drivers/infiniband/core/addr.c

   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 available to you under a choice of one of two
   8  * licenses.  You may choose to be licensed under the terms of the GNU
   9  * General Public License (GPL) Version 2, available from the file
  10  * COPYING in the main directory of this source tree, or the
  11  * OpenIB.org BSD license below:
  12  *
  13  *     Redistribution and use in source and binary forms, with or
  14  *     without modification, are permitted provided that the following
  15  *     conditions are met:
  16  *
  17  *      - Redistributions of source code must retain the above
  18  *        copyright notice, this list of conditions and the following
  19  *        disclaimer.
  20  *
  21  *      - Redistributions in binary form must reproduce the above
  22  *        copyright notice, this list of conditions and the following
  23  *        disclaimer in the documentation and/or other materials
  24  *        provided with the distribution.
  25  *
  26  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  27  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  28  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  29  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  30  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  31  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  32  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  33  * SOFTWARE.
  34  */
  35
  36 #include <linux/mutex.h>
  37 #include <linux/inetdevice.h>
  38 #include <linux/workqueue.h>
  39 #include <linux/if_arp.h>
  40 #include <net/arp.h>
  41 #include <net/neighbour.h>
  42 #include <net/route.h>
  43 #include <net/netevent.h>
  44 #include <net/addrconf.h>
  45 #include <net/ip6_route.h>
  46 #include <rdma/ib_addr.h>
  47
  48 MODULE_AUTHOR("Sean Hefty");
  49 MODULE_DESCRIPTION("IB Address Translation");
  50 MODULE_LICENSE("Dual BSD/GPL");
  51
  52 struct addr_req {
  53         struct list_head list;
  54         struct sockaddr_storage src_addr;
  55         struct sockaddr_storage dst_addr;
  56         struct rdma_dev_addr *addr;
  57         struct rdma_addr_client *client;
  58         void *context;
  59         void (*callback)(int status, struct sockaddr *src_addr,
  60                          struct rdma_dev_addr *addr, void *context);
  61         unsigned long timeout;
  62         int status;
  63 };
  64
  65 static void process_req(struct work_struct *work);
  66
  67 static DEFINE_MUTEX(lock);
  68 static LIST_HEAD(req_list);
  69 static DECLARE_DELAYED_WORK(work, process_req);
  70 static struct workqueue_struct *addr_wq;
  71
  72 void rdma_addr_register_client(struct rdma_addr_client *client)
  73 {
  74         atomic_set(&client->refcount, 1);
  75         init_completion(&client->comp);
  76 }
  77 EXPORT_SYMBOL(rdma_addr_register_client);
  78
  79 static inline void put_client(struct rdma_addr_client *client)
  80 {
  81         if (atomic_dec_and_test(&client->refcount))
  82                 complete(&client->comp);
  83 }
  84
  85 void rdma_addr_unregister_client(struct rdma_addr_client *client)
  86 {
  87         put_client(client);
  88         wait_for_completion(&client->comp);
  89 }
  90 EXPORT_SYMBOL(rdma_addr_unregister_client);
  91
  92 int rdma_copy_addr(struct rdma_dev_addr *dev_addr, struct net_device *dev,
  93                      const unsigned char *dst_dev_addr)
  94 {
  95         switch (dev->type) {
  96         case ARPHRD_INFINIBAND:
  97                 dev_addr->dev_type = RDMA_NODE_IB_CA;
  98                 break;
  99         case ARPHRD_ETHER:
 100                 dev_addr->dev_type = RDMA_NODE_RNIC;
 101                 break;
 102         default:
 103                 return -EADDRNOTAVAIL;
 104         }
 105
 106         memcpy(dev_addr->src_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
 107         memcpy(dev_addr->broadcast, dev->broadcast, MAX_ADDR_LEN);
 108         if (dst_dev_addr)
 109                 memcpy(dev_addr->dst_dev_addr, dst_dev_addr, MAX_ADDR_LEN);
 110         dev_addr->bound_dev_if = dev->ifindex;
 111         return 0;
 112 }
 113 EXPORT_SYMBOL(rdma_copy_addr);
 114
 115 int rdma_translate_ip(struct sockaddr *addr, struct rdma_dev_addr *dev_addr)
 116 {
 117         struct net_device *dev;
 118         int ret = -EADDRNOTAVAIL;
 119
 120         if (dev_addr->bound_dev_if) {
 121                 dev = dev_get_by_index(&init_net, dev_addr->bound_dev_if);
 122                 if (!dev)
 123                         return -ENODEV;
 124                 ret = rdma_copy_addr(dev_addr, dev, NULL);
 125                 dev_put(dev);
 126                 return ret;
 127         }
 128
 129         switch (addr->sa_family) {
 130         case AF_INET:
 131                 dev = ip_dev_find(&init_net,
 132                         ((struct sockaddr_in *) addr)->sin_addr.s_addr);
 133
 134                 if (!dev)
 135                         return ret;
 136
 137                 ret = rdma_copy_addr(dev_addr, dev, NULL);
 138                 dev_put(dev);
 139                 break;
 140
 141 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 142         case AF_INET6:
 143                 read_lock(&dev_base_lock);
 144                 for_each_netdev(&init_net, dev) {
 145                         if (ipv6_chk_addr(&init_net,
 146                                           &((struct sockaddr_in6 *) addr)->sin6_addr,
 147                                           dev, 1)) {
 148                                 ret = rdma_copy_addr(dev_addr, dev, NULL);
 149                                 break;
 150                         }
 151                 }
 152                 read_unlock(&dev_base_lock);
 153                 break;
 154 #endif
 155         }
 156         return ret;
 157 }
 158 EXPORT_SYMBOL(rdma_translate_ip);
 159
 160 static void set_timeout(unsigned long time)
 161 {
 162         unsigned long delay;
 163
 164         cancel_delayed_work(&work);
 165
 166         delay = time - jiffies;
 167         if ((long)delay <= 0)
 168                 delay = 1;
 169
 170         queue_delayed_work(addr_wq, &work, delay);
 171 }
 172
 173 static void queue_req(struct addr_req *req)
 174 {
 175         struct addr_req *temp_req;
 176
 177         mutex_lock(&lock);
 178         list_for_each_entry_reverse(temp_req, &req_list, list) {
 179                 if (time_after_eq(req->timeout, temp_req->timeout))
 180                         break;
 181         }
 182
 183         list_add(&req->list, &temp_req->list);
 184
 185         if (req_list.next == &req->list)
 186                 set_timeout(req->timeout);
 187         mutex_unlock(&lock);
 188 }
 189
 190 static void addr_send_arp(struct sockaddr *dst_in)
 191 {
 192         struct rtable *rt;
 193         struct flowi fl;
 194
 195         memset(&fl, 0, sizeof fl);
 196
 197         switch (dst_in->sa_family) {
 198         case AF_INET:
 199                 fl.nl_u.ip4_u.daddr =
 200                         ((struct sockaddr_in *) dst_in)->sin_addr.s_addr;
 201
 202                 if (ip_route_output_key(&init_net, &rt, &fl))
 203                         return;
 204
 205                 neigh_event_send(rt->u.dst.neighbour, NULL);
 206                 ip_rt_put(rt);
 207                 break;
 208
 209 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 210         case AF_INET6:
 211         {
 212                 struct dst_entry *dst;
 213
 214                 fl.nl_u.ip6_u.daddr =
 215                         ((struct sockaddr_in6 *) dst_in)->sin6_addr;
 216
 217                 dst = ip6_route_output(&init_net, NULL, &fl);
 218                 if (!dst)
 219                         return;
 220
 221                 neigh_event_send(dst->neighbour, NULL);
 222                 dst_release(dst);
 223                 break;
 224         }
 225 #endif
 226         }
 227 }
 228
 229 static int addr4_resolve_remote(struct sockaddr_in *src_in,
 230                                struct sockaddr_in *dst_in,
 231                                struct rdma_dev_addr *addr)
 232 {
 233         __be32 src_ip = src_in->sin_addr.s_addr;
 234         __be32 dst_ip = dst_in->sin_addr.s_addr;
 235         struct flowi fl;
 236         struct rtable *rt;
 237         struct neighbour *neigh;
 238         int ret;
 239
 240         memset(&fl, 0, sizeof fl);
 241         fl.nl_u.ip4_u.daddr = dst_ip;
 242         fl.nl_u.ip4_u.saddr = src_ip;
 243         fl.oif = addr->bound_dev_if;
 244
 245         ret = ip_route_output_key(&init_net, &rt, &fl);
 246         if (ret)
 247                 goto out;
 248
 249         /* If the device does ARP internally, return 'done' */
 250         if (rt->idev->dev->flags & IFF_NOARP) {
 251                 rdma_copy_addr(addr, rt->idev->dev, NULL);
 252                 goto put;
 253         }
 254
 255         neigh = neigh_lookup(&arp_tbl, &rt->rt_gateway, rt->idev->dev);
 256         if (!neigh) {
 257                 ret = -ENODATA;
 258                 goto put;
 259         }
 260
 261         if (!(neigh->nud_state & NUD_VALID)) {
 262                 ret = -ENODATA;
 263                 goto release;
 264         }
 265
 266         if (!src_ip) {
 267                 src_in->sin_family = dst_in->sin_family;
 268                 src_in->sin_addr.s_addr = rt->rt_src;
 269         }
 270
 271         ret = rdma_copy_addr(addr, neigh->dev, neigh->ha);
 272 release:
 273         neigh_release(neigh);
 274 put:
 275         ip_rt_put(rt);
 276 out:
 277         return ret;
 278 }
 279
 280 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 281 static int addr6_resolve_remote(struct sockaddr_in6 *src_in,
 282                                struct sockaddr_in6 *dst_in,
 283                                struct rdma_dev_addr *addr)
 284 {
 285         struct flowi fl;
 286         struct neighbour *neigh;
 287         struct dst_entry *dst;
 288         int ret = -ENODATA;
 289
 290         memset(&fl, 0, sizeof fl);
 291         fl.nl_u.ip6_u.daddr = dst_in->sin6_addr;
 292         fl.nl_u.ip6_u.saddr = src_in->sin6_addr;
 293         fl.oif = addr->bound_dev_if;
 294
 295         dst = ip6_route_output(&init_net, NULL, &fl);
 296         if (!dst)
 297                 return ret;
 298
 299         if (dst->dev->flags & IFF_NOARP) {
 300                 ret = rdma_copy_addr(addr, dst->dev, NULL);
 301         } else {
 302                 neigh = dst->neighbour;
 303                 if (neigh && (neigh->nud_state & NUD_VALID))
 304                         ret = rdma_copy_addr(addr, neigh->dev, neigh->ha);
 305         }
 306
 307         dst_release(dst);
 308         return ret;
 309 }
 310 #else
 311 static int addr6_resolve_remote(struct sockaddr_in6 *src_in,
 312                                struct sockaddr_in6 *dst_in,
 313                                struct rdma_dev_addr *addr)
 314 {
 315         return -EADDRNOTAVAIL;
 316 }
 317 #endif
 318
 319 static int addr_resolve_remote(struct sockaddr *src_in,
 320                                 struct sockaddr *dst_in,
 321                                 struct rdma_dev_addr *addr)
 322 {
 323         if (src_in->sa_family == AF_INET) {
 324                 return addr4_resolve_remote((struct sockaddr_in *) src_in,
 325                         (struct sockaddr_in *) dst_in, addr);
 326         } else
 327                 return addr6_resolve_remote((struct sockaddr_in6 *) src_in,
 328                         (struct sockaddr_in6 *) dst_in, addr);
 329 }
 330
 331 static void process_req(struct work_struct *work)
 332 {
 333         struct addr_req *req, *temp_req;
 334         struct sockaddr *src_in, *dst_in;
 335         struct list_head done_list;
 336
 337         INIT_LIST_HEAD(&done_list);
 338
 339         mutex_lock(&lock);
 340         list_for_each_entry_safe(req, temp_req, &req_list, list) {
 341                 if (req->status == -ENODATA) {
 342                         src_in = (struct sockaddr *) &req->src_addr;
 343                         dst_in = (struct sockaddr *) &req->dst_addr;
 344                         req->status = addr_resolve_remote(src_in, dst_in,
 345                                                           req->addr);
 346                         if (req->status && time_after_eq(jiffies, req->timeout))
 347                                 req->status = -ETIMEDOUT;
 348                         else if (req->status == -ENODATA)
 349                                 continue;
 350                 }
 351                 list_move_tail(&req->list, &done_list);
 352         }
 353
 354         if (!list_empty(&req_list)) {
 355                 req = list_entry(req_list.next, struct addr_req, list);
 356                 set_timeout(req->timeout);
 357         }
 358         mutex_unlock(&lock);
 359
 360         list_for_each_entry_safe(req, temp_req, &done_list, list) {
 361                 list_del(&req->list);
 362                 req->callback(req->status, (struct sockaddr *) &req->src_addr,
 363                         req->addr, req->context);
 364                 put_client(req->client);
 365                 kfree(req);
 366         }
 367 }
 368
 369 static int addr_resolve_local(struct sockaddr *src_in,
 370                               struct sockaddr *dst_in,
 371                               struct rdma_dev_addr *addr)
 372 {
 373         struct net_device *dev;
 374         int ret;
 375
 376         switch (dst_in->sa_family) {
 377         case AF_INET:
 378         {
 379                 __be32 src_ip = ((struct sockaddr_in *) src_in)->sin_addr.s_addr;
 380                 __be32 dst_ip = ((struct sockaddr_in *) dst_in)->sin_addr.s_addr;
 381
 382                 dev = ip_dev_find(&init_net, dst_ip);
 383                 if (!dev)
 384                         return -EADDRNOTAVAIL;
 385
 386                 if (ipv4_is_zeronet(src_ip)) {
 387                         src_in->sa_family = dst_in->sa_family;
 388                         ((struct sockaddr_in *) src_in)->sin_addr.s_addr = dst_ip;
 389                         ret = rdma_copy_addr(addr, dev, dev->dev_addr);
 390                 } else if (ipv4_is_loopback(src_ip)) {
 391                         ret = rdma_translate_ip(dst_in, addr);
 392                         if (!ret)
 393                                 memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
 394                 } else {
 395                         ret = rdma_translate_ip(src_in, addr);
 396                         if (!ret)
 397                                 memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
 398                 }
 399                 dev_put(dev);
 400                 break;
 401         }
 402
 403 #if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
 404         case AF_INET6:
 405         {
 406                 struct in6_addr *a;
 407
 408                 read_lock(&dev_base_lock);
 409                 for_each_netdev(&init_net, dev)
 410                         if (ipv6_chk_addr(&init_net,
 411                                           &((struct sockaddr_in6 *) dst_in)->sin6_addr,
 412                                           dev, 1))
 413                                 break;
 414
 415                 if (!dev) {
 416                         read_unlock(&dev_base_lock);
 417                         return -EADDRNOTAVAIL;
 418                 }
 419
 420                 a = &((struct sockaddr_in6 *) src_in)->sin6_addr;
 421
 422                 if (ipv6_addr_any(a)) {
 423                         src_in->sa_family = dst_in->sa_family;
 424                         ((struct sockaddr_in6 *) src_in)->sin6_addr =
 425                                 ((struct sockaddr_in6 *) dst_in)->sin6_addr;
 426                         ret = rdma_copy_addr(addr, dev, dev->dev_addr);
 427                 } else if (ipv6_addr_loopback(a)) {
 428                         ret = rdma_translate_ip(dst_in, addr);
 429                         if (!ret)
 430                                 memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
 431                 } else  {
 432                         ret = rdma_translate_ip(src_in, addr);
 433                         if (!ret)
 434                                 memcpy(addr->dst_dev_addr, dev->dev_addr, MAX_ADDR_LEN);
 435                 }
 436                 read_unlock(&dev_base_lock);
 437                 break;
 438         }
 439 #endif
 440
 441         default:
 442                 ret = -EADDRNOTAVAIL;
 443                 break;
 444         }
 445
 446         return ret;
 447 }
 448
 449 int rdma_resolve_ip(struct rdma_addr_client *client,
 450                     struct sockaddr *src_addr, struct sockaddr *dst_addr,
 451                     struct rdma_dev_addr *addr, int timeout_ms,
 452                     void (*callback)(int status, struct sockaddr *src_addr,
 453                                      struct rdma_dev_addr *addr, void *context),
 454                     void *context)
 455 {
 456         struct sockaddr *src_in, *dst_in;
 457         struct addr_req *req;
 458         int ret = 0;
 459
 460         req = kzalloc(sizeof *req, GFP_KERNEL);
 461         if (!req)
 462                 return -ENOMEM;
 463
 464         if (src_addr)
 465                 memcpy(&req->src_addr, src_addr, ip_addr_size(src_addr));
 466         memcpy(&req->dst_addr, dst_addr, ip_addr_size(dst_addr));
 467         req->addr = addr;
 468         req->callback = callback;
 469         req->context = context;
 470         req->client = client;
 471         atomic_inc(&client->refcount);
 472
 473         src_in = (struct sockaddr *) &req->src_addr;
 474         dst_in = (struct sockaddr *) &req->dst_addr;
 475
 476         req->status = addr_resolve_local(src_in, dst_in, addr);
 477         if (req->status == -EADDRNOTAVAIL)
 478                 req->status = addr_resolve_remote(src_in, dst_in, addr);
 479
 480         switch (req->status) {
 481         case 0:
 482                 req->timeout = jiffies;
 483                 queue_req(req);
 484                 break;
 485         case -ENODATA:
 486                 req->timeout = msecs_to_jiffies(timeout_ms) + jiffies;
 487                 queue_req(req);
 488                 addr_send_arp(dst_in);
 489                 break;
 490         default:
 491                 ret = req->status;
 492                 atomic_dec(&client->refcount);
 493                 kfree(req);
 494                 break;
 495         }
 496         return ret;
 497 }
 498 EXPORT_SYMBOL(rdma_resolve_ip);
 499
 500 void rdma_addr_cancel(struct rdma_dev_addr *addr)
 501 {
 502         struct addr_req *req, *temp_req;
 503
 504         mutex_lock(&lock);
 505         list_for_each_entry_safe(req, temp_req, &req_list, list) {
 506                 if (req->addr == addr) {
 507                         req->status = -ECANCELED;
 508                         req->timeout = jiffies;
 509                         list_move(&req->list, &req_list);
 510                         set_timeout(req->timeout);
 511                         break;
 512                 }
 513         }
 514         mutex_unlock(&lock);
 515 }
 516 EXPORT_SYMBOL(rdma_addr_cancel);
 517
 518 static int netevent_callback(struct notifier_block *self, unsigned long event,
 519         void *ctx)
 520 {
 521         if (event == NETEVENT_NEIGH_UPDATE) {
 522                 struct neighbour *neigh = ctx;
 523
 524                 if (neigh->nud_state & NUD_VALID) {
 525                         set_timeout(jiffies);
 526                 }
 527         }
 528         return 0;
 529 }
 530
 531 static struct notifier_block nb = {
 532         .notifier_call = netevent_callback
 533 };
 534
 535 static int __init addr_init(void)
 536 {
 537         addr_wq = create_singlethread_workqueue("ib_addr");
 538         if (!addr_wq)
 539                 return -ENOMEM;
 540
 541         register_netevent_notifier(&nb);
 542         return 0;
 543 }
 544
 545 static void __exit addr_cleanup(void)
 546 {
 547         unregister_netevent_notifier(&nb);
 548         destroy_workqueue(addr_wq);
 549 }
 550
 551 module_init(addr_init);
 552 module_exit(addr_cleanup);