ipoib_main.c 58.5 KB
Newer Older
L
Linus Torvalds 已提交
1 2
/*
 * Copyright (c) 2004 Topspin Communications.  All rights reserved.
3 4
 * Copyright (c) 2005 Sun Microsystems, Inc. All rights reserved.
 * Copyright (c) 2004 Voltaire, Inc. All rights reserved.
L
Linus Torvalds 已提交
5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40
 *
 * This software is available to you under a choice of one of two
 * licenses.  You may choose to be licensed under the terms of the GNU
 * General Public License (GPL) Version 2, available from the file
 * COPYING in the main directory of this source tree, or the
 * OpenIB.org BSD license below:
 *
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
 *
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
 *
 *      - Redistributions in binary form must reproduce the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer in the documentation and/or other materials
 *        provided with the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 * SOFTWARE.
 */

#include "ipoib.h"

#include <linux/module.h>

#include <linux/init.h>
#include <linux/slab.h>
41
#include <linux/kernel.h>
42
#include <linux/vmalloc.h>
L
Linus Torvalds 已提交
43 44 45 46 47 48

#include <linux/if_arp.h>	/* For ARPHRD_xxx */

#include <linux/ip.h>
#include <linux/in.h>

49 50
#include <linux/jhash.h>
#include <net/arp.h>
51 52 53
#include <net/addrconf.h>
#include <linux/inetdevice.h>
#include <rdma/ib_cache.h>
54
#include <linux/pci.h>
55

56 57 58 59
#define DRV_VERSION "1.0.0"

const char ipoib_driver_version[] = DRV_VERSION;

L
Linus Torvalds 已提交
60 61 62
MODULE_AUTHOR("Roland Dreier");
MODULE_DESCRIPTION("IP-over-InfiniBand net driver");
MODULE_LICENSE("Dual BSD/GPL");
63
MODULE_VERSION(DRV_VERSION);
L
Linus Torvalds 已提交
64

65 66 67 68 69 70 71 72
int ipoib_sendq_size __read_mostly = IPOIB_TX_RING_SIZE;
int ipoib_recvq_size __read_mostly = IPOIB_RX_RING_SIZE;

module_param_named(send_queue_size, ipoib_sendq_size, int, 0444);
MODULE_PARM_DESC(send_queue_size, "Number of descriptors in send queue");
module_param_named(recv_queue_size, ipoib_recvq_size, int, 0444);
MODULE_PARM_DESC(recv_queue_size, "Number of descriptors in receive queue");

L
Linus Torvalds 已提交
73 74 75 76 77 78 79
#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
int ipoib_debug_level;

module_param_named(debug_level, ipoib_debug_level, int, 0644);
MODULE_PARM_DESC(debug_level, "Enable debug tracing if > 0");
#endif

80 81 82 83 84
struct ipoib_path_iter {
	struct net_device *dev;
	struct ipoib_path  path;
};

L
Linus Torvalds 已提交
85 86 87 88 89 90 91 92
static const u8 ipv4_bcast_addr[] = {
	0x00, 0xff, 0xff, 0xff,
	0xff, 0x12, 0x40, 0x1b,	0x00, 0x00, 0x00, 0x00,
	0x00, 0x00, 0x00, 0x00,	0xff, 0xff, 0xff, 0xff
};

struct workqueue_struct *ipoib_workqueue;

93 94
struct ib_sa_client ipoib_sa_client;

L
Linus Torvalds 已提交
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 99 100 101
static struct net_device *ipoib_get_net_dev_by_params(
		struct ib_device *dev, u8 port, u16 pkey,
		const union ib_gid *gid, const struct sockaddr *addr,
		void *client_data);
102
static int ipoib_set_mac(struct net_device *dev, void *addr);
L
Linus Torvalds 已提交
103 104 105 106

static struct ib_client ipoib_client = {
	.name   = "ipoib",
	.add    = ipoib_add_one,
107 108
	.remove = ipoib_remove_one,
	.get_net_dev_by_params = ipoib_get_net_dev_by_params,
L
Linus Torvalds 已提交
109 110
};

111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137
#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
static int ipoib_netdev_event(struct notifier_block *this,
			      unsigned long event, void *ptr)
{
	struct netdev_notifier_info *ni = ptr;
	struct net_device *dev = ni->dev;

	if (dev->netdev_ops->ndo_open != ipoib_open)
		return NOTIFY_DONE;

	switch (event) {
	case NETDEV_REGISTER:
		ipoib_create_debug_files(dev);
		break;
	case NETDEV_CHANGENAME:
		ipoib_delete_debug_files(dev);
		ipoib_create_debug_files(dev);
		break;
	case NETDEV_UNREGISTER:
		ipoib_delete_debug_files(dev);
		break;
	}

	return NOTIFY_DONE;
}
#endif

L
Linus Torvalds 已提交
138 139 140 141 142 143
int ipoib_open(struct net_device *dev)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

	ipoib_dbg(priv, "bringing up interface\n");

144 145
	netif_carrier_off(dev);

146
	set_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags);
L
Linus Torvalds 已提交
147

148 149
	priv->sm_fullmember_sendonly_support = false;

150
	if (ipoib_ib_dev_open(dev)) {
151 152
		if (!test_bit(IPOIB_PKEY_ASSIGNED, &priv->flags))
			return 0;
153
		goto err_disable;
154
	}
155

156
	ipoib_ib_dev_up(dev);
L
Linus Torvalds 已提交
157 158 159 160 161

	if (!test_bit(IPOIB_FLAG_SUBINTERFACE, &priv->flags)) {
		struct ipoib_dev_priv *cpriv;

		/* Bring up any child interfaces too */
162
		down_read(&priv->vlan_rwsem);
L
Linus Torvalds 已提交
163 164 165 166 167 168 169 170 171
		list_for_each_entry(cpriv, &priv->child_intfs, list) {
			int flags;

			flags = cpriv->dev->flags;
			if (flags & IFF_UP)
				continue;

			dev_change_flags(cpriv->dev, flags | IFF_UP);
		}
172
		up_read(&priv->vlan_rwsem);
L
Linus Torvalds 已提交
173 174 175 176 177
	}

	netif_start_queue(dev);

	return 0;
178 179 180 181 182

err_disable:
	clear_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags);

	return -EINVAL;
L
Linus Torvalds 已提交
183 184 185 186 187 188 189 190 191 192 193 194
}

static int ipoib_stop(struct net_device *dev)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

	ipoib_dbg(priv, "stopping interface\n");

	clear_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags);

	netif_stop_queue(dev);

195
	ipoib_ib_dev_down(dev);
196
	ipoib_ib_dev_stop_default(dev);
L
Linus Torvalds 已提交
197 198 199 200 201

	if (!test_bit(IPOIB_FLAG_SUBINTERFACE, &priv->flags)) {
		struct ipoib_dev_priv *cpriv;

		/* Bring down any child interfaces too */
202
		down_read(&priv->vlan_rwsem);
L
Linus Torvalds 已提交
203 204 205 206 207 208 209 210 211
		list_for_each_entry(cpriv, &priv->child_intfs, list) {
			int flags;

			flags = cpriv->dev->flags;
			if (!(flags & IFF_UP))
				continue;

			dev_change_flags(cpriv->dev, flags & ~IFF_UP);
		}
212
		up_read(&priv->vlan_rwsem);
L
Linus Torvalds 已提交
213 214 215 216 217
	}

	return 0;
}

O
Or Gerlitz 已提交
218 219 220 221 222
static void ipoib_uninit(struct net_device *dev)
{
	ipoib_dev_cleanup(dev);
}

223
static netdev_features_t ipoib_fix_features(struct net_device *dev, netdev_features_t features)
224 225 226 227
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

	if (test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags))
228
		features &= ~(NETIF_F_IP_CSUM | NETIF_F_TSO);
229 230 231 232

	return features;
}

L
Linus Torvalds 已提交
233 234 235 236
static int ipoib_change_mtu(struct net_device *dev, int new_mtu)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

237
	/* dev->mtu > 2K ==> connected mode */
238 239 240 241
	if (ipoib_cm_admin_enabled(dev)) {
		if (new_mtu > ipoib_cm_max_mtu(dev))
			return -EINVAL;

242 243 244
		if (new_mtu > priv->mcast_mtu)
			ipoib_warn(priv, "mtu > %d will cause multicast packet drops.\n",
				   priv->mcast_mtu);
245

246 247 248 249
		dev->mtu = new_mtu;
		return 0;
	}

250
	if (new_mtu > IPOIB_UD_MTU(priv->max_ib_mtu))
L
Linus Torvalds 已提交
251 252 253 254
		return -EINVAL;

	priv->admin_mtu = new_mtu;

255 256 257 258
	if (priv->mcast_mtu < priv->admin_mtu)
		ipoib_dbg(priv, "MTU must be smaller than the underlying "
				"link layer MTU - 4 (%u)\n", priv->mcast_mtu);

L
Linus Torvalds 已提交
259 260 261 262 263
	dev->mtu = min(priv->mcast_mtu, priv->admin_mtu);

	return 0;
}

264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321
/* Called with an RCU read lock taken */
static bool ipoib_is_dev_match_addr_rcu(const struct sockaddr *addr,
					struct net_device *dev)
{
	struct net *net = dev_net(dev);
	struct in_device *in_dev;
	struct sockaddr_in *addr_in = (struct sockaddr_in *)addr;
	struct sockaddr_in6 *addr_in6 = (struct sockaddr_in6 *)addr;
	__be32 ret_addr;

	switch (addr->sa_family) {
	case AF_INET:
		in_dev = in_dev_get(dev);
		if (!in_dev)
			return false;

		ret_addr = inet_confirm_addr(net, in_dev, 0,
					     addr_in->sin_addr.s_addr,
					     RT_SCOPE_HOST);
		in_dev_put(in_dev);
		if (ret_addr)
			return true;

		break;
	case AF_INET6:
		if (IS_ENABLED(CONFIG_IPV6) &&
		    ipv6_chk_addr(net, &addr_in6->sin6_addr, dev, 1))
			return true;

		break;
	}
	return false;
}

/**
 * Find the master net_device on top of the given net_device.
 * @dev: base IPoIB net_device
 *
 * Returns the master net_device with a reference held, or the same net_device
 * if no master exists.
 */
static struct net_device *ipoib_get_master_net_dev(struct net_device *dev)
{
	struct net_device *master;

	rcu_read_lock();
	master = netdev_master_upper_dev_get_rcu(dev);
	if (master)
		dev_hold(master);
	rcu_read_unlock();

	if (master)
		return master;

	dev_hold(dev);
	return dev;
}

D
David Ahern 已提交
322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
struct ipoib_walk_data {
	const struct sockaddr *addr;
	struct net_device *result;
};

static int ipoib_upper_walk(struct net_device *upper, void *_data)
{
	struct ipoib_walk_data *data = _data;
	int ret = 0;

	if (ipoib_is_dev_match_addr_rcu(data->addr, upper)) {
		dev_hold(upper);
		data->result = upper;
		ret = 1;
	}

	return ret;
}

341 342 343 344 345 346 347 348 349 350 351 352
/**
 * Find a net_device matching the given address, which is an upper device of
 * the given net_device.
 * @addr: IP address to look for.
 * @dev: base IPoIB net_device
 *
 * If found, returns the net_device with a reference held. Otherwise return
 * NULL.
 */
