addr.c 12.3 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
131
132
133
134
135
136
137
138
139
140
141
142
143
		ret = rdma_copy_addr(dev_addr, dev, NULL);
		dev_put(dev);
		break;
	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;
	default:
		break;
	}
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
	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) {
167
		if (time_after_eq(req->timeout, temp_req->timeout))
168
169
170
171
172
173
174
175
176
177
			break;
	}

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

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

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

	memset(&fl, 0, sizeof fl);
185
186
187
	if (dst_in->sa_family == AF_INET)  {
		fl.nl_u.ip4_u.daddr =
			((struct sockaddr_in *) dst_in)->sin_addr.s_addr;
188

189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
		if (ip_route_output_key(&init_net, &rt, &fl))
			return;

		neigh_event_send(rt->u.dst.neighbour, NULL);
		ip_rt_put(rt);

	} else {
		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);
	}
206
207
}

208
static int addr4_resolve_remote(struct sockaddr_in *src_in,
209
210
211
			       struct sockaddr_in *dst_in,
			       struct rdma_dev_addr *addr)
{
212
213
	__be32 src_ip = src_in->sin_addr.s_addr;
	__be32 dst_ip = dst_in->sin_addr.s_addr;
214
215
216
217
218
219
220
221
	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;
222
	ret = ip_route_output_key(&init_net, &rt, &fl);
223
224
225
226
227
	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
228
		rdma_copy_addr(addr, rt->idev->dev, NULL);
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
		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
248
	ret = rdma_copy_addr(addr, neigh->dev, neigh->ha);
249
250
251
252
253
254
255
256
release:
	neigh_release(neigh);
put:
	ip_rt_put(rt);
out:
	return ret;
}

257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
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;
}

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
298
static void process_req(struct work_struct *work)
299
300
{
	struct addr_req *req, *temp_req;
301
	struct sockaddr *src_in, *dst_in;
302
303
304
305
306
307
	struct list_head done_list;

	INIT_LIST_HEAD(&done_list);

	mutex_lock(&lock);
	list_for_each_entry_safe(req, temp_req, &req_list, list) {
308
		if (req->status == -ENODATA) {
309
310
			src_in = (struct sockaddr *) &req->src_addr;
			dst_in = (struct sockaddr *) &req->dst_addr;
311
312
			req->status = addr_resolve_remote(src_in, dst_in,
							  req->addr);
313
314
315
316
			if (req->status && time_after_eq(jiffies, req->timeout))
				req->status = -ETIMEDOUT;
			else if (req->status == -ENODATA)
				continue;
317
		}
318
		list_move_tail(&req->list, &done_list);
319
320
321
322
323
324
325
326
327
328
	}

	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);
329
330
		req->callback(req->status, (struct sockaddr *) &req->src_addr,
			req->addr, req->context);
331
		put_client(req->client);
332
333
334
335
		kfree(req);
	}
}

336
337
static int addr_resolve_local(struct sockaddr *src_in,
			      struct sockaddr *dst_in,
338
339
340
341
342
			      struct rdma_dev_addr *addr)
{
	struct net_device *dev;
	int ret;

343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
	if (dst_in->sa_family == AF_INET) {
		__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);
365
	} else {
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
		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);
		}
393
394
395
396
397
	}

	return ret;
}

398
399
int rdma_resolve_ip(struct rdma_addr_client *client,
		    struct sockaddr *src_addr, struct sockaddr *dst_addr,
400
401
402
403
404
		    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)
{
405
	struct sockaddr *src_in, *dst_in;
406
407
408
	struct addr_req *req;
	int ret = 0;

409
	req = kzalloc(sizeof *req, GFP_KERNEL);
410
411
412
413
414
415
416
417
418
	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;
419
420
	req->client = client;
	atomic_inc(&client->refcount);
421

422
423
	src_in = (struct sockaddr *) &req->src_addr;
	dst_in = (struct sockaddr *) &req->dst_addr;
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440

	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;
441
		atomic_dec(&client->refcount);
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
		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;
458
			list_move(&req->list, &req_list);
459
460
461
462
463
464
465
466
			set_timeout(req->timeout);
			break;
		}
	}
	mutex_unlock(&lock);
}
EXPORT_SYMBOL(rdma_addr_cancel);

Roland Dreier's avatar
Roland Dreier committed
467
static int netevent_callback(struct notifier_block *self, unsigned long event,
468
	void *ctx)
469
{
Roland Dreier's avatar
Roland Dreier committed
470
	if (event == NETEVENT_NEIGH_UPDATE) {
471
		struct neighbour *neigh = ctx;
472

473
		if (neigh->nud_state & NUD_VALID) {
474
475
476
			set_timeout(jiffies);
		}
	}
477
478
479
	return 0;
}

480
481
static struct notifier_block nb = {
	.notifier_call = netevent_callback
482
483
484
485
};

static int addr_init(void)
{
486
	addr_wq = create_singlethread_workqueue("ib_addr");
487
488
489
	if (!addr_wq)
		return -ENOMEM;

490
	register_netevent_notifier(&nb);
491
492
493
494
495
	return 0;
}

static void addr_cleanup(void)
{
496
	unregister_netevent_notifier(&nb);
497
498
499
500
501
	destroy_workqueue(addr_wq);
}

module_init(addr_init);
module_exit(addr_cleanup);