?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
treewide: remove redundant IS_ERR() before error code check
[linux/fpc-iii.git] / drivers / infiniband / ulp / ipoib / ipoib_multicast.c
blobb9e9562f503471c19a63ae44e186058d2e1c749f
1 /*
2 * Copyright (c) 2004, 2005 Topspin Communications. All rights reserved.
3 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
4 * Copyright (c) 2004 Voltaire, Inc. All rights reserved.
5 *
6 * This software is available to you under a choice of one of two
7 * licenses. You may choose to be licensed under the terms of the GNU
8 * General Public License (GPL) Version 2, available from the file
9 * COPYING in the main directory of this source tree, or the
10 * OpenIB.org BSD license below:
11 *
12 * Redistribution and use in source and binary forms, with or
13 * without modification, are permitted provided that the following
14 * conditions are met:
15 *
16 * - Redistributions of source code must retain the above
17 * copyright notice, this list of conditions and the following
18 * disclaimer.
19 *
20 * - Redistributions in binary form must reproduce the above
21 * copyright notice, this list of conditions and the following
22 * disclaimer in the documentation and/or other materials
23 * provided with the distribution.
24 *
25 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
26 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
27 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
28 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
29 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
30 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
31 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
32 * SOFTWARE.
33 */
34
35 #include <linux/skbuff.h>
36 #include <linux/rtnetlink.h>
37 #include <linux/moduleparam.h>
38 #include <linux/ip.h>
39 #include <linux/in.h>
40 #include <linux/igmp.h>
41 #include <linux/inetdevice.h>
42 #include <linux/delay.h>
43 #include <linux/completion.h>
44 #include <linux/slab.h>
45
46 #include <net/dst.h>
47
48 #include "ipoib.h"
49
50 #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
51 static int mcast_debug_level;
52
53 module_param(mcast_debug_level, int, 0644);
54 MODULE_PARM_DESC(mcast_debug_level,
55 "Enable multicast debug tracing if > 0");
56 #endif
57
58 struct ipoib_mcast_iter {
59 struct net_device *dev;
60 union ib_gid mgid;
61 unsigned long created;
62 unsigned int queuelen;
63 unsigned int complete;
64 unsigned int send_only;
65 };
66
67 /* join state that allows creating mcg with sendonly member request */
68 #define SENDONLY_FULLMEMBER_JOIN 8
69
70 /*
71 * This should be called with the priv->lock held
72 */
73 static void __ipoib_mcast_schedule_join_thread(struct ipoib_dev_priv *priv,
74 struct ipoib_mcast *mcast,
75 bool delay)
76 {
77 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags))
78 return;
79
80 /*
81 * We will be scheduling *something*, so cancel whatever is
82 * currently scheduled first
83 */
84 cancel_delayed_work(&priv->mcast_task);
85 if (mcast && delay) {
86 /*
87 * We had a failure and want to schedule a retry later
88 */
89 mcast->backoff *= 2;
90 if (mcast->backoff > IPOIB_MAX_BACKOFF_SECONDS)
91 mcast->backoff = IPOIB_MAX_BACKOFF_SECONDS;
92 mcast->delay_until = jiffies + (mcast->backoff * HZ);
93 /*
94 * Mark this mcast for its delay, but restart the
95 * task immediately. The join task will make sure to
96 * clear out all entries without delays, and then
97 * schedule itself to run again when the earliest
98 * delay expires
99 */
100 queue_delayed_work(priv->wq, &priv->mcast_task, 0);
101 } else if (delay) {
102 /*
103 * Special case of retrying after a failure to
104 * allocate the broadcast multicast group, wait
105 * 1 second and try again
106 */
107 queue_delayed_work(priv->wq, &priv->mcast_task, HZ);
108 } else
109 queue_delayed_work(priv->wq, &priv->mcast_task, 0);
110 }
111
112 static void ipoib_mcast_free(struct ipoib_mcast *mcast)
113 {
114 struct net_device *dev = mcast->dev;
115 int tx_dropped = 0;
116
117 ipoib_dbg_mcast(ipoib_priv(dev), "deleting multicast group %pI6\n",
118 mcast->mcmember.mgid.raw);
119
120 /* remove all neigh connected to this mcast */
121 ipoib_del_neighs_by_gid(dev, mcast->mcmember.mgid.raw);
122
123 if (mcast->ah)
124 ipoib_put_ah(mcast->ah);
125
126 while (!skb_queue_empty(&mcast->pkt_queue)) {
127 ++tx_dropped;
128 dev_kfree_skb_any(skb_dequeue(&mcast->pkt_queue));
129 }
130
131 netif_tx_lock_bh(dev);
132 dev->stats.tx_dropped += tx_dropped;
133 netif_tx_unlock_bh(dev);
134
135 kfree(mcast);
136 }
137
138 static struct ipoib_mcast *ipoib_mcast_alloc(struct net_device *dev,
139 int can_sleep)
140 {
141 struct ipoib_mcast *mcast;
142
143 mcast = kzalloc(sizeof(*mcast), can_sleep ? GFP_KERNEL : GFP_ATOMIC);
144 if (!mcast)
145 return NULL;
146
147 mcast->dev = dev;
148 mcast->created = jiffies;
149 mcast->delay_until = jiffies;
150 mcast->backoff = 1;
151
152 INIT_LIST_HEAD(&mcast->list);
153 INIT_LIST_HEAD(&mcast->neigh_list);
154 skb_queue_head_init(&mcast->pkt_queue);
155
156 return mcast;
157 }
158
159 static struct ipoib_mcast *__ipoib_mcast_find(struct net_device *dev, void *mgid)
160 {
161 struct ipoib_dev_priv *priv = ipoib_priv(dev);
162 struct rb_node *n = priv->multicast_tree.rb_node;
163
164 while (n) {
165 struct ipoib_mcast *mcast;
166 int ret;
167
168 mcast = rb_entry(n, struct ipoib_mcast, rb_node);
169
170 ret = memcmp(mgid, mcast->mcmember.mgid.raw,
171 sizeof (union ib_gid));
172 if (ret < 0)
173 n = n->rb_left;
174 else if (ret > 0)
175 n = n->rb_right;
176 else
177 return mcast;
178 }
179
180 return NULL;
181 }
182
183 static int __ipoib_mcast_add(struct net_device *dev, struct ipoib_mcast *mcast)
184 {
185 struct ipoib_dev_priv *priv = ipoib_priv(dev);
186 struct rb_node **n = &priv->multicast_tree.rb_node, *pn = NULL;
187
188 while (*n) {
189 struct ipoib_mcast *tmcast;
190 int ret;
191
192 pn = *n;
193 tmcast = rb_entry(pn, struct ipoib_mcast, rb_node);
194
195 ret = memcmp(mcast->mcmember.mgid.raw, tmcast->mcmember.mgid.raw,
196 sizeof (union ib_gid));
197 if (ret < 0)
198 n = &pn->rb_left;
199 else if (ret > 0)
200 n = &pn->rb_right;
201 else
202 return -EEXIST;
203 }
204
205 rb_link_node(&mcast->rb_node, pn, n);
206 rb_insert_color(&mcast->rb_node, &priv->multicast_tree);
207
208 return 0;
209 }
210
211 static int ipoib_mcast_join_finish(struct ipoib_mcast *mcast,
212 struct ib_sa_mcmember_rec *mcmember)
213 {
214 struct net_device *dev = mcast->dev;
215 struct ipoib_dev_priv *priv = ipoib_priv(dev);
216 struct rdma_netdev *rn = netdev_priv(dev);
217 struct ipoib_ah *ah;
218 struct rdma_ah_attr av;
219 int ret;
220 int set_qkey = 0;
221
222 mcast->mcmember = *mcmember;
223
224 /* Set the multicast MTU and cached Q_Key before we attach if it's
225 * the broadcast group.
226 */
227 if (!memcmp(mcast->mcmember.mgid.raw, priv->dev->broadcast + 4,
228 sizeof (union ib_gid))) {
229 spin_lock_irq(&priv->lock);
230 if (!priv->broadcast) {
231 spin_unlock_irq(&priv->lock);
232 return -EAGAIN;
233 }
234 /*update priv member according to the new mcast*/
235 priv->broadcast->mcmember.qkey = mcmember->qkey;
236 priv->broadcast->mcmember.mtu = mcmember->mtu;
237 priv->broadcast->mcmember.traffic_class = mcmember->traffic_class;
238 priv->broadcast->mcmember.rate = mcmember->rate;
239 priv->broadcast->mcmember.sl = mcmember->sl;
240 priv->broadcast->mcmember.flow_label = mcmember->flow_label;
241 priv->broadcast->mcmember.hop_limit = mcmember->hop_limit;
242 /* assume if the admin and the mcast are the same both can be changed */
243 if (priv->mcast_mtu == priv->admin_mtu)
244 priv->admin_mtu =
245 priv->mcast_mtu =
246 IPOIB_UD_MTU(ib_mtu_enum_to_int(priv->broadcast->mcmember.mtu));
247 else
248 priv->mcast_mtu =
249 IPOIB_UD_MTU(ib_mtu_enum_to_int(priv->broadcast->mcmember.mtu));
250
251 priv->qkey = be32_to_cpu(priv->broadcast->mcmember.qkey);
252 spin_unlock_irq(&priv->lock);
253 priv->tx_wr.remote_qkey = priv->qkey;
254 set_qkey = 1;
255 }
256
257 if (!test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) {
258 if (test_and_set_bit(IPOIB_MCAST_FLAG_ATTACHED, &mcast->flags)) {
259 ipoib_warn(priv, "multicast group %pI6 already attached\n",
260 mcast->mcmember.mgid.raw);
261
262 return 0;
263 }
264
265 ret = rn->attach_mcast(dev, priv->ca, &mcast->mcmember.mgid,
266 be16_to_cpu(mcast->mcmember.mlid),
267 set_qkey, priv->qkey);
268 if (ret < 0) {
269 ipoib_warn(priv, "couldn't attach QP to multicast group %pI6\n",
270 mcast->mcmember.mgid.raw);
271
272 clear_bit(IPOIB_MCAST_FLAG_ATTACHED, &mcast->flags);
273 return ret;
274 }
275 }
276
277 memset(&av, 0, sizeof(av));
278 av.type = rdma_ah_find_type(priv->ca, priv->port);
279 rdma_ah_set_dlid(&av, be16_to_cpu(mcast->mcmember.mlid)),
280 rdma_ah_set_port_num(&av, priv->port);
281 rdma_ah_set_sl(&av, mcast->mcmember.sl);
282 rdma_ah_set_static_rate(&av, mcast->mcmember.rate);
283
284 rdma_ah_set_grh(&av, &mcast->mcmember.mgid,
285 be32_to_cpu(mcast->mcmember.flow_label),
286 0, mcast->mcmember.hop_limit,
287 mcast->mcmember.traffic_class);
288
289 ah = ipoib_create_ah(dev, priv->pd, &av);
290 if (IS_ERR(ah)) {
291 ipoib_warn(priv, "ib_address_create failed %ld\n",
292 -PTR_ERR(ah));
293 /* use original error */
294 return PTR_ERR(ah);
295 }
296 spin_lock_irq(&priv->lock);
297 mcast->ah = ah;
298 spin_unlock_irq(&priv->lock);
299
300 ipoib_dbg_mcast(priv, "MGID %pI6 AV %p, LID 0x%04x, SL %d\n",
301 mcast->mcmember.mgid.raw,
302 mcast->ah->ah,
303 be16_to_cpu(mcast->mcmember.mlid),
304 mcast->mcmember.sl);
305
306 /* actually send any queued packets */
307 netif_tx_lock_bh(dev);
308 while (!skb_queue_empty(&mcast->pkt_queue)) {
309 struct sk_buff *skb = skb_dequeue(&mcast->pkt_queue);
310
311 netif_tx_unlock_bh(dev);
312
313 skb->dev = dev;
314
315 ret = dev_queue_xmit(skb);
316 if (ret)
317 ipoib_warn(priv, "%s:dev_queue_xmit failed to re-queue packet, ret:%d\n",
318 __func__, ret);
319 netif_tx_lock_bh(dev);
320 }
321 netif_tx_unlock_bh(dev);
322
323 return 0;
324 }
325
326 void ipoib_mcast_carrier_on_task(struct work_struct *work)
327 {
328 struct ipoib_dev_priv *priv = container_of(work, struct ipoib_dev_priv,
329 carrier_on_task);
330 struct ib_port_attr attr;
331
332 if (ib_query_port(priv->ca, priv->port, &attr) ||
333 attr.state != IB_PORT_ACTIVE) {
334 ipoib_dbg(priv, "Keeping carrier off until IB port is active\n");
335 return;
336 }
337 /*
338 * Check if can send sendonly MCG's with sendonly-fullmember join state.
339 * It done here after the successfully join to the broadcast group,
340 * because the broadcast group must always be joined first and is always
341 * re-joined if the SM changes substantially.
342 */
343 priv->sm_fullmember_sendonly_support =
344 ib_sa_sendonly_fullmem_support(&ipoib_sa_client,
345 priv->ca, priv->port);
346 /*
347 * Take rtnl_lock to avoid racing with ipoib_stop() and
348 * turning the carrier back on while a device is being
349 * removed. However, ipoib_stop() will attempt to flush
350 * the workqueue while holding the rtnl lock, so loop
351 * on trylock until either we get the lock or we see
352 * FLAG_OPER_UP go away as that signals that we are bailing
353 * and can safely ignore the carrier on work.
354 */
355 while (!rtnl_trylock()) {
356 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags))
357 return;
358 else
359 msleep(20);
360 }
361 if (!ipoib_cm_admin_enabled(priv->dev))
362 dev_set_mtu(priv->dev, min(priv->mcast_mtu, priv->admin_mtu));
363 netif_carrier_on(priv->dev);
364 rtnl_unlock();
365 }
366
367 static int ipoib_mcast_join_complete(int status,
368 struct ib_sa_multicast *multicast)
369 {
370 struct ipoib_mcast *mcast = multicast->context;
371 struct net_device *dev = mcast->dev;
372 struct ipoib_dev_priv *priv = ipoib_priv(dev);
373
374 ipoib_dbg_mcast(priv, "%sjoin completion for %pI6 (status %d)\n",
375 test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) ?
376 "sendonly " : "",
377 mcast->mcmember.mgid.raw, status);
378
379 /* We trap for port events ourselves. */
380 if (status == -ENETRESET) {
381 status = 0;
382 goto out;
383 }
384
385 if (!status)
386 status = ipoib_mcast_join_finish(mcast, &multicast->rec);
387
388 if (!status) {
389 mcast->backoff = 1;
390 mcast->delay_until = jiffies;
391
392 /*
393 * Defer carrier on work to priv->wq to avoid a
394 * deadlock on rtnl_lock here. Requeue our multicast
395 * work too, which will end up happening right after
396 * our carrier on task work and will allow us to
397 * send out all of the non-broadcast joins
398 */
399 if (mcast == priv->broadcast) {
400 spin_lock_irq(&priv->lock);
401 queue_work(priv->wq, &priv->carrier_on_task);
402 __ipoib_mcast_schedule_join_thread(priv, NULL, 0);
403 goto out_locked;
404 }
405 } else {
406 bool silent_fail =
407 test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) &&
408 status == -EINVAL;
409
410 if (mcast->logcount < 20) {
411 if (status == -ETIMEDOUT || status == -EAGAIN ||
412 silent_fail) {
413 ipoib_dbg_mcast(priv, "%smulticast join failed for %pI6, status %d\n",
414 test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) ? "sendonly " : "",
415 mcast->mcmember.mgid.raw, status);
416 } else {
417 ipoib_warn(priv, "%smulticast join failed for %pI6, status %d\n",
418 test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) ? "sendonly " : "",
419 mcast->mcmember.mgid.raw, status);
420 }
421
422 if (!silent_fail)
423 mcast->logcount++;
424 }
425
426 if (test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) &&
427 mcast->backoff >= 2) {
428 /*
429 * We only retry sendonly joins once before we drop
430 * the packet and quit trying to deal with the
431 * group. However, we leave the group in the
432 * mcast list as an unjoined group. If we want to
433 * try joining again, we simply queue up a packet
434 * and restart the join thread. The empty queue
435 * is why the join thread ignores this group.
436 */
437 mcast->backoff = 1;
438 netif_tx_lock_bh(dev);
439 while (!skb_queue_empty(&mcast->pkt_queue)) {
440 ++dev->stats.tx_dropped;
441 dev_kfree_skb_any(skb_dequeue(&mcast->pkt_queue));
442 }
443 netif_tx_unlock_bh(dev);
444 } else {
445 spin_lock_irq(&priv->lock);
446 /* Requeue this join task with a backoff delay */
447 __ipoib_mcast_schedule_join_thread(priv, mcast, 1);
448 goto out_locked;
449 }
450 }
451 out:
452 spin_lock_irq(&priv->lock);
453 out_locked:
454 /*
455 * Make sure to set mcast->mc before we clear the busy flag to avoid
456 * racing with code that checks for BUSY before checking mcast->mc
457 */
458 if (status)
459 mcast->mc = NULL;
460 else
461 mcast->mc = multicast;
462 clear_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags);
463 spin_unlock_irq(&priv->lock);
464 complete(&mcast->done);
465
466 return status;
467 }
468
469 /*
470 * Caller must hold 'priv->lock'
471 */
472 static int ipoib_mcast_join(struct net_device *dev, struct ipoib_mcast *mcast)
473 {
474 struct ipoib_dev_priv *priv = ipoib_priv(dev);
475 struct ib_sa_multicast *multicast;
476 struct ib_sa_mcmember_rec rec = {
477 .join_state = 1
478 };
479 ib_sa_comp_mask comp_mask;
480 int ret = 0;
481
482 if (!priv->broadcast ||
483 !test_bit(IPOIB_FLAG_OPER_UP, &priv->flags))
484 return -EINVAL;
485
486 init_completion(&mcast->done);
487 set_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags);
488
489 ipoib_dbg_mcast(priv, "joining MGID %pI6\n", mcast->mcmember.mgid.raw);
490
491 rec.mgid = mcast->mcmember.mgid;
492 rec.port_gid = priv->local_gid;
493 rec.pkey = cpu_to_be16(priv->pkey);
494
495 comp_mask =
496 IB_SA_MCMEMBER_REC_MGID |
497 IB_SA_MCMEMBER_REC_PORT_GID |
498 IB_SA_MCMEMBER_REC_PKEY |
499 IB_SA_MCMEMBER_REC_JOIN_STATE;
500
501 if (mcast != priv->broadcast) {
502 /*
503 * RFC 4391:
504 * The MGID MUST use the same P_Key, Q_Key, SL, MTU,
505 * and HopLimit as those used in the broadcast-GID. The rest
506 * of attributes SHOULD follow the values used in the
507 * broadcast-GID as well.
508 */
509 comp_mask |=
510 IB_SA_MCMEMBER_REC_QKEY |
511 IB_SA_MCMEMBER_REC_MTU_SELECTOR |
512 IB_SA_MCMEMBER_REC_MTU |
513 IB_SA_MCMEMBER_REC_TRAFFIC_CLASS |
514 IB_SA_MCMEMBER_REC_RATE_SELECTOR |
515 IB_SA_MCMEMBER_REC_RATE |
516 IB_SA_MCMEMBER_REC_SL |
517 IB_SA_MCMEMBER_REC_FLOW_LABEL |
518 IB_SA_MCMEMBER_REC_HOP_LIMIT;
519
520 rec.qkey = priv->broadcast->mcmember.qkey;
521 rec.mtu_selector = IB_SA_EQ;
522 rec.mtu = priv->broadcast->mcmember.mtu;
523 rec.traffic_class = priv->broadcast->mcmember.traffic_class;
524 rec.rate_selector = IB_SA_EQ;
525 rec.rate = priv->broadcast->mcmember.rate;
526 rec.sl = priv->broadcast->mcmember.sl;
527 rec.flow_label = priv->broadcast->mcmember.flow_label;
528 rec.hop_limit = priv->broadcast->mcmember.hop_limit;
529
530 /*
531 * Send-only IB Multicast joins work at the core IB layer but
532 * require specific SM support.
533 * We can use such joins here only if the current SM supports that feature.
534 * However, if not, we emulate an Ethernet multicast send,
535 * which does not require a multicast subscription and will
536 * still send properly. The most appropriate thing to
537 * do is to create the group if it doesn't exist as that
538 * most closely emulates the behavior, from a user space
539 * application perspective, of Ethernet multicast operation.
540 */
541 if (test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) &&
542 priv->sm_fullmember_sendonly_support)
543 /* SM supports sendonly-fullmember, otherwise fallback to full-member */
544 rec.join_state = SENDONLY_FULLMEMBER_JOIN;
545 }
546 spin_unlock_irq(&priv->lock);
547
548 multicast = ib_sa_join_multicast(&ipoib_sa_client, priv->ca, priv->port,
549 &rec, comp_mask, GFP_KERNEL,
550 ipoib_mcast_join_complete, mcast);
551 spin_lock_irq(&priv->lock);
552 if (IS_ERR(multicast)) {
553 ret = PTR_ERR(multicast);
554 ipoib_warn(priv, "ib_sa_join_multicast failed, status %d\n", ret);
555 /* Requeue this join task with a backoff delay */
556 __ipoib_mcast_schedule_join_thread(priv, mcast, 1);
557 clear_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags);
558 spin_unlock_irq(&priv->lock);
559 complete(&mcast->done);
560 spin_lock_irq(&priv->lock);
561 }
562 return 0;
563 }
564
565 void ipoib_mcast_join_task(struct work_struct *work)
566 {
567 struct ipoib_dev_priv *priv =
568 container_of(work, struct ipoib_dev_priv, mcast_task.work);
569 struct net_device *dev = priv->dev;
570 struct ib_port_attr port_attr;
571 unsigned long delay_until = 0;
572 struct ipoib_mcast *mcast = NULL;
573
574 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags))
575 return;
576
577 if (ib_query_port(priv->ca, priv->port, &port_attr)) {
578 ipoib_dbg(priv, "ib_query_port() failed\n");
579 return;
580 }
581 if (port_attr.state != IB_PORT_ACTIVE) {
582 ipoib_dbg(priv, "port state is not ACTIVE (state = %d) suspending join task\n",
583 port_attr.state);
584 return;
585 }
586 priv->local_lid = port_attr.lid;
587 netif_addr_lock_bh(dev);
588
589 if (!test_bit(IPOIB_FLAG_DEV_ADDR_SET, &priv->flags)) {
590 netif_addr_unlock_bh(dev);
591 return;
592 }
593 netif_addr_unlock_bh(dev);
594
595 spin_lock_irq(&priv->lock);
596 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags))
597 goto out;
598
599 if (!priv->broadcast) {
600 struct ipoib_mcast *broadcast;
601
602 broadcast = ipoib_mcast_alloc(dev, 0);
603 if (!broadcast) {
604 ipoib_warn(priv, "failed to allocate broadcast group\n");
605 /*
606 * Restart us after a 1 second delay to retry
607 * creating our broadcast group and attaching to
608 * it. Until this succeeds, this ipoib dev is
609 * completely stalled (multicast wise).
610 */
611 __ipoib_mcast_schedule_join_thread(priv, NULL, 1);
612 goto out;
613 }
614
615 memcpy(broadcast->mcmember.mgid.raw, priv->dev->broadcast + 4,
616 sizeof (union ib_gid));
617 priv->broadcast = broadcast;
618
619 __ipoib_mcast_add(dev, priv->broadcast);
620 }
621
622 if (!test_bit(IPOIB_MCAST_FLAG_ATTACHED, &priv->broadcast->flags)) {
623 if (IS_ERR_OR_NULL(priv->broadcast->mc) &&
624 !test_bit(IPOIB_MCAST_FLAG_BUSY, &priv->broadcast->flags)) {
625 mcast = priv->broadcast;
626 if (mcast->backoff > 1 &&
627 time_before(jiffies, mcast->delay_until)) {
628 delay_until = mcast->delay_until;
629 mcast = NULL;
630 }
631 }
632 goto out;
633 }
634
635 /*
636 * We'll never get here until the broadcast group is both allocated
637 * and attached
638 */
639 list_for_each_entry(mcast, &priv->multicast_list, list) {
640 if (IS_ERR_OR_NULL(mcast->mc) &&
641 !test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags) &&
642 (!test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) ||
643 !skb_queue_empty(&mcast->pkt_queue))) {
644 if (mcast->backoff == 1 ||
645 time_after_eq(jiffies, mcast->delay_until)) {
646 /* Found the next unjoined group */
647 if (ipoib_mcast_join(dev, mcast)) {
648 spin_unlock_irq(&priv->lock);
649 return;
650 }
651 } else if (!delay_until ||
652 time_before(mcast->delay_until, delay_until))
653 delay_until = mcast->delay_until;
654 }
655 }
656
657 mcast = NULL;
658 ipoib_dbg_mcast(priv, "successfully started all multicast joins\n");
659
660 out:
661 if (delay_until) {
662 cancel_delayed_work(&priv->mcast_task);
663 queue_delayed_work(priv->wq, &priv->mcast_task,
664 delay_until - jiffies);
665 }
666 if (mcast)
667 ipoib_mcast_join(dev, mcast);
668
669 spin_unlock_irq(&priv->lock);
670 }
671
672 void ipoib_mcast_start_thread(struct net_device *dev)
673 {
674 struct ipoib_dev_priv *priv = ipoib_priv(dev);
675 unsigned long flags;
676
677 ipoib_dbg_mcast(priv, "starting multicast thread\n");
678
679 spin_lock_irqsave(&priv->lock, flags);
680 __ipoib_mcast_schedule_join_thread(priv, NULL, 0);
681 spin_unlock_irqrestore(&priv->lock, flags);
682 }
683
684 int ipoib_mcast_stop_thread(struct net_device *dev)
685 {
686 struct ipoib_dev_priv *priv = ipoib_priv(dev);
687
688 ipoib_dbg_mcast(priv, "stopping multicast thread\n");
689
690 cancel_delayed_work_sync(&priv->mcast_task);
691
692 return 0;
693 }
694
695 static int ipoib_mcast_leave(struct net_device *dev, struct ipoib_mcast *mcast)
696 {
697 struct ipoib_dev_priv *priv = ipoib_priv(dev);
698 struct rdma_netdev *rn = netdev_priv(dev);
699 int ret = 0;
700
701 if (test_and_clear_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags))
702 ipoib_warn(priv, "ipoib_mcast_leave on an in-flight join\n");
703
704 if (!IS_ERR_OR_NULL(mcast->mc))
705 ib_sa_free_multicast(mcast->mc);
706
707 if (test_and_clear_bit(IPOIB_MCAST_FLAG_ATTACHED, &mcast->flags)) {
708 ipoib_dbg_mcast(priv, "leaving MGID %pI6\n",
709 mcast->mcmember.mgid.raw);
710
711 /* Remove ourselves from the multicast group */
712 ret = rn->detach_mcast(dev, priv->ca, &mcast->mcmember.mgid,
713 be16_to_cpu(mcast->mcmember.mlid));
714 if (ret)
715 ipoib_warn(priv, "ib_detach_mcast failed (result = %d)\n", ret);
716 } else if (!test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags))
717 ipoib_dbg(priv, "leaving with no mcmember but not a "
718 "SENDONLY join\n");
719
720 return 0;
721 }
722
723 /*
724 * Check if the multicast group is sendonly. If so remove it from the maps
725 * and add to the remove list
726 */
727 void ipoib_check_and_add_mcast_sendonly(struct ipoib_dev_priv *priv, u8 *mgid,
728 struct list_head *remove_list)
729 {
730 /* Is this multicast ? */
731 if (*mgid == 0xff) {
732 struct ipoib_mcast *mcast = __ipoib_mcast_find(priv->dev, mgid);
733
734 if (mcast && test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) {
735 list_del(&mcast->list);
736 rb_erase(&mcast->rb_node, &priv->multicast_tree);
737 list_add_tail(&mcast->list, remove_list);
738 }
739 }
740 }
741
742 void ipoib_mcast_remove_list(struct list_head *remove_list)
743 {
744 struct ipoib_mcast *mcast, *tmcast;
745
746 /*
747 * make sure the in-flight joins have finished before we attempt
748 * to leave
749 */
750 list_for_each_entry_safe(mcast, tmcast, remove_list, list)
751 if (test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags))
752 wait_for_completion(&mcast->done);
753
754 list_for_each_entry_safe(mcast, tmcast, remove_list, list) {
755 ipoib_mcast_leave(mcast->dev, mcast);
756 ipoib_mcast_free(mcast);
757 }
758 }
759
760 void ipoib_mcast_send(struct net_device *dev, u8 *daddr, struct sk_buff *skb)
761 {
762 struct ipoib_dev_priv *priv = ipoib_priv(dev);
763 struct rdma_netdev *rn = netdev_priv(dev);
764 struct ipoib_mcast *mcast;
765 unsigned long flags;
766 void *mgid = daddr + 4;
767
768 spin_lock_irqsave(&priv->lock, flags);
769
770 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags) ||
771 !priv->broadcast ||
772 !test_bit(IPOIB_MCAST_FLAG_ATTACHED, &priv->broadcast->flags)) {
773 ++dev->stats.tx_dropped;
774 dev_kfree_skb_any(skb);
775 goto unlock;
776 }
777
778 mcast = __ipoib_mcast_find(dev, mgid);
779 if (!mcast || !mcast->ah) {
780 if (!mcast) {
781 /* Let's create a new send only group now */
782 ipoib_dbg_mcast(priv, "setting up send only multicast group for %pI6\n",
783 mgid);
784
785 mcast = ipoib_mcast_alloc(dev, 0);
786 if (!mcast) {
787 ipoib_warn(priv, "unable to allocate memory "
788 "for multicast structure\n");
789 ++dev->stats.tx_dropped;
790 dev_kfree_skb_any(skb);
791 goto unlock;
792 }
793
794 set_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags);
795 memcpy(mcast->mcmember.mgid.raw, mgid,
796 sizeof (union ib_gid));
797 __ipoib_mcast_add(dev, mcast);
798 list_add_tail(&mcast->list, &priv->multicast_list);
799 }
800 if (skb_queue_len(&mcast->pkt_queue) < IPOIB_MAX_MCAST_QUEUE) {
801 /* put pseudoheader back on for next time */
802 skb_push(skb, sizeof(struct ipoib_pseudo_header));
803 skb_queue_tail(&mcast->pkt_queue, skb);
804 } else {
805 ++dev->stats.tx_dropped;
806 dev_kfree_skb_any(skb);
807 }
808 if (!test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags)) {
809 __ipoib_mcast_schedule_join_thread(priv, NULL, 0);
810 }
811 } else {
812 struct ipoib_neigh *neigh;
813
814 spin_unlock_irqrestore(&priv->lock, flags);
815 neigh = ipoib_neigh_get(dev, daddr);
816 spin_lock_irqsave(&priv->lock, flags);
817 if (!neigh) {
818 neigh = ipoib_neigh_alloc(daddr, dev);
819 /* Make sure that the neigh will be added only
820 * once to mcast list.
821 */
822 if (neigh && list_empty(&neigh->list)) {
823 kref_get(&mcast->ah->ref);
824 neigh->ah = mcast->ah;
825 neigh->ah->valid = 1;
826 list_add_tail(&neigh->list, &mcast->neigh_list);
827 }
828 }
829 spin_unlock_irqrestore(&priv->lock, flags);
830 mcast->ah->last_send = rn->send(dev, skb, mcast->ah->ah,
831 IB_MULTICAST_QPN);
832 if (neigh)
833 ipoib_neigh_put(neigh);
834 return;
835 }
836
837 unlock:
838 spin_unlock_irqrestore(&priv->lock, flags);
839 }
840
841 void ipoib_mcast_dev_flush(struct net_device *dev)
842 {
843 struct ipoib_dev_priv *priv = ipoib_priv(dev);
844 LIST_HEAD(remove_list);
845 struct ipoib_mcast *mcast, *tmcast;
846 unsigned long flags;
847
848 mutex_lock(&priv->mcast_mutex);
849 ipoib_dbg_mcast(priv, "flushing multicast list\n");
850
851 spin_lock_irqsave(&priv->lock, flags);
852
853 list_for_each_entry_safe(mcast, tmcast, &priv->multicast_list, list) {
854 list_del(&mcast->list);
855 rb_erase(&mcast->rb_node, &priv->multicast_tree);
856 list_add_tail(&mcast->list, &remove_list);
857 }
858
859 if (priv->broadcast) {
860 rb_erase(&priv->broadcast->rb_node, &priv->multicast_tree);
861 list_add_tail(&priv->broadcast->list, &remove_list);
862 priv->broadcast = NULL;
863 }
864
865 spin_unlock_irqrestore(&priv->lock, flags);
866
867 ipoib_mcast_remove_list(&remove_list);
868 mutex_unlock(&priv->mcast_mutex);
869 }
870
871 static int ipoib_mcast_addr_is_valid(const u8 *addr, const u8 *broadcast)
872 {
873 /* reserved QPN, prefix, scope */
874 if (memcmp(addr, broadcast, 6))
875 return 0;
876 /* signature lower, pkey */
877 if (memcmp(addr + 7, broadcast + 7, 3))
878 return 0;
879 return 1;
880 }
881
882 void ipoib_mcast_restart_task(struct work_struct *work)
883 {
884 struct ipoib_dev_priv *priv =
885 container_of(work, struct ipoib_dev_priv, restart_task);
886 struct net_device *dev = priv->dev;
887 struct netdev_hw_addr *ha;
888 struct ipoib_mcast *mcast, *tmcast;
889 LIST_HEAD(remove_list);
890 struct ib_sa_mcmember_rec rec;
891
892 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags))
893 /*
894 * shortcut...on shutdown flush is called next, just
895 * let it do all the work
896 */
897 return;
898
899 ipoib_dbg_mcast(priv, "restarting multicast task\n");
900
901 netif_addr_lock_bh(dev);
902 spin_lock_irq(&priv->lock);
903
904 /*
905 * Unfortunately, the networking core only gives us a list of all of
906 * the multicast hardware addresses. We need to figure out which ones
907 * are new and which ones have been removed
908 */
909
910 /* Clear out the found flag */
911 list_for_each_entry(mcast, &priv->multicast_list, list)
912 clear_bit(IPOIB_MCAST_FLAG_FOUND, &mcast->flags);
913
914 /* Mark all of the entries that are found or don't exist */
915 netdev_for_each_mc_addr(ha, dev) {
916 union ib_gid mgid;
917
918 if (!ipoib_mcast_addr_is_valid(ha->addr, dev->broadcast))
919 continue;
920
921 memcpy(mgid.raw, ha->addr + 4, sizeof(mgid));
922
923 mcast = __ipoib_mcast_find(dev, &mgid);
924 if (!mcast || test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) {
925 struct ipoib_mcast *nmcast;
926
927 /* ignore group which is directly joined by userspace */
928 if (test_bit(IPOIB_FLAG_UMCAST, &priv->flags) &&
929 !ib_sa_get_mcmember_rec(priv->ca, priv->port, &mgid, &rec)) {
930 ipoib_dbg_mcast(priv, "ignoring multicast entry for mgid %pI6\n",
931 mgid.raw);
932 continue;
933 }
934
935 /* Not found or send-only group, let's add a new entry */
936 ipoib_dbg_mcast(priv, "adding multicast entry for mgid %pI6\n",
937 mgid.raw);
938
939 nmcast = ipoib_mcast_alloc(dev, 0);
940 if (!nmcast) {
941 ipoib_warn(priv, "unable to allocate memory for multicast structure\n");
942 continue;
943 }
944
945 set_bit(IPOIB_MCAST_FLAG_FOUND, &nmcast->flags);
946
947 nmcast->mcmember.mgid = mgid;
948
949 if (mcast) {
950 /* Destroy the send only entry */
951 list_move_tail(&mcast->list, &remove_list);
952
953 rb_replace_node(&mcast->rb_node,
954 &nmcast->rb_node,
955 &priv->multicast_tree);
956 } else
957 __ipoib_mcast_add(dev, nmcast);
958
959 list_add_tail(&nmcast->list, &priv->multicast_list);
960 }
961
962 if (mcast)
963 set_bit(IPOIB_MCAST_FLAG_FOUND, &mcast->flags);
964 }
965
966 /* Remove all of the entries don't exist anymore */
967 list_for_each_entry_safe(mcast, tmcast, &priv->multicast_list, list) {
968 if (!test_bit(IPOIB_MCAST_FLAG_FOUND, &mcast->flags) &&
969 !test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) {
970 ipoib_dbg_mcast(priv, "deleting multicast group %pI6\n",
971 mcast->mcmember.mgid.raw);
972
973 rb_erase(&mcast->rb_node, &priv->multicast_tree);
974
975 /* Move to the remove list */
976 list_move_tail(&mcast->list, &remove_list);
977 }
978 }
979
980 spin_unlock_irq(&priv->lock);
981 netif_addr_unlock_bh(dev);
982
983 ipoib_mcast_remove_list(&remove_list);
984
985 /*
986 * Double check that we are still up
987 */
988 if (test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) {
989 spin_lock_irq(&priv->lock);
990 __ipoib_mcast_schedule_join_thread(priv, NULL, 0);
991 spin_unlock_irq(&priv->lock);
992 }
993 }
994
995 #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
996
997 struct ipoib_mcast_iter *ipoib_mcast_iter_init(struct net_device *dev)
998 {
999 struct ipoib_mcast_iter *iter;
1000
1001 iter = kmalloc(sizeof(*iter), GFP_KERNEL);
1002 if (!iter)
1003 return NULL;
1004
1005 iter->dev = dev;
1006 memset(iter->mgid.raw, 0, 16);
1007
1008 if (ipoib_mcast_iter_next(iter)) {
1009 kfree(iter);
1010 return NULL;
1011 }
1012
1013 return iter;
1014 }
1015
1016 int ipoib_mcast_iter_next(struct ipoib_mcast_iter *iter)
1017 {
1018 struct ipoib_dev_priv *priv = ipoib_priv(iter->dev);
1019 struct rb_node *n;
1020 struct ipoib_mcast *mcast;
1021 int ret = 1;
1022
1023 spin_lock_irq(&priv->lock);
1024
1025 n = rb_first(&priv->multicast_tree);
1026
1027 while (n) {
1028 mcast = rb_entry(n, struct ipoib_mcast, rb_node);
1029
1030 if (memcmp(iter->mgid.raw, mcast->mcmember.mgid.raw,
1031 sizeof (union ib_gid)) < 0) {
1032 iter->mgid = mcast->mcmember.mgid;
1033 iter->created = mcast->created;
1034 iter->queuelen = skb_queue_len(&mcast->pkt_queue);
1035 iter->complete = !!mcast->ah;
1036 iter->send_only = !!(mcast->flags & (1 << IPOIB_MCAST_FLAG_SENDONLY));
1037
1038 ret = 0;
1039
1040 break;
1041 }
1042
1043 n = rb_next(n);
1044 }
1045
1046 spin_unlock_irq(&priv->lock);
1047
1048 return ret;
1049 }
1050
1051 void ipoib_mcast_iter_read(struct ipoib_mcast_iter *iter,
1052 union ib_gid *mgid,
1053 unsigned long *created,
1054 unsigned int *queuelen,
1055 unsigned int *complete,
1056 unsigned int *send_only)
1057 {
1058 *mgid = iter->mgid;
1059 *created = iter->created;
1060 *queuelen = iter->queuelen;
1061 *complete = iter->complete;
1062 *send_only = iter->send_only;
1063 }
1064
1065 #endif /* CONFIG_INFINIBAND_IPOIB_DEBUG */
Linux with added FPC-III support