nfs3proc.c 24.9 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 posix_acl *default_acl, *acl;
321 322
	struct nfs3_createdata *data;
	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
	}

343 344 345
	status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl);
	if (status)
		goto out;
346

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

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

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

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

	if (status != 0)
371
		goto out_release_acls;
L
Linus Torvalds 已提交
372 373 374

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

	status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl);

out_release_acls:
	posix_acl_release(acl);
	posix_acl_release(default_acl);
L
Linus Torvalds 已提交
398
out:
399
	nfs3_free_createdata(data);
L
Linus Torvalds 已提交
400 401 402 403 404 405 406
	dprintk("NFS reply create: %d\n", status);
	return status;
}

static int
nfs3_proc_remove(struct inode *dir, struct qstr *name)
{
407 408
	struct nfs_removeargs arg = {
		.fh = NFS_FH(dir),
409
		.name = *name,
L
Linus Torvalds 已提交
410
	};
411 412 413 414 415
	struct nfs_removeres res;
	struct rpc_message msg = {
		.rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE],
		.rpc_argp = &arg,
		.rpc_resp = &res,
L
Linus Torvalds 已提交
416
	};
417
	int status = -ENOMEM;
L
Linus Torvalds 已提交
418 419

	dprintk("NFS call  remove %s\n", name->name);
420 421 422 423
	res.dir_attr = nfs_alloc_fattr();
	if (res.dir_attr == NULL)
		goto out;

L
Linus Torvalds 已提交
424
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
425 426 427
	nfs_post_op_update_inode(dir, res.dir_attr);
	nfs_free_fattr(res.dir_attr);
out:
L
Linus Torvalds 已提交
428 429 430 431
	dprintk("NFS reply remove: %d\n", status);
	return status;
}

432 433
static void
nfs3_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
L
Linus Torvalds 已提交
434 435 436 437
{
	msg->rpc_proc = &nfs3_procedures[NFS3PROC_REMOVE];
}

438 439 440 441 442
static void nfs3_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
{
	rpc_call_start(task);
}

L
Linus Torvalds 已提交
443
static int
444
nfs3_proc_unlink_done(struct rpc_task *task, struct inode *dir)
L
Linus Torvalds 已提交
445
{
446 447 448 449
	struct nfs_removeres *res;
	if (nfs3_async_handle_jukebox(task, dir))
		return 0;
	res = task->tk_msg.rpc_resp;
450
	nfs_post_op_update_inode(dir, res->dir_attr);
451
	return 1;
L
Linus Torvalds 已提交
452 453
}

454 455 456 457 458 459
static void
nfs3_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
{
	msg->rpc_proc = &nfs3_procedures[NFS3PROC_RENAME];
}

460 461 462 463 464
static void nfs3_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
{
	rpc_call_start(task);
}

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

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

500 501 502
	res.old_fattr = nfs_alloc_fattr();
	res.new_fattr = nfs_alloc_fattr();
	if (res.old_fattr == NULL || res.new_fattr == NULL)
503 504
		goto out;

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

	dprintk("NFS call  link %s\n", name->name);
533 534 535 536 537
	res.fattr = nfs_alloc_fattr();
	res.dir_attr = nfs_alloc_fattr();
	if (res.fattr == NULL || res.dir_attr == NULL)
		goto out;

C
Chuck Lever 已提交
538
	status = rpc_call_sync(NFS_CLIENT(inode), &msg, 0);
539 540 541 542 543
	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 已提交
544 545 546 547 548
	dprintk("NFS reply link: %d\n", status);
	return status;
}

static int
549 550
nfs3_proc_symlink(struct inode *dir, struct dentry *dentry, struct page *page,
		  unsigned int len, struct iattr *sattr)
L
Linus Torvalds 已提交
551
{
552 553
	struct nfs3_createdata *data;
	int status = -ENOMEM;
L
Linus Torvalds 已提交
554

555
	if (len > NFS3_MAXPATHLEN)
L
Linus Torvalds 已提交
556
		return -ENAMETOOLONG;
557

558
	dprintk("NFS call  symlink %pd\n", dentry);
559

560 561
	data = nfs3_alloc_createdata();
	if (data == NULL)
562
		goto out;
563 564 565 566 567 568 569 570 571 572 573
	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);
