root/altq/altq_subr.c

DEFINITIONS

1. altq_lookup
2. altq_attach
3. altq_detach
4. altq_enable
5. altq_disable
6. altq_assert
7. tbr_dequeue
8. tbr_set
9. tbr_timeout
10. tbr_get
11. altq_pfattach
12. altq_pfdetach
13. altq_add
14. altq_remove
15. altq_add_queue
16. altq_remove_queue
17. altq_getqstats
18. read_dsfield
19. write_dsfield
20. init_machclk
21. rdtsc
22. read_machclk

    1 /*      $OpenBSD: altq_subr.c,v 1.21 2006/12/20 17:50:40 gwk Exp $      */
    2 /*      $KAME: altq_subr.c,v 1.11 2002/01/11 08:11:49 kjc Exp $ */
    4 /*
    5  * Copyright (C) 1997-2002
    6  *      Sony Computer Science Laboratories Inc.  All rights reserved.
    7  *
    8  * Redistribution and use in source and binary forms, with or without
    9  * modification, are permitted provided that the following conditions
   10  * are met:
   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 the
   15  *    documentation and/or other materials provided with the distribution.
   16  *
   17  * THIS SOFTWARE IS PROVIDED BY SONY CSL 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 DISCLAIMED.  IN NO EVENT SHALL SONY CSL 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  */
   30 #include <sys/param.h>
   31 #include <sys/malloc.h>
   32 #include <sys/mbuf.h>
   33 #include <sys/systm.h>
   34 #include <sys/proc.h>
   35 #include <sys/socket.h>
   36 #include <sys/socketvar.h>
   37 #include <sys/kernel.h>
   38 #include <sys/errno.h>
   39 #include <sys/syslog.h>
   40 #include <sys/sysctl.h>
   41 #include <sys/queue.h>
   43 #include <net/if.h>
   44 #include <net/if_dl.h>
   45 #include <net/if_types.h>
   47 #include <netinet/in.h>
   48 #include <netinet/in_systm.h>
   49 #include <netinet/ip.h>
   50 #ifdef INET6
   51 #include <netinet/ip6.h>
   52 #endif
   53 #include <netinet/tcp.h>
   54 #include <netinet/udp.h>
   56 #include <net/pfvar.h>
   57 #include <altq/altq.h>
   59 /* machine dependent clock related includes */
   60 #if defined(__i386__)
   61 #include <machine/cpufunc.h>            /* for pentium tsc */
   62 #include <machine/specialreg.h>         /* for CPUID_TSC */
   63 #endif /* __i386__ */
   65 /*
   66  * internal function prototypes
   67  */
   68 static void     tbr_timeout(void *);
   69 int (*altq_input)(struct mbuf *, int) = NULL;
   70 static int tbr_timer = 0;       /* token bucket regulator timer */
   71 static struct callout tbr_callout = CALLOUT_INITIALIZER;
   73 /*
   74  * alternate queueing support routines
   75  */
   77 /* look up the queue state by the interface name and the queueing type. */
   78 void *
altq_lookup(name, type)
   80         char *name;
   81         int type;
   82 {
   83         struct ifnet *ifp;
   85         if ((ifp = ifunit(name)) != NULL) {
   86                 if (type != ALTQT_NONE && ifp->if_snd.altq_type == type)
   87                         return (ifp->if_snd.altq_disc);
   88         }
   90         return NULL;
   91 }
   93 int
altq_attach(ifq, type, discipline, enqueue, dequeue, request, clfier, classify)
   95         struct ifaltq *ifq;
   96         int type;
   97         void *discipline;
   98         int (*enqueue)(struct ifaltq *, struct mbuf *, struct altq_pktattr *);
   99         struct mbuf *(*dequeue)(struct ifaltq *, int);
  100         int (*request)(struct ifaltq *, int, void *);
  101         void *clfier;
  102         void *(*classify)(void *, struct mbuf *, int);
  103 {
  104         if (!ALTQ_IS_READY(ifq))
  105                 return ENXIO;
  107 #if 0   /* pfaltq can override the existing discipline */
  108         if (ALTQ_IS_ENABLED(ifq))
  109                 return EBUSY;
  110         if (ALTQ_IS_ATTACHED(ifq))
  111                 return EEXIST;
  112 #endif
ifq->altq_type     = type;
ifq->altq_disc     = discipline;
ifq->altq_enqueue  = enqueue;
ifq->altq_dequeue  = dequeue;
ifq->altq_request  = request;
ifq->altq_clfier   = clfier;
ifq->altq_classify = classify;
ifq->altq_flags &= (ALTQF_CANTCHANGE|ALTQF_ENABLED);
  122         return 0;
  123 }
  125 int
