VirtualBox

Changeset 2859 in kBuild


Ignore:
Timestamp:
Sep 1, 2016 4:34:31 PM (9 years ago)
Author:
bird
Message:

updates

Location:
trunk/src
Files:
5 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/kWorker/kWorker.c

    r2858 r2859  
    43784378    pPeb->ProcessParameters->CommandLine.Length = (USHORT)cwc * sizeof(wchar_t);
    43794379
    4380 
    4381 /** @todo cache generation increment.   */
     4380    /*
     4381     * Invalidate the missing cache entries.
     4382     */
     4383    kFsCacheInvalidateMissing(g_pFsCache);
    43824384    return 0;
    43834385}

  • trunk/src/lib/nt/kFsCache.c

    r2858 r2859  
    566566 * @param   cchPath             The length of the path.
    567567 * @param   uHashPath           The hash of the path.
     568 * @param   fAbsolute           Whether it can be refreshed using an absolute
     569 *                              lookup or requires the slow treatment.
    568570 * @param   idxHashTab          The hash table index of the path.
    569571 * @param   enmError            The lookup error.
    570572 */
    571573static PKFSHASHA kFsCacheCreatePathHashTabEntryA(PKFSCACHE pCache, PKFSOBJ pFsObj, const char *pszPath, KU32 cchPath,
    572                                                  KU32 uHashPath, KU32 idxHashTab, KFSLOOKUPERROR enmError)
     574                                                 KU32 uHashPath, KU32 idxHashTab, BOOL fAbsolute, KFSLOOKUPERROR enmError)
    573575{
    574576    PKFSHASHA pHashEntry = (PKFSHASHA)kHlpAlloc(sizeof(*pHashEntry) + cchPath + 1);
    … …  
    576578    {
    577579        pHashEntry->uHashPath   = uHashPath;
    578         pHashEntry->cchPath     = cchPath;
    579         pHashEntry->pszPath     = (const char *)kHlpMemCopy(pHashEntry + 1, pszPath, cchPath + 1);
     580        pHashEntry->cchPath     = (KU16)cchPath;
     581        pHashEntry->fAbsolute   = fAbsolute;
    580582        pHashEntry->pFsObj      = pFsObj;
    581583        pHashEntry->enmError    = enmError;
     584        pHashEntry->pszPath     = (const char *)kHlpMemCopy(pHashEntry + 1, pszPath, cchPath + 1);
    582585        if (pFsObj)
    583586            pHashEntry->uCacheGen = pCache->uGeneration;
    … …  
    608611 * @param   cwcPath             The length of the path (in wchar_t's).
    609612 * @param   uHashPath           The hash of the path.
     613 * @param   fAbsolute           Whether it can be refreshed using an absolute
     614 *                              lookup or requires the slow treatment.
    610615 * @param   idxHashTab          The hash table index of the path.
    611616 * @param   enmError            The lookup error.
    612617 */
    613618static PKFSHASHW kFsCacheCreatePathHashTabEntryW(PKFSCACHE pCache, PKFSOBJ pFsObj, const wchar_t *pwszPath, KU32 cwcPath,
    614                                                  KU32 uHashPath, KU32 idxHashTab, KFSLOOKUPERROR enmError)
     619                                                 KU32 uHashPath, KU32 idxHashTab, BOOL fAbsolute, KFSLOOKUPERROR enmError)
    615620{
    616621    PKFSHASHW pHashEntry = (PKFSHASHW)kHlpAlloc(sizeof(*pHashEntry) + (cwcPath + 1) * sizeof(wchar_t));
    … …  
    619624        pHashEntry->uHashPath   = uHashPath;
    620625        pHashEntry->cwcPath     = cwcPath;
    621         pHashEntry->pwszPath    = (const wchar_t *)kHlpMemCopy(pHashEntry + 1, pwszPath, (cwcPath + 1) * sizeof(wchar_t));
     626        pHashEntry->fAbsolute   = fAbsolute;
    622627        pHashEntry->pFsObj      = pFsObj;
    623628        pHashEntry->enmError    = enmError;
     629        pHashEntry->pwszPath    = (const wchar_t *)kHlpMemCopy(pHashEntry + 1, pwszPath, (cwcPath + 1) * sizeof(wchar_t));
    624630        if (pFsObj)
    625631            pHashEntry->uCacheGen = pCache->uGeneration;
    … …  
    784790            pDirObj->hDir           = INVALID_HANDLE_VALUE;
    785791            pDirObj->uDevNo         = pParent->uDevNo;
     792            pDirObj->iLastWrite     = 0;
    786793            pDirObj->fPopulated     = K_FALSE;
    787794        }
    … …  
    10701077            }
    10711078
     1079            /* We need to skip the '.' and '..' entries. */
     1080            if (   *pwszFilename != '.'
     1081                ||  uPtr.pNoId->FileNameLength > 4
     1082                ||  !(   uPtr.pNoId->FileNameLength == 2
     1083                      ||  (   uPtr.pNoId->FileNameLength == 4
     1084                           && pwszFilename[1] == '.') )
     1085               )
     1086            {
     1087                /*
     1088                 * Create the entry (not linked yet).
     1089                 */
     1090                pCur = kFsCacheCreateObjectW(pCache, pDir, pwszFilename, uPtr.pNoId->FileNameLength / sizeof(wchar_t),
     1091#ifdef KFSCACHE_CFG_SHORT_NAMES
     1092                                             uPtr.pNoId->ShortName, uPtr.pNoId->ShortNameLength / sizeof(wchar_t),
     1093#endif
     1094                                             uPtr.pNoId->FileAttributes & FILE_ATTRIBUTE_DIRECTORY ? KFSOBJ_TYPE_DIR
     1095                                             : uPtr.pNoId->FileAttributes & (FILE_ATTRIBUTE_DEVICE | FILE_ATTRIBUTE_REPARSE_POINT)
     1096                                             ? KFSOBJ_TYPE_OTHER : KFSOBJ_TYPE_FILE,
     1097                                             penmError);
     1098                if (!pCur)
     1099                    return K_FALSE;
     1100                kHlpAssert(pCur->cRefs == 1);
     1101
     1102#ifdef KFSCACHE_CFG_SHORT_NAMES
     1103                if (enmInfoClass == enmInfoClassWithId)
     1104                    birdStatFillFromFileIdBothDirInfo(&pCur->Stats, uPtr.pWithId, pCur->pszName);
     1105                else
     1106                    birdStatFillFromFileBothDirInfo(&pCur->Stats, uPtr.pNoId, pCur->pszName);
     1107#else
     1108                if (enmInfoClass == enmInfoClassWithId)
     1109                    birdStatFillFromFileIdFullDirInfo(&pCur->Stats, uPtr.pWithId, pCur->pszName);
     1110                else
     1111                    birdStatFillFromFileFullDirInfo(&pCur->Stats, uPtr.pNoId, pCur->pszName);
     1112#endif
     1113                pCur->Stats.st_dev = pDir->uDevNo;
     1114                pCur->fHaveStats   = K_TRUE;
     1115
     1116                /*
     1117                 * If we're updating we have to check the data.
     1118                 */
     1119                if (fRefreshing)
     1120                {
     1121                    __debugbreak();
     1122                }
     1123
     1124                /*
     1125                 * If we've still got pCur, add it to the directory.
     1126                 */
     1127                if (pCur)
     1128                {
     1129                    KBOOL fRc = kFsCacheDirAddChild(pCache, pDir, pCur, penmError);
     1130                    kFsCacheObjRelease(pCache, pCur);
     1131                    if (fRc)
     1132                    { /* likely */ }
     1133                    else
     1134                        return K_FALSE;
     1135                }
     1136            }
    10721137            /*
    1073              * Create the entry (not linked yet).
     1138             * When seeing '.' we update the directory info.
    10741139             */
    1075             pCur = kFsCacheCreateObjectW(pCache, pDir, pwszFilename, uPtr.pNoId->FileNameLength / sizeof(wchar_t),
     1140            else if (uPtr.pNoId->FileNameLength == 2)
     1141            {
     1142                pDir->iLastWrite = uPtr.pNoId->LastWriteTime.QuadPart;
    10761143#ifdef KFSCACHE_CFG_SHORT_NAMES
    1077                                          uPtr.pNoId->ShortName, uPtr.pNoId->ShortNameLength / sizeof(wchar_t),
     1144                if (enmInfoClass == enmInfoClassWithId)
     1145                    birdStatFillFromFileIdBothDirInfo(&pDir->Obj.Stats, uPtr.pWithId, pDir->Obj.pszName);
     1146                else
     1147                    birdStatFillFromFileBothDirInfo(&pDir->Obj.Stats, uPtr.pNoId, pDir->Obj.pszName);
     1148#else
     1149                if (enmInfoClass == enmInfoClassWithId)
     1150                    birdStatFillFromFileIdFullDirInfo(&pDir->Obj.Stats, uPtr.pWithId, pDir->Obj.pszName);
     1151                else
     1152                    birdStatFillFromFileFullDirInfo(&pDir->Obj.Stats, uPtr.pNoId, pDir->Obj.pszName);
    10781153#endif
    1079                                          uPtr.pNoId->FileAttributes & FILE_ATTRIBUTE_DIRECTORY ? KFSOBJ_TYPE_DIR
    1080                                          : uPtr.pNoId->FileAttributes & (FILE_ATTRIBUTE_DEVICE | FILE_ATTRIBUTE_REPARSE_POINT)
    1081                                          ? KFSOBJ_TYPE_OTHER : KFSOBJ_TYPE_FILE,
    1082                                          penmError);
    1083             if (!pCur)
    1084                 return K_FALSE;
    1085             kHlpAssert(pCur->cRefs == 1);
    1086 
    1087 #ifdef KFSCACHE_CFG_SHORT_NAMES
    1088             if (enmInfoClass == enmInfoClassWithId)
    1089                 birdStatFillFromFileIdBothDirInfo(&pCur->Stats, uPtr.pWithId, pCur->pszName);
    1090             else
    1091                 birdStatFillFromFileBothDirInfo(&pCur->Stats, uPtr.pNoId, pCur->pszName);
    1092 #else
    1093             if (enmInfoClass == enmInfoClassWithId)
    1094                 birdStatFillFromFileIdFullDirInfo(&pCur->Stats, uPtr.pWithId, pCur->pszName);
    1095             else
    1096                 birdStatFillFromFileFullDirInfo(&pCur->Stats, uPtr.pNoId, pCur->pszName);
    1097 #endif
    1098             pCur->Stats.st_dev = pDir->uDevNo;
    1099             pCur->fHaveStats   = K_TRUE;
    1100 
    1101             /*
    1102              * If we're updating we have to check the data.
    1103              */
    1104             if (fRefreshing)
    1105             {
    1106                 __debugbreak();
    1107             }
    1108 
    1109             /*
    1110              * If we've still got pCur, add it to the directory.
    1111              */
    1112             if (pCur)
    1113             {
    1114                 KBOOL fRc = kFsCacheDirAddChild(pCache, pDir, pCur, penmError);
    1115                 kFsCacheObjRelease(pCache, pCur);
    1116                 if (fRc)
    1117                 { /* likely */ }
    1118                 else
    1119                     return K_FALSE;
    11201154            }
    11211155
    … …  
    11861220
    11871221
     1222/**
     1223 * Checks whether the modified timestamp differs on this directory.
     1224 *
     1225 * @returns K_TRUE if possibly modified, K_FALSE if definitely not modified.
     1226 * @param   pDir                The directory..
     1227 */
     1228static KBOOL kFsCacheDirIsModified(PKFSDIR pDir)
     1229{
     1230    if (   pDir->hDir != INVALID_HANDLE_VALUE
     1231        && (pDir->Obj.fFlags & KFSOBJ_F_WORKING_DIR_MTIME) )
     1232    {
     1233        MY_IO_STATUS_BLOCK          Ios;
     1234        MY_FILE_BASIC_INFORMATION   BasicInfo;
     1235        MY_NTSTATUS                 rcNt;
     1236
     1237        Ios.Information = -1;
     1238        Ios.u.Status    = -1;
     1239
     1240        rcNt = g_pfnNtQueryInformationFile(pDir->hDir, &Ios, &BasicInfo, sizeof(BasicInfo), MyFileBasicInformation);
     1241        if (MY_NT_SUCCESS(rcNt))
     1242            return BasicInfo.LastWriteTime.QuadPart != pDir->iLastWrite;
     1243    }
     1244
     1245    return K_TRUE;
     1246}
     1247
     1248
    11881249static KBOOL kFsCacheRefreshMissing(PKFSCACHE pCache, PKFSOBJ pMissing, KFSLOOKUPERROR *penmError)
    11891250{
     1251    /*
     1252     * If we can, we start by checking whether the parent directory
     1253     * has been modified.   If it has, we need to check if this entry
     1254     * was added or not, most likely it wasn't added.
     1255     */
     1256    if (!kFsCacheDirIsModified(pMissing->pParent))
     1257        pMissing->uCacheGen = pCache->uGenerationMissing;
     1258    else
     1259    {
     1260        MY_UNICODE_STRING           UniStr;
     1261        MY_OBJECT_ATTRIBUTES        ObjAttr;
     1262        MY_FILE_BASIC_INFORMATION   BasicInfo;
     1263        MY_NTSTATUS                 rcNt;
     1264
     1265        UniStr.Buffer        = (wchar_t *)pMissing->pwszName;
     1266        UniStr.Length        = (USHORT)(pMissing->cwcName * sizeof(wchar_t));
     1267        UniStr.MaximumLength = UniStr.Length + sizeof(wchar_t);
     1268
     1269        kHlpAssert(pMissing->pParent->hDir != INVALID_HANDLE_VALUE);
     1270        MyInitializeObjectAttributes(&ObjAttr, &UniStr, OBJ_CASE_INSENSITIVE, pMissing->pParent->hDir, NULL /*pSecAttr*/);
     1271
     1272        rcNt = g_pfnNtQueryAttributesFile(&ObjAttr, &BasicInfo);
     1273        if (!MY_NT_SUCCESS(rcNt))
     1274        {
     1275            /*
     1276             * Probably more likely that a missing node stays missing.
     1277             */
     1278            pMissing->uCacheGen = pCache->uGenerationMissing;
     1279        }
     1280        else
     1281        {
     1282            /*
     1283             * We must metamorphose this node.  This is tedious business
     1284             * because we need to check the file name casing.  We might
     1285             * just as well update the parent directory...
     1286             */
     1287            /** @todo   */
     1288            __debugbreak();
     1289        }
     1290    }
     1291
    11901292    return K_TRUE;
    11911293}
    … …  
    11941296static KBOOL kFsCacheRefreshMissingIntermediateDir(PKFSCACHE pCache, PKFSOBJ pMissing, KFSLOOKUPERROR *penmError)
    11951297{
    1196     return K_TRUE;
     1298    if (kFsCacheRefreshMissing(pCache, pMissing, penmError))
     1299    {
     1300        if (   pMissing->bObjType == KFSOBJ_TYPE_DIR
     1301            || pMissing->bObjType == KFSOBJ_TYPE_MISSING)
     1302            return K_TRUE;
     1303        *penmError = KFSLOOKUPERROR_PATH_COMP_NOT_DIR;
     1304    }
     1305
     1306    return K_FALSE;
    11971307}
    11981308
    … …  
    12001310static KBOOL kFsCacheRefreshObj(PKFSCACHE pCache, PKFSOBJ pObj, KFSLOOKUPERROR *penmError)
    12011311{
     1312    if (pObj->bObjType == KFSOBJ_TYPE_MISSING)
     1313        return kFsCacheRefreshMissing(pCache, pObj, penmError);
     1314
     1315    __debugbreak();
    12021316    return K_FALSE;
    12031317}
    … …  
    12251339    MY_UNICODE_STRING   NtPath;
    12261340    wchar_t             wszTmp[8];
    1227     MY_NTSTATUS         rcNt;
    12281341    char                szTmp[4];
    12291342
    … …  
    12731386    if (g_pfnRtlDosPathNameToNtPathName_U(wszTmp, &NtPath, NULL, NULL))
    12741387    {
    1275         HANDLE hDir;
     1388        HANDLE      hDir;
     1389        MY_NTSTATUS rcNt;
    12761390        rcNt = birdOpenFileUniStr(&NtPath,
    12771391                                  FILE_READ_DATA  | FILE_LIST_DIRECTORY | FILE_READ_ATTRIBUTES | SYNCHRONIZE,
    … …  
    21832297static PKFSHASHA kFsCacheRefreshPathA(PKFSCACHE pCache, PKFSHASHA pHashEntry, KU32 idxHashTab)
    21842298{
    2185     /** @todo implement once we've start inserting uCacheGen nodes. */
    2186     __debugbreak();
    2187     K_NOREF(pCache);
    2188     K_NOREF(idxHashTab);
     2299    if (!pHashEntry->pFsObj)
     2300    {
     2301        if (pHashEntry->fAbsolute)
     2302            pHashEntry->pFsObj = kFsCacheLookupAbsoluteA(pCache, pHashEntry->pszPath, pHashEntry->cchPath, &pHashEntry->enmError);
     2303        else
     2304            pHashEntry->pFsObj = kFsCacheLookupSlowA(pCache, pHashEntry->pszPath, pHashEntry->cchPath, &pHashEntry->enmError);
     2305    }
     2306    else
     2307    {
     2308        KFSLOOKUPERROR enmError;
     2309        if (kFsCacheRefreshObj(pCache, pHashEntry->pFsObj, &enmError))
     2310        {
     2311        }
     2312        __debugbreak();  /** @todo implement once we've start inserting uCacheGen nodes. */
     2313        K_NOREF(pCache);
     2314        K_NOREF(idxHashTab);
     2315    }
     2316    pHashEntry->uCacheGen = pCache->uGenerationMissing;
    21892317    return pHashEntry;
    21902318}
    … …  
    22012329static PKFSHASHW kFsCacheRefreshPathW(PKFSCACHE pCache, PKFSHASHW pHashEntry, KU32 idxHashTab)
    22022330{
    2203     /** @todo implement once we've start inserting uCacheGen nodes. */
    2204     __debugbreak();
    2205     K_NOREF(pCache);
    2206     K_NOREF(idxHashTab);
     2331    if (!pHashEntry->pFsObj)
     2332    {
     2333        if (pHashEntry->fAbsolute)
     2334            pHashEntry->pFsObj = kFsCacheLookupAbsoluteW(pCache, pHashEntry->pwszPath, pHashEntry->cwcPath, &pHashEntry->enmError);
     2335        else
     2336            pHashEntry->pFsObj = kFsCacheLookupSlowW(pCache, pHashEntry->pwszPath, pHashEntry->cwcPath, &pHashEntry->enmError);
     2337    }
     2338    else
     2339    {
     2340        KFSLOOKUPERROR enmError;
     2341        if (kFsCacheRefreshObj(pCache, pHashEntry->pFsObj, &enmError))
     2342        {
     2343        }
     2344        __debugbreak();  /** @todo implement once we've start inserting uCacheGen nodes. */
     2345        K_NOREF(pCache);
     2346        K_NOREF(idxHashTab);
     2347    }
    22072348    return pHashEntry;
    22082349}
    … …  
    22702411    {
    22712412        PKFSOBJ pFsObj;
     2413        KBOOL   fAbsolute;
    22722414
    22732415        /* Is absolute without any '..' bits? */
    … …  
    22792421                    && IS_SLASH(pszPath[1]) ) )
    22802422            && !kFsCacheHasDotDotA(pszPath, cchPath) )
     2423        {
    22812424            pFsObj = kFsCacheLookupAbsoluteA(pCache, pszPath, cchPath, penmError);
     2425            fAbsolute = K_TRUE;
     2426        }
    22822427        else
     2428        {
    22832429            pFsObj = kFsCacheLookupSlowA(pCache, pszPath, cchPath, penmError);
     2430            fAbsolute = K_FALSE;
     2431        }
    22842432        if (   pFsObj
    22852433            || (   (pCache->fFlags & KFSCACHE_F_MISSING_PATHS)
    22862434                && *penmError != KFSLOOKUPERROR_PATH_TOO_LONG)
    22872435            || *penmError == KFSLOOKUPERROR_UNSUPPORTED )
    2288             kFsCacheCreatePathHashTabEntryA(pCache, pFsObj, pszPath, cchPath, uHashPath, idxHashTab, *penmError);
     2436            kFsCacheCreatePathHashTabEntryA(pCache, pFsObj, pszPath, cchPath, uHashPath, idxHashTab, fAbsolute, *penmError);
    22892437
    22902438        pCache->cLookups++;
    … …  
    23602508    {
    23612509        PKFSOBJ pFsObj;
     2510        KBOOL   fAbsolute;
    23622511
    23632512        /* Is absolute without any '..' bits? */
    … …  
    23692518                    && IS_SLASH(pwszPath[1]) ) )
    23702519            && !kFsCacheHasDotDotW(pwszPath, cwcPath) )
     2520        {
    23712521            pFsObj = kFsCacheLookupAbsoluteW(pCache, pwszPath, cwcPath, penmError);
     2522            fAbsolute = K_TRUE;
     2523        }
    23722524        else
     2525        {
    23732526            pFsObj = kFsCacheLookupSlowW(pCache, pwszPath, cwcPath, penmError);
     2527            fAbsolute = K_FALSE;
     2528        }
    23742529        if (   pFsObj
    23752530            || (   (pCache->fFlags & KFSCACHE_F_MISSING_PATHS)
    23762531                && *penmError != KFSLOOKUPERROR_PATH_TOO_LONG)
    23772532            || *penmError == KFSLOOKUPERROR_UNSUPPORTED )
    2378             kFsCacheCreatePathHashTabEntryW(pCache, pFsObj, pwszPath, cwcPath, uHashPath, idxHashTab, *penmError);
     2533            kFsCacheCreatePathHashTabEntryW(pCache, pFsObj, pwszPath, cwcPath, uHashPath, idxHashTab, fAbsolute, *penmError);
    23792534
    23802535        pCache->cLookups++;
    … …  
    28503005
    28513006#endif /* KFSCACHE_CFG_SHORT_NAMES */
     3007
     3008
     3009/**
     3010 * Invalidate all cache entries of missing files.
     3011 *
     3012 * @param   pCache      The cache.
     3013 */
     3014void kFsCacheInvalidateMissing(PKFSCACHE pCache)
     3015{
     3016    kHlpAssert(pCache->u32Magic == KFSOBJ_MAGIC);
     3017    pCache->uGenerationMissing++;
     3018    kHlpAssert(pCache->uGenerationMissing < KU32_MAX);
     3019}
     3020
     3021
     3022/**
     3023 * Invalidate all cache entries of missing files.
     3024 *
     3025 * @param   pCache      The cache.
     3026 */
     3027void kFsCacheInvalidateAll(PKFSCACHE pCache)
     3028{
     3029    kHlpAssert(pCache->u32Magic == KFSOBJ_MAGIC);
     3030    pCache->uGenerationMissing++;
     3031    kHlpAssert(pCache->uGenerationMissing < KU32_MAX);
     3032    pCache->uGeneration++;
     3033    kHlpAssert(pCache->uGeneration < KU32_MAX);
     3034}
    28523035
    28533036
    … …  
    28983081            pCache->u32Magic        = KFSCACHE_MAGIC;
    28993082            pCache->fFlags          = fFlags;
    2900             pCache->uGeneration     = 1;
    2901             pCache->uGenerationMissing = KU32_MAX / 2;
     3083            pCache->uGeneration     = KU32_MAX / 2;
     3084            pCache->uGenerationMissing = 1;
    29023085            pCache->cObjects        = 1;
    29033086            pCache->cbObjects       = sizeof(pCache->RootDir) + pCache->RootDir.cHashTab * sizeof(pCache->RootDir.paHashTab[0]);

  • trunk/src/lib/nt/kFsCache.h

    r2858 r2859  
    239239    KU64                uDevNo;
    240240
     241    /** The last write time sampled the last time the directory was refreshed.
     242     * @remarks May differ from st_mtim because it will be updated when the
     243     *          parent directory is refreshed. */
     244    KI64                iLastWrite;
     245
    241246    /** Set if populated. */
    242247    KBOOL               fPopulated;
    … …  
    292297    KU32                uHashPath;
    293298    /** The path length. */
    294     KU32                cchPath;
     299    KU16                cchPath;
     300    /** Set if aboslute path.   */
     301    KBOOL               fAbsolute;
    295302    /** The cache generation ID. */
    296303    KU32                uCacheGen;
    … …  
    319326    KU32                uHashPath;
    320327    /** The path length (in wchar_t units). */
    321     KU32                cwcPath;
     328    KU16                cwcPath;
     329    /** Set if aboslute path.   */
     330    KBOOL               fAbsolute;
    322331    /** The cache generation ID. */
    323332    KU32                uCacheGen;
    … …  
    442451PKFSCACHE   kFsCacheCreate(KU32 fFlags);
    443452void        kFsCacheDestroy(PKFSCACHE);
    444 
    445 #endif
     453void        kFsCacheInvalidateMissing(PKFSCACHE pFsCache);
     454void        kFsCacheInvalidateAll(PKFSCACHE pFsCache);
     455
     456#endif

  • trunk/src/lib/nt/nthlpcore.c

    r2852 r2859  
    5151                                                PVOID, ULONG, MY_FILE_INFORMATION_CLASS, BOOLEAN,
    5252                                                MY_UNICODE_STRING *, BOOLEAN);
     53MY_NTSTATUS (WINAPI *g_pfnNtQueryAttributesFile)(MY_OBJECT_ATTRIBUTES *, MY_FILE_BASIC_INFORMATION *);
    5354MY_NTSTATUS (WINAPI *g_pfnNtSetInformationFile)(HANDLE, MY_IO_STATUS_BLOCK *, PVOID, LONG, MY_FILE_INFORMATION_CLASS);
    5455BOOLEAN     (WINAPI *g_pfnRtlDosPathNameToNtPathName_U)(PCWSTR, MY_UNICODE_STRING *, PCWSTR *, MY_RTL_RELATIVE_NAME_U *);
    … …  
    7172    { (FARPROC *)&g_pfnNtQueryVolumeInformationFile,    "NtQueryVolumeInformationFile" },
    7273    { (FARPROC *)&g_pfnNtQueryDirectoryFile,            "NtQueryDirectoryFile" },
     74    { (FARPROC *)&g_pfnNtQueryAttributesFile,           "NtQueryAttributesFile" },
    7375    { (FARPROC *)&g_pfnNtSetInformationFile,            "NtSetInformationFile" },
    7476    { (FARPROC *)&g_pfnRtlDosPathNameToNtPathName_U,    "RtlDosPathNameToNtPathName_U" },

  • trunk/src/lib/nt/ntstuff.h

    r2858 r2859  
    431431                                                        PVOID, ULONG, MY_FILE_INFORMATION_CLASS, BOOLEAN,
    432432                                                        MY_UNICODE_STRING *, BOOLEAN);
     433extern MY_NTSTATUS (WINAPI * g_pfnNtQueryAttributesFile)(MY_OBJECT_ATTRIBUTES *, MY_FILE_BASIC_INFORMATION *);
    433434extern MY_NTSTATUS (WINAPI * g_pfnNtSetInformationFile)(HANDLE, MY_IO_STATUS_BLOCK *, PVOID, LONG, MY_FILE_INFORMATION_CLASS);
    434435extern BOOLEAN     (WINAPI * g_pfnRtlDosPathNameToNtPathName_U)(PCWSTR, MY_UNICODE_STRING *, PCWSTR *, MY_RTL_RELATIVE_NAME_U *);
Note: See TracChangeset for help on using the changeset viewer.

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