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