scsi/qedf/qedf_fip.c

0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  *  QLogic FCoE Offload Driver
0004  *  Copyright (c) 2016-2018 Cavium Inc.
0005  */
0006 #include <linux/if_ether.h>
0007 #include <linux/if_vlan.h>
0008 #include "qedf.h"
0009
0010 extern const struct qed_fcoe_ops *qed_ops;
0011 /*
0012  * FIP VLAN functions that will eventually move to libfcoe.
0013  */
0014
0015 void qedf_fcoe_send_vlan_req(struct qedf_ctx *qedf)
0016 {
0017     struct sk_buff *skb;
0018     char *eth_fr;
0019     struct fip_vlan *vlan;
0020 #define MY_FIP_ALL_FCF_MACS        ((__u8[6]) { 1, 0x10, 0x18, 1, 0, 2 })
0021     static u8 my_fcoe_all_fcfs[ETH_ALEN] = MY_FIP_ALL_FCF_MACS;
0022     unsigned long flags = 0;
0023     int rc;
0024
0025     skb = dev_alloc_skb(sizeof(struct fip_vlan));
0026     if (!skb) {
0027         QEDF_ERR(&qedf->dbg_ctx,
0028              "Failed to allocate skb.\n");
0029         return;
0030     }
0031
0032     eth_fr = (char *)skb->data;
0033     vlan = (struct fip_vlan *)eth_fr;
0034
0035     memset(vlan, 0, sizeof(*vlan));
0036     ether_addr_copy(vlan->eth.h_source, qedf->mac);
0037     ether_addr_copy(vlan->eth.h_dest, my_fcoe_all_fcfs);
0038     vlan->eth.h_proto = htons(ETH_P_FIP);
0039
0040     vlan->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);
0041     vlan->fip.fip_op = htons(FIP_OP_VLAN);
0042     vlan->fip.fip_subcode = FIP_SC_VL_REQ;
0043     vlan->fip.fip_dl_len = htons(sizeof(vlan->desc) / FIP_BPW);
0044
0045     vlan->desc.mac.fd_desc.fip_dtype = FIP_DT_MAC;
0046     vlan->desc.mac.fd_desc.fip_dlen = sizeof(vlan->desc.mac) / FIP_BPW;
0047     ether_addr_copy(vlan->desc.mac.fd_mac, qedf->mac);
0048
0049     vlan->desc.wwnn.fd_desc.fip_dtype = FIP_DT_NAME;
0050     vlan->desc.wwnn.fd_desc.fip_dlen = sizeof(vlan->desc.wwnn) / FIP_BPW;
0051     put_unaligned_be64(qedf->lport->wwnn, &vlan->desc.wwnn.fd_wwn);
0052
0053     skb_put(skb, sizeof(*vlan));
0054     skb->protocol = htons(ETH_P_FIP);
0055     skb_reset_mac_header(skb);
0056     skb_reset_network_header(skb);
0057
0058     QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Sending FIP VLAN "
0059            "request.");
0060
0061     if (atomic_read(&qedf->link_state) != QEDF_LINK_UP) {
0062         QEDF_WARN(&(qedf->dbg_ctx), "Cannot send vlan request "
0063             "because link is not up.\n");
0064
0065         kfree_skb(skb);
0066         return;
0067     }
0068
0069     set_bit(QED_LL2_XMIT_FLAGS_FIP_DISCOVERY, &flags);
0070     rc = qed_ops->ll2->start_xmit(qedf->cdev, skb, flags);
0071     if (rc) {
0072         QEDF_ERR(&qedf->dbg_ctx, "start_xmit failed rc = %d.\n", rc);
0073         kfree_skb(skb);
0074         return;
0075     }
0076
0077 }
0078
0079 static void qedf_fcoe_process_vlan_resp(struct qedf_ctx *qedf,
0080     struct sk_buff *skb)
0081 {
0082     struct fip_header *fiph;
0083     struct fip_desc *desc;
0084     u16 vid = 0;
0085     ssize_t rlen;
0086     size_t dlen;
0087
0088     fiph = (struct fip_header *)(((void *)skb->data) + 2 * ETH_ALEN + 2);
0089
0090     rlen = ntohs(fiph->fip_dl_len) * 4;
0091     desc = (struct fip_desc *)(fiph + 1);
0092     while (rlen > 0) {
0093         dlen = desc->fip_dlen * FIP_BPW;
0094         switch (desc->fip_dtype) {
0095         case FIP_DT_VLAN:
0096             vid = ntohs(((struct fip_vlan_desc *)desc)->fd_vlan);
0097             break;
0098         }
0099         desc = (struct fip_desc *)((char *)desc + dlen);
0100         rlen -= dlen;
0101     }
0102
0103     if (atomic_read(&qedf->link_state) == QEDF_LINK_DOWN) {
0104         QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
0105               "Dropping VLAN response as link is down.\n");
0106         return;
0107     }
0108
0109     QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "VLAN response, "
0110            "vid=0x%x.\n", vid);
0111
0112     if (vid > 0 && qedf->vlan_id != vid) {
0113         qedf_set_vlan_id(qedf, vid);
0114
0115         /* Inform waiter that it's ok to call fcoe_ctlr_link up() */
0116         if (!completion_done(&qedf->fipvlan_compl))
0117             complete(&qedf->fipvlan_compl);
0118     }
0119 }
0120
0121 void qedf_fip_send(struct fcoe_ctlr *fip, struct sk_buff *skb)
0122 {
0123     struct qedf_ctx *qedf = container_of(fip, struct qedf_ctx, ctlr);
0124     struct ethhdr *eth_hdr;
0125     struct fip_header *fiph;
0126     u16 op, vlan_tci = 0;
0127     u8 sub;
0128     int rc = -1;
0129
0130     if (!test_bit(QEDF_LL2_STARTED, &qedf->flags)) {
0131         QEDF_WARN(&(qedf->dbg_ctx), "LL2 not started\n");
0132         kfree_skb(skb);
0133         return;
0134     }
0135
0136     fiph = (struct fip_header *) ((void *)skb->data + 2 * ETH_ALEN + 2);
0137     eth_hdr = (struct ethhdr *)skb_mac_header(skb);
0138     op = ntohs(fiph->fip_op);
0139     sub = fiph->fip_subcode;
0140
0141     /*
0142      * Add VLAN tag to non-offload FIP frame based on current stored VLAN
0143      * for FIP/FCoE traffic.
0144      */
0145     __vlan_hwaccel_put_tag(skb, htons(ETH_P_8021Q), qedf->vlan_id);
0146
0147     /* Get VLAN ID from skb for printing purposes */
0148     __vlan_hwaccel_get_tag(skb, &vlan_tci);
0149
0150     QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_LL2, "FIP frame send: "
0151         "dest=%pM op=%x sub=%x vlan=%04x.", eth_hdr->h_dest, op, sub,
0152         vlan_tci);
0153     if (qedf_dump_frames)
0154         print_hex_dump(KERN_WARNING, "fip ", DUMP_PREFIX_OFFSET, 16, 1,
0155             skb->data, skb->len, false);
0156
0157     rc = qed_ops->ll2->start_xmit(qedf->cdev, skb, 0);
0158     if (rc) {
0159         QEDF_ERR(&qedf->dbg_ctx, "start_xmit failed rc = %d.\n", rc);
0160         kfree_skb(skb);
0161         return;
0162     }
0163 }
0164
0165 static u8 fcoe_all_enode[ETH_ALEN] = FIP_ALL_ENODE_MACS;
0166
0167 /* Process incoming FIP frames. */
0168 void qedf_fip_recv(struct qedf_ctx *qedf, struct sk_buff *skb)
0169 {
0170     struct ethhdr *eth_hdr;
0171     struct fip_header *fiph;
0172     struct fip_desc *desc;
0173     struct fip_mac_desc *mp;
0174     struct fip_wwn_desc *wp;
0175     struct fip_vn_desc *vp;
0176     size_t rlen, dlen;
0177     u16 op;
0178     u8 sub;
0179     bool fcf_valid = false;
0180     /* Default is to handle CVL regardless of fabric id descriptor */
0181     bool fabric_id_valid = true;
0182     bool fc_wwpn_valid = false;
0183     u64 switch_name;
0184     u16 vlan = 0;
0185
0186     eth_hdr = (struct ethhdr *)skb_mac_header(skb);
0187     fiph = (struct fip_header *) ((void *)skb->data + 2 * ETH_ALEN + 2);
0188     op = ntohs(fiph->fip_op);
0189     sub = fiph->fip_subcode;
0190
0191     QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_LL2,
0192           "FIP frame received: skb=%p fiph=%p source=%pM destn=%pM op=%x sub=%x vlan=%04x",
0193           skb, fiph, eth_hdr->h_source, eth_hdr->h_dest, op,
0194           sub, vlan);
0195     if (qedf_dump_frames)
0196         print_hex_dump(KERN_WARNING, "fip ", DUMP_PREFIX_OFFSET, 16, 1,
0197             skb->data, skb->len, false);
0198
0199     if (!ether_addr_equal(eth_hdr->h_dest, qedf->mac) &&
0200         !ether_addr_equal(eth_hdr->h_dest, fcoe_all_enode) &&
0201         !ether_addr_equal(eth_hdr->h_dest, qedf->data_src_addr)) {
0202         QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_LL2,
0203               "Dropping FIP type 0x%x pkt due to destination MAC mismatch dest_mac=%pM ctlr.dest_addr=%pM data_src_addr=%pM.\n",
0204               op, eth_hdr->h_dest, qedf->mac,
0205               qedf->data_src_addr);
0206         kfree_skb(skb);
0207         return;
0208     }
0209
0210     /* Handle FIP VLAN resp in the driver */
0211     if (op == FIP_OP_VLAN && sub == FIP_SC_VL_NOTE) {
0212         qedf_fcoe_process_vlan_resp(qedf, skb);
0213         kfree_skb(skb);
0214     } else if (op == FIP_OP_CTRL && sub == FIP_SC_CLR_VLINK) {
0215         QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC, "Clear virtual "
0216                "link received.\n");
0217
0218         /* Check that an FCF has been selected by fcoe */
0219         if (qedf->ctlr.sel_fcf == NULL) {
0220             QEDF_INFO(&(qedf->dbg_ctx), QEDF_LOG_DISC,
0221                 "Dropping CVL since FCF has not been selected "
0222                 "yet.");
0223             kfree_skb(skb);
0224             return;
0225         }
0226
0227         /*
0228          * We need to loop through the CVL descriptors to determine
0229          * if we want to reset the fcoe link
0230          */
0231         rlen = ntohs(fiph->fip_dl_len) * FIP_BPW;
0232         desc = (struct fip_desc *)(fiph + 1);
0233         while (rlen >= sizeof(*desc)) {
0234             dlen = desc->fip_dlen * FIP_BPW;
0235             switch (desc->fip_dtype) {
0236             case FIP_DT_MAC:
0237                 mp = (struct fip_mac_desc *)desc;
0238                 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
0239                       "Switch fd_mac=%pM.\n", mp->fd_mac);
0240                 if (ether_addr_equal(mp->fd_mac,
0241                     qedf->ctlr.sel_fcf->fcf_mac))
0242                     fcf_valid = true;
0243                 break;
0244             case FIP_DT_NAME:
0245                 wp = (struct fip_wwn_desc *)desc;
0246                 switch_name = get_unaligned_be64(&wp->fd_wwn);
0247                 QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
0248                       "Switch fd_wwn=%016llx fcf_switch_name=%016llx.\n",
0249                       switch_name,
0250                       qedf->ctlr.sel_fcf->switch_name);
0251                 if (switch_name ==
0252                     qedf->ctlr.sel_fcf->switch_name)
0253                     fc_wwpn_valid = true;
0254                 break;
0255             case FIP_DT_VN_ID:
0256                 fabric_id_valid = false;
0257                 vp = (struct fip_vn_desc *)desc;
0258
0259                 QEDF_ERR(&qedf->dbg_ctx,
0260                      "CVL vx_port fd_fc_id=0x%x fd_mac=%pM fd_wwpn=%016llx.\n",
0261                      ntoh24(vp->fd_fc_id), vp->fd_mac,
0262                      get_unaligned_be64(&vp->fd_wwpn));
0263                 /* Check for vx_port wwpn OR Check vx_port
0264                  * fabric ID OR Check vx_port MAC
0265                  */
0266                 if ((get_unaligned_be64(&vp->fd_wwpn) ==
0267                     qedf->wwpn) ||
0268                    (ntoh24(vp->fd_fc_id) ==
0269                     qedf->lport->port_id) ||
0270                    (ether_addr_equal(vp->fd_mac,
0271                     qedf->data_src_addr))) {
0272                     fabric_id_valid = true;
0273                 }
0274                 break;
0275             default:
0276                 /* Ignore anything else */
0277                 break;
0278             }
0279             desc = (struct fip_desc *)((char *)desc + dlen);
0280             rlen -= dlen;
0281         }
0282
0283         QEDF_INFO(&qedf->dbg_ctx, QEDF_LOG_DISC,
0284               "fcf_valid=%d fabric_id_valid=%d fc_wwpn_valid=%d.\n",
0285               fcf_valid, fabric_id_valid, fc_wwpn_valid);
0286         if (fcf_valid && fabric_id_valid && fc_wwpn_valid)
0287             qedf_ctx_soft_reset(qedf->lport);
0288         kfree_skb(skb);
0289     } else {
0290         /* Everything else is handled by libfcoe */
0291         __skb_pull(skb, ETH_HLEN);
0292         fcoe_ctlr_recv(&qedf->ctlr, skb);
0293     }
0294 }
0295
0296 u8 *qedf_get_src_mac(struct fc_lport *lport)
0297 {
0298     struct qedf_ctx *qedf = lport_priv(lport);
0299
0300     return qedf->data_src_addr;
0301 }