X-Git-Url: https://git.wh0rd.org/?a=blobdiff_plain;f=src%2Ffccache.c;h=bd8db460d60513170a45d5a907813b1ef99d0d0e;hb=bc5e8adb4d05d1d03007951f46aaacc63c3b2197;hp=295ee7750abc21ac215a395b9839f33287dbee36;hpb=00f059e930f12ca7c66cf2ffbc6c4ae789912af7;p=fontconfig.git

diff --git a/src/fccache.c b/src/fccache.c
index 295ee77..bd8db46 100644
--- a/src/fccache.c
+++ b/src/fccache.c
@@ -1,6 +1,4 @@
 /*
- * $RCSId: xc/lib/fontconfig/src/fccache.c,v 1.12 2002/08/22 07:36:44 keithp Exp $
- *
  * Copyright © 2000 Keith Packard
  * Copyright © 2005 Patrick Lam
  *
@@ -30,6 +28,7 @@
 #include <dirent.h>
 #include <string.h>
 #include <sys/types.h>
+#include <assert.h>
 #if defined(HAVE_MMAP) || defined(__CYGWIN__)
 #  include <unistd.h>
 #  include <sys/mman.h>
@@ -37,30 +36,10 @@
 #  include <windows.h>
 #endif
 
-#define ENDIAN_TEST 0x12345678
-#define MACHINE_SIGNATURE_SIZE (9 + 5*20 + 1)
-/* for when we don't have sysconf: */
-#define FC_HARDCODED_PAGESIZE 8192 
-
 #ifndef O_BINARY
 #define O_BINARY 0
 #endif
 
-static FILE *
-FcDirCacheOpen (FcConfig *config, const FcChar8 *dir, FcChar8 **cache_path);
-
-static void *
-FcDirCacheProduce (FcFontSet *set, FcCache * metadata);
-
-static off_t
-FcCacheNextOffset(off_t w);
-
-static FcBool
-FcCacheHaveBank (int bank);
-
-static void
-FcCacheAddBankDir (int bank, const char * dir);
-
 struct MD5Context {
         FcChar32 buf[4];
         FcChar32 bits[2];
@@ -68,77 +47,10 @@ struct MD5Context {
 };
 
 static void MD5Init(struct MD5Context *ctx);
-static void MD5Update(struct MD5Context *ctx, unsigned char *buf, unsigned len);
+static void MD5Update(struct MD5Context *ctx, const unsigned char *buf, unsigned len);
 static void MD5Final(unsigned char digest[16], struct MD5Context *ctx);
 static void MD5Transform(FcChar32 buf[4], FcChar32 in[16]);
 
-#define FC_DBG_CACHE_REF    1024
-
-static char *
-FcCacheReadString (FILE *file, char *dest, int len)
-{
-    int	    c;
-    char    *d = dest;
-
-    if (len == 0)
-	return 0;
-
-    while ((c = getc (file)) != EOF && len > 0) {
-	*d++ = c;
-	if (c == '\0')
-	    return dest;
-	len--;
-    }
-    return 0;
-}
-
-static FcBool
-FcCacheWriteString (int fd, const char *chars)
-{
-    if (write (fd, chars, strlen(chars)+1) != strlen(chars)+1)
-	return FcFalse;
-    return FcTrue;
-}
-
-/* 
- * Find the next presumably-mmapable offset after the supplied file
- * position.
- */
-static off_t
-FcCacheNextOffset(off_t w)
-{
-    static long pagesize = -1;
-
-    if (w == -1)
-        return w;
-
-    if (pagesize == -1)
-#if defined (HAVE_SYSCONF)
-	pagesize = sysconf(_SC_PAGESIZE);
-#else
-	pagesize = FC_HARDCODED_PAGESIZE;
-#endif
-    if (w % pagesize == 0) 
-	return w;
-    else
-	return ((w / pagesize)+1)*pagesize;
-}
-
-/* Does not check that the cache has the appropriate arch section. */
-FcBool
-FcDirCacheValid (const FcChar8 *dir, FcConfig *config)
-{
-    FILE *file;
-
-    file = FcDirCacheOpen (config, dir, NULL);
-
-    if (file != NULL)
-	return FcFalse;
-    fclose (file);
-
-    return FcTrue;
-}
-
 #define CACHEBASE_LEN (1 + 32 + 1 + sizeof (FC_ARCHITECTURE) + sizeof (FC_CACHE_SUFFIX))
 
 static const char bin2hex[] = { '0', '1', '2', '3',
@@ -155,7 +67,7 @@ FcDirCacheBasename (const FcChar8 * dir, FcChar8 cache_base[CACHEBASE_LEN])
     struct MD5Context 	ctx;
 
     MD5Init (&ctx);
-    MD5Update (&ctx, (unsigned char *)dir, strlen ((char *) dir));
+    MD5Update (&ctx, (const unsigned char *)dir, strlen ((const char *) dir));
 
     MD5Final (hash, &ctx);
 
@@ -192,6 +104,7 @@ FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config)
         if (!cache_hashed)
 	    break;
 	(void) unlink ((char *) cache_hashed);
+	FcStrFree (cache_hashed);
     }
     FcStrListDone (list);
     /* return FcFalse if something went wrong */
