1 /* AFS File Server client stubs
3 * Copyright (C) 2002, 2007 Red Hat, Inc. All Rights Reserved.
4 * Written by David Howells (dhowells@redhat.com)
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
12 #include <linux/init.h>
13 #include <linux/sched.h>
14 #include <linux/circ_buf.h>
19 * decode an AFSFid block
21 static void xdr_decode_AFSFid(const __be32 **_bp, struct afs_fid *fid)
23 const __be32 *bp = *_bp;
25 fid->vid = ntohl(*bp++);
26 fid->vnode = ntohl(*bp++);
27 fid->unique = ntohl(*bp++);
32 * decode an AFSFetchStatus block
34 static void xdr_decode_AFSFetchStatus(const __be32 **_bp,
35 struct afs_file_status *status,
36 struct afs_vnode *vnode)
38 const __be32 *bp = *_bp;
40 u64 data_version, size;
41 u32 changed = 0; /* becomes non-zero if ctime-type changes seen */
43 #define EXTRACT(DST) \
45 u32 x = ntohl(*bp++); \
50 status->if_version = ntohl(*bp++);
51 EXTRACT(status->type);
52 EXTRACT(status->nlink);
54 data_version = ntohl(*bp++);
55 EXTRACT(status->author);
56 EXTRACT(status->owner);
57 EXTRACT(status->caller_access); /* call ticket dependent */
58 EXTRACT(status->anon_access);
59 EXTRACT(status->mode);
60 EXTRACT(status->parent.vnode);
61 EXTRACT(status->parent.unique);
63 status->mtime_client = ntohl(*bp++);
64 status->mtime_server = ntohl(*bp++);
65 EXTRACT(status->group);
66 bp++; /* sync counter */
67 data_version |= (u64) ntohl(*bp++) << 32;
68 bp++; /* lock count */
69 size |= (u64) ntohl(*bp++) << 32;
73 if (size != status->size) {
77 status->mode &= S_IALLUGO;
79 _debug("vnode time %lx, %lx",
80 status->mtime_client, status->mtime_server);
83 status->parent.vid = vnode->fid.vid;
84 if (changed && !test_bit(AFS_VNODE_UNSET, &vnode->flags)) {
85 _debug("vnode changed");
86 i_size_write(&vnode->vfs_inode, size);
87 vnode->vfs_inode.i_uid = status->owner;
88 vnode->vfs_inode.i_gid = status->group;
89 vnode->vfs_inode.i_version = vnode->fid.unique;
90 vnode->vfs_inode.i_nlink = status->nlink;
92 mode = vnode->vfs_inode.i_mode;
96 vnode->vfs_inode.i_mode = mode;
99 vnode->vfs_inode.i_ctime.tv_sec = status->mtime_server;
100 vnode->vfs_inode.i_mtime = vnode->vfs_inode.i_ctime;
101 vnode->vfs_inode.i_atime = vnode->vfs_inode.i_ctime;
104 if (status->data_version != data_version) {
105 status->data_version = data_version;
106 if (vnode && !test_bit(AFS_VNODE_UNSET, &vnode->flags)) {
107 _debug("vnode modified %llx on {%x:%u}",
108 (unsigned long long) data_version,
109 vnode->fid.vid, vnode->fid.vnode);
110 set_bit(AFS_VNODE_MODIFIED, &vnode->flags);
111 set_bit(AFS_VNODE_ZAP_DATA, &vnode->flags);
117 * decode an AFSCallBack block
119 static void xdr_decode_AFSCallBack(const __be32 **_bp, struct afs_vnode *vnode)
121 const __be32 *bp = *_bp;
123 vnode->cb_version = ntohl(*bp++);
124 vnode->cb_expiry = ntohl(*bp++);
125 vnode->cb_type = ntohl(*bp++);
126 vnode->cb_expires = vnode->cb_expiry + get_seconds();
130 static void xdr_decode_AFSCallBack_raw(const __be32 **_bp,
131 struct afs_callback *cb)
133 const __be32 *bp = *_bp;
135 cb->version = ntohl(*bp++);
136 cb->expiry = ntohl(*bp++);
137 cb->type = ntohl(*bp++);
142 * decode an AFSVolSync block
144 static void xdr_decode_AFSVolSync(const __be32 **_bp,
145 struct afs_volsync *volsync)
147 const __be32 *bp = *_bp;
149 volsync->creation = ntohl(*bp++);
159 * deliver reply data to an FS.FetchStatus
161 static int afs_deliver_fs_fetch_status(struct afs_call *call,
162 struct sk_buff *skb, bool last)
164 struct afs_vnode *vnode = call->reply;
167 _enter(",,%u", last);
169 afs_transfer_reply(call, skb);
173 if (call->reply_size != call->reply_max)
176 /* unmarshall the reply once we've received all of it */
178 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode);
179 xdr_decode_AFSCallBack(&bp, vnode);
181 xdr_decode_AFSVolSync(&bp, call->reply2);
183 _leave(" = 0 [done]");
188 * FS.FetchStatus operation type
190 static const struct afs_call_type afs_RXFSFetchStatus = {
191 .name = "FS.FetchStatus",
192 .deliver = afs_deliver_fs_fetch_status,
193 .abort_to_error = afs_abort_to_error,
194 .destructor = afs_flat_call_destructor,
198 * fetch the status information for a file
200 int afs_fs_fetch_file_status(struct afs_server *server,
202 struct afs_vnode *vnode,
203 struct afs_volsync *volsync,
204 const struct afs_wait_mode *wait_mode)
206 struct afs_call *call;
209 _enter(",%x,{%x:%u},,",
210 key_serial(key), vnode->fid.vid, vnode->fid.vnode);
212 call = afs_alloc_flat_call(&afs_RXFSFetchStatus, 16, (21 + 3 + 6) * 4);
218 call->reply2 = volsync;
219 call->service_id = FS_SERVICE;
220 call->port = htons(AFS_FS_PORT);
222 /* marshall the parameters */
224 bp[0] = htonl(FSFETCHSTATUS);
225 bp[1] = htonl(vnode->fid.vid);
226 bp[2] = htonl(vnode->fid.vnode);
227 bp[3] = htonl(vnode->fid.unique);
229 return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
233 * deliver reply data to an FS.FetchData
235 static int afs_deliver_fs_fetch_data(struct afs_call *call,
236 struct sk_buff *skb, bool last)
238 struct afs_vnode *vnode = call->reply;
244 _enter("{%u},{%u},%d", call->unmarshall, skb->len, last);
246 switch (call->unmarshall) {
251 /* extract the returned data length */
253 _debug("extract data length");
254 ret = afs_extract_data(call, skb, last, &call->tmp, 4);
257 case -EAGAIN: return 0;
261 call->count = ntohl(call->tmp);
262 _debug("DATA length: %u", call->count);
263 if (call->count > PAGE_SIZE)
268 /* extract the returned data */
270 _debug("extract data");
271 if (call->count > 0) {
273 buffer = kmap_atomic(page, KM_USER0);
274 ret = afs_extract_data(call, skb, last, buffer,
276 kunmap_atomic(buffer, KM_USER0);
279 case -EAGAIN: return 0;
287 /* extract the metadata */
289 ret = afs_extract_data(call, skb, last, call->buffer,
293 case -EAGAIN: return 0;
298 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode);
299 xdr_decode_AFSCallBack(&bp, vnode);
301 xdr_decode_AFSVolSync(&bp, call->reply2);
316 if (call->count < PAGE_SIZE) {
319 buffer = kmap_atomic(page, KM_USER0);
320 memset(buffer + call->count, 0, PAGE_SIZE - call->count);
321 kunmap_atomic(buffer, KM_USER0);
324 _leave(" = 0 [done]");
329 * FS.FetchData operation type
331 static const struct afs_call_type afs_RXFSFetchData = {
332 .name = "FS.FetchData",
333 .deliver = afs_deliver_fs_fetch_data,
334 .abort_to_error = afs_abort_to_error,
335 .destructor = afs_flat_call_destructor,
339 * fetch data from a file
341 int afs_fs_fetch_data(struct afs_server *server,
343 struct afs_vnode *vnode,
344 off_t offset, size_t length,
346 const struct afs_wait_mode *wait_mode)
348 struct afs_call *call;
353 call = afs_alloc_flat_call(&afs_RXFSFetchData, 24, (21 + 3 + 6) * 4);
359 call->reply2 = NULL; /* volsync */
360 call->reply3 = buffer;
361 call->service_id = FS_SERVICE;
362 call->port = htons(AFS_FS_PORT);
364 /* marshall the parameters */
366 bp[0] = htonl(FSFETCHDATA);
367 bp[1] = htonl(vnode->fid.vid);
368 bp[2] = htonl(vnode->fid.vnode);
369 bp[3] = htonl(vnode->fid.unique);
370 bp[4] = htonl(offset);
371 bp[5] = htonl(length);
373 return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
377 * deliver reply data to an FS.GiveUpCallBacks
379 static int afs_deliver_fs_give_up_callbacks(struct afs_call *call,
380 struct sk_buff *skb, bool last)
382 _enter(",{%u},%d", skb->len, last);
385 return -EBADMSG; /* shouldn't be any reply data */
390 * FS.GiveUpCallBacks operation type
392 static const struct afs_call_type afs_RXFSGiveUpCallBacks = {
393 .name = "FS.GiveUpCallBacks",
394 .deliver = afs_deliver_fs_give_up_callbacks,
395 .abort_to_error = afs_abort_to_error,
396 .destructor = afs_flat_call_destructor,
400 * give up a set of callbacks
401 * - the callbacks are held in the server->cb_break ring
403 int afs_fs_give_up_callbacks(struct afs_server *server,
404 const struct afs_wait_mode *wait_mode)
406 struct afs_call *call;
411 ncallbacks = CIRC_CNT(server->cb_break_head, server->cb_break_tail,
412 ARRAY_SIZE(server->cb_break));
414 _enter("{%zu},", ncallbacks);
418 if (ncallbacks > AFSCBMAX)
419 ncallbacks = AFSCBMAX;
421 _debug("break %zu callbacks", ncallbacks);
423 call = afs_alloc_flat_call(&afs_RXFSGiveUpCallBacks,
424 12 + ncallbacks * 6 * 4, 0);
428 call->service_id = FS_SERVICE;
429 call->port = htons(AFS_FS_PORT);
431 /* marshall the parameters */
433 tp = bp + 2 + ncallbacks * 3;
434 *bp++ = htonl(FSGIVEUPCALLBACKS);
435 *bp++ = htonl(ncallbacks);
436 *tp++ = htonl(ncallbacks);
438 atomic_sub(ncallbacks, &server->cb_break_n);
439 for (loop = ncallbacks; loop > 0; loop--) {
440 struct afs_callback *cb =
441 &server->cb_break[server->cb_break_tail];
443 *bp++ = htonl(cb->fid.vid);
444 *bp++ = htonl(cb->fid.vnode);
445 *bp++ = htonl(cb->fid.unique);
446 *tp++ = htonl(cb->version);
447 *tp++ = htonl(cb->expiry);
448 *tp++ = htonl(cb->type);
450 server->cb_break_tail =
451 (server->cb_break_tail + 1) &
452 (ARRAY_SIZE(server->cb_break) - 1);
455 ASSERT(ncallbacks > 0);
456 wake_up_nr(&server->cb_break_waitq, ncallbacks);
458 return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
462 * deliver reply data to an FS.CreateFile or an FS.MakeDir
464 static int afs_deliver_fs_create_vnode(struct afs_call *call,
465 struct sk_buff *skb, bool last)
467 struct afs_vnode *vnode = call->reply;
470 _enter("{%u},{%u},%d", call->unmarshall, skb->len, last);
472 afs_transfer_reply(call, skb);
476 if (call->reply_size != call->reply_max)
479 /* unmarshall the reply once we've received all of it */
481 xdr_decode_AFSFid(&bp, call->reply2);
482 xdr_decode_AFSFetchStatus(&bp, call->reply3, NULL);
483 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode);
484 xdr_decode_AFSCallBack_raw(&bp, call->reply4);
485 /* xdr_decode_AFSVolSync(&bp, call->replyX); */
487 _leave(" = 0 [done]");
492 * FS.CreateFile and FS.MakeDir operation type
494 static const struct afs_call_type afs_RXFSCreateXXXX = {
495 .name = "FS.CreateXXXX",
496 .deliver = afs_deliver_fs_create_vnode,
497 .abort_to_error = afs_abort_to_error,
498 .destructor = afs_flat_call_destructor,
502 * create a file or make a directory
504 int afs_fs_create(struct afs_server *server,
506 struct afs_vnode *vnode,
509 struct afs_fid *newfid,
510 struct afs_file_status *newstatus,
511 struct afs_callback *newcb,
512 const struct afs_wait_mode *wait_mode)
514 struct afs_call *call;
515 size_t namesz, reqsz, padsz;
520 namesz = strlen(name);
521 padsz = (4 - (namesz & 3)) & 3;
522 reqsz = (5 * 4) + namesz + padsz + (6 * 4);
524 call = afs_alloc_flat_call(&afs_RXFSCreateXXXX, reqsz,
525 (3 + 21 + 21 + 3 + 6) * 4);
531 call->reply2 = newfid;
532 call->reply3 = newstatus;
533 call->reply4 = newcb;
534 call->service_id = FS_SERVICE;
535 call->port = htons(AFS_FS_PORT);
537 /* marshall the parameters */
539 *bp++ = htonl(S_ISDIR(mode) ? FSMAKEDIR : FSCREATEFILE);
540 *bp++ = htonl(vnode->fid.vid);
541 *bp++ = htonl(vnode->fid.vnode);
542 *bp++ = htonl(vnode->fid.unique);
543 *bp++ = htonl(namesz);
544 memcpy(bp, name, namesz);
545 bp = (void *) bp + namesz;
547 memset(bp, 0, padsz);
548 bp = (void *) bp + padsz;
550 *bp++ = htonl(AFS_SET_MODE);
551 *bp++ = 0; /* mtime */
552 *bp++ = 0; /* owner */
553 *bp++ = 0; /* group */
554 *bp++ = htonl(mode & S_IALLUGO); /* unix mode */
555 *bp++ = 0; /* segment size */
557 return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
561 * deliver reply data to an FS.RemoveFile or FS.RemoveDir
563 static int afs_deliver_fs_remove(struct afs_call *call,
564 struct sk_buff *skb, bool last)
566 struct afs_vnode *vnode = call->reply;
569 _enter("{%u},{%u},%d", call->unmarshall, skb->len, last);
571 afs_transfer_reply(call, skb);
575 if (call->reply_size != call->reply_max)
578 /* unmarshall the reply once we've received all of it */
580 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode);
581 /* xdr_decode_AFSVolSync(&bp, call->replyX); */
583 _leave(" = 0 [done]");
588 * FS.RemoveDir/FS.RemoveFile operation type
590 static const struct afs_call_type afs_RXFSRemoveXXXX = {
591 .name = "FS.RemoveXXXX",
592 .deliver = afs_deliver_fs_remove,
593 .abort_to_error = afs_abort_to_error,
594 .destructor = afs_flat_call_destructor,
598 * remove a file or directory
600 int afs_fs_remove(struct afs_server *server,
602 struct afs_vnode *vnode,
605 const struct afs_wait_mode *wait_mode)
607 struct afs_call *call;
608 size_t namesz, reqsz, padsz;
613 namesz = strlen(name);
614 padsz = (4 - (namesz & 3)) & 3;
615 reqsz = (5 * 4) + namesz + padsz;
617 call = afs_alloc_flat_call(&afs_RXFSRemoveXXXX, reqsz, (21 + 6) * 4);
623 call->service_id = FS_SERVICE;
624 call->port = htons(AFS_FS_PORT);
626 /* marshall the parameters */
628 *bp++ = htonl(isdir ? FSREMOVEDIR : FSREMOVEFILE);
629 *bp++ = htonl(vnode->fid.vid);
630 *bp++ = htonl(vnode->fid.vnode);
631 *bp++ = htonl(vnode->fid.unique);
632 *bp++ = htonl(namesz);
633 memcpy(bp, name, namesz);
634 bp = (void *) bp + namesz;
636 memset(bp, 0, padsz);
637 bp = (void *) bp + padsz;
640 return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
644 * deliver reply data to an FS.Link
646 static int afs_deliver_fs_link(struct afs_call *call,
647 struct sk_buff *skb, bool last)
649 struct afs_vnode *dvnode = call->reply, *vnode = call->reply2;
652 _enter("{%u},{%u},%d", call->unmarshall, skb->len, last);
654 afs_transfer_reply(call, skb);
658 if (call->reply_size != call->reply_max)
661 /* unmarshall the reply once we've received all of it */
663 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode);
664 xdr_decode_AFSFetchStatus(&bp, &dvnode->status, dvnode);
665 /* xdr_decode_AFSVolSync(&bp, call->replyX); */
667 _leave(" = 0 [done]");
672 * FS.Link operation type
674 static const struct afs_call_type afs_RXFSLink = {
676 .deliver = afs_deliver_fs_link,
677 .abort_to_error = afs_abort_to_error,
678 .destructor = afs_flat_call_destructor,
684 int afs_fs_link(struct afs_server *server,
686 struct afs_vnode *dvnode,
687 struct afs_vnode *vnode,
689 const struct afs_wait_mode *wait_mode)
691 struct afs_call *call;
692 size_t namesz, reqsz, padsz;
697 namesz = strlen(name);
698 padsz = (4 - (namesz & 3)) & 3;
699 reqsz = (5 * 4) + namesz + padsz + (3 * 4);
701 call = afs_alloc_flat_call(&afs_RXFSLink, reqsz, (21 + 21 + 6) * 4);
706 call->reply = dvnode;
707 call->reply2 = vnode;
708 call->service_id = FS_SERVICE;
709 call->port = htons(AFS_FS_PORT);
711 /* marshall the parameters */
713 *bp++ = htonl(FSLINK);
714 *bp++ = htonl(dvnode->fid.vid);
715 *bp++ = htonl(dvnode->fid.vnode);
716 *bp++ = htonl(dvnode->fid.unique);
717 *bp++ = htonl(namesz);
718 memcpy(bp, name, namesz);
719 bp = (void *) bp + namesz;
721 memset(bp, 0, padsz);
722 bp = (void *) bp + padsz;
724 *bp++ = htonl(vnode->fid.vid);
725 *bp++ = htonl(vnode->fid.vnode);
726 *bp++ = htonl(vnode->fid.unique);
728 return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
732 * deliver reply data to an FS.Symlink
734 static int afs_deliver_fs_symlink(struct afs_call *call,
735 struct sk_buff *skb, bool last)
737 struct afs_vnode *vnode = call->reply;
740 _enter("{%u},{%u},%d", call->unmarshall, skb->len, last);
742 afs_transfer_reply(call, skb);
746 if (call->reply_size != call->reply_max)
749 /* unmarshall the reply once we've received all of it */
751 xdr_decode_AFSFid(&bp, call->reply2);
752 xdr_decode_AFSFetchStatus(&bp, call->reply3, NULL);
753 xdr_decode_AFSFetchStatus(&bp, &vnode->status, vnode);
754 /* xdr_decode_AFSVolSync(&bp, call->replyX); */
756 _leave(" = 0 [done]");
761 * FS.Symlink operation type
763 static const struct afs_call_type afs_RXFSSymlink = {
764 .name = "FS.Symlink",
765 .deliver = afs_deliver_fs_symlink,
766 .abort_to_error = afs_abort_to_error,
767 .destructor = afs_flat_call_destructor,
771 * create a symbolic link
773 int afs_fs_symlink(struct afs_server *server,
775 struct afs_vnode *vnode,
777 const char *contents,
778 struct afs_fid *newfid,
779 struct afs_file_status *newstatus,
780 const struct afs_wait_mode *wait_mode)
782 struct afs_call *call;
783 size_t namesz, reqsz, padsz, c_namesz, c_padsz;
788 namesz = strlen(name);
789 padsz = (4 - (namesz & 3)) & 3;
791 c_namesz = strlen(contents);
792 c_padsz = (4 - (c_namesz & 3)) & 3;
794 reqsz = (6 * 4) + namesz + padsz + c_namesz + c_padsz + (6 * 4);
796 call = afs_alloc_flat_call(&afs_RXFSSymlink, reqsz,
797 (3 + 21 + 21 + 6) * 4);
803 call->reply2 = newfid;
804 call->reply3 = newstatus;
805 call->service_id = FS_SERVICE;
806 call->port = htons(AFS_FS_PORT);
808 /* marshall the parameters */
810 *bp++ = htonl(FSSYMLINK);
811 *bp++ = htonl(vnode->fid.vid);
812 *bp++ = htonl(vnode->fid.vnode);
813 *bp++ = htonl(vnode->fid.unique);
814 *bp++ = htonl(namesz);
815 memcpy(bp, name, namesz);
816 bp = (void *) bp + namesz;
818 memset(bp, 0, padsz);
819 bp = (void *) bp + padsz;
821 *bp++ = htonl(c_namesz);
822 memcpy(bp, contents, c_namesz);
823 bp = (void *) bp + c_namesz;
825 memset(bp, 0, c_padsz);
826 bp = (void *) bp + c_padsz;
828 *bp++ = htonl(AFS_SET_MODE);
829 *bp++ = 0; /* mtime */
830 *bp++ = 0; /* owner */
831 *bp++ = 0; /* group */
832 *bp++ = htonl(S_IRWXUGO); /* unix mode */
833 *bp++ = 0; /* segment size */
835 return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);
839 * deliver reply data to an FS.Rename
841 static int afs_deliver_fs_rename(struct afs_call *call,
842 struct sk_buff *skb, bool last)
844 struct afs_vnode *orig_dvnode = call->reply, *new_dvnode = call->reply2;
847 _enter("{%u},{%u},%d", call->unmarshall, skb->len, last);
849 afs_transfer_reply(call, skb);
853 if (call->reply_size != call->reply_max)
856 /* unmarshall the reply once we've received all of it */
858 xdr_decode_AFSFetchStatus(&bp, &orig_dvnode->status, orig_dvnode);
859 if (new_dvnode != orig_dvnode)
860 xdr_decode_AFSFetchStatus(&bp, &new_dvnode->status, new_dvnode);
861 /* xdr_decode_AFSVolSync(&bp, call->replyX); */
863 _leave(" = 0 [done]");
868 * FS.Rename operation type
870 static const struct afs_call_type afs_RXFSRename = {
872 .deliver = afs_deliver_fs_rename,
873 .abort_to_error = afs_abort_to_error,
874 .destructor = afs_flat_call_destructor,
878 * create a symbolic link
880 int afs_fs_rename(struct afs_server *server,
882 struct afs_vnode *orig_dvnode,
883 const char *orig_name,
884 struct afs_vnode *new_dvnode,
885 const char *new_name,
886 const struct afs_wait_mode *wait_mode)
888 struct afs_call *call;
889 size_t reqsz, o_namesz, o_padsz, n_namesz, n_padsz;
894 o_namesz = strlen(orig_name);
895 o_padsz = (4 - (o_namesz & 3)) & 3;
897 n_namesz = strlen(new_name);
898 n_padsz = (4 - (n_namesz & 3)) & 3;
901 4 + o_namesz + o_padsz +
903 4 + n_namesz + n_padsz;
905 call = afs_alloc_flat_call(&afs_RXFSRename, reqsz, (21 + 21 + 6) * 4);
910 call->reply = orig_dvnode;
911 call->reply2 = new_dvnode;
912 call->service_id = FS_SERVICE;
913 call->port = htons(AFS_FS_PORT);
915 /* marshall the parameters */
917 *bp++ = htonl(FSRENAME);
918 *bp++ = htonl(orig_dvnode->fid.vid);
919 *bp++ = htonl(orig_dvnode->fid.vnode);
920 *bp++ = htonl(orig_dvnode->fid.unique);
921 *bp++ = htonl(o_namesz);
922 memcpy(bp, orig_name, o_namesz);
923 bp = (void *) bp + o_namesz;
925 memset(bp, 0, o_padsz);
926 bp = (void *) bp + o_padsz;
929 *bp++ = htonl(new_dvnode->fid.vid);
930 *bp++ = htonl(new_dvnode->fid.vnode);
931 *bp++ = htonl(new_dvnode->fid.unique);
932 *bp++ = htonl(n_namesz);
933 memcpy(bp, new_name, n_namesz);
934 bp = (void *) bp + n_namesz;
936 memset(bp, 0, n_padsz);
937 bp = (void *) bp + n_padsz;
940 return afs_make_call(&server->addr, call, GFP_NOFS, wait_mode);