static struct net_device *ipoib_get_net_dev_match_addr(
		const struct sockaddr *addr, struct net_device *dev)
{
D
David Ahern 已提交
353 354 355
	struct ipoib_walk_data data = {
		.addr = addr,
	};
356 357 358 359

	rcu_read_lock();
	if (ipoib_is_dev_match_addr_rcu(addr, dev)) {
		dev_hold(dev);
D
David Ahern 已提交
360
		data.result = dev;
361 362 363
		goto out;
	}

D
David Ahern 已提交
364
	netdev_walk_all_upper_dev_rcu(dev, ipoib_upper_walk, &data);
365 366
out:
	rcu_read_unlock();
D
David Ahern 已提交
367
	return data.result;
368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490 491 492 493 494 495
}

/* returns the number of IPoIB netdevs on top a given ipoib device matching a
 * pkey_index and address, if one exists.
 *
 * @found_net_dev: contains a matching net_device if the return value >= 1,
 * with a reference held. */
static int ipoib_match_gid_pkey_addr(struct ipoib_dev_priv *priv,
				     const union ib_gid *gid,
				     u16 pkey_index,
				     const struct sockaddr *addr,
				     int nesting,
				     struct net_device **found_net_dev)
{
	struct ipoib_dev_priv *child_priv;
	struct net_device *net_dev = NULL;
	int matches = 0;

	if (priv->pkey_index == pkey_index &&
	    (!gid || !memcmp(gid, &priv->local_gid, sizeof(*gid)))) {
		if (!addr) {
			net_dev = ipoib_get_master_net_dev(priv->dev);
		} else {
			/* Verify the net_device matches the IP address, as
			 * IPoIB child devices currently share a GID. */
			net_dev = ipoib_get_net_dev_match_addr(addr, priv->dev);
		}
		if (net_dev) {
			if (!*found_net_dev)
				*found_net_dev = net_dev;
			else
				dev_put(net_dev);
			++matches;
		}
	}

	/* Check child interfaces */
	down_read_nested(&priv->vlan_rwsem, nesting);
	list_for_each_entry(child_priv, &priv->child_intfs, list) {
		matches += ipoib_match_gid_pkey_addr(child_priv, gid,
						    pkey_index, addr,
						    nesting + 1,
						    found_net_dev);
		if (matches > 1)
			break;
	}
	up_read(&priv->vlan_rwsem);

	return matches;
}

/* Returns the number of matching net_devs found (between 0 and 2). Also
 * return the matching net_device in the @net_dev parameter, holding a
 * reference to the net_device, if the number of matches >= 1 */
static int __ipoib_get_net_dev_by_params(struct list_head *dev_list, u8 port,
					 u16 pkey_index,
					 const union ib_gid *gid,
					 const struct sockaddr *addr,
					 struct net_device **net_dev)
{
	struct ipoib_dev_priv *priv;
	int matches = 0;

	*net_dev = NULL;

	list_for_each_entry(priv, dev_list, list) {
		if (priv->port != port)
			continue;

		matches += ipoib_match_gid_pkey_addr(priv, gid, pkey_index,
						     addr, 0, net_dev);
		if (matches > 1)
			break;
	}

	return matches;
}

static struct net_device *ipoib_get_net_dev_by_params(
		struct ib_device *dev, u8 port, u16 pkey,
		const union ib_gid *gid, const struct sockaddr *addr,
		void *client_data)
{
	struct net_device *net_dev;
	struct list_head *dev_list = client_data;
	u16 pkey_index;
	int matches;
	int ret;

	if (!rdma_protocol_ib(dev, port))
		return NULL;

	ret = ib_find_cached_pkey(dev, port, pkey, &pkey_index);
	if (ret)
		return NULL;

	if (!dev_list)
		return NULL;

	/* See if we can find a unique device matching the L2 parameters */
	matches = __ipoib_get_net_dev_by_params(dev_list, port, pkey_index,
						gid, NULL, &net_dev);

	switch (matches) {
	case 0:
		return NULL;
	case 1:
		return net_dev;
	}

	dev_put(net_dev);

	/* Couldn't find a unique device with L2 parameters only. Use L3
	 * address to uniquely match the net device */
	matches = __ipoib_get_net_dev_by_params(dev_list, port, pkey_index,
						gid, addr, &net_dev);
	switch (matches) {
	case 0:
		return NULL;
	default:
		dev_warn_ratelimited(&dev->dev,
				     "duplicate IP address detected\n");
		/* Fall through */
	case 1:
		return net_dev;
	}
}

496 497 498 499
int ipoib_set_mode(struct net_device *dev, const char *buf)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

500 501 502 503 504 505 506
	if ((test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags) &&
	     !strcmp(buf, "connected\n")) ||
	     (!test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags) &&
	     !strcmp(buf, "datagram\n"))) {
		return 0;
	}

507 508 509 510 511 512
	/* flush paths if we switch modes so that connections are restarted */
	if (IPOIB_CM_SUPPORTED(dev->dev_addr) && !strcmp(buf, "connected\n")) {
		set_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
		ipoib_warn(priv, "enabling connected mode "
			   "will cause multicast packet drops\n");
		netdev_update_features(dev);
513
		dev_set_mtu(dev, ipoib_cm_max_mtu(dev));
514
		rtnl_unlock();
C
Christoph Hellwig 已提交
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 522 523 524 525 526
	}

	if (!strcmp(buf, "datagram\n")) {
		clear_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags);
		netdev_update_features(dev);
		dev_set_mtu(dev, min(priv->mcast_mtu, dev->mtu));
		rtnl_unlock();
		ipoib_flush_paths(dev);
527
		return (!rtnl_trylock()) ? -EBUSY : 0;
528 529 530 531 532
	}

	return -EINVAL;
}

533
struct ipoib_path *__path_find(struct net_device *dev, void *gid)
L
Linus Torvalds 已提交
534 535 536 537 538 539 540 541 542
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct rb_node *n = priv->path_tree.rb_node;
	struct ipoib_path *path;
	int ret;

	while (n) {
		path = rb_entry(n, struct ipoib_path, rb_node);

543
		ret = memcmp(gid, path->pathrec.dgid.raw,
L
Linus Torvalds 已提交
544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564 565 566 567 568 569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593
			     sizeof (union ib_gid));

		if (ret < 0)
			n = n->rb_left;
		else if (ret > 0)
			n = n->rb_right;
		else
			return path;
	}

	return NULL;
}

static int __path_add(struct net_device *dev, struct ipoib_path *path)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct rb_node **n = &priv->path_tree.rb_node;
	struct rb_node *pn = NULL;
	struct ipoib_path *tpath;
	int ret;

	while (*n) {
		pn = *n;
		tpath = rb_entry(pn, struct ipoib_path, rb_node);

		ret = memcmp(path->pathrec.dgid.raw, tpath->pathrec.dgid.raw,
			     sizeof (union ib_gid));
		if (ret < 0)
			n = &pn->rb_left;
		else if (ret > 0)
			n = &pn->rb_right;
		else
			return -EEXIST;
	}

	rb_link_node(&path->rb_node, pn, n);
	rb_insert_color(&path->rb_node, &priv->path_tree);

	list_add_tail(&path->list, &priv->path_list);

	return 0;
}

static void path_free(struct net_device *dev, struct ipoib_path *path)
{
	struct sk_buff *skb;

	while ((skb = __skb_dequeue(&path->queue)))
		dev_kfree_skb_irq(skb);

594
	ipoib_dbg(netdev_priv(dev), "path_free\n");
L
Linus Torvalds 已提交
595

596 597
	/* remove all neigh connected to this path */
	ipoib_del_neighs_by_gid(dev, path->pathrec.dgid.raw);
L
Linus Torvalds 已提交
598 599 600 601 602 603 604

	if (path->ah)
		ipoib_put_ah(path->ah);

	kfree(path);
}

605 606 607 608 609 610 611 612 613 614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629 630 631 632 633 634 635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662
#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG

struct ipoib_path_iter *ipoib_path_iter_init(struct net_device *dev)
{
	struct ipoib_path_iter *iter;

	iter = kmalloc(sizeof *iter, GFP_KERNEL);
	if (!iter)
		return NULL;

	iter->dev = dev;
	memset(iter->path.pathrec.dgid.raw, 0, 16);

	if (ipoib_path_iter_next(iter)) {
		kfree(iter);
		return NULL;
	}

	return iter;
}

int ipoib_path_iter_next(struct ipoib_path_iter *iter)
{
	struct ipoib_dev_priv *priv = netdev_priv(iter->dev);
	struct rb_node *n;
	struct ipoib_path *path;
	int ret = 1;

	spin_lock_irq(&priv->lock);

	n = rb_first(&priv->path_tree);

	while (n) {
		path = rb_entry(n, struct ipoib_path, rb_node);

		if (memcmp(iter->path.pathrec.dgid.raw, path->pathrec.dgid.raw,
			   sizeof (union ib_gid)) < 0) {
			iter->path = *path;
			ret = 0;
			break;
		}

		n = rb_next(n);
	}

	spin_unlock_irq(&priv->lock);

	return ret;
}

void ipoib_path_iter_read(struct ipoib_path_iter *iter,
			  struct ipoib_path *path)
{
	*path = iter->path;
}

#endif /* CONFIG_INFINIBAND_IPOIB_DEBUG */

663 664 665 666 667 668 669 670
void ipoib_mark_paths_invalid(struct net_device *dev)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct ipoib_path *path, *tp;

	spin_lock_irq(&priv->lock);

	list_for_each_entry_safe(path, tp, &priv->path_list, list) {
H
Harvey Harrison 已提交
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 675 676 677 678 679
		path->valid =  0;
	}

	spin_unlock_irq(&priv->lock);
}

680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748 749 750
struct classport_info_context {
	struct ipoib_dev_priv	*priv;
	struct completion	done;
	struct ib_sa_query	*sa_query;
};

static void classport_info_query_cb(int status, struct ib_class_port_info *rec,
				    void *context)
{
	struct classport_info_context *cb_ctx = context;
	struct ipoib_dev_priv *priv;

	WARN_ON(!context);

	priv = cb_ctx->priv;

	if (status || !rec) {
		pr_debug("device: %s failed query classport_info status: %d\n",
			 priv->dev->name, status);
		/* keeps the default, will try next mcast_restart */
		priv->sm_fullmember_sendonly_support = false;
		goto out;
	}

	if (ib_get_cpi_capmask2(rec) &
	    IB_SA_CAP_MASK2_SENDONLY_FULL_MEM_SUPPORT) {
		pr_debug("device: %s enabled fullmember-sendonly for sendonly MCG\n",
			 priv->dev->name);
		priv->sm_fullmember_sendonly_support = true;
	} else {
		pr_debug("device: %s disabled fullmember-sendonly for sendonly MCG\n",
			 priv->dev->name);
		priv->sm_fullmember_sendonly_support = false;
	}

out:
	complete(&cb_ctx->done);
}

