cma.c 104 KB
Newer Older
1 2 3 4 5 6
/*
 * Copyright (c) 2005 Voltaire Inc.  All rights reserved.
 * Copyright (c) 2002-2005, Network Appliance, Inc. All rights reserved.
 * Copyright (c) 1999-2005, Mellanox Technologies, Inc. All rights reserved.
 * Copyright (c) 2005-2006 Intel Corporation.  All rights reserved.
 *
Sean Hefty's avatar
Sean Hefty committed
7 8 9 10 11
 * 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:
12
 *
Sean Hefty's avatar
Sean Hefty committed
13 14 15
 *     Redistribution and use in source and binary forms, with or
 *     without modification, are permitted provided that the following
 *     conditions are met:
16
 *
Sean Hefty's avatar
Sean Hefty committed
17 18 19
 *      - Redistributions of source code must retain the above
 *        copyright notice, this list of conditions and the following
 *        disclaimer.
20
 *
Sean Hefty's avatar
Sean Hefty committed
21 22 23 24
 *      - 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.
25
 *
Sean Hefty's avatar
Sean Hefty committed
26 27 28 29 30 31 32 33
 * 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.
34 35 36 37 38 39 40 41
 */

#include <linux/completion.h>
#include <linux/in.h>
#include <linux/in6.h>
#include <linux/mutex.h>
#include <linux/random.h>
#include <linux/idr.h>
Tom Tucker's avatar
Tom Tucker committed
42
#include <linux/inetdevice.h>
43
#include <linux/slab.h>
44
#include <linux/module.h>
45
#include <net/route.h>
46

47 48
#include <net/net_namespace.h>
#include <net/netns/generic.h>
49
#include <net/tcp.h>
Aleksey Senin's avatar
Aleksey Senin committed
50
#include <net/ipv6.h>
51 52
#include <net/ip_fib.h>
#include <net/ip6_route.h>
53 54 55

#include <rdma/rdma_cm.h>
#include <rdma/rdma_cm_ib.h>
56
#include <rdma/rdma_netlink.h>
57
#include <rdma/ib.h>
58 59 60
#include <rdma/ib_cache.h>
#include <rdma/ib_cm.h>
#include <rdma/ib_sa.h>
Tom Tucker's avatar
Tom Tucker committed
61
#include <rdma/iw_cm.h>
62 63 64 65 66 67

MODULE_AUTHOR("Sean Hefty");
MODULE_DESCRIPTION("Generic RDMA CM Agent");
MODULE_LICENSE("Dual BSD/GPL");

#define CMA_CM_RESPONSE_TIMEOUT 20
68
#define CMA_MAX_CM_RETRIES 15
69
#define CMA_CM_MRA_SETTING (IB_CM_MRA_FLAG_DELAY | 24)
70
#define CMA_IBOE_PACKET_LIFETIME 18
71

72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90
static const char * const cma_events[] = {
	[RDMA_CM_EVENT_ADDR_RESOLVED]	 = "address resolved",
	[RDMA_CM_EVENT_ADDR_ERROR]	 = "address error",
	[RDMA_CM_EVENT_ROUTE_RESOLVED]	 = "route resolved ",
	[RDMA_CM_EVENT_ROUTE_ERROR]	 = "route error",
	[RDMA_CM_EVENT_CONNECT_REQUEST]	 = "connect request",
	[RDMA_CM_EVENT_CONNECT_RESPONSE] = "connect response",
	[RDMA_CM_EVENT_CONNECT_ERROR]	 = "connect error",
	[RDMA_CM_EVENT_UNREACHABLE]	 = "unreachable",
	[RDMA_CM_EVENT_REJECTED]	 = "rejected",
	[RDMA_CM_EVENT_ESTABLISHED]	 = "established",
	[RDMA_CM_EVENT_DISCONNECTED]	 = "disconnected",
	[RDMA_CM_EVENT_DEVICE_REMOVAL]	 = "device removal",
	[RDMA_CM_EVENT_MULTICAST_JOIN]	 = "multicast join",
	[RDMA_CM_EVENT_MULTICAST_ERROR]	 = "multicast error",
	[RDMA_CM_EVENT_ADDR_CHANGE]	 = "address change",
	[RDMA_CM_EVENT_TIMEWAIT_EXIT]	 = "timewait exit",
};

91
const char *__attribute_const__ rdma_event_msg(enum rdma_cm_event_type event)
92 93 94 95 96 97 98 99
{
	size_t index = event;

	return (index < ARRAY_SIZE(cma_events) && cma_events[index]) ?
			cma_events[index] : "unrecognized event";
}
EXPORT_SYMBOL(rdma_event_msg);

100
static void cma_add_one(struct ib_device *device);
101
static void cma_remove_one(struct ib_device *device, void *client_data);
102 103 104 105 106 107 108

static struct ib_client cma_client = {
	.name   = "cma",
	.add    = cma_add_one,
	.remove = cma_remove_one
};

109
static struct ib_sa_client sa_client;
110
static struct rdma_addr_client addr_client;
111 112 113 114
static LIST_HEAD(dev_list);
static LIST_HEAD(listen_any_list);
static DEFINE_MUTEX(lock);
static struct workqueue_struct *cma_wq;
115
static int cma_pernet_id;
116

117 118 119 120 121 122 123 124 125 126 127 128 129
struct cma_pernet {
	struct idr tcp_ps;
	struct idr udp_ps;
	struct idr ipoib_ps;
	struct idr ib_ps;
};

static struct cma_pernet *cma_pernet(struct net *net)
{
	return net_generic(net, cma_pernet_id);
}

static struct idr *cma_pernet_idr(struct net *net, enum rdma_port_space ps)
130
{
131 132
	struct cma_pernet *pernet = cma_pernet(net);

133 134
	switch (ps) {
	case RDMA_PS_TCP:
135
		return &pernet->tcp_ps;
136
	case RDMA_PS_UDP:
137
		return &pernet->udp_ps;
138
	case RDMA_PS_IPOIB:
139
		return &pernet->ipoib_ps;
140
	case RDMA_PS_IB:
141
		return &pernet->ib_ps;
142 143 144 145 146
	default:
		return NULL;
	}
}

147 148 149 150 151 152 153 154 155
struct cma_device {
	struct list_head	list;
	struct ib_device	*device;
	struct completion	comp;
	atomic_t		refcount;
	struct list_head	id_list;
};

struct rdma_bind_list {
156
	enum rdma_port_space	ps;
157 158 159 160
	struct hlist_head	owners;
	unsigned short		port;
};

161
static int cma_ps_alloc(struct net *net, enum rdma_port_space ps,
162 163
			struct rdma_bind_list *bind_list, int snum)
{
164
	struct idr *idr = cma_pernet_idr(net, ps);
165 166 167 168

	return idr_alloc(idr, bind_list, snum, snum + 1, GFP_KERNEL);
}

169 170
static struct rdma_bind_list *cma_ps_find(struct net *net,
					  enum rdma_port_space ps, int snum)
171
{
172
	struct idr *idr = cma_pernet_idr(net, ps);
173 174 175 176

	return idr_find(idr, snum);
}

177
static void cma_ps_remove(struct net *net, enum rdma_port_space ps, int snum)
178
{
179
	struct idr *idr = cma_pernet_idr(net, ps);
180 181 182 183

	idr_remove(idr, snum);
}

184 185 186 187
enum {
	CMA_OPTION_AFONLY,
};

188 189 190 191 192 193 194 195 196 197 198
/*
 * Device removal can occur at anytime, so we need extra handling to
 * serialize notifying the user of device removal with other callbacks.
 * We do this by disabling removal notification while a callback is in process,
 * and reporting it after the callback completes.
 */
struct rdma_id_private {
	struct rdma_cm_id	id;

	struct rdma_bind_list	*bind_list;
	struct hlist_node	node;
199 200
	struct list_head	list; /* listen_any_list or cma_device.list */
	struct list_head	listen_list; /* per device listens */
201
	struct cma_device	*cma_dev;
202
	struct list_head	mc_list;
203

204
	int			internal_id;
205
	enum rdma_cm_state	state;
206
	spinlock_t		lock;
207 208
	struct mutex		qp_mutex;

209 210
	struct completion	comp;
	atomic_t		refcount;
211
	struct mutex		handler_mutex;
212 213 214 215 216 217 218

	int			backlog;
	int			timeout_ms;
	struct ib_sa_query	*query;
	int			query_id;
	union {
		struct ib_cm_id	*ib;
Tom Tucker's avatar
Tom Tucker committed
219
		struct iw_cm_id	*iw;
220 221 222
	} cm_id;

	u32			seq_num;
223
	u32			qkey;
224
	u32			qp_num;
225
	pid_t			owner;
226
	u32			options;
227
	u8			srq;
228
	u8			tos;
229
	u8			reuseaddr;
230
	u8			afonly;
231 232
};

233 234 235 236 237 238 239
struct cma_multicast {
	struct rdma_id_private *id_priv;
	union {
		struct ib_sa_multicast *ib;
	} multicast;
	struct list_head	list;
	void			*context;
240
	struct sockaddr_storage	addr;
241
	struct kref		mcref;
242 243
};

244 245 246
struct cma_work {
	struct work_struct	work;
	struct rdma_id_private	*id;
247 248
	enum rdma_cm_state	old_state;
	enum rdma_cm_state	new_state;
249 250 251
	struct rdma_cm_event	event;
};

252 253 254 255 256 257
struct cma_ndev_work {
	struct work_struct	work;
	struct rdma_id_private	*id;
	struct rdma_cm_event	event;
};

258 259 260 261 262 263
struct iboe_mcast_work {
	struct work_struct	 work;
	struct rdma_id_private	*id;
	struct cma_multicast	*mc;
};

264 265 266
union cma_ip_addr {
	struct in6_addr ip6;
	struct {
267 268
		__be32 pad[3];
		__be32 addr;
269 270 271 272 273 274
	} ip4;
};

struct cma_hdr {
	u8 cma_version;
	u8 ip_version;	/* IP version: 7:4 */
275
	__be16 port;
276 277 278 279 280 281
	union cma_ip_addr src_addr;
	union cma_ip_addr dst_addr;
};

#define CMA_VERSION 0x00

282 283 284 285 286 287 288 289 290
struct cma_req_info {
	struct ib_device *device;
	int port;
	union ib_gid local_gid;
	__be64 service_id;
	u16 pkey;
	bool has_gid:1;
};

291
static int cma_comp(struct rdma_id_private *id_priv, enum rdma_cm_state comp)
292 293 294 295 296 297 298 299 300 301 302
{
	unsigned long flags;
	int ret;

	spin_lock_irqsave(&id_priv->lock, flags);
	ret = (id_priv->state == comp);
	spin_unlock_irqrestore(&id_priv->lock, flags);
	return ret;
}

static int cma_comp_exch(struct rdma_id_private *id_priv,
303
			 enum rdma_cm_state comp, enum rdma_cm_state exch)
304 305 306 307 308 309 310 311 312 313 314
{
	unsigned long flags;
	int ret;

	spin_lock_irqsave(&id_priv->lock, flags);
	if ((ret = (id_priv->state == comp)))
		id_priv->state = exch;
	spin_unlock_irqrestore(&id_priv->lock, flags);
	return ret;
}

315 316
static enum rdma_cm_state cma_exch(struct rdma_id_private *id_priv,
				   enum rdma_cm_state exch)
317 318
{
	unsigned long flags;
319
	enum rdma_cm_state old;
320 321 322 323 324 325 326 327

	spin_lock_irqsave(&id_priv->lock, flags);
	old = id_priv->state;
	id_priv->state = exch;
	spin_unlock_irqrestore(&id_priv->lock, flags);
	return old;
}

328
static inline u8 cma_get_ip_ver(const struct cma_hdr *hdr)
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343
{
	return hdr->ip_version >> 4;
}

static inline void cma_set_ip_ver(struct cma_hdr *hdr, u8 ip_ver)
{
	hdr->ip_version = (ip_ver << 4) | (hdr->ip_version & 0xF);
}

static void cma_attach_to_dev(struct rdma_id_private *id_priv,
			      struct cma_device *cma_dev)
{
	atomic_inc(&cma_dev->refcount);
	id_priv->cma_dev = cma_dev;
	id_priv->id.device = cma_dev->device;
344 345
	id_priv->id.route.addr.dev_addr.transport =
		rdma_node_get_transport(cma_dev->device->node_type);
346 347 348 349 350 351 352 353 354
	list_add_tail(&id_priv->list, &cma_dev->id_list);
}

static inline void cma_deref_dev(struct cma_device *cma_dev)
{
	if (atomic_dec_and_test(&cma_dev->refcount))
		complete(&cma_dev->comp);
}

355 356 357 358 359 360 361 362
static inline void release_mc(struct kref *kref)
{
	struct cma_multicast *mc = container_of(kref, struct cma_multicast, mcref);

	kfree(mc->multicast.ib);
	kfree(mc);
}

363
static void cma_release_dev(struct rdma_id_private *id_priv)
364
{
365
	mutex_lock(&lock);
366 367 368
	list_del(&id_priv->list);
	cma_deref_dev(id_priv->cma_dev);
	id_priv->cma_dev = NULL;
369
	mutex_unlock(&lock);
370 371
}

372 373 374 375 376 377 378 379 380 381 382 383 384 385 386
static inline struct sockaddr *cma_src_addr(struct rdma_id_private *id_priv)
{
	return (struct sockaddr *) &id_priv->id.route.addr.src_addr;
}

static inline struct sockaddr *cma_dst_addr(struct rdma_id_private *id_priv)
{
	return (struct sockaddr *) &id_priv->id.route.addr.dst_addr;
}

static inline unsigned short cma_family(struct rdma_id_private *id_priv)
{
	return id_priv->id.route.addr.src_addr.ss_family;
}

Sean Hefty's avatar
Sean Hefty committed
387
static int cma_set_qkey(struct rdma_id_private *id_priv, u32 qkey)
388 389 390 391
{
	struct ib_sa_mcmember_rec rec;
	int ret = 0;

Sean Hefty's avatar
Sean Hefty committed
392 393 394
	if (id_priv->qkey) {
		if (qkey && id_priv->qkey != qkey)
			return -EINVAL;
395
		return 0;
Sean Hefty's avatar
Sean Hefty committed
396 397 398 399 400 401
	}

	if (qkey) {
		id_priv->qkey = qkey;
		return 0;
	}
402 403

	switch (id_priv->id.ps) {
404
	case RDMA_PS_UDP:
Sean Hefty's avatar
Sean Hefty committed
405
	case RDMA_PS_IB:
406
		id_priv->qkey = RDMA_UDP_QKEY;
407 408
		break;
	case RDMA_PS_IPOIB:
409 410 411 412 413 414
		ib_addr_get_mgid(&id_priv->id.route.addr.dev_addr, &rec.mgid);
		ret = ib_sa_get_mcmember_rec(id_priv->id.device,
					     id_priv->id.port_num, &rec.mgid,
					     &rec);
		if (!ret)
			id_priv->qkey = be32_to_cpu(rec.qkey);
415 416 417 418 419 420 421
		break;
	default:
		break;
	}
	return ret;
}

422 423 424 425 426 427 428 429 430 431 432 433
static void cma_translate_ib(struct sockaddr_ib *sib, struct rdma_dev_addr *dev_addr)
{
	dev_addr->dev_type = ARPHRD_INFINIBAND;
	rdma_addr_set_sgid(dev_addr, (union ib_gid *) &sib->sib_addr);
	ib_addr_set_pkey(dev_addr, ntohs(sib->sib_pkey));
}

static int cma_translate_addr(struct sockaddr *addr, struct rdma_dev_addr *dev_addr)
{
	int ret;

	if (addr->sa_family != AF_IB) {
434
		ret = rdma_translate_ip(addr, dev_addr, NULL);
435 436 437 438 439 440 441 442
	} else {
		cma_translate_ib((struct sockaddr_ib *) addr, dev_addr);
		ret = 0;
	}

	return ret;
}

443
static inline int cma_validate_port(struct ib_device *device, u8 port,
444 445
				      union ib_gid *gid, int dev_type,
				      int bound_if_index)
446 447
{
	int ret = -ENODEV;
448
	struct net_device *ndev = NULL;
449 450 451 452 453 454 455

	if ((dev_type == ARPHRD_INFINIBAND) && !rdma_protocol_ib(device, port))
		return ret;

	if ((dev_type != ARPHRD_INFINIBAND) && rdma_protocol_ib(device, port))
		return ret;

456
	if (dev_type == ARPHRD_ETHER && rdma_protocol_roce(device, port))
457 458 459 460 461 462
		ndev = dev_get_by_index(&init_net, bound_if_index);

	ret = ib_find_cached_gid_by_port(device, gid, port, ndev, NULL);

	if (ndev)
		dev_put(ndev);
463 464 465 466

	return ret;
}

467 468
static int cma_acquire_dev(struct rdma_id_private *id_priv,
			   struct rdma_id_private *listen_id_priv)
469
{
470
	struct rdma_dev_addr *dev_addr = &id_priv->id.route.addr.dev_addr;
471
	struct cma_device *cma_dev;
472
	union ib_gid gid, iboe_gid, *gidp;
473
	int ret = -ENODEV;
474
	u8 port;
475

476
	if (dev_addr->dev_type != ARPHRD_INFINIBAND &&
477 478 479
	    id_priv->id.ps == RDMA_PS_IPOIB)
		return -EINVAL;

480
	mutex_lock(&lock);
481 482 483
	rdma_ip2gid((struct sockaddr *)&id_priv->id.route.addr.src_addr,
		    &iboe_gid);

484 485
	memcpy(&gid, dev_addr->src_dev_addr +
	       rdma_addr_gid_offset(dev_addr), sizeof gid);
486 487

	if (listen_id_priv) {
488 489
		cma_dev = listen_id_priv->cma_dev;
		port = listen_id_priv->id.port_num;
490
		gidp = rdma_protocol_roce(cma_dev->device, port) ?
491
		       &iboe_gid : &gid;
492

493
		ret = cma_validate_port(cma_dev->device, port, gidp,
494 495
					dev_addr->dev_type,
					dev_addr->bound_dev_if);
496 497
		if (!ret) {
			id_priv->id.port_num = port;
498 499 500
			goto out;
		}
	}
501

502
	list_for_each_entry(cma_dev, &dev_list, list) {
503
		for (port = 1; port <= cma_dev->device->phys_port_cnt; ++port) {
504 505 506 507
			if (listen_id_priv &&
			    listen_id_priv->cma_dev == cma_dev &&
			    listen_id_priv->id.port_num == port)
				continue;
508

509
			gidp = rdma_protocol_roce(cma_dev->device, port) ?
510 511 512
			       &iboe_gid : &gid;

			ret = cma_validate_port(cma_dev->device, port, gidp,
513 514
						dev_addr->dev_type,
						dev_addr->bound_dev_if);
515 516 517
			if (!ret) {
				id_priv->id.port_num = port;
				goto out;
518
			}
519 520
		}
	}
521 522 523 524 525

out:
	if (!ret)
		cma_attach_to_dev(id_priv, cma_dev);

526
	mutex_unlock(&lock);
527 528 529
	return ret;
}

530 531 532 533 534 535 536 537 538
/*
 * Select the source IB device and address to reach the destination IB address.
 */
static int cma_resolve_ib_dev(struct rdma_id_private *id_priv)
{
	struct cma_device *cma_dev, *cur_dev;
	struct sockaddr_ib *addr;
	union ib_gid gid, sgid, *dgid;
	u16 pkey, index;
Paul Bolle's avatar
Paul Bolle committed
539
	u8 p;
540 541 542 543 544 545 546 547 548
	int i;

	cma_dev = NULL;
	addr = (struct sockaddr_ib *) cma_dst_addr(id_priv);
	dgid = (union ib_gid *) &addr->sib_addr;
	pkey = ntohs(addr->sib_pkey);

	list_for_each_entry(cur_dev, &dev_list, list) {
		for (p = 1; p <= cur_dev->device->phys_port_cnt; ++p) {
549
			if (!rdma_cap_af_ib(cur_dev->device, p))
550 551
				continue;

552 553 554
			if (ib_find_cached_pkey(cur_dev->device, p, pkey, &index))
				continue;

555 556 557
			for (i = 0; !ib_get_cached_gid(cur_dev->device, p, i,
						       &gid, NULL);
			     i++) {
558 559 560
				if (!memcmp(&gid, dgid, sizeof(gid))) {
					cma_dev = cur_dev;
					sgid = gid;
Paul Bolle's avatar
Paul Bolle committed
561
					id_priv->id.port_num = p;
562 563 564 565 566 567 568
					goto found;
				}

				if (!cma_dev && (gid.global.subnet_prefix ==
						 dgid->global.subnet_prefix)) {
					cma_dev = cur_dev;
					sgid = gid;
Paul Bolle's avatar
Paul Bolle committed
569
					id_priv->id.port_num = p;
570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585
				}
			}
		}
	}

	if (!cma_dev)
		return -ENODEV;

found:
	cma_attach_to_dev(id_priv, cma_dev);
	addr = (struct sockaddr_ib *) cma_src_addr(id_priv);
	memcpy(&addr->sib_addr, &sgid, sizeof sgid);
	cma_translate_ib(addr, &id_priv->id.route.addr.dev_addr);
	return 0;
}

586 587 588 589 590 591
static void cma_deref_id(struct rdma_id_private *id_priv)
{
	if (atomic_dec_and_test(&id_priv->refcount))
		complete(&id_priv->comp);
}

