nfs3proc.c 24.3 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>
20
#include <linux/freezer.h>
L
Linus Torvalds 已提交
21

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

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

27
/* A wrapper to handle the EJUKEBOX error messages */
L
Linus Torvalds 已提交
28 29 30 31 32 33
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);
34
		if (res != -EJUKEBOX)
L
Linus Torvalds 已提交
35
			break;
36
		freezable_schedule_timeout_killable_unsafe(NFS_JUKEBOX_RETRY_TIME);
L
Linus Torvalds 已提交
37
		res = -ERESTARTSYS;
38
	} while (!fatal_signal_pending(current));
L
Linus Torvalds 已提交
39 40 41
	return res;
}

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

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

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

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

81
/*
82
 * Bare-bones access to getattr: this is for nfs_get_root/nfs_get_sb
83 84 85 86 87 88 89 90
 */
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);
91 92
	if (status && server->nfs_client->cl_rpcclient != server->client)
		status = do_proc_get_root(server->nfs_client->cl_rpcclient, fhandle, info);
93 94 95
	return status;
}

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

	dprintk("NFS call  getattr\n");
111
	nfs_fattr_init(fattr);
C
Chuck Lever 已提交
112
	status = rpc_call_sync(server->client, &msg, 0);
L
Linus Torvalds 已提交
113 114 115 116 117 118 119 120 121 122 123 124 125
	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 已提交
126 127 128 129 130
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_SETATTR],
		.rpc_argp	= &arg,
		.rpc_resp	= fattr,
	};
L
Linus Torvalds 已提交
131 132 133
	int	status;

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

static int
145
nfs3_proc_lookup(struct inode *dir, struct qstr *name,
146 147
		 struct nfs_fh *fhandle, struct nfs_fattr *fattr,
		 struct nfs4_label *label)
L
Linus Torvalds 已提交
148 149 150 151 152 153 154 155 156 157
{
	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 已提交
158 159 160 161 162
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_LOOKUP],
		.rpc_argp	= &arg,
		.rpc_resp	= &res,
	};
L
Linus Torvalds 已提交
163 164 165
	int			status;

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

170
	nfs_fattr_init(fattr);
C
Chuck Lever 已提交
171
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
172
	nfs_refresh_inode(dir, res.dir_attr);
C
Chuck Lever 已提交
173 174 175 176 177 178
	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);
	}
179
	nfs_free_fattr(res.dir_attr);
L
Linus Torvalds 已提交
180 181 182 183 184 185 186 187 188
	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),
	};
189
	struct nfs3_accessres	res;
L
Linus Torvalds 已提交
190 191 192 193
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_ACCESS],
		.rpc_argp	= &arg,
		.rpc_resp	= &res,
C
Chuck Lever 已提交
194
		.rpc_cred	= entry->cred,
L
Linus Torvalds 已提交
195 196
	};
	int mode = entry->mask;
197
	int status = -ENOMEM;
L
Linus Torvalds 已提交
198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213

	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;
	}
214 215 216 217 218

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

L
Linus Torvalds 已提交
219
	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
220
	nfs_refresh_inode(inode, res.fattr);
L
Linus Torvalds 已提交
221 222 223 224 225 226 227 228 229
	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;
	}
230 231
	nfs_free_fattr(res.fattr);
out:
L
Linus Torvalds 已提交
232 233 234 235 236 237 238
	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)
{
239
	struct nfs_fattr	*fattr;
L
Linus Torvalds 已提交
240 241 242 243 244 245
	struct nfs3_readlinkargs args = {
		.fh		= NFS_FH(inode),
		.pgbase		= pgbase,
		.pglen		= pglen,
		.pages		= &page
	};
C
Chuck Lever 已提交
246 247 248 249
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_READLINK],
		.rpc_argp	= &args,
	};
250
	int status = -ENOMEM;
L
Linus Torvalds 已提交
251 252

	dprintk("NFS call  readlink\n");
253 254 255 256 257
	fattr = nfs_alloc_fattr();
	if (fattr == NULL)
		goto out;
	msg.rpc_resp = fattr;

C
Chuck Lever 已提交
258
	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
259 260 261
	nfs_refresh_inode(inode, fattr);
	nfs_free_fattr(fattr);