int ipoib_check_sm_sendonly_fullmember_support(struct ipoib_dev_priv *priv)
{
	struct classport_info_context *callback_context;
	int ret;

	callback_context = kmalloc(sizeof(*callback_context), GFP_KERNEL);
	if (!callback_context)
		return -ENOMEM;

	callback_context->priv = priv;
	init_completion(&callback_context->done);

	ret = ib_sa_classport_info_rec_query(&ipoib_sa_client,
					     priv->ca, priv->port, 3000,
					     GFP_KERNEL,
					     classport_info_query_cb,
					     callback_context,
					     &callback_context->sa_query);
	if (ret < 0) {
		pr_info("%s failed to send ib_sa_classport_info query, ret: %d\n",
			priv->dev->name, ret);
		kfree(callback_context);
		return ret;
	}

	/* waiting for the callback to finish before returnning */
	wait_for_completion(&callback_context->done);
	kfree(callback_context);

	return ret;
}

751 752 753 754 755 756 757 758
static void push_pseudo_header(struct sk_buff *skb, const char *daddr)
{
	struct ipoib_pseudo_header *phdr;

	phdr = (struct ipoib_pseudo_header *)skb_push(skb, sizeof(*phdr));
	memcpy(phdr->hwaddr, daddr, INFINIBAND_ALEN);
}

L
Linus Torvalds 已提交
759 760 761 762 763
void ipoib_flush_paths(struct net_device *dev)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct ipoib_path *path, *tp;
	LIST_HEAD(remove_list);
764
	unsigned long flags;
L
Linus Torvalds 已提交
765

766 767
	netif_tx_lock_bh(dev);
	spin_lock_irqsave(&priv->lock, flags);
L
Linus Torvalds 已提交
768

769
	list_splice_init(&priv->path_list, &remove_list);
L
Linus Torvalds 已提交
770 771 772 773 774 775 776

	list_for_each_entry(path, &remove_list, list)
		rb_erase(&path->rb_node, &priv->path_tree);

	list_for_each_entry_safe(path, tp, &remove_list, list) {
		if (path->query)
			ib_sa_cancel_query(path->query_id, path->query);
777 778
		spin_unlock_irqrestore(&priv->lock, flags);
		netif_tx_unlock_bh(dev);
L
Linus Torvalds 已提交
779 780
		wait_for_completion(&path->done);
		path_free(dev, path);
781 782
		netif_tx_lock_bh(dev);
		spin_lock_irqsave(&priv->lock, flags);
L
Linus Torvalds 已提交
783
	}
784 785 786

	spin_unlock_irqrestore(&priv->lock, flags);
	netif_tx_unlock_bh(dev);
L
Linus Torvalds 已提交
787 788 789 790 791 792 793 794 795 796
}

static void path_rec_completion(int status,
				struct ib_sa_path_rec *pathrec,
				void *path_ptr)
{
	struct ipoib_path *path = path_ptr;
	struct net_device *dev = path->dev;
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct ipoib_ah *ah = NULL;
797
	struct ipoib_ah *old_ah = NULL;
798
	struct ipoib_neigh *neigh, *tn;
L
Linus Torvalds 已提交
799 800 801 802
	struct sk_buff_head skqueue;
	struct sk_buff *skb;
	unsigned long flags;

803
	if (!status)
H
Harvey Harrison 已提交
804
		ipoib_dbg(priv, "PathRec LID 0x%04x for GID %pI6\n",
805
			  be16_to_cpu(pathrec->dlid), pathrec->dgid.raw);
L
Linus Torvalds 已提交
806
	else
H
Harvey Harrison 已提交
807
		ipoib_dbg(priv, "PathRec status %d for GID %pI6\n",
808
			  status, path->pathrec.dgid.raw);
L
Linus Torvalds 已提交
809 810 811 812

	skb_queue_head_init(&skqueue);

	if (!status) {
813 814 815 816
		struct ib_ah_attr av;

		if (!ib_init_ah_from_path(priv->ca, priv->port, pathrec, &av))
			ah = ipoib_create_ah(dev, priv->pd, &av);
L
Linus Torvalds 已提交
817 818 819 820
	}

	spin_lock_irqsave(&priv->lock, flags);

821
	if (!IS_ERR_OR_NULL(ah)) {
L
Linus Torvalds 已提交
822 823
		path->pathrec = *pathrec;

824 825 826
		old_ah   = path->ah;
		path->ah = ah;

L
Linus Torvalds 已提交
827 828 829 830 831 832
		ipoib_dbg(priv, "created address handle %p for LID 0x%04x, SL %d\n",
			  ah, be16_to_cpu(pathrec->dlid), pathrec->sl);

		while ((skb = __skb_dequeue(&path->queue)))
			__skb_queue_tail(&skqueue, skb);

833
		list_for_each_entry_safe(neigh, tn, &path->neigh_list, list) {
834 835 836 837 838 839 840 841 842 843 844
			if (neigh->ah) {
				WARN_ON(neigh->ah != old_ah);
				/*
				 * Dropping the ah reference inside
				 * priv->lock is safe here, because we
				 * will hold one more reference from
				 * the original value of path->ah (ie
				 * old_ah).
				 */
				ipoib_put_ah(neigh->ah);
			}
L
Linus Torvalds 已提交
845 846 847
			kref_get(&path->ah->ref);
			neigh->ah = path->ah;

848
			if (ipoib_cm_enabled(dev, neigh->daddr)) {
849 850 851 852 853
				if (!ipoib_cm_get(neigh))
					ipoib_cm_set(neigh, ipoib_cm_create_tx(dev,
									       path,
									       neigh));
				if (!ipoib_cm_get(neigh)) {
854
					ipoib_neigh_free(neigh);
855 856 857 858
					continue;
				}
			}

L
Linus Torvalds 已提交
859 860 861
			while ((skb = __skb_dequeue(&neigh->queue)))
				__skb_queue_tail(&skqueue, skb);
		}
862
		path->valid = 1;
863
	}
L
Linus Torvalds 已提交
864

865
	path->query = NULL;
L
Linus Torvalds 已提交
866 867 868 869
	complete(&path->done);

	spin_unlock_irqrestore(&priv->lock, flags);

870 871 872
	if (IS_ERR_OR_NULL(ah))
		ipoib_del_neighs_by_gid(dev, path->pathrec.dgid.raw);

873 874 875
	if (old_ah)
		ipoib_put_ah(old_ah);

L
Linus Torvalds 已提交
876
	while ((skb = __skb_dequeue(&skqueue))) {
877
		int ret;
L
Linus Torvalds 已提交
878
		skb->dev = dev;
879 880 881 882
		ret = dev_queue_xmit(skb);
		if (ret)
			ipoib_warn(priv, "%s: dev_queue_xmit failed to re-queue packet, ret:%d\n",
				   __func__, ret);
L
Linus Torvalds 已提交
883 884 885
	}
}

886
static struct ipoib_path *path_rec_create(struct net_device *dev, void *gid)
L
Linus Torvalds 已提交
887 888 889 890
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct ipoib_path *path;

891 892 893
	if (!priv->broadcast)
		return NULL;

894
	path = kzalloc(sizeof *path, GFP_ATOMIC);
L
Linus Torvalds 已提交
895 896 897
	if (!path)
		return NULL;

898
	path->dev = dev;
L
Linus Torvalds 已提交
899 900 901 902 903

	skb_queue_head_init(&path->queue);

	INIT_LIST_HEAD(&path->neigh_list);

904
	memcpy(path->pathrec.dgid.raw, gid, sizeof (union ib_gid));
905 906
	path->pathrec.sgid	    = priv->local_gid;
	path->pathrec.pkey	    = cpu_to_be16(priv->pkey);
907 908
	path->pathrec.numb_path     = 1;
	path->pathrec.traffic_class = priv->broadcast->mcmember.traffic_class;
L
Linus Torvalds 已提交
909 910 911 912 913 914 915 916 917

	return path;
}

static int path_rec_start(struct net_device *dev,
			  struct ipoib_path *path)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

H
Harvey Harrison 已提交
918
	ipoib_dbg(priv, "Start path record lookup for %pI6\n",
919
		  path->pathrec.dgid.raw);
L
Linus Torvalds 已提交
920

921 922
	init_completion(&path->done);

L
Linus Torvalds 已提交
923
	path->query_id =
924
		ib_sa_path_rec_get(&ipoib_sa_client, priv->ca, priv->port,
L
Linus Torvalds 已提交
925 926 927 928
				   &path->pathrec,
				   IB_SA_PATH_REC_DGID		|
				   IB_SA_PATH_REC_SGID		|
				   IB_SA_PATH_REC_NUMB_PATH	|
929
				   IB_SA_PATH_REC_TRAFFIC_CLASS |
L
Linus Torvalds 已提交
930 931 932 933 934
				   IB_SA_PATH_REC_PKEY,
				   1000, GFP_ATOMIC,
				   path_rec_completion,
				   path, &path->query);
	if (path->query_id < 0) {
935
		ipoib_warn(priv, "ib_sa_path_rec_get failed: %d\n", path->query_id);
L
Linus Torvalds 已提交
936
		path->query = NULL;
937
		complete(&path->done);
L
Linus Torvalds 已提交
938 939 940 941 942 943
		return path->query_id;
	}

	return 0;
}

944 945
static void neigh_add_path(struct sk_buff *skb, u8 *daddr,
			   struct net_device *dev)
L
Linus Torvalds 已提交
946 947 948 949
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct ipoib_path *path;
	struct ipoib_neigh *neigh;
950
	unsigned long flags;
L
Linus Torvalds 已提交
951

952
	spin_lock_irqsave(&priv->lock, flags);
953
	neigh = ipoib_neigh_alloc(daddr, dev);
L
Linus Torvalds 已提交
954
	if (!neigh) {
955
		spin_unlock_irqrestore(&priv->lock, flags);
956
		++dev->stats.tx_dropped;
L
Linus Torvalds 已提交
957 958 959 960
		dev_kfree_skb_any(skb);
		return;
	}

961
	path = __path_find(dev, daddr + 4);
L
Linus Torvalds 已提交
962
	if (!path) {
963
		path = path_rec_create(dev, daddr + 4);
L
Linus Torvalds 已提交
964
		if (!path)
965
			goto err_path;
L
Linus Torvalds 已提交
966 967 968 969 970 971

		__path_add(dev, path);
	}

	list_add_tail(&neigh->list, &path->neigh_list);

972
	if (path->ah) {
L
Linus Torvalds 已提交
973 974 975
		kref_get(&path->ah->ref);
		neigh->ah = path->ah;

976
		if (ipoib_cm_enabled(dev, neigh->daddr)) {
977 978 979
			if (!ipoib_cm_get(neigh))
				ipoib_cm_set(neigh, ipoib_cm_create_tx(dev, path, neigh));
			if (!ipoib_cm_get(neigh)) {
980
				ipoib_neigh_free(neigh);
981 982
				goto err_drop;
			}
983 984
			if (skb_queue_len(&neigh->queue) <
			    IPOIB_MAX_PATH_REC_QUEUE) {
985
				push_pseudo_header(skb, neigh->daddr);
986
				__skb_queue_tail(&neigh->queue, skb);
987
			} else {
988 989 990 991
				ipoib_warn(priv, "queue length limit %d. Packet drop.\n",
					   skb_queue_len(&neigh->queue));
				goto err_drop;
			}
992 993
		} else {
			spin_unlock_irqrestore(&priv->lock, flags);
994 995
			ipoib_send(dev, skb, path->ah, IPOIB_QPN(daddr));
			ipoib_neigh_put(neigh);
996 997
			return;
		}
L
Linus Torvalds 已提交
998 999 1000 1001
	} else {
		neigh->ah  = NULL;

		if (!path->query && path_rec_start(dev, path))
1002
			goto err_path;
1003 1004
		if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE) {
			push_pseudo_header(skb, neigh->daddr);
1005
			__skb_queue_tail(&neigh->queue, skb);
1006
		} else {
1007
			goto err_drop;
1008
		}
