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_ctlr_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_FIP
);
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_FIP
);
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_FIP
);
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 fh
= (struct fc_frame_header
*)skb
->data
;
451 op
= *(u8
*)(fh
+ 1);
453 if (op
== ELS_FLOGI
) {
454 old_xid
= fip
->flogi_oxid
;
455 fip
->flogi_oxid
= ntohs(fh
->fh_ox_id
);
456 if (fip
->state
== FIP_ST_AUTO
) {
457 if (old_xid
== FC_XID_UNKNOWN
)
458 fip
->flogi_count
= 0;
460 if (fip
->flogi_count
< 3)
465 if (fip
->state
== FIP_ST_NON_FIP
)
469 if (fip
->state
== FIP_ST_NON_FIP
)
477 if (ntoh24(fh
->fh_s_id
))
482 if (fip
->state
!= FIP_ST_ENABLED
)
484 if (ntoh24(fh
->fh_d_id
) != FC_FID_FLOGI
)
489 if (fip
->flogi_oxid
== FC_XID_UNKNOWN
)
491 if (!ntoh24(fh
->fh_s_id
))
493 if (fip
->state
== FIP_ST_AUTO
)
496 * Here we must've gotten an SID by accepting an FLOGI
497 * from a point-to-point connection. Switch to using
498 * the source mac based on the SID. The destination
499 * MAC in this case would have been set by receving the
502 fip
->flogi_oxid
= FC_XID_UNKNOWN
;
503 fc_fcoe_set_mac(fip
->data_src_addr
, fh
->fh_s_id
);
506 if (fip
->state
!= FIP_ST_ENABLED
)
510 if (fcoe_ctlr_encaps(fip
, op
, skb
))
518 EXPORT_SYMBOL(fcoe_ctlr_els_send
);
521 * fcoe_ctlr_age_fcfs() - Reset and free all old FCFs for a controller.
522 * @fip: FCoE controller.
524 * Called with lock held.
526 * An FCF is considered old if we have missed three advertisements.
527 * That is, there have been no valid advertisement from it for three
528 * times its keep-alive period including fuzz.
530 * In addition, determine the time when an FCF selection can occur.
532 static void fcoe_ctlr_age_fcfs(struct fcoe_ctlr
*fip
)
534 struct fcoe_fcf
*fcf
;
535 struct fcoe_fcf
*next
;
536 unsigned long sel_time
= 0;
538 list_for_each_entry_safe(fcf
, next
, &fip
->fcfs
, list
) {
539 if (time_after(jiffies
, fcf
->time
+ fcf
->fka_period
* 3 +
540 msecs_to_jiffies(FIP_FCF_FUZZ
* 3))) {
541 if (fip
->sel_fcf
== fcf
)
543 list_del(&fcf
->list
);
544 WARN_ON(!fip
->fcf_count
);
547 } else if (fcoe_ctlr_mtu_valid(fcf
) &&
548 (!sel_time
|| time_before(sel_time
, fcf
->time
))) {
549 sel_time
= fcf
->time
;
553 sel_time
+= msecs_to_jiffies(FCOE_CTLR_START_DELAY
);
554 fip
->sel_time
= sel_time
;
555 if (time_before(sel_time
, fip
->timer
.expires
))
556 mod_timer(&fip
->timer
, sel_time
);
563 * fcoe_ctlr_parse_adv() - Decode a FIP advertisement into a new FCF entry.
564 * @skb: received FIP advertisement frame
565 * @fcf: resulting FCF entry.
567 * Returns zero on a valid parsed advertisement,
568 * otherwise returns non zero value.
570 static int fcoe_ctlr_parse_adv(struct sk_buff
*skb
, struct fcoe_fcf
*fcf
)
572 struct fip_header
*fiph
;
573 struct fip_desc
*desc
= NULL
;
574 struct fip_wwn_desc
*wwn
;
575 struct fip_fab_desc
*fab
;
576 struct fip_fka_desc
*fka
;
581 memset(fcf
, 0, sizeof(*fcf
));
582 fcf
->fka_period
= msecs_to_jiffies(FCOE_CTLR_DEF_FKA
);
584 fiph
= (struct fip_header
*)skb
->data
;
585 fcf
->flags
= ntohs(fiph
->fip_flags
);
587 rlen
= ntohs(fiph
->fip_dl_len
) * 4;
588 if (rlen
+ sizeof(*fiph
) > skb
->len
)
591 desc
= (struct fip_desc
*)(fiph
+ 1);
593 dlen
= desc
->fip_dlen
* FIP_BPW
;
594 if (dlen
< sizeof(*desc
) || dlen
> rlen
)
596 switch (desc
->fip_dtype
) {
598 if (dlen
!= sizeof(struct fip_pri_desc
))
600 fcf
->pri
= ((struct fip_pri_desc
*)desc
)->fd_pri
;
603 if (dlen
!= sizeof(struct fip_mac_desc
))
606 ((struct fip_mac_desc
*)desc
)->fd_mac
,
608 if (!is_valid_ether_addr(fcf
->fcf_mac
)) {
609 FIP_DBG("invalid MAC addr in FIP adv\n");
614 if (dlen
!= sizeof(struct fip_wwn_desc
))
616 wwn
= (struct fip_wwn_desc
*)desc
;
617 fcf
->switch_name
= get_unaligned_be64(&wwn
->fd_wwn
);
620 if (dlen
!= sizeof(struct fip_fab_desc
))
622 fab
= (struct fip_fab_desc
*)desc
;
623 fcf
->fabric_name
= get_unaligned_be64(&fab
->fd_wwn
);
624 fcf
->vfid
= ntohs(fab
->fd_vfid
);
625 fcf
->fc_map
= ntoh24(fab
->fd_map
);
628 if (dlen
!= sizeof(struct fip_fka_desc
))
630 fka
= (struct fip_fka_desc
*)desc
;
631 t
= ntohl(fka
->fd_fka_period
);
632 if (t
>= FCOE_CTLR_MIN_FKA
)
633 fcf
->fka_period
= msecs_to_jiffies(t
);
636 case FIP_DT_FCOE_SIZE
:
642 FIP_DBG("unexpected descriptor type %x in FIP adv\n",
644 /* standard says ignore unknown descriptors >= 128 */
645 if (desc
->fip_dtype
< FIP_DT_VENDOR_BASE
)
649 desc
= (struct fip_desc
*)((char *)desc
+ dlen
);
652 if (!fcf
->fc_map
|| (fcf
->fc_map
& 0x10000))
654 if (!fcf
->switch_name
|| !fcf
->fabric_name
)
659 FIP_DBG("FIP length error in descriptor type %x len %zu\n",
660 desc
->fip_dtype
, dlen
);
665 * fcoe_ctlr_recv_adv() - Handle an incoming advertisement.
666 * @fip: FCoE controller.
667 * @skb: Received FIP packet.
669 static void fcoe_ctlr_recv_adv(struct fcoe_ctlr
*fip
, struct sk_buff
*skb
)
671 struct fcoe_fcf
*fcf
;
673 struct fcoe_fcf
*found
;
674 unsigned long sol_tov
= msecs_to_jiffies(FCOE_CTRL_SOL_TOV
);
678 if (fcoe_ctlr_parse_adv(skb
, &new))
681 spin_lock_bh(&fip
->lock
);
682 first
= list_empty(&fip
->fcfs
);
684 list_for_each_entry(fcf
, &fip
->fcfs
, list
) {
685 if (fcf
->switch_name
== new.switch_name
&&
686 fcf
->fabric_name
== new.fabric_name
&&
687 fcf
->fc_map
== new.fc_map
&&
688 compare_ether_addr(fcf
->fcf_mac
, new.fcf_mac
) == 0) {
694 if (fip
->fcf_count
>= FCOE_CTLR_FCF_LIMIT
)
697 fcf
= kmalloc(sizeof(*fcf
), GFP_ATOMIC
);
702 memcpy(fcf
, &new, sizeof(new));
703 list_add(&fcf
->list
, &fip
->fcfs
);
706 * Flags in advertisements are ignored once the FCF is
707 * selected. Flags in unsolicited advertisements are
708 * ignored after a usable solicited advertisement
711 if (fcf
== fip
->sel_fcf
) {
712 fip
->ctlr_ka_time
-= fcf
->fka_period
;
713 fip
->ctlr_ka_time
+= new.fka_period
;
714 if (time_before(fip
->ctlr_ka_time
, fip
->timer
.expires
))
715 mod_timer(&fip
->timer
, fip
->ctlr_ka_time
);
716 } else if (!fcoe_ctlr_fcf_usable(fcf
))
717 fcf
->flags
= new.flags
;
718 fcf
->fka_period
= new.fka_period
;
719 memcpy(fcf
->fcf_mac
, new.fcf_mac
, ETH_ALEN
);
721 mtu_valid
= fcoe_ctlr_mtu_valid(fcf
);
723 FIP_DBG_LVL(found
? 2 : 1, "%s FCF for fab %llx map %x val %d\n",
724 found
? "old" : "new",
725 fcf
->fabric_name
, fcf
->fc_map
, mtu_valid
);
728 * If this advertisement is not solicited and our max receive size
729 * hasn't been verified, send a solicited advertisement.
732 fcoe_ctlr_solicit(fip
, fcf
);
735 * If its been a while since we did a solicit, and this is
736 * the first advertisement we've received, do a multicast
737 * solicitation to gather as many advertisements as we can
738 * before selection occurs.
740 if (first
&& time_after(jiffies
, fip
->sol_time
+ sol_tov
))
741 fcoe_ctlr_solicit(fip
, NULL
);
744 * If this is the first validated FCF, note the time and
745 * set a timer to trigger selection.
747 if (mtu_valid
&& !fip
->sel_time
&& fcoe_ctlr_fcf_usable(fcf
)) {
748 fip
->sel_time
= jiffies
+
749 msecs_to_jiffies(FCOE_CTLR_START_DELAY
);
750 if (!timer_pending(&fip
->timer
) ||
751 time_before(fip
->sel_time
, fip
->timer
.expires
))
752 mod_timer(&fip
->timer
, fip
->sel_time
);
755 spin_unlock_bh(&fip
->lock
);
759 * fcoe_ctlr_recv_els() - Handle an incoming FIP-encapsulated ELS frame.
760 * @fip: FCoE controller.
761 * @skb: Received FIP packet.
763 static void fcoe_ctlr_recv_els(struct fcoe_ctlr
*fip
, struct sk_buff
*skb
)
765 struct fc_lport
*lp
= fip
->lp
;
766 struct fip_header
*fiph
;
768 struct fc_frame_header
*fh
= NULL
;
769 struct fip_desc
*desc
;
770 struct fip_encaps
*els
;
771 struct fcoe_dev_stats
*stats
;
772 enum fip_desc_type els_dtype
= 0;
775 u8 granted_mac
[ETH_ALEN
] = { 0 };
780 fiph
= (struct fip_header
*)skb
->data
;
781 sub
= fiph
->fip_subcode
;
782 if (sub
!= FIP_SC_REQ
&& sub
!= FIP_SC_REP
)
785 rlen
= ntohs(fiph
->fip_dl_len
) * 4;
786 if (rlen
+ sizeof(*fiph
) > skb
->len
)
789 desc
= (struct fip_desc
*)(fiph
+ 1);
791 dlen
= desc
->fip_dlen
* FIP_BPW
;
792 if (dlen
< sizeof(*desc
) || dlen
> rlen
)
794 switch (desc
->fip_dtype
) {
796 if (dlen
!= sizeof(struct fip_mac_desc
))
799 ((struct fip_mac_desc
*)desc
)->fd_mac
,
801 if (!is_valid_ether_addr(granted_mac
)) {
802 FIP_DBG("invalid MAC addrs in FIP ELS\n");
812 if (dlen
< sizeof(*els
) + sizeof(*fh
) + 1)
814 els_len
= dlen
- sizeof(*els
);
815 els
= (struct fip_encaps
*)desc
;
816 fh
= (struct fc_frame_header
*)(els
+ 1);
817 els_dtype
= desc
->fip_dtype
;
820 FIP_DBG("unexpected descriptor type %x "
821 "in FIP adv\n", desc
->fip_dtype
);
822 /* standard says ignore unknown descriptors >= 128 */
823 if (desc
->fip_dtype
< FIP_DT_VENDOR_BASE
)
827 desc
= (struct fip_desc
*)((char *)desc
+ dlen
);
833 els_op
= *(u8
*)(fh
+ 1);
835 if (els_dtype
== FIP_DT_FLOGI
&& sub
== FIP_SC_REP
&&
836 fip
->flogi_oxid
== ntohs(fh
->fh_ox_id
) &&
837 els_op
== ELS_LS_ACC
&& is_valid_ether_addr(granted_mac
)) {
838 fip
->flogi_oxid
= FC_XID_UNKNOWN
;
839 fip
->update_mac(fip
, fip
->data_src_addr
, granted_mac
);
840 memcpy(fip
->data_src_addr
, granted_mac
, ETH_ALEN
);
844 * Convert skb into an fc_frame containing only the ELS.
846 skb_pull(skb
, (u8
*)fh
- skb
->data
);
847 skb_trim(skb
, els_len
);
848 fp
= (struct fc_frame
*)skb
;
850 fr_sof(fp
) = FC_SOF_I3
;
851 fr_eof(fp
) = FC_EOF_T
;
854 stats
= fc_lport_get_stats(lp
);
856 stats
->RxWords
+= skb
->len
/ FIP_BPW
;
858 fc_exch_recv(lp
, lp
->emp
, fp
);
862 FIP_DBG("FIP length error in descriptor type %x len %zu\n",
863 desc
->fip_dtype
, dlen
);
869 * fcoe_ctlr_recv_els() - Handle an incoming link reset frame.
870 * @fip: FCoE controller.
871 * @fh: Received FIP header.
873 * There may be multiple VN_Port descriptors.
874 * The overall length has already been checked.
876 static void fcoe_ctlr_recv_clr_vlink(struct fcoe_ctlr
*fip
,
877 struct fip_header
*fh
)
879 struct fip_desc
*desc
;
880 struct fip_mac_desc
*mp
;
881 struct fip_wwn_desc
*wp
;
882 struct fip_vn_desc
*vp
;
885 struct fcoe_fcf
*fcf
= fip
->sel_fcf
;
886 struct fc_lport
*lp
= fip
->lp
;
889 FIP_DBG("Clear Virtual Link received\n");
892 if (!fcf
|| !fc_host_port_id(lp
->host
))
896 * mask of required descriptors. Validating each one clears its bit.
898 desc_mask
= BIT(FIP_DT_MAC
) | BIT(FIP_DT_NAME
) | BIT(FIP_DT_VN_ID
);
900 rlen
= ntohs(fh
->fip_dl_len
) * FIP_BPW
;
901 desc
= (struct fip_desc
*)(fh
+ 1);
902 while (rlen
>= sizeof(*desc
)) {
903 dlen
= desc
->fip_dlen
* FIP_BPW
;
906 switch (desc
->fip_dtype
) {
908 mp
= (struct fip_mac_desc
*)desc
;
909 if (dlen
< sizeof(*mp
))
911 if (compare_ether_addr(mp
->fd_mac
, fcf
->fcf_mac
))
913 desc_mask
&= ~BIT(FIP_DT_MAC
);
916 wp
= (struct fip_wwn_desc
*)desc
;
917 if (dlen
< sizeof(*wp
))
919 if (get_unaligned_be64(&wp
->fd_wwn
) != fcf
->switch_name
)
921 desc_mask
&= ~BIT(FIP_DT_NAME
);
924 vp
= (struct fip_vn_desc
*)desc
;
925 if (dlen
< sizeof(*vp
))
927 if (compare_ether_addr(vp
->fd_mac
,
928 fip
->data_src_addr
) == 0 &&
929 get_unaligned_be64(&vp
->fd_wwpn
) == lp
->wwpn
&&
930 ntoh24(vp
->fd_fc_id
) == fc_host_port_id(lp
->host
))
931 desc_mask
&= ~BIT(FIP_DT_VN_ID
);
934 /* standard says ignore unknown descriptors >= 128 */
935 if (desc
->fip_dtype
< FIP_DT_VENDOR_BASE
)
939 desc
= (struct fip_desc
*)((char *)desc
+ dlen
);
944 * reset only if all required descriptors were present and valid.
947 FIP_DBG("missing descriptors mask %x\n", desc_mask
);
949 FIP_DBG("performing Clear Virtual Link\n");
950 fcoe_ctlr_reset(fip
, FIP_ST_ENABLED
);
955 * fcoe_ctlr_recv() - Receive a FIP frame.
956 * @fip: FCoE controller.
957 * @skb: Received FIP packet.
959 * This is called from NET_RX_SOFTIRQ.
961 void fcoe_ctlr_recv(struct fcoe_ctlr
*fip
, struct sk_buff
*skb
)
963 spin_lock_bh(&fip
->fip_recv_list
.lock
);
964 __skb_queue_tail(&fip
->fip_recv_list
, skb
);
965 spin_unlock_bh(&fip
->fip_recv_list
.lock
);
966 schedule_work(&fip
->recv_work
);
968 EXPORT_SYMBOL(fcoe_ctlr_recv
);
971 * fcoe_ctlr_recv_handler() - Receive a FIP frame.
972 * @fip: FCoE controller.
973 * @skb: Received FIP packet.
975 * Returns non-zero if the frame is dropped.
977 static int fcoe_ctlr_recv_handler(struct fcoe_ctlr
*fip
, struct sk_buff
*skb
)
979 struct fip_header
*fiph
;
981 enum fip_state state
;
985 if (skb_linearize(skb
))
987 if (skb
->len
< sizeof(*fiph
))
990 if (compare_ether_addr(eh
->h_dest
, fip
->ctl_src_addr
) &&
991 compare_ether_addr(eh
->h_dest
, FIP_ALL_ENODE_MACS
))
993 fiph
= (struct fip_header
*)skb
->data
;
994 op
= ntohs(fiph
->fip_op
);
995 sub
= fiph
->fip_subcode
;
997 FIP_DBG_LVL(2, "ver %x op %x/%x dl %x fl %x\n",
998 FIP_VER_DECAPS(fiph
->fip_ver
), op
, sub
,
999 ntohs(fiph
->fip_dl_len
), ntohs(fiph
->fip_flags
));
1001 if (FIP_VER_DECAPS(fiph
->fip_ver
) != FIP_VER
)
1003 if (ntohs(fiph
->fip_dl_len
) * FIP_BPW
+ sizeof(*fiph
) > skb
->len
)
1006 spin_lock_bh(&fip
->lock
);
1008 if (state
== FIP_ST_AUTO
) {
1010 fip
->state
= FIP_ST_ENABLED
;
1011 state
= FIP_ST_ENABLED
;
1012 FIP_DBG("using FIP mode\n");
1014 spin_unlock_bh(&fip
->lock
);
1015 if (state
!= FIP_ST_ENABLED
)
1018 if (op
== FIP_OP_LS
) {
1019 fcoe_ctlr_recv_els(fip
, skb
); /* consumes skb */
1022 if (op
== FIP_OP_DISC
&& sub
== FIP_SC_ADV
)
1023 fcoe_ctlr_recv_adv(fip
, skb
);
1024 else if (op
== FIP_OP_CTRL
&& sub
== FIP_SC_CLR_VLINK
)
1025 fcoe_ctlr_recv_clr_vlink(fip
, fiph
);
1034 * fcoe_ctlr_select() - Select the best FCF, if possible.
1035 * @fip: FCoE controller.
1037 * If there are conflicting advertisements, no FCF can be chosen.
1039 * Called with lock held.
1041 static void fcoe_ctlr_select(struct fcoe_ctlr
*fip
)
1043 struct fcoe_fcf
*fcf
;
1044 struct fcoe_fcf
*best
= NULL
;
1046 list_for_each_entry(fcf
, &fip
->fcfs
, list
) {
1047 FIP_DBG("consider FCF for fab %llx VFID %d map %x val %d\n",
1048 fcf
->fabric_name
, fcf
->vfid
,
1049 fcf
->fc_map
, fcoe_ctlr_mtu_valid(fcf
));
1050 if (!fcoe_ctlr_fcf_usable(fcf
)) {
1051 FIP_DBG("FCF for fab %llx map %x %svalid %savailable\n",
1052 fcf
->fabric_name
, fcf
->fc_map
,
1053 (fcf
->flags
& FIP_FL_SOL
) ? "" : "in",
1054 (fcf
->flags
& FIP_FL_AVAIL
) ? "" : "un");
1061 if (fcf
->fabric_name
!= best
->fabric_name
||
1062 fcf
->vfid
!= best
->vfid
||
1063 fcf
->fc_map
!= best
->fc_map
) {
1064 FIP_DBG("conflicting fabric, VFID, or FC-MAP\n");
1067 if (fcf
->pri
< best
->pri
)
1070 fip
->sel_fcf
= best
;
1074 * fcoe_ctlr_timeout() - FIP timer function.
1075 * @arg: &fcoe_ctlr pointer.
1077 * Ages FCFs. Triggers FCF selection if possible. Sends keep-alives.
1079 static void fcoe_ctlr_timeout(unsigned long arg
)
1081 struct fcoe_ctlr
*fip
= (struct fcoe_ctlr
*)arg
;
1082 struct fcoe_fcf
*sel
;
1083 struct fcoe_fcf
*fcf
;
1084 unsigned long next_timer
= jiffies
+ msecs_to_jiffies(FIP_VN_KA_PERIOD
);
1085 DECLARE_MAC_BUF(buf
);
1089 spin_lock_bh(&fip
->lock
);
1090 if (fip
->state
== FIP_ST_DISABLED
) {
1091 spin_unlock_bh(&fip
->lock
);
1096 fcoe_ctlr_age_fcfs(fip
);
1099 if (!sel
&& fip
->sel_time
&& time_after_eq(jiffies
, fip
->sel_time
)) {
1100 fcoe_ctlr_select(fip
);
1106 fcf
= sel
; /* the old FCF may have been freed */
1108 printk(KERN_INFO
"host%d: FIP selected "
1109 "Fibre-Channel Forwarder MAC %s\n",
1110 fip
->lp
->host
->host_no
,
1111 print_mac(buf
, sel
->fcf_mac
));
1112 memcpy(fip
->dest_addr
, sel
->fcf_mac
, ETH_ALEN
);
1113 fip
->port_ka_time
= jiffies
+
1114 msecs_to_jiffies(FIP_VN_KA_PERIOD
);
1115 fip
->ctlr_ka_time
= jiffies
+ sel
->fka_period
;
1118 printk(KERN_NOTICE
"host%d: "
1119 "FIP Fibre-Channel Forwarder timed out. "
1120 "Starting FCF discovery.\n",
1121 fip
->lp
->host
->host_no
);
1124 schedule_work(&fip
->link_work
);
1130 if (time_after_eq(jiffies
, fip
->ctlr_ka_time
)) {
1131 fip
->ctlr_ka_time
= jiffies
+ sel
->fka_period
;
1134 if (time_after(next_timer
, fip
->ctlr_ka_time
))
1135 next_timer
= fip
->ctlr_ka_time
;
1137 if (time_after_eq(jiffies
, fip
->port_ka_time
)) {
1138 fip
->port_ka_time
+= jiffies
+
1139 msecs_to_jiffies(FIP_VN_KA_PERIOD
);
1142 if (time_after(next_timer
, fip
->port_ka_time
))
1143 next_timer
= fip
->port_ka_time
;
1144 mod_timer(&fip
->timer
, next_timer
);
1145 } else if (fip
->sel_time
) {
1146 next_timer
= fip
->sel_time
+
1147 msecs_to_jiffies(FCOE_CTLR_START_DELAY
);
1148 mod_timer(&fip
->timer
, next_timer
);
1150 spin_unlock_bh(&fip
->lock
);
1153 fcoe_ctlr_send_keep_alive(fip
, 0, fip
->ctl_src_addr
);
1155 fcoe_ctlr_send_keep_alive(fip
, 1, fip
->data_src_addr
);
1159 * fcoe_ctlr_link_work() - worker thread function for link changes.
1160 * @work: pointer to link_work member inside &fcoe_ctlr.
1162 * See if the link status has changed and if so, report it.
1164 * This is here because fc_linkup() and fc_linkdown() must not
1165 * be called from the timer directly, since they use a mutex.
1167 static void fcoe_ctlr_link_work(struct work_struct
*work
)
1169 struct fcoe_ctlr
*fip
;
1173 fip
= container_of(work
, struct fcoe_ctlr
, link_work
);
1174 spin_lock_bh(&fip
->lock
);
1175 last_link
= fip
->last_link
;
1177 fip
->last_link
= link
;
1178 spin_unlock_bh(&fip
->lock
);
1180 if (last_link
!= link
) {
1184 fcoe_ctlr_reset(fip
, FIP_ST_LINK_WAIT
);
1189 * fcoe_ctlr_recv_work() - Worker thread function for receiving FIP frames.
1190 * @recv_work: pointer to recv_work member inside &fcoe_ctlr.
1192 static void fcoe_ctlr_recv_work(struct work_struct
*recv_work
)
1194 struct fcoe_ctlr
*fip
;
1195 struct sk_buff
*skb
;
1197 fip
= container_of(recv_work
, struct fcoe_ctlr
, recv_work
);
1198 spin_lock_bh(&fip
->fip_recv_list
.lock
);
1199 while ((skb
= __skb_dequeue(&fip
->fip_recv_list
))) {
1200 spin_unlock_bh(&fip
->fip_recv_list
.lock
);
1201 fcoe_ctlr_recv_handler(fip
, skb
);
1202 spin_lock_bh(&fip
->fip_recv_list
.lock
);
1204 spin_unlock_bh(&fip
->fip_recv_list
.lock
);
1208 * fcoe_ctlr_recv_flogi() - snoop Pre-FIP receipt of FLOGI response or request.
1209 * @fip: FCoE controller.
1211 * @sa: Ethernet source MAC address from received FCoE frame.
1213 * Snoop potential response to FLOGI or even incoming FLOGI.
1215 * The caller has checked that we are waiting for login as indicated
1216 * by fip->flogi_oxid != FC_XID_UNKNOWN.
1218 * The caller is responsible for freeing the frame.
1220 * Return non-zero if the frame should not be delivered to libfc.
1222 int fcoe_ctlr_recv_flogi(struct fcoe_ctlr
*fip
, struct fc_frame
*fp
, u8
*sa
)
1224 struct fc_frame_header
*fh
;
1228 fh
= fc_frame_header_get(fp
);
1229 if (fh
->fh_type
!= FC_TYPE_ELS
)
1232 op
= fc_frame_payload_op(fp
);
1233 if (op
== ELS_LS_ACC
&& fh
->fh_r_ctl
== FC_RCTL_ELS_REP
&&
1234 fip
->flogi_oxid
== ntohs(fh
->fh_ox_id
)) {
1236 spin_lock_bh(&fip
->lock
);
1237 if (fip
->state
!= FIP_ST_AUTO
&& fip
->state
!= FIP_ST_NON_FIP
) {
1238 spin_unlock_bh(&fip
->lock
);
1241 fip
->state
= FIP_ST_NON_FIP
;
1242 FIP_DBG("received FLOGI LS_ACC using non-FIP mode\n");
1246 * If the src mac addr is FC_OUI-based, then we mark the
1247 * address_mode flag to use FC_OUI-based Ethernet DA.
1248 * Otherwise we use the FCoE gateway addr
1250 if (!compare_ether_addr(sa
, (u8
[6])FC_FCOE_FLOGI_MAC
)) {
1253 memcpy(fip
->dest_addr
, sa
, ETH_ALEN
);
1256 fip
->flogi_oxid
= FC_XID_UNKNOWN
;
1257 memcpy(mac
, fip
->data_src_addr
, ETH_ALEN
);
1258 fc_fcoe_set_mac(fip
->data_src_addr
, fh
->fh_d_id
);
1259 spin_unlock_bh(&fip
->lock
);
1261 fip
->update_mac(fip
, mac
, fip
->data_src_addr
);
1262 } else if (op
== ELS_FLOGI
&& fh
->fh_r_ctl
== FC_RCTL_ELS_REQ
&& sa
) {
1264 * Save source MAC for point-to-point responses.
1266 spin_lock_bh(&fip
->lock
);
1267 if (fip
->state
== FIP_ST_AUTO
|| fip
->state
== FIP_ST_NON_FIP
) {
1268 memcpy(fip
->dest_addr
, sa
, ETH_ALEN
);
1270 if (fip
->state
== FIP_ST_NON_FIP
)
1271 FIP_DBG("received FLOGI REQ, "
1272 "using non-FIP mode\n");
1273 fip
->state
= FIP_ST_NON_FIP
;
1275 spin_unlock_bh(&fip
->lock
);
1279 EXPORT_SYMBOL(fcoe_ctlr_recv_flogi
);
1282 * fcoe_wwn_from_mac() - Converts 48-bit IEEE MAC address to 64-bit FC WWN.
1284 * @scheme: check port
1285 * @port: port indicator for converting
1287 * Returns: u64 fc world wide name
1289 u64
fcoe_wwn_from_mac(unsigned char mac
[MAX_ADDR_LEN
],
1290 unsigned int scheme
, unsigned int port
)
1295 /* The MAC is in NO, so flip only the low 48 bits */
1296 host_mac
= ((u64
) mac
[0] << 40) |
1297 ((u64
) mac
[1] << 32) |
1298 ((u64
) mac
[2] << 24) |
1299 ((u64
) mac
[3] << 16) |
1300 ((u64
) mac
[4] << 8) |
1303 WARN_ON(host_mac
>= (1ULL << 48));
1304 wwn
= host_mac
| ((u64
) scheme
<< 60);
1310 WARN_ON(port
>= 0xfff);
1311 wwn
|= (u64
) port
<< 48;
1320 EXPORT_SYMBOL_GPL(fcoe_wwn_from_mac
);
1323 * fcoe_libfc_config() - sets up libfc related properties for lport
1324 * @lp: ptr to the fc_lport
1325 * @tt: libfc function template
1327 * Returns : 0 for success
1329 int fcoe_libfc_config(struct fc_lport
*lp
, struct libfc_function_template
*tt
)
1331 /* Set the function pointers set by the LLDD */
1332 memcpy(&lp
->tt
, tt
, sizeof(*tt
));
1333 if (fc_fcp_init(lp
))
1343 EXPORT_SYMBOL_GPL(fcoe_libfc_config
);
This page took 0.062736 seconds and 5 git commands to generate.