Lines Matching refs:call
54 struct afs_call *call,
59 bool inline_error = (call->operation_ID == afs_FS_InlineBulkStatus);
127 afs_protocol_error(call, afs_eproto_bad_status);
131 static time64_t xdr_decode_expiry(struct afs_call *call, u32 expiry)
133 return ktime_divns(call->issue_time, NSEC_PER_SEC) + expiry;
137 struct afs_call *call,
144 cb->expires_at = xdr_decode_expiry(call, ntohl(*bp++));
237 static int afs_deliver_fs_fetch_status(struct afs_call *call)
239 struct afs_operation *op = call->op;
244 ret = afs_transfer_reply(call);
249 bp = call->buffer;
250 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
251 xdr_decode_AFSCallBack(&bp, call, &vp->scb);
274 struct afs_call *call;
280 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchStatus,
282 if (!call)
286 bp = call->request;
292 trace_afs_make_fs_call(call, &vp->fid);
293 afs_make_op_call(op, call, GFP_NOFS);
299 static int afs_deliver_fs_fetch_data(struct afs_call *call)
301 struct afs_operation *op = call->op;
309 call->unmarshall, iov_iter_count(call->iter), req->actual_len);
311 switch (call->unmarshall) {
316 call->unmarshall++;
317 if (call->operation_ID == FSFETCHDATA64) {
318 afs_extract_to_tmp64(call);
320 call->tmp_u = htonl(0);
321 afs_extract_to_tmp(call);
328 ret = afs_extract_data(call, true);
332 req->actual_len = be64_to_cpu(call->tmp64);
338 call->unmarshall++;
346 call->bvec[0].bv_len = size;
347 call->bvec[0].bv_offset = req->offset;
348 call->bvec[0].bv_page = req->pages[req->index];
349 iov_iter_bvec(&call->def_iter, READ, call->bvec, 1, size);
356 iov_iter_count(call->iter), req->remain);
358 ret = afs_extract_data(call, true);
361 req->remain -= call->bvec[0].bv_len;
362 req->offset += call->bvec[0].bv_len;
376 afs_extract_discard(call, req->actual_len - req->len);
377 call->unmarshall = 3;
382 iov_iter_count(call->iter), req->actual_len - req->len);
384 ret = afs_extract_data(call, true);
389 call->unmarshall = 4;
390 afs_extract_to_buf(call, (21 + 3 + 6) * 4);
395 ret = afs_extract_data(call, false);
399 bp = call->buffer;
400 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
401 xdr_decode_AFSCallBack(&bp, call, &vp->scb);
407 call->unmarshall++;
452 struct afs_call *call;
457 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchData64, 32, (21 + 3 + 6) * 4);
458 if (!call)
462 bp = call->request;
472 trace_afs_make_fs_call(call, &vp->fid);
473 afs_make_op_call(op, call, GFP_NOFS);
482 struct afs_call *call;
493 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchData, 24, (21 + 3 + 6) * 4);
494 if (!call)
498 bp = call->request;
506 trace_afs_make_fs_call(call, &vp->fid);
507 afs_make_op_call(op, call, GFP_NOFS);
513 static int afs_deliver_fs_create_vnode(struct afs_call *call)
515 struct afs_operation *op = call->op;
521 ret = afs_transfer_reply(call);
526 bp = call->buffer;
528 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
529 xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
530 xdr_decode_AFSCallBack(&bp, call, &vp->scb);
554 struct afs_call *call;
564 call = afs_alloc_flat_call(op->net, &afs_RXFSCreateFile,
566 if (!call)
570 bp = call->request;
589 trace_afs_make_fs_call1(call, &dvp->fid, name);
590 afs_make_op_call(op, call, GFP_NOFS);
607 struct afs_call *call;
617 call = afs_alloc_flat_call(op->net, &afs_RXFSMakeDir,
619 if (!call)
623 bp = call->request;
642 trace_afs_make_fs_call1(call, &dvp->fid, name);
643 afs_make_op_call(op, call, GFP_NOFS);
649 static int afs_deliver_fs_file_status_and_vol(struct afs_call *call)
651 struct afs_operation *op = call->op;
656 ret = afs_transfer_reply(call);
661 bp = call->buffer;
662 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
686 struct afs_call *call;
696 call = afs_alloc_flat_call(op->net, &afs_RXFSRemoveFile,
698 if (!call)
702 bp = call->request;
715 trace_afs_make_fs_call1(call, &dvp->fid, name);
716 afs_make_op_call(op, call, GFP_NOFS);
733 struct afs_call *call;
743 call = afs_alloc_flat_call(op->net, &afs_RXFSRemoveDir,
745 if (!call)
749 bp = call->request;
762 trace_afs_make_fs_call1(call, &dvp->fid, name);
763 afs_make_op_call(op, call, GFP_NOFS);
769 static int afs_deliver_fs_link(struct afs_call *call)
771 struct afs_operation *op = call->op;
777 _enter("{%u}", call->unmarshall);
779 ret = afs_transfer_reply(call);
784 bp = call->buffer;
785 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
786 xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
811 struct afs_call *call;
821 call = afs_alloc_flat_call(op->net, &afs_RXFSLink, reqsz, (21 + 21 + 6) * 4);
822 if (!call)
826 bp = call->request;
842 trace_afs_make_fs_call1(call, &vp->fid, name);
843 afs_make_op_call(op, call, GFP_NOFS);
849 static int afs_deliver_fs_symlink(struct afs_call *call)
851 struct afs_operation *op = call->op;
857 _enter("{%u}", call->unmarshall);
859 ret = afs_transfer_reply(call);
864 bp = call->buffer;
866 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
867 xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
891 struct afs_call *call;
905 call = afs_alloc_flat_call(op->net, &afs_RXFSSymlink, reqsz,
907 if (!call)
911 bp = call->request;
937 trace_afs_make_fs_call1(call, &dvp->fid, name);
938 afs_make_op_call(op, call, GFP_NOFS);
944 static int afs_deliver_fs_rename(struct afs_call *call)
946 struct afs_operation *op = call->op;
952 ret = afs_transfer_reply(call);
956 bp = call->buffer;
960 xdr_decode_AFSFetchStatus(&bp, call, &orig_dvp->scb);
961 xdr_decode_AFSFetchStatus(&bp, call, &new_dvp->scb);
987 struct afs_call *call;
1004 call = afs_alloc_flat_call(op->net, &afs_RXFSRename, reqsz, (21 + 21 + 6) * 4);
1005 if (!call)
1009 bp = call->request;
1033 trace_afs_make_fs_call2(call, &orig_dvp->fid, orig_name, new_name);
1034 afs_make_op_call(op, call, GFP_NOFS);
1040 static int afs_deliver_fs_store_data(struct afs_call *call)
1042 struct afs_operation *op = call->op;
1049 ret = afs_transfer_reply(call);
1054 bp = call->buffer;
1055 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
1086 struct afs_call *call;
1092 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData64,
1095 if (!call)
1098 call->send_pages = true;
1101 bp = call->request;
1121 trace_afs_make_fs_call(call, &vp->fid);
1122 afs_make_op_call(op, call, GFP_NOFS);
1131 struct afs_call *call;
1156 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData,
1159 if (!call)
1162 call->send_pages = true;
1165 bp = call->request;
1182 trace_afs_make_fs_call(call, &vp->fid);
1183 afs_make_op_call(op, call, GFP_NOFS);
1217 struct afs_call *call;
1226 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData64_as_Status,
1229 if (!call)
1233 bp = call->request;
1248 trace_afs_make_fs_call(call, &vp->fid);
1249 afs_make_op_call(op, call, GFP_NOFS);
1259 struct afs_call *call;
1270 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData_as_Status,
1273 if (!call)
1277 bp = call->request;
1289 trace_afs_make_fs_call(call, &vp->fid);
1290 afs_make_op_call(op, call, GFP_NOFS);
1300 struct afs_call *call;
1310 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreStatus,
1313 if (!call)
1317 bp = call->request;
1325 trace_afs_make_fs_call(call, &vp->fid);
1326 afs_make_op_call(op, call, GFP_NOFS);
1332 static int afs_deliver_fs_get_volume_status(struct afs_call *call)
1334 struct afs_operation *op = call->op;
1340 _enter("{%u}", call->unmarshall);
1342 switch (call->unmarshall) {
1344 call->unmarshall++;
1345 afs_extract_to_buf(call, 12 * 4);
1351 ret = afs_extract_data(call, true);
1355 bp = call->buffer;
1357 call->unmarshall++;
1358 afs_extract_to_tmp(call);
1363 ret = afs_extract_data(call, true);
1367 call->count = ntohl(call->tmp);
1368 _debug("volname length: %u", call->count);
1369 if (call->count >= AFSNAMEMAX)
1370 return afs_protocol_error(call, afs_eproto_volname_len);
1371 size = (call->count + 3) & ~3; /* It's padded */
1372 afs_extract_to_buf(call, size);
1373 call->unmarshall++;
1379 ret = afs_extract_data(call, true);
1383 p = call->buffer;
1384 p[call->count] = 0;
1386 afs_extract_to_tmp(call);
1387 call->unmarshall++;
1392 ret = afs_extract_data(call, true);
1396 call->count = ntohl(call->tmp);
1397 _debug("offline msg length: %u", call->count);
1398 if (call->count >= AFSNAMEMAX)
1399 return afs_protocol_error(call, afs_eproto_offline_msg_len);
1400 size = (call->count + 3) & ~3; /* It's padded */
1401 afs_extract_to_buf(call, size);
1402 call->unmarshall++;
1408 ret = afs_extract_data(call, true);
1412 p = call->buffer;
1413 p[call->count] = 0;
1416 afs_extract_to_tmp(call);
1417 call->unmarshall++;
1422 ret = afs_extract_data(call, true);
1426 call->count = ntohl(call->tmp);
1427 _debug("motd length: %u", call->count);
1428 if (call->count >= AFSNAMEMAX)
1429 return afs_protocol_error(call, afs_eproto_motd_len);
1430 size = (call->count + 3) & ~3; /* It's padded */
1431 afs_extract_to_buf(call, size);
1432 call->unmarshall++;
1438 ret = afs_extract_data(call, false);
1442 p = call->buffer;
1443 p[call->count] = 0;
1446 call->unmarshall++;
1472 struct afs_call *call;
1477 call = afs_alloc_flat_call(op->net, &afs_RXFSGetVolumeStatus, 2 * 4,
1479 if (!call)
1483 bp = call->request;
1487 trace_afs_make_fs_call(call, &vp->fid);
1488 afs_make_op_call(op, call, GFP_NOFS);
1494 static int afs_deliver_fs_xxxx_lock(struct afs_call *call)
1496 struct afs_operation *op = call->op;
1500 _enter("{%u}", call->unmarshall);
1502 ret = afs_transfer_reply(call);
1507 bp = call->buffer;
1552 struct afs_call *call;
1557 call = afs_alloc_flat_call(op->net, &afs_RXFSSetLock, 5 * 4, 6 * 4);
1558 if (!call)
1562 bp = call->request;
1569 trace_afs_make_fs_calli(call, &vp->fid, op->lock.type);
1570 afs_make_op_call(op, call, GFP_NOFS);
1579 struct afs_call *call;
1584 call = afs_alloc_flat_call(op->net, &afs_RXFSExtendLock, 4 * 4, 6 * 4);
1585 if (!call)
1589 bp = call->request;
1595 trace_afs_make_fs_call(call, &vp->fid);
1596 afs_make_op_call(op, call, GFP_NOFS);
1605 struct afs_call *call;
1610 call = afs_alloc_flat_call(op->net, &afs_RXFSReleaseLock, 4 * 4, 6 * 4);
1611 if (!call)
1615 bp = call->request;
1621 trace_afs_make_fs_call(call, &vp->fid);
1622 afs_make_op_call(op, call, GFP_NOFS);
1628 static int afs_deliver_fs_give_up_all_callbacks(struct afs_call *call)
1630 return afs_transfer_reply(call);
1651 struct afs_call *call;
1656 call = afs_alloc_flat_call(net, &afs_RXFSGiveUpAllCallBacks, 1 * 4, 0);
1657 if (!call)
1660 call->key = key;
1663 bp = call->request;
1666 call->server = afs_use_server(server, afs_server_trace_give_up_cb);
1667 afs_make_call(ac, call, GFP_NOFS);
1668 return afs_wait_for_call_to_complete(call, ac);
1674 static int afs_deliver_fs_get_capabilities(struct afs_call *call)
1679 _enter("{%u,%zu}", call->unmarshall, iov_iter_count(call->iter));
1681 switch (call->unmarshall) {
1683 afs_extract_to_tmp(call);
1684 call->unmarshall++;
1689 ret = afs_extract_data(call, true);
1693 count = ntohl(call->tmp);
1695 call->count = count;
1696 call->count2 = count;
1697 afs_extract_discard(call, count * sizeof(__be32));
1698 call->unmarshall++;
1703 ret = afs_extract_data(call, false);
1709 call->unmarshall++;
1731 * to allocate a call, true is returned the result is delivered through the
1737 struct afs_call *call;
1742 call = afs_alloc_flat_call(net, &afs_RXFSGetCapabilities, 1 * 4, 16 * 4);
1743 if (!call)
1746 call->key = key;
1747 call->server = afs_use_server(server, afs_server_trace_get_caps);
1748 call->upgrade = true;
1749 call->async = true;
1750 call->max_lifespan = AFS_PROBE_MAX_LIFESPAN;
1753 bp = call->request;
1756 trace_afs_make_fs_call(call, NULL);
1757 afs_make_call(ac, call, GFP_NOFS);
1758 afs_put_call(call);
1763 * Deliver reply data to an FS.InlineBulkStatus call
1765 static int afs_deliver_fs_inline_bulk_status(struct afs_call *call)
1767 struct afs_operation *op = call->op;
1773 _enter("{%u}", call->unmarshall);
1775 switch (call->unmarshall) {
1777 afs_extract_to_tmp(call);
1778 call->unmarshall++;
1784 ret = afs_extract_data(call, true);
1788 tmp = ntohl(call->tmp);
1791 return afs_protocol_error(call, afs_eproto_ibulkst_count);
1793 call->count = 0;
1794 call->unmarshall++;
1796 afs_extract_to_buf(call, 21 * sizeof(__be32));
1800 _debug("extract status array %u", call->count);
1801 ret = afs_extract_data(call, true);
1805 switch (call->count) {
1813 scb = &op->more_files[call->count - 2].scb;
1817 bp = call->buffer;
1818 xdr_decode_AFSFetchStatus(&bp, call, scb);
1820 call->count++;
1821 if (call->count < op->nr_files)
1824 call->count = 0;
1825 call->unmarshall++;
1826 afs_extract_to_tmp(call);
1832 ret = afs_extract_data(call, true);
1836 tmp = ntohl(call->tmp);
1839 return afs_protocol_error(call, afs_eproto_ibulkst_cb_count);
1840 call->count = 0;
1841 call->unmarshall++;
1843 afs_extract_to_buf(call, 3 * sizeof(__be32));
1848 ret = afs_extract_data(call, true);
1853 switch (call->count) {
1861 scb = &op->more_files[call->count - 2].scb;
1865 bp = call->buffer;
1866 xdr_decode_AFSCallBack(&bp, call, scb);
1867 call->count++;
1868 if (call->count < op->nr_files)
1871 afs_extract_to_buf(call, 6 * sizeof(__be32));
1872 call->unmarshall++;
1876 ret = afs_extract_data(call, false);
1880 bp = call->buffer;
1883 call->unmarshall++;
1893 static void afs_done_fs_inline_bulk_status(struct afs_call *call)
1895 if (call->error == -ECONNABORTED &&
1896 call->abort_code == RX_INVALID_OPERATION) {
1897 set_bit(AFS_SERVER_FL_NO_IBULK, &call->server->flags);
1898 if (call->op)
1899 set_bit(AFS_VOLUME_MAYBE_NO_IBULK, &call->op->volume->flags);
1921 struct afs_call *call;
1933 call = afs_alloc_flat_call(op->net, &afs_RXFSInlineBulkStatus,
1936 if (!call)
1940 bp = call->request;
1955 trace_afs_make_fs_call(call, &vp->fid);
1956 afs_make_op_call(op, call, GFP_NOFS);
1962 static int afs_deliver_fs_fetch_acl(struct afs_call *call)
1964 struct afs_operation *op = call->op;
1971 _enter("{%u}", call->unmarshall);
1973 switch (call->unmarshall) {
1975 afs_extract_to_tmp(call);
1976 call->unmarshall++;
1981 ret = afs_extract_data(call, true);
1985 size = call->count2 = ntohl(call->tmp);
1992 acl->size = call->count2;
1993 afs_extract_begin(call, acl->data, size);
1994 call->unmarshall++;
1999 ret = afs_extract_data(call, true);
2003 afs_extract_to_buf(call, (21 + 6) * 4);
2004 call->unmarshall++;
2009 ret = afs_extract_data(call, false);
2013 bp = call->buffer;
2014 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
2017 call->unmarshall++;
2042 struct afs_call *call;
2048 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchACL, 16, (21 + 6) * 4);
2049 if (!call)
2053 bp = call->request;
2059 trace_afs_make_fs_call(call, &vp->fid);
2060 afs_make_op_call(op, call, GFP_KERNEL);
2079 struct afs_call *call;
2088 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreACL,
2090 if (!call)
2094 bp = call->request;
2104 trace_afs_make_fs_call(call, &vp->fid);
2105 afs_make_op_call(op, call, GFP_KERNEL);