NFSv4: Clean up nfs_client_return_marked_delegations() (af3b61bf) · Commits · 戴 / test

fs/nfs/delegation.c

+60 −69

Original line number	Diff line number	Diff line
		@@ -563,21 +563,11 @@ static bool nfs_delegation_need_return(struct nfs_delegation *delegation)
		return ret;
		}

		/**
		* nfs_client_return_marked_delegations - return previously marked delegations
		* @clp: nfs_client to process
		*
		* Note that this function is designed to be called by the state
		* manager thread. For this reason, it cannot flush the dirty data,
		* since that could deadlock in case of a state recovery error.
		*
		* Returns zero on success, or a negative errno value.
		*/
		int nfs_client_return_marked_delegations(struct nfs_client *clp)
		static int nfs_server_return_marked_delegations(struct nfs_server *server,
		void __always_unused *data)
		{
		struct nfs_delegation *delegation;
		struct nfs_delegation *prev;
		struct nfs_server *server;
		struct inode *inode;
		struct inode *place_holder = NULL;
		struct nfs_delegation *place_holder_deleg = NULL;
		@@ -587,23 +577,16 @@ restart:
		/*
		* To avoid quadratic looping we hold a reference
		* to an inode place_holder. Each time we restart, we
		* list nfs_servers from the server of that inode, and
		* delegation in the server from the delegations of that
		* inode.
		* list delegation in the server from the delegations
		* of that inode.
		* prev is an RCU-protected pointer to a delegation which
		* wasn't marked for return and might be a good choice for
		* the next place_holder.
		*/
		rcu_read_lock();
		prev = NULL;
		if (place_holder)
		server = NFS_SERVER(place_holder);
		else
		server = list_entry_rcu(clp->cl_superblocks.next,
		struct nfs_server, client_link);
		list_for_each_entry_from_rcu(server, &clp->cl_superblocks, client_link) {
		delegation = NULL;
		if (place_holder && server == NFS_SERVER(place_holder))
		rcu_read_lock();
		if (place_holder)
		delegation = rcu_dereference(NFS_I(place_holder)->delegation);
		if (!delegation \|\| delegation != place_holder_deleg)
		delegation = list_entry_rcu(server->delegations.next,
		@@ -611,17 +594,16 @@ restart:
		list_for_each_entry_from_rcu(delegation, &server->delegations, super_list) {
		struct inode *to_put = NULL;

		if (test_bit(NFS_DELEGATION_INODE_FREEING, &delegation->flags))
		continue;
		if (!nfs_delegation_need_return(delegation)) {
		if (nfs4_is_valid_delegation(delegation, 0))
		prev = delegation;
		continue;
		}
		if (!nfs_sb_active(server->super))
		break; /* continue in outer loop */

		if (prev) {
		struct inode *tmp;

		tmp = nfs_delegation_grab_inode(prev);
		struct inode *tmp = nfs_delegation_grab_inode(prev);
		if (tmp) {
		to_put = place_holder;
		place_holder = tmp;
		@@ -632,33 +614,42 @@ restart:
		inode = nfs_delegation_grab_inode(delegation);
		if (inode == NULL) {
		rcu_read_unlock();
		if (to_put)
		iput(to_put);
		nfs_sb_deactive(server->super);
		goto restart;
		}
		delegation = nfs_start_delegation_return_locked(NFS_I(inode));
		rcu_read_unlock();

		if (to_put)
		iput(to_put);

		err = nfs_end_delegation_return(inode, delegation, 0);
		iput(inode);
		nfs_sb_deactive(server->super);
		cond_resched();
		if (!err)
		goto restart;
		set_bit(NFS4CLNT_DELEGRETURN, &clp->cl_state);
		if (place_holder)
		iput(place_holder);
		return err;
		}
		set_bit(NFS4CLNT_DELEGRETURN, &server->nfs_client->cl_state);
		goto out;
		}
		rcu_read_unlock();
		if (place_holder)
		out:
		iput(place_holder);
		return 0;
		return err;
		}

		/**
		* nfs_client_return_marked_delegations - return previously marked delegations
		* @clp: nfs_client to process
		*
		* Note that this function is designed to be called by the state
		* manager thread. For this reason, it cannot flush the dirty data,
		* since that could deadlock in case of a state recovery error.
		*
		* Returns zero on success, or a negative errno value.
		*/
		int nfs_client_return_marked_delegations(struct nfs_client *clp)
		{
		return nfs_client_for_each_server(clp,
		nfs_server_return_marked_delegations, NULL);
		}

		/**

Admin message