VirtualBox

Changeset 78365 in vbox for trunk/src/VBox


Ignore:
Timestamp:
May 2, 2019 9:49:04 PM (6 years ago)
Author:
vboxsync
Message:

winnt/vboxsf: Try keep the FCB file sizes (in FSRTL_COMMON_FCB_HEADER) up to date when we have relevant info handy. For now that means setting information, querying information and reading. bugref:9172

Location:
trunk/src/VBox/Additions/WINNT/SharedFolders/driver
Files:
4 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/SharedFolders/driver/file.cpp

    r78363 r78365  
    227227static NTSTATUS vbsfReadInternal(IN PRX_CONTEXT RxContext)
    228228{
    229     NTSTATUS Status = STATUS_SUCCESS;
    230229    VBSFTRANSFERCTX ctx;
    231230
    … …  
    240239
    241240    PMDL BufferMdl = LowIoContext->ParamsFor.ReadWrite.Buffer;
    242     uint32_t ByteCount = LowIoContext->ParamsFor.ReadWrite.ByteCount;
    243     RXVBO ByteOffset = LowIoContext->ParamsFor.ReadWrite.ByteOffset;
    244241
    245242    PVOID pbUserBuffer = RxLowIoGetBufferAddress(RxContext);
    246 
    247     int vrc;
    248243
    249244#ifdef LOG_ENABLED
    … …  
    258253         pbUserBuffer, BufferMdl));
    259254    Log(("VBOXSF: vbsfReadInternal: ByteCount 0x%X, ByteOffset 0x%RX64, FileSize 0x%RX64\n",
    260          ByteCount, ByteOffset, FileSize));
     255         LowIoContext->ParamsFor.ReadWrite.ByteCount, LowIoContext->ParamsFor.ReadWrite.ByteOffset, FileSize));
    261256
    262257    AssertReturn(BufferMdl, STATUS_INVALID_PARAMETER);
    263     Assert(ByteCount > 0); /* ASSUME this is taken care of elsewhere already. */
     258    Assert(LowIoContext->ParamsFor.ReadWrite.ByteCount > 0); /* ASSUME this is taken care of elsewhere already. */
    264259
    265260    ctx.pClient = &g_SfClient;
    266261    ctx.pMap    = &pNetRootExtension->map;
    267262    ctx.hFile   = pVBoxFobx->hFile;
    268     ctx.offset  = (uint64_t)ByteOffset;
    269     ctx.cbData  = ByteCount;
     263    ctx.offset  = LowIoContext->ParamsFor.ReadWrite.ByteOffset;
     264    ctx.cbData  = LowIoContext->ParamsFor.ReadWrite.ByteCount;
    270265    ctx.pMdl    = BufferMdl;
    271266    ctx.pBuffer = (uint8_t *)pbUserBuffer;
    … …  
    274269    ctx.pfnTransferPages = vbsfTransferPagesRead;
    275270
    276     vrc = vbsfTransferCommon(&ctx);
    277 
    278     ByteCount = ctx.cbData;
    279 
    280     Status = vbsfNtVBoxStatusToNt(vrc);
    281 
    282     if (Status == STATUS_SUCCESS)
     271    int vrc = vbsfTransferCommon(&ctx);
     272
     273    NTSTATUS Status;
     274    if (RT_SUCCESS(vrc))
    283275    {
    284276        pVBoxFobx->fTimestampsImplicitlyUpdated |= VBOX_FOBX_F_INFO_LASTACCESS_TIME;
    285277        if (pVBoxFcbx->pFobxLastAccessTime != pVBoxFobx)
    286278            pVBoxFcbx->pFobxLastAccessTime = NULL;
     279        Status = STATUS_SUCCESS;
     280
     281        /*
     282         * See if we've reached the EOF early or read beyond what we thought were the EOF.
     283         *
     284         * Note! We don't dare do this (yet) if we're in paging I/O as we then hold the
     285         *       PagingIoResource in shared mode and would probably deadlock in the
     286         *       updating code when taking the lock in exclusive mode.
     287         */
     288        if (RxContext->LowIoContext.Resource != capFcb->Header.PagingIoResource)
     289        {
     290            LONGLONG const offEndOfRead = LowIoContext->ParamsFor.ReadWrite.ByteOffset + ctx.cbData;
     291            LONGLONG       cbFileRdbss;
     292            RxGetFileSizeWithLock((PFCB)capFcb, &cbFileRdbss);
     293            if (   offEndOfRead < cbFileRdbss
     294                && ctx.cbData < LowIoContext->ParamsFor.ReadWrite.ByteCount /* hit EOF */)
     295                vbsfNtUpdateFcbSize(RxContext->pFobx->AssociatedFileObject, capFcb, pVBoxFobx, offEndOfRead, cbFileRdbss, -1);
     296            else if (offEndOfRead > cbFileRdbss)
     297                vbsfNtQueryAndUpdateFcbSize(pNetRootExtension, RxContext->pFobx->AssociatedFileObject, pVBoxFobx, capFcb, pVBoxFcbx);
     298        }
    287299    }
    288300    else
    289         ByteCount = 0; /* Nothing read. */
    290 
    291     RxContext->InformationToReturn = ByteCount;
    292 
    293 /** @todo if we read past the end-of-file as we know it, or if we reached
    294  * end-of-file earlier than we though, update the file size.  The
    295  * RxLowIoReadShellCompletion() routine does not seem to do this for is and
    296  * I (bird) couldn't find anyone else doing it either. */
     301    {
     302        ctx.cbData = 0; /* Nothing read. */
     303        Status = vbsfNtVBoxStatusToNt(vrc);
     304    }
     305
     306    RxContext->InformationToReturn = ctx.cbData;
    297307
    298308    Log(("VBOXSF: vbsfReadInternal: Status = 0x%08X, ByteCount = 0x%X\n",
    299          Status, ByteCount));
     309         Status, ctx.cbData));
    300310
    301311    return Status;
    … …  
    317327}
    318328
     329/**
     330 * Read stuff from a file.
     331 *
     332 * Prior to calling us, RDBSS will have:
     333 *  - Called CcFlushCache() for uncached accesses.
     334 *  - For non-paging access the Fcb.Header.Resource lock in shared mode in one
     335 *    way or another (ExAcquireResourceSharedLite,
     336 *    ExAcquireSharedWaitForExclusive).
     337 *  - For paging the FCB isn't, but the Fcb.Header.PagingResource is taken
     338 *    in shared mode (ExAcquireResourceSharedLite).
     339 *
     340 * Upon completion, it will update the file pointer if applicable.  There are no
     341 * EOF checks and corresponding file size updating like in the write case, so
     342 * that's something we have to do ourselves it seems since the library relies on
     343 * the size information to be accurate in a few places (set EOF, cached reads).
     344 */
    319345NTSTATUS VBoxMRxRead(IN PRX_CONTEXT RxContext)
    320346{

  • trunk/src/VBox/Additions/WINNT/SharedFolders/driver/info.cpp

    r78355 r78365  
    926926
    927927/**
     928 * Updates the FCBs copy of the file size.
     929 *
     930 * The RDBSS is using the file size from the FCB in a few places without giving
     931 * us the chance to make sure that the value is up to date and properly
     932 * reflecting the size of the actual file on the host.   Thus this mess to try
     933 * keep the the size up to date where ever possible as well as some hacks to
     934 * bypass RDBSS' use of the FCB file size.  (And no, we cannot just make the
     935 * FCB_STATE_FILESIZECACHEING_ENABLED flag isn't set, because it was never
     936 * implemented.)
     937 *
     938 * @param   pFileObj            The file object.
     939 * @param   pFcb                The FCB.
     940 * @param   pVBoxFobX           Out file object extension data.
     941 * @param   cbFileNew           The new file size.
     942 * @param   cbFileOld           The old file size from the FCB/RDBSS.
     943 * @param   cbAllocated         The allocated size for the file, -1 if not
     944 *                              available.
     945 *
     946 * @note    Will acquire the paging I/O resource lock in exclusive mode.  Caller
     947 *          must not be holding it in shared mode.
     948 */
     949void vbsfNtUpdateFcbSize(PFILE_OBJECT pFileObj, PMRX_FCB pFcb, PMRX_VBOX_FOBX pVBoxFobX,
     950                         LONGLONG cbFileNew, LONGLONG cbFileOld, LONGLONG cbAllocated)
     951{
     952    Assert(cbFileNew != cbFileOld);
     953    Assert(cbFileNew >= 0);
     954    Assert(   !ExIsResourceAcquiredSharedLite(pFcb->Header.PagingIoResource)
     955           || ExIsResourceAcquiredExclusiveLite(pFcb->Header.PagingIoResource));
     956
     957    /*
     958     * Lock the paging I/O resources before trying to modify the header variables.
     959     *
     960     * Note! RxAcquirePagingIoResource and RxReleasePagingIoResource are unsafe
     961     *       macros in need of {} wrappers when used with if statements.
     962     */
     963    NTSTATUS rcNtLock = RxAcquirePagingIoResource(NULL, pFcb);
     964
     965    LONGLONG cbFileOldRecheck;
     966    RxGetFileSizeWithLock((PFCB)pFcb, &cbFileOldRecheck);
     967    if (cbFileOldRecheck == cbFileOld)
     968    {
     969        LONGLONG cbFileNewCopy = cbFileNew;
     970        RxSetFileSizeWithLock((PFCB)pFcb, &cbFileNewCopy);
     971
     972        /* The valid data length is the same as the file size for us. */
     973        if (pFcb->Header.ValidDataLength.QuadPart != cbFileNew)
     974            pFcb->Header.ValidDataLength.QuadPart = cbFileNew;
     975
     976        /* The allocation size must be larger or equal to the file size says https://www.osronline.com/article.cfm%5Eid=167.htm . */
     977        if (cbAllocated >= cbFileNew)
     978        {
     979            if (pFcb->Header.AllocationSize.QuadPart != cbAllocated)
     980                pFcb->Header.AllocationSize.QuadPart = cbAllocated;
     981        }
     982        else if (pFcb->Header.AllocationSize.QuadPart < cbFileNew)
     983            pFcb->Header.AllocationSize.QuadPart = cbFileNew;
     984
     985        /* Update our copy. */
     986        pVBoxFobX->Info.cbObject = cbFileNew;
     987        if (cbAllocated >= 0)
     988            pVBoxFobX->Info.cbAllocated = cbAllocated;
     989
     990        /*
     991         * Tell the cache manager if we can.
     992         *
     993         * According to the MSDN documentation, we must update the cache manager when
     994         * the file size changes, allocation size increases, valid data length descreases,
     995         * and when a non-cached I/O operation increases the valid data length.
     996         */
     997        SECTION_OBJECT_POINTERS *pSectPtrs = pFileObj->SectionObjectPointer;
     998        if (pSectPtrs)
     999        {
     1000            LARGE_INTEGER NewSize;
     1001            NewSize.QuadPart = cbFileNew;
     1002            if (   cbFileNew >= cbFileOld
     1003                || MmCanFileBeTruncated(pSectPtrs, &NewSize)) /** @todo do we need to check this? */
     1004            {
     1005                CC_FILE_SIZES FileSizes;
     1006                FileSizes.AllocationSize           = pFcb->Header.AllocationSize;
     1007                FileSizes.FileSize.QuadPart        = cbFileNew;
     1008                FileSizes.ValidDataLength.QuadPart = cbFileNew;
     1009
     1010                /* RDBSS leave the lock before calling CcSetFileSizes, so we do that too then.*/
     1011                if (NT_SUCCESS(rcNtLock))
     1012                {
     1013                    RxReleasePagingIoResource(NULL, pFcb);
     1014                }
     1015
     1016                __try
     1017                {
     1018                    CcSetFileSizes(pFileObj, &FileSizes);
     1019                }
     1020                __except(EXCEPTION_EXECUTE_HANDLER)
     1021                {
     1022#ifdef LOG_ENABLED
     1023                    NTSTATUS rcNt = GetExceptionCode();
     1024                    Log(("vbsfNtUpdateFcbSize: CcSetFileSizes -> %#x\n", rcNt));
     1025#endif
     1026                }
     1027                return;
     1028            }
     1029            /** @todo should we flag this so we can try again later? */
     1030        }
     1031    }
     1032    else
     1033        Log(("vbsfNtUpdateFcbSize: Seems we raced someone updating the file size: old size = %#RX64, new size = %#RX64, current size = %#RX64\n",
     1034             cbFileOld, cbFileNew, cbFileOldRecheck));
     1035
     1036    if (NT_SUCCESS(rcNtLock))
     1037    {
     1038        RxReleasePagingIoResource(NULL, pFcb);
     1039    }
     1040}
     1041
     1042
     1043/**
    9281044 * Updates the object info to the VBox file object extension data.
    9291045 *
    930  * @param   pVBoxFobx               The VBox file object extension data.
     1046 * @param   pVBoxFobX               The VBox file object extension data.
    9311047 * @param   pObjInfo                The fresh data from the host.  Okay to modify.
    932  * @param   pVBoxFcbx               The VBox FCB extension data.
     1048 * @param   pVBoxFcbX               The VBox FCB extension data.
    9331049 * @param   fTimestampsToCopyAnyway VBOX_FOBX_F_INFO_XXX mask of timestamps to
    9341050 *                                  copy regardless of their suppressed state.
    … …  
    9361052 *                                  get current copies of newly modified and
    9371053 *                                  suppressed fields.
     1054 * @param   pFileObj                Pointer to the file object if we should
     1055 *                                  update the cache manager, otherwise NULL.
     1056 * @param   pFcb                    Pointer to the FCB if we should update its
     1057 *                                  copy of the file size, NULL if we should
     1058 *                                  leave it be.  Must be NULL when pFileObj is.
    9381059 */
    939 static void vbsfNtCopyInfo(PMRX_VBOX_FOBX pVBoxFobx, PSHFLFSOBJINFO pObjInfo,
    940                            PVBSFNTFCBEXT pVBoxFcbx, uint8_t fTimestampsToCopyAnyway)
     1060static void vbsfNtCopyInfo(PMRX_VBOX_FOBX pVBoxFobX, PSHFLFSOBJINFO pObjInfo, PVBSFNTFCBEXT pVBoxFcbX,
     1061                           uint8_t fTimestampsToCopyAnyway, PFILE_OBJECT pFileObj, PMRX_FCB pFcb)
    9411062{
    9421063    /*
    943      * Check if the size changed.
     1064     * Check if the size changed because RDBSS and the cache manager have
     1065     * cached copies of the file and allocation sizes.
    9441066     */
    945     if (pObjInfo->cbObject != pVBoxFobx->Info.cbObject)
    946     {
    947         /** @todo Tell RDBSS about this?  Seems we have to tell the cache manager
    948          *        ourselves, which sucks considering that RDBSS was supposed to
    949          *        shield us from crap like that (see the MS sales brochure). */
     1067    if (pFcb && pFileObj)
     1068    {
     1069        LONGLONG cbFileRdbss;
     1070        RxGetFileSizeWithLock((PFCB)pFcb, &cbFileRdbss);
     1071        if (pObjInfo->cbObject != cbFileRdbss)
     1072            vbsfNtUpdateFcbSize(pFileObj, pFcb, pVBoxFobX, pObjInfo->cbObject, cbFileRdbss, pObjInfo->cbAllocated);
    9501073    }
    9511074
    … …  
    9601083     * structure before preforming the copy.
    9611084     */
    962     Assert((pVBoxFobx->fTimestampsSetByUser & ~pVBoxFobx->fTimestampsUpdatingSuppressed) == 0);
    963     uint8_t fCopyTs = pVBoxFobx->fTimestampsUpdatingSuppressed & ~fTimestampsToCopyAnyway;
     1085    Assert((pVBoxFobX->fTimestampsSetByUser & ~pVBoxFobX->fTimestampsUpdatingSuppressed) == 0);
     1086    uint8_t fCopyTs = pVBoxFobX->fTimestampsUpdatingSuppressed & ~fTimestampsToCopyAnyway;
    9641087    if (fCopyTs)
    9651088    {
    9661089        if (  (fCopyTs & VBOX_FOBX_F_INFO_LASTACCESS_TIME)
    967             && pVBoxFcbx->pFobxLastAccessTime == pVBoxFobx)
    968             pObjInfo->AccessTime        = pVBoxFobx->Info.AccessTime;
     1090            && pVBoxFcbX->pFobxLastAccessTime == pVBoxFobX)
     1091            pObjInfo->AccessTime        = pVBoxFobX->Info.AccessTime;
    9691092
    9701093        if (   (fCopyTs & VBOX_FOBX_F_INFO_LASTWRITE_TIME)
    971             && pVBoxFcbx->pFobxLastWriteTime  == pVBoxFobx)
    972             pObjInfo->ModificationTime  = pVBoxFobx->Info.ModificationTime;
     1094            && pVBoxFcbX->pFobxLastWriteTime  == pVBoxFobX)
     1095            pObjInfo->ModificationTime  = pVBoxFobX->Info.ModificationTime;
    9731096
    9741097        if (   (fCopyTs & VBOX_FOBX_F_INFO_CHANGE_TIME)
    975             && pVBoxFcbx->pFobxChangeTime     == pVBoxFobx)
    976             pObjInfo->ChangeTime        = pVBoxFobx->Info.ChangeTime;
    977     }
    978     pVBoxFobx->Info = *pObjInfo;
     1098            && pVBoxFcbX->pFobxChangeTime     == pVBoxFobX)
     1099            pObjInfo->ChangeTime        = pVBoxFobX->Info.ChangeTime;
     1100    }
     1101    pVBoxFobX->Info = *pObjInfo;
    9791102
    9801103    /*
    9811104     * Try eliminate this one.
    9821105     */
    983     vbsfNtBasicInfoFromVBoxObjInfo(&pVBoxFobx->FileBasicInfo, pObjInfo);
     1106    vbsfNtBasicInfoFromVBoxObjInfo(&pVBoxFobX->FileBasicInfo, pObjInfo);
    9841107}
    9851108
     1109/**
     1110 * Queries the current file stats from the host and updates the RDBSS' copy of
     1111 * the file size if necessary.
     1112 *
     1113 * @returns IPRT status code
     1114 * @param   pNetRootX   Our net root extension data.
     1115 * @param   pFileObj    The file object.
     1116 * @param   pVBoxFobX   Our file object extension data.
     1117 * @param   pFcb        The FCB.
     1118 * @param   pVBoxFcbX   Our FCB extension data.
     1119 */
     1120int vbsfNtQueryAndUpdateFcbSize(PMRX_VBOX_NETROOT_EXTENSION pNetRootX, PFILE_OBJECT pFileObj,
     1121                                PMRX_VBOX_FOBX pVBoxFobX, PMRX_FCB pFcb, PVBSFNTFCBEXT pVBoxFcbX)
     1122{
     1123    VBOXSFOBJINFOREQ *pReq = (VBOXSFOBJINFOREQ *)VbglR0PhysHeapAlloc(sizeof(*pReq));
     1124    AssertReturn(pReq, VERR_NO_MEMORY);
     1125
     1126    int vrc = VbglR0SfHostReqQueryObjInfo(pNetRootX->map.root, pReq, pVBoxFobX->hFile);
     1127    if (RT_SUCCESS(vrc))
     1128        vbsfNtCopyInfo(pVBoxFobX, &pReq->ObjInfo, pVBoxFcbX, 0, pFileObj, pFcb);
     1129    else
     1130        AssertMsgFailed(("vrc=%Rrc\n", vrc));
     1131
     1132    VbglR0PhysHeapFree(pReq);
     1133    return vrc;
     1134}
    9861135
    9871136/**
    … …  
    9891138 *
    9901139 * The RDBSS code has done various things before we get here wrt locking and
    991  * request pre-processing.
     1140 * request pre-processing.  Unless this is a paging file (FCB_STATE_PAGING_FILE)
     1141 * or FileNameInformation is being queried, the FCB is locked.  For all except
     1142 * for FileCompressionInformation, a shared FCB access (FCB.Header.Resource) is
     1143 * acquired, where as for FileCompressionInformation it is taken exclusively.
    9921144 */
    9931145NTSTATUS VBoxMRxQueryFileInfo(IN PRX_CONTEXT RxContext)
    … …  
    11171269                int vrc = VbglR0SfHostReqQueryObjInfo(pNetRootExtension->map.root, pReq, pVBoxFobx->hFile);
    11181270                if (RT_SUCCESS(vrc))
    1119                     vbsfNtCopyInfo(pVBoxFobx, &pReq->ObjInfo, pVBoxFcbx, 0);
     1271                    vbsfNtCopyInfo(pVBoxFobx, &pReq->ObjInfo, pVBoxFcbx, 0,          /* ASSUMES that PageingIoResource is not */
     1272                                   RxContext->pFobx->AssociatedFileObject, capFcb);  /* held in shared mode here! */
    11201273                else
    11211274                {
    … …  
    13021455
    13031456/**
    1304  * Worker for vbsfNtSetBasicInfo.
     1457 * Worker for VBoxMRxSetFileInfo.
    13051458 */
    1306 static NTSTATUS vbsfNtSetBasicInfo(PMRX_VBOX_FOBX pVBoxFobx, PMRX_VBOX_NETROOT_EXTENSION pNetRootExtension,
    1307                                    PVBSFNTFCBEXT pVBoxFcbx, PFILE_BASIC_INFORMATION pBasicInfo)
     1459static NTSTATUS vbsfNtSetBasicInfo(PMRX_VBOX_NETROOT_EXTENSION pNetRootExtension, PFILE_OBJECT pFileObj, PMRX_VBOX_FOBX pVBoxFobx,
     1460                                   PMRX_FCB pFcb, PVBSFNTFCBEXT pVBoxFcbx, PFILE_BASIC_INFORMATION pBasicInfo)
    13081461{
    13091462    Log(("VBOXSF: MRxSetFileInfo: FileBasicInformation: CreationTime   %RX64\n", pBasicInfo->CreationTime.QuadPart));
    … …  
    14651618        }
    14661619
    1467         vbsfNtCopyInfo(pVBoxFobx, &pReq->ObjInfo, pVBoxFcbx, fSuppressed);
     1620        vbsfNtCopyInfo(pVBoxFobx, &pReq->ObjInfo, pVBoxFcbx, fSuppressed, pFileObj, pFcb);
    14681621
    14691622        /*
    … …  
    14971650
    14981651/**
    1499  * Worker for vbsfNtSetBasicInfo.
     1652 * Worker for VBoxMRxSetFileInfo.
    15001653 */
    15011654static NTSTATUS vbsfNtSetEndOfFile(IN OUT struct _RX_CONTEXT * RxContext, IN uint64_t cbNewFileSize)
    … …  
    15561709
    15571710/**
    1558  * Worker for vbsfNtSetBasicInfo.
     1711 * Worker for VBoxMRxSetFileInfo.
    15591712 */
    15601713static NTSTATUS vbsfNtRename(IN PRX_CONTEXT RxContext,
    … …  
    16361789 *
    16371790 * The RDBSS code has done various things before we get here wrt locking and
    1638  * request pre-processing.  It will normally acquire an exclusive lock, but not
    1639  * if this is related to a page file (FCB_STATE_PAGING_FILE set).
     1791 * request pre-processing.  It will normally acquire an exclusive FCB lock, but
     1792 * not if this is related to a page file (FCB_STATE_PAGING_FILE set).
    16401793 */
    16411794NTSTATUS VBoxMRxSetFileInfo(IN PRX_CONTEXT RxContext)
    … …  
    17021855        {
    17031856            Assert(RxContext->Info.Length >= sizeof(FILE_BASIC_INFORMATION));
    1704             Status = vbsfNtSetBasicInfo(pVBoxFobx, pNetRootExtension, VBoxMRxGetFcbExtension(capFcb),
    1705                                         (PFILE_BASIC_INFORMATION)RxContext->Info.Buffer);
     1857            Status = vbsfNtSetBasicInfo(pNetRootExtension, RxContext->pFobx->AssociatedFileObject, pVBoxFobx, capFcb,
     1858                                        VBoxMRxGetFcbExtension(capFcb), (PFILE_BASIC_INFORMATION)RxContext->Info.Buffer);
    17061859            break;
    17071860        }
    … …  
    18311984    return STATUS_SUCCESS;
    18321985}
     1986

  • trunk/src/VBox/Additions/WINNT/SharedFolders/driver/path.cpp

    r78355 r78365  
    571571            RxFinishFcbInitialization(capFcb, (RX_FILE_TYPE)RDBSS_NTC_STORAGE_TYPE_FILE, &InitPacket);
    572572    }
     573    /*
     574     * See if the size has changed and update the FCB if it has.
     575     */
     576    else
     577    {
     578        /** @todo Need to check RDBSS stack for locking semantics before updating
     579         *        anything. */
     580    }
    573581
    574582    SrvOpen->BufferingFlags = 0;

  • trunk/src/VBox/Additions/WINNT/SharedFolders/driver/vbsf.h

    r78357 r78365  
    145145    /** The RTTimeSystemNanoTS value when Info was retrieved, 0 to force update. */
    146146    uint64_t                    nsUpToDate;
    147     /** Cached object info. */
     147    /** Cached object info.
     148     * @todo Consider moving it to VBSFNTFCBEXT.  Better fit than on "handle". */
    148149    SHFLFSOBJINFO               Info;
    149150    /** NT version of Info.
    … …  
    263264#endif
    264265
     266void     vbsfNtUpdateFcbSize(PFILE_OBJECT pFileObj, PMRX_FCB pFcb, PMRX_VBOX_FOBX pVBoxFobX,
     267                             LONGLONG cbFileNew, LONGLONG cbFileOld, LONGLONG cbAllocated);
     268int      vbsfNtQueryAndUpdateFcbSize(PMRX_VBOX_NETROOT_EXTENSION pNetRootX, PFILE_OBJECT pFileObj,
     269                                     PMRX_VBOX_FOBX pVBoxFobX, PMRX_FCB pFcb, PVBSFNTFCBEXT pVBoxFcbX);
     270
    265271/**
    266272 * Converts VBox (IPRT) file mode to NT file attributes.
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