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         struct llentry *lle;
 167
 168         bzero(&iproute, sizeof iproute);
 169         *dst = *dst_in;
 170
 171         rtalloc(&iproute);
 172         if (iproute.ro_rt == NULL);
 173                 return;
 174
 175         arpresolve(iproute.ro_rt->rt_ifp, iproute.ro_rt, NULL,
 176                    rt_key(iproute.ro_rt), dmac, &lle);
 177
 178         RTFREE(iproute.ro_rt);
 179 }
 180 #endif
 181
 182 static int addr_resolve_remote(struct sockaddr_in *src_in,
 183                                struct sockaddr_in *dst_in,
 184                                struct rdma_dev_addr *addr)
 185 {
 186         int ret = 0;
 187         struct route iproute;
 188         struct sockaddr_in *dst = (struct sockaddr_in *)&iproute.ro_dst;
 189         char dmac[ETHER_ADDR_LEN];
 190         struct llentry *lle;
 191
 192         bzero(&iproute, sizeof iproute);
 193         *dst = *dst_in;
 194
 195         rtalloc(&iproute);
 196         if (iproute.ro_rt == NULL) {
 197                 ret = EHOSTUNREACH;
 198                 goto out;
 199         }
 200
 201         /* If the device does ARP internally, return 'done' */
 202         if (iproute.ro_rt->rt_ifp->if_flags & IFF_NOARP) {
 203                 rdma_copy_addr(addr, iproute.ro_rt->rt_ifp, NULL);
 204                 goto put;
 205         }
 206         ret = arpresolve(iproute.ro_rt->rt_ifp, iproute.ro_rt, NULL,
 207                 rt_key(iproute.ro_rt), dmac, &lle);
 208         if (ret) {
 209                 goto put;
 210         }
 211
 212         if (!src_in->sin_addr.s_addr) {
 213                 src_in->sin_len = sizeof *src_in;
 214                 src_in->sin_family = dst_in->sin_family;
 215                 src_in->sin_addr.s_addr = ((struct sockaddr_in *)iproute.ro_rt->rt_ifa->ifa_addr)->sin_addr.s_addr;
 216         }
 217
 218         ret = rdma_copy_addr(addr, iproute.ro_rt->rt_ifp, dmac);
 219 put:
 220         RTFREE(iproute.ro_rt);
 221 out:
 222         return ret;
 223 }
 224
 225 static void process_req(void *ctx, int pending)
 226 {
 227         struct addr_req *req, *tmp_req;
 228         struct sockaddr_in *src_in, *dst_in;
 229         TAILQ_HEAD(, addr_req) done_list;
 230
 231         TAILQ_INIT(&done_list);
 232
 233         mtx_lock(&lock);
 234         TAILQ_FOREACH_SAFE(req, &req_list, entry, tmp_req) {
 235                 if (req->status == EWOULDBLOCK) {
 236                         src_in = (struct sockaddr_in *) &req->src_addr;
 237                         dst_in = (struct sockaddr_in *) &req->dst_addr;
 238                         req->status = addr_resolve_remote(src_in, dst_in,
 239                                                           req->addr);
 240                         if (req->status && time_after_eq(ticks, req->timeout))
 241                                 req->status = ETIMEDOUT;
 242                         else if (req->status == EWOULDBLOCK)
 243                                 continue;
 244                 }
 245                 TAILQ_REMOVE(&req_list, req, entry);
 246                 TAILQ_INSERT_TAIL(&done_list, req, entry);
 247         }
 248
 249         if (!TAILQ_EMPTY(&req_list)) {
 250                 req = TAILQ_FIRST(&req_list);
 251                 callout_reset(&addr_ch, req->timeout - ticks, addr_timeout,
 252                         NULL);
 253         }
 254         mtx_unlock(&lock);
 255
 256         TAILQ_FOREACH_SAFE(req, &done_list, entry, tmp_req) {
 257                 TAILQ_REMOVE(&done_list, req, entry);
 258                 req->callback(req->status, &req->src_addr, req->addr,
 259                               req->context);
 260                 put_client(req->client);
 261                 free(req, M_DEVBUF);
 262         }
 263 }
 264
 265 int rdma_resolve_ip(struct rdma_addr_client *client,
 266                     struct sockaddr *src_addr, struct sockaddr *dst_addr,
 267                     struct rdma_dev_addr *addr, int timeout_ms,
 268                     void (*callback)(int status, struct sockaddr *src_addr,
 269                                      struct rdma_dev_addr *addr, void *context),
 270                     void *context)
 271 {
 272         struct sockaddr_in *src_in, *dst_in;
 273         struct addr_req *req;
 274         int ret = 0;
 275
 276         req = malloc(sizeof *req, M_DEVBUF, M_NOWAIT);
 277         if (!req)
 278                 return (ENOMEM);
 279         memset(req, 0, sizeof *req);
 280
 281         if (src_addr)
 282                 memcpy(&req->src_addr, src_addr, ip_addr_size(src_addr));
 283         memcpy(&req->dst_addr, dst_addr, ip_addr_size(dst_addr));
 284         req->addr = addr;
 285         req->callback = callback;
 286         req->context = context;
 287         req->client = client;
 288         mtx_lock(&client->lock);
 289         client->refcount++;
 290         mtx_unlock(&client->lock);
 291
 292         src_in = (struct sockaddr_in *) &req->src_addr;
 293         dst_in = (struct sockaddr_in *) &req->dst_addr;
 294
 295         req->status = addr_resolve_remote(src_in, dst_in, addr);
 296
 297         switch (req->status) {
 298         case 0:
 299                 req->timeout = ticks;
 300                 queue_req(req);
 301                 break;
 302         case EWOULDBLOCK:
 303                 req->timeout = msecs_to_ticks(timeout_ms) + ticks;
 304                 queue_req(req);
 305 #ifdef needed
 306                 addr_send_arp(dst_in);
 307 #endif
 308                 break;
 309         default:
 310                 ret = req->status;
 311                 mtx_lock(&client->lock);
 312                 client->refcount--;
 313                 mtx_unlock(&client->lock);
 314                 free(req, M_DEVBUF);
 315                 break;
 316         }
 317         return ret;
 318 }
 319
 320 void rdma_addr_cancel(struct rdma_dev_addr *addr)
 321 {
 322         struct addr_req *req, *tmp_req;
 323
 324         mtx_lock(&lock);
 325         TAILQ_FOREACH_SAFE(req, &req_list, entry, tmp_req) {
 326                 if (req->addr == addr) {
 327                         req->status = ECANCELED;
 328                         req->timeout = ticks;
 329                         TAILQ_REMOVE(&req_list, req, entry);
 330                         TAILQ_INSERT_HEAD(&req_list, req, entry);
 331                         callout_reset(&addr_ch, req->timeout - ticks, addr_timeout, NULL);
 332                         break;
 333                 }
 334         }
 335         mtx_unlock(&lock);
 336 }
 337
 338 static void
 339 route_event_arp_update(void *unused, struct rtentry *rt0, uint8_t *enaddr,
 340         struct sockaddr *sa)
 341 {
 342                 callout_stop(&addr_ch);
 343                 taskqueue_enqueue(addr_taskq, &addr_task);
 344 }
 345
 346 static int addr_init(void)
 347 {
 348         TAILQ_INIT(&req_list);
 349         mtx_init(&lock, "rdma_addr req_list lock", NULL, MTX_DEF);
 350
 351         addr_taskq = taskqueue_create("rdma_addr_taskq", M_NOWAIT,
 352                 taskqueue_thread_enqueue, &addr_taskq);
 353         if (addr_taskq == NULL) {
 354                 printf("failed to allocate rdma_addr taskqueue\n");
 355                 return (ENOMEM);
 356         }
 357         taskqueue_start_threads(&addr_taskq, 1, PI_NET, "rdma_addr taskq");
 358         TASK_INIT(&addr_task, 0, process_req, NULL);
 359
 360         callout_init(&addr_ch, TRUE);
 361
 362         route_event_tag = EVENTHANDLER_REGISTER(route_arp_update_event,
 363                 route_event_arp_update, NULL, EVENTHANDLER_PRI_ANY);
 364
 365         return 0;
 366 }
 367
 368 static void addr_cleanup(void)
 369 {
 370         EVENTHANDLER_DEREGISTER(route_event_arp_update, route_event_tag);
 371         callout_stop(&addr_ch);
 372         taskqueue_drain(addr_taskq, &addr_task);
 373         taskqueue_free(addr_taskq);
 374 }
 375
 376 static int
 377 addr_load(module_t mod, int cmd, void *arg)
 378 {
 379         int err = 0;
 380
 381         switch (cmd) {
 382         case MOD_LOAD:
 383                 printf("Loading rdma_addr.\n");
 384
 385                 addr_init();
 386                 break;
 387         case MOD_QUIESCE:
 388                 break;
 389         case MOD_UNLOAD:
 390                 printf("Unloading rdma_addr.\n");
 391                 addr_cleanup();
 392                 break;
 393         case MOD_SHUTDOWN:
 394                 break;
 395         default:
 396                 err = EOPNOTSUPP;
 397                 break;
 398         }
 399
 400         return (err);
 401 }
 402
 403 static moduledata_t mod_data = {
 404         "rdma_addr",
 405         addr_load,
 406         0
 407 };
 408
 409 MODULE_VERSION(rdma_addr, 1);
 410 DECLARE_MODULE(rdma_addr, mod_data, SI_SUB_EXEC, SI_ORDER_ANY);