sys/contrib/rdma/rdma_addr.c

   1 /*
   2  * Copyright (c) 2005 Voltaire Inc.  All rights reserved.
   3  * Copyright (c) 2002-2005, Network Appliance, Inc. All rights reserved.
   4  * Copyright (c) 1999-2005, Mellanox Technologies, Inc. All rights reserved.
   5  * Copyright (c) 2005 Intel Corporation.  All rights reserved.
   6  *
   7  * This Software is licensed under one of the following licenses:
   8  *
   9  * 1) under the terms of the "Common Public License 1.0" a copy of which is
  10  *    available from the Open Source Initiative, see
  11  *    http://www.opensource.org/licenses/cpl.php.
  12  *
  13  * 2) under the terms of the "The BSD License" a copy of which is
  14  *    available from the Open Source Initiative, see
  15  *    http://www.opensource.org/licenses/bsd-license.php.
  16  *
  17  * 3) under the terms of the "GNU General Public License (GPL) Version 2" a
  18  *    copy of which is available from the Open Source Initiative, see
  19  *    http://www.opensource.org/licenses/gpl-license.php.
  20  *
  21  * Licensee has the right to choose one of the above licenses.
  22  *
  23  * Redistributions of source code must retain the above copyright
  24  * notice and one of the license notices.
  25  *
  26  * Redistributions in binary form must reproduce both the above copyright
  27  * notice, one of the license notices in the documentation
  28  * and/or other materials provided with the distribution.
  29  *
  30  */
  31
  32 #include <sys/cdefs.h>
  33 __FBSDID("$FreeBSD$");
  34
  35 #include <sys/param.h>
  36 #include <sys/condvar.h>
  37 #include <sys/systm.h>
  38 #include <sys/kernel.h>
  39 #include <sys/socket.h>
  40 #include <sys/module.h>
  41
  42 #include <sys/lock.h>
  43 #include <sys/condvar.h>
  44 #include <sys/mutex.h>
  45 #include <sys/rwlock.h>
  46 #include <sys/queue.h>
  47 #include <sys/taskqueue.h>
  48
  49 #include <net/if.h>
  50 #include <net/if_dl.h>
  51 #include <net/if_var.h>
  52 #include <net/if_arp.h>
  53 #include <net/route.h>
  54
  55 #include <net80211/ieee80211_freebsd.h>
  56
  57 #include <netinet/in.h>
  58 #include <netinet/if_ether.h>
  59
  60 #include <contrib/rdma/ib_addr.h>
  61
  62 struct addr_req {
  63         TAILQ_ENTRY(addr_req) entry;
  64         struct sockaddr src_addr;
  65         struct sockaddr dst_addr;
  66         struct rdma_dev_addr *addr;
  67         struct rdma_addr_client *client;
  68         void *context;
  69         void (*callback)(int status, struct sockaddr *src_addr,
  70                          struct rdma_dev_addr *addr, void *context);
  71         unsigned long timeout;
  72         int status;
  73 };
  74
  75 static void process_req(void *ctx, int pending);
  76
  77 static struct mtx lock;
  78
  79 static TAILQ_HEAD(addr_req_list, addr_req) req_list;
  80 static struct task addr_task;
  81 static struct taskqueue *addr_taskq;
  82 static struct callout addr_ch;
  83 static eventhandler_tag route_event_tag;
  84
  85 static void addr_timeout(void *arg)
  86 {
  87         taskqueue_enqueue(addr_taskq, &addr_task);
  88 }
  89
  90 void rdma_addr_register_client(struct rdma_addr_client *client)
  91 {
  92         mtx_init(&client->lock, "rdma_addr client lock", NULL, MTX_DUPOK|MTX_DEF);
  93         cv_init(&client->comp, "rdma_addr cv");
  94         client->refcount = 1;
  95 }
  96
  97 static inline void put_client(struct rdma_addr_client *client)
  98 {
  99         mtx_lock(&client->lock);
 100         if (--client->refcount == 0) {
 101                 cv_broadcast(&client->comp);
 102         }
 103         mtx_unlock(&client->lock);
 104 }
 105
 106 void rdma_addr_unregister_client(struct rdma_addr_client *client)
 107 {
 108         put_client(client);
 109         mtx_lock(&client->lock);
 110         if (client->refcount) {
 111                 cv_wait(&client->comp, &client->lock);
 112         }
 113         mtx_unlock(&client->lock);
 114 }
 115
 116 int rdma_copy_addr(struct rdma_dev_addr *dev_addr, struct ifnet *dev,
 117                      const unsigned char *dst_dev_addr)
 118 {
 119         dev_addr->dev_type = RDMA_NODE_RNIC;
 120         memcpy(dev_addr->src_dev_addr, IF_LLADDR(dev), MAX_ADDR_LEN);
 121         memcpy(dev_addr->broadcast, dev->if_broadcastaddr, MAX_ADDR_LEN);
 122         if (dst_dev_addr)
 123                 memcpy(dev_addr->dst_dev_addr, dst_dev_addr, MAX_ADDR_LEN);
 124         return 0;
 125 }
 126
 127 int rdma_translate_ip(struct sockaddr *addr, struct rdma_dev_addr *dev_addr)
 128 {
 129         struct ifaddr *ifa;
 130         struct sockaddr_in *sin = (struct sockaddr_in *)addr;
 131         uint16_t port = sin->sin_port;
 132
 133         sin->sin_port = 0;
 134         ifa = ifa_ifwithaddr(addr);
 135         sin->sin_port = port;
 136         if (!ifa)
 137                 return (EADDRNOTAVAIL);
 138         return rdma_copy_addr(dev_addr, ifa->ifa_ifp, NULL);
 139 }
 140
 141 static void queue_req(struct addr_req *req)
 142 {
 143         struct addr_req *tmp_req = NULL;
 144
 145         mtx_lock(&lock);
 146         TAILQ_FOREACH_REVERSE(tmp_req, &req_list, addr_req_list, entry)
 147             if (time_after_eq(req->timeout, tmp_req->timeout))
 148                     break;
 149
 150         if (tmp_req)
 151                 TAILQ_INSERT_AFTER(&req_list, tmp_req, req, entry);
 152         else
 153                 TAILQ_INSERT_TAIL(&req_list, req, entry);
 154
 155         if (TAILQ_FIRST(&req_list) == req)
 156                 callout_reset(&addr_ch, req->timeout - ticks, addr_timeout, NULL);
 157         mtx_unlock(&lock);
 158 }
 159
 160 #ifdef needed
 161 static void addr_send_arp(struct sockaddr_in *dst_in)
 162 {
 163         struct route iproute;
 164         struct sockaddr_in *dst = (struct sockaddr_in *)&iproute.ro_dst;
 165         char dmac[ETHER_ADDR_LEN];
 166
 167         bzero(&iproute, sizeof iproute);
 168         *dst = *dst_in;
 169
 170         rtalloc(&iproute);
 171         if (iproute.ro_rt == NULL);
 172                 return;
 173
 174         arpresolve(iproute.ro_rt->rt_ifp, iproute.ro_rt, NULL,
 175                    rt_key(iproute.ro_rt), dmac);
 176
 177         RTFREE(iproute.ro_rt);
 178 }
 179 #endif
 180
 181 static int addr_resolve_remote(struct sockaddr_in *src_in,
 182                                struct sockaddr_in *dst_in,
 183                                struct rdma_dev_addr *addr)
 184 {
 185         int ret = 0;
 186         struct route iproute;
 187         struct sockaddr_in *dst = (struct sockaddr_in *)&iproute.ro_dst;
 188         char dmac[ETHER_ADDR_LEN];
 189
 190         bzero(&iproute, sizeof iproute);
 191         *dst = *dst_in;
 192
 193         rtalloc(&iproute);
 194         if (iproute.ro_rt == NULL) {
 195                 ret = EHOSTUNREACH;
 196                 goto out;
 197         }
 198
 199         /* If the device does ARP internally, return 'done' */
 200         if (iproute.ro_rt->rt_ifp->if_flags & IFF_NOARP) {
 201                 rdma_copy_addr(addr, iproute.ro_rt->rt_ifp, NULL);
 202                 goto put;
 203         }
 204         ret = arpresolve(iproute.ro_rt->rt_ifp, iproute.ro_rt, NULL,
 205                 rt_key(iproute.ro_rt), dmac);
 206         if (ret) {
 207                 goto put;
 208         }
 209
 210         if (!src_in->sin_addr.s_addr) {
 211                 src_in->sin_len = sizeof *src_in;
 212                 src_in->sin_family = dst_in->sin_family;
 213                 src_in->sin_addr.s_addr = ((struct sockaddr_in *)iproute.ro_rt->rt_ifa->ifa_addr)->sin_addr.s_addr;
 214         }
 215
 216         ret = rdma_copy_addr(addr, iproute.ro_rt->rt_ifp, dmac);
 217 put:
 218         RTFREE(iproute.ro_rt);
 219 out:
 220         return ret;
 221 }
 222
 223 static void process_req(void *ctx, int pending)
 224 {
 225         struct addr_req *req, *tmp_req;
 226         struct sockaddr_in *src_in, *dst_in;
 227         TAILQ_HEAD(, addr_req) done_list;
 228
 229         TAILQ_INIT(&done_list);
 230
 231         mtx_lock(&lock);
 232         TAILQ_FOREACH_SAFE(req, &req_list, entry, tmp_req) {
 233                 if (req->status == EWOULDBLOCK) {
 234                         src_in = (struct sockaddr_in *) &req->src_addr;
 235                         dst_in = (struct sockaddr_in *) &req->dst_addr;
 236                         req->status = addr_resolve_remote(src_in, dst_in,
 237                                                           req->addr);
 238                         if (req->status && time_after_eq(ticks, req->timeout))
 239                                 req->status = ETIMEDOUT;
 240                         else if (req->status == EWOULDBLOCK)
 241                                 continue;
 242                 }
 243                 TAILQ_REMOVE(&req_list, req, entry);
 244                 TAILQ_INSERT_TAIL(&done_list, req, entry);
 245         }
 246
 247         if (!TAILQ_EMPTY(&req_list)) {
 248                 req = TAILQ_FIRST(&req_list);
 249                 callout_reset(&addr_ch, req->timeout - ticks, addr_timeout,
 250                         NULL);
 251         }
 252         mtx_unlock(&lock);
 253
 254         TAILQ_FOREACH_SAFE(req, &done_list, entry, tmp_req) {
 255                 TAILQ_REMOVE(&done_list, req, entry);
 256                 req->callback(req->status, &req->src_addr, req->addr,
 257                               req->context);
 258                 put_client(req->client);
 259                 free(req, M_DEVBUF);
 260         }
 261 }
 262
 263 int rdma_resolve_ip(struct rdma_addr_client *client,
 264                     struct sockaddr *src_addr, struct sockaddr *dst_addr,
 265                     struct rdma_dev_addr *addr, int timeout_ms,
 266                     void (*callback)(int status, struct sockaddr *src_addr,
 267                                      struct rdma_dev_addr *addr, void *context),
 268                     void *context)
 269 {
 270         struct sockaddr_in *src_in, *dst_in;
 271         struct addr_req *req;
 272         int ret = 0;
 273
 274         req = malloc(sizeof *req, M_DEVBUF, M_NOWAIT);
 275         if (!req)
 276                 return (ENOMEM);
 277         memset(req, 0, sizeof *req);
 278
 279         if (src_addr)
 280                 memcpy(&req->src_addr, src_addr, ip_addr_size(src_addr));
 281         memcpy(&req->dst_addr, dst_addr, ip_addr_size(dst_addr));
 282         req->addr = addr;
 283         req->callback = callback;
 284         req->context = context;
 285         req->client = client;
 286         mtx_lock(&client->lock);
 287         client->refcount++;
 288         mtx_unlock(&client->lock);
 289
 290         src_in = (struct sockaddr_in *) &req->src_addr;
 291         dst_in = (struct sockaddr_in *) &req->dst_addr;
 292
 293         req->status = addr_resolve_remote(src_in, dst_in, addr);
 294
 295         switch (req->status) {
 296         case 0:
 297                 req->timeout = ticks;
 298                 queue_req(req);
 299                 break;
 300         case EWOULDBLOCK:
 301                 req->timeout = msecs_to_ticks(timeout_ms) + ticks;
 302                 queue_req(req);
 303 #ifdef needed
 304                 addr_send_arp(dst_in);
 305 #endif
 306                 break;
 307         default:
 308                 ret = req->status;
 309                 mtx_lock(&client->lock);
 310                 client->refcount--;
 311                 mtx_unlock(&client->lock);
 312                 free(req, M_DEVBUF);
 313                 break;
 314         }
 315         return ret;
 316 }
 317
 318 void rdma_addr_cancel(struct rdma_dev_addr *addr)
 319 {
 320         struct addr_req *req, *tmp_req;
 321
 322         mtx_lock(&lock);
 323         TAILQ_FOREACH_SAFE(req, &req_list, entry, tmp_req) {
 324                 if (req->addr == addr) {
 325                         req->status = ECANCELED;
 326                         req->timeout = ticks;
 327                         TAILQ_REMOVE(&req_list, req, entry);
 328                         TAILQ_INSERT_HEAD(&req_list, req, entry);
 329                         callout_reset(&addr_ch, req->timeout - ticks, addr_timeout, NULL);
 330                         break;
 331                 }
 332         }
 333         mtx_unlock(&lock);
 334 }
 335
 336 static void
 337 route_event_arp_update(void *unused, struct rtentry *rt0, uint8_t *enaddr,
 338         struct sockaddr *sa)
 339 {
 340                 callout_stop(&addr_ch);
 341                 taskqueue_enqueue(addr_taskq, &addr_task);
 342 }
 343
 344 static int addr_init(void)
 345 {
 346         TAILQ_INIT(&req_list);
 347         mtx_init(&lock, "rdma_addr req_list lock", NULL, MTX_DEF);
 348
 349         addr_taskq = taskqueue_create("rdma_addr_taskq", M_NOWAIT,
 350                 taskqueue_thread_enqueue, &addr_taskq);
 351         if (addr_taskq == NULL) {
 352                 printf("failed to allocate rdma_addr taskqueue\n");
 353                 return (ENOMEM);
 354         }
 355         taskqueue_start_threads(&addr_taskq, 1, PI_NET, "rdma_addr taskq");
 356         TASK_INIT(&addr_task, 0, process_req, NULL);
 357
 358         callout_init(&addr_ch, TRUE);
 359
 360         route_event_tag = EVENTHANDLER_REGISTER(route_arp_update_event,
 361                 route_event_arp_update, NULL, EVENTHANDLER_PRI_ANY);
 362
 363         return 0;
 364 }
 365
 366 static void addr_cleanup(void)
 367 {
 368         EVENTHANDLER_DEREGISTER(route_event_arp_update, route_event_tag);
 369         callout_stop(&addr_ch);
 370         taskqueue_drain(addr_taskq, &addr_task);
 371         taskqueue_free(addr_taskq);
 372 }
 373
 374 static int
 375 addr_load(module_t mod, int cmd, void *arg)
 376 {
 377         int err = 0;
 378
 379         switch (cmd) {
 380         case MOD_LOAD:
 381                 printf("Loading rdma_addr.\n");
 382
 383                 addr_init();
 384                 break;
 385         case MOD_QUIESCE:
 386                 break;
 387         case MOD_UNLOAD:
 388                 printf("Unloading rdma_addr.\n");
 389                 addr_cleanup();
 390                 break;
 391         case MOD_SHUTDOWN:
 392                 break;
 393         default:
 394                 err = EOPNOTSUPP;
 395                 break;
 396         }
 397
 398         return (err);
 399 }
 400
 401 static moduledata_t mod_data = {
 402         "rdma_addr",
 403         addr_load,
 404         0
 405 };
 406
 407 MODULE_VERSION(rdma_addr, 1);
 408 DECLARE_MODULE(rdma_addr, mod_data, SI_SUB_EXEC, SI_ORDER_ANY);