592
static int cma_disable_callback(struct rdma_id_private *id_priv,
593
				enum rdma_cm_state state)
594
{
595 596 597 598 599 600
	mutex_lock(&id_priv->handler_mutex);
	if (id_priv->state != state) {
		mutex_unlock(&id_priv->handler_mutex);
		return -EINVAL;
	}
	return 0;
601 602
}

603 604
struct rdma_cm_id *rdma_create_id(struct net *net,
				  rdma_cm_event_handler event_handler,
605 606
				  void *context, enum rdma_port_space ps,
				  enum ib_qp_type qp_type)
607 608 609 610 611 612 613
{
	struct rdma_id_private *id_priv;

	id_priv = kzalloc(sizeof *id_priv, GFP_KERNEL);
	if (!id_priv)
		return ERR_PTR(-ENOMEM);

614
	id_priv->owner = task_pid_nr(current);
615
	id_priv->state = RDMA_CM_IDLE;
616 617 618
	id_priv->id.context = context;
	id_priv->id.event_handler = event_handler;
	id_priv->id.ps = ps;
619
	id_priv->id.qp_type = qp_type;
620
	spin_lock_init(&id_priv->lock);
621
	mutex_init(&id_priv->qp_mutex);
622 623
	init_completion(&id_priv->comp);
	atomic_set(&id_priv->refcount, 1);
624
	mutex_init(&id_priv->handler_mutex);
625
	INIT_LIST_HEAD(&id_priv->listen_list);
626
	INIT_LIST_HEAD(&id_priv->mc_list);
627
	get_random_bytes(&id_priv->seq_num, sizeof id_priv->seq_num);
628
	id_priv->id.route.addr.dev_addr.net = get_net(net);
629 630 631 632 633

	return &id_priv->id;
}
EXPORT_SYMBOL(rdma_create_id);

634
static int cma_init_ud_qp(struct rdma_id_private *id_priv, struct ib_qp *qp)
635 636
{
	struct ib_qp_attr qp_attr;
637
	int qp_attr_mask, ret;
638

639 640
	qp_attr.qp_state = IB_QPS_INIT;
	ret = rdma_init_qp_attr(&id_priv->id, &qp_attr, &qp_attr_mask);
641 642 643
	if (ret)
		return ret;

644 645 646 647 648 649 650 651 652 653 654 655 656 657
	ret = ib_modify_qp(qp, &qp_attr, qp_attr_mask);
	if (ret)
		return ret;

	qp_attr.qp_state = IB_QPS_RTR;
	ret = ib_modify_qp(qp, &qp_attr, IB_QP_STATE);
	if (ret)
		return ret;

	qp_attr.qp_state = IB_QPS_RTS;
	qp_attr.sq_psn = 0;
	ret = ib_modify_qp(qp, &qp_attr, IB_QP_STATE | IB_QP_SQ_PSN);

	return ret;
658 659
}

660
static int cma_init_conn_qp(struct rdma_id_private *id_priv, struct ib_qp *qp)
Tom Tucker's avatar
Tom Tucker committed
661 662
{
	struct ib_qp_attr qp_attr;
663
	int qp_attr_mask, ret;
Tom Tucker's avatar
Tom Tucker committed
664 665

	qp_attr.qp_state = IB_QPS_INIT;
666 667 668
	ret = rdma_init_qp_attr(&id_priv->id, &qp_attr, &qp_attr_mask);
	if (ret)
		return ret;
Tom Tucker's avatar
Tom Tucker committed
669

670
	return ib_modify_qp(qp, &qp_attr, qp_attr_mask);
Tom Tucker's avatar
Tom Tucker committed
671 672
}

673 674 675 676 677 678 679 680 681 682 683 684 685 686 687
int rdma_create_qp(struct rdma_cm_id *id, struct ib_pd *pd,
		   struct ib_qp_init_attr *qp_init_attr)
{
	struct rdma_id_private *id_priv;
	struct ib_qp *qp;
	int ret;

	id_priv = container_of(id, struct rdma_id_private, id);
	if (id->device != pd->device)
		return -EINVAL;

	qp = ib_create_qp(pd, qp_init_attr);
	if (IS_ERR(qp))
		return PTR_ERR(qp);

688
	if (id->qp_type == IB_QPT_UD)
689 690 691
		ret = cma_init_ud_qp(id_priv, qp);
	else
		ret = cma_init_conn_qp(id_priv, qp);
692 693 694 695 696 697 698 699 700 701 702 703 704 705 706
	if (ret)
		goto err;

	id->qp = qp;
	id_priv->qp_num = qp->qp_num;
	id_priv->srq = (qp->srq != NULL);
	return 0;
err:
	ib_destroy_qp(qp);
	return ret;
}
EXPORT_SYMBOL(rdma_create_qp);

void rdma_destroy_qp(struct rdma_cm_id *id)
{
707 708 709 710 711 712 713
	struct rdma_id_private *id_priv;

	id_priv = container_of(id, struct rdma_id_private, id);
	mutex_lock(&id_priv->qp_mutex);
	ib_destroy_qp(id_priv->id.qp);
	id_priv->id.qp = NULL;
	mutex_unlock(&id_priv->qp_mutex);
714 715 716
}
EXPORT_SYMBOL(rdma_destroy_qp);

717 718
static int cma_modify_qp_rtr(struct rdma_id_private *id_priv,
			     struct rdma_conn_param *conn_param)
719 720 721
{
	struct ib_qp_attr qp_attr;
	int qp_attr_mask, ret;
722
	union ib_gid sgid;
723

724 725 726 727 728
	mutex_lock(&id_priv->qp_mutex);
	if (!id_priv->id.qp) {
		ret = 0;
		goto out;
	}
729 730 731

	/* Need to update QP attributes from default values. */
	qp_attr.qp_state = IB_QPS_INIT;
732
	ret = rdma_init_qp_attr(&id_priv->id, &qp_attr, &qp_attr_mask);
733
	if (ret)
734
		goto out;
735

736
	ret = ib_modify_qp(id_priv->id.qp, &qp_attr, qp_attr_mask);
737
	if (ret)
738
		goto out;
739 740

	qp_attr.qp_state = IB_QPS_RTR;
741
	ret = rdma_init_qp_attr(&id_priv->id, &qp_attr, &qp_attr_mask);
742
	if (ret)
743
		goto out;
744

745
	ret = ib_query_gid(id_priv->id.device, id_priv->id.port_num,
746
			   qp_attr.ah_attr.grh.sgid_index, &sgid, NULL);
747 748 749
	if (ret)
		goto out;

750 751
	BUG_ON(id_priv->cma_dev->device != id_priv->id.device);

752 753
	if (conn_param)
		qp_attr.max_dest_rd_atomic = conn_param->responder_resources;
754 755 756 757
	ret = ib_modify_qp(id_priv->id.qp, &qp_attr, qp_attr_mask);
out:
	mutex_unlock(&id_priv->qp_mutex);
	return ret;
758 759
}

760 761
static int cma_modify_qp_rts(struct rdma_id_private *id_priv,
			     struct rdma_conn_param *conn_param)
762 763 764 765
{
	struct ib_qp_attr qp_attr;
	int qp_attr_mask, ret;

766 767 768 769 770
	mutex_lock(&id_priv->qp_mutex);
	if (!id_priv->id.qp) {
		ret = 0;
		goto out;
	}
771 772

	qp_attr.qp_state = IB_QPS_RTS;
773
	ret = rdma_init_qp_attr(&id_priv->id, &qp_attr, &qp_attr_mask);
774
	if (ret)
775
		goto out;
776

777 778
	if (conn_param)
		qp_attr.max_rd_atomic = conn_param->initiator_depth;
779 780 781 782
	ret = ib_modify_qp(id_priv->id.qp, &qp_attr, qp_attr_mask);
out:
	mutex_unlock(&id_priv->qp_mutex);
	return ret;
783 784
}

785
static int cma_modify_qp_err(struct rdma_id_private *id_priv)
786 787
{
	struct ib_qp_attr qp_attr;
788
	int ret;
789

790 791 792 793 794
	mutex_lock(&id_priv->qp_mutex);
	if (!id_priv->id.qp) {
		ret = 0;
		goto out;
	}
795 796

	qp_attr.qp_state = IB_QPS_ERR;
797 798 799 800
	ret = ib_modify_qp(id_priv->id.qp, &qp_attr, IB_QP_STATE);
out:
	mutex_unlock(&id_priv->qp_mutex);
	return ret;
801 802
}

803 804 805 806 807
static int cma_ib_init_qp_attr(struct rdma_id_private *id_priv,
			       struct ib_qp_attr *qp_attr, int *qp_attr_mask)
{
	struct rdma_dev_addr *dev_addr = &id_priv->id.route.addr.dev_addr;
	int ret;
808 809
	u16 pkey;

810
	if (rdma_cap_eth_ah(id_priv->id.device, id_priv->id.port_num))
811
		pkey = 0xffff;
812 813
	else
		pkey = ib_addr_get_pkey(dev_addr);
814 815

	ret = ib_find_cached_pkey(id_priv->id.device, id_priv->id.port_num,
816
				  pkey, &qp_attr->pkey_index);
817 818 819 820 821 822
	if (ret)
		return ret;

	qp_attr->port_num = id_priv->id.port_num;
	*qp_attr_mask = IB_QP_STATE | IB_QP_PKEY_INDEX | IB_QP_PORT;

823
	if (id_priv->id.qp_type == IB_QPT_UD) {
Sean Hefty's avatar
Sean Hefty committed
824
		ret = cma_set_qkey(id_priv, 0);
825 826 827
		if (ret)
			return ret;

828 829 830 831 832 833 834 835 836
		qp_attr->qkey = id_priv->qkey;
		*qp_attr_mask |= IB_QP_QKEY;
	} else {
		qp_attr->qp_access_flags = 0;
		*qp_attr_mask |= IB_QP_ACCESS_FLAGS;
	}
	return 0;
}

837 838 839 840
int rdma_init_qp_attr(struct rdma_cm_id *id, struct ib_qp_attr *qp_attr,
		       int *qp_attr_mask)
{
	struct rdma_id_private *id_priv;
841
	int ret = 0;
842 843

	id_priv = container_of(id, struct rdma_id_private, id);
844
	if (rdma_cap_ib_cm(id->device, id->port_num)) {
845
		if (!id_priv->cm_id.ib || (id_priv->id.qp_type == IB_QPT_UD))
846 847 848 849
			ret = cma_ib_init_qp_attr(id_priv, qp_attr, qp_attr_mask);
		else
			ret = ib_cm_init_qp_attr(id_priv->cm_id.ib, qp_attr,
						 qp_attr_mask);
850

851 852
		if (qp_attr->qp_state == IB_QPS_RTR)
			qp_attr->rq_psn = id_priv->seq_num;
853
	} else if (rdma_cap_iw_cm(id->device, id->port_num)) {
854
		if (!id_priv->cm_id.iw) {
855
			qp_attr->qp_access_flags = 0;
856 857 858 859
			*qp_attr_mask = IB_QP_STATE | IB_QP_ACCESS_FLAGS;
		} else
			ret = iw_cm_init_qp_attr(id_priv->cm_id.iw, qp_attr,
						 qp_attr_mask);
860 861
		qp_attr->port_num = id_priv->id.port_num;
		*qp_attr_mask |= IB_QP_PORT;
862
	} else
863 864 865 866 867 868 869 870
		ret = -ENOSYS;

	return ret;
}
EXPORT_SYMBOL(rdma_init_qp_attr);

static inline int cma_zero_addr(struct sockaddr *addr)
{
871 872 873 874 875 876 877 878 879
	switch (addr->sa_family) {
	case AF_INET:
		return ipv4_is_zeronet(((struct sockaddr_in *)addr)->sin_addr.s_addr);
	case AF_INET6:
		return ipv6_addr_any(&((struct sockaddr_in6 *) addr)->sin6_addr);
	case AF_IB:
		return ib_addr_any(&((struct sockaddr_ib *) addr)->sib_addr);
	default:
		return 0;
880 881 882 883 884
	}
}

static inline int cma_loopback_addr(struct sockaddr *addr)
{
885 886 887 888 889 890 891 892 893 894
	switch (addr->sa_family) {
	case AF_INET:
		return ipv4_is_loopback(((struct sockaddr_in *) addr)->sin_addr.s_addr);
	case AF_INET6:
		return ipv6_addr_loopback(&((struct sockaddr_in6 *) addr)->sin6_addr);
	case AF_IB:
		return ib_addr_loopback(&((struct sockaddr_ib *) addr)->sib_addr);
	default:
		return 0;
	}
895 896 897 898 899 900 901
}

static inline int cma_any_addr(struct sockaddr *addr)
{
	return cma_zero_addr(addr) || cma_loopback_addr(addr);
}

902 903 904 905 906 907 908 909 910
static int cma_addr_cmp(struct sockaddr *src, struct sockaddr *dst)
{
	if (src->sa_family != dst->sa_family)
		return -1;

	switch (src->sa_family) {
	case AF_INET:
		return ((struct sockaddr_in *) src)->sin_addr.s_addr !=
		       ((struct sockaddr_in *) dst)->sin_addr.s_addr;
911
	case AF_INET6:
912 913
		return ipv6_addr_cmp(&((struct sockaddr_in6 *) src)->sin6_addr,
				     &((struct sockaddr_in6 *) dst)->sin6_addr);
914 915 916
	default:
		return ib_addr_cmp(&((struct sockaddr_ib *) src)->sib_addr,
				   &((struct sockaddr_ib *) dst)->sib_addr);
917 918 919
	}
}

920
static __be16 cma_port(struct sockaddr *addr)
921
{
922 923 924 925
	struct sockaddr_ib *sib;

	switch (addr->sa_family) {
	case AF_INET:
926
		return ((struct sockaddr_in *) addr)->sin_port;
927
	case AF_INET6:
928
		return ((struct sockaddr_in6 *) addr)->sin6_port;
929 930 931 932 933 934 935
	case AF_IB:
		sib = (struct sockaddr_ib *) addr;
		return htons((u16) (be64_to_cpu(sib->sib_sid) &
				    be64_to_cpu(sib->sib_sid_mask)));
	default:
		return 0;
	}
936 937
}

938 939
static inline int cma_any_port(struct sockaddr *addr)
{
940
	return !cma_port(addr);
941 942
}

943 944 945
static void cma_save_ib_info(struct sockaddr *src_addr,
			     struct sockaddr *dst_addr,
			     struct rdma_cm_id *listen_id,
946
			     struct ib_sa_path_rec *path)
947
{
948 949 950
	struct sockaddr_ib *listen_ib, *ib;

	listen_ib = (struct sockaddr_ib *) &listen_id->route.addr.src_addr;
951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967
	if (src_addr) {
		ib = (struct sockaddr_ib *)src_addr;
		ib->sib_family = AF_IB;
		if (path) {
			ib->sib_pkey = path->pkey;
			ib->sib_flowinfo = path->flow_label;
			memcpy(&ib->sib_addr, &path->sgid, 16);
			ib->sib_sid = path->service_id;
			ib->sib_scope_id = 0;
		} else {
			ib->sib_pkey = listen_ib->sib_pkey;
			ib->sib_flowinfo = listen_ib->sib_flowinfo;
			ib->sib_addr = listen_ib->sib_addr;
			ib->sib_sid = listen_ib->sib_sid;
			ib->sib_scope_id = listen_ib->sib_scope_id;
		}
		ib->sib_sid_mask = cpu_to_be64(0xffffffffffffffffULL);
968
	}
969 970 971 972 973 974 975 976
	if (dst_addr) {
		ib = (struct sockaddr_ib *)dst_addr;
		ib->sib_family = AF_IB;
		if (path) {
			ib->sib_pkey = path->pkey;
			ib->sib_flowinfo = path->flow_label;
			memcpy(&ib->sib_addr, &path->dgid, 16);
		}
977
	}
978
}
979

980 981 982 983
static void cma_save_ip4_info(struct sockaddr *src_addr,
			      struct sockaddr *dst_addr,
			      struct cma_hdr *hdr,
			      __be16 local_port)
984
{
985
	struct sockaddr_in *ip4;
986

987 988 989 990 991 992
	if (src_addr) {
		ip4 = (struct sockaddr_in *)src_addr;
		ip4->sin_family = AF_INET;
		ip4->sin_addr.s_addr = hdr->dst_addr.ip4.addr;
		ip4->sin_port = local_port;
	}
993

994 995 996 997 998 999
	if (dst_addr) {
		ip4 = (struct sockaddr_in *)dst_addr;
		ip4->sin_family = AF_INET;
		ip4->sin_addr.s_addr = hdr->src_addr.ip4.addr;
		ip4->sin_port = hdr->port;
	}
1000 1001
}

1002 1003 1004 1005
static void cma_save_ip6_info(struct sockaddr *src_addr,
			      struct sockaddr *dst_addr,
			      struct cma_hdr *hdr,
			      __be16 local_port)
1006
{
1007
	struct sockaddr_in6 *ip6;
1008

1009 1010 1011 1012 1013 1014
	if (src_addr) {
		ip6 = (struct sockaddr_in6 *)src_addr;
		ip6->sin6_family = AF_INET6;
		ip6->sin6_addr = hdr->dst_addr.ip6;
		ip6->sin6_port = local_port;
	}
1015

1016 1017 1018 1019 1020 1021
	if (dst_addr) {
		ip6 = (struct sockaddr_in6 *)dst_addr;
		ip6->sin6_family = AF_INET6;
		ip6->sin6_addr = hdr->src_addr.ip6;
		ip6->sin6_port = hdr->port;
	}
1022 1023
}

1024
static u16 cma_port_from_service_id(__be64 service_id)
1025
{
1026 1027
	return (u16)be64_to_cpu(service_id);
}
1028

1029 1030 1031 1032 1033 1034 1035
static int cma_save_ip_info(struct sockaddr *src_addr,
			    struct sockaddr *dst_addr,
			    struct ib_cm_event *ib_event,
			    __be64 service_id)
{
	struct cma_hdr *hdr;
	__be16 port;
1036 1037 1038 1039 1040

	hdr = ib_event->private_data;
	if (hdr->cma_version != CMA_VERSION)
		return -EINVAL;

1041 1042
	port = htons(cma_port_from_service_id(service_id));

1043
	switch (cma_get_ip_ver(hdr)) {
1044
	case 4:
1045
		cma_save_ip4_info(src_addr, dst_addr, hdr, port);
1046 1047
		break;
	case 6:
1048
		cma_save_ip6_info(src_addr, dst_addr, hdr, port);
1049 1050
		break;
	default:
1051
		return -EAFNOSUPPORT;
1052
	}
1053

1054
	return 0;
1055 1056
}

1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074
static int cma_save_net_info(struct sockaddr *src_addr,
			     struct sockaddr *dst_addr,
			     struct rdma_cm_id *listen_id,
			     struct ib_cm_event *ib_event,
			     sa_family_t sa_family, __be64 service_id)
{
	if (sa_family == AF_IB) {
		if (ib_event->event == IB_CM_REQ_RECEIVED)
			cma_save_ib_info(src_addr, dst_addr, listen_id,
					 ib_event->param.req_rcvd.primary_path);
		else if (ib_event->event == IB_CM_SIDR_REQ_RECEIVED)
			cma_save_ib_info(src_addr, dst_addr, listen_id, NULL);
		return 0;
	}

	return cma_save_ip_info(src_addr, dst_addr, ib_event, service_id);
}

1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090
static int cma_save_req_info(const struct ib_cm_event *ib_event,
			     struct cma_req_info *req)
{
	const struct ib_cm_req_event_param *req_param =
		&ib_event->param.req_rcvd;
	const struct ib_cm_sidr_req_event_param *sidr_param =
		&ib_event->param.sidr_req_rcvd;

	switch (ib_event->event) {
	case IB_CM_REQ_RECEIVED:
		req->device	= req_param->listen_id->device;
		req->port	= req_param->port;
		memcpy(&req->local_gid, &req_param->primary_path->sgid,
		       sizeof(req->local_gid));
		req->has_gid	= true;
		req->service_id	= req_param->primary_path->service_id;
1091
		req->pkey	= be16_to_cpu(req_param->primary_path->pkey);
1092 1093 1094 1095 1096 1097
		break;
	case IB_CM_SIDR_REQ_RECEIVED:
		req->device	= sidr_param->listen_id->device;
		req->port	= sidr_param->port;
		req->has_gid	= false;
		req->service_id	= sidr_param->service_id;
1098
		req->pkey	= sidr_param->pkey;
1099 1100 1101 1102 1103 1104 1105 1106
		break;
	default:
		return -EINVAL;
	}

	return 0;
}

1107 1108 1109 1110 1111 1112 1113 1114 1115 1116 1117 1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130
static bool validate_ipv4_net_dev(struct net_device *net_dev,
				  const struct sockaddr_in *dst_addr,
				  const struct sockaddr_in *src_addr)
{
	__be32 daddr = dst_addr->sin_addr.s_addr,
	       saddr = src_addr->sin_addr.s_addr;
	struct fib_result res;
	struct flowi4 fl4;
	int err;
	bool ret;

	if (ipv4_is_multicast(saddr) || ipv4_is_lbcast(saddr) ||
	    ipv4_is_lbcast(daddr) || ipv4_is_zeronet(saddr) ||
	    ipv4_is_zeronet(daddr) || ipv4_is_loopback(daddr) ||
	    ipv4_is_loopback(saddr))
		return false;

	memset(&fl4, 0, sizeof(fl4));
	fl4.flowi4_iif = net_dev->ifindex;
	fl4.daddr = daddr;
	fl4.saddr = saddr;

	rcu_read_lock();
	err = fib_lookup(dev_net(net_dev), &fl4, &res, 0);
1131
	ret = err == 0 && FIB_RES_DEV(res) == net_dev;
1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156 1157 1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168 1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183
	rcu_read_unlock();

	return ret;
}

