net/smc: preparations for SMC-R link failover
cover net/smc: preparations for SMC-R link failover
This patch series prepares the SMC code for the implementation of SMC-R link failover capabilities which are still missing to reach full compliance with RFC 7609.
The code changes are separated into 65 patches which together form the new functionality. I tried to create meaningful patches which allow to follow the implementation.
Question: how to handle the remaining 52 patches? All of them are needed for link failover to work and should make it into the same merge window. Can I send them all together?
The SMC-R implementation will transparently make use of the link failover feature when matching RoCE devices are available, no special setup is required. All RoCE devices with the same PNET ID as the TCP device (hardware-defined or user-defined via the smc_pnet tool) are candidates to get used to form a link in a link group. When at least 2 RoCE devices are available on both communication endpoints then a symmetric link group is formed, meaning the link group has 2 independent links. If one RoCE device goes down then all connections on this link are moved to the surviving link. Upon recovery of the failing device or availability of a new one, the symmetric link group will be restored.
Karsten Graul (13):
net/smc: rework pnet table to support SMC-R failover net/smc: separate function for link initialization net/smc: introduce link_idx for link group array net/smc: convert static link ID to dynamic references net/smc: convert static link ID instances to support multiple links net/smc: multi-link support for smc_rmb_rtoken_handling() net/smc: add new link state and related helpers
net/smc: move testlink work to system work queue net/smc: simplify link deactivation
net/smc: use worker to process incoming llc messages net/smc: process llc responses in tasklet context net/smc: use mutex instead of rwlock_t to protect buffers net/smc: move llc layer related init and clear into smc_llc.c
net/smc/af_smc.c | 79 ++++--- net/smc/smc.h | 1 + net/smc/smc_cdc.c | 8 +- net/smc/smc_clc.c | 12 +- net/smc/smc_clc.h | 1 + net/smc/smc_core.c | 542 +++++++++++++++++++++++++++++---------------- net/smc/smc_core.h | 78 ++++--- net/smc/smc_ib.c | 63 +++--- net/smc/smc_ib.h | 10 +- net/smc/smc_ism.c | 3 +- net/smc/smc_llc.c | 396 ++++++++++++++++++--------------- net/smc/smc_llc.h | 16 +- net/smc/smc_pnet.c | 539 +++++++++++++++++++++++++------------------- net/smc/smc_pnet.h | 2 + net/smc/smc_tx.c | 13 +- net/smc/smc_wr.c | 2 +- 16 files changed, 1063 insertions(+), 702 deletions(-)
Signature · 1 line
2.17.1
PATCH 1/13 net/smc: rework pnet table to support SMC-R failover
The pnet table stored pnet ids in the smc device structures. When a device is going down its smc device structure is freed, and when the device is brought online again it no longer has a pnet id set. Rework the pnet table implementation to store the device name with their assigned pnet id and apply the pnet id to devices when they are registered.
--- net/smc/smc_ib.c | 5 +- net/smc/smc_ism.c | 3 +- net/smc/smc_pnet.c | 539 ++++++++++++++++++++++++++------------------- net/smc/smc_pnet.h | 2 + 4 files changed, 319 insertions(+), 230 deletions(-)
net/smc/smc_ib.c +3 -2
@@ -579,8 +579,9 @@ static void smc_ib_add_dev(struct ib_device *ibdev) i++) {set_bit (i, &smcibdev->port_event_mask);/* determine pnetids of the port */ -smc_pnetid_by_dev_port (ibdev->dev.parent, i, - smcibdev->pnetid[i]); +if (smc_pnetid_by_dev_port (ibdev->dev.parent, i, + smcibdev->pnetid[i])) +smc_pnetid_by_table_ib (smcibdev, i +1 ); }schedule_work (&smcibdev->port_event_work); }
net/smc/smc_ism.c +2 -1
@@ -296,7 +296,8 @@ struct smcd_dev *smcd_alloc_dev(struct device *parent, const char *name,device_initialize (&smcd->dev);dev_set_name (&smcd->dev, name); smcd->ops = ops; -smc_pnetid_by_dev_port (parent,0 , smcd->pnetid); +if (smc_pnetid_by_dev_port (parent,0 , smcd->pnetid)) +smc_pnetid_by_table_smcd (smcd);spin_lock_init (&smcd->lock);spin_lock_init (&smcd->lgr_lock);
net/smc/smc_pnet.c +312 -227
713 lines not on this page · raw message
net/smc/smc_pnet.h +2 -0
@@ -46,5 +46,7 @@ void smc_pnet_exit(void);void smc_pnet_net_exit (struct net *net);void smc_pnet_find_roce_resource (struct sock *sk,struct smc_init_info *ini);void smc_pnet_find_ism_resource (struct sock *sk,struct smc_init_info *ini); +int smc_pnetid_by_table_ib (struct smc_ib_device *smcibdev,u8 ib_port); +int smc_pnetid_by_table_smcd (struct smcd_dev *smcd);#endif
Signature · 1 line
2.17.1
PATCH 2/13 net/smc: separate function for link initialization
In reply to Karsten GraulMove the initialization of a new link into its own function, separate from smc_lgr_create, to allow more than one link per link group. Do an extra check if the IB device initialization was successful, and reset the link state if any error occurs during smcr_link_init(). And rename two existing functions to use the prefix smcr_ to indicate that they belong to the SMC-R code path.
--- net/smc/smc_core.c | 114 ++++++++++++++++++++++++++------------------- 1 file changed, 66 insertions(+), 48 deletions(-)
net/smc/smc_core.c +66 -48
@@ -179,7 +179,7 @@ void smc_lgr_cleanup_early(struct smc_connection *conn)* of the DELETE LINK sequence from server; or as server to * initiate the delete processing. See smc_llc_rx_delete_link(). */ -static int smc_link_send_delete (struct smc_link *lnk,bool orderly) +static int smcr_link_send_delete (struct smc_link *lnk,bool orderly) {if (lnk->state ==SMC_LNK_ACTIVE && !smc_llc_send_delete_link (lnk,SMC_LLC_REQ , orderly)) {
@@ -219,7 +219,7 @@ static void smc_lgr_free_work(struct work_struct *work)if (!lgr->is_smcd && !lgr->terminating) {/* try to send del link msg, on error free lgr immediately */ if (lnk->state ==SMC_LNK_ACTIVE && - !smc_link_send_delete (lnk, true)) { + !smcr_link_send_delete (lnk, true)) {/* reschedule in case we never receive a response */ smc_lgr_schedule_free_work (lgr);spin_unlock_bh (lgr_lock);
@@ -245,6 +245,64 @@ static void smc_lgr_terminate_work(struct work_struct *work)__smc_lgr_terminate (lgr, true); } +static int smcr_link_init (struct smc_link *lnk,u8 link_id, +struct smc_init_info *ini) +{ +u8 rndvec[3 ]; +int rc; + +get_device (&ini->ib_dev->ibdev->dev); +atomic_inc (&ini->ib_dev->lnk_cnt); + lnk->state =SMC_LNK_ACTIVATING ; + lnk->link_id = link_id; + lnk->smcibdev = ini->ib_dev; + lnk->ibport = ini->ib_port; + lnk->path_mtu = ini->ib_dev->pattr[ini->ib_port -1 ].active_mtu; +if (!ini->ib_dev->initialized) { + rc = (int )smc_ib_setup_per_ibdev (ini->ib_dev); +if (rc) + goto out; + } +get_random_bytes (rndvec,sizeof (rndvec)); + lnk->psn_initial = rndvec[0 ] + (rndvec[1 ] <<8 ) + + (rndvec[2 ] <<16 ); + rc =smc_ib_determine_gid (lnk->smcibdev, lnk->ibport, + ini->vlan_id, lnk->gid, &lnk->sgid_index); +if (rc) + goto out; + rc =smc_llc_link_init (lnk); +if (rc) + goto out; + rc =smc_wr_alloc_link_mem (lnk); +if (rc) + goto clear_llc_lnk; + rc =smc_ib_create_protection_domain (lnk); +if (rc) + goto free_link_mem; + rc =smc_ib_create_queue_pair (lnk); +if (rc) + goto dealloc_pd; + rc =smc_wr_create_link (lnk); +if (rc) + goto destroy_qp; +return 0 ; + +destroy_qp: +smc_ib_destroy_queue_pair (lnk); +dealloc_pd: +smc_ib_dealloc_protection_domain (lnk); +free_link_mem: +smc_wr_free_link_mem (lnk); +clear_llc_lnk: +smc_llc_link_clear (lnk); +out: +put_device (&ini->ib_dev->ibdev->dev); +memset (lnk,0 ,sizeof (struct smc_link )); +if (!atomic_dec_return (&ini->ib_dev->lnk_cnt)) +wake_up (&ini->ib_dev->lnks_deleted); +return rc; +} +/* create a new SMC link group */ static int smc_lgr_create (struct smc_sock *smc,struct smc_init_info *ini) {
@@ -252,7 +310,6 @@ static int smc_lgr_create(struct smc_sock *smc, struct smc_init_info *ini)struct list_head *lgr_list;struct smc_link *lnk;spinlock_t *lgr_lock; -u8 rndvec[3 ];int rc =0 ;int i;
@@ -297,48 +354,17 @@ static int smc_lgr_create(struct smc_sock *smc, struct smc_init_info *ini)atomic_inc (&ini->ism_dev->lgr_cnt); }else {/* SMC-R specific settings */ -get_device (&ini->ib_dev->ibdev->dev); lgr->role = smc->listen_smc ?SMC_SERV :SMC_CLNT ;memcpy (lgr->peer_systemid, ini->ib_lcl->id_for_peer,SMC_SYSTEMID_LEN ); lnk = &lgr->lnk[SMC_SINGLE_LINK ]; -/* initialize link */ - lnk->state =SMC_LNK_ACTIVATING ; - lnk->link_id =SMC_SINGLE_LINK ; - lnk->smcibdev = ini->ib_dev; - lnk->ibport = ini->ib_port; - lgr_list = &smc_lgr_list.list; - lgr_lock = &smc_lgr_list.lock; - lnk->path_mtu = - ini->ib_dev->pattr[ini->ib_port -1 ].active_mtu; -if (!ini->ib_dev->initialized) -smc_ib_setup_per_ibdev (ini->ib_dev); -get_random_bytes (rndvec,sizeof (rndvec)); - lnk->psn_initial = rndvec[0 ] + (rndvec[1 ] <<8 ) + - (rndvec[2 ] <<16 ); - rc =smc_ib_determine_gid (lnk->smcibdev, lnk->ibport, - ini->vlan_id, lnk->gid, - &lnk->sgid_index); -if (rc) - goto free_lgr; - rc =smc_llc_link_init (lnk); + rc =smcr_link_init (lnk,SMC_SINGLE_LINK , ini);if (rc) goto free_lgr; - rc =smc_wr_alloc_link_mem (lnk); -if (rc) - goto clear_llc_lnk; - rc =smc_ib_create_protection_domain (lnk); -if (rc) - goto free_link_mem; - rc =smc_ib_create_queue_pair (lnk); -if (rc) - goto dealloc_pd; - rc =smc_wr_create_link (lnk); -if (rc) - goto destroy_qp; + lgr_list = &smc_lgr_list.list; + lgr_lock = &smc_lgr_list.lock;atomic_inc (&lgr_cnt); -atomic_inc (&ini->ib_dev->lnk_cnt); } smc->conn.lgr = lgr;spin_lock_bh (lgr_lock);
@@ -346,14 +372,6 @@ static int smc_lgr_create(struct smc_sock *smc, struct smc_init_info *ini)spin_unlock_bh (lgr_lock);return 0 ; -destroy_qp: -smc_ib_destroy_queue_pair (lnk); -dealloc_pd: -smc_ib_dealloc_protection_domain (lnk); -free_link_mem: -smc_wr_free_link_mem (lnk); -clear_llc_lnk: -smc_llc_link_clear (lnk); free_lgr:kfree (lgr); ism_put_vlan:
@@ -417,7 +435,7 @@ void smc_conn_free(struct smc_connection *conn)smc_lgr_schedule_free_work (lgr); } -static void smc_link_clear (struct smc_link *lnk) +static void smcr_link_clear (struct smc_link *lnk) { lnk->peer_qpn =0 ;smc_llc_link_clear (lnk);
@@ -426,6 +444,7 @@ static void smc_link_clear(struct smc_link *lnk)smc_ib_destroy_queue_pair (lnk);smc_ib_dealloc_protection_domain (lnk);smc_wr_free_link_mem (lnk); +put_device (&lnk->smcibdev->ibdev->dev);if (!atomic_dec_return (&lnk->smcibdev->lnk_cnt))wake_up (&lnk->smcibdev->lnks_deleted); }
@@ -512,8 +531,7 @@ static void smc_lgr_free(struct smc_link_group *lgr)if (!atomic_dec_return (&lgr->smcd->lgr_cnt))wake_up (&lgr->smcd->lgrs_deleted); }else { -smc_link_clear (&lgr->lnk[SMC_SINGLE_LINK ]); -put_device (&lgr->lnk[SMC_SINGLE_LINK ].smcibdev->ibdev->dev); +smcr_link_clear (&lgr->lnk[SMC_SINGLE_LINK ]);if (!atomic_dec_return (&lgr_cnt))wake_up (&lgrs_deleted); }
Signature · 1 line
2.17.1
PATCH 3/13 net/smc: introduce link_idx for link group array
In reply to Karsten GraulThe link_id is the index of the link in the array of the link group. When a link in the array is reused for a new link, a different unique link_id should be used, otherwise the index in the array could collide with the previous link at this array position.
Use a new variable link_idx as array index, and make link_id an increasing unique id value.
--- net/smc/smc_core.c | 34 +++++++++++++++++++++++++++++----- net/smc/smc_core.h | 2 ++ 2 files changed, 31 insertions(+), 5 deletions(-)
net/smc/smc_core.c +29 -5
@@ -245,8 +245,28 @@ static void smc_lgr_terminate_work(struct work_struct *work)__smc_lgr_terminate (lgr, true); } -static int smcr_link_init (struct smc_link *lnk,u8 link_id, -struct smc_init_info *ini) +/* return next unique link id for the lgr */ +static u8 smcr_next_link_id (struct smc_link_group *lgr) +{ +u8 link_id; +int i; + +while (1 ) { + link_id = ++lgr->next_link_id; +if (!link_id)/* skip zero as link_id */ + link_id = ++lgr->next_link_id; +for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) { +if (lgr->lnk[i].state !=SMC_LNK_INACTIVE && + lgr->lnk[i].link_id == link_id) +continue ; + } +break ; + } +return link_id; +} + +static int smcr_link_init (struct smc_link_group *lgr,struct smc_link *lnk, +u8 link_idx,struct smc_init_info *ini) {u8 rndvec[3 ];int rc;
@@ -254,7 +274,8 @@ static int smcr_link_init(struct smc_link *lnk, u8 link_id,get_device (&ini->ib_dev->ibdev->dev);atomic_inc (&ini->ib_dev->lnk_cnt); lnk->state =SMC_LNK_ACTIVATING ; - lnk->link_id = link_id; + lnk->link_id =smcr_next_link_id (lgr); + lnk->link_idx = link_idx; lnk->smcibdev = ini->ib_dev; lnk->ibport = ini->ib_port; lnk->path_mtu = ini->ib_dev->pattr[ini->ib_port -1 ].active_mtu;
@@ -310,6 +331,7 @@ static int smc_lgr_create(struct smc_sock *smc, struct smc_init_info *ini)struct list_head *lgr_list;struct smc_link *lnk;spinlock_t *lgr_lock; +u8 link_idx;int rc =0 ;int i;
@@ -338,6 +360,7 @@ static int smc_lgr_create(struct smc_sock *smc, struct smc_init_info *ini)INIT_LIST_HEAD (&lgr->sndbufs[i]);INIT_LIST_HEAD (&lgr->rmbs[i]); } + lgr->next_link_id =0 ; smc_lgr_list.num +=SMC_LGR_NUM_INCR ;memcpy (&lgr->id, (u8 *)&smc_lgr_list.num,SMC_LGR_ID_SIZE );INIT_DELAYED_WORK (&lgr->free_work, smc_lgr_free_work);
@@ -358,8 +381,9 @@ static int smc_lgr_create(struct smc_sock *smc, struct smc_init_info *ini)memcpy (lgr->peer_systemid, ini->ib_lcl->id_for_peer,SMC_SYSTEMID_LEN ); - lnk = &lgr->lnk[SMC_SINGLE_LINK ]; - rc =smcr_link_init (lnk,SMC_SINGLE_LINK , ini); + link_idx =SMC_SINGLE_LINK ; + lnk = &lgr->lnk[link_idx]; + rc =smcr_link_init (lgr, lnk, link_idx, ini);if (rc) goto free_lgr; lgr_list = &smc_lgr_list.list;
net/smc/smc_core.h +2 -0
@@ -115,6 +115,7 @@ struct smc_link {u8 peer_mac[ETH_ALEN ];/* = gid[8:10||13:15] */ u8 peer_gid[SMC_GID_SIZE ];/* gid of peer*/ u8 link_id;/* unique # within link group */ +u8 link_idx;/* index in lgr link array */ enum smc_link_state state;/* state of link */ struct workqueue_struct *llc_wq;/* single thread work queue */
@@ -222,6 +223,7 @@ struct smc_link_group {/* remote addr/key pairs */ DECLARE_BITMAP (rtokens_used_mask,SMC_RMBS_PER_LGR_MAX );/* used rtoken elements */ +u8 next_link_id; };struct {/* SMC-D */ u64 peer_gid;
Signature · 1 line
2.17.1
PATCH 4/13 net/smc: convert static link ID to dynamic references
In reply to Karsten GraulAs a preparation for the support of multiple links remove the usage of a static link id (SMC_SINGLE_LINK) and allow dynamic link ids.
--- net/smc/af_smc.c | 17 +++++------- net/smc/smc.h | 1 + net/smc/smc_cdc.c | 8 +++--- net/smc/smc_clc.c | 12 ++++----- net/smc/smc_core.c | 66 +++++++++++++++++++++++----------------------- net/smc/smc_core.h | 7 ++--- net/smc/smc_ib.c | 58 ++++++++++++++++++++-------------------- net/smc/smc_ib.h | 10 +++---- net/smc/smc_llc.c | 10 +++---- net/smc/smc_tx.c | 13 ++++----- 10 files changed, 99 insertions(+), 103 deletions(-)
net/smc/af_smc.c +6 -11
@@ -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
@@ -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
@@ -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
@@ -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
172 lines not on this page · raw message
net/smc/smc_core.h +4 -3
@@ -116,6 +116,7 @@ struct smc_link {u8 peer_gid[SMC_GID_SIZE ];/* gid of peer*/ u8 link_id;/* unique # within link group */ u8 link_idx;/* index in lgr link array */ +struct smc_link_group *lgr;/* parent link group */ enum smc_link_state state;/* state of link */ struct workqueue_struct *llc_wq;/* single thread work queue */
@@ -303,8 +304,8 @@ int smc_buf_create(struct smc_sock *smc, bool is_smcd);int smc_uncompress_bufsize (u8 compressed);int smc_rmb_rtoken_handling (struct smc_connection *conn,struct smc_clc_msg_accept_confirm *clc); -int smc_rtoken_add (struct smc_link_group *lgr,__be64 nw_vaddr,__be32 nw_rkey); -int smc_rtoken_delete (struct smc_link_group *lgr,__be32 nw_rkey); +int smc_rtoken_add (struct smc_link *lnk,__be64 nw_vaddr,__be32 nw_rkey); +int smc_rtoken_delete (struct smc_link *lnk,__be32 nw_rkey);void smc_sndbuf_sync_sg_for_cpu (struct smc_connection *conn);void smc_sndbuf_sync_sg_for_device (struct smc_connection *conn);void smc_rmb_sync_sg_for_cpu (struct smc_connection *conn);
@@ -319,6 +320,6 @@ 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]); +return link->lgr; }#endif
net/smc/smc_ib.c +29 -29
135 lines not on this page · raw message
net/smc/smc_ib.h +5 -5
@@ -59,10 +59,10 @@ struct smc_link;int smc_ib_register_client (void )__init ;void smc_ib_unregister_client (void );bool smc_ib_port_active (struct smc_ib_device *smcibdev,u8 ibport); -int smc_ib_buf_map_sg (struct smc_ib_device *smcibdev, +int smc_ib_buf_map_sg (struct smc_link *lnk,struct smc_buf_desc *buf_slot,enum dma_data_direction data_direction); -void smc_ib_buf_unmap_sg (struct smc_ib_device *smcibdev, +void smc_ib_buf_unmap_sg (struct smc_link *lnk,struct smc_buf_desc *buf_slot,enum dma_data_direction data_direction);void smc_ib_dealloc_protection_domain (struct smc_link *lnk);
@@ -74,12 +74,12 @@ int smc_ib_modify_qp_rts(struct smc_link *lnk);int smc_ib_modify_qp_reset (struct smc_link *lnk);long smc_ib_setup_per_ibdev (struct smc_ib_device *smcibdev);int smc_ib_get_memory_region (struct ib_pd *pd,int access_flags, -struct smc_buf_desc *buf_slot); +struct smc_buf_desc *buf_slot,u8 link_idx);void smc_ib_put_memory_region (struct ib_mr *mr); -void smc_ib_sync_sg_for_cpu (struct smc_ib_device *smcibdev, +void smc_ib_sync_sg_for_cpu (struct smc_link *lnk,struct smc_buf_desc *buf_slot,enum dma_data_direction data_direction); -void smc_ib_sync_sg_for_device (struct smc_ib_device *smcibdev, +void smc_ib_sync_sg_for_device (struct smc_link *lnk,struct smc_buf_desc *buf_slot,enum dma_data_direction data_direction); int smc_ib_determine_gid(struct smc_ib_device *smcibdev, u8 ibport,
net/smc/smc_llc.c +5 -5
@@ -231,9 +231,9 @@ static int smc_llc_send_confirm_rkey(struct smc_link *link, rkeyllc->hd.common.type =SMC_LLC_CONFIRM_RKEY ; rkeyllc->hd.length =sizeof (struct smc_llc_msg_confirm_rkey ); rkeyllc->rtoken[0 ].rmb_key = -htonl (rmb_desc->mr_rx[SMC_SINGLE_LINK ]->rkey); +htonl (rmb_desc->mr_rx[link->link_idx]->rkey); rkeyllc->rtoken[0 ].rmb_vaddr =cpu_to_be64 ( - (u64 )sg_dma_address (rmb_desc->sgt[SMC_SINGLE_LINK ].sgl)); + (u64 )sg_dma_address (rmb_desc->sgt[link->link_idx].sgl));/* send llc message */ rc =smc_wr_tx_send (link, pend);return rc;
@@ -256,7 +256,7 @@ static int smc_llc_send_delete_rkey(struct smc_link *link, rkeyllc->hd.common.type =SMC_LLC_DELETE_RKEY ; rkeyllc->hd.length =sizeof (struct smc_llc_msg_delete_rkey ); rkeyllc->num_rkeys =1 ; - rkeyllc->rkey[0 ] =htonl (rmb_desc->mr_rx[SMC_SINGLE_LINK ]->rkey); + rkeyllc->rkey[0 ] =htonl (rmb_desc->mr_rx[link->link_idx]->rkey);/* send llc message */ rc =smc_wr_tx_send (link, pend);return rc;
@@ -501,7 +501,7 @@ static void smc_llc_rx_confirm_rkey(struct smc_link *link,SMC_LLC_FLAG_RKEY_NEG ;complete (&link->llc_confirm_rkey); }else { - rc =smc_rtoken_add (smc_get_lgr (link), + rc =smc_rtoken_add (link, llc->rtoken[0 ].rmb_vaddr, llc->rtoken[0 ].rmb_key);
@@ -539,7 +539,7 @@ static void smc_llc_rx_delete_rkey(struct smc_link *link, }else { max =min_t (u8, llc->num_rkeys,SMC_LLC_DEL_RKEY_MAX );for (i =0 ; i < max; i++) { -if (smc_rtoken_delete (smc_get_lgr (link), llc->rkey[i])) +if (smc_rtoken_delete (link, llc->rkey[i])) err_mask |=1 << (SMC_LLC_DEL_RKEY_MAX -1 - i); }
net/smc/smc_tx.c +7 -6
@@ -269,19 +269,18 @@ static int smc_tx_rdma_write(struct smc_connection *conn, int peer_rmbe_offset, int num_sges, struct ib_rdma_wr *rdma_wr) { struct smc_link_group *lgr = conn->lgr; -struct smc_link *link; +struct smc_link *link = conn->lnk;int rc; - link = &lgr->lnk[SMC_SINGLE_LINK ]; rdma_wr->wr.wr_id =smc_wr_tx_get_next_wr_id (link); rdma_wr->wr.num_sge = num_sges; rdma_wr->remote_addr = - lgr->rtokens[conn->rtoken_idx][SMC_SINGLE_LINK ].dma_addr + + lgr->rtokens[conn->rtoken_idx][link->link_idx].dma_addr +/* RMBE within RMB */ conn->tx_off +/* offset within RMBE */ peer_rmbe_offset; - rdma_wr->rkey = lgr->rtokens[conn->rtoken_idx][SMC_SINGLE_LINK ].rkey; + rdma_wr->rkey = lgr->rtokens[conn->rtoken_idx][link->link_idx].rkey; rc =ib_post_send (link->roce_qp, &rdma_wr->wr,NULL );if (rc)smc_lgr_terminate_sched (lgr);
@@ -310,8 +309,10 @@ static int smcr_tx_rdma_writes(struct smc_connection *conn, size_t len, size_t dst_off, size_t dst_len, struct smc_rdma_wr *wr_rdma_buf) { + struct smc_link *link = conn->lnk; +dma_addr_t dma_addr = -sg_dma_address (conn->sndbuf_desc->sgt[SMC_SINGLE_LINK ].sgl); +sg_dma_address (conn->sndbuf_desc->sgt[link->link_idx].sgl);int src_len_sum = src_len, dst_len_sum = dst_len;int sent_count = src_off;int srcchunk, dstchunk;
@@ -507,7 +508,7 @@ static int smcr_tx_sndbuf_nonempty(struct smc_connection *conn)if (!pflags->urg_data_present) { rc =smc_tx_rdma_writes (conn, wr_rdma_buf);if (rc) { -smc_wr_tx_put_slot (&conn->lgr->lnk[SMC_SINGLE_LINK ], +smc_wr_tx_put_slot (conn->lnk, (struct smc_wr_tx_pend_priv *)pend); goto out_unlock; }
Signature · 1 line
2.17.1
PATCH 5/13 net/smc: convert static link ID instances to support multiple links
In reply to Karsten GraulAs a preparation for the support of multiple links remove the usage of a static link id (SMC_SINGLE_LINK) and allow dynamic link ids.
--- net/smc/af_smc.c | 54 +++++--- net/smc/smc_clc.h | 1 + net/smc/smc_core.c | 332 +++++++++++++++++++++++++++++++-------------- net/smc/smc_core.h | 37 +++-- net/smc/smc_llc.c | 2 + 5 files changed, 291 insertions(+), 135 deletions(-)
net/smc/af_smc.c +37 -17
@@ -338,28 +338,48 @@ static void smc_copy_sock_settings_to_smc(struct smc_sock *smc) }/* register a new rmb, send confirm_rkey msg to register with peer */ -static int smc_reg_rmb (struct smc_link *link,struct smc_buf_desc *rmb_desc, -bool conf_rkey) +static int smcr_link_reg_rmb (struct smc_link *link, +struct smc_buf_desc *rmb_desc,bool conf_rkey) { -if (!rmb_desc->wr_reg) { +if (!rmb_desc->is_reg_mr[link->link_idx]) {/* register memory region for new rmb */ if (smc_wr_reg_send (link, rmb_desc->mr_rx[link->link_idx])) { - rmb_desc->regerr =1 ; + rmb_desc->is_reg_err = true;return -EFAULT ; } - rmb_desc->wr_reg =1 ; + rmb_desc->is_reg_mr[link->link_idx] = true; }if (!conf_rkey)return 0 ; +/* exchange confirm_rkey msg with peer */ -if (smc_llc_do_confirm_rkey (link, rmb_desc)) { - rmb_desc->regerr =1 ; -return -EFAULT ; +if (!rmb_desc->is_conf_rkey) { +if (smc_llc_do_confirm_rkey (link, rmb_desc)) { + rmb_desc->is_reg_err = true; +return -EFAULT ; + } + rmb_desc->is_conf_rkey = true; + } +return 0 ; +} + +/* register the new rmb on all links */ +static int smcr_lgr_reg_rmbs (struct smc_link_group *lgr, +struct smc_buf_desc *rmb_desc) +{ +int i, rc; + +for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) { +if (lgr->lnk[i].state !=SMC_LNK_ACTIVE ) +continue ; + rc =smcr_link_reg_rmb (&lgr->lnk[i], rmb_desc, true); +if (rc) +return rc; }return 0 ; } -static int smc_clnt_conf_first_link (struct smc_sock *smc) +static int smcr_clnt_conf_first_link (struct smc_sock *smc) {struct net *net =sock_net (smc->clcsock->sk);struct smc_link *link = smc->conn.lnk;
@@ -387,7 +407,7 @@ static int smc_clnt_conf_first_link(struct smc_sock *smc)smc_wr_remember_qp_attr (link); -if (smc_reg_rmb (link, smc->conn.rmb_desc, false)) +if (smcr_link_reg_rmb (link, smc->conn.rmb_desc, false))return SMC_CLC_DECL_ERR_REGRMB ;/* send CONFIRM LINK response over RoCE fabric */
@@ -632,7 +652,7 @@ static int smc_connect_rdma(struct smc_sock *smc,return smc_connect_abort (smc,SMC_CLC_DECL_ERR_RDYLNK , ini->cln_first_contact); }else { -if (smc_reg_rmb (link, smc->conn.rmb_desc, true)) +if (smcr_lgr_reg_rmbs (smc->conn.lgr, smc->conn.rmb_desc))return smc_connect_abort (smc,SMC_CLC_DECL_ERR_REGRMB , ini->cln_first_contact); }
@@ -647,7 +667,7 @@ static int smc_connect_rdma(struct smc_sock *smc,if (ini->cln_first_contact ==SMC_FIRST_CONTACT ) {/* QP confirmation over RoCE fabric */ - reason_code =smc_clnt_conf_first_link (smc); + reason_code =smcr_clnt_conf_first_link (smc);if (reason_code)return smc_connect_abort (smc, reason_code, ini->cln_first_contact);
@@ -997,14 +1017,14 @@ void smc_close_non_accepted(struct sock *sk)sock_put (sk);/* final sock_put */ } -static int smc_serv_conf_first_link (struct smc_sock *smc) +static int smcr_serv_conf_first_link (struct smc_sock *smc) {struct net *net =sock_net (smc->clcsock->sk);struct smc_link *link = smc->conn.lnk;int rest;int rc; -if (smc_reg_rmb (link, smc->conn.rmb_desc, false)) +if (smcr_link_reg_rmb (link, smc->conn.rmb_desc, false))return SMC_CLC_DECL_ERR_REGRMB ;/* send CONFIRM LINK request to client over the RoCE fabric */
@@ -1189,10 +1209,10 @@ 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.lnk; +struct smc_connection *conn = &new_smc->conn;if (local_contact !=SMC_FIRST_CONTACT ) { -if (smc_reg_rmb (link, new_smc->conn.rmb_desc, true)) +if (smcr_lgr_reg_rmbs (conn->lgr, conn->rmb_desc))return SMC_CLC_DECL_ERR_REGRMB ; }smc_rmb_sync_sg_for_device (&new_smc->conn);
@@ -1222,7 +1242,7 @@ static int smc_listen_rdma_finish(struct smc_sock *new_smc, goto decline; }/* QP confirmation over RoCE fabric */ - reason_code =smc_serv_conf_first_link (new_smc); + reason_code =smcr_serv_conf_first_link (new_smc);if (reason_code) goto decline; }
net/smc/smc_clc.h +1 -0
@@ -44,6 +44,7 @@#define SMC_CLC_DECL_DIFFPREFIX 0x03070000/* IP prefix / subnet mismatch */ #define SMC_CLC_DECL_GETVLANERR 0x03080000/* err to get vlan id of ip device*/ #define SMC_CLC_DECL_ISMVLANERR 0x03090000/* err to reg vlan id on ism dev */ +#define SMC_CLC_DECL_NOACTLINK 0x030a0000/* no active smc-r link in lgr */ #define SMC_CLC_DECL_SYNCERR 0x04000000/* synchronization error */ #define SMC_CLC_DECL_PEERDECL 0x05000000/* peer declined during handshake */ #define SMC_CLC_DECL_INTERR 0x09990000/* internal error */
net/smc/smc_core.c +229 -103
520 lines not on this page · raw message
net/smc/smc_core.h +22 -15
@@ -152,25 +152,32 @@ struct smc_buf_desc {struct page *pages;int len;/* length of buffer */ u32 used;/* currently used / unused */ - u8 wr_reg : 1; /* mem region registered */ - u8 regerr : 1; /* err during registration */union {struct {/* SMC-R */ -struct sg_table sgt[SMC_LINKS_PER_LGR_MAX ]; -/* virtual buffer */ -struct ib_mr *mr_rx[SMC_LINKS_PER_LGR_MAX ]; -/* for rmb only: memory region -* incl. rkey provided to peer -*/ -u32 order;/* allocation order */ +struct sg_table sgt[SMC_LINKS_PER_LGR_MAX ]; +/* virtual buffer */ +struct ib_mr *mr_rx[SMC_LINKS_PER_LGR_MAX ]; +/* for rmb only: memory region +* incl. rkey provided to peer +*/ +u32 order;/* allocation order */ + +u8 is_conf_rkey; +/* confirm_rkey done */ +u8 is_reg_mr[SMC_LINKS_PER_LGR_MAX ]; +/* mem region registered */ +u8 is_map_ib[SMC_LINKS_PER_LGR_MAX ]; +/* mem region mapped to lnk */ +u8 is_reg_err; +/* buffer registration err */ };struct {/* SMC-D */ -unsigned short sba_idx; -/* SBA index number */ -u64 token; -/* DMB token number */ -dma_addr_t dma_addr; -/* DMA address */ +unsigned short sba_idx; +/* SBA index number */ +u64 token; +/* DMB token number */ +dma_addr_t dma_addr; +/* DMA address */ }; }; };
net/smc/smc_llc.c +2 -0
@@ -662,6 +662,8 @@ void smc_llc_link_deleting(struct smc_link *link)/* called in tasklet context */ void smc_llc_link_inactive (struct smc_link *link) { +if (link->state ==SMC_LNK_INACTIVE ) +return ; link->state =SMC_LNK_INACTIVE ;cancel_delayed_work (&link->llc_testlink_wrk);smc_wr_wakeup_reg_wait (link);
Signature · 1 line
2.17.1
PATCH 6/13 net/smc: multi-link support for smc_rmb_rtoken_handling()
In reply to Karsten GraulExtend smc_rmb_rtoken_handling() and smc_rtoken_delete() to support multiple links.
--- net/smc/af_smc.c | 4 ++-- net/smc/smc_core.c | 14 ++++++++------ net/smc/smc_core.h | 2 +- 3 files changed, 11 insertions(+), 9 deletions(-)
net/smc/af_smc.c +2 -2
@@ -640,7 +640,7 @@ static int smc_connect_rdma(struct smc_sock *smc,if (ini->cln_first_contact ==SMC_FIRST_CONTACT )smc_link_save_peer_info (link, aclc); -if (smc_rmb_rtoken_handling (&smc->conn, aclc)) +if (smc_rmb_rtoken_handling (&smc->conn, link, aclc))return smc_connect_abort (smc,SMC_CLC_DECL_ERR_RTOK , ini->cln_first_contact);
@@ -1231,7 +1231,7 @@ static int smc_listen_rdma_finish(struct smc_sock *new_smc,if (local_contact ==SMC_FIRST_CONTACT )smc_link_save_peer_info (link, cclc); -if (smc_rmb_rtoken_handling (&new_smc->conn, cclc)) { +if (smc_rmb_rtoken_handling (&new_smc->conn, link, cclc)) { reason_code =SMC_CLC_DECL_ERR_RTOK ; goto decline; }
net/smc/smc_core.c +8 -6
@@ -1392,19 +1392,20 @@ int smc_rtoken_add(struct smc_link *lnk, __be64 nw_vaddr, __be32 nw_rkey)return i; } -/* delete an rtoken */ +/* delete an rtoken from all links */ 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; +int i, j;for (i =0 ; i <SMC_RMBS_PER_LGR_MAX ; i++) {if (lgr->rtokens[i][lnk->link_idx].rkey == rkey &&test_bit (i, lgr->rtokens_used_mask)) { - lgr->rtokens[i][lnk->link_idx].rkey =0 ; - lgr->rtokens[i][lnk->link_idx].dma_addr =0 ; - +for (j =0 ; j <SMC_LINKS_PER_LGR_MAX ; j++) { + lgr->rtokens[i][j].rkey =0 ; + lgr->rtokens[i][j].dma_addr =0 ; + }clear_bit (i, lgr->rtokens_used_mask);return 0 ; }
@@ -1414,9 +1415,10 @@ int smc_rtoken_delete(struct smc_link *lnk, __be32 nw_rkey)/* save rkey and dma_addr received from peer during clc handshake */ int smc_rmb_rtoken_handling (struct smc_connection *conn, +struct smc_link *lnk,struct smc_clc_msg_accept_confirm *clc) { - conn->rtoken_idx =smc_rtoken_add (conn->lnk, clc->rmb_dma_addr, + conn->rtoken_idx =smc_rtoken_add (lnk, clc->rmb_dma_addr, clc->rmb_rkey);if (conn->rtoken_idx <0 )return conn->rtoken_idx;
net/smc/smc_core.h +1 -1
@@ -309,7 +309,7 @@ void smc_smcd_terminate_all(struct smcd_dev *dev);void smc_smcr_terminate_all (struct smc_ib_device *smcibdev);int smc_buf_create (struct smc_sock *smc,bool is_smcd);int smc_uncompress_bufsize (u8 compressed); -int smc_rmb_rtoken_handling (struct smc_connection *conn, +int smc_rmb_rtoken_handling (struct smc_connection *conn,struct smc_link *link,struct smc_clc_msg_accept_confirm *clc);int smc_rtoken_add (struct smc_link *lnk,__be64 nw_vaddr,__be32 nw_rkey);int smc_rtoken_delete (struct smc_link *lnk,__be32 nw_rkey);
Signature · 1 line
2.17.1
PATCH 7/13 net/smc: add new link state and related helpers
In reply to Karsten GraulBefore a link can be reused it must have been cleared. Lowest current link state is INACTIVE, which does not mean that the link is already cleared.
Add a new state UNUSED that is set when the link is cleared and can be reused.
Add helper smc_llc_usable_link() to find an active link in a link group, and smc_link_usable() to determine if a link is usable.
--- net/smc/smc_core.c | 36 +++++++++++++++++++----------------- net/smc/smc_core.h | 9 +++++++++ net/smc/smc_llc.c | 4 ++-- net/smc/smc_llc.h | 11 +++++++++++ net/smc/smc_wr.c | 2 +- 5 files changed, 42 insertions(+), 20 deletions(-)
net/smc/smc_core.c +19 -17
@@ -260,7 +260,7 @@ static void smc_lgr_free_work(struct work_struct *work)for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) {struct smc_link *lnk = &lgr->lnk[i]; -if (lnk->state !=SMC_LNK_INACTIVE ) +if (smc_link_usable (lnk))smc_llc_link_inactive (lnk); } }
@@ -286,7 +286,7 @@ static u8 smcr_next_link_id(struct smc_link_group *lgr)if (!link_id)/* skip zero as link_id */ link_id = ++lgr->next_link_id;for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) { -if (lgr->lnk[i].state !=SMC_LNK_INACTIVE && +if (smc_link_usable (&lgr->lnk[i]) && lgr->lnk[i].link_id == link_id)continue ; }
@@ -350,6 +350,7 @@ static int smcr_link_init(struct smc_link_group *lgr, struct smc_link *lnk, out:put_device (&ini->ib_dev->ibdev->dev);memset (lnk,0 ,sizeof (struct smc_link )); + lnk->state =SMC_LNK_UNUSED ;if (!atomic_dec_return (&ini->ib_dev->lnk_cnt))wake_up (&ini->ib_dev->lnks_deleted);return rc;
@@ -500,6 +501,8 @@ void smc_conn_free(struct smc_connection *conn)static void smcr_link_clear (struct smc_link *lnk) { +struct smc_ib_device *smcibdev; +if (lnk->peer_qpn ==0 )return ; lnk->peer_qpn =0 ;
@@ -510,8 +513,11 @@ static void smcr_link_clear(struct smc_link *lnk)smc_ib_dealloc_protection_domain (lnk);smc_wr_free_link_mem (lnk);put_device (&lnk->smcibdev->ibdev->dev); -if (!atomic_dec_return (&lnk->smcibdev->lnk_cnt)) -wake_up (&lnk->smcibdev->lnks_deleted); + smcibdev = lnk->smcibdev; +memset (lnk,0 ,sizeof (struct smc_link )); + lnk->state =SMC_LNK_UNUSED ; +if (!atomic_dec_return (&smcibdev->lnk_cnt)) +wake_up (&smcibdev->lnks_deleted); } static void smcr_buf_free(struct smc_link_group *lgr, bool is_rmb,
@@ -604,9 +610,8 @@ static void smc_lgr_free(struct smc_link_group *lgr)wake_up (&lgr->smcd->lgrs_deleted); }else {for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) { -if (lgr->lnk[i].state ==SMC_LNK_INACTIVE ) -continue ; -smcr_link_clear (&lgr->lnk[i]); +if (lgr->lnk[i].state !=SMC_LNK_UNUSED ) +smcr_link_clear (&lgr->lnk[i]); }if (!atomic_dec_return (&lgr_cnt))wake_up (&lgrs_deleted);
@@ -686,7 +691,7 @@ static void smc_lgr_cleanup(struct smc_link_group *lgr)for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) {struct smc_link *lnk = &lgr->lnk[i]; -if (lnk->state !=SMC_LNK_INACTIVE ) +if (smc_link_usable (lnk))smc_llc_link_inactive (lnk); } }
@@ -764,7 +769,7 @@ void smc_port_terminate(struct smc_ib_device *smcibdev, u8 ibport)continue ;/* tbd - terminate only when no more links are active */ for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) { -if (lgr->lnk[i].state ==SMC_LNK_INACTIVE || +if (!smc_link_usable (&lgr->lnk[i]) || lgr->lnk[i].state ==SMC_LNK_DELETING )continue ; if (lgr->lnk[i].smcibdev == smcibdev &&
@@ -1161,8 +1166,7 @@ static int smcr_buf_map_usable_links(struct smc_link_group *lgr,for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) {struct smc_link *lnk = &lgr->lnk[i]; -if (lnk->state !=SMC_LNK_ACTIVE && - lnk->state !=SMC_LNK_ACTIVATING ) +if (!smc_link_usable (lnk))continue ;if (smcr_buf_map_link (buf_desc, is_rmb, lnk)) {smcr_buf_unuse (buf_desc, lnk);
@@ -1294,14 +1298,14 @@ 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) { -if (!conn->lgr || conn->lgr->is_smcd) +if (!conn->lgr || conn->lgr->is_smcd || !smc_link_usable (conn->lnk))return ;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) { -if (!conn->lgr || conn->lgr->is_smcd) +if (!conn->lgr || conn->lgr->is_smcd || !smc_link_usable (conn->lnk))return ;smc_ib_sync_sg_for_device (conn->lnk, conn->sndbuf_desc,DMA_TO_DEVICE ); }
@@ -1313,8 +1317,7 @@ void smc_rmb_sync_sg_for_cpu(struct smc_connection *conn)if (!conn->lgr || conn->lgr->is_smcd)return ;for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) { -if (conn->lgr->lnk[i].state !=SMC_LNK_ACTIVE && - conn->lgr->lnk[i].state !=SMC_LNK_ACTIVATING ) +if (!smc_link_usable (&conn->lgr->lnk[i]))continue ;smc_ib_sync_sg_for_cpu (&conn->lgr->lnk[i], conn->rmb_desc,DMA_FROM_DEVICE );
@@ -1328,8 +1331,7 @@ void smc_rmb_sync_sg_for_device(struct smc_connection *conn)if (!conn->lgr || conn->lgr->is_smcd)return ;for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) { -if (conn->lgr->lnk[i].state !=SMC_LNK_ACTIVE && - conn->lgr->lnk[i].state !=SMC_LNK_ACTIVATING ) +if (!smc_link_usable (&conn->lgr->lnk[i]))continue ;smc_ib_sync_sg_for_device (&conn->lgr->lnk[i], conn->rmb_desc,DMA_FROM_DEVICE );
net/smc/smc_core.h +9 -0
@@ -32,6 +32,7 @@ enum smc_lgr_role { /* possible roles of a link group */ };enum smc_link_state {/* possible states of a link */ +SMC_LNK_UNUSED ,/* link is unused */ SMC_LNK_INACTIVE ,/* link is inactive */ SMC_LNK_ACTIVATING ,/* link is being activated */ SMC_LNK_ACTIVE ,/* link is active */
@@ -295,6 +296,14 @@ static inline struct smc_connection *smc_lgr_find_conn(return res; } +/* returns true if the specified link is usable */ +static inline bool smc_link_usable (struct smc_link *lnk) +{ +if (lnk->state ==SMC_LNK_UNUSED || lnk->state ==SMC_LNK_INACTIVE ) +return false; +return true; +} +struct smc_sock ;struct smc_clc_msg_accept_confirm ;struct smc_clc_msg_local ;
net/smc/smc_llc.c +2 -2
@@ -372,7 +372,7 @@ static void smc_llc_send_message_work(struct work_struct *work)struct smc_wr_buf *wr_buf;int rc; -if (llcwrk->link->state ==SMC_LNK_INACTIVE ) +if (!smc_link_usable (llcwrk->link)) goto out; rc =smc_llc_add_pending_send (llcwrk->link, &wr_buf, &pend);if (rc)
@@ -562,7 +562,7 @@ static void smc_llc_rx_handler(struct ib_wc *wc, void *buf)return ;/* short message */ if (llc->raw.hdr.length !=sizeof (*llc))return ;/* invalid message */ -if (link->state ==SMC_LNK_INACTIVE ) +if (!smc_link_usable (link))return ;/* link not active, drop msg */ switch (llc->raw.hdr.common.type) {
net/smc/smc_llc.h +11 -0
@@ -35,6 +35,17 @@ enum smc_llc_msg_type { SMC_LLC_DELETE_RKEY = 0x09, }; +/* returns a usable link of the link group, or NULL */ +static inline struct smc_link *smc_llc_usable_link (struct smc_link_group *lgr) +{ +int i; + +for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) +if (smc_link_usable (&lgr->lnk[i])) +return &lgr->lnk[i]; +return NULL ; +} +/* transmit */ int smc_llc_send_confirm_link (struct smc_link *lnk,enum smc_llc_reqresp reqresp);
net/smc/smc_wr.c +1 -1
@@ -207,7 +207,7 @@ int smc_wr_tx_get_free_slot(struct smc_link *link, }else { rc =wait_event_interruptible_timeout ( link->wr_tx_wait, - link->state ==SMC_LNK_INACTIVE || + !smc_link_usable (link) || lgr->terminating || (smc_wr_tx_get_free_slot_index (link, &idx) != -EBUSY ),SMC_WR_TX_WAIT_FREE_SLOT_TIME );
Signature · 1 line
2.17.1
PATCH 8/13 net/smc: move testlink work to system work queue
In reply to Karsten GraulThe testlink work waits for a response to the testlink request and blocks the single threaded llc_wq. This type of work does not have to be serialized and can be moved to the system work queue.
--- net/smc/smc_llc.c | 11 ++++++----- 1 file changed, 6 insertions(+), 5 deletions(-)
net/smc/smc_llc.c +6 -5
@@ -613,14 +613,15 @@ static void smc_llc_testlink_work(struct work_struct *work)/* receive TEST LINK response over RoCE fabric */ rc =wait_for_completion_interruptible_timeout (&link->llc_testlink_resp,SMC_LLC_WAIT_TIME ); +if (link->state !=SMC_LNK_ACTIVE ) +return ;/* link state changed */ if (rc <=0 ) {smc_lgr_terminate_sched (smc_get_lgr (link));return ; } next_interval = link->llc_testlink_time; out: -queue_delayed_work (link->llc_wq, &link->llc_testlink_wrk, - next_interval); +schedule_delayed_work (&link->llc_testlink_wrk, next_interval); }int smc_llc_link_init (struct smc_link *link)
@@ -648,8 +649,8 @@ void smc_llc_link_active(struct smc_link *link, int testlink_time) link->state =SMC_LNK_ACTIVE ;if (testlink_time) { link->llc_testlink_time = testlink_time *HZ ; -queue_delayed_work (link->llc_wq, &link->llc_testlink_wrk, - link->llc_testlink_time); +schedule_delayed_work (&link->llc_testlink_wrk, + link->llc_testlink_time); } }
@@ -665,7 +666,7 @@ void smc_llc_link_inactive(struct smc_link *link)if (link->state ==SMC_LNK_INACTIVE )return ; link->state =SMC_LNK_INACTIVE ; -cancel_delayed_work (&link->llc_testlink_wrk); +cancel_delayed_work_sync (&link->llc_testlink_wrk);smc_wr_wakeup_reg_wait (link);smc_wr_wakeup_tx_wait (link); }
Signature · 1 line
2.17.1
PATCH 9/13 net/smc: simplify link deactivation
In reply to Karsten GraulCancel the testlink worker during link clear processing and remove the extra function smc_llc_link_inactive().
--- net/smc/smc_core.c | 8 ++------ net/smc/smc_llc.c | 15 ++++----------- net/smc/smc_llc.h | 1 - 3 files changed, 6 insertions(+), 18 deletions(-)
net/smc/smc_core.c +2 -6
@@ -261,7 +261,7 @@ static void smc_lgr_free_work(struct work_struct *work)struct smc_link *lnk = &lgr->lnk[i];if (smc_link_usable (lnk)) -smc_llc_link_inactive (lnk); + lnk->state =SMC_LNK_INACTIVE ; } }smc_lgr_free (lgr);
@@ -692,7 +692,7 @@ static void smc_lgr_cleanup(struct smc_link_group *lgr)struct smc_link *lnk = &lgr->lnk[i];if (smc_link_usable (lnk)) -smc_llc_link_inactive (lnk); + lnk->state =SMC_LNK_INACTIVE ; } } }
@@ -706,16 +706,12 @@ static void __smc_lgr_terminate(struct smc_link_group *lgr, bool soft)struct smc_connection *conn;struct smc_sock *smc;struct rb_node *node; -int i;if (lgr->terminating)return ;/* lgr already terminating */ if (!soft)cancel_delayed_work_sync (&lgr->free_work); lgr->terminating =1 ; -if (!lgr->is_smcd) -for (i =0 ; i <SMC_LINKS_PER_LGR_MAX ; i++) -smc_llc_link_inactive (&lgr->lnk[i]);/* kill remaining link group connections */ read_lock_bh (&lgr->conns_lock);
net/smc/smc_llc.c +4 -11
@@ -660,22 +660,15 @@ void smc_llc_link_deleting(struct smc_link *link)smc_wr_wakeup_tx_wait (link); } -/* called in tasklet context */ -void smc_llc_link_inactive (struct smc_link *link) -{ -if (link->state ==SMC_LNK_INACTIVE ) -return ; - link->state =SMC_LNK_INACTIVE ; -cancel_delayed_work_sync (&link->llc_testlink_wrk); -smc_wr_wakeup_reg_wait (link); -smc_wr_wakeup_tx_wait (link); -} -/* called in worker context */ void smc_llc_link_clear (struct smc_link *link) {flush_workqueue (link->llc_wq);destroy_workqueue (link->llc_wq); +complete (&link->llc_testlink_resp); +cancel_delayed_work_sync (&link->llc_testlink_wrk); +smc_wr_wakeup_reg_wait (link); +smc_wr_wakeup_tx_wait (link); }/* register a new rtoken at the remote peer */
net/smc/smc_llc.h +0 -1
@@ -56,7 +56,6 @@ int smc_llc_send_delete_link(struct smc_link *link,int smc_llc_link_init (struct smc_link *link);void smc_llc_link_active (struct smc_link *link,int testlink_time);void smc_llc_link_deleting (struct smc_link *link); -void smc_llc_link_inactive (struct smc_link *link);void smc_llc_link_clear (struct smc_link *link);int smc_llc_do_confirm_rkey (struct smc_link *link,struct smc_buf_desc *rmb_desc);
Signature · 1 line
2.17.1
PATCH 10/13 net/smc: use worker to process incoming llc messages
In reply to Karsten GraulIncoming llc messages are processed in irq tasklet context, and a worker is used to send outgoing messages. The worker is needed because getting a send buffer could result in a wait for a free buffer.
To make sure all incoming llc messages are processed in a serialized way introduce an event queue and create a new queue entry for each message which is queued to this event queue. A new worker processes the event queue entries in order.
And remove the use of a separate worker to send outgoing llc messages because the messages are processed in worker context already. With this event queue the serialized llc_wq work queue is obsolete, remove it.
--- net/smc/smc_core.c | 4 +- net/smc/smc_core.h | 7 ++- net/smc/smc_llc.c | 142 +++++++++++++++++++++++++++------------------ net/smc/smc_llc.h | 1 + 4 files changed, 96 insertions(+), 58 deletions(-)
net/smc/smc_core.c +3 -1
@@ -412,7 +412,8 @@ static int smc_lgr_create(struct smc_sock *smc, struct smc_init_info *ini) lgr->role = smc->listen_smc ?SMC_SERV :SMC_CLNT ;memcpy (lgr->peer_systemid, ini->ib_lcl->id_for_peer,SMC_SYSTEMID_LEN ); - +INIT_LIST_HEAD (&lgr->llc_event_q); +spin_lock_init (&lgr->llc_event_q_lock); link_idx =SMC_SINGLE_LINK ; lnk = &lgr->lnk[link_idx]; rc =smcr_link_init (lgr, lnk, link_idx, ini);
@@ -613,6 +614,7 @@ static void smc_lgr_free(struct smc_link_group *lgr)if (lgr->lnk[i].state !=SMC_LNK_UNUSED )smcr_link_clear (&lgr->lnk[i]); } +smc_llc_event_flush (lgr);if (!atomic_dec_return (&lgr_cnt))wake_up (&lgrs_deleted); }
net/smc/smc_core.h +6 -1
@@ -120,7 +120,6 @@ struct smc_link {struct smc_link_group *lgr;/* parent link group */ enum smc_link_state state;/* state of link */ -struct workqueue_struct *llc_wq;/* single thread work queue */ struct completion llc_confirm;/* wait for rx of conf link */ struct completion llc_confirm_resp;/* wait 4 rx of cnf lnk rsp */ int llc_confirm_rc;/* rc from confirm link msg */
@@ -233,6 +232,12 @@ struct smc_link_group {DECLARE_BITMAP (rtokens_used_mask,SMC_RMBS_PER_LGR_MAX );/* used rtoken elements */ u8 next_link_id; +struct list_head llc_event_q; +/* queue for llc events */ +spinlock_t llc_event_q_lock; +/* protects llc_event_q */ +struct work_struct llc_event_work; +/* llc event worker */ };struct {/* SMC-D */ u64 peer_gid;
net/smc/smc_llc.c +86 -56
226 lines not on this page · raw message
net/smc/smc_llc.h +1 -0
@@ -61,6 +61,7 @@ int smc_llc_do_confirm_rkey(struct smc_link *link, struct smc_buf_desc *rmb_desc);int smc_llc_do_delete_rkey (struct smc_link *link,struct smc_buf_desc *rmb_desc); +void smc_llc_event_flush (struct smc_link_group *lgr);int smc_llc_init (void )__init ;#endif /* SMC_LLC_H */
Signature · 1 line
2.17.1
PATCH 11/13 net/smc: process llc responses in tasklet context
In reply to Karsten GraulWhen llc responses are received then possible waiters for this response are to be notified. This can be done in tasklet context, without to use a work in the llc work queue. Move all code that handles llc responses into smc_llc_rx_response().
--- net/smc/smc_core.h | 8 +- net/smc/smc_llc.c | 216 +++++++++++++++++++++++---------------------- 2 files changed, 116 insertions(+), 108 deletions(-)
net/smc/smc_core.h +4 -4
@@ -129,10 +129,10 @@ struct smc_link {struct delayed_work llc_testlink_wrk;/* testlink worker */ struct completion llc_testlink_resp;/* wait for rx of testlink */ int llc_testlink_time;/* testlink interval */ -struct completion llc_confirm_rkey;/* wait 4 rx of cnf rkey */ -int llc_confirm_rkey_rc;/* rc from cnf rkey msg */ -struct completion llc_delete_rkey;/* wait 4 rx of del rkey */ -int llc_delete_rkey_rc;/* rc from del rkey msg */ +struct completion llc_confirm_rkey_resp;/* w4 rx of cnf rkey */ +int llc_confirm_rkey_resp_rc;/* rc from cnf rkey */ +struct completion llc_delete_rkey_resp;/* w4 rx of del rkey */ +int llc_delete_rkey_resp_rc;/* rc from del rkey */ struct mutex llc_delete_rkey_mutex;/* serialize usage */ };
net/smc/smc_llc.c +112 -104
307 lines not on this page · raw message
Signature · 1 line
2.17.1
PATCH 12/13 net/smc: use mutex instead of rwlock_t to protect buffers
In reply to Karsten GraulThe locks for sndbufs and rmbs are never used from atomic context. Using a mutex for these locks will allow to nest locks with other mutexes.
--- net/smc/smc_core.c | 22 +++++++++++----------- net/smc/smc_core.h | 4 ++-- 2 files changed, 13 insertions(+), 13 deletions(-)
net/smc/smc_core.c +11 -11
@@ -385,8 +385,8 @@ static int smc_lgr_create(struct smc_sock *smc, struct smc_init_info *ini) lgr->freefast =0 ; lgr->freeing =0 ; lgr->vlan_id = ini->vlan_id; -rwlock_init (&lgr->sndbufs_lock); -rwlock_init (&lgr->rmbs_lock); +mutex_init (&lgr->sndbufs_lock); +mutex_init (&lgr->rmbs_lock);rwlock_init (&lgr->conns_lock);for (i =0 ; i <SMC_RMBE_SIZES ; i++) {INIT_LIST_HEAD (&lgr->sndbufs[i]);
@@ -456,9 +456,9 @@ static void smcr_buf_unuse(struct smc_buf_desc *rmb_desc, }if (rmb_desc->is_reg_err) {/* buf registration failed, reuse not possible */ -write_lock_bh (&lgr->rmbs_lock); +mutex_lock (&lgr->rmbs_lock);list_del (&rmb_desc->list); -write_unlock_bh (&lgr->rmbs_lock); +mutex_unlock (&lgr->rmbs_lock);smc_buf_free (lgr, true, rmb_desc); }else {
@@ -1059,19 +1059,19 @@ int smc_uncompress_bufsize(u8 compressed)* buffer size; if not available, return NULL */ static struct smc_buf_desc *smc_buf_get_slot (int compressed_bufsize, -rwlock_t *lock, +struct mutex *lock,struct list_head *buf_list) {struct smc_buf_desc *buf_slot; -read_lock_bh (lock); +mutex_lock (lock);list_for_each_entry (buf_slot, buf_list, list) {if (cmpxchg (&buf_slot->used,0 ,1 ) ==0 ) { -read_unlock_bh (lock); +mutex_unlock (lock);return buf_slot; } } -read_unlock_bh (lock); +mutex_unlock (lock);return NULL ; }
@@ -1220,8 +1220,8 @@ static int __smc_buf_create(struct smc_sock *smc, bool is_smcd, bool is_rmb)struct smc_link_group *lgr = conn->lgr;struct list_head *buf_list;int bufsize, bufsize_short; +struct mutex *lock;/* lock buffer list */ int sk_buf_size; -rwlock_t *lock;if (is_rmb)/* use socket recv buffer size (w/o overhead) as start value */
@@ -1262,9 +1262,9 @@ static int __smc_buf_create(struct smc_sock *smc, bool is_smcd, bool is_rmb)continue ; buf_desc->used =1 ; -write_lock_bh (lock); +mutex_lock (lock);list_add (&buf_desc->list, buf_list); -write_unlock_bh (lock); +mutex_unlock (lock);break ;/* found */ }
net/smc/smc_core.h +2 -2
@@ -205,9 +205,9 @@ struct smc_link_group {unsigned short vlan_id;/* vlan id of link group */ struct list_head sndbufs[SMC_RMBE_SIZES ];/* tx buffers */ -rwlock_t sndbufs_lock;/* protects tx buffers */ +struct mutex sndbufs_lock;/* protects tx buffers */ struct list_head rmbs[SMC_RMBE_SIZES ];/* rx buffers */ -rwlock_t rmbs_lock;/* protects rx buffers */ +struct mutex rmbs_lock;/* protects rx buffers */ u8 id[SMC_LGR_ID_SIZE ];/* unique lgr id */ struct delayed_work free_work;/* delayed freeing of an lgr */
Signature · 1 line
2.17.1
PATCH 13/13 net/smc: move llc layer related init and clear into smc_llc.c
In reply to Karsten GraulIntroduce smc_llc_lgr_init() and smc_llc_lgr_clear() to implement all llc layer specific initialization and cleanup in module smc_llc.c.
--- net/smc/af_smc.c | 6 ++---- net/smc/smc_core.c | 6 +++--- net/smc/smc_core.h | 2 ++ net/smc/smc_llc.c | 26 +++++++++++++++++++++----- net/smc/smc_llc.h | 5 +++-- 5 files changed, 31 insertions(+), 14 deletions(-)
net/smc/af_smc.c +2 -4
@@ -381,7 +381,6 @@ static int smcr_lgr_reg_rmbs(struct smc_link_group *lgr,static int smcr_clnt_conf_first_link (struct smc_sock *smc) { -struct net *net =sock_net (smc->clcsock->sk);struct smc_link *link = smc->conn.lnk;int rest;int rc;
@@ -433,7 +432,7 @@ static int smcr_clnt_conf_first_link(struct smc_sock *smc)if (rc <0 )return SMC_CLC_DECL_TIMEOUT_AL ; -smc_llc_link_active (link, net->ipv4.sysctl_tcp_keepalive_time); +smc_llc_link_active (link);return 0 ; }
@@ -1019,7 +1018,6 @@ void smc_close_non_accepted(struct sock *sk)static int smcr_serv_conf_first_link (struct smc_sock *smc) { -struct net *net =sock_net (smc->clcsock->sk);struct smc_link *link = smc->conn.lnk;int rest;int rc;
@@ -1065,7 +1063,7 @@ static int smcr_serv_conf_first_link(struct smc_sock *smc)return rc == -EAGAIN ?SMC_CLC_DECL_TIMEOUT_AL : rc; } -smc_llc_link_active (link, net->ipv4.sysctl_tcp_keepalive_time); +smc_llc_link_active (link);return 0 ; }
net/smc/smc_core.c +3 -3
@@ -412,8 +412,8 @@ static int smc_lgr_create(struct smc_sock *smc, struct smc_init_info *ini) lgr->role = smc->listen_smc ?SMC_SERV :SMC_CLNT ;memcpy (lgr->peer_systemid, ini->ib_lcl->id_for_peer,SMC_SYSTEMID_LEN ); -INIT_LIST_HEAD (&lgr->llc_event_q); -spin_lock_init (&lgr->llc_event_q_lock); +smc_llc_lgr_init (lgr, smc); + link_idx =SMC_SINGLE_LINK ; lnk = &lgr->lnk[link_idx]; rc =smcr_link_init (lgr, lnk, link_idx, ini);
@@ -614,7 +614,7 @@ static void smc_lgr_free(struct smc_link_group *lgr)if (lgr->lnk[i].state !=SMC_LNK_UNUSED )smcr_link_clear (&lgr->lnk[i]); } -smc_llc_event_flush (lgr); +smc_llc_lgr_clear (lgr);if (!atomic_dec_return (&lgr_cnt))wake_up (&lgrs_deleted); }
net/smc/smc_core.h +2 -0
@@ -238,6 +238,8 @@ struct smc_link_group {/* protects llc_event_q */ struct work_struct llc_event_work;/* llc event worker */ +int llc_testlink_time; +/* link keep alive time */ };struct {/* SMC-D */ u64 peer_gid;
net/smc/smc_llc.c +21 -5
@@ -493,7 +493,7 @@ static void smc_llc_rx_delete_rkey(struct smc_link *link, }/* flush the llc event queue */ -void smc_llc_event_flush (struct smc_link_group *lgr) +static void smc_llc_event_flush (struct smc_link_group *lgr) {struct smc_llc_qentry *qentry, *q;
@@ -669,6 +669,23 @@ static void smc_llc_testlink_work(struct work_struct *work)schedule_delayed_work (&link->llc_testlink_wrk, next_interval); } +void smc_llc_lgr_init (struct smc_link_group *lgr,struct smc_sock *smc) +{ +struct net *net =sock_net (smc->clcsock->sk); + +INIT_WORK (&lgr->llc_event_work, smc_llc_event_work); +INIT_LIST_HEAD (&lgr->llc_event_q); +spin_lock_init (&lgr->llc_event_q_lock); + lgr->llc_testlink_time = net->ipv4.sysctl_tcp_keepalive_time; +} + +/* called after lgr was removed from lgr_list */ +void smc_llc_lgr_clear (struct smc_link_group *lgr) +{ +smc_llc_event_flush (lgr); +cancel_work_sync (&lgr->llc_event_work); +} +int smc_llc_link_init (struct smc_link *link) {init_completion (&link->llc_confirm);
@@ -679,16 +696,15 @@ int smc_llc_link_init(struct smc_link *link)init_completion (&link->llc_delete_rkey_resp);mutex_init (&link->llc_delete_rkey_mutex);init_completion (&link->llc_testlink_resp); -INIT_WORK (&link->lgr->llc_event_work, smc_llc_event_work);INIT_DELAYED_WORK (&link->llc_testlink_wrk, smc_llc_testlink_work);return 0 ; } -void smc_llc_link_active (struct smc_link *link,int testlink_time) +void smc_llc_link_active (struct smc_link *link) { link->state =SMC_LNK_ACTIVE ; -if (testlink_time) { - link->llc_testlink_time = testlink_time *HZ ; +if (link->lgr->llc_testlink_time) { + link->llc_testlink_time = link->lgr->llc_testlink_time *HZ ;schedule_delayed_work (&link->llc_testlink_wrk, link->llc_testlink_time); }
net/smc/smc_llc.h +3 -2
@@ -53,15 +53,16 @@ int smc_llc_send_add_link(struct smc_link *link, u8 mac[], u8 gid[], enum smc_llc_reqresp reqresp);int smc_llc_send_delete_link (struct smc_link *link,enum smc_llc_reqresp reqresp,bool orderly); +void smc_llc_lgr_init (struct smc_link_group *lgr,struct smc_sock *smc); +void smc_llc_lgr_clear (struct smc_link_group *lgr);int smc_llc_link_init (struct smc_link *link); -void smc_llc_link_active (struct smc_link *link,int testlink_time); +void smc_llc_link_active (struct smc_link *link);void smc_llc_link_deleting (struct smc_link *link);void smc_llc_link_clear (struct smc_link *link);int smc_llc_do_confirm_rkey (struct smc_link *link,struct smc_buf_desc *rmb_desc);int smc_llc_do_delete_rkey (struct smc_link *link,struct smc_buf_desc *rmb_desc); -void smc_llc_event_flush (struct smc_link_group *lgr);int smc_llc_init (void )__init ;#endif /* SMC_LLC_H */
Signature · 1 line
2.17.1
David Miller
maintainerFrom: Karsten Graul <[email protected]>
Date: Wed, 29 Apr 2020 17:10:36 +0200
Quoted 6 lines
This patch series prepares the SMC code for the implementation of SMC-R link failover capabilities which are still missing to reach full compliance with RFC 7609.
The code changes are separated into 65 patches which together form the new functionality. I tried to create meaningful patches which allow to follow the implementation.
Series applied.
Quoted 3 lines
Question: how to handle the remaining 52 patches? All of them are needed for link failover to work and should make it into the same merge window. Can I send them all together?
No.
You must break these changes up into significantly smaller sized, logical, group of changes. That's part of your responsibility when submitting changes, keeping the patch series small and reviewable.