1
2
3
4
5
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
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
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
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
71
72
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);
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->reply_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++;
145 cb->expires_at = xdr_decode_expiry(call, ntohl(*bp++));
146 bp++;
147 scb->have_cb = true;
148 *_bp = bp;
149}
150
151
152
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++;
162 bp++;
163 bp++;
164 bp++;
165 bp++;
166 *_bp = bp;
167
168 if (volsync)
169 volsync->creation = creation;
170}
171
172
173
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;
207 *_bp = bp;
208}
209
210
211
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
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
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
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
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
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 trace_afs_make_fs_call(call, &vp->fid);
294 afs_make_op_call(op, call, GFP_NOFS);
295}
296
297
298
299
300static int afs_deliver_fs_fetch_data(struct afs_call *call)
301{
302 struct afs_operation *op = call->op;
303 struct afs_vnode_param *vp = &op->file[0];
304 struct afs_read *req = op->fetch.req;
305 const __be32 *bp;
306 int ret;
307
308 _enter("{%u,%zu,%zu/%llu}",
309 call->unmarshall, call->iov_len, iov_iter_count(call->iter),
310 req->actual_len);
311
312 switch (call->unmarshall) {
313 case 0:
314 req->actual_len = 0;
315 call->unmarshall++;
316 if (call->operation_ID == FSFETCHDATA64) {
317 afs_extract_to_tmp64(call);
318 } else {
319 call->tmp_u = htonl(0);
320 afs_extract_to_tmp(call);
321 }
322 fallthrough;
323
324
325
326
327
328 case 1:
329 _debug("extract data length");
330 ret = afs_extract_data(call, true);
331 if (ret < 0)
332 return ret;
333
334 req->actual_len = be64_to_cpu(call->tmp64);
335 _debug("DATA length: %llu", req->actual_len);
336
337 if (req->actual_len == 0)
338 goto no_more_data;
339
340 call->iter = req->iter;
341 call->iov_len = min(req->actual_len, req->len);
342 call->unmarshall++;
343 fallthrough;
344
345
346 case 2:
347 _debug("extract data %zu/%llu",
348 iov_iter_count(call->iter), req->actual_len);
349
350 ret = afs_extract_data(call, true);
351 if (ret < 0)
352 return ret;
353
354 call->iter = &call->def_iter;
355 if (req->actual_len <= req->len)
356 goto no_more_data;
357
358
359 afs_extract_discard(call, req->actual_len - req->len);
360 call->unmarshall = 3;
361 fallthrough;
362
363 case 3:
364 _debug("extract discard %zu/%llu",
365 iov_iter_count(call->iter), req->actual_len - req->len);
366
367 ret = afs_extract_data(call, true);
368 if (ret < 0)
369 return ret;
370
371 no_more_data:
372 call->unmarshall = 4;
373 afs_extract_to_buf(call, (21 + 3 + 6) * 4);
374 fallthrough;
375
376
377 case 4:
378 ret = afs_extract_data(call, false);
379 if (ret < 0)
380 return ret;
381
382 bp = call->buffer;
383 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
384 xdr_decode_AFSCallBack(&bp, call, &vp->scb);
385 xdr_decode_AFSVolSync(&bp, &op->volsync);
386
387 req->data_version = vp->scb.status.data_version;
388 req->file_size = vp->scb.status.size;
389
390 call->unmarshall++;
391 fallthrough;
392
393 case 5:
394 break;
395 }
396
397 _leave(" = 0 [done]");
398 return 0;
399}
400
401
402
403
404static const struct afs_call_type afs_RXFSFetchData = {
405 .name = "FS.FetchData",
406 .op = afs_FS_FetchData,
407 .deliver = afs_deliver_fs_fetch_data,
408 .destructor = afs_flat_call_destructor,
409};
410
411static const struct afs_call_type afs_RXFSFetchData64 = {
412 .name = "FS.FetchData64",
413 .op = afs_FS_FetchData64,
414 .deliver = afs_deliver_fs_fetch_data,
415 .destructor = afs_flat_call_destructor,
416};
417
418
419
420
421static void afs_fs_fetch_data64(struct afs_operation *op)
422{
423 struct afs_vnode_param *vp = &op->file[0];
424 struct afs_read *req = op->fetch.req;
425 struct afs_call *call;
426 __be32 *bp;
427
428 _enter("");
429
430 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchData64, 32, (21 + 3 + 6) * 4);
431 if (!call)
432 return afs_op_nomem(op);
433
434
435 bp = call->request;
436 bp[0] = htonl(FSFETCHDATA64);
437 bp[1] = htonl(vp->fid.vid);
438 bp[2] = htonl(vp->fid.vnode);
439 bp[3] = htonl(vp->fid.unique);
440 bp[4] = htonl(upper_32_bits(req->pos));
441 bp[5] = htonl(lower_32_bits(req->pos));
442 bp[6] = 0;
443 bp[7] = htonl(lower_32_bits(req->len));
444
445 trace_afs_make_fs_call(call, &vp->fid);
446 afs_make_op_call(op, call, GFP_NOFS);
447}
448
449
450
451
452void afs_fs_fetch_data(struct afs_operation *op)
453{
454 struct afs_vnode_param *vp = &op->file[0];
455 struct afs_call *call;
456 struct afs_read *req = op->fetch.req;
457 __be32 *bp;
458
459 if (upper_32_bits(req->pos) ||
460 upper_32_bits(req->len) ||
461 upper_32_bits(req->pos + req->len))
462 return afs_fs_fetch_data64(op);
463
464 _enter("");
465
466 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchData, 24, (21 + 3 + 6) * 4);
467 if (!call)
468 return afs_op_nomem(op);
469
470 req->call_debug_id = call->debug_id;
471
472
473 bp = call->request;
474 bp[0] = htonl(FSFETCHDATA);
475 bp[1] = htonl(vp->fid.vid);
476 bp[2] = htonl(vp->fid.vnode);
477 bp[3] = htonl(vp->fid.unique);
478 bp[4] = htonl(lower_32_bits(req->pos));
479 bp[5] = htonl(lower_32_bits(req->len));
480
481 trace_afs_make_fs_call(call, &vp->fid);
482 afs_make_op_call(op, call, GFP_NOFS);
483}
484
485
486
487
488static int afs_deliver_fs_create_vnode(struct afs_call *call)
489{
490 struct afs_operation *op = call->op;
491 struct afs_vnode_param *dvp = &op->file[0];
492 struct afs_vnode_param *vp = &op->file[1];
493 const __be32 *bp;
494 int ret;
495
496 ret = afs_transfer_reply(call);
497 if (ret < 0)
498 return ret;
499
500
501 bp = call->buffer;
502 xdr_decode_AFSFid(&bp, &op->file[1].fid);
503 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
504 xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
505 xdr_decode_AFSCallBack(&bp, call, &vp->scb);
506 xdr_decode_AFSVolSync(&bp, &op->volsync);
507
508 _leave(" = 0 [done]");
509 return 0;
510}
511
512
513
514
515static const struct afs_call_type afs_RXFSCreateFile = {
516 .name = "FS.CreateFile",
517 .op = afs_FS_CreateFile,
518 .deliver = afs_deliver_fs_create_vnode,
519 .destructor = afs_flat_call_destructor,
520};
521
522
523
524
525void afs_fs_create_file(struct afs_operation *op)
526{
527 const struct qstr *name = &op->dentry->d_name;
528 struct afs_vnode_param *dvp = &op->file[0];
529 struct afs_call *call;
530 size_t namesz, reqsz, padsz;
531 __be32 *bp;
532
533 _enter("");
534
535 namesz = name->len;
536 padsz = (4 - (namesz & 3)) & 3;
537 reqsz = (5 * 4) + namesz + padsz + (6 * 4);
538
539 call = afs_alloc_flat_call(op->net, &afs_RXFSCreateFile,
540 reqsz, (3 + 21 + 21 + 3 + 6) * 4);
541 if (!call)
542 return afs_op_nomem(op);
543
544
545 bp = call->request;
546 *bp++ = htonl(FSCREATEFILE);
547 *bp++ = htonl(dvp->fid.vid);
548 *bp++ = htonl(dvp->fid.vnode);
549 *bp++ = htonl(dvp->fid.unique);
550 *bp++ = htonl(namesz);
551 memcpy(bp, name->name, namesz);
552 bp = (void *) bp + namesz;
553 if (padsz > 0) {
554 memset(bp, 0, padsz);
555 bp = (void *) bp + padsz;
556 }
557 *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME);
558 *bp++ = htonl(op->mtime.tv_sec);
559 *bp++ = 0;
560 *bp++ = 0;
561 *bp++ = htonl(op->create.mode & S_IALLUGO);
562 *bp++ = 0;
563
564 trace_afs_make_fs_call1(call, &dvp->fid, name);
565 afs_make_op_call(op, call, GFP_NOFS);
566}
567
568static const struct afs_call_type afs_RXFSMakeDir = {
569 .name = "FS.MakeDir",
570 .op = afs_FS_MakeDir,
571 .deliver = afs_deliver_fs_create_vnode,
572 .destructor = afs_flat_call_destructor,
573};
574
575
576
577
578void afs_fs_make_dir(struct afs_operation *op)
579{
580 const struct qstr *name = &op->dentry->d_name;
581 struct afs_vnode_param *dvp = &op->file[0];
582 struct afs_call *call;
583 size_t namesz, reqsz, padsz;
584 __be32 *bp;
585
586 _enter("");
587
588 namesz = name->len;
589 padsz = (4 - (namesz & 3)) & 3;
590 reqsz = (5 * 4) + namesz + padsz + (6 * 4);
591
592 call = afs_alloc_flat_call(op->net, &afs_RXFSMakeDir,
593 reqsz, (3 + 21 + 21 + 3 + 6) * 4);
594 if (!call)
595 return afs_op_nomem(op);
596
597
598 bp = call->request;
599 *bp++ = htonl(FSMAKEDIR);
600 *bp++ = htonl(dvp->fid.vid);
601 *bp++ = htonl(dvp->fid.vnode);
602 *bp++ = htonl(dvp->fid.unique);
603 *bp++ = htonl(namesz);
604 memcpy(bp, name->name, namesz);
605 bp = (void *) bp + namesz;
606 if (padsz > 0) {
607 memset(bp, 0, padsz);
608 bp = (void *) bp + padsz;
609 }
610 *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME);
611 *bp++ = htonl(op->mtime.tv_sec);
612 *bp++ = 0;
613 *bp++ = 0;
614 *bp++ = htonl(op->create.mode & S_IALLUGO);
615 *bp++ = 0;
616
617 trace_afs_make_fs_call1(call, &dvp->fid, name);
618 afs_make_op_call(op, call, GFP_NOFS);
619}
620
621
622
623
624static int afs_deliver_fs_file_status_and_vol(struct afs_call *call)
625{
626 struct afs_operation *op = call->op;
627 struct afs_vnode_param *vp = &op->file[0];
628 const __be32 *bp;
629 int ret;
630
631 ret = afs_transfer_reply(call);
632 if (ret < 0)
633 return ret;
634
635
636 bp = call->buffer;
637 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
638 xdr_decode_AFSVolSync(&bp, &op->volsync);
639
640 _leave(" = 0 [done]");
641 return 0;
642}
643
644
645
646
647static const struct afs_call_type afs_RXFSRemoveFile = {
648 .name = "FS.RemoveFile",
649 .op = afs_FS_RemoveFile,
650 .deliver = afs_deliver_fs_file_status_and_vol,
651 .destructor = afs_flat_call_destructor,
652};
653
654
655
656
657void afs_fs_remove_file(struct afs_operation *op)
658{
659 const struct qstr *name = &op->dentry->d_name;
660 struct afs_vnode_param *dvp = &op->file[0];
661 struct afs_call *call;
662 size_t namesz, reqsz, padsz;
663 __be32 *bp;
664
665 _enter("");
666
667 namesz = name->len;
668 padsz = (4 - (namesz & 3)) & 3;
669 reqsz = (5 * 4) + namesz + padsz;
670
671 call = afs_alloc_flat_call(op->net, &afs_RXFSRemoveFile,
672 reqsz, (21 + 6) * 4);
673 if (!call)
674 return afs_op_nomem(op);
675
676
677 bp = call->request;
678 *bp++ = htonl(FSREMOVEFILE);
679 *bp++ = htonl(dvp->fid.vid);
680 *bp++ = htonl(dvp->fid.vnode);
681 *bp++ = htonl(dvp->fid.unique);
682 *bp++ = htonl(namesz);
683 memcpy(bp, name->name, namesz);
684 bp = (void *) bp + namesz;
685 if (padsz > 0) {
686 memset(bp, 0, padsz);
687 bp = (void *) bp + padsz;
688 }
689
690 trace_afs_make_fs_call1(call, &dvp->fid, name);
691 afs_make_op_call(op, call, GFP_NOFS);
692}
693
694static const struct afs_call_type afs_RXFSRemoveDir = {
695 .name = "FS.RemoveDir",
696 .op = afs_FS_RemoveDir,
697 .deliver = afs_deliver_fs_file_status_and_vol,
698 .destructor = afs_flat_call_destructor,
699};
700
701
702
703
704void afs_fs_remove_dir(struct afs_operation *op)
705{
706 const struct qstr *name = &op->dentry->d_name;
707 struct afs_vnode_param *dvp = &op->file[0];
708 struct afs_call *call;
709 size_t namesz, reqsz, padsz;
710 __be32 *bp;
711
712 _enter("");
713
714 namesz = name->len;
715 padsz = (4 - (namesz & 3)) & 3;
716 reqsz = (5 * 4) + namesz + padsz;
717
718 call = afs_alloc_flat_call(op->net, &afs_RXFSRemoveDir,
719 reqsz, (21 + 6) * 4);
720 if (!call)
721 return afs_op_nomem(op);
722
723
724 bp = call->request;
725 *bp++ = htonl(FSREMOVEDIR);
726 *bp++ = htonl(dvp->fid.vid);
727 *bp++ = htonl(dvp->fid.vnode);
728 *bp++ = htonl(dvp->fid.unique);
729 *bp++ = htonl(namesz);
730 memcpy(bp, name->name, namesz);
731 bp = (void *) bp + namesz;
732 if (padsz > 0) {
733 memset(bp, 0, padsz);
734 bp = (void *) bp + padsz;
735 }
736
737 trace_afs_make_fs_call1(call, &dvp->fid, name);
738 afs_make_op_call(op, call, GFP_NOFS);
739}
740
741
742
743
744static int afs_deliver_fs_link(struct afs_call *call)
745{
746 struct afs_operation *op = call->op;
747 struct afs_vnode_param *dvp = &op->file[0];
748 struct afs_vnode_param *vp = &op->file[1];
749 const __be32 *bp;
750 int ret;
751
752 _enter("{%u}", call->unmarshall);
753
754 ret = afs_transfer_reply(call);
755 if (ret < 0)
756 return ret;
757
758
759 bp = call->buffer;
760 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
761 xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
762 xdr_decode_AFSVolSync(&bp, &op->volsync);
763
764 _leave(" = 0 [done]");
765 return 0;
766}
767
768
769
770
771static const struct afs_call_type afs_RXFSLink = {
772 .name = "FS.Link",
773 .op = afs_FS_Link,
774 .deliver = afs_deliver_fs_link,
775 .destructor = afs_flat_call_destructor,
776};
777
778
779
780
781void afs_fs_link(struct afs_operation *op)
782{
783 const struct qstr *name = &op->dentry->d_name;
784 struct afs_vnode_param *dvp = &op->file[0];
785 struct afs_vnode_param *vp = &op->file[1];
786 struct afs_call *call;
787 size_t namesz, reqsz, padsz;
788 __be32 *bp;
789
790 _enter("");
791
792 namesz = name->len;
793 padsz = (4 - (namesz & 3)) & 3;
794 reqsz = (5 * 4) + namesz + padsz + (3 * 4);
795
796 call = afs_alloc_flat_call(op->net, &afs_RXFSLink, reqsz, (21 + 21 + 6) * 4);
797 if (!call)
798 return afs_op_nomem(op);
799
800
801 bp = call->request;
802 *bp++ = htonl(FSLINK);
803 *bp++ = htonl(dvp->fid.vid);
804 *bp++ = htonl(dvp->fid.vnode);
805 *bp++ = htonl(dvp->fid.unique);
806 *bp++ = htonl(namesz);
807 memcpy(bp, name->name, namesz);
808 bp = (void *) bp + namesz;
809 if (padsz > 0) {
810 memset(bp, 0, padsz);
811 bp = (void *) bp + padsz;
812 }
813 *bp++ = htonl(vp->fid.vid);
814 *bp++ = htonl(vp->fid.vnode);
815 *bp++ = htonl(vp->fid.unique);
816
817 trace_afs_make_fs_call1(call, &vp->fid, name);
818 afs_make_op_call(op, call, GFP_NOFS);
819}
820
821
822
823
824static int afs_deliver_fs_symlink(struct afs_call *call)
825{
826 struct afs_operation *op = call->op;
827 struct afs_vnode_param *dvp = &op->file[0];
828 struct afs_vnode_param *vp = &op->file[1];
829 const __be32 *bp;
830 int ret;
831
832 _enter("{%u}", call->unmarshall);
833
834 ret = afs_transfer_reply(call);
835 if (ret < 0)
836 return ret;
837
838
839 bp = call->buffer;
840 xdr_decode_AFSFid(&bp, &vp->fid);
841 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
842 xdr_decode_AFSFetchStatus(&bp, call, &dvp->scb);
843 xdr_decode_AFSVolSync(&bp, &op->volsync);
844
845 _leave(" = 0 [done]");
846 return 0;
847}
848
849
850
851
852static const struct afs_call_type afs_RXFSSymlink = {
853 .name = "FS.Symlink",
854 .op = afs_FS_Symlink,
855 .deliver = afs_deliver_fs_symlink,
856 .destructor = afs_flat_call_destructor,
857};
858
859
860
861
862void afs_fs_symlink(struct afs_operation *op)
863{
864 const struct qstr *name = &op->dentry->d_name;
865 struct afs_vnode_param *dvp = &op->file[0];
866 struct afs_call *call;
867 size_t namesz, reqsz, padsz, c_namesz, c_padsz;
868 __be32 *bp;
869
870 _enter("");
871
872 namesz = name->len;
873 padsz = (4 - (namesz & 3)) & 3;
874
875 c_namesz = strlen(op->create.symlink);
876 c_padsz = (4 - (c_namesz & 3)) & 3;
877
878 reqsz = (6 * 4) + namesz + padsz + c_namesz + c_padsz + (6 * 4);
879
880 call = afs_alloc_flat_call(op->net, &afs_RXFSSymlink, reqsz,
881 (3 + 21 + 21 + 6) * 4);
882 if (!call)
883 return afs_op_nomem(op);
884
885
886 bp = call->request;
887 *bp++ = htonl(FSSYMLINK);
888 *bp++ = htonl(dvp->fid.vid);
889 *bp++ = htonl(dvp->fid.vnode);
890 *bp++ = htonl(dvp->fid.unique);
891 *bp++ = htonl(namesz);
892 memcpy(bp, name->name, namesz);
893 bp = (void *) bp + namesz;
894 if (padsz > 0) {
895 memset(bp, 0, padsz);
896 bp = (void *) bp + padsz;
897 }
898 *bp++ = htonl(c_namesz);
899 memcpy(bp, op->create.symlink, c_namesz);
900 bp = (void *) bp + c_namesz;
901 if (c_padsz > 0) {
902 memset(bp, 0, c_padsz);
903 bp = (void *) bp + c_padsz;
904 }
905 *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME);
906 *bp++ = htonl(op->mtime.tv_sec);
907 *bp++ = 0;
908 *bp++ = 0;
909 *bp++ = htonl(S_IRWXUGO);
910 *bp++ = 0;
911
912 trace_afs_make_fs_call1(call, &dvp->fid, name);
913 afs_make_op_call(op, call, GFP_NOFS);
914}
915
916
917
918
919static int afs_deliver_fs_rename(struct afs_call *call)
920{
921 struct afs_operation *op = call->op;
922 struct afs_vnode_param *orig_dvp = &op->file[0];
923 struct afs_vnode_param *new_dvp = &op->file[1];
924 const __be32 *bp;
925 int ret;
926
927 ret = afs_transfer_reply(call);
928 if (ret < 0)
929 return ret;
930
931 bp = call->buffer;
932
933
934
935 xdr_decode_AFSFetchStatus(&bp, call, &orig_dvp->scb);
936 xdr_decode_AFSFetchStatus(&bp, call, &new_dvp->scb);
937 xdr_decode_AFSVolSync(&bp, &op->volsync);
938
939 _leave(" = 0 [done]");
940 return 0;
941}
942
943
944
945
946static const struct afs_call_type afs_RXFSRename = {
947 .name = "FS.Rename",
948 .op = afs_FS_Rename,
949 .deliver = afs_deliver_fs_rename,
950 .destructor = afs_flat_call_destructor,
951};
952
953
954
955
956void afs_fs_rename(struct afs_operation *op)
957{
958 struct afs_vnode_param *orig_dvp = &op->file[0];
959 struct afs_vnode_param *new_dvp = &op->file[1];
960 const struct qstr *orig_name = &op->dentry->d_name;
961 const struct qstr *new_name = &op->dentry_2->d_name;
962 struct afs_call *call;
963 size_t reqsz, o_namesz, o_padsz, n_namesz, n_padsz;
964 __be32 *bp;
965
966 _enter("");
967
968 o_namesz = orig_name->len;
969 o_padsz = (4 - (o_namesz & 3)) & 3;
970
971 n_namesz = new_name->len;
972 n_padsz = (4 - (n_namesz & 3)) & 3;
973
974 reqsz = (4 * 4) +
975 4 + o_namesz + o_padsz +
976 (3 * 4) +
977 4 + n_namesz + n_padsz;
978
979 call = afs_alloc_flat_call(op->net, &afs_RXFSRename, reqsz, (21 + 21 + 6) * 4);
980 if (!call)
981 return afs_op_nomem(op);
982
983
984 bp = call->request;
985 *bp++ = htonl(FSRENAME);
986 *bp++ = htonl(orig_dvp->fid.vid);
987 *bp++ = htonl(orig_dvp->fid.vnode);
988 *bp++ = htonl(orig_dvp->fid.unique);
989 *bp++ = htonl(o_namesz);
990 memcpy(bp, orig_name->name, o_namesz);
991 bp = (void *) bp + o_namesz;
992 if (o_padsz > 0) {
993 memset(bp, 0, o_padsz);
994 bp = (void *) bp + o_padsz;
995 }
996
997 *bp++ = htonl(new_dvp->fid.vid);
998 *bp++ = htonl(new_dvp->fid.vnode);
999 *bp++ = htonl(new_dvp->fid.unique);
1000 *bp++ = htonl(n_namesz);
1001 memcpy(bp, new_name->name, n_namesz);
1002 bp = (void *) bp + n_namesz;
1003 if (n_padsz > 0) {
1004 memset(bp, 0, n_padsz);
1005 bp = (void *) bp + n_padsz;
1006 }
1007
1008 trace_afs_make_fs_call2(call, &orig_dvp->fid, orig_name, new_name);
1009 afs_make_op_call(op, call, GFP_NOFS);
1010}
1011
1012
1013
1014
1015static int afs_deliver_fs_store_data(struct afs_call *call)
1016{
1017 struct afs_operation *op = call->op;
1018 struct afs_vnode_param *vp = &op->file[0];
1019 const __be32 *bp;
1020 int ret;
1021
1022 _enter("");
1023
1024 ret = afs_transfer_reply(call);
1025 if (ret < 0)
1026 return ret;
1027
1028
1029 bp = call->buffer;
1030 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
1031 xdr_decode_AFSVolSync(&bp, &op->volsync);
1032
1033 _leave(" = 0 [done]");
1034 return 0;
1035}
1036
1037
1038
1039
1040static const struct afs_call_type afs_RXFSStoreData = {
1041 .name = "FS.StoreData",
1042 .op = afs_FS_StoreData,
1043 .deliver = afs_deliver_fs_store_data,
1044 .destructor = afs_flat_call_destructor,
1045};
1046
1047static const struct afs_call_type afs_RXFSStoreData64 = {
1048 .name = "FS.StoreData64",
1049 .op = afs_FS_StoreData64,
1050 .deliver = afs_deliver_fs_store_data,
1051 .destructor = afs_flat_call_destructor,
1052};
1053
1054
1055
1056
1057static void afs_fs_store_data64(struct afs_operation *op)
1058{
1059 struct afs_vnode_param *vp = &op->file[0];
1060 struct afs_call *call;
1061 __be32 *bp;
1062
1063 _enter(",%x,{%llx:%llu},,",
1064 key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1065
1066 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData64,
1067 (4 + 6 + 3 * 2) * 4,
1068 (21 + 6) * 4);
1069 if (!call)
1070 return afs_op_nomem(op);
1071
1072 call->write_iter = op->store.write_iter;
1073
1074
1075 bp = call->request;
1076 *bp++ = htonl(FSSTOREDATA64);
1077 *bp++ = htonl(vp->fid.vid);
1078 *bp++ = htonl(vp->fid.vnode);
1079 *bp++ = htonl(vp->fid.unique);
1080
1081 *bp++ = htonl(AFS_SET_MTIME);
1082 *bp++ = htonl(op->mtime.tv_sec);
1083 *bp++ = 0;
1084 *bp++ = 0;
1085 *bp++ = 0;
1086 *bp++ = 0;
1087
1088 *bp++ = htonl(upper_32_bits(op->store.pos));
1089 *bp++ = htonl(lower_32_bits(op->store.pos));
1090 *bp++ = htonl(upper_32_bits(op->store.size));
1091 *bp++ = htonl(lower_32_bits(op->store.size));
1092 *bp++ = htonl(upper_32_bits(op->store.i_size));
1093 *bp++ = htonl(lower_32_bits(op->store.i_size));
1094
1095 trace_afs_make_fs_call(call, &vp->fid);
1096 afs_make_op_call(op, call, GFP_NOFS);
1097}
1098
1099
1100
1101
1102void afs_fs_store_data(struct afs_operation *op)
1103{
1104 struct afs_vnode_param *vp = &op->file[0];
1105 struct afs_call *call;
1106 __be32 *bp;
1107
1108 _enter(",%x,{%llx:%llu},,",
1109 key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1110
1111 _debug("size %llx, at %llx, i_size %llx",
1112 (unsigned long long)op->store.size,
1113 (unsigned long long)op->store.pos,
1114 (unsigned long long)op->store.i_size);
1115
1116 if (upper_32_bits(op->store.pos) ||
1117 upper_32_bits(op->store.size) ||
1118 upper_32_bits(op->store.i_size))
1119 return afs_fs_store_data64(op);
1120
1121 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData,
1122 (4 + 6 + 3) * 4,
1123 (21 + 6) * 4);
1124 if (!call)
1125 return afs_op_nomem(op);
1126
1127 call->write_iter = op->store.write_iter;
1128
1129
1130 bp = call->request;
1131 *bp++ = htonl(FSSTOREDATA);
1132 *bp++ = htonl(vp->fid.vid);
1133 *bp++ = htonl(vp->fid.vnode);
1134 *bp++ = htonl(vp->fid.unique);
1135
1136 *bp++ = htonl(AFS_SET_MTIME);
1137 *bp++ = htonl(op->mtime.tv_sec);
1138 *bp++ = 0;
1139 *bp++ = 0;
1140 *bp++ = 0;
1141 *bp++ = 0;
1142
1143 *bp++ = htonl(lower_32_bits(op->store.pos));
1144 *bp++ = htonl(lower_32_bits(op->store.size));
1145 *bp++ = htonl(lower_32_bits(op->store.i_size));
1146
1147 trace_afs_make_fs_call(call, &vp->fid);
1148 afs_make_op_call(op, call, GFP_NOFS);
1149}
1150
1151
1152
1153
1154static const struct afs_call_type afs_RXFSStoreStatus = {
1155 .name = "FS.StoreStatus",
1156 .op = afs_FS_StoreStatus,
1157 .deliver = afs_deliver_fs_store_data,
1158 .destructor = afs_flat_call_destructor,
1159};
1160
1161static const struct afs_call_type afs_RXFSStoreData_as_Status = {
1162 .name = "FS.StoreData",
1163 .op = afs_FS_StoreData,
1164 .deliver = afs_deliver_fs_store_data,
1165 .destructor = afs_flat_call_destructor,
1166};
1167
1168static const struct afs_call_type afs_RXFSStoreData64_as_Status = {
1169 .name = "FS.StoreData64",
1170 .op = afs_FS_StoreData64,
1171 .deliver = afs_deliver_fs_store_data,
1172 .destructor = afs_flat_call_destructor,
1173};
1174
1175
1176
1177
1178
1179static void afs_fs_setattr_size64(struct afs_operation *op)
1180{
1181 struct afs_vnode_param *vp = &op->file[0];
1182 struct afs_call *call;
1183 struct iattr *attr = op->setattr.attr;
1184 __be32 *bp;
1185
1186 _enter(",%x,{%llx:%llu},,",
1187 key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1188
1189 ASSERT(attr->ia_valid & ATTR_SIZE);
1190
1191 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData64_as_Status,
1192 (4 + 6 + 3 * 2) * 4,
1193 (21 + 6) * 4);
1194 if (!call)
1195 return afs_op_nomem(op);
1196
1197
1198 bp = call->request;
1199 *bp++ = htonl(FSSTOREDATA64);
1200 *bp++ = htonl(vp->fid.vid);
1201 *bp++ = htonl(vp->fid.vnode);
1202 *bp++ = htonl(vp->fid.unique);
1203
1204 xdr_encode_AFS_StoreStatus(&bp, attr);
1205
1206 *bp++ = htonl(upper_32_bits(attr->ia_size));
1207 *bp++ = htonl(lower_32_bits(attr->ia_size));
1208 *bp++ = 0;
1209 *bp++ = 0;
1210 *bp++ = htonl(upper_32_bits(attr->ia_size));
1211 *bp++ = htonl(lower_32_bits(attr->ia_size));
1212
1213 trace_afs_make_fs_call(call, &vp->fid);
1214 afs_make_op_call(op, call, GFP_NOFS);
1215}
1216
1217
1218
1219
1220
1221static void afs_fs_setattr_size(struct afs_operation *op)
1222{
1223 struct afs_vnode_param *vp = &op->file[0];
1224 struct afs_call *call;
1225 struct iattr *attr = op->setattr.attr;
1226 __be32 *bp;
1227
1228 _enter(",%x,{%llx:%llu},,",
1229 key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1230
1231 ASSERT(attr->ia_valid & ATTR_SIZE);
1232 if (upper_32_bits(attr->ia_size))
1233 return afs_fs_setattr_size64(op);
1234
1235 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreData_as_Status,
1236 (4 + 6 + 3) * 4,
1237 (21 + 6) * 4);
1238 if (!call)
1239 return afs_op_nomem(op);
1240
1241
1242 bp = call->request;
1243 *bp++ = htonl(FSSTOREDATA);
1244 *bp++ = htonl(vp->fid.vid);
1245 *bp++ = htonl(vp->fid.vnode);
1246 *bp++ = htonl(vp->fid.unique);
1247
1248 xdr_encode_AFS_StoreStatus(&bp, attr);
1249
1250 *bp++ = htonl(attr->ia_size);
1251 *bp++ = 0;
1252 *bp++ = htonl(attr->ia_size);
1253
1254 trace_afs_make_fs_call(call, &vp->fid);
1255 afs_make_op_call(op, call, GFP_NOFS);
1256}
1257
1258
1259
1260
1261
1262void afs_fs_setattr(struct afs_operation *op)
1263{
1264 struct afs_vnode_param *vp = &op->file[0];
1265 struct afs_call *call;
1266 struct iattr *attr = op->setattr.attr;
1267 __be32 *bp;
1268
1269 if (attr->ia_valid & ATTR_SIZE)
1270 return afs_fs_setattr_size(op);
1271
1272 _enter(",%x,{%llx:%llu},,",
1273 key_serial(op->key), vp->fid.vid, vp->fid.vnode);
1274
1275 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreStatus,
1276 (4 + 6) * 4,
1277 (21 + 6) * 4);
1278 if (!call)
1279 return afs_op_nomem(op);
1280
1281
1282 bp = call->request;
1283 *bp++ = htonl(FSSTORESTATUS);
1284 *bp++ = htonl(vp->fid.vid);
1285 *bp++ = htonl(vp->fid.vnode);
1286 *bp++ = htonl(vp->fid.unique);
1287
1288 xdr_encode_AFS_StoreStatus(&bp, op->setattr.attr);
1289
1290 trace_afs_make_fs_call(call, &vp->fid);
1291 afs_make_op_call(op, call, GFP_NOFS);
1292}
1293
1294
1295
1296
1297static int afs_deliver_fs_get_volume_status(struct afs_call *call)
1298{
1299 struct afs_operation *op = call->op;
1300 const __be32 *bp;
1301 char *p;
1302 u32 size;
1303 int ret;
1304
1305 _enter("{%u}", call->unmarshall);
1306
1307 switch (call->unmarshall) {
1308 case 0:
1309 call->unmarshall++;
1310 afs_extract_to_buf(call, 12 * 4);
1311 fallthrough;
1312
1313
1314 case 1:
1315 _debug("extract status");
1316 ret = afs_extract_data(call, true);
1317 if (ret < 0)
1318 return ret;
1319
1320 bp = call->buffer;
1321 xdr_decode_AFSFetchVolumeStatus(&bp, &op->volstatus.vs);
1322 call->unmarshall++;
1323 afs_extract_to_tmp(call);
1324 fallthrough;
1325
1326
1327 case 2:
1328 ret = afs_extract_data(call, true);
1329 if (ret < 0)
1330 return ret;
1331
1332 call->count = ntohl(call->tmp);
1333 _debug("volname length: %u", call->count);
1334 if (call->count >= AFSNAMEMAX)
1335 return afs_protocol_error(call, afs_eproto_volname_len);
1336 size = (call->count + 3) & ~3;
1337 afs_extract_to_buf(call, size);
1338 call->unmarshall++;
1339 fallthrough;
1340
1341
1342 case 3:
1343 _debug("extract volname");
1344 ret = afs_extract_data(call, true);
1345 if (ret < 0)
1346 return ret;
1347
1348 p = call->buffer;
1349 p[call->count] = 0;
1350 _debug("volname '%s'", p);
1351 afs_extract_to_tmp(call);
1352 call->unmarshall++;
1353 fallthrough;
1354
1355
1356 case 4:
1357 ret = afs_extract_data(call, true);
1358 if (ret < 0)
1359 return ret;
1360
1361 call->count = ntohl(call->tmp);
1362 _debug("offline msg length: %u", call->count);
1363 if (call->count >= AFSNAMEMAX)
1364 return afs_protocol_error(call, afs_eproto_offline_msg_len);
1365 size = (call->count + 3) & ~3;
1366 afs_extract_to_buf(call, size);
1367 call->unmarshall++;
1368 fallthrough;
1369
1370
1371 case 5:
1372 _debug("extract offline");
1373 ret = afs_extract_data(call, true);
1374 if (ret < 0)
1375 return ret;
1376
1377 p = call->buffer;
1378 p[call->count] = 0;
1379 _debug("offline '%s'", p);
1380
1381 afs_extract_to_tmp(call);
1382 call->unmarshall++;
1383 fallthrough;
1384
1385
1386 case 6:
1387 ret = afs_extract_data(call, true);
1388 if (ret < 0)
1389 return ret;
1390
1391 call->count = ntohl(call->tmp);
1392 _debug("motd length: %u", call->count);
1393 if (call->count >= AFSNAMEMAX)
1394 return afs_protocol_error(call, afs_eproto_motd_len);
1395 size = (call->count + 3) & ~3;
1396 afs_extract_to_buf(call, size);
1397 call->unmarshall++;
1398 fallthrough;
1399
1400
1401 case 7:
1402 _debug("extract motd");
1403 ret = afs_extract_data(call, false);
1404 if (ret < 0)
1405 return ret;
1406
1407 p = call->buffer;
1408 p[call->count] = 0;
1409 _debug("motd '%s'", p);
1410
1411 call->unmarshall++;
1412 fallthrough;
1413
1414 case 8:
1415 break;
1416 }
1417
1418 _leave(" = 0 [done]");
1419 return 0;
1420}
1421
1422
1423
1424
1425static const struct afs_call_type afs_RXFSGetVolumeStatus = {
1426 .name = "FS.GetVolumeStatus",
1427 .op = afs_FS_GetVolumeStatus,
1428 .deliver = afs_deliver_fs_get_volume_status,
1429 .destructor = afs_flat_call_destructor,
1430};
1431
1432
1433
1434
1435void afs_fs_get_volume_status(struct afs_operation *op)
1436{
1437 struct afs_vnode_param *vp = &op->file[0];
1438 struct afs_call *call;
1439 __be32 *bp;
1440
1441 _enter("");
1442
1443 call = afs_alloc_flat_call(op->net, &afs_RXFSGetVolumeStatus, 2 * 4,
1444 max(12 * 4, AFSOPAQUEMAX + 1));
1445 if (!call)
1446 return afs_op_nomem(op);
1447
1448
1449 bp = call->request;
1450 bp[0] = htonl(FSGETVOLUMESTATUS);
1451 bp[1] = htonl(vp->fid.vid);
1452
1453 trace_afs_make_fs_call(call, &vp->fid);
1454 afs_make_op_call(op, call, GFP_NOFS);
1455}
1456
1457
1458
1459
1460static int afs_deliver_fs_xxxx_lock(struct afs_call *call)
1461{
1462 struct afs_operation *op = call->op;
1463 const __be32 *bp;
1464 int ret;
1465
1466 _enter("{%u}", call->unmarshall);
1467
1468 ret = afs_transfer_reply(call);
1469 if (ret < 0)
1470 return ret;
1471
1472
1473 bp = call->buffer;
1474 xdr_decode_AFSVolSync(&bp, &op->volsync);
1475
1476 _leave(" = 0 [done]");
1477 return 0;
1478}
1479
1480
1481
1482
1483static const struct afs_call_type afs_RXFSSetLock = {
1484 .name = "FS.SetLock",
1485 .op = afs_FS_SetLock,
1486 .deliver = afs_deliver_fs_xxxx_lock,
1487 .done = afs_lock_op_done,
1488 .destructor = afs_flat_call_destructor,
1489};
1490
1491
1492
1493
1494static const struct afs_call_type afs_RXFSExtendLock = {
1495 .name = "FS.ExtendLock",
1496 .op = afs_FS_ExtendLock,
1497 .deliver = afs_deliver_fs_xxxx_lock,
1498 .done = afs_lock_op_done,
1499 .destructor = afs_flat_call_destructor,
1500};
1501
1502
1503
1504
1505static const struct afs_call_type afs_RXFSReleaseLock = {
1506 .name = "FS.ReleaseLock",
1507 .op = afs_FS_ReleaseLock,
1508 .deliver = afs_deliver_fs_xxxx_lock,
1509 .destructor = afs_flat_call_destructor,
1510};
1511
1512
1513
1514
1515void afs_fs_set_lock(struct afs_operation *op)
1516{
1517 struct afs_vnode_param *vp = &op->file[0];
1518 struct afs_call *call;
1519 __be32 *bp;
1520
1521 _enter("");
1522
1523 call = afs_alloc_flat_call(op->net, &afs_RXFSSetLock, 5 * 4, 6 * 4);
1524 if (!call)
1525 return afs_op_nomem(op);
1526
1527
1528 bp = call->request;
1529 *bp++ = htonl(FSSETLOCK);
1530 *bp++ = htonl(vp->fid.vid);
1531 *bp++ = htonl(vp->fid.vnode);
1532 *bp++ = htonl(vp->fid.unique);
1533 *bp++ = htonl(op->lock.type);
1534
1535 trace_afs_make_fs_calli(call, &vp->fid, op->lock.type);
1536 afs_make_op_call(op, call, GFP_NOFS);
1537}
1538
1539
1540
1541
1542void afs_fs_extend_lock(struct afs_operation *op)
1543{
1544 struct afs_vnode_param *vp = &op->file[0];
1545 struct afs_call *call;
1546 __be32 *bp;
1547
1548 _enter("");
1549
1550 call = afs_alloc_flat_call(op->net, &afs_RXFSExtendLock, 4 * 4, 6 * 4);
1551 if (!call)
1552 return afs_op_nomem(op);
1553
1554
1555 bp = call->request;
1556 *bp++ = htonl(FSEXTENDLOCK);
1557 *bp++ = htonl(vp->fid.vid);
1558 *bp++ = htonl(vp->fid.vnode);
1559 *bp++ = htonl(vp->fid.unique);
1560
1561 trace_afs_make_fs_call(call, &vp->fid);
1562 afs_make_op_call(op, call, GFP_NOFS);
1563}
1564
1565
1566
1567
1568void afs_fs_release_lock(struct afs_operation *op)
1569{
1570 struct afs_vnode_param *vp = &op->file[0];
1571 struct afs_call *call;
1572 __be32 *bp;
1573
1574 _enter("");
1575
1576 call = afs_alloc_flat_call(op->net, &afs_RXFSReleaseLock, 4 * 4, 6 * 4);
1577 if (!call)
1578 return afs_op_nomem(op);
1579
1580
1581 bp = call->request;
1582 *bp++ = htonl(FSRELEASELOCK);
1583 *bp++ = htonl(vp->fid.vid);
1584 *bp++ = htonl(vp->fid.vnode);
1585 *bp++ = htonl(vp->fid.unique);
1586
1587 trace_afs_make_fs_call(call, &vp->fid);
1588 afs_make_op_call(op, call, GFP_NOFS);
1589}
1590
1591
1592
1593
1594static int afs_deliver_fs_give_up_all_callbacks(struct afs_call *call)
1595{
1596 return afs_transfer_reply(call);
1597}
1598
1599
1600
1601
1602static const struct afs_call_type afs_RXFSGiveUpAllCallBacks = {
1603 .name = "FS.GiveUpAllCallBacks",
1604 .op = afs_FS_GiveUpAllCallBacks,
1605 .deliver = afs_deliver_fs_give_up_all_callbacks,
1606 .destructor = afs_flat_call_destructor,
1607};
1608
1609
1610
1611
1612int afs_fs_give_up_all_callbacks(struct afs_net *net,
1613 struct afs_server *server,
1614 struct afs_addr_cursor *ac,
1615 struct key *key)
1616{
1617 struct afs_call *call;
1618 __be32 *bp;
1619
1620 _enter("");
1621
1622 call = afs_alloc_flat_call(net, &afs_RXFSGiveUpAllCallBacks, 1 * 4, 0);
1623 if (!call)
1624 return -ENOMEM;
1625
1626 call->key = key;
1627
1628
1629 bp = call->request;
1630 *bp++ = htonl(FSGIVEUPALLCALLBACKS);
1631
1632 call->server = afs_use_server(server, afs_server_trace_give_up_cb);
1633 afs_make_call(ac, call, GFP_NOFS);
1634 return afs_wait_for_call_to_complete(call, ac);
1635}
1636
1637
1638
1639
1640static int afs_deliver_fs_get_capabilities(struct afs_call *call)
1641{
1642 u32 count;
1643 int ret;
1644
1645 _enter("{%u,%zu}", call->unmarshall, iov_iter_count(call->iter));
1646
1647 switch (call->unmarshall) {
1648 case 0:
1649 afs_extract_to_tmp(call);
1650 call->unmarshall++;
1651 fallthrough;
1652
1653
1654 case 1:
1655 ret = afs_extract_data(call, true);
1656 if (ret < 0)
1657 return ret;
1658
1659 count = ntohl(call->tmp);
1660
1661 call->count = count;
1662 call->count2 = count;
1663 afs_extract_discard(call, count * sizeof(__be32));
1664 call->unmarshall++;
1665 fallthrough;
1666
1667
1668 case 2:
1669 ret = afs_extract_data(call, false);
1670 if (ret < 0)
1671 return ret;
1672
1673
1674
1675 call->unmarshall++;
1676 break;
1677 }
1678
1679 _leave(" = 0 [done]");
1680 return 0;
1681}
1682
1683
1684
1685
1686static const struct afs_call_type afs_RXFSGetCapabilities = {
1687 .name = "FS.GetCapabilities",
1688 .op = afs_FS_GetCapabilities,
1689 .deliver = afs_deliver_fs_get_capabilities,
1690 .done = afs_fileserver_probe_result,
1691 .destructor = afs_flat_call_destructor,
1692};
1693
1694
1695
1696
1697
1698
1699
1700bool afs_fs_get_capabilities(struct afs_net *net, struct afs_server *server,
1701 struct afs_addr_cursor *ac, struct key *key)
1702{
1703 struct afs_call *call;
1704 __be32 *bp;
1705
1706 _enter("");
1707
1708 call = afs_alloc_flat_call(net, &afs_RXFSGetCapabilities, 1 * 4, 16 * 4);
1709 if (!call)
1710 return false;
1711
1712 call->key = key;
1713 call->server = afs_use_server(server, afs_server_trace_get_caps);
1714 call->upgrade = true;
1715 call->async = true;
1716 call->max_lifespan = AFS_PROBE_MAX_LIFESPAN;
1717
1718
1719 bp = call->request;
1720 *bp++ = htonl(FSGETCAPABILITIES);
1721
1722 trace_afs_make_fs_call(call, NULL);
1723 afs_make_call(ac, call, GFP_NOFS);
1724 afs_put_call(call);
1725 return true;
1726}
1727
1728
1729
1730
1731static int afs_deliver_fs_inline_bulk_status(struct afs_call *call)
1732{
1733 struct afs_operation *op = call->op;
1734 struct afs_status_cb *scb;
1735 const __be32 *bp;
1736 u32 tmp;
1737 int ret;
1738
1739 _enter("{%u}", call->unmarshall);
1740
1741 switch (call->unmarshall) {
1742 case 0:
1743 afs_extract_to_tmp(call);
1744 call->unmarshall++;
1745 fallthrough;
1746
1747
1748 case 1:
1749 _debug("extract status count");
1750 ret = afs_extract_data(call, true);
1751 if (ret < 0)
1752 return ret;
1753
1754 tmp = ntohl(call->tmp);
1755 _debug("status count: %u/%u", tmp, op->nr_files);
1756 if (tmp != op->nr_files)
1757 return afs_protocol_error(call, afs_eproto_ibulkst_count);
1758
1759 call->count = 0;
1760 call->unmarshall++;
1761 more_counts:
1762 afs_extract_to_buf(call, 21 * sizeof(__be32));
1763 fallthrough;
1764
1765 case 2:
1766 _debug("extract status array %u", call->count);
1767 ret = afs_extract_data(call, true);
1768 if (ret < 0)
1769 return ret;
1770
1771 switch (call->count) {
1772 case 0:
1773 scb = &op->file[0].scb;
1774 break;
1775 case 1:
1776 scb = &op->file[1].scb;
1777 break;
1778 default:
1779 scb = &op->more_files[call->count - 2].scb;
1780 break;
1781 }
1782
1783 bp = call->buffer;
1784 xdr_decode_AFSFetchStatus(&bp, call, scb);
1785
1786 call->count++;
1787 if (call->count < op->nr_files)
1788 goto more_counts;
1789
1790 call->count = 0;
1791 call->unmarshall++;
1792 afs_extract_to_tmp(call);
1793 fallthrough;
1794
1795
1796 case 3:
1797 _debug("extract CB count");
1798 ret = afs_extract_data(call, true);
1799 if (ret < 0)
1800 return ret;
1801
1802 tmp = ntohl(call->tmp);
1803 _debug("CB count: %u", tmp);
1804 if (tmp != op->nr_files)
1805 return afs_protocol_error(call, afs_eproto_ibulkst_cb_count);
1806 call->count = 0;
1807 call->unmarshall++;
1808 more_cbs:
1809 afs_extract_to_buf(call, 3 * sizeof(__be32));
1810 fallthrough;
1811
1812 case 4:
1813 _debug("extract CB array");
1814 ret = afs_extract_data(call, true);
1815 if (ret < 0)
1816 return ret;
1817
1818 _debug("unmarshall CB array");
1819 switch (call->count) {
1820 case 0:
1821 scb = &op->file[0].scb;
1822 break;
1823 case 1:
1824 scb = &op->file[1].scb;
1825 break;
1826 default:
1827 scb = &op->more_files[call->count - 2].scb;
1828 break;
1829 }
1830
1831 bp = call->buffer;
1832 xdr_decode_AFSCallBack(&bp, call, scb);
1833 call->count++;
1834 if (call->count < op->nr_files)
1835 goto more_cbs;
1836
1837 afs_extract_to_buf(call, 6 * sizeof(__be32));
1838 call->unmarshall++;
1839 fallthrough;
1840
1841 case 5:
1842 ret = afs_extract_data(call, false);
1843 if (ret < 0)
1844 return ret;
1845
1846 bp = call->buffer;
1847 xdr_decode_AFSVolSync(&bp, &op->volsync);
1848
1849 call->unmarshall++;
1850 fallthrough;
1851
1852 case 6:
1853 break;
1854 }
1855
1856 _leave(" = 0 [done]");
1857 return 0;
1858}
1859
1860static void afs_done_fs_inline_bulk_status(struct afs_call *call)
1861{
1862 if (call->error == -ECONNABORTED &&
1863 call->abort_code == RX_INVALID_OPERATION) {
1864 set_bit(AFS_SERVER_FL_NO_IBULK, &call->server->flags);
1865 if (call->op)
1866 set_bit(AFS_VOLUME_MAYBE_NO_IBULK, &call->op->volume->flags);
1867 }
1868}
1869
1870
1871
1872
1873static const struct afs_call_type afs_RXFSInlineBulkStatus = {
1874 .name = "FS.InlineBulkStatus",
1875 .op = afs_FS_InlineBulkStatus,
1876 .deliver = afs_deliver_fs_inline_bulk_status,
1877 .done = afs_done_fs_inline_bulk_status,
1878 .destructor = afs_flat_call_destructor,
1879};
1880
1881
1882
1883
1884void afs_fs_inline_bulk_status(struct afs_operation *op)
1885{
1886 struct afs_vnode_param *dvp = &op->file[0];
1887 struct afs_vnode_param *vp = &op->file[1];
1888 struct afs_call *call;
1889 __be32 *bp;
1890 int i;
1891
1892 if (test_bit(AFS_SERVER_FL_NO_IBULK, &op->server->flags)) {
1893 op->error = -ENOTSUPP;
1894 return;
1895 }
1896
1897 _enter(",%x,{%llx:%llu},%u",
1898 key_serial(op->key), vp->fid.vid, vp->fid.vnode, op->nr_files);
1899
1900 call = afs_alloc_flat_call(op->net, &afs_RXFSInlineBulkStatus,
1901 (2 + op->nr_files * 3) * 4,
1902 21 * 4);
1903 if (!call)
1904 return afs_op_nomem(op);
1905
1906
1907 bp = call->request;
1908 *bp++ = htonl(FSINLINEBULKSTATUS);
1909 *bp++ = htonl(op->nr_files);
1910 *bp++ = htonl(dvp->fid.vid);
1911 *bp++ = htonl(dvp->fid.vnode);
1912 *bp++ = htonl(dvp->fid.unique);
1913 *bp++ = htonl(vp->fid.vid);
1914 *bp++ = htonl(vp->fid.vnode);
1915 *bp++ = htonl(vp->fid.unique);
1916 for (i = 0; i < op->nr_files - 2; i++) {
1917 *bp++ = htonl(op->more_files[i].fid.vid);
1918 *bp++ = htonl(op->more_files[i].fid.vnode);
1919 *bp++ = htonl(op->more_files[i].fid.unique);
1920 }
1921
1922 trace_afs_make_fs_call(call, &vp->fid);
1923 afs_make_op_call(op, call, GFP_NOFS);
1924}
1925
1926
1927
1928
1929static int afs_deliver_fs_fetch_acl(struct afs_call *call)
1930{
1931 struct afs_operation *op = call->op;
1932 struct afs_vnode_param *vp = &op->file[0];
1933 struct afs_acl *acl;
1934 const __be32 *bp;
1935 unsigned int size;
1936 int ret;
1937
1938 _enter("{%u}", call->unmarshall);
1939
1940 switch (call->unmarshall) {
1941 case 0:
1942 afs_extract_to_tmp(call);
1943 call->unmarshall++;
1944 fallthrough;
1945
1946
1947 case 1:
1948 ret = afs_extract_data(call, true);
1949 if (ret < 0)
1950 return ret;
1951
1952 size = call->count2 = ntohl(call->tmp);
1953 size = round_up(size, 4);
1954
1955 acl = kmalloc(struct_size(acl, data, size), GFP_KERNEL);
1956 if (!acl)
1957 return -ENOMEM;
1958 op->acl = acl;
1959 acl->size = call->count2;
1960 afs_extract_begin(call, acl->data, size);
1961 call->unmarshall++;
1962 fallthrough;
1963
1964
1965 case 2:
1966 ret = afs_extract_data(call, true);
1967 if (ret < 0)
1968 return ret;
1969
1970 afs_extract_to_buf(call, (21 + 6) * 4);
1971 call->unmarshall++;
1972 fallthrough;
1973
1974
1975 case 3:
1976 ret = afs_extract_data(call, false);
1977 if (ret < 0)
1978 return ret;
1979
1980 bp = call->buffer;
1981 xdr_decode_AFSFetchStatus(&bp, call, &vp->scb);
1982 xdr_decode_AFSVolSync(&bp, &op->volsync);
1983
1984 call->unmarshall++;
1985 fallthrough;
1986
1987 case 4:
1988 break;
1989 }
1990
1991 _leave(" = 0 [done]");
1992 return 0;
1993}
1994
1995
1996
1997
1998static const struct afs_call_type afs_RXFSFetchACL = {
1999 .name = "FS.FetchACL",
2000 .op = afs_FS_FetchACL,
2001 .deliver = afs_deliver_fs_fetch_acl,
2002};
2003
2004
2005
2006
2007void afs_fs_fetch_acl(struct afs_operation *op)
2008{
2009 struct afs_vnode_param *vp = &op->file[0];
2010 struct afs_call *call;
2011 __be32 *bp;
2012
2013 _enter(",%x,{%llx:%llu},,",
2014 key_serial(op->key), vp->fid.vid, vp->fid.vnode);
2015
2016 call = afs_alloc_flat_call(op->net, &afs_RXFSFetchACL, 16, (21 + 6) * 4);
2017 if (!call)
2018 return afs_op_nomem(op);
2019
2020
2021 bp = call->request;
2022 bp[0] = htonl(FSFETCHACL);
2023 bp[1] = htonl(vp->fid.vid);
2024 bp[2] = htonl(vp->fid.vnode);
2025 bp[3] = htonl(vp->fid.unique);
2026
2027 trace_afs_make_fs_call(call, &vp->fid);
2028 afs_make_op_call(op, call, GFP_KERNEL);
2029}
2030
2031
2032
2033
2034static const struct afs_call_type afs_RXFSStoreACL = {
2035 .name = "FS.StoreACL",
2036 .op = afs_FS_StoreACL,
2037 .deliver = afs_deliver_fs_file_status_and_vol,
2038 .destructor = afs_flat_call_destructor,
2039};
2040
2041
2042
2043
2044void afs_fs_store_acl(struct afs_operation *op)
2045{
2046 struct afs_vnode_param *vp = &op->file[0];
2047 struct afs_call *call;
2048 const struct afs_acl *acl = op->acl;
2049 size_t size;
2050 __be32 *bp;
2051
2052 _enter(",%x,{%llx:%llu},,",
2053 key_serial(op->key), vp->fid.vid, vp->fid.vnode);
2054
2055 size = round_up(acl->size, 4);
2056 call = afs_alloc_flat_call(op->net, &afs_RXFSStoreACL,
2057 5 * 4 + size, (21 + 6) * 4);
2058 if (!call)
2059 return afs_op_nomem(op);
2060
2061
2062 bp = call->request;
2063 bp[0] = htonl(FSSTOREACL);
2064 bp[1] = htonl(vp->fid.vid);
2065 bp[2] = htonl(vp->fid.vnode);
2066 bp[3] = htonl(vp->fid.unique);
2067 bp[4] = htonl(acl->size);
2068 memcpy(&bp[5], acl->data, acl->size);
2069 if (acl->size != size)
2070 memset((void *)&bp[5] + acl->size, 0, size - acl->size);
2071
2072 trace_afs_make_fs_call(call, &vp->fid);
2073 afs_make_op_call(op, call, GFP_KERNEL);
2074}
2075