static bool validate_ipv6_net_dev(struct net_device *net_dev,
				  const struct sockaddr_in6 *dst_addr,
				  const struct sockaddr_in6 *src_addr)
{
#if IS_ENABLED(CONFIG_IPV6)
	const int strict = ipv6_addr_type(&dst_addr->sin6_addr) &
			   IPV6_ADDR_LINKLOCAL;
	struct rt6_info *rt = rt6_lookup(dev_net(net_dev), &dst_addr->sin6_addr,
					 &src_addr->sin6_addr, net_dev->ifindex,
					 strict);
	bool ret;

	if (!rt)
		return false;

	ret = rt->rt6i_idev->dev == net_dev;
	ip6_rt_put(rt);

	return ret;
#else
	return false;
#endif
}

static bool validate_net_dev(struct net_device *net_dev,
			     const struct sockaddr *daddr,
			     const struct sockaddr *saddr)
{
	const struct sockaddr_in *daddr4 = (const struct sockaddr_in *)daddr;
	const struct sockaddr_in *saddr4 = (const struct sockaddr_in *)saddr;
	const struct sockaddr_in6 *daddr6 = (const struct sockaddr_in6 *)daddr;
	const struct sockaddr_in6 *saddr6 = (const struct sockaddr_in6 *)saddr;

	switch (daddr->sa_family) {
	case AF_INET:
		return saddr->sa_family == AF_INET &&
		       validate_ipv4_net_dev(net_dev, daddr4, saddr4);

	case AF_INET6:
		return saddr->sa_family == AF_INET6 &&
		       validate_ipv6_net_dev(net_dev, daddr6, saddr6);

	default:
		return false;
	}
}

1184 1185 1186
static struct net_device *cma_get_net_dev(struct ib_cm_event *ib_event,
					  const struct cma_req_info *req)
{
1187 1188 1189
	struct sockaddr_storage listen_addr_storage, src_addr_storage;
	struct sockaddr *listen_addr = (struct sockaddr *)&listen_addr_storage,
			*src_addr = (struct sockaddr *)&src_addr_storage;
1190 1191 1192 1193
	struct net_device *net_dev;
	const union ib_gid *gid = req->has_gid ? &req->local_gid : NULL;
	int err;

1194 1195
	err = cma_save_ip_info(listen_addr, src_addr, ib_event,
			       req->service_id);
1196 1197 1198 1199 1200 1201 1202 1203
	if (err)
		return ERR_PTR(err);

	net_dev = ib_get_net_dev_by_params(req->device, req->port, req->pkey,
					   gid, listen_addr);
	if (!net_dev)
		return ERR_PTR(-ENODEV);

1204 1205 1206 1207 1208
	if (!validate_net_dev(net_dev, listen_addr, src_addr)) {
		dev_put(net_dev);
		return ERR_PTR(-EHOSTUNREACH);
	}

1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225 1226 1227 1228 1229 1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243 1244 1245 1246 1247 1248 1249 1250 1251 1252
	return net_dev;
}

static enum rdma_port_space rdma_ps_from_service_id(__be64 service_id)
{
	return (be64_to_cpu(service_id) >> 16) & 0xffff;
}

static bool cma_match_private_data(struct rdma_id_private *id_priv,
				   const struct cma_hdr *hdr)
{
	struct sockaddr *addr = cma_src_addr(id_priv);
	__be32 ip4_addr;
	struct in6_addr ip6_addr;

	if (cma_any_addr(addr) && !id_priv->afonly)
		return true;

	switch (addr->sa_family) {
	case AF_INET:
		ip4_addr = ((struct sockaddr_in *)addr)->sin_addr.s_addr;
		if (cma_get_ip_ver(hdr) != 4)
			return false;
		if (!cma_any_addr(addr) &&
		    hdr->dst_addr.ip4.addr != ip4_addr)
			return false;
		break;
	case AF_INET6:
		ip6_addr = ((struct sockaddr_in6 *)addr)->sin6_addr;
		if (cma_get_ip_ver(hdr) != 6)
			return false;
		if (!cma_any_addr(addr) &&
		    memcmp(&hdr->dst_addr.ip6, &ip6_addr, sizeof(ip6_addr)))
			return false;
		break;
	case AF_IB:
		return true;
	default:
		return false;
	}

	return true;
}

1253 1254 1255 1256 1257 1258 1259 1260 1261 1262 1263 1264 1265 1266 1267 1268 1269
static bool cma_protocol_roce_dev_port(struct ib_device *device, int port_num)
{
	enum rdma_link_layer ll = rdma_port_get_link_layer(device, port_num);
	enum rdma_transport_type transport =
		rdma_node_get_transport(device->node_type);

	return ll == IB_LINK_LAYER_ETHERNET && transport == RDMA_TRANSPORT_IB;
}

static bool cma_protocol_roce(const struct rdma_cm_id *id)
{
	struct ib_device *device = id->device;
	const int port_num = id->port_num ?: rdma_start_port(device);

	return cma_protocol_roce_dev_port(device, port_num);
}

1270 1271 1272
static bool cma_match_net_dev(const struct rdma_cm_id *id,
			      const struct net_device *net_dev,
			      u8 port_num)
1273
{
1274
	const struct rdma_addr *addr = &id->route.addr;
1275 1276

	if (!net_dev)
1277
		/* This request is an AF_IB request or a RoCE request */
1278 1279 1280
		return (!id->port_num || id->port_num == port_num) &&
		       (addr->src_addr.ss_family == AF_IB ||
			cma_protocol_roce_dev_port(id->device, port_num));
1281 1282

	return !addr->dev_addr.bound_dev_if ||
1283
	       (net_eq(dev_net(net_dev), addr->dev_addr.net) &&
1284 1285 1286 1287 1288 1289 1290 1291 1292 1293 1294 1295 1296 1297 1298 1299 1300 1301
		addr->dev_addr.bound_dev_if == net_dev->ifindex);
}

static struct rdma_id_private *cma_find_listener(
		const struct rdma_bind_list *bind_list,
		const struct ib_cm_id *cm_id,
		const struct ib_cm_event *ib_event,
		const struct cma_req_info *req,
		const struct net_device *net_dev)
{
	struct rdma_id_private *id_priv, *id_priv_dev;

	if (!bind_list)
		return ERR_PTR(-EINVAL);

	hlist_for_each_entry(id_priv, &bind_list->owners, node) {
		if (cma_match_private_data(id_priv, ib_event->private_data)) {
			if (id_priv->id.device == cm_id->device &&
1302
			    cma_match_net_dev(&id_priv->id, net_dev, req->port))
1303 1304 1305 1306 1307
				return id_priv;
			list_for_each_entry(id_priv_dev,
					    &id_priv->listen_list,
					    listen_list) {
				if (id_priv_dev->id.device == cm_id->device &&
1308
				    cma_match_net_dev(&id_priv_dev->id, net_dev, req->port))
1309 1310 1311 1312 1313 1314 1315 1316 1317
					return id_priv_dev;
			}
		}
	}

	return ERR_PTR(-EINVAL);
}

static struct rdma_id_private *cma_id_from_event(struct ib_cm_id *cm_id,
1318 1319
						 struct ib_cm_event *ib_event,
						 struct net_device **net_dev)
1320 1321 1322 1323 1324 1325 1326 1327 1328 1329
{
	struct cma_req_info req;
	struct rdma_bind_list *bind_list;
	struct rdma_id_private *id_priv;
	int err;

	err = cma_save_req_info(ib_event, &req);
	if (err)
		return ERR_PTR(err);

1330 1331 1332
	*net_dev = cma_get_net_dev(ib_event, &req);
	if (IS_ERR(*net_dev)) {
		if (PTR_ERR(*net_dev) == -EAFNOSUPPORT) {
1333
			/* Assuming the protocol is AF_IB */
1334
			*net_dev = NULL;
1335 1336 1337 1338
		} else if (cma_protocol_roce_dev_port(req.device, req.port)) {
			/* TODO find the net dev matching the request parameters
			 * through the RoCE GID table */
			*net_dev = NULL;
1339
		} else {
1340
			return ERR_CAST(*net_dev);
1341 1342 1343
		}
	}

1344
	bind_list = cma_ps_find(*net_dev ? dev_net(*net_dev) : &init_net,
1345
				rdma_ps_from_service_id(req.service_id),
1346
				cma_port_from_service_id(req.service_id));
1347
	id_priv = cma_find_listener(bind_list, cm_id, ib_event, &req, *net_dev);
1348
	if (IS_ERR(id_priv) && *net_dev) {
1349 1350 1351
		dev_put(*net_dev);
		*net_dev = NULL;
	}
1352 1353 1354 1355

	return id_priv;
}

1356
static inline u8 cma_user_data_offset(struct rdma_id_private *id_priv)
1357
{
1358
	return cma_family(id_priv) == AF_IB ? 0 : sizeof(struct cma_hdr);
1359 1360 1361 1362
}

static void cma_cancel_route(struct rdma_id_private *id_priv)
{
1363
	if (rdma_cap_ib_sa(id_priv->id.device, id_priv->id.port_num)) {
1364 1365 1366 1367 1368 1369 1370 1371 1372
		if (id_priv->query)
			ib_sa_cancel_query(id_priv->query_id, id_priv->query);
	}
}

static void cma_cancel_listens(struct rdma_id_private *id_priv)
{
	struct rdma_id_private *dev_id_priv;

1373 1374 1375 1376
	/*
	 * Remove from listen_any_list to prevent added devices from spawning
	 * additional listen requests.
	 */
1377 1378 1379 1380 1381 1382
	mutex_lock(&lock);
	list_del(&id_priv->list);

	while (!list_empty(&id_priv->listen_list)) {
		dev_id_priv = list_entry(id_priv->listen_list.next,
					 struct rdma_id_private, listen_list);
1383 1384 1385 1386 1387 1388 1389
		/* sync with device removal to avoid duplicate destruction */
		list_del_init(&dev_id_priv->list);
		list_del(&dev_id_priv->listen_list);
		mutex_unlock(&lock);

		rdma_destroy_id(&dev_id_priv->id);
		mutex_lock(&lock);
1390 1391 1392 1393 1394
	}
	mutex_unlock(&lock);
}

static void cma_cancel_operation(struct rdma_id_private *id_priv,
1395
				 enum rdma_cm_state state)
1396 1397
{
	switch (state) {
1398
	case RDMA_CM_ADDR_QUERY:
1399 1400
		rdma_addr_cancel(&id_priv->id.route.addr.dev_addr);
		break;
1401
	case RDMA_CM_ROUTE_QUERY:
1402 1403
		cma_cancel_route(id_priv);
		break;
1404
	case RDMA_CM_LISTEN:
1405
		if (cma_any_addr(cma_src_addr(id_priv)) && !id_priv->cma_dev)
1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
			cma_cancel_listens(id_priv);
		break;
	default:
		break;
	}
}

static void cma_release_port(struct rdma_id_private *id_priv)
{
	struct rdma_bind_list *bind_list = id_priv->bind_list;
1416
	struct net *net = id_priv->id.route.addr.dev_addr.net;
1417 1418 1419 1420 1421 1422 1423

	if (!bind_list)
		return;

	mutex_lock(&lock);
	hlist_del(&id_priv->node);
	if (hlist_empty(&bind_list->owners)) {
1424
		cma_ps_remove(net, bind_list->ps, bind_list->port);
1425 1426 1427 1428 1429
		kfree(bind_list);
	}
	mutex_unlock(&lock);
}

1430 1431 1432 1433 1434 1435 1436 1437
static void cma_leave_mc_groups(struct rdma_id_private *id_priv)
{
	struct cma_multicast *mc;

	while (!list_empty(&id_priv->mc_list)) {
		mc = container_of(id_priv->mc_list.next,
				  struct cma_multicast, list);
		list_del(&mc->list);
1438
		if (rdma_cap_ib_mcast(id_priv->cma_dev->device,
1439
				      id_priv->id.port_num)) {
1440 1441
			ib_sa_free_multicast(mc->multicast.ib);
			kfree(mc);
1442
		} else
1443
			kref_put(&mc->mcref, release_mc);
1444 1445 1446
	}
}

1447 1448 1449
void rdma_destroy_id(struct rdma_cm_id *id)
{
	struct rdma_id_private *id_priv;
1450
	enum rdma_cm_state state;
1451 1452

	id_priv = container_of(id, struct rdma_id_private, id);
1453
	state = cma_exch(id_priv, RDMA_CM_DESTROYING);
1454 1455
	cma_cancel_operation(id_priv, state);

1456 1457 1458 1459 1460 1461 1462
	/*
	 * Wait for any active callback to finish.  New callbacks will find
	 * the id_priv state set to destroying and abort.
	 */
	mutex_lock(&id_priv->handler_mutex);
	mutex_unlock(&id_priv->handler_mutex);

1463
	if (id_priv->cma_dev) {
1464
		if (rdma_cap_ib_cm(id_priv->id.device, 1)) {
1465
			if (id_priv->cm_id.ib)
1466
				ib_destroy_cm_id(id_priv->cm_id.ib);
1467
		} else if (rdma_cap_iw_cm(id_priv->id.device, 1)) {
1468
			if (id_priv->cm_id.iw)
Tom Tucker's avatar
Tom Tucker committed
1469
				iw_destroy_cm_id(id_priv->cm_id.iw);
1470
		}
1471
		cma_leave_mc_groups(id_priv);
1472
		cma_release_dev(id_priv);
1473 1474 1475 1476 1477 1478
	}

	cma_release_port(id_priv);
	cma_deref_id(id_priv);
	wait_for_completion(&id_priv->comp);

1479 1480 1481
	if (id_priv->internal_id)
		cma_deref_id(id_priv->id.context);

1482
	kfree(id_priv->id.route.path_rec);
1483
	put_net(id_priv->id.route.addr.dev_addr.net);
1484 1485 1486 1487 1488 1489 1490 1491
	kfree(id_priv);
}
EXPORT_SYMBOL(rdma_destroy_id);

static int cma_rep_recv(struct rdma_id_private *id_priv)
{
	int ret;

1492
	ret = cma_modify_qp_rtr(id_priv, NULL);
1493 1494 1495
	if (ret)
		goto reject;

1496
	ret = cma_modify_qp_rts(id_priv, NULL);
1497 1498 1499 1500 1501 1502 1503 1504 1505
	if (ret)
		goto reject;

	ret = ib_send_cm_rtu(id_priv->cm_id.ib, NULL, 0);
	if (ret)
		goto reject;

	return 0;
reject:
1506
	cma_modify_qp_err(id_priv);
1507 1508 1509 1510 1511
	ib_send_cm_rej(id_priv->cm_id.ib, IB_CM_REJ_CONSUMER_DEFINED,
		       NULL, 0, NULL, 0);
	return ret;
}

1512 1513 1514 1515 1516 1517 1518 1519 1520 1521 1522 1523 1524 1525
static void cma_set_rep_event_data(struct rdma_cm_event *event,
				   struct ib_cm_rep_event_param *rep_data,
				   void *private_data)
{
	event->param.conn.private_data = private_data;
	event->param.conn.private_data_len = IB_CM_REP_PRIVATE_DATA_SIZE;
	event->param.conn.responder_resources = rep_data->responder_resources;
	event->param.conn.initiator_depth = rep_data->initiator_depth;
	event->param.conn.flow_control = rep_data->flow_control;
	event->param.conn.rnr_retry_count = rep_data->rnr_retry_count;
	event->param.conn.srq = rep_data->srq;
	event->param.conn.qp_num = rep_data->remote_qpn;
}

1526 1527 1528
static int cma_ib_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event)
{
	struct rdma_id_private *id_priv = cm_id->context;
1529 1530
	struct rdma_cm_event event;
	int ret = 0;
1531

1532
	if ((ib_event->event != IB_CM_TIMEWAIT_EXIT &&
1533
		cma_disable_callback(id_priv, RDMA_CM_CONNECT)) ||
1534
	    (ib_event->event == IB_CM_TIMEWAIT_EXIT &&
1535
		cma_disable_callback(id_priv, RDMA_CM_DISCONNECT)))
1536
		return 0;
1537

1538
	memset(&event, 0, sizeof event);
1539 1540 1541
	switch (ib_event->event) {
	case IB_CM_REQ_ERROR:
	case IB_CM_REP_ERROR:
1542 1543
		event.event = RDMA_CM_EVENT_UNREACHABLE;
		event.status = -ETIMEDOUT;
1544 1545
		break;
	case IB_CM_REP_RECEIVED:
1546
		if (id_priv->id.qp) {
1547 1548 1549
			event.status = cma_rep_recv(id_priv);
			event.event = event.status ? RDMA_CM_EVENT_CONNECT_ERROR :
						     RDMA_CM_EVENT_ESTABLISHED;
1550
		} else {
1551
			event.event = RDMA_CM_EVENT_CONNECT_RESPONSE;
1552
		}
1553 1554
		cma_set_rep_event_data(&event, &ib_event->param.rep_rcvd,
				       ib_event->private_data);
1555 1556
		break;
	case IB_CM_RTU_RECEIVED:
1557 1558
	case IB_CM_USER_ESTABLISHED:
		event.event = RDMA_CM_EVENT_ESTABLISHED;
1559 1560
		break;
	case IB_CM_DREQ_ERROR:
1561
		event.status = -ETIMEDOUT; /* fall through */
1562 1563
	case IB_CM_DREQ_RECEIVED:
	case IB_CM_DREP_RECEIVED:
1564 1565
		if (!cma_comp_exch(id_priv, RDMA_CM_CONNECT,
				   RDMA_CM_DISCONNECT))
1566
			goto out;
1567
		event.event = RDMA_CM_EVENT_DISCONNECTED;
1568 1569
		break;
	case IB_CM_TIMEWAIT_EXIT:
1570 1571
		event.event = RDMA_CM_EVENT_TIMEWAIT_EXIT;
		break;
1572 1573 1574 1575
	case IB_CM_MRA_RECEIVED:
		/* ignore event */
		goto out;
	case IB_CM_REJ_RECEIVED:
1576
		cma_modify_qp_err(id_priv);
1577 1578 1579 1580
		event.status = ib_event->param.rej_rcvd.reason;
		event.event = RDMA_CM_EVENT_REJECTED;
		event.param.conn.private_data = ib_event->private_data;
		event.param.conn.private_data_len = IB_CM_REJ_PRIVATE_DATA_SIZE;
1581 1582
		break;
	default:
1583
		printk(KERN_ERR "RDMA CMA: unexpected IB CM event: %d\n",
1584 1585 1586 1587
		       ib_event->event);
		goto out;
	}

1588
	ret = id_priv->id.event_handler(&id_priv->id, &event);
1589 1590 1591
	if (ret) {
		/* Destroy the CM ID by returning a non-zero value. */
		id_priv->cm_id.ib = NULL;
1592
		cma_exch(id_priv, RDMA_CM_DESTROYING);
1593
		mutex_unlock(&id_priv->handler_mutex);
1594 1595 1596 1597
		rdma_destroy_id(&id_priv->id);
		return ret;
	}
out:
1598
	mutex_unlock(&id_priv->handler_mutex);
1599 1600 1601
	return ret;
}

1602
static struct rdma_id_private *cma_new_conn_id(struct rdma_cm_id *listen_id,
1603 1604
					       struct ib_cm_event *ib_event,
					       struct net_device *net_dev)
1605 1606 1607 1608
{
	struct rdma_id_private *id_priv;
	struct rdma_cm_id *id;
	struct rdma_route *rt;
1609 1610 1611
	const sa_family_t ss_family = listen_id->route.addr.src_addr.ss_family;
	const __be64 service_id =
		      ib_event->param.req_rcvd.primary_path->service_id;
1612
	int ret;
1613

1614 1615
	id = rdma_create_id(listen_id->route.addr.dev_addr.net,
			    listen_id->event_handler, listen_id->context,
1616
			    listen_id->ps, ib_event->param.req_rcvd.qp_type);
1617
	if (IS_ERR(id))
1618
		return NULL;
1619

1620
	id_priv = container_of(id, struct rdma_id_private, id);
1621 1622 1623
	if (cma_save_net_info((struct sockaddr *)&id->route.addr.src_addr,
			      (struct sockaddr *)&id->route.addr.dst_addr,
			      listen_id, ib_event, ss_family, service_id))
1624
		goto err;
1625 1626 1627

	rt = &id->route;
	rt->num_paths = ib_event->param.req_rcvd.alternate_path ? 2 : 1;
1628 1629
	rt->path_rec = kmalloc(sizeof *rt->path_rec * rt->num_paths,
			       GFP_KERNEL);
1630
	if (!rt->path_rec)
1631
		goto err;
1632 1633 1634 1635 1636

	rt->path_rec[0] = *ib_event->param.req_rcvd.primary_path;
	if (rt->num_paths == 2)
		rt->path_rec[1] = *ib_event->param.req_rcvd.alternate_path;

1637 1638
	if (net_dev) {
		ret = rdma_copy_addr(&rt->addr.dev_addr, net_dev, NULL);
1639
		if (ret)
1640
			goto err;
1641
	} else {
1642 1643 1644 1645 1646 1647 1648 1649 1650 1651
		if (!cma_protocol_roce(listen_id) &&
		    cma_any_addr(cma_src_addr(id_priv))) {
			rt->addr.dev_addr.dev_type = ARPHRD_INFINIBAND;
			rdma_addr_set_sgid(&rt->addr.dev_addr, &rt->path_rec[0].sgid);
			ib_addr_set_pkey(&rt->addr.dev_addr, be16_to_cpu(rt->path_rec[0].pkey));
		} else if (!cma_any_addr(cma_src_addr(id_priv))) {
			ret = cma_translate_addr(cma_src_addr(id_priv), &rt->addr.dev_addr);
			if (ret)
				goto err;
		}
1652 1653
	}
	rdma_addr_set_dgid(&rt->addr.dev_addr, &rt->path_rec[0].dgid);
1654

1655
	id_priv->state = RDMA_CM_CONNECT;
1656
	return id_priv;
1657 1658

err:
1659
	rdma_destroy_id(id);
1660 1661 1662
	return NULL;
}

