1 // SPDX-License-Identifier: GPL-2.0-only
2 /*
3  * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved.
4  *
5  * Maintained at www.Open-FCoE.org
6  */
7 
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>
17 
18 #include "libfcoe.h"
19 
20 MODULE_AUTHOR("Open-FCoE.org");
21 MODULE_DESCRIPTION("FIP discovery protocol and FCoE transport for FCoE HBAs");
22 MODULE_LICENSE("GPL v2");
23 
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);
33 
34 static LIST_HEAD(fcoe_transports);
35 static DEFINE_MUTEX(ft_mutex);
36 static LIST_HEAD(fcoe_netdevs);
37 static DEFINE_MUTEX(fn_mutex);
38 
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");
42 
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");
46 
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");
51 
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");
57 
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");
61 
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.");
65 
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.");
69 
70 /* notification function for packets from net device */
71 static struct notifier_block libfcoe_notifier = {
72 	.notifier_call = libfcoe_device_notification,
73 };
74 
75 static const struct {
76 	u32 fc_port_speed;
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
82 	u32 eth_port_speed;
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 },
96 };
97 
98 static inline u32 eth2fc_speed(u32 eth_port_speed)
99 {
100 	int i;
101 
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;
105 	}
106 
107 	return FC_PORTSPEED_UNKNOWN;
108 }
109 
110 /**
111  * fcoe_link_speed_update() - Update the supported and actual link speeds
112  * @lport: The local port to update speeds for
113  *
114  * Returns: 0 if the ethtool query was successful
115  *          -1 if the ethtool query failed
116  */
117 int fcoe_link_speed_update(struct fc_lport *lport)
118 {
119 	struct net_device *netdev = fcoe_get_netdev(lport);
120 	struct ethtool_link_ksettings ecmd;
121 
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);
127 
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;
133 
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;
140 
141 		if (ecmd.link_modes.supported[0] & (
142 			    SUPPORTED_20000baseMLD2_Full |
143 			    SUPPORTED_20000baseKR2_Full))
144 			lport->link_supported_speeds |= FC_PORTSPEED_20GBIT;
145 
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;
152 
153 		lport->link_speed = eth2fc_speed(ecmd.base.speed);
154 		return 0;
155 	}
156 	return -1;
157 }
158 EXPORT_SYMBOL_GPL(fcoe_link_speed_update);
159 
160 /**
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
165  *
166  * Note, the Link Error Status Block (LESB) for FCoE is defined in FC-BB-6
167  * Clause 7.11 in v1.04.
168  */
169 void __fcoe_get_lesb(struct fc_lport *lport,
170 		     struct fc_els_lesb *fc_lesb,
171 		     struct net_device *netdev)
172 {
173 	unsigned int cpu;
174 	u32 lfc, vlfc, mdac;
175 	struct fc_stats *stats;
176 	struct fcoe_fc_els_lesb *lesb;
177 	struct rtnl_link_stats64 temp;
178 
179 	lfc = 0;
180 	vlfc = 0;
181 	mdac = 0;
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 += stats->LinkFailureCount;
187 		vlfc += stats->VLinkFailureCount;
188 		mdac += stats->MissDiscAdvCount;
189 	}
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);
195 }
196 EXPORT_SYMBOL_GPL(__fcoe_get_lesb);
197 
198 /**
199  * fcoe_get_lesb() - Fill the FCoE Link Error Status Block
200  * @lport: the local port
201  * @fc_lesb: the link error status block
202  */
203 void fcoe_get_lesb(struct fc_lport *lport,
204 			 struct fc_els_lesb *fc_lesb)
205 {
206 	struct net_device *netdev = fcoe_get_netdev(lport);
207 
208 	__fcoe_get_lesb(lport, fc_lesb, netdev);
209 }
210 EXPORT_SYMBOL_GPL(fcoe_get_lesb);
211 
212 /**
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
216  *
217  */
218 void fcoe_ctlr_get_lesb(struct fcoe_ctlr_device *ctlr_dev)
219 {
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;
223 
224 	fc_lesb = (struct fc_els_lesb *)(&ctlr_dev->lesb);
225 	__fcoe_get_lesb(fip->lp, fc_lesb, netdev);
226 }
227 EXPORT_SYMBOL_GPL(fcoe_ctlr_get_lesb);
228 
229 void fcoe_wwn_to_str(u64 wwn, char *buf, int len)
230 {
231 	u8 wwpn[8];
232 
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]);
237 }
238 EXPORT_SYMBOL_GPL(fcoe_wwn_to_str);
239 
240 /**
241  * fcoe_validate_vport_create() - Validate a vport before creating it
242  * @vport: NPIV port to be created
243  *
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
248  */
249 int fcoe_validate_vport_create(struct fc_vport *vport)
250 {
251 	struct Scsi_Host *shost = vport_to_shost(vport);
252 	struct fc_lport *n_port = shost_priv(shost);
253 	struct fc_lport *vn_port;
254 	int rc = 0;
255 	char buf[32];
256 
257 	mutex_lock(&n_port->lp_mutex);
258 
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);
264 		rc = -EINVAL;
265 		goto out;
266 	}
267 
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);
273 			rc = -EINVAL;
274 			break;
275 		}
276 	}
277 out:
278 	mutex_unlock(&n_port->lp_mutex);
279 	return rc;
280 }
281 EXPORT_SYMBOL_GPL(fcoe_validate_vport_create);
282 
283 /**
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)
288  *
289  * Returns: 0 for success
290  */
291 int fcoe_get_wwn(struct net_device *netdev, u64 *wwn, int type)
292 {
293 	const struct net_device_ops *ops = netdev->netdev_ops;
294 
295 	if (ops->ndo_fcoe_get_wwn)
296 		return ops->ndo_fcoe_get_wwn(netdev, wwn, type);
297 	return -EINVAL;
298 }
299 EXPORT_SYMBOL_GPL(fcoe_get_wwn);
300 
301 /**
302  * fcoe_fc_crc() - Calculates the CRC for a given frame
303  * @fp: The frame to be checksumed
304  *
305  * This uses crc32() routine to calculate the CRC for a frame
306  *
307  * Return: The 32 bit CRC value
308  */
309 u32 fcoe_fc_crc(struct fc_frame *fp)
310 {
311 	struct sk_buff *skb = fp_skb(fp);
312 	skb_frag_t *frag;
313 	unsigned char *data;
314 	unsigned long off, len, clen;
315 	u32 crc;
316 	unsigned i;
317 
318 	crc = crc32(~0, skb->data, skb_headlen(skb));
319 
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);
324 		while (len > 0) {
325 			clen = min(len, PAGE_SIZE - (off & ~PAGE_MASK));
326 			data = kmap_atomic(
327 				skb_frag_page(frag) + (off >> PAGE_SHIFT));
328 			crc = crc32(crc, data + (off & ~PAGE_MASK), clen);
329 			kunmap_atomic(data);
330 			off += clen;
331 			len -= clen;
332 		}
333 	}
334 	return crc;
335 }
336 EXPORT_SYMBOL_GPL(fcoe_fc_crc);
337 
338 /**
339  * fcoe_start_io() - Start FCoE I/O
340  * @skb: The packet to be transmitted
341  *
342  * This routine is called from the net device to start transmitting
343  * FCoE packets.
344  *
345  * Returns: 0 for success
346  */
347 int fcoe_start_io(struct sk_buff *skb)
348 {
349 	struct sk_buff *nskb;
350 	int rc;
351 
352 	nskb = skb_clone(skb, GFP_ATOMIC);
353 	if (!nskb)
354 		return -ENOMEM;
355 	rc = dev_queue_xmit(nskb);
356 	if (rc != 0)
357 		return rc;
358 	kfree_skb(skb);
359 	return 0;
360 }
361 EXPORT_SYMBOL_GPL(fcoe_start_io);
362 
363 
364 /**
365  * fcoe_clean_pending_queue() - Dequeue a skb and free it
366  * @lport: The local port to dequeue a skb on
367  */
368 void fcoe_clean_pending_queue(struct fc_lport *lport)
369 {
370 	struct fcoe_port  *port = lport_priv(lport);
371 	struct sk_buff *skb;
372 
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);
376 		kfree_skb(skb);
377 		spin_lock_bh(&port->fcoe_pending_queue.lock);
378 	}
379 	spin_unlock_bh(&port->fcoe_pending_queue.lock);
380 }
381 EXPORT_SYMBOL_GPL(fcoe_clean_pending_queue);
382 
383 /**
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
387  *
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.
392  *
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.
396  */
397 void fcoe_check_wait_queue(struct fc_lport *lport, struct sk_buff *skb)
398 {
399 	struct fcoe_port *port = lport_priv(lport);
400 	int rc;
401 
402 	spin_lock_bh(&port->fcoe_pending_queue.lock);
403 
404 	if (skb)
405 		__skb_queue_tail(&port->fcoe_pending_queue, skb);
406 
407 	if (port->fcoe_pending_queue_active)
408 		goto out;
409 	port->fcoe_pending_queue_active = 1;
410 
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);
415 
416 		spin_unlock_bh(&port->fcoe_pending_queue.lock);
417 		rc = fcoe_start_io(skb);
418 		spin_lock_bh(&port->fcoe_pending_queue.lock);
419 
420 		if (rc) {
421 			__skb_queue_head(&port->fcoe_pending_queue, skb);
422 			/* undo temporary increment above */
423 			port->fcoe_pending_queue.qlen--;
424 			break;
425 		}
426 		/* undo temporary increment above */
427 		port->fcoe_pending_queue.qlen--;
428 	}
429 
430 	if (port->fcoe_pending_queue.qlen < port->min_queue_depth)
431 		lport->qfull = 0;
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;
435 out:
436 	if (port->fcoe_pending_queue.qlen > port->max_queue_depth)
437 		lport->qfull = 1;
438 	spin_unlock_bh(&port->fcoe_pending_queue.lock);
439 }
440 EXPORT_SYMBOL_GPL(fcoe_check_wait_queue);
441 
442 /**
443  * fcoe_queue_timer() - The fcoe queue timer
444  * @t: Timer context use to obtain the FCoE port
445  *
446  * Calls fcoe_check_wait_queue on timeout
447  */
448 void fcoe_queue_timer(struct timer_list *t)
449 {
450 	struct fcoe_port *port = from_timer(port, t, timer);
451 
452 	fcoe_check_wait_queue(port->lport, NULL);
453 }
454 EXPORT_SYMBOL_GPL(fcoe_queue_timer);
455 
456 /**
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
461  *
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.
467  *
468  * Returns: 0 for success
469  */
470 int fcoe_get_paged_crc_eof(struct sk_buff *skb, int tlen,
471 			   struct fcoe_percpu_s *fps)
472 {
473 	struct page *page;
474 
475 	page = fps->crc_eof_page;
476 	if (!page) {
477 		page = alloc_page(GFP_ATOMIC);
478 		if (!page)
479 			return -ENOMEM;
480 
481 		fps->crc_eof_page = page;
482 		fps->crc_eof_offset = 0;
483 	}
484 
485 	get_page(page);
486 	skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags, page,
487 			   fps->crc_eof_offset, tlen);
488 	skb->len += tlen;
489 	skb->data_len += tlen;
490 	skb->truesize += tlen;
491 	fps->crc_eof_offset += sizeof(struct fcoe_crc_eof);
492 
493 	if (fps->crc_eof_offset >= PAGE_SIZE) {
494 		fps->crc_eof_page = NULL;
495 		fps->crc_eof_offset = 0;
496 		put_page(page);
497 	}
498 
499 	return 0;
500 }
501 EXPORT_SYMBOL_GPL(fcoe_get_paged_crc_eof);
502 
503 /**
504  * fcoe_transport_lookup - find an fcoe transport that matches a netdev
505  * @netdev: The netdev to look for from all attached transports
506  *
507  * Returns : ptr to the fcoe transport that supports this netdev or NULL
508  * if not found.
509  *
510  * The ft_mutex should be held when this is called
511  */
512 static struct fcoe_transport *fcoe_transport_lookup(struct net_device *netdev)
513 {
514 	struct fcoe_transport *ft = NULL;
515 
516 	list_for_each_entry(ft, &fcoe_transports, list)
517 		if (ft->match && ft->match(netdev))
518 			return ft;
519 	return NULL;
520 }
521 
522 /**
523  * fcoe_transport_attach - Attaches an FCoE transport
524  * @ft: The fcoe transport to be attached
525  *
526  * Returns : 0 for success
527  */
528 int fcoe_transport_attach(struct fcoe_transport *ft)
529 {
530 	int rc = 0;
531 
532 	mutex_lock(&ft_mutex);
533 	if (ft->attached) {
534 		LIBFCOE_TRANSPORT_DBG("transport %s already attached\n",
535 				       ft->name);
536 		rc = -EEXIST;
537 		goto out_attach;
538 	}
539 
540 	/* Add default transport to the tail */
541 	if (strcmp(ft->name, FCOE_TRANSPORT_DEFAULT))
542 		list_add(&ft->list, &fcoe_transports);
543 	else
544 		list_add_tail(&ft->list, &fcoe_transports);
545 
546 	ft->attached = true;
547 	LIBFCOE_TRANSPORT_DBG("attaching transport %s\n", ft->name);
548 
549 out_attach:
550 	mutex_unlock(&ft_mutex);
551 	return rc;
552 }
553 EXPORT_SYMBOL(fcoe_transport_attach);
554 
555 /**
556  * fcoe_transport_detach - Detaches an FCoE transport
557  * @ft: The fcoe transport to be attached
558  *
559  * Returns : 0 for success
560  */
561 int fcoe_transport_detach(struct fcoe_transport *ft)
562 {
563 	int rc = 0;
564 	struct fcoe_netdev_mapping *nm = NULL, *tmp;
565 
566 	mutex_lock(&ft_mutex);
567 	if (!ft->attached) {
568 		LIBFCOE_TRANSPORT_DBG("transport %s already detached\n",
569 			ft->name);
570 		rc = -ENODEV;
571 		goto out_attach;
572 	}
573 
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) {
577 		if (nm->ft == ft) {
578 			LIBFCOE_TRANSPORT_DBG("transport %s going away, "
579 				"remove its netdev mapping for %s\n",
580 				ft->name, nm->netdev->name);
581 			list_del(&nm->list);
582 			kfree(nm);
583 		}
584 	}
585 	mutex_unlock(&fn_mutex);
586 
587 	list_del(&ft->list);
588 	ft->attached = false;
589 	LIBFCOE_TRANSPORT_DBG("detaching transport %s\n", ft->name);
590 
591 out_attach:
592 	mutex_unlock(&ft_mutex);
593 	return rc;
594 
595 }
596 EXPORT_SYMBOL(fcoe_transport_detach);
597 
598 static int fcoe_transport_show(char *buffer, const struct kernel_param *kp)
599 {
600 	int i, j;
601 	struct fcoe_transport *ft = NULL;
602 
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)
607 			break;
608 		i += snprintf(&buffer[i], IFNAMSIZ, "%s ", ft->name);
609 	}
610 	mutex_unlock(&ft_mutex);
611 	if (i == j)
612 		i += snprintf(&buffer[i], IFNAMSIZ, "none");
613 	return i;
614 }
615 
616 static int __init fcoe_transport_init(void)
617 {
618 	register_netdevice_notifier(&libfcoe_notifier);
619 	return 0;
620 }
621 
622 static int fcoe_transport_exit(void)
623 {
624 	struct fcoe_transport *ft;
625 
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",
630 		      ft->name);
631 	mutex_unlock(&ft_mutex);
632 	return 0;
633 }
634 
635 
636 static int fcoe_add_netdev_mapping(struct net_device *netdev,
637 					struct fcoe_transport *ft)
638 {
639 	struct fcoe_netdev_mapping *nm;
640 
641 	nm = kmalloc(sizeof(*nm), GFP_KERNEL);
642 	if (!nm) {
643 		printk(KERN_ERR "Unable to allocate netdev_mapping");
644 		return -ENOMEM;
645 	}
646 
647 	nm->netdev = netdev;
648 	nm->ft = ft;
649 
650 	mutex_lock(&fn_mutex);
651 	list_add(&nm->list, &fcoe_netdevs);
652 	mutex_unlock(&fn_mutex);
653 	return 0;
654 }
655 
656 
657 static void fcoe_del_netdev_mapping(struct net_device *netdev)
658 {
659 	struct fcoe_netdev_mapping *nm = NULL, *tmp;
660 
661 	mutex_lock(&fn_mutex);
662 	list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) {
663 		if (nm->netdev == netdev) {
664 			list_del(&nm->list);
665 			kfree(nm);
666 			mutex_unlock(&fn_mutex);
667 			return;
668 		}
669 	}
670 	mutex_unlock(&fn_mutex);
671 }
672 
673 
674 /**
675  * fcoe_netdev_map_lookup - find the fcoe transport that matches the netdev on which
676  * it was created
677  * @netdev: The net device that the FCoE interface is on
678  *
679  * Returns : ptr to the fcoe transport that supports this netdev or NULL
680  * if not found.
681  *
682  * The ft_mutex should be held when this is called
683  */
684 static struct fcoe_transport *fcoe_netdev_map_lookup(struct net_device *netdev)
685 {
686 	struct fcoe_transport *ft = NULL;
687 	struct fcoe_netdev_mapping *nm;
688 
689 	mutex_lock(&fn_mutex);
690 	list_for_each_entry(nm, &fcoe_netdevs, list) {
691 		if (netdev == nm->netdev) {
692 			ft = nm->ft;
693 			mutex_unlock(&fn_mutex);
694 			return ft;
695 		}
696 	}
697 
698 	mutex_unlock(&fn_mutex);
699 	return NULL;
700 }
701 
702 /**
703  * fcoe_if_to_netdev() - Parse a name buffer to get a net device
704  * @buffer: The name of the net device
705  *
706  * Returns: NULL or a ptr to net_device
707  */
708 static struct net_device *fcoe_if_to_netdev(const char *buffer)
709 {
710 	char *cp;
711 	char ifname[IFNAMSIZ + 2];
712 
713 	if (buffer) {
714 		strlcpy(ifname, buffer, IFNAMSIZ);
715 		cp = ifname + strlen(ifname);
716 		while (--cp >= ifname && *cp == '\n')
717 			*cp = '\0';
718 		return dev_get_by_name(&init_net, ifname);
719 	}
720 	return NULL;
721 }
722 
723 /**
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
728  *
729  * This function is called by the Ethernet driver in case of link change event.
730  *
731  * Returns: 0 for success
732  */
733 static int libfcoe_device_notification(struct notifier_block *notifier,
734 				    ulong event, void *ptr)
735 {
736 	struct net_device *netdev = netdev_notifier_info_to_dev(ptr);
737 
738 	switch (event) {
739 	case NETDEV_UNREGISTER:
740 		LIBFCOE_TRANSPORT_DBG("NETDEV_UNREGISTER %s\n",
741 				      netdev->name);
742 		fcoe_del_netdev_mapping(netdev);
743 		break;
744 	}
745 	return NOTIFY_OK;
746 }
747 
748 ssize_t fcoe_ctlr_create_store(struct bus_type *bus,
749 			       const char *buf, size_t count)
750 {
751 	struct net_device *netdev = NULL;
752 	struct fcoe_transport *ft = NULL;
753 	int rc = 0;
754 	int err;
755 
756 	mutex_lock(&ft_mutex);
757 
758 	netdev = fcoe_if_to_netdev(buf);
759 	if (!netdev) {
760 		LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buf);
761 		rc = -ENODEV;
762 		goto out_nodev;
763 	}
764 
765 	ft = fcoe_netdev_map_lookup(netdev);
766 	if (ft) {
767 		LIBFCOE_TRANSPORT_DBG("transport %s already has existing "
768 				      "FCoE instance on %s.\n",
769 				      ft->name, netdev->name);
770 		rc = -EEXIST;
771 		goto out_putdev;
772 	}
773 
774 	ft = fcoe_transport_lookup(netdev);
775 	if (!ft) {
776 		LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
777 				      netdev->name);
778 		rc = -ENODEV;
779 		goto out_putdev;
780 	}
781 
782 	/* pass to transport create */
783 	err = ft->alloc ? ft->alloc(netdev) : -ENODEV;
784 	if (err) {
785 		fcoe_del_netdev_mapping(netdev);
786 		rc = -ENOMEM;
787 		goto out_putdev;
788 	}
789 
790 	err = fcoe_add_netdev_mapping(netdev, ft);
791 	if (err) {
792 		LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping "
793 				      "for FCoE transport %s for %s.\n",
794 				      ft->name, netdev->name);
795 		rc = -ENODEV;
796 		goto out_putdev;
797 	}
798 
799 	LIBFCOE_TRANSPORT_DBG("transport %s succeeded to create fcoe on %s.\n",
800 			      ft->name, netdev->name);
801 
802 out_putdev:
803 	dev_put(netdev);
804 out_nodev:
805 	mutex_unlock(&ft_mutex);
806 	if (rc)
807 		return rc;
808 	return count;
809 }
810 
811 ssize_t fcoe_ctlr_destroy_store(struct bus_type *bus,
812 				const char *buf, size_t count)
813 {
814 	int rc = -ENODEV;
815 	struct net_device *netdev = NULL;
816 	struct fcoe_transport *ft = NULL;
817 
818 	mutex_lock(&ft_mutex);
819 
820 	netdev = fcoe_if_to_netdev(buf);
821 	if (!netdev) {
822 		LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buf);
823 		goto out_nodev;
824 	}
825 
826 	ft = fcoe_netdev_map_lookup(netdev);
827 	if (!ft) {
828 		LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
829 				      netdev->name);
830 		goto out_putdev;
831 	}
832 
833 	/* pass to transport destroy */
834 	rc = ft->destroy(netdev);
835 	if (rc)
836 		goto out_putdev;
837 
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",
841 			      netdev->name);
842 	rc = count; /* required for successful return */
843 out_putdev:
844 	dev_put(netdev);
845 out_nodev:
846 	mutex_unlock(&ft_mutex);
847 	return rc;
848 }
849 
850 /**
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
854  *
855  * Called from sysfs. This holds the ft_mutex while calling the
856  * registered fcoe transport's create function.
857  *
858  * Returns: 0 for success
859  */
860 static int fcoe_transport_create(const char *buffer,
861 				 const struct kernel_param *kp)
862 {
863 	int rc = -ENODEV;
864 	struct net_device *netdev = NULL;
865 	struct fcoe_transport *ft = NULL;
866 	enum fip_mode fip_mode = (enum fip_mode)kp->arg;
867 
868 	mutex_lock(&ft_mutex);
869 
870 	netdev = fcoe_if_to_netdev(buffer);
871 	if (!netdev) {
872 		LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buffer);
873 		goto out_nodev;
874 	}
875 
876 	ft = fcoe_netdev_map_lookup(netdev);
877 	if (ft) {
878 		LIBFCOE_TRANSPORT_DBG("transport %s already has existing "
879 				      "FCoE instance on %s.\n",
880 				      ft->name, netdev->name);
881 		rc = -EEXIST;
882 		goto out_putdev;
883 	}
884 
885 	ft = fcoe_transport_lookup(netdev);
886 	if (!ft) {
887 		LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
888 				      netdev->name);
889 		goto out_putdev;
890 	}
891 
892 	rc = fcoe_add_netdev_mapping(netdev, ft);
893 	if (rc) {
894 		LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping "
895 				      "for FCoE transport %s for %s.\n",
896 				      ft->name, netdev->name);
897 		goto out_putdev;
898 	}
899 
900 	/* pass to transport create */
901 	rc = ft->create ? ft->create(netdev, fip_mode) : -ENODEV;
902 	if (rc)
903 		fcoe_del_netdev_mapping(netdev);
904 
905 	LIBFCOE_TRANSPORT_DBG("transport %s %s to create fcoe on %s.\n",
906 			      ft->name, (rc) ? "failed" : "succeeded",
907 			      netdev->name);
908 
909 out_putdev:
910 	dev_put(netdev);
911 out_nodev:
912 	mutex_unlock(&ft_mutex);
913 	return rc;
914 }
915 
916 /**
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
920  *
921  * Called from sysfs. This holds the ft_mutex while calling the
922  * registered fcoe transport's destroy function.
923  *
924  * Returns: 0 for success
925  */
926 static int fcoe_transport_destroy(const char *buffer,
927 				  const struct kernel_param *kp)
928 {
929 	int rc = -ENODEV;
930 	struct net_device *netdev = NULL;
931 	struct fcoe_transport *ft = NULL;
932 
933 	mutex_lock(&ft_mutex);
934 
935 	netdev = fcoe_if_to_netdev(buffer);
936 	if (!netdev) {
937 		LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buffer);
938 		goto out_nodev;
939 	}
940 
941 	ft = fcoe_netdev_map_lookup(netdev);
942 	if (!ft) {
943 		LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n",
944 				      netdev->name);
945 		goto out_putdev;
946 	}
947 
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",
953 			      netdev->name);
954 
955 out_putdev:
956 	dev_put(netdev);
957 out_nodev:
958 	mutex_unlock(&ft_mutex);
959 	return rc;
960 }
961 
962 /**
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
966  *
967  * Called from sysfs.
968  *
969  * Returns: 0 for success
970  */
971 static int fcoe_transport_disable(const char *buffer,
972 				  const struct kernel_param *kp)
973 {
974 	int rc = -ENODEV;
975 	struct net_device *netdev = NULL;
976 	struct fcoe_transport *ft = NULL;
977 
978 	mutex_lock(&ft_mutex);
979 
980 	netdev = fcoe_if_to_netdev(buffer);
981 	if (!netdev)
982 		goto out_nodev;
983 
984 	ft = fcoe_netdev_map_lookup(netdev);
985 	if (!ft)
986 		goto out_putdev;
987 
988 	rc = ft->disable ? ft->disable(netdev) : -ENODEV;
989 
990 out_putdev:
991 	dev_put(netdev);
992 out_nodev:
993 	mutex_unlock(&ft_mutex);
994 	return rc;
995 }
996 
997 /**
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
1001  *
1002  * Called from sysfs.
1003  *
1004  * Returns: 0 for success
1005  */
1006 static int fcoe_transport_enable(const char *buffer,
1007 				 const struct kernel_param *kp)
1008 {
1009 	int rc = -ENODEV;
1010 	struct net_device *netdev = NULL;
1011 	struct fcoe_transport *ft = NULL;
1012 
1013 	mutex_lock(&ft_mutex);
1014 
1015 	netdev = fcoe_if_to_netdev(buffer);
1016 	if (!netdev)
1017 		goto out_nodev;
1018 
1019 	ft = fcoe_netdev_map_lookup(netdev);
1020 	if (!ft)
1021 		goto out_putdev;
1022 
1023 	rc = ft->enable ? ft->enable(netdev) : -ENODEV;
1024 
1025 out_putdev:
1026 	dev_put(netdev);
1027 out_nodev:
1028 	mutex_unlock(&ft_mutex);
1029 	return rc;
1030 }
1031 
1032 /**
1033  * libfcoe_init() - Initialization routine for libfcoe.ko
1034  */
1035 static int __init libfcoe_init(void)
1036 {
1037 	int rc = 0;
1038 
1039 	rc = fcoe_transport_init();
1040 	if (rc)
1041 		return rc;
1042 
1043 	rc = fcoe_sysfs_setup();
1044 	if (rc)
1045 		fcoe_transport_exit();
1046 
1047 	return rc;
1048 }
1049 module_init(libfcoe_init);
1050 
1051 /**
1052  * libfcoe_exit() - Tear down libfcoe.ko
1053  */
1054 static void __exit libfcoe_exit(void)
1055 {
1056 	fcoe_sysfs_teardown();
1057 	fcoe_transport_exit();
1058 }
1059 module_exit(libfcoe_exit);
1060