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

Commit be244f28 authored by Hans Wippel's avatar Hans Wippel Committed by David S. Miller
Browse files

net/smc: add SMC-D support in data transfer 



The data transfer and CDC message headers differ in SMC-R and SMC-D.
This patch adds support for the SMC-D data transfer to the existing SMC
code. It consists of the following:

* SMC-D CDC support
* SMC-D tx support
* SMC-D rx support

The CDC header is stored at the beginning of the receive buffer. Thus, a
rx_offset variable is added for the CDC header offset within the buffer
(0 for SMC-R).

Signed-off-by: default avatarHans Wippel <hwippel@linux.ibm.com>
Signed-off-by: default avatarUrsula Braun <ubraun@linux.ibm.com>
Suggested-by: default avatarThomas Richter <tmricht@linux.ibm.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent c758dfdd

net/smc/smc.h

+5 −0
Original line number Diff line number Diff line
@@ -183,6 +183,11 @@ struct smc_connection { 
	spinlock_t		acurs_lock;	/* protect cursors */

#endif

	struct work_struct	close_work;	/* peer sent some closing */

	struct tasklet_struct	rx_tsklet;	/* Receiver tasklet for SMC-D */

	u8			rx_off;		/* receive offset:

						 * 0 for SMC-R, 32 for SMC-D

						 */

	u64			peer_token;	/* SMC-D token of peer */

};



struct smc_sock {				/* smc sock container */

net/smc/smc_cdc.c

+84 −2
Original line number Diff line number Diff line
@@ -117,7 +117,7 @@ int smc_cdc_msg_send(struct smc_connection *conn, 
	return rc;

}



int smc_cdc_get_slot_and_msg_send(struct smc_connection *conn)

static int smcr_cdc_get_slot_and_msg_send(struct smc_connection *conn)

{

	struct smc_cdc_tx_pend *pend;

	struct smc_wr_buf *wr_buf;
@@ -130,6 +130,21 @@ int smc_cdc_get_slot_and_msg_send(struct smc_connection *conn) 
	return smc_cdc_msg_send(conn, wr_buf, pend);

}



int smc_cdc_get_slot_and_msg_send(struct smc_connection *conn)

{

	int rc;



	if (conn->lgr->is_smcd) {

		spin_lock_bh(&conn->send_lock);

		rc = smcd_cdc_msg_send(conn);

		spin_unlock_bh(&conn->send_lock);

	} else {

		rc = smcr_cdc_get_slot_and_msg_send(conn);

	}



	return rc;

}



static bool smc_cdc_tx_filter(struct smc_wr_tx_pend_priv *tx_pend,

			      unsigned long data)

{
@@ -157,6 +172,45 @@ void smc_cdc_tx_dismiss_slots(struct smc_connection *conn) 
				(unsigned long)conn);

}



/* Send a SMC-D CDC header.

 * This increments the free space available in our send buffer.

 * Also update the confirmed receive buffer with what was sent to the peer.

 */

int smcd_cdc_msg_send(struct smc_connection *conn)

{

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

	struct smcd_cdc_msg cdc;

	int rc, diff;



	memset(&cdc, 0, sizeof(cdc));

	cdc.common.type = SMC_CDC_MSG_TYPE;

	cdc.prod_wrap = conn->local_tx_ctrl.prod.wrap;

	cdc.prod_count = conn->local_tx_ctrl.prod.count;



	cdc.cons_wrap = conn->local_tx_ctrl.cons.wrap;

	cdc.cons_count = conn->local_tx_ctrl.cons.count;

	cdc.prod_flags = conn->local_tx_ctrl.prod_flags;

	cdc.conn_state_flags = conn->local_tx_ctrl.conn_state_flags;

	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);

	/* 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);

	/* increased by confirmed number of bytes */

	smp_mb__before_atomic();

	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_tx_sndbuf_nonfull(smc);

	return rc;

}



/********************************* receive ***********************************/



