nfs3proc.c 21.2 KB
Newer Older
L
Linus Torvalds 已提交
1 2 3 4 5 6 7 8 9 10 11 12
/*
 *  linux/fs/nfs/nfs3proc.c
 *
 *  Client-side NFSv3 procedures stubs.
 *
 *  Copyright (C) 1997, Olaf Kirch
 */

#include <linux/mm.h>
#include <linux/errno.h>
#include <linux/string.h>
#include <linux/sunrpc/clnt.h>
13
#include <linux/slab.h>
L
Linus Torvalds 已提交
14 15 16 17 18
#include <linux/nfs.h>
#include <linux/nfs3.h>
#include <linux/nfs_fs.h>
#include <linux/nfs_page.h>
#include <linux/lockd/bind.h>
19
#include <linux/nfs_mount.h>
L
Linus Torvalds 已提交
20

21
#include "iostat.h"
D
David Howells 已提交
22
#include "internal.h"
23

L
Linus Torvalds 已提交
24 25
#define NFSDBG_FACILITY		NFSDBG_PROC

26
/* A wrapper to handle the EJUKEBOX and EKEYEXPIRED error messages */
L
Linus Torvalds 已提交
27 28 29 30 31 32
static int
nfs3_rpc_wrapper(struct rpc_clnt *clnt, struct rpc_message *msg, int flags)
{
	int res;
	do {
		res = rpc_call_sync(clnt, msg, flags);
33
		if (res != -EJUKEBOX && res != -EKEYEXPIRED)
L
Linus Torvalds 已提交
34
			break;
35
		schedule_timeout_killable(NFS_JUKEBOX_RETRY_TIME);
L
Linus Torvalds 已提交
36
		res = -ERESTARTSYS;
37
	} while (!fatal_signal_pending(current));
L
Linus Torvalds 已提交
38 39 40
	return res;
}

C
Chuck Lever 已提交
41
#define rpc_call_sync(clnt, msg, flags)	nfs3_rpc_wrapper(clnt, msg, flags)
L
Linus Torvalds 已提交
42 43

static int
44
nfs3_async_handle_jukebox(struct rpc_task *task, struct inode *inode)
L
Linus Torvalds 已提交
45
{
46
	if (task->tk_status != -EJUKEBOX && task->tk_status != -EKEYEXPIRED)
L
Linus Torvalds 已提交
47
		return 0;
48 49
	if (task->tk_status == -EJUKEBOX)
		nfs_inc_stats(inode, NFSIOS_DELAY);
L
Linus Torvalds 已提交
50 51 52 53 54 55 56
	task->tk_status = 0;
	rpc_restart_call(task);
	rpc_delay(task, NFS_JUKEBOX_RETRY_TIME);
	return 1;
}

static int
57 58
do_proc_get_root(struct rpc_clnt *client, struct nfs_fh *fhandle,
		 struct nfs_fsinfo *info)
L
Linus Torvalds 已提交
59
{
C
Chuck Lever 已提交
60 61 62 63 64
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_FSINFO],
		.rpc_argp	= fhandle,
		.rpc_resp	= info,
	};
L
Linus Torvalds 已提交
65 66
	int	status;

67
	dprintk("%s: call  fsinfo\n", __func__);
68
	nfs_fattr_init(info->fattr);
C
Chuck Lever 已提交
69
	status = rpc_call_sync(client, &msg, 0);
70
	dprintk("%s: reply fsinfo: %d\n", __func__, status);
L
Linus Torvalds 已提交
71
	if (!(info->fattr->valid & NFS_ATTR_FATTR)) {
C
Chuck Lever 已提交
72 73 74
		msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
		msg.rpc_resp = info->fattr;
		status = rpc_call_sync(client, &msg, 0);
75
		dprintk("%s: reply getattr: %d\n", __func__, status);
L
Linus Torvalds 已提交
76 77 78 79
	}
	return status;
}

80
/*
81
 * Bare-bones access to getattr: this is for nfs_get_root/nfs_get_sb
82 83 84 85 86 87 88 89
 */
static int
nfs3_proc_get_root(struct nfs_server *server, struct nfs_fh *fhandle,
		   struct nfs_fsinfo *info)
{
	int	status;

