1 /* 2 * Copyright (c) 2004 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 "ipoib.h" 36 37 #include <linux/module.h> 38 39 #include <linux/init.h> 40 #include <linux/slab.h> 41 #include <linux/kernel.h> 42 #include <linux/vmalloc.h> 43 44 #include <linux/if_arp.h> /* For ARPHRD_xxx */ 45 46 #include <linux/ip.h> 47 #include <linux/in.h> 48 49 #include <linux/jhash.h> 50 #include <net/arp.h> 51 #include <net/addrconf.h> 52 #include <linux/inetdevice.h> 53 #include <rdma/ib_cache.h> 54 #include <linux/pci.h> 55 56 #define DRV_VERSION "1.0.0" 57 58 const char ipoib_driver_version[] = DRV_VERSION; 59 60 MODULE_AUTHOR("Roland Dreier"); 61 MODULE_DESCRIPTION("IP-over-InfiniBand net driver"); 62 MODULE_LICENSE("Dual BSD/GPL"); 63 MODULE_VERSION(DRV_VERSION); 64 65 int ipoib_sendq_size __read_mostly = IPOIB_TX_RING_SIZE; 66 int ipoib_recvq_size __read_mostly = IPOIB_RX_RING_SIZE; 67 68 module_param_named(send_queue_size, ipoib_sendq_size, int, 0444); 69 MODULE_PARM_DESC(send_queue_size, "Number of descriptors in send queue"); 70 module_param_named(recv_queue_size, ipoib_recvq_size, int, 0444); 71 MODULE_PARM_DESC(recv_queue_size, "Number of descriptors in receive queue"); 72 73 #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG 74 int ipoib_debug_level; 75 76 module_param_named(debug_level, ipoib_debug_level, int, 0644); 77 MODULE_PARM_DESC(debug_level, "Enable debug tracing if > 0"); 78 #endif 79 80 struct ipoib_path_iter { 81 struct net_device *dev; 82 struct ipoib_path path; 83 }; 84 85 static const u8 ipv4_bcast_addr[] = { 86 0x00, 0xff, 0xff, 0xff, 87 0xff, 0x12, 0x40, 0x1b, 0x00, 0x00, 0x00, 0x00, 88 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff 89 }; 90 91 struct workqueue_struct *ipoib_workqueue; 92 93 struct ib_sa_client ipoib_sa_client; 94 95 static void ipoib_add_one(struct ib_device *device); 96 static void ipoib_remove_one(struct ib_device *device, void *client_data); 97 static void ipoib_neigh_reclaim(struct rcu_head *rp); 98 static struct net_device *ipoib_get_net_dev_by_params( 99 struct ib_device *dev, u8 port, u16 pkey, 100 const union ib_gid *gid, const struct sockaddr *addr, 101 void *client_data); 102 static int ipoib_set_mac(struct net_device *dev, void *addr); 103 104 static struct ib_client ipoib_client = { 105 .name = "ipoib", 106 .add = ipoib_add_one, 107 .remove = ipoib_remove_one, 108 .get_net_dev_by_params = ipoib_get_net_dev_by_params, 109 }; 110 111 #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG 112 static int ipoib_netdev_event(struct notifier_block *this, 113 unsigned long event, void *ptr) 114 { 115 struct netdev_notifier_info *ni = ptr; 116 struct net_device *dev = ni->dev; 117 118 if (dev->netdev_ops->ndo_open != ipoib_open) 119 return NOTIFY_DONE; 120 121 switch (event) { 122 case NETDEV_REGISTER: 123 ipoib_create_debug_files(dev); 124 break; 125 case NETDEV_CHANGENAME: 126 ipoib_delete_debug_files(dev); 127 ipoib_create_debug_files(dev); 128 break; 129 case NETDEV_UNREGISTER: 130 ipoib_delete_debug_files(dev); 131 break; 132 } 133 134 return NOTIFY_DONE; 135 } 136 #endif 137 138 int ipoib_open(struct net_device *dev) 139 { 140 struct ipoib_dev_priv *priv = netdev_priv(dev); 141 142 ipoib_dbg(priv, "bringing up interface\n"); 143 144 netif_carrier_off(dev); 145 146 set_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags); 147 148 priv->sm_fullmember_sendonly_support = false; 149 150 if (ipoib_ib_dev_open(dev)) { 151 if (!test_bit(IPOIB_PKEY_ASSIGNED, &priv->flags)) 152 return 0; 153 goto err_disable; 154 } 155 156 ipoib_ib_dev_up(dev); 157 158 if (!test_bit(IPOIB_FLAG_SUBINTERFACE, &priv->flags)) { 159 struct ipoib_dev_priv *cpriv; 160 161 /* Bring up any child interfaces too */ 162 down_read(&priv->vlan_rwsem); 163 list_for_each_entry(cpriv, &priv->child_intfs, list) { 164 int flags; 165 166 flags = cpriv->dev->flags; 167 if (flags & IFF_UP) 168 continue; 169 170 dev_change_flags(cpriv->dev, flags | IFF_UP); 171 } 172 up_read(&priv->vlan_rwsem); 173 } 174 175 netif_start_queue(dev); 176 177 return 0; 178 179 err_disable: 180 clear_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags); 181 182 return -EINVAL; 183 } 184 185 static int ipoib_stop(struct net_device *dev) 186 { 187 struct ipoib_dev_priv *priv = netdev_priv(dev); 188 189 ipoib_dbg(priv, "stopping interface\n"); 190 191 clear_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags); 192 193 netif_stop_queue(dev); 194 195 ipoib_ib_dev_down(dev); 196 ipoib_ib_dev_stop(dev); 197 198 if (!test_bit(IPOIB_FLAG_SUBINTERFACE, &priv->flags)) { 199 struct ipoib_dev_priv *cpriv; 200 201 /* Bring down any child interfaces too */ 202 down_read(&priv->vlan_rwsem); 203 list_for_each_entry(cpriv, &priv->child_intfs, list) { 204 int flags; 205 206 flags = cpriv->dev->flags; 207 if (!(flags & IFF_UP)) 208 continue; 209 210 dev_change_flags(cpriv->dev, flags & ~IFF_UP); 211 } 212 up_read(&priv->vlan_rwsem); 213 } 214 215 return 0; 216 } 217 218 static void ipoib_uninit(struct net_device *dev) 219 { 220 ipoib_dev_cleanup(dev); 221 } 222 223 static netdev_features_t ipoib_fix_features(struct net_device *dev, netdev_features_t features) 224 { 225 struct ipoib_dev_priv *priv = netdev_priv(dev); 226 227 if (test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags)) 228 features &= ~(NETIF_F_IP_CSUM | NETIF_F_TSO); 229 230 return features; 231 } 232 233 static int ipoib_change_mtu(struct net_device *dev, int new_mtu) 234 { 235 struct ipoib_dev_priv *priv = netdev_priv(dev); 236 237 /* dev->mtu > 2K ==> connected mode */ 238 if (ipoib_cm_admin_enabled(dev)) { 239 if (new_mtu > ipoib_cm_max_mtu(dev)) 240 return -EINVAL; 241 242 if (new_mtu > priv->mcast_mtu) 243 ipoib_warn(priv, "mtu > %d will cause multicast packet drops.\n", 244 priv->mcast_mtu); 245 246 dev->mtu = new_mtu; 247 return 0; 248 } 249 250 if (new_mtu > IPOIB_UD_MTU(priv->max_ib_mtu)) 251 return -EINVAL; 252 253 priv->admin_mtu = new_mtu; 254 255 if (priv->mcast_mtu < priv->admin_mtu) 256 ipoib_dbg(priv, "MTU must be smaller than the underlying " 257 "link layer MTU - 4 (%u)\n", priv->mcast_mtu); 258 259 dev->mtu = min(priv->mcast_mtu, priv->admin_mtu); 260 261 return 0; 262 } 263 264 /* Called with an RCU read lock taken */ 265 static bool ipoib_is_dev_match_addr_rcu(const struct sockaddr *addr, 266 struct net_device *dev) 267 { 268 struct net *net = dev_net(dev); 269 struct in_device *in_dev; 270 struct sockaddr_in *addr_in = (struct sockaddr_in *)addr; 271 struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)addr; 272 __be32 ret_addr; 273 274 switch (addr->sa_family) { 275 case AF_INET: 276 in_dev = in_dev_get(dev); 277 if (!in_dev) 278 return false; 279 280 ret_addr = inet_confirm_addr(net, in_dev, 0, 281 addr_in->sin_addr.s_addr, 282 RT_SCOPE_HOST); 283 in_dev_put(in_dev); 284 if (ret_addr) 285 return true; 286 287 break; 288 case AF_INET6: 289 if (IS_ENABLED(CONFIG_IPV6) && 290 ipv6_chk_addr(net, &addr_in6->sin6_addr, dev, 1)) 291 return true; 292 293 break; 294 } 295 return false; 296 } 297 298 /** 299 * Find the master net_device on top of the given net_device. 300 * @dev: base IPoIB net_device 301 * 302 * Returns the master net_device with a reference held, or the same net_device 303 * if no master exists. 304 */ 305 static struct net_device *ipoib_get_master_net_dev(struct net_device *dev) 306 { 307 struct net_device *master; 308 309 rcu_read_lock(); 310 master = netdev_master_upper_dev_get_rcu(dev); 311 if (master) 312 dev_hold(master); 313 rcu_read_unlock(); 314 315 if (master) 316 return master; 317 318 dev_hold(dev); 319 return dev; 320 } 321 322 struct ipoib_walk_data { 323 const struct sockaddr *addr; 324 struct net_device *result; 325 }; 326 327 static int ipoib_upper_walk(struct net_device *upper, void *_data) 328 { 329 struct ipoib_walk_data *data = _data; 330 int ret = 0; 331 332 if (ipoib_is_dev_match_addr_rcu(data->addr, upper)) { 333 dev_hold(upper); 334 data->result = upper; 335 ret = 1; 336 } 337 338 return ret; 339 } 340 341 /** 342 * Find a net_device matching the given address, which is an upper device of 343 * the given net_device. 344 * @addr: IP address to look for. 345 * @dev: base IPoIB net_device 346 * 347 * If found, returns the net_device with a reference held. Otherwise return 348 * NULL. 349 */ 350 static struct net_device *ipoib_get_net_dev_match_addr( 351 const struct sockaddr *addr, struct net_device *dev) 352 { 353 struct ipoib_walk_data data = { 354 .addr = addr, 355 }; 356 357 rcu_read_lock(); 358 if (ipoib_is_dev_match_addr_rcu(addr, dev)) { 359 dev_hold(dev); 360 data.result = dev; 361 goto out; 362 } 363 364 netdev_walk_all_upper_dev_rcu(dev, ipoib_upper_walk, &data); 365 out: 366 rcu_read_unlock(); 367 return data.result; 368 } 369 370 /* returns the number of IPoIB netdevs on top a given ipoib device matching a 371 * pkey_index and address, if one exists. 372 * 373 * @found_net_dev: contains a matching net_device if the return value >= 1, 374 * with a reference held. */ 375 static int ipoib_match_gid_pkey_addr(struct ipoib_dev_priv *priv, 376 const union ib_gid *gid, 377 u16 pkey_index, 378 const struct sockaddr *addr, 379 int nesting, 380 struct net_device **found_net_dev) 381 { 382 struct ipoib_dev_priv *child_priv; 383 struct net_device *net_dev = NULL; 384 int matches = 0; 385 386 if (priv->pkey_index == pkey_index && 387 (!gid || !memcmp(gid, &priv->local_gid, sizeof(*gid)))) { 388 if (!addr) { 389 net_dev = ipoib_get_master_net_dev(priv->dev); 390 } else { 391 /* Verify the net_device matches the IP address, as 392 * IPoIB child devices currently share a GID. */ 393 net_dev = ipoib_get_net_dev_match_addr(addr, priv->dev); 394 } 395 if (net_dev) { 396 if (!*found_net_dev) 397 *found_net_dev = net_dev; 398 else 399 dev_put(net_dev); 400 ++matches; 401 } 402 } 403 404 /* Check child interfaces */ 405 down_read_nested(&priv->vlan_rwsem, nesting); 406 list_for_each_entry(child_priv, &priv->child_intfs, list) { 407 matches += ipoib_match_gid_pkey_addr(child_priv, gid, 408 pkey_index, addr, 409 nesting + 1, 410 found_net_dev); 411 if (matches > 1) 412 break; 413 } 414 up_read(&priv->vlan_rwsem); 415 416 return matches; 417 } 418 419 /* Returns the number of matching net_devs found (between 0 and 2). Also 420 * return the matching net_device in the @net_dev parameter, holding a 421 * reference to the net_device, if the number of matches >= 1 */ 422 static int __ipoib_get_net_dev_by_params(struct list_head *dev_list, u8 port, 423 u16 pkey_index, 424 const union ib_gid *gid, 425 const struct sockaddr *addr, 426 struct net_device **net_dev) 427 { 428 struct ipoib_dev_priv *priv; 429 int matches = 0; 430 431 *net_dev = NULL; 432 433 list_for_each_entry(priv, dev_list, list) { 434 if (priv->port != port) 435 continue; 436 437 matches += ipoib_match_gid_pkey_addr(priv, gid, pkey_index, 438 addr, 0, net_dev); 439 if (matches > 1) 440 break; 441 } 442 443 return matches; 444 } 445 446 static struct net_device *ipoib_get_net_dev_by_params( 447 struct ib_device *dev, u8 port, u16 pkey, 448 const union ib_gid *gid, const struct sockaddr *addr, 449 void *client_data) 450 { 451 struct net_device *net_dev; 452 struct list_head *dev_list = client_data; 453 u16 pkey_index; 454 int matches; 455 int ret; 456 457 if (!rdma_protocol_ib(dev, port)) 458 return NULL; 459 460 ret = ib_find_cached_pkey(dev, port, pkey, &pkey_index); 461 if (ret) 462 return NULL; 463 464 if (!dev_list) 465 return NULL; 466 467 /* See if we can find a unique device matching the L2 parameters */ 468 matches = __ipoib_get_net_dev_by_params(dev_list, port, pkey_index, 469 gid, NULL, &net_dev); 470 471 switch (matches) { 472 case 0: 473 return NULL; 474 case 1: 475 return net_dev; 476 } 477 478 dev_put(net_dev); 479 480 /* Couldn't find a unique device with L2 parameters only. Use L3 481 * address to uniquely match the net device */ 482 matches = __ipoib_get_net_dev_by_params(dev_list, port, pkey_index, 483 gid, addr, &net_dev); 484 switch (matches) { 485 case 0: 486 return NULL; 487 default: 488 dev_warn_ratelimited(&dev->dev, 489 "duplicate IP address detected\n"); 490 /* Fall through */ 491 case 1: 492 return net_dev; 493 } 494 } 495 496 int ipoib_set_mode(struct net_device *dev, const char *buf) 497 { 498 struct ipoib_dev_priv *priv = netdev_priv(dev); 499 500 if ((test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags) && 501 !strcmp(buf, "connected\n")) || 502 (!test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags) && 503 !strcmp(buf, "datagram\n"))) { 504 return 0; 505 } 506 507 /* flush paths if we switch modes so that connections are restarted */ 508 if (IPOIB_CM_SUPPORTED(dev->dev_addr) && !strcmp(buf, "connected\n")) { 509 set_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags); 510 ipoib_warn(priv, "enabling connected mode " 511 "will cause multicast packet drops\n"); 512 netdev_update_features(dev); 513 dev_set_mtu(dev, ipoib_cm_max_mtu(dev)); 514 rtnl_unlock(); 515 priv->tx_wr.wr.send_flags &= ~IB_SEND_IP_CSUM; 516 517 ipoib_flush_paths(dev); 518 return (!rtnl_trylock()) ? -EBUSY : 0; 519 } 520 521 if (!strcmp(buf, "datagram\n")) { 522 clear_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags); 523 netdev_update_features(dev); 524 dev_set_mtu(dev, min(priv->mcast_mtu, dev->mtu)); 525 rtnl_unlock(); 526 ipoib_flush_paths(dev); 527 return (!rtnl_trylock()) ? -EBUSY : 0; 528 } 529 530 return -EINVAL; 531 } 532 533 struct ipoib_path *__path_find(struct net_device *dev, void *gid) 534 { 535 struct ipoib_dev_priv *priv = netdev_priv(dev); 536 struct rb_node *n = priv->path_tree.rb_node; 537 struct ipoib_path *path; 538 int ret; 539 540 while (n) { 541 path = rb_entry(n, struct ipoib_path, rb_node); 542 543 ret = memcmp(gid, path->pathrec.dgid.raw, 544 sizeof (union ib_gid)); 545 546 if (ret < 0) 547 n = n->rb_left; 548 else if (ret > 0) 549 n = n->rb_right; 550 else 551 return path; 552 } 553 554 return NULL; 555 } 556 557 static int __path_add(struct net_device *dev, struct ipoib_path *path) 558 { 559 struct ipoib_dev_priv *priv = netdev_priv(dev); 560 struct rb_node **n = &priv->path_tree.rb_node; 561 struct rb_node *pn = NULL; 562 struct ipoib_path *tpath; 563 int ret; 564 565 while (*n) { 566 pn = *n; 567 tpath = rb_entry(pn, struct ipoib_path, rb_node); 568 569 ret = memcmp(path->pathrec.dgid.raw, tpath->pathrec.dgid.raw, 570 sizeof (union ib_gid)); 571 if (ret < 0) 572 n = &pn->rb_left; 573 else if (ret > 0) 574 n = &pn->rb_right; 575 else 576 return -EEXIST; 577 } 578 579 rb_link_node(&path->rb_node, pn, n); 580 rb_insert_color(&path->rb_node, &priv->path_tree); 581 582 list_add_tail(&path->list, &priv->path_list); 583 584 return 0; 585 } 586 587 static void path_free(struct net_device *dev, struct ipoib_path *path) 588 { 589 struct sk_buff *skb; 590 591 while ((skb = __skb_dequeue(&path->queue))) 592 dev_kfree_skb_irq(skb); 593 594 ipoib_dbg(netdev_priv(dev), "path_free\n"); 595 596 /* remove all neigh connected to this path */ 597 ipoib_del_neighs_by_gid(dev, path->pathrec.dgid.raw); 598 599 if (path->ah) 600 ipoib_put_ah(path->ah); 601 602 kfree(path); 603 } 604 605 #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG 606 607 struct ipoib_path_iter *ipoib_path_iter_init(struct net_device *dev) 608 { 609 struct ipoib_path_iter *iter; 610 611 iter = kmalloc(sizeof *iter, GFP_KERNEL); 612 if (!iter) 613 return NULL; 614 615 iter->dev = dev; 616 memset(iter->path.pathrec.dgid.raw, 0, 16); 617 618 if (ipoib_path_iter_next(iter)) { 619 kfree(iter); 620 return NULL; 621 } 622 623 return iter; 624 } 625 626 int ipoib_path_iter_next(struct ipoib_path_iter *iter) 627 { 628 struct ipoib_dev_priv *priv = netdev_priv(iter->dev); 629 struct rb_node *n; 630 struct ipoib_path *path; 631 int ret = 1; 632 633 spin_lock_irq(&priv->lock); 634 635 n = rb_first(&priv->path_tree); 636 637 while (n) { 638 path = rb_entry(n, struct ipoib_path, rb_node); 639 640 if (memcmp(iter->path.pathrec.dgid.raw, path->pathrec.dgid.raw, 641 sizeof (union ib_gid)) < 0) { 642 iter->path = *path; 643 ret = 0; 644 break; 645 } 646 647 n = rb_next(n); 648 } 649 650 spin_unlock_irq(&priv->lock); 651 652 return ret; 653 } 654 655 void ipoib_path_iter_read(struct ipoib_path_iter *iter, 656 struct ipoib_path *path) 657 { 658 *path = iter->path; 659 } 660 661 #endif /* CONFIG_INFINIBAND_IPOIB_DEBUG */ 662 663 void ipoib_mark_paths_invalid(struct net_device *dev) 664 { 665 struct ipoib_dev_priv *priv = netdev_priv(dev); 666 struct ipoib_path *path, *tp; 667 668 spin_lock_irq(&priv->lock); 669 670 list_for_each_entry_safe(path, tp, &priv->path_list, list) { 671 ipoib_dbg(priv, "mark path LID 0x%04x GID %pI6 invalid\n", 672 be16_to_cpu(path->pathrec.dlid), 673 path->pathrec.dgid.raw); 674 path->valid = 0; 675 } 676 677 spin_unlock_irq(&priv->lock); 678 } 679 680 struct classport_info_context { 681 struct ipoib_dev_priv *priv; 682 struct completion done; 683 struct ib_sa_query *sa_query; 684 }; 685 686 static void classport_info_query_cb(int status, struct ib_class_port_info *rec, 687 void *context) 688 { 689 struct classport_info_context *cb_ctx = context; 690 struct ipoib_dev_priv *priv; 691 692 WARN_ON(!context); 693 694 priv = cb_ctx->priv; 695 696 if (status || !rec) { 697 pr_debug("device: %s failed query classport_info status: %d\n", 698 priv->dev->name, status); 699 /* keeps the default, will try next mcast_restart */ 700 priv->sm_fullmember_sendonly_support = false; 701 goto out; 702 } 703 704 if (ib_get_cpi_capmask2(rec) & 705 IB_SA_CAP_MASK2_SENDONLY_FULL_MEM_SUPPORT) { 706 pr_debug("device: %s enabled fullmember-sendonly for sendonly MCG\n", 707 priv->dev->name); 708 priv->sm_fullmember_sendonly_support = true; 709 } else { 710 pr_debug("device: %s disabled fullmember-sendonly for sendonly MCG\n", 711 priv->dev->name); 712 priv->sm_fullmember_sendonly_support = false; 713 } 714 715 out: 716 complete(&cb_ctx->done); 717 } 718 719 int ipoib_check_sm_sendonly_fullmember_support(struct ipoib_dev_priv *priv) 720 { 721 struct classport_info_context *callback_context; 722 int ret; 723 724 callback_context = kmalloc(sizeof(*callback_context), GFP_KERNEL); 725 if (!callback_context) 726 return -ENOMEM; 727 728 callback_context->priv = priv; 729 init_completion(&callback_context->done); 730 731 ret = ib_sa_classport_info_rec_query(&ipoib_sa_client, 732 priv->ca, priv->port, 3000, 733 GFP_KERNEL, 734 classport_info_query_cb, 735 callback_context, 736 &callback_context->sa_query); 737 if (ret < 0) { 738 pr_info("%s failed to send ib_sa_classport_info query, ret: %d\n", 739 priv->dev->name, ret); 740 kfree(callback_context); 741 return ret; 742 } 743 744 /* waiting for the callback to finish before returnning */ 745 wait_for_completion(&callback_context->done); 746 kfree(callback_context); 747 748 return ret; 749 } 750 751 static void push_pseudo_header(struct sk_buff *skb, const char *daddr) 752 { 753 struct ipoib_pseudo_header *phdr; 754 755 phdr = (struct ipoib_pseudo_header *)skb_push(skb, sizeof(*phdr)); 756 memcpy(phdr->hwaddr, daddr, INFINIBAND_ALEN); 757 } 758 759 void ipoib_flush_paths(struct net_device *dev) 760 { 761 struct ipoib_dev_priv *priv = netdev_priv(dev); 762 struct ipoib_path *path, *tp; 763 LIST_HEAD(remove_list); 764 unsigned long flags; 765 766 netif_tx_lock_bh(dev); 767 spin_lock_irqsave(&priv->lock, flags); 768 769 list_splice_init(&priv->path_list, &remove_list); 770 771 list_for_each_entry(path, &remove_list, list) 772 rb_erase(&path->rb_node, &priv->path_tree); 773 774 list_for_each_entry_safe(path, tp, &remove_list, list) { 775 if (path->query) 776 ib_sa_cancel_query(path->query_id, path->query); 777 spin_unlock_irqrestore(&priv->lock, flags); 778 netif_tx_unlock_bh(dev); 779 wait_for_completion(&path->done); 780 path_free(dev, path); 781 netif_tx_lock_bh(dev); 782 spin_lock_irqsave(&priv->lock, flags); 783 } 784 785 spin_unlock_irqrestore(&priv->lock, flags); 786 netif_tx_unlock_bh(dev); 787 } 788 789 static void path_rec_completion(int status, 790 struct ib_sa_path_rec *pathrec, 791 void *path_ptr) 792 { 793 struct ipoib_path *path = path_ptr; 794 struct net_device *dev = path->dev; 795 struct ipoib_dev_priv *priv = netdev_priv(dev); 796 struct ipoib_ah *ah = NULL; 797 struct ipoib_ah *old_ah = NULL; 798 struct ipoib_neigh *neigh, *tn; 799 struct sk_buff_head skqueue; 800 struct sk_buff *skb; 801 unsigned long flags; 802 803 if (!status) 804 ipoib_dbg(priv, "PathRec LID 0x%04x for GID %pI6\n", 805 be16_to_cpu(pathrec->dlid), pathrec->dgid.raw); 806 else 807 ipoib_dbg(priv, "PathRec status %d for GID %pI6\n", 808 status, path->pathrec.dgid.raw); 809 810 skb_queue_head_init(&skqueue); 811 812 if (!status) { 813 struct ib_ah_attr av; 814 815 if (!ib_init_ah_from_path(priv->ca, priv->port, pathrec, &av)) 816 ah = ipoib_create_ah(dev, priv->pd, &av); 817 } 818 819 spin_lock_irqsave(&priv->lock, flags); 820 821 if (!IS_ERR_OR_NULL(ah)) { 822 path->pathrec = *pathrec; 823 824 old_ah = path->ah; 825 path->ah = ah; 826 827 ipoib_dbg(priv, "created address handle %p for LID 0x%04x, SL %d\n", 828 ah, be16_to_cpu(pathrec->dlid), pathrec->sl); 829 830 while ((skb = __skb_dequeue(&path->queue))) 831 __skb_queue_tail(&skqueue, skb); 832 833 list_for_each_entry_safe(neigh, tn, &path->neigh_list, list) { 834 if (neigh->ah) { 835 WARN_ON(neigh->ah != old_ah); 836 /* 837 * Dropping the ah reference inside 838 * priv->lock is safe here, because we 839 * will hold one more reference from 840 * the original value of path->ah (ie 841 * old_ah). 842 */ 843 ipoib_put_ah(neigh->ah); 844 } 845 kref_get(&path->ah->ref); 846 neigh->ah = path->ah; 847 848 if (ipoib_cm_enabled(dev, neigh->daddr)) { 849 if (!ipoib_cm_get(neigh)) 850 ipoib_cm_set(neigh, ipoib_cm_create_tx(dev, 851 path, 852 neigh)); 853 if (!ipoib_cm_get(neigh)) { 854 ipoib_neigh_free(neigh); 855 continue; 856 } 857 } 858 859 while ((skb = __skb_dequeue(&neigh->queue))) 860 __skb_queue_tail(&skqueue, skb); 861 } 862 path->valid = 1; 863 } 864 865 path->query = NULL; 866 complete(&path->done); 867 868 spin_unlock_irqrestore(&priv->lock, flags); 869 870 if (IS_ERR_OR_NULL(ah)) 871 ipoib_del_neighs_by_gid(dev, path->pathrec.dgid.raw); 872 873 if (old_ah) 874 ipoib_put_ah(old_ah); 875 876 while ((skb = __skb_dequeue(&skqueue))) { 877 int ret; 878 skb->dev = dev; 879 ret = dev_queue_xmit(skb); 880 if (ret) 881 ipoib_warn(priv, "%s: dev_queue_xmit failed to re-queue packet, ret:%d\n", 882 __func__, ret); 883 } 884 } 885 886 static struct ipoib_path *path_rec_create(struct net_device *dev, void *gid) 887 { 888 struct ipoib_dev_priv *priv = netdev_priv(dev); 889 struct ipoib_path *path; 890 891 if (!priv->broadcast) 892 return NULL; 893 894 path = kzalloc(sizeof *path, GFP_ATOMIC); 895 if (!path) 896 return NULL; 897 898 path->dev = dev; 899 900 skb_queue_head_init(&path->queue); 901 902 INIT_LIST_HEAD(&path->neigh_list); 903 904 memcpy(path->pathrec.dgid.raw, gid, sizeof (union ib_gid)); 905 path->pathrec.sgid = priv->local_gid; 906 path->pathrec.pkey = cpu_to_be16(priv->pkey); 907 path->pathrec.numb_path = 1; 908 path->pathrec.traffic_class = priv->broadcast->mcmember.traffic_class; 909 910 return path; 911 } 912 913 static int path_rec_start(struct net_device *dev, 914 struct ipoib_path *path) 915 { 916 struct ipoib_dev_priv *priv = netdev_priv(dev); 917 918 ipoib_dbg(priv, "Start path record lookup for %pI6\n", 919 path->pathrec.dgid.raw); 920 921 init_completion(&path->done); 922 923 path->query_id = 924 ib_sa_path_rec_get(&ipoib_sa_client, priv->ca, priv->port, 925 &path->pathrec, 926 IB_SA_PATH_REC_DGID | 927 IB_SA_PATH_REC_SGID | 928 IB_SA_PATH_REC_NUMB_PATH | 929 IB_SA_PATH_REC_TRAFFIC_CLASS | 930 IB_SA_PATH_REC_PKEY, 931 1000, GFP_ATOMIC, 932 path_rec_completion, 933 path, &path->query); 934 if (path->query_id < 0) { 935 ipoib_warn(priv, "ib_sa_path_rec_get failed: %d\n", path->query_id); 936 path->query = NULL; 937 complete(&path->done); 938 return path->query_id; 939 } 940 941 return 0; 942 } 943 944 static void neigh_add_path(struct sk_buff *skb, u8 *daddr, 945 struct net_device *dev) 946 { 947 struct ipoib_dev_priv *priv = netdev_priv(dev); 948 struct ipoib_path *path; 949 struct ipoib_neigh *neigh; 950 unsigned long flags; 951 952 spin_lock_irqsave(&priv->lock, flags); 953 neigh = ipoib_neigh_alloc(daddr, dev); 954 if (!neigh) { 955 spin_unlock_irqrestore(&priv->lock, flags); 956 ++dev->stats.tx_dropped; 957 dev_kfree_skb_any(skb); 958 return; 959 } 960 961 path = __path_find(dev, daddr + 4); 962 if (!path) { 963 path = path_rec_create(dev, daddr + 4); 964 if (!path) 965 goto err_path; 966 967 __path_add(dev, path); 968 } 969 970 list_add_tail(&neigh->list, &path->neigh_list); 971 972 if (path->ah) { 973 kref_get(&path->ah->ref); 974 neigh->ah = path->ah; 975 976 if (ipoib_cm_enabled(dev, neigh->daddr)) { 977 if (!ipoib_cm_get(neigh)) 978 ipoib_cm_set(neigh, ipoib_cm_create_tx(dev, path, neigh)); 979 if (!ipoib_cm_get(neigh)) { 980 ipoib_neigh_free(neigh); 981 goto err_drop; 982 } 983 if (skb_queue_len(&neigh->queue) < 984 IPOIB_MAX_PATH_REC_QUEUE) { 985 push_pseudo_header(skb, neigh->daddr); 986 __skb_queue_tail(&neigh->queue, skb); 987 } else { 988 ipoib_warn(priv, "queue length limit %d. Packet drop.\n", 989 skb_queue_len(&neigh->queue)); 990 goto err_drop; 991 } 992 } else { 993 spin_unlock_irqrestore(&priv->lock, flags); 994 ipoib_send(dev, skb, path->ah, IPOIB_QPN(daddr)); 995 ipoib_neigh_put(neigh); 996 return; 997 } 998 } else { 999 neigh->ah = NULL; 1000 1001 if (!path->query && path_rec_start(dev, path)) 1002 goto err_path; 1003 if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE) { 1004 push_pseudo_header(skb, neigh->daddr); 1005 __skb_queue_tail(&neigh->queue, skb); 1006 } else { 1007 goto err_drop; 1008 } 1009 } 1010 1011 spin_unlock_irqrestore(&priv->lock, flags); 1012 ipoib_neigh_put(neigh); 1013 return; 1014 1015 err_path: 1016 ipoib_neigh_free(neigh); 1017 err_drop: 1018 ++dev->stats.tx_dropped; 1019 dev_kfree_skb_any(skb); 1020 1021 spin_unlock_irqrestore(&priv->lock, flags); 1022 ipoib_neigh_put(neigh); 1023 } 1024 1025 static void unicast_arp_send(struct sk_buff *skb, struct net_device *dev, 1026 struct ipoib_pseudo_header *phdr) 1027 { 1028 struct ipoib_dev_priv *priv = netdev_priv(dev); 1029 struct ipoib_path *path; 1030 unsigned long flags; 1031 1032 spin_lock_irqsave(&priv->lock, flags); 1033 1034 path = __path_find(dev, phdr->hwaddr + 4); 1035 if (!path || !path->valid) { 1036 int new_path = 0; 1037 1038 if (!path) { 1039 path = path_rec_create(dev, phdr->hwaddr + 4); 1040 new_path = 1; 1041 } 1042 if (path) { 1043 if (skb_queue_len(&path->queue) < IPOIB_MAX_PATH_REC_QUEUE) { 1044 push_pseudo_header(skb, phdr->hwaddr); 1045 __skb_queue_tail(&path->queue, skb); 1046 } else { 1047 ++dev->stats.tx_dropped; 1048 dev_kfree_skb_any(skb); 1049 } 1050 1051 if (!path->query && path_rec_start(dev, path)) { 1052 spin_unlock_irqrestore(&priv->lock, flags); 1053 if (new_path) 1054 path_free(dev, path); 1055 return; 1056 } else 1057 __path_add(dev, path); 1058 } else { 1059 ++dev->stats.tx_dropped; 1060 dev_kfree_skb_any(skb); 1061 } 1062 1063 spin_unlock_irqrestore(&priv->lock, flags); 1064 return; 1065 } 1066 1067 if (path->ah) { 1068 ipoib_dbg(priv, "Send unicast ARP to %04x\n", 1069 be16_to_cpu(path->pathrec.dlid)); 1070 1071 spin_unlock_irqrestore(&priv->lock, flags); 1072 ipoib_send(dev, skb, path->ah, IPOIB_QPN(phdr->hwaddr)); 1073 return; 1074 } else if ((path->query || !path_rec_start(dev, path)) && 1075 skb_queue_len(&path->queue) < IPOIB_MAX_PATH_REC_QUEUE) { 1076 push_pseudo_header(skb, phdr->hwaddr); 1077 __skb_queue_tail(&path->queue, skb); 1078 } else { 1079 ++dev->stats.tx_dropped; 1080 dev_kfree_skb_any(skb); 1081 } 1082 1083 spin_unlock_irqrestore(&priv->lock, flags); 1084 } 1085 1086 static int ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev) 1087 { 1088 struct ipoib_dev_priv *priv = netdev_priv(dev); 1089 struct ipoib_neigh *neigh; 1090 struct ipoib_pseudo_header *phdr; 1091 struct ipoib_header *header; 1092 unsigned long flags; 1093 1094 phdr = (struct ipoib_pseudo_header *) skb->data; 1095 skb_pull(skb, sizeof(*phdr)); 1096 header = (struct ipoib_header *) skb->data; 1097 1098 if (unlikely(phdr->hwaddr[4] == 0xff)) { 1099 /* multicast, arrange "if" according to probability */ 1100 if ((header->proto != htons(ETH_P_IP)) && 1101 (header->proto != htons(ETH_P_IPV6)) && 1102 (header->proto != htons(ETH_P_ARP)) && 1103 (header->proto != htons(ETH_P_RARP)) && 1104 (header->proto != htons(ETH_P_TIPC))) { 1105 /* ethertype not supported by IPoIB */ 1106 ++dev->stats.tx_dropped; 1107 dev_kfree_skb_any(skb); 1108 return NETDEV_TX_OK; 1109 } 1110 /* Add in the P_Key for multicast*/ 1111 phdr->hwaddr[8] = (priv->pkey >> 8) & 0xff; 1112 phdr->hwaddr[9] = priv->pkey & 0xff; 1113 1114 neigh = ipoib_neigh_get(dev, phdr->hwaddr); 1115 if (likely(neigh)) 1116 goto send_using_neigh; 1117 ipoib_mcast_send(dev, phdr->hwaddr, skb); 1118 return NETDEV_TX_OK; 1119 } 1120 1121 /* unicast, arrange "switch" according to probability */ 1122 switch (header->proto) { 1123 case htons(ETH_P_IP): 1124 case htons(ETH_P_IPV6): 1125 case htons(ETH_P_TIPC): 1126 neigh = ipoib_neigh_get(dev, phdr->hwaddr); 1127 if (unlikely(!neigh)) { 1128 neigh_add_path(skb, phdr->hwaddr, dev); 1129 return NETDEV_TX_OK; 1130 } 1131 break; 1132 case htons(ETH_P_ARP): 1133 case htons(ETH_P_RARP): 1134 /* for unicast ARP and RARP should always perform path find */ 1135 unicast_arp_send(skb, dev, phdr); 1136 return NETDEV_TX_OK; 1137 default: 1138 /* ethertype not supported by IPoIB */ 1139 ++dev->stats.tx_dropped; 1140 dev_kfree_skb_any(skb); 1141 return NETDEV_TX_OK; 1142 } 1143 1144 send_using_neigh: 1145 /* note we now hold a ref to neigh */ 1146 if (ipoib_cm_get(neigh)) { 1147 if (ipoib_cm_up(neigh)) { 1148 ipoib_cm_send(dev, skb, ipoib_cm_get(neigh)); 1149 goto unref; 1150 } 1151 } else if (neigh->ah) { 1152 ipoib_send(dev, skb, neigh->ah, IPOIB_QPN(phdr->hwaddr)); 1153 goto unref; 1154 } 1155 1156 if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE) { 1157 push_pseudo_header(skb, phdr->hwaddr); 1158 spin_lock_irqsave(&priv->lock, flags); 1159 __skb_queue_tail(&neigh->queue, skb); 1160 spin_unlock_irqrestore(&priv->lock, flags); 1161 } else { 1162 ++dev->stats.tx_dropped; 1163 dev_kfree_skb_any(skb); 1164 } 1165 1166 unref: 1167 ipoib_neigh_put(neigh); 1168 1169 return NETDEV_TX_OK; 1170 } 1171 1172 static void ipoib_timeout(struct net_device *dev) 1173 { 1174 struct ipoib_dev_priv *priv = netdev_priv(dev); 1175 1176 ipoib_warn(priv, "transmit timeout: latency %d msecs\n", 1177 jiffies_to_msecs(jiffies - dev_trans_start(dev))); 1178 ipoib_warn(priv, "queue stopped %d, tx_head %u, tx_tail %u\n", 1179 netif_queue_stopped(dev), 1180 priv->tx_head, priv->tx_tail); 1181 /* XXX reset QP, etc. */ 1182 } 1183 1184 static int ipoib_hard_header(struct sk_buff *skb, 1185 struct net_device *dev, 1186 unsigned short type, 1187 const void *daddr, const void *saddr, unsigned len) 1188 { 1189 struct ipoib_header *header; 1190 1191 header = (struct ipoib_header *) skb_push(skb, sizeof *header); 1192 1193 header->proto = htons(type); 1194 header->reserved = 0; 1195 1196 /* 1197 * we don't rely on dst_entry structure, always stuff the 1198 * destination address into skb hard header so we can figure out where 1199 * to send the packet later. 1200 */ 1201 push_pseudo_header(skb, daddr); 1202 1203 return IPOIB_HARD_LEN; 1204 } 1205 1206 static void ipoib_set_mcast_list(struct net_device *dev) 1207 { 1208 struct ipoib_dev_priv *priv = netdev_priv(dev); 1209 1210 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) { 1211 ipoib_dbg(priv, "IPOIB_FLAG_OPER_UP not set"); 1212 return; 1213 } 1214 1215 queue_work(priv->wq, &priv->restart_task); 1216 } 1217 1218 static int ipoib_get_iflink(const struct net_device *dev) 1219 { 1220 struct ipoib_dev_priv *priv = netdev_priv(dev); 1221 1222 /* parent interface */ 1223 if (!test_bit(IPOIB_FLAG_SUBINTERFACE, &priv->flags)) 1224 return dev->ifindex; 1225 1226 /* child/vlan interface */ 1227 return priv->parent->ifindex; 1228 } 1229 1230 static u32 ipoib_addr_hash(struct ipoib_neigh_hash *htbl, u8 *daddr) 1231 { 1232 /* 1233 * Use only the address parts that contributes to spreading 1234 * The subnet prefix is not used as one can not connect to 1235 * same remote port (GUID) using the same remote QPN via two 1236 * different subnets. 1237 */ 1238 /* qpn octets[1:4) & port GUID octets[12:20) */ 1239 u32 *d32 = (u32 *) daddr; 1240 u32 hv; 1241 1242 hv = jhash_3words(d32[3], d32[4], IPOIB_QPN_MASK & d32[0], 0); 1243 return hv & htbl->mask; 1244 } 1245 1246 struct ipoib_neigh *ipoib_neigh_get(struct net_device *dev, u8 *daddr) 1247 { 1248 struct ipoib_dev_priv *priv = netdev_priv(dev); 1249 struct ipoib_neigh_table *ntbl = &priv->ntbl; 1250 struct ipoib_neigh_hash *htbl; 1251 struct ipoib_neigh *neigh = NULL; 1252 u32 hash_val; 1253 1254 rcu_read_lock_bh(); 1255 1256 htbl = rcu_dereference_bh(ntbl->htbl); 1257 1258 if (!htbl) 1259 goto out_unlock; 1260 1261 hash_val = ipoib_addr_hash(htbl, daddr); 1262 for (neigh = rcu_dereference_bh(htbl->buckets[hash_val]); 1263 neigh != NULL; 1264 neigh = rcu_dereference_bh(neigh->hnext)) { 1265 if (memcmp(daddr, neigh->daddr, INFINIBAND_ALEN) == 0) { 1266 /* found, take one ref on behalf of the caller */ 1267 if (!atomic_inc_not_zero(&neigh->refcnt)) { 1268 /* deleted */ 1269 neigh = NULL; 1270 goto out_unlock; 1271 } 1272 1273 if (likely(skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE)) 1274 neigh->alive = jiffies; 1275 goto out_unlock; 1276 } 1277 } 1278 1279 out_unlock: 1280 rcu_read_unlock_bh(); 1281 return neigh; 1282 } 1283 1284 static void __ipoib_reap_neigh(struct ipoib_dev_priv *priv) 1285 { 1286 struct ipoib_neigh_table *ntbl = &priv->ntbl; 1287 struct ipoib_neigh_hash *htbl; 1288 unsigned long neigh_obsolete; 1289 unsigned long dt; 1290 unsigned long flags; 1291 int i; 1292 LIST_HEAD(remove_list); 1293 1294 if (test_bit(IPOIB_STOP_NEIGH_GC, &priv->flags)) 1295 return; 1296 1297 spin_lock_irqsave(&priv->lock, flags); 1298 1299 htbl = rcu_dereference_protected(ntbl->htbl, 1300 lockdep_is_held(&priv->lock)); 1301 1302 if (!htbl) 1303 goto out_unlock; 1304 1305 /* neigh is obsolete if it was idle for two GC periods */ 1306 dt = 2 * arp_tbl.gc_interval; 1307 neigh_obsolete = jiffies - dt; 1308 /* handle possible race condition */ 1309 if (test_bit(IPOIB_STOP_NEIGH_GC, &priv->flags)) 1310 goto out_unlock; 1311 1312 for (i = 0; i < htbl->size; i++) { 1313 struct ipoib_neigh *neigh; 1314 struct ipoib_neigh __rcu **np = &htbl->buckets[i]; 1315 1316 while ((neigh = rcu_dereference_protected(*np, 1317 lockdep_is_held(&priv->lock))) != NULL) { 1318 /* was the neigh idle for two GC periods */ 1319 if (time_after(neigh_obsolete, neigh->alive)) { 1320 1321 ipoib_check_and_add_mcast_sendonly(priv, neigh->daddr + 4, &remove_list); 1322 1323 rcu_assign_pointer(*np, 1324 rcu_dereference_protected(neigh->hnext, 1325 lockdep_is_held(&priv->lock))); 1326 /* remove from path/mc list */ 1327 list_del_init(&neigh->list); 1328 call_rcu(&neigh->rcu, ipoib_neigh_reclaim); 1329 } else { 1330 np = &neigh->hnext; 1331 } 1332 1333 } 1334 } 1335 1336 out_unlock: 1337 spin_unlock_irqrestore(&priv->lock, flags); 1338 ipoib_mcast_remove_list(&remove_list); 1339 } 1340 1341 static void ipoib_reap_neigh(struct work_struct *work) 1342 { 1343 struct ipoib_dev_priv *priv = 1344 container_of(work, struct ipoib_dev_priv, neigh_reap_task.work); 1345 1346 __ipoib_reap_neigh(priv); 1347 1348 if (!test_bit(IPOIB_STOP_NEIGH_GC, &priv->flags)) 1349 queue_delayed_work(priv->wq, &priv->neigh_reap_task, 1350 arp_tbl.gc_interval); 1351 } 1352 1353 1354 static struct ipoib_neigh *ipoib_neigh_ctor(u8 *daddr, 1355 struct net_device *dev) 1356 { 1357 struct ipoib_neigh *neigh; 1358 1359 neigh = kzalloc(sizeof *neigh, GFP_ATOMIC); 1360 if (!neigh) 1361 return NULL; 1362 1363 neigh->dev = dev; 1364 memcpy(&neigh->daddr, daddr, sizeof(neigh->daddr)); 1365 skb_queue_head_init(&neigh->queue); 1366 INIT_LIST_HEAD(&neigh->list); 1367 ipoib_cm_set(neigh, NULL); 1368 /* one ref on behalf of the caller */ 1369 atomic_set(&neigh->refcnt, 1); 1370 1371 return neigh; 1372 } 1373 1374 struct ipoib_neigh *ipoib_neigh_alloc(u8 *daddr, 1375 struct net_device *dev) 1376 { 1377 struct ipoib_dev_priv *priv = netdev_priv(dev); 1378 struct ipoib_neigh_table *ntbl = &priv->ntbl; 1379 struct ipoib_neigh_hash *htbl; 1380 struct ipoib_neigh *neigh; 1381 u32 hash_val; 1382 1383 htbl = rcu_dereference_protected(ntbl->htbl, 1384 lockdep_is_held(&priv->lock)); 1385 if (!htbl) { 1386 neigh = NULL; 1387 goto out_unlock; 1388 } 1389 1390 /* need to add a new neigh, but maybe some other thread succeeded? 1391 * recalc hash, maybe hash resize took place so we do a search 1392 */ 1393 hash_val = ipoib_addr_hash(htbl, daddr); 1394 for (neigh = rcu_dereference_protected(htbl->buckets[hash_val], 1395 lockdep_is_held(&priv->lock)); 1396 neigh != NULL; 1397 neigh = rcu_dereference_protected(neigh->hnext, 1398 lockdep_is_held(&priv->lock))) { 1399 if (memcmp(daddr, neigh->daddr, INFINIBAND_ALEN) == 0) { 1400 /* found, take one ref on behalf of the caller */ 1401 if (!atomic_inc_not_zero(&neigh->refcnt)) { 1402 /* deleted */ 1403 neigh = NULL; 1404 break; 1405 } 1406 neigh->alive = jiffies; 1407 goto out_unlock; 1408 } 1409 } 1410 1411 neigh = ipoib_neigh_ctor(daddr, dev); 1412 if (!neigh) 1413 goto out_unlock; 1414 1415 /* one ref on behalf of the hash table */ 1416 atomic_inc(&neigh->refcnt); 1417 neigh->alive = jiffies; 1418 /* put in hash */ 1419 rcu_assign_pointer(neigh->hnext, 1420 rcu_dereference_protected(htbl->buckets[hash_val], 1421 lockdep_is_held(&priv->lock))); 1422 rcu_assign_pointer(htbl->buckets[hash_val], neigh); 1423 atomic_inc(&ntbl->entries); 1424 1425 out_unlock: 1426 1427 return neigh; 1428 } 1429 1430 void ipoib_neigh_dtor(struct ipoib_neigh *neigh) 1431 { 1432 /* neigh reference count was dropprd to zero */ 1433 struct net_device *dev = neigh->dev; 1434 struct ipoib_dev_priv *priv = netdev_priv(dev); 1435 struct sk_buff *skb; 1436 if (neigh->ah) 1437 ipoib_put_ah(neigh->ah); 1438 while ((skb = __skb_dequeue(&neigh->queue))) { 1439 ++dev->stats.tx_dropped; 1440 dev_kfree_skb_any(skb); 1441 } 1442 if (ipoib_cm_get(neigh)) 1443 ipoib_cm_destroy_tx(ipoib_cm_get(neigh)); 1444 ipoib_dbg(netdev_priv(dev), 1445 "neigh free for %06x %pI6\n", 1446 IPOIB_QPN(neigh->daddr), 1447 neigh->daddr + 4); 1448 kfree(neigh); 1449 if (atomic_dec_and_test(&priv->ntbl.entries)) { 1450 if (test_bit(IPOIB_NEIGH_TBL_FLUSH, &priv->flags)) 1451 complete(&priv->ntbl.flushed); 1452 } 1453 } 1454 1455 static void ipoib_neigh_reclaim(struct rcu_head *rp) 1456 { 1457 /* Called as a result of removal from hash table */ 1458 struct ipoib_neigh *neigh = container_of(rp, struct ipoib_neigh, rcu); 1459 /* note TX context may hold another ref */ 1460 ipoib_neigh_put(neigh); 1461 } 1462 1463 void ipoib_neigh_free(struct ipoib_neigh *neigh) 1464 { 1465 struct net_device *dev = neigh->dev; 1466 struct ipoib_dev_priv *priv = netdev_priv(dev); 1467 struct ipoib_neigh_table *ntbl = &priv->ntbl; 1468 struct ipoib_neigh_hash *htbl; 1469 struct ipoib_neigh __rcu **np; 1470 struct ipoib_neigh *n; 1471 u32 hash_val; 1472 1473 htbl = rcu_dereference_protected(ntbl->htbl, 1474 lockdep_is_held(&priv->lock)); 1475 if (!htbl) 1476 return; 1477 1478 hash_val = ipoib_addr_hash(htbl, neigh->daddr); 1479 np = &htbl->buckets[hash_val]; 1480 for (n = rcu_dereference_protected(*np, 1481 lockdep_is_held(&priv->lock)); 1482 n != NULL; 1483 n = rcu_dereference_protected(*np, 1484 lockdep_is_held(&priv->lock))) { 1485 if (n == neigh) { 1486 /* found */ 1487 rcu_assign_pointer(*np, 1488 rcu_dereference_protected(neigh->hnext, 1489 lockdep_is_held(&priv->lock))); 1490 /* remove from parent list */ 1491 list_del_init(&neigh->list); 1492 call_rcu(&neigh->rcu, ipoib_neigh_reclaim); 1493 return; 1494 } else { 1495 np = &n->hnext; 1496 } 1497 } 1498 } 1499 1500 static int ipoib_neigh_hash_init(struct ipoib_dev_priv *priv) 1501 { 1502 struct ipoib_neigh_table *ntbl = &priv->ntbl; 1503 struct ipoib_neigh_hash *htbl; 1504 struct ipoib_neigh __rcu **buckets; 1505 u32 size; 1506 1507 clear_bit(IPOIB_NEIGH_TBL_FLUSH, &priv->flags); 1508 ntbl->htbl = NULL; 1509 htbl = kzalloc(sizeof(*htbl), GFP_KERNEL); 1510 if (!htbl) 1511 return -ENOMEM; 1512 set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags); 1513 size = roundup_pow_of_two(arp_tbl.gc_thresh3); 1514 buckets = kzalloc(size * sizeof(*buckets), GFP_KERNEL); 1515 if (!buckets) { 1516 kfree(htbl); 1517 return -ENOMEM; 1518 } 1519 htbl->size = size; 1520 htbl->mask = (size - 1); 1521 htbl->buckets = buckets; 1522 RCU_INIT_POINTER(ntbl->htbl, htbl); 1523 htbl->ntbl = ntbl; 1524 atomic_set(&ntbl->entries, 0); 1525 1526 /* start garbage collection */ 1527 clear_bit(IPOIB_STOP_NEIGH_GC, &priv->flags); 1528 queue_delayed_work(priv->wq, &priv->neigh_reap_task, 1529 arp_tbl.gc_interval); 1530 1531 return 0; 1532 } 1533 1534 static void neigh_hash_free_rcu(struct rcu_head *head) 1535 { 1536 struct ipoib_neigh_hash *htbl = container_of(head, 1537 struct ipoib_neigh_hash, 1538 rcu); 1539 struct ipoib_neigh __rcu **buckets = htbl->buckets; 1540 struct ipoib_neigh_table *ntbl = htbl->ntbl; 1541 1542 kfree(buckets); 1543 kfree(htbl); 1544 complete(&ntbl->deleted); 1545 } 1546 1547 void ipoib_del_neighs_by_gid(struct net_device *dev, u8 *gid) 1548 { 1549 struct ipoib_dev_priv *priv = netdev_priv(dev); 1550 struct ipoib_neigh_table *ntbl = &priv->ntbl; 1551 struct ipoib_neigh_hash *htbl; 1552 unsigned long flags; 1553 int i; 1554 1555 /* remove all neigh connected to a given path or mcast */ 1556 spin_lock_irqsave(&priv->lock, flags); 1557 1558 htbl = rcu_dereference_protected(ntbl->htbl, 1559 lockdep_is_held(&priv->lock)); 1560 1561 if (!htbl) 1562 goto out_unlock; 1563 1564 for (i = 0; i < htbl->size; i++) { 1565 struct ipoib_neigh *neigh; 1566 struct ipoib_neigh __rcu **np = &htbl->buckets[i]; 1567 1568 while ((neigh = rcu_dereference_protected(*np, 1569 lockdep_is_held(&priv->lock))) != NULL) { 1570 /* delete neighs belong to this parent */ 1571 if (!memcmp(gid, neigh->daddr + 4, sizeof (union ib_gid))) { 1572 rcu_assign_pointer(*np, 1573 rcu_dereference_protected(neigh->hnext, 1574 lockdep_is_held(&priv->lock))); 1575 /* remove from parent list */ 1576 list_del_init(&neigh->list); 1577 call_rcu(&neigh->rcu, ipoib_neigh_reclaim); 1578 } else { 1579 np = &neigh->hnext; 1580 } 1581 1582 } 1583 } 1584 out_unlock: 1585 spin_unlock_irqrestore(&priv->lock, flags); 1586 } 1587 1588 static void ipoib_flush_neighs(struct ipoib_dev_priv *priv) 1589 { 1590 struct ipoib_neigh_table *ntbl = &priv->ntbl; 1591 struct ipoib_neigh_hash *htbl; 1592 unsigned long flags; 1593 int i, wait_flushed = 0; 1594 1595 init_completion(&priv->ntbl.flushed); 1596 1597 spin_lock_irqsave(&priv->lock, flags); 1598 1599 htbl = rcu_dereference_protected(ntbl->htbl, 1600 lockdep_is_held(&priv->lock)); 1601 if (!htbl) 1602 goto out_unlock; 1603 1604 wait_flushed = atomic_read(&priv->ntbl.entries); 1605 if (!wait_flushed) 1606 goto free_htbl; 1607 1608 for (i = 0; i < htbl->size; i++) { 1609 struct ipoib_neigh *neigh; 1610 struct ipoib_neigh __rcu **np = &htbl->buckets[i]; 1611 1612 while ((neigh = rcu_dereference_protected(*np, 1613 lockdep_is_held(&priv->lock))) != NULL) { 1614 rcu_assign_pointer(*np, 1615 rcu_dereference_protected(neigh->hnext, 1616 lockdep_is_held(&priv->lock))); 1617 /* remove from path/mc list */ 1618 list_del_init(&neigh->list); 1619 call_rcu(&neigh->rcu, ipoib_neigh_reclaim); 1620 } 1621 } 1622 1623 free_htbl: 1624 rcu_assign_pointer(ntbl->htbl, NULL); 1625 call_rcu(&htbl->rcu, neigh_hash_free_rcu); 1626 1627 out_unlock: 1628 spin_unlock_irqrestore(&priv->lock, flags); 1629 if (wait_flushed) 1630 wait_for_completion(&priv->ntbl.flushed); 1631 } 1632 1633 static void ipoib_neigh_hash_uninit(struct net_device *dev) 1634 { 1635 struct ipoib_dev_priv *priv = netdev_priv(dev); 1636 int stopped; 1637 1638 ipoib_dbg(priv, "ipoib_neigh_hash_uninit\n"); 1639 init_completion(&priv->ntbl.deleted); 1640 set_bit(IPOIB_NEIGH_TBL_FLUSH, &priv->flags); 1641 1642 /* Stop GC if called at init fail need to cancel work */ 1643 stopped = test_and_set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags); 1644 if (!stopped) 1645 cancel_delayed_work(&priv->neigh_reap_task); 1646 1647 ipoib_flush_neighs(priv); 1648 1649 wait_for_completion(&priv->ntbl.deleted); 1650 } 1651 1652 void ipoib_dev_uninit_default(struct net_device *dev) 1653 { 1654 struct ipoib_dev_priv *priv = netdev_priv(dev); 1655 1656 ipoib_transport_dev_cleanup(dev); 1657 1658 ipoib_cm_dev_cleanup(dev); 1659 1660 kfree(priv->rx_ring); 1661 vfree(priv->tx_ring); 1662 1663 priv->rx_ring = NULL; 1664 priv->tx_ring = NULL; 1665 } 1666 1667 static int ipoib_dev_init_default(struct net_device *dev, struct ib_device *ca, 1668 int port) 1669 { 1670 struct ipoib_dev_priv *priv = netdev_priv(dev); 1671 1672 /* Allocate RX/TX "rings" to hold queued skbs */ 1673 priv->rx_ring = kzalloc(ipoib_recvq_size * sizeof *priv->rx_ring, 1674 GFP_KERNEL); 1675 if (!priv->rx_ring) 1676 goto out; 1677 1678 priv->tx_ring = vzalloc(ipoib_sendq_size * sizeof *priv->tx_ring); 1679 if (!priv->tx_ring) { 1680 printk(KERN_WARNING "%s: failed to allocate TX ring (%d entries)\n", 1681 ca->name, ipoib_sendq_size); 1682 goto out_rx_ring_cleanup; 1683 } 1684 1685 /* priv->tx_head, tx_tail & tx_outstanding are already 0 */ 1686 1687 if (ipoib_transport_dev_init(dev, ca)) { 1688 pr_warn("%s: ipoib_transport_dev_init failed\n", ca->name); 1689 goto out_tx_ring_cleanup; 1690 } 1691 1692 setup_timer(&priv->poll_timer, ipoib_ib_tx_timer_func, 1693 (unsigned long)dev); 1694 1695 return 0; 1696 1697 out_tx_ring_cleanup: 1698 vfree(priv->tx_ring); 1699 1700 out_rx_ring_cleanup: 1701 kfree(priv->rx_ring); 1702 1703 out: 1704 return -ENOMEM; 1705 } 1706 1707 int ipoib_dev_init(struct net_device *dev, struct ib_device *ca, int port) 1708 { 1709 struct ipoib_dev_priv *priv = netdev_priv(dev); 1710 int ret = -ENOMEM; 1711 1712 priv->ca = ca; 1713 priv->port = port; 1714 priv->qp = NULL; 1715 1716 /* 1717 * the various IPoIB tasks assume they will never race against 1718 * themselves, so always use a single thread workqueue 1719 */ 1720 priv->wq = alloc_ordered_workqueue("ipoib_wq", WQ_MEM_RECLAIM); 1721 if (!priv->wq) { 1722 pr_warn("%s: failed to allocate device WQ\n", dev->name); 1723 goto out; 1724 } 1725 1726 /* create pd, which used both for control and datapath*/ 1727 priv->pd = ib_alloc_pd(priv->ca, 0); 1728 if (IS_ERR(priv->pd)) { 1729 pr_warn("%s: failed to allocate PD\n", ca->name); 1730 goto clean_wq; 1731 } 1732 1733 ret = ipoib_dev_init_default(dev, ca, port); 1734 if (ret) { 1735 pr_warn("%s failed to init HW resource\n", dev->name); 1736 goto out_free_pd; 1737 } 1738 1739 /* after qp created set dev address */ 1740 priv->dev->dev_addr[1] = (priv->qp->qp_num >> 16) & 0xff; 1741 priv->dev->dev_addr[2] = (priv->qp->qp_num >> 8) & 0xff; 1742 priv->dev->dev_addr[3] = (priv->qp->qp_num) & 0xff; 1743 1744 if (ipoib_neigh_hash_init(priv) < 0) { 1745 pr_warn("%s failed to init neigh hash\n", dev->name); 1746 goto out_dev_uninit; 1747 } 1748 1749 if (dev->flags & IFF_UP) { 1750 if (ipoib_ib_dev_open(dev)) { 1751 pr_warn("%s failed to open device\n", dev->name); 1752 ret = -ENODEV; 1753 goto out_dev_uninit; 1754 } 1755 } 1756 1757 return 0; 1758 1759 out_dev_uninit: 1760 ipoib_ib_dev_cleanup(dev); 1761 1762 out_free_pd: 1763 if (priv->pd) { 1764 ib_dealloc_pd(priv->pd); 1765 priv->pd = NULL; 1766 } 1767 1768 clean_wq: 1769 if (priv->wq) { 1770 destroy_workqueue(priv->wq); 1771 priv->wq = NULL; 1772 } 1773 1774 out: 1775 return ret; 1776 } 1777 1778 void ipoib_dev_cleanup(struct net_device *dev) 1779 { 1780 struct ipoib_dev_priv *priv = netdev_priv(dev), *cpriv, *tcpriv; 1781 LIST_HEAD(head); 1782 1783 ASSERT_RTNL(); 1784 1785 /* Delete any child interfaces first */ 1786 list_for_each_entry_safe(cpriv, tcpriv, &priv->child_intfs, list) { 1787 /* Stop GC on child */ 1788 set_bit(IPOIB_STOP_NEIGH_GC, &cpriv->flags); 1789 cancel_delayed_work(&cpriv->neigh_reap_task); 1790 unregister_netdevice_queue(cpriv->dev, &head); 1791 } 1792 unregister_netdevice_many(&head); 1793 1794 ipoib_neigh_hash_uninit(dev); 1795 1796 ipoib_ib_dev_cleanup(dev); 1797 1798 /* no more works over the priv->wq */ 1799 if (priv->wq) { 1800 flush_workqueue(priv->wq); 1801 destroy_workqueue(priv->wq); 1802 priv->wq = NULL; 1803 } 1804 } 1805 1806 static int ipoib_set_vf_link_state(struct net_device *dev, int vf, int link_state) 1807 { 1808 struct ipoib_dev_priv *priv = netdev_priv(dev); 1809 1810 return ib_set_vf_link_state(priv->ca, vf, priv->port, link_state); 1811 } 1812 1813 static int ipoib_get_vf_config(struct net_device *dev, int vf, 1814 struct ifla_vf_info *ivf) 1815 { 1816 struct ipoib_dev_priv *priv = netdev_priv(dev); 1817 int err; 1818 1819 err = ib_get_vf_config(priv->ca, vf, priv->port, ivf); 1820 if (err) 1821 return err; 1822 1823 ivf->vf = vf; 1824 1825 return 0; 1826 } 1827 1828 static int ipoib_set_vf_guid(struct net_device *dev, int vf, u64 guid, int type) 1829 { 1830 struct ipoib_dev_priv *priv = netdev_priv(dev); 1831 1832 if (type != IFLA_VF_IB_NODE_GUID && type != IFLA_VF_IB_PORT_GUID) 1833 return -EINVAL; 1834 1835 return ib_set_vf_guid(priv->ca, vf, priv->port, guid, type); 1836 } 1837 1838 static int ipoib_get_vf_stats(struct net_device *dev, int vf, 1839 struct ifla_vf_stats *vf_stats) 1840 { 1841 struct ipoib_dev_priv *priv = netdev_priv(dev); 1842 1843 return ib_get_vf_stats(priv->ca, vf, priv->port, vf_stats); 1844 } 1845 1846 static const struct header_ops ipoib_header_ops = { 1847 .create = ipoib_hard_header, 1848 }; 1849 1850 static const struct net_device_ops ipoib_netdev_ops_pf = { 1851 .ndo_uninit = ipoib_uninit, 1852 .ndo_open = ipoib_open, 1853 .ndo_stop = ipoib_stop, 1854 .ndo_change_mtu = ipoib_change_mtu, 1855 .ndo_fix_features = ipoib_fix_features, 1856 .ndo_start_xmit = ipoib_start_xmit, 1857 .ndo_tx_timeout = ipoib_timeout, 1858 .ndo_set_rx_mode = ipoib_set_mcast_list, 1859 .ndo_get_iflink = ipoib_get_iflink, 1860 .ndo_set_vf_link_state = ipoib_set_vf_link_state, 1861 .ndo_get_vf_config = ipoib_get_vf_config, 1862 .ndo_get_vf_stats = ipoib_get_vf_stats, 1863 .ndo_set_vf_guid = ipoib_set_vf_guid, 1864 .ndo_set_mac_address = ipoib_set_mac, 1865 }; 1866 1867 static const struct net_device_ops ipoib_netdev_ops_vf = { 1868 .ndo_uninit = ipoib_uninit, 1869 .ndo_open = ipoib_open, 1870 .ndo_stop = ipoib_stop, 1871 .ndo_change_mtu = ipoib_change_mtu, 1872 .ndo_fix_features = ipoib_fix_features, 1873 .ndo_start_xmit = ipoib_start_xmit, 1874 .ndo_tx_timeout = ipoib_timeout, 1875 .ndo_set_rx_mode = ipoib_set_mcast_list, 1876 .ndo_get_iflink = ipoib_get_iflink, 1877 }; 1878 1879 void ipoib_setup(struct net_device *dev) 1880 { 1881 struct ipoib_dev_priv *priv = netdev_priv(dev); 1882 1883 if (priv->hca_caps & IB_DEVICE_VIRTUAL_FUNCTION) 1884 dev->netdev_ops = &ipoib_netdev_ops_vf; 1885 else 1886 dev->netdev_ops = &ipoib_netdev_ops_pf; 1887 1888 dev->header_ops = &ipoib_header_ops; 1889 1890 ipoib_set_ethtool_ops(dev); 1891 1892 netif_napi_add(dev, &priv->napi, ipoib_poll, NAPI_POLL_WEIGHT); 1893 1894 dev->watchdog_timeo = HZ; 1895 1896 dev->flags |= IFF_BROADCAST | IFF_MULTICAST; 1897 1898 dev->hard_header_len = IPOIB_HARD_LEN; 1899 dev->addr_len = INFINIBAND_ALEN; 1900 dev->type = ARPHRD_INFINIBAND; 1901 dev->tx_queue_len = ipoib_sendq_size * 2; 1902 dev->features = (NETIF_F_VLAN_CHALLENGED | 1903 NETIF_F_HIGHDMA); 1904 netif_keep_dst(dev); 1905 1906 memcpy(dev->broadcast, ipv4_bcast_addr, INFINIBAND_ALEN); 1907 1908 priv->dev = dev; 1909 1910 spin_lock_init(&priv->lock); 1911 1912 init_rwsem(&priv->vlan_rwsem); 1913 1914 INIT_LIST_HEAD(&priv->path_list); 1915 INIT_LIST_HEAD(&priv->child_intfs); 1916 INIT_LIST_HEAD(&priv->dead_ahs); 1917 INIT_LIST_HEAD(&priv->multicast_list); 1918 1919 INIT_DELAYED_WORK(&priv->mcast_task, ipoib_mcast_join_task); 1920 INIT_WORK(&priv->carrier_on_task, ipoib_mcast_carrier_on_task); 1921 INIT_WORK(&priv->flush_light, ipoib_ib_dev_flush_light); 1922 INIT_WORK(&priv->flush_normal, ipoib_ib_dev_flush_normal); 1923 INIT_WORK(&priv->flush_heavy, ipoib_ib_dev_flush_heavy); 1924 INIT_WORK(&priv->restart_task, ipoib_mcast_restart_task); 1925 INIT_DELAYED_WORK(&priv->ah_reap_task, ipoib_reap_ah); 1926 INIT_DELAYED_WORK(&priv->neigh_reap_task, ipoib_reap_neigh); 1927 } 1928 1929 struct ipoib_dev_priv *ipoib_intf_alloc(const char *name) 1930 { 1931 struct net_device *dev; 1932 1933 dev = alloc_netdev((int)sizeof(struct ipoib_dev_priv), name, 1934 NET_NAME_UNKNOWN, ipoib_setup); 1935 if (!dev) 1936 return NULL; 1937 1938 return netdev_priv(dev); 1939 } 1940 1941 static ssize_t show_pkey(struct device *dev, 1942 struct device_attribute *attr, char *buf) 1943 { 1944 struct ipoib_dev_priv *priv = netdev_priv(to_net_dev(dev)); 1945 1946 return sprintf(buf, "0x%04x\n", priv->pkey); 1947 } 1948 static DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); 1949 1950 static ssize_t show_umcast(struct device *dev, 1951 struct device_attribute *attr, char *buf) 1952 { 1953 struct ipoib_dev_priv *priv = netdev_priv(to_net_dev(dev)); 1954 1955 return sprintf(buf, "%d\n", test_bit(IPOIB_FLAG_UMCAST, &priv->flags)); 1956 } 1957 1958 void ipoib_set_umcast(struct net_device *ndev, int umcast_val) 1959 { 1960 struct ipoib_dev_priv *priv = netdev_priv(ndev); 1961 1962 if (umcast_val > 0) { 1963 set_bit(IPOIB_FLAG_UMCAST, &priv->flags); 1964 ipoib_warn(priv, "ignoring multicast groups joined directly " 1965 "by userspace\n"); 1966 } else 1967 clear_bit(IPOIB_FLAG_UMCAST, &priv->flags); 1968 } 1969 1970 static ssize_t set_umcast(struct device *dev, 1971 struct device_attribute *attr, 1972 const char *buf, size_t count) 1973 { 1974 unsigned long umcast_val = simple_strtoul(buf, NULL, 0); 1975 1976 ipoib_set_umcast(to_net_dev(dev), umcast_val); 1977 1978 return count; 1979 } 1980 static DEVICE_ATTR(umcast, S_IWUSR | S_IRUGO, show_umcast, set_umcast); 1981 1982 int ipoib_add_umcast_attr(struct net_device *dev) 1983 { 1984 return device_create_file(&dev->dev, &dev_attr_umcast); 1985 } 1986 1987 static void set_base_guid(struct ipoib_dev_priv *priv, union ib_gid *gid) 1988 { 1989 struct ipoib_dev_priv *child_priv; 1990 struct net_device *netdev = priv->dev; 1991 1992 netif_addr_lock_bh(netdev); 1993 1994 memcpy(&priv->local_gid.global.interface_id, 1995 &gid->global.interface_id, 1996 sizeof(gid->global.interface_id)); 1997 memcpy(netdev->dev_addr + 4, &priv->local_gid, sizeof(priv->local_gid)); 1998 clear_bit(IPOIB_FLAG_DEV_ADDR_SET, &priv->flags); 1999 2000 netif_addr_unlock_bh(netdev); 2001 2002 if (!test_bit(IPOIB_FLAG_SUBINTERFACE, &priv->flags)) { 2003 down_read(&priv->vlan_rwsem); 2004 list_for_each_entry(child_priv, &priv->child_intfs, list) 2005 set_base_guid(child_priv, gid); 2006 up_read(&priv->vlan_rwsem); 2007 } 2008 } 2009 2010 static int ipoib_check_lladdr(struct net_device *dev, 2011 struct sockaddr_storage *ss) 2012 { 2013 union ib_gid *gid = (union ib_gid *)(ss->__data + 4); 2014 int ret = 0; 2015 2016 netif_addr_lock_bh(dev); 2017 2018 /* Make sure the QPN, reserved and subnet prefix match the current 2019 * lladdr, it also makes sure the lladdr is unicast. 2020 */ 2021 if (memcmp(dev->dev_addr, ss->__data, 2022 4 + sizeof(gid->global.subnet_prefix)) || 2023 gid->global.interface_id == 0) 2024 ret = -EINVAL; 2025 2026 netif_addr_unlock_bh(dev); 2027 2028 return ret; 2029 } 2030 2031 static int ipoib_set_mac(struct net_device *dev, void *addr) 2032 { 2033 struct ipoib_dev_priv *priv = netdev_priv(dev); 2034 struct sockaddr_storage *ss = addr; 2035 int ret; 2036 2037 if (!(dev->priv_flags & IFF_LIVE_ADDR_CHANGE) && netif_running(dev)) 2038 return -EBUSY; 2039 2040 ret = ipoib_check_lladdr(dev, ss); 2041 if (ret) 2042 return ret; 2043 2044 set_base_guid(priv, (union ib_gid *)(ss->__data + 4)); 2045 2046 queue_work(ipoib_workqueue, &priv->flush_light); 2047 2048 return 0; 2049 } 2050 2051 static ssize_t create_child(struct device *dev, 2052 struct device_attribute *attr, 2053 const char *buf, size_t count) 2054 { 2055 int pkey; 2056 int ret; 2057 2058 if (sscanf(buf, "%i", &pkey) != 1) 2059 return -EINVAL; 2060 2061 if (pkey <= 0 || pkey > 0xffff || pkey == 0x8000) 2062 return -EINVAL; 2063 2064 /* 2065 * Set the full membership bit, so that we join the right 2066 * broadcast group, etc. 2067 */ 2068 pkey |= 0x8000; 2069 2070 ret = ipoib_vlan_add(to_net_dev(dev), pkey); 2071 2072 return ret ? ret : count; 2073 } 2074 static DEVICE_ATTR(create_child, S_IWUSR, NULL, create_child); 2075 2076 static ssize_t delete_child(struct device *dev, 2077 struct device_attribute *attr, 2078 const char *buf, size_t count) 2079 { 2080 int pkey; 2081 int ret; 2082 2083 if (sscanf(buf, "%i", &pkey) != 1) 2084 return -EINVAL; 2085 2086 if (pkey < 0 || pkey > 0xffff) 2087 return -EINVAL; 2088 2089 ret = ipoib_vlan_delete(to_net_dev(dev), pkey); 2090 2091 return ret ? ret : count; 2092 2093 } 2094 static DEVICE_ATTR(delete_child, S_IWUSR, NULL, delete_child); 2095 2096 int ipoib_add_pkey_attr(struct net_device *dev) 2097 { 2098 return device_create_file(&dev->dev, &dev_attr_pkey); 2099 } 2100 2101 void ipoib_set_dev_features(struct ipoib_dev_priv *priv, struct ib_device *hca) 2102 { 2103 priv->hca_caps = hca->attrs.device_cap_flags; 2104 2105 if (priv->hca_caps & IB_DEVICE_UD_IP_CSUM) { 2106 priv->dev->hw_features = NETIF_F_IP_CSUM | NETIF_F_RXCSUM; 2107 2108 if (priv->hca_caps & IB_DEVICE_UD_TSO) 2109 priv->dev->hw_features |= NETIF_F_TSO; 2110 2111 priv->dev->features |= priv->dev->hw_features; 2112 } 2113 } 2114 2115 static struct net_device *ipoib_add_port(const char *format, 2116 struct ib_device *hca, u8 port) 2117 { 2118 struct ipoib_dev_priv *priv; 2119 struct ib_port_attr attr; 2120 int result = -ENOMEM; 2121 2122 priv = ipoib_intf_alloc(format); 2123 if (!priv) 2124 goto alloc_mem_failed; 2125 2126 SET_NETDEV_DEV(priv->dev, hca->dev.parent); 2127 priv->dev->dev_id = port - 1; 2128 2129 result = ib_query_port(hca, port, &attr); 2130 if (!result) 2131 priv->max_ib_mtu = ib_mtu_enum_to_int(attr.max_mtu); 2132 else { 2133 printk(KERN_WARNING "%s: ib_query_port %d failed\n", 2134 hca->name, port); 2135 goto device_init_failed; 2136 } 2137 2138 /* MTU will be reset when mcast join happens */ 2139 priv->dev->mtu = IPOIB_UD_MTU(priv->max_ib_mtu); 2140 priv->mcast_mtu = priv->admin_mtu = priv->dev->mtu; 2141 priv->dev->max_mtu = IPOIB_CM_MTU; 2142 2143 priv->dev->neigh_priv_len = sizeof(struct ipoib_neigh); 2144 2145 result = ib_query_pkey(hca, port, 0, &priv->pkey); 2146 if (result) { 2147 printk(KERN_WARNING "%s: ib_query_pkey port %d failed (ret = %d)\n", 2148 hca->name, port, result); 2149 goto device_init_failed; 2150 } 2151 2152 ipoib_set_dev_features(priv, hca); 2153 2154 /* 2155 * Set the full membership bit, so that we join the right 2156 * broadcast group, etc. 2157 */ 2158 priv->pkey |= 0x8000; 2159 2160 priv->dev->broadcast[8] = priv->pkey >> 8; 2161 priv->dev->broadcast[9] = priv->pkey & 0xff; 2162 2163 result = ib_query_gid(hca, port, 0, &priv->local_gid, NULL); 2164 if (result) { 2165 printk(KERN_WARNING "%s: ib_query_gid port %d failed (ret = %d)\n", 2166 hca->name, port, result); 2167 goto device_init_failed; 2168 } else 2169 memcpy(priv->dev->dev_addr + 4, priv->local_gid.raw, sizeof (union ib_gid)); 2170 set_bit(IPOIB_FLAG_DEV_ADDR_SET, &priv->flags); 2171 2172 result = ipoib_dev_init(priv->dev, hca, port); 2173 if (result < 0) { 2174 printk(KERN_WARNING "%s: failed to initialize port %d (ret = %d)\n", 2175 hca->name, port, result); 2176 goto device_init_failed; 2177 } 2178 2179 INIT_IB_EVENT_HANDLER(&priv->event_handler, 2180 priv->ca, ipoib_event); 2181 result = ib_register_event_handler(&priv->event_handler); 2182 if (result < 0) { 2183 printk(KERN_WARNING "%s: ib_register_event_handler failed for " 2184 "port %d (ret = %d)\n", 2185 hca->name, port, result); 2186 goto event_failed; 2187 } 2188 2189 result = register_netdev(priv->dev); 2190 if (result) { 2191 printk(KERN_WARNING "%s: couldn't register ipoib port %d; error %d\n", 2192 hca->name, port, result); 2193 goto register_failed; 2194 } 2195 2196 if (ipoib_cm_add_mode_attr(priv->dev)) 2197 goto sysfs_failed; 2198 if (ipoib_add_pkey_attr(priv->dev)) 2199 goto sysfs_failed; 2200 if (ipoib_add_umcast_attr(priv->dev)) 2201 goto sysfs_failed; 2202 if (device_create_file(&priv->dev->dev, &dev_attr_create_child)) 2203 goto sysfs_failed; 2204 if (device_create_file(&priv->dev->dev, &dev_attr_delete_child)) 2205 goto sysfs_failed; 2206 2207 return priv->dev; 2208 2209 sysfs_failed: 2210 unregister_netdev(priv->dev); 2211 2212 register_failed: 2213 ib_unregister_event_handler(&priv->event_handler); 2214 flush_workqueue(ipoib_workqueue); 2215 /* Stop GC if started before flush */ 2216 set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags); 2217 cancel_delayed_work(&priv->neigh_reap_task); 2218 flush_workqueue(priv->wq); 2219 2220 event_failed: 2221 ipoib_dev_cleanup(priv->dev); 2222 2223 device_init_failed: 2224 free_netdev(priv->dev); 2225 2226 alloc_mem_failed: 2227 return ERR_PTR(result); 2228 } 2229 2230 static void ipoib_add_one(struct ib_device *device) 2231 { 2232 struct list_head *dev_list; 2233 struct net_device *dev; 2234 struct ipoib_dev_priv *priv; 2235 int p; 2236 int count = 0; 2237 2238 dev_list = kmalloc(sizeof *dev_list, GFP_KERNEL); 2239 if (!dev_list) 2240 return; 2241 2242 INIT_LIST_HEAD(dev_list); 2243 2244 for (p = rdma_start_port(device); p <= rdma_end_port(device); ++p) { 2245 if (!rdma_protocol_ib(device, p)) 2246 continue; 2247 dev = ipoib_add_port("ib%d", device, p); 2248 if (!IS_ERR(dev)) { 2249 priv = netdev_priv(dev); 2250 list_add_tail(&priv->list, dev_list); 2251 count++; 2252 } 2253 } 2254 2255 if (!count) { 2256 kfree(dev_list); 2257 return; 2258 } 2259 2260 ib_set_client_data(device, &ipoib_client, dev_list); 2261 } 2262 2263 static void ipoib_remove_one(struct ib_device *device, void *client_data) 2264 { 2265 struct ipoib_dev_priv *priv, *tmp; 2266 struct list_head *dev_list = client_data; 2267 2268 if (!dev_list) 2269 return; 2270 2271 list_for_each_entry_safe(priv, tmp, dev_list, list) { 2272 ib_unregister_event_handler(&priv->event_handler); 2273 flush_workqueue(ipoib_workqueue); 2274 2275 /* mark interface in the middle of destruction */ 2276 set_bit(IPOIB_FLAG_GOING_DOWN, &priv->flags); 2277 2278 rtnl_lock(); 2279 dev_change_flags(priv->dev, priv->dev->flags & ~IFF_UP); 2280 rtnl_unlock(); 2281 2282 /* Stop GC */ 2283 set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags); 2284 cancel_delayed_work(&priv->neigh_reap_task); 2285 flush_workqueue(priv->wq); 2286 2287 unregister_netdev(priv->dev); 2288 free_netdev(priv->dev); 2289 } 2290 2291 kfree(dev_list); 2292 } 2293 2294 #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG 2295 static struct notifier_block ipoib_netdev_notifier = { 2296 .notifier_call = ipoib_netdev_event, 2297 }; 2298 #endif 2299 2300 static int __init ipoib_init_module(void) 2301 { 2302 int ret; 2303 2304 ipoib_recvq_size = roundup_pow_of_two(ipoib_recvq_size); 2305 ipoib_recvq_size = min(ipoib_recvq_size, IPOIB_MAX_QUEUE_SIZE); 2306 ipoib_recvq_size = max(ipoib_recvq_size, IPOIB_MIN_QUEUE_SIZE); 2307 2308 ipoib_sendq_size = roundup_pow_of_two(ipoib_sendq_size); 2309 ipoib_sendq_size = min(ipoib_sendq_size, IPOIB_MAX_QUEUE_SIZE); 2310 ipoib_sendq_size = max3(ipoib_sendq_size, 2 * MAX_SEND_CQE, IPOIB_MIN_QUEUE_SIZE); 2311 #ifdef CONFIG_INFINIBAND_IPOIB_CM 2312 ipoib_max_conn_qp = min(ipoib_max_conn_qp, IPOIB_CM_MAX_CONN_QP); 2313 #endif 2314 2315 /* 2316 * When copying small received packets, we only copy from the 2317 * linear data part of the SKB, so we rely on this condition. 2318 */ 2319 BUILD_BUG_ON(IPOIB_CM_COPYBREAK > IPOIB_CM_HEAD_SIZE); 2320 2321 ret = ipoib_register_debugfs(); 2322 if (ret) 2323 return ret; 2324 2325 /* 2326 * We create a global workqueue here that is used for all flush 2327 * operations. However, if you attempt to flush a workqueue 2328 * from a task on that same workqueue, it deadlocks the system. 2329 * We want to be able to flush the tasks associated with a 2330 * specific net device, so we also create a workqueue for each 2331 * netdevice. We queue up the tasks for that device only on 2332 * its private workqueue, and we only queue up flush events 2333 * on our global flush workqueue. This avoids the deadlocks. 2334 */ 2335 ipoib_workqueue = alloc_ordered_workqueue("ipoib_flush", 2336 WQ_MEM_RECLAIM); 2337 if (!ipoib_workqueue) { 2338 ret = -ENOMEM; 2339 goto err_fs; 2340 } 2341 2342 ib_sa_register_client(&ipoib_sa_client); 2343 2344 ret = ib_register_client(&ipoib_client); 2345 if (ret) 2346 goto err_sa; 2347 2348 ret = ipoib_netlink_init(); 2349 if (ret) 2350 goto err_client; 2351 2352 #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG 2353 register_netdevice_notifier(&ipoib_netdev_notifier); 2354 #endif 2355 return 0; 2356 2357 err_client: 2358 ib_unregister_client(&ipoib_client); 2359 2360 err_sa: 2361 ib_sa_unregister_client(&ipoib_sa_client); 2362 destroy_workqueue(ipoib_workqueue); 2363 2364 err_fs: 2365 ipoib_unregister_debugfs(); 2366 2367 return ret; 2368 } 2369 2370 static void __exit ipoib_cleanup_module(void) 2371 { 2372 #ifdef CONFIG_INFINIBAND_IPOIB_DEBUG 2373 unregister_netdevice_notifier(&ipoib_netdev_notifier); 2374 #endif 2375 ipoib_netlink_fini(); 2376 ib_unregister_client(&ipoib_client); 2377 ib_sa_unregister_client(&ipoib_sa_client); 2378 ipoib_unregister_debugfs(); 2379 destroy_workqueue(ipoib_workqueue); 2380 } 2381 2382 module_init(ipoib_init_module); 2383 module_exit(ipoib_cleanup_module); 2384