out:
L
Linus Torvalds 已提交
262 263 264 265
	dprintk("NFS reply readlink: %d\n", status);
	return status;
}

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
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)
304
		status = nfs_instantiate(dentry, data->res.fh, data->res.fattr, NULL);
305 306 307 308 309 310 311 312
	return status;
}

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

L
Linus Torvalds 已提交
313 314 315 316 317
/*
 * Create a regular file.
 */
static int
nfs3_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
318
		 int flags)
L
Linus Torvalds 已提交
319
{
320
	struct nfs3_createdata *data;
A
Al Viro 已提交
321
	umode_t mode = sattr->ia_mode;
322
	int status = -ENOMEM;
L
Linus Torvalds 已提交
323

324
	dprintk("NFS call  create %pd\n", dentry);
325 326 327 328 329 330 331 332 333 334 335 336

	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 已提交
337
	if (flags & O_EXCL) {
338
		data->arg.create.createmode  = NFS3_CREATE_EXCLUSIVE;
339 340
		data->arg.create.verifier[0] = cpu_to_be32(jiffies);
		data->arg.create.verifier[1] = cpu_to_be32(current->pid);
L
Linus Torvalds 已提交
341 342
	}

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

345 346
	for (;;) {
		status = nfs3_do_create(dir, dentry, data);
L
Linus Torvalds 已提交
347

348 349 350 351 352
		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 已提交
353
			case NFS3_CREATE_EXCLUSIVE:
354
				data->arg.create.createmode = NFS3_CREATE_GUARDED;
L
Linus Torvalds 已提交
355 356 357
				break;

			case NFS3_CREATE_GUARDED:
358
				data->arg.create.createmode = NFS3_CREATE_UNCHECKED;
L
Linus Torvalds 已提交
359 360 361 362 363
				break;

			case NFS3_CREATE_UNCHECKED:
				goto out;
		}
364 365
		nfs_fattr_init(data->res.dir_attr);
		nfs_fattr_init(data->res.fattr);
L
Linus Torvalds 已提交
366 367 368 369 370 371 372
	}

	if (status != 0)
		goto out;

	/* When we created the file with exclusive semantics, make
	 * sure we set the attributes afterwards. */
373
	if (data->arg.create.createmode == NFS3_CREATE_EXCLUSIVE) {
L
Linus Torvalds 已提交
374 375 376 377 378 379 380 381 382 383
		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) */
384 385
		status = nfs3_proc_setattr(dentry, data->res.fattr, sattr);
		nfs_post_op_update_inode(dentry->d_inode, data->res.fattr);
L
Linus Torvalds 已提交
386
		dprintk("NFS reply setattr (post-create): %d\n", status);
387 388
		if (status != 0)
			goto out;
L
Linus Torvalds 已提交
389
	}
390
	status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
L
Linus Torvalds 已提交
391
out:
392
	nfs3_free_createdata(data);
L
Linus Torvalds 已提交
393 394 395 396 397 398 399
	dprintk("NFS reply create: %d\n", status);
	return status;
}

static int
nfs3_proc_remove(struct inode *dir, struct qstr *name)
{
400 401
	struct nfs_removeargs arg = {
		.fh = NFS_FH(dir),
402
		.name = *name,
L
Linus Torvalds 已提交
403
	};
404 405 406 407 408
	struct nfs_removeres res;
	struct rpc_message msg = {
		.rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE],
		.rpc_argp = &arg,
		.rpc_resp = &res,
L
Linus Torvalds 已提交
409
	};
410
	int status = -ENOMEM;
L
Linus Torvalds 已提交
411 412

	dprintk("NFS call  remove %s\n", name->name);
413 414 415 416
	res.dir_attr = nfs_alloc_fattr();
	if (res.dir_attr == NULL)
		goto out;

L
Linus Torvalds 已提交
417
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
418 419 420
	nfs_post_op_update_inode(dir, res.dir_attr);
	nfs_free_fattr(res.dir_attr);
out:
L
Linus Torvalds 已提交
421 422 423 424
	dprintk("NFS reply remove: %d\n", status);
	return status;
}

425 426
static void
nfs3_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
L
Linus Torvalds 已提交
427 428 429 430
{
	msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE];
}

431 432 433 434 435
static void nfs3_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
{
	rpc_call_start(task);
}

