2 * Copyright (c) 2005 Voltaire Inc. All rights reserved.
3 * Copyright (c) 2002-2005, Network Appliance, Inc. All rights reserved.
4 * Copyright (c) 1999-2005, Mellanox Technologies, Inc. All rights reserved.
5 * Copyright (c) 2005 Intel Corporation. All rights reserved.
7 * This software is available to you under a choice of one of two
8 * licenses. You may choose to be licensed under the terms of the GNU
9 * General Public License (GPL) Version 2, available from the file
10 * COPYING in the main directory of this source tree, or the
11 * OpenIB.org BSD license below:
13 * Redistribution and use in source and binary forms, with or
14 * without modification, are permitted provided that the following
17 * - Redistributions of source code must retain the above
18 * copyright notice, this list of conditions and the following
21 * - Redistributions in binary form must reproduce the above
22 * copyright notice, this list of conditions and the following
23 * disclaimer in the documentation and/or other materials
24 * provided with the distribution.
26 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
27 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
28 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
29 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
30 * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
31 * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
32 * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
36 #include <linux/mutex.h>
37 #include <linux/inetdevice.h>
38 #include <linux/slab.h>
39 #include <linux/workqueue.h>
40 #include <linux/module.h>
42 #include <net/neighbour.h>
43 #include <net/route.h>
44 #include <net/netevent.h>
45 #include <net/addrconf.h>
46 #include <net/ip6_route.h>
47 #include <rdma/ib_addr.h>
49 MODULE_AUTHOR("Sean Hefty");
50 MODULE_DESCRIPTION("IB Address Translation");
51 MODULE_LICENSE("Dual BSD/GPL");
54 struct list_head list
;
55 struct sockaddr_storage src_addr
;
56 struct sockaddr_storage dst_addr
;
57 struct rdma_dev_addr
*addr
;
58 struct rdma_addr_client
*client
;
60 void (*callback
)(int status
, struct sockaddr
*src_addr
,
61 struct rdma_dev_addr
*addr
, void *context
);
62 unsigned long timeout
;
66 static void process_req(struct work_struct
*work
);
68 static DEFINE_MUTEX(lock
);
69 static LIST_HEAD(req_list
);
70 static DECLARE_DELAYED_WORK(work
, process_req
);
71 static struct workqueue_struct
*addr_wq
;
73 void rdma_addr_register_client(struct rdma_addr_client
*client
)
75 atomic_set(&client
->refcount
, 1);
76 init_completion(&client
->comp
);
78 EXPORT_SYMBOL(rdma_addr_register_client
);
80 static inline void put_client(struct rdma_addr_client
*client
)
82 if (atomic_dec_and_test(&client
->refcount
))
83 complete(&client
->comp
);
86 void rdma_addr_unregister_client(struct rdma_addr_client
*client
)
89 wait_for_completion(&client
->comp
);
91 EXPORT_SYMBOL(rdma_addr_unregister_client
);
93 int rdma_copy_addr(struct rdma_dev_addr
*dev_addr
, struct net_device
*dev
,
94 const unsigned char *dst_dev_addr
)
96 dev_addr
->dev_type
= dev
->type
;
97 memcpy(dev_addr
->src_dev_addr
, dev
->dev_addr
, MAX_ADDR_LEN
);
98 memcpy(dev_addr
->broadcast
, dev
->broadcast
, MAX_ADDR_LEN
);
100 memcpy(dev_addr
->dst_dev_addr
, dst_dev_addr
, MAX_ADDR_LEN
);
101 dev_addr
->bound_dev_if
= dev
->ifindex
;
104 EXPORT_SYMBOL(rdma_copy_addr
);
106 int rdma_translate_ip(struct sockaddr
*addr
, struct rdma_dev_addr
*dev_addr
)
108 struct net_device
*dev
;
109 int ret
= -EADDRNOTAVAIL
;
111 if (dev_addr
->bound_dev_if
) {
112 dev
= dev_get_by_index(&init_net
, dev_addr
->bound_dev_if
);
115 ret
= rdma_copy_addr(dev_addr
, dev
, NULL
);
120 switch (addr
->sa_family
) {
122 dev
= ip_dev_find(&init_net
,
123 ((struct sockaddr_in
*) addr
)->sin_addr
.s_addr
);
128 ret
= rdma_copy_addr(dev_addr
, dev
, NULL
);
132 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
135 for_each_netdev_rcu(&init_net
, dev
) {
136 if (ipv6_chk_addr(&init_net
,
137 &((struct sockaddr_in6
*) addr
)->sin6_addr
,
139 ret
= rdma_copy_addr(dev_addr
, dev
, NULL
);
149 EXPORT_SYMBOL(rdma_translate_ip
);
151 static void set_timeout(unsigned long time
)
155 cancel_delayed_work(&work
);
157 delay
= time
- jiffies
;
158 if ((long)delay
<= 0)
161 queue_delayed_work(addr_wq
, &work
, delay
);
164 static void queue_req(struct addr_req
*req
)
166 struct addr_req
*temp_req
;
169 list_for_each_entry_reverse(temp_req
, &req_list
, list
) {
170 if (time_after_eq(req
->timeout
, temp_req
->timeout
))
174 list_add(&req
->list
, &temp_req
->list
);
176 if (req_list
.next
== &req
->list
)
177 set_timeout(req
->timeout
);
181 static int dst_fetch_ha(struct dst_entry
*dst
, struct rdma_dev_addr
*dev_addr
, void *daddr
)
186 n
= dst_neigh_lookup(dst
, daddr
);
189 if (!n
|| !(n
->nud_state
& NUD_VALID
)) {
191 neigh_event_send(n
, NULL
);
194 ret
= rdma_copy_addr(dev_addr
, dst
->dev
, n
->ha
);
204 static int addr4_resolve(struct sockaddr_in
*src_in
,
205 struct sockaddr_in
*dst_in
,
206 struct rdma_dev_addr
*addr
)
208 __be32 src_ip
= src_in
->sin_addr
.s_addr
;
209 __be32 dst_ip
= dst_in
->sin_addr
.s_addr
;
214 memset(&fl4
, 0, sizeof(fl4
));
217 fl4
.flowi4_oif
= addr
->bound_dev_if
;
218 rt
= ip_route_output_key(&init_net
, &fl4
);
223 src_in
->sin_family
= AF_INET
;
224 src_in
->sin_addr
.s_addr
= fl4
.saddr
;
226 if (rt
->dst
.dev
->flags
& IFF_LOOPBACK
) {
227 ret
= rdma_translate_ip((struct sockaddr
*) dst_in
, addr
);
229 memcpy(addr
->dst_dev_addr
, addr
->src_dev_addr
, MAX_ADDR_LEN
);
233 /* If the device does ARP internally, return 'done' */
234 if (rt
->dst
.dev
->flags
& IFF_NOARP
) {
235 ret
= rdma_copy_addr(addr
, rt
->dst
.dev
, NULL
);
239 ret
= dst_fetch_ha(&rt
->dst
, addr
, &fl4
.daddr
);
246 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
247 static int addr6_resolve(struct sockaddr_in6
*src_in
,
248 struct sockaddr_in6
*dst_in
,
249 struct rdma_dev_addr
*addr
)
252 struct dst_entry
*dst
;
255 memset(&fl6
, 0, sizeof fl6
);
256 fl6
.daddr
= dst_in
->sin6_addr
;
257 fl6
.saddr
= src_in
->sin6_addr
;
258 fl6
.flowi6_oif
= addr
->bound_dev_if
;
260 dst
= ip6_route_output(&init_net
, NULL
, &fl6
);
261 if ((ret
= dst
->error
))
264 if (ipv6_addr_any(&fl6
.saddr
)) {
265 ret
= ipv6_dev_get_saddr(&init_net
, ip6_dst_idev(dst
)->dev
,
266 &fl6
.daddr
, 0, &fl6
.saddr
);
270 src_in
->sin6_family
= AF_INET6
;
271 src_in
->sin6_addr
= fl6
.saddr
;
274 if (dst
->dev
->flags
& IFF_LOOPBACK
) {
275 ret
= rdma_translate_ip((struct sockaddr
*) dst_in
, addr
);
277 memcpy(addr
->dst_dev_addr
, addr
->src_dev_addr
, MAX_ADDR_LEN
);
281 /* If the device does ARP internally, return 'done' */
282 if (dst
->dev
->flags
& IFF_NOARP
) {
283 ret
= rdma_copy_addr(addr
, dst
->dev
, NULL
);
287 ret
= dst_fetch_ha(dst
, addr
, &fl6
.daddr
);
293 static int addr6_resolve(struct sockaddr_in6
*src_in
,
294 struct sockaddr_in6
*dst_in
,
295 struct rdma_dev_addr
*addr
)
297 return -EADDRNOTAVAIL
;
301 static int addr_resolve(struct sockaddr
*src_in
,
302 struct sockaddr
*dst_in
,
303 struct rdma_dev_addr
*addr
)
305 if (src_in
->sa_family
== AF_INET
) {
306 return addr4_resolve((struct sockaddr_in
*) src_in
,
307 (struct sockaddr_in
*) dst_in
, addr
);
309 return addr6_resolve((struct sockaddr_in6
*) src_in
,
310 (struct sockaddr_in6
*) dst_in
, addr
);
313 static void process_req(struct work_struct
*work
)
315 struct addr_req
*req
, *temp_req
;
316 struct sockaddr
*src_in
, *dst_in
;
317 struct list_head done_list
;
319 INIT_LIST_HEAD(&done_list
);
322 list_for_each_entry_safe(req
, temp_req
, &req_list
, list
) {
323 if (req
->status
== -ENODATA
) {
324 src_in
= (struct sockaddr
*) &req
->src_addr
;
325 dst_in
= (struct sockaddr
*) &req
->dst_addr
;
326 req
->status
= addr_resolve(src_in
, dst_in
, req
->addr
);
327 if (req
->status
&& time_after_eq(jiffies
, req
->timeout
))
328 req
->status
= -ETIMEDOUT
;
329 else if (req
->status
== -ENODATA
)
332 list_move_tail(&req
->list
, &done_list
);
335 if (!list_empty(&req_list
)) {
336 req
= list_entry(req_list
.next
, struct addr_req
, list
);
337 set_timeout(req
->timeout
);
341 list_for_each_entry_safe(req
, temp_req
, &done_list
, list
) {
342 list_del(&req
->list
);
343 req
->callback(req
->status
, (struct sockaddr
*) &req
->src_addr
,
344 req
->addr
, req
->context
);
345 put_client(req
->client
);
350 int rdma_resolve_ip(struct rdma_addr_client
*client
,
351 struct sockaddr
*src_addr
, struct sockaddr
*dst_addr
,
352 struct rdma_dev_addr
*addr
, int timeout_ms
,
353 void (*callback
)(int status
, struct sockaddr
*src_addr
,
354 struct rdma_dev_addr
*addr
, void *context
),
357 struct sockaddr
*src_in
, *dst_in
;
358 struct addr_req
*req
;
361 req
= kzalloc(sizeof *req
, GFP_KERNEL
);
365 src_in
= (struct sockaddr
*) &req
->src_addr
;
366 dst_in
= (struct sockaddr
*) &req
->dst_addr
;
369 if (src_addr
->sa_family
!= dst_addr
->sa_family
) {
374 memcpy(src_in
, src_addr
, ip_addr_size(src_addr
));
376 src_in
->sa_family
= dst_addr
->sa_family
;
379 memcpy(dst_in
, dst_addr
, ip_addr_size(dst_addr
));
381 req
->callback
= callback
;
382 req
->context
= context
;
383 req
->client
= client
;
384 atomic_inc(&client
->refcount
);
386 req
->status
= addr_resolve(src_in
, dst_in
, addr
);
387 switch (req
->status
) {
389 req
->timeout
= jiffies
;
393 req
->timeout
= msecs_to_jiffies(timeout_ms
) + jiffies
;
398 atomic_dec(&client
->refcount
);
406 EXPORT_SYMBOL(rdma_resolve_ip
);
408 void rdma_addr_cancel(struct rdma_dev_addr
*addr
)
410 struct addr_req
*req
, *temp_req
;
413 list_for_each_entry_safe(req
, temp_req
, &req_list
, list
) {
414 if (req
->addr
== addr
) {
415 req
->status
= -ECANCELED
;
416 req
->timeout
= jiffies
;
417 list_move(&req
->list
, &req_list
);
418 set_timeout(req
->timeout
);
424 EXPORT_SYMBOL(rdma_addr_cancel
);
426 static int netevent_callback(struct notifier_block
*self
, unsigned long event
,
429 if (event
== NETEVENT_NEIGH_UPDATE
) {
430 struct neighbour
*neigh
= ctx
;
432 if (neigh
->nud_state
& NUD_VALID
) {
433 set_timeout(jiffies
);
439 static struct notifier_block nb
= {
440 .notifier_call
= netevent_callback
443 static int __init
addr_init(void)
445 addr_wq
= create_singlethread_workqueue("ib_addr");
449 register_netevent_notifier(&nb
);
453 static void __exit
addr_cleanup(void)
455 unregister_netevent_notifier(&nb
);
456 destroy_workqueue(addr_wq
);
459 module_init(addr_init
);
460 module_exit(addr_cleanup
);