X-Git-Url: http://git.tuebingen.mpg.de/?p=dss.git;a=blobdiff_plain;f=dss.c;h=3d00b0b38be37b50878375257d90f9871412c957;hp=4ca1743a63aa9011348f579bebc78199c28bbaae;hb=27edbe5dcf615a3c445f719b5833af4d392c5874;hpb=70e306b60780c8bd3574b5668adc7f18f3669c9f diff --git a/dss.c b/dss.c index 4ca1743..3d00b0b 100644 --- a/dss.c +++ b/dss.c @@ -30,9 +30,8 @@ struct gengetopt_args_info conf; -char *dss_error_txt = NULL; static FILE *logfile; -int signal_pipe; +static int signal_pipe; /** Process id of current rsync process. */ static pid_t rsync_pid; @@ -42,9 +41,33 @@ static int rsync_stopped; static pid_t rm_pid; /** When the next snapshot is due. */ struct timeval next_snapshot_time; +/** The pid of the pre-create hook. */ +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; + DEFINE_DSS_ERRLIST; @@ -75,7 +98,9 @@ int call_command_handler(void) * 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, }; @@ -87,19 +112,6 @@ struct snapshot { unsigned interval; }; -/* - * An edge snapshot is either the oldest one or the newest one. - * - * We need to find either of them occasionally: The create code - * needs to know the newest snapshot because that is the one - * used as the link destination dir. The pruning code needs to - * find the oldest one in case disk space becomes low. - */ -struct edge_snapshot_data { - int64_t now; - struct snapshot snap; -}; - __printf_2_3 void dss_log(int ll, const char* fmt,...) { va_list argp; @@ -149,6 +161,7 @@ unsigned num_snapshots(int interval) 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) { int i, ret; @@ -166,10 +179,8 @@ int is_snapshot(const char *dirname, int64_t now, struct snapshot *s) tmp[i] = '\0'; ret = dss_atoi64(tmp, &num); free(tmp); - if (ret < 0) { - free(dss_error_txt); + if (ret < 0) return 0; - } assert(num >= 0); if (num > now) return 0; @@ -198,10 +209,8 @@ int is_snapshot(const char *dirname, int64_t now, struct snapshot *s) tmp[i] = '\0'; ret = dss_atoi64(tmp, &num); free(tmp); - if (ret < 0) { - free(dss_error_txt); + if (ret < 0) return 0; - } if (num > now) return 0; s->completion_time = num; @@ -243,22 +252,14 @@ int complete_name(int64_t start, int64_t end, char **result) 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)) { - make_err_msg("%lli", (long long)start); + if (!localtime_r(start_seconds, &start_tm)) return -E_LOCALTIME; - } - if (!localtime_r(end_seconds, &end_tm)) { - make_err_msg("%lli", (long long)end); + 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)) { - make_err_msg("%lli", (long long)start); + 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)) { - make_err_msg("%lli", (long long)end); + 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; @@ -281,7 +282,15 @@ struct snapshot_list { #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))) @@ -327,6 +336,22 @@ void get_snapshot_list(struct snapshot_list *sl) 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) @@ -343,19 +368,6 @@ void restart_rsync_process(void) rsync_stopped = 0; } -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); - free(sl->snapshots); -} - /** * Print a log message about the exit status of a child. */ @@ -377,26 +389,32 @@ int wait_for_process(pid_t pid, int *status) DSS_DEBUG_LOG("Waiting for process %d to terminate\n", (int)pid); for (;;) { - pause(); - ret = next_signal(); - if (ret < 0) + 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 */ + 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) { - ret = -ERRNO_TO_DSS_ERROR(errno); - make_err_msg("failed to wait for process %d", (int)pid); - } else + if (ret < 0) + DSS_ERROR_LOG("failed to wait for process %d\n", (int)pid); + else log_termination_msg(pid, *status); return ret; } @@ -418,6 +436,7 @@ out: free(new_name); return ret; } + /* * return: 0: no redundant snapshots, 1: rm process started, negative: error */ @@ -436,8 +455,8 @@ int remove_redundant_snapshot(struct snapshot_list *sl) 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 */ @@ -504,26 +523,14 @@ int remove_outdated_snapshot(struct snapshot_list *sl) int handle_rm_exit(int status) { - int es, ret; - - if (!WIFEXITED(status)) { - make_err_msg("rm process %d died involuntary", (int)rm_pid); - ret = -E_INVOLUNTARY_EXIT; - goto out; - } - es = WEXITSTATUS(status); - if (es) { - make_err_msg("rm process %d returned %d", (int)rm_pid, es); - ret = -E_BAD_EXIT_CODE; - goto out; - } - ret = 1; rm_pid = 0; -out: - return ret; + 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); @@ -541,78 +548,201 @@ void kill_process(pid_t pid) kill(pid, SIGTERM); } -void handle_sighup() +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_INFO_LOG("FIXME: no sighup handling yet\n"); + DSS_NOTICE_LOG("SIGHUP\n"); + parse_config_file(1); } int rename_incomplete_snapshot(int64_t start) { - char *old_name, *new_name; + char *old_name; int ret; - ret = complete_name(start, get_current_time(), &new_name); + free(path_to_last_complete_snapshot); + ret = complete_name(start, get_current_time(), + &path_to_last_complete_snapshot); if (ret < 0) return ret; old_name = incomplete_name(start); - ret = dss_rename(old_name, new_name); + ret = dss_rename(old_name, path_to_last_complete_snapshot); if (ret >= 0) - DSS_NOTICE_LOG("%s -> %s\n", old_name, new_name); + DSS_NOTICE_LOG("%s -> %s\n", old_name, + path_to_last_complete_snapshot); free(old_name); - free(new_name); return ret; } +void compute_next_snapshot_time(void) +{ + 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; + 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) + goto out; +min_sleep: + next_snapshot_time = now; + next_snapshot_time.tv_sec += 60; +out: + free_snapshot_list(&sl); +} int handle_rsync_exit(int status) { int es, ret; if (!WIFEXITED(status)) { - make_err_msg("rsync process %d died involuntary", (int)rsync_pid); + 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) { - make_err_msg("rsync process %d returned %d", (int)rsync_pid, es); + 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) + goto out; + snapshot_creation_status = SCS_RSYNC_SUCCESS; out: rsync_pid = 0; - current_snapshot_creation_time = 0; rsync_stopped = 0; return ret; } - -int get_newest_complete(const char *dirname, void *private) +__malloc char *name_of_newest_complete_snapshot(void) { - struct edge_snapshot_data *esd = private; - struct snapshot s; - int ret = is_snapshot(dirname, esd->now, &s); + struct snapshot_list sl; + struct snapshot *s; + int i; + char *name = NULL; - if (ret <= 0) - return 1; - if (s.flags != SS_COMPLETE) /* incomplete or being deleted */ - return 1; - if (s.creation_time < esd->snap.creation_time) - return 1; - free(esd->snap.name); - esd->snap = s; - return 1; -} + get_snapshot_list(&sl); -__malloc char *name_of_newest_complete_snapshot(void) -{ - struct edge_snapshot_data esd = { - .now = get_current_time(), - .snap = {.creation_time = -1} - }; - for_each_subdir(get_newest_complete, &esd); - return esd.snap.name; + 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 create_rsync_argv(char ***argv, int64_t *num) @@ -660,48 +790,106 @@ void free_rsync_argv(char **argv) free(argv); } +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(&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(); + 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; +} + int create_snapshot(char **argv) { - int fds[3] = {0, 0, 0}; - char *name = incomplete_name(current_snapshot_creation_time); + 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); - return dss_exec(&rsync_pid, argv[0], argv, fds); + ret = dss_exec(&rsync_pid, argv[0], argv, fds); + if (ret < 0) + return ret; + snapshot_creation_status = SCS_RSYNC_RUNNING; + return ret; } -void compute_next_snapshot_time(struct snapshot_list *sl) +int handle_pre_create_hook_exit(int status) { - 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; + int es, ret; - gettimeofday(&now, NULL); - FOR_EACH_SNAPSHOT(s, i, sl) { - if (!(s->flags & SS_COMPLETE)) - continue; - num_complete_snapshots++; - x += s->completion_time - s->creation_time; + if (!WIFEXITED(status)) { + snapshot_creation_status = SCS_READY; + compute_next_snapshot_time(); + ret = -E_INVOLUNTARY_EXIT; + goto out; } - 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); /* time between creation */ - if (ret < 0) { - next_snapshot_time = now; - return; + es = WEXITSTATUS(status); + if (es) { + snapshot_creation_status = SCS_READY; + compute_next_snapshot_time(); + ret = -E_BAD_EXIT_CODE; + goto out; + } + snapshot_creation_status = SCS_PRE_HOOK_SUCCESS; + ret = 1; +out: + pre_create_hook_pid = 0; + return ret; +} + +int handle_sigchld() +{ + pid_t pid; + int status, ret = reap_child(&pid, &status); + + if (ret <= 0) + return ret; + if (pid == rsync_pid) + return handle_rsync_exit(status); + if (pid == rm_pid) + return handle_rm_exit(status); + if (pid == pre_create_hook_pid) + return handle_pre_create_hook_exit(status); + if (pid == post_create_hook_pid) { + snapshot_creation_status = SCS_READY; + compute_next_snapshot_time(); + return 1; } - tv_divide(wanted, &diff, &tmp); - tv_add(&now, &tmp, &next_snapshot_time); + DSS_EMERG_LOG("BUG: unknown process %d died\n", (int)pid); + exit(EXIT_FAILURE); } -void handle_signal(struct snapshot_list *sl) +void handle_signal(void) { int sig, ret = next_signal(); @@ -709,8 +897,6 @@ void handle_signal(struct snapshot_list *sl) goto out; sig = ret; switch (sig) { - int status; - pid_t pid; case SIGINT: case SIGTERM: restart_rsync_process(); @@ -719,58 +905,27 @@ void handle_signal(struct snapshot_list *sl) exit(EXIT_FAILURE); case SIGHUP: handle_sighup(); + ret = 1; break; case SIGCHLD: - ret = reap_child(&pid, &status); - if (ret <= 0) - break; - assert(pid == rsync_pid || pid == rm_pid); - if (pid == rsync_pid) - ret = handle_rsync_exit(status); - else - ret = handle_rm_exit(status); - free_snapshot_list(sl); - get_snapshot_list(sl); - compute_next_snapshot_time(sl); + ret = handle_sigchld(); + break; } out: if (ret < 0) - log_err_msg(ERROR, -ret); + DSS_ERROR_LOG("%s\n", dss_strerror(-ret)); } -int get_oldest(const char *dirname, void *private) +int remove_oldest_snapshot(struct snapshot_list *sl) { - struct edge_snapshot_data *esd = private; - struct snapshot s; - int ret = is_snapshot(dirname, esd->now, &s); + struct snapshot *s = oldest_snapshot(sl); - if (ret <= 0) - return 1; - if (s.creation_time > esd->snap.creation_time) - return 1; - free(esd->snap.name); - esd->snap = s; - return 1; -} - -int remove_oldest_snapshot() -{ - int ret; - struct edge_snapshot_data esd = { - .now = get_current_time(), - .snap = {.creation_time = LLONG_MAX} - }; - for_each_subdir(get_oldest, &esd); - if (!esd.snap.name) /* no snapshot found */ + if (!s) /* no snapshot found */ return 0; - DSS_INFO_LOG("oldest snapshot: %s\n", esd.snap.name); - ret = 0; - if (esd.snap.creation_time == current_snapshot_creation_time) - goto out; /* do not remove the snapshot currently being created */ - ret = remove_snapshot(&esd.snap); -out: - free(esd.snap.name); - return ret; + 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); } /* TODO: Also consider number of inodes. */ @@ -790,52 +945,56 @@ int disk_space_low(void) return 0; } -int try_to_free_disk_space(int low_disk_space, struct snapshot_list *sl) +int try_to_free_disk_space(int low_disk_space) { int ret; + struct snapshot_list sl; - ret = remove_outdated_snapshot(sl); + get_snapshot_list(&sl); + ret = remove_outdated_snapshot(&sl); if (ret) /* error, or we are removing something */ - return ret; + goto out; /* no outdated snapshot */ - ret = remove_redundant_snapshot(sl); + ret = remove_redundant_snapshot(&sl); if (ret) - return ret; + goto out; + ret = 0; if (!low_disk_space) - return 0; + goto out; DSS_WARNING_LOG("disk space low and nothing obvious to remove\n"); - ret = remove_oldest_snapshot(); + ret = remove_oldest_snapshot(&sl); if (ret) - return ret; - make_err_msg("uhuhu: not enough disk space for a single snapshot"); - return -ENOSPC; + 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 select_loop(void) { int ret; struct timeval tv = {.tv_sec = 0, .tv_usec = 0}; - struct snapshot_list sl = {.num_snapshots = 0}; - get_snapshot_list(&sl); - compute_next_snapshot_time(&sl); for (;;) { - struct timeval now, *tvp = &tv; fd_set rfds; int low_disk_space; char **rsync_argv; + struct timeval now, *tvp = &tv; - FD_ZERO(&rfds); - FD_SET(signal_pipe, &rfds); if (rsync_pid) - tv.tv_sec = 60; + tv.tv_sec = 60; /* check every 60 seconds for free disk space */ else if (rm_pid) - tvp = NULL; + tvp = NULL; /* sleep until rm process dies */ + 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) return ret; if (FD_ISSET(signal_pipe, &rfds)) - handle_signal(&sl); + handle_signal(); if (rm_pid) continue; ret = disk_space_low(); @@ -844,26 +1003,42 @@ int select_loop(void) low_disk_space = ret; if (low_disk_space) stop_rsync_process(); - ret = try_to_free_disk_space(low_disk_space, &sl); + ret = try_to_free_disk_space(low_disk_space); if (ret < 0) break; if (rm_pid) continue; - if (rsync_pid) { - restart_rsync_process(); - continue; - } - /* neither rsync nor rm are running. Start rsync? */ + restart_rsync_process(); gettimeofday(&now, NULL); if (tv_diff(&next_snapshot_time, &now, &tv) > 0) continue; - create_rsync_argv(&rsync_argv, ¤t_snapshot_creation_time); - ret = create_snapshot(rsync_argv); - free_rsync_argv(rsync_argv); - if (ret < 0) - break; + 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_PRE_HOOK_SUCCESS: + create_rsync_argv(&rsync_argv, ¤t_snapshot_creation_time); + ret = create_snapshot(rsync_argv); + free_rsync_argv(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; + } } - free_snapshot_list(&sl); +out: return ret; } @@ -872,22 +1047,16 @@ int com_run(void) int ret; if (conf.dry_run_given) { - make_err_msg("dry_run not supported by this command"); + DSS_ERROR_LOG("dry_run not supported by this command\n"); return -E_SYNTAX; } ret = install_sighandler(SIGHUP); if (ret < 0) return ret; + compute_next_snapshot_time(); return select_loop(); } -void log_disk_space(struct disk_space *ds) -{ - DSS_INFO_LOG("free: %uM/%uM (%u%%), %u%% inodes unused\n", - ds->free_mb, ds->total_mb, ds->percent_free, - ds->percent_free_inodes); -} - int com_prune(void) { int ret; @@ -932,20 +1101,33 @@ int com_create(void) int ret, status; char **rsync_argv; - create_rsync_argv(&rsync_argv, ¤t_snapshot_creation_time); 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 (pre_create_hook_pid) { + ret = wait_for_process(pre_create_hook_pid, &status); + if (ret < 0) + return ret; + ret = handle_pre_create_hook_exit(status); + if (ret < 0) + return ret; + } + create_rsync_argv(&rsync_argv, ¤t_snapshot_creation_time); ret = create_snapshot(rsync_argv); if (ret < 0) goto out; @@ -953,6 +1135,11 @@ int com_create(void) if (ret < 0) goto out; ret = handle_rsync_exit(status); + if (ret < 0) + goto out; + post_create_hook(); + if (post_create_hook_pid) + ret = wait_for_process(post_create_hook_pid, &status); out: free_rsync_argv(rsync_argv); return ret; @@ -970,68 +1157,6 @@ int com_ls(void) return 1; } -/* TODO: Unlink pid file */ -__noreturn void clean_exit(int status) -{ - //kill(0, SIGTERM); - free(dss_error_txt); - exit(status); -} - -int read_config_file(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; -} - static void setup_signal_handling(void) { int ret; @@ -1053,31 +1178,24 @@ err: exit(EXIT_FAILURE); } - int main(int argc, char **argv) { int ret; + struct cmdline_parser_params params = { + .override = 0, + .initialize = 1, + .check_required = 0, + .check_ambiguity = 0 + }; + + cmdline_parser_ext(argc, argv, &conf, ¶ms); /* aborts on errors */ + parse_config_file(0); - cmdline_parser(argc, argv, &conf); /* aborts on errors */ - ret = read_config_file(); - if (ret < 0) - goto out; - ret = check_config(); - if (ret < 0) - goto out; - if (conf.logfile_given) { - logfile = open_log(conf.logfile_arg); - log_welcome(conf.loglevel_arg); - } - ret = dss_chdir(conf.dest_dir_arg); - if (ret < 0) - goto out; if (conf.daemon_given) daemon_init(); setup_signal_handling(); 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); }