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  * 3. 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.3 (Berkeley) 1/4/94
  30  * $FreeBSD: src/sys/net/if.c,v 1.185 2004/03/13 02:35:03 brooks Exp $
  31  */
  32
  33 #include <sys/param.h>
  34 #include <sys/kernel.h>
  35 #include <sys/malloc.h>
  36 #include <sys/eventhandler.h>
  37 #include <sys/limits.h>
  38
  39 #include <net/if.h>
  40 #include <net/if_var.h>
  41 #include <net/if_clone.h>
  42
  43 static LIST_HEAD(, if_clone) if_cloners = LIST_HEAD_INITIALIZER(if_cloners);
  44 static int if_cloners_count;
  45
  46 MALLOC_DEFINE(M_CLONE, "clone", "interface cloning framework");
  47
  48 static int      if_name2unit(const char *, int *);
  49 static bool     if_clone_match(struct if_clone *, const char *);
  50 static struct if_clone *if_clone_lookup(const char *);
  51 static int      if_clone_alloc_unit(struct if_clone *, int *);
  52 static void     if_clone_free_unit(struct if_clone *, int);
  53 static int      if_clone_createif(struct if_clone *, int, caddr_t);
  54
  55 /*
  56  * Lookup the cloner and create a clone network interface.
  57  */
  58 int
  59 if_clone_create(char *name, int len, caddr_t params)
  60 {
  61         struct if_clone *ifc;
  62         char ifname[IFNAMSIZ];
  63         bool wildcard;
  64         int unit;
  65         int err;
  66
  67         if ((ifc = if_clone_lookup(name)) == NULL)
  68                 return (EINVAL);
  69         if ((err = if_name2unit(name, &unit)) != 0)
  70                 return (err);
  71
  72         wildcard = (unit < 0);
  73
  74         if ((err = if_clone_alloc_unit(ifc, &unit)) != 0)
  75                 return (err);
  76
  77         ksnprintf(ifname, IFNAMSIZ, "%s%d", ifc->ifc_name, unit);
  78
  79         /*
  80          * Update the name with the allocated unit for the caller,
  81          * who must preserve enough space.
  82          */
  83         if (wildcard && strlcpy(name, ifname, len) >= len)
  84                 return (ENOSPC);
  85
  86         if ((err = if_clone_createif(ifc, unit, params)) != 0) {
  87                 if_clone_free_unit(ifc, unit);
  88                 return (err);
  89         }
  90
  91         return (0);
  92 }
  93
  94 /*
  95  * Lookup the cloner and destroy a clone network interface.
  96  */
  97 int
  98 if_clone_destroy(const char *name)
  99 {
 100         struct if_clone *ifc;
 101         struct ifnet *ifp;
 102         int unit, error;
 103
 104         ifnet_lock();
 105         ifp = ifunit(name);
 106         ifnet_unlock();
 107         if (ifp == NULL)
 108                 return (ENXIO);
 109
 110         if ((ifc = if_clone_lookup(ifp->if_dname)) == NULL)
 111                 return (EINVAL);
 112
 113         unit = ifp->if_dunit;
 114         if (unit < ifc->ifc_minifs)
 115                 return (EINVAL);
 116
 117         if (ifc->ifc_destroy == NULL)
 118                 return (EOPNOTSUPP);
 119
 120         ifnet_lock();
 121         error = ifc->ifc_destroy(ifp);
 122         ifnet_unlock();
 123         if (error)
 124                 return (error);
 125
 126         if_clone_free_unit(ifc, unit);
 127
 128         return (0);
 129 }
 130
 131 /*
 132  * Register a network interface cloner.
 133  */
 134 int
 135 if_clone_attach(struct if_clone *ifc)
 136 {
 137         struct if_clone *ifct;
 138         int len, maxclone;
 139         int unit;
 140
 141         LIST_FOREACH(ifct, &if_cloners, ifc_list) {
 142                 if (strcmp(ifct->ifc_name, ifc->ifc_name) == 0)
 143                         return (EEXIST);
 144         }
 145
 146         KASSERT(ifc->ifc_minifs - 1 <= ifc->ifc_maxunit,
 147             ("%s: %s requested more units then allowed (%d > %d)",
 148             __func__, ifc->ifc_name, ifc->ifc_minifs,
 149             ifc->ifc_maxunit + 1));
 150         /*
 151          * Compute bitmap size and allocate it.
 152          */
 153         maxclone = ifc->ifc_maxunit + 1;
 154         len = maxclone >> 3;
 155         if ((len << 3) < maxclone)
 156                 len++;
 157         ifc->ifc_units = kmalloc(len, M_CLONE, M_WAITOK | M_ZERO);
 158         ifc->ifc_bmlen = len;
 159
 160         LIST_INSERT_HEAD(&if_cloners, ifc, ifc_list);
 161         if_cloners_count++;
 162
 163         for (unit = 0; unit < ifc->ifc_minifs; unit++) {
 164                 if_clone_alloc_unit(ifc, &unit);
 165                 if (if_clone_createif(ifc, unit, NULL) != 0) {
 166                         panic("%s: failed to create required interface %s%d",
 167                               __func__, ifc->ifc_name, unit);
 168                 }
 169         }
 170
 171         EVENTHANDLER_INVOKE(if_clone_event, ifc);
 172
 173         return (0);
 174 }
 175
 176 /*
 177  * Unregister a network interface cloner.
 178  */
 179 void
 180 if_clone_detach(struct if_clone *ifc)
 181 {
 182
 183         LIST_REMOVE(ifc, ifc_list);
 184         kfree(ifc->ifc_units, M_CLONE);
 185         if_cloners_count--;
 186 }
 187
 188 /*
 189  * Provide list of interface cloners to userspace.
 190  */
 191 int
 192 if_clone_list(struct if_clonereq *ifcr)
 193 {
 194         char outbuf[IFNAMSIZ], *dst;
 195         struct if_clone *ifc;
 196         int count, error = 0;
 197
 198         ifcr->ifcr_total = if_cloners_count;
 199         if ((dst = ifcr->ifcr_buffer) == NULL) {
 200                 /* Just asking how many there are. */
 201                 return (0);
 202         }
 203
 204         if (ifcr->ifcr_count < 0)
 205                 return (EINVAL);
 206
 207         count = (if_cloners_count < ifcr->ifcr_count) ?
 208             if_cloners_count : ifcr->ifcr_count;
 209
 210         for (ifc = LIST_FIRST(&if_cloners);
 211              ifc != NULL && count != 0;
 212              ifc = LIST_NEXT(ifc, ifc_list), count--, dst += IFNAMSIZ) {
 213                 bzero(outbuf, IFNAMSIZ);        /* sanitize */
 214                 strlcpy(outbuf, ifc->ifc_name, IFNAMSIZ);
 215                 error = copyout(outbuf, dst, IFNAMSIZ);
 216                 if (error)
 217                         break;
 218         }
 219
 220         return (error);
 221 }
 222
 223 /*
 224  * Extract the unit number from interface name of the form "name###".
 225  * A unit of -1 is stored if the given name doesn't have a unit.
 226  *
 227  * Returns 0 on success and an error on failure.
 228  */
 229 static int
 230 if_name2unit(const char *name, int *unit)
 231 {
 232         const char *cp;
 233         int cutoff = INT_MAX / 10;
 234         int cutlim = INT_MAX % 10;
 235
 236         for (cp = name; *cp != '\0' && (*cp < '0' || *cp > '9'); cp++)
 237                 ;
 238         if (*cp == '\0') {
 239                 *unit = -1;
 240         } else if (cp[0] == '0' && cp[1] != '\0') {
 241                 /* Disallow leading zeroes. */
 242                 return (EINVAL);
 243         } else {
 244                 for (*unit = 0; *cp != '\0'; cp++) {
 245                         if (*cp < '0' || *cp > '9') {
 246                                 /* Bogus unit number. */
 247                                 return (EINVAL);
 248                         }
 249                         if (*unit > cutoff ||
 250                             (*unit == cutoff && *cp - '0' > cutlim))
 251                                 return (EINVAL);
 252                         *unit = (*unit * 10) + (*cp - '0');
 253                 }
 254         }
 255
 256         return (0);
 257 }
 258
 259 /*
 260  * Check whether the interface cloner matches the name.
 261  */
 262 static bool
 263 if_clone_match(struct if_clone *ifc, const char *name)
 264 {
 265         const char *cp;
 266         int i;
 267
 268         /* Match the name */
 269         for (cp = name, i = 0; i < strlen(ifc->ifc_name); i++, cp++) {
 270                 if (ifc->ifc_name[i] != *cp)
 271                         return (false);
 272         }
 273
 274         /* Make sure there's a unit number or nothing after the name */
 275         for ( ; *cp != '\0'; cp++) {
 276                 if (*cp < '0' || *cp > '9')
 277                         return (false);
 278         }
 279
 280         return (true);
 281 }
 282
 283 /*
 284  * Look up a network interface cloner.
 285  */
 286 static struct if_clone *
 287 if_clone_lookup(const char *name)
 288 {
 289         struct if_clone *ifc;
 290
 291         LIST_FOREACH(ifc, &if_cloners, ifc_list) {
 292                 if (if_clone_match(ifc, name))
 293                         return ifc;
 294         }
 295
 296         return (NULL);
 297 }
 298
 299 /*
 300  * Allocate a unit number.
 301  *
 302  * Returns 0 on success and an error on failure.
 303  */
 304 static int
 305 if_clone_alloc_unit(struct if_clone *ifc, int *unit)
 306 {
 307         int bytoff, bitoff;
 308
 309         if (*unit < 0) {
 310                 /*
 311                  * Wildcard mode: find a free unit.
 312                  */
 313                 bytoff = bitoff = 0;
 314                 while (bytoff < ifc->ifc_bmlen &&
 315                        ifc->ifc_units[bytoff] == 0xff)
 316                         bytoff++;
 317                 if (bytoff >= ifc->ifc_bmlen)
 318                         return (ENOSPC);
 319                 while ((ifc->ifc_units[bytoff] & (1 << bitoff)) != 0)
 320                         bitoff++;
 321                 *unit = (bytoff << 3) + bitoff;
 322         } else {
 323                 bytoff = *unit >> 3;
 324                 bitoff = *unit - (bytoff << 3);
 325         }
 326
 327         if (*unit > ifc->ifc_maxunit)
 328                 return (ENXIO);
 329
 330         /*
 331          * Allocate the unit in the bitmap.
 332          */
 333         KASSERT((ifc->ifc_units[bytoff] & (1 << bitoff)) == 0,
 334                 ("%s: bit is already set", __func__));
 335         ifc->ifc_units[bytoff] |= (1 << bitoff);
 336
 337         return (0);
 338 }
 339
 340 /*
 341  * Free an allocated unit number.
 342  */
 343 static void
 344 if_clone_free_unit(struct if_clone *ifc, int unit)
 345 {
 346         int bytoff, bitoff;
 347
 348         bytoff = unit >> 3;
 349         bitoff = unit - (bytoff << 3);
 350         KASSERT((ifc->ifc_units[bytoff] & (1 << bitoff)) != 0,
 351                 ("%s: bit is already cleared", __func__));
 352         ifc->ifc_units[bytoff] &= ~(1 << bitoff);
 353 }
 354
 355 /*
 356  * Create a clone network interface.
 357  */
 358 static int
 359 if_clone_createif(struct if_clone *ifc, int unit, caddr_t params)
 360 {
 361         struct ifnet *ifp;
 362         char ifname[IFNAMSIZ];
 363         int err;
 364
 365         ksnprintf(ifname, IFNAMSIZ, "%s%d", ifc->ifc_name, unit);
 366
 367         ifnet_lock();
 368         ifp = ifunit(ifname);
 369         ifnet_unlock();
 370         if (ifp != NULL)
 371                 return (EEXIST);
 372
 373         err = (*ifc->ifc_create)(ifc, unit, params);
 374         if (err != 0)
 375                 return (err);
 376
 377         ifnet_lock();
 378         ifp = ifunit(ifname);
 379         ifnet_unlock();
 380         if (ifp == NULL)
 381                 return (ENXIO);
 382
 383         err = if_addgroup(ifp, ifc->ifc_name);
 384         if (err != 0)
 385                 return (err);
 386
 387         return (0);
 388 }