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_warn("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
< 6 * 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("0x60: %08x %08x\n", ntohl(x
[0]), ntohl(x
[1]));
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
;
191 status
->abort_code
= ntohl(xdr
->abort_code
);
192 if (status
->abort_code
!= 0) {
193 if (status
->abort_code
== VNOVNODE
)
195 scb
->have_error
= true;
199 type
= ntohl(xdr
->type
);
203 case AFS_FTYPE_SYMLINK
:
210 status
->nlink
= ntohl(xdr
->nlink
);
211 status
->author
= xdr_to_u64(xdr
->author
);
212 status
->owner
= xdr_to_u64(xdr
->owner
);
213 status
->caller_access
= ntohl(xdr
->caller_access
); /* Ticket dependent */
214 status
->anon_access
= ntohl(xdr
->anon_access
);
215 status
->mode
= ntohl(xdr
->mode
) & S_IALLUGO
;
216 status
->group
= xdr_to_u64(xdr
->group
);
217 status
->lock_count
= ntohl(xdr
->lock_count
);
219 status
->mtime_client
= xdr_to_time(xdr
->mtime_client
);
220 status
->mtime_server
= xdr_to_time(xdr
->mtime_server
);
221 status
->size
= xdr_to_u64(xdr
->size
);
222 status
->data_version
= xdr_to_u64(xdr
->data_version
);
223 scb
->have_status
= true;
227 *_bp
+= xdr_size(xdr
);
232 ret
= 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
);
459 /* extract the returned data length */
461 _debug("extract data length");
462 ret
= afs_extract_data(call
, true);
466 req
->actual_len
= be64_to_cpu(call
->tmp64
);
467 _debug("DATA length: %llu", req
->actual_len
);
468 req
->remain
= min(req
->len
, req
->actual_len
);
469 if (req
->remain
== 0)
475 ASSERTCMP(req
->index
, <, req
->nr_pages
);
476 if (req
->remain
> PAGE_SIZE
- req
->offset
)
477 size
= PAGE_SIZE
- req
->offset
;
480 call
->bvec
[0].bv_len
= size
;
481 call
->bvec
[0].bv_offset
= req
->offset
;
482 call
->bvec
[0].bv_page
= req
->pages
[req
->index
];
483 iov_iter_bvec(&call
->def_iter
, READ
, call
->bvec
, 1, size
);
484 ASSERTCMP(size
, <=, PAGE_SIZE
);
487 /* extract the returned data */
489 _debug("extract data %zu/%llu",
490 iov_iter_count(call
->iter
), req
->remain
);
492 ret
= afs_extract_data(call
, true);
495 req
->remain
-= call
->bvec
[0].bv_len
;
496 req
->offset
+= call
->bvec
[0].bv_len
;
497 ASSERTCMP(req
->offset
, <=, PAGE_SIZE
);
498 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 afs_extract_discard(call
, 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
));
530 /* extract the metadata */
532 ret
= afs_extract_data(call
, false);
537 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
540 xdr_decode_YFSCallBack(&bp
, call
, call
->out_scb
);
541 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
543 req
->data_version
= call
->out_scb
->status
.data_version
;
544 req
->file_size
= call
->out_scb
->status
.size
;
553 for (; req
->index
< req
->nr_pages
; req
->index
++) {
554 if (req
->offset
< PAGE_SIZE
)
555 zero_user_segment(req
->pages
[req
->index
],
556 req
->offset
, PAGE_SIZE
);
561 for (req
->index
= 0; req
->index
< req
->nr_pages
; req
->index
++)
564 _leave(" = 0 [done]");
568 static void yfs_fetch_data_destructor(struct afs_call
*call
)
570 afs_put_read(call
->read_request
);
571 afs_flat_call_destructor(call
);
575 * YFS.FetchData64 operation type
577 static const struct afs_call_type yfs_RXYFSFetchData64
= {
578 .name
= "YFS.FetchData64",
579 .op
= yfs_FS_FetchData64
,
580 .deliver
= yfs_deliver_fs_fetch_data64
,
581 .destructor
= yfs_fetch_data_destructor
,
585 * Fetch data from a file.
587 int yfs_fs_fetch_data(struct afs_fs_cursor
*fc
, struct afs_status_cb
*scb
,
588 struct afs_read
*req
)
590 struct afs_vnode
*vnode
= fc
->vnode
;
591 struct afs_call
*call
;
592 struct afs_net
*net
= afs_v2net(vnode
);
595 _enter(",%x,{%llx:%llu},%llx,%llx",
596 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
,
599 call
= afs_alloc_flat_call(net
, &yfs_RXYFSFetchData64
,
601 sizeof(struct yfs_xdr_YFSFid
) +
602 sizeof(struct yfs_xdr_u64
) * 2,
603 sizeof(struct yfs_xdr_YFSFetchStatus
) +
604 sizeof(struct yfs_xdr_YFSCallBack
) +
605 sizeof(struct yfs_xdr_YFSVolSync
));
611 call
->out_volsync
= NULL
;
612 call
->read_request
= afs_get_read(req
);
614 /* marshall the parameters */
616 bp
= xdr_encode_u32(bp
, YFSFETCHDATA64
);
617 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
618 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
619 bp
= xdr_encode_u64(bp
, req
->pos
);
620 bp
= xdr_encode_u64(bp
, req
->len
);
621 yfs_check_req(call
, bp
);
623 afs_use_fs_server(call
, fc
->cbi
);
624 trace_afs_make_fs_call(call
, &vnode
->fid
);
625 afs_set_fc_call(call
, fc
);
626 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
627 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
631 * Deliver reply data for YFS.CreateFile or YFS.MakeDir.
633 static int yfs_deliver_fs_create_vnode(struct afs_call
*call
)
638 _enter("{%u}", call
->unmarshall
);
640 ret
= afs_transfer_reply(call
);
644 /* unmarshall the reply once we've received all of it */
646 xdr_decode_YFSFid(&bp
, call
->out_fid
);
647 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
650 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
653 xdr_decode_YFSCallBack(&bp
, call
, call
->out_scb
);
654 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
656 _leave(" = 0 [done]");
661 * FS.CreateFile and FS.MakeDir operation type
663 static const struct afs_call_type afs_RXFSCreateFile
= {
664 .name
= "YFS.CreateFile",
665 .op
= yfs_FS_CreateFile
,
666 .deliver
= yfs_deliver_fs_create_vnode
,
667 .destructor
= afs_flat_call_destructor
,
673 int yfs_fs_create_file(struct afs_fs_cursor
*fc
,
676 struct afs_status_cb
*dvnode_scb
,
677 struct afs_fid
*newfid
,
678 struct afs_status_cb
*new_scb
)
680 struct afs_vnode
*dvnode
= fc
->vnode
;
681 struct afs_call
*call
;
682 struct afs_net
*net
= afs_v2net(dvnode
);
683 size_t namesz
, reqsz
, rplsz
;
688 namesz
= strlen(name
);
689 reqsz
= (sizeof(__be32
) +
691 sizeof(struct yfs_xdr_YFSFid
) +
693 sizeof(struct yfs_xdr_YFSStoreStatus
) +
695 rplsz
= (sizeof(struct yfs_xdr_YFSFid
) +
696 sizeof(struct yfs_xdr_YFSFetchStatus
) +
697 sizeof(struct yfs_xdr_YFSFetchStatus
) +
698 sizeof(struct yfs_xdr_YFSCallBack
) +
699 sizeof(struct yfs_xdr_YFSVolSync
));
701 call
= afs_alloc_flat_call(net
, &afs_RXFSCreateFile
, reqsz
, rplsz
);
706 call
->out_dir_scb
= dvnode_scb
;
707 call
->out_fid
= newfid
;
708 call
->out_scb
= new_scb
;
710 /* marshall the parameters */
712 bp
= xdr_encode_u32(bp
, YFSCREATEFILE
);
713 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
714 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
715 bp
= xdr_encode_string(bp
, name
, namesz
);
716 bp
= xdr_encode_YFSStoreStatus_mode(bp
, mode
);
717 bp
= xdr_encode_u32(bp
, yfs_LockNone
); /* ViceLockType */
718 yfs_check_req(call
, bp
);
720 afs_use_fs_server(call
, fc
->cbi
);
721 trace_afs_make_fs_call1(call
, &dvnode
->fid
, name
);
722 afs_set_fc_call(call
, fc
);
723 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
724 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
727 static const struct afs_call_type yfs_RXFSMakeDir
= {
728 .name
= "YFS.MakeDir",
729 .op
= yfs_FS_MakeDir
,
730 .deliver
= yfs_deliver_fs_create_vnode
,
731 .destructor
= afs_flat_call_destructor
,
737 int yfs_fs_make_dir(struct afs_fs_cursor
*fc
,
740 struct afs_status_cb
*dvnode_scb
,
741 struct afs_fid
*newfid
,
742 struct afs_status_cb
*new_scb
)
744 struct afs_vnode
*dvnode
= fc
->vnode
;
745 struct afs_call
*call
;
746 struct afs_net
*net
= afs_v2net(dvnode
);
747 size_t namesz
, reqsz
, rplsz
;
752 namesz
= strlen(name
);
753 reqsz
= (sizeof(__be32
) +
754 sizeof(struct yfs_xdr_RPCFlags
) +
755 sizeof(struct yfs_xdr_YFSFid
) +
757 sizeof(struct yfs_xdr_YFSStoreStatus
));
758 rplsz
= (sizeof(struct yfs_xdr_YFSFid
) +
759 sizeof(struct yfs_xdr_YFSFetchStatus
) +
760 sizeof(struct yfs_xdr_YFSFetchStatus
) +
761 sizeof(struct yfs_xdr_YFSCallBack
) +
762 sizeof(struct yfs_xdr_YFSVolSync
));
764 call
= afs_alloc_flat_call(net
, &yfs_RXFSMakeDir
, reqsz
, rplsz
);
769 call
->out_dir_scb
= dvnode_scb
;
770 call
->out_fid
= newfid
;
771 call
->out_scb
= new_scb
;
773 /* marshall the parameters */
775 bp
= xdr_encode_u32(bp
, YFSMAKEDIR
);
776 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
777 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
778 bp
= xdr_encode_string(bp
, name
, namesz
);
779 bp
= xdr_encode_YFSStoreStatus_mode(bp
, mode
);
780 yfs_check_req(call
, bp
);
782 afs_use_fs_server(call
, fc
->cbi
);
783 trace_afs_make_fs_call1(call
, &dvnode
->fid
, name
);
784 afs_set_fc_call(call
, fc
);
785 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
786 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
790 * Deliver reply data to a YFS.RemoveFile2 operation.
792 static int yfs_deliver_fs_remove_file2(struct afs_call
*call
)
798 _enter("{%u}", call
->unmarshall
);
800 ret
= afs_transfer_reply(call
);
805 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
809 xdr_decode_YFSFid(&bp
, &fid
);
810 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
813 /* Was deleted if vnode->status.abort_code == VNOVNODE. */
815 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
820 * YFS.RemoveFile2 operation type.
822 static const struct afs_call_type yfs_RXYFSRemoveFile2
= {
823 .name
= "YFS.RemoveFile2",
824 .op
= yfs_FS_RemoveFile2
,
825 .deliver
= yfs_deliver_fs_remove_file2
,
826 .destructor
= afs_flat_call_destructor
,
830 * Remove a file and retrieve new file status.
832 int yfs_fs_remove_file2(struct afs_fs_cursor
*fc
, struct afs_vnode
*vnode
,
833 const char *name
, struct afs_status_cb
*dvnode_scb
,
834 struct afs_status_cb
*vnode_scb
)
836 struct afs_vnode
*dvnode
= fc
->vnode
;
837 struct afs_call
*call
;
838 struct afs_net
*net
= afs_v2net(dvnode
);
844 namesz
= strlen(name
);
846 call
= afs_alloc_flat_call(net
, &yfs_RXYFSRemoveFile2
,
848 sizeof(struct yfs_xdr_RPCFlags
) +
849 sizeof(struct yfs_xdr_YFSFid
) +
851 sizeof(struct yfs_xdr_YFSFetchStatus
) +
852 sizeof(struct yfs_xdr_YFSFid
) +
853 sizeof(struct yfs_xdr_YFSFetchStatus
) +
854 sizeof(struct yfs_xdr_YFSVolSync
));
859 call
->out_dir_scb
= dvnode_scb
;
860 call
->out_scb
= vnode_scb
;
862 /* marshall the parameters */
864 bp
= xdr_encode_u32(bp
, YFSREMOVEFILE2
);
865 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
866 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
867 bp
= xdr_encode_string(bp
, name
, namesz
);
868 yfs_check_req(call
, bp
);
870 afs_use_fs_server(call
, fc
->cbi
);
871 trace_afs_make_fs_call1(call
, &dvnode
->fid
, name
);
872 afs_set_fc_call(call
, fc
);
873 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
874 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
878 * Deliver reply data to a YFS.RemoveFile or YFS.RemoveDir operation.
880 static int yfs_deliver_fs_remove(struct afs_call
*call
)
885 _enter("{%u}", call
->unmarshall
);
887 ret
= afs_transfer_reply(call
);
892 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
896 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
901 * FS.RemoveDir and FS.RemoveFile operation types.
903 static const struct afs_call_type yfs_RXYFSRemoveFile
= {
904 .name
= "YFS.RemoveFile",
905 .op
= yfs_FS_RemoveFile
,
906 .deliver
= yfs_deliver_fs_remove
,
907 .destructor
= afs_flat_call_destructor
,
910 static const struct afs_call_type yfs_RXYFSRemoveDir
= {
911 .name
= "YFS.RemoveDir",
912 .op
= yfs_FS_RemoveDir
,
913 .deliver
= yfs_deliver_fs_remove
,
914 .destructor
= afs_flat_call_destructor
,
918 * remove a file or directory
920 int yfs_fs_remove(struct afs_fs_cursor
*fc
, struct afs_vnode
*vnode
,
921 const char *name
, bool isdir
,
922 struct afs_status_cb
*dvnode_scb
)
924 struct afs_vnode
*dvnode
= fc
->vnode
;
925 struct afs_call
*call
;
926 struct afs_net
*net
= afs_v2net(dvnode
);
932 namesz
= strlen(name
);
933 call
= afs_alloc_flat_call(
934 net
, isdir
? &yfs_RXYFSRemoveDir
: &yfs_RXYFSRemoveFile
,
936 sizeof(struct yfs_xdr_RPCFlags
) +
937 sizeof(struct yfs_xdr_YFSFid
) +
939 sizeof(struct yfs_xdr_YFSFetchStatus
) +
940 sizeof(struct yfs_xdr_YFSVolSync
));
945 call
->out_dir_scb
= dvnode_scb
;
947 /* marshall the parameters */
949 bp
= xdr_encode_u32(bp
, isdir
? YFSREMOVEDIR
: YFSREMOVEFILE
);
950 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
951 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
952 bp
= xdr_encode_string(bp
, name
, namesz
);
953 yfs_check_req(call
, bp
);
955 afs_use_fs_server(call
, fc
->cbi
);
956 trace_afs_make_fs_call1(call
, &dvnode
->fid
, name
);
957 afs_set_fc_call(call
, fc
);
958 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
959 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
963 * Deliver reply data to a YFS.Link operation.
965 static int yfs_deliver_fs_link(struct afs_call
*call
)
970 _enter("{%u}", call
->unmarshall
);
972 ret
= afs_transfer_reply(call
);
977 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
980 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
983 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
984 _leave(" = 0 [done]");
989 * YFS.Link operation type.
991 static const struct afs_call_type yfs_RXYFSLink
= {
994 .deliver
= yfs_deliver_fs_link
,
995 .destructor
= afs_flat_call_destructor
,
1001 int yfs_fs_link(struct afs_fs_cursor
*fc
, struct afs_vnode
*vnode
,
1003 struct afs_status_cb
*dvnode_scb
,
1004 struct afs_status_cb
*vnode_scb
)
1006 struct afs_vnode
*dvnode
= fc
->vnode
;
1007 struct afs_call
*call
;
1008 struct afs_net
*net
= afs_v2net(vnode
);
1014 namesz
= strlen(name
);
1015 call
= afs_alloc_flat_call(net
, &yfs_RXYFSLink
,
1017 sizeof(struct yfs_xdr_RPCFlags
) +
1018 sizeof(struct yfs_xdr_YFSFid
) +
1019 xdr_strlen(namesz
) +
1020 sizeof(struct yfs_xdr_YFSFid
),
1021 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1022 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1023 sizeof(struct yfs_xdr_YFSVolSync
));
1027 call
->key
= fc
->key
;
1028 call
->out_dir_scb
= dvnode_scb
;
1029 call
->out_scb
= vnode_scb
;
1031 /* marshall the parameters */
1033 bp
= xdr_encode_u32(bp
, YFSLINK
);
1034 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1035 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
1036 bp
= xdr_encode_string(bp
, name
, namesz
);
1037 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1038 yfs_check_req(call
, bp
);
1040 afs_use_fs_server(call
, fc
->cbi
);
1041 trace_afs_make_fs_call1(call
, &vnode
->fid
, name
);
1042 afs_set_fc_call(call
, fc
);
1043 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1044 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1048 * Deliver reply data to a YFS.Symlink operation.
1050 static int yfs_deliver_fs_symlink(struct afs_call
*call
)
1055 _enter("{%u}", call
->unmarshall
);
1057 ret
= afs_transfer_reply(call
);
1061 /* unmarshall the reply once we've received all of it */
1063 xdr_decode_YFSFid(&bp
, call
->out_fid
);
1064 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
1067 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
1070 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
1072 _leave(" = 0 [done]");
1077 * YFS.Symlink operation type
1079 static const struct afs_call_type yfs_RXYFSSymlink
= {
1080 .name
= "YFS.Symlink",
1081 .op
= yfs_FS_Symlink
,
1082 .deliver
= yfs_deliver_fs_symlink
,
1083 .destructor
= afs_flat_call_destructor
,
1087 * Create a symbolic link.
1089 int yfs_fs_symlink(struct afs_fs_cursor
*fc
,
1091 const char *contents
,
1092 struct afs_status_cb
*dvnode_scb
,
1093 struct afs_fid
*newfid
,
1094 struct afs_status_cb
*vnode_scb
)
1096 struct afs_vnode
*dvnode
= fc
->vnode
;
1097 struct afs_call
*call
;
1098 struct afs_net
*net
= afs_v2net(dvnode
);
1099 size_t namesz
, contents_sz
;
1104 namesz
= strlen(name
);
1105 contents_sz
= strlen(contents
);
1106 call
= afs_alloc_flat_call(net
, &yfs_RXYFSSymlink
,
1108 sizeof(struct yfs_xdr_RPCFlags
) +
1109 sizeof(struct yfs_xdr_YFSFid
) +
1110 xdr_strlen(namesz
) +
1111 xdr_strlen(contents_sz
) +
1112 sizeof(struct yfs_xdr_YFSStoreStatus
),
1113 sizeof(struct yfs_xdr_YFSFid
) +
1114 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1115 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1116 sizeof(struct yfs_xdr_YFSVolSync
));
1120 call
->key
= fc
->key
;
1121 call
->out_dir_scb
= dvnode_scb
;
1122 call
->out_fid
= newfid
;
1123 call
->out_scb
= vnode_scb
;
1125 /* marshall the parameters */
1127 bp
= xdr_encode_u32(bp
, YFSSYMLINK
);
1128 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1129 bp
= xdr_encode_YFSFid(bp
, &dvnode
->fid
);
1130 bp
= xdr_encode_string(bp
, name
, namesz
);
1131 bp
= xdr_encode_string(bp
, contents
, contents_sz
);
1132 bp
= xdr_encode_YFSStoreStatus_mode(bp
, S_IRWXUGO
);
1133 yfs_check_req(call
, bp
);
1135 afs_use_fs_server(call
, fc
->cbi
);
1136 trace_afs_make_fs_call1(call
, &dvnode
->fid
, name
);
1137 afs_set_fc_call(call
, fc
);
1138 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1139 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1143 * Deliver reply data to a YFS.Rename operation.
1145 static int yfs_deliver_fs_rename(struct afs_call
*call
)
1150 _enter("{%u}", call
->unmarshall
);
1152 ret
= afs_transfer_reply(call
);
1157 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_dir_scb
);
1160 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
));
1438 /* extract the returned status record */
1440 _debug("extract status");
1441 ret
= afs_extract_data(call
, true);
1446 xdr_decode_YFSFetchVolumeStatus(&bp
, call
->out_volstatus
);
1448 afs_extract_to_tmp(call
);
1451 /* extract the volume name length */
1453 ret
= afs_extract_data(call
, true);
1457 call
->count
= ntohl(call
->tmp
);
1458 _debug("volname length: %u", call
->count
);
1459 if (call
->count
>= AFSNAMEMAX
)
1460 return afs_protocol_error(call
, -EBADMSG
,
1461 afs_eproto_volname_len
);
1462 size
= (call
->count
+ 3) & ~3; /* It's padded */
1463 afs_extract_to_buf(call
, size
);
1467 /* extract the volume name */
1469 _debug("extract volname");
1470 ret
= afs_extract_data(call
, true);
1476 _debug("volname '%s'", p
);
1477 afs_extract_to_tmp(call
);
1481 /* extract the offline message length */
1483 ret
= afs_extract_data(call
, true);
1487 call
->count
= ntohl(call
->tmp
);
1488 _debug("offline msg length: %u", call
->count
);
1489 if (call
->count
>= AFSNAMEMAX
)
1490 return afs_protocol_error(call
, -EBADMSG
,
1491 afs_eproto_offline_msg_len
);
1492 size
= (call
->count
+ 3) & ~3; /* It's padded */
1493 afs_extract_to_buf(call
, size
);
1497 /* extract the offline message */
1499 _debug("extract offline");
1500 ret
= afs_extract_data(call
, true);
1506 _debug("offline '%s'", p
);
1508 afs_extract_to_tmp(call
);
1512 /* extract the message of the day length */
1514 ret
= afs_extract_data(call
, true);
1518 call
->count
= ntohl(call
->tmp
);
1519 _debug("motd length: %u", call
->count
);
1520 if (call
->count
>= AFSNAMEMAX
)
1521 return afs_protocol_error(call
, -EBADMSG
,
1522 afs_eproto_motd_len
);
1523 size
= (call
->count
+ 3) & ~3; /* It's padded */
1524 afs_extract_to_buf(call
, size
);
1528 /* extract the message of the day */
1530 _debug("extract motd");
1531 ret
= afs_extract_data(call
, false);
1537 _debug("motd '%s'", p
);
1546 _leave(" = 0 [done]");
1551 * YFS.GetVolumeStatus operation type
1553 static const struct afs_call_type yfs_RXYFSGetVolumeStatus
= {
1554 .name
= "YFS.GetVolumeStatus",
1555 .op
= yfs_FS_GetVolumeStatus
,
1556 .deliver
= yfs_deliver_fs_get_volume_status
,
1557 .destructor
= afs_flat_call_destructor
,
1561 * fetch the status of a volume
1563 int yfs_fs_get_volume_status(struct afs_fs_cursor
*fc
,
1564 struct afs_volume_status
*vs
)
1566 struct afs_vnode
*vnode
= fc
->vnode
;
1567 struct afs_call
*call
;
1568 struct afs_net
*net
= afs_v2net(vnode
);
1573 call
= afs_alloc_flat_call(net
, &yfs_RXYFSGetVolumeStatus
,
1574 sizeof(__be32
) * 2 +
1575 sizeof(struct yfs_xdr_u64
),
1577 sizeof(struct yfs_xdr_YFSFetchVolumeStatus
) +
1583 call
->key
= fc
->key
;
1584 call
->out_volstatus
= vs
;
1586 /* marshall the parameters */
1588 bp
= xdr_encode_u32(bp
, YFSGETVOLUMESTATUS
);
1589 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1590 bp
= xdr_encode_u64(bp
, vnode
->fid
.vid
);
1591 yfs_check_req(call
, bp
);
1593 afs_use_fs_server(call
, fc
->cbi
);
1594 trace_afs_make_fs_call(call
, &vnode
->fid
);
1595 afs_set_fc_call(call
, fc
);
1596 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1597 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1601 * YFS.SetLock operation type
1603 static const struct afs_call_type yfs_RXYFSSetLock
= {
1604 .name
= "YFS.SetLock",
1605 .op
= yfs_FS_SetLock
,
1606 .deliver
= yfs_deliver_status_and_volsync
,
1607 .done
= afs_lock_op_done
,
1608 .destructor
= afs_flat_call_destructor
,
1612 * YFS.ExtendLock operation type
1614 static const struct afs_call_type yfs_RXYFSExtendLock
= {
1615 .name
= "YFS.ExtendLock",
1616 .op
= yfs_FS_ExtendLock
,
1617 .deliver
= yfs_deliver_status_and_volsync
,
1618 .done
= afs_lock_op_done
,
1619 .destructor
= afs_flat_call_destructor
,
1623 * YFS.ReleaseLock operation type
1625 static const struct afs_call_type yfs_RXYFSReleaseLock
= {
1626 .name
= "YFS.ReleaseLock",
1627 .op
= yfs_FS_ReleaseLock
,
1628 .deliver
= yfs_deliver_status_and_volsync
,
1629 .destructor
= afs_flat_call_destructor
,
1633 * Set a lock on a file
1635 int yfs_fs_set_lock(struct afs_fs_cursor
*fc
, afs_lock_type_t type
,
1636 struct afs_status_cb
*scb
)
1638 struct afs_vnode
*vnode
= fc
->vnode
;
1639 struct afs_call
*call
;
1640 struct afs_net
*net
= afs_v2net(vnode
);
1645 call
= afs_alloc_flat_call(net
, &yfs_RXYFSSetLock
,
1646 sizeof(__be32
) * 2 +
1647 sizeof(struct yfs_xdr_YFSFid
) +
1649 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1650 sizeof(struct yfs_xdr_YFSVolSync
));
1654 call
->key
= fc
->key
;
1655 call
->lvnode
= vnode
;
1656 call
->out_scb
= scb
;
1658 /* marshall the parameters */
1660 bp
= xdr_encode_u32(bp
, YFSSETLOCK
);
1661 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1662 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1663 bp
= xdr_encode_u32(bp
, type
);
1664 yfs_check_req(call
, bp
);
1666 afs_use_fs_server(call
, fc
->cbi
);
1667 trace_afs_make_fs_calli(call
, &vnode
->fid
, type
);
1668 afs_set_fc_call(call
, fc
);
1669 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1670 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1674 * extend a lock on a file
1676 int yfs_fs_extend_lock(struct afs_fs_cursor
*fc
, struct afs_status_cb
*scb
)
1678 struct afs_vnode
*vnode
= fc
->vnode
;
1679 struct afs_call
*call
;
1680 struct afs_net
*net
= afs_v2net(vnode
);
1685 call
= afs_alloc_flat_call(net
, &yfs_RXYFSExtendLock
,
1686 sizeof(__be32
) * 2 +
1687 sizeof(struct yfs_xdr_YFSFid
),
1688 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1689 sizeof(struct yfs_xdr_YFSVolSync
));
1693 call
->key
= fc
->key
;
1694 call
->lvnode
= vnode
;
1695 call
->out_scb
= scb
;
1697 /* marshall the parameters */
1699 bp
= xdr_encode_u32(bp
, YFSEXTENDLOCK
);
1700 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1701 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1702 yfs_check_req(call
, bp
);
1704 afs_use_fs_server(call
, fc
->cbi
);
1705 trace_afs_make_fs_call(call
, &vnode
->fid
);
1706 afs_set_fc_call(call
, fc
);
1707 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1708 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1712 * release a lock on a file
1714 int yfs_fs_release_lock(struct afs_fs_cursor
*fc
, struct afs_status_cb
*scb
)
1716 struct afs_vnode
*vnode
= fc
->vnode
;
1717 struct afs_call
*call
;
1718 struct afs_net
*net
= afs_v2net(vnode
);
1723 call
= afs_alloc_flat_call(net
, &yfs_RXYFSReleaseLock
,
1724 sizeof(__be32
) * 2 +
1725 sizeof(struct yfs_xdr_YFSFid
),
1726 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1727 sizeof(struct yfs_xdr_YFSVolSync
));
1731 call
->key
= fc
->key
;
1732 call
->lvnode
= vnode
;
1733 call
->out_scb
= scb
;
1735 /* marshall the parameters */
1737 bp
= xdr_encode_u32(bp
, YFSRELEASELOCK
);
1738 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1739 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
1740 yfs_check_req(call
, bp
);
1742 afs_use_fs_server(call
, fc
->cbi
);
1743 trace_afs_make_fs_call(call
, &vnode
->fid
);
1744 afs_set_fc_call(call
, fc
);
1745 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1746 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1750 * YFS.FetchStatus operation type
1752 static const struct afs_call_type yfs_RXYFSFetchStatus
= {
1753 .name
= "YFS.FetchStatus",
1754 .op
= yfs_FS_FetchStatus
,
1755 .deliver
= yfs_deliver_fs_status_cb_and_volsync
,
1756 .destructor
= afs_flat_call_destructor
,
1760 * Fetch the status information for a fid without needing a vnode handle.
1762 int yfs_fs_fetch_status(struct afs_fs_cursor
*fc
,
1763 struct afs_net
*net
,
1764 struct afs_fid
*fid
,
1765 struct afs_status_cb
*scb
,
1766 struct afs_volsync
*volsync
)
1768 struct afs_call
*call
;
1771 _enter(",%x,{%llx:%llu},,",
1772 key_serial(fc
->key
), fid
->vid
, fid
->vnode
);
1774 call
= afs_alloc_flat_call(net
, &yfs_RXYFSFetchStatus
,
1775 sizeof(__be32
) * 2 +
1776 sizeof(struct yfs_xdr_YFSFid
),
1777 sizeof(struct yfs_xdr_YFSFetchStatus
) +
1778 sizeof(struct yfs_xdr_YFSCallBack
) +
1779 sizeof(struct yfs_xdr_YFSVolSync
));
1781 fc
->ac
.error
= -ENOMEM
;
1785 call
->key
= fc
->key
;
1786 call
->out_scb
= scb
;
1787 call
->out_volsync
= volsync
;
1789 /* marshall the parameters */
1791 bp
= xdr_encode_u32(bp
, YFSFETCHSTATUS
);
1792 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
1793 bp
= xdr_encode_YFSFid(bp
, fid
);
1794 yfs_check_req(call
, bp
);
1796 afs_use_fs_server(call
, fc
->cbi
);
1797 trace_afs_make_fs_call(call
, fid
);
1798 afs_set_fc_call(call
, fc
);
1799 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1800 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1804 * Deliver reply data to an YFS.InlineBulkStatus call
1806 static int yfs_deliver_fs_inline_bulk_status(struct afs_call
*call
)
1808 struct afs_status_cb
*scb
;
1813 _enter("{%u}", call
->unmarshall
);
1815 switch (call
->unmarshall
) {
1817 afs_extract_to_tmp(call
);
1821 /* Extract the file status count and array in two steps */
1823 _debug("extract status count");
1824 ret
= afs_extract_data(call
, true);
1828 tmp
= ntohl(call
->tmp
);
1829 _debug("status count: %u/%u", tmp
, call
->count2
);
1830 if (tmp
!= call
->count2
)
1831 return afs_protocol_error(call
, -EBADMSG
,
1832 afs_eproto_ibulkst_count
);
1837 afs_extract_to_buf(call
, sizeof(struct yfs_xdr_YFSFetchStatus
));
1841 _debug("extract status array %u", call
->count
);
1842 ret
= afs_extract_data(call
, true);
1847 scb
= &call
->out_scb
[call
->count
];
1848 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, scb
);
1853 if (call
->count
< call
->count2
)
1858 afs_extract_to_tmp(call
);
1861 /* Extract the callback count and array in two steps */
1863 _debug("extract CB count");
1864 ret
= afs_extract_data(call
, true);
1868 tmp
= ntohl(call
->tmp
);
1869 _debug("CB count: %u", tmp
);
1870 if (tmp
!= call
->count2
)
1871 return afs_protocol_error(call
, -EBADMSG
,
1872 afs_eproto_ibulkst_cb_count
);
1876 afs_extract_to_buf(call
, sizeof(struct yfs_xdr_YFSCallBack
));
1880 _debug("extract CB array");
1881 ret
= afs_extract_data(call
, true);
1885 _debug("unmarshall CB array");
1887 scb
= &call
->out_scb
[call
->count
];
1888 xdr_decode_YFSCallBack(&bp
, call
, scb
);
1890 if (call
->count
< call
->count2
)
1893 afs_extract_to_buf(call
, sizeof(struct yfs_xdr_YFSVolSync
));
1898 ret
= afs_extract_data(call
, false);
1903 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
1912 _leave(" = 0 [done]");
1917 * FS.InlineBulkStatus operation type
1919 static const struct afs_call_type yfs_RXYFSInlineBulkStatus
= {
1920 .name
= "YFS.InlineBulkStatus",
1921 .op
= yfs_FS_InlineBulkStatus
,
1922 .deliver
= yfs_deliver_fs_inline_bulk_status
,
1923 .destructor
= afs_flat_call_destructor
,
1927 * Fetch the status information for up to 1024 files
1929 int yfs_fs_inline_bulk_status(struct afs_fs_cursor
*fc
,
1930 struct afs_net
*net
,
1931 struct afs_fid
*fids
,
1932 struct afs_status_cb
*statuses
,
1933 unsigned int nr_fids
,
1934 struct afs_volsync
*volsync
)
1936 struct afs_call
*call
;
1940 _enter(",%x,{%llx:%llu},%u",
1941 key_serial(fc
->key
), fids
[0].vid
, fids
[1].vnode
, nr_fids
);
1943 call
= afs_alloc_flat_call(net
, &yfs_RXYFSInlineBulkStatus
,
1947 sizeof(struct yfs_xdr_YFSFid
) * nr_fids
,
1948 sizeof(struct yfs_xdr_YFSFetchStatus
));
1950 fc
->ac
.error
= -ENOMEM
;
1954 call
->key
= fc
->key
;
1955 call
->out_scb
= statuses
;
1956 call
->out_volsync
= volsync
;
1957 call
->count2
= nr_fids
;
1959 /* marshall the parameters */
1961 bp
= xdr_encode_u32(bp
, YFSINLINEBULKSTATUS
);
1962 bp
= xdr_encode_u32(bp
, 0); /* RPCFlags */
1963 bp
= xdr_encode_u32(bp
, nr_fids
);
1964 for (i
= 0; i
< nr_fids
; i
++)
1965 bp
= xdr_encode_YFSFid(bp
, &fids
[i
]);
1966 yfs_check_req(call
, bp
);
1968 afs_use_fs_server(call
, fc
->cbi
);
1969 trace_afs_make_fs_call(call
, &fids
[0]);
1970 afs_set_fc_call(call
, fc
);
1971 afs_make_call(&fc
->ac
, call
, GFP_NOFS
);
1972 return afs_wait_for_call_to_complete(call
, &fc
->ac
);
1976 * Deliver reply data to an YFS.FetchOpaqueACL.
1978 static int yfs_deliver_fs_fetch_opaque_acl(struct afs_call
*call
)
1980 struct yfs_acl
*yacl
= call
->out_yacl
;
1981 struct afs_acl
*acl
;
1986 _enter("{%u}", call
->unmarshall
);
1988 switch (call
->unmarshall
) {
1990 afs_extract_to_tmp(call
);
1994 /* Extract the file ACL length */
1996 ret
= afs_extract_data(call
, true);
2000 size
= call
->count2
= ntohl(call
->tmp
);
2001 size
= round_up(size
, 4);
2003 if (yacl
->flags
& YFS_ACL_WANT_ACL
) {
2004 acl
= kmalloc(struct_size(acl
, data
, size
), GFP_KERNEL
);
2008 acl
->size
= call
->count2
;
2009 afs_extract_begin(call
, acl
->data
, size
);
2011 afs_extract_discard(call
, size
);
2016 /* Extract the file ACL */
2018 ret
= afs_extract_data(call
, true);
2022 afs_extract_to_tmp(call
);
2026 /* Extract the volume ACL length */
2028 ret
= afs_extract_data(call
, true);
2032 size
= call
->count2
= ntohl(call
->tmp
);
2033 size
= round_up(size
, 4);
2035 if (yacl
->flags
& YFS_ACL_WANT_VOL_ACL
) {
2036 acl
= kmalloc(struct_size(acl
, data
, size
), GFP_KERNEL
);
2039 yacl
->vol_acl
= acl
;
2040 acl
->size
= call
->count2
;
2041 afs_extract_begin(call
, acl
->data
, size
);
2043 afs_extract_discard(call
, size
);
2048 /* Extract the volume ACL */
2050 ret
= afs_extract_data(call
, true);
2054 afs_extract_to_buf(call
,
2055 sizeof(__be32
) * 2 +
2056 sizeof(struct yfs_xdr_YFSFetchStatus
) +
2057 sizeof(struct yfs_xdr_YFSVolSync
));
2061 /* extract the metadata */
2063 ret
= afs_extract_data(call
, false);
2068 yacl
->inherit_flag
= ntohl(*bp
++);
2069 yacl
->num_cleaned
= ntohl(*bp
++);
2070 ret
= xdr_decode_YFSFetchStatus(&bp
, call
, call
->out_scb
);
2073 xdr_decode_YFSVolSync(&bp
, call
->out_volsync
);
2082 _leave(" = 0 [done]");
2086 void yfs_free_opaque_acl(struct yfs_acl
*yacl
)
2090 kfree(yacl
->vol_acl
);
2096 * YFS.FetchOpaqueACL operation type
2098 static const struct afs_call_type yfs_RXYFSFetchOpaqueACL
= {
2099 .name
= "YFS.FetchOpaqueACL",
2100 .op
= yfs_FS_FetchOpaqueACL
,
2101 .deliver
= yfs_deliver_fs_fetch_opaque_acl
,
2102 .destructor
= afs_flat_call_destructor
,
2106 * Fetch the YFS advanced ACLs for a file.
2108 struct yfs_acl
*yfs_fs_fetch_opaque_acl(struct afs_fs_cursor
*fc
,
2109 struct yfs_acl
*yacl
,
2110 struct afs_status_cb
*scb
)
2112 struct afs_vnode
*vnode
= fc
->vnode
;
2113 struct afs_call
*call
;
2114 struct afs_net
*net
= afs_v2net(vnode
);
2117 _enter(",%x,{%llx:%llu},,",
2118 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
);
2120 call
= afs_alloc_flat_call(net
, &yfs_RXYFSFetchOpaqueACL
,
2121 sizeof(__be32
) * 2 +
2122 sizeof(struct yfs_xdr_YFSFid
),
2123 sizeof(__be32
) * 2 +
2124 sizeof(struct yfs_xdr_YFSFetchStatus
) +
2125 sizeof(struct yfs_xdr_YFSVolSync
));
2127 fc
->ac
.error
= -ENOMEM
;
2128 return ERR_PTR(-ENOMEM
);
2131 call
->key
= fc
->key
;
2132 call
->out_yacl
= yacl
;
2133 call
->out_scb
= scb
;
2134 call
->out_volsync
= NULL
;
2136 /* marshall the parameters */
2138 bp
= xdr_encode_u32(bp
, YFSFETCHOPAQUEACL
);
2139 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
2140 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
2141 yfs_check_req(call
, bp
);
2143 afs_use_fs_server(call
, fc
->cbi
);
2144 trace_afs_make_fs_call(call
, &vnode
->fid
);
2145 afs_make_call(&fc
->ac
, call
, GFP_KERNEL
);
2146 return (struct yfs_acl
*)afs_wait_for_call_to_complete(call
, &fc
->ac
);
2150 * YFS.StoreOpaqueACL2 operation type
2152 static const struct afs_call_type yfs_RXYFSStoreOpaqueACL2
= {
2153 .name
= "YFS.StoreOpaqueACL2",
2154 .op
= yfs_FS_StoreOpaqueACL2
,
2155 .deliver
= yfs_deliver_status_and_volsync
,
2156 .destructor
= afs_flat_call_destructor
,
2160 * Fetch the YFS ACL for a file.
2162 int yfs_fs_store_opaque_acl2(struct afs_fs_cursor
*fc
, const struct afs_acl
*acl
,
2163 struct afs_status_cb
*scb
)
2165 struct afs_vnode
*vnode
= fc
->vnode
;
2166 struct afs_call
*call
;
2167 struct afs_net
*net
= afs_v2net(vnode
);
2171 _enter(",%x,{%llx:%llu},,",
2172 key_serial(fc
->key
), vnode
->fid
.vid
, vnode
->fid
.vnode
);
2174 size
= round_up(acl
->size
, 4);
2175 call
= afs_alloc_flat_call(net
, &yfs_RXYFSStoreOpaqueACL2
,
2176 sizeof(__be32
) * 2 +
2177 sizeof(struct yfs_xdr_YFSFid
) +
2178 sizeof(__be32
) + size
,
2179 sizeof(struct yfs_xdr_YFSFetchStatus
) +
2180 sizeof(struct yfs_xdr_YFSVolSync
));
2182 fc
->ac
.error
= -ENOMEM
;
2186 call
->key
= fc
->key
;
2187 call
->out_scb
= scb
;
2188 call
->out_volsync
= NULL
;
2190 /* marshall the parameters */
2192 bp
= xdr_encode_u32(bp
, YFSSTOREOPAQUEACL2
);
2193 bp
= xdr_encode_u32(bp
, 0); /* RPC flags */
2194 bp
= xdr_encode_YFSFid(bp
, &vnode
->fid
);
2195 bp
= xdr_encode_u32(bp
, acl
->size
);
2196 memcpy(bp
, acl
->data
, acl
->size
);
2197 if (acl
->size
!= size
)
2198 memset((void *)bp
+ acl
->size
, 0, size
- acl
->size
);
2199 yfs_check_req(call
, bp
);
2201 trace_afs_make_fs_call(call
, &vnode
->fid
);
2202 afs_make_call(&fc
->ac
, call
, GFP_KERNEL
);
2203 return afs_wait_for_call_to_complete(call
, &fc
->ac
);