From: Patrick Lam <plam@MIT.EDU>
Date: Tue, 30 Aug 2005 05:55:13 +0000 (+0000)
Subject: src/fcint.c
X-Git-Tag: fc-2_3_90~20
X-Git-Url: https://git.wh0rd.org/?a=commitdiff_plain;h=eb0cf67144258acbee0a5bf369b6dfb950fcebb9;p=fontconfig.git

src/fcint.c
The global cache now uses the same mmap-based cache infrastructure as the
    per-directory caches. Furthermore, the global cache is automatically
    updated (if possible) whenever fontconfig is used. Rip out remnants of
    the old cache infrastructure.
---

diff --git a/fc-cache/fc-cache.c b/fc-cache/fc-cache.c
index d2809ee..507902f 100644
--- a/fc-cache/fc-cache.c
+++ b/fc-cache/fc-cache.c
@@ -191,7 +191,6 @@ scanDirs (FcStrList *list, FcConfig *config, char *program, FcBool force, FcBool
 	    ret++;
 	    continue;
 	}
-#if 0 // put this back later after fixing DirCacheValid
 	if (!force && FcDirCacheValid (dir))
 	{
 	    if (verbose)
@@ -199,7 +198,6 @@ scanDirs (FcStrList *list, FcConfig *config, char *program, FcBool force, FcBool
 			set->nfont, nsubdirs(subdirs));
 	}
 	else
