/*
- * Copyright (C) 2008-2010 Andre Noll <maan@systemlinux.org>
+ * Copyright (C) 2008-2011 Andre Noll <maan@systemlinux.org>
*
* Licensed under the GPL v2. For licencing details see COPYING.
*/
#include "df.h"
#include "time.h"
#include "snap.h"
+#include "ipc.h"
/** Command line and config file options. */
static struct gengetopt_args_info conf;
COMMAND(ls) \
COMMAND(create) \
COMMAND(prune) \
- COMMAND(run)
+ COMMAND(run) \
+ COMMAND(kill) \
+ COMMAND(reload) \
+
#define COMMAND(x) static int com_ ##x(void);
COMMANDS
#undef COMMAND
va_end(argp);
}
+static char *get_config_file_name(void)
+{
+ char *home, *config_file;
+
+ if (conf.config_file_given)
+ return dss_strdup(conf.config_file_arg);
+ home = get_homedir();
+ config_file = make_message("%s/.dssrc", home);
+ free(home);
+ return config_file;
+}
+
+static int send_signal(int sig)
+{
+ pid_t pid;
+ char *config_file = get_config_file_name();
+ int ret = get_dss_pid(config_file, &pid);
+
+ free(config_file);
+ if (ret < 0)
+ return ret;
+ if (conf.dry_run_given) {
+ dss_msg("%d\n", (int)pid);
+ return 0;
+ }
+ ret = kill(pid, sig);
+ if (ret < 0)
+ return -ERRNO_TO_DSS_ERROR(errno);
+ return 1;
+}
+
+static int com_kill(void)
+{
+ return send_signal(SIGTERM);
+}
+
+static int com_reload(void)
+{
+ return send_signal(SIGHUP);
+}
+
static void dss_get_snapshot_list(struct snapshot_list *sl)
{
get_snapshot_list(sl, conf.unit_interval_arg, conf.num_intervals_arg);
return 0;
}
-static int pre_create_hook(void)
+static void pre_create_hook(void)
{
- int ret, fds[3] = {0, 0, 0};
-
assert(snapshot_creation_status == HS_READY);
/* make sure that the next snapshot time will be recomputed */
invalidate_next_snapshot_time();
DSS_DEBUG_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;
+ dss_exec_cmdline_pid(&create_pid, conf.pre_create_hook_arg);
snapshot_creation_status = HS_PRE_RUNNING;
- return ret;
}
-static int pre_remove_hook(struct snapshot *s, const char *why)
+static void pre_remove_hook(struct snapshot *s, const char *why)
{
- int ret, fds[3] = {0, 0, 0};
char *cmd;
if (!s)
- return 0;
+ return;
DSS_DEBUG_LOG("%s snapshot %s\n", why, s->name);
assert(snapshot_removal_status == HS_READY);
assert(remove_pid == 0);
cmd = make_message("%s %s/%s", conf.pre_remove_hook_arg,
conf.dest_dir_arg, s->name);
DSS_DEBUG_LOG("executing %s\n", cmd);
- ret = dss_exec_cmdline_pid(&remove_pid, cmd, fds);
+ dss_exec_cmdline_pid(&remove_pid, cmd);
free(cmd);
- if (ret < 0)
- return ret;
snapshot_removal_status = HS_PRE_RUNNING;
- return ret;
}
static int exec_rm(void)
{
struct snapshot *s = snapshot_currently_being_removed;
- int fds[3] = {0, 0, 0};
char *new_name = being_deleted_name(s);
char *argv[] = {"rm", "-rf", new_name, NULL};
int ret;
ret = dss_rename(s->name, new_name);
if (ret < 0)
goto out;
- ret = dss_exec(&remove_pid, argv[0], argv, fds);
- if (ret < 0)
- goto out;
+ dss_exec(&remove_pid, argv[0], argv);
snapshot_removal_status = HS_RUNNING;
out:
free(new_name);
ret = -ERRNO_TO_DSS_ERROR(ENOSPC);
goto out;
remove:
- ret = pre_remove_hook(victim, why);
+ pre_remove_hook(victim, why);
out:
free_snapshot_list(&sl);
return ret;
}
-static int post_create_hook(void)
+static void post_create_hook(void)
{
- int ret, fds[3] = {0, 0, 0};
- char *cmd;
-
- cmd = make_message("%s %s/%s", conf.post_create_hook_arg,
+ char *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);
+ dss_exec_cmdline_pid(&create_pid, cmd);
free(cmd);
- if (ret < 0)
- return ret;
snapshot_creation_status = HS_POST_RUNNING;
- return ret;
}
-static int post_remove_hook(void)
+static void post_remove_hook(void)
{
- int ret, fds[3] = {0, 0, 0};
char *cmd;
struct snapshot *s = snapshot_currently_being_removed;
cmd = make_message("%s %s/%s", conf.post_remove_hook_arg,
conf.dest_dir_arg, s->name);
DSS_NOTICE_LOG("executing %s\n", cmd);
- ret = dss_exec_cmdline_pid(&remove_pid, cmd, fds);
+ dss_exec_cmdline_pid(&remove_pid, cmd);
free(cmd);
- if (ret < 0)
- return ret;
snapshot_removal_status = HS_POST_RUNNING;
- return ret;
}
static void dss_kill(pid_t pid, int sig, const char *msg)
static int parse_config_file(int override)
{
int ret, config_file_exists;
- char *config_file;
+ char *config_file = get_config_file_name();
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);
static int rename_resume_snap(int64_t creation_time)
{
struct snapshot_list sl = {.num_snapshots = 0};
- struct snapshot *s;
+ struct snapshot *s = NULL;
char *new_name = incomplete_name(creation_time);
int ret;
+ const char *why;
ret = 0;
if (conf.no_resume_given)
goto out;
dss_get_snapshot_list(&sl);
+ /*
+ * Snapshot recycling: We first look at the newest snapshot. If this
+ * snapshot happens to be incomplete, the last rsync process was
+ * aborted and we reuse this one. Otherwise we look at snapshots which
+ * could be removed (outdated and redundant snapshots) as candidates
+ * for recycling. If no outdated/redundant snapshot exists, we check if
+ * there is an orphaned snapshot, which likely is useless anyway.
+ *
+ * Only if no existing snapshot is suitable for recycling, we bite the
+ * bullet and create a new one.
+ */
s = get_newest_snapshot(&sl);
- if (!s)
+ if (!s) /* no snapshots at all */
goto out;
- if ((s->flags & SS_COMPLETE) != 0) /* complete */
+ /* re-use last snapshot if it is incomplete */
+ why = "aborted";
+ if ((s->flags & SS_COMPLETE) == 0)
goto out;
- DSS_INFO_LOG("resuming: reusing %s as destination dir\n", s->name);
- ret = dss_rename(s->name, new_name);
+ why = "outdated";
+ s = find_outdated_snapshot(&sl);
+ if (s)
+ goto out;
+ why = "redundant";
+ s = find_redundant_snapshot(&sl);
+ if (s)
+ goto out;
+ why = "orphaned";
+ s = find_orphaned_snapshot(&sl);
out:
+ if (s) {
+ DSS_INFO_LOG("reusing %s snapshot %s\n", why, s->name);
+ ret = dss_rename(s->name, new_name);
+ }
if (ret >= 0)
DSS_NOTICE_LOG("creating new snapshot %s\n", new_name);
free(new_name);
static int create_snapshot(char **argv)
{
- int ret, fds[3] = {0, 0, 0};
+ int ret;
ret = rename_resume_snap(current_snapshot_creation_time);
if (ret < 0)
return ret;
- ret = dss_exec(&create_pid, argv[0], argv, fds);
- if (ret < 0)
- return ret;
+ dss_exec(&create_pid, argv[0], argv);
snapshot_creation_status = HS_RUNNING;
return ret;
}
continue;
}
if (snapshot_removal_status == HS_SUCCESS) {
- ret = post_remove_hook();
- if (ret < 0)
- goto out;
+ post_remove_hook();
continue;
}
ret = try_to_free_disk_space();
case HS_READY:
if (!next_snapshot_is_due())
continue;
- ret = pre_create_hook();
- if (ret < 0)
- goto out;
+ pre_create_hook();
continue;
case HS_PRE_RUNNING:
case HS_RUNNING:
goto out;
continue;
case HS_SUCCESS:
- ret = post_create_hook();
- if (ret < 0)
- goto out;
+ post_create_hook();
continue;
}
}
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;
DSS_NOTICE_LOG("executing %s %s\n", argv[0], argv[1]);
- dss_exec(&pid, conf.exit_hook_arg, argv, fds);
+ dss_exec(&pid, conf.exit_hook_arg, argv);
+}
+
+static void lock_dss_or_die(void)
+{
+ char *config_file = get_config_file_name();
+ int ret = lock_dss(config_file);
+
+ free(config_file);
+ if (ret < 0) {
+ DSS_EMERG_LOG("failed to lock: %s\n", dss_strerror(-ret));
+ exit(EXIT_FAILURE);
+ }
}
static int com_run(void)
{
int ret;
+ lock_dss_or_die();
if (conf.dry_run_given) {
DSS_ERROR_LOG("dry_run not supported by this command\n");
return -E_SYNTAX;
struct disk_space ds;
const char *why;
+ lock_dss_or_die();
ret = get_disk_space(".", &ds);
if (ret < 0)
return ret;
ret = 0;
goto out;
}
- ret = pre_remove_hook(victim, why);
- if (ret < 0)
- goto out;
+ pre_remove_hook(victim, why);
if (snapshot_removal_status == HS_PRE_RUNNING) {
ret = wait_for_remove_process();
if (ret < 0)
goto out;
if (snapshot_removal_status != HS_SUCCESS)
goto out;
- ret = post_remove_hook();
- if (ret < 0)
- goto out;
+ post_remove_hook();
if (snapshot_removal_status != HS_POST_RUNNING)
goto out;
ret = wait_for_remove_process();
int ret, status;
char **rsync_argv;
+ lock_dss_or_die();
if (conf.dry_run_given) {
int i;
char *msg = NULL;
free(msg);
return 1;
}
- ret = pre_create_hook();
- if (ret < 0)
- return ret;
+ pre_create_hook();
if (create_pid) {
ret = wait_for_process(create_pid, &status);
if (ret < 0)