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