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

Commit 6a525818 authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch 'smc-next' 



Ursula Braun says:

====================
net/smc: patches 2018-07-23

here are some small patches for SMC: Just the first patch contains a
functional change. It allows to differ between the modes SMCR and SMCD
on s390 when monitoring SMC sockets. The remaining patches are cleanups
without functional changes.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 9a2ad362 48bf5231

include/uapi/linux/smc_diag.h

+8 −1
Original line number Diff line number Diff line
@@ -20,7 +20,7 @@ struct smc_diag_req { 
struct smc_diag_msg {

	__u8	diag_family;

	__u8	diag_state;

	__u8	diag_fallback;

	__u8	diag_mode;

	__u8	diag_shutdown;

	struct inet_diag_sockid id;
@@ -28,6 +28,13 @@ struct smc_diag_msg { 
	__u64	diag_inode;

};



/* Mode of a connection */

enum {

	SMC_DIAG_MODE_SMCR,

	SMC_DIAG_MODE_FALLBACK_TCP,

	SMC_DIAG_MODE_SMCD,

};



/* Extensions */



enum {

net/smc/af_smc.c

+2 −6
Original line number Diff line number Diff line
@@ -1755,12 +1755,8 @@ static int smc_ioctl(struct socket *sock, unsigned int cmd, 
		    smc->sk.sk_state == SMC_CLOSED) {

			answ = 0;

		} else {

			smc_curs_write(&cons,

			       smc_curs_read(&conn->local_tx_ctrl.cons, conn),

				       conn);

			smc_curs_write(&urg,

				       smc_curs_read(&conn->urg_curs, conn),

				       conn);

			smc_curs_copy(&cons, &conn->local_tx_ctrl.cons, conn);

			smc_curs_copy(&urg, &conn->urg_curs, conn);

			answ = smc_curs_diff(conn->rmb_desc->len,

					     &cons, &urg) == 1;

		}

net/smc/smc_cdc.c

+13 −22
Original line number Diff line number Diff line
@@ -34,14 +34,15 @@ static void smc_cdc_tx_handler(struct smc_wr_tx_pend_priv *pnd_snd, 
			       enum ib_wc_status wc_status)

{

	struct smc_cdc_tx_pend *cdcpend = (struct smc_cdc_tx_pend *)pnd_snd;

	struct smc_connection *conn = cdcpend->conn;

	struct smc_sock *smc;

	int diff;



	if (!cdcpend->conn)

	if (!conn)

		/* already dismissed */

		return;



	smc = container_of(cdcpend->conn, struct smc_sock, conn);

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

	bh_lock_sock(&smc->sk);

	if (!wc_status) {

		diff = smc_curs_diff(cdcpend->conn->sndbuf_desc->len,
@@ -52,9 +53,7 @@ static void smc_cdc_tx_handler(struct smc_wr_tx_pend_priv *pnd_snd, 
		atomic_add(diff, &cdcpend->conn->sndbuf_space);

		/* guarantee 0 <= sndbuf_space <= sndbuf_desc->len */

		smp_mb__after_atomic();

		smc_curs_write(&cdcpend->conn->tx_curs_fin,

			       smc_curs_read(&cdcpend->cursor, cdcpend->conn),

			       cdcpend->conn);

		smc_curs_copy(&conn->tx_curs_fin, &cdcpend->cursor, conn);

	}

	smc_tx_sndbuf_nonfull(smc);

	bh_unlock_sock(&smc->sk);
@@ -110,9 +109,8 @@ int smc_cdc_msg_send(struct smc_connection *conn, 
			    &conn->local_tx_ctrl, conn);

	rc = smc_wr_tx_send(link, (struct smc_wr_tx_pend_priv *)pend);

	if (!rc)

		smc_curs_write(&conn->rx_curs_confirmed,

			       smc_curs_read(&conn->local_tx_ctrl.cons, conn),

			       conn);

		smc_curs_copy(&conn->rx_curs_confirmed,

			      &conn->local_tx_ctrl.cons, conn);



	return rc;

}
@@ -194,8 +192,8 @@ int smcd_cdc_msg_send(struct smc_connection *conn) 
	rc = smcd_tx_ism_write(conn, &cdc, sizeof(cdc), 0, 1);

	if (rc)

		return rc;

	smc_curs_write(&conn->rx_curs_confirmed,

		       smc_curs_read(&conn->local_tx_ctrl.cons, conn), conn);

	smc_curs_copy(&conn->rx_curs_confirmed, &conn->local_tx_ctrl.cons,

		      conn);

	/* Calculate transmitted data and increment free send buffer space */

	diff = smc_curs_diff(conn->sndbuf_desc->len, &conn->tx_curs_fin,

			     &conn->tx_curs_sent);
@@ -204,8 +202,7 @@ int smcd_cdc_msg_send(struct smc_connection *conn) 
	atomic_add(diff, &conn->sndbuf_space);

	/* guarantee 0 <= sndbuf_space <= sndbuf_desc->len */

	smp_mb__after_atomic();

	smc_curs_write(&conn->tx_curs_fin,

		       smc_curs_read(&conn->tx_curs_sent, conn), conn);

	smc_curs_copy(&conn->tx_curs_fin, &conn->tx_curs_sent, conn);



	smc_tx_sndbuf_nonfull(smc);

	return rc;
@@ -225,9 +222,7 @@ static void smc_cdc_handle_urg_data_arrival(struct smc_sock *smc, 
	char *base;



	/* new data included urgent business */

	smc_curs_write(&conn->urg_curs,

		       smc_curs_read(&conn->local_rx_ctrl.prod, conn),

		       conn);

	smc_curs_copy(&conn->urg_curs, &conn->local_rx_ctrl.prod, conn);

	conn->urg_state = SMC_URG_VALID;

	if (!sock_flag(&smc->sk, SOCK_URGINLINE))

		/* we'll skip the urgent byte, so don't account for it */
@@ -247,12 +242,8 @@ static void smc_cdc_msg_recv_action(struct smc_sock *smc, 
	struct smc_connection *conn = &smc->conn;

	int diff_cons, diff_prod;



	smc_curs_write(&prod_old,

		       smc_curs_read(&conn->local_rx_ctrl.prod, conn),

		       conn);

	smc_curs_write(&cons_old,

		       smc_curs_read(&conn->local_rx_ctrl.cons, conn),

		       conn);

	smc_curs_copy(&prod_old, &conn->local_rx_ctrl.prod, conn);

	smc_curs_copy(&cons_old, &conn->local_rx_ctrl.cons, conn);

	smc_cdc_msg_to_host(&conn->local_rx_ctrl, cdc, conn);



	diff_cons = smc_curs_diff(conn->peer_rmbe_size, &cons_old,
@@ -374,7 +365,7 @@ static void smc_cdc_rx_handler(struct ib_wc *wc, void *buf) 
		return; /* invalid message */



	/* lookup connection */

	lgr = container_of(link, struct smc_link_group, lnk[SMC_SINGLE_LINK]);

	lgr = smc_get_lgr(link);

	read_lock_bh(&lgr->conns_lock);

	conn = smc_lgr_find_conn(ntohl(cdc->token), lgr);

	read_unlock_bh(&lgr->conns_lock);

net/smc/smc_cdc.h

+15 −28
Original line number Diff line number Diff line
@@ -104,47 +104,34 @@ static inline u64 smc_curs_read(union smc_host_cursor *curs, 
#endif

}



static inline u64 smc_curs_read_net(union smc_cdc_cursor *curs,

				    struct smc_connection *conn)

{

#ifndef KERNEL_HAS_ATOMIC64

	unsigned long flags;

	u64 ret;



	spin_lock_irqsave(&conn->acurs_lock, flags);

	ret = curs->acurs;

	spin_unlock_irqrestore(&conn->acurs_lock, flags);

	return ret;

#else

	return atomic64_read(&curs->acurs);

#endif

}



static inline void smc_curs_write(union smc_host_cursor *curs, u64 val,

/* Copy cursor src into tgt */

static inline void smc_curs_copy(union smc_host_cursor *tgt,

				 union smc_host_cursor *src,

				 struct smc_connection *conn)

{

#ifndef KERNEL_HAS_ATOMIC64

	unsigned long flags;



	spin_lock_irqsave(&conn->acurs_lock, flags);

	curs->acurs = val;

	tgt->acurs = src->acurs;

	spin_unlock_irqrestore(&conn->acurs_lock, flags);

#else

	atomic64_set(&curs->acurs, val);

	atomic64_set(&tgt->acurs, atomic64_read(&src->acurs));

#endif

}



static inline void smc_curs_write_net(union smc_cdc_cursor *curs, u64 val,

static inline void smc_curs_copy_net(union smc_cdc_cursor *tgt,

				     union smc_cdc_cursor *src,

				     struct smc_connection *conn)

{

#ifndef KERNEL_HAS_ATOMIC64

	unsigned long flags;



	spin_lock_irqsave(&conn->acurs_lock, flags);

	curs->acurs = val;

	tgt->acurs = src->acurs;

	spin_unlock_irqrestore(&conn->acurs_lock, flags);

#else

	atomic64_set(&curs->acurs, val);

	atomic64_set(&tgt->acurs, atomic64_read(&src->acurs));

#endif

}
@@ -179,7 +166,7 @@ static inline void smc_host_cursor_to_cdc(union smc_cdc_cursor *peer, 
{

	union smc_host_cursor temp;



	smc_curs_write(&temp, smc_curs_read(local, conn), conn);

	smc_curs_copy(&temp, local, conn);

	peer->count = htonl(temp.count);

	peer->wrap = htons(temp.wrap);

	/* peer->reserved = htons(0); must be ensured by caller */
@@ -206,8 +193,8 @@ static inline void smc_cdc_cursor_to_host(union smc_host_cursor *local, 
	union smc_host_cursor temp, old;

	union smc_cdc_cursor net;



	smc_curs_write(&old, smc_curs_read(local, conn), conn);

	smc_curs_write_net(&net, smc_curs_read_net(peer, conn), conn);

	smc_curs_copy(&old, local, conn);

	smc_curs_copy_net(&net, peer, conn);

	temp.count = ntohl(net.count);

	temp.wrap = ntohs(net.wrap);

	if ((old.wrap > temp.wrap) && temp.wrap)
@@ -215,7 +202,7 @@ static inline void smc_cdc_cursor_to_host(union smc_host_cursor *local, 
	if ((old.wrap == temp.wrap) &&

	    (old.count > temp.count))

		return;

	smc_curs_write(local, smc_curs_read(&temp, conn), conn);

	smc_curs_copy(local, &temp, conn);

}



static inline void smcr_cdc_msg_to_host(struct smc_host_cdc_msg *local,

net/smc/smc_core.h

+6 −2
Original line number Diff line number Diff line
@@ -192,8 +192,7 @@ struct smc_link_group { 
			struct smc_rtoken	rtokens[SMC_RMBS_PER_LGR_MAX]

						[SMC_LINKS_PER_LGR_MAX];

						/* remote addr/key pairs */

			unsigned long		rtokens_used_mask[BITS_TO_LONGS

							(SMC_RMBS_PER_LGR_MAX)];

			DECLARE_BITMAP(rtokens_used_mask, SMC_RMBS_PER_LGR_MAX);

						/* used rtoken elements */

		};

		struct { /* SMC-D */
@@ -266,4 +265,9 @@ int smc_conn_create(struct smc_sock *smc, bool is_smcd, int srv_first_contact, 
		    u64 peer_gid);

void smcd_conn_free(struct smc_connection *conn);

void smc_core_exit(void);



static inline struct smc_link_group *smc_get_lgr(struct smc_link *link)

{

	return container_of(link, struct smc_link_group, lnk[SMC_SINGLE_LINK]);

}

#endif