altq_detach(ifq)
  127         struct ifaltq *ifq;
  128 {
  129         if (!ALTQ_IS_READY(ifq))
  130                 return ENXIO;
  131         if (ALTQ_IS_ENABLED(ifq))
  132                 return EBUSY;
  133         if (!ALTQ_IS_ATTACHED(ifq))
  134                 return (0);
ifq->altq_type     = ALTQT_NONE;
ifq->altq_disc     = NULL;
ifq->altq_enqueue  = NULL;
ifq->altq_dequeue  = NULL;
ifq->altq_request  = NULL;
ifq->altq_clfier   = NULL;
ifq->altq_classify = NULL;
ifq->altq_flags &= ALTQF_CANTCHANGE;
  144         return 0;
  145 }
  147 int
altq_enable(ifq)
  149         struct ifaltq *ifq;
  150 {
  151         int s;
  153         if (!ALTQ_IS_READY(ifq))
  154                 return ENXIO;
  155         if (ALTQ_IS_ENABLED(ifq))
  156                 return 0;
s = splnet();
IFQ_PURGE(ifq);
ASSERT(ifq->ifq_len == 0);
ifq->altq_flags |= ALTQF_ENABLED;
  162         if (ifq->altq_clfier != NULL)
ifq->altq_flags |= ALTQF_CLASSIFY;
splx(s);
  166         return 0;
  167 }
  169 int
altq_disable(ifq)
  171         struct ifaltq *ifq;
  172 {
  173         int s;
  175         if (!ALTQ_IS_ENABLED(ifq))
  176                 return 0;
s = splnet();
IFQ_PURGE(ifq);
ASSERT(ifq->ifq_len == 0);
ifq->altq_flags &= ~(ALTQF_ENABLED|ALTQF_CLASSIFY);
splx(s);
  183         return 0;
  184 }
  186 void
altq_assert(file, line, failedexpr)
  188         const char *file, *failedexpr;
  189         int line;
  190 {
  191         (void)printf("altq assertion \"%s\" failed: file \"%s\", line %d\n",
failedexpr, file, line);
panic("altq assertion");
  194         /* NOTREACHED */
  195 }
  197 /*
  198  * internal representation of token bucket parameters
  199  *      rate:   byte_per_unittime << 32
  200  *              (((bits_per_sec) / 8) << 32) / machclk_freq
  201  *      depth:  byte << 32
  202  *
  203  */
  204 #define TBR_SHIFT       32
  205 #define TBR_SCALE(x)    ((int64_t)(x) << TBR_SHIFT)
  206 #define TBR_UNSCALE(x)  ((x) >> TBR_SHIFT)
  208 struct mbuf *