	status = do_proc_get_root(server->client, fhandle, info);
90 91
	if (status && server->nfs_client->cl_rpcclient != server->client)
		status = do_proc_get_root(server->nfs_client->cl_rpcclient, fhandle, info);
92 93 94
	return status;
}

L
Linus Torvalds 已提交
95 96 97 98 99 100 101
/*
 * One function for each procedure in the NFS protocol.
 */
static int
nfs3_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle,
		struct nfs_fattr *fattr)
{
C
Chuck Lever 已提交
102 103 104 105 106
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_GETATTR],
		.rpc_argp	= fhandle,
		.rpc_resp	= fattr,
	};
L
Linus Torvalds 已提交
107 108 109
	int	status;

	dprintk("NFS call  getattr\n");
110
	nfs_fattr_init(fattr);
C
Chuck Lever 已提交
111
	status = rpc_call_sync(server->client, &msg, 0);
L
Linus Torvalds 已提交
112 113 114 115 116 117 118 119 120 121 122 123 124
	dprintk("NFS reply getattr: %d\n", status);
	return status;
}

static int
nfs3_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
			struct iattr *sattr)
{
	struct inode *inode = dentry->d_inode;
	struct nfs3_sattrargs	arg = {
		.fh		= NFS_FH(inode),
		.sattr		= sattr,
	};
C
Chuck Lever 已提交
125 126 127 128 129
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_SETATTR],
		.rpc_argp	= &arg,
		.rpc_resp	= fattr,
	};
L
Linus Torvalds 已提交
130 131 132
	int	status;

	dprintk("NFS call  setattr\n");
133 134
	if (sattr->ia_valid & ATTR_FILE)
		msg.rpc_cred = nfs_file_cred(sattr->ia_file);
135
	nfs_fattr_init(fattr);
C
Chuck Lever 已提交
136
	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
137 138
	if (status == 0)
		nfs_setattr_update_inode(inode, sattr);
L
Linus Torvalds 已提交
139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
	dprintk("NFS reply setattr: %d\n", status);
	return status;
}

static int
nfs3_proc_lookup(struct inode *dir, struct qstr *name,
		 struct nfs_fh *fhandle, struct nfs_fattr *fattr)
{
	struct nfs3_diropargs	arg = {
		.fh		= NFS_FH(dir),
		.name		= name->name,
		.len		= name->len
	};
	struct nfs3_diropres	res = {
		.fh		= fhandle,
		.fattr		= fattr
	};
C
Chuck Lever 已提交
156 157 158 159 160
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_LOOKUP],
		.rpc_argp	= &arg,
		.rpc_resp	= &res,
	};
L
Linus Torvalds 已提交
161 162 163
	int			status;

	dprintk("NFS call  lookup %s\n", name->name);
164 165 166 167
	res.dir_attr = nfs_alloc_fattr();
	if (res.dir_attr == NULL)
		return -ENOMEM;

168
	nfs_fattr_init(fattr);
C
Chuck Lever 已提交
169
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
170
	nfs_refresh_inode(dir, res.dir_attr);
C
Chuck Lever 已提交
171 172 173 174 175 176
	if (status >= 0 && !(fattr->valid & NFS_ATTR_FATTR)) {
		msg.rpc_proc = &nfs3_procedures[NFS3PROC_GETATTR];
		msg.rpc_argp = fhandle;
		msg.rpc_resp = fattr;
		status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
	}
177
	nfs_free_fattr(res.dir_attr);
L
Linus Torvalds 已提交
178 179 180 181 182 183 184 185 186
	dprintk("NFS reply lookup: %d\n", status);
	return status;
}

static int nfs3_proc_access(struct inode *inode, struct nfs_access_entry *entry)
{
	struct nfs3_accessargs	arg = {
		.fh		= NFS_FH(inode),
	};
187
	struct nfs3_accessres	res;
L
Linus Torvalds 已提交
188 189 190 191
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_ACCESS],
		.rpc_argp	= &arg,
		.rpc_resp	= &res,
C
Chuck Lever 已提交
192
		.rpc_cred	= entry->cred,
L
Linus Torvalds 已提交
193 194
	};
	int mode = entry->mask;
195
	int status = -ENOMEM;
