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 * $Id: ipoib_main.c,v 1.1.1.1 2007/08/03 18:52:32 Exp $ 35 */ 36 37#include "ipoib.h" 38 39#include <linux/module.h> 40 41#include <linux/init.h> 42#include <linux/slab.h> 43#include <linux/kernel.h> 44 45#include <linux/if_arp.h> /* For ARPHRD_xxx */ 46 47#include <linux/ip.h> 48#include <linux/in.h> 49 50#include <net/dst.h> 51 52MODULE_AUTHOR("Roland Dreier"); 53MODULE_DESCRIPTION("IP-over-InfiniBand net driver"); 54MODULE_LICENSE("Dual BSD/GPL"); 55 56int ipoib_sendq_size __read_mostly = IPOIB_TX_RING_SIZE; 57int ipoib_recvq_size __read_mostly = IPOIB_RX_RING_SIZE; 58 59module_param_named(send_queue_size, ipoib_sendq_size, int, 0444); 60MODULE_PARM_DESC(send_queue_size, "Number of descriptors in send queue"); 61module_param_named(recv_queue_size, ipoib_recvq_size, int, 0444); 62MODULE_PARM_DESC(recv_queue_size, "Number of descriptors in receive queue"); 63 64#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG 65int ipoib_debug_level; 66 67module_param_named(debug_level, ipoib_debug_level, int, 0644); 68MODULE_PARM_DESC(debug_level, "Enable debug tracing if > 0"); 69#endif 70 71struct ipoib_path_iter { 72 struct net_device *dev; 73 struct ipoib_path path; 74}; 75 76static const u8 ipv4_bcast_addr[] = { 77 0x00, 0xff, 0xff, 0xff, 78 0xff, 0x12, 0x40, 0x1b, 0x00, 0x00, 0x00, 0x00, 79 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff 80}; 81 82struct workqueue_struct *ipoib_workqueue; 83 84struct ib_sa_client ipoib_sa_client; 85 86static void ipoib_add_one(struct ib_device *device); 87static void ipoib_remove_one(struct ib_device *device); 88 89static struct ib_client ipoib_client = { 90 .name = "ipoib", 91 .add = ipoib_add_one, 92 .remove = ipoib_remove_one 93}; 94 95int ipoib_open(struct net_device *dev) 96{ 97 struct ipoib_dev_priv *priv = netdev_priv(dev); 98 99 ipoib_dbg(priv, "bringing up interface\n"); 100 101 set_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags); 102 103 if (ipoib_pkey_dev_delay_open(dev)) 104 return 0; 105 106 if (ipoib_ib_dev_open(dev)) 107 return -EINVAL; 108 109 if (ipoib_ib_dev_up(dev)) { 110 ipoib_ib_dev_stop(dev, 1); 111 return -EINVAL; 112 } 113 114 if (!test_bit(IPOIB_FLAG_SUBINTERFACE, &priv->flags)) { 115 struct ipoib_dev_priv *cpriv; 116 117 /* Bring up any child interfaces too */ 118 mutex_lock(&priv->vlan_mutex); 119 list_for_each_entry(cpriv, &priv->child_intfs, list) { 120 int flags; 121 122 flags = cpriv->dev->flags; 123 if (flags & IFF_UP) 124 continue; 125 126 dev_change_flags(cpriv->dev, flags | IFF_UP); 127 } 128 mutex_unlock(&priv->vlan_mutex); 129 } 130 131 netif_start_queue(dev); 132 133 return 0; 134} 135 136static int ipoib_stop(struct net_device *dev) 137{ 138 struct ipoib_dev_priv *priv = netdev_priv(dev); 139 140 ipoib_dbg(priv, "stopping interface\n"); 141 142 clear_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags); 143 144 netif_stop_queue(dev); 145 146 clear_bit(IPOIB_FLAG_NETIF_STOPPED, &priv->flags); 147 148 /* 149 * Now flush workqueue to make sure a scheduled task doesn't 150 * bring our internal state back up. 151 */ 152 flush_workqueue(ipoib_workqueue); 153 154 ipoib_ib_dev_down(dev, 1); 155 ipoib_ib_dev_stop(dev, 1); 156 157 if (!test_bit(IPOIB_FLAG_SUBINTERFACE, &priv->flags)) { 158 struct ipoib_dev_priv *cpriv; 159 160 /* Bring down any child interfaces too */ 161 mutex_lock(&priv->vlan_mutex); 162 list_for_each_entry(cpriv, &priv->child_intfs, list) { 163 int flags; 164 165 flags = cpriv->dev->flags; 166 if (!(flags & IFF_UP)) 167 continue; 168 169 dev_change_flags(cpriv->dev, flags & ~IFF_UP); 170 } 171 mutex_unlock(&priv->vlan_mutex); 172 } 173 174 return 0; 175} 176 177static int ipoib_change_mtu(struct net_device *dev, int new_mtu) 178{ 179 struct ipoib_dev_priv *priv = netdev_priv(dev); 180 181 /* dev->mtu > 2K ==> connected mode */ 182 if (ipoib_cm_admin_enabled(dev) && new_mtu <= IPOIB_CM_MTU) { 183 if (new_mtu > priv->mcast_mtu) 184 ipoib_warn(priv, "mtu > %d will cause multicast packet drops.\n", 185 priv->mcast_mtu); 186 dev->mtu = new_mtu; 187 return 0; 188 } 189 190 if (new_mtu > IPOIB_PACKET_SIZE - IPOIB_ENCAP_LEN) { 191 return -EINVAL; 192 } 193 194 priv->admin_mtu = new_mtu; 195 196 dev->mtu = min(priv->mcast_mtu, priv->admin_mtu); 197 198 return 0; 199} 200 201static struct ipoib_path *__path_find(struct net_device *dev, void *gid) 202{ 203 struct ipoib_dev_priv *priv = netdev_priv(dev); 204 struct rb_node *n = priv->path_tree.rb_node; 205 struct ipoib_path *path; 206 int ret; 207 208 while (n) { 209 path = rb_entry(n, struct ipoib_path, rb_node); 210 211 ret = memcmp(gid, path->pathrec.dgid.raw, 212 sizeof (union ib_gid)); 213 214 if (ret < 0) 215 n = n->rb_left; 216 else if (ret > 0) 217 n = n->rb_right; 218 else 219 return path; 220 } 221 222 return NULL; 223} 224 225static int __path_add(struct net_device *dev, struct ipoib_path *path) 226{ 227 struct ipoib_dev_priv *priv = netdev_priv(dev); 228 struct rb_node **n = &priv->path_tree.rb_node; 229 struct rb_node *pn = NULL; 230 struct ipoib_path *tpath; 231 int ret; 232 233 while (*n) { 234 pn = *n; 235 tpath = rb_entry(pn, struct ipoib_path, rb_node); 236 237 ret = memcmp(path->pathrec.dgid.raw, tpath->pathrec.dgid.raw, 238 sizeof (union ib_gid)); 239 if (ret < 0) 240 n = &pn->rb_left; 241 else if (ret > 0) 242 n = &pn->rb_right; 243 else 244 return -EEXIST; 245 } 246 247 rb_link_node(&path->rb_node, pn, n); 248 rb_insert_color(&path->rb_node, &priv->path_tree); 249 250 list_add_tail(&path->list, &priv->path_list); 251 252 return 0; 253} 254 255static void path_free(struct net_device *dev, struct ipoib_path *path) 256{ 257 struct ipoib_dev_priv *priv = netdev_priv(dev); 258 struct ipoib_neigh *neigh, *tn; 259 struct sk_buff *skb; 260 unsigned long flags; 261 262 while ((skb = __skb_dequeue(&path->queue))) 263 dev_kfree_skb_irq(skb); 264 265 spin_lock_irqsave(&priv->lock, flags); 266 267 list_for_each_entry_safe(neigh, tn, &path->neigh_list, list) { 268 /* 269 * It's safe to call ipoib_put_ah() inside priv->lock 270 * here, because we know that path->ah will always 271 * hold one more reference, so ipoib_put_ah() will 272 * never do more than decrement the ref count. 273 */ 274 if (neigh->ah) 275 ipoib_put_ah(neigh->ah); 276 277 ipoib_neigh_free(dev, neigh); 278 } 279 280 spin_unlock_irqrestore(&priv->lock, flags); 281 282 if (path->ah) 283 ipoib_put_ah(path->ah); 284 285 kfree(path); 286} 287 288#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG 289 290struct ipoib_path_iter *ipoib_path_iter_init(struct net_device *dev) 291{ 292 struct ipoib_path_iter *iter; 293 294 iter = kmalloc(sizeof *iter, GFP_KERNEL); 295 if (!iter) 296 return NULL; 297 298 iter->dev = dev; 299 memset(iter->path.pathrec.dgid.raw, 0, 16); 300 301 if (ipoib_path_iter_next(iter)) { 302 kfree(iter); 303 return NULL; 304 } 305 306 return iter; 307} 308 309int ipoib_path_iter_next(struct ipoib_path_iter *iter) 310{ 311 struct ipoib_dev_priv *priv = netdev_priv(iter->dev); 312 struct rb_node *n; 313 struct ipoib_path *path; 314 int ret = 1; 315 316 spin_lock_irq(&priv->lock); 317 318 n = rb_first(&priv->path_tree); 319 320 while (n) { 321 path = rb_entry(n, struct ipoib_path, rb_node); 322 323 if (memcmp(iter->path.pathrec.dgid.raw, path->pathrec.dgid.raw, 324 sizeof (union ib_gid)) < 0) { 325 iter->path = *path; 326 ret = 0; 327 break; 328 } 329 330 n = rb_next(n); 331 } 332 333 spin_unlock_irq(&priv->lock); 334 335 return ret; 336} 337 338void ipoib_path_iter_read(struct ipoib_path_iter *iter, 339 struct ipoib_path *path) 340{ 341 *path = iter->path; 342} 343 344#endif /* CONFIG_INFINIBAND_IPOIB_DEBUG */ 345 346void ipoib_flush_paths(struct net_device *dev) 347{ 348 struct ipoib_dev_priv *priv = netdev_priv(dev); 349 struct ipoib_path *path, *tp; 350 LIST_HEAD(remove_list); 351 352 spin_lock_irq(&priv->tx_lock); 353 spin_lock(&priv->lock); 354 355 list_splice(&priv->path_list, &remove_list); 356 INIT_LIST_HEAD(&priv->path_list); 357 358 list_for_each_entry(path, &remove_list, list) 359 rb_erase(&path->rb_node, &priv->path_tree); 360 361 list_for_each_entry_safe(path, tp, &remove_list, list) { 362 if (path->query) 363 ib_sa_cancel_query(path->query_id, path->query); 364 spin_unlock(&priv->lock); 365 spin_unlock_irq(&priv->tx_lock); 366 wait_for_completion(&path->done); 367 path_free(dev, path); 368 spin_lock_irq(&priv->tx_lock); 369 spin_lock(&priv->lock); 370 } 371 spin_unlock(&priv->lock); 372 spin_unlock_irq(&priv->tx_lock); 373} 374 375static void path_rec_completion(int status, 376 struct ib_sa_path_rec *pathrec, 377 void *path_ptr) 378{ 379 struct ipoib_path *path = path_ptr; 380 struct net_device *dev = path->dev; 381 struct ipoib_dev_priv *priv = netdev_priv(dev); 382 struct ipoib_ah *ah = NULL; 383 struct ipoib_neigh *neigh, *tn; 384 struct sk_buff_head skqueue; 385 struct sk_buff *skb; 386 unsigned long flags; 387 388 if (!status) 389 ipoib_dbg(priv, "PathRec LID 0x%04x for GID " IPOIB_GID_FMT "\n", 390 be16_to_cpu(pathrec->dlid), IPOIB_GID_ARG(pathrec->dgid)); 391 else 392 ipoib_dbg(priv, "PathRec status %d for GID " IPOIB_GID_FMT "\n", 393 status, IPOIB_GID_ARG(path->pathrec.dgid)); 394 395 skb_queue_head_init(&skqueue); 396 397 if (!status) { 398 struct ib_ah_attr av; 399 400 if (!ib_init_ah_from_path(priv->ca, priv->port, pathrec, &av)) 401 ah = ipoib_create_ah(dev, priv->pd, &av); 402 } 403 404 spin_lock_irqsave(&priv->lock, flags); 405 406 path->ah = ah; 407 408 if (ah) { 409 path->pathrec = *pathrec; 410 411 ipoib_dbg(priv, "created address handle %p for LID 0x%04x, SL %d\n", 412 ah, be16_to_cpu(pathrec->dlid), pathrec->sl); 413 414 while ((skb = __skb_dequeue(&path->queue))) 415 __skb_queue_tail(&skqueue, skb); 416 417 list_for_each_entry_safe(neigh, tn, &path->neigh_list, list) { 418 kref_get(&path->ah->ref); 419 neigh->ah = path->ah; 420 memcpy(&neigh->dgid.raw, &path->pathrec.dgid.raw, 421 sizeof(union ib_gid)); 422 423 if (ipoib_cm_enabled(dev, neigh->neighbour)) { 424 if (!ipoib_cm_get(neigh)) 425 ipoib_cm_set(neigh, ipoib_cm_create_tx(dev, 426 path, 427 neigh)); 428 if (!ipoib_cm_get(neigh)) { 429 list_del(&neigh->list); 430 if (neigh->ah) 431 ipoib_put_ah(neigh->ah); 432 ipoib_neigh_free(dev, neigh); 433 continue; 434 } 435 } 436 437 while ((skb = __skb_dequeue(&neigh->queue))) 438 __skb_queue_tail(&skqueue, skb); 439 } 440 } 441 442 path->query = NULL; 443 complete(&path->done); 444 445 spin_unlock_irqrestore(&priv->lock, flags); 446 447 while ((skb = __skb_dequeue(&skqueue))) { 448 skb->dev = dev; 449 if (dev_queue_xmit(skb)) 450 ipoib_warn(priv, "dev_queue_xmit failed " 451 "to requeue packet\n"); 452 } 453} 454 455static struct ipoib_path *path_rec_create(struct net_device *dev, void *gid) 456{ 457 struct ipoib_dev_priv *priv = netdev_priv(dev); 458 struct ipoib_path *path; 459 460 path = kzalloc(sizeof *path, GFP_ATOMIC); 461 if (!path) 462 return NULL; 463 464 path->dev = dev; 465 466 skb_queue_head_init(&path->queue); 467 468 INIT_LIST_HEAD(&path->neigh_list); 469 470 memcpy(path->pathrec.dgid.raw, gid, sizeof (union ib_gid)); 471 path->pathrec.sgid = priv->local_gid; 472 path->pathrec.pkey = cpu_to_be16(priv->pkey); 473 path->pathrec.numb_path = 1; 474 475 return path; 476} 477 478static int path_rec_start(struct net_device *dev, 479 struct ipoib_path *path) 480{ 481 struct ipoib_dev_priv *priv = netdev_priv(dev); 482 483 ipoib_dbg(priv, "Start path record lookup for " IPOIB_GID_FMT "\n", 484 IPOIB_GID_ARG(path->pathrec.dgid)); 485 486 init_completion(&path->done); 487 488 path->query_id = 489 ib_sa_path_rec_get(&ipoib_sa_client, priv->ca, priv->port, 490 &path->pathrec, 491 IB_SA_PATH_REC_DGID | 492 IB_SA_PATH_REC_SGID | 493 IB_SA_PATH_REC_NUMB_PATH | 494 IB_SA_PATH_REC_PKEY, 495 1000, GFP_ATOMIC, 496 path_rec_completion, 497 path, &path->query); 498 if (path->query_id < 0) { 499 ipoib_warn(priv, "ib_sa_path_rec_get failed\n"); 500 path->query = NULL; 501 return path->query_id; 502 } 503 504 return 0; 505} 506 507static void neigh_add_path(struct sk_buff *skb, struct net_device *dev) 508{ 509 struct ipoib_dev_priv *priv = netdev_priv(dev); 510 struct ipoib_path *path; 511 struct ipoib_neigh *neigh; 512 513 neigh = ipoib_neigh_alloc(skb->dst->neighbour); 514 if (!neigh) { 515 ++priv->stats.tx_dropped; 516 dev_kfree_skb_any(skb); 517 return; 518 } 519 520 /* 521 * We can only be called from ipoib_start_xmit, so we're 522 * inside tx_lock -- no need to save/restore flags. 523 */ 524 spin_lock(&priv->lock); 525 526 path = __path_find(dev, skb->dst->neighbour->ha + 4); 527 if (!path) { 528 path = path_rec_create(dev, skb->dst->neighbour->ha + 4); 529 if (!path) 530 goto err_path; 531 532 __path_add(dev, path); 533 } 534 535 list_add_tail(&neigh->list, &path->neigh_list); 536 537 if (path->ah) { 538 kref_get(&path->ah->ref); 539 neigh->ah = path->ah; 540 memcpy(&neigh->dgid.raw, &path->pathrec.dgid.raw, 541 sizeof(union ib_gid)); 542 543 if (ipoib_cm_enabled(dev, neigh->neighbour)) { 544 if (!ipoib_cm_get(neigh)) 545 ipoib_cm_set(neigh, ipoib_cm_create_tx(dev, path, neigh)); 546 if (!ipoib_cm_get(neigh)) { 547 list_del(&neigh->list); 548 if (neigh->ah) 549 ipoib_put_ah(neigh->ah); 550 ipoib_neigh_free(dev, neigh); 551 goto err_drop; 552 } 553 if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE) 554 __skb_queue_tail(&neigh->queue, skb); 555 else { 556 ipoib_warn(priv, "queue length limit %d. Packet drop.\n", 557 skb_queue_len(&neigh->queue)); 558 goto err_drop; 559 } 560 } else 561 ipoib_send(dev, skb, path->ah, IPOIB_QPN(skb->dst->neighbour->ha)); 562 } else { 563 neigh->ah = NULL; 564 565 if (!path->query && path_rec_start(dev, path)) 566 goto err_list; 567 568 __skb_queue_tail(&neigh->queue, skb); 569 } 570 571 spin_unlock(&priv->lock); 572 return; 573 574err_list: 575 list_del(&neigh->list); 576 577err_path: 578 ipoib_neigh_free(dev, neigh); 579err_drop: 580 ++priv->stats.tx_dropped; 581 dev_kfree_skb_any(skb); 582 583 spin_unlock(&priv->lock); 584} 585 586static void ipoib_path_lookup(struct sk_buff *skb, struct net_device *dev) 587{ 588 struct ipoib_dev_priv *priv = netdev_priv(skb->dev); 589 590 /* Look up path record for unicasts */ 591 if (skb->dst->neighbour->ha[4] != 0xff) { 592 neigh_add_path(skb, dev); 593 return; 594 } 595 596 /* Add in the P_Key for multicasts */ 597 skb->dst->neighbour->ha[8] = (priv->pkey >> 8) & 0xff; 598 skb->dst->neighbour->ha[9] = priv->pkey & 0xff; 599 ipoib_mcast_send(dev, skb->dst->neighbour->ha + 4, skb); 600} 601 602static void unicast_arp_send(struct sk_buff *skb, struct net_device *dev, 603 struct ipoib_pseudoheader *phdr) 604{ 605 struct ipoib_dev_priv *priv = netdev_priv(dev); 606 struct ipoib_path *path; 607 608 /* 609 * We can only be called from ipoib_start_xmit, so we're 610 * inside tx_lock -- no need to save/restore flags. 611 */ 612 spin_lock(&priv->lock); 613 614 path = __path_find(dev, phdr->hwaddr + 4); 615 if (!path) { 616 path = path_rec_create(dev, phdr->hwaddr + 4); 617 if (path) { 618 /* put pseudoheader back on for next time */ 619 skb_push(skb, sizeof *phdr); 620 __skb_queue_tail(&path->queue, skb); 621 622 if (path_rec_start(dev, path)) { 623 spin_unlock(&priv->lock); 624 path_free(dev, path); 625 return; 626 } else 627 __path_add(dev, path); 628 } else { 629 ++priv->stats.tx_dropped; 630 dev_kfree_skb_any(skb); 631 } 632 633 spin_unlock(&priv->lock); 634 return; 635 } 636 637 if (path->ah) { 638 ipoib_dbg(priv, "Send unicast ARP to %04x\n", 639 be16_to_cpu(path->pathrec.dlid)); 640 641 ipoib_send(dev, skb, path->ah, IPOIB_QPN(phdr->hwaddr)); 642 } else if ((path->query || !path_rec_start(dev, path)) && 643 skb_queue_len(&path->queue) < IPOIB_MAX_PATH_REC_QUEUE) { 644 /* put pseudoheader back on for next time */ 645 skb_push(skb, sizeof *phdr); 646 __skb_queue_tail(&path->queue, skb); 647 } else { 648 ++priv->stats.tx_dropped; 649 dev_kfree_skb_any(skb); 650 } 651 652 spin_unlock(&priv->lock); 653} 654 655static int ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev) 656{ 657 struct ipoib_dev_priv *priv = netdev_priv(dev); 658 struct ipoib_neigh *neigh; 659 unsigned long flags; 660 661 if (unlikely(!spin_trylock_irqsave(&priv->tx_lock, flags))) 662 return NETDEV_TX_LOCKED; 663 664 /* 665 * Check if our queue is stopped. Since we have the LLTX bit 666 * set, we can't rely on netif_stop_queue() preventing our 667 * xmit function from being called with a full queue. 668 */ 669 if (unlikely(netif_queue_stopped(dev))) { 670 spin_unlock_irqrestore(&priv->tx_lock, flags); 671 return NETDEV_TX_BUSY; 672 } 673 674 if (likely(skb->dst && skb->dst->neighbour)) { 675 if (unlikely(!*to_ipoib_neigh(skb->dst->neighbour))) { 676 ipoib_path_lookup(skb, dev); 677 goto out; 678 } 679 680 neigh = *to_ipoib_neigh(skb->dst->neighbour); 681 682 if (ipoib_cm_get(neigh)) { 683 if (ipoib_cm_up(neigh)) { 684 ipoib_cm_send(dev, skb, ipoib_cm_get(neigh)); 685 goto out; 686 } 687 } else if (neigh->ah) { 688 if (unlikely(memcmp(&neigh->dgid.raw, 689 skb->dst->neighbour->ha + 4, 690 sizeof(union ib_gid)))) { 691 spin_lock(&priv->lock); 692 /* 693 * It's safe to call ipoib_put_ah() inside 694 * priv->lock here, because we know that 695 * path->ah will always hold one more reference, 696 * so ipoib_put_ah() will never do more than 697 * decrement the ref count. 698 */ 699 ipoib_put_ah(neigh->ah); 700 list_del(&neigh->list); 701 ipoib_neigh_free(dev, neigh); 702 spin_unlock(&priv->lock); 703 ipoib_path_lookup(skb, dev); 704 goto out; 705 } 706 707 ipoib_send(dev, skb, neigh->ah, IPOIB_QPN(skb->dst->neighbour->ha)); 708 goto out; 709 } 710 711 if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE) { 712 spin_lock(&priv->lock); 713 __skb_queue_tail(&neigh->queue, skb); 714 spin_unlock(&priv->lock); 715 } else { 716 ++priv->stats.tx_dropped; 717 dev_kfree_skb_any(skb); 718 } 719 } else { 720 struct ipoib_pseudoheader *phdr = 721 (struct ipoib_pseudoheader *) skb->data; 722 skb_pull(skb, sizeof *phdr); 723 724 if (phdr->hwaddr[4] == 0xff) { 725 /* Add in the P_Key for multicast*/ 726 phdr->hwaddr[8] = (priv->pkey >> 8) & 0xff; 727 phdr->hwaddr[9] = priv->pkey & 0xff; 728 729 ipoib_mcast_send(dev, phdr->hwaddr + 4, skb); 730 } else { 731 /* unicast GID -- should be ARP or RARP reply */ 732 733 if ((be16_to_cpup((__be16 *) skb->data) != ETH_P_ARP) && 734 (be16_to_cpup((__be16 *) skb->data) != ETH_P_RARP)) { 735 ipoib_warn(priv, "Unicast, no %s: type %04x, QPN %06x " 736 IPOIB_GID_FMT "\n", 737 skb->dst ? "neigh" : "dst", 738 be16_to_cpup((__be16 *) skb->data), 739 IPOIB_QPN(phdr->hwaddr), 740 IPOIB_GID_RAW_ARG(phdr->hwaddr + 4)); 741 dev_kfree_skb_any(skb); 742 ++priv->stats.tx_dropped; 743 goto out; 744 } 745 746 unicast_arp_send(skb, dev, phdr); 747 } 748 } 749 750out: 751 spin_unlock_irqrestore(&priv->tx_lock, flags); 752 753 return NETDEV_TX_OK; 754} 755 756static struct net_device_stats *ipoib_get_stats(struct net_device *dev) 757{ 758 struct ipoib_dev_priv *priv = netdev_priv(dev); 759 760 return &priv->stats; 761} 762 763static void ipoib_timeout(struct net_device *dev) 764{ 765 struct ipoib_dev_priv *priv = netdev_priv(dev); 766 767 ipoib_warn(priv, "transmit timeout: latency %d msecs\n", 768 jiffies_to_msecs(jiffies - dev->trans_start)); 769 ipoib_warn(priv, "queue stopped %d, tx_head %u, tx_tail %u\n", 770 netif_queue_stopped(dev), 771 priv->tx_head, priv->tx_tail); 772} 773 774static int ipoib_hard_header(struct sk_buff *skb, 775 struct net_device *dev, 776 unsigned short type, 777 void *daddr, void *saddr, unsigned len) 778{ 779 struct ipoib_header *header; 780 781 header = (struct ipoib_header *) skb_push(skb, sizeof *header); 782 783 header->proto = htons(type); 784 header->reserved = 0; 785 786 /* 787 * If we don't have a neighbour structure, stuff the 788 * destination address onto the front of the skb so we can 789 * figure out where to send the packet later. 790 */ 791 if ((!skb->dst || !skb->dst->neighbour) && daddr) { 792 struct ipoib_pseudoheader *phdr = 793 (struct ipoib_pseudoheader *) skb_push(skb, sizeof *phdr); 794 memcpy(phdr->hwaddr, daddr, INFINIBAND_ALEN); 795 } 796 797 return 0; 798} 799 800static void ipoib_set_mcast_list(struct net_device *dev) 801{ 802 struct ipoib_dev_priv *priv = netdev_priv(dev); 803 804 if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) { 805 ipoib_dbg(priv, "IPOIB_FLAG_OPER_UP not set"); 806 return; 807 } 808 809 queue_work(ipoib_workqueue, &priv->restart_task); 810} 811 812static void ipoib_neigh_cleanup(struct neighbour *n) 813{ 814 struct ipoib_neigh *neigh; 815 struct ipoib_dev_priv *priv = netdev_priv(n->dev); 816 unsigned long flags; 817 struct ipoib_ah *ah = NULL; 818 819 ipoib_dbg(priv, 820 "neigh_cleanup for %06x " IPOIB_GID_FMT "\n", 821 IPOIB_QPN(n->ha), 822 IPOIB_GID_RAW_ARG(n->ha + 4)); 823 824 spin_lock_irqsave(&priv->lock, flags); 825 826 neigh = *to_ipoib_neigh(n); 827 if (neigh) { 828 if (neigh->ah) 829 ah = neigh->ah; 830 list_del(&neigh->list); 831 ipoib_neigh_free(n->dev, neigh); 832 } 833 834 spin_unlock_irqrestore(&priv->lock, flags); 835 836 if (ah) 837 ipoib_put_ah(ah); 838} 839 840struct ipoib_neigh *ipoib_neigh_alloc(struct neighbour *neighbour) 841{ 842 struct ipoib_neigh *neigh; 843 844 neigh = kmalloc(sizeof *neigh, GFP_ATOMIC); 845 if (!neigh) 846 return NULL; 847 848 neigh->neighbour = neighbour; 849 *to_ipoib_neigh(neighbour) = neigh; 850 skb_queue_head_init(&neigh->queue); 851 ipoib_cm_set(neigh, NULL); 852 853 return neigh; 854} 855 856void ipoib_neigh_free(struct net_device *dev, struct ipoib_neigh *neigh) 857{ 858 struct ipoib_dev_priv *priv = netdev_priv(dev); 859 struct sk_buff *skb; 860 *to_ipoib_neigh(neigh->neighbour) = NULL; 861 while ((skb = __skb_dequeue(&neigh->queue))) { 862 ++priv->stats.tx_dropped; 863 dev_kfree_skb_any(skb); 864 } 865 if (ipoib_cm_get(neigh)) 866 ipoib_cm_destroy_tx(ipoib_cm_get(neigh)); 867 kfree(neigh); 868} 869 870static int ipoib_neigh_setup_dev(struct net_device *dev, struct neigh_parms *parms) 871{ 872 parms->neigh_cleanup = ipoib_neigh_cleanup; 873 874 return 0; 875} 876 877int ipoib_dev_init(struct net_device *dev, struct ib_device *ca, int port) 878{ 879 struct ipoib_dev_priv *priv = netdev_priv(dev); 880 881 /* Allocate RX/TX "rings" to hold queued skbs */ 882 priv->rx_ring = kzalloc(ipoib_recvq_size * sizeof *priv->rx_ring, 883 GFP_KERNEL); 884 if (!priv->rx_ring) { 885 printk(KERN_WARNING "%s: failed to allocate RX ring (%d entries)\n", 886 ca->name, ipoib_recvq_size); 887 goto out; 888 } 889 890 priv->tx_ring = kzalloc(ipoib_sendq_size * sizeof *priv->tx_ring, 891 GFP_KERNEL); 892 if (!priv->tx_ring) { 893 printk(KERN_WARNING "%s: failed to allocate TX ring (%d entries)\n", 894 ca->name, ipoib_sendq_size); 895 goto out_rx_ring_cleanup; 896 } 897 898 /* priv->tx_head & tx_tail are already 0 */ 899 900 if (ipoib_ib_dev_init(dev, ca, port)) 901 goto out_tx_ring_cleanup; 902 903 return 0; 904 905out_tx_ring_cleanup: 906 kfree(priv->tx_ring); 907 908out_rx_ring_cleanup: 909 kfree(priv->rx_ring); 910 911out: 912 return -ENOMEM; 913} 914 915void ipoib_dev_cleanup(struct net_device *dev) 916{ 917 struct ipoib_dev_priv *priv = netdev_priv(dev), *cpriv, *tcpriv; 918 919 ipoib_delete_debug_files(dev); 920 921 /* Delete any child interfaces first */ 922 list_for_each_entry_safe(cpriv, tcpriv, &priv->child_intfs, list) { 923 unregister_netdev(cpriv->dev); 924 ipoib_dev_cleanup(cpriv->dev); 925 free_netdev(cpriv->dev); 926 } 927 928 ipoib_ib_dev_cleanup(dev); 929 930 kfree(priv->rx_ring); 931 kfree(priv->tx_ring); 932 933 priv->rx_ring = NULL; 934 priv->tx_ring = NULL; 935} 936 937static void ipoib_setup(struct net_device *dev) 938{ 939 struct ipoib_dev_priv *priv = netdev_priv(dev); 940 941 dev->open = ipoib_open; 942 dev->stop = ipoib_stop; 943 dev->change_mtu = ipoib_change_mtu; 944 dev->hard_start_xmit = ipoib_start_xmit; 945 dev->get_stats = ipoib_get_stats; 946 dev->tx_timeout = ipoib_timeout; 947 dev->hard_header = ipoib_hard_header; 948 dev->set_multicast_list = ipoib_set_mcast_list; 949 dev->neigh_setup = ipoib_neigh_setup_dev; 950 dev->poll = ipoib_poll; 951 dev->weight = 100; 952 953 dev->watchdog_timeo = HZ; 954 955 dev->flags |= IFF_BROADCAST | IFF_MULTICAST; 956 957 /* 958 * We add in INFINIBAND_ALEN to allow for the destination 959 * address "pseudoheader" for skbs without neighbour struct. 960 */ 961 dev->hard_header_len = IPOIB_ENCAP_LEN + INFINIBAND_ALEN; 962 dev->addr_len = INFINIBAND_ALEN; 963 dev->type = ARPHRD_INFINIBAND; 964 dev->tx_queue_len = ipoib_sendq_size * 2; 965 dev->features = NETIF_F_VLAN_CHALLENGED | NETIF_F_LLTX; 966 967 /* MTU will be reset when mcast join happens */ 968 dev->mtu = IPOIB_PACKET_SIZE - IPOIB_ENCAP_LEN; 969 priv->mcast_mtu = priv->admin_mtu = dev->mtu; 970 971 memcpy(dev->broadcast, ipv4_bcast_addr, INFINIBAND_ALEN); 972 973 netif_carrier_off(dev); 974 975 SET_MODULE_OWNER(dev); 976 977 priv->dev = dev; 978 979 spin_lock_init(&priv->lock); 980 spin_lock_init(&priv->tx_lock); 981 982 mutex_init(&priv->mcast_mutex); 983 mutex_init(&priv->vlan_mutex); 984 985 INIT_LIST_HEAD(&priv->path_list); 986 INIT_LIST_HEAD(&priv->child_intfs); 987 INIT_LIST_HEAD(&priv->dead_ahs); 988 INIT_LIST_HEAD(&priv->multicast_list); 989 990 INIT_DELAYED_WORK(&priv->pkey_poll_task, ipoib_pkey_poll); 991 INIT_WORK(&priv->pkey_event_task, ipoib_pkey_event); 992 INIT_DELAYED_WORK(&priv->mcast_task, ipoib_mcast_join_task); 993 INIT_WORK(&priv->flush_task, ipoib_ib_dev_flush); 994 INIT_WORK(&priv->restart_task, ipoib_mcast_restart_task); 995 INIT_DELAYED_WORK(&priv->ah_reap_task, ipoib_reap_ah); 996} 997 998struct ipoib_dev_priv *ipoib_intf_alloc(const char *name) 999{ 1000 struct net_device *dev; 1001 1002 dev = alloc_netdev((int) sizeof (struct ipoib_dev_priv), name, 1003 ipoib_setup); 1004 if (!dev) 1005 return NULL; 1006 1007 return netdev_priv(dev); 1008} 1009 1010static ssize_t show_pkey(struct device *dev, 1011 struct device_attribute *attr, char *buf) 1012{ 1013 struct ipoib_dev_priv *priv = netdev_priv(to_net_dev(dev)); 1014 1015 return sprintf(buf, "0x%04x\n", priv->pkey); 1016} 1017static DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL); 1018 1019static ssize_t create_child(struct device *dev, 1020 struct device_attribute *attr, 1021 const char *buf, size_t count) 1022{ 1023 int pkey; 1024 int ret; 1025 1026 if (sscanf(buf, "%i", &pkey) != 1) 1027 return -EINVAL; 1028 1029 if (pkey < 0 || pkey > 0xffff) 1030 return -EINVAL; 1031 1032 /* 1033 * Set the full membership bit, so that we join the right 1034 * broadcast group, etc. 1035 */ 1036 pkey |= 0x8000; 1037 1038 ret = ipoib_vlan_add(to_net_dev(dev), pkey); 1039 1040 return ret ? ret : count; 1041} 1042static DEVICE_ATTR(create_child, S_IWUGO, NULL, create_child); 1043 1044static ssize_t delete_child(struct device *dev, 1045 struct device_attribute *attr, 1046 const char *buf, size_t count) 1047{ 1048 int pkey; 1049 int ret; 1050 1051 if (sscanf(buf, "%i", &pkey) != 1) 1052 return -EINVAL; 1053 1054 if (pkey < 0 || pkey > 0xffff) 1055 return -EINVAL; 1056 1057 ret = ipoib_vlan_delete(to_net_dev(dev), pkey); 1058 1059 return ret ? ret : count; 1060 1061} 1062static DEVICE_ATTR(delete_child, S_IWUGO, NULL, delete_child); 1063 1064int ipoib_add_pkey_attr(struct net_device *dev) 1065{ 1066 return device_create_file(&dev->dev, &dev_attr_pkey); 1067} 1068 1069static struct net_device *ipoib_add_port(const char *format, 1070 struct ib_device *hca, u8 port) 1071{ 1072 struct ipoib_dev_priv *priv; 1073 int result = -ENOMEM; 1074 1075 priv = ipoib_intf_alloc(format); 1076 if (!priv) 1077 goto alloc_mem_failed; 1078 1079 SET_NETDEV_DEV(priv->dev, hca->dma_device); 1080 1081 result = ib_query_pkey(hca, port, 0, &priv->pkey); 1082 if (result) { 1083 printk(KERN_WARNING "%s: ib_query_pkey port %d failed (ret = %d)\n", 1084 hca->name, port, result); 1085 goto alloc_mem_failed; 1086 } 1087 1088 /* 1089 * Set the full membership bit, so that we join the right 1090 * broadcast group, etc. 1091 */ 1092 priv->pkey |= 0x8000; 1093 1094 priv->dev->broadcast[8] = priv->pkey >> 8; 1095 priv->dev->broadcast[9] = priv->pkey & 0xff; 1096 1097 result = ib_query_gid(hca, port, 0, &priv->local_gid); 1098 if (result) { 1099 printk(KERN_WARNING "%s: ib_query_gid port %d failed (ret = %d)\n", 1100 hca->name, port, result); 1101 goto alloc_mem_failed; 1102 } else 1103 memcpy(priv->dev->dev_addr + 4, priv->local_gid.raw, sizeof (union ib_gid)); 1104 1105 1106 result = ipoib_dev_init(priv->dev, hca, port); 1107 if (result < 0) { 1108 printk(KERN_WARNING "%s: failed to initialize port %d (ret = %d)\n", 1109 hca->name, port, result); 1110 goto device_init_failed; 1111 } 1112 1113 INIT_IB_EVENT_HANDLER(&priv->event_handler, 1114 priv->ca, ipoib_event); 1115 result = ib_register_event_handler(&priv->event_handler); 1116 if (result < 0) { 1117 printk(KERN_WARNING "%s: ib_register_event_handler failed for " 1118 "port %d (ret = %d)\n", 1119 hca->name, port, result); 1120 goto event_failed; 1121 } 1122 1123 result = register_netdev(priv->dev); 1124 if (result) { 1125 printk(KERN_WARNING "%s: couldn't register ipoib port %d; error %d\n", 1126 hca->name, port, result); 1127 goto register_failed; 1128 } 1129 1130 ipoib_create_debug_files(priv->dev); 1131 1132 if (ipoib_cm_add_mode_attr(priv->dev)) 1133 goto sysfs_failed; 1134 if (ipoib_add_pkey_attr(priv->dev)) 1135 goto sysfs_failed; 1136 if (device_create_file(&priv->dev->dev, &dev_attr_create_child)) 1137 goto sysfs_failed; 1138 if (device_create_file(&priv->dev->dev, &dev_attr_delete_child)) 1139 goto sysfs_failed; 1140 1141 return priv->dev; 1142 1143sysfs_failed: 1144 ipoib_delete_debug_files(priv->dev); 1145 unregister_netdev(priv->dev); 1146 1147register_failed: 1148 ib_unregister_event_handler(&priv->event_handler); 1149 flush_scheduled_work(); 1150 1151event_failed: 1152 ipoib_dev_cleanup(priv->dev); 1153 1154device_init_failed: 1155 free_netdev(priv->dev); 1156 1157alloc_mem_failed: 1158 return ERR_PTR(result); 1159} 1160 1161static void ipoib_add_one(struct ib_device *device) 1162{ 1163 struct list_head *dev_list; 1164 struct net_device *dev; 1165 struct ipoib_dev_priv *priv; 1166 int s, e, p; 1167 1168 if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB) 1169 return; 1170 1171 dev_list = kmalloc(sizeof *dev_list, GFP_KERNEL); 1172 if (!dev_list) 1173 return; 1174 1175 INIT_LIST_HEAD(dev_list); 1176 1177 if (device->node_type == RDMA_NODE_IB_SWITCH) { 1178 s = 0; 1179 e = 0; 1180 } else { 1181 s = 1; 1182 e = device->phys_port_cnt; 1183 } 1184 1185 for (p = s; p <= e; ++p) { 1186 dev = ipoib_add_port("ib%d", device, p); 1187 if (!IS_ERR(dev)) { 1188 priv = netdev_priv(dev); 1189 list_add_tail(&priv->list, dev_list); 1190 } 1191 } 1192 1193 ib_set_client_data(device, &ipoib_client, dev_list); 1194} 1195 1196static void ipoib_remove_one(struct ib_device *device) 1197{ 1198 struct ipoib_dev_priv *priv, *tmp; 1199 struct list_head *dev_list; 1200 1201 if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB) 1202 return; 1203 1204 dev_list = ib_get_client_data(device, &ipoib_client); 1205 1206 list_for_each_entry_safe(priv, tmp, dev_list, list) { 1207 ib_unregister_event_handler(&priv->event_handler); 1208 flush_scheduled_work(); 1209 1210 unregister_netdev(priv->dev); 1211 ipoib_dev_cleanup(priv->dev); 1212 free_netdev(priv->dev); 1213 } 1214 1215 kfree(dev_list); 1216} 1217 1218static int __init ipoib_init_module(void) 1219{ 1220 int ret; 1221 1222 ipoib_recvq_size = roundup_pow_of_two(ipoib_recvq_size); 1223 ipoib_recvq_size = min(ipoib_recvq_size, IPOIB_MAX_QUEUE_SIZE); 1224 ipoib_recvq_size = max(ipoib_recvq_size, IPOIB_MIN_QUEUE_SIZE); 1225 1226 ipoib_sendq_size = roundup_pow_of_two(ipoib_sendq_size); 1227 ipoib_sendq_size = min(ipoib_sendq_size, IPOIB_MAX_QUEUE_SIZE); 1228 ipoib_sendq_size = max(ipoib_sendq_size, IPOIB_MIN_QUEUE_SIZE); 1229 1230 ret = ipoib_register_debugfs(); 1231 if (ret) 1232 return ret; 1233 1234 /* 1235 * We create our own workqueue mainly because we want to be 1236 * able to flush it when devices are being removed. We can't 1237 * use schedule_work()/flush_scheduled_work() because both 1238 * unregister_netdev() and linkwatch_event take the rtnl lock, 1239 * so flush_scheduled_work() can deadlock during device 1240 * removal. 1241 */ 1242 ipoib_workqueue = create_singlethread_workqueue("ipoib"); 1243 if (!ipoib_workqueue) { 1244 ret = -ENOMEM; 1245 goto err_fs; 1246 } 1247 1248 ib_sa_register_client(&ipoib_sa_client); 1249 1250 ret = ib_register_client(&ipoib_client); 1251 if (ret) 1252 goto err_sa; 1253 1254 return 0; 1255 1256err_sa: 1257 ib_sa_unregister_client(&ipoib_sa_client); 1258 destroy_workqueue(ipoib_workqueue); 1259 1260err_fs: 1261 ipoib_unregister_debugfs(); 1262 1263 return ret; 1264} 1265 1266static void __exit ipoib_cleanup_module(void) 1267{ 1268 ib_unregister_client(&ipoib_client); 1269 ib_sa_unregister_client(&ipoib_sa_client); 1270 ipoib_unregister_debugfs(); 1271 destroy_workqueue(ipoib_workqueue); 1272} 1273 1274module_init(ipoib_init_module); 1275module_exit(ipoib_cleanup_module); 1276