nfs4proc.c 191 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41
/*
 *  fs/nfs/nfs4proc.c
 *
 *  Client-side procedure declarations for NFSv4.
 *
 *  Copyright (c) 2002 The Regents of the University of Michigan.
 *  All rights reserved.
 *
 *  Kendrick Smith <kmsmith@umich.edu>
 *  Andy Adamson   <andros@umich.edu>
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions
 *  are met:
 *
 *  1. Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *  2. Redistributions in binary form must reproduce the above copyright
 *     notice, this list of conditions and the following disclaimer in the
 *     documentation and/or other materials provided with the distribution.
 *  3. Neither the name of the University nor the names of its
 *     contributors may be used to endorse or promote products derived
 *     from this software without specific prior written permission.
 *
 *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
 *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *  DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
 *  FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 *  SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
 *  BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 *  SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <linux/mm.h>
#include <linux/delay.h>
#include <linux/errno.h>
#include <linux/string.h>
42 43
#include <linux/ratelimit.h>
#include <linux/printk.h>
44
#include <linux/slab.h>
Linus Torvalds's avatar
Linus Torvalds committed
45 46 47 48 49
#include <linux/sunrpc/clnt.h>
#include <linux/nfs.h>
#include <linux/nfs4.h>
#include <linux/nfs_fs.h>
#include <linux/nfs_page.h>
50
#include <linux/nfs_mount.h>
Linus Torvalds's avatar
Linus Torvalds committed
51
#include <linux/namei.h>
52
#include <linux/mount.h>
Benny Halevy's avatar
Benny Halevy committed
53
#include <linux/module.h>
54
#include <linux/nfs_idmap.h>
55
#include <linux/xattr.h>
56
#include <linux/utsname.h>
57
#include <linux/freezer.h>
Linus Torvalds's avatar
Linus Torvalds committed
58

59
#include "nfs4_fs.h"
Linus Torvalds's avatar
Linus Torvalds committed
60
#include "delegation.h"
61
#include "internal.h"
62
#include "iostat.h"
63
#include "callback.h"
64
#include "pnfs.h"
65
#include "netns.h"
66
#include "nfs4session.h"
67
#include "fscache.h"
Linus Torvalds's avatar
Linus Torvalds committed
68 69 70

#define NFSDBG_FACILITY		NFSDBG_PROC

71
#define NFS4_POLL_RETRY_MIN	(HZ/10)
Linus Torvalds's avatar
Linus Torvalds committed
72 73
#define NFS4_POLL_RETRY_MAX	(15*HZ)

74
struct nfs4_opendata;
75
static int _nfs4_proc_open(struct nfs4_opendata *data);
76
static int _nfs4_recover_proc_open(struct nfs4_opendata *data);
Linus Torvalds's avatar
Linus Torvalds committed
77
static int nfs4_do_fsinfo(struct nfs_server *, struct nfs_fh *, struct nfs_fsinfo *);
78
static int nfs4_async_handle_error(struct rpc_task *, const struct nfs_server *, struct nfs4_state *);
79
static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr);
80
static int nfs4_proc_getattr(struct nfs_server *, struct nfs_fh *, struct nfs_fattr *);
81
static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr);
82 83 84
static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
			    struct nfs_fattr *fattr, struct iattr *sattr,
			    struct nfs4_state *state);
85
#ifdef CONFIG_NFS_V4_1
86 87
static int nfs41_test_stateid(struct nfs_server *, nfs4_stateid *);
static int nfs41_free_stateid(struct nfs_server *, nfs4_stateid *);
88
#endif
Linus Torvalds's avatar
Linus Torvalds committed
89
/* Prevent leaks of NFSv4 errors into userland */
90
static int nfs4_map_errors(int err)
Linus Torvalds's avatar
Linus Torvalds committed
91
{
92 93 94 95
	if (err >= -1000)
		return err;
	switch (err) {
	case -NFS4ERR_RESOURCE:
96 97
	case -NFS4ERR_LAYOUTTRYLATER:
	case -NFS4ERR_RECALLCONFLICT:
98
		return -EREMOTEIO;
99 100
	case -NFS4ERR_WRONGSEC:
		return -EPERM;
101 102 103
	case -NFS4ERR_BADOWNER:
	case -NFS4ERR_BADNAME:
		return -EINVAL;
104 105
	case -NFS4ERR_SHARE_DENIED:
		return -EACCES;
106 107
	case -NFS4ERR_MINOR_VERS_MISMATCH:
		return -EPROTONOSUPPORT;
108 109
	case -NFS4ERR_ACCESS:
		return -EACCES;
110 111
	case -NFS4ERR_FILE_OPEN:
		return -EBUSY;
112
	default:
Linus Torvalds's avatar
Linus Torvalds committed
113
		dprintk("%s could not handle NFSv4 error %d\n",
114
				__func__, -err);
115
		break;
Linus Torvalds's avatar
Linus Torvalds committed
116
	}
117
	return -EIO;
Linus Torvalds's avatar
Linus Torvalds committed
118 119 120 121 122
}

/*
 * This is our standard bitmap for GETATTR requests.
 */
123
const u32 nfs4_fattr_bitmap[3] = {
Linus Torvalds's avatar
Linus Torvalds committed
124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139
	FATTR4_WORD0_TYPE
	| FATTR4_WORD0_CHANGE
	| FATTR4_WORD0_SIZE
	| FATTR4_WORD0_FSID
	| FATTR4_WORD0_FILEID,
	FATTR4_WORD1_MODE
	| FATTR4_WORD1_NUMLINKS
	| FATTR4_WORD1_OWNER
	| FATTR4_WORD1_OWNER_GROUP
	| FATTR4_WORD1_RAWDEV
	| FATTR4_WORD1_SPACE_USED
	| FATTR4_WORD1_TIME_ACCESS
	| FATTR4_WORD1_TIME_METADATA
	| FATTR4_WORD1_TIME_MODIFY
};

140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
static const u32 nfs4_pnfs_open_bitmap[3] = {
	FATTR4_WORD0_TYPE
	| FATTR4_WORD0_CHANGE
	| FATTR4_WORD0_SIZE
	| FATTR4_WORD0_FSID
	| FATTR4_WORD0_FILEID,
	FATTR4_WORD1_MODE
	| FATTR4_WORD1_NUMLINKS
	| FATTR4_WORD1_OWNER
	| FATTR4_WORD1_OWNER_GROUP
	| FATTR4_WORD1_RAWDEV
	| FATTR4_WORD1_SPACE_USED
	| FATTR4_WORD1_TIME_ACCESS
	| FATTR4_WORD1_TIME_METADATA
	| FATTR4_WORD1_TIME_MODIFY,
	FATTR4_WORD2_MDSTHRESHOLD
};

158 159 160 161 162 163
static const u32 nfs4_open_noattr_bitmap[3] = {
	FATTR4_WORD0_TYPE
	| FATTR4_WORD0_CHANGE
	| FATTR4_WORD0_FILEID,
};

Linus Torvalds's avatar
Linus Torvalds committed
164 165 166 167 168 169 170 171 172
const u32 nfs4_statfs_bitmap[2] = {
	FATTR4_WORD0_FILES_AVAIL
	| FATTR4_WORD0_FILES_FREE
	| FATTR4_WORD0_FILES_TOTAL,
	FATTR4_WORD1_SPACE_AVAIL
	| FATTR4_WORD1_SPACE_FREE
	| FATTR4_WORD1_SPACE_TOTAL
};

173
const u32 nfs4_pathconf_bitmap[2] = {
Linus Torvalds's avatar
Linus Torvalds committed
174 175 176 177 178
	FATTR4_WORD0_MAXLINK
	| FATTR4_WORD0_MAXNAME,
	0
};

179
const u32 nfs4_fsinfo_bitmap[3] = { FATTR4_WORD0_MAXFILESIZE
Linus Torvalds's avatar
Linus Torvalds committed
180 181 182
			| FATTR4_WORD0_MAXREAD
			| FATTR4_WORD0_MAXWRITE
			| FATTR4_WORD0_LEASE_TIME,
183
			FATTR4_WORD1_TIME_DELTA
184 185
			| FATTR4_WORD1_FS_LAYOUT_TYPES,
			FATTR4_WORD2_LAYOUT_BLKSIZE
Linus Torvalds's avatar
Linus Torvalds committed
186 187
};

188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206
const u32 nfs4_fs_locations_bitmap[2] = {
	FATTR4_WORD0_TYPE
	| FATTR4_WORD0_CHANGE
	| FATTR4_WORD0_SIZE
	| FATTR4_WORD0_FSID
	| FATTR4_WORD0_FILEID
	| FATTR4_WORD0_FS_LOCATIONS,
	FATTR4_WORD1_MODE
	| FATTR4_WORD1_NUMLINKS
	| FATTR4_WORD1_OWNER
	| FATTR4_WORD1_OWNER_GROUP
	| FATTR4_WORD1_RAWDEV
	| FATTR4_WORD1_SPACE_USED
	| FATTR4_WORD1_TIME_ACCESS
	| FATTR4_WORD1_TIME_METADATA
	| FATTR4_WORD1_TIME_MODIFY
	| FATTR4_WORD1_MOUNTED_ON_FILEID
};

207
static void nfs4_setup_readdir(u64 cookie, __be32 *verifier, struct dentry *dentry,
Linus Torvalds's avatar
Linus Torvalds committed
208 209
		struct nfs4_readdir_arg *readdir)
{
210
	__be32 *start, *p;
Linus Torvalds's avatar
Linus Torvalds committed
211 212

	if (cookie > 2) {
213
		readdir->cookie = cookie;
Linus Torvalds's avatar
Linus Torvalds committed
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
		memcpy(&readdir->verifier, verifier, sizeof(readdir->verifier));
		return;
	}

	readdir->cookie = 0;
	memset(&readdir->verifier, 0, sizeof(readdir->verifier));
	if (cookie == 2)
		return;
	
	/*
	 * NFSv4 servers do not return entries for '.' and '..'
	 * Therefore, we fake these entries here.  We let '.'
	 * have cookie 0 and '..' have cookie 1.  Note that
	 * when talking to the server, we always send cookie 0
	 * instead of 1 or 2.
	 */
230
	start = p = kmap_atomic(*readdir->pages);
Linus Torvalds's avatar
Linus Torvalds committed
231 232 233 234 235 236 237 238 239 240 241
	
	if (cookie == 0) {
		*p++ = xdr_one;                                  /* next */
		*p++ = xdr_zero;                   /* cookie, first word */
		*p++ = xdr_one;                   /* cookie, second word */
		*p++ = xdr_one;                             /* entry len */
		memcpy(p, ".\0\0\0", 4);                        /* entry */
		p++;
		*p++ = xdr_one;                         /* bitmap length */
		*p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
		*p++ = htonl(8);              /* attribute buffer length */
242
		p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_inode));
Linus Torvalds's avatar
Linus Torvalds committed
243 244 245 246 247 248 249 250 251 252 253
	}
	
	*p++ = xdr_one;                                  /* next */
	*p++ = xdr_zero;                   /* cookie, first word */
	*p++ = xdr_two;                   /* cookie, second word */
	*p++ = xdr_two;                             /* entry len */
	memcpy(p, "..\0\0", 4);                         /* entry */
	p++;
	*p++ = xdr_one;                         /* bitmap length */
	*p++ = htonl(FATTR4_WORD0_FILEID);             /* bitmap */
	*p++ = htonl(8);              /* attribute buffer length */
254
	p = xdr_encode_hyper(p, NFS_FILEID(dentry->d_parent->d_inode));
Linus Torvalds's avatar
Linus Torvalds committed
255 256 257

	readdir->pgbase = (char *)p - (char *)start;
	readdir->count -= readdir->pgbase;
258
	kunmap_atomic(start);
Linus Torvalds's avatar
Linus Torvalds committed
259 260
}

261 262 263 264 265 266 267 268 269 270
static int nfs4_delay(struct rpc_clnt *clnt, long *timeout)
{
	int res = 0;

	might_sleep();

	if (*timeout <= 0)
		*timeout = NFS4_POLL_RETRY_MIN;
	if (*timeout > NFS4_POLL_RETRY_MAX)
		*timeout = NFS4_POLL_RETRY_MAX;
271
	freezable_schedule_timeout_killable(*timeout);
272 273 274 275 276 277 278 279 280
	if (fatal_signal_pending(current))
		res = -ERESTARTSYS;
	*timeout <<= 1;
	return res;
}

/* This is the error handling routine for processes that are allowed
 * to sleep.
 */
281
static int nfs4_handle_exception(struct nfs_server *server, int errorcode, struct nfs4_exception *exception)
282 283
{
	struct nfs_client *clp = server->nfs_client;
284
	struct nfs4_state *state = exception->state;
285
	struct inode *inode = exception->inode;
286 287 288 289 290 291
	int ret = errorcode;

	exception->retry = 0;
	switch(errorcode) {
		case 0:
			return 0;
292
		case -NFS4ERR_OPENMODE:
293
			if (inode && nfs4_have_delegation(inode, FMODE_READ)) {
294
				nfs4_inode_return_delegation(inode);
295 296 297 298 299
				exception->retry = 1;
				return 0;
			}
			if (state == NULL)
				break;
300 301 302
			ret = nfs4_schedule_stateid_recovery(server, state);
			if (ret < 0)
				break;
303
			goto wait_on_recovery;
304
		case -NFS4ERR_DELEG_REVOKED:
305 306
		case -NFS4ERR_ADMIN_REVOKED:
		case -NFS4ERR_BAD_STATEID:
307 308 309 310 311
			if (inode != NULL && nfs4_have_delegation(inode, FMODE_READ)) {
				nfs_remove_bad_delegation(inode);
				exception->retry = 1;
				break;
			}
312 313
			if (state == NULL)
				break;
314 315 316
			ret = nfs4_schedule_stateid_recovery(server, state);
			if (ret < 0)
				break;
317
			goto wait_on_recovery;
318
		case -NFS4ERR_EXPIRED:
319 320 321 322 323
			if (state != NULL) {
				ret = nfs4_schedule_stateid_recovery(server, state);
				if (ret < 0)
					break;
			}
324
		case -NFS4ERR_STALE_STATEID:
325
		case -NFS4ERR_STALE_CLIENTID:
326 327
			nfs4_schedule_lease_recovery(clp);
			goto wait_on_recovery;
328
#if defined(CONFIG_NFS_V4_1)
329 330 331 332 333 334 335 336 337
		case -NFS4ERR_BADSESSION:
		case -NFS4ERR_BADSLOT:
		case -NFS4ERR_BAD_HIGH_SLOT:
		case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
		case -NFS4ERR_DEADSESSION:
		case -NFS4ERR_SEQ_FALSE_RETRY:
		case -NFS4ERR_SEQ_MISORDERED:
			dprintk("%s ERROR: %d Reset session\n", __func__,
				errorcode);
338
			nfs4_schedule_session_recovery(clp->cl_session, errorcode);
339
			goto wait_on_recovery;
340
#endif /* defined(CONFIG_NFS_V4_1) */
341
		case -NFS4ERR_FILE_OPEN:
342 343 344 345 346 347 348
			if (exception->timeout > HZ) {
				/* We have retried a decent amount, time to
				 * fail
				 */
				ret = -EBUSY;
				break;
			}
349 350 351 352 353
		case -NFS4ERR_GRACE:
		case -NFS4ERR_DELAY:
			ret = nfs4_delay(server->client, &exception->timeout);
			if (ret != 0)
				break;
354
		case -NFS4ERR_RETRY_UNCACHED_REP:
355 356
		case -NFS4ERR_OLD_STATEID:
			exception->retry = 1;
357 358 359 360 361 362 363 364 365 366 367 368 369
			break;
		case -NFS4ERR_BADOWNER:
			/* The following works around a Linux server bug! */
		case -NFS4ERR_BADNAME:
			if (server->caps & NFS_CAP_UIDGID_NOMAP) {
				server->caps &= ~NFS_CAP_UIDGID_NOMAP;
				exception->retry = 1;
				printk(KERN_WARNING "NFS: v4 server %s "
						"does not accept raw "
						"uid/gids. "
						"Reenabling the idmapper.\n",
						server->nfs_client->cl_hostname);
			}
370 371 372
	}
	/* We failed to handle the error */
	return nfs4_map_errors(ret);
373
wait_on_recovery:
374 375 376 377
	ret = nfs4_wait_clnt_recover(clp);
	if (ret == 0)
		exception->retry = 1;
	return ret;
378 379 380
}


381
static void do_renew_lease(struct nfs_client *clp, unsigned long timestamp)
Linus Torvalds's avatar
Linus Torvalds committed
382 383 384 385 386 387 388
{
	spin_lock(&clp->cl_lock);
	if (time_before(clp->cl_last_renewal,timestamp))
		clp->cl_last_renewal = timestamp;
	spin_unlock(&clp->cl_lock);
}

389 390 391 392 393
static void renew_lease(const struct nfs_server *server, unsigned long timestamp)
{
	do_renew_lease(server->nfs_client, timestamp);
}

394 395
#if defined(CONFIG_NFS_V4_1)

396
static void nfs41_sequence_free_slot(struct nfs4_sequence_res *res)
397
{
398
	struct nfs4_session *session;
399
	struct nfs4_slot_table *tbl;
400
	bool send_new_highest_used_slotid = false;
401

402
	if (!res->sr_slot) {
403 404
		/* just wake up the next guy waiting since
		 * we may have not consumed a slot after all */
Andy Adamson's avatar
Andy Adamson committed
405
		dprintk("%s: No slot\n", __func__);
406
		return;
407
	}
408 409
	tbl = res->sr_slot->table;
	session = tbl->session;
410

411
	spin_lock(&tbl->slot_tbl_lock);
412 413 414 415 416 417
	/* Be nice to the server: try to ensure that the last transmitted
	 * value for highest_user_slotid <= target_highest_slotid
	 */
	if (tbl->highest_used_slotid > tbl->target_highest_slotid)
		send_new_highest_used_slotid = true;

418 419 420 421
	if (nfs41_wake_and_assign_slot(tbl, res->sr_slot)) {
		send_new_highest_used_slotid = false;
		goto out_unlock;
	}
422
	nfs4_free_slot(tbl, res->sr_slot);
423 424 425

	if (tbl->highest_used_slotid != NFS4_NO_SLOT)
		send_new_highest_used_slotid = false;
426
out_unlock:
427
	spin_unlock(&tbl->slot_tbl_lock);
428
	res->sr_slot = NULL;
429 430
	if (send_new_highest_used_slotid)
		nfs41_server_notify_highest_slotid_update(session->clp);
431 432
}

433
static int nfs41_sequence_done(struct rpc_task *task, struct nfs4_sequence_res *res)
Andy Adamson's avatar
Andy Adamson committed
434
{
435
	struct nfs4_session *session;
436
	struct nfs4_slot *slot;
437
	struct nfs_client *clp;
438
	bool interrupted = false;
439
	int ret = 1;
Andy Adamson's avatar
Andy Adamson committed
440

441 442
	/* don't increment the sequence number if the task wasn't sent */
	if (!RPC_WAS_SENT(task))
Andy Adamson's avatar
Andy Adamson committed
443 444
		goto out;

445
	slot = res->sr_slot;
446
	session = slot->table->session;
447

448 449 450 451 452
	if (slot->interrupted) {
		slot->interrupted = 0;
		interrupted = true;
	}

Andy Adamson's avatar
Andy Adamson committed
453
	/* Check the SEQUENCE operation status */
454 455
	switch (res->sr_status) {
	case 0:
Andy Adamson's avatar
Andy Adamson committed
456
		/* Update the slot's sequence and clientid lease timer */
457
		++slot->seq_nr;
458
		clp = session->clp;
459
		do_renew_lease(clp, res->sr_timestamp);
460
		/* Check sequence flags */
461 462
		if (res->sr_status_flags != 0)
			nfs4_schedule_lease_recovery(clp);
463
		nfs41_update_target_slotid(slot->table, slot, res);
464
		break;
465 466 467 468 469 470 471 472 473
	case 1:
		/*
		 * sr_status remains 1 if an RPC level error occurred.
		 * The server may or may not have processed the sequence
		 * operation..
		 * Mark the slot as having hosted an interrupted RPC call.
		 */
		slot->interrupted = 1;
		goto out;
474 475 476 477 478
	case -NFS4ERR_DELAY:
		/* The server detected a resend of the RPC call and
		 * returned NFS4ERR_DELAY as per Section 2.10.6.2
		 * of RFC5661.
		 */
479
		dprintk("%s: slot=%u seq=%u: Operation in progress\n",
480
			__func__,
481
			slot->slot_nr,
482
			slot->seq_nr);
483
		goto out_retry;
484 485 486 487 488
	case -NFS4ERR_BADSLOT:
		/*
		 * The slot id we used was probably retired. Try again
		 * using a different slot id.
		 */
489 490
		goto retry_nowait;
	case -NFS4ERR_SEQ_MISORDERED:
491 492 493 494 495 496 497 498
		/*
		 * Was the last operation on this sequence interrupted?
		 * If so, retry after bumping the sequence number.
		 */
		if (interrupted) {
			++slot->seq_nr;
			goto retry_nowait;
		}
499 500 501 502
		/*
		 * Could this slot have been previously retired?
		 * If so, then the server may be expecting seq_nr = 1!
		 */
503 504 505 506 507
		if (slot->seq_nr != 1) {
			slot->seq_nr = 1;
			goto retry_nowait;
		}
		break;
508 509 510
	case -NFS4ERR_SEQ_FALSE_RETRY:
		++slot->seq_nr;
		goto retry_nowait;
511 512
	default:
		/* Just update the slot sequence no. */
513
		++slot->seq_nr;
Andy Adamson's avatar
Andy Adamson committed
514 515 516 517
	}
out:
	/* The session may be reset by one of the error handlers. */
	dprintk("%s: Error %d free the slot \n", __func__, res->sr_status);
518
	nfs41_sequence_free_slot(res);
519
	return ret;
520 521 522 523 524 525
retry_nowait:
	if (rpc_restart_call_prepare(task)) {
		task->tk_status = 0;
		ret = 0;
	}
	goto out;
526
out_retry:
527
	if (!rpc_restart_call(task))
528 529 530
		goto out;
	rpc_delay(task, NFS4_POLL_RETRY_MAX);
	return 0;
Andy Adamson's avatar
Andy Adamson committed
531 532
}

533 534
static int nfs4_sequence_done(struct rpc_task *task,
			       struct nfs4_sequence_res *res)
535
{
536
	if (res->sr_slot == NULL)
537 538
		return 1;
	return nfs41_sequence_done(task, res);
539 540
}

541 542 543
static void nfs41_init_sequence(struct nfs4_sequence_args *args,
		struct nfs4_sequence_res *res, int cache_reply)
{
544
	args->sa_slot = NULL;
545
	args->sa_cache_this = 0;
546
	args->sa_privileged = 0;
547 548 549 550 551
	if (cache_reply)
		args->sa_cache_this = 1;
	res->sr_slot = NULL;
}

552 553 554 555 556
static void nfs4_set_sequence_privileged(struct nfs4_sequence_args *args)
{
	args->sa_privileged = 1;
}

Andy Adamson's avatar
Andy Adamson committed
557
int nfs41_setup_sequence(struct nfs4_session *session,
Andy Adamson's avatar
Andy Adamson committed
558 559 560 561
				struct nfs4_sequence_args *args,
				struct nfs4_sequence_res *res,
				struct rpc_task *task)
{
Andy Adamson's avatar
Andy Adamson committed
562 563 564 565
	struct nfs4_slot *slot;
	struct nfs4_slot_table *tbl;

	dprintk("--> %s\n", __func__);
Andy Adamson's avatar
Andy Adamson committed
566
	/* slot already allocated? */
567
	if (res->sr_slot != NULL)
568
		goto out_success;
Andy Adamson's avatar
Andy Adamson committed
569

Andy Adamson's avatar
Andy Adamson committed
570 571
	tbl = &session->fc_slot_table;

572 573
	task->tk_timeout = 0;

Andy Adamson's avatar
Andy Adamson committed
574
	spin_lock(&tbl->slot_tbl_lock);
575
	if (test_bit(NFS4_SLOT_TBL_DRAINING, &tbl->slot_tbl_state) &&
576
	    !args->sa_privileged) {
577 578
		/* The state manager will wait until the slot table is empty */
		dprintk("%s session is draining\n", __func__);
579
		goto out_sleep;
580 581
	}

582
	slot = nfs4_alloc_slot(tbl);
583 584 585 586
	if (IS_ERR(slot)) {
		/* If out of memory, try again in 1/4 second */
		if (slot == ERR_PTR(-ENOMEM))
			task->tk_timeout = HZ >> 2;
Andy Adamson's avatar
Andy Adamson committed
587
		dprintk("<-- %s: no free slots\n", __func__);
588
		goto out_sleep;
Andy Adamson's avatar
Andy Adamson committed
589 590 591
	}
	spin_unlock(&tbl->slot_tbl_lock);

592
	args->sa_slot = slot;
Andy Adamson's avatar
Andy Adamson committed
593

594 595
	dprintk("<-- %s slotid=%d seqid=%d\n", __func__,
			slot->slot_nr, slot->seq_nr);
Andy Adamson's avatar
Andy Adamson committed
596

597
	res->sr_slot = slot;
598
	res->sr_timestamp = jiffies;
599
	res->sr_status_flags = 0;
Andy Adamson's avatar
Andy Adamson committed
600 601 602 603 604
	/*
	 * sr_status is only set in decode_sequence, and so will remain
	 * set to 1 if an rpc level failure occurs.
	 */
	res->sr_status = 1;
605 606
out_success:
	rpc_call_start(task);
Andy Adamson's avatar
Andy Adamson committed
607
	return 0;
608
out_sleep:
609 610
	/* Privileged tasks are queued with top priority */
	if (args->sa_privileged)
611 612 613 614
		rpc_sleep_on_priority(&tbl->slot_tbl_waitq, task,
				NULL, RPC_PRIORITY_PRIVILEGED);
	else
		rpc_sleep_on(&tbl->slot_tbl_waitq, task, NULL);
615 616
	spin_unlock(&tbl->slot_tbl_lock);
	return -EAGAIN;
Andy Adamson's avatar
Andy Adamson committed
617
}
Andy Adamson's avatar
Andy Adamson committed
618
EXPORT_SYMBOL_GPL(nfs41_setup_sequence);
Andy Adamson's avatar
Andy Adamson committed
619

620
int nfs4_setup_sequence(const struct nfs_server *server,
Andy Adamson's avatar
Andy Adamson committed
621 622 623 624
			struct nfs4_sequence_args *args,
			struct nfs4_sequence_res *res,
			struct rpc_task *task)
{
625
	struct nfs4_session *session = nfs4_get_session(server);
Andy Adamson's avatar
Andy Adamson committed
626 627
	int ret = 0;

628 629
	if (session == NULL) {
		rpc_call_start(task);
630
		goto out;
631
	}
632

633
	dprintk("--> %s clp %p session %p sr_slot %d\n",
634
		__func__, session->clp, session, res->sr_slot ?
635
			res->sr_slot->slot_nr : -1);
Andy Adamson's avatar
Andy Adamson committed
636

637
	ret = nfs41_setup_sequence(session, args, res, task);
Andy Adamson's avatar
Andy Adamson committed
638 639 640 641 642 643
out:
	dprintk("<-- %s status=%d\n", __func__, ret);
	return ret;
}

struct nfs41_call_sync_data {
644
	const struct nfs_server *seq_server;
Andy Adamson's avatar
Andy Adamson committed
645 646 647 648 649 650 651
	struct nfs4_sequence_args *seq_args;
	struct nfs4_sequence_res *seq_res;
};

static void nfs41_call_sync_prepare(struct rpc_task *task, void *calldata)
{
	struct nfs41_call_sync_data *data = calldata;
652
	struct nfs4_session *session = nfs4_get_session(data->seq_server);
Andy Adamson's avatar
Andy Adamson committed
653

654 655
	dprintk("--> %s data->seq_server %p\n", __func__, data->seq_server);

656
	nfs41_setup_sequence(session, data->seq_args, data->seq_res, task);
Andy Adamson's avatar
Andy Adamson committed
657 658
}

Andy Adamson's avatar
Andy Adamson committed
659 660 661 662
static void nfs41_call_sync_done(struct rpc_task *task, void *calldata)
{
	struct nfs41_call_sync_data *data = calldata;

663
	nfs41_sequence_done(task, data->seq_res);
Andy Adamson's avatar
Andy Adamson committed
664 665
}

666
static const struct rpc_call_ops nfs41_call_sync_ops = {
Andy Adamson's avatar
Andy Adamson committed
667
	.rpc_call_prepare = nfs41_call_sync_prepare,
Andy Adamson's avatar
Andy Adamson committed
668
	.rpc_call_done = nfs41_call_sync_done,
Andy Adamson's avatar
Andy Adamson committed
669 670
};

671 672
static int nfs4_call_sync_sequence(struct rpc_clnt *clnt,
				   struct nfs_server *server,
Andy Adamson's avatar
Andy Adamson committed
673 674
				   struct rpc_message *msg,
				   struct nfs4_sequence_args *args,
675
				   struct nfs4_sequence_res *res)
Andy Adamson's avatar
Andy Adamson committed
676 677 678 679
{
	int ret;
	struct rpc_task *task;
	struct nfs41_call_sync_data data = {
680
		.seq_server = server,
Andy Adamson's avatar
Andy Adamson committed
681 682 683 684
		.seq_args = args,
		.seq_res = res,
	};
	struct rpc_task_setup task_setup = {
685
		.rpc_client = clnt,
Andy Adamson's avatar
Andy Adamson committed
686 687 688 689 690 691 692 693 694 695 696 697 698 699 700
		.rpc_message = msg,
		.callback_ops = &nfs41_call_sync_ops,
		.callback_data = &data
	};

	task = rpc_run_task(&task_setup);
	if (IS_ERR(task))
		ret = PTR_ERR(task);
	else {
		ret = task->tk_status;
		rpc_put_task(task);
	}
	return ret;
}

701
#else
702
static
703 704 705 706 707
void nfs41_init_sequence(struct nfs4_sequence_args *args,
		struct nfs4_sequence_res *res, int cache_reply)
{
}

708 709 710 711 712
static void nfs4_set_sequence_privileged(struct nfs4_sequence_args *args)
{
}


713 714
static int nfs4_sequence_done(struct rpc_task *task,
			       struct nfs4_sequence_res *res)
715
{
716
	return 1;
717
}
718 719
#endif /* CONFIG_NFS_V4_1 */

720
static
721 722
int _nfs4_call_sync(struct rpc_clnt *clnt,
		    struct nfs_server *server,
723 724
		    struct rpc_message *msg,
		    struct nfs4_sequence_args *args,
725
		    struct nfs4_sequence_res *res)
726
{
727
	return rpc_call_sync(clnt, msg, 0);
728 729
}

730
static
731 732
int nfs4_call_sync(struct rpc_clnt *clnt,
		   struct nfs_server *server,
733 734 735 736 737
		   struct rpc_message *msg,
		   struct nfs4_sequence_args *args,
		   struct nfs4_sequence_res *res,
		   int cache_reply)
{
738
	nfs41_init_sequence(args, res, cache_reply);
739
	return server->nfs_client->cl_mvops->call_sync(clnt, server, msg,
740
						args, res);
741
}
742

743
static void update_changeattr(struct inode *dir, struct nfs4_change_info *cinfo)
Linus Torvalds's avatar
Linus Torvalds committed
744
{
745
	struct nfs_inode *nfsi = NFS_I(dir);
Linus Torvalds's avatar
Linus Torvalds committed
746

747
	spin_lock(&dir->i_lock);
748
	nfsi->cache_validity |= NFS_INO_INVALID_ATTR|NFS_INO_INVALID_DATA;
749
	if (!cinfo->atomic || cinfo->before != dir->i_version)
750
		nfs_force_lookup_revalidate(dir);
751
	dir->i_version = cinfo->after;
752
	nfs_fscache_invalidate(dir);
753
	spin_unlock(&dir->i_lock);
Linus Torvalds's avatar
Linus Torvalds committed
754 755
}

756
struct nfs4_opendata {
757
	struct kref kref;
758 759
	struct nfs_openargs o_arg;
	struct nfs_openres o_res;
760 761
	struct nfs_open_confirmargs c_arg;
	struct nfs_open_confirmres c_res;
762 763
	struct nfs4_string owner_name;
	struct nfs4_string group_name;
764 765
	struct nfs_fattr f_attr;
	struct dentry *dir;
766
	struct dentry *dentry;
767
	struct nfs4_state_owner *owner;
768
	struct nfs4_state *state;
769
	struct iattr attrs;
770
	unsigned long timestamp;
771
	unsigned int rpc_done : 1;
772
	unsigned int is_recover : 1;
773 774
	int rpc_status;
	int cancelled;
775 776
};

777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805
static bool nfs4_clear_cap_atomic_open_v1(struct nfs_server *server,
		int err, struct nfs4_exception *exception)
{
	if (err != -EINVAL)
		return false;
	if (!(server->caps & NFS_CAP_ATOMIC_OPEN_V1))
		return false;
	server->caps &= ~NFS_CAP_ATOMIC_OPEN_V1;
	exception->retry = 1;
	return true;
}

static enum open_claim_type4
nfs4_map_atomic_open_claim(struct nfs_server *server,
		enum open_claim_type4 claim)
{
	if (server->caps & NFS_CAP_ATOMIC_OPEN_V1)
		return claim;
	switch (claim) {
	default:
		return claim;
	case NFS4_OPEN_CLAIM_FH:
		return NFS4_OPEN_CLAIM_NULL;
	case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
		return NFS4_OPEN_CLAIM_DELEGATE_CUR;
	case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
		return NFS4_OPEN_CLAIM_DELEGATE_PREV;
	}
}
806 807 808 809

static void nfs4_init_opendata_res(struct nfs4_opendata *p)
{
	p->o_res.f_attr = &p->f_attr;
810 811
	p->o_res.seqid = p->o_arg.seqid;
	p->c_res.seqid = p->c_arg.seqid;
812
	p->o_res.server = p->o_arg.server;
813
	p->o_res.access_request = p->o_arg.access;
814
	nfs_fattr_init(&p->f_attr);
815
	nfs_fattr_init_names(&p->f_attr, &p->owner_name, &p->group_name);
816 817
}

818
static struct nfs4_opendata *nfs4_opendata_alloc(struct dentry *dentry,
819
		struct nfs4_state_owner *sp, fmode_t fmode, int flags,
820
		const struct iattr *attrs,
821
		enum open_claim_type4 claim,
822
		gfp_t gfp_mask)
823
{
824
	struct dentry *parent = dget_parent(dentry);
825 826 827 828
	struct inode *dir = parent->d_inode;
	struct nfs_server *server = NFS_SERVER(dir);
	struct nfs4_opendata *p;

829
	p = kzalloc(sizeof(*p), gfp_mask);
830 831
	if (p == NULL)
		goto err;
832
	p->o_arg.seqid = nfs_alloc_seqid(&sp->so_seqid, gfp_mask);
833 834
	if (p->o_arg.seqid == NULL)
		goto err_free;
835 836
	nfs_sb_active(dentry->d_sb);
	p->dentry = dget(dentry);
837 838 839
	p->dir = parent;
	p->owner = sp;
	atomic_inc(&sp->so_count);
840 841
	p->o_arg.open_flags = flags;
	p->o_arg.fmode = fmode & (FMODE_READ|FMODE_WRITE);
842 843 844 845 846 847 848 849
	/* don't put an ACCESS op in OPEN compound if O_EXCL, because ACCESS
	 * will return permission denied for all bits until close */
	if (!(flags & O_EXCL)) {
		/* ask server to check for all possible rights as results
		 * are cached */
		p->o_arg.access = NFS4_ACCESS_READ | NFS4_ACCESS_MODIFY |
				  NFS4_ACCESS_EXTEND | NFS4_ACCESS_EXECUTE;
	}
850
	p->o_arg.clientid = server->nfs_client->cl_clientid;
851 852
	p->o_arg.id.create_time = ktime_to_ns(sp->so_seqid.create_time);
	p->o_arg.id.uniquifier = sp->so_seqid.owner_id;
853
	p->o_arg.name = &dentry->d_name;
854 855
	p->o_arg.server = server;
	p->o_arg.bitmask = server->attr_bitmask;
856
	p->o_arg.open_bitmap = &nfs4_fattr_bitmap[0];
857 858
	p->o_arg.claim = nfs4_map_atomic_open_claim(server, claim);
	switch (p->o_arg.claim) {
859 860 861 862 863 864 865 866 867 868 869
	case NFS4_OPEN_CLAIM_NULL:
	case NFS4_OPEN_CLAIM_DELEGATE_CUR:
	case NFS4_OPEN_CLAIM_DELEGATE_PREV:
		p->o_arg.fh = NFS_FH(dir);
		break;
	case NFS4_OPEN_CLAIM_PREVIOUS:
	case NFS4_OPEN_CLAIM_FH:
	case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
	case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
		p->o_arg.fh = NFS_FH(dentry->d_inode);
	}
870
	if (attrs != NULL && attrs->ia_valid != 0) {
871
		__be32 verf[2];
872

873 874
		p->o_arg.u.attrs = &p->attrs;
		memcpy(&p->attrs, attrs, sizeof(p->attrs));
875 876 877 878 879

		verf[0] = jiffies;
		verf[1] = current->pid;
		memcpy(p->o_arg.u.verifier.data, verf,
				sizeof(p->o_arg.u.verifier.data));
880
	}
881 882 883
	p->c_arg.fh = &p->o_res.fh;
	p->c_arg.stateid = &p->o_res.stateid;
	p->c_arg.seqid = p->o_arg.seqid;
884
	nfs4_init_opendata_res(p);
885
	kref_init(&p->kref);
886 887 888 889 890 891 892 893
	return p;
err_free:
	kfree(p);
err:
	dput(parent);
	return NULL;
}

