mirror of
https://mirrors.bfsu.edu.cn/git/linux.git
synced 2024-12-06 02:24:14 +08:00
d588adae3b
In order to replace the open coded name cache in send with the lru cache, we need an API for the lru cache to delete a specific entry for which we did a previous lookup. This adds the API for it, and a next patch in the series will use it. This patch is part of a larger patchset and the changelog of the last patch in the series contains a sample performance test and results. The patches that comprise the patchset are the following: btrfs: send: directly return from did_overwrite_ref() and simplify it btrfs: send: avoid unnecessary generation search at did_overwrite_ref() btrfs: send: directly return from will_overwrite_ref() and simplify it btrfs: send: avoid extra b+tree searches when checking reference overrides btrfs: send: remove send_progress argument from can_rmdir() btrfs: send: avoid duplicated orphan dir allocation and initialization btrfs: send: avoid unnecessary orphan dir rbtree search at can_rmdir() btrfs: send: reduce searches on parent root when checking if dir can be removed btrfs: send: iterate waiting dir move rbtree only once when processing refs btrfs: send: initialize all the red black trees earlier btrfs: send: genericize the backref cache to allow it to be reused btrfs: adapt lru cache to allow for 64 bits keys on 32 bits systems btrfs: send: cache information about created directories btrfs: allow a generation number to be associated with lru cache entries btrfs: add an api to delete a specific entry from the lru cache btrfs: send: use the lru cache to implement the name cache btrfs: send: update size of roots array for backref cache entries btrfs: send: cache utimes operations for directories if possible Signed-off-by: Filipe Manana <fdmanana@suse.com> Reviewed-by: David Sterba <dsterba@suse.com> Signed-off-by: David Sterba <dsterba@suse.com>
165 lines
3.6 KiB
C
165 lines
3.6 KiB
C
// SPDX-License-Identifier: GPL-2.0
|
|
|
|
#include <linux/mm.h>
|
|
#include "lru_cache.h"
|
|
#include "messages.h"
|
|
|
|
/*
|
|
* Initialize a cache object.
|
|
*
|
|
* @cache: The cache.
|
|
* @max_size: Maximum size (number of entries) for the cache.
|
|
*/
|
|
void btrfs_lru_cache_init(struct btrfs_lru_cache *cache, unsigned int max_size)
|
|
{
|
|
INIT_LIST_HEAD(&cache->lru_list);
|
|
mt_init(&cache->entries);
|
|
cache->size = 0;
|
|
cache->max_size = max_size;
|
|
}
|
|
|
|
static struct btrfs_lru_cache_entry *match_entry(struct list_head *head, u64 key,
|
|
u64 gen)
|
|
{
|
|
struct btrfs_lru_cache_entry *entry;
|
|
|
|
list_for_each_entry(entry, head, list) {
|
|
if (entry->key == key && entry->gen == gen)
|
|
return entry;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/*
|
|
* Lookup for an entry in the cache.
|
|
*
|
|
* @cache: The cache.
|
|
* @key: The key of the entry we are looking for.
|
|
* @gen: Generation associated to the key.
|
|
*
|
|
* Returns the entry associated with the key or NULL if none found.
|
|
*/
|
|
struct btrfs_lru_cache_entry *btrfs_lru_cache_lookup(struct btrfs_lru_cache *cache,
|
|
u64 key, u64 gen)
|
|
{
|
|
struct list_head *head;
|
|
struct btrfs_lru_cache_entry *entry;
|
|
|
|
head = mtree_load(&cache->entries, key);
|
|
if (!head)
|
|
return NULL;
|
|
|
|
entry = match_entry(head, key, gen);
|
|
if (entry)
|
|
list_move_tail(&entry->lru_list, &cache->lru_list);
|
|
|
|
return entry;
|
|
}
|
|
|
|
/*
|
|
* Remove an entry from the cache.
|
|
*
|
|
* @cache: The cache to remove from.
|
|
* @entry: The entry to remove from the cache.
|
|
*
|
|
* Note: this also frees the memory used by the entry.
|
|
*/
|
|
void btrfs_lru_cache_remove(struct btrfs_lru_cache *cache,
|
|
struct btrfs_lru_cache_entry *entry)
|
|
{
|
|
struct list_head *prev = entry->list.prev;
|
|
|
|
ASSERT(cache->size > 0);
|
|
ASSERT(!mtree_empty(&cache->entries));
|
|
|
|
list_del(&entry->list);
|
|
list_del(&entry->lru_list);
|
|
|
|
if (list_empty(prev)) {
|
|
struct list_head *head;
|
|
|
|
/*
|
|
* If previous element in the list entry->list is now empty, it
|
|
* means it's a head entry not pointing to any cached entries,
|
|
* so remove it from the maple tree and free it.
|
|
*/
|
|
head = mtree_erase(&cache->entries, entry->key);
|
|
ASSERT(head == prev);
|
|
kfree(head);
|
|
}
|
|
|
|
kfree(entry);
|
|
cache->size--;
|
|
}
|
|
|
|
/*
|
|
* Store an entry in the cache.
|
|
*
|
|
* @cache: The cache.
|
|
* @entry: The entry to store.
|
|
*
|
|
* Returns 0 on success and < 0 on error.
|
|
*/
|
|
int btrfs_lru_cache_store(struct btrfs_lru_cache *cache,
|
|
struct btrfs_lru_cache_entry *new_entry,
|
|
gfp_t gfp)
|
|
{
|
|
const u64 key = new_entry->key;
|
|
struct list_head *head;
|
|
int ret;
|
|
|
|
head = kmalloc(sizeof(*head), gfp);
|
|
if (!head)
|
|
return -ENOMEM;
|
|
|
|
ret = mtree_insert(&cache->entries, key, head, gfp);
|
|
if (ret == 0) {
|
|
INIT_LIST_HEAD(head);
|
|
list_add_tail(&new_entry->list, head);
|
|
} else if (ret == -EEXIST) {
|
|
kfree(head);
|
|
head = mtree_load(&cache->entries, key);
|
|
ASSERT(head != NULL);
|
|
if (match_entry(head, key, new_entry->gen) != NULL)
|
|
return -EEXIST;
|
|
list_add_tail(&new_entry->list, head);
|
|
} else if (ret < 0) {
|
|
kfree(head);
|
|
return ret;
|
|
}
|
|
|
|
if (cache->size == cache->max_size) {
|
|
struct btrfs_lru_cache_entry *lru_entry;
|
|
|
|
lru_entry = list_first_entry(&cache->lru_list,
|
|
struct btrfs_lru_cache_entry,
|
|
lru_list);
|
|
btrfs_lru_cache_remove(cache, lru_entry);
|
|
}
|
|
|
|
list_add_tail(&new_entry->lru_list, &cache->lru_list);
|
|
cache->size++;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/*
|
|
* Empty a cache.
|
|
*
|
|
* @cache: The cache to empty.
|
|
*
|
|
* Removes all entries from the cache.
|
|
*/
|
|
void btrfs_lru_cache_clear(struct btrfs_lru_cache *cache)
|
|
{
|
|
struct btrfs_lru_cache_entry *entry;
|
|
struct btrfs_lru_cache_entry *tmp;
|
|
|
|
list_for_each_entry_safe(entry, tmp, &cache->lru_list, lru_list)
|
|
btrfs_lru_cache_remove(cache, entry);
|
|
|
|
ASSERT(cache->size == 0);
|
|
ASSERT(mtree_empty(&cache->entries));
|
|
}
|