ipoib_main.c 43.8 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 54 55
#define DRV_VERSION "1.0.0"

const char ipoib_driver_version[] = DRV_VERSION;

L
Linus Torvalds 已提交
56 57 58
MODULE_AUTHOR("Roland Dreier");
MODULE_DESCRIPTION("IP-over-InfiniBand net driver");
MODULE_LICENSE("Dual BSD/GPL");
59
MODULE_VERSION(DRV_VERSION);
L
Linus Torvalds 已提交
60

61 62 63 64 65 66 67 68
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 已提交
69 70 71 72 73 74 75
#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

76 77 78 79 80
struct ipoib_path_iter {
	struct net_device *dev;
	struct ipoib_path  path;
};

L
Linus Torvalds 已提交
81 82 83 84 85 86 87 88
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;

89 90
struct ib_sa_client ipoib_sa_client;

L
Linus Torvalds 已提交
91 92
static void ipoib_add_one(struct ib_device *device);
static void ipoib_remove_one(struct ib_device *device);
93
static void ipoib_neigh_reclaim(struct rcu_head *rp);
L
Linus Torvalds 已提交
94 95 96 97 98 99 100 101 102 103 104 105 106

static struct ib_client ipoib_client = {
	.name   = "ipoib",
	.add    = ipoib_add_one,
	.remove = ipoib_remove_one
};

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

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

107 108
	netif_carrier_off(dev);

109
	set_bit(IPOIB_FLAG_ADMIN_UP, &priv->flags);
L
Linus Torvalds 已提交
110 111 112 113

	if (ipoib_pkey_dev_delay_open(dev))
		return 0;

114 115
	if (ipoib_ib_dev_open(dev))
		goto err_disable;
116

117 118
	if (ipoib_ib_dev_up(dev))
		goto err_stop;
L
Linus Torvalds 已提交
119 120 121 122 123

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

		/* Bring up any child interfaces too */
124
		down_read(&priv->vlan_rwsem);
L
Linus Torvalds 已提交
125 126 127 128 129 130 131 132 133
		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);
		}
134
		up_read(&priv->vlan_rwsem);
L
Linus Torvalds 已提交
135 136 137 138 139
	}

	netif_start_queue(dev);

	return 0;
140 141 142 143 144 145 146 147

err_stop:
	ipoib_ib_dev_stop(dev, 1);

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

	return -EINVAL;
L
Linus Torvalds 已提交
148 149 150 151 152 153 154 155 156 157 158 159
}

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);

160
	ipoib_ib_dev_down(dev, 1);
161
	ipoib_ib_dev_stop(dev, 0);
L
Linus Torvalds 已提交
162 163 164 165 166

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

		/* Bring down any child interfaces too */
167
		down_read(&priv->vlan_rwsem);
L
Linus Torvalds 已提交
168 169 170 171 172 173 174 175 176
		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);
		}
177
		up_read(&priv->vlan_rwsem);
L
Linus Torvalds 已提交
178 179 180 181 182
	}

	return 0;
}

O
Or Gerlitz 已提交
183 184 185 186 187
static void ipoib_uninit(struct net_device *dev)
{
	ipoib_dev_cleanup(dev);
}

188
static netdev_features_t ipoib_fix_features(struct net_device *dev, netdev_features_t features)
189 190 191 192 193 194 195 196 197
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

	if (test_bit(IPOIB_FLAG_ADMIN_CM, &priv->flags))
		features &= ~(NETIF_F_SG | NETIF_F_IP_CSUM | NETIF_F_TSO);

	return features;
}

L
Linus Torvalds 已提交
198 199 200 201
static int ipoib_change_mtu(struct net_device *dev, int new_mtu)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

202
	/* dev->mtu > 2K ==> connected mode */
203 204 205 206
	if (ipoib_cm_admin_enabled(dev)) {
		if (new_mtu > ipoib_cm_max_mtu(dev))
			return -EINVAL;

207 208 209
		if (new_mtu > priv->mcast_mtu)
			ipoib_warn(priv, "mtu > %d will cause multicast packet drops.\n",
				   priv->mcast_mtu);
210

211 212 213 214
		dev->mtu = new_mtu;
		return 0;
	}

215
	if (new_mtu > IPOIB_UD_MTU(priv->max_ib_mtu))
L
Linus Torvalds 已提交
216 217 218 219 220 221 222 223 224
		return -EINVAL;

	priv->admin_mtu = new_mtu;

	dev->mtu = min(priv->mcast_mtu, priv->admin_mtu);

	return 0;
}

225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255
int ipoib_set_mode(struct net_device *dev, const char *buf)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

	/* 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);
		rtnl_unlock();
		priv->tx_wr.send_flags &= ~IB_SEND_IP_CSUM;

		ipoib_flush_paths(dev);
		rtnl_lock();
		return 0;
	}

	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);
		rtnl_lock();
		return 0;
	}

	return -EINVAL;
}

256
static struct ipoib_path *__path_find(struct net_device *dev, void *gid)
L
Linus Torvalds 已提交
257 258 259 260 261 262 263 264 265
{
	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);

266
		ret = memcmp(gid, path->pathrec.dgid.raw,
L
Linus Torvalds 已提交
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
			     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);

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

319 320
	/* remove all neigh connected to this path */
	ipoib_del_neighs_by_gid(dev, path->pathrec.dgid.raw);
L
Linus Torvalds 已提交
321 322 323 324 325 326 327

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

	kfree(path);
}

328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385
#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 */

386 387 388 389 390 391 392 393
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 已提交
394
		ipoib_dbg(priv, "mark path LID 0x%04x GID %pI6 invalid\n",
395
			be16_to_cpu(path->pathrec.dlid),
396
			path->pathrec.dgid.raw);
397 398 399 400 401 402
		path->valid =  0;
	}

	spin_unlock_irq(&priv->lock);
}

L
Linus Torvalds 已提交
403 404 405 406 407
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);
408
	unsigned long flags;
L
Linus Torvalds 已提交
409

410 411
	netif_tx_lock_bh(dev);
	spin_lock_irqsave(&priv->lock, flags);
L
Linus Torvalds 已提交
412

413
	list_splice_init(&priv->path_list, &remove_list);