1663
static struct rdma_id_private *cma_new_udp_id(struct rdma_cm_id *listen_id,
1664 1665
					      struct ib_cm_event *ib_event,
					      struct net_device *net_dev)
1666 1667 1668
{
	struct rdma_id_private *id_priv;
	struct rdma_cm_id *id;
1669
	const sa_family_t ss_family = listen_id->route.addr.src_addr.ss_family;
1670
	struct net *net = listen_id->route.addr.dev_addr.net;
1671 1672
	int ret;

1673
	id = rdma_create_id(net, listen_id->event_handler, listen_id->context,
1674
			    listen_id->ps, IB_QPT_UD);
1675 1676 1677
	if (IS_ERR(id))
		return NULL;

1678
	id_priv = container_of(id, struct rdma_id_private, id);
1679 1680 1681 1682
	if (cma_save_net_info((struct sockaddr *)&id->route.addr.src_addr,
			      (struct sockaddr *)&id->route.addr.dst_addr,
			      listen_id, ib_event, ss_family,
			      ib_event->param.sidr_req_rcvd.service_id))
1683 1684
		goto err;

1685 1686
	if (net_dev) {
		ret = rdma_copy_addr(&id->route.addr.dev_addr, net_dev, NULL);
1687 1688
		if (ret)
			goto err;
1689
	} else {
1690 1691 1692 1693 1694 1695
		if (!cma_any_addr(cma_src_addr(id_priv))) {
			ret = cma_translate_addr(cma_src_addr(id_priv),
						 &id->route.addr.dev_addr);
			if (ret)
				goto err;
		}
1696
	}
1697

1698
	id_priv->state = RDMA_CM_CONNECT;
1699 1700 1701 1702 1703 1704
	return id_priv;
err:
	rdma_destroy_id(id);
	return NULL;
}

1705 1706 1707 1708 1709 1710 1711 1712 1713 1714 1715 1716 1717 1718 1719
static void cma_set_req_event_data(struct rdma_cm_event *event,
				   struct ib_cm_req_event_param *req_data,
				   void *private_data, int offset)
{
	event->param.conn.private_data = private_data + offset;
	event->param.conn.private_data_len = IB_CM_REQ_PRIVATE_DATA_SIZE - offset;
	event->param.conn.responder_resources = req_data->responder_resources;
	event->param.conn.initiator_depth = req_data->initiator_depth;
	event->param.conn.flow_control = req_data->flow_control;
	event->param.conn.retry_count = req_data->retry_count;
	event->param.conn.rnr_retry_count = req_data->rnr_retry_count;
	event->param.conn.srq = req_data->srq;
	event->param.conn.qp_num = req_data->remote_qpn;
}

1720 1721
static int cma_check_req_qp_type(struct rdma_cm_id *id, struct ib_cm_event *ib_event)
{
1722
	return (((ib_event->event == IB_CM_REQ_RECEIVED) &&
1723 1724 1725 1726 1727 1728
		 (ib_event->param.req_rcvd.qp_type == id->qp_type)) ||
		((ib_event->event == IB_CM_SIDR_REQ_RECEIVED) &&
		 (id->qp_type == IB_QPT_UD)) ||
		(!id->qp_type));
}

1729 1730 1731
static int cma_req_handler(struct ib_cm_id *cm_id, struct ib_cm_event *ib_event)
{
	struct rdma_id_private *listen_id, *conn_id;
1732
	struct rdma_cm_event event;
1733
	struct net_device *net_dev;
1734 1735
	u8 offset;
	int ret;
1736

1737
	listen_id = cma_id_from_event(cm_id, ib_event, &net_dev);
1738 1739 1740
	if (IS_ERR(listen_id))
		return PTR_ERR(listen_id);

1741 1742 1743 1744
	if (!cma_check_req_qp_type(&listen_id->id, ib_event)) {
		ret = -EINVAL;
		goto net_dev_put;
	}
1745

1746 1747 1748 1749
	if (cma_disable_callback(listen_id, RDMA_CM_LISTEN)) {
		ret = -ECONNABORTED;
		goto net_dev_put;
	}
1750

1751
	memset(&event, 0, sizeof event);
1752
	offset = cma_user_data_offset(listen_id);
1753
	event.event = RDMA_CM_EVENT_CONNECT_REQUEST;
1754
	if (ib_event->event == IB_CM_SIDR_REQ_RECEIVED) {
1755
		conn_id = cma_new_udp_id(&listen_id->id, ib_event, net_dev);
1756 1757 1758 1759
		event.param.ud.private_data = ib_event->private_data + offset;
		event.param.ud.private_data_len =
				IB_CM_SIDR_REQ_PRIVATE_DATA_SIZE - offset;
	} else {
1760
		conn_id = cma_new_conn_id(&listen_id->id, ib_event, net_dev);
1761 1762 1763
		cma_set_req_event_data(&event, &ib_event->param.req_rcvd,
				       ib_event->private_data, offset);
	}
1764 1765
	if (!conn_id) {
		ret = -ENOMEM;
1766
		goto err1;
1767 1768
	}

1769
	mutex_lock_nested(&conn_id->handler_mutex, SINGLE_DEPTH_NESTING);
1770
	ret = cma_acquire_dev(conn_id, listen_id);
1771
	if (ret)
1772
		goto err2;
1773 1774 1775 1776 1777

	conn_id->cm_id.ib = cm_id;
	cm_id->context = conn_id;
	cm_id->cm_handler = cma_ib_handler;

1778 1779 1780 1781 1782
	/*
	 * Protect against the user destroying conn_id from another thread
	 * until we're done accessing it.
	 */
	atomic_inc(&conn_id->refcount);
1783
	ret = conn_id->id.event_handler(&conn_id->id, &event);
1784 1785 1786 1787 1788 1789 1790
	if (ret)
		goto err3;
	/*
	 * Acquire mutex to prevent user executing rdma_destroy_id()
	 * while we're accessing the cm_id.
	 */
	mutex_lock(&lock);
1791 1792
	if (cma_comp(conn_id, RDMA_CM_CONNECT) &&
	    (conn_id->id.qp_type != IB_QPT_UD))
1793 1794 1795 1796
		ib_send_cm_mra(cm_id, CMA_CM_MRA_SETTING, NULL, 0);
	mutex_unlock(&lock);
	mutex_unlock(&conn_id->handler_mutex);
	mutex_unlock(&listen_id->handler_mutex);
1797
	cma_deref_id(conn_id);
1798 1799
	if (net_dev)
		dev_put(net_dev);
1800
	return 0;
1801

1802 1803
err3:
	cma_deref_id(conn_id);
1804 1805
	/* Destroy the CM ID by returning a non-zero value. */
	conn_id->cm_id.ib = NULL;
1806
err2:
1807
	cma_exch(conn_id, RDMA_CM_DESTROYING);
1808
	mutex_unlock(&conn_id->handler_mutex);
1809
err1:
1810
	mutex_unlock(&listen_id->handler_mutex);
1811 1812
	if (conn_id)
		rdma_destroy_id(&conn_id->id);
1813 1814 1815 1816 1817

net_dev_put:
	if (net_dev)
		dev_put(net_dev);

1818 1819 1820
	return ret;
}

1821
__be64 rdma_get_service_id(struct rdma_cm_id *id, struct sockaddr *addr)
1822
{
1823 1824 1825
	if (addr->sa_family == AF_IB)
		return ((struct sockaddr_ib *) addr)->sib_sid;

1826
	return cpu_to_be64(((u64)id->ps << 16) + be16_to_cpu(cma_port(addr)));
1827
}
1828
EXPORT_SYMBOL(rdma_get_service_id);
1829

Tom Tucker's avatar
Tom Tucker committed
1830 1831 1832
static int cma_iw_handler(struct iw_cm_id *iw_id, struct iw_cm_event *iw_event)
{
	struct rdma_id_private *id_priv = iw_id->context;
1833
	struct rdma_cm_event event;
Tom Tucker's avatar
Tom Tucker committed
1834
	int ret = 0;
1835 1836
	struct sockaddr *laddr = (struct sockaddr *)&iw_event->local_addr;
	struct sockaddr *raddr = (struct sockaddr *)&iw_event->remote_addr;
Tom Tucker's avatar
Tom Tucker committed
1837

1838
	if (cma_disable_callback(id_priv, RDMA_CM_CONNECT))
1839
		return 0;
Tom Tucker's avatar
Tom Tucker committed
1840

1841
	memset(&event, 0, sizeof event);
Tom Tucker's avatar
Tom Tucker committed
1842 1843
	switch (iw_event->event) {
	case IW_CM_EVENT_CLOSE:
1844
		event.event = RDMA_CM_EVENT_DISCONNECTED;
Tom Tucker's avatar
Tom Tucker committed
1845 1846
		break;
	case IW_CM_EVENT_CONNECT_REPLY:
1847 1848 1849 1850
		memcpy(cma_src_addr(id_priv), laddr,
		       rdma_addr_size(laddr));
		memcpy(cma_dst_addr(id_priv), raddr,
		       rdma_addr_size(raddr));
1851 1852
		switch (iw_event->status) {
		case 0:
1853
			event.event = RDMA_CM_EVENT_ESTABLISHED;
1854 1855
			event.param.conn.initiator_depth = iw_event->ird;
			event.param.conn.responder_resources = iw_event->ord;
1856 1857 1858 1859 1860 1861 1862 1863 1864 1865 1866 1867
			break;
		case -ECONNRESET:
		case -ECONNREFUSED:
			event.event = RDMA_CM_EVENT_REJECTED;
			break;
		case -ETIMEDOUT:
			event.event = RDMA_CM_EVENT_UNREACHABLE;
			break;
		default:
			event.event = RDMA_CM_EVENT_CONNECT_ERROR;
			break;
		}
Tom Tucker's avatar
Tom Tucker committed
1868 1869
		break;
	case IW_CM_EVENT_ESTABLISHED:
1870
		event.event = RDMA_CM_EVENT_ESTABLISHED;
1871 1872
		event.param.conn.initiator_depth = iw_event->ird;
		event.param.conn.responder_resources = iw_event->ord;
Tom Tucker's avatar
Tom Tucker committed
1873 1874 1875 1876 1877
		break;
	default:
		BUG_ON(1);
	}

1878 1879 1880 1881
	event.status = iw_event->status;
	event.param.conn.private_data = iw_event->private_data;
	event.param.conn.private_data_len = iw_event->private_data_len;
	ret = id_priv->id.event_handler(&id_priv->id, &event);
Tom Tucker's avatar
Tom Tucker committed
1882 1883 1884
	if (ret) {
		/* Destroy the CM ID by returning a non-zero value. */
		id_priv->cm_id.iw = NULL;
1885
		cma_exch(id_priv, RDMA_CM_DESTROYING);
1886
		mutex_unlock(&id_priv->handler_mutex);
Tom Tucker's avatar
Tom Tucker committed
1887 1888 1889 1890
		rdma_destroy_id(&id_priv->id);
		return ret;
	}

1891
	mutex_unlock(&id_priv->handler_mutex);
Tom Tucker's avatar
Tom Tucker committed
1892 1893 1894 1895 1896 1897 1898 1899
	return ret;
}

static int iw_conn_req_handler(struct iw_cm_id *cm_id,
			       struct iw_cm_event *iw_event)
{
	struct rdma_cm_id *new_cm_id;
	struct rdma_id_private *listen_id, *conn_id;
1900
	struct rdma_cm_event event;
Tom Tucker's avatar
Tom Tucker committed
1901
	int ret;
1902
	struct ib_device_attr attr;
1903 1904
	struct sockaddr *laddr = (struct sockaddr *)&iw_event->local_addr;
	struct sockaddr *raddr = (struct sockaddr *)&iw_event->remote_addr;
Tom Tucker's avatar
Tom Tucker committed
1905 1906

	listen_id = cm_id->context;
1907
	if (cma_disable_callback(listen_id, RDMA_CM_LISTEN))
1908
		return -ECONNABORTED;
Tom Tucker's avatar
Tom Tucker committed
1909 1910

	/* Create a new RDMA id for the new IW CM ID */
1911 1912
	new_cm_id = rdma_create_id(listen_id->id.route.addr.dev_addr.net,
				   listen_id->id.event_handler,
Tom Tucker's avatar
Tom Tucker committed
1913
				   listen_id->id.context,
1914
				   RDMA_PS_TCP, IB_QPT_RC);
1915
	if (IS_ERR(new_cm_id)) {
Tom Tucker's avatar
Tom Tucker committed
1916 1917 1918 1919
		ret = -ENOMEM;
		goto out;
	}
	conn_id = container_of(new_cm_id, struct rdma_id_private, id);
1920
	mutex_lock_nested(&conn_id->handler_mutex, SINGLE_DEPTH_NESTING);
1921
	conn_id->state = RDMA_CM_CONNECT;
Tom Tucker's avatar
Tom Tucker committed
1922

1923
	ret = rdma_translate_ip(laddr, &conn_id->id.route.addr.dev_addr, NULL);
Tom Tucker's avatar
Tom Tucker committed
1924
	if (ret) {
1925
		mutex_unlock(&conn_id->handler_mutex);
Tom Tucker's avatar
Tom Tucker committed
1926 1927 1928 1929
		rdma_destroy_id(new_cm_id);
		goto out;
	}

1930
	ret = cma_acquire_dev(conn_id, listen_id);
Tom Tucker's avatar
Tom Tucker committed
1931
	if (ret) {
1932
		mutex_unlock(&conn_id->handler_mutex);
Tom Tucker's avatar
Tom Tucker committed
1933 1934 1935 1936 1937 1938 1939 1940
		rdma_destroy_id(new_cm_id);
		goto out;
	}

	conn_id->cm_id.iw = cm_id;
	cm_id->context = conn_id;
	cm_id->cm_handler = cma_iw_handler;

1941 1942
	memcpy(cma_src_addr(conn_id), laddr, rdma_addr_size(laddr));
	memcpy(cma_dst_addr(conn_id), raddr, rdma_addr_size(raddr));
Tom Tucker's avatar
Tom Tucker committed
1943

1944 1945
	ret = ib_query_device(conn_id->id.device, &attr);
	if (ret) {
1946
		mutex_unlock(&conn_id->handler_mutex);
1947 1948 1949 1950
		rdma_destroy_id(new_cm_id);
		goto out;
	}

1951 1952 1953 1954
	memset(&event, 0, sizeof event);
	event.event = RDMA_CM_EVENT_CONNECT_REQUEST;
	event.param.conn.private_data = iw_event->private_data;
	event.param.conn.private_data_len = iw_event->private_data_len;
1955 1956
	event.param.conn.initiator_depth = iw_event->ird;
	event.param.conn.responder_resources = iw_event->ord;
1957 1958 1959 1960 1961 1962

	/*
	 * Protect against the user destroying conn_id from another thread
	 * until we're done accessing it.
	 */
	atomic_inc(&conn_id->refcount);
1963
	ret = conn_id->id.event_handler(&conn_id->id, &event);
Tom Tucker's avatar
Tom Tucker committed
1964 1965 1966
	if (ret) {
		/* User wants to destroy the CM ID */
		conn_id->cm_id.iw = NULL;
1967
		cma_exch(conn_id, RDMA_CM_DESTROYING);
1968
		mutex_unlock(&conn_id->handler_mutex);
1969
		cma_deref_id(conn_id);
Tom Tucker's avatar
Tom Tucker committed
1970
		rdma_destroy_id(&conn_id->id);
1971
		goto out;
Tom Tucker's avatar
Tom Tucker committed
1972 1973
	}

1974
	mutex_unlock(&conn_id->handler_mutex);
1975
	cma_deref_id(conn_id);
1976

Tom Tucker's avatar
Tom Tucker committed
1977
out:
1978
	mutex_unlock(&listen_id->handler_mutex);
Tom Tucker's avatar
Tom Tucker committed
1979 1980 1981
	return ret;
}

1982 1983 1984
static int cma_ib_listen(struct rdma_id_private *id_priv)
{
	struct sockaddr *addr;
1985
	struct ib_cm_id	*id;
1986 1987
	__be64 svc_id;

1988 1989 1990
	addr = cma_src_addr(id_priv);
	svc_id = rdma_get_service_id(&id_priv->id, addr);
	id = ib_cm_insert_listen(id_priv->id.device, cma_req_handler, svc_id);
1991 1992 1993
	if (IS_ERR(id))
		return PTR_ERR(id);
	id_priv->cm_id.ib = id;
1994

1995
	return 0;
1996 1997
}

Tom Tucker's avatar
Tom Tucker committed
1998 1999 2000
static int cma_iw_listen(struct rdma_id_private *id_priv, int backlog)
{
	int ret;
2001 2002 2003 2004 2005 2006 2007
	struct iw_cm_id	*id;

	id = iw_create_cm_id(id_priv->id.device,
			     iw_conn_req_handler,
			     id_priv);
	if (IS_ERR(id))
		return PTR_ERR(id);
Tom Tucker's avatar
Tom Tucker committed
2008

2009
	id->tos = id_priv->tos;
2010
	id_priv->cm_id.iw = id;
Tom Tucker's avatar
Tom Tucker committed
2011

2012 2013
	memcpy(&id_priv->cm_id.iw->local_addr, cma_src_addr(id_priv),
	       rdma_addr_size(cma_src_addr(id_priv)));
Tom Tucker's avatar
Tom Tucker committed
2014 2015 2016 2017 2018 2019 2020 2021 2022 2023 2024

	ret = iw_cm_listen(id_priv->cm_id.iw, backlog);

	if (ret) {
		iw_destroy_cm_id(id_priv->cm_id.iw);
		id_priv->cm_id.iw = NULL;
	}

	return ret;
}

2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039
static int cma_listen_handler(struct rdma_cm_id *id,
			      struct rdma_cm_event *event)
{
	struct rdma_id_private *id_priv = id->context;

	id->context = id_priv->id.context;
	id->event_handler = id_priv->id.event_handler;
	return id_priv->id.event_handler(id, event);
}

static void cma_listen_on_dev(struct rdma_id_private *id_priv,
			      struct cma_device *cma_dev)
{
	struct rdma_id_private *dev_id_priv;
	struct rdma_cm_id *id;
2040
	struct net *net = id_priv->id.route.addr.dev_addr.net;
2041 2042
	int ret;

2043
	if (cma_family(id_priv) == AF_IB && !rdma_cap_ib_cm(cma_dev->device, 1))
2044 2045
		return;

2046
	id = rdma_create_id(net, cma_listen_handler, id_priv, id_priv->id.ps,
2047
			    id_priv->id.qp_type);
2048 2049 2050 2051 2052
	if (IS_ERR(id))
		return;

	dev_id_priv = container_of(id, struct rdma_id_private, id);

2053
	dev_id_priv->state = RDMA_CM_ADDR_BOUND;
2054 2055
	memcpy(cma_src_addr(dev_id_priv), cma_src_addr(id_priv),
	       rdma_addr_size(cma_src_addr(id_priv)));
2056 2057 2058

	cma_attach_to_dev(dev_id_priv, cma_dev);
	list_add_tail(&dev_id_priv->listen_list, &id_priv->listen_list);
2059 2060
	atomic_inc(&id_priv->refcount);
	dev_id_priv->internal_id = 1;
2061
	dev_id_priv->afonly = id_priv->afonly;
2062 2063 2064

	ret = rdma_listen(id, id_priv->backlog);
	if (ret)
2065
		printk(KERN_WARNING "RDMA CMA: cma_listen_on_dev, error %d, "
2066
		       "listening on device %s\n", ret, cma_dev->device->name);
2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079
}

static void cma_listen_on_all(struct rdma_id_private *id_priv)
{
	struct cma_device *cma_dev;

	mutex_lock(&lock);
	list_add_tail(&id_priv->list, &listen_any_list);
	list_for_each_entry(cma_dev, &dev_list, list)
		cma_listen_on_dev(id_priv, cma_dev);
	mutex_unlock(&lock);
}

2080 2081 2082 2083 2084 2085 2086 2087 2088
void rdma_set_service_type(struct rdma_cm_id *id, int tos)
{
	struct rdma_id_private *id_priv;

	id_priv = container_of(id, struct rdma_id_private, id);
	id_priv->tos = (u8) tos;
}
EXPORT_SYMBOL(rdma_set_service_type);

2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100
static void cma_query_handler(int status, struct ib_sa_path_rec *path_rec,
			      void *context)
{
	struct cma_work *work = context;
	struct rdma_route *route;

	route = &work->id->id.route;

	if (!status) {
		route->num_paths = 1;
		*route->path_rec = *path_rec;
	} else {
2101 2102
		work->old_state = RDMA_CM_ROUTE_QUERY;
		work->new_state = RDMA_CM_ADDR_RESOLVED;
2103
		work->event.event = RDMA_CM_EVENT_ROUTE_ERROR;
2104
		work->event.status = status;
2105 2106 2107 2108 2109 2110 2111 2112
	}

	queue_work(cma_wq, &work->work);
}

