X-Git-Url: http://git.tuebingen.mpg.de/?p=dss.git;a=blobdiff_plain;f=dss.c;h=fd876e5ddc1d340dec79dee84f9706dc9a09912f;hp=f33ce8d2b194178e148141133aef45c2d49d6754;hb=d184cc0fa0368ca089b1ae6f2162ccfc224bf28c;hpb=528c5711a3bf8ea8effa2a8c6ab7e0b3413ca7ef diff --git a/dss.c b/dss.c index f33ce8d..fd876e5 100644 --- a/dss.c +++ b/dss.c @@ -1,3 +1,8 @@ +/* + * Copyright (C) 2008 Andre Noll + * + * Licensed under the GPL v2. For licencing details see COPYING. + */ #include #include #include @@ -9,6 +14,7 @@ #include #include #include +#include #include #include #include @@ -22,11 +28,34 @@ #include "error.h" #include "fd.h" #include "exec.h" +#include "daemon.h" +#include "signal.h" +#include "df.h" +#include "time.h" +#include "snap.h" + +/** Command line and config file options. */ +static struct gengetopt_args_info conf; +/** Non-NULL if we log to a file. */ +static FILE *logfile; +/** The read end of the signal pipe */ +static int signal_pipe; +/** Process id of current pre-create-hook/rsync/post-create-hook process. */ +static pid_t create_pid; +/** Whether the pre-create-hook/rsync/post-create-hook is currently stopped. */ +static int create_process_stopped; +/** Process id of current rm process. */ +static pid_t rm_pid; +/** When the next snapshot is due. */ +static struct timeval next_snapshot_time; +/** Creation time of the snapshot currently being created. */ +static int64_t current_snapshot_creation_time; +/** Needed by the post-create hook. */ +static char *path_to_last_complete_snapshot; +/** \sa \ref snap.h for details. */ +static unsigned snapshot_creation_status; -struct gengetopt_args_info conf; -char *dss_error_txt = NULL; - DEFINE_DSS_ERRLIST; @@ -36,302 +65,181 @@ DEFINE_DSS_ERRLIST; COMMAND(create) \ COMMAND(prune) \ COMMAND(run) -#define COMMAND(x) int com_ ##x(int, char * const * const); +#define COMMAND(x) static int com_ ##x(void); COMMANDS #undef COMMAND -#define COMMAND(x) if (conf.x ##_given) return com_ ##x(argc, argv); -int call_command_handler(int argc, char * const * const argv) +#define COMMAND(x) if (conf.x ##_given) return com_ ##x(); +static int call_command_handler(void) { COMMANDS - return -E_INVALID_COMMAND; + DSS_EMERG_LOG("BUG: did not find command handler\n"); + return -E_BUG; } #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 +/** + * The log function of dss. + * + * \param ll Loglevel. + * \param fml Usual format string. + * + * All DSS_XXX_LOG() macros use this function. */ -enum snapshot_status_flags { - SS_COMPLETE = 1, - SS_BEING_DELETED = 2, -}; - -struct snapshot { - char *name; - int64_t creation_time; - int64_t completion_time; - enum snapshot_status_flags flags; - unsigned interval; -}; - -int is_snapshot(const char *dirname, int64_t now, 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) { - free(dss_error_txt); - 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) { - free(dss_error_txt); - 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) +__printf_2_3 void dss_log(int ll, const char* fmt,...) { - 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]; + va_list argp; + FILE *outfd; + struct tm *tm; + time_t t1; + char str[255] = ""; - if (!localtime_r(start_seconds, &start_tm)) { - make_err_msg("%lli", (long long)start); - return -E_LOCALTIME; - } - if (!localtime_r(end_seconds, &end_tm)) { - make_err_msg("%lli", (long long)end); - return -E_LOCALTIME; - } - if (!strftime(start_str, sizeof(start_str), "%a_%b_%d_%Y_%H_%M_%S", &start_tm)) { - make_err_msg("%lli", (long long)start); - return -E_STRFTIME; - } - if (!strftime(end_str, sizeof(end_str), "%a_%b_%d_%Y_%H_%M_%S", &end_tm)) { - make_err_msg("%lli", (long long)end); - return -E_STRFTIME; - } - *result = make_message("%lli-%lli.%s-%s", (long long) start, (long long) end, - start_str, end_str); - return 1; + if (ll < conf.loglevel_arg) + return; + outfd = logfile? logfile : stderr; + time(&t1); + tm = localtime(&t1); + strftime(str, sizeof(str), "%b %d %H:%M:%S", tm); + fprintf(outfd, "%s ", str); + if (conf.loglevel_arg <= INFO) + fprintf(outfd, "%i: ", ll); + va_start(argp, fmt); + vfprintf(outfd, fmt, argp); + va_end(argp); } -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 NUM_COMPARE(x, y) ((int)((x) < (y)) - (int)((x) > (y))) - -static int compare_snapshots(const void *a, const void *b) +/** + * Print a message either to stdout or to the log file. + */ +static __printf_1_2 void dss_msg(const char* fmt,...) { - struct snapshot *s1 = *(struct snapshot **)a; - struct snapshot *s2 = *(struct snapshot **)b; - return NUM_COMPARE(s2->creation_time, s1->creation_time); + FILE *outfd = conf.daemon_given? logfile : stdout; + va_list argp; + va_start(argp, fmt); + vfprintf(outfd, fmt, argp); + va_end(argp); } -/** 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) +static int disk_space_low(void) { - struct snapshot_list *sl = private; - struct snapshot s; - int ret = is_snapshot(dirname, sl->now, &s); + struct disk_space ds; + int ret = get_disk_space(".", &ds); - 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; + 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; + if (conf.min_free_percent_inodes_arg) + if (ds.percent_free_inodes < conf.min_free_percent_inodes_arg) + return 1; + return 0; } -void get_snapshot_list(struct snapshot_list *sl) +static void dss_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); + get_snapshot_list(sl, conf.unit_interval_arg, conf.num_intervals_arg); } -void free_snapshot_list(struct snapshot_list *sl) +static void compute_next_snapshot_time(void) { - int i; - struct snapshot *s; + 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; - FOR_EACH_SNAPSHOT(s, i, sl) { - free(s->name); - free(s); + 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; + num_complete_snapshots++; + x += s->completion_time - s->creation_time; } - free(sl->interval_count); - free(sl->snapshots); + 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 */ + if (ret < 0 || !s) /* unit_interval < tmp or no snapshot */ + goto min_sleep; + tv_divide(wanted, &diff, &tmp); /* sleep time betweeen two snapshots */ + diff.tv_sec = s->completion_time; /* completion time of the the latest snaphot */ + diff.tv_usec = 0; + tv_add(&diff, &tmp, &next_snapshot_time); + gettimeofday(&now, NULL); + 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); } -/** - * 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) -{ - int ret; - - DSS_DEBUG_LOG("Waiting for process %d to terminate\n", (int)pid); - for (;;) { - ret = waitpid(pid, status, 0); - if (ret >= 0 || errno != EINTR) - break; - } - if (ret < 0) { - ret = -ERRNO_TO_DSS_ERROR(errno); - make_err_msg("failed to wait for process %d", (int)pid); - } else - log_termination_msg(pid, *status); - return ret; -} - -int remove_snapshot(struct snapshot *s, pid_t *pid) +static int remove_snapshot(struct snapshot *s, char *why) { int fds[3] = {0, 0, 0}; + assert(!rm_pid); char *new_name = being_deleted_name(s); int ret = dss_rename(s->name, new_name); char *argv[] = {"rm", "-rf", new_name, NULL}; if (ret < 0) goto out; - DSS_NOTICE_LOG("removing %s (interval = %i)\n", s->name, s->interval); - ret = dss_exec(pid, argv[0], argv, fds); + DSS_NOTICE_LOG("removing %s snapshot %s (interval = %i)\n", + why, s->name, s->interval); + ret = dss_exec(&rm_pid, argv[0], argv, fds); out: free(new_name); return ret; } -int remove_redundant_snapshot(struct snapshot_list *sl, - int dry_run, pid_t *pid) +static int snapshot_is_being_created(struct snapshot *s) +{ + return s->creation_time == current_snapshot_creation_time; +} + +/* + * return: 0: no redundant snapshots, 1: rm process started, negative: error + */ +static int remove_redundant_snapshot(struct snapshot_list *sl) { int ret, i, interval; struct snapshot *s; unsigned missing = 0; - DSS_INFO_LOG("looking for intervals containing too many snapshots\n"); + DSS_DEBUG_LOG("looking for intervals containing too many snapshots\n"); for (interval = conf.num_intervals_arg - 1; interval >= 0; interval--) { - unsigned keep = 1<<(conf.num_intervals_arg - interval - 1); + 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; if (keep >= num) missing += keep - num; - DSS_DEBUG_LOG("interval %i: keep: %u, have: %u, missing: %u\n", - interval, keep, num, missing); +// DSS_DEBUG_LOG("interval %i: keep: %u, have: %u, missing: %u\n", +// interval, keep, num, missing); if (keep + missing >= num) continue; /* redundant snapshot in this interval, pick snapshot with lowest score */ FOR_EACH_SNAPSHOT(s, i, sl) { int64_t this_score; - DSS_DEBUG_LOG("checking %s\n", s->name); + if (snapshot_is_being_created(s)) + continue; + //DSS_DEBUG_LOG("checking %s\n", s->name); if (s->interval > interval) { prev = s; continue; @@ -347,7 +255,7 @@ int remove_redundant_snapshot(struct snapshot_list *sl, /* check if s is a better victim */ this_score = s->creation_time - prev->creation_time; assert(this_score >= 0); - DSS_DEBUG_LOG("%s: score %lli\n", s->name, (long long)score); + //DSS_DEBUG_LOG("%s: score %lli\n", s->name, (long long)score); if (this_score < score) { score = this_score; victim = s; @@ -355,33 +263,35 @@ int remove_redundant_snapshot(struct snapshot_list *sl, prev = s; } assert(victim); - if (dry_run) { - printf("%s would be removed (interval = %i)\n", + if (conf.dry_run_given) { + dss_msg("%s would be removed (interval = %i)\n", victim->name, victim->interval); continue; } - ret = remove_snapshot(victim, pid); + ret = remove_snapshot(victim, "redundant"); return ret < 0? ret : 1; } return 0; } -int remove_old_snapshot(struct snapshot_list *sl, int dry_run, pid_t *pid) +static int remove_outdated_snapshot(struct snapshot_list *sl) { int i, ret; struct snapshot *s; - DSS_INFO_LOG("looking for snapshots belonging to intervals greater than %d\n", + DSS_DEBUG_LOG("looking for snapshots belonging to intervals greater than %d\n", conf.num_intervals_arg); FOR_EACH_SNAPSHOT(s, i, sl) { + if (snapshot_is_being_created(s)) + continue; if (s->interval <= conf.num_intervals_arg) continue; - if (dry_run) { - printf("%s would be removed (interval = %i)\n", + if (conf.dry_run_given) { + dss_msg("%s would be removed (interval = %i)\n", s->name, s->interval); continue; } - ret = remove_snapshot(s, pid); + ret = remove_snapshot(s, "outdated"); if (ret < 0) return ret; return 1; @@ -389,112 +299,448 @@ int remove_old_snapshot(struct snapshot_list *sl, int dry_run, pid_t *pid) return 0; } -int wait_for_rm_process(pid_t pid) +static int remove_oldest_snapshot(struct snapshot_list *sl) +{ + struct snapshot *s = get_oldest_snapshot(sl); + + if (!s) /* no snapshot found */ + return 0; + DSS_INFO_LOG("oldest snapshot: %s\n", s->name); + if (snapshot_is_being_created(s)) + return 0; + return remove_snapshot(s, "oldest"); +} + +static int rename_incomplete_snapshot(int64_t start) { - int status, es, ret = wait_for_process(pid, &status); + char *old_name; + int ret; + + free(path_to_last_complete_snapshot); + ret = complete_name(start, get_current_time(), + &path_to_last_complete_snapshot); if (ret < 0) return ret; - if (!WIFEXITED(status)) { - ret = E_INVOLUNTARY_EXIT; - make_err_msg("rm process %d died involuntary", (int)pid); + old_name = incomplete_name(start); + ret = dss_rename(old_name, path_to_last_complete_snapshot); + if (ret >= 0) + DSS_NOTICE_LOG("%s -> %s\n", old_name, + path_to_last_complete_snapshot); + free(old_name); + return ret; +} + +static int try_to_free_disk_space(int low_disk_space) +{ + int ret; + struct snapshot_list sl; + + if (!low_disk_space && conf.keep_redundant_given) + return 0; + dss_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 = -ERRNO_TO_DSS_ERROR(ENOSPC); +out: + free_snapshot_list(&sl); + return ret; +} + +static int pre_create_hook(void) +{ + int ret, fds[3] = {0, 0, 0}; + + if (!conf.pre_create_hook_given) { + snapshot_creation_status = SCS_PRE_HOOK_SUCCESS; + return 0; + } + DSS_NOTICE_LOG("executing %s\n", conf.pre_create_hook_arg); + ret = dss_exec_cmdline_pid(&create_pid, + conf.pre_create_hook_arg, fds); + if (ret < 0) + return ret; + snapshot_creation_status = SCS_PRE_HOOK_RUNNING; + return ret; +} + +static 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(); + return 0; + } + cmd = make_message("%s %s/%s", conf.post_create_hook_arg, + conf.dest_dir_arg, path_to_last_complete_snapshot); + DSS_NOTICE_LOG("executing %s\n", cmd); + ret = dss_exec_cmdline_pid(&create_pid, cmd, fds); + free(cmd); + if (ret < 0) + return ret; + snapshot_creation_status = SCS_POST_HOOK_RUNNING; + return ret; +} + +static void kill_process(pid_t pid) +{ + if (!pid) + return; + DSS_WARNING_LOG("sending SIGTERM to pid %d\n", (int)pid); + kill(pid, SIGTERM); +} + +static void stop_create_process(void) +{ + if (!create_pid || create_process_stopped) + return; + kill(SIGSTOP, create_pid); + create_process_stopped = 1; +} + +static void restart_create_process(void) +{ + if (!create_pid || !create_process_stopped) + return; + kill (SIGCONT, create_pid); + create_process_stopped = 0; +} + +/** + * Print a log message about the exit status of a child. + */ +static 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); +} + +static int wait_for_process(pid_t pid, int *status) +{ + int ret; + + DSS_DEBUG_LOG("Waiting for process %d to terminate\n", (int)pid); + for (;;) { + fd_set rfds; + + 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); + } + if (ret < 0) + DSS_ERROR_LOG("failed to wait for process %d\n", (int)pid); + else + log_termination_msg(pid, *status); + return ret; +} + +static 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; +} + +static 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); +} + +static int handle_rsync_exit(int status) +{ + int es, ret; + + if (!WIFEXITED(status)) { + DSS_ERROR_LOG("rsync process %d died involuntary\n", (int)create_pid); + ret = -E_INVOLUNTARY_EXIT; + snapshot_creation_status = SCS_READY; + compute_next_snapshot_time(); + goto out; + } + es = WEXITSTATUS(status); + if (es == 13) { /* Errors with program diagnostics */ + DSS_WARNING_LOG("rsync process %d returned %d -- restarting\n", + (int)create_pid, es); + snapshot_creation_status = SCS_RSYNC_NEEDS_RESTART; + gettimeofday(&next_snapshot_time, NULL); + next_snapshot_time.tv_sec += 60; + ret = 1; + goto out; + } + if (es != 0 && es != 23 && es != 24) { + DSS_ERROR_LOG("rsync process %d returned %d\n", (int)create_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) + goto out; + snapshot_creation_status = SCS_RSYNC_SUCCESS; +out: + create_pid = 0; + create_process_stopped = 0; + return ret; +} + +static int handle_pre_create_hook_exit(int status) +{ + int es, ret; + + if (!WIFEXITED(status)) { + snapshot_creation_status = SCS_READY; + compute_next_snapshot_time(); + ret = -E_INVOLUNTARY_EXIT; + goto out; } es = WEXITSTATUS(status); if (es) { + snapshot_creation_status = SCS_READY; + compute_next_snapshot_time(); ret = -E_BAD_EXIT_CODE; - make_err_msg("rm process %d returned %d", (int)pid, es); + goto out; + } + snapshot_creation_status = SCS_PRE_HOOK_SUCCESS; + ret = 1; +out: + create_pid = 0; + return ret; +} + +static int handle_sigchld(void) +{ + pid_t pid; + int status, ret = reap_child(&pid, &status); + + if (ret <= 0) return ret; + + if (pid == create_pid) { + switch (snapshot_creation_status) { + case SCS_PRE_HOOK_RUNNING: + return handle_pre_create_hook_exit(status); + case SCS_RSYNC_RUNNING: + return handle_rsync_exit(status); + case SCS_POST_HOOK_RUNNING: + snapshot_creation_status = SCS_READY; + compute_next_snapshot_time(); + return 1; + default: + DSS_EMERG_LOG("BUG: create can't die in status %d\n", + snapshot_creation_status); + return -E_BUG; + } } - return 1; + if (pid == rm_pid) + return handle_rm_exit(status); + DSS_EMERG_LOG("BUG: unknown process %d died\n", (int)pid); + return -E_BUG; } -int com_run(int argc, char * const * argv) +static int check_config(void) { - return 42; + 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; } -int com_prune(int argc, char * const * argv) +static int parse_config_file(int override) { - int ret, dry_run = 0; - struct snapshot_list sl; - pid_t pid; + int ret; + char *config_file; + struct stat statbuf; + char *old_logfile_arg = NULL; + int old_daemon_given = 0; - if (argc > 2) { - make_err_msg("too many arguments"); - return -E_SYNTAX; + 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; } - if (argc == 2) { - if (strcmp(argv[1], "-d")) { - make_err_msg("%s", argv[1]); - return -E_SYNTAX; + + 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, + .print_errors = 1 + }; + if (override) { /* invalidate all rsync options */ + int i; + + for (i = 0; i < conf.rsync_option_given; i++) { + free(conf.rsync_option_arg[i]); + conf.rsync_option_arg[i] = NULL; + } + conf.rsync_option_given = 0; } - dry_run = 1; + cmdline_parser_config_file(config_file, &conf, ¶ms); } - for (;;) { - get_snapshot_list(&sl); - ret = remove_old_snapshot(&sl, dry_run, &pid); - free_snapshot_list(&sl); - if (ret < 0) - return ret; - if (!ret) - break; - ret = wait_for_rm_process(pid); - if (ret < 0) - goto out; + 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; + } } - for (;;) { - get_snapshot_list(&sl); - ret = remove_redundant_snapshot(&sl, dry_run, &pid); - free_snapshot_list(&sl); - if (ret < 0) - return ret; - if (!ret) - break; - ret = wait_for_rm_process(pid); - if (ret < 0) - goto out; + if (conf.logfile_given) { + logfile = open_log(conf.logfile_arg); + log_welcome(conf.loglevel_arg); } - return 1; + DSS_DEBUG_LOG("loglevel: %d\n", conf.loglevel_arg); +// cmdline_parser_dump(logfile? logfile : stdout, &conf); out: + free(config_file); + if (ret < 0) + DSS_EMERG_LOG("%s\n", dss_strerror(-ret)); return ret; } -struct newest_snapshot_data { - char * newest_name; - int64_t newest_creation_time; - int64_t now; -}; +static int change_to_dest_dir(void) +{ + DSS_INFO_LOG("changing cwd to %s\n", conf.dest_dir_arg); + return dss_chdir(conf.dest_dir_arg); +} + +static int handle_sighup(void) +{ + int ret; + + DSS_NOTICE_LOG("SIGHUP\n"); + ret = parse_config_file(1); + if (ret < 0) + return ret; + return change_to_dest_dir(); +} -int get_newest_complete(const char *dirname, void *private) +static int handle_signal(void) { - struct newest_snapshot_data *nsd = private; - struct snapshot s; - int ret = is_snapshot(dirname, nsd->now, &s); + int sig, ret = next_signal(); if (ret <= 0) - return 1; - if (s.creation_time < nsd->newest_creation_time) - return 1; - nsd->newest_creation_time = s.creation_time; - free(nsd->newest_name); - nsd->newest_name = s.name; - return 1; + goto out; + sig = ret; + switch (sig) { + case SIGINT: + case SIGTERM: + restart_create_process(); + kill_process(create_pid); + kill_process(rm_pid); + ret = -E_SIGNAL; + break; + case SIGHUP: + ret = handle_sighup(); + break; + case SIGCHLD: + ret = handle_sigchld(); + break; + } +out: + if (ret < 0) + DSS_ERROR_LOG("%s\n", dss_strerror(-ret)); + return ret; } -__malloc char *name_of_newest_complete_snapshot(void) +/* + * We can not use rsync locally if the local user is different from the remote + * user or if the src dir is not on the local host (or both). + */ +static int use_rsync_locally(char *logname) { - struct newest_snapshot_data nsd = { - .now = get_current_time(), - .newest_creation_time = -1 - }; - for_each_subdir(get_newest_complete, &nsd); - return nsd.newest_name; + char *h = conf.remote_host_arg; + + if (strcmp(h, "localhost") && strcmp(h, "127.0.0.1")) + return 0; + if (conf.remote_user_given && strcmp(conf.remote_user_arg, logname)) + return 0; + return 1; } -void create_rsync_argv(char ***argv, int64_t *num) +static void create_rsync_argv(char ***argv, int64_t *num) { - char *logname, *newest = name_of_newest_complete_snapshot(); + char *logname, *newest; int i = 0, j; + struct snapshot_list sl; + + 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"); @@ -507,14 +753,9 @@ void create_rsync_argv(char ***argv, int64_t *num) (*argv)[i++] = make_message("--link-dest=../%s", newest); free(newest); } else - DSS_INFO_LOG("no previous snapshot found"); - if (conf.exclude_patterns_given) { - (*argv)[i++] = dss_strdup("--exclude-from"); - (*argv)[i++] = dss_strdup(conf.exclude_patterns_arg); - - } + DSS_INFO_LOG("no previous snapshot found\n"); logname = dss_logname(); - if (conf.remote_user_given && !strcmp(conf.remote_user_arg, logname)) + if (use_rsync_locally(logname)) (*argv)[i++] = dss_strdup(conf.source_dir_arg); else (*argv)[i++] = make_message("%s@%s:%s/", conf.remote_user_given? @@ -528,186 +769,297 @@ void create_rsync_argv(char ***argv, int64_t *num) DSS_DEBUG_LOG("argv[%d] = %s\n", j, (*argv)[j]); } -void free_rsync_argv(char **argv) +static void free_rsync_argv(char **argv) { int i; + + if (!argv) + return; for (i = 0; argv[i]; i++) free(argv[i]); free(argv); } -int create_snapshot(char **argv, pid_t *pid) +static int create_snapshot(char **argv) +{ + int ret, fds[3] = {0, 0, 0}; + char *name; + + name = incomplete_name(current_snapshot_creation_time); + DSS_NOTICE_LOG("creating new snapshot %s\n", name); + free(name); + ret = dss_exec(&create_pid, argv[0], argv, fds); + if (ret < 0) + return ret; + snapshot_creation_status = SCS_RSYNC_RUNNING; + return ret; +} + +static int select_loop(void) +{ + int ret; + /* check every 60 seconds for free disk space */ + struct timeval tv; + char **rsync_argv = NULL; + + for (;;) { + fd_set rfds; + int low_disk_space; + struct timeval now, *tvp; + + if (rm_pid) + tvp = NULL; /* sleep until rm process dies */ + else { /* sleep one minute */ + tv.tv_sec = 60; + tv.tv_usec = 0; + tvp = &tv; + } + FD_ZERO(&rfds); + FD_SET(signal_pipe, &rfds); + DSS_DEBUG_LOG("tvp: %p, tv_sec : %lu\n", tvp, (long unsigned) tv.tv_sec); + ret = dss_select(signal_pipe + 1, &rfds, NULL, tvp); + if (ret < 0) + goto out; + if (FD_ISSET(signal_pipe, &rfds)) { + ret = handle_signal(); + if (ret < 0) + goto out; + } + if (rm_pid) + continue; + ret = disk_space_low(); + if (ret < 0) + goto out; + low_disk_space = ret; + ret = try_to_free_disk_space(low_disk_space); + if (ret < 0) + goto out; + if (rm_pid) { + stop_create_process(); + continue; + } + restart_create_process(); + gettimeofday(&now, NULL); + if (tv_diff(&next_snapshot_time, &now, NULL) > 0) + continue; + switch (snapshot_creation_status) { + case SCS_READY: + ret = pre_create_hook(); + if (ret < 0) + goto out; + continue; + case SCS_PRE_HOOK_RUNNING: + continue; + case SCS_RSYNC_NEEDS_RESTART: + ret = create_snapshot(rsync_argv); + if (ret < 0) + goto out; + continue; + case SCS_PRE_HOOK_SUCCESS: + free_rsync_argv(rsync_argv); + create_rsync_argv(&rsync_argv, ¤t_snapshot_creation_time); + ret = create_snapshot(rsync_argv); + if (ret < 0) + goto out; + continue; + case SCS_RSYNC_RUNNING: + continue; + case SCS_RSYNC_SUCCESS: + ret = post_create_hook(); + if (ret < 0) + goto out; + continue; + case SCS_POST_HOOK_RUNNING: + continue; + } + } +out: + return ret; +} + +static void exit_hook(int exit_code) { int fds[3] = {0, 0, 0}; + char *argv[] = {conf.exit_hook_arg, dss_strerror(-exit_code), NULL}; + pid_t pid; - return dss_exec(pid, argv[0], argv, fds); + if (!conf.exit_hook_given) + return; + DSS_NOTICE_LOG("executing %s %s\n", argv[0], argv[1]); + dss_exec(&pid, conf.exit_hook_arg, argv, fds); } -int rename_incomplete_snapshot(int64_t start) +static int com_run(void) { - char *old_name, *new_name; int ret; - ret = complete_name(start, get_current_time(), &new_name); + if (conf.dry_run_given) { + DSS_ERROR_LOG("dry_run not supported by this command\n"); + return -E_SYNTAX; + } + ret = install_sighandler(SIGHUP); if (ret < 0) return ret; - old_name = incomplete_name(start); - ret = dss_rename(old_name, new_name); - if (ret >= 0) - DSS_NOTICE_LOG("%s -> %s\n", old_name, new_name); - free(old_name); - free(new_name); + compute_next_snapshot_time(); + ret = select_loop(); + if (ret >= 0) /* impossible */ + ret = -E_BUG; + exit_hook(ret); return ret; } -int com_create(int argc, __a_unused char * const * argv) +static int com_prune(void) { - int ret, status, es; + int ret; + struct snapshot_list sl; + struct disk_space ds; + + ret = get_disk_space(".", &ds); + if (ret < 0) + return ret; + log_disk_space(&ds); + for (;;) { + dss_get_snapshot_list(&sl); + ret = remove_outdated_snapshot(&sl); + free_snapshot_list(&sl); + if (ret < 0) + return ret; + if (!ret) + break; + ret = wait_for_rm_process(); + if (ret < 0) + goto out; + } + for (;;) { + dss_get_snapshot_list(&sl); + ret = remove_redundant_snapshot(&sl); + free_snapshot_list(&sl); + if (ret < 0) + return ret; + if (!ret) + break; + ret = wait_for_rm_process(); + if (ret < 0) + goto out; + } + return 1; +out: + return ret; +} + +static int com_create(void) +{ + int ret, status; char **rsync_argv; - int64_t snapshot_num; - pid_t pid; - if (argc != 1) { - ret = -E_SYNTAX; - make_err_msg("create: no args expected, %d given", argc - 1); + if (conf.dry_run_given) { + int i; + char *msg = NULL; + create_rsync_argv(&rsync_argv, ¤t_snapshot_creation_time); + for (i = 0; rsync_argv[i]; i++) { + char *tmp = msg; + msg = make_message("%s%s%s", tmp? tmp : "", + tmp? " " : "", rsync_argv[i]); + free(tmp); + } + free_rsync_argv(rsync_argv); + dss_msg("%s\n", msg); + free(msg); + return 1; + } + ret = pre_create_hook(); + if (ret < 0) return ret; + if (create_pid) { + ret = wait_for_process(create_pid, &status); + if (ret < 0) + return ret; + ret = handle_pre_create_hook_exit(status); + if (ret < 0) + return ret; } - create_rsync_argv(&rsync_argv, &snapshot_num); - DSS_NOTICE_LOG("creating snapshot %lli\n", (long long)snapshot_num); - ret = create_snapshot(rsync_argv, &pid); + create_rsync_argv(&rsync_argv, ¤t_snapshot_creation_time); + ret = create_snapshot(rsync_argv); if (ret < 0) goto out; - ret = wait_for_process(pid, &status); + ret = wait_for_process(create_pid, &status); if (ret < 0) goto out; - if (!WIFEXITED(status)) { - ret = E_INVOLUNTARY_EXIT; - make_err_msg("rsync process %d died involuntary", (int)pid); - goto out; - } - es = WEXITSTATUS(status); - if (es != 0 && es != 23 && es != 24) { - ret = -E_BAD_EXIT_CODE; - make_err_msg("rsync process %d returned %d", (int)pid, es); + ret = handle_rsync_exit(status); + if (ret < 0) goto out; - } - ret = rename_incomplete_snapshot(snapshot_num); + post_create_hook(); + if (create_pid) + ret = wait_for_process(create_pid, &status); out: free_rsync_argv(rsync_argv); return ret; } -int com_ls(int argc, __a_unused char * const * argv) +static int com_ls(void) { - int i, ret; + int i; struct snapshot_list sl; struct snapshot *s; - if (argc != 1) { - ret = -E_SYNTAX; - make_err_msg("ls: no args expected, %d given", argc - 1); - return ret; - } - get_snapshot_list(&sl); - FOR_EACH_SNAPSHOT(s, i, &sl) - printf("%u\t%s\n", s->interval, s->name); + + dss_get_snapshot_list(&sl); + FOR_EACH_SNAPSHOT(s, i, &sl) { + int64_t d = 0; + if (s->flags & SS_COMPLETE) + d = (s->completion_time - s->creation_time) / 60; + dss_msg("%u\t%s\t%3" PRId64 ":%02" PRId64 "\n", s->interval, s->name, d/60, d%60); + }; free_snapshot_list(&sl); return 1; } -/* TODO: Unlink pid file */ -__noreturn void clean_exit(int status) -{ - //kill(0, SIGTERM); - free(dss_error_txt); - exit(status); -} - -__printf_2_3 void dss_log(int ll, const char* fmt,...) -{ - va_list argp; - if (ll < conf.loglevel_arg) - return; - va_start(argp, fmt); - vfprintf(stderr, fmt, argp); - va_end(argp); -} - -int read_config_file(void) +static int setup_signal_handling(void) { int ret; - char *config_file; - struct stat statbuf; - 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); - } - ret = stat(config_file, &statbuf); - if (ret && conf.config_file_given) { - ret = -ERRNO_TO_DSS_ERROR(errno); - make_err_msg("failed to stat config file %s", config_file); - goto out; - } - if (!ret) { - struct cmdline_parser_params params = { - .override = 0, - .initialize = 0, - .check_required = 0, - .check_ambiguity = 0 - }; - cmdline_parser_config_file(config_file, &conf, ¶ms); - } - if (!conf.source_dir_given || !conf.dest_dir_given) { - ret = -E_SYNTAX; - make_err_msg("you need to specify both source_dir and dest_dir"); - goto out; - } - ret = 1; -out: - free(config_file); - return ret; -} - -int check_config(void) -{ - if (conf.unit_interval_arg <= 0) { - make_err_msg("bad unit interval: %i", 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) { - make_err_msg("bad number of intervals %i", conf.num_intervals_arg); - return -E_INVALID_NUMBER; - } - DSS_DEBUG_LOG("number of intervals: %i\n", conf.num_intervals_arg); - return 1; + DSS_INFO_LOG("setting up signal handlers\n"); + signal_pipe = signal_init(); /* always successful */ + ret = install_sighandler(SIGINT); + if (ret < 0) + return ret; + ret = install_sighandler(SIGTERM); + if (ret < 0) + return ret; + return install_sighandler(SIGCHLD); } +/** + * The main function of dss. + * + * \param argc Usual argument count. + * \param argv Usual argument vector. + */ int main(int argc, char **argv) { int ret; + struct cmdline_parser_params params = { + .override = 0, + .initialize = 1, + .check_required = 0, + .check_ambiguity = 0, + .print_errors = 1 + }; - cmdline_parser(argc, argv, &conf); /* aborts on errors */ - if (!conf.inputs_num) { - ret = -E_SYNTAX; - make_err_msg("no command given"); - goto out; - } - ret = read_config_file(); + cmdline_parser_ext(argc, argv, &conf, ¶ms); /* aborts on errors */ + ret = parse_config_file(0); if (ret < 0) goto out; - ret = check_config(); + if (conf.daemon_given) + daemon_init(); + ret = change_to_dest_dir(); if (ret < 0) goto out; - ret = dss_chdir(conf.dest_dir_arg); + ret = setup_signal_handling(); if (ret < 0) goto out; - ret = call_command_handler(conf.inputs_num, conf.inputs); + ret = call_command_handler(); out: if (ret < 0) - log_err_msg(EMERG, -ret); - clean_exit(ret >= 0? EXIT_SUCCESS : EXIT_FAILURE); + DSS_EMERG_LOG("%s\n", dss_strerror(-ret)); + exit(ret >= 0? EXIT_SUCCESS : EXIT_FAILURE); }