L
Linus Torvalds 已提交
196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211

	dprintk("NFS call  access\n");

	if (mode & MAY_READ)
		arg.access |= NFS3_ACCESS_READ;
	if (S_ISDIR(inode->i_mode)) {
		if (mode & MAY_WRITE)
			arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE;
		if (mode & MAY_EXEC)
			arg.access |= NFS3_ACCESS_LOOKUP;
	} else {
		if (mode & MAY_WRITE)
			arg.access |= NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND;
		if (mode & MAY_EXEC)
			arg.access |= NFS3_ACCESS_EXECUTE;
	}
212 213 214 215 216

	res.fattr = nfs_alloc_fattr();
	if (res.fattr == NULL)
		goto out;

L
Linus Torvalds 已提交
217
	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
218
	nfs_refresh_inode(inode, res.fattr);
L
Linus Torvalds 已提交
219 220 221 222 223 224 225 226 227
	if (status == 0) {
		entry->mask = 0;
		if (res.access & NFS3_ACCESS_READ)
			entry->mask |= MAY_READ;
		if (res.access & (NFS3_ACCESS_MODIFY | NFS3_ACCESS_EXTEND | NFS3_ACCESS_DELETE))
			entry->mask |= MAY_WRITE;
		if (res.access & (NFS3_ACCESS_LOOKUP|NFS3_ACCESS_EXECUTE))
			entry->mask |= MAY_EXEC;
	}
228 229
	nfs_free_fattr(res.fattr);
out:
L
Linus Torvalds 已提交
230 231 232 233 234 235 236 237 238 239 240 241 242 243
	dprintk("NFS reply access: %d\n", status);
	return status;
}

static int nfs3_proc_readlink(struct inode *inode, struct page *page,
		unsigned int pgbase, unsigned int pglen)
{
	struct nfs_fattr	fattr;
	struct nfs3_readlinkargs args = {
		.fh		= NFS_FH(inode),
		.pgbase		= pgbase,
		.pglen		= pglen,
		.pages		= &page
	};
C
Chuck Lever 已提交
244 245 246 247 248
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_READLINK],
		.rpc_argp	= &args,
		.rpc_resp	= &fattr,
	};
L
Linus Torvalds 已提交
249 250 251
	int			status;

	dprintk("NFS call  readlink\n");
252
	nfs_fattr_init(&fattr);
C
Chuck Lever 已提交
253
	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
L
Linus Torvalds 已提交
254 255 256 257 258
	nfs_refresh_inode(inode, &fattr);
	dprintk("NFS reply readlink: %d\n", status);
	return status;
}

259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305
struct nfs3_createdata {
	struct rpc_message msg;
	union {
		struct nfs3_createargs create;
		struct nfs3_mkdirargs mkdir;
		struct nfs3_symlinkargs symlink;
		struct nfs3_mknodargs mknod;
	} arg;
	struct nfs3_diropres res;
	struct nfs_fh fh;
	struct nfs_fattr fattr;
	struct nfs_fattr dir_attr;
};

static struct nfs3_createdata *nfs3_alloc_createdata(void)
{
	struct nfs3_createdata *data;

	data = kzalloc(sizeof(*data), GFP_KERNEL);
	if (data != NULL) {
		data->msg.rpc_argp = &data->arg;
		data->msg.rpc_resp = &data->res;
		data->res.fh = &data->fh;
		data->res.fattr = &data->fattr;
		data->res.dir_attr = &data->dir_attr;
		nfs_fattr_init(data->res.fattr);
		nfs_fattr_init(data->res.dir_attr);
	}
	return data;
}

static int nfs3_do_create(struct inode *dir, struct dentry *dentry, struct nfs3_createdata *data)
{
	int status;

	status = rpc_call_sync(NFS_CLIENT(dir), &data->msg, 0);
	nfs_post_op_update_inode(dir, data->res.dir_attr);
	if (status == 0)
		status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
	return status;
}

static void nfs3_free_createdata(struct nfs3_createdata *data)
{
	kfree(data);
}

L
Linus Torvalds 已提交
306 307 308 309 310
/*
 * Create a regular file.
 */
static int
nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
311
		 int flags, struct nameidata *nd)