L
Linus Torvalds 已提交
1009 1010
	}

1011
	spin_unlock_irqrestore(&priv->lock, flags);
1012
	ipoib_neigh_put(neigh);
L
Linus Torvalds 已提交
1013 1014
	return;

1015
err_path:
1016
	ipoib_neigh_free(neigh);
1017
err_drop:
1018
	++dev->stats.tx_dropped;
L
Linus Torvalds 已提交
1019 1020
	dev_kfree_skb_any(skb);

1021
	spin_unlock_irqrestore(&priv->lock, flags);
1022
	ipoib_neigh_put(neigh);
L
Linus Torvalds 已提交
1023 1024 1025
}

static void unicast_arp_send(struct sk_buff *skb, struct net_device *dev,
1026
			     struct ipoib_pseudo_header *phdr)
L
Linus Torvalds 已提交
1027 1028 1029
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct ipoib_path *path;
1030
	unsigned long flags;
L
Linus Torvalds 已提交
1031

1032
	spin_lock_irqsave(&priv->lock, flags);
L
Linus Torvalds 已提交
1033

1034
	path = __path_find(dev, phdr->hwaddr + 4);
1035
	if (!path || !path->valid) {
1036 1037 1038
		int new_path = 0;

		if (!path) {
1039
			path = path_rec_create(dev, phdr->hwaddr + 4);
1040 1041
			new_path = 1;
		}
L
Linus Torvalds 已提交
1042
		if (path) {
1043
			if (skb_queue_len(&path->queue) < IPOIB_MAX_PATH_REC_QUEUE) {
1044
				push_pseudo_header(skb, phdr->hwaddr);
1045 1046 1047 1048 1049
				__skb_queue_tail(&path->queue, skb);
			} else {
				++dev->stats.tx_dropped;
				dev_kfree_skb_any(skb);
			}
L
Linus Torvalds 已提交
1050

1051
			if (!path->query && path_rec_start(dev, path)) {
1052
				spin_unlock_irqrestore(&priv->lock, flags);
1053 1054
				if (new_path)
					path_free(dev, path);
L
Linus Torvalds 已提交
1055 1056 1057 1058
				return;
			} else
				__path_add(dev, path);
		} else {
1059
			++dev->stats.tx_dropped;
L
Linus Torvalds 已提交
1060 1061 1062
			dev_kfree_skb_any(skb);
		}

1063
		spin_unlock_irqrestore(&priv->lock, flags);
L
Linus Torvalds 已提交
1064 1065 1066
		return;
	}

1067
	if (path->ah) {
L
Linus Torvalds 已提交
1068 1069 1070
		ipoib_dbg(priv, "Send unicast ARP to %04x\n",
			  be16_to_cpu(path->pathrec.dlid));

1071
		spin_unlock_irqrestore(&priv->lock, flags);
1072
		ipoib_send(dev, skb, path->ah, IPOIB_QPN(phdr->hwaddr));
1073
		return;
L
Linus Torvalds 已提交
1074 1075
	} else if ((path->query || !path_rec_start(dev, path)) &&
		   skb_queue_len(&path->queue) < IPOIB_MAX_PATH_REC_QUEUE) {
1076
		push_pseudo_header(skb, phdr->hwaddr);
L
Linus Torvalds 已提交
1077 1078
		__skb_queue_tail(&path->queue, skb);
	} else {
1079
		++dev->stats.tx_dropped;
L
Linus Torvalds 已提交
1080 1081 1082
		dev_kfree_skb_any(skb);
	}

1083
	spin_unlock_irqrestore(&priv->lock, flags);
L
Linus Torvalds 已提交
1084 1085 1086 1087 1088 1089
}

static int ipoib_start_xmit(struct sk_buff *skb, struct net_device *dev)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct ipoib_neigh *neigh;
1090
	struct ipoib_pseudo_header *phdr;
1091
	struct ipoib_header *header;
L
Linus Torvalds 已提交
1092 1093
	unsigned long flags;

1094 1095
	phdr = (struct ipoib_pseudo_header *) skb->data;
	skb_pull(skb, sizeof(*phdr));
1096 1097
	header = (struct ipoib_header *) skb->data;

1098
	if (unlikely(phdr->hwaddr[4] == 0xff)) {
1099 1100 1101 1102
		/* multicast, arrange "if" according to probability */
		if ((header->proto != htons(ETH_P_IP)) &&
		    (header->proto != htons(ETH_P_IPV6)) &&
		    (header->proto != htons(ETH_P_ARP)) &&
1103 1104
		    (header->proto != htons(ETH_P_RARP)) &&
		    (header->proto != htons(ETH_P_TIPC))) {
1105
			/* ethertype not supported by IPoIB */
1106 1107
			++dev->stats.tx_dropped;
			dev_kfree_skb_any(skb);
1108
			return NETDEV_TX_OK;
1109
		}
1110
		/* Add in the P_Key for multicast*/
1111 1112
		phdr->hwaddr[8] = (priv->pkey >> 8) & 0xff;
		phdr->hwaddr[9] = priv->pkey & 0xff;
1113

1114
		neigh = ipoib_neigh_get(dev, phdr->hwaddr);
1115 1116
		if (likely(neigh))
			goto send_using_neigh;
1117
		ipoib_mcast_send(dev, phdr->hwaddr, skb);
1118
		return NETDEV_TX_OK;
1119
	}
L
Linus Torvalds 已提交
1120

1121 1122 1123 1124
	/* unicast, arrange "switch" according to probability */
	switch (header->proto) {
	case htons(ETH_P_IP):
	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 1132 1133 1134
		break;
	case htons(ETH_P_ARP):
	case htons(ETH_P_RARP):
		/* for unicast ARP and RARP should always perform path find */
1135
		unicast_arp_send(skb, dev, phdr);
1136 1137 1138 1139 1140 1141 1142
		return NETDEV_TX_OK;
	default:
		/* ethertype not supported by IPoIB */
		++dev->stats.tx_dropped;
		dev_kfree_skb_any(skb);
		return NETDEV_TX_OK;
	}
1143

1144 1145 1146 1147 1148 1149
send_using_neigh:
	/* note we now hold a ref to neigh */
	if (ipoib_cm_get(neigh)) {
		if (ipoib_cm_up(neigh)) {
			ipoib_cm_send(dev, skb, ipoib_cm_get(neigh));
			goto unref;
L
Linus Torvalds 已提交
1150
		}
1151
	} else if (neigh->ah) {
1152
		ipoib_send(dev, skb, neigh->ah, IPOIB_QPN(phdr->hwaddr));
1153 1154
		goto unref;
	}
L
Linus Torvalds 已提交
1155

1156
	if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE) {
1157
		push_pseudo_header(skb, phdr->hwaddr);
1158 1159 1160
		spin_lock_irqsave(&priv->lock, flags);
		__skb_queue_tail(&neigh->queue, skb);
		spin_unlock_irqrestore(&priv->lock, flags);
L
Linus Torvalds 已提交
1161
	} else {
1162 1163 1164
		++dev->stats.tx_dropped;
		dev_kfree_skb_any(skb);
	}
L
Linus Torvalds 已提交
1165

1166 1167
unref:
	ipoib_neigh_put(neigh);
L
Linus Torvalds 已提交
1168 1169 1170 1171 1172 1173 1174 1175

	return NETDEV_TX_OK;
}

static void ipoib_timeout(struct net_device *dev)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

1176
	ipoib_warn(priv, "transmit timeout: latency %d msecs\n",
1177
		   jiffies_to_msecs(jiffies - dev_trans_start(dev)));
1178 1179 1180
	ipoib_warn(priv, "queue stopped %d, tx_head %u, tx_tail %u\n",
		   netif_queue_stopped(dev),
		   priv->tx_head, priv->tx_tail);
L
Linus Torvalds 已提交
1181 1182 1183 1184 1185 1186
	/* XXX reset QP, etc. */
}

static int ipoib_hard_header(struct sk_buff *skb,
			     struct net_device *dev,
			     unsigned short type,
1187
			     const void *daddr, const void *saddr, unsigned len)
L
Linus Torvalds 已提交
1188 1189 1190 1191 1192 1193 1194 1195 1196
{
	struct ipoib_header *header;

	header = (struct ipoib_header *) skb_push(skb, sizeof *header);

	header->proto = htons(type);
	header->reserved = 0;

	/*
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.
L
Linus Torvalds 已提交
1200
	 */
1201
	push_pseudo_header(skb, daddr);
L
Linus Torvalds 已提交
1202

1203
	return IPOIB_HARD_LEN;
L
Linus Torvalds 已提交
1204 1205 1206 1207 1208 1209
}

static void ipoib_set_mcast_list(struct net_device *dev)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

L
Leonid Arsh 已提交
1210 1211 1212 1213 1214
	if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) {
		ipoib_dbg(priv, "IPOIB_FLAG_OPER_UP not set");
		return;
	}

1215
	queue_work(priv->wq, &priv->restart_task);
L
Linus Torvalds 已提交
1216 1217
}

1218 1219 1220 1221
static int ipoib_get_iflink(const struct net_device *dev)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

E
Erez Shitrit 已提交
1222 1223 1224 1225 1226
	/* parent interface */
	if (!test_bit(IPOIB_FLAG_SUBINTERFACE, &priv->flags))
		return dev->ifindex;

	/* child/vlan interface */
1227 1228 1229
	return priv->parent->ifindex;
}

1230
static u32 ipoib_addr_hash(struct ipoib_neigh_hash *htbl, u8 *daddr)
L
Linus Torvalds 已提交
1231
{
1232 1233 1234 1235 1236 1237 1238
	/*
	 * Use only the address parts that contributes to spreading
	 * The subnet prefix is not used as one can not connect to
	 * same remote port (GUID) using the same remote QPN via two
	 * different subnets.
	 */
	 /* qpn octets[1:4) & port GUID octets[12:20) */
1239
	u32 *d32 = (u32 *) daddr;
1240 1241
	u32 hv;

1242
	hv = jhash_3words(d32[3], d32[4], IPOIB_QPN_MASK & d32[0], 0);
1243 1244 1245 1246 1247 1248 1249 1250 1251 1252 1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269 1270 1271
	return hv & htbl->mask;
}

struct ipoib_neigh *ipoib_neigh_get(struct net_device *dev, u8 *daddr)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct ipoib_neigh_table *ntbl = &priv->ntbl;
	struct ipoib_neigh_hash *htbl;
	struct ipoib_neigh *neigh = NULL;
	u32 hash_val;

	rcu_read_lock_bh();

	htbl = rcu_dereference_bh(ntbl->htbl);

	if (!htbl)
		goto out_unlock;

	hash_val = ipoib_addr_hash(htbl, daddr);
	for (neigh = rcu_dereference_bh(htbl->buckets[hash_val]);
	     neigh != NULL;
	     neigh = rcu_dereference_bh(neigh->hnext)) {
		if (memcmp(daddr, neigh->daddr, INFINIBAND_ALEN) == 0) {
			/* found, take one ref on behalf of the caller */
			if (!atomic_inc_not_zero(&neigh->refcnt)) {
				/* deleted */
				neigh = NULL;
				goto out_unlock;
			}
1272 1273 1274

			if (likely(skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE))
				neigh->alive = jiffies;
1275 1276 1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289
			goto out_unlock;
		}
	}

