]>
git.proxmox.com Git - mirror_ubuntu-artful-kernel.git/blob - drivers/scsi/fcoe/libfcoe.c
2 * Copyright (c) 2008-2009 Cisco Systems, Inc. All rights reserved.
3 * Copyright (c) 2009 Intel Corporation. All rights reserved.
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.
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
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.
18 * Maintained at www.Open-FCoE.org
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/netdevice.h>
33 #include <linux/errno.h>
34 #include <linux/bitops.h>
35 #include <net/rtnetlink.h>
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>
43 #include <scsi/libfc.h>
44 #include <scsi/libfcoe.h>
46 MODULE_AUTHOR("Open-FCoE.org");
47 MODULE_DESCRIPTION("FIP discovery protocol support for FCoE HBAs");
48 MODULE_LICENSE("GPL v2");
50 #define FCOE_CTLR_MIN_FKA 500 /* min keep alive (mS) */
51 #define FCOE_CTLR_DEF_FKA FIP_DEF_FKA /* default keep alive (mS) */
53 static void fcoe_ctlr_timeout(unsigned long);
54 static void fcoe_ctlr_link_work(struct work_struct
*);
55 static void fcoe_ctlr_recv_work(struct work_struct
*);
57 static u8 fcoe_all_fcfs
[ETH_ALEN
] = FIP_ALL_FCF_MACS
;
59 static u32 fcoe_ctlr_debug
; /* 1 for basic, 2 for noisy debug */
61 #define FIP_DBG_LVL(level, fmt, args...) \
63 if (fcoe_ctlr_debug >= (level)) \
64 FC_DBG(fmt, ##args); \
67 #define FIP_DBG(fmt, args...) FIP_DBG_LVL(1, fmt, ##args)
70 * Return non-zero if FCF fcoe_size has been validated.
72 static inline int fcoe_ctlr_mtu_valid(const struct fcoe_fcf
*fcf
)
74 return (fcf
->flags
& FIP_FL_SOL
) != 0;
78 * Return non-zero if the FCF is usable.
80 static inline int fcoe_ctlr_fcf_usable(struct fcoe_fcf
*fcf
)
82 u16 flags
= FIP_FL_SOL
| FIP_FL_AVAIL
;
84 return (fcf
->flags
& flags
) == flags
;
88 * fcoe_ctlr_init() - Initialize the FCoE Controller instance.
89 * @fip: FCoE controller.
91 void fcoe_ctlr_init(struct fcoe_ctlr
*fip
)
93 fip
->state
= FIP_ST_LINK_WAIT
;
94 INIT_LIST_HEAD(&fip
->fcfs
);
95 spin_lock_init(&fip
->lock
);
96 fip
->flogi_oxid
= FC_XID_UNKNOWN
;
97 setup_timer(&fip
->timer
, fcoe_ctlr_timeout
, (unsigned long)fip
);
98 INIT_WORK(&fip
->link_work
, fcoe_ctlr_link_work
);
99 INIT_WORK(&fip
->recv_work
, fcoe_ctlr_recv_work
);
100 skb_queue_head_init(&fip
->fip_recv_list
);
102 EXPORT_SYMBOL(fcoe_ctlr_init
);
105 * fcoe_ctlr_reset_fcfs() - Reset and free all FCFs for a controller.
106 * @fip: FCoE controller.
108 * Called with &fcoe_ctlr lock held.
110 static void fcoe_ctlr_reset_fcfs(struct fcoe_ctlr
*fip
)
112 struct fcoe_fcf
*fcf
;
113 struct fcoe_fcf
*next
;
116 list_for_each_entry_safe(fcf
, next
, &fip
->fcfs
, list
) {
117 list_del(&fcf
->list
);
125 * fcoe_ctrl_destroy() - Disable and tear-down the FCoE controller.
126 * @fip: FCoE controller.
128 * This is called by FCoE drivers before freeing the &fcoe_ctlr.
130 * The receive handler will have been deleted before this to guarantee
131 * that no more recv_work will be scheduled.
133 * The timer routine will simply return once we set FIP_ST_DISABLED.
134 * This guarantees that no further timeouts or work will be scheduled.
136 void fcoe_ctlr_destroy(struct fcoe_ctlr
*fip
)
138 flush_work(&fip
->recv_work
);
139 spin_lock_bh(&fip
->lock
);
140 fip
->state
= FIP_ST_DISABLED
;
141 fcoe_ctlr_reset_fcfs(fip
);
142 spin_unlock_bh(&fip
->lock
);
143 del_timer_sync(&fip
->timer
);
144 flush_work(&fip
->link_work
);
146 EXPORT_SYMBOL(fcoe_ctlr_destroy
);
149 * fcoe_ctlr_fcoe_size() - Return the maximum FCoE size required for VN_Port.
150 * @fip: FCoE controller.
152 * Returns the maximum packet size including the FCoE header and trailer,
153 * but not including any Ethernet or VLAN headers.
155 static inline u32
fcoe_ctlr_fcoe_size(struct fcoe_ctlr
*fip
)
158 * Determine the max FCoE frame size allowed, including
159 * FCoE header and trailer.
160 * Note: lp->mfs is currently the payload size, not the frame size.
162 return fip
->lp
->mfs
+ sizeof(struct fc_frame_header
) +
163 sizeof(struct fcoe_hdr
) + sizeof(struct fcoe_crc_eof
);
167 * fcoe_ctlr_solicit() - Send a solicitation.
168 * @fip: FCoE controller.
169 * @fcf: Destination FCF. If NULL, a multicast solicitation is sent.
171 static void fcoe_ctlr_solicit(struct fcoe_ctlr
*fip
, struct fcoe_fcf
*fcf
)
176 struct fip_header fip
;
178 struct fip_mac_desc mac
;
179 struct fip_wwn_desc wwnn
;
180 struct fip_size_desc size
;
181 } __attribute__((packed
)) desc
;
182 } __attribute__((packed
)) *sol
;
185 skb
= dev_alloc_skb(sizeof(*sol
));
189 sol
= (struct fip_sol
*)skb
->data
;
191 memset(sol
, 0, sizeof(*sol
));
192 memcpy(sol
->eth
.h_dest
, fcf
? fcf
->fcf_mac
: fcoe_all_fcfs
, ETH_ALEN
);
193 memcpy(sol
->eth
.h_source
, fip
->ctl_src_addr
, ETH_ALEN
);
194 sol
->eth
.h_proto
= htons(ETH_P_FIP
);
196 sol
->fip
.fip_ver
= FIP_VER_ENCAPS(FIP_VER
);
197 sol
->fip
.fip_op
= htons(FIP_OP_DISC
);
198 sol
->fip
.fip_subcode
= FIP_SC_SOL
;
199 sol
->fip
.fip_dl_len
= htons(sizeof(sol
->desc
) / FIP_BPW
);
200 sol
->fip
.fip_flags
= htons(FIP_FL_FPMA
);
202 sol
->desc
.mac
.fd_desc
.fip_dtype
= FIP_DT_MAC
;
203 sol
->desc
.mac
.fd_desc
.fip_dlen
= sizeof(sol
->desc
.mac
) / FIP_BPW
;
204 memcpy(sol
->desc
.mac
.fd_mac
, fip
->ctl_src_addr
, ETH_ALEN
);
206 sol
->desc
.wwnn
.fd_desc
.fip_dtype
= FIP_DT_NAME
;
207 sol
->desc
.wwnn
.fd_desc
.fip_dlen
= sizeof(sol
->desc
.wwnn
) / FIP_BPW
;
208 put_unaligned_be64(fip
->lp
->wwnn
, &sol
->desc
.wwnn
.fd_wwn
);
210 fcoe_size
= fcoe_ctlr_fcoe_size(fip
);
211 sol
->desc
.size
.fd_desc
.fip_dtype
= FIP_DT_FCOE_SIZE
;
212 sol
->desc
.size
.fd_desc
.fip_dlen
= sizeof(sol
->desc
.size
) / FIP_BPW
;
213 sol
->desc
.size
.fd_size
= htons(fcoe_size
);
215 skb_put(skb
, sizeof(*sol
));
216 skb
->protocol
= htons(ETH_P_802_3
);
217 skb_reset_mac_header(skb
);
218 skb_reset_network_header(skb
);
222 fip
->sol_time
= jiffies
;
226 * fcoe_ctlr_link_up() - Start FCoE controller.
227 * @fip: FCoE controller.
229 * Called from the LLD when the network link is ready.
231 void fcoe_ctlr_link_up(struct fcoe_ctlr
*fip
)
233 spin_lock_bh(&fip
->lock
);
234 if (fip
->state
== FIP_ST_NON_FIP
|| fip
->state
== FIP_ST_AUTO
) {
237 spin_unlock_bh(&fip
->lock
);
239 } else if (fip
->state
== FIP_ST_LINK_WAIT
) {
240 fip
->state
= FIP_ST_AUTO
;
243 spin_unlock_bh(&fip
->lock
);
244 FIP_DBG("%s", "setting AUTO mode.\n");
246 fcoe_ctlr_solicit(fip
, NULL
);
248 spin_unlock_bh(&fip
->lock
);
250 EXPORT_SYMBOL(fcoe_ctlr_link_up
);
253 * fcoe_ctlr_reset() - Reset FIP.
254 * @fip: FCoE controller.
255 * @new_state: FIP state to be entered.
257 * Returns non-zero if the link was up and now isn't.
259 static int fcoe_ctlr_reset(struct fcoe_ctlr
*fip
, enum fip_state new_state
)
261 struct fc_lport
*lp
= fip
->lp
;
264 spin_lock_bh(&fip
->lock
);
265 fcoe_ctlr_reset_fcfs(fip
);
266 del_timer(&fip
->timer
);
267 fip
->state
= new_state
;
268 fip
->ctlr_ka_time
= 0;
269 fip
->port_ka_time
= 0;
271 fip
->flogi_oxid
= FC_XID_UNKNOWN
;
274 link_dropped
= fip
->link
;
276 spin_unlock_bh(&fip
->lock
);
281 if (new_state
== FIP_ST_ENABLED
) {
282 fcoe_ctlr_solicit(fip
, NULL
);
290 * fcoe_ctlr_link_down() - Stop FCoE controller.
291 * @fip: FCoE controller.
293 * Returns non-zero if the link was up and now isn't.
295 * Called from the LLD when the network link is not ready.
296 * There may be multiple calls while the link is down.
298 int fcoe_ctlr_link_down(struct fcoe_ctlr
*fip
)
300 return fcoe_ctlr_reset(fip
, FIP_ST_LINK_WAIT
);
302 EXPORT_SYMBOL(fcoe_ctlr_link_down
);
305 * fcoe_ctlr_send_keep_alive() - Send a keep-alive to the selected FCF.
306 * @fip: FCoE controller.
307 * @ports: 0 for controller keep-alive, 1 for port keep-alive.
308 * @sa: source MAC address.
310 * A controller keep-alive is sent every fka_period (typically 8 seconds).
311 * The source MAC is the native MAC address.
313 * A port keep-alive is sent every 90 seconds while logged in.
314 * The source MAC is the assigned mapped source address.
315 * The destination is the FCF's F-port.
317 static void fcoe_ctlr_send_keep_alive(struct fcoe_ctlr
*fip
, int ports
, u8
*sa
)
322 struct fip_header fip
;
323 struct fip_mac_desc mac
;
324 } __attribute__((packed
)) *kal
;
325 struct fip_vn_desc
*vn
;
328 struct fcoe_fcf
*fcf
;
332 if (!fcf
|| !fc_host_port_id(lp
->host
))
335 len
= fcoe_ctlr_fcoe_size(fip
) + sizeof(struct ethhdr
);
336 BUG_ON(len
< sizeof(*kal
) + sizeof(*vn
));
337 skb
= dev_alloc_skb(len
);
341 kal
= (struct fip_kal
*)skb
->data
;
343 memcpy(kal
->eth
.h_dest
, fcf
->fcf_mac
, ETH_ALEN
);
344 memcpy(kal
->eth
.h_source
, sa
, ETH_ALEN
);
345 kal
->eth
.h_proto
= htons(ETH_P_FIP
);
347 kal
->fip
.fip_ver
= FIP_VER_ENCAPS(FIP_VER
);
348 kal
->fip
.fip_op
= htons(FIP_OP_CTRL
);
349 kal
->fip
.fip_subcode
= FIP_SC_KEEP_ALIVE
;
350 kal
->fip
.fip_dl_len
= htons((sizeof(kal
->mac
) +
351 ports
* sizeof(*vn
)) / FIP_BPW
);
352 kal
->fip
.fip_flags
= htons(FIP_FL_FPMA
);
354 kal
->mac
.fd_desc
.fip_dtype
= FIP_DT_MAC
;
355 kal
->mac
.fd_desc
.fip_dlen
= sizeof(kal
->mac
) / FIP_BPW
;
356 memcpy(kal
->mac
.fd_mac
, fip
->ctl_src_addr
, ETH_ALEN
);
359 vn
= (struct fip_vn_desc
*)(kal
+ 1);
360 vn
->fd_desc
.fip_dtype
= FIP_DT_VN_ID
;
361 vn
->fd_desc
.fip_dlen
= sizeof(*vn
) / FIP_BPW
;
362 memcpy(vn
->fd_mac
, fip
->data_src_addr
, ETH_ALEN
);
363 hton24(vn
->fd_fc_id
, fc_host_port_id(lp
->host
));
364 put_unaligned_be64(lp
->wwpn
, &vn
->fd_wwpn
);
368 skb
->protocol
= htons(ETH_P_802_3
);
369 skb_reset_mac_header(skb
);
370 skb_reset_network_header(skb
);
375 * fcoe_ctlr_encaps() - Encapsulate an ELS frame for FIP, without sending it.
376 * @fip: FCoE controller.
377 * @dtype: FIP descriptor type for the frame.
378 * @skb: FCoE ELS frame including FC header but no FCoE headers.
380 * Returns non-zero error code on failure.
382 * The caller must check that the length is a multiple of 4.
384 * The @skb must have enough headroom (28 bytes) and tailroom (8 bytes).
385 * Headroom includes the FIP encapsulation description, FIP header, and
386 * Ethernet header. The tailroom is for the FIP MAC descriptor.
388 static int fcoe_ctlr_encaps(struct fcoe_ctlr
*fip
,
389 u8 dtype
, struct sk_buff
*skb
)
391 struct fip_encaps_head
{
393 struct fip_header fip
;
394 struct fip_encaps encaps
;
395 } __attribute__((packed
)) *cap
;
396 struct fip_mac_desc
*mac
;
397 struct fcoe_fcf
*fcf
;
403 dlen
= sizeof(struct fip_encaps
) + skb
->len
; /* len before push */
404 cap
= (struct fip_encaps_head
*)skb_push(skb
, sizeof(*cap
));
406 memset(cap
, 0, sizeof(*cap
));
407 memcpy(cap
->eth
.h_dest
, fcf
->fcf_mac
, ETH_ALEN
);
408 memcpy(cap
->eth
.h_source
, fip
->ctl_src_addr
, ETH_ALEN
);
409 cap
->eth
.h_proto
= htons(ETH_P_FIP
);
411 cap
->fip
.fip_ver
= FIP_VER_ENCAPS(FIP_VER
);
412 cap
->fip
.fip_op
= htons(FIP_OP_LS
);
413 cap
->fip
.fip_subcode
= FIP_SC_REQ
;
414 cap
->fip
.fip_dl_len
= htons((dlen
+ sizeof(*mac
)) / FIP_BPW
);
415 cap
->fip
.fip_flags
= htons(FIP_FL_FPMA
);
417 cap
->encaps
.fd_desc
.fip_dtype
= dtype
;
418 cap
->encaps
.fd_desc
.fip_dlen
= dlen
/ FIP_BPW
;
420 mac
= (struct fip_mac_desc
*)skb_put(skb
, sizeof(*mac
));
421 memset(mac
, 0, sizeof(mac
));
422 mac
->fd_desc
.fip_dtype
= FIP_DT_MAC
;
423 mac
->fd_desc
.fip_dlen
= sizeof(*mac
) / FIP_BPW
;
424 if (dtype
!= ELS_FLOGI
)
425 memcpy(mac
->fd_mac
, fip
->data_src_addr
, ETH_ALEN
);
427 skb
->protocol
= htons(ETH_P_802_3
);
428 skb_reset_mac_header(skb
);
429 skb_reset_network_header(skb
);
434 * fcoe_ctlr_els_send() - Send an ELS frame encapsulated by FIP if appropriate.
435 * @fip: FCoE controller.
436 * @skb: FCoE ELS frame including FC header but no FCoE headers.
438 * Returns a non-zero error code if the frame should not be sent.
439 * Returns zero if the caller should send the frame with FCoE encapsulation.
441 * The caller must check that the length is a multiple of 4.
442 * The SKB must have enough headroom (28 bytes) and tailroom (8 bytes).
444 int fcoe_ctlr_els_send(struct fcoe_ctlr
*fip
, struct sk_buff
*skb
)
446 struct fc_frame_header
*fh
;
450 if (fip
->state
== FIP_ST_NON_FIP
)
453 fh
= (struct fc_frame_header
*)skb
->data
;
454 op
= *(u8
*)(fh
+ 1);
458 old_xid
= fip
->flogi_oxid
;
459 fip
->flogi_oxid
= ntohs(fh
->fh_ox_id
);
460 if (fip
->state
== FIP_ST_AUTO
) {
461 if (old_xid
== FC_XID_UNKNOWN
)
462 fip
->flogi_count
= 0;
464 if (fip
->flogi_count
< 3)
472 if (ntoh24(fh
->fh_s_id
))
477 if (fip
->state
!= FIP_ST_ENABLED
)
479 if (ntoh24(fh
->fh_d_id
) != FC_FID_FLOGI
)
484 if (fip
->flogi_oxid
== FC_XID_UNKNOWN
)
486 if (!ntoh24(fh
->fh_s_id
))
488 if (fip
->state
== FIP_ST_AUTO
)
491 * Here we must've gotten an SID by accepting an FLOGI
492 * from a point-to-point connection. Switch to using
493 * the source mac based on the SID. The destination
494 * MAC in this case would have been set by receving the
497 fip
->flogi_oxid
= FC_XID_UNKNOWN
;
498 fc_fcoe_set_mac(fip
->data_src_addr
, fh
->fh_s_id
);
501 if (fip
->state
!= FIP_ST_ENABLED
)
505 if (fcoe_ctlr_encaps(fip
, op
, skb
))
513 EXPORT_SYMBOL(fcoe_ctlr_els_send
);
516 * fcoe_ctlr_age_fcfs() - Reset and free all old FCFs for a controller.
517 * @fip: FCoE controller.
519 * Called with lock held.
521 * An FCF is considered old if we have missed three advertisements.
522 * That is, there have been no valid advertisement from it for three
523 * times its keep-alive period including fuzz.
525 * In addition, determine the time when an FCF selection can occur.
527 static void fcoe_ctlr_age_fcfs(struct fcoe_ctlr
*fip
)
529 struct fcoe_fcf
*fcf
;
530 struct fcoe_fcf
*next
;
531 unsigned long sel_time
= 0;
533 list_for_each_entry_safe(fcf
, next
, &fip
->fcfs
, list
) {
534 if (time_after(jiffies
, fcf
->time
+ fcf
->fka_period
* 3 +
535 msecs_to_jiffies(FIP_FCF_FUZZ
* 3))) {
536 if (fip
->sel_fcf
== fcf
)
538 list_del(&fcf
->list
);
539 WARN_ON(!fip
->fcf_count
);
542 } else if (fcoe_ctlr_mtu_valid(fcf
) &&
543 (!sel_time
|| time_before(sel_time
, fcf
->time
))) {
544 sel_time
= fcf
->time
;
548 sel_time
+= msecs_to_jiffies(FCOE_CTLR_START_DELAY
);
549 fip
->sel_time
= sel_time
;
550 if (time_before(sel_time
, fip
->timer
.expires
))
551 mod_timer(&fip
->timer
, sel_time
);
558 * fcoe_ctlr_parse_adv() - Decode a FIP advertisement into a new FCF entry.
559 * @skb: received FIP advertisement frame
560 * @fcf: resulting FCF entry.
562 * Returns zero on a valid parsed advertisement,
563 * otherwise returns non zero value.
565 static int fcoe_ctlr_parse_adv(struct sk_buff
*skb
, struct fcoe_fcf
*fcf
)
567 struct fip_header
*fiph
;
568 struct fip_desc
*desc
= NULL
;
569 struct fip_wwn_desc
*wwn
;
570 struct fip_fab_desc
*fab
;
571 struct fip_fka_desc
*fka
;
576 memset(fcf
, 0, sizeof(*fcf
));
577 fcf
->fka_period
= msecs_to_jiffies(FCOE_CTLR_DEF_FKA
);
579 fiph
= (struct fip_header
*)skb
->data
;
580 fcf
->flags
= ntohs(fiph
->fip_flags
);
582 rlen
= ntohs(fiph
->fip_dl_len
) * 4;
583 if (rlen
+ sizeof(*fiph
) > skb
->len
)
586 desc
= (struct fip_desc
*)(fiph
+ 1);
588 dlen
= desc
->fip_dlen
* FIP_BPW
;
589 if (dlen
< sizeof(*desc
) || dlen
> rlen
)
591 switch (desc
->fip_dtype
) {
593 if (dlen
!= sizeof(struct fip_pri_desc
))
595 fcf
->pri
= ((struct fip_pri_desc
*)desc
)->fd_pri
;
598 if (dlen
!= sizeof(struct fip_mac_desc
))
601 ((struct fip_mac_desc
*)desc
)->fd_mac
,
603 if (!is_valid_ether_addr(fcf
->fcf_mac
)) {
604 FIP_DBG("invalid MAC addr in FIP adv\n");
609 if (dlen
!= sizeof(struct fip_wwn_desc
))
611 wwn
= (struct fip_wwn_desc
*)desc
;
612 fcf
->switch_name
= get_unaligned_be64(&wwn
->fd_wwn
);
615 if (dlen
!= sizeof(struct fip_fab_desc
))
617 fab
= (struct fip_fab_desc
*)desc
;
618 fcf
->fabric_name
= get_unaligned_be64(&fab
->fd_wwn
);
619 fcf
->vfid
= ntohs(fab
->fd_vfid
);
620 fcf
->fc_map
= ntoh24(fab
->fd_map
);
623 if (dlen
!= sizeof(struct fip_fka_desc
))
625 fka
= (struct fip_fka_desc
*)desc
;
626 t
= ntohl(fka
->fd_fka_period
);
627 if (t
>= FCOE_CTLR_MIN_FKA
)
628 fcf
->fka_period
= msecs_to_jiffies(t
);
631 case FIP_DT_FCOE_SIZE
:
637 FIP_DBG("unexpected descriptor type %x in FIP adv\n",
639 /* standard says ignore unknown descriptors >= 128 */
640 if (desc
->fip_dtype
< FIP_DT_VENDOR_BASE
)
644 desc
= (struct fip_desc
*)((char *)desc
+ dlen
);
647 if (!fcf
->fc_map
|| (fcf
->fc_map
& 0x10000))
649 if (!fcf
->switch_name
|| !fcf
->fabric_name
)
654 FIP_DBG("FIP length error in descriptor type %x len %zu\n",
655 desc
->fip_dtype
, dlen
);
660 * fcoe_ctlr_recv_adv() - Handle an incoming advertisement.
661 * @fip: FCoE controller.
662 * @skb: Received FIP packet.
664 static void fcoe_ctlr_recv_adv(struct fcoe_ctlr
*fip
, struct sk_buff
*skb
)
666 struct fcoe_fcf
*fcf
;
668 struct fcoe_fcf
*found
;
669 unsigned long sol_tov
= msecs_to_jiffies(FCOE_CTRL_SOL_TOV
);
673 if (fcoe_ctlr_parse_adv(skb
, &new))
676 spin_lock_bh(&fip
->lock
);
677 first
= list_empty(&fip
->fcfs
);
679 list_for_each_entry(fcf
, &fip
->fcfs
, list
) {
680 if (fcf
->switch_name
== new.switch_name
&&
681 fcf
->fabric_name
== new.fabric_name
&&
682 fcf
->fc_map
== new.fc_map
&&
683 compare_ether_addr(fcf
->fcf_mac
, new.fcf_mac
) == 0) {
689 if (fip
->fcf_count
>= FCOE_CTLR_FCF_LIMIT
)
692 fcf
= kmalloc(sizeof(*fcf
), GFP_ATOMIC
);
697 memcpy(fcf
, &new, sizeof(new));
698 list_add(&fcf
->list
, &fip
->fcfs
);
701 * Flags in advertisements are ignored once the FCF is
702 * selected. Flags in unsolicited advertisements are
703 * ignored after a usable solicited advertisement
706 if (fcf
== fip
->sel_fcf
) {
707 fip
->ctlr_ka_time
-= fcf
->fka_period
;
708 fip
->ctlr_ka_time
+= new.fka_period
;
709 if (time_before(fip
->ctlr_ka_time
, fip
->timer
.expires
))
710 mod_timer(&fip
->timer
, fip
->ctlr_ka_time
);
711 } else if (!fcoe_ctlr_fcf_usable(fcf
))
712 fcf
->flags
= new.flags
;
713 fcf
->fka_period
= new.fka_period
;
714 memcpy(fcf
->fcf_mac
, new.fcf_mac
, ETH_ALEN
);
716 mtu_valid
= fcoe_ctlr_mtu_valid(fcf
);
718 FIP_DBG_LVL(found
? 2 : 1, "%s FCF for fab %llx map %x val %d\n",
719 found
? "old" : "new",
720 fcf
->fabric_name
, fcf
->fc_map
, mtu_valid
);
723 * If this advertisement is not solicited and our max receive size
724 * hasn't been verified, send a solicited advertisement.
727 fcoe_ctlr_solicit(fip
, fcf
);
730 * If its been a while since we did a solicit, and this is
731 * the first advertisement we've received, do a multicast
732 * solicitation to gather as many advertisements as we can
733 * before selection occurs.
735 if (first
&& time_after(jiffies
, fip
->sol_time
+ sol_tov
))
736 fcoe_ctlr_solicit(fip
, NULL
);
739 * If this is the first validated FCF, note the time and
740 * set a timer to trigger selection.
742 if (mtu_valid
&& !fip
->sel_time
&& fcoe_ctlr_fcf_usable(fcf
)) {
743 fip
->sel_time
= jiffies
+
744 msecs_to_jiffies(FCOE_CTLR_START_DELAY
);
745 if (!timer_pending(&fip
->timer
) ||
746 time_before(fip
->sel_time
, fip
->timer
.expires
))
747 mod_timer(&fip
->timer
, fip
->sel_time
);
750 spin_unlock_bh(&fip
->lock
);
754 * fcoe_ctlr_recv_els() - Handle an incoming FIP-encapsulated ELS frame.
755 * @fip: FCoE controller.
756 * @skb: Received FIP packet.
758 static void fcoe_ctlr_recv_els(struct fcoe_ctlr
*fip
, struct sk_buff
*skb
)
760 struct fc_lport
*lp
= fip
->lp
;
761 struct fip_header
*fiph
;
763 struct fc_frame_header
*fh
= NULL
;
764 struct fip_desc
*desc
;
765 struct fip_encaps
*els
;
766 struct fcoe_dev_stats
*stats
;
767 enum fip_desc_type els_dtype
= 0;
770 u8 granted_mac
[ETH_ALEN
] = { 0 };
775 fiph
= (struct fip_header
*)skb
->data
;
776 sub
= fiph
->fip_subcode
;
777 if (sub
!= FIP_SC_REQ
&& sub
!= FIP_SC_REP
)
780 rlen
= ntohs(fiph
->fip_dl_len
) * 4;
781 if (rlen
+ sizeof(*fiph
) > skb
->len
)
784 desc
= (struct fip_desc
*)(fiph
+ 1);
786 dlen
= desc
->fip_dlen
* FIP_BPW
;
787 if (dlen
< sizeof(*desc
) || dlen
> rlen
)
789 switch (desc
->fip_dtype
) {
791 if (dlen
!= sizeof(struct fip_mac_desc
))
794 ((struct fip_mac_desc
*)desc
)->fd_mac
,
796 if (!is_valid_ether_addr(granted_mac
)) {
797 FIP_DBG("invalid MAC addrs in FIP ELS\n");
807 if (dlen
< sizeof(*els
) + sizeof(*fh
) + 1)
809 els_len
= dlen
- sizeof(*els
);
810 els
= (struct fip_encaps
*)desc
;
811 fh
= (struct fc_frame_header
*)(els
+ 1);
812 els_dtype
= desc
->fip_dtype
;
815 FIP_DBG("unexpected descriptor type %x "
816 "in FIP adv\n", desc
->fip_dtype
);
817 /* standard says ignore unknown descriptors >= 128 */
818 if (desc
->fip_dtype
< FIP_DT_VENDOR_BASE
)
822 desc
= (struct fip_desc
*)((char *)desc
+ dlen
);
828 els_op
= *(u8
*)(fh
+ 1);
830 if (els_dtype
== FIP_DT_FLOGI
&& sub
== FIP_SC_REP
&&
831 fip
->flogi_oxid
== ntohs(fh
->fh_ox_id
) &&
832 els_op
== ELS_LS_ACC
&& is_valid_ether_addr(granted_mac
)) {
833 fip
->flogi_oxid
= FC_XID_UNKNOWN
;
834 fip
->update_mac(fip
, fip
->data_src_addr
, granted_mac
);
835 memcpy(fip
->data_src_addr
, granted_mac
, ETH_ALEN
);
839 * Convert skb into an fc_frame containing only the ELS.
841 skb_pull(skb
, (u8
*)fh
- skb
->data
);
842 skb_trim(skb
, els_len
);
843 fp
= (struct fc_frame
*)skb
;
845 fr_sof(fp
) = FC_SOF_I3
;
846 fr_eof(fp
) = FC_EOF_T
;
849 stats
= fc_lport_get_stats(lp
);
851 stats
->RxWords
+= skb
->len
/ FIP_BPW
;
853 fc_exch_recv(lp
, lp
->emp
, fp
);
857 FIP_DBG("FIP length error in descriptor type %x len %zu\n",
858 desc
->fip_dtype
, dlen
);
864 * fcoe_ctlr_recv_els() - Handle an incoming link reset frame.
865 * @fip: FCoE controller.
866 * @fh: Received FIP header.
868 * There may be multiple VN_Port descriptors.
869 * The overall length has already been checked.
871 static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr
*fip
,
872 struct fip_header
*fh
)
874 struct fip_desc
*desc
;
875 struct fip_mac_desc
*mp
;
876 struct fip_wwn_desc
*wp
;
877 struct fip_vn_desc
*vp
;
880 struct fcoe_fcf
*fcf
= fip
->sel_fcf
;
881 struct fc_lport
*lp
= fip
->lp
;
884 FIP_DBG("Clear Virtual Link received\n");
887 if (!fcf
|| !fc_host_port_id(lp
->host
))
891 * mask of required descriptors. Validating each one clears its bit.
893 desc_mask
= BIT(FIP_DT_MAC
) | BIT(FIP_DT_NAME
) | BIT(FIP_DT_VN_ID
);
895 rlen
= ntohs(fh
->fip_dl_len
) * FIP_BPW
;
896 desc
= (struct fip_desc
*)(fh
+ 1);
897 while (rlen
>= sizeof(*desc
)) {
898 dlen
= desc
->fip_dlen
* FIP_BPW
;
901 switch (desc
->fip_dtype
) {
903 mp
= (struct fip_mac_desc
*)desc
;
904 if (dlen
< sizeof(*mp
))
906 if (compare_ether_addr(mp
->fd_mac
, fcf
->fcf_mac
))
908 desc_mask
&= ~BIT(FIP_DT_MAC
);
911 wp
= (struct fip_wwn_desc
*)desc
;
912 if (dlen
< sizeof(*wp
))
914 if (get_unaligned_be64(&wp
->fd_wwn
) != fcf
->switch_name
)
916 desc_mask
&= ~BIT(FIP_DT_NAME
);
919 vp
= (struct fip_vn_desc
*)desc
;
920 if (dlen
< sizeof(*vp
))
922 if (compare_ether_addr(vp
->fd_mac
,
923 fip
->data_src_addr
) == 0 &&
924 get_unaligned_be64(&vp
->fd_wwpn
) == lp
->wwpn
&&
925 ntoh24(vp
->fd_fc_id
) == fc_host_port_id(lp
->host
))
926 desc_mask
&= ~BIT(FIP_DT_VN_ID
);
929 /* standard says ignore unknown descriptors >= 128 */
930 if (desc
->fip_dtype
< FIP_DT_VENDOR_BASE
)
934 desc
= (struct fip_desc
*)((char *)desc
+ dlen
);
939 * reset only if all required descriptors were present and valid.
942 FIP_DBG("missing descriptors mask %x\n", desc_mask
);
944 FIP_DBG("performing Clear Virtual Link\n");
945 fcoe_ctlr_reset(fip
, FIP_ST_ENABLED
);
950 * fcoe_ctlr_recv() - Receive a FIP frame.
951 * @fip: FCoE controller.
952 * @skb: Received FIP packet.
954 * This is called from NET_RX_SOFTIRQ.
956 void fcoe_ctlr_recv(struct fcoe_ctlr
*fip
, struct sk_buff
*skb
)
958 spin_lock_bh(&fip
->fip_recv_list
.lock
);
959 __skb_queue_tail(&fip
->fip_recv_list
, skb
);
960 spin_unlock_bh(&fip
->fip_recv_list
.lock
);
961 schedule_work(&fip
->recv_work
);
963 EXPORT_SYMBOL(fcoe_ctlr_recv
);
966 * fcoe_ctlr_recv_handler() - Receive a FIP frame.
967 * @fip: FCoE controller.
968 * @skb: Received FIP packet.
970 * Returns non-zero if the frame is dropped.
972 static int fcoe_ctlr_recv_handler(struct fcoe_ctlr
*fip
, struct sk_buff
*skb
)
974 struct fip_header
*fiph
;
976 enum fip_state state
;
980 if (skb_linearize(skb
))
982 if (skb
->len
< sizeof(*fiph
))
985 if (compare_ether_addr(eh
->h_dest
, fip
->ctl_src_addr
) &&
986 compare_ether_addr(eh
->h_dest
, FIP_ALL_ENODE_MACS
))
988 fiph
= (struct fip_header
*)skb
->data
;
989 op
= ntohs(fiph
->fip_op
);
990 sub
= fiph
->fip_subcode
;
992 FIP_DBG_LVL(2, "ver %x op %x/%x dl %x fl %x\n",
993 FIP_VER_DECAPS(fiph
->fip_ver
), op
, sub
,
994 ntohs(fiph
->fip_dl_len
), ntohs(fiph
->fip_flags
));
996 if (FIP_VER_DECAPS(fiph
->fip_ver
) != FIP_VER
)
998 if (ntohs(fiph
->fip_dl_len
) * FIP_BPW
+ sizeof(*fiph
) > skb
->len
)
1001 spin_lock_bh(&fip
->lock
);
1003 if (state
== FIP_ST_AUTO
) {
1005 fip
->state
= FIP_ST_ENABLED
;
1006 state
= FIP_ST_ENABLED
;
1007 FIP_DBG("using FIP mode\n");
1009 spin_unlock_bh(&fip
->lock
);
1010 if (state
!= FIP_ST_ENABLED
)
1013 if (op
== FIP_OP_LS
) {
1014 fcoe_ctlr_recv_els(fip
, skb
); /* consumes skb */
1017 if (op
== FIP_OP_DISC
&& sub
== FIP_SC_ADV
)
1018 fcoe_ctlr_recv_adv(fip
, skb
);
1019 else if (op
== FIP_OP_CTRL
&& sub
== FIP_SC_CLR_VLINK
)
1020 fcoe_ctlr_recv_clr_vlink(fip
, fiph
);
1029 * fcoe_ctlr_select() - Select the best FCF, if possible.
1030 * @fip: FCoE controller.
1032 * If there are conflicting advertisements, no FCF can be chosen.
1034 * Called with lock held.
1036 static void fcoe_ctlr_select(struct fcoe_ctlr
*fip
)
1038 struct fcoe_fcf
*fcf
;
1039 struct fcoe_fcf
*best
= NULL
;
1041 list_for_each_entry(fcf
, &fip
->fcfs
, list
) {
1042 FIP_DBG("consider FCF for fab %llx VFID %d map %x val %d\n",
1043 fcf
->fabric_name
, fcf
->vfid
,
1044 fcf
->fc_map
, fcoe_ctlr_mtu_valid(fcf
));
1045 if (!fcoe_ctlr_fcf_usable(fcf
)) {
1046 FIP_DBG("FCF for fab %llx map %x %svalid %savailable\n",
1047 fcf
->fabric_name
, fcf
->fc_map
,
1048 (fcf
->flags
& FIP_FL_SOL
) ? "" : "in",
1049 (fcf
->flags
& FIP_FL_AVAIL
) ? "" : "un");
1056 if (fcf
->fabric_name
!= best
->fabric_name
||
1057 fcf
->vfid
!= best
->vfid
||
1058 fcf
->fc_map
!= best
->fc_map
) {
1059 FIP_DBG("conflicting fabric, VFID, or FC-MAP\n");
1062 if (fcf
->pri
< best
->pri
)
1065 fip
->sel_fcf
= best
;
1069 * fcoe_ctlr_timeout() - FIP timer function.
1070 * @arg: &fcoe_ctlr pointer.
1072 * Ages FCFs. Triggers FCF selection if possible. Sends keep-alives.
1074 static void fcoe_ctlr_timeout(unsigned long arg
)
1076 struct fcoe_ctlr
*fip
= (struct fcoe_ctlr
*)arg
;
1077 struct fcoe_fcf
*sel
;
1078 struct fcoe_fcf
*fcf
;
1079 unsigned long next_timer
= jiffies
+ msecs_to_jiffies(FIP_VN_KA_PERIOD
);
1080 DECLARE_MAC_BUF(buf
);
1084 spin_lock_bh(&fip
->lock
);
1085 if (fip
->state
== FIP_ST_DISABLED
) {
1086 spin_unlock_bh(&fip
->lock
);
1091 fcoe_ctlr_age_fcfs(fip
);
1094 if (!sel
&& fip
->sel_time
&& time_after_eq(jiffies
, fip
->sel_time
)) {
1095 fcoe_ctlr_select(fip
);
1101 fcf
= sel
; /* the old FCF may have been freed */
1103 printk(KERN_INFO
"host%d: FIP selected "
1104 "Fibre-Channel Forwarder MAC %s\n",
1105 fip
->lp
->host
->host_no
,
1106 print_mac(buf
, sel
->fcf_mac
));
1107 memcpy(fip
->dest_addr
, sel
->fcf_mac
, ETH_ALEN
);
1108 fip
->port_ka_time
= jiffies
+
1109 msecs_to_jiffies(FIP_VN_KA_PERIOD
);
1110 fip
->ctlr_ka_time
= jiffies
+ sel
->fka_period
;
1113 printk(KERN_NOTICE
"host%d: "
1114 "FIP Fibre-Channel Forwarder timed out. "
1115 "Starting FCF discovery.\n",
1116 fip
->lp
->host
->host_no
);
1119 schedule_work(&fip
->link_work
);
1125 if (time_after_eq(jiffies
, fip
->ctlr_ka_time
)) {
1126 fip
->ctlr_ka_time
= jiffies
+ sel
->fka_period
;
1129 if (time_after(next_timer
, fip
->ctlr_ka_time
))
1130 next_timer
= fip
->ctlr_ka_time
;
1132 if (time_after_eq(jiffies
, fip
->port_ka_time
)) {
1133 fip
->port_ka_time
+= jiffies
+
1134 msecs_to_jiffies(FIP_VN_KA_PERIOD
);
1137 if (time_after(next_timer
, fip
->port_ka_time
))
1138 next_timer
= fip
->port_ka_time
;
1139 mod_timer(&fip
->timer
, next_timer
);
1140 } else if (fip
->sel_time
) {
1141 next_timer
= fip
->sel_time
+
1142 msecs_to_jiffies(FCOE_CTLR_START_DELAY
);
1143 mod_timer(&fip
->timer
, next_timer
);
1145 spin_unlock_bh(&fip
->lock
);
1148 fcoe_ctlr_send_keep_alive(fip
, 0, fip
->ctl_src_addr
);
1150 fcoe_ctlr_send_keep_alive(fip
, 1, fip
->data_src_addr
);
1154 * fcoe_ctlr_link_work() - worker thread function for link changes.
1155 * @work: pointer to link_work member inside &fcoe_ctlr.
1157 * See if the link status has changed and if so, report it.
1159 * This is here because fc_linkup() and fc_linkdown() must not
1160 * be called from the timer directly, since they use a mutex.
1162 static void fcoe_ctlr_link_work(struct work_struct
*work
)
1164 struct fcoe_ctlr
*fip
;
1168 fip
= container_of(work
, struct fcoe_ctlr
, link_work
);
1169 spin_lock_bh(&fip
->lock
);
1170 last_link
= fip
->last_link
;
1172 fip
->last_link
= link
;
1173 spin_unlock_bh(&fip
->lock
);
1175 if (last_link
!= link
) {
1179 fcoe_ctlr_reset(fip
, FIP_ST_LINK_WAIT
);
1184 * fcoe_ctlr_recv_work() - Worker thread function for receiving FIP frames.
1185 * @recv_work: pointer to recv_work member inside &fcoe_ctlr.
1187 static void fcoe_ctlr_recv_work(struct work_struct
*recv_work
)
1189 struct fcoe_ctlr
*fip
;
1190 struct sk_buff
*skb
;
1192 fip
= container_of(recv_work
, struct fcoe_ctlr
, recv_work
);
1193 spin_lock_bh(&fip
->fip_recv_list
.lock
);
1194 while ((skb
= __skb_dequeue(&fip
->fip_recv_list
))) {
1195 spin_unlock_bh(&fip
->fip_recv_list
.lock
);
1196 fcoe_ctlr_recv_handler(fip
, skb
);
1197 spin_lock_bh(&fip
->fip_recv_list
.lock
);
1199 spin_unlock_bh(&fip
->fip_recv_list
.lock
);
1203 * fcoe_ctlr_recv_flogi() - snoop Pre-FIP receipt of FLOGI response or request.
1204 * @fip: FCoE controller.
1206 * @sa: Ethernet source MAC address from received FCoE frame.
1208 * Snoop potential response to FLOGI or even incoming FLOGI.
1210 * The caller has checked that we are waiting for login as indicated
1211 * by fip->flogi_oxid != FC_XID_UNKNOWN.
1213 * The caller is responsible for freeing the frame.
1215 * Return non-zero if the frame should not be delivered to libfc.
1217 int fcoe_ctlr_recv_flogi(struct fcoe_ctlr
*fip
, struct fc_frame
*fp
, u8
*sa
)
1219 struct fc_frame_header
*fh
;
1223 fh
= fc_frame_header_get(fp
);
1224 if (fh
->fh_type
!= FC_TYPE_ELS
)
1227 op
= fc_frame_payload_op(fp
);
1228 if (op
== ELS_LS_ACC
&& fh
->fh_r_ctl
== FC_RCTL_ELS_REP
&&
1229 fip
->flogi_oxid
== ntohs(fh
->fh_ox_id
)) {
1231 spin_lock_bh(&fip
->lock
);
1232 if (fip
->state
!= FIP_ST_AUTO
&& fip
->state
!= FIP_ST_NON_FIP
) {
1233 spin_unlock_bh(&fip
->lock
);
1236 fip
->state
= FIP_ST_NON_FIP
;
1237 FIP_DBG("received FLOGI LS_ACC using non-FIP mode\n");
1241 * If the src mac addr is FC_OUI-based, then we mark the
1242 * address_mode flag to use FC_OUI-based Ethernet DA.
1243 * Otherwise we use the FCoE gateway addr
1245 if (!compare_ether_addr(sa
, (u8
[6])FC_FCOE_FLOGI_MAC
)) {
1248 memcpy(fip
->dest_addr
, sa
, ETH_ALEN
);
1251 fip
->flogi_oxid
= FC_XID_UNKNOWN
;
1252 memcpy(mac
, fip
->data_src_addr
, ETH_ALEN
);
1253 fc_fcoe_set_mac(fip
->data_src_addr
, fh
->fh_d_id
);
1254 spin_unlock_bh(&fip
->lock
);
1256 fip
->update_mac(fip
, mac
, fip
->data_src_addr
);
1257 } else if (op
== ELS_FLOGI
&& fh
->fh_r_ctl
== FC_RCTL_ELS_REQ
&& sa
) {
1259 * Save source MAC for point-to-point responses.
1261 spin_lock_bh(&fip
->lock
);
1262 if (fip
->state
== FIP_ST_AUTO
|| fip
->state
== FIP_ST_NON_FIP
) {
1263 memcpy(fip
->dest_addr
, sa
, ETH_ALEN
);
1265 if (fip
->state
== FIP_ST_NON_FIP
)
1266 FIP_DBG("received FLOGI REQ, "
1267 "using non-FIP mode\n");
1268 fip
->state
= FIP_ST_NON_FIP
;
1270 spin_unlock_bh(&fip
->lock
);
1274 EXPORT_SYMBOL(fcoe_ctlr_recv_flogi
);
1277 * fcoe_wwn_from_mac() - Converts 48-bit IEEE MAC address to 64-bit FC WWN.
1279 * @scheme: check port
1280 * @port: port indicator for converting
1282 * Returns: u64 fc world wide name
1284 u64
fcoe_wwn_from_mac(unsigned char mac
[MAX_ADDR_LEN
],
1285 unsigned int scheme
, unsigned int port
)
1290 /* The MAC is in NO, so flip only the low 48 bits */
1291 host_mac
= ((u64
) mac
[0] << 40) |
1292 ((u64
) mac
[1] << 32) |
1293 ((u64
) mac
[2] << 24) |
1294 ((u64
) mac
[3] << 16) |
1295 ((u64
) mac
[4] << 8) |
1298 WARN_ON(host_mac
>= (1ULL << 48));
1299 wwn
= host_mac
| ((u64
) scheme
<< 60);
1305 WARN_ON(port
>= 0xfff);
1306 wwn
|= (u64
) port
<< 48;
1315 EXPORT_SYMBOL_GPL(fcoe_wwn_from_mac
);
1318 * fcoe_libfc_config() - sets up libfc related properties for lport
1319 * @lp: ptr to the fc_lport
1320 * @tt: libfc function template
1322 * Returns : 0 for success
1324 int fcoe_libfc_config(struct fc_lport
*lp
, struct libfc_function_template
*tt
)
1326 /* Set the function pointers set by the LLDD */
1327 memcpy(&lp
->tt
, tt
, sizeof(*tt
));
1328 if (fc_fcp_init(lp
))
1338 EXPORT_SYMBOL_GPL(fcoe_libfc_config
);