tbr_dequeue(ifq, op)
  210         struct ifaltq *ifq;
  211         int op;
  212 {
  213         struct tb_regulator *tbr;
  214         struct mbuf *m;
int64_t interval;
u_int64_t now;
tbr = ifq->altq_tbr;
  219         if (op == ALTDQ_REMOVE && tbr->tbr_lastop == ALTDQ_POLL) {
  220                 /* if this is a remove after poll, bypass tbr check */
  221         } else {
  222                 /* update token only when it is negative */
  223                 if (tbr->tbr_token <= 0) {
now = read_machclk();
interval = now - tbr->tbr_last;
  226                         if (interval >= tbr->tbr_filluptime)
tbr->tbr_token = tbr->tbr_depth;
  228                         else {
tbr->tbr_token += interval * tbr->tbr_rate;
  230                                 if (tbr->tbr_token > tbr->tbr_depth)
tbr->tbr_token = tbr->tbr_depth;
  232                         }
tbr->tbr_last = now;
  234                 }
  235                 /* if token is still negative, don't allow dequeue */
  236                 if (tbr->tbr_token <= 0)
  237                         return (NULL);
  238         }
  240         if (ALTQ_IS_ENABLED(ifq))
m = (*ifq->altq_dequeue)(ifq, op);
  242         else {
  243                 if (op == ALTDQ_POLL)
IF_POLL(ifq, m);
  245                 else
IF_DEQUEUE(ifq, m);
  247         }
  249         if (m != NULL && op == ALTDQ_REMOVE)
tbr->tbr_token -= TBR_SCALE(m_pktlen(m));
tbr->tbr_lastop = op;
  252         return (m);
  253 }
  255 /*
  256  * set a token bucket regulator.
  257  * if the specified rate is zero, the token bucket regulator is deleted.
  258  */
  259 int
tbr_set(ifq, profile)
  261         struct ifaltq *ifq;
  262         struct tb_profile *profile;
  263 {
  264         struct tb_regulator *tbr, *otbr;
  266         if (machclk_freq == 0)
init_machclk();
  268         if (machclk_freq == 0) {
printf("tbr_set: no cpu clock available!\n");
  270                 return (ENXIO);
  271         }
  273         if (profile->rate == 0) {
  274                 /* delete this tbr */
  275                 if ((tbr = ifq->altq_tbr) == NULL)
  276                         return (ENOENT);
ifq->altq_tbr = NULL;
FREE(tbr, M_DEVBUF);
  279                 return (0);
  280         }
MALLOC(tbr, struct tb_regulator *, sizeof(struct tb_regulator),
M_DEVBUF, M_WAITOK);
  284         if (tbr == NULL)
  285                 return (ENOMEM);
bzero(tbr, sizeof(struct tb_regulator));
tbr->tbr_rate = TBR_SCALE(profile->rate / 8) / machclk_freq;
tbr->tbr_depth = TBR_SCALE(profile->depth);
  290         if (tbr->tbr_rate > 0)
tbr->tbr_filluptime = tbr->tbr_depth / tbr->tbr_rate;
  292         else
tbr->tbr_filluptime = 0xffffffffffffffffLL;
tbr->tbr_token = tbr->tbr_depth;
tbr->tbr_last = read_machclk();
tbr->tbr_lastop = ALTDQ_REMOVE;
otbr = ifq->altq_tbr;
ifq->altq_tbr = tbr;    /* set the new tbr */
  301         if (otbr != NULL)
FREE(otbr, M_DEVBUF);
  303         else {
  304                 if (tbr_timer == 0) {
CALLOUT_RESET(&tbr_callout, 1, tbr_timeout, (void *)0);
tbr_timer = 1;
  307                 }
  308         }
  309         return (0);
  310 }
  312 /*
  313  * tbr_timeout goes through the interface list, and kicks the drivers
  314  * if necessary.
  315  */
  316 static void
tbr_timeout(arg)
  318         void *arg;
  319 {
  320         struct ifnet *ifp;
  321         int active, s;
active = 0;
s = splnet();
  325         for (ifp = TAILQ_FIRST(&ifnet); ifp; ifp = TAILQ_NEXT(ifp, if_list)) {
  326                 if (!TBR_IS_ENABLED(&ifp->if_snd))
  327                         continue;
active++;
  329                 if (!IFQ_IS_EMPTY(&ifp->if_snd) && ifp->if_start != NULL)
  330                         (*ifp->if_start)(ifp);
  331         }
splx(s);
  333         if (active > 0)
CALLOUT_RESET(&tbr_callout, 1, tbr_timeout, (void *)0);
  335         else
tbr_timer = 0;  /* don't need tbr_timer anymore */
  337 #if defined(__alpha__) && !defined(ALTQ_NOPCC)
  338         {
  339                 /*
  340                  * XXX read out the machine dependent clock once a second
  341                  * to detect counter wrap-around.
  342                  */
  343                 static u_int cnt;
  345                 if (++cnt >= hz) {
  346                         (void)read_machclk();
cnt = 0;
  348                 }
  349         }
  350 #endif /* __alpha__ && !ALTQ_NOPCC */
  351 }
  353 /*
  354  * get token bucket regulator profile
  355  */
  356 int
