nfs3proc.c

   1// SPDX-License-Identifier: GPL-2.0
   2/*
   3 *  linux/fs/nfs/nfs3proc.c
   4 *
   5 *  Client-side NFSv3 procedures stubs.
   6 *
   7 *  Copyright (C) 1997, Olaf Kirch
   8 */
   9
  10#include <linux/mm.h>
  11#include <linux/errno.h>
  12#include <linux/string.h>
  13#include <linux/sunrpc/clnt.h>
  14#include <linux/slab.h>
  15#include <linux/nfs.h>
  16#include <linux/nfs3.h>
  17#include <linux/nfs_fs.h>
  18#include <linux/nfs_page.h>
  19#include <linux/lockd/bind.h>
  20#include <linux/nfs_mount.h>
  21#include <linux/freezer.h>
  22#include <linux/xattr.h>
  23
  24#include "iostat.h"
  25#include "internal.h"
  26#include "nfs3_fs.h"
  27
  28#define NFSDBG_FACILITY		NFSDBG_PROC
  29
  30/* A wrapper to handle the EJUKEBOX error messages */
  31static int
  32nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
  33{
  34	int res;
  35	do {
  36		res = rpc_call_sync(clnt, msg, flags);
  37		if (res != -EJUKEBOX)
  38			break;
  39		__set_current_state(TASK_KILLABLE|TASK_FREEZABLE_UNSAFE);
  40		schedule_timeout(NFS_JUKEBOX_RETRY_TIME);
  41		res = -ERESTARTSYS;
  42	} while (!fatal_signal_pending(current) && !nfs_current_task_exiting());
  43	return res;
  44}
  45
  46#define rpc_call_sync(clnt, msg, flags)	nfs3_rpc_wrapper(clnt, msg, flags)
  47
  48static int
  49nfs3_async_handle_jukebox(struct rpc_task *task, struct inode *inode)
  50{
  51	if (task->tk_status != -EJUKEBOX)
  52		return 0;
  53	nfs_inc_stats(inode, NFSIOS_DELAY);
  54	task->tk_status = 0;
  55	rpc_restart_call(task);
  56	rpc_delay(task, NFS_JUKEBOX_RETRY_TIME);
  57	return 1;
  58}
  59
  60static int
  61do_proc_get_root(struct rpc_clnt *client, struct nfs_fh *fhandle,
  62		 struct nfs_fsinfo *info)
  63{
  64	struct rpc_message msg = {
  65		.rpc_proc	= &nfs3_procedures[NFS3PROC_FSINFO],
  66		.rpc_argp	= fhandle,
  67		.rpc_resp	= info,
  68	};
  69	int	status;
  70
  71	dprintk("%s: call  fsinfo\n", __func__);
  72	nfs_fattr_init(info->fattr);
  73	status = rpc_call_sync(client, &msg, 0);
  74	dprintk("%s: reply fsinfo: %d\n", __func__, status);
  75	if (status == 0 && !(info->fattr->valid & NFS_ATTR_FATTR)) {
  76		msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
  77		msg.rpc_resp = info->fattr;
  78		status = rpc_call_sync(client, &msg, 0);
  79		dprintk("%s: reply getattr: %d\n", __func__, status);
  80	}
  81	return status;
  82}
  83
  84/*
  85 * Bare-bones access to getattr: this is for nfs_get_root/nfs_get_sb
  86 */
  87static int
  88nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
  89		   struct nfs_fsinfo *info)
  90{
  91	int	status;
  92
  93	status = do_proc_get_root(server->client, fhandle, info);
  94	if (status && server->nfs_client->cl_rpcclient != server->client)
  95		status = do_proc_get_root(server->nfs_client->cl_rpcclient, fhandle, info);
  96	return status;
  97}
  98
  99/*
 100 * One function for each procedure in the NFS protocol.
 101 */
 102static int
 103nfs3_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	= &nfs3_procedures[NFS3PROC_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
 126nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
 127			struct iattr *sattr)
 128{
 129	struct inode *inode = d_inode(dentry);
 130	struct nfs3_sattrargs	arg = {
 131		.fh		= NFS_FH(inode),
 132		.sattr		= sattr,
 133	};
 134	struct rpc_message msg = {
 135		.rpc_proc	= &nfs3_procedures[NFS3PROC_SETATTR],
 136		.rpc_argp	= &arg,
 137		.rpc_resp	= fattr,
 138	};
 139	int	status;
 140
 141	dprintk("NFS call  setattr\n");
 142	if (sattr->ia_valid & ATTR_FILE)
 143		msg.rpc_cred = nfs_file_cred(sattr->ia_file);
 144	nfs_fattr_init(fattr);
 145	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 146	if (status == 0) {
 147		nfs_setattr_update_inode(inode, sattr, fattr);
 148		if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)
 149			nfs_zap_acl_cache(inode);
 150	}
 151	dprintk("NFS reply setattr: %d\n", status);
 152	return status;
 153}
 154
 155static int
 156__nfs3_proc_lookup(struct inode *dir, const char *name, size_t len,
 157		   struct nfs_fh *fhandle, struct nfs_fattr *fattr,
 158		   unsigned short task_flags)
 159{
 160	struct nfs3_diropargs	arg = {
 161		.fh		= NFS_FH(dir),
 162		.name		= name,
 163		.len		= len
 164	};
 165	struct nfs3_diropres	res = {
 166		.fh		= fhandle,
 167		.fattr		= fattr
 168	};
 169	struct rpc_message msg = {
 170		.rpc_proc	= &nfs3_procedures[NFS3PROC_LOOKUP],
 171		.rpc_argp	= &arg,
 172		.rpc_resp	= &res,
 173	};
 174	int			status;
 175
 176	res.dir_attr = nfs_alloc_fattr();
 177	if (res.dir_attr == NULL)
 178		return -ENOMEM;
 179
 180	nfs_fattr_init(fattr);
 181	status = rpc_call_sync(NFS_CLIENT(dir), &msg, task_flags);
 182	nfs_refresh_inode(dir, res.dir_attr);
 183	if (status >= 0 && !(fattr->valid & NFS_ATTR_FATTR)) {
 184		msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
 185		msg.rpc_argp = fhandle;
 186		msg.rpc_resp = fattr;
 187		status = rpc_call_sync(NFS_CLIENT(dir), &msg, task_flags);
 188	}
 189	nfs_free_fattr(res.dir_attr);
 190	dprintk("NFS reply lookup: %d\n", status);
 191	return status;
 192}
 193
 194static int
 195nfs3_proc_lookup(struct inode *dir, struct dentry *dentry, const struct qstr *name,
 196		 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
 197{
 198	unsigned short task_flags = 0;
 199
 200	/* Is this is an attribute revalidation, subject to softreval? */
 201	if (nfs_lookup_is_soft_revalidate(dentry))
 202		task_flags |= RPC_TASK_TIMEOUT;
 203
 204	dprintk("NFS call  lookup %pd2\n", dentry);
 205	return __nfs3_proc_lookup(dir, name->name, name->len, fhandle, fattr,
 206				  task_flags);
 207}
 208
 209static int nfs3_proc_lookupp(struct inode *inode, struct nfs_fh *fhandle,
 210			     struct nfs_fattr *fattr)
 211{
 212	const char dotdot[] = "..";
 213	const size_t len = strlen(dotdot);
 214	unsigned short task_flags = 0;
 215
 216	if (NFS_SERVER(inode)->flags & NFS_MOUNT_SOFTREVAL)
 217		task_flags |= RPC_TASK_TIMEOUT;
 218
 219	return __nfs3_proc_lookup(inode, dotdot, len, fhandle, fattr,
 220				  task_flags);
 221}
 222
 223static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry,
 224			    const struct cred *cred)
 225{
 226	struct nfs3_accessargs	arg = {
 227		.fh		= NFS_FH(inode),
 228		.access		= entry->mask,
 229	};
 230	struct nfs3_accessres	res;
 231	struct rpc_message msg = {
 232		.rpc_proc	= &nfs3_procedures[NFS3PROC_ACCESS],
 233		.rpc_argp	= &arg,
 234		.rpc_resp	= &res,
 235		.rpc_cred	= cred,
 236	};
 237	int status = -ENOMEM;
 238
 239	dprintk("NFS call  access\n");
 240	res.fattr = nfs_alloc_fattr();
 241	if (res.fattr == NULL)
 242		goto out;
 243
 244	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 245	nfs_refresh_inode(inode, res.fattr);
 246	if (status == 0)
 247		nfs_access_set_mask(entry, res.access);
 248	nfs_free_fattr(res.fattr);
 249out:
 250	dprintk("NFS reply access: %d\n", status);
 251	return status;
 252}
 253
 254static int nfs3_proc_readlink(struct inode *inode, struct page *page,
 255		unsigned int pgbase, unsigned int pglen)
 256{
 257	struct nfs_fattr	*fattr;
 258	struct nfs3_readlinkargs args = {
 259		.fh		= NFS_FH(inode),
 260		.pgbase		= pgbase,
 261		.pglen		= pglen,
 262		.pages		= &page
 263	};
 264	struct rpc_message msg = {
 265		.rpc_proc	= &nfs3_procedures[NFS3PROC_READLINK],
 266		.rpc_argp	= &args,
 267	};
 268	int status = -ENOMEM;
 269
 270	dprintk("NFS call  readlink\n");
 271	fattr = nfs_alloc_fattr();
 272	if (fattr == NULL)
 273		goto out;
 274	msg.rpc_resp = fattr;
 275
 276	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 277	nfs_refresh_inode(inode, fattr);
 278	nfs_free_fattr(fattr);
 279out:
 280	dprintk("NFS reply readlink: %d\n", status);
 281	return status;
 282}
 283
 284struct nfs3_createdata {
 285	struct rpc_message msg;
 286	union {
 287		struct nfs3_createargs create;
 288		struct nfs3_mkdirargs mkdir;
 289		struct nfs3_symlinkargs symlink;
 290		struct nfs3_mknodargs mknod;
 291	} arg;
 292	struct nfs3_diropres res;
 293	struct nfs_fh fh;
 294	struct nfs_fattr fattr;
 295	struct nfs_fattr dir_attr;
 296};
 297
 298static struct nfs3_createdata *nfs3_alloc_createdata(void)
 299{
 300	struct nfs3_createdata *data;
 301
 302	data = kzalloc(sizeof(*data), GFP_KERNEL);
 303	if (data != NULL) {
 304		data->msg.rpc_argp = &data->arg;
 305		data->msg.rpc_resp = &data->res;
 306		data->res.fh = &data->fh;
 307		data->res.fattr = &data->fattr;
 308		data->res.dir_attr = &data->dir_attr;
 309		nfs_fattr_init(data->res.fattr);
 310		nfs_fattr_init(data->res.dir_attr);
 311	}
 312	return data;
 313}
 314
 315static struct dentry *
 316nfs3_do_create(struct inode *dir, struct dentry *dentry, struct nfs3_createdata *data)
 317{
 318	int status;
 319
 320	status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0);
 321	nfs_post_op_update_inode(dir, data->res.dir_attr);
 322	if (status != 0)
 323		return ERR_PTR(status);
 324
 325	return nfs_add_or_obtain(dentry, data->res.fh, data->res.fattr);
 326}
 327
 328static void nfs3_free_createdata(struct nfs3_createdata *data)
 329{
 330	kfree(data);
 331}
 332
 333/*
 334 * Create a regular file.
 335 */
 336static int
 337nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
 338		 int flags)
 339{
 340	struct posix_acl *default_acl, *acl;
 341	struct nfs3_createdata *data;
 342	struct dentry *d_alias;
 343	int status = -ENOMEM;
 344
 345	dprintk("NFS call  create %pd\n", dentry);
 346
 347	data = nfs3_alloc_createdata();
 348	if (data == NULL)
 349		goto out;
 350
 351	data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_CREATE];
 352	data->arg.create.fh = NFS_FH(dir);
 353	data->arg.create.name = dentry->d_name.name;
 354	data->arg.create.len = dentry->d_name.len;
 355	data->arg.create.sattr = sattr;
 356
 357	data->arg.create.createmode = NFS3_CREATE_UNCHECKED;
 358	if (flags & O_EXCL) {
 359		data->arg.create.createmode  = NFS3_CREATE_EXCLUSIVE;
 360		data->arg.create.verifier[0] = cpu_to_be32(jiffies);
 361		data->arg.create.verifier[1] = cpu_to_be32(current->pid);
 362	}
 363
 364	status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl);
 365	if (status)
 366		goto out;
 367
 368	for (;;) {
 369		d_alias = nfs3_do_create(dir, dentry, data);
 370		status = PTR_ERR_OR_ZERO(d_alias);
 371
 372		if (status != -ENOTSUPP)
 373			break;
 374		/* If the server doesn't support the exclusive creation
 375		 * semantics, try again with simple 'guarded' mode. */
 376		switch (data->arg.create.createmode) {
 377			case NFS3_CREATE_EXCLUSIVE:
 378				data->arg.create.createmode = NFS3_CREATE_GUARDED;
 379				break;
 380
 381			case NFS3_CREATE_GUARDED:
 382				data->arg.create.createmode = NFS3_CREATE_UNCHECKED;
 383				break;
 384
 385			case NFS3_CREATE_UNCHECKED:
 386				goto out_release_acls;
 387		}
 388		nfs_fattr_init(data->res.dir_attr);
 389		nfs_fattr_init(data->res.fattr);
 390	}
 391
 392	if (status != 0)
 393		goto out_release_acls;
 394
 395	if (d_alias) {
 396		if (d_is_dir(d_alias)) {
 397			status = -EISDIR;
 398			goto out_dput;
 399		}
 400		dentry = d_alias;
 401	}
 402
 403	/* When we created the file with exclusive semantics, make
 404	 * sure we set the attributes afterwards. */
 405	if (data->arg.create.createmode == NFS3_CREATE_EXCLUSIVE) {
 406		dprintk("NFS call  setattr (post-create)\n");
 407
 408		if (!(sattr->ia_valid & ATTR_ATIME_SET))
 409			sattr->ia_valid |= ATTR_ATIME;
 410		if (!(sattr->ia_valid & ATTR_MTIME_SET))
 411			sattr->ia_valid |= ATTR_MTIME;
 412
 413		/* Note: we could use a guarded setattr here, but I'm
 414		 * not sure this buys us anything (and I'd have
 415		 * to revamp the NFSv3 XDR code) */
 416		status = nfs3_proc_setattr(dentry, data->res.fattr, sattr);
 417		nfs_post_op_update_inode(d_inode(dentry), data->res.fattr);
 418		dprintk("NFS reply setattr (post-create): %d\n", status);
 419		if (status != 0)
 420			goto out_dput;
 421	}
 422
 423	status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);
 424
 425out_dput:
 426	dput(d_alias);
 427out_release_acls:
 428	posix_acl_release(acl);
 429	posix_acl_release(default_acl);
 430out:
 431	nfs3_free_createdata(data);
 432	dprintk("NFS reply create: %d\n", status);
 433	return status;
 434}
 435
 436static int
 437nfs3_proc_remove(struct inode *dir, struct dentry *dentry)
 438{
 439	struct nfs_removeargs arg = {
 440		.fh = NFS_FH(dir),
 441		.name = dentry->d_name,
 442	};
 443	struct nfs_removeres res;
 444	struct rpc_message msg = {
 445		.rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE],
 446		.rpc_argp = &arg,
 447		.rpc_resp = &res,
 448	};
 449	int status = -ENOMEM;
 450
 451	dprintk("NFS call  remove %pd2\n", dentry);
 452	res.dir_attr = nfs_alloc_fattr();
 453	if (res.dir_attr == NULL)
 454		goto out;
 455
 456	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 457	nfs_post_op_update_inode(dir, res.dir_attr);
 458	nfs_free_fattr(res.dir_attr);
 459out:
 460	dprintk("NFS reply remove: %d\n", status);
 461	return status;
 462}
 463
 464static void
 465nfs3_proc_unlink_setup(struct rpc_message *msg,
 466		struct dentry *dentry,
 467		struct inode *inode)
 468{
 469	msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE];
 470}
 471
 472static void nfs3_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
 473{
 474	rpc_call_start(task);
 475}
 476
 477static int
 478nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir)
 479{
 480	struct nfs_removeres *res;
 481	if (nfs3_async_handle_jukebox(task, dir))
 482		return 0;
 483	res = task->tk_msg.rpc_resp;
 484	nfs_post_op_update_inode(dir, res->dir_attr);
 485	return 1;
 486}
 487
 488static void
 489nfs3_proc_rename_setup(struct rpc_message *msg,
 490		struct dentry *old_dentry,
 491		struct dentry *new_dentry,
 492		struct inode *same_parent)
 493{
 494	msg->rpc_proc = &nfs3_procedures[NFS3PROC_RENAME];
 495}
 496
 497static void nfs3_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
 498{
 499	rpc_call_start(task);
 500}
 501
 502static int
 503nfs3_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
 504		      struct inode *new_dir)
 505{
 506	struct nfs_renameres *res;
 507
 508	if (nfs3_async_handle_jukebox(task, old_dir))
 509		return 0;
 510	res = task->tk_msg.rpc_resp;
 511
 512	nfs_post_op_update_inode(old_dir, res->old_fattr);
 513	nfs_post_op_update_inode(new_dir, res->new_fattr);
 514	return 1;
 515}
 516
 517static int
 518nfs3_proc_link(struct inode *inode, struct inode *dir, const struct qstr *name)
 519{
 520	struct nfs3_linkargs	arg = {
 521		.fromfh		= NFS_FH(inode),
 522		.tofh		= NFS_FH(dir),
 523		.toname		= name->name,
 524		.tolen		= name->len
 525	};
 526	struct nfs3_linkres	res;
 527	struct rpc_message msg = {
 528		.rpc_proc	= &nfs3_procedures[NFS3PROC_LINK],
 529		.rpc_argp	= &arg,
 530		.rpc_resp	= &res,
 531	};
 532	int status = -ENOMEM;
 533
 534	dprintk("NFS call  link %s\n", name->name);
 535	res.fattr = nfs_alloc_fattr();
 536	res.dir_attr = nfs_alloc_fattr();
 537	if (res.fattr == NULL || res.dir_attr == NULL)
 538		goto out;
 539
 540	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
 541	nfs_post_op_update_inode(dir, res.dir_attr);
 542	nfs_post_op_update_inode(inode, res.fattr);
 543out:
 544	nfs_free_fattr(res.dir_attr);
 545	nfs_free_fattr(res.fattr);
 546	dprintk("NFS reply link: %d\n", status);
 547	return status;
 548}
 549
 550static int
 551nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct folio *folio,
 552		  unsigned int len, struct iattr *sattr)
 553{
 554	struct page *page = &folio->page;
 555	struct nfs3_createdata *data;
 556	struct dentry *d_alias;
 557	int status = -ENOMEM;
 558
 559	if (len > NFS3_MAXPATHLEN)
 560		return -ENAMETOOLONG;
 561
 562	dprintk("NFS call  symlink %pd\n", dentry);
 563
 564	data = nfs3_alloc_createdata();
 565	if (data == NULL)
 566		goto out;
 567	data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK];
 568	data->arg.symlink.fromfh = NFS_FH(dir);
 569	data->arg.symlink.fromname = dentry->d_name.name;
 570	data->arg.symlink.fromlen = dentry->d_name.len;
 571	data->arg.symlink.pages = &page;
 572	data->arg.symlink.pathlen = len;
 573	data->arg.symlink.sattr = sattr;
 574
 575	d_alias = nfs3_do_create(dir, dentry, data);
 576	status = PTR_ERR_OR_ZERO(d_alias);
 577
 578	if (status == 0)
 579		dput(d_alias);
 580
 581	nfs3_free_createdata(data);
 582out:
 583	dprintk("NFS reply symlink: %d\n", status);
 584	return status;
 585}
 586
 587static struct dentry *
 588nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
 589{
 590	struct posix_acl *default_acl, *acl;
 591	struct nfs3_createdata *data;
 592	struct dentry *ret = ERR_PTR(-ENOMEM);
 593	int status;
 594
 595	dprintk("NFS call  mkdir %pd\n", dentry);
 596
 597	data = nfs3_alloc_createdata();
 598	if (data == NULL)
 599		goto out;
 600
 601	ret = ERR_PTR(posix_acl_create(dir, &sattr->ia_mode,
 602				       &default_acl, &acl));
 603	if (IS_ERR(ret))
 604		goto out;
 605
 606	data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR];
 607	data->arg.mkdir.fh = NFS_FH(dir);
 608	data->arg.mkdir.name = dentry->d_name.name;
 609	data->arg.mkdir.len = dentry->d_name.len;
 610	data->arg.mkdir.sattr = sattr;
 611
 612	ret = nfs3_do_create(dir, dentry, data);
 613
 614	if (IS_ERR(ret))
 615		goto out_release_acls;
 616
 617	if (ret)
 618		dentry = ret;
 619
 620	status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);
 621	if (status) {
 622		dput(ret);
 623		ret = ERR_PTR(status);
 624	}
 625
 626out_release_acls:
 627	posix_acl_release(acl);
 628	posix_acl_release(default_acl);
 629out:
 630	nfs3_free_createdata(data);
 631	dprintk("NFS reply mkdir: %d\n", PTR_ERR_OR_ZERO(ret));
 632	return ret;
 633}
 634
 635static int
 636nfs3_proc_rmdir(struct inode *dir, const struct qstr *name)
 637{
 638	struct nfs_fattr	*dir_attr;
 639	struct nfs3_diropargs	arg = {
 640		.fh		= NFS_FH(dir),
 641		.name		= name->name,
 642		.len		= name->len
 643	};
 644	struct rpc_message msg = {
 645		.rpc_proc	= &nfs3_procedures[NFS3PROC_RMDIR],
 646		.rpc_argp	= &arg,
 647	};
 648	int status = -ENOMEM;
 649
 650	dprintk("NFS call  rmdir %s\n", name->name);
 651	dir_attr = nfs_alloc_fattr();
 652	if (dir_attr == NULL)
 653		goto out;
 654
 655	msg.rpc_resp = dir_attr;
 656	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 657	nfs_post_op_update_inode(dir, dir_attr);
 658	nfs_free_fattr(dir_attr);
 659out:
 660	dprintk("NFS reply rmdir: %d\n", status);
 661	return status;
 662}
 663
 664/*
 665 * The READDIR implementation is somewhat hackish - we pass the user buffer
 666 * to the encode function, which installs it in the receive iovec.
 667 * The decode function itself doesn't perform any decoding, it just makes
 668 * sure the reply is syntactically correct.
 669 *
 670 * Also note that this implementation handles both plain readdir and
 671 * readdirplus.
 672 */
 673static int nfs3_proc_readdir(struct nfs_readdir_arg *nr_arg,
 674			     struct nfs_readdir_res *nr_res)
 675{
 676	struct inode		*dir = d_inode(nr_arg->dentry);
 677	struct nfs3_readdirargs	arg = {
 678		.fh		= NFS_FH(dir),
 679		.cookie		= nr_arg->cookie,
 680		.plus		= nr_arg->plus,
 681		.count		= nr_arg->page_len,
 682		.pages		= nr_arg->pages
 683	};
 684	struct nfs3_readdirres	res = {
 685		.verf		= nr_res->verf,
 686		.plus		= nr_arg->plus,
 687	};
 688	struct rpc_message	msg = {
 689		.rpc_proc	= &nfs3_procedures[NFS3PROC_READDIR],
 690		.rpc_argp	= &arg,
 691		.rpc_resp	= &res,
 692		.rpc_cred	= nr_arg->cred,
 693	};
 694	int status = -ENOMEM;
 695
 696	if (nr_arg->plus)
 697		msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS];
 698	if (arg.cookie)
 699		memcpy(arg.verf, nr_arg->verf, sizeof(arg.verf));
 700
 701	dprintk("NFS call  readdir%s %llu\n", nr_arg->plus ? "plus" : "",
 702		(unsigned long long)nr_arg->cookie);
 703
 704	res.dir_attr = nfs_alloc_fattr();
 705	if (res.dir_attr == NULL)
 706		goto out;
 707
 708	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
 709
 710	nfs_invalidate_atime(dir);
 711	nfs_refresh_inode(dir, res.dir_attr);
 712
 713	nfs_free_fattr(res.dir_attr);
 714out:
 715	dprintk("NFS reply readdir%s: %d\n", nr_arg->plus ? "plus" : "",
 716		status);
 717	return status;
 718}
 719
 720static int
 721nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
 722		dev_t rdev)
 723{
 724	struct posix_acl *default_acl, *acl;
 725	struct nfs3_createdata *data;
 726	struct dentry *d_alias;
 727	int status = -ENOMEM;
 728
 729	dprintk("NFS call  mknod %pd %u:%u\n", dentry,
 730			MAJOR(rdev), MINOR(rdev));
 731
 732	data = nfs3_alloc_createdata();
 733	if (data == NULL)
 734		goto out;
 735
 736	status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl);
 737	if (status)
 738		goto out;
 739
 740	data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD];
 741	data->arg.mknod.fh = NFS_FH(dir);
 742	data->arg.mknod.name = dentry->d_name.name;
 743	data->arg.mknod.len = dentry->d_name.len;
 744	data->arg.mknod.sattr = sattr;
 745	data->arg.mknod.rdev = rdev;
 746
 747	switch (sattr->ia_mode & S_IFMT) {
 748	case S_IFBLK:
 749		data->arg.mknod.type = NF3BLK;
 750		break;
 751	case S_IFCHR:
 752		data->arg.mknod.type = NF3CHR;
 753		break;
 754	case S_IFIFO:
 755		data->arg.mknod.type = NF3FIFO;
 756		break;
 757	case S_IFSOCK:
 758		data->arg.mknod.type = NF3SOCK;
 759		break;
 760	default:
 761		status = -EINVAL;
 762		goto out_release_acls;
 763	}
 764
 765	d_alias = nfs3_do_create(dir, dentry, data);
 766	status = PTR_ERR_OR_ZERO(d_alias);
 767	if (status != 0)
 768		goto out_release_acls;
 769
 770	if (d_alias)
 771		dentry = d_alias;
 772
 773	status = nfs3_proc_setacls(d_inode(dentry), acl, default_acl);
 774
 775	dput(d_alias);
 776out_release_acls:
 777	posix_acl_release(acl);
 778	posix_acl_release(default_acl);
 779out:
 780	nfs3_free_createdata(data);
 781	dprintk("NFS reply mknod: %d\n", status);
 782	return status;
 783}
 784
 785static int
 786nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
 787		 struct nfs_fsstat *stat)
 788{
 789	struct rpc_message msg = {
 790		.rpc_proc	= &nfs3_procedures[NFS3PROC_FSSTAT],
 791		.rpc_argp	= fhandle,
 792		.rpc_resp	= stat,
 793	};
 794	int	status;
 795
 796	dprintk("NFS call  fsstat\n");
 797	nfs_fattr_init(stat->fattr);
 798	status = rpc_call_sync(server->client, &msg, 0);
 799	dprintk("NFS reply fsstat: %d\n", status);
 800	return status;
 801}
 802
 803static int
 804do_proc_fsinfo(struct rpc_clnt *client, struct nfs_fh *fhandle,
 805		 struct nfs_fsinfo *info)
 806{
 807	struct rpc_message msg = {
 808		.rpc_proc	= &nfs3_procedures[NFS3PROC_FSINFO],
 809		.rpc_argp	= fhandle,
 810		.rpc_resp	= info,
 811	};
 812	int	status;
 813
 814	dprintk("NFS call  fsinfo\n");
 815	nfs_fattr_init(info->fattr);
 816	status = rpc_call_sync(client, &msg, 0);
 817	dprintk("NFS reply fsinfo: %d\n", status);
 818	return status;
 819}
 820
 821/*
 822 * Bare-bones access to fsinfo: this is for nfs_get_root/nfs_get_sb via
 823 * nfs_create_server
 824 */
 825static int
 826nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
 827		   struct nfs_fsinfo *info)
 828{
 829	int	status;
 830
 831	status = do_proc_fsinfo(server->client, fhandle, info);
 832	if (status && server->nfs_client->cl_rpcclient != server->client)
 833		status = do_proc_fsinfo(server->nfs_client->cl_rpcclient, fhandle, info);
 834	return status;
 835}
 836
 837static int
 838nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
 839		   struct nfs_pathconf *info)
 840{
 841	struct rpc_message msg = {
 842		.rpc_proc	= &nfs3_procedures[NFS3PROC_PATHCONF],
 843		.rpc_argp	= fhandle,
 844		.rpc_resp	= info,
 845	};
 846	int	status;
 847
 848	dprintk("NFS call  pathconf\n");
 849	nfs_fattr_init(info->fattr);
 850	status = rpc_call_sync(server->client, &msg, 0);
 851	dprintk("NFS reply pathconf: %d\n", status);
 852	return status;
 853}
 854
 855#if IS_ENABLED(CONFIG_NFS_LOCALIO)
 856
 857static unsigned nfs3_localio_probe_throttle __read_mostly = 0;
 858module_param(nfs3_localio_probe_throttle, uint, 0644);
 859MODULE_PARM_DESC(nfs3_localio_probe_throttle,
 860		 "Probe for NFSv3 LOCALIO every N IO requests. Must be power-of-2, defaults to 0 (probing disabled).");
 861
 862static void nfs3_localio_probe(struct nfs_server *server)
 863{
 864	struct nfs_client *clp = server->nfs_client;
 865
 866	/* Throttled to reduce nfs_local_probe_async() frequency */
 867	if (!nfs3_localio_probe_throttle || nfs_server_is_local(clp))
 868		return;
 869
 870	/*
 871	 * Try (re)enabling LOCALIO if isn't enabled -- admin deems
 872	 * it worthwhile to periodically check if LOCALIO possible by
 873	 * setting the 'nfs3_localio_probe_throttle' module parameter.
 874	 *
 875	 * This is useful if LOCALIO was previously enabled, but was
 876	 * disabled due to server restart, and IO has successfully
 877	 * completed in terms of normal RPC.
 878	 */
 879	if ((clp->cl_uuid.nfs3_localio_probe_count++ &
 880	     (nfs3_localio_probe_throttle - 1)) == 0) {
 881		if (!nfs_server_is_local(clp))
 882			nfs_local_probe_async(clp);
 883	}
 884}
 885
 886#else
 887static void nfs3_localio_probe(struct nfs_server *server) {}
 888#endif
 889
 890static int nfs3_read_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
 891{
 892	struct inode *inode = hdr->inode;
 893	struct nfs_server *server = NFS_SERVER(inode);
 894
 895	if (hdr->pgio_done_cb != NULL)
 896		return hdr->pgio_done_cb(task, hdr);
 897
 898	if (nfs3_async_handle_jukebox(task, inode))
 899		return -EAGAIN;
 900
 901	if (task->tk_status >= 0) {
 902		if (!server->read_hdrsize)
 903			cmpxchg(&server->read_hdrsize, 0, hdr->res.replen);
 904		nfs3_localio_probe(server);
 905	}
 906
 907	nfs_invalidate_atime(inode);
 908	nfs_refresh_inode(inode, &hdr->fattr);
 909	return 0;
 910}
 911
 912static void nfs3_proc_read_setup(struct nfs_pgio_header *hdr,
 913				 struct rpc_message *msg)
 914{
 915	msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ];
 916	hdr->args.replen = NFS_SERVER(hdr->inode)->read_hdrsize;
 917}
 918
 919static int nfs3_proc_pgio_rpc_prepare(struct rpc_task *task,
 920				      struct nfs_pgio_header *hdr)
 921{
 922	rpc_call_start(task);
 923	return 0;
 924}
 925
 926static int nfs3_write_done(struct rpc_task *task, struct nfs_pgio_header *hdr)
 927{
 928	struct inode *inode = hdr->inode;
 929
 930	if (hdr->pgio_done_cb != NULL)
 931		return hdr->pgio_done_cb(task, hdr);
 932
 933	if (nfs3_async_handle_jukebox(task, inode))
 934		return -EAGAIN;
 935	if (task->tk_status >= 0) {
 936		nfs_writeback_update_inode(hdr);
 937		nfs3_localio_probe(NFS_SERVER(inode));
 938	}
 939	return 0;
 940}
 941
 942static void nfs3_proc_write_setup(struct nfs_pgio_header *hdr,
 943				  struct rpc_message *msg,
 944				  struct rpc_clnt **clnt)
 945{
 946	msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE];
 947}
 948
 949static void nfs3_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
 950{
 951	rpc_call_start(task);
 952}
 953
 954static int nfs3_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
 955{
 956	if (data->commit_done_cb != NULL)
 957		return data->commit_done_cb(task, data);
 958
 959	if (nfs3_async_handle_jukebox(task, data->inode))
 960		return -EAGAIN;
 961	nfs_refresh_inode(data->inode, data->res.fattr);
 962	return 0;
 963}
 964
 965static void nfs3_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg,
 966				   struct rpc_clnt **clnt)
 967{
 968	msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT];
 969}
 970
 971static void nfs3_nlm_alloc_call(void *data)
 972{
 973	struct nfs_lock_context *l_ctx = data;
 974	if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags)) {
 975		get_nfs_open_context(l_ctx->open_context);
 976		nfs_get_lock_context(l_ctx->open_context);
 977	}
 978}
 979
 980static bool nfs3_nlm_unlock_prepare(struct rpc_task *task, void *data)
 981{
 982	struct nfs_lock_context *l_ctx = data;
 983	if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags))
 984		return nfs_async_iocounter_wait(task, l_ctx);
 985	return false;
 986
 987}
 988
 989static void nfs3_nlm_release_call(void *data)
 990{
 991	struct nfs_lock_context *l_ctx = data;
 992	struct nfs_open_context *ctx;
 993	if (l_ctx && test_bit(NFS_CONTEXT_UNLOCK, &l_ctx->open_context->flags)) {
 994		ctx = l_ctx->open_context;
 995		nfs_put_lock_context(l_ctx);
 996		put_nfs_open_context(ctx);
 997	}
 998}
 999
