Changeset 10954 in vbox for trunk/src/VBox/Runtime

Timestamp:

Jul 29, 2008 7:51:36 PM (16 years ago)

Author:

vboxsync

Message:

IPRT: Integrated vbi v2 changes (r0drv/solaris/vbi).

Location:

trunk/src/VBox/Runtime

Files:

• Makefile.kmk (modified) (1 diff)
• r0drv/solaris/vbi/32/vbi (modified) ( previous)
• r0drv/solaris/vbi/64/vbi (modified) ( previous)
• r0drv/solaris/vbi/i86pc/os/vbi.c (modified) (7 diffs)
• r0drv/solaris/vbi/i86pc/sys/vbi.h (modified) (3 diffs)
• r0drv/solaris/vbi/mp-r0drv-solaris.c (modified) (1 diff)
• r0drv/solaris/vbi/mpnotification-r0drv-solaris.c (copied) (copied from trunk/src/VBox/Runtime/r0drv/solaris/mpnotification-r0drv-solaris.c ) (2 diffs)
• r0drv/solaris/vbi/timer-r0drv-solaris.c (modified) (7 diffs)

trunk/src/VBox/Runtime/Makefile.kmk

@@ -1132 +1132 @@
 
 ifdef VBOX_WITH_SOLARIS_VBI
- ## @todo svn copy r0drv/solaris/mpnotification-r0drv-solaris.c r0drv/solaris/vbi/mpnotification-r0drv-solaris.c
- # and change the first file below.
  RuntimeR0Drv_SOURCES.solaris += \
-        r0drv/solaris/mpnotification-r0drv-solaris.c \
+        r0drv/solaris/vbi/mpnotification-r0drv-solaris.c \
         r0drv/solaris/vbi/alloc-r0drv-solaris.c \
         r0drv/solaris/vbi/assert-r0drv-solaris.c \

trunk/src/VBox/Runtime/r0drv/solaris/vbi/i86pc/os/vbi.c

@@ -24 +24 @@
  */
 
-#pragma ident   "@(#)vbi.c      1.1     08/05/26 SMI"
+#pragma ident   "%Z%%M% %I%     %E% SMI"
 
 /*
@@ -78 +78 @@
 #pragma weak cpuset_all
 #pragma weak cpuset_all_but
+#pragma weak cpuset_only
 
 static struct modlmisc vbi_modlmisc = {
@@ -159 +160 @@
         void *ptr;
 
-        if ((size >> MMU_PAGESHIFT) << MMU_PAGESHIFT != size)
+        if ((size & MMU_PAGEOFFSET) != 0)
                 return (NULL);
 
@@ -428 +429 @@
          * hack for a kernel compiled with the different NCPU than this module
          */
+        ASSERT(curthread->t_preempt >= 1);
         if (use_old_xc_call) {
                 hack_set = 0;
                 for (i = 0; i < ncpus; ++i)
-                        hack_set |= 1 << i;
+                        hack_set |= 1ul << i;
                 p_xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI, hack_set,
                     (xc_func_t)func);
@@ -451 +453 @@
          * hack for a kernel compiled with the different NCPU than this module
          */
+        ASSERT(curthread->t_preempt >= 1);
         if (use_old_xc_call) {
                 hack_set = 0;
                 for (i = 0; i < ncpus; ++i) {
                         if (i != CPU->cpu_id)
-                                hack_set |= 1 << i;
+                                hack_set |= 1ul << i;
                 }
                 p_xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI, hack_set,
@@ -475 +478 @@
          * hack for a kernel compiled with the different NCPU than this module
          */
+        ASSERT(curthread->t_preempt >= 1);
         if (use_old_xc_call) {
-                hack_set = 1 << c;
+                hack_set = 1ul << c;
                 p_xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI, hack_set,
                     (xc_func_t)func);
         } else {
-                CPUSET_ALL_BUT(set, c);
+                CPUSET_ONLY(set, c);
                 xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI, set,
                     (xc_func_t)func);
