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 int rdma_copy_addr(struct rdma_dev_addr
*dev_addr
, struct net_device
*dev
,
65 const unsigned char *dst_dev_addr
)
68 case ARPHRD_INFINIBAND
:
69 dev_addr
->dev_type
= RDMA_NODE_IB_CA
;
72 dev_addr
->dev_type
= RDMA_NODE_RNIC
;
75 return -EADDRNOTAVAIL
;
78 memcpy(dev_addr
->src_dev_addr
, dev
->dev_addr
, MAX_ADDR_LEN
);
79 memcpy(dev_addr
->broadcast
, dev
->broadcast
, MAX_ADDR_LEN
);
81 memcpy(dev_addr
->dst_dev_addr
, dst_dev_addr
, MAX_ADDR_LEN
);
84 EXPORT_SYMBOL(rdma_copy_addr
);
86 int rdma_translate_ip(struct sockaddr
*addr
, struct rdma_dev_addr
*dev_addr
)
88 struct net_device
*dev
;
89 __be32 ip
= ((struct sockaddr_in
*) addr
)->sin_addr
.s_addr
;
92 dev
= ip_dev_find(ip
);
94 return -EADDRNOTAVAIL
;
96 ret
= rdma_copy_addr(dev_addr
, dev
, NULL
);
100 EXPORT_SYMBOL(rdma_translate_ip
);
102 static void set_timeout(unsigned long time
)
106 cancel_delayed_work(&work
);
108 delay
= time
- jiffies
;
109 if ((long)delay
<= 0)
112 queue_delayed_work(addr_wq
, &work
, delay
);
115 static void queue_req(struct addr_req
*req
)
117 struct addr_req
*temp_req
;
120 list_for_each_entry_reverse(temp_req
, &req_list
, list
) {
121 if (time_after(req
->timeout
, temp_req
->timeout
))
125 list_add(&req
->list
, &temp_req
->list
);
127 if (req_list
.next
== &req
->list
)
128 set_timeout(req
->timeout
);
132 static void addr_send_arp(struct sockaddr_in
*dst_in
)
136 u32 dst_ip
= dst_in
->sin_addr
.s_addr
;
138 memset(&fl
, 0, sizeof fl
);
139 fl
.nl_u
.ip4_u
.daddr
= dst_ip
;
140 if (ip_route_output_key(&rt
, &fl
))
143 arp_send(ARPOP_REQUEST
, ETH_P_ARP
, rt
->rt_gateway
, rt
->idev
->dev
,
144 rt
->rt_src
, NULL
, rt
->idev
->dev
->dev_addr
, NULL
);
148 static int addr_resolve_remote(struct sockaddr_in
*src_in
,
149 struct sockaddr_in
*dst_in
,
150 struct rdma_dev_addr
*addr
)
152 u32 src_ip
= src_in
->sin_addr
.s_addr
;
153 u32 dst_ip
= dst_in
->sin_addr
.s_addr
;
156 struct neighbour
*neigh
;
159 memset(&fl
, 0, sizeof fl
);
160 fl
.nl_u
.ip4_u
.daddr
= dst_ip
;
161 fl
.nl_u
.ip4_u
.saddr
= src_ip
;
162 ret
= ip_route_output_key(&rt
, &fl
);
166 /* If the device does ARP internally, return 'done' */
167 if (rt
->idev
->dev
->flags
& IFF_NOARP
) {
168 rdma_copy_addr(addr
, rt
->idev
->dev
, NULL
);
172 neigh
= neigh_lookup(&arp_tbl
, &rt
->rt_gateway
, rt
->idev
->dev
);
178 if (!(neigh
->nud_state
& NUD_VALID
)) {
184 src_in
->sin_family
= dst_in
->sin_family
;
185 src_in
->sin_addr
.s_addr
= rt
->rt_src
;
188 ret
= rdma_copy_addr(addr
, neigh
->dev
, neigh
->ha
);
190 neigh_release(neigh
);
197 static void process_req(void *data
)
199 struct addr_req
*req
, *temp_req
;
200 struct sockaddr_in
*src_in
, *dst_in
;
201 struct list_head done_list
;
203 INIT_LIST_HEAD(&done_list
);
206 list_for_each_entry_safe(req
, temp_req
, &req_list
, list
) {
208 src_in
= (struct sockaddr_in
*) &req
->src_addr
;
209 dst_in
= (struct sockaddr_in
*) &req
->dst_addr
;
210 req
->status
= addr_resolve_remote(src_in
, dst_in
,
213 if (req
->status
&& time_after(jiffies
, req
->timeout
))
214 req
->status
= -ETIMEDOUT
;
215 else if (req
->status
== -ENODATA
)
218 list_del(&req
->list
);
219 list_add_tail(&req
->list
, &done_list
);
222 if (!list_empty(&req_list
)) {
223 req
= list_entry(req_list
.next
, struct addr_req
, list
);
224 set_timeout(req
->timeout
);
228 list_for_each_entry_safe(req
, temp_req
, &done_list
, list
) {
229 list_del(&req
->list
);
230 req
->callback(req
->status
, &req
->src_addr
, req
->addr
,
236 static int addr_resolve_local(struct sockaddr_in
*src_in
,
237 struct sockaddr_in
*dst_in
,
238 struct rdma_dev_addr
*addr
)
240 struct net_device
*dev
;
241 u32 src_ip
= src_in
->sin_addr
.s_addr
;
242 __be32 dst_ip
= dst_in
->sin_addr
.s_addr
;
245 dev
= ip_dev_find(dst_ip
);
247 return -EADDRNOTAVAIL
;
249 if (ZERONET(src_ip
)) {
250 src_in
->sin_family
= dst_in
->sin_family
;
251 src_in
->sin_addr
.s_addr
= dst_ip
;
252 ret
= rdma_copy_addr(addr
, dev
, dev
->dev_addr
);
253 } else if (LOOPBACK(src_ip
)) {
254 ret
= rdma_translate_ip((struct sockaddr
*)dst_in
, addr
);
256 memcpy(addr
->dst_dev_addr
, dev
->dev_addr
, MAX_ADDR_LEN
);
258 ret
= rdma_translate_ip((struct sockaddr
*)src_in
, addr
);
260 memcpy(addr
->dst_dev_addr
, dev
->dev_addr
, MAX_ADDR_LEN
);
267 int rdma_resolve_ip(struct sockaddr
*src_addr
, struct sockaddr
*dst_addr
,
268 struct rdma_dev_addr
*addr
, int timeout_ms
,
269 void (*callback
)(int status
, struct sockaddr
*src_addr
,
270 struct rdma_dev_addr
*addr
, void *context
),
273 struct sockaddr_in
*src_in
, *dst_in
;
274 struct addr_req
*req
;
277 req
= kmalloc(sizeof *req
, GFP_KERNEL
);
280 memset(req
, 0, sizeof *req
);
283 memcpy(&req
->src_addr
, src_addr
, ip_addr_size(src_addr
));
284 memcpy(&req
->dst_addr
, dst_addr
, ip_addr_size(dst_addr
));
286 req
->callback
= callback
;
287 req
->context
= context
;
289 src_in
= (struct sockaddr_in
*) &req
->src_addr
;
290 dst_in
= (struct sockaddr_in
*) &req
->dst_addr
;
292 req
->status
= addr_resolve_local(src_in
, dst_in
, addr
);
293 if (req
->status
== -EADDRNOTAVAIL
)
294 req
->status
= addr_resolve_remote(src_in
, dst_in
, addr
);
296 switch (req
->status
) {
298 req
->timeout
= jiffies
;
302 req
->timeout
= msecs_to_jiffies(timeout_ms
) + jiffies
;
304 addr_send_arp(dst_in
);
313 EXPORT_SYMBOL(rdma_resolve_ip
);
315 void rdma_addr_cancel(struct rdma_dev_addr
*addr
)
317 struct addr_req
*req
, *temp_req
;
320 list_for_each_entry_safe(req
, temp_req
, &req_list
, list
) {
321 if (req
->addr
== addr
) {
322 req
->status
= -ECANCELED
;
323 req
->timeout
= jiffies
;
324 list_del(&req
->list
);
325 list_add(&req
->list
, &req_list
);
326 set_timeout(req
->timeout
);
332 EXPORT_SYMBOL(rdma_addr_cancel
);
334 static int netevent_callback(struct notifier_block
*self
, unsigned long event
,
337 if (event
== NETEVENT_NEIGH_UPDATE
) {
338 struct neighbour
*neigh
= ctx
;
340 if (neigh
->dev
->type
== ARPHRD_INFINIBAND
&&
341 (neigh
->nud_state
& NUD_VALID
)) {
342 set_timeout(jiffies
);
348 static struct notifier_block nb
= {
349 .notifier_call
= netevent_callback
352 static int addr_init(void)
354 addr_wq
= create_singlethread_workqueue("ib_addr_wq");
358 register_netevent_notifier(&nb
);
362 static void addr_cleanup(void)
364 unregister_netevent_notifier(&nb
);
365 destroy_workqueue(addr_wq
);
368 module_init(addr_init
);
369 module_exit(addr_cleanup
);
This page took 0.050203 seconds and 6 git commands to generate.