1000static const struct nlmclnt_operations nlmclnt_fl_close_lock_ops = {
1001	.nlmclnt_alloc_call = nfs3_nlm_alloc_call,
1002	.nlmclnt_unlock_prepare = nfs3_nlm_unlock_prepare,
1003	.nlmclnt_release_call = nfs3_nlm_release_call,
1004};
1005
1006static int
1007nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
1008{
1009	struct inode *inode = file_inode(filp);
1010	struct nfs_lock_context *l_ctx = NULL;
1011	struct nfs_open_context *ctx = nfs_file_open_context(filp);
1012	int status;
1013
1014	if (fl->c.flc_flags & FL_CLOSE) {
1015		l_ctx = nfs_get_lock_context(ctx);
1016		if (IS_ERR(l_ctx))
1017			l_ctx = NULL;
1018		else
1019			set_bit(NFS_CONTEXT_UNLOCK, &ctx->flags);
1020	}
1021
1022	status = nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl, l_ctx);
1023
1024	if (l_ctx)
1025		nfs_put_lock_context(l_ctx);
1026
1027	return status;
1028}
1029
1030static int nfs3_have_delegation(struct inode *inode, fmode_t type, int flags)
1031{
1032	return 0;
1033}
1034
1035static int nfs3_return_delegation(struct inode *inode)
1036{
1037	if (S_ISREG(inode->i_mode))
1038		nfs_wb_all(inode);
1039	return 0;
1040}
1041
1042static const struct inode_operations nfs3_dir_inode_operations = {
1043	.create		= nfs_create,
1044	.atomic_open	= nfs_atomic_open_v23,
1045	.lookup		= nfs_lookup,
1046	.link		= nfs_link,
1047	.unlink		= nfs_unlink,
1048	.symlink	= nfs_symlink,
1049	.mkdir		= nfs_mkdir,
1050	.rmdir		= nfs_rmdir,
1051	.mknod		= nfs_mknod,
1052	.rename		= nfs_rename,
1053	.permission	= nfs_permission,
1054	.getattr	= nfs_getattr,
1055	.setattr	= nfs_setattr,
1056#ifdef CONFIG_NFS_V3_ACL
1057	.listxattr	= nfs3_listxattr,
1058	.get_inode_acl	= nfs3_get_acl,
1059	.set_acl	= nfs3_set_acl,
1060#endif
1061};
1062
1063static const struct inode_operations nfs3_file_inode_operations = {
1064	.permission	= nfs_permission,
1065	.getattr	= nfs_getattr,
1066	.setattr	= nfs_setattr,
1067#ifdef CONFIG_NFS_V3_ACL
1068	.listxattr	= nfs3_listxattr,
1069	.get_inode_acl	= nfs3_get_acl,
1070	.set_acl	= nfs3_set_acl,
1071#endif
1072};
1073
1074const struct nfs_rpc_ops nfs_v3_clientops = {
1075	.version	= 3,			/* protocol version */
1076	.dentry_ops	= &nfs_dentry_operations,
1077	.dir_inode_ops	= &nfs3_dir_inode_operations,
1078	.file_inode_ops	= &nfs3_file_inode_operations,
1079	.file_ops	= &nfs_file_operations,
1080	.nlmclnt_ops	= &nlmclnt_fl_close_lock_ops,
1081	.getroot	= nfs3_proc_get_root,
1082	.submount	= nfs_submount,
1083	.try_get_tree	= nfs_try_get_tree,
1084	.getattr	= nfs3_proc_getattr,
1085	.setattr	= nfs3_proc_setattr,
1086	.lookup		= nfs3_proc_lookup,
1087	.lookupp	= nfs3_proc_lookupp,
1088	.access		= nfs3_proc_access,
1089	.readlink	= nfs3_proc_readlink,
1090	.create		= nfs3_proc_create,
1091	.remove		= nfs3_proc_remove,
1092	.unlink_setup	= nfs3_proc_unlink_setup,
1093	.unlink_rpc_prepare = nfs3_proc_unlink_rpc_prepare,
1094	.unlink_done	= nfs3_proc_unlink_done,
1095	.rename_setup	= nfs3_proc_rename_setup,
1096	.rename_rpc_prepare = nfs3_proc_rename_rpc_prepare,
1097	.rename_done	= nfs3_proc_rename_done,
1098	.link		= nfs3_proc_link,
1099	.symlink	= nfs3_proc_symlink,
1100	.mkdir		= nfs3_proc_mkdir,
1101	.rmdir		= nfs3_proc_rmdir,
1102	.readdir	= nfs3_proc_readdir,
1103	.mknod		= nfs3_proc_mknod,
1104	.statfs		= nfs3_proc_statfs,
1105	.fsinfo		= nfs3_proc_fsinfo,
1106	.pathconf	= nfs3_proc_pathconf,
1107	.decode_dirent	= nfs3_decode_dirent,
1108	.pgio_rpc_prepare = nfs3_proc_pgio_rpc_prepare,
1109	.read_setup	= nfs3_proc_read_setup,
1110	.read_done	= nfs3_read_done,
1111	.write_setup	= nfs3_proc_write_setup,
1112	.write_done	= nfs3_write_done,
1113	.commit_setup	= nfs3_proc_commit_setup,
1114	.commit_rpc_prepare = nfs3_proc_commit_rpc_prepare,
1115	.commit_done	= nfs3_commit_done,
1116	.lock		= nfs3_proc_lock,
1117	.clear_acl_cache = forget_all_cached_acls,
1118	.close_context	= nfs_close_context,
1119	.have_delegation = nfs3_have_delegation,
1120	.return_delegation = nfs3_return_delegation,
1121	.alloc_client	= nfs_alloc_client,
1122	.init_client	= nfs_init_client,
1123	.free_client	= nfs_free_client,
1124	.create_server	= nfs3_create_server,
1125	.clone_server	= nfs3_clone_server,
1126};