The Design and Implementation of the FreeBSD Operating System, Second Edition
Now available: The Design and Implementation of the FreeBSD Operating System (Second Edition)


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]

FreeBSD/Linux Kernel Cross Reference
sys/net/if_edsc.c

Version: -  FREEBSD  -  FREEBSD-13-STABLE  -  FREEBSD-13-0  -  FREEBSD-12-STABLE  -  FREEBSD-12-0  -  FREEBSD-11-STABLE  -  FREEBSD-11-0  -  FREEBSD-10-STABLE  -  FREEBSD-10-0  -  FREEBSD-9-STABLE  -  FREEBSD-9-0  -  FREEBSD-8-STABLE  -  FREEBSD-8-0  -  FREEBSD-7-STABLE  -  FREEBSD-7-0  -  FREEBSD-6-STABLE  -  FREEBSD-6-0  -  FREEBSD-5-STABLE  -  FREEBSD-5-0  -  FREEBSD-4-STABLE  -  FREEBSD-3-STABLE  -  FREEBSD22  -  l41  -  OPENBSD  -  linux-2.6  -  MK84  -  PLAN9  -  xnu-8792 
SearchContext: -  none  -  3  -  10 

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

Cache object: 60501447cd721135a25ee27b32eedacc


[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]


This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.