@@ -821 +825 @@
 
 /*
- * This is revision 1 of the interface. As more functions are added,
+ * This is revision 2 of the interface. As more functions are added,
  * they should go after this point in the file and the revision level
  * increased.
  */
-uint_t vbi_revision_level = 1;
+uint_t vbi_revision_level = 2;
+
+struct vbi_cpu_watch {
+        void (*vbi_cpu_func)();
+        void *vbi_cpu_arg;
+};
+
+static int
+vbi_watcher(cpu_setup_t state, int cpu, void *arg)
+{
+        vbi_cpu_watch_t *w = arg;
+        int online;
+
+        if (state == CPU_ON)
+                online = 1;
+        else if (state == CPU_OFF)
+                online = 0;
+        else
+                return (0);
+        w->vbi_cpu_func(w->vbi_cpu_arg, cpu, online);
+        return (0);
+}
+
+vbi_cpu_watch_t *
+vbi_watch_cpus(void (*func)(), void *arg, int current_too)
+{
+        int c;
+        vbi_cpu_watch_t *w;
+
+        w = kmem_alloc(sizeof (*w), KM_SLEEP);
+        w->vbi_cpu_func = func;
+        w->vbi_cpu_arg = arg;
+        mutex_enter(&cpu_lock);
+        register_cpu_setup_func(vbi_watcher, w);
+        if (current_too) {
+                for (c = 0; c < ncpus; ++c) {
+                        if (cpu_is_online(cpu[c]))
+                                func(arg, c, 1);
+                }
+        }
+        mutex_exit(&cpu_lock);
+        return (w);
+}
+
+void
+vbi_ignore_cpus(vbi_cpu_watch_t *w)
+{
+        mutex_enter(&cpu_lock);
+        unregister_cpu_setup_func(vbi_watcher, w);
+        mutex_exit(&cpu_lock);
+        kmem_free(w, sizeof (*w));
+}
+
+/*
+ * Simple timers are pretty much a pass through to the cyclic subsystem.
+ */
+struct vbi_stimer {
+        cyc_handler_t   s_handler;
+        cyc_time_t      s_fire_time;
+        cyclic_id_t     s_cyclic;
+        uint64_t        s_tick;
+        void            (*s_func)(void *, uint64_t);
+        void            *s_arg;
+};
+
+static void
+vbi_stimer_func(void *arg)
+{
+        vbi_stimer_t *t = arg;
+        t->s_func(t->s_arg, t->s_tick++);
+}
+
+extern vbi_stimer_t *
+vbi_stimer_begin(
+        void (*func)(void *, uint64_t),
+        void *arg,
+        uint64_t when,
+        uint64_t interval,
+        int on_cpu)
+{
+        vbi_stimer_t *t = kmem_zalloc(sizeof (*t), KM_SLEEP);
+
+        ASSERT(when < INT64_MAX);
+        ASSERT(interval < INT64_MAX);
+        ASSERT(interval + when < INT64_MAX);
+
+        t->s_handler.cyh_func = vbi_stimer_func;
+        t->s_handler.cyh_arg = t;
+        t->s_handler.cyh_level = CY_LOCK_LEVEL;
+        t->s_tick = 0;
+        t->s_func = func;
+        t->s_arg = arg;
+
+        mutex_enter(&cpu_lock);
+        if (on_cpu != VBI_ANY_CPU && !vbi_cpu_online(on_cpu)) {
+                t = NULL;
+                goto done;
+        }
+
+        when += gethrtime();
+        t->s_fire_time.cyt_when = when;
+        if (interval == 0)
+                t->s_fire_time.cyt_interval = INT64_MAX - when;
+        else
+                t->s_fire_time.cyt_interval = interval;
+        t->s_cyclic = cyclic_add(&t->s_handler, &t->s_fire_time);
+        if (on_cpu != VBI_ANY_CPU)
+                cyclic_bind(t->s_cyclic, cpu[on_cpu], NULL);
+done:
+        mutex_exit(&cpu_lock);
+        return (t);
+}
+
+extern void
+vbi_stimer_end(vbi_stimer_t *t)
+{
+        ASSERT(t->s_cyclic != CYCLIC_NONE);
+        mutex_enter(&cpu_lock);
+        cyclic_remove(t->s_cyclic);
+        mutex_exit(&cpu_lock);
+        kmem_free(t, sizeof (*t));
+}
+
+/*
+ * Global timers are more complicated. They include a counter on the callback,
+ * that indicates the first call on a given cpu.
+ */
+struct vbi_gtimer {
+        uint64_t        *g_counters;
+        void            (*g_func)(void *, uint64_t);
+        void            *g_arg;
+        uint64_t        g_when;
+        uint64_t        g_interval;
+        cyclic_id_t     g_cyclic;
+};
+
+static void
+vbi_gtimer_func(void *arg)
+{
+        vbi_gtimer_t *t = arg;
+        t->g_func(t->g_arg, t->g_counters[CPU->cpu_id]);
+}
+
+/*
+ * Whenever a cpu is onlined, need to reset the g_counters[] for it to zero.
+ */
+static void
+vbi_gtimer_online(void *arg, cpu_t *cpu, cyc_handler_t *h, cyc_time_t *ct)
+{
+        vbi_gtimer_t *t = arg;
+        hrtime_t now;
+
+        t->g_counters[cpu->cpu_id] = 0;
+        h->cyh_func = vbi_gtimer_func;
+        h->cyh_arg = t;
+        h->cyh_level = CY_LOCK_LEVEL;
+        now = gethrtime();
+        if (t->g_when < now)
+                ct->cyt_when = now + t->g_interval / 2;
+        else
+                ct->cyt_when = t->g_when;
+        ct->cyt_interval = t->g_interval;
+}
+
+
+vbi_gtimer_t *
+vbi_gtimer_begin(
+        void (*func)(void *, uint64_t),
+        void *arg,
+        uint64_t when,
+        uint64_t interval)
+{
+        vbi_gtimer_t *t;
+        cyc_omni_handler_t omni;
+
+        /*
+         * one shot global timer is not supported yet.
+         */
+        if (interval == 0)
+                return (NULL);
+
+        ASSERT(when < INT64_MAX);
+        ASSERT(interval < INT64_MAX);
+        ASSERT(interval + when < INT64_MAX);
+
+        t = kmem_zalloc(sizeof (*t), KM_SLEEP);
+        t->g_counters = kmem_zalloc(ncpus * sizeof (uint64_t), KM_SLEEP);
+        t->g_when = when + gethrtime();
+        t->g_interval = interval;
+        t->g_arg = arg;
+        t->g_func = func;
+        t->g_cyclic = CYCLIC_NONE;
+
+        omni.cyo_online = (void (*)())vbi_gtimer_online;
+        omni.cyo_offline = NULL;
+        omni.cyo_arg = t;
+
+        mutex_enter(&cpu_lock);
+        t->g_cyclic = cyclic_add_omni(&omni);
+        mutex_exit(&cpu_lock);
+        return (t);
+}
+
+extern void
+vbi_gtimer_end(vbi_gtimer_t *t)
+{
+        ASSERT(t->g_cyclic != CYCLIC_NONE);
+        mutex_enter(&cpu_lock);
+        cyclic_remove(t->g_cyclic);
+        mutex_exit(&cpu_lock);
+        kmem_free(t->g_counters, ncpus * sizeof (uint64_t));
+        kmem_free(t, sizeof (*t));
+}

