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