Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 796fff0c authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'smc-fixes' 



Ursula Braun says:

====================
net/smc: fixes 2019-04-11

here are some fixes in different areas of the smc code for the net
tree.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 988dc4a9 f61bca58

include/net/sock.h

+0 −6
Original line number Diff line number Diff line
@@ -2084,12 +2084,6 @@ static inline bool skwq_has_sleeper(struct socket_wq *wq) 
 * @p:              poll_table

 *

 * See the comments in the wq_has_sleeper function.

 *

 * Do not derive sock from filp->private_data here. An SMC socket establishes

 * an internal TCP socket that is used in the fallback case. All socket

 * operations on the SMC socket are then forwarded to the TCP socket. In case of

 * poll, the filp->private_data pointer references the SMC socket because the

 * TCP socket has no file assigned.

 */

static inline void sock_poll_wait(struct file *filp, struct socket *sock,

				  poll_table *p)

net/smc/af_smc.c

+39 −19
Original line number Diff line number Diff line
@@ -167,10 +167,9 @@ static int smc_release(struct socket *sock) 


	if (sk->sk_state == SMC_CLOSED) {

		if (smc->clcsock) {

			mutex_lock(&smc->clcsock_release_lock);

			sock_release(smc->clcsock);

			smc->clcsock = NULL;

			mutex_unlock(&smc->clcsock_release_lock);

			release_sock(sk);

			smc_clcsock_release(smc);

			lock_sock(sk);

		}

		if (!smc->use_fallback)

			smc_conn_free(&smc->conn);
@@ -446,10 +445,19 @@ static void smc_link_save_peer_info(struct smc_link *link, 
	link->peer_mtu = clc->qp_mtu;

}



static void smc_switch_to_fallback(struct smc_sock *smc)

{

	smc->use_fallback = true;

	if (smc->sk.sk_socket && smc->sk.sk_socket->file) {

		smc->clcsock->file = smc->sk.sk_socket->file;

		smc->clcsock->file->private_data = smc->clcsock;

	}

}



/* fall back during connect */

static int smc_connect_fallback(struct smc_sock *smc, int reason_code)

{

	smc->use_fallback = true;

	smc_switch_to_fallback(smc);

	smc->fallback_rsn = reason_code;

	smc_copy_sock_settings_to_clc(smc);

	if (smc->sk.sk_state == SMC_INIT)
@@ -775,10 +783,14 @@ static void smc_connect_work(struct work_struct *work) 
		smc->sk.sk_err = -rc;



out:

	if (smc->sk.sk_err)

	if (!sock_flag(&smc->sk, SOCK_DEAD)) {

		if (smc->sk.sk_err) {

			smc->sk.sk_state_change(&smc->sk);

	else

		} else { /* allow polling before and after fallback decision */

			smc->clcsock->sk->sk_write_space(smc->clcsock->sk);

			smc->sk.sk_write_space(&smc->sk);

		}

	}

	kfree(smc->connect_info);

	smc->connect_info = NULL;

	release_sock(&smc->sk);
@@ -872,11 +884,11 @@ static int smc_clcsock_accept(struct smc_sock *lsmc, struct smc_sock **new_smc) 
	if  (rc < 0)

		lsk->sk_err = -rc;

	if (rc < 0 || lsk->sk_state == SMC_CLOSED) {

		new_sk->sk_prot->unhash(new_sk);

		if (new_clcsock)

			sock_release(new_clcsock);

		new_sk->sk_state = SMC_CLOSED;

		sock_set_flag(new_sk, SOCK_DEAD);

		new_sk->sk_prot->unhash(new_sk);

		sock_put(new_sk); /* final */

		*new_smc = NULL;

		goto out;
@@ -927,16 +939,21 @@ struct sock *smc_accept_dequeue(struct sock *parent, 


		smc_accept_unlink(new_sk);

		if (new_sk->sk_state == SMC_CLOSED) {

			new_sk->sk_prot->unhash(new_sk);

			if (isk->clcsock) {

				sock_release(isk->clcsock);

				isk->clcsock = NULL;

			}

			new_sk->sk_prot->unhash(new_sk);

			sock_put(new_sk); /* final */

			continue;

		}

		if (new_sock)

		if (new_sock) {

			sock_graft(new_sk, new_sock);

			if (isk->use_fallback) {

				smc_sk(new_sk)->clcsock->file = new_sock->file;

				isk->clcsock->file->private_data = isk->clcsock;

			}

		}

		return new_sk;

	}

	return NULL;
@@ -956,6 +973,7 @@ void smc_close_non_accepted(struct sock *sk) 
		sock_set_flag(sk, SOCK_DEAD);

		sk->sk_shutdown |= SHUTDOWN_MASK;

	}

	sk->sk_prot->unhash(sk);

	if (smc->clcsock) {

		struct socket *tcp;
@@ -971,7 +989,6 @@ void smc_close_non_accepted(struct sock *sk) 
			smc_conn_free(&smc->conn);

	}

	release_sock(sk);

	sk->sk_prot->unhash(sk);

	sock_put(sk); /* final sock_put */

}
@@ -1037,13 +1054,13 @@ static void smc_listen_out(struct smc_sock *new_smc) 
	struct smc_sock *lsmc = new_smc->listen_smc;

	struct sock *newsmcsk = &new_smc->sk;



	lock_sock_nested(&lsmc->sk, SINGLE_DEPTH_NESTING);

	if (lsmc->sk.sk_state == SMC_LISTEN) {

		lock_sock_nested(&lsmc->sk, SINGLE_DEPTH_NESTING);

		smc_accept_enqueue(&lsmc->sk, newsmcsk);

		release_sock(&lsmc->sk);

	} else { /* no longer listening */

		smc_close_non_accepted(newsmcsk);

	}

	release_sock(&lsmc->sk);



	/* Wake up accept */

	lsmc->sk.sk_data_ready(&lsmc->sk);
@@ -1087,7 +1104,7 @@ static void smc_listen_decline(struct smc_sock *new_smc, int reason_code, 
		return;

	}

	smc_conn_free(&new_smc->conn);

	new_smc->use_fallback = true;

	smc_switch_to_fallback(new_smc);

	new_smc->fallback_rsn = reason_code;

	if (reason_code && reason_code != SMC_CLC_DECL_PEERDECL) {

		if (smc_clc_send_decline(new_smc, reason_code) < 0) {
@@ -1237,6 +1254,9 @@ static void smc_listen_work(struct work_struct *work) 
	int rc = 0;

	u8 ibport;



	if (new_smc->listen_smc->sk.sk_state != SMC_LISTEN)

		return smc_listen_out_err(new_smc);



	if (new_smc->use_fallback) {

		smc_listen_out_connected(new_smc);

		return;
@@ -1244,7 +1264,7 @@ static void smc_listen_work(struct work_struct *work) 


	/* check if peer is smc capable */

	if (!tcp_sk(newclcsock->sk)->syn_smc) {

		new_smc->use_fallback = true;

		smc_switch_to_fallback(new_smc);

		new_smc->fallback_rsn = SMC_CLC_DECL_PEERNOSMC;

		smc_listen_out_connected(new_smc);

		return;
@@ -1501,7 +1521,7 @@ static int smc_sendmsg(struct socket *sock, struct msghdr *msg, size_t len) 


	if (msg->msg_flags & MSG_FASTOPEN) {

		if (sk->sk_state == SMC_INIT) {

			smc->use_fallback = true;

			smc_switch_to_fallback(smc);

			smc->fallback_rsn = SMC_CLC_DECL_OPTUNSUPP;

		} else {

			rc = -EINVAL;
@@ -1703,7 +1723,7 @@ static int smc_setsockopt(struct socket *sock, int level, int optname, 
	case TCP_FASTOPEN_NO_COOKIE:

		/* option not supported by SMC */

		if (sk->sk_state == SMC_INIT) {

			smc->use_fallback = true;

			smc_switch_to_fallback(smc);

			smc->fallback_rsn = SMC_CLC_DECL_OPTUNSUPP;

		} else {

			if (!smc->use_fallback)

net/smc/smc_close.c

+21 −4
Original line number Diff line number Diff line
@@ -21,6 +21,22 @@ 


#define SMC_CLOSE_WAIT_LISTEN_CLCSOCK_TIME	(5 * HZ)



/* release the clcsock that is assigned to the smc_sock */

void smc_clcsock_release(struct smc_sock *smc)

{

	struct socket *tcp;



	if (smc->listen_smc && current_work() != &smc->smc_listen_work)

		cancel_work_sync(&smc->smc_listen_work);

	mutex_lock(&smc->clcsock_release_lock);

	if (smc->clcsock) {

		tcp = smc->clcsock;

		smc->clcsock = NULL;

		sock_release(tcp);

	}

	mutex_unlock(&smc->clcsock_release_lock);

}



static void smc_close_cleanup_listen(struct sock *parent)

{

	struct sock *sk;
@@ -321,6 +337,7 @@ static void smc_close_passive_work(struct work_struct *work) 
						   close_work);

	struct smc_sock *smc = container_of(conn, struct smc_sock, conn);

	struct smc_cdc_conn_state_flags *rxflags;

	bool release_clcsock = false;

	struct sock *sk = &smc->sk;

	int old_state;
@@ -400,13 +417,13 @@ static void smc_close_passive_work(struct work_struct *work) 
		if ((sk->sk_state == SMC_CLOSED) &&

		    (sock_flag(sk, SOCK_DEAD) || !sk->sk_socket)) {

			smc_conn_free(conn);

			if (smc->clcsock) {

				sock_release(smc->clcsock);

				smc->clcsock = NULL;

			}

			if (smc->clcsock)

				release_clcsock = true;

		}

	}

	release_sock(sk);

	if (release_clcsock)

		smc_clcsock_release(smc);

	sock_put(sk); /* sock_hold done by schedulers of close_work */

}

net/smc/smc_close.h

+1 −0
Original line number Diff line number Diff line
@@ -23,5 +23,6 @@ void smc_close_wake_tx_prepared(struct smc_sock *smc); 
int smc_close_active(struct smc_sock *smc);

int smc_close_shutdown_write(struct smc_sock *smc);

void smc_close_init(struct smc_sock *smc);

void smc_clcsock_release(struct smc_sock *smc);



#endif /* SMC_CLOSE_H */

net/smc/smc_ism.c

+5 −0
Original line number Diff line number Diff line
@@ -289,6 +289,11 @@ struct smcd_dev *smcd_alloc_dev(struct device *parent, const char *name, 
	INIT_LIST_HEAD(&smcd->vlan);

	smcd->event_wq = alloc_ordered_workqueue("ism_evt_wq-%s)",

						 WQ_MEM_RECLAIM, name);

	if (!smcd->event_wq) {

		kfree(smcd->conn);

		kfree(smcd);

		return NULL;

	}

	return smcd;

}

EXPORT_SYMBOL_GPL(smcd_alloc_dev);