894
static void nfs4_opendata_free(struct kref *kref)
895
{
896 897
	struct nfs4_opendata *p = container_of(kref,
			struct nfs4_opendata, kref);
898
	struct super_block *sb = p->dentry->d_sb;
899 900

	nfs_free_seqid(p->o_arg.seqid);
901 902
	if (p->state != NULL)
		nfs4_put_open_state(p->state);
903 904
	nfs4_put_state_owner(p->owner);
	dput(p->dir);
905 906
	dput(p->dentry);
	nfs_sb_deactive(sb);
907
	nfs_fattr_free_names(&p->f_attr);
908 909 910 911 912 913 914
	kfree(p);
}

static void nfs4_opendata_put(struct nfs4_opendata *p)
{
	if (p != NULL)
		kref_put(&p->kref, nfs4_opendata_free);
915 916
}

917 918 919 920 921 922 923 924
static int nfs4_wait_for_completion_rpc_task(struct rpc_task *task)
{
	int ret;

	ret = rpc_wait_for_completion_task(task);
	return ret;
}

925
static int can_open_cached(struct nfs4_state *state, fmode_t mode, int open_mode)
926 927
{
	int ret = 0;
928

929
	if (open_mode & (O_EXCL|O_TRUNC))
930 931
		goto out;
	switch (mode & (FMODE_READ|FMODE_WRITE)) {
932
		case FMODE_READ:
933 934
			ret |= test_bit(NFS_O_RDONLY_STATE, &state->flags) != 0
				&& state->n_rdonly != 0;
935 936
			break;
		case FMODE_WRITE:
937 938
			ret |= test_bit(NFS_O_WRONLY_STATE, &state->flags) != 0
				&& state->n_wronly != 0;
939 940
			break;
		case FMODE_READ|FMODE_WRITE:
941 942
			ret |= test_bit(NFS_O_RDWR_STATE, &state->flags) != 0
				&& state->n_rdwr != 0;
943
	}
944
out:
945 946 947
	return ret;
}

948
static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode)
949
{
950 951
	if (delegation == NULL)
		return 0;
952
	if ((delegation->type & fmode) != fmode)
953
		return 0;
954
	if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags))
955
		return 0;
956 957
	if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
		return 0;
958
	nfs_mark_delegation_referenced(delegation);
959 960 961
	return 1;
}

962
static void update_open_stateflags(struct nfs4_state *state, fmode_t fmode)
963
{
964
	switch (fmode) {
965 966 967 968 969 970 971 972 973
		case FMODE_WRITE:
			state->n_wronly++;
			break;
		case FMODE_READ:
			state->n_rdonly++;
			break;
		case FMODE_READ|FMODE_WRITE:
			state->n_rdwr++;
	}
974
	nfs4_state_set_mode_locked(state, state->state | fmode);
975 976
}

977
static void nfs_set_open_stateid_locked(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)
978 979
{
	if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
980 981
		nfs4_stateid_copy(&state->stateid, stateid);
	nfs4_stateid_copy(&state->open_stateid, stateid);
982
	set_bit(NFS_OPEN_STATE, &state->flags);
983
	switch (fmode) {
984 985 986 987 988 989 990 991 992
		case FMODE_READ:
			set_bit(NFS_O_RDONLY_STATE, &state->flags);
			break;
		case FMODE_WRITE:
			set_bit(NFS_O_WRONLY_STATE, &state->flags);
			break;
		case FMODE_READ|FMODE_WRITE:
			set_bit(NFS_O_RDWR_STATE, &state->flags);
	}
993 994
}

995
static void nfs_set_open_stateid(struct nfs4_state *state, nfs4_stateid *stateid, fmode_t fmode)
996
{
997
	write_seqlock(&state->seqlock);
998
	nfs_set_open_stateid_locked(state, stateid, fmode);
999
	write_sequnlock(&state->seqlock);
1000 1001
}

1002
static void __update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, const nfs4_stateid *deleg_stateid, fmode_t fmode)
Linus Torvalds's avatar
Linus Torvalds committed
1003
{
1004 1005 1006 1007 1008
	/*
	 * Protect the call to nfs4_state_set_mode_locked and
	 * serialise the stateid update
	 */
	write_seqlock(&state->seqlock);
1009
	if (deleg_stateid != NULL) {
1010
		nfs4_stateid_copy(&state->stateid, deleg_stateid);
1011 1012 1013
		set_bit(NFS_DELEGATED_STATE, &state->flags);
	}
	if (open_stateid != NULL)
1014
		nfs_set_open_stateid_locked(state, open_stateid, fmode);
1015 1016
	write_sequnlock(&state->seqlock);
	spin_lock(&state->owner->so_lock);
1017
	update_open_stateflags(state, fmode);
1018
	spin_unlock(&state->owner->so_lock);
Linus Torvalds's avatar
Linus Torvalds committed
1019 1020
}

1021
static int update_open_stateid(struct nfs4_state *state, nfs4_stateid *open_stateid, nfs4_stateid *delegation, fmode_t fmode)
1022 1023 1024 1025 1026
{
	struct nfs_inode *nfsi = NFS_I(state->inode);
	struct nfs_delegation *deleg_cur;
	int ret = 0;

1027
	fmode &= (FMODE_READ|FMODE_WRITE);
1028 1029 1030 1031 1032 1033 1034 1035

	rcu_read_lock();
	deleg_cur = rcu_dereference(nfsi->delegation);
	if (deleg_cur == NULL)
		goto no_delegation;

	spin_lock(&deleg_cur->lock);
	if (nfsi->delegation != deleg_cur ||
1036
	   test_bit(NFS_DELEGATION_RETURNING, &deleg_cur->flags) ||
1037
	    (deleg_cur->type & fmode) != fmode)
1038 1039 1040 1041
		goto no_delegation_unlock;

	if (delegation == NULL)
		delegation = &deleg_cur->stateid;
1042
	else if (!nfs4_stateid_match(&deleg_cur->stateid, delegation))
1043 1044
		goto no_delegation_unlock;

1045
	nfs_mark_delegation_referenced(deleg_cur);
1046
	__update_open_stateid(state, open_stateid, &deleg_cur->stateid, fmode);
1047 1048 1049 1050 1051 1052 1053
	ret = 1;
no_delegation_unlock:
	spin_unlock(&deleg_cur->lock);
no_delegation:
	rcu_read_unlock();

	if (!ret && open_stateid != NULL) {
1054
		__update_open_stateid(state, open_stateid, NULL, fmode);
1055 1056 1057 1058 1059 1060 1061
		ret = 1;
	}

	return ret;
}


1062
static void nfs4_return_incompatible_delegation(struct inode *inode, fmode_t fmode)
1063 1064 1065 1066 1067
{
	struct nfs_delegation *delegation;

	rcu_read_lock();
	delegation = rcu_dereference(NFS_I(inode)->delegation);
1068
	if (delegation == NULL || (delegation->type & fmode) == fmode) {
1069 1070 1071 1072
		rcu_read_unlock();
		return;
	}
	rcu_read_unlock();
1073
	nfs4_inode_return_delegation(inode);
1074 1075
}

1076
static struct nfs4_state *nfs4_try_open_cached(struct nfs4_opendata *opendata)
1077 1078 1079 1080
{
	struct nfs4_state *state = opendata->state;
	struct nfs_inode *nfsi = NFS_I(state->inode);
	struct nfs_delegation *delegation;
1081
	int open_mode = opendata->o_arg.open_flags;
1082
	fmode_t fmode = opendata->o_arg.fmode;
1083 1084 1085 1086
	nfs4_stateid stateid;
	int ret = -EAGAIN;

	for (;;) {
1087
		if (can_open_cached(state, fmode, open_mode)) {
1088
			spin_lock(&state->owner->so_lock);
1089 1090
			if (can_open_cached(state, fmode, open_mode)) {
				update_open_stateflags(state, fmode);
1091 1092 1093 1094 1095
				spin_unlock(&state->owner->so_lock);
				goto out_return_state;
			}
			spin_unlock(&state->owner->so_lock);
		}
1096 1097
		rcu_read_lock();
		delegation = rcu_dereference(nfsi->delegation);
1098
		if (!can_open_delegated(delegation, fmode)) {
1099
			rcu_read_unlock();
1100
			break;
1101
		}
1102
		/* Save the delegation */
1103
		nfs4_stateid_copy(&stateid, &delegation->stateid);
1104
		rcu_read_unlock();
1105
		nfs_release_seqid(opendata->o_arg.seqid);
1106 1107 1108 1109 1110
		if (!opendata->is_recover) {
			ret = nfs_may_open(state->inode, state->owner->so_cred, open_mode);
			if (ret != 0)
				goto out;
		}
1111
		ret = -EAGAIN;
1112 1113

		/* Try to update the stateid using the delegation */
1114
		if (update_open_stateid(state, NULL, &stateid, fmode))
1115
			goto out_return_state;
1116 1117 1118 1119 1120 1121 1122 1123
	}
out:
	return ERR_PTR(ret);
out_return_state:
	atomic_inc(&state->count);
	return state;
}

1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161
static void
nfs4_opendata_check_deleg(struct nfs4_opendata *data, struct nfs4_state *state)
{
	struct nfs_client *clp = NFS_SERVER(state->inode)->nfs_client;
	struct nfs_delegation *delegation;
	int delegation_flags = 0;

	rcu_read_lock();
	delegation = rcu_dereference(NFS_I(state->inode)->delegation);
	if (delegation)
		delegation_flags = delegation->flags;
	rcu_read_unlock();
	if (data->o_arg.claim == NFS4_OPEN_CLAIM_DELEGATE_CUR) {
		pr_err_ratelimited("NFS: Broken NFSv4 server %s is "
				   "returning a delegation for "
				   "OPEN(CLAIM_DELEGATE_CUR)\n",
				   clp->cl_hostname);
	} else if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)
		nfs_inode_set_delegation(state->inode,
					 data->owner->so_cred,
					 &data->o_res);
	else
		nfs_inode_reclaim_delegation(state->inode,
					     data->owner->so_cred,
					     &data->o_res);
}

/*
 * Check the inode attributes against the CLAIM_PREVIOUS returned attributes
 * and update the nfs4_state.
 */
static struct nfs4_state *
_nfs4_opendata_reclaim_to_nfs4_state(struct nfs4_opendata *data)
{
	struct inode *inode = data->state->inode;
	struct nfs4_state *state = data->state;
	int ret;

1162 1163 1164 1165 1166 1167 1168
	if (!data->rpc_done) {
		if (data->rpc_status) {
			ret = data->rpc_status;
			goto err;
		}
		/* cached opens have already been processed */
		goto update;
1169 1170 1171 1172 1173 1174 1175 1176
	}

	ret = nfs_refresh_inode(inode, &data->f_attr);
	if (ret)
		goto err;

	if (data->o_res.delegation_type != 0)
		nfs4_opendata_check_deleg(data, state);
1177
update:
1178 1179
	update_open_stateid(state, &data->o_res.stateid, NULL,
			    data->o_arg.fmode);
1180
	atomic_inc(&state->count);
1181 1182 1183 1184 1185 1186 1187 1188 1189

	return state;
err:
	return ERR_PTR(ret);

}

static struct nfs4_state *
_nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
1190 1191 1192
{
	struct inode *inode;
	struct nfs4_state *state = NULL;
1193
	int ret;
1194

1195
	if (!data->rpc_done) {
1196
		state = nfs4_try_open_cached(data);
1197 1198 1199
		goto out;
	}

1200
	ret = -EAGAIN;
1201
	if (!(data->f_attr.valid & NFS_ATTR_FATTR))
1202
		goto err;
1203
	inode = nfs_fhget(data->dir->d_sb, &data->o_res.fh, &data->f_attr);
1204
	ret = PTR_ERR(inode);
1205
	if (IS_ERR(inode))
1206 1207
		goto err;
	ret = -ENOMEM;
1208 1209
	state = nfs4_get_open_state(inode, data->owner);
	if (state == NULL)
1210
		goto err_put_inode;
1211 1212
	if (data->o_res.delegation_type != 0)
		nfs4_opendata_check_deleg(data, state);
1213
	update_open_stateid(state, &data->o_res.stateid, NULL,
1214
			data->o_arg.fmode);
1215
	iput(inode);
1216
out:
1217
	nfs_release_seqid(data->o_arg.seqid);
1218
	return state;
1219 1220 1221 1222
err_put_inode:
	iput(inode);
err:
	return ERR_PTR(ret);
1223 1224
}

1225 1226 1227 1228 1229 1230 1231 1232
static struct nfs4_state *
nfs4_opendata_to_nfs4_state(struct nfs4_opendata *data)
{
	if (data->o_arg.claim == NFS4_OPEN_CLAIM_PREVIOUS)
		return _nfs4_opendata_reclaim_to_nfs4_state(data);
	return _nfs4_opendata_to_nfs4_state(data);
}

1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249
static struct nfs_open_context *nfs4_state_find_open_context(struct nfs4_state *state)
{
	struct nfs_inode *nfsi = NFS_I(state->inode);
	struct nfs_open_context *ctx;

	spin_lock(&state->inode->i_lock);
	list_for_each_entry(ctx, &nfsi->open_files, list) {
		if (ctx->state != state)
			continue;
		get_nfs_open_context(ctx);
		spin_unlock(&state->inode->i_lock);
		return ctx;
	}
	spin_unlock(&state->inode->i_lock);
	return ERR_PTR(-ENOENT);
}

1250 1251
static struct nfs4_opendata *nfs4_open_recoverdata_alloc(struct nfs_open_context *ctx,
		struct nfs4_state *state, enum open_claim_type4 claim)
1252 1253 1254
{
	struct nfs4_opendata *opendata;

1255 1256
	opendata = nfs4_opendata_alloc(ctx->dentry, state->owner, 0, 0,
			NULL, claim, GFP_NOFS);
1257 1258 1259 1260 1261 1262 1263
	if (opendata == NULL)
		return ERR_PTR(-ENOMEM);
	opendata->state = state;
	atomic_inc(&state->count);
	return opendata;
}

1264
static int nfs4_open_recover_helper(struct nfs4_opendata *opendata, fmode_t fmode, struct nfs4_state **res)
1265
{
1266
	struct nfs4_state *newstate;
1267 1268
	int ret;

1269 1270
	opendata->o_arg.open_flags = 0;
	opendata->o_arg.fmode = fmode;
1271 1272 1273
	memset(&opendata->o_res, 0, sizeof(opendata->o_res));
	memset(&opendata->c_res, 0, sizeof(opendata->c_res));
	nfs4_init_opendata_res(opendata);
1274
	ret = _nfs4_recover_proc_open(opendata);
1275 1276
	if (ret != 0)
		return ret; 
1277
	newstate = nfs4_opendata_to_nfs4_state(opendata);
1278 1279
	if (IS_ERR(newstate))
		return PTR_ERR(newstate);
1280
	nfs4_close_state(newstate, fmode);
1281
	*res = newstate;
1282 1283 1284 1285 1286 1287 1288 1289 1290
	return 0;
}

static int nfs4_open_recover(struct nfs4_opendata *opendata, struct nfs4_state *state)
{
	struct nfs4_state *newstate;
	int ret;

	/* memory barrier prior to reading state->n_* */
1291
	clear_bit(NFS_DELEGATED_STATE, &state->flags);
1292
	clear_bit(NFS_OPEN_STATE, &state->flags);
1293 1294
	smp_rmb();
	if (state->n_rdwr != 0) {
Trond Myklebust's avatar
Trond Myklebust committed
1295
		clear_bit(NFS_O_RDWR_STATE, &state->flags);
1296
		ret = nfs4_open_recover_helper(opendata, FMODE_READ|FMODE_WRITE, &newstate);
1297 1298
		if (ret != 0)
			return ret;
1299 1300
		if (newstate != state)
			return -ESTALE;
1301 1302
	}
	if (state->n_wronly != 0) {
Trond Myklebust's avatar
Trond Myklebust committed
1303
		clear_bit(NFS_O_WRONLY_STATE, &state->flags);
1304
		ret = nfs4_open_recover_helper(opendata, FMODE_WRITE, &newstate);
1305 1306
		if (ret != 0)
			return ret;
1307 1308
		if (newstate != state)
			return -ESTALE;
1309 1310
	}
	if (state->n_rdonly != 0) {
Trond Myklebust's avatar
Trond Myklebust committed
1311
		clear_bit(NFS_O_RDONLY_STATE, &state->flags);
1312
		ret = nfs4_open_recover_helper(opendata, FMODE_READ, &newstate);
1313 1314
		if (ret != 0)
			return ret;
1315 1316
		if (newstate != state)
			return -ESTALE;
1317
	}
1318 1319 1320 1321 1322
	/*
	 * We may have performed cached opens for all three recoveries.
	 * Check if we need to update the current stateid.
	 */
	if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0 &&
1323
	    !nfs4_stateid_match(&state->stateid, &state->open_stateid)) {
1324
		write_seqlock(&state->seqlock);
1325
		if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
1326
			nfs4_stateid_copy(&state->stateid, &state->open_stateid);
1327
		write_sequnlock(&state->seqlock);
1328
	}
1329 1330 1331
	return 0;
}

Linus Torvalds's avatar
Linus Torvalds committed
1332 1333 1334 1335
/*
 * OPEN_RECLAIM:
 * 	reclaim state on the server after a reboot.
 */
1336
static int _nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
Linus Torvalds's avatar
Linus Torvalds committed
1337
{
1338
	struct nfs_delegation *delegation;
1339
	struct nfs4_opendata *opendata;
1340
	fmode_t delegation_type = 0;
Linus Torvalds's avatar
Linus Torvalds committed
1341 1342
	int status;

1343 1344
	opendata = nfs4_open_recoverdata_alloc(ctx, state,
			NFS4_OPEN_CLAIM_PREVIOUS);
1345 1346
	if (IS_ERR(opendata))
		return PTR_ERR(opendata);
1347 1348
	rcu_read_lock();
	delegation = rcu_dereference(NFS_I(state->inode)->delegation);
1349
	if (delegation != NULL && test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) != 0)
1350
		delegation_type = delegation->type;
1351
	rcu_read_unlock();
1352 1353
	opendata->o_arg.u.delegation_type = delegation_type;
	status = nfs4_open_recover(opendata, state);
1354
	nfs4_opendata_put(opendata);
Linus Torvalds's avatar
Linus Torvalds committed
1355 1356 1357
	return status;
}

1358
static int nfs4_do_open_reclaim(struct nfs_open_context *ctx, struct nfs4_state *state)
Linus Torvalds's avatar
Linus Torvalds committed
1359 1360 1361 1362 1363
{
	struct nfs_server *server = NFS_SERVER(state->inode);
	struct nfs4_exception exception = { };
	int err;
	do {
1364
		err = _nfs4_do_open_reclaim(ctx, state);
1365 1366
		if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
			continue;
1367
		if (err != -NFS4ERR_DELAY)
1368 1369
			break;
		nfs4_handle_exception(server, err, &exception);
Linus Torvalds's avatar
Linus Torvalds committed
1370 1371 1372 1373
	} while (exception.retry);
	return err;
}

1374 1375 1376 1377 1378 1379 1380
static int nfs4_open_reclaim(struct nfs4_state_owner *sp, struct nfs4_state *state)
{
	struct nfs_open_context *ctx;
	int ret;

	ctx = nfs4_state_find_open_context(state);
	if (IS_ERR(ctx))
1381
		return -EAGAIN;
1382
	ret = nfs4_do_open_reclaim(ctx, state);
1383 1384 1385 1386
	put_nfs_open_context(ctx);
	return ret;
}

1387
static int nfs4_handle_delegation_recall_error(struct nfs_server *server, struct nfs4_state *state, const nfs4_stateid *stateid, int err)
Linus Torvalds's avatar
Linus Torvalds committed
1388
{
1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414
	switch (err) {
		default:
			printk(KERN_ERR "NFS: %s: unhandled error "
					"%d.\n", __func__, err);
		case 0:
		case -ENOENT:
		case -ESTALE:
			break;
		case -NFS4ERR_BADSESSION:
		case -NFS4ERR_BADSLOT:
		case -NFS4ERR_BAD_HIGH_SLOT:
		case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
		case -NFS4ERR_DEADSESSION:
			set_bit(NFS_DELEGATED_STATE, &state->flags);
			nfs4_schedule_session_recovery(server->nfs_client->cl_session, err);
			return -EAGAIN;
		case -NFS4ERR_STALE_CLIENTID:
		case -NFS4ERR_STALE_STATEID:
			set_bit(NFS_DELEGATED_STATE, &state->flags);
		case -NFS4ERR_EXPIRED:
			/* Don't recall a delegation if it was lost */
			nfs4_schedule_lease_recovery(server->nfs_client);
			return -EAGAIN;
		case -NFS4ERR_DELEG_REVOKED:
		case -NFS4ERR_ADMIN_REVOKED:
		case -NFS4ERR_BAD_STATEID:
1415
		case -NFS4ERR_OPENMODE:
1416 1417 1418
			nfs_inode_find_state_and_recover(state->inode,
					stateid);
			nfs4_schedule_stateid_recovery(server, state);
1419
			return -EAGAIN;
1420 1421 1422 1423 1424
		case -NFS4ERR_DELAY:
		case -NFS4ERR_GRACE:
			set_bit(NFS_DELEGATED_STATE, &state->flags);
			ssleep(1);
			return -EAGAIN;
1425 1426 1427 1428
		case -ENOMEM:
		case -NFS4ERR_DENIED:
			/* kill_proc(fl->fl_pid, SIGLOST, 1); */
			return 0;
1429
	}
Linus Torvalds's avatar
Linus Torvalds committed
1430 1431 1432
	return err;
}

1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448
int nfs4_open_delegation_recall(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
{
	struct nfs_server *server = NFS_SERVER(state->inode);
	struct nfs4_opendata *opendata;
	int err;

	opendata = nfs4_open_recoverdata_alloc(ctx, state,
			NFS4_OPEN_CLAIM_DELEG_CUR_FH);
	if (IS_ERR(opendata))
		return PTR_ERR(opendata);
	nfs4_stateid_copy(&opendata->o_arg.u.delegation, stateid);
	err = nfs4_open_recover(opendata, state);
	nfs4_opendata_put(opendata);
	return nfs4_handle_delegation_recall_error(server, state, stateid, err);
}

1449 1450 1451 1452 1453
static void nfs4_open_confirm_done(struct rpc_task *task, void *calldata)
{
	struct nfs4_opendata *data = calldata;

	data->rpc_status = task->tk_status;
1454
	if (data->rpc_status == 0) {
1455
		nfs4_stateid_copy(&data->o_res.stateid, &data->c_res.stateid);
1456
		nfs_confirm_seqid(&data->owner->so_seqid, 0);
1457
		renew_lease(data->o_res.server, data->timestamp);
1458
		data->rpc_done = 1;
1459
	}
1460 1461 1462 1463 1464 1465 1466 1467 1468 1469 1470
}

static void nfs4_open_confirm_release(void *calldata)
{
	struct nfs4_opendata *data = calldata;
	struct nfs4_state *state = NULL;

	/* If this request hasn't been cancelled, do nothing */
	if (data->cancelled == 0)
		goto out_free;
	/* In case of error, no cleanup! */
1471
	if (!data->rpc_done)
1472 1473
		goto out_free;
	state = nfs4_opendata_to_nfs4_state(data);
1474
	if (!IS_ERR(state))
1475
		nfs4_close_state(state, data->o_arg.fmode);
1476
out_free:
1477
	nfs4_opendata_put(data);
1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488 1489 1490 1491
}

static const struct rpc_call_ops nfs4_open_confirm_ops = {
	.rpc_call_done = nfs4_open_confirm_done,
	.rpc_release = nfs4_open_confirm_release,
};

/*
 * Note: On error, nfs4_proc_open_confirm will free the struct nfs4_opendata
 */
static int _nfs4_proc_open_confirm(struct nfs4_opendata *data)
{
	struct nfs_server *server = NFS_SERVER(data->dir->d_inode);
	struct rpc_task *task;
1492 1493 1494 1495 1496 1497
	struct  rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_CONFIRM],
		.rpc_argp = &data->c_arg,
		.rpc_resp = &data->c_res,
		.rpc_cred = data->owner->so_cred,
	};
1498 1499
	struct rpc_task_setup task_setup_data = {
		.rpc_client = server->client,
1500
		.rpc_message = &msg,
1501 1502
		.callback_ops = &nfs4_open_confirm_ops,
		.callback_data = data,
1503
		.workqueue = nfsiod_workqueue,
1504 1505
		.flags = RPC_TASK_ASYNC,
	};
Linus Torvalds's avatar
Linus Torvalds committed
1506 1507
	int status;

1508
	kref_get(&data->kref);
1509 1510
	data->rpc_done = 0;
	data->rpc_status = 0;
1511
	data->timestamp = jiffies;
1512
	task = rpc_run_task(&task_setup_data);
1513
	if (IS_ERR(task))
1514 1515 1516 1517 1518 1519 1520
		return PTR_ERR(task);
	status = nfs4_wait_for_completion_rpc_task(task);
	if (status != 0) {
		data->cancelled = 1;
		smp_wmb();
	} else
		status = data->rpc_status;
1521
	rpc_put_task(task);
Linus Torvalds's avatar
Linus Torvalds committed
1522 1523 1524
	return status;
}

1525
static void nfs4_open_prepare(struct rpc_task *task, void *calldata)
Linus Torvalds's avatar
Linus Torvalds committed
1526
{
1527 1528
	struct nfs4_opendata *data = calldata;
	struct nfs4_state_owner *sp = data->owner;
1529
	struct nfs_client *clp = sp->so_server->nfs_client;
1530

1531
	if (nfs_wait_on_sequence(data->o_arg.seqid, task) != 0)
1532
		goto out_wait;
1533 1534 1535 1536 1537 1538 1539
	/*
	 * Check if we still need to send an OPEN call, or if we can use
	 * a delegation instead.
	 */
	if (data->state != NULL) {
		struct nfs_delegation *delegation;

1540
		if (can_open_cached(data->state, data->o_arg.fmode, data->o_arg.open_flags))
1541
			goto out_no_action;
1542 1543
		rcu_read_lock();
		delegation = rcu_dereference(NFS_I(data->state->inode)->delegation);
1544
		if (data->o_arg.claim != NFS4_OPEN_CLAIM_DELEGATE_CUR &&
1545
		    data->o_arg.claim != NFS4_OPEN_CLAIM_DELEG_CUR_FH &&
1546 1547
		    can_open_delegated(delegation, data->o_arg.fmode))
			goto unlock_no_action;
1548 1549
		rcu_read_unlock();
	}
1550
	/* Update client id. */
1551
	data->o_arg.clientid = clp->cl_clientid;
1552 1553 1554 1555
	switch (data->o_arg.claim) {
	case NFS4_OPEN_CLAIM_PREVIOUS:
	case NFS4_OPEN_CLAIM_DELEG_CUR_FH:
	case NFS4_OPEN_CLAIM_DELEG_PREV_FH:
1556
		data->o_arg.open_bitmap = &nfs4_open_noattr_bitmap[0];
1557 1558
	case NFS4_OPEN_CLAIM_FH:
		task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_NOATTR];
1559 1560
		nfs_copy_fh(&data->o_res.fh, data->o_arg.fh);
	}
1561
	data->timestamp = jiffies;
1562
	if (nfs4_setup_sequence(data->o_arg.server,
1563
				&data->o_arg.seq_args,
1564 1565 1566
				&data->o_res.seq_res,
				task) != 0)
		nfs_release_seqid(data->o_arg.seqid);
1567 1568 1569 1570 1571 1572 1573 1574 1575 1576

	/* Set the create mode (note dependency on the session type) */
	data->o_arg.createmode = NFS4_CREATE_UNCHECKED;
	if (data->o_arg.open_flags & O_EXCL) {
		data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE;
		if (nfs4_has_persistent_session(clp))
			data->o_arg.createmode = NFS4_CREATE_GUARDED;
		else if (clp->cl_mvops->minor_version > 0)
			data->o_arg.createmode = NFS4_CREATE_EXCLUSIVE4_1;
	}
1577
	return;
1578 1579
unlock_no_action:
	rcu_read_unlock();
1580 1581
out_no_action:
	task->tk_action = NULL;
1582
out_wait:
1583
	nfs4_sequence_done(task, &data->o_res.seq_res);
1584 1585
}

1586 1587 1588
static void nfs4_open_done(struct rpc_task *task, void *calldata)
{
	struct nfs4_opendata *data = calldata;
Linus Torvalds's avatar
Linus Torvalds committed
1589

1590
	data->rpc_status = task->tk_status;
1591

1592 1593
	if (!nfs4_sequence_done(task, &data->o_res.seq_res))
		return;
1594

1595
	if (task->tk_status == 0) {
1596 1597
		if (data->o_res.f_attr->valid & NFS_ATTR_FATTR_TYPE) {
			switch (data->o_res.f_attr->mode & S_IFMT) {
1598 1599 1600
			case S_IFREG:
				break;
			case S_IFLNK:
1601
				data->rpc_status = -ELOOP;
1602 1603
				break;
			case S_IFDIR:
1604
				data->rpc_status = -EISDIR;
1605 1606
				break;
			default:
1607
				data->rpc_status = -ENOTDIR;
1608
			}
1609
		}
1610
		renew_lease(data->o_res.server, data->timestamp);
1611 1612
		if (!(data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM))
			nfs_confirm_seqid(&data->owner->so_seqid, 0);
1613
	}
1614
	data->rpc_done = 1;
1615
}
1616

1617 1618 1619 1620 1621 1622 1623 1624 1625
static void nfs4_open_release(void *calldata)
{
	struct nfs4_opendata *data = calldata;
	struct nfs4_state *state = NULL;

	/* If this request hasn't been cancelled, do nothing */
	if (data->cancelled == 0)
		goto out_free;
	/* In case of error, no cleanup! */
1626
	if (data->rpc_status != 0 || !data->rpc_done)
1627 1628 1629 1630 1631
		goto out_free;
	/* In case we need an open_confirm, no cleanup! */
	if (data->o_res.rflags & NFS4_OPEN_RESULT_CONFIRM)
		goto out_free;
	state = nfs4_opendata_to_nfs4_state(data);
1632
	if (!IS_ERR(state))
1633
		nfs4_close_state(state, data->o_arg.fmode);
1634
out_free:
1635
	nfs4_opendata_put(data);
1636 1637 1638 1639 1640 1641 1642 1643
}

static const struct rpc_call_ops nfs4_open_ops = {
	.rpc_call_prepare = nfs4_open_prepare,
	.rpc_call_done = nfs4_open_done,
	.rpc_release = nfs4_open_release,
};

1644
static int nfs4_run_open_task(struct nfs4_opendata *data, int isrecover)
1645 1646 1647 1648 1649 1650
{
	struct inode *dir = data->dir->d_inode;
	struct nfs_server *server = NFS_SERVER(dir);
	struct nfs_openargs *o_arg = &data->o_arg;
	struct nfs_openres *o_res = &data->o_res;
	struct rpc_task *task;
1651 1652 1653 1654 1655 1656
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN],
		.rpc_argp = o_arg,
		.rpc_resp = o_res,
		.rpc_cred = data->owner->so_cred,
	};
1657 1658
	struct rpc_task_setup task_setup_data = {
		.rpc_client = server->client,
1659
		.rpc_message = &msg,
1660 1661
		.callback_ops = &nfs4_open_ops,
		.callback_data = data,
1662
		.workqueue = nfsiod_workqueue,
1663 1664
		.flags = RPC_TASK_ASYNC,
	};
1665 1666
	int status;

1667
	nfs41_init_sequence(&o_arg->seq_args, &o_res->seq_res, 1);
1668
	kref_get(&data->kref);
1669 1670
	data->rpc_done = 0;
	data->rpc_status = 0;
1671
	data->cancelled = 0;
1672 1673
	data->is_recover = 0;
	if (isrecover) {
1674
		nfs4_set_sequence_privileged(&o_arg->seq_args);
1675 1676
		data->is_recover = 1;
	}
1677
	task = rpc_run_task(&task_setup_data);
1678 1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700
        if (IS_ERR(task))
                return PTR_ERR(task);
        status = nfs4_wait_for_completion_rpc_task(task);
        if (status != 0) {
                data->cancelled = 1;
                smp_wmb();
        } else
                status = data->rpc_status;
        rpc_put_task(task);

	return status;
}

static int _nfs4_recover_proc_open(struct nfs4_opendata *data)
{
	struct inode *dir = data->dir->d_inode;
	struct nfs_openres *o_res = &data->o_res;
        int status;

	status = nfs4_run_open_task(data, 1);
	if (status != 0 || !data->rpc_done)
		return status;

1701 1702
	nfs_fattr_map_and_free_names(NFS_SERVER(dir), &data->f_attr);

1703 1704 1705 1706 1707 1708 1709 1710 1711
	if (o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
		status = _nfs4_proc_open_confirm(data);
		if (status != 0)
			return status;
	}

	return status;
}

1712 1713
static int nfs4_opendata_access(struct rpc_cred *cred,
				struct nfs4_opendata *opendata,
1714 1715
				struct nfs4_state *state, fmode_t fmode,
				int openflags)
1716 1717 1718 1719 1720 1721 1722 1723 1724 1725
{
	struct nfs_access_entry cache;
	u32 mask;

	/* access call failed or for some reason the server doesn't
	 * support any access modes -- defer access call until later */
	if (opendata->o_res.access_supported == 0)
		return 0;

	mask = 0;
1726
	/* don't check MAY_WRITE - a newly created file may not have
1727 1728 1729 1730 1731 1732 1733 1734
	 * write mode bits, but POSIX allows the creating process to write.
	 * use openflags to check for exec, because fmode won't
	 * always have FMODE_EXEC set when file open for exec. */
	if (openflags & __FMODE_EXEC) {
		/* ONLY check for exec rights */
		mask = MAY_EXEC;
	} else if (fmode & FMODE_READ)
		mask = MAY_READ;
1735 1736 1737 1738 1739 1740

	cache.cred = cred;
	cache.jiffies = jiffies;
	nfs_access_set_mask(&cache, opendata->o_res.access_result);
	nfs_access_add_cache(state->inode, &cache);

1741
	if ((mask & ~cache.mask & (MAY_READ | MAY_EXEC)) == 0)
1742 1743 1744 1745
		return 0;

	/* even though OPEN succeeded, access is denied. Close the file */
	nfs4_close_state(state, fmode);
1746
	return -EACCES;
1747 1748
}

1749 1750 1751 1752 1753 1754 1755 1756 1757 1758 1759 1760
/*
 * Note: On error, nfs4_proc_open will free the struct nfs4_opendata
 */
static int _nfs4_proc_open(struct nfs4_opendata *data)
{
	struct inode *dir = data->dir->d_inode;
	struct nfs_server *server = NFS_SERVER(dir);
	struct nfs_openargs *o_arg = &data->o_arg;
	struct nfs_openres *o_res = &data->o_res;
	int status;

	status = nfs4_run_open_task(data, 0);
1761 1762 1763 1764 1765 1766
	if (!data->rpc_done)
		return status;
	if (status != 0) {
		if (status == -NFS4ERR_BADNAME &&
				!(o_arg->open_flags & O_CREAT))
			return -ENOENT;
1767
		return status;
1768
	}
1769

1770 1771
	nfs_fattr_map_and_free_names(server, &data->f_attr);

1772
	if (o_arg->open_flags & O_CREAT)
1773
		update_changeattr(dir, &o_res->cinfo);
1774 1775
	if ((o_res->rflags & NFS4_OPEN_RESULT_LOCKTYPE_POSIX) == 0)
		server->caps &= ~NFS_CAP_POSIX_LOCK;
Linus Torvalds's avatar
Linus Torvalds committed
1776
	if(o_res->rflags & NFS4_OPEN_RESULT_CONFIRM) {
1777
		status = _nfs4_proc_open_confirm(data);
Linus Torvalds's avatar
Linus Torvalds committed
1778
		if (status != 0)
1779
			return status;
Linus Torvalds's avatar
Linus Torvalds committed
1780 1781
	}
	if (!(o_res->f_attr->valid & NFS_ATTR_FATTR))
1782
		_nfs4_proc_getattr(server, &o_res->fh, o_res->f_attr);
1783
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
1784 1785
}

1786 1787 1788 1789 1790
static int nfs4_recover_expired_lease(struct nfs_server *server)
{
	return nfs4_client_recover_expired_lease(server->nfs_client);
}

Linus Torvalds's avatar
Linus Torvalds committed
1791 1792 1793 1794 1795
/*
 * OPEN_EXPIRED:
 * 	reclaim state on the server after a network partition.
 * 	Assumes caller holds the appropriate lock
 */
1796
static int _nfs4_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
Linus Torvalds's avatar
Linus Torvalds committed
1797
{
1798
	struct nfs4_opendata *opendata;
1799
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
1800

1801
	opendata = nfs4_open_recoverdata_alloc(ctx, state,
1802
			NFS4_OPEN_CLAIM_FH);
1803 1804
	if (IS_ERR(opendata))
		return PTR_ERR(opendata);
1805
	ret = nfs4_open_recover(opendata, state);
1806
	if (ret == -ESTALE)
1807
		d_drop(ctx->dentry);
1808
	nfs4_opendata_put(opendata);
1809
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
1810 1811
}

1812
static int nfs4_do_open_expired(struct nfs_open_context *ctx, struct nfs4_state *state)
1813
{
1814
	struct nfs_server *server = NFS_SERVER(state->inode);
1815 1816 1817 1818
	struct nfs4_exception exception = { };
	int err;

	do {
1819
		err = _nfs4_open_expired(ctx, state);
1820 1821
		if (nfs4_clear_cap_atomic_open_v1(server, err, &exception))
			continue;
1822 1823 1824 1825 1826 1827 1828 1829
		switch (err) {
		default:
			goto out;
		case -NFS4ERR_GRACE:
		case -NFS4ERR_DELAY:
			nfs4_handle_exception(server, err, &exception);
			err = 0;
		}
1830
	} while (exception.retry);
1831
out:
1832 1833 1834
	return err;
}

Linus Torvalds's avatar
Linus Torvalds committed
1835 1836 1837
static int nfs4_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
{
	struct nfs_open_context *ctx;
1838
	int ret;
Linus Torvalds's avatar
Linus Torvalds committed
1839

1840 1841
	ctx = nfs4_state_find_open_context(state);
	if (IS_ERR(ctx))
1842
		return -EAGAIN;
1843
	ret = nfs4_do_open_expired(ctx, state);
1844 1845
	put_nfs_open_context(ctx);
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
1846 1847
}