out_unlock:
	rcu_read_unlock_bh();
	return neigh;
}

static void __ipoib_reap_neigh(struct ipoib_dev_priv *priv)
{
	struct ipoib_neigh_table *ntbl = &priv->ntbl;
	struct ipoib_neigh_hash *htbl;
	unsigned long neigh_obsolete;
	unsigned long dt;
L
Linus Torvalds 已提交
1290
	unsigned long flags;
1291
	int i;
1292
	LIST_HEAD(remove_list);
L
Linus Torvalds 已提交
1293

1294
	if (test_bit(IPOIB_STOP_NEIGH_GC, &priv->flags))
1295
		return;
L
Linus Torvalds 已提交
1296

1297
	spin_lock_irqsave(&priv->lock, flags);
1298 1299

	htbl = rcu_dereference_protected(ntbl->htbl,
1300
					 lockdep_is_held(&priv->lock));
1301 1302 1303 1304 1305 1306 1307 1308 1309 1310 1311 1312 1313 1314 1315 1316

	if (!htbl)
		goto out_unlock;

	/* neigh is obsolete if it was idle for two GC periods */
	dt = 2 * arp_tbl.gc_interval;
	neigh_obsolete = jiffies - dt;
	/* handle possible race condition */
	if (test_bit(IPOIB_STOP_NEIGH_GC, &priv->flags))
		goto out_unlock;

	for (i = 0; i < htbl->size; i++) {
		struct ipoib_neigh *neigh;
		struct ipoib_neigh __rcu **np = &htbl->buckets[i];

		while ((neigh = rcu_dereference_protected(*np,
1317
							  lockdep_is_held(&priv->lock))) != NULL) {
1318 1319
			/* was the neigh idle for two GC periods */
			if (time_after(neigh_obsolete, neigh->alive)) {
1320

1321
				ipoib_check_and_add_mcast_sendonly(priv, neigh->daddr + 4, &remove_list);
1322

1323 1324
				rcu_assign_pointer(*np,
						   rcu_dereference_protected(neigh->hnext,
1325
									     lockdep_is_held(&priv->lock)));
1326
				/* remove from path/mc list */
1327
				list_del_init(&neigh->list);
1328 1329 1330 1331
				call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
			} else {
				np = &neigh->hnext;
			}
L
Linus Torvalds 已提交
1332

1333 1334
		}
	}
L
Linus Torvalds 已提交
1335

1336
out_unlock:
1337
	spin_unlock_irqrestore(&priv->lock, flags);
1338
	ipoib_mcast_remove_list(&remove_list);
1339
}
L
Linus Torvalds 已提交
1340

1341 1342 1343 1344 1345 1346 1347 1348
static void ipoib_reap_neigh(struct work_struct *work)
{
	struct ipoib_dev_priv *priv =
		container_of(work, struct ipoib_dev_priv, neigh_reap_task.work);

	__ipoib_reap_neigh(priv);

	if (!test_bit(IPOIB_STOP_NEIGH_GC, &priv->flags))
1349
		queue_delayed_work(priv->wq, &priv->neigh_reap_task,
1350
				   arp_tbl.gc_interval);
L
Linus Torvalds 已提交
1351 1352
}

1353 1354

static struct ipoib_neigh *ipoib_neigh_ctor(u8 *daddr,
1355
				      struct net_device *dev)
1356 1357 1358
{
	struct ipoib_neigh *neigh;

1359
	neigh = kzalloc(sizeof *neigh, GFP_ATOMIC);
1360 1361 1362
	if (!neigh)
		return NULL;

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 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383
	/* one ref on behalf of the caller */
	atomic_set(&neigh->refcnt, 1);

	return neigh;
}

struct ipoib_neigh *ipoib_neigh_alloc(u8 *daddr,
				      struct net_device *dev)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct ipoib_neigh_table *ntbl = &priv->ntbl;
	struct ipoib_neigh_hash *htbl;
	struct ipoib_neigh *neigh;
	u32 hash_val;

	htbl = rcu_dereference_protected(ntbl->htbl,
1384
					 lockdep_is_held(&priv->lock));
1385 1386 1387 1388 1389 1390 1391 1392 1393 1394
	if (!htbl) {
		neigh = NULL;
		goto out_unlock;
	}

	/* need to add a new neigh, but maybe some other thread succeeded?
	 * recalc hash, maybe hash resize took place so we do a search
	 */
	hash_val = ipoib_addr_hash(htbl, daddr);
	for (neigh = rcu_dereference_protected(htbl->buckets[hash_val],
1395
					       lockdep_is_held(&priv->lock));
1396 1397
	     neigh != NULL;
	     neigh = rcu_dereference_protected(neigh->hnext,
1398
					       lockdep_is_held(&priv->lock))) {
1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420
		if (memcmp(daddr, neigh->daddr, INFINIBAND_ALEN) == 0) {
			/* found, take one ref on behalf of the caller */
			if (!atomic_inc_not_zero(&neigh->refcnt)) {
				/* deleted */
				neigh = NULL;
				break;
			}
			neigh->alive = jiffies;
			goto out_unlock;
		}
	}

	neigh = ipoib_neigh_ctor(daddr, dev);
	if (!neigh)
		goto out_unlock;

	/* one ref on behalf of the hash table */
	atomic_inc(&neigh->refcnt);
	neigh->alive = jiffies;
	/* put in hash */
	rcu_assign_pointer(neigh->hnext,
			   rcu_dereference_protected(htbl->buckets[hash_val],
1421
						     lockdep_is_held(&priv->lock)));
1422 1423 1424 1425
	rcu_assign_pointer(htbl->buckets[hash_val], neigh);
	atomic_inc(&ntbl->entries);

out_unlock:
1426 1427 1428 1429

	return neigh;
}

1430
void ipoib_neigh_dtor(struct ipoib_neigh *neigh)
1431
{
1432 1433 1434
	/* neigh reference count was dropprd to zero */
	struct net_device *dev = neigh->dev;
	struct ipoib_dev_priv *priv = netdev_priv(dev);
1435
	struct sk_buff *skb;
1436 1437
	if (neigh->ah)
		ipoib_put_ah(neigh->ah);
1438
	while ((skb = __skb_dequeue(&neigh->queue))) {
1439
		++dev->stats.tx_dropped;
1440 1441
		dev_kfree_skb_any(skb);
	}
1442 1443
	if (ipoib_cm_get(neigh))
		ipoib_cm_destroy_tx(ipoib_cm_get(neigh));
1444 1445 1446 1447
	ipoib_dbg(netdev_priv(dev),
		  "neigh free for %06x %pI6\n",
		  IPOIB_QPN(neigh->daddr),
		  neigh->daddr + 4);
1448
	kfree(neigh);
1449 1450 1451 1452 1453 1454 1455 1456 1457 1458 1459 1460
	if (atomic_dec_and_test(&priv->ntbl.entries)) {
		if (test_bit(IPOIB_NEIGH_TBL_FLUSH, &priv->flags))
			complete(&priv->ntbl.flushed);
	}
}

static void ipoib_neigh_reclaim(struct rcu_head *rp)
{
	/* Called as a result of removal from hash table */
	struct ipoib_neigh *neigh = container_of(rp, struct ipoib_neigh, rcu);
	/* note TX context may hold another ref */
	ipoib_neigh_put(neigh);
1461 1462
}

1463
void ipoib_neigh_free(struct ipoib_neigh *neigh)
L
Linus Torvalds 已提交
1464
{
1465 1466 1467 1468 1469 1470 1471 1472 1473
	struct net_device *dev = neigh->dev;
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct ipoib_neigh_table *ntbl = &priv->ntbl;
	struct ipoib_neigh_hash *htbl;
	struct ipoib_neigh __rcu **np;
	struct ipoib_neigh *n;
	u32 hash_val;

	htbl = rcu_dereference_protected(ntbl->htbl,
1474
					lockdep_is_held(&priv->lock));
1475
	if (!htbl)
1476
		return;
1477 1478 1479 1480

	hash_val = ipoib_addr_hash(htbl, neigh->daddr);
	np = &htbl->buckets[hash_val];
	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 1486 1487 1488
		if (n == neigh) {
			/* found */
			rcu_assign_pointer(*np,
					   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 1495 1496 1497 1498 1499 1500 1501 1502 1503
		} else {
			np = &n->hnext;
		}
	}
}

static int ipoib_neigh_hash_init(struct ipoib_dev_priv *priv)
{
	struct ipoib_neigh_table *ntbl = &priv->ntbl;
	struct ipoib_neigh_hash *htbl;
1504
	struct ipoib_neigh __rcu **buckets;
1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521
	u32 size;

	clear_bit(IPOIB_NEIGH_TBL_FLUSH, &priv->flags);
	ntbl->htbl = NULL;
	htbl = kzalloc(sizeof(*htbl), GFP_KERNEL);
	if (!htbl)
		return -ENOMEM;
	set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
	size = roundup_pow_of_two(arp_tbl.gc_thresh3);
	buckets = kzalloc(size * sizeof(*buckets), GFP_KERNEL);
	if (!buckets) {
		kfree(htbl);
		return -ENOMEM;
	}
	htbl->size = size;
	htbl->mask = (size - 1);
	htbl->buckets = buckets;
1522
	RCU_INIT_POINTER(ntbl->htbl, htbl);
1523
	htbl->ntbl = ntbl;
1524 1525 1526 1527
	atomic_set(&ntbl->entries, 0);

	/* start garbage collection */
	clear_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
1528
	queue_delayed_work(priv->wq, &priv->neigh_reap_task,
1529
			   arp_tbl.gc_interval);
L
Linus Torvalds 已提交
1530 1531 1532 1533

	return 0;
}

1534 1535 1536 1537 1538 1539
static void neigh_hash_free_rcu(struct rcu_head *head)
{
	struct ipoib_neigh_hash *htbl = container_of(head,
						    struct ipoib_neigh_hash,
						    rcu);
	struct ipoib_neigh __rcu **buckets = htbl->buckets;
1540
	struct ipoib_neigh_table *ntbl = htbl->ntbl;
1541 1542 1543

	kfree(buckets);
	kfree(htbl);
1544
	complete(&ntbl->deleted);
1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555
}

void ipoib_del_neighs_by_gid(struct net_device *dev, u8 *gid)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct ipoib_neigh_table *ntbl = &priv->ntbl;
	struct ipoib_neigh_hash *htbl;
	unsigned long flags;
	int i;

	/* 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 1562 1563 1564 1565 1566 1567 1568

	if (!htbl)
		goto out_unlock;

	for (i = 0; i < htbl->size; i++) {
		struct ipoib_neigh *neigh;
		struct ipoib_neigh __rcu **np = &htbl->buckets[i];

		while ((neigh = rcu_dereference_protected(*np,
1569
							  lockdep_is_held(&priv->lock))) != NULL) {
1570 1571 1572 1573
			/* delete neighs belong to this parent */
			if (!memcmp(gid, neigh->daddr + 4, sizeof (union ib_gid))) {
				rcu_assign_pointer(*np,
						   rcu_dereference_protected(neigh->hnext,
1574
									     lockdep_is_held(&priv->lock)));
1575
				/* remove from parent list */
1576
				list_del_init(&neigh->list);
1577 1578 1579 1580 1581 1582 1583 1584
				call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
			} else {
				np = &neigh->hnext;
			}

		}
	}
