Merge branch 'bugfixes' of git://git.linux-nfs.org/projects/trondmy/linux-nfs (822a5d31) · Commits · 戴 / test

fs/nfs/file.c

+1 −1

Original line number	Diff line number	Diff line
		@@ -147,7 +147,7 @@ static loff_t nfs_file_llseek(struct file *filp, loff_t offset, int origin)
		* origin == SEEK_END \|\| SEEK_DATA \|\| SEEK_HOLE => we must revalidate
		* the cached file length
		*/
		if (origin != SEEK_SET \|\| origin != SEEK_CUR) {
		if (origin != SEEK_SET && origin != SEEK_CUR) {
		struct inode *inode = filp->f_mapping->host;

		int retval = nfs_revalidate_file_size(inode, filp);

fs/nfs/nfs4proc.c

+16 −8

Original line number	Diff line number	Diff line
		@@ -39,6 +39,8 @@
		#include <linux/delay.h>
		#include <linux/errno.h>
		#include <linux/string.h>
		#include <linux/ratelimit.h>
		#include <linux/printk.h>
		#include <linux/slab.h>
		#include <linux/sunrpc/clnt.h>
		#include <linux/sunrpc/gss_api.h>
		@@ -894,6 +896,8 @@ out:

		static int can_open_delegated(struct nfs_delegation *delegation, fmode_t fmode)
		{
		if (delegation == NULL)
		return 0;
		if ((delegation->type & fmode) != fmode)
		return 0;
		if (test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags))
		@@ -1036,8 +1040,7 @@ static struct nfs4_state nfs4_try_open_cached(struct nfs4_opendata opendata)
		}
		rcu_read_lock();
		delegation = rcu_dereference(nfsi->delegation);
		if (delegation == NULL \|\|
		!can_open_delegated(delegation, fmode)) {
		if (!can_open_delegated(delegation, fmode)) {
		rcu_read_unlock();
		break;
		}
		@@ -1091,7 +1094,12 @@ static struct nfs4_state nfs4_opendata_to_nfs4_state(struct nfs4_opendata data
		if (delegation)
		delegation_flags = delegation->flags;
		rcu_read_unlock();
		if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)
		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",
		NFS_CLIENT(inode)->cl_server);
		} else if ((delegation_flags & 1UL<<NFS_DELEGATION_NEED_RECLAIM) == 0)
		nfs_inode_set_delegation(state->inode,
		data->owner->so_cred,
		&data->o_res);
		@@ -1423,11 +1431,9 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata)
		goto out_no_action;
		rcu_read_lock();
		delegation = rcu_dereference(NFS_I(data->state->inode)->delegation);
		if (delegation != NULL &&
		test_bit(NFS_DELEGATION_NEED_RECLAIM, &delegation->flags) == 0) {
		rcu_read_unlock();
		goto out_no_action;
		}
		if (data->o_arg.claim != NFS4_OPEN_CLAIM_DELEGATE_CUR &&
		can_open_delegated(delegation, data->o_arg.fmode))
		goto unlock_no_action;
		rcu_read_unlock();
		}
		/* Update sequence id. */
		@@ -1444,6 +1450,8 @@ static void nfs4_open_prepare(struct rpc_task task, void calldata)
		return;
		rpc_call_start(task);
		return;
		unlock_no_action:
		rcu_read_unlock();
		out_no_action:
		task->tk_action = NULL;

fs/nfs/nfs4state.c

+21 −12

