Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
ipoib_multicast.c
Go to the documentation of this file.
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 static DEFINE_MUTEX(mcast_mutex);
59 
61  struct net_device *dev;
62  union ib_gid mgid;
63  unsigned long created;
64  unsigned int queuelen;
65  unsigned int complete;
66  unsigned int send_only;
67 };
68 
69 static void ipoib_mcast_free(struct ipoib_mcast *mcast)
70 {
71  struct net_device *dev = mcast->dev;
72  int tx_dropped = 0;
73 
74  ipoib_dbg_mcast(netdev_priv(dev), "deleting multicast group %pI6\n",
75  mcast->mcmember.mgid.raw);
76 
77  /* remove all neigh connected to this mcast */
78  ipoib_del_neighs_by_gid(dev, mcast->mcmember.mgid.raw);
79 
80  if (mcast->ah)
81  ipoib_put_ah(mcast->ah);
82 
83  while (!skb_queue_empty(&mcast->pkt_queue)) {
84  ++tx_dropped;
86  }
87 
88  netif_tx_lock_bh(dev);
89  dev->stats.tx_dropped += tx_dropped;
90  netif_tx_unlock_bh(dev);
91 
92  kfree(mcast);
93 }
94 
95 static struct ipoib_mcast *ipoib_mcast_alloc(struct net_device *dev,
96  int can_sleep)
97 {
98  struct ipoib_mcast *mcast;
99 
100  mcast = kzalloc(sizeof *mcast, can_sleep ? GFP_KERNEL : GFP_ATOMIC);
101  if (!mcast)
102  return NULL;
103 
104  mcast->dev = dev;
105  mcast->created = jiffies;
106  mcast->backoff = 1;
107 
108  INIT_LIST_HEAD(&mcast->list);
109  INIT_LIST_HEAD(&mcast->neigh_list);
110  skb_queue_head_init(&mcast->pkt_queue);
111 
112  return mcast;
113 }
114 
115 static struct ipoib_mcast *__ipoib_mcast_find(struct net_device *dev, void *mgid)
116 {
117  struct ipoib_dev_priv *priv = netdev_priv(dev);
118  struct rb_node *n = priv->multicast_tree.rb_node;
119 
120  while (n) {
121  struct ipoib_mcast *mcast;
122  int ret;
123 
124  mcast = rb_entry(n, struct ipoib_mcast, rb_node);
125 
126  ret = memcmp(mgid, mcast->mcmember.mgid.raw,
127  sizeof (union ib_gid));
128  if (ret < 0)
129  n = n->rb_left;
130  else if (ret > 0)
131  n = n->rb_right;
132  else
133  return mcast;
134  }
135 
136  return NULL;
137 }
138 
139 static int __ipoib_mcast_add(struct net_device *dev, struct ipoib_mcast *mcast)
140 {
141  struct ipoib_dev_priv *priv = netdev_priv(dev);
142  struct rb_node **n = &priv->multicast_tree.rb_node, *pn = NULL;
143 
144  while (*n) {
145  struct ipoib_mcast *tmcast;
146  int ret;
147 
148  pn = *n;
149  tmcast = rb_entry(pn, struct ipoib_mcast, rb_node);
150 
151  ret = memcmp(mcast->mcmember.mgid.raw, tmcast->mcmember.mgid.raw,
152  sizeof (union ib_gid));
153  if (ret < 0)
154  n = &pn->rb_left;
155  else if (ret > 0)
156  n = &pn->rb_right;
157  else
158  return -EEXIST;
159  }
160 
161  rb_link_node(&mcast->rb_node, pn, n);
162  rb_insert_color(&mcast->rb_node, &priv->multicast_tree);
163 
164  return 0;
165 }
166 
167 static int ipoib_mcast_join_finish(struct ipoib_mcast *mcast,
169 {
170  struct net_device *dev = mcast->dev;
171  struct ipoib_dev_priv *priv = netdev_priv(dev);
172  struct ipoib_ah *ah;
173  int ret;
174  int set_qkey = 0;
175 
176  mcast->mcmember = *mcmember;
177 
178  /* Set the multicast MTU and cached Q_Key before we attach if it's
179  * the broadcast group.
180  */
181  if (!memcmp(mcast->mcmember.mgid.raw, priv->dev->broadcast + 4,
182  sizeof (union ib_gid))) {
183  spin_lock_irq(&priv->lock);
184  if (!priv->broadcast) {
185  spin_unlock_irq(&priv->lock);
186  return -EAGAIN;
187  }
188  priv->mcast_mtu = IPOIB_UD_MTU(ib_mtu_enum_to_int(priv->broadcast->mcmember.mtu));
189  priv->qkey = be32_to_cpu(priv->broadcast->mcmember.qkey);
190  spin_unlock_irq(&priv->lock);
191  priv->tx_wr.wr.ud.remote_qkey = priv->qkey;
192  set_qkey = 1;
193 
194  if (!ipoib_cm_admin_enabled(dev)) {
195  rtnl_lock();
196  dev_set_mtu(dev, min(priv->mcast_mtu, priv->admin_mtu));
197  rtnl_unlock();
198  }
199  }
200 
201  if (!test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) {
203  ipoib_warn(priv, "multicast group %pI6 already attached\n",
204  mcast->mcmember.mgid.raw);
205 
206  return 0;
207  }
208 
209  ret = ipoib_mcast_attach(dev, be16_to_cpu(mcast->mcmember.mlid),
210  &mcast->mcmember.mgid, set_qkey);
211  if (ret < 0) {
212  ipoib_warn(priv, "couldn't attach QP to multicast group %pI6\n",
213  mcast->mcmember.mgid.raw);
214 
216  return ret;
217  }
218  }
219 
220  {
221  struct ib_ah_attr av = {
222  .dlid = be16_to_cpu(mcast->mcmember.mlid),
223  .port_num = priv->port,
224  .sl = mcast->mcmember.sl,
225  .ah_flags = IB_AH_GRH,
226  .static_rate = mcast->mcmember.rate,
227  .grh = {
228  .flow_label = be32_to_cpu(mcast->mcmember.flow_label),
229  .hop_limit = mcast->mcmember.hop_limit,
230  .sgid_index = 0,
231  .traffic_class = mcast->mcmember.traffic_class
232  }
233  };
234  av.grh.dgid = mcast->mcmember.mgid;
235 
236  ah = ipoib_create_ah(dev, priv->pd, &av);
237  if (IS_ERR(ah)) {
238  ipoib_warn(priv, "ib_address_create failed %ld\n",
239  -PTR_ERR(ah));
240  /* use original error */
241  return PTR_ERR(ah);
242  } else {
243  spin_lock_irq(&priv->lock);
244  mcast->ah = ah;
245  spin_unlock_irq(&priv->lock);
246 
247  ipoib_dbg_mcast(priv, "MGID %pI6 AV %p, LID 0x%04x, SL %d\n",
248  mcast->mcmember.mgid.raw,
249  mcast->ah->ah,
250  be16_to_cpu(mcast->mcmember.mlid),
251  mcast->mcmember.sl);
252  }
253  }
254 
255  /* actually send any queued packets */
256  netif_tx_lock_bh(dev);
257  while (!skb_queue_empty(&mcast->pkt_queue)) {
258  struct sk_buff *skb = skb_dequeue(&mcast->pkt_queue);
259 
260  netif_tx_unlock_bh(dev);
261 
262  skb->dev = dev;
263  if (dev_queue_xmit(skb))
264  ipoib_warn(priv, "dev_queue_xmit failed to requeue packet\n");
265 
266  netif_tx_lock_bh(dev);
267  }
268  netif_tx_unlock_bh(dev);
269 
270  return 0;
271 }
272 
273 static int
274 ipoib_mcast_sendonly_join_complete(int status,
275  struct ib_sa_multicast *multicast)
276 {
277  struct ipoib_mcast *mcast = multicast->context;
278  struct net_device *dev = mcast->dev;
279 
280  /* We trap for port events ourselves. */
281  if (status == -ENETRESET)
282  return 0;
283 
284  if (!status)
285  status = ipoib_mcast_join_finish(mcast, &multicast->rec);
286 
287  if (status) {
288  if (mcast->logcount++ < 20)
289  ipoib_dbg_mcast(netdev_priv(dev), "multicast join failed for %pI6, status %d\n",
290  mcast->mcmember.mgid.raw, status);
291 
292  /* Flush out any queued packets */
293  netif_tx_lock_bh(dev);
294  while (!skb_queue_empty(&mcast->pkt_queue)) {
295  ++dev->stats.tx_dropped;
297  }
298  netif_tx_unlock_bh(dev);
299 
300  /* Clear the busy flag so we try again */
302  &mcast->flags);
303  }
304  return status;
305 }
306 
307 static int ipoib_mcast_sendonly_join(struct ipoib_mcast *mcast)
308 {
309  struct net_device *dev = mcast->dev;
310  struct ipoib_dev_priv *priv = netdev_priv(dev);
311  struct ib_sa_mcmember_rec rec = {
312 #if 0 /* Some SMs don't support send-only yet */
313  .join_state = 4
314 #else
315  .join_state = 1
316 #endif
317  };
318  int ret = 0;
319 
320  if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) {
321  ipoib_dbg_mcast(priv, "device shutting down, no multicast joins\n");
322  return -ENODEV;
323  }
324 
326  ipoib_dbg_mcast(priv, "multicast entry busy, skipping\n");
327  return -EBUSY;
328  }
329 
330  rec.mgid = mcast->mcmember.mgid;
331  rec.port_gid = priv->local_gid;
332  rec.pkey = cpu_to_be16(priv->pkey);
333 
334  mcast->mc = ib_sa_join_multicast(&ipoib_sa_client, priv->ca,
335  priv->port, &rec,
340  GFP_ATOMIC,
341  ipoib_mcast_sendonly_join_complete,
342  mcast);
343  if (IS_ERR(mcast->mc)) {
344  ret = PTR_ERR(mcast->mc);
346  ipoib_warn(priv, "ib_sa_join_multicast failed (ret = %d)\n",
347  ret);
348  } else {
349  ipoib_dbg_mcast(priv, "no multicast record for %pI6, starting join\n",
350  mcast->mcmember.mgid.raw);
351  }
352 
353  return ret;
354 }
355 
357 {
358  struct ipoib_dev_priv *priv = container_of(work, struct ipoib_dev_priv,
360  struct ib_port_attr attr;
361 
362  /*
363  * Take rtnl_lock to avoid racing with ipoib_stop() and
364  * turning the carrier back on while a device is being
365  * removed.
366  */
367  if (ib_query_port(priv->ca, priv->port, &attr) ||
368  attr.state != IB_PORT_ACTIVE) {
369  ipoib_dbg(priv, "Keeping carrier off until IB port is active\n");
370  return;
371  }
372 
373  rtnl_lock();
374  netif_carrier_on(priv->dev);
375  rtnl_unlock();
376 }
377 
378 static int ipoib_mcast_join_complete(int status,
379  struct ib_sa_multicast *multicast)
380 {
381  struct ipoib_mcast *mcast = multicast->context;
382  struct net_device *dev = mcast->dev;
383  struct ipoib_dev_priv *priv = netdev_priv(dev);
384 
385  ipoib_dbg_mcast(priv, "join completion for %pI6 (status %d)\n",
386  mcast->mcmember.mgid.raw, status);
387 
388  /* We trap for port events ourselves. */
389  if (status == -ENETRESET)
390  return 0;
391 
392  if (!status)
393  status = ipoib_mcast_join_finish(mcast, &multicast->rec);
394 
395  if (!status) {
396  mcast->backoff = 1;
397  mutex_lock(&mcast_mutex);
398  if (test_bit(IPOIB_MCAST_RUN, &priv->flags))
400  &priv->mcast_task, 0);
401  mutex_unlock(&mcast_mutex);
402 
403  /*
404  * Defer carrier on work to ipoib_workqueue to avoid a
405  * deadlock on rtnl_lock here.
406  */
407  if (mcast == priv->broadcast)
409 
410  return 0;
411  }
412 
413  if (mcast->logcount++ < 20) {
414  if (status == -ETIMEDOUT || status == -EAGAIN) {
415  ipoib_dbg_mcast(priv, "multicast join failed for %pI6, status %d\n",
416  mcast->mcmember.mgid.raw, status);
417  } else {
418  ipoib_warn(priv, "multicast join failed for %pI6, status %d\n",
419  mcast->mcmember.mgid.raw, status);
420  }
421  }
422 
423  mcast->backoff *= 2;
424  if (mcast->backoff > IPOIB_MAX_BACKOFF_SECONDS)
426 
427  /* Clear the busy flag so we try again */
429 
430  mutex_lock(&mcast_mutex);
431  spin_lock_irq(&priv->lock);
432  if (test_bit(IPOIB_MCAST_RUN, &priv->flags))
434  mcast->backoff * HZ);
435  spin_unlock_irq(&priv->lock);
436  mutex_unlock(&mcast_mutex);
437 
438  return status;
439 }
440 
441 static void ipoib_mcast_join(struct net_device *dev, struct ipoib_mcast *mcast,
442  int create)
443 {
444  struct ipoib_dev_priv *priv = netdev_priv(dev);
445  struct ib_sa_mcmember_rec rec = {
446  .join_state = 1
447  };
449  int ret = 0;
450 
451  ipoib_dbg_mcast(priv, "joining MGID %pI6\n", mcast->mcmember.mgid.raw);
452 
453  rec.mgid = mcast->mcmember.mgid;
454  rec.port_gid = priv->local_gid;
455  rec.pkey = cpu_to_be16(priv->pkey);
456 
457  comp_mask =
462 
463  if (create) {
464  comp_mask |=
474 
475  rec.qkey = priv->broadcast->mcmember.qkey;
476  rec.mtu_selector = IB_SA_EQ;
477  rec.mtu = priv->broadcast->mcmember.mtu;
478  rec.traffic_class = priv->broadcast->mcmember.traffic_class;
479  rec.rate_selector = IB_SA_EQ;
480  rec.rate = priv->broadcast->mcmember.rate;
481  rec.sl = priv->broadcast->mcmember.sl;
482  rec.flow_label = priv->broadcast->mcmember.flow_label;
483  rec.hop_limit = priv->broadcast->mcmember.hop_limit;
484  }
485 
487  mcast->mc = ib_sa_join_multicast(&ipoib_sa_client, priv->ca, priv->port,
488  &rec, comp_mask, GFP_KERNEL,
489  ipoib_mcast_join_complete, mcast);
490  if (IS_ERR(mcast->mc)) {
492  ret = PTR_ERR(mcast->mc);
493  ipoib_warn(priv, "ib_sa_join_multicast failed, status %d\n", ret);
494 
495  mcast->backoff *= 2;
496  if (mcast->backoff > IPOIB_MAX_BACKOFF_SECONDS)
498 
499  mutex_lock(&mcast_mutex);
500  if (test_bit(IPOIB_MCAST_RUN, &priv->flags))
502  &priv->mcast_task,
503  mcast->backoff * HZ);
504  mutex_unlock(&mcast_mutex);
505  }
506 }
507 
509 {
510  struct ipoib_dev_priv *priv =
511  container_of(work, struct ipoib_dev_priv, mcast_task.work);
512  struct net_device *dev = priv->dev;
513 
514  if (!test_bit(IPOIB_MCAST_RUN, &priv->flags))
515  return;
516 
517  if (ib_query_gid(priv->ca, priv->port, 0, &priv->local_gid))
518  ipoib_warn(priv, "ib_query_gid() failed\n");
519  else
520  memcpy(priv->dev->dev_addr + 4, priv->local_gid.raw, sizeof (union ib_gid));
521 
522  {
523  struct ib_port_attr attr;
524 
525  if (!ib_query_port(priv->ca, priv->port, &attr))
526  priv->local_lid = attr.lid;
527  else
528  ipoib_warn(priv, "ib_query_port failed\n");
529  }
530 
531  if (!priv->broadcast) {
532  struct ipoib_mcast *broadcast;
533 
534  if (!test_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags))
535  return;
536 
537  broadcast = ipoib_mcast_alloc(dev, 1);
538  if (!broadcast) {
539  ipoib_warn(priv, "failed to allocate broadcast group\n");
540  mutex_lock(&mcast_mutex);
541  if (test_bit(IPOIB_MCAST_RUN, &priv->flags))
543  &priv->mcast_task, HZ);
544  mutex_unlock(&mcast_mutex);
545  return;
546  }
547 
548  spin_lock_irq(&priv->lock);
549  memcpy(broadcast->mcmember.mgid.raw, priv->dev->broadcast + 4,
550  sizeof (union ib_gid));
551  priv->broadcast = broadcast;
552 
553  __ipoib_mcast_add(dev, priv->broadcast);
554  spin_unlock_irq(&priv->lock);
555  }
556 
557  if (!test_bit(IPOIB_MCAST_FLAG_ATTACHED, &priv->broadcast->flags)) {
558  if (!test_bit(IPOIB_MCAST_FLAG_BUSY, &priv->broadcast->flags))
559  ipoib_mcast_join(dev, priv->broadcast, 0);
560  return;
561  }
562 
563  while (1) {
564  struct ipoib_mcast *mcast = NULL;
565 
566  spin_lock_irq(&priv->lock);
567  list_for_each_entry(mcast, &priv->multicast_list, list) {
569  && !test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags)
570  && !test_bit(IPOIB_MCAST_FLAG_ATTACHED, &mcast->flags)) {
571  /* Found the next unjoined group */
572  break;
573  }
574  }
575  spin_unlock_irq(&priv->lock);
576 
577  if (&mcast->list == &priv->multicast_list) {
578  /* All done */
579  break;
580  }
581 
582  ipoib_mcast_join(dev, mcast, 1);
583  return;
584  }
585 
586  ipoib_dbg_mcast(priv, "successfully joined all multicast groups\n");
587 
589 }
590 
592 {
593  struct ipoib_dev_priv *priv = netdev_priv(dev);
594 
595  ipoib_dbg_mcast(priv, "starting multicast thread\n");
596 
597  mutex_lock(&mcast_mutex);
598  if (!test_and_set_bit(IPOIB_MCAST_RUN, &priv->flags))
600  mutex_unlock(&mcast_mutex);
601 
602  return 0;
603 }
604 
605 int ipoib_mcast_stop_thread(struct net_device *dev, int flush)
606 {
607  struct ipoib_dev_priv *priv = netdev_priv(dev);
608 
609  ipoib_dbg_mcast(priv, "stopping multicast thread\n");
610 
611  mutex_lock(&mcast_mutex);
614  mutex_unlock(&mcast_mutex);
615 
616  if (flush)
618 
619  return 0;
620 }
621 
622 static int ipoib_mcast_leave(struct net_device *dev, struct ipoib_mcast *mcast)
623 {
624  struct ipoib_dev_priv *priv = netdev_priv(dev);
625  int ret = 0;
626 
628  ib_sa_free_multicast(mcast->mc);
629 
631  ipoib_dbg_mcast(priv, "leaving MGID %pI6\n",
632  mcast->mcmember.mgid.raw);
633 
634  /* Remove ourselves from the multicast group */
635  ret = ib_detach_mcast(priv->qp, &mcast->mcmember.mgid,
636  be16_to_cpu(mcast->mcmember.mlid));
637  if (ret)
638  ipoib_warn(priv, "ib_detach_mcast failed (result = %d)\n", ret);
639  }
640 
641  return 0;
642 }
643 
644 void ipoib_mcast_send(struct net_device *dev, u8 *daddr, struct sk_buff *skb)
645 {
646  struct ipoib_dev_priv *priv = netdev_priv(dev);
647  struct ipoib_mcast *mcast;
648  unsigned long flags;
649  void *mgid = daddr + 4;
650 
651  spin_lock_irqsave(&priv->lock, flags);
652 
653  if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags) ||
654  !priv->broadcast ||
655  !test_bit(IPOIB_MCAST_FLAG_ATTACHED, &priv->broadcast->flags)) {
656  ++dev->stats.tx_dropped;
657  dev_kfree_skb_any(skb);
658  goto unlock;
659  }
660 
661  mcast = __ipoib_mcast_find(dev, mgid);
662  if (!mcast) {
663  /* Let's create a new send only group now */
664  ipoib_dbg_mcast(priv, "setting up send only multicast group for %pI6\n",
665  mgid);
666 
667  mcast = ipoib_mcast_alloc(dev, 0);
668  if (!mcast) {
669  ipoib_warn(priv, "unable to allocate memory for "
670  "multicast structure\n");
671  ++dev->stats.tx_dropped;
672  dev_kfree_skb_any(skb);
673  goto out;
674  }
675 
677  memcpy(mcast->mcmember.mgid.raw, mgid, sizeof (union ib_gid));
678  __ipoib_mcast_add(dev, mcast);
679  list_add_tail(&mcast->list, &priv->multicast_list);
680  }
681 
682  if (!mcast->ah) {
683  if (skb_queue_len(&mcast->pkt_queue) < IPOIB_MAX_MCAST_QUEUE)
684  skb_queue_tail(&mcast->pkt_queue, skb);
685  else {
686  ++dev->stats.tx_dropped;
687  dev_kfree_skb_any(skb);
688  }
689 
690  if (test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags))
691  ipoib_dbg_mcast(priv, "no address vector, "
692  "but multicast join already started\n");
693  else if (test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags))
694  ipoib_mcast_sendonly_join(mcast);
695 
696  /*
697  * If lookup completes between here and out:, don't
698  * want to send packet twice.
699  */
700  mcast = NULL;
701  }
702 
703 out:
704  if (mcast && mcast->ah) {
705  struct ipoib_neigh *neigh;
706 
707  spin_unlock_irqrestore(&priv->lock, flags);
708  neigh = ipoib_neigh_get(dev, daddr);
709  spin_lock_irqsave(&priv->lock, flags);
710  if (!neigh) {
711  neigh = ipoib_neigh_alloc(daddr, dev);
712  if (neigh) {
713  kref_get(&mcast->ah->ref);
714  neigh->ah = mcast->ah;
715  list_add_tail(&neigh->list, &mcast->neigh_list);
716  }
717  }
718  spin_unlock_irqrestore(&priv->lock, flags);
719  ipoib_send(dev, skb, mcast->ah, IB_MULTICAST_QPN);
720  if (neigh)
721  ipoib_neigh_put(neigh);
722  return;
723  }
724 
725 unlock:
726  spin_unlock_irqrestore(&priv->lock, flags);
727 }
728 
730 {
731  struct ipoib_dev_priv *priv = netdev_priv(dev);
732  LIST_HEAD(remove_list);
733  struct ipoib_mcast *mcast, *tmcast;
734  unsigned long flags;
735 
736  ipoib_dbg_mcast(priv, "flushing multicast list\n");
737 
738  spin_lock_irqsave(&priv->lock, flags);
739 
740  list_for_each_entry_safe(mcast, tmcast, &priv->multicast_list, list) {
741  list_del(&mcast->list);
742  rb_erase(&mcast->rb_node, &priv->multicast_tree);
743  list_add_tail(&mcast->list, &remove_list);
744  }
745 
746  if (priv->broadcast) {
747  rb_erase(&priv->broadcast->rb_node, &priv->multicast_tree);
748  list_add_tail(&priv->broadcast->list, &remove_list);
749  priv->broadcast = NULL;
750  }
751 
752  spin_unlock_irqrestore(&priv->lock, flags);
753 
754  list_for_each_entry_safe(mcast, tmcast, &remove_list, list) {
755  ipoib_mcast_leave(dev, mcast);
756  ipoib_mcast_free(mcast);
757  }
758 }
759 
760 static int ipoib_mcast_addr_is_valid(const u8 *addr, const u8 *broadcast)
761 {
762  /* reserved QPN, prefix, scope */
763  if (memcmp(addr, broadcast, 6))
764  return 0;
765  /* signature lower, pkey */
766  if (memcmp(addr + 7, broadcast + 7, 3))
767  return 0;
768  return 1;
769 }
770 
772 {
773  struct ipoib_dev_priv *priv =
775  struct net_device *dev = priv->dev;
776  struct netdev_hw_addr *ha;
777  struct ipoib_mcast *mcast, *tmcast;
778  LIST_HEAD(remove_list);
779  unsigned long flags;
780  struct ib_sa_mcmember_rec rec;
781 
782  ipoib_dbg_mcast(priv, "restarting multicast task\n");
783 
784  ipoib_mcast_stop_thread(dev, 0);
785 
786  local_irq_save(flags);
787  netif_addr_lock(dev);
788  spin_lock(&priv->lock);
789 
790  /*
791  * Unfortunately, the networking core only gives us a list of all of
792  * the multicast hardware addresses. We need to figure out which ones
793  * are new and which ones have been removed
794  */
795 
796  /* Clear out the found flag */
797  list_for_each_entry(mcast, &priv->multicast_list, list)
799 
800  /* Mark all of the entries that are found or don't exist */
801  netdev_for_each_mc_addr(ha, dev) {
802  union ib_gid mgid;
803 
804  if (!ipoib_mcast_addr_is_valid(ha->addr, dev->broadcast))
805  continue;
806 
807  memcpy(mgid.raw, ha->addr + 4, sizeof mgid);
808 
809  mcast = __ipoib_mcast_find(dev, &mgid);
810  if (!mcast || test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) {
811  struct ipoib_mcast *nmcast;
812 
813  /* ignore group which is directly joined by userspace */
814  if (test_bit(IPOIB_FLAG_UMCAST, &priv->flags) &&
815  !ib_sa_get_mcmember_rec(priv->ca, priv->port, &mgid, &rec)) {
816  ipoib_dbg_mcast(priv, "ignoring multicast entry for mgid %pI6\n",
817  mgid.raw);
818  continue;
819  }
820 
821  /* Not found or send-only group, let's add a new entry */
822  ipoib_dbg_mcast(priv, "adding multicast entry for mgid %pI6\n",
823  mgid.raw);
824 
825  nmcast = ipoib_mcast_alloc(dev, 0);
826  if (!nmcast) {
827  ipoib_warn(priv, "unable to allocate memory for multicast structure\n");
828  continue;
829  }
830 
832 
833  nmcast->mcmember.mgid = mgid;
834 
835  if (mcast) {
836  /* Destroy the send only entry */
837  list_move_tail(&mcast->list, &remove_list);
838 
839  rb_replace_node(&mcast->rb_node,
840  &nmcast->rb_node,
841  &priv->multicast_tree);
842  } else
843  __ipoib_mcast_add(dev, nmcast);
844 
845  list_add_tail(&nmcast->list, &priv->multicast_list);
846  }
847 
848  if (mcast)
850  }
851 
852  /* Remove all of the entries don't exist anymore */
853  list_for_each_entry_safe(mcast, tmcast, &priv->multicast_list, list) {
854  if (!test_bit(IPOIB_MCAST_FLAG_FOUND, &mcast->flags) &&
856  ipoib_dbg_mcast(priv, "deleting multicast group %pI6\n",
857  mcast->mcmember.mgid.raw);
858 
859  rb_erase(&mcast->rb_node, &priv->multicast_tree);
860 
861  /* Move to the remove list */
862  list_move_tail(&mcast->list, &remove_list);
863  }
864  }
865 
866  spin_unlock(&priv->lock);
867  netif_addr_unlock(dev);
868  local_irq_restore(flags);
869 
870  /* We have to cancel outside of the spinlock */
871  list_for_each_entry_safe(mcast, tmcast, &remove_list, list) {
872  ipoib_mcast_leave(mcast->dev, mcast);
873  ipoib_mcast_free(mcast);
874  }
875 
876  if (test_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags))
878 }
879 
880 #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
881 
882 struct ipoib_mcast_iter *ipoib_mcast_iter_init(struct net_device *dev)
883 {
884  struct ipoib_mcast_iter *iter;
885 
886  iter = kmalloc(sizeof *iter, GFP_KERNEL);
887  if (!iter)
888  return NULL;
889 
890  iter->dev = dev;
891  memset(iter->mgid.raw, 0, 16);
892 
893  if (ipoib_mcast_iter_next(iter)) {
894  kfree(iter);
895  return NULL;
896  }
897 
898  return iter;
899 }
900 
901 int ipoib_mcast_iter_next(struct ipoib_mcast_iter *iter)
902 {
903  struct ipoib_dev_priv *priv = netdev_priv(iter->dev);
904  struct rb_node *n;
905  struct ipoib_mcast *mcast;
906  int ret = 1;
907 
908  spin_lock_irq(&priv->lock);
909 
910  n = rb_first(&priv->multicast_tree);
911 
912  while (n) {
913  mcast = rb_entry(n, struct ipoib_mcast, rb_node);
914 
915  if (memcmp(iter->mgid.raw, mcast->mcmember.mgid.raw,
916  sizeof (union ib_gid)) < 0) {
917  iter->mgid = mcast->mcmember.mgid;
918  iter->created = mcast->created;
919  iter->queuelen = skb_queue_len(&mcast->pkt_queue);
920  iter->complete = !!mcast->ah;
921  iter->send_only = !!(mcast->flags & (1 << IPOIB_MCAST_FLAG_SENDONLY));
922 
923  ret = 0;
924 
925  break;
926  }
927 
928  n = rb_next(n);
929  }
930 
931  spin_unlock_irq(&priv->lock);
932 
933  return ret;
934 }
935 
936 void ipoib_mcast_iter_read(struct ipoib_mcast_iter *iter,
937  union ib_gid *mgid,
938  unsigned long *created,
939  unsigned int *queuelen,
940  unsigned int *complete,
941  unsigned int *send_only)
942 {
943  *mgid = iter->mgid;
944  *created = iter->created;
945  *queuelen = iter->queuelen;
946  *complete = iter->complete;
947  *send_only = iter->send_only;
948 }
949 
950 #endif /* CONFIG_INFINIBAND_IPOIB_DEBUG */