Commit fec4fba6 authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'nfs-for-3.7-3' of git://git.linux-nfs.org/projects/trondmy/linux-nfs 

Pull NFS bugfixes from Trond Myklebust:

 - Fix the NFSv2/v3 kernel statd protocol, which broke due to net
   namespace related changes.

 - Fix a number of races in the SUNRPC TCP disconnect/reconnect code.

* tag 'nfs-for-3.7-3' of git://git.linux-nfs.org/projects/trondmy/linux-nfs:
  LOCKD: Clear ln->nsm_clnt only when ln->nsm_users is zero
  LOCKD: fix races in nsm_client_get
  SUNRPC: Get rid of the xs_error_report socket callback
  SUNRPC: Prevent races in xs_abort_connection()
  Revert "SUNRPC: Ensure we close the socket on EPIPE errors too..."
  SUNRPC: Clear the connect flag when socket state is TCP_CLOSE_WAIT
parents 2ab3f29d e498daa8

fs/lockd/mon.c

+32 −25
Original line number Diff line number Diff line
@@ -85,29 +85,38 @@ static struct rpc_clnt *nsm_create(struct net *net) 
	return rpc_create(&args);

}



static struct rpc_clnt *nsm_client_get(struct net *net)

static struct rpc_clnt *nsm_client_set(struct lockd_net *ln,

		struct rpc_clnt *clnt)

{

	static DEFINE_MUTEX(nsm_create_mutex);

	struct rpc_clnt	*clnt;

	struct lockd_net *ln = net_generic(net, lockd_net_id);



	spin_lock(&ln->nsm_clnt_lock);

