VirtualBox

Changeset 4233 in vbox


Ignore:
Timestamp:
Aug 19, 2007 8:51:14 PM (18 years ago)
Author:
vboxsync
svn:sync-xref-src-repo-rev:
23730
Message:

please keep in mind that this file is part of the Linux kernel module and therefore compiled as C90 source

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/r0drv/memobj-r0drv.cpp

    r4159 r4233  
    9595static int rtR0MemObjLink(PRTR0MEMOBJINTERNAL pParent, PRTR0MEMOBJINTERNAL pChild)
    9696{
     97    uint32_t i;
     98
    9799    /* sanity */
    98100    Assert(rtR0MemObjIsMapping(pChild));
    … …  
    100102
    101103    /* expand the array? */
    102     const uint32_t i = pParent->uRel.Parent.cMappings;
     104    i = pParent->uRel.Parent.cMappings;
    103105    if (i >= pParent->uRel.Parent.cMappingsAllocated)
    104106    {
    … …  
    130132{
    131133    /* Validate the object handle. */
     134    PRTR0MEMOBJINTERNAL pMem;
    132135    AssertPtrReturn(MemObj, false);
    133     PRTR0MEMOBJINTERNAL pMem = (PRTR0MEMOBJINTERNAL)MemObj;
     136    pMem = (PRTR0MEMOBJINTERNAL)MemObj;
    134137    AssertMsgReturn(pMem->u32Magic == RTR0MEMOBJ_MAGIC, ("%p: %#x\n", pMem, pMem->u32Magic), false);
    135138    AssertMsgReturn(pMem->enmType > RTR0MEMOBJTYPE_INVALID && pMem->enmType < RTR0MEMOBJTYPE_END, ("%p: %d\n", pMem, pMem->enmType), false);
    … …  
    150153{
    151154    /* Validate the object handle. */
     155    PRTR0MEMOBJINTERNAL pMem;
    152156    AssertPtrReturn(MemObj, 0);
    153     PRTR0MEMOBJINTERNAL pMem = (PRTR0MEMOBJINTERNAL)MemObj;
     157    pMem = (PRTR0MEMOBJINTERNAL)MemObj;
    154158    AssertMsgReturn(pMem->u32Magic == RTR0MEMOBJ_MAGIC, ("%p: %#x\n", pMem, pMem->u32Magic), 0);
    155159    AssertMsgReturn(pMem->enmType > RTR0MEMOBJTYPE_INVALID && pMem->enmType < RTR0MEMOBJTYPE_END, ("%p: %d\n", pMem, pMem->enmType), 0);
    … …  
    175179{
    176180    /* Validate the object handle. */
     181    PRTR0MEMOBJINTERNAL pMem;
    177182    AssertPtrReturn(MemObj, NIL_RTR3PTR);
    178     PRTR0MEMOBJINTERNAL pMem = (PRTR0MEMOBJINTERNAL)MemObj;
     183    pMem = (PRTR0MEMOBJINTERNAL)MemObj;
    179184    AssertMsgReturn(pMem->u32Magic == RTR0MEMOBJ_MAGIC, ("%p: %#x\n", pMem, pMem->u32Magic), NIL_RTR3PTR);
    180185    AssertMsgReturn(pMem->enmType > RTR0MEMOBJTYPE_INVALID && pMem->enmType < RTR0MEMOBJTYPE_END, ("%p: %d\n", pMem, pMem->enmType), NIL_RTR3PTR);
    … …  
    202207{
    203208    /* Validate the object handle. */
     209    PRTR0MEMOBJINTERNAL pMem;
    204210    AssertPtrReturn(MemObj, 0);
    205     PRTR0MEMOBJINTERNAL pMem = (PRTR0MEMOBJINTERNAL)MemObj;
     211    pMem = (PRTR0MEMOBJINTERNAL)MemObj;
    206212    AssertMsgReturn(pMem->u32Magic == RTR0MEMOBJ_MAGIC, ("%p: %#x\n", pMem, pMem->u32Magic), 0);
    207213    AssertMsgReturn(pMem->enmType > RTR0MEMOBJTYPE_INVALID && pMem->enmType < RTR0MEMOBJTYPE_END, ("%p: %d\n", pMem, pMem->enmType), 0);
    … …  
    225231{
    226232    /* Validate the object handle. */
     233    PRTR0MEMOBJINTERNAL pMem;
     234    size_t cPages;
    227235    AssertPtrReturn(MemObj, NIL_RTHCPHYS);
    228     PRTR0MEMOBJINTERNAL pMem = (PRTR0MEMOBJINTERNAL)MemObj;
     236    pMem = (PRTR0MEMOBJINTERNAL)MemObj;
    229237    AssertReturn(pMem->u32Magic == RTR0MEMOBJ_MAGIC, NIL_RTHCPHYS);
    230238    AssertReturn(pMem->enmType > RTR0MEMOBJTYPE_INVALID && pMem->enmType < RTR0MEMOBJTYPE_END, NIL_RTHCPHYS);
    231239    AssertMsgReturn(pMem->u32Magic == RTR0MEMOBJ_MAGIC, ("%p: %#x\n", pMem, pMem->u32Magic), NIL_RTHCPHYS);
    232240    AssertMsgReturn(pMem->enmType > RTR0MEMOBJTYPE_INVALID && pMem->enmType < RTR0MEMOBJTYPE_END, ("%p: %d\n", pMem, pMem->enmType), NIL_RTHCPHYS);
    233     const size_t cPages = (pMem->cb >> PAGE_SHIFT);
     241    cPages = (pMem->cb >> PAGE_SHIFT);
    234242    if (iPage >= cPages)
    235243    {
    … …  
    268276     * Validate the object handle.
    269277     */
     278    PRTR0MEMOBJINTERNAL pMem;
     279    int rc;
     280
    270281    if (MemObj == NIL_RTR0MEMOBJ)
    271282        return VINF_SUCCESS;
    272283    AssertPtrReturn(MemObj, VERR_INVALID_HANDLE);
    273     PRTR0MEMOBJINTERNAL pMem = (PRTR0MEMOBJINTERNAL)MemObj;
     284    pMem = (PRTR0MEMOBJINTERNAL)MemObj;
    274285    AssertReturn(pMem->u32Magic == RTR0MEMOBJ_MAGIC, VERR_INVALID_HANDLE);
    275286    AssertReturn(pMem->enmType > RTR0MEMOBJTYPE_INVALID && pMem->enmType < RTR0MEMOBJTYPE_END, VERR_INVALID_HANDLE);
    … …  
    297308
    298309            /* free the mapping. */
    299             int rc = rtR0MemObjNativeFree(pChild);
     310            rc = rtR0MemObjNativeFree(pChild);
    300311            if (RT_FAILURE(rc))
    301312            {
    … …  
    310321     * Free this object.
    311322     */
    312     int rc = rtR0MemObjNativeFree(pMem);
     323    rc = rtR0MemObjNativeFree(pMem);
    313324    if (RT_SUCCESS(rc))
    314325    {
    … …  
    319330        {
    320331            PRTR0MEMOBJINTERNAL pParent = pMem->uRel.Child.pParent;
     332            uint32_t i;
    321333
    322334            /* sanity checks */
    … …  
    329341
    330342            /* locate and remove from the array of mappings. */
    331             uint32_t i = pParent->uRel.Parent.cMappings;
     343            i = pParent->uRel.Parent.cMappings;
    332344            while (i-- > 0)
    333345            {
    … …  
    373385{
    374386    /* sanity checks. */
    375     AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
    376     *pMemObj = NIL_RTR0MEMOBJ;
    377     AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    378387    const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
     388    AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
     389    *pMemObj = NIL_RTR0MEMOBJ;
     390    AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    379391    AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
    380392
    … …  
    397409{
    398410    /* sanity checks. */
    399     AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
    400     *pMemObj = NIL_RTR0MEMOBJ;
    401     AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    402411    const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
     412    AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
     413    *pMemObj = NIL_RTR0MEMOBJ;
     414    AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    403415    AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
    404416
    … …  
    421433{
    422434    /* sanity checks. */
    423     AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
    424     *pMemObj = NIL_RTR0MEMOBJ;
    425     AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    426435    const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
     436    AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
     437    *pMemObj = NIL_RTR0MEMOBJ;
     438    AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    427439    AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
    428440
    … …  
    446458{
    447459    /* sanity checks. */
    448     AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
    449     *pMemObj = NIL_RTR0MEMOBJ;
    450     AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    451460    const size_t cbAligned = RT_ALIGN_Z(cb + (R3Ptr & PAGE_OFFSET_MASK), PAGE_SIZE);
    452     AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
    453461    RTR3PTR const R3PtrAligned = (R3Ptr & ~(RTR3PTR)PAGE_OFFSET_MASK);
     462    AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
     463    *pMemObj = NIL_RTR0MEMOBJ;
     464    AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
     465    AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
    454466    if (R0Process == NIL_RTR0PROCESS)
    455467        R0Process = RTR0ProcHandleSelf();
    … …  
    473485{
    474486    /* sanity checks. */
    475     AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
    476     *pMemObj = NIL_RTR0MEMOBJ;
    477     AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    478487    const size_t cbAligned = RT_ALIGN_Z(cb + ((uintptr_t)pv & PAGE_OFFSET_MASK), PAGE_SIZE);
    479     AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
    480488    void * const pvAligned = (void *)((uintptr_t)pv & ~(uintptr_t)PAGE_OFFSET_MASK);
     489    AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
     490    *pMemObj = NIL_RTR0MEMOBJ;
     491    AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
     492    AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
    481493    AssertPtrReturn(pvAligned, VERR_INVALID_POINTER);
    482494
    … …  
    498510{
    499511    /* sanity checks. */
    500     AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
    501     *pMemObj = NIL_RTR0MEMOBJ;
    502     AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    503512    const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
     513    AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
     514    *pMemObj = NIL_RTR0MEMOBJ;
     515    AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    504516    AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
    505517    AssertReturn(PhysHighest >= cb, VERR_INVALID_PARAMETER);
    … …  
    522534{
    523535    /* sanity checks. */
    524     AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
    525     *pMemObj = NIL_RTR0MEMOBJ;
    526     AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    527536    const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
     537    AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
     538    *pMemObj = NIL_RTR0MEMOBJ;
     539    AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    528540    AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
    529541    AssertReturn(PhysHighest >= cb, VERR_INVALID_PARAMETER);
    … …  
    548560{
    549561    /* sanity checks. */
    550     AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
    551     *pMemObj = NIL_RTR0MEMOBJ;
    552     AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    553562    const size_t cbAligned = RT_ALIGN_Z(cb + (Phys & PAGE_OFFSET_MASK), PAGE_SIZE);
     563    const RTHCPHYS PhysAligned = Phys & ~(RTHCPHYS)PAGE_OFFSET_MASK;
     564    AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
     565    *pMemObj = NIL_RTR0MEMOBJ;
     566    AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    554567    AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
    555568    AssertReturn(Phys != NIL_RTHCPHYS, VERR_INVALID_PARAMETER);
    556     const RTHCPHYS PhysAligned = Phys & ~(RTHCPHYS)PAGE_OFFSET_MASK;
    557569
    558570    /* do the allocation. */
    … …  
    574586{
    575587    /* sanity checks. */
     588    const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
    576589    AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
    577590    *pMemObj = NIL_RTR0MEMOBJ;
    … …  
    580593    AssertReturn(uAlignment == PAGE_SIZE || uAlignment == _2M || uAlignment == _4M, VERR_INVALID_PARAMETER);
    581594    AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    582     const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
    583595    AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
    584596    if (pvFixed != (void *)-1)
    … …  
    604616{
    605617    /* sanity checks. */
     618    const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
    606619    AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
    607620    *pMemObj = NIL_RTR0MEMOBJ;
    … …  
    610623    AssertReturn(uAlignment == PAGE_SIZE || uAlignment == _2M || uAlignment == _4M, VERR_INVALID_PARAMETER);
    611624    AssertReturn(cb > 0, VERR_INVALID_PARAMETER);
    612     const size_t cbAligned = RT_ALIGN_Z(cb, PAGE_SIZE);
    613625    AssertReturn(cb <= cbAligned, VERR_INVALID_PARAMETER);
    614626    if (R3PtrFixed != (RTR3PTR)-1)
    … …  
    636648{
    637649    /* sanity checks. */
     650    PRTR0MEMOBJINTERNAL pMemToMap;
     651    PRTR0MEMOBJINTERNAL pNew;
     652    int rc;
    638653    AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
    639654    *pMemObj = NIL_RTR0MEMOBJ;
    640655    AssertPtrReturn(MemObjToMap, VERR_INVALID_HANDLE);
    641     PRTR0MEMOBJINTERNAL pMemToMap = (PRTR0MEMOBJINTERNAL)MemObjToMap;
     656    pMemToMap = (PRTR0MEMOBJINTERNAL)MemObjToMap;
    642657    AssertReturn(pMemToMap->u32Magic == RTR0MEMOBJ_MAGIC, VERR_INVALID_HANDLE);
    643658    AssertReturn(pMemToMap->enmType > RTR0MEMOBJTYPE_INVALID && pMemToMap->enmType < RTR0MEMOBJTYPE_END, VERR_INVALID_HANDLE);
    … …  
    654669
    655670    /* do the mapping. */
    656     PRTR0MEMOBJINTERNAL pNew;
    657     int rc = rtR0MemObjNativeMapKernel(&pNew, pMemToMap, pvFixed, uAlignment, fProt);
     671    rc = rtR0MemObjNativeMapKernel(&pNew, pMemToMap, pvFixed, uAlignment, fProt);
    658672    if (RT_SUCCESS(rc))
    659673    {
    … …  
    692706{
    693707    /* sanity checks. */
    694     AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
     708    PRTR0MEMOBJINTERNAL pMemToMap;
     709    PRTR0MEMOBJINTERNAL pNew;
     710    int rc;
     711    AssertPtrReturn(pMemObj, VERR_INVALID_POINTER);
     712    pMemToMap = (PRTR0MEMOBJINTERNAL)MemObjToMap;
    695713    *pMemObj = NIL_RTR0MEMOBJ;
    696714    AssertPtrReturn(MemObjToMap, VERR_INVALID_HANDLE);
    697     PRTR0MEMOBJINTERNAL pMemToMap = (PRTR0MEMOBJINTERNAL)MemObjToMap;
    698715    AssertReturn(pMemToMap->u32Magic == RTR0MEMOBJ_MAGIC, VERR_INVALID_HANDLE);
    699716    AssertReturn(pMemToMap->enmType > RTR0MEMOBJTYPE_INVALID && pMemToMap->enmType < RTR0MEMOBJTYPE_END, VERR_INVALID_HANDLE);
    … …  
    711728
    712729    /* do the mapping. */
    713     PRTR0MEMOBJINTERNAL pNew;
    714     int rc = rtR0MemObjNativeMapUser(&pNew, pMemToMap, R3PtrFixed, uAlignment, fProt, R0Process);
     730    rc = rtR0MemObjNativeMapUser(&pNew, pMemToMap, R3PtrFixed, uAlignment, fProt, R0Process);
    715731    if (RT_SUCCESS(rc))
    716732    {
Note: See TracChangeset for help on using the changeset viewer.

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