diff options
author | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
---|---|---|
committer | Linus Torvalds <torvalds@ppc970.osdl.org> | 2005-04-16 18:20:36 -0400 |
commit | 1da177e4c3f41524e886b7f1b8a0c1fc7321cac2 (patch) | |
tree | 0bba044c4ce775e45a88a51686b5d9f90697ea9d /drivers/infiniband/ulp/ipoib/ipoib_main.c |
Linux-2.6.12-rc2v2.6.12-rc2
Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.
Let it rip!
Diffstat (limited to 'drivers/infiniband/ulp/ipoib/ipoib_main.c')
-rw-r--r-- | drivers/infiniband/ulp/ipoib/ipoib_main.c | 1103 |
1 files changed, 1103 insertions, 0 deletions
diff --git a/drivers/infiniband/ulp/ipoib/ipoib_main.c b/drivers/infiniband/ulp/ipoib/ipoib_main.c new file mode 100644 index 000000000000..5a3b5c6a4494 --- /dev/null +++ b/drivers/infiniband/ulp/ipoib/ipoib_main.c | |||
@@ -0,0 +1,1103 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2004 Topspin Communications. All rights reserved. | ||
3 | * | ||
4 | * This software is available to you under a choice of one of two | ||
5 | * licenses. You may choose to be licensed under the terms of the GNU | ||
6 | * General Public License (GPL) Version 2, available from the file | ||
7 | * COPYING in the main directory of this source tree, or the | ||
8 | * OpenIB.org BSD license below: | ||
9 | * | ||
10 | * Redistribution and use in source and binary forms, with or | ||
11 | * without modification, are permitted provided that the following | ||
12 | * conditions are met: | ||
13 | * | ||
14 | * - Redistributions of source code must retain the above | ||
15 | * copyright notice, this list of conditions and the following | ||
16 | * disclaimer. | ||
17 | * | ||
18 | * - Redistributions in binary form must reproduce the above | ||
19 | * copyright notice, this list of conditions and the following | ||
20 | * disclaimer in the documentation and/or other materials | ||
21 | * provided with the distribution. | ||
22 | * | ||
23 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | ||
24 | * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | ||
25 | * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | ||
26 | * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | ||
27 | * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | ||
28 | * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | ||
29 | * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | ||
30 | * SOFTWARE. | ||
31 | * | ||
32 | * $Id: ipoib_main.c 1377 2004-12-23 19:57:12Z roland $ | ||
33 | */ | ||
34 | |||
35 | #include "ipoib.h" | ||
36 | |||
37 | #include <linux/version.h> | ||
38 | #include <linux/module.h> | ||
39 | |||
40 | #include <linux/init.h> | ||
41 | #include <linux/slab.h> | ||
42 | #include <linux/vmalloc.h> | ||
43 | |||
44 | #include <linux/if_arp.h> /* For ARPHRD_xxx */ | ||
45 | |||
46 | #include <linux/ip.h> | ||
47 | #include <linux/in.h> | ||
48 | |||
49 | MODULE_AUTHOR("Roland Dreier"); | ||
50 | MODULE_DESCRIPTION("IP-over-InfiniBand net driver"); | ||
51 | MODULE_LICENSE("Dual BSD/GPL"); | ||
52 | |||
53 | #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG | ||
54 | int ipoib_debug_level; | ||
55 | |||
56 | module_param_named(debug_level, ipoib_debug_level, int, 0644); | ||
57 | MODULE_PARM_DESC(debug_level, "Enable debug tracing if > 0"); | ||
58 | #endif | ||
59 | |||
60 | static const u8 ipv4_bcast_addr[] = { | ||
61 | 0x00, 0xff, 0xff, 0xff, | ||
62 | 0xff, 0x12, 0x40, 0x1b, 0x00, 0x00, 0x00, 0x00, | ||
63 | 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff | ||
64 | }; | ||
65 | |||
66 | struct workqueue_struct *ipoib_workqueue; | ||
67 | |||
68 | static void ipoib_add_one(struct ib_device *device); | ||
69 | static void ipoib_remove_one(struct ib_device *device); | ||
70 | |||
71 | static struct ib_client ipoib_client = { | ||
72 | .name = "ipoib", | ||
73 | .add = ipoib_add_one, | ||
74 | .remove = ipoib_remove_one | ||
75 | }; | ||
76 | |||
77 | int ipoib_open(struct net_device *dev) | ||
78 | { | ||
79 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
80 | |||
81 | ipoib_dbg(priv, "bringing up interface\n"); | ||
82 | |||
83 | set_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags); | ||
84 | |||
85 | if (ipoib_pkey_dev_delay_open(dev)) | ||
86 | return 0; | ||
87 | |||
88 | if (ipoib_ib_dev_open(dev)) | ||
89 | return -EINVAL; | ||
90 | |||
91 | if (ipoib_ib_dev_up(dev)) | ||
92 | return -EINVAL; | ||
93 | |||
94 | if (!test_bit(IPOIB_FLAG_SUBINTERFACE, &priv->flags)) { | ||
95 | struct ipoib_dev_priv *cpriv; | ||
96 | |||
97 | /* Bring up any child interfaces too */ | ||
98 | down(&priv->vlan_mutex); | ||
99 | list_for_each_entry(cpriv, &priv->child_intfs, list) { | ||
100 | int flags; | ||
101 | |||
102 | flags = cpriv->dev->flags; | ||
103 | if (flags & IFF_UP) | ||
104 | continue; | ||
105 | |||
106 | dev_change_flags(cpriv->dev, flags | IFF_UP); | ||
107 | } | ||
108 | up(&priv->vlan_mutex); | ||
109 | } | ||
110 | |||
111 | netif_start_queue(dev); | ||
112 | |||
113 | return 0; | ||
114 | } | ||
115 | |||
116 | static int ipoib_stop(struct net_device *dev) | ||
117 | { | ||
118 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
119 | |||
120 | ipoib_dbg(priv, "stopping interface\n"); | ||
121 | |||
122 | clear_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags); | ||
123 | |||
124 | netif_stop_queue(dev); | ||
125 | |||
126 | ipoib_ib_dev_down(dev); | ||
127 | ipoib_ib_dev_stop(dev); | ||
128 | |||
129 | if (!test_bit(IPOIB_FLAG_SUBINTERFACE, &priv->flags)) { | ||
130 | struct ipoib_dev_priv *cpriv; | ||
131 | |||
132 | /* Bring down any child interfaces too */ | ||
133 | down(&priv->vlan_mutex); | ||
134 | list_for_each_entry(cpriv, &priv->child_intfs, list) { | ||
135 | int flags; | ||
136 | |||
137 | flags = cpriv->dev->flags; | ||
138 | if (!(flags & IFF_UP)) | ||
139 | continue; | ||
140 | |||
141 | dev_change_flags(cpriv->dev, flags & ~IFF_UP); | ||
142 | } | ||
143 | up(&priv->vlan_mutex); | ||
144 | } | ||
145 | |||
146 | return 0; | ||
147 | } | ||
148 | |||
149 | static int ipoib_change_mtu(struct net_device *dev, int new_mtu) | ||
150 | { | ||
151 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
152 | |||
153 | if (new_mtu > IPOIB_PACKET_SIZE - IPOIB_ENCAP_LEN) | ||
154 | return -EINVAL; | ||
155 | |||
156 | priv->admin_mtu = new_mtu; | ||
157 | |||
158 | dev->mtu = min(priv->mcast_mtu, priv->admin_mtu); | ||
159 | |||
160 | return 0; | ||
161 | } | ||
162 | |||
163 | static struct ipoib_path *__path_find(struct net_device *dev, | ||
164 | union ib_gid *gid) | ||
165 | { | ||
166 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
167 | struct rb_node *n = priv->path_tree.rb_node; | ||
168 | struct ipoib_path *path; | ||
169 | int ret; | ||
170 | |||
171 | while (n) { | ||
172 | path = rb_entry(n, struct ipoib_path, rb_node); | ||
173 | |||
174 | ret = memcmp(gid->raw, path->pathrec.dgid.raw, | ||
175 | sizeof (union ib_gid)); | ||
176 | |||
177 | if (ret < 0) | ||
178 | n = n->rb_left; | ||
179 | else if (ret > 0) | ||
180 | n = n->rb_right; | ||
181 | else | ||
182 | return path; | ||
183 | } | ||
184 | |||
185 | return NULL; | ||
186 | } | ||
187 | |||
188 | static int __path_add(struct net_device *dev, struct ipoib_path *path) | ||
189 | { | ||
190 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
191 | struct rb_node **n = &priv->path_tree.rb_node; | ||
192 | struct rb_node *pn = NULL; | ||
193 | struct ipoib_path *tpath; | ||
194 | int ret; | ||
195 | |||
196 | while (*n) { | ||
197 | pn = *n; | ||
198 | tpath = rb_entry(pn, struct ipoib_path, rb_node); | ||
199 | |||
200 | ret = memcmp(path->pathrec.dgid.raw, tpath->pathrec.dgid.raw, | ||
201 | sizeof (union ib_gid)); | ||
202 | if (ret < 0) | ||
203 | n = &pn->rb_left; | ||
204 | else if (ret > 0) | ||
205 | n = &pn->rb_right; | ||
206 | else | ||
207 | return -EEXIST; | ||
208 | } | ||
209 | |||
210 | rb_link_node(&path->rb_node, pn, n); | ||
211 | rb_insert_color(&path->rb_node, &priv->path_tree); | ||
212 | |||
213 | list_add_tail(&path->list, &priv->path_list); | ||
214 | |||
215 | return 0; | ||
216 | } | ||
217 | |||
218 | static void path_free(struct net_device *dev, struct ipoib_path *path) | ||
219 | { | ||
220 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
221 | struct ipoib_neigh *neigh, *tn; | ||
222 | struct sk_buff *skb; | ||
223 | unsigned long flags; | ||
224 | |||
225 | while ((skb = __skb_dequeue(&path->queue))) | ||
226 | dev_kfree_skb_irq(skb); | ||
227 | |||
228 | spin_lock_irqsave(&priv->lock, flags); | ||
229 | |||
230 | list_for_each_entry_safe(neigh, tn, &path->neigh_list, list) { | ||
231 | /* | ||
232 | * It's safe to call ipoib_put_ah() inside priv->lock | ||
233 | * here, because we know that path->ah will always | ||
234 | * hold one more reference, so ipoib_put_ah() will | ||
235 | * never do more than decrement the ref count. | ||
236 | */ | ||
237 | if (neigh->ah) | ||
238 | ipoib_put_ah(neigh->ah); | ||
239 | *to_ipoib_neigh(neigh->neighbour) = NULL; | ||
240 | neigh->neighbour->ops->destructor = NULL; | ||
241 | kfree(neigh); | ||
242 | } | ||
243 | |||
244 | spin_unlock_irqrestore(&priv->lock, flags); | ||
245 | |||
246 | if (path->ah) | ||
247 | ipoib_put_ah(path->ah); | ||
248 | |||
249 | kfree(path); | ||
250 | } | ||
251 | |||
252 | void ipoib_flush_paths(struct net_device *dev) | ||
253 | { | ||
254 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
255 | struct ipoib_path *path, *tp; | ||
256 | LIST_HEAD(remove_list); | ||
257 | unsigned long flags; | ||
258 | |||
259 | spin_lock_irqsave(&priv->lock, flags); | ||
260 | |||
261 | list_splice(&priv->path_list, &remove_list); | ||
262 | INIT_LIST_HEAD(&priv->path_list); | ||
263 | |||
264 | list_for_each_entry(path, &remove_list, list) | ||
265 | rb_erase(&path->rb_node, &priv->path_tree); | ||
266 | |||
267 | spin_unlock_irqrestore(&priv->lock, flags); | ||
268 | |||
269 | list_for_each_entry_safe(path, tp, &remove_list, list) { | ||
270 | if (path->query) | ||
271 | ib_sa_cancel_query(path->query_id, path->query); | ||
272 | wait_for_completion(&path->done); | ||
273 | path_free(dev, path); | ||
274 | } | ||
275 | } | ||
276 | |||
277 | static void path_rec_completion(int status, | ||
278 | struct ib_sa_path_rec *pathrec, | ||
279 | void *path_ptr) | ||
280 | { | ||
281 | struct ipoib_path *path = path_ptr; | ||
282 | struct net_device *dev = path->dev; | ||
283 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
284 | struct ipoib_ah *ah = NULL; | ||
285 | struct ipoib_neigh *neigh; | ||
286 | struct sk_buff_head skqueue; | ||
287 | struct sk_buff *skb; | ||
288 | unsigned long flags; | ||
289 | |||
290 | if (pathrec) | ||
291 | ipoib_dbg(priv, "PathRec LID 0x%04x for GID " IPOIB_GID_FMT "\n", | ||
292 | be16_to_cpu(pathrec->dlid), IPOIB_GID_ARG(pathrec->dgid)); | ||
293 | else | ||
294 | ipoib_dbg(priv, "PathRec status %d for GID " IPOIB_GID_FMT "\n", | ||
295 | status, IPOIB_GID_ARG(path->pathrec.dgid)); | ||
296 | |||
297 | skb_queue_head_init(&skqueue); | ||
298 | |||
299 | if (!status) { | ||
300 | struct ib_ah_attr av = { | ||
301 | .dlid = be16_to_cpu(pathrec->dlid), | ||
302 | .sl = pathrec->sl, | ||
303 | .port_num = priv->port | ||
304 | }; | ||
305 | |||
306 | if (ib_sa_rate_enum_to_int(pathrec->rate) > 0) | ||
307 | av.static_rate = (2 * priv->local_rate - | ||
308 | ib_sa_rate_enum_to_int(pathrec->rate) - 1) / | ||
309 | (priv->local_rate ? priv->local_rate : 1); | ||
310 | |||
311 | ipoib_dbg(priv, "static_rate %d for local port %dX, path %dX\n", | ||
312 | av.static_rate, priv->local_rate, | ||
313 | ib_sa_rate_enum_to_int(pathrec->rate)); | ||
314 | |||
315 | ah = ipoib_create_ah(dev, priv->pd, &av); | ||
316 | } | ||
317 | |||
318 | spin_lock_irqsave(&priv->lock, flags); | ||
319 | |||
320 | path->ah = ah; | ||
321 | |||
322 | if (ah) { | ||
323 | path->pathrec = *pathrec; | ||
324 | |||
325 | ipoib_dbg(priv, "created address handle %p for LID 0x%04x, SL %d\n", | ||
326 | ah, be16_to_cpu(pathrec->dlid), pathrec->sl); | ||
327 | |||
328 | while ((skb = __skb_dequeue(&path->queue))) | ||
329 | __skb_queue_tail(&skqueue, skb); | ||
330 | |||
331 | list_for_each_entry(neigh, &path->neigh_list, list) { | ||
332 | kref_get(&path->ah->ref); | ||
333 | neigh->ah = path->ah; | ||
334 | |||
335 | while ((skb = __skb_dequeue(&neigh->queue))) | ||
336 | __skb_queue_tail(&skqueue, skb); | ||
337 | } | ||
338 | } else | ||
339 | path->query = NULL; | ||
340 | |||
341 | complete(&path->done); | ||
342 | |||
343 | spin_unlock_irqrestore(&priv->lock, flags); | ||
344 | |||
345 | while ((skb = __skb_dequeue(&skqueue))) { | ||
346 | skb->dev = dev; | ||
347 | if (dev_queue_xmit(skb)) | ||
348 | ipoib_warn(priv, "dev_queue_xmit failed " | ||
349 | "to requeue packet\n"); | ||
350 | } | ||
351 | } | ||
352 | |||
353 | static struct ipoib_path *path_rec_create(struct net_device *dev, | ||
354 | union ib_gid *gid) | ||
355 | { | ||
356 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
357 | struct ipoib_path *path; | ||
358 | |||
359 | path = kmalloc(sizeof *path, GFP_ATOMIC); | ||
360 | if (!path) | ||
361 | return NULL; | ||
362 | |||
363 | path->dev = dev; | ||
364 | path->pathrec.dlid = 0; | ||
365 | path->ah = NULL; | ||
366 | |||
367 | skb_queue_head_init(&path->queue); | ||
368 | |||
369 | INIT_LIST_HEAD(&path->neigh_list); | ||
370 | path->query = NULL; | ||
371 | init_completion(&path->done); | ||
372 | |||
373 | memcpy(path->pathrec.dgid.raw, gid->raw, sizeof (union ib_gid)); | ||
374 | path->pathrec.sgid = priv->local_gid; | ||
375 | path->pathrec.pkey = cpu_to_be16(priv->pkey); | ||
376 | path->pathrec.numb_path = 1; | ||
377 | |||
378 | return path; | ||
379 | } | ||
380 | |||
381 | static int path_rec_start(struct net_device *dev, | ||
382 | struct ipoib_path *path) | ||
383 | { | ||
384 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
385 | |||
386 | ipoib_dbg(priv, "Start path record lookup for " IPOIB_GID_FMT "\n", | ||
387 | IPOIB_GID_ARG(path->pathrec.dgid)); | ||
388 | |||
389 | path->query_id = | ||
390 | ib_sa_path_rec_get(priv->ca, priv->port, | ||
391 | &path->pathrec, | ||
392 | IB_SA_PATH_REC_DGID | | ||
393 | IB_SA_PATH_REC_SGID | | ||
394 | IB_SA_PATH_REC_NUMB_PATH | | ||
395 | IB_SA_PATH_REC_PKEY, | ||
396 | 1000, GFP_ATOMIC, | ||
397 | path_rec_completion, | ||
398 | path, &path->query); | ||
399 | if (path->query_id < 0) { | ||
400 | ipoib_warn(priv, "ib_sa_path_rec_get failed\n"); | ||
401 | path->query = NULL; | ||
402 | return path->query_id; | ||
403 | } | ||
404 | |||
405 | return 0; | ||
406 | } | ||
407 | |||
408 | static void neigh_add_path(struct sk_buff *skb, struct net_device *dev) | ||
409 | { | ||
410 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
411 | struct ipoib_path *path; | ||
412 | struct ipoib_neigh *neigh; | ||
413 | |||
414 | neigh = kmalloc(sizeof *neigh, GFP_ATOMIC); | ||
415 | if (!neigh) { | ||
416 | ++priv->stats.tx_dropped; | ||
417 | dev_kfree_skb_any(skb); | ||
418 | return; | ||
419 | } | ||
420 | |||
421 | skb_queue_head_init(&neigh->queue); | ||
422 | neigh->neighbour = skb->dst->neighbour; | ||
423 | *to_ipoib_neigh(skb->dst->neighbour) = neigh; | ||
424 | |||
425 | /* | ||
426 | * We can only be called from ipoib_start_xmit, so we're | ||
427 | * inside tx_lock -- no need to save/restore flags. | ||
428 | */ | ||
429 | spin_lock(&priv->lock); | ||
430 | |||
431 | path = __path_find(dev, (union ib_gid *) (skb->dst->neighbour->ha + 4)); | ||
432 | if (!path) { | ||
433 | path = path_rec_create(dev, | ||
434 | (union ib_gid *) (skb->dst->neighbour->ha + 4)); | ||
435 | if (!path) | ||
436 | goto err; | ||
437 | |||
438 | __path_add(dev, path); | ||
439 | } | ||
440 | |||
441 | list_add_tail(&neigh->list, &path->neigh_list); | ||
442 | |||
443 | if (path->pathrec.dlid) { | ||
444 | kref_get(&path->ah->ref); | ||
445 | neigh->ah = path->ah; | ||
446 | |||
447 | ipoib_send(dev, skb, path->ah, | ||
448 | be32_to_cpup((__be32 *) skb->dst->neighbour->ha)); | ||
449 | } else { | ||
450 | neigh->ah = NULL; | ||
451 | if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE) { | ||
452 | __skb_queue_tail(&neigh->queue, skb); | ||
453 | } else { | ||
454 | ++priv->stats.tx_dropped; | ||
455 | dev_kfree_skb_any(skb); | ||
456 | } | ||
457 | |||
458 | if (!path->query && path_rec_start(dev, path)) | ||
459 | goto err; | ||
460 | } | ||
461 | |||
462 | spin_unlock(&priv->lock); | ||
463 | return; | ||
464 | |||
465 | err: | ||
466 | *to_ipoib_neigh(skb->dst->neighbour) = NULL; | ||
467 | list_del(&neigh->list); | ||
468 | neigh->neighbour->ops->destructor = NULL; | ||
469 | kfree(neigh); | ||
470 | |||
471 | ++priv->stats.tx_dropped; | ||
472 | dev_kfree_skb_any(skb); | ||
473 | |||
474 | spin_unlock(&priv->lock); | ||
475 | } | ||
476 | |||
477 | static void path_lookup(struct sk_buff *skb, struct net_device *dev) | ||
478 | { | ||
479 | struct ipoib_dev_priv *priv = netdev_priv(skb->dev); | ||
480 | |||
481 | /* Look up path record for unicasts */ | ||
482 | if (skb->dst->neighbour->ha[4] != 0xff) { | ||
483 | neigh_add_path(skb, dev); | ||
484 | return; | ||
485 | } | ||
486 | |||
487 | /* Add in the P_Key for multicasts */ | ||
488 | skb->dst->neighbour->ha[8] = (priv->pkey >> 8) & 0xff; | ||
489 | skb->dst->neighbour->ha[9] = priv->pkey & 0xff; | ||
490 | ipoib_mcast_send(dev, (union ib_gid *) (skb->dst->neighbour->ha + 4), skb); | ||
491 | } | ||
492 | |||
493 | static void unicast_arp_send(struct sk_buff *skb, struct net_device *dev, | ||
494 | struct ipoib_pseudoheader *phdr) | ||
495 | { | ||
496 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
497 | struct ipoib_path *path; | ||
498 | |||
499 | /* | ||
500 | * We can only be called from ipoib_start_xmit, so we're | ||
501 | * inside tx_lock -- no need to save/restore flags. | ||
502 | */ | ||
503 | spin_lock(&priv->lock); | ||
504 | |||
505 | path = __path_find(dev, (union ib_gid *) (phdr->hwaddr + 4)); | ||
506 | if (!path) { | ||
507 | path = path_rec_create(dev, | ||
508 | (union ib_gid *) (phdr->hwaddr + 4)); | ||
509 | if (path) { | ||
510 | /* put pseudoheader back on for next time */ | ||
511 | skb_push(skb, sizeof *phdr); | ||
512 | __skb_queue_tail(&path->queue, skb); | ||
513 | |||
514 | if (path_rec_start(dev, path)) { | ||
515 | spin_unlock(&priv->lock); | ||
516 | path_free(dev, path); | ||
517 | return; | ||
518 | } else | ||
519 | __path_add(dev, path); | ||
520 | } else { | ||
521 | ++priv->stats.tx_dropped; | ||
522 | dev_kfree_skb_any(skb); | ||
523 | } | ||
524 | |||
525 | spin_unlock(&priv->lock); | ||
526 | return; | ||
527 | } | ||
528 | |||
529 | if (path->pathrec.dlid) { | ||
530 | ipoib_dbg(priv, "Send unicast ARP to %04x\n", | ||
531 | be16_to_cpu(path->pathrec.dlid)); | ||
532 | |||
533 | ipoib_send(dev, skb, path->ah, | ||
534 | be32_to_cpup((__be32 *) phdr->hwaddr)); | ||
535 | } else if ((path->query || !path_rec_start(dev, path)) && | ||
536 | skb_queue_len(&path->queue) < IPOIB_MAX_PATH_REC_QUEUE) { | ||
537 | /* put pseudoheader back on for next time */ | ||
538 | skb_push(skb, sizeof *phdr); | ||
539 | __skb_queue_tail(&path->queue, skb); | ||
540 | } else { | ||
541 | ++priv->stats.tx_dropped; | ||
542 | dev_kfree_skb_any(skb); | ||
543 | } | ||
544 | |||
545 | spin_unlock(&priv->lock); | ||
546 | } | ||
547 | |||
548 | static int ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev) | ||
549 | { | ||
550 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
551 | struct ipoib_neigh *neigh; | ||
552 | unsigned long flags; | ||
553 | |||
554 | local_irq_save(flags); | ||
555 | if (!spin_trylock(&priv->tx_lock)) { | ||
556 | local_irq_restore(flags); | ||
557 | return NETDEV_TX_LOCKED; | ||
558 | } | ||
559 | |||
560 | /* | ||
561 | * Check if our queue is stopped. Since we have the LLTX bit | ||
562 | * set, we can't rely on netif_stop_queue() preventing our | ||
563 | * xmit function from being called with a full queue. | ||
564 | */ | ||
565 | if (unlikely(netif_queue_stopped(dev))) { | ||
566 | spin_unlock_irqrestore(&priv->tx_lock, flags); | ||
567 | return NETDEV_TX_BUSY; | ||
568 | } | ||
569 | |||
570 | if (skb->dst && skb->dst->neighbour) { | ||
571 | if (unlikely(!*to_ipoib_neigh(skb->dst->neighbour))) { | ||
572 | path_lookup(skb, dev); | ||
573 | goto out; | ||
574 | } | ||
575 | |||
576 | neigh = *to_ipoib_neigh(skb->dst->neighbour); | ||
577 | |||
578 | if (likely(neigh->ah)) { | ||
579 | ipoib_send(dev, skb, neigh->ah, | ||
580 | be32_to_cpup((__be32 *) skb->dst->neighbour->ha)); | ||
581 | goto out; | ||
582 | } | ||
583 | |||
584 | if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE) { | ||
585 | spin_lock(&priv->lock); | ||
586 | __skb_queue_tail(&neigh->queue, skb); | ||
587 | spin_unlock(&priv->lock); | ||
588 | } else { | ||
589 | ++priv->stats.tx_dropped; | ||
590 | dev_kfree_skb_any(skb); | ||
591 | } | ||
592 | } else { | ||
593 | struct ipoib_pseudoheader *phdr = | ||
594 | (struct ipoib_pseudoheader *) skb->data; | ||
595 | skb_pull(skb, sizeof *phdr); | ||
596 | |||
597 | if (phdr->hwaddr[4] == 0xff) { | ||
598 | /* Add in the P_Key for multicast*/ | ||
599 | phdr->hwaddr[8] = (priv->pkey >> 8) & 0xff; | ||
600 | phdr->hwaddr[9] = priv->pkey & 0xff; | ||
601 | |||
602 | ipoib_mcast_send(dev, (union ib_gid *) (phdr->hwaddr + 4), skb); | ||
603 | } else { | ||
604 | /* unicast GID -- should be ARP reply */ | ||
605 | |||
606 | if (be16_to_cpup((u16 *) skb->data) != ETH_P_ARP) { | ||
607 | ipoib_warn(priv, "Unicast, no %s: type %04x, QPN %06x " | ||
608 | IPOIB_GID_FMT "\n", | ||
609 | skb->dst ? "neigh" : "dst", | ||
610 | be16_to_cpup((u16 *) skb->data), | ||
611 | be32_to_cpup((u32 *) phdr->hwaddr), | ||
612 | IPOIB_GID_ARG(*(union ib_gid *) (phdr->hwaddr + 4))); | ||
613 | dev_kfree_skb_any(skb); | ||
614 | ++priv->stats.tx_dropped; | ||
615 | goto out; | ||
616 | } | ||
617 | |||
618 | unicast_arp_send(skb, dev, phdr); | ||
619 | } | ||
620 | } | ||
621 | |||
622 | out: | ||
623 | spin_unlock_irqrestore(&priv->tx_lock, flags); | ||
624 | |||
625 | return NETDEV_TX_OK; | ||
626 | } | ||
627 | |||
628 | static struct net_device_stats *ipoib_get_stats(struct net_device *dev) | ||
629 | { | ||
630 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
631 | |||
632 | return &priv->stats; | ||
633 | } | ||
634 | |||
635 | static void ipoib_timeout(struct net_device *dev) | ||
636 | { | ||
637 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
638 | |||
639 | ipoib_warn(priv, "transmit timeout: latency %ld\n", | ||
640 | jiffies - dev->trans_start); | ||
641 | /* XXX reset QP, etc. */ | ||
642 | } | ||
643 | |||
644 | static int ipoib_hard_header(struct sk_buff *skb, | ||
645 | struct net_device *dev, | ||
646 | unsigned short type, | ||
647 | void *daddr, void *saddr, unsigned len) | ||
648 | { | ||
649 | struct ipoib_header *header; | ||
650 | |||
651 | header = (struct ipoib_header *) skb_push(skb, sizeof *header); | ||
652 | |||
653 | header->proto = htons(type); | ||
654 | header->reserved = 0; | ||
655 | |||
656 | /* | ||
657 | * If we don't have a neighbour structure, stuff the | ||
658 | * destination address onto the front of the skb so we can | ||
659 | * figure out where to send the packet later. | ||
660 | */ | ||
661 | if (!skb->dst || !skb->dst->neighbour) { | ||
662 | struct ipoib_pseudoheader *phdr = | ||
663 | (struct ipoib_pseudoheader *) skb_push(skb, sizeof *phdr); | ||
664 | memcpy(phdr->hwaddr, daddr, INFINIBAND_ALEN); | ||
665 | } | ||
666 | |||
667 | return 0; | ||
668 | } | ||
669 | |||
670 | static void ipoib_set_mcast_list(struct net_device *dev) | ||
671 | { | ||
672 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
673 | |||
674 | schedule_work(&priv->restart_task); | ||
675 | } | ||
676 | |||
677 | static void ipoib_neigh_destructor(struct neighbour *n) | ||
678 | { | ||
679 | struct ipoib_neigh *neigh; | ||
680 | struct ipoib_dev_priv *priv = netdev_priv(n->dev); | ||
681 | unsigned long flags; | ||
682 | struct ipoib_ah *ah = NULL; | ||
683 | |||
684 | ipoib_dbg(priv, | ||
685 | "neigh_destructor for %06x " IPOIB_GID_FMT "\n", | ||
686 | be32_to_cpup((__be32 *) n->ha), | ||
687 | IPOIB_GID_ARG(*((union ib_gid *) (n->ha + 4)))); | ||
688 | |||
689 | spin_lock_irqsave(&priv->lock, flags); | ||
690 | |||
691 | neigh = *to_ipoib_neigh(n); | ||
692 | if (neigh) { | ||
693 | if (neigh->ah) | ||
694 | ah = neigh->ah; | ||
695 | list_del(&neigh->list); | ||
696 | *to_ipoib_neigh(n) = NULL; | ||
697 | kfree(neigh); | ||
698 | } | ||
699 | |||
700 | spin_unlock_irqrestore(&priv->lock, flags); | ||
701 | |||
702 | if (ah) | ||
703 | ipoib_put_ah(ah); | ||
704 | } | ||
705 | |||
706 | static int ipoib_neigh_setup(struct neighbour *neigh) | ||
707 | { | ||
708 | /* | ||
709 | * Is this kosher? I can't find anybody in the kernel that | ||
710 | * sets neigh->destructor, so we should be able to set it here | ||
711 | * without trouble. | ||
712 | */ | ||
713 | neigh->ops->destructor = ipoib_neigh_destructor; | ||
714 | |||
715 | return 0; | ||
716 | } | ||
717 | |||
718 | static int ipoib_neigh_setup_dev(struct net_device *dev, struct neigh_parms *parms) | ||
719 | { | ||
720 | parms->neigh_setup = ipoib_neigh_setup; | ||
721 | |||
722 | return 0; | ||
723 | } | ||
724 | |||
725 | int ipoib_dev_init(struct net_device *dev, struct ib_device *ca, int port) | ||
726 | { | ||
727 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
728 | |||
729 | /* Allocate RX/TX "rings" to hold queued skbs */ | ||
730 | |||
731 | priv->rx_ring = kmalloc(IPOIB_RX_RING_SIZE * sizeof (struct ipoib_buf), | ||
732 | GFP_KERNEL); | ||
733 | if (!priv->rx_ring) { | ||
734 | printk(KERN_WARNING "%s: failed to allocate RX ring (%d entries)\n", | ||
735 | ca->name, IPOIB_RX_RING_SIZE); | ||
736 | goto out; | ||
737 | } | ||
738 | memset(priv->rx_ring, 0, | ||
739 | IPOIB_RX_RING_SIZE * sizeof (struct ipoib_buf)); | ||
740 | |||
741 | priv->tx_ring = kmalloc(IPOIB_TX_RING_SIZE * sizeof (struct ipoib_buf), | ||
742 | GFP_KERNEL); | ||
743 | if (!priv->tx_ring) { | ||
744 | printk(KERN_WARNING "%s: failed to allocate TX ring (%d entries)\n", | ||
745 | ca->name, IPOIB_TX_RING_SIZE); | ||
746 | goto out_rx_ring_cleanup; | ||
747 | } | ||
748 | memset(priv->tx_ring, 0, | ||
749 | IPOIB_TX_RING_SIZE * sizeof (struct ipoib_buf)); | ||
750 | |||
751 | /* priv->tx_head & tx_tail are already 0 */ | ||
752 | |||
753 | if (ipoib_ib_dev_init(dev, ca, port)) | ||
754 | goto out_tx_ring_cleanup; | ||
755 | |||
756 | return 0; | ||
757 | |||
758 | out_tx_ring_cleanup: | ||
759 | kfree(priv->tx_ring); | ||
760 | |||
761 | out_rx_ring_cleanup: | ||
762 | kfree(priv->rx_ring); | ||
763 | |||
764 | out: | ||
765 | return -ENOMEM; | ||
766 | } | ||
767 | |||
768 | void ipoib_dev_cleanup(struct net_device *dev) | ||
769 | { | ||
770 | struct ipoib_dev_priv *priv = netdev_priv(dev), *cpriv, *tcpriv; | ||
771 | |||
772 | ipoib_delete_debug_file(dev); | ||
773 | |||
774 | /* Delete any child interfaces first */ | ||
775 | list_for_each_entry_safe(cpriv, tcpriv, &priv->child_intfs, list) { | ||
776 | unregister_netdev(cpriv->dev); | ||
777 | ipoib_dev_cleanup(cpriv->dev); | ||
778 | free_netdev(cpriv->dev); | ||
779 | } | ||
780 | |||
781 | ipoib_ib_dev_cleanup(dev); | ||
782 | |||
783 | if (priv->rx_ring) { | ||
784 | kfree(priv->rx_ring); | ||
785 | priv->rx_ring = NULL; | ||
786 | } | ||
787 | |||
788 | if (priv->tx_ring) { | ||
789 | kfree(priv->tx_ring); | ||
790 | priv->tx_ring = NULL; | ||
791 | } | ||
792 | } | ||
793 | |||
794 | static void ipoib_setup(struct net_device *dev) | ||
795 | { | ||
796 | struct ipoib_dev_priv *priv = netdev_priv(dev); | ||
797 | |||
798 | dev->open = ipoib_open; | ||
799 | dev->stop = ipoib_stop; | ||
800 | dev->change_mtu = ipoib_change_mtu; | ||
801 | dev->hard_start_xmit = ipoib_start_xmit; | ||
802 | dev->get_stats = ipoib_get_stats; | ||
803 | dev->tx_timeout = ipoib_timeout; | ||
804 | dev->hard_header = ipoib_hard_header; | ||
805 | dev->set_multicast_list = ipoib_set_mcast_list; | ||
806 | dev->neigh_setup = ipoib_neigh_setup_dev; | ||
807 | |||
808 | dev->watchdog_timeo = HZ; | ||
809 | |||
810 | dev->rebuild_header = NULL; | ||
811 | dev->set_mac_address = NULL; | ||
812 | dev->header_cache_update = NULL; | ||
813 | |||
814 | dev->flags |= IFF_BROADCAST | IFF_MULTICAST; | ||
815 | |||
816 | /* | ||
817 | * We add in INFINIBAND_ALEN to allow for the destination | ||
818 | * address "pseudoheader" for skbs without neighbour struct. | ||
819 | */ | ||
820 | dev->hard_header_len = IPOIB_ENCAP_LEN + INFINIBAND_ALEN; | ||
821 | dev->addr_len = INFINIBAND_ALEN; | ||
822 | dev->type = ARPHRD_INFINIBAND; | ||
823 | dev->tx_queue_len = IPOIB_TX_RING_SIZE * 2; | ||
824 | dev->features = NETIF_F_VLAN_CHALLENGED | NETIF_F_LLTX; | ||
825 | |||
826 | /* MTU will be reset when mcast join happens */ | ||
827 | dev->mtu = IPOIB_PACKET_SIZE - IPOIB_ENCAP_LEN; | ||
828 | priv->mcast_mtu = priv->admin_mtu = dev->mtu; | ||
829 | |||
830 | memcpy(dev->broadcast, ipv4_bcast_addr, INFINIBAND_ALEN); | ||
831 | |||
832 | netif_carrier_off(dev); | ||
833 | |||
834 | SET_MODULE_OWNER(dev); | ||
835 | |||
836 | priv->dev = dev; | ||
837 | |||
838 | spin_lock_init(&priv->lock); | ||
839 | spin_lock_init(&priv->tx_lock); | ||
840 | |||
841 | init_MUTEX(&priv->mcast_mutex); | ||
842 | init_MUTEX(&priv->vlan_mutex); | ||
843 | |||
844 | INIT_LIST_HEAD(&priv->path_list); | ||
845 | INIT_LIST_HEAD(&priv->child_intfs); | ||
846 | INIT_LIST_HEAD(&priv->dead_ahs); | ||
847 | INIT_LIST_HEAD(&priv->multicast_list); | ||
848 | |||
849 | INIT_WORK(&priv->pkey_task, ipoib_pkey_poll, priv->dev); | ||
850 | INIT_WORK(&priv->mcast_task, ipoib_mcast_join_task, priv->dev); | ||
851 | INIT_WORK(&priv->flush_task, ipoib_ib_dev_flush, priv->dev); | ||
852 | INIT_WORK(&priv->restart_task, ipoib_mcast_restart_task, priv->dev); | ||
853 | INIT_WORK(&priv->ah_reap_task, ipoib_reap_ah, priv->dev); | ||
854 | } | ||
855 | |||
856 | struct ipoib_dev_priv *ipoib_intf_alloc(const char *name) | ||
857 | { | ||
858 | struct net_device *dev; | ||
859 | |||
860 | dev = alloc_netdev((int) sizeof (struct ipoib_dev_priv), name, | ||
861 | ipoib_setup); | ||
862 | if (!dev) | ||
863 | return NULL; | ||
864 | |||
865 | return netdev_priv(dev); | ||
866 | } | ||
867 | |||
868 | static ssize_t show_pkey(struct class_device *cdev, char *buf) | ||
869 | { | ||
870 | struct ipoib_dev_priv *priv = | ||
871 | netdev_priv(container_of(cdev, struct net_device, class_dev)); | ||
872 | |||
873 | return sprintf(buf, "0x%04x\n", priv->pkey); | ||
874 | } | ||
875 | static CLASS_DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); | ||
876 | |||
877 | static ssize_t create_child(struct class_device *cdev, | ||
878 | const char *buf, size_t count) | ||
879 | { | ||
880 | int pkey; | ||
881 | int ret; | ||
882 | |||
883 | if (sscanf(buf, "%i", &pkey) != 1) | ||
884 | return -EINVAL; | ||
885 | |||
886 | if (pkey < 0 || pkey > 0xffff) | ||
887 | return -EINVAL; | ||
888 | |||
889 | ret = ipoib_vlan_add(container_of(cdev, struct net_device, class_dev), | ||
890 | pkey); | ||
891 | |||
892 | return ret ? ret : count; | ||
893 | } | ||
894 | static CLASS_DEVICE_ATTR(create_child, S_IWUGO, NULL, create_child); | ||
895 | |||
896 | static ssize_t delete_child(struct class_device *cdev, | ||
897 | const char *buf, size_t count) | ||
898 | { | ||
899 | int pkey; | ||
900 | int ret; | ||
901 | |||
902 | if (sscanf(buf, "%i", &pkey) != 1) | ||
903 | return -EINVAL; | ||
904 | |||
905 | if (pkey < 0 || pkey > 0xffff) | ||
906 | return -EINVAL; | ||
907 | |||
908 | ret = ipoib_vlan_delete(container_of(cdev, struct net_device, class_dev), | ||
909 | pkey); | ||
910 | |||
911 | return ret ? ret : count; | ||
912 | |||
913 | } | ||
914 | static CLASS_DEVICE_ATTR(delete_child, S_IWUGO, NULL, delete_child); | ||
915 | |||
916 | int ipoib_add_pkey_attr(struct net_device *dev) | ||
917 | { | ||
918 | return class_device_create_file(&dev->class_dev, | ||
919 | &class_device_attr_pkey); | ||
920 | } | ||
921 | |||
922 | static struct net_device *ipoib_add_port(const char *format, | ||
923 | struct ib_device *hca, u8 port) | ||
924 | { | ||
925 | struct ipoib_dev_priv *priv; | ||
926 | int result = -ENOMEM; | ||
927 | |||
928 | priv = ipoib_intf_alloc(format); | ||
929 | if (!priv) | ||
930 | goto alloc_mem_failed; | ||
931 | |||
932 | SET_NETDEV_DEV(priv->dev, hca->dma_device); | ||
933 | |||
934 | result = ib_query_pkey(hca, port, 0, &priv->pkey); | ||
935 | if (result) { | ||
936 | printk(KERN_WARNING "%s: ib_query_pkey port %d failed (ret = %d)\n", | ||
937 | hca->name, port, result); | ||
938 | goto alloc_mem_failed; | ||
939 | } | ||
940 | |||
941 | priv->dev->broadcast[8] = priv->pkey >> 8; | ||
942 | priv->dev->broadcast[9] = priv->pkey & 0xff; | ||
943 | |||
944 | result = ib_query_gid(hca, port, 0, &priv->local_gid); | ||
945 | if (result) { | ||
946 | printk(KERN_WARNING "%s: ib_query_gid port %d failed (ret = %d)\n", | ||
947 | hca->name, port, result); | ||
948 | goto alloc_mem_failed; | ||
949 | } else | ||
950 | memcpy(priv->dev->dev_addr + 4, priv->local_gid.raw, sizeof (union ib_gid)); | ||
951 | |||
952 | |||
953 | result = ipoib_dev_init(priv->dev, hca, port); | ||
954 | if (result < 0) { | ||
955 | printk(KERN_WARNING "%s: failed to initialize port %d (ret = %d)\n", | ||
956 | hca->name, port, result); | ||
957 | goto device_init_failed; | ||
958 | } | ||
959 | |||
960 | INIT_IB_EVENT_HANDLER(&priv->event_handler, | ||
961 | priv->ca, ipoib_event); | ||
962 | result = ib_register_event_handler(&priv->event_handler); | ||
963 | if (result < 0) { | ||
964 | printk(KERN_WARNING "%s: ib_register_event_handler failed for " | ||
965 | "port %d (ret = %d)\n", | ||
966 | hca->name, port, result); | ||
967 | goto event_failed; | ||
968 | } | ||
969 | |||
970 | result = register_netdev(priv->dev); | ||
971 | if (result) { | ||
972 | printk(KERN_WARNING "%s: couldn't register ipoib port %d; error %d\n", | ||
973 | hca->name, port, result); | ||
974 | goto register_failed; | ||
975 | } | ||
976 | |||
977 | if (ipoib_create_debug_file(priv->dev)) | ||
978 | goto debug_failed; | ||
979 | |||
980 | if (ipoib_add_pkey_attr(priv->dev)) | ||
981 | goto sysfs_failed; | ||
982 | if (class_device_create_file(&priv->dev->class_dev, | ||
983 | &class_device_attr_create_child)) | ||
984 | goto sysfs_failed; | ||
985 | if (class_device_create_file(&priv->dev->class_dev, | ||
986 | &class_device_attr_delete_child)) | ||
987 | goto sysfs_failed; | ||
988 | |||
989 | return priv->dev; | ||
990 | |||
991 | sysfs_failed: | ||
992 | ipoib_delete_debug_file(priv->dev); | ||
993 | |||
994 | debug_failed: | ||
995 | unregister_netdev(priv->dev); | ||
996 | |||
997 | register_failed: | ||
998 | ib_unregister_event_handler(&priv->event_handler); | ||
999 | |||
1000 | event_failed: | ||
1001 | ipoib_dev_cleanup(priv->dev); | ||
1002 | |||
1003 | device_init_failed: | ||
1004 | free_netdev(priv->dev); | ||
1005 | |||
1006 | alloc_mem_failed: | ||
1007 | return ERR_PTR(result); | ||
1008 | } | ||
1009 | |||
1010 | static void ipoib_add_one(struct ib_device *device) | ||
1011 | { | ||
1012 | struct list_head *dev_list; | ||
1013 | struct net_device *dev; | ||
1014 | struct ipoib_dev_priv *priv; | ||
1015 | int s, e, p; | ||
1016 | |||
1017 | dev_list = kmalloc(sizeof *dev_list, GFP_KERNEL); | ||
1018 | if (!dev_list) | ||
1019 | return; | ||
1020 | |||
1021 | INIT_LIST_HEAD(dev_list); | ||
1022 | |||
1023 | if (device->node_type == IB_NODE_SWITCH) { | ||
1024 | s = 0; | ||
1025 | e = 0; | ||
1026 | } else { | ||
1027 | s = 1; | ||
1028 | e = device->phys_port_cnt; | ||
1029 | } | ||
1030 | |||
1031 | for (p = s; p <= e; ++p) { | ||
1032 | dev = ipoib_add_port("ib%d", device, p); | ||
1033 | if (!IS_ERR(dev)) { | ||
1034 | priv = netdev_priv(dev); | ||
1035 | list_add_tail(&priv->list, dev_list); | ||
1036 | } | ||
1037 | } | ||
1038 | |||
1039 | ib_set_client_data(device, &ipoib_client, dev_list); | ||
1040 | } | ||
1041 | |||
1042 | static void ipoib_remove_one(struct ib_device *device) | ||
1043 | { | ||
1044 | struct ipoib_dev_priv *priv, *tmp; | ||
1045 | struct list_head *dev_list; | ||
1046 | |||
1047 | dev_list = ib_get_client_data(device, &ipoib_client); | ||
1048 | |||
1049 | list_for_each_entry_safe(priv, tmp, dev_list, list) { | ||
1050 | ib_unregister_event_handler(&priv->event_handler); | ||
1051 | |||
1052 | unregister_netdev(priv->dev); | ||
1053 | ipoib_dev_cleanup(priv->dev); | ||
1054 | free_netdev(priv->dev); | ||
1055 | } | ||
1056 | } | ||
1057 | |||
1058 | static int __init ipoib_init_module(void) | ||
1059 | { | ||
1060 | int ret; | ||
1061 | |||
1062 | ret = ipoib_register_debugfs(); | ||
1063 | if (ret) | ||
1064 | return ret; | ||
1065 | |||
1066 | /* | ||
1067 | * We create our own workqueue mainly because we want to be | ||
1068 | * able to flush it when devices are being removed. We can't | ||
1069 | * use schedule_work()/flush_scheduled_work() because both | ||
1070 | * unregister_netdev() and linkwatch_event take the rtnl lock, | ||
1071 | * so flush_scheduled_work() can deadlock during device | ||
1072 | * removal. | ||
1073 | */ | ||
1074 | ipoib_workqueue = create_singlethread_workqueue("ipoib"); | ||
1075 | if (!ipoib_workqueue) { | ||
1076 | ret = -ENOMEM; | ||
1077 | goto err_fs; | ||
1078 | } | ||
1079 | |||
1080 | ret = ib_register_client(&ipoib_client); | ||
1081 | if (ret) | ||
1082 | goto err_wq; | ||
1083 | |||
1084 | return 0; | ||
1085 | |||
1086 | err_fs: | ||
1087 | ipoib_unregister_debugfs(); | ||
1088 | |||
1089 | err_wq: | ||
1090 | destroy_workqueue(ipoib_workqueue); | ||
1091 | |||
1092 | return ret; | ||
1093 | } | ||
1094 | |||
1095 | static void __exit ipoib_cleanup_module(void) | ||
1096 | { | ||
1097 | ipoib_unregister_debugfs(); | ||
1098 | ib_unregister_client(&ipoib_client); | ||
1099 | destroy_workqueue(ipoib_workqueue); | ||
1100 | } | ||
1101 | |||
1102 | module_init(ipoib_init_module); | ||
1103 | module_exit(ipoib_cleanup_module); | ||