github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-05-13 00:28:54 +02:00
Code Issues Actions Packages Projects Releases Wiki Activity

f2fs: add a sysfs entry to reclaim POSIX_FADV_NOREUSE pages

Browse Source 
1. fadvise(fd1, POSIX_FADV_NOREUSE, {0,3});
2. fadvise(fd2, POSIX_FADV_NOREUSE, {1,2});
3. fadvise(fd3, POSIX_FADV_NOREUSE, {3,1});
4. echo 1024 > /sys/fs/f2fs/tuning/reclaim_caches_kb

This gives a way to reclaim file-backed pages by iterating all f2fs mounts until
reclaiming 1MB page cache ranges, registered by #1, #2, and #3.

5. cat /sys/fs/f2fs/tuning/reclaim_caches_kb
-> gives total number of registered file ranges.

Reviewed-by: Chao Yu <chao@kernel.org>
Signed-off-by: Jaegeuk Kim <jaegeuk@kernel.org>
This commit is contained in:
Jaegeuk Kim 2025-01-31 22:27:57 +00:00
parent ef0c333cad
commit a907f3a68e
4 changed files with 162 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
Documentation/ABI/testing/sysfs-fs-f2fs
View File

@ -828,3 +828,10 @@ Date: November 2024
Contact: "Chao Yu" <chao@kernel.org>
Description: It controls max read extent count for per-inode, the value of threshold
is 10240 by default.
What: /sys/fs/f2fs/tuning/reclaim_caches_kb
Date: February 2025
Contact: "Jaegeuk Kim" <jaegeuk@kernel.org>
Description: It reclaims the given KBs of file-backed pages registered by
ioctl(F2FS_IOC_DONATE_RANGE).
For example, writing N tries to drop N KBs spaces in LRU.

2
fs/f2fs/f2fs.h
View File

@ -4243,6 +4243,8 @@ unsigned long f2fs_shrink_count(struct shrinker *shrink,
struct shrink_control *sc);
unsigned long f2fs_shrink_scan(struct shrinker *shrink,
struct shrink_control *sc);
unsigned int f2fs_donate_files(void);
void f2fs_reclaim_caches(unsigned int reclaim_caches_kb);
void f2fs_join_shrinker(struct f2fs_sb_info *sbi);
void f2fs_leave_shrinker(struct f2fs_sb_info *sbi);

90
fs/f2fs/shrinker.c
View File

