sys/altq/altq_conf.c

   1 /*      $NetBSD: altq_conf.c,v 1.18 2006/10/20 21:55:56 elad Exp $      */
   2 /*      $KAME: altq_conf.c,v 1.24 2005/04/13 03:44:24 suz Exp $ */
   3
   4 /*
   5  * Copyright (C) 1997-2003
   6  *      Sony Computer Science Laboratories Inc.  All rights reserved.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY SONY CSL 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 SONY CSL 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
  30 #include <sys/cdefs.h>
  31 __KERNEL_RCSID(0, "$NetBSD: altq_conf.c,v 1.18 2006/10/20 21:55:56 elad Exp $");
  32
  33 #ifdef _KERNEL_OPT
  34 #include "opt_altq.h"
  35 #include "opt_inet.h"
  36 #endif
  37
  38 /*
  39  * altq device interface.
  40  */
  41 #include <sys/param.h>
  42 #include <sys/systm.h>
  43 #include <sys/socket.h>
  44 #include <sys/kernel.h>
  45 #include <sys/proc.h>
  46 #include <sys/errno.h>
  47 #include <sys/kauth.h>
  48
  49 #include <net/if.h>
  50
  51 #include <altq/altq.h>
  52 #include <altq/altqconf.h>
  53 #include <altq/altq_conf.h>
  54
  55 #ifdef ALTQ3_COMPAT
  56
  57 #ifdef ALTQ_CBQ
  58 altqdev_decl(cbq);
  59 #endif
  60 #ifdef ALTQ_WFQ
  61 altqdev_decl(wfq);
  62 #endif
  63 #ifdef ALTQ_AFMAP
  64 altqdev_decl(afm);
  65 #endif
  66 #ifdef ALTQ_FIFOQ
  67 altqdev_decl(fifoq);
  68 #endif
  69 #ifdef ALTQ_RED
  70 altqdev_decl(red);
  71 #endif
  72 #ifdef ALTQ_RIO
  73 altqdev_decl(rio);
  74 #endif
  75 #ifdef ALTQ_LOCALQ
  76 altqdev_decl(localq);
  77 #endif
  78 #ifdef ALTQ_HFSC
  79 altqdev_decl(hfsc);
  80 #endif
  81 #ifdef ALTQ_CDNR
  82 altqdev_decl(cdnr);
  83 #endif
  84 #ifdef ALTQ_BLUE
  85 altqdev_decl(blue);
  86 #endif
  87 #ifdef ALTQ_PRIQ
  88 altqdev_decl(priq);
  89 #endif
  90 #ifdef ALTQ_JOBS
  91 altqdev_decl(jobs);
  92 #endif
  93
  94 /*
  95  * altq minor device (discipline) table
  96  */
  97 static struct altqsw altqsw[] = {                               /* minor */
  98         {"altq", noopen,        noclose,        noioctl},  /* 0 (reserved) */
  99 #ifdef ALTQ_CBQ
 100         {"cbq", cbqopen,        cbqclose,       cbqioctl},      /* 1 */
 101 #else
 102         {"noq", noopen,         noclose,        noioctl},       /* 1 */
 103 #endif
 104 #ifdef ALTQ_WFQ
 105         {"wfq", wfqopen,        wfqclose,       wfqioctl},      /* 2 */
 106 #else
 107         {"noq", noopen,         noclose,        noioctl},       /* 2 */
 108 #endif
 109 #ifdef ALTQ_AFMAP
 110         {"afm", afmopen,        afmclose,       afmioctl},      /* 3 */
 111 #else
 112         {"noq", noopen,         noclose,        noioctl},       /* 3 */
 113 #endif
 114 #ifdef ALTQ_FIFOQ
 115         {"fifoq", fifoqopen,    fifoqclose,     fifoqioctl},    /* 4 */
 116 #else
 117         {"noq", noopen,         noclose,        noioctl},       /* 4 */
 118 #endif
 119 #ifdef ALTQ_RED
 120         {"red", redopen,        redclose,       redioctl},      /* 5 */
 121 #else
 122         {"noq", noopen,         noclose,        noioctl},       /* 5 */
 123 #endif
 124 #ifdef ALTQ_RIO
 125         {"rio", rioopen,        rioclose,       rioioctl},      /* 6 */
 126 #else
 127         {"noq", noopen,         noclose,        noioctl},       /* 6 */
 128 #endif
 129 #ifdef ALTQ_LOCALQ
 130         {"localq",localqopen,   localqclose,    localqioctl}, /* 7 (local use) */
 131 #else
 132         {"noq", noopen,         noclose,        noioctl},  /* 7 (local use) */
 133 #endif
 134 #ifdef ALTQ_HFSC
 135         {"hfsc",hfscopen,       hfscclose,      hfscioctl},     /* 8 */
 136 #else
 137         {"noq", noopen,         noclose,        noioctl},       /* 8 */
 138 #endif
 139 #ifdef ALTQ_CDNR
 140         {"cdnr",cdnropen,       cdnrclose,      cdnrioctl},     /* 9 */
 141 #else
 142         {"noq", noopen,         noclose,        noioctl},       /* 9 */
 143 #endif
 144 #ifdef ALTQ_BLUE
 145         {"blue",blueopen,       blueclose,      blueioctl},     /* 10 */
 146 #else
 147         {"noq", noopen,         noclose,        noioctl},       /* 10 */
 148 #endif
 149 #ifdef ALTQ_PRIQ
 150         {"priq",priqopen,       priqclose,      priqioctl},     /* 11 */
 151 #else
 152         {"noq", noopen,         noclose,        noioctl},       /* 11 */
 153 #endif
 154 #ifdef ALTQ_JOBS
 155         {"jobs",jobsopen,       jobsclose,      jobsioctl},     /* 12 */
 156 #else
 157         {"noq", noopen,         noclose,        noioctl},       /* 12 */
 158 #endif
 159 };
 160
 161 /*
 162  * altq major device support
 163  */
 164 int     naltqsw = sizeof (altqsw) / sizeof (altqsw[0]);
 165
 166 dev_type_open(altqopen);
 167 dev_type_close(altqclose);
 168 dev_type_ioctl(altqioctl);
 169
 170 const struct cdevsw altq_cdevsw = {
 171         altqopen, altqclose, noread, nowrite, altqioctl,
 172         nostop, notty, nopoll, nommap, nokqfilter, D_OTHER,
 173 };
 174
 175 int
 176 altqopen(dev_t dev, int flag, int fmt, struct lwp *l)
 177 {
 178         int unit = minor(dev);
 179
 180         if (unit == 0)
 181                 return (0);
 182         if (unit < naltqsw)
 183                 return (*altqsw[unit].d_open)(dev, flag, fmt, l);
 184
 185         return ENXIO;
 186 }
 187
 188 int
 189 altqclose(dev_t dev, int flag, int fmt, struct lwp *l)
 190 {
 191         int unit = minor(dev);
 192
 193         if (unit == 0)
 194                 return (0);
 195         if (unit < naltqsw)
 196                 return (*altqsw[unit].d_close)(dev, flag, fmt, l);
 197
 198         return ENXIO;
 199 }
 200
 201 int
 202 altqioctl(dev_t dev, ioctlcmd_t cmd, void *addr, int flag, struct lwp *l)
 203 {
 204         int unit = minor(dev);
 205
 206         if (unit == 0) {
 207                 struct ifnet *ifp;
 208                 struct altqreq *typereq;
 209                 struct tbrreq *tbrreq;
 210                 int error;
 211
 212                 switch (cmd) {
 213                 case ALTQGTYPE:
 214                 case ALTQTBRGET:
 215                         break;
 216                 default:
 217 #if (__FreeBSD_version > 400000)
 218                         if ((error = suser(p)) != 0)
 219                                 return (error);
 220 #else
 221                         if ((error = kauth_authorize_network(l->l_cred,
 222                             KAUTH_NETWORK_ALTQ, KAUTH_REQ_NETWORK_ALTQ_CONF,
 223                             NULL, NULL, NULL)) != 0)
 224                                 return (error);
 225 #endif
 226                         break;
 227                 }
 228
 229                 switch (cmd) {
 230                 case ALTQGTYPE:
 231                         typereq = (struct altqreq *)addr;
 232                         if ((ifp = ifunit(typereq->ifname)) == NULL)
 233                                 return (EINVAL);
 234                         typereq->arg = (u_long)ifp->if_snd.altq_type;
 235                         return (0);
 236                 case ALTQTBRSET:
 237                         tbrreq = (struct tbrreq *)addr;
 238                         if ((ifp = ifunit(tbrreq->ifname)) == NULL)
 239                                 return (EINVAL);
 240                         return tbr_set(&ifp->if_snd, &tbrreq->tb_prof);
 241                 case ALTQTBRGET:
 242                         tbrreq = (struct tbrreq *)addr;
 243                         if ((ifp = ifunit(tbrreq->ifname)) == NULL)
 244                                 return (EINVAL);
 245                         return tbr_get(&ifp->if_snd, &tbrreq->tb_prof);
 246                 default:
 247                         return (EINVAL);
 248                 }
 249         }
 250         if (unit < naltqsw)
 251                 return (*altqsw[unit].d_ioctl)(dev, cmd, addr, flag, l);
 252
 253         return ENXIO;
 254 }
 255
 256 #ifdef __FreeBSD__
 257 static int altq_devsw_installed = 0;
 258 #endif
 259
 260 #ifdef __FreeBSD__
 261 static void
 262 altq_drvinit(void *unused)
 263 {
 264         int unit;
 265
 266 #if 0
 267         mtx_init(&altq_mtx, "altq global lock", MTX_DEF);
 268 #endif
 269         altq_devsw_installed = 1;
 270         printf("altq: attached. Major number assigned automatically.\n");
 271
 272         /* create minor devices */
 273         for (unit = 0; unit < naltqsw; unit++) {
 274                 if (unit == 0 || altqsw[unit].d_open != NULL)
 275                         altqsw[unit].dev = make_dev(&altq_cdevsw, unit,
 276                             UID_ROOT, GID_WHEEL, 0644, "altq/%s",
 277                             altqsw[unit].d_name);
 278         }
 279 }
 280
 281 SYSINIT(altqdev,SI_SUB_DRIVERS,SI_ORDER_MIDDLE+CDEV_MAJOR,altq_drvinit,NULL)
 282
 283 #endif /* FreeBSD */
 284
 285 #ifdef ALTQ_KLD
 286 /*
 287  * KLD support
 288  */
 289 static int altq_module_register(struct altq_module_data *);
 290 static int altq_module_deregister(struct altq_module_data *);
 291
 292 static struct altq_module_data *altq_modules[ALTQT_MAX];
 293 #if __FreeBSD_version < 502103
 294 static struct altqsw noqdisc = {"noq", noopen, noclose, noioctl};
 295 #else
 296 static struct altqsw noqdisc = {"noq"};
 297 #endif
 298
 299 void altq_module_incref(int type)
 300 {
 301         if (type < 0 || type >= ALTQT_MAX || altq_modules[type] == NULL)
 302                 return;
 303
 304         altq_modules[type]->ref++;
 305 }
 306
 307 void altq_module_declref(int type)
 308 {
 309         if (type < 0 || type >= ALTQT_MAX || altq_modules[type] == NULL)
 310                 return;
 311
 312         altq_modules[type]->ref--;
 313 }
 314
 315 static int
 316 altq_module_register(struct altq_module_data *mdata)
 317 {
 318         int type = mdata->type;
 319
 320         if (type < 0 || type >= ALTQT_MAX)
 321                 return (EINVAL);
 322 #if (__FreeBSD_version < 502103)
 323         if (altqsw[type].d_open != noopen)
 324 #else
 325         if (altqsw[type].d_open != NULL)
 326 #endif
 327                 return (EBUSY);
 328         altqsw[type] = *mdata->altqsw;  /* set discipline functions */
 329         altq_modules[type] = mdata;     /* save module data pointer */
 330 #if (__FreeBSD_version < 502103)
 331         make_dev(&altq_cdevsw, type, UID_ROOT, GID_WHEEL, 0644,
 332                  "altq/%s", altqsw[type].d_name);
 333 #else
 334         altqsw[type].dev = make_dev(&altq_cdevsw, type, UID_ROOT, GID_WHEEL,
 335             0644, "altq/%s", altqsw[type].d_name);
 336 #endif
 337         return (0);
 338 }
 339
 340 static int
 341 altq_module_deregister(struct altq_module_data *mdata)
 342 {
 343         int type = mdata->type;
 344
 345         if (type < 0 || type >= ALTQT_MAX)
 346                 return (EINVAL);
 347         if (mdata != altq_modules[type])
 348                 return (EINVAL);
 349         if (altq_modules[type]->ref > 0)
 350                 return (EBUSY);
 351 #if (__FreeBSD_version < 502103)
 352         destroy_dev(makedev(CDEV_MAJOR, type));
 353 #else
 354         destroy_dev(altqsw[type].dev);
 355 #endif
 356         altqsw[type] = noqdisc;
 357         altq_modules[type] = NULL;
 358         return (0);
 359 }
 360
 361 int
 362 altq_module_handler(module_t mod, int cmd, void *arg)
 363 {
 364         struct altq_module_data *data = (struct altq_module_data *)arg;
 365         int     error = 0;
 366
 367         switch (cmd) {
 368         case MOD_LOAD:
 369                 error = altq_module_register(data);
 370                 break;
 371
 372         case MOD_UNLOAD:
 373                 error = altq_module_deregister(data);
 374                 break;
 375
 376         default:
 377                 error = EINVAL;
 378                 break;
 379         }
 380
 381         return (error);
 382 }
 383
 384 #endif  /* ALTQ_KLD */
 385 #endif /* ALTQ3_COMPAT */