L
Linus Torvalds 已提交
436
static int
437
nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir)
L
Linus Torvalds 已提交
438
{
439 440 441 442
	struct nfs_removeres *res;
	if (nfs3_async_handle_jukebox(task, dir))
		return 0;
	res = task->tk_msg.rpc_resp;
443
	nfs_post_op_update_inode(dir, res->dir_attr);
444
	return 1;
L
Linus Torvalds 已提交
445 446
}

447 448 449 450 451 452
static void
nfs3_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
{
	msg->rpc_proc = &nfs3_procedures[NFS3PROC_RENAME];
}

453 454 455 456 457
static void nfs3_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
{
	rpc_call_start(task);
}

458 459 460 461 462 463 464 465 466 467 468 469 470 471 472
static int
nfs3_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
		      struct inode *new_dir)
{
	struct nfs_renameres *res;

	if (nfs3_async_handle_jukebox(task, old_dir))
		return 0;
	res = task->tk_msg.rpc_resp;

	nfs_post_op_update_inode(old_dir, res->old_fattr);
	nfs_post_op_update_inode(new_dir, res->new_fattr);
	return 1;
}

L
Linus Torvalds 已提交
473 474 475 476
static int
nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name,
		 struct inode *new_dir, struct qstr *new_name)
{
477 478 479 480 481
	struct nfs_renameargs	arg = {
		.old_dir	= NFS_FH(old_dir),
		.old_name	= old_name,
		.new_dir	= NFS_FH(new_dir),
		.new_name	= new_name,
L
Linus Torvalds 已提交
482
	};
483
	struct nfs_renameres res;
C
Chuck Lever 已提交
484 485 486 487 488
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_RENAME],
		.rpc_argp	= &arg,
		.rpc_resp	= &res,
	};
489
	int status = -ENOMEM;
L
Linus Torvalds 已提交
490 491

	dprintk("NFS call  rename %s -> %s\n", old_name->name, new_name->name);
492

493 494 495
	res.old_fattr = nfs_alloc_fattr();
	res.new_fattr = nfs_alloc_fattr();
	if (res.old_fattr == NULL || res.new_fattr == NULL)
496 497
		goto out;

C
Chuck Lever 已提交
498
	status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
499 500
	nfs_post_op_update_inode(old_dir, res.old_fattr);
	nfs_post_op_update_inode(new_dir, res.new_fattr);
501
out:
502 503
	nfs_free_fattr(res.old_fattr);
	nfs_free_fattr(res.new_fattr);
L
Linus Torvalds 已提交
504 505 506 507 508 509 510 511 512 513 514 515 516
	dprintk("NFS reply rename: %d\n", status);
	return status;
}

static int
nfs3_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
{
	struct nfs3_linkargs	arg = {
		.fromfh		= NFS_FH(inode),
		.tofh		= NFS_FH(dir),
		.toname		= name->name,
		.tolen		= name->len
	};
517
	struct nfs3_linkres	res;
C
Chuck Lever 已提交
518 519 520 521 522
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_LINK],
		.rpc_argp	= &arg,
		.rpc_resp	= &res,
	};
523
	int status = -ENOMEM;
L
Linus Torvalds 已提交
524 525

	dprintk("NFS call  link %s\n", name->name);
526 527 528 529 530
	res.fattr = nfs_alloc_fattr();
	res.dir_attr = nfs_alloc_fattr();
	if (res.fattr == NULL || res.dir_attr == NULL)
		goto out;

C
Chuck Lever 已提交
531
	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
532 533 534 535 536
	nfs_post_op_update_inode(dir, res.dir_attr);
	nfs_post_op_update_inode(inode, res.fattr);
out:
	nfs_free_fattr(res.dir_attr);
	nfs_free_fattr(res.fattr);
L
Linus Torvalds 已提交
537 538 539 540 541
	dprintk("NFS reply link: %d\n", status);
	return status;
}

static int
542 543
nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
		  unsigned int len, struct iattr *sattr)
L
Linus Torvalds 已提交
544
{
545 546
	struct nfs3_createdata *data;
	int status = -ENOMEM;
L
Linus Torvalds 已提交
547

548
	if (len > NFS3_MAXPATHLEN)
L
Linus Torvalds 已提交
549
		return -ENAMETOOLONG;
550

551
	dprintk("NFS call  symlink %pd\n", dentry);
552

553 554
	data = nfs3_alloc_createdata();
	if (data == NULL)
555
		goto out;
556 557 558 559 560 561 562 563 564 565 566
	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);
