sys/dev/virtual/net/if_vke.c

   1 /*
   2  * Copyright (c) 2007 The DragonFly Project.  All rights reserved.
   3  *
   4  * This code is derived from software contributed to The DragonFly Project
   5  * by Sepherosa Ziehau <sepherosa@gmail.com>
   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  *
  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
  15  *    the documentation and/or other materials provided with the
  16  *    distribution.
  17  * 3. Neither the name of The DragonFly Project nor the names of its
  18  *    contributors may be used to endorse or promote products derived
  19  *    from this software without specific, prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  22  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  23  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
  24  * FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE
  25  * COPYRIGHT HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  26  * INCIDENTAL, SPECIAL, EXEMPLARY OR CONSEQUENTIAL DAMAGES (INCLUDING,
  27  * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  28  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
  29  * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  30  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  31  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  32  * SUCH DAMAGE.
  33  *
  34  * $DragonFly: src/sys/dev/virtual/net/if_vke.c,v 1.4 2007/01/15 05:27:28 dillon Exp $
  35  */
  36
  37 #include <sys/param.h>
  38 #include <sys/endian.h>
  39 #include <sys/kernel.h>
  40 #include <sys/malloc.h>
  41 #include <sys/proc.h>
  42 #include <sys/serialize.h>
  43 #include <sys/socket.h>
  44 #include <sys/sockio.h>
  45 #include <sys/sysctl.h>
  46
  47 #include <machine/md_var.h>
  48
  49 #include <net/ethernet.h>
  50 #include <net/if.h>
  51 #include <net/bpf.h>
  52 #include <net/if_arp.h>
  53 #include <net/ifq_var.h>
  54
  55 #include <netinet/in_var.h>
  56
  57 #include <sys/stat.h>
  58 #include <sys/ioccom.h>
  59 #include <net/tap/if_tap.h>
  60 #include <errno.h>
  61 #include <stdio.h>
  62 #include <string.h>
  63 #include <unistd.h>
  64
  65 #define VKE_DEVNAME             "vke"
  66
  67 struct vke_softc {
  68         struct arpcom           arpcom;
  69         int                     sc_fd;
  70         int                     sc_unit;
  71
  72         struct kqueue_info      *sc_kqueue;
  73
  74         void                    *sc_txbuf;
  75         struct mbuf             *sc_rx_mbuf;
  76
  77         struct sysctl_ctx_list  sc_sysctl_ctx;
  78         struct sysctl_oid       *sc_sysctl_tree;
  79
  80         int                     sc_tap_unit;    /* unit of backend tap(4) */
  81         in_addr_t               sc_addr;        /* address */
  82         in_addr_t               sc_mask;        /* netmask */
  83 };
  84
  85 static void     vke_start(struct ifnet *);
  86 static void     vke_init(void *);
  87 static int      vke_ioctl(struct ifnet *, u_long, caddr_t, struct ucred *);
  88
  89 static int      vke_attach(const struct vknetif_info *, int);
  90 static void     vke_intr(void *, struct intrframe *);
  91 static int      vke_stop(struct vke_softc *);
  92 static int      vke_rxeof(struct vke_softc *);
  93 static int      vke_init_addr(struct ifnet *, in_addr_t, in_addr_t);
  94
  95 static void
  96 vke_sysinit(void *arg __unused)
  97 {
  98         int i, unit;
  99
 100         KASSERT(NetifNum <= VKNETIF_MAX, ("too many netifs: %d\n", NetifNum));
 101
 102         unit = 0;
 103         for (i = 0; i < NetifNum; ++i) {
 104                 if (vke_attach(&NetifInfo[i], unit) == 0)
 105                         ++unit;
 106         }
 107 }
 108 SYSINIT(vke, SI_SUB_DRIVERS, SI_ORDER_MIDDLE, vke_sysinit, NULL);
 109
 110 static void
 111 vke_init(void *xsc)
 112 {
 113         struct vke_softc *sc = xsc;
 114         struct ifnet *ifp = &sc->arpcom.ac_if;
 115
 116         ASSERT_SERIALIZED(ifp->if_serializer);
 117
 118         vke_stop(sc);
 119
 120         ifp->if_flags |= IFF_RUNNING;
 121         ifp->if_flags &= ~IFF_OACTIVE;
 122
 123         if (sc->sc_addr != 0) {
 124                 in_addr_t addr, mask;
 125
 126                 addr = sc->sc_addr;
 127                 mask = sc->sc_mask;
 128
 129                 /*
 130                  * Make sure vkernel assigned
 131                  * address will not be added
 132                  * again.
 133                  */
 134                 sc->sc_addr = 0;
 135                 sc->sc_mask = 0;
 136
 137                 vke_init_addr(ifp, addr, mask);
 138         }
 139
 140         ifp->if_start(ifp);
 141 }
 142
 143 static void
 144 vke_start(struct ifnet *ifp)
 145 {
 146         struct vke_softc *sc = ifp->if_softc;
 147         struct mbuf *m;
 148
 149         ASSERT_SERIALIZED(ifp->if_serializer);
 150
 151         if ((ifp->if_flags & (IFF_RUNNING | IFF_OACTIVE)) != IFF_RUNNING)
 152                 return;
 153
 154         if (sc->sc_kqueue == NULL) {
 155                 sc->sc_kqueue = kqueue_add(sc->sc_fd, vke_intr, sc);
 156         }
 157
 158         while ((m = ifq_dequeue(&ifp->if_snd, NULL)) != NULL) {
 159                 m_copydata(m, 0, m->m_pkthdr.len, sc->sc_txbuf);
 160                 write(sc->sc_fd, sc->sc_txbuf, m->m_pkthdr.len);
 161                 m_freem(m);
 162                 ifp->if_opackets++;
 163         }
 164 }
 165
 166 static int
 167 vke_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data, struct ucred *cr)
 168 {
 169         struct vke_softc *sc = ifp->if_softc;
 170         int error = 0;
 171
 172         ASSERT_SERIALIZED(ifp->if_serializer);
 173
 174         switch (cmd) {
 175         case SIOCSIFFLAGS:
 176                 if (ifp->if_flags & IFF_UP) {
 177                         if ((ifp->if_flags & IFF_RUNNING) == 0)
 178                                 vke_init(sc);
 179                 } else {
 180                         if (ifp->if_flags & IFF_RUNNING)
 181                                 vke_stop(sc);
 182                 }
 183                 break;
 184         case SIOCGIFMEDIA:
 185         case SIOCSIFMEDIA:
 186                 error = EOPNOTSUPP;
 187                 /* TODO */
 188                 break;
 189         case SIOCGIFSTATUS: {
 190                 struct ifstat *ifs = (struct ifstat *)data;
 191                 int len;
 192
 193                 len = strlen(ifs->ascii);
 194                 if (len < sizeof(ifs->ascii)) {
 195                         ksnprintf(ifs->ascii + len, sizeof(ifs->ascii) - len,
 196                                   "\tBacked by tap%d\n", sc->sc_tap_unit);
 197                 }
 198                 break;
 199         }
 200         case SIOCSIFADDR:
 201                 if (((struct ifaddr *)data)->ifa_addr->sa_family == AF_INET) {
 202                         /*
 203                          * If we are explicitly requested to change address,
 204                          * we should invalidate address/netmask passed in
 205                          * from vkernel command line.
 206                          */
 207                         sc->sc_addr = 0;
 208                         sc->sc_mask = 0;
 209                 }
 210                 /* FALL THROUGH */
 211         default:
 212                 error = ether_ioctl(ifp, cmd, data);
 213                 break;
 214         }
 215         return error;
 216 }
 217
 218 static int
 219 vke_stop(struct vke_softc *sc)
 220 {
 221         struct ifnet *ifp = &sc->arpcom.ac_if;
 222
 223         ASSERT_SERIALIZED(ifp->if_serializer);
 224
 225         ifp->if_flags &= ~(IFF_RUNNING | IFF_OACTIVE);
 226         if (sc->sc_kqueue) {
 227                 kqueue_del(sc->sc_kqueue);
 228                 sc->sc_kqueue = NULL;
 229         }
 230
 231         if (sc->sc_rx_mbuf != NULL) {
 232                 m_freem(sc->sc_rx_mbuf);
 233                 sc->sc_rx_mbuf = NULL;
 234         }
 235         return 0;
 236 }
 237
 238 static void
 239 vke_intr(void *xsc, struct intrframe *frame __unused)
 240 {
 241         struct vke_softc *sc = xsc;
 242         struct ifnet *ifp = &sc->arpcom.ac_if;
 243
 244         lwkt_serialize_enter(ifp->if_serializer);
 245
 246         if ((ifp->if_flags & IFF_RUNNING) == 0)
 247                 goto back;
 248
 249         vke_rxeof(sc);
 250
 251         ifp->if_start(ifp);
 252
 253 back:
 254         lwkt_serialize_exit(ifp->if_serializer);
 255 }
 256
 257 static int
 258 vke_rxeof(struct vke_softc *sc)
 259 {
 260         struct ifnet *ifp = &sc->arpcom.ac_if;
 261         struct mbuf *m;
 262
 263         ASSERT_SERIALIZED(ifp->if_serializer);
 264
 265         for (;;) {
 266                 int n;
 267
 268                 if (sc->sc_rx_mbuf != NULL) {
 269                         m = sc->sc_rx_mbuf;
 270                         sc->sc_rx_mbuf = NULL;
 271                 } else {
 272                         m = m_getcl(MB_DONTWAIT, MT_DATA, M_PKTHDR);
 273                         if (m == NULL)
 274                                 return ENOBUFS;
 275                 }
 276
 277                 n = read(sc->sc_fd, mtod(m, void *), MCLBYTES);
 278                 if (n < 0) {
 279                         sc->sc_rx_mbuf = m;     /* We can use it next time */
 280
 281                         /* TODO: handle fatal error */
 282                         break;
 283                 }
 284                 ifp->if_ipackets++;
 285                 m->m_pkthdr.rcvif = ifp;
 286                 m->m_pkthdr.len = m->m_len = n;
 287                 ifp->if_input(ifp, m);
 288         }
 289         return 0;
 290 }
 291
 292 static int
 293 vke_attach(const struct vknetif_info *info, int unit)
 294 {
 295         struct vke_softc *sc;
 296         struct ifnet *ifp;
 297         struct tapinfo tapinfo;
 298         uint8_t enaddr[ETHER_ADDR_LEN];
 299         int fd;
 300
 301         KKASSERT(info->tap_fd >= 0);
 302         fd = info->tap_fd;
 303
 304         if (ioctl(fd, TAPGIFINFO, &tapinfo) < 0) {
 305                 kprintf(VKE_DEVNAME "%d: ioctl(TAPGIFINFO) failed: %s\n",
 306                         unit, strerror(errno));
 307                 return ENXIO;
 308         }
 309
 310         if (ioctl(fd, SIOCGIFADDR, enaddr) < 0) {
 311                 kprintf(VKE_DEVNAME "%d: ioctl(SIOCGIFADDR) failed: %s\n",
 312                         unit, strerror(errno));
 313                 return ENXIO;
 314         }
 315         enaddr[1] += 1;
 316
 317         sc = kmalloc(sizeof(*sc), M_DEVBUF, M_WAITOK | M_ZERO);
 318
 319         sc->sc_txbuf = kmalloc(MCLBYTES, M_DEVBUF, M_WAITOK);
 320         sc->sc_fd = fd;
 321         sc->sc_unit = unit;
 322         sc->sc_tap_unit = info->tap_unit;
 323         sc->sc_addr = info->netif_addr;
 324         sc->sc_mask = info->netif_mask;
 325
 326         ifp = &sc->arpcom.ac_if;
 327         if_initname(ifp, VKE_DEVNAME, sc->sc_unit);
 328
 329         /* NB: after if_initname() */
 330         sysctl_ctx_init(&sc->sc_sysctl_ctx);
 331         sc->sc_sysctl_tree = SYSCTL_ADD_NODE(&sc->sc_sysctl_ctx,
 332                                              SYSCTL_STATIC_CHILDREN(_hw),
 333                                              OID_AUTO, ifp->if_xname,
 334                                              CTLFLAG_RD, 0, "");
 335         if (sc->sc_sysctl_tree == NULL) {
 336                 kprintf(VKE_DEVNAME "%d: can't add sysctl node\n", unit);
 337         } else {
 338                 SYSCTL_ADD_INT(&sc->sc_sysctl_ctx,
 339                                SYSCTL_CHILDREN(sc->sc_sysctl_tree),
 340                                OID_AUTO, "tap_unit",
 341                                CTLFLAG_RW, &sc->sc_tap_unit, 0,
 342                                "Backend tap(4) unit");
 343         }
 344
 345         ifp->if_softc = sc;
 346         ifp->if_ioctl = vke_ioctl;
 347         ifp->if_start = vke_start;
 348         ifp->if_init = vke_init;
 349         ifp->if_mtu = tapinfo.mtu;
 350         ifp->if_baudrate = tapinfo.baudrate;
 351         ifp->if_flags = IFF_BROADCAST | IFF_SIMPLEX | IFF_MULTICAST;
 352         ifq_set_maxlen(&ifp->if_snd, IFQ_MAXLEN);
 353         ifq_set_ready(&ifp->if_snd);
 354
 355         /* TODO: if_media */
 356
 357         ether_ifattach(ifp, enaddr, NULL);
 358
 359         if (bootverbose && sc->sc_addr != 0) {
 360                 if_printf(ifp, "pre-configured "
 361                           "address 0x%08x, netmask 0x%08x\n",
 362                           ntohl(sc->sc_addr), ntohl(sc->sc_mask));
 363         }
 364
 365         return 0;
 366 }
 367
 368 static int
 369 vke_init_addr(struct ifnet *ifp, in_addr_t addr, in_addr_t mask)
 370 {
 371         struct ifaliasreq ifra;
 372         struct sockaddr_in *sin;
 373         int ret;
 374
 375         ASSERT_SERIALIZED(ifp->if_serializer);
 376
 377         if (bootverbose) {
 378                 if_printf(ifp, "add pre-configured "
 379                           "address 0x%08x, netmask 0x%08x\n",
 380                           ntohl(addr), ntohl(mask));
 381         }
 382
 383         bzero(&ifra, sizeof(ifra));
 384
 385         /* NB: no need to set ifaliasreq.ifra_name */
 386
 387         sin = (struct sockaddr_in *)&ifra.ifra_addr;
 388         sin->sin_family = AF_INET;
 389         sin->sin_len = sizeof(*sin);
 390         sin->sin_addr.s_addr = addr;
 391
 392         if (mask != 0) {
 393                 sin = (struct sockaddr_in *)&ifra.ifra_mask;
 394                 sin->sin_len = sizeof(*sin);
 395                 sin->sin_addr.s_addr = mask;
 396         }
 397
 398         /*
 399          * Temporarily release serializer, in_control() will hold
 400          * it again before calling ifnet.if_ioctl().
 401          */
 402         lwkt_serialize_exit(ifp->if_serializer);
 403         ret = in_control(NULL, SIOCAIFADDR, (caddr_t)&ifra, ifp, NULL);
 404         lwkt_serialize_enter(ifp->if_serializer);
 405
 406         return ret;
 407 }
 408