ipoib_main.c 44.3 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
	if (ipoib_ib_dev_open(dev)) {
112 113
		if (!test_bit(IPOIB_PKEY_ASSIGNED, &priv->flags))
			return 0;
114
		goto err_disable;
115
	}
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

err_stop:
142
	ipoib_ib_dev_stop(dev);
143 144 145 146 147

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 161
	ipoib_ib_dev_down(dev);
	ipoib_ib_dev_stop(dev);
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
	struct ipoib_cb *cb = ipoib_skb_cb(skb);
720
	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 = ipoib_skb_cb(skb);
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(priv->wq, &priv->restart_task);
L
Linus Torvalds 已提交
843 844
}

845 846 847 848 849 850 851
static int ipoib_get_iflink(const struct net_device *dev)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

	return priv->parent->ifindex;
}

852
static u32 ipoib_addr_hash(struct ipoib_neigh_hash *htbl, u8 *daddr)
L
Linus Torvalds 已提交
853
{
854 855 856 857 858 859 860
	/*
	 * 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) */
861
	u32 *d32 = (u32 *) daddr;
862 863
	u32 hv;

864
	hv = jhash_3words(d32[3], d32[4], IPOIB_QPN_MASK & d32[0], 0);
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 903 904 905 906 907 908 909
	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 已提交
910
	unsigned long flags;
911
	int i;
L
Linus Torvalds 已提交
912

913
	if (test_bit(IPOIB_STOP_NEIGH_GC, &priv->flags))
914
		return;
L
Linus Torvalds 已提交
915

916
	spin_lock_irqsave(&priv->lock, flags);
917 918

	htbl = rcu_dereference_protected(ntbl->htbl,
919
					 lockdep_is_held(&priv->lock));
920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935

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

949 950
		}
	}
L
Linus Torvalds 已提交
951

952
out_unlock:
953
	spin_unlock_irqrestore(&priv->lock, flags);
954
}
L
Linus Torvalds 已提交
955

956 957 958 959 960 961 962 963
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))
964
		queue_delayed_work(priv->wq, &priv->neigh_reap_task,
965
				   arp_tbl.gc_interval);
L
Linus Torvalds 已提交
966 967
}

968 969

static struct ipoib_neigh *ipoib_neigh_ctor(u8 *daddr,
970
				      struct net_device *dev)
971 972 973
{
	struct ipoib_neigh *neigh;

974
	neigh = kzalloc(sizeof *neigh, GFP_ATOMIC);
975 976 977
	if (!neigh)
		return NULL;

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

out_unlock:
1041 1042 1043 1044

	return neigh;
}

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

1078
void ipoib_neigh_free(struct ipoib_neigh *neigh)
L
Linus Torvalds 已提交
1079
{
1080 1081 1082 1083 1084 1085 1086 1087 1088
	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,
1089
					lockdep_is_held(&priv->lock));
1090
	if (!htbl)
1091
		return;
1092 1093 1094 1095

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

	/* start garbage collection */
	clear_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
1143
	queue_delayed_work(priv->wq, &priv->neigh_reap_task,
1144
			   arp_tbl.gc_interval);
L
Linus Torvalds 已提交
1145 1146 1147 1148

	return 0;
}

1149 1150 1151 1152 1153 1154
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;
1155
	struct ipoib_neigh_table *ntbl = htbl->ntbl;
1156 1157 1158

	kfree(buckets);
	kfree(htbl);
1159
	complete(&ntbl->deleted);
1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170
}

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 */
1171
	spin_lock_irqsave(&priv->lock, flags);
1172 1173

	htbl = rcu_dereference_protected(ntbl->htbl,
1174
					 lockdep_is_held(&priv->lock));
1175 1176 1177 1178 1179 1180 1181 1182 1183

	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,
1184
							  lockdep_is_held(&priv->lock))) != NULL) {
1185 1186 1187 1188
			/* 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,
1189
									     lockdep_is_held(&priv->lock)));
1190 1191 1192 1193 1194 1195 1196 1197 1198 1199
				/* remove from parent list */
				list_del(&neigh->list);
				call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
			} else {
				np = &neigh->hnext;
			}

		}
	}
out_unlock:
1200
	spin_unlock_irqrestore(&priv->lock, flags);
1201 1202 1203 1204 1205 1206 1207
}

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;
1208
	int i, wait_flushed = 0;
1209

1210
	init_completion(&priv->ntbl.flushed);
1211

1212
	spin_lock_irqsave(&priv->lock, flags);
