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