static int cma_query_ib_route(struct rdma_id_private *id_priv, int timeout_ms,
			      struct cma_work *work)
{
2113
	struct rdma_dev_addr *dev_addr = &id_priv->id.route.addr.dev_addr;
2114
	struct ib_sa_path_rec path_rec;
2115 2116
	ib_sa_comp_mask comp_mask;
	struct sockaddr_in6 *sin6;
2117
	struct sockaddr_ib *sib;
2118 2119

	memset(&path_rec, 0, sizeof path_rec);
2120 2121 2122
	rdma_addr_get_sgid(dev_addr, &path_rec.sgid);
	rdma_addr_get_dgid(dev_addr, &path_rec.dgid);
	path_rec.pkey = cpu_to_be16(ib_addr_get_pkey(dev_addr));
2123
	path_rec.numb_path = 1;
2124
	path_rec.reversible = 1;
2125
	path_rec.service_id = rdma_get_service_id(&id_priv->id, cma_dst_addr(id_priv));
2126 2127 2128 2129 2130

	comp_mask = IB_SA_PATH_REC_DGID | IB_SA_PATH_REC_SGID |
		    IB_SA_PATH_REC_PKEY | IB_SA_PATH_REC_NUMB_PATH |
		    IB_SA_PATH_REC_REVERSIBLE | IB_SA_PATH_REC_SERVICE_ID;

2131 2132
	switch (cma_family(id_priv)) {
	case AF_INET:
2133 2134
		path_rec.qos_class = cpu_to_be16((u16) id_priv->tos);
		comp_mask |= IB_SA_PATH_REC_QOS_CLASS;
2135 2136
		break;
	case AF_INET6:
2137
		sin6 = (struct sockaddr_in6 *) cma_src_addr(id_priv);
2138 2139
		path_rec.traffic_class = (u8) (be32_to_cpu(sin6->sin6_flowinfo) >> 20);
		comp_mask |= IB_SA_PATH_REC_TRAFFIC_CLASS;
2140 2141 2142 2143 2144 2145
		break;
	case AF_IB:
		sib = (struct sockaddr_ib *) cma_src_addr(id_priv);
		path_rec.traffic_class = (u8) (be32_to_cpu(sib->sib_flowinfo) >> 20);
		comp_mask |= IB_SA_PATH_REC_TRAFFIC_CLASS;
		break;
2146
	}
2147

2148
	id_priv->query_id = ib_sa_path_rec_get(&sa_client, id_priv->id.device,
2149 2150 2151 2152
					       id_priv->id.port_num, &path_rec,
					       comp_mask, timeout_ms,
					       GFP_KERNEL, cma_query_handler,
					       work, &id_priv->query);
2153 2154 2155 2156

	return (id_priv->query_id < 0) ? id_priv->query_id : 0;
}

2157
static void cma_work_handler(struct work_struct *_work)
2158
{
2159
	struct cma_work *work = container_of(_work, struct cma_work, work);
2160 2161 2162
	struct rdma_id_private *id_priv = work->id;
	int destroy = 0;

2163
	mutex_lock(&id_priv->handler_mutex);
2164 2165 2166 2167
	if (!cma_comp_exch(id_priv, work->old_state, work->new_state))
		goto out;

	if (id_priv->id.event_handler(&id_priv->id, &work->event)) {
2168
		cma_exch(id_priv, RDMA_CM_DESTROYING);
2169 2170 2171
		destroy = 1;
	}
out:
2172
	mutex_unlock(&id_priv->handler_mutex);
2173 2174 2175 2176 2177 2178
	cma_deref_id(id_priv);
	if (destroy)
		rdma_destroy_id(&id_priv->id);
	kfree(work);
}

2179 2180 2181 2182 2183 2184 2185
static void cma_ndev_work_handler(struct work_struct *_work)
{
	struct cma_ndev_work *work = container_of(_work, struct cma_ndev_work, work);
	struct rdma_id_private *id_priv = work->id;
	int destroy = 0;

	mutex_lock(&id_priv->handler_mutex);
2186 2187
	if (id_priv->state == RDMA_CM_DESTROYING ||
	    id_priv->state == RDMA_CM_DEVICE_REMOVAL)
2188 2189 2190
		goto out;

	if (id_priv->id.event_handler(&id_priv->id, &work->event)) {
2191
		cma_exch(id_priv, RDMA_CM_DESTROYING);
2192 2193 2194 2195 2196 2197 2198 2199 2200 2201 2202
		destroy = 1;
	}

out:
	mutex_unlock(&id_priv->handler_mutex);
	cma_deref_id(id_priv);
	if (destroy)
		rdma_destroy_id(&id_priv->id);
	kfree(work);
}

2203 2204 2205 2206 2207 2208 2209 2210 2211 2212 2213
static int cma_resolve_ib_route(struct rdma_id_private *id_priv, int timeout_ms)
{
	struct rdma_route *route = &id_priv->id.route;
	struct cma_work *work;
	int ret;

	work = kzalloc(sizeof *work, GFP_KERNEL);
	if (!work)
		return -ENOMEM;

	work->id = id_priv;
2214
	INIT_WORK(&work->work, cma_work_handler);
2215 2216
	work->old_state = RDMA_CM_ROUTE_QUERY;
	work->new_state = RDMA_CM_ROUTE_RESOLVED;
2217 2218 2219 2220 2221 2222 2223 2224 2225 2226 2227 2228 2229 2230 2231 2232 2233 2234 2235 2236 2237 2238 2239 2240 2241 2242 2243 2244
	work->event.event = RDMA_CM_EVENT_ROUTE_RESOLVED;

	route->path_rec = kmalloc(sizeof *route->path_rec, GFP_KERNEL);
	if (!route->path_rec) {
		ret = -ENOMEM;
		goto err1;
	}

	ret = cma_query_ib_route(id_priv, timeout_ms, work);
	if (ret)
		goto err2;

	return 0;
err2:
	kfree(route->path_rec);
	route->path_rec = NULL;
err1:
	kfree(work);
	return ret;
}

int rdma_set_ib_paths(struct rdma_cm_id *id,
		      struct ib_sa_path_rec *path_rec, int num_paths)
{
	struct rdma_id_private *id_priv;
	int ret;

	id_priv = container_of(id, struct rdma_id_private, id);
2245 2246
	if (!cma_comp_exch(id_priv, RDMA_CM_ADDR_RESOLVED,
			   RDMA_CM_ROUTE_RESOLVED))
2247 2248
		return -EINVAL;

2249 2250
	id->route.path_rec = kmemdup(path_rec, sizeof *path_rec * num_paths,
				     GFP_KERNEL);
2251 2252 2253 2254 2255
	if (!id->route.path_rec) {
		ret = -ENOMEM;
		goto err;
	}

2256
	id->route.num_paths = num_paths;
2257 2258
	return 0;
err:
2259
	cma_comp_exch(id_priv, RDMA_CM_ROUTE_RESOLVED, RDMA_CM_ADDR_RESOLVED);
2260 2261 2262 2263
	return ret;
}
EXPORT_SYMBOL(rdma_set_ib_paths);

Tom Tucker's avatar
Tom Tucker committed
2264 2265 2266 2267 2268 2269 2270 2271 2272
static int cma_resolve_iw_route(struct rdma_id_private *id_priv, int timeout_ms)
{
	struct cma_work *work;

	work = kzalloc(sizeof *work, GFP_KERNEL);
	if (!work)
		return -ENOMEM;

	work->id = id_priv;
2273
	INIT_WORK(&work->work, cma_work_handler);
2274 2275
	work->old_state = RDMA_CM_ROUTE_QUERY;
	work->new_state = RDMA_CM_ROUTE_RESOLVED;
Tom Tucker's avatar
Tom Tucker committed
2276 2277 2278 2279 2280
	work->event.event = RDMA_CM_EVENT_ROUTE_RESOLVED;
	queue_work(cma_wq, &work->work);
	return 0;
}

2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293 2294 2295 2296 2297 2298 2299 2300
static int iboe_tos_to_sl(struct net_device *ndev, int tos)
{
	int prio;
	struct net_device *dev;

	prio = rt_tos2priority(tos);
	dev = ndev->priv_flags & IFF_802_1Q_VLAN ?
		vlan_dev_real_dev(ndev) : ndev;

	if (dev->num_tc)
		return netdev_get_prio_tc_map(dev, prio);

#if IS_ENABLED(CONFIG_VLAN_8021Q)
	if (ndev->priv_flags & IFF_802_1Q_VLAN)
		return (vlan_dev_get_egress_qos_mask(ndev, prio) &
			VLAN_PRIO_MASK) >> VLAN_PRIO_SHIFT;
#endif
	return 0;
}

2301 2302 2303 2304 2305 2306 2307
static int cma_resolve_iboe_route(struct rdma_id_private *id_priv)
{
	struct rdma_route *route = &id_priv->id.route;
	struct rdma_addr *addr = &route->addr;
	struct cma_work *work;
	int ret;
	struct net_device *ndev = NULL;
2308

2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324

	work = kzalloc(sizeof *work, GFP_KERNEL);
	if (!work)
		return -ENOMEM;

	work->id = id_priv;
	INIT_WORK(&work->work, cma_work_handler);

	route->path_rec = kzalloc(sizeof *route->path_rec, GFP_KERNEL);
	if (!route->path_rec) {
		ret = -ENOMEM;
		goto err1;
	}

	route->num_paths = 1;

2325
	if (addr->dev_addr.bound_dev_if) {
2326
		ndev = dev_get_by_index(&init_net, addr->dev_addr.bound_dev_if);
2327 2328 2329
		route->path_rec->net = &init_net;
		route->path_rec->ifindex = addr->dev_addr.bound_dev_if;
	}
2330 2331 2332 2333 2334
	if (!ndev) {
		ret = -ENODEV;
		goto err2;
	}

2335
	memcpy(route->path_rec->dmac, addr->dev_addr.dst_dev_addr, ETH_ALEN);
2336

2337 2338 2339 2340
	rdma_ip2gid((struct sockaddr *)&id_priv->id.route.addr.src_addr,
		    &route->path_rec->sgid);
	rdma_ip2gid((struct sockaddr *)&id_priv->id.route.addr.dst_addr,
		    &route->path_rec->dgid);
2341 2342 2343 2344 2345

	route->path_rec->hop_limit = 1;
	route->path_rec->reversible = 1;
	route->path_rec->pkey = cpu_to_be16(0xffff);
	route->path_rec->mtu_selector = IB_SA_EQ;
2346
	route->path_rec->sl = iboe_tos_to_sl(ndev, id_priv->tos);
2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357
	route->path_rec->mtu = iboe_get_mtu(ndev->mtu);
	route->path_rec->rate_selector = IB_SA_EQ;
	route->path_rec->rate = iboe_get_rate(ndev);
	dev_put(ndev);
	route->path_rec->packet_life_time_selector = IB_SA_EQ;
	route->path_rec->packet_life_time = CMA_IBOE_PACKET_LIFETIME;
	if (!route->path_rec->mtu) {
		ret = -EINVAL;
		goto err2;
	}

2358 2359
	work->old_state = RDMA_CM_ROUTE_QUERY;
	work->new_state = RDMA_CM_ROUTE_RESOLVED;
2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374
	work->event.event = RDMA_CM_EVENT_ROUTE_RESOLVED;
	work->event.status = 0;

	queue_work(cma_wq, &work->work);

	return 0;

err2:
	kfree(route->path_rec);
	route->path_rec = NULL;
err1:
	kfree(work);
	return ret;
}

2375 2376 2377 2378 2379 2380
int rdma_resolve_route(struct rdma_cm_id *id, int timeout_ms)
{
	struct rdma_id_private *id_priv;
	int ret;

	id_priv = container_of(id, struct rdma_id_private, id);
2381
	if (!cma_comp_exch(id_priv, RDMA_CM_ADDR_RESOLVED, RDMA_CM_ROUTE_QUERY))
2382 2383 2384
		return -EINVAL;

	atomic_inc(&id_priv->refcount);
2385
	if (rdma_cap_ib_sa(id->device, id->port_num))
2386
		ret = cma_resolve_ib_route(id_priv, timeout_ms);
2387
	else if (rdma_protocol_roce(id->device, id->port_num))
2388 2389
		ret = cma_resolve_iboe_route(id_priv);
	else if (rdma_protocol_iwarp(id->device, id->port_num))
Tom Tucker's avatar
Tom Tucker committed
2390
		ret = cma_resolve_iw_route(id_priv, timeout_ms);
2391
	else
2392
		ret = -ENOSYS;
2393

2394 2395 2396 2397 2398
	if (ret)
		goto err;

	return 0;
err:
2399
	cma_comp_exch(id_priv, RDMA_CM_ROUTE_QUERY, RDMA_CM_ADDR_RESOLVED);
2400 2401 2402 2403 2404
	cma_deref_id(id_priv);
	return ret;
}
EXPORT_SYMBOL(rdma_resolve_route);

2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419 2420 2421
static void cma_set_loopback(struct sockaddr *addr)
{
	switch (addr->sa_family) {
	case AF_INET:
		((struct sockaddr_in *) addr)->sin_addr.s_addr = htonl(INADDR_LOOPBACK);
		break;
	case AF_INET6:
		ipv6_addr_set(&((struct sockaddr_in6 *) addr)->sin6_addr,
			      0, 0, 0, htonl(1));
		break;
	default:
		ib_addr_set(&((struct sockaddr_ib *) addr)->sib_addr,
			    0, 0, 0, htonl(1));
		break;
	}
}

2422 2423
static int cma_bind_loopback(struct rdma_id_private *id_priv)
{
2424
	struct cma_device *cma_dev, *cur_dev;
2425
	struct ib_port_attr port_attr;
2426
	union ib_gid gid;
2427 2428 2429 2430
	u16 pkey;
	int ret;
	u8 p;

2431
	cma_dev = NULL;
2432
	mutex_lock(&lock);
2433 2434
	list_for_each_entry(cur_dev, &dev_list, list) {
		if (cma_family(id_priv) == AF_IB &&
2435
		    !rdma_cap_ib_cm(cur_dev->device, 1))
2436 2437 2438 2439 2440 2441 2442 2443 2444 2445 2446 2447 2448 2449 2450
			continue;

		if (!cma_dev)
			cma_dev = cur_dev;

		for (p = 1; p <= cur_dev->device->phys_port_cnt; ++p) {
			if (!ib_query_port(cur_dev->device, p, &port_attr) &&
			    port_attr.state == IB_PORT_ACTIVE) {
				cma_dev = cur_dev;
				goto port_found;
			}
		}
	}

	if (!cma_dev) {
2451 2452 2453
		ret = -ENODEV;
		goto out;
	}
2454

2455
	p = 1;
2456 2457

port_found:
2458
	ret = ib_get_cached_gid(cma_dev->device, p, 0, &gid, NULL);
2459 2460 2461 2462 2463 2464 2465
	if (ret)
		goto out;

	ret = ib_get_cached_pkey(cma_dev->device, p, 0, &pkey);
	if (ret)
		goto out;

2466
	id_priv->id.route.addr.dev_addr.dev_type =
2467
		(rdma_protocol_ib(cma_dev->device, p)) ?
2468 2469 2470
		ARPHRD_INFINIBAND : ARPHRD_ETHER;

	rdma_addr_set_sgid(&id_priv->id.route.addr.dev_addr, &gid);
2471 2472 2473
	ib_addr_set_pkey(&id_priv->id.route.addr.dev_addr, pkey);
	id_priv->id.port_num = p;
	cma_attach_to_dev(id_priv, cma_dev);
2474
	cma_set_loopback(cma_src_addr(id_priv));
2475 2476 2477 2478 2479 2480 2481 2482 2483
out:
	mutex_unlock(&lock);
	return ret;
}

static void addr_handler(int status, struct sockaddr *src_addr,
			 struct rdma_dev_addr *dev_addr, void *context)
{
	struct rdma_id_private *id_priv = context;
2484
	struct rdma_cm_event event;
2485

2486
	memset(&event, 0, sizeof event);
2487
	mutex_lock(&id_priv->handler_mutex);
2488 2489
	if (!cma_comp_exch(id_priv, RDMA_CM_ADDR_QUERY,
			   RDMA_CM_ADDR_RESOLVED))
2490 2491
		goto out;

2492
	memcpy(cma_src_addr(id_priv), src_addr, rdma_addr_size(src_addr));
2493
	if (!status && !id_priv->cma_dev)
2494
		status = cma_acquire_dev(id_priv, NULL);
2495 2496

	if (status) {
2497 2498
		if (!cma_comp_exch(id_priv, RDMA_CM_ADDR_RESOLVED,
				   RDMA_CM_ADDR_BOUND))
2499
			goto out;
2500 2501
		event.event = RDMA_CM_EVENT_ADDR_ERROR;
		event.status = status;
2502
	} else
2503
		event.event = RDMA_CM_EVENT_ADDR_RESOLVED;
2504

2505
	if (id_priv->id.event_handler(&id_priv->id, &event)) {
2506
		cma_exch(id_priv, RDMA_CM_DESTROYING);
2507
		mutex_unlock(&id_priv->handler_mutex);
2508 2509 2510 2511 2512
		cma_deref_id(id_priv);
		rdma_destroy_id(&id_priv->id);
		return;
	}
out:
2513
	mutex_unlock(&id_priv->handler_mutex);
2514 2515 2516 2517 2518 2519
	cma_deref_id(id_priv);
}

static int cma_resolve_loopback(struct rdma_id_private *id_priv)
{
	struct cma_work *work;
2520
	union ib_gid gid;
2521 2522 2523 2524 2525 2526 2527 2528 2529 2530 2531 2532
	int ret;

	work = kzalloc(sizeof *work, GFP_KERNEL);
	if (!work)
		return -ENOMEM;

	if (!id_priv->cma_dev) {
		ret = cma_bind_loopback(id_priv);
		if (ret)
			goto err;
	}

2533 2534
	rdma_addr_get_sgid(&id_priv->id.route.addr.dev_addr, &gid);
	rdma_addr_set_dgid(&id_priv->id.route.addr.dev_addr, &gid);
2535 2536

	work->id = id_priv;
2537
	INIT_WORK(&work->work, cma_work_handler);
2538 2539
	work->old_state = RDMA_CM_ADDR_QUERY;
	work->new_state = RDMA_CM_ADDR_RESOLVED;
2540 2541 2542 2543 2544 2545 2546 2547
	work->event.event = RDMA_CM_EVENT_ADDR_RESOLVED;
	queue_work(cma_wq, &work->work);
	return 0;
err:
	kfree(work);
	return ret;
}

2548 2549 2550 2551 2552 2553 2554 2555 2556 2557 2558 2559 2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570 2571 2572 2573 2574 2575 2576 2577
static int cma_resolve_ib_addr(struct rdma_id_private *id_priv)
{
	struct cma_work *work;
	int ret;

	work = kzalloc(sizeof *work, GFP_KERNEL);
	if (!work)
		return -ENOMEM;

	if (!id_priv->cma_dev) {
		ret = cma_resolve_ib_dev(id_priv);
		if (ret)
			goto err;
	}

	rdma_addr_set_dgid(&id_priv->id.route.addr.dev_addr, (union ib_gid *)
		&(((struct sockaddr_ib *) &id_priv->id.route.addr.dst_addr)->sib_addr));

	work->id = id_priv;
	INIT_WORK(&work->work, cma_work_handler);
	work->old_state = RDMA_CM_ADDR_QUERY;
	work->new_state = RDMA_CM_ADDR_RESOLVED;
	work->event.event = RDMA_CM_EVENT_ADDR_RESOLVED;
	queue_work(cma_wq, &work->work);
	return 0;
err:
	kfree(work);
	return ret;
}

2578 2579 2580
static int cma_bind_addr(struct rdma_cm_id *id, struct sockaddr *src_addr,
			 struct sockaddr *dst_addr)
{
2581 2582
	if (!src_addr || !src_addr->sa_family) {
		src_addr = (struct sockaddr *) &id->route.addr.src_addr;
2583
		src_addr->sa_family = dst_addr->sa_family;
2584 2585
		if (IS_ENABLED(CONFIG_IPV6) &&
		    dst_addr->sa_family == AF_INET6) {
2586 2587 2588 2589 2590
			struct sockaddr_in6 *src_addr6 = (struct sockaddr_in6 *) src_addr;
			struct sockaddr_in6 *dst_addr6 = (struct sockaddr_in6 *) dst_addr;
			src_addr6->sin6_scope_id = dst_addr6->sin6_scope_id;
			if (ipv6_addr_type(&dst_addr6->sin6_addr) & IPV6_ADDR_LINKLOCAL)
				id->route.addr.dev_addr.bound_dev_if = dst_addr6->sin6_scope_id;
2591 2592 2593
		} else if (dst_addr->sa_family == AF_IB) {
			((struct sockaddr_ib *) src_addr)->sib_pkey =
				((struct sockaddr_ib *) dst_addr)->sib_pkey;
2594 2595 2596
		}
	}
	return rdma_bind_addr(id, src_addr);
2597 2598 2599 2600 2601 2602 2603 2604 2605
}

int rdma_resolve_addr(struct rdma_cm_id *id, struct sockaddr *src_addr,
		      struct sockaddr *dst_addr, int timeout_ms)
{
	struct rdma_id_private *id_priv;
	int ret;

