r0drv/solaris/memobj-r0drv-solaris.c

	memobj-r0drv-solaris.c revision 43d5e45fa237a3eebb3e624d67a0eaf21502c336
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync/* $Id$ */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync/** @file
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync * IPRT - Ring-0 Memory Objects, Solaris.
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync/*
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * Copyright (C) 2006-2007 Sun Microsystems, Inc.
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync *
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * This file is part of VirtualBox Open Source Edition (OSE), as
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * available from http://www.virtualbox.org. This file is free software;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * you can redistribute it and/or modify it under the terms of the GNU
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * General Public License (GPL) as published by the Free Software
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * Foundation, in version 2 as it comes in the "COPYING" file of the
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync *
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * The contents of this file may alternatively be used under the terms
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * of the Common Development and Distribution License Version 1.0
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * (CDDL) only, as it comes in the "COPYING.CDDL" file of the
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * VirtualBox OSE distribution, in which case the provisions of the
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * CDDL are applicable instead of those of the GPL.
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync *
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * You may elect to license modified versions of this file under the
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * terms and conditions of either the GPL or the CDDL or both.
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync *
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * Clara, CA 95054 USA or visit http://www.sun.com if you need
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync * additional information or have any questions.
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync/*******************************************************************************
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync*   Header Files                                                               *
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync*******************************************************************************/
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync#include "the-solaris-kernel.h"
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync#include <iprt/memobj.h>
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync#include <iprt/mem.h>
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync#include <iprt/err.h>
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync#include <iprt/assert.h>
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync#include <iprt/log.h>
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync#include <iprt/param.h>
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync#include <iprt/process.h>
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync#include "internal/memobj.h"
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync/*******************************************************************************
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync*   Structures and Typedefs                                                    *
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync*******************************************************************************/
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync/**
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync * The Solaris version of the memory object structure.
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync */
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsynctypedef struct RTR0MEMOBJSOLARIS
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync{
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    /** The core structure. */
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    RTR0MEMOBJINTERNAL  Core;
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    /** Pointer to kernel memory cookie. */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    ddi_umem_cookie_t   Cookie;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    /** Shadow locked pages. */
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync    page_t              **ppShadowPages;
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync} RTR0MEMOBJSOLARIS, *PRTR0MEMOBJSOLARIS;
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync/**
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync * Used for supplying the solaris kernel info. about memory limits
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync * during contiguous allocations (i_ddi_mem_alloc)
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync */
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsyncstruct ddi_dma_attr g_SolarisX86PhysMemLimits =
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync{
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync    DMA_ATTR_V0,            /* Version Number */
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync    (uint64_t)0,            /* lower limit */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    (uint64_t)0xffffffff,   /* high limit (32-bit PA, 4G) */
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync    (uint64_t)0xffffffff,   /* counter limit */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    (uint64_t)PAGE_SIZE,    /* alignment */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    (uint64_t)PAGE_SIZE,    /* burst size */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    (uint64_t)PAGE_SIZE,    /* effective DMA size */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    (uint64_t)0xffffffff,   /* max DMA xfer size */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    (uint64_t)0xffffffff,   /* segment boundary */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    1,                      /* scatter-gather list length (1 for contiguous) */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    1,                      /* device granularity */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    0                       /* bus-specific flags */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync};
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsyncstatic uint64_t rtR0MemObjSolarisVirtToPhys(struct hat* hatSpace, caddr_t virtAddr)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync{
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    /* We could use paddr_t (more solaris-like) rather than uint64_t but paddr_t isn't defined for 64-bit */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    pfn_t pfn = hat_getpfnum(hatSpace, virtAddr);
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync    if (pfn == PFN_INVALID)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    {
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        AssertMsgFailed(("rtR0MemObjSolarisVirtToPhys: hat_getpfnum for %p failed.\n", virtAddr));
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        return PFN_INVALID;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    }
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    /* Both works, but second will work for non-page aligned virtAddr */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync#if 0
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    uint64_t physAddr = PAGE_SIZE * pfn;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync#else
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    uint64_t physAddr = ((uint64_t)pfn << MMU_PAGESHIFT) | ((uintptr_t)virtAddr & MMU_PAGEOFFSET);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync#endif
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    return physAddr;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync}
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsyncint rtR0MemObjNativeFree(RTR0MEMOBJ pMem)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync{
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    PRTR0MEMOBJSOLARIS pMemSolaris = (PRTR0MEMOBJSOLARIS)pMem;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    switch (pMemSolaris->Core.enmType)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    {
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync        case RTR0MEMOBJTYPE_CONT:
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            i_ddi_mem_free(pMemSolaris->Core.pv, NULL);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            break;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        case RTR0MEMOBJTYPE_PAGE:
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            ddi_umem_free(pMemSolaris->Cookie);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            break;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync        case RTR0MEMOBJTYPE_LOCK:
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        {
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            struct as *addrSpace;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            if (pMemSolaris->Core.u.Lock.R0Process == NIL_RTR0PROCESS)
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync                addrSpace = &kas;
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync            else
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync                addrSpace = ((proc_t *)pMemSolaris->Core.u.Lock.R0Process)->p_as;
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync            as_pageunlock(addrSpace, pMemSolaris->ppShadowPages, pMemSolaris->Core.pv, pMemSolaris->Core.cb, S_WRITE);
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync            break;
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync        }
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync        case RTR0MEMOBJTYPE_MAPPING:
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync        {
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync            struct hat *hatSpace;
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync            struct as *addrSpace;
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync            if (pMemSolaris->Core.u.Mapping.R0Process == NIL_RTR0PROCESS)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            {
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync                /* Kernel process*/
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync                hatSpace = kas.a_hat;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync                addrSpace = &kas;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            }
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            else
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            {
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync                /* User process */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync                proc_t *userProc = (proc_t *)pMemSolaris->Core.u.Mapping.R0Process;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync                hatSpace = userProc->p_as->a_hat;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync                addrSpace = userProc->p_as;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            }
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            rw_enter(&addrSpace->a_lock, RW_READER);
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync            hat_unload(hatSpace, pMemSolaris->Core.pv, pMemSolaris->Core.cb, HAT_UNLOAD_UNLOCK);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            rw_exit(&addrSpace->a_lock);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            as_unmap(addrSpace, pMemSolaris->Core.pv, pMemSolaris->Core.cb);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            break;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        }
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync        /* unused */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        case RTR0MEMOBJTYPE_LOW:
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        case RTR0MEMOBJTYPE_PHYS:
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync        case RTR0MEMOBJTYPE_RES_VIRT:
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync        default:
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            AssertMsgFailed(("enmType=%d\n", pMemSolaris->Core.enmType));
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            return VERR_INTERNAL_ERROR;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    }
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    return VINF_SUCCESS;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync}
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsyncint rtR0MemObjNativeAllocPage(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync{
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    /* Create the object */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    PRTR0MEMOBJSOLARIS pMemSolaris = (PRTR0MEMOBJSOLARIS)rtR0MemObjNew(sizeof(*pMemSolaris), RTR0MEMOBJTYPE_PAGE, NULL, cb);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    if (!pMemSolaris)
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync        return VERR_NO_MEMORY;
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    void *virtAddr = ddi_umem_alloc(cb, DDI_UMEM_SLEEP, &pMemSolaris->Cookie);
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    if (!virtAddr)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    {
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        rtR0MemObjDelete(&pMemSolaris->Core);
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync        return VERR_NO_PAGE_MEMORY;
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    }
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    pMemSolaris->Core.pv = virtAddr;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    pMemSolaris->ppShadowPages = NULL;
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    *ppMem = &pMemSolaris->Core;
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync    return VINF_SUCCESS;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync}
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsyncint rtR0MemObjNativeAllocLow(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync{
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    /* Try page alloc first */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    int rc = rtR0MemObjNativeAllocPage(ppMem, cb, fExecutable);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    if (RT_SUCCESS(rc))
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    {
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync        size_t iPage = cb >> PAGE_SHIFT;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        while (iPage-- > 0)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            if (rtR0MemObjNativeGetPagePhysAddr(*ppMem, iPage) > (_4G - PAGE_SIZE))
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync            {
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync                /* Failed! Fall back to physical contiguous alloc */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync                RTR0MemObjFree(*ppMem, false);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync                rc = rtR0MemObjNativeAllocCont(ppMem, cb, fExecutable);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync                break;
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync            }
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    }
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    return rc;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync}
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsyncint rtR0MemObjNativeAllocCont(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, bool fExecutable)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync{
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    NOREF(fExecutable);
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    /* Create the object */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    PRTR0MEMOBJSOLARIS pMemSolaris = (PRTR0MEMOBJSOLARIS)rtR0MemObjNew(sizeof(*pMemSolaris), RTR0MEMOBJTYPE_CONT, NULL, cb);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    if (!pMemSolaris)
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync        return VERR_NO_MEMORY;
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync    /* Allocate physically contiguous page-aligned memory. */
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync    caddr_t virtAddr;
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync    int rc = i_ddi_mem_alloc(NULL, &g_SolarisX86PhysMemLimits, cb, 1, 0, NULL, &virtAddr, NULL, NULL);
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync    if (rc != DDI_SUCCESS)
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync    {
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync        rtR0MemObjDelete(&pMemSolaris->Core);
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync        return VERR_NO_CONT_MEMORY;
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync    }
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    pMemSolaris->Core.pv = virtAddr;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    pMemSolaris->Core.u.Cont.Phys = rtR0MemObjSolarisVirtToPhys(kas.a_hat, virtAddr);
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    pMemSolaris->ppShadowPages = NULL;
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    *ppMem = &pMemSolaris->Core;
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync    return VINF_SUCCESS;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync}
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsyncint rtR0MemObjNativeAllocPhysNC(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync{
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    /** @todo rtR0MemObjNativeAllocPhysNC / solaris */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    return VERR_NOT_SUPPORTED; /* see the RTR0MemObjAllocPhysNC specs */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync}
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsyncint rtR0MemObjNativeAllocPhys(PPRTR0MEMOBJINTERNAL ppMem, size_t cb, RTHCPHYS PhysHighest)
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync{
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    AssertMsgReturn(PhysHighest >= 16 *_1M, ("PhysHigest=%VHp\n", PhysHighest), VERR_NOT_IMPLEMENTED);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    return rtR0MemObjNativeAllocCont(ppMem, cb, false);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync}
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsyncint rtR0MemObjNativeEnterPhys(PPRTR0MEMOBJINTERNAL ppMem, RTHCPHYS Phys, size_t cb)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync{
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    /* Create the object */
6a30d0e9d748ecb8a0c62b4233a97fed255a8a4cvboxsync    PRTR0MEMOBJSOLARIS pMemSolaris = (PRTR0MEMOBJSOLARIS)rtR0MemObjNew(sizeof(*pMemSolaris), RTR0MEMOBJTYPE_PHYS, NULL, cb);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    if (!pMemSolaris)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        return VERR_NO_MEMORY;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    /* There is no allocation here, it needs to be mapped somewhere first */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    pMemSolaris->Core.u.Phys.fAllocated = false;
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    pMemSolaris->Core.u.Phys.PhysBase = Phys;
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    *ppMem = &pMemSolaris->Core;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    return VINF_SUCCESS;
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync}
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsyncint rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync{
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    AssertReturn(R0Process == RTR0ProcHandleSelf(), VERR_INVALID_PARAMETER);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    /* Create the locking object */
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    PRTR0MEMOBJSOLARIS pMemSolaris = (PRTR0MEMOBJSOLARIS)rtR0MemObjNew(sizeof(*pMemSolaris), RTR0MEMOBJTYPE_LOCK, (void *)R3Ptr, cb);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    if (!pMemSolaris)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        return VERR_NO_MEMORY;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    proc_t *userproc = (proc_t *)R0Process;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    struct as *useras = userproc->p_as;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    page_t **ppl;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    /* Lock down user pages */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    int rc = as_pagelock(useras, &ppl, (caddr_t)R3Ptr, cb, S_WRITE);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    if (!rc)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    {
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        if (ppl)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        {
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            pMemSolaris->Core.u.Lock.R0Process = (RTR0PROCESS)userproc;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync            pMemSolaris->ppShadowPages = ppl;
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync            *ppMem = &pMemSolaris->Core;
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync            return VINF_SUCCESS;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        }
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        as_pageunlock(useras, ppl, (caddr_t)R3Ptr, cb, S_WRITE);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        cmn_err(CE_NOTE, "rtR0MemObjNativeLockUser: as_pagelock failed to get shadow pages\n");
9148e7ca5f9ee1d467112d347bfb2de2b97254d2vboxsync    }
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    else
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        cmn_err(CE_NOTE,"rtR0MemObjNativeLockUser: as_pagelock failed rc=%d\n", rc);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    rtR0MemObjDelete(pMemSolaris);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    return VERR_LOCK_FAILED;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync}
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsyncint rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync{
32ded45b3caba42c8a2315a20bbfabb513fa54c1vboxsync    /* Create the locking object */
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    PRTR0MEMOBJSOLARIS pMemSolaris = (PRTR0MEMOBJSOLARIS)rtR0MemObjNew(sizeof(*pMemSolaris), RTR0MEMOBJTYPE_LOCK, pv, cb);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    if (!pMemSolaris)
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync        return VERR_NO_MEMORY;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    caddr_t virtAddr = (caddr_t)((uintptr_t)pv & (uintptr_t)PAGEMASK);
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    page_t **ppl;
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync
dc23707aec4dc2ce2c6b6f51af21eef72bb8bf2evboxsync    /* Lock down kernel pages */
    int rc = as_pagelock(&kas, &ppl, virtAddr, cb, S_WRITE);
    if (rc != 0)
    {
        cmn_err(CE_NOTE,"rtR0MemObjNativeLockKernel: as_pagelock failed rc=%d\n", rc);
        return VERR_LOCK_FAILED;
    }

    if (!ppl)
    {
        as_pageunlock(&kas, ppl, virtAddr, cb, S_WRITE);
        cmn_err(CE_NOTE, "rtR0MemObjNativeLockKernel: failed to get shadow pages\n");
        return VERR_LOCK_FAILED;
    }

    pMemSolaris->Core.u.Lock.R0Process = NIL_RTR0PROCESS;   /* means kernel, see rtR0MemObjNativeFree() */
    pMemSolaris->ppShadowPages = ppl;
    *ppMem = &pMemSolaris->Core;
    return VINF_SUCCESS;
}


int rtR0MemObjNativeReserveKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pvFixed, size_t cb, size_t uAlignment)
{
    return VERR_NOT_IMPLEMENTED;
}


int rtR0MemObjNativeReserveUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3PtrFixed, size_t cb, size_t uAlignment, RTR0PROCESS R0Process)
{
    return VERR_NOT_IMPLEMENTED;
}

int rtR0MemObjNativeMapKernel(PPRTR0MEMOBJINTERNAL ppMem, RTR0MEMOBJ pMemToMap, void *pvFixed, size_t uAlignment, unsigned fProt)
{
    PRTR0MEMOBJSOLARIS pMemToMapSolaris = (PRTR0MEMOBJSOLARIS)pMemToMap;
    size_t size = pMemToMapSolaris->Core.cb;
    void *pv = pMemToMapSolaris->Core.pv;
    pgcnt_t cPages = btop(size);
    pgcnt_t iPage;
    caddr_t addr;
    int rc;

    /* Create the mapping object */
    PRTR0MEMOBJSOLARIS pMemSolaris = (PRTR0MEMOBJSOLARIS)rtR0MemObjNew(sizeof(*pMemSolaris), RTR0MEMOBJTYPE_MAPPING, pv, size);
    if (!pMemSolaris)
        return VERR_NO_MEMORY;

    as_rangelock(&kas);
    if (pvFixed != (void *)-1)
    {
        /* Use user specified address */
        addr = (caddr_t)pvFixed;

        /* Blow away any previous mapping */
        as_unmap(&kas, addr, size);
    }
    else
    {
        /* Let the system choose an address */
        map_addr(&addr, size, 0, 1, MAP_SHARED | MAP_ANONYMOUS);
        if (addr == NULL)
        {
            as_rangeunlock(&kas);
            cmn_err(CE_NOTE, "rtR0MemObjNativeMapKernel: map_addr failed\n");
            return VERR_NO_MEMORY;
        }

        /* Check address against alignment, fail if it doesn't match */
        if ((uintptr_t)addr & (uAlignment - 1))
        {
            as_rangeunlock(&kas);
            cmn_err(CE_NOTE, "rtR0MemObjNativeMapKernel: map_addr alignment(%ld) failed.\n", uAlignment);
            return VERR_MAP_FAILED;
        }
    }

    /* Our protection masks are identical to <sys/mman.h> but we
     * need to add PROT_USER for the pages to be accessible by user
     */
    struct segvn_crargs crArgs = SEGVN_ZFOD_ARGS(fProt | PROT_USER, PROT_ALL);
    rc = as_map(&kas, addr, size, segvn_create, &crArgs);
    as_rangeunlock(&kas);
    if (rc != 0)
    {
        cmn_err(CE_NOTE, "rtR0MemObjNativeMapKernel: as_map failure.\n");
        return VERR_NO_MEMORY;
    }

    /* Map each page into kernel space */
    rw_enter(&kas.a_lock, RW_READER);
    caddr_t kernAddr = pv;
    caddr_t pageAddr = addr;
    for (iPage = 0; iPage < cPages; iPage++)
    {
        page_t *pp = page_numtopp_nolock(hat_getpfnum(kas.a_hat, kernAddr));
        hat_memload(kas.a_hat, pageAddr, pp, (fProt | PROT_USER), HAT_LOAD_LOCK);
        pageAddr += ptob(1);
        kernAddr += ptob(1);
    }
    rw_exit(&kas.a_lock);

    pMemSolaris->Core.u.Mapping.R0Process = NIL_RTR0PROCESS; /* means kernel */
    pMemSolaris->Core.pv = addr;
    *ppMem = &pMemSolaris->Core;
    return VINF_SUCCESS;
}


int rtR0MemObjNativeMapUser(PPRTR0MEMOBJINTERNAL ppMem, PRTR0MEMOBJINTERNAL pMemToMap, RTR3PTR R3PtrFixed, size_t uAlignment, unsigned fProt, RTR0PROCESS R0Process)
{
    PRTR0MEMOBJSOLARIS pMemToMapSolaris = (PRTR0MEMOBJSOLARIS)pMemToMap;
    size_t size = pMemToMapSolaris->Core.cb;
    proc_t *userproc = (proc_t *)R0Process;
    struct as *useras = userproc->p_as;
    void *pv = pMemToMapSolaris->Core.pv;
    pgcnt_t cPages = btop(size);
    pgcnt_t iPage;
    caddr_t addr;
    int rc;

    /* Create the mapping object */
    PRTR0MEMOBJSOLARIS pMemSolaris = (PRTR0MEMOBJSOLARIS)rtR0MemObjNew(sizeof(*pMemSolaris), RTR0MEMOBJTYPE_MAPPING, pv, size);
    if (!pMemSolaris)
        return VERR_NO_MEMORY;

    as_rangelock(useras);
    if (R3PtrFixed != (RTR3PTR)-1)
    {
        /* Use user specified address */
        addr = (caddr_t)R3PtrFixed;

        /* Verify user address (a bit paranoid) */
        rc = valid_usr_range(addr, size, fProt, useras, (caddr_t)USERLIMIT32);
        if (rc != RANGE_OKAY)
        {
            as_rangeunlock(useras);
            cmn_err(CE_NOTE, "rtR0MemObjNativeMapUser: valid_usr_range failed, returned %d\n", rc);
            return VERR_INVALID_POINTER;
        }

        /* Blow away any previous mapping */
        as_unmap(useras, addr, size);
    }
    else
    {
        /* Let the system choose an address */
        map_addr(&addr, size, 0, 1, MAP_SHARED | MAP_ANONYMOUS);
        if (addr == NULL)
        {
            as_rangeunlock(useras);
            cmn_err(CE_NOTE, "rtR0MemObjNativeMapUser: map_addr failed\n");
            return VERR_MAP_FAILED;
        }

        /* Check address against alignment, fail if it doesn't match */
        if ((uintptr_t)addr & (uAlignment - 1))
        {
            as_rangeunlock(useras);
            cmn_err(CE_NOTE, "rtR0MemObjNativeMapUser: map_addr alignment(%ld) failed.\n", uAlignment);
            return VERR_MAP_FAILED;
        }
    }

    /* Our protection masks are identical to <sys/mman.h> but we
     * need to add PROT_USER for the pages to be accessible by user
     */
    struct segvn_crargs crArgs = SEGVN_ZFOD_ARGS(fProt | PROT_USER, PROT_ALL);
    rc = as_map(useras, addr, size, segvn_create, &crArgs);
    as_rangeunlock(useras);
    if (rc != 0)
    {
        cmn_err(CE_NOTE, "rtR0MemObjNativeMapUser: as_map failure.\n");
        return VERR_MAP_FAILED;
    }

#if 0
    /* Lock down the pages and get the shadow page list
     * In this case we must as_pageunlock if(ppShadowPages) exists while freeing CONT, PAGE
     */
    rc = as_pagelock(&kas, &pMemToMapSolaris->ppShadowPages, pv, size, S_WRITE);
    if (rc != 0 || pMemToMapSolaris->ppShadowPages == NULL)
    {
        cmn_err(CE_NOTE, "rtR0MemObjNativeMapUser: as_pagelock failed\n");
        as_unmap(useras, addr, size);
        return VERR_NO_MEMORY;
    }

    /* Map each page into user space */
    rw_enter(&useras->a_lock, RW_READER);
    caddr_t pageAddr = addr;
    for (iPage = 0; iPage < cPages; iPage++)
    {
        hat_memload(useras->a_hat, pageAddr, pMemToMapSolaris->ppShadowPages[iPage], fProt | PROT_USER,
                HAT_LOAD_NOCONSIST | HAT_STRICTORDER | HAT_LOAD_LOCK);
        pageAddr += ptob(1);
    }
    rw_exit(&useras->a_lock, RW_READER);
#else
    /* Map each page into user space */
    rw_enter(&useras->a_lock, RW_READER);
    caddr_t kernAddr = pv;
    caddr_t pageAddr = addr;
    for (iPage = 0; iPage < cPages; iPage++)
    {
        page_t *pp = page_numtopp_nolock(hat_getpfnum(kas.a_hat, kernAddr));
        hat_memload(useras->a_hat, pageAddr, pp, (fProt | PROT_USER), HAT_LOAD_LOCK);
        pageAddr += ptob(1);
        kernAddr += ptob(1);
    }
    rw_exit(&useras->a_lock);
#endif

    pMemSolaris->Core.u.Mapping.R0Process = (RTR0PROCESS)userproc;
    pMemSolaris->Core.pv = addr;
    *ppMem = &pMemSolaris->Core;
    return VINF_SUCCESS;
}


RTHCPHYS rtR0MemObjNativeGetPagePhysAddr(PRTR0MEMOBJINTERNAL pMem, size_t iPage)
{
    PRTR0MEMOBJSOLARIS pMemSolaris = (PRTR0MEMOBJSOLARIS)pMem;

    switch (pMemSolaris->Core.enmType)
    {
        case RTR0MEMOBJTYPE_PAGE:
        case RTR0MEMOBJTYPE_LOW:
        case RTR0MEMOBJTYPE_MAPPING:
        {
            uint8_t *pb = (uint8_t *)pMemSolaris->Core.pv + ((size_t)iPage << PAGE_SHIFT);
            return rtR0MemObjSolarisVirtToPhys(kas.a_hat, pb);
        }

        case RTR0MEMOBJTYPE_LOCK:
        {
            struct hat *hatSpace;
            if (pMemSolaris->Core.u.Lock.R0Process != NIL_RTR0PROCESS)
            {
                /* User */
                proc_t *userProc = (proc_t *)pMemSolaris->Core.u.Lock.R0Process;
                hatSpace = userProc->p_as->a_hat;
            }
            else    /* Kernel */
                hatSpace = kas.a_hat;

            uint8_t *pb = (uint8_t *)pMemSolaris->Core.pv + ((size_t)iPage << PAGE_SHIFT);
            return rtR0MemObjSolarisVirtToPhys(hatSpace, pb);
        }

        case RTR0MEMOBJTYPE_CONT:
            return pMemSolaris->Core.u.Cont.Phys + (iPage << PAGE_SHIFT);

        case RTR0MEMOBJTYPE_PHYS:
            return pMemSolaris->Core.u.Phys.PhysBase + (iPage << PAGE_SHIFT);

        case RTR0MEMOBJTYPE_PHYS_NC:
            AssertFailed(/* not implemented */);
        case RTR0MEMOBJTYPE_RES_VIRT:
        default:
            return NIL_RTHCPHYS;
    }
}