proc.c

  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 */
 53static int
 54nfs_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	info->change_attr_type = NFS4_CHANGE_TYPE_IS_UNDEFINED;
 95	info->xattr_support = 0;
 96	return 0;
 97}
 98
 99/*
100 * One function for each procedure in the NFS protocol.
101 */
102static int
103nfs_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
104		struct nfs_fattr *fattr, struct inode *inode)
105{
106	struct rpc_message msg = {
107		.rpc_proc	= &nfs_procedures[NFSPROC_GETATTR],
108		.rpc_argp	= fhandle,
109		.rpc_resp	= fattr,
110	};
111	int	status;
112	unsigned short task_flags = 0;
113
114	/* Is this is an attribute revalidation, subject to softreval? */
115	if (inode && (server->flags & NFS_MOUNT_SOFTREVAL))
116		task_flags |= RPC_TASK_TIMEOUT;
117
118	dprintk("NFS call  getattr\n");
119	nfs_fattr_init(fattr);
120	status = rpc_call_sync(server->client, &msg, task_flags);
121	dprintk("NFS reply getattr: %d\n", status);
122	return status;
123}
124
125static int
126nfs_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
127		 struct iattr *sattr)
128{
129	struct inode *inode = d_inode(dentry);
130	struct nfs_sattrargs	arg = { 
131		.fh	= NFS_FH(inode),
132		.sattr	= sattr
133	};
134	struct rpc_message msg = {
135		.rpc_proc	= &nfs_procedures[NFSPROC_SETATTR],
136		.rpc_argp	= &arg,
137		.rpc_resp	= fattr,
138	};
139	int	status;
140
141	/* Mask out the non-modebit related stuff from attr->ia_mode */
142	sattr->ia_mode &= S_IALLUGO;
143
144	dprintk("NFS call  setattr\n");
145	if (sattr->ia_valid & ATTR_FILE)
146		msg.rpc_cred = nfs_file_cred(sattr->ia_file);
147	nfs_fattr_init(fattr);
148	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
149	if (status == 0)
150		nfs_setattr_update_inode(inode, sattr, fattr);
151	dprintk("NFS reply setattr: %d\n", status);
152	return status;
153}
154
155static int
156nfs_proc_lookup(struct inode *dir, struct dentry *dentry, const struct qstr *name,
157		struct nfs_fh *fhandle, struct nfs_fattr *fattr)
158{
159	struct nfs_diropargs	arg = {
160		.fh		= NFS_FH(dir),
161		.name		= name->name,
162		.len		= name->len
163	};
164	struct nfs_diropok	res = {
165		.fh		= fhandle,
166		.fattr		= fattr
167	};
168	struct rpc_message msg = {
169		.rpc_proc	= &nfs_procedures[NFSPROC_LOOKUP],
170		.rpc_argp	= &arg,
171		.rpc_resp	= &res,
172	};
173	int			status;
174	unsigned short task_flags = 0;
175
176	/* Is this is an attribute revalidation, subject to softreval? */
177	if (nfs_lookup_is_soft_revalidate(dentry))
178		task_flags |= RPC_TASK_TIMEOUT;
179
180	dprintk("NFS call  lookup %pd2\n", dentry);
181	nfs_fattr_init(fattr);
182	status = rpc_call_sync(NFS_CLIENT(dir), &msg, task_flags);
183	dprintk("NFS reply lookup: %d\n", status);
184	return status;
185}
186
187static int nfs_proc_readlink(struct inode *inode, struct page *page,
188		unsigned int pgbase, unsigned int pglen)
189{
190	struct nfs_readlinkargs	args = {
191		.fh		= NFS_FH(inode),
192		.pgbase		= pgbase,
193		.pglen		= pglen,
194		.pages		= &page
195	};
196	struct rpc_message msg = {
197		.rpc_proc	= &nfs_procedures[NFSPROC_READLINK],
198		.rpc_argp	= &args,
199	};
200	int			status;
201
202	dprintk("NFS call  readlink\n");
203	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
204	dprintk("NFS reply readlink: %d\n", status);
205	return status;
206}
207
208struct nfs_createdata {
209	struct nfs_createargs arg;
210	struct nfs_diropok res;
211	struct nfs_fh fhandle;
212	struct nfs_fattr fattr;
213};
214
215static struct nfs_createdata *nfs_alloc_createdata(struct inode *dir,
216		struct dentry *dentry, struct iattr *sattr)
217{
218	struct nfs_createdata *data;
219
220	data = kmalloc(sizeof(*data), GFP_KERNEL);
221
222	if (data != NULL) {
223		data->arg.fh = NFS_FH(dir);
224		data->arg.name = dentry->d_name.name;
225		data->arg.len = dentry->d_name.len;
226		data->arg.sattr = sattr;
227		nfs_fattr_init(&data->fattr);
228		data->fhandle.size = 0;
229		data->res.fh = &data->fhandle;
230		data->res.fattr = &data->fattr;
231	}
232	return data;
233};
234
235static void nfs_free_createdata(const struct nfs_createdata *data)
236{
237	kfree(data);
238}
239
240static int
241nfs_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
242		int flags)
243{
244	struct nfs_createdata *data;
245	struct rpc_message msg = {
246		.rpc_proc	= &nfs_procedures[NFSPROC_CREATE],
247	};
248	int status = -ENOMEM;
249
250	dprintk("NFS call  create %pd\n", dentry);
251	data = nfs_alloc_createdata(dir, dentry, sattr);
252	if (data == NULL)
253		goto out;
254	msg.rpc_argp = &data->arg;
255	msg.rpc_resp = &data->res;
256	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
257	nfs_mark_for_revalidate(dir);
258	if (status == 0)
259		status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
260	nfs_free_createdata(data);
261out:
262	dprintk("NFS reply create: %d\n", status);
263	return status;
264}
265
266/*
267 * In NFSv2, mknod is grafted onto the create call.
268 */
269static int
270nfs_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
271	       dev_t rdev)
272{
273	struct nfs_createdata *data;
274	struct rpc_message msg = {
275		.rpc_proc	= &nfs_procedures[NFSPROC_CREATE],
276	};
277	umode_t mode;
278	int status = -ENOMEM;
279
280	dprintk("NFS call  mknod %pd\n", dentry);
281
282	mode = sattr->ia_mode;
283	if (S_ISFIFO(mode)) {
284		sattr->ia_mode = (mode & ~S_IFMT) | S_IFCHR;
285		sattr->ia_valid &= ~ATTR_SIZE;
286	} else if (S_ISCHR(mode) || S_ISBLK(mode)) {
287		sattr->ia_valid |= ATTR_SIZE;
288		sattr->ia_size = new_encode_dev(rdev);/* get out your barf bag */
289	}
290
291	data = nfs_alloc_createdata(dir, dentry, sattr);
292	if (data == NULL)
293		goto out;
294	msg.rpc_argp = &data->arg;
295	msg.rpc_resp = &data->res;
296
297	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
298	nfs_mark_for_revalidate(dir);
299
300	if (status == -EINVAL && S_ISFIFO(mode)) {
301		sattr->ia_mode = mode;
302		nfs_fattr_init(data->res.fattr);
303		status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
304	}
305	if (status == 0)
306		status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
307	nfs_free_createdata(data);
308out:
309	dprintk("NFS reply mknod: %d\n", status);
310	return status;
311}
312  
313static int
314nfs_proc_remove(struct inode *dir, struct dentry *dentry)
315{
316	struct nfs_removeargs arg = {
317		.fh = NFS_FH(dir),
318		.name = dentry->d_name,
319	};
320	struct rpc_message msg = { 
321		.rpc_proc = &nfs_procedures[NFSPROC_REMOVE],
322		.rpc_argp = &arg,
323	};
324	int			status;
325
326	dprintk("NFS call  remove %pd2\n",dentry);
327	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
328	nfs_mark_for_revalidate(dir);
329
330	dprintk("NFS reply remove: %d\n", status);
331	return status;
332}
333
334static void
335nfs_proc_unlink_setup(struct rpc_message *msg,
336		struct dentry *dentry,
337		struct inode *inode)
338{
339	msg->rpc_proc = &nfs_procedures[NFSPROC_REMOVE];
340}
341
342static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
343{
344	rpc_call_start(task);
345}
346
347static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
348{
349	nfs_mark_for_revalidate(dir);
350	return 1;
351}
352
353static void
354nfs_proc_rename_setup(struct rpc_message *msg,
355		struct dentry *old_dentry,
356		struct dentry *new_dentry,
357		struct inode *same_parent)
358{
359	msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME];
360}
361
362static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
363{
364	rpc_call_start(task);
365}
366
367static int
368nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
369		     struct inode *new_dir)
370{
371	nfs_mark_for_revalidate(old_dir);
372	nfs_mark_for_revalidate(new_dir);
373	return 1;
374}
375
376static int
377nfs_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
378{
379	struct nfs_linkargs	arg = {
380		.fromfh		= NFS_FH(inode),
381		.tofh		= NFS_FH(dir),
382		.toname		= name->name,
383		.tolen		= name->len
384	};
385	struct rpc_message msg = {
386		.rpc_proc	= &nfs_procedures[NFSPROC_LINK],
387		.rpc_argp	= &arg,
388	};
389	int			status;
390
391	dprintk("NFS call  link %s\n", name->name);
392	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
393	nfs_mark_for_revalidate(inode);
394	nfs_mark_for_revalidate(dir);
395	dprintk("NFS reply link: %d\n", status);
396	return status;
397}
398
399static int
400nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct folio *folio,
401		 unsigned int len, struct iattr *sattr)
402{
403	struct page *page = &folio->page;
404	struct nfs_fh *fh;
405	struct nfs_fattr *fattr;
406	struct nfs_symlinkargs	arg = {
407		.fromfh		= NFS_FH(dir),
408		.fromname	= dentry->d_name.name,
409		.fromlen	= dentry->d_name.len,
410		.pages		= &page,
411		.pathlen	= len,
412		.sattr		= sattr
413	};
414	struct rpc_message msg = {
415		.rpc_proc	= &nfs_procedures[NFSPROC_SYMLINK],
416		.rpc_argp	= &arg,
417	};
418	int status = -ENAMETOOLONG;
419
420	dprintk("NFS call  symlink %pd\n", dentry);
421
422	if (len > NFS2_MAXPATHLEN)
423		goto out;
424
425	fh = nfs_alloc_fhandle();
426	fattr = nfs_alloc_fattr();
427	status = -ENOMEM;
428	if (fh == NULL || fattr == NULL)
429		goto out_free;
430
431	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
432	nfs_mark_for_revalidate(dir);
433
434	/*
435	 * V2 SYMLINK requests don't return any attributes.  Setting the
436	 * filehandle size to zero indicates to nfs_instantiate that it
437	 * should fill in the data with a LOOKUP call on the wire.
438	 */
439	if (status == 0)
440		status = nfs_instantiate(dentry, fh, fattr);
441
442out_free:
443	nfs_free_fattr(fattr);
444	nfs_free_fhandle(fh);
445out:
446	dprintk("NFS reply symlink: %d\n", status);
447	return status;
448}
449
450static struct dentry *
451nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
452{
453	struct nfs_createdata *data;
454	struct rpc_message msg = {
455		.rpc_proc	= &nfs_procedures[NFSPROC_MKDIR],
456	};
457	struct dentry *alias = NULL;
458	int status = -ENOMEM;
459
460	dprintk("NFS call  mkdir %pd\n", dentry);
461	data = nfs_alloc_createdata(dir, dentry, sattr);
462	if (data == NULL)
463		goto out;
464	msg.rpc_argp = &data->arg;
465	msg.rpc_resp = &data->res;
466
467	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
468	nfs_mark_for_revalidate(dir);
469	if (status == 0) {
470		alias = nfs_add_or_obtain(dentry, data->res.fh, data->res.fattr);
471		status = PTR_ERR_OR_ZERO(alias);
472	} else
473		alias = ERR_PTR(status);
474	nfs_free_createdata(data);
475out:
476	dprintk("NFS reply mkdir: %d\n", status);
477	return alias;
478}
479
480static int
481nfs_proc_rmdir(struct inode *dir, const struct qstr *name)
482{
483	struct nfs_diropargs	arg = {
484		.fh		= NFS_FH(dir),
485		.name		= name->name,
486		.len		= name->len
487	};
488	struct rpc_message msg = {
489		.rpc_proc	= &nfs_procedures[NFSPROC_RMDIR],
490		.rpc_argp	= &arg,
491	};
492	int			status;
493
494	dprintk("NFS call  rmdir %s\n", name->name);
495	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
496	nfs_mark_for_revalidate(dir);
497	dprintk("NFS reply rmdir: %d\n", status);
498	return status;
499}
500
501/*
502 * The READDIR implementation is somewhat hackish - we pass a temporary
503 * buffer to the encode function, which installs it in the receive
504 * the receive iovec. The decode function just parses the reply to make
505 * sure it is syntactically correct; the entries itself are decoded
506 * from nfs_readdir by calling the decode_entry function directly.
507 */
508static int nfs_proc_readdir(struct nfs_readdir_arg *nr_arg,
509			    struct nfs_readdir_res *nr_res)
510{
511	struct inode		*dir = d_inode(nr_arg->dentry);
512	struct nfs_readdirargs	arg = {
513		.fh		= NFS_FH(dir),
514		.cookie		= nr_arg->cookie,
515		.count		= nr_arg->page_len,
516		.pages		= nr_arg->pages,
517	};
518	struct rpc_message	msg = {
519		.rpc_proc	= &nfs_procedures[NFSPROC_READDIR],
520		.rpc_argp	= &arg,
521		.rpc_cred	= nr_arg->cred,
522	};
523	int			status;
524
525	dprintk("NFS call  readdir %llu\n", (unsigned long long)nr_arg->cookie);
526	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
527	nr_res->verf[0] = nr_res->verf[1] = 0;
528
529	nfs_invalidate_atime(dir);
530
531	dprintk("NFS reply readdir: %d\n", status);
532	return status;
533}
534
535static int
536nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
537			struct nfs_fsstat *stat)
538{
539	struct nfs2_fsstat fsinfo;
540	struct rpc_message msg = {
541		.rpc_proc	= &nfs_procedures[NFSPROC_STATFS],
542		.rpc_argp	= fhandle,
543		.rpc_resp	= &fsinfo,
544	};
545	int	status;
546
547	dprintk("NFS call  statfs\n");
548	nfs_fattr_init(stat->fattr);
549	status = rpc_call_sync(server->client, &msg, 0);
550	dprintk("NFS reply statfs: %d\n", status);
551	if (status)
552		goto out;
553	stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
554	stat->fbytes = (u64)fsinfo.bfree  * fsinfo.bsize;
555	stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
556	stat->tfiles = 0;
557	stat->ffiles = 0;
558	stat->afiles = 0;
559out:
560	return status;
561}
562
563static int
564nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
565			struct nfs_fsinfo *info)
566{
567	struct nfs2_fsstat fsinfo;
568	struct rpc_message msg = {
569		.rpc_proc	= &nfs_procedures[NFSPROC_STATFS],
570		.rpc_argp	= fhandle,
571		.rpc_resp	= &fsinfo,
572	};
573	int	status;
574
575	dprintk("NFS call  fsinfo\n");
576	nfs_fattr_init(info->fattr);
577	status = rpc_call_sync(server->client, &msg, 0);
578	dprintk("NFS reply fsinfo: %d\n", status);
579	if (status)
580		goto out;
581	info->rtmax  = NFS_MAXDATA;
582	info->rtpref = fsinfo.tsize;
583	info->rtmult = fsinfo.bsize;
584	info->wtmax  = NFS_MAXDATA;
585	info->wtpref = fsinfo.tsize;
586	info->wtmult = fsinfo.bsize;
587	info->dtpref = fsinfo.tsize;
588	info->maxfilesize = 0x7FFFFFFF;
589	info->lease_time = 0;
590out:
591	return status;
592}
593
594static int
595nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
596		  struct nfs_pathconf *info)
597{
598	info->max_link = 0;
599	info->max_namelen = NFS2_MAXNAMLEN;
600	return 0;
601}
602
603static int nfs_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
604{
605	struct inode *inode = hdr->inode;
606
607	nfs_invalidate_atime(inode);
608	if (task->tk_status >= 0) {
609		nfs_refresh_inode(inode, hdr->res.fattr);
610		/* Emulate the eof flag, which isn't normally needed in NFSv2
611		 * as it is guaranteed to always return the file attributes
612		 */
613		if ((hdr->res.count == 0 && hdr->args.count > 0) ||
614		    hdr->args.offset + hdr->res.count >= hdr->res.fattr->size)
615			hdr->res.eof = 1;
616	}
617	return 0;
618}
619
620static void nfs_proc_read_setup(struct nfs_pgio_header *hdr,
621				struct rpc_message *msg)
622{
623	msg->rpc_proc = &nfs_procedures[NFSPROC_READ];
624}
625
626static int nfs_proc_pgio_rpc_prepare(struct rpc_task *task,
627				     struct nfs_pgio_header *hdr)
628{
629	rpc_call_start(task);
630	return 0;
631}
632
633static int nfs_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
634{
635	if (task->tk_status >= 0) {
636		hdr->res.count = hdr->args.count;
637		nfs_writeback_update_inode(hdr);
638	}
639	return 0;
640}
641
642static void nfs_proc_write_setup(struct nfs_pgio_header *hdr,
643				 struct rpc_message *msg,
644				 struct rpc_clnt **clnt)
645{
646	/* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
647	hdr->args.stable = NFS_FILE_SYNC;
648	msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE];
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			struct rpc_clnt **clnt)
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, NULL);
669}
670
671/* Helper functions for NFS lock bounds checking */
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 type, int flags)
696{
697	return 0;
698}
699
700static int nfs_return_delegation(struct inode *inode)
701{
702	if (S_ISREG(inode->i_mode))
703		nfs_wb_all(inode);
704	return 0;
705}
706
707static const struct inode_operations nfs_dir_inode_operations = {
708	.create		= nfs_create,
709	.lookup		= nfs_lookup,
710	.atomic_open	= nfs_atomic_open_v23,
711	.link		= nfs_link,
712	.unlink		= nfs_unlink,
713	.symlink	= nfs_symlink,
714	.mkdir		= nfs_mkdir,
715	.rmdir		= nfs_rmdir,
716	.mknod		= nfs_mknod,
717	.rename		= nfs_rename,
718	.permission	= nfs_permission,
719	.getattr	= nfs_getattr,
720	.setattr	= nfs_setattr,
721};
722
723static const struct inode_operations nfs_file_inode_operations = {
724	.permission	= nfs_permission,
725	.getattr	= nfs_getattr,
726	.setattr	= nfs_setattr,
727};
728
729const struct nfs_rpc_ops nfs_v2_clientops = {
730	.version	= 2,		       /* protocol version */
731	.dentry_ops	= &nfs_dentry_operations,
732	.dir_inode_ops	= &nfs_dir_inode_operations,
733	.file_inode_ops	= &nfs_file_inode_operations,
734	.file_ops	= &nfs_file_operations,
735	.getroot	= nfs_proc_get_root,
736	.submount	= nfs_submount,
737	.try_get_tree	= nfs_try_get_tree,
738	.getattr	= nfs_proc_getattr,
739	.setattr	= nfs_proc_setattr,
740	.lookup		= nfs_proc_lookup,
741	.access		= NULL,		       /* access */
742	.readlink	= nfs_proc_readlink,
743	.create		= nfs_proc_create,
744	.remove		= nfs_proc_remove,
745	.unlink_setup	= nfs_proc_unlink_setup,
746	.unlink_rpc_prepare = nfs_proc_unlink_rpc_prepare,
747	.unlink_done	= nfs_proc_unlink_done,
748	.rename_setup	= nfs_proc_rename_setup,
749	.rename_rpc_prepare = nfs_proc_rename_rpc_prepare,
750	.rename_done	= nfs_proc_rename_done,
751	.link		= nfs_proc_link,
752	.symlink	= nfs_proc_symlink,
753	.mkdir		= nfs_proc_mkdir,
754	.rmdir		= nfs_proc_rmdir,
755	.readdir	= nfs_proc_readdir,
756	.mknod		= nfs_proc_mknod,
757	.statfs		= nfs_proc_statfs,
758	.fsinfo		= nfs_proc_fsinfo,
759	.pathconf	= nfs_proc_pathconf,
760	.decode_dirent	= nfs2_decode_dirent,
761	.pgio_rpc_prepare = nfs_proc_pgio_rpc_prepare,
762	.read_setup	= nfs_proc_read_setup,
763	.read_done	= nfs_read_done,
764	.write_setup	= nfs_proc_write_setup,
765	.write_done	= nfs_write_done,
766	.commit_setup	= nfs_proc_commit_setup,
767	.commit_rpc_prepare = nfs_proc_commit_rpc_prepare,
768	.lock		= nfs_proc_lock,
769	.lock_check_bounds = nfs_lock_check_bounds,
770	.close_context	= nfs_close_context,
771	.have_delegation = nfs_have_delegation,
772	.return_delegation = nfs_return_delegation,
773	.alloc_client	= nfs_alloc_client,
774	.init_client	= nfs_init_client,
775	.free_client	= nfs_free_client,
776	.create_server	= nfs_create_server,
777	.clone_server	= nfs_clone_server,
778};