Changeset 16720 in vbox

Timestamp:

Feb 13, 2009 12:32:05 AM (16 years ago)

Author:

vboxsync

Message:

handle upcoming xc_call() change and can build as part of VirtualBox

Location:

trunk/src/VBox/Runtime/r0drv/solaris/vbi

Files:

• 32/vbi (modified) ( previous)
• 64/vbi (modified) ( previous)
• i86pc/os/vbi.c (modified) (36 diffs)
• i86pc/sys/vbi.h (modified) (1 diff)

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

@@ -55 +55 @@
 #include <sys/sunddi.h>
 #include <sys/modctl.h>
-
-#include <sys/vbi.h>
-
-/*
- * If we are running on an old version of Solaris, then
- * we have to use dl_lookup to find contig_free().
+#include <sys/machparam.h>
+
+#include "vbi.h"
+
+/*
+ * We have to use dl_lookup to find contig_free().
  */
 extern void *contig_alloc(size_t, ddi_dma_attr_t *, uintptr_t, int);
@@ -68 +68 @@
 
 /*
- * Workarounds for running on old versions of solaris with lower NCPU.
- * If we detect this, the assumption is that NCPU was such that a cpuset_t
- * is just a ulong_t
- */
-static int use_old_xc_call = 0;
+ * Workarounds for running on old versions of solaris with different cross call
+ * interfaces. If we find xc_init_cpu() in the kenel, then just use the defined
+ * interfaces for xc_call() from the include file where the xc_call()
+ * interfaces just takes a pointer to a ulong_t array. The array must be long
+ * enough to hold "ncpus" bits at runtime.
+
+ * The reason for the hacks is that using the type "cpuset_t" is pretty much
+ * impossible from code built outside the Solaris source repository that wants
+ * to run on multiple releases of Solaris.
+ *
+ * For old style xc_call()s, 32 bit solaris and older 64 bit versions use
+ * "ulong_t" as cpuset_t.
+ *
+ * Later versions of 64 bit Solaris used: struct {ulong_t words[x];}
+ * where "x" depends on NCPU.
+ *
+ * We detect the difference in 64 bit support by checking the kernel value of
+ * max_cpuid, which always holds the compiled value of NCPU - 1.
+ *
+ * If Solaris increases NCPU to more than 256, this module will continue
+ * to work on all versions of Solaris as long as the number of installed
+ * CPUs in the machine is <= VBI_NCPU. If VBI_NCPU is increased, this code
+ * has to be re-written some to provide compatibility with older Solaris which
+ * expects cpuset_t to be based on NCPU==256 -- or we discontinue support
+ * of old Nevada/S10.
+ */
+static int use_old = 0;
+static int use_old_with_ulong = 0;
 static void (*p_xc_call)() = (void (*)())xc_call;
-#pragma weak cpuset_all
-#pragma weak cpuset_all_but
-#pragma weak cpuset_only
-
+
+#define VBI_NCPU        256
+#define VBI_SET_WORDS   (VBI_NCPU / (sizeof (ulong_t) * 8))
+typedef struct vbi_cpuset {
+        ulong_t words[VBI_SET_WORDS];
+} vbi_cpuset_t;
+#define X_CALL_HIPRI    (2)     /* for old Solaris interface */
+
+/*
+ * module linkage stuff
+ */
 static struct modlmisc vbi_modlmisc = {
         &mod_miscops, "VirtualBox Interfaces V3"
@@ -86 +116 @@
 };
 
+extern uintptr_t kernelbase;
 #define IS_KERNEL(v)    ((uintptr_t)(v) >= kernelbase)
+
+static int vbi_verbose = 0;
+
+#define VBI_VERBOSE(msg) {if (vbi_verbose) cmn_err(CE_WARN, msg);}
 
 int
@@ -95 +130 @@
         /*
          * Check to see if this version of virtualbox interface module will work
-         * with the kernel. The sizeof (cpuset_t) is problematic, as it changed
-         * with the change to NCPU in nevada build 87 and S10U6.
+         * with the kernel.
          */