574
out:
L
Linus Torvalds 已提交
575 576 577 578 579 580 581
	dprintk("NFS reply symlink: %d\n", status);
	return status;
}

static int
nfs3_proc_mkdir(struct inode *dir, struct dentry *dentry, struct iattr *sattr)
{
582
	struct posix_acl *default_acl, *acl;
583 584
	struct nfs3_createdata *data;
	int status = -ENOMEM;
L
Linus Torvalds 已提交
585

586
	dprintk("NFS call  mkdir %pd\n", dentry);
587

588 589
	data = nfs3_alloc_createdata();
	if (data == NULL)
590
		goto out;
591

592 593 594 595
	status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl);
	if (status)
		goto out;

596 597 598 599 600 601 602
	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);
603
	if (status != 0)
604
		goto out_release_acls;
605

606 607 608 609 610
	status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl);

out_release_acls:
	posix_acl_release(acl);
	posix_acl_release(default_acl);
611
out:
612
	nfs3_free_createdata(data);
L
Linus Torvalds 已提交
613 614 615 616 617 618 619
	dprintk("NFS reply mkdir: %d\n", status);
	return status;
}

static int
nfs3_proc_rmdir(struct inode *dir, struct qstr *name)
{
620
	struct nfs_fattr	*dir_attr;
L
Linus Torvalds 已提交
621 622 623 624 625
	struct nfs3_diropargs	arg = {
		.fh		= NFS_FH(dir),
		.name		= name->name,
		.len		= name->len
	};
C
Chuck Lever 已提交
626 627 628 629
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_RMDIR],
		.rpc_argp	= &arg,
	};
630
	int status = -ENOMEM;
L
Linus Torvalds 已提交
631 632

	dprintk("NFS call  rmdir %s\n", name->name);
633 634 635 636 637
	dir_attr = nfs_alloc_fattr();
	if (dir_attr == NULL)
		goto out;

	msg.rpc_resp = dir_attr;
C
Chuck Lever 已提交
638
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
639 640 641
	nfs_post_op_update_inode(dir, dir_attr);
	nfs_free_fattr(dir_attr);
out:
L
Linus Torvalds 已提交
642 643 644 645 646 647 648 649 650 651 652 653 654 655 656
	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 已提交
657
		  u64 cookie, struct page **pages, unsigned int count, int plus)
L
Linus Torvalds 已提交
658 659
{
	struct inode		*dir = dentry->d_inode;
660
	__be32			*verf = NFS_I(dir)->cookieverf;
L
Linus Torvalds 已提交
661 662 663 664 665 666
	struct nfs3_readdirargs	arg = {
		.fh		= NFS_FH(dir),
		.cookie		= cookie,
		.verf		= {verf[0], verf[1]},
		.plus		= plus,
		.count		= count,
B
Bryan Schumaker 已提交
667
		.pages		= pages
L
Linus Torvalds 已提交
668 669 670 671 672 673 674 675 676 677 678
	};
	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
	};
679
	int status = -ENOMEM;
L
Linus Torvalds 已提交
680 681 682 683 684 685 686

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

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

687 688 689 690
	res.dir_attr = nfs_alloc_fattr();
	if (res.dir_attr == NULL)
		goto out;

L
Linus Torvalds 已提交
691
	status = rpc_call_sync(NFS_CLIENT(dir), &msg, 0);
692 693

	nfs_invalidate_atime(dir);
694
	nfs_refresh_inode(dir, res.dir_attr);
695

696 697
	nfs_free_fattr(res.dir_attr);
out:
698 699
	dprintk("NFS reply readdir%s: %d\n",
			plus? "plus" : "", status);
L
Linus Torvalds 已提交
700 701 702 703 704 705 706
	return status;
}

static int
nfs3_proc_mknod(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
		dev_t rdev)
{
707
	struct posix_acl *default_acl, *acl;
708 709
	struct nfs3_createdata *data;
	int status = -ENOMEM;
L
Linus Torvalds 已提交
710

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

714 715
	data = nfs3_alloc_createdata();
	if (data == NULL)
716
		goto out;
717

718 719 720 721
	status = posix_acl_create(dir, &sattr->ia_mode, &default_acl, &acl);
	if (status)
		goto out;

722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747
	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);
748
	if (status != 0)
