1/*
   2 * linux/fs/nfs/delegation.c
   3 *
   4 * Copyright (C) 2004 Trond Myklebust
   5 *
   6 * NFS file delegation management
   7 *
   8 */
   9#include <linux/completion.h>
  10#include <linux/kthread.h>
  11#include <linux/module.h>
  12#include <linux/sched.h>
  13#include <linux/slab.h>
  14#include <linux/spinlock.h>
 
  15
  16#include <linux/nfs4.h>
  17#include <linux/nfs_fs.h>
  18#include <linux/nfs_xdr.h>
  19
  20#include "nfs4_fs.h"
 
  21#include "delegation.h"
  22#include "internal.h"
  23#include "nfs4trace.h"
  24
  25static void nfs_free_delegation(struct nfs_delegation *delegation)
 
 
 
 
 
  26{
  27	if (delegation->cred) {
  28		put_rpccred(delegation->cred);
  29		delegation->cred = NULL;
  30	}
  31	kfree_rcu(delegation, rcu);
  32}
  33
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
  34/**
  35 * nfs_mark_delegation_referenced - set delegation's REFERENCED flag
  36 * @delegation: delegation to process
  37 *
  38 */
  39void nfs_mark_delegation_referenced(struct nfs_delegation *delegation)
  40{
  41	set_bit(NFS_DELEGATION_REFERENCED, &delegation->flags);
  42}
  43
 
 
 
 
 
 
 
  44static bool
  45nfs4_is_valid_delegation(const struct nfs_delegation *delegation,
  46		fmode_t flags)
  47{
  48	if (delegation != NULL && (delegation->type & flags) == flags &&
  49	    !test_bit(NFS_DELEGATION_REVOKED, &delegation->flags) &&
  50	    !test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
  51		return true;
  52	return false;
  53}
  54
 
 
 
 
 
 
 
 
 
 
  55static int
  56nfs4_do_check_delegation(struct inode *inode, fmode_t flags, bool mark)
  57{
  58	struct nfs_delegation *delegation;
  59	int ret = 0;
  60
  61	flags &= FMODE_READ|FMODE_WRITE;
  62	rcu_read_lock();
  63	delegation = rcu_dereference(NFS_I(inode)->delegation);
  64	if (nfs4_is_valid_delegation(delegation, flags)) {
  65		if (mark)
  66			nfs_mark_delegation_referenced(delegation);
  67		ret = 1;
  68	}
  69	rcu_read_unlock();
  70	return ret;
  71}
  72/**
  73 * nfs_have_delegation - check if inode has a delegation, mark it
  74 * NFS_DELEGATION_REFERENCED if there is one.
  75 * @inode: inode to check
  76 * @flags: delegation types to check for
  77 *
  78 * Returns one if inode has the indicated delegation, otherwise zero.
  79 */
  80int nfs4_have_delegation(struct inode *inode, fmode_t flags)
  81{
  82	return nfs4_do_check_delegation(inode, flags, true);
  83}
  84
  85/*
  86 * nfs4_check_delegation - check if inode has a delegation, do not mark
  87 * NFS_DELEGATION_REFERENCED if it has one.
  88 */
  89int nfs4_check_delegation(struct inode *inode, fmode_t flags)
  90{
  91	return nfs4_do_check_delegation(inode, flags, false);
  92}
  93
  94static int nfs_delegation_claim_locks(struct nfs_open_context *ctx, struct nfs4_state *state, const nfs4_stateid *stateid)
  95{
  96	struct inode *inode = state->inode;
  97	struct file_lock *fl;
  98	struct file_lock_context *flctx = inode->i_flctx;
  99	struct list_head *list;
 100	int status = 0;
 101
 102	if (flctx == NULL)
 103		goto out;
 104
 105	list = &flctx->flc_posix;
 106	spin_lock(&flctx->flc_lock);
 107restart:
 108	list_for_each_entry(fl, list, fl_list) {
 109		if (nfs_file_open_context(fl->fl_file) != ctx)
 110			continue;
 111		spin_unlock(&flctx->flc_lock);
 112		status = nfs4_lock_delegation_recall(fl, state, stateid);
 113		if (status < 0)
 114			goto out;
 115		spin_lock(&flctx->flc_lock);
 116	}
 117	if (list == &flctx->flc_posix) {
 118		list = &flctx->flc_flock;
 119		goto restart;
 120	}
 121	spin_unlock(&flctx->flc_lock);
 122out:
 123	return status;
 124}
 125
 126static int nfs_delegation_claim_opens(struct inode *inode,
 127		const nfs4_stateid *stateid, fmode_t type)
 128{
 129	struct nfs_inode *nfsi = NFS_I(inode);
 130	struct nfs_open_context *ctx;
 131	struct nfs4_state_owner *sp;
 132	struct nfs4_state *state;
 133	unsigned int seq;
 134	int err;
 135
 136again:
 137	spin_lock(&inode->i_lock);
 138	list_for_each_entry(ctx, &nfsi->open_files, list) {
 139		state = ctx->state;
 140		if (state == NULL)
 141			continue;
 142		if (!test_bit(NFS_DELEGATED_STATE, &state->flags))
 143			continue;
 144		if (!nfs4_valid_open_stateid(state))
 145			continue;
 146		if (!nfs4_stateid_match(&state->stateid, stateid))
 147			continue;
 148		get_nfs_open_context(ctx);
 149		spin_unlock(&inode->i_lock);
 
 150		sp = state->owner;
 151		/* Block nfs4_proc_unlck */
 152		mutex_lock(&sp->so_delegreturn_mutex);
 153		seq = raw_seqcount_begin(&sp->so_reclaim_seqcount);
 154		err = nfs4_open_delegation_recall(ctx, state, stateid, type);
 155		if (!err)
 156			err = nfs_delegation_claim_locks(ctx, state, stateid);
 157		if (!err && read_seqcount_retry(&sp->so_reclaim_seqcount, seq))
 158			err = -EAGAIN;
 159		mutex_unlock(&sp->so_delegreturn_mutex);
 160		put_nfs_open_context(ctx);
 161		if (err != 0)
 162			return err;
 163		goto again;
 164	}
 165	spin_unlock(&inode->i_lock);
 166	return 0;
 167}
 168
 169/**
 170 * nfs_inode_reclaim_delegation - process a delegation reclaim request
 171 * @inode: inode to process
 172 * @cred: credential to use for request
 173 * @res: new delegation state from server
 
 
 174 *
 175 */
 176void nfs_inode_reclaim_delegation(struct inode *inode, struct rpc_cred *cred,
 177				  struct nfs_openres *res)
 
 178{
 179	struct nfs_delegation *delegation;
 180	struct rpc_cred *oldcred = NULL;
 181
 182	rcu_read_lock();
 183	delegation = rcu_dereference(NFS_I(inode)->delegation);
 184	if (delegation != NULL) {
 185		spin_lock(&delegation->lock);
 186		if (delegation->inode != NULL) {
 187			nfs4_stateid_copy(&delegation->stateid, &res->delegation);
 188			delegation->type = res->delegation_type;
 189			delegation->pagemod_limit = res->pagemod_limit;
 190			oldcred = delegation->cred;
 191			delegation->cred = get_rpccred(cred);
 192			clear_bit(NFS_DELEGATION_NEED_RECLAIM,
 193				  &delegation->flags);
 194			spin_unlock(&delegation->lock);
 195			rcu_read_unlock();
 196			put_rpccred(oldcred);
 197			trace_nfs4_reclaim_delegation(inode, res->delegation_type);
 198			return;
 199		}
 200		/* We appear to have raced with a delegation return. */
 201		spin_unlock(&delegation->lock);
 
 
 
 
 
 
 
 202	}
 203	rcu_read_unlock();
 204	nfs_inode_set_delegation(inode, cred, res);
 205}
 206
 207static int nfs_do_return_delegation(struct inode *inode, struct nfs_delegation *delegation, int issync)
 208{
 
 209	int res = 0;
 210
 211	if (!test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
 212		res = nfs4_proc_delegreturn(inode,
 213				delegation->cred,
 
 
 214				&delegation->stateid,
 215				issync);
 216	nfs_free_delegation(delegation);
 
 217	return res;
 218}
 219
 220static struct inode *nfs_delegation_grab_inode(struct nfs_delegation *delegation)
 221{
 222	struct inode *inode = NULL;
 223
 224	spin_lock(&delegation->lock);
 225	if (delegation->inode != NULL)
 226		inode = igrab(delegation->inode);
 
 
 227	spin_unlock(&delegation->lock);
 228	return inode;
 229}
 230
 231static struct nfs_delegation *
 232nfs_start_delegation_return_locked(struct nfs_inode *nfsi)
 233{
 234	struct nfs_delegation *ret = NULL;
 235	struct nfs_delegation *delegation = rcu_dereference(nfsi->delegation);
 236
 237	if (delegation == NULL)
 238		goto out;
 239	spin_lock(&delegation->lock);
 240	if (!test_and_set_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
 241		ret = delegation;
 
 
 
 242	spin_unlock(&delegation->lock);
 
 
 243out:
 244	return ret;
 245}
 246
 247static struct nfs_delegation *
 248nfs_start_delegation_return(struct nfs_inode *nfsi)
 249{
 250	struct nfs_delegation *delegation;
 251
 252	rcu_read_lock();
 253	delegation = nfs_start_delegation_return_locked(nfsi);
 254	rcu_read_unlock();
 255	return delegation;
 256}
 257
 258static void
 259nfs_abort_delegation_return(struct nfs_delegation *delegation,
 260		struct nfs_client *clp)
 261{
 262
 263	spin_lock(&delegation->lock);
 264	clear_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
 265	set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
 
 
 
 266	spin_unlock(&delegation->lock);
 267	set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
 268}
 269
 270static struct nfs_delegation *
 271nfs_detach_delegation_locked(struct nfs_inode *nfsi,
 272		struct nfs_delegation *delegation,
 273		struct nfs_client *clp)
 274{
 275	struct nfs_delegation *deleg_cur =
 276		rcu_dereference_protected(nfsi->delegation,
 277				lockdep_is_held(&clp->cl_lock));
 278
 279	if (deleg_cur == NULL || delegation != deleg_cur)
 280		return NULL;
 281
 282	spin_lock(&delegation->lock);
 283	set_bit(NFS_DELEGATION_RETURNING, &delegation->flags);
 
 
 
 284	list_del_rcu(&delegation->super_list);
 285	delegation->inode = NULL;
 286	rcu_assign_pointer(nfsi->delegation, NULL);
 287	spin_unlock(&delegation->lock);
 288	return delegation;
 289}
 290
 291static struct nfs_delegation *nfs_detach_delegation(struct nfs_inode *nfsi,
 292		struct nfs_delegation *delegation,
 293		struct nfs_server *server)
 294{
 295	struct nfs_client *clp = server->nfs_client;
 296
 297	spin_lock(&clp->cl_lock);
 298	delegation = nfs_detach_delegation_locked(nfsi, delegation, clp);
 299	spin_unlock(&clp->cl_lock);
 300	return delegation;
 301}
 302
 303static struct nfs_delegation *
 304nfs_inode_detach_delegation(struct inode *inode)
 305{
 306	struct nfs_inode *nfsi = NFS_I(inode);
 307	struct nfs_server *server = NFS_SERVER(inode);
 308	struct nfs_delegation *delegation;
 309
 310	delegation = nfs_start_delegation_return(nfsi);
 311	if (delegation == NULL)
 312		return NULL;
 313	return nfs_detach_delegation(nfsi, delegation, server);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 314}
 315
 316static void
 317nfs_update_inplace_delegation(struct nfs_delegation *delegation,
 318		const struct nfs_delegation *update)
 319{
 320	if (nfs4_stateid_is_newer(&update->stateid, &delegation->stateid)) {
 321		delegation->stateid.seqid = update->stateid.seqid;
 322		smp_wmb();
 323		delegation->type = update->type;
 
 
 
 
 
 
 
 
 324	}
 325}
 326
 327/**
 328 * nfs_inode_set_delegation - set up a delegation on an inode
 329 * @inode: inode to which delegation applies
 330 * @cred: cred to use for subsequent delegation processing
 331 * @res: new delegation state from server
 
 
 332 *
 333 * Returns zero on success, or a negative errno value.
 334 */
 335int nfs_inode_set_delegation(struct inode *inode, struct rpc_cred *cred, struct nfs_openres *res)
 
 
 
 336{
 337	struct nfs_server *server = NFS_SERVER(inode);
 338	struct nfs_client *clp = server->nfs_client;
 339	struct nfs_inode *nfsi = NFS_I(inode);
 340	struct nfs_delegation *delegation, *old_delegation;
 341	struct nfs_delegation *freeme = NULL;
 342	int status = 0;
 343
 344	delegation = kmalloc(sizeof(*delegation), GFP_NOFS);
 345	if (delegation == NULL)
 346		return -ENOMEM;
 347	nfs4_stateid_copy(&delegation->stateid, &res->delegation);
 348	delegation->type = res->delegation_type;
 349	delegation->pagemod_limit = res->pagemod_limit;
 350	delegation->change_attr = inode->i_version;
 351	delegation->cred = get_rpccred(cred);
 
 352	delegation->inode = inode;
 353	delegation->flags = 1<<NFS_DELEGATION_REFERENCED;
 
 354	spin_lock_init(&delegation->lock);
 355
 356	spin_lock(&clp->cl_lock);
 357	old_delegation = rcu_dereference_protected(nfsi->delegation,
 358					lockdep_is_held(&clp->cl_lock));
 359	if (old_delegation != NULL) {
 360		/* Is this an update of the existing delegation? */
 361		if (nfs4_stateid_match_other(&old_delegation->stateid,
 362					&delegation->stateid)) {
 363			nfs_update_inplace_delegation(old_delegation,
 364					delegation);
 365			goto out;
 366		}
 
 
 
 
 367		/*
 368		 * Deal with broken servers that hand out two
 369		 * delegations for the same file.
 370		 * Allow for upgrades to a WRITE delegation, but
 371		 * nothing else.
 372		 */
 373		dfprintk(FILE, "%s: server %s handed out "
 374				"a duplicate delegation!\n",
 375				__func__, clp->cl_hostname);
 376		if (delegation->type == old_delegation->type ||
 377		    !(delegation->type & FMODE_WRITE)) {
 378			freeme = delegation;
 379			delegation = NULL;
 380			goto out;
 381		}
 382		if (test_and_set_bit(NFS_DELEGATION_RETURNING,
 383					&old_delegation->flags))
 384			goto out;
 385		freeme = nfs_detach_delegation_locked(nfsi,
 386				old_delegation, clp);
 387		if (freeme == NULL)
 388			goto out;
 389	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 390	list_add_tail_rcu(&delegation->super_list, &server->delegations);
 391	rcu_assign_pointer(nfsi->delegation, delegation);
 392	delegation = NULL;
 393
 394	trace_nfs4_set_delegation(inode, res->delegation_type);
 395
 
 396out:
 397	spin_unlock(&clp->cl_lock);
 398	if (delegation != NULL)
 399		nfs_free_delegation(delegation);
 400	if (freeme != NULL)
 401		nfs_do_return_delegation(inode, freeme, 0);
 
 
 402	return status;
 403}
 404
 405/*
 406 * Basic procedure for returning a delegation to the server
 407 */
 408static int nfs_end_delegation_return(struct inode *inode, struct nfs_delegation *delegation, int issync)
 409{
 410	struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
 411	struct nfs_inode *nfsi = NFS_I(inode);
 412	int err = 0;
 413
 414	if (delegation == NULL)
 415		return 0;
 416	do {
 
 
 
 
 
 
 417		if (test_bit(NFS_DELEGATION_REVOKED, &delegation->flags))
 418			break;
 419		err = nfs_delegation_claim_opens(inode, &delegation->stateid,
 420				delegation->type);
 421		if (!issync || err != -EAGAIN)
 422			break;
 423		/*
 424		 * Guard against state recovery
 425		 */
 426		err = nfs4_wait_clnt_recover(clp);
 427	} while (err == 0);
 428
 429	if (err) {
 430		nfs_abort_delegation_return(delegation, clp);
 431		goto out;
 432	}
 433	if (!nfs_detach_delegation(nfsi, delegation, NFS_SERVER(inode)))
 434		goto out;
 435
 436	err = nfs_do_return_delegation(inode, delegation, issync);
 437out:
 
 
 438	return err;
 439}
 440
 441static bool nfs_delegation_need_return(struct nfs_delegation *delegation)
 442{
 443	bool ret = false;
 444
 445	if (test_bit(NFS_DELEGATION_RETURNING, &delegation->flags))
 446		goto out;
 447	if (test_and_clear_bit(NFS_DELEGATION_RETURN, &delegation->flags))
 448		ret = true;
 449	if (test_and_clear_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags) && !ret) {
 450		struct inode *inode;
 451
 452		spin_lock(&delegation->lock);
 453		inode = delegation->inode;
 454		if (inode && list_empty(&NFS_I(inode)->open_files))
 455			ret = true;
 456		spin_unlock(&delegation->lock);
 457	}
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 458out:
 459	return ret;
 460}
 461
 462/**
 463 * nfs_client_return_marked_delegations - return previously marked delegations
 464 * @clp: nfs_client to process
 465 *
 466 * Note that this function is designed to be called by the state
 467 * manager thread. For this reason, it cannot flush the dirty data,
 468 * since that could deadlock in case of a state recovery error.
 469 *
 470 * Returns zero on success, or a negative errno value.
 471 */
 472int nfs_client_return_marked_delegations(struct nfs_client *clp)
 473{
 474	struct nfs_delegation *delegation;
 475	struct nfs_server *server;
 476	struct inode *inode;
 477	int err = 0;
 478
 479restart:
 480	rcu_read_lock();
 481	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 482		list_for_each_entry_rcu(delegation, &server->delegations,
 483								super_list) {
 484			if (!nfs_delegation_need_return(delegation))
 485				continue;
 486			if (!nfs_sb_active(server->super))
 487				continue;
 488			inode = nfs_delegation_grab_inode(delegation);
 489			if (inode == NULL) {
 490				rcu_read_unlock();
 491				nfs_sb_deactive(server->super);
 492				goto restart;
 493			}
 494			delegation = nfs_start_delegation_return_locked(NFS_I(inode));
 495			rcu_read_unlock();
 496
 497			err = nfs_end_delegation_return(inode, delegation, 0);
 498			iput(inode);
 499			nfs_sb_deactive(server->super);
 500			if (!err)
 501				goto restart;
 502			set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
 503			return err;
 504		}
 505	}
 506	rcu_read_unlock();
 507	return 0;
 508}
 509
 510/**
 511 * nfs_inode_return_delegation_noreclaim - return delegation, don't reclaim opens
 512 * @inode: inode to process
 513 *
 514 * Does not protect against delegation reclaims, therefore really only safe
 515 * to be called from nfs4_clear_inode().
 
 516 */
 517void nfs_inode_return_delegation_noreclaim(struct inode *inode)
 518{
 519	struct nfs_delegation *delegation;
 520
 521	delegation = nfs_inode_detach_delegation(inode);
 522	if (delegation != NULL)
 
 
 523		nfs_do_return_delegation(inode, delegation, 1);
 
 
 524}
 525
 526/**
 527 * nfs_inode_return_delegation - synchronously return a delegation
 528 * @inode: inode to process
 529 *
 530 * This routine will always flush any dirty data to disk on the
 531 * assumption that if we need to return the delegation, then
 532 * we should stop caching.
 533 *
 534 * Returns zero on success, or a negative errno value.
 535 */
 536int nfs4_inode_return_delegation(struct inode *inode)
 537{
 538	struct nfs_inode *nfsi = NFS_I(inode);
 539	struct nfs_delegation *delegation;
 540	int err = 0;
 541
 542	nfs_wb_all(inode);
 543	delegation = nfs_start_delegation_return(nfsi);
 544	if (delegation != NULL)
 545		err = nfs_end_delegation_return(inode, delegation, 1);
 546	return err;
 
 
 
 
 
 547}
 548
 549static void nfs_mark_return_if_closed_delegation(struct nfs_server *server,
 550		struct nfs_delegation *delegation)
 
 
 
 
 
 
 551{
 552	set_bit(NFS_DELEGATION_RETURN_IF_CLOSED, &delegation->flags);
 553	set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 554}
 555
 556static void nfs_mark_return_delegation(struct nfs_server *server,
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 557		struct nfs_delegation *delegation)
 558{
 559	set_bit(NFS_DELEGATION_RETURN, &delegation->flags);
 560	set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
 561}
 562
 563static bool nfs_server_mark_return_all_delegations(struct nfs_server *server)
 564{
 565	struct nfs_delegation *delegation;
 566	bool ret = false;
 567
 568	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 569		nfs_mark_return_delegation(server, delegation);
 570		ret = true;
 571	}
 572	return ret;
 573}
 574
 575static void nfs_client_mark_return_all_delegations(struct nfs_client *clp)
 576{
 577	struct nfs_server *server;
 578
 579	rcu_read_lock();
 580	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 581		nfs_server_mark_return_all_delegations(server);
 582	rcu_read_unlock();
 583}
 584
 585static void nfs_delegation_run_state_manager(struct nfs_client *clp)
 586{
 587	if (test_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state))
 588		nfs4_schedule_state_manager(clp);
 589}
 590
 591/**
 592 * nfs_expire_all_delegations
 593 * @clp: client to process
 594 *
 595 */
 596void nfs_expire_all_delegations(struct nfs_client *clp)
 597{
 598	nfs_client_mark_return_all_delegations(clp);
 599	nfs_delegation_run_state_manager(clp);
 600}
 601
 602/**
 603 * nfs_super_return_all_delegations - return delegations for one superblock
 604 * @sb: sb to process
 605 *
 606 */
 607void nfs_server_return_all_delegations(struct nfs_server *server)
 608{
 609	struct nfs_client *clp = server->nfs_client;
 610	bool need_wait;
 611
 612	if (clp == NULL)
 613		return;
 614
 615	rcu_read_lock();
 616	need_wait = nfs_server_mark_return_all_delegations(server);
 617	rcu_read_unlock();
 618
 619	if (need_wait) {
 620		nfs4_schedule_state_manager(clp);
 621		nfs4_wait_clnt_recover(clp);
 622	}
 623}
 624
 625static void nfs_mark_return_unused_delegation_types(struct nfs_server *server,
 626						 fmode_t flags)
 627{
 628	struct nfs_delegation *delegation;
 629
 630	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 631		if ((delegation->type == (FMODE_READ|FMODE_WRITE)) && !(flags & FMODE_WRITE))
 632			continue;
 633		if (delegation->type & flags)
 634			nfs_mark_return_if_closed_delegation(server, delegation);
 635	}
 636}
 637
 638static void nfs_client_mark_return_unused_delegation_types(struct nfs_client *clp,
 639							fmode_t flags)
 640{
 641	struct nfs_server *server;
 642
 643	rcu_read_lock();
 644	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 645		nfs_mark_return_unused_delegation_types(server, flags);
 646	rcu_read_unlock();
 647}
 648
 649static void nfs_mark_delegation_revoked(struct nfs_server *server,
 650		struct nfs_delegation *delegation)
 651{
 652	set_bit(NFS_DELEGATION_REVOKED, &delegation->flags);
 653	delegation->stateid.type = NFS4_INVALID_STATEID_TYPE;
 654	nfs_mark_return_delegation(server, delegation);
 655}
 656
 657static bool nfs_revoke_delegation(struct inode *inode,
 658		const nfs4_stateid *stateid)
 659{
 660	struct nfs_delegation *delegation;
 661	nfs4_stateid tmp;
 662	bool ret = false;
 663
 664	rcu_read_lock();
 665	delegation = rcu_dereference(NFS_I(inode)->delegation);
 666	if (delegation == NULL)
 667		goto out;
 668	if (stateid == NULL) {
 669		nfs4_stateid_copy(&tmp, &delegation->stateid);
 670		stateid = &tmp;
 671	} else if (!nfs4_stateid_match(stateid, &delegation->stateid))
 672		goto out;
 673	nfs_mark_delegation_revoked(NFS_SERVER(inode), delegation);
 
 
 
 
 
 
 
 
 
 
 
 674	ret = true;
 675out:
 676	rcu_read_unlock();
 677	if (ret)
 678		nfs_inode_find_state_and_recover(inode, stateid);
 679	return ret;
 680}
 681
 682void nfs_remove_bad_delegation(struct inode *inode,
 683		const nfs4_stateid *stateid)
 684{
 
 
 
 
 
 
 
 685	struct nfs_delegation *delegation;
 686
 687	if (!nfs_revoke_delegation(inode, stateid))
 688		return;
 689	delegation = nfs_inode_detach_delegation(inode);
 690	if (delegation)
 691		nfs_free_delegation(delegation);
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 692}
 693EXPORT_SYMBOL_GPL(nfs_remove_bad_delegation);
 694
 695/**
 696 * nfs_expire_unused_delegation_types
 697 * @clp: client to process
 698 * @flags: delegation types to expire
 699 *
 700 */
 701void nfs_expire_unused_delegation_types(struct nfs_client *clp, fmode_t flags)
 702{
 703	nfs_client_mark_return_unused_delegation_types(clp, flags);
 704	nfs_delegation_run_state_manager(clp);
 705}
 706
 707static void nfs_mark_return_unreferenced_delegations(struct nfs_server *server)
 708{
 709	struct nfs_delegation *delegation;
 710
 711	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 712		if (test_and_clear_bit(NFS_DELEGATION_REFERENCED, &delegation->flags))
 713			continue;
 714		nfs_mark_return_if_closed_delegation(server, delegation);
 715	}
 716}
 717
 718/**
 719 * nfs_expire_unreferenced_delegations - Eliminate unused delegations
 720 * @clp: nfs_client to process
 721 *
 722 */
 723void nfs_expire_unreferenced_delegations(struct nfs_client *clp)
 724{
 725	struct nfs_server *server;
 726
 727	rcu_read_lock();
 728	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 729		nfs_mark_return_unreferenced_delegations(server);
 730	rcu_read_unlock();
 731
 732	nfs_delegation_run_state_manager(clp);
 733}
 734
 735/**
 736 * nfs_async_inode_return_delegation - asynchronously return a delegation
 737 * @inode: inode to process
 738 * @stateid: state ID information
 739 *
 740 * Returns zero on success, or a negative errno value.
 741 */
 742int nfs_async_inode_return_delegation(struct inode *inode,
 743				      const nfs4_stateid *stateid)
 744{
 745	struct nfs_server *server = NFS_SERVER(inode);
 746	struct nfs_client *clp = server->nfs_client;
 747	struct nfs_delegation *delegation;
 748
 749	rcu_read_lock();
 750	delegation = rcu_dereference(NFS_I(inode)->delegation);
 751	if (delegation == NULL)
 752		goto out_enoent;
 753	if (stateid != NULL &&
 754	    !clp->cl_mvops->match_stateid(&delegation->stateid, stateid))
 755		goto out_enoent;
 756	nfs_mark_return_delegation(server, delegation);
 757	rcu_read_unlock();
 758
 
 
 
 759	nfs_delegation_run_state_manager(clp);
 760	return 0;
 761out_enoent:
 762	rcu_read_unlock();
 763	return -ENOENT;
 764}
 765
 766static struct inode *
 767nfs_delegation_find_inode_server(struct nfs_server *server,
 768				 const struct nfs_fh *fhandle)
 769{
 770	struct nfs_delegation *delegation;
 
 771	struct inode *res = NULL;
 772
 773	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 774		spin_lock(&delegation->lock);
 775		if (delegation->inode != NULL &&
 
 776		    nfs_compare_fh(fhandle, &NFS_I(delegation->inode)->fh) == 0) {
 777			res = igrab(delegation->inode);
 
 
 
 
 
 
 
 
 
 
 
 
 778		}
 779		spin_unlock(&delegation->lock);
 780		if (res != NULL)
 781			break;
 782	}
 783	return res;
 784}
 785
 786/**
 787 * nfs_delegation_find_inode - retrieve the inode associated with a delegation
 788 * @clp: client state handle
 789 * @fhandle: filehandle from a delegation recall
 790 *
 791 * Returns pointer to inode matching "fhandle," or NULL if a matching inode
 792 * cannot be found.
 793 */
 794struct inode *nfs_delegation_find_inode(struct nfs_client *clp,
 795					const struct nfs_fh *fhandle)
 796{
 797	struct nfs_server *server;
 798	struct inode *res = NULL;
 799
 800	rcu_read_lock();
 801	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 802		res = nfs_delegation_find_inode_server(server, fhandle);
 803		if (res != NULL)
 804			break;
 
 
 805	}
 806	rcu_read_unlock();
 807	return res;
 808}
 809
 810static void nfs_delegation_mark_reclaim_server(struct nfs_server *server)
 811{
 812	struct nfs_delegation *delegation;
 813
 814	list_for_each_entry_rcu(delegation, &server->delegations, super_list) {
 815		/*
 816		 * If the delegation may have been admin revoked, then we
 817		 * cannot reclaim it.
 818		 */
 819		if (test_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags))
 820			continue;
 821		set_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
 822	}
 823}
 824
 825/**
 826 * nfs_delegation_mark_reclaim - mark all delegations as needing to be reclaimed
 827 * @clp: nfs_client to process
 828 *
 829 */
 830void nfs_delegation_mark_reclaim(struct nfs_client *clp)
 831{
 832	struct nfs_server *server;
 833
 834	rcu_read_lock();
 835	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 836		nfs_delegation_mark_reclaim_server(server);
 837	rcu_read_unlock();
 838}
 839
 840/**
 841 * nfs_delegation_reap_unclaimed - reap unclaimed delegations after reboot recovery is done
 842 * @clp: nfs_client to process
 843 *
 844 */
 845void nfs_delegation_reap_unclaimed(struct nfs_client *clp)
 846{
 847	struct nfs_delegation *delegation;
 848	struct nfs_server *server;
 849	struct inode *inode;
 850
 851restart:
 852	rcu_read_lock();
 853	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 854		list_for_each_entry_rcu(delegation, &server->delegations,
 855								super_list) {
 856			if (test_bit(NFS_DELEGATION_RETURNING,
 857						&delegation->flags))
 858				continue;
 859			if (test_bit(NFS_DELEGATION_NEED_RECLAIM,
 860						&delegation->flags) == 0)
 861				continue;
 862			if (!nfs_sb_active(server->super))
 863				continue;
 864			inode = nfs_delegation_grab_inode(delegation);
 865			if (inode == NULL) {
 866				rcu_read_unlock();
 867				nfs_sb_deactive(server->super);
 868				goto restart;
 869			}
 870			delegation = nfs_start_delegation_return_locked(NFS_I(inode));
 871			rcu_read_unlock();
 872			if (delegation != NULL) {
 873				delegation = nfs_detach_delegation(NFS_I(inode),
 874					delegation, server);
 875				if (delegation != NULL)
 876					nfs_free_delegation(delegation);
 877			}
 878			iput(inode);
 879			nfs_sb_deactive(server->super);
 880			goto restart;
 881		}
 
 
 
 882	}
 883	rcu_read_unlock();
 
 
 
 
 
 
 
 
 
 
 
 
 884}
 885
 886static inline bool nfs4_server_rebooted(const struct nfs_client *clp)
 887{
 888	return (clp->cl_state & (BIT(NFS4CLNT_CHECK_LEASE) |
 889				BIT(NFS4CLNT_LEASE_EXPIRED) |
 890				BIT(NFS4CLNT_SESSION_RESET))) != 0;
 891}
 892
 893static void nfs_mark_test_expired_delegation(struct nfs_server *server,
 894	    struct nfs_delegation *delegation)
 895{
 896	if (delegation->stateid.type == NFS4_INVALID_STATEID_TYPE)
 897		return;
 898	clear_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags);
 899	set_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
 900	set_bit(NFS4CLNT_DELEGATION_EXPIRED, &server->nfs_client->cl_state);
 901}
 902
 903static void nfs_inode_mark_test_expired_delegation(struct nfs_server *server,
 904		struct inode *inode)
 905{
 906	struct nfs_delegation *delegation;
 907
 908	rcu_read_lock();
 909	delegation = rcu_dereference(NFS_I(inode)->delegation);
 910	if (delegation)
 911		nfs_mark_test_expired_delegation(server, delegation);
 912	rcu_read_unlock();
 913
 914}
 915
 916static void nfs_delegation_mark_test_expired_server(struct nfs_server *server)
 917{
 918	struct nfs_delegation *delegation;
 919
 920	list_for_each_entry_rcu(delegation, &server->delegations, super_list)
 921		nfs_mark_test_expired_delegation(server, delegation);
 922}
 923
 924/**
 925 * nfs_mark_test_expired_all_delegations - mark all delegations for testing
 926 * @clp: nfs_client to process
 927 *
 928 * Iterates through all the delegations associated with this server and
 929 * marks them as needing to be checked for validity.
 930 */
 931void nfs_mark_test_expired_all_delegations(struct nfs_client *clp)
 932{
 933	struct nfs_server *server;
 934
 935	rcu_read_lock();
 936	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
 937		nfs_delegation_mark_test_expired_server(server);
 938	rcu_read_unlock();
 939}
 940
 941/**
 942 * nfs_reap_expired_delegations - reap expired delegations
 943 * @clp: nfs_client to process
 944 *
 945 * Iterates through all the delegations associated with this server and
 946 * checks if they have may have been revoked. This function is usually
 947 * expected to be called in cases where the server may have lost its
 948 * lease.
 949 */
 950void nfs_reap_expired_delegations(struct nfs_client *clp)
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 951{
 952	const struct nfs4_minor_version_ops *ops = clp->cl_mvops;
 953	struct nfs_delegation *delegation;
 954	struct nfs_server *server;
 955	struct inode *inode;
 956	struct rpc_cred *cred;
 957	nfs4_stateid stateid;
 
 958
 959restart:
 960	rcu_read_lock();
 961	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link) {
 962		list_for_each_entry_rcu(delegation, &server->delegations,
 963								super_list) {
 964			if (test_bit(NFS_DELEGATION_RETURNING,
 965						&delegation->flags))
 966				continue;
 967			if (test_bit(NFS_DELEGATION_TEST_EXPIRED,
 968						&delegation->flags) == 0)
 969				continue;
 970			if (!nfs_sb_active(server->super))
 971				continue;
 972			inode = nfs_delegation_grab_inode(delegation);
 973			if (inode == NULL) {
 974				rcu_read_unlock();
 975				nfs_sb_deactive(server->super);
 976				goto restart;
 977			}
 978			cred = get_rpccred_rcu(delegation->cred);
 979			nfs4_stateid_copy(&stateid, &delegation->stateid);
 980			clear_bit(NFS_DELEGATION_TEST_EXPIRED, &delegation->flags);
 981			rcu_read_unlock();
 982			if (cred != NULL &&
 983			    ops->test_and_free_expired(server, &stateid, cred) < 0) {
 984				nfs_revoke_delegation(inode, &stateid);
 985				nfs_inode_find_state_and_recover(inode, &stateid);
 986			}
 987			put_rpccred(cred);
 988			if (nfs4_server_rebooted(clp)) {
 989				nfs_inode_mark_test_expired_delegation(server,inode);
 990				iput(inode);
 991				nfs_sb_deactive(server->super);
 992				return;
 993			}
 994			iput(inode);
 995			nfs_sb_deactive(server->super);
 996			goto restart;
 997		}
 
 
 
 998	}
 999	rcu_read_unlock();
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1000}
1001
1002void nfs_inode_find_delegation_state_and_recover(struct inode *inode,
1003		const nfs4_stateid *stateid)
1004{
1005	struct nfs_client *clp = NFS_SERVER(inode)->nfs_client;
1006	struct nfs_delegation *delegation;
1007	bool found = false;
1008
1009	rcu_read_lock();
1010	delegation = rcu_dereference(NFS_I(inode)->delegation);
1011	if (delegation &&
1012	    nfs4_stateid_match_other(&delegation->stateid, stateid)) {
 
1013		nfs_mark_test_expired_delegation(NFS_SERVER(inode), delegation);
1014		found = true;
1015	}
1016	rcu_read_unlock();
1017	if (found)
1018		nfs4_schedule_state_manager(clp);
1019}
1020
1021/**
1022 * nfs_delegations_present - check for existence of delegations
1023 * @clp: client state handle
1024 *
1025 * Returns one if there are any nfs_delegation structures attached
1026 * to this nfs_client.
1027 */
1028int nfs_delegations_present(struct nfs_client *clp)
1029{
1030	struct nfs_server *server;
1031	int ret = 0;
1032
1033	rcu_read_lock();
1034	list_for_each_entry_rcu(server, &clp->cl_superblocks, client_link)
1035		if (!list_empty(&server->delegations)) {
1036			ret = 1;
1037			break;
1038		}
1039	rcu_read_unlock();
1040	return ret;
1041}
1042
1043/**
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1044 * nfs4_copy_delegation_stateid - Copy inode's state ID information
1045 * @inode: inode to check
1046 * @flags: delegation type requirement
1047 * @dst: stateid data structure to fill in
1048 * @cred: optional argument to retrieve credential
1049 *
1050 * Returns "true" and fills in "dst->data" * if inode had a delegation,
1051 * otherwise "false" is returned.
1052 */
1053bool nfs4_copy_delegation_stateid(struct inode *inode, fmode_t flags,
1054		nfs4_stateid *dst, struct rpc_cred **cred)
1055{
1056	struct nfs_inode *nfsi = NFS_I(inode);
1057	struct nfs_delegation *delegation;
1058	bool ret;
1059
1060	flags &= FMODE_READ|FMODE_WRITE;
1061	rcu_read_lock();
1062	delegation = rcu_dereference(nfsi->delegation);
 
 
 
1063	ret = nfs4_is_valid_delegation(delegation, flags);
1064	if (ret) {
1065		nfs4_stateid_copy(dst, &delegation->stateid);
1066		nfs_mark_delegation_referenced(delegation);
1067		if (cred)
1068			*cred = get_rpccred(delegation->cred);
1069	}
 
 
1070	rcu_read_unlock();
1071	return ret;
1072}
1073
1074/**
1075 * nfs4_delegation_flush_on_close - Check if we must flush file on close
1076 * @inode: inode to check
1077 *
1078 * This function checks the number of outstanding writes to the file
1079 * against the delegation 'space_limit' field to see if
1080 * the spec requires us to flush the file on close.
1081 */
1082bool nfs4_delegation_flush_on_close(const struct inode *inode)
1083{
1084	struct nfs_inode *nfsi = NFS_I(inode);
1085	struct nfs_delegation *delegation;
1086	bool ret = true;
1087
1088	rcu_read_lock();
1089	delegation = rcu_dereference(nfsi->delegation);
1090	if (delegation == NULL || !(delegation->type & FMODE_WRITE))
1091		goto out;
1092	if (nfsi->nrequests < delegation->pagemod_limit)
1093		ret = false;
1094out:
1095	rcu_read_unlock();
1096	return ret;
1097}