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.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 * Send-only IB Multicast joins do not work at the core 512 * IB layer yet, so we can't use them here. However, 513 * we are emulating an Ethernet multicast send, which 514 * does not require a multicast subscription and will 515 * still send properly. The most appropriate thing to 516 * do is to create the group if it doesn't exist as that 517 * most closely emulates the behavior, from a user space 518 * application perspecitive, of Ethernet multicast 519 * operation. For now, we do a full join, maybe later 520 * when the core IB layers support send only joins we 521 * will use them. 522 */ 523 #if 0 524 if (test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) 525 rec.join_state = 4; 526 #endif 527 } 528 529 multicast = ib_sa_join_multicast(&ipoib_sa_client, priv->ca, priv->port, 530 &rec, comp_mask, GFP_KERNEL, 531 ipoib_mcast_join_complete, mcast); 532 if (IS_ERR(multicast)) { 533 ret = PTR_ERR(multicast); 534 ipoib_warn(priv, "ib_sa_join_multicast failed, status %d\n", ret); 535 spin_lock_irq(&priv->lock); 536 /* Requeue this join task with a backoff delay */ 537 __ipoib_mcast_schedule_join_thread(priv, mcast, 1); 538 clear_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags); 539 spin_unlock_irq(&priv->lock); 540 complete(&mcast->done); 541 } 542 } 543 544 void ipoib_mcast_join_task(struct work_struct *work) 545 { 546 struct ipoib_dev_priv *priv = 547 container_of(work, struct ipoib_dev_priv, mcast_task.work); 548 struct net_device *dev = priv->dev; 549 struct ib_port_attr port_attr; 550 unsigned long delay_until = 0; 551 struct ipoib_mcast *mcast = NULL; 552 553 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) 554 return; 555 556 if (ib_query_port(priv->ca, priv->port, &port_attr) || 557 port_attr.state != IB_PORT_ACTIVE) { 558 ipoib_dbg(priv, "port state is not ACTIVE (state = %d) suspending join task\n", 559 port_attr.state); 560 return; 561 } 562 priv->local_lid = port_attr.lid; 563 564 if (ib_query_gid(priv->ca, priv->port, 0, &priv->local_gid, NULL)) 565 ipoib_warn(priv, "ib_query_gid() failed\n"); 566 else 567 memcpy(priv->dev->dev_addr + 4, priv->local_gid.raw, sizeof (union ib_gid)); 568 569 spin_lock_irq(&priv->lock); 570 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) 571 goto out; 572 573 if (!priv->broadcast) { 574 struct ipoib_mcast *broadcast; 575 576 broadcast = ipoib_mcast_alloc(dev, 0); 577 if (!broadcast) { 578 ipoib_warn(priv, "failed to allocate broadcast group\n"); 579 /* 580 * Restart us after a 1 second delay to retry 581 * creating our broadcast group and attaching to 582 * it. Until this succeeds, this ipoib dev is 583 * completely stalled (multicast wise). 584 */ 585 __ipoib_mcast_schedule_join_thread(priv, NULL, 1); 586 goto out; 587 } 588 589 memcpy(broadcast->mcmember.mgid.raw, priv->dev->broadcast + 4, 590 sizeof (union ib_gid)); 591 priv->broadcast = broadcast; 592 593 __ipoib_mcast_add(dev, priv->broadcast); 594 } 595 596 if (!test_bit(IPOIB_MCAST_FLAG_ATTACHED, &priv->broadcast->flags)) { 597 if (IS_ERR_OR_NULL(priv->broadcast->mc) && 598 !test_bit(IPOIB_MCAST_FLAG_BUSY, &priv->broadcast->flags)) { 599 mcast = priv->broadcast; 600 if (mcast->backoff > 1 && 601 time_before(jiffies, mcast->delay_until)) { 602 delay_until = mcast->delay_until; 603 mcast = NULL; 604 } 605 } 606 goto out; 607 } 608 609 /* 610 * We'll never get here until the broadcast group is both allocated 611 * and attached 612 */ 613 list_for_each_entry(mcast, &priv->multicast_list, list) { 614 if (IS_ERR_OR_NULL(mcast->mc) && 615 !test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags) && 616 (!test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags) || 617 !skb_queue_empty(&mcast->pkt_queue))) { 618 if (mcast->backoff == 1 || 619 time_after_eq(jiffies, mcast->delay_until)) { 620 /* Found the next unjoined group */ 621 init_completion(&mcast->done); 622 set_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags); 623 spin_unlock_irq(&priv->lock); 624 ipoib_mcast_join(dev, mcast); 625 spin_lock_irq(&priv->lock); 626 } else if (!delay_until || 627 time_before(mcast->delay_until, delay_until)) 628 delay_until = mcast->delay_until; 629 } 630 } 631 632 mcast = NULL; 633 ipoib_dbg_mcast(priv, "successfully started all multicast joins\n"); 634 635 out: 636 if (delay_until) { 637 cancel_delayed_work(&priv->mcast_task); 638 queue_delayed_work(priv->wq, &priv->mcast_task, 639 delay_until - jiffies); 640 } 641 if (mcast) { 642 init_completion(&mcast->done); 643 set_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags); 644 } 645 spin_unlock_irq(&priv->lock); 646 if (mcast) 647 ipoib_mcast_join(dev, mcast); 648 } 649 650 int ipoib_mcast_start_thread(struct net_device *dev) 651 { 652 struct ipoib_dev_priv *priv = netdev_priv(dev); 653 unsigned long flags; 654 655 ipoib_dbg_mcast(priv, "starting multicast thread\n"); 656 657 spin_lock_irqsave(&priv->lock, flags); 658 __ipoib_mcast_schedule_join_thread(priv, NULL, 0); 659 spin_unlock_irqrestore(&priv->lock, flags); 660 661 return 0; 662 } 663 664 int ipoib_mcast_stop_thread(struct net_device *dev) 665 { 666 struct ipoib_dev_priv *priv = netdev_priv(dev); 667 unsigned long flags; 668 669 ipoib_dbg_mcast(priv, "stopping multicast thread\n"); 670 671 spin_lock_irqsave(&priv->lock, flags); 672 cancel_delayed_work(&priv->mcast_task); 673 spin_unlock_irqrestore(&priv->lock, flags); 674 675 flush_workqueue(priv->wq); 676 677 return 0; 678 } 679 680 static int ipoib_mcast_leave(struct net_device *dev, struct ipoib_mcast *mcast) 681 { 682 struct ipoib_dev_priv *priv = netdev_priv(dev); 683 int ret = 0; 684 685 if (test_and_clear_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags)) 686 ipoib_warn(priv, "ipoib_mcast_leave on an in-flight join\n"); 687 688 if (!IS_ERR_OR_NULL(mcast->mc)) 689 ib_sa_free_multicast(mcast->mc); 690 691 if (test_and_clear_bit(IPOIB_MCAST_FLAG_ATTACHED, &mcast->flags)) { 692 ipoib_dbg_mcast(priv, "leaving MGID %pI6\n", 693 mcast->mcmember.mgid.raw); 694 695 /* Remove ourselves from the multicast group */ 696 ret = ib_detach_mcast(priv->qp, &mcast->mcmember.mgid, 697 be16_to_cpu(mcast->mcmember.mlid)); 698 if (ret) 699 ipoib_warn(priv, "ib_detach_mcast failed (result = %d)\n", ret); 700 } else if (!test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) 701 ipoib_dbg(priv, "leaving with no mcmember but not a " 702 "SENDONLY join\n"); 703 704 return 0; 705 } 706 707 /* 708 * Check if the multicast group is sendonly. If so remove it from the maps 709 * and add to the remove list 710 */ 711 void ipoib_check_and_add_mcast_sendonly(struct ipoib_dev_priv *priv, u8 *mgid, 712 struct list_head *remove_list) 713 { 714 /* Is this multicast ? */ 715 if (*mgid == 0xff) { 716 struct ipoib_mcast *mcast = __ipoib_mcast_find(priv->dev, mgid); 717 718 if (mcast && test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) { 719 list_del(&mcast->list); 720 rb_erase(&mcast->rb_node, &priv->multicast_tree); 721 list_add_tail(&mcast->list, remove_list); 722 } 723 } 724 } 725 726 void ipoib_mcast_remove_list(struct list_head *remove_list) 727 { 728 struct ipoib_mcast *mcast, *tmcast; 729 730 list_for_each_entry_safe(mcast, tmcast, remove_list, list) { 731 ipoib_mcast_leave(mcast->dev, mcast); 732 ipoib_mcast_free(mcast); 733 } 734 } 735 736 void ipoib_mcast_send(struct net_device *dev, u8 *daddr, struct sk_buff *skb) 737 { 738 struct ipoib_dev_priv *priv = netdev_priv(dev); 739 struct ipoib_mcast *mcast; 740 unsigned long flags; 741 void *mgid = daddr + 4; 742 743 spin_lock_irqsave(&priv->lock, flags); 744 745 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags) || 746 !priv->broadcast || 747 !test_bit(IPOIB_MCAST_FLAG_ATTACHED, &priv->broadcast->flags)) { 748 ++dev->stats.tx_dropped; 749 dev_kfree_skb_any(skb); 750 goto unlock; 751 } 752 753 mcast = __ipoib_mcast_find(dev, mgid); 754 if (!mcast || !mcast->ah) { 755 if (!mcast) { 756 /* Let's create a new send only group now */ 757 ipoib_dbg_mcast(priv, "setting up send only multicast group for %pI6\n", 758 mgid); 759 760 mcast = ipoib_mcast_alloc(dev, 0); 761 if (!mcast) { 762 ipoib_warn(priv, "unable to allocate memory " 763 "for multicast structure\n"); 764 ++dev->stats.tx_dropped; 765 dev_kfree_skb_any(skb); 766 goto unlock; 767 } 768 769 set_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags); 770 memcpy(mcast->mcmember.mgid.raw, mgid, 771 sizeof (union ib_gid)); 772 __ipoib_mcast_add(dev, mcast); 773 list_add_tail(&mcast->list, &priv->multicast_list); 774 } 775 if (skb_queue_len(&mcast->pkt_queue) < IPOIB_MAX_MCAST_QUEUE) 776 skb_queue_tail(&mcast->pkt_queue, skb); 777 else { 778 ++dev->stats.tx_dropped; 779 dev_kfree_skb_any(skb); 780 } 781 if (!test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags)) { 782 __ipoib_mcast_schedule_join_thread(priv, NULL, 0); 783 } 784 } else { 785 struct ipoib_neigh *neigh; 786 787 spin_unlock_irqrestore(&priv->lock, flags); 788 neigh = ipoib_neigh_get(dev, daddr); 789 spin_lock_irqsave(&priv->lock, flags); 790 if (!neigh) { 791 neigh = ipoib_neigh_alloc(daddr, dev); 792 if (neigh) { 793 kref_get(&mcast->ah->ref); 794 neigh->ah = mcast->ah; 795 list_add_tail(&neigh->list, &mcast->neigh_list); 796 } 797 } 798 spin_unlock_irqrestore(&priv->lock, flags); 799 ipoib_send(dev, skb, mcast->ah, IB_MULTICAST_QPN); 800 if (neigh) 801 ipoib_neigh_put(neigh); 802 return; 803 } 804 805 unlock: 806 spin_unlock_irqrestore(&priv->lock, flags); 807 } 808 809 void ipoib_mcast_dev_flush(struct net_device *dev) 810 { 811 struct ipoib_dev_priv *priv = netdev_priv(dev); 812 LIST_HEAD(remove_list); 813 struct ipoib_mcast *mcast, *tmcast; 814 unsigned long flags; 815 816 ipoib_dbg_mcast(priv, "flushing multicast list\n"); 817 818 spin_lock_irqsave(&priv->lock, flags); 819 820 list_for_each_entry_safe(mcast, tmcast, &priv->multicast_list, list) { 821 list_del(&mcast->list); 822 rb_erase(&mcast->rb_node, &priv->multicast_tree); 823 list_add_tail(&mcast->list, &remove_list); 824 } 825 826 if (priv->broadcast) { 827 rb_erase(&priv->broadcast->rb_node, &priv->multicast_tree); 828 list_add_tail(&priv->broadcast->list, &remove_list); 829 priv->broadcast = NULL; 830 } 831 832 spin_unlock_irqrestore(&priv->lock, flags); 833 834 /* 835 * make sure the in-flight joins have finished before we attempt 836 * to leave 837 */ 838 list_for_each_entry_safe(mcast, tmcast, &remove_list, list) 839 if (test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags)) 840 wait_for_completion(&mcast->done); 841 842 ipoib_mcast_remove_list(&remove_list); 843 } 844 845 static int ipoib_mcast_addr_is_valid(const u8 *addr, const u8 *broadcast) 846 { 847 /* reserved QPN, prefix, scope */ 848 if (memcmp(addr, broadcast, 6)) 849 return 0; 850 /* signature lower, pkey */ 851 if (memcmp(addr + 7, broadcast + 7, 3)) 852 return 0; 853 return 1; 854 } 855 856 void ipoib_mcast_restart_task(struct work_struct *work) 857 { 858 struct ipoib_dev_priv *priv = 859 container_of(work, struct ipoib_dev_priv, restart_task); 860 struct net_device *dev = priv->dev; 861 struct netdev_hw_addr *ha; 862 struct ipoib_mcast *mcast, *tmcast; 863 LIST_HEAD(remove_list); 864 unsigned long flags; 865 struct ib_sa_mcmember_rec rec; 866 867 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) 868 /* 869 * shortcut...on shutdown flush is called next, just 870 * let it do all the work 871 */ 872 return; 873 874 ipoib_dbg_mcast(priv, "restarting multicast task\n"); 875 876 local_irq_save(flags); 877 netif_addr_lock(dev); 878 spin_lock(&priv->lock); 879 880 /* 881 * Unfortunately, the networking core only gives us a list of all of 882 * the multicast hardware addresses. We need to figure out which ones 883 * are new and which ones have been removed 884 */ 885 886 /* Clear out the found flag */ 887 list_for_each_entry(mcast, &priv->multicast_list, list) 888 clear_bit(IPOIB_MCAST_FLAG_FOUND, &mcast->flags); 889 890 /* Mark all of the entries that are found or don't exist */ 891 netdev_for_each_mc_addr(ha, dev) { 892 union ib_gid mgid; 893 894 if (!ipoib_mcast_addr_is_valid(ha->addr, dev->broadcast)) 895 continue; 896 897 memcpy(mgid.raw, ha->addr + 4, sizeof mgid); 898 899 mcast = __ipoib_mcast_find(dev, &mgid); 900 if (!mcast || test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) { 901 struct ipoib_mcast *nmcast; 902 903 /* ignore group which is directly joined by userspace */ 904 if (test_bit(IPOIB_FLAG_UMCAST, &priv->flags) && 905 !ib_sa_get_mcmember_rec(priv->ca, priv->port, &mgid, &rec)) { 906 ipoib_dbg_mcast(priv, "ignoring multicast entry for mgid %pI6\n", 907 mgid.raw); 908 continue; 909 } 910 911 /* Not found or send-only group, let's add a new entry */ 912 ipoib_dbg_mcast(priv, "adding multicast entry for mgid %pI6\n", 913 mgid.raw); 914 915 nmcast = ipoib_mcast_alloc(dev, 0); 916 if (!nmcast) { 917 ipoib_warn(priv, "unable to allocate memory for multicast structure\n"); 918 continue; 919 } 920 921 set_bit(IPOIB_MCAST_FLAG_FOUND, &nmcast->flags); 922 923 nmcast->mcmember.mgid = mgid; 924 925 if (mcast) { 926 /* Destroy the send only entry */ 927 list_move_tail(&mcast->list, &remove_list); 928 929 rb_replace_node(&mcast->rb_node, 930 &nmcast->rb_node, 931 &priv->multicast_tree); 932 } else 933 __ipoib_mcast_add(dev, nmcast); 934 935 list_add_tail(&nmcast->list, &priv->multicast_list); 936 } 937 938 if (mcast) 939 set_bit(IPOIB_MCAST_FLAG_FOUND, &mcast->flags); 940 } 941 942 /* Remove all of the entries don't exist anymore */ 943 list_for_each_entry_safe(mcast, tmcast, &priv->multicast_list, list) { 944 if (!test_bit(IPOIB_MCAST_FLAG_FOUND, &mcast->flags) && 945 !test_bit(IPOIB_MCAST_FLAG_SENDONLY, &mcast->flags)) { 946 ipoib_dbg_mcast(priv, "deleting multicast group %pI6\n", 947 mcast->mcmember.mgid.raw); 948 949 rb_erase(&mcast->rb_node, &priv->multicast_tree); 950 951 /* Move to the remove list */ 952 list_move_tail(&mcast->list, &remove_list); 953 } 954 } 955 956 spin_unlock(&priv->lock); 957 netif_addr_unlock(dev); 958 local_irq_restore(flags); 959 960 /* 961 * make sure the in-flight joins have finished before we attempt 962 * to leave 963 */ 964 list_for_each_entry_safe(mcast, tmcast, &remove_list, list) 965 if (test_bit(IPOIB_MCAST_FLAG_BUSY, &mcast->flags)) 966 wait_for_completion(&mcast->done); 967 968 ipoib_mcast_remove_list(&remove_list); 969 970 /* 971 * Double check that we are still up 972 */ 973 if (test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) { 974 spin_lock_irqsave(&priv->lock, flags); 975 __ipoib_mcast_schedule_join_thread(priv, NULL, 0); 976 spin_unlock_irqrestore(&priv->lock, flags); 977 } 978 } 979 980 #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG 981 982 struct ipoib_mcast_iter *ipoib_mcast_iter_init(struct net_device *dev) 983 { 984 struct ipoib_mcast_iter *iter; 985 986 iter = kmalloc(sizeof *iter, GFP_KERNEL); 987 if (!iter) 988 return NULL; 989 990 iter->dev = dev; 991 memset(iter->mgid.raw, 0, 16); 992 993 if (ipoib_mcast_iter_next(iter)) { 994 kfree(iter); 995 return NULL; 996 } 997 998 return iter; 999 } 1000 1001 int ipoib_mcast_iter_next(struct ipoib_mcast_iter *iter) 1002 { 1003 struct ipoib_dev_priv *priv = netdev_priv(iter->dev); 1004 struct rb_node *n; 1005 struct ipoib_mcast *mcast; 1006 int ret = 1; 1007 1008 spin_lock_irq(&priv->lock); 1009 1010 n = rb_first(&priv->multicast_tree); 1011 1012 while (n) { 1013 mcast = rb_entry(n, struct ipoib_mcast, rb_node); 1014 1015 if (memcmp(iter->mgid.raw, mcast->mcmember.mgid.raw, 1016 sizeof (union ib_gid)) < 0) { 1017 iter->mgid = mcast->mcmember.mgid; 1018 iter->created = mcast->created; 1019 iter->queuelen = skb_queue_len(&mcast->pkt_queue); 1020 iter->complete = !!mcast->ah; 1021 iter->send_only = !!(mcast->flags & (1 << IPOIB_MCAST_FLAG_SENDONLY)); 1022 1023 ret = 0; 1024 1025 break; 1026 } 1027 1028 n = rb_next(n); 1029 } 1030 1031 spin_unlock_irq(&priv->lock); 1032 1033 return ret; 1034 } 1035 1036 void ipoib_mcast_iter_read(struct ipoib_mcast_iter *iter, 1037 union ib_gid *mgid, 1038 unsigned long *created, 1039 unsigned int *queuelen, 1040 unsigned int *complete, 1041 unsigned int *send_only) 1042 { 1043 *mgid = iter->mgid; 1044 *created = iter->created; 1045 *queuelen = iter->queuelen; 1046 *complete = iter->complete; 1047 *send_only = iter->send_only; 1048 } 1049 1050 #endif /* CONFIG_INFINIBAND_IPOIB_DEBUG */ 1051