Original line number	Diff line number	Diff line
		@@ -1156,11 +1156,13 @@ restart:
		if (status >= 0) {
		status = nfs4_reclaim_locks(state, ops);
		if (status >= 0) {
		spin_lock(&state->state_lock);
		list_for_each_entry(lock, &state->lock_states, ls_locks) {
		if (!(lock->ls_flags & NFS_LOCK_INITIALIZED))
		printk("%s: Lock reclaim failed!\n",
		__func__);
		}
		spin_unlock(&state->state_lock);
		nfs4_put_open_state(state);
		goto restart;
		}
		@@ -1224,10 +1226,12 @@ static void nfs4_clear_open_state(struct nfs4_state *state)
		clear_bit(NFS_O_RDONLY_STATE, &state->flags);
		clear_bit(NFS_O_WRONLY_STATE, &state->flags);
		clear_bit(NFS_O_RDWR_STATE, &state->flags);
		spin_lock(&state->state_lock);
		list_for_each_entry(lock, &state->lock_states, ls_locks) {
		lock->ls_seqid.flags = 0;
		lock->ls_flags &= ~NFS_LOCK_INITIALIZED;
		}
		spin_unlock(&state->state_lock);
		}

		static void nfs4_reset_seqids(struct nfs_server *server,
		@@ -1350,12 +1354,14 @@ static void nfs4_warn_keyexpired(const char *s)
		static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
		{
		switch (error) {
		case 0:
		break;
		case -NFS4ERR_CB_PATH_DOWN:
		nfs_handle_cb_pathdown(clp);
		return 0;
		break;
		case -NFS4ERR_NO_GRACE:
		nfs4_state_end_reclaim_reboot(clp);
		return 0;
		break;
		case -NFS4ERR_STALE_CLIENTID:
		case -NFS4ERR_LEASE_MOVED:
		set_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state);
		@@ -1375,14 +1381,16 @@ static int nfs4_recovery_handle_error(struct nfs_client *clp, int error)
		case -NFS4ERR_SEQ_MISORDERED:
		set_bit(NFS4CLNT_SESSION_RESET, &clp->cl_state);
		/* Zero session reset errors */
		return 0;
		break;
		case -EKEYEXPIRED:
		/* Nothing we can do */
		nfs4_warn_keyexpired(clp->cl_hostname);
		return 0;
		}
		break;
		default:
		return error;
		}
		return 0;
		}

		static int nfs4_do_reclaim(struct nfs_client clp, const struct nfs4_state_recovery_ops ops)
		{
		@@ -1428,7 +1436,7 @@ static int nfs4_check_lease(struct nfs_client *clp)
		struct rpc_cred *cred;
		const struct nfs4_state_maintenance_ops *ops =
		clp->cl_mvops->state_renewal_ops;
		int status = -NFS4ERR_EXPIRED;
		int status;

		/* Is the client already known to have an expired lease? */
		if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
		@@ -1438,6 +1446,7 @@ static int nfs4_check_lease(struct nfs_client *clp)
		spin_unlock(&clp->cl_lock);
		if (cred == NULL) {
		cred = nfs4_get_setclientid_cred(clp);
		status = -ENOKEY;
		if (cred == NULL)
		goto out;
		}
		@@ -1525,16 +1534,16 @@ void nfs41_handle_sequence_flag_errors(struct nfs_client *clp, u32 flags)
		{
		if (!flags)
		return;
		else if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
		if (flags & SEQ4_STATUS_RESTART_RECLAIM_NEEDED)
		nfs41_handle_server_reboot(clp);
		else if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED \|
		if (flags & (SEQ4_STATUS_EXPIRED_ALL_STATE_REVOKED \|
		SEQ4_STATUS_EXPIRED_SOME_STATE_REVOKED \|
		SEQ4_STATUS_ADMIN_STATE_REVOKED \|
		SEQ4_STATUS_LEASE_MOVED))
		nfs41_handle_state_revoked(clp);
		else if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
		if (flags & SEQ4_STATUS_RECALLABLE_STATE_REVOKED)
		nfs41_handle_recallable_state_revoked(clp);
		else if (flags & (SEQ4_STATUS_CB_PATH_DOWN \|
		if (flags & (SEQ4_STATUS_CB_PATH_DOWN \|
		SEQ4_STATUS_BACKCHANNEL_FAULT \|
		SEQ4_STATUS_CB_PATH_DOWN_SESSION))
		nfs41_handle_cb_path_down(clp);
		@@ -1662,10 +1671,10 @@ static void nfs4_state_manager(struct nfs_client *clp)

		if (test_and_clear_bit(NFS4CLNT_CHECK_LEASE, &clp->cl_state)) {
		status = nfs4_check_lease(clp);
		if (status < 0)
		goto out_error;
		if (test_bit(NFS4CLNT_LEASE_EXPIRED, &clp->cl_state))
		continue;
		if (status < 0 && status != -NFS4ERR_CB_PATH_DOWN)
		goto out_error;
		}

		/* Initialize or reset the session */

net/sunrpc/sched.c

+23 −7

Original line number	Diff line number	Diff line
		@@ -590,6 +590,27 @@ void rpc_prepare_task(struct rpc_task *task)
		task->tk_ops->rpc_call_prepare(task, task->tk_calldata);
		}

		static void
		rpc_init_task_statistics(struct rpc_task *task)
		{
		/* Initialize retry counters */
		task->tk_garb_retry = 2;
		task->tk_cred_retry = 2;
		task->tk_rebind_retry = 2;

		/* starting timestamp */
		task->tk_start = ktime_get();
		}

		static void
		rpc_reset_task_statistics(struct rpc_task *task)
		{
		task->tk_timeouts = 0;
		task->tk_flags &= ~(RPC_CALL_MAJORSEEN\|RPC_TASK_KILLED\|RPC_TASK_SENT);

		rpc_init_task_statistics(task);
		}

		/*
		* Helper that calls task->tk_ops->rpc_call_done if it exists
		*/
		@@ -602,6 +623,7 @@ void rpc_exit_task(struct rpc_task *task)
		WARN_ON(RPC_ASSASSINATED(task));
		/* Always release the RPC slot and buffer memory */
		xprt_release(task);
		rpc_reset_task_statistics(task);
		}
		}
		}
		@@ -804,11 +826,6 @@ static void rpc_init_task(struct rpc_task task, const struct rpc_task_setup ta
		task->tk_calldata = task_setup_data->callback_data;
		INIT_LIST_HEAD(&task->tk_task);

		/* Initialize retry counters */
		task->tk_garb_retry = 2;
		task->tk_cred_retry = 2;
		task->tk_rebind_retry = 2;

		task->tk_priority = task_setup_data->priority - RPC_PRIORITY_LOW;
		task->tk_owner = current->tgid;

		@@ -818,8 +835,7 @@ static void rpc_init_task(struct rpc_task task, const struct rpc_task_setup ta
		if (task->tk_ops->rpc_call_prepare != NULL)
		task->tk_action = rpc_prepare_task;

		/* starting timestamp */
		task->tk_start = ktime_get();
		rpc_init_task_statistics(task);

		dprintk("RPC: new task initialized, procpid %u\n",
		task_pid_nr(current));

net/sunrpc/xprt.c

+4 −6

Original line number	Diff line number	Diff line
		@@ -995,13 +995,11 @@ out_init_req:

		static void xprt_free_slot(struct rpc_xprt xprt, struct rpc_rqst req)
		{
		if (xprt_dynamic_free_slot(xprt, req))
		return;

		memset(req, 0, sizeof(req)); / mark unused */

		spin_lock(&xprt->reserve_lock);
		if (!xprt_dynamic_free_slot(xprt, req)) {
		memset(req, 0, sizeof(req)); / mark unused */
		list_add(&req->rq_list, &xprt->free);
		}
		rpc_wake_up_next(&xprt->backlog);
		spin_unlock(&xprt->reserve_lock);
		}

Admin message