L
Linus Torvalds 已提交
414 415 416 417 418 419 420

	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);
421 422
		spin_unlock_irqrestore(&priv->lock, flags);
		netif_tx_unlock_bh(dev);
L
Linus Torvalds 已提交
423 424
		wait_for_completion(&path->done);
		path_free(dev, path);
425 426
		netif_tx_lock_bh(dev);
		spin_lock_irqsave(&priv->lock, flags);
L
Linus Torvalds 已提交
427
	}
428 429 430

	spin_unlock_irqrestore(&priv->lock, flags);
	netif_tx_unlock_bh(dev);
L
Linus Torvalds 已提交
431 432 433 434 435 436 437 438 439 440
}

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;
441
	struct ipoib_ah *old_ah = NULL;
442
	struct ipoib_neigh *neigh, *tn;
L
Linus Torvalds 已提交
443 444 445 446
	struct sk_buff_head skqueue;
	struct sk_buff *skb;
	unsigned long flags;

447
	if (!status)
H
Harvey Harrison 已提交
448
		ipoib_dbg(priv, "PathRec LID 0x%04x for GID %pI6\n",
449
			  be16_to_cpu(pathrec->dlid), pathrec->dgid.raw);
L
Linus Torvalds 已提交
450
	else
H
Harvey Harrison 已提交
451
		ipoib_dbg(priv, "PathRec status %d for GID %pI6\n",
452
			  status, path->pathrec.dgid.raw);
L
Linus Torvalds 已提交
453 454 455 456

	skb_queue_head_init(&skqueue);

	if (!status) {
457 458 459 460
		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 已提交
461 462 463 464
	}

	spin_lock_irqsave(&priv->lock, flags);

465
	if (!IS_ERR_OR_NULL(ah)) {
L
Linus Torvalds 已提交
466 467
		path->pathrec = *pathrec;

468 469 470
		old_ah   = path->ah;
		path->ah = ah;

L
Linus Torvalds 已提交
471 472 473 474 475 476
		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);

477
		list_for_each_entry_safe(neigh, tn, &path->neigh_list, list) {
478 479 480 481 482 483 484 485 486 487 488
			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 已提交
489 490 491
			kref_get(&path->ah->ref);
			neigh->ah = path->ah;

492
			if (ipoib_cm_enabled(dev, neigh->daddr)) {
493 494 495 496 497
				if (!ipoib_cm_get(neigh))
					ipoib_cm_set(neigh, ipoib_cm_create_tx(dev,
									       path,
									       neigh));
				if (!ipoib_cm_get(neigh)) {
498
					ipoib_neigh_free(neigh);
499 500 501 502
					continue;
				}
			}

L
Linus Torvalds 已提交
503 504 505
			while ((skb = __skb_dequeue(&neigh->queue)))
				__skb_queue_tail(&skqueue, skb);
		}
506
		path->valid = 1;
507
	}
L
Linus Torvalds 已提交
508

509
	path->query = NULL;
L
Linus Torvalds 已提交
510 511 512 513
	complete(&path->done);

	spin_unlock_irqrestore(&priv->lock, flags);

514 515 516
	if (IS_ERR_OR_NULL(ah))
		ipoib_del_neighs_by_gid(dev, path->pathrec.dgid.raw);

517 518 519
	if (old_ah)
		ipoib_put_ah(old_ah);

L
Linus Torvalds 已提交
520 521 522 523 524 525 526 527
	while ((skb = __skb_dequeue(&skqueue))) {
		skb->dev = dev;
		if (dev_queue_xmit(skb))
			ipoib_warn(priv, "dev_queue_xmit failed "
				   "to requeue packet\n");
	}
}

528
static struct ipoib_path *path_rec_create(struct net_device *dev, void *gid)
L
Linus Torvalds 已提交
529 530 531 532
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct ipoib_path *path;

533 534 535
	if (!priv->broadcast)
		return NULL;

536
	path = kzalloc(sizeof *path, GFP_ATOMIC);
L
Linus Torvalds 已提交
537 538 539
	if (!path)
		return NULL;

540
	path->dev = dev;
L
Linus Torvalds 已提交
541 542 543 544 545

	skb_queue_head_init(&path->queue);

	INIT_LIST_HEAD(&path->neigh_list);

546
	memcpy(path->pathrec.dgid.raw, gid, sizeof (union ib_gid));
547 548
	path->pathrec.sgid	    = priv->local_gid;
	path->pathrec.pkey	    = cpu_to_be16(priv->pkey);
549 550
	path->pathrec.numb_path     = 1;
	path->pathrec.traffic_class = priv->broadcast->mcmember.traffic_class;
L
Linus Torvalds 已提交
551 552 553 554 555 556 557 558 559

	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 已提交
560
	ipoib_dbg(priv, "Start path record lookup for %pI6\n",
561
		  path->pathrec.dgid.raw);
L
Linus Torvalds 已提交
562

563 564
	init_completion(&path->done);

L
Linus Torvalds 已提交
565
	path->query_id =
566
		ib_sa_path_rec_get(&ipoib_sa_client, priv->ca, priv->port,
L
Linus Torvalds 已提交
567 568 569 570
				   &path->pathrec,
				   IB_SA_PATH_REC_DGID		|
				   IB_SA_PATH_REC_SGID		|
				   IB_SA_PATH_REC_NUMB_PATH	|
571
				   IB_SA_PATH_REC_TRAFFIC_CLASS |
L
Linus Torvalds 已提交
572 573 574 575 576
				   IB_SA_PATH_REC_PKEY,
				   1000, GFP_ATOMIC,
				   path_rec_completion,
				   path, &path->query);
	if (path->query_id < 0) {
577
		ipoib_warn(priv, "ib_sa_path_rec_get failed: %d\n", path->query_id);
L
Linus Torvalds 已提交
578
		path->query = NULL;
579
		complete(&path->done);
L
Linus Torvalds 已提交
580 581 582 583 584 585
		return path->query_id;
	}

	return 0;
}

586 587
static void neigh_add_path(struct sk_buff *skb, u8 *daddr,
			   struct net_device *dev)
L
Linus Torvalds 已提交
588 589 590 591
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct ipoib_path *path;
	struct ipoib_neigh *neigh;
