/*      $NetBSD: kern_hook.c,v 1.18 2026/05/26 15:11:44 simonb Exp $    */

/*-
 * Copyright (c) 1997, 1998, 1999, 2002, 2007, 2008 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Jason R. Thorpe of the Numerical Aerospace Simulation Facility,
 * NASA Ames Research Center, and by Luke Mewburn.
 *
 * 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 THE NETBSD FOUNDATION, INC. 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 THE FOUNDATION 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: kern_hook.c,v 1.18 2026/05/26 15:11:44 simonb Exp $");

#include <sys/param.h>

#include <sys/condvar.h>
#include <sys/cpu.h>
#include <sys/device.h>
#include <sys/exec.h>
#include <sys/hook.h>
#include <sys/kernel.h>
#include <sys/kmem.h>
#include <sys/malloc.h>
#include <sys/once.h>
#include <sys/rwlock.h>
#include <sys/systm.h>
#include <sys/sdt.h>

/*
 * A generic linear hook.
 */
struct hook_desc {
        LIST_ENTRY(hook_desc) hk_list;
        void    (*hk_fn)(void *);
        void    *hk_arg;
};
typedef LIST_HEAD(, hook_desc) hook_list_t;

enum hook_list_st {
        HKLIST_IDLE,
        HKLIST_INUSE,
};

struct khook_list {
        hook_list_t      hl_list;
        kmutex_t         hl_lock;
        kmutex_t        *hl_cvlock;
        struct lwp      *hl_lwp;
        kcondvar_t       hl_cv;
        enum hook_list_st
                         hl_state;
        khook_t         *hl_active_hk;
        char             hl_namebuf[HOOKNAMSIZ];
};

int     powerhook_debug = 0;

static ONCE_DECL(hook_control);
static krwlock_t exithook_lock;
static krwlock_t forkhook_lock;

static int
hook_init(void)
{

        rw_init(&exithook_lock);
        rw_init(&forkhook_lock);

        return 0;
}

static void *
hook_establish(hook_list_t *list, krwlock_t *lock,
    void (*fn)(void *), void *arg)
{
        struct hook_desc *hd;

        RUN_ONCE(&hook_control, hook_init);

        hd = malloc(sizeof(*hd), M_DEVBUF, M_NOWAIT);
        if (hd != NULL) {
                if (lock)
                        rw_enter(lock, RW_WRITER);
                hd->hk_fn = fn;
                hd->hk_arg = arg;
                LIST_INSERT_HEAD(list, hd, hk_list);
                if (lock)
                        rw_exit(lock);
        }

        return (hd);
}

static void
hook_disestablish(hook_list_t *list, krwlock_t *lock, void *vhook)
{

        if (lock)
                rw_enter(lock, RW_WRITER);
#ifdef DIAGNOSTIC
        struct hook_desc *hd;

        LIST_FOREACH(hd, list, hk_list) {
                if (hd == vhook)
                        break;
        }

        if (hd == NULL)
                panic("hook_disestablish: hook %p not established", vhook);
#endif
        LIST_REMOVE((struct hook_desc *)vhook, hk_list);
        free(vhook, M_DEVBUF);
        if (lock)
                rw_exit(lock);
}

static void
hook_destroy(hook_list_t *list)
{
        struct hook_desc *hd;

        while ((hd = LIST_FIRST(list)) != NULL) {
                LIST_REMOVE(hd, hk_list);
                free(hd, M_DEVBUF);
        }
}

static void
hook_proc_run(hook_list_t *list, krwlock_t *lock, struct proc *p)
{
        struct hook_desc *hd;

        RUN_ONCE(&hook_control, hook_init);

        if (lock)
                rw_enter(lock, RW_READER);
        LIST_FOREACH(hd, list, hk_list) {
                __FPTRCAST(void (*)(struct proc *, void *), *hd->hk_fn)(p,
                    hd->hk_arg);
        }
        if (lock)
                rw_exit(lock);
}