567
out:
L
Linus Torvalds 已提交
568 569 570 571 572 573 574
	dprintk("NFS reply symlink: %d\n", status);
	return status;
}

static int
nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
{
575
	struct nfs3_createdata *data;
A
Al Viro 已提交
576
	umode_t mode = sattr->ia_mode;
577
	int status = -ENOMEM;
L
Linus Torvalds 已提交
578

579
	dprintk("NFS call  mkdir %pd\n", dentry);
580

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

583 584
	data = nfs3_alloc_createdata();
	if (data == NULL)
585
		goto out;
586 587 588 589 590 591 592 593

	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);
594 595
	if (status != 0)
		goto out;
596

597 598
	status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
out:
599
	nfs3_free_createdata(data);
L
Linus Torvalds 已提交
600 601 602 603 604 605 606
	dprintk("NFS reply mkdir: %d\n", status);
	return status;
}

static int
nfs3_proc_rmdir(struct inode *dir, struct qstr *name)
{
607
	struct nfs_fattr	*dir_attr;
L
Linus Torvalds 已提交
608 609 610 611 612
	struct nfs3_diropargs	arg = {
		.fh		= NFS_FH(dir),
		.name		= name->name,
		.len		= name->len
	};
C
Chuck Lever 已提交
613 614 615 616
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_RMDIR],
		.rpc_argp	= &arg,
	};
617
	int status = -ENOMEM;
L
Linus Torvalds 已提交
618 619

	dprintk("NFS call  rmdir %s\n", name->name);
620 621 622 623 624
	dir_attr = nfs_alloc_fattr();
	if (dir_attr == NULL)
		goto out;

	msg.rpc_resp = dir_attr;
C
Chuck Lever 已提交
625
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
626 627 628
	nfs_post_op_update_inode(dir, dir_attr);
	nfs_free_fattr(dir_attr);
out:
L
Linus Torvalds 已提交
629 630 631 632 633 634 635 636 637 638 639 640 641 642 643
	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,
B
Bryan Schumaker 已提交
644
		  u64 cookie, struct page **pages, unsigned int count, int plus)
L
Linus Torvalds 已提交
645 646
{
	struct inode		*dir = dentry->d_inode;
647
	__be32			*verf = NFS_I(dir)->cookieverf;
L
Linus Torvalds 已提交
648 649 650 651 652 653
	struct nfs3_readdirargs	arg = {
		.fh		= NFS_FH(dir),
		.cookie		= cookie,
		.verf		= {verf[0], verf[1]},
		.plus		= plus,
		.count		= count,
B
Bryan Schumaker 已提交
654
		.pages		= pages
L
Linus Torvalds 已提交
655 656 657 658 659 660 661 662 663 664 665
	};
	struct nfs3_readdirres	res = {
		.verf		= verf,
		.plus		= plus
	};
	struct rpc_message	msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_READDIR],
		.rpc_argp	= &arg,
		.rpc_resp	= &res,
		.rpc_cred	= cred
	};
666
	int status = -ENOMEM;
L
Linus Torvalds 已提交
667 668 669 670 671 672 673

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

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

674 675 676 677
	res.dir_attr = nfs_alloc_fattr();
	if (res.dir_attr == NULL)
		goto out;

L
Linus Torvalds 已提交
678
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
679 680

	nfs_invalidate_atime(dir);
681
	nfs_refresh_inode(dir, res.dir_attr);
682

683 684
	nfs_free_fattr(res.dir_attr);
out:
685 686
	dprintk("NFS reply readdir%s: %d\n",
			plus? "plus" : "", status);
L
Linus Torvalds 已提交
687 688 689 690 691 692 693
	return status;
}

static int
nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
		dev_t rdev)
{
694
	struct nfs3_createdata *data;
A
Al Viro 已提交
695
	umode_t mode = sattr->ia_mode;
696
	int status = -ENOMEM;
L
Linus Torvalds 已提交
697

698
	dprintk("NFS call  mknod %pd %u:%u\n", dentry,
L
Linus Torvalds 已提交
699
			MAJOR(rdev), MINOR(rdev));
700

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

703 704
	data = nfs3_alloc_createdata();
	if (data == NULL)
705
		goto out;
706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732

	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);
