riscv64: switch to clockintr

- Remove riscv64-specific clock interrupt scheduling bits from
  cpu_info.
- Remove riscv64-specific randomized statclock() bits from
  riscv64/clock.c.
- Remove the 'stat_count' evcount.  All clock interrupts are
  now counted via the 'clock_count' evcount.
- Wire up timer_intrclock.

With input from jca@, kettenis@.  Tested by jca@.

Link: https://marc.info/?l=openbsd-tech&m=166776413003655&w=2
ok kettenis@ jca@ mlarkin@

diff --git a/sys/arch/riscv64/include/_types.h b/sys/arch/riscv64/include/_types.h
index 394d4ab..0704283 100644 (file)
--- a/sys/arch/riscv64/include/_types.h
+++ b/sys/arch/riscv64/include/_types.h
@@ -1,4 +1,4 @@
-/*     $OpenBSD: _types.h,v 1.3 2021/05/12 01:20:52 jsg Exp $ */
+/*     $OpenBSD: _types.h,v 1.4 2022/11/19 16:02:37 cheloha Exp $ */
 
 /*-
  * Copyright (c) 1990, 1993
@@ -35,6 +35,8 @@
 #ifndef _MACHINE__TYPES_H_
 #define _MACHINE__TYPES_H_
 
+#define        __HAVE_CLOCKINTR
+
 #if defined(_KERNEL)
 typedef struct label_t {
        long val[14];

diff --git a/sys/arch/riscv64/include/cpu.h b/sys/arch/riscv64/include/cpu.h
index b90219e..4d0aca1 100644 (file)
--- a/sys/arch/riscv64/include/cpu.h
+++ b/sys/arch/riscv64/include/cpu.h
@@ -1,4 +1,4 @@
-/*     $OpenBSD: cpu.h,v 1.14 2022/08/29 02:01:18 jsg Exp $    */
+/*     $OpenBSD: cpu.h,v 1.15 2022/11/19 16:02:37 cheloha Exp $        */
 
 /*
  * Copyright (c) 2019 Mike Larkin <mlarkin@openbsd.org>
@@ -68,6 +68,7 @@
 #define PROC_PC(p)     ((p)->p_addr->u_pcb.pcb_tf->tf_sepc)
 #define PROC_STACK(p)  ((p)->p_addr->u_pcb.pcb_tf->tf_sp)
 
+#include <sys/clockintr.h>
 #include <sys/device.h>
 #include <sys/sched.h>
 #include <sys/srp.h>
@@ -89,9 +90,7 @@ struct cpu_info {
        struct pcb              *ci_curpcb;
        struct pcb              *ci_idle_pcb;
 
-       uint64_t                ci_lasttb;
-       uint64_t                ci_nexttimerevent;
-       uint64_t                ci_nextstatevent;
+       struct clockintr_queue  ci_queue;
        volatile int            ci_timer_deferred;
 
        uint32_t                ci_cpl;

diff --git a/sys/arch/riscv64/riscv64/clock.c b/sys/arch/riscv64/riscv64/clock.c
index b1ddd38..437399e 100644 (file)
--- a/sys/arch/riscv64/riscv64/clock.c
+++ b/sys/arch/riscv64/riscv64/clock.c
@@ -1,4 +1,4 @@
-/*     $OpenBSD: clock.c,v 1.5 2022/09/08 03:09:40 cheloha Exp $       */
+/*     $OpenBSD: clock.c,v 1.6 2022/11/19 16:02:37 cheloha Exp $       */
 
 /*
  * Copyright (c) 2020 Mark Kettenis <kettenis@openbsd.org>
@@ -20,6 +20,7 @@
 #include <sys/param.h>
 #include <sys/kernel.h>
 #include <sys/systm.h>
+#include <sys/clockintr.h>
 #include <sys/evcount.h>
 #include <sys/stdint.h>
 #include <sys/timetc.h>
@@ -30,13 +31,18 @@
 #include <riscv64/dev/riscv_cpu_intc.h>
 
 extern uint64_t tb_freq;       /* machdep.c */
-
-uint64_t tick_increment;
-uint64_t statmin;
-uint32_t statvar;
+uint64_t timer_nsec_max;
+uint64_t timer_nsec_cycle_ratio;
 
 struct evcount clock_count;
-struct evcount stat_count;
+
+void timer_rearm(void *, uint64_t);
+void timer_trigger(void *);
+
+const struct intrclock timer_intrclock = {
+       .ic_rearm = timer_rearm,
+       .ic_trigger = timer_trigger
+};
 
 u_int  tb_get_timecount(struct timecounter *);
 