L
Linus Torvalds 已提交
312
{
313
	struct nfs3_createdata *data;
314
	mode_t mode = sattr->ia_mode;
315
	int status = -ENOMEM;
L
Linus Torvalds 已提交
316 317

	dprintk("NFS call  create %s\n", dentry->d_name.name);
318 319 320 321 322 323 324 325 326 327 328 329

	data = nfs3_alloc_createdata();
	if (data == NULL)
		goto out;

	data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_CREATE];
	data->arg.create.fh = NFS_FH(dir);
	data->arg.create.name = dentry->d_name.name;
	data->arg.create.len = dentry->d_name.len;
	data->arg.create.sattr = sattr;

	data->arg.create.createmode = NFS3_CREATE_UNCHECKED;
L
Linus Torvalds 已提交
330
	if (flags & O_EXCL) {
331 332 333
		data->arg.create.createmode  = NFS3_CREATE_EXCLUSIVE;
		data->arg.create.verifier[0] = jiffies;
		data->arg.create.verifier[1] = current->pid;
L
Linus Torvalds 已提交
334 335
	}

A
Al Viro 已提交
336
	sattr->ia_mode &= ~current_umask();
337

338 339
	for (;;) {
		status = nfs3_do_create(dir, dentry, data);
L
Linus Torvalds 已提交
340

341 342 343 344 345
		if (status != -ENOTSUPP)
			break;
		/* If the server doesn't support the exclusive creation
		 * semantics, try again with simple 'guarded' mode. */
		switch (data->arg.create.createmode) {
L
Linus Torvalds 已提交
346
			case NFS3_CREATE_EXCLUSIVE:
347
				data->arg.create.createmode = NFS3_CREATE_GUARDED;
L
Linus Torvalds 已提交
348 349 350
				break;

			case NFS3_CREATE_GUARDED:
351
				data->arg.create.createmode = NFS3_CREATE_UNCHECKED;
L
Linus Torvalds 已提交
352 353 354 355 356
				break;

			case NFS3_CREATE_UNCHECKED:
				goto out;
		}
357 358
		nfs_fattr_init(data->res.dir_attr);
		nfs_fattr_init(data->res.fattr);
L
Linus Torvalds 已提交
359 360 361 362 363 364 365
	}

	if (status != 0)
		goto out;

	/* When we created the file with exclusive semantics, make
	 * sure we set the attributes afterwards. */
366
	if (data->arg.create.createmode == NFS3_CREATE_EXCLUSIVE) {
L
Linus Torvalds 已提交
367 368 369 370 371 372 373 374 375 376
		dprintk("NFS call  setattr (post-create)\n");

		if (!(sattr->ia_valid & ATTR_ATIME_SET))
			sattr->ia_valid |= ATTR_ATIME;
		if (!(sattr->ia_valid & ATTR_MTIME_SET))
			sattr->ia_valid |= ATTR_MTIME;

		/* Note: we could use a guarded setattr here, but I'm
		 * not sure this buys us anything (and I'd have
		 * to revamp the NFSv3 XDR code) */
377 378
		status = nfs3_proc_setattr(dentry, data->res.fattr, sattr);
		nfs_post_op_update_inode(dentry->d_inode, data->res.fattr);
L
Linus Torvalds 已提交
379
		dprintk("NFS reply setattr (post-create): %d\n", status);
380 381
		if (status != 0)
			goto out;
L
Linus Torvalds 已提交
382
	}
383
	status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
L
Linus Torvalds 已提交
384
out:
385
	nfs3_free_createdata(data);
L
Linus Torvalds 已提交
386 387 388 389 390 391 392
	dprintk("NFS reply create: %d\n", status);
	return status;
}

static int
nfs3_proc_remove(struct inode *dir, struct qstr *name)
{
393 394 395 396
	struct nfs_removeargs arg = {
		.fh = NFS_FH(dir),
		.name.len = name->len,
		.name.name = name->name,
L
Linus Torvalds 已提交
397
	};
398 399 400 401 402
	struct nfs_removeres res;
	struct rpc_message msg = {
		.rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE],
		.rpc_argp = &arg,
		.rpc_resp = &res,
L
Linus Torvalds 已提交
403 404 405 406
	};
	int			status;

	dprintk("NFS call  remove %s\n", name->name);
407
	nfs_fattr_init(&res.dir_attr);
L
Linus Torvalds 已提交
408
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
409
	nfs_post_op_update_inode(dir, &res.dir_attr);
