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