@@ -201,275 +114,607 @@ FcDirCacheUnlink (const FcChar8 *dir, FcConfig *config)
 }
 
 static int
-FcCacheReadDirs (FcConfig * config,
-		 FcStrList *list, FcFontSet * set, FcStrSet *processed_dirs)
+FcDirCacheOpenFile (const FcChar8 *cache_file, struct stat *file_stat)
 {
-    int			ret = 0;
-    FcChar8		*dir;
-    FcStrSet		*subdirs;
-    FcStrList		*sublist;
+    int	fd;
 
-    /*
-     * Read in the results from 'list'.
-     */
-    while ((dir = FcStrListNext (list)))
+    fd = open((char *) cache_file, O_RDONLY | O_BINARY);
+    if (fd < 0)
+	return fd;
+    if (fstat (fd, file_stat) < 0)
     {
-	if (!FcConfigAcceptFilename (config, dir))
-	    continue;
-
-	/* Skip this directory if already updated
-	 * to avoid the looped directories via symlinks
-	 * Clearly a dir not in fonts.conf shouldn't be globally cached.
-	 */
-
-	if (FcStrSetMember (processed_dirs, dir))
-	    continue;
-	if (!FcStrSetAdd (processed_dirs, dir))
-	    continue;
-
-	subdirs = FcStrSetCreate ();
-	if (!subdirs)
-	{
-	    fprintf (stderr, "Can't create directory set\n");
-	    ret++;
-	    continue;
-	}
-	
-	FcDirScanConfig (set, subdirs,
-			 config->blanks, dir, FcFalse, config);
-	
-	sublist = FcStrListCreate (subdirs);
-	FcStrSetDestroy (subdirs);
-	if (!sublist)
-	{
-	    fprintf (stderr, "Can't create subdir list in \"%s\"\n", dir);
-	    ret++;
-	    continue;
-	}
-	ret += FcCacheReadDirs (config, sublist, set, processed_dirs);
+	close (fd);
+	return -1;
     }
-    FcStrListDone (list);
-    return ret;
-}
-
-FcFontSet *
-FcCacheRead (FcConfig *config)
-{
-    FcFontSet 	*s = FcFontSetCreate();
-    FcStrSet 	*processed_dirs;
-
-    if (!s) 
-	return 0;
-
-    processed_dirs = FcStrSetCreate();
-    if (!processed_dirs)
-	goto bail;
-
-    if (FcCacheReadDirs (config, FcConfigGetConfigDirs (config), s, processed_dirs))
-	goto bail1;
-
-    FcStrSetDestroy (processed_dirs);
-    return s;
-
- bail1:
-    FcStrSetDestroy (processed_dirs);
- bail:
-    FcFontSetDestroy (s);
-    return 0;
+    return fd;
 }
 
-/* Opens the cache file for 'dir' for reading.
- * This searches the list of cache dirs for the relevant cache file,
- * returning the first one found.
+/* 
+ * Look for a cache file for the specified dir. Attempt
+ * to use each one we find, stopping when the callback
+ * indicates success
  */
