]>
Commit | Line | Data |
---|---|---|
fdecf31b YZ |
1 | /* |
2 | * Copyright(c) 2008 - 2011 Intel Corporation. All rights reserved. | |
3 | * | |
4 | * This program is free software; you can redistribute it and/or modify it | |
5 | * under the terms and conditions of the GNU General Public License, | |
6 | * version 2, as published by the Free Software Foundation. | |
7 | * | |
8 | * This program is distributed in the hope it will be useful, but WITHOUT | |
9 | * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or | |
10 | * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for | |
11 | * more details. | |
12 | * | |
13 | * You should have received a copy of the GNU General Public License along with | |
14 | * this program; if not, write to the Free Software Foundation, Inc., | |
15 | * 51 Franklin St - Fifth Floor, Boston, MA 02110-1301 USA. | |
16 | * | |
17 | * Maintained at www.Open-FCoE.org | |
18 | */ | |
19 | ||
20 | #include <linux/types.h> | |
21 | #include <linux/module.h> | |
22 | #include <linux/kernel.h> | |
23 | #include <linux/list.h> | |
24 | #include <linux/netdevice.h> | |
25 | #include <linux/errno.h> | |
8597ae8b | 26 | #include <linux/crc32.h> |
fdecf31b YZ |
27 | #include <scsi/libfcoe.h> |
28 | ||
29 | #include "libfcoe.h" | |
30 | ||
e01efc33 YZ |
31 | MODULE_AUTHOR("Open-FCoE.org"); |
32 | MODULE_DESCRIPTION("FIP discovery protocol and FCoE transport for FCoE HBAs"); | |
33 | MODULE_LICENSE("GPL v2"); | |
34 | ||
fdecf31b YZ |
35 | static int fcoe_transport_create(const char *, struct kernel_param *); |
36 | static int fcoe_transport_destroy(const char *, struct kernel_param *); | |
37 | static int fcoe_transport_show(char *buffer, const struct kernel_param *kp); | |
38 | static struct fcoe_transport *fcoe_transport_lookup(struct net_device *device); | |
39 | static struct fcoe_transport *fcoe_netdev_map_lookup(struct net_device *device); | |
40 | static int fcoe_transport_enable(const char *, struct kernel_param *); | |
41 | static int fcoe_transport_disable(const char *, struct kernel_param *); | |
70be6344 BPG |
42 | static int libfcoe_device_notification(struct notifier_block *notifier, |
43 | ulong event, void *ptr); | |
fdecf31b YZ |
44 | |
45 | static LIST_HEAD(fcoe_transports); | |
fdecf31b | 46 | static DEFINE_MUTEX(ft_mutex); |
70be6344 BPG |
47 | static LIST_HEAD(fcoe_netdevs); |
48 | static DEFINE_MUTEX(fn_mutex); | |
fdecf31b | 49 | |
e01efc33 YZ |
50 | unsigned int libfcoe_debug_logging; |
51 | module_param_named(debug_logging, libfcoe_debug_logging, int, S_IRUGO|S_IWUSR); | |
52 | MODULE_PARM_DESC(debug_logging, "a bit mask of logging levels"); | |
53 | ||
fdecf31b YZ |
54 | module_param_call(show, NULL, fcoe_transport_show, NULL, S_IRUSR); |
55 | __MODULE_PARM_TYPE(show, "string"); | |
56 | MODULE_PARM_DESC(show, " Show attached FCoE transports"); | |
57 | ||
58 | module_param_call(create, fcoe_transport_create, NULL, | |
59 | (void *)FIP_MODE_FABRIC, S_IWUSR); | |
60 | __MODULE_PARM_TYPE(create, "string"); | |
bd0a1d6c | 61 | MODULE_PARM_DESC(create, " Creates fcoe instance on an ethernet interface"); |
fdecf31b YZ |
62 | |
63 | module_param_call(create_vn2vn, fcoe_transport_create, NULL, | |
64 | (void *)FIP_MODE_VN2VN, S_IWUSR); | |
65 | __MODULE_PARM_TYPE(create_vn2vn, "string"); | |
66 | MODULE_PARM_DESC(create_vn2vn, " Creates a VN_node to VN_node FCoE instance " | |
67 | "on an Ethernet interface"); | |
68 | ||
69 | module_param_call(destroy, fcoe_transport_destroy, NULL, NULL, S_IWUSR); | |
70 | __MODULE_PARM_TYPE(destroy, "string"); | |
bd0a1d6c | 71 | MODULE_PARM_DESC(destroy, " Destroys fcoe instance on an ethernet interface"); |
fdecf31b YZ |
72 | |
73 | module_param_call(enable, fcoe_transport_enable, NULL, NULL, S_IWUSR); | |
74 | __MODULE_PARM_TYPE(enable, "string"); | |
bd0a1d6c | 75 | MODULE_PARM_DESC(enable, " Enables fcoe on an ethernet interface."); |
fdecf31b YZ |
76 | |
77 | module_param_call(disable, fcoe_transport_disable, NULL, NULL, S_IWUSR); | |
78 | __MODULE_PARM_TYPE(disable, "string"); | |
bd0a1d6c | 79 | MODULE_PARM_DESC(disable, " Disables fcoe on an ethernet interface."); |
fdecf31b | 80 | |
70be6344 BPG |
81 | /* notification function for packets from net device */ |
82 | static struct notifier_block libfcoe_notifier = { | |
83 | .notifier_call = libfcoe_device_notification, | |
84 | }; | |
85 | ||
0b924e55 JT |
86 | static const struct { |
87 | u32 fc_port_speed; | |
88 | #define SPEED_2000 2000 | |
89 | #define SPEED_4000 4000 | |
90 | #define SPEED_8000 8000 | |
91 | #define SPEED_16000 16000 | |
92 | #define SPEED_32000 32000 | |
93 | u32 eth_port_speed; | |
94 | } fcoe_port_speed_mapping[] = { | |
95 | { FC_PORTSPEED_1GBIT, SPEED_1000 }, | |
96 | { FC_PORTSPEED_2GBIT, SPEED_2000 }, | |
97 | { FC_PORTSPEED_4GBIT, SPEED_4000 }, | |
98 | { FC_PORTSPEED_8GBIT, SPEED_8000 }, | |
99 | { FC_PORTSPEED_10GBIT, SPEED_10000 }, | |
100 | { FC_PORTSPEED_16GBIT, SPEED_16000 }, | |
101 | { FC_PORTSPEED_20GBIT, SPEED_20000 }, | |
102 | { FC_PORTSPEED_25GBIT, SPEED_25000 }, | |
103 | { FC_PORTSPEED_32GBIT, SPEED_32000 }, | |
104 | { FC_PORTSPEED_40GBIT, SPEED_40000 }, | |
105 | { FC_PORTSPEED_50GBIT, SPEED_50000 }, | |
106 | { FC_PORTSPEED_100GBIT, SPEED_100000 }, | |
107 | }; | |
108 | ||
109 | static inline u32 eth2fc_speed(u32 eth_port_speed) | |
110 | { | |
111 | int i; | |
112 | ||
182d3f84 | 113 | for (i = 0; i < ARRAY_SIZE(fcoe_port_speed_mapping); i++) { |
0b924e55 JT |
114 | if (fcoe_port_speed_mapping[i].eth_port_speed == eth_port_speed) |
115 | return fcoe_port_speed_mapping[i].fc_port_speed; | |
116 | } | |
117 | ||
118 | return FC_PORTSPEED_UNKNOWN; | |
119 | } | |
120 | ||
03702689 YZ |
121 | /** |
122 | * fcoe_link_speed_update() - Update the supported and actual link speeds | |
123 | * @lport: The local port to update speeds for | |
124 | * | |
125 | * Returns: 0 if the ethtool query was successful | |
126 | * -1 if the ethtool query failed | |
127 | */ | |
128 | int fcoe_link_speed_update(struct fc_lport *lport) | |
129 | { | |
130 | struct net_device *netdev = fcoe_get_netdev(lport); | |
008eb736 | 131 | struct ethtool_link_ksettings ecmd; |
03702689 | 132 | |
008eb736 | 133 | if (!__ethtool_get_link_ksettings(netdev, &ecmd)) { |
b8d23dc6 CL |
134 | lport->link_supported_speeds &= ~(FC_PORTSPEED_1GBIT | |
135 | FC_PORTSPEED_10GBIT | | |
136 | FC_PORTSPEED_20GBIT | | |
137 | FC_PORTSPEED_40GBIT); | |
138 | ||
008eb736 DD |
139 | if (ecmd.link_modes.supported[0] & ( |
140 | SUPPORTED_1000baseT_Half | | |
141 | SUPPORTED_1000baseT_Full | | |
142 | SUPPORTED_1000baseKX_Full)) | |
03702689 | 143 | lport->link_supported_speeds |= FC_PORTSPEED_1GBIT; |
b8d23dc6 | 144 | |
008eb736 DD |
145 | if (ecmd.link_modes.supported[0] & ( |
146 | SUPPORTED_10000baseT_Full | | |
147 | SUPPORTED_10000baseKX4_Full | | |
148 | SUPPORTED_10000baseKR_Full | | |
149 | SUPPORTED_10000baseR_FEC)) | |
b8d23dc6 CL |
150 | lport->link_supported_speeds |= FC_PORTSPEED_10GBIT; |
151 | ||
008eb736 DD |
152 | if (ecmd.link_modes.supported[0] & ( |
153 | SUPPORTED_20000baseMLD2_Full | | |
154 | SUPPORTED_20000baseKR2_Full)) | |
b8d23dc6 CL |
155 | lport->link_supported_speeds |= FC_PORTSPEED_20GBIT; |
156 | ||
008eb736 DD |
157 | if (ecmd.link_modes.supported[0] & ( |
158 | SUPPORTED_40000baseKR4_Full | | |
159 | SUPPORTED_40000baseCR4_Full | | |
160 | SUPPORTED_40000baseSR4_Full | | |
161 | SUPPORTED_40000baseLR4_Full)) | |
b8d23dc6 CL |
162 | lport->link_supported_speeds |= FC_PORTSPEED_40GBIT; |
163 | ||
0b924e55 | 164 | lport->link_speed = eth2fc_speed(ecmd.base.speed); |
03702689 YZ |
165 | return 0; |
166 | } | |
167 | return -1; | |
168 | } | |
169 | EXPORT_SYMBOL_GPL(fcoe_link_speed_update); | |
170 | ||
57c2728f YZ |
171 | /** |
172 | * __fcoe_get_lesb() - Get the Link Error Status Block (LESB) for a given lport | |
173 | * @lport: The local port to update speeds for | |
174 | * @fc_lesb: Pointer to the LESB to be filled up | |
175 | * @netdev: Pointer to the netdev that is associated with the lport | |
176 | * | |
177 | * Note, the Link Error Status Block (LESB) for FCoE is defined in FC-BB-6 | |
178 | * Clause 7.11 in v1.04. | |
179 | */ | |
814740d5 BPG |
180 | void __fcoe_get_lesb(struct fc_lport *lport, |
181 | struct fc_els_lesb *fc_lesb, | |
182 | struct net_device *netdev) | |
183 | { | |
184 | unsigned int cpu; | |
185 | u32 lfc, vlfc, mdac; | |
1bd49b48 | 186 | struct fc_stats *stats; |
814740d5 BPG |
187 | struct fcoe_fc_els_lesb *lesb; |
188 | struct rtnl_link_stats64 temp; | |
189 | ||
190 | lfc = 0; | |
191 | vlfc = 0; | |
192 | mdac = 0; | |
193 | lesb = (struct fcoe_fc_els_lesb *)fc_lesb; | |
194 | memset(lesb, 0, sizeof(*lesb)); | |
195 | for_each_possible_cpu(cpu) { | |
1bd49b48 VD |
196 | stats = per_cpu_ptr(lport->stats, cpu); |
197 | lfc += stats->LinkFailureCount; | |
198 | vlfc += stats->VLinkFailureCount; | |
199 | mdac += stats->MissDiscAdvCount; | |
814740d5 BPG |
200 | } |
201 | lesb->lesb_link_fail = htonl(lfc); | |
202 | lesb->lesb_vlink_fail = htonl(vlfc); | |
203 | lesb->lesb_miss_fka = htonl(mdac); | |
204 | lesb->lesb_fcs_error = | |
205 | htonl(dev_get_stats(netdev, &temp)->rx_crc_errors); | |
206 | } | |
207 | EXPORT_SYMBOL_GPL(__fcoe_get_lesb); | |
208 | ||
57c2728f YZ |
209 | /** |
210 | * fcoe_get_lesb() - Fill the FCoE Link Error Status Block | |
211 | * @lport: the local port | |
212 | * @fc_lesb: the link error status block | |
213 | */ | |
214 | void fcoe_get_lesb(struct fc_lport *lport, | |
215 | struct fc_els_lesb *fc_lesb) | |
216 | { | |
217 | struct net_device *netdev = fcoe_get_netdev(lport); | |
218 | ||
219 | __fcoe_get_lesb(lport, fc_lesb, netdev); | |
220 | } | |
221 | EXPORT_SYMBOL_GPL(fcoe_get_lesb); | |
222 | ||
223 | /** | |
224 | * fcoe_ctlr_get_lesb() - Get the Link Error Status Block (LESB) for a given | |
225 | * fcoe controller device | |
226 | * @ctlr_dev: The given fcoe controller device | |
227 | * | |
228 | */ | |
229 | void fcoe_ctlr_get_lesb(struct fcoe_ctlr_device *ctlr_dev) | |
230 | { | |
231 | struct fcoe_ctlr *fip = fcoe_ctlr_device_priv(ctlr_dev); | |
232 | struct net_device *netdev = fcoe_get_netdev(fip->lp); | |
418a8cfe YZ |
233 | struct fc_els_lesb *fc_lesb; |
234 | ||
235 | fc_lesb = (struct fc_els_lesb *)(&ctlr_dev->lesb); | |
236 | __fcoe_get_lesb(fip->lp, fc_lesb, netdev); | |
57c2728f YZ |
237 | } |
238 | EXPORT_SYMBOL_GPL(fcoe_ctlr_get_lesb); | |
239 | ||
d834895c BPG |
240 | void fcoe_wwn_to_str(u64 wwn, char *buf, int len) |
241 | { | |
242 | u8 wwpn[8]; | |
243 | ||
244 | u64_to_wwn(wwn, wwpn); | |
245 | snprintf(buf, len, "%02x%02x%02x%02x%02x%02x%02x%02x", | |
246 | wwpn[0], wwpn[1], wwpn[2], wwpn[3], | |
247 | wwpn[4], wwpn[5], wwpn[6], wwpn[7]); | |
248 | } | |
249 | EXPORT_SYMBOL_GPL(fcoe_wwn_to_str); | |
250 | ||
251 | /** | |
252 | * fcoe_validate_vport_create() - Validate a vport before creating it | |
253 | * @vport: NPIV port to be created | |
254 | * | |
255 | * This routine is meant to add validation for a vport before creating it | |
256 | * via fcoe_vport_create(). | |
257 | * Current validations are: | |
258 | * - WWPN supplied is unique for given lport | |
259 | */ | |
260 | int fcoe_validate_vport_create(struct fc_vport *vport) | |
261 | { | |
262 | struct Scsi_Host *shost = vport_to_shost(vport); | |
263 | struct fc_lport *n_port = shost_priv(shost); | |
264 | struct fc_lport *vn_port; | |
265 | int rc = 0; | |
266 | char buf[32]; | |
267 | ||
268 | mutex_lock(&n_port->lp_mutex); | |
269 | ||
270 | fcoe_wwn_to_str(vport->port_name, buf, sizeof(buf)); | |
271 | /* Check if the wwpn is not same as that of the lport */ | |
272 | if (!memcmp(&n_port->wwpn, &vport->port_name, sizeof(u64))) { | |
273 | LIBFCOE_TRANSPORT_DBG("vport WWPN 0x%s is same as that of the " | |
274 | "base port WWPN\n", buf); | |
275 | rc = -EINVAL; | |
276 | goto out; | |
277 | } | |
278 | ||
279 | /* Check if there is any existing vport with same wwpn */ | |
280 | list_for_each_entry(vn_port, &n_port->vports, list) { | |
281 | if (!memcmp(&vn_port->wwpn, &vport->port_name, sizeof(u64))) { | |
282 | LIBFCOE_TRANSPORT_DBG("vport with given WWPN 0x%s " | |
283 | "already exists\n", buf); | |
284 | rc = -EINVAL; | |
285 | break; | |
286 | } | |
287 | } | |
288 | out: | |
289 | mutex_unlock(&n_port->lp_mutex); | |
290 | return rc; | |
291 | } | |
292 | EXPORT_SYMBOL_GPL(fcoe_validate_vport_create); | |
293 | ||
294 | /** | |
295 | * fcoe_get_wwn() - Get the world wide name from LLD if it supports it | |
296 | * @netdev: the associated net device | |
297 | * @wwn: the output WWN | |
298 | * @type: the type of WWN (WWPN or WWNN) | |
299 | * | |
300 | * Returns: 0 for success | |
301 | */ | |
302 | int fcoe_get_wwn(struct net_device *netdev, u64 *wwn, int type) | |
303 | { | |
304 | const struct net_device_ops *ops = netdev->netdev_ops; | |
305 | ||
306 | if (ops->ndo_fcoe_get_wwn) | |
307 | return ops->ndo_fcoe_get_wwn(netdev, wwn, type); | |
308 | return -EINVAL; | |
309 | } | |
310 | EXPORT_SYMBOL_GPL(fcoe_get_wwn); | |
311 | ||
8597ae8b BPG |
312 | /** |
313 | * fcoe_fc_crc() - Calculates the CRC for a given frame | |
314 | * @fp: The frame to be checksumed | |
315 | * | |
316 | * This uses crc32() routine to calculate the CRC for a frame | |
317 | * | |
318 | * Return: The 32 bit CRC value | |
319 | */ | |
320 | u32 fcoe_fc_crc(struct fc_frame *fp) | |
321 | { | |
322 | struct sk_buff *skb = fp_skb(fp); | |
323 | struct skb_frag_struct *frag; | |
324 | unsigned char *data; | |
325 | unsigned long off, len, clen; | |
326 | u32 crc; | |
327 | unsigned i; | |
328 | ||
329 | crc = crc32(~0, skb->data, skb_headlen(skb)); | |
330 | ||
331 | for (i = 0; i < skb_shinfo(skb)->nr_frags; i++) { | |
332 | frag = &skb_shinfo(skb)->frags[i]; | |
333 | off = frag->page_offset; | |
9e903e08 | 334 | len = skb_frag_size(frag); |
8597ae8b BPG |
335 | while (len > 0) { |
336 | clen = min(len, PAGE_SIZE - (off & ~PAGE_MASK)); | |
165c68d5 | 337 | data = kmap_atomic( |
77dfce07 | 338 | skb_frag_page(frag) + (off >> PAGE_SHIFT)); |
8597ae8b | 339 | crc = crc32(crc, data + (off & ~PAGE_MASK), clen); |
77dfce07 | 340 | kunmap_atomic(data); |
8597ae8b BPG |
341 | off += clen; |
342 | len -= clen; | |
343 | } | |
344 | } | |
345 | return crc; | |
346 | } | |
347 | EXPORT_SYMBOL_GPL(fcoe_fc_crc); | |
348 | ||
349 | /** | |
350 | * fcoe_start_io() - Start FCoE I/O | |
351 | * @skb: The packet to be transmitted | |
352 | * | |
353 | * This routine is called from the net device to start transmitting | |
354 | * FCoE packets. | |
355 | * | |
356 | * Returns: 0 for success | |
357 | */ | |
358 | int fcoe_start_io(struct sk_buff *skb) | |
359 | { | |
360 | struct sk_buff *nskb; | |
361 | int rc; | |
362 | ||
363 | nskb = skb_clone(skb, GFP_ATOMIC); | |
364 | if (!nskb) | |
365 | return -ENOMEM; | |
366 | rc = dev_queue_xmit(nskb); | |
367 | if (rc != 0) | |
368 | return rc; | |
369 | kfree_skb(skb); | |
370 | return 0; | |
371 | } | |
372 | EXPORT_SYMBOL_GPL(fcoe_start_io); | |
373 | ||
374 | ||
375 | /** | |
376 | * fcoe_clean_pending_queue() - Dequeue a skb and free it | |
377 | * @lport: The local port to dequeue a skb on | |
378 | */ | |
379 | void fcoe_clean_pending_queue(struct fc_lport *lport) | |
380 | { | |
381 | struct fcoe_port *port = lport_priv(lport); | |
382 | struct sk_buff *skb; | |
383 | ||
384 | spin_lock_bh(&port->fcoe_pending_queue.lock); | |
385 | while ((skb = __skb_dequeue(&port->fcoe_pending_queue)) != NULL) { | |
386 | spin_unlock_bh(&port->fcoe_pending_queue.lock); | |
387 | kfree_skb(skb); | |
388 | spin_lock_bh(&port->fcoe_pending_queue.lock); | |
389 | } | |
390 | spin_unlock_bh(&port->fcoe_pending_queue.lock); | |
391 | } | |
392 | EXPORT_SYMBOL_GPL(fcoe_clean_pending_queue); | |
393 | ||
394 | /** | |
395 | * fcoe_check_wait_queue() - Attempt to clear the transmit backlog | |
396 | * @lport: The local port whose backlog is to be cleared | |
397 | * | |
398 | * This empties the wait_queue, dequeues the head of the wait_queue queue | |
399 | * and calls fcoe_start_io() for each packet. If all skb have been | |
400 | * transmitted it returns the qlen. If an error occurs it restores | |
401 | * wait_queue (to try again later) and returns -1. | |
402 | * | |
403 | * The wait_queue is used when the skb transmit fails. The failed skb | |
404 | * will go in the wait_queue which will be emptied by the timer function or | |
405 | * by the next skb transmit. | |
406 | */ | |
407 | void fcoe_check_wait_queue(struct fc_lport *lport, struct sk_buff *skb) | |
408 | { | |
409 | struct fcoe_port *port = lport_priv(lport); | |
410 | int rc; | |
411 | ||
412 | spin_lock_bh(&port->fcoe_pending_queue.lock); | |
413 | ||
414 | if (skb) | |
415 | __skb_queue_tail(&port->fcoe_pending_queue, skb); | |
416 | ||
417 | if (port->fcoe_pending_queue_active) | |
418 | goto out; | |
419 | port->fcoe_pending_queue_active = 1; | |
420 | ||
421 | while (port->fcoe_pending_queue.qlen) { | |
422 | /* keep qlen > 0 until fcoe_start_io succeeds */ | |
423 | port->fcoe_pending_queue.qlen++; | |
424 | skb = __skb_dequeue(&port->fcoe_pending_queue); | |
425 | ||
426 | spin_unlock_bh(&port->fcoe_pending_queue.lock); | |
427 | rc = fcoe_start_io(skb); | |
428 | spin_lock_bh(&port->fcoe_pending_queue.lock); | |
429 | ||
430 | if (rc) { | |
431 | __skb_queue_head(&port->fcoe_pending_queue, skb); | |
432 | /* undo temporary increment above */ | |
433 | port->fcoe_pending_queue.qlen--; | |
434 | break; | |
435 | } | |
436 | /* undo temporary increment above */ | |
437 | port->fcoe_pending_queue.qlen--; | |
438 | } | |
439 | ||
440 | if (port->fcoe_pending_queue.qlen < port->min_queue_depth) | |
441 | lport->qfull = 0; | |
442 | if (port->fcoe_pending_queue.qlen && !timer_pending(&port->timer)) | |
443 | mod_timer(&port->timer, jiffies + 2); | |
444 | port->fcoe_pending_queue_active = 0; | |
445 | out: | |
446 | if (port->fcoe_pending_queue.qlen > port->max_queue_depth) | |
447 | lport->qfull = 1; | |
448 | spin_unlock_bh(&port->fcoe_pending_queue.lock); | |
449 | } | |
450 | EXPORT_SYMBOL_GPL(fcoe_check_wait_queue); | |
451 | ||
452 | /** | |
453 | * fcoe_queue_timer() - The fcoe queue timer | |
454 | * @lport: The local port | |
455 | * | |
456 | * Calls fcoe_check_wait_queue on timeout | |
457 | */ | |
458 | void fcoe_queue_timer(ulong lport) | |
459 | { | |
460 | fcoe_check_wait_queue((struct fc_lport *)lport, NULL); | |
461 | } | |
462 | EXPORT_SYMBOL_GPL(fcoe_queue_timer); | |
463 | ||
464 | /** | |
465 | * fcoe_get_paged_crc_eof() - Allocate a page to be used for the trailer CRC | |
466 | * @skb: The packet to be transmitted | |
467 | * @tlen: The total length of the trailer | |
468 | * @fps: The fcoe context | |
469 | * | |
470 | * This routine allocates a page for frame trailers. The page is re-used if | |
471 | * there is enough room left on it for the current trailer. If there isn't | |
472 | * enough buffer left a new page is allocated for the trailer. Reference to | |
473 | * the page from this function as well as the skbs using the page fragments | |
474 | * ensure that the page is freed at the appropriate time. | |
475 | * | |
476 | * Returns: 0 for success | |
477 | */ | |
478 | int fcoe_get_paged_crc_eof(struct sk_buff *skb, int tlen, | |
479 | struct fcoe_percpu_s *fps) | |
480 | { | |
481 | struct page *page; | |
482 | ||
483 | page = fps->crc_eof_page; | |
484 | if (!page) { | |
485 | page = alloc_page(GFP_ATOMIC); | |
486 | if (!page) | |
487 | return -ENOMEM; | |
488 | ||
489 | fps->crc_eof_page = page; | |
490 | fps->crc_eof_offset = 0; | |
491 | } | |
492 | ||
493 | get_page(page); | |
494 | skb_fill_page_desc(skb, skb_shinfo(skb)->nr_frags, page, | |
495 | fps->crc_eof_offset, tlen); | |
496 | skb->len += tlen; | |
497 | skb->data_len += tlen; | |
498 | skb->truesize += tlen; | |
499 | fps->crc_eof_offset += sizeof(struct fcoe_crc_eof); | |
500 | ||
501 | if (fps->crc_eof_offset >= PAGE_SIZE) { | |
502 | fps->crc_eof_page = NULL; | |
503 | fps->crc_eof_offset = 0; | |
504 | put_page(page); | |
505 | } | |
506 | ||
507 | return 0; | |
508 | } | |
509 | EXPORT_SYMBOL_GPL(fcoe_get_paged_crc_eof); | |
510 | ||
fdecf31b YZ |
511 | /** |
512 | * fcoe_transport_lookup - find an fcoe transport that matches a netdev | |
513 | * @netdev: The netdev to look for from all attached transports | |
514 | * | |
515 | * Returns : ptr to the fcoe transport that supports this netdev or NULL | |
516 | * if not found. | |
517 | * | |
518 | * The ft_mutex should be held when this is called | |
519 | */ | |
520 | static struct fcoe_transport *fcoe_transport_lookup(struct net_device *netdev) | |
521 | { | |
522 | struct fcoe_transport *ft = NULL; | |
523 | ||
524 | list_for_each_entry(ft, &fcoe_transports, list) | |
525 | if (ft->match && ft->match(netdev)) | |
526 | return ft; | |
527 | return NULL; | |
528 | } | |
529 | ||
530 | /** | |
531 | * fcoe_transport_attach - Attaches an FCoE transport | |
532 | * @ft: The fcoe transport to be attached | |
533 | * | |
534 | * Returns : 0 for success | |
535 | */ | |
536 | int fcoe_transport_attach(struct fcoe_transport *ft) | |
537 | { | |
538 | int rc = 0; | |
539 | ||
540 | mutex_lock(&ft_mutex); | |
541 | if (ft->attached) { | |
542 | LIBFCOE_TRANSPORT_DBG("transport %s already attached\n", | |
543 | ft->name); | |
544 | rc = -EEXIST; | |
545 | goto out_attach; | |
546 | } | |
547 | ||
548 | /* Add default transport to the tail */ | |
549 | if (strcmp(ft->name, FCOE_TRANSPORT_DEFAULT)) | |
550 | list_add(&ft->list, &fcoe_transports); | |
551 | else | |
552 | list_add_tail(&ft->list, &fcoe_transports); | |
553 | ||
554 | ft->attached = true; | |
555 | LIBFCOE_TRANSPORT_DBG("attaching transport %s\n", ft->name); | |
556 | ||
557 | out_attach: | |
558 | mutex_unlock(&ft_mutex); | |
559 | return rc; | |
560 | } | |
561 | EXPORT_SYMBOL(fcoe_transport_attach); | |
562 | ||
563 | /** | |
4ef7fb15 | 564 | * fcoe_transport_detach - Detaches an FCoE transport |
fdecf31b YZ |
565 | * @ft: The fcoe transport to be attached |
566 | * | |
567 | * Returns : 0 for success | |
568 | */ | |
569 | int fcoe_transport_detach(struct fcoe_transport *ft) | |
570 | { | |
571 | int rc = 0; | |
69922fcd | 572 | struct fcoe_netdev_mapping *nm = NULL, *tmp; |
fdecf31b YZ |
573 | |
574 | mutex_lock(&ft_mutex); | |
575 | if (!ft->attached) { | |
576 | LIBFCOE_TRANSPORT_DBG("transport %s already detached\n", | |
577 | ft->name); | |
578 | rc = -ENODEV; | |
579 | goto out_attach; | |
580 | } | |
581 | ||
69922fcd YZ |
582 | /* remove netdev mapping for this transport as it is going away */ |
583 | mutex_lock(&fn_mutex); | |
584 | list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) { | |
585 | if (nm->ft == ft) { | |
586 | LIBFCOE_TRANSPORT_DBG("transport %s going away, " | |
587 | "remove its netdev mapping for %s\n", | |
588 | ft->name, nm->netdev->name); | |
589 | list_del(&nm->list); | |
590 | kfree(nm); | |
591 | } | |
592 | } | |
593 | mutex_unlock(&fn_mutex); | |
594 | ||
fdecf31b YZ |
595 | list_del(&ft->list); |
596 | ft->attached = false; | |
597 | LIBFCOE_TRANSPORT_DBG("detaching transport %s\n", ft->name); | |
598 | ||
599 | out_attach: | |
600 | mutex_unlock(&ft_mutex); | |
601 | return rc; | |
602 | ||
603 | } | |
604 | EXPORT_SYMBOL(fcoe_transport_detach); | |
605 | ||
606 | static int fcoe_transport_show(char *buffer, const struct kernel_param *kp) | |
607 | { | |
608 | int i, j; | |
609 | struct fcoe_transport *ft = NULL; | |
610 | ||
611 | i = j = sprintf(buffer, "Attached FCoE transports:"); | |
612 | mutex_lock(&ft_mutex); | |
613 | list_for_each_entry(ft, &fcoe_transports, list) { | |
a01a5a57 | 614 | if (i >= PAGE_SIZE - IFNAMSIZ) |
fdecf31b | 615 | break; |
a01a5a57 | 616 | i += snprintf(&buffer[i], IFNAMSIZ, "%s ", ft->name); |
fdecf31b YZ |
617 | } |
618 | mutex_unlock(&ft_mutex); | |
619 | if (i == j) | |
620 | i += snprintf(&buffer[i], IFNAMSIZ, "none"); | |
621 | return i; | |
622 | } | |
623 | ||
624 | static int __init fcoe_transport_init(void) | |
625 | { | |
70be6344 | 626 | register_netdevice_notifier(&libfcoe_notifier); |
fdecf31b YZ |
627 | return 0; |
628 | } | |
629 | ||
87098bdd | 630 | static int fcoe_transport_exit(void) |
fdecf31b YZ |
631 | { |
632 | struct fcoe_transport *ft; | |
633 | ||
70be6344 | 634 | unregister_netdevice_notifier(&libfcoe_notifier); |
fdecf31b YZ |
635 | mutex_lock(&ft_mutex); |
636 | list_for_each_entry(ft, &fcoe_transports, list) | |
637 | printk(KERN_ERR "FCoE transport %s is still attached!\n", | |
638 | ft->name); | |
639 | mutex_unlock(&ft_mutex); | |
640 | return 0; | |
641 | } | |
642 | ||
643 | ||
644 | static int fcoe_add_netdev_mapping(struct net_device *netdev, | |
645 | struct fcoe_transport *ft) | |
646 | { | |
647 | struct fcoe_netdev_mapping *nm; | |
648 | ||
649 | nm = kmalloc(sizeof(*nm), GFP_KERNEL); | |
650 | if (!nm) { | |
651 | printk(KERN_ERR "Unable to allocate netdev_mapping"); | |
652 | return -ENOMEM; | |
653 | } | |
654 | ||
655 | nm->netdev = netdev; | |
656 | nm->ft = ft; | |
657 | ||
70be6344 | 658 | mutex_lock(&fn_mutex); |
fdecf31b | 659 | list_add(&nm->list, &fcoe_netdevs); |
70be6344 | 660 | mutex_unlock(&fn_mutex); |
fdecf31b YZ |
661 | return 0; |
662 | } | |
663 | ||
664 | ||
665 | static void fcoe_del_netdev_mapping(struct net_device *netdev) | |
666 | { | |
667 | struct fcoe_netdev_mapping *nm = NULL, *tmp; | |
668 | ||
70be6344 | 669 | mutex_lock(&fn_mutex); |
fdecf31b YZ |
670 | list_for_each_entry_safe(nm, tmp, &fcoe_netdevs, list) { |
671 | if (nm->netdev == netdev) { | |
672 | list_del(&nm->list); | |
673 | kfree(nm); | |
70be6344 | 674 | mutex_unlock(&fn_mutex); |
fdecf31b YZ |
675 | return; |
676 | } | |
677 | } | |
70be6344 | 678 | mutex_unlock(&fn_mutex); |
fdecf31b YZ |
679 | } |
680 | ||
681 | ||
682 | /** | |
683 | * fcoe_netdev_map_lookup - find the fcoe transport that matches the netdev on which | |
684 | * it was created | |
685 | * | |
686 | * Returns : ptr to the fcoe transport that supports this netdev or NULL | |
687 | * if not found. | |
688 | * | |
689 | * The ft_mutex should be held when this is called | |
690 | */ | |
691 | static struct fcoe_transport *fcoe_netdev_map_lookup(struct net_device *netdev) | |
692 | { | |
693 | struct fcoe_transport *ft = NULL; | |
694 | struct fcoe_netdev_mapping *nm; | |
695 | ||
70be6344 | 696 | mutex_lock(&fn_mutex); |
fdecf31b YZ |
697 | list_for_each_entry(nm, &fcoe_netdevs, list) { |
698 | if (netdev == nm->netdev) { | |
699 | ft = nm->ft; | |
70be6344 | 700 | mutex_unlock(&fn_mutex); |
fdecf31b YZ |
701 | return ft; |
702 | } | |
703 | } | |
704 | ||
70be6344 | 705 | mutex_unlock(&fn_mutex); |
fdecf31b YZ |
706 | return NULL; |
707 | } | |
708 | ||
709 | /** | |
710 | * fcoe_if_to_netdev() - Parse a name buffer to get a net device | |
711 | * @buffer: The name of the net device | |
712 | * | |
713 | * Returns: NULL or a ptr to net_device | |
714 | */ | |
715 | static struct net_device *fcoe_if_to_netdev(const char *buffer) | |
716 | { | |
717 | char *cp; | |
718 | char ifname[IFNAMSIZ + 2]; | |
719 | ||
720 | if (buffer) { | |
721 | strlcpy(ifname, buffer, IFNAMSIZ); | |
722 | cp = ifname + strlen(ifname); | |
723 | while (--cp >= ifname && *cp == '\n') | |
724 | *cp = '\0'; | |
725 | return dev_get_by_name(&init_net, ifname); | |
726 | } | |
727 | return NULL; | |
728 | } | |
729 | ||
70be6344 BPG |
730 | /** |
731 | * libfcoe_device_notification() - Handler for net device events | |
732 | * @notifier: The context of the notification | |
733 | * @event: The type of event | |
734 | * @ptr: The net device that the event was on | |
735 | * | |
736 | * This function is called by the Ethernet driver in case of link change event. | |
737 | * | |
738 | * Returns: 0 for success | |
739 | */ | |
740 | static int libfcoe_device_notification(struct notifier_block *notifier, | |
741 | ulong event, void *ptr) | |
742 | { | |
351638e7 | 743 | struct net_device *netdev = netdev_notifier_info_to_dev(ptr); |
70be6344 BPG |
744 | |
745 | switch (event) { | |
746 | case NETDEV_UNREGISTER: | |
b99fbf6a RL |
747 | LIBFCOE_TRANSPORT_DBG("NETDEV_UNREGISTER %s\n", |
748 | netdev->name); | |
70be6344 BPG |
749 | fcoe_del_netdev_mapping(netdev); |
750 | break; | |
751 | } | |
752 | return NOTIFY_OK; | |
753 | } | |
754 | ||
6a891b07 RL |
755 | ssize_t fcoe_ctlr_create_store(struct bus_type *bus, |
756 | const char *buf, size_t count) | |
757 | { | |
758 | struct net_device *netdev = NULL; | |
759 | struct fcoe_transport *ft = NULL; | |
6a891b07 RL |
760 | int rc = 0; |
761 | int err; | |
762 | ||
763 | mutex_lock(&ft_mutex); | |
764 | ||
765 | netdev = fcoe_if_to_netdev(buf); | |
766 | if (!netdev) { | |
767 | LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buf); | |
768 | rc = -ENODEV; | |
769 | goto out_nodev; | |
770 | } | |
771 | ||
772 | ft = fcoe_netdev_map_lookup(netdev); | |
773 | if (ft) { | |
774 | LIBFCOE_TRANSPORT_DBG("transport %s already has existing " | |
775 | "FCoE instance on %s.\n", | |
776 | ft->name, netdev->name); | |
777 | rc = -EEXIST; | |
778 | goto out_putdev; | |
779 | } | |
780 | ||
781 | ft = fcoe_transport_lookup(netdev); | |
782 | if (!ft) { | |
783 | LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n", | |
784 | netdev->name); | |
785 | rc = -ENODEV; | |
786 | goto out_putdev; | |
787 | } | |
788 | ||
789 | /* pass to transport create */ | |
790 | err = ft->alloc ? ft->alloc(netdev) : -ENODEV; | |
791 | if (err) { | |
792 | fcoe_del_netdev_mapping(netdev); | |
793 | rc = -ENOMEM; | |
794 | goto out_putdev; | |
795 | } | |
796 | ||
797 | err = fcoe_add_netdev_mapping(netdev, ft); | |
798 | if (err) { | |
799 | LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping " | |
800 | "for FCoE transport %s for %s.\n", | |
801 | ft->name, netdev->name); | |
802 | rc = -ENODEV; | |
803 | goto out_putdev; | |
804 | } | |
805 | ||
a2ceb1fb RL |
806 | LIBFCOE_TRANSPORT_DBG("transport %s succeeded to create fcoe on %s.\n", |
807 | ft->name, netdev->name); | |
6a891b07 RL |
808 | |
809 | out_putdev: | |
810 | dev_put(netdev); | |
811 | out_nodev: | |
812 | mutex_unlock(&ft_mutex); | |
813 | if (rc) | |
814 | return rc; | |
815 | return count; | |
816 | } | |
817 | ||
818 | ssize_t fcoe_ctlr_destroy_store(struct bus_type *bus, | |
819 | const char *buf, size_t count) | |
820 | { | |
821 | int rc = -ENODEV; | |
822 | struct net_device *netdev = NULL; | |
823 | struct fcoe_transport *ft = NULL; | |
824 | ||
825 | mutex_lock(&ft_mutex); | |
826 | ||
827 | netdev = fcoe_if_to_netdev(buf); | |
828 | if (!netdev) { | |
829 | LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buf); | |
830 | goto out_nodev; | |
831 | } | |
832 | ||
833 | ft = fcoe_netdev_map_lookup(netdev); | |
834 | if (!ft) { | |
835 | LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n", | |
836 | netdev->name); | |
837 | goto out_putdev; | |
838 | } | |
839 | ||
840 | /* pass to transport destroy */ | |
841 | rc = ft->destroy(netdev); | |
842 | if (rc) | |
843 | goto out_putdev; | |
844 | ||
845 | fcoe_del_netdev_mapping(netdev); | |
846 | LIBFCOE_TRANSPORT_DBG("transport %s %s to destroy fcoe on %s.\n", | |
847 | ft->name, (rc) ? "failed" : "succeeded", | |
848 | netdev->name); | |
849 | rc = count; /* required for successful return */ | |
850 | out_putdev: | |
851 | dev_put(netdev); | |
852 | out_nodev: | |
853 | mutex_unlock(&ft_mutex); | |
854 | return rc; | |
855 | } | |
856 | EXPORT_SYMBOL(fcoe_ctlr_destroy_store); | |
70be6344 | 857 | |
fdecf31b YZ |
858 | /** |
859 | * fcoe_transport_create() - Create a fcoe interface | |
860 | * @buffer: The name of the Ethernet interface to create on | |
861 | * @kp: The associated kernel param | |
862 | * | |
863 | * Called from sysfs. This holds the ft_mutex while calling the | |
864 | * registered fcoe transport's create function. | |
865 | * | |
866 | * Returns: 0 for success | |
867 | */ | |
868 | static int fcoe_transport_create(const char *buffer, struct kernel_param *kp) | |
869 | { | |
870 | int rc = -ENODEV; | |
871 | struct net_device *netdev = NULL; | |
872 | struct fcoe_transport *ft = NULL; | |
873 | enum fip_state fip_mode = (enum fip_state)(long)kp->arg; | |
874 | ||
b3960afe RL |
875 | mutex_lock(&ft_mutex); |
876 | ||
fdecf31b YZ |
877 | netdev = fcoe_if_to_netdev(buffer); |
878 | if (!netdev) { | |
879 | LIBFCOE_TRANSPORT_DBG("Invalid device %s.\n", buffer); | |
880 | goto out_nodev; | |
881 | } | |
882 | ||
883 | ft = fcoe_netdev_map_lookup(netdev); | |
884 | if (ft) { | |
885 | LIBFCOE_TRANSPORT_DBG("transport %s already has existing " | |
886 | "FCoE instance on %s.\n", | |
887 | ft->name, netdev->name); | |
888 | rc = -EEXIST; | |
889 | goto out_putdev; | |
890 | } | |
891 | ||
892 | ft = fcoe_transport_lookup(netdev); | |
893 | if (!ft) { | |
894 | LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n", | |
895 | netdev->name); | |
896 | goto out_putdev; | |
897 | } | |
898 | ||
899 | rc = fcoe_add_netdev_mapping(netdev, ft); | |
900 | if (rc) { | |
901 | LIBFCOE_TRANSPORT_DBG("failed to add new netdev mapping " | |
902 | "for FCoE transport %s for %s.\n", | |
903 | ft->name, netdev->name); | |
904 | goto out_putdev; | |
905 | } | |
906 | ||
907 | /* pass to transport create */ | |
908 | rc = ft->create ? ft->create(netdev, fip_mode) : -ENODEV; | |
909 | if (rc) | |
910 | fcoe_del_netdev_mapping(netdev); | |
911 | ||
912 | LIBFCOE_TRANSPORT_DBG("transport %s %s to create fcoe on %s.\n", | |
913 | ft->name, (rc) ? "failed" : "succeeded", | |
914 | netdev->name); | |
915 | ||
916 | out_putdev: | |
917 | dev_put(netdev); | |
918 | out_nodev: | |
919 | mutex_unlock(&ft_mutex); | |
b3960afe | 920 | return rc; |
fdecf31b YZ |
921 | } |
922 | ||
923 | /** | |
924 | * fcoe_transport_destroy() - Destroy a FCoE interface | |
925 | * @buffer: The name of the Ethernet interface to be destroyed | |
926 | * @kp: The associated kernel parameter | |
927 | * | |
928 | * Called from sysfs. This holds the ft_mutex while calling the | |
929 | * registered fcoe transport's destroy function. | |
930 | * | |
931 | * Returns: 0 for success | |
932 | */ | |
933 | static int fcoe_transport_destroy(const char *buffer, struct kernel_param *kp) | |
934 | { | |
935 | int rc = -ENODEV; | |
936 | struct net_device *netdev = NULL; | |
937 | struct fcoe_transport *ft = NULL; | |
938 | ||
b3960afe RL |
939 | mutex_lock(&ft_mutex); |
940 | ||
fdecf31b YZ |
941 | netdev = fcoe_if_to_netdev(buffer); |
942 | if (!netdev) { | |
943 | LIBFCOE_TRANSPORT_DBG("invalid device %s.\n", buffer); | |
944 | goto out_nodev; | |
945 | } | |
946 | ||
947 | ft = fcoe_netdev_map_lookup(netdev); | |
948 | if (!ft) { | |
949 | LIBFCOE_TRANSPORT_DBG("no FCoE transport found for %s.\n", | |
950 | netdev->name); | |
951 | goto out_putdev; | |
952 | } | |
953 | ||
954 | /* pass to transport destroy */ | |
955 | rc = ft->destroy ? ft->destroy(netdev) : -ENODEV; | |
956 | fcoe_del_netdev_mapping(netdev); | |
957 | LIBFCOE_TRANSPORT_DBG("transport %s %s to destroy fcoe on %s.\n", | |
958 | ft->name, (rc) ? "failed" : "succeeded", | |
959 | netdev->name); | |
960 | ||
961 | out_putdev: | |
962 | dev_put(netdev); | |
963 | out_nodev: | |
964 | mutex_unlock(&ft_mutex); | |
b3960afe | 965 | return rc; |
fdecf31b YZ |
966 | } |
967 | ||
968 | /** | |
969 | * fcoe_transport_disable() - Disables a FCoE interface | |
970 | * @buffer: The name of the Ethernet interface to be disabled | |
971 | * @kp: The associated kernel parameter | |
972 | * | |
973 | * Called from sysfs. | |
974 | * | |
975 | * Returns: 0 for success | |
976 | */ | |
977 | static int fcoe_transport_disable(const char *buffer, struct kernel_param *kp) | |
978 | { | |
979 | int rc = -ENODEV; | |
980 | struct net_device *netdev = NULL; | |
981 | struct fcoe_transport *ft = NULL; | |
982 | ||
b3960afe RL |
983 | mutex_lock(&ft_mutex); |
984 | ||
fdecf31b YZ |
985 | netdev = fcoe_if_to_netdev(buffer); |
986 | if (!netdev) | |
987 | goto out_nodev; | |
988 | ||
989 | ft = fcoe_netdev_map_lookup(netdev); | |
990 | if (!ft) | |
991 | goto out_putdev; | |
992 | ||
993 | rc = ft->disable ? ft->disable(netdev) : -ENODEV; | |
994 | ||
995 | out_putdev: | |
996 | dev_put(netdev); | |
997 | out_nodev: | |
998 | mutex_unlock(&ft_mutex); | |
4f670ff8 | 999 | return rc; |
fdecf31b YZ |
1000 | } |
1001 | ||
1002 | /** | |
1003 | * fcoe_transport_enable() - Enables a FCoE interface | |
1004 | * @buffer: The name of the Ethernet interface to be enabled | |
1005 | * @kp: The associated kernel parameter | |
1006 | * | |
1007 | * Called from sysfs. | |
1008 | * | |
1009 | * Returns: 0 for success | |
1010 | */ | |
1011 | static int fcoe_transport_enable(const char *buffer, struct kernel_param *kp) | |
1012 | { | |
1013 | int rc = -ENODEV; | |
1014 | struct net_device *netdev = NULL; | |
1015 | struct fcoe_transport *ft = NULL; | |
1016 | ||
b3960afe RL |
1017 | mutex_lock(&ft_mutex); |
1018 | ||
fdecf31b YZ |
1019 | netdev = fcoe_if_to_netdev(buffer); |
1020 | if (!netdev) | |
1021 | goto out_nodev; | |
1022 | ||
1023 | ft = fcoe_netdev_map_lookup(netdev); | |
1024 | if (!ft) | |
1025 | goto out_putdev; | |
1026 | ||
1027 | rc = ft->enable ? ft->enable(netdev) : -ENODEV; | |
1028 | ||
1029 | out_putdev: | |
1030 | dev_put(netdev); | |
1031 | out_nodev: | |
1032 | mutex_unlock(&ft_mutex); | |
b3960afe | 1033 | return rc; |
fdecf31b YZ |
1034 | } |
1035 | ||
1036 | /** | |
1037 | * libfcoe_init() - Initialization routine for libfcoe.ko | |
1038 | */ | |
1039 | static int __init libfcoe_init(void) | |
1040 | { | |
9a74e884 | 1041 | int rc = 0; |
fdecf31b | 1042 | |
9a74e884 RL |
1043 | rc = fcoe_transport_init(); |
1044 | if (rc) | |
1045 | return rc; | |
1046 | ||
1047 | rc = fcoe_sysfs_setup(); | |
1048 | if (rc) | |
1049 | fcoe_transport_exit(); | |
1050 | ||
1051 | return rc; | |
fdecf31b YZ |
1052 | } |
1053 | module_init(libfcoe_init); | |
1054 | ||
1055 | /** | |
1056 | * libfcoe_exit() - Tear down libfcoe.ko | |
1057 | */ | |
1058 | static void __exit libfcoe_exit(void) | |
1059 | { | |
9a74e884 | 1060 | fcoe_sysfs_teardown(); |
fdecf31b YZ |
1061 | fcoe_transport_exit(); |
1062 | } | |
1063 | module_exit(libfcoe_exit); |