L
Linus Torvalds 已提交
410 411 412 413
	dprintk("NFS reply remove: %d\n", status);
	return status;
}

414 415
static void
nfs3_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
L
Linus Torvalds 已提交
416 417 418 419 420
{
	msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE];
}

static int
421
nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir)
L
Linus Torvalds 已提交
422
{
423 424 425 426 427 428
	struct nfs_removeres *res;
	if (nfs3_async_handle_jukebox(task, dir))
		return 0;
	res = task->tk_msg.rpc_resp;
	nfs_post_op_update_inode(dir, &res->dir_attr);
	return 1;
L
Linus Torvalds 已提交
429 430 431 432 433 434 435 436 437 438 439 440 441 442
}

static int
nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name,
		 struct inode *new_dir, struct qstr *new_name)
{
	struct nfs3_renameargs	arg = {
		.fromfh		= NFS_FH(old_dir),
		.fromname	= old_name->name,
		.fromlen	= old_name->len,
		.tofh		= NFS_FH(new_dir),
		.toname		= new_name->name,
		.tolen		= new_name->len
	};
443
	struct nfs3_renameres res;
C
Chuck Lever 已提交
444 445 446 447 448
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_RENAME],
		.rpc_argp	= &arg,
		.rpc_resp	= &res,
	};
449
	int status = -ENOMEM;
L
Linus Torvalds 已提交
450 451

	dprintk("NFS call  rename %s -> %s\n", old_name->name, new_name->name);
452 453 454 455 456 457

	res.fromattr = nfs_alloc_fattr();
	res.toattr = nfs_alloc_fattr();
	if (res.fromattr == NULL || res.toattr == NULL)
		goto out;

C
Chuck Lever 已提交
458
	status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
459 460 461 462 463
	nfs_post_op_update_inode(old_dir, res.fromattr);
	nfs_post_op_update_inode(new_dir, res.toattr);
out:
	nfs_free_fattr(res.toattr);
	nfs_free_fattr(res.fromattr);
L
Linus Torvalds 已提交
464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481
	dprintk("NFS reply rename: %d\n", status);
	return status;
}

static int
nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
{
	struct nfs_fattr	dir_attr, fattr;
	struct nfs3_linkargs	arg = {
		.fromfh		= NFS_FH(inode),
		.tofh		= NFS_FH(dir),
		.toname		= name->name,
		.tolen		= name->len
	};
	struct nfs3_linkres	res = {
		.dir_attr	= &dir_attr,
		.fattr		= &fattr
	};
C
Chuck Lever 已提交
482 483 484 485 486
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_LINK],
		.rpc_argp	= &arg,
		.rpc_resp	= &res,
	};
L
Linus Torvalds 已提交
487 488 489
	int			status;

	dprintk("NFS call  link %s\n", name->name);
490 491
	nfs_fattr_init(&dir_attr);
	nfs_fattr_init(&fattr);
C
Chuck Lever 已提交
492
	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
493 494
	nfs_post_op_update_inode(dir, &dir_attr);
	nfs_post_op_update_inode(inode, &fattr);
L
Linus Torvalds 已提交
495 496 497 498 499
	dprintk("NFS reply link: %d\n", status);
	return status;
}

static int
500 501
nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
		  unsigned int len, struct iattr *sattr)
L
Linus Torvalds 已提交
502
{
503 504
	struct nfs3_createdata *data;
	int status = -ENOMEM;
L
Linus Torvalds 已提交
505

506
	if (len > NFS3_MAXPATHLEN)
L
Linus Torvalds 已提交
507
		return -ENAMETOOLONG;
508

509 510
	dprintk("NFS call  symlink %s\n", dentry->d_name.name);

511 512
	data = nfs3_alloc_createdata();
	if (data == NULL)
513
		goto out;
514 515 516 517 518 519 520 521 522 523 524
	data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_SYMLINK];
	data->arg.symlink.fromfh = NFS_FH(dir);
	data->arg.symlink.fromname = dentry->d_name.name;
	data->arg.symlink.fromlen = dentry->d_name.len;
	data->arg.symlink.pages = &page;
	data->arg.symlink.pathlen = len;
	data->arg.symlink.sattr = sattr;

	status = nfs3_do_create(dir, dentry, data);

	nfs3_free_createdata(data);
