sys/net/if_clone.c

   1 /*-
   2  * Copyright (c) 1980, 1986, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 4. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  *      @(#)if.c        8.5 (Berkeley) 1/9/95
  30  * $FreeBSD$
  31  */
  32
  33 #include <sys/param.h>
  34 #include <sys/malloc.h>
  35 #include <sys/limits.h>
  36 #include <sys/lock.h>
  37 #include <sys/mutex.h>
  38 #include <sys/kernel.h>
  39 #include <sys/systm.h>
  40 #include <sys/types.h>
  41 #include <sys/socket.h>
  42
  43 #include <net/if.h>
  44 #include <net/if_clone.h>
  45 #if 0
  46 #include <net/if_dl.h>
  47 #endif
  48 #include <net/if_types.h>
  49 #include <net/if_var.h>
  50 #include <net/radix.h>
  51 #include <net/route.h>
  52 #include <net/vnet.h>
  53
  54 static void     if_clone_free(struct if_clone *ifc);
  55 static int      if_clone_createif(struct if_clone *ifc, char *name, size_t len,
  56                     caddr_t params);
  57
  58 static struct mtx       if_cloners_mtx;
  59 static VNET_DEFINE(int, if_cloners_count);
  60 VNET_DEFINE(LIST_HEAD(, if_clone), if_cloners);
  61
  62 #define V_if_cloners_count      VNET(if_cloners_count)
  63 #define V_if_cloners            VNET(if_cloners)
  64
  65 #define IF_CLONERS_LOCK_INIT()          \
  66     mtx_init(&if_cloners_mtx, "if_cloners lock", NULL, MTX_DEF)
  67 #define IF_CLONERS_LOCK_ASSERT()        mtx_assert(&if_cloners_mtx, MA_OWNED)
  68 #define IF_CLONERS_LOCK()               mtx_lock(&if_cloners_mtx)
  69 #define IF_CLONERS_UNLOCK()             mtx_unlock(&if_cloners_mtx)
  70
  71 #define IF_CLONE_LOCK_INIT(ifc)         \
  72     mtx_init(&(ifc)->ifc_mtx, "if_clone lock", NULL, MTX_DEF)
  73 #define IF_CLONE_LOCK_DESTROY(ifc)      mtx_destroy(&(ifc)->ifc_mtx)
  74 #define IF_CLONE_LOCK_ASSERT(ifc)       mtx_assert(&(ifc)->ifc_mtx, MA_OWNED)
  75 #define IF_CLONE_LOCK(ifc)              mtx_lock(&(ifc)->ifc_mtx)
  76 #define IF_CLONE_UNLOCK(ifc)            mtx_unlock(&(ifc)->ifc_mtx)
  77
  78 #define IF_CLONE_ADDREF(ifc)                                            \
  79         do {                                                            \
  80                 IF_CLONE_LOCK(ifc);                                     \
  81                 IF_CLONE_ADDREF_LOCKED(ifc);                            \
  82                 IF_CLONE_UNLOCK(ifc);                                   \
  83         } while (0)
  84 #define IF_CLONE_ADDREF_LOCKED(ifc)                                     \
  85         do {                                                            \
  86                 IF_CLONE_LOCK_ASSERT(ifc);                              \
  87                 KASSERT((ifc)->ifc_refcnt >= 0,                         \
  88                     ("negative refcnt %ld", (ifc)->ifc_refcnt));        \
  89                 (ifc)->ifc_refcnt++;                                    \
  90         } while (0)
  91 #define IF_CLONE_REMREF(ifc)                                            \
  92         do {                                                            \
  93                 IF_CLONE_LOCK(ifc);                                     \
  94                 IF_CLONE_REMREF_LOCKED(ifc);                            \
  95         } while (0)
  96 #define IF_CLONE_REMREF_LOCKED(ifc)                                     \
  97         do {                                                            \
  98                 IF_CLONE_LOCK_ASSERT(ifc);                              \
  99                 KASSERT((ifc)->ifc_refcnt > 0,                          \
 100                     ("bogus refcnt %ld", (ifc)->ifc_refcnt));           \
 101                 if (--(ifc)->ifc_refcnt == 0) {                         \
 102                         IF_CLONE_UNLOCK(ifc);                           \
 103                         if_clone_free(ifc);                             \
 104                 } else {                                                \
 105                         /* silently free the lock */                    \
 106                         IF_CLONE_UNLOCK(ifc);                           \
 107                 }                                                       \
 108         } while (0)
 109
 110 #define IFC_IFLIST_INSERT(_ifc, _ifp)                                   \
 111         LIST_INSERT_HEAD(&_ifc->ifc_iflist, _ifp, if_clones)
 112 #define IFC_IFLIST_REMOVE(_ifc, _ifp)                                   \
 113         LIST_REMOVE(_ifp, if_clones)
 114
 115 static MALLOC_DEFINE(M_CLONE, "clone", "interface cloning framework");
 116
 117 void
 118 vnet_if_clone_init(void)
 119 {
 120
 121         LIST_INIT(&V_if_cloners);
 122 }
 123
 124 void
 125 if_clone_init(void)
 126 {
 127
 128         IF_CLONERS_LOCK_INIT();
 129 }
 130
 131 /*
 132  * Lookup and create a clone network interface.
 133  */
 134 int
 135 if_clone_create(char *name, size_t len, caddr_t params)
 136 {
 137         struct if_clone *ifc;
 138
 139         /* Try to find an applicable cloner for this request */
 140         IF_CLONERS_LOCK();
 141         LIST_FOREACH(ifc, &V_if_cloners, ifc_list) {
 142                 if (ifc->ifc_match(ifc, name)) {
 143                         break;
 144                 }
 145         }
 146 #ifdef VIMAGE
 147         if (ifc == NULL && !IS_DEFAULT_VNET(curvnet)) {
 148                 CURVNET_SET_QUIET(vnet0);
 149                 LIST_FOREACH(ifc, &V_if_cloners, ifc_list) {
 150                         if (ifc->ifc_match(ifc, name))
 151                                 break;
 152                 }
 153                 CURVNET_RESTORE();
 154         }
 155 #endif
 156         IF_CLONERS_UNLOCK();
 157
 158         if (ifc == NULL)
 159                 return (EINVAL);
 160
 161         return (if_clone_createif(ifc, name, len, params));
 162 }
 163
 164 /*
 165  * Create a clone network interface.
 166  */
 167 static int
 168 if_clone_createif(struct if_clone *ifc, char *name, size_t len, caddr_t params)
 169 {
 170         int err;
 171         struct ifnet *ifp;
 172
 173         if (ifunit(name) != NULL)
 174                 return (EEXIST);
 175
 176         err = (*ifc->ifc_create)(ifc, name, len, params);
 177
 178         if (!err) {
 179                 ifp = ifunit(name);
 180                 if (ifp == NULL)
 181                         panic("%s: lookup failed for %s", __func__, name);
 182
 183                 if_addgroup(ifp, ifc->ifc_name);
 184
 185                 IF_CLONE_LOCK(ifc);
 186                 IFC_IFLIST_INSERT(ifc, ifp);
 187                 IF_CLONE_UNLOCK(ifc);
 188         }
 189
 190         return (err);
 191 }
 192
 193 /*
 194  * Lookup and destroy a clone network interface.
 195  */
 196 int
 197 if_clone_destroy(const char *name)
 198 {
 199         struct if_clone *ifc;
 200         struct ifnet *ifp;
 201
 202         ifp = ifunit(name);
 203         if (ifp == NULL)
 204                 return (ENXIO);
 205
 206         /* Find the cloner for this interface */
 207         IF_CLONERS_LOCK();
 208         LIST_FOREACH(ifc, &V_if_cloners, ifc_list) {
 209                 if (strcmp(ifc->ifc_name, ifp->if_dname) == 0) {
 210                         break;
 211                 }
 212         }
 213 #ifdef VIMAGE
 214         if (ifc == NULL && !IS_DEFAULT_VNET(curvnet)) {
 215                 CURVNET_SET_QUIET(vnet0);
 216                 LIST_FOREACH(ifc, &V_if_cloners, ifc_list) {
 217                         if (ifc->ifc_match(ifc, name))
 218                                 break;
 219                 }
 220                 CURVNET_RESTORE();
 221         }
 222 #endif
 223         IF_CLONERS_UNLOCK();
 224         if (ifc == NULL)
 225                 return (EINVAL);
 226
 227         return (if_clone_destroyif(ifc, ifp));
 228 }
 229
 230 /*
 231  * Destroy a clone network interface.
 232  */
 233 int
 234 if_clone_destroyif(struct if_clone *ifc, struct ifnet *ifp)
 235 {
 236         int err;
 237
 238         if (ifc->ifc_destroy == NULL)
 239                 return(EOPNOTSUPP);
 240
 241         /*
 242          * Given that the cloned ifnet might be attached to a different
 243          * vnet from where its cloner was registered, we have to
 244          * switch to the vnet context of the target vnet.
 245          */
 246         CURVNET_SET_QUIET(ifp->if_vnet);
 247
 248         IF_CLONE_LOCK(ifc);
 249         IFC_IFLIST_REMOVE(ifc, ifp);
 250         IF_CLONE_UNLOCK(ifc);
 251
 252         if_delgroup(ifp, ifc->ifc_name);
 253
 254         err =  (*ifc->ifc_destroy)(ifc, ifp);
 255
 256         if (err != 0) {
 257                 if_addgroup(ifp, ifc->ifc_name);
 258
 259                 IF_CLONE_LOCK(ifc);
 260                 IFC_IFLIST_INSERT(ifc, ifp);
 261                 IF_CLONE_UNLOCK(ifc);
 262         }
 263         CURVNET_RESTORE();
 264         return (err);
 265 }
 266
 267 /*
 268  * Register a network interface cloner.
 269  */
 270 void
 271 if_clone_attach(struct if_clone *ifc)
 272 {
 273         int len, maxclone;
 274
 275         /*
 276          * Compute bitmap size and allocate it.
 277          */
 278         maxclone = ifc->ifc_maxunit + 1;
 279         len = maxclone >> 3;
 280         if ((len << 3) < maxclone)
 281                 len++;
 282         ifc->ifc_units = malloc(len, M_CLONE, M_WAITOK | M_ZERO);
 283         ifc->ifc_bmlen = len;
 284         IF_CLONE_LOCK_INIT(ifc);
 285         IF_CLONE_ADDREF(ifc);
 286
 287         IF_CLONERS_LOCK();
 288         LIST_INSERT_HEAD(&V_if_cloners, ifc, ifc_list);
 289         V_if_cloners_count++;
 290         IF_CLONERS_UNLOCK();
 291
 292         LIST_INIT(&ifc->ifc_iflist);
 293
 294         if (ifc->ifc_attach != NULL)
 295                 (*ifc->ifc_attach)(ifc);
 296         EVENTHANDLER_INVOKE(if_clone_event, ifc);
 297 }
 298
 299 /*
 300  * Unregister a network interface cloner.
 301  */
 302 void
 303 if_clone_detach(struct if_clone *ifc)
 304 {
 305         struct ifc_simple_data *ifcs = ifc->ifc_data;
 306
 307         IF_CLONERS_LOCK();
 308         LIST_REMOVE(ifc, ifc_list);
 309         V_if_cloners_count--;
 310         IF_CLONERS_UNLOCK();
 311
 312         /* Allow all simples to be destroyed */
 313         if (ifc->ifc_attach == ifc_simple_attach)
 314                 ifcs->ifcs_minifs = 0;
 315
 316         /* destroy all interfaces for this cloner */
 317         while (!LIST_EMPTY(&ifc->ifc_iflist))
 318                 if_clone_destroyif(ifc, LIST_FIRST(&ifc->ifc_iflist));
 319
 320         IF_CLONE_REMREF(ifc);
 321 }
 322
 323 static void
 324 if_clone_free(struct if_clone *ifc)
 325 {
 326         for (int bytoff = 0; bytoff < ifc->ifc_bmlen; bytoff++) {
 327                 KASSERT(ifc->ifc_units[bytoff] == 0x00,
 328                     ("ifc_units[%d] is not empty", bytoff));
 329         }
 330
 331         KASSERT(LIST_EMPTY(&ifc->ifc_iflist),
 332             ("%s: ifc_iflist not empty", __func__));
 333
 334         IF_CLONE_LOCK_DESTROY(ifc);
 335         free(ifc->ifc_units, M_CLONE);
 336 }
 337
 338 /*
 339  * Provide list of interface cloners to userspace.
 340  */
 341 int
 342 if_clone_list(struct if_clonereq *ifcr)
 343 {
 344         char *buf, *dst, *outbuf = NULL;
 345         struct if_clone *ifc;
 346         int buf_count, count, err = 0;
 347
 348         if (ifcr->ifcr_count < 0)
 349                 return (EINVAL);
 350
 351         IF_CLONERS_LOCK();
 352         /*
 353          * Set our internal output buffer size.  We could end up not
 354          * reporting a cloner that is added between the unlock and lock
 355          * below, but that's not a major problem.  Not caping our
 356          * allocation to the number of cloners actually in the system
 357          * could be because that would let arbitrary users cause us to
 358          * allocate abritrary amounts of kernel memory.
 359          */
 360         buf_count = (V_if_cloners_count < ifcr->ifcr_count) ?
 361             V_if_cloners_count : ifcr->ifcr_count;
 362         IF_CLONERS_UNLOCK();
 363
 364         outbuf = malloc(IFNAMSIZ*buf_count, M_CLONE, M_WAITOK | M_ZERO);
 365
 366         IF_CLONERS_LOCK();
 367
 368         ifcr->ifcr_total = V_if_cloners_count;
 369         if ((dst = ifcr->ifcr_buffer) == NULL) {
 370                 /* Just asking how many there are. */
 371                 goto done;
 372         }
 373         count = (V_if_cloners_count < buf_count) ?
 374             V_if_cloners_count : buf_count;
 375
 376         for (ifc = LIST_FIRST(&V_if_cloners), buf = outbuf;
 377             ifc != NULL && count != 0;
 378             ifc = LIST_NEXT(ifc, ifc_list), count--, buf += IFNAMSIZ) {
 379                 strlcpy(buf, ifc->ifc_name, IFNAMSIZ);
 380         }
 381
 382 done:
 383         IF_CLONERS_UNLOCK();
 384         if (err == 0)
 385                 err = copyout(outbuf, dst, buf_count*IFNAMSIZ);
 386         if (outbuf != NULL)
 387                 free(outbuf, M_CLONE);
 388         return (err);
 389 }
 390
 391 /*
 392  * A utility function to extract unit numbers from interface names of
 393  * the form name###.
 394  *
 395  * Returns 0 on success and an error on failure.
 396  */
 397 int
 398 ifc_name2unit(const char *name, int *unit)
 399 {
 400         const char      *cp;
 401         int             cutoff = INT_MAX / 10;
 402         int             cutlim = INT_MAX % 10;
 403
 404         for (cp = name; *cp != '\0' && (*cp < '0' || *cp > '9'); cp++);
 405         if (*cp == '\0') {
 406                 *unit = -1;
 407         } else if (cp[0] == '0' && cp[1] != '\0') {
 408                 /* Disallow leading zeroes. */
 409                 return (EINVAL);
 410         } else {
 411                 for (*unit = 0; *cp != '\0'; cp++) {
 412                         if (*cp < '0' || *cp > '9') {
 413                                 /* Bogus unit number. */
 414                                 return (EINVAL);
 415                         }
 416                         if (*unit > cutoff ||
 417                             (*unit == cutoff && *cp - '0' > cutlim))
 418                                 return (EINVAL);
 419                         *unit = (*unit * 10) + (*cp - '0');
 420                 }
 421         }
 422
 423         return (0);
 424 }
 425
 426 int
 427 ifc_alloc_unit(struct if_clone *ifc, int *unit)
 428 {
 429         int wildcard, bytoff, bitoff;
 430         int err = 0;
 431
 432         IF_CLONE_LOCK(ifc);
 433
 434         bytoff = bitoff = 0;
 435         wildcard = (*unit < 0);
 436         /*
 437          * Find a free unit if none was given.
 438          */
 439         if (wildcard) {
 440                 while ((bytoff < ifc->ifc_bmlen)
 441                     && (ifc->ifc_units[bytoff] == 0xff))
 442                         bytoff++;
 443                 if (bytoff >= ifc->ifc_bmlen) {
 444                         err = ENOSPC;
 445                         goto done;
 446                 }
 447                 while ((ifc->ifc_units[bytoff] & (1 << bitoff)) != 0)
 448                         bitoff++;
 449                 *unit = (bytoff << 3) + bitoff;
 450         }
 451
 452         if (*unit > ifc->ifc_maxunit) {
 453                 err = ENOSPC;
 454                 goto done;
 455         }
 456
 457         if (!wildcard) {
 458                 bytoff = *unit >> 3;
 459                 bitoff = *unit - (bytoff << 3);
 460         }
 461
 462         if((ifc->ifc_units[bytoff] & (1 << bitoff)) != 0) {
 463                 err = EEXIST;
 464                 goto done;
 465         }
 466         /*
 467          * Allocate the unit in the bitmap.
 468          */
 469         KASSERT((ifc->ifc_units[bytoff] & (1 << bitoff)) == 0,
 470             ("%s: bit is already set", __func__));
 471         ifc->ifc_units[bytoff] |= (1 << bitoff);
 472         IF_CLONE_ADDREF_LOCKED(ifc);
 473
 474 done:
 475         IF_CLONE_UNLOCK(ifc);
 476         return (err);
 477 }
 478
 479 void
 480 ifc_free_unit(struct if_clone *ifc, int unit)
 481 {
 482         int bytoff, bitoff;
 483
 484
 485         /*
 486          * Compute offset in the bitmap and deallocate the unit.
 487          */
 488         bytoff = unit >> 3;
 489         bitoff = unit - (bytoff << 3);
 490
 491         IF_CLONE_LOCK(ifc);
 492         KASSERT((ifc->ifc_units[bytoff] & (1 << bitoff)) != 0,
 493             ("%s: bit is already cleared", __func__));
 494         ifc->ifc_units[bytoff] &= ~(1 << bitoff);
 495         IF_CLONE_REMREF_LOCKED(ifc);    /* releases lock */
 496 }
 497
 498 void
 499 ifc_simple_attach(struct if_clone *ifc)
 500 {
 501         int err;
 502         int unit;
 503         char name[IFNAMSIZ];
 504         struct ifc_simple_data *ifcs = ifc->ifc_data;
 505
 506         KASSERT(ifcs->ifcs_minifs - 1 <= ifc->ifc_maxunit,
 507             ("%s: %s requested more units than allowed (%d > %d)",
 508             __func__, ifc->ifc_name, ifcs->ifcs_minifs,
 509             ifc->ifc_maxunit + 1));
 510
 511         for (unit = 0; unit < ifcs->ifcs_minifs; unit++) {
 512                 snprintf(name, IFNAMSIZ, "%s%d", ifc->ifc_name, unit);
 513                 err = if_clone_createif(ifc, name, IFNAMSIZ, NULL);
 514                 KASSERT(err == 0,
 515                     ("%s: failed to create required interface %s",
 516                     __func__, name));
 517         }
 518 }
 519
 520 int
 521 ifc_simple_match(struct if_clone *ifc, const char *name)
 522 {
 523         const char *cp;
 524         int i;
 525
 526         /* Match the name */
 527         for (cp = name, i = 0; i < strlen(ifc->ifc_name); i++, cp++) {
 528                 if (ifc->ifc_name[i] != *cp)
 529                         return (0);
 530         }
 531
 532         /* Make sure there's a unit number or nothing after the name */
 533         for (; *cp != '\0'; cp++) {
 534                 if (*cp < '0' || *cp > '9')
 535                         return (0);
 536         }
 537
 538         return (1);
 539 }
 540
 541 int
 542 ifc_simple_create(struct if_clone *ifc, char *name, size_t len, caddr_t params)
 543 {
 544         char *dp;
 545         int wildcard;
 546         int unit;
 547         int err;
 548         struct ifc_simple_data *ifcs = ifc->ifc_data;
 549
 550         err = ifc_name2unit(name, &unit);
 551         if (err != 0)
 552                 return (err);
 553
 554         wildcard = (unit < 0);
 555
 556         err = ifc_alloc_unit(ifc, &unit);
 557         if (err != 0)
 558                 return (err);
 559
 560         err = ifcs->ifcs_create(ifc, unit, params);
 561         if (err != 0) {
 562                 ifc_free_unit(ifc, unit);
 563                 return (err);
 564         }
 565
 566         /* In the wildcard case, we need to update the name. */
 567         if (wildcard) {
 568                 for (dp = name; *dp != '\0'; dp++);
 569                 if (snprintf(dp, len - (dp-name), "%d", unit) >
 570                     len - (dp-name) - 1) {
 571                         /*
 572                          * This can only be a programmer error and
 573                          * there's no straightforward way to recover if
 574                          * it happens.
 575                          */
 576                         panic("if_clone_create(): interface name too long");
 577                 }
 578
 579         }
 580
 581         return (0);
 582 }
 583
 584 int
 585 ifc_simple_destroy(struct if_clone *ifc, struct ifnet *ifp)
 586 {
 587         int unit;
 588         struct ifc_simple_data *ifcs = ifc->ifc_data;
 589
 590         unit = ifp->if_dunit;
 591
 592         if (unit < ifcs->ifcs_minifs)
 593                 return (EINVAL);
 594
 595         ifcs->ifcs_destroy(ifp);
 596
 597         ifc_free_unit(ifc, unit);
 598
 599         return (0);
 600 }