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