1213 1214

	htbl = rcu_dereference_protected(ntbl->htbl,
1215
					lockdep_is_held(&priv->lock));
1216 1217 1218
	if (!htbl)
		goto out_unlock;

1219 1220 1221 1222
	wait_flushed = atomic_read(&priv->ntbl.entries);
	if (!wait_flushed)
		goto free_htbl;

1223 1224 1225 1226 1227
	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,
1228
				       lockdep_is_held(&priv->lock))) != NULL) {
1229 1230
			rcu_assign_pointer(*np,
					   rcu_dereference_protected(neigh->hnext,
1231
								     lockdep_is_held(&priv->lock)));
1232 1233 1234 1235 1236 1237
			/* remove from path/mc list */
			list_del(&neigh->list);
			call_rcu(&neigh->rcu, ipoib_neigh_reclaim);
		}
	}

1238
free_htbl:
1239 1240 1241 1242
	rcu_assign_pointer(ntbl->htbl, NULL);
	call_rcu(&htbl->rcu, neigh_hash_free_rcu);

out_unlock:
1243
	spin_unlock_irqrestore(&priv->lock, flags);
1244 1245
	if (wait_flushed)
		wait_for_completion(&priv->ntbl.flushed);
1246 1247 1248 1249 1250 1251 1252 1253
}

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");
1254
	init_completion(&priv->ntbl.deleted);
1255 1256 1257 1258 1259 1260 1261
	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);

1262 1263 1264
	ipoib_flush_neighs(priv);

	wait_for_completion(&priv->ntbl.deleted);
1265 1266 1267
}


L
Linus Torvalds 已提交
1268 1269 1270 1271 1272
int ipoib_dev_init(struct net_device *dev, struct ib_device *ca, int port)
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

	/* Allocate RX/TX "rings" to hold queued skbs */
1273
	priv->rx_ring =	kzalloc(ipoib_recvq_size * sizeof *priv->rx_ring,
L
Linus Torvalds 已提交
1274 1275 1276
				GFP_KERNEL);
	if (!priv->rx_ring) {
		printk(KERN_WARNING "%s: failed to allocate RX ring (%d entries)\n",
1277
		       ca->name, ipoib_recvq_size);
1278
		goto out;
L
Linus Torvalds 已提交
1279 1280
	}

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

1288
	/* priv->tx_head, tx_tail & tx_outstanding are already 0 */
L
Linus Torvalds 已提交
1289 1290 1291 1292

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

1293 1294 1295 1296 1297 1298 1299
	/*
	 * Must be after ipoib_ib_dev_init so we can allocate a per
	 * device wq there and use it here
	 */
	if (ipoib_neigh_hash_init(priv) < 0)
		goto out_dev_uninit;

L
Linus Torvalds 已提交
1300 1301
	return 0;

1302 1303 1304
out_dev_uninit:
	ipoib_ib_dev_cleanup(dev);

L
Linus Torvalds 已提交
1305
out_tx_ring_cleanup:
1306
	vfree(priv->tx_ring);
L
Linus Torvalds 已提交
1307 1308 1309 1310 1311 1312 1313 1314 1315 1316 1317

out_rx_ring_cleanup:
	kfree(priv->rx_ring);

out:
	return -ENOMEM;
}

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

	ASSERT_RTNL();
L
Linus Torvalds 已提交
1321

1322
	ipoib_delete_debug_files(dev);
L
Linus Torvalds 已提交
1323 1324 1325

	/* Delete any child interfaces first */
	list_for_each_entry_safe(cpriv, tcpriv, &priv->child_intfs, list) {
1326 1327 1328
		/* Stop GC on child */
		set_bit(IPOIB_STOP_NEIGH_GC, &cpriv->flags);
		cancel_delayed_work(&cpriv->neigh_reap_task);
O
Or Gerlitz 已提交
1329
		unregister_netdevice_queue(cpriv->dev, &head);
L
Linus Torvalds 已提交
1330
	}
O
Or Gerlitz 已提交
1331
	unregister_netdevice_many(&head);
L
Linus Torvalds 已提交
1332

1333 1334 1335 1336 1337 1338
	/*
	 * Must be before ipoib_ib_dev_cleanup or we delete an in use
	 * work queue
	 */
	ipoib_neigh_hash_uninit(dev);

L
Linus Torvalds 已提交
1339 1340
	ipoib_ib_dev_cleanup(dev);

1341
	kfree(priv->rx_ring);
1342
	vfree(priv->tx_ring);
L
Linus Torvalds 已提交
1343

1344 1345
	priv->rx_ring = NULL;
	priv->tx_ring = NULL;