-#endif
 	{
 	    if (verbose)
 		printf ("caching, %d fonts, %d dirs\n", 
@@ -271,7 +269,6 @@ main (int argc, char **argv)
 
     if (systemOnly)
 	FcConfigEnableHome (FcFalse);
-    FcCacheForce (FcTrue);
     /* need to use FcInitLoadConfig when we use dirs */
     FcInit ();
     config = FcConfigGetCurrent ();
diff --git a/src/fccache.c b/src/fccache.c
index 2255b3b..51a49af 100644
--- a/src/fccache.c
+++ b/src/fccache.c
@@ -31,236 +31,34 @@
 #define ENDIAN_TEST 0x12345678
 #define MACHINE_SIGNATURE_SIZE 9 + 5*19 + 1
 
-static char *
-FcCacheProduceMachineSignature (void);
-
-/*
- * POSIX has broken stdio so that getc must do thread-safe locking,
- * this is a serious performance problem for applications doing large
- * amounts of IO with getc (as is done here).  If available, use
- * the getc_unlocked varient instead.
- */
- 
-#if defined(getc_unlocked) || defined(_IO_getc_unlocked)
-#define GETC(f) getc_unlocked(f)
-#define PUTC(c,f) putc_unlocked(c,f)
-#else
-#define GETC(f) getc(f)
-#define PUTC(c,f) putc(c,f)
-#endif
-
-#define FC_DBG_CACHE_REF    1024
-
-#define PAGESIZE 8192
-
-static FcBool force;
-
-static FcChar8 *
-FcCacheReadString (FILE *f, FcChar8 *dest, int len)
-{
-    int		c;
-    FcBool	escape;
-    FcChar8	*d;
-    int		size;
-    int		i;
-
-    while ((c = GETC (f)) != EOF)
-	if (c == '"')
-	    break;
-    if (c == EOF)
-	return FcFalse;
-    if (len == 0)
-	return FcFalse;
-    
-    size = len;
-    i = 0;
-    d = dest;
-    escape = FcFalse;
-    while ((c = GETC (f)) != EOF)
-    {
-	if (!escape)
-	{
-	    switch (c) {
-	    case '"':
-		c = '\0';
-		break;
-	    case '\\':
-		escape = FcTrue;
-		continue;
-	    }
-	}
-	if (i == size)
-	{
-	    FcChar8 *new = malloc (size * 2);	/* freed in caller */
-	    if (!new)
-		break;
-	    memcpy (new, d, size);
-	    size *= 2;
-	    if (d != dest)
-		free (d);
-	    d = new;
-	}
-	d[i++] = c;
-	if (c == '\0')
-	    return d;
-	escape = FcFalse;
-    }
-    if (d != dest)
-	free (d);
-    return 0;
-}
-
-static FcBool
-FcCacheReadUlong (FILE *f, unsigned long *dest)
-{
-    unsigned long   t;
-    int		    c;
-
-    while ((c = GETC (f)) != EOF)
-    {
-	if (!isspace (c))
-	    break;
-    }
-    if (c == EOF)
-	return FcFalse;
-    t = 0;
-    for (;;)
-    {
-	if (c == EOF || isspace (c))
-	    break;
-	if (!isdigit (c))
-	    return FcFalse;
-	t = t * 10 + (c - '0');
-	c = GETC (f);
-    }
-    *dest = t;
-    return FcTrue;
-}
-
-static FcBool
-FcCacheReadInt (FILE *f, int *dest)
-{
-    unsigned long   t;
-    FcBool	    ret;
-
-    ret = FcCacheReadUlong (f, &t);
-    if (ret)
-	*dest = (int) t;
-    return ret;
-}
+static off_t
+FcCacheSkipToArch (int fd, const char * arch);
 
-static FcBool
-FcCacheReadTime (FILE *f, time_t *dest)
-{
-    unsigned long   t;
-    FcBool	    ret;
+static FcBool 
+FcCacheMoveDown (int fd, off_t start);
 
-    ret = FcCacheReadUlong (f, &t);
-    if (ret)
-	*dest = (time_t) t;
-    return ret;
-}
+static void *
+FcDirCacheProduce (FcFontSet *set, FcCache * metadata);
 
 static FcBool
-FcCacheWriteChars (FILE *f, const FcChar8 *chars)
-{
-    FcChar8    c;
-    while ((c = *chars++))
-    {
-	switch (c) {
-	case '"':
-	case '\\':
-	    if (PUTC ('\\', f) == EOF)
-		return FcFalse;
-	    /* fall through */
-	default:
-	    if (PUTC (c, f) == EOF)
-		return FcFalse;
-	}
-    }
-    return FcTrue;
-}
+FcDirCacheConsume (int fd, FcFontSet *set);
 
 static FcBool
-FcCacheWriteString (FILE *f, const FcChar8 *string)
-{
+FcDirCacheRead (FcFontSet * set, const FcChar8 *dir);
 
-    if (PUTC ('"', f) == EOF)
-	return FcFalse;
-    if (!FcCacheWriteChars (f, string))
-	return FcFalse;
-    if (PUTC ('"', f) == EOF)
-	return FcFalse;
-    return FcTrue;
-}
-
-static FcBool
-FcCacheWritePath (FILE *f, const FcChar8 *dir, const FcChar8 *file)
-{
-    if (PUTC ('"', f) == EOF)
-	return FcFalse;
-    if (dir)
-	if (!FcCacheWriteChars (f, dir))
-	    return FcFalse;
-#ifdef _WIN32
-    if (dir &&
-	dir[strlen((const char *) dir) - 1] != '/' &&
-	dir[strlen((const char *) dir) - 1] != '\\')
-    {
-	if (!FcCacheWriteChars (f, "\\"))
-	    return FcFalse;
-    }
-#else
-    if (dir && dir[strlen((const char *) dir) - 1] != '/')
-	if (PUTC ('/', f) == EOF)
-	    return FcFalse;
-#endif
-    if (!FcCacheWriteChars (f, file))
-	return FcFalse;
-    if (PUTC ('"', f) == EOF)
-	return FcFalse;
-    return FcTrue;
-}
-
-static FcBool
-FcCacheWriteUlong (FILE *f, unsigned long t)
-{
-    int	    pow;
-    unsigned long   temp, digit;
+static int
+FcCacheNextOffset(off_t w);
 
-    temp = t;
-    pow = 1;
-    while (temp >= 10)
-    {
-	temp /= 10;
-	pow *= 10;
-    }
-    temp = t;
-    while (pow)
-    {
-	digit = temp / pow;
-	if (PUTC ((char) digit + '0', f) == EOF)
-	    return FcFalse;
-	temp = temp - pow * digit;
-	pow = pow / 10;
-    }
-    return FcTrue;
-}
+static char *
+FcCacheMachineSignature (void);
 
 static FcBool
-FcCacheWriteInt (FILE *f, int i)
-{
-    return FcCacheWriteUlong (f, (unsigned long) i);
-}
+FcCacheHaveBank (int bank);
 
-static FcBool
-FcCacheWriteTime (FILE *f, time_t t)
-{
-    return FcCacheWriteUlong (f, (unsigned long) t);
-}
+#define FC_DBG_CACHE_REF    1024
 
 static FcChar8 *
-FcCacheReadString2 (int fd, FcChar8 *dest, int len)
+FcCacheReadString (int fd, FcChar8 *dest, int len)
 {
     FcChar8	c;
     FcBool	escape;
@@ -300,635 +98,187 @@ FcCacheReadString2 (int fd, FcChar8 *dest, int len)
 }
 
 static FcBool
-FcCacheWriteString2 (int fd, const FcChar8 *chars)
+FcCacheWriteString (int fd, const FcChar8 *chars)
 {
     if (write (fd, chars, strlen(chars)+1) != strlen(chars)+1)
 	return FcFalse;
     return FcTrue;
 }
 
-static FcBool
-FcCacheFontSetAdd (FcFontSet	    *set,
-		   FcStrSet	    *dirs,
-		   const FcChar8    *dir,
-		   int		    dir_len,
-		   const FcChar8    *file,
-		   const FcChar8    *name,
-		   FcConfig	    *config)
+static void
+FcGlobalCacheDirDestroy (FcGlobalCacheDir *d)
 {
-    FcChar8	path_buf[8192], *path;
-    int		len;
-    FcBool	ret = FcFalse;
-    FcPattern	*font;
-    FcPattern	*frozen;
-
-    path = path_buf;
-    len = (dir_len + 1 + strlen ((const char *) file) + 1);
-    if (len > sizeof (path_buf))
-    {
-	path = malloc (len);	/* freed down below */
-	if (!path)
-	    return FcFalse;
-    }
-    strncpy ((char *) path, (const char *) dir, dir_len);
-#ifdef _WIN32
-    if (dir[dir_len - 1] != '/' && dir[dir_len - 1] != '\\' )
-	path[dir_len++] = '\\';
-#else
-    if (dir[dir_len - 1] != '/')
-	path[dir_len++] = '/';
-#endif
-    strcpy ((char *) path + dir_len, (const char *) file);
-    if (config && !FcConfigAcceptFilename (config, path))
-	ret = FcTrue;
-    else if (!FcStrCmp (name, FC_FONT_FILE_DIR))
-    {
-	if (FcDebug () & FC_DBG_CACHEV)
-	    printf (" dir cache dir \"%s\"\n", path);
-	ret = FcStrSetAdd (dirs, path);
-    }
-    else if (!FcStrCmp (name, FC_FONT_FILE_INVALID))
-    {
-	ret = FcTrue;
-    }
-    else
+    FcGlobalCacheDir	*dd, *next;
+
+    for (dd = d; dd; dd = next)
     {
-	font = FcNameParse (name);
-	if (font)
-	{
-	    FcChar8 *family;
-	    
-	    if (FcDebug () & FC_DBG_CACHEV)
-		printf (" dir cache file \"%s\"\n", file);
-	    ret = FcPatternAddString (font, FC_FILE, path);
-	    /*
-	     * Make sure the pattern has the file name as well as
-	     * already containing at least one family name.
-	     */
-	    if (ret && 
-		FcPatternGetString (font, FC_FAMILY, 0, &family) == FcResultMatch &&
-		(!config || FcConfigAcceptFont (config, font)))
-	    {
-		frozen = FcPatternFreeze (font);
-		ret = (frozen != 0);
-		if (ret)
-		   ret = FcFontSetAdd (set, frozen);
-	    }
-	    FcPatternDestroy (font);
-	}
+	next = dd->next;
+	FcMemFree (FC_MEM_STRING, strlen (dd->name)+1);
+	free (dd->name);
+	FcMemFree (FC_MEM_CACHE, sizeof (FcGlobalCacheDir));
+	free (dd);
     }
-    if (path != path_buf) free (path);
-    return ret;
-    
 }
 
-static unsigned int
-FcCacheHash (const FcChar8 *string, int len)
+FcGlobalCache *
+FcGlobalCacheCreate (void)
 {
-    unsigned int    h = 0;
-    FcChar8	    c;
+    FcGlobalCache   *cache;
 
-    while (len-- && (c = *string++))
-	h = (h << 1) ^ c;
-    return h;
+    cache = malloc (sizeof (FcGlobalCache));
+    if (!cache)
+	return 0;
+    FcMemAlloc (FC_MEM_CACHE, sizeof (FcGlobalCache));
+    cache->dirs = 0;
+    cache->updated = FcFalse;
+    cache->fd = -1;
+    return cache;
 }
 
-/*
- * Verify the saved timestamp for a file
- */
-FcBool
-FcGlobalCacheCheckTime (const FcChar8 *file, FcGlobalCacheInfo *info)
+void
+FcGlobalCacheDestroy (FcGlobalCache *cache)
 {
-    struct stat	    statb;
+    FcGlobalCacheDir	*d, *next;
 
-    if (stat ((char *) file, &statb) < 0)
+    for (d = cache->dirs; d; d = next)
     {
-	if (FcDebug () & FC_DBG_CACHE)
-	    printf (" file %s missing\n", file);
-	return FcFalse;
+	next = d->next;
+	FcGlobalCacheDirDestroy (d);
     }
-    if (statb.st_mtime != info->time)
-    {
-	if (FcDebug () & FC_DBG_CACHE)
-	    printf (" timestamp mismatch (was %d is %d)\n",
-		    (int) info->time, (int) statb.st_mtime);
-	return FcFalse;
-    }
-    return FcTrue;
+    FcMemFree (FC_MEM_CACHE, sizeof (FcGlobalCache));
+    free (cache);
 }
 
 void
-FcGlobalCacheReferenced (FcGlobalCache	    *cache,
-			 FcGlobalCacheInfo  *info)
+FcGlobalCacheLoad (FcGlobalCache    *cache,
+		   const FcChar8    *cache_file)
 {
-    if (!info->referenced)
-    {
-	info->referenced = FcTrue;
-	cache->referenced++;
-	if (FcDebug () & FC_DBG_CACHE_REF)
-	    printf ("Reference %d %s\n", cache->referenced, info->file);
-    }
-}
-
-/*
- * Break a path into dir/base elements and compute the base hash
- * and the dir length.  This is shared between the functions
- * which walk the file caches
- */
+    FcChar8		name_buf[8192];
+    FcGlobalCacheDir	*d, *next;
+    char 		* current_arch_machine_name;
+    char 		candidate_arch_machine_name[MACHINE_SIGNATURE_SIZE + 9];
+    off_t		current_arch_start;
 
-typedef struct _FcFilePathInfo {
-    const FcChar8   *dir;
-    int		    dir_len;
-    const FcChar8   *base;
-    unsigned int    base_hash;
-} FcFilePathInfo;
+    cache->fd = open ((char *) cache_file, O_RDONLY);
+    if (cache->fd == -1)
+	return;
 
-static FcFilePathInfo
-FcFilePathInfoGet (const FcChar8    *path)
-{
-    FcFilePathInfo  i;
-    FcChar8	    *slash;
+    cache->updated = FcFalse;
 
-    slash = FcStrLastSlash (path);
-    if (slash)
-    {
-        i.dir = path;
-        i.dir_len = slash - path;
-	if (!i.dir_len)
-	    i.dir_len = 1;
-	i.base = slash + 1;
-    }
-    else
-    {
-	i.dir = (const FcChar8 *) ".";
-	i.dir_len = 1;
-	i.base = path;
-    }
-    i.base_hash = FcCacheHash (i.base, -1);
-    return i;
-}
+    current_arch_machine_name = FcCacheMachineSignature ();
+    current_arch_start = FcCacheSkipToArch(cache->fd, 
+					   current_arch_machine_name);
+    if (current_arch_start < 0)
+        goto bail0;
 
-FcGlobalCacheDir *
-FcGlobalCacheDirGet (FcGlobalCache  *cache,
-		     const FcChar8  *dir,
-		     int	    len,
-		     FcBool	    create_missing)
-{
-    unsigned int	hash = FcCacheHash (dir, len);
-    FcGlobalCacheDir	*d, **prev;
+    lseek (cache->fd, current_arch_start, SEEK_SET);
+    if (FcCacheReadString (cache->fd, candidate_arch_machine_name, 
+			   sizeof (candidate_arch_machine_name)) == 0)
+	goto bail0;
 
-    for (prev = &cache->ents[hash % FC_GLOBAL_CACHE_DIR_HASH_SIZE];
-	 (d = *prev);
-	 prev = &(*prev)->next)
+    while (1) 
     {
-	if (d->info.hash == hash && d->len == len &&
-	    !strncmp ((const char *) d->info.file,
-		      (const char *) dir, len))
+	FcCacheReadString (cache->fd, name_buf, sizeof (name_buf));
+	if (!strlen(name_buf))
 	    break;
-    }
-    if (!(d = *prev))
-    {
-	int	i;
-	if (!create_missing)
-	    return 0;
-	d = malloc (sizeof (FcGlobalCacheDir) + len + 1);
-	if (!d)
-	    return 0;
-	FcMemAlloc (FC_MEM_CACHE, sizeof (FcGlobalCacheDir) + len + 1);
-	d->next = *prev;
-	*prev = d;
-	d->info.hash = hash;
-	d->info.file = (FcChar8 *) (d + 1);
-	strncpy ((char *) d->info.file, (const char *) dir, len);
-	d->info.file[len] = '\0';
-	d->info.time = 0;
-	d->info.referenced = FcFalse;
-	d->len = len;
-	for (i = 0; i < FC_GLOBAL_CACHE_FILE_HASH_SIZE; i++)
-	    d->ents[i] = 0;
-	d->subdirs = 0;
-    }
-    return d;
-}
-
-static FcGlobalCacheInfo *
-FcGlobalCacheDirAdd (FcGlobalCache  *cache,
-		     const FcChar8  *dir,
-		     time_t	    time,
-		     FcBool	    replace,
-		     FcBool	    create_missing)
-{
-    FcGlobalCacheDir	*d;
-    FcFilePathInfo	i;
-    FcGlobalCacheSubdir	*subdir;
-    FcGlobalCacheDir	*parent;
 
-    i = FcFilePathInfoGet (dir);
-    parent = FcGlobalCacheDirGet (cache, i.dir, i.dir_len, create_missing);
-    /*
-     * Tricky here -- directories containing fonts.cache-1 files
-     * need entries only when the parent doesn't have a cache file.
-     * That is, when the parent already exists in the cache, is
-     * referenced and has a "real" timestamp.  The time of 0 is
-     * special and marks directories which got stuck in the
-     * global cache for this very reason.  Yes, it could
-     * use a separate boolean field, and probably should.
-     */
-    if (!parent || (!create_missing && 
-		    (!parent->info.referenced ||
-		    (parent->info.time == 0))))
-	return 0;
-    /*
-     * Add this directory to the cache
-     */
-    d = FcGlobalCacheDirGet (cache, dir, strlen ((const char *) dir), FcTrue);
-    if (!d)
-	return 0;
-    d->info.time = time;
-    /*
-     * Add this directory to the subdirectory list of the parent
-     */
-    subdir = malloc (sizeof (FcGlobalCacheSubdir));
-    if (!subdir)
-	return 0;
-    FcMemAlloc (FC_MEM_CACHE, sizeof (FcGlobalCacheSubdir));
-    subdir->ent = d;
-    subdir->next = parent->subdirs;
-    parent->subdirs = subdir;
-    return &d->info;
-}
+	d = malloc (sizeof (FcGlobalCacheDir));
+	if (!d)
+	    goto bail1;
 
-static void
-FcGlobalCacheDirDestroy (FcGlobalCacheDir *d)
-{
-    FcGlobalCacheFile	*f, *next;
-    int			h;
-    FcGlobalCacheSubdir	*s, *nexts;
+	d->next = cache->dirs;
+	cache->dirs = d;
 
-    for (h = 0; h < FC_GLOBAL_CACHE_FILE_HASH_SIZE; h++)
-	for (f = d->ents[h]; f; f = next)
-	{
-	    next = f->next;
-	    FcMemFree (FC_MEM_CACHE, sizeof (FcGlobalCacheFile) +
-		       strlen ((char *) f->info.file) + 1 +
-		       strlen ((char *) f->name) + 1);
-	    free (f);
-	}
-    for (s = d->subdirs; s; s = nexts)
-    {
-	nexts = s->next;
-	FcMemFree (FC_MEM_CACHE, sizeof (FcGlobalCacheSubdir));
-	free (s);
+	d->name = FcStrCopy (name_buf);
+	d->ent = 0;
+	d->offset = lseek (cache->fd, 0, SEEK_CUR);
+	read (cache->fd, &d->metadata, sizeof (FcCache));
+	lseek (cache->fd, d->metadata.count, SEEK_CUR);
     }
-    FcMemFree (FC_MEM_CACHE, sizeof (FcGlobalCacheDir) + d->len + 1);
-    free (d);
-}
+    return;
 
-/*
- * If the parent is in the global cache and referenced, add
- * an entry for 'dir' to the global cache.  This is used
- * for directories with fonts.cache files
- */
-
-void
-FcGlobalCacheReferenceSubdir (FcGlobalCache *cache,
-			      const FcChar8 *dir)
-{
-    FcGlobalCacheInfo	*info;
-    info = FcGlobalCacheDirAdd (cache, dir, 0, FcFalse, FcFalse);
-    if (info && !info->referenced)
+ bail1:
+    for (d = cache->dirs; d; d = next)
     {
-	info->referenced = FcTrue;
-	cache->referenced++;
+	next = d->next;
+	free (d);
     }
+    cache->dirs = 0;
+ bail0:
+    free (current_arch_machine_name);
+    close (cache->fd);
+    cache->fd = -1;
+    return;
 }
 
-/*
- * Check to see if the global cache contains valid data for 'dir'.
- * If so, scan the global cache for files and directories in 'dir'.
- * else, return False.
- */
 FcBool
-FcGlobalCacheScanDir (FcFontSet		*set,
-		      FcStrSet		*dirs,
-		      FcGlobalCache	*cache,
-		      const FcChar8	*dir,
-		      FcConfig		*config)
+FcGlobalCacheReadDir (FcFontSet *set, FcStrSet *dirs, FcGlobalCache * cache, const FcChar8 *dir, FcConfig *config)
 {
-    FcGlobalCacheDir	*d = FcGlobalCacheDirGet (cache, dir,
-						  strlen ((const char *) dir),
-						  FcFalse);
-    FcGlobalCacheFile	*f;
-    int			h;
-    int			dir_len;
-    FcGlobalCacheSubdir	*subdir;
-    FcBool		any_in_cache = FcFalse;
-
-    if (FcDebug() & FC_DBG_CACHE)
-	printf ("FcGlobalCacheScanDir %s\n", dir);
-    
-    if (!d)
-    {
-	if (FcDebug () & FC_DBG_CACHE)
-	    printf ("\tNo dir cache entry\n");
-	return FcFalse;
-    }
+    FcGlobalCacheDir *d;
 
-    /*
-     * See if the timestamp recorded in the global cache
-     * matches the directory time, if not, return False
-     */
-    if (!FcGlobalCacheCheckTime (d->info.file, &d->info))
-    {
-	if (FcDebug () & FC_DBG_CACHE)
-	    printf ("\tdir cache entry time mismatch\n");
+    if (cache->fd == -1)
 	return FcFalse;
-    }
 
-    /*
-     * Add files from 'dir' to the fontset
-     */
-    dir_len = strlen ((const char *) dir);
-    for (h = 0; h < FC_GLOBAL_CACHE_FILE_HASH_SIZE; h++)
-	for (f = d->ents[h]; f; f = f->next)
-	{
-	    if (FcDebug() & FC_DBG_CACHEV)
-		printf ("FcGlobalCacheScanDir add file %s\n", f->info.file);
-	    any_in_cache = FcTrue;
-	    if (!FcCacheFontSetAdd (set, dirs, dir, dir_len,
-				    f->info.file, f->name, config))
-	    {
-		cache->broken = FcTrue;
-		return FcFalse;
-	    }
-	    FcGlobalCacheReferenced (cache, &f->info);
-	}
-    /*
-     * Add directories in 'dir' to 'dirs'
-     */
-    for (subdir = d->subdirs; subdir; subdir = subdir->next)
+    for (d = cache->dirs; d; d = d->next)
     {
-	FcFilePathInfo	info = FcFilePathInfoGet (subdir->ent->info.file);
-	
-        any_in_cache = FcTrue;
-	if (!FcCacheFontSetAdd (set, dirs, dir, dir_len,
-				info.base, FC_FONT_FILE_DIR, config))
+	if (strcmp (d->name, dir) == 0)
 	{
-	    cache->broken = FcTrue;
-	    return FcFalse;
+	    lseek (cache->fd, d->offset, SEEK_SET);
+	    if (!FcDirCacheConsume (cache->fd, set))
+		return FcFalse;
+	    return FcTrue;
 	}
-	FcGlobalCacheReferenced (cache, &subdir->ent->info);
     }
-    
-    FcGlobalCacheReferenced (cache, &d->info);
 
-    /*
-     * To recover from a bug in previous versions of fontconfig,
-     * return FcFalse if no entries in the cache were found
-     * for this directory.  This will cause any empty directories
-     * to get rescanned every time fontconfig is initialized.  This
-     * might get removed at some point when the older cache files are
-     * presumably fixed.
-     */
-    return any_in_cache;
+    return FcFalse;
 }
 
-/*
- * Locate the cache entry for a particular file
- */
-FcGlobalCacheFile *
-FcGlobalCacheFileGet (FcGlobalCache *cache,
-		      const FcChar8 *file,
-		      int	    id,
-		      int	    *count)
+FcBool
+FcGlobalCacheUpdate (FcGlobalCache  *cache,
+		     const FcChar8  *name,
+		     FcFontSet	    *set)
 {
-    FcFilePathInfo	i = FcFilePathInfoGet (file);
-    FcGlobalCacheDir	*d = FcGlobalCacheDirGet (cache, i.dir, 
-						  i.dir_len, FcFalse);
-    FcGlobalCacheFile	*f, *match = 0;
-    int			max = -1;
+    FcGlobalCacheDir * d;
 
-    if (!d)
-	return 0;
-    for (f = d->ents[i.base_hash % FC_GLOBAL_CACHE_FILE_HASH_SIZE]; f; f = f->next)
-    {
-	if (f->info.hash == i.base_hash &&
-	    !strcmp ((const char *) f->info.file, (const char *) i.base))
-	{
-	    if (f->id == id)
-		match = f;
-	    if (f->id > max)
-		max = f->id;
-	}
-    }
-    if (count)
-	*count = max + 1;
-    return match;
-}
-    
-/*
- * Add a file entry to the cache
- */
-static FcGlobalCacheInfo *
-FcGlobalCacheFileAdd (FcGlobalCache *cache,
-		      const FcChar8 *path,
-		      int	    id,
-		      time_t	    time,
-		      const FcChar8 *name,
-		      FcBool	    replace)
-{
-    FcFilePathInfo	i = FcFilePathInfoGet (path);
-    FcGlobalCacheDir	*d = FcGlobalCacheDirGet (cache, i.dir, 
-						  i.dir_len, FcTrue);
-    FcGlobalCacheFile	*f, **prev;
-    int			size;
+    if (!set->nfont)
+	return FcTrue;
 
-    if (!d)
-	return 0;
-    for (prev = &d->ents[i.base_hash % FC_GLOBAL_CACHE_FILE_HASH_SIZE];
-	 (f = *prev);
-	 prev = &(*prev)->next)
+    for (d = cache->dirs; d; d = d->next)
     {
-	if (f->info.hash == i.base_hash && 
-	    f->id == id &&
-	    !strcmp ((const char *) f->info.file, (const char *) i.base))
-	{
+	if (strcmp(d->name, name) == 0)
 	    break;
-	}
-    }
-    if (*prev)
-    {
-	if (!replace)
-	    return 0;
-
-	f = *prev;
-	if (f->info.referenced)
-	    cache->referenced--;
-	*prev = f->next;
-	FcMemFree (FC_MEM_CACHE, sizeof (FcGlobalCacheFile) +
-		   strlen ((char *) f->info.file) + 1 +
-		   strlen ((char *) f->name) + 1);
-	free (f);
-    }
-    size = (sizeof (FcGlobalCacheFile) +
-	    strlen ((char *) i.base) + 1 +
-	    strlen ((char *) name) + 1);
-    f = malloc (size);
-    if (!f)
-	return 0;
-    FcMemAlloc (FC_MEM_CACHE, size);
-    f->next = *prev;
-    *prev = f;
-    f->info.hash = i.base_hash;
-    f->info.file = (FcChar8 *) (f + 1);
-    f->info.time = time;
-    f->info.referenced = FcFalse;
-    f->id = id;
-    f->name = f->info.file + strlen ((char *) i.base) + 1;
-    strcpy ((char *) f->info.file, (const char *) i.base);
-    strcpy ((char *) f->name, (const char *) name);
-    return &f->info;
-}
-
-FcGlobalCache *
-FcGlobalCacheCreate (void)
-{
-    FcGlobalCache   *cache;
-    int		    h;
-
-    cache = malloc (sizeof (FcGlobalCache));
-    if (!cache)
-	return 0;
-    FcMemAlloc (FC_MEM_CACHE, sizeof (FcGlobalCache));
-    for (h = 0; h < FC_GLOBAL_CACHE_DIR_HASH_SIZE; h++)
-	cache->ents[h] = 0;
-    cache->entries = 0;
-    cache->referenced = 0;
-    cache->updated = FcFalse;
-    cache->broken = FcFalse;
-    return cache;
-}
-
-void
-FcGlobalCacheDestroy (FcGlobalCache *cache)
-{
-    FcGlobalCacheDir	*d, *next;
-    int			h;
-
-    for (h = 0; h < FC_GLOBAL_CACHE_DIR_HASH_SIZE; h++)
-    {
-	for (d = cache->ents[h]; d; d = next)
-	{
-	    next = d->next;
-	    FcGlobalCacheDirDestroy (d);
-	}
     }
-    FcMemFree (FC_MEM_CACHE, sizeof (FcGlobalCache));
-    free (cache);
-}
 
-/*
- * Cache file syntax is quite simple:
- *
- * "file_name" id time "font_name" \n
- */
- 
-void
-FcGlobalCacheLoad (FcGlobalCache    *cache,
-		   const FcChar8    *cache_file)
-{
-    FILE		*f;
-    FcChar8		file_buf[8192], *file;
-    int			id;
-    time_t		time;
-    FcChar8		name_buf[8192], *name;
-    FcGlobalCacheInfo	*info;
-
-    f = fopen ((char *) cache_file, "r");
-    if (!f)
-	return;
-
-    cache->updated = FcFalse;
-    file = 0;
-    name = 0;
-    while ((file = FcCacheReadString (f, file_buf, sizeof (file_buf))) &&
-	   FcCacheReadInt (f, &id) &&
-	   FcCacheReadTime (f, &time) &&
-	   (name = FcCacheReadString (f, name_buf, sizeof (name_buf))))
+    if (!d)
     {
-	if (FcDebug () & FC_DBG_CACHEV)
-	    printf ("FcGlobalCacheLoad \"%s\" \"%20.20s\"\n", file, name);
-	if (!FcStrCmp (name, FC_FONT_FILE_DIR))
-	    info = FcGlobalCacheDirAdd (cache, file, time, FcFalse, FcTrue);
-	else
-	    info = FcGlobalCacheFileAdd (cache, file, id, time, name, FcFalse);
-	if (!info)
-	    cache->broken = FcTrue;
-	else
-	    cache->entries++;
-	if (FcDebug () & FC_DBG_CACHE_REF)
-	    printf ("FcGlobalCacheLoad entry %d %s\n",
-		    cache->entries, file);
-	if (file != file_buf)
-	    free (file);
-	if (name != name_buf)
-	    free (name);
-	file = 0;
-	name = 0;
+	d = malloc (sizeof (FcGlobalCacheDir));
+	if (!d)
+	    return FcFalse;
+	d->next = cache->dirs;
+	cache->dirs = d;
     }
-    if (file && file != file_buf)
-	free (file);
-    if (name && name != name_buf)
-	free (name);
-    fclose (f);
-}
 
-FcBool
-FcGlobalCacheUpdate (FcGlobalCache  *cache,
-		     const FcChar8  *file,
-		     int	    id,
-		     const FcChar8  *name)
-{
-    const FcChar8	*match;
-    struct stat		statb;
-    FcGlobalCacheInfo	*info;
-
-    match = file;
+    cache->updated = FcTrue;
 
-    if (stat ((char *) file, &statb) < 0)
-	return FcFalse;
-    if (S_ISDIR (statb.st_mode))
-	info = FcGlobalCacheDirAdd (cache, file, statb.st_mtime, 
-				    FcTrue, FcTrue);
-    else
-	info = FcGlobalCacheFileAdd (cache, file, id, statb.st_mtime, 
-				    name, FcTrue);
-    if (info)
-    {
-	FcGlobalCacheReferenced (cache, info);
-	cache->updated = FcTrue;
-    }
-    else
-	cache->broken = FcTrue;
-    return info != 0;
+    d->name = FcStrCopy (name);
+    d->ent = FcDirCacheProduce (set, &d->metadata);
+    d->offset = 0;
+    return FcTrue;
 }
 
 FcBool
 FcGlobalCacheSave (FcGlobalCache    *cache,
 		   const FcChar8    *cache_file)
 {
-    FILE		*f;
-    int			dir_hash, file_hash;
+    int			fd;
     FcGlobalCacheDir	*dir;
-    FcGlobalCacheFile	*file;
     FcAtomic		*atomic;
+    off_t 		current_arch_start = 0, truncate_to;
+    char 		* current_arch_machine_name, * header;
 
-    if (!cache->updated && cache->referenced == cache->entries)
+    if (!cache->updated)
 	return FcTrue;
     
-    if (cache->broken)
-	return FcFalse;
-
 #if defined (HAVE_GETUID) && defined (HAVE_GETEUID)
     /* Set-UID programs can't safely update the cache */
     if (getuid () != geteuid ())
@@ -940,61 +290,50 @@ FcGlobalCacheSave (FcGlobalCache    *cache,
 	goto bail0;
     if (!FcAtomicLock (atomic))
 	goto bail1;
-    f = fopen ((char *) FcAtomicNewFile(atomic), "w");
-    if (!f)
+    fd = open ((char *) FcAtomicNewFile(atomic), O_RDWR | O_CREAT, 
+	       S_IRUSR | S_IWUSR);
+    if (fd == -1)
 	goto bail2;
 
-    for (dir_hash = 0; dir_hash < FC_GLOBAL_CACHE_DIR_HASH_SIZE; dir_hash++)
+    current_arch_machine_name = FcCacheMachineSignature ();
+    current_arch_start = FcCacheSkipToArch(fd, current_arch_machine_name);
+    if (current_arch_start < 0)
+	current_arch_start = FcCacheNextOffset (lseek(fd, 0, SEEK_END));
+
+    if (!FcCacheMoveDown(fd, current_arch_start))
+	goto bail2;
+
+    current_arch_start = lseek(fd, 0, SEEK_CUR);
+    if (ftruncate (fd, current_arch_start) == -1)
+	goto bail2;
+
+    truncate_to = current_arch_start;
+    for (dir = cache->dirs; dir; dir = dir->next)
     {
-	for (dir = cache->ents[dir_hash]; dir; dir = dir->next)
-	{
-	    if (!dir->info.referenced)
-		continue;
-	    if (!FcCacheWriteString (f, dir->info.file))
-		goto bail4;
-	    if (PUTC (' ', f) == EOF)
-		goto bail4;
-	    if (!FcCacheWriteInt (f, 0))
-		goto bail4;
-	    if (PUTC (' ', f) == EOF)
-		goto bail4;
-	    if (!FcCacheWriteTime (f, dir->info.time))
-		goto bail4;
-	    if (PUTC (' ', f) == EOF)
-		goto bail4;
-	    if (!FcCacheWriteString (f, (FcChar8 *) FC_FONT_FILE_DIR))
-		goto bail4;
-	    if (PUTC ('\n', f) == EOF)
-		goto bail4;
-	    
-	    for (file_hash = 0; file_hash < FC_GLOBAL_CACHE_FILE_HASH_SIZE; file_hash++)
-	    {
-		for (file = dir->ents[file_hash]; file; file = file->next)
-		{
-		    if (!file->info.referenced)
-			continue;
-		    if (!FcCacheWritePath (f, dir->info.file, file->info.file))
-			goto bail4;
-		    if (PUTC (' ', f) == EOF)
-			goto bail4;
-		    if (!FcCacheWriteInt (f, file->id < 0 ? 0 : file->id))
-			goto bail4;
-		    if (PUTC (' ', f) == EOF)
-			goto bail4;
-		    if (!FcCacheWriteTime (f, file->info.time))
-			goto bail4;
-		    if (PUTC (' ', f) == EOF)
-			goto bail4;
-		    if (!FcCacheWriteString (f, file->name))
-			goto bail4;
-		    if (PUTC ('\n', f) == EOF)
-			goto bail4;
-		}
-	    }
-	}
+	truncate_to += strlen(dir->name) + 1;
+	truncate_to += sizeof (FcCache);
+	truncate_to = FcCacheNextOffset (current_arch_start + truncate_to);
+	truncate_to += dir->metadata.count;
+    }
+    truncate_to -= current_arch_start;
+    header = malloc (10 + strlen (current_arch_machine_name));
+    if (!header)
+	goto bail1;
+    sprintf (header, "%8x ", (int)truncate_to);
+    strcat (header, current_arch_machine_name);
+    if (!FcCacheWriteString (fd, header))
+	goto bail1;
+
+    for (dir = cache->dirs; dir; dir = dir->next)
+    {
+	FcCacheWriteString (fd, dir->name);
+	write (fd, &dir->metadata, sizeof(FcCache));
+	lseek (fd, FcCacheNextOffset (lseek(fd, 0, SEEK_END)), SEEK_SET);
+	write (fd, dir->ent, dir->metadata.count);
     }
+    FcCacheWriteString (fd, "");
 
-    if (fclose (f) == EOF)
+    if (close (fd) == -1)
 	goto bail3;
     
     if (!FcAtomicReplaceOrig (atomic))
@@ -1006,8 +345,6 @@ FcGlobalCacheSave (FcGlobalCache    *cache,
     cache->updated = FcFalse;
     return FcTrue;
 
-bail4:
-    fclose (f);
 bail3:
     FcAtomicDeleteNew (atomic);
 bail2:
@@ -1018,9 +355,10 @@ bail0:
     return FcFalse;
 }
 
+#define PAGESIZE 8192
 /* 
- * Find the next presumably-mmapable offset after the current file
- * pointer.
+ * Find the next presumably-mmapable offset after the supplied file
+ * position.
  */
 static int
 FcCacheNextOffset(off_t w)
@@ -1046,7 +384,7 @@ FcCacheSkipToArch (int fd, const char * arch)
 	long bs;
 
 	lseek (fd, current_arch_start, SEEK_SET);
-	if (FcCacheReadString2 (fd, candidate_arch_machine_name_count, 
+	if (FcCacheReadString (fd, candidate_arch_machine_name_count, 
 				sizeof (candidate_arch_machine_name_count)) == 0)
 	    break;
 	if (!strlen(candidate_arch_machine_name_count))
@@ -1059,7 +397,7 @@ FcCacheSkipToArch (int fd, const char * arch)
 	current_arch_start += bs;
     }
 
-    if (strcmp (candidate_arch, arch)!=0)
+    if (candidate_arch && strcmp (candidate_arch, arch)!=0)
 	return -1;
 
     return current_arch_start;
@@ -1068,12 +406,10 @@ FcCacheSkipToArch (int fd, const char * arch)
 /* Cuts out the segment at the file pointer (moves everything else
  * down to cover it), and leaves the file pointer at the end of the
  * file. */
-#define BUF_SIZE 8192
-
 static FcBool 
 FcCacheMoveDown (int fd, off_t start)
 {
-    char * buf = malloc (BUF_SIZE);
+    char * buf = malloc (8192);
     char candidate_arch_machine_name[MACHINE_SIGNATURE_SIZE + 9];
     long bs;
     int c, bytes_skipped;
@@ -1082,7 +418,7 @@ FcCacheMoveDown (int fd, off_t start)
 	return FcFalse;
 
     lseek (fd, start, SEEK_SET);
-    if (FcCacheReadString2 (fd, candidate_arch_machine_name, 
+    if (FcCacheReadString (fd, candidate_arch_machine_name, 
 			   sizeof (candidate_arch_machine_name)) == 0)
 	goto done;
     if (!strlen(candidate_arch_machine_name))
@@ -1096,7 +432,7 @@ FcCacheMoveDown (int fd, off_t start)
     do
     {
 	lseek (fd, start+bs+bytes_skipped, SEEK_SET);
-	if ((c = read (fd, buf, BUF_SIZE)) <= 0)
+	if ((c = read (fd, buf, 8192)) <= 0)
 	    break;
 	lseek (fd, start+bytes_skipped, SEEK_SET);
 	if (write (fd, buf, c) < 0)
@@ -1257,9 +593,6 @@ FcCacheRead (FcConfig *config, FcGlobalCache * cache)
     if (!s) 
 	return 0;
 
-    if (force)
-	goto bail;
-
     if (FcCacheReadDirs (config, cache, FcConfigGetConfigDirs (config), s))
 	goto bail;
 
@@ -1271,23 +604,19 @@ FcCacheRead (FcConfig *config, FcGlobalCache * cache)
 }
 
 /* read serialized state from the cache file */
-FcBool
+static FcBool
 FcDirCacheRead (FcFontSet * set, const FcChar8 *dir)
 {
     FcChar8         *cache_file = FcStrPlus (dir, (FcChar8 *) "/" FC_DIR_CACHE_FILE);
     int fd;
-    FcCache metadata;
-    void * current_dir_block;
     char * current_arch_machine_name;
     char candidate_arch_machine_name[9+MACHINE_SIGNATURE_SIZE];
     off_t current_arch_start = 0;
 
-    if (force)
-	goto bail;
     if (!cache_file)
         goto bail;
 
-    current_arch_machine_name = FcCacheProduceMachineSignature();
+    current_arch_machine_name = FcCacheMachineSignature();
     fd = open(cache_file, O_RDONLY);
     if (fd == -1)
         goto bail;
@@ -1297,109 +626,148 @@ FcDirCacheRead (FcFontSet * set, const FcChar8 *dir)
         goto bail1;
 
     lseek (fd, current_arch_start, SEEK_SET);
-    if (FcCacheReadString2 (fd, candidate_arch_machine_name, 
+    if (FcCacheReadString (fd, candidate_arch_machine_name, 
 			   sizeof (candidate_arch_machine_name)) == 0)
 	goto bail1;
+    
+    if (!FcDirCacheConsume (fd, set))
+	goto bail1;
+	
+    close(fd);
+    free (cache_file);
+    return FcTrue;
+
+ bail1:
+    close(fd);
+ bail:
+    free (cache_file);
+    return FcFalse;
+}
+
+static FcBool
+FcDirCacheConsume (int fd, FcFontSet *set)
+{
+    FcCache metadata;
+    void * current_dir_block;
 
-    // sanity check for endianness issues
     read(fd, &metadata, sizeof(FcCache));
     if (metadata.magic != FC_CACHE_MAGIC)
-        goto bail1;
+        return FcFalse;
 
     if (!metadata.count)
-	goto bail1;
+	return FcTrue;
 
     off_t pos = FcCacheNextOffset (lseek(fd, 0, SEEK_CUR));
     current_dir_block = mmap (0, metadata.count, 
 			      PROT_READ, MAP_SHARED, fd, pos);
     if (current_dir_block == MAP_FAILED)
-	perror("");
+	return FcFalse;
     
     if (!FcFontSetUnserialize (metadata, set, current_dir_block))
-	goto bail1;
-	
-    close(fd);
-    free (cache_file);
+	return FcFalse;
+
     return FcTrue;
+}
+
+static void *
+FcDirCacheProduce (FcFontSet *set, FcCache *metadata)
+{
+    void * current_dir_block, * final_dir_block;
+    static int rand_state = 0;
+    int bank;
+
+    if (!rand_state) 
+	rand_state = time(0L);
+    bank = rand_r(&rand_state);
+
+    while (FcCacheHaveBank(bank))
+	bank = rand_r(&rand_state);
+
+    memset (metadata, 0, sizeof(FcCache));
+    FcFontSetNewBank();
+    metadata->count = FcFontSetNeededBytes (set);
+    metadata->magic = FC_CACHE_MAGIC;
+    metadata->bank = bank;
+
+    if (!metadata->count) /* not a failure, no fonts to write */
+	return 0;
+
+    current_dir_block = malloc (metadata->count);
+    if (!current_dir_block)
+	goto bail;
+    final_dir_block = FcFontSetDistributeBytes (metadata, current_dir_block);
+
+    if ((char *)current_dir_block + metadata->count != final_dir_block)
+	goto bail;
+			      
+    if (!FcFontSetSerialize (bank, set))
+	goto bail;
+
+    return current_dir_block;
 
- bail1:
-    close(fd);
  bail:
-    free (cache_file);
-    return FcFalse;
+    free (current_dir_block);
+    return 0;
 }
 
 /* write serialized state to the cache file */
 FcBool
-FcDirCacheWrite (int bank, FcFontSet *set, const FcChar8 *dir)
+FcDirCacheWrite (FcFontSet *set, const FcChar8 *dir)
 {
     FcChar8         *cache_file = FcStrPlus (dir, (FcChar8 *) "/" FC_DIR_CACHE_FILE);
-    int fd, bytes_to_write, metadata_bytes;
+    int fd;
     FcCache metadata;
     off_t current_arch_start = 0, truncate_to;
     char * current_arch_machine_name, * header;
-    void * current_dir_block, *final_dir_block;
+    void * current_dir_block;
 
     if (!cache_file)
         goto bail;
 
-    FcFontSetNewBank();
-    bytes_to_write = FcFontSetNeededBytes (set);
-    metadata_bytes = FcCacheNextOffset (sizeof (FcCache));
+    current_dir_block = FcDirCacheProduce (set, &metadata);
 
-    if (!bytes_to_write)
+    if (!metadata.count)
     {
 	unlink (cache_file);
 	free (cache_file);
 	return FcTrue;
     }
 
-    current_dir_block = malloc (bytes_to_write);
-    memset (&metadata, 0, sizeof(FcCache));
-    metadata.count = bytes_to_write;
-    metadata.bank = bank;
     if (!current_dir_block)
 	goto bail;
-    final_dir_block = FcFontSetDistributeBytes (&metadata, current_dir_block);
-
-    if ((char *)current_dir_block + bytes_to_write != final_dir_block)
-	goto bail;
-			      
-    if (!FcFontSetSerialize (bank, set))
-	goto bail;
 
     if (FcDebug () & FC_DBG_CACHE)
         printf ("FcDirCacheWriteDir cache_file \"%s\"\n", cache_file);
 
     fd = open(cache_file, O_RDWR | O_CREAT, 0666);
     if (fd == -1)
-        goto bail;
+        goto bail0;
 
-    current_arch_machine_name = FcCacheProduceMachineSignature ();
+    current_arch_machine_name = FcCacheMachineSignature ();
     current_arch_start = FcCacheSkipToArch(fd, current_arch_machine_name);
     if (current_arch_start < 0)
 	current_arch_start = FcCacheNextOffset (lseek(fd, 0, SEEK_END));
 
     if (!FcCacheMoveDown(fd, current_arch_start))
-	goto bail1;
+	goto bail2;
 
     current_arch_start = lseek(fd, 0, SEEK_CUR);
     if (ftruncate (fd, current_arch_start) == -1)
-	goto bail1;
+	goto bail2;
 
     /* now write the address of the next offset */
-    truncate_to = FcCacheNextOffset (FcCacheNextOffset (current_arch_start + metadata_bytes) + bytes_to_write) - current_arch_start;
-
+    truncate_to = FcCacheNextOffset (FcCacheNextOffset (current_arch_start + sizeof (FcCache)) + metadata.count) - current_arch_start;
     header = malloc (10 + strlen (current_arch_machine_name));
+    if (!header)
+	goto bail1;
     sprintf (header, "%8x ", (int)truncate_to);
     strcat (header, current_arch_machine_name);
-    if (!FcCacheWriteString2 (fd, header))
+    if (!FcCacheWriteString (fd, header))
 	goto bail1;
 
-    metadata.magic = FC_CACHE_MAGIC;
     write (fd, &metadata, sizeof(FcCache));
     lseek (fd, FcCacheNextOffset (lseek(fd, 0, SEEK_END)), SEEK_SET);
-    write (fd, current_dir_block, bytes_to_write);
+    write (fd, current_dir_block, metadata.count);
 
     /* this actually serves to pad out the cache file, if needed */
     if (ftruncate (fd, current_arch_start + truncate_to) == -1)
@@ -1408,9 +776,12 @@ FcDirCacheWrite (int bank, FcFontSet *set, const FcChar8 *dir)
     close(fd);
     return FcTrue;
 
+ bail2:
+    free (header);
  bail1:
-    free (current_dir_block);
     free (current_arch_machine_name);
+ bail0:
+    free (current_dir_block);
  bail:
     unlink (cache_file);
     free (cache_file);
@@ -1418,7 +789,7 @@ FcDirCacheWrite (int bank, FcFontSet *set, const FcChar8 *dir)
 }
 
 static char *
-FcCacheProduceMachineSignature ()
+FcCacheMachineSignature ()
 {
     static char buf[MACHINE_SIGNATURE_SIZE];
     int magic = ENDIAN_TEST;
@@ -1451,23 +822,10 @@ FcCacheProduceMachineSignature ()
     return buf;
 }
 
-/* if true, ignore the cache file */
-void
-FcCacheForce (FcBool f)
-{
-    force = f;
-}
-
 static int banks_ptr = 0, banks_alloc = 0;
 static int * bankId = 0;
 
-int
-FcCacheBankCount (void)
-{
-    return banks_ptr;
-}
-
-FcBool
+static FcBool
 FcCacheHaveBank (int bank)
 {
     int i;
diff --git a/src/fcdir.c b/src/fcdir.c
index 4f69f22..4ee84de 100644
--- a/src/fcdir.c
+++ b/src/fcdir.c
@@ -45,16 +45,10 @@ FcFileScanConfig (FcFontSet	*set,
 		  FcConfig	*config)
 {
     int			id;
-#if 0
-    FcChar8		*name;
-    FcGlobalCacheFile	*cache_file;
-    FcGlobalCacheDir	*cache_dir;
-#endif
     FcPattern		*font;
     FcBool		ret = FcTrue;
     FcBool		isDir;
     int			count = 0;
-    FcBool		need_scan;
     
     if (config && !FcConfigAcceptFilename (config, file))
 	return FcTrue;
@@ -64,85 +58,23 @@ FcFileScanConfig (FcFontSet	*set,
     id = 0;
     do
     {
-	need_scan = FcTrue;
 	font = 0;
-#if 0
 	/*
-	 * Check the cache
+	 * Nothing in the cache, scan the file
 	 */
-	if (cache)
+	if (FcDebug () & FC_DBG_SCAN)
 	{
-	    if ((cache_file = FcGlobalCacheFileGet (cache, file, id, &count)))
-	    {
-		/*
-		 * Found a cache entry for the file
-		 */
-		if (FcGlobalCacheCheckTime (file, &cache_file->info))
-		{
-		    name = cache_file->name;
-		    need_scan = FcFalse;
-		    FcGlobalCacheReferenced (cache, &cache_file->info);
-		    /* "." means the file doesn't contain a font */
-		    if (FcStrCmp (name, FC_FONT_FILE_INVALID) != 0)
-		    {
-			font = FcNameParse (name);
-			if (font)
-			    if (!FcPatternAddString (font, FC_FILE, file))
-				ret = FcFalse;
-		    }
-		}
-	    }
-	    else if ((cache_dir = FcGlobalCacheDirGet (cache, file,
-						       strlen ((const char *) file),
-						       FcFalse)))
-	    {
-		if (FcGlobalCacheCheckTime (cache_dir->info.file, 
-					    &cache_dir->info))
-		{
-		    font = 0;
-		    need_scan = FcFalse;
-		    FcGlobalCacheReferenced (cache, &cache_dir->info);
-		    if (!FcStrSetAdd (dirs, file))
-			ret = FcFalse;
-		}
-	    }
+	    printf ("\tScanning file %s...", file);
+	    fflush (stdout);
 	}
-#endif
-	/*
-	 * Nothing in the cache, scan the file
-	 */
-	if (need_scan)
+	font = FcFreeTypeQuery (file, id, blanks, &count);
+	if (FcDebug () & FC_DBG_SCAN)
+	    printf ("done\n");
+	isDir = FcFalse;
+	if (!font && FcFileIsDir (file))
 	{
-	    if (FcDebug () & FC_DBG_SCAN)
-	    {
-		printf ("\tScanning file %s...", file);
-		fflush (stdout);
-	    }
-	    font = FcFreeTypeQuery (file, id, blanks, &count);
-	    if (FcDebug () & FC_DBG_SCAN)
-		printf ("done\n");
-	    isDir = FcFalse;
-	    if (!font && FcFileIsDir (file))
-	    {
-		isDir = FcTrue;
-		ret = FcStrSetAdd (dirs, file);
-	    }
-#if 0
-	    /*
-	     * Update the cache
-	     */
-	    if (cache && font)
-	    {
-		FcChar8	*unparse;
-
-		unparse = FcNameUnparse (font);
-		if (unparse)
-		{
-		    (void) FcGlobalCacheUpdate (cache, file, id, unparse);
-		    FcStrFree (unparse);
-		}
-	    }
-#endif
+	    isDir = FcTrue;
+	    ret = FcStrSetAdd (dirs, file);
 	}
 	/*
 	 * Add the font
@@ -193,29 +125,19 @@ FcDirScanConfig (FcFontSet	*set,
     FcChar8		*file;
     FcChar8		*base;
     FcBool		ret = FcTrue;
+    FcFontSet		*tmpSet;
+    int			i;
 
     if (config && !FcConfigAcceptFilename (config, dir))
 	return FcTrue;
 
     if (!force)
     {
-#if 0
-	/*
-	 * Check fonts.cache-<version> file
-	 */
-	if (FcDirCacheReadDir (set, dirs, dir, config))
-	{
-	    if (cache)
-		FcGlobalCacheReferenceSubdir (cache, dir);
-	    return FcTrue;
-	}
-    
 	/*
 	 * Check ~/.fonts.cache-<version> file
 	 */
-	if (cache && FcGlobalCacheScanDir (set, dirs, cache, dir, config))
+	if (cache && FcGlobalCacheReadDir (set, dirs, cache, dir, config))
 	    return FcTrue;
-#endif
     }
     
     /* freed below */
@@ -231,7 +153,6 @@ FcDirScanConfig (FcFontSet	*set,
 	printf ("\tScanning dir %s\n", dir);
 	
     d = opendir ((char *) dir);
-    
     if (!d)
     {
 	free (file);
@@ -240,12 +161,20 @@ FcDirScanConfig (FcFontSet	*set,
 	    return FcTrue;
 	return FcFalse;
     }
+
+    tmpSet = FcFontSetCreate();
+    if (!tmpSet)
+    {	
+	free (file);
+	return FcFalse;
+    }
+
     while (ret && (e = readdir (d)))
     {
 	if (e->d_name[0] != '.' && strlen (e->d_name) < FC_MAX_FILE_LEN)
 	{
 	    strcpy ((char *) base, (char *) e->d_name);
-	    ret = FcFileScanConfig (set, dirs, cache, blanks, file, force, config);
+	    ret = FcFileScanConfig (tmpSet, dirs, cache, blanks, file, force, config);
 	}
     }
     free (file);
@@ -254,10 +183,19 @@ FcDirScanConfig (FcFontSet	*set,
      * Now that the directory has been scanned,
      * add the cache entry 
      */
-#if 0
     if (ret && cache)
-	FcGlobalCacheUpdate (cache, dir, 0, 0);
-#endif
+	FcGlobalCacheUpdate (cache, dir, tmpSet);
+
+    for (i = 0; i < tmpSet->nfont; i++)
+	FcFontSetAdd (set, tmpSet->fonts[i]);
+
+    if (tmpSet->fonts)
+    {
+	FcMemFree (FC_MEM_FONTPTR, tmpSet->sfont * sizeof (FcPattern *));
+	free (tmpSet->fonts);
+    }
+    FcMemFree (FC_MEM_FONTSET, sizeof (FcFontSet));
+    free (tmpSet);
 	
     return ret;
 }
@@ -276,15 +214,5 @@ FcDirScan (FcFontSet	    *set,
 FcBool
 FcDirSave (FcFontSet *set, const FcChar8 *dir)
 {
-    static int rand_state = 0;
-    int bank;
-
-    if (!rand_state) 
-	rand_state = time(0L);
-    bank = rand_r(&rand_state);
-
-    while (FcCacheHaveBank(bank))
-	bank = rand_r(&rand_state);
-
-    return FcDirCacheWrite (bank, set, dir);
+    return FcDirCacheWrite (set, dir);
 }
diff --git a/src/fcint.h b/src/fcint.h
index e78fef7..8a68570 100644
--- a/src/fcint.h
+++ b/src/fcint.h
@@ -41,12 +41,6 @@
 #include <config.h>
 #endif
 
-/* unused */
-typedef struct _FcSymbolic {
-    const char	*name;
-    int		value;
-} FcSymbolic;
-
 #ifndef FC_CONFIG_PATH
 #define FC_CONFIG_PATH "fonts.conf"
 #endif
@@ -323,45 +317,22 @@ typedef struct _FcCaseFold {
  * cache which is then rewritten to the users home directory
  */
 
-#define FC_CACHE_MAGIC 0xFC20FC20
-#define FC_GLOBAL_CACHE_DIR_HASH_SIZE	    37
-#define FC_GLOBAL_CACHE_FILE_HASH_SIZE	    67
-
-typedef struct _FcGlobalCacheInfo {
-    unsigned int		hash;
-    FcChar8			*file;
-    time_t			time;
-    FcBool			referenced;
-} FcGlobalCacheInfo;
-
-typedef struct _FcGlobalCacheFile {
-    struct _FcGlobalCacheFile	*next;
-    FcGlobalCacheInfo		info;
-    int				id;
-    FcChar8			*name;
-} FcGlobalCacheFile;
+#define FC_CACHE_MAGIC 0xFC02FC02
 
 typedef struct _FcGlobalCacheDir FcGlobalCacheDir;
 
-typedef struct _FcGlobalCacheSubdir {
-    struct _FcGlobalCacheSubdir	*next;
-    FcGlobalCacheDir		*ent;
-} FcGlobalCacheSubdir;
-
 struct _FcGlobalCacheDir {
     struct _FcGlobalCacheDir	*next;
-    FcGlobalCacheInfo    	info;
-    int				len;
-    FcGlobalCacheFile		*ents[FC_GLOBAL_CACHE_FILE_HASH_SIZE];
-    FcGlobalCacheSubdir		*subdirs;
+    FcChar8			*name;
+    FcCache			metadata;
+    off_t			offset;
+    void			*ent;
 };
 
 typedef struct _FcGlobalCache {
-    FcGlobalCacheDir		*ents[FC_GLOBAL_CACHE_DIR_HASH_SIZE];
+    FcGlobalCacheDir		*dirs;
     FcBool			updated;
-    FcBool			broken;
-    int				entries;
-    int				referenced;
+    int				fd;
 } FcGlobalCache;
 
 struct _FcAtomic {
@@ -448,35 +419,11 @@ void
 FcGlobalCacheDestroy (FcGlobalCache *cache);
 
 FcBool
-FcGlobalCacheCheckTime (const FcChar8*file, FcGlobalCacheInfo *info);
-
-void
-FcGlobalCacheReferenced (FcGlobalCache	    *cache,
-			 FcGlobalCacheInfo  *info);
-
-void
-FcGlobalCacheReferenceSubdir (FcGlobalCache *cache,
-			      const FcChar8 *dir);
-
-FcGlobalCacheDir *
-FcGlobalCacheDirGet (FcGlobalCache  *cache,
-		     const FcChar8  *dir,
-		     int	    len,
-		     FcBool	    create_missing);
-
-FcBool
-FcGlobalCacheScanDir (FcFontSet		*set,
-		      FcStrSet		*dirs,
-		      FcGlobalCache	*cache,
-		      const FcChar8	*dir,
-		      FcConfig		*config);
-
-FcGlobalCacheFile *
-FcGlobalCacheFileGet (FcGlobalCache *cache,
-		      const FcChar8 *file,
-		      int	    id,
-		      int	    *count);
-
+FcGlobalCacheReadDir (FcFontSet     *set, 
+		      FcStrSet 	    *dirs, 
+		      FcGlobalCache *cache, 
+		      const FcChar8 *dir, 
+		      FcConfig 	    *config);
 
 void
 FcGlobalCacheLoad (FcGlobalCache    *cache,
@@ -485,33 +432,17 @@ FcGlobalCacheLoad (FcGlobalCache    *cache,
 FcBool
 FcGlobalCacheUpdate (FcGlobalCache  *cache,
 		     const FcChar8  *file,
-		     int	    id,
-		     const FcChar8  *name);
+		     FcFontSet	    *set);
 
 FcBool
 FcGlobalCacheSave (FcGlobalCache    *cache,
 		   const FcChar8    *cache_file);
 
-void
-FcCacheForce(FcBool force);
-
-FcBool
-FcCacheSerialize (int bank, FcConfig * config);
-
 FcFontSet *
 FcCacheRead (FcConfig *config, FcGlobalCache * cache);
 
 FcBool
-FcDirCacheRead (FcFontSet * set, const FcChar8 *dir);
-
-FcBool
-FcDirCacheWrite (int bank, FcFontSet *set, const FcChar8 *dir);
-
-int
-FcCacheBankCount (void);
-
-FcBool
-FcCacheHaveBank (int bank);
+FcDirCacheWrite (FcFontSet *set, const FcChar8 *dir);
 
 int
 FcCacheBankToIndex (int bank);