592
	unsigned long flags;
L
Linus Torvalds 已提交
593

594
	spin_lock_irqsave(&priv->lock, flags);
595
	neigh = ipoib_neigh_alloc(daddr, dev);
L
Linus Torvalds 已提交
596
	if (!neigh) {
597
		spin_unlock_irqrestore(&priv->lock, flags);
598
		++dev->stats.tx_dropped;
L
Linus Torvalds 已提交
599 600 601 602
		dev_kfree_skb_any(skb);
		return;
	}

603
	path = __path_find(dev, daddr + 4);
L
Linus Torvalds 已提交
604
	if (!path) {
605
		path = path_rec_create(dev, daddr + 4);
L
Linus Torvalds 已提交
606
		if (!path)
607
			goto err_path;
L
Linus Torvalds 已提交
608 609 610 611 612 613

		__path_add(dev, path);
	}

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

614
	if (path->ah) {
L
Linus Torvalds 已提交
615 616 617
		kref_get(&path->ah->ref);
		neigh->ah = path->ah;

618
		if (ipoib_cm_enabled(dev, neigh->daddr)) {
619 620 621
			if (!ipoib_cm_get(neigh))
				ipoib_cm_set(neigh, ipoib_cm_create_tx(dev, path, neigh));
			if (!ipoib_cm_get(neigh)) {
622
				ipoib_neigh_free(neigh);
623 624 625 626 627 628 629 630 631
				goto err_drop;
			}
			if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE)
				__skb_queue_tail(&neigh->queue, skb);
			else {
				ipoib_warn(priv, "queue length limit %d. Packet drop.\n",
					   skb_queue_len(&neigh->queue));
				goto err_drop;
			}
632 633
		} else {
			spin_unlock_irqrestore(&priv->lock, flags);
634 635
			ipoib_send(dev, skb, path->ah, IPOIB_QPN(daddr));
			ipoib_neigh_put(neigh);
636 637
			return;
		}
L
Linus Torvalds 已提交
638 639 640 641
	} else {
		neigh->ah  = NULL;

		if (!path->query && path_rec_start(dev, path))
642
			goto err_path;
643 644

		__skb_queue_tail(&neigh->queue, skb);
L
Linus Torvalds 已提交
645 646
	}

647
	spin_unlock_irqrestore(&priv->lock, flags);
648
	ipoib_neigh_put(neigh);
L
Linus Torvalds 已提交
649 650
	return;

651
err_path:
652
	ipoib_neigh_free(neigh);
653
err_drop:
654
	++dev->stats.tx_dropped;
L
Linus Torvalds 已提交
655 656
	dev_kfree_skb_any(skb);

657
	spin_unlock_irqrestore(&priv->lock, flags);
658
	ipoib_neigh_put(neigh);
L
Linus Torvalds 已提交
659 660 661
}

static void unicast_arp_send(struct sk_buff *skb, struct net_device *dev,
662
			     struct ipoib_cb *cb)
L
Linus Torvalds 已提交
663 664 665
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);
	struct ipoib_path *path;
666
	unsigned long flags;
L
Linus Torvalds 已提交
667

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

670
	path = __path_find(dev, cb->hwaddr + 4);
671
	if (!path || !path->valid) {
672 673 674
		int new_path = 0;

		if (!path) {
675
			path = path_rec_create(dev, cb->hwaddr + 4);
676 677
			new_path = 1;
		}
L
Linus Torvalds 已提交
678 679 680
		if (path) {
			__skb_queue_tail(&path->queue, skb);

681
			if (!path->query && path_rec_start(dev, path)) {
682
				spin_unlock_irqrestore(&priv->lock, flags);
683 684
				if (new_path)
					path_free(dev, path);
L
Linus Torvalds 已提交
685 686 687 688
				return;
			} else
				__path_add(dev, path);
		} else {
689
			++dev->stats.tx_dropped;
L
Linus Torvalds 已提交
690 691 692
			dev_kfree_skb_any(skb);
		}

693
		spin_unlock_irqrestore(&priv->lock, flags);
L
Linus Torvalds 已提交
694 695 696
		return;
	}

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

701
		spin_unlock_irqrestore(&priv->lock, flags);
702
		ipoib_send(dev, skb, path->ah, IPOIB_QPN(cb->hwaddr));
703
		return;
L
Linus Torvalds 已提交
704 705 706 707
	} else if ((path->query || !path_rec_start(dev, path)) &&
		   skb_queue_len(&path->queue) < IPOIB_MAX_PATH_REC_QUEUE) {
		__skb_queue_tail(&path->queue, skb);
	} else {
708
		++dev->stats.tx_dropped;
L
Linus Torvalds 已提交
709 710 711
		dev_kfree_skb_any(skb);
	}

712
	spin_unlock_irqrestore(&priv->lock, flags);
L
Linus Torvalds 已提交
713 714 715 716 717 718
}

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;
719 720
	struct ipoib_cb *cb = (struct ipoib_cb *) skb->cb;
	struct ipoib_header *header;
L
Linus Torvalds 已提交
721 722
	unsigned long flags;

723 724 725 726 727 728 729
	header = (struct ipoib_header *) skb->data;

	if (unlikely(cb->hwaddr[4] == 0xff)) {
		/* 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)) &&
730 731
		    (header->proto != htons(ETH_P_RARP)) &&
		    (header->proto != htons(ETH_P_TIPC))) {
732
			/* ethertype not supported by IPoIB */
733 734
			++dev->stats.tx_dropped;
			dev_kfree_skb_any(skb);
735
			return NETDEV_TX_OK;
736
		}
737 738 739 740 741 742 743 744 745
		/* Add in the P_Key for multicast*/
		cb->hwaddr[8] = (priv->pkey >> 8) & 0xff;
		cb->hwaddr[9] = priv->pkey & 0xff;

		neigh = ipoib_neigh_get(dev, cb->hwaddr);
		if (likely(neigh))
			goto send_using_neigh;
		ipoib_mcast_send(dev, cb->hwaddr, skb);
		return NETDEV_TX_OK;
746
	}
L
Linus Torvalds 已提交
747

