FreeBSD/Linux Kernel Cross Reference
sys/kern/subr_evcount.c

     /*      $OpenBSD: subr_evcount.c,v 1.15 2022/12/05 08:58:49 visa Exp $ */
     /*
      * Copyright (c) 2004 Artur Grabowski <art@openbsd.org>
      * Copyright (c) 2004 Aaron Campbell <aaron@openbsd.org>
      * 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. The name of the author may not be used to endorse or promote products
     *    derived from this software without specific prior written permission.
     *
     * THIS SOFTWARE IS PROVIDED ``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
     * THE AUTHOR 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/param.h>
    #include <sys/evcount.h>
    #include <sys/systm.h>
    #include <sys/sysctl.h>
    #include <sys/percpu.h>
    
    static TAILQ_HEAD(,evcount) evcount_list = TAILQ_HEAD_INITIALIZER(evcount_list);
    static TAILQ_HEAD(,evcount) evcount_percpu_init_list =
        TAILQ_HEAD_INITIALIZER(evcount_percpu_init_list);
    static int evcount_percpu_done;
    
    void
    evcount_attach(struct evcount *ec, const char *name, void *data)
    {
            static int nextid = 0;
    
            memset(ec, 0, sizeof(*ec));
            ec->ec_name = name;
            ec->ec_id = ++nextid;
            ec->ec_data = data;
            TAILQ_INSERT_TAIL(&evcount_list, ec, next);
    }
    
    void
    evcount_percpu(struct evcount *ec)
    {
            if (evcount_percpu_done == 0) {
                    TAILQ_REMOVE(&evcount_list, ec, next);
                    TAILQ_INSERT_TAIL(&evcount_percpu_init_list, ec, next);
            } else {
                    ec->ec_percpu = counters_alloc(1);
            }
    }
    
    void
    evcount_init_percpu(void)
    {
            struct evcount *ec;
    
            KASSERT(evcount_percpu_done == 0);
            TAILQ_FOREACH(ec, &evcount_percpu_init_list, next) {
                    ec->ec_percpu = counters_alloc(1);
                    counters_add(ec->ec_percpu, 0, ec->ec_count);
                    ec->ec_count = 0;
            }
            TAILQ_CONCAT(&evcount_list, &evcount_percpu_init_list, next);
            evcount_percpu_done = 1;
    }
    
    void
    evcount_detach(struct evcount *ec)
    {
            TAILQ_REMOVE(&evcount_list, ec, next);
            if (ec->ec_percpu != NULL) {
                    counters_free(ec->ec_percpu, 1);
                    ec->ec_percpu = NULL;
            }
    }
    
    void
    evcount_inc(struct evcount *ec)
    {
            if (ec->ec_percpu != NULL)
                    counters_inc(ec->ec_percpu, 0);
            else
                    ec->ec_count++;
    }
    
    #ifndef SMALL_KERNEL
    
    int
    evcount_sysctl(int *name, u_int namelen, void *oldp, size_t *oldlenp,
       void *newp, size_t newlen)
   {
           int error = 0, s, nintr, i;
           struct evcount *ec;
           u_int64_t count;
   
           if (newp != NULL)
                   return (EPERM);
   
           if (name[0] != KERN_INTRCNT_NUM) {
                   if (namelen != 2)
                           return (ENOTDIR);
                   if (name[1] < 0)
                           return (EINVAL);
                   i = name[1];
           } else
                   i = -1;
   
           nintr = 0;
           TAILQ_FOREACH(ec, &evcount_list, next) {
                   if (nintr++ == i)
                           break;
           }
   
           switch (name[0]) {
           case KERN_INTRCNT_NUM:
                   error = sysctl_rdint(oldp, oldlenp, NULL, nintr);
                   break;
           case KERN_INTRCNT_CNT:
                   if (ec == NULL)
                           return (ENOENT);
                   if (ec->ec_percpu != NULL) {
                           counters_read(ec->ec_percpu, &count, 1);
                   } else {
                           s = splhigh();
                           count = ec->ec_count;
                           splx(s);
                   }
                   error = sysctl_rdquad(oldp, oldlenp, NULL, count);
                   break;
           case KERN_INTRCNT_NAME:
                   if (ec == NULL)
                           return (ENOENT);
                   error = sysctl_rdstring(oldp, oldlenp, NULL, ec->ec_name);
                   break;
           case KERN_INTRCNT_VECTOR:
                   if (ec == NULL || ec->ec_data == NULL)
                           return (ENOENT);
                   error = sysctl_rdint(oldp, oldlenp, NULL,
                       *((int *)ec->ec_data));
                   break;
           default:
                   error = EOPNOTSUPP;
                   break;
           }
   
           return (error);
   }
   #endif  /* SMALL_KERNEL */

Cache object: 670c12a4ae5e4193671e0a138ae0961d