1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36#include <linux/mutex.h>
37#include <linux/inetdevice.h>
38#include <linux/slab.h>
39#include <linux/workqueue.h>
40#include <linux/module.h>
41#include <net/arp.h>
42#include <net/neighbour.h>
43#include <net/route.h>
44#include <net/netevent.h>
45#include <net/addrconf.h>
46#include <net/ip6_route.h>
47#include <rdma/ib_addr.h>
48
49MODULE_AUTHOR("Sean Hefty");
50MODULE_DESCRIPTION("IB Address Translation");
51MODULE_LICENSE("Dual BSD/GPL");
52
53struct addr_req {
54 struct list_head list;
55 struct sockaddr_storage src_addr;
56 struct sockaddr_storage dst_addr;
57 struct rdma_dev_addr *addr;
58 struct rdma_addr_client *client;
59 void *context;
60 void (*callback)(int status, struct sockaddr *src_addr,
61 struct rdma_dev_addr *addr, void *context);
62 unsigned long timeout;
63 int status;
64};
65
66static void process_req(struct work_struct *work);
67
68static DEFINE_MUTEX(lock);
69static LIST_HEAD(req_list);
70static DECLARE_DELAYED_WORK(work, process_req);
71static struct workqueue_struct *addr_wq;
72
73void rdma_addr_register_client(struct rdma_addr_client *client)
74{
75 atomic_set(&client->refcount, 1);
76 init_completion(&client->comp);
77}
78EXPORT_SYMBOL(rdma_addr_register_client);
79
80static inline void put_client(struct rdma_addr_client *client)
81{
82 if (atomic_dec_and_test(&client->refcount))
83 complete(&client->comp);
84}
85
86void rdma_addr_unregister_client(struct rdma_addr_client *client)
87{
88 put_client(client);
89 wait_for_completion(&client->comp);
90}
91EXPORT_SYMBOL(rdma_addr_unregister_client);
92
93int rdma_copy_addr(struct rdma_dev_addr *dev_addr, struct net_device *dev,
94 const unsigned char *dst_dev_addr)
95{
96 dev_addr->dev_type = dev->type;
97 memcpy(dev_addr->src_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
98 memcpy(dev_addr->broadcast, dev->broadcast, MAX_ADDR_LEN);
99 if (dst_dev_addr)
100 memcpy(dev_addr->dst_dev_addr, dst_dev_addr, MAX_ADDR_LEN);
101 dev_addr->bound_dev_if = dev->ifindex;
102 return 0;
103}
104EXPORT_SYMBOL(rdma_copy_addr);
105
106int rdma_translate_ip(struct sockaddr *addr, struct rdma_dev_addr *dev_addr)
107{
108 struct net_device *dev;
109 int ret = -EADDRNOTAVAIL;
110
111 if (dev_addr->bound_dev_if) {
112 dev = dev_get_by_index(&init_net, dev_addr->bound_dev_if);
113 if (!dev)
114 return -ENODEV;
115 ret = rdma_copy_addr(dev_addr, dev, NULL);
116 dev_put(dev);
117 return ret;
118 }
119
120 switch (addr->sa_family) {
121 case AF_INET:
122 dev = ip_dev_find(&init_net,
123 ((struct sockaddr_in *) addr)->sin_addr.s_addr);
124
125 if (!dev)
126 return ret;
127
128 ret = rdma_copy_addr(dev_addr, dev, NULL);
129 dev_put(dev);
130 break;
131
132#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
133 case AF_INET6:
134 rcu_read_lock();
135 for_each_netdev_rcu(&init_net, dev) {
136 if (ipv6_chk_addr(&init_net,
137 &((struct sockaddr_in6 *) addr)->sin6_addr,
138 dev, 1)) {
139 ret = rdma_copy_addr(dev_addr, dev, NULL);
140 break;
141 }
142 }
143 rcu_read_unlock();
144 break;
145#endif
146 }
147 return ret;
148}
149EXPORT_SYMBOL(rdma_translate_ip);
150
151static void set_timeout(unsigned long time)
152{
153 unsigned long delay;
154
155 cancel_delayed_work(&work);
156
157 delay = time - jiffies;
158 if ((long)delay <= 0)
159 delay = 1;
160
161 queue_delayed_work(addr_wq, &work, delay);
162}
163
164static void queue_req(struct addr_req *req)
165{
166 struct addr_req *temp_req;
167
168 mutex_lock(&lock);
169 list_for_each_entry_reverse(temp_req, &req_list, list) {
170 if (time_after_eq(req->timeout, temp_req->timeout))
171 break;
172 }
173
174 list_add(&req->list, &temp_req->list);
175
176 if (req_list.next == &req->list)
177 set_timeout(req->timeout);
178 mutex_unlock(&lock);
179}
180
181static int addr4_resolve(struct sockaddr_in *src_in,
182 struct sockaddr_in *dst_in,
183 struct rdma_dev_addr *addr)
184{
185 __be32 src_ip = src_in->sin_addr.s_addr;
186 __be32 dst_ip = dst_in->sin_addr.s_addr;
187 struct rtable *rt;
188 struct neighbour *neigh;
189 struct flowi4 fl4;
190 int ret;
191
192 memset(&fl4, 0, sizeof(fl4));
193 fl4.daddr = dst_ip;
194 fl4.saddr = src_ip;
195 fl4.flowi4_oif = addr->bound_dev_if;
196 rt = ip_route_output_key(&init_net, &fl4);
197 if (IS_ERR(rt)) {
198 ret = PTR_ERR(rt);
199 goto out;
200 }
201 src_in->sin_family = AF_INET;
202 src_in->sin_addr.s_addr = fl4.saddr;
203
204 if (rt->dst.dev->flags & IFF_LOOPBACK) {
205 ret = rdma_translate_ip((struct sockaddr *) dst_in, addr);
206 if (!ret)
207 memcpy(addr->dst_dev_addr, addr->src_dev_addr, MAX_ADDR_LEN);
208 goto put;
209 }
210
211
212 if (rt->dst.dev->flags & IFF_NOARP) {
213 ret = rdma_copy_addr(addr, rt->dst.dev, NULL);
214 goto put;
215 }
216
217 neigh = neigh_lookup(&arp_tbl, &rt->rt_gateway, rt->dst.dev);
218 if (!neigh || !(neigh->nud_state & NUD_VALID)) {
219 rcu_read_lock();
220 neigh_event_send(dst_get_neighbour(&rt->dst), NULL);
221 rcu_read_unlock();
222 ret = -ENODATA;
223 if (neigh)
224 goto release;
225 goto put;
226 }
227
228 ret = rdma_copy_addr(addr, neigh->dev, neigh->ha);
229release:
230 neigh_release(neigh);
231put:
232 ip_rt_put(rt);
233out:
234 return ret;
235}
236
237#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
238static int addr6_resolve(struct sockaddr_in6 *src_in,
239 struct sockaddr_in6 *dst_in,
240 struct rdma_dev_addr *addr)
241{
242 struct flowi6 fl6;
243 struct neighbour *neigh;
244 struct dst_entry *dst;
245 int ret;
246
247 memset(&fl6, 0, sizeof fl6);
248 ipv6_addr_copy(&fl6.daddr, &dst_in->sin6_addr);
249 ipv6_addr_copy(&fl6.saddr, &src_in->sin6_addr);
250 fl6.flowi6_oif = addr->bound_dev_if;
251
252 dst = ip6_route_output(&init_net, NULL, &fl6);
253 if ((ret = dst->error))
254 goto put;
255
256 if (ipv6_addr_any(&fl6.saddr)) {
257 ret = ipv6_dev_get_saddr(&init_net, ip6_dst_idev(dst)->dev,
258 &fl6.daddr, 0, &fl6.saddr);
259 if (ret)
260 goto put;
261
262 src_in->sin6_family = AF_INET6;
263 ipv6_addr_copy(&src_in->sin6_addr, &fl6.saddr);
264 }
265
266 if (dst->dev->flags & IFF_LOOPBACK) {
267 ret = rdma_translate_ip((struct sockaddr *) dst_in, addr);
268 if (!ret)
269 memcpy(addr->dst_dev_addr, addr->src_dev_addr, MAX_ADDR_LEN);
270 goto put;
271 }
272
273
274 if (dst->dev->flags & IFF_NOARP) {
275 ret = rdma_copy_addr(addr, dst->dev, NULL);
276 goto put;
277 }
278
279 rcu_read_lock();
280 neigh = dst_get_neighbour(dst);
281 if (!neigh || !(neigh->nud_state & NUD_VALID)) {
282 if (neigh)
283 neigh_event_send(neigh, NULL);
284 ret = -ENODATA;
285 } else {
286 ret = rdma_copy_addr(addr, dst->dev, neigh->ha);
287 }
288 rcu_read_unlock();
289put:
290 dst_release(dst);
291 return ret;
292}
293#else
294static int addr6_resolve(struct sockaddr_in6 *src_in,
295 struct sockaddr_in6 *dst_in,
296 struct rdma_dev_addr *addr)
297{
298 return -EADDRNOTAVAIL;
299}
300#endif
301
302static int addr_resolve(struct sockaddr *src_in,
303 struct sockaddr *dst_in,
304 struct rdma_dev_addr *addr)
305{
306 if (src_in->sa_family == AF_INET) {
307 return addr4_resolve((struct sockaddr_in *) src_in,
308 (struct sockaddr_in *) dst_in, addr);
309 } else
310 return addr6_resolve((struct sockaddr_in6 *) src_in,
311 (struct sockaddr_in6 *) dst_in, addr);
312}
313
314static void process_req(struct work_struct *work)
315{
316 struct addr_req *req, *temp_req;
317 struct sockaddr *src_in, *dst_in;
318 struct list_head done_list;
319
320 INIT_LIST_HEAD(&done_list);
321
322 mutex_lock(&lock);
323 list_for_each_entry_safe(req, temp_req, &req_list, list) {
324 if (req->status == -ENODATA) {
325 src_in = (struct sockaddr *) &req->src_addr;
326 dst_in = (struct sockaddr *) &req->dst_addr;
327 req->status = addr_resolve(src_in, dst_in, req->addr);
328 if (req->status && time_after_eq(jiffies, req->timeout))
329 req->status = -ETIMEDOUT;
330 else if (req->status == -ENODATA)
331 continue;
332 }
333 list_move_tail(&req->list, &done_list);
334 }
335
336 if (!list_empty(&req_list)) {
337 req = list_entry(req_list.next, struct addr_req, list);
338 set_timeout(req->timeout);
339 }
340 mutex_unlock(&lock);
341
342 list_for_each_entry_safe(req, temp_req, &done_list, list) {
343 list_del(&req->list);
344 req->callback(req->status, (struct sockaddr *) &req->src_addr,
345 req->addr, req->context);
346 put_client(req->client);
347 kfree(req);
348 }
349}
350
351int rdma_resolve_ip(struct rdma_addr_client *client,
352 struct sockaddr *src_addr, struct sockaddr *dst_addr,
353 struct rdma_dev_addr *addr, int timeout_ms,
354 void (*callback)(int status, struct sockaddr *src_addr,
355 struct rdma_dev_addr *addr, void *context),
356 void *context)
357{
358 struct sockaddr *src_in, *dst_in;
359 struct addr_req *req;
360 int ret = 0;
361
362 req = kzalloc(sizeof *req, GFP_KERNEL);
363 if (!req)
364 return -ENOMEM;
365
366 src_in = (struct sockaddr *) &req->src_addr;
367 dst_in = (struct sockaddr *) &req->dst_addr;
368
369 if (src_addr) {
370 if (src_addr->sa_family != dst_addr->sa_family) {
371 ret = -EINVAL;
372 goto err;
373 }
374
375 memcpy(src_in, src_addr, ip_addr_size(src_addr));
376 } else {
377 src_in->sa_family = dst_addr->sa_family;
378 }
379
380 memcpy(dst_in, dst_addr, ip_addr_size(dst_addr));
381 req->addr = addr;
382 req->callback = callback;
383 req->context = context;
384 req->client = client;
385 atomic_inc(&client->refcount);
386
387 req->status = addr_resolve(src_in, dst_in, addr);
388 switch (req->status) {
389 case 0:
390 req->timeout = jiffies;
391 queue_req(req);
392 break;
393 case -ENODATA:
394 req->timeout = msecs_to_jiffies(timeout_ms) + jiffies;
395 queue_req(req);
396 break;
397 default:
398 ret = req->status;
399 atomic_dec(&client->refcount);
400 goto err;
401 }
402 return ret;
403err:
404 kfree(req);
405 return ret;
406}
407EXPORT_SYMBOL(rdma_resolve_ip);
408
409void rdma_addr_cancel(struct rdma_dev_addr *addr)
410{
411 struct addr_req *req, *temp_req;
412
413 mutex_lock(&lock);
414 list_for_each_entry_safe(req, temp_req, &req_list, list) {
415 if (req->addr == addr) {
416 req->status = -ECANCELED;
417 req->timeout = jiffies;
418 list_move(&req->list, &req_list);
419 set_timeout(req->timeout);
420 break;
421 }
422 }
423 mutex_unlock(&lock);
424}
425EXPORT_SYMBOL(rdma_addr_cancel);
426
427static int netevent_callback(struct notifier_block *self, unsigned long event,
428 void *ctx)
429{
430 if (event == NETEVENT_NEIGH_UPDATE) {
431 struct neighbour *neigh = ctx;
432
433 if (neigh->nud_state & NUD_VALID) {
434 set_timeout(jiffies);
435 }
436 }
437 return 0;
438}
439
440static struct notifier_block nb = {
441 .notifier_call = netevent_callback
442};
443
444static int __init addr_init(void)
445{
446 addr_wq = create_singlethread_workqueue("ib_addr");
447 if (!addr_wq)
448 return -ENOMEM;
449
450 register_netevent_notifier(&nb);
451 return 0;
452}
453
454static void __exit addr_cleanup(void)
455{
456 unregister_netevent_notifier(&nb);
457 destroy_workqueue(addr_wq);
458}
459
460module_init(addr_init);
461module_exit(addr_cleanup);
462