1848 1849 1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867 1868 1869
static void nfs_finish_clear_delegation_stateid(struct nfs4_state *state)
{
	nfs_remove_bad_delegation(state->inode);
	write_seqlock(&state->seqlock);
	nfs4_stateid_copy(&state->stateid, &state->open_stateid);
	write_sequnlock(&state->seqlock);
	clear_bit(NFS_DELEGATED_STATE, &state->flags);
}

static void nfs40_clear_delegation_stateid(struct nfs4_state *state)
{
	if (rcu_access_pointer(NFS_I(state->inode)->delegation) != NULL)
		nfs_finish_clear_delegation_stateid(state);
}

static int nfs40_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
{
	/* NFSv4.0 doesn't allow for delegation recovery on open expire */
	nfs40_clear_delegation_stateid(state);
	return nfs4_open_expired(sp, state);
}

1870
#if defined(CONFIG_NFS_V4_1)
1871
static void nfs41_clear_delegation_stateid(struct nfs4_state *state)
1872 1873
{
	struct nfs_server *server = NFS_SERVER(state->inode);
1874 1875 1876 1877 1878 1879 1880 1881 1882 1883 1884 1885 1886
	nfs4_stateid *stateid = &state->stateid;
	int status;

	/* If a state reset has been done, test_stateid is unneeded */
	if (test_bit(NFS_DELEGATED_STATE, &state->flags) == 0)
		return;

	status = nfs41_test_stateid(server, stateid);
	if (status != NFS_OK) {
		/* Free the stateid unless the server explicitly
		 * informs us the stateid is unrecognized. */
		if (status != -NFS4ERR_BAD_STATEID)
			nfs41_free_stateid(server, stateid);
1887
		nfs_remove_bad_delegation(state->inode);
1888

1889 1890 1891
		write_seqlock(&state->seqlock);
		nfs4_stateid_copy(&state->stateid, &state->open_stateid);
		write_sequnlock(&state->seqlock);
1892 1893 1894 1895 1896 1897 1898 1899 1900 1901 1902 1903 1904 1905 1906
		clear_bit(NFS_DELEGATED_STATE, &state->flags);
	}
}

/**
 * nfs41_check_open_stateid - possibly free an open stateid
 *
 * @state: NFSv4 state for an inode
 *
 * Returns NFS_OK if recovery for this stateid is now finished.
 * Otherwise a negative NFS4ERR value is returned.
 */
static int nfs41_check_open_stateid(struct nfs4_state *state)
{
	struct nfs_server *server = NFS_SERVER(state->inode);
1907
	nfs4_stateid *stateid = &state->open_stateid;
1908 1909 1910 1911 1912 1913 1914 1915 1916 1917 1918 1919 1920 1921 1922 1923 1924 1925
	int status;

	/* If a state reset has been done, test_stateid is unneeded */
	if ((test_bit(NFS_O_RDONLY_STATE, &state->flags) == 0) &&
	    (test_bit(NFS_O_WRONLY_STATE, &state->flags) == 0) &&
	    (test_bit(NFS_O_RDWR_STATE, &state->flags) == 0))
		return -NFS4ERR_BAD_STATEID;

	status = nfs41_test_stateid(server, stateid);
	if (status != NFS_OK) {
		/* Free the stateid unless the server explicitly
		 * informs us the stateid is unrecognized. */
		if (status != -NFS4ERR_BAD_STATEID)
			nfs41_free_stateid(server, stateid);

		clear_bit(NFS_O_RDONLY_STATE, &state->flags);
		clear_bit(NFS_O_WRONLY_STATE, &state->flags);
		clear_bit(NFS_O_RDWR_STATE, &state->flags);
1926
		clear_bit(NFS_OPEN_STATE, &state->flags);
1927 1928 1929 1930 1931 1932
	}
	return status;
}

static int nfs41_open_expired(struct nfs4_state_owner *sp, struct nfs4_state *state)
{
1933
	int status;
1934

1935 1936
	nfs41_clear_delegation_stateid(state);
	status = nfs41_check_open_stateid(state);
1937 1938 1939
	if (status != NFS_OK)
		status = nfs4_open_expired(sp, state);
	return status;
1940 1941 1942
}
#endif

1943 1944 1945 1946 1947 1948 1949 1950 1951 1952 1953 1954 1955 1956 1957 1958
/*
 * on an EXCLUSIVE create, the server should send back a bitmask with FATTR4-*
 * fields corresponding to attributes that were used to store the verifier.
 * Make sure we clobber those fields in the later setattr call
 */
static inline void nfs4_exclusive_attrset(struct nfs4_opendata *opendata, struct iattr *sattr)
{
	if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_ACCESS) &&
	    !(sattr->ia_valid & ATTR_ATIME_SET))
		sattr->ia_valid |= ATTR_ATIME;

	if ((opendata->o_res.attrset[1] & FATTR4_WORD1_TIME_MODIFY) &&
	    !(sattr->ia_valid & ATTR_MTIME_SET))
		sattr->ia_valid |= ATTR_MTIME;
}

1959 1960 1961 1962 1963 1964 1965 1966 1967 1968 1969 1970 1971 1972 1973 1974 1975 1976 1977 1978 1979 1980 1981 1982 1983 1984 1985 1986
static int _nfs4_open_and_get_state(struct nfs4_opendata *opendata,
		fmode_t fmode,
		int flags,
		struct nfs4_state **res)
{
	struct nfs4_state_owner *sp = opendata->owner;
	struct nfs_server *server = sp->so_server;
	struct nfs4_state *state;
	unsigned int seq;
	int ret;

	seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);

	ret = _nfs4_proc_open(opendata);
	if (ret != 0)
		goto out;

	state = nfs4_opendata_to_nfs4_state(opendata);
	ret = PTR_ERR(state);
	if (IS_ERR(state))
		goto out;
	if (server->caps & NFS_CAP_POSIX_LOCK)
		set_bit(NFS_STATE_POSIX_LOCKS, &state->flags);

	ret = nfs4_opendata_access(sp->so_cred, opendata, state, fmode, flags);
	if (ret != 0)
		goto out;

1987
	if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
1988 1989 1990 1991 1992 1993
		nfs4_schedule_stateid_recovery(server, state);
	*res = state;
out:
	return ret;
}

Linus Torvalds's avatar
Linus Torvalds committed
1994
/*
1995
 * Returns a referenced nfs4_state
Linus Torvalds's avatar
Linus Torvalds committed
1996
 */
1997 1998 1999 2000 2001 2002 2003 2004
static int _nfs4_do_open(struct inode *dir,
			struct dentry *dentry,
			fmode_t fmode,
			int flags,
			struct iattr *sattr,
			struct rpc_cred *cred,
			struct nfs4_state **res,
			struct nfs4_threshold **ctx_th)
Linus Torvalds's avatar
Linus Torvalds committed
2005 2006 2007 2008
{
	struct nfs4_state_owner  *sp;
	struct nfs4_state     *state = NULL;
	struct nfs_server       *server = NFS_SERVER(dir);
2009
	struct nfs4_opendata *opendata;
2010
	enum open_claim_type4 claim = NFS4_OPEN_CLAIM_NULL;
2011
	int status;
Linus Torvalds's avatar
Linus Torvalds committed
2012 2013 2014

	/* Protect against reboot recovery conflicts */
	status = -ENOMEM;
2015 2016
	sp = nfs4_get_state_owner(server, cred, GFP_KERNEL);
	if (sp == NULL) {
Linus Torvalds's avatar
Linus Torvalds committed
2017 2018 2019
		dprintk("nfs4_do_open: nfs4_get_state_owner failed!\n");
		goto out_err;
	}
2020 2021
	status = nfs4_recover_expired_lease(server);
	if (status != 0)
2022
		goto err_put_state_owner;
2023 2024
	if (dentry->d_inode != NULL)
		nfs4_return_incompatible_delegation(dentry->d_inode, fmode);
2025
	status = -ENOMEM;
2026 2027
	if (dentry->d_inode)
		claim = NFS4_OPEN_CLAIM_FH;
2028
	opendata = nfs4_opendata_alloc(dentry, sp, fmode, flags, sattr,
2029
			claim, GFP_KERNEL);
2030
	if (opendata == NULL)
2031
		goto err_put_state_owner;
Linus Torvalds's avatar
Linus Torvalds committed
2032

2033 2034 2035 2036
	if (ctx_th && server->attr_bitmask[2] & FATTR4_WORD2_MDSTHRESHOLD) {
		opendata->f_attr.mdsthreshold = pnfs_mdsthreshold_alloc();
		if (!opendata->f_attr.mdsthreshold)
			goto err_opendata_put;
2037
		opendata->o_arg.open_bitmap = &nfs4_pnfs_open_bitmap[0];
2038
	}
2039 2040
	if (dentry->d_inode != NULL)
		opendata->state = nfs4_get_open_state(dentry->d_inode, sp);
2041

2042
	status = _nfs4_open_and_get_state(opendata, fmode, flags, &state);
2043 2044 2045
	if (status != 0)
		goto err_opendata_put;

2046 2047
	if ((opendata->o_arg.open_flags & O_EXCL) &&
	    (opendata->o_arg.createmode != NFS4_CREATE_GUARDED)) {
2048 2049 2050 2051 2052 2053 2054 2055 2056 2057
		nfs4_exclusive_attrset(opendata, sattr);

		nfs_fattr_init(opendata->o_res.f_attr);
		status = nfs4_do_setattr(state->inode, cred,
				opendata->o_res.f_attr, sattr,
				state);
		if (status == 0)
			nfs_setattr_update_inode(state->inode, sattr);
		nfs_post_op_update_inode(state->inode, opendata->o_res.f_attr);
	}
2058 2059 2060 2061 2062 2063 2064

	if (pnfs_use_threshold(ctx_th, opendata->f_attr.mdsthreshold, server))
		*ctx_th = opendata->f_attr.mdsthreshold;
	else
		kfree(opendata->f_attr.mdsthreshold);
	opendata->f_attr.mdsthreshold = NULL;

2065
	nfs4_opendata_put(opendata);
Linus Torvalds's avatar
Linus Torvalds committed
2066 2067 2068
	nfs4_put_state_owner(sp);
	*res = state;
	return 0;
2069
err_opendata_put:
2070
	kfree(opendata->f_attr.mdsthreshold);
2071
	nfs4_opendata_put(opendata);
2072 2073
err_put_state_owner:
	nfs4_put_state_owner(sp);
Linus Torvalds's avatar
Linus Torvalds committed
2074 2075 2076 2077 2078 2079
out_err:
	*res = NULL;
	return status;
}


2080 2081 2082 2083 2084 2085 2086
static struct nfs4_state *nfs4_do_open(struct inode *dir,
					struct dentry *dentry,
					fmode_t fmode,
					int flags,
					struct iattr *sattr,
					struct rpc_cred *cred,
					struct nfs4_threshold **ctx_th)
Linus Torvalds's avatar
Linus Torvalds committed
2087
{
2088
	struct nfs_server *server = NFS_SERVER(dir);
Linus Torvalds's avatar
Linus Torvalds committed
2089 2090 2091 2092
	struct nfs4_exception exception = { };
	struct nfs4_state *res;
	int status;

2093
	fmode &= FMODE_READ|FMODE_WRITE|FMODE_EXEC;
Linus Torvalds's avatar
Linus Torvalds committed
2094
	do {
2095 2096
		status = _nfs4_do_open(dir, dentry, fmode, flags, sattr, cred,
				       &res, ctx_th);
Linus Torvalds's avatar
Linus Torvalds committed
2097 2098 2099 2100 2101 2102 2103 2104
		if (status == 0)
			break;
		/* NOTE: BAD_SEQID means the server and client disagree about the
		 * book-keeping w.r.t. state-changing operations
		 * (OPEN/CLOSE/LOCK/LOCKU...)
		 * It is actually a sign of a bug on the client or on the server.
		 *
		 * If we receive a BAD_SEQID error in the particular case of
2105
		 * doing an OPEN, we assume that nfs_increment_open_seqid() will
Linus Torvalds's avatar
Linus Torvalds committed
2106 2107 2108 2109 2110
		 * have unhashed the old state_owner for us, and that we can
		 * therefore safely retry using a new one. We should still warn
		 * the user though...
		 */
		if (status == -NFS4ERR_BAD_SEQID) {
2111
			pr_warn_ratelimited("NFS: v4 server %s "
2112 2113
					" returned a bad sequence-id error!\n",
					NFS_SERVER(dir)->nfs_client->cl_hostname);
Linus Torvalds's avatar
Linus Torvalds committed
2114 2115 2116
			exception.retry = 1;
			continue;
		}
2117 2118 2119 2120 2121 2122 2123 2124 2125 2126
		/*
		 * BAD_STATEID on OPEN means that the server cancelled our
		 * state before it received the OPEN_CONFIRM.
		 * Recover by retrying the request as per the discussion
		 * on Page 181 of RFC3530.
		 */
		if (status == -NFS4ERR_BAD_STATEID) {
			exception.retry = 1;
			continue;
		}
2127 2128 2129 2130 2131
		if (status == -EAGAIN) {
			/* We must have found a delegation */
			exception.retry = 1;
			continue;
		}
2132 2133 2134
		if (nfs4_clear_cap_atomic_open_v1(server, status, &exception))
			continue;
		res = ERR_PTR(nfs4_handle_exception(server,
Linus Torvalds's avatar
Linus Torvalds committed
2135 2136 2137 2138 2139
					status, &exception));
	} while (exception.retry);
	return res;
}

2140 2141 2142
static int _nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
			    struct nfs_fattr *fattr, struct iattr *sattr,
			    struct nfs4_state *state)
Linus Torvalds's avatar
Linus Torvalds committed
2143
{
2144
	struct nfs_server *server = NFS_SERVER(inode);
Linus Torvalds's avatar
Linus Torvalds committed
2145
        struct nfs_setattrargs  arg = {
2146
                .fh             = NFS_FH(inode),
Linus Torvalds's avatar
Linus Torvalds committed
2147 2148 2149 2150 2151 2152 2153 2154 2155
                .iap            = sattr,
		.server		= server,
		.bitmask = server->attr_bitmask,
        };
        struct nfs_setattrres  res = {
		.fattr		= fattr,
		.server		= server,
        };
        struct rpc_message msg = {
2156 2157 2158 2159
		.rpc_proc	= &nfs4_procedures[NFSPROC4_CLNT_SETATTR],
		.rpc_argp	= &arg,
		.rpc_resp	= &res,
		.rpc_cred	= cred,
Linus Torvalds's avatar
Linus Torvalds committed
2160
        };
2161
	unsigned long timestamp = jiffies;
2162 2163
	fmode_t fmode;
	bool truncate;
2164
	int status;
Linus Torvalds's avatar
Linus Torvalds committed
2165

2166
	nfs_fattr_init(fattr);
Linus Torvalds's avatar
Linus Torvalds committed
2167

2168 2169 2170 2171 2172 2173 2174
	/* Servers should only apply open mode checks for file size changes */
	truncate = (sattr->ia_valid & ATTR_SIZE) ? true : false;
	fmode = truncate ? FMODE_WRITE : FMODE_READ;

	if (nfs4_copy_delegation_stateid(&arg.stateid, inode, fmode)) {
		/* Use that stateid */
	} else if (truncate && state != NULL && nfs4_valid_open_stateid(state)) {
2175 2176 2177 2178
		struct nfs_lockowner lockowner = {
			.l_owner = current->files,
			.l_pid = current->tgid,
		};
2179
		nfs4_select_rw_stateid(&arg.stateid, state, FMODE_WRITE,
2180
				&lockowner);
2181
	} else
2182
		nfs4_stateid_copy(&arg.stateid, &zero_stateid);
Linus Torvalds's avatar
Linus Torvalds committed
2183

2184
	status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
2185 2186
	if (status == 0 && state != NULL)
		renew_lease(server, timestamp);
2187
	return status;
Linus Torvalds's avatar
Linus Torvalds committed
2188 2189
}

2190 2191 2192
static int nfs4_do_setattr(struct inode *inode, struct rpc_cred *cred,
			   struct nfs_fattr *fattr, struct iattr *sattr,
			   struct nfs4_state *state)
Linus Torvalds's avatar
Linus Torvalds committed
2193
{
2194
	struct nfs_server *server = NFS_SERVER(inode);
2195 2196
	struct nfs4_exception exception = {
		.state = state,
2197
		.inode = inode,
2198
	};
Linus Torvalds's avatar
Linus Torvalds committed
2199 2200
	int err;
	do {
2201 2202 2203
		err = _nfs4_do_setattr(inode, cred, fattr, sattr, state);
		switch (err) {
		case -NFS4ERR_OPENMODE:
2204 2205 2206 2207 2208 2209 2210
			if (!(sattr->ia_valid & ATTR_SIZE)) {
				pr_warn_once("NFSv4: server %s is incorrectly "
						"applying open mode checks to "
						"a SETATTR that is not "
						"changing file size.\n",
						server->nfs_client->cl_hostname);
			}
2211 2212 2213 2214 2215 2216 2217 2218
			if (state && !(state->state & FMODE_WRITE)) {
				err = -EBADF;
				if (sattr->ia_valid & ATTR_OPEN)
					err = -EACCES;
				goto out;
			}
		}
		err = nfs4_handle_exception(server, err, &exception);
Linus Torvalds's avatar
Linus Torvalds committed
2219
	} while (exception.retry);
2220
out:
Linus Torvalds's avatar
Linus Torvalds committed
2221 2222 2223 2224 2225 2226 2227 2228
	return err;
}

struct nfs4_closedata {
	struct inode *inode;
	struct nfs4_state *state;
	struct nfs_closeargs arg;
	struct nfs_closeres res;
2229
	struct nfs_fattr fattr;
2230
	unsigned long timestamp;
Fred Isaman's avatar
Fred Isaman committed
2231 2232
	bool roc;
	u32 roc_barrier;
Linus Torvalds's avatar
Linus Torvalds committed
2233 2234
};

2235
static void nfs4_free_closedata(void *data)
2236
{
2237 2238
	struct nfs4_closedata *calldata = data;
	struct nfs4_state_owner *sp = calldata->state->owner;
2239
	struct super_block *sb = calldata->state->inode->i_sb;
2240

Fred Isaman's avatar
Fred Isaman committed
2241 2242
	if (calldata->roc)
		pnfs_roc_release(calldata->state->inode);
2243 2244 2245
	nfs4_put_open_state(calldata->state);
	nfs_free_seqid(calldata->arg.seqid);
	nfs4_put_state_owner(sp);
2246
	nfs_sb_deactive(sb);
2247 2248 2249
	kfree(calldata);
}

2250 2251 2252 2253
static void nfs4_close_clear_stateid_flags(struct nfs4_state *state,
		fmode_t fmode)
{
	spin_lock(&state->owner->so_lock);
2254 2255 2256
	clear_bit(NFS_O_RDWR_STATE, &state->flags);
	switch (fmode & (FMODE_READ|FMODE_WRITE)) {
	case FMODE_WRITE:
2257
		clear_bit(NFS_O_RDONLY_STATE, &state->flags);
2258 2259
		break;
	case FMODE_READ:
2260
		clear_bit(NFS_O_WRONLY_STATE, &state->flags);
2261 2262 2263 2264 2265 2266
		break;
	case 0:
		clear_bit(NFS_O_RDONLY_STATE, &state->flags);
		clear_bit(NFS_O_WRONLY_STATE, &state->flags);
		clear_bit(NFS_OPEN_STATE, &state->flags);
	}
2267 2268 2269
	spin_unlock(&state->owner->so_lock);
}

2270
static void nfs4_close_done(struct rpc_task *task, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
2271
{
2272
	struct nfs4_closedata *calldata = data;
Linus Torvalds's avatar
Linus Torvalds committed
2273 2274 2275
	struct nfs4_state *state = calldata->state;
	struct nfs_server *server = NFS_SERVER(calldata->inode);

2276
	dprintk("%s: begin!\n", __func__);
2277 2278
	if (!nfs4_sequence_done(task, &calldata->res.seq_res))
		return;
Linus Torvalds's avatar
Linus Torvalds committed
2279 2280 2281 2282 2283
        /* hmm. we are done with the inode, and in the process of freeing
	 * the state_owner. we keep this around to process errors
	 */
	switch (task->tk_status) {
		case 0:
Fred Isaman's avatar
Fred Isaman committed
2284 2285 2286
			if (calldata->roc)
				pnfs_roc_set_barrier(state->inode,
						     calldata->roc_barrier);
2287
			nfs_set_open_stateid(state, &calldata->res.stateid, 0);
2288
			renew_lease(server, calldata->timestamp);
2289 2290
			nfs4_close_clear_stateid_flags(state,
					calldata->arg.fmode);
Linus Torvalds's avatar
Linus Torvalds committed
2291 2292
			break;
		case -NFS4ERR_STALE_STATEID:
2293 2294
		case -NFS4ERR_OLD_STATEID:
		case -NFS4ERR_BAD_STATEID:
Linus Torvalds's avatar
Linus Torvalds committed
2295
		case -NFS4ERR_EXPIRED:
2296
			if (calldata->arg.fmode == 0)
2297
				break;
Linus Torvalds's avatar
Linus Torvalds committed
2298
		default:
2299 2300
			if (nfs4_async_handle_error(task, server, state) == -EAGAIN)
				rpc_restart_call_prepare(task);
Linus Torvalds's avatar
Linus Torvalds committed
2301
	}
2302
	nfs_release_seqid(calldata->arg.seqid);
2303
	nfs_refresh_inode(calldata->inode, calldata->res.fattr);
2304
	dprintk("%s: done, ret = %d!\n", __func__, task->tk_status);
Linus Torvalds's avatar
Linus Torvalds committed
2305 2306
}

Trond Myklebust's avatar
Trond Myklebust committed
2307
static void nfs4_close_prepare(struct rpc_task *task, void *data)
Linus Torvalds's avatar
Linus Torvalds committed
2308
{
Trond Myklebust's avatar
Trond Myklebust committed
2309
	struct nfs4_closedata *calldata = data;
2310
	struct nfs4_state *state = calldata->state;
2311
	struct inode *inode = calldata->inode;
2312
	bool is_rdonly, is_wronly, is_rdwr;
2313
	int call_close = 0;
2314

2315
	dprintk("%s: begin!\n", __func__);
2316
	if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
2317
		goto out_wait;
2318

2319
	task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_OPEN_DOWNGRADE];
2320
	spin_lock(&state->owner->so_lock);
2321 2322 2323
	is_rdwr = test_bit(NFS_O_RDWR_STATE, &state->flags);
	is_rdonly = test_bit(NFS_O_RDONLY_STATE, &state->flags);
	is_wronly = test_bit(NFS_O_WRONLY_STATE, &state->flags);
2324
	/* Calculate the change in open mode */
2325
	calldata->arg.fmode = 0;
2326
	if (state->n_rdwr == 0) {
2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340
		if (state->n_rdonly == 0)
			call_close |= is_rdonly;
		else if (is_rdonly)
			calldata->arg.fmode |= FMODE_READ;
		if (state->n_wronly == 0)
			call_close |= is_wronly;
		else if (is_wronly)
			calldata->arg.fmode |= FMODE_WRITE;
	} else if (is_rdwr)
		calldata->arg.fmode |= FMODE_READ|FMODE_WRITE;

	if (calldata->arg.fmode == 0)
		call_close |= is_rdwr;

2341 2342
	if (!nfs4_valid_open_stateid(state))
		call_close = 0;
2343
	spin_unlock(&state->owner->so_lock);
2344 2345

	if (!call_close) {
2346
		/* Note: exit _without_ calling nfs4_close_done */
2347
		goto out_no_action;
2348
	}
2349

Fred Isaman's avatar
Fred Isaman committed
2350
	if (calldata->arg.fmode == 0) {
2351
		task->tk_msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE];
Fred Isaman's avatar
Fred Isaman committed
2352
		if (calldata->roc &&
2353 2354
		    pnfs_roc_drain(inode, &calldata->roc_barrier, task)) {
			nfs_release_seqid(calldata->arg.seqid);
2355
			goto out_wait;
2356
		    }
Fred Isaman's avatar
Fred Isaman committed
2357
	}
2358

2359
	nfs_fattr_init(calldata->res.fattr);
2360
	calldata->timestamp = jiffies;
2361
	if (nfs4_setup_sequence(NFS_SERVER(inode),
2362 2363
				&calldata->arg.seq_args,
				&calldata->res.seq_res,
2364 2365
				task) != 0)
		nfs_release_seqid(calldata->arg.seqid);
2366
	dprintk("%s: done!\n", __func__);
2367 2368 2369 2370 2371
	return;
out_no_action:
	task->tk_action = NULL;
out_wait:
	nfs4_sequence_done(task, &calldata->res.seq_res);
Linus Torvalds's avatar
Linus Torvalds committed
2372 2373
}

2374
static const struct rpc_call_ops nfs4_close_ops = {
Trond Myklebust's avatar
Trond Myklebust committed
2375
	.rpc_call_prepare = nfs4_close_prepare,
2376 2377 2378 2379
	.rpc_call_done = nfs4_close_done,
	.rpc_release = nfs4_free_closedata,
};

Linus Torvalds's avatar
Linus Torvalds committed
2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390
/* 
 * It is possible for data to be read/written from a mem-mapped file 
 * after the sys_close call (which hits the vfs layer as a flush).
 * This means that we can't safely call nfsv4 close on a file until 
 * the inode is cleared. This in turn means that we are not good
 * NFSv4 citizens - we do not indicate to the server to update the file's 
 * share state even when we are done with one of the three share 
 * stateid's in the inode.
 *
 * NOTE: Caller must be holding the sp->so_owner semaphore!
 */
2391
int nfs4_do_close(struct nfs4_state *state, gfp_t gfp_mask, int wait)
Linus Torvalds's avatar
Linus Torvalds committed
2392
{
2393
	struct nfs_server *server = NFS_SERVER(state->inode);
Linus Torvalds's avatar
Linus Torvalds committed
2394
	struct nfs4_closedata *calldata;
2395 2396
	struct nfs4_state_owner *sp = state->owner;
	struct rpc_task *task;
2397 2398 2399 2400
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CLOSE],
		.rpc_cred = state->owner->so_cred,
	};
2401 2402
	struct rpc_task_setup task_setup_data = {
		.rpc_client = server->client,
2403
		.rpc_message = &msg,
2404
		.callback_ops = &nfs4_close_ops,
2405
		.workqueue = nfsiod_workqueue,
2406 2407
		.flags = RPC_TASK_ASYNC,
	};
2408
	int status = -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
2409

2410
	calldata = kzalloc(sizeof(*calldata), gfp_mask);
Linus Torvalds's avatar
Linus Torvalds committed
2411
	if (calldata == NULL)
2412
		goto out;
2413
	nfs41_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 1);
2414
	calldata->inode = state->inode;
Linus Torvalds's avatar
Linus Torvalds committed
2415
	calldata->state = state;
2416
	calldata->arg.fh = NFS_FH(state->inode);
2417
	calldata->arg.stateid = &state->open_stateid;
Linus Torvalds's avatar
Linus Torvalds committed
2418
	/* Serialization for the sequence id */
2419
	calldata->arg.seqid = nfs_alloc_seqid(&state->owner->so_seqid, gfp_mask);
2420 2421
	if (calldata->arg.seqid == NULL)
		goto out_free_calldata;
2422
	calldata->arg.fmode = 0;
2423
	calldata->arg.bitmask = server->cache_consistency_bitmask;
2424
	calldata->res.fattr = &calldata->fattr;
2425
	calldata->res.seqid = calldata->arg.seqid;
2426
	calldata->res.server = server;
2427
	calldata->roc = pnfs_roc(state->inode);
2428
	nfs_sb_active(calldata->inode->i_sb);
2429

2430 2431
	msg.rpc_argp = &calldata->arg;
	msg.rpc_resp = &calldata->res;
2432 2433
	task_setup_data.callback_data = calldata;
	task = rpc_run_task(&task_setup_data);
2434 2435
	if (IS_ERR(task))
		return PTR_ERR(task);
2436 2437 2438
	status = 0;
	if (wait)
		status = rpc_wait_for_completion_task(task);
2439
	rpc_put_task(task);
2440
	return status;
2441 2442 2443
out_free_calldata:
	kfree(calldata);
out:
2444 2445
	nfs4_put_open_state(state);
	nfs4_put_state_owner(sp);
2446
	return status;
Linus Torvalds's avatar
Linus Torvalds committed
2447 2448
}

2449
static struct inode *
2450
nfs4_atomic_open(struct inode *dir, struct nfs_open_context *ctx, int open_flags, struct iattr *attr)
Linus Torvalds's avatar
Linus Torvalds committed
2451 2452 2453
{
	struct nfs4_state *state;

2454
	/* Protect against concurrent sillydeletes */
2455 2456
	state = nfs4_do_open(dir, ctx->dentry, ctx->mode, open_flags, attr,
			     ctx->cred, &ctx->mdsthreshold);
2457 2458
	if (IS_ERR(state))
		return ERR_CAST(state);
2459
	ctx->state = state;
2460
	return igrab(state->inode);
Linus Torvalds's avatar
Linus Torvalds committed
2461 2462
}

2463
static void nfs4_close_context(struct nfs_open_context *ctx, int is_sync)
Trond Myklebust's avatar
Trond Myklebust committed
2464 2465 2466 2467
{
	if (ctx->state == NULL)
		return;
	if (is_sync)
2468
		nfs4_close_sync(ctx->state, ctx->mode);
Trond Myklebust's avatar
Trond Myklebust committed
2469
	else
2470
		nfs4_close_state(ctx->state, ctx->mode);
Trond Myklebust's avatar
Trond Myklebust committed
2471
}
Linus Torvalds's avatar
Linus Torvalds committed
2472 2473 2474

static int _nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
{
2475 2476 2477
	struct nfs4_server_caps_arg args = {
		.fhandle = fhandle,
	};
Linus Torvalds's avatar
Linus Torvalds committed
2478 2479 2480
	struct nfs4_server_caps_res res = {};
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SERVER_CAPS],
2481
		.rpc_argp = &args,
Linus Torvalds's avatar
Linus Torvalds committed
2482 2483 2484 2485
		.rpc_resp = &res,
	};
	int status;

2486
	status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
Linus Torvalds's avatar
Linus Torvalds committed
2487 2488
	if (status == 0) {
		memcpy(server->attr_bitmask, res.attr_bitmask, sizeof(server->attr_bitmask));
2489 2490 2491 2492 2493
		server->caps &= ~(NFS_CAP_ACLS|NFS_CAP_HARDLINKS|
				NFS_CAP_SYMLINKS|NFS_CAP_FILEID|
				NFS_CAP_MODE|NFS_CAP_NLINK|NFS_CAP_OWNER|
				NFS_CAP_OWNER_GROUP|NFS_CAP_ATIME|
				NFS_CAP_CTIME|NFS_CAP_MTIME);
Linus Torvalds's avatar
Linus Torvalds committed
2494 2495 2496 2497 2498 2499
		if (res.attr_bitmask[0] & FATTR4_WORD0_ACL)
			server->caps |= NFS_CAP_ACLS;
		if (res.has_links != 0)
			server->caps |= NFS_CAP_HARDLINKS;
		if (res.has_symlinks != 0)
			server->caps |= NFS_CAP_SYMLINKS;
2500 2501 2502 2503 2504 2505 2506 2507 2508 2509 2510 2511 2512 2513 2514 2515 2516
		if (res.attr_bitmask[0] & FATTR4_WORD0_FILEID)
			server->caps |= NFS_CAP_FILEID;
		if (res.attr_bitmask[1] & FATTR4_WORD1_MODE)
			server->caps |= NFS_CAP_MODE;
		if (res.attr_bitmask[1] & FATTR4_WORD1_NUMLINKS)
			server->caps |= NFS_CAP_NLINK;
		if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER)
			server->caps |= NFS_CAP_OWNER;
		if (res.attr_bitmask[1] & FATTR4_WORD1_OWNER_GROUP)
			server->caps |= NFS_CAP_OWNER_GROUP;
		if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_ACCESS)
			server->caps |= NFS_CAP_ATIME;
		if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_METADATA)
			server->caps |= NFS_CAP_CTIME;
		if (res.attr_bitmask[1] & FATTR4_WORD1_TIME_MODIFY)
			server->caps |= NFS_CAP_MTIME;

2517 2518 2519
		memcpy(server->cache_consistency_bitmask, res.attr_bitmask, sizeof(server->cache_consistency_bitmask));
		server->cache_consistency_bitmask[0] &= FATTR4_WORD0_CHANGE|FATTR4_WORD0_SIZE;
		server->cache_consistency_bitmask[1] &= FATTR4_WORD1_TIME_METADATA|FATTR4_WORD1_TIME_MODIFY;
Linus Torvalds's avatar
Linus Torvalds committed
2520
		server->acl_bitmask = res.acl_bitmask;
2521
		server->fh_expire_type = res.fh_expire_type;
Linus Torvalds's avatar
Linus Torvalds committed
2522
	}
2523

Linus Torvalds's avatar
Linus Torvalds committed
2524 2525 2526
	return status;
}

2527
int nfs4_server_capabilities(struct nfs_server *server, struct nfs_fh *fhandle)
Linus Torvalds's avatar
Linus Torvalds committed
2528 2529 2530 2531 2532 2533 2534 2535 2536 2537 2538 2539 2540 2541 2542 2543 2544 2545 2546
{
	struct nfs4_exception exception = { };
	int err;
	do {
		err = nfs4_handle_exception(server,
				_nfs4_server_capabilities(server, fhandle),
				&exception);
	} while (exception.retry);
	return err;
}

static int _nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
		struct nfs_fsinfo *info)
{
	struct nfs4_lookup_root_arg args = {
		.bitmask = nfs4_fattr_bitmap,
	};
	struct nfs4_lookup_res res = {
		.server = server,
2547
		.fattr = info->fattr,
Linus Torvalds's avatar
Linus Torvalds committed
2548 2549 2550 2551 2552 2553 2554
		.fh = fhandle,
	};
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP_ROOT],
		.rpc_argp = &args,
		.rpc_resp = &res,
	};
2555

2556
	nfs_fattr_init(info->fattr);
2557
	return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
Linus Torvalds's avatar
Linus Torvalds committed
2558 2559 2560 2561 2562 2563 2564 2565
}

static int nfs4_lookup_root(struct nfs_server *server, struct nfs_fh *fhandle,
		struct nfs_fsinfo *info)
{
	struct nfs4_exception exception = { };
	int err;
	do {
2566 2567 2568 2569
		err = _nfs4_lookup_root(server, fhandle, info);
		switch (err) {
		case 0:
		case -NFS4ERR_WRONGSEC:
2570
			goto out;
2571 2572 2573
		default:
			err = nfs4_handle_exception(server, err, &exception);
		}
Linus Torvalds's avatar
Linus Torvalds committed
2574
	} while (exception.retry);
2575
out:
Linus Torvalds's avatar
Linus Torvalds committed
2576 2577 2578
	return err;
}

2579 2580 2581 2582 2583 2584 2585
static int nfs4_lookup_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
				struct nfs_fsinfo *info, rpc_authflavor_t flavor)
{
	struct rpc_auth *auth;
	int ret;

	auth = rpcauth_create(flavor, server->client);
2586
	if (IS_ERR(auth)) {
2587
		ret = -EACCES;
2588 2589 2590 2591 2592 2593 2594
		goto out;
	}
	ret = nfs4_lookup_root(server, fhandle, info);
out:
	return ret;
}

2595 2596 2597 2598 2599 2600 2601 2602 2603
/*
 * Retry pseudoroot lookup with various security flavors.  We do this when:
 *
 *   NFSv4.0: the PUTROOTFH operation returns NFS4ERR_WRONGSEC
 *   NFSv4.1: the server does not support the SECINFO_NO_NAME operation
 *
 * Returns zero on success, or a negative NFS4ERR value, or a
 * negative errno value.
 */
2604
static int nfs4_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
2605
			      struct nfs_fsinfo *info)
Linus Torvalds's avatar
Linus Torvalds committed
2606
{
2607 2608 2609 2610 2611
	/* Per 3530bis 15.33.5 */
	static const rpc_authflavor_t flav_array[] = {
		RPC_AUTH_GSS_KRB5P,
		RPC_AUTH_GSS_KRB5I,
		RPC_AUTH_GSS_KRB5,
2612
		RPC_AUTH_UNIX,			/* courtesy */
2613 2614 2615 2616
		RPC_AUTH_NULL,
	};
	int status = -EPERM;
	size_t i;
2617

2618
	for (i = 0; i < ARRAY_SIZE(flav_array); i++) {
2619
		status = nfs4_lookup_root_sec(server, fhandle, info, flav_array[i]);
2620
		if (status == -NFS4ERR_WRONGSEC || status == -EACCES)
2621 2622
			continue;
		break;
2623
	}
2624

2625 2626 2627 2628 2629 2630 2631 2632 2633
	/*
	 * -EACCESS could mean that the user doesn't have correct permissions
	 * to access the mount.  It could also mean that we tried to mount
	 * with a gss auth flavor, but rpc.gssd isn't running.  Either way,
	 * existing mount programs don't handle -EACCES very well so it should
	 * be mapped to -EPERM instead.
	 */
	if (status == -EACCES)
		status = -EPERM;
2634 2635 2636
	return status;
}

2637 2638 2639 2640 2641 2642 2643 2644 2645 2646 2647 2648 2649 2650
static int nfs4_do_find_root_sec(struct nfs_server *server,
		struct nfs_fh *fhandle, struct nfs_fsinfo *info)
{
	int mv = server->nfs_client->cl_minorversion;
	return nfs_v4_minor_ops[mv]->find_root_sec(server, fhandle, info);
}

/**
 * nfs4_proc_get_rootfh - get file handle for server's pseudoroot
 * @server: initialized nfs_server handle
 * @fhandle: we fill in the pseudo-fs root file handle
 * @info: we fill in an FSINFO struct
 *
 * Returns zero on success, or a negative errno.
2651
 */
