projects / linux-2.6-block.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
Merge tag 'pm-6.16-rc5' of git://git.kernel.org/pub/scm/linux/kernel/git/rafael/linux-pm
[linux-2.6-block.git] / fs / afs / fsclient.c
... / ...
CommitLineData
1// SPDX-License-Identifier: GPL-2.0-or-later
2/* AFS File Server client stubs
3 *
4 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
6 */
7
8#include <linux/init.h>
9#include <linux/slab.h>
10#include <linux/sched.h>
11#include <linux/circ_buf.h>
12#include <linux/iversion.h>
13#include <linux/netfs.h>
14#include "internal.h"
15#include "afs_fs.h"
16#include "xdr_fs.h"
17
18/*
19 * decode an AFSFid block
20 */
21static void xdr_decode_AFSFid(const __be32 **_bp, struct afs_fid *fid)
22{
23 const __be32 *bp = *_bp;
24
25 fid->vid = ntohl(*bp++);
26 fid->vnode = ntohl(*bp++);
27 fid->unique = ntohl(*bp++);
28 *_bp = bp;
29}
30
31/*
32 * Dump a bad file status record.
33 */
34static void xdr_dump_bad(const __be32 *bp)
35{
36 __be32 x[4];
37 int i;
38
39 pr_notice("AFS XDR: Bad status record\n");
40 for (i = 0; i < 5 * 4 * 4; i += 16) {
41 memcpy(x, bp, 16);
42 bp += 4;
43 pr_notice("%03x: %08x %08x %08x %08x\n",
44 i, ntohl(x[0]), ntohl(x[1]), ntohl(x[2]), ntohl(x[3]));
45 }
46
47 memcpy(x, bp, 4);
48 pr_notice("0x50: %08x\n", ntohl(x[0]));
49}
50
51/*
52 * decode an AFSFetchStatus block
53 */
54static void xdr_decode_AFSFetchStatus(const __be32 **_bp,
55 struct afs_call *call,
56 struct afs_status_cb *scb)
57{
58 const struct afs_xdr_AFSFetchStatus *xdr = (const void *)*_bp;
59 struct afs_file_status *status = &scb->status;
60 bool inline_error = (call->operation_ID == afs_FS_InlineBulkStatus);
61 u64 data_version, size;
62 u32 type, abort_code;
63
64 abort_code = ntohl(xdr->abort_code);
65
66 if (xdr->if_version != htonl(AFS_FSTATUS_VERSION)) {
67 if (xdr->if_version == htonl(0) &&
68 abort_code != 0 &&
69 inline_error) {
70 /* The OpenAFS fileserver has a bug in FS.InlineBulkStatus
71 * whereby it doesn't set the interface version in the error
72 * case.
73 */
74 status->abort_code = abort_code;
75 scb->have_error = true;
76 goto advance;
77 }
78
79 pr_warn("Unknown AFSFetchStatus version %u\n", ntohl(xdr->if_version));
80 goto bad;
81 }
82
83 if (abort_code != 0 && inline_error) {
84 status->abort_code = abort_code;
85 scb->have_error = true;
86 goto advance;
87 }
88
89 type = ntohl(xdr->type);
90 switch (type) {
91 case AFS_FTYPE_FILE:
92 case AFS_FTYPE_DIR:
93 case AFS_FTYPE_SYMLINK:
94 status->type = type;
95 break;
96 default:
97 goto bad;
98 }
99
100 status->nlink = ntohl(xdr->nlink);
101 status->author = ntohl(xdr->author);
102 status->owner = ntohl(xdr->owner);
103 status->caller_access = ntohl(xdr->caller_access); /* Ticket dependent */
104 status->anon_access = ntohl(xdr->anon_access);
105 status->mode = ntohl(xdr->mode) & S_IALLUGO;
106 status->group = ntohl(xdr->group);
107 status->lock_count = ntohl(xdr->lock_count);
108
109 status->mtime_client.tv_sec = ntohl(xdr->mtime_client);
110 status->mtime_client.tv_nsec = 0;
111 status->mtime_server.tv_sec = ntohl(xdr->mtime_server);
112 status->mtime_server.tv_nsec = 0;
113
114 size = (u64)ntohl(xdr->size_lo);
115 size |= (u64)ntohl(xdr->size_hi) << 32;
116 status->size = size;
117
118 data_version = (u64)ntohl(xdr->data_version_lo);
119 data_version |= (u64)ntohl(xdr->data_version_hi) << 32;
120 status->data_version = data_version;
121 scb->have_status = true;
122advance:
123 *_bp = (const void *)*_bp + sizeof(*xdr);
124 return;
125
126bad:
127 xdr_dump_bad(*_bp);
128 afs_protocol_error(call, afs_eproto_bad_status);
129 goto advance;
130}
131
132static time64_t xdr_decode_expiry(struct afs_call *call, u32 expiry)
133{
134 return ktime_divns(call->issue_time, NSEC_PER_SEC) + expiry;
135}
136
137static void xdr_decode_AFSCallBack(const __be32 **_bp,
138 struct afs_call *call,
139 struct afs_status_cb *scb)
140{
141 struct afs_callback *cb = &scb->callback;
142 const __be32 *bp = *_bp;
143
144 bp++; /* version */
145 cb->expires_at = xdr_decode_expiry(call, ntohl(*bp++));
146 bp++; /* type */
147 scb->have_cb = true;
148 *_bp = bp;
149}
150
151/*
152 * decode an AFSVolSync block
153 */
154static void xdr_decode_AFSVolSync(const __be32 **_bp,
155 struct afs_volsync *volsync)
156{
157 const __be32 *bp = *_bp;
158 u32 creation;
159
160 creation = ntohl(*bp++);
161 bp++; /* spare2 */
162 bp++; /* spare3 */
163 bp++; /* spare4 */
164 bp++; /* spare5 */
165 bp++; /* spare6 */
166 *_bp = bp;
167
168 if (volsync)
169 volsync->creation = creation;
170}
171
172/*
173 * encode the requested attributes into an AFSStoreStatus block
174 */
175static void xdr_encode_AFS_StoreStatus(__be32 **_bp, struct iattr *attr)
176{
177 __be32 *bp = *_bp;
178 u32 mask = 0, mtime = 0, owner = 0, group = 0, mode = 0;
179
180 mask = 0;
181 if (attr->ia_valid & ATTR_MTIME) {
182 mask |= AFS_SET_MTIME;
183 mtime = attr->ia_mtime.tv_sec;
184 }
185
186 if (attr->ia_valid & ATTR_UID) {
187 mask |= AFS_SET_OWNER;
188 owner = from_kuid(&init_user_ns, attr->ia_uid);
189 }
190
191 if (attr->ia_valid & ATTR_GID) {
192 mask |= AFS_SET_GROUP;
193 group = from_kgid(&init_user_ns, attr->ia_gid);
194 }
195
196 if (attr->ia_valid & ATTR_MODE) {
197 mask |= AFS_SET_MODE;
198 mode = attr->ia_mode & S_IALLUGO;
199 }
200
201 *bp++ = htonl(mask);
202 *bp++ = htonl(mtime);
203 *bp++ = htonl(owner);
204 *bp++ = htonl(group);
205 *bp++ = htonl(mode);
206 *bp++ = 0; /* segment size */
207 *_bp = bp;
208}
209
210/*
211 * decode an AFSFetchVolumeStatus block
212 */
213static void xdr_decode_AFSFetchVolumeStatus(const __be32 **_bp,
214 struct afs_volume_status *vs)
215{
216 const __be32 *bp = *_bp;
217
218 vs->vid = ntohl(*bp++);
219 vs->parent_id = ntohl(*bp++);
220 vs->online = ntohl(*bp++);
221 vs->in_service = ntohl(*bp++);
222 vs->blessed = ntohl(*bp++);
223 vs->needs_salvage = ntohl(*bp++);
224 vs->type = ntohl(*bp++);
225 vs->min_quota = ntohl(*bp++);
226 vs->max_quota = ntohl(*bp++);
227 vs->blocks_in_use = ntohl(*bp++);
228 vs->part_blocks_avail = ntohl(*bp++);
229 vs->part_max_blocks = ntohl(*bp++);
230 vs->vol_copy_date = 0;
231 vs->vol_backup_date = 0;
232 *_bp = bp;
233}
234
235/*
236 * deliver reply data to an FS.FetchStatus
237 */
238static int afs_deliver_fs_fetch_status(struct afs_call *call)
239{
240 struct afs_operation *op = call->op;
241 struct afs_vnode_param *vp = &op->file[op->fetch_status.which];
242 const __be32 *bp;
243 int ret;
244
245 ret = afs_transfer_reply(call);
246 if (ret < 0)
247 return ret;
248
249 /* unmarshall the reply once we've received all of it */
250 bp = call->buffer;
251 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
252 xdr_decode_AFSCallBack(&bp, call, &vp->scb);
253 xdr_decode_AFSVolSync(&bp, &op->volsync);
254
255 _leave(" = 0 [done]");
256 return 0;
257}
258
259/*
260 * FS.FetchStatus operation type
261 */
262static const struct afs_call_type afs_RXFSFetchStatus = {
263 .name = "FS.FetchStatus",
264 .op = afs_FS_FetchStatus,
265 .deliver = afs_deliver_fs_fetch_status,
266 .destructor = afs_flat_call_destructor,
267};
268
269/*
270 * fetch the status information for a file
271 */
272void afs_fs_fetch_status(struct afs_operation *op)
273{
274 struct afs_vnode_param *vp = &op->file[op->fetch_status.which];
275 struct afs_call *call;
276 __be32 *bp;
277
278 _enter(",%x,{%llx:%llu},,",
279 key_serial(op->key), vp->fid.vid, vp->fid.vnode);
280
281 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchStatus,
282 16, (21 + 3 + 6) * 4);
283 if (!call)
284 return afs_op_nomem(op);
285
286 /* marshall the parameters */
287 bp = call->request;
288 bp[0] = htonl(FSFETCHSTATUS);
289 bp[1] = htonl(vp->fid.vid);
290 bp[2] = htonl(vp->fid.vnode);
291 bp[3] = htonl(vp->fid.unique);
292
293 call->fid = vp->fid;
294 trace_afs_make_fs_call(call, &vp->fid);
295 afs_make_op_call(op, call, GFP_NOFS);
296}
297
298/*
299 * deliver reply data to an FS.FetchData
300 */
301static int afs_deliver_fs_fetch_data(struct afs_call *call)
302{
303 struct afs_operation *op = call->op;
304 struct netfs_io_subrequest *subreq = op->fetch.subreq;
305 struct afs_vnode_param *vp = &op->file[0];
306 const __be32 *bp;
307 size_t count_before;
308 int ret;
309
310 _enter("{%u,%zu,%zu/%llu}",
311 call->unmarshall, call->iov_len, iov_iter_count(call->iter),
312 call->remaining);
313
314 switch (call->unmarshall) {
315 case 0:
316 call->remaining = 0;
317 call->unmarshall++;
318 if (call->operation_ID == FSFETCHDATA64) {
319 afs_extract_to_tmp64(call);
320 } else {
321 call->tmp_u = htonl(0);
322 afs_extract_to_tmp(call);
323 }
324 fallthrough;
325
326 /* Extract the returned data length into ->remaining.
327 * This may indicate more or less data than was
328 * requested will be returned.
329 */
330 case 1:
331 _debug("extract data length");
332 ret = afs_extract_data(call, true);
333 if (ret < 0)
334 return ret;
335
336 call->remaining = be64_to_cpu(call->tmp64);
337 _debug("DATA length: %llu", call->remaining);
338
339 if (call->remaining == 0)
340 goto no_more_data;
341
342 call->iter = &subreq->io_iter;
343 call->iov_len = umin(call->remaining, subreq->len - subreq->transferred);
344 call->unmarshall++;
345 fallthrough;
346
347 /* extract the returned data */
348 case 2:
349 count_before = call->iov_len;
350 _debug("extract data %zu/%llu", count_before, call->remaining);
351
352 ret = afs_extract_data(call, true);
353 subreq->transferred += count_before - call->iov_len;
354 call->remaining -= count_before - call->iov_len;
355 if (ret < 0)
356 return ret;
357
358 call->iter = &call->def_iter;
359 if (call->remaining)
360 goto no_more_data;
361
362 /* Discard any excess data the server gave us */
363 afs_extract_discard(call, call->remaining);
364 call->unmarshall = 3;
365 fallthrough;
366
367 case 3:
368 _debug("extract discard %zu/%llu",
369 iov_iter_count(call->iter), call->remaining);
370
371 ret = afs_extract_data(call, true);
372 if (ret < 0)
373 return ret;
374
375 no_more_data:
376 call->unmarshall = 4;
377 afs_extract_to_buf(call, (21 + 3 + 6) * 4);
378 fallthrough;
379
380 /* extract the metadata */
381 case 4:
382 ret = afs_extract_data(call, false);
383 if (ret < 0)
384 return ret;
385
386 bp = call->buffer;
387 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
388 xdr_decode_AFSCallBack(&bp, call, &vp->scb);
389 xdr_decode_AFSVolSync(&bp, &op->volsync);
390
391 if (subreq->start + subreq->transferred >= vp->scb.status.size)
392 __set_bit(NETFS_SREQ_HIT_EOF, &subreq->flags);
393
394 call->unmarshall++;
395 fallthrough;
396
397 case 5:
398 break;
399 }
400
401 _leave(" = 0 [done]");
402 return 0;
403}
404
405/*
406 * FS.FetchData operation type
407 */
408static const struct afs_call_type afs_RXFSFetchData = {
409 .name = "FS.FetchData",
410 .op = afs_FS_FetchData,
411 .async_rx = afs_fetch_data_async_rx,
412 .deliver = afs_deliver_fs_fetch_data,
413 .immediate_cancel = afs_fetch_data_immediate_cancel,
414 .destructor = afs_flat_call_destructor,
415};
416
417static const struct afs_call_type afs_RXFSFetchData64 = {
418 .name = "FS.FetchData64",
419 .op = afs_FS_FetchData64,
420 .async_rx = afs_fetch_data_async_rx,
421 .deliver = afs_deliver_fs_fetch_data,
422 .immediate_cancel = afs_fetch_data_immediate_cancel,
423 .destructor = afs_flat_call_destructor,
424};
425
426/*
427 * fetch data from a very large file
428 */
429static void afs_fs_fetch_data64(struct afs_operation *op)
430{
431 struct netfs_io_subrequest *subreq = op->fetch.subreq;
432 struct afs_vnode_param *vp = &op->file[0];
433 struct afs_call *call;
434 __be32 *bp;
435
436 _enter("");
437
438 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchData64, 32, (21 + 3 + 6) * 4);
439 if (!call)
440 return afs_op_nomem(op);
441
442 if (op->flags & AFS_OPERATION_ASYNC)
443 call->async = true;
444
445 /* marshall the parameters */
446 bp = call->request;
447 bp[0] = htonl(FSFETCHDATA64);
448 bp[1] = htonl(vp->fid.vid);
449 bp[2] = htonl(vp->fid.vnode);
450 bp[3] = htonl(vp->fid.unique);
451 bp[4] = htonl(upper_32_bits(subreq->start + subreq->transferred));
452 bp[5] = htonl(lower_32_bits(subreq->start + subreq->transferred));
453 bp[6] = 0;
454 bp[7] = htonl(lower_32_bits(subreq->len - subreq->transferred));
455
456 call->fid = vp->fid;
457 trace_afs_make_fs_call(call, &vp->fid);
458 afs_make_op_call(op, call, GFP_NOFS);
459}
460
461/*
462 * fetch data from a file
463 */
464void afs_fs_fetch_data(struct afs_operation *op)
465{
466 struct netfs_io_subrequest *subreq = op->fetch.subreq;
467 struct afs_vnode_param *vp = &op->file[0];
468 struct afs_call *call;
469 __be32 *bp;
470
471 if (test_bit(AFS_SERVER_FL_HAS_FS64, &op->server->flags))
472 return afs_fs_fetch_data64(op);
473
474 _enter("");
475
476 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchData, 24, (21 + 3 + 6) * 4);
477 if (!call)
478 return afs_op_nomem(op);
479
480 /* marshall the parameters */
481 bp = call->request;
482 bp[0] = htonl(FSFETCHDATA);
483 bp[1] = htonl(vp->fid.vid);
484 bp[2] = htonl(vp->fid.vnode);
485 bp[3] = htonl(vp->fid.unique);
486 bp[4] = htonl(lower_32_bits(subreq->start + subreq->transferred));
487 bp[5] = htonl(lower_32_bits(subreq->len + subreq->transferred));
488
489 call->fid = vp->fid;
490 trace_afs_make_fs_call(call, &vp->fid);
491 afs_make_op_call(op, call, GFP_NOFS);
492}
493
494/*
495 * deliver reply data to an FS.CreateFile or an FS.MakeDir
496 */
497static int afs_deliver_fs_create_vnode(struct afs_call *call)
498{
499 struct afs_operation *op = call->op;
500 struct afs_vnode_param *dvp = &op->file[0];
501 struct afs_vnode_param *vp = &op->file[1];
502 const __be32 *bp;
503 int ret;
504
505 ret = afs_transfer_reply(call);
506 if (ret < 0)
507 return ret;
508
509 /* unmarshall the reply once we've received all of it */
510 bp = call->buffer;
511 xdr_decode_AFSFid(&bp, &op->file[1].fid);
512 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
513 xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
514 xdr_decode_AFSCallBack(&bp, call, &vp->scb);
515 xdr_decode_AFSVolSync(&bp, &op->volsync);
516
517 _leave(" = 0 [done]");
518 return 0;
519}
520
521/*
522 * FS.CreateFile and FS.MakeDir operation type
523 */
524static const struct afs_call_type afs_RXFSCreateFile = {
525 .name = "FS.CreateFile",
526 .op = afs_FS_CreateFile,
527 .deliver = afs_deliver_fs_create_vnode,
528 .destructor = afs_flat_call_destructor,
529};
530
531/*
532 * Create a file.
533 */
534void afs_fs_create_file(struct afs_operation *op)
535{
536 const struct qstr *name = &op->dentry->d_name;
537 struct afs_vnode_param *dvp = &op->file[0];
538 struct afs_call *call;
539 size_t namesz, reqsz, padsz;
540 __be32 *bp;
541
542 _enter("");
543
544 namesz = name->len;
545 padsz = (4 - (namesz & 3)) & 3;
546 reqsz = (5 * 4) + namesz + padsz + (6 * 4);
547
548 call = afs_alloc_flat_call(op->net, &afs_RXFSCreateFile,
549 reqsz, (3 + 21 + 21 + 3 + 6) * 4);
550 if (!call)
551 return afs_op_nomem(op);
552
553 /* marshall the parameters */
554 bp = call->request;
555 *bp++ = htonl(FSCREATEFILE);
556 *bp++ = htonl(dvp->fid.vid);
557 *bp++ = htonl(dvp->fid.vnode);
558 *bp++ = htonl(dvp->fid.unique);
559 *bp++ = htonl(namesz);
560 memcpy(bp, name->name, namesz);
561 bp = (void *) bp + namesz;
562 if (padsz > 0) {
563 memset(bp, 0, padsz);
564 bp = (void *) bp + padsz;
565 }
566 *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME);
567 *bp++ = htonl(op->mtime.tv_sec); /* mtime */
568 *bp++ = 0; /* owner */
569 *bp++ = 0; /* group */
570 *bp++ = htonl(op->create.mode & S_IALLUGO); /* unix mode */
571 *bp++ = 0; /* segment size */
572
573 call->fid = dvp->fid;
574 trace_afs_make_fs_call1(call, &dvp->fid, name);
575 afs_make_op_call(op, call, GFP_NOFS);
576}
577
578static const struct afs_call_type afs_RXFSMakeDir = {
579 .name = "FS.MakeDir",
580 .op = afs_FS_MakeDir,
581 .deliver = afs_deliver_fs_create_vnode,
582 .destructor = afs_flat_call_destructor,
583};
584
585/*
586 * Create a new directory
587 */
588void afs_fs_make_dir(struct afs_operation *op)
589{
590 const struct qstr *name = &op->dentry->d_name;
591 struct afs_vnode_param *dvp = &op->file[0];
592 struct afs_call *call;
593 size_t namesz, reqsz, padsz;
594 __be32 *bp;
595
596 _enter("");
597
598 namesz = name->len;
599 padsz = (4 - (namesz & 3)) & 3;
600 reqsz = (5 * 4) + namesz + padsz + (6 * 4);
601
602 call = afs_alloc_flat_call(op->net, &afs_RXFSMakeDir,
603 reqsz, (3 + 21 + 21 + 3 + 6) * 4);
604 if (!call)
605 return afs_op_nomem(op);
606
607 /* marshall the parameters */
608 bp = call->request;
609 *bp++ = htonl(FSMAKEDIR);
610 *bp++ = htonl(dvp->fid.vid);
611 *bp++ = htonl(dvp->fid.vnode);
612 *bp++ = htonl(dvp->fid.unique);
613 *bp++ = htonl(namesz);
614 memcpy(bp, name->name, namesz);
615 bp = (void *) bp + namesz;
616 if (padsz > 0) {
617 memset(bp, 0, padsz);
618 bp = (void *) bp + padsz;
619 }
620 *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME);
621 *bp++ = htonl(op->mtime.tv_sec); /* mtime */
622 *bp++ = 0; /* owner */
623 *bp++ = 0; /* group */
624 *bp++ = htonl(op->create.mode & S_IALLUGO); /* unix mode */
625 *bp++ = 0; /* segment size */
626
627 call->fid = dvp->fid;
628 trace_afs_make_fs_call1(call, &dvp->fid, name);
629 afs_make_op_call(op, call, GFP_NOFS);
630}
631
632/*
633 * Deliver reply data to any operation that returns status and volume sync.
634 */
635static int afs_deliver_fs_file_status_and_vol(struct afs_call *call)
636{
637 struct afs_operation *op = call->op;
638 struct afs_vnode_param *vp = &op->file[0];
639 const __be32 *bp;
640 int ret;
641
642 ret = afs_transfer_reply(call);
643 if (ret < 0)
644 return ret;
645
646 /* unmarshall the reply once we've received all of it */
647 bp = call->buffer;
648 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
649 xdr_decode_AFSVolSync(&bp, &op->volsync);
650
651 _leave(" = 0 [done]");
652 return 0;
653}
654
655/*
656 * FS.RemoveFile operation type
657 */
658static const struct afs_call_type afs_RXFSRemoveFile = {
659 .name = "FS.RemoveFile",
660 .op = afs_FS_RemoveFile,
661 .deliver = afs_deliver_fs_file_status_and_vol,
662 .destructor = afs_flat_call_destructor,
663};
664
665/*
666 * Remove a file.
667 */
668void afs_fs_remove_file(struct afs_operation *op)
669{
670 const struct qstr *name = &op->dentry->d_name;
671 struct afs_vnode_param *dvp = &op->file[0];
672 struct afs_call *call;
673 size_t namesz, reqsz, padsz;
674 __be32 *bp;
675
676 _enter("");
677
678 namesz = name->len;
679 padsz = (4 - (namesz & 3)) & 3;
680 reqsz = (5 * 4) + namesz + padsz;
681
682 call = afs_alloc_flat_call(op->net, &afs_RXFSRemoveFile,
683 reqsz, (21 + 6) * 4);
684 if (!call)
685 return afs_op_nomem(op);
686
687 /* marshall the parameters */
688 bp = call->request;
689 *bp++ = htonl(FSREMOVEFILE);
690 *bp++ = htonl(dvp->fid.vid);
691 *bp++ = htonl(dvp->fid.vnode);
692 *bp++ = htonl(dvp->fid.unique);
693 *bp++ = htonl(namesz);
694 memcpy(bp, name->name, namesz);
695 bp = (void *) bp + namesz;
696 if (padsz > 0) {
697 memset(bp, 0, padsz);
698 bp = (void *) bp + padsz;
699 }
700
701 call->fid = dvp->fid;
702 trace_afs_make_fs_call1(call, &dvp->fid, name);
703 afs_make_op_call(op, call, GFP_NOFS);
704}
705
706static const struct afs_call_type afs_RXFSRemoveDir = {
707 .name = "FS.RemoveDir",
708 .op = afs_FS_RemoveDir,
709 .deliver = afs_deliver_fs_file_status_and_vol,
710 .destructor = afs_flat_call_destructor,
711};
712
713/*
714 * Remove a directory.
715 */
716void afs_fs_remove_dir(struct afs_operation *op)
717{
718 const struct qstr *name = &op->dentry->d_name;
719 struct afs_vnode_param *dvp = &op->file[0];
720 struct afs_call *call;
721 size_t namesz, reqsz, padsz;
722 __be32 *bp;
723
724 _enter("");
725
726 namesz = name->len;
727 padsz = (4 - (namesz & 3)) & 3;
728 reqsz = (5 * 4) + namesz + padsz;
729
730 call = afs_alloc_flat_call(op->net, &afs_RXFSRemoveDir,
731 reqsz, (21 + 6) * 4);
732 if (!call)
733 return afs_op_nomem(op);
734
735 /* marshall the parameters */
736 bp = call->request;
737 *bp++ = htonl(FSREMOVEDIR);
738 *bp++ = htonl(dvp->fid.vid);
739 *bp++ = htonl(dvp->fid.vnode);
740 *bp++ = htonl(dvp->fid.unique);
741 *bp++ = htonl(namesz);
742 memcpy(bp, name->name, namesz);
743 bp = (void *) bp + namesz;
744 if (padsz > 0) {
745 memset(bp, 0, padsz);
746 bp = (void *) bp + padsz;
747 }
748
749 call->fid = dvp->fid;
750 trace_afs_make_fs_call1(call, &dvp->fid, name);
751 afs_make_op_call(op, call, GFP_NOFS);
752}
753
754/*
755 * deliver reply data to an FS.Link
756 */
757static int afs_deliver_fs_link(struct afs_call *call)
758{
759 struct afs_operation *op = call->op;
760 struct afs_vnode_param *dvp = &op->file[0];
761 struct afs_vnode_param *vp = &op->file[1];
762 const __be32 *bp;
763 int ret;
764
765 _enter("{%u}", call->unmarshall);
766
767 ret = afs_transfer_reply(call);
768 if (ret < 0)
769 return ret;
770
771 /* unmarshall the reply once we've received all of it */
772 bp = call->buffer;
773 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
774 xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
775 xdr_decode_AFSVolSync(&bp, &op->volsync);
776
777 _leave(" = 0 [done]");
778 return 0;
779}
780
781/*
782 * FS.Link operation type
783 */
784static const struct afs_call_type afs_RXFSLink = {
785 .name = "FS.Link",
786 .op = afs_FS_Link,
787 .deliver = afs_deliver_fs_link,
788 .destructor = afs_flat_call_destructor,
789};
790
791/*
792 * make a hard link
793 */
794void afs_fs_link(struct afs_operation *op)
795{
796 const struct qstr *name = &op->dentry->d_name;
797 struct afs_vnode_param *dvp = &op->file[0];
798 struct afs_vnode_param *vp = &op->file[1];
799 struct afs_call *call;
800 size_t namesz, reqsz, padsz;
801 __be32 *bp;
802
803 _enter("");
804
805 namesz = name->len;
806 padsz = (4 - (namesz & 3)) & 3;
807 reqsz = (5 * 4) + namesz + padsz + (3 * 4);
808
809 call = afs_alloc_flat_call(op->net, &afs_RXFSLink, reqsz, (21 + 21 + 6) * 4);
810 if (!call)
811 return afs_op_nomem(op);
812
813 /* marshall the parameters */
814 bp = call->request;
815 *bp++ = htonl(FSLINK);
816 *bp++ = htonl(dvp->fid.vid);
817 *bp++ = htonl(dvp->fid.vnode);
818 *bp++ = htonl(dvp->fid.unique);
819 *bp++ = htonl(namesz);
820 memcpy(bp, name->name, namesz);
821 bp = (void *) bp + namesz;
822 if (padsz > 0) {
823 memset(bp, 0, padsz);
824 bp = (void *) bp + padsz;
825 }
826 *bp++ = htonl(vp->fid.vid);
827 *bp++ = htonl(vp->fid.vnode);
828 *bp++ = htonl(vp->fid.unique);
829
830 call->fid = vp->fid;
831 trace_afs_make_fs_call1(call, &vp->fid, name);
832 afs_make_op_call(op, call, GFP_NOFS);
833}
834
835/*
836 * deliver reply data to an FS.Symlink
837 */
838static int afs_deliver_fs_symlink(struct afs_call *call)
839{
840 struct afs_operation *op = call->op;
841 struct afs_vnode_param *dvp = &op->file[0];
842 struct afs_vnode_param *vp = &op->file[1];
843 const __be32 *bp;
844 int ret;
845
846 _enter("{%u}", call->unmarshall);
847
848 ret = afs_transfer_reply(call);
849 if (ret < 0)
850 return ret;
851
852 /* unmarshall the reply once we've received all of it */
853 bp = call->buffer;
854 xdr_decode_AFSFid(&bp, &vp->fid);
855 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
856 xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
857 xdr_decode_AFSVolSync(&bp, &op->volsync);
858
859 _leave(" = 0 [done]");
860 return 0;
861}
862
863/*
864 * FS.Symlink operation type
865 */
866static const struct afs_call_type afs_RXFSSymlink = {
867 .name = "FS.Symlink",
868 .op = afs_FS_Symlink,
869 .deliver = afs_deliver_fs_symlink,
870 .destructor = afs_flat_call_destructor,
871};
872
873/*
874 * create a symbolic link
875 */
876void afs_fs_symlink(struct afs_operation *op)
877{
878 const struct qstr *name = &op->dentry->d_name;
879 struct afs_vnode_param *dvp = &op->file[0];
880 struct afs_call *call;
881 size_t namesz, reqsz, padsz, c_namesz, c_padsz;
882 __be32 *bp;
883
884 _enter("");
885
886 namesz = name->len;
887 padsz = (4 - (namesz & 3)) & 3;
888
889 c_namesz = strlen(op->create.symlink);
890 c_padsz = (4 - (c_namesz & 3)) & 3;
891
892 reqsz = (6 * 4) + namesz + padsz + c_namesz + c_padsz + (6 * 4);
893
894 call = afs_alloc_flat_call(op->net, &afs_RXFSSymlink, reqsz,
895 (3 + 21 + 21 + 6) * 4);
896 if (!call)
897 return afs_op_nomem(op);
898
899 /* marshall the parameters */
900 bp = call->request;
901 *bp++ = htonl(FSSYMLINK);
902 *bp++ = htonl(dvp->fid.vid);
903 *bp++ = htonl(dvp->fid.vnode);
904 *bp++ = htonl(dvp->fid.unique);
905 *bp++ = htonl(namesz);
906 memcpy(bp, name->name, namesz);
907 bp = (void *) bp + namesz;
908 if (padsz > 0) {
909 memset(bp, 0, padsz);
910 bp = (void *) bp + padsz;
911 }
912 *bp++ = htonl(c_namesz);
913 memcpy(bp, op->create.symlink, c_namesz);
914 bp = (void *) bp + c_namesz;
915 if (c_padsz > 0) {
916 memset(bp, 0, c_padsz);
917 bp = (void *) bp + c_padsz;
918 }
919 *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME);
920 *bp++ = htonl(op->mtime.tv_sec); /* mtime */
921 *bp++ = 0; /* owner */
922 *bp++ = 0; /* group */
923 *bp++ = htonl(S_IRWXUGO); /* unix mode */
924 *bp++ = 0; /* segment size */
925
926 call->fid = dvp->fid;
927 trace_afs_make_fs_call1(call, &dvp->fid, name);
928 afs_make_op_call(op, call, GFP_NOFS);
929}
930
931/*
932 * deliver reply data to an FS.Rename
933 */
934static int afs_deliver_fs_rename(struct afs_call *call)
935{
936 struct afs_operation *op = call->op;
937 struct afs_vnode_param *orig_dvp = &op->file[0];
938 struct afs_vnode_param *new_dvp = &op->file[1];
939 const __be32 *bp;
940 int ret;
941
942 ret = afs_transfer_reply(call);
943 if (ret < 0)
944 return ret;
945
946 bp = call->buffer;
947 /* If the two dirs are the same, we have two copies of the same status
948 * report, so we just decode it twice.
949 */
950 xdr_decode_AFSFetchStatus(&bp, call, &orig_dvp->scb);
951 xdr_decode_AFSFetchStatus(&bp, call, &new_dvp->scb);
952 xdr_decode_AFSVolSync(&bp, &op->volsync);
953
954 _leave(" = 0 [done]");
955 return 0;
956}
957
958/*
959 * FS.Rename operation type
960 */
961static const struct afs_call_type afs_RXFSRename = {
962 .name = "FS.Rename",
963 .op = afs_FS_Rename,
964 .deliver = afs_deliver_fs_rename,
965 .destructor = afs_flat_call_destructor,
966};
967
968/*
969 * Rename/move a file or directory.
970 */
971void afs_fs_rename(struct afs_operation *op)
972{
973 struct afs_vnode_param *orig_dvp = &op->file[0];
974 struct afs_vnode_param *new_dvp = &op->file[1];
975 const struct qstr *orig_name = &op->dentry->d_name;
976 const struct qstr *new_name = &op->dentry_2->d_name;
977 struct afs_call *call;
978 size_t reqsz, o_namesz, o_padsz, n_namesz, n_padsz;
979 __be32 *bp;
980
981 _enter("");
982
983 o_namesz = orig_name->len;
984 o_padsz = (4 - (o_namesz & 3)) & 3;
985
986 n_namesz = new_name->len;
987 n_padsz = (4 - (n_namesz & 3)) & 3;
988
989 reqsz = (4 * 4) +
990 4 + o_namesz + o_padsz +
991 (3 * 4) +
992 4 + n_namesz + n_padsz;
993
994 call = afs_alloc_flat_call(op->net, &afs_RXFSRename, reqsz, (21 + 21 + 6) * 4);
995 if (!call)
996 return afs_op_nomem(op);
997
998 /* marshall the parameters */
999 bp = call->request;
1000 *bp++ = htonl(FSRENAME);
1001 *bp++ = htonl(orig_dvp->fid.vid);
1002 *bp++ = htonl(orig_dvp->fid.vnode);
1003 *bp++ = htonl(orig_dvp->fid.unique);
1004 *bp++ = htonl(o_namesz);
1005 memcpy(bp, orig_name->name, o_namesz);
1006 bp = (void *) bp + o_namesz;
1007 if (o_padsz > 0) {
1008 memset(bp, 0, o_padsz);
1009 bp = (void *) bp + o_padsz;
1010 }
1011
1012 *bp++ = htonl(new_dvp->fid.vid);
1013 *bp++ = htonl(new_dvp->fid.vnode);
1014 *bp++ = htonl(new_dvp->fid.unique);
1015 *bp++ = htonl(n_namesz);
1016 memcpy(bp, new_name->name, n_namesz);
1017 bp = (void *) bp + n_namesz;
1018 if (n_padsz > 0) {
1019 memset(bp, 0, n_padsz);
1020 bp = (void *) bp + n_padsz;
1021 }
1022
1023 call->fid = orig_dvp->fid;
1024 trace_afs_make_fs_call2(call, &orig_dvp->fid, orig_name, new_name);
1025 afs_make_op_call(op, call, GFP_NOFS);
1026}
1027
1028/*
1029 * Deliver reply data to FS.StoreData or FS.StoreStatus
1030 */
1031static int afs_deliver_fs_store_data(struct afs_call *call)
1032{
1033 struct afs_operation *op = call->op;
1034 struct afs_vnode_param *vp = &op->file[0];
1035 const __be32 *bp;
1036 int ret;
1037
1038 _enter("");
1039
1040 ret = afs_transfer_reply(call);
1041 if (ret < 0)
1042 return ret;
1043
1044 /* unmarshall the reply once we've received all of it */
1045 bp = call->buffer;
1046 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
1047 xdr_decode_AFSVolSync(&bp, &op->volsync);
1048
1049 _leave(" = 0 [done]");
1050 return 0;
1051}
1052
1053/*
1054 * FS.StoreData operation type
1055 */
1056static const struct afs_call_type afs_RXFSStoreData = {
1057 .name = "FS.StoreData",
1058 .op = afs_FS_StoreData,
1059 .deliver = afs_deliver_fs_store_data,
1060 .destructor = afs_flat_call_destructor,
1061};
1062
1063static const struct afs_call_type afs_RXFSStoreData64 = {
1064 .name = "FS.StoreData64",
1065 .op = afs_FS_StoreData64,
1066 .deliver = afs_deliver_fs_store_data,
1067 .destructor = afs_flat_call_destructor,
1068};
1069
1070/*
1071 * store a set of pages to a very large file
1072 */
1073static void afs_fs_store_data64(struct afs_operation *op)
1074{
1075 struct afs_vnode_param *vp = &op->file[0];
1076 struct afs_call *call;
1077 __be32 *bp;
1078
1079 _enter(",%x,{%llx:%llu},,",
1080 key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1081
1082 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData64,
1083 (4 + 6 + 3 * 2) * 4,
1084 (21 + 6) * 4);
1085 if (!call)
1086 return afs_op_nomem(op);
1087
1088 call->write_iter = op->store.write_iter;
1089
1090 /* marshall the parameters */
1091 bp = call->request;
1092 *bp++ = htonl(FSSTOREDATA64);
1093 *bp++ = htonl(vp->fid.vid);
1094 *bp++ = htonl(vp->fid.vnode);
1095 *bp++ = htonl(vp->fid.unique);
1096
1097 *bp++ = htonl(AFS_SET_MTIME); /* mask */
1098 *bp++ = htonl(op->mtime.tv_sec); /* mtime */
1099 *bp++ = 0; /* owner */
1100 *bp++ = 0; /* group */
1101 *bp++ = 0; /* unix mode */
1102 *bp++ = 0; /* segment size */
1103
1104 *bp++ = htonl(upper_32_bits(op->store.pos));
1105 *bp++ = htonl(lower_32_bits(op->store.pos));
1106 *bp++ = htonl(upper_32_bits(op->store.size));
1107 *bp++ = htonl(lower_32_bits(op->store.size));
1108 *bp++ = htonl(upper_32_bits(op->store.i_size));
1109 *bp++ = htonl(lower_32_bits(op->store.i_size));
1110
1111 call->fid = vp->fid;
1112 trace_afs_make_fs_call(call, &vp->fid);
1113 afs_make_op_call(op, call, GFP_NOFS);
1114}
1115
1116/*
1117 * Write data to a file on the server.
1118 */
1119void afs_fs_store_data(struct afs_operation *op)
1120{
1121 struct afs_vnode_param *vp = &op->file[0];
1122 struct afs_call *call;
1123 __be32 *bp;
1124
1125 _enter(",%x,{%llx:%llu},,",
1126 key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1127
1128 _debug("size %llx, at %llx, i_size %llx",
1129 (unsigned long long)op->store.size,
1130 (unsigned long long)op->store.pos,
1131 (unsigned long long)op->store.i_size);
1132
1133 if (test_bit(AFS_SERVER_FL_HAS_FS64, &op->server->flags))
1134 return afs_fs_store_data64(op);
1135
1136 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData,
1137 (4 + 6 + 3) * 4,
1138 (21 + 6) * 4);
1139 if (!call)
1140 return afs_op_nomem(op);
1141
1142 call->write_iter = op->store.write_iter;
1143
1144 /* marshall the parameters */
1145 bp = call->request;
1146 *bp++ = htonl(FSSTOREDATA);
1147 *bp++ = htonl(vp->fid.vid);
1148 *bp++ = htonl(vp->fid.vnode);
1149 *bp++ = htonl(vp->fid.unique);
1150
1151 *bp++ = htonl(AFS_SET_MTIME); /* mask */
1152 *bp++ = htonl(op->mtime.tv_sec); /* mtime */
1153 *bp++ = 0; /* owner */
1154 *bp++ = 0; /* group */
1155 *bp++ = 0; /* unix mode */
1156 *bp++ = 0; /* segment size */
1157
1158 *bp++ = htonl(lower_32_bits(op->store.pos));
1159 *bp++ = htonl(lower_32_bits(op->store.size));
1160 *bp++ = htonl(lower_32_bits(op->store.i_size));
1161
1162 call->fid = vp->fid;
1163 trace_afs_make_fs_call(call, &vp->fid);
1164 afs_make_op_call(op, call, GFP_NOFS);
1165}
1166
1167/*
1168 * FS.StoreStatus operation type
1169 */
1170static const struct afs_call_type afs_RXFSStoreStatus = {
1171 .name = "FS.StoreStatus",
1172 .op = afs_FS_StoreStatus,
1173 .deliver = afs_deliver_fs_store_data,
1174 .destructor = afs_flat_call_destructor,
1175};
1176
1177static const struct afs_call_type afs_RXFSStoreData_as_Status = {
1178 .name = "FS.StoreData",
1179 .op = afs_FS_StoreData,
1180 .deliver = afs_deliver_fs_store_data,
1181 .destructor = afs_flat_call_destructor,
1182};
1183
1184static const struct afs_call_type afs_RXFSStoreData64_as_Status = {
1185 .name = "FS.StoreData64",
1186 .op = afs_FS_StoreData64,
1187 .deliver = afs_deliver_fs_store_data,
1188 .destructor = afs_flat_call_destructor,
1189};
1190
1191/*
1192 * set the attributes on a very large file, using FS.StoreData rather than
1193 * FS.StoreStatus so as to alter the file size also
1194 */
1195static void afs_fs_setattr_size64(struct afs_operation *op)
1196{
1197 struct afs_vnode_param *vp = &op->file[0];
1198 struct afs_call *call;
1199 struct iattr *attr = op->setattr.attr;
1200 __be32 *bp;
1201
1202 _enter(",%x,{%llx:%llu},,",
1203 key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1204
1205 ASSERT(attr->ia_valid & ATTR_SIZE);
1206
1207 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData64_as_Status,
1208 (4 + 6 + 3 * 2) * 4,
1209 (21 + 6) * 4);
1210 if (!call)
1211 return afs_op_nomem(op);
1212
1213 /* marshall the parameters */
1214 bp = call->request;
1215 *bp++ = htonl(FSSTOREDATA64);
1216 *bp++ = htonl(vp->fid.vid);
1217 *bp++ = htonl(vp->fid.vnode);
1218 *bp++ = htonl(vp->fid.unique);
1219
1220 xdr_encode_AFS_StoreStatus(&bp, attr);
1221
1222 *bp++ = htonl(upper_32_bits(attr->ia_size)); /* position of start of write */
1223 *bp++ = htonl(lower_32_bits(attr->ia_size));
1224 *bp++ = 0; /* size of write */
1225 *bp++ = 0;
1226 *bp++ = htonl(upper_32_bits(attr->ia_size)); /* new file length */
1227 *bp++ = htonl(lower_32_bits(attr->ia_size));
1228
1229 call->fid = vp->fid;
1230 trace_afs_make_fs_call(call, &vp->fid);
1231 afs_make_op_call(op, call, GFP_NOFS);
1232}
1233
1234/*
1235 * set the attributes on a file, using FS.StoreData rather than FS.StoreStatus
1236 * so as to alter the file size also
1237 */
1238static void afs_fs_setattr_size(struct afs_operation *op)
1239{
1240 struct afs_vnode_param *vp = &op->file[0];
1241 struct afs_call *call;
1242 struct iattr *attr = op->setattr.attr;
1243 __be32 *bp;
1244
1245 _enter(",%x,{%llx:%llu},,",
1246 key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1247
1248 ASSERT(attr->ia_valid & ATTR_SIZE);
1249 if (test_bit(AFS_SERVER_FL_HAS_FS64, &op->server->flags))
1250 return afs_fs_setattr_size64(op);
1251
1252 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData_as_Status,
1253 (4 + 6 + 3) * 4,
1254 (21 + 6) * 4);
1255 if (!call)
1256 return afs_op_nomem(op);
1257
1258 /* marshall the parameters */
1259 bp = call->request;
1260 *bp++ = htonl(FSSTOREDATA);
1261 *bp++ = htonl(vp->fid.vid);
1262 *bp++ = htonl(vp->fid.vnode);
1263 *bp++ = htonl(vp->fid.unique);
1264
1265 xdr_encode_AFS_StoreStatus(&bp, attr);
1266
1267 *bp++ = htonl(attr->ia_size); /* position of start of write */
1268 *bp++ = 0; /* size of write */
1269 *bp++ = htonl(attr->ia_size); /* new file length */
1270
1271 call->fid = vp->fid;
1272 trace_afs_make_fs_call(call, &vp->fid);
1273 afs_make_op_call(op, call, GFP_NOFS);
1274}
1275
1276/*
1277 * set the attributes on a file, using FS.StoreData if there's a change in file
1278 * size, and FS.StoreStatus otherwise
1279 */
1280void afs_fs_setattr(struct afs_operation *op)
1281{
1282 struct afs_vnode_param *vp = &op->file[0];
1283 struct afs_call *call;
1284 struct iattr *attr = op->setattr.attr;
1285 __be32 *bp;
1286
1287 if (attr->ia_valid & ATTR_SIZE)
1288 return afs_fs_setattr_size(op);
1289
1290 _enter(",%x,{%llx:%llu},,",
1291 key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1292
1293 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreStatus,
1294 (4 + 6) * 4,
1295 (21 + 6) * 4);
1296 if (!call)
1297 return afs_op_nomem(op);
1298
1299 /* marshall the parameters */
1300 bp = call->request;
1301 *bp++ = htonl(FSSTORESTATUS);
1302 *bp++ = htonl(vp->fid.vid);
1303 *bp++ = htonl(vp->fid.vnode);
1304 *bp++ = htonl(vp->fid.unique);
1305
1306 xdr_encode_AFS_StoreStatus(&bp, op->setattr.attr);
1307
1308 call->fid = vp->fid;
1309 trace_afs_make_fs_call(call, &vp->fid);
1310 afs_make_op_call(op, call, GFP_NOFS);
1311}
1312
1313/*
1314 * deliver reply data to an FS.GetVolumeStatus
1315 */
1316static int afs_deliver_fs_get_volume_status(struct afs_call *call)
1317{
1318 struct afs_operation *op = call->op;
1319 const __be32 *bp;
1320 char *p;
1321 u32 size;
1322 int ret;
1323
1324 _enter("{%u}", call->unmarshall);
1325
1326 switch (call->unmarshall) {
1327 case 0:
1328 call->unmarshall++;
1329 afs_extract_to_buf(call, 12 * 4);
1330 fallthrough;
1331
1332 /* extract the returned status record */
1333 case 1:
1334 _debug("extract status");
1335 ret = afs_extract_data(call, true);
1336 if (ret < 0)
1337 return ret;
1338
1339 bp = call->buffer;
1340 xdr_decode_AFSFetchVolumeStatus(&bp, &op->volstatus.vs);
1341 call->unmarshall++;
1342 afs_extract_to_tmp(call);
1343 fallthrough;
1344
1345 /* extract the volume name length */
1346 case 2:
1347 ret = afs_extract_data(call, true);
1348 if (ret < 0)
1349 return ret;
1350
1351 call->count = ntohl(call->tmp);
1352 _debug("volname length: %u", call->count);
1353 if (call->count >= AFSNAMEMAX)
1354 return afs_protocol_error(call, afs_eproto_volname_len);
1355 size = (call->count + 3) & ~3; /* It's padded */
1356 afs_extract_to_buf(call, size);
1357 call->unmarshall++;
1358 fallthrough;
1359
1360 /* extract the volume name */
1361 case 3:
1362 _debug("extract volname");
1363 ret = afs_extract_data(call, true);
1364 if (ret < 0)
1365 return ret;
1366
1367 p = call->buffer;
1368 p[call->count] = 0;
1369 _debug("volname '%s'", p);
1370 afs_extract_to_tmp(call);
1371 call->unmarshall++;
1372 fallthrough;
1373
1374 /* extract the offline message length */
1375 case 4:
1376 ret = afs_extract_data(call, true);
1377 if (ret < 0)
1378 return ret;
1379
1380 call->count = ntohl(call->tmp);
1381 _debug("offline msg length: %u", call->count);
1382 if (call->count >= AFSNAMEMAX)
1383 return afs_protocol_error(call, afs_eproto_offline_msg_len);
1384 size = (call->count + 3) & ~3; /* It's padded */
1385 afs_extract_to_buf(call, size);
1386 call->unmarshall++;
1387 fallthrough;
1388
1389 /* extract the offline message */
1390 case 5:
1391 _debug("extract offline");
1392 ret = afs_extract_data(call, true);
1393 if (ret < 0)
1394 return ret;
1395
1396 p = call->buffer;
1397 p[call->count] = 0;
1398 _debug("offline '%s'", p);
1399
1400 afs_extract_to_tmp(call);
1401 call->unmarshall++;
1402 fallthrough;
1403
1404 /* extract the message of the day length */
1405 case 6:
1406 ret = afs_extract_data(call, true);
1407 if (ret < 0)
1408 return ret;
1409
1410 call->count = ntohl(call->tmp);
1411 _debug("motd length: %u", call->count);
1412 if (call->count >= AFSNAMEMAX)
1413 return afs_protocol_error(call, afs_eproto_motd_len);
1414 size = (call->count + 3) & ~3; /* It's padded */
1415 afs_extract_to_buf(call, size);
1416 call->unmarshall++;
1417 fallthrough;
1418
1419 /* extract the message of the day */
1420 case 7:
1421 _debug("extract motd");
1422 ret = afs_extract_data(call, false);
1423 if (ret < 0)
1424 return ret;
1425
1426 p = call->buffer;
1427 p[call->count] = 0;
1428 _debug("motd '%s'", p);
1429
1430 call->unmarshall++;
1431 fallthrough;
1432
1433 case 8:
1434 break;
1435 }
1436
1437 _leave(" = 0 [done]");
1438 return 0;
1439}
1440
1441/*
1442 * FS.GetVolumeStatus operation type
1443 */
1444static const struct afs_call_type afs_RXFSGetVolumeStatus = {
1445 .name = "FS.GetVolumeStatus",
1446 .op = afs_FS_GetVolumeStatus,
1447 .deliver = afs_deliver_fs_get_volume_status,
1448 .destructor = afs_flat_call_destructor,
1449};
1450
1451/*
1452 * fetch the status of a volume
1453 */
1454void afs_fs_get_volume_status(struct afs_operation *op)
1455{
1456 struct afs_vnode_param *vp = &op->file[0];
1457 struct afs_call *call;
1458 __be32 *bp;
1459
1460 _enter("");
1461
1462 call = afs_alloc_flat_call(op->net, &afs_RXFSGetVolumeStatus, 2 * 4,
1463 max(12 * 4, AFSOPAQUEMAX + 1));
1464 if (!call)
1465 return afs_op_nomem(op);
1466
1467 /* marshall the parameters */
1468 bp = call->request;
1469 bp[0] = htonl(FSGETVOLUMESTATUS);
1470 bp[1] = htonl(vp->fid.vid);
1471
1472 call->fid = vp->fid;
1473 trace_afs_make_fs_call(call, &vp->fid);
1474 afs_make_op_call(op, call, GFP_NOFS);
1475}
1476
1477/*
1478 * deliver reply data to an FS.SetLock, FS.ExtendLock or FS.ReleaseLock
1479 */
1480static int afs_deliver_fs_xxxx_lock(struct afs_call *call)
1481{
1482 struct afs_operation *op = call->op;
1483 const __be32 *bp;
1484 int ret;
1485
1486 _enter("{%u}", call->unmarshall);
1487
1488 ret = afs_transfer_reply(call);
1489 if (ret < 0)
1490 return ret;
1491
1492 /* unmarshall the reply once we've received all of it */
1493 bp = call->buffer;
1494 xdr_decode_AFSVolSync(&bp, &op->volsync);
1495
1496 _leave(" = 0 [done]");
1497 return 0;
1498}
1499
1500/*
1501 * FS.SetLock operation type
1502 */
1503static const struct afs_call_type afs_RXFSSetLock = {
1504 .name = "FS.SetLock",
1505 .op = afs_FS_SetLock,
1506 .deliver = afs_deliver_fs_xxxx_lock,
1507 .done = afs_lock_op_done,
1508 .destructor = afs_flat_call_destructor,
1509};
1510
1511/*
1512 * FS.ExtendLock operation type
1513 */
1514static const struct afs_call_type afs_RXFSExtendLock = {
1515 .name = "FS.ExtendLock",
1516 .op = afs_FS_ExtendLock,
1517 .deliver = afs_deliver_fs_xxxx_lock,
1518 .done = afs_lock_op_done,
1519 .destructor = afs_flat_call_destructor,
1520};
1521
1522/*
1523 * FS.ReleaseLock operation type
1524 */
1525static const struct afs_call_type afs_RXFSReleaseLock = {
1526 .name = "FS.ReleaseLock",
1527 .op = afs_FS_ReleaseLock,
1528 .deliver = afs_deliver_fs_xxxx_lock,
1529 .destructor = afs_flat_call_destructor,
1530};
1531
1532/*
1533 * Set a lock on a file
1534 */
1535void afs_fs_set_lock(struct afs_operation *op)
1536{
1537 struct afs_vnode_param *vp = &op->file[0];
1538 struct afs_call *call;
1539 __be32 *bp;
1540
1541 _enter("");
1542
1543 call = afs_alloc_flat_call(op->net, &afs_RXFSSetLock, 5 * 4, 6 * 4);
1544 if (!call)
1545 return afs_op_nomem(op);
1546
1547 /* marshall the parameters */
1548 bp = call->request;
1549 *bp++ = htonl(FSSETLOCK);
1550 *bp++ = htonl(vp->fid.vid);
1551 *bp++ = htonl(vp->fid.vnode);
1552 *bp++ = htonl(vp->fid.unique);
1553 *bp++ = htonl(op->lock.type);
1554
1555 call->fid = vp->fid;
1556 trace_afs_make_fs_calli(call, &vp->fid, op->lock.type);
1557 afs_make_op_call(op, call, GFP_NOFS);
1558}
1559
1560/*
1561 * extend a lock on a file
1562 */
1563void afs_fs_extend_lock(struct afs_operation *op)
1564{
1565 struct afs_vnode_param *vp = &op->file[0];
1566 struct afs_call *call;
1567 __be32 *bp;
1568
1569 _enter("");
1570
1571 call = afs_alloc_flat_call(op->net, &afs_RXFSExtendLock, 4 * 4, 6 * 4);
1572 if (!call)
1573 return afs_op_nomem(op);
1574
1575 /* marshall the parameters */
1576 bp = call->request;
1577 *bp++ = htonl(FSEXTENDLOCK);
1578 *bp++ = htonl(vp->fid.vid);
1579 *bp++ = htonl(vp->fid.vnode);
1580 *bp++ = htonl(vp->fid.unique);
1581
1582 call->fid = vp->fid;
1583 trace_afs_make_fs_call(call, &vp->fid);
1584 afs_make_op_call(op, call, GFP_NOFS);
1585}
1586
1587/*
1588 * release a lock on a file
1589 */
1590void afs_fs_release_lock(struct afs_operation *op)
1591{
1592 struct afs_vnode_param *vp = &op->file[0];
1593 struct afs_call *call;
1594 __be32 *bp;
1595
1596 _enter("");
1597
1598 call = afs_alloc_flat_call(op->net, &afs_RXFSReleaseLock, 4 * 4, 6 * 4);
1599 if (!call)
1600 return afs_op_nomem(op);
1601
1602 /* marshall the parameters */
1603 bp = call->request;
1604 *bp++ = htonl(FSRELEASELOCK);
1605 *bp++ = htonl(vp->fid.vid);
1606 *bp++ = htonl(vp->fid.vnode);
1607 *bp++ = htonl(vp->fid.unique);
1608
1609 call->fid = vp->fid;
1610 trace_afs_make_fs_call(call, &vp->fid);
1611 afs_make_op_call(op, call, GFP_NOFS);
1612}
1613
1614/*
1615 * Deliver reply data to an FS.GiveUpAllCallBacks operation.
1616 */
1617static int afs_deliver_fs_give_up_all_callbacks(struct afs_call *call)
1618{
1619 return afs_transfer_reply(call);
1620}
1621
1622/*
1623 * FS.GiveUpAllCallBacks operation type
1624 */
1625static const struct afs_call_type afs_RXFSGiveUpAllCallBacks = {
1626 .name = "FS.GiveUpAllCallBacks",
1627 .op = afs_FS_GiveUpAllCallBacks,
1628 .deliver = afs_deliver_fs_give_up_all_callbacks,
1629 .destructor = afs_flat_call_destructor,
1630};
1631
1632/*
1633 * Flush all the callbacks we have on a server.
1634 */
1635int afs_fs_give_up_all_callbacks(struct afs_net *net, struct afs_server *server,
1636 struct afs_address *addr, struct key *key)
1637{
1638 struct afs_call *call;
1639 __be32 *bp;
1640 int ret;
1641
1642 _enter("");
1643
1644 call = afs_alloc_flat_call(net, &afs_RXFSGiveUpAllCallBacks, 1 * 4, 0);
1645 if (!call)
1646 return -ENOMEM;
1647
1648 call->key = key;
1649 call->peer = rxrpc_kernel_get_peer(addr->peer);
1650 call->service_id = server->service_id;
1651
1652 /* marshall the parameters */
1653 bp = call->request;
1654 *bp++ = htonl(FSGIVEUPALLCALLBACKS);
1655
1656 call->server = afs_use_server(server, false, afs_server_trace_use_give_up_cb);
1657 afs_make_call(call, GFP_NOFS);
1658 afs_wait_for_call_to_complete(call);
1659 ret = call->error;
1660 if (call->responded)
1661 set_bit(AFS_SERVER_FL_RESPONDING, &server->flags);
1662 afs_put_call(call);
1663 return ret;
1664}
1665
1666/*
1667 * Deliver reply data to an FS.GetCapabilities operation.
1668 */
1669static int afs_deliver_fs_get_capabilities(struct afs_call *call)
1670{
1671 u32 count;
1672 int ret;
1673
1674 _enter("{%u,%zu}", call->unmarshall, iov_iter_count(call->iter));
1675
1676 switch (call->unmarshall) {
1677 case 0:
1678 afs_extract_to_tmp(call);
1679 call->unmarshall++;
1680 fallthrough;
1681
1682 /* Extract the capabilities word count */
1683 case 1:
1684 ret = afs_extract_data(call, true);
1685 if (ret < 0)
1686 return ret;
1687
1688 count = ntohl(call->tmp);
1689 call->count = count;
1690 call->count2 = count;
1691 if (count == 0) {
1692 call->unmarshall = 4;
1693 call->tmp = 0;
1694 break;
1695 }
1696
1697 /* Extract the first word of the capabilities to call->tmp */
1698 afs_extract_to_tmp(call);
1699 call->unmarshall++;
1700 fallthrough;
1701
1702 case 2:
1703 ret = afs_extract_data(call, false);
1704 if (ret < 0)
1705 return ret;
1706
1707 afs_extract_discard(call, (count - 1) * sizeof(__be32));
1708 call->unmarshall++;
1709 fallthrough;
1710
1711 /* Extract remaining capabilities words */
1712 case 3:
1713 ret = afs_extract_data(call, false);
1714 if (ret < 0)
1715 return ret;
1716
1717 call->unmarshall++;
1718 break;
1719 }
1720
1721 _leave(" = 0 [done]");
1722 return 0;
1723}
1724
1725static void afs_fs_get_capabilities_destructor(struct afs_call *call)
1726{
1727 afs_put_endpoint_state(call->probe, afs_estate_trace_put_getcaps);
1728 afs_flat_call_destructor(call);
1729}
1730
1731/*
1732 * FS.GetCapabilities operation type
1733 */
1734static const struct afs_call_type afs_RXFSGetCapabilities = {
1735 .name = "FS.GetCapabilities",
1736 .op = afs_FS_GetCapabilities,
1737 .deliver = afs_deliver_fs_get_capabilities,
1738 .done = afs_fileserver_probe_result,
1739 .immediate_cancel = afs_fileserver_probe_result,
1740 .destructor = afs_fs_get_capabilities_destructor,
1741};
1742
1743/*
1744 * Probe a fileserver for the capabilities that it supports. This RPC can
1745 * reply with up to 196 words. The operation is asynchronous and if we managed
1746 * to allocate a call, true is returned the result is delivered through the
1747 * ->done() - otherwise we return false to indicate we didn't even try.
1748 */
1749bool afs_fs_get_capabilities(struct afs_net *net, struct afs_server *server,
1750 struct afs_endpoint_state *estate, unsigned int addr_index,
1751 struct key *key)
1752{
1753 struct afs_call *call;
1754 __be32 *bp;
1755
1756 _enter("");
1757
1758 call = afs_alloc_flat_call(net, &afs_RXFSGetCapabilities, 1 * 4, 16 * 4);
1759 if (!call)
1760 return false;
1761
1762 call->key = key;
1763 call->server = afs_use_server(server, false, afs_server_trace_use_get_caps);
1764 call->peer = rxrpc_kernel_get_peer(estate->addresses->addrs[addr_index].peer);
1765 call->probe = afs_get_endpoint_state(estate, afs_estate_trace_get_getcaps);
1766 call->probe_index = addr_index;
1767 call->service_id = server->service_id;
1768 call->upgrade = true;
1769 call->async = true;
1770 call->max_lifespan = AFS_PROBE_MAX_LIFESPAN;
1771
1772 /* marshall the parameters */
1773 bp = call->request;
1774 *bp++ = htonl(FSGETCAPABILITIES);
1775
1776 trace_afs_make_fs_call(call, NULL);
1777 afs_make_call(call, GFP_NOFS);
1778 afs_put_call(call);
1779 return true;
1780}
1781
1782/*
1783 * Deliver reply data to an FS.InlineBulkStatus call
1784 */
1785static int afs_deliver_fs_inline_bulk_status(struct afs_call *call)
1786{
1787 struct afs_operation *op = call->op;
1788 struct afs_status_cb *scb;
1789 const __be32 *bp;
1790 u32 tmp;
1791 int ret;
1792
1793 _enter("{%u}", call->unmarshall);
1794
1795 switch (call->unmarshall) {
1796 case 0:
1797 afs_extract_to_tmp(call);
1798 call->unmarshall++;
1799 fallthrough;
1800
1801 /* Extract the file status count and array in two steps */
1802 case 1:
1803 _debug("extract status count");
1804 ret = afs_extract_data(call, true);
1805 if (ret < 0)
1806 return ret;
1807
1808 tmp = ntohl(call->tmp);
1809 _debug("status count: %u/%u", tmp, op->nr_files);
1810 if (tmp != op->nr_files)
1811 return afs_protocol_error(call, afs_eproto_ibulkst_count);
1812
1813 call->count = 0;
1814 call->unmarshall++;
1815 more_counts:
1816 afs_extract_to_buf(call, 21 * sizeof(__be32));
1817 fallthrough;
1818
1819 case 2:
1820 _debug("extract status array %u", call->count);
1821 ret = afs_extract_data(call, true);
1822 if (ret < 0)
1823 return ret;
1824
1825 switch (call->count) {
1826 case 0:
1827 scb = &op->file[0].scb;
1828 break;
1829 case 1:
1830 scb = &op->file[1].scb;
1831 break;
1832 default:
1833 scb = &op->more_files[call->count - 2].scb;
1834 break;
1835 }
1836
1837 bp = call->buffer;
1838 xdr_decode_AFSFetchStatus(&bp, call, scb);
1839
1840 call->count++;
1841 if (call->count < op->nr_files)
1842 goto more_counts;
1843
1844 call->count = 0;
1845 call->unmarshall++;
1846 afs_extract_to_tmp(call);
1847 fallthrough;
1848
1849 /* Extract the callback count and array in two steps */
1850 case 3:
1851 _debug("extract CB count");
1852 ret = afs_extract_data(call, true);
1853 if (ret < 0)
1854 return ret;
1855
1856 tmp = ntohl(call->tmp);
1857 _debug("CB count: %u", tmp);
1858 if (tmp != op->nr_files)
1859 return afs_protocol_error(call, afs_eproto_ibulkst_cb_count);
1860 call->count = 0;
1861 call->unmarshall++;
1862 more_cbs:
1863 afs_extract_to_buf(call, 3 * sizeof(__be32));
1864 fallthrough;
1865
1866 case 4:
1867 _debug("extract CB array");
1868 ret = afs_extract_data(call, true);
1869 if (ret < 0)
1870 return ret;
1871
1872 _debug("unmarshall CB array");
1873 switch (call->count) {
1874 case 0:
1875 scb = &op->file[0].scb;
1876 break;
1877 case 1:
1878 scb = &op->file[1].scb;
1879 break;
1880 default:
1881 scb = &op->more_files[call->count - 2].scb;
1882 break;
1883 }
1884
1885 bp = call->buffer;
1886 xdr_decode_AFSCallBack(&bp, call, scb);
1887 call->count++;
1888 if (call->count < op->nr_files)
1889 goto more_cbs;
1890
1891 afs_extract_to_buf(call, 6 * sizeof(__be32));
1892 call->unmarshall++;
1893 fallthrough;
1894
1895 case 5:
1896 ret = afs_extract_data(call, false);
1897 if (ret < 0)
1898 return ret;
1899
1900 bp = call->buffer;
1901 /* Unfortunately, prior to OpenAFS-1.6, volsync here is filled
1902 * with rubbish.
1903 */
1904 xdr_decode_AFSVolSync(&bp, NULL);
1905
1906 call->unmarshall++;
1907 fallthrough;
1908
1909 case 6:
1910 break;
1911 }
1912
1913 _leave(" = 0 [done]");
1914 return 0;
1915}
1916
1917static void afs_done_fs_inline_bulk_status(struct afs_call *call)
1918{
1919 if (call->error == -ECONNABORTED &&
1920 call->abort_code == RX_INVALID_OPERATION) {
1921 set_bit(AFS_SERVER_FL_NO_IBULK, &call->server->flags);
1922 if (call->op)
1923 set_bit(AFS_VOLUME_MAYBE_NO_IBULK, &call->op->volume->flags);
1924 }
1925}
1926
1927/*
1928 * FS.InlineBulkStatus operation type
1929 */
1930static const struct afs_call_type afs_RXFSInlineBulkStatus = {
1931 .name = "FS.InlineBulkStatus",
1932 .op = afs_FS_InlineBulkStatus,
1933 .deliver = afs_deliver_fs_inline_bulk_status,
1934 .done = afs_done_fs_inline_bulk_status,
1935 .destructor = afs_flat_call_destructor,
1936};
1937
1938/*
1939 * Fetch the status information for up to 50 files
1940 */
1941void afs_fs_inline_bulk_status(struct afs_operation *op)
1942{
1943 struct afs_vnode_param *dvp = &op->file[0];
1944 struct afs_vnode_param *vp = &op->file[1];
1945 struct afs_call *call;
1946 __be32 *bp;
1947 int i;
1948
1949 if (test_bit(AFS_SERVER_FL_NO_IBULK, &op->server->flags)) {
1950 afs_op_set_error(op, -ENOTSUPP);
1951 return;
1952 }
1953
1954 _enter(",%x,{%llx:%llu},%u",
1955 key_serial(op->key), vp->fid.vid, vp->fid.vnode, op->nr_files);
1956
1957 call = afs_alloc_flat_call(op->net, &afs_RXFSInlineBulkStatus,
1958 (2 + op->nr_files * 3) * 4,
1959 21 * 4);
1960 if (!call)
1961 return afs_op_nomem(op);
1962
1963 /* marshall the parameters */
1964 bp = call->request;
1965 *bp++ = htonl(FSINLINEBULKSTATUS);
1966 *bp++ = htonl(op->nr_files);
1967 *bp++ = htonl(dvp->fid.vid);
1968 *bp++ = htonl(dvp->fid.vnode);
1969 *bp++ = htonl(dvp->fid.unique);
1970 *bp++ = htonl(vp->fid.vid);
1971 *bp++ = htonl(vp->fid.vnode);
1972 *bp++ = htonl(vp->fid.unique);
1973 for (i = 0; i < op->nr_files - 2; i++) {
1974 *bp++ = htonl(op->more_files[i].fid.vid);
1975 *bp++ = htonl(op->more_files[i].fid.vnode);
1976 *bp++ = htonl(op->more_files[i].fid.unique);
1977 }
1978
1979 call->fid = vp->fid;
1980 trace_afs_make_fs_call(call, &vp->fid);
1981 afs_make_op_call(op, call, GFP_NOFS);
1982}
1983
1984/*
1985 * deliver reply data to an FS.FetchACL
1986 */
1987static int afs_deliver_fs_fetch_acl(struct afs_call *call)
1988{
1989 struct afs_operation *op = call->op;
1990 struct afs_vnode_param *vp = &op->file[0];
1991 struct afs_acl *acl;
1992 const __be32 *bp;
1993 unsigned int size;
1994 int ret;
1995
1996 _enter("{%u}", call->unmarshall);
1997
1998 switch (call->unmarshall) {
1999 case 0:
2000 afs_extract_to_tmp(call);
2001 call->unmarshall++;
2002 fallthrough;
2003
2004 /* extract the returned data length */
2005 case 1:
2006 ret = afs_extract_data(call, true);
2007 if (ret < 0)
2008 return ret;
2009
2010 size = call->count2 = ntohl(call->tmp);
2011 size = round_up(size, 4);
2012
2013 acl = kmalloc(struct_size(acl, data, size), GFP_KERNEL);
2014 if (!acl)
2015 return -ENOMEM;
2016 op->acl = acl;
2017 acl->size = call->count2;
2018 afs_extract_begin(call, acl->data, size);
2019 call->unmarshall++;
2020 fallthrough;
2021
2022 /* extract the returned data */
2023 case 2:
2024 ret = afs_extract_data(call, true);
2025 if (ret < 0)
2026 return ret;
2027
2028 afs_extract_to_buf(call, (21 + 6) * 4);
2029 call->unmarshall++;
2030 fallthrough;
2031
2032 /* extract the metadata */
2033 case 3:
2034 ret = afs_extract_data(call, false);
2035 if (ret < 0)
2036 return ret;
2037
2038 bp = call->buffer;
2039 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
2040 xdr_decode_AFSVolSync(&bp, &op->volsync);
2041
2042 call->unmarshall++;
2043 fallthrough;
2044
2045 case 4:
2046 break;
2047 }
2048
2049 _leave(" = 0 [done]");
2050 return 0;
2051}
2052
2053/*
2054 * FS.FetchACL operation type
2055 */
2056static const struct afs_call_type afs_RXFSFetchACL = {
2057 .name = "FS.FetchACL",
2058 .op = afs_FS_FetchACL,
2059 .deliver = afs_deliver_fs_fetch_acl,
2060};
2061
2062/*
2063 * Fetch the ACL for a file.
2064 */
2065void afs_fs_fetch_acl(struct afs_operation *op)
2066{
2067 struct afs_vnode_param *vp = &op->file[0];
2068 struct afs_call *call;
2069 __be32 *bp;
2070
2071 _enter(",%x,{%llx:%llu},,",
2072 key_serial(op->key), vp->fid.vid, vp->fid.vnode);
2073
2074 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchACL, 16, (21 + 6) * 4);
2075 if (!call)
2076 return afs_op_nomem(op);
2077
2078 /* marshall the parameters */
2079 bp = call->request;
2080 bp[0] = htonl(FSFETCHACL);
2081 bp[1] = htonl(vp->fid.vid);
2082 bp[2] = htonl(vp->fid.vnode);
2083 bp[3] = htonl(vp->fid.unique);
2084
2085 call->fid = vp->fid;
2086 trace_afs_make_fs_call(call, &vp->fid);
2087 afs_make_op_call(op, call, GFP_KERNEL);
2088}
2089
2090/*
2091 * FS.StoreACL operation type
2092 */
2093static const struct afs_call_type afs_RXFSStoreACL = {
2094 .name = "FS.StoreACL",
2095 .op = afs_FS_StoreACL,
2096 .deliver = afs_deliver_fs_file_status_and_vol,
2097 .destructor = afs_flat_call_destructor,
2098};
2099
2100/*
2101 * Fetch the ACL for a file.
2102 */
2103void afs_fs_store_acl(struct afs_operation *op)
2104{
2105 struct afs_vnode_param *vp = &op->file[0];
2106 struct afs_call *call;
2107 const struct afs_acl *acl = op->acl;
2108 size_t size;
2109 __be32 *bp;
2110
2111 _enter(",%x,{%llx:%llu},,",
2112 key_serial(op->key), vp->fid.vid, vp->fid.vnode);
2113
2114 size = round_up(acl->size, 4);
2115 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreACL,
2116 5 * 4 + size, (21 + 6) * 4);
2117 if (!call)
2118 return afs_op_nomem(op);
2119
2120 /* marshall the parameters */
2121 bp = call->request;
2122 bp[0] = htonl(FSSTOREACL);
2123 bp[1] = htonl(vp->fid.vid);
2124 bp[2] = htonl(vp->fid.vnode);
2125 bp[3] = htonl(vp->fid.unique);
2126 bp[4] = htonl(acl->size);
2127 memcpy(&bp[5], acl->data, acl->size);
2128 if (acl->size != size)
2129 memset((void *)&bp[5] + acl->size, 0, size - acl->size);
2130
2131 call->fid = vp->fid;
2132 trace_afs_make_fs_call(call, &vp->fid);
2133 afs_make_op_call(op, call, GFP_KERNEL);
2134}
Linux 6.x block layer and io_uring tree(s)