drivers/scsi/fcoe/fcoe_ctlr.c

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