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