VirtualBox

Changeset 9435 in vbox for trunk/src


Ignore:
Timestamp:
Jun 5, 2008 3:39:11 PM (17 years ago)
Author:
vboxsync
Message:

Extend HGCM interface to support 64 bit pointers.

Location:
trunk/src/VBox
Files:
9 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/VBoxTray/VBoxClipboard.cpp

    r8857 r9435  
    153153    pParm->type                    = VMMDevHGCMParmType_LinAddr;
    154154    pParm->u.Pointer.size          = cb;
    155     pParm->u.Pointer.u.linearAddr  = (RTGCPTR)pv;
     155    pParm->u.Pointer.u.linearAddr  = (uintptr_t)pv;
    156156}
    157157

  • trunk/src/VBox/Additions/common/VBoxGuestLib/GenericRequest.cpp

    r8155 r9435  
    7676
    7777    physaddr = VbglPhysHeapGetPhysAddr (pReq);
    78     if (!physaddr)
     78    if (  !physaddr
     79       || (physaddr >> 32) != 0) /* Port IO is 32 bit. */
    7980    {
    8081        rc = VERR_VBGL_INVALID_ADDR;

  • trunk/src/VBox/Additions/common/VBoxGuestLib/PhysHeap.cpp

    r8155 r9435  
    305305
    306306    physAddr = 0;
     307    /* This function allocates physical contiguous memory (below 4GB) according to the IPRT docs.
     308     * Address < 4G is required for the port IO.
     309     */
    307310    pChunk = (VBGLPHYSHEAPCHUNK *)RTMemContAlloc (&physAddr, cbSize);
    308311

  • trunk/src/VBox/Additions/common/VBoxGuestLib/VBoxCalls.c

    r8155 r9435  
    129129    data.mappings.type                   = VMMDevHGCMParmType_LinAddr;
    130130    data.mappings.u.Pointer.size         = sizeof (SHFLMAPPING) * *pcMappings;
    131     data.mappings.u.Pointer.u.linearAddr = (RTGCPTR)&paMappings[0];
     131    data.mappings.u.Pointer.u.linearAddr = (uintptr_t)&paMappings[0];
    132132
    133133/*    Log(("VBOXSF: in ifs difference %d\n",
    … …  
    166166    data.name.type                   = VMMDevHGCMParmType_LinAddr;
    167167    data.name.u.Pointer.size         = size;
    168     data.name.u.Pointer.u.linearAddr = (RTGCPTR)pString;
     168    data.name.u.Pointer.u.linearAddr = (uintptr_t)pString;
    169169
    170170    rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
    … …  
    192192    data.path.type                    = VMMDevHGCMParmType_LinAddr;
    193193    data.path.u.Pointer.size          = ShflStringSizeOfBuffer (szFolderName);
    194     data.path.u.Pointer.u.linearAddr  = (RTGCPTR)szFolderName;
     194    data.path.u.Pointer.u.linearAddr  = (uintptr_t)szFolderName;
    195195
    196196    data.root.type                    = VMMDevHGCMParmType_32bit;
    … …  
    227227        data.path.type                    = VMMDevHGCMParmType_LinAddr;
    228228        data.path.u.Pointer.size          = ShflStringSizeOfBuffer (szFolderName);
    229         data.path.u.Pointer.u.linearAddr  = (RTGCPTR)szFolderName;
     229        data.path.u.Pointer.u.linearAddr  = (uintptr_t)szFolderName;
    230230
    231231        data.root.type                    = VMMDevHGCMParmType_32bit;
    … …  
    284284    data.path.type                    = VMMDevHGCMParmType_LinAddr;
    285285    data.path.u.Pointer.size          = ShflStringSizeOfBuffer (pParsedPath);
    286     data.path.u.Pointer.u.linearAddr  = (RTGCPTR)pParsedPath;
     286    data.path.u.Pointer.u.linearAddr  = (uintptr_t)pParsedPath;
    287287
    288288    data.parms.type                   = VMMDevHGCMParmType_LinAddr;
    289289    data.parms.u.Pointer.size         = sizeof (SHFLCREATEPARMS);
    290     data.parms.u.Pointer.u.linearAddr = (RTGCPTR)pCreateParms;
     290    data.parms.u.Pointer.u.linearAddr = (uintptr_t)pCreateParms;
    291291
    292292    rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
    … …  
    343343    data.path.type                      = VMMDevHGCMParmType_LinAddr_In;
    344344    data.path.u.Pointer.size            = ShflStringSizeOfBuffer (pParsedPath);
    345     data.path.u.Pointer.u.linearAddr    = (RTGCPTR)pParsedPath;
     345    data.path.u.Pointer.u.linearAddr    = (uintptr_t)pParsedPath;
    346346
    347347    data.flags.type                     = VMMDevHGCMParmType_32bit;
    … …  
    375375    data.src.type                       = VMMDevHGCMParmType_LinAddr_In;
    376376    data.src.u.Pointer.size             = ShflStringSizeOfBuffer (pSrcPath);
    377     data.src.u.Pointer.u.linearAddr     = (RTGCPTR)pSrcPath;
     377    data.src.u.Pointer.u.linearAddr     = (uintptr_t)pSrcPath;
    378378
    379379    data.dest.type                      = VMMDevHGCMParmType_LinAddr_In;
    380380    data.dest.u.Pointer.size            = ShflStringSizeOfBuffer (pDestPath);
    381     data.dest.u.Pointer.u.linearAddr    = (RTGCPTR)pDestPath;
     381    data.dest.u.Pointer.u.linearAddr    = (uintptr_t)pDestPath;
    382382
    383383    data.flags.type                     = VMMDevHGCMParmType_32bit;
    … …  
    416416    data.buffer.type                    = (fLocked) ? VMMDevHGCMParmType_LinAddr_Locked_Out : VMMDevHGCMParmType_LinAddr_Out;
    417417    data.buffer.u.Pointer.size          = *pcbBuffer;
    418     data.buffer.u.Pointer.u.linearAddr  = (RTGCPTR)pBuffer;
     418    data.buffer.u.Pointer.u.linearAddr  = (uintptr_t)pBuffer;
    419419
    420420    rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
    … …  
    451451    data.buffer.type                    = (fLocked) ? VMMDevHGCMParmType_LinAddr_Locked_In : VMMDevHGCMParmType_LinAddr_In;
    452452    data.buffer.u.Pointer.size          = *pcbBuffer;
    453     data.buffer.u.Pointer.u.linearAddr  = (RTGCPTR)pBuffer;
     453    data.buffer.u.Pointer.u.linearAddr  = (uintptr_t)pBuffer;
    454454
    455455    rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));
    … …  
    521521    data.path.u.Pointer.size            =
    522522        (ParsedPath) ? ShflStringSizeOfBuffer(ParsedPath) : 0;
    523     data.path.u.Pointer.u.linearAddr    = (RTGCPTR) ParsedPath;
     523    data.path.u.Pointer.u.linearAddr    = (uintptr_t) ParsedPath;
    524524
    525525    data.buffer.type                    = VMMDevHGCMParmType_LinAddr_Out;
    526526    data.buffer.u.Pointer.size          = *pcbBuffer;
    527     data.buffer.u.Pointer.u.linearAddr  = (RTGCPTR)pBuffer;
     527    data.buffer.u.Pointer.u.linearAddr  = (uintptr_t)pBuffer;
    528528
    529529    data.resumePoint.type               = VMMDevHGCMParmType_32bit;
    … …  
    566566    data.info.type                      = VMMDevHGCMParmType_LinAddr;
    567567    data.info.u.Pointer.size            = *pcbBuffer;
    568     data.info.u.Pointer.u.linearAddr    = (RTGCPTR)pBuffer;
     568    data.info.u.Pointer.u.linearAddr    = (uintptr_t)pBuffer;
    569569
    570570    rc = VbglHGCMCall (pClient->handle, &data.callInfo, sizeof (data));

  • trunk/src/VBox/Devices/Makefile.kmk

    r9408 r9435  
    226226DevicesR3_TEMPLATE      = VBOXR3
    227227DevicesR3_SDKS.win      = WINPSDK W2K3DDK
     228DevicesR3_DEFS         += VBOX_HGCM_HOST_CODE
    228229DevicesR3_INCS         := \
    229230        $(PATH_SUB_CURRENT)

  • trunk/src/VBox/Devices/VMMDev/VBoxDev.cpp

    r8996 r9435  
    10651065        }
    10661066
     1067#ifdef VBOX_WITH_64_BITS_GUESTS
     1068        case VMMDevReq_HGCMCall32:
     1069        case VMMDevReq_HGCMCall64:
     1070#else
    10671071        case VMMDevReq_HGCMCall:
     1072#endif /* VBOX_WITH_64_BITS_GUESTS */
    10681073        {
    10691074            if (pRequestHeader->size < sizeof(VMMDevHGCMCall))
    … …  
    10841089                Log2(("%.*Vhxd\n", pRequestHeader->size, pRequestHeader));
    10851090
    1086                 pRequestHeader->rc = vmmdevHGCMCall (pData, pHGCMCall, (RTGCPHYS)u32);
     1091#ifdef VBOX_WITH_64_BITS_GUESTS
     1092                bool f64Bits = (pRequestHeader->requestType == VMMDevReq_HGCMCall64);
     1093#else
     1094                bool f64Bits = false;
     1095#endif /* VBOX_WITH_64_BITS_GUESTS */
     1096
     1097                pRequestHeader->rc = vmmdevHGCMCall (pData, pHGCMCall, (RTGCPHYS)u32, f64Bits);
    10871098            }
    10881099            break;

  • trunk/src/VBox/Devices/VMMDev/VMMDevHGCM.cpp

    r8155 r9435  
    349349
    350350
    351 int vmmdevHGCMCall (VMMDevState *pVMMDevState, VMMDevHGCMCall *pHGCMCall, RTGCPHYS GCPhys)
     351int vmmdevHGCMCall (VMMDevState *pVMMDevState, VMMDevHGCMCall *pHGCMCall, RTGCPHYS GCPhys, bool f64Bits)
    352352{
    353353    int rc = VINF_SUCCESS;
    354354
    355     Log(("vmmdevHGCMCall: client id = %d, function = %d\n", pHGCMCall->u32ClientID, pHGCMCall->u32Function));
     355    Log(("vmmdevHGCMCall: client id = %d, function = %d, %s bit\n", pHGCMCall->u32ClientID, pHGCMCall->u32Function, f64Bits? "64": "32"));
    356356
    357357    /* Compute size and allocate memory block to hold:
    … …  
    371371    uint32_t cbCmdSize = sizeof (struct VBOXHGCMCMD) + cParms * sizeof (VBOXHGCMSVCPARM);
    372372
    373     HGCMFunctionParameter *pGuestParm = VMMDEV_HGCM_CALL_PARMS(pHGCMCall);
    374 
    375     /* Look for pointer parameters, which require a host buffer. */
    376373    uint32_t i;
    377374
    … …  
    379376    uint32_t cLinPtrPages  = 0;
    380377
    381     for (i = 0; i < cParms && VBOX_SUCCESS(rc); i++, pGuestParm++)
    382     {
    383         switch (pGuestParm->type)
    384         {
    385             case VMMDevHGCMParmType_LinAddr_In:  /* In (read) */
    386             case VMMDevHGCMParmType_LinAddr_Out: /* Out (write) */
    387             case VMMDevHGCMParmType_LinAddr:     /* In & Out */
     378    if (f64Bits)
     379    {
     380#ifdef VBOX_WITH_64_BITS_GUESTS
     381        HGCMFunctionParameter64 *pGuestParm = VMMDEV_HGCM_CALL_PARMS64(pHGCMCall);
     382#else
     383        HGCMFunctionParameter *pGuestParm = VMMDEV_HGCM_CALL_PARMS(pHGCMCall);
     384        AssertFailed (); /* This code should not be called in this case */
     385#endif /* VBOX_WITH_64_BITS_GUESTS */
     386
     387        /* Look for pointer parameters, which require a host buffer. */
     388        for (i = 0; i < cParms && VBOX_SUCCESS(rc); i++, pGuestParm++)
     389        {
     390            switch (pGuestParm->type)
    388391            {
    389                 cbCmdSize += pGuestParm->u.Pointer.size;
     392                case VMMDevHGCMParmType_LinAddr_In:  /* In (read) */
     393                case VMMDevHGCMParmType_LinAddr_Out: /* Out (write) */
     394                case VMMDevHGCMParmType_LinAddr:     /* In & Out */
     395                {
     396                    cbCmdSize += pGuestParm->u.Pointer.size;
    390397               
    391                 if (pGuestParm->type != VMMDevHGCMParmType_LinAddr_In)
     398                    if (pGuestParm->type != VMMDevHGCMParmType_LinAddr_In)
     399                    {
     400                        cLinPtrs++;
     401                        /* Take the offset into the current page also into account! */
     402                        cLinPtrPages += ((pGuestParm->u.Pointer.u.linearAddr & PAGE_OFFSET_MASK)
     403                                          + pGuestParm->u.Pointer.size + PAGE_SIZE - 1) / PAGE_SIZE;
     404                    }
     405               
     406                    Log(("vmmdevHGCMCall: linptr size = %d\n", pGuestParm->u.Pointer.size));
     407                } break;
     408
     409                case VMMDevHGCMParmType_32bit:
     410                case VMMDevHGCMParmType_64bit:
     411                case VMMDevHGCMParmType_PhysAddr:
    392412                {
    393                     cLinPtrs++;
    394                     /* Take the offset into the current page also into account! */
    395                     cLinPtrPages += ((pGuestParm->u.Pointer.u.linearAddr & PAGE_OFFSET_MASK)
    396                                       + pGuestParm->u.Pointer.size + PAGE_SIZE - 1) / PAGE_SIZE;
     413                } break;
     414
     415                default:
     416                {
     417                    AssertMsgFailed(("vmmdevHGCMCall: invalid parameter type %x\n", pGuestParm->type));
     418                    rc = VERR_INVALID_PARAMETER;
     419                    break;
    397420                }
     421            }
     422        }
     423    }
     424    else
     425    {
     426#ifdef VBOX_WITH_64_BITS_GUESTS
     427        HGCMFunctionParameter32 *pGuestParm = VMMDEV_HGCM_CALL_PARMS32(pHGCMCall);
     428#else
     429        HGCMFunctionParameter *pGuestParm = VMMDEV_HGCM_CALL_PARMS(pHGCMCall);
     430#endif /* VBOX_WITH_64_BITS_GUESTS */
     431
     432        /* Look for pointer parameters, which require a host buffer. */
     433        for (i = 0; i < cParms && VBOX_SUCCESS(rc); i++, pGuestParm++)
     434        {
     435            switch (pGuestParm->type)
     436            {
     437                case VMMDevHGCMParmType_LinAddr_In:  /* In (read) */
     438                case VMMDevHGCMParmType_LinAddr_Out: /* Out (write) */
     439                case VMMDevHGCMParmType_LinAddr:     /* In & Out */
     440                {
     441                    cbCmdSize += pGuestParm->u.Pointer.size;
    398442               
    399                 Log(("vmmdevHGCMCall: linptr size = %d\n", pGuestParm->u.Pointer.size));
    400             } break;
    401 
    402             case VMMDevHGCMParmType_32bit:
    403             case VMMDevHGCMParmType_64bit:
    404             case VMMDevHGCMParmType_PhysAddr:
    405             {
    406             } break;
    407 
    408             default:
    409             {
    410                 AssertMsgFailed(("vmmdevHGCMCall: invalid parameter type %x\n", pGuestParm->type));
    411                 rc = VERR_INVALID_PARAMETER;
    412                 break;
     443                    if (pGuestParm->type != VMMDevHGCMParmType_LinAddr_In)
     444                    {
     445                        cLinPtrs++;
     446                        /* Take the offset into the current page also into account! */
     447                        cLinPtrPages += ((pGuestParm->u.Pointer.u.linearAddr & PAGE_OFFSET_MASK)
     448                                          + pGuestParm->u.Pointer.size + PAGE_SIZE - 1) / PAGE_SIZE;
     449                    }
     450               
     451                    Log(("vmmdevHGCMCall: linptr size = %d\n", pGuestParm->u.Pointer.size));
     452                } break;
     453
     454                case VMMDevHGCMParmType_32bit:
     455                case VMMDevHGCMParmType_64bit:
     456                case VMMDevHGCMParmType_PhysAddr:
     457                {
     458                } break;
     459
     460                default:
     461                {
     462                    AssertMsgFailed(("vmmdevHGCMCall: invalid parameter type %x\n", pGuestParm->type));
     463                    rc = VERR_INVALID_PARAMETER;
     464                    break;
     465                }
    413466            }
    414467        }
    … …  
    462515        pCmd->paHostParms = pHostParm;
    463516
    464         pGuestParm = VMMDEV_HGCM_CALL_PARMS(pHGCMCall);
    465 
    466517        uint32_t iLinPtr = 0;
    467518        RTGCPHYS *pPages  = (RTGCPHYS *)((uint8_t *)pCmd->paLinPtrs + sizeof (VBOXHGCMLINPTR) *cLinPtrs);
    468519
    469         for (i = 0; i < cParms && VBOX_SUCCESS(rc); i++, pGuestParm++, pHostParm++)
    470         {
    471             switch (pGuestParm->type)
     520        if (f64Bits)
     521        {
     522#ifdef VBOX_WITH_64_BITS_GUESTS
     523            HGCMFunctionParameter64 *pGuestParm = VMMDEV_HGCM_CALL_PARMS64(pHGCMCall);
     524#else
     525            HGCMFunctionParameter *pGuestParm = VMMDEV_HGCM_CALL_PARMS(pHGCMCall);
     526            AssertFailed (); /* This code should not be called in this case */
     527#endif /* VBOX_WITH_64_BITS_GUESTS */
     528
     529
     530            for (i = 0; i < cParms && VBOX_SUCCESS(rc); i++, pGuestParm++, pHostParm++)
    472531            {
    473                  case VMMDevHGCMParmType_32bit:
    474                  {
    475                      uint32_t u32 = pGuestParm->u.value32;
    476 
    477                      pHostParm->type = VBOX_HGCM_SVC_PARM_32BIT;
    478                      pHostParm->u.uint32 = u32;
    479 
    480                      Log(("vmmdevHGCMCall: uint32 guest parameter %u\n", u32));
    481                      break;
    482                  }
    483 
    484                  case VMMDevHGCMParmType_64bit:
    485                  {
    486                      uint64_t u64 = pGuestParm->u.value64;
    487 
    488                      pHostParm->type = VBOX_HGCM_SVC_PARM_64BIT;
    489                      pHostParm->u.uint64 = u64;
    490 
    491                      Log(("vmmdevHGCMCall: uint64 guest parameter %llu\n", u64));
    492                      break;
    493                  }
    494 
    495                  case VMMDevHGCMParmType_PhysAddr:
    496                  {
    497                      uint32_t size = pGuestParm->u.Pointer.size;
     532                switch (pGuestParm->type)
     533                {
     534                     case VMMDevHGCMParmType_32bit:
     535                     {
     536                         uint32_t u32 = pGuestParm->u.value32;
     537
     538                         pHostParm->type = VBOX_HGCM_SVC_PARM_32BIT;
     539                         pHostParm->u.uint32 = u32;
     540
     541                         Log(("vmmdevHGCMCall: uint32 guest parameter %u\n", u32));
     542                         break;
     543                     }
     544
     545                     case VMMDevHGCMParmType_64bit:
     546                     {
     547                         uint64_t u64 = pGuestParm->u.value64;
     548
     549                         pHostParm->type = VBOX_HGCM_SVC_PARM_64BIT;
     550                         pHostParm->u.uint64 = u64;
     551
     552                         Log(("vmmdevHGCMCall: uint64 guest parameter %llu\n", u64));
     553                         break;
     554                     }
     555
     556                     case VMMDevHGCMParmType_PhysAddr:
     557                     {
     558                         uint32_t size = pGuestParm->u.Pointer.size;
    498559#ifdef LOG_ENABLED
    499                      RTGCPHYS physAddr = pGuestParm->u.Pointer.u.physAddr;
     560                         RTGCPHYS physAddr = pGuestParm->u.Pointer.u.physAddr;
    500561#endif
    501562
    502                      pHostParm->type = VBOX_HGCM_SVC_PARM_PTR;
    503                      pHostParm->u.pointer.size = size;
    504 
    505                      AssertFailed();
    506                      /* rc = PDMDevHlpPhys2HCVirt (pVMMDevState->pDevIns, physAddr, size, &pHostParm->u.pointer.addr); */
    507 
    508                      Log(("vmmdevHGCMCall: PhysAddr guest parameter %VGp\n", physAddr));
    509                      break;
    510                  }
    511 
    512                  case VMMDevHGCMParmType_LinAddr_In:  /* In (read) */
    513                  case VMMDevHGCMParmType_LinAddr_Out: /* Out (write) */
    514                  case VMMDevHGCMParmType_LinAddr:     /* In & Out */
    515                  {
    516                      uint32_t size = pGuestParm->u.Pointer.size;
    517                      RTGCPTR linearAddr = pGuestParm->u.Pointer.u.linearAddr;
    518 
    519                      pHostParm->type = VBOX_HGCM_SVC_PARM_PTR;
    520                      pHostParm->u.pointer.size = size;
    521 
    522                      /* Copy guest data to an allocated buffer, so
    523                       * services can use the data.
    524                       */
    525 
    526                      if (size == 0)
     563                         pHostParm->type = VBOX_HGCM_SVC_PARM_PTR;
     564                         pHostParm->u.pointer.size = size;
     565
     566                         AssertFailed();
     567                         /* rc = PDMDevHlpPhys2HCVirt (pVMMDevState->pDevIns, physAddr, size, &pHostParm->u.pointer.addr); */
     568
     569                         Log(("vmmdevHGCMCall: PhysAddr guest parameter %VGp\n", physAddr));
     570                         break;
     571                     }
     572
     573                     case VMMDevHGCMParmType_LinAddr_In:  /* In (read) */
     574                     case VMMDevHGCMParmType_LinAddr_Out: /* Out (write) */
     575                     case VMMDevHGCMParmType_LinAddr:     /* In & Out */
    527576                     {
    528                          pHostParm->u.pointer.addr = (void *) 0xfeeddead;
    529                      }
    530                      else
    531                      {
    532                          /* Don't overdo it */
    533                          if (pGuestParm->type != VMMDevHGCMParmType_LinAddr_Out)
    534                              rc = PDMDevHlpPhysReadGCVirt(pVMMDevState->pDevIns, pcBuf, linearAddr, size);
     577                         uint32_t size = pGuestParm->u.Pointer.size;
     578                         RTGCPTR linearAddr = pGuestParm->u.Pointer.u.linearAddr;
     579
     580                         pHostParm->type = VBOX_HGCM_SVC_PARM_PTR;
     581                         pHostParm->u.pointer.size = size;
     582
     583                         /* Copy guest data to an allocated buffer, so
     584                          * services can use the data.
     585                          */
     586
     587                         if (size == 0)
     588                         {
     589                             pHostParm->u.pointer.addr = (void *) 0xfeeddead;
     590                         }
    535591                         else
    536                              rc = VINF_SUCCESS;
    537 
    538                          if (VBOX_SUCCESS(rc))
    539592                         {
    540                              pHostParm->u.pointer.addr = pcBuf;
    541                              pcBuf += size;
     593                             /* Don't overdo it */
     594                             if (pGuestParm->type != VMMDevHGCMParmType_LinAddr_Out)
     595                                 rc = PDMDevHlpPhysReadGCVirt(pVMMDevState->pDevIns, pcBuf, linearAddr, size);
     596                             else
     597                                 rc = VINF_SUCCESS;
     598
     599                             if (VBOX_SUCCESS(rc))
     600                             {
     601                                 pHostParm->u.pointer.addr = pcBuf;
     602                                 pcBuf += size;
    542603                             
    543                              if (pGuestParm->type != VMMDevHGCMParmType_LinAddr_In)
    544                              {
    545                                  /* Remember the guest physical pages that belong to the virtual address
    546                                   * region.
    547                                   */
    548                                  rc = vmmdevHGCMSaveLinPtr (pVMMDevState->pDevIns, i, linearAddr, size, iLinPtr++, pCmd->paLinPtrs, &pPages);
     604                                 if (pGuestParm->type != VMMDevHGCMParmType_LinAddr_In)
     605                                 {
     606                                     /* Remember the guest physical pages that belong to the virtual address
     607                                      * region.
     608                                      */
     609                                     rc = vmmdevHGCMSaveLinPtr (pVMMDevState->pDevIns, i, linearAddr, size, iLinPtr++, pCmd->paLinPtrs, &pPages);
     610                                 }
    549611                             }
    550612                         }
     613
     614                         Log(("vmmdevHGCMCall: LinAddr guest parameter %VGv, rc = %Vrc\n", linearAddr, rc));
     615                         break;
    551616                     }
    552617
    553                      Log(("vmmdevHGCMCall: LinAddr guest parameter %VGv, rc = %Vrc\n", linearAddr, rc));
    554                      break;
    555                  }
    556 
    557                 /* just to shut up gcc */
    558                 default:
    559                     break;
     618                    /* just to shut up gcc */
     619                    default:
     620                        break;
     621                }
     622            }
     623        }
     624        else
     625        {
     626#ifdef VBOX_WITH_64_BITS_GUESTS
     627            HGCMFunctionParameter32 *pGuestParm = VMMDEV_HGCM_CALL_PARMS32(pHGCMCall);
     628#else
     629            HGCMFunctionParameter *pGuestParm = VMMDEV_HGCM_CALL_PARMS(pHGCMCall);
     630#endif /* VBOX_WITH_64_BITS_GUESTS */
     631
     632            for (i = 0; i < cParms && VBOX_SUCCESS(rc); i++, pGuestParm++, pHostParm++)
     633            {
     634                switch (pGuestParm->type)
     635                {
     636                     case VMMDevHGCMParmType_32bit:
     637                     {
     638                         uint32_t u32 = pGuestParm->u.value32;
     639
     640                         pHostParm->type = VBOX_HGCM_SVC_PARM_32BIT;
     641                         pHostParm->u.uint32 = u32;
     642
     643                         Log(("vmmdevHGCMCall: uint32 guest parameter %u\n", u32));
     644                         break;
     645                     }
     646
     647                     case VMMDevHGCMParmType_64bit:
     648                     {
     649                         uint64_t u64 = pGuestParm->u.value64;
     650
     651                         pHostParm->type = VBOX_HGCM_SVC_PARM_64BIT;
     652                         pHostParm->u.uint64 = u64;
     653
     654                         Log(("vmmdevHGCMCall: uint64 guest parameter %llu\n", u64));
     655                         break;
     656                     }
     657
     658                     case VMMDevHGCMParmType_PhysAddr:
     659                     {
     660                         uint32_t size = pGuestParm->u.Pointer.size;
     661#ifdef LOG_ENABLED
     662                         RTGCPHYS physAddr = pGuestParm->u.Pointer.u.physAddr;
     663#endif
     664
     665                         pHostParm->type = VBOX_HGCM_SVC_PARM_PTR;
     666                         pHostParm->u.pointer.size = size;
     667
     668                         AssertFailed();
     669                         /* rc = PDMDevHlpPhys2HCVirt (pVMMDevState->pDevIns, physAddr, size, &pHostParm->u.pointer.addr); */
     670
     671                         Log(("vmmdevHGCMCall: PhysAddr guest parameter %VGp\n", physAddr));
     672                         break;
     673                     }
     674
     675                     case VMMDevHGCMParmType_LinAddr_In:  /* In (read) */
     676                     case VMMDevHGCMParmType_LinAddr_Out: /* Out (write) */
     677                     case VMMDevHGCMParmType_LinAddr:     /* In & Out */
     678                     {
     679                         uint32_t size = pGuestParm->u.Pointer.size;
     680                         RTGCPTR linearAddr = pGuestParm->u.Pointer.u.linearAddr;
     681
     682                         pHostParm->type = VBOX_HGCM_SVC_PARM_PTR;
     683                         pHostParm->u.pointer.size = size;
     684
     685                         /* Copy guest data to an allocated buffer, so
     686                          * services can use the data.
     687                          */
     688
     689                         if (size == 0)
     690                         {
     691                             pHostParm->u.pointer.addr = (void *) 0xfeeddead;
     692                         }
     693                         else
     694                         {
     695                             /* Don't overdo it */
     696                             if (pGuestParm->type != VMMDevHGCMParmType_LinAddr_Out)
     697                                 rc = PDMDevHlpPhysReadGCVirt(pVMMDevState->pDevIns, pcBuf, linearAddr, size);
     698                             else
     699                                 rc = VINF_SUCCESS;
     700
     701                             if (VBOX_SUCCESS(rc))
     702                             {
     703                                 pHostParm->u.pointer.addr = pcBuf;
     704                                 pcBuf += size;
     705                             
     706                                 if (pGuestParm->type != VMMDevHGCMParmType_LinAddr_In)
     707                                 {
     708                                     /* Remember the guest physical pages that belong to the virtual address
     709                                      * region.
     710                                      */
     711                                     rc = vmmdevHGCMSaveLinPtr (pVMMDevState->pDevIns, i, linearAddr, size, iLinPtr++, pCmd->paLinPtrs, &pPages);
     712                                 }
     713                             }
     714                         }
     715
     716                         Log(("vmmdevHGCMCall: LinAddr guest parameter %VGv, rc = %Vrc\n", linearAddr, rc));
     717                         break;
     718                     }
     719
     720                    /* just to shut up gcc */
     721                    default:
     722                        break;
     723                }
    560724            }
    561725        }
    … …  
    595759
    596760        case VBOXHGCMCMDTYPE_CALL:
    597             if (pHeader->header.requestType == VMMDevReq_HGCMCall) return VINF_SUCCESS;
     761#ifdef VBOX_WITH_64_BITS_GUESTS
     762            if (   pHeader->header.requestType == VMMDevReq_HGCMCall32
     763                || pHeader->header.requestType == VMMDevReq_HGCMCall64) return VINF_SUCCESS;
     764#else
     765            if (   pHeader->header.requestType == VMMDevReq_HGCMCall) return VINF_SUCCESS;
     766#endif /* VBOX_WITH_64_BITS_GUESTS */
     767
    598768            break;
    599769
    … …  
    636806            switch (pHeader->header.requestType)
    637807            {
    638             case VMMDevReq_HGCMCall:
     808#ifdef VBOX_WITH_64_BITS_GUESTS
     809            case VMMDevReq_HGCMCall64:
    639810            {
    640811                VMMDevHGCMCall *pHGCMCall = (VMMDevHGCMCall *)pHeader;
    … …  
    642813                uint32_t cParms = pHGCMCall->cParms;
    643814
    644                 HGCMFunctionParameter *pGuestParm = VMMDEV_HGCM_CALL_PARMS(pHGCMCall);
    645 
    646815                VBOXHGCMSVCPARM *pHostParm = pCmd->paHostParms;
    647816
    648817                uint32_t i;
    649818                uint32_t iLinPtr = 0;
     819
     820                HGCMFunctionParameter64 *pGuestParm = VMMDEV_HGCM_CALL_PARMS64(pHGCMCall);
    650821
    651822                for (i = 0; i < cParms; i++, pGuestParm++, pHostParm++)
    … …  
    693864            }
    694865
     866            case VMMDevReq_HGCMCall32:
     867            {
     868                VMMDevHGCMCall *pHGCMCall = (VMMDevHGCMCall *)pHeader;
     869
     870                uint32_t cParms = pHGCMCall->cParms;
     871
     872                VBOXHGCMSVCPARM *pHostParm = pCmd->paHostParms;
     873
     874                uint32_t i;
     875                uint32_t iLinPtr = 0;
     876
     877                HGCMFunctionParameter32 *pGuestParm = VMMDEV_HGCM_CALL_PARMS32(pHGCMCall);
     878
     879                for (i = 0; i < cParms; i++, pGuestParm++, pHostParm++)
     880                {
     881                    switch (pGuestParm->type)
     882                    {
     883                        case VMMDevHGCMParmType_32bit:
     884                        {
     885                            pGuestParm->u.value32 = pHostParm->u.uint32;
     886                        } break;
     887
     888                        case VMMDevHGCMParmType_64bit:
     889                        {
     890                            pGuestParm->u.value64 = pHostParm->u.uint64;
     891                        } break;
     892
     893                        case VMMDevHGCMParmType_PhysAddr:
     894                        {
     895                            /* do nothing */
     896                        } break;
     897
     898                        case VMMDevHGCMParmType_LinAddr_In:  /* In (read) */
     899                        case VMMDevHGCMParmType_LinAddr_Out: /* Out (write) */
     900                        case VMMDevHGCMParmType_LinAddr:     /* In & Out */
     901                        {
     902                            /* Copy buffer back to guest memory. */
     903                            uint32_t size = pGuestParm->u.Pointer.size;
     904
     905                            if (size > 0 && pGuestParm->type != VMMDevHGCMParmType_LinAddr_In)
     906                            {
     907                                /* Use the saved page list. */
     908                                rc = vmmdevHGCMWriteLinPtr (pVMMDevState->pDevIns, i, pHostParm->u.pointer.addr, size, iLinPtr++, pCmd->paLinPtrs);
     909                                AssertReleaseRC(rc);
     910                            }
     911                        } break;
     912
     913                        default:
     914                        {
     915                            /* This indicates that the guest request memory was corrupted. */
     916                            AssertReleaseMsgFailed(("hgcmCompleted: invalid parameter type %08X\n", pGuestParm->type));
     917                        }
     918                    }
     919                }
     920                break;
     921            }
     922#else
     923            case VMMDevReq_HGCMCall:
     924            {
     925                VMMDevHGCMCall *pHGCMCall = (VMMDevHGCMCall *)pHeader;
     926
     927                uint32_t cParms = pHGCMCall->cParms;
     928
     929                VBOXHGCMSVCPARM *pHostParm = pCmd->paHostParms;
     930
     931                uint32_t i;
     932                uint32_t iLinPtr = 0;
     933
     934                HGCMFunctionParameter *pGuestParm = VMMDEV_HGCM_CALL_PARMS(pHGCMCall);
     935
     936                for (i = 0; i < cParms; i++, pGuestParm++, pHostParm++)
     937                {
     938                    switch (pGuestParm->type)
     939                    {
     940                        case VMMDevHGCMParmType_32bit:
     941                        {
     942                            pGuestParm->u.value32 = pHostParm->u.uint32;
     943                        } break;
     944
     945                        case VMMDevHGCMParmType_64bit:
     946                        {
     947                            pGuestParm->u.value64 = pHostParm->u.uint64;
     948                        } break;
     949
     950                        case VMMDevHGCMParmType_PhysAddr:
     951                        {
     952                            /* do nothing */
     953                        } break;
     954
     955                        case VMMDevHGCMParmType_LinAddr_In:  /* In (read) */
     956                        case VMMDevHGCMParmType_LinAddr_Out: /* Out (write) */
     957                        case VMMDevHGCMParmType_LinAddr:     /* In & Out */
     958                        {
     959                            /* Copy buffer back to guest memory. */
     960                            uint32_t size = pGuestParm->u.Pointer.size;
     961
     962                            if (size > 0 && pGuestParm->type != VMMDevHGCMParmType_LinAddr_In)
     963                            {
     964                                /* Use the saved page list. */
     965                                rc = vmmdevHGCMWriteLinPtr (pVMMDevState->pDevIns, i, pHostParm->u.pointer.addr, size, iLinPtr++, pCmd->paLinPtrs);
     966                                AssertReleaseRC(rc);
     967                            }
     968                        } break;
     969
     970                        default:
     971                        {
     972                            /* This indicates that the guest request memory was corrupted. */
     973                            AssertReleaseMsgFailed(("hgcmCompleted: invalid parameter type %08X\n", pGuestParm->type));
     974                        }
     975                    }
     976                }
     977                break;
     978            }
     979#endif /* VBOX_WITH_64_BITS_GUESTS */
    695980            case VMMDevReq_HGCMConnect:
    696981            {
    … …  
    9261211                        }
    9271212
     1213#ifdef VBOX_WITH_64_BITS_GUESTS
     1214                        case VMMDevReq_HGCMCall64:
     1215                        case VMMDevReq_HGCMCall32:
     1216#else
    9281217                        case VMMDevReq_HGCMCall:
     1218#endif /* VBOX_WITH_64_BITS_GUESTS */
    9291219                        {
    9301220                            if (requestHeader->size < sizeof(VMMDevHGCMCall))
    … …  
    9461236                                Log(("%.*Vhxd\n", requestHeader->size, requestHeader));
    9471237
    948                                 requestHeader->rc = vmmdevHGCMCall (pVMMDevState, pHGCMCall, pIter->GCPhys);
     1238#ifdef VBOX_WITH_64_BITS_GUESTS
     1239                                bool f64Bits = (requestHeader->requestType == VMMDevReq_HGCMCall64);
     1240#else
     1241                                bool f64Bits = false;
     1242#endif /* VBOX_WITH_64_BITS_GUESTS */
     1243                                requestHeader->rc = vmmdevHGCMCall (pVMMDevState, pHGCMCall, pIter->GCPhys, f64Bits);
    9491244                            }
    9501245                            break;

  • trunk/src/VBox/Devices/VMMDev/VMMDevHGCM.h

    r8155 r9435  
    3434DECLCALLBACK(int) vmmdevHGCMConnect (VMMDevState *pVMMDevState, VMMDevHGCMConnect *pHGCMConnect, RTGCPHYS GCPtr);
    3535DECLCALLBACK(int) vmmdevHGCMDisconnect (VMMDevState *pVMMDevState, VMMDevHGCMDisconnect *pHGCMDisconnect, RTGCPHYS GCPtr);
    36 DECLCALLBACK(int) vmmdevHGCMCall (VMMDevState *pVMMDevState, VMMDevHGCMCall *pHGCMCall, RTGCPHYS GCPtr);
     36DECLCALLBACK(int) vmmdevHGCMCall (VMMDevState *pVMMDevState, VMMDevHGCMCall *pHGCMCall, RTGCPHYS GCPtr, bool f64Bits);
    3737
    3838DECLCALLBACK(void) hgcmCompleted (PPDMIHGCMPORT pInterface, int32_t result, PVBOXHGCMCMD pCmdPtr);

  • trunk/src/VBox/HostServices/SharedClipboard/service.cpp

    r8155 r9435  
    3232#include "VBoxClipboard.h"
    3333
    34 #define VBOX_HGCM_PARM_COUNT(a) ((sizeof (a) - sizeof (((a *)0)->hdr)) / sizeof (HGCMFunctionParameter))
    35 
    3634static void VBoxHGCMParmUInt32Set (VBOXHGCMSVCPARM *pParm, uint32_t u32)
    3735{
    … …  
    339337            Log(("svcCall: VBOX_SHARED_CLIPBOARD_FN_GET_HOST_MSG\n"));
    340338
    341             if (cParms != VBOX_HGCM_PARM_COUNT (VBoxClipboardGetHostMsg))
     339            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_GET_HOST_MSG)
    342340            {
    343341                rc = VERR_INVALID_PARAMETER;
    … …  
    387385            Log(("svcCall: VBOX_SHARED_CLIPBOARD_FN_FORMATS\n"));
    388386
    389             if (cParms != VBOX_HGCM_PARM_COUNT (VBoxClipboardFormats))
     387            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_FORMATS)
    390388            {
    391389                rc = VERR_INVALID_PARAMETER;
    … …  
    432430            Log(("svcCall: VBOX_SHARED_CLIPBOARD_FN_READ_DATA\n"));
    433431
    434             if (cParms != VBOX_HGCM_PARM_COUNT (VBoxClipboardReadData))
     432            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_READ_DATA)
    435433            {
    436434                rc = VERR_INVALID_PARAMETER;
    … …  
    500498            Log(("svcCall: VBOX_SHARED_CLIPBOARD_FN_WRITE_DATA\n"));
    501499
    502             if (cParms != VBOX_HGCM_PARM_COUNT (VBoxClipboardWriteData))
     500            if (cParms != VBOX_SHARED_CLIPBOARD_CPARMS_WRITE_DATA)
    503501            {
    504502                rc = VERR_INVALID_PARAMETER;
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