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