/*-
 * Copyright (c) 2026 Capabilities Limited
 *
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * This software was developed by Capabilities Limited with funding from
 * Innovate UK and the Department for Science, Innovation and Technology
 * for the adoption and diffusion of CHERI technology under project
 * 10168042 (“CheriBSD feature extraction, maturity, and testing”).
 *
 */

#define EXTERR_CATEGORY_DYNAMIC "kern/subr_exterr.c"

#include <sys/param.h>
#include <sys/exterrvar.h>
#include <sys/exterr_cat.h>
#include <sys/kernel.h>
#include <sys/libkern.h>
#include <sys/linker_set.h>
#include <sys/malloc.h>
#include <sys/linker.h> /* Need MALLOC_DECLARE */
#include <sys/rwlock.h>
#include <sys/stddef.h>
#include <sys/sysctl.h>

struct exterr_cat_span {
        unsigned int                    first;
        unsigned int                    count;
        struct exterr_cat               **cat_sets;
        TAILQ_ENTRY(exterr_cat_span)    entries;
};

TAILQ_HEAD(exterr_cat_span_head, exterr_cat_span) cat_span_head;

SET_DECLARE(exterr_cats, struct exterr_cat);

static struct exterr_cat_span kern_cats;
unsigned int ncats;
struct rwlock cat_lock;

static bool
exterr_cat_register_set(struct exterr_cat_span *span, struct exterr_cat **start,
    struct exterr_cat **stop)
{
        struct exterr_cat **catp;
        ptrdiff_t count;

        count = stop - start;
        if (count < 1)
                return (true);

        rw_wlock(&cat_lock);

        if (ncats + count < ncats) {
                printf("too many exterror categories\n");
                rw_wunlock(&cat_lock);
                return (false);
        }

        span->first = ncats + 1;
        for (catp = start; catp < stop; catp++)
                (*catp)->cat = ++ncats;
        span->count = count;
        span->cat_sets = start;
        TAILQ_INSERT_TAIL(&cat_span_head, span, entries);

        rw_wunlock(&cat_lock);

        return (true);
}

void
exterr_cat_register_module(struct exterr_cat **start, struct exterr_cat **stop)
{
        struct exterr_cat_span *span;

        span = malloc(sizeof(*span), M_LINKER, M_WAITOK | M_ZERO);
        if (!exterr_cat_register_set(span, start, stop))
                free(span, M_LINKER);
}

void
exterr_cat_unregister_module(struct exterr_cat **start,
    struct exterr_cat **stop)
{
        struct exterr_cat_span *span;

        if (stop - start < 1)
                return;

        rw_wlock(&cat_lock);

        TAILQ_FOREACH(span, &cat_span_head, entries) {
                if (span->cat_sets == start) {
                        MPASS(span->first > 1);
                        MPASS(span->count == stop - start);
                        TAILQ_REMOVE(&cat_span_head, span, entries);
                        break;
                }
        }
        KASSERT(span != NULL, ("start not found in spans"));

        /*
         * NB: we leak category numbers on module unload because we can't
         * reasonably know which ones are in use in running software.
         */

        rw_wunlock(&cat_lock);

        free(span, M_LINKER);
}

static void
exterr_cat_register_kern(void *arg)
{
        rw_init(&cat_lock, "exterr dynamic categories");

        TAILQ_INIT(&cat_span_head);

        if (SET_COUNT(exterr_cats) == 0)
                return;

        exterr_cat_register_set(&kern_cats, SET_BEGIN(exterr_cats),
            SET_LIMIT(exterr_cats));
}
SYSINIT(exterr, SI_SUB_KMEM, SI_ORDER_FIRST, exterr_cat_register_kern, NULL);

static int
sysctl_exterr_categories(SYSCTL_HANDLER_ARGS)
{
        struct exterr_cat_span *span;
        const struct exterr_cat *cat = NULL;
        int idx;

        if (arg2 != 1)
                return (EXTERROR(EINVAL,
                    "too many args to kern.exterr.categories %d", arg2));

        idx = *(int *)arg1;

        rw_rlock(&cat_lock);
        if (idx < 1 || idx > ncats) {
                rw_runlock(&cat_lock);
                return (EXTERROR(EINVAL, "category %d out of range (1...%d)",
                    idx, ncats));
        }

        TAILQ_FOREACH(span, &cat_span_head, entries) {
                if (idx < span->first)
                        break;  /* Not here any more */

                if (idx < span->first + span->count)
                        cat = span->cat_sets[idx - span->first];
        }
        rw_runlock(&cat_lock);

        if (cat == NULL)
                return (EXTERROR(ENOENT, "category not found %d", idx));
        MPASS(cat->cat == idx);
        return (SYSCTL_OUT(req, cat->file, strlen(cat->file) + 1));
}

SYSCTL_NODE(_kern, OID_AUTO, exterr, CTLFLAG_RD | CTLFLAG_MPSAFE, 0,
    "Extended error information");
SYSCTL_UINT(_kern_exterr, OID_AUTO, ncategories, CTLFLAG_RD | CTLFLAG_MPSAFE,
    &ncats, 0, "Number of dynamic categories");
SYSCTL_NODE(_kern_exterr, OID_AUTO, categories, CTLFLAG_RD | CTLFLAG_MPSAFE,
    sysctl_exterr_categories, "Extended error categories");