usr.sbin/altq/libaltq/qop_fifoq.c

   1 /*      $NetBSD: qop_fifoq.c,v 1.4 2001/08/22 08:52:37 itojun Exp $     */
   2 /*      $KAME: qop_fifoq.c,v 1.6 2001/12/03 08:20:55 kjc Exp $  */
   3 /*
   4  * Copyright (C) 1999-2000
   5  *      Sony Computer Science Laboratories, Inc.  All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  *
  16  * THIS SOFTWARE IS PROVIDED BY SONY CSL AND CONTRIBUTORS ``AS IS'' AND
  17  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  19  * ARE DISCLAIMED.  IN NO EVENT SHALL SONY CSL OR CONTRIBUTORS BE LIABLE
  20  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  22  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  23  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  24  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  25  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  26  * SUCH DAMAGE.
  27  */
  28
  29 #include <sys/param.h>
  30 #include <sys/socket.h>
  31 #include <sys/sockio.h>
  32 #include <sys/ioctl.h>
  33 #include <sys/fcntl.h>
  34 #include <net/if.h>
  35 #include <netinet/in.h>
  36 #include <arpa/inet.h>
  37
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <unistd.h>
  41 #include <stddef.h>
  42 #include <string.h>
  43 #include <ctype.h>
  44 #include <errno.h>
  45 #include <syslog.h>
  46 #include <netdb.h>
  47
  48 #include <altq/altq.h>
  49 #include <altq/altq_fifoq.h>
  50 #include "altq_qop.h"
  51 #include "qop_fifoq.h"
  52
  53 static int fifoq_attach(struct ifinfo *);
  54 static int fifoq_detach(struct ifinfo *);
  55 static int fifoq_enable(struct ifinfo *);
  56 static int fifoq_disable(struct ifinfo *);
  57
  58 #define FIFOQ_DEVICE    "/dev/altq/fifoq"
  59
  60 static int fifoq_fd = -1;
  61 static int fifoq_refcount = 0;
  62
  63 static struct qdisc_ops fifoq_qdisc = {
  64         ALTQT_FIFOQ,
  65         "fifoq",
  66         fifoq_attach,
  67         fifoq_detach,
  68         NULL,                   /* clear */
  69         fifoq_enable,
  70         fifoq_disable,
  71         NULL,                   /* add class */
  72         NULL,                   /* modify class */
  73         NULL,                   /* delete class */
  74         NULL,                   /* add filter */
  75         NULL                    /* delete filter */
  76 };
  77
  78 /*
  79  * parser interface
  80  */
  81 #define EQUAL(s1, s2)   (strcmp((s1), (s2)) == 0)
  82
  83 int
  84 fifoq_interface_parser(const char *ifname, int argc, char **argv)
  85 {
  86         u_int   bandwidth = 100000000;  /* 100Mbps */
  87         u_int   tbrsize = 0;
  88         int     qlimit = 50;
  89
  90         /*
  91          * process options
  92          */
  93         while (argc > 0) {
  94                 if (EQUAL(*argv, "bandwidth")) {
  95                         argc--; argv++;
  96                         if (argc > 0)
  97                                 bandwidth = atobps(*argv);
  98                 } else if (EQUAL(*argv, "tbrsize")) {
  99                         argc--; argv++;
 100                         if (argc > 0)
 101                                 tbrsize = atobytes(*argv);
 102                 } else if (EQUAL(*argv, "qlimit")) {
 103                         argc--; argv++;
 104                         if (argc > 0)
 105                                 qlimit = (int)strtol(*argv, NULL, 0);
 106                 } else if (EQUAL(*argv, "fifoq")) {
 107                         /* just skip */
 108                 } else {
 109                         LOG(LOG_ERR, 0, "Unknown keyword '%s'", *argv);
 110                         return (0);
 111                 }
 112                 argc--; argv++;
 113         }
 114
 115         if (qcmd_tbr_register(ifname, bandwidth, tbrsize) != 0)
 116                 return (0);
 117
 118         if (qcmd_fifoq_add_if(ifname, bandwidth, qlimit) != 0)
 119                 return (0);
 120         return (1);
 121 }
 122
 123 /*
 124  * qcmd api
 125  */
 126 int
 127 qcmd_fifoq_add_if(const char *ifname, u_int bandwidth, int qlimit)
 128 {
 129         int error;
 130
 131         error = qop_fifoq_add_if(NULL, ifname, bandwidth, qlimit);
 132         if (error != 0)
 133                 LOG(LOG_ERR, errno, "%s: can't add fifoq on interface '%s'",
 134                     qoperror(error), ifname);
 135         return (error);
 136 }
 137
 138 /*
 139  * qop api
 140  */
 141 int
 142 qop_fifoq_add_if(struct ifinfo **rp, const char *ifname,
 143                  u_int bandwidth, int qlimit)
 144 {
 145         struct ifinfo *ifinfo = NULL;
 146         struct fifoq_ifinfo *fifoq_ifinfo;
 147         int error;
 148
 149         if ((fifoq_ifinfo = calloc(1, sizeof(*fifoq_ifinfo))) == NULL)
 150                 return (QOPERR_NOMEM);
 151         fifoq_ifinfo->qlimit   = qlimit;
 152
 153         error = qop_add_if(&ifinfo, ifname, bandwidth,
 154                            &fifoq_qdisc, fifoq_ifinfo);
 155         if (error != 0) {
 156                 free(fifoq_ifinfo);
 157                 return (error);
 158         }
 159
 160         if (rp != NULL)
 161                 *rp = ifinfo;
 162         return (0);
 163 }
 164
 165 /*
 166  *  system call interfaces for qdisc_ops
 167  */
 168 static int
 169 fifoq_attach(struct ifinfo *ifinfo)
 170 {
 171         struct fifoq_interface iface;
 172         struct fifoq_ifinfo *fifoq_ifinfo;
 173         struct fifoq_conf conf;
 174
 175         if (fifoq_fd < 0 &&
 176             (fifoq_fd = open(FIFOQ_DEVICE, O_RDWR)) < 0 &&
 177             (fifoq_fd = open_module(FIFOQ_DEVICE, O_RDWR)) < 0) {
 178                 LOG(LOG_ERR, errno, "FIFOQ open");
 179                 return (QOPERR_SYSCALL);
 180         }
 181
 182         fifoq_refcount++;
 183         memset(&iface, 0, sizeof(iface));
 184         strncpy(iface.fifoq_ifname, ifinfo->ifname, IFNAMSIZ);
 185
 186         if (ioctl(fifoq_fd, FIFOQ_IF_ATTACH, &iface) < 0)
 187                 return (QOPERR_SYSCALL);
 188
 189         /* set fifoq parameters */
 190         fifoq_ifinfo = (struct fifoq_ifinfo *)ifinfo->private;
 191         if (fifoq_ifinfo->qlimit > 0) {
 192                 memset(&conf, 0, sizeof(conf));
 193                 strncpy(conf.iface.fifoq_ifname, ifinfo->ifname, IFNAMSIZ);
 194                 conf.fifoq_limit = fifoq_ifinfo->qlimit;
 195                 if (ioctl(fifoq_fd, FIFOQ_CONFIG, &conf) < 0)
 196                         return (QOPERR_SYSCALL);
 197         }
 198 #if 1
 199         LOG(LOG_INFO, 0, "fifoq attached to %s", iface.fifoq_ifname);
 200 #endif
 201         return (0);
 202 }
 203
 204 static int
 205 fifoq_detach(struct ifinfo *ifinfo)
 206 {
 207         struct fifoq_interface iface;
 208
 209         memset(&iface, 0, sizeof(iface));
 210         strncpy(iface.fifoq_ifname, ifinfo->ifname, IFNAMSIZ);
 211
 212         if (ioctl(fifoq_fd, FIFOQ_IF_DETACH, &iface) < 0)
 213                 return (QOPERR_SYSCALL);
 214
 215         if (--fifoq_refcount == 0) {
 216                 close(fifoq_fd);
 217                 fifoq_fd = -1;
 218         }
 219         return (0);
 220 }
 221
 222 static int
 223 fifoq_enable(struct ifinfo *ifinfo)
 224 {
 225         struct fifoq_interface iface;
 226
 227         memset(&iface, 0, sizeof(iface));
 228         strncpy(iface.fifoq_ifname, ifinfo->ifname, IFNAMSIZ);
 229
 230         if (ioctl(fifoq_fd, FIFOQ_ENABLE, &iface) < 0)
 231                 return (QOPERR_SYSCALL);
 232         return (0);
 233 }
 234
 235 static int
 236 fifoq_disable(struct ifinfo *ifinfo)
 237 {
 238         struct fifoq_interface iface;
 239
 240         memset(&iface, 0, sizeof(iface));
 241         strncpy(iface.fifoq_ifname, ifinfo->ifname, IFNAMSIZ);
 242
 243         if (ioctl(fifoq_fd, FIFOQ_DISABLE, &iface) < 0)
 244                 return (QOPERR_SYSCALL);
 245         return (0);
 246 }