With this option the user can specify the minimal number of free/dead blocks before a segment can be cleaned. This is a threshold for the GC to prevent needless moving of data. If there are less free blocks to gain from cleaning a segment than the specified number, the GC will abort and try again with a different segment.
By setting it to 0 this feature is effectively disabled. Signed-off-by: Andreas Rohner <[email protected]> --- include/nilfs_cleaner.h | 19 ++++++++++--------- sbin/cleanerd/cldconfig.c | 40 +++++++++++++++++++++++++++++++++++++++ sbin/cleanerd/cldconfig.h | 4 ++++ sbin/cleanerd/cleanerd.c | 23 ++++++++++++++++++++++ sbin/cleanerd/nilfs_cleanerd.conf | 9 +++++++++ sbin/nilfs-clean/nilfs-clean.c | 18 ++++++++++++++---- 6 files changed, 100 insertions(+), 13 deletions(-) diff --git a/include/nilfs_cleaner.h b/include/nilfs_cleaner.h index 0bf02aa..42c4aa7 100644 --- a/include/nilfs_cleaner.h +++ b/include/nilfs_cleaner.h @@ -46,17 +46,18 @@ struct nilfs_cleaner_args { uint64_t start_segnum; /* start segment number */ uint64_t nsegs; /* number of segments */ uint32_t runtime; /* runtime in seconds */ - uint32_t pad2; + uint32_t min_free_blocks_threshold; }; /* valid flags */ -#define NILFS_CLEANER_ARG_PROTECTION_PERIOD (1 << 0) -#define NILFS_CLEANER_ARG_NSEGMENTS_PER_CLEAN (1 << 1) -#define NILFS_CLEANER_ARG_CLEANING_INTERVAL (1 << 2) -#define NILFS_CLEANER_ARG_USAGE_RATE_THRESHOLD (1 << 3) /* reserved */ -#define NILFS_CLEANER_ARG_START_SEGNUM (1 << 4) /* reserved */ -#define NILFS_CLEANER_ARG_NSEGS (1 << 5) /* reserved */ -#define NILFS_CLEANER_ARG_NPASSES (1 << 6) /* reserved */ -#define NILFS_CLEANER_ARG_RUNTIME (1 << 7) /* reserved */ +#define NILFS_CLEANER_ARG_PROTECTION_PERIOD (1 << 0) +#define NILFS_CLEANER_ARG_NSEGMENTS_PER_CLEAN (1 << 1) +#define NILFS_CLEANER_ARG_CLEANING_INTERVAL (1 << 2) +#define NILFS_CLEANER_ARG_USAGE_RATE_THRESHOLD (1 << 3) /* reserved */ +#define NILFS_CLEANER_ARG_START_SEGNUM (1 << 4) /* reserved */ +#define NILFS_CLEANER_ARG_NSEGS (1 << 5) /* reserved */ +#define NILFS_CLEANER_ARG_NPASSES (1 << 6) /* reserved */ +#define NILFS_CLEANER_ARG_RUNTIME (1 << 7) /* reserved */ +#define NILFS_CLEANER_ARG_MIN_FREE_BLOCKS_THRESHOLD (1 << 8) enum { NILFS_CLEANER_STATUS_IDLE, diff --git a/sbin/cleanerd/cldconfig.c b/sbin/cleanerd/cldconfig.c index 270d360..4d7589c 100644 --- a/sbin/cleanerd/cldconfig.c +++ b/sbin/cleanerd/cldconfig.c @@ -456,6 +456,34 @@ nilfs_cldconfig_handle_mc_nsegments_per_clean(struct nilfs_cldconfig *config, } static int +nilfs_cldconfig_handle_min_free_blocks(struct nilfs_cldconfig *config, + char **tokens, size_t ntoks, + struct nilfs *nilfs) +{ + unsigned long n; + + if (nilfs_cldconfig_get_ulong_argument(tokens, ntoks, &n) < 0) + return 0; + + config->cf_min_free_blocks_threshold = n; + return 0; +} + +static int +nilfs_cldconfig_handle_mc_min_free_blocks(struct nilfs_cldconfig *config, + char **tokens, size_t ntoks, + struct nilfs *nilfs) +{ + unsigned long n; + + if (nilfs_cldconfig_get_ulong_argument(tokens, ntoks, &n) < 0) + return 0; + + config->cf_mc_min_free_blocks_threshold = n; + return 0; +} + +static int nilfs_cldconfig_handle_cleaning_interval(struct nilfs_cldconfig *config, char **tokens, size_t ntoks, struct nilfs *nilfs) @@ -576,6 +604,14 @@ nilfs_cldconfig_keyword_table[] = { "log_priority", 2, 2, nilfs_cldconfig_handle_log_priority }, + { + "min_free_blocks_threshold", 2, 2, + nilfs_cldconfig_handle_min_free_blocks + }, + { + "mc_min_free_blocks_threshold", 2, 2, + nilfs_cldconfig_handle_mc_min_free_blocks + }, }; #define NILFS_CLDCONFIG_NKEYWORDS \ @@ -641,6 +677,10 @@ static void nilfs_cldconfig_set_default(struct nilfs_cldconfig *config, config->cf_retry_interval.tv_usec = 0; config->cf_use_mmap = NILFS_CLDCONFIG_USE_MMAP; config->cf_log_priority = NILFS_CLDCONFIG_LOG_PRIORITY; + config->cf_min_free_blocks_threshold = + NILFS_CLDCONFIG_MIN_FREE_BLOCKS_THRESHOLD; + config->cf_mc_min_free_blocks_threshold = + NILFS_CLDCONFIG_MC_MIN_FREE_BLOCKS_THRESHOLD; } static inline int iseol(int c) diff --git a/sbin/cleanerd/cldconfig.h b/sbin/cleanerd/cldconfig.h index 188ce9b..49ee6be 100644 --- a/sbin/cleanerd/cldconfig.h +++ b/sbin/cleanerd/cldconfig.h @@ -102,6 +102,8 @@ struct nilfs_cldconfig { struct timeval cf_retry_interval; int cf_use_mmap; int cf_log_priority; + unsigned long cf_min_free_blocks_threshold; + unsigned long cf_mc_min_free_blocks_threshold; }; #define NILFS_CLDCONFIG_SELECTION_POLICY_IMPORTANCE \ @@ -120,6 +122,8 @@ struct nilfs_cldconfig { #define NILFS_CLDCONFIG_RETRY_INTERVAL 60 #define NILFS_CLDCONFIG_USE_MMAP 1 #define NILFS_CLDCONFIG_LOG_PRIORITY LOG_INFO +#define NILFS_CLDCONFIG_MIN_FREE_BLOCKS_THRESHOLD 256 +#define NILFS_CLDCONFIG_MC_MIN_FREE_BLOCKS_THRESHOLD 128 #define NILFS_CLDCONFIG_NSEGMENTS_PER_CLEAN_MAX 32 diff --git a/sbin/cleanerd/cleanerd.c b/sbin/cleanerd/cleanerd.c index 86dfcf7..eb6eace 100644 --- a/sbin/cleanerd/cleanerd.c +++ b/sbin/cleanerd/cleanerd.c @@ -172,6 +172,7 @@ struct nilfs_cleanerd { struct timeval cleaning_interval; struct timeval target; struct timeval timeout; + unsigned long min_free_blocks_threshold; __u64 prev_nongc_ctime; mqd_t recvq; char *recvq_name; @@ -184,6 +185,7 @@ struct nilfs_cleanerd { long mm_ncleansegs; struct timeval mm_protection_period; struct timeval mm_cleaning_interval; + unsigned long mm_min_free_blocks_threshold; }; /** @@ -459,6 +461,14 @@ nilfs_cleanerd_protection_period(struct nilfs_cleanerd *cleanerd) &cleanerd->config.cf_protection_period; } +static unsigned long +nilfs_cleanerd_min_free_blocks_threshold(struct nilfs_cleanerd *cleanerd) +{ + return cleanerd->running == 2 ? + cleanerd->mm_min_free_blocks_threshold : + cleanerd->min_free_blocks_threshold; +} + static void nilfs_cleanerd_reduce_ncleansegs_for_retry(struct nilfs_cleanerd *cleanerd) { @@ -998,6 +1008,13 @@ static int nilfs_cleanerd_cmd_run(struct nilfs_cleanerd *cleanerd, cleanerd->mm_cleaning_interval = cleanerd->cleaning_interval; } + /* minimal free blocks threshold */ + if (req2->args.valid & NILFS_CLEANER_ARG_MIN_FREE_BLOCKS_THRESHOLD) { + cleanerd->mm_min_free_blocks_threshold = + req2->args.min_free_blocks_threshold; + } else { + cleanerd->mm_min_free_blocks_threshold = 0; + } /* number of passes */ if (req2->args.valid & NILFS_CLEANER_ARG_NPASSES) { if (!req2->args.npasses) @@ -1235,10 +1252,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_free_blocks_threshold = + config->cf_mc_min_free_blocks_threshold; } else { /* continue to run */ cleanerd->ncleansegs = config->cf_nsegments_per_clean; cleanerd->cleaning_interval = config->cf_cleaning_interval; + cleanerd->min_free_blocks_threshold = + config->cf_min_free_blocks_threshold; } return 0; /* do gc */ @@ -1424,6 +1445,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_free_blocks_threshold = + cleanerd->config.cf_min_free_blocks_threshold; if (nilfs_cleanerd_automatic_suspend(cleanerd)) diff --git a/sbin/cleanerd/nilfs_cleanerd.conf b/sbin/cleanerd/nilfs_cleanerd.conf index 26872aa..23ef8de 100644 --- a/sbin/cleanerd/nilfs_cleanerd.conf +++ b/sbin/cleanerd/nilfs_cleanerd.conf @@ -51,6 +51,15 @@ mc_cleaning_interval 1 # Retry interval in seconds. retry_interval 60 +# Minimal number of free blocks before a segment +# can be cleaned. Set to 0 to disable it. +min_free_blocks_threshold 256 + +# Minimal number of free blocks before a segment +# can be cleaned. Set to 0 to disable it. +# if clean segments < min_clean_segments +mc_min_free_blocks_threshold 128 + # Use mmap when reading segments if supported. use_mmap diff --git a/sbin/nilfs-clean/nilfs-clean.c b/sbin/nilfs-clean/nilfs-clean.c index 55abd55..23b7e61 100644 --- a/sbin/nilfs-clean/nilfs-clean.c +++ b/sbin/nilfs-clean/nilfs-clean.c @@ -77,6 +77,7 @@ const static struct option long_option[] = { {"stop", no_argument, NULL, 'b'}, {"suspend", no_argument, NULL, 's'}, {"speed", required_argument, NULL, 'S'}, + {"free-blocks-threshold", optional_argument, NULL, 't'}, {"verbose", no_argument, NULL, 'v'}, {"version", no_argument, NULL, 'V'}, {NULL, 0, NULL, 0} @@ -95,12 +96,15 @@ const static struct option long_option[] = { " -s, --suspend\t\tsuspend cleaner\n" \ " -S, --speed=COUNT[/SECONDS]\n" \ " \t\tset GC speed\n" \ + " -t, --free-blocks-threshold=COUNT\n" \ + " \t\tset minimal number of free blocks before\n" \ + " \t\ta segment can be cleaned\n" \ " -v, --verbose\t\tverbose mode\n" \ " -V, --version\t\tdisplay version and exit\n" #else #define NILFS_CLEAN_USAGE \ "Usage: %s [-b] [-c [conffile]] [-h] [-l] [-p protection-period]" \ - " [-q] [-r] [-s] [-S gc-speed] [-v] [-V] [device]\n" + " [-q] [-r] [-s] [-S gc-speed] [-t blocks][-v] [-V] [device]\n" #endif /* _GNU_SOURCE */ @@ -124,6 +128,7 @@ static const char *conffile = NULL; static unsigned long protection_period = ULONG_MAX; static int nsegments_per_clean = 2; static struct timespec cleaning_interval = { 0, 100000000 }; /* 100 msec */ +static unsigned long min_free_blocks_threshold; static sigjmp_buf nilfs_clean_env; static struct nilfs_cleaner *nilfs_cleaner; @@ -164,9 +169,11 @@ static int nilfs_clean_do_run(struct nilfs_cleaner *cleaner) args.nsegments_per_clean = nsegments_per_clean; args.cleaning_interval = cleaning_interval.tv_sec; args.cleaning_interval_nsec = cleaning_interval.tv_nsec; + args.min_free_blocks_threshold = min_free_blocks_threshold; args.valid = (NILFS_CLEANER_ARG_NPASSES | NILFS_CLEANER_ARG_CLEANING_INTERVAL | - NILFS_CLEANER_ARG_NSEGMENTS_PER_CLEAN); + NILFS_CLEANER_ARG_NSEGMENTS_PER_CLEAN | + NILFS_CLEANER_ARG_MIN_FREE_BLOCKS_THRESHOLD); if (protection_period != ULONG_MAX) { args.protection_period = protection_period; @@ -434,10 +441,10 @@ static void nilfs_clean_parse_options(int argc, char *argv[]) int c; #ifdef _GNU_SOURCE - while ((c = getopt_long(argc, argv, "bc::hlp:qrsS:vV", + while ((c = getopt_long(argc, argv, "bc::hlp:qrsS:t:vV", long_option, &option_index)) >= 0) { #else - while ((c = getopt(argc, argv, "bc::hlp:qrsS:vV")) >= 0) { + while ((c = getopt(argc, argv, "bc::hlp:qrsS:t:vV")) >= 0) { #endif /* _GNU_SOURCE */ switch (c) { case 'b': @@ -472,6 +479,9 @@ static void nilfs_clean_parse_options(int argc, char *argv[]) if (nilfs_clean_parse_gcspeed(optarg) < 0) exit(EXIT_FAILURE); break; + case 't': + min_free_blocks_threshold = strtoul(optarg, NULL, 10); + break; case 'v': verbose = 1; break; -- 1.8.5.3 -- To unsubscribe from this list: send the line "unsubscribe linux-nilfs" in the body of a message to [email protected] More majordomo info at http://vger.kernel.org/majordomo-info.html
