Lines Matching refs:call
55 struct afs_call *call,
60 bool inline_error = (call->operation_ID == afs_FS_InlineBulkStatus);
128 afs_protocol_error(call, afs_eproto_bad_status);
132 static time64_t xdr_decode_expiry(struct afs_call *call, u32 expiry)
134 return ktime_divns(call->issue_time, NSEC_PER_SEC) + expiry;
138 struct afs_call *call,
145 cb->expires_at = xdr_decode_expiry(call, ntohl(*bp++));
238 static int afs_deliver_fs_fetch_status(struct afs_call *call)
240 struct afs_operation *op = call->op;
245 ret = afs_transfer_reply(call);
250 bp = call->buffer;
251 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
252 xdr_decode_AFSCallBack(&bp, call, &vp->scb);
275 struct afs_call *call;
281 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchStatus,
283 if (!call)
287 bp = call->request;
293 call->fid = vp->fid;
294 trace_afs_make_fs_call(call, &vp->fid);
295 afs_make_op_call(op, call, GFP_NOFS);
301 static int afs_deliver_fs_fetch_data(struct afs_call *call)
303 struct afs_operation *op = call->op;
310 call->unmarshall, call->iov_len, iov_iter_count(call->iter),
313 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);
331 ret = afs_extract_data(call, true);
335 req->actual_len = be64_to_cpu(call->tmp64);
341 call->iter = req->iter;
342 call->iov_len = min(req->actual_len, req->len);
343 call->unmarshall++;
349 iov_iter_count(call->iter), req->actual_len);
351 ret = afs_extract_data(call, true);
355 call->iter = &call->def_iter;
360 afs_extract_discard(call, req->actual_len - req->len);
361 call->unmarshall = 3;
366 iov_iter_count(call->iter), req->actual_len - req->len);
368 ret = afs_extract_data(call, true);
373 call->unmarshall = 4;
374 afs_extract_to_buf(call, (21 + 3 + 6) * 4);
379 ret = afs_extract_data(call, false);
383 bp = call->buffer;
384 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
385 xdr_decode_AFSCallBack(&bp, call, &vp->scb);
391 call->unmarshall++;
426 struct afs_call *call;
431 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchData64, 32, (21 + 3 + 6) * 4);
432 if (!call)
436 bp = call->request;
446 call->fid = vp->fid;
447 trace_afs_make_fs_call(call, &vp->fid);
448 afs_make_op_call(op, call, GFP_NOFS);
457 struct afs_call *call;
466 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchData, 24, (21 + 3 + 6) * 4);
467 if (!call)
470 req->call_debug_id = call->debug_id;
473 bp = call->request;
481 call->fid = vp->fid;
482 trace_afs_make_fs_call(call, &vp->fid);
483 afs_make_op_call(op, call, GFP_NOFS);
489 static int afs_deliver_fs_create_vnode(struct afs_call *call)
491 struct afs_operation *op = call->op;
497 ret = afs_transfer_reply(call);
502 bp = call->buffer;
504 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
505 xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
506 xdr_decode_AFSCallBack(&bp, call, &vp->scb);
530 struct afs_call *call;
540 call = afs_alloc_flat_call(op->net, &afs_RXFSCreateFile,
542 if (!call)
546 bp = call->request;
565 call->fid = dvp->fid;
566 trace_afs_make_fs_call1(call, &dvp->fid, name);
567 afs_make_op_call(op, call, GFP_NOFS);
584 struct afs_call *call;
594 call = afs_alloc_flat_call(op->net, &afs_RXFSMakeDir,
596 if (!call)
600 bp = call->request;
619 call->fid = dvp->fid;
620 trace_afs_make_fs_call1(call, &dvp->fid, name);
621 afs_make_op_call(op, call, GFP_NOFS);
627 static int afs_deliver_fs_file_status_and_vol(struct afs_call *call)
629 struct afs_operation *op = call->op;
634 ret = afs_transfer_reply(call);
639 bp = call->buffer;
640 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
664 struct afs_call *call;
674 call = afs_alloc_flat_call(op->net, &afs_RXFSRemoveFile,
676 if (!call)
680 bp = call->request;
693 call->fid = dvp->fid;
694 trace_afs_make_fs_call1(call, &dvp->fid, name);
695 afs_make_op_call(op, call, GFP_NOFS);
712 struct afs_call *call;
722 call = afs_alloc_flat_call(op->net, &afs_RXFSRemoveDir,
724 if (!call)
728 bp = call->request;
741 call->fid = dvp->fid;
742 trace_afs_make_fs_call1(call, &dvp->fid, name);
743 afs_make_op_call(op, call, GFP_NOFS);
749 static int afs_deliver_fs_link(struct afs_call *call)
751 struct afs_operation *op = call->op;
757 _enter("{%u}", call->unmarshall);
759 ret = afs_transfer_reply(call);
764 bp = call->buffer;
765 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
766 xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
791 struct afs_call *call;
801 call = afs_alloc_flat_call(op->net, &afs_RXFSLink, reqsz, (21 + 21 + 6) * 4);
802 if (!call)
806 bp = call->request;
822 call->fid = vp->fid;
823 trace_afs_make_fs_call1(call, &vp->fid, name);
824 afs_make_op_call(op, call, GFP_NOFS);
830 static int afs_deliver_fs_symlink(struct afs_call *call)
832 struct afs_operation *op = call->op;
838 _enter("{%u}", call->unmarshall);
840 ret = afs_transfer_reply(call);
845 bp = call->buffer;
847 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
848 xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
872 struct afs_call *call;
886 call = afs_alloc_flat_call(op->net, &afs_RXFSSymlink, reqsz,
888 if (!call)
892 bp = call->request;
918 call->fid = dvp->fid;
919 trace_afs_make_fs_call1(call, &dvp->fid, name);
920 afs_make_op_call(op, call, GFP_NOFS);
926 static int afs_deliver_fs_rename(struct afs_call *call)
928 struct afs_operation *op = call->op;
934 ret = afs_transfer_reply(call);
938 bp = call->buffer;
942 xdr_decode_AFSFetchStatus(&bp, call, &orig_dvp->scb);
943 xdr_decode_AFSFetchStatus(&bp, call, &new_dvp->scb);
969 struct afs_call *call;
986 call = afs_alloc_flat_call(op->net, &afs_RXFSRename, reqsz, (21 + 21 + 6) * 4);
987 if (!call)
991 bp = call->request;
1015 call->fid = orig_dvp->fid;
1016 trace_afs_make_fs_call2(call, &orig_dvp->fid, orig_name, new_name);
1017 afs_make_op_call(op, call, GFP_NOFS);
1023 static int afs_deliver_fs_store_data(struct afs_call *call)
1025 struct afs_operation *op = call->op;
1032 ret = afs_transfer_reply(call);
1037 bp = call->buffer;
1038 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
1068 struct afs_call *call;
1074 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData64,
1077 if (!call)
1080 call->write_iter = op->store.write_iter;
1083 bp = call->request;
1103 call->fid = vp->fid;
1104 trace_afs_make_fs_call(call, &vp->fid);
1105 afs_make_op_call(op, call, GFP_NOFS);
1114 struct afs_call *call;
1128 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData,
1131 if (!call)
1134 call->write_iter = op->store.write_iter;
1137 bp = call->request;
1154 call->fid = vp->fid;
1155 trace_afs_make_fs_call(call, &vp->fid);
1156 afs_make_op_call(op, call, GFP_NOFS);
1190 struct afs_call *call;
1199 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData64_as_Status,
1202 if (!call)
1206 bp = call->request;
1221 call->fid = vp->fid;
1222 trace_afs_make_fs_call(call, &vp->fid);
1223 afs_make_op_call(op, call, GFP_NOFS);
1233 struct afs_call *call;
1244 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData_as_Status,
1247 if (!call)
1251 bp = call->request;
1263 call->fid = vp->fid;
1264 trace_afs_make_fs_call(call, &vp->fid);
1265 afs_make_op_call(op, call, GFP_NOFS);
1275 struct afs_call *call;
1285 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreStatus,
1288 if (!call)
1292 bp = call->request;
1300 call->fid = vp->fid;
1301 trace_afs_make_fs_call(call, &vp->fid);
1302 afs_make_op_call(op, call, GFP_NOFS);
1308 static int afs_deliver_fs_get_volume_status(struct afs_call *call)
1310 struct afs_operation *op = call->op;
1316 _enter("{%u}", call->unmarshall);
1318 switch (call->unmarshall) {
1320 call->unmarshall++;
1321 afs_extract_to_buf(call, 12 * 4);
1327 ret = afs_extract_data(call, true);
1331 bp = call->buffer;
1333 call->unmarshall++;
1334 afs_extract_to_tmp(call);
1339 ret = afs_extract_data(call, true);
1343 call->count = ntohl(call->tmp);
1344 _debug("volname length: %u", call->count);
1345 if (call->count >= AFSNAMEMAX)
1346 return afs_protocol_error(call, afs_eproto_volname_len);
1347 size = (call->count + 3) & ~3; /* It's padded */
1348 afs_extract_to_buf(call, size);
1349 call->unmarshall++;
1355 ret = afs_extract_data(call, true);
1359 p = call->buffer;
1360 p[call->count] = 0;
1362 afs_extract_to_tmp(call);
1363 call->unmarshall++;
1368 ret = afs_extract_data(call, true);
1372 call->count = ntohl(call->tmp);
1373 _debug("offline msg length: %u", call->count);
1374 if (call->count >= AFSNAMEMAX)
1375 return afs_protocol_error(call, afs_eproto_offline_msg_len);
1376 size = (call->count + 3) & ~3; /* It's padded */
1377 afs_extract_to_buf(call, size);
1378 call->unmarshall++;
1384 ret = afs_extract_data(call, true);
1388 p = call->buffer;
1389 p[call->count] = 0;
1392 afs_extract_to_tmp(call);
1393 call->unmarshall++;
1398 ret = afs_extract_data(call, true);
1402 call->count = ntohl(call->tmp);
1403 _debug("motd length: %u", call->count);
1404 if (call->count >= AFSNAMEMAX)
1405 return afs_protocol_error(call, afs_eproto_motd_len);
1406 size = (call->count + 3) & ~3; /* It's padded */
1407 afs_extract_to_buf(call, size);
1408 call->unmarshall++;
1414 ret = afs_extract_data(call, false);
1418 p = call->buffer;
1419 p[call->count] = 0;
1422 call->unmarshall++;
1449 struct afs_call *call;
1454 call = afs_alloc_flat_call(op->net, &afs_RXFSGetVolumeStatus, 2 * 4,
1456 if (!call)
1460 bp = call->request;
1464 call->fid = vp->fid;
1465 trace_afs_make_fs_call(call, &vp->fid);
1466 afs_make_op_call(op, call, GFP_NOFS);
1472 static int afs_deliver_fs_xxxx_lock(struct afs_call *call)
1474 struct afs_operation *op = call->op;
1478 _enter("{%u}", call->unmarshall);
1480 ret = afs_transfer_reply(call);
1485 bp = call->buffer;
1530 struct afs_call *call;
1535 call = afs_alloc_flat_call(op->net, &afs_RXFSSetLock, 5 * 4, 6 * 4);
1536 if (!call)
1540 bp = call->request;
1547 call->fid = vp->fid;
1548 trace_afs_make_fs_calli(call, &vp->fid, op->lock.type);
1549 afs_make_op_call(op, call, GFP_NOFS);
1558 struct afs_call *call;
1563 call = afs_alloc_flat_call(op->net, &afs_RXFSExtendLock, 4 * 4, 6 * 4);
1564 if (!call)
1568 bp = call->request;
1574 call->fid = vp->fid;
1575 trace_afs_make_fs_call(call, &vp->fid);
1576 afs_make_op_call(op, call, GFP_NOFS);
1585 struct afs_call *call;
1590 call = afs_alloc_flat_call(op->net, &afs_RXFSReleaseLock, 4 * 4, 6 * 4);
1591 if (!call)
1595 bp = call->request;
1601 call->fid = vp->fid;
1602 trace_afs_make_fs_call(call, &vp->fid);
1603 afs_make_op_call(op, call, GFP_NOFS);
1609 static int afs_deliver_fs_give_up_all_callbacks(struct afs_call *call)
1611 return afs_transfer_reply(call);
1630 struct afs_call *call;
1636 call = afs_alloc_flat_call(net, &afs_RXFSGiveUpAllCallBacks, 1 * 4, 0);
1637 if (!call)
1640 call->key = key;
1641 call->peer = rxrpc_kernel_get_peer(addr->peer);
1642 call->service_id = server->service_id;
1645 bp = call->request;
1648 call->server = afs_use_server(server, afs_server_trace_give_up_cb);
1649 afs_make_call(call, GFP_NOFS);
1650 afs_wait_for_call_to_complete(call);
1651 ret = call->error;
1652 if (call->responded)
1654 afs_put_call(call);
1661 static int afs_deliver_fs_get_capabilities(struct afs_call *call)
1666 _enter("{%u,%zu}", call->unmarshall, iov_iter_count(call->iter));
1668 switch (call->unmarshall) {
1670 afs_extract_to_tmp(call);
1671 call->unmarshall++;
1676 ret = afs_extract_data(call, true);
1680 count = ntohl(call->tmp);
1681 call->count = count;
1682 call->count2 = count;
1684 call->unmarshall = 4;
1685 call->tmp = 0;
1689 /* Extract the first word of the capabilities to call->tmp */
1690 afs_extract_to_tmp(call);
1691 call->unmarshall++;
1695 ret = afs_extract_data(call, false);
1699 afs_extract_discard(call, (count - 1) * sizeof(__be32));
1700 call->unmarshall++;
1705 ret = afs_extract_data(call, false);
1709 call->unmarshall++;
1717 static void afs_fs_get_capabilities_destructor(struct afs_call *call)
1719 afs_put_endpoint_state(call->probe, afs_estate_trace_put_getcaps);
1720 afs_flat_call_destructor(call);
1737 * to allocate a call, true is returned the result is delivered through the
1744 struct afs_call *call;
1749 call = afs_alloc_flat_call(net, &afs_RXFSGetCapabilities, 1 * 4, 16 * 4);
1750 if (!call)
1753 call->key = key;
1754 call->server = afs_use_server(server, afs_server_trace_get_caps);
1755 call->peer = rxrpc_kernel_get_peer(estate->addresses->addrs[addr_index].peer);
1756 call->probe = afs_get_endpoint_state(estate, afs_estate_trace_get_getcaps);
1757 call->probe_index = addr_index;
1758 call->service_id = server->service_id;
1759 call->upgrade = true;
1760 call->async = true;
1761 call->max_lifespan = AFS_PROBE_MAX_LIFESPAN;
1764 bp = call->request;
1767 trace_afs_make_fs_call(call, NULL);
1768 afs_make_call(call, GFP_NOFS);
1769 afs_put_call(call);
1774 * Deliver reply data to an FS.InlineBulkStatus call
1776 static int afs_deliver_fs_inline_bulk_status(struct afs_call *call)
1778 struct afs_operation *op = call->op;
1784 _enter("{%u}", call->unmarshall);
1786 switch (call->unmarshall) {
1788 afs_extract_to_tmp(call);
1789 call->unmarshall++;
1795 ret = afs_extract_data(call, true);
1799 tmp = ntohl(call->tmp);
1802 return afs_protocol_error(call, afs_eproto_ibulkst_count);
1804 call->count = 0;
1805 call->unmarshall++;
1807 afs_extract_to_buf(call, 21 * sizeof(__be32));
1811 _debug("extract status array %u", call->count);
1812 ret = afs_extract_data(call, true);
1816 switch (call->count) {
1824 scb = &op->more_files[call->count - 2].scb;
1828 bp = call->buffer;
1829 xdr_decode_AFSFetchStatus(&bp, call, scb);
1831 call->count++;
1832 if (call->count < op->nr_files)
1835 call->count = 0;
1836 call->unmarshall++;
1837 afs_extract_to_tmp(call);
1843 ret = afs_extract_data(call, true);
1847 tmp = ntohl(call->tmp);
1850 return afs_protocol_error(call, afs_eproto_ibulkst_cb_count);
1851 call->count = 0;
1852 call->unmarshall++;
1854 afs_extract_to_buf(call, 3 * sizeof(__be32));
1859 ret = afs_extract_data(call, true);
1864 switch (call->count) {
1872 scb = &op->more_files[call->count - 2].scb;
1876 bp = call->buffer;
1877 xdr_decode_AFSCallBack(&bp, call, scb);
1878 call->count++;
1879 if (call->count < op->nr_files)
1882 afs_extract_to_buf(call, 6 * sizeof(__be32));
1883 call->unmarshall++;
1887 ret = afs_extract_data(call, false);
1891 bp = call->buffer;
1897 call->unmarshall++;
1908 static void afs_done_fs_inline_bulk_status(struct afs_call *call)
1910 if (call->error == -ECONNABORTED &&
1911 call->abort_code == RX_INVALID_OPERATION) {
1912 set_bit(AFS_SERVER_FL_NO_IBULK, &call->server->flags);
1913 if (call->op)
1914 set_bit(AFS_VOLUME_MAYBE_NO_IBULK, &call->op->volume->flags);
1936 struct afs_call *call;
1948 call = afs_alloc_flat_call(op->net, &afs_RXFSInlineBulkStatus,
1951 if (!call)
1955 bp = call->request;
1970 call->fid = vp->fid;
1971 trace_afs_make_fs_call(call, &vp->fid);
1972 afs_make_op_call(op, call, GFP_NOFS);
1978 static int afs_deliver_fs_fetch_acl(struct afs_call *call)
1980 struct afs_operation *op = call->op;
1987 _enter("{%u}", call->unmarshall);
1989 switch (call->unmarshall) {
1991 afs_extract_to_tmp(call);
1992 call->unmarshall++;
1997 ret = afs_extract_data(call, true);
2001 size = call->count2 = ntohl(call->tmp);
2008 acl->size = call->count2;
2009 afs_extract_begin(call, acl->data, size);
2010 call->unmarshall++;
2015 ret = afs_extract_data(call, true);
2019 afs_extract_to_buf(call, (21 + 6) * 4);
2020 call->unmarshall++;
2025 ret = afs_extract_data(call, false);
2029 bp = call->buffer;
2030 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
2033 call->unmarshall++;
2059 struct afs_call *call;
2065 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchACL, 16, (21 + 6) * 4);
2066 if (!call)
2070 bp = call->request;
2076 call->fid = vp->fid;
2077 trace_afs_make_fs_call(call, &vp->fid);
2078 afs_make_op_call(op, call, GFP_KERNEL);
2097 struct afs_call *call;
2106 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreACL,
2108 if (!call)
2112 bp = call->request;
2122 call->fid = vp->fid;
2123 trace_afs_make_fs_call(call, &vp->fid);
2124 afs_make_op_call(op, call, GFP_KERNEL);