xref: /linux/fs/nfs/proc.c (revision a1ff5a7d78a036d6c2178ee5acd6ba4946243800)
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
nfs_proc_get_root(struct nfs_server * server,struct nfs_fh * fhandle,struct nfs_fsinfo * info)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 	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  */
102 static int
nfs_proc_getattr(struct nfs_server * server,struct nfs_fh * fhandle,struct nfs_fattr * fattr,struct inode * inode)103 nfs_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 
125 static int
nfs_proc_setattr(struct dentry * dentry,struct nfs_fattr * fattr,struct iattr * sattr)126 nfs_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 
155 static int
nfs_proc_lookup(struct inode * dir,struct dentry * dentry,struct nfs_fh * fhandle,struct nfs_fattr * fattr)156 nfs_proc_lookup(struct inode *dir, struct dentry *dentry,
157 		struct nfs_fh *fhandle, struct nfs_fattr *fattr)
158 {
159 	struct nfs_diropargs	arg = {
160 		.fh		= NFS_FH(dir),
161 		.name		= dentry->d_name.name,
162 		.len		= dentry->d_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 
nfs_proc_readlink(struct inode * inode,struct page * page,unsigned int pgbase,unsigned int pglen)187 static 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 
208 struct nfs_createdata {
209 	struct nfs_createargs arg;
210 	struct nfs_diropok res;
211 	struct nfs_fh fhandle;
212 	struct nfs_fattr fattr;
213 };
214 
nfs_alloc_createdata(struct inode * dir,struct dentry * dentry,struct iattr * sattr)215 static 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 
nfs_free_createdata(const struct nfs_createdata * data)235 static void nfs_free_createdata(const struct nfs_createdata *data)
236 {
237 	kfree(data);
238 }
239 
240 static int
nfs_proc_create(struct inode * dir,struct dentry * dentry,struct iattr * sattr,int flags)241 nfs_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);
261 out:
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  */
269 static int
nfs_proc_mknod(struct inode * dir,struct dentry * dentry,struct iattr * sattr,dev_t rdev)270 nfs_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);
308 out:
309 	dprintk("NFS reply mknod: %d\n", status);
310 	return status;
311 }
312 
313 static int
nfs_proc_remove(struct inode * dir,struct dentry * dentry)314 nfs_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 
334 static void
nfs_proc_unlink_setup(struct rpc_message * msg,struct dentry * dentry,struct inode * inode)335 nfs_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 
nfs_proc_unlink_rpc_prepare(struct rpc_task * task,struct nfs_unlinkdata * data)342 static void nfs_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
343 {
344 	rpc_call_start(task);
345 }
346 
nfs_proc_unlink_done(struct rpc_task * task,struct inode * dir)347 static int nfs_proc_unlink_done(struct rpc_task *task, struct inode *dir)
348 {
349 	nfs_mark_for_revalidate(dir);
350 	return 1;
351 }
352 
353 static void
nfs_proc_rename_setup(struct rpc_message * msg,struct dentry * old_dentry,struct dentry * new_dentry)354 nfs_proc_rename_setup(struct rpc_message *msg,
355 		struct dentry *old_dentry,
356 		struct dentry *new_dentry)
357 {
358 	msg->rpc_proc = &nfs_procedures[NFSPROC_RENAME];
359 }
360 
nfs_proc_rename_rpc_prepare(struct rpc_task * task,struct nfs_renamedata * data)361 static void nfs_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
362 {
363 	rpc_call_start(task);
364 }
365 
366 static int
nfs_proc_rename_done(struct rpc_task * task,struct inode * old_dir,struct inode * new_dir)367 nfs_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
368 		     struct inode *new_dir)
369 {
370 	nfs_mark_for_revalidate(old_dir);
371 	nfs_mark_for_revalidate(new_dir);
372 	return 1;
373 }
374 
375 static int
nfs_proc_link(struct inode * inode,struct inode * dir,const struct qstr * name)376 nfs_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
377 {
378 	struct nfs_linkargs	arg = {
379 		.fromfh		= NFS_FH(inode),
380 		.tofh		= NFS_FH(dir),
381 		.toname		= name->name,
382 		.tolen		= name->len
383 	};
384 	struct rpc_message msg = {
385 		.rpc_proc	= &nfs_procedures[NFSPROC_LINK],
386 		.rpc_argp	= &arg,
387 	};
388 	int			status;
389 
390 	dprintk("NFS call  link %s\n", name->name);
391 	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
392 	nfs_mark_for_revalidate(inode);
393 	nfs_mark_for_revalidate(dir);
394 	dprintk("NFS reply link: %d\n", status);
395 	return status;
396 }
397 
398 static int
nfs_proc_symlink(struct inode * dir,struct dentry * dentry,struct folio * folio,unsigned int len,struct iattr * sattr)399 nfs_proc_symlink(struct inode *dir, struct dentry *dentry, struct folio *folio,
400 		 unsigned int len, struct iattr *sattr)
401 {
402 	struct page *page = &folio->page;
403 	struct nfs_fh *fh;
404 	struct nfs_fattr *fattr;
405 	struct nfs_symlinkargs	arg = {
406 		.fromfh		= NFS_FH(dir),
407 		.fromname	= dentry->d_name.name,
408 		.fromlen	= dentry->d_name.len,
409 		.pages		= &page,
410 		.pathlen	= len,
411 		.sattr		= sattr
412 	};
413 	struct rpc_message msg = {
414 		.rpc_proc	= &nfs_procedures[NFSPROC_SYMLINK],
415 		.rpc_argp	= &arg,
416 	};
417 	int status = -ENAMETOOLONG;
418 
419 	dprintk("NFS call  symlink %pd\n", dentry);
420 
421 	if (len > NFS2_MAXPATHLEN)
422 		goto out;
423 
424 	fh = nfs_alloc_fhandle();
425 	fattr = nfs_alloc_fattr();
426 	status = -ENOMEM;
427 	if (fh == NULL || fattr == NULL)
428 		goto out_free;
429 
430 	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
431 	nfs_mark_for_revalidate(dir);
432 
433 	/*
434 	 * V2 SYMLINK requests don't return any attributes.  Setting the
435 	 * filehandle size to zero indicates to nfs_instantiate that it
436 	 * should fill in the data with a LOOKUP call on the wire.
437 	 */
438 	if (status == 0)
439 		status = nfs_instantiate(dentry, fh, fattr);
440 
441 out_free:
442 	nfs_free_fattr(fattr);
443 	nfs_free_fhandle(fh);
444 out:
445 	dprintk("NFS reply symlink: %d\n", status);
446 	return status;
447 }
448 
449 static int
nfs_proc_mkdir(struct inode * dir,struct dentry * dentry,struct iattr * sattr)450 nfs_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
451 {
452 	struct nfs_createdata *data;
453 	struct rpc_message msg = {
454 		.rpc_proc	= &nfs_procedures[NFSPROC_MKDIR],
455 	};
456 	int status = -ENOMEM;
457 
458 	dprintk("NFS call  mkdir %pd\n", dentry);
459 	data = nfs_alloc_createdata(dir, dentry, sattr);
460 	if (data == NULL)
461 		goto out;
462 	msg.rpc_argp = &data->arg;
463 	msg.rpc_resp = &data->res;
464 
465 	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
466 	nfs_mark_for_revalidate(dir);
467 	if (status == 0)
468 		status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
469 	nfs_free_createdata(data);
470 out:
471 	dprintk("NFS reply mkdir: %d\n", status);
472 	return status;
473 }
474 
475 static int
nfs_proc_rmdir(struct inode * dir,const struct qstr * name)476 nfs_proc_rmdir(struct inode *dir, const struct qstr *name)
477 {
478 	struct nfs_diropargs	arg = {
479 		.fh		= NFS_FH(dir),
480 		.name		= name->name,
481 		.len		= name->len
482 	};
483 	struct rpc_message msg = {
484 		.rpc_proc	= &nfs_procedures[NFSPROC_RMDIR],
485 		.rpc_argp	= &arg,
486 	};
487 	int			status;
488 
489 	dprintk("NFS call  rmdir %s\n", name->name);
490 	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
491 	nfs_mark_for_revalidate(dir);
492 	dprintk("NFS reply rmdir: %d\n", status);
493 	return status;
494 }
495 
496 /*
497  * The READDIR implementation is somewhat hackish - we pass a temporary
498  * buffer to the encode function, which installs it in the receive
499  * the receive iovec. The decode function just parses the reply to make
500  * sure it is syntactically correct; the entries itself are decoded
501  * from nfs_readdir by calling the decode_entry function directly.
502  */
nfs_proc_readdir(struct nfs_readdir_arg * nr_arg,struct nfs_readdir_res * nr_res)503 static int nfs_proc_readdir(struct nfs_readdir_arg *nr_arg,
504 			    struct nfs_readdir_res *nr_res)
505 {
506 	struct inode		*dir = d_inode(nr_arg->dentry);
507 	struct nfs_readdirargs	arg = {
508 		.fh		= NFS_FH(dir),
509 		.cookie		= nr_arg->cookie,
510 		.count		= nr_arg->page_len,
511 		.pages		= nr_arg->pages,
512 	};
513 	struct rpc_message	msg = {
514 		.rpc_proc	= &nfs_procedures[NFSPROC_READDIR],
515 		.rpc_argp	= &arg,
516 		.rpc_cred	= nr_arg->cred,
517 	};
518 	int			status;
519 
520 	dprintk("NFS call  readdir %llu\n", (unsigned long long)nr_arg->cookie);
521 	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
522 	nr_res->verf[0] = nr_res->verf[1] = 0;
523 
524 	nfs_invalidate_atime(dir);
525 
526 	dprintk("NFS reply readdir: %d\n", status);
527 	return status;
528 }
529 
530 static int
nfs_proc_statfs(struct nfs_server * server,struct nfs_fh * fhandle,struct nfs_fsstat * stat)531 nfs_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
532 			struct nfs_fsstat *stat)
533 {
534 	struct nfs2_fsstat fsinfo;
535 	struct rpc_message msg = {
536 		.rpc_proc	= &nfs_procedures[NFSPROC_STATFS],
537 		.rpc_argp	= fhandle,
538 		.rpc_resp	= &fsinfo,
539 	};
540 	int	status;
541 
542 	dprintk("NFS call  statfs\n");
543 	nfs_fattr_init(stat->fattr);
544 	status = rpc_call_sync(server->client, &msg, 0);
545 	dprintk("NFS reply statfs: %d\n", status);
546 	if (status)
547 		goto out;
548 	stat->tbytes = (u64)fsinfo.blocks * fsinfo.bsize;
549 	stat->fbytes = (u64)fsinfo.bfree  * fsinfo.bsize;
550 	stat->abytes = (u64)fsinfo.bavail * fsinfo.bsize;
551 	stat->tfiles = 0;
552 	stat->ffiles = 0;
553 	stat->afiles = 0;
554 out:
555 	return status;
556 }
557 
558 static int
nfs_proc_fsinfo(struct nfs_server * server,struct nfs_fh * fhandle,struct nfs_fsinfo * info)559 nfs_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
560 			struct nfs_fsinfo *info)
561 {
562 	struct nfs2_fsstat fsinfo;
563 	struct rpc_message msg = {
564 		.rpc_proc	= &nfs_procedures[NFSPROC_STATFS],
565 		.rpc_argp	= fhandle,
566 		.rpc_resp	= &fsinfo,
567 	};
568 	int	status;
569 
570 	dprintk("NFS call  fsinfo\n");
571 	nfs_fattr_init(info->fattr);
572 	status = rpc_call_sync(server->client, &msg, 0);
573 	dprintk("NFS reply fsinfo: %d\n", status);
574 	if (status)
575 		goto out;
576 	info->rtmax  = NFS_MAXDATA;
577 	info->rtpref = fsinfo.tsize;
578 	info->rtmult = fsinfo.bsize;
579 	info->wtmax  = NFS_MAXDATA;
580 	info->wtpref = fsinfo.tsize;
581 	info->wtmult = fsinfo.bsize;
582 	info->dtpref = fsinfo.tsize;
583 	info->maxfilesize = 0x7FFFFFFF;
584 	info->lease_time = 0;
585 out:
586 	return status;
587 }
588 
589 static int
nfs_proc_pathconf(struct nfs_server * server,struct nfs_fh * fhandle,struct nfs_pathconf * info)590 nfs_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
591 		  struct nfs_pathconf *info)
592 {
593 	info->max_link = 0;
594 	info->max_namelen = NFS2_MAXNAMLEN;
595 	return 0;
596 }
597 
nfs_read_done(struct rpc_task * task,struct nfs_pgio_header * hdr)598 static int nfs_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
599 {
600 	struct inode *inode = hdr->inode;
601 
602 	nfs_invalidate_atime(inode);
603 	if (task->tk_status >= 0) {
604 		nfs_refresh_inode(inode, hdr->res.fattr);
605 		/* Emulate the eof flag, which isn't normally needed in NFSv2
606 		 * as it is guaranteed to always return the file attributes
607 		 */
608 		if ((hdr->res.count == 0 && hdr->args.count > 0) ||
609 		    hdr->args.offset + hdr->res.count >= hdr->res.fattr->size)
610 			hdr->res.eof = 1;
611 	}
612 	return 0;
613 }
614 
nfs_proc_read_setup(struct nfs_pgio_header * hdr,struct rpc_message * msg)615 static void nfs_proc_read_setup(struct nfs_pgio_header *hdr,
616 				struct rpc_message *msg)
617 {
618 	msg->rpc_proc = &nfs_procedures[NFSPROC_READ];
619 }
620 
nfs_proc_pgio_rpc_prepare(struct rpc_task * task,struct nfs_pgio_header * hdr)621 static int nfs_proc_pgio_rpc_prepare(struct rpc_task *task,
622 				     struct nfs_pgio_header *hdr)
623 {
624 	rpc_call_start(task);
625 	return 0;
626 }
627 
nfs_write_done(struct rpc_task * task,struct nfs_pgio_header * hdr)628 static int nfs_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
629 {
630 	if (task->tk_status >= 0) {
631 		hdr->res.count = hdr->args.count;
632 		nfs_writeback_update_inode(hdr);
633 	}
634 	return 0;
635 }
636 
nfs_proc_write_setup(struct nfs_pgio_header * hdr,struct rpc_message * msg,struct rpc_clnt ** clnt)637 static void nfs_proc_write_setup(struct nfs_pgio_header *hdr,
638 				 struct rpc_message *msg,
639 				 struct rpc_clnt **clnt)
640 {
641 	/* Note: NFSv2 ignores @stable and always uses NFS_FILE_SYNC */
642 	hdr->args.stable = NFS_FILE_SYNC;
643 	msg->rpc_proc = &nfs_procedures[NFSPROC_WRITE];
644 }
645 
nfs_proc_commit_rpc_prepare(struct rpc_task * task,struct nfs_commit_data * data)646 static void nfs_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
647 {
648 	BUG();
649 }
650 
651 static void
nfs_proc_commit_setup(struct nfs_commit_data * data,struct rpc_message * msg,struct rpc_clnt ** clnt)652 nfs_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg,
653 			struct rpc_clnt **clnt)
654 {
655 	BUG();
656 }
657 
658 static int
nfs_proc_lock(struct file * filp,int cmd,struct file_lock * fl)659 nfs_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
660 {
661 	struct inode *inode = file_inode(filp);
662 
663 	return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl, NULL);
664 }
665 
666 /* Helper functions for NFS lock bounds checking */
667 #define NFS_LOCK32_OFFSET_MAX ((__s32)0x7fffffffUL)
nfs_lock_check_bounds(const struct file_lock * fl)668 static int nfs_lock_check_bounds(const struct file_lock *fl)
669 {
670 	__s32 start, end;
671 
672 	start = (__s32)fl->fl_start;
673 	if ((loff_t)start != fl->fl_start)
674 		goto out_einval;
675 
676 	if (fl->fl_end != OFFSET_MAX) {
677 		end = (__s32)fl->fl_end;
678 		if ((loff_t)end != fl->fl_end)
679 			goto out_einval;
680 	} else
681 		end = NFS_LOCK32_OFFSET_MAX;
682 
683 	if (start < 0 || start > end)
684 		goto out_einval;
685 	return 0;
686 out_einval:
687 	return -EINVAL;
688 }
689 
nfs_have_delegation(struct inode * inode,fmode_t type,int flags)690 static int nfs_have_delegation(struct inode *inode, fmode_t type, int flags)
691 {
692 	return 0;
693 }
694 
nfs_return_delegation(struct inode * inode)695 static int nfs_return_delegation(struct inode *inode)
696 {
697 	if (S_ISREG(inode->i_mode))
698 		nfs_wb_all(inode);
699 	return 0;
700 }
701 
702 static const struct inode_operations nfs_dir_inode_operations = {
703 	.create		= nfs_create,
704 	.lookup		= nfs_lookup,
705 	.atomic_open	= nfs_atomic_open_v23,
706 	.link		= nfs_link,
707 	.unlink		= nfs_unlink,
708 	.symlink	= nfs_symlink,
709 	.mkdir		= nfs_mkdir,
710 	.rmdir		= nfs_rmdir,
711 	.mknod		= nfs_mknod,
712 	.rename		= nfs_rename,
713 	.permission	= nfs_permission,
714 	.getattr	= nfs_getattr,
715 	.setattr	= nfs_setattr,
716 };
717 
718 static const struct inode_operations nfs_file_inode_operations = {
719 	.permission	= nfs_permission,
720 	.getattr	= nfs_getattr,
721 	.setattr	= nfs_setattr,
722 };
723 
724 const struct nfs_rpc_ops nfs_v2_clientops = {
725 	.version	= 2,		       /* protocol version */
726 	.dentry_ops	= &nfs_dentry_operations,
727 	.dir_inode_ops	= &nfs_dir_inode_operations,
728 	.file_inode_ops	= &nfs_file_inode_operations,
729 	.file_ops	= &nfs_file_operations,
730 	.getroot	= nfs_proc_get_root,
731 	.submount	= nfs_submount,
732 	.try_get_tree	= nfs_try_get_tree,
733 	.getattr	= nfs_proc_getattr,
734 	.setattr	= nfs_proc_setattr,
735 	.lookup		= nfs_proc_lookup,
736 	.access		= NULL,		       /* access */
737 	.readlink	= nfs_proc_readlink,
738 	.create		= nfs_proc_create,
739 	.remove		= nfs_proc_remove,
740 	.unlink_setup	= nfs_proc_unlink_setup,
741 	.unlink_rpc_prepare = nfs_proc_unlink_rpc_prepare,
742 	.unlink_done	= nfs_proc_unlink_done,
743 	.rename_setup	= nfs_proc_rename_setup,
744 	.rename_rpc_prepare = nfs_proc_rename_rpc_prepare,
745 	.rename_done	= nfs_proc_rename_done,
746 	.link		= nfs_proc_link,
747 	.symlink	= nfs_proc_symlink,
748 	.mkdir		= nfs_proc_mkdir,
749 	.rmdir		= nfs_proc_rmdir,
750 	.readdir	= nfs_proc_readdir,
751 	.mknod		= nfs_proc_mknod,
752 	.statfs		= nfs_proc_statfs,
753 	.fsinfo		= nfs_proc_fsinfo,
754 	.pathconf	= nfs_proc_pathconf,
755 	.decode_dirent	= nfs2_decode_dirent,
756 	.pgio_rpc_prepare = nfs_proc_pgio_rpc_prepare,
757 	.read_setup	= nfs_proc_read_setup,
758 	.read_done	= nfs_read_done,
759 	.write_setup	= nfs_proc_write_setup,
760 	.write_done	= nfs_write_done,
761 	.commit_setup	= nfs_proc_commit_setup,
762 	.commit_rpc_prepare = nfs_proc_commit_rpc_prepare,
763 	.lock		= nfs_proc_lock,
764 	.lock_check_bounds = nfs_lock_check_bounds,
765 	.close_context	= nfs_close_context,
766 	.have_delegation = nfs_have_delegation,
767 	.return_delegation = nfs_return_delegation,
768 	.alloc_client	= nfs_alloc_client,
769 	.init_client	= nfs_init_client,
770 	.free_client	= nfs_free_client,
771 	.create_server	= nfs_create_server,
772 	.clone_server	= nfs_clone_server,
773 };
774