749 750 751 752 753 754 755
		goto out_release_acls;

	status = nfs3_proc_setacls(dentry->d_inode, acl, default_acl);

out_release_acls:
	posix_acl_release(acl);
	posix_acl_release(default_acl);
756
out:
757
	nfs3_free_createdata(data);
L
Linus Torvalds 已提交
758 759 760 761 762 763 764 765
	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 已提交
766 767 768 769 770
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_FSSTAT],
		.rpc_argp	= fhandle,
		.rpc_resp	= stat,
	};
L
Linus Torvalds 已提交
771 772 773
	int	status;

	dprintk("NFS call  fsstat\n");
774
	nfs_fattr_init(stat->fattr);
C
Chuck Lever 已提交
775
	status = rpc_call_sync(server->client, &msg, 0);
776
	dprintk("NFS reply fsstat: %d\n", status);
L
Linus Torvalds 已提交
777 778 779 780
	return status;
}

static int
E
EG Keizer 已提交
781
do_proc_fsinfo(struct rpc_clnt *client, struct nfs_fh *fhandle,
L
Linus Torvalds 已提交
782 783
		 struct nfs_fsinfo *info)
{
C
Chuck Lever 已提交
784 785 786 787 788
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_FSINFO],
		.rpc_argp	= fhandle,
		.rpc_resp	= info,
	};
L
Linus Torvalds 已提交
789 790 791
	int	status;

	dprintk("NFS call  fsinfo\n");
792
	nfs_fattr_init(info->fattr);
E
EG Keizer 已提交
793
	status = rpc_call_sync(client, &msg, 0);
L
Linus Torvalds 已提交
794 795 796 797
	dprintk("NFS reply fsinfo: %d\n", status);
	return status;
}

E
EG Keizer 已提交
798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813
/*
 * 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 已提交
814 815 816 817
static int
nfs3_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
		   struct nfs_pathconf *info)
{
C
Chuck Lever 已提交
818 819 820 821 822
	struct rpc_message msg = {
		.rpc_proc	= &nfs3_procedures[NFS3PROC_PATHCONF],
		.rpc_argp	= fhandle,
		.rpc_resp	= info,
	};
L
Linus Torvalds 已提交
823 824 825
	int	status;

	dprintk("NFS call  pathconf\n");
826
	nfs_fattr_init(info->fattr);
C
Chuck Lever 已提交
827
	status = rpc_call_sync(server->client, &msg, 0);
L
Linus Torvalds 已提交
828 829 830 831
	dprintk("NFS reply pathconf: %d\n", status);
	return status;
}

T
Trond Myklebust 已提交
832
static int nfs3_read_done(struct rpc_task *task, struct nfs_read_data *data)
L
Linus Torvalds 已提交
833
{
834 835 836
	struct inode *inode = data->header->inode;

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

839 840
	nfs_invalidate_atime(inode);
	nfs_refresh_inode(inode, &data->fattr);
T
Trond Myklebust 已提交
841
	return 0;
L
Linus Torvalds 已提交
842 843
}

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

849
static int nfs3_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data)
850 851
{
	rpc_call_start(task);
852
	return 0;
853 854
}

855
static int nfs3_write_done(struct rpc_task *task, struct nfs_write_data *data)
L
Linus Torvalds 已提交
856
{
857 858 859
	struct inode *inode = data->header->inode;

	if (nfs3_async_handle_jukebox(task, inode))
860
		return -EAGAIN;
L
Linus Torvalds 已提交
861
	if (task->tk_status >= 0)
862
		nfs_post_op_update_inode_force_wcc(inode, data->res.fattr);
863
	return 0;
L
Linus Torvalds 已提交
864 865
}

866
static void nfs3_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
L
Linus Torvalds 已提交
867
{
868
	msg->rpc_proc = &nfs3_procedures[NFS3PROC_WRITE];
L
Linus Torvalds 已提交
869 870
}

871
static int nfs3_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data)
872 873
{
	rpc_call_start(task);
874
	return 0;
875 876
}

877 878 879 880 881 882
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 已提交
883
{
884
	if (nfs3_async_handle_jukebox(task, data->inode))
885
		return -EAGAIN;
886
	nfs_refresh_inode(data->inode, data->res.fattr);
887
	return 0;
L
Linus Torvalds 已提交
888 889
}

890
static void nfs3_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
L
Linus Torvalds 已提交
891
{
892
	msg->rpc_proc = &nfs3_procedures[NFS3PROC_COMMIT];
L
Linus Torvalds 已提交
893 894 895 896 897
}

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

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

903 904 905 906 907
static int nfs3_have_delegation(struct inode *inode, fmode_t flags)
{
	return 0;
}

908 909 910 911 912 913
static int nfs3_return_delegation(struct inode *inode)
{
	nfs_wb_all(inode);
	return 0;
}

914 915 916 917 918 919 920 921 922 923 924 925 926
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,
927 928 929 930 931 932 933 934
	.listxattr	= generic_listxattr,
	.getxattr	= generic_getxattr,
	.setxattr	= generic_setxattr,
	.removexattr	= generic_removexattr,
#ifdef CONFIG_NFS_V3_ACL
	.get_acl	= nfs3_get_acl,
	.set_acl	= nfs3_set_acl,
#endif
935 936 937 938 939 940
};

static const struct inode_operations nfs3_file_inode_operations = {
	.permission	= nfs_permission,
	.getattr	= nfs_getattr,
	.setattr	= nfs_setattr,
941 942 943 944 945 946 947 948
	.listxattr	= generic_listxattr,
	.getxattr	= generic_getxattr,
	.setxattr	= generic_setxattr,
	.removexattr	= generic_removexattr,
#ifdef CONFIG_NFS_V3_ACL
	.get_acl	= nfs3_get_acl,
	.set_acl	= nfs3_set_acl,
#endif
949 950
};

D
David Howells 已提交
951
const struct nfs_rpc_ops nfs_v3_clientops = {
L
Linus Torvalds 已提交
952 953
	.version	= 3,			/* protocol version */
	.dentry_ops	= &nfs_dentry_operations,