trunk/src/VBox/Runtime/r0drv/solaris/vbi/i86pc/sys/vbi.h

@@ -28 +28 @@
 #define _SYS_VBI_H
 
-#pragma ident   "@(#)vbi.h      1.1     08/05/26 SMI"
+#pragma ident   "%Z%%M% %I%     %E% SMI"
 
 #ifdef  __cplusplus
@@ -109 +109 @@
  */
 extern uint64_t vbi_timer_granularity(void);
+
+/* old timer funcs */
 extern void *vbi_timer_create(void *callback, void *arg1, void *arg2,
     uint64_t interval);
@@ -222 +224 @@
 extern uint_t vbi_revision_level;
 
+/* begin interfaces defined for version 2 */
+
+/*
+ * Install/remove a call back for CPU online/offline event notification.
+ *
+ * The call back func is invoked with 3 arguments:
+ *      void func(void *arg, int cpu, int online);
+ * - arg is passed through from vbi_watch_cpus()
+ * - cpu is the CPU id involved
+ * - online is non-zero for a CPU that comes online and 0 for a CPU that is
+ *   going offline.
+ *
+ * If current_too is non-zero, then a cpu online event will be invoked for all
+ * currently online CPUs.
+ *
+ * Note there is no guarantee about which CPU the function is invoked on.
+ */
+typedef struct vbi_cpu_watch vbi_cpu_watch_t;
+extern vbi_cpu_watch_t *vbi_watch_cpus(void (*func)(), void *arg,
+    int current_too);
+extern void vbi_ignore_cpus(vbi_cpu_watch_t *);
+#pragma weak vbi_watch_cpus
+#pragma weak vbi_ignore_cpus
+
+/*
+ * New timer interfaces
+ *
+ * A simple timer fires just once and on only one cpu. It may be repeating or
+ * a one shot.
+ *
+ * Support for one shot (ie interval == 0) global timers is optional.
+ *
+ * For simple timers, if cpu is VBI_ANY_CPU, the timer may fire on any
+ * available cpu otherwise the timer will fire only on the given cpu
+ *
+ * The repeating call back, func, is invoked with 2 arguments:
+ * - arg is just passed through
+ * - a uint64_t counter that starts at 0 and increments with each timer event.
+ *   The count is per-cpu and resets whenever a cpu goes offline and comes back
+ *   online.
+ *
+ * The when parameter is time relative to now.
+ *
+ * vbi_stimer_begin() may return NULL if there was an error in
+ * creating the timer, for example if a requested cpu is not online.
+ *
+ * vbi_gtimer_begin() may return NULL when called if it does not
+ * support the requested kind of timer (ie interval == 0)
+ */
+#define VBI_ANY_CPU     (-1)
+
+typedef struct vbi_stimer vbi_stimer_t;
+extern vbi_stimer_t *vbi_stimer_begin(void (*func)(void *, uint64_t), void *arg,
+    uint64_t when, uint64_t interval, int cpu);
+extern void vbi_stimer_end(vbi_stimer_t *);
+#pragma weak vbi_stimer_begin
+#pragma weak vbi_stimer_end
+
+typedef struct vbi_gtimer vbi_gtimer_t;
+extern vbi_gtimer_t *vbi_gtimer_begin(void (*func)(void *, uint64_t), void *arg,
+    uint64_t when, uint64_t interval);
+extern void vbi_gtimer_end(vbi_gtimer_t *);
+#pragma weak vbi_gtimer_begin
+#pragma weak vbi_gtimer_end
+
+
+/* end of interfaces defined for version 2 */
+
 #ifdef  __cplusplus
 }