2652 2653
int nfs4_proc_get_rootfh(struct nfs_server *server, struct nfs_fh *fhandle,
			 struct nfs_fsinfo *info)
2654
{
2655 2656 2657 2658 2659 2660 2661
	int status;

	status = nfs4_lookup_root(server, fhandle, info);
	if ((status == -NFS4ERR_WRONGSEC) &&
	    !(server->flags & NFS_MOUNT_SECFLAVOUR))
		status = nfs4_do_find_root_sec(server, fhandle, info);

Linus Torvalds's avatar
Linus Torvalds committed
2662 2663 2664 2665
	if (status == 0)
		status = nfs4_server_capabilities(server, fhandle);
	if (status == 0)
		status = nfs4_do_fsinfo(server, fhandle, info);
2666

2667
	return nfs4_map_errors(status);
Linus Torvalds's avatar
Linus Torvalds committed
2668 2669
}

2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680 2681 2682 2683 2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694
static int nfs4_proc_get_root(struct nfs_server *server, struct nfs_fh *mntfh,
			      struct nfs_fsinfo *info)
{
	int error;
	struct nfs_fattr *fattr = info->fattr;

	error = nfs4_server_capabilities(server, mntfh);
	if (error < 0) {
		dprintk("nfs4_get_root: getcaps error = %d\n", -error);
		return error;
	}

	error = nfs4_proc_getattr(server, mntfh, fattr);
	if (error < 0) {
		dprintk("nfs4_get_root: getattr error = %d\n", -error);
		return error;
	}

	if (fattr->valid & NFS_ATTR_FATTR_FSID &&
	    !nfs_fsid_equal(&server->fsid, &fattr->fsid))
		memcpy(&server->fsid, &fattr->fsid, sizeof(server->fsid));

	return error;
}

Manoj Naik's avatar
Manoj Naik committed
2695 2696 2697 2698 2699
/*
 * Get locations and (maybe) other attributes of a referral.
 * Note that we'll actually follow the referral later when
 * we detect fsid mismatch in inode revalidation
 */
2700 2701 2702
static int nfs4_get_referral(struct rpc_clnt *client, struct inode *dir,
			     const struct qstr *name, struct nfs_fattr *fattr,
			     struct nfs_fh *fhandle)
Manoj Naik's avatar
Manoj Naik committed
2703 2704 2705 2706 2707 2708 2709 2710 2711 2712 2713 2714
{
	int status = -ENOMEM;
	struct page *page = NULL;
	struct nfs4_fs_locations *locations = NULL;

	page = alloc_page(GFP_KERNEL);
	if (page == NULL)
		goto out;
	locations = kmalloc(sizeof(struct nfs4_fs_locations), GFP_KERNEL);
	if (locations == NULL)
		goto out;

2715
	status = nfs4_proc_fs_locations(client, dir, name, locations, page);
Manoj Naik's avatar
Manoj Naik committed
2716 2717 2718 2719
	if (status != 0)
		goto out;
	/* Make sure server returned a different fsid for the referral */
	if (nfs_fsid_equal(&NFS_SERVER(dir)->fsid, &locations->fattr.fsid)) {
2720 2721
		dprintk("%s: server did not return a different fsid for"
			" a referral at %s\n", __func__, name->name);
Manoj Naik's avatar
Manoj Naik committed
2722 2723 2724
		status = -EIO;
		goto out;
	}
2725 2726
	/* Fixup attributes for the nfs_lookup() call to nfs_fhget() */
	nfs_fixup_referral_attributes(&locations->fattr);
Manoj Naik's avatar
Manoj Naik committed
2727

2728
	/* replace the lookup nfs_fattr with the locations nfs_fattr */
Manoj Naik's avatar
Manoj Naik committed
2729 2730 2731 2732 2733
	memcpy(fattr, &locations->fattr, sizeof(struct nfs_fattr));
	memset(fhandle, 0, sizeof(struct nfs_fh));
out:
	if (page)
		__free_page(page);
2734
	kfree(locations);
Manoj Naik's avatar
Manoj Naik committed
2735 2736 2737
	return status;
}

Linus Torvalds's avatar
Linus Torvalds committed
2738 2739 2740 2741 2742 2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753
static int _nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
{
	struct nfs4_getattr_arg args = {
		.fh = fhandle,
		.bitmask = server->attr_bitmask,
	};
	struct nfs4_getattr_res res = {
		.fattr = fattr,
		.server = server,
	};
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETATTR],
		.rpc_argp = &args,
		.rpc_resp = &res,
	};
	
2754
	nfs_fattr_init(fattr);
2755
	return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
Linus Torvalds's avatar
Linus Torvalds committed
2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771 2772 2773 2774 2775 2776 2777 2778 2779 2780 2781 2782 2783 2784 2785 2786 2787 2788 2789 2790
}

static int nfs4_proc_getattr(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fattr *fattr)
{
	struct nfs4_exception exception = { };
	int err;
	do {
		err = nfs4_handle_exception(server,
				_nfs4_proc_getattr(server, fhandle, fattr),
				&exception);
	} while (exception.retry);
	return err;
}

/* 
 * The file is not closed if it is opened due to the a request to change
 * the size of the file. The open call will not be needed once the
 * VFS layer lookup-intents are implemented.
 *
 * Close is called when the inode is destroyed.
 * If we haven't opened the file for O_WRONLY, we
 * need to in the size_change case to obtain a stateid.
 *
 * Got race?
 * Because OPEN is always done by name in nfsv4, it is
 * possible that we opened a different file by the same
 * name.  We can recognize this race condition, but we
 * can't do anything about it besides returning an error.
 *
 * This will be fixed with VFS changes (lookup-intent).
 */
static int
nfs4_proc_setattr(struct dentry *dentry, struct nfs_fattr *fattr,
		  struct iattr *sattr)
{
2791
	struct inode *inode = dentry->d_inode;
2792
	struct rpc_cred *cred = NULL;
2793
	struct nfs4_state *state = NULL;
Linus Torvalds's avatar
Linus Torvalds committed
2794 2795
	int status;

Benny Halevy's avatar
Benny Halevy committed
2796
	if (pnfs_ld_layoutret_on_setattr(inode))
2797
		pnfs_commit_and_return_layout(inode);
Benny Halevy's avatar
Benny Halevy committed
2798

2799
	nfs_fattr_init(fattr);
Linus Torvalds's avatar
Linus Torvalds committed
2800
	
2801 2802 2803 2804 2805 2806 2807 2808
	/* Deal with open(O_TRUNC) */
	if (sattr->ia_valid & ATTR_OPEN)
		sattr->ia_valid &= ~(ATTR_MTIME|ATTR_CTIME|ATTR_OPEN);

	/* Optimization: if the end result is no change, don't RPC */
	if ((sattr->ia_valid & ~(ATTR_FILE)) == 0)
		return 0;

2809
	/* Search for an existing open(O_WRITE) file */
2810 2811 2812 2813
	if (sattr->ia_valid & ATTR_FILE) {
		struct nfs_open_context *ctx;

		ctx = nfs_file_open_context(sattr->ia_file);
Neil Brown's avatar
Neil Brown committed
2814 2815 2816 2817
		if (ctx) {
			cred = ctx->cred;
			state = ctx->state;
		}
2818
	}
2819

2820
	status = nfs4_do_setattr(inode, cred, fattr, sattr, state);
2821 2822
	if (status == 0)
		nfs_setattr_update_inode(inode, sattr);
Linus Torvalds's avatar
Linus Torvalds committed
2823 2824 2825
	return status;
}

2826 2827 2828
static int _nfs4_proc_lookup(struct rpc_clnt *clnt, struct inode *dir,
		const struct qstr *name, struct nfs_fh *fhandle,
		struct nfs_fattr *fattr)
2829
{
2830
	struct nfs_server *server = NFS_SERVER(dir);
2831 2832 2833
	int		       status;
	struct nfs4_lookup_arg args = {
		.bitmask = server->attr_bitmask,
2834
		.dir_fh = NFS_FH(dir),
2835 2836 2837 2838 2839 2840 2841 2842 2843 2844 2845 2846 2847 2848 2849
		.name = name,
	};
	struct nfs4_lookup_res res = {
		.server = server,
		.fattr = fattr,
		.fh = fhandle,
	};
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOOKUP],
		.rpc_argp = &args,
		.rpc_resp = &res,
	};

	nfs_fattr_init(fattr);

Linus Torvalds's avatar
Linus Torvalds committed
2850
	dprintk("NFS call  lookup %s\n", name->name);
2851
	status = nfs4_call_sync(clnt, server, &msg, &args.seq_args, &res.seq_res, 0);
Linus Torvalds's avatar
Linus Torvalds committed
2852 2853 2854 2855
	dprintk("NFS reply lookup: %d\n", status);
	return status;
}

2856
static void nfs_fixup_secinfo_attributes(struct nfs_fattr *fattr)
2857 2858
{
	fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
2859
		NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_MOUNTPOINT;
2860 2861 2862 2863
	fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
	fattr->nlink = 2;
}

2864 2865 2866
static int nfs4_proc_lookup_common(struct rpc_clnt **clnt, struct inode *dir,
				   struct qstr *name, struct nfs_fh *fhandle,
				   struct nfs_fattr *fattr)
Linus Torvalds's avatar
Linus Torvalds committed
2867 2868
{
	struct nfs4_exception exception = { };
2869
	struct rpc_clnt *client = *clnt;
Linus Torvalds's avatar
Linus Torvalds committed
2870 2871
	int err;
	do {
2872 2873
		err = _nfs4_proc_lookup(client, dir, name, fhandle, fattr);
		switch (err) {
2874
		case -NFS4ERR_BADNAME:
2875 2876
			err = -ENOENT;
			goto out;
2877
		case -NFS4ERR_MOVED:
2878
			err = nfs4_get_referral(client, dir, name, fattr, fhandle);
2879
			goto out;
2880
		case -NFS4ERR_WRONGSEC:
2881 2882 2883 2884 2885 2886 2887 2888 2889 2890 2891 2892
			err = -EPERM;
			if (client != *clnt)
				goto out;

			client = nfs4_create_sec_client(client, dir, name);
			if (IS_ERR(client))
				return PTR_ERR(client);

			exception.retry = 1;
			break;
		default:
			err = nfs4_handle_exception(NFS_SERVER(dir), err, &exception);
2893
		}
Linus Torvalds's avatar
Linus Torvalds committed
2894
	} while (exception.retry);
2895 2896 2897 2898 2899 2900 2901

out:
	if (err == 0)
		*clnt = client;
	else if (client != *clnt)
		rpc_shutdown_client(client);

Linus Torvalds's avatar
Linus Torvalds committed
2902 2903 2904
	return err;
}

2905
static int nfs4_proc_lookup(struct inode *dir, struct qstr *name,
2906 2907 2908 2909 2910 2911 2912 2913 2914 2915 2916 2917 2918
			    struct nfs_fh *fhandle, struct nfs_fattr *fattr)
{
	int status;
	struct rpc_clnt *client = NFS_CLIENT(dir);

	status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr);
	if (client != NFS_CLIENT(dir)) {
		rpc_shutdown_client(client);
		nfs_fixup_secinfo_attributes(fattr);
	}
	return status;
}

2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933
struct rpc_clnt *
nfs4_proc_lookup_mountpoint(struct inode *dir, struct qstr *name,
			    struct nfs_fh *fhandle, struct nfs_fattr *fattr)
{
	int status;
	struct rpc_clnt *client = rpc_clone_client(NFS_CLIENT(dir));

	status = nfs4_proc_lookup_common(&client, dir, name, fhandle, fattr);
	if (status < 0) {
		rpc_shutdown_client(client);
		return ERR_PTR(status);
	}
	return client;
}

Linus Torvalds's avatar
Linus Torvalds committed
2934 2935
static int _nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
{
2936
	struct nfs_server *server = NFS_SERVER(inode);
Linus Torvalds's avatar
Linus Torvalds committed
2937 2938
	struct nfs4_accessargs args = {
		.fh = NFS_FH(inode),
2939
		.bitmask = server->cache_consistency_bitmask,
2940 2941 2942
	};
	struct nfs4_accessres res = {
		.server = server,
Linus Torvalds's avatar
Linus Torvalds committed
2943 2944 2945 2946 2947 2948 2949 2950 2951 2952 2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963 2964 2965 2966 2967 2968
	};
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_ACCESS],
		.rpc_argp = &args,
		.rpc_resp = &res,
		.rpc_cred = entry->cred,
	};
	int mode = entry->mask;
	int status;

	/*
	 * Determine which access bits we want to ask for...
	 */
	if (mode & MAY_READ)
		args.access |= NFS4_ACCESS_READ;
	if (S_ISDIR(inode->i_mode)) {
		if (mode & MAY_WRITE)
			args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND | NFS4_ACCESS_DELETE;
		if (mode & MAY_EXEC)
			args.access |= NFS4_ACCESS_LOOKUP;
	} else {
		if (mode & MAY_WRITE)
			args.access |= NFS4_ACCESS_MODIFY | NFS4_ACCESS_EXTEND;
		if (mode & MAY_EXEC)
			args.access |= NFS4_ACCESS_EXECUTE;
	}
2969 2970 2971 2972 2973

	res.fattr = nfs_alloc_fattr();
	if (res.fattr == NULL)
		return -ENOMEM;

2974
	status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
Linus Torvalds's avatar
Linus Torvalds committed
2975
	if (!status) {
2976
		nfs_access_set_mask(entry, res.access);
2977
		nfs_refresh_inode(inode, res.fattr);
Linus Torvalds's avatar
Linus Torvalds committed
2978
	}
2979
	nfs_free_fattr(res.fattr);
Linus Torvalds's avatar
Linus Torvalds committed
2980 2981 2982 2983 2984 2985 2986 2987 2988 2989 2990 2991 2992 2993 2994 2995 2996 2997 2998 2999 3000 3001 3002 3003 3004 3005 3006 3007 3008 3009 3010 3011
	return status;
}

static int nfs4_proc_access(struct inode *inode, struct nfs_access_entry *entry)
{
	struct nfs4_exception exception = { };
	int err;
	do {
		err = nfs4_handle_exception(NFS_SERVER(inode),
				_nfs4_proc_access(inode, entry),
				&exception);
	} while (exception.retry);
	return err;
}

/*
 * TODO: For the time being, we don't try to get any attributes
 * along with any of the zero-copy operations READ, READDIR,
 * READLINK, WRITE.
 *
 * In the case of the first three, we want to put the GETATTR
 * after the read-type operation -- this is because it is hard
 * to predict the length of a GETATTR response in v4, and thus
 * align the READ data correctly.  This means that the GETATTR
 * may end up partially falling into the page cache, and we should
 * shift it into the 'tail' of the xdr_buf before processing.
 * To do this efficiently, we need to know the total length
 * of data received, which doesn't seem to be available outside
 * of the RPC layer.
 *
 * In the case of WRITE, we also want to put the GETATTR after
 * the operation -- in this case because we want to make sure
3012
 * we get the post-operation mtime and size.
Linus Torvalds's avatar
Linus Torvalds committed
3013 3014 3015 3016 3017 3018 3019 3020 3021 3022 3023 3024 3025
 *
 * Both of these changes to the XDR layer would in fact be quite
 * minor, but I decided to leave them for a subsequent patch.
 */
static int _nfs4_proc_readlink(struct inode *inode, struct page *page,
		unsigned int pgbase, unsigned int pglen)
{
	struct nfs4_readlink args = {
		.fh       = NFS_FH(inode),
		.pgbase	  = pgbase,
		.pglen    = pglen,
		.pages    = &page,
	};
Benny Halevy's avatar
Benny Halevy committed
3026
	struct nfs4_readlink_res res;
Linus Torvalds's avatar
Linus Torvalds committed
3027 3028 3029
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READLINK],
		.rpc_argp = &args,
Benny Halevy's avatar
Benny Halevy committed
3030
		.rpc_resp = &res,
Linus Torvalds's avatar
Linus Torvalds committed
3031 3032
	};

3033
	return nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode), &msg, &args.seq_args, &res.seq_res, 0);
Linus Torvalds's avatar
Linus Torvalds committed
3034 3035 3036 3037 3038 3039 3040 3041 3042 3043 3044 3045 3046 3047 3048 3049
}

static int nfs4_proc_readlink(struct inode *inode, struct page *page,
		unsigned int pgbase, unsigned int pglen)
{
	struct nfs4_exception exception = { };
	int err;
	do {
		err = nfs4_handle_exception(NFS_SERVER(inode),
				_nfs4_proc_readlink(inode, page, pgbase, pglen),
				&exception);
	} while (exception.retry);
	return err;
}

/*
3050
 * This is just for mknod.  open(O_CREAT) will always do ->open_context().
Linus Torvalds's avatar
Linus Torvalds committed
3051 3052 3053
 */
static int
nfs4_proc_create(struct inode *dir, struct dentry *dentry, struct iattr *sattr,
3054
		 int flags)
Linus Torvalds's avatar
Linus Torvalds committed
3055
{
3056
	struct nfs_open_context *ctx;
Linus Torvalds's avatar
Linus Torvalds committed
3057 3058 3059
	struct nfs4_state *state;
	int status = 0;

3060 3061 3062 3063
	ctx = alloc_nfs_open_context(dentry, FMODE_READ);
	if (IS_ERR(ctx))
		return PTR_ERR(ctx);

3064
	sattr->ia_mode &= ~current_umask();
3065 3066 3067
	state = nfs4_do_open(dir, dentry, ctx->mode,
			flags, sattr, ctx->cred,
			&ctx->mdsthreshold);
3068
	d_drop(dentry);
Linus Torvalds's avatar
Linus Torvalds committed
3069 3070
	if (IS_ERR(state)) {
		status = PTR_ERR(state);
3071
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
3072
	}
3073
	d_add(dentry, igrab(state->inode));
3074
	nfs_set_verifier(dentry, nfs_save_change_attribute(dir));
3075
	ctx->state = state;
Linus Torvalds's avatar
Linus Torvalds committed
3076
out:
3077
	put_nfs_open_context(ctx);
Linus Torvalds's avatar
Linus Torvalds committed
3078 3079 3080 3081 3082
	return status;
}

static int _nfs4_proc_remove(struct inode *dir, struct qstr *name)
{
3083
	struct nfs_server *server = NFS_SERVER(dir);
3084
	struct nfs_removeargs args = {
Linus Torvalds's avatar
Linus Torvalds committed
3085
		.fh = NFS_FH(dir),
3086
		.name = *name,
3087
	};
3088
	struct nfs_removeres res = {
3089
		.server = server,
Linus Torvalds's avatar
Linus Torvalds committed
3090 3091
	};
	struct rpc_message msg = {
3092 3093 3094
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE],
		.rpc_argp = &args,
		.rpc_resp = &res,
Linus Torvalds's avatar
Linus Torvalds committed
3095
	};
3096
	int status;
Linus Torvalds's avatar
Linus Torvalds committed
3097

3098
	status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 1);
3099
	if (status == 0)
3100
		update_changeattr(dir, &res.cinfo);
Linus Torvalds's avatar
Linus Torvalds committed
3101 3102 3103 3104 3105 3106 3107 3108 3109 3110 3111 3112 3113 3114 3115
	return status;
}

static int nfs4_proc_remove(struct inode *dir, struct qstr *name)
{
	struct nfs4_exception exception = { };
	int err;
	do {
		err = nfs4_handle_exception(NFS_SERVER(dir),
				_nfs4_proc_remove(dir, name),
				&exception);
	} while (exception.retry);
	return err;
}

3116
static void nfs4_proc_unlink_setup(struct rpc_message *msg, struct inode *dir)
Linus Torvalds's avatar
Linus Torvalds committed
3117
{
3118 3119 3120
	struct nfs_server *server = NFS_SERVER(dir);
	struct nfs_removeargs *args = msg->rpc_argp;
	struct nfs_removeres *res = msg->rpc_resp;
Linus Torvalds's avatar
Linus Torvalds committed
3121

3122
	res->server = server;
Linus Torvalds's avatar
Linus Torvalds committed
3123
	msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_REMOVE];
3124
	nfs41_init_sequence(&args->seq_args, &res->seq_res, 1);
Linus Torvalds's avatar
Linus Torvalds committed
3125 3126
}

3127 3128
static void nfs4_proc_unlink_rpc_prepare(struct rpc_task *task, struct nfs_unlinkdata *data)
{
3129 3130 3131 3132
	nfs4_setup_sequence(NFS_SERVER(data->dir),
			&data->args.seq_args,
			&data->res.seq_res,
			task);
Linus Torvalds's avatar
Linus Torvalds committed
3133 3134
}

3135
static int nfs4_proc_unlink_done(struct rpc_task *task, struct inode *dir)
Linus Torvalds's avatar
Linus Torvalds committed
3136
{
3137 3138
	struct nfs_removeres *res = task->tk_msg.rpc_resp;

3139 3140
	if (!nfs4_sequence_done(task, &res->seq_res))
		return 0;
3141
	if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN)
3142 3143 3144
		return 0;
	update_changeattr(dir, &res->cinfo);
	return 1;
Linus Torvalds's avatar
Linus Torvalds committed
3145 3146
}

3147 3148 3149 3150 3151 3152 3153 3154
static void nfs4_proc_rename_setup(struct rpc_message *msg, struct inode *dir)
{
	struct nfs_server *server = NFS_SERVER(dir);
	struct nfs_renameargs *arg = msg->rpc_argp;
	struct nfs_renameres *res = msg->rpc_resp;

	msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME];
	res->server = server;
3155
	nfs41_init_sequence(&arg->seq_args, &res->seq_res, 1);
3156 3157
}

3158 3159
static void nfs4_proc_rename_rpc_prepare(struct rpc_task *task, struct nfs_renamedata *data)
{
3160 3161 3162 3163
	nfs4_setup_sequence(NFS_SERVER(data->old_dir),
			&data->args.seq_args,
			&data->res.seq_res,
			task);
3164 3165 3166 3167 3168 3169 3170 3171 3172 3173 3174 3175 3176 3177 3178 3179 3180
}

static int nfs4_proc_rename_done(struct rpc_task *task, struct inode *old_dir,
				 struct inode *new_dir)
{
	struct nfs_renameres *res = task->tk_msg.rpc_resp;

	if (!nfs4_sequence_done(task, &res->seq_res))
		return 0;
	if (nfs4_async_handle_error(task, res->server, NULL) == -EAGAIN)
		return 0;

	update_changeattr(old_dir, &res->old_cinfo);
	update_changeattr(new_dir, &res->new_cinfo);
	return 1;
}

Linus Torvalds's avatar
Linus Torvalds committed
3181 3182 3183
static int _nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
		struct inode *new_dir, struct qstr *new_name)
{
3184
	struct nfs_server *server = NFS_SERVER(old_dir);
3185
	struct nfs_renameargs arg = {
Linus Torvalds's avatar
Linus Torvalds committed
3186 3187 3188 3189
		.old_dir = NFS_FH(old_dir),
		.new_dir = NFS_FH(new_dir),
		.old_name = old_name,
		.new_name = new_name,
3190
	};
3191
	struct nfs_renameres res = {
3192
		.server = server,
Linus Torvalds's avatar
Linus Torvalds committed
3193 3194 3195 3196 3197 3198
	};
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RENAME],
		.rpc_argp = &arg,
		.rpc_resp = &res,
	};
3199
	int status = -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
3200
	
3201
	status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
Linus Torvalds's avatar
Linus Torvalds committed
3202 3203 3204 3205 3206 3207 3208 3209 3210 3211 3212 3213 3214 3215 3216 3217 3218 3219 3220 3221 3222 3223 3224
	if (!status) {
		update_changeattr(old_dir, &res.old_cinfo);
		update_changeattr(new_dir, &res.new_cinfo);
	}
	return status;
}

static int nfs4_proc_rename(struct inode *old_dir, struct qstr *old_name,
		struct inode *new_dir, struct qstr *new_name)
{
	struct nfs4_exception exception = { };
	int err;
	do {
		err = nfs4_handle_exception(NFS_SERVER(old_dir),
				_nfs4_proc_rename(old_dir, old_name,
					new_dir, new_name),
				&exception);
	} while (exception.retry);
	return err;
}

static int _nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
{
3225
	struct nfs_server *server = NFS_SERVER(inode);
Linus Torvalds's avatar
Linus Torvalds committed
3226 3227 3228 3229
	struct nfs4_link_arg arg = {
		.fh     = NFS_FH(inode),
		.dir_fh = NFS_FH(dir),
		.name   = name,
3230 3231 3232 3233
		.bitmask = server->attr_bitmask,
	};
	struct nfs4_link_res res = {
		.server = server,
Linus Torvalds's avatar
Linus Torvalds committed
3234 3235 3236 3237
	};
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LINK],
		.rpc_argp = &arg,
3238
		.rpc_resp = &res,
Linus Torvalds's avatar
Linus Torvalds committed
3239
	};
3240 3241 3242
	int status = -ENOMEM;

	res.fattr = nfs_alloc_fattr();
3243
	if (res.fattr == NULL)
3244
		goto out;
Linus Torvalds's avatar
Linus Torvalds committed
3245

3246
	status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
3247 3248
	if (!status) {
		update_changeattr(dir, &res.cinfo);
3249
		nfs_post_op_update_inode(inode, res.fattr);
3250
	}
3251 3252
out:
	nfs_free_fattr(res.fattr);
Linus Torvalds's avatar
Linus Torvalds committed
3253 3254 3255 3256 3257 3258 3259 3260 3261 3262 3263 3264 3265 3266 3267
	return status;
}

static int nfs4_proc_link(struct inode *inode, struct inode *dir, struct qstr *name)
{
	struct nfs4_exception exception = { };
	int err;
	do {
		err = nfs4_handle_exception(NFS_SERVER(inode),
				_nfs4_proc_link(inode, dir, name),
				&exception);
	} while (exception.retry);
	return err;
}

3268 3269 3270 3271 3272 3273 3274 3275 3276 3277 3278 3279 3280 3281 3282 3283 3284 3285 3286 3287 3288 3289 3290 3291 3292 3293 3294 3295 3296 3297 3298 3299 3300 3301 3302 3303
struct nfs4_createdata {
	struct rpc_message msg;
	struct nfs4_create_arg arg;
	struct nfs4_create_res res;
	struct nfs_fh fh;
	struct nfs_fattr fattr;
};

static struct nfs4_createdata *nfs4_alloc_createdata(struct inode *dir,
		struct qstr *name, struct iattr *sattr, u32 ftype)
{
	struct nfs4_createdata *data;

	data = kzalloc(sizeof(*data), GFP_KERNEL);
	if (data != NULL) {
		struct nfs_server *server = NFS_SERVER(dir);

		data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE];
		data->msg.rpc_argp = &data->arg;
		data->msg.rpc_resp = &data->res;
		data->arg.dir_fh = NFS_FH(dir);
		data->arg.server = server;
		data->arg.name = name;
		data->arg.attrs = sattr;
		data->arg.ftype = ftype;
		data->arg.bitmask = server->attr_bitmask;
		data->res.server = server;
		data->res.fh = &data->fh;
		data->res.fattr = &data->fattr;
		nfs_fattr_init(data->res.fattr);
	}
	return data;
}

static int nfs4_do_create(struct inode *dir, struct dentry *dentry, struct nfs4_createdata *data)
{
3304
	int status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &data->msg,
3305
				    &data->arg.seq_args, &data->res.seq_res, 1);
3306 3307 3308 3309 3310 3311 3312 3313 3314 3315 3316 3317
	if (status == 0) {
		update_changeattr(dir, &data->res.dir_cinfo);
		status = nfs_instantiate(dentry, data->res.fh, data->res.fattr);
	}
	return status;
}

static void nfs4_free_createdata(struct nfs4_createdata *data)
{
	kfree(data);
}

3318
static int _nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
3319
		struct page *page, unsigned int len, struct iattr *sattr)
Linus Torvalds's avatar
Linus Torvalds committed
3320
{
3321 3322
	struct nfs4_createdata *data;
	int status = -ENAMETOOLONG;
Linus Torvalds's avatar
Linus Torvalds committed
3323

3324
	if (len > NFS4_MAXPATHLEN)
3325
		goto out;
3326

3327 3328 3329 3330 3331 3332 3333 3334
	status = -ENOMEM;
	data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4LNK);
	if (data == NULL)
		goto out;

	data->msg.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SYMLINK];
	data->arg.u.symlink.pages = &page;
	data->arg.u.symlink.len = len;
Linus Torvalds's avatar
Linus Torvalds committed
3335
	
3336 3337 3338 3339
	status = nfs4_do_create(dir, dentry, data);

	nfs4_free_createdata(data);
out:
Linus Torvalds's avatar
Linus Torvalds committed
3340 3341 3342
	return status;
}

3343
static int nfs4_proc_symlink(struct inode *dir, struct dentry *dentry,
3344
		struct page *page, unsigned int len, struct iattr *sattr)
Linus Torvalds's avatar
Linus Torvalds committed
3345 3346 3347 3348 3349
{
	struct nfs4_exception exception = { };
	int err;
	do {
		err = nfs4_handle_exception(NFS_SERVER(dir),
3350 3351
				_nfs4_proc_symlink(dir, dentry, page,
							len, sattr),
Linus Torvalds's avatar
Linus Torvalds committed
3352 3353 3354 3355 3356 3357 3358 3359
				&exception);
	} while (exception.retry);
	return err;
}

static int _nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
		struct iattr *sattr)
{
3360 3361
	struct nfs4_createdata *data;
	int status = -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
3362

3363 3364 3365 3366 3367 3368 3369 3370
	data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4DIR);
	if (data == NULL)
		goto out;

	status = nfs4_do_create(dir, dentry, data);

	nfs4_free_createdata(data);
out:
Linus Torvalds's avatar
Linus Torvalds committed
3371 3372 3373 3374 3375 3376 3377 3378
	return status;
}

static int nfs4_proc_mkdir(struct inode *dir, struct dentry *dentry,
		struct iattr *sattr)
{
	struct nfs4_exception exception = { };
	int err;
3379 3380

	sattr->ia_mode &= ~current_umask();
Linus Torvalds's avatar
Linus Torvalds committed
3381 3382 3383 3384 3385 3386 3387 3388 3389
	do {
		err = nfs4_handle_exception(NFS_SERVER(dir),
				_nfs4_proc_mkdir(dir, dentry, sattr),
				&exception);
	} while (exception.retry);
	return err;
}

static int _nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
3390
		u64 cookie, struct page **pages, unsigned int count, int plus)
Linus Torvalds's avatar
Linus Torvalds committed
3391 3392 3393 3394
{
	struct inode		*dir = dentry->d_inode;
	struct nfs4_readdir_arg args = {
		.fh = NFS_FH(dir),
3395
		.pages = pages,
Linus Torvalds's avatar
Linus Torvalds committed
3396 3397
		.pgbase = 0,
		.count = count,
3398
		.bitmask = NFS_SERVER(dentry->d_inode)->attr_bitmask,
Bryan Schumaker's avatar
Bryan Schumaker committed
3399
		.plus = plus,
Linus Torvalds's avatar
Linus Torvalds committed
3400 3401 3402 3403 3404 3405 3406 3407 3408 3409
	};
	struct nfs4_readdir_res res;
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READDIR],
		.rpc_argp = &args,
		.rpc_resp = &res,
		.rpc_cred = cred,
	};
	int			status;

3410
	dprintk("%s: dentry = %s/%s, cookie = %Lu\n", __func__,
3411 3412 3413
			dentry->d_parent->d_name.name,
			dentry->d_name.name,
			(unsigned long long)cookie);
3414
	nfs4_setup_readdir(cookie, NFS_I(dir)->cookieverf, dentry, &args);
Linus Torvalds's avatar
Linus Torvalds committed
3415
	res.pgbase = args.pgbase;
3416
	status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0);
3417
	if (status >= 0) {
3418
		memcpy(NFS_I(dir)->cookieverf, res.verifier.data, NFS4_VERIFIER_SIZE);
3419 3420
		status += args.pgbase;
	}
3421 3422 3423

	nfs_invalidate_atime(dir);

3424
	dprintk("%s: returns %d\n", __func__, status);
Linus Torvalds's avatar
Linus Torvalds committed
3425 3426 3427 3428
	return status;
}

static int nfs4_proc_readdir(struct dentry *dentry, struct rpc_cred *cred,
3429
		u64 cookie, struct page **pages, unsigned int count, int plus)
Linus Torvalds's avatar
Linus Torvalds committed
3430 3431 3432 3433 3434 3435
{
	struct nfs4_exception exception = { };
	int err;
	do {
		err = nfs4_handle_exception(NFS_SERVER(dentry->d_inode),
				_nfs4_proc_readdir(dentry, cred, cookie,
3436
					pages, count, plus),
Linus Torvalds's avatar
Linus Torvalds committed
3437 3438 3439 3440 3441 3442 3443 3444
				&exception);
	} while (exception.retry);
	return err;
}

static int _nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
		struct iattr *sattr, dev_t rdev)
{
3445 3446 3447
	struct nfs4_createdata *data;
	int mode = sattr->ia_mode;
	int status = -ENOMEM;
Linus Torvalds's avatar
Linus Torvalds committed
3448

3449 3450 3451 3452
	data = nfs4_alloc_createdata(dir, &dentry->d_name, sattr, NF4SOCK);
	if (data == NULL)
		goto out;

Linus Torvalds's avatar
Linus Torvalds committed
3453
	if (S_ISFIFO(mode))
3454
		data->arg.ftype = NF4FIFO;
Linus Torvalds's avatar
Linus Torvalds committed
3455
	else if (S_ISBLK(mode)) {
3456 3457 3458
		data->arg.ftype = NF4BLK;
		data->arg.u.device.specdata1 = MAJOR(rdev);
		data->arg.u.device.specdata2 = MINOR(rdev);
Linus Torvalds's avatar
Linus Torvalds committed
3459 3460
	}
	else if (S_ISCHR(mode)) {
3461 3462 3463
		data->arg.ftype = NF4CHR;
		data->arg.u.device.specdata1 = MAJOR(rdev);
		data->arg.u.device.specdata2 = MINOR(rdev);
3464 3465 3466
	} else if (!S_ISSOCK(mode)) {
		status = -EINVAL;
		goto out_free;
Linus Torvalds's avatar
Linus Torvalds committed
3467 3468
	}
	
3469
	status = nfs4_do_create(dir, dentry, data);
3470
out_free:
3471 3472
	nfs4_free_createdata(data);
out:
Linus Torvalds's avatar
Linus Torvalds committed
3473 3474 3475 3476 3477 3478 3479 3480
	return status;
}

static int nfs4_proc_mknod(struct inode *dir, struct dentry *dentry,
		struct iattr *sattr, dev_t rdev)
{
	struct nfs4_exception exception = { };
	int err;
3481 3482

	sattr->ia_mode &= ~current_umask();
Linus Torvalds's avatar
Linus Torvalds committed
3483 3484 3485 3486 3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497
	do {
		err = nfs4_handle_exception(NFS_SERVER(dir),
				_nfs4_proc_mknod(dir, dentry, sattr, rdev),
				&exception);
	} while (exception.retry);
	return err;
}

static int _nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle,
		 struct nfs_fsstat *fsstat)
{
	struct nfs4_statfs_arg args = {
		.fh = fhandle,
		.bitmask = server->attr_bitmask,
	};
Benny Halevy's avatar
Benny Halevy committed
3498 3499 3500
	struct nfs4_statfs_res res = {
		.fsstat = fsstat,
	};
Linus Torvalds's avatar
Linus Torvalds committed
3501 3502 3503
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_STATFS],
		.rpc_argp = &args,
Benny Halevy's avatar
Benny Halevy committed
3504
		.rpc_resp = &res,
Linus Torvalds's avatar
Linus Torvalds committed
3505 3506
	};

3507
	nfs_fattr_init(fsstat->fattr);
3508
	return  nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
Linus Torvalds's avatar
Linus Torvalds committed
3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529
}

static int nfs4_proc_statfs(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsstat *fsstat)
{
	struct nfs4_exception exception = { };
	int err;
	do {
		err = nfs4_handle_exception(server,
				_nfs4_proc_statfs(server, fhandle, fsstat),
				&exception);
	} while (exception.retry);
	return err;
}

static int _nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle,
		struct nfs_fsinfo *fsinfo)
{
	struct nfs4_fsinfo_arg args = {
		.fh = fhandle,
		.bitmask = server->attr_bitmask,
	};
Benny Halevy's avatar
Benny Halevy committed
3530 3531 3532
	struct nfs4_fsinfo_res res = {
		.fsinfo = fsinfo,
	};
Linus Torvalds's avatar
Linus Torvalds committed
3533 3534 3535
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FSINFO],
		.rpc_argp = &args,
Benny Halevy's avatar
Benny Halevy committed
3536
		.rpc_resp = &res,
Linus Torvalds's avatar
Linus Torvalds committed
3537 3538
	};

3539
	return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
Linus Torvalds's avatar
Linus Torvalds committed
3540 3541 3542 3543 3544
}

static int nfs4_do_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
{
	struct nfs4_exception exception = { };
3545
	unsigned long now = jiffies;
Linus Torvalds's avatar
Linus Torvalds committed
3546 3547 3548
	int err;

	do {
3549 3550 3551 3552 3553 3554 3555 3556 3557 3558 3559
		err = _nfs4_do_fsinfo(server, fhandle, fsinfo);
		if (err == 0) {
			struct nfs_client *clp = server->nfs_client;

			spin_lock(&clp->cl_lock);
			clp->cl_lease_time = fsinfo->lease_time * HZ;
			clp->cl_last_renewal = now;
			spin_unlock(&clp->cl_lock);
			break;
		}
		err = nfs4_handle_exception(server, err, &exception);
Linus Torvalds's avatar
Linus Torvalds committed
3560 3561 3562 3563 3564 3565
	} while (exception.retry);
	return err;
}

