Index: /trunk/include/VBox/shflsvc.h =================================================================== --- /trunk/include/VBox/shflsvc.h (revision 76142) +++ /trunk/include/VBox/shflsvc.h (revision 76143) @@ -131,4 +131,7 @@ * @since VBox 6.0 */ #define SHFL_FN_CANCEL_MAPPINGS_CHANGES_WAITS (23) +/** Sets the file size. + * @since VBox 6.0 */ +#define SHFL_FN_SET_FILE_SIZE (24) /** @} */ @@ -1122,4 +1125,17 @@ */ +/** SHFL_FN_MAP_FOLDER parameters. */ +typedef struct VBoxSFParmMapFolder +{ + /** pointer, in: SHFLSTRING with the name of the folder to map. */ + HGCMFunctionParameter pStrName; + /** value32, out: The root ID (SHFLROOT) of the mapping. */ + HGCMFunctionParameter id32Root; + /** value32, in: Path delimiter code point. */ + HGCMFunctionParameter uc32Delimiter; + /** value32, in: case senstive flag */ + HGCMFunctionParameter fCaseSensitive; +} VBoxSFParmMapFolder; + /** Parameters structure. */ typedef struct _VBoxSFMapFolder @@ -1157,4 +1173,11 @@ * @{ */ + +/** SHFL_FN_UNMAP_FOLDER parameters. */ +typedef struct VBoxSFParmUnmapFolder +{ + /** value32, in: SHFLROOT of the mapping to unmap */ + HGCMFunctionParameter id32Root; +} VBoxSFParmUnmapFolder; /** Parameters structure. */ @@ -1259,4 +1282,19 @@ /** Parameters structure. */ +typedef struct VBoxSFParmRead +{ + /** value32, in: SHFLROOT of the mapping with the handle. */ + HGCMFunctionParameter id32Root; + /** value64, in: SHFLHANDLE of object to read from . */ + HGCMFunctionParameter u64Handle; + /** value64, in: Offset to start reading from. */ + HGCMFunctionParameter off64Read; + /** value32, in/out: How much to try read / Actually read. */ + HGCMFunctionParameter cb32Read; + /** pointer, out: Buffer to return the data in. */ + HGCMFunctionParameter pBuf; +} VBoxSFParmRead; + +/** Parameters structure. */ typedef struct _VBoxSFRead { @@ -1400,4 +1438,13 @@ * @{ */ + +/** SHFL_FN_FLUSH parameters. */ +typedef struct VBoxSFParmFlush +{ + /** value32, in: SHFLROOT of the mapping with the handle. */ + HGCMFunctionParameter id32Root; + /** value64, in: SHFLHANDLE of object to flush. */ + HGCMFunctionParameter u64Handle; +} VBoxSFParmFlush; /** Parameters structure. */ @@ -1604,4 +1651,15 @@ #define SHFL_REMOVE_SYMLINK (0x4) +/** SHFL_FN_REMOVE parameters. */ +typedef struct VBoxSFParmRemove +{ + /** value32, in: SHFLROOT of the mapping the path is relative to. */ + HGCMFunctionParameter id32Root; + /** pointer, in: Points to SHFLSTRING buffer. */ + HGCMFunctionParameter pStrPath; + /** value32, in: SHFL_REMOVE_XXX */ + HGCMFunctionParameter f32Flags; +} VBoxSFParmRemove; + /** Parameters structure. */ typedef struct _VBoxSFRemove @@ -1637,4 +1695,17 @@ #define SHFL_RENAME_DIR (0x2) #define SHFL_RENAME_REPLACE_IF_EXISTS (0x4) + +/** SHFL_FN_RENAME parameters. */ +typedef struct VBoxSFParmRename +{ + /** value32, in: SHFLROOT of the mapping the paths are relative to. */ + HGCMFunctionParameter id32Root; + /** pointer, in: SHFLSTRING giving the source (old) path. */ + HGCMFunctionParameter pStrSrcPath; + /** pointer, in: SHFLSTRING giving the destination (new) path. */ + HGCMFunctionParameter pStrDstPath; + /** value32, in: SHFL_RENAME_XXX */ + HGCMFunctionParameter f32Flags; +} VBoxSFParmRename; /** Parameters structure. */ @@ -1775,4 +1846,25 @@ +/** @name SHFL_FN_SET_FILE_SIZE + * @{ + */ +/** SHFL_FN_SET_FILE_SIZE parameters. */ +typedef struct VBoxSFParmSetFileSize +{ + /** value32, in: SHFLROOT of the mapping the handle belongs to. */ + HGCMFunctionParameter id32Root; + /** value64, in: SHFLHANDLE of the file to change the size of. */ + HGCMFunctionParameter u64Handle; + /** value64, in: The new file size. */ + HGCMFunctionParameter cb64NewSize; +} VBoxSFParmSetFileSize; +/** Number of parameters */ +#define SHFL_CPARMS_SET_FILE_SIZE (3) +/** @} */ + + + + + /** @name SHFL_FN_ADD_MAPPING * @note Host call, no guest structure is used. Index: /trunk/src/VBox/Additions/os2/VBoxSF/VBoxSF.cpp =================================================================== --- /trunk/src/VBox/Additions/os2/VBoxSF/VBoxSF.cpp (revision 76142) +++ /trunk/src/VBox/Additions/os2/VBoxSF/VBoxSF.cpp (revision 76143) @@ -40,4 +40,5 @@ #include #include +#include #include @@ -92,4 +93,5 @@ case VERR_WRITE_PROTECT: return ERROR_WRITE_PROTECT; case VERR_IS_A_DIRECTORY: return ERROR_DIRECTORY; + case VERR_DISK_FULL: return ERROR_DISK_FULL; case VINF_SUCCESS: return NO_ERROR; } @@ -281,5 +283,5 @@ /* Note! We won't get there while the folder is on the list. */ LogRel(("vboxSfOs2ReleaseFolder: Destroying %p [%s]\n", pFolder, pFolder->szName)); - VbglR0SfUnmapFolder(&g_SfClient, &pFolder->hHostFolder); + vboxSfOs2HostReqUnmapFolderSimple(pFolder->hHostFolder.root); RT_ZERO(pFolder); RTMemFree(pFolder); @@ -387,18 +389,26 @@ /* Try do the mapping.*/ - rc = VbglR0SfMapFolder(&g_SfClient, pName, &pNew->hHostFolder); - if (RT_SUCCESS(rc)) - { - RTListAppend(&g_FolderHead, &pNew->ListEntry); - ASMAtomicIncU32(&g_uFolderRevision); - LogRel(("vboxSfOs2MapFolder: %p - %s\n", pNew, pNew->szName)); - - *ppFolder = pNew; + VBOXSFMAPFOLDERWITHBUFREQ *pReq = (VBOXSFMAPFOLDERWITHBUFREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq)); + if (pReq) + { + rc = vboxSfOs2HostReqMapFolderWithBuf(pReq, pName, RTPATH_DELIMITER, false /*fCaseSensitive*/); + if (RT_SUCCESS(rc)) + { + pNew->hHostFolder.root = pReq->Parms.id32Root.u.value32; + + RTListAppend(&g_FolderHead, &pNew->ListEntry); + ASMAtomicIncU32(&g_uFolderRevision); + LogRel(("vboxSfOs2MapFolder: %p - %s\n", pNew, pNew->szName)); + + *ppFolder = pNew; + pNew = NULL; + } + else + LogRel(("vboxSfOs2MapFolder: vboxSfOs2HostReqMapFolderWithBuf(,%s,) -> %Rrc\n", pNew->szName, rc)); + VbglR0PhysHeapFree(pReq); } else - { - LogRel(("vboxSfOs2MapFolder: VbglR0SfMapFolder(,%s,) -> %Rrc\n", pNew->szName, rc)); - RTMemFree(pNew); - } + LogRel(("vboxSfOs2MapFolder: Out of physical heap :-(\n")); + RTMemFree(pNew); } else @@ -1350,5 +1360,5 @@ && pu->Open.Req.CreateParms.Handle != SHFL_HANDLE_NIL) { - SHFLHANDLE hHandle = pu->Open.Req.CreateParms.Handle; + SHFLHANDLE volatile hHandle = pu->Open.Req.CreateParms.Handle; RT_ZERO(pu->Info.Req); @@ -1380,5 +1390,5 @@ else { - LogRel(("FS32_FSINFO: VbglR0SfFsInfo/SHFL_INFO_VOLUME failed: %Rrc\n", vrc)); + LogRel(("FS32_FSINFO: vboxSfOs2HostReqQueryVolInfo failed: %Rrc\n", vrc)); rc = ERROR_GEN_FAILURE; } @@ -1595,10 +1605,11 @@ */ PVBOXSFFOLDER pFolder; - PSHFLSTRING pStrFolderPath; - APIRET rc = vboxSfOs2ResolvePath(pszDir, pCdFsd, offCurDirEnd, &pFolder, &pStrFolderPath); + VBOXSFREMOVEREQ *pReq; + APIRET rc = vboxSfOs2ResolvePathEx(pszDir, pCdFsd, offCurDirEnd, RT_UOFFSETOF(VBOXSFREMOVEREQ, StrPath), + &pFolder, (void **)&pReq); if (rc == NO_ERROR) { - int vrc = VbglR0SfRemove(&g_SfClient, &pFolder->hHostFolder, pStrFolderPath, SHFL_REMOVE_DIR); - LogFlow(("FS32_RMDIR: VbglR0SfRemove -> %Rrc\n", rc)); + int vrc = vboxSfOs2HostReqRemove(pFolder, pReq, SHFL_REMOVE_DIR); + LogFlow(("FS32_RMDIR: vboxSfOs2HostReqRemove -> %Rrc\n", rc)); if (RT_SUCCESS(vrc)) rc = NO_ERROR; @@ -1606,5 +1617,6 @@ rc = vboxSfOs2ConvertStatusToOs2(vrc, ERROR_ACCESS_DENIED); - vboxSfOs2ReleasePathAndFolder(pStrFolderPath, pFolder); + VbglR0PhysHeapFree(pReq); + vboxSfOs2ReleaseFolder(pFolder); } @@ -1644,7 +1656,8 @@ if (rc == NO_ERROR) { - PVBOXSFFOLDER pDstFolder; - PSHFLSTRING pDstFolderPath; - rc = vboxSfOs2ResolvePath(pszDst, pCdFsd, offDstCurDirEnd, &pDstFolder, &pDstFolderPath); + PVBOXSFFOLDER pDstFolder; + VBOXSFRENAMEWITHSRCBUFREQ *pReq; + rc = vboxSfOs2ResolvePathEx(pszDst, pCdFsd, offDstCurDirEnd, RT_UOFFSETOF(VBOXSFRENAMEWITHSRCBUFREQ, StrDstPath), + &pDstFolder, (void **)&pReq); if (rc == NO_ERROR) { @@ -1655,11 +1668,10 @@ * Note! Requires 6.0.0beta2+ or 5.2.24+ host for renaming files. */ - int vrc = VbglR0SfRename(&g_SfClient, &pSrcFolder->hHostFolder, pSrcFolderPath, pDstFolderPath, - SHFL_RENAME_FILE | SHFL_RENAME_DIR); + int vrc = vboxSfOs2HostReqRenameWithSrcBuf(pSrcFolder, pReq, pSrcFolderPath, SHFL_RENAME_FILE | SHFL_RENAME_DIR); if (RT_SUCCESS(vrc)) rc = NO_ERROR; else { - Log(("FS32_MOVE: VbglR0SfRename failed: %Rrc\n", rc)); + Log(("FS32_MOVE: vboxSfOs2HostReqRenameWithSrcBuf failed: %Rrc\n", rc)); rc = vboxSfOs2ConvertStatusToOs2(vrc, ERROR_ACCESS_DENIED); } @@ -1667,8 +1679,9 @@ else { - Log(("FS32_MOVE: source folder '%s' != destiation folder '%s'\n", pSrcFolder->szName, pDstFolder->szName)); + Log(("FS32_MOVE: source folder '%s' != destiation folder '%s'\n", pszSrc, pszDst)); rc = ERROR_NOT_SAME_DEVICE; } - vboxSfOs2ReleasePathAndFolder(pDstFolderPath, pDstFolder); + VbglR0PhysHeapFree(pReq); + vboxSfOs2ReleaseFolder(pDstFolder); } vboxSfOs2ReleasePathAndFolder(pSrcFolderPath, pSrcFolder); @@ -1688,11 +1701,12 @@ * Resolve the path. */ - PVBOXSFFOLDER pFolder; - PSHFLSTRING pStrFolderPath; - APIRET rc = vboxSfOs2ResolvePath(pszFile, pCdFsd, offCurDirEnd, &pFolder, &pStrFolderPath); + PVBOXSFFOLDER pFolder; + VBOXSFREMOVEREQ *pReq; + APIRET rc = vboxSfOs2ResolvePathEx(pszFile, pCdFsd, offCurDirEnd, RT_UOFFSETOF(VBOXSFREMOVEREQ, StrPath), + &pFolder, (void **)&pReq); if (rc == NO_ERROR) { - int vrc = VbglR0SfRemove(&g_SfClient, &pFolder->hHostFolder, pStrFolderPath, SHFL_REMOVE_FILE); - LogFlow(("FS32_DELETE: VbglR0SfRemove -> %Rrc\n", rc)); + int vrc = vboxSfOs2HostReqRemove(pFolder, pReq, SHFL_REMOVE_FILE); + LogFlow(("FS32_DELETE: vboxSfOs2HostReqRemove -> %Rrc\n", rc)); if (RT_SUCCESS(vrc)) rc = NO_ERROR; @@ -1700,5 +1714,6 @@ rc = vboxSfOs2ConvertStatusToOs2(vrc, ERROR_ACCESS_DENIED); - vboxSfOs2ReleasePathAndFolder(pStrFolderPath, pFolder); + VbglR0PhysHeapFree(pReq); + vboxSfOs2ReleaseFolder(pFolder); } @@ -1714,14 +1729,17 @@ * * @returns OS/2 status code - * @param pFolder The folder. - * @param hHostFile The host file handle. - * @param fAttribs The attributes to set. - * @param pTimestamps Pointer to the timestamps. NULL if none should be - * modified. - * @param pObjInfoBuf Buffer to use when setting the attributes (host will - * return current info upon successful return). + * @param pFolder The folder. + * @param hHostFile The host file handle. + * @param fAttribs The attributes to set. + * @param pTimestamps Pointer to the timestamps. NULL if none should be + * modified. + * @param pObjInfoBuf Buffer to use when setting the attributes (host + * will return current info upon successful + * return). This must life on the phys heap. + * @param offObjInfoInAlloc Offset of pObjInfoBuf in the phys heap + * allocation where it lives. */ APIRET vboxSfOs2SetInfoCommonWorker(PVBOXSFFOLDER pFolder, SHFLHANDLE hHostFile, ULONG fAttribs, - PFILESTATUS pTimestamps, PSHFLFSOBJINFO pObjInfoBuf) + PFILESTATUS pTimestamps, PSHFLFSOBJINFO pObjInfoBuf, uint32_t offObjInfoInAlloc) { /* @@ -1766,12 +1784,16 @@ * Call the host to do the updating. */ - uint32_t cbBuf = sizeof(*pObjInfoBuf); - int vrc = VbglR0SfFsInfo(&g_SfClient, &pFolder->hHostFolder, hHostFile, SHFL_INFO_SET | SHFL_INFO_FILE, - &cbBuf, (SHFLDIRINFO *)pObjInfoBuf); - LogFlow(("vboxSfOs2SetFileInfo: VbglR0SfFsInfo -> %Rrc\n", vrc)); - - if (RT_SUCCESS(vrc)) - return NO_ERROR; - return vboxSfOs2ConvertStatusToOs2(vrc, ERROR_ACCESS_DENIED); + VBOXSFOBJINFOWITHBUFREQ *pReq = (VBOXSFOBJINFOWITHBUFREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq)); + if (pReq) + { + int vrc = vboxSfOs2HostReqSetObjInfoWithBuf(pFolder, pReq, hHostFile, pObjInfoBuf, offObjInfoInAlloc); + LogFlow(("vboxSfOs2SetFileInfo: vboxSfOs2HostReqSetObjInfoWithBuf -> %Rrc\n", vrc)); + + VbglR0PhysHeapFree(pReq); + if (RT_SUCCESS(vrc)) + return NO_ERROR; + return vboxSfOs2ConvertStatusToOs2(vrc, ERROR_ACCESS_DENIED); + } + return ERROR_NOT_ENOUGH_MEMORY; } @@ -1821,12 +1843,9 @@ * Join up with FS32_FILEINFO to do the actual setting. */ - uint64_t const uHandle = pReq->CreateParms.Handle; - ASMCompilerBarrier(); /* paranoia */ - rc = vboxSfOs2SetInfoCommonWorker(pFolder, pReq->CreateParms.Handle, fAttribs, pTimestamps, - &pReq->CreateParms.Info); - - AssertCompile(sizeof(VBOXSFCLOSEREQ) < sizeof(*pReq)); - vrc = vboxSfOs2HostReqClose(pFolder, (VBOXSFCLOSEREQ *)pReq, uHandle); + &pReq->CreateParms.Info, RT_UOFFSETOF(VBOXSFCREATEREQ, CreateParms.Info)); + + AssertCompile(RTASSERT_OFFSET_OF(VBOXSFCREATEREQ, CreateParms.Handle) > sizeof(VBOXSFCLOSEREQ)); /* no aliasing issues */ + vrc = vboxSfOs2HostReqClose(pFolder, (VBOXSFCLOSEREQ *)pReq, pReq->CreateParms.Handle); AssertRC(vrc); } Index: /trunk/src/VBox/Additions/os2/VBoxSF/VBoxSFFile.cpp =================================================================== --- /trunk/src/VBox/Additions/os2/VBoxSF/VBoxSFFile.cpp (revision 76142) +++ /trunk/src/VBox/Additions/os2/VBoxSF/VBoxSFFile.cpp (revision 76143) @@ -152,5 +152,6 @@ */ int vrc = vboxSfOs2HostReqCreate(pFolder, pReq); - LogFlow(("FS32_OPENCREATE: VbglR0SfCreate -> %Rrc Result=%d fMode=%#x\n", vrc, pReq->CreateParms.Result, pReq->CreateParms.Info.Attr.fMode)); + LogFlow(("FS32_OPENCREATE: vboxSfOs2HostReqCreate -> %Rrc Result=%d fMode=%#x\n", + vrc, pReq->CreateParms.Result, pReq->CreateParms.Info.Attr.fMode)); if (RT_SUCCESS(vrc)) { @@ -198,5 +199,6 @@ { LogRel(("FS32_OPENCREATE: cbObject=%#RX64 no OPEN_FLAGS_LARGEFILE (%s)\n", pReq->CreateParms.Info.cbObject, pszName)); - VbglR0SfClose(&g_SfClient, &pFolder->hHostFolder, pReq->CreateParms.Handle); + AssertCompile(RTASSERT_OFFSET_OF(VBOXSFCREATEREQ, CreateParms.Handle) > sizeof(VBOXSFCLOSEREQ)); /* no aliasing issues */ + vboxSfOs2HostReqClose(pFolder, (VBOXSFCLOSEREQ *)pReq, pReq->CreateParms.Handle); rc = ERROR_ACCESS_DENIED; } @@ -251,5 +253,5 @@ RT_NOREF(fIoFlags); - int vrc = VbglR0SfClose(&g_SfClient, &pFolder->hHostFolder, pSfFsd->hHostFile); + int vrc = vboxSfOs2HostReqCloseSimple(pFolder, pSfFsd->hHostFile); AssertRC(vrc); @@ -290,8 +292,8 @@ || (pSfFsi->sfi_mode & SFMODE_OPEN_ACCESS) == SFMODE_OPEN_READWRITE) { - int vrc = VbglR0SfFlush(&g_SfClient, &pFolder->hHostFolder, pSfFsd->hHostFile); + int vrc = vboxSfOs2HostReqFlushSimple(pFolder, pSfFsd->hHostFile); if (RT_FAILURE(vrc)) { - LogRel(("FS32_COMMIT: VbglR0SfFlush failed: %Rrc\n", vrc)); + LogRel(("FS32_COMMIT: vboxSfOs2HostReqFlushSimple failed: %Rrc\n", vrc)); return ERROR_FLUSHBUF_FAILED; } @@ -345,23 +347,22 @@ { /* Have to consult the host to get the current file size. */ - - PSHFLFSOBJINFO pObjInfo = (PSHFLFSOBJINFO)VbglR0PhysHeapAlloc(sizeof(*pObjInfo)); - if (!pObjInfo) + VBOXSFOBJINFOREQ *pReq = (VBOXSFOBJINFOREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq)); + if (pReq) + RT_ZERO(*pReq); + else return ERROR_NOT_ENOUGH_MEMORY; - RT_ZERO(*pObjInfo); - uint32_t cbObjInfo = sizeof(*pObjInfo); - - int vrc = VbglR0SfFsInfo(&g_SfClient, &pFolder->hHostFolder, pSfFsd->hHostFile, - SHFL_INFO_FILE | SHFL_INFO_GET, &cbObjInfo, (PSHFLDIRINFO)pObjInfo); + + int vrc = vboxSfOs2HostReqQueryObjInfo(pFolder, pReq, pSfFsd->hHostFile); if (RT_SUCCESS(vrc)) { if (pSfFsi->sfi_mode & SFMODE_LARGE_FILE) - pSfFsi->sfi_sizel = pObjInfo->cbObject; + pSfFsi->sfi_sizel = pReq->ObjInfo.cbObject; else - pSfFsi->sfi_sizel = RT_MIN(pObjInfo->cbObject, _2G - 1); + pSfFsi->sfi_sizel = RT_MIN(pReq->ObjInfo.cbObject, _2G - 1); } else LogRel(("FS32_CHGFILEPTRL/CFP_RELEND: VbglR0SfFsInfo failed: %Rrc\n", vrc)); - VbglR0PhysHeapFree(pObjInfo); + + VbglR0PhysHeapFree(pReq); offNew = pSfFsi->sfi_sizel + off; @@ -425,5 +426,4 @@ }; SHFLFSOBJINFO ObjInfo; - } *pBuf = (struct SetFileInfoBuf *)VbglR0PhysHeapAlloc(sizeof(*pBuf)); if (pBuf) @@ -438,5 +438,5 @@ rc = vboxSfOs2SetInfoCommonWorker(pFolder, pSfFsd->hHostFile, uLevel == FI_LVL_STANDARD ? pBuf->Lvl1.attrFile : pBuf->Lvl1L.attrFile, - &pBuf->Lvl1, &pBuf->ObjInfo); + &pBuf->Lvl1, &pBuf->ObjInfo, RT_UOFFSETOF(struct SetFileInfoBuf, ObjInfo)); if (rc == NO_ERROR) { @@ -467,4 +467,5 @@ +#if 0 DECLVBGL(int) VbglR0SfFastPhysFsInfo(PVBGLSFCLIENT pClient, PVBGLSFMAP pMap, SHFLHANDLE hFile, @@ -588,4 +589,6 @@ } +#endif + /** @@ -712,5 +715,5 @@ else rc = ERROR_NOT_ENOUGH_MEMORY; -#else +#elif 0 APIRET rc; struct MyEmbReq @@ -761,4 +764,35 @@ { Log(("vboxSfOs2QueryFileInfo: VbglR0SfFsInfo failed: %Rrc\n", vrc)); + rc = vboxSfOs2ConvertStatusToOs2(vrc, ERROR_GEN_FAILURE); + } + + VbglR0PhysHeapFree(pReq); + } + else + rc = ERROR_NOT_ENOUGH_MEMORY; +#else /* clean version of the above. */ + APIRET rc; + VBOXSFOBJINFOREQ *pReq = (VBOXSFOBJINFOREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq)); + if (pReq) + { + int vrc = vboxSfOs2HostReqQueryObjInfo(pFolder, pReq, pSfFsd->hHostFile); + if (RT_SUCCESS(vrc)) + { + rc = vboxSfOs2FileStatusFromObjInfo(pbData, cbData, uLevel, &pReq->ObjInfo); + if (rc == NO_ERROR) + { + /* Update the timestamps in the independent file data: */ + int16_t cMinLocalTimeDelta = vboxSfOs2GetLocalTimeDelta(); + vboxSfOs2DateTimeFromTimeSpec(&pSfFsi->sfi_cdate, &pSfFsi->sfi_ctime, pReq->ObjInfo.BirthTime, cMinLocalTimeDelta); + vboxSfOs2DateTimeFromTimeSpec(&pSfFsi->sfi_adate, &pSfFsi->sfi_atime, pReq->ObjInfo.AccessTime, cMinLocalTimeDelta); + vboxSfOs2DateTimeFromTimeSpec(&pSfFsi->sfi_mdate, &pSfFsi->sfi_mtime, pReq->ObjInfo.ModificationTime, cMinLocalTimeDelta); + + /* And the size field as we're at it: */ + pSfFsi->sfi_sizel = pReq->ObjInfo.cbObject; + } + } + else + { + Log(("vboxSfOs2QueryFileInfo: vboxSfOs2HostReqQueryObjInfo failed: %Rrc\n", vrc)); rc = vboxSfOs2ConvertStatusToOs2(vrc, ERROR_GEN_FAILURE); } @@ -929,33 +963,17 @@ { /* - * Call the host. We need a full object info structure here to pass - * a 64-bit unsigned integer value. Sigh. + * Call the host. */ - /** @todo Shared folders: New SET_FILE_SIZE API. */ - PSHFLFSOBJINFO pObjInfo = (PSHFLFSOBJINFO)VbglR0PhysHeapAlloc(sizeof(*pObjInfo)); - if (pObjInfo) - { - RT_ZERO(*pObjInfo); - pObjInfo->cbObject = cbFile; - uint32_t cbObjInfo = sizeof(*pObjInfo); - int vrc = VbglR0SfFsInfo(&g_SfClient, &pFolder->hHostFolder, pSfFsd->hHostFile, - SHFL_INFO_SIZE | SHFL_INFO_SET, &cbObjInfo, (PSHFLDIRINFO)pObjInfo); - if (RT_SUCCESS(vrc)) - { - pSfFsi->sfi_sizel = cbFile; - rc = NO_ERROR; - } - else - { - LogRel(("FS32_NEWSIZEL: VbglR0SfFsInfo failed: %Rrc\n", vrc)); - if (vrc == VERR_DISK_FULL) - rc = ERROR_DISK_FULL; - else - rc = ERROR_GEN_FAILURE; - } - VbglR0PhysHeapFree(pObjInfo); + int vrc = vboxSfOs2HostReqSetFileSizeSimple(pFolder, pSfFsd->hHostFile, cbFile); + if (RT_SUCCESS(vrc)) + { + pSfFsi->sfi_sizel = cbFile; + rc = NO_ERROR; } else - rc = ERROR_NOT_ENOUGH_MEMORY; + { + LogRel(("FS32_NEWSIZEL: VbglR0SfFsInfo failed: %Rrc\n", vrc)); + rc = vboxSfOs2ConvertStatusToOs2(vrc, ERROR_GEN_FAILURE); + } } else @@ -988,19 +1006,23 @@ * avoid locking/unlocking user memory. */ - uint64_t offRead = pSfFsi->sfi_positionl; - uint32_t cbRead = *pcb; - uint32_t cbActual = cbRead; - if (cbRead <= _8K - ALLOC_HDR_SIZE) - { - void *pvBuf = VbglR0PhysHeapAlloc(cbRead); - if (pvBuf != NULL) - { + uint64_t const offRead = pSfFsi->sfi_positionl; + uint32_t const cbToRead = *pcb; + uint32_t cbActual = cbToRead; +#if 0 /** @todo debug some other day. */ + if (cbToRead <= _8K - ALLOC_HDR_SIZE - RT_UOFFSETOF(VBOXSFREADEMBEDDEDREQ, abData[0])) + { + size_t cbReq = RT_UOFFSETOF(VBOXSFREADEMBEDDEDREQ, abData[0]) + RT_ALIGN_32(cbToRead, 4); + VBOXSFREADEMBEDDEDREQ *pReq = (VBOXSFREADEMBEDDEDREQ *)VbglR0PhysHeapAlloc(cbReq); + if (pReq != NULL) + { + RT_BZERO(pReq, cbReq); + APIRET rc; - int vrc = VbglR0SfRead(&g_SfClient, &pFolder->hHostFolder, pSfFsd->hHostFile, - offRead, &cbActual, (uint8_t *)pvBuf, true /*fLocked*/); + int vrc = vboxSfOs2HostReqReadEmbedded(pFolder, pReq, pSfFsd->hHostFile, offRead, cbToRead); if (RT_SUCCESS(vrc)) { - AssertStmt(cbActual <= cbRead, cbActual = cbRead); - rc = KernCopyOut(pvData, pvBuf, cbActual); + cbActual = pReq->Parms.cb32Read.u.value32; + AssertStmt(cbActual <= cbToRead, cbActual = cbToRead); + rc = KernCopyOut(pvData, &pReq->abData[0], cbActual); if (rc == NO_ERROR) { @@ -1015,11 +1037,13 @@ else { - Log(("FS32_READ: VbglR0SfRead(off=%#x,cb=%#x) -> %Rrc [copy]\n", offRead, cbRead, vrc)); + Log(("FS32_READ: vboxSfOs2HostReqReadEmbedded(off=%#RU64,cb=%#x) -> %Rrc [copy]\n", offRead, cbToRead, vrc)); rc = ERROR_BAD_NET_RESP; } - VbglR0PhysHeapFree(pvBuf); + VbglR0PhysHeapFree(pReq); return rc; } } +#endif + /* @@ -1030,5 +1054,5 @@ if (RT_SUCCESS(vrc)) { - AssertStmt(cbActual <= cbRead, cbActual = cbRead); + AssertStmt(cbActual <= cbToRead, cbActual = cbToRead); *pcb = cbActual; pSfFsi->sfi_positionl = offRead + cbActual; @@ -1039,5 +1063,5 @@ return NO_ERROR; } - Log(("FS32_READ: VbglR0SfRead(off=%#x,cb=%#x) -> %Rrc [direct]\n", offRead, cbRead, vrc)); + Log(("FS32_READ: VbglR0SfRead(off=%#RU64,cb=%#x) -> %Rrc [direct]\n", offRead, cbToRead, vrc)); RT_NOREF_PV(fIoFlags); return ERROR_BAD_NET_RESP; Index: /trunk/src/VBox/Additions/os2/VBoxSF/VBoxSFFind.cpp =================================================================== --- /trunk/src/VBox/Additions/os2/VBoxSF/VBoxSFFind.cpp (revision 76142) +++ /trunk/src/VBox/Additions/os2/VBoxSF/VBoxSFFind.cpp (revision 76143) @@ -467,11 +467,14 @@ * Resolve path to a folder and folder relative path. */ - PVBOXSFFOLDER pFolder; - PSHFLSTRING pStrFolderPath; RT_NOREF(pCdFsi); - APIRET rc = vboxSfOs2ResolvePath(pszPath, pCdFsd, offCurDirEnd, &pFolder, &pStrFolderPath); - LogFlow(("FS32_FINDFIRST: vboxSfOs2ResolvePath: -> %u pFolder=%p\n", rc, pFolder)); + PVBOXSFFOLDER pFolder; + VBOXSFCREATEREQ *pReq; + APIRET rc = vboxSfOs2ResolvePathEx(pszPath, pCdFsd, offCurDirEnd, RT_UOFFSETOF(VBOXSFCREATEREQ, StrPath), + &pFolder, (void **)&pReq); + LogFlow(("FS32_FINDFIRST: vboxSfOs2ResolvePathEx: -> %u pReq=%p\n", rc, pReq)); if (rc == NO_ERROR) { + PSHFLSTRING pStrFolderPath = &pReq->StrPath; + /* * Look for a wildcard filter at the end of the path, saving it all for @@ -537,10 +540,11 @@ else if (pwszFilter) { - pFilter = pStrFolderPath; - pStrFolderPath = vboxSfOs2StrAlloc(pwszFilter - pFilter->String.utf16); - if (pStrFolderPath) - { - pStrFolderPath->u16Length = (uint16_t)((uintptr_t)pwszFilter - (uintptr_t)pFilter->String.utf16); - memcpy(pStrFolderPath->String.utf16, pFilter->String.utf16, pStrFolderPath->u16Length); + /* Copy the whole path for filtering. */ + pFilter = vboxSfOs2StrDup(pStrFolderPath); + if (pFilter) + { + /* Strip the filename off the one we're opening. */ + pStrFolderPath->u16Length = (uint16_t)((uintptr_t)pwszFilter - (uintptr_t)pStrFolderPath->String.utf16); + pStrFolderPath->u16Size = pStrFolderPath->u16Length + (uint16_t)sizeof(RTUTF16); pStrFolderPath->String.utf16[pStrFolderPath->u16Length / sizeof(RTUTF16)] = '\0'; } @@ -559,4 +563,5 @@ * Make sure we've got a buffer for keeping unused search results. */ + /** @todo use phys heap for this too? */ PVBOXSFFSBUF pDataBuf = NULL; if (rc == NO_ERROR) @@ -578,25 +583,23 @@ /* * Now, try open the directory for reading. - * We pre-use the data buffer for parameter passin to avoid - * wasting any stack space. */ - PSHFLCREATEPARMS pParams = (PSHFLCREATEPARMS)(pDataBuf + 1); - RT_ZERO(*pParams); - pParams->CreateFlags = SHFL_CF_DIRECTORY | SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACT_OPEN_IF_EXISTS - | SHFL_CF_ACCESS_READ | SHFL_CF_ACCESS_ATTR_READ | SHFL_CF_ACCESS_DENYNONE; - int vrc = VbglR0SfCreate(&g_SfClient, &pFolder->hHostFolder, pStrFolderPath, pParams); - LogFlow(("FS32_FINDFIRST: VbglR0SfCreate(%ls) -> %Rrc Result=%d fMode=%#x hHandle=%#RX64\n", - pStrFolderPath->String.utf16, vrc, pParams->Result, pParams->Info.Attr.fMode, pParams->Handle)); + pReq->CreateParms.CreateFlags = SHFL_CF_DIRECTORY | SHFL_CF_ACT_FAIL_IF_NEW | SHFL_CF_ACT_OPEN_IF_EXISTS + | SHFL_CF_ACCESS_READ | SHFL_CF_ACCESS_ATTR_READ | SHFL_CF_ACCESS_DENYNONE; + + int vrc = vboxSfOs2HostReqCreate(pFolder, pReq); + LogFlow(("FS32_FINDFIRST: vboxSfOs2HostReqCreate(%ls) -> %Rrc Result=%d fMode=%#x hHandle=%#RX64\n", + pStrFolderPath->String.utf16, vrc, pReq->CreateParms.Result, pReq->CreateParms.Info.Attr.fMode, + pReq->CreateParms.Handle)); if (RT_SUCCESS(vrc)) { - switch (pParams->Result) + switch (pReq->CreateParms.Result) { case SHFL_FILE_EXISTS: - if (pParams->Handle != SHFL_HANDLE_NIL) + if (pReq->CreateParms.Handle != SHFL_HANDLE_NIL) { /* * Initialize the structures. */ - pFsFsd->hHostDir = pParams->Handle; + pFsFsd->hHostDir = pReq->CreateParms.Handle; pFsFsd->u32Magic = VBOXSFFS_MAGIC; pFsFsd->pFolder = pFolder; @@ -631,5 +634,6 @@ else { - vrc = VbglR0SfClose(&g_SfClient, &pFolder->hHostFolder, pFsFsd->hHostDir); + AssertCompile(sizeof(VBOXSFCLOSEREQ) < sizeof(*pReq)); + vrc = vboxSfOs2HostReqClose(pFolder, (VBOXSFCLOSEREQ *)pReq, pFsFsd->hHostDir); AssertRC(vrc); pFsFsd->u32Magic = ~VBOXSFFS_MAGIC; @@ -641,5 +645,6 @@ else { - LogFlow(("FS32_FINDFIRST: VbglR0SfCreate returns NIL handle for '%ls'\n", pStrFolderPath->String.utf16)); + LogFlow(("FS32_FINDFIRST: vboxSfOs2HostReqCreate returns NIL handle for '%ls'\n", + pStrFolderPath->String.utf16)); rc = ERROR_PATH_NOT_FOUND; } @@ -661,7 +666,7 @@ RTMemFree(pDataBuf); - if (pFilter != pStrFolderPath) - vboxSfOs2StrFree(pFilter); - vboxSfOs2ReleasePathAndFolder(pStrFolderPath, pFolder); + vboxSfOs2StrFree(pFilter); + VbglR0PhysHeapFree(pReq); + vboxSfOs2ReleaseFolder(pFolder); } @@ -801,5 +806,5 @@ if (pFsFsd->hHostDir != SHFL_HANDLE_NIL) { - int vrc = VbglR0SfClose(&g_SfClient, &pFolder->hHostFolder, pFsFsd->hHostDir); + int vrc = vboxSfOs2HostReqCloseSimple(pFolder, pFsFsd->hHostDir); AssertRC(vrc); } Index: /trunk/src/VBox/Additions/os2/VBoxSF/VBoxSFInternal.h =================================================================== --- /trunk/src/VBox/Additions/os2/VBoxSF/VBoxSFInternal.h (revision 76142) +++ /trunk/src/VBox/Additions/os2/VBoxSF/VBoxSFInternal.h (revision 76143) @@ -238,5 +238,5 @@ APIRET vboxSfOs2FileStatusFromObjInfo(PBYTE pbDst, ULONG cbDst, ULONG uLevel, SHFLFSOBJINFO const *pSrc); APIRET vboxSfOs2SetInfoCommonWorker(PVBOXSFFOLDER pFolder, SHFLHANDLE hHostFile, ULONG fAttribs, - PFILESTATUS pTimestamps, PSHFLFSOBJINFO pObjInfoBuf); + PFILESTATUS pTimestamps, PSHFLFSOBJINFO pObjInfoBuf, uint32_t offObjInfoInAlloc); APIRET vboxSfOs2MakeEmptyEaList(PEAOP pEaOp, ULONG uLevel); APIRET vboxSfOs2MakeEmptyEaListEx(PEAOP pEaOp, ULONG uLevel, uint32_t *pcbWritten, ULONG *poffError); @@ -244,4 +244,104 @@ DECLASM(PVBOXSFVP) Fsh32GetVolParams(USHORT hVbp, PVPFSI *ppVpFsi /*optional*/); + +/** @name Host request helpers + * + * @todo generalize these and put back into VbglR0Sf. + * + * @{ */ + + +/** Request structure for vboxSfOs2HostReqMapFolderWithBuf. */ +typedef struct VBOXSFMAPFOLDERWITHBUFREQ +{ + VBGLIOCIDCHGCMFASTCALL Hdr; + VMMDevHGCMCall Call; + VBoxSFParmMapFolder Parms; + union + { + HGCMPageListInfo PgLst; + uint8_t abPadding[8 + sizeof(RTGCPHYS64) * 2 /*RT_UOFFSETOF(HGCMPageListInfo, aPages[2])*/]; + } u; +} VBOXSFMAPFOLDERWITHBUFREQ; + +/** + * SHFL_FN_MAP_FOLDER request. + */ +DECLINLINE(int) vboxSfOs2HostReqMapFolderWithBuf(VBOXSFMAPFOLDERWITHBUFREQ *pReq, PSHFLSTRING pStrName, + RTUTF16 wcDelimiter, bool fCaseSensitive) +{ + pReq->Parms.id32Root.type = VMMDevHGCMParmType_32bit; + pReq->Parms.id32Root.u.value32 = SHFL_ROOT_NIL; + + pReq->Parms.uc32Delimiter.type = VMMDevHGCMParmType_32bit; + pReq->Parms.uc32Delimiter.u.value32 = wcDelimiter; + + pReq->Parms.fCaseSensitive.type = VMMDevHGCMParmType_32bit; + pReq->Parms.fCaseSensitive.u.value32 = fCaseSensitive; + + AssertReturn(pStrName->u16Size <= PAGE_SIZE - SHFLSTRING_HEADER_SIZE, VERR_FILENAME_TOO_LONG); + pReq->Parms.pStrName.type = VMMDevHGCMParmType_PageList; + pReq->Parms.pStrName.u.PageList.size = SHFLSTRING_HEADER_SIZE + pStrName->u16Size; + pReq->Parms.pStrName.u.PageList.offset = RT_UOFFSETOF(VBOXSFMAPFOLDERWITHBUFREQ, u.PgLst) - sizeof(VBGLIOCIDCHGCMFASTCALL); + pReq->u.PgLst.flags = VBOX_HGCM_F_PARM_DIRECTION_BOTH; + pReq->u.PgLst.aPages[0] = VbglR0PhysHeapGetPhysAddr(pStrName); + pReq->u.PgLst.offFirstPage = (uint16_t)(pReq->u.PgLst.aPages[0] & PAGE_OFFSET_MASK); + pReq->u.PgLst.aPages[0] &= ~(RTGCPHYS)PAGE_OFFSET_MASK; + uint32_t cbReq; + if (PAGE_SIZE - pReq->u.PgLst.offFirstPage <= pStrName->u16Size + SHFLSTRING_HEADER_SIZE) + { + pReq->u.PgLst.cPages = 1; + cbReq = RT_UOFFSETOF(VBOXSFMAPFOLDERWITHBUFREQ, u.PgLst.aPages[1]); + } + else + { + pReq->u.PgLst.aPages[1] = pReq->u.PgLst.aPages[0] + PAGE_SIZE; + pReq->u.PgLst.cPages = 2; + cbReq = RT_UOFFSETOF(VBOXSFMAPFOLDERWITHBUFREQ, u.PgLst.aPages[2]); + } + + VBGLIOCIDCHGCMFASTCALL_INIT(&pReq->Hdr, VbglR0PhysHeapGetPhysAddr(pReq), &pReq->Call, g_SfClient.idClient, + SHFL_FN_MAP_FOLDER, SHFL_CPARMS_MAP_FOLDER, cbReq); + + int vrc = VbglR0HGCMFastCall(g_SfClient.handle, &pReq->Hdr, cbReq); + if (RT_SUCCESS(vrc)) + vrc = pReq->Call.header.result; + return vrc; +} + + + +/** Request structure used by vboxSfOs2HostReqUnmapFolder. */ +typedef struct VBOXSFUNMAPFOLDERREQ +{ + VBGLIOCIDCHGCMFASTCALL Hdr; + VMMDevHGCMCall Call; + VBoxSFParmUnmapFolder Parms; +} VBOXSFUNMAPFOLDERREQ; + + +/** + * SHFL_FN_UNMAP_FOLDER request. + */ +DECLINLINE(int) vboxSfOs2HostReqUnmapFolderSimple(uint32_t idRoot) +{ + VBOXSFUNMAPFOLDERREQ *pReq = (VBOXSFUNMAPFOLDERREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq)); + if (pReq) + { + pReq->Parms.id32Root.type = VMMDevHGCMParmType_32bit; + pReq->Parms.id32Root.u.value32 = idRoot; + + VBGLIOCIDCHGCMFASTCALL_INIT(&pReq->Hdr, VbglR0PhysHeapGetPhysAddr(pReq), &pReq->Call, g_SfClient.idClient, + SHFL_FN_UNMAP_FOLDER, SHFL_CPARMS_UNMAP_FOLDER, sizeof(*pReq)); + + int vrc = VbglR0HGCMFastCall(g_SfClient.handle, &pReq->Hdr, sizeof(*pReq)); + if (RT_SUCCESS(vrc)) + vrc = pReq->Call.header.result; + + VbglR0PhysHeapFree(pReq); + return vrc; + } + return VERR_NO_MEMORY; +} @@ -286,5 +386,5 @@ -/** Request structure for vboxSfOs2HostReqCreate. */ +/** Request structure for vboxSfOs2HostReqClose. */ typedef struct VBOXSFCLOSEREQ { @@ -297,5 +397,5 @@ * SHFL_FN_CLOSE request. */ -DECLINLINE(int) vboxSfOs2HostReqClose(PVBOXSFFOLDER pFolder, VBOXSFCLOSEREQ *pReq, uint64_t uHandle) +DECLINLINE(int) vboxSfOs2HostReqClose(PVBOXSFFOLDER pFolder, VBOXSFCLOSEREQ *pReq, uint64_t hHostFile) { VBGLIOCIDCHGCMFASTCALL_INIT(&pReq->Hdr, VbglR0PhysHeapGetPhysAddr(pReq), &pReq->Call, g_SfClient.idClient, @@ -306,5 +406,5 @@ pReq->Parms.u64Handle.type = VMMDevHGCMParmType_64bit; - pReq->Parms.u64Handle.u.value64 = uHandle; + pReq->Parms.u64Handle.u.value64 = hHostFile; int vrc = VbglR0HGCMFastCall(g_SfClient.handle, &pReq->Hdr, sizeof(*pReq)); @@ -312,4 +412,19 @@ vrc = pReq->Call.header.result; return vrc; +} + +/** + * SHFL_FN_CLOSE request, allocate request buffer. + */ +DECLINLINE(int) vboxSfOs2HostReqCloseSimple(PVBOXSFFOLDER pFolder, uint64_t hHostFile) +{ + VBOXSFCLOSEREQ *pReq = (VBOXSFCLOSEREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq)); + if (pReq) + { + int vrc = vboxSfOs2HostReqClose(pFolder, pReq, hHostFile); + VbglR0PhysHeapFree(pReq); + return vrc; + } + return VERR_NO_MEMORY; } @@ -327,5 +442,5 @@ * SHFL_FN_INFORMATION[SHFL_INFO_VOLUME | SHFL_INFO_GET] request. */ -DECLINLINE(int) vboxSfOs2HostReqQueryVolInfo(PVBOXSFFOLDER pFolder, VBOXSFVOLINFOREQ *pReq, uint64_t uHandle) +DECLINLINE(int) vboxSfOs2HostReqQueryVolInfo(PVBOXSFFOLDER pFolder, VBOXSFVOLINFOREQ *pReq, uint64_t hHostFile) { VBGLIOCIDCHGCMFASTCALL_INIT(&pReq->Hdr, VbglR0PhysHeapGetPhysAddr(pReq), &pReq->Call, g_SfClient.idClient, @@ -336,5 +451,5 @@ pReq->Parms.u64Handle.type = VMMDevHGCMParmType_64bit; - pReq->Parms.u64Handle.u.value64 = uHandle; + pReq->Parms.u64Handle.u.value64 = hHostFile; pReq->Parms.f32Flags.type = VMMDevHGCMParmType_32bit; @@ -356,4 +471,375 @@ +/** Request structure for vboxSfOs2HostReqSetObjInfo & vboxSfOs2HostReqQueryObjInfo. */ +typedef struct VBOXSFOBJINFOREQ +{ + VBGLIOCIDCHGCMFASTCALL Hdr; + VMMDevHGCMCall Call; + VBoxSFParmInformation Parms; + SHFLFSOBJINFO ObjInfo; +} VBOXSFOBJINFOREQ; + +/** + * SHFL_FN_INFORMATION[SHFL_INFO_GET | SHFL_INFO_FILE] request. + */ +DECLINLINE(int) vboxSfOs2HostReqQueryObjInfo(PVBOXSFFOLDER pFolder, VBOXSFOBJINFOREQ *pReq, uint64_t hHostFile) +{ + VBGLIOCIDCHGCMFASTCALL_INIT(&pReq->Hdr, VbglR0PhysHeapGetPhysAddr(pReq), &pReq->Call, g_SfClient.idClient, + SHFL_FN_INFORMATION, SHFL_CPARMS_INFORMATION, sizeof(*pReq)); + + pReq->Parms.id32Root.type = VMMDevHGCMParmType_32bit; + pReq->Parms.id32Root.u.value32 = pFolder->hHostFolder.root; + + pReq->Parms.u64Handle.type = VMMDevHGCMParmType_64bit; + pReq->Parms.u64Handle.u.value64 = hHostFile; + + pReq->Parms.f32Flags.type = VMMDevHGCMParmType_32bit; + pReq->Parms.f32Flags.u.value32 = SHFL_INFO_GET | SHFL_INFO_FILE; + + pReq->Parms.cb32.type = VMMDevHGCMParmType_32bit; + pReq->Parms.cb32.u.value32 = sizeof(pReq->ObjInfo); + + pReq->Parms.pInfo.type = VMMDevHGCMParmType_Embedded; + pReq->Parms.pInfo.u.Embedded.cbData = sizeof(pReq->ObjInfo); + pReq->Parms.pInfo.u.Embedded.offData = RT_UOFFSETOF(VBOXSFOBJINFOREQ, ObjInfo) - sizeof(VBGLIOCIDCHGCMFASTCALL); + pReq->Parms.pInfo.u.Embedded.fFlags = VBOX_HGCM_F_PARM_DIRECTION_FROM_HOST; + + int vrc = VbglR0HGCMFastCall(g_SfClient.handle, &pReq->Hdr, sizeof(*pReq)); + if (RT_SUCCESS(vrc)) + vrc = pReq->Call.header.result; + return vrc; +} + + +/** + * SHFL_FN_INFORMATION[SHFL_INFO_SET | SHFL_INFO_FILE] request. + */ +DECLINLINE(int) vboxSfOs2HostReqSetObjInfo(PVBOXSFFOLDER pFolder, VBOXSFOBJINFOREQ *pReq, uint64_t hHostFile) +{ + VBGLIOCIDCHGCMFASTCALL_INIT(&pReq->Hdr, VbglR0PhysHeapGetPhysAddr(pReq), &pReq->Call, g_SfClient.idClient, + SHFL_FN_INFORMATION, SHFL_CPARMS_INFORMATION, sizeof(*pReq)); + + pReq->Parms.id32Root.type = VMMDevHGCMParmType_32bit; + pReq->Parms.id32Root.u.value32 = pFolder->hHostFolder.root; + + pReq->Parms.u64Handle.type = VMMDevHGCMParmType_64bit; + pReq->Parms.u64Handle.u.value64 = hHostFile; + + pReq->Parms.f32Flags.type = VMMDevHGCMParmType_32bit; + pReq->Parms.f32Flags.u.value32 = SHFL_INFO_SET | SHFL_INFO_FILE; + + pReq->Parms.cb32.type = VMMDevHGCMParmType_32bit; + pReq->Parms.cb32.u.value32 = sizeof(pReq->ObjInfo); + + pReq->Parms.pInfo.type = VMMDevHGCMParmType_Embedded; + pReq->Parms.pInfo.u.Embedded.cbData = sizeof(pReq->ObjInfo); + pReq->Parms.pInfo.u.Embedded.offData = RT_UOFFSETOF(VBOXSFOBJINFOREQ, ObjInfo) - sizeof(VBGLIOCIDCHGCMFASTCALL); + pReq->Parms.pInfo.u.Embedded.fFlags = VBOX_HGCM_F_PARM_DIRECTION_BOTH; + + int vrc = VbglR0HGCMFastCall(g_SfClient.handle, &pReq->Hdr, sizeof(*pReq)); + if (RT_SUCCESS(vrc)) + vrc = pReq->Call.header.result; + return vrc; +} + + +/** Request structure for vboxSfOs2HostReqSetObjInfo. */ +typedef struct VBOXSFOBJINFOWITHBUFREQ +{ + VBGLIOCIDCHGCMFASTCALL Hdr; + VMMDevHGCMCall Call; + VBoxSFParmInformation Parms; + union + { + HGCMPageListInfo PgLst; + uint8_t abPadding[8 + sizeof(RTGCPHYS64) * 2 /*RT_UOFFSETOF(HGCMPageListInfo, aPages[2])*/]; + } u; +} VBOXSFOBJINFOWITHBUFREQ; + +/** + * SHFL_FN_INFORMATION[SHFL_INFO_SET | SHFL_INFO_FILE] request, with separate + * buffer (on the physical heap). + */ +DECLINLINE(int) vboxSfOs2HostReqSetObjInfoWithBuf(PVBOXSFFOLDER pFolder, VBOXSFOBJINFOWITHBUFREQ *pReq, uint64_t hHostFile, + PSHFLFSOBJINFO pObjInfo, uint32_t offObjInfoInAlloc) +{ + pReq->Parms.id32Root.type = VMMDevHGCMParmType_32bit; + pReq->Parms.id32Root.u.value32 = pFolder->hHostFolder.root; + + pReq->Parms.u64Handle.type = VMMDevHGCMParmType_64bit; + pReq->Parms.u64Handle.u.value64 = hHostFile; + + pReq->Parms.f32Flags.type = VMMDevHGCMParmType_32bit; + pReq->Parms.f32Flags.u.value32 = SHFL_INFO_SET | SHFL_INFO_FILE; + + pReq->Parms.cb32.type = VMMDevHGCMParmType_32bit; + pReq->Parms.cb32.u.value32 = sizeof(*pObjInfo); + + pReq->Parms.pInfo.type = VMMDevHGCMParmType_PageList; + pReq->Parms.pInfo.u.PageList.size = sizeof(*pObjInfo); + pReq->Parms.pInfo.u.PageList.offset = RT_UOFFSETOF(VBOXSFOBJINFOREQ, ObjInfo) - sizeof(VBGLIOCIDCHGCMFASTCALL); + pReq->u.PgLst.flags = VBOX_HGCM_F_PARM_DIRECTION_BOTH; + pReq->u.PgLst.aPages[0] = VbglR0PhysHeapGetPhysAddr((uint8_t *)pObjInfo - offObjInfoInAlloc) + offObjInfoInAlloc; + pReq->u.PgLst.offFirstPage = (uint16_t)(pReq->u.PgLst.aPages[0] & PAGE_OFFSET_MASK); + pReq->u.PgLst.aPages[0] &= ~(RTGCPHYS)PAGE_OFFSET_MASK; + uint32_t cbReq; + if (PAGE_SIZE - pReq->u.PgLst.offFirstPage <= sizeof(*pObjInfo)) + { + pReq->u.PgLst.cPages = 1; + cbReq = RT_UOFFSETOF(VBOXSFOBJINFOWITHBUFREQ, u.PgLst.aPages[1]); + } + else + { + pReq->u.PgLst.aPages[1] = pReq->u.PgLst.aPages[0] + PAGE_SIZE; + pReq->u.PgLst.cPages = 2; + cbReq = RT_UOFFSETOF(VBOXSFOBJINFOWITHBUFREQ, u.PgLst.aPages[2]); + } + + VBGLIOCIDCHGCMFASTCALL_INIT(&pReq->Hdr, VbglR0PhysHeapGetPhysAddr(pReq), &pReq->Call, g_SfClient.idClient, + SHFL_FN_INFORMATION, SHFL_CPARMS_INFORMATION, cbReq); + + int vrc = VbglR0HGCMFastCall(g_SfClient.handle, &pReq->Hdr, cbReq); + if (RT_SUCCESS(vrc)) + vrc = pReq->Call.header.result; + return vrc; +} + + +/** Request structure for vboxSfOs2HostReqRemove. */ +typedef struct VBOXSFREMOVEREQ +{ + VBGLIOCIDCHGCMFASTCALL Hdr; + VMMDevHGCMCall Call; + VBoxSFParmRemove Parms; + SHFLSTRING StrPath; +} VBOXSFREMOVEREQ; + +/** + * SHFL_FN_REMOVE request. + */ +DECLINLINE(int) vboxSfOs2HostReqRemove(PVBOXSFFOLDER pFolder, VBOXSFREMOVEREQ *pReq, uint32_t fFlags) +{ + VBGLIOCIDCHGCMFASTCALL_INIT(&pReq->Hdr, VbglR0PhysHeapGetPhysAddr(pReq), &pReq->Call, g_SfClient.idClient, + SHFL_FN_REMOVE, SHFL_CPARMS_REMOVE, + RT_UOFFSETOF(VBOXSFREMOVEREQ, StrPath.String) + pReq->StrPath.u16Size); + + pReq->Parms.id32Root.type = VMMDevHGCMParmType_32bit; + pReq->Parms.id32Root.u.value32 = pFolder->hHostFolder.root; + + pReq->Parms.pStrPath.type = VMMDevHGCMParmType_Embedded; + pReq->Parms.pStrPath.u.Embedded.cbData = SHFLSTRING_HEADER_SIZE + pReq->StrPath.u16Size; + pReq->Parms.pStrPath.u.Embedded.offData = RT_UOFFSETOF(VBOXSFREMOVEREQ, StrPath) - sizeof(VBGLIOCIDCHGCMFASTCALL); + pReq->Parms.pStrPath.u.Embedded.fFlags = VBOX_HGCM_F_PARM_DIRECTION_TO_HOST; + + pReq->Parms.f32Flags.type = VMMDevHGCMParmType_32bit; + pReq->Parms.f32Flags.u.value32 = fFlags; + + int vrc = VbglR0HGCMFastCall(g_SfClient.handle, &pReq->Hdr, + RT_UOFFSETOF(VBOXSFREMOVEREQ, StrPath.String) + pReq->StrPath.u16Size); + if (RT_SUCCESS(vrc)) + vrc = pReq->Call.header.result; + return vrc; +} + + +/** Request structure for vboxSfOs2HostReqRename. */ +typedef struct VBOXSFRENAMEWITHSRCBUFREQ +{ + VBGLIOCIDCHGCMFASTCALL Hdr; + VMMDevHGCMCall Call; + VBoxSFParmRename Parms; + union + { + HGCMPageListInfo PgLst; + uint8_t abPadding[8 + sizeof(RTGCPHYS64) * 2 /*RT_UOFFSETOF(HGCMPageListInfo, aPages[2])*/]; + } u; + SHFLSTRING StrDstPath; +} VBOXSFRENAMEWITHSRCBUFREQ; + +/** + * SHFL_FN_REMOVE request. + */ +DECLINLINE(int) vboxSfOs2HostReqRenameWithSrcBuf(PVBOXSFFOLDER pFolder, VBOXSFRENAMEWITHSRCBUFREQ *pReq, + PSHFLSTRING pSrcStr, uint32_t fFlags) +{ + VBGLIOCIDCHGCMFASTCALL_INIT(&pReq->Hdr, VbglR0PhysHeapGetPhysAddr(pReq), &pReq->Call, g_SfClient.idClient, + SHFL_FN_RENAME, SHFL_CPARMS_RENAME, + RT_UOFFSETOF(VBOXSFRENAMEWITHSRCBUFREQ, StrDstPath.String) + pReq->StrDstPath.u16Size); + + pReq->Parms.id32Root.type = VMMDevHGCMParmType_32bit; + pReq->Parms.id32Root.u.value32 = pFolder->hHostFolder.root; + + /** @todo Using page lists for contiguous buffers sucks. */ + AssertReturn(pSrcStr->u16Size <= PAGE_SIZE - SHFLSTRING_HEADER_SIZE, VERR_FILENAME_TOO_LONG); + pReq->Parms.pStrSrcPath.type = VMMDevHGCMParmType_PageList; + pReq->Parms.pStrSrcPath.u.PageList.size = SHFLSTRING_HEADER_SIZE + pSrcStr->u16Size; + pReq->Parms.pStrSrcPath.u.PageList.offset = RT_UOFFSETOF(VBOXSFRENAMEWITHSRCBUFREQ, u.PgLst) - sizeof(VBGLIOCIDCHGCMFASTCALL); + pReq->u.PgLst.flags = VBOX_HGCM_F_PARM_DIRECTION_TO_HOST; + pReq->u.PgLst.aPages[0] = VbglR0PhysHeapGetPhysAddr(pSrcStr); + pReq->u.PgLst.offFirstPage = (uint16_t)(pReq->u.PgLst.aPages[0] & PAGE_OFFSET_MASK); + pReq->u.PgLst.aPages[0] &= ~(RTGCPHYS)PAGE_OFFSET_MASK; + if (PAGE_SIZE - pReq->u.PgLst.offFirstPage <= SHFLSTRING_HEADER_SIZE + pSrcStr->u16Size) + { + pReq->u.PgLst.aPages[1] = NIL_RTGCPHYS64; + pReq->u.PgLst.cPages = 1; + } + else + { + pReq->u.PgLst.aPages[1] = pReq->u.PgLst.aPages[0] + PAGE_SIZE; + pReq->u.PgLst.cPages = 2; + } + + pReq->Parms.pStrDstPath.type = VMMDevHGCMParmType_Embedded; + pReq->Parms.pStrDstPath.u.Embedded.cbData = SHFLSTRING_HEADER_SIZE + pReq->StrDstPath.u16Size; + pReq->Parms.pStrDstPath.u.Embedded.offData = RT_UOFFSETOF(VBOXSFRENAMEWITHSRCBUFREQ, StrDstPath) - sizeof(VBGLIOCIDCHGCMFASTCALL); + pReq->Parms.pStrDstPath.u.Embedded.fFlags = VBOX_HGCM_F_PARM_DIRECTION_TO_HOST; + + pReq->Parms.f32Flags.type = VMMDevHGCMParmType_32bit; + pReq->Parms.f32Flags.u.value32 = fFlags; + + int vrc = VbglR0HGCMFastCall(g_SfClient.handle, &pReq->Hdr, + RT_UOFFSETOF(VBOXSFRENAMEWITHSRCBUFREQ, StrDstPath.String) + pReq->StrDstPath.u16Size); + if (RT_SUCCESS(vrc)) + vrc = pReq->Call.header.result; + return vrc; +} + + +/** Request structure for vboxSfOs2HostReqFlush. */ +typedef struct VBOXSFFLUSHREQ +{ + VBGLIOCIDCHGCMFASTCALL Hdr; + VMMDevHGCMCall Call; + VBoxSFParmFlush Parms; +} VBOXSFFLUSHREQ; + +/** + * SHFL_FN_FLUSH request. + */ +DECLINLINE(int) vboxSfOs2HostReqFlush(PVBOXSFFOLDER pFolder, VBOXSFFLUSHREQ *pReq, uint64_t hHostFile) +{ + VBGLIOCIDCHGCMFASTCALL_INIT(&pReq->Hdr, VbglR0PhysHeapGetPhysAddr(pReq), &pReq->Call, g_SfClient.idClient, + SHFL_FN_FLUSH, SHFL_CPARMS_FLUSH, sizeof(*pReq)); + + pReq->Parms.id32Root.type = VMMDevHGCMParmType_32bit; + pReq->Parms.id32Root.u.value32 = pFolder->hHostFolder.root; + + pReq->Parms.u64Handle.type = VMMDevHGCMParmType_64bit; + pReq->Parms.u64Handle.u.value64 = hHostFile; + + int vrc = VbglR0HGCMFastCall(g_SfClient.handle, &pReq->Hdr, sizeof(*pReq)); + if (RT_SUCCESS(vrc)) + vrc = pReq->Call.header.result; + return vrc; +} + +/** + * SHFL_FN_FLUSH request, allocate request buffer. + */ +DECLINLINE(int) vboxSfOs2HostReqFlushSimple(PVBOXSFFOLDER pFolder, uint64_t hHostFile) +{ + VBOXSFFLUSHREQ *pReq = (VBOXSFFLUSHREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq)); + if (pReq) + { + int vrc = vboxSfOs2HostReqFlush(pFolder, pReq, hHostFile); + VbglR0PhysHeapFree(pReq); + return vrc; + } + return VERR_NO_MEMORY; +} + + +/** Request structure for vboxSfOs2HostReqSetFileSize. */ +typedef struct VBOXSFSETFILESIZEREQ +{ + VBGLIOCIDCHGCMFASTCALL Hdr; + VMMDevHGCMCall Call; + VBoxSFParmSetFileSize Parms; +} VBOXSFSETFILESIZEREQ; + +/** + * SHFL_FN_SET_FILE_SIZE request. + */ +DECLINLINE(int) vboxSfOs2HostReqSetFileSize(PVBOXSFFOLDER pFolder, VBOXSFSETFILESIZEREQ *pReq, + uint64_t hHostFile, uint64_t cbNewSize) +{ + VBGLIOCIDCHGCMFASTCALL_INIT(&pReq->Hdr, VbglR0PhysHeapGetPhysAddr(pReq), &pReq->Call, g_SfClient.idClient, + SHFL_FN_SET_FILE_SIZE, SHFL_CPARMS_SET_FILE_SIZE, sizeof(*pReq)); + + pReq->Parms.id32Root.type = VMMDevHGCMParmType_32bit; + pReq->Parms.id32Root.u.value32 = pFolder->hHostFolder.root; + + pReq->Parms.u64Handle.type = VMMDevHGCMParmType_64bit; + pReq->Parms.u64Handle.u.value64 = hHostFile; + + pReq->Parms.cb64NewSize.type = VMMDevHGCMParmType_64bit; + pReq->Parms.cb64NewSize.u.value64 = cbNewSize; + + int vrc = VbglR0HGCMFastCall(g_SfClient.handle, &pReq->Hdr, sizeof(*pReq)); + if (RT_SUCCESS(vrc)) + vrc = pReq->Call.header.result; + return vrc; +} + +/** + * SHFL_FN_SET_FILE_SIZE request, allocate request buffer. + */ +DECLINLINE(int) vboxSfOs2HostReqSetFileSizeSimple(PVBOXSFFOLDER pFolder, uint64_t hHostFile, uint64_t cbNewSize) +{ + VBOXSFSETFILESIZEREQ *pReq = (VBOXSFSETFILESIZEREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq)); + if (pReq) + { + int vrc = vboxSfOs2HostReqSetFileSize(pFolder, pReq, hHostFile, cbNewSize); + VbglR0PhysHeapFree(pReq); + return vrc; + } + return VERR_NO_MEMORY; +} + + +/** Request structure for vboxSfOs2HostReqRead. */ +typedef struct VBOXSFREADEMBEDDEDREQ +{ + VBGLIOCIDCHGCMFASTCALL Hdr; + VMMDevHGCMCall Call; + VBoxSFParmRead Parms; + uint8_t abData[RT_FLEXIBLE_ARRAY]; +} VBOXSFREADEMBEDDEDREQ; + +/** + * SHFL_FN_INFORMATION[SHFL_INFO_GET | SHFL_INFO_FILE] request. + */ +DECLINLINE(int) vboxSfOs2HostReqReadEmbedded(PVBOXSFFOLDER pFolder, VBOXSFREADEMBEDDEDREQ *pReq, uint64_t hHostFile, + uint64_t offRead, uint32_t cbToRead) +{ + VBGLIOCIDCHGCMFASTCALL_INIT(&pReq->Hdr, VbglR0PhysHeapGetPhysAddr(pReq), &pReq->Call, g_SfClient.idClient, + SHFL_FN_READ, SHFL_CPARMS_READ, RT_UOFFSETOF(VBOXSFREADEMBEDDEDREQ, abData[0]) + cbToRead); + + pReq->Parms.id32Root.type = VMMDevHGCMParmType_32bit; + pReq->Parms.id32Root.u.value32 = pFolder->hHostFolder.root; + + pReq->Parms.u64Handle.type = VMMDevHGCMParmType_64bit; + pReq->Parms.u64Handle.u.value64 = hHostFile; + + pReq->Parms.off64Read.type = VMMDevHGCMParmType_64bit; + pReq->Parms.off64Read.u.value64 = offRead; + + pReq->Parms.cb32Read.type = VMMDevHGCMParmType_32bit; + pReq->Parms.cb32Read.u.value32 = cbToRead; + + pReq->Parms.pBuf.type = VMMDevHGCMParmType_Embedded; + pReq->Parms.pBuf.u.Embedded.cbData = cbToRead; + pReq->Parms.pBuf.u.Embedded.offData = RT_UOFFSETOF(VBOXSFREADEMBEDDEDREQ, abData[0]) - sizeof(VBGLIOCIDCHGCMFASTCALL); + pReq->Parms.pBuf.u.Embedded.fFlags = VBOX_HGCM_F_PARM_DIRECTION_FROM_HOST; + + int vrc = VbglR0HGCMFastCall(g_SfClient.handle, &pReq->Hdr, RT_UOFFSETOF(VBOXSFREADEMBEDDEDREQ, abData[0]) + cbToRead); + if (RT_SUCCESS(vrc)) + vrc = pReq->Call.header.result; + return vrc; +} + + +/** @} */ + #endif Index: /trunk/src/VBox/HostServices/SharedFolders/service.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedFolders/service.cpp (revision 76142) +++ /trunk/src/VBox/HostServices/SharedFolders/service.cpp (revision 76143) @@ -91,4 +91,6 @@ static STAMPROFILE g_StatFlushFail; static STAMPROFILE g_StatSetUtf8; +static STAMPROFILE g_StatSetFileSize; +static STAMPROFILE g_StatSetFileSizeFail; static STAMPROFILE g_StatSymlink; static STAMPROFILE g_StatSymlinkFail; @@ -1497,4 +1499,21 @@ /* Execute the function: */ rc = vbsfMappingsCancelChangesWaits(pClient); + break; + } + + case SHFL_FN_SET_FILE_SIZE: + { + pStat = &g_StatSetFileSize; + pStatFail = &g_StatSetFileSizeFail; + Log(("SharedFolders host service: svcCall: SHFL_FN_SET_FILE_SIZE\n")); + + /* Validate input: */ + ASSERT_GUEST_STMT_BREAK(cParms == SHFL_CPARMS_SET_FILE_SIZE, rc = VERR_WRONG_PARAMETER_COUNT); + ASSERT_GUEST_STMT_BREAK(paParms[0].type == VBOX_HGCM_SVC_PARM_32BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* id32Root */ + ASSERT_GUEST_STMT_BREAK(paParms[1].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* u64Handle */ + ASSERT_GUEST_STMT_BREAK(paParms[2].type == VBOX_HGCM_SVC_PARM_64BIT, rc = VERR_WRONG_PARAMETER_TYPE); /* cb64NewSize */ + + /* Execute the function: */ + rc = vbsfSetFileSize(pClient, paParms[0].u.uint32, paParms[1].u.uint64, paParms[2].u.uint64); break; } Index: /trunk/src/VBox/HostServices/SharedFolders/vbsf.cpp =================================================================== --- /trunk/src/VBox/HostServices/SharedFolders/vbsf.cpp (revision 76142) +++ /trunk/src/VBox/HostServices/SharedFolders/vbsf.cpp (revision 76143) @@ -30,4 +30,5 @@ #include "shflhandle.h" +#include #include #include @@ -1583,4 +1584,27 @@ +/** + * Handles SHFL_FN_SET_FILE_SIZE. + */ +int vbsfSetFileSize(SHFLCLIENTDATA *pClient, SHFLROOT idRoot, SHFLHANDLE hHandle, uint64_t cbNewSize) +{ + /* + * Resolve handle and validate write access. + */ + SHFLFILEHANDLE *pHandle = vbsfQueryFileHandle(pClient, hHandle); + ASSERT_GUEST_RETURN(pHandle, VERR_INVALID_HANDLE); + + int rc = vbsfCheckHandleAccess(pClient, idRoot, pHandle, VBSF_CHECK_ACCESS_WRITE); + if (RT_SUCCESS(rc)) + { + /* + * Execute the request. + */ + rc = RTFileSetSize(pHandle->file.Handle, cbNewSize); + } + return rc; +} + + static int vbsfSetEndOfFile(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint32_t flags, uint32_t *pcbBuffer, uint8_t *pBuffer) Index: /trunk/src/VBox/HostServices/SharedFolders/vbsf.h =================================================================== --- /trunk/src/VBox/HostServices/SharedFolders/vbsf.h (revision 76142) +++ /trunk/src/VBox/HostServices/SharedFolders/vbsf.h (revision 76143) @@ -34,4 +34,5 @@ int vbsfDirList(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, SHFLSTRING *pPath, uint32_t flags, uint32_t *pcbBuffer, uint8_t *pBuffer, uint32_t *pIndex, uint32_t *pcFiles); int vbsfFileInfo(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint32_t flags, uint32_t *pcbBuffer, uint8_t *pBuffer); +int vbsfSetFileSize(SHFLCLIENTDATA *pClient, SHFLROOT idRoot, SHFLHANDLE hHandle, uint64_t cbNewSize); int vbsfQueryFSInfo(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint32_t flags, uint32_t *pcbBuffer, uint8_t *pBuffer); int vbsfSetFSInfo(SHFLCLIENTDATA *pClient, SHFLROOT root, SHFLHANDLE Handle, uint32_t flags, uint32_t *pcbBuffer, uint8_t *pBuffer);