-        if (max_cpuid + 1 != NCPU)
-                use_old_xc_call = 1;
+        if (kobj_getsymvalue("xc_init_cpu", 1) != NULL) {
+                /*
+                 * Our bit vector storage needs to be large enough for the
+                 * actual number of CPUs running in the sytem.
+                 */
+                if (ncpus > VBI_NCPU)
+                        return (EINVAL);
+        } else {
+                use_old = 1;
+                if (max_cpuid + 1 == sizeof(ulong_t) * 8)
+                        use_old_with_ulong = 1;
+                else if (max_cpuid + 1 != VBI_NCPU)
+                        return (EINVAL);        /* cpuset_t size mismatch */
+        }
 
         /*
@@ -141 +187 @@
         (uint64_t)0,            /* high limit */
         (uint64_t)0xffffffff,   /* counter limit */
-        (uint64_t)MMU_PAGESIZE, /* alignment */
-        (uint64_t)MMU_PAGESIZE, /* burst size */
-        (uint64_t)MMU_PAGESIZE, /* effective DMA size */
+        (uint64_t)PAGESIZE,     /* pagesize alignment */
+        (uint64_t)PAGESIZE,     /* pagesize burst size */
+        (uint64_t)PAGESIZE,     /* pagesize effective DMA size */
         (uint64_t)0xffffffff,   /* max DMA xfer size */
         (uint64_t)0xffffffff,   /* segment boundary */
@@ -158 +204 @@
         void *ptr;
 
-        if ((size & MMU_PAGEOFFSET) != 0)
+        if ((size & PAGEOFFSET) != 0)
                 return (NULL);
 
         attr = base_attr;
         attr.dma_attr_addr_hi = *phys;
-        ptr = contig_alloc(size, &attr, MMU_PAGESIZE, 1);
-
-        if (ptr == NULL)
+        ptr = contig_alloc(size, &attr, PAGESIZE, 1);
+
+        if (ptr == NULL) {
+                VBI_VERBOSE("vbi_contig_alloc() failure");
                 return (NULL);
+        }
 
         pfn = hat_getpfnum(kas.a_hat, (caddr_t)ptr);
         if (pfn == PFN_INVALID)
                 panic("vbi_contig_alloc(): hat_getpfnum() failed\n");
-        *phys = (uint64_t)pfn << MMU_PAGESHIFT;
+        *phys = (uint64_t)pfn << PAGESHIFT;
         return (ptr);
 }
@@ -186 +234 @@
         caddr_t va;
 
-        if ((pa & MMU_PAGEOFFSET) || (size & MMU_PAGEOFFSET))
+        if ((pa & PAGEOFFSET) || (size & PAGEOFFSET)) {
+                VBI_VERBOSE("vbi_kernel_map() bad pa or size");
                 return (NULL);
+        }
 
         va = vmem_alloc(heap_arena, size, VM_SLEEP);
 
