From 222b3355ee441ab4a310ef2830181ffd4300223b Mon Sep 17 00:00:00 2001 From: Andre Noll Date: Sat, 22 Mar 2008 14:37:09 +0100 Subject: [PATCH] Move snapshot helpers to new file snap.[ch]. --- Makefile | 2 +- dss.c | 955 +++++++++++++++++++++---------------------------------- snap.c | 217 +++++++++++++ snap.h | 72 +++++ time.c | 15 + time.h | 1 + 6 files changed, 660 insertions(+), 602 deletions(-) create mode 100644 snap.c create mode 100644 snap.h diff --git a/Makefile b/Makefile index 55f9e3c..b1ba12c 100644 --- a/Makefile +++ b/Makefile @@ -1,4 +1,4 @@ -dss_objects := cmdline.o dss.o string.o fd.o exec.o signal.o daemon.o df.o time.o +dss_objects := cmdline.o dss.o string.o fd.o exec.o signal.o daemon.o df.o time.o snap.o all: dss man: dss.1 diff --git a/dss.c b/dss.c index 3d00b0b..4a14c4b 100644 --- a/dss.c +++ b/dss.c @@ -27,9 +27,10 @@ #include "signal.h" #include "df.h" #include "time.h" +#include "snap.h" -struct gengetopt_args_info conf; +static struct gengetopt_args_info conf; static FILE *logfile; static int signal_pipe; @@ -45,27 +46,11 @@ struct timeval next_snapshot_time; pid_t pre_create_hook_pid; /** The pid of the post-create hook. */ pid_t post_create_hook_pid; - /* Creation time of the snapshot currently being created. */ int64_t current_snapshot_creation_time; static char *path_to_last_complete_snapshot; -enum { - /** We are ready to take the next snapshot. */ - SCS_READY, - /** The pre-creation hook has been started. */ - SCS_PRE_HOOK_RUNNING, - /** The pre-creation hook exited successfully. */ - SCS_PRE_HOOK_SUCCESS, - /** The rsync process is running. */ - SCS_RSYNC_RUNNING, - /** The rsync process exited successfully. */ - SCS_RSYNC_SUCCESS, - /** The post-create hook has been started- */ - SCS_POST_HOOK_RUNNING, -}; - static unsigned snapshot_creation_status; @@ -91,27 +76,6 @@ int call_command_handler(void) #undef COMMAND #undef COMMANDS -/* - * complete, not being deleted: 1204565370-1204565371.Sun_Mar_02_2008_14_33-Sun_Mar_02_2008_14_43 - * complete, being deleted: 1204565370-1204565371.being_deleted - * incomplete, not being deleted: 1204565370-incomplete - * incomplete, being deleted: 1204565370-incomplete.being_deleted - */ -enum snapshot_status_flags { - /** The rsync process terminated successfully. */ - SS_COMPLETE = 1, - /** The rm process is running to remove this snapshot. */ - SS_BEING_DELETED = 2, -}; - -struct snapshot { - char *name; - int64_t creation_time; - int64_t completion_time; - enum snapshot_status_flags flags; - unsigned interval; -}; - __printf_2_3 void dss_log(int ll, const char* fmt,...) { va_list argp; @@ -146,279 +110,72 @@ __printf_1_2 void dss_msg(const char* fmt,...) va_end(argp); } -/** - * Return the desired number of snapshots of an interval. - */ -unsigned num_snapshots(int interval) -{ - unsigned n; - - assert(interval >= 0); - - if (interval >= conf.num_intervals_arg) - return 0; - n = conf.num_intervals_arg - interval - 1; - return 1 << n; -} - -/* return: Whether dirname is a snapshot directory (0: no, 1: yes) */ -int is_snapshot(const char *dirname, int64_t now, struct snapshot *s) +/* TODO: Also consider number of inodes. */ +int disk_space_low(void) { - int i, ret; - char *dash, *dot, *tmp; - int64_t num; + struct disk_space ds; + int ret = get_disk_space(".", &ds); - assert(dirname); - dash = strchr(dirname, '-'); - if (!dash || !dash[1] || dash == dirname) - return 0; - for (i = 0; dirname[i] != '-'; i++) - if (!isdigit(dirname[i])) - return 0; - tmp = dss_strdup(dirname); - tmp[i] = '\0'; - ret = dss_atoi64(tmp, &num); - free(tmp); if (ret < 0) - return 0; - assert(num >= 0); - if (num > now) - return 0; - s->creation_time = num; - //DSS_DEBUG_LOG("%s start time: %lli\n", dirname, (long long)s->creation_time); - s->interval = (long long) ((now - s->creation_time) - / conf.unit_interval_arg / 24 / 3600); - if (!strcmp(dash + 1, "incomplete")) { - s->completion_time = -1; - s->flags = 0; /* neither complete, nor being deleted */ - goto success; - } - if (!strcmp(dash + 1, "incomplete.being_deleted")) { - s->completion_time = -1; - s->flags = SS_BEING_DELETED; /* mot cpmplete, being deleted */ - goto success; - } - tmp = dash + 1; - dot = strchr(tmp, '.'); - if (!dot || !dot[1] || dot == tmp) - return 0; - for (i = 0; tmp[i] != '.'; i++) - if (!isdigit(tmp[i])) - return 0; - tmp = dss_strdup(dash + 1); - tmp[i] = '\0'; - ret = dss_atoi64(tmp, &num); - free(tmp); - if (ret < 0) - return 0; - if (num > now) - return 0; - s->completion_time = num; - s->flags = SS_COMPLETE; - if (!strcmp(dot + 1, "being_deleted")) - s->flags |= SS_BEING_DELETED; -success: - s->name = dss_strdup(dirname); - return 1; -} - -int64_t get_current_time(void) -{ - time_t now; - time(&now); - DSS_DEBUG_LOG("now: %lli\n", (long long) now); - return (int64_t)now; -} - -char *incomplete_name(int64_t start) -{ - return make_message("%lli-incomplete", (long long)start); -} - -char *being_deleted_name(struct snapshot *s) -{ - if (s->flags & SS_COMPLETE) - return make_message("%lli-%lli.being_deleted", - (long long)s->creation_time, - (long long)s->completion_time); - return make_message("%lli-incomplete.being_deleted", - (long long)s->creation_time); -} - -int complete_name(int64_t start, int64_t end, char **result) -{ - struct tm start_tm, end_tm; - time_t *start_seconds = (time_t *) (uint64_t *)&start; /* STFU, gcc */ - time_t *end_seconds = (time_t *) (uint64_t *)&end; /* STFU, gcc */ - char start_str[200], end_str[200]; - - if (!localtime_r(start_seconds, &start_tm)) - return -E_LOCALTIME; - if (!localtime_r(end_seconds, &end_tm)) - return -E_LOCALTIME; - if (!strftime(start_str, sizeof(start_str), "%a_%b_%d_%Y_%H_%M_%S", &start_tm)) - return -E_STRFTIME; - if (!strftime(end_str, sizeof(end_str), "%a_%b_%d_%Y_%H_%M_%S", &end_tm)) - return -E_STRFTIME; - *result = make_message("%lli-%lli.%s-%s", (long long) start, (long long) end, - start_str, end_str); - return 1; -} - -struct snapshot_list { - int64_t now; - unsigned num_snapshots; - unsigned array_size; - struct snapshot **snapshots; - /** - * Array of size num_intervals + 1 - * - * It contains the number of snapshots in each interval. interval_count[num_intervals] - * is the number of snapshots which belong to any interval greater than num_intervals. - */ - unsigned *interval_count; -}; - -#define FOR_EACH_SNAPSHOT(s, i, sl) \ - for ((i) = 0; (i) < (sl)->num_snapshots && ((s) = (sl)->snapshots[(i)]); (i)++) - -#define FOR_EACH_SNAPSHOT_REVERSE(s, i, sl) \ - for ((i) = (sl)->num_snapshots; (i) > 0 && ((s) = (sl)->snapshots[(i - 1)]); (i)--) - -static inline struct snapshot *oldest_snapshot(struct snapshot_list *sl) -{ - if (!sl->num_snapshots) - return NULL; - return sl->snapshots[0]; -} - -#define NUM_COMPARE(x, y) ((int)((x) < (y)) - (int)((x) > (y))) - -static int compare_snapshots(const void *a, const void *b) -{ - struct snapshot *s1 = *(struct snapshot **)a; - struct snapshot *s2 = *(struct snapshot **)b; - return NUM_COMPARE(s2->creation_time, s1->creation_time); -} - -/** Compute the minimum of \a a and \a b. */ -#define DSS_MIN(a,b) ((a) < (b) ? (a) : (b)) - -int add_snapshot(const char *dirname, void *private) -{ - struct snapshot_list *sl = private; - struct snapshot s; - int ret = is_snapshot(dirname, sl->now, &s); - - if (!ret) - return 1; - if (sl->num_snapshots >= sl->array_size) { - sl->array_size = 2 * sl->array_size + 1; - sl->snapshots = dss_realloc(sl->snapshots, - sl->array_size * sizeof(struct snapshot *)); - } - sl->snapshots[sl->num_snapshots] = dss_malloc(sizeof(struct snapshot)); - *(sl->snapshots[sl->num_snapshots]) = s; - sl->interval_count[DSS_MIN(s.interval, conf.num_intervals_arg)]++; - sl->num_snapshots++; - return 1; -} - -void get_snapshot_list(struct snapshot_list *sl) -{ - sl->now = get_current_time(); - sl->num_snapshots = 0; - sl->array_size = 0; - sl->snapshots = NULL; - sl->interval_count = dss_calloc((conf.num_intervals_arg + 1) * sizeof(unsigned)); - for_each_subdir(add_snapshot, sl); - qsort(sl->snapshots, sl->num_snapshots, sizeof(struct snapshot *), - compare_snapshots); -} - -void free_snapshot_list(struct snapshot_list *sl) -{ - int i; - struct snapshot *s; - - FOR_EACH_SNAPSHOT(s, i, sl) { - free(s->name); - free(s); - } - free(sl->interval_count); - sl->interval_count = NULL; - free(sl->snapshots); - sl->snapshots = NULL; - sl->num_snapshots = 0; -} - -void stop_rsync_process(void) -{ - if (!rsync_pid || rsync_stopped) - return; - kill(SIGSTOP, rsync_pid); - rsync_stopped = 1; + return ret; + if (conf.min_free_mb_arg) + if (ds.free_mb < conf.min_free_mb_arg) + return 1; + if (conf.min_free_percent_arg) + if (ds.percent_free < conf.min_free_percent_arg) + return 1; + return 0; } -void restart_rsync_process(void) +void dss_get_snapshot_list(struct snapshot_list *sl) { - if (!rsync_pid || !rsync_stopped) - return; - kill (SIGCONT, rsync_pid); - rsync_stopped = 0; + get_snapshot_list(sl, conf.unit_interval_arg, conf.num_intervals_arg); } -/** - * Print a log message about the exit status of a child. - */ -void log_termination_msg(pid_t pid, int status) -{ - if (WIFEXITED(status)) - DSS_INFO_LOG("child %i exited. Exit status: %i\n", (int)pid, - WEXITSTATUS(status)); - else if (WIFSIGNALED(status)) - DSS_NOTICE_LOG("child %i was killed by signal %i\n", (int)pid, - WTERMSIG(status)); - else - DSS_WARNING_LOG("child %i terminated abormally\n", (int)pid); -} - -int wait_for_process(pid_t pid, int *status) +void compute_next_snapshot_time(void) { - int ret; - - DSS_DEBUG_LOG("Waiting for process %d to terminate\n", (int)pid); - for (;;) { - fd_set rfds; + struct timeval now, unit_interval = {.tv_sec = 24 * 3600 * conf.unit_interval_arg}, + tmp, diff; + int64_t x = 0; + unsigned wanted = desired_number_of_snapshots(0, conf.num_intervals_arg), + num_complete_snapshots = 0; + int i, ret; + struct snapshot *s = NULL; + struct snapshot_list sl; - FD_ZERO(&rfds); - FD_SET(signal_pipe, &rfds); - ret = dss_select(signal_pipe + 1, &rfds, NULL, NULL); - if (ret < 0) - break; - ret = next_signal(); - if (!ret) + assert(snapshot_creation_status == SCS_READY); + current_snapshot_creation_time = 0; + dss_get_snapshot_list(&sl); + FOR_EACH_SNAPSHOT(s, i, &sl) { + if (!(s->flags & SS_COMPLETE)) continue; - if (ret == SIGCHLD) { - ret = waitpid(pid, status, 0); - if (ret >= 0) - break; - if (errno != EINTR) { /* error */ - ret = -ERRNO_TO_DSS_ERROR(errno); - break; - } - } - /* SIGINT or SIGTERM */ - DSS_WARNING_LOG("sending SIGTERM to pid %d\n", (int)pid); - kill(pid, SIGTERM); + num_complete_snapshots++; + x += s->completion_time - s->creation_time; } - if (ret < 0) - DSS_ERROR_LOG("failed to wait for process %d\n", (int)pid); - else - log_termination_msg(pid, *status); - return ret; + assert(x >= 0); + if (num_complete_snapshots) + x /= num_complete_snapshots; /* avg time to create one snapshot */ + x *= wanted; /* time to create all snapshots in interval 0 */ + tmp.tv_sec = x; + tmp.tv_usec = 0; + ret = tv_diff(&unit_interval, &tmp, &diff); /* total sleep time per unit interval */ + gettimeofday(&now, NULL); + if (ret < 0 || !s) + goto min_sleep; + tv_divide(wanted, &diff, &tmp); /* sleep time betweeen two snapshots */ + diff.tv_sec = s->completion_time; + diff.tv_usec = 0; + tv_add(&diff, &tmp, &next_snapshot_time); + if (tv_diff(&now, &next_snapshot_time, NULL) < 0) + goto out; +min_sleep: + next_snapshot_time = now; + next_snapshot_time.tv_sec += 60; +out: + free_snapshot_list(&sl); } + int remove_snapshot(struct snapshot *s) { int fds[3] = {0, 0, 0}; @@ -430,7 +187,6 @@ int remove_snapshot(struct snapshot *s) if (ret < 0) goto out; DSS_NOTICE_LOG("removing %s (interval = %i)\n", s->name, s->interval); - stop_rsync_process(); ret = dss_exec(&rm_pid, argv[0], argv, fds); out: free(new_name); @@ -448,7 +204,7 @@ int remove_redundant_snapshot(struct snapshot_list *sl) DSS_INFO_LOG("looking for intervals containing too many snapshots\n"); for (interval = conf.num_intervals_arg - 1; interval >= 0; interval--) { - unsigned keep = num_snapshots(interval); + unsigned keep = desired_number_of_snapshots(interval, conf.num_intervals_arg); unsigned num = sl->interval_count[interval]; struct snapshot *victim = NULL, *prev = NULL; int64_t score = LONG_MAX; @@ -521,119 +277,16 @@ int remove_outdated_snapshot(struct snapshot_list *sl) return 0; } -int handle_rm_exit(int status) -{ - rm_pid = 0; - if (!WIFEXITED(status)) - return -E_INVOLUNTARY_EXIT; - if (WEXITSTATUS(status)) - return -E_BAD_EXIT_CODE; - return 1; -} - -int wait_for_rm_process(void) -{ - int status, ret = wait_for_process(rm_pid, &status); - - if (ret < 0) - return ret; - return handle_rm_exit(status); -} - -void kill_process(pid_t pid) +int remove_oldest_snapshot(struct snapshot_list *sl) { - if (!pid) - return; - DSS_WARNING_LOG("sending SIGTERM to pid %d\n", (int)pid); - kill(pid, SIGTERM); -} + struct snapshot *s = get_oldest_snapshot(sl); -int check_config(void) -{ - if (conf.unit_interval_arg <= 0) { - DSS_ERROR_LOG("bad unit interval: %i\n", conf.unit_interval_arg); - return -E_INVALID_NUMBER; - } - DSS_DEBUG_LOG("unit interval: %i day(s)\n", conf.unit_interval_arg); - if (conf.num_intervals_arg <= 0) { - DSS_ERROR_LOG("bad number of intervals %i\n", conf.num_intervals_arg); - return -E_INVALID_NUMBER; - } - DSS_DEBUG_LOG("number of intervals: %i\n", conf.num_intervals_arg); - return 1; -} - -/* exits on errors */ -void parse_config_file(int override) -{ - int ret; - char *config_file; - struct stat statbuf; - char *old_logfile_arg = NULL; - int old_daemon_given = 0; - - if (conf.config_file_given) - config_file = dss_strdup(conf.config_file_arg); - else { - char *home = get_homedir(); - config_file = make_message("%s/.dssrc", home); - free(home); - } - if (override) { /* SIGHUP */ - if (conf.logfile_given) - old_logfile_arg = dss_strdup(conf.logfile_arg); - old_daemon_given = conf.daemon_given; - } - - ret = stat(config_file, &statbuf); - if (ret && conf.config_file_given) { - ret = -ERRNO_TO_DSS_ERROR(errno); - DSS_ERROR_LOG("failed to stat config file %s\n", config_file); - goto out; - } - if (!ret) { - struct cmdline_parser_params params = { - .override = override, - .initialize = 0, - .check_required = 1, - .check_ambiguity = 0 - }; - cmdline_parser_config_file(config_file, &conf, ¶ms); - } - ret = check_config(); - if (ret < 0) - goto out; - if (override) { - /* don't change daemon mode on SIGHUP */ - conf.daemon_given = old_daemon_given; - close_log(logfile); - logfile = NULL; - if (conf.logfile_given) - free(old_logfile_arg); - else if (conf.daemon_given) { /* re-use old logfile */ - conf.logfile_arg = old_logfile_arg; - conf.logfile_given = 1; - } - } - if (conf.logfile_given) { - logfile = open_log(conf.logfile_arg); - log_welcome(conf.loglevel_arg); - } - DSS_EMERG_LOG("loglevel: %d\n", conf.loglevel_arg); -// cmdline_parser_dump(logfile? logfile : stdout, &conf); - ret = dss_chdir(conf.dest_dir_arg); -out: - free(config_file); - if (ret >= 0) - return; - DSS_EMERG_LOG("%s\n", dss_strerror(-ret)); - exit(EXIT_FAILURE); -} - -void handle_sighup(void) -{ - DSS_NOTICE_LOG("SIGHUP\n"); - parse_config_file(1); + if (!s) /* no snapshot found */ + return 0; + DSS_INFO_LOG("oldest snapshot: %s\n", s->name); + if (s->creation_time == current_snapshot_creation_time) + return 0; /* do not remove the snapshot currently being created */ + return remove_snapshot(s); } int rename_incomplete_snapshot(int64_t start) @@ -655,191 +308,191 @@ int rename_incomplete_snapshot(int64_t start) return ret; } -void compute_next_snapshot_time(void) +int try_to_free_disk_space(int low_disk_space) { - struct timeval now, unit_interval = {.tv_sec = 24 * 3600 * conf.unit_interval_arg}, - tmp, diff; - int64_t x = 0; - unsigned wanted = num_snapshots(0), num_complete_snapshots = 0; - int i, ret; - struct snapshot *s = NULL; + int ret; struct snapshot_list sl; - assert(snapshot_creation_status == SCS_READY); - current_snapshot_creation_time = 0; - get_snapshot_list(&sl); - FOR_EACH_SNAPSHOT(s, i, &sl) { - if (!(s->flags & SS_COMPLETE)) - continue; - num_complete_snapshots++; - x += s->completion_time - s->creation_time; - } - assert(x >= 0); - if (num_complete_snapshots) - x /= num_complete_snapshots; /* avg time to create one snapshot */ - x *= wanted; /* time to create all snapshots in interval 0 */ - tmp.tv_sec = x; - tmp.tv_usec = 0; - ret = tv_diff(&unit_interval, &tmp, &diff); /* total sleep time per unit interval */ - gettimeofday(&now, NULL); - if (ret < 0 || !s) - goto min_sleep; - tv_divide(wanted, &diff, &tmp); /* sleep time betweeen two snapshots */ - diff.tv_sec = s->completion_time; - diff.tv_usec = 0; - tv_add(&diff, &tmp, &next_snapshot_time); - if (tv_diff(&now, &next_snapshot_time, NULL) < 0) + dss_get_snapshot_list(&sl); + ret = remove_outdated_snapshot(&sl); + if (ret) /* error, or we are removing something */ goto out; -min_sleep: - next_snapshot_time = now; - next_snapshot_time.tv_sec += 60; + /* no outdated snapshot */ + ret = remove_redundant_snapshot(&sl); + if (ret) + goto out; + ret = 0; + if (!low_disk_space) + goto out; + DSS_WARNING_LOG("disk space low and nothing obvious to remove\n"); + ret = remove_oldest_snapshot(&sl); + if (ret) + goto out; + DSS_CRIT_LOG("uhuhu: not enough disk space for a single snapshot\n"); + ret= -ENOSPC; out: free_snapshot_list(&sl); + return ret; } -int handle_rsync_exit(int status) +int pre_create_hook(void) { - int es, ret; + int ret, fds[3] = {0, 0, 0}; - if (!WIFEXITED(status)) { - DSS_ERROR_LOG("rsync process %d died involuntary\n", (int)rsync_pid); - ret = -E_INVOLUNTARY_EXIT; - snapshot_creation_status = SCS_READY; - compute_next_snapshot_time(); - goto out; + if (!conf.pre_create_hook_given) { + snapshot_creation_status = SCS_PRE_HOOK_SUCCESS; + return 0; } - es = WEXITSTATUS(status); - if (es != 0 && es != 23 && es != 24) { - DSS_ERROR_LOG("rsync process %d returned %d\n", (int)rsync_pid, es); - ret = -E_BAD_EXIT_CODE; + DSS_NOTICE_LOG("executing %s\n", conf.pre_create_hook_arg); + ret = dss_exec_cmdline_pid(&pre_create_hook_pid, + conf.pre_create_hook_arg, fds); + if (ret < 0) + return ret; + snapshot_creation_status = SCS_PRE_HOOK_RUNNING; + return ret; +} + +int post_create_hook(void) +{ + int ret, fds[3] = {0, 0, 0}; + char *cmd; + + if (!conf.post_create_hook_given) { snapshot_creation_status = SCS_READY; compute_next_snapshot_time(); - goto out; + return 0; } - ret = rename_incomplete_snapshot(current_snapshot_creation_time); + cmd = make_message("%s %s", conf.post_create_hook_arg, + path_to_last_complete_snapshot); + DSS_NOTICE_LOG("executing %s\n", cmd); + ret = dss_exec_cmdline_pid(&post_create_hook_pid, cmd, fds); + free(cmd); if (ret < 0) - goto out; - snapshot_creation_status = SCS_RSYNC_SUCCESS; -out: - rsync_pid = 0; - rsync_stopped = 0; + return ret; + snapshot_creation_status = SCS_POST_HOOK_RUNNING; return ret; } -__malloc char *name_of_newest_complete_snapshot(void) +void kill_process(pid_t pid) { - struct snapshot_list sl; - struct snapshot *s; - int i; - char *name = NULL; - - get_snapshot_list(&sl); + if (!pid) + return; + DSS_WARNING_LOG("sending SIGTERM to pid %d\n", (int)pid); + kill(pid, SIGTERM); +} - FOR_EACH_SNAPSHOT_REVERSE(s, i, &sl) { - if (s->flags != SS_COMPLETE) /* incomplete or being deleted */ - continue; - name = dss_strdup(s->name); - break; - } - free_snapshot_list(&sl); - return name; +void stop_rsync_process(void) +{ + if (!rsync_pid || rsync_stopped) + return; + kill(SIGSTOP, rsync_pid); + rsync_stopped = 1; } -void create_rsync_argv(char ***argv, int64_t *num) +void restart_rsync_process(void) { - char *logname, *newest = name_of_newest_complete_snapshot(); - int i = 0, j; + if (!rsync_pid || !rsync_stopped) + return; + kill (SIGCONT, rsync_pid); + rsync_stopped = 0; +} - *argv = dss_malloc((15 + conf.rsync_option_given) * sizeof(char *)); - (*argv)[i++] = dss_strdup("rsync"); - (*argv)[i++] = dss_strdup("-aq"); - (*argv)[i++] = dss_strdup("--delete"); - for (j = 0; j < conf.rsync_option_given; j++) - (*argv)[i++] = dss_strdup(conf.rsync_option_arg[j]); - if (newest) { - DSS_INFO_LOG("using %s as reference snapshot\n", newest); - (*argv)[i++] = make_message("--link-dest=../%s", newest); - free(newest); - } else - DSS_INFO_LOG("no previous snapshot found\n"); - if (conf.exclude_patterns_given) { - (*argv)[i++] = dss_strdup("--exclude-from"); - (*argv)[i++] = dss_strdup(conf.exclude_patterns_arg); - } - logname = dss_logname(); - if (conf.remote_user_given && !strcmp(conf.remote_user_arg, logname)) - (*argv)[i++] = dss_strdup(conf.source_dir_arg); +/** + * Print a log message about the exit status of a child. + */ +void log_termination_msg(pid_t pid, int status) +{ + if (WIFEXITED(status)) + DSS_INFO_LOG("child %i exited. Exit status: %i\n", (int)pid, + WEXITSTATUS(status)); + else if (WIFSIGNALED(status)) + DSS_NOTICE_LOG("child %i was killed by signal %i\n", (int)pid, + WTERMSIG(status)); else - (*argv)[i++] = make_message("%s@%s:%s/", conf.remote_user_given? - conf.remote_user_arg : logname, - conf.remote_host_arg, conf.source_dir_arg); - free(logname); - *num = get_current_time(); - (*argv)[i++] = incomplete_name(*num); - (*argv)[i++] = NULL; - for (j = 0; j < i; j++) - DSS_DEBUG_LOG("argv[%d] = %s\n", j, (*argv)[j]); + DSS_WARNING_LOG("child %i terminated abormally\n", (int)pid); } -void free_rsync_argv(char **argv) +int wait_for_process(pid_t pid, int *status) { - int i; - for (i = 0; argv[i]; i++) - free(argv[i]); - free(argv); -} + int ret; -int pre_create_hook(void) -{ - int ret, fds[3] = {0, 0, 0}; + DSS_DEBUG_LOG("Waiting for process %d to terminate\n", (int)pid); + for (;;) { + fd_set rfds; - if (!conf.pre_create_hook_given) { - snapshot_creation_status = SCS_PRE_HOOK_SUCCESS; - return 0; + FD_ZERO(&rfds); + FD_SET(signal_pipe, &rfds); + ret = dss_select(signal_pipe + 1, &rfds, NULL, NULL); + if (ret < 0) + break; + ret = next_signal(); + if (!ret) + continue; + if (ret == SIGCHLD) { + ret = waitpid(pid, status, 0); + if (ret >= 0) + break; + if (errno != EINTR) { /* error */ + ret = -ERRNO_TO_DSS_ERROR(errno); + break; + } + } + /* SIGINT or SIGTERM */ + DSS_WARNING_LOG("sending SIGTERM to pid %d\n", (int)pid); + kill(pid, SIGTERM); } - DSS_NOTICE_LOG("executing %s\n", conf.pre_create_hook_arg); - ret = dss_exec_cmdline_pid(&pre_create_hook_pid, - conf.pre_create_hook_arg, fds); if (ret < 0) - return ret; - snapshot_creation_status = SCS_PRE_HOOK_RUNNING; + DSS_ERROR_LOG("failed to wait for process %d\n", (int)pid); + else + log_termination_msg(pid, *status); return ret; } +int handle_rm_exit(int status) +{ + rm_pid = 0; + if (!WIFEXITED(status)) + return -E_INVOLUNTARY_EXIT; + if (WEXITSTATUS(status)) + return -E_BAD_EXIT_CODE; + return 1; +} -int post_create_hook(void) +int wait_for_rm_process(void) { - int ret, fds[3] = {0, 0, 0}; - char *cmd; + int status, ret = wait_for_process(rm_pid, &status); - if (!conf.post_create_hook_given) { - snapshot_creation_status = SCS_READY; - compute_next_snapshot_time(); - return 0; - } - cmd = make_message("%s %s", conf.post_create_hook_arg, - path_to_last_complete_snapshot); - DSS_NOTICE_LOG("executing %s\n", cmd); - ret = dss_exec_cmdline_pid(&post_create_hook_pid, cmd, fds); - free(cmd); if (ret < 0) return ret; - snapshot_creation_status = SCS_POST_HOOK_RUNNING; - return ret; + return handle_rm_exit(status); } -int create_snapshot(char **argv) +int handle_rsync_exit(int status) { - int ret, fds[3] = {0, 0, 0}; - char *name; + int es, ret; - name = incomplete_name(current_snapshot_creation_time); - DSS_NOTICE_LOG("creating new snapshot %s\n", name); - free(name); - ret = dss_exec(&rsync_pid, argv[0], argv, fds); + if (!WIFEXITED(status)) { + DSS_ERROR_LOG("rsync process %d died involuntary\n", (int)rsync_pid); + ret = -E_INVOLUNTARY_EXIT; + snapshot_creation_status = SCS_READY; + compute_next_snapshot_time(); + goto out; + } + es = WEXITSTATUS(status); + if (es != 0 && es != 23 && es != 24) { + DSS_ERROR_LOG("rsync process %d returned %d\n", (int)rsync_pid, es); + ret = -E_BAD_EXIT_CODE; + snapshot_creation_status = SCS_READY; + compute_next_snapshot_time(); + goto out; + } + ret = rename_incomplete_snapshot(current_snapshot_creation_time); if (ret < 0) - return ret; - snapshot_creation_status = SCS_RSYNC_RUNNING; + goto out; + snapshot_creation_status = SCS_RSYNC_SUCCESS; +out: + rsync_pid = 0; + rsync_stopped = 0; return ret; } @@ -867,7 +520,7 @@ out: return ret; } -int handle_sigchld() +int handle_sigchld(void) { pid_t pid; int status, ret = reap_child(&pid, &status); @@ -889,6 +542,95 @@ int handle_sigchld() exit(EXIT_FAILURE); } + +int check_config(void) +{ + if (conf.unit_interval_arg <= 0) { + DSS_ERROR_LOG("bad unit interval: %i\n", conf.unit_interval_arg); + return -E_INVALID_NUMBER; + } + DSS_DEBUG_LOG("unit interval: %i day(s)\n", conf.unit_interval_arg); + if (conf.num_intervals_arg <= 0) { + DSS_ERROR_LOG("bad number of intervals %i\n", conf.num_intervals_arg); + return -E_INVALID_NUMBER; + } + DSS_DEBUG_LOG("number of intervals: %i\n", conf.num_intervals_arg); + return 1; +} + +/* exits on errors */ +void parse_config_file(int override) +{ + int ret; + char *config_file; + struct stat statbuf; + char *old_logfile_arg = NULL; + int old_daemon_given = 0; + + if (conf.config_file_given) + config_file = dss_strdup(conf.config_file_arg); + else { + char *home = get_homedir(); + config_file = make_message("%s/.dssrc", home); + free(home); + } + if (override) { /* SIGHUP */ + if (conf.logfile_given) + old_logfile_arg = dss_strdup(conf.logfile_arg); + old_daemon_given = conf.daemon_given; + } + + ret = stat(config_file, &statbuf); + if (ret && conf.config_file_given) { + ret = -ERRNO_TO_DSS_ERROR(errno); + DSS_ERROR_LOG("failed to stat config file %s\n", config_file); + goto out; + } + if (!ret) { + struct cmdline_parser_params params = { + .override = override, + .initialize = 0, + .check_required = 1, + .check_ambiguity = 0 + }; + cmdline_parser_config_file(config_file, &conf, ¶ms); + } + ret = check_config(); + if (ret < 0) + goto out; + if (override) { + /* don't change daemon mode on SIGHUP */ + conf.daemon_given = old_daemon_given; + close_log(logfile); + logfile = NULL; + if (conf.logfile_given) + free(old_logfile_arg); + else if (conf.daemon_given) { /* re-use old logfile */ + conf.logfile_arg = old_logfile_arg; + conf.logfile_given = 1; + } + } + if (conf.logfile_given) { + logfile = open_log(conf.logfile_arg); + log_welcome(conf.loglevel_arg); + } + DSS_EMERG_LOG("loglevel: %d\n", conf.loglevel_arg); +// cmdline_parser_dump(logfile? logfile : stdout, &conf); + ret = dss_chdir(conf.dest_dir_arg); +out: + free(config_file); + if (ret >= 0) + return; + DSS_EMERG_LOG("%s\n", dss_strerror(-ret)); + exit(EXIT_FAILURE); +} + +void handle_sighup(void) +{ + DSS_NOTICE_LOG("SIGHUP\n"); + parse_config_file(1); +} + void handle_signal(void) { int sig, ret = next_signal(); @@ -916,59 +658,68 @@ out: DSS_ERROR_LOG("%s\n", dss_strerror(-ret)); } -int remove_oldest_snapshot(struct snapshot_list *sl) +void create_rsync_argv(char ***argv, int64_t *num) { - struct snapshot *s = oldest_snapshot(sl); + char *logname, *newest; + int i = 0, j; + struct snapshot_list sl; - if (!s) /* no snapshot found */ - return 0; - DSS_INFO_LOG("oldest snapshot: %s\n", s->name); - if (s->creation_time == current_snapshot_creation_time) - return 0; /* do not remove the snapshot currently being created */ - return remove_snapshot(s); + dss_get_snapshot_list(&sl); + newest = name_of_newest_complete_snapshot(&sl); + free_snapshot_list(&sl); + + *argv = dss_malloc((15 + conf.rsync_option_given) * sizeof(char *)); + (*argv)[i++] = dss_strdup("rsync"); + (*argv)[i++] = dss_strdup("-aq"); + (*argv)[i++] = dss_strdup("--delete"); + for (j = 0; j < conf.rsync_option_given; j++) + (*argv)[i++] = dss_strdup(conf.rsync_option_arg[j]); + if (newest) { + DSS_INFO_LOG("using %s as reference snapshot\n", newest); + (*argv)[i++] = make_message("--link-dest=../%s", newest); + free(newest); + } else + DSS_INFO_LOG("no previous snapshot found\n"); + if (conf.exclude_patterns_given) { + (*argv)[i++] = dss_strdup("--exclude-from"); + (*argv)[i++] = dss_strdup(conf.exclude_patterns_arg); + + } + logname = dss_logname(); + if (conf.remote_user_given && !strcmp(conf.remote_user_arg, logname)) + (*argv)[i++] = dss_strdup(conf.source_dir_arg); + else + (*argv)[i++] = make_message("%s@%s:%s/", conf.remote_user_given? + conf.remote_user_arg : logname, + conf.remote_host_arg, conf.source_dir_arg); + free(logname); + *num = get_current_time(); + (*argv)[i++] = incomplete_name(*num); + (*argv)[i++] = NULL; + for (j = 0; j < i; j++) + DSS_DEBUG_LOG("argv[%d] = %s\n", j, (*argv)[j]); } -/* TODO: Also consider number of inodes. */ -int disk_space_low(void) +void free_rsync_argv(char **argv) { - struct disk_space ds; - int ret = get_disk_space(".", &ds); - - if (ret < 0) - return ret; - if (conf.min_free_mb_arg) - if (ds.free_mb < conf.min_free_mb_arg) - return 1; - if (conf.min_free_percent_arg) - if (ds.percent_free < conf.min_free_percent_arg) - return 1; - return 0; + int i; + for (i = 0; argv[i]; i++) + free(argv[i]); + free(argv); } -int try_to_free_disk_space(int low_disk_space) +int create_snapshot(char **argv) { - int ret; - struct snapshot_list sl; + int ret, fds[3] = {0, 0, 0}; + char *name; - get_snapshot_list(&sl); - ret = remove_outdated_snapshot(&sl); - if (ret) /* error, or we are removing something */ - goto out; - /* no outdated snapshot */ - ret = remove_redundant_snapshot(&sl); - if (ret) - goto out; - ret = 0; - if (!low_disk_space) - goto out; - DSS_WARNING_LOG("disk space low and nothing obvious to remove\n"); - ret = remove_oldest_snapshot(&sl); - if (ret) - goto out; - DSS_CRIT_LOG("uhuhu: not enough disk space for a single snapshot\n"); - ret= -ENOSPC; -out: - free_snapshot_list(&sl); + name = incomplete_name(current_snapshot_creation_time); + DSS_NOTICE_LOG("creating new snapshot %s\n", name); + free(name); + ret = dss_exec(&rsync_pid, argv[0], argv, fds); + if (ret < 0) + return ret; + snapshot_creation_status = SCS_RSYNC_RUNNING; return ret; } @@ -1001,13 +752,13 @@ int select_loop(void) if (ret < 0) break; low_disk_space = ret; - if (low_disk_space) - stop_rsync_process(); ret = try_to_free_disk_space(low_disk_space); if (ret < 0) break; - if (rm_pid) + if (rm_pid) { + stop_rsync_process(); continue; + } restart_rsync_process(); gettimeofday(&now, NULL); if (tv_diff(&next_snapshot_time, &now, &tv) > 0) @@ -1068,7 +819,7 @@ int com_prune(void) return ret; log_disk_space(&ds); for (;;) { - get_snapshot_list(&sl); + dss_get_snapshot_list(&sl); ret = remove_outdated_snapshot(&sl); free_snapshot_list(&sl); if (ret < 0) @@ -1080,7 +831,7 @@ int com_prune(void) goto out; } for (;;) { - get_snapshot_list(&sl); + dss_get_snapshot_list(&sl); ret = remove_redundant_snapshot(&sl); free_snapshot_list(&sl); if (ret < 0) @@ -1150,7 +901,8 @@ int com_ls(void) int i; struct snapshot_list sl; struct snapshot *s; - get_snapshot_list(&sl); + + dss_get_snapshot_list(&sl); FOR_EACH_SNAPSHOT(s, i, &sl) dss_msg("%u\t%s\n", s->interval, s->name); free_snapshot_list(&sl); @@ -1178,6 +930,7 @@ err: exit(EXIT_FAILURE); } + int main(int argc, char **argv) { int ret; diff --git a/snap.c b/snap.c new file mode 100644 index 0000000..1bc97b5 --- /dev/null +++ b/snap.c @@ -0,0 +1,217 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +#include "gcc-compat.h" +#include "error.h" +#include "snap.h" +#include "string.h" +#include "time.h" +#include "fd.h" + +/** + * Return the desired number of snapshots of an interval. + */ +unsigned desired_number_of_snapshots(int interval_num, int num_intervals) +{ + unsigned n; + + assert(interval_num >= 0); + + if (interval_num >= num_intervals) + return 0; + n = num_intervals - interval_num - 1; + return 1 << n; +} + +/* return: Whether dirname is a snapshot directory (0: no, 1: yes) */ +static int is_snapshot(const char *dirname, int64_t now, int unit_interval, + struct snapshot *s) +{ + int i, ret; + char *dash, *dot, *tmp; + int64_t num; + + assert(dirname); + dash = strchr(dirname, '-'); + if (!dash || !dash[1] || dash == dirname) + return 0; + for (i = 0; dirname[i] != '-'; i++) + if (!isdigit(dirname[i])) + return 0; + tmp = dss_strdup(dirname); + tmp[i] = '\0'; + ret = dss_atoi64(tmp, &num); + free(tmp); + if (ret < 0) + return 0; + assert(num >= 0); + if (num > now) + return 0; + s->creation_time = num; + //DSS_DEBUG_LOG("%s start time: %lli\n", dirname, (long long)s->creation_time); + s->interval = (long long) ((now - s->creation_time) + / unit_interval / 24 / 3600); + if (!strcmp(dash + 1, "incomplete")) { + s->completion_time = -1; + s->flags = 0; /* neither complete, nor being deleted */ + goto success; + } + if (!strcmp(dash + 1, "incomplete.being_deleted")) { + s->completion_time = -1; + s->flags = SS_BEING_DELETED; /* mot cpmplete, being deleted */ + goto success; + } + tmp = dash + 1; + dot = strchr(tmp, '.'); + if (!dot || !dot[1] || dot == tmp) + return 0; + for (i = 0; tmp[i] != '.'; i++) + if (!isdigit(tmp[i])) + return 0; + tmp = dss_strdup(dash + 1); + tmp[i] = '\0'; + ret = dss_atoi64(tmp, &num); + free(tmp); + if (ret < 0) + return 0; + if (num > now) + return 0; + s->completion_time = num; + s->flags = SS_COMPLETE; + if (!strcmp(dot + 1, "being_deleted")) + s->flags |= SS_BEING_DELETED; +success: + s->name = dss_strdup(dirname); + return 1; +} + +struct add_snapshot_data { + int unit_interval; + int num_intervals; + struct snapshot_list *sl; +}; + +/** Compute the minimum of \a a and \a b. */ +#define DSS_MIN(a,b) ((a) < (b) ? (a) : (b)) + +static int add_snapshot(const char *dirname, void *private) +{ + struct add_snapshot_data *asd = private; + struct snapshot_list *sl = asd->sl; + struct snapshot s; + int ret = is_snapshot(dirname, sl->now, asd->unit_interval, &s); + + if (!ret) + return 1; + if (sl->num_snapshots >= sl->array_size) { + sl->array_size = 2 * sl->array_size + 1; + sl->snapshots = dss_realloc(sl->snapshots, + sl->array_size * sizeof(struct snapshot *)); + } + sl->snapshots[sl->num_snapshots] = dss_malloc(sizeof(struct snapshot)); + *(sl->snapshots[sl->num_snapshots]) = s; + sl->interval_count[DSS_MIN(s.interval, asd->num_intervals)]++; + sl->num_snapshots++; + return 1; +} + +#define NUM_COMPARE(x, y) ((int)((x) < (y)) - (int)((x) > (y))) + +static int compare_snapshots(const void *a, const void *b) +{ + struct snapshot *s1 = *(struct snapshot **)a; + struct snapshot *s2 = *(struct snapshot **)b; + return NUM_COMPARE(s2->creation_time, s1->creation_time); +} + + +void get_snapshot_list(struct snapshot_list *sl, int unit_interval, + int num_intervals) +{ + struct add_snapshot_data asd = { + .unit_interval = unit_interval, + .num_intervals = num_intervals, + .sl = sl + }; + sl->now = get_current_time(); + sl->num_snapshots = 0; + sl->array_size = 0; + sl->snapshots = NULL; + sl->interval_count = dss_calloc((num_intervals + 1) * sizeof(unsigned)); + for_each_subdir(add_snapshot, &asd); + qsort(sl->snapshots, sl->num_snapshots, sizeof(struct snapshot *), + compare_snapshots); +} + +void free_snapshot_list(struct snapshot_list *sl) +{ + int i; + struct snapshot *s; + + FOR_EACH_SNAPSHOT(s, i, sl) { + free(s->name); + free(s); + } + free(sl->interval_count); + sl->interval_count = NULL; + free(sl->snapshots); + sl->snapshots = NULL; + sl->num_snapshots = 0; +} + +__malloc char *incomplete_name(int64_t start) +{ + return make_message("%lli-incomplete", (long long)start); +} + +__malloc char *being_deleted_name(struct snapshot *s) +{ + if (s->flags & SS_COMPLETE) + return make_message("%lli-%lli.being_deleted", + (long long)s->creation_time, + (long long)s->completion_time); + return make_message("%lli-incomplete.being_deleted", + (long long)s->creation_time); +} + +int complete_name(int64_t start, int64_t end, char **result) +{ + struct tm start_tm, end_tm; + time_t *start_seconds = (time_t *) (uint64_t *)&start; /* STFU, gcc */ + time_t *end_seconds = (time_t *) (uint64_t *)&end; /* STFU, gcc */ + char start_str[200], end_str[200]; + + if (!localtime_r(start_seconds, &start_tm)) + return -E_LOCALTIME; + if (!localtime_r(end_seconds, &end_tm)) + return -E_LOCALTIME; + if (!strftime(start_str, sizeof(start_str), "%a_%b_%d_%Y_%H_%M_%S", &start_tm)) + return -E_STRFTIME; + if (!strftime(end_str, sizeof(end_str), "%a_%b_%d_%Y_%H_%M_%S", &end_tm)) + return -E_STRFTIME; + *result = make_message("%lli-%lli.%s-%s", (long long) start, (long long) end, + start_str, end_str); + return 1; +} + +__malloc char *name_of_newest_complete_snapshot(struct snapshot_list *sl) +{ + struct snapshot *s; + int i; + char *name = NULL; + + FOR_EACH_SNAPSHOT_REVERSE(s, i, sl) { + if (s->flags != SS_COMPLETE) /* incomplete or being deleted */ + continue; + name = dss_strdup(s->name); + break; + } + return name; +} + diff --git a/snap.h b/snap.h new file mode 100644 index 0000000..1e9fc2b --- /dev/null +++ b/snap.h @@ -0,0 +1,72 @@ +enum { + /** We are ready to take the next snapshot. */ + SCS_READY, + /** The pre-creation hook has been started. */ + SCS_PRE_HOOK_RUNNING, + /** The pre-creation hook exited successfully. */ + SCS_PRE_HOOK_SUCCESS, + /** The rsync process is running. */ + SCS_RSYNC_RUNNING, + /** The rsync process exited successfully. */ + SCS_RSYNC_SUCCESS, + /** The post-create hook has been started- */ + SCS_POST_HOOK_RUNNING, +}; + +/* + * complete, not being deleted: 1204565370-1204565371.Sun_Mar_02_2008_14_33-Sun_Mar_02_2008_14_43 + * complete, being deleted: 1204565370-1204565371.being_deleted + * incomplete, not being deleted: 1204565370-incomplete + * incomplete, being deleted: 1204565370-incomplete.being_deleted + */ +enum snapshot_status_flags { + /** The rsync process terminated successfully. */ + SS_COMPLETE = 1, + /** The rm process is running to remove this snapshot. */ + SS_BEING_DELETED = 2, +}; + +struct snapshot { + char *name; + int64_t creation_time; + int64_t completion_time; + enum snapshot_status_flags flags; + unsigned interval; +}; + +struct snapshot_list { + int64_t now; + unsigned num_snapshots; + unsigned array_size; + struct snapshot **snapshots; + /** + * Array of size num_intervals + 1 + * + * It contains the number of snapshots in each interval. interval_count[num_intervals] + * is the number of snapshots which belong to any interval greater than num_intervals. + */ + unsigned *interval_count; +}; + +#define FOR_EACH_SNAPSHOT(s, i, sl) \ + for ((i) = 0; (i) < (sl)->num_snapshots && ((s) = (sl)->snapshots[(i)]); (i)++) + +#define FOR_EACH_SNAPSHOT_REVERSE(s, i, sl) \ + for ((i) = (sl)->num_snapshots; (i) > 0 && ((s) = (sl)->snapshots[(i - 1)]); (i)--) + + +unsigned desired_number_of_snapshots(int interval_num, int num_intervals); +void get_snapshot_list(struct snapshot_list *sl, int unit_interval, + int num_intervals); +void free_snapshot_list(struct snapshot_list *sl); +__malloc char *incomplete_name(int64_t start); +__malloc char *being_deleted_name(struct snapshot *s); +int complete_name(int64_t start, int64_t end, char **result); +__malloc char *name_of_newest_complete_snapshot(struct snapshot_list *sl); + +static inline struct snapshot *get_oldest_snapshot(struct snapshot_list *sl) +{ + if (!sl->num_snapshots) + return NULL; + return sl->snapshots[0]; +} diff --git a/time.c b/time.c index 18366cd..b54e34c 100644 --- a/time.c +++ b/time.c @@ -1,6 +1,13 @@ #include #include #include +#include +#include + +#include "gcc-compat.h" +#include "error.h" +#include "string.h" +#include "log.h" /* * Copyright (C) 2005-2008 Andre Noll @@ -129,3 +136,11 @@ void tv_divide(const unsigned long divisor, const struct timeval *tv, result->tv_sec = x / 1000 / 1000; result->tv_usec = x % (1000 * 1000); } + +int64_t get_current_time(void) +{ + time_t now; + time(&now); + DSS_DEBUG_LOG("now: %lli\n", (long long) now); + return (int64_t)now; +} diff --git a/time.h b/time.h index 97b3065..f2021e0 100644 --- a/time.h +++ b/time.h @@ -6,3 +6,4 @@ void tv_scale(const unsigned long, const struct timeval *, struct timeval *); void tv_divide(const unsigned long divisor, const struct timeval *tv, struct timeval *result); void ms2tv(const long unsigned n, struct timeval *tv); +int64_t get_current_time(void); -- 2.39.5