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)
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{
151 struct nfs_diropargs arg = {
152 .fh = NFS_FH(dir),
153 .name = name->name,
154 .len = name->len
155 };
156 struct nfs_diropok res = {
157 .fh = fhandle,
158 .fattr = fattr
159 };
160 struct rpc_message msg = {
161 .rpc_proc = &nfs_procedures[NFSPROC_LOOKUP],
162 .rpc_argp = &arg,
163 .rpc_resp = &res,
164 };
165 int status;
166
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);
171 return status;
172}
173
174static int nfs_proc_readlink(struct inode *inode, struct page *page,
175 unsigned int pgbase, unsigned int pglen)
176{
177 struct nfs_readlinkargs args = {
178 .fh = NFS_FH(inode),
179 .pgbase = pgbase,
180 .pglen = pglen,
181 .pages = &page
182 };
183 struct rpc_message msg = {
184 .rpc_proc = &nfs_procedures[NFSPROC_READLINK],
185 .rpc_argp = &args,
186 };
187 int status;
188
189 dprintk("NFS call readlink\n");
190 status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
191 dprintk("NFS reply readlink: %d\n", status);
192 return status;
193}
194
195struct nfs_createdata {
196 struct nfs_createargs arg;
197 struct nfs_diropok res;
198 struct nfs_fh fhandle;
199 struct nfs_fattr fattr;
200};
201
202static struct nfs_createdata *nfs_alloc_createdata(struct inode *dir,
203 struct dentry *dentry, struct iattr *sattr)
204{
205 struct nfs_createdata *data;
206
207 data = kmalloc(sizeof(*data), GFP_KERNEL);
208
209 if (data != NULL) {
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;
218 }
219 return data;
220};
221
222static void nfs_free_createdata(const struct nfs_createdata *data)
223{
224 kfree(data);
225}
226
227static int
228nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
229 int flags)
230{
231 struct nfs_createdata *data;
232 struct rpc_message msg = {
233 .rpc_proc = &nfs_procedures[NFSPROC_CREATE],
234 };
235 int status = -ENOMEM;
236
237 dprintk("NFS call create %s\n", dentry->d_name.name);
238 data = nfs_alloc_createdata(dir, dentry, sattr);
239 if (data == NULL)
240 goto out;
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);
245 if (status == 0)
246 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
247 nfs_free_createdata(data);
248out:
249 dprintk("NFS reply create: %d\n", status);
250 return status;
251}
252
253
254
255
256static int
257nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
258 dev_t rdev)
259{
260 struct nfs_createdata *data;
261 struct rpc_message msg = {
262 .rpc_proc = &nfs_procedures[NFSPROC_CREATE],
263 };
264 umode_t mode;
265 int status = -ENOMEM;
266
267 dprintk("NFS call mknod %s\n", dentry->d_name.name);
268
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);
276 }
277
278 data = nfs_alloc_createdata(dir, dentry, sattr);
279 if (data == NULL)
280 goto out;
281 msg.rpc_argp = &data->arg;
282 msg.rpc_resp = &data->res;
283
284 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
285 nfs_mark_for_revalidate(dir);
286
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);
291 }
292 if (status == 0)
293 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
294 nfs_free_createdata(data);
295out:
296 dprintk("NFS reply mknod: %d\n", status);
297 return status;
298}
299
300static int
301nfs_proc_remove(struct inode *dir, struct qstr *name)
302{
303 struct nfs_removeargs arg = {
304 .fh = NFS_FH(dir),
305 .name = *name,
306 };
307 struct rpc_message msg = {
308 .rpc_proc = &nfs_procedures[NFSPROC_REMOVE],
309 .rpc_argp = &arg,
310 };
311 int status;
312
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);
316
317 dprintk("NFS reply remove: %d\n", status);
318 return status;
319}
320
321static void
322nfs_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
323{
324 msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
325}
326
327static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
328{
329 rpc_call_start(task);
330}
331
332static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
333{
334 nfs_mark_for_revalidate(dir);
335 return 1;
336}
337
338static void
339nfs_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
340{
341 msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME];
342}
343
344static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
345{
346 rpc_call_start(task);
347}
348
349static int
350nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
351 struct inode *new_dir)
352{
353 nfs_mark_for_revalidate(old_dir);
354 nfs_mark_for_revalidate(new_dir);
355 return 1;
356}
357
358static int
359nfs_proc_rename(struct inode *old_dir, struct qstr *old_name,
360 struct inode *new_dir, struct qstr *new_name)
361{
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,
367 };
368 struct rpc_message msg = {
369 .rpc_proc = &nfs_procedures[NFSPROC_RENAME],
370 .rpc_argp = &arg,
371 };
372 int status;
373
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);
379 return status;
380}
381
382static int
383nfs_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
384{
385 struct nfs_linkargs arg = {
386 .fromfh = NFS_FH(inode),
387 .tofh = NFS_FH(dir),
388 .toname = name->name,
389 .tolen = name->len
390 };
391 struct rpc_message msg = {
392 .rpc_proc = &nfs_procedures[NFSPROC_LINK],
393 .rpc_argp = &arg,
394 };
395 int status;
396
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);
402 return status;
403}
404
405static int
406nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
407 unsigned int len, struct iattr *sattr)
408{
409 struct nfs_fh *fh;
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,
415 .pages = &page,
416 .pathlen = len,
417 .sattr = sattr
418 };
419 struct rpc_message msg = {
420 .rpc_proc = &nfs_procedures[NFSPROC_SYMLINK],
421 .rpc_argp = &arg,
422 };
423 int status = -ENAMETOOLONG;
424
425 dprintk("NFS call symlink %s\n", dentry->d_name.name);
426
427 if (len > NFS2_MAXPATHLEN)
428 goto out;
429
430 fh = nfs_alloc_fhandle();
431 fattr = nfs_alloc_fattr();
432 status = -ENOMEM;
433 if (fh == NULL || fattr == NULL)
434 goto out_free;
435
436 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
437 nfs_mark_for_revalidate(dir);
438
439
440
441
442
443
444 if (status == 0)
445 status = nfs_instantiate(dentry, fh, fattr);
446
447out_free:
448 nfs_free_fattr(fattr);
449 nfs_free_fhandle(fh);
450out:
451 dprintk("NFS reply symlink: %d\n", status);
452 return status;
453}
454
455static int
456nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
457{
458 struct nfs_createdata *data;
459 struct rpc_message msg = {
460 .rpc_proc = &nfs_procedures[NFSPROC_MKDIR],
461 };
462 int status = -ENOMEM;
463
464 dprintk("NFS call mkdir %s\n", dentry->d_name.name);
465 data = nfs_alloc_createdata(dir, dentry, sattr);
466 if (data == NULL)
467 goto out;
468 msg.rpc_argp = &data->arg;
469 msg.rpc_resp = &data->res;
470
471 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
472 nfs_mark_for_revalidate(dir);
473 if (status == 0)
474 status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
475 nfs_free_createdata(data);
476out:
477 dprintk("NFS reply mkdir: %d\n", status);
478 return status;
479}
480
481static int
482nfs_proc_rmdir(struct inode *dir, struct qstr *name)
483{
484 struct nfs_diropargs arg = {
485 .fh = NFS_FH(dir),
486 .name = name->name,
487 .len = name->len
488 };
489 struct rpc_message msg = {
490 .rpc_proc = &nfs_procedures[NFSPROC_RMDIR],
491 .rpc_argp = &arg,
492 };
493 int status;
494
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);
499 return status;
500}
501
502
503
504
505
506
507
508
509static int
510nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
511 u64 cookie, struct page **pages, unsigned int count, int plus)
512{
513 struct inode *dir = dentry->d_inode;
514 struct nfs_readdirargs arg = {
515 .fh = NFS_FH(dir),
516 .cookie = cookie,
517 .count = count,
518 .pages = pages,
519 };
520 struct rpc_message msg = {
521 .rpc_proc = &nfs_procedures[NFSPROC_READDIR],
522 .rpc_argp = &arg,
523 .rpc_cred = cred,
524 };
525 int status;
526
527 dprintk("NFS call readdir %d\n", (unsigned int)cookie);
528 status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
529
530 nfs_invalidate_atime(dir);
531
532 dprintk("NFS reply readdir: %d\n", status);
533 return status;
534}
535
536static int
537nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
538 struct nfs_fsstat *stat)
539{
540 struct nfs2_fsstat fsinfo;
541 struct rpc_message msg = {
542 .rpc_proc = &nfs_procedures[NFSPROC_STATFS],
543 .rpc_argp = fhandle,
544 .rpc_resp = &fsinfo,
545 };
546 int status;
547
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);
552 if (status)
553 goto out;
554 stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
555 stat->fbytes = (u64)fsinfo.bfree * fsinfo.bsize;
556 stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
557 stat->tfiles = 0;
558 stat->ffiles = 0;
559 stat->afiles = 0;
560out:
561 return status;
562}
563
564static int
565nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
566 struct nfs_fsinfo *info)
567{
568 struct nfs2_fsstat fsinfo;
569 struct rpc_message msg = {
570 .rpc_proc = &nfs_procedures[NFSPROC_STATFS],
571 .rpc_argp = fhandle,
572 .rpc_resp = &fsinfo,
573 };
574 int status;
575
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);
580 if (status)
581 goto out;
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;
591out:
592 return status;
593}
594
595static int
596nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
597 struct nfs_pathconf *info)
598{
599 info->max_link = 0;
600 info->max_namelen = NFS2_MAXNAMLEN;
601 return 0;
602}
603
604static int nfs_read_done(struct rpc_task *task, struct nfs_read_data *data)
605{
606 struct inode *inode = data->header->inode;
607
608 nfs_invalidate_atime(inode);
609 if (task->tk_status >= 0) {
610 nfs_refresh_inode(inode, data->res.fattr);
611
612
613
614 if (data->args.offset + data->res.count >= data->res.fattr->size)
615 data->res.eof = 1;
616 }
617 return 0;
618}
619
620static void nfs_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
621{
622 msg->rpc_proc = &nfs_procedures[NFSPROC_READ];
623}
624
625static void nfs_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data)
626{
627 rpc_call_start(task);
628}
629
630static int nfs_write_done(struct rpc_task *task, struct nfs_write_data *data)
631{
632 struct inode *inode = data->header->inode;
633
634 if (task->tk_status >= 0)
635 nfs_post_op_update_inode_force_wcc(inode, data->res.fattr);
636 return 0;
637}
638
639static void nfs_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
640{
641
642 data->args.stable = NFS_FILE_SYNC;
643 msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE];
644}
645
646static void nfs_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data)
647{
648 rpc_call_start(task);
649}
650
651static void nfs_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
652{
653 BUG();
654}
655
656static void
657nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
658{
659 BUG();
660}
661
662static int
663nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
664{
665 struct inode *inode = filp->f_path.dentry->d_inode;
666
667 return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
668}
669
670
671#define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL)
672static int nfs_lock_check_bounds(const struct file_lock *fl)
673{
674 __s32 start, end;
675
676 start = (__s32)fl->fl_start;
677 if ((loff_t)start != fl->fl_start)
678 goto out_einval;
679
680 if (fl->fl_end != OFFSET_MAX) {
681 end = (__s32)fl->fl_end;
682 if ((loff_t)end != fl->fl_end)
683 goto out_einval;
684 } else
685 end = NFS_LOCK32_OFFSET_MAX;
686
687 if (start < 0 || start > end)
688 goto out_einval;
689 return 0;
690out_einval:
691 return -EINVAL;
692}
693
694static int nfs_have_delegation(struct inode *inode, fmode_t flags)
695{
696 return 0;
697}
698
699static int nfs_return_delegation(struct inode *inode)
700{
701 nfs_wb_all(inode);
702 return 0;
703}
704
705static const struct inode_operations nfs_dir_inode_operations = {
706 .create = nfs_create,
707 .lookup = nfs_lookup,
708 .link = nfs_link,
709 .unlink = nfs_unlink,
710 .symlink = nfs_symlink,
711 .mkdir = nfs_mkdir,
712 .rmdir = nfs_rmdir,
713 .mknod = nfs_mknod,
714 .rename = nfs_rename,
715 .permission = nfs_permission,
716 .getattr = nfs_getattr,
717 .setattr = nfs_setattr,
718};
719
720static const struct inode_operations nfs_file_inode_operations = {
721 .permission = nfs_permission,
722 .getattr = nfs_getattr,
723 .setattr = nfs_setattr,
724};
725
726const struct nfs_rpc_ops nfs_v2_clientops = {
727 .version = 2,
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,
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,
779};
780
