]> git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - fs/afs/fsclient.c
projects / mirror_ubuntu-artful-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge tag 'imx-drm-fixes-2017-07-18' of git://git.pengutronix.de/git/pza/linux into...
[mirror_ubuntu-artful-kernel.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 "internal.h"
17 #include "afs_fs.h"
18
19 /*
20 * We need somewhere to discard into in case the server helpfully returns more
21 * than we asked for in FS.FetchData{,64}.
22 */
23 static u8 afs_discard_buffer[64];
24
25 /*
26 * decode an AFSFid block
27 */
28 static void xdr_decode_AFSFid(const __be32 **_bp, struct afs_fid *fid)
29 {
30 const __be32 *bp = *_bp;
31
32 fid->vid = ntohl(*bp++);
33 fid->vnode = ntohl(*bp++);
34 fid->unique = ntohl(*bp++);
35 *_bp = bp;
36 }
37
38 /*
39 * decode an AFSFetchStatus block
40 */
41 static void xdr_decode_AFSFetchStatus(const __be32 **_bp,
42 struct afs_file_status *status,
43 struct afs_vnode *vnode,
44 afs_dataversion_t *store_version)
45 {
46 afs_dataversion_t expected_version;
47 const __be32 *bp = *_bp;
48 umode_t mode;
49 u64 data_version, size;
50 u32 changed = 0; /* becomes non-zero if ctime-type changes seen */
51 kuid_t owner;
52 kgid_t group;
53
54 #define EXTRACT(DST) \
55 do { \
56 u32 x = ntohl(*bp++); \
57 changed |= DST - x; \
58 DST = x; \
59 } while (0)
60
61 status->if_version = ntohl(*bp++);
62 EXTRACT(status->type);
63 EXTRACT(status->nlink);
64 size = ntohl(*bp++);
65 data_version = ntohl(*bp++);
66 EXTRACT(status->author);
67 owner = make_kuid(&init_user_ns, ntohl(*bp++));
68 changed |= !uid_eq(owner, status->owner);
69 status->owner = owner;
70 EXTRACT(status->caller_access); /* call ticket dependent */
71 EXTRACT(status->anon_access);
72 EXTRACT(status->mode);
73 EXTRACT(status->parent.vnode);
74 EXTRACT(status->parent.unique);
75 bp++; /* seg size */
76 status->mtime_client = ntohl(*bp++);
77 status->mtime_server = ntohl(*bp++);
78 group = make_kgid(&init_user_ns, ntohl(*bp++));
79 changed |= !gid_eq(group, status->group);
80 status->group = group;
81 bp++; /* sync counter */
82 data_version |= (u64) ntohl(*bp++) << 32;
83 EXTRACT(status->lock_count);
84 size |= (u64) ntohl(*bp++) << 32;
85 bp++; /* spare 4 */
86 *_bp = bp;
87
88 if (size != status->size) {
89 status->size = size;
90 changed |= true;
91 }
92 status->mode &= S_IALLUGO;
93
94 _debug("vnode time %lx, %lx",
95 status->mtime_client, status->mtime_server);
96
97 if (vnode) {
98 status->parent.vid = vnode->fid.vid;
99 if (changed && !test_bit(AFS_VNODE_UNSET, &vnode->flags)) {
100 _debug("vnode changed");
101 i_size_write(&vnode->vfs_inode, size);
102 vnode->vfs_inode.i_uid = status->owner;
103 vnode->vfs_inode.i_gid = status->group;
104 vnode->vfs_inode.i_generation = vnode->fid.unique;
105 set_nlink(&vnode->vfs_inode, status->nlink);
106
107 mode = vnode->vfs_inode.i_mode;
108 mode &= ~S_IALLUGO;
109 mode |= status->mode;
110 barrier();
111 vnode->vfs_inode.i_mode = mode;
112 }
113
114 vnode->vfs_inode.i_ctime.tv_sec = status->mtime_client;
115 vnode->vfs_inode.i_mtime = vnode->vfs_inode.i_ctime;
116 vnode->vfs_inode.i_atime = vnode->vfs_inode.i_ctime;
117 vnode->vfs_inode.i_version = data_version;
118 }
119
120 expected_version = status->data_version;
121 if (store_version)
122 expected_version = *store_version;
123
124 if (expected_version != data_version) {
125 status->data_version = data_version;
126 if (vnode && !test_bit(AFS_VNODE_UNSET, &vnode->flags)) {
127 _debug("vnode modified %llx on {%x:%u}",
128 (unsigned long long) data_version,
129 vnode->fid.vid, vnode->fid.vnode);
130 set_bit(AFS_VNODE_MODIFIED, &vnode->flags);
131 set_bit(AFS_VNODE_ZAP_DATA, &vnode->flags);
132 }
133 } else if (store_version) {
134 status->data_version = data_version;
135 }
136 }
137
138 /*
139 * decode an AFSCallBack block
140 */
141 static void xdr_decode_AFSCallBack(const __be32 **_bp, struct afs_vnode *vnode)
142 {
143 const __be32 *bp = *_bp;
144
145 vnode->cb_version = ntohl(*bp++);
146 vnode->cb_expiry = ntohl(*bp++);
147 vnode->cb_type = ntohl(*bp++);
148 vnode->cb_expires = vnode->cb_expiry + ktime_get_real_seconds();
149 *_bp = bp;
150 }
151
152 static void xdr_decode_AFSCallBack_raw(const __be32 **_bp,
153 struct afs_callback *cb)
154 {
155 const __be32 *bp = *_bp;
156
157 cb->version = ntohl(*bp++);
158 cb->expiry = ntohl(*bp++);
159 cb->type = ntohl(*bp++);
160 *_bp = bp;
161 }
162
163 /*
164 * decode an AFSVolSync block
165 */
166 static void xdr_decode_AFSVolSync(const __be32 **_bp,
167 struct afs_volsync *volsync)
168 {
169 const __be32 *bp = *_bp;
170
171 volsync->creation = ntohl(*bp++);
172 bp++; /* spare2 */
173 bp++; /* spare3 */
174 bp++; /* spare4 */
175 bp++; /* spare5 */
176 bp++; /* spare6 */
177 *_bp = bp;
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 *_bp = bp;
239 }
240
241 /*
242 * deliver reply data to an FS.FetchStatus
243 */
244 static int afs_deliver_fs_fetch_status(struct afs_call *call)
245 {
246 struct afs_vnode *vnode = call->reply;
247 const __be32 *bp;
248 int ret;
249
250 _enter("");
251
252 ret = afs_transfer_reply(call);
253 if (ret < 0)
254 return ret;
255
256 /* unmarshall the reply once we've received all of it */
257 bp = call->buffer;
258 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);
259 xdr_decode_AFSCallBack(&bp, vnode);
260 if (call->reply2)
261 xdr_decode_AFSVolSync(&bp, call->reply2);
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 = {
271 .name = "FS.FetchStatus",
272 .deliver = afs_deliver_fs_fetch_status,
273 .abort_to_error = afs_abort_to_error,
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_server *server,
281 struct key *key,
282 struct afs_vnode *vnode,
283 struct afs_volsync *volsync,
284 bool async)
285 {
286 struct afs_call *call;
287 __be32 *bp;
288
289 _enter(",%x,{%x:%u},,",
290 key_serial(key), vnode->fid.vid, vnode->fid.vnode);
291
292 call = afs_alloc_flat_call(&afs_RXFSFetchStatus, 16, (21 + 3 + 6) * 4);
293 if (!call)
294 return -ENOMEM;
295
296 call->key = key;
297 call->reply = vnode;
298 call->reply2 = volsync;
299 call->service_id = FS_SERVICE;
300 call->port = htons(AFS_FS_PORT);
301
302 /* marshall the parameters */
303 bp = call->request;
304 bp[0] = htonl(FSFETCHSTATUS);
305 bp[1] = htonl(vnode->fid.vid);
306 bp[2] = htonl(vnode->fid.vnode);
307 bp[3] = htonl(vnode->fid.unique);
308
309 return afs_make_call(&server->addr, call, GFP_NOFS, async);
310 }
311
312 /*
313 * deliver reply data to an FS.FetchData
314 */
315 static int afs_deliver_fs_fetch_data(struct afs_call *call)
316 {
317 struct afs_vnode *vnode = call->reply;
318 struct afs_read *req = call->reply3;
319 const __be32 *bp;
320 unsigned int size;
321 void *buffer;
322 int ret;
323
324 _enter("{%u,%zu/%u;%llu/%llu}",
325 call->unmarshall, call->offset, call->count,
326 req->remain, req->actual_len);
327
328 switch (call->unmarshall) {
329 case 0:
330 req->actual_len = 0;
331 call->offset = 0;
332 call->unmarshall++;
333 if (call->operation_ID != FSFETCHDATA64) {
334 call->unmarshall++;
335 goto no_msw;
336 }
337
338 /* extract the upper part of the returned data length of an
339 * FSFETCHDATA64 op (which should always be 0 using this
340 * client) */
341 case 1:
342 _debug("extract data length (MSW)");
343 ret = afs_extract_data(call, &call->tmp, 4, true);
344 if (ret < 0)
345 return ret;
346
347 req->actual_len = ntohl(call->tmp);
348 req->actual_len <<= 32;
349 call->offset = 0;
350 call->unmarshall++;
351
352 no_msw:
353 /* extract the returned data length */
354 case 2:
355 _debug("extract data length");
356 ret = afs_extract_data(call, &call->tmp, 4, true);
357 if (ret < 0)
358 return ret;
359
360 req->actual_len |= ntohl(call->tmp);
361 _debug("DATA length: %llu", req->actual_len);
362
363 req->remain = req->actual_len;
364 call->offset = req->pos & (PAGE_SIZE - 1);
365 req->index = 0;
366 if (req->actual_len == 0)
367 goto no_more_data;
368 call->unmarshall++;
369
370 begin_page:
371 ASSERTCMP(req->index, <, req->nr_pages);
372 if (req->remain > PAGE_SIZE - call->offset)
373 size = PAGE_SIZE - call->offset;
374 else
375 size = req->remain;
376 call->count = call->offset + size;
377 ASSERTCMP(call->count, <=, PAGE_SIZE);
378 req->remain -= size;
379
380 /* extract the returned data */
381 case 3:
382 _debug("extract data %llu/%llu %zu/%u",
383 req->remain, req->actual_len, call->offset, call->count);
384
385 buffer = kmap(req->pages[req->index]);
386 ret = afs_extract_data(call, buffer, call->count, true);
387 kunmap(req->pages[req->index]);
388 if (ret < 0)
389 return ret;
390 if (call->offset == PAGE_SIZE) {
391 if (req->page_done)
392 req->page_done(call, req);
393 req->index++;
394 if (req->remain > 0) {
395 call->offset = 0;
396 if (req->index >= req->nr_pages) {
397 call->unmarshall = 4;
398 goto begin_discard;
399 }
400 goto begin_page;
401 }
402 }
403 goto no_more_data;
404
405 /* Discard any excess data the server gave us */
406 begin_discard:
407 case 4:
408 size = min_t(loff_t, sizeof(afs_discard_buffer), req->remain);
409 call->count = size;
410 _debug("extract discard %llu/%llu %zu/%u",
411 req->remain, req->actual_len, call->offset, call->count);
412
413 call->offset = 0;
414 ret = afs_extract_data(call, afs_discard_buffer, call->count, true);
415 req->remain -= call->offset;
416 if (ret < 0)
417 return ret;
418 if (req->remain > 0)
419 goto begin_discard;
420
421 no_more_data:
422 call->offset = 0;
423 call->unmarshall = 5;
424
425 /* extract the metadata */
426 case 5:
427 ret = afs_extract_data(call, call->buffer,
428 (21 + 3 + 6) * 4, false);
429 if (ret < 0)
430 return ret;
431
432 bp = call->buffer;
433 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);
434 xdr_decode_AFSCallBack(&bp, vnode);
435 if (call->reply2)
436 xdr_decode_AFSVolSync(&bp, call->reply2);
437
438 call->offset = 0;
439 call->unmarshall++;
440
441 case 6:
442 break;
443 }
444
445 for (; req->index < req->nr_pages; req->index++) {
446 if (call->count < PAGE_SIZE)
447 zero_user_segment(req->pages[req->index],
448 call->count, PAGE_SIZE);
449 if (req->page_done)
450 req->page_done(call, req);
451 call->count = 0;
452 }
453
454 _leave(" = 0 [done]");
455 return 0;
456 }
457
458 static void afs_fetch_data_destructor(struct afs_call *call)
459 {
460 struct afs_read *req = call->reply3;
461
462 afs_put_read(req);
463 afs_flat_call_destructor(call);
464 }
465
466 /*
467 * FS.FetchData operation type
468 */
469 static const struct afs_call_type afs_RXFSFetchData = {
470 .name = "FS.FetchData",
471 .deliver = afs_deliver_fs_fetch_data,
472 .abort_to_error = afs_abort_to_error,
473 .destructor = afs_fetch_data_destructor,
474 };
475
476 static const struct afs_call_type afs_RXFSFetchData64 = {
477 .name = "FS.FetchData64",
478 .deliver = afs_deliver_fs_fetch_data,
479 .abort_to_error = afs_abort_to_error,
480 .destructor = afs_fetch_data_destructor,
481 };
482
483 /*
484 * fetch data from a very large file
485 */
486 static int afs_fs_fetch_data64(struct afs_server *server,
487 struct key *key,
488 struct afs_vnode *vnode,
489 struct afs_read *req,
490 bool async)
491 {
492 struct afs_call *call;
493 __be32 *bp;
494
495 _enter("");
496
497 call = afs_alloc_flat_call(&afs_RXFSFetchData64, 32, (21 + 3 + 6) * 4);
498 if (!call)
499 return -ENOMEM;
500
501 call->key = key;
502 call->reply = vnode;
503 call->reply2 = NULL; /* volsync */
504 call->reply3 = req;
505 call->service_id = FS_SERVICE;
506 call->port = htons(AFS_FS_PORT);
507 call->operation_ID = FSFETCHDATA64;
508
509 /* marshall the parameters */
510 bp = call->request;
511 bp[0] = htonl(FSFETCHDATA64);
512 bp[1] = htonl(vnode->fid.vid);
513 bp[2] = htonl(vnode->fid.vnode);
514 bp[3] = htonl(vnode->fid.unique);
515 bp[4] = htonl(upper_32_bits(req->pos));
516 bp[5] = htonl(lower_32_bits(req->pos));
517 bp[6] = 0;
518 bp[7] = htonl(lower_32_bits(req->len));
519
520 atomic_inc(&req->usage);
521 return afs_make_call(&server->addr, call, GFP_NOFS, async);
522 }
523
524 /*
525 * fetch data from a file
526 */
527 int afs_fs_fetch_data(struct afs_server *server,
528 struct key *key,
529 struct afs_vnode *vnode,
530 struct afs_read *req,
531 bool async)
532 {
533 struct afs_call *call;
534 __be32 *bp;
535
536 if (upper_32_bits(req->pos) ||
537 upper_32_bits(req->len) ||
538 upper_32_bits(req->pos + req->len))
539 return afs_fs_fetch_data64(server, key, vnode, req, async);
540
541 _enter("");
542
543 call = afs_alloc_flat_call(&afs_RXFSFetchData, 24, (21 + 3 + 6) * 4);
544 if (!call)
545 return -ENOMEM;
546
547 call->key = key;
548 call->reply = vnode;
549 call->reply2 = NULL; /* volsync */
550 call->reply3 = req;
551 call->service_id = FS_SERVICE;
552 call->port = htons(AFS_FS_PORT);
553 call->operation_ID = FSFETCHDATA;
554
555 /* marshall the parameters */
556 bp = call->request;
557 bp[0] = htonl(FSFETCHDATA);
558 bp[1] = htonl(vnode->fid.vid);
559 bp[2] = htonl(vnode->fid.vnode);
560 bp[3] = htonl(vnode->fid.unique);
561 bp[4] = htonl(lower_32_bits(req->pos));
562 bp[5] = htonl(lower_32_bits(req->len));
563
564 atomic_inc(&req->usage);
565 return afs_make_call(&server->addr, call, GFP_NOFS, async);
566 }
567
568 /*
569 * deliver reply data to an FS.GiveUpCallBacks
570 */
571 static int afs_deliver_fs_give_up_callbacks(struct afs_call *call)
572 {
573 _enter("");
574
575 /* shouldn't be any reply data */
576 return afs_extract_data(call, NULL, 0, false);
577 }
578
579 /*
580 * FS.GiveUpCallBacks operation type
581 */
582 static const struct afs_call_type afs_RXFSGiveUpCallBacks = {
583 .name = "FS.GiveUpCallBacks",
584 .deliver = afs_deliver_fs_give_up_callbacks,
585 .abort_to_error = afs_abort_to_error,
586 .destructor = afs_flat_call_destructor,
587 };
588
589 /*
590 * give up a set of callbacks
591 * - the callbacks are held in the server->cb_break ring
592 */
593 int afs_fs_give_up_callbacks(struct afs_server *server,
594 bool async)
595 {
596 struct afs_call *call;
597 size_t ncallbacks;
598 __be32 *bp, *tp;
599 int loop;
600
601 ncallbacks = CIRC_CNT(server->cb_break_head, server->cb_break_tail,
602 ARRAY_SIZE(server->cb_break));
603
604 _enter("{%zu},", ncallbacks);
605
606 if (ncallbacks == 0)
607 return 0;
608 if (ncallbacks > AFSCBMAX)
609 ncallbacks = AFSCBMAX;
610
611 _debug("break %zu callbacks", ncallbacks);
612
613 call = afs_alloc_flat_call(&afs_RXFSGiveUpCallBacks,
614 12 + ncallbacks * 6 * 4, 0);
615 if (!call)
616 return -ENOMEM;
617
618 call->service_id = FS_SERVICE;
619 call->port = htons(AFS_FS_PORT);
620
621 /* marshall the parameters */
622 bp = call->request;
623 tp = bp + 2 + ncallbacks * 3;
624 *bp++ = htonl(FSGIVEUPCALLBACKS);
625 *bp++ = htonl(ncallbacks);
626 *tp++ = htonl(ncallbacks);
627
628 atomic_sub(ncallbacks, &server->cb_break_n);
629 for (loop = ncallbacks; loop > 0; loop--) {
630 struct afs_callback *cb =
631 &server->cb_break[server->cb_break_tail];
632
633 *bp++ = htonl(cb->fid.vid);
634 *bp++ = htonl(cb->fid.vnode);
635 *bp++ = htonl(cb->fid.unique);
636 *tp++ = htonl(cb->version);
637 *tp++ = htonl(cb->expiry);
638 *tp++ = htonl(cb->type);
639 smp_mb();
640 server->cb_break_tail =
641 (server->cb_break_tail + 1) &
642 (ARRAY_SIZE(server->cb_break) - 1);
643 }
644
645 ASSERT(ncallbacks > 0);
646 wake_up_nr(&server->cb_break_waitq, ncallbacks);
647
648 return afs_make_call(&server->addr, call, GFP_NOFS, async);
649 }
650
651 /*
652 * deliver reply data to an FS.CreateFile or an FS.MakeDir
653 */
654 static int afs_deliver_fs_create_vnode(struct afs_call *call)
655 {
656 struct afs_vnode *vnode = call->reply;
657 const __be32 *bp;
658 int ret;
659
660 _enter("{%u}", call->unmarshall);
661
662 ret = afs_transfer_reply(call);
663 if (ret < 0)
664 return ret;
665
666 /* unmarshall the reply once we've received all of it */
667 bp = call->buffer;
668 xdr_decode_AFSFid(&bp, call->reply2);
669 xdr_decode_AFSFetchStatus(&bp, call->reply3, NULL, NULL);
670 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);
671 xdr_decode_AFSCallBack_raw(&bp, call->reply4);
672 /* xdr_decode_AFSVolSync(&bp, call->replyX); */
673
674 _leave(" = 0 [done]");
675 return 0;
676 }
677
678 /*
679 * FS.CreateFile and FS.MakeDir operation type
680 */
681 static const struct afs_call_type afs_RXFSCreateXXXX = {
682 .name = "FS.CreateXXXX",
683 .deliver = afs_deliver_fs_create_vnode,
684 .abort_to_error = afs_abort_to_error,
685 .destructor = afs_flat_call_destructor,
686 };
687
688 /*
689 * create a file or make a directory
690 */
691 int afs_fs_create(struct afs_server *server,
692 struct key *key,
693 struct afs_vnode *vnode,
694 const char *name,
695 umode_t mode,
696 struct afs_fid *newfid,
697 struct afs_file_status *newstatus,
698 struct afs_callback *newcb,
699 bool async)
700 {
701 struct afs_call *call;
702 size_t namesz, reqsz, padsz;
703 __be32 *bp;
704
705 _enter("");
706
707 namesz = strlen(name);
708 padsz = (4 - (namesz & 3)) & 3;
709 reqsz = (5 * 4) + namesz + padsz + (6 * 4);
710
711 call = afs_alloc_flat_call(&afs_RXFSCreateXXXX, reqsz,
712 (3 + 21 + 21 + 3 + 6) * 4);
713 if (!call)
714 return -ENOMEM;
715
716 call->key = key;
717 call->reply = vnode;
718 call->reply2 = newfid;
719 call->reply3 = newstatus;
720 call->reply4 = newcb;
721 call->service_id = FS_SERVICE;
722 call->port = htons(AFS_FS_PORT);
723
724 /* marshall the parameters */
725 bp = call->request;
726 *bp++ = htonl(S_ISDIR(mode) ? FSMAKEDIR : FSCREATEFILE);
727 *bp++ = htonl(vnode->fid.vid);
728 *bp++ = htonl(vnode->fid.vnode);
729 *bp++ = htonl(vnode->fid.unique);
730 *bp++ = htonl(namesz);
731 memcpy(bp, name, namesz);
732 bp = (void *) bp + namesz;
733 if (padsz > 0) {
734 memset(bp, 0, padsz);
735 bp = (void *) bp + padsz;
736 }
737 *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME);
738 *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */
739 *bp++ = 0; /* owner */
740 *bp++ = 0; /* group */
741 *bp++ = htonl(mode & S_IALLUGO); /* unix mode */
742 *bp++ = 0; /* segment size */
743
744 return afs_make_call(&server->addr, call, GFP_NOFS, async);
745 }
746
747 /*
748 * deliver reply data to an FS.RemoveFile or FS.RemoveDir
749 */
750 static int afs_deliver_fs_remove(struct afs_call *call)
751 {
752 struct afs_vnode *vnode = call->reply;
753 const __be32 *bp;
754 int ret;
755
756 _enter("{%u}", call->unmarshall);
757
758 ret = afs_transfer_reply(call);
759 if (ret < 0)
760 return ret;
761
762 /* unmarshall the reply once we've received all of it */
763 bp = call->buffer;
764 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);
765 /* xdr_decode_AFSVolSync(&bp, call->replyX); */
766
767 _leave(" = 0 [done]");
768 return 0;
769 }
770
771 /*
772 * FS.RemoveDir/FS.RemoveFile operation type
773 */
774 static const struct afs_call_type afs_RXFSRemoveXXXX = {
775 .name = "FS.RemoveXXXX",
776 .deliver = afs_deliver_fs_remove,
777 .abort_to_error = afs_abort_to_error,
778 .destructor = afs_flat_call_destructor,
779 };
780
781 /*
782 * remove a file or directory
783 */
784 int afs_fs_remove(struct afs_server *server,
785 struct key *key,
786 struct afs_vnode *vnode,
787 const char *name,
788 bool isdir,
789 bool async)
790 {
791 struct afs_call *call;
792 size_t namesz, reqsz, padsz;
793 __be32 *bp;
794
795 _enter("");
796
797 namesz = strlen(name);
798 padsz = (4 - (namesz & 3)) & 3;
799 reqsz = (5 * 4) + namesz + padsz;
800
801 call = afs_alloc_flat_call(&afs_RXFSRemoveXXXX, reqsz, (21 + 6) * 4);
802 if (!call)
803 return -ENOMEM;
804
805 call->key = key;
806 call->reply = vnode;
807 call->service_id = FS_SERVICE;
808 call->port = htons(AFS_FS_PORT);
809
810 /* marshall the parameters */
811 bp = call->request;
812 *bp++ = htonl(isdir ? FSREMOVEDIR : FSREMOVEFILE);
813 *bp++ = htonl(vnode->fid.vid);
814 *bp++ = htonl(vnode->fid.vnode);
815 *bp++ = htonl(vnode->fid.unique);
816 *bp++ = htonl(namesz);
817 memcpy(bp, name, namesz);
818 bp = (void *) bp + namesz;
819 if (padsz > 0) {
820 memset(bp, 0, padsz);
821 bp = (void *) bp + padsz;
822 }
823
824 return afs_make_call(&server->addr, call, GFP_NOFS, async);
825 }
826
827 /*
828 * deliver reply data to an FS.Link
829 */
830 static int afs_deliver_fs_link(struct afs_call *call)
831 {
832 struct afs_vnode *dvnode = call->reply, *vnode = call->reply2;
833 const __be32 *bp;
834 int ret;
835
836 _enter("{%u}", call->unmarshall);
837
838 ret = afs_transfer_reply(call);
839 if (ret < 0)
840 return ret;
841
842 /* unmarshall the reply once we've received all of it */
843 bp = call->buffer;
844 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);
845 xdr_decode_AFSFetchStatus(&bp, &dvnode->status, dvnode, NULL);
846 /* xdr_decode_AFSVolSync(&bp, call->replyX); */
847
848 _leave(" = 0 [done]");
849 return 0;
850 }
851
852 /*
853 * FS.Link operation type
854 */
855 static const struct afs_call_type afs_RXFSLink = {
856 .name = "FS.Link",
857 .deliver = afs_deliver_fs_link,
858 .abort_to_error = afs_abort_to_error,
859 .destructor = afs_flat_call_destructor,
860 };
861
862 /*
863 * make a hard link
864 */
865 int afs_fs_link(struct afs_server *server,
866 struct key *key,
867 struct afs_vnode *dvnode,
868 struct afs_vnode *vnode,
869 const char *name,
870 bool async)
871 {
872 struct afs_call *call;
873 size_t namesz, reqsz, padsz;
874 __be32 *bp;
875
876 _enter("");
877
878 namesz = strlen(name);
879 padsz = (4 - (namesz & 3)) & 3;
880 reqsz = (5 * 4) + namesz + padsz + (3 * 4);
881
882 call = afs_alloc_flat_call(&afs_RXFSLink, reqsz, (21 + 21 + 6) * 4);
883 if (!call)
884 return -ENOMEM;
885
886 call->key = key;
887 call->reply = dvnode;
888 call->reply2 = vnode;
889 call->service_id = FS_SERVICE;
890 call->port = htons(AFS_FS_PORT);
891
892 /* marshall the parameters */
893 bp = call->request;
894 *bp++ = htonl(FSLINK);
895 *bp++ = htonl(dvnode->fid.vid);
896 *bp++ = htonl(dvnode->fid.vnode);
897 *bp++ = htonl(dvnode->fid.unique);
898 *bp++ = htonl(namesz);
899 memcpy(bp, name, namesz);
900 bp = (void *) bp + namesz;
901 if (padsz > 0) {
902 memset(bp, 0, padsz);
903 bp = (void *) bp + padsz;
904 }
905 *bp++ = htonl(vnode->fid.vid);
906 *bp++ = htonl(vnode->fid.vnode);
907 *bp++ = htonl(vnode->fid.unique);
908
909 return afs_make_call(&server->addr, call, GFP_NOFS, async);
910 }
911
912 /*
913 * deliver reply data to an FS.Symlink
914 */
915 static int afs_deliver_fs_symlink(struct afs_call *call)
916 {
917 struct afs_vnode *vnode = call->reply;
918 const __be32 *bp;
919 int ret;
920
921 _enter("{%u}", call->unmarshall);
922
923 ret = afs_transfer_reply(call);
924 if (ret < 0)
925 return ret;
926
927 /* unmarshall the reply once we've received all of it */
928 bp = call->buffer;
929 xdr_decode_AFSFid(&bp, call->reply2);
930 xdr_decode_AFSFetchStatus(&bp, call->reply3, NULL, NULL);
931 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, NULL);
932 /* xdr_decode_AFSVolSync(&bp, call->replyX); */
933
934 _leave(" = 0 [done]");
935 return 0;
936 }
937
938 /*
939 * FS.Symlink operation type
940 */
941 static const struct afs_call_type afs_RXFSSymlink = {
942 .name = "FS.Symlink",
943 .deliver = afs_deliver_fs_symlink,
944 .abort_to_error = afs_abort_to_error,
945 .destructor = afs_flat_call_destructor,
946 };
947
948 /*
949 * create a symbolic link
950 */
951 int afs_fs_symlink(struct afs_server *server,
952 struct key *key,
953 struct afs_vnode *vnode,
954 const char *name,
955 const char *contents,
956 struct afs_fid *newfid,
957 struct afs_file_status *newstatus,
958 bool async)
959 {
960 struct afs_call *call;
961 size_t namesz, reqsz, padsz, c_namesz, c_padsz;
962 __be32 *bp;
963
964 _enter("");
965
966 namesz = strlen(name);
967 padsz = (4 - (namesz & 3)) & 3;
968
969 c_namesz = strlen(contents);
970 c_padsz = (4 - (c_namesz & 3)) & 3;
971
972 reqsz = (6 * 4) + namesz + padsz + c_namesz + c_padsz + (6 * 4);
973
974 call = afs_alloc_flat_call(&afs_RXFSSymlink, reqsz,
975 (3 + 21 + 21 + 6) * 4);
976 if (!call)
977 return -ENOMEM;
978
979 call->key = key;
980 call->reply = vnode;
981 call->reply2 = newfid;
982 call->reply3 = newstatus;
983 call->service_id = FS_SERVICE;
984 call->port = htons(AFS_FS_PORT);
985
986 /* marshall the parameters */
987 bp = call->request;
988 *bp++ = htonl(FSSYMLINK);
989 *bp++ = htonl(vnode->fid.vid);
990 *bp++ = htonl(vnode->fid.vnode);
991 *bp++ = htonl(vnode->fid.unique);
992 *bp++ = htonl(namesz);
993 memcpy(bp, name, namesz);
994 bp = (void *) bp + namesz;
995 if (padsz > 0) {
996 memset(bp, 0, padsz);
997 bp = (void *) bp + padsz;
998 }
999 *bp++ = htonl(c_namesz);
1000 memcpy(bp, contents, c_namesz);
1001 bp = (void *) bp + c_namesz;
1002 if (c_padsz > 0) {
1003 memset(bp, 0, c_padsz);
1004 bp = (void *) bp + c_padsz;
1005 }
1006 *bp++ = htonl(AFS_SET_MODE | AFS_SET_MTIME);
1007 *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */
1008 *bp++ = 0; /* owner */
1009 *bp++ = 0; /* group */
1010 *bp++ = htonl(S_IRWXUGO); /* unix mode */
1011 *bp++ = 0; /* segment size */
1012
1013 return afs_make_call(&server->addr, call, GFP_NOFS, async);
1014 }
1015
1016 /*
1017 * deliver reply data to an FS.Rename
1018 */
1019 static int afs_deliver_fs_rename(struct afs_call *call)
1020 {
1021 struct afs_vnode *orig_dvnode = call->reply, *new_dvnode = call->reply2;
1022 const __be32 *bp;
1023 int ret;
1024
1025 _enter("{%u}", call->unmarshall);
1026
1027 ret = afs_transfer_reply(call);
1028 if (ret < 0)
1029 return ret;
1030
1031 /* unmarshall the reply once we've received all of it */
1032 bp = call->buffer;
1033 xdr_decode_AFSFetchStatus(&bp, &orig_dvnode->status, orig_dvnode, NULL);
1034 if (new_dvnode != orig_dvnode)
1035 xdr_decode_AFSFetchStatus(&bp, &new_dvnode->status, new_dvnode,
1036 NULL);
1037 /* xdr_decode_AFSVolSync(&bp, call->replyX); */
1038
1039 _leave(" = 0 [done]");
1040 return 0;
1041 }
1042
1043 /*
1044 * FS.Rename operation type
1045 */
1046 static const struct afs_call_type afs_RXFSRename = {
1047 .name = "FS.Rename",
1048 .deliver = afs_deliver_fs_rename,
1049 .abort_to_error = afs_abort_to_error,
1050 .destructor = afs_flat_call_destructor,
1051 };
1052
1053 /*
1054 * create a symbolic link
1055 */
1056 int afs_fs_rename(struct afs_server *server,
1057 struct key *key,
1058 struct afs_vnode *orig_dvnode,
1059 const char *orig_name,
1060 struct afs_vnode *new_dvnode,
1061 const char *new_name,
1062 bool async)
1063 {
1064 struct afs_call *call;
1065 size_t reqsz, o_namesz, o_padsz, n_namesz, n_padsz;
1066 __be32 *bp;
1067
1068 _enter("");
1069
1070 o_namesz = strlen(orig_name);
1071 o_padsz = (4 - (o_namesz & 3)) & 3;
1072
1073 n_namesz = strlen(new_name);
1074 n_padsz = (4 - (n_namesz & 3)) & 3;
1075
1076 reqsz = (4 * 4) +
1077 4 + o_namesz + o_padsz +
1078 (3 * 4) +
1079 4 + n_namesz + n_padsz;
1080
1081 call = afs_alloc_flat_call(&afs_RXFSRename, reqsz, (21 + 21 + 6) * 4);
1082 if (!call)
1083 return -ENOMEM;
1084
1085 call->key = key;
1086 call->reply = orig_dvnode;
1087 call->reply2 = new_dvnode;
1088 call->service_id = FS_SERVICE;
1089 call->port = htons(AFS_FS_PORT);
1090
1091 /* marshall the parameters */
1092 bp = call->request;
1093 *bp++ = htonl(FSRENAME);
1094 *bp++ = htonl(orig_dvnode->fid.vid);
1095 *bp++ = htonl(orig_dvnode->fid.vnode);
1096 *bp++ = htonl(orig_dvnode->fid.unique);
1097 *bp++ = htonl(o_namesz);
1098 memcpy(bp, orig_name, o_namesz);
1099 bp = (void *) bp + o_namesz;
1100 if (o_padsz > 0) {
1101 memset(bp, 0, o_padsz);
1102 bp = (void *) bp + o_padsz;
1103 }
1104
1105 *bp++ = htonl(new_dvnode->fid.vid);
1106 *bp++ = htonl(new_dvnode->fid.vnode);
1107 *bp++ = htonl(new_dvnode->fid.unique);
1108 *bp++ = htonl(n_namesz);
1109 memcpy(bp, new_name, n_namesz);
1110 bp = (void *) bp + n_namesz;
1111 if (n_padsz > 0) {
1112 memset(bp, 0, n_padsz);
1113 bp = (void *) bp + n_padsz;
1114 }
1115
1116 return afs_make_call(&server->addr, call, GFP_NOFS, async);
1117 }
1118
1119 /*
1120 * deliver reply data to an FS.StoreData
1121 */
1122 static int afs_deliver_fs_store_data(struct afs_call *call)
1123 {
1124 struct afs_vnode *vnode = call->reply;
1125 const __be32 *bp;
1126 int ret;
1127
1128 _enter("");
1129
1130 ret = afs_transfer_reply(call);
1131 if (ret < 0)
1132 return ret;
1133
1134 /* unmarshall the reply once we've received all of it */
1135 bp = call->buffer;
1136 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode,
1137 &call->store_version);
1138 /* xdr_decode_AFSVolSync(&bp, call->replyX); */
1139
1140 afs_pages_written_back(vnode, call);
1141
1142 _leave(" = 0 [done]");
1143 return 0;
1144 }
1145
1146 /*
1147 * FS.StoreData operation type
1148 */
1149 static const struct afs_call_type afs_RXFSStoreData = {
1150 .name = "FS.StoreData",
1151 .deliver = afs_deliver_fs_store_data,
1152 .abort_to_error = afs_abort_to_error,
1153 .destructor = afs_flat_call_destructor,
1154 };
1155
1156 static const struct afs_call_type afs_RXFSStoreData64 = {
1157 .name = "FS.StoreData64",
1158 .deliver = afs_deliver_fs_store_data,
1159 .abort_to_error = afs_abort_to_error,
1160 .destructor = afs_flat_call_destructor,
1161 };
1162
1163 /*
1164 * store a set of pages to a very large file
1165 */
1166 static int afs_fs_store_data64(struct afs_server *server,
1167 struct afs_writeback *wb,
1168 pgoff_t first, pgoff_t last,
1169 unsigned offset, unsigned to,
1170 loff_t size, loff_t pos, loff_t i_size,
1171 bool async)
1172 {
1173 struct afs_vnode *vnode = wb->vnode;
1174 struct afs_call *call;
1175 __be32 *bp;
1176
1177 _enter(",%x,{%x:%u},,",
1178 key_serial(wb->key), vnode->fid.vid, vnode->fid.vnode);
1179
1180 call = afs_alloc_flat_call(&afs_RXFSStoreData64,
1181 (4 + 6 + 3 * 2) * 4,
1182 (21 + 6) * 4);
1183 if (!call)
1184 return -ENOMEM;
1185
1186 call->wb = wb;
1187 call->key = wb->key;
1188 call->reply = vnode;
1189 call->service_id = FS_SERVICE;
1190 call->port = htons(AFS_FS_PORT);
1191 call->mapping = vnode->vfs_inode.i_mapping;
1192 call->first = first;
1193 call->last = last;
1194 call->first_offset = offset;
1195 call->last_to = to;
1196 call->send_pages = true;
1197 call->store_version = vnode->status.data_version + 1;
1198
1199 /* marshall the parameters */
1200 bp = call->request;
1201 *bp++ = htonl(FSSTOREDATA64);
1202 *bp++ = htonl(vnode->fid.vid);
1203 *bp++ = htonl(vnode->fid.vnode);
1204 *bp++ = htonl(vnode->fid.unique);
1205
1206 *bp++ = htonl(AFS_SET_MTIME); /* mask */
1207 *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */
1208 *bp++ = 0; /* owner */
1209 *bp++ = 0; /* group */
1210 *bp++ = 0; /* unix mode */
1211 *bp++ = 0; /* segment size */
1212
1213 *bp++ = htonl(pos >> 32);
1214 *bp++ = htonl((u32) pos);
1215 *bp++ = htonl(size >> 32);
1216 *bp++ = htonl((u32) size);
1217 *bp++ = htonl(i_size >> 32);
1218 *bp++ = htonl((u32) i_size);
1219
1220 return afs_make_call(&server->addr, call, GFP_NOFS, async);
1221 }
1222
1223 /*
1224 * store a set of pages
1225 */
1226 int afs_fs_store_data(struct afs_server *server, struct afs_writeback *wb,
1227 pgoff_t first, pgoff_t last,
1228 unsigned offset, unsigned to,
1229 bool async)
1230 {
1231 struct afs_vnode *vnode = wb->vnode;
1232 struct afs_call *call;
1233 loff_t size, pos, i_size;
1234 __be32 *bp;
1235
1236 _enter(",%x,{%x:%u},,",
1237 key_serial(wb->key), vnode->fid.vid, vnode->fid.vnode);
1238
1239 size = (loff_t)to - (loff_t)offset;
1240 if (first != last)
1241 size += (loff_t)(last - first) << PAGE_SHIFT;
1242 pos = (loff_t)first << PAGE_SHIFT;
1243 pos += offset;
1244
1245 i_size = i_size_read(&vnode->vfs_inode);
1246 if (pos + size > i_size)
1247 i_size = size + pos;
1248
1249 _debug("size %llx, at %llx, i_size %llx",
1250 (unsigned long long) size, (unsigned long long) pos,
1251 (unsigned long long) i_size);
1252
1253 if (pos >> 32 || i_size >> 32 || size >> 32 || (pos + size) >> 32)
1254 return afs_fs_store_data64(server, wb, first, last, offset, to,
1255 size, pos, i_size, async);
1256
1257 call = afs_alloc_flat_call(&afs_RXFSStoreData,
1258 (4 + 6 + 3) * 4,
1259 (21 + 6) * 4);
1260 if (!call)
1261 return -ENOMEM;
1262
1263 call->wb = wb;
1264 call->key = wb->key;
1265 call->reply = vnode;
1266 call->service_id = FS_SERVICE;
1267 call->port = htons(AFS_FS_PORT);
1268 call->mapping = vnode->vfs_inode.i_mapping;
1269 call->first = first;
1270 call->last = last;
1271 call->first_offset = offset;
1272 call->last_to = to;
1273 call->send_pages = true;
1274 call->store_version = vnode->status.data_version + 1;
1275
1276 /* marshall the parameters */
1277 bp = call->request;
1278 *bp++ = htonl(FSSTOREDATA);
1279 *bp++ = htonl(vnode->fid.vid);
1280 *bp++ = htonl(vnode->fid.vnode);
1281 *bp++ = htonl(vnode->fid.unique);
1282
1283 *bp++ = htonl(AFS_SET_MTIME); /* mask */
1284 *bp++ = htonl(vnode->vfs_inode.i_mtime.tv_sec); /* mtime */
1285 *bp++ = 0; /* owner */
1286 *bp++ = 0; /* group */
1287 *bp++ = 0; /* unix mode */
1288 *bp++ = 0; /* segment size */
1289
1290 *bp++ = htonl(pos);
1291 *bp++ = htonl(size);
1292 *bp++ = htonl(i_size);
1293
1294 return afs_make_call(&server->addr, call, GFP_NOFS, async);
1295 }
1296
1297 /*
1298 * deliver reply data to an FS.StoreStatus
1299 */
1300 static int afs_deliver_fs_store_status(struct afs_call *call)
1301 {
1302 afs_dataversion_t *store_version;
1303 struct afs_vnode *vnode = call->reply;
1304 const __be32 *bp;
1305 int ret;
1306
1307 _enter("");
1308
1309 ret = afs_transfer_reply(call);
1310 if (ret < 0)
1311 return ret;
1312
1313 /* unmarshall the reply once we've received all of it */
1314 store_version = NULL;
1315 if (call->operation_ID == FSSTOREDATA)
1316 store_version = &call->store_version;
1317
1318 bp = call->buffer;
1319 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode, store_version);
1320 /* xdr_decode_AFSVolSync(&bp, call->replyX); */
1321
1322 _leave(" = 0 [done]");
1323 return 0;
1324 }
1325
1326 /*
1327 * FS.StoreStatus operation type
1328 */
1329 static const struct afs_call_type afs_RXFSStoreStatus = {
1330 .name = "FS.StoreStatus",
1331 .deliver = afs_deliver_fs_store_status,
1332 .abort_to_error = afs_abort_to_error,
1333 .destructor = afs_flat_call_destructor,
1334 };
1335
1336 static const struct afs_call_type afs_RXFSStoreData_as_Status = {
1337 .name = "FS.StoreData",
1338 .deliver = afs_deliver_fs_store_status,
1339 .abort_to_error = afs_abort_to_error,
1340 .destructor = afs_flat_call_destructor,
1341 };
1342
1343 static const struct afs_call_type afs_RXFSStoreData64_as_Status = {
1344 .name = "FS.StoreData64",
1345 .deliver = afs_deliver_fs_store_status,
1346 .abort_to_error = afs_abort_to_error,
1347 .destructor = afs_flat_call_destructor,
1348 };
1349
1350 /*
1351 * set the attributes on a very large file, using FS.StoreData rather than
1352 * FS.StoreStatus so as to alter the file size also
1353 */
1354 static int afs_fs_setattr_size64(struct afs_server *server, struct key *key,
1355 struct afs_vnode *vnode, struct iattr *attr,
1356 bool async)
1357 {
1358 struct afs_call *call;
1359 __be32 *bp;
1360
1361 _enter(",%x,{%x:%u},,",
1362 key_serial(key), vnode->fid.vid, vnode->fid.vnode);
1363
1364 ASSERT(attr->ia_valid & ATTR_SIZE);
1365
1366 call = afs_alloc_flat_call(&afs_RXFSStoreData64_as_Status,
1367 (4 + 6 + 3 * 2) * 4,
1368 (21 + 6) * 4);
1369 if (!call)
1370 return -ENOMEM;
1371
1372 call->key = key;
1373 call->reply = vnode;
1374 call->service_id = FS_SERVICE;
1375 call->port = htons(AFS_FS_PORT);
1376 call->store_version = vnode->status.data_version + 1;
1377 call->operation_ID = FSSTOREDATA;
1378
1379 /* marshall the parameters */
1380 bp = call->request;
1381 *bp++ = htonl(FSSTOREDATA64);
1382 *bp++ = htonl(vnode->fid.vid);
1383 *bp++ = htonl(vnode->fid.vnode);
1384 *bp++ = htonl(vnode->fid.unique);
1385
1386 xdr_encode_AFS_StoreStatus(&bp, attr);
1387
1388 *bp++ = 0; /* position of start of write */
1389 *bp++ = 0;
1390 *bp++ = 0; /* size of write */
1391 *bp++ = 0;
1392 *bp++ = htonl(attr->ia_size >> 32); /* new file length */
1393 *bp++ = htonl((u32) attr->ia_size);
1394
1395 return afs_make_call(&server->addr, call, GFP_NOFS, async);
1396 }
1397
1398 /*
1399 * set the attributes on a file, using FS.StoreData rather than FS.StoreStatus
1400 * so as to alter the file size also
1401 */
1402 static int afs_fs_setattr_size(struct afs_server *server, struct key *key,
1403 struct afs_vnode *vnode, struct iattr *attr,
1404 bool async)
1405 {
1406 struct afs_call *call;
1407 __be32 *bp;
1408
1409 _enter(",%x,{%x:%u},,",
1410 key_serial(key), vnode->fid.vid, vnode->fid.vnode);
1411
1412 ASSERT(attr->ia_valid & ATTR_SIZE);
1413 if (attr->ia_size >> 32)
1414 return afs_fs_setattr_size64(server, key, vnode, attr,
1415 async);
1416
1417 call = afs_alloc_flat_call(&afs_RXFSStoreData_as_Status,
1418 (4 + 6 + 3) * 4,
1419 (21 + 6) * 4);
1420 if (!call)
1421 return -ENOMEM;
1422
1423 call->key = key;
1424 call->reply = vnode;
1425 call->service_id = FS_SERVICE;
1426 call->port = htons(AFS_FS_PORT);
1427 call->store_version = vnode->status.data_version + 1;
1428 call->operation_ID = FSSTOREDATA;
1429
1430 /* marshall the parameters */
1431 bp = call->request;
1432 *bp++ = htonl(FSSTOREDATA);
1433 *bp++ = htonl(vnode->fid.vid);
1434 *bp++ = htonl(vnode->fid.vnode);
1435 *bp++ = htonl(vnode->fid.unique);
1436
1437 xdr_encode_AFS_StoreStatus(&bp, attr);
1438
1439 *bp++ = 0; /* position of start of write */
1440 *bp++ = 0; /* size of write */
1441 *bp++ = htonl(attr->ia_size); /* new file length */
1442
1443 return afs_make_call(&server->addr, call, GFP_NOFS, async);
1444 }
1445
1446 /*
1447 * set the attributes on a file, using FS.StoreData if there's a change in file
1448 * size, and FS.StoreStatus otherwise
1449 */
1450 int afs_fs_setattr(struct afs_server *server, struct key *key,
1451 struct afs_vnode *vnode, struct iattr *attr,
1452 bool async)
1453 {
1454 struct afs_call *call;
1455 __be32 *bp;
1456
1457 if (attr->ia_valid & ATTR_SIZE)
1458 return afs_fs_setattr_size(server, key, vnode, attr,
1459 async);
1460
1461 _enter(",%x,{%x:%u},,",
1462 key_serial(key), vnode->fid.vid, vnode->fid.vnode);
1463
1464 call = afs_alloc_flat_call(&afs_RXFSStoreStatus,
1465 (4 + 6) * 4,
1466 (21 + 6) * 4);
1467 if (!call)
1468 return -ENOMEM;
1469
1470 call->key = key;
1471 call->reply = vnode;
1472 call->service_id = FS_SERVICE;
1473 call->port = htons(AFS_FS_PORT);
1474 call->operation_ID = FSSTORESTATUS;
1475
1476 /* marshall the parameters */
1477 bp = call->request;
1478 *bp++ = htonl(FSSTORESTATUS);
1479 *bp++ = htonl(vnode->fid.vid);
1480 *bp++ = htonl(vnode->fid.vnode);
1481 *bp++ = htonl(vnode->fid.unique);
1482
1483 xdr_encode_AFS_StoreStatus(&bp, attr);
1484
1485 return afs_make_call(&server->addr, call, GFP_NOFS, async);
1486 }
1487
1488 /*
1489 * deliver reply data to an FS.GetVolumeStatus
1490 */
1491 static int afs_deliver_fs_get_volume_status(struct afs_call *call)
1492 {
1493 const __be32 *bp;
1494 char *p;
1495 int ret;
1496
1497 _enter("{%u}", call->unmarshall);
1498
1499 switch (call->unmarshall) {
1500 case 0:
1501 call->offset = 0;
1502 call->unmarshall++;
1503
1504 /* extract the returned status record */
1505 case 1:
1506 _debug("extract status");
1507 ret = afs_extract_data(call, call->buffer,
1508 12 * 4, true);
1509 if (ret < 0)
1510 return ret;
1511
1512 bp = call->buffer;
1513 xdr_decode_AFSFetchVolumeStatus(&bp, call->reply2);
1514 call->offset = 0;
1515 call->unmarshall++;
1516
1517 /* extract the volume name length */
1518 case 2:
1519 ret = afs_extract_data(call, &call->tmp, 4, true);
1520 if (ret < 0)
1521 return ret;
1522
1523 call->count = ntohl(call->tmp);
1524 _debug("volname length: %u", call->count);
1525 if (call->count >= AFSNAMEMAX)
1526 return -EBADMSG;
1527 call->offset = 0;
1528 call->unmarshall++;
1529
1530 /* extract the volume name */
1531 case 3:
1532 _debug("extract volname");
1533 if (call->count > 0) {
1534 ret = afs_extract_data(call, call->reply3,
1535 call->count, true);
1536 if (ret < 0)
1537 return ret;
1538 }
1539
1540 p = call->reply3;
1541 p[call->count] = 0;
1542 _debug("volname '%s'", p);
1543
1544 call->offset = 0;
1545 call->unmarshall++;
1546
1547 /* extract the volume name padding */
1548 if ((call->count & 3) == 0) {
1549 call->unmarshall++;
1550 goto no_volname_padding;
1551 }
1552 call->count = 4 - (call->count & 3);
1553
1554 case 4:
1555 ret = afs_extract_data(call, call->buffer,
1556 call->count, true);
1557 if (ret < 0)
1558 return ret;
1559
1560 call->offset = 0;
1561 call->unmarshall++;
1562 no_volname_padding:
1563
1564 /* extract the offline message length */
1565 case 5:
1566 ret = afs_extract_data(call, &call->tmp, 4, true);
1567 if (ret < 0)
1568 return ret;
1569
1570 call->count = ntohl(call->tmp);
1571 _debug("offline msg length: %u", call->count);
1572 if (call->count >= AFSNAMEMAX)
1573 return -EBADMSG;
1574 call->offset = 0;
1575 call->unmarshall++;
1576
1577 /* extract the offline message */
1578 case 6:
1579 _debug("extract offline");
1580 if (call->count > 0) {
1581 ret = afs_extract_data(call, call->reply3,
1582 call->count, true);
1583 if (ret < 0)
1584 return ret;
1585 }
1586
1587 p = call->reply3;
1588 p[call->count] = 0;
1589 _debug("offline '%s'", p);
1590
1591 call->offset = 0;
1592 call->unmarshall++;
1593
1594 /* extract the offline message padding */
1595 if ((call->count & 3) == 0) {
1596 call->unmarshall++;
1597 goto no_offline_padding;
1598 }
1599 call->count = 4 - (call->count & 3);
1600
1601 case 7:
1602 ret = afs_extract_data(call, call->buffer,
1603 call->count, true);
1604 if (ret < 0)
1605 return ret;
1606
1607 call->offset = 0;
1608 call->unmarshall++;
1609 no_offline_padding:
1610
1611 /* extract the message of the day length */
1612 case 8:
1613 ret = afs_extract_data(call, &call->tmp, 4, true);
1614 if (ret < 0)
1615 return ret;
1616
1617 call->count = ntohl(call->tmp);
1618 _debug("motd length: %u", call->count);
1619 if (call->count >= AFSNAMEMAX)
1620 return -EBADMSG;
1621 call->offset = 0;
1622 call->unmarshall++;
1623
1624 /* extract the message of the day */
1625 case 9:
1626 _debug("extract motd");
1627 if (call->count > 0) {
1628 ret = afs_extract_data(call, call->reply3,
1629 call->count, true);
1630 if (ret < 0)
1631 return ret;
1632 }
1633
1634 p = call->reply3;
1635 p[call->count] = 0;
1636 _debug("motd '%s'", p);
1637
1638 call->offset = 0;
1639 call->unmarshall++;
1640
1641 /* extract the message of the day padding */
1642 call->count = (4 - (call->count & 3)) & 3;
1643
1644 case 10:
1645 ret = afs_extract_data(call, call->buffer,
1646 call->count, false);
1647 if (ret < 0)
1648 return ret;
1649
1650 call->offset = 0;
1651 call->unmarshall++;
1652 case 11:
1653 break;
1654 }
1655
1656 _leave(" = 0 [done]");
1657 return 0;
1658 }
1659
1660 /*
1661 * destroy an FS.GetVolumeStatus call
1662 */
1663 static void afs_get_volume_status_call_destructor(struct afs_call *call)
1664 {
1665 kfree(call->reply3);
1666 call->reply3 = NULL;
1667 afs_flat_call_destructor(call);
1668 }
1669
1670 /*
1671 * FS.GetVolumeStatus operation type
1672 */
1673 static const struct afs_call_type afs_RXFSGetVolumeStatus = {
1674 .name = "FS.GetVolumeStatus",
1675 .deliver = afs_deliver_fs_get_volume_status,
1676 .abort_to_error = afs_abort_to_error,
1677 .destructor = afs_get_volume_status_call_destructor,
1678 };
1679
1680 /*
1681 * fetch the status of a volume
1682 */
1683 int afs_fs_get_volume_status(struct afs_server *server,
1684 struct key *key,
1685 struct afs_vnode *vnode,
1686 struct afs_volume_status *vs,
1687 bool async)
1688 {
1689 struct afs_call *call;
1690 __be32 *bp;
1691 void *tmpbuf;
1692
1693 _enter("");
1694
1695 tmpbuf = kmalloc(AFSOPAQUEMAX, GFP_KERNEL);
1696 if (!tmpbuf)
1697 return -ENOMEM;
1698
1699 call = afs_alloc_flat_call(&afs_RXFSGetVolumeStatus, 2 * 4, 12 * 4);
1700 if (!call) {
1701 kfree(tmpbuf);
1702 return -ENOMEM;
1703 }
1704
1705 call->key = key;
1706 call->reply = vnode;
1707 call->reply2 = vs;
1708 call->reply3 = tmpbuf;
1709 call->service_id = FS_SERVICE;
1710 call->port = htons(AFS_FS_PORT);
1711
1712 /* marshall the parameters */
1713 bp = call->request;
1714 bp[0] = htonl(FSGETVOLUMESTATUS);
1715 bp[1] = htonl(vnode->fid.vid);
1716
1717 return afs_make_call(&server->addr, call, GFP_NOFS, async);
1718 }
1719
1720 /*
1721 * deliver reply data to an FS.SetLock, FS.ExtendLock or FS.ReleaseLock
1722 */
1723 static int afs_deliver_fs_xxxx_lock(struct afs_call *call)
1724 {
1725 const __be32 *bp;
1726 int ret;
1727
1728 _enter("{%u}", call->unmarshall);
1729
1730 ret = afs_transfer_reply(call);
1731 if (ret < 0)
1732 return ret;
1733
1734 /* unmarshall the reply once we've received all of it */
1735 bp = call->buffer;
1736 /* xdr_decode_AFSVolSync(&bp, call->replyX); */
1737
1738 _leave(" = 0 [done]");
1739 return 0;
1740 }
1741
1742 /*
1743 * FS.SetLock operation type
1744 */
1745 static const struct afs_call_type afs_RXFSSetLock = {
1746 .name = "FS.SetLock",
1747 .deliver = afs_deliver_fs_xxxx_lock,
1748 .abort_to_error = afs_abort_to_error,
1749 .destructor = afs_flat_call_destructor,
1750 };
1751
1752 /*
1753 * FS.ExtendLock operation type
1754 */
1755 static const struct afs_call_type afs_RXFSExtendLock = {
1756 .name = "FS.ExtendLock",
1757 .deliver = afs_deliver_fs_xxxx_lock,
1758 .abort_to_error = afs_abort_to_error,
1759 .destructor = afs_flat_call_destructor,
1760 };
1761
1762 /*
1763 * FS.ReleaseLock operation type
1764 */
1765 static const struct afs_call_type afs_RXFSReleaseLock = {
1766 .name = "FS.ReleaseLock",
1767 .deliver = afs_deliver_fs_xxxx_lock,
1768 .abort_to_error = afs_abort_to_error,
1769 .destructor = afs_flat_call_destructor,
1770 };
1771
1772 /*
1773 * get a lock on a file
1774 */
1775 int afs_fs_set_lock(struct afs_server *server,
1776 struct key *key,
1777 struct afs_vnode *vnode,
1778 afs_lock_type_t type,
1779 bool async)
1780 {
1781 struct afs_call *call;
1782 __be32 *bp;
1783
1784 _enter("");
1785
1786 call = afs_alloc_flat_call(&afs_RXFSSetLock, 5 * 4, 6 * 4);
1787 if (!call)
1788 return -ENOMEM;
1789
1790 call->key = key;
1791 call->reply = vnode;
1792 call->service_id = FS_SERVICE;
1793 call->port = htons(AFS_FS_PORT);
1794
1795 /* marshall the parameters */
1796 bp = call->request;
1797 *bp++ = htonl(FSSETLOCK);
1798 *bp++ = htonl(vnode->fid.vid);
1799 *bp++ = htonl(vnode->fid.vnode);
1800 *bp++ = htonl(vnode->fid.unique);
1801 *bp++ = htonl(type);
1802
1803 return afs_make_call(&server->addr, call, GFP_NOFS, async);
1804 }
1805
1806 /*
1807 * extend a lock on a file
1808 */
1809 int afs_fs_extend_lock(struct afs_server *server,
1810 struct key *key,
1811 struct afs_vnode *vnode,
1812 bool async)
1813 {
1814 struct afs_call *call;
1815 __be32 *bp;
1816
1817 _enter("");
1818
1819 call = afs_alloc_flat_call(&afs_RXFSExtendLock, 4 * 4, 6 * 4);
1820 if (!call)
1821 return -ENOMEM;
1822
1823 call->key = key;
1824 call->reply = vnode;
1825 call->service_id = FS_SERVICE;
1826 call->port = htons(AFS_FS_PORT);
1827
1828 /* marshall the parameters */
1829 bp = call->request;
1830 *bp++ = htonl(FSEXTENDLOCK);
1831 *bp++ = htonl(vnode->fid.vid);
1832 *bp++ = htonl(vnode->fid.vnode);
1833 *bp++ = htonl(vnode->fid.unique);
1834
1835 return afs_make_call(&server->addr, call, GFP_NOFS, async);
1836 }
1837
1838 /*
1839 * release a lock on a file
1840 */
1841 int afs_fs_release_lock(struct afs_server *server,
1842 struct key *key,
1843 struct afs_vnode *vnode,
1844 bool async)
1845 {
1846 struct afs_call *call;
1847 __be32 *bp;
1848
1849 _enter("");
1850
1851 call = afs_alloc_flat_call(&afs_RXFSReleaseLock, 4 * 4, 6 * 4);
1852 if (!call)
1853 return -ENOMEM;
1854
1855 call->key = key;
1856 call->reply = vnode;
1857 call->service_id = FS_SERVICE;
1858 call->port = htons(AFS_FS_PORT);
1859
1860 /* marshall the parameters */
1861 bp = call->request;
1862 *bp++ = htonl(FSRELEASELOCK);
1863 *bp++ = htonl(vnode->fid.vid);
1864 *bp++ = htonl(vnode->fid.vnode);
1865 *bp++ = htonl(vnode->fid.unique);
1866
1867 return afs_make_call(&server->addr, call, GFP_NOFS, async);
1868 }
Ubuntu Artful kernel mirror