-static FILE *
-FcDirCacheOpen (FcConfig *config, const FcChar8 *dir, FcChar8 **cache_path)
+static FcBool
+FcDirCacheProcess (FcConfig *config, const FcChar8 *dir, 
+		   FcBool (*callback) (int fd, struct stat *fd_stat,
+				       struct stat *dir_stat, void *closure),
+		   void *closure, FcChar8 **cache_file_ret)
 {
-    FILE	*file = NULL;
-    FcChar8	*cache_hashed = NULL;
+    int		fd = -1;
     FcChar8	cache_base[CACHEBASE_LEN];
     FcStrList	*list;
     FcChar8	*cache_dir;
     struct stat file_stat, dir_stat;
+    FcBool	ret = FcFalse;
 
     if (stat ((char *) dir, &dir_stat) < 0)
-        return NULL;
+        return FcFalse;
 
     FcDirCacheBasename (dir, cache_base);
 
     list = FcStrListCreate (config->cacheDirs);
     if (!list)
-        return NULL;
+        return FcFalse;
 	
     while ((cache_dir = FcStrListNext (list)))
     {
-        cache_hashed = FcStrPlus (cache_dir, cache_base);
+        FcChar8	*cache_hashed = FcStrPlus (cache_dir, cache_base);
         if (!cache_hashed)
 	    break;
-        file = fopen((char *) cache_hashed, "rb");
-        if (file != NULL) {
-	    if (fstat (fileno (file), &file_stat) >= 0 &&
-		dir_stat.st_mtime <= file_stat.st_mtime)
+        fd = FcDirCacheOpenFile (cache_hashed, &file_stat);
+        if (fd >= 0) {
+	    ret = (*callback) (fd, &file_stat, &dir_stat, closure);
+	    close (fd);
+	    if (ret)
 	    {
+		if (cache_file_ret)
+		    *cache_file_ret = cache_hashed;
+		else
+		    FcStrFree (cache_hashed);
 		break;
 	    }
-	    fclose (file);
-	    file = NULL;
 	}
-	FcStrFree (cache_hashed);
-	cache_hashed = NULL;
+    	FcStrFree (cache_hashed);
     }
     FcStrListDone (list);
+    
+    return ret;
+}
 
-    if (file == NULL)
-	return NULL;
+#define FC_CACHE_MIN_MMAP   1024
+
+/*
+ * Skip list element, make sure the 'next' pointer is the last thing
+ * in the structure, it will be allocated large enough to hold all
+ * of the necessary pointers
+ */
+
+typedef struct _FcCacheSkip FcCacheSkip;
+
+struct _FcCacheSkip {
+    FcCache	    *cache;
+    int		    ref;
+    intptr_t	    size;
+    dev_t	    cache_dev;
+    ino_t	    cache_ino;
+    time_t	    cache_mtime;
+    FcCacheSkip	    *next[1];
+};
+
+/*
+ * The head of the skip list; pointers for every possible level
+ * in the skip list, plus the largest level in the list
+ */
+
+#define FC_CACHE_MAX_LEVEL  16
+
+static FcCacheSkip	*fcCacheChains[FC_CACHE_MAX_LEVEL];
+static int		fcCacheMaxLevel;
+
+#if HAVE_RANDOM
+# define FcRandom()  random()
+#else
+# if HAVE_LRAND48
+#  define FcRandom()  lrand48()
+# else
+#  if HAVE_RAND
+#   define FcRandom()  rand()
+#  endif
+# endif
+#endif
+/*
+ * Generate a random level number, distributed
+ * so that each level is 1/4 as likely as the one before
+ *
+ * Note that level numbers run 1 <= level <= MAX_LEVEL
+ */
+static int
+random_level (void)
+{
+    /* tricky bit -- each bit is '1' 75% of the time */
+    long int	bits = FcRandom () | FcRandom ();
+    int	level = 0;
+
+    while (++level < FC_CACHE_MAX_LEVEL)
+    {
+	if (bits & 1)
+	    break;
+	bits >>= 1;
+    }
+    return level;
+}
+
+/*
+ * Insert cache into the list
+ */
+static FcBool
+FcCacheInsert (FcCache *cache, struct stat *cache_stat)
+{
+    FcCacheSkip    **update[FC_CACHE_MAX_LEVEL];
+    FcCacheSkip    *s, **next;
+    int		    i, level;
+
+    /*
+     * Find links along each chain
+     */
+    next = fcCacheChains;
+    for (i = fcCacheMaxLevel; --i >= 0; )
+    {
+	for (; (s = next[i]); next = s->next)
+	    if (s->cache > cache)
+		break;
+        update[i] = &next[i];
+    }
+
+    /*
+     * Create new list element
+     */
+    level = random_level ();
+    if (level > fcCacheMaxLevel)
+    {
+	level = fcCacheMaxLevel + 1;
+	update[fcCacheMaxLevel] = &fcCacheChains[fcCacheMaxLevel];
+	fcCacheMaxLevel = level;
+    }
     
-    if (cache_path)
-	*cache_path = cache_hashed;
+    s = malloc (sizeof (FcCacheSkip) + (level - 1) * sizeof (FcCacheSkip *));
+    if (!s)
+	return FcFalse;
+
+    s->cache = cache;
+    s->size = cache->size;
+    s->ref = 1;
+    if (cache_stat)
+    {
+	s->cache_dev = cache_stat->st_dev;
+	s->cache_ino = cache_stat->st_ino;
+	s->cache_mtime = cache_stat->st_mtime;
+    }
     else
-	FcStrFree (cache_hashed);
+    {
+	s->cache_dev = 0;
+	s->cache_ino = 0;
+	s->cache_mtime = 0;
+    }
+    
+    /*
+     * Insert into all fcCacheChains
+     */
+    for (i = 0; i < level; i++)
+    {
+	s->next[i] = *update[i];
+	*update[i] = s;
+    }
+    return FcTrue;
+}
 
-    return file;
+static FcCacheSkip *
+FcCacheFindByAddr (void *object)
+{
+    int	    i;
+    FcCacheSkip    **next = fcCacheChains;
+    FcCacheSkip    *s;
+
+    /*
+     * Walk chain pointers one level at a time
+     */
+    for (i = fcCacheMaxLevel; --i >= 0;)
+	while (next[i] && (char *) object >= ((char *) next[i]->cache + next[i]->size))
+	    next = next[i]->next;
+    /*
+     * Here we are
+     */
+    s = next[0];
+    if (s && (char *) object < ((char *) s->cache + s->size))
+	return s;
+    return NULL;
 }
 
-/* read serialized state from the cache file */
-FcBool
-FcDirCacheRead (FcFontSet * set, FcStrSet * dirs, 
-		const FcChar8 *dir, FcConfig *config)
+static void
+FcCacheRemove (FcCache *cache)
 {
-    FILE	*file;
-    FcCache	metadata;
-    void	*current_dir_block;
-    char	subdir_name[FC_MAX_FILE_LEN + 1 + 12 + 1];
+    FcCacheSkip	    **update[FC_CACHE_MAX_LEVEL];
+    FcCacheSkip	    *s, **next;
+    int		    i;
 
-    file = FcDirCacheOpen (config, dir, NULL);
-    if (file == NULL)
-	goto bail;
+    /*
+     * Find links along each chain
+     */
+    next = fcCacheChains;
+    for (i = fcCacheMaxLevel; --i >= 0; )
+    {
+	for (; (s = next[i]); next = s->next)
+	    if (s->cache >= cache)
+		break;
+        update[i] = &next[i];
+    }
+    s = next[0];
+    for (i = 0; i < fcCacheMaxLevel && *update[i] == s; i++)
+	*update[i] = s->next[i];
+    while (fcCacheMaxLevel > 0 && fcCacheChains[fcCacheMaxLevel - 1] == NULL)
+	fcCacheMaxLevel--;
+    free (s);
+}
 
-    if (fread(&metadata, sizeof(FcCache), 1, file) != 1)
-	goto bail1;
-    if (metadata.magic != FC_CACHE_MAGIC)
-        goto bail1;
+static FcCache *
+FcCacheFindByStat (struct stat *cache_stat)
+{
+    FcCacheSkip	    *s;
+
+    for (s = fcCacheChains[0]; s; s = s->next[0])
+	if (s->cache_dev == cache_stat->st_dev &&
+	    s->cache_ino == cache_stat->st_ino &&
+	    s->cache_mtime == cache_stat->st_mtime)
+	{
+	    s->ref++;
+	    return s->cache;
+	}
+    return NULL;
+}
 
-    while (FcCacheReadString (file, subdir_name, sizeof (subdir_name)) && 
-	   strlen (subdir_name) > 0)
-        FcStrSetAdd (dirs, (FcChar8 *)subdir_name);
+static void
+FcDirCacheDispose (FcCache *cache)
+{
+    switch (cache->magic) {
+    case FC_CACHE_MAGIC_ALLOC:
+	free (cache);
+	break;
+    case FC_CACHE_MAGIC_MMAP:
+#if defined(HAVE_MMAP) || defined(__CYGWIN__)
+	munmap (cache, cache->size);
+#elif defined(_WIN32)
+	UnmapViewOfFile (cache);
+#endif
+	break;
+    }
+    FcCacheRemove (cache);
+}
+
+void
+FcCacheObjectReference (void *object)
+{
+    FcCacheSkip *skip = FcCacheFindByAddr (object);
 
-    if (metadata.count)
+    if (skip)
+	skip->ref++;
+}
+
+void
+FcCacheObjectDereference (void *object)
+{
+    FcCacheSkip	*skip = FcCacheFindByAddr (object);
+
+    if (skip)
+    {
+	skip->ref--;
+	if (skip->ref <= 0)
+	    FcDirCacheDispose (skip->cache);
+    }
+}
+
+void
+FcCacheFini (void)
+{
+    int		    i;
+
+    for (i = 0; i < FC_CACHE_MAX_LEVEL; i++)
+	assert (fcCacheChains[i] == NULL);
+    assert (fcCacheMaxLevel == 0);
+}
+
+static FcBool
+FcCacheTimeValid (FcCache *cache, struct stat *dir_stat)
+{
+    struct stat	dir_static;
+
+    if (!dir_stat)
+    {
+	if (stat ((const char *) FcCacheDir (cache), &dir_static) < 0)
+	    return FcFalse;
+	dir_stat = &dir_static;
+    }
+    if (FcDebug () & FC_DBG_CACHE)
+	printf ("FcCacheTimeValid dir \"%s\" cache time %d dir time %d\n",
+		FcCacheDir (cache), cache->mtime, (int) dir_stat->st_mtime);
+    return cache->mtime == (int) dir_stat->st_mtime;
+}
+
+/*
+ * Map a cache file into memory
+ */
+static FcCache *
+FcDirCacheMapFd (int fd, struct stat *fd_stat, struct stat *dir_stat)
+{
+    FcCache	*cache;
+    FcBool	allocated = FcFalse;
+
+    if (fd_stat->st_size < sizeof (FcCache))
+	return NULL;
+    cache = FcCacheFindByStat (fd_stat);
+    if (cache)
+	return cache;
+    /*
+     * Lage cache files are mmap'ed, smaller cache files are read. This
+     * balances the system cost of mmap against per-process memory usage.
+     */
+    if (fd_stat->st_size >= FC_CACHE_MIN_MMAP)
     {
-	int	fd = fileno (file);
 #if defined(HAVE_MMAP) || defined(__CYGWIN__)
-	current_dir_block = mmap (0, metadata.count, 
-				  PROT_READ, MAP_SHARED, fd, metadata.pos);
-	if (current_dir_block == MAP_FAILED)
-	    goto bail1;
+	cache = mmap (0, fd_stat->st_size, PROT_READ, MAP_SHARED, fd, 0);
 #elif defined(_WIN32)
 	{
 	    HANDLE hFileMap;
 
-	    hFileMap = CreateFileMapping((HANDLE) _get_osfhandle(fd), NULL, PAGE_READONLY, 0, 0, NULL);
-	    if (hFileMap == NULL)
-		goto bail1;
-
-	    current_dir_block = MapViewOfFile (hFileMap, FILE_MAP_READ, 0, metadata.pos, metadata.count);
-	    if (current_dir_block == NULL)
+	    cache = NULL;
+	    hFileMap = CreateFileMapping((HANDLE) _get_osfhandle(fd), NULL,
+					 PAGE_READONLY, 0, 0, NULL);
+	    if (hFileMap != NULL)
 	    {
+		cache = MapViewOfFile (hFileMap, FILE_MAP_READ, 0, 0, 
+				       fd_stat->st_size);
 		CloseHandle (hFileMap);
-		goto bail1;
 	    }
 	}
-#else
-	if (lseek (fd, metatdata.pos, SEEK_SET) == -1)
-	    goto bail1;
-
-	current_dir_block = malloc (metadata.count);
-	if (!current_dir_block)
-	    goto bail1;
+#endif
+    }
+    if (!cache)
+    {
+	cache = malloc (fd_stat->st_size);
+	if (!cache)
+	    return NULL;
 
-	/* could also use CreateMappedViewOfFile under MinGW... */
-	if (read (fd, current_dir_block, metadata.count) != metadata.count)
+	if (read (fd, cache, fd_stat->st_size) != fd_stat->st_size)
 	{
-	    free (current_dir_block);
-	    goto bail1;
+	    free (cache);
+	    return NULL;
 	}
+	allocated = FcTrue;
+    } 
+    if (cache->magic != FC_CACHE_MAGIC_MMAP || 
+	cache->version < FC_CACHE_CONTENT_VERSION ||
+	cache->size != fd_stat->st_size ||
+	!FcCacheTimeValid (cache, dir_stat) ||
+	!FcCacheInsert (cache, fd_stat))
+    {
+	if (allocated)
+	    free (cache);
+	else
+	{
+#if defined(HAVE_MMAP) || defined(__CYGWIN__)
+	    munmap (cache, fd_stat->st_size);
+#elif defined(_WIN32)
+	    UnmapViewOfFile (cache);
 #endif
-	FcCacheAddBankDir (metadata.bank, (char *) dir);
-	if (!FcFontSetUnserialize (&metadata, set, current_dir_block))
-	    goto bail1;
+	}
+	return NULL;
     }
-    if (config)
-	FcConfigAddFontDir (config, (FcChar8 *)dir);
 
-    fclose(file);
+    /* Mark allocated caches so they're freed rather than unmapped */
+    if (allocated)
+	cache->magic = FC_CACHE_MAGIC_ALLOC;
+	
+    return cache;
+}
+
+void
+FcDirCacheReference (FcCache *cache, int nref)
+{
+    FcCacheSkip *skip = FcCacheFindByAddr (cache);
+
+    if (skip)
+	skip->ref += nref;
+}
+
+void
+FcDirCacheUnload (FcCache *cache)
+{
+    FcCacheObjectDereference (cache);
+}
+
+static FcBool
+FcDirCacheMapHelper (int fd, struct stat *fd_stat, struct stat *dir_stat, void *closure)
+{
+    FcCache *cache = FcDirCacheMapFd (fd, fd_stat, dir_stat);
+
+    if (!cache)
+	return FcFalse;
+    *((FcCache **) closure) = cache;
     return FcTrue;
+}
 
- bail1:
-    fclose (file);
- bail:
-    return FcFalse;
+FcCache *
+FcDirCacheLoad (const FcChar8 *dir, FcConfig *config, FcChar8 **cache_file)
+{
+    FcCache *cache = NULL;
+
+    if (!FcDirCacheProcess (config, dir,
+			    FcDirCacheMapHelper,
+			    &cache, cache_file))
+	return NULL;
+    return cache;
 }
 
-static void *
-FcDirCacheProduce (FcFontSet *set, FcCache *metadata)
+FcCache *
+FcDirCacheLoadFile (const FcChar8 *cache_file, struct stat *file_stat)
 {
-    void * current_dir_block, * final_dir_block;
-    static unsigned int rand_state = 0;
-    int bank, needed_bytes_no_align;
+    int	fd;
+    FcCache *cache;
 
-#if defined (HAVE_RAND_R)
-    if (!rand_state) 
-	rand_state = time(0L);
-    bank = rand_r(&rand_state);
+    fd = FcDirCacheOpenFile (cache_file, file_stat);
+    if (fd < 0)
+	return NULL;
+    cache = FcDirCacheMapFd (fd, file_stat, NULL);
+    close (fd);
+    return cache;
+}
 
-    while (FcCacheHaveBank(bank))
-	bank = rand_r(&rand_state);
-#else
-    if (!rand_state)
-    {
-        rand_state = 1;
-        srand (time (0L));
-    }
-    bank = rand();
+/*
+ * Validate a cache file by reading the header and checking
+ * the magic number and the size field
+ */
+static FcBool
+FcDirCacheValidateHelper (int fd, struct stat *fd_stat, struct stat *dir_stat, void *closure)
+{
+    FcBool  ret = FcTrue;
+    FcCache	c;
+    
+    if (read (fd, &c, sizeof (FcCache)) != sizeof (FcCache))
+	ret = FcFalse;
+    else if (c.magic != FC_CACHE_MAGIC_MMAP)
+	ret = FcFalse;
+    else if (c.version < FC_CACHE_CONTENT_VERSION)
+	ret = FcFalse;
+    else if (fd_stat->st_size != c.size)
+	ret = FcFalse;
+    else if (c.mtime != (int) dir_stat->st_mtime)
+	ret = FcFalse;
+    return ret;
+}
 
-    while (FcCacheHaveBank(bank))
-        bank = rand();
-#endif
+static FcBool
+FcDirCacheValidConfig (const FcChar8 *dir, FcConfig *config)
+{
+    return FcDirCacheProcess (config, dir, 
+			      FcDirCacheValidateHelper,
+			      NULL, NULL);
+}
 
-    memset (metadata, 0, sizeof(FcCache));
-    FcFontSetNewBank();
-    needed_bytes_no_align = FcFontSetNeededBytes (set);
-    metadata->count = needed_bytes_no_align + 
-	FcFontSetNeededBytesAlign ();
-    metadata->magic = FC_CACHE_MAGIC;
-    metadata->bank = bank;
+FcBool
+FcDirCacheValid (const FcChar8 *dir)
+{
+    FcConfig	*config;
+    
+    config = FcConfigGetCurrent ();
+    if (!config)
+        return FcFalse;
 
-    if (!needed_bytes_no_align) /* not a failure, no fonts to write */
-    {
-	/* no, you don't really need to write any bytes at all. */
-	metadata->count = 0;
-	return 0;
-    }
+    return FcDirCacheValidConfig (dir, config);
+}
 
-    current_dir_block = malloc (metadata->count);
-    if (!current_dir_block)
-	goto bail;
+/*
+ * Build a cache structure from the given contents
+ */
+FcCache *
+FcDirCacheBuild (FcFontSet *set, const FcChar8 *dir, struct stat *dir_stat, FcStrSet *dirs)
+{
+    FcSerialize	*serialize = FcSerializeCreate ();
+    FcCache *cache;
+    int i;
+    intptr_t	cache_offset;
+    intptr_t	dirs_offset;
+    FcChar8	*dir_serialize;
+    intptr_t	*dirs_serialize;
+    FcFontSet	*set_serialize;
+    
+    if (!serialize)
+	return NULL;
+    /*
+     * Space for cache structure
+     */
+    cache_offset = FcSerializeReserve (serialize, sizeof (FcCache));
+    /*
+     * Directory name
+     */
+    if (!FcStrSerializeAlloc (serialize, dir))
+	goto bail1;
+    /*
+     * Subdirs
+     */
+    dirs_offset = FcSerializeAlloc (serialize, dirs, dirs->num * sizeof (FcChar8 *));
+    for (i = 0; i < dirs->num; i++)
+	if (!FcStrSerializeAlloc (serialize, dirs->strs[i]))
+	    goto bail1;
+
+    /*
+     * Patterns
+     */
+    if (!FcFontSetSerializeAlloc (serialize, set))
+	goto bail1;
+    
+    /* Serialize layout complete. Now allocate space and fill it */
+    cache = malloc (serialize->size);
+    if (!cache)
+	goto bail1;
     /* shut up valgrind */
-    memset (current_dir_block, 0, metadata->count);
-    final_dir_block = FcFontSetDistributeBytes (metadata, current_dir_block);
+    memset (cache, 0, serialize->size);
+
+    serialize->linear = cache;
+
+    cache->magic = FC_CACHE_MAGIC_ALLOC;
+    cache->version = FC_CACHE_CONTENT_VERSION;
+    cache->size = serialize->size;
+    cache->mtime = (int) dir_stat->st_mtime;
 
-    if ((void *)((char *)current_dir_block+metadata->count) < final_dir_block)
-	goto bail;
-			      
-    if (!FcFontSetSerialize (bank, set))
-	goto bail;
+    /*
+     * Serialize directory name
+     */
+    dir_serialize = FcStrSerialize (serialize, dir);
+    if (!dir_serialize)
+	goto bail2;
+    cache->dir = FcPtrToOffset (cache, dir_serialize);
+    
+    /*
+     * Serialize sub dirs
+     */
+    dirs_serialize = FcSerializePtr (serialize, dirs);
+    if (!dirs_serialize)
+	goto bail2;
+    cache->dirs = FcPtrToOffset (cache, dirs_serialize);
+    cache->dirs_count = dirs->num;
+    for (i = 0; i < dirs->num; i++) 
+    {
+	FcChar8	*d_serialize = FcStrSerialize (serialize, dirs->strs[i]);
+	if (!d_serialize)
+	    goto bail2;
+	dirs_serialize[i] = FcPtrToOffset (dirs_serialize, d_serialize);
+    }
+    
+    /*
+     * Serialize font set
+     */
+    set_serialize = FcFontSetSerialize (serialize, set);
+    if (!set_serialize)
+	goto bail2;
+    cache->set = FcPtrToOffset (cache, set_serialize);
 
-    return current_dir_block;
+    FcSerializeDestroy (serialize);
+    
+    FcCacheInsert (cache, NULL);
 
- bail:
-    free (current_dir_block);
-    return 0;
+    return cache;
+
+bail2:
+    free (cache);
+bail1:
+    FcSerializeDestroy (serialize);
+    return NULL;
 }
 
+
+#ifdef _WIN32
+#define mkdir(path,mode) _mkdir(path)
+#endif
+
 static FcBool
 FcMakeDirectory (const FcChar8 *dir)
 {
@@ -482,7 +727,7 @@ FcMakeDirectory (const FcChar8 *dir)
     parent = FcStrDirname (dir);
     if (!parent)
 	return FcFalse;
-    if (access ((char *) parent, W_OK|X_OK) == 0)
+    if (access ((char *) parent, F_OK) == 0)
 	ret = mkdir ((char *) dir, 0777) == 0;
     else if (access ((char *) parent, F_OK) == -1)
 	ret = FcMakeDirectory (parent) && (mkdir ((char *) dir, 0777) == 0);
@@ -494,18 +739,18 @@ FcMakeDirectory (const FcChar8 *dir)
 
 /* write serialized state to the cache file */
 FcBool
-FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir, FcConfig *config)
+FcDirCacheWrite (FcCache *cache, FcConfig *config)
 {
+    FcChar8	    *dir = FcCacheDir (cache);
     FcChar8	    cache_base[CACHEBASE_LEN];
     FcChar8	    *cache_hashed;
-    int 	    fd, i;
+    int 	    fd;
     FcAtomic 	    *atomic;
-    FcCache 	    metadata;
-    void 	    *current_dir_block = 0;
     FcStrList	    *list;
     FcChar8	    *cache_dir = NULL;
     FcChar8	    *test_dir;
-    off_t	    header_len;
+    int		    magic;
+    int		    written;
 
     /*
      * Write it to the first directory in the list which is writable
@@ -515,7 +760,7 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir, FcConfig *c
     if (!list)
 	return FcFalse;
     while ((test_dir = FcStrListNext (list))) {
-	if (access ((char *) test_dir, W_OK|X_OK) == 0)
+	if (access ((char *) test_dir, W_OK) == 0)
 	{
 	    cache_dir = test_dir;
 	    break;
@@ -537,16 +782,12 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir, FcConfig *c
     FcStrListDone (list);
     if (!cache_dir)
 	return FcFalse;
+
     FcDirCacheBasename (dir, cache_base);
     cache_hashed = FcStrPlus (cache_dir, cache_base);
     if (!cache_hashed)
         return FcFalse;
 
-    current_dir_block = FcDirCacheProduce (set, &metadata);
-
-    if (metadata.count && !current_dir_block)
-	goto bail1;
-
     if (FcDebug () & FC_DBG_CACHE)
         printf ("FcDirCacheWriteDir dir \"%s\" file \"%s\"\n",
 		dir, cache_hashed);
@@ -556,146 +797,103 @@ FcDirCacheWrite (FcFontSet *set, FcStrSet *dirs, const FcChar8 *dir, FcConfig *c
 	goto bail1;
 
     if (!FcAtomicLock (atomic))
-	goto bail2;
+	goto bail3;
 
     fd = open((char *)FcAtomicNewFile (atomic), O_RDWR | O_CREAT | O_BINARY, 0666);
     if (fd == -1)
-	goto bail3;
+	goto bail4;
+    
+    /* Temporarily switch magic to MMAP while writing to file */
+    magic = cache->magic;
+    if (magic != FC_CACHE_MAGIC_MMAP)
+	cache->magic = FC_CACHE_MAGIC_MMAP;
     
     /*
-     * Compute file header length -- the FcCache followed by the subdir names
+     * Write cache contents to file
      */
-    header_len = sizeof (FcCache);
-    for (i = 0; i < dirs->size; i++)
-	header_len += strlen ((char *)dirs->strs[i]) + 1;
+    written = write (fd, cache, cache->size);
     
-    metadata.pos = FcCacheNextOffset (lseek (fd, 0, SEEK_CUR) + header_len);
-    metadata.subdirs = dirs->size;
+    /* Switch magic back */
+    if (magic != FC_CACHE_MAGIC_MMAP)
+	cache->magic = magic;
     
-    /*
-     * Write out the header
-     */
-    if (write (fd, &metadata, sizeof(FcCache)) != sizeof(FcCache)) 
+    if (written != cache->size)
     {
-	perror("write metadata");
+	perror ("write cache");
 	goto bail5;
     }
-    
-    for (i = 0; i < dirs->size; i++)
-        FcCacheWriteString (fd, (char *)dirs->strs[i]);
-
-    if (metadata.count)
-    {
-	if (lseek (fd, metadata.pos, SEEK_SET) != metadata.pos)
-	    perror("lseek");
-	else if (write (fd, current_dir_block, metadata.count) !=
-		 metadata.count)
-	    perror("write current_dir_block");
-	free (current_dir_block);
-        current_dir_block = 0;
-    }
 
     close(fd);
     if (!FcAtomicReplaceOrig(atomic))
-        goto bail3;
-    FcStrFree ((FcChar8 *)cache_hashed);
+        goto bail4;
+    FcStrFree (cache_hashed);
     FcAtomicUnlock (atomic);
     FcAtomicDestroy (atomic);
     return FcTrue;
 
  bail5:
     close (fd);
- bail3:
+ bail4:
     FcAtomicUnlock (atomic);
- bail2:
+ bail3:
     FcAtomicDestroy (atomic);
  bail1:
-    FcStrFree ((FcChar8 *)cache_hashed);
-    if (current_dir_block)
-        free (current_dir_block);
+    FcStrFree (cache_hashed);
     return FcFalse;
 }
 
-static int banks_ptr = 0, banks_alloc = 0;
-int * _fcBankId = 0, * _fcBankIdx = 0;
-static const char ** bankDirs = 0;
+/*
+ * Hokey little macro trick to permit the definitions of C functions
+ * with the same name as CPP macros
+ */
+#define args1(x)	    (x)
+#define args2(x,y)	    (x,y)
 
-static FcBool
-FcCacheHaveBank (int bank)
+const FcChar8 *
+FcCacheDir args1(const FcCache *c)
 {
-    int i;
-
-    if (bank < FC_BANK_FIRST)
-	return FcTrue;
-
-    for (i = 0; i < banks_ptr; i++)
-	if (_fcBankId[i] == bank)
-	    return FcTrue;
-
-    return FcFalse;
+    return FcCacheDir (c);
 }
 
-int
-FcCacheBankToIndexMTF (int bank)
+FcFontSet *
+FcCacheCopySet args1(const FcCache *c)
 {
-    int i, j;
-
-    for (i = 0; i < banks_ptr; i++)
-	if (_fcBankId[_fcBankIdx[i]] == bank)
+    FcFontSet	*old = FcCacheSet (c);
+    FcFontSet	*new = FcFontSetCreate ();
+    int		i;
+    
+    if (!new)
+	return NULL;
+    for (i = 0; i < old->nfont; i++)
+    {
+	FcPattern   *font = FcFontSetFont (old, i);
+	
+	FcPatternReference (font);
+	if (!FcFontSetAdd (new, font))
 	{
-	    int t = _fcBankIdx[i];
-
-	    for (j = i; j > 0; j--)
-		_fcBankIdx[j] = _fcBankIdx[j-1];
-	    _fcBankIdx[0] = t;
-	    return t;
+	    FcFontSetDestroy (new);
+	    return NULL;
 	}
-
-    if (banks_ptr >= banks_alloc)
-    {
-	int * b, * bidx;
-	const char ** bds;
-
-	b = realloc (_fcBankId, (banks_alloc + 4) * sizeof(int));
-	if (!b)
-	    return -1;
-	_fcBankId = b;
-
-	bidx = realloc (_fcBankIdx, (banks_alloc + 4) * sizeof(int));
-	if (!bidx)
-	    return -1;
-	_fcBankIdx = bidx;
-
-	bds = realloc (bankDirs, (banks_alloc + 4) * sizeof (char *));
-	if (!bds)
-	    return -1;
-	bankDirs = bds;
-
-	banks_alloc += 4;
     }
-
-    i = banks_ptr++;
-    _fcBankId[i] = bank;
-    _fcBankIdx[i] = i;
-    return i;
+    return new;
 }
 
-static void
-FcCacheAddBankDir (int bank, const char * dir)
+const FcChar8 *
+FcCacheSubdir args2(const FcCache *c, int i)
 {
-    int bi = FcCacheBankToIndexMTF (bank);
-
-    if (bi < 0)
-	return;
+    return FcCacheSubdir (c, i);
+}
 
-    bankDirs[bi] = (const char *)FcStrCopy ((FcChar8 *)dir);
+int
+FcCacheNumSubdir args1(const FcCache *c)
+{
+    return c->dirs_count;
 }
 
-const char *
-FcCacheFindBankDir (int bank)
+int
+FcCacheNumFont args1(const FcCache *c)
 {
-    int bi = FcCacheBankToIndex (bank);
-    return bankDirs[bi];
+    return FcCacheSet(c)->nfont;
 }
 
 /*
@@ -752,7 +950,7 @@ static void MD5Init(struct MD5Context *ctx)
  * Update context to reflect the concatenation of another buffer full
  * of bytes.
  */
-static void MD5Update(struct MD5Context *ctx, unsigned char *buf, unsigned len)
+static void MD5Update(struct MD5Context *ctx, const unsigned char *buf, unsigned len)
 {
     FcChar32 t;
 
@@ -941,3 +1139,6 @@ static void MD5Transform(FcChar32 buf[4], FcChar32 in[16])
     buf[2] += c;
     buf[3] += d;
 }
+#define __fccache__
+#include "fcaliastail.h"
+#undef __fccache__