	id_priv = container_of(id, struct rdma_id_private, id);
2606
	if (id_priv->state == RDMA_CM_IDLE) {
2607 2608 2609 2610 2611
		ret = cma_bind_addr(id, src_addr, dst_addr);
		if (ret)
			return ret;
	}

2612 2613 2614
	if (cma_family(id_priv) != dst_addr->sa_family)
		return -EINVAL;

2615
	if (!cma_comp_exch(id_priv, RDMA_CM_ADDR_BOUND, RDMA_CM_ADDR_QUERY))
2616 2617 2618
		return -EINVAL;

	atomic_inc(&id_priv->refcount);
2619
	memcpy(cma_dst_addr(id_priv), dst_addr, rdma_addr_size(dst_addr));
2620
	if (cma_any_addr(dst_addr)) {
2621
		ret = cma_resolve_loopback(id_priv);
2622 2623 2624 2625 2626 2627 2628 2629 2630
	} else {
		if (dst_addr->sa_family == AF_IB) {
			ret = cma_resolve_ib_addr(id_priv);
		} else {
			ret = rdma_resolve_ip(&addr_client, cma_src_addr(id_priv),
					      dst_addr, &id->route.addr.dev_addr,
					      timeout_ms, addr_handler, id_priv);
		}
	}
2631 2632 2633 2634 2635
	if (ret)
		goto err;

	return 0;
err:
2636
	cma_comp_exch(id_priv, RDMA_CM_ADDR_QUERY, RDMA_CM_ADDR_BOUND);
2637 2638 2639 2640 2641
	cma_deref_id(id_priv);
	return ret;
}
EXPORT_SYMBOL(rdma_resolve_addr);

2642 2643 2644 2645 2646 2647 2648 2649
int rdma_set_reuseaddr(struct rdma_cm_id *id, int reuse)
{
	struct rdma_id_private *id_priv;
	unsigned long flags;
	int ret;

	id_priv = container_of(id, struct rdma_id_private, id);
	spin_lock_irqsave(&id_priv->lock, flags);
2650
	if (reuse || id_priv->state == RDMA_CM_IDLE) {
2651 2652 2653 2654 2655 2656 2657 2658 2659 2660
		id_priv->reuseaddr = reuse;
		ret = 0;
	} else {
		ret = -EINVAL;
	}
	spin_unlock_irqrestore(&id_priv->lock, flags);
	return ret;
}
EXPORT_SYMBOL(rdma_set_reuseaddr);

2661 2662 2663 2664 2665 2666 2667 2668 2669 2670 2671 2672 2673 2674 2675 2676 2677 2678 2679 2680
int rdma_set_afonly(struct rdma_cm_id *id, int afonly)
{
	struct rdma_id_private *id_priv;
	unsigned long flags;
	int ret;

	id_priv = container_of(id, struct rdma_id_private, id);
	spin_lock_irqsave(&id_priv->lock, flags);
	if (id_priv->state == RDMA_CM_IDLE || id_priv->state == RDMA_CM_ADDR_BOUND) {
		id_priv->options |= (1 << CMA_OPTION_AFONLY);
		id_priv->afonly = afonly;
		ret = 0;
	} else {
		ret = -EINVAL;
	}
	spin_unlock_irqrestore(&id_priv->lock, flags);
	return ret;
}
EXPORT_SYMBOL(rdma_set_afonly);

2681 2682 2683
static void cma_bind_port(struct rdma_bind_list *bind_list,
			  struct rdma_id_private *id_priv)
{
2684 2685 2686 2687
	struct sockaddr *addr;
	struct sockaddr_ib *sib;
	u64 sid, mask;
	__be16 port;
2688

2689
	addr = cma_src_addr(id_priv);
2690 2691 2692 2693 2694 2695 2696 2697 2698 2699 2700 2701 2702 2703 2704 2705 2706
	port = htons(bind_list->port);

	switch (addr->sa_family) {
	case AF_INET:
		((struct sockaddr_in *) addr)->sin_port = port;
		break;
	case AF_INET6:
		((struct sockaddr_in6 *) addr)->sin6_port = port;
		break;
	case AF_IB:
		sib = (struct sockaddr_ib *) addr;
		sid = be64_to_cpu(sib->sib_sid);
		mask = be64_to_cpu(sib->sib_sid_mask);
		sib->sib_sid = cpu_to_be64((sid & mask) | (u64) ntohs(port));
		sib->sib_sid_mask = cpu_to_be64(~0ULL);
		break;
	}
2707 2708 2709 2710
	id_priv->bind_list = bind_list;
	hlist_add_head(&id_priv->node, &bind_list->owners);
}

2711 2712
static int cma_alloc_port(enum rdma_port_space ps,
			  struct rdma_id_private *id_priv, unsigned short snum)
2713 2714
{
	struct rdma_bind_list *bind_list;
Tejun Heo's avatar
Tejun Heo committed
2715
	int ret;
2716

2717
	bind_list = kzalloc(sizeof *bind_list, GFP_KERNEL);
2718 2719 2720
	if (!bind_list)
		return -ENOMEM;

2721 2722
	ret = cma_ps_alloc(id_priv->id.route.addr.dev_addr.net, ps, bind_list,
			   snum);
Tejun Heo's avatar
Tejun Heo committed
2723 2724
	if (ret < 0)
		goto err;
2725 2726

	bind_list->ps = ps;
Tejun Heo's avatar
Tejun Heo committed
2727
	bind_list->port = (unsigned short)ret;
2728 2729
	cma_bind_port(bind_list, id_priv);
	return 0;
Tejun Heo's avatar
Tejun Heo committed
2730
err:
2731
	kfree(bind_list);
Tejun Heo's avatar
Tejun Heo committed
2732
	return ret == -ENOSPC ? -EADDRNOTAVAIL : ret;
2733
}
2734

2735 2736
static int cma_alloc_any_port(enum rdma_port_space ps,
			      struct rdma_id_private *id_priv)
2737
{
2738 2739 2740
	static unsigned int last_used_port;
	int low, high, remaining;
	unsigned int rover;
2741
	struct net *net = id_priv->id.route.addr.dev_addr.net;
2742

2743
	inet_get_local_port_range(net, &low, &high);
2744
	remaining = (high - low) + 1;
2745
	rover = prandom_u32() % remaining + low;
2746 2747
retry:
	if (last_used_port != rover &&
2748
	    !cma_ps_find(net, ps, (unsigned short)rover)) {
2749 2750 2751 2752 2753 2754 2755 2756 2757
		int ret = cma_alloc_port(ps, id_priv, rover);
		/*
		 * Remember previously used port number in order to avoid
		 * re-using same port immediately after it is closed.
		 */
		if (!ret)
			last_used_port = rover;
		if (ret != -EADDRNOTAVAIL)
			return ret;
2758
	}
2759 2760 2761 2762 2763 2764 2765
	if (--remaining) {
		rover++;
		if ((rover < low) || (rover > high))
			rover = low;
		goto retry;
	}
	return -EADDRNOTAVAIL;
2766 2767
}

2768 2769 2770 2771 2772 2773 2774 2775
/*
 * Check that the requested port is available.  This is called when trying to
 * bind to a specific port, or when trying to listen on a bound port.  In
 * the latter case, the provided id_priv may already be on the bind_list, but
 * we still need to check that it's okay to start listening.
 */
static int cma_check_port(struct rdma_bind_list *bind_list,
			  struct rdma_id_private *id_priv, uint8_t reuseaddr)
2776 2777
{
	struct rdma_id_private *cur_id;
2778
	struct sockaddr *addr, *cur_addr;
2779

2780
	addr = cma_src_addr(id_priv);
2781
	hlist_for_each_entry(cur_id, &bind_list->owners, node) {
2782 2783
		if (id_priv == cur_id)
			continue;
Roland Dreier's avatar
Roland Dreier committed
2784

2785 2786 2787
		if ((cur_id->state != RDMA_CM_LISTEN) && reuseaddr &&
		    cur_id->reuseaddr)
			continue;
2788

2789
		cur_addr = cma_src_addr(cur_id);
2790 2791 2792 2793 2794 2795 2796 2797 2798
		if (id_priv->afonly && cur_id->afonly &&
		    (addr->sa_family != cur_addr->sa_family))
			continue;

		if (cma_any_addr(addr) || cma_any_addr(cur_addr))
			return -EADDRNOTAVAIL;

		if (!cma_addr_cmp(addr, cur_addr))
			return -EADDRINUSE;
2799
	}
2800 2801 2802
	return 0;
}

2803 2804
static int cma_use_port(enum rdma_port_space ps,
			struct rdma_id_private *id_priv)
2805 2806 2807 2808 2809
{
	struct rdma_bind_list *bind_list;
	unsigned short snum;
	int ret;

2810
	snum = ntohs(cma_port(cma_src_addr(id_priv)));
2811 2812 2813
	if (snum < PROT_SOCK && !capable(CAP_NET_BIND_SERVICE))
		return -EACCES;

2814
	bind_list = cma_ps_find(id_priv->id.route.addr.dev_addr.net, ps, snum);
2815 2816 2817 2818 2819 2820 2821 2822 2823 2824 2825 2826 2827 2828 2829 2830 2831 2832 2833 2834 2835 2836
	if (!bind_list) {
		ret = cma_alloc_port(ps, id_priv, snum);
	} else {
		ret = cma_check_port(bind_list, id_priv, id_priv->reuseaddr);
		if (!ret)
			cma_bind_port(bind_list, id_priv);
	}
	return ret;
}

static int cma_bind_listen(struct rdma_id_private *id_priv)
{
	struct rdma_bind_list *bind_list = id_priv->bind_list;
	int ret = 0;

	mutex_lock(&lock);
	if (bind_list->owners.first->next)
		ret = cma_check_port(bind_list, id_priv, 0);
	mutex_unlock(&lock);
	return ret;
}

2837 2838
static enum rdma_port_space cma_select_inet_ps(
		struct rdma_id_private *id_priv)
2839 2840 2841
{
	switch (id_priv->id.ps) {
	case RDMA_PS_TCP:
2842
	case RDMA_PS_UDP:
2843
	case RDMA_PS_IPOIB:
2844
	case RDMA_PS_IB:
2845
		return id_priv->id.ps;
2846
	default:
2847 2848

		return 0;
2849 2850 2851
	}
}

2852
static enum rdma_port_space cma_select_ib_ps(struct rdma_id_private *id_priv)
2853
{
2854
	enum rdma_port_space ps = 0;
2855 2856 2857
	struct sockaddr_ib *sib;
	u64 sid_ps, mask, sid;

2858
	sib = (struct sockaddr_ib *) cma_src_addr(id_priv);
2859 2860 2861 2862 2863
	mask = be64_to_cpu(sib->sib_sid_mask) & RDMA_IB_IP_PS_MASK;
	sid = be64_to_cpu(sib->sib_sid) & mask;

	if ((id_priv->id.ps == RDMA_PS_IB) && (sid == (RDMA_IB_IP_PS_IB & mask))) {
		sid_ps = RDMA_IB_IP_PS_IB;
2864
		ps = RDMA_PS_IB;
2865 2866 2867
	} else if (((id_priv->id.ps == RDMA_PS_IB) || (id_priv->id.ps == RDMA_PS_TCP)) &&
		   (sid == (RDMA_IB_IP_PS_TCP & mask))) {
		sid_ps = RDMA_IB_IP_PS_TCP;
2868
		ps = RDMA_PS_TCP;
2869 2870 2871
	} else if (((id_priv->id.ps == RDMA_PS_IB) || (id_priv->id.ps == RDMA_PS_UDP)) &&
		   (sid == (RDMA_IB_IP_PS_UDP & mask))) {
		sid_ps = RDMA_IB_IP_PS_UDP;
2872
		ps = RDMA_PS_UDP;
2873 2874
	}

2875 2876 2877 2878 2879 2880 2881 2882 2883 2884
	if (ps) {
		sib->sib_sid = cpu_to_be64(sid_ps | ntohs(cma_port((struct sockaddr *) sib)));
		sib->sib_sid_mask = cpu_to_be64(RDMA_IB_IP_PS_MASK |
						be64_to_cpu(sib->sib_sid_mask));
	}
	return ps;
}

static int cma_get_port(struct rdma_id_private *id_priv)
{
2885
	enum rdma_port_space ps;
2886 2887
	int ret;

2888
	if (cma_family(id_priv) != AF_IB)
2889 2890 2891 2892 2893 2894
		ps = cma_select_inet_ps(id_priv);
	else
		ps = cma_select_ib_ps(id_priv);
	if (!ps)
		return -EPROTONOSUPPORT;

2895
	mutex_lock(&lock);
2896
	if (cma_any_port(cma_src_addr(id_priv)))
2897
		ret = cma_alloc_any_port(ps, id_priv);
2898 2899 2900 2901 2902 2903 2904
	else
		ret = cma_use_port(ps, id_priv);
	mutex_unlock(&lock);

	return ret;
}

2905 2906 2907
static int cma_check_linklocal(struct rdma_dev_addr *dev_addr,
			       struct sockaddr *addr)
{
2908
#if IS_ENABLED(CONFIG_IPV6)
2909 2910 2911 2912 2913 2914
	struct sockaddr_in6 *sin6;

	if (addr->sa_family != AF_INET6)
		return 0;

	sin6 = (struct sockaddr_in6 *) addr;
2915 2916 2917 2918 2919

	if (!(ipv6_addr_type(&sin6->sin6_addr) & IPV6_ADDR_LINKLOCAL))
		return 0;

	if (!sin6->sin6_scope_id)
2920 2921 2922 2923 2924 2925 2926
			return -EINVAL;

	dev_addr->bound_dev_if = sin6->sin6_scope_id;
#endif
	return 0;
}

2927 2928 2929 2930 2931 2932
int rdma_listen(struct rdma_cm_id *id, int backlog)
{
	struct rdma_id_private *id_priv;
	int ret;

	id_priv = container_of(id, struct rdma_id_private, id);
2933
	if (id_priv->state == RDMA_CM_IDLE) {
2934 2935
		id->route.addr.src_addr.ss_family = AF_INET;
		ret = rdma_bind_addr(id, cma_src_addr(id_priv));
2936 2937 2938 2939
		if (ret)
			return ret;
	}

2940
	if (!cma_comp_exch(id_priv, RDMA_CM_ADDR_BOUND, RDMA_CM_LISTEN))
2941 2942 2943 2944 2945 2946 2947 2948 2949 2950
		return -EINVAL;

	if (id_priv->reuseaddr) {
		ret = cma_bind_listen(id_priv);
		if (ret)
			goto err;
	}

	id_priv->backlog = backlog;
	if (id->device) {
2951
		if (rdma_cap_ib_cm(id->device, 1)) {
2952 2953 2954
			ret = cma_ib_listen(id_priv);
			if (ret)
				goto err;
2955
		} else if (rdma_cap_iw_cm(id->device, 1)) {
2956 2957 2958
			ret = cma_iw_listen(id_priv, backlog);
			if (ret)
				goto err;
2959
		} else {
2960 2961 2962 2963 2964 2965 2966 2967 2968
			ret = -ENOSYS;
			goto err;
		}
	} else
		cma_listen_on_all(id_priv);

	return 0;
err:
	id_priv->backlog = 0;
2969
	cma_comp_exch(id_priv, RDMA_CM_LISTEN, RDMA_CM_ADDR_BOUND);
2970 2971 2972 2973
	return ret;
}
EXPORT_SYMBOL(rdma_listen);

2974 2975 2976 2977 2978
int rdma_bind_addr(struct rdma_cm_id *id, struct sockaddr *addr)
{
	struct rdma_id_private *id_priv;
	int ret;

2979 2980
	if (addr->sa_family != AF_INET && addr->sa_family != AF_INET6 &&
	    addr->sa_family != AF_IB)
2981 2982 2983
		return -EAFNOSUPPORT;

	id_priv = container_of(id, struct rdma_id_private, id);
2984
	if (!cma_comp_exch(id_priv, RDMA_CM_IDLE, RDMA_CM_ADDR_BOUND))
2985 2986
		return -EINVAL;

2987 2988 2989 2990
	ret = cma_check_linklocal(&id->route.addr.dev_addr, addr);
	if (ret)
		goto err1;

2991
	memcpy(cma_src_addr(id_priv), addr, rdma_addr_size(addr));
2992
	if (!cma_any_addr(addr)) {
2993
		ret = cma_translate_addr(addr, &id->route.addr.dev_addr);
2994
		if (ret)
2995 2996
			goto err1;

2997
		ret = cma_acquire_dev(id_priv, NULL);
2998 2999
		if (ret)
			goto err1;
3000 3001
	}

3002 3003 3004
	if (!(id_priv->options & (1 << CMA_OPTION_AFONLY))) {
		if (addr->sa_family == AF_INET)
			id_priv->afonly = 1;
3005
#if IS_ENABLED(CONFIG_IPV6)
3006 3007 3008 3009 3010
		else if (addr->sa_family == AF_INET6) {
			struct net *net = id_priv->id.route.addr.dev_addr.net;

			id_priv->afonly = net->ipv6.sysctl.bindv6only;
		}
3011
#endif
3012
	}
3013 3014
	ret = cma_get_port(id_priv);
	if (ret)
3015
		goto err2;
3016 3017

	return 0;
3018
err2:
3019 3020
	if (id_priv->cma_dev)
		cma_release_dev(id_priv);
3021
err1:
3022
	cma_comp_exch(id_priv, RDMA_CM_ADDR_BOUND, RDMA_CM_IDLE);
3023 3024 3025 3026
	return ret;
}
EXPORT_SYMBOL(rdma_bind_addr);

3027
static int cma_format_hdr(void *hdr, struct rdma_id_private *id_priv)
3028 3029 3030
{
	struct cma_hdr *cma_hdr;

3031 3032
	cma_hdr = hdr;
	cma_hdr->cma_version = CMA_VERSION;
3033
	if (cma_family(id_priv) == AF_INET) {
Aleksey Senin's avatar
Aleksey Senin committed
3034 3035
		struct sockaddr_in *src4, *dst4;

3036 3037
		src4 = (struct sockaddr_in *) cma_src_addr(id_priv);
		dst4 = (struct sockaddr_in *) cma_dst_addr(id_priv);
Aleksey Senin's avatar
Aleksey Senin committed
3038

3039 3040 3041 3042
		cma_set_ip_ver(cma_hdr, 4);
		cma_hdr->src_addr.ip4.addr = src4->sin_addr.s_addr;
		cma_hdr->dst_addr.ip4.addr = dst4->sin_addr.s_addr;
		cma_hdr->port = src4->sin_port;
3043
	} else if (cma_family(id_priv) == AF_INET6) {
Aleksey Senin's avatar
Aleksey Senin committed
3044 3045
		struct sockaddr_in6 *src6, *dst6;

3046 3047
		src6 = (struct sockaddr_in6 *) cma_src_addr(id_priv);
		dst6 = (struct sockaddr_in6 *) cma_dst_addr(id_priv);
Aleksey Senin's avatar
Aleksey Senin committed
3048

3049 3050 3051 3052
		cma_set_ip_ver(cma_hdr, 6);
		cma_hdr->src_addr.ip6 = src6->sin6_addr;
		cma_hdr->dst_addr.ip6 = dst6->sin6_addr;
		cma_hdr->port = src6->sin6_port;
3053 3054 3055 3056
	}
	return 0;
}

3057 3058 3059 3060 3061 3062 3063 3064
static int cma_sidr_rep_handler(struct ib_cm_id *cm_id,
				struct ib_cm_event *ib_event)
{
	struct rdma_id_private *id_priv = cm_id->context;
	struct rdma_cm_event event;
	struct ib_cm_sidr_rep_event_param *rep = &ib_event->param.sidr_rep_rcvd;
	int ret = 0;

3065
	if (cma_disable_callback(id_priv, RDMA_CM_CONNECT))
3066
		return 0;
3067

3068
	memset(&event, 0, sizeof event);
3069 3070 3071 3072 3073 3074 3075 3076 3077 3078 3079 3080 3081
	switch (ib_event->event) {
	case IB_CM_SIDR_REQ_ERROR:
		event.event = RDMA_CM_EVENT_UNREACHABLE;
		event.status = -ETIMEDOUT;
		break;
	case IB_CM_SIDR_REP_RECEIVED:
		event.param.ud.private_data = ib_event->private_data;
		event.param.ud.private_data_len = IB_CM_SIDR_REP_PRIVATE_DATA_SIZE;
		if (rep->status != IB_SIDR_SUCCESS) {
			event.event = RDMA_CM_EVENT_UNREACHABLE;
			event.status = ib_event->param.sidr_rep_rcvd.status;
			break;
		}
Sean Hefty's avatar
Sean Hefty committed
3082
		ret = cma_set_qkey(id_priv, rep->qkey);
3083 3084
		if (ret) {
			event.event = RDMA_CM_EVENT_ADDR_ERROR;
Sean Hefty's avatar
Sean Hefty committed
3085
			event.status = ret;
3086 3087 3088 3089 3090 3091 3092 3093 3094 3095 3096
			break;
		}
		ib_init_ah_from_path(id_priv->id.device, id_priv->id.port_num,
				     id_priv->id.route.path_rec,
				     &event.param.ud.ah_attr);
		event.param.ud.qp_num = rep->qpn;
		event.param.ud.qkey = rep->qkey;
		event.event = RDMA_CM_EVENT_ESTABLISHED;
		event.status = 0;
		break;
	default:
3097
		printk(KERN_ERR "RDMA CMA: unexpected IB CM event: %d\n",
3098 3099 3100 3101 3102 3103 3104 3105
		       ib_event->event);
		goto out;
	}