/*
 * "Shutdown hook" types, functions, and variables.
 *
 * Should be invoked immediately before the
 * system is halted or rebooted, i.e. after file systems unmounted,
 * after crash dump done, etc.
 *
 * Each shutdown hook is removed from the list before it's run, so that
 * it won't be run again.
 */

static hook_list_t shutdownhook_list = LIST_HEAD_INITIALIZER(shutdownhook_list);

void *
shutdownhook_establish(void (*fn)(void *), void *arg)
{
        return hook_establish(&shutdownhook_list, NULL, fn, arg);
}

void
shutdownhook_disestablish(void *vhook)
{
        hook_disestablish(&shutdownhook_list, NULL, vhook);
}

/*
 * Run shutdown hooks.  Should be invoked immediately before the
 * system is halted or rebooted, i.e. after file systems unmounted,
 * after crash dump done, etc.
 *
 * Each shutdown hook is removed from the list before it's run, so that
 * it won't be run again.
 */
void
doshutdownhooks(void)
{
        struct hook_desc *dp;

        while ((dp = LIST_FIRST(&shutdownhook_list)) != NULL) {
                LIST_REMOVE(dp, hk_list);
                (*dp->hk_fn)(dp->hk_arg);
#if 0
                /*
                 * Don't bother freeing the hook structure,, since we may
                 * be rebooting because of a memory corruption problem,
                 * and this might only make things worse.  It doesn't
                 * matter, anyway, since the system is just about to
                 * reboot.
                 */
                free(dp, M_DEVBUF);
#endif
        }
}

/*
 * "Mountroot hook" types, functions, and variables.
 */

static hook_list_t mountroothook_list=LIST_HEAD_INITIALIZER(mountroothook_list);

void *
mountroothook_establish(void (*fn)(device_t), device_t dev)
{
        return hook_establish(&mountroothook_list, NULL,
            __FPTRCAST(void (*), fn), dev);
}

void
mountroothook_disestablish(void *vhook)
{
        hook_disestablish(&mountroothook_list, NULL, vhook);
}

void
mountroothook_destroy(void)
{
        hook_destroy(&mountroothook_list);
}

void
domountroothook(device_t therootdev)
{
        struct hook_desc *hd;

        LIST_FOREACH(hd, &mountroothook_list, hk_list) {
                if (hd->hk_arg == therootdev) {
                        (*hd->hk_fn)(hd->hk_arg);
                        return;
                }
        }
}

/*
 * "rootspec hook" types, functions, and variables.
 *
 * A rootspec hook allows a driver to register a name/prefix that will
 * be handled if entered at the "root device" prompt when the kernel
 * starts.
 * One example is the dk/wedge driver which registers the prefixes
 * "NAME=" and "wedge:".  If a user enters "NAME=foo" or "wedge:foo" at
 * the "root device" prompt, then the dk driver's rootspec hook will be
 * called with the string "foo".  It can then interpret that string to
 * determine the real device to mount the root filesystem from.
 */

static LIST_HEAD(rootspechook_list, rootspechook) rootspechook_list =
    LIST_HEAD_INITIALIZER(rootspechook_list);
struct rootspechook {
        LIST_ENTRY(rootspechook) hk_list;
        device_t        (*hk_hook_func)(const char *);
        void            (*hk_print_func)(void);
        const char      *hk_prefix;
        size_t          hk_prefixlen;
};

struct rootspechook *
rootspechook_establish(const char *prefix, device_t (*hookfn)(const char *),
    void (*printfn)(void))
{
        struct rootspechook *hd;

        KASSERT(cold || kernconfig_is_held());

#ifdef DIAGNOSTIC
        LIST_FOREACH(hd, &rootspechook_list, hk_list) {
                if (strcmp(hd->hk_prefix, prefix) == 0) {
                        panic("%s: hook for '%s' already exists",
                            __func__, prefix);
                }
        }
#endif

        hd = kmem_zalloc(sizeof(*hd), KM_SLEEP);
        hd->hk_hook_func = hookfn;
        hd->hk_print_func = printfn;
        hd->hk_prefix = prefix;
        hd->hk_prefixlen = strlen(prefix);
        LIST_INSERT_HEAD(&rootspechook_list, hd, hk_list);

        return hd;
}

