addr.c 8.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367
  1. /*
  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.
  6. *
  7. * This Software is licensed under one of the following licenses:
  8. *
  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.
  12. *
  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.
  16. *
  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.
  20. *
  21. * Licensee has the right to choose one of the above licenses.
  22. *
  23. * Redistributions of source code must retain the above copyright
  24. * notice and one of the license notices.
  25. *
  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.
  29. */
  30. #include <linux/mutex.h>
  31. #include <linux/inetdevice.h>
  32. #include <linux/workqueue.h>
  33. #include <linux/if_arp.h>
  34. #include <net/arp.h>
  35. #include <net/neighbour.h>
  36. #include <net/route.h>
  37. #include <rdma/ib_addr.h>
  38. MODULE_AUTHOR("Sean Hefty");
  39. MODULE_DESCRIPTION("IB Address Translation");
  40. MODULE_LICENSE("Dual BSD/GPL");
  41. struct addr_req {
  42. struct list_head list;
  43. struct sockaddr src_addr;
  44. struct sockaddr dst_addr;
  45. struct rdma_dev_addr *addr;
  46. void *context;
  47. void (*callback)(int status, struct sockaddr *src_addr,
  48. struct rdma_dev_addr *addr, void *context);
  49. unsigned long timeout;
  50. int status;
  51. };
  52. static void process_req(void *data);
  53. static DEFINE_MUTEX(lock);
  54. static LIST_HEAD(req_list);
  55. static DECLARE_WORK(work, process_req, NULL);
  56. static struct workqueue_struct *addr_wq;
  57. static int copy_addr(struct rdma_dev_addr *dev_addr, struct net_device *dev,
  58. unsigned char *dst_dev_addr)
  59. {
  60. switch (dev->type) {
  61. case ARPHRD_INFINIBAND:
  62. dev_addr->dev_type = IB_NODE_CA;
  63. break;
  64. default:
  65. return -EADDRNOTAVAIL;
  66. }
  67. memcpy(dev_addr->src_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
  68. memcpy(dev_addr->broadcast, dev->broadcast, MAX_ADDR_LEN);
  69. if (dst_dev_addr)
  70. memcpy(dev_addr->dst_dev_addr, dst_dev_addr, MAX_ADDR_LEN);
  71. return 0;
  72. }
  73. int rdma_translate_ip(struct sockaddr *addr, struct rdma_dev_addr *dev_addr)
  74. {
  75. struct net_device *dev;
  76. u32 ip = ((struct sockaddr_in *) addr)->sin_addr.s_addr;
  77. int ret;
  78. dev = ip_dev_find(ip);
  79. if (!dev)
  80. return -EADDRNOTAVAIL;
  81. ret = copy_addr(dev_addr, dev, NULL);
  82. dev_put(dev);
  83. return ret;
  84. }
  85. EXPORT_SYMBOL(rdma_translate_ip);
  86. static void set_timeout(unsigned long time)
  87. {
  88. unsigned long delay;
  89. cancel_delayed_work(&work);
  90. delay = time - jiffies;
  91. if ((long)delay <= 0)
  92. delay = 1;
  93. queue_delayed_work(addr_wq, &work, delay);
  94. }
  95. static void queue_req(struct addr_req *req)
  96. {
  97. struct addr_req *temp_req;
  98. mutex_lock(&lock);
  99. list_for_each_entry_reverse(temp_req, &req_list, list) {
  100. if (time_after(req->timeout, temp_req->timeout))
  101. break;
  102. }
  103. list_add(&req->list, &temp_req->list);
  104. if (req_list.next == &req->list)
  105. set_timeout(req->timeout);
  106. mutex_unlock(&lock);
  107. }
  108. static void addr_send_arp(struct sockaddr_in *dst_in)
  109. {
  110. struct rtable *rt;
  111. struct flowi fl;
  112. u32 dst_ip = dst_in->sin_addr.s_addr;
  113. memset(&fl, 0, sizeof fl);
  114. fl.nl_u.ip4_u.daddr = dst_ip;
  115. if (ip_route_output_key(&rt, &fl))
  116. return;
  117. arp_send(ARPOP_REQUEST, ETH_P_ARP, rt->rt_gateway, rt->idev->dev,
  118. rt->rt_src, NULL, rt->idev->dev->dev_addr, NULL);
  119. ip_rt_put(rt);
  120. }
  121. static int addr_resolve_remote(struct sockaddr_in *src_in,
  122. struct sockaddr_in *dst_in,
  123. struct rdma_dev_addr *addr)
  124. {
  125. u32 src_ip = src_in->sin_addr.s_addr;
  126. u32 dst_ip = dst_in->sin_addr.s_addr;
  127. struct flowi fl;
  128. struct rtable *rt;
  129. struct neighbour *neigh;
  130. int ret;
  131. memset(&fl, 0, sizeof fl);
  132. fl.nl_u.ip4_u.daddr = dst_ip;
  133. fl.nl_u.ip4_u.saddr = src_ip;
  134. ret = ip_route_output_key(&rt, &fl);
  135. if (ret)
  136. goto out;
  137. /* If the device does ARP internally, return 'done' */
  138. if (rt->idev->dev->flags & IFF_NOARP) {
  139. copy_addr(addr, rt->idev->dev, NULL);
  140. goto put;
  141. }
  142. neigh = neigh_lookup(&arp_tbl, &rt->rt_gateway, rt->idev->dev);
  143. if (!neigh) {
  144. ret = -ENODATA;
  145. goto put;
  146. }
  147. if (!(neigh->nud_state & NUD_VALID)) {
  148. ret = -ENODATA;
  149. goto release;
  150. }
  151. if (!src_ip) {
  152. src_in->sin_family = dst_in->sin_family;
  153. src_in->sin_addr.s_addr = rt->rt_src;
  154. }
  155. ret = copy_addr(addr, neigh->dev, neigh->ha);
  156. release:
  157. neigh_release(neigh);
  158. put:
  159. ip_rt_put(rt);
  160. out:
  161. return ret;
  162. }
  163. static void process_req(void *data)
  164. {
  165. struct addr_req *req, *temp_req;
  166. struct sockaddr_in *src_in, *dst_in;
  167. struct list_head done_list;
  168. INIT_LIST_HEAD(&done_list);
  169. mutex_lock(&lock);
  170. list_for_each_entry_safe(req, temp_req, &req_list, list) {
  171. if (req->status) {
  172. src_in = (struct sockaddr_in *) &req->src_addr;
  173. dst_in = (struct sockaddr_in *) &req->dst_addr;
  174. req->status = addr_resolve_remote(src_in, dst_in,
  175. req->addr);
  176. }
  177. if (req->status && time_after(jiffies, req->timeout))
  178. req->status = -ETIMEDOUT;
  179. else if (req->status == -ENODATA)
  180. continue;
  181. list_del(&req->list);
  182. list_add_tail(&req->list, &done_list);
  183. }
  184. if (!list_empty(&req_list)) {
  185. req = list_entry(req_list.next, struct addr_req, list);
  186. set_timeout(req->timeout);
  187. }
  188. mutex_unlock(&lock);
  189. list_for_each_entry_safe(req, temp_req, &done_list, list) {
  190. list_del(&req->list);
  191. req->callback(req->status, &req->src_addr, req->addr,
  192. req->context);
  193. kfree(req);
  194. }
  195. }
  196. static int addr_resolve_local(struct sockaddr_in *src_in,
  197. struct sockaddr_in *dst_in,
  198. struct rdma_dev_addr *addr)
  199. {
  200. struct net_device *dev;
  201. u32 src_ip = src_in->sin_addr.s_addr;
  202. u32 dst_ip = dst_in->sin_addr.s_addr;
  203. int ret;
  204. dev = ip_dev_find(dst_ip);
  205. if (!dev)
  206. return -EADDRNOTAVAIL;
  207. if (ZERONET(src_ip)) {
  208. src_in->sin_family = dst_in->sin_family;
  209. src_in->sin_addr.s_addr = dst_ip;
  210. ret = copy_addr(addr, dev, dev->dev_addr);
  211. } else if (LOOPBACK(src_ip)) {
  212. ret = rdma_translate_ip((struct sockaddr *)dst_in, addr);
  213. if (!ret)
  214. memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
  215. } else {
  216. ret = rdma_translate_ip((struct sockaddr *)src_in, addr);
  217. if (!ret)
  218. memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
  219. }
  220. dev_put(dev);
  221. return ret;
  222. }
  223. int rdma_resolve_ip(struct sockaddr *src_addr, struct sockaddr *dst_addr,
  224. struct rdma_dev_addr *addr, int timeout_ms,
  225. void (*callback)(int status, struct sockaddr *src_addr,
  226. struct rdma_dev_addr *addr, void *context),
  227. void *context)
  228. {
  229. struct sockaddr_in *src_in, *dst_in;
  230. struct addr_req *req;
  231. int ret = 0;
  232. req = kmalloc(sizeof *req, GFP_KERNEL);
  233. if (!req)
  234. return -ENOMEM;
  235. memset(req, 0, sizeof *req);
  236. if (src_addr)
  237. memcpy(&req->src_addr, src_addr, ip_addr_size(src_addr));
  238. memcpy(&req->dst_addr, dst_addr, ip_addr_size(dst_addr));
  239. req->addr = addr;
  240. req->callback = callback;
  241. req->context = context;
  242. src_in = (struct sockaddr_in *) &req->src_addr;
  243. dst_in = (struct sockaddr_in *) &req->dst_addr;
  244. req->status = addr_resolve_local(src_in, dst_in, addr);
  245. if (req->status == -EADDRNOTAVAIL)
  246. req->status = addr_resolve_remote(src_in, dst_in, addr);
  247. switch (req->status) {
  248. case 0:
  249. req->timeout = jiffies;
  250. queue_req(req);
  251. break;
  252. case -ENODATA:
  253. req->timeout = msecs_to_jiffies(timeout_ms) + jiffies;
  254. queue_req(req);
  255. addr_send_arp(dst_in);
  256. break;
  257. default:
  258. ret = req->status;
  259. kfree(req);
  260. break;
  261. }
  262. return ret;
  263. }
  264. EXPORT_SYMBOL(rdma_resolve_ip);
  265. void rdma_addr_cancel(struct rdma_dev_addr *addr)
  266. {
  267. struct addr_req *req, *temp_req;
  268. mutex_lock(&lock);
  269. list_for_each_entry_safe(req, temp_req, &req_list, list) {
  270. if (req->addr == addr) {
  271. req->status = -ECANCELED;
  272. req->timeout = jiffies;
  273. list_del(&req->list);
  274. list_add(&req->list, &req_list);
  275. set_timeout(req->timeout);
  276. break;
  277. }
  278. }
  279. mutex_unlock(&lock);
  280. }
  281. EXPORT_SYMBOL(rdma_addr_cancel);
  282. static int addr_arp_recv(struct sk_buff *skb, struct net_device *dev,
  283. struct packet_type *pkt, struct net_device *orig_dev)
  284. {
  285. struct arphdr *arp_hdr;
  286. arp_hdr = (struct arphdr *) skb->nh.raw;
  287. if (arp_hdr->ar_op == htons(ARPOP_REQUEST) ||
  288. arp_hdr->ar_op == htons(ARPOP_REPLY))
  289. set_timeout(jiffies);
  290. kfree_skb(skb);
  291. return 0;
  292. }
  293. static struct packet_type addr_arp = {
  294. .type = __constant_htons(ETH_P_ARP),
  295. .func = addr_arp_recv,
  296. .af_packet_priv = (void*) 1,
  297. };
  298. static int addr_init(void)
  299. {
  300. addr_wq = create_singlethread_workqueue("ib_addr_wq");
  301. if (!addr_wq)
  302. return -ENOMEM;
  303. dev_add_pack(&addr_arp);
  304. return 0;
  305. }
  306. static void addr_cleanup(void)
  307. {
  308. dev_remove_pack(&addr_arp);
  309. destroy_workqueue(addr_wq);
  310. }
  311. module_init(addr_init);
  312. module_exit(addr_cleanup);