ROX-Filer/src/fscache.c

   1 /*
   2  * $Id$
   3  *
   4  * FSCache - a glib-style object for caching files
   5  * Copyright (C) 2001, the ROX-Filer team.
   6  *
   7  * A cache object holds stat details about files in a hash table, along
   8  * with user-specified data. When you want to read in a file try to
   9  * get the data via the cache - if the file is cached AND has not been
  10  * modified since it was last loaded the cached copy is returned, else the
  11  * file is reloaded.
  12  *
  13  * The actual data need not be the raw file contents - a user specified
  14  * function loads the file and associates data with the file in the cache.
  15  *
  16  * This program is free software; you can redistribute it and/or modify it
  17  * under the terms of the GNU General Public License as published by the Free
  18  * Software Foundation; either version 2 of the License, or (at your option)
  19  * any later version.
  20  *
  21  * This program is distributed in the hope that it will be useful, but WITHOUT
  22  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  23  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  24  * more details.
  25  *
  26  * You should have received a copy of the GNU General Public License along with
  27  * this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  28  * Place, Suite 330, Boston, MA  02111-1307  USA
  29  */
  30
  31 #include "config.h"
  32
  33 #include "fscache.h"
  34
  35 #define UPTODATE(data, info)                            \
  36                 (data->m_time == info.st_mtime          \
  37                  && data->length == info.st_size        \
  38                  && data->mode == info.st_mode)         \
  39
  40
  41 /* Static prototypes */
  42
  43 static guint hash_key(gconstpointer key);
  44 static gint cmp_stats(gconstpointer a, gconstpointer b);
  45 static void destroy_hash_entry(gpointer key, gpointer data, gpointer user_data);
  46 static gboolean purge_hash_entry(gpointer key, gpointer data,
  47                                  gpointer user_data);
  48
  49
  50 struct PurgeInfo
  51 {
  52         GFSCache *cache;
  53         gint     age;
  54         time_t   now;
  55 };
  56
  57 /****************************************************************
  58  *                      EXTERNAL INTERFACE                      *
  59  ****************************************************************/
  60
  61
  62 /* Create a new GFSCache object and return a pointer to it.
  63  *
  64  * When someone tries to lookup a file which is not in the cache,
  65  * load() is called.
  66  * It should load the file and return a pointer to an object for the file.
  67  * The object should have a ref count of 1.
  68  *
  69  * ref() and unref() should modify the reference counter of the object.
  70  * When the counter reaches zero, destroy the object.
  71  *
  72  * getref() returns the current value. This can be used to stop objects
  73  * being purged from the cache while they are being used elsewhere, which
  74  * is rather wasteful. If NULL then this check isn't done.
  75  *
  76  * update() will be called to update an object which is cached, but
  77  * out of date. If NULL, the object will be unref'd and load() used
  78  * to make a new one.
  79  *
  80  * 'user_data' will be passed to all of the above functions.
  81  */
  82 GFSCache *g_fscache_new(GFSLoadFunc load,
  83                         GFSRefFunc ref,
  84                         GFSRefFunc unref,
  85                         GFSGetRefFunc getref,
  86                         GFSUpdateFunc update,
  87                         gpointer user_data)
  88 {
  89         GFSCache *cache;
  90
  91         cache = g_new(GFSCache, 1);
  92         cache->inode_to_stats = g_hash_table_new(hash_key, cmp_stats);
  93         cache->load = load;
  94         cache->ref = ref;
  95         cache->unref = unref;
  96         cache->getref = getref;
  97         cache->update = update;
  98         cache->user_data = user_data;
  99
 100         return cache;
 101 }
 102
 103 void g_fscache_destroy(GFSCache *cache)
 104 {
 105         g_return_if_fail(cache != NULL);
 106
 107         g_hash_table_foreach(cache->inode_to_stats, destroy_hash_entry, cache);
 108         g_hash_table_destroy(cache->inode_to_stats);
 109
 110         g_free(cache);
 111 }
 112
 113 /* Call the ref() user function for this object */
 114 void g_fscache_data_ref(GFSCache *cache, gpointer data)
 115 {
 116         g_return_if_fail(cache != NULL);
 117
 118         if (cache->ref)
 119                 cache->ref(data, cache->user_data);
 120 }
 121
 122 /* Call the unref() user function for this object */
 123 void g_fscache_data_unref(GFSCache *cache, gpointer data)
 124 {
 125         g_return_if_fail(cache != NULL);
 126
 127         if (cache->unref)
 128                 cache->unref(data, cache->user_data);
 129 }
 130
 131 /* Find the data for this file in the cache, loading it into
 132  * the cache if it isn't there already.
 133  *
 134  * Remember to g_fscache_data_unref() the returned value when
 135  * you're done with it.
 136  *
 137  * Returns NULL on failure.
 138  */
 139 gpointer g_fscache_lookup(GFSCache *cache, char *pathname)
 140 {
 141         return g_fscache_lookup_full(cache, pathname, FSCACHE_LOOKUP_CREATE);
 142 }
 143
 144 /* As g_fscache_lookup, but 'load' flags control what happens if the data
 145  * is out-of-date.
 146  * TRUE => Data is updated / reloaded
 147  * FALSE => Returns NULL
 148  */
 149 gpointer g_fscache_lookup_full(GFSCache *cache, char *pathname,
 150                                 FSCacheLookup lookup_type)
 151 {
 152         struct stat     info;
 153         GFSCacheKey     key;
 154         GFSCacheData    *data;
 155
 156         g_return_val_if_fail(cache != NULL, NULL);
 157         g_return_val_if_fail(pathname != NULL, NULL);
 158
 159         if (mc_stat(pathname, &info))
 160                 return NULL;
 161
 162         key.device = info.st_dev;
 163         key.inode = info.st_ino;
 164
 165         data = g_hash_table_lookup(cache->inode_to_stats, &key);
 166
 167         if (data)
 168         {
 169                 /* We've cached this file already */
 170
 171                 if (lookup_type == FSCACHE_LOOKUP_PEEK)
 172                         goto out;       /* Never update on peeks */
 173
 174                 /* Is it up-to-date? */
 175
 176                 if (UPTODATE(data, info))
 177                         goto out;
 178
 179                 if (lookup_type == FSCACHE_LOOKUP_ONLY_NEW)
 180                         return NULL;
 181
 182                 /* Out-of-date */
 183                 if (cache->update)
 184                         cache->update(data->data, pathname, cache->user_data);
 185                 else
 186                 {
 187                         if (cache->unref)
 188                                 cache->unref(data->data, cache->user_data);
 189                         data->data = NULL;
 190                 }
 191         }
 192         else
 193         {
 194                 GFSCacheKey *new_key;
 195
 196                 if (lookup_type != FSCACHE_LOOKUP_CREATE)
 197                         return NULL;
 198
 199                 new_key = g_memdup(&key, sizeof(key));
 200
 201                 data = g_new(GFSCacheData, 1);
 202                 data->data = NULL;
 203
 204                 g_hash_table_insert(cache->inode_to_stats, new_key, data);
 205         }
 206
 207         data->m_time = info.st_mtime;
 208         data->length = info.st_size;
 209         data->mode = info.st_mode;
 210
 211         if (data->data == NULL)
 212         {
 213                 /* Create the object for the file (ie, not an update) */
 214                 if (cache->load)
 215                         data->data = cache->load(pathname, cache->user_data);
 216         }
 217 out:
 218         if (cache->ref)
 219                 cache->ref(data->data, cache->user_data);
 220         data->last_lookup = time(NULL);
 221         return data->data;
 222 }
 223
 224 /* Call the update() function on this item if it's in the cache
 225  * AND it's out-of-date.
 226  */
 227 void g_fscache_may_update(GFSCache *cache, char *pathname)
 228 {
 229         GFSCacheKey     key;
 230         GFSCacheData    *data;
 231         struct stat     info;
 232
 233         g_return_if_fail(cache != NULL);
 234         g_return_if_fail(pathname != NULL);
 235         g_return_if_fail(cache->update != NULL);
 236
 237         if (mc_stat(pathname, &info))
 238                 return;
 239
 240         key.device = info.st_dev;
 241         key.inode = info.st_ino;
 242
 243         data = g_hash_table_lookup(cache->inode_to_stats, &key);
 244
 245         if (data && !UPTODATE(data, info))
 246         {
 247                 cache->update(data->data, pathname, cache->user_data);
 248                 data->m_time = info.st_mtime;
 249                 data->length = info.st_size;
 250                 data->mode = info.st_mode;
 251         }
 252 }
 253
 254 /* Call the update() function on this item iff it's in the cache. */
 255 void g_fscache_update(GFSCache *cache, char *pathname)
 256 {
 257         GFSCacheKey     key;
 258         GFSCacheData    *data;
 259         struct stat     info;
 260
 261         g_return_if_fail(cache != NULL);
 262         g_return_if_fail(pathname != NULL);
 263         g_return_if_fail(cache->update != NULL);
 264
 265         if (mc_stat(pathname, &info))
 266                 return;
 267
 268         key.device = info.st_dev;
 269         key.inode = info.st_ino;
 270
 271         data = g_hash_table_lookup(cache->inode_to_stats, &key);
 272
 273         if (data)
 274         {
 275                 cache->update(data->data, pathname, cache->user_data);
 276                 data->m_time = info.st_mtime;
 277                 data->length = info.st_size;
 278                 data->mode = info.st_mode;
 279         }
 280 }
 281
 282 /* Remove all cache entries last accessed more than 'age' seconds
 283  * ago.
 284  */
 285 void g_fscache_purge(GFSCache *cache, gint age)
 286 {
 287         struct PurgeInfo info;
 288
 289         g_return_if_fail(cache != NULL);
 290
 291         info.age = age;
 292         info.cache = cache;
 293         info.now = time(NULL);
 294
 295         g_hash_table_foreach_remove(cache->inode_to_stats, purge_hash_entry,
 296                         (gpointer) &info);
 297 }
 298
 299
 300 /****************************************************************
 301  *                      INTERNAL FUNCTIONS                      *
 302  ****************************************************************/
 303
 304
 305 /* Generate a hash number for some stats */
 306 static guint hash_key(gconstpointer key)
 307 {
 308         GFSCacheKey *stats = (GFSCacheKey *) key;
 309
 310         return stats->inode;
 311 }
 312
 313 /* See if two stats blocks represent the same file */
 314 static gint cmp_stats(gconstpointer a, gconstpointer b)
 315 {
 316         GFSCacheKey *c = (GFSCacheKey *) a;
 317         GFSCacheKey *d = (GFSCacheKey *) b;
 318
 319         return c->device == d->device && c->inode == d->inode;
 320 }
 321
 322 static void destroy_hash_entry(gpointer key, gpointer data, gpointer user_data)
 323 {
 324         GFSCache *cache = (GFSCache *) user_data;
 325         GFSCacheData *cache_data = (GFSCacheData *) data;
 326
 327         if (cache->unref)
 328                 cache->unref(cache_data->data, cache->user_data);
 329
 330         g_free(key);
 331         g_free(data);
 332 }
 333
 334 static gboolean purge_hash_entry(gpointer key, gpointer data,
 335                                  gpointer user_data)
 336 {
 337         struct PurgeInfo *info = (struct PurgeInfo *) user_data;
 338         GFSCacheData *cache_data = (GFSCacheData *) data;
 339         GFSCache *cache = info->cache;
 340
 341         /* It's wasteful to remove an entry if someone else is using it */
 342         if (cache->getref &&
 343                 cache->getref(cache_data->data, cache->user_data) > 1)
 344                 return FALSE;
 345
 346         if (cache_data->last_lookup <= info->now
 347                 && cache_data->last_lookup >= info->now - info->age)
 348                 return FALSE;
 349
 350         if (cache->unref)
 351                 cache->unref(cache_data->data, cache->user_data);
 352
 353         g_free(key);
 354         g_free(data);
 355
 356         return TRUE;
 357 }