tbr_get(ifq, profile)
  358         struct ifaltq *ifq;
  359         struct tb_profile *profile;
  360 {
  361         struct tb_regulator *tbr;
  363         if ((tbr = ifq->altq_tbr) == NULL) {
profile->rate = 0;
profile->depth = 0;
  366         } else {
profile->rate =
  368                     (u_int)TBR_UNSCALE(tbr->tbr_rate * 8 * machclk_freq);
profile->depth = (u_int)TBR_UNSCALE(tbr->tbr_depth);
  370         }
  371         return (0);
  372 }
  374 /*
  375  * attach a discipline to the interface.  if one already exists, it is
  376  * overridden.
  377  */
  378 int
altq_pfattach(struct pf_altq *a)
  380 {
  381         int error = 0;
  383         switch (a->scheduler) {
  384         case ALTQT_NONE:
  385                 break;
  386 #ifdef ALTQ_CBQ
  387         case ALTQT_CBQ:
error = cbq_pfattach(a);
  389                 break;
  390 #endif
  391 #ifdef ALTQ_PRIQ
  392         case ALTQT_PRIQ:
error = priq_pfattach(a);
  394                 break;
  395 #endif
  396 #ifdef ALTQ_HFSC
  397         case ALTQT_HFSC:
error = hfsc_pfattach(a);
  399                 break;
  400 #endif
  401         default:
error = ENXIO;
  403         }
  405         return (error);
  406 }
  408 /*
  409  * detach a discipline from the interface.
  410  * it is possible that the discipline was already overridden by another
  411  * discipline.
  412  */
  413 int
altq_pfdetach(struct pf_altq *a)
  415 {
  416         struct ifnet *ifp;
  417         int s, error = 0;
  419         if ((ifp = ifunit(a->ifname)) == NULL)
  420                 return (EINVAL);
  422         /* if this discipline is no longer referenced, just return */
  423         if (a->altq_disc == NULL || a->altq_disc != ifp->if_snd.altq_disc)
  424                 return (0);
s = splnet();
  427         if (ALTQ_IS_ENABLED(&ifp->if_snd))
error = altq_disable(&ifp->if_snd);
  429         if (error == 0)
error = altq_detach(&ifp->if_snd);
splx(s);
  433         return (error);
  434 }
  436 /*
  437  * add a discipline or a queue
  438  */
  439 int
altq_add(struct pf_altq *a)
  441 {
  442         int error = 0;
  444         if (a->qname[0] != 0)
  445                 return (altq_add_queue(a));
  447         if (machclk_freq == 0)
init_machclk();
  449         if (machclk_freq == 0)
panic("altq_add: no cpu clock");
  452         switch (a->scheduler) {
  453 #ifdef ALTQ_CBQ
  454         case ALTQT_CBQ:
error = cbq_add_altq(a);
  456                 break;
  457 #endif
  458 #ifdef ALTQ_PRIQ
  459         case ALTQT_PRIQ:
error = priq_add_altq(a);
  461                 break;
  462 #endif
  463 #ifdef ALTQ_HFSC
  464         case ALTQT_HFSC:
error = hfsc_add_altq(a);
  466                 break;
  467 #endif
  468         default:
error = ENXIO;
  470         }
  472         return (error);
  473 }
  475 /*
  476  * remove a discipline or a queue
  477  */
  478 int
altq_remove(struct pf_altq *a)
  480 {
  481         int error = 0;
  483         if (a->qname[0] != 0)
  484                 return (altq_remove_queue(a));
  486         switch (a->scheduler) {
  487 #ifdef ALTQ_CBQ
  488         case ALTQT_CBQ:
error = cbq_remove_altq(a);
  490                 break;
  491 #endif
  492 #ifdef ALTQ_PRIQ
  493         case ALTQT_PRIQ:
error = priq_remove_altq(a);
  495                 break;
  496 #endif
  497 #ifdef ALTQ_HFSC
  498         case ALTQT_HFSC:
error = hfsc_remove_altq(a);
  500                 break;
  501 #endif
  502         default:
error = ENXIO;
  504         }
  506         return (error);
  507 }
  509 /*
  510  * add a queue to the discipline
  511  */
  512 int