	if (ln->nsm_users) {

		ln->nsm_users++;

		clnt = ln->nsm_clnt;

		spin_unlock(&ln->nsm_clnt_lock);

	if (ln->nsm_users == 0) {

		if (clnt == NULL)

			goto out;

		ln->nsm_clnt = clnt;

	}

	clnt = ln->nsm_clnt;

	ln->nsm_users++;

out:

	spin_unlock(&ln->nsm_clnt_lock);



	mutex_lock(&nsm_create_mutex);

	clnt = nsm_create(net);

	if (!IS_ERR(clnt)) {

		ln->nsm_clnt = clnt;

		smp_wmb();

		ln->nsm_users = 1;

	return clnt;

}

	mutex_unlock(&nsm_create_mutex);



static struct rpc_clnt *nsm_client_get(struct net *net)

{

	struct rpc_clnt	*clnt, *new;

	struct lockd_net *ln = net_generic(net, lockd_net_id);



	clnt = nsm_client_set(ln, NULL);

	if (clnt != NULL)

		goto out;



	clnt = new = nsm_create(net);

	if (IS_ERR(clnt))

		goto out;



	clnt = nsm_client_set(ln, new);

	if (clnt != new)

		rpc_shutdown_client(new);

out:

	return clnt;

}
@@ -115,18 +124,16 @@ out: 
static void nsm_client_put(struct net *net)

{

	struct lockd_net *ln = net_generic(net, lockd_net_id);

	struct rpc_clnt	*clnt = ln->nsm_clnt;

	int shutdown = 0;

	struct rpc_clnt	*clnt = NULL;



	spin_lock(&ln->nsm_clnt_lock);

	if (ln->nsm_users) {

		if (--ln->nsm_users)

	ln->nsm_users--;

	if (ln->nsm_users == 0) {

		clnt = ln->nsm_clnt;

		ln->nsm_clnt = NULL;

		shutdown = !ln->nsm_users;

	}

	spin_unlock(&ln->nsm_clnt_lock);



	if (shutdown)

	if (clnt != NULL)

		rpc_shutdown_client(clnt);

}

net/sunrpc/xprtsock.c

+10 −31
Original line number Diff line number Diff line
@@ -254,7 +254,6 @@ struct sock_xprt { 
	void			(*old_data_ready)(struct sock *, int);

	void			(*old_state_change)(struct sock *);

	void			(*old_write_space)(struct sock *);

	void			(*old_error_report)(struct sock *);

};



/*
@@ -737,10 +736,10 @@ static int xs_tcp_send_request(struct rpc_task *task) 
		dprintk("RPC:       sendmsg returned unrecognized error %d\n",

			-status);

	case -ECONNRESET:

	case -EPIPE:

		xs_tcp_shutdown(xprt);

	case -ECONNREFUSED:

	case -ENOTCONN:

	case -EPIPE:

		clear_bit(SOCK_ASYNC_NOSPACE, &transport->sock->flags);

	}
@@ -781,7 +780,6 @@ static void xs_save_old_callbacks(struct sock_xprt *transport, struct sock *sk) 
	transport->old_data_ready = sk->sk_data_ready;

	transport->old_state_change = sk->sk_state_change;

	transport->old_write_space = sk->sk_write_space;

	transport->old_error_report = sk->sk_error_report;

}



static void xs_restore_old_callbacks(struct sock_xprt *transport, struct sock *sk)
@@ -789,7 +787,6 @@ static void xs_restore_old_callbacks(struct sock_xprt *transport, struct sock *s 
	sk->sk_data_ready = transport->old_data_ready;

	sk->sk_state_change = transport->old_state_change;

	sk->sk_write_space = transport->old_write_space;

	sk->sk_error_report = transport->old_error_report;

}



static void xs_reset_transport(struct sock_xprt *transport)
@@ -1453,7 +1450,7 @@ static void xs_tcp_cancel_linger_timeout(struct rpc_xprt *xprt) 
	xprt_clear_connecting(xprt);

}



static void xs_sock_mark_closed(struct rpc_xprt *xprt)

static void xs_sock_reset_connection_flags(struct rpc_xprt *xprt)

{

	smp_mb__before_clear_bit();

	clear_bit(XPRT_CONNECTION_ABORT, &xprt->state);
@@ -1461,6 +1458,11 @@ static void xs_sock_mark_closed(struct rpc_xprt *xprt) 
	clear_bit(XPRT_CLOSE_WAIT, &xprt->state);

	clear_bit(XPRT_CLOSING, &xprt->state);

	smp_mb__after_clear_bit();

}



static void xs_sock_mark_closed(struct rpc_xprt *xprt)

{

	xs_sock_reset_connection_flags(xprt);

	/* Mark transport as closed and wake up all pending tasks */

	xprt_disconnect_done(xprt);

}
@@ -1516,6 +1518,7 @@ static void xs_tcp_state_change(struct sock *sk) 
	case TCP_CLOSE_WAIT:

		/* The server initiated a shutdown of the socket */

		xprt->connect_cookie++;

		clear_bit(XPRT_CONNECTED, &xprt->state);

		xs_tcp_force_close(xprt);

	case TCP_CLOSING:

		/*
@@ -1540,25 +1543,6 @@ static void xs_tcp_state_change(struct sock *sk) 
	read_unlock_bh(&sk->sk_callback_lock);

}



/**

 * xs_error_report - callback mainly for catching socket errors

 * @sk: socket

 */

static void xs_error_report(struct sock *sk)

{

	struct rpc_xprt *xprt;



	read_lock_bh(&sk->sk_callback_lock);

	if (!(xprt = xprt_from_sock(sk)))

		goto out;

	dprintk("RPC:       %s client %p...\n"

			"RPC:       error %d\n",

			__func__, xprt, sk->sk_err);

	xprt_wake_pending_tasks(xprt, -EAGAIN);

out:

	read_unlock_bh(&sk->sk_callback_lock);

}



static void xs_write_space(struct sock *sk)

{

	struct socket *sock;
@@ -1858,7 +1842,6 @@ static int xs_local_finish_connecting(struct rpc_xprt *xprt, 
		sk->sk_user_data = xprt;

		sk->sk_data_ready = xs_local_data_ready;

		sk->sk_write_space = xs_udp_write_space;

		sk->sk_error_report = xs_error_report;

		sk->sk_allocation = GFP_ATOMIC;



		xprt_clear_connected(xprt);
@@ -1983,7 +1966,6 @@ static void xs_udp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock) 
		sk->sk_user_data = xprt;

		sk->sk_data_ready = xs_udp_data_ready;

		sk->sk_write_space = xs_udp_write_space;

		sk->sk_error_report = xs_error_report;

		sk->sk_no_check = UDP_CSUM_NORCV;

		sk->sk_allocation = GFP_ATOMIC;
@@ -2050,10 +2032,8 @@ static void xs_abort_connection(struct sock_xprt *transport) 
	any.sa_family = AF_UNSPEC;

	result = kernel_connect(transport->sock, &any, sizeof(any), 0);

	if (!result)

		xs_sock_mark_closed(&transport->xprt);

	else

		dprintk("RPC:       AF_UNSPEC connect return code %d\n",

				result);

		xs_sock_reset_connection_flags(&transport->xprt);

	dprintk("RPC:       AF_UNSPEC connect return code %d\n", result);

}



static void xs_tcp_reuse_connection(struct sock_xprt *transport)
@@ -2098,7 +2078,6 @@ static int xs_tcp_finish_connecting(struct rpc_xprt *xprt, struct socket *sock) 
		sk->sk_data_ready = xs_tcp_data_ready;

		sk->sk_state_change = xs_tcp_state_change;

		sk->sk_write_space = xs_tcp_write_space;

		sk->sk_error_report = xs_error_report;

		sk->sk_allocation = GFP_ATOMIC;



		/* socket options */

CRA Git | Maintained and supported by SUSTech CRA and CCSE