748 749 750 751
	/* unicast, arrange "switch" according to probability */
	switch (header->proto) {
	case htons(ETH_P_IP):
	case htons(ETH_P_IPV6):
752
	case htons(ETH_P_TIPC):
753 754 755 756
		neigh = ipoib_neigh_get(dev, cb->hwaddr);
		if (unlikely(!neigh)) {
			neigh_add_path(skb, cb->hwaddr, dev);
			return NETDEV_TX_OK;
757
		}
758 759 760 761 762 763 764 765 766 767 768 769
		break;
	case htons(ETH_P_ARP):
	case htons(ETH_P_RARP):
		/* for unicast ARP and RARP should always perform path find */
		unicast_arp_send(skb, dev, cb);
		return NETDEV_TX_OK;
	default:
		/* ethertype not supported by IPoIB */
		++dev->stats.tx_dropped;
		dev_kfree_skb_any(skb);
		return NETDEV_TX_OK;
	}
770

771 772 773 774 775 776
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 已提交
777
		}
778 779 780 781
	} else if (neigh->ah) {
		ipoib_send(dev, skb, neigh->ah, IPOIB_QPN(cb->hwaddr));
		goto unref;
	}
L
Linus Torvalds 已提交
782

783 784 785 786
	if (skb_queue_len(&neigh->queue) < IPOIB_MAX_PATH_REC_QUEUE) {
		spin_lock_irqsave(&priv->lock, flags);
		__skb_queue_tail(&neigh->queue, skb);
		spin_unlock_irqrestore(&priv->lock, flags);
L
Linus Torvalds 已提交
787
	} else {
788 789 790
		++dev->stats.tx_dropped;
		dev_kfree_skb_any(skb);
	}
L
Linus Torvalds 已提交
791

792 793
unref:
	ipoib_neigh_put(neigh);
L
Linus Torvalds 已提交
794 795 796 797 798 799 800 801

	return NETDEV_TX_OK;
}

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

802 803 804 805 806
	ipoib_warn(priv, "transmit timeout: latency %d msecs\n",
		   jiffies_to_msecs(jiffies - dev->trans_start));
	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 已提交
807 808 809 810 811 812
	/* XXX reset QP, etc. */
}

static int ipoib_hard_header(struct sk_buff *skb,
			     struct net_device *dev,
			     unsigned short type,
813
			     const void *daddr, const void *saddr, unsigned len)
L
Linus Torvalds 已提交
814 815
{
	struct ipoib_header *header;
816
	struct ipoib_cb *cb = (struct ipoib_cb *) skb->cb;
L
Linus Torvalds 已提交
817 818 819 820 821 822 823

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

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

	/*
824
	 * we don't rely on dst_entry structure,  always stuff the
825 826
	 * destination address into skb->cb so we can figure out where
	 * to send the packet later.
L
Linus Torvalds 已提交
827
	 */
828
	memcpy(cb->hwaddr, daddr, INFINIBAND_ALEN);
L
Linus Torvalds 已提交
829

830
	return sizeof *header;
L
Linus Torvalds 已提交
831 832 833 834 835 836
}

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

L
Leonid Arsh 已提交
837 838 839 840 841
	if (!test_bit(IPOIB_FLAG_OPER_UP, &priv->flags)) {
		ipoib_dbg(priv, "IPOIB_FLAG_OPER_UP not set");
		return;
	}

842
	queue_work(ipoib_workqueue, &priv->restart_task);
L
Linus Torvalds 已提交
843 844
}

845
static u32 ipoib_addr_hash(struct ipoib_neigh_hash *htbl, u8 *daddr)
L
Linus Torvalds 已提交
846
{
847 848 849 850 851 852 853
	/*
	 * 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) */
854
	u32 *d32 = (u32 *) daddr;
855 856
	u32 hv;

857
	hv = jhash_3words(d32[3], d32[4], IPOIB_QPN_MASK & d32[0], 0);
858 859 860 861 862 863 864 865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902
	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;
			}
			neigh->alive = jiffies;
			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 已提交
903
	unsigned long flags;
904
	int i;
L
Linus Torvalds 已提交
905

906
	if (test_bit(IPOIB_STOP_NEIGH_GC, &priv->flags))
907
		return;
L
Linus Torvalds 已提交
908

909
	spin_lock_irqsave(&priv->lock, flags);
910 911

	htbl = rcu_dereference_protected(ntbl->htbl,
912
					 lockdep_is_held(&priv->lock));
913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928

	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,
929
							  lockdep_is_held(&priv->lock))) != NULL) {
930 931 932 933
			/* was the neigh idle for two GC periods */
			if (time_after(neigh_obsolete, neigh->alive)) {
				rcu_assign_pointer(*np,
						   rcu_dereference_protected(neigh->hnext,
934
									     lockdep_is_held(&priv->lock)));
935 936 937 938 939 940
				/* remove from path/mc list */
				list_del(&neigh->list);
				call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
			} else {
				np = &neigh->hnext;
			}
L
Linus Torvalds 已提交
941

942 943
		}
	}
L
Linus Torvalds 已提交
944

945
out_unlock:
946
	spin_unlock_irqrestore(&priv->lock, flags);
947
}
L
Linus Torvalds 已提交
948

949 950 951 952 953 954 955 956 957 958
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))
		queue_delayed_work(ipoib_workqueue, &priv->neigh_reap_task,
				   arp_tbl.gc_interval);
L
Linus Torvalds 已提交
959 960
}

961 962

static struct ipoib_neigh *ipoib_neigh_ctor(u8 *daddr,
963
				      struct net_device *dev)