733 734 735 736
	if (status != 0)
		goto out;
	status = nfs3_proc_set_default_acl(dir, dentry->d_inode, mode);
out:
737
	nfs3_free_createdata(data);
L
Linus Torvalds 已提交
738 739 740 741 742 743 744 745
	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 已提交
746 747 748 749 750
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_FSSTAT],
		.rpc_argp	= fhandle,
		.rpc_resp	= stat,
	};
L
Linus Torvalds 已提交
751 752 753
	int	status;

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

static int
E
EG Keizer 已提交
761
do_proc_fsinfo(struct rpc_clnt *client, struct nfs_fh *fhandle,
L
Linus Torvalds 已提交
762 763
		 struct nfs_fsinfo *info)
{
C
Chuck Lever 已提交
764 765 766 767 768
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_FSINFO],
		.rpc_argp	= fhandle,
		.rpc_resp	= info,
	};
L
Linus Torvalds 已提交
769 770 771
	int	status;

	dprintk("NFS call  fsinfo\n");
772
	nfs_fattr_init(info->fattr);
E
EG Keizer 已提交
773
	status = rpc_call_sync(client, &msg, 0);
L
Linus Torvalds 已提交
774 775 776 777
	dprintk("NFS reply fsinfo: %d\n", status);
	return status;
}

E
EG Keizer 已提交
778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793
/*
 * 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 已提交
794 795 796 797
static int
nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
		   struct nfs_pathconf *info)
{
C
Chuck Lever 已提交
798 799 800 801 802
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_PATHCONF],
		.rpc_argp	= fhandle,
		.rpc_resp	= info,
	};
L
Linus Torvalds 已提交
803 804 805
	int	status;

	dprintk("NFS call  pathconf\n");
806
	nfs_fattr_init(info->fattr);
C
Chuck Lever 已提交
807
	status = rpc_call_sync(server->client, &msg, 0);
L
Linus Torvalds 已提交
808 809 810 811
	dprintk("NFS reply pathconf: %d\n", status);
	return status;
}

T
Trond Myklebust 已提交
812
static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data)
L
Linus Torvalds 已提交
813
{
814 815 816
	struct inode *inode = data->header->inode;

	if (nfs3_async_handle_jukebox(task, inode))
T
Trond Myklebust 已提交
817
		return -EAGAIN;
818

819 820
	nfs_invalidate_atime(inode);
	nfs_refresh_inode(inode, &data->fattr);
T
Trond Myklebust 已提交
821
	return 0;
L
Linus Torvalds 已提交
822 823
}

824
static void nfs3_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
L
Linus Torvalds 已提交
825
{
826
	msg->rpc_proc = &nfs3_procedures[NFS3PROC_READ];
L
Linus Torvalds 已提交
827 828
}

829
static int nfs3_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data)
830 831
{
	rpc_call_start(task);
832
	return 0;
833 834
}

835
static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data)
L
Linus Torvalds 已提交
836
{
837 838 839
	struct inode *inode = data->header->inode;

	if (nfs3_async_handle_jukebox(task, inode))
840
		return -EAGAIN;
L
Linus Torvalds 已提交
841
	if (task->tk_status >= 0)
842
		nfs_post_op_update_inode_force_wcc(inode, data->res.fattr);
843
	return 0;
L
Linus Torvalds 已提交
844 845
}

846
static void nfs3_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
L
Linus Torvalds 已提交
847
{
848
	msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE];
L
Linus Torvalds 已提交
849 850
}

851
static int nfs3_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data)
852 853
{
	rpc_call_start(task);
854
	return 0;
855 856
}

857 858 859 860 861 862
static void nfs3_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
{
	rpc_call_start(task);
}

static int nfs3_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
L
Linus Torvalds 已提交
863
{
864
	if (nfs3_async_handle_jukebox(task, data->inode))
865
		return -EAGAIN;
866
	nfs_refresh_inode(data->inode, data->res.fattr);
867
	return 0;
L
Linus Torvalds 已提交
868 869
}

870
static void nfs3_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
L
Linus Torvalds 已提交
871
{
872
	msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT];
L
Linus Torvalds 已提交
873 874 875 876 877
}

static int
nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
{
A
Al Viro 已提交
878
	struct inode *inode = file_inode(filp);
879 880

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

883 884 885 886 887
static int nfs3_have_delegation(struct inode *inode, fmode_t flags)
{
	return 0;
}

888 889 890 891 892 893
static int nfs3_return_delegation(struct inode *inode)
{
	nfs_wb_all(inode);
	return 0;
}

894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922
static const struct inode_operations nfs3_dir_inode_operations = {
	.create		= nfs_create,
	.lookup		= nfs_lookup,
	.link		= nfs_link,
	.unlink		= nfs_unlink,
	.symlink	= nfs_symlink,
	.mkdir		= nfs_mkdir,
	.rmdir		= nfs_rmdir,
	.mknod		= nfs_mknod,
	.rename		= nfs_rename,
	.permission	= nfs_permission,
	.getattr	= nfs_getattr,
	.setattr	= nfs_setattr,
	.listxattr	= nfs3_listxattr,
	.getxattr	= nfs3_getxattr,
	.setxattr	= nfs3_setxattr,
	.removexattr	= nfs3_removexattr,
};

static const struct inode_operations nfs3_file_inode_operations = {
	.permission	= nfs_permission,
	.getattr	= nfs_getattr,
	.setattr	= nfs_setattr,
	.listxattr	= nfs3_listxattr,
	.getxattr	= nfs3_getxattr,
	.setxattr	= nfs3_setxattr,
	.removexattr	= nfs3_removexattr,
};

D
David Howells 已提交
923
const struct nfs_rpc_ops nfs_v3_clientops = {
L
Linus Torvalds 已提交
924 925
	.version	= 3,			/* protocol version */
	.dentry_ops	= &nfs_dentry_operations,