static int nfs4_proc_fsinfo(struct nfs_server *server, struct nfs_fh *fhandle, struct nfs_fsinfo *fsinfo)
{
3566 3567
	int error;

3568
	nfs_fattr_init(fsinfo->fattr);
3569
	error = nfs4_do_fsinfo(server, fhandle, fsinfo);
3570 3571 3572
	if (error == 0) {
		/* block layout checks this! */
		server->pnfs_blksize = fsinfo->blksize;
3573
		set_pnfs_layoutdriver(server, fhandle, fsinfo->layouttype);
3574
	}
3575 3576

	return error;
Linus Torvalds's avatar
Linus Torvalds committed
3577 3578 3579 3580 3581 3582 3583 3584 3585
}

static int _nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
		struct nfs_pathconf *pathconf)
{
	struct nfs4_pathconf_arg args = {
		.fh = fhandle,
		.bitmask = server->attr_bitmask,
	};
Benny Halevy's avatar
Benny Halevy committed
3586 3587 3588
	struct nfs4_pathconf_res res = {
		.pathconf = pathconf,
	};
Linus Torvalds's avatar
Linus Torvalds committed
3589 3590 3591
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_PATHCONF],
		.rpc_argp = &args,
Benny Halevy's avatar
Benny Halevy committed
3592
		.rpc_resp = &res,
Linus Torvalds's avatar
Linus Torvalds committed
3593 3594 3595 3596 3597 3598 3599 3600
	};

	/* None of the pathconf attributes are mandatory to implement */
	if ((args.bitmask[0] & nfs4_pathconf_bitmap[0]) == 0) {
		memset(pathconf, 0, sizeof(*pathconf));
		return 0;
	}

3601
	nfs_fattr_init(pathconf->fattr);
3602
	return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
Linus Torvalds's avatar
Linus Torvalds committed
3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615 3616 3617 3618
}

static int nfs4_proc_pathconf(struct nfs_server *server, struct nfs_fh *fhandle,
		struct nfs_pathconf *pathconf)
{
	struct nfs4_exception exception = { };
	int err;

	do {
		err = nfs4_handle_exception(server,
				_nfs4_proc_pathconf(server, fhandle, pathconf),
				&exception);
	} while (exception.retry);
	return err;
}

3619
int nfs4_set_rw_stateid(nfs4_stateid *stateid,
3620 3621 3622 3623 3624 3625 3626 3627
		const struct nfs_open_context *ctx,
		const struct nfs_lock_context *l_ctx,
		fmode_t fmode)
{
	const struct nfs_lockowner *lockowner = NULL;

	if (l_ctx != NULL)
		lockowner = &l_ctx->lockowner;
3628
	return nfs4_select_rw_stateid(stateid, ctx->state, fmode, lockowner);
3629 3630 3631
}
EXPORT_SYMBOL_GPL(nfs4_set_rw_stateid);

3632 3633 3634 3635 3636 3637 3638
static bool nfs4_stateid_is_current(nfs4_stateid *stateid,
		const struct nfs_open_context *ctx,
		const struct nfs_lock_context *l_ctx,
		fmode_t fmode)
{
	nfs4_stateid current_stateid;

3639 3640 3641
	/* If the current stateid represents a lost lock, then exit */
	if (nfs4_set_rw_stateid(&current_stateid, ctx, l_ctx, fmode) == -EIO)
		return true;
3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659
	return nfs4_stateid_match(stateid, &current_stateid);
}

static bool nfs4_error_stateid_expired(int err)
{
	switch (err) {
	case -NFS4ERR_DELEG_REVOKED:
	case -NFS4ERR_ADMIN_REVOKED:
	case -NFS4ERR_BAD_STATEID:
	case -NFS4ERR_STALE_STATEID:
	case -NFS4ERR_OLD_STATEID:
	case -NFS4ERR_OPENMODE:
	case -NFS4ERR_EXPIRED:
		return true;
	}
	return false;
}

3660 3661
void __nfs4_read_done_cb(struct nfs_read_data *data)
{
3662
	nfs_invalidate_atime(data->header->inode);
3663 3664
}

3665
static int nfs4_read_done_cb(struct rpc_task *task, struct nfs_read_data *data)
Linus Torvalds's avatar
Linus Torvalds committed
3666
{
3667
	struct nfs_server *server = NFS_SERVER(data->header->inode);
Linus Torvalds's avatar
Linus Torvalds committed
3668

3669
	if (nfs4_async_handle_error(task, server, data->args.context->state) == -EAGAIN) {
3670
		rpc_restart_call_prepare(task);
3671
		return -EAGAIN;
Linus Torvalds's avatar
Linus Torvalds committed
3672
	}
3673

3674
	__nfs4_read_done_cb(data);
Linus Torvalds's avatar
Linus Torvalds committed
3675
	if (task->tk_status > 0)
3676 3677
		renew_lease(server, data->timestamp);
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
3678 3679
}

3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693
static bool nfs4_read_stateid_changed(struct rpc_task *task,
		struct nfs_readargs *args)
{

	if (!nfs4_error_stateid_expired(task->tk_status) ||
		nfs4_stateid_is_current(&args->stateid,
				args->context,
				args->lock_context,
				FMODE_READ))
		return false;
	rpc_restart_call_prepare(task);
	return true;
}

3694 3695 3696 3697 3698 3699 3700
static int nfs4_read_done(struct rpc_task *task, struct nfs_read_data *data)
{

	dprintk("--> %s\n", __func__);

	if (!nfs4_sequence_done(task, &data->res.seq_res))
		return -EAGAIN;
3701 3702
	if (nfs4_read_stateid_changed(task, &data->args))
		return -EAGAIN;
3703 3704
	return data->read_done_cb ? data->read_done_cb(task, data) :
				    nfs4_read_done_cb(task, data);
3705 3706
}

3707
static void nfs4_proc_read_setup(struct nfs_read_data *data, struct rpc_message *msg)
Linus Torvalds's avatar
Linus Torvalds committed
3708 3709
{
	data->timestamp   = jiffies;
3710
	data->read_done_cb = nfs4_read_done_cb;
3711
	msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_READ];
3712
	nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 0);
Linus Torvalds's avatar
Linus Torvalds committed
3713 3714
}

3715 3716
static void nfs4_proc_read_rpc_prepare(struct rpc_task *task, struct nfs_read_data *data)
{
3717
	if (nfs4_setup_sequence(NFS_SERVER(data->header->inode),
3718 3719
			&data->args.seq_args,
			&data->res.seq_res,
3720 3721 3722 3723
			task))
		return;
	nfs4_set_rw_stateid(&data->args.stateid, data->args.context,
			data->args.lock_context, FMODE_READ);
Linus Torvalds's avatar
Linus Torvalds committed
3724 3725
}

3726
static int nfs4_write_done_cb(struct rpc_task *task, struct nfs_write_data *data)
Linus Torvalds's avatar
Linus Torvalds committed
3727
{
3728
	struct inode *inode = data->header->inode;
Linus Torvalds's avatar
Linus Torvalds committed
3729
	
3730
	if (nfs4_async_handle_error(task, NFS_SERVER(inode), data->args.context->state) == -EAGAIN) {
3731
		rpc_restart_call_prepare(task);
3732
		return -EAGAIN;
Linus Torvalds's avatar
Linus Torvalds committed
3733
	}
3734
	if (task->tk_status >= 0) {
Linus Torvalds's avatar
Linus Torvalds committed
3735
		renew_lease(NFS_SERVER(inode), data->timestamp);
3736
		nfs_post_op_update_inode_force_wcc(inode, &data->fattr);
3737
	}
3738
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
3739 3740
}

3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753 3754
static bool nfs4_write_stateid_changed(struct rpc_task *task,
		struct nfs_writeargs *args)
{

	if (!nfs4_error_stateid_expired(task->tk_status) ||
		nfs4_stateid_is_current(&args->stateid,
				args->context,
				args->lock_context,
				FMODE_WRITE))
		return false;
	rpc_restart_call_prepare(task);
	return true;
}

3755 3756 3757 3758
static int nfs4_write_done(struct rpc_task *task, struct nfs_write_data *data)
{
	if (!nfs4_sequence_done(task, &data->res.seq_res))
		return -EAGAIN;
3759 3760
	if (nfs4_write_stateid_changed(task, &data->args))
		return -EAGAIN;
3761 3762
	return data->write_done_cb ? data->write_done_cb(task, data) :
		nfs4_write_done_cb(task, data);
3763 3764
}

3765 3766
static
bool nfs4_write_need_cache_consistency_data(const struct nfs_write_data *data)
3767
{
3768 3769 3770 3771 3772 3773 3774 3775
	const struct nfs_pgio_header *hdr = data->header;

	/* Don't request attributes for pNFS or O_DIRECT writes */
	if (data->ds_clp != NULL || hdr->dreq != NULL)
		return false;
	/* Otherwise, request attributes if and only if we don't hold
	 * a delegation
	 */
3776
	return nfs4_have_delegation(hdr->inode, FMODE_READ) == 0;
3777 3778
}

3779
static void nfs4_proc_write_setup(struct nfs_write_data *data, struct rpc_message *msg)
Linus Torvalds's avatar
Linus Torvalds committed
3780
{
3781
	struct nfs_server *server = NFS_SERVER(data->header->inode);
3782

3783
	if (!nfs4_write_need_cache_consistency_data(data)) {
3784 3785 3786 3787
		data->args.bitmask = NULL;
		data->res.fattr = NULL;
	} else
		data->args.bitmask = server->cache_consistency_bitmask;
3788

3789 3790
	if (!data->write_done_cb)
		data->write_done_cb = nfs4_write_done_cb;
3791
	data->res.server = server;
Linus Torvalds's avatar
Linus Torvalds committed
3792 3793
	data->timestamp   = jiffies;

3794
	msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_WRITE];
3795
	nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
Linus Torvalds's avatar
Linus Torvalds committed
3796 3797
}

3798 3799
static void nfs4_proc_write_rpc_prepare(struct rpc_task *task, struct nfs_write_data *data)
{
3800
	if (nfs4_setup_sequence(NFS_SERVER(data->header->inode),
3801 3802
			&data->args.seq_args,
			&data->res.seq_res,
3803 3804 3805 3806
			task))
		return;
	nfs4_set_rw_stateid(&data->args.stateid, data->args.context,
			data->args.lock_context, FMODE_WRITE);
Linus Torvalds's avatar
Linus Torvalds committed
3807 3808
}

3809
static void nfs4_proc_commit_rpc_prepare(struct rpc_task *task, struct nfs_commit_data *data)
3810
{
3811 3812 3813 3814
	nfs4_setup_sequence(NFS_SERVER(data->inode),
			&data->args.seq_args,
			&data->res.seq_res,
			task);
Linus Torvalds's avatar
Linus Torvalds committed
3815 3816
}

3817
static int nfs4_commit_done_cb(struct rpc_task *task, struct nfs_commit_data *data)
Linus Torvalds's avatar
Linus Torvalds committed
3818 3819
{
	struct inode *inode = data->inode;
3820

3821
	if (nfs4_async_handle_error(task, NFS_SERVER(inode), NULL) == -EAGAIN) {
3822
		rpc_restart_call_prepare(task);
3823
		return -EAGAIN;
Linus Torvalds's avatar
Linus Torvalds committed
3824
	}
3825
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
3826 3827
}

3828
static int nfs4_commit_done(struct rpc_task *task, struct nfs_commit_data *data)
3829 3830 3831
{
	if (!nfs4_sequence_done(task, &data->res.seq_res))
		return -EAGAIN;
3832
	return data->commit_done_cb(task, data);
3833 3834
}

3835
static void nfs4_proc_commit_setup(struct nfs_commit_data *data, struct rpc_message *msg)
Linus Torvalds's avatar
Linus Torvalds committed
3836
{
3837
	struct nfs_server *server = NFS_SERVER(data->inode);
3838

3839 3840
	if (data->commit_done_cb == NULL)
		data->commit_done_cb = nfs4_commit_done_cb;
3841
	data->res.server = server;
3842
	msg->rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_COMMIT];
3843
	nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
Linus Torvalds's avatar
Linus Torvalds committed
3844 3845
}

3846 3847 3848 3849 3850
struct nfs4_renewdata {
	struct nfs_client	*client;
	unsigned long		timestamp;
};

Linus Torvalds's avatar
Linus Torvalds committed
3851 3852 3853 3854
/*
 * nfs4_proc_async_renew(): This is not one of the nfs_rpc_ops; it is a special
 * standalone procedure for queueing an asynchronous RENEW.
 */
3855
static void nfs4_renew_release(void *calldata)
3856
{
3857 3858
	struct nfs4_renewdata *data = calldata;
	struct nfs_client *clp = data->client;
3859

3860 3861 3862
	if (atomic_read(&clp->cl_count) > 1)
		nfs4_schedule_state_renewal(clp);
	nfs_put_client(clp);
3863
	kfree(data);
3864 3865
}

3866
static void nfs4_renew_done(struct rpc_task *task, void *calldata)
Linus Torvalds's avatar
Linus Torvalds committed
3867
{
3868 3869 3870
	struct nfs4_renewdata *data = calldata;
	struct nfs_client *clp = data->client;
	unsigned long timestamp = data->timestamp;
Linus Torvalds's avatar
Linus Torvalds committed
3871 3872

	if (task->tk_status < 0) {
3873
		/* Unless we're shutting down, schedule state recovery! */
3874 3875 3876
		if (test_bit(NFS_CS_RENEWD, &clp->cl_res_state) == 0)
			return;
		if (task->tk_status != NFS4ERR_CB_PATH_DOWN) {
3877
			nfs4_schedule_lease_recovery(clp);
3878 3879 3880
			return;
		}
		nfs4_schedule_path_down_recovery(clp);
Linus Torvalds's avatar
Linus Torvalds committed
3881
	}
3882
	do_renew_lease(clp, timestamp);
Linus Torvalds's avatar
Linus Torvalds committed
3883 3884
}

3885 3886
static const struct rpc_call_ops nfs4_renew_ops = {
	.rpc_call_done = nfs4_renew_done,
3887
	.rpc_release = nfs4_renew_release,
3888 3889
};

3890
static int nfs4_proc_async_renew(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
Linus Torvalds's avatar
Linus Torvalds committed
3891 3892 3893 3894
{
	struct rpc_message msg = {
		.rpc_proc	= &nfs4_procedures[NFSPROC4_CLNT_RENEW],
		.rpc_argp	= clp,
3895
		.rpc_cred	= cred,
Linus Torvalds's avatar
Linus Torvalds committed
3896
	};
3897
	struct nfs4_renewdata *data;
Linus Torvalds's avatar
Linus Torvalds committed
3898

3899 3900
	if (renew_flags == 0)
		return 0;
3901 3902
	if (!atomic_inc_not_zero(&clp->cl_count))
		return -EIO;
3903
	data = kmalloc(sizeof(*data), GFP_NOFS);
3904 3905 3906 3907
	if (data == NULL)
		return -ENOMEM;
	data->client = clp;
	data->timestamp = jiffies;
3908
	return rpc_call_async(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT,
3909
			&nfs4_renew_ops, data);
Linus Torvalds's avatar
Linus Torvalds committed
3910 3911
}

3912
static int nfs4_proc_renew(struct nfs_client *clp, struct rpc_cred *cred)
Linus Torvalds's avatar
Linus Torvalds committed
3913 3914 3915 3916
{
	struct rpc_message msg = {
		.rpc_proc	= &nfs4_procedures[NFSPROC4_CLNT_RENEW],
		.rpc_argp	= clp,
3917
		.rpc_cred	= cred,
Linus Torvalds's avatar
Linus Torvalds committed
3918 3919 3920 3921
	};
	unsigned long now = jiffies;
	int status;

3922
	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
Linus Torvalds's avatar
Linus Torvalds committed
3923 3924
	if (status < 0)
		return status;
3925
	do_renew_lease(clp, now);
Linus Torvalds's avatar
Linus Torvalds committed
3926 3927 3928
	return 0;
}

3929 3930 3931 3932 3933 3934 3935
static inline int nfs4_server_supports_acls(struct nfs_server *server)
{
	return (server->caps & NFS_CAP_ACLS)
		&& (server->acl_bitmask & ACL4_SUPPORT_ALLOW_ACL)
		&& (server->acl_bitmask & ACL4_SUPPORT_DENY_ACL);
}

3936 3937
/* Assuming that XATTR_SIZE_MAX is a multiple of PAGE_SIZE, and that
 * it's OK to put sizeof(void) * (XATTR_SIZE_MAX/PAGE_SIZE) bytes on
3938 3939
 * the stack.
 */
3940
#define NFS4ACL_MAXPAGES DIV_ROUND_UP(XATTR_SIZE_MAX, PAGE_SIZE)
3941

3942 3943 3944 3945 3946 3947 3948 3949 3950
static int buf_to_pages_noslab(const void *buf, size_t buflen,
		struct page **pages, unsigned int *pgbase)
{
	struct page *newpage, **spages;
	int rc = 0;
	size_t len;
	spages = pages;

	do {
3951
		len = min_t(size_t, PAGE_SIZE, buflen);
3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970
		newpage = alloc_page(GFP_KERNEL);

		if (newpage == NULL)
			goto unwind;
		memcpy(page_address(newpage), buf, len);
                buf += len;
                buflen -= len;
		*pages++ = newpage;
		rc++;
	} while (buflen != 0);

	return rc;

unwind:
	for(; rc > 0; rc--)
		__free_page(spages[rc-1]);
	return -ENOMEM;
}

3971 3972 3973
struct nfs4_cached_acl {
	int cached;
	size_t len;
3974
	char data[0];
3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993 3994 3995 3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016
};

static void nfs4_set_cached_acl(struct inode *inode, struct nfs4_cached_acl *acl)
{
	struct nfs_inode *nfsi = NFS_I(inode);

	spin_lock(&inode->i_lock);
	kfree(nfsi->nfs4_acl);
	nfsi->nfs4_acl = acl;
	spin_unlock(&inode->i_lock);
}

static void nfs4_zap_acl_attr(struct inode *inode)
{
	nfs4_set_cached_acl(inode, NULL);
}

static inline ssize_t nfs4_read_cached_acl(struct inode *inode, char *buf, size_t buflen)
{
	struct nfs_inode *nfsi = NFS_I(inode);
	struct nfs4_cached_acl *acl;
	int ret = -ENOENT;

	spin_lock(&inode->i_lock);
	acl = nfsi->nfs4_acl;
	if (acl == NULL)
		goto out;
	if (buf == NULL) /* user is just asking for length */
		goto out_len;
	if (acl->cached == 0)
		goto out;
	ret = -ERANGE; /* see getxattr(2) man page */
	if (acl->len > buflen)
		goto out;
	memcpy(buf, acl->data, acl->len);
out_len:
	ret = acl->len;
out:
	spin_unlock(&inode->i_lock);
	return ret;
}

4017
static void nfs4_write_cached_acl(struct inode *inode, struct page **pages, size_t pgbase, size_t acl_len)
4018 4019
{
	struct nfs4_cached_acl *acl;
4020
	size_t buflen = sizeof(*acl) + acl_len;
4021

4022
	if (buflen <= PAGE_SIZE) {
4023
		acl = kmalloc(buflen, GFP_KERNEL);
4024 4025 4026
		if (acl == NULL)
			goto out;
		acl->cached = 1;
4027
		_copy_from_pages(acl->data, pages, pgbase, acl_len);
4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038
	} else {
		acl = kmalloc(sizeof(*acl), GFP_KERNEL);
		if (acl == NULL)
			goto out;
		acl->cached = 0;
	}
	acl->len = acl_len;
out:
	nfs4_set_cached_acl(inode, acl);
}

4039 4040 4041 4042 4043 4044 4045 4046 4047 4048
/*
 * The getxattr API returns the required buffer length when called with a
 * NULL buf. The NFSv4 acl tool then calls getxattr again after allocating
 * the required buf.  On a NULL buf, we send a page of data to the server
 * guessing that the ACL request can be serviced by a page. If so, we cache
 * up to the page of ACL data, and the 2nd call to getxattr is serviced by
 * the cache. If not so, we throw away the page, and cache the required
 * length. The next getxattr call will then produce another round trip to
 * the server, this time with the input buf of the required size.
 */
4049
static ssize_t __nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
4050
{
4051
	struct page *pages[NFS4ACL_MAXPAGES] = {NULL, };
4052 4053 4054 4055 4056
	struct nfs_getaclargs args = {
		.fh = NFS_FH(inode),
		.acl_pages = pages,
		.acl_len = buflen,
	};
Benny Halevy's avatar
Benny Halevy committed
4057 4058 4059
	struct nfs_getaclres res = {
		.acl_len = buflen,
	};
4060 4061 4062
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETACL],
		.rpc_argp = &args,
Benny Halevy's avatar
Benny Halevy committed
4063
		.rpc_resp = &res,
4064
	};
4065 4066
	unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
	int ret = -ENOMEM, i;
4067

4068 4069 4070 4071
	/* As long as we're doing a round trip to the server anyway,
	 * let's be prepared for a page of acl data. */
	if (npages == 0)
		npages = 1;
4072 4073
	if (npages > ARRAY_SIZE(pages))
		return -ERANGE;
4074

4075 4076 4077 4078
	for (i = 0; i < npages; i++) {
		pages[i] = alloc_page(GFP_KERNEL);
		if (!pages[i])
			goto out_free;
4079
	}
4080 4081 4082 4083 4084 4085

	/* for decoding across pages */
	res.acl_scratch = alloc_page(GFP_KERNEL);
	if (!res.acl_scratch)
		goto out_free;

4086 4087
	args.acl_len = npages * PAGE_SIZE;
	args.acl_pgbase = 0;
4088

4089
	dprintk("%s  buf %p buflen %zu npages %d args.acl_len %zu\n",
4090 4091 4092
		__func__, buf, buflen, npages, args.acl_len);
	ret = nfs4_call_sync(NFS_SERVER(inode)->client, NFS_SERVER(inode),
			     &msg, &args.seq_args, &res.seq_res, 0);
4093 4094
	if (ret)
		goto out_free;
4095

4096 4097 4098 4099 4100
	/* Handle the case where the passed-in buffer is too short */
	if (res.acl_flags & NFS4_ACL_TRUNC) {
		/* Did the user only issue a request for the acl length? */
		if (buf == NULL)
			goto out_ok;
4101
		ret = -ERANGE;
4102
		goto out_free;
4103
	}
4104
	nfs4_write_cached_acl(inode, pages, res.acl_data_offset, res.acl_len);
4105 4106 4107 4108 4109
	if (buf) {
		if (res.acl_len > buflen) {
			ret = -ERANGE;
			goto out_free;
		}
4110
		_copy_from_pages(buf, pages, res.acl_data_offset, res.acl_len);
4111
	}
4112 4113
out_ok:
	ret = res.acl_len;
4114
out_free:
4115 4116 4117
	for (i = 0; i < npages; i++)
		if (pages[i])
			__free_page(pages[i]);
4118 4119
	if (res.acl_scratch)
		__free_page(res.acl_scratch);
4120 4121 4122
	return ret;
}

4123 4124 4125 4126 4127 4128 4129 4130 4131 4132 4133 4134 4135
static ssize_t nfs4_get_acl_uncached(struct inode *inode, void *buf, size_t buflen)
{
	struct nfs4_exception exception = { };
	ssize_t ret;
	do {
		ret = __nfs4_get_acl_uncached(inode, buf, buflen);
		if (ret >= 0)
			break;
		ret = nfs4_handle_exception(NFS_SERVER(inode), ret, &exception);
	} while (exception.retry);
	return ret;
}

4136 4137 4138 4139 4140 4141 4142 4143 4144 4145
static ssize_t nfs4_proc_get_acl(struct inode *inode, void *buf, size_t buflen)
{
	struct nfs_server *server = NFS_SERVER(inode);
	int ret;

	if (!nfs4_server_supports_acls(server))
		return -EOPNOTSUPP;
	ret = nfs_revalidate_inode(server, inode);
	if (ret < 0)
		return ret;
4146 4147
	if (NFS_I(inode)->cache_validity & NFS_INO_INVALID_ACL)
		nfs_zap_acl_cache(inode);
4148 4149
	ret = nfs4_read_cached_acl(inode, buf, buflen);
	if (ret != -ENOENT)
4150 4151
		/* -ENOENT is returned if there is no ACL or if there is an ACL
		 * but no cached acl data, just the acl length */
4152 4153 4154 4155
		return ret;
	return nfs4_get_acl_uncached(inode, buf, buflen);
}

4156
static int __nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
4157 4158 4159 4160 4161 4162 4163 4164
{
	struct nfs_server *server = NFS_SERVER(inode);
	struct page *pages[NFS4ACL_MAXPAGES];
	struct nfs_setaclargs arg = {
		.fh		= NFS_FH(inode),
		.acl_pages	= pages,
		.acl_len	= buflen,
	};
Benny Halevy's avatar
Benny Halevy committed
4165
	struct nfs_setaclres res;
4166 4167 4168
	struct rpc_message msg = {
		.rpc_proc	= &nfs4_procedures[NFSPROC4_CLNT_SETACL],
		.rpc_argp	= &arg,
Benny Halevy's avatar
Benny Halevy committed
4169
		.rpc_resp	= &res,
4170
	};
4171
	unsigned int npages = DIV_ROUND_UP(buflen, PAGE_SIZE);
4172
	int ret, i;
4173 4174 4175

	if (!nfs4_server_supports_acls(server))
		return -EOPNOTSUPP;
4176 4177
	if (npages > ARRAY_SIZE(pages))
		return -ERANGE;
4178 4179 4180
	i = buf_to_pages_noslab(buf, buflen, arg.acl_pages, &arg.acl_pgbase);
	if (i < 0)
		return i;
4181
	nfs4_inode_return_delegation(inode);
4182
	ret = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
4183 4184 4185 4186 4187 4188 4189 4190

	/*
	 * Free each page after tx, so the only ref left is
	 * held by the network stack
	 */
	for (; i > 0; i--)
		put_page(pages[i-1]);

4191 4192 4193 4194 4195 4196 4197
	/*
	 * Acl update can result in inode attribute update.
	 * so mark the attribute cache invalid.
	 */
	spin_lock(&inode->i_lock);
	NFS_I(inode)->cache_validity |= NFS_INO_INVALID_ATTR;
	spin_unlock(&inode->i_lock);
4198 4199
	nfs_access_zap_cache(inode);
	nfs_zap_acl_cache(inode);
4200 4201 4202
	return ret;
}

4203 4204 4205 4206 4207 4208 4209 4210 4211 4212 4213 4214
static int nfs4_proc_set_acl(struct inode *inode, const void *buf, size_t buflen)
{
	struct nfs4_exception exception = { };
	int err;
	do {
		err = nfs4_handle_exception(NFS_SERVER(inode),
				__nfs4_proc_set_acl(inode, buf, buflen),
				&exception);
	} while (exception.retry);
	return err;
}

Linus Torvalds's avatar
Linus Torvalds committed
4215
static int
4216
nfs4_async_handle_error(struct rpc_task *task, const struct nfs_server *server, struct nfs4_state *state)
Linus Torvalds's avatar
Linus Torvalds committed
4217
{
4218 4219 4220
	struct nfs_client *clp = server->nfs_client;

	if (task->tk_status >= 0)
Linus Torvalds's avatar
Linus Torvalds committed
4221 4222
		return 0;
	switch(task->tk_status) {
4223
		case -NFS4ERR_DELEG_REVOKED:
4224 4225
		case -NFS4ERR_ADMIN_REVOKED:
		case -NFS4ERR_BAD_STATEID:
4226 4227 4228
			if (state == NULL)
				break;
			nfs_remove_bad_delegation(state->inode);
4229 4230 4231
		case -NFS4ERR_OPENMODE:
			if (state == NULL)
				break;
4232 4233
			if (nfs4_schedule_stateid_recovery(server, state) < 0)
				goto stateid_invalid;
4234
			goto wait_on_recovery;
4235
		case -NFS4ERR_EXPIRED:
4236 4237 4238 4239
			if (state != NULL) {
				if (nfs4_schedule_stateid_recovery(server, state) < 0)
					goto stateid_invalid;
			}
Linus Torvalds's avatar
Linus Torvalds committed
4240
		case -NFS4ERR_STALE_STATEID:
4241
		case -NFS4ERR_STALE_CLIENTID:
4242 4243
			nfs4_schedule_lease_recovery(clp);
			goto wait_on_recovery;
4244 4245 4246 4247 4248 4249 4250 4251 4252 4253
#if defined(CONFIG_NFS_V4_1)
		case -NFS4ERR_BADSESSION:
		case -NFS4ERR_BADSLOT:
		case -NFS4ERR_BAD_HIGH_SLOT:
		case -NFS4ERR_DEADSESSION:
		case -NFS4ERR_CONN_NOT_BOUND_TO_SESSION:
		case -NFS4ERR_SEQ_FALSE_RETRY:
		case -NFS4ERR_SEQ_MISORDERED:
			dprintk("%s ERROR %d, Reset session\n", __func__,
				task->tk_status);
4254
			nfs4_schedule_session_recovery(clp->cl_session, task->tk_status);
4255
			goto wait_on_recovery;
4256
#endif /* CONFIG_NFS_V4_1 */
Linus Torvalds's avatar
Linus Torvalds committed
4257
		case -NFS4ERR_DELAY:
4258
			nfs_inc_server_stats(server, NFSIOS_DELAY);
4259
		case -NFS4ERR_GRACE:
Linus Torvalds's avatar
Linus Torvalds committed
4260 4261 4262
			rpc_delay(task, NFS4_POLL_RETRY_MAX);
			task->tk_status = 0;
			return -EAGAIN;
4263
		case -NFS4ERR_RETRY_UNCACHED_REP:
Linus Torvalds's avatar
Linus Torvalds committed
4264 4265 4266 4267 4268 4269
		case -NFS4ERR_OLD_STATEID:
			task->tk_status = 0;
			return -EAGAIN;
	}
	task->tk_status = nfs4_map_errors(task->tk_status);
	return 0;
4270 4271 4272
stateid_invalid:
	task->tk_status = -EIO;
	return 0;
4273
wait_on_recovery:
4274 4275 4276 4277 4278
	rpc_sleep_on(&clp->cl_rpcwaitq, task, NULL);
	if (test_bit(NFS4CLNT_MANAGER_RUNNING, &clp->cl_state) == 0)
		rpc_wake_up_queued_task(&clp->cl_rpcwaitq, task);
	task->tk_status = 0;
	return -EAGAIN;
Linus Torvalds's avatar
Linus Torvalds committed
4279 4280
}

4281 4282
static void nfs4_init_boot_verifier(const struct nfs_client *clp,
				    nfs4_verifier *bootverf)
4283 4284 4285
{
	__be32 verf[2];

4286 4287 4288 4289 4290 4291
	if (test_bit(NFS4CLNT_PURGE_STATE, &clp->cl_state)) {
		/* An impossible timestamp guarantees this value
		 * will never match a generated boot time. */
		verf[0] = 0;
		verf[1] = (__be32)(NSEC_PER_SEC + 1);
	} else {
4292 4293 4294
		struct nfs_net *nn = net_generic(clp->cl_net, nfs_net_id);
		verf[0] = (__be32)nn->boot_time.tv_sec;
		verf[1] = (__be32)nn->boot_time.tv_nsec;
4295
	}
4296 4297 4298
	memcpy(bootverf->data, verf, sizeof(bootverf->data));
}

4299 4300 4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319
static unsigned int
nfs4_init_nonuniform_client_string(const struct nfs_client *clp,
				   char *buf, size_t len)
{
	unsigned int result;

	rcu_read_lock();
	result = scnprintf(buf, len, "Linux NFSv4.0 %s/%s %s",
				clp->cl_ipaddr,
				rpc_peeraddr2str(clp->cl_rpcclient,
							RPC_DISPLAY_ADDR),
				rpc_peeraddr2str(clp->cl_rpcclient,
							RPC_DISPLAY_PROTO));
	rcu_read_unlock();
	return result;
}

static unsigned int
nfs4_init_uniform_client_string(const struct nfs_client *clp,
				char *buf, size_t len)
{
4320 4321 4322 4323
	char *nodename = clp->cl_rpcclient->cl_nodename;

	if (nfs4_client_id_uniquifier[0] != '\0')
		nodename = nfs4_client_id_uniquifier;
4324 4325
	return scnprintf(buf, len, "Linux NFSv%u.%u %s",
				clp->rpc_ops->version, clp->cl_minorversion,
4326
				nodename);
4327 4328
}

4329 4330 4331 4332 4333 4334 4335 4336 4337 4338
/**
 * nfs4_proc_setclientid - Negotiate client ID
 * @clp: state data structure
 * @program: RPC program for NFSv4 callback service
 * @port: IP port number for NFS4 callback service
 * @cred: RPC credential to use for this call
 * @res: where to place the result
 *
 * Returns zero, a negative errno, or a negative NFS4ERR status code.
 */
4339 4340 4341
int nfs4_proc_setclientid(struct nfs_client *clp, u32 program,
		unsigned short port, struct rpc_cred *cred,
		struct nfs4_setclientid_res *res)
Linus Torvalds's avatar
Linus Torvalds committed
4342 4343 4344 4345 4346
{
	nfs4_verifier sc_verifier;
	struct nfs4_setclientid setclientid = {
		.sc_verifier = &sc_verifier,
		.sc_prog = program,
4347
		.sc_cb_ident = clp->cl_cb_ident,
Linus Torvalds's avatar
Linus Torvalds committed
4348 4349 4350 4351
	};
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID],
		.rpc_argp = &setclientid,
4352
		.rpc_resp = res,
4353
		.rpc_cred = cred,
Linus Torvalds's avatar
Linus Torvalds committed
4354
	};
4355
	int status;
Linus Torvalds's avatar
Linus Torvalds committed
4356

4357
	/* nfs_client_id4 */
4358
	nfs4_init_boot_verifier(clp, &sc_verifier);
4359 4360 4361 4362 4363 4364 4365 4366 4367 4368
	if (test_bit(NFS_CS_MIGRATION, &clp->cl_flags))
		setclientid.sc_name_len =
				nfs4_init_uniform_client_string(clp,
						setclientid.sc_name,
						sizeof(setclientid.sc_name));
	else
		setclientid.sc_name_len =
				nfs4_init_nonuniform_client_string(clp,
						setclientid.sc_name,
						sizeof(setclientid.sc_name));
4369
	/* cb_client4 */
4370
	rcu_read_lock();
4371
	setclientid.sc_netid_len = scnprintf(setclientid.sc_netid,
4372 4373 4374
				sizeof(setclientid.sc_netid),
				rpc_peeraddr2str(clp->cl_rpcclient,
							RPC_DISPLAY_NETID));
4375 4376
	rcu_read_unlock();
	setclientid.sc_uaddr_len = scnprintf(setclientid.sc_uaddr,
4377
				sizeof(setclientid.sc_uaddr), "%s.%u.%u",
Linus Torvalds's avatar
Linus Torvalds committed
4378 4379
				clp->cl_ipaddr, port >> 8, port & 255);

4380 4381 4382 4383 4384 4385
	dprintk("NFS call  setclientid auth=%s, '%.*s'\n",
		clp->cl_rpcclient->cl_auth->au_ops->au_name,
		setclientid.sc_name_len, setclientid.sc_name);
	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
	dprintk("NFS reply setclientid: %d\n", status);
	return status;
Linus Torvalds's avatar
Linus Torvalds committed
4386 4387
}

4388 4389 4390 4391 4392 4393 4394 4395
/**
 * nfs4_proc_setclientid_confirm - Confirm client ID
 * @clp: state data structure
 * @res: result of a previous SETCLIENTID
 * @cred: RPC credential to use for this call
 *
 * Returns zero, a negative errno, or a negative NFS4ERR status code.
 */
4396
int nfs4_proc_setclientid_confirm(struct nfs_client *clp,
4397 4398
		struct nfs4_setclientid_res *arg,
		struct rpc_cred *cred)
Linus Torvalds's avatar
Linus Torvalds committed
4399 4400 4401
{
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SETCLIENTID_CONFIRM],
4402
		.rpc_argp = arg,
4403
		.rpc_cred = cred,
Linus Torvalds's avatar
Linus Torvalds committed
4404 4405 4406
	};
	int status;

4407 4408 4409
	dprintk("NFS call  setclientid_confirm auth=%s, (client ID %llx)\n",
		clp->cl_rpcclient->cl_auth->au_ops->au_name,
		clp->cl_clientid);
4410
	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
4411
	dprintk("NFS reply setclientid_confirm: %d\n", status);
Linus Torvalds's avatar
Linus Torvalds committed
4412 4413 4414
	return status;
}

4415 4416
struct nfs4_delegreturndata {
	struct nfs4_delegreturnargs args;
4417
	struct nfs4_delegreturnres res;
4418 4419
	struct nfs_fh fh;
	nfs4_stateid stateid;
4420
	unsigned long timestamp;
4421
	struct nfs_fattr fattr;
4422 4423 4424 4425 4426 4427
	int rpc_status;
};

static void nfs4_delegreturn_done(struct rpc_task *task, void *calldata)
{
	struct nfs4_delegreturndata *data = calldata;
4428

4429 4430
	if (!nfs4_sequence_done(task, &data->res.seq_res))
		return;
4431

4432 4433
	switch (task->tk_status) {
	case 0:
4434
		renew_lease(data->res.server, data->timestamp);
4435
		break;
4436 4437 4438 4439 4440 4441 4442 4443
	case -NFS4ERR_ADMIN_REVOKED:
	case -NFS4ERR_DELEG_REVOKED:
	case -NFS4ERR_BAD_STATEID:
	case -NFS4ERR_OLD_STATEID:
	case -NFS4ERR_STALE_STATEID:
	case -NFS4ERR_EXPIRED:
		task->tk_status = 0;
		break;
4444 4445 4446
	default:
		if (nfs4_async_handle_error(task, data->res.server, NULL) ==
				-EAGAIN) {
4447
			rpc_restart_call_prepare(task);
4448 4449 4450 4451
			return;
		}
	}
	data->rpc_status = task->tk_status;
4452 4453 4454 4455 4456 4457 4458
}

static void nfs4_delegreturn_release(void *calldata)
{
	kfree(calldata);
}