out_unlock:
1585
	spin_unlock_irqrestore(&priv->lock, flags);
1586 1587 1588 1589 1590 1591 1592
}

static void ipoib_flush_neighs(struct ipoib_dev_priv *priv)
{
	struct ipoib_neigh_table *ntbl = &priv->ntbl;
	struct ipoib_neigh_hash *htbl;
	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 1602 1603
	if (!htbl)
		goto out_unlock;

1604 1605 1606 1607
	wait_flushed = atomic_read(&priv->ntbl.entries);
	if (!wait_flushed)
		goto free_htbl;

1608 1609 1610 1611 1612
	for (i = 0; i < htbl->size; i++) {
		struct ipoib_neigh *neigh;
		struct ipoib_neigh __rcu **np = &htbl->buckets[i];

		while ((neigh = rcu_dereference_protected(*np,
1613
				       lockdep_is_held(&priv->lock))) != NULL) {
1614 1615
			rcu_assign_pointer(*np,
					   rcu_dereference_protected(neigh->hnext,
1616
								     lockdep_is_held(&priv->lock)));
1617
			/* remove from path/mc list */
1618
			list_del_init(&neigh->list);
1619 1620 1621 1622
			call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
		}
	}

1623
free_htbl:
1624 1625 1626 1627
	rcu_assign_pointer(ntbl->htbl, NULL);
	call_rcu(&htbl->rcu, neigh_hash_free_rcu);

out_unlock:
1628
	spin_unlock_irqrestore(&priv->lock, flags);
1629 1630
	if (wait_flushed)
		wait_for_completion(&priv->ntbl.flushed);
1631 1632 1633 1634 1635 1636 1637 1638
}

static void ipoib_neigh_hash_uninit(struct net_device *dev)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	int stopped;

	ipoib_dbg(priv, "ipoib_neigh_hash_uninit\n");
1639
	init_completion(&priv->ntbl.deleted);
1640 1641 1642 1643 1644 1645 1646
	set_bit(IPOIB_NEIGH_TBL_FLUSH, &priv->flags);

	/* Stop GC if called at init fail need to cancel work */
	stopped = test_and_set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
	if (!stopped)
		cancel_delayed_work(&priv->neigh_reap_task);

1647 1648 1649
	ipoib_flush_neighs(priv);

	wait_for_completion(&priv->ntbl.deleted);
1650 1651
}

1652 1653 1654
void ipoib_dev_uninit_default(struct net_device *dev)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
1655

1656 1657 1658 1659 1660 1661 1662 1663 1664 1665 1666 1667 1668
	ipoib_transport_dev_cleanup(dev);

	ipoib_cm_dev_cleanup(dev);

	kfree(priv->rx_ring);
	vfree(priv->tx_ring);

	priv->rx_ring = NULL;
	priv->tx_ring = NULL;
}

static int ipoib_dev_init_default(struct net_device *dev, struct ib_device *ca,
				  int port)
L
Linus Torvalds 已提交
1669 1670 1671 1672
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

	/* Allocate RX/TX "rings" to hold queued skbs */
1673
	priv->rx_ring =	kzalloc(ipoib_recvq_size * sizeof *priv->rx_ring,
L
Linus Torvalds 已提交
1674
				GFP_KERNEL);
1675
	if (!priv->rx_ring)
1676
		goto out;
L
Linus Torvalds 已提交
1677

1678
	priv->tx_ring = vzalloc(ipoib_sendq_size * sizeof *priv->tx_ring);
L
Linus Torvalds 已提交
1679 1680
	if (!priv->tx_ring) {
		printk(KERN_WARNING "%s: failed to allocate TX ring (%d entries)\n",
1681
		       ca->name, ipoib_sendq_size);
L
Linus Torvalds 已提交
1682 1683 1684
		goto out_rx_ring_cleanup;
	}

1685
	/* priv->tx_head, tx_tail & tx_outstanding are already 0 */
L
Linus Torvalds 已提交
1686

1687 1688
	if (ipoib_transport_dev_init(dev, ca)) {
		pr_warn("%s: ipoib_transport_dev_init failed\n", ca->name);
L
Linus Torvalds 已提交
1689
		goto out_tx_ring_cleanup;
1690 1691 1692 1693 1694 1695 1696 1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714
	}

	setup_timer(&priv->poll_timer, ipoib_ib_tx_timer_func,
		    (unsigned long)dev);

	return 0;

out_tx_ring_cleanup:
	vfree(priv->tx_ring);

out_rx_ring_cleanup:
	kfree(priv->rx_ring);

out:
	return -ENOMEM;
}

int ipoib_dev_init(struct net_device *dev, struct ib_device *ca, int port)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	int ret = -ENOMEM;

	priv->ca = ca;
	priv->port = port;
	priv->qp = NULL;
L
Linus Torvalds 已提交
1715

1716
	/*
1717 1718
	 * the various IPoIB tasks assume they will never race against
	 * themselves, so always use a single thread workqueue
1719
	 */
1720 1721 1722 1723 1724 1725 1726 1727 1728 1729 1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744 1745
	priv->wq = alloc_ordered_workqueue("ipoib_wq", WQ_MEM_RECLAIM);
	if (!priv->wq) {
		pr_warn("%s: failed to allocate device WQ\n", dev->name);
		goto out;
	}

	/* create pd, which used both for control and datapath*/
	priv->pd = ib_alloc_pd(priv->ca, 0);
	if (IS_ERR(priv->pd)) {
		pr_warn("%s: failed to allocate PD\n", ca->name);
		goto clean_wq;
	}

	ret = ipoib_dev_init_default(dev, ca, port);
	if (ret) {
		pr_warn("%s failed to init HW resource\n", dev->name);
		goto out_free_pd;
	}

	/* after qp created set dev address */
	priv->dev->dev_addr[1] = (priv->qp->qp_num >> 16) & 0xff;
	priv->dev->dev_addr[2] = (priv->qp->qp_num >>  8) & 0xff;
	priv->dev->dev_addr[3] = (priv->qp->qp_num) & 0xff;

	if (ipoib_neigh_hash_init(priv) < 0) {
		pr_warn("%s failed to init neigh hash\n", dev->name);
1746
		goto out_dev_uninit;
1747 1748 1749 1750 1751 1752 1753 1754 1755
	}

	if (dev->flags & IFF_UP) {
		if (ipoib_ib_dev_open(dev)) {
			pr_warn("%s failed to open device\n", dev->name);
			ret = -ENODEV;
			goto out_dev_uninit;
		}
	}
1756

L
Linus Torvalds 已提交
1757 1758
	return 0;

1759 1760 1761
out_dev_uninit:
	ipoib_ib_dev_cleanup(dev);

1762 1763 1764 1765 1766
out_free_pd:
	if (priv->pd) {
		ib_dealloc_pd(priv->pd);
		priv->pd = NULL;
	}
L
Linus Torvalds 已提交
1767

1768 1769 1770 1771 1772
clean_wq:
	if (priv->wq) {
		destroy_workqueue(priv->wq);
		priv->wq = NULL;
	}
L
Linus Torvalds 已提交
1773 1774

out:
1775
	return ret;
L
Linus Torvalds 已提交
1776 1777 1778 1779 1780
}

void ipoib_dev_cleanup(struct net_device *dev)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev), *cpriv, *tcpriv;
O
Or Gerlitz 已提交
1781 1782 1783
	LIST_HEAD(head);

	ASSERT_RTNL();
L
Linus Torvalds 已提交
1784 1785 1786

	/* Delete any child interfaces first */
	list_for_each_entry_safe(cpriv, tcpriv, &priv->child_intfs, list) {
1787 1788 1789
		/* Stop GC on child */
		set_bit(IPOIB_STOP_NEIGH_GC, &cpriv->flags);
		cancel_delayed_work(&cpriv->neigh_reap_task);
O
Or Gerlitz 已提交
1790
		unregister_netdevice_queue(cpriv->dev, &head);
L
Linus Torvalds 已提交
1791
	}
O
Or Gerlitz 已提交
1792
	unregister_netdevice_many(&head);
L
Linus Torvalds 已提交
1793

1794 1795
	ipoib_neigh_hash_uninit(dev);

L
Linus Torvalds 已提交
1796 1797
	ipoib_ib_dev_cleanup(dev);

1798 1799 1800 1801 1802 1803
	/* no more works over the priv->wq */
	if (priv->wq) {
		flush_workqueue(priv->wq);
		destroy_workqueue(priv->wq);
		priv->wq = NULL;
	}
L
Linus Torvalds 已提交
1804 1805
}

1806 1807 1808 1809 1810 1811 1812 1813 1814 1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825 1826 1827 1828 1829 1830 1831 1832 1833 1834 1835 1836 1837 1838 1839 1840 1841 1842 1843 1844 1845
static int ipoib_set_vf_link_state(struct net_device *dev, int vf, int link_state)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

	return ib_set_vf_link_state(priv->ca, vf, priv->port, link_state);
}

static int ipoib_get_vf_config(struct net_device *dev, int vf,
			       struct ifla_vf_info *ivf)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	int err;

	err = ib_get_vf_config(priv->ca, vf, priv->port, ivf);
	if (err)
		return err;

	ivf->vf = vf;

	return 0;
}

static int ipoib_set_vf_guid(struct net_device *dev, int vf, u64 guid, int type)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

	if (type != IFLA_VF_IB_NODE_GUID && type != IFLA_VF_IB_PORT_GUID)
		return -EINVAL;

	return ib_set_vf_guid(priv->ca, vf, priv->port, guid, type);
}

static int ipoib_get_vf_stats(struct net_device *dev, int vf,
			      struct ifla_vf_stats *vf_stats)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

	return ib_get_vf_stats(priv->ca, vf, priv->port, vf_stats);
}

1846 1847 1848 1849
static const struct header_ops ipoib_header_ops = {
	.create	= ipoib_hard_header,
};

