root/drivers/scsi/fcoe/fcoe_ctlr.c

DEFINITIONS

1. fcoe_ctlr_state
2. fcoe_ctlr_set_state
3. fcoe_ctlr_mtu_valid
4. fcoe_ctlr_fcf_usable
5. fcoe_ctlr_map_dest
6. fcoe_ctlr_init
7. fcoe_sysfs_fcf_add
8. fcoe_sysfs_fcf_del
9. fcoe_ctlr_reset_fcfs
10. fcoe_ctlr_destroy
11. fcoe_ctlr_announce
12. fcoe_ctlr_fcoe_size
13. fcoe_ctlr_solicit
14. fcoe_ctlr_link_up
15. fcoe_ctlr_reset
16. fcoe_ctlr_link_down
17. fcoe_ctlr_send_keep_alive
18. fcoe_ctlr_encaps
19. fcoe_ctlr_els_send
20. fcoe_ctlr_age_fcfs
21. fcoe_ctlr_parse_adv
22. fcoe_ctlr_recv_adv
23. fcoe_ctlr_recv_els
24. fcoe_ctlr_recv_clr_vlink
25. fcoe_ctlr_recv
26. fcoe_ctlr_recv_handler
27. fcoe_ctlr_select
28. fcoe_ctlr_flogi_send_locked
29. fcoe_ctlr_flogi_retry
30. fcoe_ctlr_flogi_send
31. fcoe_ctlr_timeout
32. fcoe_ctlr_timer_work
33. fcoe_ctlr_recv_work
34. fcoe_ctlr_recv_flogi
35. fcoe_wwn_from_mac
36. fcoe_ctlr_rport
37. fcoe_ctlr_vn_send
38. fcoe_ctlr_vn_rport_callback
39. fcoe_ctlr_disc_stop_locked
40. fcoe_ctlr_disc_stop
41. fcoe_ctlr_disc_stop_final
42. fcoe_ctlr_vn_restart
43. fcoe_ctlr_vn_start
44. fcoe_ctlr_vn_parse
45. fcoe_ctlr_vn_send_claim
46. fcoe_ctlr_vn_probe_req
47. fcoe_ctlr_vn_probe_reply
48. fcoe_ctlr_vn_add
49. fcoe_ctlr_vn_lookup
50. fcoe_ctlr_vn_claim_notify
51. fcoe_ctlr_vn_claim_resp
52. fcoe_ctlr_vn_beacon
53. fcoe_ctlr_vn_age
54. fcoe_ctlr_vn_recv
55. fcoe_ctlr_vlan_parse
56. fcoe_ctlr_vlan_send
57. fcoe_ctlr_vlan_disc_reply
58. fcoe_ctlr_vlan_recv
59. fcoe_ctlr_disc_recv
60. fcoe_ctlr_disc_start
61. fcoe_ctlr_vn_disc
62. fcoe_ctlr_vn_timeout
63. fcoe_ctlr_mode_set
64. fcoe_libfc_config
65. fcoe_fcf_get_selected
66. fcoe_ctlr_set_fip_mode

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