/*      $NetBSD: intr.c,v 1.57 2025/04/06 01:58:22 riastradh Exp $      */

/*
* Copyright (c) 2008-2010, 2015 Antti Kantee.  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. 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 AUTHOR ``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 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: intr.c,v 1.57 2025/04/06 01:58:22 riastradh Exp $");

#include <sys/param.h>
#include <sys/atomic.h>
#include <sys/cpu.h>
#include <sys/kernel.h>
#include <sys/kmem.h>
#include <sys/kthread.h>
#include <sys/malloc.h>
#include <sys/intr.h>
#include <sys/timetc.h>

#include <rump-sys/kern.h>

#include <rump/rumpuser.h>

/*
* Interrupt simulator.  It executes hardclock() and softintrs.
*/

#define SI_MPSAFE 0x01
#define SI_KILLME 0x02

struct softint_percpu;
struct softint {
       void (*si_func)(void *);
       void *si_arg;
       int si_flags;
       int si_level;

       struct softint_percpu *si_entry; /* [0,ncpu-1] */
};

struct softint_percpu {
       struct softint *sip_parent;
       bool sip_onlist;
       bool sip_onlist_cpu;

       TAILQ_ENTRY(softint_percpu) sip_entries;        /* scheduled */
       TAILQ_ENTRY(softint_percpu) sip_entries_cpu;    /* to be scheduled */
};

struct softint_lev {
       struct rumpuser_cv *si_cv;
       TAILQ_HEAD(, softint_percpu) si_pending;
};

static TAILQ_HEAD(, softint_percpu) sicpupending \
   = TAILQ_HEAD_INITIALIZER(sicpupending);
static struct rumpuser_mtx *sicpumtx;
static struct rumpuser_cv *sicpucv;

kcondvar_t lbolt; /* Oh Kath Ra */

static int ncpu_final;

void noclock(void); void noclock(void) {return;}
__strong_alias(sched_schedclock,noclock);
__strong_alias(cpu_initclocks,noclock);
__strong_alias(addupc_intr,noclock);
__strong_alias(sched_tick,noclock);
__strong_alias(setstatclockrate,noclock);

/*
* clock "interrupt"
*/
static void
doclock(void *noarg)
{
       struct timespec thetick, curclock;
       struct clockframe *clkframe;
       int64_t sec;
       long nsec;
       int error;
       struct cpu_info *ci = curcpu();

       error = rumpuser_clock_gettime(RUMPUSER_CLOCK_ABSMONO, &sec, &nsec);
       if (error)
               panic("clock: cannot get monotonic time");

       curclock.tv_sec = sec;
       curclock.tv_nsec = nsec;
       thetick.tv_sec = 0;
       thetick.tv_nsec = 1000000000/hz;

       /* generate dummy clockframe for hardclock to consume */
       clkframe = rump_cpu_makeclockframe();

       for (;;) {
               int lbolt_ticks = 0;

               hardclock(clkframe);
               if (CPU_IS_PRIMARY(ci)) {
                       if (++lbolt_ticks >= hz) {
                               lbolt_ticks = 0;
                               cv_broadcast(&lbolt);
                       }
               }

               error = rumpuser_clock_sleep(RUMPUSER_CLOCK_ABSMONO,
                   curclock.tv_sec, curclock.tv_nsec);
               if (error) {
                       panic("rumpuser_clock_sleep failed with error %d",
                           error);
               }
               timespecadd(&curclock, &thetick, &curclock);
       }
}

/*
* Soft interrupt execution thread.  This thread is pinned to the
* same CPU that scheduled the interrupt, so we don't need to do
* lock against si_lvl.
*/
static void
sithread(void *arg)
{
       struct softint_percpu *sip;
       struct softint *si;
       void (*func)(void *) = NULL;
       void *funarg;
       bool mpsafe;
       int mylevel = (uintptr_t)arg;
       struct softint_lev *si_lvlp, *si_lvl;
       struct cpu_data *cd = &curcpu()->ci_data;

       si_lvlp = cd->cpu_softcpu;
       si_lvl = &si_lvlp[mylevel];

       for (;;) {
               if (!TAILQ_EMPTY(&si_lvl->si_pending)) {
                       sip = TAILQ_FIRST(&si_lvl->si_pending);
                       si = sip->sip_parent;

                       func = si->si_func;
                       funarg = si->si_arg;
                       mpsafe = si->si_flags & SI_MPSAFE;

                       sip->sip_onlist = false;
                       TAILQ_REMOVE(&si_lvl->si_pending, sip, sip_entries);
                       if (si->si_flags & SI_KILLME) {
                               softint_disestablish(si);
                               continue;
                       }
               } else {
                       rump_schedlock_cv_wait(si_lvl->si_cv);
                       continue;
               }

               if (!mpsafe)
                       KERNEL_LOCK(1, curlwp);
               func(funarg);
               if (!mpsafe)
                       KERNEL_UNLOCK_ONE(curlwp);
       }

       panic("sithread unreachable");
}