964 965 966
{
	struct ipoib_neigh *neigh;

967
	neigh = kzalloc(sizeof *neigh, GFP_ATOMIC);
968 969 970
	if (!neigh)
		return NULL;

971
	neigh->dev = dev;
972
	memcpy(&neigh->daddr, daddr, sizeof(neigh->daddr));
973
	skb_queue_head_init(&neigh->queue);
974
	INIT_LIST_HEAD(&neigh->list);
975
	ipoib_cm_set(neigh, NULL);
976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991
	/* 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,
992
					 lockdep_is_held(&priv->lock));
993 994 995 996 997 998 999 1000 1001 1002
	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],
1003
					       lockdep_is_held(&priv->lock));
1004 1005
	     neigh != NULL;
	     neigh = rcu_dereference_protected(neigh->hnext,
1006
					       lockdep_is_held(&priv->lock))) {
1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028
		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],
1029
						     lockdep_is_held(&priv->lock)));
1030 1031 1032 1033
	rcu_assign_pointer(htbl->buckets[hash_val], neigh);
	atomic_inc(&ntbl->entries);

out_unlock:
1034 1035 1036 1037

	return neigh;
}

1038
void ipoib_neigh_dtor(struct ipoib_neigh *neigh)
1039
{
1040 1041 1042
	/* neigh reference count was dropprd to zero */
	struct net_device *dev = neigh->dev;
	struct ipoib_dev_priv *priv = netdev_priv(dev);
1043
	struct sk_buff *skb;
1044 1045
	if (neigh->ah)
		ipoib_put_ah(neigh->ah);
1046
	while ((skb = __skb_dequeue(&neigh->queue))) {
1047
		++dev->stats.tx_dropped;
1048 1049
		dev_kfree_skb_any(skb);
	}
1050 1051
	if (ipoib_cm_get(neigh))
		ipoib_cm_destroy_tx(ipoib_cm_get(neigh));
1052 1053 1054 1055
	ipoib_dbg(netdev_priv(dev),
		  "neigh free for %06x %pI6\n",
		  IPOIB_QPN(neigh->daddr),
		  neigh->daddr + 4);
1056
	kfree(neigh);
1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068
	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);
1069 1070
}

1071
void ipoib_neigh_free(struct ipoib_neigh *neigh)
L
Linus Torvalds 已提交
1072
{
1073 1074 1075 1076 1077 1078 1079 1080 1081
	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,
1082
					lockdep_is_held(&priv->lock));
1083
	if (!htbl)
1084
		return;
1085 1086 1087 1088

	hash_val = ipoib_addr_hash(htbl, neigh->daddr);
	np = &htbl->buckets[hash_val];
	for (n = rcu_dereference_protected(*np,
1089
					    lockdep_is_held(&priv->lock));
1090
	     n != NULL;
1091
	     n = rcu_dereference_protected(*np,
1092
					lockdep_is_held(&priv->lock))) {
1093 1094 1095 1096
		if (n == neigh) {
			/* found */
			rcu_assign_pointer(*np,
					   rcu_dereference_protected(neigh->hnext,
1097
								     lockdep_is_held(&priv->lock)));
1098 1099
			/* remove from parent list */
			list_del(&neigh->list);
1100
			call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
1101
			return;
1102 1103 1104 1105 1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130
		} 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;
	struct ipoib_neigh **buckets;
	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;
	ntbl->htbl = htbl;
1131
	htbl->ntbl = ntbl;
1132 1133 1134 1135 1136 1137
	atomic_set(&ntbl->entries, 0);

	/* start garbage collection */
	clear_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
	queue_delayed_work(ipoib_workqueue, &priv->neigh_reap_task,
			   arp_tbl.gc_interval);
L
Linus Torvalds 已提交
1138 1139 1140 1141

	return 0;
}

1142 1143 1144 1145 1146 1147
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;
1148
	struct ipoib_neigh_table *ntbl = htbl->ntbl;
1149 1150 1151

	kfree(buckets);
	kfree(htbl);
1152
	complete(&ntbl->deleted);
1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163
}

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 */
1164
	spin_lock_irqsave(&priv->lock, flags);
1165 1166

	htbl = rcu_dereference_protected(ntbl->htbl,
1167
					 lockdep_is_held(&priv->lock));
1168 1169 1170 1171 1172 1173 1174 1175 1176

	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,
1177
							  lockdep_is_held(&priv->lock))) != NULL) {
1178 1179 1180 1181
			/* 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,
1182
									     lockdep_is_held(&priv->lock)));
1183 1184 1185 1186 1187 1188 1189 1190 1191 1192
				/* remove from parent list */
				list_del(&neigh->list);
				call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
			} else {
				np = &neigh->hnext;
			}

		}
	}
out_unlock:
1193
	spin_unlock_irqrestore(&priv->lock, flags);
1194 1195 1196 1197 1198 1199 1200
}

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;
1201
	int i, wait_flushed = 0;
1202

1203
	init_completion(&priv->ntbl.flushed);
1204

1205
	spin_lock_irqsave(&priv->lock, flags);
1206 1207

	htbl = rcu_dereference_protected(ntbl->htbl,
1208
					lockdep_is_held(&priv->lock));
1209 1210 1211
	if (!htbl)
		goto out_unlock;

1212 1213 1214 1215
	wait_flushed = atomic_read(&priv->ntbl.entries);
	if (!wait_flushed)
		goto free_htbl;

1216 1217 1218 1219 1220
	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,
1221
				       lockdep_is_held(&priv->lock))) != NULL) {
1222 1223
			rcu_assign_pointer(*np,
					   rcu_dereference_protected(neigh->hnext,
1224
								     lockdep_is_held(&priv->lock)));
1225 1226 1227 1228 1229 1230
			/* remove from path/mc list */
			list_del(&neigh->list);
			call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
		}
	}

1231
free_htbl:
1232 1233 1234 1235
	rcu_assign_pointer(ntbl->htbl, NULL);
	call_rcu(&htbl->rcu, neigh_hash_free_rcu);

out_unlock:
1236
	spin_unlock_irqrestore(&priv->lock, flags);
1237 1238
	if (wait_flushed)
		wait_for_completion(&priv->ntbl.flushed);
1239 1240 1241 1242 1243 1244 1245 1246
}

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");
1247
	init_completion(&priv->ntbl.deleted);
1248 1249 1250 1251 1252 1253 1254
	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);

1255 1256 1257
	ipoib_flush_neighs(priv);

	wait_for_completion(&priv->ntbl.deleted);
1258 1259 1260
}


L
Linus Torvalds 已提交
1261 1262 1263 1264
int ipoib_dev_init(struct net_device *dev, struct ib_device *ca, int port)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

1265 1266
	if (ipoib_neigh_hash_init(priv) < 0)
		goto out;
L
Linus Torvalds 已提交
1267
	/* Allocate RX/TX "rings" to hold queued skbs */