void
rootspechook_disestablish(struct rootspechook *hd)
{
        KASSERT(cold || kernconfig_is_held());

#ifdef DIAGNOSTIC
        struct rootspechook *hd0;

        LIST_FOREACH(hd0, &rootspechook_list, hk_list) {
                if (hd == hd0)
                        break;
        }

        if (hd0 == NULL)
                panic("%s: hook %p not established", __func__, hd);
#endif

        LIST_REMOVE(hd, hk_list);
        kmem_free(hd, sizeof(*hd));
}

device_t
dorootspechooks(const char *spec)
{
        struct rootspechook *hd;
        device_t ret = NULL;

        kernconfig_lock();
        LIST_FOREACH(hd, &rootspechook_list, hk_list) {
                if (strncmp(hd->hk_prefix, spec, hd->hk_prefixlen) == 0) {
                        ret = (*hd->hk_hook_func)(spec + hd->hk_prefixlen);
                        if (ret != NULL) {
                                break;
                        }
                }
        }
        kernconfig_unlock();

        return ret;
}

void
dorootspecprint(void)
{
        struct rootspechook *hd;

        kernconfig_lock();
        LIST_FOREACH(hd, &rootspechook_list, hk_list)
                (*hd->hk_print_func)();
        kernconfig_unlock();
}


static hook_list_t exechook_list = LIST_HEAD_INITIALIZER(exechook_list);

void *
exechook_establish(void (*fn)(struct proc *, void *), void *arg)
{
        return hook_establish(&exechook_list, &exec_lock,
                __FPTRCAST(void (*)(void *), fn), arg);
}

void
exechook_disestablish(void *vhook)
{
        hook_disestablish(&exechook_list, &exec_lock, vhook);
}

/*
 * Run exec hooks.
 */
void
doexechooks(struct proc *p)
{
        KASSERT(rw_lock_held(&exec_lock));

        hook_proc_run(&exechook_list, NULL, p);
}

static hook_list_t exithook_list = LIST_HEAD_INITIALIZER(exithook_list);

void *
exithook_establish(void (*fn)(struct proc *, void *), void *arg)
{

        return hook_establish(&exithook_list, &exithook_lock,
            __FPTRCAST(void (*)(void *), fn), arg);
}

void
exithook_disestablish(void *vhook)
{

        hook_disestablish(&exithook_list, &exithook_lock, vhook);
}

/*
 * Run exit hooks.
 */
void
doexithooks(struct proc *p)
{
        hook_proc_run(&exithook_list, &exithook_lock, p);
}

static hook_list_t forkhook_list = LIST_HEAD_INITIALIZER(forkhook_list);

void *
forkhook_establish(void (*fn)(struct proc *, struct proc *))
{
        return hook_establish(&forkhook_list, &forkhook_lock,
            __FPTRCAST(void (*)(void *), fn), NULL);
}

void
forkhook_disestablish(void *vhook)
{
        hook_disestablish(&forkhook_list, &forkhook_lock, vhook);
}

/*
 * Run fork hooks.
 */
void
doforkhooks(struct proc *p2, struct proc *p1)
{
        struct hook_desc *hd;

        RUN_ONCE(&hook_control, hook_init);

        rw_enter(&forkhook_lock, RW_READER);
        LIST_FOREACH(hd, &forkhook_list, hk_list) {
                __FPTRCAST(void (*)(struct proc *, struct proc *), *hd->hk_fn)
                    (p2, p1);
        }
        rw_exit(&forkhook_lock);
}

static hook_list_t critpollhook_list = LIST_HEAD_INITIALIZER(critpollhook_list);

void *
critpollhook_establish(void (*fn)(void *), void *arg)
{
        return hook_establish(&critpollhook_list, NULL, fn, arg);
}

void
critpollhook_disestablish(void *vhook)
{
        hook_disestablish(&critpollhook_list, NULL, vhook);
}

/*
 * Run critical polling hooks.
 */
void
docritpollhooks(void)
{
        struct hook_desc *hd;

        LIST_FOREACH(hd, &critpollhook_list, hk_list) {
                (*hd->hk_fn)(hd->hk_arg);
        }
}

