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