net/smc: CLC header fields renaming

SMCD version 2 defines 2 more bits in the CLC header to specify
version 2 types. This patch prepares better naming of the CLC
header fields. 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>

diff --git a/net/smc/af_smc.c b/net/smc/af_smc.c
index ed8f971..1a02d36 100644 (file)
--- a/net/smc/af_smc.c
+++ b/net/smc/af_smc.c
@@ -618,7 +618,7 @@ static int smc_connect_rdma(struct smc_sock *smc,
        ini->is_smcd = false;
        ini->ib_lcl = &aclc->r0.lcl;
        ini->ib_clcqpn = ntoh24(aclc->r0.qpn);
-       ini->first_contact_peer = aclc->hdr.flag;
+       ini->first_contact_peer = aclc->hdr.typev2 & SMC_FIRST_CONTACT_MASK;
 
        mutex_lock(&smc_client_lgr_pending);
        reason_code = smc_conn_create(smc, ini);
@@ -713,7 +713,7 @@ static int smc_connect_ism(struct smc_sock *smc,
 
        ini->is_smcd = true;
        ini->ism_peer_gid = aclc->d0.gid;
-       ini->first_contact_peer = aclc->hdr.flag;
+       ini->first_contact_peer = aclc->hdr.typev2 & SMC_FIRST_CONTACT_MASK;
 
        /* there is only one lgr role for SMC-D; use server lock */
        mutex_lock(&smc_server_lgr_pending);
@@ -804,9 +804,9 @@ static int __smc_connect(struct smc_sock *smc)
        }
 
        /* depending on previous steps, connect using rdma or ism */
-       if (rdma_supported && aclc.hdr.path == SMC_TYPE_R)
+       if (rdma_supported && aclc.hdr.typev1 == SMC_TYPE_R)
                rc = smc_connect_rdma(smc, &aclc, &ini);
-       else if (ism_supported && aclc.hdr.path == SMC_TYPE_D)
+       else if (ism_supported && aclc.hdr.typev1 == SMC_TYPE_D)
                rc = smc_connect_ism(smc, &aclc, &ini);
        else
                rc = SMC_CLC_DECL_MODEUNSUPP;
@@ -1316,7 +1316,7 @@ static void smc_listen_work(struct work_struct *work)
        smc_tx_init(new_smc);
 
        /* check if ISM is available */
-       if (pclc->hdr.path == SMC_TYPE_D || pclc->hdr.path == SMC_TYPE_B) {
+       if (pclc->hdr.typev1 == SMC_TYPE_D || pclc->hdr.typev1 == SMC_TYPE_B) {
                struct smc_clc_msg_smcd *pclc_smcd = smc_get_clc_msg_smcd(pclc);
 
                ini.is_smcd = true; /* prepare ISM check */
@@ -1326,7 +1326,7 @@ static void smc_listen_work(struct work_struct *work)
                        rc = smc_listen_ism_init(new_smc, pclc, &ini);
                if (!rc)
                        ism_supported = true;
-               else if (pclc->hdr.path == SMC_TYPE_D)
+               else if (pclc->hdr.typev1 == SMC_TYPE_D)
                        goto out_unlock; /* skip RDMA and decline */
        }
 
@@ -1339,7 +1339,7 @@ static void smc_listen_work(struct work_struct *work)
                rc = smc_find_rdma_device(new_smc, &ini);
                if (rc) {
                        /* no RDMA device found */
-                       if (pclc->hdr.path == SMC_TYPE_B)
+                       if (pclc->hdr.typev1 == SMC_TYPE_B)
                                /* neither ISM nor RDMA device found */
                                rc = SMC_CLC_DECL_NOSMCDEV;
                        goto out_unlock;

diff --git a/net/smc/smc_clc.c b/net/smc/smc_clc.c
index bd116e1..524d2b2 100644 (file)
--- a/net/smc/smc_clc.c
+++ b/net/smc/smc_clc.c
@@ -64,12 +64,12 @@ static bool smc_clc_msg_hdr_valid(struct smc_clc_msg_hdr *clcm, bool check_trl)
                break;
        case SMC_CLC_ACCEPT:
        case SMC_CLC_CONFIRM:
-               if (clcm->path != SMC_TYPE_R && clcm->path != SMC_TYPE_D)
+               if (clcm->typev1 != SMC_TYPE_R && clcm->typev1 != SMC_TYPE_D)
                        return false;
                clc = (struct smc_clc_msg_accept_confirm *)clcm;
-               if ((clcm->path == SMC_TYPE_R &&
+               if ((clcm->typev1 == SMC_TYPE_R &&
                     ntohs(clc->hdr.length) != SMCR_CLC_ACCEPT_CONFIRM_LEN) ||
-                   (clcm->path == SMC_TYPE_D &&
+                   (clcm->typev1 == SMC_TYPE_D &&
                     ntohs(clc->hdr.length) != SMCD_CLC_ACCEPT_CONFIRM_LEN))
                        return false;
                trl = (struct smc_clc_msg_trail *)
@@ -327,7 +327,7 @@ int smc_clc_wait_msg(struct smc_sock *smc, void *buf, int buflen,
                goto out;
        }
 
-       if (clcm->type == SMC_CLC_PROPOSAL && clcm->path == SMC_TYPE_N)
+       if (clcm->type == SMC_CLC_PROPOSAL && clcm->typev1 == SMC_TYPE_N)
                reason_code = SMC_CLC_DECL_VERSMISMAT; /* just V2 offered */
 
        /* receive the complete CLC message */
@@ -365,7 +365,8 @@ int smc_clc_wait_msg(struct smc_sock *smc, void *buf, int buflen,
                dclc = (struct smc_clc_msg_decline *)clcm;
                reason_code = SMC_CLC_DECL_PEERDECL;
                smc->peer_diagnosis = ntohl(dclc->peer_diagnosis);
-               if (((struct smc_clc_msg_decline *)buf)->hdr.flag) {
+               if (((struct smc_clc_msg_decline *)buf)->hdr.typev2 &
+                                               SMC_FIRST_CONTACT_MASK) {
                        smc->conn.lgr->sync_err = 1;
                        smc_lgr_terminate_sched(smc->conn.lgr);
                }
@@ -389,7 +390,8 @@ int smc_clc_send_decline(struct smc_sock *smc, u32 peer_diag_info)
        dclc.hdr.type = SMC_CLC_DECLINE;
        dclc.hdr.length = htons(sizeof(struct smc_clc_msg_decline));
        dclc.hdr.version = SMC_V1;
-       dclc.hdr.flag = (peer_diag_info == SMC_CLC_DECL_SYNCERR) ? 1 : 0;
+       dclc.hdr.typev2 = (peer_diag_info == SMC_CLC_DECL_SYNCERR) ?
+                                               SMC_FIRST_CONTACT_MASK : 0;
        if ((!smc->conn.lgr || !smc->conn.lgr->is_smcd) &&
            smc_ib_is_valid_local_systemid())
                memcpy(dclc.id_for_peer, local_systemid,
@@ -447,7 +449,7 @@ int smc_clc_send_proposal(struct smc_sock *smc, int smc_type,
               sizeof(SMC_EYECATCHER));
        pclc_base->hdr.type = SMC_CLC_PROPOSAL;
        pclc_base->hdr.version = SMC_V1;                /* SMC version */
-       pclc_base->hdr.path = smc_type;
+       pclc_base->hdr.typev1 = smc_type;
        if (smc_type == SMC_TYPE_R || smc_type == SMC_TYPE_B) {
                /* add SMC-R specifics */
                memcpy(pclc_base->lcl.id_for_peer, local_systemid,
@@ -509,12 +511,12 @@ static int smc_clc_send_confirm_accept(struct smc_sock *smc,
        /* send SMC Confirm CLC msg */
        clc->hdr.version = SMC_V1;              /* SMC version */
        if (first_contact)
-               clc->hdr.flag = 1;
+               clc->hdr.typev2 |= SMC_FIRST_CONTACT_MASK;
        if (conn->lgr->is_smcd) {
                /* SMC-D specific settings */
                memcpy(clc->hdr.eyecatcher, SMCD_EYECATCHER,
                       sizeof(SMCD_EYECATCHER));
-               clc->hdr.path = SMC_TYPE_D;
+               clc->hdr.typev1 = SMC_TYPE_D;
                clc->hdr.length = htons(SMCD_CLC_ACCEPT_CONFIRM_LEN);
                clc->d0.gid = conn->lgr->smcd->local_gid;
                clc->d0.token = conn->rmb_desc->token;
@@ -530,7 +532,7 @@ static int smc_clc_send_confirm_accept(struct smc_sock *smc,
                link = conn->lnk;
                memcpy(clc->hdr.eyecatcher, SMC_EYECATCHER,
                       sizeof(SMC_EYECATCHER));
-               clc->hdr.path = SMC_TYPE_R;
+               clc->hdr.typev1 = SMC_TYPE_R;
                clc->hdr.length = htons(SMCR_CLC_ACCEPT_CONFIRM_LEN);
                memcpy(clc->r0.lcl.id_for_peer, local_systemid,
                       sizeof(local_systemid));

diff --git a/net/smc/smc_clc.h b/net/smc/smc_clc.h
index fcd8521..5b2d058 100644 (file)
--- a/net/smc/smc_clc.h
+++ b/net/smc/smc_clc.h
@@ -54,19 +54,19 @@
 #define SMC_CLC_DECL_ERR_RDYLNK        0x09990002  /*   ib ready link failed         */
 #define SMC_CLC_DECL_ERR_REGRMB        0x09990003  /*   reg rmb failed               */
 
+#define SMC_FIRST_CONTACT_MASK 0b10    /* first contact bit within typev2 */
+
 struct smc_clc_msg_hdr {       /* header1 of clc messages */
        u8 eyecatcher[4];       /* eye catcher */
        u8 type;                /* proposal / accept / confirm / decline */
        __be16 length;
 #if defined(__BIG_ENDIAN_BITFIELD)
        u8 version : 4,
-          flag    : 1,
-          rsvd    : 1,
-          path    : 2;
+          typev2  : 2,
+          typev1  : 2;
 #elif defined(__LITTLE_ENDIAN_BITFIELD)
-       u8 path    : 2,
-          rsvd    : 1,
-          flag    : 1,
+       u8 typev1  : 2,
+          typev2  : 2,
           version : 4;
 #endif
 } __packed;                    /* format defined in RFC7609 */