6/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/lock.h>
  36 #include <sys/mutex.h>
  37 #include <sys/kernel.h>
  38 #include <sys/systm.h>
  39 #include <sys/types.h>
  40 #include <sys/socket.h>
  41
  42 #include <net/if.h>
  43 #include <net/if_clone.h>
  44 #if 0
  45 #include <net/if_dl.h>
  46 #endif
  47 #include <net/if_types.h>
  48 #include <net/if_var.h>
  49 #include <net/radix.h>
  50 #include <net/route.h>
  51
  52 static void             if_clone_free(struct if_clone *ifc);
  53
  54 static struct mtx       if_cloners_mtx;
  55 static int              if_cloners_count;
  56 LIST_HEAD(, if_clone)   if_cloners = LIST_HEAD_INITIALIZER(if_cloners);
  57
  58 #define IF_CLONERS_LOCK_INIT()          \
  59     mtx_init(&if_cloners_mtx, "if_cloners lock", NULL, MTX_DEF)
  60 #define IF_CLONERS_LOCK_ASSERT()        mtx_assert(&if_cloners_mtx, MA_OWNED)
  61 #define IF_CLONERS_LOCK()               mtx_lock(&if_cloners_mtx)
  62 #define IF_CLONERS_UNLOCK()             mtx_unlock(&if_cloners_mtx)
  63
  64 #define IF_CLONE_LOCK_INIT(ifc)         \
  65     mtx_init(&(ifc)->ifc_mtx, "if_clone lock", NULL, MTX_DEF)
  66 #define IF_CLONE_LOCK_DESTROY(ifc)      mtx_destroy(&(ifc)->ifc_mtx)
  67 #define IF_CLONE_LOCK_ASSERT(ifc)       mtx_assert(&(ifc)->ifc_mtx, MA_OWNED)
  68 #define IF_CLONE_LOCK(ifc)              mtx_lock(&(ifc)->ifc_mtx)
  69 #define IF_CLONE_UNLOCK(ifc)            mtx_unlock(&(ifc)->ifc_mtx)
  70
  71 #define IF_CLONE_ADDREF(ifc)                                            \
  72         do {                                                            \
  73                 IF_CLONE_LOCK(ifc);                                     \
  74                 IF_CLONE_ADDREF_LOCKED(ifc);                            \
  75                 IF_CLONE_UNLOCK(ifc);                                   \
  76         } while (0)
  77 #define IF_CLONE_ADDREF_LOCKED(ifc)                                     \
  78         do {                                                            \
  79                 IF_CLONE_LOCK_ASSERT(ifc);                              \
  80                 KASSERT((ifc)->ifc_refcnt >= 0,                         \
  81                     ("negative refcnt %ld", (ifc)->ifc_refcnt));        \
  82                 (ifc)->ifc_refcnt++;                                    \
  83         } while (0)
  84 #define IF_CLONE_REMREF(ifc)                                            \
  85         do {                                                            \
  86                 IF_CLONE_LOCK(ifc);                                     \
  87                 IF_CLONE_REMREF_LOCKED(ifc);                            \
  88         } while (0)
  89 #define IF_CLONE_REMREF_LOCKED(ifc)                                     \
  90         do {                                                            \
  91                 IF_CLONE_LOCK_ASSERT(ifc);                              \
  92                 KASSERT((ifc)->ifc_refcnt > 0,                          \
  93                     ("bogus refcnt %ld", (ifc)->ifc_refcnt));           \
  94                 if (--(ifc)->ifc_refcnt == 0) {                         \
  95                         IF_CLONE_UNLOCK(ifc);                           \
  96                         if_clone_free(ifc);                             \
  97                 } else {                                                \
  98                         /* silently free the lock */                    \
  99                         IF_CLONE_UNLOCK(ifc);                           \
 100                 }                                                       \
 101         } while (0)
 102
 103 static MALLOC_DEFINE(M_CLONE, "clone", "interface cloning framework");
 104
 105 void
 106 if_clone_init(void)
 107 {
 108         IF_CLONERS_LOCK_INIT();
 109 }
 110
 111 /*
 112  * Create a clone network interface.
 113  */
 114 int
 115 if_clone_create(char *name, size_t len)
 116 {
 117         int err;
 118         struct if_clone *ifc;
 119
 120         if (ifunit(name) != NULL)
 121                 return (EEXIST);
 122
 123         /* Try to find an applicable cloner for this request */
 124         IF_CLONERS_LOCK();
 125         LIST_FOREACH(ifc, &if_cloners, ifc_list) {
 126                 if (ifc->ifc_match(ifc, name)) {
 127                         IF_CLONE_ADDREF(ifc);
 128                         break;
 129                 }
 130         }
 131         IF_CLONERS_UNLOCK();
 132
 133         if (ifc == NULL)
 134                 return (EINVAL);
 135
 136         err = (*ifc->ifc_create)(ifc, name, len);
 137         IF_CLONE_REMREF(ifc);
 138         return (err);
 139 }
 140
 141 /*
 142  * Destroy a clone network interface.
 143  */
 144 int
 145 if_clone_destroy(const char *name)
 146 {
 147         int err;
 148         struct if_clone *ifc;
 149         struct ifnet *ifp;
 150
 151         ifp = ifunit(name);
 152         if (ifp == NULL)
 153                 return (ENXIO);
 154
 155         /* Find the cloner for this interface */
 156         IF_CLONERS_LOCK();
 157         LIST_FOREACH(ifc, &if_cloners, ifc_list) {
 158                 if (strcmp(ifc->ifc_name, ifp->if_dname) == 0) {
 159                         IF_CLONE_ADDREF(ifc);
 160                         break;
 161                 }
 162         }
 163         IF_CLONERS_UNLOCK();
 164         if (ifc == NULL)
 165                 return (EINVAL);
 166
 167         if (ifc->ifc_destroy == NULL) {
 168                 err = EOPNOTSUPP;
 169                 goto done;
 170         }
 171
 172         err =  (*ifc->ifc_destroy)(ifc, ifp);
 173
 174 done:
 175         IF_CLONE_REMREF(ifc);
 176         return (err);
 177 }
 178
 179 /*
 180  * Register a network interface cloner.
 181  */
 182 void
 183 if_clone_attach(struct if_clone *ifc)
 184 {
 185         int len, maxclone;
 186
 187         /*
 188          * Compute bitmap size and allocate it.
 189          */
 190         maxclone = ifc->ifc_maxunit + 1;
 191         len = maxclone >> 3;
 192         if ((len << 3) < maxclone)
 193                 len++;
 194         ifc->ifc_units = malloc(len, M_CLONE, M_WAITOK | M_ZERO);
 195         ifc->ifc_bmlen = len;
 196         IF_CLONE_LOCK_INIT(ifc);
 197         IF_CLONE_ADDREF(ifc);
 198
 199         IF_CLONERS_LOCK();
 200         LIST_INSERT_HEAD(&if_cloners, ifc, ifc_list);
 201         if_cloners_count++;
 202         IF_CLONERS_UNLOCK();
 203
 204         if (ifc->ifc_attach != NULL)
 205                 (*ifc->ifc_attach)(ifc);
 206         EVENTHANDLER_INVOKE(if_clone_event, ifc);
 207 }
 208
 209 /*
 210  * Unregister a network interface cloner.
 211  */
 212 void
 213 if_clone_detach(struct if_clone *ifc)
 214 {
 215
 216         IF_CLONERS_LOCK();
 217         LIST_REMOVE(ifc, ifc_list);
 218         if_cloners_count--;
 219         IF_CLONERS_UNLOCK();
 220
 221         IF_CLONE_REMREF(ifc);
 222 }
 223
 224 static void
 225 if_clone_free(struct if_clone *ifc)
 226 {
 227
 228         IF_CLONE_LOCK_DESTROY(ifc);
 229         free(ifc->ifc_units, M_CLONE);
 230 }
 231
 232 /*
 233  * Provide list of interface cloners to userspace.
 234  */
 235 int
 236 if_clone_list(struct if_clonereq *ifcr)
 237 {
 238         char *buf, *dst, *outbuf = NULL;
 239         struct if_clone *ifc;
 240         int buf_count, count, err = 0;
 241
 242         if (ifcr->ifcr_count < 0)
 243                 return (EINVAL);
 244
 245         IF_CLONERS_LOCK();
 246         /*
 247          * Set our internal output buffer size.  We could end up not
 248          * reporting a cloner that is added between the unlock and lock
 249          * below, but that's not a major problem.  Not caping our
 250          * allocation to the number of cloners actually in the system
 251          * could be because that would let arbitrary users cause us to
 252          * allocate abritrary amounts of kernel memory.
 253          */
 254         buf_count = (if_cloners_count < ifcr->ifcr_count) ?
 255             if_cloners_count : ifcr->ifcr_count;
 256         IF_CLONERS_UNLOCK();
 257
 258         outbuf = malloc(IFNAMSIZ*buf_count, M_CLONE, M_WAITOK | M_ZERO);
 259
 260         IF_CLONERS_LOCK();
 261
 262         ifcr->ifcr_total = if_cloners_count;
 263         if ((dst = ifcr->ifcr_buffer) == NULL) {
 264                 /* Just asking how many there are. */
 265                 goto done;
 266         }
 267         count = (if_cloners_count < buf_count) ?
 268             if_cloners_count : buf_count;
 269
 270         for (ifc = LIST_FIRST(&if_cloners), buf = outbuf;
 271             ifc != NULL && count != 0;
 272             ifc = LIST_NEXT(ifc, ifc_list), count--, buf += IFNAMSIZ) {
 273                 strlcpy(buf, ifc->ifc_name, IFNAMSIZ);
 274         }
 275
 276 done:
 277         IF_CLONERS_UNLOCK();
 278         if (err == 0)
 279                 err = copyout(outbuf, dst, buf_count*IFNAMSIZ);
 280         if (outbuf != NULL)
 281                 free(outbuf, M_CLONE);
 282         return (err);
 283 }
 284
 285 /*
 286  * A utility function to extract unit numbers from interface names of
 287  * the form name###.
 288  *
 289  * Returns 0 on success and an error on failure.
 290  */
 291 int
 292 ifc_name2unit(const char *name, int *unit)
 293 {
 294         const char      *cp;
 295
 296         for (cp = name; *cp != '\0' && (*cp < '0' || *cp > '9'); cp++);
 297         if (*cp == '\0') {
 298                 *unit = -1;
 299         } else {
 300                 for (*unit = 0; *cp != '\0'; cp++) {
 301                         if (*cp < '0' || *cp > '9') {
 302                                 /* Bogus unit number. */
 303                                 return (EINVAL);
 304                         }
 305                         *unit = (*unit * 10) + (*cp - '0');
 306                 }
 307         }
 308
 309         return (0);
 310 }
 311
 312 int
 313 ifc_alloc_unit(struct if_clone *ifc, int *unit)
 314 {
 315         int wildcard, bytoff, bitoff;
 316         int err = 0;
 317
 318         IF_CLONE_LOCK(ifc);
 319
 320         bytoff = bitoff = 0;
 321         wildcard = (*unit < 0);
 322         /*
 323          * Find a free unit if none was given.
 324          */
 325         if (wildcard) {
 326                 while ((bytoff < ifc->ifc_bmlen)
 327                     && (ifc->ifc_units[bytoff] == 0xff))
 328                         bytoff++;
 329                 if (bytoff >= ifc->ifc_bmlen) {
 330                         err = ENOSPC;
 331                         goto done;
 332                 }
 333                 while ((ifc->ifc_units[bytoff] & (1 << bitoff)) != 0)
 334                         bitoff++;
 335                 *unit = (bytoff << 3) + bitoff;
 336         }
 337
 338         if (*unit > ifc->ifc_maxunit) {
 339                 err = ENOSPC;
 340                 goto done;
 341         }
 342
 343         if (!wildcard) {
 344                 bytoff = *unit >> 3;
 345                 bitoff = *unit - (bytoff << 3);
 346         }
 347
 348         if((ifc->ifc_units[bytoff] & (1 << bitoff)) != 0) {
 349                 err = EEXIST;
 350                 goto done;
 351         }
 352         /*
 353          * Allocate the unit in the bitmap.
 354          */
 355         ifc->ifc_units[bytoff] |= (1 << bitoff);
 356
 357 done:
 358         IF_CLONE_UNLOCK(ifc);
 359         return (err);
 360 }
 361
 362 void
 363 ifc_free_unit(struct if_clone *ifc, int unit)
 364 {
 365         int bytoff, bitoff;
 366
 367
 368         /*
 369          * Compute offset in the bitmap and deallocate the unit.
 370          */
 371         bytoff = unit >> 3;
 372         bitoff = unit - (bytoff << 3);
 373
 374         IF_CLONE_LOCK(ifc);
 375         KASSERT((ifc->ifc_units[bytoff] & (1 << bitoff)) != 0,
 376             ("%s: bit is already cleared", __func__));
 377         ifc->ifc_units[bytoff] &= ~(1 << bitoff);
 378         IF_CLONE_UNLOCK(ifc);
 379 }
 380
 381 void
 382 ifc_simple_attach(struct if_clone *ifc)
 383 {
 384         int err;
 385         int unit;
 386         char name[IFNAMSIZ];
 387         struct ifc_simple_data *ifcs = ifc->ifc_data;
 388
 389         KASSERT(ifcs->ifcs_minifs - 1 <= ifc->ifc_maxunit,
 390             ("%s: %s requested more units then allowed (%d > %d)",
 391             __func__, ifc->ifc_name, ifcs->ifcs_minifs,
 392             ifc->ifc_maxunit + 1));
 393
 394         for (unit = 0; unit < ifcs->ifcs_minifs; unit++) {
 395                 snprintf(name, IFNAMSIZ, "%s%d", ifc->ifc_name, unit);
 396                 err = (*ifc->ifc_create)(ifc, name, IFNAMSIZ);
 397                 KASSERT(err == 0,
 398                     ("%s: failed to create required interface %s",
 399                     __func__, name));
 400         }
 401 }
 402
 403 int
 404 ifc_simple_match(struct if_clone *ifc, const char *name)
 405 {
 406         const char *cp;
 407         int i;
 408
 409         /* Match the name */
 410         for (cp = name, i = 0; i < strlen(ifc->ifc_name); i++, cp++) {
 411                 if (ifc->ifc_name[i] != *cp)
 412                         return (0);
 413         }
 414
 415         /* Make sure there's a unit number or nothing after the name */
 416         for (; *cp != '\0'; cp++) {
 417                 if (*cp < '0' || *cp > '9')
 418                         return (0);
 419         }
 420
 421         return (1);
 422 }
 423
 424 int
 425 ifc_simple_create(struct if_clone *ifc, char *name, size_t len)
 426 {
 427         char *dp;
 428         int wildcard;
 429         int unit;
 430         int err;
 431         struct ifc_simple_data *ifcs = ifc->ifc_data;
 432
 433         err = ifc_name2unit(name, &unit);
 434         if (err != 0)
 435                 return (err);
 436
 437         wildcard = (unit < 0);
 438
 439         err = ifc_alloc_unit(ifc, &unit);
 440         if (err != 0)
 441                 return (err);
 442
 443         err = ifcs->ifcs_create(ifc, unit);
 444         if (err != 0) {
 445                 ifc_free_unit(ifc, unit);
 446                 return (err);
 447         }
 448
 449         /* In the wildcard case, we need to update the name. */
 450         if (wildcard) {
 451                 for (dp = name; *dp != '\0'; dp++);
 452                 if (snprintf(dp, len - (dp-name), "%d", unit) >
 453                     len - (dp-name) - 1) {
 454                         /*
 455                          * This can only be a programmer error and
 456                          * there's no straightforward way to recover if
 457                          * it happens.
 458                          */
 459                         panic("if_clone_create(): interface name too long");
 460                 }
 461
 462         }
 463
 464         return (0);
 465 }
 466
 467 int
 468 ifc_simple_destroy(struct if_clone *ifc, struct ifnet *ifp)
 469 {
 470         int unit;
 471         struct ifc_simple_data *ifcs = ifc->ifc_data;
 472
 473         unit = ifp->if_dunit;
 474
 475         if (unit < ifcs->ifcs_minifs)
 476                 return (EINVAL);
 477
 478         ifcs->ifcs_destroy(ifp);
 479
 480         ifc_free_unit(ifc, unit);
 481
 482         return (0);
 483 }