	ret = id_priv->id.event_handler(&id_priv->id, &event);
	if (ret) {
		/* Destroy the CM ID by returning a non-zero value. */
		id_priv->cm_id.ib = NULL;
3106
		cma_exch(id_priv, RDMA_CM_DESTROYING);
3107
		mutex_unlock(&id_priv->handler_mutex);
3108 3109 3110 3111
		rdma_destroy_id(&id_priv->id);
		return ret;
	}
out:
3112
	mutex_unlock(&id_priv->handler_mutex);
3113 3114 3115 3116 3117 3118 3119
	return ret;
}

static int cma_resolve_ib_udp(struct rdma_id_private *id_priv,
			      struct rdma_conn_param *conn_param)
{
	struct ib_cm_sidr_req_param req;
3120
	struct ib_cm_id	*id;
3121
	void *private_data;
3122 3123
	u8 offset;
	int ret;
3124

3125
	memset(&req, 0, sizeof req);
3126 3127
	offset = cma_user_data_offset(id_priv);
	req.private_data_len = offset + conn_param->private_data_len;
3128 3129 3130
	if (req.private_data_len < conn_param->private_data_len)
		return -EINVAL;

3131
	if (req.private_data_len) {
3132 3133
		private_data = kzalloc(req.private_data_len, GFP_ATOMIC);
		if (!private_data)
3134 3135
			return -ENOMEM;
	} else {
3136
		private_data = NULL;
3137
	}
3138 3139

	if (conn_param->private_data && conn_param->private_data_len)
3140 3141
		memcpy(private_data + offset, conn_param->private_data,
		       conn_param->private_data_len);
3142

3143 3144
	if (private_data) {
		ret = cma_format_hdr(private_data, id_priv);
3145 3146
		if (ret)
			goto out;
3147
		req.private_data = private_data;
3148
	}
3149

3150 3151 3152 3153
	id = ib_create_cm_id(id_priv->id.device, cma_sidr_rep_handler,
			     id_priv);
	if (IS_ERR(id)) {
		ret = PTR_ERR(id);
3154 3155
		goto out;
	}
3156
	id_priv->cm_id.ib = id;
3157

3158
	req.path = id_priv->id.route.path_rec;
3159
	req.service_id = rdma_get_service_id(&id_priv->id, cma_dst_addr(id_priv));
3160 3161 3162 3163 3164 3165 3166 3167 3168
	req.timeout_ms = 1 << (CMA_CM_RESPONSE_TIMEOUT - 8);
	req.max_cm_retries = CMA_MAX_CM_RETRIES;

	ret = ib_send_cm_sidr_req(id_priv->cm_id.ib, &req);
	if (ret) {
		ib_destroy_cm_id(id_priv->cm_id.ib);
		id_priv->cm_id.ib = NULL;
	}
out:
3169
	kfree(private_data);
3170 3171 3172
	return ret;
}

3173 3174 3175 3176 3177 3178
static int cma_connect_ib(struct rdma_id_private *id_priv,
			  struct rdma_conn_param *conn_param)
{
	struct ib_cm_req_param req;
	struct rdma_route *route;
	void *private_data;
3179
	struct ib_cm_id	*id;
3180 3181
	u8 offset;
	int ret;
3182 3183

	memset(&req, 0, sizeof req);
3184
	offset = cma_user_data_offset(id_priv);
3185
	req.private_data_len = offset + conn_param->private_data_len;
3186 3187 3188
	if (req.private_data_len < conn_param->private_data_len)
		return -EINVAL;

3189 3190 3191 3192 3193 3194 3195
	if (req.private_data_len) {
		private_data = kzalloc(req.private_data_len, GFP_ATOMIC);
		if (!private_data)
			return -ENOMEM;
	} else {
		private_data = NULL;
	}
3196 3197 3198 3199 3200

	if (conn_param->private_data && conn_param->private_data_len)
		memcpy(private_data + offset, conn_param->private_data,
		       conn_param->private_data_len);

3201 3202 3203
	id = ib_create_cm_id(id_priv->id.device, cma_ib_handler, id_priv);
	if (IS_ERR(id)) {
		ret = PTR_ERR(id);
3204 3205
		goto out;
	}
3206
	id_priv->cm_id.ib = id;
3207 3208

	route = &id_priv->id.route;
3209 3210 3211 3212 3213 3214
	if (private_data) {
		ret = cma_format_hdr(private_data, id_priv);
		if (ret)
			goto out;
		req.private_data = private_data;
	}
3215 3216 3217 3218 3219

	req.primary_path = &route->path_rec[0];
	if (route->num_paths == 2)
		req.alternate_path = &route->path_rec[1];

3220
	req.service_id = rdma_get_service_id(&id_priv->id, cma_dst_addr(id_priv));
3221
	req.qp_num = id_priv->qp_num;
Sean Hefty's avatar
Sean Hefty committed
3222
	req.qp_type = id_priv->id.qp_type;
3223 3224 3225 3226
	req.starting_psn = id_priv->seq_num;
	req.responder_resources = conn_param->responder_resources;
	req.initiator_depth = conn_param->initiator_depth;
	req.flow_control = conn_param->flow_control;
3227 3228
	req.retry_count = min_t(u8, 7, conn_param->retry_count);
	req.rnr_retry_count = min_t(u8, 7, conn_param->rnr_retry_count);
3229 3230 3231 3232 3233 3234 3235
	req.remote_cm_response_timeout = CMA_CM_RESPONSE_TIMEOUT;
	req.local_cm_response_timeout = CMA_CM_RESPONSE_TIMEOUT;
	req.max_cm_retries = CMA_MAX_CM_RETRIES;
	req.srq = id_priv->srq ? 1 : 0;

	ret = ib_send_cm_req(id_priv->cm_id.ib, &req);
out:
3236 3237
	if (ret && !IS_ERR(id)) {
		ib_destroy_cm_id(id);
3238 3239 3240
		id_priv->cm_id.ib = NULL;
	}

3241 3242 3243 3244
	kfree(private_data);
	return ret;
}

Tom Tucker's avatar
Tom Tucker committed
3245 3246 3247 3248 3249 3250 3251 3252
static int cma_connect_iw(struct rdma_id_private *id_priv,
			  struct rdma_conn_param *conn_param)
{
	struct iw_cm_id *cm_id;
	int ret;
	struct iw_cm_conn_param iw_param;

	cm_id = iw_create_cm_id(id_priv->id.device, cma_iw_handler, id_priv);
3253 3254
	if (IS_ERR(cm_id))
		return PTR_ERR(cm_id);
Tom Tucker's avatar
Tom Tucker committed
3255

3256
	cm_id->tos = id_priv->tos;
Tom Tucker's avatar
Tom Tucker committed
3257 3258
	id_priv->cm_id.iw = cm_id;

3259 3260 3261 3262
	memcpy(&cm_id->local_addr, cma_src_addr(id_priv),
	       rdma_addr_size(cma_src_addr(id_priv)));
	memcpy(&cm_id->remote_addr, cma_dst_addr(id_priv),
	       rdma_addr_size(cma_dst_addr(id_priv)));
Tom Tucker's avatar
Tom Tucker committed
3263

3264
	ret = cma_modify_qp_rtr(id_priv, conn_param);
3265 3266
	if (ret)
		goto out;
Tom Tucker's avatar
Tom Tucker committed
3267

3268 3269 3270 3271 3272 3273 3274 3275
	if (conn_param) {
		iw_param.ord = conn_param->initiator_depth;
		iw_param.ird = conn_param->responder_resources;
		iw_param.private_data = conn_param->private_data;
		iw_param.private_data_len = conn_param->private_data_len;
		iw_param.qpn = id_priv->id.qp ? id_priv->qp_num : conn_param->qp_num;
	} else {
		memset(&iw_param, 0, sizeof iw_param);
Tom Tucker's avatar
Tom Tucker committed
3276
		iw_param.qpn = id_priv->qp_num;
3277
	}
Tom Tucker's avatar
Tom Tucker committed
3278 3279
	ret = iw_cm_connect(cm_id, &iw_param);
out:
3280
	if (ret) {
3281 3282 3283
		iw_destroy_cm_id(cm_id);
		id_priv->cm_id.iw = NULL;
	}
Tom Tucker's avatar
Tom Tucker committed
3284 3285 3286
	return ret;
}

3287 3288 3289 3290 3291 3292
int rdma_connect(struct rdma_cm_id *id, struct rdma_conn_param *conn_param)
{
	struct rdma_id_private *id_priv;
	int ret;

	id_priv = container_of(id, struct rdma_id_private, id);
3293
	if (!cma_comp_exch(id_priv, RDMA_CM_ROUTE_RESOLVED, RDMA_CM_CONNECT))
3294 3295 3296 3297 3298 3299 3300
		return -EINVAL;

	if (!id->qp) {
		id_priv->qp_num = conn_param->qp_num;
		id_priv->srq = conn_param->srq;
	}

3301
	if (rdma_cap_ib_cm(id->device, id->port_num)) {
3302
		if (id->qp_type == IB_QPT_UD)
3303 3304 3305
			ret = cma_resolve_ib_udp(id_priv, conn_param);
		else
			ret = cma_connect_ib(id_priv, conn_param);
3306
	} else if (rdma_cap_iw_cm(id->device, id->port_num))
Tom Tucker's avatar
Tom Tucker committed
3307
		ret = cma_connect_iw(id_priv, conn_param);
3308
	else
3309 3310 3311 3312 3313 3314
		ret = -ENOSYS;
	if (ret)
		goto err;

	return 0;
err:
3315
	cma_comp_exch(id_priv, RDMA_CM_CONNECT, RDMA_CM_ROUTE_RESOLVED);
3316 3317 3318 3319 3320 3321 3322 3323
	return ret;
}
EXPORT_SYMBOL(rdma_connect);

static int cma_accept_ib(struct rdma_id_private *id_priv,
			 struct rdma_conn_param *conn_param)
{
	struct ib_cm_rep_param rep;
3324
	int ret;
3325

3326 3327 3328
	ret = cma_modify_qp_rtr(id_priv, conn_param);
	if (ret)
		goto out;
3329

3330 3331 3332
	ret = cma_modify_qp_rts(id_priv, conn_param);
	if (ret)
		goto out;
3333 3334 3335 3336 3337 3338 3339 3340 3341 3342

	memset(&rep, 0, sizeof rep);
	rep.qp_num = id_priv->qp_num;
	rep.starting_psn = id_priv->seq_num;
	rep.private_data = conn_param->private_data;
	rep.private_data_len = conn_param->private_data_len;
	rep.responder_resources = conn_param->responder_resources;
	rep.initiator_depth = conn_param->initiator_depth;
	rep.failover_accepted = 0;
	rep.flow_control = conn_param->flow_control;
3343
	rep.rnr_retry_count = min_t(u8, 7, conn_param->rnr_retry_count);
3344 3345
	rep.srq = id_priv->srq ? 1 : 0;

3346 3347 3348
	ret = ib_send_cm_rep(id_priv->cm_id.ib, &rep);
out:
	return ret;
3349 3350
}

Tom Tucker's avatar
Tom Tucker committed
3351 3352 3353 3354 3355 3356
static int cma_accept_iw(struct rdma_id_private *id_priv,
		  struct rdma_conn_param *conn_param)
{
	struct iw_cm_conn_param iw_param;
	int ret;

3357 3358 3359
	if (!conn_param)
		return -EINVAL;

3360
	ret = cma_modify_qp_rtr(id_priv, conn_param);
Tom Tucker's avatar
Tom Tucker committed
3361 3362 3363 3364 3365 3366 3367 3368 3369 3370 3371 3372 3373 3374 3375
	if (ret)
		return ret;

	iw_param.ord = conn_param->initiator_depth;
	iw_param.ird = conn_param->responder_resources;
	iw_param.private_data = conn_param->private_data;
	iw_param.private_data_len = conn_param->private_data_len;
	if (id_priv->id.qp) {
		iw_param.qpn = id_priv->qp_num;
	} else
		iw_param.qpn = conn_param->qp_num;

	return iw_cm_accept(id_priv->cm_id.iw, &iw_param);
}

3376
static int cma_send_sidr_rep(struct rdma_id_private *id_priv,
Sean Hefty's avatar
Sean Hefty committed
3377
			     enum ib_cm_sidr_status status, u32 qkey,
3378 3379 3380
			     const void *private_data, int private_data_len)
{
	struct ib_cm_sidr_rep_param rep;
3381
	int ret;
3382 3383 3384 3385

	memset(&rep, 0, sizeof rep);
	rep.status = status;
	if (status == IB_SIDR_SUCCESS) {
Sean Hefty's avatar
Sean Hefty committed
3386
		ret = cma_set_qkey(id_priv, qkey);
3387 3388
		if (ret)
			return ret;
3389
		rep.qp_num = id_priv->qp_num;
3390
		rep.qkey = id_priv->qkey;
3391 3392 3393 3394 3395 3396 3397
	}
	rep.private_data = private_data;
	rep.private_data_len = private_data_len;

	return ib_send_cm_sidr_rep(id_priv->cm_id.ib, &rep);
}

3398 3399 3400 3401 3402 3403
int rdma_accept(struct rdma_cm_id *id, struct rdma_conn_param *conn_param)
{
	struct rdma_id_private *id_priv;
	int ret;

	id_priv = container_of(id, struct rdma_id_private, id);
3404 3405 3406

	id_priv->owner = task_pid_nr(current);

3407
	if (!cma_comp(id_priv, RDMA_CM_CONNECT))
3408 3409 3410 3411 3412 3413 3414
		return -EINVAL;

	if (!id->qp && conn_param) {
		id_priv->qp_num = conn_param->qp_num;
		id_priv->srq = conn_param->srq;
	}

3415
	if (rdma_cap_ib_cm(id->device, id->port_num)) {
3416 3417 3418
		if (id->qp_type == IB_QPT_UD) {
			if (conn_param)
				ret = cma_send_sidr_rep(id_priv, IB_SIDR_SUCCESS,
Sean Hefty's avatar
Sean Hefty committed
3419
							conn_param->qkey,
3420 3421 3422 3423
							conn_param->private_data,
							conn_param->private_data_len);
			else
				ret = cma_send_sidr_rep(id_priv, IB_SIDR_SUCCESS,
Sean Hefty's avatar
Sean Hefty committed
3424
							0, NULL, 0);
3425 3426 3427 3428 3429 3430
		} else {
			if (conn_param)
				ret = cma_accept_ib(id_priv, conn_param);
			else
				ret = cma_rep_recv(id_priv);
		}
3431
	} else if (rdma_cap_iw_cm(id->device, id->port_num))
Tom Tucker's avatar
Tom Tucker committed
3432
		ret = cma_accept_iw(id_priv, conn_param);
3433
	else
3434 3435 3436 3437 3438 3439 3440
		ret = -ENOSYS;

	if (ret)
		goto reject;

	return 0;
reject:
3441
	cma_modify_qp_err(id_priv);
3442 3443 3444 3445 3446
	rdma_reject(id, NULL, 0);
	return ret;
}
EXPORT_SYMBOL(rdma_accept);

3447 3448 3449 3450 3451 3452
int rdma_notify(struct rdma_cm_id *id, enum ib_event_type event)
{
	struct rdma_id_private *id_priv;
	int ret;

	id_priv = container_of(id, struct rdma_id_private, id);
3453
	if (!id_priv->cm_id.ib)
3454 3455 3456 3457 3458 3459 3460 3461 3462 3463 3464 3465 3466 3467
		return -EINVAL;

	switch (id->device->node_type) {
	case RDMA_NODE_IB_CA:
		ret = ib_cm_notify(id_priv->cm_id.ib, event);
		break;
	default:
		ret = 0;
		break;
	}
	return ret;
}
EXPORT_SYMBOL(rdma_notify);

3468 3469 3470 3471 3472 3473 3474
int rdma_reject(struct rdma_cm_id *id, const void *private_data,
		u8 private_data_len)
{
	struct rdma_id_private *id_priv;
	int ret;

	id_priv = container_of(id, struct rdma_id_private, id);
3475
	if (!id_priv->cm_id.ib)
3476 3477
		return -EINVAL;

3478
	if (rdma_cap_ib_cm(id->device, id->port_num)) {
3479
		if (id->qp_type == IB_QPT_UD)
Sean Hefty's avatar
Sean Hefty committed
3480
			ret = cma_send_sidr_rep(id_priv, IB_SIDR_REJECT, 0,
3481 3482 3483 3484 3485
						private_data, private_data_len);
		else
			ret = ib_send_cm_rej(id_priv->cm_id.ib,
					     IB_CM_REJ_CONSUMER_DEFINED, NULL,
					     0, private_data, private_data_len);
3486
	} else if (rdma_cap_iw_cm(id->device, id->port_num)) {
Tom Tucker's avatar
Tom Tucker committed
3487 3488
		ret = iw_cm_reject(id_priv->cm_id.iw,
				   private_data, private_data_len);
3489
	} else
3490
		ret = -ENOSYS;
3491

3492 3493 3494 3495 3496 3497 3498 3499 3500 3501
	return ret;
}
EXPORT_SYMBOL(rdma_reject);

int rdma_disconnect(struct rdma_cm_id *id)
{
	struct rdma_id_private *id_priv;
	int ret;

	id_priv = container_of(id, struct rdma_id_private, id);
3502
	if (!id_priv->cm_id.ib)
3503 3504
		return -EINVAL;

3505
	if (rdma_cap_ib_cm(id->device, id->port_num)) {
3506
		ret = cma_modify_qp_err(id_priv);
Tom Tucker's avatar
Tom Tucker committed
3507 3508
		if (ret)
			goto out;
3509 3510 3511
		/* Initiate or respond to a disconnect. */
		if (ib_send_cm_dreq(id_priv->cm_id.ib, NULL, 0))
			ib_send_cm_drep(id_priv->cm_id.ib, NULL, 0);
3512
	} else if (rdma_cap_iw_cm(id->device, id->port_num)) {
Tom Tucker's avatar
Tom Tucker committed
3513
		ret = iw_cm_disconnect(id_priv->cm_id.iw, 0);
3514
	} else
Tom Tucker's avatar
Tom Tucker committed
3515
		ret = -EINVAL;
3516

3517 3518 3519 3520 3521
out:
	return ret;
}
EXPORT_SYMBOL(rdma_disconnect);

3522 3523 3524 3525 3526 3527 3528 3529
static int cma_ib_mc_handler(int status, struct ib_sa_multicast *multicast)
{
	struct rdma_id_private *id_priv;
	struct cma_multicast *mc = multicast->context;
	struct rdma_cm_event event;
	int ret;

	id_priv = mc->id_priv;
3530 3531
	if (cma_disable_callback(id_priv, RDMA_CM_ADDR_BOUND) &&
	    cma_disable_callback(id_priv, RDMA_CM_ADDR_RESOLVED))
3532
		return 0;
3533

Sean Hefty's avatar
Sean Hefty committed
3534 3535
	if (!status)
		status = cma_set_qkey(id_priv, be32_to_cpu(multicast->rec.qkey));
3536
	mutex_lock(&id_priv->qp_mutex);
3537 3538
	if (!status && id_priv->id.qp)
		status = ib_attach_mcast(id_priv->id.qp, &multicast->rec.mgid,
Sean Hefty's avatar
Sean Hefty committed
3539
					 be16_to_cpu(multicast->rec.mlid));
3540
	mutex_unlock(&id_priv->qp_mutex);
3541 3542 3543 3544 3545 3546 3547 3548 3549 3550 3551 3552 3553 3554 3555 3556

	memset(&event, 0, sizeof event);
	event.status = status;
	event.param.ud.private_data = mc->context;
	if (!status) {
		event.event = RDMA_CM_EVENT_MULTICAST_JOIN;
		ib_init_ah_from_mcmember(id_priv->id.device,
					 id_priv->id.port_num, &multicast->rec,
					 &event.param.ud.ah_attr);
		event.param.ud.qp_num = 0xFFFFFF;
		event.param.ud.qkey = be32_to_cpu(multicast->rec.qkey);
	} else
		event.event = RDMA_CM_EVENT_MULTICAST_ERROR;

	ret = id_priv->id.event_handler(&id_priv->id, &event);
	if (ret) {
3557
		cma_exch(id_priv, RDMA_CM_DESTROYING);
3558
		mutex_unlock(&id_priv->handler_mutex);
3559 3560 3561
		rdma_destroy_id(&id_priv->id);
		return 0;
	}
3562

3563
	mutex_unlock(&id_priv->handler_mutex);
3564 3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577
	return 0;
}

