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 <rdma/ib_addr.h>
40 MODULE_AUTHOR("Sean Hefty");
41 MODULE_DESCRIPTION("IB Address Translation");
42 MODULE_LICENSE("Dual BSD/GPL");
45 struct list_head list
;
46 struct sockaddr src_addr
;
47 struct sockaddr dst_addr
;
48 struct rdma_dev_addr
*addr
;
50 void (*callback
)(int status
, struct sockaddr
*src_addr
,
51 struct rdma_dev_addr
*addr
, void *context
);
52 unsigned long timeout
;
56 static void process_req(void *data
);
58 static DEFINE_MUTEX(lock
);
59 static LIST_HEAD(req_list
);
60 static DECLARE_WORK(work
, process_req
, NULL
);
61 static struct workqueue_struct
*addr_wq
;
63 static int copy_addr(struct rdma_dev_addr
*dev_addr
, struct net_device
*dev
,
64 unsigned char *dst_dev_addr
)
67 case ARPHRD_INFINIBAND
:
68 dev_addr
->dev_type
= IB_NODE_CA
;
71 return -EADDRNOTAVAIL
;
74 memcpy(dev_addr
->src_dev_addr
, dev
->dev_addr
, MAX_ADDR_LEN
);
75 memcpy(dev_addr
->broadcast
, dev
->broadcast
, MAX_ADDR_LEN
);
77 memcpy(dev_addr
->dst_dev_addr
, dst_dev_addr
, MAX_ADDR_LEN
);
81 int rdma_translate_ip(struct sockaddr
*addr
, struct rdma_dev_addr
*dev_addr
)
83 struct net_device
*dev
;
84 u32 ip
= ((struct sockaddr_in
*) addr
)->sin_addr
.s_addr
;
87 dev
= ip_dev_find(ip
);
89 return -EADDRNOTAVAIL
;
91 ret
= copy_addr(dev_addr
, dev
, NULL
);
95 EXPORT_SYMBOL(rdma_translate_ip
);
97 static void set_timeout(unsigned long time
)
101 cancel_delayed_work(&work
);
103 delay
= time
- jiffies
;
104 if ((long)delay
<= 0)
107 queue_delayed_work(addr_wq
, &work
, delay
);
110 static void queue_req(struct addr_req
*req
)
112 struct addr_req
*temp_req
;
115 list_for_each_entry_reverse(temp_req
, &req_list
, list
) {
116 if (time_after(req
->timeout
, temp_req
->timeout
))
120 list_add(&req
->list
, &temp_req
->list
);
122 if (req_list
.next
== &req
->list
)
123 set_timeout(req
->timeout
);
127 static void addr_send_arp(struct sockaddr_in
*dst_in
)
131 u32 dst_ip
= dst_in
->sin_addr
.s_addr
;
133 memset(&fl
, 0, sizeof fl
);
134 fl
.nl_u
.ip4_u
.daddr
= dst_ip
;
135 if (ip_route_output_key(&rt
, &fl
))
138 arp_send(ARPOP_REQUEST
, ETH_P_ARP
, rt
->rt_gateway
, rt
->idev
->dev
,
139 rt
->rt_src
, NULL
, rt
->idev
->dev
->dev_addr
, NULL
);
143 static int addr_resolve_remote(struct sockaddr_in
*src_in
,
144 struct sockaddr_in
*dst_in
,
145 struct rdma_dev_addr
*addr
)
147 u32 src_ip
= src_in
->sin_addr
.s_addr
;
148 u32 dst_ip
= dst_in
->sin_addr
.s_addr
;
151 struct neighbour
*neigh
;
154 memset(&fl
, 0, sizeof fl
);
155 fl
.nl_u
.ip4_u
.daddr
= dst_ip
;
156 fl
.nl_u
.ip4_u
.saddr
= src_ip
;
157 ret
= ip_route_output_key(&rt
, &fl
);
161 /* If the device does ARP internally, return 'done' */
162 if (rt
->idev
->dev
->flags
& IFF_NOARP
) {
163 copy_addr(addr
, rt
->idev
->dev
, NULL
);
167 neigh
= neigh_lookup(&arp_tbl
, &rt
->rt_gateway
, rt
->idev
->dev
);
173 if (!(neigh
->nud_state
& NUD_VALID
)) {
179 src_in
->sin_family
= dst_in
->sin_family
;
180 src_in
->sin_addr
.s_addr
= rt
->rt_src
;
183 ret
= copy_addr(addr
, neigh
->dev
, neigh
->ha
);
185 neigh_release(neigh
);
192 static void process_req(void *data
)
194 struct addr_req
*req
, *temp_req
;
195 struct sockaddr_in
*src_in
, *dst_in
;
196 struct list_head done_list
;
198 INIT_LIST_HEAD(&done_list
);
201 list_for_each_entry_safe(req
, temp_req
, &req_list
, list
) {
203 src_in
= (struct sockaddr_in
*) &req
->src_addr
;
204 dst_in
= (struct sockaddr_in
*) &req
->dst_addr
;
205 req
->status
= addr_resolve_remote(src_in
, dst_in
,
208 if (req
->status
&& time_after(jiffies
, req
->timeout
))
209 req
->status
= -ETIMEDOUT
;
210 else if (req
->status
== -ENODATA
)
213 list_del(&req
->list
);
214 list_add_tail(&req
->list
, &done_list
);
217 if (!list_empty(&req_list
)) {
218 req
= list_entry(req_list
.next
, struct addr_req
, list
);
219 set_timeout(req
->timeout
);
223 list_for_each_entry_safe(req
, temp_req
, &done_list
, list
) {
224 list_del(&req
->list
);
225 req
->callback(req
->status
, &req
->src_addr
, req
->addr
,
231 static int addr_resolve_local(struct sockaddr_in
*src_in
,
232 struct sockaddr_in
*dst_in
,
233 struct rdma_dev_addr
*addr
)
235 struct net_device
*dev
;
236 u32 src_ip
= src_in
->sin_addr
.s_addr
;
237 u32 dst_ip
= dst_in
->sin_addr
.s_addr
;
240 dev
= ip_dev_find(dst_ip
);
242 return -EADDRNOTAVAIL
;
244 if (ZERONET(src_ip
)) {
245 src_in
->sin_family
= dst_in
->sin_family
;
246 src_in
->sin_addr
.s_addr
= dst_ip
;
247 ret
= copy_addr(addr
, dev
, dev
->dev_addr
);
248 } else if (LOOPBACK(src_ip
)) {
249 ret
= rdma_translate_ip((struct sockaddr
*)dst_in
, addr
);
251 memcpy(addr
->dst_dev_addr
, dev
->dev_addr
, MAX_ADDR_LEN
);
253 ret
= rdma_translate_ip((struct sockaddr
*)src_in
, addr
);
255 memcpy(addr
->dst_dev_addr
, dev
->dev_addr
, MAX_ADDR_LEN
);
262 int rdma_resolve_ip(struct sockaddr
*src_addr
, struct sockaddr
*dst_addr
,
263 struct rdma_dev_addr
*addr
, int timeout_ms
,
264 void (*callback
)(int status
, struct sockaddr
*src_addr
,
265 struct rdma_dev_addr
*addr
, void *context
),
268 struct sockaddr_in
*src_in
, *dst_in
;
269 struct addr_req
*req
;
272 req
= kmalloc(sizeof *req
, GFP_KERNEL
);
275 memset(req
, 0, sizeof *req
);
278 memcpy(&req
->src_addr
, src_addr
, ip_addr_size(src_addr
));
279 memcpy(&req
->dst_addr
, dst_addr
, ip_addr_size(dst_addr
));
281 req
->callback
= callback
;
282 req
->context
= context
;
284 src_in
= (struct sockaddr_in
*) &req
->src_addr
;
285 dst_in
= (struct sockaddr_in
*) &req
->dst_addr
;
287 req
->status
= addr_resolve_local(src_in
, dst_in
, addr
);
288 if (req
->status
== -EADDRNOTAVAIL
)
289 req
->status
= addr_resolve_remote(src_in
, dst_in
, addr
);
291 switch (req
->status
) {
293 req
->timeout
= jiffies
;
297 req
->timeout
= msecs_to_jiffies(timeout_ms
) + jiffies
;
299 addr_send_arp(dst_in
);
308 EXPORT_SYMBOL(rdma_resolve_ip
);
310 void rdma_addr_cancel(struct rdma_dev_addr
*addr
)
312 struct addr_req
*req
, *temp_req
;
315 list_for_each_entry_safe(req
, temp_req
, &req_list
, list
) {
316 if (req
->addr
== addr
) {
317 req
->status
= -ECANCELED
;
318 req
->timeout
= jiffies
;
319 list_del(&req
->list
);
320 list_add(&req
->list
, &req_list
);
321 set_timeout(req
->timeout
);
327 EXPORT_SYMBOL(rdma_addr_cancel
);
329 static int addr_arp_recv(struct sk_buff
*skb
, struct net_device
*dev
,
330 struct packet_type
*pkt
, struct net_device
*orig_dev
)
332 struct arphdr
*arp_hdr
;
334 arp_hdr
= (struct arphdr
*) skb
->nh
.raw
;
336 if (arp_hdr
->ar_op
== htons(ARPOP_REQUEST
) ||
337 arp_hdr
->ar_op
== htons(ARPOP_REPLY
))
338 set_timeout(jiffies
);
344 static struct packet_type addr_arp
= {
345 .type
= __constant_htons(ETH_P_ARP
),
346 .func
= addr_arp_recv
,
347 .af_packet_priv
= (void*) 1,
350 static int addr_init(void)
352 addr_wq
= create_singlethread_workqueue("ib_addr_wq");
356 dev_add_pack(&addr_arp
);
360 static void addr_cleanup(void)
362 dev_remove_pack(&addr_arp
);
363 destroy_workqueue(addr_wq
);
366 module_init(addr_init
);
367 module_exit(addr_cleanup
);
This page took 0.041648 seconds and 6 git commands to generate.