-        hat_devload(kas.a_hat, va, size, (pfn_t)(pa >> MMU_PAGESHIFT),
+        hat_devload(kas.a_hat, va, size, (pfn_t)(pa >> PAGESHIFT),
             prot, HAT_LOAD | HAT_LOAD_LOCK | HAT_UNORDERED_OK);
 
@@ -379 +429 @@
 vbi_max_cpu_id(void)
 {
-        return (NCPU - 1);
+        return (max_cpuid);
 }
 
@@ -385 +435 @@
 vbi_cpu_maxcount(void)
 {
-        return (NCPU);
+        return (max_cpuid + 1);
 }
 
@@ -420 +470 @@
 vbi_execute_on_all(void *func, void *arg)
 {
-        cpuset_t set;
-        ulong_t hack_set;
+        vbi_cpuset_t set;
         int i;
 
+        for (i = 0; i < VBI_SET_WORDS; ++i)
+                set.words[i] = (ulong_t)-1L;
+        if (use_old) {
+                if (use_old_with_ulong) {
+                        p_xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI,
+                            set.words[0], (xc_func_t)func);
+                } else {
+                        p_xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI,
+                            set, (xc_func_t)func);
+                }
+        } else {
+                xc_call((xc_arg_t)arg, 0, 0, &set.words[0], (xc_func_t)func);
+        }
+}
+
+void
+vbi_execute_on_others(void *func, void *arg)
+{
+        vbi_cpuset_t set;
+        int i;
+
+        for (i = 0; i < VBI_SET_WORDS; ++i)
+                set.words[i] = (ulong_t)-1L;
+        BT_CLEAR(set.words, vbi_cpu_id());
+        if (use_old) {
+                if (use_old_with_ulong) {
+                        p_xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI,
+                            set.words[0], (xc_func_t)func);
+                } else {
+                        p_xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI,
+                            set, (xc_func_t)func);
+                }
+        } else {
+                xc_call((xc_arg_t)arg, 0, 0, &set.words[0], (xc_func_t)func);
+        }
+}
+
+void
+vbi_execute_on_one(void *func, void *arg, int c)
+{
+        vbi_cpuset_t set;
+        int i;
+
+        for (i = 0; i < VBI_SET_WORDS; ++i)
+                set.words[i] = 0;
+        BT_SET(set.words, vbi_cpu_id());
+        if (use_old) {
+                if (use_old_with_ulong) {
+                        p_xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI,
+                            set.words[0], (xc_func_t)func);
+                } else {
+                        p_xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI,
+                            set, (xc_func_t)func);
+                }
+        } else {
+                xc_call((xc_arg_t)arg, 0, 0, &set.words[0], (xc_func_t)func);
+        }
+}
+
+int
+vbi_lock_va(void *addr, size_t len, void **handle)
+{
+        faultcode_t err;
+
         /*
-         * hack for a kernel compiled with the different NCPU than this module
+         * kernel mappings on x86 are always locked, so only handle user.
          */
-        ASSERT(curthread->t_preempt >= 1);
-        if (use_old_xc_call) {
-                hack_set = 0;
-                for (i = 0; i < ncpus; ++i)
-                        hack_set |= 1ul << i;
-                p_xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI, hack_set,
-                    (xc_func_t)func);
-        } else {
-                CPUSET_ALL(set);
-                xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI, set,
-                    (xc_func_t)func);
-        }
-}
-
-void
-vbi_execute_on_others(void *func, void *arg)
-{
-        cpuset_t set;
-        ulong_t hack_set;
-        int i;
-
-        /*
-         * 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 |= 1ul << i;
+        *handle = NULL;
+        if (!IS_KERNEL(addr)) {
+                err = as_fault(curproc->p_as->a_hat, curproc->p_as,
+                    (caddr_t)addr, len, F_SOFTLOCK, S_WRITE);
+                if (err != 0) {
+                        VBI_VERBOSE("vbi_lock_va() failed to lock");
+                        return (-1);
                 }
-                p_xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI, hack_set,
-                    (xc_func_t)func);
-        } else {
-                CPUSET_ALL_BUT(set, CPU->cpu_id);
-                xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI, set,
-                    (xc_func_t)func);
-        }
-}
-
-void
-vbi_execute_on_one(void *func, void *arg, int c)
-{
-        cpuset_t set;
-        ulong_t hack_set;
-
-        /*
-         * hack for a kernel compiled with the different NCPU than this module
-         */
-        ASSERT(curthread->t_preempt >= 1);
-        if (use_old_xc_call) {
-                hack_set = 1ul << c;
-                p_xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI, hack_set,
-                    (xc_func_t)func);
-        } else {
-                CPUSET_ONLY(set, c);
-                xc_call((xc_arg_t)arg, 0, 0, X_CALL_HIPRI, set,
-                    (xc_func_t)func);
-        }
-}
-
-int
-vbi_lock_va(void *addr, size_t len, void **handle)
-{
-        page_t **ppl;
-        int rc = 0;
-
-        if (IS_KERNEL(addr)) {
-                /* kernel mappings on x86 are always locked */
-                *handle = NULL;
-        } else {
-                rc = as_pagelock(curproc->p_as, &ppl, (caddr_t)addr, len,
-                    S_WRITE);
-                if (rc != 0)
-                        return (rc);
-                *handle = (void *)ppl;
-        }
-        return (rc);
-}
-
+        }
+        return (0);
+}
+
+/*ARGSUSED*/
 void
 vbi_unlock_va(void *addr, size_t len, void *handle)
 {
-        page_t **ppl = (page_t **)handle;
-
-        if (IS_KERNEL(addr))
-                ASSERT(handle == NULL);
-        else
-                as_pageunlock(curproc->p_as, ppl, (caddr_t)addr, len, S_WRITE);
+        if (!IS_KERNEL(addr))
+                as_fault(curproc->p_as->a_hat, curproc->p_as, (caddr_t)addr,
+                    len, F_SOFTUNLOCK, S_WRITE);
 }
 
