Commit 387707fd authored by Karsten Graul's avatar Karsten Graul Committed by David S. Miller
Browse files

net/smc: convert static link ID to dynamic references 



As a preparation for the support of multiple links remove the usage of
a static link id (SMC_SINGLE_LINK) and allow dynamic link ids.

Signed-off-by: default avatarKarsten Graul <kgraul@linux.ibm.com>
Reviewed-by: default avatarUrsula Braun <ubraun@linux.ibm.com>
Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parent 026c381f

net/smc/af_smc.c

+6 −11
Original line number Diff line number Diff line
@@ -343,7 +343,7 @@ static int smc_reg_rmb(struct smc_link *link, struct smc_buf_desc *rmb_desc, 
{

	if (!rmb_desc->wr_reg) {

		/* register memory region for new rmb */

		if (smc_wr_reg_send(link, rmb_desc->mr_rx[SMC_SINGLE_LINK])) {

		if (smc_wr_reg_send(link, rmb_desc->mr_rx[link->link_idx])) {

			rmb_desc->regerr = 1;

			return -EFAULT;

		}
@@ -362,12 +362,10 @@ static int smc_reg_rmb(struct smc_link *link, struct smc_buf_desc *rmb_desc, 
static int smc_clnt_conf_first_link(struct smc_sock *smc)

{

	struct net *net = sock_net(smc->clcsock->sk);

	struct smc_link_group *lgr = smc->conn.lgr;

	struct smc_link *link;

	struct smc_link *link = smc->conn.lnk;

	int rest;

	int rc;



	link = &lgr->lnk[SMC_SINGLE_LINK];

	/* receive CONFIRM LINK request from server over RoCE fabric */

	rest = wait_for_completion_interruptible_timeout(

		&link->llc_confirm,
@@ -610,7 +608,7 @@ static int smc_connect_rdma(struct smc_sock *smc, 
		mutex_unlock(&smc_client_lgr_pending);

		return reason_code;

	}

	link = &smc->conn.lgr->lnk[SMC_SINGLE_LINK];

	link = smc->conn.lnk;



	smc_conn_save_peer_info(smc, aclc);
@@ -1002,13 +1000,10 @@ void smc_close_non_accepted(struct sock *sk) 
static int smc_serv_conf_first_link(struct smc_sock *smc)

{

	struct net *net = sock_net(smc->clcsock->sk);

	struct smc_link_group *lgr = smc->conn.lgr;

	struct smc_link *link;

	struct smc_link *link = smc->conn.lnk;

	int rest;

	int rc;



	link = &lgr->lnk[SMC_SINGLE_LINK];



	if (smc_reg_rmb(link, smc->conn.rmb_desc, false))

		return SMC_CLC_DECL_ERR_REGRMB;
@@ -1194,7 +1189,7 @@ static int smc_listen_ism_init(struct smc_sock *new_smc, 
/* listen worker: register buffers */

static int smc_listen_rdma_reg(struct smc_sock *new_smc, int local_contact)

{

	struct smc_link *link = &new_smc->conn.lgr->lnk[SMC_SINGLE_LINK];

	struct smc_link *link = new_smc->conn.lnk;



	if (local_contact != SMC_FIRST_CONTACT) {

		if (smc_reg_rmb(link, new_smc->conn.rmb_desc, true))
@@ -1210,7 +1205,7 @@ static int smc_listen_rdma_finish(struct smc_sock *new_smc, 
				  struct smc_clc_msg_accept_confirm *cclc,

				  int local_contact)

{

	struct smc_link *link = &new_smc->conn.lgr->lnk[SMC_SINGLE_LINK];

	struct smc_link *link = new_smc->conn.lnk;

	int reason_code = 0;



	if (local_contact == SMC_FIRST_CONTACT)

net/smc/smc.h

+1 −0
Original line number Diff line number Diff line
@@ -121,6 +121,7 @@ enum smc_urg_state { 
struct smc_connection {

	struct rb_node		alert_node;

	struct smc_link_group	*lgr;		/* link group of connection */

	struct smc_link		*lnk;		/* assigned SMC-R link */

	u32			alert_token_local; /* unique conn. id */

	u8			peer_rmbe_idx;	/* from tcp handshake */

	int			peer_rmbe_size;	/* size of peer rx buffer */

net/smc/smc_cdc.c

+3 −5
Original line number Diff line number Diff line
@@ -57,7 +57,7 @@ int smc_cdc_get_free_slot(struct smc_connection *conn, 
			  struct smc_rdma_wr **wr_rdma_buf,

			  struct smc_cdc_tx_pend **pend)

{

	struct smc_link *link = &conn->lgr->lnk[SMC_SINGLE_LINK];

	struct smc_link *link = conn->lnk;

	int rc;



	rc = smc_wr_tx_get_free_slot(link, smc_cdc_tx_handler, wr_buf,
@@ -91,12 +91,10 @@ int smc_cdc_msg_send(struct smc_connection *conn, 
		     struct smc_wr_buf *wr_buf,

		     struct smc_cdc_tx_pend *pend)

{

	struct smc_link *link = conn->lnk;

	union smc_host_cursor cfed;

	struct smc_link *link;

	int rc;



	link = &conn->lgr->lnk[SMC_SINGLE_LINK];



	smc_cdc_add_pending_send(conn, pend);



	conn->tx_cdc_seq++;
@@ -165,7 +163,7 @@ static void smc_cdc_tx_dismisser(struct smc_wr_tx_pend_priv *tx_pend) 


void smc_cdc_tx_dismiss_slots(struct smc_connection *conn)

{

	struct smc_link *link = &conn->lgr->lnk[SMC_SINGLE_LINK];

	struct smc_link *link = conn->lnk;



	smc_wr_tx_dismiss_slots(link, SMC_CDC_MSG_TYPE,

				smc_cdc_tx_filter, smc_cdc_tx_dismisser,

net/smc/smc_clc.c

+6 −6
Original line number Diff line number Diff line
@@ -496,7 +496,7 @@ int smc_clc_send_confirm(struct smc_sock *smc) 
		       sizeof(SMCD_EYECATCHER));

	} else {

		/* SMC-R specific settings */

		link = &conn->lgr->lnk[SMC_SINGLE_LINK];

		link = conn->lnk;

		memcpy(cclc.hdr.eyecatcher, SMC_EYECATCHER,

		       sizeof(SMC_EYECATCHER));

		cclc.hdr.path = SMC_TYPE_R;
@@ -508,13 +508,13 @@ int smc_clc_send_confirm(struct smc_sock *smc) 
		       ETH_ALEN);

		hton24(cclc.qpn, link->roce_qp->qp_num);

		cclc.rmb_rkey =

			htonl(conn->rmb_desc->mr_rx[SMC_SINGLE_LINK]->rkey);

			htonl(conn->rmb_desc->mr_rx[link->link_idx]->rkey);

		cclc.rmbe_idx = 1; /* for now: 1 RMB = 1 RMBE */

		cclc.rmbe_alert_token = htonl(conn->alert_token_local);

		cclc.qp_mtu = min(link->path_mtu, link->peer_mtu);

		cclc.rmbe_size = conn->rmbe_size_short;

		cclc.rmb_dma_addr = cpu_to_be64((u64)sg_dma_address

				(conn->rmb_desc->sgt[SMC_SINGLE_LINK].sgl));

				(conn->rmb_desc->sgt[link->link_idx].sgl));

		hton24(cclc.psn, link->psn_initial);

		memcpy(cclc.smcr_trl.eyecatcher, SMC_EYECATCHER,

		       sizeof(SMC_EYECATCHER));
@@ -572,7 +572,7 @@ int smc_clc_send_accept(struct smc_sock *new_smc, int srv_first_contact) 
		memcpy(aclc.hdr.eyecatcher, SMC_EYECATCHER,

		       sizeof(SMC_EYECATCHER));

		aclc.hdr.path = SMC_TYPE_R;

		link = &conn->lgr->lnk[SMC_SINGLE_LINK];

		link = conn->lnk;

		memcpy(aclc.lcl.id_for_peer, local_systemid,

		       sizeof(local_systemid));

		memcpy(&aclc.lcl.gid, link->gid, SMC_GID_SIZE);
@@ -580,13 +580,13 @@ int smc_clc_send_accept(struct smc_sock *new_smc, int srv_first_contact) 
		       ETH_ALEN);

		hton24(aclc.qpn, link->roce_qp->qp_num);

		aclc.rmb_rkey =

			htonl(conn->rmb_desc->mr_rx[SMC_SINGLE_LINK]->rkey);

			htonl(conn->rmb_desc->mr_rx[link->link_idx]->rkey);

		aclc.rmbe_idx = 1;		/* as long as 1 RMB = 1 RMBE */

		aclc.rmbe_alert_token = htonl(conn->alert_token_local);

		aclc.qp_mtu = link->path_mtu;

		aclc.rmbe_size = conn->rmbe_size_short,

		aclc.rmb_dma_addr = cpu_to_be64((u64)sg_dma_address

				(conn->rmb_desc->sgt[SMC_SINGLE_LINK].sgl));

				(conn->rmb_desc->sgt[link->link_idx].sgl));

		hton24(aclc.psn, link->psn_initial);

		memcpy(aclc.smcr_trl.eyecatcher, SMC_EYECATCHER,

		       sizeof(SMC_EYECATCHER));

net/smc/smc_core.c

+33 −33
Original line number Diff line number Diff line
@@ -131,6 +131,11 @@ static void smc_lgr_register_conn(struct smc_connection *conn) 
			conn->alert_token_local = 0;

	}

	smc_lgr_add_alert_token(conn);



	/* assign the new connection to a link */

	if (!conn->lgr->is_smcd)

		conn->lnk = &conn->lgr->lnk[SMC_SINGLE_LINK];



	conn->lgr->conns_num++;

}
@@ -275,6 +280,7 @@ static int smcr_link_init(struct smc_link_group *lgr, struct smc_link *lnk, 
	atomic_inc(&ini->ib_dev->lnk_cnt);

	lnk->state = SMC_LNK_ACTIVATING;

	lnk->link_id = smcr_next_link_id(lgr);

	lnk->lgr = lgr;

	lnk->link_idx = link_idx;

	lnk->smcibdev = ini->ib_dev;

	lnk->ibport = ini->ib_port;
@@ -421,7 +427,7 @@ static void smc_buf_unuse(struct smc_connection *conn, 
			if (!lgr->is_smcd && !list_empty(&lgr->list)) {

				/* unregister rmb with peer */

				smc_llc_do_delete_rkey(

						&lgr->lnk[SMC_SINGLE_LINK],

						conn->lnk,

						conn->rmb_desc);

			}

			conn->rmb_desc->used = 0;
@@ -479,16 +485,15 @@ static void smcr_buf_free(struct smc_link_group *lgr, bool is_rmb, 
	struct smc_link *lnk = &lgr->lnk[SMC_SINGLE_LINK];



	if (is_rmb) {

		if (buf_desc->mr_rx[SMC_SINGLE_LINK])

		if (buf_desc->mr_rx[lnk->link_idx])

			smc_ib_put_memory_region(

					buf_desc->mr_rx[SMC_SINGLE_LINK]);

		smc_ib_buf_unmap_sg(lnk->smcibdev, buf_desc,

				    DMA_FROM_DEVICE);

					buf_desc->mr_rx[lnk->link_idx]);

		smc_ib_buf_unmap_sg(lnk, buf_desc, DMA_FROM_DEVICE);

	} else {

		smc_ib_buf_unmap_sg(lnk->smcibdev, buf_desc,

				    DMA_TO_DEVICE);

		smc_ib_buf_unmap_sg(lnk, buf_desc, DMA_TO_DEVICE);

	}

	sg_free_table(&buf_desc->sgt[SMC_SINGLE_LINK]);

	sg_free_table(&buf_desc->sgt[lnk->link_idx]);



	if (buf_desc->pages)

		__free_pages(buf_desc->pages, buf_desc->order);

	kfree(buf_desc);
@@ -1026,17 +1031,16 @@ static struct smc_buf_desc *smcr_new_buf_create(struct smc_link_group *lgr, 


	/* build the sg table from the pages */

	lnk = &lgr->lnk[SMC_SINGLE_LINK];

	rc = sg_alloc_table(&buf_desc->sgt[SMC_SINGLE_LINK], 1,

			    GFP_KERNEL);

	rc = sg_alloc_table(&buf_desc->sgt[lnk->link_idx], 1, GFP_KERNEL);

	if (rc) {

		smc_buf_free(lgr, is_rmb, buf_desc);

		return ERR_PTR(rc);

	}

	sg_set_buf(buf_desc->sgt[SMC_SINGLE_LINK].sgl,

	sg_set_buf(buf_desc->sgt[lnk->link_idx].sgl,

		   buf_desc->cpu_addr, bufsize);



	/* map sg table to DMA address */

	rc = smc_ib_buf_map_sg(lnk->smcibdev, buf_desc,

	rc = smc_ib_buf_map_sg(lnk, buf_desc,

			       is_rmb ? DMA_FROM_DEVICE : DMA_TO_DEVICE);

	/* SMC protocol depends on mapping to one DMA address only */

	if (rc != 1)  {
@@ -1049,7 +1053,7 @@ static struct smc_buf_desc *smcr_new_buf_create(struct smc_link_group *lgr, 
		rc = smc_ib_get_memory_region(lnk->roce_pd,

					      IB_ACCESS_REMOTE_WRITE |

					      IB_ACCESS_LOCAL_WRITE,

					      buf_desc);

					      buf_desc, lnk->link_idx);

		if (rc) {

			smc_buf_free(lgr, is_rmb, buf_desc);

			return ERR_PTR(rc);
@@ -1174,22 +1178,16 @@ static int __smc_buf_create(struct smc_sock *smc, bool is_smcd, bool is_rmb) 


void smc_sndbuf_sync_sg_for_cpu(struct smc_connection *conn)

{

	struct smc_link_group *lgr = conn->lgr;



	if (!conn->lgr || conn->lgr->is_smcd)

		return;

	smc_ib_sync_sg_for_cpu(lgr->lnk[SMC_SINGLE_LINK].smcibdev,

			       conn->sndbuf_desc, DMA_TO_DEVICE);

	smc_ib_sync_sg_for_cpu(conn->lnk, conn->sndbuf_desc, DMA_TO_DEVICE);

}



void smc_sndbuf_sync_sg_for_device(struct smc_connection *conn)

{

	struct smc_link_group *lgr = conn->lgr;



	if (!conn->lgr || conn->lgr->is_smcd)

		return;

	smc_ib_sync_sg_for_device(lgr->lnk[SMC_SINGLE_LINK].smcibdev,

				  conn->sndbuf_desc, DMA_TO_DEVICE);

	smc_ib_sync_sg_for_device(conn->lnk, conn->sndbuf_desc, DMA_TO_DEVICE);

}



void smc_rmb_sync_sg_for_cpu(struct smc_connection *conn)
@@ -1198,7 +1196,7 @@ void smc_rmb_sync_sg_for_cpu(struct smc_connection *conn) 


	if (!conn->lgr || conn->lgr->is_smcd)

		return;

	smc_ib_sync_sg_for_cpu(lgr->lnk[SMC_SINGLE_LINK].smcibdev,

	smc_ib_sync_sg_for_cpu(&lgr->lnk[SMC_SINGLE_LINK],

			       conn->rmb_desc, DMA_FROM_DEVICE);

}
@@ -1208,7 +1206,7 @@ void smc_rmb_sync_sg_for_device(struct smc_connection *conn) 


	if (!conn->lgr || conn->lgr->is_smcd)

		return;

	smc_ib_sync_sg_for_device(lgr->lnk[SMC_SINGLE_LINK].smcibdev,

	smc_ib_sync_sg_for_device(&lgr->lnk[SMC_SINGLE_LINK],

				  conn->rmb_desc, DMA_FROM_DEVICE);

}
@@ -1245,15 +1243,16 @@ static inline int smc_rmb_reserve_rtoken_idx(struct smc_link_group *lgr) 
}



/* add a new rtoken from peer */

int smc_rtoken_add(struct smc_link_group *lgr, __be64 nw_vaddr, __be32 nw_rkey)

int smc_rtoken_add(struct smc_link *lnk, __be64 nw_vaddr, __be32 nw_rkey)

{

	struct smc_link_group *lgr = smc_get_lgr(lnk);

	u64 dma_addr = be64_to_cpu(nw_vaddr);

	u32 rkey = ntohl(nw_rkey);

	int i;



	for (i = 0; i < SMC_RMBS_PER_LGR_MAX; i++) {

		if ((lgr->rtokens[i][SMC_SINGLE_LINK].rkey == rkey) &&

		    (lgr->rtokens[i][SMC_SINGLE_LINK].dma_addr == dma_addr) &&

		if (lgr->rtokens[i][lnk->link_idx].rkey == rkey &&

		    lgr->rtokens[i][lnk->link_idx].dma_addr == dma_addr &&

		    test_bit(i, lgr->rtokens_used_mask)) {

			/* already in list */

			return i;
@@ -1262,22 +1261,23 @@ int smc_rtoken_add(struct smc_link_group *lgr, __be64 nw_vaddr, __be32 nw_rkey) 
	i = smc_rmb_reserve_rtoken_idx(lgr);

	if (i < 0)

		return i;

	lgr->rtokens[i][SMC_SINGLE_LINK].rkey = rkey;

	lgr->rtokens[i][SMC_SINGLE_LINK].dma_addr = dma_addr;

	lgr->rtokens[i][lnk->link_idx].rkey = rkey;

	lgr->rtokens[i][lnk->link_idx].dma_addr = dma_addr;

	return i;

}



/* delete an rtoken */

int smc_rtoken_delete(struct smc_link_group *lgr, __be32 nw_rkey)

int smc_rtoken_delete(struct smc_link *lnk, __be32 nw_rkey)

{

	struct smc_link_group *lgr = smc_get_lgr(lnk);

	u32 rkey = ntohl(nw_rkey);

	int i;



	for (i = 0; i < SMC_RMBS_PER_LGR_MAX; i++) {

		if (lgr->rtokens[i][SMC_SINGLE_LINK].rkey == rkey &&

		if (lgr->rtokens[i][lnk->link_idx].rkey == rkey &&

		    test_bit(i, lgr->rtokens_used_mask)) {

			lgr->rtokens[i][SMC_SINGLE_LINK].rkey = 0;

			lgr->rtokens[i][SMC_SINGLE_LINK].dma_addr = 0;

			lgr->rtokens[i][lnk->link_idx].rkey = 0;

			lgr->rtokens[i][lnk->link_idx].dma_addr = 0;



			clear_bit(i, lgr->rtokens_used_mask);

			return 0;
@@ -1290,7 +1290,7 @@ int smc_rtoken_delete(struct smc_link_group *lgr, __be32 nw_rkey) 
int smc_rmb_rtoken_handling(struct smc_connection *conn,

			    struct smc_clc_msg_accept_confirm *clc)

{

	conn->rtoken_idx = smc_rtoken_add(conn->lgr, clc->rmb_dma_addr,

	conn->rtoken_idx = smc_rtoken_add(conn->lnk, clc->rmb_dma_addr,

					  clc->rmb_rkey);

	if (conn->rtoken_idx < 0)

		return conn->rtoken_idx;