1 /* YFS File Server client stubs
3 * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public Licence
8 * as published by the Free Software Foundation; either version
9 * 2 of the Licence, or (at your option) any later version.
12 #include <linux/init.h>
13 #include <linux/slab.h>
14 #include <linux/sched.h>
15 #include <linux/circ_buf.h>
16 #include <linux/iversion.h>
20 #include "protocol_yfs.h"
22 static const struct afs_fid afs_zero_fid
;
24 static inline void afs_use_fs_server(struct afs_call
*call
, struct afs_cb_interest
*cbi
)
26 call
->cbi
= afs_get_cb_interest(cbi
);
29 #define xdr_size(x) (sizeof(*x) / sizeof(__be32))
31 static void xdr_decode_YFSFid(const __be32
**_bp
, struct afs_fid
*fid
)
33 const struct yfs_xdr_YFSFid
*x
= (const void *)*_bp
;
35 fid
->vid
= xdr_to_u64(x
->volume
);
36 fid
->vnode
= xdr_to_u64(x
->vnode
.lo
);
37 fid
->vnode_hi
= ntohl(x
->vnode
.hi
);
38 fid
->unique
= ntohl(x
->vnode
.unique
);
42 static __be32
*xdr_encode_u32(__be32
*bp
, u32 n
)
48 static __be32
*xdr_encode_u64(__be32
*bp
, u64 n
)
50 struct yfs_xdr_u64
*x
= (void *)bp
;
53 return bp
+ xdr_size(x
);
56 static __be32
*xdr_encode_YFSFid(__be32
*bp
, struct afs_fid
*fid
)
58 struct yfs_xdr_YFSFid
*x
= (void *)bp
;
60 x
->volume
= u64_to_xdr(fid
->vid
);
61 x
->vnode
.lo
= u64_to_xdr(fid
->vnode
);
62 x
->vnode
.hi
= htonl(fid
->vnode_hi
);
63 x
->vnode
.unique
= htonl(fid
->unique
);
64 return bp
+ xdr_size(x
);
67 static size_t xdr_strlen(unsigned int len
)
69 return sizeof(__be32
) + round_up(len
, sizeof(__be32
));
72 static __be32
*xdr_encode_string(__be32
*bp
, const char *p
, unsigned int len
)
74 bp
= xdr_encode_u32(bp
, len
);
75 bp
= memcpy(bp
, p
, len
);
77 unsigned int pad
= 4 - (len
& 3);
79 memset((u8
*)bp
+ len
, 0, pad
);
83 return bp
+ len
/ sizeof(__be32
);
86 static s64
linux_to_yfs_time(const struct timespec64
*t
)
88 /* Convert to 100ns intervals. */
89 return (u64
)t
->tv_sec
* 10000000 + t
->tv_nsec
/100;
92 static __be32
*xdr_encode_YFSStoreStatus_mode(__be32
*bp
, mode_t mode
)
94 struct yfs_xdr_YFSStoreStatus
*x
= (void *)bp
;
96 x
->mask
= htonl(AFS_SET_MODE
);
97 x
->mode
= htonl(mode
& S_IALLUGO
);
98 x
->mtime_client
= u64_to_xdr(0);
99 x
->owner
= u64_to_xdr(0);
100 x
->group
= u64_to_xdr(0);
101 return bp
+ xdr_size(x
);
104 static __be32
*xdr_encode_YFSStoreStatus_mtime(__be32
*bp
, const struct timespec64
*t
)
106 struct yfs_xdr_YFSStoreStatus
*x
= (void *)bp
;
107 s64 mtime
= linux_to_yfs_time(t
);
109 x
->mask
= htonl(AFS_SET_MTIME
);
111 x
->mtime_client
= u64_to_xdr(mtime
);
112 x
->owner
= u64_to_xdr(0);
113 x
->group
= u64_to_xdr(0);
114 return bp
+ xdr_size(x
);
118 * Convert a signed 100ns-resolution 64-bit time into a timespec.
120 static struct timespec64
yfs_time_to_linux(s64 t
)
122 struct timespec64 ts
;
126 * Unfortunately can not use normal 64 bit division on 32 bit arch, but
127 * the alternative, do_div, does not work with negative numbers so have
128 * to special case them
132 ts
.tv_nsec
= (time64_t
)(do_div(abs_t
, 10000000) * 100);
133 ts
.tv_nsec
= -ts
.tv_nsec
;
137 ts
.tv_nsec
= (time64_t
)do_div(abs_t
, 10000000) * 100;
144 static struct timespec64
xdr_to_time(const struct yfs_xdr_u64 xdr
)
146 s64 t
= xdr_to_u64(xdr
);
148 return yfs_time_to_linux(t
);
151 static void yfs_check_req(struct afs_call
*call
, __be32
*bp
)
153 size_t len
= (void *)bp
- call
->request
;
155 if (len
> call
->request_size
)
156 pr_err("kAFS: %s: Request buffer overflow (%zu>%u)\n",
157 call
->type
->name
, len
, call
->request_size
);
158 else if (len
< call
->request_size
)
159 pr_warning("kAFS: %s: Request buffer underflow (%zu<%u)\n",
160 call
->type
->name
, len
, call
->request_size
);
164 * Dump a bad file status record.
166 static void xdr_dump_bad(const __be32
*bp
)
171 pr_notice("YFS XDR: Bad status record\n");
172 for (i
= 0; i
< 5 * 4 * 4; i
+= 16) {
175 pr_notice("%03x: %08x %08x %08x %08x\n",
176 i
, ntohl(x
[0]), ntohl(x
[1]), ntohl(x
[2]), ntohl(x
[3]));
180 pr_notice("0x50: %08x\n", ntohl(x
[0]));
184 * Decode a YFSFetchStatus block
186 static int xdr_decode_YFSFetchStatus(const __be32
**_bp
,
187 struct afs_call
*call
,
188 struct afs_status_cb
*scb
)
190 const struct yfs_xdr_YFSFetchStatus
*xdr
= (const void *)*_bp
;
191 struct afs_file_status
*status
= &scb
->status
;
194 status
->abort_code
= ntohl(xdr
->abort_code
);
195 if (status
->abort_code
!= 0) {
196 if (status
->abort_code
== VNOVNODE
)
198 scb
->have_error
= true;
202 type
= ntohl(xdr
->type
);
206 case AFS_FTYPE_SYMLINK
:
213 status
->nlink
= ntohl(xdr
->nlink
);
214 status
->author
= xdr_to_u64(xdr
->author
);
215 status
->owner
= xdr_to_u64(xdr
->owner
);
216 status
->caller_access
= ntohl(xdr
->caller_access
); /* Ticket dependent */
217 status
->anon_access
= ntohl(xdr
->anon_access
);
218 status
->mode
= ntohl(xdr
->mode
) & S_IALLUGO
;
219 status
->group
= xdr_to_u64(xdr
->group
);
220 status
->lock_count
= ntohl(xdr
->lock_count
);
222 status
->mtime_client
= xdr_to_time(xdr
->mtime_client
);
223 status
->mtime_server
= xdr_to_time(xdr
->mtime_server
);
224 status
->size
= xdr_to_u64(xdr
->size
);
225 status
->data_version
= xdr_to_u64(xdr
->data_version
);
226 scb
->have_status
= true;
228 *_bp
+= xdr_size(xdr
);
233 return afs_protocol_error(call
, -EBADMSG
, afs_eproto_bad_status
);
237 * Decode a YFSCallBack block
239 static void xdr_decode_YFSCallBack(const __be32
**_bp
,
240 struct afs_call
*call
,
241 struct afs_status_cb
*scb
)
243 struct yfs_xdr_YFSCallBack
*x
= (void *)*_bp
;
244 struct afs_callback
*cb
= &scb
->callback
;
247 cb_expiry
= call
->reply_time
;
248 cb_expiry
= ktime_add(cb_expiry
, xdr_to_u64(x
->expiration_time
) * 100);
249 cb
->expires_at
= ktime_divns(cb_expiry
, NSEC_PER_SEC
);
255 * Decode a YFSVolSync block
257 static void xdr_decode_YFSVolSync(const __be32
**_bp
,
258 struct afs_volsync
*volsync
)
260 struct yfs_xdr_YFSVolSync
*x
= (void *)*_bp
;
264 creation
= xdr_to_u64(x
->vol_creation_date
);
265 do_div(creation
, 10 * 1000 * 1000);
266 volsync
->creation
= creation
;
273 * Encode the requested attributes into a YFSStoreStatus block
275 static __be32
*xdr_encode_YFS_StoreStatus(__be32
*bp
, struct iattr
*attr
)
277 struct yfs_xdr_YFSStoreStatus
*x
= (void *)bp
;
278 s64 mtime
= 0, owner
= 0, group
= 0;
279 u32 mask
= 0, mode
= 0;
282 if (attr
->ia_valid
& ATTR_MTIME
) {
283 mask
|= AFS_SET_MTIME
;
284 mtime
= linux_to_yfs_time(&attr
->ia_mtime
);
287 if (attr
->ia_valid
& ATTR_UID
) {
288 mask
|= AFS_SET_OWNER
;
289 owner
= from_kuid(&init_user_ns
, attr
->ia_uid
);
292 if (attr
->ia_valid
& ATTR_GID
) {
293 mask
|= AFS_SET_GROUP
;
294 group
= from_kgid(&init_user_ns
, attr
->ia_gid
);
297 if (attr
->ia_valid
& ATTR_MODE
) {
298 mask
|= AFS_SET_MODE
;
299 mode
= attr
->ia_mode
& S_IALLUGO
;
302 x
->mask
= htonl(mask
);
303 x
->mode
= htonl(mode
);
304 x
->mtime_client
= u64_to_xdr(mtime
);
305 x
->owner
= u64_to_xdr(owner
);
306 x
->group
= u64_to_xdr(group
);
307 return bp
+ xdr_size(x
);
311 * Decode a YFSFetchVolumeStatus block.
313 static void xdr_decode_YFSFetchVolumeStatus(const __be32
**_bp
,
314 struct afs_volume_status
*vs
)
316 const struct yfs_xdr_YFSFetchVolumeStatus
*x
= (const void *)*_bp
;
319 vs
->vid
= xdr_to_u64(x
->vid
);
320 vs
->parent_id
= xdr_to_u64(x
->parent_id
);
321 flags
= ntohl(x
->flags
);
322 vs
->online
= flags
& yfs_FVSOnline
;
323 vs
->in_service
= flags
& yfs_FVSInservice
;
324 vs
->blessed
= flags
& yfs_FVSBlessed
;
325 vs
->needs_salvage
= flags
& yfs_FVSNeedsSalvage
;
326 vs
->type
= ntohl(x
->type
);
328 vs
->max_quota
= xdr_to_u64(x
->max_quota
);
329 vs
->blocks_in_use
= xdr_to_u64(x
->blocks_in_use
);
330 vs
->part_blocks_avail
= xdr_to_u64(x
->part_blocks_avail
);
331 vs
->part_max_blocks
= xdr_to_u64(x
->part_max_blocks
);
332 vs
->vol_copy_date
= xdr_to_u64(x
->vol_copy_date
);
333 vs
->vol_backup_date
= xdr_to_u64(x
->vol_backup_date
);
334 *_bp
+= sizeof(*x
) / sizeof(__be32
);
338 * Deliver a reply that's a status, callback and volsync.
340 static int yfs_deliver_fs_status_cb_and_volsync(struct afs_call
*call
)
345 ret
= afs_transfer_reply(call
);
349 /* unmarshall the reply once we've received all of it */
351 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
354 xdr_decode_YFSCallBack(&bp
, call
, call
->out_scb
);
355 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
357 _leave(" = 0 [done]");
362 * Deliver reply data to operations that just return a file status and a volume
365 static int yfs_deliver_status_and_volsync(struct afs_call
*call
)
370 ret
= afs_transfer_reply(call
);
375 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
378 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
380 _leave(" = 0 [done]");
385 * YFS.FetchStatus operation type
387 static const struct afs_call_type yfs_RXYFSFetchStatus_vnode
= {
388 .name
= "YFS.FetchStatus(vnode)",
389 .op
= yfs_FS_FetchStatus
,
390 .deliver
= yfs_deliver_fs_status_cb_and_volsync
,
391 .destructor
= afs_flat_call_destructor
,
395 * Fetch the status information for a file.
397 int yfs_fs_fetch_file_status(struct afs_fs_cursor
*fc
, struct afs_status_cb
*scb
,
398 struct afs_volsync
*volsync
)
400 struct afs_vnode
*vnode
= fc
->vnode
;
401 struct afs_call
*call
;
402 struct afs_net
*net
= afs_v2net(vnode
);
405 _enter(",%x,{%llx:%llu},,",
406 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
);
408 call
= afs_alloc_flat_call(net
, &yfs_RXYFSFetchStatus_vnode
,
410 sizeof(struct yfs_xdr_YFSFid
),
411 sizeof(struct yfs_xdr_YFSFetchStatus
) +
412 sizeof(struct yfs_xdr_YFSCallBack
) +
413 sizeof(struct yfs_xdr_YFSVolSync
));
415 fc
->ac
.error
= -ENOMEM
;
421 call
->out_volsync
= volsync
;
423 /* marshall the parameters */
425 bp
= xdr_encode_u32(bp
, YFSFETCHSTATUS
);
426 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
427 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
428 yfs_check_req(call
, bp
);
430 afs_use_fs_server(call
, fc
->cbi
);
431 trace_afs_make_fs_call(call
, &vnode
->fid
);
432 afs_set_fc_call(call
, fc
);
433 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
434 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
438 * Deliver reply data to an YFS.FetchData64.
440 static int yfs_deliver_fs_fetch_data64(struct afs_call
*call
)
442 struct afs_read
*req
= call
->read_request
;
447 _enter("{%u,%zu/%llu}",
448 call
->unmarshall
, iov_iter_count(&call
->iter
), req
->actual_len
);
450 switch (call
->unmarshall
) {
454 req
->offset
= req
->pos
& (PAGE_SIZE
- 1);
455 afs_extract_to_tmp64(call
);
458 /* Fall through - and extract the returned data length */
460 _debug("extract data length");
461 ret
= afs_extract_data(call
, true);
465 req
->actual_len
= be64_to_cpu(call
->tmp64
);
466 _debug("DATA length: %llu", req
->actual_len
);
467 req
->remain
= min(req
->len
, req
->actual_len
);
468 if (req
->remain
== 0)
474 ASSERTCMP(req
->index
, <, req
->nr_pages
);
475 if (req
->remain
> PAGE_SIZE
- req
->offset
)
476 size
= PAGE_SIZE
- req
->offset
;
479 call
->bvec
[0].bv_len
= size
;
480 call
->bvec
[0].bv_offset
= req
->offset
;
481 call
->bvec
[0].bv_page
= req
->pages
[req
->index
];
482 iov_iter_bvec(&call
->iter
, READ
, call
->bvec
, 1, size
);
483 ASSERTCMP(size
, <=, PAGE_SIZE
);
485 /* Fall through - and extract the returned data */
487 _debug("extract data %zu/%llu",
488 iov_iter_count(&call
->iter
), req
->remain
);
490 ret
= afs_extract_data(call
, true);
493 req
->remain
-= call
->bvec
[0].bv_len
;
494 req
->offset
+= call
->bvec
[0].bv_len
;
495 ASSERTCMP(req
->offset
, <=, PAGE_SIZE
);
496 if (req
->offset
== PAGE_SIZE
) {
505 ASSERTCMP(req
->remain
, ==, 0);
506 if (req
->actual_len
<= req
->len
)
509 /* Discard any excess data the server gave us */
510 iov_iter_discard(&call
->iter
, READ
, req
->actual_len
- req
->len
);
511 call
->unmarshall
= 3;
515 _debug("extract discard %zu/%llu",
516 iov_iter_count(&call
->iter
), req
->actual_len
- req
->len
);
518 ret
= afs_extract_data(call
, true);
523 call
->unmarshall
= 4;
524 afs_extract_to_buf(call
,
525 sizeof(struct yfs_xdr_YFSFetchStatus
) +
526 sizeof(struct yfs_xdr_YFSCallBack
) +
527 sizeof(struct yfs_xdr_YFSVolSync
));
529 /* Fall through - and extract the metadata */
531 ret
= afs_extract_data(call
, false);
536 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
539 xdr_decode_YFSCallBack(&bp
, call
, call
->out_scb
);
540 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
542 req
->data_version
= call
->out_scb
->status
.data_version
;
543 req
->file_size
= call
->out_scb
->status
.size
;
552 for (; req
->index
< req
->nr_pages
; req
->index
++) {
553 if (req
->offset
< PAGE_SIZE
)
554 zero_user_segment(req
->pages
[req
->index
],
555 req
->offset
, PAGE_SIZE
);
561 _leave(" = 0 [done]");
565 static void yfs_fetch_data_destructor(struct afs_call
*call
)
567 afs_put_read(call
->read_request
);
568 afs_flat_call_destructor(call
);
572 * YFS.FetchData64 operation type
574 static const struct afs_call_type yfs_RXYFSFetchData64
= {
575 .name
= "YFS.FetchData64",
576 .op
= yfs_FS_FetchData64
,
577 .deliver
= yfs_deliver_fs_fetch_data64
,
578 .destructor
= yfs_fetch_data_destructor
,
582 * Fetch data from a file.
584 int yfs_fs_fetch_data(struct afs_fs_cursor
*fc
, struct afs_status_cb
*scb
,
585 struct afs_read
*req
)
587 struct afs_vnode
*vnode
= fc
->vnode
;
588 struct afs_call
*call
;
589 struct afs_net
*net
= afs_v2net(vnode
);
592 _enter(",%x,{%llx:%llu},%llx,%llx",
593 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
,
596 call
= afs_alloc_flat_call(net
, &yfs_RXYFSFetchData64
,
598 sizeof(struct yfs_xdr_YFSFid
) +
599 sizeof(struct yfs_xdr_u64
) * 2,
600 sizeof(struct yfs_xdr_YFSFetchStatus
) +
601 sizeof(struct yfs_xdr_YFSCallBack
) +
602 sizeof(struct yfs_xdr_YFSVolSync
));
608 call
->out_volsync
= NULL
;
609 call
->read_request
= req
;
611 /* marshall the parameters */
613 bp
= xdr_encode_u32(bp
, YFSFETCHDATA64
);
614 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
615 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
616 bp
= xdr_encode_u64(bp
, req
->pos
);
617 bp
= xdr_encode_u64(bp
, req
->len
);
618 yfs_check_req(call
, bp
);
620 refcount_inc(&req
->usage
);
621 afs_use_fs_server(call
, fc
->cbi
);
622 trace_afs_make_fs_call(call
, &vnode
->fid
);
623 afs_set_fc_call(call
, fc
);
624 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
625 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
629 * Deliver reply data for YFS.CreateFile or YFS.MakeDir.
631 static int yfs_deliver_fs_create_vnode(struct afs_call
*call
)
636 _enter("{%u}", call
->unmarshall
);
638 ret
= afs_transfer_reply(call
);
642 /* unmarshall the reply once we've received all of it */
644 xdr_decode_YFSFid(&bp
, call
->out_fid
);
645 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
648 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
651 xdr_decode_YFSCallBack(&bp
, call
, call
->out_scb
);
652 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
654 _leave(" = 0 [done]");
659 * FS.CreateFile and FS.MakeDir operation type
661 static const struct afs_call_type afs_RXFSCreateFile
= {
662 .name
= "YFS.CreateFile",
663 .op
= yfs_FS_CreateFile
,
664 .deliver
= yfs_deliver_fs_create_vnode
,
665 .destructor
= afs_flat_call_destructor
,
671 int yfs_fs_create_file(struct afs_fs_cursor
*fc
,
674 struct afs_status_cb
*dvnode_scb
,
675 struct afs_fid
*newfid
,
676 struct afs_status_cb
*new_scb
)
678 struct afs_vnode
*dvnode
= fc
->vnode
;
679 struct afs_call
*call
;
680 struct afs_net
*net
= afs_v2net(dvnode
);
681 size_t namesz
, reqsz
, rplsz
;
686 namesz
= strlen(name
);
687 reqsz
= (sizeof(__be32
) +
689 sizeof(struct yfs_xdr_YFSFid
) +
691 sizeof(struct yfs_xdr_YFSStoreStatus
) +
693 rplsz
= (sizeof(struct yfs_xdr_YFSFid
) +
694 sizeof(struct yfs_xdr_YFSFetchStatus
) +
695 sizeof(struct yfs_xdr_YFSFetchStatus
) +
696 sizeof(struct yfs_xdr_YFSCallBack
) +
697 sizeof(struct yfs_xdr_YFSVolSync
));
699 call
= afs_alloc_flat_call(net
, &afs_RXFSCreateFile
, reqsz
, rplsz
);
704 call
->out_dir_scb
= dvnode_scb
;
705 call
->out_fid
= newfid
;
706 call
->out_scb
= new_scb
;
708 /* marshall the parameters */
710 bp
= xdr_encode_u32(bp
, YFSCREATEFILE
);
711 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
712 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
713 bp
= xdr_encode_string(bp
, name
, namesz
);
714 bp
= xdr_encode_YFSStoreStatus_mode(bp
, mode
);
715 bp
= xdr_encode_u32(bp
, yfs_LockNone
); /* ViceLockType */
716 yfs_check_req(call
, bp
);
718 afs_use_fs_server(call
, fc
->cbi
);
719 trace_afs_make_fs_call1(call
, &dvnode
->fid
, name
);
720 afs_set_fc_call(call
, fc
);
721 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
722 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
725 static const struct afs_call_type yfs_RXFSMakeDir
= {
726 .name
= "YFS.MakeDir",
727 .op
= yfs_FS_MakeDir
,
728 .deliver
= yfs_deliver_fs_create_vnode
,
729 .destructor
= afs_flat_call_destructor
,
735 int yfs_fs_make_dir(struct afs_fs_cursor
*fc
,
738 struct afs_status_cb
*dvnode_scb
,
739 struct afs_fid
*newfid
,
740 struct afs_status_cb
*new_scb
)
742 struct afs_vnode
*dvnode
= fc
->vnode
;
743 struct afs_call
*call
;
744 struct afs_net
*net
= afs_v2net(dvnode
);
745 size_t namesz
, reqsz
, rplsz
;
750 namesz
= strlen(name
);
751 reqsz
= (sizeof(__be32
) +
752 sizeof(struct yfs_xdr_RPCFlags
) +
753 sizeof(struct yfs_xdr_YFSFid
) +
755 sizeof(struct yfs_xdr_YFSStoreStatus
));
756 rplsz
= (sizeof(struct yfs_xdr_YFSFid
) +
757 sizeof(struct yfs_xdr_YFSFetchStatus
) +
758 sizeof(struct yfs_xdr_YFSFetchStatus
) +
759 sizeof(struct yfs_xdr_YFSCallBack
) +
760 sizeof(struct yfs_xdr_YFSVolSync
));
762 call
= afs_alloc_flat_call(net
, &yfs_RXFSMakeDir
, reqsz
, rplsz
);
767 call
->out_dir_scb
= dvnode_scb
;
768 call
->out_fid
= newfid
;
769 call
->out_scb
= new_scb
;
771 /* marshall the parameters */
773 bp
= xdr_encode_u32(bp
, YFSMAKEDIR
);
774 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
775 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
776 bp
= xdr_encode_string(bp
, name
, namesz
);
777 bp
= xdr_encode_YFSStoreStatus_mode(bp
, mode
);
778 yfs_check_req(call
, bp
);
780 afs_use_fs_server(call
, fc
->cbi
);
781 trace_afs_make_fs_call1(call
, &dvnode
->fid
, name
);
782 afs_set_fc_call(call
, fc
);
783 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
784 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
788 * Deliver reply data to a YFS.RemoveFile2 operation.
790 static int yfs_deliver_fs_remove_file2(struct afs_call
*call
)
796 _enter("{%u}", call
->unmarshall
);
798 ret
= afs_transfer_reply(call
);
803 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
807 xdr_decode_YFSFid(&bp
, &fid
);
808 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
811 /* Was deleted if vnode->status.abort_code == VNOVNODE. */
813 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
818 * YFS.RemoveFile2 operation type.
820 static const struct afs_call_type yfs_RXYFSRemoveFile2
= {
821 .name
= "YFS.RemoveFile2",
822 .op
= yfs_FS_RemoveFile2
,
823 .deliver
= yfs_deliver_fs_remove_file2
,
824 .destructor
= afs_flat_call_destructor
,
828 * Remove a file and retrieve new file status.
830 int yfs_fs_remove_file2(struct afs_fs_cursor
*fc
, struct afs_vnode
*vnode
,
831 const char *name
, struct afs_status_cb
*dvnode_scb
,
832 struct afs_status_cb
*vnode_scb
)
834 struct afs_vnode
*dvnode
= fc
->vnode
;
835 struct afs_call
*call
;
836 struct afs_net
*net
= afs_v2net(dvnode
);
842 namesz
= strlen(name
);
844 call
= afs_alloc_flat_call(net
, &yfs_RXYFSRemoveFile2
,
846 sizeof(struct yfs_xdr_RPCFlags
) +
847 sizeof(struct yfs_xdr_YFSFid
) +
849 sizeof(struct yfs_xdr_YFSFetchStatus
) +
850 sizeof(struct yfs_xdr_YFSFid
) +
851 sizeof(struct yfs_xdr_YFSFetchStatus
) +
852 sizeof(struct yfs_xdr_YFSVolSync
));
857 call
->out_dir_scb
= dvnode_scb
;
858 call
->out_scb
= vnode_scb
;
860 /* marshall the parameters */
862 bp
= xdr_encode_u32(bp
, YFSREMOVEFILE2
);
863 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
864 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
865 bp
= xdr_encode_string(bp
, name
, namesz
);
866 yfs_check_req(call
, bp
);
868 afs_use_fs_server(call
, fc
->cbi
);
869 trace_afs_make_fs_call1(call
, &dvnode
->fid
, name
);
870 afs_set_fc_call(call
, fc
);
871 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
872 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
876 * Deliver reply data to a YFS.RemoveFile or YFS.RemoveDir operation.
878 static int yfs_deliver_fs_remove(struct afs_call
*call
)
883 _enter("{%u}", call
->unmarshall
);
885 ret
= afs_transfer_reply(call
);
890 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
894 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
899 * FS.RemoveDir and FS.RemoveFile operation types.
901 static const struct afs_call_type yfs_RXYFSRemoveFile
= {
902 .name
= "YFS.RemoveFile",
903 .op
= yfs_FS_RemoveFile
,
904 .deliver
= yfs_deliver_fs_remove
,
905 .destructor
= afs_flat_call_destructor
,
908 static const struct afs_call_type yfs_RXYFSRemoveDir
= {
909 .name
= "YFS.RemoveDir",
910 .op
= yfs_FS_RemoveDir
,
911 .deliver
= yfs_deliver_fs_remove
,
912 .destructor
= afs_flat_call_destructor
,
916 * remove a file or directory
918 int yfs_fs_remove(struct afs_fs_cursor
*fc
, struct afs_vnode
*vnode
,
919 const char *name
, bool isdir
,
920 struct afs_status_cb
*dvnode_scb
)
922 struct afs_vnode
*dvnode
= fc
->vnode
;
923 struct afs_call
*call
;
924 struct afs_net
*net
= afs_v2net(dvnode
);
930 namesz
= strlen(name
);
931 call
= afs_alloc_flat_call(
932 net
, isdir
? &yfs_RXYFSRemoveDir
: &yfs_RXYFSRemoveFile
,
934 sizeof(struct yfs_xdr_RPCFlags
) +
935 sizeof(struct yfs_xdr_YFSFid
) +
937 sizeof(struct yfs_xdr_YFSFetchStatus
) +
938 sizeof(struct yfs_xdr_YFSVolSync
));
943 call
->out_dir_scb
= dvnode_scb
;
945 /* marshall the parameters */
947 bp
= xdr_encode_u32(bp
, isdir
? YFSREMOVEDIR
: YFSREMOVEFILE
);
948 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
949 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
950 bp
= xdr_encode_string(bp
, name
, namesz
);
951 yfs_check_req(call
, bp
);
953 afs_use_fs_server(call
, fc
->cbi
);
954 trace_afs_make_fs_call1(call
, &dvnode
->fid
, name
);
955 afs_set_fc_call(call
, fc
);
956 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
957 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
961 * Deliver reply data to a YFS.Link operation.
963 static int yfs_deliver_fs_link(struct afs_call
*call
)
968 _enter("{%u}", call
->unmarshall
);
970 ret
= afs_transfer_reply(call
);
975 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
978 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
981 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
982 _leave(" = 0 [done]");
987 * YFS.Link operation type.
989 static const struct afs_call_type yfs_RXYFSLink
= {
992 .deliver
= yfs_deliver_fs_link
,
993 .destructor
= afs_flat_call_destructor
,
999 int yfs_fs_link(struct afs_fs_cursor
*fc
, struct afs_vnode
*vnode
,
1001 struct afs_status_cb
*dvnode_scb
,
1002 struct afs_status_cb
*vnode_scb
)
1004 struct afs_vnode
*dvnode
= fc
->vnode
;
1005 struct afs_call
*call
;
1006 struct afs_net
*net
= afs_v2net(vnode
);
1012 namesz
= strlen(name
);
1013 call
= afs_alloc_flat_call(net
, &yfs_RXYFSLink
,
1015 sizeof(struct yfs_xdr_RPCFlags
) +
1016 sizeof(struct yfs_xdr_YFSFid
) +
1017 xdr_strlen(namesz
) +
1018 sizeof(struct yfs_xdr_YFSFid
),
1019 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1020 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1021 sizeof(struct yfs_xdr_YFSVolSync
));
1025 call
->key
= fc
->key
;
1026 call
->out_dir_scb
= dvnode_scb
;
1027 call
->out_scb
= vnode_scb
;
1029 /* marshall the parameters */
1031 bp
= xdr_encode_u32(bp
, YFSLINK
);
1032 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1033 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
1034 bp
= xdr_encode_string(bp
, name
, namesz
);
1035 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1036 yfs_check_req(call
, bp
);
1038 afs_use_fs_server(call
, fc
->cbi
);
1039 trace_afs_make_fs_call1(call
, &vnode
->fid
, name
);
1040 afs_set_fc_call(call
, fc
);
1041 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1042 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1046 * Deliver reply data to a YFS.Symlink operation.
1048 static int yfs_deliver_fs_symlink(struct afs_call
*call
)
1053 _enter("{%u}", call
->unmarshall
);
1055 ret
= afs_transfer_reply(call
);
1059 /* unmarshall the reply once we've received all of it */
1061 xdr_decode_YFSFid(&bp
, call
->out_fid
);
1062 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
1065 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
1068 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
1070 _leave(" = 0 [done]");
1075 * YFS.Symlink operation type
1077 static const struct afs_call_type yfs_RXYFSSymlink
= {
1078 .name
= "YFS.Symlink",
1079 .op
= yfs_FS_Symlink
,
1080 .deliver
= yfs_deliver_fs_symlink
,
1081 .destructor
= afs_flat_call_destructor
,
1085 * Create a symbolic link.
1087 int yfs_fs_symlink(struct afs_fs_cursor
*fc
,
1089 const char *contents
,
1090 struct afs_status_cb
*dvnode_scb
,
1091 struct afs_fid
*newfid
,
1092 struct afs_status_cb
*vnode_scb
)
1094 struct afs_vnode
*dvnode
= fc
->vnode
;
1095 struct afs_call
*call
;
1096 struct afs_net
*net
= afs_v2net(dvnode
);
1097 size_t namesz
, contents_sz
;
1102 namesz
= strlen(name
);
1103 contents_sz
= strlen(contents
);
1104 call
= afs_alloc_flat_call(net
, &yfs_RXYFSSymlink
,
1106 sizeof(struct yfs_xdr_RPCFlags
) +
1107 sizeof(struct yfs_xdr_YFSFid
) +
1108 xdr_strlen(namesz
) +
1109 xdr_strlen(contents_sz
) +
1110 sizeof(struct yfs_xdr_YFSStoreStatus
),
1111 sizeof(struct yfs_xdr_YFSFid
) +
1112 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1113 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1114 sizeof(struct yfs_xdr_YFSVolSync
));
1118 call
->key
= fc
->key
;
1119 call
->out_dir_scb
= dvnode_scb
;
1120 call
->out_fid
= newfid
;
1121 call
->out_scb
= vnode_scb
;
1123 /* marshall the parameters */
1125 bp
= xdr_encode_u32(bp
, YFSSYMLINK
);
1126 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1127 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
1128 bp
= xdr_encode_string(bp
, name
, namesz
);
1129 bp
= xdr_encode_string(bp
, contents
, contents_sz
);
1130 bp
= xdr_encode_YFSStoreStatus_mode(bp
, S_IRWXUGO
);
1131 yfs_check_req(call
, bp
);
1133 afs_use_fs_server(call
, fc
->cbi
);
1134 trace_afs_make_fs_call1(call
, &dvnode
->fid
, name
);
1135 afs_set_fc_call(call
, fc
);
1136 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1137 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1141 * Deliver reply data to a YFS.Rename operation.
1143 static int yfs_deliver_fs_rename(struct afs_call
*call
)
1148 _enter("{%u}", call
->unmarshall
);
1150 ret
= afs_transfer_reply(call
);
1155 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
1158 if (call
->out_dir_scb
!= call
->out_scb
) {
1159 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
1164 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
1165 _leave(" = 0 [done]");
1170 * YFS.Rename operation type
1172 static const struct afs_call_type yfs_RXYFSRename
= {
1173 .name
= "FS.Rename",
1174 .op
= yfs_FS_Rename
,
1175 .deliver
= yfs_deliver_fs_rename
,
1176 .destructor
= afs_flat_call_destructor
,
1180 * Rename a file or directory.
1182 int yfs_fs_rename(struct afs_fs_cursor
*fc
,
1183 const char *orig_name
,
1184 struct afs_vnode
*new_dvnode
,
1185 const char *new_name
,
1186 struct afs_status_cb
*orig_dvnode_scb
,
1187 struct afs_status_cb
*new_dvnode_scb
)
1189 struct afs_vnode
*orig_dvnode
= fc
->vnode
;
1190 struct afs_call
*call
;
1191 struct afs_net
*net
= afs_v2net(orig_dvnode
);
1192 size_t o_namesz
, n_namesz
;
1197 o_namesz
= strlen(orig_name
);
1198 n_namesz
= strlen(new_name
);
1199 call
= afs_alloc_flat_call(net
, &yfs_RXYFSRename
,
1201 sizeof(struct yfs_xdr_RPCFlags
) +
1202 sizeof(struct yfs_xdr_YFSFid
) +
1203 xdr_strlen(o_namesz
) +
1204 sizeof(struct yfs_xdr_YFSFid
) +
1205 xdr_strlen(n_namesz
),
1206 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1207 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1208 sizeof(struct yfs_xdr_YFSVolSync
));
1212 call
->key
= fc
->key
;
1213 call
->out_dir_scb
= orig_dvnode_scb
;
1214 call
->out_scb
= new_dvnode_scb
;
1216 /* marshall the parameters */
1218 bp
= xdr_encode_u32(bp
, YFSRENAME
);
1219 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1220 bp
= xdr_encode_YFSFid(bp
, &orig_dvnode
->fid
);
1221 bp
= xdr_encode_string(bp
, orig_name
, o_namesz
);
1222 bp
= xdr_encode_YFSFid(bp
, &new_dvnode
->fid
);
1223 bp
= xdr_encode_string(bp
, new_name
, n_namesz
);
1224 yfs_check_req(call
, bp
);
1226 afs_use_fs_server(call
, fc
->cbi
);
1227 trace_afs_make_fs_call2(call
, &orig_dvnode
->fid
, orig_name
, new_name
);
1228 afs_set_fc_call(call
, fc
);
1229 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1230 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1234 * YFS.StoreData64 operation type.
1236 static const struct afs_call_type yfs_RXYFSStoreData64
= {
1237 .name
= "YFS.StoreData64",
1238 .op
= yfs_FS_StoreData64
,
1239 .deliver
= yfs_deliver_status_and_volsync
,
1240 .destructor
= afs_flat_call_destructor
,
1244 * Store a set of pages to a large file.
1246 int yfs_fs_store_data(struct afs_fs_cursor
*fc
, struct address_space
*mapping
,
1247 pgoff_t first
, pgoff_t last
,
1248 unsigned offset
, unsigned to
,
1249 struct afs_status_cb
*scb
)
1251 struct afs_vnode
*vnode
= fc
->vnode
;
1252 struct afs_call
*call
;
1253 struct afs_net
*net
= afs_v2net(vnode
);
1254 loff_t size
, pos
, i_size
;
1257 _enter(",%x,{%llx:%llu},,",
1258 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
);
1260 size
= (loff_t
)to
- (loff_t
)offset
;
1262 size
+= (loff_t
)(last
- first
) << PAGE_SHIFT
;
1263 pos
= (loff_t
)first
<< PAGE_SHIFT
;
1266 i_size
= i_size_read(&vnode
->vfs_inode
);
1267 if (pos
+ size
> i_size
)
1268 i_size
= size
+ pos
;
1270 _debug("size %llx, at %llx, i_size %llx",
1271 (unsigned long long)size
, (unsigned long long)pos
,
1272 (unsigned long long)i_size
);
1274 call
= afs_alloc_flat_call(net
, &yfs_RXYFSStoreData64
,
1277 sizeof(struct yfs_xdr_YFSFid
) +
1278 sizeof(struct yfs_xdr_YFSStoreStatus
) +
1279 sizeof(struct yfs_xdr_u64
) * 3,
1280 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1281 sizeof(struct yfs_xdr_YFSVolSync
));
1285 call
->key
= fc
->key
;
1286 call
->mapping
= mapping
;
1287 call
->first
= first
;
1289 call
->first_offset
= offset
;
1291 call
->send_pages
= true;
1292 call
->out_scb
= scb
;
1294 /* marshall the parameters */
1296 bp
= xdr_encode_u32(bp
, YFSSTOREDATA64
);
1297 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1298 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1299 bp
= xdr_encode_YFSStoreStatus_mtime(bp
, &vnode
->vfs_inode
.i_mtime
);
1300 bp
= xdr_encode_u64(bp
, pos
);
1301 bp
= xdr_encode_u64(bp
, size
);
1302 bp
= xdr_encode_u64(bp
, i_size
);
1303 yfs_check_req(call
, bp
);
1305 afs_use_fs_server(call
, fc
->cbi
);
1306 trace_afs_make_fs_call(call
, &vnode
->fid
);
1307 afs_set_fc_call(call
, fc
);
1308 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1309 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1313 * YFS.StoreStatus operation type
1315 static const struct afs_call_type yfs_RXYFSStoreStatus
= {
1316 .name
= "YFS.StoreStatus",
1317 .op
= yfs_FS_StoreStatus
,
1318 .deliver
= yfs_deliver_status_and_volsync
,
1319 .destructor
= afs_flat_call_destructor
,
1322 static const struct afs_call_type yfs_RXYFSStoreData64_as_Status
= {
1323 .name
= "YFS.StoreData64",
1324 .op
= yfs_FS_StoreData64
,
1325 .deliver
= yfs_deliver_status_and_volsync
,
1326 .destructor
= afs_flat_call_destructor
,
1330 * Set the attributes on a file, using YFS.StoreData64 rather than
1331 * YFS.StoreStatus so as to alter the file size also.
1333 static int yfs_fs_setattr_size(struct afs_fs_cursor
*fc
, struct iattr
*attr
,
1334 struct afs_status_cb
*scb
)
1336 struct afs_vnode
*vnode
= fc
->vnode
;
1337 struct afs_call
*call
;
1338 struct afs_net
*net
= afs_v2net(vnode
);
1341 _enter(",%x,{%llx:%llu},,",
1342 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
);
1344 call
= afs_alloc_flat_call(net
, &yfs_RXYFSStoreData64_as_Status
,
1345 sizeof(__be32
) * 2 +
1346 sizeof(struct yfs_xdr_YFSFid
) +
1347 sizeof(struct yfs_xdr_YFSStoreStatus
) +
1348 sizeof(struct yfs_xdr_u64
) * 3,
1349 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1350 sizeof(struct yfs_xdr_YFSVolSync
));
1354 call
->key
= fc
->key
;
1355 call
->out_scb
= scb
;
1357 /* marshall the parameters */
1359 bp
= xdr_encode_u32(bp
, YFSSTOREDATA64
);
1360 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1361 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1362 bp
= xdr_encode_YFS_StoreStatus(bp
, attr
);
1363 bp
= xdr_encode_u64(bp
, attr
->ia_size
); /* position of start of write */
1364 bp
= xdr_encode_u64(bp
, 0); /* size of write */
1365 bp
= xdr_encode_u64(bp
, attr
->ia_size
); /* new file length */
1366 yfs_check_req(call
, bp
);
1368 afs_use_fs_server(call
, fc
->cbi
);
1369 trace_afs_make_fs_call(call
, &vnode
->fid
);
1370 afs_set_fc_call(call
, fc
);
1371 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1372 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1376 * Set the attributes on a file, using YFS.StoreData64 if there's a change in
1377 * file size, and YFS.StoreStatus otherwise.
1379 int yfs_fs_setattr(struct afs_fs_cursor
*fc
, struct iattr
*attr
,
1380 struct afs_status_cb
*scb
)
1382 struct afs_vnode
*vnode
= fc
->vnode
;
1383 struct afs_call
*call
;
1384 struct afs_net
*net
= afs_v2net(vnode
);
1387 if (attr
->ia_valid
& ATTR_SIZE
)
1388 return yfs_fs_setattr_size(fc
, attr
, scb
);
1390 _enter(",%x,{%llx:%llu},,",
1391 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
);
1393 call
= afs_alloc_flat_call(net
, &yfs_RXYFSStoreStatus
,
1394 sizeof(__be32
) * 2 +
1395 sizeof(struct yfs_xdr_YFSFid
) +
1396 sizeof(struct yfs_xdr_YFSStoreStatus
),
1397 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1398 sizeof(struct yfs_xdr_YFSVolSync
));
1402 call
->key
= fc
->key
;
1403 call
->out_scb
= scb
;
1405 /* marshall the parameters */
1407 bp
= xdr_encode_u32(bp
, YFSSTORESTATUS
);
1408 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1409 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1410 bp
= xdr_encode_YFS_StoreStatus(bp
, attr
);
1411 yfs_check_req(call
, bp
);
1413 afs_use_fs_server(call
, fc
->cbi
);
1414 trace_afs_make_fs_call(call
, &vnode
->fid
);
1415 afs_set_fc_call(call
, fc
);
1416 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1417 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1421 * Deliver reply data to a YFS.GetVolumeStatus operation.
1423 static int yfs_deliver_fs_get_volume_status(struct afs_call
*call
)
1430 _enter("{%u}", call
->unmarshall
);
1432 switch (call
->unmarshall
) {
1435 afs_extract_to_buf(call
, sizeof(struct yfs_xdr_YFSFetchVolumeStatus
));
1437 /* Fall through - and extract the returned status record */
1439 _debug("extract status");
1440 ret
= afs_extract_data(call
, true);
1445 xdr_decode_YFSFetchVolumeStatus(&bp
, call
->out_volstatus
);
1447 afs_extract_to_tmp(call
);
1449 /* Fall through - and extract the volume name length */
1451 ret
= afs_extract_data(call
, true);
1455 call
->count
= ntohl(call
->tmp
);
1456 _debug("volname length: %u", call
->count
);
1457 if (call
->count
>= AFSNAMEMAX
)
1458 return afs_protocol_error(call
, -EBADMSG
,
1459 afs_eproto_volname_len
);
1460 size
= (call
->count
+ 3) & ~3; /* It's padded */
1461 afs_extract_to_buf(call
, size
);
1464 /* Fall through - and extract the volume name */
1466 _debug("extract volname");
1467 ret
= afs_extract_data(call
, true);
1473 _debug("volname '%s'", p
);
1474 afs_extract_to_tmp(call
);
1477 /* Fall through - and extract the offline message length */
1479 ret
= afs_extract_data(call
, true);
1483 call
->count
= ntohl(call
->tmp
);
1484 _debug("offline msg length: %u", call
->count
);
1485 if (call
->count
>= AFSNAMEMAX
)
1486 return afs_protocol_error(call
, -EBADMSG
,
1487 afs_eproto_offline_msg_len
);
1488 size
= (call
->count
+ 3) & ~3; /* It's padded */
1489 afs_extract_to_buf(call
, size
);
1492 /* Fall through - and extract the offline message */
1494 _debug("extract offline");
1495 ret
= afs_extract_data(call
, true);
1501 _debug("offline '%s'", p
);
1503 afs_extract_to_tmp(call
);
1506 /* Fall through - and extract the message of the day length */
1508 ret
= afs_extract_data(call
, true);
1512 call
->count
= ntohl(call
->tmp
);
1513 _debug("motd length: %u", call
->count
);
1514 if (call
->count
>= AFSNAMEMAX
)
1515 return afs_protocol_error(call
, -EBADMSG
,
1516 afs_eproto_motd_len
);
1517 size
= (call
->count
+ 3) & ~3; /* It's padded */
1518 afs_extract_to_buf(call
, size
);
1521 /* Fall through - and extract the message of the day */
1523 _debug("extract motd");
1524 ret
= afs_extract_data(call
, false);
1530 _debug("motd '%s'", p
);
1539 _leave(" = 0 [done]");
1544 * YFS.GetVolumeStatus operation type
1546 static const struct afs_call_type yfs_RXYFSGetVolumeStatus
= {
1547 .name
= "YFS.GetVolumeStatus",
1548 .op
= yfs_FS_GetVolumeStatus
,
1549 .deliver
= yfs_deliver_fs_get_volume_status
,
1550 .destructor
= afs_flat_call_destructor
,
1554 * fetch the status of a volume
1556 int yfs_fs_get_volume_status(struct afs_fs_cursor
*fc
,
1557 struct afs_volume_status
*vs
)
1559 struct afs_vnode
*vnode
= fc
->vnode
;
1560 struct afs_call
*call
;
1561 struct afs_net
*net
= afs_v2net(vnode
);
1566 call
= afs_alloc_flat_call(net
, &yfs_RXYFSGetVolumeStatus
,
1567 sizeof(__be32
) * 2 +
1568 sizeof(struct yfs_xdr_u64
),
1570 sizeof(struct yfs_xdr_YFSFetchVolumeStatus
) +
1576 call
->key
= fc
->key
;
1577 call
->out_volstatus
= vs
;
1579 /* marshall the parameters */
1581 bp
= xdr_encode_u32(bp
, YFSGETVOLUMESTATUS
);
1582 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1583 bp
= xdr_encode_u64(bp
, vnode
->fid
.vid
);
1584 yfs_check_req(call
, bp
);
1586 afs_use_fs_server(call
, fc
->cbi
);
1587 trace_afs_make_fs_call(call
, &vnode
->fid
);
1588 afs_set_fc_call(call
, fc
);
1589 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1590 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1594 * YFS.SetLock operation type
1596 static const struct afs_call_type yfs_RXYFSSetLock
= {
1597 .name
= "YFS.SetLock",
1598 .op
= yfs_FS_SetLock
,
1599 .deliver
= yfs_deliver_status_and_volsync
,
1600 .done
= afs_lock_op_done
,
1601 .destructor
= afs_flat_call_destructor
,
1605 * YFS.ExtendLock operation type
1607 static const struct afs_call_type yfs_RXYFSExtendLock
= {
1608 .name
= "YFS.ExtendLock",
1609 .op
= yfs_FS_ExtendLock
,
1610 .deliver
= yfs_deliver_status_and_volsync
,
1611 .done
= afs_lock_op_done
,
1612 .destructor
= afs_flat_call_destructor
,
1616 * YFS.ReleaseLock operation type
1618 static const struct afs_call_type yfs_RXYFSReleaseLock
= {
1619 .name
= "YFS.ReleaseLock",
1620 .op
= yfs_FS_ReleaseLock
,
1621 .deliver
= yfs_deliver_status_and_volsync
,
1622 .destructor
= afs_flat_call_destructor
,
1626 * Set a lock on a file
1628 int yfs_fs_set_lock(struct afs_fs_cursor
*fc
, afs_lock_type_t type
,
1629 struct afs_status_cb
*scb
)
1631 struct afs_vnode
*vnode
= fc
->vnode
;
1632 struct afs_call
*call
;
1633 struct afs_net
*net
= afs_v2net(vnode
);
1638 call
= afs_alloc_flat_call(net
, &yfs_RXYFSSetLock
,
1639 sizeof(__be32
) * 2 +
1640 sizeof(struct yfs_xdr_YFSFid
) +
1642 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1643 sizeof(struct yfs_xdr_YFSVolSync
));
1647 call
->key
= fc
->key
;
1648 call
->lvnode
= vnode
;
1649 call
->out_scb
= scb
;
1651 /* marshall the parameters */
1653 bp
= xdr_encode_u32(bp
, YFSSETLOCK
);
1654 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1655 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1656 bp
= xdr_encode_u32(bp
, type
);
1657 yfs_check_req(call
, bp
);
1659 afs_use_fs_server(call
, fc
->cbi
);
1660 trace_afs_make_fs_calli(call
, &vnode
->fid
, type
);
1661 afs_set_fc_call(call
, fc
);
1662 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1663 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1667 * extend a lock on a file
1669 int yfs_fs_extend_lock(struct afs_fs_cursor
*fc
, struct afs_status_cb
*scb
)
1671 struct afs_vnode
*vnode
= fc
->vnode
;
1672 struct afs_call
*call
;
1673 struct afs_net
*net
= afs_v2net(vnode
);
1678 call
= afs_alloc_flat_call(net
, &yfs_RXYFSExtendLock
,
1679 sizeof(__be32
) * 2 +
1680 sizeof(struct yfs_xdr_YFSFid
),
1681 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1682 sizeof(struct yfs_xdr_YFSVolSync
));
1686 call
->key
= fc
->key
;
1687 call
->lvnode
= vnode
;
1688 call
->out_scb
= scb
;
1690 /* marshall the parameters */
1692 bp
= xdr_encode_u32(bp
, YFSEXTENDLOCK
);
1693 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1694 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1695 yfs_check_req(call
, bp
);
1697 afs_use_fs_server(call
, fc
->cbi
);
1698 trace_afs_make_fs_call(call
, &vnode
->fid
);
1699 afs_set_fc_call(call
, fc
);
1700 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1701 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1705 * release a lock on a file
1707 int yfs_fs_release_lock(struct afs_fs_cursor
*fc
, struct afs_status_cb
*scb
)
1709 struct afs_vnode
*vnode
= fc
->vnode
;
1710 struct afs_call
*call
;
1711 struct afs_net
*net
= afs_v2net(vnode
);
1716 call
= afs_alloc_flat_call(net
, &yfs_RXYFSReleaseLock
,
1717 sizeof(__be32
) * 2 +
1718 sizeof(struct yfs_xdr_YFSFid
),
1719 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1720 sizeof(struct yfs_xdr_YFSVolSync
));
1724 call
->key
= fc
->key
;
1725 call
->lvnode
= vnode
;
1726 call
->out_scb
= scb
;
1728 /* marshall the parameters */
1730 bp
= xdr_encode_u32(bp
, YFSRELEASELOCK
);
1731 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1732 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1733 yfs_check_req(call
, bp
);
1735 afs_use_fs_server(call
, fc
->cbi
);
1736 trace_afs_make_fs_call(call
, &vnode
->fid
);
1737 afs_set_fc_call(call
, fc
);
1738 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1739 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1743 * YFS.FetchStatus operation type
1745 static const struct afs_call_type yfs_RXYFSFetchStatus
= {
1746 .name
= "YFS.FetchStatus",
1747 .op
= yfs_FS_FetchStatus
,
1748 .deliver
= yfs_deliver_fs_status_cb_and_volsync
,
1749 .destructor
= afs_flat_call_destructor
,
1753 * Fetch the status information for a fid without needing a vnode handle.
1755 int yfs_fs_fetch_status(struct afs_fs_cursor
*fc
,
1756 struct afs_net
*net
,
1757 struct afs_fid
*fid
,
1758 struct afs_status_cb
*scb
,
1759 struct afs_volsync
*volsync
)
1761 struct afs_call
*call
;
1764 _enter(",%x,{%llx:%llu},,",
1765 key_serial(fc
->key
), fid
->vid
, fid
->vnode
);
1767 call
= afs_alloc_flat_call(net
, &yfs_RXYFSFetchStatus
,
1768 sizeof(__be32
) * 2 +
1769 sizeof(struct yfs_xdr_YFSFid
),
1770 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1771 sizeof(struct yfs_xdr_YFSCallBack
) +
1772 sizeof(struct yfs_xdr_YFSVolSync
));
1774 fc
->ac
.error
= -ENOMEM
;
1778 call
->key
= fc
->key
;
1779 call
->out_scb
= scb
;
1780 call
->out_volsync
= volsync
;
1782 /* marshall the parameters */
1784 bp
= xdr_encode_u32(bp
, YFSFETCHSTATUS
);
1785 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1786 bp
= xdr_encode_YFSFid(bp
, fid
);
1787 yfs_check_req(call
, bp
);
1789 afs_use_fs_server(call
, fc
->cbi
);
1790 trace_afs_make_fs_call(call
, fid
);
1791 afs_set_fc_call(call
, fc
);
1792 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1793 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1797 * Deliver reply data to an YFS.InlineBulkStatus call
1799 static int yfs_deliver_fs_inline_bulk_status(struct afs_call
*call
)
1801 struct afs_status_cb
*scb
;
1806 _enter("{%u}", call
->unmarshall
);
1808 switch (call
->unmarshall
) {
1810 afs_extract_to_tmp(call
);
1813 /* Extract the file status count and array in two steps */
1816 _debug("extract status count");
1817 ret
= afs_extract_data(call
, true);
1821 tmp
= ntohl(call
->tmp
);
1822 _debug("status count: %u/%u", tmp
, call
->count2
);
1823 if (tmp
!= call
->count2
)
1824 return afs_protocol_error(call
, -EBADMSG
,
1825 afs_eproto_ibulkst_count
);
1830 afs_extract_to_buf(call
, sizeof(struct yfs_xdr_YFSFetchStatus
));
1834 _debug("extract status array %u", call
->count
);
1835 ret
= afs_extract_data(call
, true);
1840 scb
= &call
->out_scb
[call
->count
];
1841 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, scb
);
1846 if (call
->count
< call
->count2
)
1851 afs_extract_to_tmp(call
);
1853 /* Extract the callback count and array in two steps */
1856 _debug("extract CB count");
1857 ret
= afs_extract_data(call
, true);
1861 tmp
= ntohl(call
->tmp
);
1862 _debug("CB count: %u", tmp
);
1863 if (tmp
!= call
->count2
)
1864 return afs_protocol_error(call
, -EBADMSG
,
1865 afs_eproto_ibulkst_cb_count
);
1869 afs_extract_to_buf(call
, sizeof(struct yfs_xdr_YFSCallBack
));
1873 _debug("extract CB array");
1874 ret
= afs_extract_data(call
, true);
1878 _debug("unmarshall CB array");
1880 scb
= &call
->out_scb
[call
->count
];
1881 xdr_decode_YFSCallBack(&bp
, call
, scb
);
1883 if (call
->count
< call
->count2
)
1886 afs_extract_to_buf(call
, sizeof(struct yfs_xdr_YFSVolSync
));
1891 ret
= afs_extract_data(call
, false);
1896 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
1905 _leave(" = 0 [done]");
1910 * FS.InlineBulkStatus operation type
1912 static const struct afs_call_type yfs_RXYFSInlineBulkStatus
= {
1913 .name
= "YFS.InlineBulkStatus",
1914 .op
= yfs_FS_InlineBulkStatus
,
1915 .deliver
= yfs_deliver_fs_inline_bulk_status
,
1916 .destructor
= afs_flat_call_destructor
,
1920 * Fetch the status information for up to 1024 files
1922 int yfs_fs_inline_bulk_status(struct afs_fs_cursor
*fc
,
1923 struct afs_net
*net
,
1924 struct afs_fid
*fids
,
1925 struct afs_status_cb
*statuses
,
1926 unsigned int nr_fids
,
1927 struct afs_volsync
*volsync
)
1929 struct afs_call
*call
;
1933 _enter(",%x,{%llx:%llu},%u",
1934 key_serial(fc
->key
), fids
[0].vid
, fids
[1].vnode
, nr_fids
);
1936 call
= afs_alloc_flat_call(net
, &yfs_RXYFSInlineBulkStatus
,
1940 sizeof(struct yfs_xdr_YFSFid
) * nr_fids
,
1941 sizeof(struct yfs_xdr_YFSFetchStatus
));
1943 fc
->ac
.error
= -ENOMEM
;
1947 call
->key
= fc
->key
;
1948 call
->out_scb
= statuses
;
1949 call
->out_volsync
= volsync
;
1950 call
->count2
= nr_fids
;
1952 /* marshall the parameters */
1954 bp
= xdr_encode_u32(bp
, YFSINLINEBULKSTATUS
);
1955 bp
= xdr_encode_u32(bp
, 0); /* RPCFlags */
1956 bp
= xdr_encode_u32(bp
, nr_fids
);
1957 for (i
= 0; i
< nr_fids
; i
++)
1958 bp
= xdr_encode_YFSFid(bp
, &fids
[i
]);
1959 yfs_check_req(call
, bp
);
1961 afs_use_fs_server(call
, fc
->cbi
);
1962 trace_afs_make_fs_call(call
, &fids
[0]);
1963 afs_set_fc_call(call
, fc
);
1964 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1965 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1969 * Deliver reply data to an YFS.FetchOpaqueACL.
1971 static int yfs_deliver_fs_fetch_opaque_acl(struct afs_call
*call
)
1973 struct yfs_acl
*yacl
= call
->out_yacl
;
1974 struct afs_acl
*acl
;
1979 _enter("{%u}", call
->unmarshall
);
1981 switch (call
->unmarshall
) {
1983 afs_extract_to_tmp(call
);
1986 /* Extract the file ACL length */
1988 ret
= afs_extract_data(call
, true);
1992 size
= call
->count2
= ntohl(call
->tmp
);
1993 size
= round_up(size
, 4);
1995 if (yacl
->flags
& YFS_ACL_WANT_ACL
) {
1996 acl
= kmalloc(struct_size(acl
, data
, size
), GFP_KERNEL
);
2000 acl
->size
= call
->count2
;
2001 afs_extract_begin(call
, acl
->data
, size
);
2003 iov_iter_discard(&call
->iter
, READ
, size
);
2007 /* Extract the file ACL */
2009 ret
= afs_extract_data(call
, true);
2013 afs_extract_to_tmp(call
);
2016 /* Extract the volume ACL length */
2018 ret
= afs_extract_data(call
, true);
2022 size
= call
->count2
= ntohl(call
->tmp
);
2023 size
= round_up(size
, 4);
2025 if (yacl
->flags
& YFS_ACL_WANT_VOL_ACL
) {
2026 acl
= kmalloc(struct_size(acl
, data
, size
), GFP_KERNEL
);
2029 yacl
->vol_acl
= acl
;
2030 acl
->size
= call
->count2
;
2031 afs_extract_begin(call
, acl
->data
, size
);
2033 iov_iter_discard(&call
->iter
, READ
, size
);
2037 /* Extract the volume ACL */
2039 ret
= afs_extract_data(call
, true);
2043 afs_extract_to_buf(call
,
2044 sizeof(__be32
) * 2 +
2045 sizeof(struct yfs_xdr_YFSFetchStatus
) +
2046 sizeof(struct yfs_xdr_YFSVolSync
));
2049 /* extract the metadata */
2051 ret
= afs_extract_data(call
, false);
2056 yacl
->inherit_flag
= ntohl(*bp
++);
2057 yacl
->num_cleaned
= ntohl(*bp
++);
2058 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
2061 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
2069 _leave(" = 0 [done]");
2073 void yfs_free_opaque_acl(struct yfs_acl
*yacl
)
2077 kfree(yacl
->vol_acl
);
2083 * YFS.FetchOpaqueACL operation type
2085 static const struct afs_call_type yfs_RXYFSFetchOpaqueACL
= {
2086 .name
= "YFS.FetchOpaqueACL",
2087 .op
= yfs_FS_FetchOpaqueACL
,
2088 .deliver
= yfs_deliver_fs_fetch_opaque_acl
,
2089 .destructor
= afs_flat_call_destructor
,
2093 * Fetch the YFS advanced ACLs for a file.
2095 struct yfs_acl
*yfs_fs_fetch_opaque_acl(struct afs_fs_cursor
*fc
,
2096 struct yfs_acl
*yacl
,
2097 struct afs_status_cb
*scb
)
2099 struct afs_vnode
*vnode
= fc
->vnode
;
2100 struct afs_call
*call
;
2101 struct afs_net
*net
= afs_v2net(vnode
);
2104 _enter(",%x,{%llx:%llu},,",
2105 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
);
2107 call
= afs_alloc_flat_call(net
, &yfs_RXYFSFetchOpaqueACL
,
2108 sizeof(__be32
) * 2 +
2109 sizeof(struct yfs_xdr_YFSFid
),
2110 sizeof(__be32
) * 2 +
2111 sizeof(struct yfs_xdr_YFSFetchStatus
) +
2112 sizeof(struct yfs_xdr_YFSVolSync
));
2114 fc
->ac
.error
= -ENOMEM
;
2115 return ERR_PTR(-ENOMEM
);
2118 call
->key
= fc
->key
;
2119 call
->out_yacl
= yacl
;
2120 call
->out_scb
= scb
;
2121 call
->out_volsync
= NULL
;
2123 /* marshall the parameters */
2125 bp
= xdr_encode_u32(bp
, YFSFETCHOPAQUEACL
);
2126 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
2127 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
2128 yfs_check_req(call
, bp
);
2130 afs_use_fs_server(call
, fc
->cbi
);
2131 trace_afs_make_fs_call(call
, &vnode
->fid
);
2132 afs_make_call(&fc
->ac
, call
, GFP_KERNEL
);
2133 return (struct yfs_acl
*)afs_wait_for_call_to_complete(call
, &fc
->ac
);
2137 * YFS.StoreOpaqueACL2 operation type
2139 static const struct afs_call_type yfs_RXYFSStoreOpaqueACL2
= {
2140 .name
= "YFS.StoreOpaqueACL2",
2141 .op
= yfs_FS_StoreOpaqueACL2
,
2142 .deliver
= yfs_deliver_status_and_volsync
,
2143 .destructor
= afs_flat_call_destructor
,
2147 * Fetch the YFS ACL for a file.
2149 int yfs_fs_store_opaque_acl2(struct afs_fs_cursor
*fc
, const struct afs_acl
*acl
,
2150 struct afs_status_cb
*scb
)
2152 struct afs_vnode
*vnode
= fc
->vnode
;
2153 struct afs_call
*call
;
2154 struct afs_net
*net
= afs_v2net(vnode
);
2158 _enter(",%x,{%llx:%llu},,",
2159 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
);
2161 size
= round_up(acl
->size
, 4);
2162 call
= afs_alloc_flat_call(net
, &yfs_RXYFSStoreStatus
,
2163 sizeof(__be32
) * 2 +
2164 sizeof(struct yfs_xdr_YFSFid
) +
2165 sizeof(__be32
) + size
,
2166 sizeof(struct yfs_xdr_YFSFetchStatus
) +
2167 sizeof(struct yfs_xdr_YFSVolSync
));
2169 fc
->ac
.error
= -ENOMEM
;
2173 call
->key
= fc
->key
;
2174 call
->out_scb
= scb
;
2175 call
->out_volsync
= NULL
;
2177 /* marshall the parameters */
2179 bp
= xdr_encode_u32(bp
, YFSSTOREOPAQUEACL2
);
2180 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
2181 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
2182 bp
= xdr_encode_u32(bp
, acl
->size
);
2183 memcpy(bp
, acl
->data
, acl
->size
);
2184 if (acl
->size
!= size
)
2185 memset((void *)bp
+ acl
->size
, 0, size
- acl
->size
);
2186 yfs_check_req(call
, bp
);
2188 trace_afs_make_fs_call(call
, &vnode
->fid
);
2189 afs_make_call(&fc
->ac
, call
, GFP_KERNEL
);
2190 return afs_wait_for_call_to_complete(call
, &fc
->ac
);