1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* YFS File Server client stubs
4 * Copyright (C) 2018 Red Hat, Inc. All Rights Reserved.
5 * Written by David Howells (dhowells@redhat.com)
8 #include <linux/init.h>
9 #include <linux/slab.h>
10 #include <linux/sched.h>
11 #include <linux/circ_buf.h>
12 #include <linux/iversion.h>
16 #include "protocol_yfs.h"
18 static const struct afs_fid afs_zero_fid
;
20 static inline void afs_use_fs_server(struct afs_call
*call
, struct afs_cb_interest
*cbi
)
22 call
->cbi
= afs_get_cb_interest(cbi
);
25 #define xdr_size(x) (sizeof(*x) / sizeof(__be32))
27 static void xdr_decode_YFSFid(const __be32
**_bp
, struct afs_fid
*fid
)
29 const struct yfs_xdr_YFSFid
*x
= (const void *)*_bp
;
31 fid
->vid
= xdr_to_u64(x
->volume
);
32 fid
->vnode
= xdr_to_u64(x
->vnode
.lo
);
33 fid
->vnode_hi
= ntohl(x
->vnode
.hi
);
34 fid
->unique
= ntohl(x
->vnode
.unique
);
38 static __be32
*xdr_encode_u32(__be32
*bp
, u32 n
)
44 static __be32
*xdr_encode_u64(__be32
*bp
, u64 n
)
46 struct yfs_xdr_u64
*x
= (void *)bp
;
49 return bp
+ xdr_size(x
);
52 static __be32
*xdr_encode_YFSFid(__be32
*bp
, struct afs_fid
*fid
)
54 struct yfs_xdr_YFSFid
*x
= (void *)bp
;
56 x
->volume
= u64_to_xdr(fid
->vid
);
57 x
->vnode
.lo
= u64_to_xdr(fid
->vnode
);
58 x
->vnode
.hi
= htonl(fid
->vnode_hi
);
59 x
->vnode
.unique
= htonl(fid
->unique
);
60 return bp
+ xdr_size(x
);
63 static size_t xdr_strlen(unsigned int len
)
65 return sizeof(__be32
) + round_up(len
, sizeof(__be32
));
68 static __be32
*xdr_encode_string(__be32
*bp
, const char *p
, unsigned int len
)
70 bp
= xdr_encode_u32(bp
, len
);
71 bp
= memcpy(bp
, p
, len
);
73 unsigned int pad
= 4 - (len
& 3);
75 memset((u8
*)bp
+ len
, 0, pad
);
79 return bp
+ len
/ sizeof(__be32
);
82 static s64
linux_to_yfs_time(const struct timespec64
*t
)
84 /* Convert to 100ns intervals. */
85 return (u64
)t
->tv_sec
* 10000000 + t
->tv_nsec
/100;
88 static __be32
*xdr_encode_YFSStoreStatus_mode(__be32
*bp
, mode_t mode
)
90 struct yfs_xdr_YFSStoreStatus
*x
= (void *)bp
;
92 x
->mask
= htonl(AFS_SET_MODE
);
93 x
->mode
= htonl(mode
& S_IALLUGO
);
94 x
->mtime_client
= u64_to_xdr(0);
95 x
->owner
= u64_to_xdr(0);
96 x
->group
= u64_to_xdr(0);
97 return bp
+ xdr_size(x
);
100 static __be32
*xdr_encode_YFSStoreStatus_mtime(__be32
*bp
, const struct timespec64
*t
)
102 struct yfs_xdr_YFSStoreStatus
*x
= (void *)bp
;
103 s64 mtime
= linux_to_yfs_time(t
);
105 x
->mask
= htonl(AFS_SET_MTIME
);
107 x
->mtime_client
= u64_to_xdr(mtime
);
108 x
->owner
= u64_to_xdr(0);
109 x
->group
= u64_to_xdr(0);
110 return bp
+ xdr_size(x
);
114 * Convert a signed 100ns-resolution 64-bit time into a timespec.
116 static struct timespec64
yfs_time_to_linux(s64 t
)
118 struct timespec64 ts
;
122 * Unfortunately can not use normal 64 bit division on 32 bit arch, but
123 * the alternative, do_div, does not work with negative numbers so have
124 * to special case them
128 ts
.tv_nsec
= (time64_t
)(do_div(abs_t
, 10000000) * 100);
129 ts
.tv_nsec
= -ts
.tv_nsec
;
133 ts
.tv_nsec
= (time64_t
)do_div(abs_t
, 10000000) * 100;
140 static struct timespec64
xdr_to_time(const struct yfs_xdr_u64 xdr
)
142 s64 t
= xdr_to_u64(xdr
);
144 return yfs_time_to_linux(t
);
147 static void yfs_check_req(struct afs_call
*call
, __be32
*bp
)
149 size_t len
= (void *)bp
- call
->request
;
151 if (len
> call
->request_size
)
152 pr_err("kAFS: %s: Request buffer overflow (%zu>%u)\n",
153 call
->type
->name
, len
, call
->request_size
);
154 else if (len
< call
->request_size
)
155 pr_warning("kAFS: %s: Request buffer underflow (%zu<%u)\n",
156 call
->type
->name
, len
, call
->request_size
);
160 * Dump a bad file status record.
162 static void xdr_dump_bad(const __be32
*bp
)
167 pr_notice("YFS XDR: Bad status record\n");
168 for (i
= 0; i
< 5 * 4 * 4; i
+= 16) {
171 pr_notice("%03x: %08x %08x %08x %08x\n",
172 i
, ntohl(x
[0]), ntohl(x
[1]), ntohl(x
[2]), ntohl(x
[3]));
176 pr_notice("0x50: %08x\n", ntohl(x
[0]));
180 * Decode a YFSFetchStatus block
182 static int xdr_decode_YFSFetchStatus(const __be32
**_bp
,
183 struct afs_call
*call
,
184 struct afs_status_cb
*scb
)
186 const struct yfs_xdr_YFSFetchStatus
*xdr
= (const void *)*_bp
;
187 struct afs_file_status
*status
= &scb
->status
;
190 status
->abort_code
= ntohl(xdr
->abort_code
);
191 if (status
->abort_code
!= 0) {
192 if (status
->abort_code
== VNOVNODE
)
194 scb
->have_error
= true;
198 type
= ntohl(xdr
->type
);
202 case AFS_FTYPE_SYMLINK
:
209 status
->nlink
= ntohl(xdr
->nlink
);
210 status
->author
= xdr_to_u64(xdr
->author
);
211 status
->owner
= xdr_to_u64(xdr
->owner
);
212 status
->caller_access
= ntohl(xdr
->caller_access
); /* Ticket dependent */
213 status
->anon_access
= ntohl(xdr
->anon_access
);
214 status
->mode
= ntohl(xdr
->mode
) & S_IALLUGO
;
215 status
->group
= xdr_to_u64(xdr
->group
);
216 status
->lock_count
= ntohl(xdr
->lock_count
);
218 status
->mtime_client
= xdr_to_time(xdr
->mtime_client
);
219 status
->mtime_server
= xdr_to_time(xdr
->mtime_server
);
220 status
->size
= xdr_to_u64(xdr
->size
);
221 status
->data_version
= xdr_to_u64(xdr
->data_version
);
222 scb
->have_status
= true;
224 *_bp
+= xdr_size(xdr
);
229 return afs_protocol_error(call
, -EBADMSG
, afs_eproto_bad_status
);
233 * Decode a YFSCallBack block
235 static void xdr_decode_YFSCallBack(const __be32
**_bp
,
236 struct afs_call
*call
,
237 struct afs_status_cb
*scb
)
239 struct yfs_xdr_YFSCallBack
*x
= (void *)*_bp
;
240 struct afs_callback
*cb
= &scb
->callback
;
243 cb_expiry
= call
->reply_time
;
244 cb_expiry
= ktime_add(cb_expiry
, xdr_to_u64(x
->expiration_time
) * 100);
245 cb
->expires_at
= ktime_divns(cb_expiry
, NSEC_PER_SEC
);
251 * Decode a YFSVolSync block
253 static void xdr_decode_YFSVolSync(const __be32
**_bp
,
254 struct afs_volsync
*volsync
)
256 struct yfs_xdr_YFSVolSync
*x
= (void *)*_bp
;
260 creation
= xdr_to_u64(x
->vol_creation_date
);
261 do_div(creation
, 10 * 1000 * 1000);
262 volsync
->creation
= creation
;
269 * Encode the requested attributes into a YFSStoreStatus block
271 static __be32
*xdr_encode_YFS_StoreStatus(__be32
*bp
, struct iattr
*attr
)
273 struct yfs_xdr_YFSStoreStatus
*x
= (void *)bp
;
274 s64 mtime
= 0, owner
= 0, group
= 0;
275 u32 mask
= 0, mode
= 0;
278 if (attr
->ia_valid
& ATTR_MTIME
) {
279 mask
|= AFS_SET_MTIME
;
280 mtime
= linux_to_yfs_time(&attr
->ia_mtime
);
283 if (attr
->ia_valid
& ATTR_UID
) {
284 mask
|= AFS_SET_OWNER
;
285 owner
= from_kuid(&init_user_ns
, attr
->ia_uid
);
288 if (attr
->ia_valid
& ATTR_GID
) {
289 mask
|= AFS_SET_GROUP
;
290 group
= from_kgid(&init_user_ns
, attr
->ia_gid
);
293 if (attr
->ia_valid
& ATTR_MODE
) {
294 mask
|= AFS_SET_MODE
;
295 mode
= attr
->ia_mode
& S_IALLUGO
;
298 x
->mask
= htonl(mask
);
299 x
->mode
= htonl(mode
);
300 x
->mtime_client
= u64_to_xdr(mtime
);
301 x
->owner
= u64_to_xdr(owner
);
302 x
->group
= u64_to_xdr(group
);
303 return bp
+ xdr_size(x
);
307 * Decode a YFSFetchVolumeStatus block.
309 static void xdr_decode_YFSFetchVolumeStatus(const __be32
**_bp
,
310 struct afs_volume_status
*vs
)
312 const struct yfs_xdr_YFSFetchVolumeStatus
*x
= (const void *)*_bp
;
315 vs
->vid
= xdr_to_u64(x
->vid
);
316 vs
->parent_id
= xdr_to_u64(x
->parent_id
);
317 flags
= ntohl(x
->flags
);
318 vs
->online
= flags
& yfs_FVSOnline
;
319 vs
->in_service
= flags
& yfs_FVSInservice
;
320 vs
->blessed
= flags
& yfs_FVSBlessed
;
321 vs
->needs_salvage
= flags
& yfs_FVSNeedsSalvage
;
322 vs
->type
= ntohl(x
->type
);
324 vs
->max_quota
= xdr_to_u64(x
->max_quota
);
325 vs
->blocks_in_use
= xdr_to_u64(x
->blocks_in_use
);
326 vs
->part_blocks_avail
= xdr_to_u64(x
->part_blocks_avail
);
327 vs
->part_max_blocks
= xdr_to_u64(x
->part_max_blocks
);
328 vs
->vol_copy_date
= xdr_to_u64(x
->vol_copy_date
);
329 vs
->vol_backup_date
= xdr_to_u64(x
->vol_backup_date
);
330 *_bp
+= sizeof(*x
) / sizeof(__be32
);
334 * Deliver a reply that's a status, callback and volsync.
336 static int yfs_deliver_fs_status_cb_and_volsync(struct afs_call
*call
)
341 ret
= afs_transfer_reply(call
);
345 /* unmarshall the reply once we've received all of it */
347 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
350 xdr_decode_YFSCallBack(&bp
, call
, call
->out_scb
);
351 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
353 _leave(" = 0 [done]");
358 * Deliver reply data to operations that just return a file status and a volume
361 static int yfs_deliver_status_and_volsync(struct afs_call
*call
)
366 ret
= afs_transfer_reply(call
);
371 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
374 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
376 _leave(" = 0 [done]");
381 * YFS.FetchStatus operation type
383 static const struct afs_call_type yfs_RXYFSFetchStatus_vnode
= {
384 .name
= "YFS.FetchStatus(vnode)",
385 .op
= yfs_FS_FetchStatus
,
386 .deliver
= yfs_deliver_fs_status_cb_and_volsync
,
387 .destructor
= afs_flat_call_destructor
,
391 * Fetch the status information for a file.
393 int yfs_fs_fetch_file_status(struct afs_fs_cursor
*fc
, struct afs_status_cb
*scb
,
394 struct afs_volsync
*volsync
)
396 struct afs_vnode
*vnode
= fc
->vnode
;
397 struct afs_call
*call
;
398 struct afs_net
*net
= afs_v2net(vnode
);
401 _enter(",%x,{%llx:%llu},,",
402 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
);
404 call
= afs_alloc_flat_call(net
, &yfs_RXYFSFetchStatus_vnode
,
406 sizeof(struct yfs_xdr_YFSFid
),
407 sizeof(struct yfs_xdr_YFSFetchStatus
) +
408 sizeof(struct yfs_xdr_YFSCallBack
) +
409 sizeof(struct yfs_xdr_YFSVolSync
));
411 fc
->ac
.error
= -ENOMEM
;
417 call
->out_volsync
= volsync
;
419 /* marshall the parameters */
421 bp
= xdr_encode_u32(bp
, YFSFETCHSTATUS
);
422 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
423 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
424 yfs_check_req(call
, bp
);
426 afs_use_fs_server(call
, fc
->cbi
);
427 trace_afs_make_fs_call(call
, &vnode
->fid
);
428 afs_set_fc_call(call
, fc
);
429 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
430 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
434 * Deliver reply data to an YFS.FetchData64.
436 static int yfs_deliver_fs_fetch_data64(struct afs_call
*call
)
438 struct afs_read
*req
= call
->read_request
;
443 _enter("{%u,%zu/%llu}",
444 call
->unmarshall
, iov_iter_count(&call
->iter
), req
->actual_len
);
446 switch (call
->unmarshall
) {
450 req
->offset
= req
->pos
& (PAGE_SIZE
- 1);
451 afs_extract_to_tmp64(call
);
455 /* extract the returned data length */
457 _debug("extract data length");
458 ret
= afs_extract_data(call
, true);
462 req
->actual_len
= be64_to_cpu(call
->tmp64
);
463 _debug("DATA length: %llu", req
->actual_len
);
464 req
->remain
= min(req
->len
, req
->actual_len
);
465 if (req
->remain
== 0)
471 ASSERTCMP(req
->index
, <, req
->nr_pages
);
472 if (req
->remain
> PAGE_SIZE
- req
->offset
)
473 size
= PAGE_SIZE
- req
->offset
;
476 call
->bvec
[0].bv_len
= size
;
477 call
->bvec
[0].bv_offset
= req
->offset
;
478 call
->bvec
[0].bv_page
= req
->pages
[req
->index
];
479 iov_iter_bvec(&call
->iter
, READ
, call
->bvec
, 1, size
);
480 ASSERTCMP(size
, <=, PAGE_SIZE
);
483 /* extract the returned data */
485 _debug("extract data %zu/%llu",
486 iov_iter_count(&call
->iter
), req
->remain
);
488 ret
= afs_extract_data(call
, true);
491 req
->remain
-= call
->bvec
[0].bv_len
;
492 req
->offset
+= call
->bvec
[0].bv_len
;
493 ASSERTCMP(req
->offset
, <=, PAGE_SIZE
);
494 if (req
->offset
== PAGE_SIZE
) {
503 ASSERTCMP(req
->remain
, ==, 0);
504 if (req
->actual_len
<= req
->len
)
507 /* Discard any excess data the server gave us */
508 iov_iter_discard(&call
->iter
, READ
, req
->actual_len
- req
->len
);
509 call
->unmarshall
= 3;
513 _debug("extract discard %zu/%llu",
514 iov_iter_count(&call
->iter
), req
->actual_len
- req
->len
);
516 ret
= afs_extract_data(call
, true);
521 call
->unmarshall
= 4;
522 afs_extract_to_buf(call
,
523 sizeof(struct yfs_xdr_YFSFetchStatus
) +
524 sizeof(struct yfs_xdr_YFSCallBack
) +
525 sizeof(struct yfs_xdr_YFSVolSync
));
528 /* extract the metadata */
530 ret
= afs_extract_data(call
, false);
535 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
538 xdr_decode_YFSCallBack(&bp
, call
, call
->out_scb
);
539 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
541 req
->data_version
= call
->out_scb
->status
.data_version
;
542 req
->file_size
= call
->out_scb
->status
.size
;
551 for (; req
->index
< req
->nr_pages
; req
->index
++) {
552 if (req
->offset
< PAGE_SIZE
)
553 zero_user_segment(req
->pages
[req
->index
],
554 req
->offset
, PAGE_SIZE
);
560 _leave(" = 0 [done]");
564 static void yfs_fetch_data_destructor(struct afs_call
*call
)
566 afs_put_read(call
->read_request
);
567 afs_flat_call_destructor(call
);
571 * YFS.FetchData64 operation type
573 static const struct afs_call_type yfs_RXYFSFetchData64
= {
574 .name
= "YFS.FetchData64",
575 .op
= yfs_FS_FetchData64
,
576 .deliver
= yfs_deliver_fs_fetch_data64
,
577 .destructor
= yfs_fetch_data_destructor
,
581 * Fetch data from a file.
583 int yfs_fs_fetch_data(struct afs_fs_cursor
*fc
, struct afs_status_cb
*scb
,
584 struct afs_read
*req
)
586 struct afs_vnode
*vnode
= fc
->vnode
;
587 struct afs_call
*call
;
588 struct afs_net
*net
= afs_v2net(vnode
);
591 _enter(",%x,{%llx:%llu},%llx,%llx",
592 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
,
595 call
= afs_alloc_flat_call(net
, &yfs_RXYFSFetchData64
,
597 sizeof(struct yfs_xdr_YFSFid
) +
598 sizeof(struct yfs_xdr_u64
) * 2,
599 sizeof(struct yfs_xdr_YFSFetchStatus
) +
600 sizeof(struct yfs_xdr_YFSCallBack
) +
601 sizeof(struct yfs_xdr_YFSVolSync
));
607 call
->out_volsync
= NULL
;
608 call
->read_request
= req
;
610 /* marshall the parameters */
612 bp
= xdr_encode_u32(bp
, YFSFETCHDATA64
);
613 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
614 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
615 bp
= xdr_encode_u64(bp
, req
->pos
);
616 bp
= xdr_encode_u64(bp
, req
->len
);
617 yfs_check_req(call
, bp
);
619 refcount_inc(&req
->usage
);
620 afs_use_fs_server(call
, fc
->cbi
);
621 trace_afs_make_fs_call(call
, &vnode
->fid
);
622 afs_set_fc_call(call
, fc
);
623 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
624 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
628 * Deliver reply data for YFS.CreateFile or YFS.MakeDir.
630 static int yfs_deliver_fs_create_vnode(struct afs_call
*call
)
635 _enter("{%u}", call
->unmarshall
);
637 ret
= afs_transfer_reply(call
);
641 /* unmarshall the reply once we've received all of it */
643 xdr_decode_YFSFid(&bp
, call
->out_fid
);
644 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
647 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
650 xdr_decode_YFSCallBack(&bp
, call
, call
->out_scb
);
651 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
653 _leave(" = 0 [done]");
658 * FS.CreateFile and FS.MakeDir operation type
660 static const struct afs_call_type afs_RXFSCreateFile
= {
661 .name
= "YFS.CreateFile",
662 .op
= yfs_FS_CreateFile
,
663 .deliver
= yfs_deliver_fs_create_vnode
,
664 .destructor
= afs_flat_call_destructor
,
670 int yfs_fs_create_file(struct afs_fs_cursor
*fc
,
673 struct afs_status_cb
*dvnode_scb
,
674 struct afs_fid
*newfid
,
675 struct afs_status_cb
*new_scb
)
677 struct afs_vnode
*dvnode
= fc
->vnode
;
678 struct afs_call
*call
;
679 struct afs_net
*net
= afs_v2net(dvnode
);
680 size_t namesz
, reqsz
, rplsz
;
685 namesz
= strlen(name
);
686 reqsz
= (sizeof(__be32
) +
688 sizeof(struct yfs_xdr_YFSFid
) +
690 sizeof(struct yfs_xdr_YFSStoreStatus
) +
692 rplsz
= (sizeof(struct yfs_xdr_YFSFid
) +
693 sizeof(struct yfs_xdr_YFSFetchStatus
) +
694 sizeof(struct yfs_xdr_YFSFetchStatus
) +
695 sizeof(struct yfs_xdr_YFSCallBack
) +
696 sizeof(struct yfs_xdr_YFSVolSync
));
698 call
= afs_alloc_flat_call(net
, &afs_RXFSCreateFile
, reqsz
, rplsz
);
703 call
->out_dir_scb
= dvnode_scb
;
704 call
->out_fid
= newfid
;
705 call
->out_scb
= new_scb
;
707 /* marshall the parameters */
709 bp
= xdr_encode_u32(bp
, YFSCREATEFILE
);
710 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
711 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
712 bp
= xdr_encode_string(bp
, name
, namesz
);
713 bp
= xdr_encode_YFSStoreStatus_mode(bp
, mode
);
714 bp
= xdr_encode_u32(bp
, yfs_LockNone
); /* ViceLockType */
715 yfs_check_req(call
, bp
);
717 afs_use_fs_server(call
, fc
->cbi
);
718 trace_afs_make_fs_call1(call
, &dvnode
->fid
, name
);
719 afs_set_fc_call(call
, fc
);
720 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
721 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
724 static const struct afs_call_type yfs_RXFSMakeDir
= {
725 .name
= "YFS.MakeDir",
726 .op
= yfs_FS_MakeDir
,
727 .deliver
= yfs_deliver_fs_create_vnode
,
728 .destructor
= afs_flat_call_destructor
,
734 int yfs_fs_make_dir(struct afs_fs_cursor
*fc
,
737 struct afs_status_cb
*dvnode_scb
,
738 struct afs_fid
*newfid
,
739 struct afs_status_cb
*new_scb
)
741 struct afs_vnode
*dvnode
= fc
->vnode
;
742 struct afs_call
*call
;
743 struct afs_net
*net
= afs_v2net(dvnode
);
744 size_t namesz
, reqsz
, rplsz
;
749 namesz
= strlen(name
);
750 reqsz
= (sizeof(__be32
) +
751 sizeof(struct yfs_xdr_RPCFlags
) +
752 sizeof(struct yfs_xdr_YFSFid
) +
754 sizeof(struct yfs_xdr_YFSStoreStatus
));
755 rplsz
= (sizeof(struct yfs_xdr_YFSFid
) +
756 sizeof(struct yfs_xdr_YFSFetchStatus
) +
757 sizeof(struct yfs_xdr_YFSFetchStatus
) +
758 sizeof(struct yfs_xdr_YFSCallBack
) +
759 sizeof(struct yfs_xdr_YFSVolSync
));
761 call
= afs_alloc_flat_call(net
, &yfs_RXFSMakeDir
, reqsz
, rplsz
);
766 call
->out_dir_scb
= dvnode_scb
;
767 call
->out_fid
= newfid
;
768 call
->out_scb
= new_scb
;
770 /* marshall the parameters */
772 bp
= xdr_encode_u32(bp
, YFSMAKEDIR
);
773 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
774 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
775 bp
= xdr_encode_string(bp
, name
, namesz
);
776 bp
= xdr_encode_YFSStoreStatus_mode(bp
, mode
);
777 yfs_check_req(call
, bp
);
779 afs_use_fs_server(call
, fc
->cbi
);
780 trace_afs_make_fs_call1(call
, &dvnode
->fid
, name
);
781 afs_set_fc_call(call
, fc
);
782 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
783 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
787 * Deliver reply data to a YFS.RemoveFile2 operation.
789 static int yfs_deliver_fs_remove_file2(struct afs_call
*call
)
795 _enter("{%u}", call
->unmarshall
);
797 ret
= afs_transfer_reply(call
);
802 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
806 xdr_decode_YFSFid(&bp
, &fid
);
807 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
810 /* Was deleted if vnode->status.abort_code == VNOVNODE. */
812 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
817 * YFS.RemoveFile2 operation type.
819 static const struct afs_call_type yfs_RXYFSRemoveFile2
= {
820 .name
= "YFS.RemoveFile2",
821 .op
= yfs_FS_RemoveFile2
,
822 .deliver
= yfs_deliver_fs_remove_file2
,
823 .destructor
= afs_flat_call_destructor
,
827 * Remove a file and retrieve new file status.
829 int yfs_fs_remove_file2(struct afs_fs_cursor
*fc
, struct afs_vnode
*vnode
,
830 const char *name
, struct afs_status_cb
*dvnode_scb
,
831 struct afs_status_cb
*vnode_scb
)
833 struct afs_vnode
*dvnode
= fc
->vnode
;
834 struct afs_call
*call
;
835 struct afs_net
*net
= afs_v2net(dvnode
);
841 namesz
= strlen(name
);
843 call
= afs_alloc_flat_call(net
, &yfs_RXYFSRemoveFile2
,
845 sizeof(struct yfs_xdr_RPCFlags
) +
846 sizeof(struct yfs_xdr_YFSFid
) +
848 sizeof(struct yfs_xdr_YFSFetchStatus
) +
849 sizeof(struct yfs_xdr_YFSFid
) +
850 sizeof(struct yfs_xdr_YFSFetchStatus
) +
851 sizeof(struct yfs_xdr_YFSVolSync
));
856 call
->out_dir_scb
= dvnode_scb
;
857 call
->out_scb
= vnode_scb
;
859 /* marshall the parameters */
861 bp
= xdr_encode_u32(bp
, YFSREMOVEFILE2
);
862 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
863 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
864 bp
= xdr_encode_string(bp
, name
, namesz
);
865 yfs_check_req(call
, bp
);
867 afs_use_fs_server(call
, fc
->cbi
);
868 trace_afs_make_fs_call1(call
, &dvnode
->fid
, name
);
869 afs_set_fc_call(call
, fc
);
870 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
871 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
875 * Deliver reply data to a YFS.RemoveFile or YFS.RemoveDir operation.
877 static int yfs_deliver_fs_remove(struct afs_call
*call
)
882 _enter("{%u}", call
->unmarshall
);
884 ret
= afs_transfer_reply(call
);
889 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
893 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
898 * FS.RemoveDir and FS.RemoveFile operation types.
900 static const struct afs_call_type yfs_RXYFSRemoveFile
= {
901 .name
= "YFS.RemoveFile",
902 .op
= yfs_FS_RemoveFile
,
903 .deliver
= yfs_deliver_fs_remove
,
904 .destructor
= afs_flat_call_destructor
,
907 static const struct afs_call_type yfs_RXYFSRemoveDir
= {
908 .name
= "YFS.RemoveDir",
909 .op
= yfs_FS_RemoveDir
,
910 .deliver
= yfs_deliver_fs_remove
,
911 .destructor
= afs_flat_call_destructor
,
915 * remove a file or directory
917 int yfs_fs_remove(struct afs_fs_cursor
*fc
, struct afs_vnode
*vnode
,
918 const char *name
, bool isdir
,
919 struct afs_status_cb
*dvnode_scb
)
921 struct afs_vnode
*dvnode
= fc
->vnode
;
922 struct afs_call
*call
;
923 struct afs_net
*net
= afs_v2net(dvnode
);
929 namesz
= strlen(name
);
930 call
= afs_alloc_flat_call(
931 net
, isdir
? &yfs_RXYFSRemoveDir
: &yfs_RXYFSRemoveFile
,
933 sizeof(struct yfs_xdr_RPCFlags
) +
934 sizeof(struct yfs_xdr_YFSFid
) +
936 sizeof(struct yfs_xdr_YFSFetchStatus
) +
937 sizeof(struct yfs_xdr_YFSVolSync
));
942 call
->out_dir_scb
= dvnode_scb
;
944 /* marshall the parameters */
946 bp
= xdr_encode_u32(bp
, isdir
? YFSREMOVEDIR
: YFSREMOVEFILE
);
947 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
948 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
949 bp
= xdr_encode_string(bp
, name
, namesz
);
950 yfs_check_req(call
, bp
);
952 afs_use_fs_server(call
, fc
->cbi
);
953 trace_afs_make_fs_call1(call
, &dvnode
->fid
, name
);
954 afs_set_fc_call(call
, fc
);
955 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
956 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
960 * Deliver reply data to a YFS.Link operation.
962 static int yfs_deliver_fs_link(struct afs_call
*call
)
967 _enter("{%u}", call
->unmarshall
);
969 ret
= afs_transfer_reply(call
);
974 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
977 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
980 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
981 _leave(" = 0 [done]");
986 * YFS.Link operation type.
988 static const struct afs_call_type yfs_RXYFSLink
= {
991 .deliver
= yfs_deliver_fs_link
,
992 .destructor
= afs_flat_call_destructor
,
998 int yfs_fs_link(struct afs_fs_cursor
*fc
, struct afs_vnode
*vnode
,
1000 struct afs_status_cb
*dvnode_scb
,
1001 struct afs_status_cb
*vnode_scb
)
1003 struct afs_vnode
*dvnode
= fc
->vnode
;
1004 struct afs_call
*call
;
1005 struct afs_net
*net
= afs_v2net(vnode
);
1011 namesz
= strlen(name
);
1012 call
= afs_alloc_flat_call(net
, &yfs_RXYFSLink
,
1014 sizeof(struct yfs_xdr_RPCFlags
) +
1015 sizeof(struct yfs_xdr_YFSFid
) +
1016 xdr_strlen(namesz
) +
1017 sizeof(struct yfs_xdr_YFSFid
),
1018 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1019 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1020 sizeof(struct yfs_xdr_YFSVolSync
));
1024 call
->key
= fc
->key
;
1025 call
->out_dir_scb
= dvnode_scb
;
1026 call
->out_scb
= vnode_scb
;
1028 /* marshall the parameters */
1030 bp
= xdr_encode_u32(bp
, YFSLINK
);
1031 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1032 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
1033 bp
= xdr_encode_string(bp
, name
, namesz
);
1034 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1035 yfs_check_req(call
, bp
);
1037 afs_use_fs_server(call
, fc
->cbi
);
1038 trace_afs_make_fs_call1(call
, &vnode
->fid
, name
);
1039 afs_set_fc_call(call
, fc
);
1040 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1041 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1045 * Deliver reply data to a YFS.Symlink operation.
1047 static int yfs_deliver_fs_symlink(struct afs_call
*call
)
1052 _enter("{%u}", call
->unmarshall
);
1054 ret
= afs_transfer_reply(call
);
1058 /* unmarshall the reply once we've received all of it */
1060 xdr_decode_YFSFid(&bp
, call
->out_fid
);
1061 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
1064 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
1067 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
1069 _leave(" = 0 [done]");
1074 * YFS.Symlink operation type
1076 static const struct afs_call_type yfs_RXYFSSymlink
= {
1077 .name
= "YFS.Symlink",
1078 .op
= yfs_FS_Symlink
,
1079 .deliver
= yfs_deliver_fs_symlink
,
1080 .destructor
= afs_flat_call_destructor
,
1084 * Create a symbolic link.
1086 int yfs_fs_symlink(struct afs_fs_cursor
*fc
,
1088 const char *contents
,
1089 struct afs_status_cb
*dvnode_scb
,
1090 struct afs_fid
*newfid
,
1091 struct afs_status_cb
*vnode_scb
)
1093 struct afs_vnode
*dvnode
= fc
->vnode
;
1094 struct afs_call
*call
;
1095 struct afs_net
*net
= afs_v2net(dvnode
);
1096 size_t namesz
, contents_sz
;
1101 namesz
= strlen(name
);
1102 contents_sz
= strlen(contents
);
1103 call
= afs_alloc_flat_call(net
, &yfs_RXYFSSymlink
,
1105 sizeof(struct yfs_xdr_RPCFlags
) +
1106 sizeof(struct yfs_xdr_YFSFid
) +
1107 xdr_strlen(namesz
) +
1108 xdr_strlen(contents_sz
) +
1109 sizeof(struct yfs_xdr_YFSStoreStatus
),
1110 sizeof(struct yfs_xdr_YFSFid
) +
1111 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1112 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1113 sizeof(struct yfs_xdr_YFSVolSync
));
1117 call
->key
= fc
->key
;
1118 call
->out_dir_scb
= dvnode_scb
;
1119 call
->out_fid
= newfid
;
1120 call
->out_scb
= vnode_scb
;
1122 /* marshall the parameters */
1124 bp
= xdr_encode_u32(bp
, YFSSYMLINK
);
1125 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1126 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
1127 bp
= xdr_encode_string(bp
, name
, namesz
);
1128 bp
= xdr_encode_string(bp
, contents
, contents_sz
);
1129 bp
= xdr_encode_YFSStoreStatus_mode(bp
, S_IRWXUGO
);
1130 yfs_check_req(call
, bp
);
1132 afs_use_fs_server(call
, fc
->cbi
);
1133 trace_afs_make_fs_call1(call
, &dvnode
->fid
, name
);
1134 afs_set_fc_call(call
, fc
);
1135 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1136 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1140 * Deliver reply data to a YFS.Rename operation.
1142 static int yfs_deliver_fs_rename(struct afs_call
*call
)
1147 _enter("{%u}", call
->unmarshall
);
1149 ret
= afs_transfer_reply(call
);
1154 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
1157 if (call
->out_dir_scb
!= call
->out_scb
) {
1158 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
1163 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
1164 _leave(" = 0 [done]");
1169 * YFS.Rename operation type
1171 static const struct afs_call_type yfs_RXYFSRename
= {
1172 .name
= "FS.Rename",
1173 .op
= yfs_FS_Rename
,
1174 .deliver
= yfs_deliver_fs_rename
,
1175 .destructor
= afs_flat_call_destructor
,
1179 * Rename a file or directory.
1181 int yfs_fs_rename(struct afs_fs_cursor
*fc
,
1182 const char *orig_name
,
1183 struct afs_vnode
*new_dvnode
,
1184 const char *new_name
,
1185 struct afs_status_cb
*orig_dvnode_scb
,
1186 struct afs_status_cb
*new_dvnode_scb
)
1188 struct afs_vnode
*orig_dvnode
= fc
->vnode
;
1189 struct afs_call
*call
;
1190 struct afs_net
*net
= afs_v2net(orig_dvnode
);
1191 size_t o_namesz
, n_namesz
;
1196 o_namesz
= strlen(orig_name
);
1197 n_namesz
= strlen(new_name
);
1198 call
= afs_alloc_flat_call(net
, &yfs_RXYFSRename
,
1200 sizeof(struct yfs_xdr_RPCFlags
) +
1201 sizeof(struct yfs_xdr_YFSFid
) +
1202 xdr_strlen(o_namesz
) +
1203 sizeof(struct yfs_xdr_YFSFid
) +
1204 xdr_strlen(n_namesz
),
1205 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1206 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1207 sizeof(struct yfs_xdr_YFSVolSync
));
1211 call
->key
= fc
->key
;
1212 call
->out_dir_scb
= orig_dvnode_scb
;
1213 call
->out_scb
= new_dvnode_scb
;
1215 /* marshall the parameters */
1217 bp
= xdr_encode_u32(bp
, YFSRENAME
);
1218 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1219 bp
= xdr_encode_YFSFid(bp
, &orig_dvnode
->fid
);
1220 bp
= xdr_encode_string(bp
, orig_name
, o_namesz
);
1221 bp
= xdr_encode_YFSFid(bp
, &new_dvnode
->fid
);
1222 bp
= xdr_encode_string(bp
, new_name
, n_namesz
);
1223 yfs_check_req(call
, bp
);
1225 afs_use_fs_server(call
, fc
->cbi
);
1226 trace_afs_make_fs_call2(call
, &orig_dvnode
->fid
, orig_name
, new_name
);
1227 afs_set_fc_call(call
, fc
);
1228 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1229 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1233 * YFS.StoreData64 operation type.
1235 static const struct afs_call_type yfs_RXYFSStoreData64
= {
1236 .name
= "YFS.StoreData64",
1237 .op
= yfs_FS_StoreData64
,
1238 .deliver
= yfs_deliver_status_and_volsync
,
1239 .destructor
= afs_flat_call_destructor
,
1243 * Store a set of pages to a large file.
1245 int yfs_fs_store_data(struct afs_fs_cursor
*fc
, struct address_space
*mapping
,
1246 pgoff_t first
, pgoff_t last
,
1247 unsigned offset
, unsigned to
,
1248 struct afs_status_cb
*scb
)
1250 struct afs_vnode
*vnode
= fc
->vnode
;
1251 struct afs_call
*call
;
1252 struct afs_net
*net
= afs_v2net(vnode
);
1253 loff_t size
, pos
, i_size
;
1256 _enter(",%x,{%llx:%llu},,",
1257 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
);
1259 size
= (loff_t
)to
- (loff_t
)offset
;
1261 size
+= (loff_t
)(last
- first
) << PAGE_SHIFT
;
1262 pos
= (loff_t
)first
<< PAGE_SHIFT
;
1265 i_size
= i_size_read(&vnode
->vfs_inode
);
1266 if (pos
+ size
> i_size
)
1267 i_size
= size
+ pos
;
1269 _debug("size %llx, at %llx, i_size %llx",
1270 (unsigned long long)size
, (unsigned long long)pos
,
1271 (unsigned long long)i_size
);
1273 call
= afs_alloc_flat_call(net
, &yfs_RXYFSStoreData64
,
1276 sizeof(struct yfs_xdr_YFSFid
) +
1277 sizeof(struct yfs_xdr_YFSStoreStatus
) +
1278 sizeof(struct yfs_xdr_u64
) * 3,
1279 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1280 sizeof(struct yfs_xdr_YFSVolSync
));
1284 call
->key
= fc
->key
;
1285 call
->mapping
= mapping
;
1286 call
->first
= first
;
1288 call
->first_offset
= offset
;
1290 call
->send_pages
= true;
1291 call
->out_scb
= scb
;
1293 /* marshall the parameters */
1295 bp
= xdr_encode_u32(bp
, YFSSTOREDATA64
);
1296 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1297 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1298 bp
= xdr_encode_YFSStoreStatus_mtime(bp
, &vnode
->vfs_inode
.i_mtime
);
1299 bp
= xdr_encode_u64(bp
, pos
);
1300 bp
= xdr_encode_u64(bp
, size
);
1301 bp
= xdr_encode_u64(bp
, i_size
);
1302 yfs_check_req(call
, bp
);
1304 afs_use_fs_server(call
, fc
->cbi
);
1305 trace_afs_make_fs_call(call
, &vnode
->fid
);
1306 afs_set_fc_call(call
, fc
);
1307 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1308 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1312 * YFS.StoreStatus operation type
1314 static const struct afs_call_type yfs_RXYFSStoreStatus
= {
1315 .name
= "YFS.StoreStatus",
1316 .op
= yfs_FS_StoreStatus
,
1317 .deliver
= yfs_deliver_status_and_volsync
,
1318 .destructor
= afs_flat_call_destructor
,
1321 static const struct afs_call_type yfs_RXYFSStoreData64_as_Status
= {
1322 .name
= "YFS.StoreData64",
1323 .op
= yfs_FS_StoreData64
,
1324 .deliver
= yfs_deliver_status_and_volsync
,
1325 .destructor
= afs_flat_call_destructor
,
1329 * Set the attributes on a file, using YFS.StoreData64 rather than
1330 * YFS.StoreStatus so as to alter the file size also.
1332 static int yfs_fs_setattr_size(struct afs_fs_cursor
*fc
, struct iattr
*attr
,
1333 struct afs_status_cb
*scb
)
1335 struct afs_vnode
*vnode
= fc
->vnode
;
1336 struct afs_call
*call
;
1337 struct afs_net
*net
= afs_v2net(vnode
);
1340 _enter(",%x,{%llx:%llu},,",
1341 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
);
1343 call
= afs_alloc_flat_call(net
, &yfs_RXYFSStoreData64_as_Status
,
1344 sizeof(__be32
) * 2 +
1345 sizeof(struct yfs_xdr_YFSFid
) +
1346 sizeof(struct yfs_xdr_YFSStoreStatus
) +
1347 sizeof(struct yfs_xdr_u64
) * 3,
1348 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1349 sizeof(struct yfs_xdr_YFSVolSync
));
1353 call
->key
= fc
->key
;
1354 call
->out_scb
= scb
;
1356 /* marshall the parameters */
1358 bp
= xdr_encode_u32(bp
, YFSSTOREDATA64
);
1359 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1360 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1361 bp
= xdr_encode_YFS_StoreStatus(bp
, attr
);
1362 bp
= xdr_encode_u64(bp
, attr
->ia_size
); /* position of start of write */
1363 bp
= xdr_encode_u64(bp
, 0); /* size of write */
1364 bp
= xdr_encode_u64(bp
, attr
->ia_size
); /* new file length */
1365 yfs_check_req(call
, bp
);
1367 afs_use_fs_server(call
, fc
->cbi
);
1368 trace_afs_make_fs_call(call
, &vnode
->fid
);
1369 afs_set_fc_call(call
, fc
);
1370 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1371 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1375 * Set the attributes on a file, using YFS.StoreData64 if there's a change in
1376 * file size, and YFS.StoreStatus otherwise.
1378 int yfs_fs_setattr(struct afs_fs_cursor
*fc
, struct iattr
*attr
,
1379 struct afs_status_cb
*scb
)
1381 struct afs_vnode
*vnode
= fc
->vnode
;
1382 struct afs_call
*call
;
1383 struct afs_net
*net
= afs_v2net(vnode
);
1386 if (attr
->ia_valid
& ATTR_SIZE
)
1387 return yfs_fs_setattr_size(fc
, attr
, scb
);
1389 _enter(",%x,{%llx:%llu},,",
1390 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
);
1392 call
= afs_alloc_flat_call(net
, &yfs_RXYFSStoreStatus
,
1393 sizeof(__be32
) * 2 +
1394 sizeof(struct yfs_xdr_YFSFid
) +
1395 sizeof(struct yfs_xdr_YFSStoreStatus
),
1396 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1397 sizeof(struct yfs_xdr_YFSVolSync
));
1401 call
->key
= fc
->key
;
1402 call
->out_scb
= scb
;
1404 /* marshall the parameters */
1406 bp
= xdr_encode_u32(bp
, YFSSTORESTATUS
);
1407 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1408 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1409 bp
= xdr_encode_YFS_StoreStatus(bp
, attr
);
1410 yfs_check_req(call
, bp
);
1412 afs_use_fs_server(call
, fc
->cbi
);
1413 trace_afs_make_fs_call(call
, &vnode
->fid
);
1414 afs_set_fc_call(call
, fc
);
1415 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1416 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1420 * Deliver reply data to a YFS.GetVolumeStatus operation.
1422 static int yfs_deliver_fs_get_volume_status(struct afs_call
*call
)
1429 _enter("{%u}", call
->unmarshall
);
1431 switch (call
->unmarshall
) {
1434 afs_extract_to_buf(call
, sizeof(struct yfs_xdr_YFSFetchVolumeStatus
));
1437 /* 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
);
1450 /* extract the volume name length */
1452 ret
= afs_extract_data(call
, true);
1456 call
->count
= ntohl(call
->tmp
);
1457 _debug("volname length: %u", call
->count
);
1458 if (call
->count
>= AFSNAMEMAX
)
1459 return afs_protocol_error(call
, -EBADMSG
,
1460 afs_eproto_volname_len
);
1461 size
= (call
->count
+ 3) & ~3; /* It's padded */
1462 afs_extract_to_buf(call
, size
);
1466 /* extract the volume name */
1468 _debug("extract volname");
1469 ret
= afs_extract_data(call
, true);
1475 _debug("volname '%s'", p
);
1476 afs_extract_to_tmp(call
);
1480 /* extract the offline message length */
1482 ret
= afs_extract_data(call
, true);
1486 call
->count
= ntohl(call
->tmp
);
1487 _debug("offline msg length: %u", call
->count
);
1488 if (call
->count
>= AFSNAMEMAX
)
1489 return afs_protocol_error(call
, -EBADMSG
,
1490 afs_eproto_offline_msg_len
);
1491 size
= (call
->count
+ 3) & ~3; /* It's padded */
1492 afs_extract_to_buf(call
, size
);
1496 /* extract the offline message */
1498 _debug("extract offline");
1499 ret
= afs_extract_data(call
, true);
1505 _debug("offline '%s'", p
);
1507 afs_extract_to_tmp(call
);
1511 /* extract the message of the day length */
1513 ret
= afs_extract_data(call
, true);
1517 call
->count
= ntohl(call
->tmp
);
1518 _debug("motd length: %u", call
->count
);
1519 if (call
->count
>= AFSNAMEMAX
)
1520 return afs_protocol_error(call
, -EBADMSG
,
1521 afs_eproto_motd_len
);
1522 size
= (call
->count
+ 3) & ~3; /* It's padded */
1523 afs_extract_to_buf(call
, size
);
1527 /* extract the message of the day */
1529 _debug("extract motd");
1530 ret
= afs_extract_data(call
, false);
1536 _debug("motd '%s'", p
);
1545 _leave(" = 0 [done]");
1550 * YFS.GetVolumeStatus operation type
1552 static const struct afs_call_type yfs_RXYFSGetVolumeStatus
= {
1553 .name
= "YFS.GetVolumeStatus",
1554 .op
= yfs_FS_GetVolumeStatus
,
1555 .deliver
= yfs_deliver_fs_get_volume_status
,
1556 .destructor
= afs_flat_call_destructor
,
1560 * fetch the status of a volume
1562 int yfs_fs_get_volume_status(struct afs_fs_cursor
*fc
,
1563 struct afs_volume_status
*vs
)
1565 struct afs_vnode
*vnode
= fc
->vnode
;
1566 struct afs_call
*call
;
1567 struct afs_net
*net
= afs_v2net(vnode
);
1572 call
= afs_alloc_flat_call(net
, &yfs_RXYFSGetVolumeStatus
,
1573 sizeof(__be32
) * 2 +
1574 sizeof(struct yfs_xdr_u64
),
1576 sizeof(struct yfs_xdr_YFSFetchVolumeStatus
) +
1582 call
->key
= fc
->key
;
1583 call
->out_volstatus
= vs
;
1585 /* marshall the parameters */
1587 bp
= xdr_encode_u32(bp
, YFSGETVOLUMESTATUS
);
1588 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1589 bp
= xdr_encode_u64(bp
, vnode
->fid
.vid
);
1590 yfs_check_req(call
, bp
);
1592 afs_use_fs_server(call
, fc
->cbi
);
1593 trace_afs_make_fs_call(call
, &vnode
->fid
);
1594 afs_set_fc_call(call
, fc
);
1595 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1596 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1600 * YFS.SetLock operation type
1602 static const struct afs_call_type yfs_RXYFSSetLock
= {
1603 .name
= "YFS.SetLock",
1604 .op
= yfs_FS_SetLock
,
1605 .deliver
= yfs_deliver_status_and_volsync
,
1606 .done
= afs_lock_op_done
,
1607 .destructor
= afs_flat_call_destructor
,
1611 * YFS.ExtendLock operation type
1613 static const struct afs_call_type yfs_RXYFSExtendLock
= {
1614 .name
= "YFS.ExtendLock",
1615 .op
= yfs_FS_ExtendLock
,
1616 .deliver
= yfs_deliver_status_and_volsync
,
1617 .done
= afs_lock_op_done
,
1618 .destructor
= afs_flat_call_destructor
,
1622 * YFS.ReleaseLock operation type
1624 static const struct afs_call_type yfs_RXYFSReleaseLock
= {
1625 .name
= "YFS.ReleaseLock",
1626 .op
= yfs_FS_ReleaseLock
,
1627 .deliver
= yfs_deliver_status_and_volsync
,
1628 .destructor
= afs_flat_call_destructor
,
1632 * Set a lock on a file
1634 int yfs_fs_set_lock(struct afs_fs_cursor
*fc
, afs_lock_type_t type
,
1635 struct afs_status_cb
*scb
)
1637 struct afs_vnode
*vnode
= fc
->vnode
;
1638 struct afs_call
*call
;
1639 struct afs_net
*net
= afs_v2net(vnode
);
1644 call
= afs_alloc_flat_call(net
, &yfs_RXYFSSetLock
,
1645 sizeof(__be32
) * 2 +
1646 sizeof(struct yfs_xdr_YFSFid
) +
1648 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1649 sizeof(struct yfs_xdr_YFSVolSync
));
1653 call
->key
= fc
->key
;
1654 call
->lvnode
= vnode
;
1655 call
->out_scb
= scb
;
1657 /* marshall the parameters */
1659 bp
= xdr_encode_u32(bp
, YFSSETLOCK
);
1660 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1661 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1662 bp
= xdr_encode_u32(bp
, type
);
1663 yfs_check_req(call
, bp
);
1665 afs_use_fs_server(call
, fc
->cbi
);
1666 trace_afs_make_fs_calli(call
, &vnode
->fid
, type
);
1667 afs_set_fc_call(call
, fc
);
1668 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1669 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1673 * extend a lock on a file
1675 int yfs_fs_extend_lock(struct afs_fs_cursor
*fc
, struct afs_status_cb
*scb
)
1677 struct afs_vnode
*vnode
= fc
->vnode
;
1678 struct afs_call
*call
;
1679 struct afs_net
*net
= afs_v2net(vnode
);
1684 call
= afs_alloc_flat_call(net
, &yfs_RXYFSExtendLock
,
1685 sizeof(__be32
) * 2 +
1686 sizeof(struct yfs_xdr_YFSFid
),
1687 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1688 sizeof(struct yfs_xdr_YFSVolSync
));
1692 call
->key
= fc
->key
;
1693 call
->lvnode
= vnode
;
1694 call
->out_scb
= scb
;
1696 /* marshall the parameters */
1698 bp
= xdr_encode_u32(bp
, YFSEXTENDLOCK
);
1699 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1700 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1701 yfs_check_req(call
, bp
);
1703 afs_use_fs_server(call
, fc
->cbi
);
1704 trace_afs_make_fs_call(call
, &vnode
->fid
);
1705 afs_set_fc_call(call
, fc
);
1706 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1707 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1711 * release a lock on a file
1713 int yfs_fs_release_lock(struct afs_fs_cursor
*fc
, struct afs_status_cb
*scb
)
1715 struct afs_vnode
*vnode
= fc
->vnode
;
1716 struct afs_call
*call
;
1717 struct afs_net
*net
= afs_v2net(vnode
);
1722 call
= afs_alloc_flat_call(net
, &yfs_RXYFSReleaseLock
,
1723 sizeof(__be32
) * 2 +
1724 sizeof(struct yfs_xdr_YFSFid
),
1725 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1726 sizeof(struct yfs_xdr_YFSVolSync
));
1730 call
->key
= fc
->key
;
1731 call
->lvnode
= vnode
;
1732 call
->out_scb
= scb
;
1734 /* marshall the parameters */
1736 bp
= xdr_encode_u32(bp
, YFSRELEASELOCK
);
1737 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1738 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1739 yfs_check_req(call
, bp
);
1741 afs_use_fs_server(call
, fc
->cbi
);
1742 trace_afs_make_fs_call(call
, &vnode
->fid
);
1743 afs_set_fc_call(call
, fc
);
1744 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1745 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1749 * YFS.FetchStatus operation type
1751 static const struct afs_call_type yfs_RXYFSFetchStatus
= {
1752 .name
= "YFS.FetchStatus",
1753 .op
= yfs_FS_FetchStatus
,
1754 .deliver
= yfs_deliver_fs_status_cb_and_volsync
,
1755 .destructor
= afs_flat_call_destructor
,
1759 * Fetch the status information for a fid without needing a vnode handle.
1761 int yfs_fs_fetch_status(struct afs_fs_cursor
*fc
,
1762 struct afs_net
*net
,
1763 struct afs_fid
*fid
,
1764 struct afs_status_cb
*scb
,
1765 struct afs_volsync
*volsync
)
1767 struct afs_call
*call
;
1770 _enter(",%x,{%llx:%llu},,",
1771 key_serial(fc
->key
), fid
->vid
, fid
->vnode
);
1773 call
= afs_alloc_flat_call(net
, &yfs_RXYFSFetchStatus
,
1774 sizeof(__be32
) * 2 +
1775 sizeof(struct yfs_xdr_YFSFid
),
1776 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1777 sizeof(struct yfs_xdr_YFSCallBack
) +
1778 sizeof(struct yfs_xdr_YFSVolSync
));
1780 fc
->ac
.error
= -ENOMEM
;
1784 call
->key
= fc
->key
;
1785 call
->out_scb
= scb
;
1786 call
->out_volsync
= volsync
;
1788 /* marshall the parameters */
1790 bp
= xdr_encode_u32(bp
, YFSFETCHSTATUS
);
1791 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1792 bp
= xdr_encode_YFSFid(bp
, fid
);
1793 yfs_check_req(call
, bp
);
1795 afs_use_fs_server(call
, fc
->cbi
);
1796 trace_afs_make_fs_call(call
, fid
);
1797 afs_set_fc_call(call
, fc
);
1798 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1799 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1803 * Deliver reply data to an YFS.InlineBulkStatus call
1805 static int yfs_deliver_fs_inline_bulk_status(struct afs_call
*call
)
1807 struct afs_status_cb
*scb
;
1812 _enter("{%u}", call
->unmarshall
);
1814 switch (call
->unmarshall
) {
1816 afs_extract_to_tmp(call
);
1820 /* Extract the file status count and array in two steps */
1822 _debug("extract status count");
1823 ret
= afs_extract_data(call
, true);
1827 tmp
= ntohl(call
->tmp
);
1828 _debug("status count: %u/%u", tmp
, call
->count2
);
1829 if (tmp
!= call
->count2
)
1830 return afs_protocol_error(call
, -EBADMSG
,
1831 afs_eproto_ibulkst_count
);
1836 afs_extract_to_buf(call
, sizeof(struct yfs_xdr_YFSFetchStatus
));
1840 _debug("extract status array %u", call
->count
);
1841 ret
= afs_extract_data(call
, true);
1846 scb
= &call
->out_scb
[call
->count
];
1847 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, scb
);
1852 if (call
->count
< call
->count2
)
1857 afs_extract_to_tmp(call
);
1860 /* Extract the callback count and array in two steps */
1862 _debug("extract CB count");
1863 ret
= afs_extract_data(call
, true);
1867 tmp
= ntohl(call
->tmp
);
1868 _debug("CB count: %u", tmp
);
1869 if (tmp
!= call
->count2
)
1870 return afs_protocol_error(call
, -EBADMSG
,
1871 afs_eproto_ibulkst_cb_count
);
1875 afs_extract_to_buf(call
, sizeof(struct yfs_xdr_YFSCallBack
));
1879 _debug("extract CB array");
1880 ret
= afs_extract_data(call
, true);
1884 _debug("unmarshall CB array");
1886 scb
= &call
->out_scb
[call
->count
];
1887 xdr_decode_YFSCallBack(&bp
, call
, scb
);
1889 if (call
->count
< call
->count2
)
1892 afs_extract_to_buf(call
, sizeof(struct yfs_xdr_YFSVolSync
));
1897 ret
= afs_extract_data(call
, false);
1902 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
1911 _leave(" = 0 [done]");
1916 * FS.InlineBulkStatus operation type
1918 static const struct afs_call_type yfs_RXYFSInlineBulkStatus
= {
1919 .name
= "YFS.InlineBulkStatus",
1920 .op
= yfs_FS_InlineBulkStatus
,
1921 .deliver
= yfs_deliver_fs_inline_bulk_status
,
1922 .destructor
= afs_flat_call_destructor
,
1926 * Fetch the status information for up to 1024 files
1928 int yfs_fs_inline_bulk_status(struct afs_fs_cursor
*fc
,
1929 struct afs_net
*net
,
1930 struct afs_fid
*fids
,
1931 struct afs_status_cb
*statuses
,
1932 unsigned int nr_fids
,
1933 struct afs_volsync
*volsync
)
1935 struct afs_call
*call
;
1939 _enter(",%x,{%llx:%llu},%u",
1940 key_serial(fc
->key
), fids
[0].vid
, fids
[1].vnode
, nr_fids
);
1942 call
= afs_alloc_flat_call(net
, &yfs_RXYFSInlineBulkStatus
,
1946 sizeof(struct yfs_xdr_YFSFid
) * nr_fids
,
1947 sizeof(struct yfs_xdr_YFSFetchStatus
));
1949 fc
->ac
.error
= -ENOMEM
;
1953 call
->key
= fc
->key
;
1954 call
->out_scb
= statuses
;
1955 call
->out_volsync
= volsync
;
1956 call
->count2
= nr_fids
;
1958 /* marshall the parameters */
1960 bp
= xdr_encode_u32(bp
, YFSINLINEBULKSTATUS
);
1961 bp
= xdr_encode_u32(bp
, 0); /* RPCFlags */
1962 bp
= xdr_encode_u32(bp
, nr_fids
);
1963 for (i
= 0; i
< nr_fids
; i
++)
1964 bp
= xdr_encode_YFSFid(bp
, &fids
[i
]);
1965 yfs_check_req(call
, bp
);
1967 afs_use_fs_server(call
, fc
->cbi
);
1968 trace_afs_make_fs_call(call
, &fids
[0]);
1969 afs_set_fc_call(call
, fc
);
1970 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1971 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1975 * Deliver reply data to an YFS.FetchOpaqueACL.
1977 static int yfs_deliver_fs_fetch_opaque_acl(struct afs_call
*call
)
1979 struct yfs_acl
*yacl
= call
->out_yacl
;
1980 struct afs_acl
*acl
;
1985 _enter("{%u}", call
->unmarshall
);
1987 switch (call
->unmarshall
) {
1989 afs_extract_to_tmp(call
);
1993 /* Extract the file ACL length */
1995 ret
= afs_extract_data(call
, true);
1999 size
= call
->count2
= ntohl(call
->tmp
);
2000 size
= round_up(size
, 4);
2002 if (yacl
->flags
& YFS_ACL_WANT_ACL
) {
2003 acl
= kmalloc(struct_size(acl
, data
, size
), GFP_KERNEL
);
2007 acl
->size
= call
->count2
;
2008 afs_extract_begin(call
, acl
->data
, size
);
2010 iov_iter_discard(&call
->iter
, READ
, size
);
2015 /* Extract the file ACL */
2017 ret
= afs_extract_data(call
, true);
2021 afs_extract_to_tmp(call
);
2025 /* Extract the volume ACL length */
2027 ret
= afs_extract_data(call
, true);
2031 size
= call
->count2
= ntohl(call
->tmp
);
2032 size
= round_up(size
, 4);
2034 if (yacl
->flags
& YFS_ACL_WANT_VOL_ACL
) {
2035 acl
= kmalloc(struct_size(acl
, data
, size
), GFP_KERNEL
);
2038 yacl
->vol_acl
= acl
;
2039 acl
->size
= call
->count2
;
2040 afs_extract_begin(call
, acl
->data
, size
);
2042 iov_iter_discard(&call
->iter
, READ
, size
);
2047 /* Extract the volume ACL */
2049 ret
= afs_extract_data(call
, true);
2053 afs_extract_to_buf(call
,
2054 sizeof(__be32
) * 2 +
2055 sizeof(struct yfs_xdr_YFSFetchStatus
) +
2056 sizeof(struct yfs_xdr_YFSVolSync
));
2060 /* extract the metadata */
2062 ret
= afs_extract_data(call
, false);
2067 yacl
->inherit_flag
= ntohl(*bp
++);
2068 yacl
->num_cleaned
= ntohl(*bp
++);
2069 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
2072 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
2081 _leave(" = 0 [done]");
2085 void yfs_free_opaque_acl(struct yfs_acl
*yacl
)
2089 kfree(yacl
->vol_acl
);
2095 * YFS.FetchOpaqueACL operation type
2097 static const struct afs_call_type yfs_RXYFSFetchOpaqueACL
= {
2098 .name
= "YFS.FetchOpaqueACL",
2099 .op
= yfs_FS_FetchOpaqueACL
,
2100 .deliver
= yfs_deliver_fs_fetch_opaque_acl
,
2101 .destructor
= afs_flat_call_destructor
,
2105 * Fetch the YFS advanced ACLs for a file.
2107 struct yfs_acl
*yfs_fs_fetch_opaque_acl(struct afs_fs_cursor
*fc
,
2108 struct yfs_acl
*yacl
,
2109 struct afs_status_cb
*scb
)
2111 struct afs_vnode
*vnode
= fc
->vnode
;
2112 struct afs_call
*call
;
2113 struct afs_net
*net
= afs_v2net(vnode
);
2116 _enter(",%x,{%llx:%llu},,",
2117 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
);
2119 call
= afs_alloc_flat_call(net
, &yfs_RXYFSFetchOpaqueACL
,
2120 sizeof(__be32
) * 2 +
2121 sizeof(struct yfs_xdr_YFSFid
),
2122 sizeof(__be32
) * 2 +
2123 sizeof(struct yfs_xdr_YFSFetchStatus
) +
2124 sizeof(struct yfs_xdr_YFSVolSync
));
2126 fc
->ac
.error
= -ENOMEM
;
2127 return ERR_PTR(-ENOMEM
);
2130 call
->key
= fc
->key
;
2131 call
->out_yacl
= yacl
;
2132 call
->out_scb
= scb
;
2133 call
->out_volsync
= NULL
;
2135 /* marshall the parameters */
2137 bp
= xdr_encode_u32(bp
, YFSFETCHOPAQUEACL
);
2138 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
2139 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
2140 yfs_check_req(call
, bp
);
2142 afs_use_fs_server(call
, fc
->cbi
);
2143 trace_afs_make_fs_call(call
, &vnode
->fid
);
2144 afs_make_call(&fc
->ac
, call
, GFP_KERNEL
);
2145 return (struct yfs_acl
*)afs_wait_for_call_to_complete(call
, &fc
->ac
);
2149 * YFS.StoreOpaqueACL2 operation type
2151 static const struct afs_call_type yfs_RXYFSStoreOpaqueACL2
= {
2152 .name
= "YFS.StoreOpaqueACL2",
2153 .op
= yfs_FS_StoreOpaqueACL2
,
2154 .deliver
= yfs_deliver_status_and_volsync
,
2155 .destructor
= afs_flat_call_destructor
,
2159 * Fetch the YFS ACL for a file.
2161 int yfs_fs_store_opaque_acl2(struct afs_fs_cursor
*fc
, const struct afs_acl
*acl
,
2162 struct afs_status_cb
*scb
)
2164 struct afs_vnode
*vnode
= fc
->vnode
;
2165 struct afs_call
*call
;
2166 struct afs_net
*net
= afs_v2net(vnode
);
2170 _enter(",%x,{%llx:%llu},,",
2171 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
);
2173 size
= round_up(acl
->size
, 4);
2174 call
= afs_alloc_flat_call(net
, &yfs_RXYFSStoreStatus
,
2175 sizeof(__be32
) * 2 +
2176 sizeof(struct yfs_xdr_YFSFid
) +
2177 sizeof(__be32
) + size
,
2178 sizeof(struct yfs_xdr_YFSFetchStatus
) +
2179 sizeof(struct yfs_xdr_YFSVolSync
));
2181 fc
->ac
.error
= -ENOMEM
;
2185 call
->key
= fc
->key
;
2186 call
->out_scb
= scb
;
2187 call
->out_volsync
= NULL
;
2189 /* marshall the parameters */
2191 bp
= xdr_encode_u32(bp
, YFSSTOREOPAQUEACL2
);
2192 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
2193 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
2194 bp
= xdr_encode_u32(bp
, acl
->size
);
2195 memcpy(bp
, acl
->data
, acl
->size
);
2196 if (acl
->size
!= size
)
2197 memset((void *)bp
+ acl
->size
, 0, size
- acl
->size
);
2198 yfs_check_req(call
, bp
);
2200 trace_afs_make_fs_call(call
, &vnode
->fid
);
2201 afs_make_call(&fc
->ac
, call
, GFP_KERNEL
);
2202 return afs_wait_for_call_to_complete(call
, &fc
->ac
);