addr.c 12.9 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 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
42
 */

#include <linux/mutex.h>
#include <linux/inetdevice.h>
#include <linux/workqueue.h>
#include <linux/if_arp.h>
#include <net/arp.h>
#include <net/neighbour.h>
#include <net/route.h>
43
#include <net/netevent.h>
44
45
#include <net/addrconf.h>
#include <net/ip6_route.h>
46
47
48
49
50
51
52
53
#include <rdma/ib_addr.h>

MODULE_AUTHOR("Sean Hefty");
MODULE_DESCRIPTION("IB Address Translation");
MODULE_LICENSE("Dual BSD/GPL");

struct addr_req {
	struct list_head list;
54
55
	struct sockaddr_storage src_addr;
	struct sockaddr_storage dst_addr;
56
	struct rdma_dev_addr *addr;
57
	struct rdma_addr_client *client;
58
59
60
61
62
63
64
	void *context;
	void (*callback)(int status, struct sockaddr *src_addr,
			 struct rdma_dev_addr *addr, void *context);
	unsigned long timeout;
	int status;
};

David Howells's avatar
David Howells committed
65
static void process_req(struct work_struct *work);
66
67
68

static DEFINE_MUTEX(lock);
static LIST_HEAD(req_list);
David Howells's avatar
David Howells committed
69
static DECLARE_DELAYED_WORK(work, process_req);
70
71
static struct workqueue_struct *addr_wq;

72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
void rdma_addr_register_client(struct rdma_addr_client *client)
{
	atomic_set(&client->refcount, 1);
	init_completion(&client->comp);
}
EXPORT_SYMBOL(rdma_addr_register_client);

static inline void put_client(struct rdma_addr_client *client)
{
	if (atomic_dec_and_test(&client->refcount))
		complete(&client->comp);
}

void rdma_addr_unregister_client(struct rdma_addr_client *client)
{
	put_client(client);
	wait_for_completion(&client->comp);
}
EXPORT_SYMBOL(rdma_addr_unregister_client);

Tom Tucker's avatar
Tom Tucker committed
92
93
int rdma_copy_addr(struct rdma_dev_addr *dev_addr, struct net_device *dev,
		     const unsigned char *dst_dev_addr)
