pdq_ifsubr.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  * Copyright (c) 1995, 1996 Matt Thomas <matt@3am-software.com>
    3  * 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 disclaimer.
   10  * 2. The name of the author may not be used to endorse or promote products
   11  *    derived from this software withough specific prior written permission
   12  *
   13  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
   14  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
   15  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
   16  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
   17  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
   18  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
   19  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
   20  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
   21  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
   22  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
   23  *
   24  * $FreeBSD$
   25  *
   26  */
   27 
   28 /*
   29  * DEC PDQ FDDI Controller; code for BSD derived operating systems
   30  *
   31  *      This module provide bus independent BSD specific O/S functions.
   32  *      (ie. it provides an ifnet interface to the rest of the system)
   33  */
   34 
   35 
   36 #include "opt_inet.h"
   37 
   38 #include <sys/param.h>
   39 #include <sys/socket.h>
   40 #include <sys/sockio.h>
   41 #if defined(__bsdi__) || defined(__NetBSD__)
   42 #include <sys/device.h>
   43 #endif
   44 
   45 #include <net/if.h>
   46 #include <net/if_dl.h>
   47 
   48 #include <net/bpf.h>
   49 
   50 #if defined(__FreeBSD__)
   51 #ifdef INET
   52 #include <netinet/in.h>
   53 #include <netinet/if_ether.h>
   54 #endif
   55 #include <netinet/if_fddi.h>
   56 #else
   57 #include <net/if_fddi.h>
   58 #endif
   59 
   60 #if defined(__bsdi__)
   61 #include <i386/isa/isavar.h>
   62 #endif
   63 
   64 #ifdef NS
   65 #include <netns/ns.h>
   66 #include <netns/ns_if.h>
   67 #endif
   68 
   69 #if defined(__FreeBSD__)
   70 #include <dev/pdq/pdqvar.h>
   71 #include <dev/pdq/pdqreg.h>
   72 #else
   73 #include "pdqvar.h"
   74 #include "pdqreg.h"
   75 #endif
   76 
   77 #if defined(__bsdi__) && _BSDI_VERSION < 199506 /* XXX */
   78 static void
   79 arp_ifinit(
   80     struct arpcom *ac,
   81     struct ifaddr *ifa)
   82 {
   83     sc->sc_ac.ac_ipaddr = IA_SIN(ifa)->sin_addr;
   84     arpwhohas(&sc->sc_ac, &IA_SIN(ifa)->sin_addr);
   85 #if _BSDI_VERSION >= 199401
   86     ifa->ifa_rtrequest = arp_rtrequest;
   87     ifa->ifa_flags |= RTF_CLONING;
   88 #endif
   89 }
   90 #endif
   91 
   92 
   93 void
   94 pdq_ifinit(
   95     pdq_softc_t *sc)
   96 {
   97     if (sc->sc_if.if_flags & IFF_UP) {
   98         sc->sc_if.if_flags |= IFF_RUNNING;
   99         if (sc->sc_if.if_flags & IFF_PROMISC) {
  100             sc->sc_pdq->pdq_flags |= PDQ_PROMISC;
  101         } else {
  102             sc->sc_pdq->pdq_flags &= ~PDQ_PROMISC;
  103         }
  104         if (sc->sc_if.if_flags & IFF_ALLMULTI) {
  105             sc->sc_pdq->pdq_flags |= PDQ_ALLMULTI;
  106         } else {
  107             sc->sc_pdq->pdq_flags &= ~PDQ_ALLMULTI;
  108         }
  109         if (sc->sc_if.if_flags & IFF_LINK1) {
  110             sc->sc_pdq->pdq_flags |= PDQ_PASS_SMT;
  111         } else {
  112             sc->sc_pdq->pdq_flags &= ~PDQ_PASS_SMT;
  113         }
  114         sc->sc_pdq->pdq_flags |= PDQ_RUNNING;
  115         pdq_run(sc->sc_pdq);
  116     } else {
  117         sc->sc_if.if_flags &= ~IFF_RUNNING;
  118         sc->sc_pdq->pdq_flags &= ~PDQ_RUNNING;
  119         pdq_stop(sc->sc_pdq);
  120     }
  121 }
  122 
  123 void
  124 pdq_ifwatchdog(
  125     struct ifnet *ifp)
  126 {
  127     /*
  128      * No progress was made on the transmit queue for PDQ_OS_TX_TRANSMIT
  129      * seconds.  Remove all queued packets.
  130      */
  131 
  132     ifp->if_flags &= ~IFF_OACTIVE;
  133     ifp->if_timer = 0;
  134     for (;;) {
  135         struct mbuf *m;
  136         IF_DEQUEUE(&ifp->if_snd, m);
  137         if (m == NULL)
  138             return;
  139         m_freem(m);
  140     }
  141 }
  142 
  143 ifnet_ret_t
  144 pdq_ifstart(
  145     struct ifnet *ifp)
  146 {
  147     pdq_softc_t *sc = (pdq_softc_t *) ((caddr_t) ifp - offsetof(pdq_softc_t, sc_ac.ac_if));
  148     struct ifqueue *ifq = &ifp->if_snd;
  149     struct mbuf *m;
  150     int tx = 0;
  151 
  152     if ((ifp->if_flags & IFF_RUNNING) == 0)
  153         return;
  154 
  155     if (sc->sc_if.if_timer == 0)
  156         sc->sc_if.if_timer = PDQ_OS_TX_TIMEOUT;
  157 
  158     if ((sc->sc_pdq->pdq_flags & PDQ_TXOK) == 0) {
  159         sc->sc_if.if_flags |= IFF_OACTIVE;
  160         return;
  161     }
  162     for (;; tx = 1) {
  163         IF_DEQUEUE(ifq, m);
  164         if (m == NULL)
  165             break;
  166 
  167         if (pdq_queue_transmit_data(sc->sc_pdq, m) == PDQ_FALSE) {
  168             ifp->if_flags |= IFF_OACTIVE;
  169             IF_PREPEND(ifq, m);
  170             break;
  171         }
  172     }
  173     if (tx)
  174         PDQ_DO_TYPE2_PRODUCER(sc->sc_pdq);
  175 }
  176 
  177 void
  178 pdq_os_receive_pdu(
  179     pdq_t *pdq,
  180     struct mbuf *m,
  181     size_t pktlen)
  182 {
  183     pdq_softc_t *sc = (pdq_softc_t *) pdq->pdq_os_ctx;
  184     struct fddi_header *fh = mtod(m, struct fddi_header *);
  185 
  186     sc->sc_if.if_ipackets++;
  187     if (sc->sc_bpf != NULL)
  188         PDQ_BPF_MTAP(sc, m);
  189     if ((fh->fddi_fc & (FDDIFC_L|FDDIFC_F)) != FDDIFC_LLC_ASYNC) {
  190         m_freem(m);
  191         return;
  192     }
  193 
  194     m->m_data += sizeof(struct fddi_header);
  195     m->m_len  -= sizeof(struct fddi_header);
  196     m->m_pkthdr.len = pktlen - sizeof(struct fddi_header);
  197     m->m_pkthdr.rcvif = &sc->sc_if;
  198     fddi_input(&sc->sc_if, fh, m);
  199 }
  200 
  201 void
  202 pdq_os_restart_transmitter(
  203     pdq_t *pdq)
  204 {
  205     pdq_softc_t *sc = (pdq_softc_t *) pdq->pdq_os_ctx;
  206     sc->sc_if.if_flags &= ~IFF_OACTIVE;
  207     if (sc->sc_if.if_snd.ifq_head != NULL) {
  208         sc->sc_if.if_timer = PDQ_OS_TX_TIMEOUT;
  209         pdq_ifstart(&sc->sc_if);
  210     } else {
  211         sc->sc_if.if_timer = 0;
  212     }
  213 }
  214 
  215 void
  216 pdq_os_transmit_done(
  217     pdq_t *pdq,
  218     struct mbuf *m)
  219 {
  220     pdq_softc_t *sc = (pdq_softc_t *) pdq->pdq_os_ctx;
  221     if (sc->sc_bpf != NULL)
  222         PDQ_BPF_MTAP(sc, m);
  223     m_freem(m);
  224     sc->sc_if.if_opackets++;
  225 }
  226 
  227 void
  228 pdq_os_addr_fill(
  229     pdq_t *pdq,
  230     pdq_lanaddr_t *addr,
  231     size_t num_addrs)
  232 {
  233     pdq_softc_t *sc = (pdq_softc_t *) pdq->pdq_os_ctx;
  234     struct ifmultiaddr *ifma;
  235 
  236     for (ifma = sc->sc_if.if_multiaddrs.lh_first; ifma && num_addrs > 0;
  237          ifma = ifma->ifma_link.le_next) {
  238             char *mcaddr;
  239             if (ifma->ifma_addr->sa_family != AF_LINK)
  240                     continue;
  241             mcaddr = LLADDR((struct sockaddr_dl *)ifma->ifma_addr);
  242             ((u_short *) addr->lanaddr_bytes)[0] = ((u_short *) mcaddr)[0];
  243             ((u_short *) addr->lanaddr_bytes)[1] = ((u_short *) mcaddr)[1];
  244             ((u_short *) addr->lanaddr_bytes)[2] = ((u_short *) mcaddr)[2];
  245             addr++;
  246             num_addrs--;
  247     }
  248 }
  249 
  250 int
  251 pdq_ifioctl(
  252     struct ifnet *ifp,
  253     ioctl_cmd_t cmd,
  254     caddr_t data)
  255 {
  256     pdq_softc_t *sc = (pdq_softc_t *) ((caddr_t) ifp - offsetof(pdq_softc_t, sc_ac.ac_if));
  257     int s, error = 0;
  258 
  259     s = splimp();
  260 
  261     switch (cmd) {
  262         case SIOCSIFADDR: {
  263             struct ifaddr *ifa = (struct ifaddr *)data;
  264 
  265             ifp->if_flags |= IFF_UP;
  266             switch(ifa->ifa_addr->sa_family) {
  267 #if defined(INET)
  268                 case AF_INET: {
  269                     pdq_ifinit(sc);
  270                     arp_ifinit(&sc->sc_ac, ifa);
  271                     break;
  272                 }
  273 #endif /* INET */
  274 
  275 #if defined(NS)
  276                 /* This magic copied from if_is.c; I don't use XNS,
  277                  * so I have no way of telling if this actually
  278                  * works or not.
  279                  */
  280                 case AF_NS: {
  281                     struct ns_addr *ina = &(IA_SNS(ifa)->sns_addr);
  282                     if (ns_nullhost(*ina)) {
  283                         ina->x_host = *(union ns_host *)(sc->sc_ac.ac_enaddr);
  284                     } else {
  285                         ifp->if_flags &= ~IFF_RUNNING;
  286                         bcopy((caddr_t)ina->x_host.c_host,
  287                               (caddr_t)sc->sc_ac.ac_enaddr,
  288                               sizeof sc->sc_ac.ac_enaddr);
  289                     }
  290 
  291                     pdq_ifinit(sc);
  292                     break;
  293                 }
  294 #endif /* NS */
  295 
  296                 default: {
  297                     pdq_ifinit(sc);
  298                     break;
  299                 }
  300             }
  301             break;
  302         }
  303         case SIOCGIFADDR: {
  304             struct ifreq *ifr = (struct ifreq *)data;
  305             bcopy((caddr_t) sc->sc_ac.ac_enaddr,
  306                   (caddr_t) ((struct sockaddr *)&ifr->ifr_data)->sa_data,
  307                   6);
  308             break;
  309         }
  310 
  311         case SIOCSIFFLAGS: {
  312             pdq_ifinit(sc);
  313             break;
  314         }
  315 
  316         case SIOCADDMULTI:
  317         case SIOCDELMULTI:
  318                 /*
  319                  * Update multicast listeners
  320                  */
  321                 if (sc->sc_if.if_flags & IFF_RUNNING)
  322                         pdq_run(sc->sc_pdq);
  323                 error = 0;
  324                 break;
  325 
  326 #if defined(SIOCSIFMTU)
  327 #if !defined(ifr_mtu)
  328 #define ifr_mtu ifr_metric
  329 #endif
  330         case SIOCSIFMTU: {
  331             struct ifreq *ifr = (struct ifreq *)data;
  332             /*
  333              * Set the interface MTU.
  334              */
  335             if (ifr->ifr_mtu > FDDIMTU) {
  336                 error = EINVAL;
  337                 break;
  338             }
  339             ifp->if_mtu = ifr->ifr_mtu;
  340             break;
  341         }
  342 #endif /* SIOCSIFMTU */
  343 
  344         default: {
  345             error = EINVAL;
  346             break;
  347         }
  348     }
  349 
  350     splx(s);
  351     return error;
  352 }
  353 
  354 #ifndef IFF_NOTRAILERS
  355 #define IFF_NOTRAILERS  0
  356 #endif
  357 
  358 void
  359 pdq_ifattach(
  360     pdq_softc_t *sc,
  361     ifnet_ret_t (*ifwatchdog)(int unit))
  362 {
  363     struct ifnet *ifp = &sc->sc_if;
  364 
  365     ifp->if_flags = IFF_BROADCAST|IFF_SIMPLEX|IFF_NOTRAILERS|IFF_MULTICAST;
  366 
  367 #if (defined(__FreeBSD__) && BSD >= 199506) || defined(__NetBSD__)
  368     ifp->if_watchdog = pdq_ifwatchdog;
  369 #else
  370     ifp->if_watchdog = ifwatchdog;
  371 #endif
  372 
  373     ifp->if_ioctl = pdq_ifioctl;
  374     ifp->if_output = fddi_output;
  375     ifp->if_start = pdq_ifstart;
  376     ifp->if_snd.ifq_maxlen = IFQ_MAXLEN;
  377 #warning "Implement fddi_resolvemulti!"
  378 /*    ifp->if_resolvemulti = ether_resolvemulti; XXX */
  379   
  380     if_attach(ifp);
  381     fddi_ifattach(ifp);
  382     PDQ_BPFATTACH(sc, DLT_FDDI, sizeof(struct fddi_header));
  383 }
Cache object: ed7621d398a38b66df1ada701413540e
[ 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.
FreeBSD/Linux Kernel Cross Reference sys/dev/pdq/pdq_ifsubr.c

FreeBSD/Linux Kernel Cross Reference
sys/dev/pdq/pdq_ifsubr.c
