/*      $OpenBSD: subr_evcount.c,v 1.16 2023/09/16 09:33:27 mpi 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;
        uint64_t count, scratch;

        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, &scratch);
                } 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 */