4459 4460 4461 4462 4463 4464 4465
#if defined(CONFIG_NFS_V4_1)
static void nfs4_delegreturn_prepare(struct rpc_task *task, void *data)
{
	struct nfs4_delegreturndata *d_data;

	d_data = (struct nfs4_delegreturndata *)data;

4466 4467 4468 4469
	nfs4_setup_sequence(d_data->res.server,
			&d_data->args.seq_args,
			&d_data->res.seq_res,
			task);
4470 4471 4472
}
#endif /* CONFIG_NFS_V4_1 */

4473
static const struct rpc_call_ops nfs4_delegreturn_ops = {
4474 4475 4476
#if defined(CONFIG_NFS_V4_1)
	.rpc_call_prepare = nfs4_delegreturn_prepare,
#endif /* CONFIG_NFS_V4_1 */
4477 4478 4479 4480
	.rpc_call_done = nfs4_delegreturn_done,
	.rpc_release = nfs4_delegreturn_release,
};

4481
static int _nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
4482 4483
{
	struct nfs4_delegreturndata *data;
4484
	struct nfs_server *server = NFS_SERVER(inode);
4485
	struct rpc_task *task;
4486 4487 4488 4489
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DELEGRETURN],
		.rpc_cred = cred,
	};
4490 4491
	struct rpc_task_setup task_setup_data = {
		.rpc_client = server->client,
4492
		.rpc_message = &msg,
4493 4494 4495
		.callback_ops = &nfs4_delegreturn_ops,
		.flags = RPC_TASK_ASYNC,
	};
4496
	int status = 0;
4497

4498
	data = kzalloc(sizeof(*data), GFP_NOFS);
4499 4500
	if (data == NULL)
		return -ENOMEM;
4501
	nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
4502 4503
	data->args.fhandle = &data->fh;
	data->args.stateid = &data->stateid;
4504
	data->args.bitmask = server->cache_consistency_bitmask;
4505
	nfs_copy_fh(&data->fh, NFS_FH(inode));
4506
	nfs4_stateid_copy(&data->stateid, stateid);
4507 4508
	data->res.fattr = &data->fattr;
	data->res.server = server;
4509
	nfs_fattr_init(data->res.fattr);
4510
	data->timestamp = jiffies;
4511 4512
	data->rpc_status = 0;

4513
	task_setup_data.callback_data = data;
4514 4515
	msg.rpc_argp = &data->args;
	msg.rpc_resp = &data->res;
4516
	task = rpc_run_task(&task_setup_data);
4517
	if (IS_ERR(task))
4518
		return PTR_ERR(task);
4519 4520
	if (!issync)
		goto out;
4521
	status = nfs4_wait_for_completion_rpc_task(task);
4522 4523 4524
	if (status != 0)
		goto out;
	status = data->rpc_status;
4525 4526 4527 4528
	if (status == 0)
		nfs_post_op_update_inode_force_wcc(inode, &data->fattr);
	else
		nfs_refresh_inode(inode, &data->fattr);
4529
out:
4530
	rpc_put_task(task);
4531
	return status;
Linus Torvalds's avatar
Linus Torvalds committed
4532 4533
}

4534
int nfs4_proc_delegreturn(struct inode *inode, struct rpc_cred *cred, const nfs4_stateid *stateid, int issync)
Linus Torvalds's avatar
Linus Torvalds committed
4535 4536 4537 4538 4539
{
	struct nfs_server *server = NFS_SERVER(inode);
	struct nfs4_exception exception = { };
	int err;
	do {
4540
		err = _nfs4_proc_delegreturn(inode, cred, stateid, issync);
Linus Torvalds's avatar
Linus Torvalds committed
4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558 4559 4560
		switch (err) {
			case -NFS4ERR_STALE_STATEID:
			case -NFS4ERR_EXPIRED:
			case 0:
				return 0;
		}
		err = nfs4_handle_exception(server, err, &exception);
	} while (exception.retry);
	return err;
}

#define NFS4_LOCK_MINTIMEOUT (1 * HZ)
#define NFS4_LOCK_MAXTIMEOUT (30 * HZ)

/* 
 * sleep, with exponential backoff, and retry the LOCK operation. 
 */
static unsigned long
nfs4_set_lock_task_retry(unsigned long timeout)
{
4561
	freezable_schedule_timeout_killable(timeout);
Linus Torvalds's avatar
Linus Torvalds committed
4562 4563 4564 4565 4566 4567 4568 4569 4570 4571
	timeout <<= 1;
	if (timeout > NFS4_LOCK_MAXTIMEOUT)
		return NFS4_LOCK_MAXTIMEOUT;
	return timeout;
}

static int _nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
{
	struct inode *inode = state->inode;
	struct nfs_server *server = NFS_SERVER(inode);
4572
	struct nfs_client *clp = server->nfs_client;
Trond Myklebust's avatar
Trond Myklebust committed
4573
	struct nfs_lockt_args arg = {
Linus Torvalds's avatar
Linus Torvalds committed
4574
		.fh = NFS_FH(inode),
Trond Myklebust's avatar
Trond Myklebust committed
4575
		.fl = request,
Linus Torvalds's avatar
Linus Torvalds committed
4576
	};
Trond Myklebust's avatar
Trond Myklebust committed
4577 4578
	struct nfs_lockt_res res = {
		.denied = request,
Linus Torvalds's avatar
Linus Torvalds committed
4579 4580 4581 4582 4583 4584 4585 4586 4587 4588
	};
	struct rpc_message msg = {
		.rpc_proc	= &nfs4_procedures[NFSPROC4_CLNT_LOCKT],
		.rpc_argp       = &arg,
		.rpc_resp       = &res,
		.rpc_cred	= state->owner->so_cred,
	};
	struct nfs4_lock_state *lsp;
	int status;

Trond Myklebust's avatar
Trond Myklebust committed
4589
	arg.lock_owner.clientid = clp->cl_clientid;
4590 4591 4592 4593
	status = nfs4_set_lock_state(state, request);
	if (status != 0)
		goto out;
	lsp = request->fl_u.nfs4_fl.owner;
4594
	arg.lock_owner.id = lsp->ls_seqid.owner_id;
4595
	arg.lock_owner.s_dev = server->s_dev;
4596
	status = nfs4_call_sync(server->client, server, &msg, &arg.seq_args, &res.seq_res, 1);
Trond Myklebust's avatar
Trond Myklebust committed
4597 4598 4599 4600 4601 4602
	switch (status) {
		case 0:
			request->fl_type = F_UNLCK;
			break;
		case -NFS4ERR_DENIED:
			status = 0;
Linus Torvalds's avatar
Linus Torvalds committed
4603
	}
4604
	request->fl_ops->fl_release_private(request);
4605
	request->fl_ops = NULL;
4606
out:
Linus Torvalds's avatar
Linus Torvalds committed
4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618 4619 4620 4621 4622 4623 4624 4625 4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636 4637 4638
	return status;
}

static int nfs4_proc_getlk(struct nfs4_state *state, int cmd, struct file_lock *request)
{
	struct nfs4_exception exception = { };
	int err;

	do {
		err = nfs4_handle_exception(NFS_SERVER(state->inode),
				_nfs4_proc_getlk(state, cmd, request),
				&exception);
	} while (exception.retry);
	return err;
}

static int do_vfs_lock(struct file *file, struct file_lock *fl)
{
	int res = 0;
	switch (fl->fl_flags & (FL_POSIX|FL_FLOCK)) {
		case FL_POSIX:
			res = posix_lock_file_wait(file, fl);
			break;
		case FL_FLOCK:
			res = flock_lock_file_wait(file, fl);
			break;
		default:
			BUG();
	}
	return res;
}

4639
struct nfs4_unlockdata {
Trond Myklebust's avatar
Trond Myklebust committed
4640 4641
	struct nfs_locku_args arg;
	struct nfs_locku_res res;
4642 4643
	struct nfs4_lock_state *lsp;
	struct nfs_open_context *ctx;
Trond Myklebust's avatar
Trond Myklebust committed
4644 4645
	struct file_lock fl;
	const struct nfs_server *server;
4646
	unsigned long timestamp;
4647 4648
};

Trond Myklebust's avatar
Trond Myklebust committed
4649 4650 4651 4652 4653 4654 4655 4656
static struct nfs4_unlockdata *nfs4_alloc_unlockdata(struct file_lock *fl,
		struct nfs_open_context *ctx,
		struct nfs4_lock_state *lsp,
		struct nfs_seqid *seqid)
{
	struct nfs4_unlockdata *p;
	struct inode *inode = lsp->ls_state->inode;

4657
	p = kzalloc(sizeof(*p), GFP_NOFS);
Trond Myklebust's avatar
Trond Myklebust committed
4658 4659 4660 4661 4662
	if (p == NULL)
		return NULL;
	p->arg.fh = NFS_FH(inode);
	p->arg.fl = &p->fl;
	p->arg.seqid = seqid;
4663
	p->res.seqid = seqid;
Trond Myklebust's avatar
Trond Myklebust committed
4664 4665 4666 4667 4668 4669 4670 4671 4672 4673
	p->arg.stateid = &lsp->ls_stateid;
	p->lsp = lsp;
	atomic_inc(&lsp->ls_count);
	/* Ensure we don't close file until we're done freeing locks! */
	p->ctx = get_nfs_open_context(ctx);
	memcpy(&p->fl, fl, sizeof(p->fl));
	p->server = NFS_SERVER(inode);
	return p;
}

4674
static void nfs4_locku_release_calldata(void *data)
4675
{
4676
	struct nfs4_unlockdata *calldata = data;
Trond Myklebust's avatar
Trond Myklebust committed
4677
	nfs_free_seqid(calldata->arg.seqid);
4678 4679 4680
	nfs4_put_lock_state(calldata->lsp);
	put_nfs_open_context(calldata->ctx);
	kfree(calldata);
4681 4682
}

4683
static void nfs4_locku_done(struct rpc_task *task, void *data)
4684
{
4685
	struct nfs4_unlockdata *calldata = data;
4686

4687 4688
	if (!nfs4_sequence_done(task, &calldata->res.seq_res))
		return;
4689 4690
	switch (task->tk_status) {
		case 0:
4691 4692
			nfs4_stateid_copy(&calldata->lsp->ls_stateid,
					&calldata->res.stateid);
4693
			renew_lease(calldata->server, calldata->timestamp);
4694
			break;
4695 4696
		case -NFS4ERR_BAD_STATEID:
		case -NFS4ERR_OLD_STATEID:
4697 4698 4699 4700
		case -NFS4ERR_STALE_STATEID:
		case -NFS4ERR_EXPIRED:
			break;
		default:
4701
			if (nfs4_async_handle_error(task, calldata->server, NULL) == -EAGAIN)
4702
				rpc_restart_call_prepare(task);
4703
	}
4704
	nfs_release_seqid(calldata->arg.seqid);
4705 4706
}

Trond Myklebust's avatar
Trond Myklebust committed
4707
static void nfs4_locku_prepare(struct rpc_task *task, void *data)
4708
{
Trond Myklebust's avatar
Trond Myklebust committed
4709
	struct nfs4_unlockdata *calldata = data;
4710

Trond Myklebust's avatar
Trond Myklebust committed
4711
	if (nfs_wait_on_sequence(calldata->arg.seqid, task) != 0)
4712
		goto out_wait;
4713
	if (test_bit(NFS_LOCK_INITIALIZED, &calldata->lsp->ls_flags) == 0) {
4714
		/* Note: exit _without_ running nfs4_locku_done */
4715
		goto out_no_action;
4716
	}
4717
	calldata->timestamp = jiffies;
4718
	if (nfs4_setup_sequence(calldata->server,
4719
				&calldata->arg.seq_args,
4720 4721 4722
				&calldata->res.seq_res,
				task) != 0)
		nfs_release_seqid(calldata->arg.seqid);
4723 4724 4725 4726 4727
	return;
out_no_action:
	task->tk_action = NULL;
out_wait:
	nfs4_sequence_done(task, &calldata->res.seq_res);
4728 4729
}

4730
static const struct rpc_call_ops nfs4_locku_ops = {
Trond Myklebust's avatar
Trond Myklebust committed
4731
	.rpc_call_prepare = nfs4_locku_prepare,
4732
	.rpc_call_done = nfs4_locku_done,
4733
	.rpc_release = nfs4_locku_release_calldata,
4734 4735
};

4736 4737 4738 4739 4740 4741
static struct rpc_task *nfs4_do_unlck(struct file_lock *fl,
		struct nfs_open_context *ctx,
		struct nfs4_lock_state *lsp,
		struct nfs_seqid *seqid)
{
	struct nfs4_unlockdata *data;
4742 4743 4744 4745
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCKU],
		.rpc_cred = ctx->cred,
	};
4746 4747
	struct rpc_task_setup task_setup_data = {
		.rpc_client = NFS_CLIENT(lsp->ls_state->inode),
4748
		.rpc_message = &msg,
4749
		.callback_ops = &nfs4_locku_ops,
4750
		.workqueue = nfsiod_workqueue,
4751 4752
		.flags = RPC_TASK_ASYNC,
	};
4753

4754 4755 4756 4757 4758
	/* Ensure this is an unlock - when canceling a lock, the
	 * canceled lock is passed in, and it won't be an unlock.
	 */
	fl->fl_type = F_UNLCK;

4759 4760 4761 4762 4763 4764
	data = nfs4_alloc_unlockdata(fl, ctx, lsp, seqid);
	if (data == NULL) {
		nfs_free_seqid(seqid);
		return ERR_PTR(-ENOMEM);
	}

4765
	nfs41_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
4766 4767
	msg.rpc_argp = &data->arg;
	msg.rpc_resp = &data->res;
4768 4769
	task_setup_data.callback_data = data;
	return rpc_run_task(&task_setup_data);
4770 4771
}

4772 4773
static int nfs4_proc_unlck(struct nfs4_state *state, int cmd, struct file_lock *request)
{
4774 4775 4776
	struct inode *inode = state->inode;
	struct nfs4_state_owner *sp = state->owner;
	struct nfs_inode *nfsi = NFS_I(inode);
Trond Myklebust's avatar
Trond Myklebust committed
4777
	struct nfs_seqid *seqid;
Linus Torvalds's avatar
Linus Torvalds committed
4778
	struct nfs4_lock_state *lsp;
4779 4780
	struct rpc_task *task;
	int status = 0;
4781
	unsigned char fl_flags = request->fl_flags;
4782

4783
	status = nfs4_set_lock_state(state, request);
4784 4785
	/* Unlock _before_ we do the RPC call */
	request->fl_flags |= FL_EXISTS;
4786 4787 4788
	/* Exclude nfs_delegation_claim_locks() */
	mutex_lock(&sp->so_delegreturn_mutex);
	/* Exclude nfs4_reclaim_open_stateid() - note nesting! */
4789 4790 4791
	down_read(&nfsi->rwsem);
	if (do_vfs_lock(request->fl_file, request) == -ENOENT) {
		up_read(&nfsi->rwsem);
4792
		mutex_unlock(&sp->so_delegreturn_mutex);
4793
		goto out;
4794 4795
	}
	up_read(&nfsi->rwsem);
4796
	mutex_unlock(&sp->so_delegreturn_mutex);
4797
	if (status != 0)
4798 4799
		goto out;
	/* Is this a delegated lock? */
4800
	lsp = request->fl_u.nfs4_fl.owner;
4801 4802
	if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) == 0)
		goto out;
4803
	seqid = nfs_alloc_seqid(&lsp->ls_seqid, GFP_KERNEL);
4804
	status = -ENOMEM;
Trond Myklebust's avatar
Trond Myklebust committed
4805
	if (seqid == NULL)
4806
		goto out;
4807
	task = nfs4_do_unlck(request, nfs_file_open_context(request->fl_file), lsp, seqid);
4808 4809
	status = PTR_ERR(task);
	if (IS_ERR(task))
4810
		goto out;
4811
	status = nfs4_wait_for_completion_rpc_task(task);
4812
	rpc_put_task(task);
4813
out:
4814
	request->fl_flags = fl_flags;
Linus Torvalds's avatar
Linus Torvalds committed
4815 4816 4817
	return status;
}

4818 4819 4820 4821 4822 4823
struct nfs4_lockdata {
	struct nfs_lock_args arg;
	struct nfs_lock_res res;
	struct nfs4_lock_state *lsp;
	struct nfs_open_context *ctx;
	struct file_lock fl;
4824
	unsigned long timestamp;
4825 4826
	int rpc_status;
	int cancelled;
4827
	struct nfs_server *server;
4828 4829 4830
};

static struct nfs4_lockdata *nfs4_alloc_lockdata(struct file_lock *fl,
4831 4832
		struct nfs_open_context *ctx, struct nfs4_lock_state *lsp,
		gfp_t gfp_mask)
Linus Torvalds's avatar
Linus Torvalds committed
4833
{
4834 4835
	struct nfs4_lockdata *p;
	struct inode *inode = lsp->ls_state->inode;
Linus Torvalds's avatar
Linus Torvalds committed
4836
	struct nfs_server *server = NFS_SERVER(inode);
4837

4838
	p = kzalloc(sizeof(*p), gfp_mask);
4839 4840 4841 4842 4843
	if (p == NULL)
		return NULL;

	p->arg.fh = NFS_FH(inode);
	p->arg.fl = &p->fl;
4844
	p->arg.open_seqid = nfs_alloc_seqid(&lsp->ls_state->owner->so_seqid, gfp_mask);
4845 4846
	if (p->arg.open_seqid == NULL)
		goto out_free;
4847
	p->arg.lock_seqid = nfs_alloc_seqid(&lsp->ls_seqid, gfp_mask);
4848
	if (p->arg.lock_seqid == NULL)
4849
		goto out_free_seqid;
4850
	p->arg.lock_stateid = &lsp->ls_stateid;
4851
	p->arg.lock_owner.clientid = server->nfs_client->cl_clientid;
4852
	p->arg.lock_owner.id = lsp->ls_seqid.owner_id;
4853
	p->arg.lock_owner.s_dev = server->s_dev;
4854
	p->res.lock_seqid = p->arg.lock_seqid;
4855
	p->lsp = lsp;
4856
	p->server = server;
4857 4858 4859 4860
	atomic_inc(&lsp->ls_count);
	p->ctx = get_nfs_open_context(ctx);
	memcpy(&p->fl, fl, sizeof(p->fl));
	return p;
4861 4862
out_free_seqid:
	nfs_free_seqid(p->arg.open_seqid);
4863 4864 4865 4866 4867 4868 4869 4870 4871
out_free:
	kfree(p);
	return NULL;
}

static void nfs4_lock_prepare(struct rpc_task *task, void *calldata)
{
	struct nfs4_lockdata *data = calldata;
	struct nfs4_state *state = data->lsp->ls_state;
4872

4873
	dprintk("%s: begin!\n", __func__);
4874
	if (nfs_wait_on_sequence(data->arg.lock_seqid, task) != 0)
4875
		goto out_wait;
4876 4877
	/* Do we need to do an open_to_lock_owner? */
	if (!(data->arg.lock_seqid->sequence->flags & NFS_SEQID_CONFIRMED)) {
4878
		if (nfs_wait_on_sequence(data->arg.open_seqid, task) != 0) {
4879
			goto out_release_lock_seqid;
4880
		}
4881
		data->arg.open_stateid = &state->open_stateid;
4882
		data->arg.new_lock_owner = 1;
4883
		data->res.open_seqid = data->arg.open_seqid;
4884 4885
	} else
		data->arg.new_lock_owner = 0;
4886 4887 4888 4889 4890
	if (!nfs4_valid_open_stateid(state)) {
		data->rpc_status = -EBADF;
		task->tk_action = NULL;
		goto out_release_open_seqid;
	}
4891
	data->timestamp = jiffies;
4892 4893
	if (nfs4_setup_sequence(data->server,
				&data->arg.seq_args,
4894
				&data->res.seq_res,
4895
				task) == 0)
4896
		return;
4897
out_release_open_seqid:
4898 4899 4900
	nfs_release_seqid(data->arg.open_seqid);
out_release_lock_seqid:
	nfs_release_seqid(data->arg.lock_seqid);
4901 4902
out_wait:
	nfs4_sequence_done(task, &data->res.seq_res);
4903
	dprintk("%s: done!, ret = %d\n", __func__, data->rpc_status);
4904 4905
}

4906 4907 4908 4909
static void nfs4_lock_done(struct rpc_task *task, void *calldata)
{
	struct nfs4_lockdata *data = calldata;

4910
	dprintk("%s: begin!\n", __func__);
4911

4912 4913
	if (!nfs4_sequence_done(task, &data->res.seq_res))
		return;
4914

4915 4916 4917 4918 4919 4920 4921 4922
	data->rpc_status = task->tk_status;
	if (data->arg.new_lock_owner != 0) {
		if (data->rpc_status == 0)
			nfs_confirm_seqid(&data->lsp->ls_seqid, 0);
		else
			goto out;
	}
	if (data->rpc_status == 0) {
4923
		nfs4_stateid_copy(&data->lsp->ls_stateid, &data->res.stateid);
4924
		set_bit(NFS_LOCK_INITIALIZED, &data->lsp->ls_flags);
4925
		renew_lease(NFS_SERVER(data->ctx->dentry->d_inode), data->timestamp);
4926 4927
	}
out:
4928
	dprintk("%s: done, ret = %d!\n", __func__, data->rpc_status);
4929 4930 4931 4932 4933 4934
}

static void nfs4_lock_release(void *calldata)
{
	struct nfs4_lockdata *data = calldata;

4935
	dprintk("%s: begin!\n", __func__);
4936
	nfs_free_seqid(data->arg.open_seqid);
4937 4938 4939 4940 4941
	if (data->cancelled != 0) {
		struct rpc_task *task;
		task = nfs4_do_unlck(&data->fl, data->ctx, data->lsp,
				data->arg.lock_seqid);
		if (!IS_ERR(task))
4942
			rpc_put_task_async(task);
4943
		dprintk("%s: cancelling lock!\n", __func__);
4944 4945 4946 4947 4948
	} else
		nfs_free_seqid(data->arg.lock_seqid);
	nfs4_put_lock_state(data->lsp);
	put_nfs_open_context(data->ctx);
	kfree(data);
4949
	dprintk("%s: done!\n", __func__);
4950 4951 4952 4953 4954 4955 4956 4957
}

static const struct rpc_call_ops nfs4_lock_ops = {
	.rpc_call_prepare = nfs4_lock_prepare,
	.rpc_call_done = nfs4_lock_done,
	.rpc_release = nfs4_lock_release,
};

4958 4959 4960 4961 4962
static void nfs4_handle_setlk_error(struct nfs_server *server, struct nfs4_lock_state *lsp, int new_lock_owner, int error)
{
	switch (error) {
	case -NFS4ERR_ADMIN_REVOKED:
	case -NFS4ERR_BAD_STATEID:
4963
		lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
4964
		if (new_lock_owner != 0 ||
4965
		   test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags) != 0)
4966
			nfs4_schedule_stateid_recovery(server, lsp->ls_state);
4967 4968 4969
		break;
	case -NFS4ERR_STALE_STATEID:
		lsp->ls_seqid.flags &= ~NFS_SEQID_CONFIRMED;
4970 4971
	case -NFS4ERR_EXPIRED:
		nfs4_schedule_lease_recovery(server->nfs_client);
4972 4973 4974
	};
}

4975
static int _nfs4_do_setlk(struct nfs4_state *state, int cmd, struct file_lock *fl, int recovery_type)
4976 4977 4978
{
	struct nfs4_lockdata *data;
	struct rpc_task *task;
4979 4980 4981 4982
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LOCK],
		.rpc_cred = state->owner->so_cred,
	};
4983 4984
	struct rpc_task_setup task_setup_data = {
		.rpc_client = NFS_CLIENT(state->inode),
4985
		.rpc_message = &msg,
4986
		.callback_ops = &nfs4_lock_ops,
4987
		.workqueue = nfsiod_workqueue,
4988 4989
		.flags = RPC_TASK_ASYNC,
	};
4990 4991
	int ret;

4992
	dprintk("%s: begin!\n", __func__);
4993
	data = nfs4_alloc_lockdata(fl, nfs_file_open_context(fl->fl_file),
4994 4995
			fl->fl_u.nfs4_fl.owner,
			recovery_type == NFS_LOCK_NEW ? GFP_KERNEL : GFP_NOFS);
4996 4997 4998 4999
	if (data == NULL)
		return -ENOMEM;
	if (IS_SETLKW(cmd))
		data->arg.block = 1;
5000
	nfs41_init_sequence(&data->arg.seq_args, &data->res.seq_res, 1);
5001 5002
	msg.rpc_argp = &data->arg;
	msg.rpc_resp = &data->res;
5003
	task_setup_data.callback_data = data;
5004 5005 5006 5007 5008
	if (recovery_type > NFS_LOCK_NEW) {
		if (recovery_type == NFS_LOCK_RECLAIM)
			data->arg.reclaim = NFS_LOCK_RECLAIM;
		nfs4_set_sequence_privileged(&data->arg.seq_args);
	}
5009
	task = rpc_run_task(&task_setup_data);
5010
	if (IS_ERR(task))
5011 5012 5013 5014
		return PTR_ERR(task);
	ret = nfs4_wait_for_completion_rpc_task(task);
	if (ret == 0) {
		ret = data->rpc_status;
5015 5016 5017
		if (ret)
			nfs4_handle_setlk_error(data->server, data->lsp,
					data->arg.new_lock_owner, ret);
5018 5019
	} else
		data->cancelled = 1;
5020
	rpc_put_task(task);
5021
	dprintk("%s: done, ret = %d!\n", __func__, ret);
5022
	return ret;
Linus Torvalds's avatar
Linus Torvalds committed
5023 5024 5025 5026
}

static int nfs4_lock_reclaim(struct nfs4_state *state, struct file_lock *request)
{
5027
	struct nfs_server *server = NFS_SERVER(state->inode);
5028 5029 5030
	struct nfs4_exception exception = {
		.inode = state->inode,
	};
5031 5032 5033
	int err;

	do {
5034 5035 5036
		/* Cache the lock if possible... */
		if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
			return 0;
5037
		err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_RECLAIM);
5038
		if (err != -NFS4ERR_DELAY)
5039 5040 5041 5042
			break;
		nfs4_handle_exception(server, err, &exception);
	} while (exception.retry);
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
5043 5044 5045 5046
}

static int nfs4_lock_expired(struct nfs4_state *state, struct file_lock *request)
{
5047
	struct nfs_server *server = NFS_SERVER(state->inode);
5048 5049 5050
	struct nfs4_exception exception = {
		.inode = state->inode,
	};
5051 5052
	int err;

5053 5054 5055
	err = nfs4_set_lock_state(state, request);
	if (err != 0)
		return err;
5056
	do {
5057 5058
		if (test_bit(NFS_DELEGATED_STATE, &state->flags) != 0)
			return 0;
5059
		err = _nfs4_do_setlk(state, F_SETLK, request, NFS_LOCK_EXPIRED);
5060 5061 5062 5063 5064 5065 5066 5067
		switch (err) {
		default:
			goto out;
		case -NFS4ERR_GRACE:
		case -NFS4ERR_DELAY:
			nfs4_handle_exception(server, err, &exception);
			err = 0;
		}
5068
	} while (exception.retry);
5069
out:
5070
	return err;
Linus Torvalds's avatar
Linus Torvalds committed
5071 5072
}

5073
#if defined(CONFIG_NFS_V4_1)
5074 5075 5076 5077 5078 5079 5080 5081
/**
 * nfs41_check_expired_locks - possibly free a lock stateid
 *
 * @state: NFSv4 state for an inode
 *
 * Returns NFS_OK if recovery for this stateid is now finished.
 * Otherwise a negative NFS4ERR value is returned.
 */
5082
static int nfs41_check_expired_locks(struct nfs4_state *state)
5083
{
5084
	int status, ret = -NFS4ERR_BAD_STATEID;
5085
	struct nfs4_lock_state *lsp;
5086 5087
	struct nfs_server *server = NFS_SERVER(state->inode);

5088
	list_for_each_entry(lsp, &state->lock_states, ls_locks) {
5089
		if (test_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags)) {
5090 5091
			status = nfs41_test_stateid(server, &lsp->ls_stateid);
			if (status != NFS_OK) {
5092 5093
				/* Free the stateid unless the server
				 * informs us the stateid is unrecognized. */
5094 5095 5096
				if (status != -NFS4ERR_BAD_STATEID)
					nfs41_free_stateid(server,
							&lsp->ls_stateid);
5097
				clear_bit(NFS_LOCK_INITIALIZED, &lsp->ls_flags);
5098 5099 5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111
				ret = status;
			}
		}
	};

	return ret;
}

static int nfs41_lock_expired(struct nfs4_state *state, struct file_lock *request)
{
	int status = NFS_OK;

	if (test_bit(LK_STATE_IN_USE, &state->flags))
		status = nfs41_check_expired_locks(state);
5112 5113 5114
	if (status != NFS_OK)
		status = nfs4_lock_expired(state, request);
	return status;
5115 5116 5117
}
#endif

Linus Torvalds's avatar
Linus Torvalds committed
5118 5119
static int _nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
{
5120
	struct nfs4_state_owner *sp = state->owner;
5121
	struct nfs_inode *nfsi = NFS_I(state->inode);
5122
	unsigned char fl_flags = request->fl_flags;
5123
	unsigned int seq;
5124
	int status = -ENOLCK;
Linus Torvalds's avatar
Linus Torvalds committed
5125

5126 5127 5128
	if ((fl_flags & FL_POSIX) &&
			!test_bit(NFS_STATE_POSIX_LOCKS, &state->flags))
		goto out;
5129 5130 5131 5132
	/* Is this a delegated open? */
	status = nfs4_set_lock_state(state, request);
	if (status != 0)
		goto out;
5133 5134 5135 5136
	request->fl_flags |= FL_ACCESS;
	status = do_vfs_lock(request->fl_file, request);
	if (status < 0)
		goto out;
5137
	down_read(&nfsi->rwsem);
5138 5139 5140
	if (test_bit(NFS_DELEGATED_STATE, &state->flags)) {
		/* Yes: cache locks! */
		/* ...but avoid races with delegation recall... */
5141 5142 5143
		request->fl_flags = fl_flags & ~FL_SLEEP;
		status = do_vfs_lock(request->fl_file, request);
		goto out_unlock;
5144
	}
5145 5146
	seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
	up_read(&nfsi->rwsem);
5147
	status = _nfs4_do_setlk(state, cmd, request, NFS_LOCK_NEW);
5148
	if (status != 0)
5149 5150 5151 5152
		goto out;
	down_read(&nfsi->rwsem);
	if (read_seqcount_retry(&sp->so_reclaim_seqcount, seq)) {
		status = -NFS4ERR_DELAY;
5153
		goto out_unlock;
5154
	}
5155
	/* Note: we always want to sleep here! */
5156
	request->fl_flags = fl_flags | FL_SLEEP;
5157
	if (do_vfs_lock(request->fl_file, request) < 0)
5158 5159
		printk(KERN_WARNING "NFS: %s: VFS is out of sync with lock "
			"manager!\n", __func__);
5160
out_unlock:
5161
	up_read(&nfsi->rwsem);
5162 5163
out:
	request->fl_flags = fl_flags;
Linus Torvalds's avatar
Linus Torvalds committed
5164 5165 5166 5167 5168
	return status;
}

static int nfs4_proc_setlk(struct nfs4_state *state, int cmd, struct file_lock *request)
{
5169 5170
	struct nfs4_exception exception = {
		.state = state,
5171
		.inode = state->inode,
5172
	};
Linus Torvalds's avatar
Linus Torvalds committed
5173 5174 5175
	int err;

	do {
5176 5177 5178
		err = _nfs4_proc_setlk(state, cmd, request);
		if (err == -NFS4ERR_DENIED)
			err = -EAGAIN;
Linus Torvalds's avatar
Linus Torvalds committed
5179
		err = nfs4_handle_exception(NFS_SERVER(state->inode),
5180
				err, &exception);
Linus Torvalds's avatar
Linus Torvalds committed
5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193
	} while (exception.retry);
	return err;
}

static int
nfs4_proc_lock(struct file *filp, int cmd, struct file_lock *request)
{
	struct nfs_open_context *ctx;
	struct nfs4_state *state;
	unsigned long timeout = NFS4_LOCK_MINTIMEOUT;
	int status;

	/* verify open state */
5194
	ctx = nfs_file_open_context(filp);
Linus Torvalds's avatar
Linus Torvalds committed
5195 5196 5197 5198 5199
	state = ctx->state;

	if (request->fl_start < 0 || request->fl_end < 0)
		return -EINVAL;

5200 5201 5202 5203 5204
	if (IS_GETLK(cmd)) {
		if (state != NULL)
			return nfs4_proc_getlk(state, F_GETLK, request);
		return 0;
	}
Linus Torvalds's avatar
Linus Torvalds committed
5205 5206 5207 5208

	if (!(IS_SETLK(cmd) || IS_SETLKW(cmd)))
		return -EINVAL;

5209 5210 5211 5212 5213
	if (request->fl_type == F_UNLCK) {
		if (state != NULL)
			return nfs4_proc_unlck(state, cmd, request);
		return 0;
	}
Linus Torvalds's avatar
Linus Torvalds committed
5214

5215 5216
	if (state == NULL)
		return -ENOLCK;
5217 5218 5219 5220
	/*
	 * Don't rely on the VFS having checked the file open mode,
	 * since it won't do this for flock() locks.
	 */
5221
	switch (request->fl_type) {
5222 5223 5224 5225 5226 5227 5228 5229 5230
	case F_RDLCK:
		if (!(filp->f_mode & FMODE_READ))
			return -EBADF;
		break;
	case F_WRLCK:
		if (!(filp->f_mode & FMODE_WRITE))
			return -EBADF;
	}

Linus Torvalds's avatar
Linus Torvalds committed
5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242
	do {
		status = nfs4_proc_setlk(state, cmd, request);
		if ((status != -EAGAIN) || IS_SETLK(cmd))
			break;
		timeout = nfs4_set_lock_task_retry(timeout);
		status = -ERESTARTSYS;
		if (signalled())
			break;
	} while(status < 0);
	return status;
}

5243
int nfs4_lock_delegation_recall(struct file_lock *fl, struct nfs4_state *state, const nfs4_stateid *stateid)
5244 5245 5246 5247 5248 5249
{
	struct nfs_server *server = NFS_SERVER(state->inode);
	int err;

	err = nfs4_set_lock_state(state, fl);
	if (err != 0)
5250
		return err;
5251
	err = _nfs4_do_setlk(state, F_SETLK, fl, NFS_LOCK_NEW);
5252
	return nfs4_handle_delegation_recall_error(server, state, stateid, err);
5253
}
5254

5255 5256
struct nfs_release_lockowner_data {
	struct nfs4_lock_state *lsp;
5257
	struct nfs_server *server;
5258 5259 5260
	struct nfs_release_lockowner_args args;
};

5261 5262
static void nfs4_release_lockowner_release(void *calldata)
{
5263
	struct nfs_release_lockowner_data *data = calldata;
5264
	nfs4_free_lock_state(data->server, data->lsp);
5265 5266 5267
	kfree(calldata);
}

5268
static const struct rpc_call_ops nfs4_release_lockowner_ops = {
5269 5270 5271
	.rpc_release = nfs4_release_lockowner_release,
};

5272
static int nfs4_release_lockowner(struct nfs_server *server, struct nfs4_lock_state *lsp)
5273
{
5274
	struct nfs_release_lockowner_data *data;
5275 5276 5277 5278 5279
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RELEASE_LOCKOWNER],
	};

	if (server->nfs_client->cl_mvops->minor_version != 0)
5280 5281 5282 5283 5284
		return -EINVAL;
	data = kmalloc(sizeof(*data), GFP_NOFS);
	if (!data)
		return -ENOMEM;
	data->lsp = lsp;
5285
	data->server = server;
5286 5287 5288 5289 5290 5291
	data->args.lock_owner.clientid = server->nfs_client->cl_clientid;
	data->args.lock_owner.id = lsp->ls_seqid.owner_id;
	data->args.lock_owner.s_dev = server->s_dev;
	msg.rpc_argp = &data->args;
	rpc_call_async(server->client, &msg, 0, &nfs4_release_lockowner_ops, data);
	return 0;
5292 5293
}

5294 5295
#define XATTR_NAME_NFSV4_ACL "system.nfs4_acl"

5296 5297 5298
static int nfs4_xattr_set_nfs4_acl(struct dentry *dentry, const char *key,
				   const void *buf, size_t buflen,
				   int flags, int type)
5299
{
5300 5301
	if (strcmp(key, "") != 0)
		return -EINVAL;
5302

5303
	return nfs4_proc_set_acl(dentry->d_inode, buf, buflen);
5304 5305
}

5306 5307
static int nfs4_xattr_get_nfs4_acl(struct dentry *dentry, const char *key,
				   void *buf, size_t buflen, int type)
5308
{
5309 5310
	if (strcmp(key, "") != 0)
		return -EINVAL;
5311

5312
	return nfs4_proc_get_acl(dentry->d_inode, buf, buflen);
5313 5314
}

5315 5316 5317
static size_t nfs4_xattr_list_nfs4_acl(struct dentry *dentry, char *list,
				       size_t list_len, const char *name,
				       size_t name_len, int type)
5318
{
5319
	size_t len = sizeof(XATTR_NAME_NFSV4_ACL);
5320

5321 5322
	if (!nfs4_server_supports_acls(NFS_SERVER(dentry->d_inode)))
		return 0;
5323 5324 5325

	if (list && len <= list_len)
		memcpy(list, XATTR_NAME_NFSV4_ACL, len);
5326
	return len;
5327 5328
}

5329 5330 5331
/*
 * nfs_fhget will use either the mounted_on_fileid or the fileid
 */
5332 5333
static void nfs_fixup_referral_attributes(struct nfs_fattr *fattr)
{
5334 5335 5336
	if (!(((fattr->valid & NFS_ATTR_FATTR_MOUNTED_ON_FILEID) ||
	       (fattr->valid & NFS_ATTR_FATTR_FILEID)) &&
	      (fattr->valid & NFS_ATTR_FATTR_FSID) &&
5337
	      (fattr->valid & NFS_ATTR_FATTR_V4_LOCATIONS)))
5338 5339 5340
		return;

	fattr->valid |= NFS_ATTR_FATTR_TYPE | NFS_ATTR_FATTR_MODE |
5341
		NFS_ATTR_FATTR_NLINK | NFS_ATTR_FATTR_V4_REFERRAL;
5342 5343 5344 5345
	fattr->mode = S_IFDIR | S_IRUGO | S_IXUGO;
	fattr->nlink = 2;
}