trunk/src/VBox/Runtime/r0drv/solaris/vbi/mp-r0drv-solaris.c

@@ -229 +229 @@
     RTCPUID idCpu = RTMpCpuId();
 
-    Assert(idCpu != pArgs->idCpu);
+    Assert(idCpu == pArgs->idCpu);
     pArgs->pfnWorker(idCpu, pArgs->pvUser1, pArgs->pvUser2);
     ASMAtomicIncU32(&pArgs->cHits);

trunk/src/VBox/Runtime/r0drv/solaris/vbi/mpnotification-r0drv-solaris.c

@@ -36 +36 @@
 
 #include <iprt/mp.h>
+#include <iprt/err.h>
 #include "r0drv/mp-r0drv.h"
 
 
-static int rtMpNotificationSolarisCallback(cpu_setup_t enmSolarisEvent, int iCpu, void *pvUser)
+static void rtMpNotificationSolarisCallback(void *pvUser, int iCpu, int online)
 {
     NOREF(pvUser);
 
     /* ASSUMES iCpu == RTCPUID */
-    switch (enmSolarisEvent)
-    {
-        case CPU_INIT:
-        case CPU_CONFIG:
-        case CPU_UNCONFIG:
-            break;
-
-        case CPU_ON:
-            rtMpNotificationDoCallbacks(RTMPEVENT_ONLINE, iCpu);
-            break;
-
-        case CPU_OFF:
-            rtMpNotificationDoCallbacks(RTMPEVENT_OFFLINE, iCpu);
-            break;
-
-        case CPU_CPUPART_IN:
-        case CPU_CPUPART_OUT:
-            /** @todo are these relevant? */
-            break;
-    }
-    return 0;
+    if (online)
+        rtMpNotificationDoCallbacks(RTMPEVENT_ONLINE, iCpu);
+    else
+        rtMpNotificationDoCallbacks(RTMPEVENT_OFFLINE, iCpu);
 }
 
