xref: /openbmc/linux/fs/nfs/proc.c (revision c16c6655)
1  // SPDX-License-Identifier: GPL-2.0
2  /*
3   *  linux/fs/nfs/proc.c
4   *
5   *  Copyright (C) 1992, 1993, 1994  Rick Sladkey
6   *
7   *  OS-independent nfs remote procedure call functions
8   *
9   *  Tuned by Alan Cox <A.Cox@swansea.ac.uk> for >3K buffers
10   *  so at last we can have decent(ish) throughput off a
11   *  Sun server.
12   *
13   *  Coding optimized and cleaned up by Florian La Roche.
14   *  Note: Error returns are optimized for NFS_OK, which isn't translated via
15   *  nfs_stat_to_errno(), but happens to be already the right return code.
16   *
17   *  Also, the code currently doesn't check the size of the packet, when
18   *  it decodes the packet.
19   *
20   *  Feel free to fix it and mail me the diffs if it worries you.
21   *
22   *  Completely rewritten to support the new RPC call interface;
23   *  rewrote and moved the entire XDR stuff to xdr.c
24   *  --Olaf Kirch June 1996
25   *
26   *  The code below initializes all auto variables explicitly, otherwise
27   *  it will fail to work as a module (gcc generates a memset call for an
28   *  incomplete struct).
29   */
30  
31  #include <linux/types.h>
32  #include <linux/param.h>
33  #include <linux/time.h>
34  #include <linux/mm.h>
35  #include <linux/errno.h>
36  #include <linux/string.h>
37  #include <linux/in.h>
38  #include <linux/pagemap.h>
39  #include <linux/sunrpc/clnt.h>
40  #include <linux/nfs.h>
41  #include <linux/nfs2.h>
42  #include <linux/nfs_fs.h>
43  #include <linux/nfs_page.h>
44  #include <linux/lockd/bind.h>
45  #include <linux/freezer.h>
46  #include "internal.h"
47  
48  #define NFSDBG_FACILITY		NFSDBG_PROC
49  
50  /*
51   * Bare-bones access to getattr: this is for nfs_read_super.
52   */
53  static int
54  nfs_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
55  		  struct nfs_fsinfo *info)
56  {
57  	struct nfs_fattr *fattr = info->fattr;
58  	struct nfs2_fsstat fsinfo;
59  	struct rpc_message msg = {
60  		.rpc_proc	= &nfs_procedures[NFSPROC_GETATTR],
61  		.rpc_argp	= fhandle,
62  		.rpc_resp	= fattr,
63  	};
64  	int status;
65  
66  	dprintk("%s: call getattr\n", __func__);
67  	nfs_fattr_init(fattr);
68  	status = rpc_call_sync(server->client, &msg, 0);
69  	/* Retry with default authentication if different */
70  	if (status && server->nfs_client->cl_rpcclient != server->client)
71  		status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
72  	dprintk("%s: reply getattr: %d\n", __func__, status);
73  	if (status)
74  		return status;
75  	dprintk("%s: call statfs\n", __func__);
76  	msg.rpc_proc = &nfs_procedures[NFSPROC_STATFS];
77  	msg.rpc_resp = &fsinfo;
78  	status = rpc_call_sync(server->client, &msg, 0);
79  	/* Retry with default authentication if different */
80  	if (status && server->nfs_client->cl_rpcclient != server->client)
81  		status = rpc_call_sync(server->nfs_client->cl_rpcclient, &msg, 0);
82  	dprintk("%s: reply statfs: %d\n", __func__, status);
83  	if (status)
84  		return status;
85  	info->rtmax  = NFS_MAXDATA;
86  	info->rtpref = fsinfo.tsize;
87  	info->rtmult = fsinfo.bsize;
88  	info->wtmax  = NFS_MAXDATA;
89  	info->wtpref = fsinfo.tsize;
90  	info->wtmult = fsinfo.bsize;
91  	info->dtpref = fsinfo.tsize;
92  	info->maxfilesize = 0x7FFFFFFF;
93  	info->lease_time = 0;
94  	return 0;
95  }
96  
97  /*
98   * One function for each procedure in the NFS protocol.
99   */
100  static int
101  nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
102  		struct nfs_fattr *fattr, struct nfs4_label *label,
103  		struct inode *inode)
104  {
105  	struct rpc_message msg = {
106  		.rpc_proc	= &nfs_procedures[NFSPROC_GETATTR],
107  		.rpc_argp	= fhandle,
108  		.rpc_resp	= fattr,
109  	};
110  	int	status;
111  
112  	dprintk("NFS call  getattr\n");
113  	nfs_fattr_init(fattr);
114  	status = rpc_call_sync(server->client, &msg, 0);
115  	dprintk("NFS reply getattr: %d\n", status);
116  	return status;
117  }
118  
119  static int
120  nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
121  		 struct iattr *sattr)
122  {
123  	struct inode *inode = d_inode(dentry);
124  	struct nfs_sattrargs	arg = {
125  		.fh	= NFS_FH(inode),
126  		.sattr	= sattr
127  	};
128  	struct rpc_message msg = {
129  		.rpc_proc	= &nfs_procedures[NFSPROC_SETATTR],
130  		.rpc_argp	= &arg,
131  		.rpc_resp	= fattr,
132  	};
133  	int	status;
134  
135  	/* Mask out the non-modebit related stuff from attr->ia_mode */
136  	sattr->ia_mode &= S_IALLUGO;
137  
138  	dprintk("NFS call  setattr\n");
139  	if (sattr->ia_valid & ATTR_FILE)
140  		msg.rpc_cred = nfs_file_cred(sattr->ia_file);
141  	nfs_fattr_init(fattr);
142  	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
143  	if (status == 0)
144  		nfs_setattr_update_inode(inode, sattr, fattr);
145  	dprintk("NFS reply setattr: %d\n", status);
146  	return status;
147  }
148  
149  static int
150  nfs_proc_lookup(struct inode *dir, const struct qstr *name,
151  		struct nfs_fh *fhandle, struct nfs_fattr *fattr,
152  		struct nfs4_label *label)
153  {
154  	struct nfs_diropargs	arg = {
155  		.fh		= NFS_FH(dir),
156  		.name		= name->name,
157  		.len		= name->len
158  	};
159  	struct nfs_diropok	res = {
160  		.fh		= fhandle,
161  		.fattr		= fattr
162  	};
163  	struct rpc_message msg = {
164  		.rpc_proc	= &nfs_procedures[NFSPROC_LOOKUP],
165  		.rpc_argp	= &arg,
166  		.rpc_resp	= &res,
167  	};
168  	int			status;
169  
170  	dprintk("NFS call  lookup %s\n", name->name);
171  	nfs_fattr_init(fattr);
172  	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
173  	dprintk("NFS reply lookup: %d\n", status);
174  	return status;
175  }
176  
177  static int nfs_proc_readlink(struct inode *inode, struct page *page,
178  		unsigned int pgbase, unsigned int pglen)
179  {
180  	struct nfs_readlinkargs	args = {
181  		.fh		= NFS_FH(inode),
182  		.pgbase		= pgbase,
183  		.pglen		= pglen,
184  		.pages		= &page
185  	};
186  	struct rpc_message msg = {
187  		.rpc_proc	= &nfs_procedures[NFSPROC_READLINK],
188  		.rpc_argp	= &args,
189  	};
190  	int			status;
191  
192  	dprintk("NFS call  readlink\n");
193  	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
194  	dprintk("NFS reply readlink: %d\n", status);
195  	return status;
196  }
197  
198  struct nfs_createdata {
199  	struct nfs_createargs arg;
200  	struct nfs_diropok res;
201  	struct nfs_fh fhandle;
202  	struct nfs_fattr fattr;
203  };
204  
205  static struct nfs_createdata *nfs_alloc_createdata(struct inode *dir,
206  		struct dentry *dentry, struct iattr *sattr)
207  {
208  	struct nfs_createdata *data;
209  
210  	data = kmalloc(sizeof(*data), GFP_KERNEL);
211  
212  	if (data != NULL) {
213  		data->arg.fh = NFS_FH(dir);
214  		data->arg.name = dentry->d_name.name;
215  		data->arg.len = dentry->d_name.len;
216  		data->arg.sattr = sattr;
217  		nfs_fattr_init(&data->fattr);
218  		data->fhandle.size = 0;
219  		data->res.fh = &data->fhandle;
220  		data->res.fattr = &data->fattr;
221  	}
222  	return data;
223  };
224  
225  static void nfs_free_createdata(const struct nfs_createdata *data)
226  {
227  	kfree(data);
228  }
229  
230  static int
231  nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
232  		int flags)
233  {
234  	struct nfs_createdata *data;
235  	struct rpc_message msg = {
236  		.rpc_proc	= &nfs_procedures[NFSPROC_CREATE],
237  	};
238  	int status = -ENOMEM;
239  
240  	dprintk("NFS call  create %pd\n", dentry);
241  	data = nfs_alloc_createdata(dir, dentry, sattr);
242  	if (data == NULL)
243  		goto out;
244  	msg.rpc_argp = &data->arg;
245  	msg.rpc_resp = &data->res;
246  	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
247  	nfs_mark_for_revalidate(dir);
248  	if (status == 0)
249  		status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
250  	nfs_free_createdata(data);
251  out:
252  	dprintk("NFS reply create: %d\n", status);
253  	return status;
254  }
255  
256  /*
257   * In NFSv2, mknod is grafted onto the create call.
258   */
259  static int
260  nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
261  	       dev_t rdev)
262  {
263  	struct nfs_createdata *data;
264  	struct rpc_message msg = {
265  		.rpc_proc	= &nfs_procedures[NFSPROC_CREATE],
266  	};
267  	umode_t mode;
268  	int status = -ENOMEM;
269  
270  	dprintk("NFS call  mknod %pd\n", dentry);
271  
272  	mode = sattr->ia_mode;
273  	if (S_ISFIFO(mode)) {
274  		sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR;
275  		sattr->ia_valid &= ~ATTR_SIZE;
276  	} else if (S_ISCHR(mode) || S_ISBLK(mode)) {
277  		sattr->ia_valid |= ATTR_SIZE;
278  		sattr->ia_size = new_encode_dev(rdev);/* get out your barf bag */
279  	}
280  
281  	data = nfs_alloc_createdata(dir, dentry, sattr);
282  	if (data == NULL)
283  		goto out;
284  	msg.rpc_argp = &data->arg;
285  	msg.rpc_resp = &data->res;
286  
287  	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
288  	nfs_mark_for_revalidate(dir);
289  
290  	if (status == -EINVAL && S_ISFIFO(mode)) {
291  		sattr->ia_mode = mode;
292  		nfs_fattr_init(data->res.fattr);
293  		status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
294  	}
295  	if (status == 0)
296  		status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
297  	nfs_free_createdata(data);
298  out:
299  	dprintk("NFS reply mknod: %d\n", status);
300  	return status;
301  }
302  
303  static int
304  nfs_proc_remove(struct inode *dir, struct dentry *dentry)
305  {
306  	struct nfs_removeargs arg = {
307  		.fh = NFS_FH(dir),
308  		.name = dentry->d_name,
309  	};
310  	struct rpc_message msg = {
311  		.rpc_proc = &nfs_procedures[NFSPROC_REMOVE],
312  		.rpc_argp = &arg,
313  	};
314  	int			status;
315  
316  	dprintk("NFS call  remove %pd2\n",dentry);
317  	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
318  	nfs_mark_for_revalidate(dir);
319  
320  	dprintk("NFS reply remove: %d\n", status);
321  	return status;
322  }
323  
324  static void
325  nfs_proc_unlink_setup(struct rpc_message *msg,
326  		struct dentry *dentry,
327  		struct inode *inode)
328  {
329  	msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
330  }
331  
332  static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
333  {
334  	rpc_call_start(task);
335  }
336  
337  static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
338  {
339  	nfs_mark_for_revalidate(dir);
340  	return 1;
341  }
342  
343  static void
344  nfs_proc_rename_setup(struct rpc_message *msg,
345  		struct dentry *old_dentry,
346  		struct dentry *new_dentry)
347  {
348  	msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME];
349  }
350  
351  static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
352  {
353  	rpc_call_start(task);
354  }
355  
356  static int
357  nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
358  		     struct inode *new_dir)
359  {
360  	nfs_mark_for_revalidate(old_dir);
361  	nfs_mark_for_revalidate(new_dir);
362  	return 1;
363  }
364  
365  static int
366  nfs_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
367  {
368  	struct nfs_linkargs	arg = {
369  		.fromfh		= NFS_FH(inode),
370  		.tofh		= NFS_FH(dir),
371  		.toname		= name->name,
372  		.tolen		= name->len
373  	};
374  	struct rpc_message msg = {
375  		.rpc_proc	= &nfs_procedures[NFSPROC_LINK],
376  		.rpc_argp	= &arg,
377  	};
378  	int			status;
379  
380  	dprintk("NFS call  link %s\n", name->name);
381  	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
382  	nfs_mark_for_revalidate(inode);
383  	nfs_mark_for_revalidate(dir);
384  	dprintk("NFS reply link: %d\n", status);
385  	return status;
386  }
387  
388  static int
389  nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
390  		 unsigned int len, struct iattr *sattr)
391  {
392  	struct nfs_fh *fh;
393  	struct nfs_fattr *fattr;
394  	struct nfs_symlinkargs	arg = {
395  		.fromfh		= NFS_FH(dir),
396  		.fromname	= dentry->d_name.name,
397  		.fromlen	= dentry->d_name.len,
398  		.pages		= &page,
399  		.pathlen	= len,
400  		.sattr		= sattr
401  	};
402  	struct rpc_message msg = {
403  		.rpc_proc	= &nfs_procedures[NFSPROC_SYMLINK],
404  		.rpc_argp	= &arg,
405  	};
406  	int status = -ENAMETOOLONG;
407  
408  	dprintk("NFS call  symlink %pd\n", dentry);
409  
410  	if (len > NFS2_MAXPATHLEN)
411  		goto out;
412  
413  	fh = nfs_alloc_fhandle();
414  	fattr = nfs_alloc_fattr();
415  	status = -ENOMEM;
416  	if (fh == NULL || fattr == NULL)
417  		goto out_free;
418  
419  	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
420  	nfs_mark_for_revalidate(dir);
421  
422  	/*
423  	 * V2 SYMLINK requests don't return any attributes.  Setting the
424  	 * filehandle size to zero indicates to nfs_instantiate that it
425  	 * should fill in the data with a LOOKUP call on the wire.
426  	 */
427  	if (status == 0)
428  		status = nfs_instantiate(dentry, fh, fattr, NULL);
429  
430  out_free:
431  	nfs_free_fattr(fattr);
432  	nfs_free_fhandle(fh);
433  out:
434  	dprintk("NFS reply symlink: %d\n", status);
435  	return status;
436  }
437  
438  static int
439  nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
440  {
441  	struct nfs_createdata *data;
442  	struct rpc_message msg = {
443  		.rpc_proc	= &nfs_procedures[NFSPROC_MKDIR],
444  	};
445  	int status = -ENOMEM;
446  
447  	dprintk("NFS call  mkdir %pd\n", dentry);
448  	data = nfs_alloc_createdata(dir, dentry, sattr);
449  	if (data == NULL)
450  		goto out;
451  	msg.rpc_argp = &data->arg;
452  	msg.rpc_resp = &data->res;
453  
454  	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
455  	nfs_mark_for_revalidate(dir);
456  	if (status == 0)
457  		status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
458  	nfs_free_createdata(data);
459  out:
460  	dprintk("NFS reply mkdir: %d\n", status);
461  	return status;
462  }
463  
464  static int
465  nfs_proc_rmdir(struct inode *dir, const struct qstr *name)
466  {
467  	struct nfs_diropargs	arg = {
468  		.fh		= NFS_FH(dir),
469  		.name		= name->name,
470  		.len		= name->len
471  	};
472  	struct rpc_message msg = {
473  		.rpc_proc	= &nfs_procedures[NFSPROC_RMDIR],
474  		.rpc_argp	= &arg,
475  	};
476  	int			status;
477  
478  	dprintk("NFS call  rmdir %s\n", name->name);
479  	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
480  	nfs_mark_for_revalidate(dir);
481  	dprintk("NFS reply rmdir: %d\n", status);
482  	return status;
483  }
484  
485  /*
486   * The READDIR implementation is somewhat hackish - we pass a temporary
487   * buffer to the encode function, which installs it in the receive
488   * the receive iovec. The decode function just parses the reply to make
489   * sure it is syntactically correct; the entries itself are decoded
490   * from nfs_readdir by calling the decode_entry function directly.
491   */
492  static int
493  nfs_proc_readdir(struct dentry *dentry, const struct cred *cred,
494  		 u64 cookie, struct page **pages, unsigned int count, bool plus)
495  {
496  	struct inode		*dir = d_inode(dentry);
497  	struct nfs_readdirargs	arg = {
498  		.fh		= NFS_FH(dir),
499  		.cookie		= cookie,
500  		.count		= count,
501  		.pages		= pages,
502  	};
503  	struct rpc_message	msg = {
504  		.rpc_proc	= &nfs_procedures[NFSPROC_READDIR],
505  		.rpc_argp	= &arg,
506  		.rpc_cred	= cred,
507  	};
508  	int			status;
509  
510  	dprintk("NFS call  readdir %d\n", (unsigned int)cookie);
511  	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
512  
513  	nfs_invalidate_atime(dir);
514  
515  	dprintk("NFS reply readdir: %d\n", status);
516  	return status;
517  }
518  
519  static int
520  nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
521  			struct nfs_fsstat *stat)
522  {
523  	struct nfs2_fsstat fsinfo;
524  	struct rpc_message msg = {
525  		.rpc_proc	= &nfs_procedures[NFSPROC_STATFS],
526  		.rpc_argp	= fhandle,
527  		.rpc_resp	= &fsinfo,
528  	};
529  	int	status;
530  
531  	dprintk("NFS call  statfs\n");
532  	nfs_fattr_init(stat->fattr);
533  	status = rpc_call_sync(server->client, &msg, 0);
534  	dprintk("NFS reply statfs: %d\n", status);
535  	if (status)
536  		goto out;
537  	stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
538  	stat->fbytes = (u64)fsinfo.bfree  * fsinfo.bsize;
539  	stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
540  	stat->tfiles = 0;
541  	stat->ffiles = 0;
542  	stat->afiles = 0;
543  out:
544  	return status;
545  }
546  
547  static int
548  nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
549  			struct nfs_fsinfo *info)
550  {
551  	struct nfs2_fsstat fsinfo;
552  	struct rpc_message msg = {
553  		.rpc_proc	= &nfs_procedures[NFSPROC_STATFS],
554  		.rpc_argp	= fhandle,
555  		.rpc_resp	= &fsinfo,
556  	};
557  	int	status;
558  
559  	dprintk("NFS call  fsinfo\n");
560  	nfs_fattr_init(info->fattr);
561  	status = rpc_call_sync(server->client, &msg, 0);
562  	dprintk("NFS reply fsinfo: %d\n", status);
563  	if (status)
564  		goto out;
565  	info->rtmax  = NFS_MAXDATA;
566  	info->rtpref = fsinfo.tsize;
567  	info->rtmult = fsinfo.bsize;
568  	info->wtmax  = NFS_MAXDATA;
569  	info->wtpref = fsinfo.tsize;
570  	info->wtmult = fsinfo.bsize;
571  	info->dtpref = fsinfo.tsize;
572  	info->maxfilesize = 0x7FFFFFFF;
573  	info->lease_time = 0;
574  out:
575  	return status;
576  }
577  
578  static int
579  nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
580  		  struct nfs_pathconf *info)
581  {
582  	info->max_link = 0;
583  	info->max_namelen = NFS2_MAXNAMLEN;
584  	return 0;
585  }
586  
587  static int nfs_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
588  {
589  	struct inode *inode = hdr->inode;
590  
591  	nfs_invalidate_atime(inode);
592  	if (task->tk_status >= 0) {
593  		nfs_refresh_inode(inode, hdr->res.fattr);
594  		/* Emulate the eof flag, which isn't normally needed in NFSv2
595  		 * as it is guaranteed to always return the file attributes
596  		 */
597  		if ((hdr->res.count == 0 && hdr->args.count > 0) ||
598  		    hdr->args.offset + hdr->res.count >= hdr->res.fattr->size)
599  			hdr->res.eof = 1;
600  	}
601  	return 0;
602  }
603  
604  static void nfs_proc_read_setup(struct nfs_pgio_header *hdr,
605  				struct rpc_message *msg)
606  {
607  	msg->rpc_proc = &nfs_procedures[NFSPROC_READ];
608  }
609  
610  static int nfs_proc_pgio_rpc_prepare(struct rpc_task *task,
611  				     struct nfs_pgio_header *hdr)
612  {
613  	rpc_call_start(task);
614  	return 0;
615  }
616  
617  static int nfs_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
618  {
619  	if (task->tk_status >= 0) {
620  		hdr->res.count = hdr->args.count;
621  		nfs_writeback_update_inode(hdr);
622  	}
623  	return 0;
624  }
625  
626  static void nfs_proc_write_setup(struct nfs_pgio_header *hdr,
627  				 struct rpc_message *msg,
628  				 struct rpc_clnt **clnt)
629  {
630  	/* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
631  	hdr->args.stable = NFS_FILE_SYNC;
632  	msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE];
633  }
634  
635  static void nfs_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
636  {
637  	BUG();
638  }
639  
640  static void
641  nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg,
642  			struct rpc_clnt **clnt)
643  {
644  	BUG();
645  }
646  
647  static int
648  nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
649  {
650  	struct inode *inode = file_inode(filp);
651  
652  	return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl, NULL);
653  }
654  
655  /* Helper functions for NFS lock bounds checking */
656  #define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL)
657  static int nfs_lock_check_bounds(const struct file_lock *fl)
658  {
659  	__s32 start, end;
660  
661  	start = (__s32)fl->fl_start;
662  	if ((loff_t)start != fl->fl_start)
663  		goto out_einval;
664  
665  	if (fl->fl_end != OFFSET_MAX) {
666  		end = (__s32)fl->fl_end;
667  		if ((loff_t)end != fl->fl_end)
668  			goto out_einval;
669  	} else
670  		end = NFS_LOCK32_OFFSET_MAX;
671  
672  	if (start < 0 || start > end)
673  		goto out_einval;
674  	return 0;
675  out_einval:
676  	return -EINVAL;
677  }
678  
679  static int nfs_have_delegation(struct inode *inode, fmode_t flags)
680  {
681  	return 0;
682  }
683  
684  static const struct inode_operations nfs_dir_inode_operations = {
685  	.create		= nfs_create,
686  	.lookup		= nfs_lookup,
687  	.link		= nfs_link,
688  	.unlink		= nfs_unlink,
689  	.symlink	= nfs_symlink,
690  	.mkdir		= nfs_mkdir,
691  	.rmdir		= nfs_rmdir,
692  	.mknod		= nfs_mknod,
693  	.rename		= nfs_rename,
694  	.permission	= nfs_permission,
695  	.getattr	= nfs_getattr,
696  	.setattr	= nfs_setattr,
697  };
698  
699  static const struct inode_operations nfs_file_inode_operations = {
700  	.permission	= nfs_permission,
701  	.getattr	= nfs_getattr,
702  	.setattr	= nfs_setattr,
703  };
704  
705  const struct nfs_rpc_ops nfs_v2_clientops = {
706  	.version	= 2,		       /* protocol version */
707  	.dentry_ops	= &nfs_dentry_operations,
708  	.dir_inode_ops	= &nfs_dir_inode_operations,
709  	.file_inode_ops	= &nfs_file_inode_operations,
710  	.file_ops	= &nfs_file_operations,
711  	.getroot	= nfs_proc_get_root,
712  	.submount	= nfs_submount,
713  	.try_mount	= nfs_try_mount,
714  	.getattr	= nfs_proc_getattr,
715  	.setattr	= nfs_proc_setattr,
716  	.lookup		= nfs_proc_lookup,
717  	.access		= NULL,		       /* access */
718  	.readlink	= nfs_proc_readlink,
719  	.create		= nfs_proc_create,
720  	.remove		= nfs_proc_remove,
721  	.unlink_setup	= nfs_proc_unlink_setup,
722  	.unlink_rpc_prepare = nfs_proc_unlink_rpc_prepare,
723  	.unlink_done	= nfs_proc_unlink_done,
724  	.rename_setup	= nfs_proc_rename_setup,
725  	.rename_rpc_prepare = nfs_proc_rename_rpc_prepare,
726  	.rename_done	= nfs_proc_rename_done,
727  	.link		= nfs_proc_link,
728  	.symlink	= nfs_proc_symlink,
729  	.mkdir		= nfs_proc_mkdir,
730  	.rmdir		= nfs_proc_rmdir,
731  	.readdir	= nfs_proc_readdir,
732  	.mknod		= nfs_proc_mknod,
733  	.statfs		= nfs_proc_statfs,
734  	.fsinfo		= nfs_proc_fsinfo,
735  	.pathconf	= nfs_proc_pathconf,
736  	.decode_dirent	= nfs2_decode_dirent,
737  	.pgio_rpc_prepare = nfs_proc_pgio_rpc_prepare,
738  	.read_setup	= nfs_proc_read_setup,
739  	.read_done	= nfs_read_done,
740  	.write_setup	= nfs_proc_write_setup,
741  	.write_done	= nfs_write_done,
742  	.commit_setup	= nfs_proc_commit_setup,
743  	.commit_rpc_prepare = nfs_proc_commit_rpc_prepare,
744  	.lock		= nfs_proc_lock,
745  	.lock_check_bounds = nfs_lock_check_bounds,
746  	.close_context	= nfs_close_context,
747  	.have_delegation = nfs_have_delegation,
748  	.alloc_client	= nfs_alloc_client,
749  	.init_client	= nfs_init_client,
750  	.free_client	= nfs_free_client,
751  	.create_server	= nfs_create_server,
752  	.clone_server	= nfs_clone_server,
753  };
754