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