/*
* Helper for softint_schedule_cpu()
*/
static void
sithread_cpu_bouncer(void *arg)
{
       struct lwp *me;

       me = curlwp;
       me->l_pflag |= LP_BOUND;

       rump_unschedule();
       for (;;) {
               struct softint_percpu *sip;
               struct softint *si;
               struct cpu_info *ci;
               unsigned int cidx;

               rumpuser_mutex_enter_nowrap(sicpumtx);
               while (TAILQ_EMPTY(&sicpupending)) {
                       rumpuser_cv_wait_nowrap(sicpucv, sicpumtx);
               }
               sip = TAILQ_FIRST(&sicpupending);
               TAILQ_REMOVE(&sicpupending, sip, sip_entries_cpu);
               sip->sip_onlist_cpu = false;
               rumpuser_mutex_exit(sicpumtx);

               /*
                * ok, now figure out which cpu we need the softint to
                * be handled on
                */
               si = sip->sip_parent;
               cidx = sip - si->si_entry;
               ci = cpu_lookup(cidx);
               me->l_target_cpu = ci;

               /* schedule ourselves there, and then schedule the softint */
               rump_schedule();
               KASSERT(curcpu() == ci);
               softint_schedule(si);
               rump_unschedule();
       }
       panic("sithread_cpu_bouncer unreasonable");
}

static kmutex_t sithr_emtx;
static unsigned int sithr_est;
static int sithr_canest;

/*
* Create softint handler threads when the softint for each respective
* level is established for the first time.  Most rump kernels don't
* need at least half of the softint levels, so on-demand saves bootstrap
* time and memory resources.  Note, though, that this routine may be
* called before it's possible to call kthread_create().  Creation of
* those softints (SOFTINT_CLOCK, as of writing this) will be deferred
* to until softint_init() is called for the main CPU.
*/
static void
sithread_establish(int level)
{
       int docreate, rv;
       int lvlbit = 1<<level;
       int i;

       KASSERT((level & ~SOFTINT_LVLMASK) == 0);
       if (__predict_true(sithr_est & lvlbit))
               return;

       mutex_enter(&sithr_emtx);
       docreate = (sithr_est & lvlbit) == 0 && sithr_canest;
       sithr_est |= lvlbit;
       mutex_exit(&sithr_emtx);

       if (docreate) {
               for (i = 0; i < ncpu_final; i++) {
                       if ((rv = kthread_create(PRI_NONE,
                           KTHREAD_MPSAFE | KTHREAD_INTR,
                           cpu_lookup(i), sithread, (void *)(uintptr_t)level,
                           NULL, "rsi%d/%d", i, level)) != 0)
                               panic("softint thread create failed: %d", rv);
               }
       }
}

void
rump_intr_init(int numcpu)
{

       cv_init(&lbolt, "oh kath ra");
       mutex_init(&sithr_emtx, MUTEX_DEFAULT, IPL_NONE);
       ncpu_final = numcpu;
}

void
softint_init(struct cpu_info *ci)
{
       struct cpu_data *cd = &ci->ci_data;
       struct softint_lev *slev;
       int rv, i;

       if (!rump_threads)
               return;

       slev = kmem_alloc(sizeof(struct softint_lev) * SOFTINT_COUNT, KM_SLEEP);
       for (i = 0; i < SOFTINT_COUNT; i++) {
               rumpuser_cv_init(&slev[i].si_cv);
               TAILQ_INIT(&slev[i].si_pending);
       }
       cd->cpu_softcpu = slev;

       /* overloaded global init ... */
       /* XXX: should be done the last time we are called */
       if (ci->ci_index == 0) {
               int sithr_swap;

               /* pretend that we have our own for these */
               stathz = 1;
               schedhz = 1;
               profhz = 1;

               initclocks();

               /* create deferred softint threads */
               mutex_enter(&sithr_emtx);
               sithr_swap = sithr_est;
               sithr_est = 0;
               sithr_canest = 1;
               mutex_exit(&sithr_emtx);
               for (i = 0; i < SOFTINT_COUNT; i++) {
                       if (sithr_swap & (1<<i))
                               sithread_establish(i);
               }
       }

       /* well, not really a "soft" interrupt ... */
       if ((rv = kthread_create(PRI_NONE, KTHREAD_MPSAFE,
           ci, doclock, NULL, NULL, "rumpclk%d", ci->ci_index)) != 0)
               panic("clock thread creation failed: %d", rv);

       /* not one either, but at least a softint helper */
       if (CPU_IS_PRIMARY(ci)) {
               rumpuser_mutex_init(&sicpumtx, RUMPUSER_MTX_SPIN);
               rumpuser_cv_init(&sicpucv);
               if ((rv = kthread_create(PRI_NONE, KTHREAD_MPSAFE,
                   NULL, sithread_cpu_bouncer, NULL, NULL, "sipbnc")) != 0)
                       panic("softint cpu bouncer creation failed: %d", rv);
       }
}