static void cma_set_mgid(struct rdma_id_private *id_priv,
			 struct sockaddr *addr, union ib_gid *mgid)
{
	unsigned char mc_map[MAX_ADDR_LEN];
	struct rdma_dev_addr *dev_addr = &id_priv->id.route.addr.dev_addr;
	struct sockaddr_in *sin = (struct sockaddr_in *) addr;
	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) addr;

	if (cma_any_addr(addr)) {
		memset(mgid, 0, sizeof *mgid);
	} else if ((addr->sa_family == AF_INET6) &&
3578
		   ((be32_to_cpu(sin6->sin6_addr.s6_addr32[0]) & 0xFFF0FFFF) ==
3579 3580 3581
								 0xFF10A01B)) {
		/* IPv6 address is an SA assigned MGID. */
		memcpy(mgid, &sin6->sin6_addr, sizeof *mgid);
3582 3583
	} else if (addr->sa_family == AF_IB) {
		memcpy(mgid, &((struct sockaddr_ib *) addr)->sib_addr, sizeof *mgid);
3584 3585 3586 3587 3588
	} else if ((addr->sa_family == AF_INET6)) {
		ipv6_ib_mc_map(&sin6->sin6_addr, dev_addr->broadcast, mc_map);
		if (id_priv->id.ps == RDMA_PS_UDP)
			mc_map[7] = 0x01;	/* Use RDMA CM signature */
		*mgid = *(union ib_gid *) (mc_map + 4);
3589
	} else {
3590
		ip_ib_mc_map(sin->sin_addr.s_addr, dev_addr->broadcast, mc_map);
3591 3592 3593 3594 3595 3596 3597 3598 3599 3600 3601 3602 3603 3604 3605 3606 3607 3608 3609 3610
		if (id_priv->id.ps == RDMA_PS_UDP)
			mc_map[7] = 0x01;	/* Use RDMA CM signature */
		*mgid = *(union ib_gid *) (mc_map + 4);
	}
}

static int cma_join_ib_multicast(struct rdma_id_private *id_priv,
				 struct cma_multicast *mc)
{
	struct ib_sa_mcmember_rec rec;
	struct rdma_dev_addr *dev_addr = &id_priv->id.route.addr.dev_addr;
	ib_sa_comp_mask comp_mask;
	int ret;

	ib_addr_get_mgid(dev_addr, &rec.mgid);
	ret = ib_sa_get_mcmember_rec(id_priv->id.device, id_priv->id.port_num,
				     &rec.mgid, &rec);
	if (ret)
		return ret;

3611 3612 3613 3614
	ret = cma_set_qkey(id_priv, 0);
	if (ret)
		return ret;

3615
	cma_set_mgid(id_priv, (struct sockaddr *) &mc->addr, &rec.mgid);
3616
	rec.qkey = cpu_to_be32(id_priv->qkey);
3617
	rdma_addr_get_sgid(dev_addr, &rec.port_gid);
3618 3619 3620 3621 3622 3623 3624 3625 3626
	rec.pkey = cpu_to_be16(ib_addr_get_pkey(dev_addr));
	rec.join_state = 1;

	comp_mask = IB_SA_MCMEMBER_REC_MGID | IB_SA_MCMEMBER_REC_PORT_GID |
		    IB_SA_MCMEMBER_REC_PKEY | IB_SA_MCMEMBER_REC_JOIN_STATE |
		    IB_SA_MCMEMBER_REC_QKEY | IB_SA_MCMEMBER_REC_SL |
		    IB_SA_MCMEMBER_REC_FLOW_LABEL |
		    IB_SA_MCMEMBER_REC_TRAFFIC_CLASS;

3627 3628
	if (id_priv->id.ps == RDMA_PS_IPOIB)
		comp_mask |= IB_SA_MCMEMBER_REC_RATE |
3629 3630 3631 3632
			     IB_SA_MCMEMBER_REC_RATE_SELECTOR |
			     IB_SA_MCMEMBER_REC_MTU_SELECTOR |
			     IB_SA_MCMEMBER_REC_MTU |
			     IB_SA_MCMEMBER_REC_HOP_LIMIT;
3633

3634 3635 3636 3637
	mc->multicast.ib = ib_sa_join_multicast(&sa_client, id_priv->id.device,
						id_priv->id.port_num, &rec,
						comp_mask, GFP_KERNEL,
						cma_ib_mc_handler, mc);
3638
	return PTR_ERR_OR_ZERO(mc->multicast.ib);
3639 3640
}

3641 3642 3643 3644 3645 3646 3647 3648 3649 3650 3651 3652 3653 3654 3655 3656 3657 3658 3659 3660 3661 3662 3663 3664 3665 3666 3667 3668 3669 3670 3671 3672 3673 3674 3675 3676 3677 3678 3679 3680 3681 3682 3683 3684 3685 3686 3687 3688 3689 3690 3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705 3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720
static void iboe_mcast_work_handler(struct work_struct *work)
{
	struct iboe_mcast_work *mw = container_of(work, struct iboe_mcast_work, work);
	struct cma_multicast *mc = mw->mc;
	struct ib_sa_multicast *m = mc->multicast.ib;

	mc->multicast.ib->context = mc;
	cma_ib_mc_handler(0, m);
	kref_put(&mc->mcref, release_mc);
	kfree(mw);
}

static void cma_iboe_set_mgid(struct sockaddr *addr, union ib_gid *mgid)
{
	struct sockaddr_in *sin = (struct sockaddr_in *)addr;
	struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)addr;

	if (cma_any_addr(addr)) {
		memset(mgid, 0, sizeof *mgid);
	} else if (addr->sa_family == AF_INET6) {
		memcpy(mgid, &sin6->sin6_addr, sizeof *mgid);
	} else {
		mgid->raw[0] = 0xff;
		mgid->raw[1] = 0x0e;
		mgid->raw[2] = 0;
		mgid->raw[3] = 0;
		mgid->raw[4] = 0;
		mgid->raw[5] = 0;
		mgid->raw[6] = 0;
		mgid->raw[7] = 0;
		mgid->raw[8] = 0;
		mgid->raw[9] = 0;
		mgid->raw[10] = 0xff;
		mgid->raw[11] = 0xff;
		*(__be32 *)(&mgid->raw[12]) = sin->sin_addr.s_addr;
	}
}

static int cma_iboe_join_multicast(struct rdma_id_private *id_priv,
				   struct cma_multicast *mc)
{
	struct iboe_mcast_work *work;
	struct rdma_dev_addr *dev_addr = &id_priv->id.route.addr.dev_addr;
	int err;
	struct sockaddr *addr = (struct sockaddr *)&mc->addr;
	struct net_device *ndev = NULL;

	if (cma_zero_addr((struct sockaddr *)&mc->addr))
		return -EINVAL;

	work = kzalloc(sizeof *work, GFP_KERNEL);
	if (!work)
		return -ENOMEM;

	mc->multicast.ib = kzalloc(sizeof(struct ib_sa_multicast), GFP_KERNEL);
	if (!mc->multicast.ib) {
		err = -ENOMEM;
		goto out1;
	}

	cma_iboe_set_mgid(addr, &mc->multicast.ib->rec.mgid);

	mc->multicast.ib->rec.pkey = cpu_to_be16(0xffff);
	if (id_priv->id.ps == RDMA_PS_UDP)
		mc->multicast.ib->rec.qkey = cpu_to_be32(RDMA_UDP_QKEY);

	if (dev_addr->bound_dev_if)
		ndev = dev_get_by_index(&init_net, dev_addr->bound_dev_if);
	if (!ndev) {
		err = -ENODEV;
		goto out2;
	}
	mc->multicast.ib->rec.rate = iboe_get_rate(ndev);
	mc->multicast.ib->rec.hop_limit = 1;
	mc->multicast.ib->rec.mtu = iboe_get_mtu(ndev->mtu);
	dev_put(ndev);
	if (!mc->multicast.ib->rec.mtu) {
		err = -EINVAL;
		goto out2;
	}
3721 3722
	rdma_ip2gid((struct sockaddr *)&id_priv->id.route.addr.src_addr,
		    &mc->multicast.ib->rec.port_gid);
3723 3724 3725 3726 3727 3728 3729 3730 3731 3732 3733 3734 3735 3736 3737
	work->id = id_priv;
	work->mc = mc;
	INIT_WORK(&work->work, iboe_mcast_work_handler);
	kref_get(&mc->mcref);
	queue_work(cma_wq, &work->work);

	return 0;

out2:
	kfree(mc->multicast.ib);
out1:
	kfree(work);
	return err;
}

3738 3739 3740 3741 3742 3743 3744 3745
int rdma_join_multicast(struct rdma_cm_id *id, struct sockaddr *addr,
			void *context)
{
	struct rdma_id_private *id_priv;
	struct cma_multicast *mc;
	int ret;

	id_priv = container_of(id, struct rdma_id_private, id);
3746 3747
	if (!cma_comp(id_priv, RDMA_CM_ADDR_BOUND) &&
	    !cma_comp(id_priv, RDMA_CM_ADDR_RESOLVED))
3748 3749 3750 3751 3752 3753
		return -EINVAL;

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

3754
	memcpy(&mc->addr, addr, rdma_addr_size(addr));
3755 3756 3757 3758 3759 3760 3761
	mc->context = context;
	mc->id_priv = id_priv;

	spin_lock(&id_priv->lock);
	list_add(&mc->list, &id_priv->mc_list);
	spin_unlock(&id_priv->lock);

3762
	if (rdma_protocol_roce(id->device, id->port_num)) {
3763 3764
		kref_init(&mc->mcref);
		ret = cma_iboe_join_multicast(id_priv, mc);
3765
	} else if (rdma_cap_ib_mcast(id->device, id->port_num))
3766 3767
		ret = cma_join_ib_multicast(id_priv, mc);
	else
3768 3769 3770 3771 3772 3773 3774 3775 3776 3777 3778 3779 3780 3781 3782 3783 3784 3785 3786 3787
		ret = -ENOSYS;

	if (ret) {
		spin_lock_irq(&id_priv->lock);
		list_del(&mc->list);
		spin_unlock_irq(&id_priv->lock);
		kfree(mc);
	}
	return ret;
}
EXPORT_SYMBOL(rdma_join_multicast);

void rdma_leave_multicast(struct rdma_cm_id *id, struct sockaddr *addr)
{
	struct rdma_id_private *id_priv;
	struct cma_multicast *mc;

	id_priv = container_of(id, struct rdma_id_private, id);
	spin_lock_irq(&id_priv->lock);
	list_for_each_entry(mc, &id_priv->mc_list, list) {
3788
		if (!memcmp(&mc->addr, addr, rdma_addr_size(addr))) {
3789 3790 3791 3792 3793 3794
			list_del(&mc->list);
			spin_unlock_irq(&id_priv->lock);

			if (id->qp)
				ib_detach_mcast(id->qp,
						&mc->multicast.ib->rec.mgid,
Sean Hefty's avatar
Sean Hefty committed
3795
						be16_to_cpu(mc->multicast.ib->rec.mlid));
3796 3797 3798

			BUG_ON(id_priv->cma_dev->device != id->device);

3799
			if (rdma_cap_ib_mcast(id->device, id->port_num)) {
3800 3801
				ib_sa_free_multicast(mc->multicast.ib);
				kfree(mc);
3802
			} else if (rdma_protocol_roce(id->device, id->port_num))
3803 3804
				kref_put(&mc->mcref, release_mc);

3805 3806 3807 3808 3809 3810 3811
			return;
		}
	}
	spin_unlock_irq(&id_priv->lock);
}
EXPORT_SYMBOL(rdma_leave_multicast);

3812 3813 3814 3815 3816 3817 3818
static int cma_netdev_change(struct net_device *ndev, struct rdma_id_private *id_priv)
{
	struct rdma_dev_addr *dev_addr;
	struct cma_ndev_work *work;

	dev_addr = &id_priv->id.route.addr.dev_addr;

3819
	if ((dev_addr->bound_dev_if == ndev->ifindex) &&
3820
	    (net_eq(dev_net(ndev), dev_addr->net)) &&
3821 3822 3823 3824 3825 3826 3827 3828 3829 3830 3831 3832 3833 3834 3835 3836 3837 3838
	    memcmp(dev_addr->src_dev_addr, ndev->dev_addr, ndev->addr_len)) {
		printk(KERN_INFO "RDMA CM addr change for ndev %s used by id %p\n",
		       ndev->name, &id_priv->id);
		work = kzalloc(sizeof *work, GFP_KERNEL);
		if (!work)
			return -ENOMEM;

		INIT_WORK(&work->work, cma_ndev_work_handler);
		work->id = id_priv;
		work->event.event = RDMA_CM_EVENT_ADDR_CHANGE;
		atomic_inc(&id_priv->refcount);
		queue_work(cma_wq, &work->work);
	}

	return 0;
}

static int cma_netdev_callback(struct notifier_block *self, unsigned long event,
3839
			       void *ptr)
3840
{
3841
	struct net_device *ndev = netdev_notifier_info_to_dev(ptr);
3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859 3860 3861 3862 3863 3864 3865 3866 3867 3868
	struct cma_device *cma_dev;
	struct rdma_id_private *id_priv;
	int ret = NOTIFY_DONE;

	if (event != NETDEV_BONDING_FAILOVER)
		return NOTIFY_DONE;

	if (!(ndev->flags & IFF_MASTER) || !(ndev->priv_flags & IFF_BONDING))
		return NOTIFY_DONE;

	mutex_lock(&lock);
	list_for_each_entry(cma_dev, &dev_list, list)
		list_for_each_entry(id_priv, &cma_dev->id_list, list) {
			ret = cma_netdev_change(ndev, id_priv);
			if (ret)
				goto out;
		}

out:
	mutex_unlock(&lock);
	return ret;
}

static struct notifier_block cma_nb = {
	.notifier_call = cma_netdev_callback
};

3869 3870 3871 3872 3873 3874 3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890 3891 3892 3893
static void cma_add_one(struct ib_device *device)
{
	struct cma_device *cma_dev;
	struct rdma_id_private *id_priv;

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

	cma_dev->device = device;

	init_completion(&cma_dev->comp);
	atomic_set(&cma_dev->refcount, 1);
	INIT_LIST_HEAD(&cma_dev->id_list);
	ib_set_client_data(device, &cma_client, cma_dev);

	mutex_lock(&lock);
	list_add_tail(&cma_dev->list, &dev_list);
	list_for_each_entry(id_priv, &listen_any_list, list)
		cma_listen_on_dev(id_priv, cma_dev);
	mutex_unlock(&lock);
}

static int cma_remove_id_dev(struct rdma_id_private *id_priv)
{
3894
	struct rdma_cm_event event;
3895
	enum rdma_cm_state state;
3896
	int ret = 0;
3897 3898

	/* Record that we want to remove the device */
3899 3900
	state = cma_exch(id_priv, RDMA_CM_DEVICE_REMOVAL);
	if (state == RDMA_CM_DESTROYING)
3901 3902 3903
		return 0;

	cma_cancel_operation(id_priv, state);
3904
	mutex_lock(&id_priv->handler_mutex);
3905 3906

	/* Check for destruction from another callback. */
3907
	if (!cma_comp(id_priv, RDMA_CM_DEVICE_REMOVAL))
3908
		goto out;
3909

3910 3911
	memset(&event, 0, sizeof event);
	event.event = RDMA_CM_EVENT_DEVICE_REMOVAL;
3912 3913 3914 3915
	ret = id_priv->id.event_handler(&id_priv->id, &event);
out:
	mutex_unlock(&id_priv->handler_mutex);
	return ret;
3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927
}

static void cma_process_remove(struct cma_device *cma_dev)
{
	struct rdma_id_private *id_priv;
	int ret;

	mutex_lock(&lock);
	while (!list_empty(&cma_dev->id_list)) {
		id_priv = list_entry(cma_dev->id_list.next,
				     struct rdma_id_private, list);

3928
		list_del(&id_priv->listen_list);
3929
		list_del_init(&id_priv->list);
3930 3931 3932
		atomic_inc(&id_priv->refcount);
		mutex_unlock(&lock);

3933
		ret = id_priv->internal_id ? 1 : cma_remove_id_dev(id_priv);
3934 3935 3936 3937 3938 3939 3940 3941 3942 3943 3944 3945
		cma_deref_id(id_priv);
		if (ret)
			rdma_destroy_id(&id_priv->id);

		mutex_lock(&lock);
	}
	mutex_unlock(&lock);

	cma_deref_dev(cma_dev);
	wait_for_completion(&cma_dev->comp);
}

3946
static void cma_remove_one(struct ib_device *device, void *client_data)
3947
{
3948
	struct cma_device *cma_dev = client_data;
3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960

	if (!cma_dev)
		return;

	mutex_lock(&lock);
	list_del(&cma_dev->list);
	mutex_unlock(&lock);

	cma_process_remove(cma_dev);
	kfree(cma_dev);
}

3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990
static int cma_get_id_stats(struct sk_buff *skb, struct netlink_callback *cb)
{
	struct nlmsghdr *nlh;
	struct rdma_cm_id_stats *id_stats;
	struct rdma_id_private *id_priv;
	struct rdma_cm_id *id = NULL;
	struct cma_device *cma_dev;
	int i_dev = 0, i_id = 0;

	/*
	 * We export all of the IDs as a sequence of messages.  Each
	 * ID gets its own netlink message.
	 */
	mutex_lock(&lock);

	list_for_each_entry(cma_dev, &dev_list, list) {
		if (i_dev < cb->args[0]) {
			i_dev++;
			continue;
		}

		i_id = 0;
		list_for_each_entry(id_priv, &cma_dev->id_list, list) {
			if (i_id < cb->args[1]) {
				i_id++;
				continue;
			}

			id_stats = ibnl_put_msg(skb, &nlh, cb->nlh->nlmsg_seq,
						sizeof *id_stats, RDMA_NL_RDMA_CM,
3991 3992
						RDMA_NL_RDMA_CM_ID_STATS,
						NLM_F_MULTI);
3993 3994 3995 3996 3997 3998 3999 4000 4001 4002
			if (!id_stats)
				goto out;

			memset(id_stats, 0, sizeof *id_stats);
			id = &id_priv->id;
			id_stats->node_type = id->route.addr.dev_addr.dev_type;
			id_stats->port_num = id->port_num;
			id_stats->bound_dev_if =
				id->route.addr.dev_addr.bound_dev_if;

4003 4004 4005 4006 4007 4008 4009 4010 4011 4012
			if (ibnl_put_attr(skb, nlh,
					  rdma_addr_size(cma_src_addr(id_priv)),
					  cma_src_addr(id_priv),
					  RDMA_NL_RDMA_CM_ATTR_SRC_ADDR))
				goto out;
			if (ibnl_put_attr(skb, nlh,
					  rdma_addr_size(cma_src_addr(id_priv)),
					  cma_dst_addr(id_priv),
					  RDMA_NL_RDMA_CM_ATTR_DST_ADDR))
				goto out;
4013

4014
			id_stats->pid		= id_priv->owner;
4015 4016 4017 4018 4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035
			id_stats->port_space	= id->ps;
			id_stats->cm_state	= id_priv->state;
			id_stats->qp_num	= id_priv->qp_num;
			id_stats->qp_type	= id->qp_type;

			i_id++;
		}

		cb->args[1] = 0;
		i_dev++;
	}

out:
	mutex_unlock(&lock);
	cb->args[0] = i_dev;
	cb->args[1] = i_id;

	return skb->len;
}

static const struct ibnl_client_cbs cma_cb_table[] = {
4036 4037
	[RDMA_NL_RDMA_CM_ID_STATS] = { .dump = cma_get_id_stats,
				       .module = THIS_MODULE },
4038 4039
};

4040 4041 4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064 4065 4066 4067 4068
static int cma_init_net(struct net *net)
{
	struct cma_pernet *pernet = cma_pernet(net);

	idr_init(&pernet->tcp_ps);
	idr_init(&pernet->udp_ps);
	idr_init(&pernet->ipoib_ps);
	idr_init(&pernet->ib_ps);

	return 0;
}

static void cma_exit_net(struct net *net)
{
	struct cma_pernet *pernet = cma_pernet(net);

	idr_destroy(&pernet->tcp_ps);
	idr_destroy(&pernet->udp_ps);
	idr_destroy(&pernet->ipoib_ps);
	idr_destroy(&pernet->ib_ps);
}

static struct pernet_operations cma_pernet_operations = {
	.init = cma_init_net,
	.exit = cma_exit_net,
	.id = &cma_pernet_id,
	.size = sizeof(struct cma_pernet),
};

4069
static int __init cma_init(void)
4070
{
4071
	int ret;
4072

4073
	cma_wq = create_singlethread_workqueue("rdma_cm");
4074 4075 4076
	if (!cma_wq)
		return -ENOMEM;

4077 4078 4079 4080
	ret = register_pernet_subsys(&cma_pernet_operations);
	if (ret)
		goto err_wq;

4081
	ib_sa_register_client(&sa_client);
4082
	rdma_addr_register_client(&addr_client);
4083
	register_netdevice_notifier(&cma_nb);
4084

4085 4086 4087
	ret = ib_register_client(&cma_client);
	if (ret)
		goto err;
4088 4089 4090 4091

	if (ibnl_add_client(RDMA_NL_RDMA_CM, RDMA_NL_RDMA_CM_NUM_OPS, cma_cb_table))
		printk(KERN_WARNING "RDMA CMA: failed to add netlink callback\n");

4092 4093 4094
	return 0;

err:
4095
	unregister_netdevice_notifier(&cma_nb);
4096
	rdma_addr_unregister_client(&addr_client);
4097
	ib_sa_unregister_client(&sa_client);
4098
err_wq:
4099 4100 4101 4102
	destroy_workqueue(cma_wq);
	return ret;
}

4103
static void __exit cma_cleanup(void)
4104
{
4105
	ibnl_remove_client(RDMA_NL_RDMA_CM);
4106
	ib_unregister_client(&cma_client);
4107
	unregister_netdevice_notifier(&cma_nb);
4108
	rdma_addr_unregister_client(&addr_client);
4109
	ib_sa_unregister_client(&sa_client);
4110
	unregister_pernet_subsys(&cma_pernet_operations);
4111 4112 4113 4114 4115
	destroy_workqueue(cma_wq);
}

module_init(cma_init);
module_exit(cma_cleanup);