525
out:
L
Linus Torvalds 已提交
526 527 528 529 530 531 532
	dprintk("NFS reply symlink: %d\n", status);
	return status;
}

static int
nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
{
533
	struct nfs3_createdata *data;
534
	int mode = sattr->ia_mode;
535
	int status = -ENOMEM;
L
Linus Torvalds 已提交
536 537

	dprintk("NFS call  mkdir %s\n", dentry->d_name.name);
538

A
Al Viro 已提交
539
	sattr->ia_mode &= ~current_umask();
540

541 542
	data = nfs3_alloc_createdata();
	if (data == NULL)
543
		goto out;
544 545 546 547 548 549 550 551

	data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKDIR];
	data->arg.mkdir.fh = NFS_FH(dir);
	data->arg.mkdir.name = dentry->d_name.name;
	data->arg.mkdir.len = dentry->d_name.len;
	data->arg.mkdir.sattr = sattr;

	status = nfs3_do_create(dir, dentry, data);
552 553
	if (status != 0)
		goto out;
554

555 556
	status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
out:
557
	nfs3_free_createdata(data);
L
Linus Torvalds 已提交
558 559 560 561 562 563 564 565 566 567 568 569 570
	dprintk("NFS reply mkdir: %d\n", status);
	return status;
}

static int
nfs3_proc_rmdir(struct inode *dir, struct qstr *name)
{
	struct nfs_fattr	dir_attr;
	struct nfs3_diropargs	arg = {
		.fh		= NFS_FH(dir),
		.name		= name->name,
		.len		= name->len
	};
C
Chuck Lever 已提交
571 572 573 574 575
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_RMDIR],
		.rpc_argp	= &arg,
		.rpc_resp	= &dir_attr,
	};
L
Linus Torvalds 已提交
576 577 578
	int			status;

	dprintk("NFS call  rmdir %s\n", name->name);
579
	nfs_fattr_init(&dir_attr);
C
Chuck Lever 已提交
580
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
581
	nfs_post_op_update_inode(dir, &dir_attr);
L
Linus Torvalds 已提交
582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600
	dprintk("NFS reply rmdir: %d\n", status);
	return status;
}

/*
 * The READDIR implementation is somewhat hackish - we pass the user buffer
 * to the encode function, which installs it in the receive iovec.
 * The decode function itself doesn't perform any decoding, it just makes
 * sure the reply is syntactically correct.
 *
 * Also note that this implementation handles both plain readdir and
 * readdirplus.
 */
static int
nfs3_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
		  u64 cookie, struct page *page, unsigned int count, int plus)
{
	struct inode		*dir = dentry->d_inode;
	struct nfs_fattr	dir_attr;
A
Al Viro 已提交
601
	__be32			*verf = NFS_COOKIEVERF(dir);
L
Linus Torvalds 已提交
602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628
	struct nfs3_readdirargs	arg = {
		.fh		= NFS_FH(dir),
		.cookie		= cookie,
		.verf		= {verf[0], verf[1]},
		.plus		= plus,
		.count		= count,
		.pages		= &page
	};
	struct nfs3_readdirres	res = {
		.dir_attr	= &dir_attr,
		.verf		= verf,
		.plus		= plus
	};
	struct rpc_message	msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_READDIR],
		.rpc_argp	= &arg,
		.rpc_resp	= &res,
		.rpc_cred	= cred
	};
	int			status;

	if (plus)
		msg.rpc_proc = &nfs3_procedures[NFS3PROC_READDIRPLUS];

	dprintk("NFS call  readdir%s %d\n",
			plus? "plus" : "", (unsigned int) cookie);

629
	nfs_fattr_init(&dir_attr);
L
Linus Torvalds 已提交
630
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
631 632 633

	nfs_invalidate_atime(dir);

L
Linus Torvalds 已提交
634 635 636 637 638 639 640 641 642
	nfs_refresh_inode(dir, &dir_attr);
	dprintk("NFS reply readdir: %d\n", status);
	return status;
}