L
Linus Torvalds 已提交
1346 1347
}

1348 1349 1350 1351
static const struct header_ops ipoib_header_ops = {
	.create	= ipoib_hard_header,
};

1352
static const struct net_device_ops ipoib_netdev_ops = {
O
Or Gerlitz 已提交
1353
	.ndo_uninit		 = ipoib_uninit,
1354 1355 1356
	.ndo_open		 = ipoib_open,
	.ndo_stop		 = ipoib_stop,
	.ndo_change_mtu		 = ipoib_change_mtu,
1357
	.ndo_fix_features	 = ipoib_fix_features,
1358 1359
	.ndo_start_xmit	 	 = ipoib_start_xmit,
	.ndo_tx_timeout		 = ipoib_timeout,
1360
	.ndo_set_rx_mode	 = ipoib_set_mcast_list,
1361
	.ndo_get_iflink		 = ipoib_get_iflink,
1362 1363
};

O
Or Gerlitz 已提交
1364
void ipoib_setup(struct net_device *dev)
L
Linus Torvalds 已提交
1365 1366 1367
{
	struct ipoib_dev_priv *priv = netdev_priv(dev);

1368
	dev->netdev_ops		 = &ipoib_netdev_ops;
1369
	dev->header_ops		 = &ipoib_header_ops;
1370

E
Eli Cohen 已提交
1371 1372
	ipoib_set_ethtool_ops(dev);

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

1375
	dev->watchdog_timeo	 = HZ;
L
Linus Torvalds 已提交
1376

1377
	dev->flags		|= IFF_BROADCAST | IFF_MULTICAST;
L
Linus Torvalds 已提交
1378

1379
	dev->hard_header_len	 = IPOIB_ENCAP_LEN;
1380 1381 1382
	dev->addr_len		 = INFINIBAND_ALEN;
	dev->type		 = ARPHRD_INFINIBAND;
	dev->tx_queue_len	 = ipoib_sendq_size * 2;
E
Eli Cohen 已提交
1383 1384
	dev->features		 = (NETIF_F_VLAN_CHALLENGED	|
				    NETIF_F_HIGHDMA);
1385
	netif_keep_dst(dev);
L
Linus Torvalds 已提交
1386 1387 1388 1389 1390 1391 1392

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

	priv->dev = dev;

	spin_lock_init(&priv->lock);

1393
	init_rwsem(&priv->vlan_rwsem);
L
Linus Torvalds 已提交
1394 1395 1396 1397 1398 1399

	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 已提交
1400
	INIT_DELAYED_WORK(&priv->mcast_task,   ipoib_mcast_join_task);
1401
	INIT_WORK(&priv->carrier_on_task, ipoib_mcast_carrier_on_task);
1402 1403 1404
	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 已提交
1405 1406
	INIT_WORK(&priv->restart_task, ipoib_mcast_restart_task);
	INIT_DELAYED_WORK(&priv->ah_reap_task, ipoib_reap_ah);
1407
	INIT_DELAYED_WORK(&priv->neigh_reap_task, ipoib_reap_neigh);
L
Linus Torvalds 已提交
1408 1409 1410 1411 1412 1413
}

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

1414 1415
	dev = alloc_netdev((int)sizeof(struct ipoib_dev_priv), name,
			   NET_NAME_UNKNOWN, ipoib_setup);
L
Linus Torvalds 已提交
1416 1417 1418 1419 1420 1421
	if (!dev)
		return NULL;

	return netdev_priv(dev);
}

1422 1423
static ssize_t show_pkey(struct device *dev,
			 struct device_attribute *attr, char *buf)
L
Linus Torvalds 已提交
1424
{
1425
	struct ipoib_dev_priv *priv = netdev_priv(to_net_dev(dev));
L
Linus Torvalds 已提交
1426 1427 1428

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

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

1439
void ipoib_set_umcast(struct net_device *ndev, int umcast_val)
1440
{
1441
	struct ipoib_dev_priv *priv = netdev_priv(ndev);
1442 1443 1444 1445 1446 1447 1448

	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);
1449 1450 1451 1452 1453 1454 1455 1456 1457
}

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);
1458 1459 1460 1461 1462 1463 1464 1465 1466 1467

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

