1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30#include <linux/types.h>
31#include <linux/param.h>
32#include <linux/time.h>
33#include <linux/mm.h>
34#include <linux/errno.h>
35#include <linux/string.h>
36#include <linux/in.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>
45#include "internal.h"
46
47#define NFSDBG_FACILITY NFSDBG_PROC
48
49
50
51
52static int
53nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
54 struct nfs_fsinfo *info)
55{
56 struct nfs_fattr *fattr = info->fattr;
57 struct nfs2_fsstat fsinfo;
58 struct rpc_message msg = {
59 .rpc_proc = &nfs_procedures[NFSPROC_GETATTR],
60 .rpc_argp = fhandle,
61 .rpc_resp = fattr,
62 };
63 int status;
64
65 dprintk("%s: call getattr\n", __func__);
66 nfs_fattr_init(fattr);
67 status = rpc_call_sync(server->client, &msg, 0);
68
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);
72 if (status)
73 return 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
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);
82 if (status)
83 return 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;
92 info->lease_time = 0;
93 return 0;
94}
95
96
97
98
99static int
100nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
101 struct nfs_fattr *fattr, struct nfs4_label *label)
102{
103 struct rpc_message msg = {
104 .rpc_proc = &nfs_procedures[NFSPROC_GETATTR],
105 .rpc_argp = fhandle,
106 .rpc_resp = fattr,
107 };
108 int status;
109
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);
114 return status;
115}
116
117static int
118nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
119 struct iattr *sattr)
120{
121 struct inode *inode = dentry->d_inode;
122 struct nfs_sattrargs arg = {
123 .fh = NFS_FH(inode),
124 .sattr = sattr
125 };
126 struct rpc_message msg = {
127 .rpc_proc = &nfs_procedures[NFSPROC_SETATTR],
128 .rpc_argp = &arg,
129 .rpc_resp = fattr,
130 };
131 int status;
132
133
134 sattr->ia_mode &= S_IALLUGO;
135
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);
141 if (status == 0)
142 nfs_setattr_update_inode(inode, sattr);
143 dprintk("NFS reply setattr: %d\n", status);
144 return status;
145}
146
147static int
148nfs_proc_lookup(struct inode *dir, struct qstr *name,
149 struct nfs_fh *fhandle, struct nfs_fattr *fattr,
150 struct nfs4_label *label)
151{
152 struct nfs_diropargs arg = {
153 .fh = NFS_FH(dir),
154 .name = name->name,
155 .len = name->len
156 };
157 struct nfs_diropok res = {
158 .fh = fhandle,
159 .fattr = fattr
160 };
161 struct rpc_message msg = {
162 .rpc_proc = &nfs_procedures[NFSPROC_LOOKUP],
163 .rpc_argp = &arg,
164 .rpc_resp = &res,
165 };
166 int status;
167
168 dprintk("NFS call lookup %s\n", name->name);
169 nfs_fattr_init(fattr);
170 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
171 dprintk("NFS reply lookup: %d\n", status);
172 return status;
173}
174
175static int nfs_proc_readlink(struct inode *inode, struct page *page,
176 unsigned int pgbase, unsigned int pglen)
177{
178 struct nfs_readlinkargs args = {
179 .fh = NFS_FH(inode),
180 .pgbase = pgbase,
181 .pglen = pglen,
182 .pages = &page
183 };
184 struct rpc_message msg = {
185 .rpc_proc = &nfs_procedures[NFSPROC_READLINK],
186 .rpc_argp = &args,
187 };
188 int status;
189
190 dprintk("NFS call readlink\n");
191 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
192 dprintk("NFS reply readlink: %d\n", status);
193 return status;
194}
195
196struct nfs_createdata {
197 struct nfs_createargs arg;
198 struct nfs_diropok res;
199 struct nfs_fh fhandle;
200 struct nfs_fattr fattr;
201};
202
203static struct nfs_createdata *nfs_alloc_createdata(struct inode *dir,
204 struct dentry *dentry, struct iattr *sattr)
205{
206 struct nfs_createdata *data;
207
208 data = kmalloc(sizeof(*data), GFP_KERNEL);
209
210 if (data != NULL) {
211 data->arg.fh = NFS_FH(dir);
212 data->arg.name = dentry->d_name.name;
213 data->arg.len = dentry->d_name.len;
214 data->arg.sattr = sattr;
215 nfs_fattr_init(&data->fattr);
216 data->fhandle.size = 0;
217 data->res.fh = &data->fhandle;
218 data->res.fattr = &data->fattr;
219 }
220 return data;
221};
222
223static void nfs_free_createdata(const struct nfs_createdata *data)
224{
225 kfree(data);
226}
227
228static int
229nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
230 int flags)
231{
232 struct nfs_createdata *data;
233 struct rpc_message msg = {
234 .rpc_proc = &nfs_procedures[NFSPROC_CREATE],
235 };
236 int status = -ENOMEM;
237
238 dprintk("NFS call create %s\n", dentry->d_name.name);
239 data = nfs_alloc_createdata(dir, dentry, sattr);
240 if (data == NULL)
241 goto out;
242 msg.rpc_argp = &data->arg;
243 msg.rpc_resp = &data->res;
244 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
245 nfs_mark_for_revalidate(dir);
246 if (status == 0)
247 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
248 nfs_free_createdata(data);
249out:
250 dprintk("NFS reply create: %d\n", status);
251 return status;
252}
253
254
255
256
257static int
258nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
259 dev_t rdev)
260{
261 struct nfs_createdata *data;
262 struct rpc_message msg = {
263 .rpc_proc = &nfs_procedures[NFSPROC_CREATE],
264 };
265 umode_t mode;
266 int status = -ENOMEM;
267
268 dprintk("NFS call mknod %s\n", dentry->d_name.name);
269
270 mode = sattr->ia_mode;
271 if (S_ISFIFO(mode)) {
272 sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR;
273 sattr->ia_valid &= ~ATTR_SIZE;
274 } else if (S_ISCHR(mode) || S_ISBLK(mode)) {
275 sattr->ia_valid |= ATTR_SIZE;
276 sattr->ia_size = new_encode_dev(rdev);
277 }
278
279 data = nfs_alloc_createdata(dir, dentry, sattr);
280 if (data == NULL)
281 goto out;
282 msg.rpc_argp = &data->arg;
283 msg.rpc_resp = &data->res;
284
285 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
286 nfs_mark_for_revalidate(dir);
287
288 if (status == -EINVAL && S_ISFIFO(mode)) {
289 sattr->ia_mode = mode;
290 nfs_fattr_init(data->res.fattr);
291 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
292 }
293 if (status == 0)
294 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
295 nfs_free_createdata(data);
296out:
297 dprintk("NFS reply mknod: %d\n", status);
298 return status;
299}
300
301static int
302nfs_proc_remove(struct inode *dir, struct qstr *name)
303{
304 struct nfs_removeargs arg = {
305 .fh = NFS_FH(dir),
306 .name = *name,
307 };
308 struct rpc_message msg = {
309 .rpc_proc = &nfs_procedures[NFSPROC_REMOVE],
310 .rpc_argp = &arg,
311 };
312 int status;
313
314 dprintk("NFS call remove %s\n", name->name);
315 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
316 nfs_mark_for_revalidate(dir);
317
318 dprintk("NFS reply remove: %d\n", status);
319 return status;
320}
321
322static void
323nfs_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
324{
325 msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
326}
327
328static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
329{
330 rpc_call_start(task);
331}
332
333static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
334{
335 nfs_mark_for_revalidate(dir);
336 return 1;
337}
338
339static void
340nfs_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
341{
342 msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME];
343}
344
345static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
346{
347 rpc_call_start(task);
348}
349
350static int
351nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
352 struct inode *new_dir)
353{
354 nfs_mark_for_revalidate(old_dir);
355 nfs_mark_for_revalidate(new_dir);
356 return 1;
357}
358
359static int
360nfs_proc_rename(struct inode *old_dir, struct qstr *old_name,
361 struct inode *new_dir, struct qstr *new_name)
362{
363 struct nfs_renameargs arg = {
364 .old_dir = NFS_FH(old_dir),
365 .old_name = old_name,
366 .new_dir = NFS_FH(new_dir),
367 .new_name = new_name,
368 };
369 struct rpc_message msg = {
370 .rpc_proc = &nfs_procedures[NFSPROC_RENAME],
371 .rpc_argp = &arg,
372 };
373 int status;
374
375 dprintk("NFS call rename %s -> %s\n", old_name->name, new_name->name);
376 status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
377 nfs_mark_for_revalidate(old_dir);
378 nfs_mark_for_revalidate(new_dir);
379 dprintk("NFS reply rename: %d\n", status);
380 return status;
381}
382
383static int
384nfs_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
385{
386 struct nfs_linkargs arg = {
387 .fromfh = NFS_FH(inode),
388 .tofh = NFS_FH(dir),
389 .toname = name->name,
390 .tolen = name->len
391 };
392 struct rpc_message msg = {
393 .rpc_proc = &nfs_procedures[NFSPROC_LINK],
394 .rpc_argp = &arg,
395 };
396 int status;
397
398 dprintk("NFS call link %s\n", name->name);
399 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
400 nfs_mark_for_revalidate(inode);
401 nfs_mark_for_revalidate(dir);
402 dprintk("NFS reply link: %d\n", status);
403 return status;
404}
405
406static int
407nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
408 unsigned int len, struct iattr *sattr)
409{
410 struct nfs_fh *fh;
411 struct nfs_fattr *fattr;
412 struct nfs_symlinkargs arg = {
413 .fromfh = NFS_FH(dir),
414 .fromname = dentry->d_name.name,
415 .fromlen = dentry->d_name.len,
416 .pages = &page,
417 .pathlen = len,
418 .sattr = sattr
419 };
420 struct rpc_message msg = {
421 .rpc_proc = &nfs_procedures[NFSPROC_SYMLINK],
422 .rpc_argp = &arg,
423 };
424 int status = -ENAMETOOLONG;
425
426 dprintk("NFS call symlink %s\n", dentry->d_name.name);
427
428 if (len > NFS2_MAXPATHLEN)
429 goto out;
430
431 fh = nfs_alloc_fhandle();
432 fattr = nfs_alloc_fattr();
433 status = -ENOMEM;
434 if (fh == NULL || fattr == NULL)
435 goto out_free;
436
437 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
438 nfs_mark_for_revalidate(dir);
439
440
441
442
443
444
445 if (status == 0)
446 status = nfs_instantiate(dentry, fh, fattr, NULL);
447
448out_free:
449 nfs_free_fattr(fattr);
450 nfs_free_fhandle(fh);
451out:
452 dprintk("NFS reply symlink: %d\n", status);
453 return status;
454}
455
456static int
457nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
458{
459 struct nfs_createdata *data;
460 struct rpc_message msg = {
461 .rpc_proc = &nfs_procedures[NFSPROC_MKDIR],
462 };
463 int status = -ENOMEM;
464
465 dprintk("NFS call mkdir %s\n", dentry->d_name.name);
466 data = nfs_alloc_createdata(dir, dentry, sattr);
467 if (data == NULL)
468 goto out;
469 msg.rpc_argp = &data->arg;
470 msg.rpc_resp = &data->res;
471
472 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
473 nfs_mark_for_revalidate(dir);
474 if (status == 0)
475 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
476 nfs_free_createdata(data);
477out:
478 dprintk("NFS reply mkdir: %d\n", status);
479 return status;
480}
481
482static int
483nfs_proc_rmdir(struct inode *dir, struct qstr *name)
484{
485 struct nfs_diropargs arg = {
486 .fh = NFS_FH(dir),
487 .name = name->name,
488 .len = name->len
489 };
490 struct rpc_message msg = {
491 .rpc_proc = &nfs_procedures[NFSPROC_RMDIR],
492 .rpc_argp = &arg,
493 };
494 int status;
495
496 dprintk("NFS call rmdir %s\n", name->name);
497 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
498 nfs_mark_for_revalidate(dir);
499 dprintk("NFS reply rmdir: %d\n", status);
500 return status;
501}
502
503
504
505
506
507
508
509
510static int
511nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
512 u64 cookie, struct page **pages, unsigned int count, int plus)
513{
514 struct inode *dir = dentry->d_inode;
515 struct nfs_readdirargs arg = {
516 .fh = NFS_FH(dir),
517 .cookie = cookie,
518 .count = count,
519 .pages = pages,
520 };
521 struct rpc_message msg = {
522 .rpc_proc = &nfs_procedures[NFSPROC_READDIR],
523 .rpc_argp = &arg,
524 .rpc_cred = cred,
525 };
526 int status;
527
528 dprintk("NFS call readdir %d\n", (unsigned int)cookie);
529 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
530
531 nfs_invalidate_atime(dir);
532
533 dprintk("NFS reply readdir: %d\n", status);
534 return status;
535}
536
537static int
538nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
539 struct nfs_fsstat *stat)
540{
541 struct nfs2_fsstat fsinfo;
542 struct rpc_message msg = {
543 .rpc_proc = &nfs_procedures[NFSPROC_STATFS],
544 .rpc_argp = fhandle,
545 .rpc_resp = &fsinfo,
546 };
547 int status;
548
549 dprintk("NFS call statfs\n");
550 nfs_fattr_init(stat->fattr);
551 status = rpc_call_sync(server->client, &msg, 0);
552 dprintk("NFS reply statfs: %d\n", status);
553 if (status)
554 goto out;
555 stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
556 stat->fbytes = (u64)fsinfo.bfree * fsinfo.bsize;
557 stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
558 stat->tfiles = 0;
559 stat->ffiles = 0;
560 stat->afiles = 0;
561out:
562 return status;
563}
564
565static int
566nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
567 struct nfs_fsinfo *info)
568{
569 struct nfs2_fsstat fsinfo;
570 struct rpc_message msg = {
571 .rpc_proc = &nfs_procedures[NFSPROC_STATFS],
572 .rpc_argp = fhandle,
573 .rpc_resp = &fsinfo,
574 };
575 int status;
576
577 dprintk("NFS call fsinfo\n");
578 nfs_fattr_init(info->fattr);
579 status = rpc_call_sync(server->client, &msg, 0);
580 dprintk("NFS reply fsinfo: %d\n", status);
581 if (status)
582 goto out;
583 info->rtmax = NFS_MAXDATA;
584 info->rtpref = fsinfo.tsize;
585 info->rtmult = fsinfo.bsize;
586 info->wtmax = NFS_MAXDATA;
587 info->wtpref = fsinfo.tsize;
588 info->wtmult = fsinfo.bsize;
589 info->dtpref = fsinfo.tsize;
590 info->maxfilesize = 0x7FFFFFFF;
591 info->lease_time = 0;
592out:
593 return status;
594}
595
596static int
597nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
598 struct nfs_pathconf *info)
599{
600 info->max_link = 0;
601 info->max_namelen = NFS2_MAXNAMLEN;
602 return 0;
603}
604
605static int nfs_read_done(struct rpc_task *task, struct nfs_read_data *data)
606{
607 struct inode *inode = data->header->inode;
608
609 nfs_invalidate_atime(inode);
610 if (task->tk_status >= 0) {
611 nfs_refresh_inode(inode, data->res.fattr);
612
613
614
615 if (data->args.offset + data->res.count >= data->res.fattr->size)
616 data->res.eof = 1;
617 }
618 return 0;
619}
620
621static void nfs_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
622{
623 msg->rpc_proc = &nfs_procedures[NFSPROC_READ];
624}
625
626static void nfs_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data)
627{
628 rpc_call_start(task);
629}
630
631static int nfs_write_done(struct rpc_task *task, struct nfs_write_data *data)
632{
633 struct inode *inode = data->header->inode;
634
635 if (task->tk_status >= 0)
636 nfs_post_op_update_inode_force_wcc(inode, data->res.fattr);
637 return 0;
638}
639
640static void nfs_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
641{
642
643 data->args.stable = NFS_FILE_SYNC;
644 msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE];
645}
646
647static void nfs_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data)
648{
649 rpc_call_start(task);
650}
651
652static void nfs_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
653{
654 BUG();
655}
656
657static void
658nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
659{
660 BUG();
661}
662
663static int
664nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
665{
666 struct inode *inode = file_inode(filp);
667
668 return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
669}
670
671
672#define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL)
673static int nfs_lock_check_bounds(const struct file_lock *fl)
674{
675 __s32 start, end;
676
677 start = (__s32)fl->fl_start;
678 if ((loff_t)start != fl->fl_start)
679 goto out_einval;
680
681 if (fl->fl_end != OFFSET_MAX) {
682 end = (__s32)fl->fl_end;
683 if ((loff_t)end != fl->fl_end)
684 goto out_einval;
685 } else
686 end = NFS_LOCK32_OFFSET_MAX;
687
688 if (start < 0 || start > end)
689 goto out_einval;
690 return 0;
691out_einval:
692 return -EINVAL;
693}
694
695static int nfs_have_delegation(struct inode *inode, fmode_t flags)
696{
697 return 0;
698}
699
700static int nfs_return_delegation(struct inode *inode)
701{
702 nfs_wb_all(inode);
703 return 0;
704}
705
706static const struct inode_operations nfs_dir_inode_operations = {
707 .create = nfs_create,
708 .lookup = nfs_lookup,
709 .link = nfs_link,
710 .unlink = nfs_unlink,
711 .symlink = nfs_symlink,
712 .mkdir = nfs_mkdir,
713 .rmdir = nfs_rmdir,
714 .mknod = nfs_mknod,
715 .rename = nfs_rename,
716 .permission = nfs_permission,
717 .getattr = nfs_getattr,
718 .setattr = nfs_setattr,
719};
720
721static const struct inode_operations nfs_file_inode_operations = {
722 .permission = nfs_permission,
723 .getattr = nfs_getattr,
724 .setattr = nfs_setattr,
725};
726
727const struct nfs_rpc_ops nfs_v2_clientops = {
728 .version = 2,
729 .dentry_ops = &nfs_dentry_operations,
730 .dir_inode_ops = &nfs_dir_inode_operations,
731 .file_inode_ops = &nfs_file_inode_operations,
732 .file_ops = &nfs_file_operations,
733 .getroot = nfs_proc_get_root,
734 .submount = nfs_submount,
735 .try_mount = nfs_try_mount,
736 .getattr = nfs_proc_getattr,
737 .setattr = nfs_proc_setattr,
738 .lookup = nfs_proc_lookup,
739 .access = NULL,
740 .readlink = nfs_proc_readlink,
741 .create = nfs_proc_create,
742 .remove = nfs_proc_remove,
743 .unlink_setup = nfs_proc_unlink_setup,
744 .unlink_rpc_prepare = nfs_proc_unlink_rpc_prepare,
745 .unlink_done = nfs_proc_unlink_done,
746 .rename = nfs_proc_rename,
747 .rename_setup = nfs_proc_rename_setup,
748 .rename_rpc_prepare = nfs_proc_rename_rpc_prepare,
749 .rename_done = nfs_proc_rename_done,
750 .link = nfs_proc_link,
751 .symlink = nfs_proc_symlink,
752 .mkdir = nfs_proc_mkdir,
753 .rmdir = nfs_proc_rmdir,
754 .readdir = nfs_proc_readdir,
755 .mknod = nfs_proc_mknod,
756 .statfs = nfs_proc_statfs,
757 .fsinfo = nfs_proc_fsinfo,
758 .pathconf = nfs_proc_pathconf,
759 .decode_dirent = nfs2_decode_dirent,
760 .read_setup = nfs_proc_read_setup,
761 .read_pageio_init = nfs_pageio_init_read,
762 .read_rpc_prepare = nfs_proc_read_rpc_prepare,
763 .read_done = nfs_read_done,
764 .write_setup = nfs_proc_write_setup,
765 .write_pageio_init = nfs_pageio_init_write,
766 .write_rpc_prepare = nfs_proc_write_rpc_prepare,
767 .write_done = nfs_write_done,
768 .commit_setup = nfs_proc_commit_setup,
769 .commit_rpc_prepare = nfs_proc_commit_rpc_prepare,
770 .lock = nfs_proc_lock,
771 .lock_check_bounds = nfs_lock_check_bounds,
772 .close_context = nfs_close_context,
773 .have_delegation = nfs_have_delegation,
774 .return_delegation = nfs_return_delegation,
775 .alloc_client = nfs_alloc_client,
776 .init_client = nfs_init_client,
777 .free_client = nfs_free_client,
778 .create_server = nfs_create_server,
779 .clone_server = nfs_clone_server,
780};
781