altq_add_queue(struct pf_altq *a)
  514 {
  515         int error = 0;
  517         switch (a->scheduler) {
  518 #ifdef ALTQ_CBQ
  519         case ALTQT_CBQ:
error = cbq_add_queue(a);
  521                 break;
  522 #endif
  523 #ifdef ALTQ_PRIQ
  524         case ALTQT_PRIQ:
error = priq_add_queue(a);
  526                 break;
  527 #endif
  528 #ifdef ALTQ_HFSC
  529         case ALTQT_HFSC:
error = hfsc_add_queue(a);
  531                 break;
  532 #endif
  533         default:
error = ENXIO;
  535         }
  537         return (error);
  538 }
  540 /*
  541  * remove a queue from the discipline
  542  */
  543 int
altq_remove_queue(struct pf_altq *a)
  545 {
  546         int error = 0;
  548         switch (a->scheduler) {
  549 #ifdef ALTQ_CBQ
  550         case ALTQT_CBQ:
error = cbq_remove_queue(a);
  552                 break;
  553 #endif
  554 #ifdef ALTQ_PRIQ
  555         case ALTQT_PRIQ:
error = priq_remove_queue(a);
  557                 break;
  558 #endif
  559 #ifdef ALTQ_HFSC
  560         case ALTQT_HFSC:
error = hfsc_remove_queue(a);
  562                 break;
  563 #endif
  564         default:
error = ENXIO;
  566         }
  568         return (error);
  569 }
  571 /*
  572  * get queue statistics
  573  */
  574 int
altq_getqstats(struct pf_altq *a, void *ubuf, int *nbytes)
  576 {
  577         int error = 0;
  579         switch (a->scheduler) {
  580 #ifdef ALTQ_CBQ
  581         case ALTQT_CBQ:
error = cbq_getqstats(a, ubuf, nbytes);
  583                 break;
  584 #endif
  585 #ifdef ALTQ_PRIQ
  586         case ALTQT_PRIQ:
error = priq_getqstats(a, ubuf, nbytes);
  588                 break;
  589 #endif
  590 #ifdef ALTQ_HFSC
  591         case ALTQT_HFSC:
error = hfsc_getqstats(a, ubuf, nbytes);
  593                 break;
  594 #endif
  595         default:
error = ENXIO;
  597         }
  599         return (error);
  600 }
  602 /*
  603  * read and write diffserv field in IPv4 or IPv6 header
  604  */
u_int8_t
read_dsfield(m, pktattr)
  607         struct mbuf *m;
  608         struct altq_pktattr *pktattr;
  609 {
  610         struct mbuf *m0;
u_int8_t ds_field = 0;
  613         if (pktattr == NULL ||
  614             (pktattr->pattr_af != AF_INET && pktattr->pattr_af != AF_INET6))
  615                 return ((u_int8_t)0);
  617         /* verify that pattr_hdr is within the mbuf data */
  618         for (m0 = m; m0 != NULL; m0 = m0->m_next)
  619                 if ((pktattr->pattr_hdr >= m0->m_data) &&
  620                     (pktattr->pattr_hdr < m0->m_data + m0->m_len))
  621                         break;
  622         if (m0 == NULL) {
  623                 /* ick, pattr_hdr is stale */
pktattr->pattr_af = AF_UNSPEC;
  625 #ifdef ALTQ_DEBUG
printf("read_dsfield: can't locate header!\n");
  627 #endif
  628                 return ((u_int8_t)0);
  629         }
  631         if (pktattr->pattr_af == AF_INET) {
  632                 struct ip *ip = (struct ip *)pktattr->pattr_hdr;
  634                 if (ip->ip_v != 4)
  635                         return ((u_int8_t)0);   /* version mismatch! */
ds_field = ip->ip_tos;
  637         }
  638 #ifdef INET6
  639         else if (pktattr->pattr_af == AF_INET6) {
  640                 struct ip6_hdr *ip6 = (struct ip6_hdr *)pktattr->pattr_hdr;
u_int32_t flowlabel;
flowlabel = ntohl(ip6->ip6_flow);
  644                 if ((flowlabel >> 28) != 6)
  645                         return ((u_int8_t)0);   /* version mismatch! */
ds_field = (flowlabel >> 20) & 0xff;
  647         }
  648 #endif
  649         return (ds_field);
  650 }
  652 void