void *
softint_establish(u_int flags, void (*func)(void *), void *arg)
{
       struct softint *si;
       struct softint_percpu *sip;
       int level = flags & SOFTINT_LVLMASK;
       int i;

       si = malloc(sizeof(*si), M_TEMP, M_WAITOK);
       si->si_func = func;
       si->si_arg = arg;
       si->si_flags = flags & SOFTINT_MPSAFE ? SI_MPSAFE : 0;
       si->si_level = level;
       KASSERT(si->si_level < SOFTINT_COUNT);
       si->si_entry = malloc(sizeof(*si->si_entry) * ncpu_final,
           M_TEMP, M_WAITOK | M_ZERO);
       for (i = 0; i < ncpu_final; i++) {
               sip = &si->si_entry[i];
               sip->sip_parent = si;
       }
       sithread_establish(level);

       return si;
}

static struct softint_percpu *
sitosip(struct softint *si, struct cpu_info *ci)
{

       return &si->si_entry[ci->ci_index];
}

/*
* Soft interrupts bring two choices.  If we are running with thread
* support enabled, defer execution, otherwise execute in place.
*/

void
softint_schedule(void *arg)
{
       struct softint *si = arg;
       struct cpu_info *ci = curcpu();
       struct softint_percpu *sip = sitosip(si, ci);
       struct cpu_data *cd = &ci->ci_data;
       struct softint_lev *si_lvl = cd->cpu_softcpu;

       if (!rump_threads) {
               si->si_func(si->si_arg);
       } else {
               if (!sip->sip_onlist) {
                       TAILQ_INSERT_TAIL(&si_lvl[si->si_level].si_pending,
                           sip, sip_entries);
                       sip->sip_onlist = true;
               }
       }
}

/*
* Like softint_schedule(), except schedule softint to be handled on
* the core designated by ci_tgt instead of the core the call is made on.
*
* Unlike softint_schedule(), the performance is not important
* (unless ci_tgt == curcpu): high-performance rump kernel I/O stacks
* should arrange data to already be on the right core at the driver
* layer.
*/
void
softint_schedule_cpu(void *arg, struct cpu_info *ci_tgt)
{
       struct softint *si = arg;
       struct cpu_info *ci_cur = curcpu();
       struct softint_percpu *sip;

       KASSERT(rump_threads);

       /* preferred case (which can be optimized some day) */
       if (ci_cur == ci_tgt) {
               softint_schedule(si);
               return;
       }

       /*
        * no?  then it's softint turtles all the way down
        */

       sip = sitosip(si, ci_tgt);
       rumpuser_mutex_enter_nowrap(sicpumtx);
       if (sip->sip_onlist_cpu) {
               rumpuser_mutex_exit(sicpumtx);
               return;
       }
       TAILQ_INSERT_TAIL(&sicpupending, sip, sip_entries_cpu);
       sip->sip_onlist_cpu = true;
       rumpuser_cv_signal(sicpucv);
       rumpuser_mutex_exit(sicpumtx);
}

/*
* flimsy disestablish: should wait for softints to finish.
*/
void
softint_disestablish(void *cook)
{
       struct softint *si = cook;
       int i;

       for (i = 0; i < ncpu_final; i++) {
               struct softint_percpu *sip;

               sip = &si->si_entry[i];
               if (sip->sip_onlist) {
                       si->si_flags |= SI_KILLME;
                       return;
               }
       }
       free(si->si_entry, M_TEMP);
       free(si, M_TEMP);
}

void
rump_softint_run(struct cpu_info *ci)
{
       struct cpu_data *cd = &ci->ci_data;
       struct softint_lev *si_lvl = cd->cpu_softcpu;
       int i;

       if (!rump_threads)
               return;

       for (i = 0; i < SOFTINT_COUNT; i++) {
               if (!TAILQ_EMPTY(&si_lvl[i].si_pending))
                       rump_schedlock_cv_signal(ci, si_lvl[i].si_cv);
       }
}

bool
cpu_intr_p(void)
{

       return false;
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.