/*
 * "Power hook" types, functions, and variables.
 * The list of power hooks is kept ordered with the last registered hook
 * first.
 * When running the hooks on power down the hooks are called in reverse
 * registration order, when powering up in registration order.
 */
struct powerhook {
        TAILQ_ENTRY(powerhook) sfd_list;
        void    (*sfd_fn)(int, void *);
        void    *sfd_arg;
        char    sfd_name[16];
};

static TAILQ_HEAD(powerhook_head, powerhook) powerhook_list =
    TAILQ_HEAD_INITIALIZER(powerhook_list);

void *
powerhook_establish(const char *name, void (*fn)(int, void *), void *arg)
{
        struct powerhook *ndp;

        ndp = (struct powerhook *)
            malloc(sizeof(*ndp), M_DEVBUF, M_NOWAIT);
        if (ndp == NULL)
                return (NULL);

        ndp->sfd_fn = fn;
        ndp->sfd_arg = arg;
        strlcpy(ndp->sfd_name, name, sizeof(ndp->sfd_name));
        TAILQ_INSERT_HEAD(&powerhook_list, ndp, sfd_list);

        aprint_error("%s: WARNING: powerhook_establish is deprecated\n", name);
        return (ndp);
}

void
powerhook_disestablish(void *vhook)
{
#ifdef DIAGNOSTIC
        struct powerhook *dp;

        TAILQ_FOREACH(dp, &powerhook_list, sfd_list)
                if (dp == vhook)
                        goto found;
        panic("powerhook_disestablish: hook %p not established", vhook);
 found:
#endif

        TAILQ_REMOVE(&powerhook_list, (struct powerhook *)vhook,
            sfd_list);
        free(vhook, M_DEVBUF);
}

/*
 * Run power hooks.
 */
void
dopowerhooks(int why)
{
        struct powerhook *dp;
        const char *why_name;
        static const char * pwr_names[] = {PWR_NAMES};
        why_name = why < __arraycount(pwr_names) ? pwr_names[why] : "???";

        if (why == PWR_RESUME || why == PWR_SOFTRESUME) {
                TAILQ_FOREACH_REVERSE(dp, &powerhook_list, powerhook_head,
                    sfd_list)
                {
                        if (powerhook_debug)
                                printf("dopowerhooks %s: %s (%p)\n",
                                    why_name, dp->sfd_name, dp);
                        (*dp->sfd_fn)(why, dp->sfd_arg);
                }
        } else {
                TAILQ_FOREACH(dp, &powerhook_list, sfd_list) {
                        if (powerhook_debug)
                                printf("dopowerhooks %s: %s (%p)\n",
                                    why_name, dp->sfd_name, dp);
                        (*dp->sfd_fn)(why, dp->sfd_arg);
                }
        }

        if (powerhook_debug)
                printf("dopowerhooks: %s done\n", why_name);
}

/*
 * A simple linear hook.
 */

khook_list_t *
simplehook_create(int ipl, const char *wmsg)
{
        khook_list_t *l;

        l = kmem_zalloc(sizeof(*l), KM_SLEEP);

        mutex_init(&l->hl_lock, MUTEX_DEFAULT, ipl);
        strlcpy(l->hl_namebuf, wmsg, sizeof(l->hl_namebuf));
        cv_init(&l->hl_cv, l->hl_namebuf);
        LIST_INIT(&l->hl_list);
        l->hl_state = HKLIST_IDLE;

        return l;
}

void
simplehook_destroy(khook_list_t *l)
{
        struct hook_desc *hd;

        KASSERT(l->hl_state == HKLIST_IDLE);

        while ((hd = LIST_FIRST(&l->hl_list)) != NULL) {
                LIST_REMOVE(hd, hk_list);
                kmem_free(hd, sizeof(*hd));
        }

        cv_destroy(&l->hl_cv);
        mutex_destroy(&l->hl_lock);
        kmem_free(l, sizeof(*l));
}

