/*      $NetBSD: altq_fifoq.c,v 1.19 2025/01/08 13:00:04 joe Exp $      */
/*      $KAME: altq_fifoq.c,v 1.12 2003/07/10 12:07:48 kjc Exp $        */

/*
* Copyright (C) 1997-2002
*      Sony Computer Science Laboratories Inc.  All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY SONY CSL AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED.  IN NO EVENT SHALL SONY CSL OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
*/

#include <sys/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: altq_fifoq.c,v 1.19 2025/01/08 13:00:04 joe Exp $");

#ifdef _KERNEL_OPT
#include "opt_altq.h"
#endif

#ifdef ALTQ_FIFOQ  /* fifoq is enabled by ALTQ_FIFOQ option in opt_altq.h */

/*
* FIFOQ is an altq sample implementation.  There will be little
* need to use FIFOQ as an alternative queueing scheme.
* But this code is provided as a template for those who want to
* write their own queueing schemes.
*/

#include <sys/param.h>
#include <sys/malloc.h>
#include <sys/mbuf.h>
#include <sys/socket.h>
#include <sys/sockio.h>
#include <sys/systm.h>
#include <sys/proc.h>
#include <sys/errno.h>
#include <sys/kernel.h>
#include <sys/kauth.h>

#include <net/if.h>
#include <net/if_types.h>
#include <netinet/in.h>

#include <altq/altq.h>
#include <altq/altq_conf.h>
#include <altq/altq_fifoq.h>

#ifdef ALTQ3_COMPAT

#define FIFOQ_STATS     /* collect statistics */

/* fifoq_list keeps all fifoq_state_t's allocated. */
static fifoq_state_t *fifoq_list = NULL;

/* internal function prototypes */
static int              fifoq_enqueue(struct ifaltq *, struct mbuf *);
static struct mbuf      *fifoq_dequeue(struct ifaltq *, int);
static int              fifoq_detach(fifoq_state_t *);
static int              fifoq_request(struct ifaltq *, int, void *);
static void             fifoq_purge(fifoq_state_t *);

/*
* fifoq device interface
*/
altqdev_decl(fifoq);

int
fifoqopen(dev_t dev, int flag, int fmt,
   struct lwp *l)
{
       /* everything will be done when the queueing scheme is attached. */
       return 0;
}

/*
* there are 2 ways to act on close.
*   detach-all-on-close:
*      use for the daemon style approach.  if the daemon dies, all the
*      resource will be released.
*   no-action-on-close:
*      use for the command style approach.  (e.g.  fifoq on/off)
*
* note: close is called not on every close but when the last reference
*       is removed (only once with multiple simultaneous references.)
*/
int
fifoqclose(dev_t dev, int flag, int fmt,
   struct lwp *l)
{
       fifoq_state_t *q;
       int err, error = 0;

       while ((q = fifoq_list) != NULL) {
               /* destroy all */
               err = fifoq_detach(q);
               if (err != 0 && error == 0)
                       error = err;
       }

       return error;
}

int
fifoqioctl(dev_t dev, ioctlcmd_t cmd, void *addr, int flag,
   struct lwp *l)
{
       fifoq_state_t *q;
       struct fifoq_interface *ifacep;
       struct ifnet *ifp;
       int     error = 0;

       /* check super-user privilege */
       switch (cmd) {
       case FIFOQ_GETSTATS:
               break;
       default:
               if ((error = kauth_authorize_network(l->l_cred,
                   KAUTH_NETWORK_ALTQ, KAUTH_REQ_NETWORK_ALTQ_FIFOQ, NULL,
                   NULL, NULL)) != 0)
                       return error;
               break;
       }

       switch (cmd) {
       case FIFOQ_ENABLE:
               ifacep = (struct fifoq_interface *)addr;
               if ((q = altq_lookup(ifacep->fifoq_ifname, ALTQT_FIFOQ))
                   == NULL) {
                       error = EBADF;
                       break;
               }
               error = altq_enable(q->q_ifq);
               break;

       case FIFOQ_DISABLE:
               ifacep = (struct fifoq_interface *)addr;
               if ((q = altq_lookup(ifacep->fifoq_ifname, ALTQT_FIFOQ))
                   == NULL) {
                       error = EBADF;
                       break;
               }
               error = altq_disable(q->q_ifq);
               break;

       case FIFOQ_IF_ATTACH:
               ifp = ifunit(((struct fifoq_interface *)addr)->fifoq_ifname);
               if (ifp == NULL) {
                       error = ENXIO;
                       break;
               }

               /* allocate and initialize fifoq_state_t */
               q = malloc(sizeof(fifoq_state_t), M_DEVBUF, M_WAITOK|M_ZERO);
               if (q == NULL) {
                       error = ENOMEM;
                       break;
               }

               q->q_ifq = &ifp->if_snd;
               q->q_head = q->q_tail = NULL;
               q->q_len = 0;
               q->q_limit = FIFOQ_LIMIT;

               /*
                * set FIFOQ to this ifnet structure.
                */
               error = altq_attach(q->q_ifq, ALTQT_FIFOQ, q,
                                   fifoq_enqueue, fifoq_dequeue, fifoq_request,
                                   NULL, NULL);
               if (error) {
                       free(q, M_DEVBUF);
                       break;
               }

               /* add this state to the fifoq list */
               q->q_next = fifoq_list;
               fifoq_list = q;
               break;

       case FIFOQ_IF_DETACH:
               ifacep = (struct fifoq_interface *)addr;
               if ((q = altq_lookup(ifacep->fifoq_ifname, ALTQT_FIFOQ))
                   == NULL) {
                       error = EBADF;
                       break;
               }
               error = fifoq_detach(q);
               break;

       case FIFOQ_GETSTATS:
               do {
                       struct fifoq_getstats *q_stats;

                       q_stats = (struct fifoq_getstats *)addr;
                       if ((q = altq_lookup(q_stats->iface.fifoq_ifname,
                                            ALTQT_FIFOQ)) == NULL) {
                               error = EBADF;
                               break;
                       }

                       q_stats->q_len          = q->q_len;
                       q_stats->q_limit        = q->q_limit;
                       q_stats->xmit_cnt       = q->q_stats.xmit_cnt;
                       q_stats->drop_cnt       = q->q_stats.drop_cnt;
                       q_stats->period         = q->q_stats.period;
               } while (/*CONSTCOND*/ 0);
               break;

       case FIFOQ_CONFIG:
               do {
                       struct fifoq_conf *fc;
                       int limit;

                       fc = (struct fifoq_conf *)addr;
                       if ((q = altq_lookup(fc->iface.fifoq_ifname,
                                            ALTQT_FIFOQ)) == NULL) {
                               error = EBADF;
                               break;
                       }
                       limit = fc->fifoq_limit;
                       if (limit < 0)
                               limit = 0;
                       q->q_limit = limit;
                       fc->fifoq_limit = limit;
               } while (/*CONSTCOND*/ 0);
               break;

       default:
               error = EINVAL;
               break;
       }
       return error;
}