5346 5347 5348 5349
static int _nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
				   const struct qstr *name,
				   struct nfs4_fs_locations *fs_locations,
				   struct page *page)
5350 5351 5352
{
	struct nfs_server *server = NFS_SERVER(dir);
	u32 bitmask[2] = {
5353
		[0] = FATTR4_WORD0_FSID | FATTR4_WORD0_FS_LOCATIONS,
5354 5355 5356
	};
	struct nfs4_fs_locations_arg args = {
		.dir_fh = NFS_FH(dir),
5357
		.name = name,
5358 5359 5360
		.page = page,
		.bitmask = bitmask,
	};
5361 5362 5363
	struct nfs4_fs_locations_res res = {
		.fs_locations = fs_locations,
	};
5364 5365 5366
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FS_LOCATIONS],
		.rpc_argp = &args,
5367
		.rpc_resp = &res,
5368 5369 5370
	};
	int status;

5371
	dprintk("%s: start\n", __func__);
5372 5373 5374 5375 5376 5377 5378 5379

	/* Ask for the fileid of the absent filesystem if mounted_on_fileid
	 * is not supported */
	if (NFS_SERVER(dir)->attr_bitmask[1] & FATTR4_WORD1_MOUNTED_ON_FILEID)
		bitmask[1] |= FATTR4_WORD1_MOUNTED_ON_FILEID;
	else
		bitmask[0] |= FATTR4_WORD0_FILEID;

5380
	nfs_fattr_init(&fs_locations->fattr);
5381
	fs_locations->server = server;
5382
	fs_locations->nlocations = 0;
5383
	status = nfs4_call_sync(client, server, &msg, &args.seq_args, &res.seq_res, 0);
5384
	dprintk("%s: returned status = %d\n", __func__, status);
5385 5386 5387
	return status;
}

5388 5389 5390 5391
int nfs4_proc_fs_locations(struct rpc_clnt *client, struct inode *dir,
			   const struct qstr *name,
			   struct nfs4_fs_locations *fs_locations,
			   struct page *page)
5392 5393 5394 5395 5396
{
	struct nfs4_exception exception = { };
	int err;
	do {
		err = nfs4_handle_exception(NFS_SERVER(dir),
5397
				_nfs4_proc_fs_locations(client, dir, name, fs_locations, page),
5398 5399 5400 5401 5402
				&exception);
	} while (exception.retry);
	return err;
}

Bryan Schumaker's avatar
Bryan Schumaker committed
5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424
static int _nfs4_proc_secinfo(struct inode *dir, const struct qstr *name, struct nfs4_secinfo_flavors *flavors)
{
	int status;
	struct nfs4_secinfo_arg args = {
		.dir_fh = NFS_FH(dir),
		.name   = name,
	};
	struct nfs4_secinfo_res res = {
		.flavors     = flavors,
	};
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO],
		.rpc_argp = &args,
		.rpc_resp = &res,
	};

	dprintk("NFS call  secinfo %s\n", name->name);
	status = nfs4_call_sync(NFS_SERVER(dir)->client, NFS_SERVER(dir), &msg, &args.seq_args, &res.seq_res, 0);
	dprintk("NFS reply  secinfo: %d\n", status);
	return status;
}

5425 5426
int nfs4_proc_secinfo(struct inode *dir, const struct qstr *name,
		      struct nfs4_secinfo_flavors *flavors)
Bryan Schumaker's avatar
Bryan Schumaker committed
5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437
{
	struct nfs4_exception exception = { };
	int err;
	do {
		err = nfs4_handle_exception(NFS_SERVER(dir),
				_nfs4_proc_secinfo(dir, name, flavors),
				&exception);
	} while (exception.retry);
	return err;
}

5438
#ifdef CONFIG_NFS_V4_1
5439 5440 5441 5442 5443 5444 5445 5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457
/*
 * Check the exchange flags returned by the server for invalid flags, having
 * both PNFS and NON_PNFS flags set, and not having one of NON_PNFS, PNFS, or
 * DS flags set.
 */
static int nfs4_check_cl_exchange_flags(u32 flags)
{
	if (flags & ~EXCHGID4_FLAG_MASK_R)
		goto out_inval;
	if ((flags & EXCHGID4_FLAG_USE_PNFS_MDS) &&
	    (flags & EXCHGID4_FLAG_USE_NON_PNFS))
		goto out_inval;
	if (!(flags & (EXCHGID4_FLAG_MASK_PNFS)))
		goto out_inval;
	return NFS_OK;
out_inval:
	return -NFS4ERR_INVAL;
}

5458
static bool
5459 5460
nfs41_same_server_scope(struct nfs41_server_scope *a,
			struct nfs41_server_scope *b)
5461 5462 5463 5464 5465 5466 5467 5468
{
	if (a->server_scope_sz == b->server_scope_sz &&
	    memcmp(a->server_scope, b->server_scope, a->server_scope_sz) == 0)
		return true;

	return false;
}

5469 5470 5471 5472 5473 5474
/*
 * nfs4_proc_bind_conn_to_session()
 *
 * The 4.1 client currently uses the same TCP connection for the
 * fore and backchannel.
 */
5475
int nfs4_proc_bind_conn_to_session(struct nfs_client *clp, struct rpc_cred *cred)
5476 5477 5478 5479 5480 5481 5482 5483
{
	int status;
	struct nfs41_bind_conn_to_session_res res;
	struct rpc_message msg = {
		.rpc_proc =
			&nfs4_procedures[NFSPROC4_CLNT_BIND_CONN_TO_SESSION],
		.rpc_argp = clp,
		.rpc_resp = &res,
5484
		.rpc_cred = cred,
5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522
	};

	dprintk("--> %s\n", __func__);

	res.session = kzalloc(sizeof(struct nfs4_session), GFP_NOFS);
	if (unlikely(res.session == NULL)) {
		status = -ENOMEM;
		goto out;
	}

	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
	if (status == 0) {
		if (memcmp(res.session->sess_id.data,
		    clp->cl_session->sess_id.data, NFS4_MAX_SESSIONID_LEN)) {
			dprintk("NFS: %s: Session ID mismatch\n", __func__);
			status = -EIO;
			goto out_session;
		}
		if (res.dir != NFS4_CDFS4_BOTH) {
			dprintk("NFS: %s: Unexpected direction from server\n",
				__func__);
			status = -EIO;
			goto out_session;
		}
		if (res.use_conn_in_rdma_mode) {
			dprintk("NFS: %s: Server returned RDMA mode = true\n",
				__func__);
			status = -EIO;
			goto out_session;
		}
	}
out_session:
	kfree(res.session);
out:
	dprintk("<-- %s status= %d\n", __func__, status);
	return status;
}

Benny Halevy's avatar
Benny Halevy committed
5523 5524 5525
/*
 * nfs4_proc_exchange_id()
 *
5526 5527
 * Returns zero, a negative errno, or a negative NFS4ERR status code.
 *
Benny Halevy's avatar
Benny Halevy committed
5528 5529 5530 5531 5532
 * Since the clientid has expired, all compounds using sessions
 * associated with the stale clientid will be returning
 * NFS4ERR_BADSESSION in the sequence operation, and will therefore
 * be in some phase of session reset.
 */
5533
int nfs4_proc_exchange_id(struct nfs_client *clp, struct rpc_cred *cred)
Benny Halevy's avatar
Benny Halevy committed
5534 5535 5536
{
	nfs4_verifier verifier;
	struct nfs41_exchange_id_args args = {
5537
		.verifier = &verifier,
Benny Halevy's avatar
Benny Halevy committed
5538
		.client = clp,
5539
		.flags = EXCHGID4_FLAG_SUPP_MOVED_REFER,
Benny Halevy's avatar
Benny Halevy committed
5540 5541
	};
	struct nfs41_exchange_id_res res = {
5542
		0
Benny Halevy's avatar
Benny Halevy committed
5543 5544 5545 5546 5547 5548 5549 5550 5551
	};
	int status;
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_EXCHANGE_ID],
		.rpc_argp = &args,
		.rpc_resp = &res,
		.rpc_cred = cred,
	};

5552
	nfs4_init_boot_verifier(clp, &verifier);
5553 5554
	args.id_len = nfs4_init_uniform_client_string(clp, args.id,
							sizeof(args.id));
5555 5556 5557
	dprintk("NFS call  exchange_id auth=%s, '%.*s'\n",
		clp->cl_rpcclient->cl_auth->au_ops->au_name,
		args.id_len, args.id);
Benny Halevy's avatar
Benny Halevy committed
5558

5559
	res.server_owner = kzalloc(sizeof(struct nfs41_server_owner),
5560
					GFP_NOFS);
5561
	if (unlikely(res.server_owner == NULL)) {
5562 5563 5564
		status = -ENOMEM;
		goto out;
	}
5565

5566
	res.server_scope = kzalloc(sizeof(struct nfs41_server_scope),
5567
					GFP_NOFS);
5568
	if (unlikely(res.server_scope == NULL)) {
5569
		status = -ENOMEM;
5570
		goto out_server_owner;
5571
	}
5572

5573
	res.impl_id = kzalloc(sizeof(struct nfs41_impl_id), GFP_NOFS);
5574
	if (unlikely(res.impl_id == NULL)) {
5575 5576 5577 5578
		status = -ENOMEM;
		goto out_server_scope;
	}

5579
	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
5580
	if (status == 0)
5581
		status = nfs4_check_cl_exchange_flags(res.flags);
5582

5583
	if (status == 0) {
5584 5585 5586 5587 5588
		clp->cl_clientid = res.clientid;
		clp->cl_exchange_flags = (res.flags & ~EXCHGID4_FLAG_CONFIRMED_R);
		if (!(res.flags & EXCHGID4_FLAG_CONFIRMED_R))
			clp->cl_seqid = res.seqid;

5589 5590 5591
		kfree(clp->cl_serverowner);
		clp->cl_serverowner = res.server_owner;
		res.server_owner = NULL;
5592

5593
		/* use the most recent implementation id */
5594 5595
		kfree(clp->cl_implid);
		clp->cl_implid = res.impl_id;
5596

5597
		if (clp->cl_serverscope != NULL &&
5598
		    !nfs41_same_server_scope(clp->cl_serverscope,
5599 5600 5601 5602
					     res.server_scope)) {
			dprintk("%s: server_scope mismatch detected\n",
				__func__);
			set_bit(NFS4CLNT_SERVER_SCOPE_MISMATCH, &clp->cl_state);
5603 5604
			kfree(clp->cl_serverscope);
			clp->cl_serverscope = NULL;
5605 5606
		}

5607
		if (clp->cl_serverscope == NULL) {
5608
			clp->cl_serverscope = res.server_scope;
5609 5610
			goto out;
		}
5611 5612
	} else
		kfree(res.impl_id);
5613

5614 5615
out_server_owner:
	kfree(res.server_owner);
5616
out_server_scope:
5617 5618
	kfree(res.server_scope);
out:
5619
	if (clp->cl_implid != NULL)
5620
		dprintk("NFS reply exchange_id: Server Implementation ID: "
5621
			"domain: %s, name: %s, date: %llu,%u\n",
5622
			clp->cl_implid->domain, clp->cl_implid->name,
5623 5624
			clp->cl_implid->date.seconds,
			clp->cl_implid->date.nseconds);
5625
	dprintk("NFS reply exchange_id: %d\n", status);
Benny Halevy's avatar
Benny Halevy committed
5626 5627 5628
	return status;
}

5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640
static int _nfs4_proc_destroy_clientid(struct nfs_client *clp,
		struct rpc_cred *cred)
{
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_CLIENTID],
		.rpc_argp = clp,
		.rpc_cred = cred,
	};
	int status;

	status = rpc_call_sync(clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
	if (status)
5641
		dprintk("NFS: Got error %d from the server %s on "
5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674
			"DESTROY_CLIENTID.", status, clp->cl_hostname);
	return status;
}

static int nfs4_proc_destroy_clientid(struct nfs_client *clp,
		struct rpc_cred *cred)
{
	unsigned int loop;
	int ret;

	for (loop = NFS4_MAX_LOOP_ON_RECOVER; loop != 0; loop--) {
		ret = _nfs4_proc_destroy_clientid(clp, cred);
		switch (ret) {
		case -NFS4ERR_DELAY:
		case -NFS4ERR_CLIENTID_BUSY:
			ssleep(1);
			break;
		default:
			return ret;
		}
	}
	return 0;
}

int nfs4_destroy_clientid(struct nfs_client *clp)
{
	struct rpc_cred *cred;
	int ret = 0;

	if (clp->cl_mvops->minor_version < 1)
		goto out;
	if (clp->cl_exchange_flags == 0)
		goto out;
5675 5676
	if (clp->cl_preserve_clid)
		goto out;
5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689
	cred = nfs4_get_exchange_id_cred(clp);
	ret = nfs4_proc_destroy_clientid(clp, cred);
	if (cred)
		put_rpccred(cred);
	switch (ret) {
	case 0:
	case -NFS4ERR_STALE_CLIENTID:
		clp->cl_exchange_flags = 0;
	}
out:
	return ret;
}

Andy Adamson's avatar
Andy Adamson committed
5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704
struct nfs4_get_lease_time_data {
	struct nfs4_get_lease_time_args *args;
	struct nfs4_get_lease_time_res *res;
	struct nfs_client *clp;
};

static void nfs4_get_lease_time_prepare(struct rpc_task *task,
					void *calldata)
{
	struct nfs4_get_lease_time_data *data =
			(struct nfs4_get_lease_time_data *)calldata;

	dprintk("--> %s\n", __func__);
	/* just setup sequence, do not trigger session recovery
	   since we're invoked within one */
5705 5706 5707 5708
	nfs41_setup_sequence(data->clp->cl_session,
			&data->args->la_seq_args,
			&data->res->lr_seq_res,
			task);
Andy Adamson's avatar
Andy Adamson committed
5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721
	dprintk("<-- %s\n", __func__);
}

/*
 * Called from nfs4_state_manager thread for session setup, so don't recover
 * from sequence operation or clientid errors.
 */
static void nfs4_get_lease_time_done(struct rpc_task *task, void *calldata)
{
	struct nfs4_get_lease_time_data *data =
			(struct nfs4_get_lease_time_data *)calldata;

	dprintk("--> %s\n", __func__);
5722 5723
	if (!nfs41_sequence_done(task, &data->res->lr_seq_res))
		return;
Andy Adamson's avatar
Andy Adamson committed
5724 5725 5726 5727 5728 5729
	switch (task->tk_status) {
	case -NFS4ERR_DELAY:
	case -NFS4ERR_GRACE:
		dprintk("%s Retry: tk_status %d\n", __func__, task->tk_status);
		rpc_delay(task, NFS4_POLL_RETRY_MIN);
		task->tk_status = 0;
5730 5731
		/* fall through */
	case -NFS4ERR_RETRY_UNCACHED_REP:
5732
		rpc_restart_call_prepare(task);
Andy Adamson's avatar
Andy Adamson committed
5733 5734 5735 5736 5737
		return;
	}
	dprintk("<-- %s\n", __func__);
}

5738
static const struct rpc_call_ops nfs4_get_lease_time_ops = {
Andy Adamson's avatar
Andy Adamson committed
5739 5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758 5759 5760 5761 5762 5763
	.rpc_call_prepare = nfs4_get_lease_time_prepare,
	.rpc_call_done = nfs4_get_lease_time_done,
};

int nfs4_proc_get_lease_time(struct nfs_client *clp, struct nfs_fsinfo *fsinfo)
{
	struct rpc_task *task;
	struct nfs4_get_lease_time_args args;
	struct nfs4_get_lease_time_res res = {
		.lr_fsinfo = fsinfo,
	};
	struct nfs4_get_lease_time_data data = {
		.args = &args,
		.res = &res,
		.clp = clp,
	};
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GET_LEASE_TIME],
		.rpc_argp = &args,
		.rpc_resp = &res,
	};
	struct rpc_task_setup task_setup = {
		.rpc_client = clp->cl_rpcclient,
		.rpc_message = &msg,
		.callback_ops = &nfs4_get_lease_time_ops,
5764 5765
		.callback_data = &data,
		.flags = RPC_TASK_TIMEOUT,
Andy Adamson's avatar
Andy Adamson committed
5766 5767 5768
	};
	int status;

5769
	nfs41_init_sequence(&args.la_seq_args, &res.lr_seq_res, 0);
5770
	nfs4_set_sequence_privileged(&args.la_seq_args);
Andy Adamson's avatar
Andy Adamson committed
5771 5772 5773 5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784
	dprintk("--> %s\n", __func__);
	task = rpc_run_task(&task_setup);

	if (IS_ERR(task))
		status = PTR_ERR(task);
	else {
		status = task->tk_status;
		rpc_put_task(task);
	}
	dprintk("<-- %s return %d\n", __func__, status);

	return status;
}

5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796
/*
 * Initialize the values to be used by the client in CREATE_SESSION
 * If nfs4_init_session set the fore channel request and response sizes,
 * use them.
 *
 * Set the back channel max_resp_sz_cached to zero to force the client to
 * always set csa_cachethis to FALSE because the current implementation
 * of the back channel DRC only supports caching the CB_SEQUENCE operation.
 */
static void nfs4_init_channel_attrs(struct nfs41_create_session_args *args)
{
	struct nfs4_session *session = args->client->cl_session;
5797 5798
	unsigned int mxrqst_sz = session->fc_target_max_rqst_sz,
		     mxresp_sz = session->fc_target_max_resp_sz;
5799 5800 5801 5802 5803 5804 5805 5806 5807

	if (mxrqst_sz == 0)
		mxrqst_sz = NFS_MAX_FILE_IO_SIZE;
	if (mxresp_sz == 0)
		mxresp_sz = NFS_MAX_FILE_IO_SIZE;
	/* Fore channel attributes */
	args->fc_attrs.max_rqst_sz = mxrqst_sz;
	args->fc_attrs.max_resp_sz = mxresp_sz;
	args->fc_attrs.max_ops = NFS4_MAX_OPS;
5808
	args->fc_attrs.max_reqs = max_session_slots;
5809 5810

	dprintk("%s: Fore Channel : max_rqst_sz=%u max_resp_sz=%u "
5811
		"max_ops=%u max_reqs=%u\n",
5812 5813
		__func__,
		args->fc_attrs.max_rqst_sz, args->fc_attrs.max_resp_sz,
5814
		args->fc_attrs.max_ops, args->fc_attrs.max_reqs);
5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830

	/* Back channel attributes */
	args->bc_attrs.max_rqst_sz = PAGE_SIZE;
	args->bc_attrs.max_resp_sz = PAGE_SIZE;
	args->bc_attrs.max_resp_sz_cached = 0;
	args->bc_attrs.max_ops = NFS4_MAX_BACK_CHANNEL_OPS;
	args->bc_attrs.max_reqs = 1;

	dprintk("%s: Back Channel : max_rqst_sz=%u max_resp_sz=%u "
		"max_resp_sz_cached=%u max_ops=%u max_reqs=%u\n",
		__func__,
		args->bc_attrs.max_rqst_sz, args->bc_attrs.max_resp_sz,
		args->bc_attrs.max_resp_sz_cached, args->bc_attrs.max_ops,
		args->bc_attrs.max_reqs);
}

5831
static int nfs4_verify_fore_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session)
5832
{
5833 5834 5835 5836 5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847
	struct nfs4_channel_attrs *sent = &args->fc_attrs;
	struct nfs4_channel_attrs *rcvd = &session->fc_attrs;

	if (rcvd->max_resp_sz > sent->max_resp_sz)
		return -EINVAL;
	/*
	 * Our requested max_ops is the minimum we need; we're not
	 * prepared to break up compounds into smaller pieces than that.
	 * So, no point even trying to continue if the server won't
	 * cooperate:
	 */
	if (rcvd->max_ops < sent->max_ops)
		return -EINVAL;
	if (rcvd->max_reqs == 0)
		return -EINVAL;
5848 5849
	if (rcvd->max_reqs > NFS4_MAX_SLOT_TABLE)
		rcvd->max_reqs = NFS4_MAX_SLOT_TABLE;
5850
	return 0;
5851 5852
}

5853 5854 5855 5856
static int nfs4_verify_back_channel_attrs(struct nfs41_create_session_args *args, struct nfs4_session *session)
{
	struct nfs4_channel_attrs *sent = &args->bc_attrs;
	struct nfs4_channel_attrs *rcvd = &session->bc_attrs;
5857

5858 5859 5860 5861 5862 5863 5864
	if (rcvd->max_rqst_sz > sent->max_rqst_sz)
		return -EINVAL;
	if (rcvd->max_resp_sz < sent->max_resp_sz)
		return -EINVAL;
	if (rcvd->max_resp_sz_cached > sent->max_resp_sz_cached)
		return -EINVAL;
	/* These would render the backchannel useless: */
5865
	if (rcvd->max_ops != sent->max_ops)
5866
		return -EINVAL;
5867
	if (rcvd->max_reqs != sent->max_reqs)
5868 5869 5870
		return -EINVAL;
	return 0;
}
5871 5872 5873 5874

static int nfs4_verify_channel_attrs(struct nfs41_create_session_args *args,
				     struct nfs4_session *session)
{
5875
	int ret;
5876

5877 5878 5879 5880
	ret = nfs4_verify_fore_channel_attrs(args, session);
	if (ret)
		return ret;
	return nfs4_verify_back_channel_attrs(args, session);
5881 5882
}

5883 5884
static int _nfs4_proc_create_session(struct nfs_client *clp,
		struct rpc_cred *cred)
5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897
{
	struct nfs4_session *session = clp->cl_session;
	struct nfs41_create_session_args args = {
		.client = clp,
		.cb_program = NFS4_CALLBACK,
	};
	struct nfs41_create_session_res res = {
		.client = clp,
	};
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_CREATE_SESSION],
		.rpc_argp = &args,
		.rpc_resp = &res,
5898
		.rpc_cred = cred,
5899 5900 5901 5902
	};
	int status;

	nfs4_init_channel_attrs(&args);
5903
	args.flags = (SESSION4_PERSIST | SESSION4_BACK_CHAN);
5904

5905
	status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
5906

5907
	if (!status) {
5908 5909
		/* Verify the session's negotiated channel_attrs values */
		status = nfs4_verify_channel_attrs(&args, session);
5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921
		/* Increment the clientid slot sequence id */
		clp->cl_seqid++;
	}

	return status;
}

/*
 * Issues a CREATE_SESSION operation to the server.
 * It is the responsibility of the caller to verify the session is
 * expired before calling this routine.
 */
5922
int nfs4_proc_create_session(struct nfs_client *clp, struct rpc_cred *cred)
5923 5924 5925 5926 5927 5928 5929
{
	int status;
	unsigned *ptr;
	struct nfs4_session *session = clp->cl_session;

	dprintk("--> %s clp=%p session=%p\n", __func__, clp, session);

5930
	status = _nfs4_proc_create_session(clp, cred);
5931 5932 5933
	if (status)
		goto out;

5934 5935 5936
	/* Init or reset the session slot tables */
	status = nfs4_setup_session_slot_tables(session);
	dprintk("slot table setup returned %d\n", status);
5937 5938 5939 5940 5941 5942 5943 5944 5945 5946 5947
	if (status)
		goto out;

	ptr = (unsigned *)&session->sess_id.data[0];
	dprintk("%s client>seqid %d sessionid %u:%u:%u:%u\n", __func__,
		clp->cl_seqid, ptr[0], ptr[1], ptr[2], ptr[3]);
out:
	dprintk("<-- %s\n", __func__);
	return status;
}

5948 5949 5950 5951
/*
 * Issue the over-the-wire RPC DESTROY_SESSION.
 * The caller must serialize access to this routine.
 */
5952 5953
int nfs4_proc_destroy_session(struct nfs4_session *session,
		struct rpc_cred *cred)
5954
{
5955 5956 5957 5958 5959
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_DESTROY_SESSION],
		.rpc_argp = session,
		.rpc_cred = cred,
	};
5960 5961 5962 5963 5964 5965 5966 5967
	int status = 0;

	dprintk("--> nfs4_proc_destroy_session\n");

	/* session is still being setup */
	if (session->clp->cl_cons_state != NFS_CS_READY)
		return status;

5968
	status = rpc_call_sync(session->clp->cl_rpcclient, &msg, RPC_TASK_TIMEOUT);
5969 5970

	if (status)
5971
		dprintk("NFS: Got error %d from the server on DESTROY_SESSION. "
5972 5973 5974 5975 5976 5977
			"Session has been destroyed regardless...\n", status);

	dprintk("<-- nfs4_proc_destroy_session\n");
	return status;
}

Andy Adamson's avatar
Andy Adamson committed
5978 5979 5980
/*
 * Renew the cl_session lease.
 */
5981 5982 5983 5984 5985 5986
struct nfs4_sequence_data {
	struct nfs_client *clp;
	struct nfs4_sequence_args args;
	struct nfs4_sequence_res res;
};

5987 5988
static void nfs41_sequence_release(void *data)
{
5989 5990
	struct nfs4_sequence_data *calldata = data;
	struct nfs_client *clp = calldata->clp;
5991

5992 5993 5994
	if (atomic_read(&clp->cl_count) > 1)
		nfs4_schedule_state_renewal(clp);
	nfs_put_client(clp);
5995
	kfree(calldata);
5996 5997
}

5998 5999 6000 6001 6002 6003 6004
static int nfs41_sequence_handle_errors(struct rpc_task *task, struct nfs_client *clp)
{
	switch(task->tk_status) {
	case -NFS4ERR_DELAY:
		rpc_delay(task, NFS4_POLL_RETRY_MAX);
		return -EAGAIN;
	default:
6005
		nfs4_schedule_lease_recovery(clp);
6006 6007 6008 6009
	}
	return 0;
}

6010
static void nfs41_sequence_call_done(struct rpc_task *task, void *data)
Andy Adamson's avatar
Andy Adamson committed
6011
{
6012 6013
	struct nfs4_sequence_data *calldata = data;
	struct nfs_client *clp = calldata->clp;
Andy Adamson's avatar
Andy Adamson committed
6014

6015 6016
	if (!nfs41_sequence_done(task, task->tk_msg.rpc_resp))
		return;
Andy Adamson's avatar
Andy Adamson committed
6017 6018 6019

	if (task->tk_status < 0) {
		dprintk("%s ERROR %d\n", __func__, task->tk_status);
6020 6021
		if (atomic_read(&clp->cl_count) == 1)
			goto out;
Andy Adamson's avatar
Andy Adamson committed
6022

6023 6024
		if (nfs41_sequence_handle_errors(task, clp) == -EAGAIN) {
			rpc_restart_call_prepare(task);
Andy Adamson's avatar
Andy Adamson committed
6025 6026 6027 6028
			return;
		}
	}
	dprintk("%s rpc_cred %p\n", __func__, task->tk_msg.rpc_cred);
6029
out:
Andy Adamson's avatar
Andy Adamson committed
6030 6031 6032 6033 6034
	dprintk("<-- %s\n", __func__);
}

static void nfs41_sequence_prepare(struct rpc_task *task, void *data)
{
6035 6036
	struct nfs4_sequence_data *calldata = data;
	struct nfs_client *clp = calldata->clp;
Andy Adamson's avatar
Andy Adamson committed
6037 6038 6039 6040 6041 6042
	struct nfs4_sequence_args *args;
	struct nfs4_sequence_res *res;

	args = task->tk_msg.rpc_argp;
	res = task->tk_msg.rpc_resp;

6043
	nfs41_setup_sequence(clp->cl_session, args, res, task);
Andy Adamson's avatar
Andy Adamson committed
6044 6045 6046 6047 6048
}

static const struct rpc_call_ops nfs41_sequence_ops = {
	.rpc_call_done = nfs41_sequence_call_done,
	.rpc_call_prepare = nfs41_sequence_prepare,
6049
	.rpc_release = nfs41_sequence_release,
Andy Adamson's avatar
Andy Adamson committed
6050 6051
};

6052 6053 6054
static struct rpc_task *_nfs41_proc_sequence(struct nfs_client *clp,
		struct rpc_cred *cred,
		bool is_privileged)
Andy Adamson's avatar
Andy Adamson committed
6055
{
6056
	struct nfs4_sequence_data *calldata;
Andy Adamson's avatar
Andy Adamson committed
6057 6058 6059 6060
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SEQUENCE],
		.rpc_cred = cred,
	};
6061 6062 6063
	struct rpc_task_setup task_setup_data = {
		.rpc_client = clp->cl_rpcclient,
		.rpc_message = &msg,
6064
		.callback_ops = &nfs41_sequence_ops,
6065
		.flags = RPC_TASK_ASYNC | RPC_TASK_TIMEOUT,
6066
	};
Andy Adamson's avatar
Andy Adamson committed
6067

6068
	if (!atomic_inc_not_zero(&clp->cl_count))
6069
		return ERR_PTR(-EIO);
6070
	calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
6071
	if (calldata == NULL) {
6072
		nfs_put_client(clp);
6073
		return ERR_PTR(-ENOMEM);
Andy Adamson's avatar
Andy Adamson committed
6074
	}
6075
	nfs41_init_sequence(&calldata->args, &calldata->res, 0);
6076 6077
	if (is_privileged)
		nfs4_set_sequence_privileged(&calldata->args);
6078 6079 6080
	msg.rpc_argp = &calldata->args;
	msg.rpc_resp = &calldata->res;
	calldata->clp = clp;
6081
	task_setup_data.callback_data = calldata;
Andy Adamson's avatar
Andy Adamson committed
6082

6083 6084 6085
	return rpc_run_task(&task_setup_data);
}

6086
static int nfs41_proc_async_sequence(struct nfs_client *clp, struct rpc_cred *cred, unsigned renew_flags)
6087 6088 6089 6090
{
	struct rpc_task *task;
	int ret = 0;

6091
	if ((renew_flags & NFS4_RENEW_TIMEOUT) == 0)
6092
		return -EAGAIN;
6093
	task = _nfs41_proc_sequence(clp, cred, false);
6094 6095 6096
	if (IS_ERR(task))
		ret = PTR_ERR(task);
	else
6097
		rpc_put_task_async(task);
6098 6099 6100 6101 6102 6103 6104 6105 6106
	dprintk("<-- %s status=%d\n", __func__, ret);
	return ret;
}

static int nfs4_proc_sequence(struct nfs_client *clp, struct rpc_cred *cred)
{
	struct rpc_task *task;
	int ret;

6107
	task = _nfs41_proc_sequence(clp, cred, true);
6108 6109 6110 6111 6112
	if (IS_ERR(task)) {
		ret = PTR_ERR(task);
		goto out;
	}
	ret = rpc_wait_for_completion_task(task);
6113 6114 6115 6116 6117
	if (!ret) {
		struct nfs4_sequence_res *res = task->tk_msg.rpc_resp;

		if (task->tk_status == 0)
			nfs41_handle_sequence_flag_errors(clp, res->sr_status_flags);
6118
		ret = task->tk_status;
6119
	}
6120 6121 6122 6123
	rpc_put_task(task);
out:
	dprintk("<-- %s status=%d\n", __func__, ret);
	return ret;
Andy Adamson's avatar
Andy Adamson committed
6124 6125
}

6126 6127 6128 6129 6130 6131 6132 6133 6134 6135
struct nfs4_reclaim_complete_data {
	struct nfs_client *clp;
	struct nfs41_reclaim_complete_args arg;
	struct nfs41_reclaim_complete_res res;
};

static void nfs4_reclaim_complete_prepare(struct rpc_task *task, void *data)
{
	struct nfs4_reclaim_complete_data *calldata = data;

6136 6137 6138 6139
	nfs41_setup_sequence(calldata->clp->cl_session,
			&calldata->arg.seq_args,
			&calldata->res.seq_res,
			task);
6140 6141
}

6142 6143 6144 6145 6146 6147 6148 6149 6150
static int nfs41_reclaim_complete_handle_errors(struct rpc_task *task, struct nfs_client *clp)
{
	switch(task->tk_status) {
	case 0:
	case -NFS4ERR_COMPLETE_ALREADY:
	case -NFS4ERR_WRONG_CRED: /* What to do here? */
		break;
	case -NFS4ERR_DELAY:
		rpc_delay(task, NFS4_POLL_RETRY_MAX);
6151 6152
		/* fall through */
	case -NFS4ERR_RETRY_UNCACHED_REP:
6153 6154
		return -EAGAIN;
	default:
6155
		nfs4_schedule_lease_recovery(clp);
6156 6157 6158 6159
	}
	return 0;
}

6160 6161 6162 6163 6164 6165 6166
static void nfs4_reclaim_complete_done(struct rpc_task *task, void *data)
{
	struct nfs4_reclaim_complete_data *calldata = data;
	struct nfs_client *clp = calldata->clp;
	struct nfs4_sequence_res *res = &calldata->res.seq_res;

	dprintk("--> %s\n", __func__);
6167 6168
	if (!nfs41_sequence_done(task, res))
		return;
6169

6170 6171 6172 6173
	if (nfs41_reclaim_complete_handle_errors(task, clp) == -EAGAIN) {
		rpc_restart_call_prepare(task);
		return;
	}
6174 6175 6176 6177 6178 6179 6180 6181 6182 6183 6184 6185 6186 6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199 6200 6201 6202 6203 6204 6205 6206 6207 6208
	dprintk("<-- %s\n", __func__);
}

static void nfs4_free_reclaim_complete_data(void *data)
{
	struct nfs4_reclaim_complete_data *calldata = data;

	kfree(calldata);
}

static const struct rpc_call_ops nfs4_reclaim_complete_call_ops = {
	.rpc_call_prepare = nfs4_reclaim_complete_prepare,
	.rpc_call_done = nfs4_reclaim_complete_done,
	.rpc_release = nfs4_free_reclaim_complete_data,
};

/*
 * Issue a global reclaim complete.
 */
static int nfs41_proc_reclaim_complete(struct nfs_client *clp)
{
	struct nfs4_reclaim_complete_data *calldata;
	struct rpc_task *task;
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_RECLAIM_COMPLETE],
	};
	struct rpc_task_setup task_setup_data = {
		.rpc_client = clp->cl_rpcclient,
		.rpc_message = &msg,
		.callback_ops = &nfs4_reclaim_complete_call_ops,
		.flags = RPC_TASK_ASYNC,
	};
	int status = -ENOMEM;

	dprintk("--> %s\n", __func__);
6209
	calldata = kzalloc(sizeof(*calldata), GFP_NOFS);
6210 6211 6212 6213 6214
	if (calldata == NULL)
		goto out;
	calldata->clp = clp;
	calldata->arg.one_fs = 0;

6215
	nfs41_init_sequence(&calldata->arg.seq_args, &calldata->res.seq_res, 0);
6216
	nfs4_set_sequence_privileged(&calldata->arg.seq_args);
6217 6218 6219 6220
	msg.rpc_argp = &calldata->arg;
	msg.rpc_resp = &calldata->res;
	task_setup_data.callback_data = calldata;
	task = rpc_run_task(&task_setup_data);
6221
	if (IS_ERR(task)) {
6222
		status = PTR_ERR(task);
6223 6224
		goto out;
	}
6225 6226 6227
	status = nfs4_wait_for_completion_rpc_task(task);
	if (status == 0)
		status = task->tk_status;
6228
	rpc_put_task(task);
6229
	return 0;
6230 6231 6232 6233
out:
	dprintk("<-- %s status=%d\n", __func__, status);
	return status;
}
6234 6235 6236 6237 6238

static void
nfs4_layoutget_prepare(struct rpc_task *task, void *calldata)
{
	struct nfs4_layoutget *lgp = calldata;
6239
	struct nfs_server *server = NFS_SERVER(lgp->args.inode);
6240
	struct nfs4_session *session = nfs4_get_session(server);
6241 6242

	dprintk("--> %s\n", __func__);
6243 6244 6245 6246 6247
	/* Note the is a race here, where a CB_LAYOUTRECALL can come in
	 * right now covering the LAYOUTGET we are about to send.
	 * However, that is not so catastrophic, and there seems
	 * to be no way to prevent it completely.
	 */
6248
	if (nfs41_setup_sequence(session, &lgp->args.seq_args,
6249
				&lgp->res.seq_res, task))
6250
		return;
6251 6252 6253 6254 6255
	if (pnfs_choose_layoutget_stateid(&lgp->args.stateid,
					  NFS_I(lgp->args.inode)->layout,
					  lgp->args.ctx->state)) {
		rpc_exit(task, NFS4_OK);
	}
6256 6257 6258 6259 6260
}

