4 * Copyright (C) 1992, 1993, 1994 Rick Sladkey
6 * OS-independent nfs remote procedure call functions
8 * Tuned by Alan Cox <A.Cox@swansea.ac.uk> for >3K buffers
9 * so at last we can have decent(ish) throughput off a
12 * Coding optimized and cleaned up by Florian La Roche.
13 * Note: Error returns are optimized for NFS_OK, which isn't translated via
14 * nfs_stat_to_errno(), but happens to be already the right return code.
16 * Also, the code currently doesn't check the size of the packet, when
17 * it decodes the packet.
19 * Feel free to fix it and mail me the diffs if it worries you.
21 * Completely rewritten to support the new RPC call interface;
22 * rewrote and moved the entire XDR stuff to xdr.c
23 * --Olaf Kirch June 1996
25 * The code below initializes all auto variables explicitly, otherwise
26 * it will fail to work as a module (gcc generates a memset call for an
30 #include <linux/types.h>
31 #include <linux/param.h>
32 #include <linux/time.h>
34 #include <linux/errno.h>
35 #include <linux/string.h>
37 #include <linux/pagemap.h>
38 #include <linux/sunrpc/clnt.h>
39 #include <linux/nfs.h>
40 #include <linux/nfs2.h>
41 #include <linux/nfs_fs.h>
42 #include <linux/nfs_page.h>
43 #include <linux/lockd/bind.h>
44 #include <linux/freezer.h>
47 #define NFSDBG_FACILITY NFSDBG_PROC
50 * Bare-bones access to getattr: this is for nfs_read_super.
53 nfs_proc_get_root(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
54 struct nfs_fsinfo
*info
)
56 struct nfs_fattr
*fattr
= info
->fattr
;
57 struct nfs2_fsstat fsinfo
;
58 struct rpc_message msg
= {
59 .rpc_proc
= &nfs_procedures
[NFSPROC_GETATTR
],
65 dprintk("%s: call getattr\n", __func__
);
66 nfs_fattr_init(fattr
);
67 status
= rpc_call_sync(server
->client
, &msg
, 0);
68 /* Retry with default authentication if different */
69 if (status
&& server
->nfs_client
->cl_rpcclient
!= server
->client
)
70 status
= rpc_call_sync(server
->nfs_client
->cl_rpcclient
, &msg
, 0);
71 dprintk("%s: reply getattr: %d\n", __func__
, status
);
74 dprintk("%s: call statfs\n", __func__
);
75 msg
.rpc_proc
= &nfs_procedures
[NFSPROC_STATFS
];
76 msg
.rpc_resp
= &fsinfo
;
77 status
= rpc_call_sync(server
->client
, &msg
, 0);
78 /* Retry with default authentication if different */
79 if (status
&& server
->nfs_client
->cl_rpcclient
!= server
->client
)
80 status
= rpc_call_sync(server
->nfs_client
->cl_rpcclient
, &msg
, 0);
81 dprintk("%s: reply statfs: %d\n", __func__
, status
);
84 info
->rtmax
= NFS_MAXDATA
;
85 info
->rtpref
= fsinfo
.tsize
;
86 info
->rtmult
= fsinfo
.bsize
;
87 info
->wtmax
= NFS_MAXDATA
;
88 info
->wtpref
= fsinfo
.tsize
;
89 info
->wtmult
= fsinfo
.bsize
;
90 info
->dtpref
= fsinfo
.tsize
;
91 info
->maxfilesize
= 0x7FFFFFFF;
97 * One function for each procedure in the NFS protocol.
100 nfs_proc_getattr(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
101 struct nfs_fattr
*fattr
)
103 struct rpc_message msg
= {
104 .rpc_proc
= &nfs_procedures
[NFSPROC_GETATTR
],
110 dprintk("NFS call getattr\n");
111 nfs_fattr_init(fattr
);
112 status
= rpc_call_sync(server
->client
, &msg
, 0);
113 dprintk("NFS reply getattr: %d\n", status
);
118 nfs_proc_setattr(struct dentry
*dentry
, struct nfs_fattr
*fattr
,
121 struct inode
*inode
= dentry
->d_inode
;
122 struct nfs_sattrargs arg
= {
126 struct rpc_message msg
= {
127 .rpc_proc
= &nfs_procedures
[NFSPROC_SETATTR
],
133 /* Mask out the non-modebit related stuff from attr->ia_mode */
134 sattr
->ia_mode
&= S_IALLUGO
;
136 dprintk("NFS call setattr\n");
137 if (sattr
->ia_valid
& ATTR_FILE
)
138 msg
.rpc_cred
= nfs_file_cred(sattr
->ia_file
);
139 nfs_fattr_init(fattr
);
140 status
= rpc_call_sync(NFS_CLIENT(inode
), &msg
, 0);
142 nfs_setattr_update_inode(inode
, sattr
);
143 dprintk("NFS reply setattr: %d\n", status
);
148 nfs_proc_lookup(struct inode
*dir
, struct qstr
*name
,
149 struct nfs_fh
*fhandle
, struct nfs_fattr
*fattr
)
151 struct nfs_diropargs arg
= {
156 struct nfs_diropok res
= {
160 struct rpc_message msg
= {
161 .rpc_proc
= &nfs_procedures
[NFSPROC_LOOKUP
],
167 dprintk("NFS call lookup %s\n", name
->name
);
168 nfs_fattr_init(fattr
);
169 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
170 dprintk("NFS reply lookup: %d\n", status
);
174 static int nfs_proc_readlink(struct inode
*inode
, struct page
*page
,
175 unsigned int pgbase
, unsigned int pglen
)
177 struct nfs_readlinkargs args
= {
183 struct rpc_message msg
= {
184 .rpc_proc
= &nfs_procedures
[NFSPROC_READLINK
],
189 dprintk("NFS call readlink\n");
190 status
= rpc_call_sync(NFS_CLIENT(inode
), &msg
, 0);
191 dprintk("NFS reply readlink: %d\n", status
);
195 struct nfs_createdata
{
196 struct nfs_createargs arg
;
197 struct nfs_diropok res
;
198 struct nfs_fh fhandle
;
199 struct nfs_fattr fattr
;
202 static struct nfs_createdata
*nfs_alloc_createdata(struct inode
*dir
,
203 struct dentry
*dentry
, struct iattr
*sattr
)
205 struct nfs_createdata
*data
;
207 data
= kmalloc(sizeof(*data
), GFP_KERNEL
);
210 data
->arg
.fh
= NFS_FH(dir
);
211 data
->arg
.name
= dentry
->d_name
.name
;
212 data
->arg
.len
= dentry
->d_name
.len
;
213 data
->arg
.sattr
= sattr
;
214 nfs_fattr_init(&data
->fattr
);
215 data
->fhandle
.size
= 0;
216 data
->res
.fh
= &data
->fhandle
;
217 data
->res
.fattr
= &data
->fattr
;
222 static void nfs_free_createdata(const struct nfs_createdata
*data
)
228 nfs_proc_create(struct inode
*dir
, struct dentry
*dentry
, struct iattr
*sattr
,
231 struct nfs_createdata
*data
;
232 struct rpc_message msg
= {
233 .rpc_proc
= &nfs_procedures
[NFSPROC_CREATE
],
235 int status
= -ENOMEM
;
237 dprintk("NFS call create %s\n", dentry
->d_name
.name
);
238 data
= nfs_alloc_createdata(dir
, dentry
, sattr
);
241 msg
.rpc_argp
= &data
->arg
;
242 msg
.rpc_resp
= &data
->res
;
243 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
244 nfs_mark_for_revalidate(dir
);
246 status
= nfs_instantiate(dentry
, data
->res
.fh
, data
->res
.fattr
);
247 nfs_free_createdata(data
);
249 dprintk("NFS reply create: %d\n", status
);
254 * In NFSv2, mknod is grafted onto the create call.
257 nfs_proc_mknod(struct inode
*dir
, struct dentry
*dentry
, struct iattr
*sattr
,
260 struct nfs_createdata
*data
;
261 struct rpc_message msg
= {
262 .rpc_proc
= &nfs_procedures
[NFSPROC_CREATE
],
265 int status
= -ENOMEM
;
267 dprintk("NFS call mknod %s\n", dentry
->d_name
.name
);
269 mode
= sattr
->ia_mode
;
270 if (S_ISFIFO(mode
)) {
271 sattr
->ia_mode
= (mode
& ~S_IFMT
) | S_IFCHR
;
272 sattr
->ia_valid
&= ~ATTR_SIZE
;
273 } else if (S_ISCHR(mode
) || S_ISBLK(mode
)) {
274 sattr
->ia_valid
|= ATTR_SIZE
;
275 sattr
->ia_size
= new_encode_dev(rdev
);/* get out your barf bag */
278 data
= nfs_alloc_createdata(dir
, dentry
, sattr
);
281 msg
.rpc_argp
= &data
->arg
;
282 msg
.rpc_resp
= &data
->res
;
284 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
285 nfs_mark_for_revalidate(dir
);
287 if (status
== -EINVAL
&& S_ISFIFO(mode
)) {
288 sattr
->ia_mode
= mode
;
289 nfs_fattr_init(data
->res
.fattr
);
290 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
293 status
= nfs_instantiate(dentry
, data
->res
.fh
, data
->res
.fattr
);
294 nfs_free_createdata(data
);
296 dprintk("NFS reply mknod: %d\n", status
);
301 nfs_proc_remove(struct inode
*dir
, struct qstr
*name
)
303 struct nfs_removeargs arg
= {
307 struct rpc_message msg
= {
308 .rpc_proc
= &nfs_procedures
[NFSPROC_REMOVE
],
313 dprintk("NFS call remove %s\n", name
->name
);
314 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
315 nfs_mark_for_revalidate(dir
);
317 dprintk("NFS reply remove: %d\n", status
);
322 nfs_proc_unlink_setup(struct rpc_message
*msg
, struct inode
*dir
)
324 msg
->rpc_proc
= &nfs_procedures
[NFSPROC_REMOVE
];
327 static void nfs_proc_unlink_rpc_prepare(struct rpc_task
*task
, struct nfs_unlinkdata
*data
)
329 rpc_call_start(task
);
332 static int nfs_proc_unlink_done(struct rpc_task
*task
, struct inode
*dir
)
334 nfs_mark_for_revalidate(dir
);
339 nfs_proc_rename_setup(struct rpc_message
*msg
, struct inode
*dir
)
341 msg
->rpc_proc
= &nfs_procedures
[NFSPROC_RENAME
];
344 static void nfs_proc_rename_rpc_prepare(struct rpc_task
*task
, struct nfs_renamedata
*data
)
346 rpc_call_start(task
);
350 nfs_proc_rename_done(struct rpc_task
*task
, struct inode
*old_dir
,
351 struct inode
*new_dir
)
353 nfs_mark_for_revalidate(old_dir
);
354 nfs_mark_for_revalidate(new_dir
);
359 nfs_proc_rename(struct inode
*old_dir
, struct qstr
*old_name
,
360 struct inode
*new_dir
, struct qstr
*new_name
)
362 struct nfs_renameargs arg
= {
363 .old_dir
= NFS_FH(old_dir
),
364 .old_name
= old_name
,
365 .new_dir
= NFS_FH(new_dir
),
366 .new_name
= new_name
,
368 struct rpc_message msg
= {
369 .rpc_proc
= &nfs_procedures
[NFSPROC_RENAME
],
374 dprintk("NFS call rename %s -> %s\n", old_name
->name
, new_name
->name
);
375 status
= rpc_call_sync(NFS_CLIENT(old_dir
), &msg
, 0);
376 nfs_mark_for_revalidate(old_dir
);
377 nfs_mark_for_revalidate(new_dir
);
378 dprintk("NFS reply rename: %d\n", status
);
383 nfs_proc_link(struct inode
*inode
, struct inode
*dir
, struct qstr
*name
)
385 struct nfs_linkargs arg
= {
386 .fromfh
= NFS_FH(inode
),
388 .toname
= name
->name
,
391 struct rpc_message msg
= {
392 .rpc_proc
= &nfs_procedures
[NFSPROC_LINK
],
397 dprintk("NFS call link %s\n", name
->name
);
398 status
= rpc_call_sync(NFS_CLIENT(inode
), &msg
, 0);
399 nfs_mark_for_revalidate(inode
);
400 nfs_mark_for_revalidate(dir
);
401 dprintk("NFS reply link: %d\n", status
);
406 nfs_proc_symlink(struct inode
*dir
, struct dentry
*dentry
, struct page
*page
,
407 unsigned int len
, struct iattr
*sattr
)
410 struct nfs_fattr
*fattr
;
411 struct nfs_symlinkargs arg
= {
412 .fromfh
= NFS_FH(dir
),
413 .fromname
= dentry
->d_name
.name
,
414 .fromlen
= dentry
->d_name
.len
,
419 struct rpc_message msg
= {
420 .rpc_proc
= &nfs_procedures
[NFSPROC_SYMLINK
],
423 int status
= -ENAMETOOLONG
;
425 dprintk("NFS call symlink %s\n", dentry
->d_name
.name
);
427 if (len
> NFS2_MAXPATHLEN
)
430 fh
= nfs_alloc_fhandle();
431 fattr
= nfs_alloc_fattr();
433 if (fh
== NULL
|| fattr
== NULL
)
436 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
437 nfs_mark_for_revalidate(dir
);
440 * V2 SYMLINK requests don't return any attributes. Setting the
441 * filehandle size to zero indicates to nfs_instantiate that it
442 * should fill in the data with a LOOKUP call on the wire.
445 status
= nfs_instantiate(dentry
, fh
, fattr
);
448 nfs_free_fattr(fattr
);
449 nfs_free_fhandle(fh
);
451 dprintk("NFS reply symlink: %d\n", status
);
456 nfs_proc_mkdir(struct inode
*dir
, struct dentry
*dentry
, struct iattr
*sattr
)
458 struct nfs_createdata
*data
;
459 struct rpc_message msg
= {
460 .rpc_proc
= &nfs_procedures
[NFSPROC_MKDIR
],
462 int status
= -ENOMEM
;
464 dprintk("NFS call mkdir %s\n", dentry
->d_name
.name
);
465 data
= nfs_alloc_createdata(dir
, dentry
, sattr
);
468 msg
.rpc_argp
= &data
->arg
;
469 msg
.rpc_resp
= &data
->res
;
471 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
472 nfs_mark_for_revalidate(dir
);
474 status
= nfs_instantiate(dentry
, data
->res
.fh
, data
->res
.fattr
);
475 nfs_free_createdata(data
);
477 dprintk("NFS reply mkdir: %d\n", status
);
482 nfs_proc_rmdir(struct inode
*dir
, struct qstr
*name
)
484 struct nfs_diropargs arg
= {
489 struct rpc_message msg
= {
490 .rpc_proc
= &nfs_procedures
[NFSPROC_RMDIR
],
495 dprintk("NFS call rmdir %s\n", name
->name
);
496 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
497 nfs_mark_for_revalidate(dir
);
498 dprintk("NFS reply rmdir: %d\n", status
);
503 * The READDIR implementation is somewhat hackish - we pass a temporary
504 * buffer to the encode function, which installs it in the receive
505 * the receive iovec. The decode function just parses the reply to make
506 * sure it is syntactically correct; the entries itself are decoded
507 * from nfs_readdir by calling the decode_entry function directly.
510 nfs_proc_readdir(struct dentry
*dentry
, struct rpc_cred
*cred
,
511 u64 cookie
, struct page
**pages
, unsigned int count
, int plus
)
513 struct inode
*dir
= dentry
->d_inode
;
514 struct nfs_readdirargs arg
= {
520 struct rpc_message msg
= {
521 .rpc_proc
= &nfs_procedures
[NFSPROC_READDIR
],
527 dprintk("NFS call readdir %d\n", (unsigned int)cookie
);
528 status
= rpc_call_sync(NFS_CLIENT(dir
), &msg
, 0);
530 nfs_invalidate_atime(dir
);
532 dprintk("NFS reply readdir: %d\n", status
);
537 nfs_proc_statfs(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
538 struct nfs_fsstat
*stat
)
540 struct nfs2_fsstat fsinfo
;
541 struct rpc_message msg
= {
542 .rpc_proc
= &nfs_procedures
[NFSPROC_STATFS
],
548 dprintk("NFS call statfs\n");
549 nfs_fattr_init(stat
->fattr
);
550 status
= rpc_call_sync(server
->client
, &msg
, 0);
551 dprintk("NFS reply statfs: %d\n", status
);
554 stat
->tbytes
= (u64
)fsinfo
.blocks
* fsinfo
.bsize
;
555 stat
->fbytes
= (u64
)fsinfo
.bfree
* fsinfo
.bsize
;
556 stat
->abytes
= (u64
)fsinfo
.bavail
* fsinfo
.bsize
;
565 nfs_proc_fsinfo(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
566 struct nfs_fsinfo
*info
)
568 struct nfs2_fsstat fsinfo
;
569 struct rpc_message msg
= {
570 .rpc_proc
= &nfs_procedures
[NFSPROC_STATFS
],
576 dprintk("NFS call fsinfo\n");
577 nfs_fattr_init(info
->fattr
);
578 status
= rpc_call_sync(server
->client
, &msg
, 0);
579 dprintk("NFS reply fsinfo: %d\n", status
);
582 info
->rtmax
= NFS_MAXDATA
;
583 info
->rtpref
= fsinfo
.tsize
;
584 info
->rtmult
= fsinfo
.bsize
;
585 info
->wtmax
= NFS_MAXDATA
;
586 info
->wtpref
= fsinfo
.tsize
;
587 info
->wtmult
= fsinfo
.bsize
;
588 info
->dtpref
= fsinfo
.tsize
;
589 info
->maxfilesize
= 0x7FFFFFFF;
590 info
->lease_time
= 0;
596 nfs_proc_pathconf(struct nfs_server
*server
, struct nfs_fh
*fhandle
,
597 struct nfs_pathconf
*info
)
600 info
->max_namelen
= NFS2_MAXNAMLEN
;
604 static int nfs_read_done(struct rpc_task
*task
, struct nfs_read_data
*data
)
606 struct inode
*inode
= data
->header
->inode
;
608 nfs_invalidate_atime(inode
);
609 if (task
->tk_status
>= 0) {
610 nfs_refresh_inode(inode
, data
->res
.fattr
);
611 /* Emulate the eof flag, which isn't normally needed in NFSv2
612 * as it is guaranteed to always return the file attributes
614 if (data
->args
.offset
+ data
->res
.count
>= data
->res
.fattr
->size
)
620 static void nfs_proc_read_setup(struct nfs_read_data
*data
, struct rpc_message
*msg
)
622 msg
->rpc_proc
= &nfs_procedures
[NFSPROC_READ
];
625 static void nfs_proc_read_rpc_prepare(struct rpc_task
*task
, struct nfs_read_data
*data
)
627 rpc_call_start(task
);
630 static int nfs_write_done(struct rpc_task
*task
, struct nfs_write_data
*data
)
632 struct inode
*inode
= data
->header
->inode
;
634 if (task
->tk_status
>= 0)
635 nfs_post_op_update_inode_force_wcc(inode
, data
->res
.fattr
);
639 static void nfs_proc_write_setup(struct nfs_write_data
*data
, struct rpc_message
*msg
)
641 /* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
642 data
->args
.stable
= NFS_FILE_SYNC
;
643 msg
->rpc_proc
= &nfs_procedures
[NFSPROC_WRITE
];
646 static void nfs_proc_write_rpc_prepare(struct rpc_task
*task
, struct nfs_write_data
*data
)
648 rpc_call_start(task
);
651 static void nfs_proc_commit_rpc_prepare(struct rpc_task
*task
, struct nfs_commit_data
*data
)
657 nfs_proc_commit_setup(struct nfs_commit_data
*data
, struct rpc_message
*msg
)
663 nfs_proc_lock(struct file
*filp
, int cmd
, struct file_lock
*fl
)
665 struct inode
*inode
= file_inode(filp
);
667 return nlmclnt_proc(NFS_SERVER(inode
)->nlm_host
, cmd
, fl
);
670 /* Helper functions for NFS lock bounds checking */
671 #define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL)
672 static int nfs_lock_check_bounds(const struct file_lock
*fl
)
676 start
= (__s32
)fl
->fl_start
;
677 if ((loff_t
)start
!= fl
->fl_start
)
680 if (fl
->fl_end
!= OFFSET_MAX
) {
681 end
= (__s32
)fl
->fl_end
;
682 if ((loff_t
)end
!= fl
->fl_end
)
685 end
= NFS_LOCK32_OFFSET_MAX
;
687 if (start
< 0 || start
> end
)
694 static int nfs_have_delegation(struct inode
*inode
, fmode_t flags
)
699 static int nfs_return_delegation(struct inode
*inode
)
705 static const struct inode_operations nfs_dir_inode_operations
= {
706 .create
= nfs_create
,
707 .lookup
= nfs_lookup
,
709 .unlink
= nfs_unlink
,
710 .symlink
= nfs_symlink
,
714 .rename
= nfs_rename
,
715 .permission
= nfs_permission
,
716 .getattr
= nfs_getattr
,
717 .setattr
= nfs_setattr
,
720 static const struct inode_operations nfs_file_inode_operations
= {
721 .permission
= nfs_permission
,
722 .getattr
= nfs_getattr
,
723 .setattr
= nfs_setattr
,
726 const struct nfs_rpc_ops nfs_v2_clientops
= {
727 .version
= 2, /* protocol version */
728 .dentry_ops
= &nfs_dentry_operations
,
729 .dir_inode_ops
= &nfs_dir_inode_operations
,
730 .file_inode_ops
= &nfs_file_inode_operations
,
731 .file_ops
= &nfs_file_operations
,
732 .getroot
= nfs_proc_get_root
,
733 .submount
= nfs_submount
,
734 .try_mount
= nfs_try_mount
,
735 .getattr
= nfs_proc_getattr
,
736 .setattr
= nfs_proc_setattr
,
737 .lookup
= nfs_proc_lookup
,
738 .access
= NULL
, /* access */
739 .readlink
= nfs_proc_readlink
,
740 .create
= nfs_proc_create
,
741 .remove
= nfs_proc_remove
,
742 .unlink_setup
= nfs_proc_unlink_setup
,
743 .unlink_rpc_prepare
= nfs_proc_unlink_rpc_prepare
,
744 .unlink_done
= nfs_proc_unlink_done
,
745 .rename
= nfs_proc_rename
,
746 .rename_setup
= nfs_proc_rename_setup
,
747 .rename_rpc_prepare
= nfs_proc_rename_rpc_prepare
,
748 .rename_done
= nfs_proc_rename_done
,
749 .link
= nfs_proc_link
,
750 .symlink
= nfs_proc_symlink
,
751 .mkdir
= nfs_proc_mkdir
,
752 .rmdir
= nfs_proc_rmdir
,
753 .readdir
= nfs_proc_readdir
,
754 .mknod
= nfs_proc_mknod
,
755 .statfs
= nfs_proc_statfs
,
756 .fsinfo
= nfs_proc_fsinfo
,
757 .pathconf
= nfs_proc_pathconf
,
758 .decode_dirent
= nfs2_decode_dirent
,
759 .read_setup
= nfs_proc_read_setup
,
760 .read_pageio_init
= nfs_pageio_init_read
,
761 .read_rpc_prepare
= nfs_proc_read_rpc_prepare
,
762 .read_done
= nfs_read_done
,
763 .write_setup
= nfs_proc_write_setup
,
764 .write_pageio_init
= nfs_pageio_init_write
,
765 .write_rpc_prepare
= nfs_proc_write_rpc_prepare
,
766 .write_done
= nfs_write_done
,
767 .commit_setup
= nfs_proc_commit_setup
,
768 .commit_rpc_prepare
= nfs_proc_commit_rpc_prepare
,
769 .lock
= nfs_proc_lock
,
770 .lock_check_bounds
= nfs_lock_check_bounds
,
771 .close_context
= nfs_close_context
,
772 .have_delegation
= nfs_have_delegation
,
773 .return_delegation
= nfs_return_delegation
,
774 .alloc_client
= nfs_alloc_client
,
775 .init_client
= nfs_init_client
,
776 .free_client
= nfs_free_client
,
777 .create_server
= nfs_create_server
,
778 .clone_server
= nfs_clone_server
,