954 955
	.dir_inode_ops	= &nfs3_dir_inode_operations,
	.file_inode_ops	= &nfs3_file_inode_operations,
956
	.file_ops	= &nfs_file_operations,
L
Linus Torvalds 已提交
957
	.getroot	= nfs3_proc_get_root,
B
Bryan Schumaker 已提交
958
	.submount	= nfs_submount,
B
Bryan Schumaker 已提交
959
	.try_mount	= nfs_try_mount,
L
Linus Torvalds 已提交
960 961 962 963 964 965 966 967
	.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,
968
	.unlink_rpc_prepare = nfs3_proc_unlink_rpc_prepare,
L
Linus Torvalds 已提交
969 970
	.unlink_done	= nfs3_proc_unlink_done,
	.rename		= nfs3_proc_rename,
971
	.rename_setup	= nfs3_proc_rename_setup,
972
	.rename_rpc_prepare = nfs3_proc_rename_rpc_prepare,
973
	.rename_done	= nfs3_proc_rename_done,
L
Linus Torvalds 已提交
974 975 976 977 978 979 980 981 982 983 984
	.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,
985
	.read_pageio_init = nfs_pageio_init_read,
986
	.read_rpc_prepare = nfs3_proc_read_rpc_prepare,
T
Trond Myklebust 已提交
987
	.read_done	= nfs3_read_done,
L
Linus Torvalds 已提交
988
	.write_setup	= nfs3_proc_write_setup,
989
	.write_pageio_init = nfs_pageio_init_write,
990
	.write_rpc_prepare = nfs3_proc_write_rpc_prepare,
991
	.write_done	= nfs3_write_done,
L
Linus Torvalds 已提交
992
	.commit_setup	= nfs3_proc_commit_setup,
993
	.commit_rpc_prepare = nfs3_proc_commit_rpc_prepare,
994
	.commit_done	= nfs3_commit_done,
L
Linus Torvalds 已提交
995
	.lock		= nfs3_proc_lock,
996
	.clear_acl_cache = forget_all_cached_acls,
T
Trond Myklebust 已提交
997
	.close_context	= nfs_close_context,
998
	.have_delegation = nfs3_have_delegation,
999
	.return_delegation = nfs3_return_delegation,
1000
	.alloc_client	= nfs_alloc_client,
1001
	.init_client	= nfs_init_client,
1002
	.free_client	= nfs_free_client,
1003 1004
	.create_server	= nfs3_create_server,
	.clone_server	= nfs3_clone_server,
L
Linus Torvalds 已提交
1005
};