static void nfs4_layoutget_done(struct rpc_task *task, void *calldata)
{
	struct nfs4_layoutget *lgp = calldata;
6261 6262 6263 6264
	struct inode *inode = lgp->args.inode;
	struct nfs_server *server = NFS_SERVER(inode);
	struct pnfs_layout_hdr *lo;
	struct nfs4_state *state = NULL;
6265
	unsigned long timeo, now, giveup;
6266

6267
	dprintk("--> %s tk_status => %d\n", __func__, -task->tk_status);
6268

6269
	if (!nfs41_sequence_done(task, &lgp->res.seq_res))
6270
		goto out;
6271 6272 6273

	switch (task->tk_status) {
	case 0:
6274
		goto out;
6275 6276 6277 6278
	/*
	 * NFS4ERR_LAYOUTTRYLATER is a conflict with another client
	 * (or clients) writing to the same RAID stripe
	 */
6279
	case -NFS4ERR_LAYOUTTRYLATER:
6280 6281 6282 6283
	/*
	 * NFS4ERR_RECALLCONFLICT is when conflict with self (must recall
	 * existing layout before getting a new one).
	 */
6284
	case -NFS4ERR_RECALLCONFLICT:
6285 6286
		timeo = rpc_get_timeout(task->tk_client);
		giveup = lgp->args.timestamp + timeo;
6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306
		now = jiffies;
		if (time_after(giveup, now)) {
			unsigned long delay;

			/* Delay for:
			 * - Not less then NFS4_POLL_RETRY_MIN.
			 * - One last time a jiffie before we give up
			 * - exponential backoff (time_now minus start_attempt)
			 */
			delay = max_t(unsigned long, NFS4_POLL_RETRY_MIN,
				    min((giveup - now - 1),
					now - lgp->args.timestamp));

			dprintk("%s: NFS4ERR_RECALLCONFLICT waiting %lu\n",
				__func__, delay);
			rpc_delay(task, delay);
			task->tk_status = 0;
			rpc_restart_call_prepare(task);
			goto out; /* Do not call nfs4_async_handle_error() */
		}
6307 6308 6309 6310 6311 6312 6313 6314 6315 6316 6317 6318 6319 6320 6321 6322 6323
		break;
	case -NFS4ERR_EXPIRED:
	case -NFS4ERR_BAD_STATEID:
		spin_lock(&inode->i_lock);
		lo = NFS_I(inode)->layout;
		if (!lo || list_empty(&lo->plh_segs)) {
			spin_unlock(&inode->i_lock);
			/* If the open stateid was bad, then recover it. */
			state = lgp->args.ctx->state;
		} else {
			LIST_HEAD(head);

			pnfs_mark_matching_lsegs_invalid(lo, &head, NULL);
			spin_unlock(&inode->i_lock);
			/* Mark the bad layout state as invalid, then
			 * retry using the open stateid. */
			pnfs_free_lseg_list(&head);
6324 6325
		}
	}
6326 6327 6328
	if (nfs4_async_handle_error(task, server, state) == -EAGAIN)
		rpc_restart_call_prepare(task);
out:
6329 6330 6331
	dprintk("<-- %s\n", __func__);
}

6332 6333 6334 6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345 6346 6347 6348 6349 6350 6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362 6363 6364 6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375
static size_t max_response_pages(struct nfs_server *server)
{
	u32 max_resp_sz = server->nfs_client->cl_session->fc_attrs.max_resp_sz;
	return nfs_page_array_len(0, max_resp_sz);
}

static void nfs4_free_pages(struct page **pages, size_t size)
{
	int i;

	if (!pages)
		return;

	for (i = 0; i < size; i++) {
		if (!pages[i])
			break;
		__free_page(pages[i]);
	}
	kfree(pages);
}

static struct page **nfs4_alloc_pages(size_t size, gfp_t gfp_flags)
{
	struct page **pages;
	int i;

	pages = kcalloc(size, sizeof(struct page *), gfp_flags);
	if (!pages) {
		dprintk("%s: can't alloc array of %zu pages\n", __func__, size);
		return NULL;
	}

	for (i = 0; i < size; i++) {
		pages[i] = alloc_page(gfp_flags);
		if (!pages[i]) {
			dprintk("%s: failed to allocate page\n", __func__);
			nfs4_free_pages(pages, size);
			return NULL;
		}
	}

	return pages;
}

6376 6377 6378
static void nfs4_layoutget_release(void *calldata)
{
	struct nfs4_layoutget *lgp = calldata;
6379 6380
	struct inode *inode = lgp->args.inode;
	struct nfs_server *server = NFS_SERVER(inode);
6381
	size_t max_pages = max_response_pages(server);
6382 6383

	dprintk("--> %s\n", __func__);
6384
	nfs4_free_pages(lgp->args.layout.pages, max_pages);
6385
	pnfs_put_layout_hdr(NFS_I(inode)->layout);
6386 6387 6388 6389 6390 6391 6392 6393 6394 6395 6396
	put_nfs_open_context(lgp->args.ctx);
	kfree(calldata);
	dprintk("<-- %s\n", __func__);
}

static const struct rpc_call_ops nfs4_layoutget_call_ops = {
	.rpc_call_prepare = nfs4_layoutget_prepare,
	.rpc_call_done = nfs4_layoutget_done,
	.rpc_release = nfs4_layoutget_release,
};

6397 6398
struct pnfs_layout_segment *
nfs4_proc_layoutget(struct nfs4_layoutget *lgp, gfp_t gfp_flags)
6399
{
6400 6401
	struct inode *inode = lgp->args.inode;
	struct nfs_server *server = NFS_SERVER(inode);
6402
	size_t max_pages = max_response_pages(server);
6403 6404 6405 6406 6407 6408 6409 6410 6411 6412 6413 6414 6415
	struct rpc_task *task;
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTGET],
		.rpc_argp = &lgp->args,
		.rpc_resp = &lgp->res,
	};
	struct rpc_task_setup task_setup_data = {
		.rpc_client = server->client,
		.rpc_message = &msg,
		.callback_ops = &nfs4_layoutget_call_ops,
		.callback_data = lgp,
		.flags = RPC_TASK_ASYNC,
	};
6416
	struct pnfs_layout_segment *lseg = NULL;
6417 6418 6419 6420
	int status = 0;

	dprintk("--> %s\n", __func__);

6421 6422 6423
	/* nfs4_layoutget_release calls pnfs_put_layout_hdr */
	pnfs_get_layout_hdr(NFS_I(inode)->layout);

6424 6425 6426
	lgp->args.layout.pages = nfs4_alloc_pages(max_pages, gfp_flags);
	if (!lgp->args.layout.pages) {
		nfs4_layoutget_release(lgp);
6427
		return ERR_PTR(-ENOMEM);
6428 6429
	}
	lgp->args.layout.pglen = max_pages * PAGE_SIZE;
6430
	lgp->args.timestamp = jiffies;
6431

6432
	lgp->res.layoutp = &lgp->args.layout;
6433
	lgp->res.seq_res.sr_slot = NULL;
6434
	nfs41_init_sequence(&lgp->args.seq_args, &lgp->res.seq_res, 0);
6435

6436 6437
	task = rpc_run_task(&task_setup_data);
	if (IS_ERR(task))
6438
		return ERR_CAST(task);
6439
	status = nfs4_wait_for_completion_rpc_task(task);
6440 6441
	if (status == 0)
		status = task->tk_status;
6442 6443
	/* if layoutp->len is 0, nfs4_layoutget_prepare called rpc_exit */
	if (status == 0 && lgp->res.layoutp->len)
6444
		lseg = pnfs_layout_process(lgp);
6445 6446
	rpc_put_task(task);
	dprintk("<-- %s status=%d\n", __func__, status);
6447 6448 6449
	if (status)
		return ERR_PTR(status);
	return lseg;
6450 6451
}

Benny Halevy's avatar
Benny Halevy committed
6452 6453 6454 6455 6456 6457
static void
nfs4_layoutreturn_prepare(struct rpc_task *task, void *calldata)
{
	struct nfs4_layoutreturn *lrp = calldata;

	dprintk("--> %s\n", __func__);
6458 6459 6460 6461
	nfs41_setup_sequence(lrp->clp->cl_session,
			&lrp->args.seq_args,
			&lrp->res.seq_res,
			task);
Benny Halevy's avatar
Benny Halevy committed
6462 6463 6464 6465 6466 6467 6468 6469 6470
}

static void nfs4_layoutreturn_done(struct rpc_task *task, void *calldata)
{
	struct nfs4_layoutreturn *lrp = calldata;
	struct nfs_server *server;

	dprintk("--> %s\n", __func__);

6471
	if (!nfs41_sequence_done(task, &lrp->res.seq_res))
Benny Halevy's avatar
Benny Halevy committed
6472 6473 6474 6475
		return;

	server = NFS_SERVER(lrp->args.inode);
	if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {
6476
		rpc_restart_call_prepare(task);
Benny Halevy's avatar
Benny Halevy committed
6477 6478 6479 6480 6481 6482 6483 6484
		return;
	}
	dprintk("<-- %s\n", __func__);
}

static void nfs4_layoutreturn_release(void *calldata)
{
	struct nfs4_layoutreturn *lrp = calldata;
6485
	struct pnfs_layout_hdr *lo = lrp->args.layout;
Benny Halevy's avatar
Benny Halevy committed
6486 6487

	dprintk("--> %s\n", __func__);
6488 6489 6490 6491 6492
	spin_lock(&lo->plh_inode->i_lock);
	if (lrp->res.lrs_present)
		pnfs_set_layout_stateid(lo, &lrp->res.stateid, true);
	lo->plh_block_lgets--;
	spin_unlock(&lo->plh_inode->i_lock);
6493
	pnfs_put_layout_hdr(lrp->args.layout);
Benny Halevy's avatar
Benny Halevy committed
6494 6495 6496 6497 6498 6499 6500 6501 6502 6503 6504 6505 6506 6507 6508 6509 6510 6511 6512 6513 6514 6515 6516 6517 6518 6519 6520
	kfree(calldata);
	dprintk("<-- %s\n", __func__);
}

static const struct rpc_call_ops nfs4_layoutreturn_call_ops = {
	.rpc_call_prepare = nfs4_layoutreturn_prepare,
	.rpc_call_done = nfs4_layoutreturn_done,
	.rpc_release = nfs4_layoutreturn_release,
};

int nfs4_proc_layoutreturn(struct nfs4_layoutreturn *lrp)
{
	struct rpc_task *task;
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTRETURN],
		.rpc_argp = &lrp->args,
		.rpc_resp = &lrp->res,
	};
	struct rpc_task_setup task_setup_data = {
		.rpc_client = lrp->clp->cl_rpcclient,
		.rpc_message = &msg,
		.callback_ops = &nfs4_layoutreturn_call_ops,
		.callback_data = lrp,
	};
	int status;

	dprintk("--> %s\n", __func__);
6521
	nfs41_init_sequence(&lrp->args.seq_args, &lrp->res.seq_res, 1);
Benny Halevy's avatar
Benny Halevy committed
6522 6523 6524 6525 6526 6527 6528 6529 6530
	task = rpc_run_task(&task_setup_data);
	if (IS_ERR(task))
		return PTR_ERR(task);
	status = task->tk_status;
	dprintk("<-- %s status=%d\n", __func__, status);
	rpc_put_task(task);
	return status;
}

Andy Adamson's avatar
Andy Adamson committed
6531 6532 6533 6534 6535 6536 6537 6538 6539 6540 6541 6542 6543 6544 6545 6546 6547 6548 6549 6550 6551 6552 6553 6554 6555 6556 6557 6558 6559 6560 6561 6562 6563 6564 6565 6566 6567 6568 6569 6570 6571 6572 6573 6574 6575 6576 6577 6578
/*
 * Retrieve the list of Data Server devices from the MDS.
 */
static int _nfs4_getdevicelist(struct nfs_server *server,
				    const struct nfs_fh *fh,
				    struct pnfs_devicelist *devlist)
{
	struct nfs4_getdevicelist_args args = {
		.fh = fh,
		.layoutclass = server->pnfs_curr_ld->id,
	};
	struct nfs4_getdevicelist_res res = {
		.devlist = devlist,
	};
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICELIST],
		.rpc_argp = &args,
		.rpc_resp = &res,
	};
	int status;

	dprintk("--> %s\n", __func__);
	status = nfs4_call_sync(server->client, server, &msg, &args.seq_args,
				&res.seq_res, 0);
	dprintk("<-- %s status=%d\n", __func__, status);
	return status;
}

int nfs4_proc_getdevicelist(struct nfs_server *server,
			    const struct nfs_fh *fh,
			    struct pnfs_devicelist *devlist)
{
	struct nfs4_exception exception = { };
	int err;

	do {
		err = nfs4_handle_exception(server,
				_nfs4_getdevicelist(server, fh, devlist),
				&exception);
	} while (exception.retry);

	dprintk("%s: err=%d, num_devs=%u\n", __func__,
		err, devlist->num_devs);

	return err;
}
EXPORT_SYMBOL_GPL(nfs4_proc_getdevicelist);

6579 6580 6581 6582 6583 6584 6585 6586 6587 6588 6589 6590 6591 6592 6593 6594 6595
static int
_nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
{
	struct nfs4_getdeviceinfo_args args = {
		.pdev = pdev,
	};
	struct nfs4_getdeviceinfo_res res = {
		.pdev = pdev,
	};
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_GETDEVICEINFO],
		.rpc_argp = &args,
		.rpc_resp = &res,
	};
	int status;

	dprintk("--> %s\n", __func__);
6596
	status = nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
6597 6598 6599 6600 6601 6602 6603 6604 6605 6606 6607 6608 6609 6610 6611 6612 6613 6614 6615
	dprintk("<-- %s status=%d\n", __func__, status);

	return status;
}

int nfs4_proc_getdeviceinfo(struct nfs_server *server, struct pnfs_device *pdev)
{
	struct nfs4_exception exception = { };
	int err;

	do {
		err = nfs4_handle_exception(server,
					_nfs4_proc_getdeviceinfo(server, pdev),
					&exception);
	} while (exception.retry);
	return err;
}
EXPORT_SYMBOL_GPL(nfs4_proc_getdeviceinfo);

Andy Adamson's avatar
Andy Adamson committed
6616 6617 6618 6619
static void nfs4_layoutcommit_prepare(struct rpc_task *task, void *calldata)
{
	struct nfs4_layoutcommit_data *data = calldata;
	struct nfs_server *server = NFS_SERVER(data->args.inode);
6620
	struct nfs4_session *session = nfs4_get_session(server);
Andy Adamson's avatar
Andy Adamson committed
6621

6622 6623 6624 6625
	nfs41_setup_sequence(session,
			&data->args.seq_args,
			&data->res.seq_res,
			task);
Andy Adamson's avatar
Andy Adamson committed
6626 6627 6628 6629 6630 6631 6632 6633
}

static void
nfs4_layoutcommit_done(struct rpc_task *task, void *calldata)
{
	struct nfs4_layoutcommit_data *data = calldata;
	struct nfs_server *server = NFS_SERVER(data->args.inode);

6634
	if (!nfs41_sequence_done(task, &data->res.seq_res))
Andy Adamson's avatar
Andy Adamson committed
6635 6636 6637
		return;

	switch (task->tk_status) { /* Just ignore these failures */
6638 6639 6640 6641
	case -NFS4ERR_DELEG_REVOKED: /* layout was recalled */
	case -NFS4ERR_BADIOMODE:     /* no IOMODE_RW layout for range */
	case -NFS4ERR_BADLAYOUT:     /* no layout */
	case -NFS4ERR_GRACE:	    /* loca_recalim always false */
Andy Adamson's avatar
Andy Adamson committed
6642
		task->tk_status = 0;
6643 6644
		break;
	case 0:
Andy Adamson's avatar
Andy Adamson committed
6645 6646
		nfs_post_op_update_inode_force_wcc(data->args.inode,
						   data->res.fattr);
6647 6648 6649 6650 6651 6652 6653
		break;
	default:
		if (nfs4_async_handle_error(task, server, NULL) == -EAGAIN) {
			rpc_restart_call_prepare(task);
			return;
		}
	}
Andy Adamson's avatar
Andy Adamson committed
6654 6655 6656 6657 6658 6659
}

static void nfs4_layoutcommit_release(void *calldata)
{
	struct nfs4_layoutcommit_data *data = calldata;

Andy Adamson's avatar
Andy Adamson committed
6660
	pnfs_cleanup_layoutcommit(data);
Andy Adamson's avatar
Andy Adamson committed
6661 6662 6663 6664 6665 6666 6667 6668 6669 6670 6671
	put_rpccred(data->cred);
	kfree(data);
}

static const struct rpc_call_ops nfs4_layoutcommit_ops = {
	.rpc_call_prepare = nfs4_layoutcommit_prepare,
	.rpc_call_done = nfs4_layoutcommit_done,
	.rpc_release = nfs4_layoutcommit_release,
};

int
6672
nfs4_proc_layoutcommit(struct nfs4_layoutcommit_data *data, bool sync)
Andy Adamson's avatar
Andy Adamson committed
6673 6674 6675 6676 6677 6678 6679 6680 6681 6682 6683 6684 6685 6686 6687 6688 6689 6690 6691 6692 6693 6694 6695 6696
{
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_LAYOUTCOMMIT],
		.rpc_argp = &data->args,
		.rpc_resp = &data->res,
		.rpc_cred = data->cred,
	};
	struct rpc_task_setup task_setup_data = {
		.task = &data->task,
		.rpc_client = NFS_CLIENT(data->args.inode),
		.rpc_message = &msg,
		.callback_ops = &nfs4_layoutcommit_ops,
		.callback_data = data,
		.flags = RPC_TASK_ASYNC,
	};
	struct rpc_task *task;
	int status = 0;

	dprintk("NFS: %4d initiating layoutcommit call. sync %d "
		"lbw: %llu inode %lu\n",
		data->task.tk_pid, sync,
		data->args.lastbytewritten,
		data->args.inode->i_ino);

6697
	nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 1);
Andy Adamson's avatar
Andy Adamson committed
6698 6699 6700
	task = rpc_run_task(&task_setup_data);
	if (IS_ERR(task))
		return PTR_ERR(task);
6701
	if (sync == false)
Andy Adamson's avatar
Andy Adamson committed
6702 6703 6704 6705 6706 6707 6708 6709 6710 6711
		goto out;
	status = nfs4_wait_for_completion_rpc_task(task);
	if (status != 0)
		goto out;
	status = task->tk_status;
out:
	dprintk("%s: status %d\n", __func__, status);
	rpc_put_task(task);
	return status;
}
6712 6713 6714 6715 6716 6717 6718 6719 6720 6721 6722 6723 6724 6725 6726 6727 6728 6729 6730 6731 6732 6733 6734 6735 6736 6737 6738 6739 6740 6741

static int
_nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
		    struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)
{
	struct nfs41_secinfo_no_name_args args = {
		.style = SECINFO_STYLE_CURRENT_FH,
	};
	struct nfs4_secinfo_res res = {
		.flavors = flavors,
	};
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_SECINFO_NO_NAME],
		.rpc_argp = &args,
		.rpc_resp = &res,
	};
	return nfs4_call_sync(server->client, server, &msg, &args.seq_args, &res.seq_res, 0);
}

static int
nfs41_proc_secinfo_no_name(struct nfs_server *server, struct nfs_fh *fhandle,
			   struct nfs_fsinfo *info, struct nfs4_secinfo_flavors *flavors)
{
	struct nfs4_exception exception = { };
	int err;
	do {
		err = _nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);
		switch (err) {
		case 0:
		case -NFS4ERR_WRONGSEC:
6742
		case -ENOTSUPP:
6743
			goto out;
6744 6745 6746 6747
		default:
			err = nfs4_handle_exception(server, err, &exception);
		}
	} while (exception.retry);
6748
out:
6749 6750 6751 6752 6753 6754 6755 6756 6757 6758 6759 6760 6761 6762 6763 6764 6765 6766 6767 6768 6769 6770 6771 6772 6773
	return err;
}

static int
nfs41_find_root_sec(struct nfs_server *server, struct nfs_fh *fhandle,
		    struct nfs_fsinfo *info)
{
	int err;
	struct page *page;
	rpc_authflavor_t flavor;
	struct nfs4_secinfo_flavors *flavors;

	page = alloc_page(GFP_KERNEL);
	if (!page) {
		err = -ENOMEM;
		goto out;
	}

	flavors = page_address(page);
	err = nfs41_proc_secinfo_no_name(server, fhandle, info, flavors);

	/*
	 * Fall back on "guess and check" method if
	 * the server doesn't support SECINFO_NO_NAME
	 */
6774
	if (err == -NFS4ERR_WRONGSEC || err == -ENOTSUPP) {
6775 6776 6777 6778 6779 6780 6781 6782 6783 6784 6785 6786 6787 6788 6789 6790 6791
		err = nfs4_find_root_sec(server, fhandle, info);
		goto out_freepage;
	}
	if (err)
		goto out_freepage;

	flavor = nfs_find_best_sec(flavors);
	if (err == 0)
		err = nfs4_lookup_root_sec(server, fhandle, info, flavor);

out_freepage:
	put_page(page);
	if (err == -EACCES)
		return -EPERM;
out:
	return err;
}
6792 6793

static int _nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
6794 6795 6796
{
	int status;
	struct nfs41_test_stateid_args args = {
6797
		.stateid = stateid,
6798 6799 6800 6801 6802 6803 6804
	};
	struct nfs41_test_stateid_res res;
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_TEST_STATEID],
		.rpc_argp = &args,
		.rpc_resp = &res,
	};
6805

6806
	dprintk("NFS call  test_stateid %p\n", stateid);
6807
	nfs41_init_sequence(&args.seq_args, &res.seq_res, 0);
6808 6809 6810
	nfs4_set_sequence_privileged(&args.seq_args);
	status = nfs4_call_sync_sequence(server->client, server, &msg,
			&args.seq_args, &res.seq_res);
6811 6812
	if (status != NFS_OK) {
		dprintk("NFS reply test_stateid: failed, %d\n", status);
6813
		return status;
6814 6815
	}
	dprintk("NFS reply test_stateid: succeeded, %d\n", -res.status);
6816
	return -res.status;
6817 6818
}

6819 6820 6821 6822 6823 6824 6825 6826 6827 6828
/**
 * nfs41_test_stateid - perform a TEST_STATEID operation
 *
 * @server: server / transport on which to perform the operation
 * @stateid: state ID to test
 *
 * Returns NFS_OK if the server recognizes that "stateid" is valid.
 * Otherwise a negative NFS4ERR value is returned if the operation
 * failed or the state ID is not currently valid.
 */
6829
static int nfs41_test_stateid(struct nfs_server *server, nfs4_stateid *stateid)
6830 6831 6832 6833
{
	struct nfs4_exception exception = { };
	int err;
	do {
6834 6835 6836 6837
		err = _nfs41_test_stateid(server, stateid);
		if (err != -NFS4ERR_DELAY)
			break;
		nfs4_handle_exception(server, err, &exception);
6838 6839 6840
	} while (exception.retry);
	return err;
}
6841

6842 6843 6844
struct nfs_free_stateid_data {
	struct nfs_server *server;
	struct nfs41_free_stateid_args args;
6845
	struct nfs41_free_stateid_res res;
6846 6847 6848 6849 6850 6851 6852 6853 6854 6855 6856 6857 6858 6859 6860 6861 6862 6863 6864 6865 6866 6867 6868 6869 6870 6871 6872 6873 6874 6875 6876 6877 6878 6879 6880 6881 6882 6883 6884
};

static void nfs41_free_stateid_prepare(struct rpc_task *task, void *calldata)
{
	struct nfs_free_stateid_data *data = calldata;
	nfs41_setup_sequence(nfs4_get_session(data->server),
			&data->args.seq_args,
			&data->res.seq_res,
			task);
}

static void nfs41_free_stateid_done(struct rpc_task *task, void *calldata)
{
	struct nfs_free_stateid_data *data = calldata;

	nfs41_sequence_done(task, &data->res.seq_res);

	switch (task->tk_status) {
	case -NFS4ERR_DELAY:
		if (nfs4_async_handle_error(task, data->server, NULL) == -EAGAIN)
			rpc_restart_call_prepare(task);
	}
}

static void nfs41_free_stateid_release(void *calldata)
{
	kfree(calldata);
}

const struct rpc_call_ops nfs41_free_stateid_ops = {
	.rpc_call_prepare = nfs41_free_stateid_prepare,
	.rpc_call_done = nfs41_free_stateid_done,
	.rpc_release = nfs41_free_stateid_release,
};

static struct rpc_task *_nfs41_free_stateid(struct nfs_server *server,
		nfs4_stateid *stateid,
		bool privileged)
{
6885 6886 6887
	struct rpc_message msg = {
		.rpc_proc = &nfs4_procedures[NFSPROC4_CLNT_FREE_STATEID],
	};
6888 6889 6890 6891 6892 6893 6894
	struct rpc_task_setup task_setup = {
		.rpc_client = server->client,
		.rpc_message = &msg,
		.callback_ops = &nfs41_free_stateid_ops,
		.flags = RPC_TASK_ASYNC,
	};
	struct nfs_free_stateid_data *data;
6895

6896
	dprintk("NFS call  free_stateid %p\n", stateid);
6897 6898 6899 6900 6901 6902 6903 6904 6905 6906 6907 6908 6909 6910 6911
	data = kmalloc(sizeof(*data), GFP_NOFS);
	if (!data)
		return ERR_PTR(-ENOMEM);
	data->server = server;
	nfs4_stateid_copy(&data->args.stateid, stateid);

	task_setup.callback_data = data;

	msg.rpc_argp = &data->args;
	msg.rpc_resp = &data->res;
	nfs41_init_sequence(&data->args.seq_args, &data->res.seq_res, 0);
	if (privileged)
		nfs4_set_sequence_privileged(&data->args.seq_args);

	return rpc_run_task(&task_setup);
6912 6913
}

6914 6915 6916 6917 6918 6919 6920 6921 6922
/**
 * nfs41_free_stateid - perform a FREE_STATEID operation
 *
 * @server: server / transport on which to perform the operation
 * @stateid: state ID to release
 *
 * Returns NFS_OK if the server freed "stateid".  Otherwise a
 * negative NFS4ERR value is returned.
 */
6923
static int nfs41_free_stateid(struct nfs_server *server, nfs4_stateid *stateid)
6924
{
6925 6926 6927 6928 6929 6930 6931 6932 6933 6934 6935
	struct rpc_task *task;
	int ret;

	task = _nfs41_free_stateid(server, stateid, true);
	if (IS_ERR(task))
		return PTR_ERR(task);
	ret = rpc_wait_for_completion_task(task);
	if (!ret)
		ret = task->tk_status;
	rpc_put_task(task);
	return ret;
6936
}
6937

6938 6939 6940 6941 6942 6943 6944 6945 6946 6947 6948 6949
static int nfs41_free_lock_state(struct nfs_server *server, struct nfs4_lock_state *lsp)
{
	struct rpc_task *task;

	task = _nfs41_free_stateid(server, &lsp->ls_stateid, false);
	nfs4_free_lock_state(server, lsp);
	if (IS_ERR(task))
		return PTR_ERR(task);
	rpc_put_task(task);
	return 0;
}

6950 6951 6952
static bool nfs41_match_stateid(const nfs4_stateid *s1,
		const nfs4_stateid *s2)
{
6953
	if (memcmp(s1->other, s2->other, sizeof(s1->other)) != 0)
6954 6955
		return false;

6956
	if (s1->seqid == s2->seqid)
6957
		return true;
6958
	if (s1->seqid == 0 || s2->seqid == 0)
6959 6960 6961 6962 6963
		return true;

	return false;
}

6964 6965
#endif /* CONFIG_NFS_V4_1 */

6966 6967 6968
static bool nfs4_match_stateid(const nfs4_stateid *s1,
		const nfs4_stateid *s2)
{
6969
	return nfs4_stateid_match(s1, s2);
6970 6971 6972
}


6973
static const struct nfs4_state_recovery_ops nfs40_reboot_recovery_ops = {
6974
	.owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
6975
	.state_flag_bit	= NFS_STATE_RECLAIM_REBOOT,
Linus Torvalds's avatar
Linus Torvalds committed
6976 6977
	.recover_open	= nfs4_open_reclaim,
	.recover_lock	= nfs4_lock_reclaim,
6978
	.establish_clid = nfs4_init_clientid,
6979
	.get_clid_cred	= nfs4_get_setclientid_cred,
6980
	.detect_trunking = nfs40_discover_server_trunking,
Linus Torvalds's avatar
Linus Torvalds committed
6981 6982
};

6983
#if defined(CONFIG_NFS_V4_1)
6984
static const struct nfs4_state_recovery_ops nfs41_reboot_recovery_ops = {
6985 6986 6987 6988
	.owner_flag_bit = NFS_OWNER_RECLAIM_REBOOT,
	.state_flag_bit	= NFS_STATE_RECLAIM_REBOOT,
	.recover_open	= nfs4_open_reclaim,
	.recover_lock	= nfs4_lock_reclaim,
6989
	.establish_clid = nfs41_init_clientid,
6990
	.get_clid_cred	= nfs4_get_exchange_id_cred,
6991
	.reclaim_complete = nfs41_proc_reclaim_complete,
6992
	.detect_trunking = nfs41_discover_server_trunking,
6993 6994 6995
};
#endif /* CONFIG_NFS_V4_1 */

6996
static const struct nfs4_state_recovery_ops nfs40_nograce_recovery_ops = {
6997 6998
	.owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
	.state_flag_bit	= NFS_STATE_RECLAIM_NOGRACE,
6999
	.recover_open	= nfs40_open_expired,
7000 7001
	.recover_lock	= nfs4_lock_expired,
	.establish_clid = nfs4_init_clientid,
7002
	.get_clid_cred	= nfs4_get_setclientid_cred,
7003 7004 7005
};

#if defined(CONFIG_NFS_V4_1)
7006
static const struct nfs4_state_recovery_ops nfs41_nograce_recovery_ops = {
7007
	.owner_flag_bit = NFS_OWNER_RECLAIM_NOGRACE,
7008
	.state_flag_bit	= NFS_STATE_RECLAIM_NOGRACE,
7009 7010
	.recover_open	= nfs41_open_expired,
	.recover_lock	= nfs41_lock_expired,
7011
	.establish_clid = nfs41_init_clientid,
7012
	.get_clid_cred	= nfs4_get_exchange_id_cred,
Linus Torvalds's avatar
Linus Torvalds committed
7013
};
7014
#endif /* CONFIG_NFS_V4_1 */
Linus Torvalds's avatar
Linus Torvalds committed
7015

7016
static const struct nfs4_state_maintenance_ops nfs40_state_renewal_ops = {
Benny Halevy's avatar
Benny Halevy committed
7017
	.sched_state_renewal = nfs4_proc_async_renew,
7018
	.get_state_renewal_cred_locked = nfs4_get_renew_cred_locked,
7019
	.renew_lease = nfs4_proc_renew,
Benny Halevy's avatar
Benny Halevy committed
7020 7021 7022
};

#if defined(CONFIG_NFS_V4_1)
7023
static const struct nfs4_state_maintenance_ops nfs41_state_renewal_ops = {
Benny Halevy's avatar
Benny Halevy committed
7024
	.sched_state_renewal = nfs41_proc_async_sequence,
7025
	.get_state_renewal_cred_locked = nfs4_get_machine_cred_locked,
7026
	.renew_lease = nfs4_proc_sequence,
Benny Halevy's avatar
Benny Halevy committed
7027 7028 7029
};
#endif

7030 7031
static const struct nfs4_minor_version_ops nfs_v4_0_minor_ops = {
	.minor_version = 0,
7032 7033 7034 7035
	.init_caps = NFS_CAP_READDIRPLUS
		| NFS_CAP_ATOMIC_OPEN
		| NFS_CAP_CHANGE_ATTR
		| NFS_CAP_POSIX_LOCK,
7036
	.call_sync = _nfs4_call_sync,
7037
	.match_stateid = nfs4_match_stateid,
7038
	.find_root_sec = nfs4_find_root_sec,
7039
	.free_lock_state = nfs4_release_lockowner,
7040 7041 7042
	.reboot_recovery_ops = &nfs40_reboot_recovery_ops,
	.nograce_recovery_ops = &nfs40_nograce_recovery_ops,
	.state_renewal_ops = &nfs40_state_renewal_ops,
7043 7044 7045 7046 7047
};

#if defined(CONFIG_NFS_V4_1)
static const struct nfs4_minor_version_ops nfs_v4_1_minor_ops = {
	.minor_version = 1,
7048 7049 7050
	.init_caps = NFS_CAP_READDIRPLUS
		| NFS_CAP_ATOMIC_OPEN
		| NFS_CAP_CHANGE_ATTR
7051
		| NFS_CAP_POSIX_LOCK
7052 7053
		| NFS_CAP_STATEID_NFSV41
		| NFS_CAP_ATOMIC_OPEN_V1,
7054
	.call_sync = nfs4_call_sync_sequence,
7055
	.match_stateid = nfs41_match_stateid,
7056
	.find_root_sec = nfs41_find_root_sec,
7057
	.free_lock_state = nfs41_free_lock_state,
7058 7059 7060
	.reboot_recovery_ops = &nfs41_reboot_recovery_ops,
	.nograce_recovery_ops = &nfs41_nograce_recovery_ops,
	.state_renewal_ops = &nfs41_state_renewal_ops,
7061 7062 7063 7064 7065 7066 7067 7068 7069 7070
};
#endif

const struct nfs4_minor_version_ops *nfs_v4_minor_ops[] = {
	[0] = &nfs_v4_0_minor_ops,
#if defined(CONFIG_NFS_V4_1)
	[1] = &nfs_v4_1_minor_ops,
#endif
};

7071 7072 7073 7074 7075 7076 7077 7078 7079 7080 7081 7082 7083 7084 7085 7086 7087 7088 7089 7090
const struct inode_operations nfs4_dir_inode_operations = {
	.create		= nfs_create,
	.lookup		= nfs_lookup,
	.atomic_open	= nfs_atomic_open,
	.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,
	.getxattr	= generic_getxattr,
	.setxattr	= generic_setxattr,
	.listxattr	= generic_listxattr,
	.removexattr	= generic_removexattr,
};

7091
static const struct inode_operations nfs4_file_inode_operations = {
7092 7093 7094
	.permission	= nfs_permission,
	.getattr	= nfs_getattr,
	.setattr	= nfs_setattr,
7095 7096 7097 7098
	.getxattr	= generic_getxattr,
	.setxattr	= generic_setxattr,
	.listxattr	= generic_listxattr,
	.removexattr	= generic_removexattr,
7099 7100
};

7101
const struct nfs_rpc_ops nfs_v4_clientops = {
Linus Torvalds's avatar
Linus Torvalds committed
7102 7103 7104
	.version	= 4,			/* protocol version */
	.dentry_ops	= &nfs4_dentry_operations,
	.dir_inode_ops	= &nfs4_dir_inode_operations,
7105
	.file_inode_ops	= &nfs4_file_inode_operations,
7106
	.file_ops	= &nfs4_file_operations,
Linus Torvalds's avatar
Linus Torvalds committed
7107
	.getroot	= nfs4_proc_get_root,
7108
	.submount	= nfs4_submount,
7109
	.try_mount	= nfs4_try_mount,
Linus Torvalds's avatar
Linus Torvalds committed
7110 7111 7112 7113 7114 7115 7116 7117
	.getattr	= nfs4_proc_getattr,
	.setattr	= nfs4_proc_setattr,
	.lookup		= nfs4_proc_lookup,
	.access		= nfs4_proc_access,
	.readlink	= nfs4_proc_readlink,
	.create		= nfs4_proc_create,
	.remove		= nfs4_proc_remove,
	.unlink_setup	= nfs4_proc_unlink_setup,
7118
	.unlink_rpc_prepare = nfs4_proc_unlink_rpc_prepare,
Linus Torvalds's avatar
Linus Torvalds committed
7119 7120
	.unlink_done	= nfs4_proc_unlink_done,
	.rename		= nfs4_proc_rename,
7121
	.rename_setup	= nfs4_proc_rename_setup,
7122
	.rename_rpc_prepare = nfs4_proc_rename_rpc_prepare,
7123
	.rename_done	= nfs4_proc_rename_done,
Linus Torvalds's avatar
Linus Torvalds committed
7124 7125 7126 7127 7128 7129 7130 7131 7132
	.link		= nfs4_proc_link,
	.symlink	= nfs4_proc_symlink,
	.mkdir		= nfs4_proc_mkdir,
	.rmdir		= nfs4_proc_remove,
	.readdir	= nfs4_proc_readdir,
	.mknod		= nfs4_proc_mknod,
	.statfs		= nfs4_proc_statfs,
	.fsinfo		= nfs4_proc_fsinfo,
	.pathconf	= nfs4_proc_pathconf,
7133
	.set_capabilities = nfs4_server_capabilities,
Linus Torvalds's avatar
Linus Torvalds committed
7134 7135
	.decode_dirent	= nfs4_decode_dirent,
	.read_setup	= nfs4_proc_read_setup,
7136
	.read_pageio_init = pnfs_pageio_init_read,
7137
	.read_rpc_prepare = nfs4_proc_read_rpc_prepare,
7138
	.read_done	= nfs4_read_done,
Linus Torvalds's avatar
Linus Torvalds committed
7139
	.write_setup	= nfs4_proc_write_setup,
7140
	.write_pageio_init = pnfs_pageio_init_write,
7141
	.write_rpc_prepare = nfs4_proc_write_rpc_prepare,
7142
	.write_done	= nfs4_write_done,
Linus Torvalds's avatar
Linus Torvalds committed
7143
	.commit_setup	= nfs4_proc_commit_setup,
7144
	.commit_rpc_prepare = nfs4_proc_commit_rpc_prepare,
7145
	.commit_done	= nfs4_commit_done,
Linus Torvalds's avatar
Linus Torvalds committed
7146
	.lock		= nfs4_proc_lock,
7147
	.clear_acl_cache = nfs4_zap_acl_attr,
Trond Myklebust's avatar
Trond Myklebust committed
7148
	.close_context  = nfs4_close_context,
7149
	.open_context	= nfs4_atomic_open,
7150
	.have_delegation = nfs4_have_delegation,
7151
	.return_delegation = nfs4_inode_return_delegation,
7152
	.alloc_client	= nfs4_alloc_client,
7153
	.init_client	= nfs4_init_client,
7154
	.free_client	= nfs4_free_client,
7155 7156
	.create_server	= nfs4_create_server,
	.clone_server	= nfs_clone_server,
Linus Torvalds's avatar
Linus Torvalds committed
7157 7158
};

7159 7160 7161 7162 7163 7164 7165 7166 7167 7168 7169 7170
static const struct xattr_handler nfs4_xattr_nfs4_acl_handler = {
	.prefix	= XATTR_NAME_NFSV4_ACL,
	.list	= nfs4_xattr_list_nfs4_acl,
	.get	= nfs4_xattr_get_nfs4_acl,
	.set	= nfs4_xattr_set_nfs4_acl,
};

const struct xattr_handler *nfs4_xattr_handlers[] = {
	&nfs4_xattr_nfs4_acl_handler,
	NULL
};

Linus Torvalds's avatar
Linus Torvalds committed
7171 7172 7173 7174 7175
/*
 * Local variables:
 *  c-basic-offset: 8
 * End:
 */