1468 1469
static ssize_t create_child(struct device *dev,
			    struct device_attribute *attr,
L
Linus Torvalds 已提交
1470 1471 1472 1473 1474 1475 1476 1477
			    const char *buf, size_t count)
{
	int pkey;
	int ret;

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

1478
	if (pkey <= 0 || pkey > 0xffff || pkey == 0x8000)
L
Linus Torvalds 已提交
1479 1480
		return -EINVAL;

1481 1482 1483 1484 1485 1486
	/*
	 * Set the full membership bit, so that we join the right
	 * broadcast group, etc.
	 */
	pkey |= 0x8000;

1487
	ret = ipoib_vlan_add(to_net_dev(dev), pkey);
L
Linus Torvalds 已提交
1488 1489 1490

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

1493 1494
static ssize_t delete_child(struct device *dev,
			    struct device_attribute *attr,
L
Linus Torvalds 已提交
1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505
			    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;

1506
	ret = ipoib_vlan_delete(to_net_dev(dev), pkey);
L
Linus Torvalds 已提交
1507 1508 1509 1510

	return ret ? ret : count;

}
1511
static DEVICE_ATTR(delete_child, S_IWUSR, NULL, delete_child);
L
Linus Torvalds 已提交
1512 1513 1514

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

1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541
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) {
1542 1543
		priv->dev->hw_features = NETIF_F_SG |
			NETIF_F_IP_CSUM | NETIF_F_RXCSUM;
1544

1545 1546
		if (priv->hca_caps & IB_DEVICE_UD_TSO)
			priv->dev->hw_features |= NETIF_F_TSO;
O
Or Gerlitz 已提交
1547

1548 1549
		priv->dev->features |= priv->dev->hw_features;
	}
1550 1551 1552 1553

	return 0;
}

L
Linus Torvalds 已提交
1554 1555 1556 1557
static struct net_device *ipoib_add_port(const char *format,
					 struct ib_device *hca, u8 port)
{
	struct ipoib_dev_priv *priv;
1558
	struct ib_port_attr attr;
L
Linus Torvalds 已提交
1559 1560 1561 1562 1563 1564 1565
	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 已提交
1566
	priv->dev->dev_id = port - 1;
L
Linus Torvalds 已提交
1567

1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579
	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;

1580 1581
	priv->dev->neigh_priv_len = sizeof(struct ipoib_neigh);

L
Linus Torvalds 已提交
1582 1583 1584 1585
	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 已提交
1586
		goto device_init_failed;
L
Linus Torvalds 已提交
1587 1588
	}

1589
	if (ipoib_set_dev_features(priv, hca))
1590
		goto device_init_failed;
V
Vladimir Sokolovsky 已提交
1591

1592 1593 1594 1595 1596 1597
	/*
	 * Set the full membership bit, so that we join the right
	 * broadcast group, etc.
	 */
	priv->pkey |= 0x8000;

L
Linus Torvalds 已提交
1598 1599 1600 1601 1602 1603 1604
	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 已提交
1605
		goto device_init_failed;
L
Linus Torvalds 已提交
1606 1607 1608 1609 1610 1611 1612 1613 1614 1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632
	} 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;
	}

1633
	ipoib_create_debug_files(priv->dev);
L
Linus Torvalds 已提交
1634

1635 1636
	if (ipoib_cm_add_mode_attr(priv->dev))
		goto sysfs_failed;
L
Linus Torvalds 已提交
1637 1638
	if (ipoib_add_pkey_attr(priv->dev))
		goto sysfs_failed;
1639 1640
	if (ipoib_add_umcast_attr(priv->dev))
		goto sysfs_failed;
1641
	if (device_create_file(&priv->dev->dev, &dev_attr_create_child))
L
Linus Torvalds 已提交
1642
		goto sysfs_failed;
1643
	if (device_create_file(&priv->dev->dev, &dev_attr_delete_child))
L
Linus Torvalds 已提交
1644 1645 1646 1647 1648
		goto sysfs_failed;

	return priv->dev;

sysfs_failed:
1649
	ipoib_delete_debug_files(priv->dev);
L
Linus Torvalds 已提交
1650 1651 1652 1653
	unregister_netdev(priv->dev);

register_failed:
	ib_unregister_event_handler(&priv->event_handler);
1654
	flush_workqueue(ipoib_workqueue);
1655 1656 1657
	/* Stop GC if started before flush */
	set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
	cancel_delayed_work(&priv->neigh_reap_task);
1658
	flush_workqueue(priv->wq);
L
Linus Torvalds 已提交
1659 1660 1661 1662 1663 1664 1665 1666 1667 1668 1669 1670 1671 1672 1673 1674 1675 1676

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 已提交
1677 1678 1679
	if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
		return;

L
Linus Torvalds 已提交
1680 1681 1682 1683 1684 1685
	dev_list = kmalloc(sizeof *dev_list, GFP_KERNEL);
	if (!dev_list)
		return;

	INIT_LIST_HEAD(dev_list);