+static vbi_cpu_watch_t *watch_handle = NULL;
 
 int rtR0MpNotificationNativeInit(void)
 {
-    register_cpu_setup_func(rtMpNotificationSolarisCallback, NULL);
+    if (vbi_revision_level < 2)
+        return VERR_NOT_SUPPORTED;
+    if (watch_handle != NULL)
+        return VERR_INVALID_PARAMETER;
+    watch_handle = vbi_watch_cpus(rtMpNotificationSolarisCallback, NULL, 0);
+    return VINF_SUCCESS;
 }
 
@@ -76 +66 @@
 void rtR0MpNotificationNativeTerm(void)
 {
-    unregister_cpu_setup_func(rtMpNotificationSolarisCallback, NULL);
+    if (vbi_revision_level >= 2 && watch_handle != NULL)
+        vbi_ignore_cpus(watch_handle);
+    watch_handle = NULL;
 }
 

trunk/src/VBox/Runtime/r0drv/solaris/vbi/timer-r0drv-solaris.c

@@ -60 +60 @@
     /** Flag indicating the the timer is suspended. */
     uint8_t volatile        fSuspended;
+    /** Run on all CPUs if set */
+    uint8_t                 fAllCpu;
     /** Whether the timer must run on a specific CPU or not. */
     uint8_t                 fSpecificCpu;
     /** The CPU it must run on if fSpecificCpu is set. */
     uint8_t                 iCpu;
-    /** The Solaris timer handle. */
-    void                   *handle;
+    /** The nano second interval for repeating timers */
+    uint64_t                interval;
+    /** simple Solaris timer handle. */
+    vbi_stimer_t            *stimer;
+    /** global Solaris timer handle. */
+    vbi_gtimer_t            *gtimer;
     /** The user callback. */
     PFNRTTIMER              pfnTimer;
-    /** The current tick count. */
-    uint64_t                iTick;
-
+    /** The argument for the user callback. */
+    void                    *pvUser;
 } RTTIMER;
 
 
-/**
- * Callback wrapper for adding the new iTick argument.
- *
- * @param   pTimer  The timer.
- * @param   pvUser  The user argument.
- */
-static void rtTimerSolarisCallbackWrapper(PRTTIMER pTimer, void *pvUser)
-{
-    pTimer->pfnTimer(pTimer, pvUser, ++pTimer->iTick);
+/*
+ * Need a wrapper to get the PRTTIMER passed through
+ */
+static void rtTimerSolarisCallbackWrapper(PRTTIMER pTimer, uint64_t tick)
+{
+    pTimer->pfnTimer(pTimer, pTimer->pvUser, tick);
 }
 
@@ -97 +99 @@
     if (!RTTIMER_FLAGS_ARE_VALID(fFlags))
         return VERR_INVALID_PARAMETER;
+    if (vbi_revision_level < 2)
+        return VERR_NOT_SUPPORTED;
+
     if (    (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC)
-        /** @todo implement &&  (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL*/)
+        &&  (fFlags & RTTIMER_FLAGS_CPU_ALL) != RTTIMER_FLAGS_CPU_ALL
+        &&  !RTMpIsCpuPossible((fFlags & RTTIMER_FLAGS_CPU_MASK)))
+        return VERR_CPU_NOT_FOUND;
+
+    if ((fFlags & RTTIMER_FLAGS_CPU_ALL) == RTTIMER_FLAGS_CPU_ALL && u64NanoInterval == 0)
         return VERR_NOT_SUPPORTED;
 
