Lines Matching refs:call
138 static void yfs_check_req(struct afs_call *call, __be32 *bp)
140 size_t len = (void *)bp - call->request;
142 if (len > call->request_size)
144 call->type->name, len, call->request_size);
145 else if (len < call->request_size)
147 call->type->name, len, call->request_size);
174 struct afs_call *call,
220 afs_protocol_error(call, afs_eproto_bad_status);
228 struct afs_call *call,
235 cb_expiry = ktime_add(call->issue_time, xdr_to_u64(x->expiration_time) * 100);
328 static int yfs_deliver_status_and_volsync(struct afs_call *call)
330 struct afs_operation *op = call->op;
334 ret = afs_transfer_reply(call);
338 bp = call->buffer;
339 xdr_decode_YFSFetchStatus(&bp, call, &op->file[0].scb);
349 static int yfs_deliver_fs_fetch_data64(struct afs_call *call)
351 struct afs_operation *op = call->op;
358 call->unmarshall, call->iov_len, iov_iter_count(call->iter),
361 switch (call->unmarshall) {
364 afs_extract_to_tmp64(call);
365 call->unmarshall++;
374 ret = afs_extract_data(call, true);
378 req->actual_len = be64_to_cpu(call->tmp64);
384 call->iter = req->iter;
385 call->iov_len = min(req->actual_len, req->len);
386 call->unmarshall++;
392 iov_iter_count(call->iter), req->actual_len);
394 ret = afs_extract_data(call, true);
398 call->iter = &call->def_iter;
403 afs_extract_discard(call, req->actual_len - req->len);
404 call->unmarshall = 3;
409 iov_iter_count(call->iter), req->actual_len - req->len);
411 ret = afs_extract_data(call, true);
416 call->unmarshall = 4;
417 afs_extract_to_buf(call,
425 ret = afs_extract_data(call, false);
429 bp = call->buffer;
430 xdr_decode_YFSFetchStatus(&bp, call, &vp->scb);
431 xdr_decode_YFSCallBack(&bp, call, &vp->scb);
437 call->unmarshall++;
465 struct afs_call *call;
472 call = afs_alloc_flat_call(op->net, &yfs_RXYFSFetchData64,
479 if (!call)
482 req->call_debug_id = call->debug_id;
485 bp = call->request;
491 yfs_check_req(call, bp);
493 trace_afs_make_fs_call(call, &vp->fid);
494 afs_make_op_call(op, call, GFP_NOFS);
500 static int yfs_deliver_fs_create_vnode(struct afs_call *call)
502 struct afs_operation *op = call->op;
508 _enter("{%u}", call->unmarshall);
510 ret = afs_transfer_reply(call);
515 bp = call->buffer;
517 xdr_decode_YFSFetchStatus(&bp, call, &vp->scb);
518 xdr_decode_YFSFetchStatus(&bp, call, &dvp->scb);
519 xdr_decode_YFSCallBack(&bp, call, &vp->scb);
543 struct afs_call *call;
561 call = afs_alloc_flat_call(op->net, &afs_RXFSCreateFile, reqsz, rplsz);
562 if (!call)
566 bp = call->request;
573 yfs_check_req(call, bp);
575 trace_afs_make_fs_call1(call, &dvp->fid, name);
576 afs_make_op_call(op, call, GFP_NOFS);
593 struct afs_call *call;
610 call = afs_alloc_flat_call(op->net, &yfs_RXFSMakeDir, reqsz, rplsz);
611 if (!call)
615 bp = call->request;
621 yfs_check_req(call, bp);
623 trace_afs_make_fs_call1(call, &dvp->fid, name);
624 afs_make_op_call(op, call, GFP_NOFS);
630 static int yfs_deliver_fs_remove_file2(struct afs_call *call)
632 struct afs_operation *op = call->op;
639 _enter("{%u}", call->unmarshall);
641 ret = afs_transfer_reply(call);
645 bp = call->buffer;
646 xdr_decode_YFSFetchStatus(&bp, call, &dvp->scb);
648 xdr_decode_YFSFetchStatus(&bp, call, &vp->scb);
655 static void yfs_done_fs_remove_file2(struct afs_call *call)
657 if (call->error == -ECONNABORTED &&
658 call->abort_code == RX_INVALID_OPERATION) {
659 set_bit(AFS_SERVER_FL_NO_RM2, &call->server->flags);
660 call->op->flags |= AFS_OPERATION_DOWNGRADE;
682 struct afs_call *call;
687 call = afs_alloc_flat_call(op->net, &yfs_RXYFSRemoveFile2,
696 if (!call)
700 bp = call->request;
705 yfs_check_req(call, bp);
707 trace_afs_make_fs_call1(call, &dvp->fid, name);
708 afs_make_op_call(op, call, GFP_NOFS);
714 static int yfs_deliver_fs_remove(struct afs_call *call)
716 struct afs_operation *op = call->op;
721 _enter("{%u}", call->unmarshall);
723 ret = afs_transfer_reply(call);
727 bp = call->buffer;
728 xdr_decode_YFSFetchStatus(&bp, call, &dvp->scb);
750 struct afs_call *call;
758 call = afs_alloc_flat_call(op->net, &yfs_RXYFSRemoveFile,
765 if (!call)
769 bp = call->request;
774 yfs_check_req(call, bp);
776 trace_afs_make_fs_call1(call, &dvp->fid, name);
777 afs_make_op_call(op, call, GFP_NOFS);
794 struct afs_call *call;
799 call = afs_alloc_flat_call(op->net, &yfs_RXYFSRemoveDir,
806 if (!call)
810 bp = call->request;
815 yfs_check_req(call, bp);
817 trace_afs_make_fs_call1(call, &dvp->fid, name);
818 afs_make_op_call(op, call, GFP_NOFS);
824 static int yfs_deliver_fs_link(struct afs_call *call)
826 struct afs_operation *op = call->op;
832 _enter("{%u}", call->unmarshall);
834 ret = afs_transfer_reply(call);
838 bp = call->buffer;
839 xdr_decode_YFSFetchStatus(&bp, call, &vp->scb);
840 xdr_decode_YFSFetchStatus(&bp, call, &dvp->scb);
864 struct afs_call *call;
869 call = afs_alloc_flat_call(op->net, &yfs_RXYFSLink,
878 if (!call)
882 bp = call->request;
888 yfs_check_req(call, bp);
890 trace_afs_make_fs_call1(call, &vp->fid, name);
891 afs_make_op_call(op, call, GFP_NOFS);
897 static int yfs_deliver_fs_symlink(struct afs_call *call)
899 struct afs_operation *op = call->op;
905 _enter("{%u}", call->unmarshall);
907 ret = afs_transfer_reply(call);
912 bp = call->buffer;
914 xdr_decode_YFSFetchStatus(&bp, call, &vp->scb);
915 xdr_decode_YFSFetchStatus(&bp, call, &dvp->scb);
939 struct afs_call *call;
947 call = afs_alloc_flat_call(op->net, &yfs_RXYFSSymlink,
958 if (!call)
962 bp = call->request;
969 yfs_check_req(call, bp);
971 trace_afs_make_fs_call1(call, &dvp->fid, name);
972 afs_make_op_call(op, call, GFP_NOFS);
978 static int yfs_deliver_fs_rename(struct afs_call *call)
980 struct afs_operation *op = call->op;
986 _enter("{%u}", call->unmarshall);
988 ret = afs_transfer_reply(call);
992 bp = call->buffer;
996 xdr_decode_YFSFetchStatus(&bp, call, &orig_dvp->scb);
997 xdr_decode_YFSFetchStatus(&bp, call, &new_dvp->scb);
1022 struct afs_call *call;
1027 call = afs_alloc_flat_call(op->net, &yfs_RXYFSRename,
1037 if (!call)
1041 bp = call->request;
1048 yfs_check_req(call, bp);
1050 trace_afs_make_fs_call2(call, &orig_dvp->fid, orig_name, new_name);
1051 afs_make_op_call(op, call, GFP_NOFS);
1070 struct afs_call *call;
1081 call = afs_alloc_flat_call(op->net, &yfs_RXYFSStoreData64,
1089 if (!call)
1092 call->write_iter = op->store.write_iter;
1095 bp = call->request;
1103 yfs_check_req(call, bp);
1105 trace_afs_make_fs_call(call, &vp->fid);
1106 afs_make_op_call(op, call, GFP_NOFS);
1133 struct afs_call *call;
1140 call = afs_alloc_flat_call(op->net, &yfs_RXYFSStoreData64_as_Status,
1147 if (!call)
1151 bp = call->request;
1159 yfs_check_req(call, bp);
1161 trace_afs_make_fs_call(call, &vp->fid);
1162 afs_make_op_call(op, call, GFP_NOFS);
1172 struct afs_call *call;
1182 call = afs_alloc_flat_call(op->net, &yfs_RXYFSStoreStatus,
1188 if (!call)
1192 bp = call->request;
1197 yfs_check_req(call, bp);
1199 trace_afs_make_fs_call(call, &vp->fid);
1200 afs_make_op_call(op, call, GFP_NOFS);
1206 static int yfs_deliver_fs_get_volume_status(struct afs_call *call)
1208 struct afs_operation *op = call->op;
1214 _enter("{%u}", call->unmarshall);
1216 switch (call->unmarshall) {
1218 call->unmarshall++;
1219 afs_extract_to_buf(call, sizeof(struct yfs_xdr_YFSFetchVolumeStatus));
1225 ret = afs_extract_data(call, true);
1229 bp = call->buffer;
1231 call->unmarshall++;
1232 afs_extract_to_tmp(call);
1237 ret = afs_extract_data(call, true);
1241 call->count = ntohl(call->tmp);
1242 _debug("volname length: %u", call->count);
1243 if (call->count >= AFSNAMEMAX)
1244 return afs_protocol_error(call, afs_eproto_volname_len);
1245 size = (call->count + 3) & ~3; /* It's padded */
1246 afs_extract_to_buf(call, size);
1247 call->unmarshall++;
1253 ret = afs_extract_data(call, true);
1257 p = call->buffer;
1258 p[call->count] = 0;
1260 afs_extract_to_tmp(call);
1261 call->unmarshall++;
1266 ret = afs_extract_data(call, true);
1270 call->count = ntohl(call->tmp);
1271 _debug("offline msg length: %u", call->count);
1272 if (call->count >= AFSNAMEMAX)
1273 return afs_protocol_error(call, afs_eproto_offline_msg_len);
1274 size = (call->count + 3) & ~3; /* It's padded */
1275 afs_extract_to_buf(call, size);
1276 call->unmarshall++;
1282 ret = afs_extract_data(call, true);
1286 p = call->buffer;
1287 p[call->count] = 0;
1290 afs_extract_to_tmp(call);
1291 call->unmarshall++;
1296 ret = afs_extract_data(call, true);
1300 call->count = ntohl(call->tmp);
1301 _debug("motd length: %u", call->count);
1302 if (call->count >= AFSNAMEMAX)
1303 return afs_protocol_error(call, afs_eproto_motd_len);
1304 size = (call->count + 3) & ~3; /* It's padded */
1305 afs_extract_to_buf(call, size);
1306 call->unmarshall++;
1312 ret = afs_extract_data(call, false);
1316 p = call->buffer;
1317 p[call->count] = 0;
1320 call->unmarshall++;
1347 struct afs_call *call;
1352 call = afs_alloc_flat_call(op->net, &yfs_RXYFSGetVolumeStatus,
1359 if (!call)
1363 bp = call->request;
1367 yfs_check_req(call, bp);
1369 trace_afs_make_fs_call(call, &vp->fid);
1370 afs_make_op_call(op, call, GFP_NOFS);
1411 struct afs_call *call;
1416 call = afs_alloc_flat_call(op->net, &yfs_RXYFSSetLock,
1422 if (!call)
1426 bp = call->request;
1431 yfs_check_req(call, bp);
1433 trace_afs_make_fs_calli(call, &vp->fid, op->lock.type);
1434 afs_make_op_call(op, call, GFP_NOFS);
1443 struct afs_call *call;
1448 call = afs_alloc_flat_call(op->net, &yfs_RXYFSExtendLock,
1453 if (!call)
1457 bp = call->request;
1461 yfs_check_req(call, bp);
1463 trace_afs_make_fs_call(call, &vp->fid);
1464 afs_make_op_call(op, call, GFP_NOFS);
1473 struct afs_call *call;
1478 call = afs_alloc_flat_call(op->net, &yfs_RXYFSReleaseLock,
1483 if (!call)
1487 bp = call->request;
1491 yfs_check_req(call, bp);
1493 trace_afs_make_fs_call(call, &vp->fid);
1494 afs_make_op_call(op, call, GFP_NOFS);
1500 static int yfs_deliver_fs_fetch_status(struct afs_call *call)
1502 struct afs_operation *op = call->op;
1507 ret = afs_transfer_reply(call);
1512 bp = call->buffer;
1513 xdr_decode_YFSFetchStatus(&bp, call, &vp->scb);
1514 xdr_decode_YFSCallBack(&bp, call, &vp->scb);
1537 struct afs_call *call;
1543 call = afs_alloc_flat_call(op->net, &yfs_RXYFSFetchStatus,
1549 if (!call)
1553 bp = call->request;
1557 yfs_check_req(call, bp);
1559 trace_afs_make_fs_call(call, &vp->fid);
1560 afs_make_op_call(op, call, GFP_NOFS);
1564 * Deliver reply data to an YFS.InlineBulkStatus call
1566 static int yfs_deliver_fs_inline_bulk_status(struct afs_call *call)
1568 struct afs_operation *op = call->op;
1574 _enter("{%u}", call->unmarshall);
1576 switch (call->unmarshall) {
1578 afs_extract_to_tmp(call);
1579 call->unmarshall++;
1585 ret = afs_extract_data(call, true);
1589 tmp = ntohl(call->tmp);
1592 return afs_protocol_error(call, afs_eproto_ibulkst_count);
1594 call->count = 0;
1595 call->unmarshall++;
1597 afs_extract_to_buf(call, sizeof(struct yfs_xdr_YFSFetchStatus));
1601 _debug("extract status array %u", call->count);
1602 ret = afs_extract_data(call, true);
1606 switch (call->count) {
1614 scb = &op->more_files[call->count - 2].scb;
1618 bp = call->buffer;
1619 xdr_decode_YFSFetchStatus(&bp, call, scb);
1621 call->count++;
1622 if (call->count < op->nr_files)
1625 call->count = 0;
1626 call->unmarshall++;
1627 afs_extract_to_tmp(call);
1633 ret = afs_extract_data(call, true);
1637 tmp = ntohl(call->tmp);
1640 return afs_protocol_error(call, afs_eproto_ibulkst_cb_count);
1641 call->count = 0;
1642 call->unmarshall++;
1644 afs_extract_to_buf(call, sizeof(struct yfs_xdr_YFSCallBack));
1649 ret = afs_extract_data(call, true);
1654 switch (call->count) {
1662 scb = &op->more_files[call->count - 2].scb;
1666 bp = call->buffer;
1667 xdr_decode_YFSCallBack(&bp, call, scb);
1668 call->count++;
1669 if (call->count < op->nr_files)
1672 afs_extract_to_buf(call, sizeof(struct yfs_xdr_YFSVolSync));
1673 call->unmarshall++;
1677 ret = afs_extract_data(call, false);
1681 bp = call->buffer;
1684 call->unmarshall++;
1712 struct afs_call *call;
1719 call = afs_alloc_flat_call(op->net, &yfs_RXYFSInlineBulkStatus,
1725 if (!call)
1729 bp = call->request;
1737 yfs_check_req(call, bp);
1739 trace_afs_make_fs_call(call, &vp->fid);
1740 afs_make_op_call(op, call, GFP_NOFS);
1746 static int yfs_deliver_fs_fetch_opaque_acl(struct afs_call *call)
1748 struct afs_operation *op = call->op;
1756 _enter("{%u}", call->unmarshall);
1758 switch (call->unmarshall) {
1760 afs_extract_to_tmp(call);
1761 call->unmarshall++;
1766 ret = afs_extract_data(call, true);
1770 size = call->count2 = ntohl(call->tmp);
1778 acl->size = call->count2;
1779 afs_extract_begin(call, acl->data, size);
1781 afs_extract_discard(call, size);
1783 call->unmarshall++;
1788 ret = afs_extract_data(call, true);
1792 afs_extract_to_tmp(call);
1793 call->unmarshall++;
1798 ret = afs_extract_data(call, true);
1802 size = call->count2 = ntohl(call->tmp);
1810 acl->size = call->count2;
1811 afs_extract_begin(call, acl->data, size);
1813 afs_extract_discard(call, size);
1815 call->unmarshall++;
1820 ret = afs_extract_data(call, true);
1824 afs_extract_to_buf(call,
1828 call->unmarshall++;
1833 ret = afs_extract_data(call, false);
1837 bp = call->buffer;
1840 xdr_decode_YFSFetchStatus(&bp, call, &vp->scb);
1843 call->unmarshall++;
1879 struct afs_call *call;
1885 call = afs_alloc_flat_call(op->net, &yfs_RXYFSFetchOpaqueACL,
1891 if (!call)
1895 bp = call->request;
1899 yfs_check_req(call, bp);
1901 trace_afs_make_fs_call(call, &vp->fid);
1902 afs_make_op_call(op, call, GFP_KERNEL);
1921 struct afs_call *call;
1930 call = afs_alloc_flat_call(op->net, &yfs_RXYFSStoreOpaqueACL2,
1936 if (!call)
1940 bp = call->request;
1949 yfs_check_req(call, bp);
1951 trace_afs_make_fs_call(call, &vp->fid);
1952 afs_make_op_call(op, call, GFP_KERNEL);