VirtualBox

Ignore:
Timestamp:
Jan 8, 2019 11:08:12 PM (6 years ago)
Author:
vboxsync
Message:

os2/VBoxSF: Pass root ID rather than PVBOXSFFOLDER to inline request packers.

Location:
trunk/src/VBox/Additions/os2/VBoxSF
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Additions/os2/VBoxSF/VBoxSF.cpp

    r76693 r76715  
    286286    /* Note! We won't get there while the folder is on the list. */
    287287    LogRel(("vboxSfOs2ReleaseFolder: Destroying %p [%s]\n", pFolder, pFolder->szName));
    288     vboxSfOs2HostReqUnmapFolderSimple(pFolder->hHostFolder.root);
     288    vboxSfOs2HostReqUnmapFolderSimple(pFolder->idHostRoot);
    289289    RT_ZERO(pFolder);
    290290    RTMemFree(pFolder);
     
    371371        pNew->cOpenSearches = 0;
    372372        pNew->cDrives       = 0;
    373         RT_ZERO(pNew->hHostFolder);
     373        pNew->idHostRoot    = SHFL_ROOT_NIL;
    374374        pNew->hVpb          = 0;
    375375        pNew->cbNameAndTag  = pName->u16Length + (uint16_t)cbTag;
     
    398398            if (RT_SUCCESS(rc))
    399399            {
    400                 pNew->hHostFolder.root = pReq->Parms.id32Root.u.value32;
     400                pNew->idHostRoot = pReq->Parms.id32Root.u.value32;
    401401
    402402                RTListAppend(&g_FolderHead, &pNew->ListEntry);
     
    13641364        pu->Open.Req.StrPath.String.utf16[2] = '\0';
    13651365
    1366         int vrc = vboxSfOs2HostReqCreate(pFolder, &pu->Open.Req);
     1366        int vrc = vboxSfOs2HostReqCreate(pFolder->idHostRoot, &pu->Open.Req);
    13671367        LogFlow(("FS32_FSINFO: vboxSfOs2HostReqCreate -> %Rrc Result=%d Handle=%#RX64\n",
    13681368                 vrc, pu->Open.Req.CreateParms.Result, pu->Open.Req.CreateParms.Handle));
     
    13731373
    13741374            RT_ZERO(pu->Info.Req);
    1375             vrc = vboxSfOs2HostReqQueryVolInfo(pFolder, &pu->Info.Req, hHandle);
     1375            vrc = vboxSfOs2HostReqQueryVolInfo(pFolder->idHostRoot, &pu->Info.Req, hHandle);
    13761376            if (RT_SUCCESS(vrc))
    13771377            {
     
    14041404            }
    14051405
    1406             vrc = vboxSfOs2HostReqClose(pFolder, &pu->Close, hHandle);
     1406            vrc = vboxSfOs2HostReqClose(pFolder->idHostRoot, &pu->Close, hHandle);
    14071407            AssertRC(vrc);
    14081408        }
     
    14801480            pReq->CreateParms.CreateFlags = SHFL_CF_LOOKUP;
    14811481
    1482             int vrc = vboxSfOs2HostReqCreate(pFolder, pReq);
     1482            int vrc = vboxSfOs2HostReqCreate(pFolder->idHostRoot, pReq);
    14831483            LogFlow(("FS32_CHDIR: vboxSfOs2HostReqCreate -> %Rrc Result=%d fMode=%#x\n",
    14841484                     vrc, pReq->CreateParms.Result, pReq->CreateParms.Info.Attr.fMode));
     
    15541554                                          | SHFL_CF_ACCESS_READ | SHFL_CF_ACCESS_DENYNONE;
    15551555
    1556             int vrc = vboxSfOs2HostReqCreate(pFolder, pReq);
     1556            int vrc = vboxSfOs2HostReqCreate(pFolder->idHostRoot, pReq);
    15571557            LogFlow(("FS32_MKDIR: vboxSfOs2HostReqCreate -> %Rrc Result=%d fMode=%#x\n",
    15581558                     vrc, pReq->CreateParms.Result, pReq->CreateParms.Info.Attr.fMode));
     
    15651565                        {
    15661566                            AssertCompile(RTASSERT_OFFSET_OF(VBOXSFCREATEREQ, CreateParms.Handle) > sizeof(VBOXSFCLOSEREQ)); /* no aliasing issues */
    1567                             vrc = vboxSfOs2HostReqClose(pFolder, (VBOXSFCLOSEREQ *)pReq, pReq->CreateParms.Handle);
     1567                            vrc = vboxSfOs2HostReqClose(pFolder->idHostRoot, (VBOXSFCLOSEREQ *)pReq, pReq->CreateParms.Handle);
    15681568                            AssertRC(vrc);
    15691569                        }
     
    16201620    if (rc == NO_ERROR)
    16211621    {
    1622         int vrc = vboxSfOs2HostReqRemove(pFolder, pReq, SHFL_REMOVE_DIR);
     1622        int vrc = vboxSfOs2HostReqRemove(pFolder->idHostRoot, pReq, SHFL_REMOVE_DIR);
    16231623        LogFlow(("FS32_RMDIR: vboxSfOs2HostReqRemove -> %Rrc\n", rc));
    16241624        if (RT_SUCCESS(vrc))
     
    16781678                 * Note! Requires 6.0.0beta2+ or 5.2.24+ host for renaming files.
    16791679                 */
    1680                 int vrc = vboxSfOs2HostReqRenameWithSrcBuf(pSrcFolder, pReq, pSrcFolderPath, SHFL_RENAME_FILE | SHFL_RENAME_DIR);
     1680                int vrc = vboxSfOs2HostReqRenameWithSrcBuf(pSrcFolder->idHostRoot, pReq, pSrcFolderPath,
     1681                                                           SHFL_RENAME_FILE | SHFL_RENAME_DIR);
    16811682                if (RT_SUCCESS(vrc))
    16821683                    rc = NO_ERROR;
     
    17171718    if (rc == NO_ERROR)
    17181719    {
    1719         int vrc = vboxSfOs2HostReqRemove(pFolder, pReq, SHFL_REMOVE_FILE);
     1720        int vrc = vboxSfOs2HostReqRemove(pFolder->idHostRoot, pReq, SHFL_REMOVE_FILE);
    17201721        LogFlow(("FS32_DELETE: vboxSfOs2HostReqRemove -> %Rrc\n", rc));
    17211722        if (RT_SUCCESS(vrc))
     
    17971798    if (pReq)
    17981799    {
    1799         int vrc = vboxSfOs2HostReqSetObjInfoWithBuf(pFolder, pReq, hHostFile, pObjInfoBuf, offObjInfoInAlloc);
     1800        int vrc = vboxSfOs2HostReqSetObjInfoWithBuf(pFolder->idHostRoot, pReq, hHostFile, pObjInfoBuf, offObjInfoInAlloc);
    18001801        LogFlow(("vboxSfOs2SetFileInfo: vboxSfOs2HostReqSetObjInfoWithBuf -> %Rrc\n", vrc));
    18011802
     
    18281829                                  | SHFL_CF_ACCESS_ATTR_READWRITE | SHFL_CF_ACCESS_DENYNONE | SHFL_CF_ACCESS_NONE;
    18291830
    1830     int vrc = vboxSfOs2HostReqCreate(pFolder, pReq);
     1831    int vrc = vboxSfOs2HostReqCreate(pFolder->idHostRoot, pReq);
    18311832    LogFlow(("vboxSfOs2SetPathInfoWorker: vboxSfOs2HostReqCreate -> %Rrc Result=%d Handle=%#RX64 fMode=%#x\n",
    18321833             vrc, pReq->CreateParms.Result, pReq->CreateParms.Handle, pReq->CreateParms.Info.Attr.fMode));
     
    18391840        pReq->CreateParms.CreateFlags = SHFL_CF_DIRECTORY | SHFL_CF_ACT_OPEN_IF_EXISTS | SHFL_CF_ACT_FAIL_IF_NEW
    18401841                                      | SHFL_CF_ACCESS_ATTR_READWRITE | SHFL_CF_ACCESS_DENYNONE | SHFL_CF_ACCESS_NONE;
    1841         vrc = vboxSfOs2HostReqCreate(pFolder, pReq);
     1842        vrc = vboxSfOs2HostReqCreate(pFolder->idHostRoot, pReq);
    18421843        LogFlow(("vboxSfOs2SetPathInfoWorker: vboxSfOs2HostReqCreate#2 -> %Rrc Result=%d Handle=%#RX64 fMode=%#x\n",
    18431844                 vrc, pReq->CreateParms.Result, pReq->CreateParms.Handle, pReq->CreateParms.Info.Attr.fMode));
     
    18571858
    18581859                    AssertCompile(RTASSERT_OFFSET_OF(VBOXSFCREATEREQ, CreateParms.Handle) > sizeof(VBOXSFCLOSEREQ)); /* no aliasing issues */
    1859                     vrc = vboxSfOs2HostReqClose(pFolder, (VBOXSFCLOSEREQ *)pReq, pReq->CreateParms.Handle);
     1860                    vrc = vboxSfOs2HostReqClose(pFolder->idHostRoot, (VBOXSFCLOSEREQ *)pReq, pReq->CreateParms.Handle);
    18601861                    AssertRC(vrc);
    18611862                }
     
    19081909                pReq->CreateParms.CreateFlags = SHFL_CF_LOOKUP;
    19091910
    1910                 int vrc = vboxSfOs2HostReqCreate(pFolder, pReq);
     1911                int vrc = vboxSfOs2HostReqCreate(pFolder->idHostRoot, pReq);
    19111912                LogFlow(("FS32_FILEATTRIBUTE: vboxSfOs2HostReqCreate -> %Rrc Result=%d fMode=%#x\n",
    19121913                         vrc, pReq->CreateParms.Result, pReq->CreateParms.Info.Attr.fMode));
     
    22132214    pReq->CreateParms.CreateFlags = SHFL_CF_LOOKUP;
    22142215
    2215     int vrc = vboxSfOs2HostReqCreate(pFolder, pReq);
     2216    int vrc = vboxSfOs2HostReqCreate(pFolder->idHostRoot, pReq);
    22162217    LogFlow(("FS32_PATHINFO: vboxSfOs2HostReqCreate -> %Rrc Result=%d fMode=%#x\n",
    22172218             vrc, pReq->CreateParms.Result, pReq->CreateParms.Info.Attr.fMode));
  • trunk/src/VBox/Additions/os2/VBoxSF/VBoxSFFile.cpp

    r76693 r76715  
    233233     * Try open the file.
    234234     */
    235     int vrc = vboxSfOs2HostReqCreate(pFolder, pReq);
     235    int vrc = vboxSfOs2HostReqCreate(pFolder->idHostRoot, pReq);
    236236    LogFlow(("FS32_OPENCREATE: vboxSfOs2HostReqCreate -> %Rrc Result=%d fMode=%#x\n",
    237237             vrc, pReq->CreateParms.Result, pReq->CreateParms.Info.Attr.fMode));
     
    282282                    LogRel(("FS32_OPENCREATE: cbObject=%#RX64 no OPEN_FLAGS_LARGEFILE (%s)\n", pReq->CreateParms.Info.cbObject, pszName));
    283283                    AssertCompile(RTASSERT_OFFSET_OF(VBOXSFCREATEREQ, CreateParms.Handle) > sizeof(VBOXSFCLOSEREQ)); /* no aliasing issues */
    284                     vboxSfOs2HostReqClose(pFolder, (VBOXSFCLOSEREQ *)pReq, pReq->CreateParms.Handle);
     284                    vboxSfOs2HostReqClose(pFolder->idHostRoot, (VBOXSFCLOSEREQ *)pReq, pReq->CreateParms.Handle);
    285285                    rc = ERROR_ACCESS_DENIED;
    286286                }
     
    335335    RT_NOREF(fIoFlags);
    336336
    337     int vrc = vboxSfOs2HostReqCloseSimple(pFolder, pSfFsd->hHostFile);
     337    int vrc = vboxSfOs2HostReqCloseSimple(pFolder->idHostRoot, pSfFsd->hHostFile);
    338338    AssertRC(vrc);
    339339
     
    374374        || (pSfFsi->sfi_mode & SFMODE_OPEN_ACCESS) == SFMODE_OPEN_READWRITE)
    375375    {
    376         int vrc = vboxSfOs2HostReqFlushSimple(pFolder, pSfFsd->hHostFile);
     376        int vrc = vboxSfOs2HostReqFlushSimple(pFolder->idHostRoot, pSfFsd->hHostFile);
    377377        if (RT_FAILURE(vrc))
    378378        {
     
    435435                return ERROR_NOT_ENOUGH_MEMORY;
    436436
    437             int vrc = vboxSfOs2HostReqQueryObjInfo(pFolder, pReq, pSfFsd->hHostFile);
     437            int vrc = vboxSfOs2HostReqQueryObjInfo(pFolder->idHostRoot, pReq, pSfFsd->hHostFile);
    438438            if (RT_SUCCESS(vrc))
    439439            {
     
    813813                                    SHFL_FN_INFORMATION, SHFL_CPARMS_INFORMATION, sizeof(*pReq));
    814814        pReq->Parms.id32Root.type               = VMMDevHGCMParmType_32bit;
    815         pReq->Parms.id32Root.u.value32          = pFolder->hHostFolder.root;
     815        pReq->Parms.id32Root.u.value32          = pFolder->idHostRoot;
    816816        pReq->Parms.u64Handle.type              = VMMDevHGCMParmType_64bit;
    817817        pReq->Parms.u64Handle.u.value64         = pSfFsd->hHostFile;
     
    858858    if (pReq)
    859859    {
    860         int vrc = vboxSfOs2HostReqQueryObjInfo(pFolder, pReq, pSfFsd->hHostFile);
     860        int vrc = vboxSfOs2HostReqQueryObjInfo(pFolder->idHostRoot, pReq, pSfFsd->hHostFile);
    861861        if (RT_SUCCESS(vrc))
    862862        {
     
    10471047         * Call the host.
    10481048         */
    1049         int vrc = vboxSfOs2HostReqSetFileSizeSimple(pFolder, pSfFsd->hHostFile, cbFile);
     1049        int vrc = vboxSfOs2HostReqSetFileSizeSimple(pFolder->idHostRoot, pSfFsd->hHostFile, cbFile);
    10501050        if (RT_SUCCESS(vrc))
    10511051        {
     
    11661166        {
    11671167            APIRET rc;
    1168             int vrc = vboxSfOs2HostReqReadEmbedded(pFolder, pReq, pSfFsd->hHostFile, offRead, cbToRead);
     1168            int vrc = vboxSfOs2HostReqReadEmbedded(pFolder->idHostRoot, pReq, pSfFsd->hHostFile, offRead, cbToRead);
    11691169            if (RT_SUCCESS(vrc))
    11701170            {
     
    12231223        {
    12241224            APIRET rc;
    1225             int vrc = vboxSfOs2HostReqReadContig(pFolder, pReq, pSfFsd->hHostFile, offRead, cbToRead, pvBuf, GCPhys);
     1225            int vrc = vboxSfOs2HostReqReadContig(pFolder->idHostRoot, pReq, pSfFsd->hHostFile,
     1226                                                 offRead, cbToRead, pvBuf, GCPhys);
    12261227            if (RT_SUCCESS(vrc))
    12271228            {
     
    12651266
    12661267        APIRET rc;
    1267         int vrc = vboxSfOs2HostReqReadPgLst(pFolder, pReq, pSfFsd->hHostFile, offRead, cbToRead, cPages);
     1268        int vrc = vboxSfOs2HostReqReadPgLst(pFolder->idHostRoot, pReq, pSfFsd->hHostFile, offRead, cbToRead, cPages);
    12681269        if (RT_SUCCESS(vrc))
    12691270        {
     
    13361337            if (rc == NO_ERROR)
    13371338            {
    1338                 int vrc = vboxSfOs2HostReqWriteEmbedded(pFolder, pReq, pSfFsd->hHostFile, offWrite, cbToWrite);
     1339                int vrc = vboxSfOs2HostReqWriteEmbedded(pFolder->idHostRoot, pReq, pSfFsd->hHostFile, offWrite, cbToWrite);
    13391340                if (RT_SUCCESS(vrc))
    13401341                {
     
    13931394            {
    13941395                APIRET rc;
    1395                 int vrc = vboxSfOs2HostReqWriteContig(pFolder, pReq, pSfFsd->hHostFile, offWrite, cbToWrite, pvBuf, GCPhys);
     1396                int vrc = vboxSfOs2HostReqWriteContig(pFolder->idHostRoot, pReq, pSfFsd->hHostFile,
     1397                                                      offWrite, cbToWrite, pvBuf, GCPhys);
    13961398                if (RT_SUCCESS(vrc))
    13971399                {
     
    14311433
    14321434        APIRET rc;
    1433         int vrc = vboxSfOs2HostReqWritePgLst(pFolder, pReq, pSfFsd->hHostFile, offWrite, cbToWrite, cPages);
     1435        int vrc = vboxSfOs2HostReqWritePgLst(pFolder->idHostRoot, pReq, pSfFsd->hHostFile, offWrite, cbToWrite, cPages);
    14341436        if (RT_SUCCESS(vrc))
    14351437        {
  • trunk/src/VBox/Additions/os2/VBoxSF/VBoxSFFind.cpp

    r76665 r76715  
    234234        {
    235235            pDataBuf->pEntry = pEntry = pDataBuf->pBuf;
    236             int vrc = vboxSfOs2HostReqListDir(pFolder, &pDataBuf->Req, pFsFsd->hHostDir, pDataBuf->pFilter,
     236            int vrc = vboxSfOs2HostReqListDir(pFolder->idHostRoot, &pDataBuf->Req, pFsFsd->hHostDir, pDataBuf->pFilter,
    237237                                              /*cMaxMatches == 1 ? SHFL_LIST_RETURN_ONE :*/ 0, pDataBuf->pBuf, pDataBuf->cbBuf);
    238238            if (RT_SUCCESS(vrc))
     
    601601                                              | SHFL_CF_ACCESS_READ | SHFL_CF_ACCESS_ATTR_READ | SHFL_CF_ACCESS_DENYNONE;
    602602
    603                 int vrc = vboxSfOs2HostReqCreate(pFolder, pReq);
     603                int vrc = vboxSfOs2HostReqCreate(pFolder->idHostRoot, pReq);
    604604                LogFlow(("FS32_FINDFIRST: vboxSfOs2HostReqCreate(%ls) -> %Rrc Result=%d fMode=%#x hHandle=%#RX64\n",
    605605                         pStrFolderPath->String.utf16, vrc, pReq->CreateParms.Result, pReq->CreateParms.Info.Attr.fMode,
     
    649649                                {
    650650                                    AssertCompile(sizeof(VBOXSFCLOSEREQ) < sizeof(*pReq));
    651                                     vrc = vboxSfOs2HostReqClose(pFolder, (VBOXSFCLOSEREQ *)pReq, pFsFsd->hHostDir);
     651                                    vrc = vboxSfOs2HostReqClose(pFolder->idHostRoot, (VBOXSFCLOSEREQ *)pReq, pFsFsd->hHostDir);
    652652                                    AssertRC(vrc);
    653653                                    pFsFsd->u32Magic = ~VBOXSFFS_MAGIC;
     
    826826    if (pFsFsd->hHostDir != SHFL_HANDLE_NIL)
    827827    {
    828         int vrc = vboxSfOs2HostReqCloseSimple(pFolder, pFsFsd->hHostDir);
     828        int vrc = vboxSfOs2HostReqCloseSimple(pFolder->idHostRoot, pFsFsd->hHostDir);
    829829        AssertRC(vrc);
    830830    }
  • trunk/src/VBox/Additions/os2/VBoxSF/VBoxSFInternal.h

    r76693 r76715  
    7777
    7878    /** The host folder handle. */
    79     VBGLSFMAP           hHostFolder;
     79    SHFLROOT            idHostRoot;
    8080
    8181    /** OS/2 volume handle. */
     
    369369 * SHFL_FN_CREATE request.
    370370 */
    371 DECLINLINE(int) vboxSfOs2HostReqCreate(PVBOXSFFOLDER pFolder, VBOXSFCREATEREQ *pReq)
     371DECLINLINE(int) vboxSfOs2HostReqCreate(SHFLROOT idRoot, VBOXSFCREATEREQ *pReq)
    372372{
    373373    uint32_t const cbReq = g_fHostFeatures & VMMDEV_HVF_HGCM_EMBEDDED_BUFFERS
     
    377377                                SHFL_FN_CREATE, SHFL_CPARMS_CREATE, cbReq);
    378378
    379     pReq->Parms.id32Root.type                   = VMMDevHGCMParmType_32bit;
    380     pReq->Parms.id32Root.u.value32              = pFolder->hHostFolder.root;
     379    pReq->Parms.id32Root.type                       = VMMDevHGCMParmType_32bit;
     380    pReq->Parms.id32Root.u.value32                  = idRoot;
    381381
    382382    if (g_fHostFeatures & VMMDEV_HVF_HGCM_EMBEDDED_BUFFERS)
     
    421421 * SHFL_FN_CLOSE request.
    422422 */
    423 DECLINLINE(int) vboxSfOs2HostReqClose(PVBOXSFFOLDER pFolder, VBOXSFCLOSEREQ *pReq, uint64_t hHostFile)
     423DECLINLINE(int) vboxSfOs2HostReqClose(SHFLROOT idRoot, VBOXSFCLOSEREQ *pReq, uint64_t hHostFile)
    424424{
    425425    VBGLIOCIDCHGCMFASTCALL_INIT(&pReq->Hdr, VbglR0PhysHeapGetPhysAddr(pReq), &pReq->Call, g_SfClient.idClient,
    426426                                SHFL_FN_CLOSE, SHFL_CPARMS_CLOSE, sizeof(*pReq));
    427427
    428     pReq->Parms.id32Root.type                   = VMMDevHGCMParmType_32bit;
    429     pReq->Parms.id32Root.u.value32              = pFolder->hHostFolder.root;
    430 
    431     pReq->Parms.u64Handle.type                  = VMMDevHGCMParmType_64bit;
    432     pReq->Parms.u64Handle.u.value64             = hHostFile;
     428    pReq->Parms.id32Root.type       = VMMDevHGCMParmType_32bit;
     429    pReq->Parms.id32Root.u.value32  = idRoot;
     430
     431    pReq->Parms.u64Handle.type      = VMMDevHGCMParmType_64bit;
     432    pReq->Parms.u64Handle.u.value64 = hHostFile;
    433433
    434434    int vrc = VbglR0HGCMFastCall(g_SfClient.handle, &pReq->Hdr, sizeof(*pReq));
     
    441441 * SHFL_FN_CLOSE request, allocate request buffer.
    442442 */
    443 DECLINLINE(int) vboxSfOs2HostReqCloseSimple(PVBOXSFFOLDER pFolder, uint64_t hHostFile)
     443DECLINLINE(int) vboxSfOs2HostReqCloseSimple(SHFLROOT idRoot, uint64_t hHostFile)
    444444{
    445445    VBOXSFCLOSEREQ *pReq = (VBOXSFCLOSEREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
    446446    if (pReq)
    447447    {
    448         int vrc = vboxSfOs2HostReqClose(pFolder, pReq, hHostFile);
     448        int vrc = vboxSfOs2HostReqClose(idRoot, pReq, hHostFile);
    449449        VbglR0PhysHeapFree(pReq);
    450450        return vrc;
     
    466466 * SHFL_FN_INFORMATION[SHFL_INFO_VOLUME | SHFL_INFO_GET] request.
    467467 */
    468 DECLINLINE(int) vboxSfOs2HostReqQueryVolInfo(PVBOXSFFOLDER pFolder, VBOXSFVOLINFOREQ *pReq, uint64_t hHostFile)
     468DECLINLINE(int) vboxSfOs2HostReqQueryVolInfo(SHFLROOT idRoot, VBOXSFVOLINFOREQ *pReq, uint64_t hHostFile)
    469469{
    470470    uint32_t const cbReq = g_fHostFeatures & VMMDEV_HVF_HGCM_EMBEDDED_BUFFERS
     
    474474
    475475    pReq->Parms.id32Root.type                   = VMMDevHGCMParmType_32bit;
    476     pReq->Parms.id32Root.u.value32              = pFolder->hHostFolder.root;
     476    pReq->Parms.id32Root.u.value32              = idRoot;
    477477
    478478    pReq->Parms.u64Handle.type                  = VMMDevHGCMParmType_64bit;
     
    518518 * SHFL_FN_INFORMATION[SHFL_INFO_GET | SHFL_INFO_FILE] request.
    519519 */
    520 DECLINLINE(int) vboxSfOs2HostReqQueryObjInfo(PVBOXSFFOLDER pFolder, VBOXSFOBJINFOREQ *pReq, uint64_t hHostFile)
     520DECLINLINE(int) vboxSfOs2HostReqQueryObjInfo(SHFLROOT idRoot, VBOXSFOBJINFOREQ *pReq, uint64_t hHostFile)
    521521{
    522522    uint32_t const cbReq = g_fHostFeatures & VMMDEV_HVF_HGCM_EMBEDDED_BUFFERS
     
    526526
    527527    pReq->Parms.id32Root.type                   = VMMDevHGCMParmType_32bit;
    528     pReq->Parms.id32Root.u.value32              = pFolder->hHostFolder.root;
     528    pReq->Parms.id32Root.u.value32              = idRoot;
    529529
    530530    pReq->Parms.u64Handle.type                  = VMMDevHGCMParmType_64bit;
     
    561561 * SHFL_FN_INFORMATION[SHFL_INFO_SET | SHFL_INFO_FILE] request.
    562562 */
    563 DECLINLINE(int) vboxSfOs2HostReqSetObjInfo(PVBOXSFFOLDER pFolder, VBOXSFOBJINFOREQ *pReq, uint64_t hHostFile)
     563DECLINLINE(int) vboxSfOs2HostReqSetObjInfo(SHFLROOT idRoot, VBOXSFOBJINFOREQ *pReq, uint64_t hHostFile)
    564564{
    565565    uint32_t const cbReq = g_fHostFeatures & VMMDEV_HVF_HGCM_EMBEDDED_BUFFERS
     
    569569
    570570    pReq->Parms.id32Root.type                   = VMMDevHGCMParmType_32bit;
    571     pReq->Parms.id32Root.u.value32              = pFolder->hHostFolder.root;
     571    pReq->Parms.id32Root.u.value32              = idRoot;
    572572
    573573    pReq->Parms.u64Handle.type                  = VMMDevHGCMParmType_64bit;
     
    614614 * buffer (on the physical heap).
    615615 */
    616 DECLINLINE(int) vboxSfOs2HostReqSetObjInfoWithBuf(PVBOXSFFOLDER pFolder, VBOXSFOBJINFOWITHBUFREQ *pReq, uint64_t hHostFile,
     616DECLINLINE(int) vboxSfOs2HostReqSetObjInfoWithBuf(SHFLROOT idRoot, VBOXSFOBJINFOWITHBUFREQ *pReq, uint64_t hHostFile,
    617617                                                  PSHFLFSOBJINFO pObjInfo, uint32_t offObjInfoInAlloc)
    618618{
     
    621621
    622622    pReq->Parms.id32Root.type               = VMMDevHGCMParmType_32bit;
    623     pReq->Parms.id32Root.u.value32          = pFolder->hHostFolder.root;
     623    pReq->Parms.id32Root.u.value32          = idRoot;
    624624
    625625    pReq->Parms.u64Handle.type              = VMMDevHGCMParmType_64bit;
     
    669669 * SHFL_FN_REMOVE request.
    670670 */
    671 DECLINLINE(int) vboxSfOs2HostReqRemove(PVBOXSFFOLDER pFolder, VBOXSFREMOVEREQ *pReq, uint32_t fFlags)
     671DECLINLINE(int) vboxSfOs2HostReqRemove(SHFLROOT idRoot, VBOXSFREMOVEREQ *pReq, uint32_t fFlags)
    672672{
    673673    uint32_t const cbReq = RT_UOFFSETOF(VBOXSFREMOVEREQ, StrPath.String)
     
    677677
    678678    pReq->Parms.id32Root.type                   = VMMDevHGCMParmType_32bit;
    679     pReq->Parms.id32Root.u.value32              = pFolder->hHostFolder.root;
     679    pReq->Parms.id32Root.u.value32              = idRoot;
    680680
    681681    if (g_fHostFeatures & VMMDEV_HVF_HGCM_EMBEDDED_BUFFERS)
     
    716716 * SHFL_FN_REMOVE request.
    717717 */
    718 DECLINLINE(int) vboxSfOs2HostReqRenameWithSrcBuf(PVBOXSFFOLDER pFolder, VBOXSFRENAMEWITHSRCBUFREQ *pReq,
     718DECLINLINE(int) vboxSfOs2HostReqRenameWithSrcBuf(SHFLROOT idRoot, VBOXSFRENAMEWITHSRCBUFREQ *pReq,
    719719                                                 PSHFLSTRING pSrcStr, uint32_t fFlags)
    720720{
     
    725725
    726726    pReq->Parms.id32Root.type                       = VMMDevHGCMParmType_32bit;
    727     pReq->Parms.id32Root.u.value32                  = pFolder->hHostFolder.root;
     727    pReq->Parms.id32Root.u.value32                  = idRoot;
    728728
    729729    if (g_fHostFeatures & VMMDEV_HVF_HGCM_CONTIGUOUS_PAGE_LIST)
     
    782782 * SHFL_FN_FLUSH request.
    783783 */
    784 DECLINLINE(int) vboxSfOs2HostReqFlush(PVBOXSFFOLDER pFolder, VBOXSFFLUSHREQ *pReq, uint64_t hHostFile)
     784DECLINLINE(int) vboxSfOs2HostReqFlush(SHFLROOT idRoot, VBOXSFFLUSHREQ *pReq, uint64_t hHostFile)
    785785{
    786786    VBGLIOCIDCHGCMFASTCALL_INIT(&pReq->Hdr, VbglR0PhysHeapGetPhysAddr(pReq), &pReq->Call, g_SfClient.idClient,
    787787                                SHFL_FN_FLUSH, SHFL_CPARMS_FLUSH, sizeof(*pReq));
    788788
    789     pReq->Parms.id32Root.type                   = VMMDevHGCMParmType_32bit;
    790     pReq->Parms.id32Root.u.value32              = pFolder->hHostFolder.root;
    791 
    792     pReq->Parms.u64Handle.type                  = VMMDevHGCMParmType_64bit;
    793     pReq->Parms.u64Handle.u.value64             = hHostFile;
     789    pReq->Parms.id32Root.type       = VMMDevHGCMParmType_32bit;
     790    pReq->Parms.id32Root.u.value32  = idRoot;
     791
     792    pReq->Parms.u64Handle.type      = VMMDevHGCMParmType_64bit;
     793    pReq->Parms.u64Handle.u.value64 = hHostFile;
    794794
    795795    int vrc = VbglR0HGCMFastCall(g_SfClient.handle, &pReq->Hdr, sizeof(*pReq));
     
    802802 * SHFL_FN_FLUSH request, allocate request buffer.
    803803 */
    804 DECLINLINE(int) vboxSfOs2HostReqFlushSimple(PVBOXSFFOLDER pFolder, uint64_t hHostFile)
     804DECLINLINE(int) vboxSfOs2HostReqFlushSimple(SHFLROOT idRoot, uint64_t hHostFile)
    805805{
    806806    VBOXSFFLUSHREQ *pReq = (VBOXSFFLUSHREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
    807807    if (pReq)
    808808    {
    809         int vrc = vboxSfOs2HostReqFlush(pFolder, pReq, hHostFile);
     809        int vrc = vboxSfOs2HostReqFlush(idRoot, pReq, hHostFile);
    810810        VbglR0PhysHeapFree(pReq);
    811811        return vrc;
     
    826826 * SHFL_FN_SET_FILE_SIZE request.
    827827 */
    828 DECLINLINE(int) vboxSfOs2HostReqSetFileSize(PVBOXSFFOLDER pFolder, VBOXSFSETFILESIZEREQ *pReq,
     828DECLINLINE(int) vboxSfOs2HostReqSetFileSize(SHFLROOT idRoot, VBOXSFSETFILESIZEREQ *pReq,
    829829                                            uint64_t hHostFile, uint64_t cbNewSize)
    830830{
     
    832832                                SHFL_FN_SET_FILE_SIZE, SHFL_CPARMS_SET_FILE_SIZE, sizeof(*pReq));
    833833
    834     pReq->Parms.id32Root.type                   = VMMDevHGCMParmType_32bit;
    835     pReq->Parms.id32Root.u.value32              = pFolder->hHostFolder.root;
    836 
    837     pReq->Parms.u64Handle.type                  = VMMDevHGCMParmType_64bit;
    838     pReq->Parms.u64Handle.u.value64             = hHostFile;
    839 
    840     pReq->Parms.cb64NewSize.type                = VMMDevHGCMParmType_64bit;
    841     pReq->Parms.cb64NewSize.u.value64           = cbNewSize;
     834    pReq->Parms.id32Root.type           = VMMDevHGCMParmType_32bit;
     835    pReq->Parms.id32Root.u.value32      = idRoot;
     836
     837    pReq->Parms.u64Handle.type          = VMMDevHGCMParmType_64bit;
     838    pReq->Parms.u64Handle.u.value64     = hHostFile;
     839
     840    pReq->Parms.cb64NewSize.type        = VMMDevHGCMParmType_64bit;
     841    pReq->Parms.cb64NewSize.u.value64   = cbNewSize;
    842842
    843843    int vrc = VbglR0HGCMFastCall(g_SfClient.handle, &pReq->Hdr, sizeof(*pReq));
     
    850850 * SHFL_FN_SET_FILE_SIZE request, allocate request buffer.
    851851 */
    852 DECLINLINE(int) vboxSfOs2HostReqSetFileSizeSimple(PVBOXSFFOLDER pFolder, uint64_t hHostFile, uint64_t cbNewSize)
     852DECLINLINE(int) vboxSfOs2HostReqSetFileSizeSimple(SHFLROOT idRoot, uint64_t hHostFile, uint64_t cbNewSize)
    853853{
    854854    VBOXSFSETFILESIZEREQ *pReq = (VBOXSFSETFILESIZEREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
    855855    if (pReq)
    856856    {
    857         int vrc = vboxSfOs2HostReqSetFileSize(pFolder, pReq, hHostFile, cbNewSize);
     857        int vrc = vboxSfOs2HostReqSetFileSize(idRoot, pReq, hHostFile, cbNewSize);
    858858        VbglR0PhysHeapFree(pReq);
    859859        return vrc;
     
    875875 * SHFL_FN_READ request using embedded data buffer.
    876876 */
    877 DECLINLINE(int) vboxSfOs2HostReqReadEmbedded(PVBOXSFFOLDER pFolder, VBOXSFREADEMBEDDEDREQ *pReq, uint64_t hHostFile,
     877DECLINLINE(int) vboxSfOs2HostReqReadEmbedded(SHFLROOT idRoot, VBOXSFREADEMBEDDEDREQ *pReq, uint64_t hHostFile,
    878878                                             uint64_t offRead, uint32_t cbToRead)
    879879{
     
    884884
    885885    pReq->Parms.id32Root.type               = VMMDevHGCMParmType_32bit;
    886     pReq->Parms.id32Root.u.value32          = pFolder->hHostFolder.root;
     886    pReq->Parms.id32Root.u.value32          = idRoot;
    887887
    888888    pReq->Parms.u64Handle.type              = VMMDevHGCMParmType_64bit;
     
    928928 * SHFL_FN_READ request using page list for data buffer (caller populated).
    929929 */
    930 DECLINLINE(int) vboxSfOs2HostReqReadPgLst(PVBOXSFFOLDER pFolder, VBOXSFREADPGLSTREQ *pReq, uint64_t hHostFile,
     930DECLINLINE(int) vboxSfOs2HostReqReadPgLst(SHFLROOT idRoot, VBOXSFREADPGLSTREQ *pReq, uint64_t hHostFile,
    931931                                          uint64_t offRead, uint32_t cbToRead, uint32_t cPages)
    932932{
     
    936936
    937937    pReq->Parms.id32Root.type               = VMMDevHGCMParmType_32bit;
    938     pReq->Parms.id32Root.u.value32          = pFolder->hHostFolder.root;
     938    pReq->Parms.id32Root.u.value32          = idRoot;
    939939
    940940    pReq->Parms.u64Handle.type              = VMMDevHGCMParmType_64bit;
     
    966966 * SHFL_FN_READ request using a physically contiguous buffer.
    967967 */
    968 DECLINLINE(int) vboxSfOs2HostReqReadContig(PVBOXSFFOLDER pFolder, VBOXSFREADPGLSTREQ *pReq, uint64_t hHostFile,
     968DECLINLINE(int) vboxSfOs2HostReqReadContig(SHFLROOT idRoot, VBOXSFREADPGLSTREQ *pReq, uint64_t hHostFile,
    969969                                          uint64_t offRead, uint32_t cbToRead, void *pvBuffer, RTGCPHYS64 PhysBuffer)
    970970{
     
    973973
    974974    pReq->Parms.id32Root.type               = VMMDevHGCMParmType_32bit;
    975     pReq->Parms.id32Root.u.value32          = pFolder->hHostFolder.root;
     975    pReq->Parms.id32Root.u.value32          = idRoot;
    976976
    977977    pReq->Parms.u64Handle.type              = VMMDevHGCMParmType_64bit;
     
    10211021 * SHFL_FN_WRITE request using embedded data buffer.
    10221022 */
    1023 DECLINLINE(int) vboxSfOs2HostReqWriteEmbedded(PVBOXSFFOLDER pFolder, VBOXSFWRITEEMBEDDEDREQ *pReq, uint64_t hHostFile,
     1023DECLINLINE(int) vboxSfOs2HostReqWriteEmbedded(SHFLROOT idRoot, VBOXSFWRITEEMBEDDEDREQ *pReq, uint64_t hHostFile,
    10241024                                              uint64_t offWrite, uint32_t cbToWrite)
    10251025{
     
    10301030
    10311031    pReq->Parms.id32Root.type               = VMMDevHGCMParmType_32bit;
    1032     pReq->Parms.id32Root.u.value32          = pFolder->hHostFolder.root;
     1032    pReq->Parms.id32Root.u.value32          = idRoot;
    10331033
    10341034    pReq->Parms.u64Handle.type              = VMMDevHGCMParmType_64bit;
     
    10741074 * SHFL_FN_WRITE request using page list for data buffer (caller populated).
    10751075 */
    1076 DECLINLINE(int) vboxSfOs2HostReqWritePgLst(PVBOXSFFOLDER pFolder, VBOXSFWRITEPGLSTREQ *pReq, uint64_t hHostFile,
     1076DECLINLINE(int) vboxSfOs2HostReqWritePgLst(SHFLROOT idRoot, VBOXSFWRITEPGLSTREQ *pReq, uint64_t hHostFile,
    10771077                                           uint64_t offWrite, uint32_t cbToWrite, uint32_t cPages)
    10781078{
     
    10821082
    10831083    pReq->Parms.id32Root.type               = VMMDevHGCMParmType_32bit;
    1084     pReq->Parms.id32Root.u.value32          = pFolder->hHostFolder.root;
     1084    pReq->Parms.id32Root.u.value32          = idRoot;
    10851085
    10861086    pReq->Parms.u64Handle.type              = VMMDevHGCMParmType_64bit;
     
    11121112 * SHFL_FN_WRITE request using a physically contiguous buffer.
    11131113 */
    1114 DECLINLINE(int) vboxSfOs2HostReqWriteContig(PVBOXSFFOLDER pFolder, VBOXSFWRITEPGLSTREQ *pReq, uint64_t hHostFile,
     1114DECLINLINE(int) vboxSfOs2HostReqWriteContig(SHFLROOT idRoot, VBOXSFWRITEPGLSTREQ *pReq, uint64_t hHostFile,
    11151115                                            uint64_t offWrite, uint32_t cbToWrite, void const *pvBuffer, RTGCPHYS64 PhysBuffer)
    11161116{
     
    11191119
    11201120    pReq->Parms.id32Root.type               = VMMDevHGCMParmType_32bit;
    1121     pReq->Parms.id32Root.u.value32          = pFolder->hHostFolder.root;
     1121    pReq->Parms.id32Root.u.value32          = idRoot;
    11221122
    11231123    pReq->Parms.u64Handle.type              = VMMDevHGCMParmType_64bit;
     
    11581158 * both allocated on the physical heap.
    11591159 */
    1160 DECLINLINE(int) vboxSfOs2HostReqListDir(PVBOXSFFOLDER pFolder, VBOXSFLISTDIRREQ *pReq, uint64_t hHostDir,
     1160DECLINLINE(int) vboxSfOs2HostReqListDir(SHFLROOT idRoot, VBOXSFLISTDIRREQ *pReq, uint64_t hHostDir,
    11611161                                        PSHFLSTRING pFilter, uint32_t fFlags, PSHFLDIRINFO pBuffer, uint32_t cbBuffer)
    11621162{
     
    11651165
    11661166    pReq->Parms.id32Root.type                       = VMMDevHGCMParmType_32bit;
    1167     pReq->Parms.id32Root.u.value32                  = pFolder->hHostFolder.root;
     1167    pReq->Parms.id32Root.u.value32                  = idRoot;
    11681168
    11691169    pReq->Parms.u64Handle.type                      = VMMDevHGCMParmType_64bit;
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