Btrfs: disable snapshot aware defrag for now
[linux-3.10.git] / fs / mbcache.c
index eb31b73..8c32ef3 100644 (file)
@@ -76,21 +76,6 @@ EXPORT_SYMBOL(mb_cache_entry_find_first);
 EXPORT_SYMBOL(mb_cache_entry_find_next);
 #endif
 
-struct mb_cache {
-       struct list_head                c_cache_list;
-       const char                      *c_name;
-       struct mb_cache_op              c_op;
-       atomic_t                        c_entry_count;
-       int                             c_bucket_bits;
-#ifndef MB_CACHE_INDEXES_COUNT
-       int                             c_indexes_count;
-#endif
-       struct kmem_cache                       *c_entry_cache;
-       struct list_head                *c_block_hash;
-       struct list_head                *c_indexes_hash[0];
-};
-
-
 /*
  * Global data: list of all mbcache's, lru list, and a spinlock for
  * accessing cache data structures on SMP machines. The lru list is
@@ -101,21 +86,12 @@ static LIST_HEAD(mb_cache_list);
 static LIST_HEAD(mb_cache_lru_list);
 static DEFINE_SPINLOCK(mb_cache_spinlock);
 
-static inline int
-mb_cache_indexes(struct mb_cache *cache)
-{
-#ifdef MB_CACHE_INDEXES_COUNT
-       return MB_CACHE_INDEXES_COUNT;
-#else
-       return cache->c_indexes_count;
-#endif
-}
-
 /*
  * What the mbcache registers as to get shrunk dynamically.
  */
 
-static int mb_cache_shrink_fn(int nr_to_scan, gfp_t gfp_mask);
+static int mb_cache_shrink_fn(struct shrinker *shrink,
+                             struct shrink_control *sc);
 
 static struct shrinker mb_cache_shrinker = {
        .shrink = mb_cache_shrink_fn,
@@ -132,12 +108,9 @@ __mb_cache_entry_is_hashed(struct mb_cache_entry *ce)
 static void
 __mb_cache_entry_unhash(struct mb_cache_entry *ce)
 {
-       int n;
-
        if (__mb_cache_entry_is_hashed(ce)) {
                list_del_init(&ce->e_block_list);
-               for (n=0; n<mb_cache_indexes(ce->e_cache); n++)
-                       list_del(&ce->e_indexes[n].o_list);
+               list_del(&ce->e_index.o_list);
        }
 }
 
@@ -148,16 +121,8 @@ __mb_cache_entry_forget(struct mb_cache_entry *ce, gfp_t gfp_mask)
        struct mb_cache *cache = ce->e_cache;
 
        mb_assert(!(ce->e_used || ce->e_queued));
-       if (cache->c_op.free && cache->c_op.free(ce, gfp_mask)) {
-               /* free failed -- put back on the lru list
-                  for freeing later. */
-               spin_lock(&mb_cache_spinlock);
-               list_add(&ce->e_lru_list, &mb_cache_lru_list);
-               spin_unlock(&mb_cache_spinlock);
-       } else {
-               kmem_cache_free(cache->c_entry_cache, ce);
-               atomic_dec(&cache->c_entry_count);
-       }
+       kmem_cache_free(cache->c_entry_cache, ce);
+       atomic_dec(&cache->c_entry_count);
 }
 
 
@@ -191,31 +156,23 @@ forget:
  * This function is called by the kernel memory management when memory
  * gets low.
  *
- * @nr_to_scan: Number of objects to scan
- * @gfp_mask: (ignored)
+ * @shrink: (ignored)
+ * @sc: shrink_control passed from reclaim
  *
  * Returns the number of objects which are present in the cache.
  */
 static int
