VirtualBox

Changeset 4717 in vbox


Ignore:
Timestamp:
Sep 12, 2007 6:44:18 AM (17 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
24390
Message:

Solaris changes.

Location:
trunk/src/VBox
Files:
1 added
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/HostDrivers/Support/solaris/SUPDrv-solaris.c

    r4550 r4717  
    4747/** The module name. */
    4848#define DEVICE_NAME              "vboxdrv"
     49/** The module description as seen in 'modinfo'. */
    4950#define DEVICE_DESC              "VirtualBox Driver"
     51/** Maximum number of driver instances. */
    5052#define DEVICE_MAXINSTANCES      16
    5153
     
    5456*   Internal Functions                                                         *
    5557*******************************************************************************/
    56 static int VBoxDrvSolarisOpen(dev_t* pDev, int fFlag, int fType, cred_t* pCred);
    57 static int VBoxDrvSolarisClose(dev_t Dev, int fFlag, int fType, cred_t* pCred);
    58 static int VBoxDrvSolarisRead(dev_t Dev, struct uio* pUio, cred_t* pCred);
    59 static int VBoxDrvSolarisWrite(dev_t Dev, struct uio* pUio, cred_t* pCred);
    60 static int VBoxDrvSolarisIOCtl (dev_t Dev, int Cmd, intptr_t pArgs, int mode, cred_t* pCred, int* pVal);
    61 
    62 static int VBoxDrvSolarisAttach(dev_info_t* pDip, ddi_attach_cmd_t Cmd);
    63 static int VBoxDrvSolarisDetach(dev_info_t* pDip, ddi_detach_cmd_t Cmd);
     58static int VBoxDrvSolarisOpen(dev_t *pDev, int fFlag, int fType, cred_t *pCred);
     59static int VBoxDrvSolarisClose(dev_t Dev, int fFlag, int fType, cred_t *pCred);
     60static int VBoxDrvSolarisRead(dev_t Dev, struct uio *pUio, cred_t *pCred);
     61static int VBoxDrvSolarisWrite(dev_t Dev, struct uio *pUio, cred_t *pCred);
     62static int VBoxDrvSolarisIOCtl (dev_t Dev, int Cmd, intptr_t pArgs, int mode, cred_t *pCred, int *pVal);
     63
     64static int VBoxDrvSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t Cmd);
     65static int VBoxDrvSolarisDetach(dev_info_t *pDip, ddi_detach_cmd_t Cmd);
    6466
    6567static int VBoxSupDrvErr2SolarisErr(int rc);
     
    131133};
    132134
    133 /** State info. each our kernel module instances */
     135/** State info. for each driver instance. */
    134136typedef struct
    135137{
    136     dev_info_t*     pDip;   /* Device handle */
     138    dev_info_t     *pDip;   /* Device handle */
    137139} vbox_devstate_t;
    138140
    139141/** Opaque pointer to state */
    140 static void* g_pVBoxDrvSolarisState;
     142static void *g_pVBoxDrvSolarisState;
    141143
    142144/** Device extention & session data association structure */
     
    207209    if (RT_SUCCESS(rc))
    208210    {
    209         cmn_err(CE_NOTE,"supdrvCreateSession success");
    210211        RTSPINLOCKTMP   Tmp = RTSPINLOCKTMP_INITIALIZER;
    211212        unsigned        iHash;
     
    237238    if (instance >= DEVICE_MAXINSTANCES)
    238239    {
    239         cmn_err(CE_NOTE, "All instances exhausted\n");
     240        cmn_err(CE_NOTE, "VBoxDrvSolarisOpen: All instances exhausted\n");
    240241        return ENXIO;
    241242    }
     
    301302}
    302303
    303 static int VBoxDrvSolarisRead(dev_t dev, struct uio* pUio, cred_t* credp)
     304static int VBoxDrvSolarisRead(dev_t Dev, struct uio *pUio, cred_t *pCred)
    304305{
    305306    cmn_err(CE_CONT, "VBoxDrvSolarisRead");
     
    307308}
    308309
    309 static int VBoxDrvSolarisWrite(dev_t dev, struct uio* pUio, cred_t* credp)
     310static int VBoxDrvSolarisWrite(dev_t Dev, struct uio *pUio, cred_t *pCred)
    310311{
    311312    cmn_err(CE_CONT, "VBoxDrvSolarisWrite");
     
    321322 * @return  corresponding solaris error code.
    322323 */
    323 static int VBoxDrvSolarisAttach(dev_info_t* pDip, ddi_attach_cmd_t enmCmd)
     324static int VBoxDrvSolarisAttach(dev_info_t *pDip, ddi_attach_cmd_t enmCmd)
    324325{
    325326    cmn_err(CE_CONT, "VBoxDrvSolarisAttach");
    326327    int rc = VINF_SUCCESS;
    327328    int instance = 0;
    328     vbox_devstate_t* pState;
     329    vbox_devstate_t *pState;
    329330   
    330331    switch (enmCmd)
     
    412413    int rc = VINF_SUCCESS;
    413414    int instance;
    414     register vbox_devstate_t* pState;
     415    register vbox_devstate_t *pState;
    415416
    416417    cmn_err(CE_CONT, "VBoxDrvSolarisDetach");
     
    557558            {
    558559                OSDBGPRINT(("VBoxDrvSolarisIOCtlSlow: ddi_copyout(,%p,%d) failed.\n", pArgData->pvOut, cbBuf));
    559 
    560                 /** @todo r=bird: why this extra return? setting rc = EFAULT; should do the trick, shouldn't it? */
    561                 RTMemTmpFree(pvBuf);
    562                 return EFAULT;
     560                rc = EFAULT;
    563561            }
    564562        }
     
    573571        RTMemTmpFree(pvBuf);
    574572   
    575     OSDBGPRINT(("VBoxDrvSolarisIOCtlSlow: returns %d cbOut=%d\n", rc, cbOut));
    576573    return rc;
    577574}
     
    633630}
    634631
     632
    635633RTDECL(int) SUPR0Printf(const char *pszFormat, ...)
    636634{
     
    643641
    644642    szMsg[sizeof(szMsg) - 1] = '\0';
    645     printf("%s", szMsg);
     643    uprintf("%s", szMsg);
    646644    return 0;
    647645}
  • trunk/src/VBox/Runtime/Makefile.kmk

    r4713 r4717  
    876876        generic/RTTimerCreate-generic.cpp
    877877
    878 # SOLARISTODO - Todo for Solaris
    879878RuntimeR0Drv_SOURCES.solaris = \
    880879        generic/RTAssertDoBreakpoint-generic.cpp \
     
    891890        r0drv/solaris/process-r0drv-solaris.c \
    892891        r0drv/solaris/semevent-r0drv-solaris.c \
     892        r0drv/solaris/semeventmulti-r0drv-solaris.c \
    893893        r0drv/solaris/semfastmutex-r0drv-solaris.c \
    894894        r0drv/solaris/spinlock-r0drv-solaris.c \
     
    898898        r0drv/solaris/timer-r0drv-solaris.c
    899899
    900 ## @todo r0drv/solaris/semeventmulti-r0drv-solaris.c
    901900
    902901## PORTME: Porters create and add their selection of platform specific Ring-0 Driver files here.
  • trunk/src/VBox/Runtime/r0drv/solaris/assert-r0drv-solaris.c

    r4071 r4717  
    3737#endif
    3838
    39     printf("\r\n!!Assertion Failed!!\r\n"
    40            "Expression: %s\r\n"
    41            "Location  : %s(%d) %s\r\n",
    42            pszExpr, pszFile, uLine, pszFunction);
     39    uprintf("\r\n!!Assertion Failed!!\r\n"
     40            "Expression: %s\r\n"
     41            "Location  : %s(%d) %s\r\n",
     42            pszExpr, pszFile, uLine, pszFunction);
    4343}
    4444
     
    5959    szMsg[sizeof(szMsg) - 1] = '\0';
    6060    va_end(va);
    61     printf("%s", szMsg);
     61    uprintf("%s", szMsg);
    6262}
    6363
  • trunk/src/VBox/Runtime/r0drv/solaris/memobj-r0drv-solaris.c

    r4474 r4717  
    101101
    102102        case RTR0MEMOBJTYPE_PAGE:
    103             kmem_free(pMemSolaris->Core.pv, pMemSolaris->Core.cb);
     103            ddi_umem_free(pMemSolaris->Cookie);
    104104            break;
    105105
     
    107107        {
    108108            cmn_err(CE_NOTE, "rtR0MemObjNativeFree: LOCK\n");
    109             struct as* addrSpace;
     109            struct as *addrSpace;
    110110            if (pMemSolaris->Core.u.Lock.R0Process == NIL_RTR0PROCESS)
    111111                addrSpace = &kas;
     
    119119        case RTR0MEMOBJTYPE_MAPPING:
    120120        {
    121             struct hat* hatSpace;
    122             struct as* addrSpace;
     121            struct hat *hatSpace;
     122            struct as *addrSpace;
    123123            cmn_err(CE_NOTE, "rtR0MemObjNativeFree: MAPPING\n");
    124124            if (pMemSolaris->Core.u.Mapping.R0Process == NIL_RTR0PROCESS)
     
    164164        return VERR_NO_MEMORY;
    165165
    166     /** @todo r=bird: The man page says: "The allocated memory is at least double-word aligned, so it can hold any C data structure. No greater alignment can be assumed." */
    167     void* virtAddr = kmem_alloc(cb, KM_SLEEP);
     166    void *virtAddr = ddi_umem_alloc(cb, DDI_UMEM_SLEEP, &pMemSolaris->Cookie);
    168167    if (!virtAddr)
    169168    {
    170169        rtR0MemObjDelete(&pMemSolaris->Core);
    171         return VERR_NO_MEMORY;
     170        return VERR_NO_PAGE_MEMORY;
    172171    }
    173172   
     
    215214    {
    216215        rtR0MemObjDelete(&pMemSolaris->Core);
    217         return VERR_NO_MEMORY;
     216        return VERR_NO_CONT_MEMORY;
    218217    }
    219218
     
    258257int rtR0MemObjNativeLockUser(PPRTR0MEMOBJINTERNAL ppMem, RTR3PTR R3Ptr, size_t cb, RTR0PROCESS R0Process)
    259258{
    260     /* Create the object */
     259    /* Create the locking object */
    261260    PRTR0MEMOBJSOLARIS pMemSolaris = (PRTR0MEMOBJSOLARIS)rtR0MemObjNew(sizeof(*pMemSolaris), RTR0MEMOBJTYPE_LOCK, (void *)R3Ptr, cb);
    262261    if (!pMemSolaris)
     
    270269    page_t **ppl;
    271270
     271    /* Lock down user pages */
    272272    int rc = as_pagelock(useras, &ppl, (caddr_t)R3Ptr, cb, S_WRITE);
    273273    if (rc != 0)
    274274    {
    275275        cmn_err(CE_NOTE,"rtR0MemObjNativeLockUser: as_pagelock failed rc=%d\n", rc);
    276         return VERR_NO_MEMORY;
     276        return VERR_LOCK_FAILED;
    277277    }
    278278
     
    281281        as_pageunlock(useras, ppl, (caddr_t)R3Ptr, cb, S_WRITE);
    282282        cmn_err(CE_NOTE, "rtR0MemObjNativeLockUser: as_pagelock failed to get shadow pages\n");
    283         return VERR_NO_MEMORY;
     283        return VERR_LOCK_FAILED;
    284284    }
    285285   
     
    293293int rtR0MemObjNativeLockKernel(PPRTR0MEMOBJINTERNAL ppMem, void *pv, size_t cb)
    294294{
    295     /* Create the object */
     295    /* Create the locking object */
    296296    PRTR0MEMOBJSOLARIS pMemSolaris = (PRTR0MEMOBJSOLARIS)rtR0MemObjNew(sizeof(*pMemSolaris), RTR0MEMOBJTYPE_LOCK, pv, cb);
    297297    if (!pMemSolaris)
     
    301301    page_t **ppl;
    302302   
     303    /* Lock down kernel pages */
    303304    int rc = as_pagelock(&kas, &ppl, virtAddr, cb, S_WRITE);
    304305    if (rc != 0)
    305         return VERR_NO_MEMORY;
     306    {
     307        cmn_err(CE_NOTE,"rtR0MemObjNativeLockKernel: as_pagelock failed rc=%d\n", rc);
     308        return VERR_LOCK_FAILED;
     309    }
    306310
    307311    if (!ppl)
    308312    {
    309313        as_pageunlock(&kas, ppl, virtAddr, cb, S_WRITE);
    310         cmn_err(CE_NOTE, "rtR0MemObjNativeLockUser: failed to get shadow pages\n");
    311         return VERR_NO_MEMORY;
     314        cmn_err(CE_NOTE, "rtR0MemObjNativeLockKernel: failed to get shadow pages\n");
     315        return VERR_LOCK_FAILED;
    312316    }
    313317
     
    333337{
    334338    PRTR0MEMOBJSOLARIS pMemToMapSolaris = (PRTR0MEMOBJSOLARIS)pMemToMap;   
    335     size_t size = P2ROUNDUP(pMemToMapSolaris->Core.cb, PAGE_SIZE); /* r=bird: not necessary, see the specs / caller implementation. */
     339    size_t size = pMemToMapSolaris->Core.cb;
    336340    void *pv = pMemToMapSolaris->Core.pv;
    337341    pgcnt_t cPages = btop(size);
     
    364368            return VERR_NO_MEMORY;
    365369        }
    366         /** @todo r=bird: check address against uAlignment, just fail if it's not matching. */
     370       
     371        /* Check address against alignment, fail if it doesn't match */
     372        if ((uintptr_t)addr & (uAlignment - 1))
     373        {
     374            as_rangeunlock(&kas);
     375            cmn_err(CE_NOTE, "rtR0MemObjNativeMapKernel: map_addr alignment(%ld) failed.\n", uAlignment);
     376            return VERR_MAP_FAILED;
     377        }
    367378    }
    368379   
     
    401412{
    402413    PRTR0MEMOBJSOLARIS pMemToMapSolaris = (PRTR0MEMOBJSOLARIS)pMemToMap;   
    403     size_t size = P2ROUNDUP(pMemToMapSolaris->Core.cb, PAGE_SIZE); /** @todo r=bird: this isn't necessary, see the specs. */
     414    size_t size = pMemToMapSolaris->Core.cb;
    404415    proc_t *userproc = (proc_t *)R0Process;
    405416    struct as *useras = userproc->p_as;
     
    441452            as_rangeunlock(useras);
    442453            cmn_err(CE_NOTE, "rtR0MemObjNativeMapUser: map_addr failed\n");
    443             return VERR_NO_MEMORY;
    444         }
    445 
    446         /** @todo r=bird: check address against uAlignment, just fail if it's not matching. */
     454            return VERR_MAP_FAILED;
     455        }
     456       
     457        /* Check address against alignment, fail if it doesn't match */
     458        if ((uintptr_t)addr & (uAlignment - 1))
     459        {
     460            as_rangeunlock(useras);
     461            cmn_err(CE_NOTE, "rtR0MemObjNativeMapUser: map_addr alignment(%ld) failed.\n", uAlignment);
     462            return VERR_MAP_FAILED;
     463        }
    447464    }
    448465   
     
    456473    {
    457474        cmn_err(CE_NOTE, "rtR0MemObjNativeMapUser: as_map failure.\n");
    458         return VERR_NO_MEMORY;
     475        return VERR_MAP_FAILED;
    459476    }
    460477
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette