3255 lines · c
1// SPDX-License-Identifier: GPL-2.0-only2/*3 * Copyright (c) 2008-2009 Cisco Systems, Inc. All rights reserved.4 * Copyright (c) 2009 Intel Corporation. All rights reserved.5 *6 * Maintained at www.Open-FCoE.org7 */8 9#include <linux/types.h>10#include <linux/module.h>11#include <linux/kernel.h>12#include <linux/list.h>13#include <linux/spinlock.h>14#include <linux/timer.h>15#include <linux/netdevice.h>16#include <linux/etherdevice.h>17#include <linux/ethtool.h>18#include <linux/if_ether.h>19#include <linux/if_vlan.h>20#include <linux/errno.h>21#include <linux/bitops.h>22#include <linux/slab.h>23#include <net/rtnetlink.h>24 25#include <scsi/fc/fc_els.h>26#include <scsi/fc/fc_fs.h>27#include <scsi/fc/fc_fip.h>28#include <scsi/fc/fc_encaps.h>29#include <scsi/fc/fc_fcoe.h>30#include <scsi/fc/fc_fcp.h>31 32#include <scsi/libfc.h>33#include <scsi/libfcoe.h>34 35#include "libfcoe.h"36 37#define FCOE_CTLR_MIN_FKA 500 /* min keep alive (mS) */38#define FCOE_CTLR_DEF_FKA FIP_DEF_FKA /* default keep alive (mS) */39 40static void fcoe_ctlr_timeout(struct timer_list *);41static void fcoe_ctlr_timer_work(struct work_struct *);42static void fcoe_ctlr_recv_work(struct work_struct *);43static int fcoe_ctlr_flogi_retry(struct fcoe_ctlr *);44 45static void fcoe_ctlr_vn_start(struct fcoe_ctlr *);46static int fcoe_ctlr_vn_recv(struct fcoe_ctlr *, struct sk_buff *);47static void fcoe_ctlr_vn_timeout(struct fcoe_ctlr *);48static int fcoe_ctlr_vn_lookup(struct fcoe_ctlr *, u32, u8 *);49 50static int fcoe_ctlr_vlan_recv(struct fcoe_ctlr *, struct sk_buff *);51 52static u8 fcoe_all_fcfs[ETH_ALEN] = FIP_ALL_FCF_MACS;53static u8 fcoe_all_enode[ETH_ALEN] = FIP_ALL_ENODE_MACS;54static u8 fcoe_all_vn2vn[ETH_ALEN] = FIP_ALL_VN2VN_MACS;55static u8 fcoe_all_p2p[ETH_ALEN] = FIP_ALL_P2P_MACS;56 57static const char * const fcoe_ctlr_states[] = {58 [FIP_ST_DISABLED] = "DISABLED",59 [FIP_ST_LINK_WAIT] = "LINK_WAIT",60 [FIP_ST_AUTO] = "AUTO",61 [FIP_ST_NON_FIP] = "NON_FIP",62 [FIP_ST_ENABLED] = "ENABLED",63 [FIP_ST_VNMP_START] = "VNMP_START",64 [FIP_ST_VNMP_PROBE1] = "VNMP_PROBE1",65 [FIP_ST_VNMP_PROBE2] = "VNMP_PROBE2",66 [FIP_ST_VNMP_CLAIM] = "VNMP_CLAIM",67 [FIP_ST_VNMP_UP] = "VNMP_UP",68};69 70static const char *fcoe_ctlr_state(enum fip_state state)71{72 const char *cp = "unknown";73 74 if (state < ARRAY_SIZE(fcoe_ctlr_states))75 cp = fcoe_ctlr_states[state];76 if (!cp)77 cp = "unknown";78 return cp;79}80 81/**82 * fcoe_ctlr_set_state() - Set and do debug printing for the new FIP state.83 * @fip: The FCoE controller84 * @state: The new state85 */86static void fcoe_ctlr_set_state(struct fcoe_ctlr *fip, enum fip_state state)87{88 if (state == fip->state)89 return;90 if (fip->lp)91 LIBFCOE_FIP_DBG(fip, "state %s -> %s\n",92 fcoe_ctlr_state(fip->state), fcoe_ctlr_state(state));93 fip->state = state;94}95 96/**97 * fcoe_ctlr_mtu_valid() - Check if a FCF's MTU is valid98 * @fcf: The FCF to check99 *100 * Return non-zero if FCF fcoe_size has been validated.101 */102static inline int fcoe_ctlr_mtu_valid(const struct fcoe_fcf *fcf)103{104 return (fcf->flags & FIP_FL_SOL) != 0;105}106 107/**108 * fcoe_ctlr_fcf_usable() - Check if a FCF is usable109 * @fcf: The FCF to check110 *111 * Return non-zero if the FCF is usable.112 */113static inline int fcoe_ctlr_fcf_usable(struct fcoe_fcf *fcf)114{115 u16 flags = FIP_FL_SOL | FIP_FL_AVAIL;116 117 return (fcf->flags & flags) == flags;118}119 120/**121 * fcoe_ctlr_map_dest() - Set flag and OUI for mapping destination addresses122 * @fip: The FCoE controller123 */124static void fcoe_ctlr_map_dest(struct fcoe_ctlr *fip)125{126 if (fip->mode == FIP_MODE_VN2VN)127 hton24(fip->dest_addr, FIP_VN_FC_MAP);128 else129 hton24(fip->dest_addr, FIP_DEF_FC_MAP);130 hton24(fip->dest_addr + 3, 0);131 fip->map_dest = 1;132}133 134/**135 * fcoe_ctlr_init() - Initialize the FCoE Controller instance136 * @fip: The FCoE controller to initialize137 * @mode: FIP mode to set138 */139void fcoe_ctlr_init(struct fcoe_ctlr *fip, enum fip_mode mode)140{141 fcoe_ctlr_set_state(fip, FIP_ST_LINK_WAIT);142 fip->mode = mode;143 fip->fip_resp = false;144 INIT_LIST_HEAD(&fip->fcfs);145 mutex_init(&fip->ctlr_mutex);146 spin_lock_init(&fip->ctlr_lock);147 fip->flogi_oxid = FC_XID_UNKNOWN;148 timer_setup(&fip->timer, fcoe_ctlr_timeout, 0);149 INIT_WORK(&fip->timer_work, fcoe_ctlr_timer_work);150 INIT_WORK(&fip->recv_work, fcoe_ctlr_recv_work);151 skb_queue_head_init(&fip->fip_recv_list);152}153EXPORT_SYMBOL(fcoe_ctlr_init);154 155/**156 * fcoe_sysfs_fcf_add() - Add a fcoe_fcf{,_device} to a fcoe_ctlr{,_device}157 * @new: The newly discovered FCF158 *159 * Called with fip->ctlr_mutex held160 */161static int fcoe_sysfs_fcf_add(struct fcoe_fcf *new)162{163 struct fcoe_ctlr *fip = new->fip;164 struct fcoe_ctlr_device *ctlr_dev;165 struct fcoe_fcf_device *temp, *fcf_dev;166 int rc = -ENOMEM;167 168 LIBFCOE_FIP_DBG(fip, "New FCF fab %16.16llx mac %pM\n",169 new->fabric_name, new->fcf_mac);170 171 temp = kzalloc(sizeof(*temp), GFP_KERNEL);172 if (!temp)173 goto out;174 175 temp->fabric_name = new->fabric_name;176 temp->switch_name = new->switch_name;177 temp->fc_map = new->fc_map;178 temp->vfid = new->vfid;179 memcpy(temp->mac, new->fcf_mac, ETH_ALEN);180 temp->priority = new->pri;181 temp->fka_period = new->fka_period;182 temp->selected = 0; /* default to unselected */183 184 /*185 * If ctlr_dev doesn't exist then it means we're a libfcoe user186 * who doesn't use fcoe_syfs and didn't allocate a fcoe_ctlr_device.187 * fnic would be an example of a driver with this behavior. In this188 * case we want to add the fcoe_fcf to the fcoe_ctlr list, but we189 * don't want to make sysfs changes.190 */191 192 ctlr_dev = fcoe_ctlr_to_ctlr_dev(fip);193 if (ctlr_dev) {194 mutex_lock(&ctlr_dev->lock);195 fcf_dev = fcoe_fcf_device_add(ctlr_dev, temp);196 if (unlikely(!fcf_dev)) {197 rc = -ENOMEM;198 mutex_unlock(&ctlr_dev->lock);199 goto out;200 }201 202 /*203 * The fcoe_sysfs layer can return a CONNECTED fcf that204 * has a priv (fcf was never deleted) or a CONNECTED fcf205 * that doesn't have a priv (fcf was deleted). However,206 * libfcoe will always delete FCFs before trying to add207 * them. This is ensured because both recv_adv and208 * age_fcfs are protected by the the fcoe_ctlr's mutex.209 * This means that we should never get a FCF with a210 * non-NULL priv pointer.211 */212 BUG_ON(fcf_dev->priv);213 214 fcf_dev->priv = new;215 new->fcf_dev = fcf_dev;216 mutex_unlock(&ctlr_dev->lock);217 }218 219 list_add(&new->list, &fip->fcfs);220 fip->fcf_count++;221 rc = 0;222 223out:224 kfree(temp);225 return rc;226}227 228/**229 * fcoe_sysfs_fcf_del() - Remove a fcoe_fcf{,_device} to a fcoe_ctlr{,_device}230 * @new: The FCF to be removed231 *232 * Called with fip->ctlr_mutex held233 */234static void fcoe_sysfs_fcf_del(struct fcoe_fcf *new)235{236 struct fcoe_ctlr *fip = new->fip;237 struct fcoe_ctlr_device *cdev;238 struct fcoe_fcf_device *fcf_dev;239 240 list_del(&new->list);241 fip->fcf_count--;242 243 /*244 * If ctlr_dev doesn't exist then it means we're a libfcoe user245 * who doesn't use fcoe_syfs and didn't allocate a fcoe_ctlr_device246 * or a fcoe_fcf_device.247 *248 * fnic would be an example of a driver with this behavior. In this249 * case we want to remove the fcoe_fcf from the fcoe_ctlr list (above),250 * but we don't want to make sysfs changes.251 */252 cdev = fcoe_ctlr_to_ctlr_dev(fip);253 if (cdev) {254 mutex_lock(&cdev->lock);255 fcf_dev = fcoe_fcf_to_fcf_dev(new);256 WARN_ON(!fcf_dev);257 new->fcf_dev = NULL;258 fcoe_fcf_device_delete(fcf_dev);259 mutex_unlock(&cdev->lock);260 }261 kfree(new);262}263 264/**265 * fcoe_ctlr_reset_fcfs() - Reset and free all FCFs for a controller266 * @fip: The FCoE controller whose FCFs are to be reset267 *268 * Called with &fcoe_ctlr lock held.269 */270static void fcoe_ctlr_reset_fcfs(struct fcoe_ctlr *fip)271{272 struct fcoe_fcf *fcf;273 struct fcoe_fcf *next;274 275 fip->sel_fcf = NULL;276 list_for_each_entry_safe(fcf, next, &fip->fcfs, list) {277 fcoe_sysfs_fcf_del(fcf);278 }279 WARN_ON(fip->fcf_count);280 281 fip->sel_time = 0;282}283 284/**285 * fcoe_ctlr_destroy() - Disable and tear down a FCoE controller286 * @fip: The FCoE controller to tear down287 *288 * This is called by FCoE drivers before freeing the &fcoe_ctlr.289 *290 * The receive handler will have been deleted before this to guarantee291 * that no more recv_work will be scheduled.292 *293 * The timer routine will simply return once we set FIP_ST_DISABLED.294 * This guarantees that no further timeouts or work will be scheduled.295 */296void fcoe_ctlr_destroy(struct fcoe_ctlr *fip)297{298 cancel_work_sync(&fip->recv_work);299 skb_queue_purge(&fip->fip_recv_list);300 301 mutex_lock(&fip->ctlr_mutex);302 fcoe_ctlr_set_state(fip, FIP_ST_DISABLED);303 fcoe_ctlr_reset_fcfs(fip);304 mutex_unlock(&fip->ctlr_mutex);305 del_timer_sync(&fip->timer);306 cancel_work_sync(&fip->timer_work);307}308EXPORT_SYMBOL(fcoe_ctlr_destroy);309 310/**311 * fcoe_ctlr_announce() - announce new FCF selection312 * @fip: The FCoE controller313 *314 * Also sets the destination MAC for FCoE and control packets315 *316 * Called with neither ctlr_mutex nor ctlr_lock held.317 */318static void fcoe_ctlr_announce(struct fcoe_ctlr *fip)319{320 struct fcoe_fcf *sel;321 struct fcoe_fcf *fcf;322 323 mutex_lock(&fip->ctlr_mutex);324 spin_lock_bh(&fip->ctlr_lock);325 326 kfree_skb(fip->flogi_req);327 fip->flogi_req = NULL;328 list_for_each_entry(fcf, &fip->fcfs, list)329 fcf->flogi_sent = 0;330 331 spin_unlock_bh(&fip->ctlr_lock);332 sel = fip->sel_fcf;333 334 if (sel && ether_addr_equal(sel->fcf_mac, fip->dest_addr))335 goto unlock;336 if (!is_zero_ether_addr(fip->dest_addr)) {337 printk(KERN_NOTICE "libfcoe: host%d: "338 "FIP Fibre-Channel Forwarder MAC %pM deselected\n",339 fip->lp->host->host_no, fip->dest_addr);340 eth_zero_addr(fip->dest_addr);341 }342 if (sel) {343 printk(KERN_INFO "libfcoe: host%d: FIP selected "344 "Fibre-Channel Forwarder MAC %pM\n",345 fip->lp->host->host_no, sel->fcf_mac);346 memcpy(fip->dest_addr, sel->fcoe_mac, ETH_ALEN);347 fip->map_dest = 0;348 }349unlock:350 mutex_unlock(&fip->ctlr_mutex);351}352 353/**354 * fcoe_ctlr_fcoe_size() - Return the maximum FCoE size required for VN_Port355 * @fip: The FCoE controller to get the maximum FCoE size from356 *357 * Returns the maximum packet size including the FCoE header and trailer,358 * but not including any Ethernet or VLAN headers.359 */360static inline u32 fcoe_ctlr_fcoe_size(struct fcoe_ctlr *fip)361{362 /*363 * Determine the max FCoE frame size allowed, including364 * FCoE header and trailer.365 * Note: lp->mfs is currently the payload size, not the frame size.366 */367 return fip->lp->mfs + sizeof(struct fc_frame_header) +368 sizeof(struct fcoe_hdr) + sizeof(struct fcoe_crc_eof);369}370 371/**372 * fcoe_ctlr_solicit() - Send a FIP solicitation373 * @fip: The FCoE controller to send the solicitation on374 * @fcf: The destination FCF (if NULL, a multicast solicitation is sent)375 */376static void fcoe_ctlr_solicit(struct fcoe_ctlr *fip, struct fcoe_fcf *fcf)377{378 struct sk_buff *skb;379 struct fip_sol {380 struct ethhdr eth;381 struct fip_header fip;382 struct {383 struct fip_mac_desc mac;384 struct fip_wwn_desc wwnn;385 struct fip_size_desc size;386 } __packed desc;387 } __packed * sol;388 u32 fcoe_size;389 390 skb = dev_alloc_skb(sizeof(*sol));391 if (!skb)392 return;393 394 sol = (struct fip_sol *)skb->data;395 396 memset(sol, 0, sizeof(*sol));397 memcpy(sol->eth.h_dest, fcf ? fcf->fcf_mac : fcoe_all_fcfs, ETH_ALEN);398 memcpy(sol->eth.h_source, fip->ctl_src_addr, ETH_ALEN);399 sol->eth.h_proto = htons(ETH_P_FIP);400 401 sol->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);402 sol->fip.fip_op = htons(FIP_OP_DISC);403 sol->fip.fip_subcode = FIP_SC_SOL;404 sol->fip.fip_dl_len = htons(sizeof(sol->desc) / FIP_BPW);405 sol->fip.fip_flags = htons(FIP_FL_FPMA);406 if (fip->spma)407 sol->fip.fip_flags |= htons(FIP_FL_SPMA);408 409 sol->desc.mac.fd_desc.fip_dtype = FIP_DT_MAC;410 sol->desc.mac.fd_desc.fip_dlen = sizeof(sol->desc.mac) / FIP_BPW;411 memcpy(sol->desc.mac.fd_mac, fip->ctl_src_addr, ETH_ALEN);412 413 sol->desc.wwnn.fd_desc.fip_dtype = FIP_DT_NAME;414 sol->desc.wwnn.fd_desc.fip_dlen = sizeof(sol->desc.wwnn) / FIP_BPW;415 put_unaligned_be64(fip->lp->wwnn, &sol->desc.wwnn.fd_wwn);416 417 fcoe_size = fcoe_ctlr_fcoe_size(fip);418 sol->desc.size.fd_desc.fip_dtype = FIP_DT_FCOE_SIZE;419 sol->desc.size.fd_desc.fip_dlen = sizeof(sol->desc.size) / FIP_BPW;420 sol->desc.size.fd_size = htons(fcoe_size);421 422 skb_put(skb, sizeof(*sol));423 skb->protocol = htons(ETH_P_FIP);424 skb->priority = fip->priority;425 skb_reset_mac_header(skb);426 skb_reset_network_header(skb);427 fip->send(fip, skb);428 429 if (!fcf)430 fip->sol_time = jiffies;431}432 433/**434 * fcoe_ctlr_link_up() - Start FCoE controller435 * @fip: The FCoE controller to start436 *437 * Called from the LLD when the network link is ready.438 */439void fcoe_ctlr_link_up(struct fcoe_ctlr *fip)440{441 mutex_lock(&fip->ctlr_mutex);442 if (fip->state == FIP_ST_NON_FIP || fip->state == FIP_ST_AUTO) {443 mutex_unlock(&fip->ctlr_mutex);444 fc_linkup(fip->lp);445 } else if (fip->state == FIP_ST_LINK_WAIT) {446 if (fip->mode == FIP_MODE_NON_FIP)447 fcoe_ctlr_set_state(fip, FIP_ST_NON_FIP);448 else449 fcoe_ctlr_set_state(fip, FIP_ST_AUTO);450 switch (fip->mode) {451 default:452 LIBFCOE_FIP_DBG(fip, "invalid mode %d\n", fip->mode);453 fallthrough;454 case FIP_MODE_AUTO:455 LIBFCOE_FIP_DBG(fip, "%s", "setting AUTO mode.\n");456 fallthrough;457 case FIP_MODE_FABRIC:458 case FIP_MODE_NON_FIP:459 mutex_unlock(&fip->ctlr_mutex);460 fc_linkup(fip->lp);461 fcoe_ctlr_solicit(fip, NULL);462 break;463 case FIP_MODE_VN2VN:464 fcoe_ctlr_vn_start(fip);465 mutex_unlock(&fip->ctlr_mutex);466 fc_linkup(fip->lp);467 break;468 }469 } else470 mutex_unlock(&fip->ctlr_mutex);471}472EXPORT_SYMBOL(fcoe_ctlr_link_up);473 474/**475 * fcoe_ctlr_reset() - Reset a FCoE controller476 * @fip: The FCoE controller to reset477 */478static void fcoe_ctlr_reset(struct fcoe_ctlr *fip)479{480 fcoe_ctlr_reset_fcfs(fip);481 del_timer(&fip->timer);482 fip->ctlr_ka_time = 0;483 fip->port_ka_time = 0;484 fip->sol_time = 0;485 fip->flogi_oxid = FC_XID_UNKNOWN;486 fcoe_ctlr_map_dest(fip);487}488 489/**490 * fcoe_ctlr_link_down() - Stop a FCoE controller491 * @fip: The FCoE controller to be stopped492 *493 * Returns non-zero if the link was up and now isn't.494 *495 * Called from the LLD when the network link is not ready.496 * There may be multiple calls while the link is down.497 */498int fcoe_ctlr_link_down(struct fcoe_ctlr *fip)499{500 int link_dropped;501 502 LIBFCOE_FIP_DBG(fip, "link down.\n");503 mutex_lock(&fip->ctlr_mutex);504 fcoe_ctlr_reset(fip);505 link_dropped = fip->state != FIP_ST_LINK_WAIT;506 fcoe_ctlr_set_state(fip, FIP_ST_LINK_WAIT);507 mutex_unlock(&fip->ctlr_mutex);508 509 if (link_dropped)510 fc_linkdown(fip->lp);511 return link_dropped;512}513EXPORT_SYMBOL(fcoe_ctlr_link_down);514 515/**516 * fcoe_ctlr_send_keep_alive() - Send a keep-alive to the selected FCF517 * @fip: The FCoE controller to send the FKA on518 * @lport: libfc fc_lport to send from519 * @ports: 0 for controller keep-alive, 1 for port keep-alive520 * @sa: The source MAC address521 *522 * A controller keep-alive is sent every fka_period (typically 8 seconds).523 * The source MAC is the native MAC address.524 *525 * A port keep-alive is sent every 90 seconds while logged in.526 * The source MAC is the assigned mapped source address.527 * The destination is the FCF's F-port.528 */529static void fcoe_ctlr_send_keep_alive(struct fcoe_ctlr *fip,530 struct fc_lport *lport,531 int ports, u8 *sa)532{533 struct sk_buff *skb;534 struct fip_kal {535 struct ethhdr eth;536 struct fip_header fip;537 struct fip_mac_desc mac;538 } __packed * kal;539 struct fip_vn_desc *vn;540 u32 len;541 struct fc_lport *lp;542 struct fcoe_fcf *fcf;543 544 fcf = fip->sel_fcf;545 lp = fip->lp;546 if (!fcf || (ports && !lp->port_id))547 return;548 549 len = sizeof(*kal) + ports * sizeof(*vn);550 skb = dev_alloc_skb(len);551 if (!skb)552 return;553 554 kal = (struct fip_kal *)skb->data;555 memset(kal, 0, len);556 memcpy(kal->eth.h_dest, fcf->fcf_mac, ETH_ALEN);557 memcpy(kal->eth.h_source, sa, ETH_ALEN);558 kal->eth.h_proto = htons(ETH_P_FIP);559 560 kal->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);561 kal->fip.fip_op = htons(FIP_OP_CTRL);562 kal->fip.fip_subcode = FIP_SC_KEEP_ALIVE;563 kal->fip.fip_dl_len = htons((sizeof(kal->mac) +564 ports * sizeof(*vn)) / FIP_BPW);565 kal->fip.fip_flags = htons(FIP_FL_FPMA);566 if (fip->spma)567 kal->fip.fip_flags |= htons(FIP_FL_SPMA);568 569 kal->mac.fd_desc.fip_dtype = FIP_DT_MAC;570 kal->mac.fd_desc.fip_dlen = sizeof(kal->mac) / FIP_BPW;571 memcpy(kal->mac.fd_mac, fip->ctl_src_addr, ETH_ALEN);572 if (ports) {573 vn = (struct fip_vn_desc *)(kal + 1);574 vn->fd_desc.fip_dtype = FIP_DT_VN_ID;575 vn->fd_desc.fip_dlen = sizeof(*vn) / FIP_BPW;576 memcpy(vn->fd_mac, fip->get_src_addr(lport), ETH_ALEN);577 hton24(vn->fd_fc_id, lport->port_id);578 put_unaligned_be64(lport->wwpn, &vn->fd_wwpn);579 }580 skb_put(skb, len);581 skb->protocol = htons(ETH_P_FIP);582 skb->priority = fip->priority;583 skb_reset_mac_header(skb);584 skb_reset_network_header(skb);585 fip->send(fip, skb);586}587 588/**589 * fcoe_ctlr_encaps() - Encapsulate an ELS frame for FIP, without sending it590 * @fip: The FCoE controller for the ELS frame591 * @lport: The local port592 * @dtype: The FIP descriptor type for the frame593 * @skb: The FCoE ELS frame including FC header but no FCoE headers594 * @d_id: The destination port ID.595 *596 * Returns non-zero error code on failure.597 *598 * The caller must check that the length is a multiple of 4.599 *600 * The @skb must have enough headroom (28 bytes) and tailroom (8 bytes).601 * Headroom includes the FIP encapsulation description, FIP header, and602 * Ethernet header. The tailroom is for the FIP MAC descriptor.603 */604static int fcoe_ctlr_encaps(struct fcoe_ctlr *fip, struct fc_lport *lport,605 u8 dtype, struct sk_buff *skb, u32 d_id)606{607 struct fip_encaps_head {608 struct ethhdr eth;609 struct fip_header fip;610 struct fip_encaps encaps;611 } __packed * cap;612 struct fc_frame_header *fh;613 struct fip_mac_desc *mac;614 struct fcoe_fcf *fcf;615 size_t dlen;616 u16 fip_flags;617 u8 op;618 619 fh = (struct fc_frame_header *)skb->data;620 op = *(u8 *)(fh + 1);621 dlen = sizeof(struct fip_encaps) + skb->len; /* len before push */622 cap = skb_push(skb, sizeof(*cap));623 memset(cap, 0, sizeof(*cap));624 625 if (lport->point_to_multipoint) {626 if (fcoe_ctlr_vn_lookup(fip, d_id, cap->eth.h_dest))627 return -ENODEV;628 fip_flags = 0;629 } else {630 fcf = fip->sel_fcf;631 if (!fcf)632 return -ENODEV;633 fip_flags = fcf->flags;634 fip_flags &= fip->spma ? FIP_FL_SPMA | FIP_FL_FPMA :635 FIP_FL_FPMA;636 if (!fip_flags)637 return -ENODEV;638 memcpy(cap->eth.h_dest, fcf->fcf_mac, ETH_ALEN);639 }640 memcpy(cap->eth.h_source, fip->ctl_src_addr, ETH_ALEN);641 cap->eth.h_proto = htons(ETH_P_FIP);642 643 cap->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);644 cap->fip.fip_op = htons(FIP_OP_LS);645 if (op == ELS_LS_ACC || op == ELS_LS_RJT)646 cap->fip.fip_subcode = FIP_SC_REP;647 else648 cap->fip.fip_subcode = FIP_SC_REQ;649 cap->fip.fip_flags = htons(fip_flags);650 651 cap->encaps.fd_desc.fip_dtype = dtype;652 cap->encaps.fd_desc.fip_dlen = dlen / FIP_BPW;653 654 if (op != ELS_LS_RJT) {655 dlen += sizeof(*mac);656 mac = skb_put_zero(skb, sizeof(*mac));657 mac->fd_desc.fip_dtype = FIP_DT_MAC;658 mac->fd_desc.fip_dlen = sizeof(*mac) / FIP_BPW;659 if (dtype != FIP_DT_FLOGI && dtype != FIP_DT_FDISC) {660 memcpy(mac->fd_mac, fip->get_src_addr(lport), ETH_ALEN);661 } else if (fip->mode == FIP_MODE_VN2VN) {662 hton24(mac->fd_mac, FIP_VN_FC_MAP);663 hton24(mac->fd_mac + 3, fip->port_id);664 } else if (fip_flags & FIP_FL_SPMA) {665 LIBFCOE_FIP_DBG(fip, "FLOGI/FDISC sent with SPMA\n");666 memcpy(mac->fd_mac, fip->ctl_src_addr, ETH_ALEN);667 } else {668 LIBFCOE_FIP_DBG(fip, "FLOGI/FDISC sent with FPMA\n");669 /* FPMA only FLOGI. Must leave the MAC desc zeroed. */670 }671 }672 cap->fip.fip_dl_len = htons(dlen / FIP_BPW);673 674 skb->protocol = htons(ETH_P_FIP);675 skb->priority = fip->priority;676 skb_reset_mac_header(skb);677 skb_reset_network_header(skb);678 return 0;679}680 681/**682 * fcoe_ctlr_els_send() - Send an ELS frame encapsulated by FIP if appropriate.683 * @fip: FCoE controller.684 * @lport: libfc fc_lport to send from685 * @skb: FCoE ELS frame including FC header but no FCoE headers.686 *687 * Returns a non-zero error code if the frame should not be sent.688 * Returns zero if the caller should send the frame with FCoE encapsulation.689 *690 * The caller must check that the length is a multiple of 4.691 * The SKB must have enough headroom (28 bytes) and tailroom (8 bytes).692 * The the skb must also be an fc_frame.693 *694 * This is called from the lower-level driver with spinlocks held,695 * so we must not take a mutex here.696 */697int fcoe_ctlr_els_send(struct fcoe_ctlr *fip, struct fc_lport *lport,698 struct sk_buff *skb)699{700 struct fc_frame *fp;701 struct fc_frame_header *fh;702 u16 old_xid;703 u8 op;704 u8 mac[ETH_ALEN];705 706 fp = container_of(skb, struct fc_frame, skb);707 fh = (struct fc_frame_header *)skb->data;708 op = *(u8 *)(fh + 1);709 710 if (op == ELS_FLOGI && fip->mode != FIP_MODE_VN2VN) {711 old_xid = fip->flogi_oxid;712 fip->flogi_oxid = ntohs(fh->fh_ox_id);713 if (fip->state == FIP_ST_AUTO) {714 if (old_xid == FC_XID_UNKNOWN)715 fip->flogi_count = 0;716 fip->flogi_count++;717 if (fip->flogi_count < 3)718 goto drop;719 fcoe_ctlr_map_dest(fip);720 return 0;721 }722 if (fip->state == FIP_ST_NON_FIP)723 fcoe_ctlr_map_dest(fip);724 }725 726 if (fip->state == FIP_ST_NON_FIP)727 return 0;728 if (!fip->sel_fcf && fip->mode != FIP_MODE_VN2VN)729 goto drop;730 switch (op) {731 case ELS_FLOGI:732 op = FIP_DT_FLOGI;733 if (fip->mode == FIP_MODE_VN2VN)734 break;735 spin_lock_bh(&fip->ctlr_lock);736 kfree_skb(fip->flogi_req);737 fip->flogi_req = skb;738 fip->flogi_req_send = 1;739 spin_unlock_bh(&fip->ctlr_lock);740 schedule_work(&fip->timer_work);741 return -EINPROGRESS;742 case ELS_FDISC:743 if (ntoh24(fh->fh_s_id))744 return 0;745 op = FIP_DT_FDISC;746 break;747 case ELS_LOGO:748 if (fip->mode == FIP_MODE_VN2VN) {749 if (fip->state != FIP_ST_VNMP_UP)750 goto drop;751 if (ntoh24(fh->fh_d_id) == FC_FID_FLOGI)752 goto drop;753 } else {754 if (fip->state != FIP_ST_ENABLED)755 return 0;756 if (ntoh24(fh->fh_d_id) != FC_FID_FLOGI)757 return 0;758 }759 op = FIP_DT_LOGO;760 break;761 case ELS_LS_ACC:762 /*763 * If non-FIP, we may have gotten an SID by accepting an FLOGI764 * from a point-to-point connection. Switch to using765 * the source mac based on the SID. The destination766 * MAC in this case would have been set by receiving the767 * FLOGI.768 */769 if (fip->state == FIP_ST_NON_FIP) {770 if (fip->flogi_oxid == FC_XID_UNKNOWN)771 return 0;772 fip->flogi_oxid = FC_XID_UNKNOWN;773 fc_fcoe_set_mac(mac, fh->fh_d_id);774 fip->update_mac(lport, mac);775 }776 fallthrough;777 case ELS_LS_RJT:778 op = fr_encaps(fp);779 if (op)780 break;781 return 0;782 default:783 if (fip->state != FIP_ST_ENABLED &&784 fip->state != FIP_ST_VNMP_UP)785 goto drop;786 return 0;787 }788 LIBFCOE_FIP_DBG(fip, "els_send op %u d_id %x\n",789 op, ntoh24(fh->fh_d_id));790 if (fcoe_ctlr_encaps(fip, lport, op, skb, ntoh24(fh->fh_d_id)))791 goto drop;792 fip->send(fip, skb);793 return -EINPROGRESS;794drop:795 LIBFCOE_FIP_DBG(fip, "drop els_send op %u d_id %x\n",796 op, ntoh24(fh->fh_d_id));797 kfree_skb(skb);798 return -EINVAL;799}800EXPORT_SYMBOL(fcoe_ctlr_els_send);801 802/**803 * fcoe_ctlr_age_fcfs() - Reset and free all old FCFs for a controller804 * @fip: The FCoE controller to free FCFs on805 *806 * Called with lock held and preemption disabled.807 *808 * An FCF is considered old if we have missed two advertisements.809 * That is, there have been no valid advertisement from it for 2.5810 * times its keep-alive period.811 *812 * In addition, determine the time when an FCF selection can occur.813 *814 * Also, increment the MissDiscAdvCount when no advertisement is received815 * for the corresponding FCF for 1.5 * FKA_ADV_PERIOD (FC-BB-5 LESB).816 *817 * Returns the time in jiffies for the next call.818 */819static unsigned long fcoe_ctlr_age_fcfs(struct fcoe_ctlr *fip)820{821 struct fcoe_fcf *fcf;822 struct fcoe_fcf *next;823 unsigned long next_timer = jiffies + msecs_to_jiffies(FIP_VN_KA_PERIOD);824 unsigned long deadline;825 unsigned long sel_time = 0;826 struct list_head del_list;827 828 INIT_LIST_HEAD(&del_list);829 830 list_for_each_entry_safe(fcf, next, &fip->fcfs, list) {831 deadline = fcf->time + fcf->fka_period + fcf->fka_period / 2;832 if (fip->sel_fcf == fcf) {833 if (time_after(jiffies, deadline)) {834 u64 miss_cnt;835 836 miss_cnt = this_cpu_inc_return(fip->lp->stats->MissDiscAdvCount);837 printk(KERN_INFO "libfcoe: host%d: "838 "Missing Discovery Advertisement "839 "for fab %16.16llx count %lld\n",840 fip->lp->host->host_no, fcf->fabric_name,841 miss_cnt);842 } else if (time_after(next_timer, deadline))843 next_timer = deadline;844 }845 846 deadline += fcf->fka_period;847 if (time_after_eq(jiffies, deadline)) {848 if (fip->sel_fcf == fcf)849 fip->sel_fcf = NULL;850 /*851 * Move to delete list so we can call852 * fcoe_sysfs_fcf_del (which can sleep)853 * after the put_cpu().854 */855 list_del(&fcf->list);856 list_add(&fcf->list, &del_list);857 this_cpu_inc(fip->lp->stats->VLinkFailureCount);858 } else {859 if (time_after(next_timer, deadline))860 next_timer = deadline;861 if (fcoe_ctlr_mtu_valid(fcf) &&862 (!sel_time || time_before(sel_time, fcf->time)))863 sel_time = fcf->time;864 }865 }866 867 list_for_each_entry_safe(fcf, next, &del_list, list) {868 /* Removes fcf from current list */869 fcoe_sysfs_fcf_del(fcf);870 }871 872 if (sel_time && !fip->sel_fcf && !fip->sel_time) {873 sel_time += msecs_to_jiffies(FCOE_CTLR_START_DELAY);874 fip->sel_time = sel_time;875 }876 877 return next_timer;878}879 880/**881 * fcoe_ctlr_parse_adv() - Decode a FIP advertisement into a new FCF entry882 * @fip: The FCoE controller receiving the advertisement883 * @skb: The received FIP advertisement frame884 * @fcf: The resulting FCF entry885 *886 * Returns zero on a valid parsed advertisement,887 * otherwise returns non zero value.888 */889static int fcoe_ctlr_parse_adv(struct fcoe_ctlr *fip,890 struct sk_buff *skb, struct fcoe_fcf *fcf)891{892 struct fip_header *fiph;893 struct fip_desc *desc = NULL;894 struct fip_wwn_desc *wwn;895 struct fip_fab_desc *fab;896 struct fip_fka_desc *fka;897 unsigned long t;898 size_t rlen;899 size_t dlen;900 u32 desc_mask;901 902 memset(fcf, 0, sizeof(*fcf));903 fcf->fka_period = msecs_to_jiffies(FCOE_CTLR_DEF_FKA);904 905 fiph = (struct fip_header *)skb->data;906 fcf->flags = ntohs(fiph->fip_flags);907 908 /*909 * mask of required descriptors. validating each one clears its bit.910 */911 desc_mask = BIT(FIP_DT_PRI) | BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME) |912 BIT(FIP_DT_FAB) | BIT(FIP_DT_FKA);913 914 rlen = ntohs(fiph->fip_dl_len) * 4;915 if (rlen + sizeof(*fiph) > skb->len)916 return -EINVAL;917 918 desc = (struct fip_desc *)(fiph + 1);919 while (rlen > 0) {920 dlen = desc->fip_dlen * FIP_BPW;921 if (dlen < sizeof(*desc) || dlen > rlen)922 return -EINVAL;923 /* Drop Adv if there are duplicate critical descriptors */924 if ((desc->fip_dtype < 32) &&925 !(desc_mask & 1U << desc->fip_dtype)) {926 LIBFCOE_FIP_DBG(fip, "Duplicate Critical "927 "Descriptors in FIP adv\n");928 return -EINVAL;929 }930 switch (desc->fip_dtype) {931 case FIP_DT_PRI:932 if (dlen != sizeof(struct fip_pri_desc))933 goto len_err;934 fcf->pri = ((struct fip_pri_desc *)desc)->fd_pri;935 desc_mask &= ~BIT(FIP_DT_PRI);936 break;937 case FIP_DT_MAC:938 if (dlen != sizeof(struct fip_mac_desc))939 goto len_err;940 memcpy(fcf->fcf_mac,941 ((struct fip_mac_desc *)desc)->fd_mac,942 ETH_ALEN);943 memcpy(fcf->fcoe_mac, fcf->fcf_mac, ETH_ALEN);944 if (!is_valid_ether_addr(fcf->fcf_mac)) {945 LIBFCOE_FIP_DBG(fip,946 "Invalid MAC addr %pM in FIP adv\n",947 fcf->fcf_mac);948 return -EINVAL;949 }950 desc_mask &= ~BIT(FIP_DT_MAC);951 break;952 case FIP_DT_NAME:953 if (dlen != sizeof(struct fip_wwn_desc))954 goto len_err;955 wwn = (struct fip_wwn_desc *)desc;956 fcf->switch_name = get_unaligned_be64(&wwn->fd_wwn);957 desc_mask &= ~BIT(FIP_DT_NAME);958 break;959 case FIP_DT_FAB:960 if (dlen != sizeof(struct fip_fab_desc))961 goto len_err;962 fab = (struct fip_fab_desc *)desc;963 fcf->fabric_name = get_unaligned_be64(&fab->fd_wwn);964 fcf->vfid = ntohs(fab->fd_vfid);965 fcf->fc_map = ntoh24(fab->fd_map);966 desc_mask &= ~BIT(FIP_DT_FAB);967 break;968 case FIP_DT_FKA:969 if (dlen != sizeof(struct fip_fka_desc))970 goto len_err;971 fka = (struct fip_fka_desc *)desc;972 if (fka->fd_flags & FIP_FKA_ADV_D)973 fcf->fd_flags = 1;974 t = ntohl(fka->fd_fka_period);975 if (t >= FCOE_CTLR_MIN_FKA)976 fcf->fka_period = msecs_to_jiffies(t);977 desc_mask &= ~BIT(FIP_DT_FKA);978 break;979 case FIP_DT_MAP_OUI:980 case FIP_DT_FCOE_SIZE:981 case FIP_DT_FLOGI:982 case FIP_DT_FDISC:983 case FIP_DT_LOGO:984 case FIP_DT_ELP:985 default:986 LIBFCOE_FIP_DBG(fip, "unexpected descriptor type %x "987 "in FIP adv\n", desc->fip_dtype);988 /* standard says ignore unknown descriptors >= 128 */989 if (desc->fip_dtype < FIP_DT_NON_CRITICAL)990 return -EINVAL;991 break;992 }993 desc = (struct fip_desc *)((char *)desc + dlen);994 rlen -= dlen;995 }996 if (!fcf->fc_map || (fcf->fc_map & 0x10000))997 return -EINVAL;998 if (!fcf->switch_name)999 return -EINVAL;1000 if (desc_mask) {1001 LIBFCOE_FIP_DBG(fip, "adv missing descriptors mask %x\n",1002 desc_mask);1003 return -EINVAL;1004 }1005 return 0;1006 1007len_err:1008 LIBFCOE_FIP_DBG(fip, "FIP length error in descriptor type %x len %zu\n",1009 desc->fip_dtype, dlen);1010 return -EINVAL;1011}1012 1013/**1014 * fcoe_ctlr_recv_adv() - Handle an incoming advertisement1015 * @fip: The FCoE controller receiving the advertisement1016 * @skb: The received FIP packet1017 */1018static void fcoe_ctlr_recv_adv(struct fcoe_ctlr *fip, struct sk_buff *skb)1019{1020 struct fcoe_fcf *fcf;1021 struct fcoe_fcf new;1022 unsigned long sol_tov = msecs_to_jiffies(FCOE_CTLR_SOL_TOV);1023 int first = 0;1024 int mtu_valid;1025 int found = 0;1026 int rc = 0;1027 1028 if (fcoe_ctlr_parse_adv(fip, skb, &new))1029 return;1030 1031 mutex_lock(&fip->ctlr_mutex);1032 first = list_empty(&fip->fcfs);1033 list_for_each_entry(fcf, &fip->fcfs, list) {1034 if (fcf->switch_name == new.switch_name &&1035 fcf->fabric_name == new.fabric_name &&1036 fcf->fc_map == new.fc_map &&1037 ether_addr_equal(fcf->fcf_mac, new.fcf_mac)) {1038 found = 1;1039 break;1040 }1041 }1042 if (!found) {1043 if (fip->fcf_count >= FCOE_CTLR_FCF_LIMIT)1044 goto out;1045 1046 fcf = kmalloc(sizeof(*fcf), GFP_ATOMIC);1047 if (!fcf)1048 goto out;1049 1050 memcpy(fcf, &new, sizeof(new));1051 fcf->fip = fip;1052 rc = fcoe_sysfs_fcf_add(fcf);1053 if (rc) {1054 printk(KERN_ERR "Failed to allocate sysfs instance "1055 "for FCF, fab %16.16llx mac %pM\n",1056 new.fabric_name, new.fcf_mac);1057 kfree(fcf);1058 goto out;1059 }1060 } else {1061 /*1062 * Update the FCF's keep-alive descriptor flags.1063 * Other flag changes from new advertisements are1064 * ignored after a solicited advertisement is1065 * received and the FCF is selectable (usable).1066 */1067 fcf->fd_flags = new.fd_flags;1068 if (!fcoe_ctlr_fcf_usable(fcf))1069 fcf->flags = new.flags;1070 1071 if (fcf == fip->sel_fcf && !fcf->fd_flags) {1072 fip->ctlr_ka_time -= fcf->fka_period;1073 fip->ctlr_ka_time += new.fka_period;1074 if (time_before(fip->ctlr_ka_time, fip->timer.expires))1075 mod_timer(&fip->timer, fip->ctlr_ka_time);1076 }1077 fcf->fka_period = new.fka_period;1078 memcpy(fcf->fcf_mac, new.fcf_mac, ETH_ALEN);1079 }1080 1081 mtu_valid = fcoe_ctlr_mtu_valid(fcf);1082 fcf->time = jiffies;1083 if (!found)1084 LIBFCOE_FIP_DBG(fip, "New FCF fab %16.16llx mac %pM\n",1085 fcf->fabric_name, fcf->fcf_mac);1086 1087 /*1088 * If this advertisement is not solicited and our max receive size1089 * hasn't been verified, send a solicited advertisement.1090 */1091 if (!mtu_valid)1092 fcoe_ctlr_solicit(fip, fcf);1093 1094 /*1095 * If its been a while since we did a solicit, and this is1096 * the first advertisement we've received, do a multicast1097 * solicitation to gather as many advertisements as we can1098 * before selection occurs.1099 */1100 if (first && time_after(jiffies, fip->sol_time + sol_tov))1101 fcoe_ctlr_solicit(fip, NULL);1102 1103 /*1104 * Put this FCF at the head of the list for priority among equals.1105 * This helps in the case of an NPV switch which insists we use1106 * the FCF that answers multicast solicitations, not the others that1107 * are sending periodic multicast advertisements.1108 */1109 if (mtu_valid)1110 list_move(&fcf->list, &fip->fcfs);1111 1112 /*1113 * If this is the first validated FCF, note the time and1114 * set a timer to trigger selection.1115 */1116 if (mtu_valid && !fip->sel_fcf && !fip->sel_time &&1117 fcoe_ctlr_fcf_usable(fcf)) {1118 fip->sel_time = jiffies +1119 msecs_to_jiffies(FCOE_CTLR_START_DELAY);1120 if (!timer_pending(&fip->timer) ||1121 time_before(fip->sel_time, fip->timer.expires))1122 mod_timer(&fip->timer, fip->sel_time);1123 }1124 1125out:1126 mutex_unlock(&fip->ctlr_mutex);1127}1128 1129/**1130 * fcoe_ctlr_recv_els() - Handle an incoming FIP encapsulated ELS frame1131 * @fip: The FCoE controller which received the packet1132 * @skb: The received FIP packet1133 */1134static void fcoe_ctlr_recv_els(struct fcoe_ctlr *fip, struct sk_buff *skb)1135{1136 struct fc_lport *lport = fip->lp;1137 struct fip_header *fiph;1138 struct fc_frame *fp = (struct fc_frame *)skb;1139 struct fc_frame_header *fh = NULL;1140 struct fip_desc *desc;1141 struct fip_encaps *els;1142 struct fcoe_fcf *sel;1143 enum fip_desc_type els_dtype = 0;1144 u8 els_op;1145 u8 sub;1146 u8 granted_mac[ETH_ALEN] = { 0 };1147 size_t els_len = 0;1148 size_t rlen;1149 size_t dlen;1150 u32 desc_mask = 0;1151 u32 desc_cnt = 0;1152 1153 fiph = (struct fip_header *)skb->data;1154 sub = fiph->fip_subcode;1155 if (sub != FIP_SC_REQ && sub != FIP_SC_REP)1156 goto drop;1157 1158 rlen = ntohs(fiph->fip_dl_len) * 4;1159 if (rlen + sizeof(*fiph) > skb->len)1160 goto drop;1161 1162 desc = (struct fip_desc *)(fiph + 1);1163 while (rlen > 0) {1164 desc_cnt++;1165 dlen = desc->fip_dlen * FIP_BPW;1166 if (dlen < sizeof(*desc) || dlen > rlen)1167 goto drop;1168 /* Drop ELS if there are duplicate critical descriptors */1169 if (desc->fip_dtype < 32) {1170 if ((desc->fip_dtype != FIP_DT_MAC) &&1171 (desc_mask & 1U << desc->fip_dtype)) {1172 LIBFCOE_FIP_DBG(fip, "Duplicate Critical "1173 "Descriptors in FIP ELS\n");1174 goto drop;1175 }1176 desc_mask |= (1 << desc->fip_dtype);1177 }1178 switch (desc->fip_dtype) {1179 case FIP_DT_MAC:1180 sel = fip->sel_fcf;1181 if (desc_cnt == 1) {1182 LIBFCOE_FIP_DBG(fip, "FIP descriptors "1183 "received out of order\n");1184 goto drop;1185 }1186 /*1187 * Some switch implementations send two MAC descriptors,1188 * with first MAC(granted_mac) being the FPMA, and the1189 * second one(fcoe_mac) is used as destination address1190 * for sending/receiving FCoE packets. FIP traffic is1191 * sent using fip_mac. For regular switches, both1192 * fip_mac and fcoe_mac would be the same.1193 */1194 if (desc_cnt == 2)1195 memcpy(granted_mac,1196 ((struct fip_mac_desc *)desc)->fd_mac,1197 ETH_ALEN);1198 1199 if (dlen != sizeof(struct fip_mac_desc))1200 goto len_err;1201 1202 if ((desc_cnt == 3) && (sel))1203 memcpy(sel->fcoe_mac,1204 ((struct fip_mac_desc *)desc)->fd_mac,1205 ETH_ALEN);1206 break;1207 case FIP_DT_FLOGI:1208 case FIP_DT_FDISC:1209 case FIP_DT_LOGO:1210 case FIP_DT_ELP:1211 if (desc_cnt != 1) {1212 LIBFCOE_FIP_DBG(fip, "FIP descriptors "1213 "received out of order\n");1214 goto drop;1215 }1216 if (fh)1217 goto drop;1218 if (dlen < sizeof(*els) + sizeof(*fh) + 1)1219 goto len_err;1220 els_len = dlen - sizeof(*els);1221 els = (struct fip_encaps *)desc;1222 fh = (struct fc_frame_header *)(els + 1);1223 els_dtype = desc->fip_dtype;1224 break;1225 default:1226 LIBFCOE_FIP_DBG(fip, "unexpected descriptor type %x "1227 "in FIP adv\n", desc->fip_dtype);1228 /* standard says ignore unknown descriptors >= 128 */1229 if (desc->fip_dtype < FIP_DT_NON_CRITICAL)1230 goto drop;1231 if (desc_cnt <= 2) {1232 LIBFCOE_FIP_DBG(fip, "FIP descriptors "1233 "received out of order\n");1234 goto drop;1235 }1236 break;1237 }1238 desc = (struct fip_desc *)((char *)desc + dlen);1239 rlen -= dlen;1240 }1241 1242 if (!fh)1243 goto drop;1244 els_op = *(u8 *)(fh + 1);1245 1246 if ((els_dtype == FIP_DT_FLOGI || els_dtype == FIP_DT_FDISC) &&1247 sub == FIP_SC_REP && fip->mode != FIP_MODE_VN2VN) {1248 if (els_op == ELS_LS_ACC) {1249 if (!is_valid_ether_addr(granted_mac)) {1250 LIBFCOE_FIP_DBG(fip,1251 "Invalid MAC address %pM in FIP ELS\n",1252 granted_mac);1253 goto drop;1254 }1255 memcpy(fr_cb(fp)->granted_mac, granted_mac, ETH_ALEN);1256 1257 if (fip->flogi_oxid == ntohs(fh->fh_ox_id)) {1258 fip->flogi_oxid = FC_XID_UNKNOWN;1259 if (els_dtype == FIP_DT_FLOGI)1260 fcoe_ctlr_announce(fip);1261 }1262 } else if (els_dtype == FIP_DT_FLOGI &&1263 !fcoe_ctlr_flogi_retry(fip))1264 goto drop; /* retrying FLOGI so drop reject */1265 }1266 1267 if ((desc_cnt == 0) || ((els_op != ELS_LS_RJT) &&1268 (!(1U << FIP_DT_MAC & desc_mask)))) {1269 LIBFCOE_FIP_DBG(fip, "Missing critical descriptors "1270 "in FIP ELS\n");1271 goto drop;1272 }1273 1274 /*1275 * Convert skb into an fc_frame containing only the ELS.1276 */1277 skb_pull(skb, (u8 *)fh - skb->data);1278 skb_trim(skb, els_len);1279 fp = (struct fc_frame *)skb;1280 fc_frame_init(fp);1281 fr_sof(fp) = FC_SOF_I3;1282 fr_eof(fp) = FC_EOF_T;1283 fr_dev(fp) = lport;1284 fr_encaps(fp) = els_dtype;1285 1286 this_cpu_inc(lport->stats->RxFrames);1287 this_cpu_add(lport->stats->RxWords, skb->len / FIP_BPW);1288 1289 fc_exch_recv(lport, fp);1290 return;1291 1292len_err:1293 LIBFCOE_FIP_DBG(fip, "FIP length error in descriptor type %x len %zu\n",1294 desc->fip_dtype, dlen);1295drop:1296 kfree_skb(skb);1297}1298 1299/**1300 * fcoe_ctlr_recv_clr_vlink() - Handle an incoming link reset frame1301 * @fip: The FCoE controller that received the frame1302 * @skb: The received FIP packet1303 *1304 * There may be multiple VN_Port descriptors.1305 * The overall length has already been checked.1306 */1307static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr *fip,1308 struct sk_buff *skb)1309{1310 struct fip_desc *desc;1311 struct fip_mac_desc *mp;1312 struct fip_wwn_desc *wp;1313 struct fip_vn_desc *vp;1314 size_t rlen;1315 size_t dlen;1316 struct fcoe_fcf *fcf = fip->sel_fcf;1317 struct fc_lport *lport = fip->lp;1318 struct fc_lport *vn_port = NULL;1319 u32 desc_mask;1320 int num_vlink_desc;1321 int reset_phys_port = 0;1322 struct fip_vn_desc **vlink_desc_arr = NULL;1323 struct fip_header *fh = (struct fip_header *)skb->data;1324 struct ethhdr *eh = eth_hdr(skb);1325 1326 LIBFCOE_FIP_DBG(fip, "Clear Virtual Link received\n");1327 1328 if (!fcf) {1329 /*1330 * We are yet to select best FCF, but we got CVL in the1331 * meantime. reset the ctlr and let it rediscover the FCF1332 */1333 LIBFCOE_FIP_DBG(fip, "Resetting fcoe_ctlr as FCF has not been "1334 "selected yet\n");1335 mutex_lock(&fip->ctlr_mutex);1336 fcoe_ctlr_reset(fip);1337 mutex_unlock(&fip->ctlr_mutex);1338 return;1339 }1340 1341 /*1342 * If we've selected an FCF check that the CVL is from there to avoid1343 * processing CVLs from an unexpected source. If it is from an1344 * unexpected source drop it on the floor.1345 */1346 if (!ether_addr_equal(eh->h_source, fcf->fcf_mac)) {1347 LIBFCOE_FIP_DBG(fip, "Dropping CVL due to source address "1348 "mismatch with FCF src=%pM\n", eh->h_source);1349 return;1350 }1351 1352 /*1353 * If we haven't logged into the fabric but receive a CVL we should1354 * reset everything and go back to solicitation.1355 */1356 if (!lport->port_id) {1357 LIBFCOE_FIP_DBG(fip, "lport not logged in, resoliciting\n");1358 mutex_lock(&fip->ctlr_mutex);1359 fcoe_ctlr_reset(fip);1360 mutex_unlock(&fip->ctlr_mutex);1361 fc_lport_reset(fip->lp);1362 fcoe_ctlr_solicit(fip, NULL);1363 return;1364 }1365 1366 /*1367 * mask of required descriptors. Validating each one clears its bit.1368 */1369 desc_mask = BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME);1370 1371 rlen = ntohs(fh->fip_dl_len) * FIP_BPW;1372 desc = (struct fip_desc *)(fh + 1);1373 1374 /*1375 * Actually need to subtract 'sizeof(*mp) - sizeof(*wp)' from 'rlen'1376 * before determining max Vx_Port descriptor but a buggy FCF could have1377 * omitted either or both MAC Address and Name Identifier descriptors1378 */1379 num_vlink_desc = rlen / sizeof(*vp);1380 if (num_vlink_desc)1381 vlink_desc_arr = kmalloc_array(num_vlink_desc, sizeof(vp),1382 GFP_ATOMIC);1383 if (!vlink_desc_arr)1384 return;1385 num_vlink_desc = 0;1386 1387 while (rlen >= sizeof(*desc)) {1388 dlen = desc->fip_dlen * FIP_BPW;1389 if (dlen > rlen)1390 goto err;1391 /* Drop CVL if there are duplicate critical descriptors */1392 if ((desc->fip_dtype < 32) &&1393 (desc->fip_dtype != FIP_DT_VN_ID) &&1394 !(desc_mask & 1U << desc->fip_dtype)) {1395 LIBFCOE_FIP_DBG(fip, "Duplicate Critical "1396 "Descriptors in FIP CVL\n");1397 goto err;1398 }1399 switch (desc->fip_dtype) {1400 case FIP_DT_MAC:1401 mp = (struct fip_mac_desc *)desc;1402 if (dlen < sizeof(*mp))1403 goto err;1404 if (!ether_addr_equal(mp->fd_mac, fcf->fcf_mac))1405 goto err;1406 desc_mask &= ~BIT(FIP_DT_MAC);1407 break;1408 case FIP_DT_NAME:1409 wp = (struct fip_wwn_desc *)desc;1410 if (dlen < sizeof(*wp))1411 goto err;1412 if (get_unaligned_be64(&wp->fd_wwn) != fcf->switch_name)1413 goto err;1414 desc_mask &= ~BIT(FIP_DT_NAME);1415 break;1416 case FIP_DT_VN_ID:1417 vp = (struct fip_vn_desc *)desc;1418 if (dlen < sizeof(*vp))1419 goto err;1420 vlink_desc_arr[num_vlink_desc++] = vp;1421 vn_port = fc_vport_id_lookup(lport,1422 ntoh24(vp->fd_fc_id));1423 if (vn_port && (vn_port == lport)) {1424 mutex_lock(&fip->ctlr_mutex);1425 this_cpu_inc(lport->stats->VLinkFailureCount);1426 fcoe_ctlr_reset(fip);1427 mutex_unlock(&fip->ctlr_mutex);1428 }1429 break;1430 default:1431 /* standard says ignore unknown descriptors >= 128 */1432 if (desc->fip_dtype < FIP_DT_NON_CRITICAL)1433 goto err;1434 break;1435 }1436 desc = (struct fip_desc *)((char *)desc + dlen);1437 rlen -= dlen;1438 }1439 1440 /*1441 * reset only if all required descriptors were present and valid.1442 */1443 if (desc_mask)1444 LIBFCOE_FIP_DBG(fip, "missing descriptors mask %x\n",1445 desc_mask);1446 else if (!num_vlink_desc) {1447 LIBFCOE_FIP_DBG(fip, "CVL: no Vx_Port descriptor found\n");1448 /*1449 * No Vx_Port description. Clear all NPIV ports,1450 * followed by physical port1451 */1452 mutex_lock(&fip->ctlr_mutex);1453 this_cpu_inc(lport->stats->VLinkFailureCount);1454 fcoe_ctlr_reset(fip);1455 mutex_unlock(&fip->ctlr_mutex);1456 1457 mutex_lock(&lport->lp_mutex);1458 list_for_each_entry(vn_port, &lport->vports, list)1459 fc_lport_reset(vn_port);1460 mutex_unlock(&lport->lp_mutex);1461 1462 fc_lport_reset(fip->lp);1463 fcoe_ctlr_solicit(fip, NULL);1464 } else {1465 int i;1466 1467 LIBFCOE_FIP_DBG(fip, "performing Clear Virtual Link\n");1468 for (i = 0; i < num_vlink_desc; i++) {1469 vp = vlink_desc_arr[i];1470 vn_port = fc_vport_id_lookup(lport,1471 ntoh24(vp->fd_fc_id));1472 if (!vn_port)1473 continue;1474 1475 /*1476 * 'port_id' is already validated, check MAC address and1477 * wwpn1478 */1479 if (!ether_addr_equal(fip->get_src_addr(vn_port),1480 vp->fd_mac) ||1481 get_unaligned_be64(&vp->fd_wwpn) !=1482 vn_port->wwpn)1483 continue;1484 1485 if (vn_port == lport)1486 /*1487 * Physical port, defer processing till all1488 * listed NPIV ports are cleared1489 */1490 reset_phys_port = 1;1491 else /* NPIV port */1492 fc_lport_reset(vn_port);1493 }1494 1495 if (reset_phys_port) {1496 fc_lport_reset(fip->lp);1497 fcoe_ctlr_solicit(fip, NULL);1498 }1499 }1500 1501err:1502 kfree(vlink_desc_arr);1503}1504 1505/**1506 * fcoe_ctlr_recv() - Receive a FIP packet1507 * @fip: The FCoE controller that received the packet1508 * @skb: The received FIP packet1509 *1510 * This may be called from either NET_RX_SOFTIRQ or IRQ.1511 */1512void fcoe_ctlr_recv(struct fcoe_ctlr *fip, struct sk_buff *skb)1513{1514 skb = skb_share_check(skb, GFP_ATOMIC);1515 if (!skb)1516 return;1517 skb_queue_tail(&fip->fip_recv_list, skb);1518 schedule_work(&fip->recv_work);1519}1520EXPORT_SYMBOL(fcoe_ctlr_recv);1521 1522/**1523 * fcoe_ctlr_recv_handler() - Receive a FIP frame1524 * @fip: The FCoE controller that received the frame1525 * @skb: The received FIP frame1526 *1527 * Returns non-zero if the frame is dropped.1528 */1529static int fcoe_ctlr_recv_handler(struct fcoe_ctlr *fip, struct sk_buff *skb)1530{1531 struct fip_header *fiph;1532 struct ethhdr *eh;1533 enum fip_state state;1534 bool fip_vlan_resp = false;1535 u16 op;1536 u8 sub;1537 1538 if (skb_linearize(skb))1539 goto drop;1540 if (skb->len < sizeof(*fiph))1541 goto drop;1542 eh = eth_hdr(skb);1543 if (fip->mode == FIP_MODE_VN2VN) {1544 if (!ether_addr_equal(eh->h_dest, fip->ctl_src_addr) &&1545 !ether_addr_equal(eh->h_dest, fcoe_all_vn2vn) &&1546 !ether_addr_equal(eh->h_dest, fcoe_all_p2p))1547 goto drop;1548 } else if (!ether_addr_equal(eh->h_dest, fip->ctl_src_addr) &&1549 !ether_addr_equal(eh->h_dest, fcoe_all_enode))1550 goto drop;1551 fiph = (struct fip_header *)skb->data;1552 op = ntohs(fiph->fip_op);1553 sub = fiph->fip_subcode;1554 1555 if (FIP_VER_DECAPS(fiph->fip_ver) != FIP_VER)1556 goto drop;1557 if (ntohs(fiph->fip_dl_len) * FIP_BPW + sizeof(*fiph) > skb->len)1558 goto drop;1559 1560 mutex_lock(&fip->ctlr_mutex);1561 state = fip->state;1562 if (state == FIP_ST_AUTO) {1563 fip->map_dest = 0;1564 fcoe_ctlr_set_state(fip, FIP_ST_ENABLED);1565 state = FIP_ST_ENABLED;1566 LIBFCOE_FIP_DBG(fip, "Using FIP mode\n");1567 }1568 fip_vlan_resp = fip->fip_resp;1569 mutex_unlock(&fip->ctlr_mutex);1570 1571 if (fip->mode == FIP_MODE_VN2VN && op == FIP_OP_VN2VN)1572 return fcoe_ctlr_vn_recv(fip, skb);1573 1574 if (fip_vlan_resp && op == FIP_OP_VLAN) {1575 LIBFCOE_FIP_DBG(fip, "fip vlan discovery\n");1576 return fcoe_ctlr_vlan_recv(fip, skb);1577 }1578 1579 if (state != FIP_ST_ENABLED && state != FIP_ST_VNMP_UP &&1580 state != FIP_ST_VNMP_CLAIM)1581 goto drop;1582 1583 if (op == FIP_OP_LS) {1584 fcoe_ctlr_recv_els(fip, skb); /* consumes skb */1585 return 0;1586 }1587 1588 if (state != FIP_ST_ENABLED)1589 goto drop;1590 1591 if (op == FIP_OP_DISC && sub == FIP_SC_ADV)1592 fcoe_ctlr_recv_adv(fip, skb);1593 else if (op == FIP_OP_CTRL && sub == FIP_SC_CLR_VLINK)1594 fcoe_ctlr_recv_clr_vlink(fip, skb);1595 kfree_skb(skb);1596 return 0;1597drop:1598 kfree_skb(skb);1599 return -1;1600}1601 1602/**1603 * fcoe_ctlr_select() - Select the best FCF (if possible)1604 * @fip: The FCoE controller1605 *1606 * Returns the selected FCF, or NULL if none are usable.1607 *1608 * If there are conflicting advertisements, no FCF can be chosen.1609 *1610 * If there is already a selected FCF, this will choose a better one or1611 * an equivalent one that hasn't already been sent a FLOGI.1612 *1613 * Called with lock held.1614 */1615static struct fcoe_fcf *fcoe_ctlr_select(struct fcoe_ctlr *fip)1616{1617 struct fcoe_fcf *fcf;1618 struct fcoe_fcf *best = fip->sel_fcf;1619 1620 list_for_each_entry(fcf, &fip->fcfs, list) {1621 LIBFCOE_FIP_DBG(fip, "consider FCF fab %16.16llx "1622 "VFID %d mac %pM map %x val %d "1623 "sent %u pri %u\n",1624 fcf->fabric_name, fcf->vfid, fcf->fcf_mac,1625 fcf->fc_map, fcoe_ctlr_mtu_valid(fcf),1626 fcf->flogi_sent, fcf->pri);1627 if (!fcoe_ctlr_fcf_usable(fcf)) {1628 LIBFCOE_FIP_DBG(fip, "FCF for fab %16.16llx "1629 "map %x %svalid %savailable\n",1630 fcf->fabric_name, fcf->fc_map,1631 (fcf->flags & FIP_FL_SOL) ? "" : "in",1632 (fcf->flags & FIP_FL_AVAIL) ?1633 "" : "un");1634 continue;1635 }1636 if (!best || fcf->pri < best->pri || best->flogi_sent)1637 best = fcf;1638 if (fcf->fabric_name != best->fabric_name ||1639 fcf->vfid != best->vfid ||1640 fcf->fc_map != best->fc_map) {1641 LIBFCOE_FIP_DBG(fip, "Conflicting fabric, VFID, "1642 "or FC-MAP\n");1643 return NULL;1644 }1645 }1646 fip->sel_fcf = best;1647 if (best) {1648 LIBFCOE_FIP_DBG(fip, "using FCF mac %pM\n", best->fcf_mac);1649 fip->port_ka_time = jiffies +1650 msecs_to_jiffies(FIP_VN_KA_PERIOD);1651 fip->ctlr_ka_time = jiffies + best->fka_period;1652 if (time_before(fip->ctlr_ka_time, fip->timer.expires))1653 mod_timer(&fip->timer, fip->ctlr_ka_time);1654 }1655 return best;1656}1657 1658/**1659 * fcoe_ctlr_flogi_send_locked() - send FIP-encapsulated FLOGI to current FCF1660 * @fip: The FCoE controller1661 *1662 * Returns non-zero error if it could not be sent.1663 *1664 * Called with ctlr_mutex and ctlr_lock held.1665 * Caller must verify that fip->sel_fcf is not NULL.1666 */1667static int fcoe_ctlr_flogi_send_locked(struct fcoe_ctlr *fip)1668{1669 struct sk_buff *skb;1670 struct sk_buff *skb_orig;1671 struct fc_frame_header *fh;1672 int error;1673 1674 skb_orig = fip->flogi_req;1675 if (!skb_orig)1676 return -EINVAL;1677 1678 /*1679 * Clone and send the FLOGI request. If clone fails, use original.1680 */1681 skb = skb_clone(skb_orig, GFP_ATOMIC);1682 if (!skb) {1683 skb = skb_orig;1684 fip->flogi_req = NULL;1685 }1686 fh = (struct fc_frame_header *)skb->data;1687 error = fcoe_ctlr_encaps(fip, fip->lp, FIP_DT_FLOGI, skb,1688 ntoh24(fh->fh_d_id));1689 if (error) {1690 kfree_skb(skb);1691 return error;1692 }1693 fip->send(fip, skb);1694 fip->sel_fcf->flogi_sent = 1;1695 return 0;1696}1697 1698/**1699 * fcoe_ctlr_flogi_retry() - resend FLOGI request to a new FCF if possible1700 * @fip: The FCoE controller1701 *1702 * Returns non-zero error code if there's no FLOGI request to retry or1703 * no alternate FCF available.1704 */1705static int fcoe_ctlr_flogi_retry(struct fcoe_ctlr *fip)1706{1707 struct fcoe_fcf *fcf;1708 int error;1709 1710 mutex_lock(&fip->ctlr_mutex);1711 spin_lock_bh(&fip->ctlr_lock);1712 LIBFCOE_FIP_DBG(fip, "re-sending FLOGI - reselect\n");1713 fcf = fcoe_ctlr_select(fip);1714 if (!fcf || fcf->flogi_sent) {1715 kfree_skb(fip->flogi_req);1716 fip->flogi_req = NULL;1717 error = -ENOENT;1718 } else {1719 fcoe_ctlr_solicit(fip, NULL);1720 error = fcoe_ctlr_flogi_send_locked(fip);1721 }1722 spin_unlock_bh(&fip->ctlr_lock);1723 mutex_unlock(&fip->ctlr_mutex);1724 return error;1725}1726 1727 1728/**1729 * fcoe_ctlr_flogi_send() - Handle sending of FIP FLOGI.1730 * @fip: The FCoE controller that timed out1731 *1732 * Done here because fcoe_ctlr_els_send() can't get mutex.1733 *1734 * Called with ctlr_mutex held. The caller must not hold ctlr_lock.1735 */1736static void fcoe_ctlr_flogi_send(struct fcoe_ctlr *fip)1737{1738 struct fcoe_fcf *fcf;1739 1740 spin_lock_bh(&fip->ctlr_lock);1741 fcf = fip->sel_fcf;1742 if (!fcf || !fip->flogi_req_send)1743 goto unlock;1744 1745 LIBFCOE_FIP_DBG(fip, "sending FLOGI\n");1746 1747 /*1748 * If this FLOGI is being sent due to a timeout retry1749 * to the same FCF as before, select a different FCF if possible.1750 */1751 if (fcf->flogi_sent) {1752 LIBFCOE_FIP_DBG(fip, "sending FLOGI - reselect\n");1753 fcf = fcoe_ctlr_select(fip);1754 if (!fcf || fcf->flogi_sent) {1755 LIBFCOE_FIP_DBG(fip, "sending FLOGI - clearing\n");1756 list_for_each_entry(fcf, &fip->fcfs, list)1757 fcf->flogi_sent = 0;1758 fcf = fcoe_ctlr_select(fip);1759 }1760 }1761 if (fcf) {1762 fcoe_ctlr_flogi_send_locked(fip);1763 fip->flogi_req_send = 0;1764 } else /* XXX */1765 LIBFCOE_FIP_DBG(fip, "No FCF selected - defer send\n");1766unlock:1767 spin_unlock_bh(&fip->ctlr_lock);1768}1769 1770/**1771 * fcoe_ctlr_timeout() - FIP timeout handler1772 * @t: Timer context use to obtain the controller reference1773 */1774static void fcoe_ctlr_timeout(struct timer_list *t)1775{1776 struct fcoe_ctlr *fip = from_timer(fip, t, timer);1777 1778 schedule_work(&fip->timer_work);1779}1780 1781/**1782 * fcoe_ctlr_timer_work() - Worker thread function for timer work1783 * @work: Handle to a FCoE controller1784 *1785 * Ages FCFs. Triggers FCF selection if possible.1786 * Sends keep-alives and resets.1787 */1788static void fcoe_ctlr_timer_work(struct work_struct *work)1789{1790 struct fcoe_ctlr *fip;1791 struct fc_lport *vport;1792 u8 *mac;1793 u8 reset = 0;1794 u8 send_ctlr_ka = 0;1795 u8 send_port_ka = 0;1796 struct fcoe_fcf *sel;1797 struct fcoe_fcf *fcf;1798 unsigned long next_timer;1799 1800 fip = container_of(work, struct fcoe_ctlr, timer_work);1801 if (fip->mode == FIP_MODE_VN2VN)1802 return fcoe_ctlr_vn_timeout(fip);1803 mutex_lock(&fip->ctlr_mutex);1804 if (fip->state == FIP_ST_DISABLED) {1805 mutex_unlock(&fip->ctlr_mutex);1806 return;1807 }1808 1809 fcf = fip->sel_fcf;1810 next_timer = fcoe_ctlr_age_fcfs(fip);1811 1812 sel = fip->sel_fcf;1813 if (!sel && fip->sel_time) {1814 if (time_after_eq(jiffies, fip->sel_time)) {1815 sel = fcoe_ctlr_select(fip);1816 fip->sel_time = 0;1817 } else if (time_after(next_timer, fip->sel_time))1818 next_timer = fip->sel_time;1819 }1820 1821 if (sel && fip->flogi_req_send)1822 fcoe_ctlr_flogi_send(fip);1823 else if (!sel && fcf)1824 reset = 1;1825 1826 if (sel && !sel->fd_flags) {1827 if (time_after_eq(jiffies, fip->ctlr_ka_time)) {1828 fip->ctlr_ka_time = jiffies + sel->fka_period;1829 send_ctlr_ka = 1;1830 }1831 if (time_after(next_timer, fip->ctlr_ka_time))1832 next_timer = fip->ctlr_ka_time;1833 1834 if (time_after_eq(jiffies, fip->port_ka_time)) {1835 fip->port_ka_time = jiffies +1836 msecs_to_jiffies(FIP_VN_KA_PERIOD);1837 send_port_ka = 1;1838 }1839 if (time_after(next_timer, fip->port_ka_time))1840 next_timer = fip->port_ka_time;1841 }1842 if (!list_empty(&fip->fcfs))1843 mod_timer(&fip->timer, next_timer);1844 mutex_unlock(&fip->ctlr_mutex);1845 1846 if (reset) {1847 fc_lport_reset(fip->lp);1848 /* restart things with a solicitation */1849 fcoe_ctlr_solicit(fip, NULL);1850 }1851 1852 if (send_ctlr_ka)1853 fcoe_ctlr_send_keep_alive(fip, NULL, 0, fip->ctl_src_addr);1854 1855 if (send_port_ka) {1856 mutex_lock(&fip->lp->lp_mutex);1857 mac = fip->get_src_addr(fip->lp);1858 fcoe_ctlr_send_keep_alive(fip, fip->lp, 1, mac);1859 list_for_each_entry(vport, &fip->lp->vports, list) {1860 mac = fip->get_src_addr(vport);1861 fcoe_ctlr_send_keep_alive(fip, vport, 1, mac);1862 }1863 mutex_unlock(&fip->lp->lp_mutex);1864 }1865}1866 1867/**1868 * fcoe_ctlr_recv_work() - Worker thread function for receiving FIP frames1869 * @recv_work: Handle to a FCoE controller1870 */1871static void fcoe_ctlr_recv_work(struct work_struct *recv_work)1872{1873 struct fcoe_ctlr *fip;1874 struct sk_buff *skb;1875 1876 fip = container_of(recv_work, struct fcoe_ctlr, recv_work);1877 while ((skb = skb_dequeue(&fip->fip_recv_list)))1878 fcoe_ctlr_recv_handler(fip, skb);1879}1880 1881/**1882 * fcoe_ctlr_recv_flogi() - Snoop pre-FIP receipt of FLOGI response1883 * @fip: The FCoE controller1884 * @lport: The local port1885 * @fp: The FC frame to snoop1886 *1887 * Snoop potential response to FLOGI or even incoming FLOGI.1888 *1889 * The caller has checked that we are waiting for login as indicated1890 * by fip->flogi_oxid != FC_XID_UNKNOWN.1891 *1892 * The caller is responsible for freeing the frame.1893 * Fill in the granted_mac address.1894 *1895 * Return non-zero if the frame should not be delivered to libfc.1896 */1897int fcoe_ctlr_recv_flogi(struct fcoe_ctlr *fip, struct fc_lport *lport,1898 struct fc_frame *fp)1899{1900 struct fc_frame_header *fh;1901 u8 op;1902 u8 *sa;1903 1904 sa = eth_hdr(&fp->skb)->h_source;1905 fh = fc_frame_header_get(fp);1906 if (fh->fh_type != FC_TYPE_ELS)1907 return 0;1908 1909 op = fc_frame_payload_op(fp);1910 if (op == ELS_LS_ACC && fh->fh_r_ctl == FC_RCTL_ELS_REP &&1911 fip->flogi_oxid == ntohs(fh->fh_ox_id)) {1912 1913 mutex_lock(&fip->ctlr_mutex);1914 if (fip->state != FIP_ST_AUTO && fip->state != FIP_ST_NON_FIP) {1915 mutex_unlock(&fip->ctlr_mutex);1916 return -EINVAL;1917 }1918 fcoe_ctlr_set_state(fip, FIP_ST_NON_FIP);1919 LIBFCOE_FIP_DBG(fip,1920 "received FLOGI LS_ACC using non-FIP mode\n");1921 1922 /*1923 * FLOGI accepted.1924 * If the src mac addr is FC_OUI-based, then we mark the1925 * address_mode flag to use FC_OUI-based Ethernet DA.1926 * Otherwise we use the FCoE gateway addr1927 */1928 if (ether_addr_equal(sa, (u8[6])FC_FCOE_FLOGI_MAC)) {1929 fcoe_ctlr_map_dest(fip);1930 } else {1931 memcpy(fip->dest_addr, sa, ETH_ALEN);1932 fip->map_dest = 0;1933 }1934 fip->flogi_oxid = FC_XID_UNKNOWN;1935 mutex_unlock(&fip->ctlr_mutex);1936 fc_fcoe_set_mac(fr_cb(fp)->granted_mac, fh->fh_d_id);1937 } else if (op == ELS_FLOGI && fh->fh_r_ctl == FC_RCTL_ELS_REQ && sa) {1938 /*1939 * Save source MAC for point-to-point responses.1940 */1941 mutex_lock(&fip->ctlr_mutex);1942 if (fip->state == FIP_ST_AUTO || fip->state == FIP_ST_NON_FIP) {1943 memcpy(fip->dest_addr, sa, ETH_ALEN);1944 fip->map_dest = 0;1945 if (fip->state == FIP_ST_AUTO)1946 LIBFCOE_FIP_DBG(fip, "received non-FIP FLOGI. "1947 "Setting non-FIP mode\n");1948 fcoe_ctlr_set_state(fip, FIP_ST_NON_FIP);1949 }1950 mutex_unlock(&fip->ctlr_mutex);1951 }1952 return 0;1953}1954EXPORT_SYMBOL(fcoe_ctlr_recv_flogi);1955 1956/**1957 * fcoe_wwn_from_mac() - Converts a 48-bit IEEE MAC address to a 64-bit FC WWN1958 * @mac: The MAC address to convert1959 * @scheme: The scheme to use when converting1960 * @port: The port indicator for converting1961 *1962 * Returns: u64 fc world wide name1963 */1964u64 fcoe_wwn_from_mac(unsigned char mac[ETH_ALEN],1965 unsigned int scheme, unsigned int port)1966{1967 u64 wwn;1968 u64 host_mac;1969 1970 /* The MAC is in NO, so flip only the low 48 bits */1971 host_mac = ((u64) mac[0] << 40) |1972 ((u64) mac[1] << 32) |1973 ((u64) mac[2] << 24) |1974 ((u64) mac[3] << 16) |1975 ((u64) mac[4] << 8) |1976 (u64) mac[5];1977 1978 WARN_ON(host_mac >= (1ULL << 48));1979 wwn = host_mac | ((u64) scheme << 60);1980 switch (scheme) {1981 case 1:1982 WARN_ON(port != 0);1983 break;1984 case 2:1985 WARN_ON(port >= 0xfff);1986 wwn |= (u64) port << 48;1987 break;1988 default:1989 WARN_ON(1);1990 break;1991 }1992 1993 return wwn;1994}1995EXPORT_SYMBOL_GPL(fcoe_wwn_from_mac);1996 1997/**1998 * fcoe_ctlr_rport() - return the fcoe_rport for a given fc_rport_priv1999 * @rdata: libfc remote port2000 */2001static inline struct fcoe_rport *fcoe_ctlr_rport(struct fc_rport_priv *rdata)2002{2003 return container_of(rdata, struct fcoe_rport, rdata);2004}2005 2006/**2007 * fcoe_ctlr_vn_send() - Send a FIP VN2VN Probe Request or Reply.2008 * @fip: The FCoE controller2009 * @sub: sub-opcode for probe request, reply, or advertisement.2010 * @dest: The destination Ethernet MAC address2011 * @min_len: minimum size of the Ethernet payload to be sent2012 */2013static void fcoe_ctlr_vn_send(struct fcoe_ctlr *fip,2014 enum fip_vn2vn_subcode sub,2015 const u8 *dest, size_t min_len)2016{2017 struct sk_buff *skb;2018 struct fip_vn2vn_probe_frame {2019 struct ethhdr eth;2020 struct fip_header fip;2021 struct fip_mac_desc mac;2022 struct fip_wwn_desc wwnn;2023 struct fip_vn_desc vn;2024 } __packed * frame;2025 struct fip_fc4_feat *ff;2026 struct fip_size_desc *size;2027 u32 fcp_feat;2028 size_t len;2029 size_t dlen;2030 2031 len = sizeof(*frame);2032 dlen = 0;2033 if (sub == FIP_SC_VN_CLAIM_NOTIFY || sub == FIP_SC_VN_CLAIM_REP) {2034 dlen = sizeof(struct fip_fc4_feat) +2035 sizeof(struct fip_size_desc);2036 len += dlen;2037 }2038 dlen += sizeof(frame->mac) + sizeof(frame->wwnn) + sizeof(frame->vn);2039 len = max(len, min_len + sizeof(struct ethhdr));2040 2041 skb = dev_alloc_skb(len);2042 if (!skb)2043 return;2044 2045 frame = (struct fip_vn2vn_probe_frame *)skb->data;2046 memset(frame, 0, len);2047 memcpy(frame->eth.h_dest, dest, ETH_ALEN);2048 2049 if (sub == FIP_SC_VN_BEACON) {2050 hton24(frame->eth.h_source, FIP_VN_FC_MAP);2051 hton24(frame->eth.h_source + 3, fip->port_id);2052 } else {2053 memcpy(frame->eth.h_source, fip->ctl_src_addr, ETH_ALEN);2054 }2055 frame->eth.h_proto = htons(ETH_P_FIP);2056 2057 frame->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);2058 frame->fip.fip_op = htons(FIP_OP_VN2VN);2059 frame->fip.fip_subcode = sub;2060 frame->fip.fip_dl_len = htons(dlen / FIP_BPW);2061 2062 frame->mac.fd_desc.fip_dtype = FIP_DT_MAC;2063 frame->mac.fd_desc.fip_dlen = sizeof(frame->mac) / FIP_BPW;2064 memcpy(frame->mac.fd_mac, fip->ctl_src_addr, ETH_ALEN);2065 2066 frame->wwnn.fd_desc.fip_dtype = FIP_DT_NAME;2067 frame->wwnn.fd_desc.fip_dlen = sizeof(frame->wwnn) / FIP_BPW;2068 put_unaligned_be64(fip->lp->wwnn, &frame->wwnn.fd_wwn);2069 2070 frame->vn.fd_desc.fip_dtype = FIP_DT_VN_ID;2071 frame->vn.fd_desc.fip_dlen = sizeof(frame->vn) / FIP_BPW;2072 hton24(frame->vn.fd_mac, FIP_VN_FC_MAP);2073 hton24(frame->vn.fd_mac + 3, fip->port_id);2074 hton24(frame->vn.fd_fc_id, fip->port_id);2075 put_unaligned_be64(fip->lp->wwpn, &frame->vn.fd_wwpn);2076 2077 /*2078 * For claims, add FC-4 features.2079 * TBD: Add interface to get fc-4 types and features from libfc.2080 */2081 if (sub == FIP_SC_VN_CLAIM_NOTIFY || sub == FIP_SC_VN_CLAIM_REP) {2082 ff = (struct fip_fc4_feat *)(frame + 1);2083 ff->fd_desc.fip_dtype = FIP_DT_FC4F;2084 ff->fd_desc.fip_dlen = sizeof(*ff) / FIP_BPW;2085 ff->fd_fts = fip->lp->fcts;2086 2087 fcp_feat = 0;2088 if (fip->lp->service_params & FCP_SPPF_INIT_FCN)2089 fcp_feat |= FCP_FEAT_INIT;2090 if (fip->lp->service_params & FCP_SPPF_TARG_FCN)2091 fcp_feat |= FCP_FEAT_TARG;2092 fcp_feat <<= (FC_TYPE_FCP * 4) % 32;2093 ff->fd_ff.fd_feat[FC_TYPE_FCP * 4 / 32] = htonl(fcp_feat);2094 2095 size = (struct fip_size_desc *)(ff + 1);2096 size->fd_desc.fip_dtype = FIP_DT_FCOE_SIZE;2097 size->fd_desc.fip_dlen = sizeof(*size) / FIP_BPW;2098 size->fd_size = htons(fcoe_ctlr_fcoe_size(fip));2099 }2100 2101 skb_put(skb, len);2102 skb->protocol = htons(ETH_P_FIP);2103 skb->priority = fip->priority;2104 skb_reset_mac_header(skb);2105 skb_reset_network_header(skb);2106 2107 fip->send(fip, skb);2108}2109 2110/**2111 * fcoe_ctlr_vn_rport_callback - Event handler for rport events.2112 * @lport: The lport which is receiving the event2113 * @rdata: remote port private data2114 * @event: The event that occurred2115 *2116 * Locking Note: The rport lock must not be held when calling this function.2117 */2118static void fcoe_ctlr_vn_rport_callback(struct fc_lport *lport,2119 struct fc_rport_priv *rdata,2120 enum fc_rport_event event)2121{2122 struct fcoe_ctlr *fip = lport->disc.priv;2123 struct fcoe_rport *frport = fcoe_ctlr_rport(rdata);2124 2125 LIBFCOE_FIP_DBG(fip, "vn_rport_callback %x event %d\n",2126 rdata->ids.port_id, event);2127 2128 mutex_lock(&fip->ctlr_mutex);2129 switch (event) {2130 case RPORT_EV_READY:2131 frport->login_count = 0;2132 break;2133 case RPORT_EV_LOGO:2134 case RPORT_EV_FAILED:2135 case RPORT_EV_STOP:2136 frport->login_count++;2137 if (frport->login_count > FCOE_CTLR_VN2VN_LOGIN_LIMIT) {2138 LIBFCOE_FIP_DBG(fip,2139 "rport FLOGI limited port_id %6.6x\n",2140 rdata->ids.port_id);2141 fc_rport_logoff(rdata);2142 }2143 break;2144 default:2145 break;2146 }2147 mutex_unlock(&fip->ctlr_mutex);2148}2149 2150static struct fc_rport_operations fcoe_ctlr_vn_rport_ops = {2151 .event_callback = fcoe_ctlr_vn_rport_callback,2152};2153 2154/**2155 * fcoe_ctlr_disc_stop_locked() - stop discovery in VN2VN mode2156 * @lport: The local port2157 *2158 * Called with ctlr_mutex held.2159 */2160static void fcoe_ctlr_disc_stop_locked(struct fc_lport *lport)2161{2162 struct fc_rport_priv *rdata;2163 2164 mutex_lock(&lport->disc.disc_mutex);2165 list_for_each_entry_rcu(rdata, &lport->disc.rports, peers) {2166 if (kref_get_unless_zero(&rdata->kref)) {2167 fc_rport_logoff(rdata);2168 kref_put(&rdata->kref, fc_rport_destroy);2169 }2170 }2171 lport->disc.disc_callback = NULL;2172 mutex_unlock(&lport->disc.disc_mutex);2173}2174 2175/**2176 * fcoe_ctlr_disc_stop() - stop discovery in VN2VN mode2177 * @lport: The local port2178 *2179 * Called through the local port template for discovery.2180 * Called without the ctlr_mutex held.2181 */2182static void fcoe_ctlr_disc_stop(struct fc_lport *lport)2183{2184 struct fcoe_ctlr *fip = lport->disc.priv;2185 2186 mutex_lock(&fip->ctlr_mutex);2187 fcoe_ctlr_disc_stop_locked(lport);2188 mutex_unlock(&fip->ctlr_mutex);2189}2190 2191/**2192 * fcoe_ctlr_disc_stop_final() - stop discovery for shutdown in VN2VN mode2193 * @lport: The local port2194 *2195 * Called through the local port template for discovery.2196 * Called without the ctlr_mutex held.2197 */2198static void fcoe_ctlr_disc_stop_final(struct fc_lport *lport)2199{2200 fcoe_ctlr_disc_stop(lport);2201 fc_rport_flush_queue();2202 synchronize_rcu();2203}2204 2205/**2206 * fcoe_ctlr_vn_restart() - VN2VN probe restart with new port_id2207 * @fip: The FCoE controller2208 *2209 * Called with fcoe_ctlr lock held.2210 */2211static void fcoe_ctlr_vn_restart(struct fcoe_ctlr *fip)2212{2213 unsigned long wait;2214 u32 port_id;2215 2216 fcoe_ctlr_disc_stop_locked(fip->lp);2217 2218 /*2219 * Get proposed port ID.2220 * If this is the first try after link up, use any previous port_id.2221 * If there was none, use the low bits of the port_name.2222 * On subsequent tries, get the next random one.2223 * Don't use reserved IDs, use another non-zero value, just as random.2224 */2225 port_id = fip->port_id;2226 if (fip->probe_tries)2227 port_id = prandom_u32_state(&fip->rnd_state) & 0xffff;2228 else if (!port_id)2229 port_id = fip->lp->wwpn & 0xffff;2230 if (!port_id || port_id == 0xffff)2231 port_id = 1;2232 fip->port_id = port_id;2233 2234 if (fip->probe_tries < FIP_VN_RLIM_COUNT) {2235 fip->probe_tries++;2236 wait = get_random_u32_below(FIP_VN_PROBE_WAIT);2237 } else2238 wait = FIP_VN_RLIM_INT;2239 mod_timer(&fip->timer, jiffies + msecs_to_jiffies(wait));2240 fcoe_ctlr_set_state(fip, FIP_ST_VNMP_START);2241}2242 2243/**2244 * fcoe_ctlr_vn_start() - Start in VN2VN mode2245 * @fip: The FCoE controller2246 *2247 * Called with fcoe_ctlr lock held.2248 */2249static void fcoe_ctlr_vn_start(struct fcoe_ctlr *fip)2250{2251 fip->probe_tries = 0;2252 prandom_seed_state(&fip->rnd_state, fip->lp->wwpn);2253 fcoe_ctlr_vn_restart(fip);2254}2255 2256/**2257 * fcoe_ctlr_vn_parse - parse probe request or response2258 * @fip: The FCoE controller2259 * @skb: incoming packet2260 * @frport: parsed FCoE rport from the probe request2261 *2262 * Returns non-zero error number on error.2263 * Does not consume the packet.2264 */2265static int fcoe_ctlr_vn_parse(struct fcoe_ctlr *fip,2266 struct sk_buff *skb,2267 struct fcoe_rport *frport)2268{2269 struct fip_header *fiph;2270 struct fip_desc *desc = NULL;2271 struct fip_mac_desc *macd = NULL;2272 struct fip_wwn_desc *wwn = NULL;2273 struct fip_vn_desc *vn = NULL;2274 struct fip_size_desc *size = NULL;2275 size_t rlen;2276 size_t dlen;2277 u32 desc_mask = 0;2278 u32 dtype;2279 u8 sub;2280 2281 fiph = (struct fip_header *)skb->data;2282 frport->flags = ntohs(fiph->fip_flags);2283 2284 sub = fiph->fip_subcode;2285 switch (sub) {2286 case FIP_SC_VN_PROBE_REQ:2287 case FIP_SC_VN_PROBE_REP:2288 case FIP_SC_VN_BEACON:2289 desc_mask = BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME) |2290 BIT(FIP_DT_VN_ID);2291 break;2292 case FIP_SC_VN_CLAIM_NOTIFY:2293 case FIP_SC_VN_CLAIM_REP:2294 desc_mask = BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME) |2295 BIT(FIP_DT_VN_ID) | BIT(FIP_DT_FC4F) |2296 BIT(FIP_DT_FCOE_SIZE);2297 break;2298 default:2299 LIBFCOE_FIP_DBG(fip, "vn_parse unknown subcode %u\n", sub);2300 return -EINVAL;2301 }2302 2303 rlen = ntohs(fiph->fip_dl_len) * 4;2304 if (rlen + sizeof(*fiph) > skb->len)2305 return -EINVAL;2306 2307 desc = (struct fip_desc *)(fiph + 1);2308 while (rlen > 0) {2309 dlen = desc->fip_dlen * FIP_BPW;2310 if (dlen < sizeof(*desc) || dlen > rlen)2311 return -EINVAL;2312 2313 dtype = desc->fip_dtype;2314 if (dtype < 32) {2315 if (!(desc_mask & BIT(dtype))) {2316 LIBFCOE_FIP_DBG(fip,2317 "unexpected or duplicated desc "2318 "desc type %u in "2319 "FIP VN2VN subtype %u\n",2320 dtype, sub);2321 return -EINVAL;2322 }2323 desc_mask &= ~BIT(dtype);2324 }2325 2326 switch (dtype) {2327 case FIP_DT_MAC:2328 if (dlen != sizeof(struct fip_mac_desc))2329 goto len_err;2330 macd = (struct fip_mac_desc *)desc;2331 if (!is_valid_ether_addr(macd->fd_mac)) {2332 LIBFCOE_FIP_DBG(fip,2333 "Invalid MAC addr %pM in FIP VN2VN\n",2334 macd->fd_mac);2335 return -EINVAL;2336 }2337 memcpy(frport->enode_mac, macd->fd_mac, ETH_ALEN);2338 break;2339 case FIP_DT_NAME:2340 if (dlen != sizeof(struct fip_wwn_desc))2341 goto len_err;2342 wwn = (struct fip_wwn_desc *)desc;2343 frport->rdata.ids.node_name =2344 get_unaligned_be64(&wwn->fd_wwn);2345 break;2346 case FIP_DT_VN_ID:2347 if (dlen != sizeof(struct fip_vn_desc))2348 goto len_err;2349 vn = (struct fip_vn_desc *)desc;2350 memcpy(frport->vn_mac, vn->fd_mac, ETH_ALEN);2351 frport->rdata.ids.port_id = ntoh24(vn->fd_fc_id);2352 frport->rdata.ids.port_name =2353 get_unaligned_be64(&vn->fd_wwpn);2354 break;2355 case FIP_DT_FC4F:2356 if (dlen != sizeof(struct fip_fc4_feat))2357 goto len_err;2358 break;2359 case FIP_DT_FCOE_SIZE:2360 if (dlen != sizeof(struct fip_size_desc))2361 goto len_err;2362 size = (struct fip_size_desc *)desc;2363 frport->fcoe_len = ntohs(size->fd_size);2364 break;2365 default:2366 LIBFCOE_FIP_DBG(fip, "unexpected descriptor type %x "2367 "in FIP probe\n", dtype);2368 /* standard says ignore unknown descriptors >= 128 */2369 if (dtype < FIP_DT_NON_CRITICAL)2370 return -EINVAL;2371 break;2372 }2373 desc = (struct fip_desc *)((char *)desc + dlen);2374 rlen -= dlen;2375 }2376 return 0;2377 2378len_err:2379 LIBFCOE_FIP_DBG(fip, "FIP length error in descriptor type %x len %zu\n",2380 dtype, dlen);2381 return -EINVAL;2382}2383 2384/**2385 * fcoe_ctlr_vn_send_claim() - send multicast FIP VN2VN Claim Notification.2386 * @fip: The FCoE controller2387 *2388 * Called with ctlr_mutex held.2389 */2390static void fcoe_ctlr_vn_send_claim(struct fcoe_ctlr *fip)2391{2392 fcoe_ctlr_vn_send(fip, FIP_SC_VN_CLAIM_NOTIFY, fcoe_all_vn2vn, 0);2393 fip->sol_time = jiffies;2394}2395 2396/**2397 * fcoe_ctlr_vn_probe_req() - handle incoming VN2VN probe request.2398 * @fip: The FCoE controller2399 * @frport: parsed FCoE rport from the probe request2400 *2401 * Called with ctlr_mutex held.2402 */2403static void fcoe_ctlr_vn_probe_req(struct fcoe_ctlr *fip,2404 struct fcoe_rport *frport)2405{2406 if (frport->rdata.ids.port_id != fip->port_id)2407 return;2408 2409 switch (fip->state) {2410 case FIP_ST_VNMP_CLAIM:2411 case FIP_ST_VNMP_UP:2412 LIBFCOE_FIP_DBG(fip, "vn_probe_req: send reply, state %x\n",2413 fip->state);2414 fcoe_ctlr_vn_send(fip, FIP_SC_VN_PROBE_REP,2415 frport->enode_mac, 0);2416 break;2417 case FIP_ST_VNMP_PROBE1:2418 case FIP_ST_VNMP_PROBE2:2419 /*2420 * Decide whether to reply to the Probe.2421 * Our selected address is never a "recorded" one, so2422 * only reply if our WWPN is greater and the2423 * Probe's REC bit is not set.2424 * If we don't reply, we will change our address.2425 */2426 if (fip->lp->wwpn > frport->rdata.ids.port_name &&2427 !(frport->flags & FIP_FL_REC_OR_P2P)) {2428 LIBFCOE_FIP_DBG(fip, "vn_probe_req: "2429 "port_id collision\n");2430 fcoe_ctlr_vn_send(fip, FIP_SC_VN_PROBE_REP,2431 frport->enode_mac, 0);2432 break;2433 }2434 fallthrough;2435 case FIP_ST_VNMP_START:2436 LIBFCOE_FIP_DBG(fip, "vn_probe_req: "2437 "restart VN2VN negotiation\n");2438 fcoe_ctlr_vn_restart(fip);2439 break;2440 default:2441 LIBFCOE_FIP_DBG(fip, "vn_probe_req: ignore state %x\n",2442 fip->state);2443 break;2444 }2445}2446 2447/**2448 * fcoe_ctlr_vn_probe_reply() - handle incoming VN2VN probe reply.2449 * @fip: The FCoE controller2450 * @frport: parsed FCoE rport from the probe request2451 *2452 * Called with ctlr_mutex held.2453 */2454static void fcoe_ctlr_vn_probe_reply(struct fcoe_ctlr *fip,2455 struct fcoe_rport *frport)2456{2457 if (frport->rdata.ids.port_id != fip->port_id)2458 return;2459 switch (fip->state) {2460 case FIP_ST_VNMP_START:2461 case FIP_ST_VNMP_PROBE1:2462 case FIP_ST_VNMP_PROBE2:2463 case FIP_ST_VNMP_CLAIM:2464 LIBFCOE_FIP_DBG(fip, "vn_probe_reply: restart state %x\n",2465 fip->state);2466 fcoe_ctlr_vn_restart(fip);2467 break;2468 case FIP_ST_VNMP_UP:2469 LIBFCOE_FIP_DBG(fip, "vn_probe_reply: send claim notify\n");2470 fcoe_ctlr_vn_send_claim(fip);2471 break;2472 default:2473 break;2474 }2475}2476 2477/**2478 * fcoe_ctlr_vn_add() - Add a VN2VN entry to the list, based on a claim reply.2479 * @fip: The FCoE controller2480 * @new: newly-parsed FCoE rport as a template for new rdata2481 *2482 * Called with ctlr_mutex held.2483 */2484static void fcoe_ctlr_vn_add(struct fcoe_ctlr *fip, struct fcoe_rport *new)2485{2486 struct fc_lport *lport = fip->lp;2487 struct fc_rport_priv *rdata;2488 struct fc_rport_identifiers *ids;2489 struct fcoe_rport *frport;2490 u32 port_id;2491 2492 port_id = new->rdata.ids.port_id;2493 if (port_id == fip->port_id)2494 return;2495 2496 mutex_lock(&lport->disc.disc_mutex);2497 rdata = fc_rport_create(lport, port_id);2498 if (!rdata) {2499 mutex_unlock(&lport->disc.disc_mutex);2500 return;2501 }2502 mutex_lock(&rdata->rp_mutex);2503 mutex_unlock(&lport->disc.disc_mutex);2504 2505 rdata->ops = &fcoe_ctlr_vn_rport_ops;2506 rdata->disc_id = lport->disc.disc_id;2507 2508 ids = &rdata->ids;2509 if ((ids->port_name != -1 &&2510 ids->port_name != new->rdata.ids.port_name) ||2511 (ids->node_name != -1 &&2512 ids->node_name != new->rdata.ids.node_name)) {2513 mutex_unlock(&rdata->rp_mutex);2514 LIBFCOE_FIP_DBG(fip, "vn_add rport logoff %6.6x\n", port_id);2515 fc_rport_logoff(rdata);2516 mutex_lock(&rdata->rp_mutex);2517 }2518 ids->port_name = new->rdata.ids.port_name;2519 ids->node_name = new->rdata.ids.node_name;2520 mutex_unlock(&rdata->rp_mutex);2521 2522 frport = fcoe_ctlr_rport(rdata);2523 LIBFCOE_FIP_DBG(fip, "vn_add rport %6.6x %s state %d\n",2524 port_id, frport->fcoe_len ? "old" : "new",2525 rdata->rp_state);2526 frport->fcoe_len = new->fcoe_len;2527 frport->flags = new->flags;2528 frport->login_count = new->login_count;2529 memcpy(frport->enode_mac, new->enode_mac, ETH_ALEN);2530 memcpy(frport->vn_mac, new->vn_mac, ETH_ALEN);2531 frport->time = 0;2532}2533 2534/**2535 * fcoe_ctlr_vn_lookup() - Find VN remote port's MAC address2536 * @fip: The FCoE controller2537 * @port_id: The port_id of the remote VN_node2538 * @mac: buffer which will hold the VN_NODE destination MAC address, if found.2539 *2540 * Returns non-zero error if no remote port found.2541 */2542static int fcoe_ctlr_vn_lookup(struct fcoe_ctlr *fip, u32 port_id, u8 *mac)2543{2544 struct fc_lport *lport = fip->lp;2545 struct fc_rport_priv *rdata;2546 struct fcoe_rport *frport;2547 int ret = -1;2548 2549 rdata = fc_rport_lookup(lport, port_id);2550 if (rdata) {2551 frport = fcoe_ctlr_rport(rdata);2552 memcpy(mac, frport->enode_mac, ETH_ALEN);2553 ret = 0;2554 kref_put(&rdata->kref, fc_rport_destroy);2555 }2556 return ret;2557}2558 2559/**2560 * fcoe_ctlr_vn_claim_notify() - handle received FIP VN2VN Claim Notification2561 * @fip: The FCoE controller2562 * @new: newly-parsed FCoE rport as a template for new rdata2563 *2564 * Called with ctlr_mutex held.2565 */2566static void fcoe_ctlr_vn_claim_notify(struct fcoe_ctlr *fip,2567 struct fcoe_rport *new)2568{2569 if (new->flags & FIP_FL_REC_OR_P2P) {2570 LIBFCOE_FIP_DBG(fip, "send probe req for P2P/REC\n");2571 fcoe_ctlr_vn_send(fip, FIP_SC_VN_PROBE_REQ, fcoe_all_vn2vn, 0);2572 return;2573 }2574 switch (fip->state) {2575 case FIP_ST_VNMP_START:2576 case FIP_ST_VNMP_PROBE1:2577 case FIP_ST_VNMP_PROBE2:2578 if (new->rdata.ids.port_id == fip->port_id) {2579 LIBFCOE_FIP_DBG(fip, "vn_claim_notify: "2580 "restart, state %d\n",2581 fip->state);2582 fcoe_ctlr_vn_restart(fip);2583 }2584 break;2585 case FIP_ST_VNMP_CLAIM:2586 case FIP_ST_VNMP_UP:2587 if (new->rdata.ids.port_id == fip->port_id) {2588 if (new->rdata.ids.port_name > fip->lp->wwpn) {2589 LIBFCOE_FIP_DBG(fip, "vn_claim_notify: "2590 "restart, port_id collision\n");2591 fcoe_ctlr_vn_restart(fip);2592 break;2593 }2594 LIBFCOE_FIP_DBG(fip, "vn_claim_notify: "2595 "send claim notify\n");2596 fcoe_ctlr_vn_send_claim(fip);2597 break;2598 }2599 LIBFCOE_FIP_DBG(fip, "vn_claim_notify: send reply to %x\n",2600 new->rdata.ids.port_id);2601 fcoe_ctlr_vn_send(fip, FIP_SC_VN_CLAIM_REP, new->enode_mac,2602 min((u32)new->fcoe_len,2603 fcoe_ctlr_fcoe_size(fip)));2604 fcoe_ctlr_vn_add(fip, new);2605 break;2606 default:2607 LIBFCOE_FIP_DBG(fip, "vn_claim_notify: "2608 "ignoring claim from %x\n",2609 new->rdata.ids.port_id);2610 break;2611 }2612}2613 2614/**2615 * fcoe_ctlr_vn_claim_resp() - handle received Claim Response2616 * @fip: The FCoE controller that received the frame2617 * @new: newly-parsed FCoE rport from the Claim Response2618 *2619 * Called with ctlr_mutex held.2620 */2621static void fcoe_ctlr_vn_claim_resp(struct fcoe_ctlr *fip,2622 struct fcoe_rport *new)2623{2624 LIBFCOE_FIP_DBG(fip, "claim resp from from rport %x - state %s\n",2625 new->rdata.ids.port_id, fcoe_ctlr_state(fip->state));2626 if (fip->state == FIP_ST_VNMP_UP || fip->state == FIP_ST_VNMP_CLAIM)2627 fcoe_ctlr_vn_add(fip, new);2628}2629 2630/**2631 * fcoe_ctlr_vn_beacon() - handle received beacon.2632 * @fip: The FCoE controller that received the frame2633 * @new: newly-parsed FCoE rport from the Beacon2634 *2635 * Called with ctlr_mutex held.2636 */2637static void fcoe_ctlr_vn_beacon(struct fcoe_ctlr *fip,2638 struct fcoe_rport *new)2639{2640 struct fc_lport *lport = fip->lp;2641 struct fc_rport_priv *rdata;2642 struct fcoe_rport *frport;2643 2644 if (new->flags & FIP_FL_REC_OR_P2P) {2645 LIBFCOE_FIP_DBG(fip, "p2p beacon while in vn2vn mode\n");2646 fcoe_ctlr_vn_send(fip, FIP_SC_VN_PROBE_REQ, fcoe_all_vn2vn, 0);2647 return;2648 }2649 rdata = fc_rport_lookup(lport, new->rdata.ids.port_id);2650 if (rdata) {2651 if (rdata->ids.node_name == new->rdata.ids.node_name &&2652 rdata->ids.port_name == new->rdata.ids.port_name) {2653 frport = fcoe_ctlr_rport(rdata);2654 2655 LIBFCOE_FIP_DBG(fip, "beacon from rport %x\n",2656 rdata->ids.port_id);2657 if (!frport->time && fip->state == FIP_ST_VNMP_UP) {2658 LIBFCOE_FIP_DBG(fip, "beacon expired "2659 "for rport %x\n",2660 rdata->ids.port_id);2661 fc_rport_login(rdata);2662 }2663 frport->time = jiffies;2664 }2665 kref_put(&rdata->kref, fc_rport_destroy);2666 return;2667 }2668 if (fip->state != FIP_ST_VNMP_UP)2669 return;2670 2671 /*2672 * Beacon from a new neighbor.2673 * Send a claim notify if one hasn't been sent recently.2674 * Don't add the neighbor yet.2675 */2676 LIBFCOE_FIP_DBG(fip, "beacon from new rport %x. sending claim notify\n",2677 new->rdata.ids.port_id);2678 if (time_after(jiffies,2679 fip->sol_time + msecs_to_jiffies(FIP_VN_ANN_WAIT)))2680 fcoe_ctlr_vn_send_claim(fip);2681}2682 2683/**2684 * fcoe_ctlr_vn_age() - Check for VN_ports without recent beacons2685 * @fip: The FCoE controller2686 *2687 * Called with ctlr_mutex held.2688 * Called only in state FIP_ST_VNMP_UP.2689 * Returns the soonest time for next age-out or a time far in the future.2690 */2691static unsigned long fcoe_ctlr_vn_age(struct fcoe_ctlr *fip)2692{2693 struct fc_lport *lport = fip->lp;2694 struct fc_rport_priv *rdata;2695 struct fcoe_rport *frport;2696 unsigned long next_time;2697 unsigned long deadline;2698 2699 next_time = jiffies + msecs_to_jiffies(FIP_VN_BEACON_INT * 10);2700 mutex_lock(&lport->disc.disc_mutex);2701 list_for_each_entry_rcu(rdata, &lport->disc.rports, peers) {2702 if (!kref_get_unless_zero(&rdata->kref))2703 continue;2704 frport = fcoe_ctlr_rport(rdata);2705 if (!frport->time) {2706 kref_put(&rdata->kref, fc_rport_destroy);2707 continue;2708 }2709 deadline = frport->time +2710 msecs_to_jiffies(FIP_VN_BEACON_INT * 25 / 10);2711 if (time_after_eq(jiffies, deadline)) {2712 frport->time = 0;2713 LIBFCOE_FIP_DBG(fip,2714 "port %16.16llx fc_id %6.6x beacon expired\n",2715 rdata->ids.port_name, rdata->ids.port_id);2716 fc_rport_logoff(rdata);2717 } else if (time_before(deadline, next_time))2718 next_time = deadline;2719 kref_put(&rdata->kref, fc_rport_destroy);2720 }2721 mutex_unlock(&lport->disc.disc_mutex);2722 return next_time;2723}2724 2725/**2726 * fcoe_ctlr_vn_recv() - Receive a FIP frame2727 * @fip: The FCoE controller that received the frame2728 * @skb: The received FIP frame2729 *2730 * Returns non-zero if the frame is dropped.2731 * Always consumes the frame.2732 */2733static int fcoe_ctlr_vn_recv(struct fcoe_ctlr *fip, struct sk_buff *skb)2734{2735 struct fip_header *fiph;2736 enum fip_vn2vn_subcode sub;2737 struct fcoe_rport frport = { };2738 int rc, vlan_id = 0;2739 2740 fiph = (struct fip_header *)skb->data;2741 sub = fiph->fip_subcode;2742 2743 if (fip->lp->vlan)2744 vlan_id = skb_vlan_tag_get_id(skb);2745 2746 if (vlan_id && vlan_id != fip->lp->vlan) {2747 LIBFCOE_FIP_DBG(fip, "vn_recv drop frame sub %x vlan %d\n",2748 sub, vlan_id);2749 rc = -EAGAIN;2750 goto drop;2751 }2752 2753 rc = fcoe_ctlr_vn_parse(fip, skb, &frport);2754 if (rc) {2755 LIBFCOE_FIP_DBG(fip, "vn_recv vn_parse error %d\n", rc);2756 goto drop;2757 }2758 2759 mutex_lock(&fip->ctlr_mutex);2760 switch (sub) {2761 case FIP_SC_VN_PROBE_REQ:2762 fcoe_ctlr_vn_probe_req(fip, &frport);2763 break;2764 case FIP_SC_VN_PROBE_REP:2765 fcoe_ctlr_vn_probe_reply(fip, &frport);2766 break;2767 case FIP_SC_VN_CLAIM_NOTIFY:2768 fcoe_ctlr_vn_claim_notify(fip, &frport);2769 break;2770 case FIP_SC_VN_CLAIM_REP:2771 fcoe_ctlr_vn_claim_resp(fip, &frport);2772 break;2773 case FIP_SC_VN_BEACON:2774 fcoe_ctlr_vn_beacon(fip, &frport);2775 break;2776 default:2777 LIBFCOE_FIP_DBG(fip, "vn_recv unknown subcode %d\n", sub);2778 rc = -1;2779 break;2780 }2781 mutex_unlock(&fip->ctlr_mutex);2782drop:2783 kfree_skb(skb);2784 return rc;2785}2786 2787/**2788 * fcoe_ctlr_vlan_parse - parse vlan discovery request or response2789 * @fip: The FCoE controller2790 * @skb: incoming packet2791 * @frport: parsed FCoE rport from the probe request2792 *2793 * Returns non-zero error number on error.2794 * Does not consume the packet.2795 */2796static int fcoe_ctlr_vlan_parse(struct fcoe_ctlr *fip,2797 struct sk_buff *skb,2798 struct fcoe_rport *frport)2799{2800 struct fip_header *fiph;2801 struct fip_desc *desc = NULL;2802 struct fip_mac_desc *macd = NULL;2803 struct fip_wwn_desc *wwn = NULL;2804 size_t rlen;2805 size_t dlen;2806 u32 desc_mask = 0;2807 u32 dtype;2808 u8 sub;2809 2810 fiph = (struct fip_header *)skb->data;2811 frport->flags = ntohs(fiph->fip_flags);2812 2813 sub = fiph->fip_subcode;2814 switch (sub) {2815 case FIP_SC_VL_REQ:2816 desc_mask = BIT(FIP_DT_MAC) | BIT(FIP_DT_NAME);2817 break;2818 default:2819 LIBFCOE_FIP_DBG(fip, "vn_parse unknown subcode %u\n", sub);2820 return -EINVAL;2821 }2822 2823 rlen = ntohs(fiph->fip_dl_len) * 4;2824 if (rlen + sizeof(*fiph) > skb->len)2825 return -EINVAL;2826 2827 desc = (struct fip_desc *)(fiph + 1);2828 while (rlen > 0) {2829 dlen = desc->fip_dlen * FIP_BPW;2830 if (dlen < sizeof(*desc) || dlen > rlen)2831 return -EINVAL;2832 2833 dtype = desc->fip_dtype;2834 if (dtype < 32) {2835 if (!(desc_mask & BIT(dtype))) {2836 LIBFCOE_FIP_DBG(fip,2837 "unexpected or duplicated desc "2838 "desc type %u in "2839 "FIP VN2VN subtype %u\n",2840 dtype, sub);2841 return -EINVAL;2842 }2843 desc_mask &= ~BIT(dtype);2844 }2845 2846 switch (dtype) {2847 case FIP_DT_MAC:2848 if (dlen != sizeof(struct fip_mac_desc))2849 goto len_err;2850 macd = (struct fip_mac_desc *)desc;2851 if (!is_valid_ether_addr(macd->fd_mac)) {2852 LIBFCOE_FIP_DBG(fip,2853 "Invalid MAC addr %pM in FIP VN2VN\n",2854 macd->fd_mac);2855 return -EINVAL;2856 }2857 memcpy(frport->enode_mac, macd->fd_mac, ETH_ALEN);2858 break;2859 case FIP_DT_NAME:2860 if (dlen != sizeof(struct fip_wwn_desc))2861 goto len_err;2862 wwn = (struct fip_wwn_desc *)desc;2863 frport->rdata.ids.node_name =2864 get_unaligned_be64(&wwn->fd_wwn);2865 break;2866 default:2867 LIBFCOE_FIP_DBG(fip, "unexpected descriptor type %x "2868 "in FIP probe\n", dtype);2869 /* standard says ignore unknown descriptors >= 128 */2870 if (dtype < FIP_DT_NON_CRITICAL)2871 return -EINVAL;2872 break;2873 }2874 desc = (struct fip_desc *)((char *)desc + dlen);2875 rlen -= dlen;2876 }2877 return 0;2878 2879len_err:2880 LIBFCOE_FIP_DBG(fip, "FIP length error in descriptor type %x len %zu\n",2881 dtype, dlen);2882 return -EINVAL;2883}2884 2885/**2886 * fcoe_ctlr_vlan_send() - Send a FIP VLAN Notification2887 * @fip: The FCoE controller2888 * @sub: sub-opcode for vlan notification or vn2vn vlan notification2889 * @dest: The destination Ethernet MAC address2890 */2891static void fcoe_ctlr_vlan_send(struct fcoe_ctlr *fip,2892 enum fip_vlan_subcode sub,2893 const u8 *dest)2894{2895 struct sk_buff *skb;2896 struct fip_vlan_notify_frame {2897 struct ethhdr eth;2898 struct fip_header fip;2899 struct fip_mac_desc mac;2900 struct fip_vlan_desc vlan;2901 } __packed * frame;2902 size_t len;2903 size_t dlen;2904 2905 len = sizeof(*frame);2906 dlen = sizeof(frame->mac) + sizeof(frame->vlan);2907 len = max(len, sizeof(struct ethhdr));2908 2909 skb = dev_alloc_skb(len);2910 if (!skb)2911 return;2912 2913 LIBFCOE_FIP_DBG(fip, "fip %s vlan notification, vlan %d\n",2914 fip->mode == FIP_MODE_VN2VN ? "vn2vn" : "fcf",2915 fip->lp->vlan);2916 2917 frame = (struct fip_vlan_notify_frame *)skb->data;2918 memset(frame, 0, len);2919 memcpy(frame->eth.h_dest, dest, ETH_ALEN);2920 2921 memcpy(frame->eth.h_source, fip->ctl_src_addr, ETH_ALEN);2922 frame->eth.h_proto = htons(ETH_P_FIP);2923 2924 frame->fip.fip_ver = FIP_VER_ENCAPS(FIP_VER);2925 frame->fip.fip_op = htons(FIP_OP_VLAN);2926 frame->fip.fip_subcode = sub;2927 frame->fip.fip_dl_len = htons(dlen / FIP_BPW);2928 2929 frame->mac.fd_desc.fip_dtype = FIP_DT_MAC;2930 frame->mac.fd_desc.fip_dlen = sizeof(frame->mac) / FIP_BPW;2931 memcpy(frame->mac.fd_mac, fip->ctl_src_addr, ETH_ALEN);2932 2933 frame->vlan.fd_desc.fip_dtype = FIP_DT_VLAN;2934 frame->vlan.fd_desc.fip_dlen = sizeof(frame->vlan) / FIP_BPW;2935 put_unaligned_be16(fip->lp->vlan, &frame->vlan.fd_vlan);2936 2937 skb_put(skb, len);2938 skb->protocol = htons(ETH_P_FIP);2939 skb->priority = fip->priority;2940 skb_reset_mac_header(skb);2941 skb_reset_network_header(skb);2942 2943 fip->send(fip, skb);2944}2945 2946/**2947 * fcoe_ctlr_vlan_disc_reply() - send FIP VLAN Discovery Notification.2948 * @fip: The FCoE controller2949 * @frport: The newly-parsed FCoE rport from the Discovery Request2950 *2951 * Called with ctlr_mutex held.2952 */2953static void fcoe_ctlr_vlan_disc_reply(struct fcoe_ctlr *fip,2954 struct fcoe_rport *frport)2955{2956 enum fip_vlan_subcode sub = FIP_SC_VL_NOTE;2957 2958 if (fip->mode == FIP_MODE_VN2VN)2959 sub = FIP_SC_VL_VN2VN_NOTE;2960 2961 fcoe_ctlr_vlan_send(fip, sub, frport->enode_mac);2962}2963 2964/**2965 * fcoe_ctlr_vlan_recv - vlan request receive handler for VN2VN mode.2966 * @fip: The FCoE controller2967 * @skb: The received FIP packet2968 */2969static int fcoe_ctlr_vlan_recv(struct fcoe_ctlr *fip, struct sk_buff *skb)2970{2971 struct fip_header *fiph;2972 enum fip_vlan_subcode sub;2973 struct fcoe_rport frport = { };2974 int rc;2975 2976 fiph = (struct fip_header *)skb->data;2977 sub = fiph->fip_subcode;2978 rc = fcoe_ctlr_vlan_parse(fip, skb, &frport);2979 if (rc) {2980 LIBFCOE_FIP_DBG(fip, "vlan_recv vlan_parse error %d\n", rc);2981 goto drop;2982 }2983 mutex_lock(&fip->ctlr_mutex);2984 if (sub == FIP_SC_VL_REQ)2985 fcoe_ctlr_vlan_disc_reply(fip, &frport);2986 mutex_unlock(&fip->ctlr_mutex);2987 2988drop:2989 kfree_skb(skb);2990 return rc;2991}2992 2993/**2994 * fcoe_ctlr_disc_recv - discovery receive handler for VN2VN mode.2995 * @lport: The local port2996 * @fp: The received frame2997 *2998 * This should never be called since we don't see RSCNs or other2999 * fabric-generated ELSes.3000 */3001static void fcoe_ctlr_disc_recv(struct fc_lport *lport, struct fc_frame *fp)3002{3003 struct fc_seq_els_data rjt_data;3004 3005 rjt_data.reason = ELS_RJT_UNSUP;3006 rjt_data.explan = ELS_EXPL_NONE;3007 fc_seq_els_rsp_send(fp, ELS_LS_RJT, &rjt_data);3008 fc_frame_free(fp);3009}3010 3011/*3012 * fcoe_ctlr_disc_start - start discovery for VN2VN mode.3013 *3014 * This sets a flag indicating that remote ports should be created3015 * and started for the peers we discover. We use the disc_callback3016 * pointer as that flag. Peers already discovered are created here.3017 *3018 * The lport lock is held during this call. The callback must be done3019 * later, without holding either the lport or discovery locks.3020 * The fcoe_ctlr lock may also be held during this call.3021 */3022static void fcoe_ctlr_disc_start(void (*callback)(struct fc_lport *,3023 enum fc_disc_event),3024 struct fc_lport *lport)3025{3026 struct fc_disc *disc = &lport->disc;3027 struct fcoe_ctlr *fip = disc->priv;3028 3029 mutex_lock(&disc->disc_mutex);3030 disc->disc_callback = callback;3031 disc->disc_id = (disc->disc_id + 2) | 1;3032 disc->pending = 1;3033 schedule_work(&fip->timer_work);3034 mutex_unlock(&disc->disc_mutex);3035}3036 3037/**3038 * fcoe_ctlr_vn_disc() - report FIP VN_port discovery results after claim state.3039 * @fip: The FCoE controller3040 *3041 * Starts the FLOGI and PLOGI login process to each discovered rport for which3042 * we've received at least one beacon.3043 * Performs the discovery complete callback.3044 */3045static void fcoe_ctlr_vn_disc(struct fcoe_ctlr *fip)3046{3047 struct fc_lport *lport = fip->lp;3048 struct fc_disc *disc = &lport->disc;3049 struct fc_rport_priv *rdata;3050 struct fcoe_rport *frport;3051 void (*callback)(struct fc_lport *, enum fc_disc_event);3052 3053 mutex_lock(&disc->disc_mutex);3054 callback = disc->pending ? disc->disc_callback : NULL;3055 disc->pending = 0;3056 list_for_each_entry_rcu(rdata, &disc->rports, peers) {3057 if (!kref_get_unless_zero(&rdata->kref))3058 continue;3059 frport = fcoe_ctlr_rport(rdata);3060 if (frport->time)3061 fc_rport_login(rdata);3062 kref_put(&rdata->kref, fc_rport_destroy);3063 }3064 mutex_unlock(&disc->disc_mutex);3065 if (callback)3066 callback(lport, DISC_EV_SUCCESS);3067}3068 3069/**3070 * fcoe_ctlr_vn_timeout - timer work function for VN2VN mode.3071 * @fip: The FCoE controller3072 */3073static void fcoe_ctlr_vn_timeout(struct fcoe_ctlr *fip)3074{3075 unsigned long next_time;3076 u8 mac[ETH_ALEN];3077 u32 new_port_id = 0;3078 3079 mutex_lock(&fip->ctlr_mutex);3080 switch (fip->state) {3081 case FIP_ST_VNMP_START:3082 fcoe_ctlr_set_state(fip, FIP_ST_VNMP_PROBE1);3083 LIBFCOE_FIP_DBG(fip, "vn_timeout: send 1st probe request\n");3084 fcoe_ctlr_vn_send(fip, FIP_SC_VN_PROBE_REQ, fcoe_all_vn2vn, 0);3085 next_time = jiffies + msecs_to_jiffies(FIP_VN_PROBE_WAIT);3086 break;3087 case FIP_ST_VNMP_PROBE1:3088 fcoe_ctlr_set_state(fip, FIP_ST_VNMP_PROBE2);3089 LIBFCOE_FIP_DBG(fip, "vn_timeout: send 2nd probe request\n");3090 fcoe_ctlr_vn_send(fip, FIP_SC_VN_PROBE_REQ, fcoe_all_vn2vn, 0);3091 next_time = jiffies + msecs_to_jiffies(FIP_VN_ANN_WAIT);3092 break;3093 case FIP_ST_VNMP_PROBE2:3094 fcoe_ctlr_set_state(fip, FIP_ST_VNMP_CLAIM);3095 new_port_id = fip->port_id;3096 hton24(mac, FIP_VN_FC_MAP);3097 hton24(mac + 3, new_port_id);3098 fcoe_ctlr_map_dest(fip);3099 fip->update_mac(fip->lp, mac);3100 LIBFCOE_FIP_DBG(fip, "vn_timeout: send claim notify\n");3101 fcoe_ctlr_vn_send_claim(fip);3102 next_time = jiffies + msecs_to_jiffies(FIP_VN_ANN_WAIT);3103 break;3104 case FIP_ST_VNMP_CLAIM:3105 /*3106 * This may be invoked either by starting discovery so don't3107 * go to the next state unless it's been long enough.3108 */3109 next_time = fip->sol_time + msecs_to_jiffies(FIP_VN_ANN_WAIT);3110 if (time_after_eq(jiffies, next_time)) {3111 fcoe_ctlr_set_state(fip, FIP_ST_VNMP_UP);3112 LIBFCOE_FIP_DBG(fip, "vn_timeout: send vn2vn beacon\n");3113 fcoe_ctlr_vn_send(fip, FIP_SC_VN_BEACON,3114 fcoe_all_vn2vn, 0);3115 next_time = jiffies + msecs_to_jiffies(FIP_VN_ANN_WAIT);3116 fip->port_ka_time = next_time;3117 }3118 fcoe_ctlr_vn_disc(fip);3119 break;3120 case FIP_ST_VNMP_UP:3121 next_time = fcoe_ctlr_vn_age(fip);3122 if (time_after_eq(jiffies, fip->port_ka_time)) {3123 LIBFCOE_FIP_DBG(fip, "vn_timeout: send vn2vn beacon\n");3124 fcoe_ctlr_vn_send(fip, FIP_SC_VN_BEACON,3125 fcoe_all_vn2vn, 0);3126 fip->port_ka_time = jiffies +3127 msecs_to_jiffies(FIP_VN_BEACON_INT +3128 get_random_u32_below(FIP_VN_BEACON_FUZZ));3129 }3130 if (time_before(fip->port_ka_time, next_time))3131 next_time = fip->port_ka_time;3132 break;3133 case FIP_ST_LINK_WAIT:3134 goto unlock;3135 default:3136 WARN(1, "unexpected state %d\n", fip->state);3137 goto unlock;3138 }3139 mod_timer(&fip->timer, next_time);3140unlock:3141 mutex_unlock(&fip->ctlr_mutex);3142 3143 /* If port ID is new, notify local port after dropping ctlr_mutex */3144 if (new_port_id)3145 fc_lport_set_local_id(fip->lp, new_port_id);3146}3147 3148/**3149 * fcoe_ctlr_mode_set() - Set or reset the ctlr's mode3150 * @lport: The local port to be (re)configured3151 * @fip: The FCoE controller whose mode is changing3152 * @fip_mode: The new fip mode3153 *3154 * Note that the we shouldn't be changing the libfc discovery settings3155 * (fc_disc_config) while an lport is going through the libfc state3156 * machine. The mode can only be changed when a fcoe_ctlr device is3157 * disabled, so that should ensure that this routine is only called3158 * when nothing is happening.3159 */3160static void fcoe_ctlr_mode_set(struct fc_lport *lport, struct fcoe_ctlr *fip,3161 enum fip_mode fip_mode)3162{3163 void *priv;3164 3165 WARN_ON(lport->state != LPORT_ST_RESET &&3166 lport->state != LPORT_ST_DISABLED);3167 3168 if (fip_mode == FIP_MODE_VN2VN) {3169 lport->rport_priv_size = sizeof(struct fcoe_rport);3170 lport->point_to_multipoint = 1;3171 lport->tt.disc_recv_req = fcoe_ctlr_disc_recv;3172 lport->tt.disc_start = fcoe_ctlr_disc_start;3173 lport->tt.disc_stop = fcoe_ctlr_disc_stop;3174 lport->tt.disc_stop_final = fcoe_ctlr_disc_stop_final;3175 priv = fip;3176 } else {3177 lport->rport_priv_size = 0;3178 lport->point_to_multipoint = 0;3179 lport->tt.disc_recv_req = NULL;3180 lport->tt.disc_start = NULL;3181 lport->tt.disc_stop = NULL;3182 lport->tt.disc_stop_final = NULL;3183 priv = lport;3184 }3185 3186 fc_disc_config(lport, priv);3187}3188 3189/**3190 * fcoe_libfc_config() - Sets up libfc related properties for local port3191 * @lport: The local port to configure libfc for3192 * @fip: The FCoE controller in use by the local port3193 * @tt: The libfc function template3194 * @init_fcp: If non-zero, the FCP portion of libfc should be initialized3195 *3196 * Returns : 0 for success3197 */3198int fcoe_libfc_config(struct fc_lport *lport, struct fcoe_ctlr *fip,3199 const struct libfc_function_template *tt, int init_fcp)3200{3201 /* Set the function pointers set by the LLDD */3202 memcpy(&lport->tt, tt, sizeof(*tt));3203 if (init_fcp && fc_fcp_init(lport))3204 return -ENOMEM;3205 fc_exch_init(lport);3206 fc_elsct_init(lport);3207 fc_lport_init(lport);3208 fc_disc_init(lport);3209 fcoe_ctlr_mode_set(lport, fip, fip->mode);3210 return 0;3211}3212EXPORT_SYMBOL_GPL(fcoe_libfc_config);3213 3214void fcoe_fcf_get_selected(struct fcoe_fcf_device *fcf_dev)3215{3216 struct fcoe_ctlr_device *ctlr_dev = fcoe_fcf_dev_to_ctlr_dev(fcf_dev);3217 struct fcoe_ctlr *fip = fcoe_ctlr_device_priv(ctlr_dev);3218 struct fcoe_fcf *fcf;3219 3220 mutex_lock(&fip->ctlr_mutex);3221 mutex_lock(&ctlr_dev->lock);3222 3223 fcf = fcoe_fcf_device_priv(fcf_dev);3224 if (fcf)3225 fcf_dev->selected = (fcf == fip->sel_fcf) ? 1 : 0;3226 else3227 fcf_dev->selected = 0;3228 3229 mutex_unlock(&ctlr_dev->lock);3230 mutex_unlock(&fip->ctlr_mutex);3231}3232EXPORT_SYMBOL(fcoe_fcf_get_selected);3233 3234void fcoe_ctlr_set_fip_mode(struct fcoe_ctlr_device *ctlr_dev)3235{3236 struct fcoe_ctlr *ctlr = fcoe_ctlr_device_priv(ctlr_dev);3237 struct fc_lport *lport = ctlr->lp;3238 3239 mutex_lock(&ctlr->ctlr_mutex);3240 switch (ctlr_dev->mode) {3241 case FIP_CONN_TYPE_VN2VN:3242 ctlr->mode = FIP_MODE_VN2VN;3243 break;3244 case FIP_CONN_TYPE_FABRIC:3245 default:3246 ctlr->mode = FIP_MODE_FABRIC;3247 break;3248 }3249 3250 mutex_unlock(&ctlr->ctlr_mutex);3251 3252 fcoe_ctlr_mode_set(lport, ctlr, ctlr->mode);3253}3254EXPORT_SYMBOL(fcoe_ctlr_set_fip_mode);3255