1268
	priv->rx_ring =	kzalloc(ipoib_recvq_size * sizeof *priv->rx_ring,
L
Linus Torvalds 已提交
1269 1270 1271
				GFP_KERNEL);
	if (!priv->rx_ring) {
		printk(KERN_WARNING "%s: failed to allocate RX ring (%d entries)\n",
1272
		       ca->name, ipoib_recvq_size);
1273
		goto out_neigh_hash_cleanup;
L
Linus Torvalds 已提交
1274 1275
	}

1276
	priv->tx_ring = vzalloc(ipoib_sendq_size * sizeof *priv->tx_ring);
L
Linus Torvalds 已提交
1277 1278
	if (!priv->tx_ring) {
		printk(KERN_WARNING "%s: failed to allocate TX ring (%d entries)\n",
1279
		       ca->name, ipoib_sendq_size);
L
Linus Torvalds 已提交
1280 1281 1282
		goto out_rx_ring_cleanup;
	}

1283
	/* priv->tx_head, tx_tail & tx_outstanding are already 0 */
L
Linus Torvalds 已提交
1284 1285 1286 1287 1288 1289 1290

	if (ipoib_ib_dev_init(dev, ca, port))
		goto out_tx_ring_cleanup;

	return 0;

out_tx_ring_cleanup:
1291
	vfree(priv->tx_ring);
L
Linus Torvalds 已提交
1292 1293 1294 1295

out_rx_ring_cleanup:
	kfree(priv->rx_ring);

1296 1297
out_neigh_hash_cleanup:
	ipoib_neigh_hash_uninit(dev);
L
Linus Torvalds 已提交
1298 1299 1300 1301 1302 1303 1304
out:
	return -ENOMEM;
}

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

	ASSERT_RTNL();
L
Linus Torvalds 已提交
1308

1309
	ipoib_delete_debug_files(dev);
L
Linus Torvalds 已提交
1310 1311 1312

	/* Delete any child interfaces first */
	list_for_each_entry_safe(cpriv, tcpriv, &priv->child_intfs, list) {
1313 1314 1315
		/* Stop GC on child */
		set_bit(IPOIB_STOP_NEIGH_GC, &cpriv->flags);
		cancel_delayed_work(&cpriv->neigh_reap_task);
O
Or Gerlitz 已提交
1316
		unregister_netdevice_queue(cpriv->dev, &head);
L
Linus Torvalds 已提交
1317
	}
O
Or Gerlitz 已提交
1318
	unregister_netdevice_many(&head);
L
Linus Torvalds 已提交
1319 1320 1321

	ipoib_ib_dev_cleanup(dev);

1322
	kfree(priv->rx_ring);
1323
	vfree(priv->tx_ring);
L
Linus Torvalds 已提交
1324

1325 1326
	priv->rx_ring = NULL;
	priv->tx_ring = NULL;
1327 1328

	ipoib_neigh_hash_uninit(dev);
L
Linus Torvalds 已提交
1329 1330
}

1331 1332 1333 1334
static const struct header_ops ipoib_header_ops = {
	.create	= ipoib_hard_header,
};

1335
static const struct net_device_ops ipoib_netdev_ops = {
O
Or Gerlitz 已提交
1336
	.ndo_uninit		 = ipoib_uninit,
1337 1338 1339
	.ndo_open		 = ipoib_open,
	.ndo_stop		 = ipoib_stop,
	.ndo_change_mtu		 = ipoib_change_mtu,
1340
	.ndo_fix_features	 = ipoib_fix_features,
1341 1342
	.ndo_start_xmit	 	 = ipoib_start_xmit,
	.ndo_tx_timeout		 = ipoib_timeout,
1343
	.ndo_set_rx_mode	 = ipoib_set_mcast_list,
1344 1345
};

O
Or Gerlitz 已提交
1346
void ipoib_setup(struct net_device *dev)
L
Linus Torvalds 已提交
1347 1348 1349
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

1350
	dev->netdev_ops		 = &ipoib_netdev_ops;
1351
	dev->header_ops		 = &ipoib_header_ops;
1352

E
Eli Cohen 已提交
1353 1354
	ipoib_set_ethtool_ops(dev);

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

1357
	dev->watchdog_timeo	 = HZ;
L
Linus Torvalds 已提交
1358

1359
	dev->flags		|= IFF_BROADCAST | IFF_MULTICAST;
L
Linus Torvalds 已提交
1360

1361
	dev->hard_header_len	 = IPOIB_ENCAP_LEN;
1362 1363 1364
	dev->addr_len		 = INFINIBAND_ALEN;
	dev->type		 = ARPHRD_INFINIBAND;
	dev->tx_queue_len	 = ipoib_sendq_size * 2;
E
Eli Cohen 已提交
1365 1366
	dev->features		 = (NETIF_F_VLAN_CHALLENGED	|
				    NETIF_F_HIGHDMA);
1367
	dev->priv_flags		&= ~IFF_XMIT_DST_RELEASE;
L
Linus Torvalds 已提交
1368 1369 1370 1371 1372 1373 1374

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

	priv->dev = dev;

	spin_lock_init(&priv->lock);

1375
	init_rwsem(&priv->vlan_rwsem);
L
Linus Torvalds 已提交
1376 1377 1378 1379 1380 1381

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

1382
	INIT_DELAYED_WORK(&priv->pkey_poll_task, ipoib_pkey_poll);
D
David Howells 已提交
1383
	INIT_DELAYED_WORK(&priv->mcast_task,   ipoib_mcast_join_task);
1384
	INIT_WORK(&priv->carrier_on_task, ipoib_mcast_carrier_on_task);
1385 1386 1387
	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 已提交
1388 1389
	INIT_WORK(&priv->restart_task, ipoib_mcast_restart_task);
	INIT_DELAYED_WORK(&priv->ah_reap_task, ipoib_reap_ah);
1390
	INIT_DELAYED_WORK(&priv->neigh_reap_task, ipoib_reap_neigh);
L
Linus Torvalds 已提交
1391 1392 1393 1394 1395 1396 1397 1398 1399 1400 1401 1402 1403 1404
}

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

	dev = alloc_netdev((int) sizeof (struct ipoib_dev_priv), name,
			   ipoib_setup);
	if (!dev)
		return NULL;

	return netdev_priv(dev);
}

