| lists.openwall.net | lists / announce owl-users owl-dev john-users john-dev passwdqc-users yescrypt popa3d-users / oss-security kernel-hardening musl sabotage tlsify passwords / crypt-dev xvendor / Bugtraq Full-Disclosure linux-kernel linux-netdev linux-ext4 linux-hardening linux-cve-announce PHC | |
|
Open Source and information security mailing list archives
| ||
|
Date: Fri, 10 Aug 2018 18:08:06 +0800
From: Chao Yu <yuchao0@...wei.com>
To: <jaegeuk@...nel.org>
CC: <linux-f2fs-devel@...ts.sourceforge.net>,
<linux-kernel@...r.kernel.org>, <chao@...nel.org>,
Chao Yu <yuchao0@...wei.com>
Subject: [PATCH 2/2] f2fs: tune discard speed with storage usage rate
Previously, discard speed was fixed mostly, and in high usage rate
device, we will speed up issuing discard, but it doesn't make sense
that in a non-full filesystem, we still issue discard with slow speed.
Anyway, it comes out undiscarded block makes FTL GC be lower efficient
and causing high lifetime overhead.
Let's tune discard speed as below:
a. adjust default issue interval:
original after
min_interval: 50ms 100ms
mid_interval: 500ms 1000ms
max_interval: 60000ms 10000ms
b. if last time we stop issuing discard due to IO interruption of user,
let's reset all {min,mid,max}_interval to default one.
c. tune {min,mid,max}_interval with below calculation method:
base_interval = default_interval / 10;
total_interval = default_interval - base_interval;
interval = base_interval + total_interval * (100 - dev_util) / 100;
For example:
min_interval (:100ms)
dev_util (%) interval (ms)
0 100
10 91
20 82
30 73
...
80 28
90 19
100 10
Signed-off-by: Chao Yu <yuchao0@...wei.com>
---
fs/f2fs/f2fs.h | 11 ++++----
fs/f2fs/segment.c | 64 +++++++++++++++++++++++++++++++++++++----------
fs/f2fs/segment.h | 9 +++++++
fs/f2fs/super.c | 2 +-
4 files changed, 67 insertions(+), 19 deletions(-)
diff --git a/fs/f2fs/f2fs.h b/fs/f2fs/f2fs.h
index 273ffdaf4891..a1dd2e1c3cb9 100644
--- a/fs/f2fs/f2fs.h
+++ b/fs/f2fs/f2fs.h
@@ -185,10 +185,9 @@ enum {
#define MAX_DISCARD_BLOCKS(sbi) BLKS_PER_SEC(sbi)
#define DEF_MAX_DISCARD_REQUEST 8 /* issue 8 discards per round */
-#define DEF_MIN_DISCARD_ISSUE_TIME 50 /* 50 ms, if exists */
-#define DEF_MID_DISCARD_ISSUE_TIME 500 /* 500 ms, if device busy */
-#define DEF_MAX_DISCARD_ISSUE_TIME 60000 /* 60 s, if no candidates */
-#define DEF_DISCARD_URGENT_UTIL 80 /* do more discard over 80% */
+#define DEF_MIN_DISCARD_ISSUE_TIME 100 /* 100 ms, if exists */
+#define DEF_MID_DISCARD_ISSUE_TIME 1000 /* 1000 ms, if device busy */
+#define DEF_MAX_DISCARD_ISSUE_TIME 10000 /* 10000 ms, if no candidates */
#define DEF_CP_INTERVAL 60 /* 60 secs */
#define DEF_IDLE_INTERVAL 5 /* 5 secs */
@@ -248,7 +247,8 @@ struct discard_entry {
};
/* default discard granularity of inner discard thread, unit: block count */
-#define DEFAULT_DISCARD_GRANULARITY 1
+#define MID_DISCARD_GRANULARITY 16
+#define MIN_DISCARD_GRANULARITY 1
/* max discard pend list number */
#define MAX_PLIST_NUM 512
@@ -330,6 +330,7 @@ struct discard_cmd_control {
atomic_t discard_cmd_cnt; /* # of cached cmd count */
struct rb_root root; /* root of discard rb-tree */
bool rbtree_check; /* config for consistence check */
+ bool io_interrupted; /* last state of io interrupted */
};
/* for the list of fsync inodes, used only during recovery */
diff --git a/fs/f2fs/segment.c b/fs/f2fs/segment.c
index 8b52e8dfb12f..9564aaf1f27b 100644
--- a/fs/f2fs/segment.c
+++ b/fs/f2fs/segment.c
@@ -968,6 +968,44 @@ static void __check_sit_bitmap(struct f2fs_sb_info *sbi,
#endif
}
+static void __adjust_discard_speed(unsigned int *interval,
+ unsigned int def_interval, int dev_util)
+{
+ unsigned int base_interval, total_interval;
+
+ base_interval = def_interval / 10;
+ total_interval = def_interval - base_interval;
+
+ /*
+ * if def_interval = 100, adjusted interval should be in range of
+ * [10, 100].
+ */
+ *interval = base_interval + total_interval * (100 - dev_util) / 100;
+}
+
+static void __tune_discard_policy(struct f2fs_sb_info *sbi,
+ struct discard_policy *dpolicy)
+{
+ struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
+ int dev_util;
+
+ if (dcc->io_interrupted) {
+ dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
+ dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
+ dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
+ return;
+ }
+
+ dev_util = dev_utilization(sbi);
+
+ __adjust_discard_speed(&dpolicy->min_interval,
+ DEF_MIN_DISCARD_ISSUE_TIME, dev_util);
+ __adjust_discard_speed(&dpolicy->mid_interval,
+ DEF_MID_DISCARD_ISSUE_TIME, dev_util);
+ __adjust_discard_speed(&dpolicy->max_interval,
+ DEF_MAX_DISCARD_ISSUE_TIME, dev_util);
+}
+
static void __init_discard_policy(struct f2fs_sb_info *sbi,
struct discard_policy *dpolicy,
int discard_type, unsigned int granularity)
@@ -982,20 +1020,11 @@ static void __init_discard_policy(struct f2fs_sb_info *sbi,
dpolicy->io_aware_gran = MAX_PLIST_NUM;
if (discard_type == DPOLICY_BG) {
- dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
- dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
- dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
dpolicy->io_aware = true;
dpolicy->sync = false;
dpolicy->ordered = true;
- if (utilization(sbi) > DEF_DISCARD_URGENT_UTIL) {
- dpolicy->granularity = 1;
- dpolicy->max_interval = DEF_MIN_DISCARD_ISSUE_TIME;
- }
+ __tune_discard_policy(sbi, dpolicy);
} else if (discard_type == DPOLICY_FORCE) {
- dpolicy->min_interval = DEF_MIN_DISCARD_ISSUE_TIME;
- dpolicy->mid_interval = DEF_MID_DISCARD_ISSUE_TIME;
- dpolicy->max_interval = DEF_MAX_DISCARD_ISSUE_TIME;
dpolicy->io_aware = false;
} else if (discard_type == DPOLICY_FSTRIM) {
dpolicy->io_aware = false;
@@ -1353,6 +1382,8 @@ static unsigned int __issue_discard_cmd_orderly(struct f2fs_sb_info *sbi,
if (!issued && io_interrupted)
issued = -1;
+ dcc->io_interrupted = io_interrupted;
+
return issued;
}
@@ -1370,7 +1401,7 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
if (i + 1 < dpolicy->granularity)
break;
- if (i < DEFAULT_DISCARD_GRANULARITY && dpolicy->ordered)
+ if (i < MID_DISCARD_GRANULARITY && dpolicy->ordered)
return __issue_discard_cmd_orderly(sbi, dpolicy);
pend_list = &dcc->pend_list[i];
@@ -1407,6 +1438,8 @@ static int __issue_discard_cmd(struct f2fs_sb_info *sbi,
if (!issued && io_interrupted)
issued = -1;
+ dcc->io_interrupted = io_interrupted;
+
return issued;
}
@@ -1576,7 +1609,11 @@ static int issue_discard_thread(void *data)
struct f2fs_sb_info *sbi = data;
struct discard_cmd_control *dcc = SM_I(sbi)->dcc_info;
wait_queue_head_t *q = &dcc->discard_wait_queue;
- struct discard_policy dpolicy;
+ struct discard_policy dpolicy = {
+ .min_interval = DEF_MIN_DISCARD_ISSUE_TIME,
+ .mid_interval = DEF_MID_DISCARD_ISSUE_TIME,
+ .max_interval = DEF_MAX_DISCARD_ISSUE_TIME,
+ };
unsigned int wait_ms = DEF_MIN_DISCARD_ISSUE_TIME;
int issued;
@@ -1929,7 +1966,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
if (!dcc)
return -ENOMEM;
- dcc->discard_granularity = DEFAULT_DISCARD_GRANULARITY;
+ dcc->discard_granularity = MIN_DISCARD_GRANULARITY;
INIT_LIST_HEAD(&dcc->entry_list);
for (i = 0; i < MAX_PLIST_NUM; i++)
INIT_LIST_HEAD(&dcc->pend_list[i]);
@@ -1945,6 +1982,7 @@ static int create_discard_cmd_control(struct f2fs_sb_info *sbi)
dcc->next_pos = 0;
dcc->root = RB_ROOT;
dcc->rbtree_check = false;
+ dcc->io_interrupted = false;
init_waitqueue_head(&dcc->discard_wait_queue);
SM_I(sbi)->dcc_info = dcc;
diff --git a/fs/f2fs/segment.h b/fs/f2fs/segment.h
index 422b0ceb1eaa..63b4da72cd34 100644
--- a/fs/f2fs/segment.h
+++ b/fs/f2fs/segment.h
@@ -616,6 +616,15 @@ static inline int utilization(struct f2fs_sb_info *sbi)
sbi->user_block_count);
}
+static inline int dev_utilization(struct f2fs_sb_info *sbi)
+{
+ unsigned int dev_blks;
+
+ dev_blks = valid_user_blocks(sbi) + SM_I(sbi)->dcc_info->undiscard_blks;
+ return div_u64((u64)dev_blks * 100,
+ MAIN_SEGS(sbi) << sbi->log_blocks_per_seg);
+}
+
/*
* Sometimes f2fs may be better to drop out-of-place update policy.
* And, users can control the policy through sysfs entries.
diff --git a/fs/f2fs/super.c b/fs/f2fs/super.c
index b055f2ea77c5..55ed76daad23 100644
--- a/fs/f2fs/super.c
+++ b/fs/f2fs/super.c
@@ -2862,7 +2862,7 @@ static void f2fs_tuning_parameters(struct f2fs_sb_info *sbi)
/* adjust parameters according to the volume size */
if (sm_i->main_segments <= SMALL_VOLUME_SEGMENTS) {
F2FS_OPTION(sbi).alloc_mode = ALLOC_MODE_REUSE;
- sm_i->dcc_info->discard_granularity = 1;
+ sm_i->dcc_info->discard_granularity = MIN_DISCARD_GRANULARITY;
sm_i->ipu_policy = 1 << F2FS_IPU_FORCE;
}
--
2.18.0.rc1
Powered by blists - more mailing lists