-mb_cache_shrink_fn(int nr_to_scan, gfp_t gfp_mask)
+mb_cache_shrink_fn(struct shrinker *shrink, struct shrink_control *sc)
 {
        LIST_HEAD(free_list);
-       struct list_head *l, *ltmp;
+       struct mb_cache *cache;
+       struct mb_cache_entry *entry, *tmp;
        int count = 0;
+       int nr_to_scan = sc->nr_to_scan;
+       gfp_t gfp_mask = sc->gfp_mask;
 
-       spin_lock(&mb_cache_spinlock);
-       list_for_each(l, &mb_cache_list) {
-               struct mb_cache *cache =
-                       list_entry(l, struct mb_cache, c_cache_list);
-               mb_debug("cache %s (%d)", cache->c_name,
-                         atomic_read(&cache->c_entry_count));
-               count += atomic_read(&cache->c_entry_count);
-       }
        mb_debug("trying to free %d entries", nr_to_scan);
-       if (nr_to_scan == 0) {
-               spin_unlock(&mb_cache_spinlock);
-               goto out;
-       }
+       spin_lock(&mb_cache_spinlock);
        while (nr_to_scan-- && !list_empty(&mb_cache_lru_list)) {
                struct mb_cache_entry *ce =
                        list_entry(mb_cache_lru_list.next,
@@ -223,12 +180,15 @@ mb_cache_shrink_fn(int nr_to_scan, gfp_t gfp_mask)
                list_move_tail(&ce->e_lru_list, &free_list);
                __mb_cache_entry_unhash(ce);
        }
+       list_for_each_entry(cache, &mb_cache_list, c_cache_list) {
+               mb_debug("cache %s (%d)", cache->c_name,
+                         atomic_read(&cache->c_entry_count));
+               count += atomic_read(&cache->c_entry_count);
+       }
        spin_unlock(&mb_cache_spinlock);
-       list_for_each_safe(l, ltmp, &free_list) {
-               __mb_cache_entry_forget(list_entry(l, struct mb_cache_entry,
-                                                  e_lru_list), gfp_mask);
+       list_for_each_entry_safe(entry, tmp, &free_list, e_lru_list) {
+               __mb_cache_entry_forget(entry, gfp_mask);
        }
-out:
        return (count / 100) * sysctl_vfs_cache_pressure;
 }
 
@@ -242,72 +202,55 @@ out:
  * memory was available.
  *
  * @name: name of the cache (informal)
- * @cache_op: contains the callback called when freeing a cache entry
- * @entry_size: The size of a cache entry, including
- *              struct mb_cache_entry
- * @indexes_count: number of additional indexes in the cache. Must equal
- *                 MB_CACHE_INDEXES_COUNT if the number of indexes is
- *                 hardwired.
  * @bucket_bits: log2(number of hash buckets)
  */
 struct mb_cache *
-mb_cache_create(const char *name, struct mb_cache_op *cache_op,
-               size_t entry_size, int indexes_count, int bucket_bits)
+mb_cache_create(const char *name, int bucket_bits)
 {
-       int m=0, n, bucket_count = 1 << bucket_bits;
+       int n, bucket_count = 1 << bucket_bits;
        struct mb_cache *cache = NULL;
 
-       if(entry_size < sizeof(struct mb_cache_entry) +
-          indexes_count * sizeof(((struct mb_cache_entry *) 0)->e_indexes[0]))
-               return NULL;
-
-       cache = kmalloc(sizeof(struct mb_cache) +
-                       indexes_count * sizeof(struct list_head), GFP_KERNEL);
+       cache = kmalloc(sizeof(struct mb_cache), GFP_KERNEL);
        if (!cache)
-               goto fail;
+               return NULL;
        cache->c_name = name;
-       cache->c_op.free = NULL;
-       if (cache_op)
-               cache->c_op.free = cache_op->free;
        atomic_set(&cache->c_entry_count, 0);
        cache->c_bucket_bits = bucket_bits;
-#ifdef MB_CACHE_INDEXES_COUNT
-       mb_assert(indexes_count == MB_CACHE_INDEXES_COUNT);
-#else
-       cache->c_indexes_count = indexes_count;
-#endif
        cache->c_block_hash = kmalloc(bucket_count * sizeof(struct list_head),
                                      GFP_KERNEL);
        if (!cache->c_block_hash)
                goto fail;
        for (n=0; n<bucket_count; n++)
                INIT_LIST_HEAD(&cache->c_block_hash[n]);
-       for (m=0; m<indexes_count; m++) {
-               cache->c_indexes_hash[m] = kmalloc(bucket_count *
-                                                sizeof(struct list_head),
-                                                GFP_KERNEL);
-               if (!cache->c_indexes_hash[m])
-                       goto fail;
-               for (n=0; n<bucket_count; n++)
-                       INIT_LIST_HEAD(&cache->c_indexes_hash[m][n]);
-       }
-       cache->c_entry_cache = kmem_cache_create(name, entry_size, 0,
+       cache->c_index_hash = kmalloc(bucket_count * sizeof(struct list_head),
+                                     GFP_KERNEL);
+       if (!cache->c_index_hash)
+               goto fail;
+       for (n=0; n<bucket_count; n++)
+               INIT_LIST_HEAD(&cache->c_index_hash[n]);
+       cache->c_entry_cache = kmem_cache_create(name,
+               sizeof(struct mb_cache_entry), 0,
                SLAB_RECLAIM_ACCOUNT|SLAB_MEM_SPREAD, NULL);
        if (!cache->c_entry_cache)
-               goto fail;
+               goto fail2;
+
+       /*
+        * Set an upper limit on the number of cache entries so that the hash
+        * chains won't grow too long.
+        */
+       cache->c_max_entries = bucket_count << 4;
 
        spin_lock(&mb_cache_spinlock);
        list_add(&cache->c_cache_list, &mb_cache_list);
        spin_unlock(&mb_cache_spinlock);
        return cache;
 
+fail2:
+       kfree(cache->c_index_hash);
+
 fail:
-       if (cache) {
-               while (--m >= 0)
-                       kfree(cache->c_indexes_hash[m]);
-               kfree(cache->c_block_hash);
-               kfree(cache);
-       }
+       kfree(cache->c_block_hash);
+       kfree(cache);
        return NULL;
 }
 
@@ -356,7 +299,6 @@ mb_cache_destroy(struct mb_cache *cache)
 {
        LIST_HEAD(free_list);
        struct list_head *l, *ltmp;
-       int n;
 
        spin_lock(&mb_cache_spinlock);
        list_for_each_safe(l, ltmp, &mb_cache_lru_list) {
@@ -383,13 +325,11 @@ mb_cache_destroy(struct mb_cache *cache)
 
        kmem_cache_destroy(cache->c_entry_cache);
 
-       for (n=0; n < mb_cache_indexes(cache); n++)
-               kfree(cache->c_indexes_hash[n]);
+       kfree(cache->c_index_hash);
        kfree(cache->c_block_hash);
        kfree(cache);
 }
 
-
 /*
  * mb_cache_entry_alloc()
  *
@@ -399,19 +339,31 @@ mb_cache_destroy(struct mb_cache *cache)
  * if no more memory was available.
  */
 struct mb_cache_entry *
-mb_cache_entry_alloc(struct mb_cache *cache)
+mb_cache_entry_alloc(struct mb_cache *cache, gfp_t gfp_flags)
 {
-       struct mb_cache_entry *ce;
+       struct mb_cache_entry *ce = NULL;
 
-       ce = kmem_cache_alloc(cache->c_entry_cache, GFP_KERNEL);
-       if (ce) {
+       if (atomic_read(&cache->c_entry_count) >= cache->c_max_entries) {
+               spin_lock(&mb_cache_spinlock);
+               if (!list_empty(&mb_cache_lru_list)) {
+                       ce = list_entry(mb_cache_lru_list.next,
+                                       struct mb_cache_entry, e_lru_list);
+                       list_del_init(&ce->e_lru_list);
+                       __mb_cache_entry_unhash(ce);
+               }
+               spin_unlock(&mb_cache_spinlock);
+       }
+       if (!ce) {
+               ce = kmem_cache_alloc(cache->c_entry_cache, gfp_flags);
+               if (!ce)
+                       return NULL;
                atomic_inc(&cache->c_entry_count);
                INIT_LIST_HEAD(&ce->e_lru_list);
                INIT_LIST_HEAD(&ce->e_block_list);
                ce->e_cache = cache;
-               ce->e_used = 1 + MB_CACHE_WRITER;
                ce->e_queued = 0;
        }
+       ce->e_used = 1 + MB_CACHE_WRITER;
        return ce;
 }
 
@@ -428,17 +380,16 @@ mb_cache_entry_alloc(struct mb_cache *cache)
  *
  * @bdev: device the cache entry belongs to
  * @block: block number
- * @keys: array of additional keys. There must be indexes_count entries
- *        in the array (as specified when creating the cache).
+ * @key: lookup key
  */
 int
 mb_cache_entry_insert(struct mb_cache_entry *ce, struct block_device *bdev,
-                     sector_t block, unsigned int keys[])
+                     sector_t block, unsigned int key)
 {
        struct mb_cache *cache = ce->e_cache;
        unsigned int bucket;
        struct list_head *l;
-       int error = -EBUSY, n;
+       int error = -EBUSY;
 
        bucket = hash_long((unsigned long)bdev + (block & 0xffffffff), 
                           cache->c_bucket_bits);
@@ -453,12 +404,9 @@ mb_cache_entry_insert(struct mb_cache_entry *ce, struct block_device *bdev,
        ce->e_bdev = bdev;
        ce->e_block = block;
        list_add(&ce->e_block_list, &cache->c_block_hash[bucket]);
-       for (n=0; n<mb_cache_indexes(cache); n++) {
-               ce->e_indexes[n].o_key = keys[n];
-               bucket = hash_long(keys[n], cache->c_bucket_bits);
-               list_add(&ce->e_indexes[n].o_list,
-                        &cache->c_indexes_hash[n][bucket]);
-       }
+       ce->e_index.o_key = key;
+       bucket = hash_long(key, cache->c_bucket_bits);
+       list_add(&ce->e_index.o_list, &cache->c_index_hash[bucket]);
        error = 0;
 out:
        spin_unlock(&mb_cache_spinlock);
@@ -554,13 +502,12 @@ cleanup:
 
 static struct mb_cache_entry *
 __mb_cache_entry_find(struct list_head *l, struct list_head *head,
-                     int index, struct block_device *bdev, unsigned int key)
+                     struct block_device *bdev, unsigned int key)
 {
        while (l != head) {
                struct mb_cache_entry *ce =
-                       list_entry(l, struct mb_cache_entry,
-                                  e_indexes[index].o_list);
-               if (ce->e_bdev == bdev && ce->e_indexes[index].o_key == key) {
+                       list_entry(l, struct mb_cache_entry, e_index.o_list);
+               if (ce->e_bdev == bdev && ce->e_index.o_key == key) {
                        DEFINE_WAIT(wait);
 
                        if (!list_empty(&ce->e_lru_list))
@@ -597,28 +544,25 @@ __mb_cache_entry_find(struct list_head *l, struct list_head *head,
  * mb_cache_entry_find_first()
  *
  * Find the first cache entry on a given device with a certain key in
- * an additional index. Additonal matches can be found with
+ * an additional index. Additional matches can be found with
  * mb_cache_entry_find_next(). Returns NULL if no match was found. The
  * returned cache entry is locked for shared access ("multiple readers").
  *
  * @cache: the cache to search
- * @index: the number of the additonal index to search (0<=index<indexes_count)
  * @bdev: the device the cache entry should belong to
  * @key: the key in the index
  */
 struct mb_cache_entry *
-mb_cache_entry_find_first(struct mb_cache *cache, int index,
-                         struct block_device *bdev, unsigned int key)
+mb_cache_entry_find_first(struct mb_cache *cache, struct block_device *bdev,
+                         unsigned int key)
 {
        unsigned int bucket = hash_long(key, cache->c_bucket_bits);
        struct list_head *l;
        struct mb_cache_entry *ce;
 
-       mb_assert(index < mb_cache_indexes(cache));
        spin_lock(&mb_cache_spinlock);
-       l = cache->c_indexes_hash[index][bucket].next;
-       ce = __mb_cache_entry_find(l, &cache->c_indexes_hash[index][bucket],
-                                  index, bdev, key);
+       l = cache->c_index_hash[bucket].next;
+       ce = __mb_cache_entry_find(l, &cache->c_index_hash[bucket], bdev, key);
        spin_unlock(&mb_cache_spinlock);
        return ce;
 }
@@ -639,12 +583,11 @@ mb_cache_entry_find_first(struct mb_cache *cache, int index,
  * }
  *
  * @prev: The previous match
- * @index: the number of the additonal index to search (0<=index<indexes_count)
  * @bdev: the device the cache entry should belong to
  * @key: the key in the index
  */
 struct mb_cache_entry *
-mb_cache_entry_find_next(struct mb_cache_entry *prev, int index,
+mb_cache_entry_find_next(struct mb_cache_entry *prev,
                         struct block_device *bdev, unsigned int key)
 {
        struct mb_cache *cache = prev->e_cache;
@@ -652,11 +595,9 @@ mb_cache_entry_find_next(struct mb_cache_entry *prev, int index,
        struct list_head *l;
        struct mb_cache_entry *ce;
 
-       mb_assert(index < mb_cache_indexes(cache));
        spin_lock(&mb_cache_spinlock);
-       l = prev->e_indexes[index].o_list.next;
-       ce = __mb_cache_entry_find(l, &cache->c_indexes_hash[index][bucket],
-                                  index, bdev, key);
+       l = prev->e_index.o_list.next;
+       ce = __mb_cache_entry_find(l, &cache->c_index_hash[bucket], bdev, key);
        __mb_cache_entry_release_unlock(prev);
        return ce;
 }