@@ -110 +119 @@
     pTimer->u32Magic = RTTIMER_MAGIC;
     pTimer->fSuspended = true;
-    pTimer->fSpecificCpu = !!(fFlags & RTTIMER_FLAGS_CPU_SPECIFIC);
-    pTimer->iCpu = fFlags & RTTIMER_FLAGS_CPU_MASK;
-    pTimer->handle = vbi_timer_create(rtTimerSolarisCallbackWrapper, pTimer, pvUser, u64NanoInterval);
+    if ((fFlags & RTTIMER_FLAGS_CPU_ALL) == RTTIMER_FLAGS_CPU_ALL)
+    {
+        pTimer->fAllCpu = true;
+        pTimer->fSpecificCpu = false;
+    }
+    else if (fFlags & RTTIMER_FLAGS_CPU_SPECIFIC)
+    {
+        pTimer->fAllCpu = false;
+        pTimer->fSpecificCpu = true;
+        pTimer->iCpu = fFlags & RTTIMER_FLAGS_CPU_MASK;
+    }
+    pTimer->interval = u64NanoInterval;
     pTimer->pfnTimer = pfnTimer;
-    pTimer->iTick = 0;
+    pTimer->pvUser = pvUser;
+    pTimer->stimer = NULL;
+    pTimer->gtimer = NULL;
 
     *ppTimer = pTimer;
@@ -145 +165 @@
      * Free the associated resources.
      */
+    RTTimerStop(pTimer);
     pTimer->u32Magic++;
-    vbi_timer_stop(pTimer->handle);
-    vbi_timer_destroy(pTimer->handle);
     RTMemFree(pTimer);
     return VINF_SUCCESS;
@@ -155 +174 @@
 RTDECL(int) RTTimerStart(PRTTIMER pTimer, uint64_t u64First)
 {
+    int cpu = VBI_ANY_CPU;
+
     if (!rtTimerIsValid(pTimer))
         return VERR_INVALID_HANDLE;
@@ -160 +181 @@
         return VERR_TIMER_ACTIVE;
 
-    /*
-     * Calc when it should start firing.
-     */
     pTimer->fSuspended = false;
-    vbi_timer_start(pTimer->handle, u64First);
+    if (pTimer->fAllCpu)
+    {
+        pTimer->gtimer = vbi_gtimer_begin(rtTimerSolarisCallbackWrapper, pTimer, u64First, pTimer->interval);
+        if (pTimer->gtimer == NULL)
+            return VERR_INVALID_PARAMETER;
+    }
+    else
+    {
+        if (pTimer->fSpecificCpu)
+            cpu = pTimer->iCpu;
+        pTimer->stimer = vbi_stimer_begin(rtTimerSolarisCallbackWrapper, pTimer, u64First, pTimer->interval, cpu);
+        if (pTimer->stimer == NULL)
+        {
+            if (cpu != VBI_ANY_CPU)
+                return VERR_CPU_OFFLINE;
+            return VERR_INVALID_PARAMETER;
+        }
+    }
 
     return VINF_SUCCESS;
@@ -177 +212 @@
         return VERR_TIMER_SUSPENDED;
 
-    /*
-     * Suspend the timer.
-     */
     pTimer->fSuspended = true;
-    vbi_timer_stop(pTimer->handle);
+    if (pTimer->stimer)
+    {
+        vbi_stimer_end(pTimer->stimer);
+        pTimer->stimer = NULL;
+    }
+    else if (pTimer->gtimer)
+    {
+        vbi_gtimer_end(pTimer->gtimer);
+        pTimer->gtimer = NULL;
+    }
 
     return VINF_SUCCESS;