Skip to content

Commit 3d9725a

Browse files
Ursula Braundavem330
Ursula Braun
authored and
davem330
committed
net/smc: common routine for CLC accept and confirm
smc_clc_send_accept() and smc_clc_send_confirm() are quite similar. Move common code into a separate function smc_clc_send_confirm_accept(). And introduce separate SMCD and SMCR struct definitions for CLC accept resp. confirm. No functional change. Signed-off-by: Ursula Braun <ubraun@linux.ibm.com> Signed-off-by: Karsten Graul <kgraul@linux.ibm.com> Signed-off-by: David S. Miller <davem@davemloft.net>
1 parent 6bb14e4 commit 3d9725a

File tree

4 files changed

+118
-143
lines changed

4 files changed

+118
-143
lines changed

‎net/smc/af_smc.c‎

Lines changed: 19 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -436,10 +436,10 @@ static int smcr_clnt_conf_first_link(struct smc_sock *smc)
436436
static void smcr_conn_save_peer_info(struct smc_sock *smc,
437437
struct smc_clc_msg_accept_confirm *clc)
438438
{
439-
int bufsize = smc_uncompress_bufsize(clc->rmbe_size);
439+
int bufsize = smc_uncompress_bufsize(clc->r0.rmbe_size);
440440

441-
smc->conn.peer_rmbe_idx = clc->rmbe_idx;
442-
smc->conn.local_tx_ctrl.token = ntohl(clc->rmbe_alert_token);
441+
smc->conn.peer_rmbe_idx = clc->r0.rmbe_idx;
442+
smc->conn.local_tx_ctrl.token = ntohl(clc->r0.rmbe_alert_token);
443443
smc->conn.peer_rmbe_size = bufsize;
444444
atomic_set(&smc->conn.peer_rmbe_space, smc->conn.peer_rmbe_size);
445445
smc->conn.tx_off = bufsize * (smc->conn.peer_rmbe_idx - 1);
@@ -448,10 +448,10 @@ static void smcr_conn_save_peer_info(struct smc_sock *smc,
448448
static void smcd_conn_save_peer_info(struct smc_sock *smc,
449449
struct smc_clc_msg_accept_confirm *clc)
450450
{
451-
int bufsize = smc_uncompress_bufsize(clc->dmbe_size);
451+
int bufsize = smc_uncompress_bufsize(clc->d0.dmbe_size);
452452

453-
smc->conn.peer_rmbe_idx = clc->dmbe_idx;
454-
smc->conn.peer_token = clc->token;
453+
smc->conn.peer_rmbe_idx = clc->d0.dmbe_idx;
454+
smc->conn.peer_token = clc->d0.token;
455455
/* msg header takes up space in the buffer */
456456
smc->conn.peer_rmbe_size = bufsize - sizeof(struct smcd_cdc_msg);
457457
atomic_set(&smc->conn.peer_rmbe_space, smc->conn.peer_rmbe_size);
@@ -470,11 +470,11 @@ static void smc_conn_save_peer_info(struct smc_sock *smc,
470470
static void smc_link_save_peer_info(struct smc_link *link,
471471
struct smc_clc_msg_accept_confirm *clc)
472472
{
473-
link->peer_qpn = ntoh24(clc->qpn);
474-
memcpy(link->peer_gid, clc->lcl.gid, SMC_GID_SIZE);
475-
memcpy(link->peer_mac, clc->lcl.mac, sizeof(link->peer_mac));
476-
link->peer_psn = ntoh24(clc->psn);
477-
link->peer_mtu = clc->qp_mtu;
473+
link->peer_qpn = ntoh24(clc->r0.qpn);
474+
memcpy(link->peer_gid, clc->r0.lcl.gid, SMC_GID_SIZE);
475+
memcpy(link->peer_mac, clc->r0.lcl.mac, sizeof(link->peer_mac));
476+
link->peer_psn = ntoh24(clc->r0.psn);
477+
link->peer_mtu = clc->r0.qp_mtu;
478478
}
479479

480480
static void smc_switch_to_fallback(struct smc_sock *smc)
@@ -613,8 +613,8 @@ static int smc_connect_rdma(struct smc_sock *smc,
613613
struct smc_link *link;
614614

615615
ini->is_smcd = false;
616-
ini->ib_lcl = &aclc->lcl;
617-
ini->ib_clcqpn = ntoh24(aclc->qpn);
616+
ini->ib_lcl = &aclc->r0.lcl;
617+
ini->ib_clcqpn = ntoh24(aclc->r0.qpn);
618618
ini->first_contact_peer = aclc->hdr.flag;
619619

620620
mutex_lock(&smc_client_lgr_pending);
@@ -634,9 +634,11 @@ static int smc_connect_rdma(struct smc_sock *smc,
634634
for (i = 0; i < SMC_LINKS_PER_LGR_MAX; i++) {
635635
struct smc_link *l = &smc->conn.lgr->lnk[i];
636636

637-
if (l->peer_qpn == ntoh24(aclc->qpn) &&
638-
!memcmp(l->peer_gid, &aclc->lcl.gid, SMC_GID_SIZE) &&
639-
!memcmp(l->peer_mac, &aclc->lcl.mac, sizeof(l->peer_mac))) {
637+
if (l->peer_qpn == ntoh24(aclc->r0.qpn) &&
638+
!memcmp(l->peer_gid, &aclc->r0.lcl.gid,
639+
SMC_GID_SIZE) &&
640+
!memcmp(l->peer_mac, &aclc->r0.lcl.mac,
641+
sizeof(l->peer_mac))) {
640642
link = l;
641643
break;
642644
}
@@ -707,7 +709,7 @@ static int smc_connect_ism(struct smc_sock *smc,
707709
int rc = 0;
708710

709711
ini->is_smcd = true;
710-
ini->ism_peer_gid = aclc->gid;
712+
ini->ism_peer_gid = aclc->d0.gid;
711713
ini->first_contact_peer = aclc->hdr.flag;
712714

713715
/* there is only one lgr role for SMC-D; use server lock */

‎net/smc/smc_clc.c‎

Lines changed: 58 additions & 89 deletions
Original file line numberDiff line numberDiff line change
@@ -497,65 +497,85 @@ int smc_clc_send_proposal(struct smc_sock *smc, int smc_type,
497497
return reason_code;
498498
}
499499

500-
/* send CLC CONFIRM message across internal TCP socket */
501-
int smc_clc_send_confirm(struct smc_sock *smc)
500+
/* build and send CLC CONFIRM / ACCEPT message */
501+
static int smc_clc_send_confirm_accept(struct smc_sock *smc,
502+
struct smc_clc_msg_accept_confirm *clc,
503+
int first_contact)
502504
{
503505
struct smc_connection *conn = &smc->conn;
504-
struct smc_clc_msg_accept_confirm cclc;
505-
struct smc_link *link;
506-
int reason_code = 0;
507506
struct msghdr msg;
508507
struct kvec vec;
509-
int len;
510508

511509
/* send SMC Confirm CLC msg */
512-
memset(&cclc, 0, sizeof(cclc));
513-
cclc.hdr.type = SMC_CLC_CONFIRM;
514-
cclc.hdr.version = SMC_V1; /* SMC version */
510+
clc->hdr.version = SMC_V1; /* SMC version */
511+
if (first_contact)
512+
clc->hdr.flag = 1;
515513
if (conn->lgr->is_smcd) {
516514
/* SMC-D specific settings */
517-
memcpy(cclc.hdr.eyecatcher, SMCD_EYECATCHER,
515+
memcpy(clc->hdr.eyecatcher, SMCD_EYECATCHER,
518516
sizeof(SMCD_EYECATCHER));
519-
cclc.hdr.path = SMC_TYPE_D;
520-
cclc.hdr.length = htons(SMCD_CLC_ACCEPT_CONFIRM_LEN);
521-
cclc.gid = conn->lgr->smcd->local_gid;
522-
cclc.token = conn->rmb_desc->token;
523-
cclc.dmbe_size = conn->rmbe_size_short;
524-
cclc.dmbe_idx = 0;
525-
memcpy(&cclc.linkid, conn->lgr->id, SMC_LGR_ID_SIZE);
526-
memcpy(cclc.smcd_trl.eyecatcher, SMCD_EYECATCHER,
517+
clc->hdr.path = SMC_TYPE_D;
518+
clc->hdr.length = htons(SMCD_CLC_ACCEPT_CONFIRM_LEN);
519+
clc->d0.gid = conn->lgr->smcd->local_gid;
520+
clc->d0.token = conn->rmb_desc->token;
521+
clc->d0.dmbe_size = conn->rmbe_size_short;
522+
clc->d0.dmbe_idx = 0;
523+
memcpy(&clc->d0.linkid, conn->lgr->id, SMC_LGR_ID_SIZE);
524+
memcpy(clc->d0.smcd_trl.eyecatcher, SMCD_EYECATCHER,
527525
sizeof(SMCD_EYECATCHER));
528526
} else {
527+
struct smc_link *link = conn->lnk;
528+
529529
/* SMC-R specific settings */
530530
link = conn->lnk;
531-
memcpy(cclc.hdr.eyecatcher, SMC_EYECATCHER,
531+
memcpy(clc->hdr.eyecatcher, SMC_EYECATCHER,
532532
sizeof(SMC_EYECATCHER));
533-
cclc.hdr.path = SMC_TYPE_R;
534-
cclc.hdr.length = htons(SMCR_CLC_ACCEPT_CONFIRM_LEN);
535-
memcpy(cclc.lcl.id_for_peer, local_systemid,
533+
clc->hdr.path = SMC_TYPE_R;
534+
clc->hdr.length = htons(SMCR_CLC_ACCEPT_CONFIRM_LEN);
535+
memcpy(clc->r0.lcl.id_for_peer, local_systemid,
536536
sizeof(local_systemid));
537-
memcpy(&cclc.lcl.gid, link->gid, SMC_GID_SIZE);
538-
memcpy(&cclc.lcl.mac, &link->smcibdev->mac[link->ibport - 1],
537+
memcpy(&clc->r0.lcl.gid, link->gid, SMC_GID_SIZE);
538+
memcpy(&clc->r0.lcl.mac, &link->smcibdev->mac[link->ibport - 1],
539539
ETH_ALEN);
540-
hton24(cclc.qpn, link->roce_qp->qp_num);
541-
cclc.rmb_rkey =
540+
hton24(clc->r0.qpn, link->roce_qp->qp_num);
541+
clc->r0.rmb_rkey =
542542
htonl(conn->rmb_desc->mr_rx[link->link_idx]->rkey);
543-
cclc.rmbe_idx = 1; /* for now: 1 RMB = 1 RMBE */
544-
cclc.rmbe_alert_token = htonl(conn->alert_token_local);
545-
cclc.qp_mtu = min(link->path_mtu, link->peer_mtu);
546-
cclc.rmbe_size = conn->rmbe_size_short;
547-
cclc.rmb_dma_addr = cpu_to_be64((u64)sg_dma_address
543+
clc->r0.rmbe_idx = 1; /* for now: 1 RMB = 1 RMBE */
544+
clc->r0.rmbe_alert_token = htonl(conn->alert_token_local);
545+
switch (clc->hdr.type) {
546+
case SMC_CLC_ACCEPT:
547+
clc->r0.qp_mtu = link->path_mtu;
548+
break;
549+
case SMC_CLC_CONFIRM:
550+
clc->r0.qp_mtu = min(link->path_mtu, link->peer_mtu);
551+
break;
552+
}
553+
clc->r0.rmbe_size = conn->rmbe_size_short;
554+
clc->r0.rmb_dma_addr = cpu_to_be64((u64)sg_dma_address
548555
(conn->rmb_desc->sgt[link->link_idx].sgl));
549-
hton24(cclc.psn, link->psn_initial);
550-
memcpy(cclc.smcr_trl.eyecatcher, SMC_EYECATCHER,
556+
hton24(clc->r0.psn, link->psn_initial);
557+
memcpy(clc->r0.smcr_trl.eyecatcher, SMC_EYECATCHER,
551558
sizeof(SMC_EYECATCHER));
552559
}
553560

554561
memset(&msg, 0, sizeof(msg));
555-
vec.iov_base = &cclc;
556-
vec.iov_len = ntohs(cclc.hdr.length);
557-
len = kernel_sendmsg(smc->clcsock, &msg, &vec, 1,
558-
ntohs(cclc.hdr.length));
562+
vec.iov_base = clc;
563+
vec.iov_len = ntohs(clc->hdr.length);
564+
return kernel_sendmsg(smc->clcsock, &msg, &vec, 1,
565+
ntohs(clc->hdr.length));
566+
}
567+
568+
/* send CLC CONFIRM message across internal TCP socket */
569+
int smc_clc_send_confirm(struct smc_sock *smc)
570+
{
571+
struct smc_clc_msg_accept_confirm cclc;
572+
int reason_code = 0;
573+
int len;
574+
575+
/* send SMC Confirm CLC msg */
576+
memset(&cclc, 0, sizeof(cclc));
577+
cclc.hdr.type = SMC_CLC_CONFIRM;
578+
len = smc_clc_send_confirm_accept(smc, &cclc, 0);
559579
if (len < ntohs(cclc.hdr.length)) {
560580
if (len >= 0) {
561581
reason_code = -ENETUNREACH;
@@ -571,63 +591,12 @@ int smc_clc_send_confirm(struct smc_sock *smc)
571591
/* send CLC ACCEPT message across internal TCP socket */
572592
int smc_clc_send_accept(struct smc_sock *new_smc, bool srv_first_contact)
573593
{
574-
struct smc_connection *conn = &new_smc->conn;
575594
struct smc_clc_msg_accept_confirm aclc;
576-
struct smc_link *link;
577-
struct msghdr msg;
578-
struct kvec vec;
579595
int len;
580596

581597
memset(&aclc, 0, sizeof(aclc));
582598
aclc.hdr.type = SMC_CLC_ACCEPT;
583-
aclc.hdr.version = SMC_V1; /* SMC version */
584-
if (srv_first_contact)
585-
aclc.hdr.flag = 1;
586-
587-
if (conn->lgr->is_smcd) {
588-
/* SMC-D specific settings */
589-
aclc.hdr.length = htons(SMCD_CLC_ACCEPT_CONFIRM_LEN);
590-
memcpy(aclc.hdr.eyecatcher, SMCD_EYECATCHER,
591-
sizeof(SMCD_EYECATCHER));
592-
aclc.hdr.path = SMC_TYPE_D;
593-
aclc.gid = conn->lgr->smcd->local_gid;
594-
aclc.token = conn->rmb_desc->token;
595-
aclc.dmbe_size = conn->rmbe_size_short;
596-
aclc.dmbe_idx = 0;
597-
memcpy(&aclc.linkid, conn->lgr->id, SMC_LGR_ID_SIZE);
598-
memcpy(aclc.smcd_trl.eyecatcher, SMCD_EYECATCHER,
599-
sizeof(SMCD_EYECATCHER));
600-
} else {
601-
/* SMC-R specific settings */
602-
aclc.hdr.length = htons(SMCR_CLC_ACCEPT_CONFIRM_LEN);
603-
memcpy(aclc.hdr.eyecatcher, SMC_EYECATCHER,
604-
sizeof(SMC_EYECATCHER));
605-
aclc.hdr.path = SMC_TYPE_R;
606-
link = conn->lnk;
607-
memcpy(aclc.lcl.id_for_peer, local_systemid,
608-
sizeof(local_systemid));
609-
memcpy(&aclc.lcl.gid, link->gid, SMC_GID_SIZE);
610-
memcpy(&aclc.lcl.mac, link->smcibdev->mac[link->ibport - 1],
611-
ETH_ALEN);
612-
hton24(aclc.qpn, link->roce_qp->qp_num);
613-
aclc.rmb_rkey =
614-
htonl(conn->rmb_desc->mr_rx[link->link_idx]->rkey);
615-
aclc.rmbe_idx = 1; /* as long as 1 RMB = 1 RMBE */
616-
aclc.rmbe_alert_token = htonl(conn->alert_token_local);
617-
aclc.qp_mtu = link->path_mtu;
618-
aclc.rmbe_size = conn->rmbe_size_short,
619-
aclc.rmb_dma_addr = cpu_to_be64((u64)sg_dma_address
620-
(conn->rmb_desc->sgt[link->link_idx].sgl));
621-
hton24(aclc.psn, link->psn_initial);
622-
memcpy(aclc.smcr_trl.eyecatcher, SMC_EYECATCHER,
623-
sizeof(SMC_EYECATCHER));
624-
}
625-
626-
memset(&msg, 0, sizeof(msg));
627-
vec.iov_base = &aclc;
628-
vec.iov_len = ntohs(aclc.hdr.length);
629-
len = kernel_sendmsg(new_smc->clcsock, &msg, &vec, 1,
630-
ntohs(aclc.hdr.length));
599+
len = smc_clc_send_confirm_accept(new_smc, &aclc, srv_first_contact);
631600
if (len < ntohs(aclc.hdr.length))
632601
len = len >= 0 ? -EPROTO : -new_smc->clcsock->sk->sk_err;
633602

‎net/smc/smc_clc.h‎

Lines changed: 39 additions & 35 deletions
Original file line numberDiff line numberDiff line change
@@ -118,46 +118,50 @@ struct smc_clc_msg_proposal_area {
118118
struct smc_clc_msg_trail pclc_trl;
119119
};
120120

121-
struct smc_clc_msg_accept_confirm { /* clc accept / confirm message */
122-
struct smc_clc_msg_hdr hdr;
123-
union {
124-
struct { /* SMC-R */
125-
struct smc_clc_msg_local lcl;
126-
u8 qpn[3]; /* QP number */
127-
__be32 rmb_rkey; /* RMB rkey */
128-
u8 rmbe_idx; /* Index of RMBE in RMB */
129-
__be32 rmbe_alert_token;/* unique connection id */
130-
#if defined(__BIG_ENDIAN_BITFIELD)
131-
u8 rmbe_size : 4, /* buf size (compressed) */
132-
qp_mtu : 4; /* QP mtu */
121+
struct smcr_clc_msg_accept_confirm { /* SMCR accept/confirm */
122+
struct smc_clc_msg_local lcl;
123+
u8 qpn[3]; /* QP number */
124+
__be32 rmb_rkey; /* RMB rkey */
125+
u8 rmbe_idx; /* Index of RMBE in RMB */
126+
__be32 rmbe_alert_token; /* unique connection id */
127+
#if defined(__BIG_ENDIAN_BITFIELD)
128+
u8 rmbe_size : 4, /* buf size (compressed) */
129+
qp_mtu : 4; /* QP mtu */
133130
#elif defined(__LITTLE_ENDIAN_BITFIELD)
134-
u8 qp_mtu : 4,
135-
rmbe_size : 4;
131+
u8 qp_mtu : 4,
132+
rmbe_size : 4;
136133
#endif
137-
u8 reserved;
138-
__be64 rmb_dma_addr; /* RMB virtual address */
139-
u8 reserved2;
140-
u8 psn[3]; /* packet sequence number */
141-
struct smc_clc_msg_trail smcr_trl;
142-
/* eye catcher "SMCR" EBCDIC */
143-
} __packed;
144-
struct { /* SMC-D */
145-
u64 gid; /* Sender GID */
146-
u64 token; /* DMB token */
147-
u8 dmbe_idx; /* DMBE index */
134+
u8 reserved;
135+
__be64 rmb_dma_addr; /* RMB virtual address */
136+
u8 reserved2;
137+
u8 psn[3]; /* packet sequence number */
138+
struct smc_clc_msg_trail smcr_trl;
139+
/* eye catcher "SMCR" EBCDIC */
140+
} __packed;
141+
142+
struct smcd_clc_msg_accept_confirm { /* SMCD accept/confirm */
143+
u64 gid; /* Sender GID */
144+
u64 token; /* DMB token */
145+
u8 dmbe_idx; /* DMBE index */
148146
#if defined(__BIG_ENDIAN_BITFIELD)
149-
u8 dmbe_size : 4, /* buf size (compressed) */
150-
reserved3 : 4;
147+
u8 dmbe_size : 4, /* buf size (compressed) */
148+
reserved3 : 4;
151149
#elif defined(__LITTLE_ENDIAN_BITFIELD)
152-
u8 reserved3 : 4,
153-
dmbe_size : 4;
150+
u8 reserved3 : 4,
151+
dmbe_size : 4;
154152
#endif
155-
u16 reserved4;
156-
u32 linkid; /* Link identifier */
157-
u32 reserved5[3];
158-
struct smc_clc_msg_trail smcd_trl;
159-
/* eye catcher "SMCD" EBCDIC */
160-
} __packed;
153+
u16 reserved4;
154+
u32 linkid; /* Link identifier */
155+
u32 reserved5[3];
156+
struct smc_clc_msg_trail smcd_trl;
157+
/* eye catcher "SMCD" EBCDIC */
158+
} __packed;
159+
160+
struct smc_clc_msg_accept_confirm { /* clc accept / confirm message */
161+
struct smc_clc_msg_hdr hdr;
162+
union {
163+
struct smcr_clc_msg_accept_confirm r0; /* SMC-R */
164+
struct smcd_clc_msg_accept_confirm d0; /* SMC-D */
161165
};
162166
} __packed; /* format defined in RFC7609 */
163167

‎net/smc/smc_core.c‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1892,8 +1892,8 @@ int smc_rmb_rtoken_handling(struct smc_connection *conn,
18921892
struct smc_link *lnk,
18931893
struct smc_clc_msg_accept_confirm *clc)
18941894
{
1895-
conn->rtoken_idx = smc_rtoken_add(lnk, clc->rmb_dma_addr,
1896-
clc->rmb_rkey);
1895+
conn->rtoken_idx = smc_rtoken_add(lnk, clc->r0.rmb_dma_addr,
1896+
clc->r0.rmb_rkey);
18971897
if (conn->rtoken_idx < 0)
18981898
return conn->rtoken_idx;
18991899
return 0;

0 commit comments

Comments
 (0)