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;
50 struct rdma_addr_client *client;
52 void (*callback)(int status, struct sockaddr *src_addr,
53 struct rdma_dev_addr *addr, void *context);
54 unsigned long timeout;
58 static void process_req(void *data);
60 static DEFINE_MUTEX(lock);
61 static LIST_HEAD(req_list);
62 static DECLARE_WORK(work, process_req, NULL);
63 static struct workqueue_struct *addr_wq;
65 void rdma_addr_register_client(struct rdma_addr_client *client)
67 atomic_set(&client->refcount, 1);
68 init_completion(&client->comp);
70 EXPORT_SYMBOL(rdma_addr_register_client);
72 static inline void put_client(struct rdma_addr_client *client)
74 if (atomic_dec_and_test(&client->refcount))
75 complete(&client->comp);
78 void rdma_addr_unregister_client(struct rdma_addr_client *client)
81 wait_for_completion(&client->comp);
83 EXPORT_SYMBOL(rdma_addr_unregister_client);
85 int rdma_copy_addr(struct rdma_dev_addr *dev_addr, struct net_device *dev,
86 const unsigned char *dst_dev_addr)
89 case ARPHRD_INFINIBAND:
90 dev_addr->dev_type = RDMA_NODE_IB_CA;
93 dev_addr->dev_type = RDMA_NODE_RNIC;
96 return -EADDRNOTAVAIL;
99 memcpy(dev_addr->src_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
100 memcpy(dev_addr->broadcast, dev->broadcast, MAX_ADDR_LEN);
102 memcpy(dev_addr->dst_dev_addr, dst_dev_addr, MAX_ADDR_LEN);
105 EXPORT_SYMBOL(rdma_copy_addr);
107 int rdma_translate_ip(struct sockaddr *addr, struct rdma_dev_addr *dev_addr)
109 struct net_device *dev;
110 __be32 ip = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
113 dev = ip_dev_find(ip);
115 return -EADDRNOTAVAIL;
117 ret = rdma_copy_addr(dev_addr, dev, NULL);
121 EXPORT_SYMBOL(rdma_translate_ip);
123 static void set_timeout(unsigned long time)
127 cancel_delayed_work(&work);
129 delay = time - jiffies;
130 if ((long)delay <= 0)
133 queue_delayed_work(addr_wq, &work, delay);
136 static void queue_req(struct addr_req *req)
138 struct addr_req *temp_req;
141 list_for_each_entry_reverse(temp_req, &req_list, list) {
142 if (time_after_eq(req->timeout, temp_req->timeout))
146 list_add(&req->list, &temp_req->list);
148 if (req_list.next == &req->list)
149 set_timeout(req->timeout);
153 static void addr_send_arp(struct sockaddr_in *dst_in)
157 u32 dst_ip = dst_in->sin_addr.s_addr;
159 memset(&fl, 0, sizeof fl);
160 fl.nl_u.ip4_u.daddr = dst_ip;
161 if (ip_route_output_key(&rt, &fl))
164 arp_send(ARPOP_REQUEST, ETH_P_ARP, rt->rt_gateway, rt->idev->dev,
165 rt->rt_src, NULL, rt->idev->dev->dev_addr, NULL);
169 static int addr_resolve_remote(struct sockaddr_in *src_in,
170 struct sockaddr_in *dst_in,
171 struct rdma_dev_addr *addr)
173 u32 src_ip = src_in->sin_addr.s_addr;
174 u32 dst_ip = dst_in->sin_addr.s_addr;
177 struct neighbour *neigh;
180 memset(&fl, 0, sizeof fl);
181 fl.nl_u.ip4_u.daddr = dst_ip;
182 fl.nl_u.ip4_u.saddr = src_ip;
183 ret = ip_route_output_key(&rt, &fl);
187 /* If the device does ARP internally, return 'done' */
188 if (rt->idev->dev->flags & IFF_NOARP) {
189 rdma_copy_addr(addr, rt->idev->dev, NULL);
193 neigh = neigh_lookup(&arp_tbl, &rt->rt_gateway, rt->idev->dev);
199 if (!(neigh->nud_state & NUD_VALID)) {
205 src_in->sin_family = dst_in->sin_family;
206 src_in->sin_addr.s_addr = rt->rt_src;
209 ret = rdma_copy_addr(addr, neigh->dev, neigh->ha);
211 neigh_release(neigh);
218 static void process_req(void *data)
220 struct addr_req *req, *temp_req;
221 struct sockaddr_in *src_in, *dst_in;
222 struct list_head done_list;
224 INIT_LIST_HEAD(&done_list);
227 list_for_each_entry_safe(req, temp_req, &req_list, list) {
228 if (req->status == -ENODATA) {
229 src_in = (struct sockaddr_in *) &req->src_addr;
230 dst_in = (struct sockaddr_in *) &req->dst_addr;
231 req->status = addr_resolve_remote(src_in, dst_in,
233 if (req->status && time_after_eq(jiffies, req->timeout))
234 req->status = -ETIMEDOUT;
235 else if (req->status == -ENODATA)
238 list_del(&req->list);
239 list_add_tail(&req->list, &done_list);
242 if (!list_empty(&req_list)) {
243 req = list_entry(req_list.next, struct addr_req, list);
244 set_timeout(req->timeout);
248 list_for_each_entry_safe(req, temp_req, &done_list, list) {
249 list_del(&req->list);
250 req->callback(req->status, &req->src_addr, req->addr,
252 put_client(req->client);
257 static int addr_resolve_local(struct sockaddr_in *src_in,
258 struct sockaddr_in *dst_in,
259 struct rdma_dev_addr *addr)
261 struct net_device *dev;
262 u32 src_ip = src_in->sin_addr.s_addr;
263 __be32 dst_ip = dst_in->sin_addr.s_addr;
266 dev = ip_dev_find(dst_ip);
268 return -EADDRNOTAVAIL;
270 if (ZERONET(src_ip)) {
271 src_in->sin_family = dst_in->sin_family;
272 src_in->sin_addr.s_addr = dst_ip;
273 ret = rdma_copy_addr(addr, dev, dev->dev_addr);
274 } else if (LOOPBACK(src_ip)) {
275 ret = rdma_translate_ip((struct sockaddr *)dst_in, addr);
277 memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
279 ret = rdma_translate_ip((struct sockaddr *)src_in, addr);
281 memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
288 int rdma_resolve_ip(struct rdma_addr_client *client,
289 struct sockaddr *src_addr, struct sockaddr *dst_addr,
290 struct rdma_dev_addr *addr, int timeout_ms,
291 void (*callback)(int status, struct sockaddr *src_addr,
292 struct rdma_dev_addr *addr, void *context),
295 struct sockaddr_in *src_in, *dst_in;
296 struct addr_req *req;
299 req = kmalloc(sizeof *req, GFP_KERNEL);
302 memset(req, 0, sizeof *req);
305 memcpy(&req->src_addr, src_addr, ip_addr_size(src_addr));
306 memcpy(&req->dst_addr, dst_addr, ip_addr_size(dst_addr));
308 req->callback = callback;
309 req->context = context;
310 req->client = client;
311 atomic_inc(&client->refcount);
313 src_in = (struct sockaddr_in *) &req->src_addr;
314 dst_in = (struct sockaddr_in *) &req->dst_addr;
316 req->status = addr_resolve_local(src_in, dst_in, addr);
317 if (req->status == -EADDRNOTAVAIL)
318 req->status = addr_resolve_remote(src_in, dst_in, addr);
320 switch (req->status) {
322 req->timeout = jiffies;
326 req->timeout = msecs_to_jiffies(timeout_ms) + jiffies;
328 addr_send_arp(dst_in);
332 atomic_dec(&client->refcount);
338 EXPORT_SYMBOL(rdma_resolve_ip);
340 void rdma_addr_cancel(struct rdma_dev_addr *addr)
342 struct addr_req *req, *temp_req;
345 list_for_each_entry_safe(req, temp_req, &req_list, list) {
346 if (req->addr == addr) {
347 req->status = -ECANCELED;
348 req->timeout = jiffies;
349 list_del(&req->list);
350 list_add(&req->list, &req_list);
351 set_timeout(req->timeout);
357 EXPORT_SYMBOL(rdma_addr_cancel);
359 static int netevent_callback(struct notifier_block *self, unsigned long event,
362 if (event == NETEVENT_NEIGH_UPDATE) {
363 struct neighbour *neigh = ctx;
365 if (neigh->dev->type == ARPHRD_INFINIBAND &&
366 (neigh->nud_state & NUD_VALID)) {
367 set_timeout(jiffies);
373 static struct notifier_block nb = {
374 .notifier_call = netevent_callback
377 static int addr_init(void)
379 addr_wq = create_singlethread_workqueue("ib_addr_wq");
383 register_netevent_notifier(&nb);
387 static void addr_cleanup(void)
389 unregister_netevent_notifier(&nb);
390 destroy_workqueue(addr_wq);
393 module_init(addr_init);
394 module_exit(addr_cleanup);