With this option the user can specify the minimum number of
reclaimable blocks of a segment, before it can be cleaned. This is
a threshold for the GC to prevent needless moving of data. If
there are less reclaimable blocks in a segment than the specified
number, the GC will abort and try again with a different segment.
If there are less clean segments than min_clean_segments,
mc_min_reclaimable_blocks is used instead of
min_reclaimable_blocks. This allows for more flexibility in
configuring the GC.
The number of blocks can be specified in percent of a segment or
in bytes.
If the use_set_suinfo switch is not set, the optimization is
completely disabled.
Signed-off-by: Andreas Rohner <andreas.rohner@xxxxxxx>
---
man/nilfs_cleanerd.conf.5 | 22 +++++
sbin/cleanerd/cldconfig.c | 169 ++++++++++++++++++++++++++++----------
sbin/cleanerd/cldconfig.h | 12 +++
sbin/cleanerd/cleanerd.c | 10 +++
sbin/cleanerd/nilfs_cleanerd.conf | 20 +++++
5 files changed, 191 insertions(+), 42 deletions(-)
diff --git a/man/nilfs_cleanerd.conf.5 b/man/nilfs_cleanerd.conf.5
index 8f3fcd2..4315ecd 100644
--- a/man/nilfs_cleanerd.conf.5
+++ b/man/nilfs_cleanerd.conf.5
@@ -79,6 +79,28 @@ Specify whether to use \fBmmap\fP(2) for reading segments. At
present, this option is enabled if supported regardless of this
directive.
.TP
+.B use_set_suinfo
+Specify whether to use the set_suinfo ioctl if it is supported. This is
+necessary for the \fBmin_reclaimable_blocks\fP feature. By disabling this
+switch \fBmin_reclaimable_blocks\fP is also disabled.
+.TP
+.B min_reclaimable_blocks
+Specify the minimum number of reclaimable blocks in a segment before
+it can be cleaned.
+.TP
+.B mc_min_reclaimable_blocks
+Specify the minimum number of reclaimable blocks in a segment before
+it can be cleaned. if clean segments < min_clean_segments.
+.PP
+\fBmin_reclaimable_blocks\fP and \fBmc_min_reclaimable_blocks\fP may
+be followed by a percent sign or the following multiplicative suffixes:
+kB 1000, K 1024, MB 1000*1000, M 1024*1024, GB 1000*1000*1000, G
+1024*1024*1024, and so on for T, P, E. If the argument is followed by
+a percent sign, it represents the ratio of blocks in a segment.
+.PP
+The default values of \fBmin_reclaimable_blocks\fP and
+\fBmc_min_reclaimable_blocks\fP are 5 percent and 1 percent respectively.
+.TP
.B log_priority
Gives the verbosity level that is used when logging messages from
\fBnilfs_cleanerd\fP(8). The possible values are: \fBemerg\fP,
diff --git a/sbin/cleanerd/cldconfig.c b/sbin/cleanerd/cldconfig.c
index 270d360..bdd8c85 100644
--- a/sbin/cleanerd/cldconfig.c
+++ b/sbin/cleanerd/cldconfig.c
@@ -278,6 +278,55 @@ nilfs_cldconfig_handle_protection_period(struct nilfs_cldconfig *config,
}
static unsigned long long
+nilfs_convert_units_to_bytes(const struct nilfs_param *param)
+{
+ unsigned long long bytes = param->num;
+
+ switch (param->unit) {
+ case NILFS_SIZE_UNIT_KB:
+ bytes *= 1000ULL;
+ break;
+ case NILFS_SIZE_UNIT_KIB:
+ bytes <<= 10;
+ break;
+ case NILFS_SIZE_UNIT_MB:
+ bytes *= 1000000ULL;
+ break;
+ case NILFS_SIZE_UNIT_MIB:
+ bytes <<= 20;
+ break;
+ case NILFS_SIZE_UNIT_GB:
+ bytes *= 1000000000ULL;
+ break;
+ case NILFS_SIZE_UNIT_GIB:
+ bytes <<= 30;
+ break;
+ case NILFS_SIZE_UNIT_TB:
+ bytes *= 1000000000000ULL;
+ break;
+ case NILFS_SIZE_UNIT_TIB:
+ bytes <<= 40;
+ break;
+ case NILFS_SIZE_UNIT_PB:
+ bytes *= 1000000000000000ULL;
+ break;
+ case NILFS_SIZE_UNIT_PIB:
+ bytes <<= 50;
+ break;
+ case NILFS_SIZE_UNIT_EB:
+ bytes *= 1000000000000000000ULL;
+ break;
+ case NILFS_SIZE_UNIT_EIB:
+ bytes <<= 60;
+ break;
+ default:
+ assert(0);
+ }
+
+ return bytes;
+}
+
+static unsigned long long
nilfs_convert_size_to_nsegments(struct nilfs *nilfs, struct nilfs_param *param)
{
unsigned long long ret, segment_size, bytes;
@@ -287,48 +336,7 @@ nilfs_convert_size_to_nsegments(struct nilfs *nilfs, struct nilfs_param *param)
} else if (param->unit == NILFS_SIZE_UNIT_PERCENT) {
ret = (nilfs_get_nsegments(nilfs) * param->num + 99) / 100;
} else {
- bytes = param->num;
-
- switch (param->unit) {
- case NILFS_SIZE_UNIT_KB:
- bytes *= 1000ULL;
- break;
- case NILFS_SIZE_UNIT_KIB:
- bytes <<= 10;
- break;
- case NILFS_SIZE_UNIT_MB:
- bytes *= 1000000ULL;
- break;
- case NILFS_SIZE_UNIT_MIB:
- bytes <<= 20;
- break;
- case NILFS_SIZE_UNIT_GB:
- bytes *= 1000000000ULL;
- break;
- case NILFS_SIZE_UNIT_GIB:
- bytes <<= 30;
- break;
- case NILFS_SIZE_UNIT_TB:
- bytes *= 1000000000000ULL;
- break;
- case NILFS_SIZE_UNIT_TIB:
- bytes <<= 40;
- break;
- case NILFS_SIZE_UNIT_PB:
- bytes *= 1000000000000000ULL;
- break;
- case NILFS_SIZE_UNIT_PIB:
- bytes <<= 50;
- break;
- case NILFS_SIZE_UNIT_EB:
- bytes *= 1000000000000000000ULL;
- break;
- case NILFS_SIZE_UNIT_EIB:
- bytes <<= 60;
- break;
- default:
- assert(0);
- }
+ bytes = nilfs_convert_units_to_bytes(param);
segment_size = nilfs_get_block_size(nilfs) *
nilfs_get_blocks_per_segment(nilfs);
ret = (bytes + segment_size - 1) / segment_size;
@@ -455,6 +463,52 @@ nilfs_cldconfig_handle_mc_nsegments_per_clean(struct nilfs_cldconfig *config,
return 0;
}
+static unsigned long long
+nilfs_convert_size_to_blocks_per_segment(struct nilfs *nilfs,
+ struct nilfs_param *param)
+{
+ unsigned long long ret, segment_size, block_size, bytes;
+
+ if (param->unit == NILFS_SIZE_UNIT_NONE) {
+ ret = param->num;
+ } else if (param->unit == NILFS_SIZE_UNIT_PERCENT) {
+ ret = (nilfs_get_blocks_per_segment(nilfs) * param->num) / 100;
+ } else {
+ block_size = nilfs_get_block_size(nilfs);
+ segment_size = block_size *
+ nilfs_get_blocks_per_segment(nilfs);
+ bytes = nilfs_convert_units_to_bytes(param) % segment_size;
+ ret = (bytes + block_size - 1) / block_size;
+ }
+ return ret;
+}
+
+static int
+nilfs_cldconfig_handle_min_reclaimable_blocks(struct nilfs_cldconfig *config,
+ char **tokens, size_t ntoks,
+ struct nilfs *nilfs)
+{
+ struct nilfs_param param;
+
+ if (nilfs_cldconfig_get_size_argument(tokens, ntoks, ¶m) == 0)
+ config->cf_min_reclaimable_blocks =
+ nilfs_convert_size_to_blocks_per_segment(nilfs, ¶m);
+ return 0;
+}
+
+static int
+nilfs_cldconfig_handle_mc_min_reclaimable_blocks(struct nilfs_cldconfig *config,
+ char **tokens, size_t ntoks,
+ struct nilfs *nilfs)
+{
+ struct nilfs_param param;
+
+ if (nilfs_cldconfig_get_size_argument(tokens, ntoks, ¶m) == 0)
+ config->cf_mc_min_reclaimable_blocks =
+ nilfs_convert_size_to_blocks_per_segment(nilfs, ¶m);
+ return 0;
+}
+
static int
nilfs_cldconfig_handle_cleaning_interval(struct nilfs_cldconfig *config,
char **tokens, size_t ntoks,
@@ -490,6 +544,14 @@ static int nilfs_cldconfig_handle_use_mmap(struct nilfs_cldconfig *config,
return 0;
}
+static int nilfs_cldconfig_handle_use_set_suinfo(struct nilfs_cldconfig *config,
+ char **tokens, size_t ntoks,
+ struct nilfs *nilfs)
+{
+ config->cf_use_set_suinfo = 1;
+ return 0;
+}
+
static const struct nilfs_cldconfig_log_priority
nilfs_cldconfig_log_priority_table[] = {
{"emerg", LOG_EMERG},
@@ -576,6 +638,18 @@ nilfs_cldconfig_keyword_table[] = {
"log_priority", 2, 2,
nilfs_cldconfig_handle_log_priority
},
+ {
+ "min_reclaimable_blocks", 2, 2,
+ nilfs_cldconfig_handle_min_reclaimable_blocks
+ },
+ {
+ "mc_min_reclaimable_blocks", 2, 2,
+ nilfs_cldconfig_handle_mc_min_reclaimable_blocks
+ },
+ {
+ "use_set_suinfo", 1, 1,
+ nilfs_cldconfig_handle_use_set_suinfo
+ },
};
#define NILFS_CLDCONFIG_NKEYWORDS \
@@ -640,7 +714,18 @@ static void nilfs_cldconfig_set_default(struct nilfs_cldconfig *config,
config->cf_retry_interval.tv_sec = NILFS_CLDCONFIG_RETRY_INTERVAL;
config->cf_retry_interval.tv_usec = 0;
config->cf_use_mmap = NILFS_CLDCONFIG_USE_MMAP;
+ config->cf_use_set_suinfo = NILFS_CLDCONFIG_USE_SET_SUINFO;
config->cf_log_priority = NILFS_CLDCONFIG_LOG_PRIORITY;
+
+ param.num = NILFS_CLDCONFIG_MIN_RECLAIMABLE_BLOCKS;
+ param.unit = NILFS_CLDCONFIG_MIN_RECLAIMABLE_BLOCKS_UNIT;
+ config->cf_min_reclaimable_blocks =
+ nilfs_convert_size_to_blocks_per_segment(nilfs, ¶m);
+
+ param.num = NILFS_CLDCONFIG_MC_MIN_RECLAIMABLE_BLOCKS;
+ param.unit = NILFS_CLDCONFIG_MC_MIN_RECLAIMABLE_BLOCKS_UNIT;
+ config->cf_mc_min_reclaimable_blocks =
+ nilfs_convert_size_to_blocks_per_segment(nilfs, ¶m);
}
static inline int iseol(int c)
diff --git a/sbin/cleanerd/cldconfig.h b/sbin/cleanerd/cldconfig.h
index 188ce9b..0a598d5 100644
--- a/sbin/cleanerd/cldconfig.h
+++ b/sbin/cleanerd/cldconfig.h
@@ -87,7 +87,11 @@ enum nilfs_size_unit {
* if clean segments < min_clean_segments
* @cf_retry_interval: retry interval
* @cf_use_mmap: flag that indicate using mmap
+ * @cf_use_set_suinfo: flag that indicates the use of the set_suinfo ioctl
* @cf_log_priority: log priority level
+ * @cf_min_reclaimable_blocks: minimum reclaimable blocks for cleaning
+ * @cf_mc_min_reclaimable_blocks: minimum reclaimable blocks for cleaning
+ * if clean segments < min_clean_segments
*/
struct nilfs_cldconfig {
struct nilfs_selection_policy cf_selection_policy;
@@ -101,7 +105,10 @@ struct nilfs_cldconfig {
struct timeval cf_mc_cleaning_interval;
struct timeval cf_retry_interval;
int cf_use_mmap;
+ int cf_use_set_suinfo;
int cf_log_priority;
+ unsigned long cf_min_reclaimable_blocks;
+ unsigned long cf_mc_min_reclaimable_blocks;
};
#define NILFS_CLDCONFIG_SELECTION_POLICY_IMPORTANCE \
@@ -119,7 +126,12 @@ struct nilfs_cldconfig {
#define NILFS_CLDCONFIG_MC_CLEANING_INTERVAL 1
#define NILFS_CLDCONFIG_RETRY_INTERVAL 60
#define NILFS_CLDCONFIG_USE_MMAP 1
+#define NILFS_CLDCONFIG_USE_SET_SUINFO 0
#define NILFS_CLDCONFIG_LOG_PRIORITY LOG_INFO
+#define NILFS_CLDCONFIG_MIN_RECLAIMABLE_BLOCKS 5
+#define NILFS_CLDCONFIG_MIN_RECLAIMABLE_BLOCKS_UNIT NILFS_SIZE_UNIT_PERCENT
+#define NILFS_CLDCONFIG_MC_MIN_RECLAIMABLE_BLOCKS 1
+#define NILFS_CLDCONFIG_MC_MIN_RECLAIMABLE_BLOCKS_UNIT NILFS_SIZE_UNIT_PERCENT
#define NILFS_CLDCONFIG_NSEGMENTS_PER_CLEAN_MAX 32
diff --git a/sbin/cleanerd/cleanerd.c b/sbin/cleanerd/cleanerd.c
index 1d09b5b..c58a542 100644
--- a/sbin/cleanerd/cleanerd.c
+++ b/sbin/cleanerd/cleanerd.c
@@ -145,6 +145,7 @@ const static struct option long_option[] = {
* @cleaning_interval: cleaning interval
* @target: target time for sleeping
* @timeout: timeout value for sleeping
+ * @min_reclaimable_blocks: min. number of reclaimable blocks
* @prev_nongc_ctime: previous nongc ctime
* @recvq: receive queue
* @recvq_name: receive queue name
@@ -172,6 +173,7 @@ struct nilfs_cleanerd {
struct timeval cleaning_interval;
struct timeval target;
struct timeval timeout;
+ unsigned long min_reclaimable_blocks;
__u64 prev_nongc_ctime;
mqd_t recvq;
char *recvq_name;
@@ -273,6 +275,8 @@ static int nilfs_cleanerd_reconfig(struct nilfs_cleanerd *cleanerd,
} else {
cleanerd->ncleansegs = config->cf_nsegments_per_clean;
cleanerd->cleaning_interval = config->cf_cleaning_interval;
+ cleanerd->min_reclaimable_blocks =
+ config->cf_min_reclaimable_blocks;
syslog(LOG_INFO, "configuration file reloaded");
}
return ret;
@@ -1238,10 +1242,14 @@ static int nilfs_cleanerd_handle_clean_check(struct nilfs_cleanerd *cleanerd,
/* disk space is close to limit -- accelerate cleaning */
cleanerd->ncleansegs = config->cf_mc_nsegments_per_clean;
cleanerd->cleaning_interval = config->cf_mc_cleaning_interval;
+ cleanerd->min_reclaimable_blocks =
+ config->cf_mc_min_reclaimable_blocks;
} else {
/* continue to run */
cleanerd->ncleansegs = config->cf_nsegments_per_clean;
cleanerd->cleaning_interval = config->cf_cleaning_interval;
+ cleanerd->min_reclaimable_blocks =
+ config->cf_min_reclaimable_blocks;
}
return 0; /* do gc */
@@ -1442,6 +1450,8 @@ static int nilfs_cleanerd_clean_loop(struct nilfs_cleanerd *cleanerd)
cleanerd->ncleansegs = cleanerd->config.cf_nsegments_per_clean;
cleanerd->cleaning_interval = cleanerd->config.cf_cleaning_interval;
+ cleanerd->min_reclaimable_blocks =
+ cleanerd->config.cf_min_reclaimable_blocks;
if (nilfs_cleanerd_automatic_suspend(cleanerd))
diff --git a/sbin/cleanerd/nilfs_cleanerd.conf b/sbin/cleanerd/nilfs_cleanerd.conf
index 26872aa..79d3fce 100644
--- a/sbin/cleanerd/nilfs_cleanerd.conf
+++ b/sbin/cleanerd/nilfs_cleanerd.conf
@@ -51,6 +51,26 @@ mc_cleaning_interval 1
# Retry interval in seconds.
retry_interval 60
+# Specify the minimum number of reclaimable blocks in a segment
+# before it can be cleaned.
+min_reclaimable_blocks 5%
+
+# Specify the minimum number of reclaimable blocks in a segment
+# before it can be cleaned.
+# if clean segments < min_clean_segments
+mc_min_reclaimable_blocks 1%
+
+# The argument of min_reclaimable_blocks and mc_min_reclaimable_blocks
+# can be followed by a percent sign (%) or one of the following
+# multiplicative suffixes similar to min_clean_segments.
+#
+# If the argument is followed by "%", it represents a ratio for the
+# number of blocks per segment.
+
+# enable set_suinfo ioctl if supported
+# (needed for min_reclaimable_blocks)
+#use_set_suinfo
+
# Use mmap when reading segments if supported.
use_mmap
--
1.8.5.4
--
To unsubscribe from this list: send the line "unsubscribe linux-nilfs" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