@ -130,6 +130,96 @@ unsigned long f2fs_shrink_scan(struct shrinker *shrink,
return freed;
}
unsigned int f2fs_donate_files(void)
{
struct f2fs_sb_info *sbi;
struct list_head *p;
unsigned int donate_files = 0;
spin_lock(&f2fs_list_lock);
p = f2fs_list.next;
while (p != &f2fs_list) {
sbi = list_entry(p, struct f2fs_sb_info, s_list);
/* stop f2fs_put_super */
if (!mutex_trylock(&sbi->umount_mutex)) {
p = p->next;
continue;
}
spin_unlock(&f2fs_list_lock);
donate_files += sbi->donate_files;
spin_lock(&f2fs_list_lock);
p = p->next;
mutex_unlock(&sbi->umount_mutex);
}
spin_unlock(&f2fs_list_lock);
return donate_files;
}
static unsigned int do_reclaim_caches(struct f2fs_sb_info *sbi,
unsigned int reclaim_caches_kb)
{
struct inode *inode;
struct f2fs_inode_info *fi;
unsigned int nfiles = sbi->donate_files;
pgoff_t npages = reclaim_caches_kb >> (PAGE_SHIFT - 10);
while (npages && nfiles--) {
pgoff_t len;
spin_lock(&sbi->inode_lock[DONATE_INODE]);
if (list_empty(&sbi->inode_list[DONATE_INODE])) {
spin_unlock(&sbi->inode_lock[DONATE_INODE]);
break;
}
fi = list_first_entry(&sbi->inode_list[DONATE_INODE],
struct f2fs_inode_info, gdonate_list);
list_move_tail(&fi->gdonate_list, &sbi->inode_list[DONATE_INODE]);
inode = igrab(&fi->vfs_inode);
spin_unlock(&sbi->inode_lock[DONATE_INODE]);
if (!inode)
continue;
len = fi->donate_end - fi->donate_start + 1;
npages = npages < len ? 0 : npages - len;
invalidate_inode_pages2_range(inode->i_mapping,
fi->donate_start, fi->donate_end);
iput(inode);
cond_resched();
}
return npages << (PAGE_SHIFT - 10);
}
void f2fs_reclaim_caches(unsigned int reclaim_caches_kb)
{
struct f2fs_sb_info *sbi;
struct list_head *p;
spin_lock(&f2fs_list_lock);
p = f2fs_list.next;
while (p != &f2fs_list && reclaim_caches_kb) {
sbi = list_entry(p, struct f2fs_sb_info, s_list);
/* stop f2fs_put_super */
if (!mutex_trylock(&sbi->umount_mutex)) {
p = p->next;
continue;
}
spin_unlock(&f2fs_list_lock);
reclaim_caches_kb = do_reclaim_caches(sbi, reclaim_caches_kb);
spin_lock(&f2fs_list_lock);
p = p->next;
mutex_unlock(&sbi->umount_mutex);
}
spin_unlock(&f2fs_list_lock);
}
void f2fs_join_shrinker(struct f2fs_sb_info *sbi)
{
spin_lock(&f2fs_list_lock);

63
fs/f2fs/sysfs.c
View File

@ -916,6 +916,39 @@ static struct f2fs_base_attr f2fs_base_attr_##_name = { \
.show = f2fs_feature_show, \
}
static ssize_t f2fs_tune_show(struct f2fs_base_attr *a, char *buf)
{
unsigned int res = 0;
if (!strcmp(a->attr.name, "reclaim_caches_kb"))
res = f2fs_donate_files();
return sysfs_emit(buf, "%u\n", res);
}
static ssize_t f2fs_tune_store(struct f2fs_base_attr *a,
const char *buf, size_t count)
{
unsigned long t;
int ret;
ret = kstrtoul(skip_spaces(buf), 0, &t);
if (ret)
return ret;
if (!strcmp(a->attr.name, "reclaim_caches_kb"))
f2fs_reclaim_caches(t);
return count;
}
#define F2FS_TUNE_RW_ATTR(_name) \
static struct f2fs_base_attr f2fs_base_attr_##_name = { \
.attr = {.name = __stringify(_name), .mode = 0644 }, \
.show = f2fs_tune_show, \
.store = f2fs_tune_store, \
}
static ssize_t f2fs_sb_feature_show(struct f2fs_attr *a,
struct f2fs_sb_info *sbi, char *buf)
{
@ -1368,6 +1401,14 @@ static struct attribute *f2fs_sb_feat_attrs[] = {
};
ATTRIBUTE_GROUPS(f2fs_sb_feat);
F2FS_TUNE_RW_ATTR(reclaim_caches_kb);
static struct attribute *f2fs_tune_attrs[] = {
BASE_ATTR_LIST(reclaim_caches_kb),
NULL,
};
ATTRIBUTE_GROUPS(f2fs_tune);
static const struct sysfs_ops f2fs_attr_ops = {
.show = f2fs_attr_show,
.store = f2fs_attr_store,
@ -1401,6 +1442,20 @@ static struct kobject f2fs_feat = {
.kset = &f2fs_kset,
};
static const struct sysfs_ops f2fs_tune_attr_ops = {
.show = f2fs_base_attr_show,
.store = f2fs_base_attr_store,
};
static const struct kobj_type f2fs_tune_ktype = {
.default_groups = f2fs_tune_groups,
.sysfs_ops = &f2fs_tune_attr_ops,
};
static struct kobject f2fs_tune = {
.kset = &f2fs_kset,
};
static ssize_t f2fs_stat_attr_show(struct kobject *kobj,
struct attribute *attr, char *buf)
{
@ -1637,6 +1692,11 @@ int __init f2fs_init_sysfs(void)
if (ret)
goto put_kobject;
ret = kobject_init_and_add(&f2fs_tune, &f2fs_tune_ktype,
NULL, "tuning");
if (ret)
goto put_kobject;
f2fs_proc_root = proc_mkdir("fs/f2fs", NULL);
if (!f2fs_proc_root) {
ret = -ENOMEM;
@ -1644,7 +1704,9 @@ int __init f2fs_init_sysfs(void)
}
return 0;
put_kobject:
kobject_put(&f2fs_tune);
kobject_put(&f2fs_feat);
kset_unregister(&f2fs_kset);
return ret;
@ -1652,6 +1714,7 @@ int __init f2fs_init_sysfs(void)
void f2fs_exit_sysfs(void)
{
kobject_put(&f2fs_tune);
kobject_put(&f2fs_feat);
kset_unregister(&f2fs_kset);
remove_proc_entry("fs/f2fs", NULL);