1850 1851 1852 1853 1854 1855 1856 1857 1858 1859 1860 1861 1862 1863
static const struct net_device_ops ipoib_netdev_ops_pf = {
	.ndo_uninit		 = ipoib_uninit,
	.ndo_open		 = ipoib_open,
	.ndo_stop		 = ipoib_stop,
	.ndo_change_mtu		 = ipoib_change_mtu,
	.ndo_fix_features	 = ipoib_fix_features,
	.ndo_start_xmit		 = ipoib_start_xmit,
	.ndo_tx_timeout		 = ipoib_timeout,
	.ndo_set_rx_mode	 = ipoib_set_mcast_list,
	.ndo_get_iflink		 = ipoib_get_iflink,
	.ndo_set_vf_link_state	 = ipoib_set_vf_link_state,
	.ndo_get_vf_config	 = ipoib_get_vf_config,
	.ndo_get_vf_stats	 = ipoib_get_vf_stats,
	.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 = {
O
Or Gerlitz 已提交
1868
	.ndo_uninit		 = ipoib_uninit,
1869 1870 1871
	.ndo_open		 = ipoib_open,
	.ndo_stop		 = ipoib_stop,
	.ndo_change_mtu		 = ipoib_change_mtu,
1872
	.ndo_fix_features	 = ipoib_fix_features,
1873 1874
	.ndo_start_xmit	 	 = ipoib_start_xmit,
	.ndo_tx_timeout		 = ipoib_timeout,
1875
	.ndo_set_rx_mode	 = ipoib_set_mcast_list,
1876
	.ndo_get_iflink		 = ipoib_get_iflink,
1877 1878
};

O
Or Gerlitz 已提交
1879
void ipoib_setup(struct net_device *dev)
L
Linus Torvalds 已提交
1880 1881 1882
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

1883 1884 1885 1886 1887
	if (priv->hca_caps & IB_DEVICE_VIRTUAL_FUNCTION)
		dev->netdev_ops	= &ipoib_netdev_ops_vf;
	else
		dev->netdev_ops	= &ipoib_netdev_ops_pf;

1888
	dev->header_ops		 = &ipoib_header_ops;
1889

E
Eli Cohen 已提交
1890 1891
	ipoib_set_ethtool_ops(dev);

M
Michal Schmidt 已提交
1892
	netif_napi_add(dev, &priv->napi, ipoib_poll, NAPI_POLL_WEIGHT);
L
Linus Torvalds 已提交
1893

1894
	dev->watchdog_timeo	 = HZ;
L
Linus Torvalds 已提交
1895

1896
	dev->flags		|= IFF_BROADCAST | IFF_MULTICAST;
L
Linus Torvalds 已提交
1897

1898
	dev->hard_header_len	 = IPOIB_HARD_LEN;
1899 1900 1901
	dev->addr_len		 = INFINIBAND_ALEN;
	dev->type		 = ARPHRD_INFINIBAND;
	dev->tx_queue_len	 = ipoib_sendq_size * 2;
E
Eli Cohen 已提交
1902 1903
	dev->features		 = (NETIF_F_VLAN_CHALLENGED	|
				    NETIF_F_HIGHDMA);
1904
	netif_keep_dst(dev);
L
Linus Torvalds 已提交
1905 1906 1907 1908 1909 1910 1911

	memcpy(dev->broadcast, ipv4_bcast_addr, INFINIBAND_ALEN);

	priv->dev = dev;

	spin_lock_init(&priv->lock);

1912
	init_rwsem(&priv->vlan_rwsem);
L
Linus Torvalds 已提交
1913 1914 1915 1916 1917 1918

	INIT_LIST_HEAD(&priv->path_list);
	INIT_LIST_HEAD(&priv->child_intfs);
	INIT_LIST_HEAD(&priv->dead_ahs);
	INIT_LIST_HEAD(&priv->multicast_list);

D
David Howells 已提交
1919
	INIT_DELAYED_WORK(&priv->mcast_task,   ipoib_mcast_join_task);
1920
	INIT_WORK(&priv->carrier_on_task, ipoib_mcast_carrier_on_task);
1921 1922 1923
	INIT_WORK(&priv->flush_light,   ipoib_ib_dev_flush_light);
	INIT_WORK(&priv->flush_normal,   ipoib_ib_dev_flush_normal);
	INIT_WORK(&priv->flush_heavy,   ipoib_ib_dev_flush_heavy);
D
David Howells 已提交
1924 1925
	INIT_WORK(&priv->restart_task, ipoib_mcast_restart_task);
	INIT_DELAYED_WORK(&priv->ah_reap_task, ipoib_reap_ah);
1926
	INIT_DELAYED_WORK(&priv->neigh_reap_task, ipoib_reap_neigh);
L
Linus Torvalds 已提交
1927 1928 1929 1930 1931 1932
}

struct ipoib_dev_priv *ipoib_intf_alloc(const char *name)
{
	struct net_device *dev;

1933 1934
	dev = alloc_netdev((int)sizeof(struct ipoib_dev_priv), name,
			   NET_NAME_UNKNOWN, ipoib_setup);
L
Linus Torvalds 已提交
1935 1936 1937 1938 1939 1940
	if (!dev)
		return NULL;

	return netdev_priv(dev);
}

1941 1942
static ssize_t show_pkey(struct device *dev,
			 struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
1943
{
1944
	struct ipoib_dev_priv *priv = netdev_priv(to_net_dev(dev));
L
Linus Torvalds 已提交
1945 1946 1947

	return sprintf(buf, "0x%04x\n", priv->pkey);
}
1948
static DEVICE_ATTR(pkey, S_IRUGO, show_pkey, NULL);
L
Linus Torvalds 已提交
1949

1950 1951 1952 1953 1954 1955 1956 1957
static ssize_t show_umcast(struct device *dev,
			   struct device_attribute *attr, char *buf)
{
	struct ipoib_dev_priv *priv = netdev_priv(to_net_dev(dev));

	return sprintf(buf, "%d\n", test_bit(IPOIB_FLAG_UMCAST, &priv->flags));
}

1958
void ipoib_set_umcast(struct net_device *ndev, int umcast_val)
1959
{
1960
	struct ipoib_dev_priv *priv = netdev_priv(ndev);
1961 1962 1963 1964 1965 1966 1967

	if (umcast_val > 0) {
		set_bit(IPOIB_FLAG_UMCAST, &priv->flags);
		ipoib_warn(priv, "ignoring multicast groups joined directly "
				"by userspace\n");
	} else
		clear_bit(IPOIB_FLAG_UMCAST, &priv->flags);
1968 1969 1970 1971 1972 1973 1974 1975 1976
}

static ssize_t set_umcast(struct device *dev,
			  struct device_attribute *attr,
			  const char *buf, size_t count)
{
	unsigned long umcast_val = simple_strtoul(buf, NULL, 0);

	ipoib_set_umcast(to_net_dev(dev), umcast_val);
1977 1978 1979 1980 1981 1982 1983 1984 1985 1986

	return count;
}
static DEVICE_ATTR(umcast, S_IWUSR | S_IRUGO, show_umcast, set_umcast);

int ipoib_add_umcast_attr(struct net_device *dev)
{
	return device_create_file(&dev->dev, &dev_attr_umcast);
}

1987 1988 1989 1990 1991
static void set_base_guid(struct ipoib_dev_priv *priv, union ib_gid *gid)
{
	struct ipoib_dev_priv *child_priv;
	struct net_device *netdev = priv->dev;

1992
	netif_addr_lock_bh(netdev);
1993 1994 1995 1996 1997 1998 1999

	memcpy(&priv->local_gid.global.interface_id,
	       &gid->global.interface_id,
	       sizeof(gid->global.interface_id));
	memcpy(netdev->dev_addr + 4, &priv->local_gid, sizeof(priv->local_gid));
	clear_bit(IPOIB_FLAG_DEV_ADDR_SET, &priv->flags);

2000
	netif_addr_unlock_bh(netdev);
2001 2002 2003 2004 2005 2006 2007 2008 2009 2010 2011 2012 2013 2014 2015

	if (!test_bit(IPOIB_FLAG_SUBINTERFACE, &priv->flags)) {
		down_read(&priv->vlan_rwsem);
		list_for_each_entry(child_priv, &priv->child_intfs, list)
			set_base_guid(child_priv, gid);
		up_read(&priv->vlan_rwsem);
	}
}

static int ipoib_check_lladdr(struct net_device *dev,
			      struct sockaddr_storage *ss)
{
	union ib_gid *gid = (union ib_gid *)(ss->__data + 4);
	int ret = 0;

2016
	netif_addr_lock_bh(dev);
2017 2018 2019 2020 2021 2022 2023 2024 2025

	/* Make sure the QPN, reserved and subnet prefix match the current
	 * lladdr, it also makes sure the lladdr is unicast.
	 */
	if (memcmp(dev->dev_addr, ss->__data,
		   4 + sizeof(gid->global.subnet_prefix)) ||
	    gid->global.interface_id == 0)
		ret = -EINVAL;

2026
	netif_addr_unlock_bh(dev);
2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050

	return ret;
}

static int ipoib_set_mac(struct net_device *dev, void *addr)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct sockaddr_storage *ss = addr;
	int ret;

	if (!(dev->priv_flags & IFF_LIVE_ADDR_CHANGE) && netif_running(dev))
		return -EBUSY;

	ret = ipoib_check_lladdr(dev, ss);
	if (ret)
		return ret;

	set_base_guid(priv, (union ib_gid *)(ss->__data + 4));

	queue_work(ipoib_workqueue, &priv->flush_light);

	return 0;
}

2051 2052
static ssize_t create_child(struct device *dev,
			    struct device_attribute *attr,
L
Linus Torvalds 已提交
2053 2054 2055 2056 2057 2058 2059 2060
			    const char *buf, size_t count)
{
	int pkey;
	int ret;

	if (sscanf(buf, "%i", &pkey) != 1)
		return -EINVAL;

2061
	if (pkey <= 0 || pkey > 0xffff || pkey == 0x8000)
L
Linus Torvalds 已提交
2062 2063
		return -EINVAL;

2064 2065 2066 2067 2068 2069
	/*
	 * Set the full membership bit, so that we join the right
	 * broadcast group, etc.
	 */
	pkey |= 0x8000;

2070
	ret = ipoib_vlan_add(to_net_dev(dev), pkey);
L
Linus Torvalds 已提交
2071 2072 2073

	return ret ? ret : count;
}
2074
static DEVICE_ATTR(create_child, S_IWUSR, NULL, create_child);
L
Linus Torvalds 已提交
2075

2076 2077
static ssize_t delete_child(struct device *dev,
			    struct device_attribute *attr,
L
Linus Torvalds 已提交
2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088
			    const char *buf, size_t count)
{
	int pkey;
	int ret;

	if (sscanf(buf, "%i", &pkey) != 1)
		return -EINVAL;

	if (pkey < 0 || pkey > 0xffff)
		return -EINVAL;

2089
	ret = ipoib_vlan_delete(to_net_dev(dev), pkey);
L
Linus Torvalds 已提交
2090 2091 2092 2093

	return ret ? ret : count;

}
2094
static DEVICE_ATTR(delete_child, S_IWUSR, NULL, delete_child);
L
Linus Torvalds 已提交
2095 2096 2097

int ipoib_add_pkey_attr(struct net_device *dev)
{
2098
	return device_create_file(&dev->dev, &dev_attr_pkey);
L
Linus Torvalds 已提交
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 2109
		if (priv->hca_caps & IB_DEVICE_UD_TSO)
			priv->dev->hw_features |= NETIF_F_TSO;
O
Or Gerlitz 已提交
2110

2111 2112
		priv->dev->features |= priv->dev->hw_features;
	}
2113 2114
}

L
Linus Torvalds 已提交
2115 2116 2117 2118
static struct net_device *ipoib_add_port(const char *format,
					 struct ib_device *hca, u8 port)
{
	struct ipoib_dev_priv *priv;
2119
	struct ib_port_attr attr;
L
Linus Torvalds 已提交
2120 2121 2122 2123 2124 2125
	int result = -ENOMEM;

	priv = ipoib_intf_alloc(format);
	if (!priv)
		goto alloc_mem_failed;

2126
	SET_NETDEV_DEV(priv->dev, hca->dev.parent);
E
Eli Cohen 已提交
2127
	priv->dev->dev_id = port - 1;
L
Linus Torvalds 已提交
2128

2129 2130
	result = ib_query_port(hca, port, &attr);
	if (!result)
2131 2132 2133 2134 2135 2136 2137 2138 2139 2140
		priv->max_ib_mtu = ib_mtu_enum_to_int(attr.max_mtu);
	else {
		printk(KERN_WARNING "%s: ib_query_port %d failed\n",
		       hca->name, port);
		goto device_init_failed;
	}

