1 // SPDX-License-Identifier: GPL-2.0-only
3 * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
5 * Maintained at www.Open-FCoE.org
8 #include <linux/types.h>
9 #include <linux/module.h>
10 #include <linux/kernel.h>
11 #include <linux/list.h>
12 #include <linux/netdevice.h>
13 #include <linux/ethtool.h>
14 #include <linux/errno.h>
15 #include <linux/crc32.h>
16 #include <scsi/libfcoe.h>
20 MODULE_AUTHOR("Open-FCoE.org");
21 MODULE_DESCRIPTION("FIP discovery protocol and FCoE transport for FCoE HBAs");
22 MODULE_LICENSE("GPL v2");
24 static int fcoe_transport_create(const char *, const struct kernel_param *);
25 static int fcoe_transport_destroy(const char *, const struct kernel_param *);
26 static int fcoe_transport_show(char *buffer, const struct kernel_param *kp);
27 static struct fcoe_transport *fcoe_transport_lookup(struct net_device *device);
28 static struct fcoe_transport *fcoe_netdev_map_lookup(struct net_device *device);
29 static int fcoe_transport_enable(const char *, const struct kernel_param *);
30 static int fcoe_transport_disable(const char *, const struct kernel_param *);
31 static int libfcoe_device_notification(struct notifier_block *notifier,
32 ulong event, void *ptr);
34 static LIST_HEAD(fcoe_transports);
35 static DEFINE_MUTEX(ft_mutex);
36 static LIST_HEAD(fcoe_netdevs);
37 static DEFINE_MUTEX(fn_mutex);
39 unsigned int libfcoe_debug_logging;
40 module_param_named(debug_logging, libfcoe_debug_logging, int, S_IRUGO|S_IWUSR);
41 MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels");
43 module_param_call(show, NULL, fcoe_transport_show, NULL, S_IRUSR);
44 __MODULE_PARM_TYPE(show, "string");
45 MODULE_PARM_DESC(show, " Show attached FCoE transports");
47 module_param_call(create, fcoe_transport_create, NULL,
48 (void *)FIP_MODE_FABRIC, S_IWUSR);
49 __MODULE_PARM_TYPE(create, "string");
50 MODULE_PARM_DESC(create, " Creates fcoe instance on an ethernet interface");
52 module_param_call(create_vn2vn, fcoe_transport_create, NULL,
53 (void *)FIP_MODE_VN2VN, S_IWUSR);
54 __MODULE_PARM_TYPE(create_vn2vn, "string");
55 MODULE_PARM_DESC(create_vn2vn, " Creates a VN_node to VN_node FCoE instance "
56 "on an Ethernet interface");
58 module_param_call(destroy, fcoe_transport_destroy, NULL, NULL, S_IWUSR);
59 __MODULE_PARM_TYPE(destroy, "string");
60 MODULE_PARM_DESC(destroy, " Destroys fcoe instance on an ethernet interface");
62 module_param_call(enable, fcoe_transport_enable, NULL, NULL, S_IWUSR);
63 __MODULE_PARM_TYPE(enable, "string");
64 MODULE_PARM_DESC(enable, " Enables fcoe on an ethernet interface.");
66 module_param_call(disable, fcoe_transport_disable, NULL, NULL, S_IWUSR);
67 __MODULE_PARM_TYPE(disable, "string");
68 MODULE_PARM_DESC(disable, " Disables fcoe on an ethernet interface.");
70 /* notification function for packets from net device */
71 static struct notifier_block libfcoe_notifier = {
72 .notifier_call = libfcoe_device_notification,
77 #define SPEED_2000 2000
78 #define SPEED_4000 4000
79 #define SPEED_8000 8000
80 #define SPEED_16000 16000
81 #define SPEED_32000 32000
83 } fcoe_port_speed_mapping[] = {
84 { FC_PORTSPEED_1GBIT, SPEED_1000 },
85 { FC_PORTSPEED_2GBIT, SPEED_2000 },
86 { FC_PORTSPEED_4GBIT, SPEED_4000 },
87 { FC_PORTSPEED_8GBIT, SPEED_8000 },
88 { FC_PORTSPEED_10GBIT, SPEED_10000 },
89 { FC_PORTSPEED_16GBIT, SPEED_16000 },
90 { FC_PORTSPEED_20GBIT, SPEED_20000 },
91 { FC_PORTSPEED_25GBIT, SPEED_25000 },
92 { FC_PORTSPEED_32GBIT, SPEED_32000 },
93 { FC_PORTSPEED_40GBIT, SPEED_40000 },
94 { FC_PORTSPEED_50GBIT, SPEED_50000 },
95 { FC_PORTSPEED_100GBIT, SPEED_100000 },
98 static inline u32 eth2fc_speed(u32 eth_port_speed)
102 for (i = 0; i < ARRAY_SIZE(fcoe_port_speed_mapping); i++) {
103 if (fcoe_port_speed_mapping[i].eth_port_speed == eth_port_speed)
104 return fcoe_port_speed_mapping[i].fc_port_speed;
107 return FC_PORTSPEED_UNKNOWN;
111 * fcoe_link_speed_update() - Update the supported and actual link speeds
112 * @lport: The local port to update speeds for
114 * Returns: 0 if the ethtool query was successful
115 * -1 if the ethtool query failed
117 int fcoe_link_speed_update(struct fc_lport *lport)
119 struct net_device *netdev = fcoe_get_netdev(lport);
120 struct ethtool_link_ksettings ecmd;
122 if (!__ethtool_get_link_ksettings(netdev, &ecmd)) {
123 lport->link_supported_speeds &= ~(FC_PORTSPEED_1GBIT |
124 FC_PORTSPEED_10GBIT |
125 FC_PORTSPEED_20GBIT |
126 FC_PORTSPEED_40GBIT);
128 if (ecmd.link_modes.supported[0] & (
129 SUPPORTED_1000baseT_Half |
130 SUPPORTED_1000baseT_Full |
131 SUPPORTED_1000baseKX_Full))
132 lport->link_supported_speeds |= FC_PORTSPEED_1GBIT;
134 if (ecmd.link_modes.supported[0] & (
135 SUPPORTED_10000baseT_Full |
136 SUPPORTED_10000baseKX4_Full |
137 SUPPORTED_10000baseKR_Full |
138 SUPPORTED_10000baseR_FEC))
139 lport->link_supported_speeds |= FC_PORTSPEED_10GBIT;
141 if (ecmd.link_modes.supported[0] & (
142 SUPPORTED_20000baseMLD2_Full |
143 SUPPORTED_20000baseKR2_Full))
144 lport->link_supported_speeds |= FC_PORTSPEED_20GBIT;
146 if (ecmd.link_modes.supported[0] & (
147 SUPPORTED_40000baseKR4_Full |
148 SUPPORTED_40000baseCR4_Full |
149 SUPPORTED_40000baseSR4_Full |
150 SUPPORTED_40000baseLR4_Full))
151 lport->link_supported_speeds |= FC_PORTSPEED_40GBIT;
153 lport->link_speed = eth2fc_speed(ecmd.base.speed);
158 EXPORT_SYMBOL_GPL(fcoe_link_speed_update);
161 * __fcoe_get_lesb() - Get the Link Error Status Block (LESB) for a given lport
162 * @lport: The local port to update speeds for
163 * @fc_lesb: Pointer to the LESB to be filled up
164 * @netdev: Pointer to the netdev that is associated with the lport
166 * Note, the Link Error Status Block (LESB) for FCoE is defined in FC-BB-6
167 * Clause 7.11 in v1.04.
169 void __fcoe_get_lesb(struct fc_lport *lport,
170 struct fc_els_lesb *fc_lesb,
171 struct net_device *netdev)
175 struct fc_stats *stats;
176 struct fcoe_fc_els_lesb *lesb;
177 struct rtnl_link_stats64 temp;
182 lesb = (struct fcoe_fc_els_lesb *)fc_lesb;
183 memset(lesb, 0, sizeof(*lesb));
184 for_each_possible_cpu(cpu) {
185 stats = per_cpu_ptr(lport->stats, cpu);
186 lfc += READ_ONCE(stats->LinkFailureCount);
187 vlfc += READ_ONCE(stats->VLinkFailureCount);
188 mdac += READ_ONCE(stats->MissDiscAdvCount);
190 lesb->lesb_link_fail = htonl(lfc);
191 lesb->lesb_vlink_fail = htonl(vlfc);
192 lesb->lesb_miss_fka = htonl(mdac);
193 lesb->lesb_fcs_error =
194 htonl(dev_get_stats(netdev, &temp)->rx_crc_errors);
196 EXPORT_SYMBOL_GPL(__fcoe_get_lesb);
199 * fcoe_get_lesb() - Fill the FCoE Link Error Status Block
200 * @lport: the local port
201 * @fc_lesb: the link error status block
203 void fcoe_get_lesb(struct fc_lport *lport,
204 struct fc_els_lesb *fc_lesb)
206 struct net_device *netdev = fcoe_get_netdev(lport);
208 __fcoe_get_lesb(lport, fc_lesb, netdev);
210 EXPORT_SYMBOL_GPL(fcoe_get_lesb);
213 * fcoe_ctlr_get_lesb() - Get the Link Error Status Block (LESB) for a given
214 * fcoe controller device
215 * @ctlr_dev: The given fcoe controller device
218 void fcoe_ctlr_get_lesb(struct fcoe_ctlr_device *ctlr_dev)
220 struct fcoe_ctlr *fip = fcoe_ctlr_device_priv(ctlr_dev);
221 struct net_device *netdev = fcoe_get_netdev(fip->lp);
222 struct fc_els_lesb *fc_lesb;
224 fc_lesb = (struct fc_els_lesb *)(&ctlr_dev->lesb);
225 __fcoe_get_lesb(fip->lp, fc_lesb, netdev);
227 EXPORT_SYMBOL_GPL(fcoe_ctlr_get_lesb);
229 void fcoe_wwn_to_str(u64 wwn, char *buf, int len)
233 u64_to_wwn(wwn, wwpn);
234 snprintf(buf, len, "%02x%02x%02x%02x%02x%02x%02x%02x",
235 wwpn[0], wwpn[1], wwpn[2], wwpn[3],
236 wwpn[4], wwpn[5], wwpn[6], wwpn[7]);
238 EXPORT_SYMBOL_GPL(fcoe_wwn_to_str);
241 * fcoe_validate_vport_create() - Validate a vport before creating it
242 * @vport: NPIV port to be created
244 * This routine is meant to add validation for a vport before creating it
245 * via fcoe_vport_create().
246 * Current validations are:
247 * - WWPN supplied is unique for given lport
249 int fcoe_validate_vport_create(struct fc_vport *vport)
251 struct Scsi_Host *shost = vport_to_shost(vport);
252 struct fc_lport *n_port = shost_priv(shost);
253 struct fc_lport *vn_port;
257 mutex_lock(&n_port->lp_mutex);
259 fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf));
260 /* Check if the wwpn is not same as that of the lport */
261 if (!memcmp(&n_port->wwpn, &vport->port_name, sizeof(u64))) {
262 LIBFCOE_TRANSPORT_DBG("vport WWPN 0x%s is same as that of the "
263 "base port WWPN\n", buf);
268 /* Check if there is any existing vport with same wwpn */
269 list_for_each_entry(vn_port, &n_port->vports, list) {
270 if (!memcmp(&vn_port->wwpn, &vport->port_name, sizeof(u64))) {
271 LIBFCOE_TRANSPORT_DBG("vport with given WWPN 0x%s "
272 "already exists\n", buf);
278 mutex_unlock(&n_port->lp_mutex);
281 EXPORT_SYMBOL_GPL(fcoe_validate_vport_create);
284 * fcoe_get_wwn() - Get the world wide name from LLD if it supports it
285 * @netdev: the associated net device
286 * @wwn: the output WWN
287 * @type: the type of WWN (WWPN or WWNN)
289 * Returns: 0 for success
291 int fcoe_get_wwn(struct net_device *netdev, u64 *wwn, int type)
293 const struct net_device_ops *ops = netdev->netdev_ops;
295 if (ops->ndo_fcoe_get_wwn)
296 return ops->ndo_fcoe_get_wwn(netdev, wwn, type);
299 EXPORT_SYMBOL_GPL(fcoe_get_wwn);
302 * fcoe_fc_crc() - Calculates the CRC for a given frame
303 * @fp: The frame to be checksumed
305 * This uses crc32() routine to calculate the CRC for a frame
307 * Return: The 32 bit CRC value
309 u32 fcoe_fc_crc(struct fc_frame *fp)
311 struct sk_buff *skb = fp_skb(fp);
314 unsigned long off, len, clen;
318 crc = crc32(~0, skb->data, skb_headlen(skb));
320 for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) {
321 frag = &skb_shinfo(skb)->frags[i];
322 off = skb_frag_off(frag);
323 len = skb_frag_size(frag);
325 clen = min(len, PAGE_SIZE - (off & ~PAGE_MASK));
327 skb_frag_page(frag) + (off >> PAGE_SHIFT));
328 crc = crc32(crc, data + (off & ~PAGE_MASK), clen);
336 EXPORT_SYMBOL_GPL(fcoe_fc_crc);
339 * fcoe_start_io() - Start FCoE I/O
340 * @skb: The packet to be transmitted
342 * This routine is called from the net device to start transmitting
345 * Returns: 0 for success
347 int fcoe_start_io(struct sk_buff *skb)
349 struct sk_buff *nskb;
352 nskb = skb_clone(skb, GFP_ATOMIC);
355 rc = dev_queue_xmit(nskb);
361 EXPORT_SYMBOL_GPL(fcoe_start_io);
365 * fcoe_clean_pending_queue() - Dequeue a skb and free it
366 * @lport: The local port to dequeue a skb on
368 void fcoe_clean_pending_queue(struct fc_lport *lport)
370 struct fcoe_port *port = lport_priv(lport);
373 spin_lock_bh(&port->fcoe_pending_queue.lock);
374 while ((skb = __skb_dequeue(&port->fcoe_pending_queue)) != NULL) {
375 spin_unlock_bh(&port->fcoe_pending_queue.lock);
377 spin_lock_bh(&port->fcoe_pending_queue.lock);
379 spin_unlock_bh(&port->fcoe_pending_queue.lock);
381 EXPORT_SYMBOL_GPL(fcoe_clean_pending_queue);
384 * fcoe_check_wait_queue() - Attempt to clear the transmit backlog
385 * @lport: The local port whose backlog is to be cleared
386 * @skb: The received FIP packet
388 * This empties the wait_queue, dequeues the head of the wait_queue queue
389 * and calls fcoe_start_io() for each packet. If all skb have been
390 * transmitted it returns the qlen. If an error occurs it restores
391 * wait_queue (to try again later) and returns -1.
393 * The wait_queue is used when the skb transmit fails. The failed skb
394 * will go in the wait_queue which will be emptied by the timer function or
395 * by the next skb transmit.
397 void fcoe_check_wait_queue(struct fc_lport *lport, struct sk_buff *skb)
399 struct fcoe_port *port = lport_priv(lport);
402 spin_lock_bh(&port->fcoe_pending_queue.lock);
405 __skb_queue_tail(&port->fcoe_pending_queue, skb);
407 if (port->fcoe_pending_queue_active)
409 port->fcoe_pending_queue_active = 1;
411 while (port->fcoe_pending_queue.qlen) {
412 /* keep qlen > 0 until fcoe_start_io succeeds */
413 port->fcoe_pending_queue.qlen++;
414 skb = __skb_dequeue(&port->fcoe_pending_queue);
416 spin_unlock_bh(&port->fcoe_pending_queue.lock);
417 rc = fcoe_start_io(skb);
418 spin_lock_bh(&port->fcoe_pending_queue.lock);
421 __skb_queue_head(&port->fcoe_pending_queue, skb);
422 /* undo temporary increment above */
423 port->fcoe_pending_queue.qlen--;
426 /* undo temporary increment above */
427 port->fcoe_pending_queue.qlen--;
430 if (port->fcoe_pending_queue.qlen < port->min_queue_depth)
432 if (port->fcoe_pending_queue.qlen && !timer_pending(&port->timer))
433 mod_timer(&port->timer, jiffies + 2);
434 port->fcoe_pending_queue_active = 0;
436 if (port->fcoe_pending_queue.qlen > port->max_queue_depth)
438 spin_unlock_bh(&port->fcoe_pending_queue.lock);
440 EXPORT_SYMBOL_GPL(fcoe_check_wait_queue);
443 * fcoe_queue_timer() - The fcoe queue timer
444 * @t: Timer context use to obtain the FCoE port
446 * Calls fcoe_check_wait_queue on timeout
448 void fcoe_queue_timer(struct timer_list *t)
450 struct fcoe_port *port = from_timer(port, t, timer);
452 fcoe_check_wait_queue(port->lport, NULL);
454 EXPORT_SYMBOL_GPL(fcoe_queue_timer);
457 * fcoe_get_paged_crc_eof() - Allocate a page to be used for the trailer CRC
458 * @skb: The packet to be transmitted
459 * @tlen: The total length of the trailer
460 * @fps: The fcoe context
462 * This routine allocates a page for frame trailers. The page is re-used if
463 * there is enough room left on it for the current trailer. If there isn't
464 * enough buffer left a new page is allocated for the trailer. Reference to
465 * the page from this function as well as the skbs using the page fragments
466 * ensure that the page is freed at the appropriate time.
468 * Returns: 0 for success
470 int fcoe_get_paged_crc_eof(struct sk_buff *skb, int tlen,
471 struct fcoe_percpu_s *fps)
475 page = fps->crc_eof_page;
477 page = alloc_page(GFP_ATOMIC);
481 fps->crc_eof_page = page;
482 fps->crc_eof_offset = 0;
486 skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags, page,
487 fps->crc_eof_offset, tlen);
489 skb->data_len += tlen;
490 skb->truesize += tlen;
491 fps->crc_eof_offset += sizeof(struct fcoe_crc_eof);
493 if (fps->crc_eof_offset >= PAGE_SIZE) {
494 fps->crc_eof_page = NULL;
495 fps->crc_eof_offset = 0;
501 EXPORT_SYMBOL_GPL(fcoe_get_paged_crc_eof);
504 * fcoe_transport_lookup - find an fcoe transport that matches a netdev
505 * @netdev: The netdev to look for from all attached transports
507 * Returns : ptr to the fcoe transport that supports this netdev or NULL
510 * The ft_mutex should be held when this is called
512 static struct fcoe_transport *fcoe_transport_lookup(struct net_device *netdev)
514 struct fcoe_transport *ft = NULL;
516 list_for_each_entry(ft, &fcoe_transports, list)
517 if (ft->match && ft->match(netdev))
523 * fcoe_transport_attach - Attaches an FCoE transport
524 * @ft: The fcoe transport to be attached
526 * Returns : 0 for success
528 int fcoe_transport_attach(struct fcoe_transport *ft)
532 mutex_lock(&ft_mutex);
534 LIBFCOE_TRANSPORT_DBG("transport %s already attached\n",
540 /* Add default transport to the tail */
541 if (strcmp(ft->name, FCOE_TRANSPORT_DEFAULT))
542 list_add(&ft->list, &fcoe_transports);
544 list_add_tail(&ft->list, &fcoe_transports);
547 LIBFCOE_TRANSPORT_DBG("attaching transport %s\n", ft->name);
550 mutex_unlock(&ft_mutex);
553 EXPORT_SYMBOL(fcoe_transport_attach);
556 * fcoe_transport_detach - Detaches an FCoE transport
557 * @ft: The fcoe transport to be attached
559 * Returns : 0 for success
561 int fcoe_transport_detach(struct fcoe_transport *ft)
564 struct fcoe_netdev_mapping *nm = NULL, *tmp;
566 mutex_lock(&ft_mutex);
568 LIBFCOE_TRANSPORT_DBG("transport %s already detached\n",
574 /* remove netdev mapping for this transport as it is going away */
575 mutex_lock(&fn_mutex);
576 list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) {
578 LIBFCOE_TRANSPORT_DBG("transport %s going away, "
579 "remove its netdev mapping for %s\n",
580 ft->name, nm->netdev->name);
585 mutex_unlock(&fn_mutex);
588 ft->attached = false;
589 LIBFCOE_TRANSPORT_DBG("detaching transport %s\n", ft->name);
592 mutex_unlock(&ft_mutex);
596 EXPORT_SYMBOL(fcoe_transport_detach);
598 static int fcoe_transport_show(char *buffer, const struct kernel_param *kp)
601 struct fcoe_transport *ft = NULL;
603 i = j = sprintf(buffer, "Attached FCoE transports:");
604 mutex_lock(&ft_mutex);
605 list_for_each_entry(ft, &fcoe_transports, list) {
606 if (i >= PAGE_SIZE - IFNAMSIZ)
608 i += snprintf(&buffer[i], IFNAMSIZ, "%s ", ft->name);
610 mutex_unlock(&ft_mutex);
612 i += snprintf(&buffer[i], IFNAMSIZ, "none");
616 static int __init fcoe_transport_init(void)
618 register_netdevice_notifier(&libfcoe_notifier);
622 static int fcoe_transport_exit(void)
624 struct fcoe_transport *ft;
626 unregister_netdevice_notifier(&libfcoe_notifier);
627 mutex_lock(&ft_mutex);
628 list_for_each_entry(ft, &fcoe_transports, list)
629 printk(KERN_ERR "FCoE transport %s is still attached!\n",
631 mutex_unlock(&ft_mutex);
636 static int fcoe_add_netdev_mapping(struct net_device *netdev,
637 struct fcoe_transport *ft)
639 struct fcoe_netdev_mapping *nm;
641 nm = kmalloc(sizeof(*nm), GFP_KERNEL);
643 printk(KERN_ERR "Unable to allocate netdev_mapping");
650 mutex_lock(&fn_mutex);
651 list_add(&nm->list, &fcoe_netdevs);
652 mutex_unlock(&fn_mutex);
657 static void fcoe_del_netdev_mapping(struct net_device *netdev)
659 struct fcoe_netdev_mapping *nm = NULL, *tmp;
661 mutex_lock(&fn_mutex);
662 list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) {
663 if (nm->netdev == netdev) {
666 mutex_unlock(&fn_mutex);
670 mutex_unlock(&fn_mutex);
675 * fcoe_netdev_map_lookup - find the fcoe transport that matches the netdev on which
677 * @netdev: The net device that the FCoE interface is on
679 * Returns : ptr to the fcoe transport that supports this netdev or NULL
682 * The ft_mutex should be held when this is called
684 static struct fcoe_transport *fcoe_netdev_map_lookup(struct net_device *netdev)
686 struct fcoe_transport *ft = NULL;
687 struct fcoe_netdev_mapping *nm;
689 mutex_lock(&fn_mutex);
690 list_for_each_entry(nm, &fcoe_netdevs, list) {
691 if (netdev == nm->netdev) {
693 mutex_unlock(&fn_mutex);
698 mutex_unlock(&fn_mutex);
703 * fcoe_if_to_netdev() - Parse a name buffer to get a net device
704 * @buffer: The name of the net device
706 * Returns: NULL or a ptr to net_device
708 static struct net_device *fcoe_if_to_netdev(const char *buffer)
711 char ifname[IFNAMSIZ + 2];
714 strlcpy(ifname, buffer, IFNAMSIZ);
715 cp = ifname + strlen(ifname);
716 while (--cp >= ifname && *cp == '\n')
718 return dev_get_by_name(&init_net, ifname);
724 * libfcoe_device_notification() - Handler for net device events
725 * @notifier: The context of the notification
726 * @event: The type of event
727 * @ptr: The net device that the event was on
729 * This function is called by the Ethernet driver in case of link change event.
731 * Returns: 0 for success
733 static int libfcoe_device_notification(struct notifier_block *notifier,
734 ulong event, void *ptr)
736 struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
739 case NETDEV_UNREGISTER:
740 LIBFCOE_TRANSPORT_DBG("NETDEV_UNREGISTER %s\n",
742 fcoe_del_netdev_mapping(netdev);
748 ssize_t fcoe_ctlr_create_store(struct bus_type *bus,
749 const char *buf, size_t count)
751 struct net_device *netdev = NULL;
752 struct fcoe_transport *ft = NULL;
756 mutex_lock(&ft_mutex);
758 netdev = fcoe_if_to_netdev(buf);
760 LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buf);
765 ft = fcoe_netdev_map_lookup(netdev);
767 LIBFCOE_TRANSPORT_DBG("transport %s already has existing "
768 "FCoE instance on %s.\n",
769 ft->name, netdev->name);
774 ft = fcoe_transport_lookup(netdev);
776 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
782 /* pass to transport create */
783 err = ft->alloc ? ft->alloc(netdev) : -ENODEV;
785 fcoe_del_netdev_mapping(netdev);
790 err = fcoe_add_netdev_mapping(netdev, ft);
792 LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping "
793 "for FCoE transport %s for %s.\n",
794 ft->name, netdev->name);
799 LIBFCOE_TRANSPORT_DBG("transport %s succeeded to create fcoe on %s.\n",
800 ft->name, netdev->name);
805 mutex_unlock(&ft_mutex);
811 ssize_t fcoe_ctlr_destroy_store(struct bus_type *bus,
812 const char *buf, size_t count)
815 struct net_device *netdev = NULL;
816 struct fcoe_transport *ft = NULL;
818 mutex_lock(&ft_mutex);
820 netdev = fcoe_if_to_netdev(buf);
822 LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buf);
826 ft = fcoe_netdev_map_lookup(netdev);
828 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
833 /* pass to transport destroy */
834 rc = ft->destroy(netdev);
838 fcoe_del_netdev_mapping(netdev);
839 LIBFCOE_TRANSPORT_DBG("transport %s %s to destroy fcoe on %s.\n",
840 ft->name, (rc) ? "failed" : "succeeded",
842 rc = count; /* required for successful return */
846 mutex_unlock(&ft_mutex);
851 * fcoe_transport_create() - Create a fcoe interface
852 * @buffer: The name of the Ethernet interface to create on
853 * @kp: The associated kernel param
855 * Called from sysfs. This holds the ft_mutex while calling the
856 * registered fcoe transport's create function.
858 * Returns: 0 for success
860 static int fcoe_transport_create(const char *buffer,
861 const struct kernel_param *kp)
864 struct net_device *netdev = NULL;
865 struct fcoe_transport *ft = NULL;
866 enum fip_mode fip_mode = (enum fip_mode)(uintptr_t)kp->arg;
868 mutex_lock(&ft_mutex);
870 netdev = fcoe_if_to_netdev(buffer);
872 LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buffer);
876 ft = fcoe_netdev_map_lookup(netdev);
878 LIBFCOE_TRANSPORT_DBG("transport %s already has existing "
879 "FCoE instance on %s.\n",
880 ft->name, netdev->name);
885 ft = fcoe_transport_lookup(netdev);
887 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
892 rc = fcoe_add_netdev_mapping(netdev, ft);
894 LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping "
895 "for FCoE transport %s for %s.\n",
896 ft->name, netdev->name);
900 /* pass to transport create */
901 rc = ft->create ? ft->create(netdev, fip_mode) : -ENODEV;
903 fcoe_del_netdev_mapping(netdev);
905 LIBFCOE_TRANSPORT_DBG("transport %s %s to create fcoe on %s.\n",
906 ft->name, (rc) ? "failed" : "succeeded",
912 mutex_unlock(&ft_mutex);
917 * fcoe_transport_destroy() - Destroy a FCoE interface
918 * @buffer: The name of the Ethernet interface to be destroyed
919 * @kp: The associated kernel parameter
921 * Called from sysfs. This holds the ft_mutex while calling the
922 * registered fcoe transport's destroy function.
924 * Returns: 0 for success
926 static int fcoe_transport_destroy(const char *buffer,
927 const struct kernel_param *kp)
930 struct net_device *netdev = NULL;
931 struct fcoe_transport *ft = NULL;
933 mutex_lock(&ft_mutex);
935 netdev = fcoe_if_to_netdev(buffer);
937 LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buffer);
941 ft = fcoe_netdev_map_lookup(netdev);
943 LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
948 /* pass to transport destroy */
949 rc = ft->destroy ? ft->destroy(netdev) : -ENODEV;
950 fcoe_del_netdev_mapping(netdev);
951 LIBFCOE_TRANSPORT_DBG("transport %s %s to destroy fcoe on %s.\n",
952 ft->name, (rc) ? "failed" : "succeeded",
958 mutex_unlock(&ft_mutex);
963 * fcoe_transport_disable() - Disables a FCoE interface
964 * @buffer: The name of the Ethernet interface to be disabled
965 * @kp: The associated kernel parameter
969 * Returns: 0 for success
971 static int fcoe_transport_disable(const char *buffer,
972 const struct kernel_param *kp)
975 struct net_device *netdev = NULL;
976 struct fcoe_transport *ft = NULL;
978 mutex_lock(&ft_mutex);
980 netdev = fcoe_if_to_netdev(buffer);
984 ft = fcoe_netdev_map_lookup(netdev);
988 rc = ft->disable ? ft->disable(netdev) : -ENODEV;
993 mutex_unlock(&ft_mutex);
998 * fcoe_transport_enable() - Enables a FCoE interface
999 * @buffer: The name of the Ethernet interface to be enabled
1000 * @kp: The associated kernel parameter
1002 * Called from sysfs.
1004 * Returns: 0 for success
1006 static int fcoe_transport_enable(const char *buffer,
1007 const struct kernel_param *kp)
1010 struct net_device *netdev = NULL;
1011 struct fcoe_transport *ft = NULL;
1013 mutex_lock(&ft_mutex);
1015 netdev = fcoe_if_to_netdev(buffer);
1019 ft = fcoe_netdev_map_lookup(netdev);
1023 rc = ft->enable ? ft->enable(netdev) : -ENODEV;
1028 mutex_unlock(&ft_mutex);
1033 * libfcoe_init() - Initialization routine for libfcoe.ko
1035 static int __init libfcoe_init(void)
1039 rc = fcoe_transport_init();
1043 rc = fcoe_sysfs_setup();
1045 fcoe_transport_exit();
1049 module_init(libfcoe_init);
1052 * libfcoe_exit() - Tear down libfcoe.ko
1054 static void __exit libfcoe_exit(void)
1056 fcoe_sysfs_teardown();
1057 fcoe_transport_exit();
1059 module_exit(libfcoe_exit);