int
simplehook_dohooks(khook_list_t *l)
{
        struct hook_desc *hd, *nexthd;
        kmutex_t *cv_lock;
        void (*fn)(void *);
        void *arg;

        mutex_enter(&l->hl_lock);
        if (l->hl_state != HKLIST_IDLE) {
                mutex_exit(&l->hl_lock);
                return SET_ERROR(EBUSY);
        }

        /* stop removing hooks */
        l->hl_state = HKLIST_INUSE;
        l->hl_lwp = curlwp;

        LIST_FOREACH(hd, &l->hl_list, hk_list) {
                if (hd->hk_fn == NULL)
                        continue;

                fn = hd->hk_fn;
                arg = hd->hk_arg;
                l->hl_active_hk = hd;
                l->hl_cvlock = NULL;

                mutex_exit(&l->hl_lock);

                /* do callback without l->hl_lock */
                (*fn)(arg);

                mutex_enter(&l->hl_lock);
                l->hl_active_hk = NULL;
                cv_lock = l->hl_cvlock;

                if (hd->hk_fn == NULL) {
                        if (cv_lock != NULL) {
                                mutex_exit(&l->hl_lock);
                                mutex_enter(cv_lock);
                        }

                        cv_broadcast(&l->hl_cv);

                        if (cv_lock != NULL) {
                                mutex_exit(cv_lock);
                                mutex_enter(&l->hl_lock);
                        }
                }
        }

        /* remove marked node while running hooks */
        LIST_FOREACH_SAFE(hd, &l->hl_list, hk_list, nexthd) {
                if (hd->hk_fn == NULL) {
                        LIST_REMOVE(hd, hk_list);
                        kmem_free(hd, sizeof(*hd));
                }
        }

        l->hl_lwp = NULL;
        l->hl_state = HKLIST_IDLE;
        mutex_exit(&l->hl_lock);

        return 0;
}

khook_t *
simplehook_establish(khook_list_t *l, void (*fn)(void *), void *arg)
{
        struct hook_desc *hd;

        hd = kmem_zalloc(sizeof(*hd), KM_SLEEP);
        hd->hk_fn = fn;
        hd->hk_arg = arg;

        mutex_enter(&l->hl_lock);
        LIST_INSERT_HEAD(&l->hl_list, hd, hk_list);
        mutex_exit(&l->hl_lock);

        return hd;
}

void
simplehook_disestablish(khook_list_t *l, khook_t *hd, kmutex_t *lock)
{
        struct hook_desc *hd0 __diagused;
        kmutex_t *cv_lock;

        KASSERT(lock == NULL || mutex_owned(lock));
        mutex_enter(&l->hl_lock);

#ifdef DIAGNOSTIC
        LIST_FOREACH(hd0, &l->hl_list, hk_list) {
                if (hd == hd0)
                        break;
        }

        if (hd0 == NULL)
                panic("hook_disestablish: hook %p not established", hd);
#endif

        /* The hook is not referred, remove immediately */
        if (l->hl_state == HKLIST_IDLE) {
                LIST_REMOVE(hd, hk_list);
                kmem_free(hd, sizeof(*hd));
                mutex_exit(&l->hl_lock);
                return;
        }

        /* remove callback. hd will be removed in dohooks */
        hd->hk_fn = NULL;
        hd->hk_arg = NULL;

        /* If the hook is running, wait for the completion */
        if (l->hl_active_hk == hd &&
            l->hl_lwp != curlwp) {
                if (lock != NULL) {
                        cv_lock = lock;
                        KASSERT(l->hl_cvlock == NULL);
                        l->hl_cvlock = lock;
                        mutex_exit(&l->hl_lock);
                } else {
                        cv_lock = &l->hl_lock;
                }

                cv_wait(&l->hl_cv, cv_lock);

                if (lock == NULL)
                        mutex_exit(&l->hl_lock);
        } else {
                mutex_exit(&l->hl_lock);
        }
}

bool
simplehook_has_hooks(khook_list_t *l)
{
        bool empty;

        mutex_enter(&l->hl_lock);
        empty = LIST_EMPTY(&l->hl_list);
        mutex_exit(&l->hl_lock);

        return !empty;
}