@@ -529 +572 @@
         else
                 hat = curproc->p_as->a_hat;
-        pfn = hat_getpfnum(hat, (caddr_t)(v & MMU_PAGEMASK));
+        pfn = hat_getpfnum(hat, (caddr_t)(v & PAGEMASK));
         if (pfn == PFN_INVALID)
                 return (-(uint64_t)1);
-        return (((uint64_t)pfn << MMU_PAGESHIFT) | (v & MMU_PAGEOFFSET));
+        return (((uint64_t)pfn << PAGESHIFT) | (v & PAGEOFFSET));
 }
 
@@ -569 +612 @@
          */
         va = seg->s_base;
-        ASSERT(((uintptr_t)va & MMU_PAGEOFFSET) == 0);
-        pgcnt = seg->s_size >> MMU_PAGESHIFT;
-        for (p = 0; p < pgcnt; ++p, va += MMU_PAGESIZE) {
-                ASSERT((a->palist[p] & MMU_PAGEOFFSET) == 0);
+        pgcnt = seg->s_size >> PAGESHIFT;
+        for (p = 0; p < pgcnt; ++p, va += PAGESIZE) {
                 hat_devload(as->a_hat, va,
-                    MMU_PAGESIZE, a->palist[p] >> MMU_PAGESHIFT,
+                    PAGESIZE, a->palist[p] >> PAGESHIFT,
                     data->prot | HAT_UNORDERED_OK, HAT_LOAD | HAT_LOAD_LOCK);
         }
@@ -598 +639 @@
 }
 
-/*ARGSUSED*/
 static int
 segvbi_unmap(struct seg *seg, caddr_t addr, size_t len)
 {
         if (addr < seg->s_base || addr + len > seg->s_base + seg->s_size ||
-            (len & MMU_PAGEOFFSET) || ((uintptr_t)addr & MMU_PAGEOFFSET))
+            (len & PAGEOFFSET) || ((uintptr_t)addr & PAGEOFFSET))
                 panic("segvbi_unmap");
 
@@ -626 +666 @@
  * We never demand-fault for seg_vbi.
  */
-/*ARGSUSED*/
 static int
 segvbi_fault(struct hat *hat, struct seg *seg, caddr_t addr, size_t len,
@@ -634 +673 @@
 }
 
-/*ARGSUSED*/
 static int
 segvbi_faulta(struct seg *seg, caddr_t addr)
@@ -641 +679 @@
 }
 
-/*ARGSUSED*/
 static int
 segvbi_setprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
@@ -648 +685 @@
 }
 
-/*ARGSUSED*/
 static int
 segvbi_checkprot(struct seg *seg, caddr_t addr, size_t len, uint_t prot)
@@ -655 +691 @@
 }
 
-/*ARGSUSED*/
 static int
 segvbi_kluster(struct seg *seg, caddr_t addr, ssize_t delta)
@@ -662 +697 @@
 }
 
-/*ARGSUSED*/
 static int
 segvbi_sync(struct seg *seg, caddr_t addr, size_t len, int attr, uint_t flags)
@@ -669 +703 @@
 }
 
-/*ARGSUSED*/
 static size_t
 segvbi_incore(struct seg *seg, caddr_t addr, size_t len, char *vec)
@@ -675 +708 @@
         size_t v;
 
-        for (v = 0, len = (len + MMU_PAGEOFFSET) & MMU_PAGEMASK; len;
-            len -= MMU_PAGESIZE, v += MMU_PAGESIZE)
+        for (v = 0, len = (len + PAGEOFFSET) & PAGEMASK; len;
+            len -= PAGESIZE, v += PAGESIZE)
                 *vec++ = 1;
         return (v);
 }
 
