VirtualBox

source: kBuild/trunk/src/kmk/dir-nt-bird.c@ 2913

Last change on this file since 2913 was 2912, checked in by bird, 9 years ago

rewrote kmk_redirect to skip the separate process. Added chache invalidation after directory deletion for addressing kmk rebuild and fetching.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Id
File size: 19.2 KB
Line 
1/* $Id: dir-nt-bird.c 2912 2016-09-14 13:36:15Z bird $ */
2/** @file
3 * Reimplementation of dir.c for NT using kFsCache.
4 *
5 * This should perform better on NT, especially on machines "infected"
6 * by antivirus programs.
7 */
8
9/*
10 * Copyright (c) 2016 knut st. osmundsen <bird-kBuild-spamx@anduin.net>
11 *
12 * This file is part of kBuild.
13 *
14 * kBuild is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 3 of the License, or
17 * (at your option) any later version.
18 *
19 * kBuild is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with kBuild. If not, see <http://www.gnu.org/licenses/>
26 *
27 */
28
29
30/*********************************************************************************************************************************
31* Header Files *
32*********************************************************************************************************************************/
33#include "nt/kFsCache.h"
34#include "make.h"
35#if defined(KMK) && !defined(__OS2__)
36# include "glob/glob.h"
37#else
38# include <glob.h>
39#endif
40
41
42#include "nt_fullpath.h" /* for the time being - will be implemented here later on. */
43
44
45/*********************************************************************************************************************************
46* Defined Constants And Macros *
47*********************************************************************************************************************************/
48/** User data key indicating that it's an impossible file to make.
49 * See file_impossible() and file_impossible_p(). */
50#define KMK_DIR_NT_IMPOSSIBLE_KEY (~(KUPTR)7)
51
52
53/*********************************************************************************************************************************
54* Structures and Typedefs *
55*********************************************************************************************************************************/
56/**
57 * glob directory stream.
58 */
59typedef struct KMKNTOPENDIR
60{
61 /** Reference to the directory. */
62 PKFSDIR pDir;
63 /** Index of the next directory entry (child) to return. */
64 KU32 idxNext;
65 /** The structure in which to return the directory entry. */
66 struct dirent DirEnt;
67} KMKNTOPENDIR;
68
69
70/*********************************************************************************************************************************
71* Global Variables *
72*********************************************************************************************************************************/
73/** The cache.*/
74PKFSCACHE g_pFsCache = NULL;
75/** Number of times dir_cache_invalid_missing was called. */
76static KU32 g_cInvalidates = 0;
77/** Set by dir_cache_volatile_dir to indicate that the user has marked the
78 * volatile parts of the file system with custom revisioning and we only need to
79 * flush these. This is very handy when using a separate output directory
80 * from the sources. */
81static KBOOL g_fFsCacheIsUsingCustomRevision = K_FALSE;
82
83
84void hash_init_directories(void)
85{
86 g_pFsCache = kFsCacheCreate(0);
87 if (g_pFsCache)
88 return;
89 fputs("kFsCacheCreate failed!", stderr);
90 exit(9);
91}
92
93
94/**
95 * Checks if @a pszName exists in directory @a pszDir.
96 *
97 * @returns 1 if it does, 0 if it doesn't.
98 *
99 * @param pszDir The directory.
100 * @param pszName The name.
101 *
102 * If empty string, just check if the directory exists.
103 *
104 * If NULL, just read the whole cache the directory into
105 * the cache (we always do that).
106 */
107int dir_file_exists_p(const char *pszDir, const char *pszName)
108{
109 int fRc = 0;
110 KFSLOOKUPERROR enmError;
111 PKFSOBJ pDirObj = kFsCacheLookupA(g_pFsCache, pszDir, &enmError);
112 if (pDirObj)
113 {
114 if (pDirObj->bObjType == KFSOBJ_TYPE_DIR)
115 {
116 if (pszName != 0)
117 {
118 /* Empty filename is just checking out the directory. */
119 if (*pszName == '\0')
120 fRc = 1;
121 else
122 {
123 PKFSOBJ pNameObj = kFsCacheLookupRelativeToDirA(g_pFsCache, (PKFSDIR)pDirObj, pszName, strlen(pszName),
124 0/*fFlags*/, &enmError, NULL);
125 if (pNameObj)
126 {
127 fRc = pNameObj->bObjType == KFSOBJ_TYPE_MISSING;
128 kFsCacheObjRelease(g_pFsCache, pNameObj);
129 }
130 }
131 }
132 }
133 kFsCacheObjRelease(g_pFsCache, pDirObj);
134 }
135 return fRc;
136}
137
138
139/**
140 * Checks if a file exists.
141 *
142 * @returns 1 if it does exist, 0 if it doesn't.
143 * @param pszPath The path to check out.
144 */
145int file_exists_p(const char *pszPath)
146{
147 int fRc;
148 KFSLOOKUPERROR enmError;
149 PKFSOBJ pPathObj = kFsCacheLookupA(g_pFsCache, pszPath, &enmError);
150 if (pPathObj)
151 {
152 fRc = pPathObj->bObjType != KFSOBJ_TYPE_MISSING;
153 kFsCacheObjRelease(g_pFsCache, pPathObj);
154 }
155 else
156 fRc = 0;
157 return fRc;
158}
159
160
161/**
162 * Just a way for vpath.c to get a correctly cased path, I think.
163 *
164 * @returns Directory path in string cache.
165 * @param pszDir The directory.
166 */
167const char *dir_name(const char *pszDir)
168{
169 char szTmp[MAX_PATH];
170 nt_fullpath(pszDir, szTmp, sizeof(szTmp));
171 return strcache_add(szTmp);
172}
173
174
175/**
176 * Makes future file_impossible_p calls return 1 for pszPath.
177 */
178void file_impossible(const char *pszPath)
179{
180 KFSLOOKUPERROR enmError;
181 PKFSOBJ pPathObj = kFsCacheLookupA(g_pFsCache, pszPath, &enmError);
182 if (pPathObj)
183 {
184 kFsCacheObjAddUserData(g_pFsCache, pPathObj, KMK_DIR_NT_IMPOSSIBLE_KEY, sizeof(KFSUSERDATA));
185 kFsCacheObjRelease(g_pFsCache, pPathObj);
186 }
187}
188
189/**
190 * Makes future file_impossible_p calls return 1 for pszPath.
191 */
192int file_impossible_p(const char *pszPath)
193{
194 int fRc;
195 KFSLOOKUPERROR enmError;
196 PKFSOBJ pPathObj = kFsCacheLookupA(g_pFsCache, pszPath, &enmError);
197 if (pPathObj)
198 {
199 fRc = kFsCacheObjGetUserData(g_pFsCache, pPathObj, KMK_DIR_NT_IMPOSSIBLE_KEY) != NULL;
200 kFsCacheObjRelease(g_pFsCache, pPathObj);
201 }
202 else
203 fRc = 0;
204 return fRc;
205}
206
207
208/**
209 * opendir for glob.
210 *
211 * @returns Pointer to DIR like handle, NULL if directory not found.
212 * @param pszDir The directory to enumerate.
213 */
214static __ptr_t dir_glob_opendir(const char *pszDir)
215{
216 KFSLOOKUPERROR enmError;
217 PKFSOBJ pDirObj = kFsCacheLookupA(g_pFsCache, pszDir, &enmError);
218 if (pDirObj)
219 {
220 if (pDirObj->bObjType == KFSOBJ_TYPE_DIR)
221 {
222 if (kFsCacheDirEnsurePopuplated(g_pFsCache, (PKFSDIR)pDirObj, NULL))
223 {
224 KMKNTOPENDIR *pDir = xmalloc(sizeof(*pDir));
225 pDir->pDir = (PKFSDIR)pDirObj;
226 pDir->idxNext = 0;
227 return pDir;
228 }
229 }
230 kFsCacheObjRelease(g_pFsCache, pDirObj);
231 }
232 return NULL;
233}
234
235
236/**
237 * readdir for glob.
238 *
239 * @returns Pointer to DIR like handle, NULL if directory not found.
240 * @param pDir Directory enum handle by dir_glob_opendir.
241 */
242static struct dirent *dir_glob_readdir(__ptr_t pvDir)
243{
244 KMKNTOPENDIR *pDir = (KMKNTOPENDIR *)pvDir;
245 KU32 const cChildren = pDir->pDir->cChildren;
246 while (pDir->idxNext < cChildren)
247 {
248 PKFSOBJ pEntry = pDir->pDir->papChildren[pDir->idxNext++];
249
250 /* Don't return missing objects. */
251 if (pEntry->bObjType != KFSOBJ_TYPE_MISSING)
252 {
253 /* Copy the name that fits. If neither fits, skip the name. */
254 if (pEntry->cchName < sizeof(pDir->DirEnt.d_name))
255 {
256 pDir->DirEnt.d_namlen = pEntry->cchName;
257 memcpy(pDir->DirEnt.d_name, pEntry->pszName, pEntry->cchName + 1);
258 }
259 else if (pEntry->cchShortName < sizeof(pDir->DirEnt.d_name))
260 {
261 pDir->DirEnt.d_namlen = pEntry->cchShortName;
262 memcpy(pDir->DirEnt.d_name, pEntry->pszShortName, pEntry->cchShortName + 1);
263 }
264 else
265 continue;
266
267 pDir->DirEnt.d_reclen = offsetof(struct dirent, d_name) + pDir->DirEnt.d_namlen;
268 if (pEntry->bObjType == KFSOBJ_TYPE_DIR)
269 pDir->DirEnt.d_type = DT_DIR;
270 else if (pEntry->bObjType == KFSOBJ_TYPE_FILE)
271 pDir->DirEnt.d_type = DT_REG;
272 else
273 pDir->DirEnt.d_type = DT_UNKNOWN;
274
275 return &pDir->DirEnt;
276 }
277 }
278
279 /*
280 * Fake the '.' and '..' directories because they're not part of papChildren above.
281 */
282 if (pDir->idxNext < cChildren + 2)
283 {
284 pDir->idxNext++;
285 pDir->DirEnt.d_type = DT_DIR;
286 pDir->DirEnt.d_namlen = pDir->idxNext - cChildren;
287 pDir->DirEnt.d_reclen = offsetof(struct dirent, d_name) + pDir->DirEnt.d_namlen;
288 pDir->DirEnt.d_name[0] = '.';
289 pDir->DirEnt.d_name[1] = '.';
290 pDir->DirEnt.d_name[pDir->DirEnt.d_namlen] = '\0';
291 return &pDir->DirEnt;
292 }
293
294 return NULL;
295}
296
297
298/**
299 * closedir for glob.
300 *
301 * @param pDir Directory enum handle by dir_glob_opendir.
302 */
303static void dir_glob_closedir(__ptr_t pvDir)
304{
305 KMKNTOPENDIR *pDir = (KMKNTOPENDIR *)pvDir;
306 kFsCacheObjRelease(g_pFsCache, &pDir->pDir->Obj);
307 pDir->pDir = NULL;
308 free(pDir);
309}
310
311
312/**
313 * stat for glob.
314 *
315 * @returns 0 on success, -1 + errno on failure.
316 * @param pszPath The path to stat.
317 * @param pStat Where to return the info.
318 */
319static int dir_glob_stat(const char *pszPath, struct stat *pStat)
320{
321 KFSLOOKUPERROR enmError;
322 PKFSOBJ pPathObj = kFsCacheLookupA(g_pFsCache, pszPath, &enmError);
323/** @todo follow symlinks vs. on symlink! */
324 if (pPathObj)
325 {
326 if (pPathObj->bObjType != KFSOBJ_TYPE_MISSING)
327 {
328 kHlpAssert(pPathObj->fHaveStats); /* currently always true. */
329 *pStat = pPathObj->Stats;
330 kFsCacheObjRelease(g_pFsCache, pPathObj);
331 return 0;
332 }
333 kFsCacheObjRelease(g_pFsCache, pPathObj);
334 }
335 errno = ENOENT;
336 return -1;
337}
338
339
340/**
341 * lstat for glob.
342 *
343 * @returns 0 on success, -1 + errno on failure.
344 * @param pszPath The path to stat.
345 * @param pStat Where to return the info.
346 */
347static int dir_glob_lstat(const char *pszPath, struct stat *pStat)
348{
349 KFSLOOKUPERROR enmError;
350 PKFSOBJ pPathObj = kFsCacheLookupA(g_pFsCache, pszPath, &enmError);
351 if (pPathObj)
352 {
353 if (pPathObj->bObjType != KFSOBJ_TYPE_MISSING)
354 {
355 kHlpAssert(pPathObj->fHaveStats); /* currently always true. */
356 *pStat = pPathObj->Stats;
357 kFsCacheObjRelease(g_pFsCache, pPathObj);
358 return 0;
359 }
360 kFsCacheObjRelease(g_pFsCache, pPathObj);
361 errno = ENOENT;
362 }
363 else
364 errno = enmError == KFSLOOKUPERROR_NOT_DIR
365 || enmError == KFSLOOKUPERROR_PATH_COMP_NOT_DIR
366 ? ENOTDIR : ENOENT;
367
368 return -1;
369}
370
371
372/**
373 * Checks if @a pszDir exists and is a directory.
374 *
375 * @returns 1 if is directory, 0 if isn't or doesn't exists.
376 * @param pszDir The alleged directory.
377 */
378static int dir_globl_dir_exists_p(const char *pszDir)
379{
380 int fRc;
381 KFSLOOKUPERROR enmError;
382 PKFSOBJ pDirObj = kFsCacheLookupA(g_pFsCache, pszDir, &enmError);
383 if (pDirObj)
384 {
385 fRc = pDirObj->bObjType == KFSOBJ_TYPE_DIR;
386 kFsCacheObjRelease(g_pFsCache, pDirObj);
387 }
388 else
389 fRc = 0;
390 return fRc;
391
392}
393
394
395/**
396 * Sets up pGlob with the necessary callbacks.
397 *
398 * @param pGlob Structure to populate.
399 */
400void dir_setup_glob(glob_t *pGlob)
401{
402 pGlob->gl_opendir = dir_glob_opendir;
403 pGlob->gl_readdir = dir_glob_readdir;
404 pGlob->gl_closedir = dir_glob_closedir;
405 pGlob->gl_stat = dir_glob_stat;
406#ifdef __EMX__ /* The FreeBSD implementation actually uses gl_lstat!! */
407 pGlob->gl_lstat = dir_glob_lstat;
408#else
409 pGlob->gl_exists = file_exists_p;
410 pGlob->gl_isdir = dir_globl_dir_exists_p;
411#endif
412}
413
414
415void print_dir_data_base(void)
416{
417 /** @todo. */
418}
419
420
421
422void nt_fullpath_cached(const char *pszPath, char *pszFull, size_t cbFull)
423{
424 KFSLOOKUPERROR enmError;
425 PKFSOBJ pPathObj = kFsCacheLookupA(g_pFsCache, pszPath, &enmError);
426 if (pPathObj)
427 {
428 KSIZE off = pPathObj->cchParent;
429 if (off > 0)
430 {
431 KSIZE offEnd = off + pPathObj->cchName;
432 if (offEnd < cbFull)
433 {
434 PKFSDIR pAncestor;
435
436 pszFull[off + pPathObj->cchName] = '\0';
437 memcpy(&pszFull[off], pPathObj->pszName, pPathObj->cchName);
438
439 for (pAncestor = pPathObj->pParent; off > 0; pAncestor = pAncestor->Obj.pParent)
440 {
441 kHlpAssert(off > 1);
442 kHlpAssert(pAncestor != NULL);
443 kHlpAssert(pAncestor->ObjcchName > 0);
444 pszFull[--off] = '/';
445 off -= pAncestor->Obj.cchName;
446 kHlpAssert(pAncestor->Obj.cchParent == off);
447 memcpy(&pszFull[off], pAncestor->Obj.pszName, pAncestor->Obj.cchName);
448 }
449 kFsCacheObjRelease(g_pFsCache, pPathObj);
450 return;
451 }
452 }
453 else
454 {
455 if ((size_t)pPathObj->cchName + 1 < cbFull)
456 {
457 memcpy(pszFull, pPathObj->pszName, pPathObj->cchName);
458 pszFull[pPathObj->cchName] = '/';
459 pszFull[pPathObj->cchName + 1] = '\0';
460
461 kFsCacheObjRelease(g_pFsCache, pPathObj);
462 return;
463 }
464 }
465
466 /* do fallback. */
467 kHlpAssertFailed();
468 kFsCacheObjRelease(g_pFsCache, pPathObj);
469 }
470
471 nt_fullpath(pszPath, pszFull, cbFull);
472}
473
474
475/**
476 * Special stat call used by remake.c
477 *
478 * @returns 0 on success, -1 + errno on failure.
479 * @param pszPath The path to stat.
480 * @param pStat Where to return the mtime field only.
481 */
482int stat_only_mtime(const char *pszPath, struct stat *pStat)
483{
484 /* Currently a little expensive, so just hit the file system once the
485 jobs starts comming in. */
486 if (g_cInvalidates == 0)
487 {
488 KFSLOOKUPERROR enmError;
489 PKFSOBJ pPathObj = kFsCacheLookupA(g_pFsCache, pszPath, &enmError);
490 if (pPathObj)
491 {
492 if (pPathObj->bObjType != KFSOBJ_TYPE_MISSING)
493 {
494 kHlpAssert(pPathObj->fHaveStats); /* currently always true. */
495 pStat->st_mtime = pPathObj->Stats.st_mtime;
496 kFsCacheObjRelease(g_pFsCache, pPathObj);
497 return 0;
498 }
499
500 kFsCacheObjRelease(g_pFsCache, pPathObj);
501 errno = ENOENT;
502 }
503 else
504 errno = enmError == KFSLOOKUPERROR_NOT_DIR
505 || enmError == KFSLOOKUPERROR_PATH_COMP_NOT_DIR
506 ? ENOTDIR : ENOENT;
507 return -1;
508 }
509 return birdStatModTimeOnly(pszPath, &pStat->st_mtim, 1 /*fFollowLink*/);
510}
511
512/**
513 * Do cache invalidation after a job completes.
514 */
515void dir_cache_invalid_after_job(void)
516{
517 g_cInvalidates++;
518 if (g_fFsCacheIsUsingCustomRevision)
519 kFsCacheInvalidateCustomBoth(g_pFsCache);
520 else
521 kFsCacheInvalidateAll(g_pFsCache);
522}
523
524/**
525 * Invalidate the whole directory cache
526 *
527 * Used by $(dircache-ctl invalidate)
528 */
529void dir_cache_invalid_all(void)
530{
531 g_cInvalidates++;
532 kFsCacheInvalidateAll(g_pFsCache);
533}
534
535/**
536 * Invalidate missing bits of the directory cache.
537 *
538 * Used by $(dircache-ctl invalidate-missing)
539 */
540void dir_cache_invalid_missing(void)
541{
542 g_cInvalidates++;
543 kFsCacheInvalidateAll(g_pFsCache);
544}
545
546/**
547 * Invalidate the volatile bits of the directory cache.
548 *
549 * Used by $(dircache-ctl invalidate-missing)
550 */
551void dir_cache_invalid_volatile(void)
552{
553 g_cInvalidates++;
554 if (g_fFsCacheIsUsingCustomRevision)
555 kFsCacheInvalidateCustomBoth(g_pFsCache);
556 else
557 kFsCacheInvalidateAll(g_pFsCache);
558}
559
560/**
561 * Used by $(dircache-ctl ) to mark a directory subtree or file as volatile.
562 *
563 * The first call changes the rest of the cache to be considered non-volatile.
564 *
565 * @returns 0 on success, -1 on failure.
566 * @param pszDir The directory (or file for what that is worth).
567 */
568int dir_cache_volatile_dir(const char *pszDir)
569{
570 KFSLOOKUPERROR enmError;
571 PKFSOBJ pObj = kFsCacheLookupA(g_pFsCache, pszDir, &enmError);
572 if (pObj)
573 {
574 KBOOL fRc = kFsCacheSetupCustomRevisionForTree(g_pFsCache, pObj);
575 kFsCacheObjRelease(g_pFsCache, pObj);
576 if (fRc)
577 {
578 g_fFsCacheIsUsingCustomRevision = K_TRUE;
579 return 0;
580 }
581 error(reading_file, "failed to mark '%s' as volatile", pszDir);
582 }
583 else
584 error(reading_file, "failed to mark '%s' as volatile (not found)", pszDir);
585 return -1;
586}
587
588/**
589 * Invalidates a deleted directory so the cache can close handles to it.
590 *
591 * Used by kmk_builtin_rm and kmk_builtin_rmdir.
592 *
593 * @returns 0 on success, -1 on failure.
594 * @param pszDir The directory to invalidate as deleted.
595 */
596int dir_cache_deleted_directory(const char *pszDir)
597{
598 if (kFsCacheInvalidateDeletedDirectoryA(g_pFsCache, pszDir))
599 return 0;
600 return -1;
601}
602
603
604int kmk_builtin_dircache(int argc, char **argv, char **envp)
605{
606 if (argc >= 2)
607 {
608 const char *pszCmd = argv[1];
609 if (strcmp(pszCmd, "invalidate") == 0)
610 {
611 if (argc == 2)
612 {
613 dir_cache_invalid_all();
614 return 0;
615 }
616 fprintf(stderr, "kmk_builtin_dircache: the 'invalidate' command takes no arguments!\n");
617 }
618 else if (strcmp(pszCmd, "invalidate-missing") == 0)
619 {
620 if (argc == 2)
621 {
622 dir_cache_invalid_missing ();
623 return 0;
624 }
625 fprintf(stderr, "kmk_builtin_dircache: the 'invalidate-missing' command takes no arguments!\n");
626 }
627 else if (strcmp(pszCmd, "volatile") == 0)
628 {
629 int i;
630 for (i = 2; i < argc; i++)
631 dir_cache_volatile_dir(argv[i]);
632 return 0;
633 }
634 else if (strcmp(pszCmd, "deleted") == 0)
635 {
636 int i;
637 for (i = 2; i < argc; i++)
638 dir_cache_deleted_directory(argv[i]);
639 return 0;
640 }
641 else
642 fprintf(stderr, "kmk_builtin_dircache: Invalid command '%s'!\n", pszCmd);
643 }
644 else
645 fprintf(stderr, "kmk_builtin_dircache: No command given!\n");
646
647 K_NOREF(envp);
648 return 2;
649}
650
Note: See TracBrowser for help on using the repository browser.

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