1405 1406
static ssize_t show_pkey(struct device *dev,
			 struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
1407
{
1408
	struct ipoib_dev_priv *priv = netdev_priv(to_net_dev(dev));
L
Linus Torvalds 已提交
1409 1410 1411

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

1414 1415 1416 1417 1418 1419 1420 1421
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));
}

1422
void ipoib_set_umcast(struct net_device *ndev, int umcast_val)
1423
{
1424
	struct ipoib_dev_priv *priv = netdev_priv(ndev);
1425 1426 1427 1428 1429 1430 1431

	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);
1432 1433 1434 1435 1436 1437 1438 1439 1440
}

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);
1441 1442 1443 1444 1445 1446 1447 1448 1449 1450

	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);
}

1451 1452
static ssize_t create_child(struct device *dev,
			    struct device_attribute *attr,
L
Linus Torvalds 已提交
1453 1454 1455 1456 1457 1458 1459 1460
			    const char *buf, size_t count)
{
	int pkey;
	int ret;

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

1461
	if (pkey <= 0 || pkey > 0xffff || pkey == 0x8000)
L
Linus Torvalds 已提交
1462 1463
		return -EINVAL;

1464 1465 1466 1467 1468 1469
	/*
	 * Set the full membership bit, so that we join the right
	 * broadcast group, etc.
	 */
	pkey |= 0x8000;

1470
	ret = ipoib_vlan_add(to_net_dev(dev), pkey);
L
Linus Torvalds 已提交
1471 1472 1473

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

1476 1477
static ssize_t delete_child(struct device *dev,
			    struct device_attribute *attr,
L
Linus Torvalds 已提交
1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488
			    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;

1489
	ret = ipoib_vlan_delete(to_net_dev(dev), pkey);
L
Linus Torvalds 已提交
1490 1491 1492 1493

	return ret ? ret : count;

}
1494
static DEVICE_ATTR(delete_child, S_IWUSR, NULL, delete_child);
L
Linus Torvalds 已提交
1495 1496 1497

int ipoib_add_pkey_attr(struct net_device *dev)
{
1498
	return device_create_file(&dev->dev, &dev_attr_pkey);
L
Linus Torvalds 已提交
1499 1500
}

1501 1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524
int ipoib_set_dev_features(struct ipoib_dev_priv *priv, struct ib_device *hca)
{
	struct ib_device_attr *device_attr;
	int result = -ENOMEM;

	device_attr = kmalloc(sizeof *device_attr, GFP_KERNEL);
	if (!device_attr) {
		printk(KERN_WARNING "%s: allocation of %zu bytes failed\n",
		       hca->name, sizeof *device_attr);
		return result;
	}

	result = ib_query_device(hca, device_attr);
	if (result) {
		printk(KERN_WARNING "%s: ib_query_device failed (ret = %d)\n",
		       hca->name, result);
		kfree(device_attr);
		return result;
	}
	priv->hca_caps = device_attr->device_cap_flags;

	kfree(device_attr);

	if (priv->hca_caps & IB_DEVICE_UD_IP_CSUM) {
1525 1526
		priv->dev->hw_features = NETIF_F_SG |
			NETIF_F_IP_CSUM | NETIF_F_RXCSUM;
1527

1528 1529
		if (priv->hca_caps & IB_DEVICE_UD_TSO)
			priv->dev->hw_features |= NETIF_F_TSO;
O
Or Gerlitz 已提交
1530

1531 1532
		priv->dev->features |= priv->dev->hw_features;
	}
1533 1534 1535 1536

	return 0;
}

L
Linus Torvalds 已提交
1537 1538 1539 1540
static struct net_device *ipoib_add_port(const char *format,
					 struct ib_device *hca, u8 port)
{
	struct ipoib_dev_priv *priv;
1541
	struct ib_port_attr attr;
L
Linus Torvalds 已提交
1542 1543 1544 1545 1546 1547 1548
	int result = -ENOMEM;

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

	SET_NETDEV_DEV(priv->dev, hca->dma_device);
E
Eli Cohen 已提交
1549
	priv->dev->dev_id = port - 1;
L
Linus Torvalds 已提交
1550

1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562
	if (!ib_query_port(hca, port, &attr))
		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;

1563 1564
	priv->dev->neigh_priv_len = sizeof(struct ipoib_neigh);

L
Linus Torvalds 已提交
1565 1566 1567 1568
	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 已提交
1569
		goto device_init_failed;
L
Linus Torvalds 已提交
1570 1571
	}

1572
	if (ipoib_set_dev_features(priv, hca))
1573
		goto device_init_failed;
V
Vladimir Sokolovsky 已提交
1574

1575 1576 1577 1578 1579 1580
	/*
	 * Set the full membership bit, so that we join the right
	 * broadcast group, etc.
	 */
	priv->pkey |= 0x8000;

L
Linus Torvalds 已提交
1581 1582 1583 1584 1585 1586 1587
	priv->dev->broadcast[8] = priv->pkey >> 8;
	priv->dev->broadcast[9] = priv->pkey & 0xff;

	result = ib_query_gid(hca, port, 0, &priv->local_gid);
	if (result) {
		printk(KERN_WARNING "%s: ib_query_gid port %d failed (ret = %d)\n",
		       hca->name, port, result);
E
Eli Cohen 已提交
1588
		goto device_init_failed;
L
Linus Torvalds 已提交
1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611 1612 1613 1614 1615
	} else
		memcpy(priv->dev->dev_addr + 4, priv->local_gid.raw, sizeof (union ib_gid));

	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;
	}

1616
	ipoib_create_debug_files(priv->dev);
L
Linus Torvalds 已提交
1617

1618 1619
	if (ipoib_cm_add_mode_attr(priv->dev))
		goto sysfs_failed;
L
Linus Torvalds 已提交
1620 1621
	if (ipoib_add_pkey_attr(priv->dev))
		goto sysfs_failed;
1622 1623
	if (ipoib_add_umcast_attr(priv->dev))
		goto sysfs_failed;
1624
	if (device_create_file(&priv->dev->dev, &dev_attr_create_child))