94
95
96
{
	switch (dev->type) {
	case ARPHRD_INFINIBAND:
Tom Tucker's avatar
Tom Tucker committed
97
98
99
100
		dev_addr->dev_type = RDMA_NODE_IB_CA;
		break;
	case ARPHRD_ETHER:
		dev_addr->dev_type = RDMA_NODE_RNIC;
101
102
103
104
105
106
107
108
109
		break;
	default:
		return -EADDRNOTAVAIL;
	}

	memcpy(dev_addr->src_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
	memcpy(dev_addr->broadcast, dev->broadcast, MAX_ADDR_LEN);
	if (dst_dev_addr)
		memcpy(dev_addr->dst_dev_addr, dst_dev_addr, MAX_ADDR_LEN);
110
	dev_addr->src_dev = dev;
111
112
	return 0;
}
Tom Tucker's avatar
Tom Tucker committed
113
EXPORT_SYMBOL(rdma_copy_addr);
114
115
116
117

int rdma_translate_ip(struct sockaddr *addr, struct rdma_dev_addr *dev_addr)
{
	struct net_device *dev;
118
	int ret = -EADDRNOTAVAIL;
119

120
121
122
123
124
125
126
	switch (addr->sa_family) {
	case AF_INET:
		dev = ip_dev_find(&init_net,
			((struct sockaddr_in *) addr)->sin_addr.s_addr);

		if (!dev)
			return ret;
127

128
129
130
		ret = rdma_copy_addr(dev_addr, dev, NULL);
		dev_put(dev);
		break;
131
132

#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
133
134
135
136
137
138
139
140
141
142
	case AF_INET6:
		for_each_netdev(&init_net, dev) {
			if (ipv6_chk_addr(&init_net,
					  &((struct sockaddr_in6 *) addr)->sin6_addr,
					  dev, 1)) {
				ret = rdma_copy_addr(dev_addr, dev, NULL);
				break;
			}
		}
		break;
143
#endif
144
	}
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
	return ret;
}
EXPORT_SYMBOL(rdma_translate_ip);

static void set_timeout(unsigned long time)
{
	unsigned long delay;

	cancel_delayed_work(&work);

	delay = time - jiffies;
	if ((long)delay <= 0)
		delay = 1;

	queue_delayed_work(addr_wq, &work, delay);
}

static void queue_req(struct addr_req *req)
{
	struct addr_req *temp_req;

	mutex_lock(&lock);
	list_for_each_entry_reverse(temp_req, &req_list, list) {
168
		if (time_after_eq(req->timeout, temp_req->timeout))
169
170
171
172
173
174
175
176
177
178
			break;
	}

	list_add(&req->list, &temp_req->list);

	if (req_list.next == &req->list)
		set_timeout(req->timeout);
	mutex_unlock(&lock);
}

179
static void addr_send_arp(struct sockaddr *dst_in)
180
181
182
183
184
{
	struct rtable *rt;
	struct flowi fl;

	memset(&fl, 0, sizeof fl);
185
186
187

	switch (dst_in->sa_family) {
	case AF_INET:
188
189
		fl.nl_u.ip4_u.daddr =
			((struct sockaddr_in *) dst_in)->sin_addr.s_addr;
190

191
192
193
194
195
		if (ip_route_output_key(&init_net, &rt, &fl))
			return;

		neigh_event_send(rt->u.dst.neighbour, NULL);
		ip_rt_put(rt);
196
197
198
199
200
201
		break;

#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
	case AF_INET6:
	{
		struct dst_entry *dst;
202
203
204
205
206
207
208
209
210
211

		fl.nl_u.ip6_u.daddr =
			((struct sockaddr_in6 *) dst_in)->sin6_addr;

		dst = ip6_route_output(&init_net, NULL, &fl);
		if (!dst)
			return;

		neigh_event_send(dst->neighbour, NULL);
		dst_release(dst);
212
213
214
		break;
	}
#endif
215
	}
216
217
}

218
static int addr4_resolve_remote(struct sockaddr_in *src_in,
219
220
221
			       struct sockaddr_in *dst_in,
			       struct rdma_dev_addr *addr)
{
222
223
	__be32 src_ip = src_in->sin_addr.s_addr;
	__be32 dst_ip = dst_in->sin_addr.s_addr;
224
225
226
227
228
229
230
231
	struct flowi fl;
	struct rtable *rt;
	struct neighbour *neigh;
	int ret;

	memset(&fl, 0, sizeof fl);
	fl.nl_u.ip4_u.daddr = dst_ip;
	fl.nl_u.ip4_u.saddr = src_ip;
232
	ret = ip_route_output_key(&init_net, &rt, &fl);
233
234
235
236
237
	if (ret)
		goto out;

	/* If the device does ARP internally, return 'done' */
	if (rt->idev->dev->flags & IFF_NOARP) {
Tom Tucker's avatar
Tom Tucker committed
238
		rdma_copy_addr(addr, rt->idev->dev, NULL);
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
		goto put;
	}

	neigh = neigh_lookup(&arp_tbl, &rt->rt_gateway, rt->idev->dev);
	if (!neigh) {
		ret = -ENODATA;
		goto put;
	}

	if (!(neigh->nud_state & NUD_VALID)) {
		ret = -ENODATA;
		goto release;
	}

	if (!src_ip) {
		src_in->sin_family = dst_in->sin_family;
		src_in->sin_addr.s_addr = rt->rt_src;
	}

Tom Tucker's avatar
Tom Tucker committed
258
	ret = rdma_copy_addr(addr, neigh->dev, neigh->ha);
259
260
261
262
263
264
265
266
release:
	neigh_release(neigh);
put:
	ip_rt_put(rt);
out:
	return ret;
}

267
#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
static int addr6_resolve_remote(struct sockaddr_in6 *src_in,
			       struct sockaddr_in6 *dst_in,
			       struct rdma_dev_addr *addr)
{
	struct flowi fl;
	struct neighbour *neigh;
	struct dst_entry *dst;
	int ret = -ENODATA;

	memset(&fl, 0, sizeof fl);
	fl.nl_u.ip6_u.daddr = dst_in->sin6_addr;
	fl.nl_u.ip6_u.saddr = src_in->sin6_addr;

	dst = ip6_route_output(&init_net, NULL, &fl);
	if (!dst)
		return ret;

	if (dst->dev->flags & IFF_NOARP) {
		ret = rdma_copy_addr(addr, dst->dev, NULL);
	} else {
		neigh = dst->neighbour;
		if (neigh && (neigh->nud_state & NUD_VALID))
			ret = rdma_copy_addr(addr, neigh->dev, neigh->ha);
	}

	dst_release(dst);
	return ret;
}
296
297
298
299
300
301
302
303
#else
static int addr6_resolve_remote(struct sockaddr_in6 *src_in,
			       struct sockaddr_in6 *dst_in,
			       struct rdma_dev_addr *addr)
{
	return -EADDRNOTAVAIL;
}
#endif
304
305
306
307
308
309
310
311
312
313
314
315
316

static int addr_resolve_remote(struct sockaddr *src_in,
				struct sockaddr *dst_in,
				struct rdma_dev_addr *addr)
{
	if (src_in->sa_family == AF_INET) {
		return addr4_resolve_remote((struct sockaddr_in *) src_in,
			(struct sockaddr_in *) dst_in, addr);
	} else
		return addr6_resolve_remote((struct sockaddr_in6 *) src_in,
			(struct sockaddr_in6 *) dst_in, addr);
}

David Howells's avatar
David Howells committed
317
static void process_req(struct work_struct *work)
318
319
{
	struct addr_req *req, *temp_req;
320
	struct sockaddr *src_in, *dst_in;
321
322
323
324
325
326
	struct list_head done_list;

	INIT_LIST_HEAD(&done_list);

	mutex_lock(&lock);
	list_for_each_entry_safe(req, temp_req, &req_list, list) {
327
		if (req->status == -ENODATA) {
328
329
			src_in = (struct sockaddr *) &req->src_addr;
			dst_in = (struct sockaddr *) &req->dst_addr;
330
331
			req->status = addr_resolve_remote(src_in, dst_in,
							  req->addr);
332
333
334
335
			if (req->status && time_after_eq(jiffies, req->timeout))
				req->status = -ETIMEDOUT;
			else if (req->status == -ENODATA)
				continue;
336
		}
337
		list_move_tail(&req->list, &done_list);
338
339
340
341
342
343
344
345
346
347
	}

	if (!list_empty(&req_list)) {
		req = list_entry(req_list.next, struct addr_req, list);
		set_timeout(req->timeout);
	}
	mutex_unlock(&lock);

	list_for_each_entry_safe(req, temp_req, &done_list, list) {
		list_del(&req->list);
348
349
		req->callback(req->status, (struct sockaddr *) &req->src_addr,
			req->addr, req->context);
350
		put_client(req->client);
351
352
353
354
		kfree(req);
	}
}

355
356
static int addr_resolve_local(struct sockaddr *src_in,
			      struct sockaddr *dst_in,
357
358
359
360
361
			      struct rdma_dev_addr *addr)
{
	struct net_device *dev;
	int ret;

362
363
364
	switch (dst_in->sa_family) {
	case AF_INET:
	{
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
		__be32 src_ip = ((struct sockaddr_in *) src_in)->sin_addr.s_addr;
		__be32 dst_ip = ((struct sockaddr_in *) dst_in)->sin_addr.s_addr;

		dev = ip_dev_find(&init_net, dst_ip);
		if (!dev)
			return -EADDRNOTAVAIL;

		if (ipv4_is_zeronet(src_ip)) {
			src_in->sa_family = dst_in->sa_family;
			((struct sockaddr_in *) src_in)->sin_addr.s_addr = dst_ip;
			ret = rdma_copy_addr(addr, dev, dev->dev_addr);
		} else if (ipv4_is_loopback(src_ip)) {
			ret = rdma_translate_ip(dst_in, addr);
			if (!ret)
				memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
		} else {
			ret = rdma_translate_ip(src_in, addr);
			if (!ret)
				memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
		}
		dev_put(dev);
386
387
388
389
390
391
		break;
	}

#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
	case AF_INET6:
	{
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
		struct in6_addr *a;

		for_each_netdev(&init_net, dev)
			if (ipv6_chk_addr(&init_net,
					  &((struct sockaddr_in6 *) addr)->sin6_addr,
					  dev, 1))
				break;

		if (!dev)
			return -EADDRNOTAVAIL;

		a = &((struct sockaddr_in6 *) src_in)->sin6_addr;

		if (ipv6_addr_any(a)) {
			src_in->sa_family = dst_in->sa_family;
			((struct sockaddr_in6 *) src_in)->sin6_addr =
				((struct sockaddr_in6 *) dst_in)->sin6_addr;
			ret = rdma_copy_addr(addr, dev, dev->dev_addr);
		} else if (ipv6_addr_loopback(a)) {
			ret = rdma_translate_ip(dst_in, addr);
			if (!ret)
				memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
		} else  {
			ret = rdma_translate_ip(src_in, addr);
			if (!ret)
				memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
		}
419
420
421
422
423
424
425
		break;
	}
#endif

	default:
		ret = -EADDRNOTAVAIL;
		break;
426
427
428
429
430
	}

	return ret;
}

431
432
int rdma_resolve_ip(struct rdma_addr_client *client,
		    struct sockaddr *src_addr, struct sockaddr *dst_addr,
433
434
435
436
437
		    struct rdma_dev_addr *addr, int timeout_ms,
		    void (*callback)(int status, struct sockaddr *src_addr,
				     struct rdma_dev_addr *addr, void *context),
		    void *context)
{
438
	struct sockaddr *src_in, *dst_in;
439
440
441
	struct addr_req *req;
	int ret = 0;

442
	req = kzalloc(sizeof *req, GFP_KERNEL);
443
444
445
446
447
448
449
450
451
	if (!req)
		return -ENOMEM;

	if (src_addr)
		memcpy(&req->src_addr, src_addr, ip_addr_size(src_addr));
	memcpy(&req->dst_addr, dst_addr, ip_addr_size(dst_addr));
	req->addr = addr;
	req->callback = callback;
	req->context = context;
452
453
	req->client = client;
	atomic_inc(&client->refcount);
454

455
456
	src_in = (struct sockaddr *) &req->src_addr;
	dst_in = (struct sockaddr *) &req->dst_addr;
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473

	req->status = addr_resolve_local(src_in, dst_in, addr);
	if (req->status == -EADDRNOTAVAIL)
		req->status = addr_resolve_remote(src_in, dst_in, addr);

	switch (req->status) {
	case 0:
		req->timeout = jiffies;
		queue_req(req);
		break;
	case -ENODATA:
		req->timeout = msecs_to_jiffies(timeout_ms) + jiffies;
		queue_req(req);
		addr_send_arp(dst_in);
		break;
	default:
		ret = req->status;
474
		atomic_dec(&client->refcount);
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
		kfree(req);
		break;
	}
	return ret;
}
EXPORT_SYMBOL(rdma_resolve_ip);

void rdma_addr_cancel(struct rdma_dev_addr *addr)
{
	struct addr_req *req, *temp_req;

	mutex_lock(&lock);
	list_for_each_entry_safe(req, temp_req, &req_list, list) {
		if (req->addr == addr) {
			req->status = -ECANCELED;
			req->timeout = jiffies;
491
			list_move(&req->list, &req_list);
492
493
494
495
496
497
498
499
			set_timeout(req->timeout);
			break;
		}
	}
	mutex_unlock(&lock);
}
EXPORT_SYMBOL(rdma_addr_cancel);

Roland Dreier's avatar
Roland Dreier committed
500
static int netevent_callback(struct notifier_block *self, unsigned long event,
501
	void *ctx)
502
{
Roland Dreier's avatar
Roland Dreier committed
503
	if (event == NETEVENT_NEIGH_UPDATE) {
504
		struct neighbour *neigh = ctx;
505

506
		if (neigh->nud_state & NUD_VALID) {
507
508
509
			set_timeout(jiffies);
		}
	}
510
511
512
	return 0;
}

513
514
static struct notifier_block nb = {
	.notifier_call = netevent_callback
515
516
517
518
};

static int addr_init(void)
{
519
	addr_wq = create_singlethread_workqueue("ib_addr");
520
521
522
	if (!addr_wq)
		return -ENOMEM;

523
	register_netevent_notifier(&nb);
524
525
526
527
528
	return 0;
}

static void addr_cleanup(void)
{
529
	unregister_netevent_notifier(&nb);
530
531
532
533
534
	destroy_workqueue(addr_wq);
}

module_init(addr_init);
module_exit(addr_cleanup);