static inline bool smc_cdc_before(u16 seq1, u16 seq2)
@@ -178,7 +232,7 @@ static void smc_cdc_handle_urg_data_arrival(struct smc_sock *smc, 
	if (!sock_flag(&smc->sk, SOCK_URGINLINE))

		/* we'll skip the urgent byte, so don't account for it */

		(*diff_prod)--;

	base = (char *)conn->rmb_desc->cpu_addr;

	base = (char *)conn->rmb_desc->cpu_addr + conn->rx_off;

	if (conn->urg_curs.count)

		conn->urg_rx_byte = *(base + conn->urg_curs.count - 1);

	else
@@ -276,6 +330,34 @@ static void smc_cdc_msg_recv(struct smc_sock *smc, struct smc_cdc_msg *cdc) 
	sock_put(&smc->sk); /* no free sk in softirq-context */

}



/* Schedule a tasklet for this connection. Triggered from the ISM device IRQ

 * handler to indicate update in the DMBE.

 *

 * Context:

 * - tasklet context

 */

static void smcd_cdc_rx_tsklet(unsigned long data)

{

	struct smc_connection *conn = (struct smc_connection *)data;

	struct smcd_cdc_msg cdc;

	struct smc_sock *smc;



	if (!conn)

		return;



	memcpy(&cdc, conn->rmb_desc->cpu_addr, sizeof(cdc));

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

	smc_cdc_msg_recv(smc, (struct smc_cdc_msg *)&cdc);

}



/* Initialize receive tasklet. Called from ISM device IRQ handler to start

 * receiver side.

 */

void smcd_cdc_rx_init(struct smc_connection *conn)

{

	tasklet_init(&conn->rx_tsklet, smcd_cdc_rx_tsklet, (unsigned long)conn);

}



/***************************** init, exit, misc ******************************/



static void smc_cdc_rx_handler(struct ib_wc *wc, void *buf)

net/smc/smc_cdc.h

+40 −3
Original line number Diff line number Diff line
@@ -50,6 +50,20 @@ struct smc_cdc_msg { 
	u8				reserved[18];

} __packed;					/* format defined in RFC7609 */



/* CDC message for SMC-D */

struct smcd_cdc_msg {

	struct smc_wr_rx_hdr common;	/* Type = 0xFE */

	u8 res1[7];

	u16 prod_wrap;

	u32 prod_count;

	u8 res2[2];

	u16 cons_wrap;

	u32 cons_count;

	struct smc_cdc_producer_flags	prod_flags;

	struct smc_cdc_conn_state_flags conn_state_flags;

	u8 res3[8];

} __packed;



static inline bool smc_cdc_rxed_any_close(struct smc_connection *conn)

