sys/net/if_edsc.c

   1 /*-
   2  * Copyright (c) 1982, 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 edsclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following edsclaimer 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 EDSCLAIMED.  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  *      From: @(#)if_loop.c     8.1 (Berkeley) 6/10/93
  30  * $FreeBSD$
  31  */
  32
  33 /*
  34  * Discard interface driver for protocol testing and timing.
  35  * Mimics an Ethernet device so that VLANs can be attached to it etc.
  36  */
  37
  38 #include <sys/param.h>          /* types, important constants */
  39 #include <sys/kernel.h>         /* SYSINIT for load-time initializations */
  40 #include <sys/malloc.h>         /* malloc(9) */
  41 #include <sys/module.h>         /* module(9) */
  42 #include <sys/mbuf.h>           /* mbuf(9) */
  43 #include <sys/socket.h>         /* struct ifreq */
  44 #include <sys/sockio.h>         /* socket ioctl's */
  45 /* #include <sys/systm.h> if you need printf(9) or other all-purpose globals */
  46
  47 #include <net/bpf.h>            /* bpf(9) */
  48 #include <net/ethernet.h>       /* Ethernet related constants and types */
  49 #include <net/if.h>
  50 #include <net/if_var.h>         /* basic part of ifnet(9) */
  51 #include <net/if_clone.h>       /* network interface cloning */
  52 #include <net/if_types.h>       /* IFT_ETHER and friends */
  53 #include <net/if_var.h>         /* kernel-only part of ifnet(9) */
  54 #include <net/vnet.h>
  55
  56 static const char edscname[] = "edsc";
  57
  58 /*
  59  * Software configuration of an interface specific to this device type.
  60  */
  61 struct edsc_softc {
  62         struct ifnet    *sc_ifp; /* ptr to generic interface configuration */
  63
  64         /*
  65          * A non-null driver can keep various things here, for instance,
  66          * the hardware revision, cached values of write-only registers, etc.
  67          */
  68 };
  69
  70 /*
  71  * Attach to the interface cloning framework.
  72  */
  73 static VNET_DEFINE(struct if_clone *, edsc_cloner);
  74 #define V_edsc_cloner   VNET(edsc_cloner)
  75 static int      edsc_clone_create(struct if_clone *, int, caddr_t);
  76 static void     edsc_clone_destroy(struct ifnet *);
  77
  78 /*
  79  * Interface driver methods.
  80  */
  81 static void     edsc_init(void *dummy);
  82 /* static void edsc_input(struct ifnet *ifp, struct mbuf *m); would be here */
  83 static int      edsc_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data);
  84 static void     edsc_start(struct ifnet *ifp);
  85
  86 /*
  87  * We'll allocate softc instances from this.
  88  */
  89 static          MALLOC_DEFINE(M_EDSC, edscname, "Ethernet discard interface");
  90
  91 /*
  92  * Create an interface instance.
  93  */
  94 static int
  95 edsc_clone_create(struct if_clone *ifc, int unit, caddr_t params)
  96 {
  97         struct edsc_softc       *sc;
  98         struct ifnet            *ifp;
  99         static u_char            eaddr[ETHER_ADDR_LEN]; /* 0:0:0:0:0:0 */
 100
 101         /*
 102          * Allocate soft and ifnet structures.  Link each to the other.
 103          */
 104         sc = malloc(sizeof(struct edsc_softc), M_EDSC, M_WAITOK | M_ZERO);
 105         ifp = sc->sc_ifp = if_alloc(IFT_ETHER);
 106         if (ifp == NULL) {
 107                 free(sc, M_EDSC);
 108                 return (ENOSPC);
 109         }
 110
 111         ifp->if_softc = sc;
 112
 113         /*
 114          * Get a name for this particular interface in its ifnet structure.
 115          */
 116         if_initname(ifp, edscname, unit);
 117
 118         /*
 119          * Typical Ethernet interface flags: we can do broadcast and
 120          * multicast but can't hear our own broadcasts or multicasts.
 121          */
 122         ifp->if_flags = IFF_BROADCAST | IFF_MULTICAST | IFF_SIMPLEX;
 123
 124         /*
 125          * We can pretent we have the whole set of hardware features
 126          * because we just discard all packets we get from the upper layer.
 127          * However, the features are disabled initially.  They can be
 128          * enabled via edsc_ioctl() when needed.
 129          */
 130         ifp->if_capabilities =
 131             IFCAP_VLAN_MTU | IFCAP_VLAN_HWTAGGING | IFCAP_VLAN_HWCSUM |
 132             IFCAP_HWCSUM | IFCAP_TSO |
 133             IFCAP_JUMBO_MTU;
 134         ifp->if_capenable = 0;
 135
 136         /*
 137          * Set the interface driver methods.
 138          */
 139         ifp->if_init = edsc_init;
 140         /* ifp->if_input = edsc_input; */
 141         ifp->if_ioctl = edsc_ioctl;
 142         ifp->if_start = edsc_start;
 143
 144         /*
 145          * Set the maximum output queue length from the global parameter.
 146          */
 147         ifp->if_snd.ifq_maxlen = ifqmaxlen;
 148
 149         /*
 150          * Do ifnet initializations common to all Ethernet drivers
 151          * and attach to the network interface framework.
 152          * TODO: Pick a non-zero link level address.
 153          */
 154         ether_ifattach(ifp, eaddr);
 155
 156         /*
 157          * Now we can mark the interface as running, i.e., ready
 158          * for operation.
 159          */
 160         ifp->if_drv_flags |= IFF_DRV_RUNNING;
 161
 162         return (0);
 163 }
 164
 165 /*
 166  * Destroy an interface instance.
 167  */
 168 static void
 169 edsc_clone_destroy(struct ifnet *ifp)
 170 {
 171         struct edsc_softc       *sc = ifp->if_softc;
 172
 173         /*
 174          * Detach from the network interface framework.
 175          */
 176         ether_ifdetach(ifp);
 177
 178         /*
 179          * Free memory occupied by ifnet and softc.
 180          */
 181         if_free(ifp);
 182         free(sc, M_EDSC);
 183 }
 184
 185 /*
 186  * This method is invoked from ether_ioctl() when it's time
 187  * to bring up the hardware.
 188  */
 189 static void
 190 edsc_init(void *dummy)
 191 {
 192 #if 0   /* what a hardware driver would do here... */
 193         struct edsc_soft        *sc = (struct edsc_softc *)dummy;
 194         struct ifnet            *ifp = sc->sc_ifp;
 195
 196         /* blah-blah-blah */
 197 #endif
 198 }
 199
 200 /*
 201  * Network interfaces are controlled via the ioctl(2) syscall.
 202  */
 203 static int
 204 edsc_ioctl(struct ifnet *ifp, u_long cmd, caddr_t data)
 205 {
 206         struct ifreq            *ifr = (struct ifreq *)data;
 207
 208         switch (cmd) {
 209         case SIOCSIFCAP:
 210 #if 1
 211                 /*
 212                  * Just turn on any capabilities requested.
 213                  * The generic ifioctl() function has already made sure
 214                  * that they are supported, i.e., set in if_capabilities.
 215                  */
 216                 ifp->if_capenable = ifr->ifr_reqcap;
 217 #else
 218                 /*
 219                  * A h/w driver would need to analyze the requested
 220                  * bits and program the hardware, e.g.:
 221                  */
 222                 mask = ifp->if_capenable ^ ifr->ifr_reqcap;
 223
 224                 if (mask & IFCAP_VLAN_HWTAGGING) {
 225                         ifp->if_capenable ^= IFCAP_VLAN_HWTAGGING;
 226
 227                         if (ifp->if_capenable & IFCAP_VLAN_HWTAGGING)
 228                                 /* blah-blah-blah */
 229                         else
 230                                 /* etc-etc-etc */
 231                 }
 232 #endif
 233                 break;
 234
 235         default:
 236                 /*
 237                  * Offload the rest onto the common Ethernet handler.
 238                  */
 239                 return (ether_ioctl(ifp, cmd, data));
 240         }
 241
 242         return (0);
 243 }
 244
 245 /*
 246  * Process the output queue.
 247  */
 248 static void
 249 edsc_start(struct ifnet *ifp)
 250 {
 251         struct mbuf             *m;
 252
 253         /*
 254          * A hardware interface driver can set IFF_DRV_OACTIVE
 255          * in ifp->if_drv_flags:
 256          *
 257          * ifp->if_drv_flags |= IFF_DRV_OACTIVE;
 258          *
 259          * to prevent if_start from being invoked again while the
 260          * transmission is under way.  The flag is to protect the
 261          * device's transmitter, not the method itself.  The output
 262          * queue is locked and several threads can process it in
 263          * parallel safely, so the driver can use other means to
 264          * serialize access to the transmitter.
 265          *
 266          * If using IFF_DRV_OACTIVE, the driver should clear the flag
 267          * not earlier than the current transmission is complete, e.g.,
 268          * upon an interrupt from the device, not just before returning
 269          * from if_start.  This method merely starts the transmission,
 270          * which may proceed asynchronously.
 271          */
 272
 273         /*
 274          * We loop getting packets from the queue until it's empty.
 275          * A h/w driver would loop until the device can accept more
 276          * data into its buffer, or while there are free transmit
 277          * descriptors, or whatever.
 278          */
 279         for (;;) {
 280                 /*
 281                  * Try to dequeue one packet.  Stop if the queue is empty.
 282                  * Use IF_DEQUEUE() here if ALTQ(9) support is unneeded.
 283                  */
 284                 IFQ_DEQUEUE(&ifp->if_snd, m);
 285                 if (m == NULL)
 286                         break;
 287
 288                 /*
 289                  * Let bpf(9) at the packet.
 290                  */
 291                 BPF_MTAP(ifp, m);
 292
 293                 /*
 294                  * Update the interface counters.
 295                  */
 296                 if_inc_counter(ifp, IFCOUNTER_OBYTES, m->m_pkthdr.len);
 297                 if_inc_counter(ifp, IFCOUNTER_OPACKETS, 1);
 298
 299                 /*
 300                  * Finally, just drop the packet.
 301                  * TODO: Reply to ARP requests unless IFF_NOARP is set.
 302                  */
 303                 m_freem(m);
 304         }
 305
 306         /*
 307          * ifp->if_drv_flags &= ~IFF_DRV_OACTIVE;
 308          * would be here only if the transmission were synchronous.
 309          */
 310 }
 311
 312 static void
 313 vnet_edsc_init(const void *unused __unused)
 314 {
 315
 316         /*
 317          * Connect to the network interface cloning framework.
 318          * The last argument is the number of units to be created
 319          * from the outset.  It's also the minimum number of units
 320          * allowed.  We don't want any units created as soon as the
 321          * driver is loaded.
 322          */
 323         V_edsc_cloner = if_clone_simple(edscname, edsc_clone_create,
 324             edsc_clone_destroy, 0);
 325 }
 326 VNET_SYSINIT(vnet_edsc_init, SI_SUB_PROTO_IFATTACHDOMAIN, SI_ORDER_ANY,
 327     vnet_edsc_init, NULL);
 328
 329 static void
 330 vnet_edsc_uninit(const void *unused __unused)
 331 {
 332
 333         /*
 334          * Disconnect from the cloning framework.
 335          * Existing interfaces will be disposed of properly.
 336          */
 337         if_clone_detach(V_edsc_cloner);
 338 }
 339 VNET_SYSUNINIT(vnet_edsc_uninit, SI_SUB_INIT_IF, SI_ORDER_ANY,
 340     vnet_edsc_uninit, NULL);
 341
 342 /*
 343  * This function provides handlers for module events, namely load and unload.
 344  */
 345 static int
 346 edsc_modevent(module_t mod, int type, void *data)
 347 {
 348
 349         switch (type) {
 350         case MOD_LOAD:
 351         case MOD_UNLOAD:
 352                 break;
 353         default:
 354                 /*
 355                  * There are other event types, but we don't handle them.
 356                  * See module(9).
 357                  */
 358                 return (EOPNOTSUPP);
 359         }
 360         return (0);
 361 }
 362
 363 static moduledata_t edsc_mod = {
 364         "if_edsc",                      /* name */
 365         edsc_modevent,                  /* event handler */
 366         NULL                            /* additional data */
 367 };
 368
 369 DECLARE_MODULE(if_edsc, edsc_mod, SI_SUB_PSEUDO, SI_ORDER_ANY);