T
Tom Tucker 已提交
1686
	if (device->node_type == RDMA_NODE_IB_SWITCH) {
L
Linus Torvalds 已提交
1687 1688 1689 1690 1691 1692 1693 1694
		s = 0;
		e = 0;
	} else {
		s = 1;
		e = device->phys_port_cnt;
	}

	for (p = s; p <= e; ++p) {
E
Eli Cohen 已提交
1695 1696
		if (rdma_port_get_link_layer(device, p) != IB_LINK_LAYER_INFINIBAND)
			continue;
L
Linus Torvalds 已提交
1697 1698 1699 1700 1701 1702 1703 1704 1705 1706 1707 1708 1709 1710 1711
		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 已提交
1712 1713 1714
	if (rdma_node_get_transport(device->node_type) != RDMA_TRANSPORT_IB)
		return;

L
Linus Torvalds 已提交
1715
	dev_list = ib_get_client_data(device, &ipoib_client);
1716 1717
	if (!dev_list)
		return;
L
Linus Torvalds 已提交
1718 1719 1720

	list_for_each_entry_safe(priv, tmp, dev_list, list) {
		ib_unregister_event_handler(&priv->event_handler);
1721
		flush_workqueue(ipoib_workqueue);
1722 1723 1724 1725 1726

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

1727 1728 1729
		/* Stop GC */
		set_bit(IPOIB_STOP_NEIGH_GC, &priv->flags);
		cancel_delayed_work(&priv->neigh_reap_task);
1730
		flush_workqueue(priv->wq);
L
Linus Torvalds 已提交
1731 1732 1733 1734

		unregister_netdev(priv->dev);
		free_netdev(priv->dev);
	}
1735 1736

	kfree(dev_list);
L
Linus Torvalds 已提交
1737 1738 1739 1740 1741 1742
}

static int __init ipoib_init_module(void)
{
	int ret;

1743 1744 1745 1746 1747 1748
	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);
1749
	ipoib_sendq_size = max3(ipoib_sendq_size, 2 * MAX_SEND_CQE, IPOIB_MIN_QUEUE_SIZE);
1750 1751 1752
#ifdef CONFIG_INFINIBAND_IPOIB_CM
	ipoib_max_conn_qp = min(ipoib_max_conn_qp, IPOIB_CM_MAX_CONN_QP);
#endif
1753

1754 1755 1756 1757 1758 1759
	/*
	 * 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 已提交
1760 1761 1762 1763 1764
	ret = ipoib_register_debugfs();
	if (ret)
		return ret;

	/*
1765 1766 1767 1768 1769 1770 1771 1772
	 * 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 已提交
1773
	 */
1774
	ipoib_workqueue = create_singlethread_workqueue("ipoib_flush");
L
Linus Torvalds 已提交
1775 1776 1777 1778 1779
	if (!ipoib_workqueue) {
		ret = -ENOMEM;
		goto err_fs;
	}

1780 1781
	ib_sa_register_client(&ipoib_sa_client);

L
Linus Torvalds 已提交
1782 1783
	ret = ib_register_client(&ipoib_client);
	if (ret)
1784
		goto err_sa;
L
Linus Torvalds 已提交
1785

O
Or Gerlitz 已提交
1786 1787 1788 1789
	ret = ipoib_netlink_init();
	if (ret)
		goto err_client;

L
Linus Torvalds 已提交
1790 1791
	return 0;

O
Or Gerlitz 已提交
1792 1793 1794
err_client:
	ib_unregister_client(&ipoib_client);

1795 1796
err_sa:
	ib_sa_unregister_client(&ipoib_sa_client);
L
Linus Torvalds 已提交
1797 1798
	destroy_workqueue(ipoib_workqueue);

1799 1800 1801
err_fs:
	ipoib_unregister_debugfs();

L
Linus Torvalds 已提交
1802 1803 1804 1805 1806
	return ret;
}

static void __exit ipoib_cleanup_module(void)
{
O
Or Gerlitz 已提交
1807
	ipoib_netlink_fini();
L
Linus Torvalds 已提交
1808
	ib_unregister_client(&ipoib_client);
1809
	ib_sa_unregister_client(&ipoib_sa_client);
1810
	ipoib_unregister_debugfs();
L
Linus Torvalds 已提交
1811 1812 1813 1814 1815
	destroy_workqueue(ipoib_workqueue);
}

module_init(ipoib_init_module);
module_exit(ipoib_cleanup_module);