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