xref: /openbmc/linux/fs/nfs/nfs3proc.c (revision d2999e1b)
1 /*
2  *  linux/fs/nfs/nfs3proc.c
3  *
4  *  Client-side NFSv3 procedures stubs.
5  *
6  *  Copyright (C) 1997, Olaf Kirch
7  */
8 
9 #include <linux/mm.h>
10 #include <linux/errno.h>
11 #include <linux/string.h>
12 #include <linux/sunrpc/clnt.h>
13 #include <linux/slab.h>
14 #include <linux/nfs.h>
15 #include <linux/nfs3.h>
16 #include <linux/nfs_fs.h>
17 #include <linux/nfs_page.h>
18 #include <linux/lockd/bind.h>
19 #include <linux/nfs_mount.h>
20 #include <linux/freezer.h>
21 #include <linux/xattr.h>
22 
23 #include "iostat.h"
24 #include "internal.h"
25 
26 #define NFSDBG_FACILITY		NFSDBG_PROC
27 
28 /* A wrapper to handle the EJUKEBOX error messages */
29 static int
30 nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
31 {
32 	int res;
33 	do {
34 		res = rpc_call_sync(clnt, msg, flags);
35 		if (res != -EJUKEBOX)
36 			break;
37 		freezable_schedule_timeout_killable_unsafe(NFS_JUKEBOX_RETRY_TIME);
38 		res = -ERESTARTSYS;
39 	} while (!fatal_signal_pending(current));
40 	return res;
41 }
42 
43 #define rpc_call_sync(clnt, msg, flags)	nfs3_rpc_wrapper(clnt, msg, flags)
44 
45 static int
46 nfs3_async_handle_jukebox(struct rpc_task *task, struct inode *inode)
47 {
48 	if (task->tk_status != -EJUKEBOX)
49 		return 0;
50 	if (task->tk_status == -EJUKEBOX)
51 		nfs_inc_stats(inode, NFSIOS_DELAY);
52 	task->tk_status = 0;
53 	rpc_restart_call(task);
54 	rpc_delay(task, NFS_JUKEBOX_RETRY_TIME);
55 	return 1;
56 }
57 
58 static int
59 do_proc_get_root(struct rpc_clnt *client, struct nfs_fh *fhandle,
60 		 struct nfs_fsinfo *info)
61 {
62 	struct rpc_message msg = {
63 		.rpc_proc	= &nfs3_procedures[NFS3PROC_FSINFO],
64 		.rpc_argp	= fhandle,
65 		.rpc_resp	= info,
66 	};
67 	int	status;
68 
69 	dprintk("%s: call  fsinfo\n", __func__);
70 	nfs_fattr_init(info->fattr);
71 	status = rpc_call_sync(client, &msg, 0);
72 	dprintk("%s: reply fsinfo: %d\n", __func__, status);
73 	if (status == 0 && !(info->fattr->valid & NFS_ATTR_FATTR)) {
74 		msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
75 		msg.rpc_resp = info->fattr;
76 		status = rpc_call_sync(client, &msg, 0);
77 		dprintk("%s: reply getattr: %d\n", __func__, status);
78 	}
79 	return status;
80 }
81 
82 /*
83  * Bare-bones access to getattr: this is for nfs_get_root/nfs_get_sb
84  */
85 static int
86 nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
87 		   struct nfs_fsinfo *info)
88 {
89 	int	status;
90 
91 	status = do_proc_get_root(server->client, fhandle, info);
92 	if (status && server->nfs_client->cl_rpcclient != server->client)
93 		status = do_proc_get_root(server->nfs_client->cl_rpcclient, fhandle, info);
94 	return status;
95 }
96 
97 /*
98  * One function for each procedure in the NFS protocol.
99  */
100 static int
101 nfs3_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
102 		struct nfs_fattr *fattr, struct nfs4_label *label)
103 {
104 	struct rpc_message msg = {
105 		.rpc_proc	= &nfs3_procedures[NFS3PROC_GETATTR],
106 		.rpc_argp	= fhandle,
107 		.rpc_resp	= fattr,
108 	};
109 	int	status;
110 
111 	dprintk("NFS call  getattr\n");
112 	nfs_fattr_init(fattr);
113 	status = rpc_call_sync(server->client, &msg, 0);
114 	dprintk("NFS reply getattr: %d\n", status);
115 	return status;
116 }
117 
118 static int
119 nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
120 			struct iattr *sattr)
121 {
122 	struct inode *inode = dentry->d_inode;
123 	struct nfs3_sattrargs	arg = {
124 		.fh		= NFS_FH(inode),
125 		.sattr		= sattr,
126 	};
127 	struct rpc_message msg = {
128 		.rpc_proc	= &nfs3_procedures[NFS3PROC_SETATTR],
129 		.rpc_argp	= &arg,
130 		.rpc_resp	= fattr,
131 	};
132 	int	status;
133 
134 	dprintk("NFS call  setattr\n");
135 	if (sattr->ia_valid & ATTR_FILE)
136 		msg.rpc_cred = nfs_file_cred(sattr->ia_file);
137 	nfs_fattr_init(fattr);
138 	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
139 	if (status == 0)
140 		nfs_setattr_update_inode(inode, sattr);
141 	dprintk("NFS reply setattr: %d\n", status);
142 	return status;
143 }
144 
145 static int
146 nfs3_proc_lookup(struct inode *dir, struct qstr *name,
147 		 struct nfs_fh *fhandle, struct nfs_fattr *fattr,
148 		 struct nfs4_label *label)
149 {
150 	struct nfs3_diropargs	arg = {
151 		.fh		= NFS_FH(dir),
152 		.name		= name->name,
153 		.len		= name->len
154 	};
155 	struct nfs3_diropres	res = {
156 		.fh		= fhandle,
157 		.fattr		= fattr
158 	};
159 	struct rpc_message msg = {
160 		.rpc_proc	= &nfs3_procedures[NFS3PROC_LOOKUP],
161 		.rpc_argp	= &arg,
162 		.rpc_resp	= &res,
163 	};
164 	int			status;
165 
166 	dprintk("NFS call  lookup %s\n", name->name);
167 	res.dir_attr = nfs_alloc_fattr();
168 	if (res.dir_attr == NULL)
169 		return -ENOMEM;
170 
171 	nfs_fattr_init(fattr);
172 	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
173 	nfs_refresh_inode(dir, res.dir_attr);
174 	if (status >= 0 && !(fattr->valid & NFS_ATTR_FATTR)) {
175 		msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
176 		msg.rpc_argp = fhandle;
177 		msg.rpc_resp = fattr;
178 		status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
179 	}
180 	nfs_free_fattr(res.dir_attr);
181 	dprintk("NFS reply lookup: %d\n", status);
182 	return status;
183 }
184 
185 static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry)
186 {
187 	struct nfs3_accessargs	arg = {
188 		.fh		= NFS_FH(inode),
189 	};
190 	struct nfs3_accessres	res;
191 	struct rpc_message msg = {
192 		.rpc_proc	= &nfs3_procedures[NFS3PROC_ACCESS],
193 		.rpc_argp	= &arg,
194 		.rpc_resp	= &res,
195 		.rpc_cred	= entry->cred,
196 	};
197 	int mode = entry->mask;
198 	int status = -ENOMEM;
199 
200 	dprintk("NFS call  access\n");
201 
202 	if (mode & MAY_READ)
203 		arg.access |= NFS3_ACCESS_READ;
204 	if (S_ISDIR(inode->i_mode)) {
205 		if (mode & MAY_WRITE)
206 			arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE;
207 		if (mode & MAY_EXEC)
208 			arg.access |= NFS3_ACCESS_LOOKUP;
209 	} else {
210 		if (mode & MAY_WRITE)
211 			arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND;
212 		if (mode & MAY_EXEC)
213 			arg.access |= NFS3_ACCESS_EXECUTE;
214 	}
215 
216 	res.fattr = nfs_alloc_fattr();
217 	if (res.fattr == NULL)
218 		goto out;
219 
220 	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
221 	nfs_refresh_inode(inode, res.fattr);
222 	if (status == 0) {
223 		entry->mask = 0;
224 		if (res.access & NFS3_ACCESS_READ)
225 			entry->mask |= MAY_READ;
226 		if (res.access & (NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE))
227 			entry->mask |= MAY_WRITE;
228 		if (res.access & (NFS3_ACCESS_LOOKUP|NFS3_ACCESS_EXECUTE))
229 			entry->mask |= MAY_EXEC;
230 	}
231 	nfs_free_fattr(res.fattr);
232 out:
233 	dprintk("NFS reply access: %d\n", status);
234 	return status;
235 }
236 
237 static int nfs3_proc_readlink(struct inode *inode, struct page *page,
238 		unsigned int pgbase, unsigned int pglen)
239 {
240 	struct nfs_fattr	*fattr;
241 	struct nfs3_readlinkargs args = {
242 		.fh		= NFS_FH(inode),
243 		.pgbase		= pgbase,
244 		.pglen		= pglen,
245 		.pages		= &page
246 	};
247 	struct rpc_message msg = {
248 		.rpc_proc	= &nfs3_procedures[NFS3PROC_READLINK],
249 		.rpc_argp	= &args,
250 	};
251 	int status = -ENOMEM;
252 
253 	dprintk("NFS call  readlink\n");
254 	fattr = nfs_alloc_fattr();
255 	if (fattr == NULL)
256 		goto out;
257 	msg.rpc_resp = fattr;
258 
259 	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
260 	nfs_refresh_inode(inode, fattr);
261 	nfs_free_fattr(fattr);
262 out:
263 	dprintk("NFS reply readlink: %d\n", status);
264 	return status;
265 }
266 
267 struct nfs3_createdata {
268 	struct rpc_message msg;
269 	union {
270 		struct nfs3_createargs create;
271 		struct nfs3_mkdirargs mkdir;
272 		struct nfs3_symlinkargs symlink;
273 		struct nfs3_mknodargs mknod;
274 	} arg;
275 	struct nfs3_diropres res;
276 	struct nfs_fh fh;
277 	struct nfs_fattr fattr;
278 	struct nfs_fattr dir_attr;
279 };
280 
281 static struct nfs3_createdata *nfs3_alloc_createdata(void)
282 {
283 	struct nfs3_createdata *data;
284 
285 	data = kzalloc(sizeof(*data), GFP_KERNEL);
286 	if (data != NULL) {
287 		data->msg.rpc_argp = &data->arg;
288 		data->msg.rpc_resp = &data->res;
289 		data->res.fh = &data->fh;
290 		data->res.fattr = &data->fattr;
291 		data->res.dir_attr = &data->dir_attr;
292 		nfs_fattr_init(data->res.fattr);
293 		nfs_fattr_init(data->res.dir_attr);
294 	}
295 	return data;
296 }
297 
298 static int nfs3_do_create(struct inode *dir, struct dentry *dentry, struct nfs3_createdata *data)
299 {
300 	int status;
301 
302 	status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0);
303 	nfs_post_op_update_inode(dir, data->res.dir_attr);
304 	if (status == 0)
305 		status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
306 	return status;
307 }
308 
309 static void nfs3_free_createdata(struct nfs3_createdata *data)
310 {
311 	kfree(data);
312 }
313 
314 /*
315  * Create a regular file.
316  */
317 static int
318 nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
319 		 int flags)
320 {
321 	struct posix_acl *default_acl, *acl;
322 	struct nfs3_createdata *data;
323 	int status = -ENOMEM;
324 
325 	dprintk("NFS call  create %pd\n", dentry);
326 
327 	data = nfs3_alloc_createdata();
328 	if (data == NULL)
329 		goto out;
330 
331 	data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_CREATE];
332 	data->arg.create.fh = NFS_FH(dir);
333 	data->arg.create.name = dentry->d_name.name;
334 	data->arg.create.len = dentry->d_name.len;
335 	data->arg.create.sattr = sattr;
336 
337 	data->arg.create.createmode = NFS3_CREATE_UNCHECKED;
338 	if (flags & O_EXCL) {
339 		data->arg.create.createmode  = NFS3_CREATE_EXCLUSIVE;
340 		data->arg.create.verifier[0] = cpu_to_be32(jiffies);
341 		data->arg.create.verifier[1] = cpu_to_be32(current->pid);
342 	}
343 
344 	status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl);
345 	if (status)
346 		goto out;
347 
348 	for (;;) {
349 		status = nfs3_do_create(dir, dentry, data);
350 
351 		if (status != -ENOTSUPP)
352 			break;
353 		/* If the server doesn't support the exclusive creation
354 		 * semantics, try again with simple 'guarded' mode. */
355 		switch (data->arg.create.createmode) {
356 			case NFS3_CREATE_EXCLUSIVE:
357 				data->arg.create.createmode = NFS3_CREATE_GUARDED;
358 				break;
359 
360 			case NFS3_CREATE_GUARDED:
361 				data->arg.create.createmode = NFS3_CREATE_UNCHECKED;
362 				break;
363 
364 			case NFS3_CREATE_UNCHECKED:
365 				goto out;
366 		}
367 		nfs_fattr_init(data->res.dir_attr);
368 		nfs_fattr_init(data->res.fattr);
369 	}
370 
371 	if (status != 0)
372 		goto out_release_acls;
373 
374 	/* When we created the file with exclusive semantics, make
375 	 * sure we set the attributes afterwards. */
376 	if (data->arg.create.createmode == NFS3_CREATE_EXCLUSIVE) {
377 		dprintk("NFS call  setattr (post-create)\n");
378 
379 		if (!(sattr->ia_valid & ATTR_ATIME_SET))
380 			sattr->ia_valid |= ATTR_ATIME;
381 		if (!(sattr->ia_valid & ATTR_MTIME_SET))
382 			sattr->ia_valid |= ATTR_MTIME;
383 
384 		/* Note: we could use a guarded setattr here, but I'm
385 		 * not sure this buys us anything (and I'd have
386 		 * to revamp the NFSv3 XDR code) */
387 		status = nfs3_proc_setattr(dentry, data->res.fattr, sattr);
388 		nfs_post_op_update_inode(dentry->d_inode, data->res.fattr);
389 		dprintk("NFS reply setattr (post-create): %d\n", status);
390 		if (status != 0)
391 			goto out_release_acls;
392 	}
393 
394 	status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl);
395 
396 out_release_acls:
397 	posix_acl_release(acl);
398 	posix_acl_release(default_acl);
399 out:
400 	nfs3_free_createdata(data);
401 	dprintk("NFS reply create: %d\n", status);
402 	return status;
403 }
404 
405 static int
406 nfs3_proc_remove(struct inode *dir, struct qstr *name)
407 {
408 	struct nfs_removeargs arg = {
409 		.fh = NFS_FH(dir),
410 		.name = *name,
411 	};
412 	struct nfs_removeres res;
413 	struct rpc_message msg = {
414 		.rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE],
415 		.rpc_argp = &arg,
416 		.rpc_resp = &res,
417 	};
418 	int status = -ENOMEM;
419 
420 	dprintk("NFS call  remove %s\n", name->name);
421 	res.dir_attr = nfs_alloc_fattr();
422 	if (res.dir_attr == NULL)
423 		goto out;
424 
425 	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
426 	nfs_post_op_update_inode(dir, res.dir_attr);
427 	nfs_free_fattr(res.dir_attr);
428 out:
429 	dprintk("NFS reply remove: %d\n", status);
430 	return status;
431 }
432 
433 static void
434 nfs3_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
435 {
436 	msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE];
437 }
438 
439 static void nfs3_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
440 {
441 	rpc_call_start(task);
442 }
443 
444 static int
445 nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir)
446 {
447 	struct nfs_removeres *res;
448 	if (nfs3_async_handle_jukebox(task, dir))
449 		return 0;
450 	res = task->tk_msg.rpc_resp;
451 	nfs_post_op_update_inode(dir, res->dir_attr);
452 	return 1;
453 }
454 
455 static void
456 nfs3_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
457 {
458 	msg->rpc_proc = &nfs3_procedures[NFS3PROC_RENAME];
459 }
460 
461 static void nfs3_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
462 {
463 	rpc_call_start(task);
464 }
465 
466 static int
467 nfs3_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
468 		      struct inode *new_dir)
469 {
470 	struct nfs_renameres *res;
471 
472 	if (nfs3_async_handle_jukebox(task, old_dir))
473 		return 0;
474 	res = task->tk_msg.rpc_resp;
475 
476 	nfs_post_op_update_inode(old_dir, res->old_fattr);
477 	nfs_post_op_update_inode(new_dir, res->new_fattr);
478 	return 1;
479 }
480 
481 static int
482 nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
483 {
484 	struct nfs3_linkargs	arg = {
485 		.fromfh		= NFS_FH(inode),
486 		.tofh		= NFS_FH(dir),
487 		.toname		= name->name,
488 		.tolen		= name->len
489 	};
490 	struct nfs3_linkres	res;
491 	struct rpc_message msg = {
492 		.rpc_proc	= &nfs3_procedures[NFS3PROC_LINK],
493 		.rpc_argp	= &arg,
494 		.rpc_resp	= &res,
495 	};
496 	int status = -ENOMEM;
497 
498 	dprintk("NFS call  link %s\n", name->name);
499 	res.fattr = nfs_alloc_fattr();
500 	res.dir_attr = nfs_alloc_fattr();
501 	if (res.fattr == NULL || res.dir_attr == NULL)
502 		goto out;
503 
504 	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
505 	nfs_post_op_update_inode(dir, res.dir_attr);
506 	nfs_post_op_update_inode(inode, res.fattr);
507 out:
508 	nfs_free_fattr(res.dir_attr);
509 	nfs_free_fattr(res.fattr);
510 	dprintk("NFS reply link: %d\n", status);
511 	return status;
512 }
513 
514 static int
515 nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
516 		  unsigned int len, struct iattr *sattr)
517 {
518 	struct nfs3_createdata *data;
519 	int status = -ENOMEM;
520 
521 	if (len > NFS3_MAXPATHLEN)
522 		return -ENAMETOOLONG;
523 
524 	dprintk("NFS call  symlink %pd\n", dentry);
525 
526 	data = nfs3_alloc_createdata();
527 	if (data == NULL)
528 		goto out;
529 	data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK];
530 	data->arg.symlink.fromfh = NFS_FH(dir);
531 	data->arg.symlink.fromname = dentry->d_name.name;
532 	data->arg.symlink.fromlen = dentry->d_name.len;
533 	data->arg.symlink.pages = &page;
534 	data->arg.symlink.pathlen = len;
535 	data->arg.symlink.sattr = sattr;
536 
537 	status = nfs3_do_create(dir, dentry, data);
538 
539 	nfs3_free_createdata(data);
540 out:
541 	dprintk("NFS reply symlink: %d\n", status);
542 	return status;
543 }
544 
545 static int
546 nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
547 {
548 	struct posix_acl *default_acl, *acl;
549 	struct nfs3_createdata *data;
550 	int status = -ENOMEM;
551 
552 	dprintk("NFS call  mkdir %pd\n", dentry);
553 
554 	data = nfs3_alloc_createdata();
555 	if (data == NULL)
556 		goto out;
557 
558 	status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl);
559 	if (status)
560 		goto out;
561 
562 	data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR];
563 	data->arg.mkdir.fh = NFS_FH(dir);
564 	data->arg.mkdir.name = dentry->d_name.name;
565 	data->arg.mkdir.len = dentry->d_name.len;
566 	data->arg.mkdir.sattr = sattr;
567 
568 	status = nfs3_do_create(dir, dentry, data);
569 	if (status != 0)
570 		goto out_release_acls;
571 
572 	status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl);
573 
574 out_release_acls:
575 	posix_acl_release(acl);
576 	posix_acl_release(default_acl);
577 out:
578 	nfs3_free_createdata(data);
579 	dprintk("NFS reply mkdir: %d\n", status);
580 	return status;
581 }
582 
583 static int
584 nfs3_proc_rmdir(struct inode *dir, struct qstr *name)
585 {
586 	struct nfs_fattr	*dir_attr;
587 	struct nfs3_diropargs	arg = {
588 		.fh		= NFS_FH(dir),
589 		.name		= name->name,
590 		.len		= name->len
591 	};
592 	struct rpc_message msg = {
593 		.rpc_proc	= &nfs3_procedures[NFS3PROC_RMDIR],
594 		.rpc_argp	= &arg,
595 	};
596 	int status = -ENOMEM;
597 
598 	dprintk("NFS call  rmdir %s\n", name->name);
599 	dir_attr = nfs_alloc_fattr();
600 	if (dir_attr == NULL)
601 		goto out;
602 
603 	msg.rpc_resp = dir_attr;
604 	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
605 	nfs_post_op_update_inode(dir, dir_attr);
606 	nfs_free_fattr(dir_attr);
607 out:
608 	dprintk("NFS reply rmdir: %d\n", status);
609 	return status;
610 }
611 
612 /*
613  * The READDIR implementation is somewhat hackish - we pass the user buffer
614  * to the encode function, which installs it in the receive iovec.
615  * The decode function itself doesn't perform any decoding, it just makes
616  * sure the reply is syntactically correct.
617  *
618  * Also note that this implementation handles both plain readdir and
619  * readdirplus.
620  */
621 static int
622 nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
623 		  u64 cookie, struct page **pages, unsigned int count, int plus)
624 {
625 	struct inode		*dir = dentry->d_inode;
626 	__be32			*verf = NFS_I(dir)->cookieverf;
627 	struct nfs3_readdirargs	arg = {
628 		.fh		= NFS_FH(dir),
629 		.cookie		= cookie,
630 		.verf		= {verf[0], verf[1]},
631 		.plus		= plus,
632 		.count		= count,
633 		.pages		= pages
634 	};
635 	struct nfs3_readdirres	res = {
636 		.verf		= verf,
637 		.plus		= plus
638 	};
639 	struct rpc_message	msg = {
640 		.rpc_proc	= &nfs3_procedures[NFS3PROC_READDIR],
641 		.rpc_argp	= &arg,
642 		.rpc_resp	= &res,
643 		.rpc_cred	= cred
644 	};
645 	int status = -ENOMEM;
646 
647 	if (plus)
648 		msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS];
649 
650 	dprintk("NFS call  readdir%s %d\n",
651 			plus? "plus" : "", (unsigned int) cookie);
652 
653 	res.dir_attr = nfs_alloc_fattr();
654 	if (res.dir_attr == NULL)
655 		goto out;
656 
657 	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
658 
659 	nfs_invalidate_atime(dir);
660 	nfs_refresh_inode(dir, res.dir_attr);
661 
662 	nfs_free_fattr(res.dir_attr);
663 out:
664 	dprintk("NFS reply readdir%s: %d\n",
665 			plus? "plus" : "", status);
666 	return status;
667 }
668 
669 static int
670 nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
671 		dev_t rdev)
672 {
673 	struct posix_acl *default_acl, *acl;
674 	struct nfs3_createdata *data;
675 	int status = -ENOMEM;
676 
677 	dprintk("NFS call  mknod %pd %u:%u\n", dentry,
678 			MAJOR(rdev), MINOR(rdev));
679 
680 	data = nfs3_alloc_createdata();
681 	if (data == NULL)
682 		goto out;
683 
684 	status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl);
685 	if (status)
686 		goto out;
687 
688 	data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD];
689 	data->arg.mknod.fh = NFS_FH(dir);
690 	data->arg.mknod.name = dentry->d_name.name;
691 	data->arg.mknod.len = dentry->d_name.len;
692 	data->arg.mknod.sattr = sattr;
693 	data->arg.mknod.rdev = rdev;
694 
695 	switch (sattr->ia_mode & S_IFMT) {
696 	case S_IFBLK:
697 		data->arg.mknod.type = NF3BLK;
698 		break;
699 	case S_IFCHR:
700 		data->arg.mknod.type = NF3CHR;
701 		break;
702 	case S_IFIFO:
703 		data->arg.mknod.type = NF3FIFO;
704 		break;
705 	case S_IFSOCK:
706 		data->arg.mknod.type = NF3SOCK;
707 		break;
708 	default:
709 		status = -EINVAL;
710 		goto out;
711 	}
712 
713 	status = nfs3_do_create(dir, dentry, data);
714 	if (status != 0)
715 		goto out_release_acls;
716 
717 	status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl);
718 
719 out_release_acls:
720 	posix_acl_release(acl);
721 	posix_acl_release(default_acl);
722 out:
723 	nfs3_free_createdata(data);
724 	dprintk("NFS reply mknod: %d\n", status);
725 	return status;
726 }
727 
728 static int
729 nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
730 		 struct nfs_fsstat *stat)
731 {
732 	struct rpc_message msg = {
733 		.rpc_proc	= &nfs3_procedures[NFS3PROC_FSSTAT],
734 		.rpc_argp	= fhandle,
735 		.rpc_resp	= stat,
736 	};
737 	int	status;
738 
739 	dprintk("NFS call  fsstat\n");
740 	nfs_fattr_init(stat->fattr);
741 	status = rpc_call_sync(server->client, &msg, 0);
742 	dprintk("NFS reply fsstat: %d\n", status);
743 	return status;
744 }
745 
746 static int
747 do_proc_fsinfo(struct rpc_clnt *client, struct nfs_fh *fhandle,
748 		 struct nfs_fsinfo *info)
749 {
750 	struct rpc_message msg = {
751 		.rpc_proc	= &nfs3_procedures[NFS3PROC_FSINFO],
752 		.rpc_argp	= fhandle,
753 		.rpc_resp	= info,
754 	};
755 	int	status;
756 
757 	dprintk("NFS call  fsinfo\n");
758 	nfs_fattr_init(info->fattr);
759 	status = rpc_call_sync(client, &msg, 0);
760 	dprintk("NFS reply fsinfo: %d\n", status);
761 	return status;
762 }
763 
764 /*
765  * Bare-bones access to fsinfo: this is for nfs_get_root/nfs_get_sb via
766  * nfs_create_server
767  */
768 static int
769 nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
770 		   struct nfs_fsinfo *info)
771 {
772 	int	status;
773 
774 	status = do_proc_fsinfo(server->client, fhandle, info);
775 	if (status && server->nfs_client->cl_rpcclient != server->client)
776 		status = do_proc_fsinfo(server->nfs_client->cl_rpcclient, fhandle, info);
777 	return status;
778 }
779 
780 static int
781 nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
782 		   struct nfs_pathconf *info)
783 {
784 	struct rpc_message msg = {
785 		.rpc_proc	= &nfs3_procedures[NFS3PROC_PATHCONF],
786 		.rpc_argp	= fhandle,
787 		.rpc_resp	= info,
788 	};
789 	int	status;
790 
791 	dprintk("NFS call  pathconf\n");
792 	nfs_fattr_init(info->fattr);
793 	status = rpc_call_sync(server->client, &msg, 0);
794 	dprintk("NFS reply pathconf: %d\n", status);
795 	return status;
796 }
797 
798 static int nfs3_read_done(struct rpc_task *task, struct nfs_pgio_data *data)
799 {
800 	struct inode *inode = data->header->inode;
801 
802 	if (nfs3_async_handle_jukebox(task, inode))
803 		return -EAGAIN;
804 
805 	nfs_invalidate_atime(inode);
806 	nfs_refresh_inode(inode, &data->fattr);
807 	return 0;
808 }
809 
810 static void nfs3_proc_read_setup(struct nfs_pgio_data *data, struct rpc_message *msg)
811 {
812 	msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ];
813 }
814 
815 static int nfs3_proc_pgio_rpc_prepare(struct rpc_task *task, struct nfs_pgio_data *data)
816 {
817 	rpc_call_start(task);
818 	return 0;
819 }
820 
821 static int nfs3_write_done(struct rpc_task *task, struct nfs_pgio_data *data)
822 {
823 	struct inode *inode = data->header->inode;
824 
825 	if (nfs3_async_handle_jukebox(task, inode))
826 		return -EAGAIN;
827 	if (task->tk_status >= 0)
828 		nfs_post_op_update_inode_force_wcc(inode, data->res.fattr);
829 	return 0;
830 }
831 
832 static void nfs3_proc_write_setup(struct nfs_pgio_data *data, struct rpc_message *msg)
833 {
834 	msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE];
835 }
836 
837 static void nfs3_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
838 {
839 	rpc_call_start(task);
840 }
841 
842 static int nfs3_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
843 {
844 	if (nfs3_async_handle_jukebox(task, data->inode))
845 		return -EAGAIN;
846 	nfs_refresh_inode(data->inode, data->res.fattr);
847 	return 0;
848 }
849 
850 static void nfs3_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
851 {
852 	msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT];
853 }
854 
855 static int
856 nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
857 {
858 	struct inode *inode = file_inode(filp);
859 
860 	return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
861 }
862 
863 static int nfs3_have_delegation(struct inode *inode, fmode_t flags)
864 {
865 	return 0;
866 }
867 
868 static int nfs3_return_delegation(struct inode *inode)
869 {
870 	nfs_wb_all(inode);
871 	return 0;
872 }
873 
874 static const struct inode_operations nfs3_dir_inode_operations = {
875 	.create		= nfs_create,
876 	.lookup		= nfs_lookup,
877 	.link		= nfs_link,
878 	.unlink		= nfs_unlink,
879 	.symlink	= nfs_symlink,
880 	.mkdir		= nfs_mkdir,
881 	.rmdir		= nfs_rmdir,
882 	.mknod		= nfs_mknod,
883 	.rename		= nfs_rename,
884 	.permission	= nfs_permission,
885 	.getattr	= nfs_getattr,
886 	.setattr	= nfs_setattr,
887 #ifdef CONFIG_NFS_V3_ACL
888 	.listxattr	= generic_listxattr,
889 	.getxattr	= generic_getxattr,
890 	.setxattr	= generic_setxattr,
891 	.removexattr	= generic_removexattr,
892 	.get_acl	= nfs3_get_acl,
893 	.set_acl	= nfs3_set_acl,
894 #endif
895 };
896 
897 static const struct inode_operations nfs3_file_inode_operations = {
898 	.permission	= nfs_permission,
899 	.getattr	= nfs_getattr,
900 	.setattr	= nfs_setattr,
901 #ifdef CONFIG_NFS_V3_ACL
902 	.listxattr	= generic_listxattr,
903 	.getxattr	= generic_getxattr,
904 	.setxattr	= generic_setxattr,
905 	.removexattr	= generic_removexattr,
906 	.get_acl	= nfs3_get_acl,
907 	.set_acl	= nfs3_set_acl,
908 #endif
909 };
910 
911 const struct nfs_rpc_ops nfs_v3_clientops = {
912 	.version	= 3,			/* protocol version */
913 	.dentry_ops	= &nfs_dentry_operations,
914 	.dir_inode_ops	= &nfs3_dir_inode_operations,
915 	.file_inode_ops	= &nfs3_file_inode_operations,
916 	.file_ops	= &nfs_file_operations,
917 	.getroot	= nfs3_proc_get_root,
918 	.submount	= nfs_submount,
919 	.try_mount	= nfs_try_mount,
920 	.getattr	= nfs3_proc_getattr,
921 	.setattr	= nfs3_proc_setattr,
922 	.lookup		= nfs3_proc_lookup,
923 	.access		= nfs3_proc_access,
924 	.readlink	= nfs3_proc_readlink,
925 	.create		= nfs3_proc_create,
926 	.remove		= nfs3_proc_remove,
927 	.unlink_setup	= nfs3_proc_unlink_setup,
928 	.unlink_rpc_prepare = nfs3_proc_unlink_rpc_prepare,
929 	.unlink_done	= nfs3_proc_unlink_done,
930 	.rename_setup	= nfs3_proc_rename_setup,
931 	.rename_rpc_prepare = nfs3_proc_rename_rpc_prepare,
932 	.rename_done	= nfs3_proc_rename_done,
933 	.link		= nfs3_proc_link,
934 	.symlink	= nfs3_proc_symlink,
935 	.mkdir		= nfs3_proc_mkdir,
936 	.rmdir		= nfs3_proc_rmdir,
937 	.readdir	= nfs3_proc_readdir,
938 	.mknod		= nfs3_proc_mknod,
939 	.statfs		= nfs3_proc_statfs,
940 	.fsinfo		= nfs3_proc_fsinfo,
941 	.pathconf	= nfs3_proc_pathconf,
942 	.decode_dirent	= nfs3_decode_dirent,
943 	.pgio_rpc_prepare = nfs3_proc_pgio_rpc_prepare,
944 	.read_setup	= nfs3_proc_read_setup,
945 	.read_done	= nfs3_read_done,
946 	.write_setup	= nfs3_proc_write_setup,
947 	.write_done	= nfs3_write_done,
948 	.commit_setup	= nfs3_proc_commit_setup,
949 	.commit_rpc_prepare = nfs3_proc_commit_rpc_prepare,
950 	.commit_done	= nfs3_commit_done,
951 	.lock		= nfs3_proc_lock,
952 	.clear_acl_cache = forget_all_cached_acls,
953 	.close_context	= nfs_close_context,
954 	.have_delegation = nfs3_have_delegation,
955 	.return_delegation = nfs3_return_delegation,
956 	.alloc_client	= nfs_alloc_client,
957 	.init_client	= nfs_init_client,
958 	.free_client	= nfs_free_client,
959 	.create_server	= nfs3_create_server,
960 	.clone_server	= nfs3_clone_server,
961 };
962