write_dsfield(m, pktattr, dsfield)
  654         struct mbuf *m;
  655         struct altq_pktattr *pktattr;
u_int8_t dsfield;
  657 {
  658         struct mbuf *m0;
  660         if (pktattr == NULL ||
  661             (pktattr->pattr_af != AF_INET && pktattr->pattr_af != AF_INET6))
  662                 return;
  664         /* verify that pattr_hdr is within the mbuf data */
  665         for (m0 = m; m0 != NULL; m0 = m0->m_next)
  666                 if ((pktattr->pattr_hdr >= m0->m_data) &&
  667                     (pktattr->pattr_hdr < m0->m_data + m0->m_len))
  668                         break;
  669         if (m0 == NULL) {
  670                 /* ick, pattr_hdr is stale */
pktattr->pattr_af = AF_UNSPEC;
  672 #ifdef ALTQ_DEBUG
printf("write_dsfield: can't locate header!\n");
  674 #endif
  675                 return;
  676         }
  678         if (pktattr->pattr_af == AF_INET) {
  679                 struct ip *ip = (struct ip *)pktattr->pattr_hdr;
u_int8_t old;
int32_t sum;
  683                 if (ip->ip_v != 4)
  684                         return;         /* version mismatch! */
old = ip->ip_tos;
dsfield |= old & 3;     /* leave CU bits */
  687                 if (old == dsfield)
  688                         return;
ip->ip_tos = dsfield;
  690                 /*
  691                  * update checksum (from RFC1624)
  692                  *         HC' = ~(~HC + ~m + m')
  693                  */
sum = ~ntohs(ip->ip_sum) & 0xffff;
sum += 0xff00 + (~old & 0xff) + dsfield;
sum = (sum >> 16) + (sum & 0xffff);
sum += (sum >> 16);  /* add carry */
ip->ip_sum = htons(~sum & 0xffff);
  700         }
  701 #ifdef INET6
  702         else if (pktattr->pattr_af == AF_INET6) {
  703                 struct ip6_hdr *ip6 = (struct ip6_hdr *)pktattr->pattr_hdr;
u_int32_t flowlabel;
flowlabel = ntohl(ip6->ip6_flow);
  707                 if ((flowlabel >> 28) != 6)
  708                         return;         /* version mismatch! */
flowlabel = (flowlabel & 0xf03fffff) | (dsfield << 20);
ip6->ip6_flow = htonl(flowlabel);
  711         }
  712 #endif
  713         return;
  714 }
  717 /*
  718  * high resolution clock support taking advantage of a machine dependent
  719  * high resolution time counter (e.g., timestamp counter of intel pentium).
  720  * we assume
  721  *  - 64-bit-long monotonically-increasing counter
  722  *  - frequency range is 100M-4GHz (CPU speed)
  723  */
  724 /* if pcc is not available or disabled, emulate 256MHz using microtime() */
  725 #define MACHCLK_SHIFT   8
  727 int machclk_usepcc;
u_int32_t machclk_freq = 0;
u_int32_t machclk_per_tick = 0;
  731 #ifdef __alpha__
  732 extern u_int64_t cycles_per_usec;       /* alpha cpu clock frequency */
  733 #endif /* __alpha__ */
  735 void