	/* MTU will be reset when mcast join happens */
	priv->dev->mtu  = IPOIB_UD_MTU(priv->max_ib_mtu);
	priv->mcast_mtu  = priv->admin_mtu = priv->dev->mtu;
2141
	priv->dev->max_mtu = IPOIB_CM_MTU;
2142

2143 2144
	priv->dev->neigh_priv_len = sizeof(struct ipoib_neigh);

L
Linus Torvalds 已提交
2145 2146 2147 2148
	result = ib_query_pkey(hca, port, 0, &priv->pkey);
	if (result) {
		printk(KERN_WARNING "%s: ib_query_pkey port %d failed (ret = %d)\n",
		       hca->name, port, result);
E
Eli Cohen 已提交
2149
		goto device_init_failed;
L
Linus Torvalds 已提交
2150 2151
	}

2152
	ipoib_set_dev_features(priv, hca);
V
Vladimir Sokolovsky 已提交
2153

2154 2155 2156 2157 2158 2159
	/*
	 * Set the full membership bit, so that we join the right
	 * broadcast group, etc.
	 */
	priv->pkey |= 0x8000;

L
Linus Torvalds 已提交
2160 2161 2162
	priv->dev->broadcast[8] = priv->pkey >> 8;
	priv->dev->broadcast[9] = priv->pkey & 0xff;

2163
	result = ib_query_gid(hca, port, 0, &priv->local_gid, NULL);
L
Linus Torvalds 已提交
2164 2165 2166
	if (result) {
		printk(KERN_WARNING "%s: ib_query_gid port %d failed (ret = %d)\n",
		       hca->name, port, result);
E
Eli Cohen 已提交
2167
		goto device_init_failed;
L
Linus Torvalds 已提交
2168 2169
	} else
		memcpy(priv->dev->dev_addr + 4, priv->local_gid.raw, sizeof (union ib_gid));
2170
	set_bit(IPOIB_FLAG_DEV_ADDR_SET, &priv->flags);
L
Linus Torvalds 已提交
2171 2172 2173 2174 2175 2176 2177 2178 2179 2180 2181 2182 2183 2184 2185 2186 2187 2188 2189 2190 2191 2192 2193 2194 2195

	result = ipoib_dev_init(priv->dev, hca, port);
	if (result < 0) {
		printk(KERN_WARNING "%s: failed to initialize port %d (ret = %d)\n",
		       hca->name, port, result);
		goto device_init_failed;
	}

	INIT_IB_EVENT_HANDLER(&priv->event_handler,
			      priv->ca, ipoib_event);
	result = ib_register_event_handler(&priv->event_handler);
	if (result < 0) {
		printk(KERN_WARNING "%s: ib_register_event_handler failed for "
		       "port %d (ret = %d)\n",
		       hca->name, port, result);
		goto event_failed;
	}

	result = register_netdev(priv->dev);
	if (result) {
		printk(KERN_WARNING "%s: couldn't register ipoib port %d; error %d\n",
		       hca->name, port, result);
		goto register_failed;
	}

2196 2197
	if (ipoib_cm_add_mode_attr(priv->dev))
		goto sysfs_failed;
L
Linus Torvalds 已提交
2198 2199
	if (ipoib_add_pkey_attr(priv->dev))
		goto sysfs_failed;
2200 2201
	if (ipoib_add_umcast_attr(priv->dev))
		goto sysfs_failed;
2202
	if (device_create_file(&priv->dev->dev, &dev_attr_create_child))
L
Linus Torvalds 已提交
2203
		goto sysfs_failed;
2204
	if (device_create_file(&priv->dev->dev, &dev_attr_delete_child))
L
Linus Torvalds 已提交
2205 2206 2207 2208 2209 2210 2211 2212 2213
		goto sysfs_failed;

	return priv->dev;

sysfs_failed:
	unregister_netdev(priv->dev);

register_failed:
	ib_unregister_event_handler(&priv->event_handler);
2214
	flush_workqueue(ipoib_workqueue);
2215 2216 2217
	/* Stop GC if started before flush */
	set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
	cancel_delayed_work(&priv->neigh_reap_task);
2218
	flush_workqueue(priv->wq);
L
Linus Torvalds 已提交
2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234

event_failed:
	ipoib_dev_cleanup(priv->dev);

device_init_failed:
	free_netdev(priv->dev);

alloc_mem_failed:
	return ERR_PTR(result);
}

static void ipoib_add_one(struct ib_device *device)
{
	struct list_head *dev_list;
	struct net_device *dev;
	struct ipoib_dev_priv *priv;
2235
	int p;
M
Michael Wang 已提交
2236
	int count = 0;
T
Tom Tucker 已提交
2237

L
Linus Torvalds 已提交
2238 2239 2240 2241 2242 2243
	dev_list = kmalloc(sizeof *dev_list, GFP_KERNEL);
	if (!dev_list)
		return;

	INIT_LIST_HEAD(dev_list);

2244
	for (p = rdma_start_port(device); p <= rdma_end_port(device); ++p) {
M
Michael Wang 已提交
2245
		if (!rdma_protocol_ib(device, p))
E
Eli Cohen 已提交
2246
			continue;
L
Linus Torvalds 已提交
2247 2248 2249 2250
		dev = ipoib_add_port("ib%d", device, p);
		if (!IS_ERR(dev)) {
			priv = netdev_priv(dev);
			list_add_tail(&priv->list, dev_list);
M
Michael Wang 已提交
2251
			count++;
L
Linus Torvalds 已提交
2252 2253 2254
		}
	}

M
Michael Wang 已提交
2255 2256 2257 2258 2259
	if (!count) {
		kfree(dev_list);
		return;
	}

L
Linus Torvalds 已提交
2260 2261 2262
	ib_set_client_data(device, &ipoib_client, dev_list);
}

2263
static void ipoib_remove_one(struct ib_device *device, void *client_data)
L
Linus Torvalds 已提交
2264 2265
{
	struct ipoib_dev_priv *priv, *tmp;
2266
	struct list_head *dev_list = client_data;
L
Linus Torvalds 已提交
2267

2268 2269
	if (!dev_list)
		return;
L
Linus Torvalds 已提交
2270 2271 2272

	list_for_each_entry_safe(priv, tmp, dev_list, list) {
		ib_unregister_event_handler(&priv->event_handler);
2273
		flush_workqueue(ipoib_workqueue);
2274

2275 2276 2277
		/* mark interface in the middle of destruction */
		set_bit(IPOIB_FLAG_GOING_DOWN, &priv->flags);

2278 2279 2280 2281
		rtnl_lock();
		dev_change_flags(priv->dev, priv->dev->flags & ~IFF_UP);
		rtnl_unlock();

2282 2283 2284
		/* Stop GC */
		set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
		cancel_delayed_work(&priv->neigh_reap_task);
2285
		flush_workqueue(priv->wq);
L
Linus Torvalds 已提交
2286 2287 2288 2289

		unregister_netdev(priv->dev);
		free_netdev(priv->dev);
	}
2290 2291

	kfree(dev_list);
L
Linus Torvalds 已提交
2292 2293
}

2294 2295 2296 2297 2298 2299
#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
static struct notifier_block ipoib_netdev_notifier = {
	.notifier_call = ipoib_netdev_event,
};
#endif

L
Linus Torvalds 已提交
2300 2301 2302 2303
static int __init ipoib_init_module(void)
{
	int ret;

2304 2305 2306 2307 2308 2309
	ipoib_recvq_size = roundup_pow_of_two(ipoib_recvq_size);
	ipoib_recvq_size = min(ipoib_recvq_size, IPOIB_MAX_QUEUE_SIZE);
	ipoib_recvq_size = max(ipoib_recvq_size, IPOIB_MIN_QUEUE_SIZE);

	ipoib_sendq_size = roundup_pow_of_two(ipoib_sendq_size);
	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 2312 2313
#ifdef CONFIG_INFINIBAND_IPOIB_CM
	ipoib_max_conn_qp = min(ipoib_max_conn_qp, IPOIB_CM_MAX_CONN_QP);
#endif
2314

2315 2316 2317 2318 2319 2320
	/*
	 * When copying small received packets, we only copy from the
	 * linear data part of the SKB, so we rely on this condition.
	 */
	BUILD_BUG_ON(IPOIB_CM_COPYBREAK > IPOIB_CM_HEAD_SIZE);

L
Linus Torvalds 已提交
2321 2322 2323 2324 2325
	ret = ipoib_register_debugfs();
	if (ret)
		return ret;

	/*
2326 2327 2328 2329 2330 2331 2332 2333
	 * We create a global workqueue here that is used for all flush
	 * operations.  However, if you attempt to flush a workqueue
	 * from a task on that same workqueue, it deadlocks the system.
	 * We want to be able to flush the tasks associated with a
	 * specific net device, so we also create a workqueue for each
	 * netdevice.  We queue up the tasks for that device only on
	 * its private workqueue, and we only queue up flush events
	 * on our global flush workqueue.  This avoids the deadlocks.
L
Linus Torvalds 已提交
2334
	 */
2335 2336
	ipoib_workqueue = alloc_ordered_workqueue("ipoib_flush",
						  WQ_MEM_RECLAIM);
L
Linus Torvalds 已提交
2337 2338 2339 2340 2341
	if (!ipoib_workqueue) {
		ret = -ENOMEM;
		goto err_fs;
	}

2342 2343
	ib_sa_register_client(&ipoib_sa_client);

L
Linus Torvalds 已提交
2344 2345
	ret = ib_register_client(&ipoib_client);
	if (ret)
2346
		goto err_sa;
L
Linus Torvalds 已提交
2347

O
Or Gerlitz 已提交
2348 2349 2350 2351
	ret = ipoib_netlink_init();
	if (ret)
		goto err_client;

2352 2353 2354
#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
	register_netdevice_notifier(&ipoib_netdev_notifier);
#endif
L
Linus Torvalds 已提交
2355 2356
	return 0;

O
Or Gerlitz 已提交
2357 2358 2359
err_client:
	ib_unregister_client(&ipoib_client);

2360 2361
err_sa:
	ib_sa_unregister_client(&ipoib_sa_client);
L
Linus Torvalds 已提交
2362 2363
	destroy_workqueue(ipoib_workqueue);

2364 2365 2366
err_fs:
	ipoib_unregister_debugfs();

L
Linus Torvalds 已提交
2367 2368 2369 2370 2371
	return ret;
}

static void __exit ipoib_cleanup_module(void)
{
2372 2373 2374
#ifdef CONFIG_INFINIBAND_IPOIB_DEBUG
	unregister_netdevice_notifier(&ipoib_netdev_notifier);
#endif
O
Or Gerlitz 已提交
2375
	ipoib_netlink_fini();
L
Linus Torvalds 已提交
2376
	ib_unregister_client(&ipoib_client);
2377
	ib_sa_unregister_client(&ipoib_sa_client);
2378
	ipoib_unregister_debugfs();
L
Linus Torvalds 已提交
2379 2380 2381 2382 2383
	destroy_workqueue(ipoib_workqueue);
}

module_init(ipoib_init_module);
module_exit(ipoib_cleanup_module);