/*
* fifoq support routines
*/

/*
* enqueue routine:
*
*      returns: 0 when successfully queued.
*               ENOBUFS when drop occurs.
*/
static int
fifoq_enqueue(struct ifaltq *ifq, struct mbuf *m)
{
       fifoq_state_t *q = (fifoq_state_t *)ifq->altq_disc;

       /* if the queue is full, drop the incoming packet(drop-tail) */
       if (q->q_len >= q->q_limit) {
#ifdef FIFOQ_STATS
               PKTCNTR_ADD(&q->q_stats.drop_cnt, m_pktlen(m));
#endif
               m_freem(m);
               return ENOBUFS;
       }

       /* enqueue the packet at the taile of the queue */
       m->m_nextpkt = NULL;
       if (q->q_tail == NULL)
               q->q_head = m;
       else
               q->q_tail->m_nextpkt = m;
       q->q_tail = m;
       q->q_len++;
       ifq->ifq_len++;
       return 0;
}

/*
* dequeue routine:
*      must be called in splnet.
*
*      returns: mbuf dequeued.
*               NULL when no packet is available in the queue.
*/
/*
* ALTDQ_PEEK is provided for drivers which need to know the next packet
* to send in advance.
* when ALTDQ_PEEK is specified, the next packet to be dequeued is
* returned without dequeueing the packet.
* when ALTDQ_DEQUEUE is called *immediately after* an ALTDQ_PEEK
* operation, the same packet should be returned.
*/
static struct mbuf *
fifoq_dequeue(struct ifaltq *ifq, int op)
{
       fifoq_state_t *q = (fifoq_state_t *)ifq->altq_disc;
       struct mbuf *m = NULL;

       if (op == ALTDQ_POLL)
               return (q->q_head);

       if ((m = q->q_head) == NULL)
               return NULL;

       if ((q->q_head = m->m_nextpkt) == NULL)
               q->q_tail = NULL;
       m->m_nextpkt = NULL;
       q->q_len--;
       ifq->ifq_len--;
#ifdef FIFOQ_STATS
       PKTCNTR_ADD(&q->q_stats.xmit_cnt, m_pktlen(m));
       if (q->q_len == 0)
               q->q_stats.period++;
#endif
       return m;
}

static int
fifoq_request(struct ifaltq *ifq, int req, void *arg)
{
       fifoq_state_t *q = (fifoq_state_t *)ifq->altq_disc;

       switch (req) {
       case ALTRQ_PURGE:
               fifoq_purge(q);
               break;
       }
       return 0;
}


static int
fifoq_detach(fifoq_state_t *q)
{
       fifoq_state_t *tmp;
       int error = 0;

       if (ALTQ_IS_ENABLED(q->q_ifq))
               altq_disable(q->q_ifq);

       fifoq_purge(q);

       if ((error = altq_detach(q->q_ifq)))
               return error;

       if (fifoq_list == q)
               fifoq_list = q->q_next;
       else {
               for (tmp = fifoq_list; tmp != NULL; tmp = tmp->q_next)
                       if (tmp->q_next == q) {
                               tmp->q_next = q->q_next;
                               break;
                       }
               if (tmp == NULL)
                       printf("fifoq_detach: no state in fifoq_list!\n");
       }

       free(q, M_DEVBUF);
       return error;
}

/*
* fifoq_purge
* should be called in splnet or after disabling the fifoq.
*/
static void
fifoq_purge(fifoq_state_t *q)
{
       struct mbuf *m;

       while ((m = q->q_head) != NULL) {
               q->q_head = m->m_nextpkt;
               m_freem(m);
       }
       q->q_tail = NULL;
       q->q_len = 0;
       if (ALTQ_IS_ENABLED(q->q_ifq))
               q->q_ifq->ifq_len = 0;
}

#ifdef KLD_MODULE

static struct altqsw fifoq_sw =
       {"fifoq", fifoqopen, fifoqclose, fifoqioctl};

ALTQ_MODULE(altq_fifoq, ALTQT_FIFOQ, &fifoq_sw);

#endif /* KLD_MODULE */

#endif /* ALTQ3_COMPAT */
#endif /* ALTQ_FIFOQ */

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.