sys/ofed/drivers/infiniband/core/ib_addr.c

   1 /*-
   2  * SPDX-License-Identifier: BSD-2-Clause OR GPL-2.0
   3  *
   4  * Copyright (c) 2005 Voltaire Inc.  All rights reserved.
   5  * Copyright (c) 2002-2005, Network Appliance, Inc. All rights reserved.
   6  * Copyright (c) 1999-2019, Mellanox Technologies, Inc. All rights reserved.
   7  * Copyright (c) 2005 Intel Corporation.  All rights reserved.
   8  *
   9  * This software is available to you under a choice of one of two
  10  * licenses.  You may choose to be licensed under the terms of the GNU
  11  * General Public License (GPL) Version 2, available from the file
  12  * COPYING in the main directory of this source tree, or the
  13  * OpenIB.org BSD license below:
  14  *
  15  *     Redistribution and use in source and binary forms, with or
  16  *     without modification, are permitted provided that the following
  17  *     conditions are met:
  18  *
  19  *      - Redistributions of source code must retain the above
  20  *        copyright notice, this list of conditions and the following
  21  *        disclaimer.
  22  *
  23  *      - Redistributions in binary form must reproduce the above
  24  *        copyright notice, this list of conditions and the following
  25  *        disclaimer in the documentation and/or other materials
  26  *        provided with the distribution.
  27  *
  28  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  29  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  30  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  31  * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
  32  * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
  33  * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
  34  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  35  * SOFTWARE.
  36  */
  37
  38 #include <sys/cdefs.h>
  39 __FBSDID("$FreeBSD$");
  40
  41 #include <linux/mutex.h>
  42 #include <linux/inetdevice.h>
  43 #include <linux/slab.h>
  44 #include <linux/workqueue.h>
  45 #include <linux/module.h>
  46 #include <net/route.h>
  47 #include <net/route/nhop.h>
  48 #include <net/netevent.h>
  49 #include <rdma/ib_addr.h>
  50 #include <rdma/ib.h>
  51
  52 #include <netinet/in_fib.h>
  53 #include <netinet/if_ether.h>
  54 #include <netinet/ip_var.h>
  55 #include <netinet6/scope6_var.h>
  56 #include <netinet6/in6_pcb.h>
  57 #include <netinet6/in6_fib.h>
  58
  59 #include "core_priv.h"
  60
  61 struct addr_req {
  62         struct list_head list;
  63         struct sockaddr_storage src_addr;
  64         struct sockaddr_storage dst_addr;
  65         struct rdma_dev_addr *addr;
  66         struct rdma_addr_client *client;
  67         void *context;
  68         void (*callback)(int status, struct sockaddr *src_addr,
  69                          struct rdma_dev_addr *addr, void *context);
  70         int timeout;
  71         int status;
  72 };
  73
  74 static void process_req(struct work_struct *work);
  75
  76 static DEFINE_MUTEX(lock);
  77 static LIST_HEAD(req_list);
  78 static DECLARE_DELAYED_WORK(work, process_req);
  79 static struct workqueue_struct *addr_wq;
  80
  81 int rdma_addr_size(struct sockaddr *addr)
  82 {
  83         switch (addr->sa_family) {
  84         case AF_INET:
  85                 return sizeof(struct sockaddr_in);
  86         case AF_INET6:
  87                 return sizeof(struct sockaddr_in6);
  88         case AF_IB:
  89                 return sizeof(struct sockaddr_ib);
  90         default:
  91                 return 0;
  92         }
  93 }
  94 EXPORT_SYMBOL(rdma_addr_size);
  95
  96 int rdma_addr_size_in6(struct sockaddr_in6 *addr)
  97 {
  98         int ret = rdma_addr_size((struct sockaddr *) addr);
  99
 100         return ret <= sizeof(*addr) ? ret : 0;
 101 }
 102 EXPORT_SYMBOL(rdma_addr_size_in6);
 103
 104 int rdma_addr_size_kss(struct sockaddr_storage *addr)
 105 {
 106         int ret = rdma_addr_size((struct sockaddr *) addr);
 107
 108         return ret <= sizeof(*addr) ? ret : 0;
 109 }
 110 EXPORT_SYMBOL(rdma_addr_size_kss);
 111
 112 static struct rdma_addr_client self;
 113
 114 void rdma_addr_register_client(struct rdma_addr_client *client)
 115 {
 116         atomic_set(&client->refcount, 1);
 117         init_completion(&client->comp);
 118 }
 119 EXPORT_SYMBOL(rdma_addr_register_client);
 120
 121 static inline void put_client(struct rdma_addr_client *client)
 122 {
 123         if (atomic_dec_and_test(&client->refcount))
 124                 complete(&client->comp);
 125 }
 126
 127 void rdma_addr_unregister_client(struct rdma_addr_client *client)
 128 {
 129         put_client(client);
 130         wait_for_completion(&client->comp);
 131 }
 132 EXPORT_SYMBOL(rdma_addr_unregister_client);
 133
 134 static inline void
 135 rdma_copy_addr_sub(u8 *dst, const u8 *src, unsigned min, unsigned max)
 136 {
 137         if (min > max)
 138                 min = max;
 139         memcpy(dst, src, min);
 140         memset(dst + min, 0, max - min);
 141 }
 142
 143 int rdma_copy_addr(struct rdma_dev_addr *dev_addr, struct net_device *dev,
 144                      const unsigned char *dst_dev_addr)
 145 {
 146         /* check for loopback device */
 147         if (dev->if_flags & IFF_LOOPBACK) {
 148                 dev_addr->dev_type = ARPHRD_ETHER;
 149                 memset(dev_addr->src_dev_addr, 0, MAX_ADDR_LEN);
 150                 memset(dev_addr->broadcast, 0, MAX_ADDR_LEN);
 151                 memset(dev_addr->dst_dev_addr, 0, MAX_ADDR_LEN);
 152                 dev_addr->bound_dev_if = dev->if_index;
 153                 return (0);
 154         } else if (dev->if_type == IFT_INFINIBAND)
 155                 dev_addr->dev_type = ARPHRD_INFINIBAND;
 156         else if (dev->if_type == IFT_ETHER)
 157                 dev_addr->dev_type = ARPHRD_ETHER;
 158         else
 159                 dev_addr->dev_type = 0;
 160         rdma_copy_addr_sub(dev_addr->src_dev_addr, IF_LLADDR(dev),
 161                            dev->if_addrlen, MAX_ADDR_LEN);
 162         rdma_copy_addr_sub(dev_addr->broadcast, dev->if_broadcastaddr,
 163                            dev->if_addrlen, MAX_ADDR_LEN);
 164         if (dst_dev_addr != NULL) {
 165                 rdma_copy_addr_sub(dev_addr->dst_dev_addr, dst_dev_addr,
 166                                    dev->if_addrlen, MAX_ADDR_LEN);
 167         }
 168         dev_addr->bound_dev_if = dev->if_index;
 169         return 0;
 170 }
 171 EXPORT_SYMBOL(rdma_copy_addr);
 172
 173 int rdma_translate_ip(const struct sockaddr *addr,
 174                       struct rdma_dev_addr *dev_addr)
 175 {
 176         struct net_device *dev;
 177         int ret;
 178
 179         if (dev_addr->bound_dev_if) {
 180                 dev = dev_get_by_index(dev_addr->net, dev_addr->bound_dev_if);
 181         } else switch (addr->sa_family) {
 182 #ifdef INET
 183         case AF_INET:
 184                 dev = ip_dev_find(dev_addr->net,
 185                         ((const struct sockaddr_in *)addr)->sin_addr.s_addr);
 186                 break;
 187 #endif
 188 #ifdef INET6
 189         case AF_INET6:
 190                 dev = ip6_dev_find(dev_addr->net,
 191                         ((const struct sockaddr_in6 *)addr)->sin6_addr, 0);
 192                 break;
 193 #endif
 194         default:
 195                 dev = NULL;
 196                 break;
 197         }
 198
 199         if (dev != NULL) {
 200                 /* disallow connections through 127.0.0.1 itself */
 201                 if (dev->if_flags & IFF_LOOPBACK)
 202                         ret = -EINVAL;
 203                 else
 204                         ret = rdma_copy_addr(dev_addr, dev, NULL);
 205                 dev_put(dev);
 206         } else {
 207                 ret = -ENODEV;
 208         }
 209         return ret;
 210 }
 211 EXPORT_SYMBOL(rdma_translate_ip);
 212
 213 static void set_timeout(int time)
 214 {
 215         int delay;      /* under FreeBSD ticks are 32-bit */
 216
 217         delay = time - jiffies;
 218         if (delay <= 0)
 219                 delay = 1;
 220         else if (delay > hz)
 221                 delay = hz;
 222
 223         mod_delayed_work(addr_wq, &work, delay);
 224 }
 225
 226 static void queue_req(struct addr_req *req)
 227 {
 228         struct addr_req *temp_req;
 229
 230         mutex_lock(&lock);
 231         list_for_each_entry_reverse(temp_req, &req_list, list) {
 232                 if (time_after_eq(req->timeout, temp_req->timeout))
 233                         break;
 234         }
 235
 236         list_add(&req->list, &temp_req->list);
 237
 238         if (req_list.next == &req->list)
 239                 set_timeout(req->timeout);
 240         mutex_unlock(&lock);
 241 }
 242
 243 #if defined(INET) || defined(INET6)
 244 static int addr_resolve_multi(u8 *edst, struct ifnet *ifp, struct sockaddr *dst_in)
 245 {
 246         struct sockaddr *llsa;
 247         struct sockaddr_dl sdl;
 248         int error;
 249
 250         sdl.sdl_len = sizeof(sdl);
 251         llsa = (struct sockaddr *)&sdl;
 252
 253         if (ifp->if_resolvemulti == NULL) {
 254                 error = EOPNOTSUPP;
 255         } else {
 256                 error = ifp->if_resolvemulti(ifp, &llsa, dst_in);
 257                 if (error == 0) {
 258                         rdma_copy_addr_sub(edst, LLADDR((struct sockaddr_dl *)llsa),
 259                             ifp->if_addrlen, MAX_ADDR_LEN);
 260                 }
 261         }
 262         return (error);
 263 }
 264 #endif
 265
 266 #ifdef INET
 267 static int addr4_resolve(struct sockaddr_in *src_in,
 268                          const struct sockaddr_in *dst_in,
 269                          struct rdma_dev_addr *addr,
 270                          u8 *edst,
 271                          struct ifnet **ifpp)
 272 {
 273         enum {
 274                 ADDR_VALID = 0,
 275                 ADDR_SRC_ANY = 1,
 276                 ADDR_DST_ANY = 2,
 277         };
 278         struct sockaddr_in dst_tmp = *dst_in;
 279         in_port_t src_port;
 280         struct sockaddr *saddr = NULL;
 281         struct nhop_object *nh;
 282         struct ifnet *ifp;
 283         int error;
 284         int type;
 285
 286         NET_EPOCH_ASSERT();
 287
 288         /* set VNET, if any */
 289         CURVNET_SET(addr->net);
 290
 291         /* set default TTL limit */
 292         addr->hoplimit = V_ip_defttl;
 293
 294         type = ADDR_VALID;
 295         if (src_in->sin_addr.s_addr == INADDR_ANY)
 296                 type |= ADDR_SRC_ANY;
 297         if (dst_tmp.sin_addr.s_addr == INADDR_ANY)
 298                 type |= ADDR_DST_ANY;
 299
 300         /*
 301          * Make sure the socket address length field is set.
 302          */
 303         dst_tmp.sin_len = sizeof(dst_tmp);
 304
 305         /* Step 1 - lookup destination route if any */
 306         switch (type) {
 307         case ADDR_VALID:
 308         case ADDR_SRC_ANY:
 309                 /* regular destination route lookup */
 310                 nh = fib4_lookup(RT_DEFAULT_FIB, dst_tmp.sin_addr,0,NHR_NONE,0);
 311                 if (nh == NULL) {
 312                         error = EHOSTUNREACH;
 313                         goto done;
 314                 }
 315                 break;
 316         default:
 317                 error = ENETUNREACH;
 318                 goto done;
 319         }
 320
 321         /* Step 2 - find outgoing network interface */
 322         switch (type) {
 323         case ADDR_VALID:
 324                 /* get source interface */
 325                 if (addr->bound_dev_if != 0) {
 326                         ifp = dev_get_by_index(addr->net, addr->bound_dev_if);
 327                 } else {
 328                         ifp = ip_dev_find(addr->net, src_in->sin_addr.s_addr);
 329                 }
 330
 331                 /* check source interface */
 332                 if (ifp == NULL) {
 333                         error = ENETUNREACH;
 334                         goto done;
 335                 } else if (ifp->if_flags & IFF_LOOPBACK) {
 336                         /*
 337                          * Source address cannot be a loopback device.
 338                          */
 339                         error = EHOSTUNREACH;
 340                         goto error_put_ifp;
 341                 } else if (nh->nh_ifp->if_flags & IFF_LOOPBACK) {
 342                         if (memcmp(&src_in->sin_addr, &dst_in->sin_addr,
 343                             sizeof(src_in->sin_addr))) {
 344                                 /*
 345                                  * Destination is loopback, but source
 346                                  * and destination address is not the
 347                                  * same.
 348                                  */
 349                                 error = EHOSTUNREACH;
 350                                 goto error_put_ifp;
 351                         }
 352                         /* get destination network interface from route */
 353                         dev_put(ifp);
 354                         ifp = nh->nh_ifp;
 355                         dev_hold(ifp);
 356                 } else if (ifp != nh->nh_ifp) {
 357                         /*
 358                          * Source and destination interfaces are
 359                          * different.
 360                          */
 361                         error = ENETUNREACH;
 362                         goto error_put_ifp;
 363                 }
 364                 break;
 365         case ADDR_SRC_ANY:
 366                 /* check for loopback device */
 367                 if (nh->nh_ifp->if_flags & IFF_LOOPBACK)
 368                         saddr = (struct sockaddr *)&dst_tmp;
 369                 else
 370                         saddr = nh->nh_ifa->ifa_addr;
 371
 372                 /* get destination network interface from route */
 373                 ifp = nh->nh_ifp;
 374                 dev_hold(ifp);
 375                 break;
 376         default:
 377                 break;
 378         }
 379
 380         /*
 381          * Step 3 - resolve destination MAC address
 382          */
 383         if (dst_tmp.sin_addr.s_addr == INADDR_BROADCAST) {
 384                 rdma_copy_addr_sub(edst, ifp->if_broadcastaddr,
 385                     ifp->if_addrlen, MAX_ADDR_LEN);
 386                 error = 0;
 387         } else if (IN_MULTICAST(ntohl(dst_tmp.sin_addr.s_addr))) {
 388                 bool is_gw = (nh->nh_flags & NHF_GATEWAY) != 0;
 389                 error = addr_resolve_multi(edst, ifp, (struct sockaddr *)&dst_tmp);
 390                 if (error != 0)
 391                         goto error_put_ifp;
 392                 else if (is_gw)
 393                         addr->network = RDMA_NETWORK_IPV4;
 394         } else if (ifp->if_flags & IFF_LOOPBACK) {
 395                 memset(edst, 0, MAX_ADDR_LEN);
 396                 error = 0;
 397         } else {
 398                 bool is_gw = (nh->nh_flags & NHF_GATEWAY) != 0;
 399                 memset(edst, 0, MAX_ADDR_LEN);
 400                 error = arpresolve(ifp, is_gw, NULL, is_gw ?
 401                     &nh->gw_sa : (const struct sockaddr *)&dst_tmp,
 402                     edst, NULL, NULL);
 403                 if (error != 0)
 404                         goto error_put_ifp;
 405                 else if (is_gw)
 406                         addr->network = RDMA_NETWORK_IPV4;
 407         }
 408
 409         /*
 410          * Step 4 - update source address, if any
 411          */
 412         if (saddr != NULL) {
 413                 src_port = src_in->sin_port;
 414                 memcpy(src_in, saddr, rdma_addr_size(saddr));
 415                 src_in->sin_port = src_port;    /* preserve port number */
 416         }
 417
 418         *ifpp = ifp;
 419
 420         goto done;
 421
 422 error_put_ifp:
 423         dev_put(ifp);
 424 done:
 425         CURVNET_RESTORE();
 426
 427         if (error == EWOULDBLOCK || error == EAGAIN)
 428                 error = ENODATA;
 429         return (-error);
 430 }
 431 #else
 432 static int addr4_resolve(struct sockaddr_in *src_in,
 433                          const struct sockaddr_in *dst_in,
 434                          struct rdma_dev_addr *addr,
 435                          u8 *edst,
 436                          struct ifnet **ifpp)
 437 {
 438         return -EADDRNOTAVAIL;
 439 }
 440 #endif
 441
 442 #ifdef INET6
 443 static int addr6_resolve(struct sockaddr_in6 *src_in,
 444                          const struct sockaddr_in6 *dst_in,
 445                          struct rdma_dev_addr *addr,
 446                          u8 *edst,
 447                          struct ifnet **ifpp)
 448 {
 449         enum {
 450                 ADDR_VALID = 0,
 451                 ADDR_SRC_ANY = 1,
 452                 ADDR_DST_ANY = 2,
 453         };
 454         struct sockaddr_in6 dst_tmp = *dst_in;
 455         in_port_t src_port;
 456         struct sockaddr *saddr = NULL;
 457         struct nhop_object *nh;
 458         struct ifnet *ifp;
 459         int error;
 460         int type;
 461
 462         NET_EPOCH_ASSERT();
 463
 464         /* set VNET, if any */
 465         CURVNET_SET(addr->net);
 466
 467         /* set default TTL limit */
 468         addr->hoplimit = V_ip_defttl;
 469
 470         type = ADDR_VALID;
 471         if (ipv6_addr_any(&src_in->sin6_addr))
 472                 type |= ADDR_SRC_ANY;
 473         if (ipv6_addr_any(&dst_tmp.sin6_addr))
 474                 type |= ADDR_DST_ANY;
 475
 476         /*
 477          * Make sure the socket address length field is set.
 478          */
 479         dst_tmp.sin6_len = sizeof(dst_tmp);
 480
 481         /*
 482          * Make sure the scope ID gets embedded, else nd6_resolve() will
 483          * not find the record.
 484          */
 485         dst_tmp.sin6_scope_id = addr->bound_dev_if;
 486         sa6_embedscope(&dst_tmp, 0);
 487
 488         /* Step 1 - lookup destination route if any */
 489         switch (type) {
 490         case ADDR_VALID:
 491                 /* sanity check for IPv4 addresses */
 492                 if (ipv6_addr_v4mapped(&src_in->sin6_addr) !=
 493                     ipv6_addr_v4mapped(&dst_tmp.sin6_addr)) {
 494                         error = EAFNOSUPPORT;
 495                         goto done;
 496                 }
 497                 /* FALLTHROUGH */
 498         case ADDR_SRC_ANY:
 499                 /* regular destination route lookup */
 500                 nh = fib6_lookup(RT_DEFAULT_FIB, &dst_in->sin6_addr,
 501                     addr->bound_dev_if, NHR_NONE, 0);
 502                 if (nh == NULL) {
 503                         error = EHOSTUNREACH;
 504                         goto done;
 505                 }
 506                 break;
 507         default:
 508                 error = ENETUNREACH;
 509                 goto done;
 510         }
 511
 512         /* Step 2 - find outgoing network interface */
 513         switch (type) {
 514         case ADDR_VALID:
 515                 /* get source interface */
 516                 if (addr->bound_dev_if != 0) {
 517                         ifp = dev_get_by_index(addr->net, addr->bound_dev_if);
 518                 } else {
 519                         ifp = ip6_dev_find(addr->net, src_in->sin6_addr, 0);
 520                 }
 521
 522                 /* check source interface */
 523                 if (ifp == NULL) {
 524                         error = ENETUNREACH;
 525                         goto done;
 526                 } else if (ifp->if_flags & IFF_LOOPBACK) {
 527                         /*
 528                          * Source address cannot be a loopback device.
 529                          */
 530                         error = EHOSTUNREACH;
 531                         goto error_put_ifp;
 532                 } else if (nh->nh_ifp->if_flags & IFF_LOOPBACK) {
 533                         if (memcmp(&src_in->sin6_addr, &dst_in->sin6_addr,
 534                             sizeof(src_in->sin6_addr))) {
 535                                 /*
 536                                  * Destination is loopback, but source
 537                                  * and destination address is not the
 538                                  * same.
 539                                  */
 540                                 error = EHOSTUNREACH;
 541                                 goto error_put_ifp;
 542                         }
 543                         /* get destination network interface from route */
 544                         dev_put(ifp);
 545                         ifp = nh->nh_ifp;
 546                         dev_hold(ifp);
 547                 } else if (ifp != nh->nh_ifp) {
 548                         /*
 549                          * Source and destination interfaces are
 550                          * different.
 551                          */
 552                         error = ENETUNREACH;
 553                         goto error_put_ifp;
 554                 }
 555                 break;
 556         case ADDR_SRC_ANY:
 557                 /* check for loopback device */
 558                 if (nh->nh_ifp->if_flags & IFF_LOOPBACK)
 559                         saddr = (struct sockaddr *)&dst_tmp;
 560                 else
 561                         saddr = nh->nh_ifa->ifa_addr;
 562
 563                 /* get destination network interface from route */
 564                 ifp = nh->nh_ifp;
 565                 dev_hold(ifp);
 566                 break;
 567         default:
 568                 break;
 569         }
 570
 571         /*
 572          * Step 3 - resolve destination MAC address
 573          */
 574         if (IN6_IS_ADDR_MULTICAST(&dst_tmp.sin6_addr)) {
 575                 bool is_gw = (nh->nh_flags & NHF_GATEWAY) != 0;
 576                 error = addr_resolve_multi(edst, ifp,
 577                     (struct sockaddr *)&dst_tmp);
 578                 if (error != 0)
 579                         goto error_put_ifp;
 580                 else if (is_gw)
 581                         addr->network = RDMA_NETWORK_IPV6;
 582         } else if (nh->nh_ifp->if_flags & IFF_LOOPBACK) {
 583                 memset(edst, 0, MAX_ADDR_LEN);
 584                 error = 0;
 585         } else {
 586                 bool is_gw = (nh->nh_flags & NHF_GATEWAY) != 0;
 587                 memset(edst, 0, MAX_ADDR_LEN);
 588                 error = nd6_resolve(ifp, is_gw, NULL, is_gw ?
 589                     &nh->gw_sa : (const struct sockaddr *)&dst_tmp,
 590                     edst, NULL, NULL);
 591                 if (error != 0)
 592                         goto error_put_ifp;
 593                 else if (is_gw)
 594                         addr->network = RDMA_NETWORK_IPV6;
 595         }
 596
 597         /*
 598          * Step 4 - update source address, if any
 599          */
 600         if (saddr != NULL) {
 601                 src_port = src_in->sin6_port;
 602                 memcpy(src_in, saddr, rdma_addr_size(saddr));
 603                 src_in->sin6_port = src_port;   /* preserve port number */
 604         }
 605
 606         *ifpp = ifp;
 607
 608         goto done;
 609
 610 error_put_ifp:
 611         dev_put(ifp);
 612 done:
 613         CURVNET_RESTORE();
 614
 615         if (error == EWOULDBLOCK || error == EAGAIN)
 616                 error = ENODATA;
 617         return (-error);
 618 }
 619 #else
 620 static int addr6_resolve(struct sockaddr_in6 *src_in,
 621                          const struct sockaddr_in6 *dst_in,
 622                          struct rdma_dev_addr *addr,
 623                          u8 *edst,
 624                          struct ifnet **ifpp)
 625 {
 626         return -EADDRNOTAVAIL;
 627 }
 628 #endif
 629
 630 static int addr_resolve_neigh(struct ifnet *dev,
 631                               const struct sockaddr *dst_in,
 632                               u8 *edst,
 633                               struct rdma_dev_addr *addr)
 634 {
 635         if (dev->if_flags & IFF_LOOPBACK) {
 636                 int ret;
 637
 638                 /*
 639                  * Binding to a loopback device is not allowed. Make
 640                  * sure the destination device address is global by
 641                  * clearing the bound device interface:
 642                  */
 643                 if (addr->bound_dev_if == dev->if_index)
 644                         addr->bound_dev_if = 0;
 645
 646                 ret = rdma_translate_ip(dst_in, addr);
 647                 if (ret == 0) {
 648                         memcpy(addr->dst_dev_addr, addr->src_dev_addr,
 649                                MAX_ADDR_LEN);
 650                 }
 651                 return ret;
 652         }
 653
 654         /* If the device doesn't do ARP internally */
 655         if (!(dev->if_flags & IFF_NOARP))
 656                 return rdma_copy_addr(addr, dev, edst);
 657
 658         return rdma_copy_addr(addr, dev, NULL);
 659 }
 660
 661 static int addr_resolve(struct sockaddr *src_in,
 662                         const struct sockaddr *dst_in,
 663                         struct rdma_dev_addr *addr)
 664 {
 665         struct epoch_tracker et;
 666         struct net_device *ndev = NULL;
 667         u8 edst[MAX_ADDR_LEN];
 668         int ret;
 669
 670         if (dst_in->sa_family != src_in->sa_family)
 671                 return -EINVAL;
 672
 673         NET_EPOCH_ENTER(et);
 674         switch (src_in->sa_family) {
 675         case AF_INET:
 676                 ret = addr4_resolve((struct sockaddr_in *)src_in,
 677                                     (const struct sockaddr_in *)dst_in,
 678                                     addr, edst, &ndev);
 679                 break;
 680         case AF_INET6:
 681                 ret = addr6_resolve((struct sockaddr_in6 *)src_in,
 682                                     (const struct sockaddr_in6 *)dst_in, addr,
 683                                     edst, &ndev);
 684                 break;
 685         default:
 686                 ret = -EADDRNOTAVAIL;
 687                 break;
 688         }
 689         NET_EPOCH_EXIT(et);
 690
 691         /* check for error */
 692         if (ret != 0)
 693                 return ret;
 694
 695         /* store MAC addresses and check for loopback */
 696         ret = addr_resolve_neigh(ndev, dst_in, edst, addr);
 697
 698         /* set belonging VNET, if any */
 699         addr->net = dev_net(ndev);
 700         dev_put(ndev);
 701
 702         return ret;
 703 }
 704
 705 static void process_req(struct work_struct *work)
 706 {
 707         struct addr_req *req, *temp_req;
 708         struct sockaddr *src_in, *dst_in;
 709         struct list_head done_list;
 710
 711         INIT_LIST_HEAD(&done_list);
 712
 713         mutex_lock(&lock);
 714         list_for_each_entry_safe(req, temp_req, &req_list, list) {
 715                 if (req->status == -ENODATA) {
 716                         src_in = (struct sockaddr *) &req->src_addr;
 717                         dst_in = (struct sockaddr *) &req->dst_addr;
 718                         req->status = addr_resolve(src_in, dst_in, req->addr);
 719                         if (req->status && time_after_eq(jiffies, req->timeout))
 720                                 req->status = -ETIMEDOUT;
 721                         else if (req->status == -ENODATA)
 722                                 continue;
 723                 }
 724                 list_move_tail(&req->list, &done_list);
 725         }
 726
 727         if (!list_empty(&req_list)) {
 728                 req = list_entry(req_list.next, struct addr_req, list);
 729                 set_timeout(req->timeout);
 730         }
 731         mutex_unlock(&lock);
 732
 733         list_for_each_entry_safe(req, temp_req, &done_list, list) {
 734                 list_del(&req->list);
 735                 req->callback(req->status, (struct sockaddr *) &req->src_addr,
 736                         req->addr, req->context);
 737                 put_client(req->client);
 738                 kfree(req);
 739         }
 740 }
 741
 742 int rdma_resolve_ip(struct rdma_addr_client *client,
 743                     struct sockaddr *src_addr, struct sockaddr *dst_addr,
 744                     struct rdma_dev_addr *addr, int timeout_ms,
 745                     void (*callback)(int status, struct sockaddr *src_addr,
 746                                      struct rdma_dev_addr *addr, void *context),
 747                     void *context)
 748 {
 749         struct sockaddr *src_in, *dst_in;
 750         struct addr_req *req;
 751         int ret = 0;
 752
 753         req = kzalloc(sizeof *req, GFP_KERNEL);
 754         if (!req)
 755                 return -ENOMEM;
 756
 757         src_in = (struct sockaddr *) &req->src_addr;
 758         dst_in = (struct sockaddr *) &req->dst_addr;
 759
 760         if (src_addr) {
 761                 if (src_addr->sa_family != dst_addr->sa_family) {
 762                         ret = -EINVAL;
 763                         goto err;
 764                 }
 765
 766                 memcpy(src_in, src_addr, rdma_addr_size(src_addr));
 767         } else {
 768                 src_in->sa_family = dst_addr->sa_family;
 769         }
 770
 771         memcpy(dst_in, dst_addr, rdma_addr_size(dst_addr));
 772         req->addr = addr;
 773         req->callback = callback;
 774         req->context = context;
 775         req->client = client;
 776         atomic_inc(&client->refcount);
 777
 778         req->status = addr_resolve(src_in, dst_in, addr);
 779         switch (req->status) {
 780         case 0:
 781                 req->timeout = jiffies;
 782                 queue_req(req);
 783                 break;
 784         case -ENODATA:
 785                 req->timeout = msecs_to_jiffies(timeout_ms) + jiffies;
 786                 queue_req(req);
 787                 break;
 788         default:
 789                 ret = req->status;
 790                 atomic_dec(&client->refcount);
 791                 goto err;
 792         }
 793         return ret;
 794 err:
 795         kfree(req);
 796         return ret;
 797 }
 798 EXPORT_SYMBOL(rdma_resolve_ip);
 799
 800 int rdma_resolve_ip_route(struct sockaddr *src_addr,
 801                           const struct sockaddr *dst_addr,
 802                           struct rdma_dev_addr *addr)
 803 {
 804         struct sockaddr_storage ssrc_addr = {};
 805         struct sockaddr *src_in = (struct sockaddr *)&ssrc_addr;
 806
 807         if (src_addr) {
 808                 if (src_addr->sa_family != dst_addr->sa_family)
 809                         return -EINVAL;
 810
 811                 memcpy(src_in, src_addr, rdma_addr_size(src_addr));
 812         } else {
 813                 src_in->sa_family = dst_addr->sa_family;
 814         }
 815
 816         return addr_resolve(src_in, dst_addr, addr);
 817 }
 818 EXPORT_SYMBOL(rdma_resolve_ip_route);
 819
 820 void rdma_addr_cancel(struct rdma_dev_addr *addr)
 821 {
 822         struct addr_req *req, *temp_req;
 823
 824         mutex_lock(&lock);
 825         list_for_each_entry_safe(req, temp_req, &req_list, list) {
 826                 if (req->addr == addr) {
 827                         req->status = -ECANCELED;
 828                         req->timeout = jiffies;
 829                         list_move(&req->list, &req_list);
 830                         set_timeout(req->timeout);
 831                         break;
 832                 }
 833         }
 834         mutex_unlock(&lock);
 835 }
 836 EXPORT_SYMBOL(rdma_addr_cancel);
 837
 838 struct resolve_cb_context {
 839         struct rdma_dev_addr *addr;
 840         struct completion comp;
 841         int status;
 842 };
 843
 844 static void resolve_cb(int status, struct sockaddr *src_addr,
 845              struct rdma_dev_addr *addr, void *context)
 846 {
 847         if (!status)
 848                 memcpy(((struct resolve_cb_context *)context)->addr,
 849                        addr, sizeof(struct rdma_dev_addr));
 850         ((struct resolve_cb_context *)context)->status = status;
 851         complete(&((struct resolve_cb_context *)context)->comp);
 852 }
 853
 854 int rdma_addr_find_l2_eth_by_grh(const union ib_gid *sgid,
 855                                  const union ib_gid *dgid,
 856                                  u8 *dmac, struct net_device *dev,
 857                                  int *hoplimit)
 858 {
 859         int ret = 0;
 860         struct rdma_dev_addr dev_addr;
 861         struct resolve_cb_context ctx;
 862
 863         union rdma_sockaddr sgid_addr, dgid_addr;
 864
 865         rdma_gid2ip(&sgid_addr._sockaddr, sgid);
 866         rdma_gid2ip(&dgid_addr._sockaddr, dgid);
 867
 868         memset(&dev_addr, 0, sizeof(dev_addr));
 869
 870         dev_addr.bound_dev_if = dev->if_index;
 871         dev_addr.net = dev_net(dev);
 872
 873         ctx.addr = &dev_addr;
 874         init_completion(&ctx.comp);
 875         ret = rdma_resolve_ip(&self, &sgid_addr._sockaddr, &dgid_addr._sockaddr,
 876                         &dev_addr, 1000, resolve_cb, &ctx);
 877         if (ret)
 878                 return ret;
 879
 880         wait_for_completion(&ctx.comp);
 881
 882         ret = ctx.status;
 883         if (ret)
 884                 return ret;
 885
 886         memcpy(dmac, dev_addr.dst_dev_addr, ETH_ALEN);
 887         if (hoplimit)
 888                 *hoplimit = dev_addr.hoplimit;
 889         return ret;
 890 }
 891 EXPORT_SYMBOL(rdma_addr_find_l2_eth_by_grh);
 892
 893 int addr_init(void)
 894 {
 895         addr_wq = alloc_workqueue("ib_addr", WQ_MEM_RECLAIM, 0);
 896         if (!addr_wq)
 897                 return -ENOMEM;
 898
 899         rdma_addr_register_client(&self);
 900
 901         return 0;
 902 }
 903
 904 void addr_cleanup(void)
 905 {
 906         rdma_addr_unregister_client(&self);
 907         destroy_workqueue(addr_wq);
 908 }