xref: /openbmc/linux/fs/nfs/proc.c (revision d0b5e15f)
1  /*
2   *  linux/fs/nfs/proc.c
3   *
4   *  Copyright (C) 1992, 1993, 1994  Rick Sladkey
5   *
6   *  OS-independent nfs remote procedure call functions
7   *
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
10   *  Sun server.
11   *
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.
15   *
16   *  Also, the code currently doesn't check the size of the packet, when
17   *  it decodes the packet.
18   *
19   *  Feel free to fix it and mail me the diffs if it worries you.
20   *
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
24   *
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
27   *  incomplete struct).
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   * Bare-bones access to getattr: this is for nfs_read_super.
51   */
52  static int
53  nfs_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  	/* 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);
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  	/* 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);
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   * One function for each procedure in the NFS protocol.
98   */
99  static int
100  nfs_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  
117  static int
118  nfs_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  	/* Mask out the non-modebit related stuff from attr->ia_mode */
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, fattr);
143  	dprintk("NFS reply setattr: %d\n", status);
144  	return status;
145  }
146  
147  static int
148  nfs_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  
175  static 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  
196  struct nfs_createdata {
197  	struct nfs_createargs arg;
198  	struct nfs_diropok res;
199  	struct nfs_fh fhandle;
200  	struct nfs_fattr fattr;
201  };
202  
203  static 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  
223  static void nfs_free_createdata(const struct nfs_createdata *data)
224  {
225  	kfree(data);
226  }
227  
228  static int
229  nfs_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 %pd\n", dentry);
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);
249  out:
250  	dprintk("NFS reply create: %d\n", status);
251  	return status;
252  }
253  
254  /*
255   * In NFSv2, mknod is grafted onto the create call.
256   */
257  static int
258  nfs_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 %pd\n", dentry);
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);/* get out your barf bag */
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);
296  out:
297  	dprintk("NFS reply mknod: %d\n", status);
298  	return status;
299  }
300  
301  static int
302  nfs_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  
322  static void
323  nfs_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
324  {
325  	msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
326  }
327  
328  static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
329  {
330  	rpc_call_start(task);
331  }
332  
333  static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
334  {
335  	nfs_mark_for_revalidate(dir);
336  	return 1;
337  }
338  
339  static void
340  nfs_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
341  {
342  	msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME];
343  }
344  
345  static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
346  {
347  	rpc_call_start(task);
348  }
349  
350  static int
351  nfs_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  
359  static int
360  nfs_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
361  {
362  	struct nfs_linkargs	arg = {
363  		.fromfh		= NFS_FH(inode),
364  		.tofh		= NFS_FH(dir),
365  		.toname		= name->name,
366  		.tolen		= name->len
367  	};
368  	struct rpc_message msg = {
369  		.rpc_proc	= &nfs_procedures[NFSPROC_LINK],
370  		.rpc_argp	= &arg,
371  	};
372  	int			status;
373  
374  	dprintk("NFS call  link %s\n", name->name);
375  	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
376  	nfs_mark_for_revalidate(inode);
377  	nfs_mark_for_revalidate(dir);
378  	dprintk("NFS reply link: %d\n", status);
379  	return status;
380  }
381  
382  static int
383  nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
384  		 unsigned int len, struct iattr *sattr)
385  {
386  	struct nfs_fh *fh;
387  	struct nfs_fattr *fattr;
388  	struct nfs_symlinkargs	arg = {
389  		.fromfh		= NFS_FH(dir),
390  		.fromname	= dentry->d_name.name,
391  		.fromlen	= dentry->d_name.len,
392  		.pages		= &page,
393  		.pathlen	= len,
394  		.sattr		= sattr
395  	};
396  	struct rpc_message msg = {
397  		.rpc_proc	= &nfs_procedures[NFSPROC_SYMLINK],
398  		.rpc_argp	= &arg,
399  	};
400  	int status = -ENAMETOOLONG;
401  
402  	dprintk("NFS call  symlink %pd\n", dentry);
403  
404  	if (len > NFS2_MAXPATHLEN)
405  		goto out;
406  
407  	fh = nfs_alloc_fhandle();
408  	fattr = nfs_alloc_fattr();
409  	status = -ENOMEM;
410  	if (fh == NULL || fattr == NULL)
411  		goto out_free;
412  
413  	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
414  	nfs_mark_for_revalidate(dir);
415  
416  	/*
417  	 * V2 SYMLINK requests don't return any attributes.  Setting the
418  	 * filehandle size to zero indicates to nfs_instantiate that it
419  	 * should fill in the data with a LOOKUP call on the wire.
420  	 */
421  	if (status == 0)
422  		status = nfs_instantiate(dentry, fh, fattr, NULL);
423  
424  out_free:
425  	nfs_free_fattr(fattr);
426  	nfs_free_fhandle(fh);
427  out:
428  	dprintk("NFS reply symlink: %d\n", status);
429  	return status;
430  }
431  
432  static int
433  nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
434  {
435  	struct nfs_createdata *data;
436  	struct rpc_message msg = {
437  		.rpc_proc	= &nfs_procedures[NFSPROC_MKDIR],
438  	};
439  	int status = -ENOMEM;
440  
441  	dprintk("NFS call  mkdir %pd\n", dentry);
442  	data = nfs_alloc_createdata(dir, dentry, sattr);
443  	if (data == NULL)
444  		goto out;
445  	msg.rpc_argp = &data->arg;
446  	msg.rpc_resp = &data->res;
447  
448  	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
449  	nfs_mark_for_revalidate(dir);
450  	if (status == 0)
451  		status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
452  	nfs_free_createdata(data);
453  out:
454  	dprintk("NFS reply mkdir: %d\n", status);
455  	return status;
456  }
457  
458  static int
459  nfs_proc_rmdir(struct inode *dir, struct qstr *name)
460  {
461  	struct nfs_diropargs	arg = {
462  		.fh		= NFS_FH(dir),
463  		.name		= name->name,
464  		.len		= name->len
465  	};
466  	struct rpc_message msg = {
467  		.rpc_proc	= &nfs_procedures[NFSPROC_RMDIR],
468  		.rpc_argp	= &arg,
469  	};
470  	int			status;
471  
472  	dprintk("NFS call  rmdir %s\n", name->name);
473  	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
474  	nfs_mark_for_revalidate(dir);
475  	dprintk("NFS reply rmdir: %d\n", status);
476  	return status;
477  }
478  
479  /*
480   * The READDIR implementation is somewhat hackish - we pass a temporary
481   * buffer to the encode function, which installs it in the receive
482   * the receive iovec. The decode function just parses the reply to make
483   * sure it is syntactically correct; the entries itself are decoded
484   * from nfs_readdir by calling the decode_entry function directly.
485   */
486  static int
487  nfs_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
488  		 u64 cookie, struct page **pages, unsigned int count, int plus)
489  {
490  	struct inode		*dir = dentry->d_inode;
491  	struct nfs_readdirargs	arg = {
492  		.fh		= NFS_FH(dir),
493  		.cookie		= cookie,
494  		.count		= count,
495  		.pages		= pages,
496  	};
497  	struct rpc_message	msg = {
498  		.rpc_proc	= &nfs_procedures[NFSPROC_READDIR],
499  		.rpc_argp	= &arg,
500  		.rpc_cred	= cred,
501  	};
502  	int			status;
503  
504  	dprintk("NFS call  readdir %d\n", (unsigned int)cookie);
505  	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
506  
507  	nfs_invalidate_atime(dir);
508  
509  	dprintk("NFS reply readdir: %d\n", status);
510  	return status;
511  }
512  
513  static int
514  nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
515  			struct nfs_fsstat *stat)
516  {
517  	struct nfs2_fsstat fsinfo;
518  	struct rpc_message msg = {
519  		.rpc_proc	= &nfs_procedures[NFSPROC_STATFS],
520  		.rpc_argp	= fhandle,
521  		.rpc_resp	= &fsinfo,
522  	};
523  	int	status;
524  
525  	dprintk("NFS call  statfs\n");
526  	nfs_fattr_init(stat->fattr);
527  	status = rpc_call_sync(server->client, &msg, 0);
528  	dprintk("NFS reply statfs: %d\n", status);
529  	if (status)
530  		goto out;
531  	stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
532  	stat->fbytes = (u64)fsinfo.bfree  * fsinfo.bsize;
533  	stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
534  	stat->tfiles = 0;
535  	stat->ffiles = 0;
536  	stat->afiles = 0;
537  out:
538  	return status;
539  }
540  
541  static int
542  nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
543  			struct nfs_fsinfo *info)
544  {
545  	struct nfs2_fsstat fsinfo;
546  	struct rpc_message msg = {
547  		.rpc_proc	= &nfs_procedures[NFSPROC_STATFS],
548  		.rpc_argp	= fhandle,
549  		.rpc_resp	= &fsinfo,
550  	};
551  	int	status;
552  
553  	dprintk("NFS call  fsinfo\n");
554  	nfs_fattr_init(info->fattr);
555  	status = rpc_call_sync(server->client, &msg, 0);
556  	dprintk("NFS reply fsinfo: %d\n", status);
557  	if (status)
558  		goto out;
559  	info->rtmax  = NFS_MAXDATA;
560  	info->rtpref = fsinfo.tsize;
561  	info->rtmult = fsinfo.bsize;
562  	info->wtmax  = NFS_MAXDATA;
563  	info->wtpref = fsinfo.tsize;
564  	info->wtmult = fsinfo.bsize;
565  	info->dtpref = fsinfo.tsize;
566  	info->maxfilesize = 0x7FFFFFFF;
567  	info->lease_time = 0;
568  out:
569  	return status;
570  }
571  
572  static int
573  nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
574  		  struct nfs_pathconf *info)
575  {
576  	info->max_link = 0;
577  	info->max_namelen = NFS2_MAXNAMLEN;
578  	return 0;
579  }
580  
581  static int nfs_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
582  {
583  	struct inode *inode = hdr->inode;
584  
585  	nfs_invalidate_atime(inode);
586  	if (task->tk_status >= 0) {
587  		nfs_refresh_inode(inode, hdr->res.fattr);
588  		/* Emulate the eof flag, which isn't normally needed in NFSv2
589  		 * as it is guaranteed to always return the file attributes
590  		 */
591  		if (hdr->args.offset + hdr->res.count >= hdr->res.fattr->size)
592  			hdr->res.eof = 1;
593  	}
594  	return 0;
595  }
596  
597  static void nfs_proc_read_setup(struct nfs_pgio_header *hdr,
598  				struct rpc_message *msg)
599  {
600  	msg->rpc_proc = &nfs_procedures[NFSPROC_READ];
601  }
602  
603  static int nfs_proc_pgio_rpc_prepare(struct rpc_task *task,
604  				     struct nfs_pgio_header *hdr)
605  {
606  	rpc_call_start(task);
607  	return 0;
608  }
609  
610  static int nfs_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
611  {
612  	if (task->tk_status >= 0)
613  		nfs_writeback_update_inode(hdr);
614  	return 0;
615  }
616  
617  static void nfs_proc_write_setup(struct nfs_pgio_header *hdr,
618  				 struct rpc_message *msg)
619  {
620  	/* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
621  	hdr->args.stable = NFS_FILE_SYNC;
622  	msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE];
623  }
624  
625  static void nfs_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
626  {
627  	BUG();
628  }
629  
630  static void
631  nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
632  {
633  	BUG();
634  }
635  
636  static int
637  nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
638  {
639  	struct inode *inode = file_inode(filp);
640  
641  	return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
642  }
643  
644  /* Helper functions for NFS lock bounds checking */
645  #define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL)
646  static int nfs_lock_check_bounds(const struct file_lock *fl)
647  {
648  	__s32 start, end;
649  
650  	start = (__s32)fl->fl_start;
651  	if ((loff_t)start != fl->fl_start)
652  		goto out_einval;
653  
654  	if (fl->fl_end != OFFSET_MAX) {
655  		end = (__s32)fl->fl_end;
656  		if ((loff_t)end != fl->fl_end)
657  			goto out_einval;
658  	} else
659  		end = NFS_LOCK32_OFFSET_MAX;
660  
661  	if (start < 0 || start > end)
662  		goto out_einval;
663  	return 0;
664  out_einval:
665  	return -EINVAL;
666  }
667  
668  static int nfs_have_delegation(struct inode *inode, fmode_t flags)
669  {
670  	return 0;
671  }
672  
673  static int nfs_return_delegation(struct inode *inode)
674  {
675  	nfs_wb_all(inode);
676  	return 0;
677  }
678  
679  static const struct inode_operations nfs_dir_inode_operations = {
680  	.create		= nfs_create,
681  	.lookup		= nfs_lookup,
682  	.link		= nfs_link,
683  	.unlink		= nfs_unlink,
684  	.symlink	= nfs_symlink,
685  	.mkdir		= nfs_mkdir,
686  	.rmdir		= nfs_rmdir,
687  	.mknod		= nfs_mknod,
688  	.rename		= nfs_rename,
689  	.permission	= nfs_permission,
690  	.getattr	= nfs_getattr,
691  	.setattr	= nfs_setattr,
692  };
693  
694  static const struct inode_operations nfs_file_inode_operations = {
695  	.permission	= nfs_permission,
696  	.getattr	= nfs_getattr,
697  	.setattr	= nfs_setattr,
698  };
699  
700  const struct nfs_rpc_ops nfs_v2_clientops = {
701  	.version	= 2,		       /* protocol version */
702  	.dentry_ops	= &nfs_dentry_operations,
703  	.dir_inode_ops	= &nfs_dir_inode_operations,
704  	.file_inode_ops	= &nfs_file_inode_operations,
705  	.file_ops	= &nfs_file_operations,
706  	.getroot	= nfs_proc_get_root,
707  	.submount	= nfs_submount,
708  	.try_mount	= nfs_try_mount,
709  	.getattr	= nfs_proc_getattr,
710  	.setattr	= nfs_proc_setattr,
711  	.lookup		= nfs_proc_lookup,
712  	.access		= NULL,		       /* access */
713  	.readlink	= nfs_proc_readlink,
714  	.create		= nfs_proc_create,
715  	.remove		= nfs_proc_remove,
716  	.unlink_setup	= nfs_proc_unlink_setup,
717  	.unlink_rpc_prepare = nfs_proc_unlink_rpc_prepare,
718  	.unlink_done	= nfs_proc_unlink_done,
719  	.rename_setup	= nfs_proc_rename_setup,
720  	.rename_rpc_prepare = nfs_proc_rename_rpc_prepare,
721  	.rename_done	= nfs_proc_rename_done,
722  	.link		= nfs_proc_link,
723  	.symlink	= nfs_proc_symlink,
724  	.mkdir		= nfs_proc_mkdir,
725  	.rmdir		= nfs_proc_rmdir,
726  	.readdir	= nfs_proc_readdir,
727  	.mknod		= nfs_proc_mknod,
728  	.statfs		= nfs_proc_statfs,
729  	.fsinfo		= nfs_proc_fsinfo,
730  	.pathconf	= nfs_proc_pathconf,
731  	.decode_dirent	= nfs2_decode_dirent,
732  	.pgio_rpc_prepare = nfs_proc_pgio_rpc_prepare,
733  	.read_setup	= nfs_proc_read_setup,
734  	.read_done	= nfs_read_done,
735  	.write_setup	= nfs_proc_write_setup,
736  	.write_done	= nfs_write_done,
737  	.commit_setup	= nfs_proc_commit_setup,
738  	.commit_rpc_prepare = nfs_proc_commit_rpc_prepare,
739  	.lock		= nfs_proc_lock,
740  	.lock_check_bounds = nfs_lock_check_bounds,
741  	.close_context	= nfs_close_context,
742  	.have_delegation = nfs_have_delegation,
743  	.return_delegation = nfs_return_delegation,
744  	.alloc_client	= nfs_alloc_client,
745  	.init_client	= nfs_init_client,
746  	.free_client	= nfs_free_client,
747  	.create_server	= nfs_create_server,
748  	.clone_server	= nfs_clone_server,
749  };
750