926 927
	.dir_inode_ops	= &nfs3_dir_inode_operations,
	.file_inode_ops	= &nfs3_file_inode_operations,
928
	.file_ops	= &nfs_file_operations,
L
Linus Torvalds 已提交
929
	.getroot	= nfs3_proc_get_root,
B
Bryan Schumaker 已提交
930
	.submount	= nfs_submount,
B
Bryan Schumaker 已提交
931
	.try_mount	= nfs_try_mount,
L
Linus Torvalds 已提交
932 933 934 935 936 937 938 939
	.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,
940
	.unlink_rpc_prepare = nfs3_proc_unlink_rpc_prepare,
L
Linus Torvalds 已提交
941 942
	.unlink_done	= nfs3_proc_unlink_done,
	.rename		= nfs3_proc_rename,
943
	.rename_setup	= nfs3_proc_rename_setup,
944
	.rename_rpc_prepare = nfs3_proc_rename_rpc_prepare,
945
	.rename_done	= nfs3_proc_rename_done,
L
Linus Torvalds 已提交
946 947 948 949 950 951 952 953 954 955 956
	.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,
957
	.read_pageio_init = nfs_pageio_init_read,
958
	.read_rpc_prepare = nfs3_proc_read_rpc_prepare,
T
Trond Myklebust 已提交
959
	.read_done	= nfs3_read_done,
L
Linus Torvalds 已提交
960
	.write_setup	= nfs3_proc_write_setup,
961
	.write_pageio_init = nfs_pageio_init_write,
962
	.write_rpc_prepare = nfs3_proc_write_rpc_prepare,
963
	.write_done	= nfs3_write_done,
L
Linus Torvalds 已提交
964
	.commit_setup	= nfs3_proc_commit_setup,
965
	.commit_rpc_prepare = nfs3_proc_commit_rpc_prepare,
966
	.commit_done	= nfs3_commit_done,
L
Linus Torvalds 已提交
967
	.lock		= nfs3_proc_lock,
968
	.clear_acl_cache = nfs3_forget_cached_acls,
T
Trond Myklebust 已提交
969
	.close_context	= nfs_close_context,
970
	.have_delegation = nfs3_have_delegation,
971
	.return_delegation = nfs3_return_delegation,
972
	.alloc_client	= nfs_alloc_client,
973
	.init_client	= nfs_init_client,
974
	.free_client	= nfs_free_client,
975 976
	.create_server	= nfs3_create_server,
	.clone_server	= nfs3_clone_server,
L
Linus Torvalds 已提交
977
};