L
Linus Torvalds 已提交
1625
		goto sysfs_failed;
1626
	if (device_create_file(&priv->dev->dev, &dev_attr_delete_child))
L
Linus Torvalds 已提交
1627 1628 1629 1630 1631
		goto sysfs_failed;

	return priv->dev;

sysfs_failed:
1632
	ipoib_delete_debug_files(priv->dev);
L
Linus Torvalds 已提交
1633 1634 1635 1636
	unregister_netdev(priv->dev);

register_failed:
	ib_unregister_event_handler(&priv->event_handler);
1637 1638 1639
	/* Stop GC if started before flush */
	set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
	cancel_delayed_work(&priv->neigh_reap_task);
1640
	flush_workqueue(ipoib_workqueue);
L
Linus Torvalds 已提交
1641 1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655 1656 1657 1658

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;
	int s, e, p;

T
Tom Tucker 已提交
1659 1660 1661
	if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
		return;

L
Linus Torvalds 已提交
1662 1663 1664 1665 1666 1667
	dev_list = kmalloc(sizeof *dev_list, GFP_KERNEL);
	if (!dev_list)
		return;

	INIT_LIST_HEAD(dev_list);

T
Tom Tucker 已提交
1668
	if (device->node_type == RDMA_NODE_IB_SWITCH) {
L
Linus Torvalds 已提交
1669 1670 1671 1672 1673 1674 1675 1676
		s = 0;
		e = 0;
	} else {
		s = 1;
		e = device->phys_port_cnt;
	}

	for (p = s; p <= e; ++p) {
E
Eli Cohen 已提交
1677 1678
		if (rdma_port_get_link_layer(device, p) != IB_LINK_LAYER_INFINIBAND)
			continue;
L
Linus Torvalds 已提交
1679 1680 1681 1682 1683 1684 1685 1686 1687 1688 1689 1690 1691 1692 1693
		dev = ipoib_add_port("ib%d", device, p);
		if (!IS_ERR(dev)) {
			priv = netdev_priv(dev);
			list_add_tail(&priv->list, dev_list);
		}
	}

	ib_set_client_data(device, &ipoib_client, dev_list);
}

static void ipoib_remove_one(struct ib_device *device)
{
	struct ipoib_dev_priv *priv, *tmp;
	struct list_head *dev_list;

T
Tom Tucker 已提交
1694 1695 1696
	if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
		return;

L
Linus Torvalds 已提交
1697
	dev_list = ib_get_client_data(device, &ipoib_client);
1698 1699
	if (!dev_list)
		return;
L
Linus Torvalds 已提交
1700 1701 1702

	list_for_each_entry_safe(priv, tmp, dev_list, list) {
		ib_unregister_event_handler(&priv->event_handler);
1703 1704 1705 1706 1707

		rtnl_lock();
		dev_change_flags(priv->dev, priv->dev->flags & ~IFF_UP);
		rtnl_unlock();

1708 1709 1710
		/* Stop GC */
		set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
		cancel_delayed_work(&priv->neigh_reap_task);
1711
		flush_workqueue(ipoib_workqueue);
L
Linus Torvalds 已提交
1712 1713 1714 1715

		unregister_netdev(priv->dev);
		free_netdev(priv->dev);
	}
1716 1717

	kfree(dev_list);
L
Linus Torvalds 已提交
1718 1719 1720 1721 1722 1723
}

static int __init ipoib_init_module(void)
{
	int ret;

1724 1725 1726 1727 1728 1729
	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);
1730
	ipoib_sendq_size = max3(ipoib_sendq_size, 2 * MAX_SEND_CQE, IPOIB_MIN_QUEUE_SIZE);
1731 1732 1733
#ifdef CONFIG_INFINIBAND_IPOIB_CM
	ipoib_max_conn_qp = min(ipoib_max_conn_qp, IPOIB_CM_MAX_CONN_QP);
#endif
1734

1735 1736 1737 1738 1739 1740
	/*
	 * 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 已提交
1741 1742 1743 1744 1745 1746 1747 1748 1749 1750 1751 1752 1753 1754 1755 1756 1757 1758
	ret = ipoib_register_debugfs();
	if (ret)
		return ret;

	/*
	 * We create our own workqueue mainly because we want to be
	 * able to flush it when devices are being removed.  We can't
	 * use schedule_work()/flush_scheduled_work() because both
	 * unregister_netdev() and linkwatch_event take the rtnl lock,
	 * so flush_scheduled_work() can deadlock during device
	 * removal.
	 */
	ipoib_workqueue = create_singlethread_workqueue("ipoib");
	if (!ipoib_workqueue) {
		ret = -ENOMEM;
		goto err_fs;
	}

1759 1760
	ib_sa_register_client(&ipoib_sa_client);

L
Linus Torvalds 已提交
1761 1762
	ret = ib_register_client(&ipoib_client);
	if (ret)
1763
		goto err_sa;
L
Linus Torvalds 已提交
1764

O
Or Gerlitz 已提交
1765 1766 1767 1768
	ret = ipoib_netlink_init();
	if (ret)
		goto err_client;

L
Linus Torvalds 已提交
1769 1770
	return 0;

O
Or Gerlitz 已提交
1771 1772 1773
err_client:
	ib_unregister_client(&ipoib_client);

1774 1775
err_sa:
	ib_sa_unregister_client(&ipoib_sa_client);
L
Linus Torvalds 已提交
1776 1777
	destroy_workqueue(ipoib_workqueue);

1778 1779 1780
err_fs:
	ipoib_unregister_debugfs();

L
Linus Torvalds 已提交
1781 1782 1783 1784 1785
	return ret;
}

static void __exit ipoib_cleanup_module(void)
{
O
Or Gerlitz 已提交
1786
	ipoib_netlink_fini();
L
Linus Torvalds 已提交
1787
	ib_unregister_client(&ipoib_client);
1788
	ib_sa_unregister_client(&ipoib_sa_client);
1789
	ipoib_unregister_debugfs();
L
Linus Torvalds 已提交
1790 1791 1792 1793 1794
	destroy_workqueue(ipoib_workqueue);
}

module_init(ipoib_init_module);
module_exit(ipoib_cleanup_module);