static int
nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
		dev_t rdev)
{
643
	struct nfs3_createdata *data;
644
	mode_t mode = sattr->ia_mode;
645
	int status = -ENOMEM;
L
Linus Torvalds 已提交
646 647 648

	dprintk("NFS call  mknod %s %u:%u\n", dentry->d_name.name,
			MAJOR(rdev), MINOR(rdev));
649

A
Al Viro 已提交
650
	sattr->ia_mode &= ~current_umask();
651

652 653
	data = nfs3_alloc_createdata();
	if (data == NULL)
654
		goto out;
655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681

	data->msg.rpc_proc = &nfs3_procedures[NFS3PROC_MKNOD];
	data->arg.mknod.fh = NFS_FH(dir);
	data->arg.mknod.name = dentry->d_name.name;
	data->arg.mknod.len = dentry->d_name.len;
	data->arg.mknod.sattr = sattr;
	data->arg.mknod.rdev = rdev;

	switch (sattr->ia_mode & S_IFMT) {
	case S_IFBLK:
		data->arg.mknod.type = NF3BLK;
		break;
	case S_IFCHR:
		data->arg.mknod.type = NF3CHR;
		break;
	case S_IFIFO:
		data->arg.mknod.type = NF3FIFO;
		break;
	case S_IFSOCK:
		data->arg.mknod.type = NF3SOCK;
		break;
	default:
		status = -EINVAL;
		goto out;
	}

	status = nfs3_do_create(dir, dentry, data);
682 683 684 685
	if (status != 0)
		goto out;
	status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
out:
686
	nfs3_free_createdata(data);
L
Linus Torvalds 已提交
687 688 689 690 691 692 693 694
	dprintk("NFS reply mknod: %d\n", status);
	return status;
}

static int
nfs3_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
		 struct nfs_fsstat *stat)
{
C
Chuck Lever 已提交
695 696 697 698 699
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_FSSTAT],
		.rpc_argp	= fhandle,
		.rpc_resp	= stat,
	};
L
Linus Torvalds 已提交
700 701 702
	int	status;

	dprintk("NFS call  fsstat\n");
703
	nfs_fattr_init(stat->fattr);
C
Chuck Lever 已提交
704
	status = rpc_call_sync(server->client, &msg, 0);
L
Linus Torvalds 已提交
705 706 707 708 709
	dprintk("NFS reply statfs: %d\n", status);
	return status;
}

static int
E
EG Keizer 已提交
710
do_proc_fsinfo(struct rpc_clnt *client, struct nfs_fh *fhandle,
L
Linus Torvalds 已提交
711 712
		 struct nfs_fsinfo *info)
{
C
Chuck Lever 已提交
713 714 715 716 717
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_FSINFO],
		.rpc_argp	= fhandle,
		.rpc_resp	= info,
	};
L
Linus Torvalds 已提交
718 719 720
	int	status;

	dprintk("NFS call  fsinfo\n");
721
	nfs_fattr_init(info->fattr);
E
EG Keizer 已提交
722
	status = rpc_call_sync(client, &msg, 0);
L
Linus Torvalds 已提交
723 724 725 726
	dprintk("NFS reply fsinfo: %d\n", status);
	return status;
}

E
EG Keizer 已提交
727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742
/*
 * Bare-bones access to fsinfo: this is for nfs_get_root/nfs_get_sb via
 * nfs_create_server
 */
static int
nfs3_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
		   struct nfs_fsinfo *info)
{
	int	status;

	status = do_proc_fsinfo(server->client, fhandle, info);
	if (status && server->nfs_client->cl_rpcclient != server->client)
		status = do_proc_fsinfo(server->nfs_client->cl_rpcclient, fhandle, info);
	return status;
}

L
Linus Torvalds 已提交
743 744 745 746
static int
nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
		   struct nfs_pathconf *info)
{
C
Chuck Lever 已提交
747 748 749 750 751
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_PATHCONF],
		.rpc_argp	= fhandle,
		.rpc_resp	= info,
	};
L
Linus Torvalds 已提交
752 753 754
	int	status;

	dprintk("NFS call  pathconf\n");
755
	nfs_fattr_init(info->fattr);
C
Chuck Lever 已提交
756
	status = rpc_call_sync(server->client, &msg, 0);
L
Linus Torvalds 已提交
757 758 759 760
	dprintk("NFS reply pathconf: %d\n", status);
	return status;
}

