/*
- * 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.
*/
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 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 int com_run(void)
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();
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)