-/*ARGSUSED*/
 static int
 segvbi_lockop(struct seg *seg, caddr_t addr,
@@ -689 +721 @@
 }
 
-/*ARGSUSED*/
 static int
 segvbi_getprot(struct seg *seg, caddr_t addr, size_t len, uint_t *protv)
@@ -703 +734 @@
 }
 
-/*ARGSUSED*/
 static int
 segvbi_gettype(struct seg *seg, caddr_t addr)
@@ -712 +742 @@
 static vnode_t vbivp;
 
-/*ARGSUSED*/
 static int
 segvbi_getvp(struct seg *seg, caddr_t addr, struct vnode **vpp)
@@ -720 +749 @@
 }
 
-/*ARGSUSED*/
 static int
 segvbi_advise(struct seg *seg, caddr_t addr, size_t len, uint_t behav)
@@ -727 +755 @@
 }
 
-/*ARGSUSED*/
 static void
 segvbi_dump(struct seg *seg)
 {}
 
-/*ARGSUSED*/
 static int
 segvbi_pagelock(struct seg *seg, caddr_t addr, size_t len,
@@ -740 +766 @@
 }
 
-/*ARGSUSED*/
 static int
 segvbi_setpagesize(struct seg *seg, caddr_t addr, size_t len, uint_t szc)
@@ -747 +772 @@
 }
 
-/*ARGSUSED*/
 static int
 segvbi_getmemid(struct seg *seg, caddr_t addr, memid_t *memid)
@@ -754 +778 @@
 }
 
-/*ARGSUSED*/
 static lgrp_mem_policy_info_t *
 segvbi_getpolicy(struct seg *seg, caddr_t addr)
@@ -761 +784 @@
 }
 
-/*ARGSUSED*/
 static int
 segvbi_capable(struct seg *seg, segcapability_t capability)
@@ -811 +833 @@
         as_rangelock(as);
         map_addr(va, len, 0, 0, MAP_SHARED);
-        ASSERT(((uintptr_t)*va & MMU_PAGEOFFSET) == 0);
-        ASSERT((len & MMU_PAGEOFFSET) == 0);
-        ASSERT(len != 0);
         if (*va != NULL)
                 error = as_map(as, *va, len, segvbi_create, &args);
         else
                 error = ENOMEM;
+        if (error)
+                VBI_VERBOSE("vbi_user_map() failed");
         as_rangeunlock(as);
         return (error);
@@ -906 +927 @@
 {
         vbi_stimer_t *t = kmem_zalloc(sizeof (*t), KM_SLEEP);
-
-        ASSERT(when < INT64_MAX);
-        ASSERT(interval < INT64_MAX);
-        ASSERT(interval + when < INT64_MAX);
-        ASSERT(on_cpu == VBI_ANY_CPU || on_cpu < ncpus);
 
         t->s_handler.cyh_func = vbi_stimer_func;
@@ -942 +958 @@
 vbi_stimer_end(vbi_stimer_t *t)
 {
-        ASSERT(t->s_cyclic != CYCLIC_NONE);
         mutex_enter(&cpu_lock);
         cyclic_remove(t->s_cyclic);
@@ -966 +981 @@
 {
         vbi_gtimer_t *t = arg;
-        t->g_func(t->g_arg, ++t->g_counters[CPU->cpu_id]);
+        t->g_func(t->g_arg, ++t->g_counters[vbi_cpu_id()]);
 }
 
@@ -1007 +1022 @@
                 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);
@@ -1032 +1043 @@
 vbi_gtimer_end(vbi_gtimer_t *t)
 {
-        ASSERT(t->g_cyclic != CYCLIC_NONE);
         mutex_enter(&cpu_lock);
         cyclic_remove(t->g_cyclic);

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

@@ -37 +37 @@
  * to hypervisor boundary. (void *) is for handles and function and other
  * pointers. uint64 for physical addresses, size_t and int elsewhere.
+ * The goal is for this module to eventually be part of OpenSolaris once
+ * interfaces have become more stable.
  */