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 /* 68 * This should be called with the priv->lock held 69 */ 70 static 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 109 static 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 135 static 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 156 static 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 180 static 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 208 static 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 324 void 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 357 static 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 bool silent_fail = 397 test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) && 398 status == -EINVAL; 399 400 if (mcast->logcount < 20) { 401 if (status == -ETIMEDOUT || status == -EAGAIN || 402 silent_fail) { 403 ipoib_dbg_mcast(priv, "%smulticast join failed for %pI6, status %d\n", 404 test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) ? "sendonly " : "", 405 mcast->mcmember.mgid.raw, status); 406 } else { 407 ipoib_warn(priv, "%smulticast join failed for %pI6, status %d\n", 408 test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) ? "sendonly " : "", 409 mcast->mcmember.mgid.raw, status); 410 } 411 412 if (!silent_fail) 413 mcast->logcount++; 414 } 415 416 if (test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) && 417 mcast->backoff >= 2) { 418 /* 419 * We only retry sendonly joins once before we drop 420 * the packet and quit trying to deal with the 421 * group. However, we leave the group in the 422 * mcast list as an unjoined group. If we want to 423 * try joining again, we simply queue up a packet 424 * and restart the join thread. The empty queue 425 * is why the join thread ignores this group. 426 */ 427 mcast->backoff = 1; 428 netif_tx_lock_bh(dev); 429 while (!skb_queue_empty(&mcast->pkt_queue)) { 430 ++dev->stats.tx_dropped; 431 dev_kfree_skb_any(skb_dequeue(&mcast->pkt_queue)); 432 } 433 netif_tx_unlock_bh(dev); 434 } else { 435 spin_lock_irq(&priv->lock); 436 /* Requeue this join task with a backoff delay */ 437 __ipoib_mcast_schedule_join_thread(priv, mcast, 1); 438 goto out_locked; 439 } 440 } 441 out: 442 spin_lock_irq(&priv->lock); 443 out_locked: 444 /* 445 * Make sure to set mcast->mc before we clear the busy flag to avoid 446 * racing with code that checks for BUSY before checking mcast->mc 447 */ 448 if (status) 449 mcast->mc = NULL; 450 else 451 mcast->mc = multicast; 452 clear_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags); 453 spin_unlock_irq(&priv->lock); 454 complete(&mcast->done); 455 456 return status; 457 } 458 459 static void ipoib_mcast_join(struct net_device *dev, struct ipoib_mcast *mcast) 460 { 461 struct ipoib_dev_priv *priv = netdev_priv(dev); 462 struct ib_sa_multicast *multicast; 463 struct ib_sa_mcmember_rec rec = { 464 .join_state = 1 465 }; 466 ib_sa_comp_mask comp_mask; 467 int ret = 0; 468 469 ipoib_dbg_mcast(priv, "joining MGID %pI6\n", mcast->mcmember.mgid.raw); 470 471 rec.mgid = mcast->mcmember.mgid; 472 rec.port_gid = priv->local_gid; 473 rec.pkey = cpu_to_be16(priv->pkey); 474 475 comp_mask = 476 IB_SA_MCMEMBER_REC_MGID | 477 IB_SA_MCMEMBER_REC_PORT_GID | 478 IB_SA_MCMEMBER_REC_PKEY | 479 IB_SA_MCMEMBER_REC_JOIN_STATE; 480 481 if (mcast != priv->broadcast) { 482 /* 483 * RFC 4391: 484 * The MGID MUST use the same P_Key, Q_Key, SL, MTU, 485 * and HopLimit as those used in the broadcast-GID. The rest 486 * of attributes SHOULD follow the values used in the 487 * broadcast-GID as well. 488 */ 489 comp_mask |= 490 IB_SA_MCMEMBER_REC_QKEY | 491 IB_SA_MCMEMBER_REC_MTU_SELECTOR | 492 IB_SA_MCMEMBER_REC_MTU | 493 IB_SA_MCMEMBER_REC_TRAFFIC_CLASS | 494 IB_SA_MCMEMBER_REC_RATE_SELECTOR | 495 IB_SA_MCMEMBER_REC_RATE | 496 IB_SA_MCMEMBER_REC_SL | 497 IB_SA_MCMEMBER_REC_FLOW_LABEL | 498 IB_SA_MCMEMBER_REC_HOP_LIMIT; 499 500 rec.qkey = priv->broadcast->mcmember.qkey; 501 rec.mtu_selector = IB_SA_EQ; 502 rec.mtu = priv->broadcast->mcmember.mtu; 503 rec.traffic_class = priv->broadcast->mcmember.traffic_class; 504 rec.rate_selector = IB_SA_EQ; 505 rec.rate = priv->broadcast->mcmember.rate; 506 rec.sl = priv->broadcast->mcmember.sl; 507 rec.flow_label = priv->broadcast->mcmember.flow_label; 508 rec.hop_limit = priv->broadcast->mcmember.hop_limit; 509 510 /* 511 * Historically Linux IPoIB has never properly supported SEND 512 * ONLY join. It emulated it by not providing all the required 513 * attributes, which is enough to prevent group creation and 514 * detect if there are full members or not. A major problem 515 * with supporting SEND ONLY is detecting when the group is 516 * auto-destroyed as IPoIB will cache the MLID.. 517 */ 518 #if 1 519 if (test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) 520 comp_mask &= ~IB_SA_MCMEMBER_REC_TRAFFIC_CLASS; 521 #else 522 if (test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) 523 rec.join_state = 4; 524 #endif 525 } 526 527 multicast = ib_sa_join_multicast(&ipoib_sa_client, priv->ca, priv->port, 528 &rec, comp_mask, GFP_KERNEL, 529 ipoib_mcast_join_complete, mcast); 530 if (IS_ERR(multicast)) { 531 ret = PTR_ERR(multicast); 532 ipoib_warn(priv, "ib_sa_join_multicast failed, status %d\n", ret); 533 spin_lock_irq(&priv->lock); 534 /* Requeue this join task with a backoff delay */ 535 __ipoib_mcast_schedule_join_thread(priv, mcast, 1); 536 clear_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags); 537 spin_unlock_irq(&priv->lock); 538 complete(&mcast->done); 539 } 540 } 541 542 void ipoib_mcast_join_task(struct work_struct *work) 543 { 544 struct ipoib_dev_priv *priv = 545 container_of(work, struct ipoib_dev_priv, mcast_task.work); 546 struct net_device *dev = priv->dev; 547 struct ib_port_attr port_attr; 548 unsigned long delay_until = 0; 549 struct ipoib_mcast *mcast = NULL; 550 551 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) 552 return; 553 554 if (ib_query_port(priv->ca, priv->port, &port_attr) || 555 port_attr.state != IB_PORT_ACTIVE) { 556 ipoib_dbg(priv, "port state is not ACTIVE (state = %d) suspending join task\n", 557 port_attr.state); 558 return; 559 } 560 priv->local_lid = port_attr.lid; 561 562 if (ib_query_gid(priv->ca, priv->port, 0, &priv->local_gid)) 563 ipoib_warn(priv, "ib_query_gid() failed\n"); 564 else 565 memcpy(priv->dev->dev_addr + 4, priv->local_gid.raw, sizeof (union ib_gid)); 566 567 spin_lock_irq(&priv->lock); 568 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) 569 goto out; 570 571 if (!priv->broadcast) { 572 struct ipoib_mcast *broadcast; 573 574 broadcast = ipoib_mcast_alloc(dev, 0); 575 if (!broadcast) { 576 ipoib_warn(priv, "failed to allocate broadcast group\n"); 577 /* 578 * Restart us after a 1 second delay to retry 579 * creating our broadcast group and attaching to 580 * it. Until this succeeds, this ipoib dev is 581 * completely stalled (multicast wise). 582 */ 583 __ipoib_mcast_schedule_join_thread(priv, NULL, 1); 584 goto out; 585 } 586 587 memcpy(broadcast->mcmember.mgid.raw, priv->dev->broadcast + 4, 588 sizeof (union ib_gid)); 589 priv->broadcast = broadcast; 590 591 __ipoib_mcast_add(dev, priv->broadcast); 592 } 593 594 if (!test_bit(IPOIB_MCAST_FLAG_ATTACHED, &priv->broadcast->flags)) { 595 if (IS_ERR_OR_NULL(priv->broadcast->mc) && 596 !test_bit(IPOIB_MCAST_FLAG_BUSY, &priv->broadcast->flags)) { 597 mcast = priv->broadcast; 598 if (mcast->backoff > 1 && 599 time_before(jiffies, mcast->delay_until)) { 600 delay_until = mcast->delay_until; 601 mcast = NULL; 602 } 603 } 604 goto out; 605 } 606 607 /* 608 * We'll never get here until the broadcast group is both allocated 609 * and attached 610 */ 611 list_for_each_entry(mcast, &priv->multicast_list, list) { 612 if (IS_ERR_OR_NULL(mcast->mc) && 613 !test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags) && 614 (!test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) || 615 !skb_queue_empty(&mcast->pkt_queue))) { 616 if (mcast->backoff == 1 || 617 time_after_eq(jiffies, mcast->delay_until)) { 618 /* Found the next unjoined group */ 619 init_completion(&mcast->done); 620 set_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags); 621 spin_unlock_irq(&priv->lock); 622 ipoib_mcast_join(dev, mcast); 623 spin_lock_irq(&priv->lock); 624 } else if (!delay_until || 625 time_before(mcast->delay_until, delay_until)) 626 delay_until = mcast->delay_until; 627 } 628 } 629 630 mcast = NULL; 631 ipoib_dbg_mcast(priv, "successfully started all multicast joins\n"); 632 633 out: 634 if (delay_until) { 635 cancel_delayed_work(&priv->mcast_task); 636 queue_delayed_work(priv->wq, &priv->mcast_task, 637 delay_until - jiffies); 638 } 639 if (mcast) { 640 init_completion(&mcast->done); 641 set_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags); 642 } 643 spin_unlock_irq(&priv->lock); 644 if (mcast) 645 ipoib_mcast_join(dev, mcast); 646 } 647 648 int ipoib_mcast_start_thread(struct net_device *dev) 649 { 650 struct ipoib_dev_priv *priv = netdev_priv(dev); 651 unsigned long flags; 652 653 ipoib_dbg_mcast(priv, "starting multicast thread\n"); 654 655 spin_lock_irqsave(&priv->lock, flags); 656 __ipoib_mcast_schedule_join_thread(priv, NULL, 0); 657 spin_unlock_irqrestore(&priv->lock, flags); 658 659 return 0; 660 } 661 662 int ipoib_mcast_stop_thread(struct net_device *dev) 663 { 664 struct ipoib_dev_priv *priv = netdev_priv(dev); 665 unsigned long flags; 666 667 ipoib_dbg_mcast(priv, "stopping multicast thread\n"); 668 669 spin_lock_irqsave(&priv->lock, flags); 670 cancel_delayed_work(&priv->mcast_task); 671 spin_unlock_irqrestore(&priv->lock, flags); 672 673 flush_workqueue(priv->wq); 674 675 return 0; 676 } 677 678 static int ipoib_mcast_leave(struct net_device *dev, struct ipoib_mcast *mcast) 679 { 680 struct ipoib_dev_priv *priv = netdev_priv(dev); 681 int ret = 0; 682 683 if (test_and_clear_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags)) 684 ipoib_warn(priv, "ipoib_mcast_leave on an in-flight join\n"); 685 686 if (!IS_ERR_OR_NULL(mcast->mc)) 687 ib_sa_free_multicast(mcast->mc); 688 689 if (test_and_clear_bit(IPOIB_MCAST_FLAG_ATTACHED, &mcast->flags)) { 690 ipoib_dbg_mcast(priv, "leaving MGID %pI6\n", 691 mcast->mcmember.mgid.raw); 692 693 /* Remove ourselves from the multicast group */ 694 ret = ib_detach_mcast(priv->qp, &mcast->mcmember.mgid, 695 be16_to_cpu(mcast->mcmember.mlid)); 696 if (ret) 697 ipoib_warn(priv, "ib_detach_mcast failed (result = %d)\n", ret); 698 } else if (!test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) 699 ipoib_dbg(priv, "leaving with no mcmember but not a " 700 "SENDONLY join\n"); 701 702 return 0; 703 } 704 705 void ipoib_mcast_send(struct net_device *dev, u8 *daddr, struct sk_buff *skb) 706 { 707 struct ipoib_dev_priv *priv = netdev_priv(dev); 708 struct ipoib_mcast *mcast; 709 unsigned long flags; 710 void *mgid = daddr + 4; 711 712 spin_lock_irqsave(&priv->lock, flags); 713 714 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags) || 715 !priv->broadcast || 716 !test_bit(IPOIB_MCAST_FLAG_ATTACHED, &priv->broadcast->flags)) { 717 ++dev->stats.tx_dropped; 718 dev_kfree_skb_any(skb); 719 goto unlock; 720 } 721 722 mcast = __ipoib_mcast_find(dev, mgid); 723 if (!mcast || !mcast->ah) { 724 if (!mcast) { 725 /* Let's create a new send only group now */ 726 ipoib_dbg_mcast(priv, "setting up send only multicast group for %pI6\n", 727 mgid); 728 729 mcast = ipoib_mcast_alloc(dev, 0); 730 if (!mcast) { 731 ipoib_warn(priv, "unable to allocate memory " 732 "for multicast structure\n"); 733 ++dev->stats.tx_dropped; 734 dev_kfree_skb_any(skb); 735 goto unlock; 736 } 737 738 set_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags); 739 memcpy(mcast->mcmember.mgid.raw, mgid, 740 sizeof (union ib_gid)); 741 __ipoib_mcast_add(dev, mcast); 742 list_add_tail(&mcast->list, &priv->multicast_list); 743 } 744 if (skb_queue_len(&mcast->pkt_queue) < IPOIB_MAX_MCAST_QUEUE) 745 skb_queue_tail(&mcast->pkt_queue, skb); 746 else { 747 ++dev->stats.tx_dropped; 748 dev_kfree_skb_any(skb); 749 } 750 if (!test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags)) { 751 __ipoib_mcast_schedule_join_thread(priv, NULL, 0); 752 } 753 } else { 754 struct ipoib_neigh *neigh; 755 756 spin_unlock_irqrestore(&priv->lock, flags); 757 neigh = ipoib_neigh_get(dev, daddr); 758 spin_lock_irqsave(&priv->lock, flags); 759 if (!neigh) { 760 neigh = ipoib_neigh_alloc(daddr, dev); 761 if (neigh) { 762 kref_get(&mcast->ah->ref); 763 neigh->ah = mcast->ah; 764 list_add_tail(&neigh->list, &mcast->neigh_list); 765 } 766 } 767 spin_unlock_irqrestore(&priv->lock, flags); 768 ipoib_send(dev, skb, mcast->ah, IB_MULTICAST_QPN); 769 if (neigh) 770 ipoib_neigh_put(neigh); 771 return; 772 } 773 774 unlock: 775 spin_unlock_irqrestore(&priv->lock, flags); 776 } 777 778 void ipoib_mcast_dev_flush(struct net_device *dev) 779 { 780 struct ipoib_dev_priv *priv = netdev_priv(dev); 781 LIST_HEAD(remove_list); 782 struct ipoib_mcast *mcast, *tmcast; 783 unsigned long flags; 784 785 ipoib_dbg_mcast(priv, "flushing multicast list\n"); 786 787 spin_lock_irqsave(&priv->lock, flags); 788 789 list_for_each_entry_safe(mcast, tmcast, &priv->multicast_list, list) { 790 list_del(&mcast->list); 791 rb_erase(&mcast->rb_node, &priv->multicast_tree); 792 list_add_tail(&mcast->list, &remove_list); 793 } 794 795 if (priv->broadcast) { 796 rb_erase(&priv->broadcast->rb_node, &priv->multicast_tree); 797 list_add_tail(&priv->broadcast->list, &remove_list); 798 priv->broadcast = NULL; 799 } 800 801 spin_unlock_irqrestore(&priv->lock, flags); 802 803 /* 804 * make sure the in-flight joins have finished before we attempt 805 * to leave 806 */ 807 list_for_each_entry_safe(mcast, tmcast, &remove_list, list) 808 if (test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags)) 809 wait_for_completion(&mcast->done); 810 811 list_for_each_entry_safe(mcast, tmcast, &remove_list, list) { 812 ipoib_mcast_leave(dev, mcast); 813 ipoib_mcast_free(mcast); 814 } 815 } 816 817 static int ipoib_mcast_addr_is_valid(const u8 *addr, const u8 *broadcast) 818 { 819 /* reserved QPN, prefix, scope */ 820 if (memcmp(addr, broadcast, 6)) 821 return 0; 822 /* signature lower, pkey */ 823 if (memcmp(addr + 7, broadcast + 7, 3)) 824 return 0; 825 return 1; 826 } 827 828 void ipoib_mcast_restart_task(struct work_struct *work) 829 { 830 struct ipoib_dev_priv *priv = 831 container_of(work, struct ipoib_dev_priv, restart_task); 832 struct net_device *dev = priv->dev; 833 struct netdev_hw_addr *ha; 834 struct ipoib_mcast *mcast, *tmcast; 835 LIST_HEAD(remove_list); 836 unsigned long flags; 837 struct ib_sa_mcmember_rec rec; 838 839 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) 840 /* 841 * shortcut...on shutdown flush is called next, just 842 * let it do all the work 843 */ 844 return; 845 846 ipoib_dbg_mcast(priv, "restarting multicast task\n"); 847 848 local_irq_save(flags); 849 netif_addr_lock(dev); 850 spin_lock(&priv->lock); 851 852 /* 853 * Unfortunately, the networking core only gives us a list of all of 854 * the multicast hardware addresses. We need to figure out which ones 855 * are new and which ones have been removed 856 */ 857 858 /* Clear out the found flag */ 859 list_for_each_entry(mcast, &priv->multicast_list, list) 860 clear_bit(IPOIB_MCAST_FLAG_FOUND, &mcast->flags); 861 862 /* Mark all of the entries that are found or don't exist */ 863 netdev_for_each_mc_addr(ha, dev) { 864 union ib_gid mgid; 865 866 if (!ipoib_mcast_addr_is_valid(ha->addr, dev->broadcast)) 867 continue; 868 869 memcpy(mgid.raw, ha->addr + 4, sizeof mgid); 870 871 mcast = __ipoib_mcast_find(dev, &mgid); 872 if (!mcast || test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) { 873 struct ipoib_mcast *nmcast; 874 875 /* ignore group which is directly joined by userspace */ 876 if (test_bit(IPOIB_FLAG_UMCAST, &priv->flags) && 877 !ib_sa_get_mcmember_rec(priv->ca, priv->port, &mgid, &rec)) { 878 ipoib_dbg_mcast(priv, "ignoring multicast entry for mgid %pI6\n", 879 mgid.raw); 880 continue; 881 } 882 883 /* Not found or send-only group, let's add a new entry */ 884 ipoib_dbg_mcast(priv, "adding multicast entry for mgid %pI6\n", 885 mgid.raw); 886 887 nmcast = ipoib_mcast_alloc(dev, 0); 888 if (!nmcast) { 889 ipoib_warn(priv, "unable to allocate memory for multicast structure\n"); 890 continue; 891 } 892 893 set_bit(IPOIB_MCAST_FLAG_FOUND, &nmcast->flags); 894 895 nmcast->mcmember.mgid = mgid; 896 897 if (mcast) { 898 /* Destroy the send only entry */ 899 list_move_tail(&mcast->list, &remove_list); 900 901 rb_replace_node(&mcast->rb_node, 902 &nmcast->rb_node, 903 &priv->multicast_tree); 904 } else 905 __ipoib_mcast_add(dev, nmcast); 906 907 list_add_tail(&nmcast->list, &priv->multicast_list); 908 } 909 910 if (mcast) 911 set_bit(IPOIB_MCAST_FLAG_FOUND, &mcast->flags); 912 } 913 914 /* Remove all of the entries don't exist anymore */ 915 list_for_each_entry_safe(mcast, tmcast, &priv->multicast_list, list) { 916 if (!test_bit(IPOIB_MCAST_FLAG_FOUND, &mcast->flags) && 917 !test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) { 918 ipoib_dbg_mcast(priv, "deleting multicast group %pI6\n", 919 mcast->mcmember.mgid.raw); 920 921 rb_erase(&mcast->rb_node, &priv->multicast_tree); 922 923 /* Move to the remove list */ 924 list_move_tail(&mcast->list, &remove_list); 925 } 926 } 927 928 spin_unlock(&priv->lock); 929 netif_addr_unlock(dev); 930 local_irq_restore(flags); 931 932 /* 933 * make sure the in-flight joins have finished before we attempt 934 * to leave 935 */ 936 list_for_each_entry_safe(mcast, tmcast, &remove_list, list) 937 if (test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags)) 938 wait_for_completion(&mcast->done); 939 940 list_for_each_entry_safe(mcast, tmcast, &remove_list, list) { 941 ipoib_mcast_leave(mcast->dev, mcast); 942 ipoib_mcast_free(mcast); 943 } 944 945 /* 946 * Double check that we are still up 947 */ 948 if (test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) { 949 spin_lock_irqsave(&priv->lock, flags); 950 __ipoib_mcast_schedule_join_thread(priv, NULL, 0); 951 spin_unlock_irqrestore(&priv->lock, flags); 952 } 953 } 954 955 #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG 956 957 struct ipoib_mcast_iter *ipoib_mcast_iter_init(struct net_device *dev) 958 { 959 struct ipoib_mcast_iter *iter; 960 961 iter = kmalloc(sizeof *iter, GFP_KERNEL); 962 if (!iter) 963 return NULL; 964 965 iter->dev = dev; 966 memset(iter->mgid.raw, 0, 16); 967 968 if (ipoib_mcast_iter_next(iter)) { 969 kfree(iter); 970 return NULL; 971 } 972 973 return iter; 974 } 975 976 int ipoib_mcast_iter_next(struct ipoib_mcast_iter *iter) 977 { 978 struct ipoib_dev_priv *priv = netdev_priv(iter->dev); 979 struct rb_node *n; 980 struct ipoib_mcast *mcast; 981 int ret = 1; 982 983 spin_lock_irq(&priv->lock); 984 985 n = rb_first(&priv->multicast_tree); 986 987 while (n) { 988 mcast = rb_entry(n, struct ipoib_mcast, rb_node); 989 990 if (memcmp(iter->mgid.raw, mcast->mcmember.mgid.raw, 991 sizeof (union ib_gid)) < 0) { 992 iter->mgid = mcast->mcmember.mgid; 993 iter->created = mcast->created; 994 iter->queuelen = skb_queue_len(&mcast->pkt_queue); 995 iter->complete = !!mcast->ah; 996 iter->send_only = !!(mcast->flags & (1 << IPOIB_MCAST_FLAG_SENDONLY)); 997 998 ret = 0; 999 1000 break; 1001 } 1002 1003 n = rb_next(n); 1004 } 1005 1006 spin_unlock_irq(&priv->lock); 1007 1008 return ret; 1009 } 1010 1011 void ipoib_mcast_iter_read(struct ipoib_mcast_iter *iter, 1012 union ib_gid *mgid, 1013 unsigned long *created, 1014 unsigned int *queuelen, 1015 unsigned int *complete, 1016 unsigned int *send_only) 1017 { 1018 *mgid = iter->mgid; 1019 *created = iter->created; 1020 *queuelen = iter->queuelen; 1021 *complete = iter->complete; 1022 *send_only = iter->send_only; 1023 } 1024 1025 #endif /* CONFIG_INFINIBAND_IPOIB_DEBUG */ 1026