@@ -54,6 +60,23 @@ static struct timecounter tb_timecounter = {
 void   cpu_startclock(void);
 int    clock_intr(void *);
 
+void
+timer_rearm(void *unused, uint64_t nsecs)
+{
+       uint32_t cycles;
+
+       if (nsecs > timer_nsec_max)
+               nsecs = timer_nsec_max;
+       cycles = (nsecs * timer_nsec_cycle_ratio) >> 32;
+       sbi_set_timer(rdtime() + cycles);
+}
+
+void
+timer_trigger(void *unused)
+{
+       sbi_set_timer(0);
+}
+
 u_int
 tb_get_timecount(struct timecounter *tc)
 {
@@ -66,18 +89,17 @@ cpu_initclocks(void)
        tb_timecounter.tc_frequency = tb_freq;
        tc_init(&tb_timecounter);
 
-       tick_increment = tb_freq / hz;
+       timer_nsec_cycle_ratio = tb_freq * (1ULL << 32) / 1000000000;
+       timer_nsec_max = UINT64_MAX / timer_nsec_cycle_ratio;
 
        stathz = 100;
        profhz = 1000; /* must be a multiple of stathz */
-
-       setstatclockrate(stathz);
+       clockintr_init(CL_RNDSTAT);
 
        riscv_intc_intr_establish(IRQ_TIMER_SUPERVISOR, 0,
            clock_intr, NULL, NULL);
 
        evcount_attach(&clock_count, "clock", NULL);
-       evcount_attach(&stat_count, "stat", NULL);
 
        cpu_startclock();
 }
@@ -85,14 +107,8 @@ cpu_initclocks(void)
 void
 cpu_startclock(void)
 {
-       struct cpu_info *ci = curcpu();
-       uint64_t nextevent;
-
-       ci->ci_lasttb = rdtime();
-       ci->ci_nexttimerevent = ci->ci_lasttb + tick_increment;
-       nextevent = ci->ci_nextstatevent = ci->ci_nexttimerevent;
-
-       sbi_set_timer(nextevent);
+       clockintr_cpu_init(&timer_intrclock);
+       clockintr_trigger();
        csr_set(sie, SIE_STIE);
 }
 
@@ -100,93 +116,35 @@ int
 clock_intr(void *frame)
 {
        struct cpu_info *ci = curcpu();
-       uint64_t tb, prevtb;
-       uint64_t nextevent;
-       uint32_t r;
-       int nstats;
        int s;
 
+       sbi_set_timer(UINT64_MAX);      /* clear timer interrupt */
+
        /*
         * If the clock interrupt is masked, defer all clock interrupt
         * work until the clock interrupt is unmasked from splx(9).
         */
        if (ci->ci_cpl >= IPL_CLOCK) {
                ci->ci_timer_deferred = 1;
-               sbi_set_timer(UINT64_MAX);
                return 0;
        }
        ci->ci_timer_deferred = 0;
 
-       /*
-        * Based on the actual time delay since the last clock interrupt,
-        * we arrange for earlier interrupt next time.
-        */
-
-       tb = rdtime();
-
-       while (ci->ci_nexttimerevent <= tb)
-               ci->ci_nexttimerevent += tick_increment;
-
-       prevtb = ci->ci_nexttimerevent - tick_increment;
-
-       for (nstats = 0; ci->ci_nextstatevent <= tb; nstats++) {
-               do {
-                       r = random() & (statvar - 1);
-               } while (r == 0); /* random == 0 not allowed */
-               ci->ci_nextstatevent += statmin + r;
-       }
-       stat_count.ec_count += nstats;
-
-       if (ci->ci_nexttimerevent < ci->ci_nextstatevent)
-               nextevent = ci->ci_nexttimerevent;
-       else
-               nextevent = ci->ci_nextstatevent;
-
-       sbi_set_timer(nextevent);
-
        s = splclock();
        intr_enable();
-
-       /*
-        * Do standard timer interrupt stuff.
-        */
-       while (ci->ci_lasttb < prevtb) {
-               ci->ci_lasttb += tick_increment;
-               clock_count.ec_count++;
-               hardclock((struct clockframe *)frame);
-       }
-
-       while (nstats-- > 0)
-               statclock((struct clockframe *)frame);
-
+       clockintr_dispatch(frame);
        intr_disable();
        splx(s);
 
+       clock_count.ec_count++;
+
        return 0;
 }
 
 void
 setstatclockrate(int newhz)
 {
-       uint64_t stat_increment;
-       uint64_t min_increment;
-       uint32_t var;
-       u_long msr;
-
-       msr = intr_disable();
-
-       stat_increment = tb_freq / newhz;
-       var = 0x40000000; /* really big power of two */
-       /* Find largest 2^n which is nearly smaller than statint/2. */
-       min_increment = stat_increment / 2 + 100;
-       while (var > min_increment)
-               var >>= 1;
-
-       /* Not atomic, but we can probably live with that. */
-       statmin = stat_increment - (var >> 1);
-       statvar = var;
-
-       intr_restore(msr);
+       clockintr_setstatclockrate(newhz);
 }
 
 void