linux-master/fs/mbcache.c

16  * Ext2 and ext4 use this cache for deduplication of extended attribute blocks.
21  * identifies a cache entry.
33 	/* Maximum entries in cache to avoid degrading hash too much */
38 	/* Number of entries in cache */
41 	/* Work for shrinking when the cache has too many entries */
47 static unsigned long mb_cache_shrink(struct mb_cache *cache,
50 static inline struct hlist_bl_head *mb_cache_entry_head(struct mb_cache *cache,
53 	return &cache->c_hash[hash_32(key, cache->c_bucket_bits)];
58  * in cache
63  * mb_cache_entry_create - create entry in cache
64  * @cache - cache where the entry should be created
70  * Creates entry in @cache with key @key and value @value. The function returns
71  * -EBUSY if entry with the same key and value already exists in cache.
74 int mb_cache_entry_create(struct mb_cache *cache, gfp_t mask, u32 key,
82 	if (cache->c_entry_count >= cache->c_max_entries)
83 		schedule_work(&cache->c_shrink_work);
85 	if (cache->c_entry_count >= 2*cache->c_max_entries)
86 		mb_cache_shrink(cache, SYNC_SHRINK_BATCH);
97 	 * avoids nesting of cache->c_list_lock into hash table bit locks which
106 	head = mb_cache_entry_head(cache, key);
117 	spin_lock(&cache->c_list_lock);
118 	list_add_tail(&entry->e_list, &cache->c_list);
119 	cache->c_entry_count++;
120 	spin_unlock(&cache->c_list_lock);
121 	mb_cache_entry_put(cache, entry);
127 void __mb_cache_entry_free(struct mb_cache *cache, struct mb_cache_entry *entry)
131 	head = mb_cache_entry_head(cache, entry->e_key);
152 static struct mb_cache_entry *__entry_find(struct mb_cache *cache,
160 	head = mb_cache_entry_head(cache, key);
179 		mb_cache_entry_put(cache, old_entry);
186  * @cache: cache where we should search
189  * Search in @cache for a reusable entry with key @key. Grabs reference to the
192 struct mb_cache_entry *mb_cache_entry_find_first(struct mb_cache *cache,
195 	return __entry_find(cache, NULL, key);
201  * @cache: cache where we should search
209 struct mb_cache_entry *mb_cache_entry_find_next(struct mb_cache *cache,
212 	return __entry_find(cache, entry, entry->e_key);
217  * mb_cache_entry_get - get a cache entry by value (and key)
218  * @cache - cache we work with
222 struct mb_cache_entry *mb_cache_entry_get(struct mb_cache *cache, u32 key,
229 	head = mb_cache_entry_head(cache, key);
243 /* mb_cache_entry_delete_or_get - remove a cache entry if it has no users
244  * @cache - cache we work with
248  * Remove entry from cache @cache with key @key and value @value. The removal
250  * entry was successfully removed or there's no entry in cache. Otherwise the
254 struct mb_cache_entry *mb_cache_entry_delete_or_get(struct mb_cache *cache,
259 	entry = mb_cache_entry_get(cache, key, value);
270 	spin_lock(&cache->c_list_lock);
273 	cache->c_entry_count--;
274 	spin_unlock(&cache->c_list_lock);
275 	__mb_cache_entry_free(cache, entry);
280 /* mb_cache_entry_touch - cache entry got used
281  * @cache - cache the entry belongs to
284  * Marks entry as used to give hit higher chances of surviving in cache.
286 void mb_cache_entry_touch(struct mb_cache *cache,
296 	struct mb_cache *cache = shrink->private_data;
298 	return cache->c_entry_count;
301 /* Shrink number of entries in cache */
302 static unsigned long mb_cache_shrink(struct mb_cache *cache,
308 	spin_lock(&cache->c_list_lock);
309 	while (nr_to_scan-- && !list_empty(&cache->c_list)) {
310 		entry = list_first_entry(&cache->c_list,
316 			list_move_tail(&entry->e_list, &cache->c_list);
320 		cache->c_entry_count--;
321 		spin_unlock(&cache->c_list_lock);
322 		__mb_cache_entry_free(cache, entry);
325 		spin_lock(&cache->c_list_lock);
327 	spin_unlock(&cache->c_list_lock);
335 	struct mb_cache *cache = shrink->private_data;
336 	return mb_cache_shrink(cache, sc->nr_to_scan);
339 /* We shrink 1/X of the cache when we have too many entries in it */
344 	struct mb_cache *cache = container_of(work, struct mb_cache,
346 	mb_cache_shrink(cache, cache->c_max_entries / SHRINK_DIVISOR);
350  * mb_cache_create - create cache
353  * Create cache for keys with 2^bucket_bits hash entries.
357 	struct mb_cache *cache;
361 	cache = kzalloc(sizeof(struct mb_cache), GFP_KERNEL);
362 	if (!cache)
364 	cache->c_bucket_bits = bucket_bits;
365 	cache->c_max_entries = bucket_count << 4;
366 	INIT_LIST_HEAD(&cache->c_list);
367 	spin_lock_init(&cache->c_list_lock);
368 	cache->c_hash = kmalloc_array(bucket_count,
371 	if (!cache->c_hash) {
372 		kfree(cache);
376 		INIT_HLIST_BL_HEAD(&cache->c_hash[i]);
378 	cache->c_shrink = shrinker_alloc(0, "mbcache-shrinker");
379 	if (!cache->c_shrink) {
380 		kfree(cache->c_hash);
381 		kfree(cache);
385 	cache->c_shrink->count_objects = mb_cache_count;
386 	cache->c_shrink->scan_objects = mb_cache_scan;
387 	cache->c_shrink->private_data = cache;
389 	shrinker_register(cache->c_shrink);
391 	INIT_WORK(&cache->c_shrink_work, mb_cache_shrink_worker);
393 	return cache;
401  * mb_cache_destroy - destroy cache
402  * @cache: the cache to destroy
404  * Free all entries in cache and cache itself. Caller must make sure nobody
405  * (except shrinker) can reach @cache when calling this.
407 void mb_cache_destroy(struct mb_cache *cache)
411 	shrinker_free(cache->c_shrink);
417 	list_for_each_entry_safe(entry, next, &cache->c_list, e_list) {
420 		mb_cache_entry_put(cache, entry);
422 	kfree(cache->c_hash);
423 	kfree(cache);
444 MODULE_DESCRIPTION("Meta block cache (for extended attributes)");