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 licensed under one of the following licenses:
9 * 1) under the terms of the "Common Public License 1.0" a copy of which is
10 * available from the Open Source Initiative, see
11 * http://www.opensource.org/licenses/cpl.php.
13 * 2) under the terms of the "The BSD License" a copy of which is
14 * available from the Open Source Initiative, see
15 * http://www.opensource.org/licenses/bsd-license.php.
17 * 3) under the terms of the "GNU General Public License (GPL) Version 2" a
18 * copy of which is available from the Open Source Initiative, see
19 * http://www.opensource.org/licenses/gpl-license.php.
21 * Licensee has the right to choose one of the above licenses.
23 * Redistributions of source code must retain the above copyright
24 * notice and one of the license notices.
26 * Redistributions in binary form must reproduce both the above copyright
27 * notice, one of the license notices in the documentation
28 * and/or other materials provided with the distribution.
31 #include <linux/mutex.h>
32 #include <linux/inetdevice.h>
33 #include <linux/workqueue.h>
34 #include <linux/if_arp.h>
36 #include <net/neighbour.h>
37 #include <net/route.h>
38 #include <net/netevent.h>
39 #include <rdma/ib_addr.h>
41 MODULE_AUTHOR("Sean Hefty");
42 MODULE_DESCRIPTION("IB Address Translation");
43 MODULE_LICENSE("Dual BSD/GPL");
46 struct list_head list
;
47 struct sockaddr src_addr
;
48 struct sockaddr dst_addr
;
49 struct rdma_dev_addr
*addr
;
51 void (*callback
)(int status
, struct sockaddr
*src_addr
,
52 struct rdma_dev_addr
*addr
, void *context
);
53 unsigned long timeout
;
57 static void process_req(void *data
);
59 static DEFINE_MUTEX(lock
);
60 static LIST_HEAD(req_list
);
61 static DECLARE_WORK(work
, process_req
, NULL
);
62 static struct workqueue_struct
*addr_wq
;
64 static int copy_addr(struct rdma_dev_addr
*dev_addr
, struct net_device
*dev
,
65 unsigned char *dst_dev_addr
)
68 case ARPHRD_INFINIBAND
:
69 dev_addr
->dev_type
= IB_NODE_CA
;
72 return -EADDRNOTAVAIL
;
75 memcpy(dev_addr
->src_dev_addr
, dev
->dev_addr
, MAX_ADDR_LEN
);
76 memcpy(dev_addr
->broadcast
, dev
->broadcast
, MAX_ADDR_LEN
);
78 memcpy(dev_addr
->dst_dev_addr
, dst_dev_addr
, MAX_ADDR_LEN
);
82 int rdma_translate_ip(struct sockaddr
*addr
, struct rdma_dev_addr
*dev_addr
)
84 struct net_device
*dev
;
85 u32 ip
= ((struct sockaddr_in
*) addr
)->sin_addr
.s_addr
;
88 dev
= ip_dev_find(ip
);
90 return -EADDRNOTAVAIL
;
92 ret
= copy_addr(dev_addr
, dev
, NULL
);
96 EXPORT_SYMBOL(rdma_translate_ip
);
98 static void set_timeout(unsigned long time
)
102 cancel_delayed_work(&work
);
104 delay
= time
- jiffies
;
105 if ((long)delay
<= 0)
108 queue_delayed_work(addr_wq
, &work
, delay
);
111 static void queue_req(struct addr_req
*req
)
113 struct addr_req
*temp_req
;
116 list_for_each_entry_reverse(temp_req
, &req_list
, list
) {
117 if (time_after(req
->timeout
, temp_req
->timeout
))
121 list_add(&req
->list
, &temp_req
->list
);
123 if (req_list
.next
== &req
->list
)
124 set_timeout(req
->timeout
);
128 static void addr_send_arp(struct sockaddr_in
*dst_in
)
132 u32 dst_ip
= dst_in
->sin_addr
.s_addr
;
134 memset(&fl
, 0, sizeof fl
);
135 fl
.nl_u
.ip4_u
.daddr
= dst_ip
;
136 if (ip_route_output_key(&rt
, &fl
))
139 arp_send(ARPOP_REQUEST
, ETH_P_ARP
, rt
->rt_gateway
, rt
->idev
->dev
,
140 rt
->rt_src
, NULL
, rt
->idev
->dev
->dev_addr
, NULL
);
144 static int addr_resolve_remote(struct sockaddr_in
*src_in
,
145 struct sockaddr_in
*dst_in
,
146 struct rdma_dev_addr
*addr
)
148 u32 src_ip
= src_in
->sin_addr
.s_addr
;
149 u32 dst_ip
= dst_in
->sin_addr
.s_addr
;
152 struct neighbour
*neigh
;
155 memset(&fl
, 0, sizeof fl
);
156 fl
.nl_u
.ip4_u
.daddr
= dst_ip
;
157 fl
.nl_u
.ip4_u
.saddr
= src_ip
;
158 ret
= ip_route_output_key(&rt
, &fl
);
162 /* If the device does ARP internally, return 'done' */
163 if (rt
->idev
->dev
->flags
& IFF_NOARP
) {
164 copy_addr(addr
, rt
->idev
->dev
, NULL
);
168 neigh
= neigh_lookup(&arp_tbl
, &rt
->rt_gateway
, rt
->idev
->dev
);
174 if (!(neigh
->nud_state
& NUD_VALID
)) {
180 src_in
->sin_family
= dst_in
->sin_family
;
181 src_in
->sin_addr
.s_addr
= rt
->rt_src
;
184 ret
= copy_addr(addr
, neigh
->dev
, neigh
->ha
);
186 neigh_release(neigh
);
193 static void process_req(void *data
)
195 struct addr_req
*req
, *temp_req
;
196 struct sockaddr_in
*src_in
, *dst_in
;
197 struct list_head done_list
;
199 INIT_LIST_HEAD(&done_list
);
202 list_for_each_entry_safe(req
, temp_req
, &req_list
, list
) {
204 src_in
= (struct sockaddr_in
*) &req
->src_addr
;
205 dst_in
= (struct sockaddr_in
*) &req
->dst_addr
;
206 req
->status
= addr_resolve_remote(src_in
, dst_in
,
209 if (req
->status
&& time_after(jiffies
, req
->timeout
))
210 req
->status
= -ETIMEDOUT
;
211 else if (req
->status
== -ENODATA
)
214 list_del(&req
->list
);
215 list_add_tail(&req
->list
, &done_list
);
218 if (!list_empty(&req_list
)) {
219 req
= list_entry(req_list
.next
, struct addr_req
, list
);
220 set_timeout(req
->timeout
);
224 list_for_each_entry_safe(req
, temp_req
, &done_list
, list
) {
225 list_del(&req
->list
);
226 req
->callback(req
->status
, &req
->src_addr
, req
->addr
,
232 static int addr_resolve_local(struct sockaddr_in
*src_in
,
233 struct sockaddr_in
*dst_in
,
234 struct rdma_dev_addr
*addr
)
236 struct net_device
*dev
;
237 u32 src_ip
= src_in
->sin_addr
.s_addr
;
238 u32 dst_ip
= dst_in
->sin_addr
.s_addr
;
241 dev
= ip_dev_find(dst_ip
);
243 return -EADDRNOTAVAIL
;
245 if (ZERONET(src_ip
)) {
246 src_in
->sin_family
= dst_in
->sin_family
;
247 src_in
->sin_addr
.s_addr
= dst_ip
;
248 ret
= copy_addr(addr
, dev
, dev
->dev_addr
);
249 } else if (LOOPBACK(src_ip
)) {
250 ret
= rdma_translate_ip((struct sockaddr
*)dst_in
, addr
);
252 memcpy(addr
->dst_dev_addr
, dev
->dev_addr
, MAX_ADDR_LEN
);
254 ret
= rdma_translate_ip((struct sockaddr
*)src_in
, addr
);
256 memcpy(addr
->dst_dev_addr
, dev
->dev_addr
, MAX_ADDR_LEN
);
263 int rdma_resolve_ip(struct sockaddr
*src_addr
, struct sockaddr
*dst_addr
,
264 struct rdma_dev_addr
*addr
, int timeout_ms
,
265 void (*callback
)(int status
, struct sockaddr
*src_addr
,
266 struct rdma_dev_addr
*addr
, void *context
),
269 struct sockaddr_in
*src_in
, *dst_in
;
270 struct addr_req
*req
;
273 req
= kmalloc(sizeof *req
, GFP_KERNEL
);
276 memset(req
, 0, sizeof *req
);
279 memcpy(&req
->src_addr
, src_addr
, ip_addr_size(src_addr
));
280 memcpy(&req
->dst_addr
, dst_addr
, ip_addr_size(dst_addr
));
282 req
->callback
= callback
;
283 req
->context
= context
;
285 src_in
= (struct sockaddr_in
*) &req
->src_addr
;
286 dst_in
= (struct sockaddr_in
*) &req
->dst_addr
;
288 req
->status
= addr_resolve_local(src_in
, dst_in
, addr
);
289 if (req
->status
== -EADDRNOTAVAIL
)
290 req
->status
= addr_resolve_remote(src_in
, dst_in
, addr
);
292 switch (req
->status
) {
294 req
->timeout
= jiffies
;
298 req
->timeout
= msecs_to_jiffies(timeout_ms
) + jiffies
;
300 addr_send_arp(dst_in
);
309 EXPORT_SYMBOL(rdma_resolve_ip
);
311 void rdma_addr_cancel(struct rdma_dev_addr
*addr
)
313 struct addr_req
*req
, *temp_req
;
316 list_for_each_entry_safe(req
, temp_req
, &req_list
, list
) {
317 if (req
->addr
== addr
) {
318 req
->status
= -ECANCELED
;
319 req
->timeout
= jiffies
;
320 list_del(&req
->list
);
321 list_add(&req
->list
, &req_list
);
322 set_timeout(req
->timeout
);
328 EXPORT_SYMBOL(rdma_addr_cancel
);
330 static int netevent_callback(struct notifier_block
*self
, unsigned long event
,
333 if (event
== NETEVENT_NEIGH_UPDATE
) {
334 struct neighbour
*neigh
= ctx
;
336 if (neigh
->dev
->type
== ARPHRD_INFINIBAND
&&
337 (neigh
->nud_state
& NUD_VALID
)) {
338 set_timeout(jiffies
);
344 static struct notifier_block nb
= {
345 .notifier_call
= netevent_callback
348 static int addr_init(void)
350 addr_wq
= create_singlethread_workqueue("ib_addr_wq");
354 register_netevent_notifier(&nb
);
358 static void addr_cleanup(void)
360 unregister_netevent_notifier(&nb
);
361 destroy_workqueue(addr_wq
);
364 module_init(addr_init
);
365 module_exit(addr_cleanup
);
This page took 0.039799 seconds and 6 git commands to generate.