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/slab.h>
  43 #include <linux/workqueue.h>
  44 #include <linux/module.h>
  45 #include <net/if_llatbl.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 ifnet *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 ifnet *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_ifp_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_ifp_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_ifp_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 #ifdef INET6
 401                 if (is_gw && nh->gw_sa.sa_family == AF_INET6)
 402                         error = nd6_resolve(ifp, LLE_SF(AF_INET, is_gw), NULL,
 403                             &nh->gw_sa, edst, NULL, NULL);
 404                 else
 405 #endif
 406                         error = arpresolve(ifp, is_gw, NULL, is_gw ?
 407                             &nh->gw_sa : (const struct sockaddr *)&dst_tmp,
 408                             edst, NULL, NULL);
 409
 410                 if (error != 0)
 411                         goto error_put_ifp;
 412                 else if (is_gw)
 413                         addr->network = RDMA_NETWORK_IPV4;
 414         }
 415
 416         /*
 417          * Step 4 - update source address, if any
 418          */
 419         if (saddr != NULL) {
 420                 src_port = src_in->sin_port;
 421                 memcpy(src_in, saddr, rdma_addr_size(saddr));
 422                 src_in->sin_port = src_port;    /* preserve port number */
 423         }
 424
 425         *ifpp = ifp;
 426
 427         goto done;
 428
 429 error_put_ifp:
 430         dev_put(ifp);
 431 done:
 432         CURVNET_RESTORE();
 433
 434         if (error == EWOULDBLOCK || error == EAGAIN)
 435                 error = ENODATA;
 436         return (-error);
 437 }
 438 #else
 439 static int addr4_resolve(struct sockaddr_in *src_in,
 440                          const struct sockaddr_in *dst_in,
 441                          struct rdma_dev_addr *addr,
 442                          u8 *edst,
 443                          struct ifnet **ifpp)
 444 {
 445         return -EADDRNOTAVAIL;
 446 }
 447 #endif
 448
 449 #ifdef INET6
 450 static int addr6_resolve(struct sockaddr_in6 *src_in,
 451                          const struct sockaddr_in6 *dst_in,
 452                          struct rdma_dev_addr *addr,
 453                          u8 *edst,
 454                          struct ifnet **ifpp)
 455 {
 456         enum {
 457                 ADDR_VALID = 0,
 458                 ADDR_SRC_ANY = 1,
 459                 ADDR_DST_ANY = 2,
 460         };
 461         struct sockaddr_in6 dst_tmp = *dst_in;
 462         in_port_t src_port;
 463         struct sockaddr *saddr = NULL;
 464         struct nhop_object *nh;
 465         struct ifnet *ifp;
 466         int error;
 467         int type;
 468
 469         NET_EPOCH_ASSERT();
 470
 471         /* set VNET, if any */
 472         CURVNET_SET(addr->net);
 473
 474         /* set default TTL limit */
 475         addr->hoplimit = V_ip_defttl;
 476
 477         type = ADDR_VALID;
 478         if (ipv6_addr_any(&src_in->sin6_addr))
 479                 type |= ADDR_SRC_ANY;
 480         if (ipv6_addr_any(&dst_tmp.sin6_addr))
 481                 type |= ADDR_DST_ANY;
 482
 483         /*
 484          * Make sure the socket address length field is set.
 485          */
 486         dst_tmp.sin6_len = sizeof(dst_tmp);
 487
 488         /*
 489          * Make sure the scope ID gets embedded, else nd6_resolve() will
 490          * not find the record.
 491          */
 492         dst_tmp.sin6_scope_id = addr->bound_dev_if;
 493         sa6_embedscope(&dst_tmp, 0);
 494
 495         /* Step 1 - lookup destination route if any */
 496         switch (type) {
 497         case ADDR_VALID:
 498                 /* sanity check for IPv4 addresses */
 499                 if (ipv6_addr_v4mapped(&src_in->sin6_addr) !=
 500                     ipv6_addr_v4mapped(&dst_tmp.sin6_addr)) {
 501                         error = EAFNOSUPPORT;
 502                         goto done;
 503                 }
 504                 /* FALLTHROUGH */
 505         case ADDR_SRC_ANY:
 506                 /* regular destination route lookup */
 507                 nh = fib6_lookup(RT_DEFAULT_FIB, &dst_in->sin6_addr,
 508                     addr->bound_dev_if, NHR_NONE, 0);
 509                 if (nh == NULL) {
 510                         error = EHOSTUNREACH;
 511                         goto done;
 512                 }
 513                 break;
 514         default:
 515                 error = ENETUNREACH;
 516                 goto done;
 517         }
 518
 519         /* Step 2 - find outgoing network interface */
 520         switch (type) {
 521         case ADDR_VALID:
 522                 /* get source interface */
 523                 if (addr->bound_dev_if != 0) {
 524                         ifp = dev_get_by_index(addr->net, addr->bound_dev_if);
 525                 } else {
 526                         ifp = ip6_ifp_find(addr->net, src_in->sin6_addr, 0);
 527                 }
 528
 529                 /* check source interface */
 530                 if (ifp == NULL) {
 531                         error = ENETUNREACH;
 532                         goto done;
 533                 } else if (ifp->if_flags & IFF_LOOPBACK) {
 534                         /*
 535                          * Source address cannot be a loopback device.
 536                          */
 537                         error = EHOSTUNREACH;
 538                         goto error_put_ifp;
 539                 } else if (nh->nh_ifp->if_flags & IFF_LOOPBACK) {
 540                         if (memcmp(&src_in->sin6_addr, &dst_in->sin6_addr,
 541                             sizeof(src_in->sin6_addr))) {
 542                                 /*
 543                                  * Destination is loopback, but source
 544                                  * and destination address is not the
 545                                  * same.
 546                                  */
 547                                 error = EHOSTUNREACH;
 548                                 goto error_put_ifp;
 549                         }
 550                         /* get destination network interface from route */
 551                         dev_put(ifp);
 552                         ifp = nh->nh_ifp;
 553                         dev_hold(ifp);
 554                 } else if (ifp != nh->nh_ifp) {
 555                         /*
 556                          * Source and destination interfaces are
 557                          * different.
 558                          */
 559                         error = ENETUNREACH;
 560                         goto error_put_ifp;
 561                 }
 562                 break;
 563         case ADDR_SRC_ANY:
 564                 /* check for loopback device */
 565                 if (nh->nh_ifp->if_flags & IFF_LOOPBACK)
 566                         saddr = (struct sockaddr *)&dst_tmp;
 567                 else
 568                         saddr = nh->nh_ifa->ifa_addr;
 569
 570                 /* get destination network interface from route */
 571                 ifp = nh->nh_ifp;
 572                 dev_hold(ifp);
 573                 break;
 574         default:
 575                 break;
 576         }
 577
 578         /*
 579          * Step 3 - resolve destination MAC address
 580          */
 581         if (IN6_IS_ADDR_MULTICAST(&dst_tmp.sin6_addr)) {
 582                 bool is_gw = (nh->nh_flags & NHF_GATEWAY) != 0;
 583                 error = addr_resolve_multi(edst, ifp,
 584                     (struct sockaddr *)&dst_tmp);
 585                 if (error != 0)
 586                         goto error_put_ifp;
 587                 else if (is_gw)
 588                         addr->network = RDMA_NETWORK_IPV6;
 589         } else if (nh->nh_ifp->if_flags & IFF_LOOPBACK) {
 590                 memset(edst, 0, MAX_ADDR_LEN);
 591                 error = 0;
 592         } else {
 593                 bool is_gw = (nh->nh_flags & NHF_GATEWAY) != 0;
 594                 memset(edst, 0, MAX_ADDR_LEN);
 595                 error = nd6_resolve(ifp, LLE_SF(AF_INET6, is_gw), NULL,
 596                     is_gw ? &nh->gw_sa : (const struct sockaddr *)&dst_tmp,
 597                     edst, NULL, NULL);
 598                 if (error != 0)
 599                         goto error_put_ifp;
 600                 else if (is_gw)
 601                         addr->network = RDMA_NETWORK_IPV6;
 602         }
 603
 604         /*
 605          * Step 4 - update source address, if any
 606          */
 607         if (saddr != NULL) {
 608                 src_port = src_in->sin6_port;
 609                 memcpy(src_in, saddr, rdma_addr_size(saddr));
 610                 src_in->sin6_port = src_port;   /* preserve port number */
 611         }
 612
 613         *ifpp = ifp;
 614
 615         goto done;
 616
 617 error_put_ifp:
 618         dev_put(ifp);
 619 done:
 620         CURVNET_RESTORE();
 621
 622         if (error == EWOULDBLOCK || error == EAGAIN)
 623                 error = ENODATA;
 624         return (-error);
 625 }
 626 #else
 627 static int addr6_resolve(struct sockaddr_in6 *src_in,
 628                          const struct sockaddr_in6 *dst_in,
 629                          struct rdma_dev_addr *addr,
 630                          u8 *edst,
 631                          struct ifnet **ifpp)
 632 {
 633         return -EADDRNOTAVAIL;
 634 }
 635 #endif
 636
 637 static int addr_resolve_neigh(struct ifnet *dev,
 638                               const struct sockaddr *dst_in,
 639                               u8 *edst,
 640                               struct rdma_dev_addr *addr)
 641 {
 642         if (dev->if_flags & IFF_LOOPBACK) {
 643                 int ret;
 644
 645                 /*
 646                  * Binding to a loopback device is not allowed. Make
 647                  * sure the destination device address is global by
 648                  * clearing the bound device interface:
 649                  */
 650                 if (addr->bound_dev_if == dev->if_index)
 651                         addr->bound_dev_if = 0;
 652
 653                 ret = rdma_translate_ip(dst_in, addr);
 654                 if (ret == 0) {
 655                         memcpy(addr->dst_dev_addr, addr->src_dev_addr,
 656                                MAX_ADDR_LEN);
 657                 }
 658                 return ret;
 659         }
 660
 661         /* If the device doesn't do ARP internally */
 662         if (!(dev->if_flags & IFF_NOARP))
 663                 return rdma_copy_addr(addr, dev, edst);
 664
 665         return rdma_copy_addr(addr, dev, NULL);
 666 }
 667
 668 static int addr_resolve(struct sockaddr *src_in,
 669                         const struct sockaddr *dst_in,
 670                         struct rdma_dev_addr *addr)
 671 {
 672         struct epoch_tracker et;
 673         struct ifnet *ndev = NULL;
 674         u8 edst[MAX_ADDR_LEN];
 675         int ret;
 676
 677         if (dst_in->sa_family != src_in->sa_family)
 678                 return -EINVAL;
 679
 680         NET_EPOCH_ENTER(et);
 681         switch (src_in->sa_family) {
 682         case AF_INET:
 683                 ret = addr4_resolve((struct sockaddr_in *)src_in,
 684                                     (const struct sockaddr_in *)dst_in,
 685                                     addr, edst, &ndev);
 686                 break;
 687         case AF_INET6:
 688                 ret = addr6_resolve((struct sockaddr_in6 *)src_in,
 689                                     (const struct sockaddr_in6 *)dst_in, addr,
 690                                     edst, &ndev);
 691                 break;
 692         default:
 693                 ret = -EADDRNOTAVAIL;
 694                 break;
 695         }
 696         NET_EPOCH_EXIT(et);
 697
 698         /* check for error */
 699         if (ret != 0)
 700                 return ret;
 701
 702         /* store MAC addresses and check for loopback */
 703         ret = addr_resolve_neigh(ndev, dst_in, edst, addr);
 704
 705         /* set belonging VNET, if any */
 706         addr->net = dev_net(ndev);
 707         dev_put(ndev);
 708
 709         return ret;
 710 }
 711
 712 static void process_req(struct work_struct *work)
 713 {
 714         struct addr_req *req, *temp_req;
 715         struct sockaddr *src_in, *dst_in;
 716         struct list_head done_list;
 717
 718         INIT_LIST_HEAD(&done_list);
 719
 720         mutex_lock(&lock);
 721         list_for_each_entry_safe(req, temp_req, &req_list, list) {
 722                 if (req->status == -ENODATA) {
 723                         src_in = (struct sockaddr *) &req->src_addr;
 724                         dst_in = (struct sockaddr *) &req->dst_addr;
 725                         req->status = addr_resolve(src_in, dst_in, req->addr);
 726                         if (req->status && time_after_eq(jiffies, req->timeout))
 727                                 req->status = -ETIMEDOUT;
 728                         else if (req->status == -ENODATA)
 729                                 continue;
 730                 }
 731                 list_move_tail(&req->list, &done_list);
 732         }
 733
 734         if (!list_empty(&req_list)) {
 735                 req = list_entry(req_list.next, struct addr_req, list);
 736                 set_timeout(req->timeout);
 737         }
 738         mutex_unlock(&lock);
 739
 740         list_for_each_entry_safe(req, temp_req, &done_list, list) {
 741                 list_del(&req->list);
 742                 req->callback(req->status, (struct sockaddr *) &req->src_addr,
 743                         req->addr, req->context);
 744                 put_client(req->client);
 745                 kfree(req);
 746         }
 747 }
 748
 749 int rdma_resolve_ip(struct rdma_addr_client *client,
 750                     struct sockaddr *src_addr, struct sockaddr *dst_addr,
 751                     struct rdma_dev_addr *addr, int timeout_ms,
 752                     void (*callback)(int status, struct sockaddr *src_addr,
 753                                      struct rdma_dev_addr *addr, void *context),
 754                     void *context)
 755 {
 756         struct sockaddr *src_in, *dst_in;
 757         struct addr_req *req;
 758         int ret = 0;
 759
 760         req = kzalloc(sizeof *req, GFP_KERNEL);
 761         if (!req)
 762                 return -ENOMEM;
 763
 764         src_in = (struct sockaddr *) &req->src_addr;
 765         dst_in = (struct sockaddr *) &req->dst_addr;
 766
 767         if (src_addr) {
 768                 if (src_addr->sa_family != dst_addr->sa_family) {
 769                         ret = -EINVAL;
 770                         goto err;
 771                 }
 772
 773                 memcpy(src_in, src_addr, rdma_addr_size(src_addr));
 774         } else {
 775                 src_in->sa_family = dst_addr->sa_family;
 776         }
 777
 778         memcpy(dst_in, dst_addr, rdma_addr_size(dst_addr));
 779         req->addr = addr;
 780         req->callback = callback;
 781         req->context = context;
 782         req->client = client;
 783         atomic_inc(&client->refcount);
 784
 785         req->status = addr_resolve(src_in, dst_in, addr);
 786         switch (req->status) {
 787         case 0:
 788                 req->timeout = jiffies;
 789                 queue_req(req);
 790                 break;
 791         case -ENODATA:
 792                 req->timeout = msecs_to_jiffies(timeout_ms) + jiffies;
 793                 queue_req(req);
 794                 break;
 795         default:
 796                 ret = req->status;
 797                 atomic_dec(&client->refcount);
 798                 goto err;
 799         }
 800         return ret;
 801 err:
 802         kfree(req);
 803         return ret;
 804 }
 805 EXPORT_SYMBOL(rdma_resolve_ip);
 806
 807 int rdma_resolve_ip_route(struct sockaddr *src_addr,
 808                           const struct sockaddr *dst_addr,
 809                           struct rdma_dev_addr *addr)
 810 {
 811         struct sockaddr_storage ssrc_addr = {};
 812         struct sockaddr *src_in = (struct sockaddr *)&ssrc_addr;
 813
 814         if (src_addr) {
 815                 if (src_addr->sa_family != dst_addr->sa_family)
 816                         return -EINVAL;
 817
 818                 memcpy(src_in, src_addr, rdma_addr_size(src_addr));
 819         } else {
 820                 src_in->sa_family = dst_addr->sa_family;
 821         }
 822
 823         return addr_resolve(src_in, dst_addr, addr);
 824 }
 825 EXPORT_SYMBOL(rdma_resolve_ip_route);
 826
 827 void rdma_addr_cancel(struct rdma_dev_addr *addr)
 828 {
 829         struct addr_req *req, *temp_req;
 830
 831         mutex_lock(&lock);
 832         list_for_each_entry_safe(req, temp_req, &req_list, list) {
 833                 if (req->addr == addr) {
 834                         req->status = -ECANCELED;
 835                         req->timeout = jiffies;
 836                         list_move(&req->list, &req_list);
 837                         set_timeout(req->timeout);
 838                         break;
 839                 }
 840         }
 841         mutex_unlock(&lock);
 842 }
 843 EXPORT_SYMBOL(rdma_addr_cancel);
 844
 845 struct resolve_cb_context {
 846         struct rdma_dev_addr *addr;
 847         struct completion comp;
 848         int status;
 849 };
 850
 851 static void resolve_cb(int status, struct sockaddr *src_addr,
 852              struct rdma_dev_addr *addr, void *context)
 853 {
 854         if (!status)
 855                 memcpy(((struct resolve_cb_context *)context)->addr,
 856                        addr, sizeof(struct rdma_dev_addr));
 857         ((struct resolve_cb_context *)context)->status = status;
 858         complete(&((struct resolve_cb_context *)context)->comp);
 859 }
 860
 861 int rdma_addr_find_l2_eth_by_grh(const union ib_gid *sgid,
 862                                  const union ib_gid *dgid,
 863                                  u8 *dmac, struct ifnet *dev,
 864                                  int *hoplimit)
 865 {
 866         int ret = 0;
 867         struct rdma_dev_addr dev_addr;
 868         struct resolve_cb_context ctx;
 869
 870         union rdma_sockaddr sgid_addr, dgid_addr;
 871
 872         rdma_gid2ip(&sgid_addr._sockaddr, sgid);
 873         rdma_gid2ip(&dgid_addr._sockaddr, dgid);
 874
 875         memset(&dev_addr, 0, sizeof(dev_addr));
 876
 877         dev_addr.bound_dev_if = dev->if_index;
 878         dev_addr.net = dev_net(dev);
 879
 880         ctx.addr = &dev_addr;
 881         init_completion(&ctx.comp);
 882         ret = rdma_resolve_ip(&self, &sgid_addr._sockaddr, &dgid_addr._sockaddr,
 883                         &dev_addr, 1000, resolve_cb, &ctx);
 884         if (ret)
 885                 return ret;
 886
 887         wait_for_completion(&ctx.comp);
 888
 889         ret = ctx.status;
 890         if (ret)
 891                 return ret;
 892
 893         memcpy(dmac, dev_addr.dst_dev_addr, ETH_ALEN);
 894         if (hoplimit)
 895                 *hoplimit = dev_addr.hoplimit;
 896         return ret;
 897 }
 898 EXPORT_SYMBOL(rdma_addr_find_l2_eth_by_grh);
 899
 900 int addr_init(void)
 901 {
 902         addr_wq = alloc_workqueue("ib_addr", WQ_MEM_RECLAIM, 0);
 903         if (!addr_wq)
 904                 return -ENOMEM;
 905
 906         rdma_addr_register_client(&self);
 907
 908         return 0;
 909 }
 910
 911 void addr_cleanup(void)
 912 {
 913         rdma_addr_unregister_client(&self);
 914         destroy_workqueue(addr_wq);
 915 }