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/workqueue.h>
40 #include <net/neighbour.h>
41 #include <net/route.h>
42 #include <net/netevent.h>
43 #include <net/addrconf.h>
44 #include <net/ip6_route.h>
45 #include <rdma/ib_addr.h>
47 MODULE_AUTHOR("Sean Hefty");
48 MODULE_DESCRIPTION("IB Address Translation");
49 MODULE_LICENSE("Dual BSD/GPL");
52 struct list_head list
;
53 struct sockaddr_storage src_addr
;
54 struct sockaddr_storage dst_addr
;
55 struct rdma_dev_addr
*addr
;
56 struct rdma_addr_client
*client
;
58 void (*callback
)(int status
, struct sockaddr
*src_addr
,
59 struct rdma_dev_addr
*addr
, void *context
);
60 unsigned long timeout
;
64 static void process_req(struct work_struct
*work
);
66 static DEFINE_MUTEX(lock
);
67 static LIST_HEAD(req_list
);
68 static DECLARE_DELAYED_WORK(work
, process_req
);
69 static struct workqueue_struct
*addr_wq
;
71 void rdma_addr_register_client(struct rdma_addr_client
*client
)
73 atomic_set(&client
->refcount
, 1);
74 init_completion(&client
->comp
);
76 EXPORT_SYMBOL(rdma_addr_register_client
);
78 static inline void put_client(struct rdma_addr_client
*client
)
80 if (atomic_dec_and_test(&client
->refcount
))
81 complete(&client
->comp
);
84 void rdma_addr_unregister_client(struct rdma_addr_client
*client
)
87 wait_for_completion(&client
->comp
);
89 EXPORT_SYMBOL(rdma_addr_unregister_client
);
91 int rdma_copy_addr(struct rdma_dev_addr
*dev_addr
, struct net_device
*dev
,
92 const unsigned char *dst_dev_addr
)
94 dev_addr
->dev_type
= dev
->type
;
95 memcpy(dev_addr
->src_dev_addr
, dev
->dev_addr
, MAX_ADDR_LEN
);
96 memcpy(dev_addr
->broadcast
, dev
->broadcast
, MAX_ADDR_LEN
);
98 memcpy(dev_addr
->dst_dev_addr
, dst_dev_addr
, MAX_ADDR_LEN
);
99 dev_addr
->bound_dev_if
= dev
->ifindex
;
102 EXPORT_SYMBOL(rdma_copy_addr
);
104 int rdma_translate_ip(struct sockaddr
*addr
, struct rdma_dev_addr
*dev_addr
)
106 struct net_device
*dev
;
107 int ret
= -EADDRNOTAVAIL
;
109 if (dev_addr
->bound_dev_if
) {
110 dev
= dev_get_by_index(&init_net
, dev_addr
->bound_dev_if
);
113 ret
= rdma_copy_addr(dev_addr
, dev
, NULL
);
118 switch (addr
->sa_family
) {
120 dev
= ip_dev_find(&init_net
,
121 ((struct sockaddr_in
*) addr
)->sin_addr
.s_addr
);
126 ret
= rdma_copy_addr(dev_addr
, dev
, NULL
);
130 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
132 read_lock(&dev_base_lock
);
133 for_each_netdev(&init_net
, dev
) {
134 if (ipv6_chk_addr(&init_net
,
135 &((struct sockaddr_in6
*) addr
)->sin6_addr
,
137 ret
= rdma_copy_addr(dev_addr
, dev
, NULL
);
141 read_unlock(&dev_base_lock
);
147 EXPORT_SYMBOL(rdma_translate_ip
);
149 static void set_timeout(unsigned long time
)
153 cancel_delayed_work(&work
);
155 delay
= time
- jiffies
;
156 if ((long)delay
<= 0)
159 queue_delayed_work(addr_wq
, &work
, delay
);
162 static void queue_req(struct addr_req
*req
)
164 struct addr_req
*temp_req
;
167 list_for_each_entry_reverse(temp_req
, &req_list
, list
) {
168 if (time_after_eq(req
->timeout
, temp_req
->timeout
))
172 list_add(&req
->list
, &temp_req
->list
);
174 if (req_list
.next
== &req
->list
)
175 set_timeout(req
->timeout
);
179 static int addr4_resolve(struct sockaddr_in
*src_in
,
180 struct sockaddr_in
*dst_in
,
181 struct rdma_dev_addr
*addr
)
183 __be32 src_ip
= src_in
->sin_addr
.s_addr
;
184 __be32 dst_ip
= dst_in
->sin_addr
.s_addr
;
187 struct neighbour
*neigh
;
190 memset(&fl
, 0, sizeof fl
);
191 fl
.nl_u
.ip4_u
.daddr
= dst_ip
;
192 fl
.nl_u
.ip4_u
.saddr
= src_ip
;
193 fl
.oif
= addr
->bound_dev_if
;
195 ret
= ip_route_output_key(&init_net
, &rt
, &fl
);
199 src_in
->sin_family
= AF_INET
;
200 src_in
->sin_addr
.s_addr
= rt
->rt_src
;
202 if (rt
->idev
->dev
->flags
& IFF_LOOPBACK
) {
203 ret
= rdma_translate_ip((struct sockaddr
*) dst_in
, addr
);
205 memcpy(addr
->dst_dev_addr
, addr
->src_dev_addr
, MAX_ADDR_LEN
);
209 /* If the device does ARP internally, return 'done' */
210 if (rt
->idev
->dev
->flags
& IFF_NOARP
) {
211 rdma_copy_addr(addr
, rt
->idev
->dev
, NULL
);
215 neigh
= neigh_lookup(&arp_tbl
, &rt
->rt_gateway
, rt
->idev
->dev
);
216 if (!neigh
|| !(neigh
->nud_state
& NUD_VALID
)) {
217 neigh_event_send(rt
->u
.dst
.neighbour
, NULL
);
224 ret
= rdma_copy_addr(addr
, neigh
->dev
, neigh
->ha
);
226 neigh_release(neigh
);
233 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
234 static int addr6_resolve(struct sockaddr_in6
*src_in
,
235 struct sockaddr_in6
*dst_in
,
236 struct rdma_dev_addr
*addr
)
239 struct neighbour
*neigh
;
240 struct dst_entry
*dst
;
243 memset(&fl
, 0, sizeof fl
);
244 ipv6_addr_copy(&fl
.fl6_dst
, &dst_in
->sin6_addr
);
245 ipv6_addr_copy(&fl
.fl6_src
, &src_in
->sin6_addr
);
246 fl
.oif
= addr
->bound_dev_if
;
248 dst
= ip6_route_output(&init_net
, NULL
, &fl
);
249 if ((ret
= dst
->error
))
252 if (ipv6_addr_any(&fl
.fl6_src
)) {
253 ret
= ipv6_dev_get_saddr(&init_net
, ip6_dst_idev(dst
)->dev
,
254 &fl
.fl6_dst
, 0, &fl
.fl6_src
);
258 src_in
->sin6_family
= AF_INET6
;
259 ipv6_addr_copy(&src_in
->sin6_addr
, &fl
.fl6_src
);
262 if (dst
->dev
->flags
& IFF_LOOPBACK
) {
263 ret
= rdma_translate_ip((struct sockaddr
*) dst_in
, addr
);
265 memcpy(addr
->dst_dev_addr
, addr
->src_dev_addr
, MAX_ADDR_LEN
);
269 /* If the device does ARP internally, return 'done' */
270 if (dst
->dev
->flags
& IFF_NOARP
) {
271 ret
= rdma_copy_addr(addr
, dst
->dev
, NULL
);
275 neigh
= dst
->neighbour
;
276 if (!neigh
|| !(neigh
->nud_state
& NUD_VALID
)) {
277 neigh_event_send(dst
->neighbour
, NULL
);
282 ret
= rdma_copy_addr(addr
, dst
->dev
, neigh
->ha
);
288 static int addr6_resolve(struct sockaddr_in6
*src_in
,
289 struct sockaddr_in6
*dst_in
,
290 struct rdma_dev_addr
*addr
)
292 return -EADDRNOTAVAIL
;
296 static int addr_resolve(struct sockaddr
*src_in
,
297 struct sockaddr
*dst_in
,
298 struct rdma_dev_addr
*addr
)
300 if (src_in
->sa_family
== AF_INET
) {
301 return addr4_resolve((struct sockaddr_in
*) src_in
,
302 (struct sockaddr_in
*) dst_in
, addr
);
304 return addr6_resolve((struct sockaddr_in6
*) src_in
,
305 (struct sockaddr_in6
*) dst_in
, addr
);
308 static void process_req(struct work_struct
*work
)
310 struct addr_req
*req
, *temp_req
;
311 struct sockaddr
*src_in
, *dst_in
;
312 struct list_head done_list
;
314 INIT_LIST_HEAD(&done_list
);
317 list_for_each_entry_safe(req
, temp_req
, &req_list
, list
) {
318 if (req
->status
== -ENODATA
) {
319 src_in
= (struct sockaddr
*) &req
->src_addr
;
320 dst_in
= (struct sockaddr
*) &req
->dst_addr
;
321 req
->status
= addr_resolve(src_in
, dst_in
, req
->addr
);
322 if (req
->status
&& time_after_eq(jiffies
, req
->timeout
))
323 req
->status
= -ETIMEDOUT
;
324 else if (req
->status
== -ENODATA
)
327 list_move_tail(&req
->list
, &done_list
);
330 if (!list_empty(&req_list
)) {
331 req
= list_entry(req_list
.next
, struct addr_req
, list
);
332 set_timeout(req
->timeout
);
336 list_for_each_entry_safe(req
, temp_req
, &done_list
, list
) {
337 list_del(&req
->list
);
338 req
->callback(req
->status
, (struct sockaddr
*) &req
->src_addr
,
339 req
->addr
, req
->context
);
340 put_client(req
->client
);
345 int rdma_resolve_ip(struct rdma_addr_client
*client
,
346 struct sockaddr
*src_addr
, struct sockaddr
*dst_addr
,
347 struct rdma_dev_addr
*addr
, int timeout_ms
,
348 void (*callback
)(int status
, struct sockaddr
*src_addr
,
349 struct rdma_dev_addr
*addr
, void *context
),
352 struct sockaddr
*src_in
, *dst_in
;
353 struct addr_req
*req
;
356 req
= kzalloc(sizeof *req
, GFP_KERNEL
);
360 src_in
= (struct sockaddr
*) &req
->src_addr
;
361 dst_in
= (struct sockaddr
*) &req
->dst_addr
;
364 if (src_addr
->sa_family
!= dst_addr
->sa_family
) {
369 memcpy(src_in
, src_addr
, ip_addr_size(src_addr
));
371 src_in
->sa_family
= dst_addr
->sa_family
;
374 memcpy(dst_in
, dst_addr
, ip_addr_size(dst_addr
));
376 req
->callback
= callback
;
377 req
->context
= context
;
378 req
->client
= client
;
379 atomic_inc(&client
->refcount
);
381 req
->status
= addr_resolve(src_in
, dst_in
, addr
);
382 switch (req
->status
) {
384 req
->timeout
= jiffies
;
388 req
->timeout
= msecs_to_jiffies(timeout_ms
) + jiffies
;
393 atomic_dec(&client
->refcount
);
401 EXPORT_SYMBOL(rdma_resolve_ip
);
403 void rdma_addr_cancel(struct rdma_dev_addr
*addr
)
405 struct addr_req
*req
, *temp_req
;
408 list_for_each_entry_safe(req
, temp_req
, &req_list
, list
) {
409 if (req
->addr
== addr
) {
410 req
->status
= -ECANCELED
;
411 req
->timeout
= jiffies
;
412 list_move(&req
->list
, &req_list
);
413 set_timeout(req
->timeout
);
419 EXPORT_SYMBOL(rdma_addr_cancel
);
421 static int netevent_callback(struct notifier_block
*self
, unsigned long event
,
424 if (event
== NETEVENT_NEIGH_UPDATE
) {
425 struct neighbour
*neigh
= ctx
;
427 if (neigh
->nud_state
& NUD_VALID
) {
428 set_timeout(jiffies
);
434 static struct notifier_block nb
= {
435 .notifier_call
= netevent_callback
438 static int __init
addr_init(void)
440 addr_wq
= create_singlethread_workqueue("ib_addr");
444 register_netevent_notifier(&nb
);
448 static void __exit
addr_cleanup(void)
450 unregister_netevent_notifier(&nb
);
451 destroy_workqueue(addr_wq
);
454 module_init(addr_init
);
455 module_exit(addr_cleanup
);