nfs3proc.c 24.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>
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(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 101 102
/*
 * 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 已提交
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,
L
Linus Torvalds 已提交
146 147 148 149 150 151 152 153 154 155 156
		 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 已提交
157 158 159 160 161
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_LOOKUP],
		.rpc_argp	= &arg,
		.rpc_resp	= &res,
	};
L
Linus Torvalds 已提交
162 163 164
	int			status;

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

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

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

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

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

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

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

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

	dprintk("NFS call  create %s\n", dentry->d_name.name);
324 325 326 327 328 329 330 331 332 333 334 335

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

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

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

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

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

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

	if (status != 0)
		goto out;

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

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

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

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

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

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

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

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

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

457 458 459 460 461 462 463 464 465 466 467 468 469 470 471
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 已提交
472 473 474 475
static int
nfs3_proc_rename(struct inode *old_dir, struct qstr *old_name,
		 struct inode *new_dir, struct qstr *new_name)
{
476 477 478 479 480
	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 已提交
481
	};
482
	struct nfs_renameres res;
C
Chuck Lever 已提交
483 484 485 486 487
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_RENAME],
		.rpc_argp	= &arg,
		.rpc_resp	= &res,
	};
488
	int status = -ENOMEM;
L
Linus Torvalds 已提交
489 490

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

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

C
Chuck Lever 已提交
497
	status = rpc_call_sync(NFS_CLIENT(old_dir), &msg, 0);
498 499
	nfs_post_op_update_inode(old_dir, res.old_fattr);
	nfs_post_op_update_inode(new_dir, res.new_fattr);
500
out:
501 502
	nfs_free_fattr(res.old_fattr);
	nfs_free_fattr(res.new_fattr);
L
Linus Torvalds 已提交
503 504 505 506 507 508 509 510 511 512 513 514 515
	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
	};
516
	struct nfs3_linkres	res;
C
Chuck Lever 已提交
517 518 519 520 521
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_LINK],
		.rpc_argp	= &arg,
		.rpc_resp	= &res,
	};
522
	int status = -ENOMEM;
L
Linus Torvalds 已提交
523 524

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

C
Chuck Lever 已提交
530
	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
531 532 533 534 535
	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 已提交
536 537 538 539 540
	dprintk("NFS reply link: %d\n", status);
	return status;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

702 703
	data = nfs3_alloc_createdata();
	if (data == NULL)
704
		goto out;
705 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

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

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

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

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

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

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

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

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

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

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

828 829 830 831 832
static void nfs3_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data)
{
	rpc_call_start(task);
}

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

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

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

849 850 851 852 853
static void nfs3_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data)
{
	rpc_call_start(task);
}

854 855 856 857 858 859
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 已提交
860
{
861
	if (nfs3_async_handle_jukebox(task, data->inode))
862
		return -EAGAIN;
863
	nfs_refresh_inode(data->inode, data->res.fattr);
864
	return 0;
L
Linus Torvalds 已提交
865 866
}

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

static int
nfs3_proc_lock(struct file *filp, int cmd, struct file_lock *fl)
{
875 876 877
	struct inode *inode = filp->f_path.dentry->d_inode;

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

880 881 882 883 884
static int nfs3_have_delegation(struct inode *inode, fmode_t flags)
{
	return 0;
}

885 886 887 888 889 890
static int nfs3_return_delegation(struct inode *inode)
{
	nfs_wb_all(inode);
	return 0;
}

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