init_machclk(void)
  737 {
machclk_usepcc = 1;
  740 #if (!defined(__i386__) && !defined(__alpha__)) || defined(ALTQ_NOPCC)
machclk_usepcc = 0;
  742 #endif
  743 #if defined(__FreeBSD__) && defined(SMP)
machclk_usepcc = 0;
  745 #endif
  746 #if defined(__NetBSD__) && defined(MULTIPROCESSOR)
machclk_usepcc = 0;
  748 #endif
  749 #if defined(__OpenBSD__) && defined(__HAVE_TIMECOUNTER)
  750         /*
  751          * If we have timecounters, microtime is good enough and we can
  752          * avoid problems on machines with variable cycle counter
  753          * frequencies.
  754          */
machclk_usepcc = 0;
  756 #endif
  757 #ifdef __i386__
  758         /* check if TSC is available */
  759         if (machclk_usepcc == 1 && (cpu_feature & CPUID_TSC) == 0)
machclk_usepcc = 0;
  761 #endif
  763         if (machclk_usepcc == 0) {
  764                 /* emulate 256MHz using microtime() */
machclk_freq = 1000000 << MACHCLK_SHIFT;
machclk_per_tick = machclk_freq / hz;
  767 #ifdef ALTQ_DEBUG
printf("altq: emulate %uHz cpu clock\n", machclk_freq);
  769 #endif
  770                 return;
  771         }
  773         /*
  774          * if the clock frequency (of Pentium TSC or Alpha PCC) is
  775          * accessible, just use it.
  776          */
  777 #if defined(__i386__) && (defined(I586_CPU) || defined(I686_CPU))
  778         /* XXX - this will break down with variable cpu frequency. */
machclk_freq = cpuspeed * 1000000;
  780 #endif
  781 #if defined(__alpha__)
machclk_freq = (u_int32_t)(cycles_per_usec * 1000000);
  783 #endif /* __alpha__ */
  785         /*
  786          * if we don't know the clock frequency, measure it.
  787          */
  788         if (machclk_freq == 0) {
  789                 static int      wait;
  790                 struct timeval  tv_start, tv_end;
u_int64_t       start, end, diff;
  792                 int             timo;
microtime(&tv_start);
start = read_machclk();
timo = hz;      /* 1 sec */
  797                 (void)tsleep(&wait, PWAIT | PCATCH, "init_machclk", timo);
microtime(&tv_end);
end = read_machclk();
diff = (u_int64_t)(tv_end.tv_sec - tv_start.tv_sec) * 1000000
  801                     + tv_end.tv_usec - tv_start.tv_usec;
  802                 if (diff != 0)
machclk_freq = (u_int)((end - start) * 1000000 / diff);
  804         }
machclk_per_tick = machclk_freq / hz;
  808 #ifdef ALTQ_DEBUG
printf("altq: CPU clock: %uHz\n", machclk_freq);
  810 #endif
  811 }
  813 #if defined(__OpenBSD__) && defined(__i386__)
  814 static __inline u_int64_t
rdtsc(void)
  816 {
u_int64_t rv;
  818         __asm __volatile(".byte 0x0f, 0x31" : "=A" (rv));
  819         return (rv);
  820 }
  821 #endif /* __OpenBSD__ && __i386__ */
u_int64_t
read_machclk(void)
  825 {
u_int64_t val;
  828         if (machclk_usepcc) {
  829 #if defined(__i386__)
val = rdtsc();
  831 #elif defined(__alpha__)
  832                 static u_int32_t last_pcc, upper;
u_int32_t pcc;
  835                 /*
  836                  * for alpha, make a 64bit counter value out of the 32bit
  837                  * alpha processor cycle counter.
  838                  * read_machclk must be called within a half of its
  839                  * wrap-around cycle (about 5 sec for 400MHz cpu) to properly
  840                  * detect a counter wrap-around.
  841                  * tbr_timeout calls read_machclk once a second.
  842                  */
pcc = (u_int32_t)alpha_rpcc();
  844                 if (pcc <= last_pcc)
upper++;
last_pcc = pcc;
val = ((u_int64_t)upper << 32) + pcc;
  848 #else
panic("read_machclk");
  850 #endif
  851         } else {
  852                 struct timeval tv;
microuptime(&tv);
val = (((u_int64_t)(tv.tv_sec) * 1000000
  856                     + tv.tv_usec) << MACHCLK_SHIFT);
  857         }
  858         return (val);
  859 }