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