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 51static int mcast_debug_level; 52 53module_param(mcast_debug_level, int, 0644); 54MODULE_PARM_DESC(mcast_debug_level, 55 "Enable multicast debug tracing if > 0"); 56#endif 57 58struct 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/* 68 * This should be called with the priv->lock held 69 */ 70static void __ipoib_mcast_schedule_join_thread(struct ipoib_dev_priv *priv, 71 struct ipoib_mcast *mcast, 72 bool delay) 73{ 74 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) 75 return; 76 77 /* 78 * We will be scheduling *something*, so cancel whatever is 79 * currently scheduled first 80 */ 81 cancel_delayed_work(&priv->mcast_task); 82 if (mcast && delay) { 83 /* 84 * We had a failure and want to schedule a retry later 85 */ 86 mcast->backoff *= 2; 87 if (mcast->backoff > IPOIB_MAX_BACKOFF_SECONDS) 88 mcast->backoff = IPOIB_MAX_BACKOFF_SECONDS; 89 mcast->delay_until = jiffies + (mcast->backoff * HZ); 90 /* 91 * Mark this mcast for its delay, but restart the 92 * task immediately. The join task will make sure to 93 * clear out all entries without delays, and then 94 * schedule itself to run again when the earliest 95 * delay expires 96 */ 97 queue_delayed_work(priv->wq, &priv->mcast_task, 0); 98 } else if (delay) { 99 /* 100 * Special case of retrying after a failure to 101 * allocate the broadcast multicast group, wait 102 * 1 second and try again 103 */ 104 queue_delayed_work(priv->wq, &priv->mcast_task, HZ); 105 } else 106 queue_delayed_work(priv->wq, &priv->mcast_task, 0); 107} 108 109static void ipoib_mcast_free(struct ipoib_mcast *mcast) 110{ 111 struct net_device *dev = mcast->dev; 112 int tx_dropped = 0; 113 114 ipoib_dbg_mcast(netdev_priv(dev), "deleting multicast group %pI6\n", 115 mcast->mcmember.mgid.raw); 116 117 /* remove all neigh connected to this mcast */ 118 ipoib_del_neighs_by_gid(dev, mcast->mcmember.mgid.raw); 119 120 if (mcast->ah) 121 ipoib_put_ah(mcast->ah); 122 123 while (!skb_queue_empty(&mcast->pkt_queue)) { 124 ++tx_dropped; 125 dev_kfree_skb_any(skb_dequeue(&mcast->pkt_queue)); 126 } 127 128 netif_tx_lock_bh(dev); 129 dev->stats.tx_dropped += tx_dropped; 130 netif_tx_unlock_bh(dev); 131 132 kfree(mcast); 133} 134 135static struct ipoib_mcast *ipoib_mcast_alloc(struct net_device *dev, 136 int can_sleep) 137{ 138 struct ipoib_mcast *mcast; 139 140 mcast = kzalloc(sizeof *mcast, can_sleep ? GFP_KERNEL : GFP_ATOMIC); 141 if (!mcast) 142 return NULL; 143 144 mcast->dev = dev; 145 mcast->created = jiffies; 146 mcast->delay_until = jiffies; 147 mcast->backoff = 1; 148 149 INIT_LIST_HEAD(&mcast->list); 150 INIT_LIST_HEAD(&mcast->neigh_list); 151 skb_queue_head_init(&mcast->pkt_queue); 152 153 return mcast; 154} 155 156static struct ipoib_mcast *__ipoib_mcast_find(struct net_device *dev, void *mgid) 157{ 158 struct ipoib_dev_priv *priv = netdev_priv(dev); 159 struct rb_node *n = priv->multicast_tree.rb_node; 160 161 while (n) { 162 struct ipoib_mcast *mcast; 163 int ret; 164 165 mcast = rb_entry(n, struct ipoib_mcast, rb_node); 166 167 ret = memcmp(mgid, mcast->mcmember.mgid.raw, 168 sizeof (union ib_gid)); 169 if (ret < 0) 170 n = n->rb_left; 171 else if (ret > 0) 172 n = n->rb_right; 173 else 174 return mcast; 175 } 176 177 return NULL; 178} 179 180static int __ipoib_mcast_add(struct net_device *dev, struct ipoib_mcast *mcast) 181{ 182 struct ipoib_dev_priv *priv = netdev_priv(dev); 183 struct rb_node **n = &priv->multicast_tree.rb_node, *pn = NULL; 184 185 while (*n) { 186 struct ipoib_mcast *tmcast; 187 int ret; 188 189 pn = *n; 190 tmcast = rb_entry(pn, struct ipoib_mcast, rb_node); 191 192 ret = memcmp(mcast->mcmember.mgid.raw, tmcast->mcmember.mgid.raw, 193 sizeof (union ib_gid)); 194 if (ret < 0) 195 n = &pn->rb_left; 196 else if (ret > 0) 197 n = &pn->rb_right; 198 else 199 return -EEXIST; 200 } 201 202 rb_link_node(&mcast->rb_node, pn, n); 203 rb_insert_color(&mcast->rb_node, &priv->multicast_tree); 204 205 return 0; 206} 207 208static int ipoib_mcast_join_finish(struct ipoib_mcast *mcast, 209 struct ib_sa_mcmember_rec *mcmember) 210{ 211 struct net_device *dev = mcast->dev; 212 struct ipoib_dev_priv *priv = netdev_priv(dev); 213 struct ipoib_ah *ah; 214 int ret; 215 int set_qkey = 0; 216 217 mcast->mcmember = *mcmember; 218 219 /* Set the multicast MTU and cached Q_Key before we attach if it's 220 * the broadcast group. 221 */ 222 if (!memcmp(mcast->mcmember.mgid.raw, priv->dev->broadcast + 4, 223 sizeof (union ib_gid))) { 224 spin_lock_irq(&priv->lock); 225 if (!priv->broadcast) { 226 spin_unlock_irq(&priv->lock); 227 return -EAGAIN; 228 } 229 /*update priv member according to the new mcast*/ 230 priv->broadcast->mcmember.qkey = mcmember->qkey; 231 priv->broadcast->mcmember.mtu = mcmember->mtu; 232 priv->broadcast->mcmember.traffic_class = mcmember->traffic_class; 233 priv->broadcast->mcmember.rate = mcmember->rate; 234 priv->broadcast->mcmember.sl = mcmember->sl; 235 priv->broadcast->mcmember.flow_label = mcmember->flow_label; 236 priv->broadcast->mcmember.hop_limit = mcmember->hop_limit; 237 /* assume if the admin and the mcast are the same both can be changed */ 238 if (priv->mcast_mtu == priv->admin_mtu) 239 priv->admin_mtu = 240 priv->mcast_mtu = 241 IPOIB_UD_MTU(ib_mtu_enum_to_int(priv->broadcast->mcmember.mtu)); 242 else 243 priv->mcast_mtu = 244 IPOIB_UD_MTU(ib_mtu_enum_to_int(priv->broadcast->mcmember.mtu)); 245 246 priv->qkey = be32_to_cpu(priv->broadcast->mcmember.qkey); 247 spin_unlock_irq(&priv->lock); 248 priv->tx_wr.wr.ud.remote_qkey = priv->qkey; 249 set_qkey = 1; 250 } 251 252 if (!test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) { 253 if (test_and_set_bit(IPOIB_MCAST_FLAG_ATTACHED, &mcast->flags)) { 254 ipoib_warn(priv, "multicast group %pI6 already attached\n", 255 mcast->mcmember.mgid.raw); 256 257 return 0; 258 } 259 260 ret = ipoib_mcast_attach(dev, be16_to_cpu(mcast->mcmember.mlid), 261 &mcast->mcmember.mgid, set_qkey); 262 if (ret < 0) { 263 ipoib_warn(priv, "couldn't attach QP to multicast group %pI6\n", 264 mcast->mcmember.mgid.raw); 265 266 clear_bit(IPOIB_MCAST_FLAG_ATTACHED, &mcast->flags); 267 return ret; 268 } 269 } 270 271 { 272 struct ib_ah_attr av = { 273 .dlid = be16_to_cpu(mcast->mcmember.mlid), 274 .port_num = priv->port, 275 .sl = mcast->mcmember.sl, 276 .ah_flags = IB_AH_GRH, 277 .static_rate = mcast->mcmember.rate, 278 .grh = { 279 .flow_label = be32_to_cpu(mcast->mcmember.flow_label), 280 .hop_limit = mcast->mcmember.hop_limit, 281 .sgid_index = 0, 282 .traffic_class = mcast->mcmember.traffic_class 283 } 284 }; 285 av.grh.dgid = mcast->mcmember.mgid; 286 287 ah = ipoib_create_ah(dev, priv->pd, &av); 288 if (IS_ERR(ah)) { 289 ipoib_warn(priv, "ib_address_create failed %ld\n", 290 -PTR_ERR(ah)); 291 /* use original error */ 292 return PTR_ERR(ah); 293 } else { 294 spin_lock_irq(&priv->lock); 295 mcast->ah = ah; 296 spin_unlock_irq(&priv->lock); 297 298 ipoib_dbg_mcast(priv, "MGID %pI6 AV %p, LID 0x%04x, SL %d\n", 299 mcast->mcmember.mgid.raw, 300 mcast->ah->ah, 301 be16_to_cpu(mcast->mcmember.mlid), 302 mcast->mcmember.sl); 303 } 304 } 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 if (dev_queue_xmit(skb)) 315 ipoib_warn(priv, "dev_queue_xmit failed to requeue packet\n"); 316 317 netif_tx_lock_bh(dev); 318 } 319 netif_tx_unlock_bh(dev); 320 321 return 0; 322} 323 324void ipoib_mcast_carrier_on_task(struct work_struct *work) 325{ 326 struct ipoib_dev_priv *priv = container_of(work, struct ipoib_dev_priv, 327 carrier_on_task); 328 struct ib_port_attr attr; 329 330 if (ib_query_port(priv->ca, priv->port, &attr) || 331 attr.state != IB_PORT_ACTIVE) { 332 ipoib_dbg(priv, "Keeping carrier off until IB port is active\n"); 333 return; 334 } 335 336 /* 337 * Take rtnl_lock to avoid racing with ipoib_stop() and 338 * turning the carrier back on while a device is being 339 * removed. However, ipoib_stop() will attempt to flush 340 * the workqueue while holding the rtnl lock, so loop 341 * on trylock until either we get the lock or we see 342 * FLAG_OPER_UP go away as that signals that we are bailing 343 * and can safely ignore the carrier on work. 344 */ 345 while (!rtnl_trylock()) { 346 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) 347 return; 348 else 349 msleep(20); 350 } 351 if (!ipoib_cm_admin_enabled(priv->dev)) 352 dev_set_mtu(priv->dev, min(priv->mcast_mtu, priv->admin_mtu)); 353 netif_carrier_on(priv->dev); 354 rtnl_unlock(); 355} 356 357static int ipoib_mcast_join_complete(int status, 358 struct ib_sa_multicast *multicast) 359{ 360 struct ipoib_mcast *mcast = multicast->context; 361 struct net_device *dev = mcast->dev; 362 struct ipoib_dev_priv *priv = netdev_priv(dev); 363 364 ipoib_dbg_mcast(priv, "%sjoin completion for %pI6 (status %d)\n", 365 test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) ? 366 "sendonly " : "", 367 mcast->mcmember.mgid.raw, status); 368 369 /* We trap for port events ourselves. */ 370 if (status == -ENETRESET) { 371 status = 0; 372 goto out; 373 } 374 375 if (!status) 376 status = ipoib_mcast_join_finish(mcast, &multicast->rec); 377 378 if (!status) { 379 mcast->backoff = 1; 380 mcast->delay_until = jiffies; 381 382 /* 383 * Defer carrier on work to priv->wq to avoid a 384 * deadlock on rtnl_lock here. Requeue our multicast 385 * work too, which will end up happening right after 386 * our carrier on task work and will allow us to 387 * send out all of the non-broadcast joins 388 */ 389 if (mcast == priv->broadcast) { 390 spin_lock_irq(&priv->lock); 391 queue_work(priv->wq, &priv->carrier_on_task); 392 __ipoib_mcast_schedule_join_thread(priv, NULL, 0); 393 goto out_locked; 394 } 395 } else { 396 if (mcast->logcount++ < 20) { 397 if (status == -ETIMEDOUT || status == -EAGAIN) { 398 ipoib_dbg_mcast(priv, "%smulticast join failed for %pI6, status %d\n", 399 test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) ? "sendonly " : "", 400 mcast->mcmember.mgid.raw, status); 401 } else { 402 ipoib_warn(priv, "%smulticast join failed for %pI6, status %d\n", 403 test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) ? "sendonly " : "", 404 mcast->mcmember.mgid.raw, status); 405 } 406 } 407 408 if (test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) && 409 mcast->backoff >= 2) { 410 /* 411 * We only retry sendonly joins once before we drop 412 * the packet and quit trying to deal with the 413 * group. However, we leave the group in the 414 * mcast list as an unjoined group. If we want to 415 * try joining again, we simply queue up a packet 416 * and restart the join thread. The empty queue 417 * is why the join thread ignores this group. 418 */ 419 mcast->backoff = 1; 420 netif_tx_lock_bh(dev); 421 while (!skb_queue_empty(&mcast->pkt_queue)) { 422 ++dev->stats.tx_dropped; 423 dev_kfree_skb_any(skb_dequeue(&mcast->pkt_queue)); 424 } 425 netif_tx_unlock_bh(dev); 426 } else { 427 spin_lock_irq(&priv->lock); 428 /* Requeue this join task with a backoff delay */ 429 __ipoib_mcast_schedule_join_thread(priv, mcast, 1); 430 goto out_locked; 431 } 432 } 433out: 434 spin_lock_irq(&priv->lock); 435out_locked: 436 /* 437 * Make sure to set mcast->mc before we clear the busy flag to avoid 438 * racing with code that checks for BUSY before checking mcast->mc 439 */ 440 if (status) 441 mcast->mc = NULL; 442 else 443 mcast->mc = multicast; 444 clear_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags); 445 spin_unlock_irq(&priv->lock); 446 complete(&mcast->done); 447 448 return status; 449} 450 451static void ipoib_mcast_join(struct net_device *dev, struct ipoib_mcast *mcast, 452 int create) 453{ 454 struct ipoib_dev_priv *priv = netdev_priv(dev); 455 struct ib_sa_multicast *multicast; 456 struct ib_sa_mcmember_rec rec = { 457 .join_state = 1 458 }; 459 ib_sa_comp_mask comp_mask; 460 int ret = 0; 461 462 ipoib_dbg_mcast(priv, "joining MGID %pI6\n", mcast->mcmember.mgid.raw); 463 464 rec.mgid = mcast->mcmember.mgid; 465 rec.port_gid = priv->local_gid; 466 rec.pkey = cpu_to_be16(priv->pkey); 467 468 comp_mask = 469 IB_SA_MCMEMBER_REC_MGID | 470 IB_SA_MCMEMBER_REC_PORT_GID | 471 IB_SA_MCMEMBER_REC_PKEY | 472 IB_SA_MCMEMBER_REC_JOIN_STATE; 473 474 if (create) { 475 comp_mask |= 476 IB_SA_MCMEMBER_REC_QKEY | 477 IB_SA_MCMEMBER_REC_MTU_SELECTOR | 478 IB_SA_MCMEMBER_REC_MTU | 479 IB_SA_MCMEMBER_REC_TRAFFIC_CLASS | 480 IB_SA_MCMEMBER_REC_RATE_SELECTOR | 481 IB_SA_MCMEMBER_REC_RATE | 482 IB_SA_MCMEMBER_REC_SL | 483 IB_SA_MCMEMBER_REC_FLOW_LABEL | 484 IB_SA_MCMEMBER_REC_HOP_LIMIT; 485 486 rec.qkey = priv->broadcast->mcmember.qkey; 487 rec.mtu_selector = IB_SA_EQ; 488 rec.mtu = priv->broadcast->mcmember.mtu; 489 rec.traffic_class = priv->broadcast->mcmember.traffic_class; 490 rec.rate_selector = IB_SA_EQ; 491 rec.rate = priv->broadcast->mcmember.rate; 492 rec.sl = priv->broadcast->mcmember.sl; 493 rec.flow_label = priv->broadcast->mcmember.flow_label; 494 rec.hop_limit = priv->broadcast->mcmember.hop_limit; 495 } 496 497 multicast = ib_sa_join_multicast(&ipoib_sa_client, priv->ca, priv->port, 498 &rec, comp_mask, GFP_KERNEL, 499 ipoib_mcast_join_complete, mcast); 500 if (IS_ERR(multicast)) { 501 ret = PTR_ERR(multicast); 502 ipoib_warn(priv, "ib_sa_join_multicast failed, status %d\n", ret); 503 spin_lock_irq(&priv->lock); 504 /* Requeue this join task with a backoff delay */ 505 __ipoib_mcast_schedule_join_thread(priv, mcast, 1); 506 clear_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags); 507 spin_unlock_irq(&priv->lock); 508 complete(&mcast->done); 509 } 510} 511 512void ipoib_mcast_join_task(struct work_struct *work) 513{ 514 struct ipoib_dev_priv *priv = 515 container_of(work, struct ipoib_dev_priv, mcast_task.work); 516 struct net_device *dev = priv->dev; 517 struct ib_port_attr port_attr; 518 unsigned long delay_until = 0; 519 struct ipoib_mcast *mcast = NULL; 520 int create = 1; 521 522 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) 523 return; 524 525 if (ib_query_port(priv->ca, priv->port, &port_attr) || 526 port_attr.state != IB_PORT_ACTIVE) { 527 ipoib_dbg(priv, "port state is not ACTIVE (state = %d) suspending join task\n", 528 port_attr.state); 529 return; 530 } 531 priv->local_lid = port_attr.lid; 532 533 if (ib_query_gid(priv->ca, priv->port, 0, &priv->local_gid)) 534 ipoib_warn(priv, "ib_query_gid() failed\n"); 535 else 536 memcpy(priv->dev->dev_addr + 4, priv->local_gid.raw, sizeof (union ib_gid)); 537 538 spin_lock_irq(&priv->lock); 539 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) 540 goto out; 541 542 if (!priv->broadcast) { 543 struct ipoib_mcast *broadcast; 544 545 broadcast = ipoib_mcast_alloc(dev, 0); 546 if (!broadcast) { 547 ipoib_warn(priv, "failed to allocate broadcast group\n"); 548 /* 549 * Restart us after a 1 second delay to retry 550 * creating our broadcast group and attaching to 551 * it. Until this succeeds, this ipoib dev is 552 * completely stalled (multicast wise). 553 */ 554 __ipoib_mcast_schedule_join_thread(priv, NULL, 1); 555 goto out; 556 } 557 558 memcpy(broadcast->mcmember.mgid.raw, priv->dev->broadcast + 4, 559 sizeof (union ib_gid)); 560 priv->broadcast = broadcast; 561 562 __ipoib_mcast_add(dev, priv->broadcast); 563 } 564 565 if (!test_bit(IPOIB_MCAST_FLAG_ATTACHED, &priv->broadcast->flags)) { 566 if (IS_ERR_OR_NULL(priv->broadcast->mc) && 567 !test_bit(IPOIB_MCAST_FLAG_BUSY, &priv->broadcast->flags)) { 568 mcast = priv->broadcast; 569 create = 0; 570 if (mcast->backoff > 1 && 571 time_before(jiffies, mcast->delay_until)) { 572 delay_until = mcast->delay_until; 573 mcast = NULL; 574 } 575 } 576 goto out; 577 } 578 579 /* 580 * We'll never get here until the broadcast group is both allocated 581 * and attached 582 */ 583 list_for_each_entry(mcast, &priv->multicast_list, list) { 584 if (IS_ERR_OR_NULL(mcast->mc) && 585 !test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags) && 586 (!test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) || 587 !skb_queue_empty(&mcast->pkt_queue))) { 588 if (mcast->backoff == 1 || 589 time_after_eq(jiffies, mcast->delay_until)) { 590 /* Found the next unjoined group */ 591 init_completion(&mcast->done); 592 set_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags); 593 if (test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) 594 create = 0; 595 else 596 create = 1; 597 spin_unlock_irq(&priv->lock); 598 ipoib_mcast_join(dev, mcast, create); 599 spin_lock_irq(&priv->lock); 600 } else if (!delay_until || 601 time_before(mcast->delay_until, delay_until)) 602 delay_until = mcast->delay_until; 603 } 604 } 605 606 mcast = NULL; 607 ipoib_dbg_mcast(priv, "successfully started all multicast joins\n"); 608 609out: 610 if (delay_until) { 611 cancel_delayed_work(&priv->mcast_task); 612 queue_delayed_work(priv->wq, &priv->mcast_task, 613 delay_until - jiffies); 614 } 615 if (mcast) { 616 init_completion(&mcast->done); 617 set_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags); 618 } 619 spin_unlock_irq(&priv->lock); 620 if (mcast) 621 ipoib_mcast_join(dev, mcast, create); 622} 623 624int ipoib_mcast_start_thread(struct net_device *dev) 625{ 626 struct ipoib_dev_priv *priv = netdev_priv(dev); 627 unsigned long flags; 628 629 ipoib_dbg_mcast(priv, "starting multicast thread\n"); 630 631 spin_lock_irqsave(&priv->lock, flags); 632 __ipoib_mcast_schedule_join_thread(priv, NULL, 0); 633 spin_unlock_irqrestore(&priv->lock, flags); 634 635 return 0; 636} 637 638int ipoib_mcast_stop_thread(struct net_device *dev) 639{ 640 struct ipoib_dev_priv *priv = netdev_priv(dev); 641 unsigned long flags; 642 643 ipoib_dbg_mcast(priv, "stopping multicast thread\n"); 644 645 spin_lock_irqsave(&priv->lock, flags); 646 cancel_delayed_work(&priv->mcast_task); 647 spin_unlock_irqrestore(&priv->lock, flags); 648 649 flush_workqueue(priv->wq); 650 651 return 0; 652} 653 654static int ipoib_mcast_leave(struct net_device *dev, struct ipoib_mcast *mcast) 655{ 656 struct ipoib_dev_priv *priv = netdev_priv(dev); 657 int ret = 0; 658 659 if (test_and_clear_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags)) 660 ipoib_warn(priv, "ipoib_mcast_leave on an in-flight join\n"); 661 662 if (!IS_ERR_OR_NULL(mcast->mc)) 663 ib_sa_free_multicast(mcast->mc); 664 665 if (test_and_clear_bit(IPOIB_MCAST_FLAG_ATTACHED, &mcast->flags)) { 666 ipoib_dbg_mcast(priv, "leaving MGID %pI6\n", 667 mcast->mcmember.mgid.raw); 668 669 /* Remove ourselves from the multicast group */ 670 ret = ib_detach_mcast(priv->qp, &mcast->mcmember.mgid, 671 be16_to_cpu(mcast->mcmember.mlid)); 672 if (ret) 673 ipoib_warn(priv, "ib_detach_mcast failed (result = %d)\n", ret); 674 } else if (!test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) 675 ipoib_dbg(priv, "leaving with no mcmember but not a " 676 "SENDONLY join\n"); 677 678 return 0; 679} 680 681void ipoib_mcast_send(struct net_device *dev, u8 *daddr, struct sk_buff *skb) 682{ 683 struct ipoib_dev_priv *priv = netdev_priv(dev); 684 struct ipoib_mcast *mcast; 685 unsigned long flags; 686 void *mgid = daddr + 4; 687 688 spin_lock_irqsave(&priv->lock, flags); 689 690 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags) || 691 !priv->broadcast || 692 !test_bit(IPOIB_MCAST_FLAG_ATTACHED, &priv->broadcast->flags)) { 693 ++dev->stats.tx_dropped; 694 dev_kfree_skb_any(skb); 695 goto unlock; 696 } 697 698 mcast = __ipoib_mcast_find(dev, mgid); 699 if (!mcast || !mcast->ah) { 700 if (!mcast) { 701 /* Let's create a new send only group now */ 702 ipoib_dbg_mcast(priv, "setting up send only multicast group for %pI6\n", 703 mgid); 704 705 mcast = ipoib_mcast_alloc(dev, 0); 706 if (!mcast) { 707 ipoib_warn(priv, "unable to allocate memory " 708 "for multicast structure\n"); 709 ++dev->stats.tx_dropped; 710 dev_kfree_skb_any(skb); 711 goto unlock; 712 } 713 714 set_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags); 715 memcpy(mcast->mcmember.mgid.raw, mgid, 716 sizeof (union ib_gid)); 717 __ipoib_mcast_add(dev, mcast); 718 list_add_tail(&mcast->list, &priv->multicast_list); 719 } 720 if (skb_queue_len(&mcast->pkt_queue) < IPOIB_MAX_MCAST_QUEUE) 721 skb_queue_tail(&mcast->pkt_queue, skb); 722 else { 723 ++dev->stats.tx_dropped; 724 dev_kfree_skb_any(skb); 725 } 726 if (!test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags)) { 727 __ipoib_mcast_schedule_join_thread(priv, NULL, 0); 728 } 729 } else { 730 struct ipoib_neigh *neigh; 731 732 spin_unlock_irqrestore(&priv->lock, flags); 733 neigh = ipoib_neigh_get(dev, daddr); 734 spin_lock_irqsave(&priv->lock, flags); 735 if (!neigh) { 736 neigh = ipoib_neigh_alloc(daddr, dev); 737 if (neigh) { 738 kref_get(&mcast->ah->ref); 739 neigh->ah = mcast->ah; 740 list_add_tail(&neigh->list, &mcast->neigh_list); 741 } 742 } 743 spin_unlock_irqrestore(&priv->lock, flags); 744 ipoib_send(dev, skb, mcast->ah, IB_MULTICAST_QPN); 745 if (neigh) 746 ipoib_neigh_put(neigh); 747 return; 748 } 749 750unlock: 751 spin_unlock_irqrestore(&priv->lock, flags); 752} 753 754void ipoib_mcast_dev_flush(struct net_device *dev) 755{ 756 struct ipoib_dev_priv *priv = netdev_priv(dev); 757 LIST_HEAD(remove_list); 758 struct ipoib_mcast *mcast, *tmcast; 759 unsigned long flags; 760 761 ipoib_dbg_mcast(priv, "flushing multicast list\n"); 762 763 spin_lock_irqsave(&priv->lock, flags); 764 765 list_for_each_entry_safe(mcast, tmcast, &priv->multicast_list, list) { 766 list_del(&mcast->list); 767 rb_erase(&mcast->rb_node, &priv->multicast_tree); 768 list_add_tail(&mcast->list, &remove_list); 769 } 770 771 if (priv->broadcast) { 772 rb_erase(&priv->broadcast->rb_node, &priv->multicast_tree); 773 list_add_tail(&priv->broadcast->list, &remove_list); 774 priv->broadcast = NULL; 775 } 776 777 spin_unlock_irqrestore(&priv->lock, flags); 778 779 /* 780 * make sure the in-flight joins have finished before we attempt 781 * to leave 782 */ 783 list_for_each_entry_safe(mcast, tmcast, &remove_list, list) 784 if (test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags)) 785 wait_for_completion(&mcast->done); 786 787 list_for_each_entry_safe(mcast, tmcast, &remove_list, list) { 788 ipoib_mcast_leave(dev, mcast); 789 ipoib_mcast_free(mcast); 790 } 791} 792 793static int ipoib_mcast_addr_is_valid(const u8 *addr, const u8 *broadcast) 794{ 795 /* reserved QPN, prefix, scope */ 796 if (memcmp(addr, broadcast, 6)) 797 return 0; 798 /* signature lower, pkey */ 799 if (memcmp(addr + 7, broadcast + 7, 3)) 800 return 0; 801 return 1; 802} 803 804void ipoib_mcast_restart_task(struct work_struct *work) 805{ 806 struct ipoib_dev_priv *priv = 807 container_of(work, struct ipoib_dev_priv, restart_task); 808 struct net_device *dev = priv->dev; 809 struct netdev_hw_addr *ha; 810 struct ipoib_mcast *mcast, *tmcast; 811 LIST_HEAD(remove_list); 812 unsigned long flags; 813 struct ib_sa_mcmember_rec rec; 814 815 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) 816 /* 817 * shortcut...on shutdown flush is called next, just 818 * let it do all the work 819 */ 820 return; 821 822 ipoib_dbg_mcast(priv, "restarting multicast task\n"); 823 824 local_irq_save(flags); 825 netif_addr_lock(dev); 826 spin_lock(&priv->lock); 827 828 /* 829 * Unfortunately, the networking core only gives us a list of all of 830 * the multicast hardware addresses. We need to figure out which ones 831 * are new and which ones have been removed 832 */ 833 834 /* Clear out the found flag */ 835 list_for_each_entry(mcast, &priv->multicast_list, list) 836 clear_bit(IPOIB_MCAST_FLAG_FOUND, &mcast->flags); 837 838 /* Mark all of the entries that are found or don't exist */ 839 netdev_for_each_mc_addr(ha, dev) { 840 union ib_gid mgid; 841 842 if (!ipoib_mcast_addr_is_valid(ha->addr, dev->broadcast)) 843 continue; 844 845 memcpy(mgid.raw, ha->addr + 4, sizeof mgid); 846 847 mcast = __ipoib_mcast_find(dev, &mgid); 848 if (!mcast || test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) { 849 struct ipoib_mcast *nmcast; 850 851 /* ignore group which is directly joined by userspace */ 852 if (test_bit(IPOIB_FLAG_UMCAST, &priv->flags) && 853 !ib_sa_get_mcmember_rec(priv->ca, priv->port, &mgid, &rec)) { 854 ipoib_dbg_mcast(priv, "ignoring multicast entry for mgid %pI6\n", 855 mgid.raw); 856 continue; 857 } 858 859 /* Not found or send-only group, let's add a new entry */ 860 ipoib_dbg_mcast(priv, "adding multicast entry for mgid %pI6\n", 861 mgid.raw); 862 863 nmcast = ipoib_mcast_alloc(dev, 0); 864 if (!nmcast) { 865 ipoib_warn(priv, "unable to allocate memory for multicast structure\n"); 866 continue; 867 } 868 869 set_bit(IPOIB_MCAST_FLAG_FOUND, &nmcast->flags); 870 871 nmcast->mcmember.mgid = mgid; 872 873 if (mcast) { 874 /* Destroy the send only entry */ 875 list_move_tail(&mcast->list, &remove_list); 876 877 rb_replace_node(&mcast->rb_node, 878 &nmcast->rb_node, 879 &priv->multicast_tree); 880 } else 881 __ipoib_mcast_add(dev, nmcast); 882 883 list_add_tail(&nmcast->list, &priv->multicast_list); 884 } 885 886 if (mcast) 887 set_bit(IPOIB_MCAST_FLAG_FOUND, &mcast->flags); 888 } 889 890 /* Remove all of the entries don't exist anymore */ 891 list_for_each_entry_safe(mcast, tmcast, &priv->multicast_list, list) { 892 if (!test_bit(IPOIB_MCAST_FLAG_FOUND, &mcast->flags) && 893 !test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) { 894 ipoib_dbg_mcast(priv, "deleting multicast group %pI6\n", 895 mcast->mcmember.mgid.raw); 896 897 rb_erase(&mcast->rb_node, &priv->multicast_tree); 898 899 /* Move to the remove list */ 900 list_move_tail(&mcast->list, &remove_list); 901 } 902 } 903 904 spin_unlock(&priv->lock); 905 netif_addr_unlock(dev); 906 local_irq_restore(flags); 907 908 /* 909 * make sure the in-flight joins have finished before we attempt 910 * to leave 911 */ 912 list_for_each_entry_safe(mcast, tmcast, &remove_list, list) 913 if (test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags)) 914 wait_for_completion(&mcast->done); 915 916 list_for_each_entry_safe(mcast, tmcast, &remove_list, list) { 917 ipoib_mcast_leave(mcast->dev, mcast); 918 ipoib_mcast_free(mcast); 919 } 920 921 /* 922 * Double check that we are still up 923 */ 924 if (test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) { 925 spin_lock_irqsave(&priv->lock, flags); 926 __ipoib_mcast_schedule_join_thread(priv, NULL, 0); 927 spin_unlock_irqrestore(&priv->lock, flags); 928 } 929} 930 931#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG 932 933struct ipoib_mcast_iter *ipoib_mcast_iter_init(struct net_device *dev) 934{ 935 struct ipoib_mcast_iter *iter; 936 937 iter = kmalloc(sizeof *iter, GFP_KERNEL); 938 if (!iter) 939 return NULL; 940 941 iter->dev = dev; 942 memset(iter->mgid.raw, 0, 16); 943 944 if (ipoib_mcast_iter_next(iter)) { 945 kfree(iter); 946 return NULL; 947 } 948 949 return iter; 950} 951 952int ipoib_mcast_iter_next(struct ipoib_mcast_iter *iter) 953{ 954 struct ipoib_dev_priv *priv = netdev_priv(iter->dev); 955 struct rb_node *n; 956 struct ipoib_mcast *mcast; 957 int ret = 1; 958 959 spin_lock_irq(&priv->lock); 960 961 n = rb_first(&priv->multicast_tree); 962 963 while (n) { 964 mcast = rb_entry(n, struct ipoib_mcast, rb_node); 965 966 if (memcmp(iter->mgid.raw, mcast->mcmember.mgid.raw, 967 sizeof (union ib_gid)) < 0) { 968 iter->mgid = mcast->mcmember.mgid; 969 iter->created = mcast->created; 970 iter->queuelen = skb_queue_len(&mcast->pkt_queue); 971 iter->complete = !!mcast->ah; 972 iter->send_only = !!(mcast->flags & (1 << IPOIB_MCAST_FLAG_SENDONLY)); 973 974 ret = 0; 975 976 break; 977 } 978 979 n = rb_next(n); 980 } 981 982 spin_unlock_irq(&priv->lock); 983 984 return ret; 985} 986 987void ipoib_mcast_iter_read(struct ipoib_mcast_iter *iter, 988 union ib_gid *mgid, 989 unsigned long *created, 990 unsigned int *queuelen, 991 unsigned int *complete, 992 unsigned int *send_only) 993{ 994 *mgid = iter->mgid; 995 *created = iter->created; 996 *queuelen = iter->queuelen; 997 *complete = iter->complete; 998 *send_only = iter->send_only; 999} 1000 1001#endif /* CONFIG_INFINIBAND_IPOIB_DEBUG */ 1002