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