T
Trond Myklebust 已提交
761
static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data)
L
Linus Torvalds 已提交
762
{
763
	if (nfs3_async_handle_jukebox(task, data->inode))
T
Trond Myklebust 已提交
764
		return -EAGAIN;
765 766 767

	nfs_invalidate_atime(data->inode);
	nfs_refresh_inode(data->inode, &data->fattr);
T
Trond Myklebust 已提交
768
	return 0;
L
Linus Torvalds 已提交
769 770
}

771
static void nfs3_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
L
Linus Torvalds 已提交
772
{
773
	msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ];
L
Linus Torvalds 已提交
774 775
}

776
static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data)
L
Linus Torvalds 已提交
777
{
778
	if (nfs3_async_handle_jukebox(task, data->inode))
779
		return -EAGAIN;
L
Linus Torvalds 已提交
780
	if (task->tk_status >= 0)
781
		nfs_post_op_update_inode_force_wcc(data->inode, data->res.fattr);
782
	return 0;
L
Linus Torvalds 已提交
783 784
}

785
static void nfs3_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
L
Linus Torvalds 已提交
786
{
787
	msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE];
L
Linus Torvalds 已提交
788 789
}

790
static int nfs3_commit_done(struct rpc_task *task, struct nfs_write_data *data)
L
Linus Torvalds 已提交
791
{
792
	if (nfs3_async_handle_jukebox(task, data->inode))
793
		return -EAGAIN;
794
	nfs_refresh_inode(data->inode, data->res.fattr);
795
	return 0;
L
Linus Torvalds 已提交
796 797
}

798
static void nfs3_proc_commit_setup(struct nfs_write_data *data, struct rpc_message *msg)
L
Linus Torvalds 已提交
799
{
800
	msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT];
L
Linus Torvalds 已提交
801 802 803 804 805
}

static int
nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
{
806 807 808
	struct inode *inode = filp->f_path.dentry->d_inode;

	return nlmclnt_proc(NFS_SERVER(inode)->nlm_host, cmd, fl);
L
Linus Torvalds 已提交
809 810
}

D
David Howells 已提交
811
const struct nfs_rpc_ops nfs_v3_clientops = {
L
Linus Torvalds 已提交
812 813
	.version	= 3,			/* protocol version */
	.dentry_ops	= &nfs_dentry_operations,
814 815
	.dir_inode_ops	= &nfs3_dir_inode_operations,
	.file_inode_ops	= &nfs3_file_inode_operations,
L
Linus Torvalds 已提交
816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837
	.getroot	= nfs3_proc_get_root,
	.getattr	= nfs3_proc_getattr,
	.setattr	= nfs3_proc_setattr,
	.lookup		= nfs3_proc_lookup,
	.access		= nfs3_proc_access,
	.readlink	= nfs3_proc_readlink,
	.create		= nfs3_proc_create,
	.remove		= nfs3_proc_remove,
	.unlink_setup	= nfs3_proc_unlink_setup,
	.unlink_done	= nfs3_proc_unlink_done,
	.rename		= nfs3_proc_rename,
	.link		= nfs3_proc_link,
	.symlink	= nfs3_proc_symlink,
	.mkdir		= nfs3_proc_mkdir,
	.rmdir		= nfs3_proc_rmdir,
	.readdir	= nfs3_proc_readdir,
	.mknod		= nfs3_proc_mknod,
	.statfs		= nfs3_proc_statfs,
	.fsinfo		= nfs3_proc_fsinfo,
	.pathconf	= nfs3_proc_pathconf,
	.decode_dirent	= nfs3_decode_dirent,
	.read_setup	= nfs3_proc_read_setup,
T
Trond Myklebust 已提交
838
	.read_done	= nfs3_read_done,
L
Linus Torvalds 已提交
839
	.write_setup	= nfs3_proc_write_setup,
840
	.write_done	= nfs3_write_done,
L
Linus Torvalds 已提交
841
	.commit_setup	= nfs3_proc_commit_setup,
842
	.commit_done	= nfs3_commit_done,
L
Linus Torvalds 已提交
843
	.lock		= nfs3_proc_lock,
844
	.clear_acl_cache = nfs3_forget_cached_acls,
T
Trond Myklebust 已提交
845
	.close_context	= nfs_close_context,
L
Linus Torvalds 已提交
846
};