tuntap/src/tuntap_mgr.cc

   1 /*
   2  * ip tunnel/ethertap device for MacOSX.
   3  *
   4  * tuntap_manager definition.
   5  */
   6 /*
   7  * Copyright (c) 2004, 2005, 2006, 2007 Mattias Nissler <mattias.nissler@gmx.de>
   8  *
   9  * Redistribution and use in source and binary forms, with or without modification, are permitted
  10  * provided that the following conditions are met:
  11  *
  12  *   1. Redistributions of source code must retain the above copyright notice, this list of
  13  *      conditions and the following disclaimer.
  14  *   2. Redistributions in binary form must reproduce the above copyright notice, this list of
  15  *      conditions and the following disclaimer in the documentation and/or other materials provided
  16  *      with the distribution.
  17  *   3. The name of the author may not be used to endorse or promote products derived from this
  18  *      software without specific prior written permission.
  19  *
  20  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
  21  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  22  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
  23  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  24  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  25  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  26  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  27  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include "tuntap.h"
  31
  32 extern "C" {
  33
  34 #include <sys/conf.h>
  35 #include <sys/param.h>
  36 #include <sys/syslog.h>
  37 #include <sys/systm.h>
  38 #include <sys/malloc.h>
  39
  40 #include <vm/vm_kern.h>
  41
  42 #include <miscfs/devfs/devfs.h>
  43
  44 }
  45
  46 #if 0
  47 #define dprintf(...)                    log(LOG_INFO, __VA_ARGS__)
  48 #else
  49 #define dprintf(...)
  50 #endif
  51
  52 /* cdevsw for tuntap_manager */
  53 static struct cdevsw mgr_cdevsw =
  54 {
  55         tuntap_manager::cdev_open,
  56         tuntap_manager::cdev_close,
  57         tuntap_manager::cdev_read,
  58         tuntap_manager::cdev_write,
  59         tuntap_manager::cdev_ioctl,
  60         eno_stop,
  61         eno_reset,
  62         NULL,
  63         tuntap_manager::cdev_select,
  64         eno_mmap,
  65         eno_strat,
  66         eno_getc,
  67         eno_putc,
  68         0
  69 };
  70
  71 /* tuntap_manager members */
  72 tuntap_manager *tuntap_manager::mgr_map[MAX_CDEV];
  73
  74 bool tuntap_manager::statics_initialized = false;
  75
  76 /* static initializer */
  77 void
  78 tuntap_manager::initialize_statics()
  79 {
  80         dprintf("initializing mgr_map\n");
  81
  82         /* initialize the major-to-manager map */
  83         for (int i = 0; i < MAX_CDEV; i++)
  84                 mgr_map[i] = NULL;
  85
  86         statics_initialized = true;
  87 }
  88
  89 bool
  90 tuntap_manager::initialize(unsigned int count, char *family)
  91 {
  92         this->count = count;
  93         this->family = family;
  94         this->tuntaps = NULL;
  95
  96         if (!statics_initialized)
  97                 initialize_statics();
  98
  99         /* make sure noone can access the character devices until we are done */
 100         auto_lock l(&cdev_gate);
 101
 102         /* register the switch for the tap character devices */
 103         dev_major = cdevsw_add(-1, &mgr_cdevsw);
 104         if (dev_major == -1) {
 105                 log(LOG_ERR, "%s: could not register character device switch.\n", family);
 106                 return false;
 107         }
 108
 109         /* allocate memory for the interface instance table */
 110         tuntaps = (tuntap_interface **) kalloc(count * sizeof(tuntap_interface *));
 111
 112         if (tuntaps == NULL) {
 113                 log(LOG_ERR, "%s: no memory!\n", family);
 114                 return false;
 115         }
 116
 117         bzero(tuntaps, count * sizeof(tuntap_interface *));
 118
 119         /* Create the interfaces. This will only add the character devices. The network devices will
 120          * be created upon open()ing the corresponding character devices.
 121          */
 122         for (int i = 0; i < (int) count; i++)
 123         {
 124                 tuntaps[i] = create_interface();
 125
 126                 if (tuntaps[i] != NULL)
 127                 {
 128                         if (tuntaps[i]->initialize(dev_major, i))
 129                         {
 130                                 continue;
 131                         }
 132
 133                         /* error here. current interface needs to be shut down */
 134                         i++;
 135                 }
 136
 137                 /* something went wrong. clean up. */
 138                 while (--i >= 0)
 139                 {
 140                         tuntaps[i]->shutdown();
 141                         delete  tuntaps[i];
 142                 }
 143
 144                 return false;
 145         }
 146
 147         /* register the new family in the mgr switch */
 148         mgr_map[dev_major] = this;
 149
 150         log(LOG_INFO, "%s kernel extension version %s <mattias.nissler@gmx.de>\n",
 151                         family, TUNTAP_VERSION);
 152
 153         return true;
 154 }
 155
 156 bool
 157 tuntap_manager::shutdown()
 158 {
 159         bool ok = true;
 160
 161         /* we halt the whole thing while we check whether we can shutdown */
 162         auto_lock l(&cdev_gate);
 163
 164         /* anyone in? */
 165         if (cdev_gate.is_anyone_in()) {
 166                 dprintf("tuntap_mgr: won't shutdown, threads still behind the gate.");
 167                 ok = false;
 168         } else {
 169                 /* query the interfaces to see if shutting down is ok */
 170                 if (tuntaps != NULL) {
 171                         for (unsigned int i = 0; i < count; i++) {
 172                                 if (tuntaps[i] != NULL)
 173                                         ok &= tuntaps[i]->idle();
 174                         }
 175
 176                         /* if yes, do it now */
 177                         if (ok) {
 178                                 for (unsigned int i = 0; i < count; i++) {
 179                                         if (tuntaps[i] != NULL) {
 180                                                 tuntaps[i]->shutdown();
 181                                                 delete tuntaps[i];
 182                                                 tuntaps[i] = NULL;
 183                                         }
 184                                 }
 185                         }
 186                 }
 187         }
 188
 189         /* unregister the character device switch */
 190         if (ok) {
 191                 if (dev_major != -1 && cdevsw_remove(dev_major, &mgr_cdevsw) == -1) {
 192                         log(LOG_WARNING,
 193                                 "%s: character device switch got lost. strange.\n", family);
 194                 }
 195                 mgr_map[dev_major] = NULL;
 196                 dev_major = -1;
 197
 198                 /* at this point there is still a chance that some thread hangs at the cdev_gate in
 199                  * one of the cdev service functions. I can't imagine any way that would aviod this.
 200                  * So lets unblock the gate such that they fail.
 201                  */
 202                 unsigned int old_number;
 203                 do {
 204                         old_number = cdev_gate.get_ticket_number();
 205                         l.unlock();
 206
 207                         dprintf("tuntap_manager: waiting for other threads to give up.\n");
 208
 209                         /* wait one second */
 210                         delay(1000000);
 211                         l.lock();
 212                 } while (cdev_gate.get_ticket_number() != old_number);
 213
 214                 /* I hope it is safe to unload now. */
 215
 216         } else {
 217                 log(LOG_WARNING, "%s: won't unload, at least one interface is busy.\n", family);
 218         }
 219
 220         dprintf("tuntap manager: shutdown %s\n", ok ? "ok" : "failed");
 221
 222         return ok;
 223 }
 224
 225 tuntap_manager::~tuntap_manager()
 226 {
 227         dprintf("freeing interface table\n");
 228
 229         /* free memory */
 230         if (tuntaps != NULL)
 231                 kfree(tuntaps, count * sizeof(tuntap_interface *));
 232 }
 233
 234 /* service method dispatchers */
 235 int
 236 tuntap_manager::cdev_open(dev_t dev, int flags, int devtype, proc_t p)
 237 {
 238         return (mgr_map[major(dev)] == NULL ? ENOENT
 239                         : mgr_map[major(dev)]->do_cdev_open(dev, flags, devtype, p));
 240 }
 241
 242 int
 243 tuntap_manager::cdev_close(dev_t dev, int flags, int devtype, proc_t p)
 244 {
 245         return (mgr_map[major(dev)] == NULL ? EBADF
 246                         : mgr_map[major(dev)]->do_cdev_close(dev, flags, devtype, p));
 247 }
 248
 249 int
 250 tuntap_manager::cdev_read(dev_t dev, uio_t uio, int ioflag)
 251 {
 252         return (mgr_map[major(dev)] == NULL ? EBADF
 253                         : mgr_map[major(dev)]->do_cdev_read(dev, uio, ioflag));
 254 }
 255
 256 int
 257 tuntap_manager::cdev_write(dev_t dev, uio_t uio, int ioflag)
 258 {
 259         return (mgr_map[major(dev)] == NULL ? EBADF
 260                         : mgr_map[major(dev)]->do_cdev_write(dev, uio, ioflag));
 261 }
 262
 263 int
 264 tuntap_manager::cdev_ioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, proc_t p)
 265 {
 266         return (mgr_map[major(dev)] == NULL ? EBADF
 267                         : mgr_map[major(dev)]->do_cdev_ioctl(dev, cmd, data, fflag, p));
 268 }
 269
 270 int
 271 tuntap_manager::cdev_select(dev_t dev, int which, void *wql, proc_t p)
 272 {
 273         return (mgr_map[major(dev)] == NULL ? EBADF
 274                         : mgr_map[major(dev)]->do_cdev_select(dev, which, wql, p));
 275 }
 276
 277 /* character device service methods */
 278 int
 279 tuntap_manager::do_cdev_open(dev_t dev, int flags, int devtype, proc_t p)
 280 {
 281         int dmin = minor(dev);
 282         int error = ENOENT;
 283
 284         cdev_gate.enter();
 285
 286         if (dmin < (int) count && dmin >= 0 && tuntaps[dmin] != NULL)
 287                 error = tuntaps[dmin]->cdev_open(flags, devtype, p);
 288
 289         cdev_gate.exit();
 290
 291         return error;
 292 }
 293
 294 int
 295 tuntap_manager::do_cdev_close(dev_t dev, int flags, int devtype, proc_t p)
 296 {
 297         int dmin = minor(dev);
 298         int error = EBADF;
 299
 300         cdev_gate.enter();
 301
 302         if (dmin < (int) count && dmin >= 0 && tuntaps[dmin] != NULL)
 303                 error = tuntaps[dmin]->cdev_close(flags, devtype, p);
 304
 305         cdev_gate.exit();
 306
 307         return error;
 308 }
 309
 310 int
 311 tuntap_manager::do_cdev_read(dev_t dev, uio_t uio, int ioflag)
 312 {
 313         int dmin = minor(dev);
 314         int error = EBADF;
 315
 316         cdev_gate.enter();
 317
 318         if (dmin < (int) count && dmin >= 0 && tuntaps[dmin] != NULL)
 319                 error = tuntaps[dmin]->cdev_read(uio, ioflag);
 320
 321         cdev_gate.exit();
 322
 323         return error;
 324 }
 325
 326 int
 327 tuntap_manager::do_cdev_write(dev_t dev, uio_t uio, int ioflag)
 328 {
 329         int dmin = minor(dev);
 330         int error = EBADF;
 331
 332         cdev_gate.enter();
 333
 334         if (dmin < (int) count && dmin >= 0 && tuntaps[dmin] != NULL)
 335                 error = tuntaps[dmin]->cdev_write(uio, ioflag);
 336
 337         cdev_gate.exit();
 338
 339         return error;
 340 }
 341
 342 int
 343 tuntap_manager::do_cdev_ioctl(dev_t dev, u_long cmd, caddr_t data, int fflag, proc_t p)
 344 {
 345         int dmin = minor(dev);
 346         int error = EBADF;
 347
 348         cdev_gate.enter();
 349
 350         if (dmin < (int) count && dmin >= 0 && tuntaps[dmin] != NULL)
 351                 error = tuntaps[dmin]->cdev_ioctl(cmd, data, fflag, p);
 352
 353         cdev_gate.exit();
 354
 355         return error;
 356 }
 357
 358 int
 359 tuntap_manager::do_cdev_select(dev_t dev, int which, void *wql, proc_t p)
 360 {
 361         int dmin = minor(dev);
 362         int error = EBADF;
 363
 364         cdev_gate.enter();
 365
 366         if (dmin < (int) count && dmin >= 0 && tuntaps[dmin] != NULL)
 367                 error = tuntaps[dmin]->cdev_select(which, wql, p);
 368
 369         cdev_gate.exit();
 370
 371         return error;
 372 }
 373