{

	return conn->local_rx_ctrl.conn_state_flags.peer_conn_abort ||
@@ -204,7 +218,7 @@ static inline void smc_cdc_cursor_to_host(union smc_host_cursor *local, 
	smc_curs_write(local, smc_curs_read(&temp, conn), conn);

}



static inline void smc_cdc_msg_to_host(struct smc_host_cdc_msg *local,

static inline void smcr_cdc_msg_to_host(struct smc_host_cdc_msg *local,

					struct smc_cdc_msg *peer,

					struct smc_connection *conn)

{
@@ -218,6 +232,27 @@ static inline void smc_cdc_msg_to_host(struct smc_host_cdc_msg *local, 
	local->conn_state_flags = peer->conn_state_flags;

}



static inline void smcd_cdc_msg_to_host(struct smc_host_cdc_msg *local,

					struct smcd_cdc_msg *peer)

{

	local->prod.wrap = peer->prod_wrap;

	local->prod.count = peer->prod_count;

	local->cons.wrap = peer->cons_wrap;

	local->cons.count = peer->cons_count;

	local->prod_flags = peer->prod_flags;

	local->conn_state_flags = peer->conn_state_flags;

}



static inline void smc_cdc_msg_to_host(struct smc_host_cdc_msg *local,

				       struct smc_cdc_msg *peer,

				       struct smc_connection *conn)

{

	if (conn->lgr->is_smcd)

		smcd_cdc_msg_to_host(local, (struct smcd_cdc_msg *)peer);

	else

		smcr_cdc_msg_to_host(local, peer, conn);

}



struct smc_cdc_tx_pend;



int smc_cdc_get_free_slot(struct smc_connection *conn,
@@ -227,6 +262,8 @@ void smc_cdc_tx_dismiss_slots(struct smc_connection *conn); 
int smc_cdc_msg_send(struct smc_connection *conn, struct smc_wr_buf *wr_buf,

		     struct smc_cdc_tx_pend *pend);

int smc_cdc_get_slot_and_msg_send(struct smc_connection *conn);

int smcd_cdc_msg_send(struct smc_connection *conn);

int smc_cdc_init(void) __init;

void smcd_cdc_rx_init(struct smc_connection *conn);



#endif /* SMC_CDC_H */

net/smc/smc_core.c

+18 −7
Original line number Diff line number Diff line
@@ -281,10 +281,12 @@ void smc_conn_free(struct smc_connection *conn) 
{

	if (!conn->lgr)

		return;

	if (conn->lgr->is_smcd)

	if (conn->lgr->is_smcd) {

		smc_ism_unset_conn(conn);

	else

		tasklet_kill(&conn->rx_tsklet);

	} else {

		smc_cdc_tx_dismiss_slots(conn);

	}

	smc_lgr_unregister_conn(conn);

	smc_buf_unuse(conn);

}
@@ -324,10 +326,13 @@ static void smcr_buf_free(struct smc_link_group *lgr, bool is_rmb, 
static void smcd_buf_free(struct smc_link_group *lgr, bool is_dmb,

			  struct smc_buf_desc *buf_desc)

{

	if (is_dmb)

	if (is_dmb) {

		/* restore original buf len */

		buf_desc->len += sizeof(struct smcd_cdc_msg);

		smc_ism_unregister_dmb(lgr->smcd, buf_desc);

	else

	} else {

		kfree(buf_desc->cpu_addr);

	}

	kfree(buf_desc);

}
@@ -632,6 +637,10 @@ int smc_conn_create(struct smc_sock *smc, bool is_smcd, int srv_first_contact, 
	conn->local_tx_ctrl.common.type = SMC_CDC_MSG_TYPE;

	conn->local_tx_ctrl.len = SMC_WR_TX_SIZE;

	conn->urg_state = SMC_URG_READ;

	if (is_smcd) {

		conn->rx_off = sizeof(struct smcd_cdc_msg);

		smcd_cdc_rx_init(conn); /* init tasklet for this conn */

	}

#ifndef KERNEL_HAS_ATOMIC64

	spin_lock_init(&conn->acurs_lock);

#endif
@@ -776,8 +785,9 @@ static struct smc_buf_desc *smcd_new_buf_create(struct smc_link_group *lgr, 
			kfree(buf_desc);

			return ERR_PTR(-EAGAIN);

		}

		memset(buf_desc->cpu_addr, 0, bufsize);

		buf_desc->len = bufsize;

		buf_desc->pages = virt_to_page(buf_desc->cpu_addr);

		/* CDC header stored in buf. So, pretend it was smaller */

		buf_desc->len = bufsize - sizeof(struct smcd_cdc_msg);

	} else {

		buf_desc->cpu_addr = kzalloc(bufsize, GFP_KERNEL |

					     __GFP_NOWARN | __GFP_NORETRY |
@@ -854,7 +864,8 @@ static int __smc_buf_create(struct smc_sock *smc, bool is_smcd, bool is_rmb) 
		conn->rmbe_size_short = bufsize_short;

		smc->sk.sk_rcvbuf = bufsize * 2;

		atomic_set(&conn->bytes_to_rcv, 0);

		conn->rmbe_update_limit = smc_rmb_wnd_update_limit(bufsize);

		conn->rmbe_update_limit =

			smc_rmb_wnd_update_limit(buf_desc->len);

		if (is_smcd)

			smc_ism_set_conn(conn); /* map RMB/smcd_dev to conn */

	} else {

net/smc/smc_ism.c

+8 −0
Original line number Diff line number Diff line
@@ -302,5 +302,13 @@ EXPORT_SYMBOL_GPL(smcd_handle_event); 
 */

void smcd_handle_irq(struct smcd_dev *smcd, unsigned int dmbno)

{

	struct smc_connection *conn = NULL;

	unsigned long flags;



	spin_lock_irqsave(&smcd->lock, flags);

	conn = smcd->conn[dmbno];

	if (conn)

		tasklet_schedule(&conn->rx_tsklet);

	spin_unlock_irqrestore(&smcd->lock, flags);

}

EXPORT_SYMBOL_GPL(smcd_handle_irq);