Move log_disk_space() to df.c.
[dss.git] / dss.c
1 #include <string.h>
2 #include <stdlib.h>
3 #include <stdarg.h>
4 #include <assert.h>
5 #include <errno.h>
6 #include <sys/types.h>
7 #include <signal.h>
8 #include <ctype.h>
9 #include <sys/stat.h>
10 #include <unistd.h>
11 #include <inttypes.h>
12 #include <sys/time.h>
13 #include <time.h>
14 #include <sys/wait.h>
15 #include <fnmatch.h>
16 #include <limits.h>
17
18
19 #include "gcc-compat.h"
20 #include "cmdline.h"
21 #include "log.h"
22 #include "string.h"
23 #include "error.h"
24 #include "fd.h"
25 #include "exec.h"
26 #include "daemon.h"
27 #include "signal.h"
28 #include "df.h"
29 #include "time.h"
30
31
32 struct gengetopt_args_info conf;
33 char *dss_error_txt = NULL;
34 static FILE *logfile;
35 static int signal_pipe;
36
37 /** Process id of current rsync process. */
38 static pid_t rsync_pid;
39 /** Whether the rsync process is currently stopped */
40 static int rsync_stopped;
41 /** Process id of current rm process. */
42 static pid_t rm_pid;
43 /** When the next snapshot is due. */
44 struct timeval next_snapshot_time;
45 /** The pid of the pre-create hook. */
46 pid_t pre_create_hook_pid;
47 /** The pid of the post-create hook. */
48 pid_t post_create_hook_pid;
49
50 /* Creation time of the snapshot currently being created. */
51 int64_t current_snapshot_creation_time;
52
53 static char *path_to_last_complete_snapshot;
54
55 enum {
56 /** We are ready to take the next snapshot. */
57 SCS_READY,
58 /** The pre-creation hook has been started. */
59 SCS_PRE_HOOK_RUNNING,
60 /** The pre-creation hook exited successfully. */
61 SCS_PRE_HOOK_SUCCESS,
62 /** The rsync process is running. */
63 SCS_RSYNC_RUNNING,
64 /** The rsync process exited successfully. */
65 SCS_RSYNC_SUCCESS,
66 /** The post-create hook has been started- */
67 SCS_POST_HOOK_RUNNING,
68 };
69
70 static unsigned snapshot_creation_status;
71
72
73 DEFINE_DSS_ERRLIST;
74
75
76 /* a litte cpp magic helps to DRY */
77 #define COMMANDS \
78 COMMAND(ls) \
79 COMMAND(create) \
80 COMMAND(prune) \
81 COMMAND(run)
82 #define COMMAND(x) int com_ ##x(void);
83 COMMANDS
84 #undef COMMAND
85 #define COMMAND(x) if (conf.x ##_given) return com_ ##x();
86 int call_command_handler(void)
87 {
88 COMMANDS
89 DSS_EMERG_LOG("BUG: did not find command handler\n");
90 exit(EXIT_FAILURE);
91 }
92 #undef COMMAND
93 #undef COMMANDS
94
95 /*
96 * complete, not being deleted: 1204565370-1204565371.Sun_Mar_02_2008_14_33-Sun_Mar_02_2008_14_43
97 * complete, being deleted: 1204565370-1204565371.being_deleted
98 * incomplete, not being deleted: 1204565370-incomplete
99 * incomplete, being deleted: 1204565370-incomplete.being_deleted
100 */
101 enum snapshot_status_flags {
102 /** The rsync process terminated successfully. */
103 SS_COMPLETE = 1,
104 /** The rm process is running to remove this snapshot. */
105 SS_BEING_DELETED = 2,
106 };
107
108 struct snapshot {
109 char *name;
110 int64_t creation_time;
111 int64_t completion_time;
112 enum snapshot_status_flags flags;
113 unsigned interval;
114 };
115
116 __printf_2_3 void dss_log(int ll, const char* fmt,...)
117 {
118 va_list argp;
119 FILE *outfd;
120 struct tm *tm;
121 time_t t1;
122 char str[255] = "";
123
124 if (ll < conf.loglevel_arg)
125 return;
126 outfd = logfile? logfile : stderr;
127 time(&t1);
128 tm = localtime(&t1);
129 strftime(str, sizeof(str), "%b %d %H:%M:%S", tm);
130 fprintf(outfd, "%s ", str);
131 if (conf.loglevel_arg <= INFO)
132 fprintf(outfd, "%i: ", ll);
133 va_start(argp, fmt);
134 vfprintf(outfd, fmt, argp);
135 va_end(argp);
136 }
137
138 /**
139 * Print a message either to stdout or to the log file.
140 */
141 __printf_1_2 void dss_msg(const char* fmt,...)
142 {
143 FILE *outfd = conf.daemon_given? logfile : stdout;
144 va_list argp;
145 va_start(argp, fmt);
146 vfprintf(outfd, fmt, argp);
147 va_end(argp);
148 }
149
150 /**
151 * Return the desired number of snapshots of an interval.
152 */
153 unsigned num_snapshots(int interval)
154 {
155 unsigned n;
156
157 assert(interval >= 0);
158
159 if (interval >= conf.num_intervals_arg)
160 return 0;
161 n = conf.num_intervals_arg - interval - 1;
162 return 1 << n;
163 }
164
165 /* return: Whether dirname is a snapshot directory (0: no, 1: yes) */
166 int is_snapshot(const char *dirname, int64_t now, struct snapshot *s)
167 {
168 int i, ret;
169 char *dash, *dot, *tmp;
170 int64_t num;
171
172 assert(dirname);
173 dash = strchr(dirname, '-');
174 if (!dash || !dash[1] || dash == dirname)
175 return 0;
176 for (i = 0; dirname[i] != '-'; i++)
177 if (!isdigit(dirname[i]))
178 return 0;
179 tmp = dss_strdup(dirname);
180 tmp[i] = '\0';
181 ret = dss_atoi64(tmp, &num);
182 free(tmp);
183 if (ret < 0) {
184 free(dss_error_txt);
185 return 0;
186 }
187 assert(num >= 0);
188 if (num > now)
189 return 0;
190 s->creation_time = num;
191 //DSS_DEBUG_LOG("%s start time: %lli\n", dirname, (long long)s->creation_time);
192 s->interval = (long long) ((now - s->creation_time)
193 / conf.unit_interval_arg / 24 / 3600);
194 if (!strcmp(dash + 1, "incomplete")) {
195 s->completion_time = -1;
196 s->flags = 0; /* neither complete, nor being deleted */
197 goto success;
198 }
199 if (!strcmp(dash + 1, "incomplete.being_deleted")) {
200 s->completion_time = -1;
201 s->flags = SS_BEING_DELETED; /* mot cpmplete, being deleted */
202 goto success;
203 }
204 tmp = dash + 1;
205 dot = strchr(tmp, '.');
206 if (!dot || !dot[1] || dot == tmp)
207 return 0;
208 for (i = 0; tmp[i] != '.'; i++)
209 if (!isdigit(tmp[i]))
210 return 0;
211 tmp = dss_strdup(dash + 1);
212 tmp[i] = '\0';
213 ret = dss_atoi64(tmp, &num);
214 free(tmp);
215 if (ret < 0) {
216 free(dss_error_txt);
217 return 0;
218 }
219 if (num > now)
220 return 0;
221 s->completion_time = num;
222 s->flags = SS_COMPLETE;
223 if (!strcmp(dot + 1, "being_deleted"))
224 s->flags |= SS_BEING_DELETED;
225 success:
226 s->name = dss_strdup(dirname);
227 return 1;
228 }
229
230 int64_t get_current_time(void)
231 {
232 time_t now;
233 time(&now);
234 DSS_DEBUG_LOG("now: %lli\n", (long long) now);
235 return (int64_t)now;
236 }
237
238 char *incomplete_name(int64_t start)
239 {
240 return make_message("%lli-incomplete", (long long)start);
241 }
242
243 char *being_deleted_name(struct snapshot *s)
244 {
245 if (s->flags & SS_COMPLETE)
246 return make_message("%lli-%lli.being_deleted",
247 (long long)s->creation_time,
248 (long long)s->completion_time);
249 return make_message("%lli-incomplete.being_deleted",
250 (long long)s->creation_time);
251 }
252
253 int complete_name(int64_t start, int64_t end, char **result)
254 {
255 struct tm start_tm, end_tm;
256 time_t *start_seconds = (time_t *) (uint64_t *)&start; /* STFU, gcc */
257 time_t *end_seconds = (time_t *) (uint64_t *)&end; /* STFU, gcc */
258 char start_str[200], end_str[200];
259
260 if (!localtime_r(start_seconds, &start_tm))
261 return -E_LOCALTIME;
262 if (!localtime_r(end_seconds, &end_tm))
263 return -E_LOCALTIME;
264 if (!strftime(start_str, sizeof(start_str), "%a_%b_%d_%Y_%H_%M_%S", &start_tm))
265 return -E_STRFTIME;
266 if (!strftime(end_str, sizeof(end_str), "%a_%b_%d_%Y_%H_%M_%S", &end_tm))
267 return -E_STRFTIME;
268 *result = make_message("%lli-%lli.%s-%s", (long long) start, (long long) end,
269 start_str, end_str);
270 return 1;
271 }
272
273 struct snapshot_list {
274 int64_t now;
275 unsigned num_snapshots;
276 unsigned array_size;
277 struct snapshot **snapshots;
278 /**
279 * Array of size num_intervals + 1
280 *
281 * It contains the number of snapshots in each interval. interval_count[num_intervals]
282 * is the number of snapshots which belong to any interval greater than num_intervals.
283 */
284 unsigned *interval_count;
285 };
286
287 #define FOR_EACH_SNAPSHOT(s, i, sl) \
288 for ((i) = 0; (i) < (sl)->num_snapshots && ((s) = (sl)->snapshots[(i)]); (i)++)
289
290 #define FOR_EACH_SNAPSHOT_REVERSE(s, i, sl) \
291 for ((i) = (sl)->num_snapshots; (i) > 0 && ((s) = (sl)->snapshots[(i - 1)]); (i)--)
292
293 static inline struct snapshot *oldest_snapshot(struct snapshot_list *sl)
294 {
295 if (!sl->num_snapshots)
296 return NULL;
297 return sl->snapshots[0];
298 }
299
300 #define NUM_COMPARE(x, y) ((int)((x) < (y)) - (int)((x) > (y)))
301
302 static int compare_snapshots(const void *a, const void *b)
303 {
304 struct snapshot *s1 = *(struct snapshot **)a;
305 struct snapshot *s2 = *(struct snapshot **)b;
306 return NUM_COMPARE(s2->creation_time, s1->creation_time);
307 }
308
309 /** Compute the minimum of \a a and \a b. */
310 #define DSS_MIN(a,b) ((a) < (b) ? (a) : (b))
311
312 int add_snapshot(const char *dirname, void *private)
313 {
314 struct snapshot_list *sl = private;
315 struct snapshot s;
316 int ret = is_snapshot(dirname, sl->now, &s);
317
318 if (!ret)
319 return 1;
320 if (sl->num_snapshots >= sl->array_size) {
321 sl->array_size = 2 * sl->array_size + 1;
322 sl->snapshots = dss_realloc(sl->snapshots,
323 sl->array_size * sizeof(struct snapshot *));
324 }
325 sl->snapshots[sl->num_snapshots] = dss_malloc(sizeof(struct snapshot));
326 *(sl->snapshots[sl->num_snapshots]) = s;
327 sl->interval_count[DSS_MIN(s.interval, conf.num_intervals_arg)]++;
328 sl->num_snapshots++;
329 return 1;
330 }
331
332 void get_snapshot_list(struct snapshot_list *sl)
333 {
334 sl->now = get_current_time();
335 sl->num_snapshots = 0;
336 sl->array_size = 0;
337 sl->snapshots = NULL;
338 sl->interval_count = dss_calloc((conf.num_intervals_arg + 1) * sizeof(unsigned));
339 for_each_subdir(add_snapshot, sl);
340 qsort(sl->snapshots, sl->num_snapshots, sizeof(struct snapshot *),
341 compare_snapshots);
342 }
343
344 void free_snapshot_list(struct snapshot_list *sl)
345 {
346 int i;
347 struct snapshot *s;
348
349 FOR_EACH_SNAPSHOT(s, i, sl) {
350 free(s->name);
351 free(s);
352 }
353 free(sl->interval_count);
354 sl->interval_count = NULL;
355 free(sl->snapshots);
356 sl->snapshots = NULL;
357 sl->num_snapshots = 0;
358 }
359
360 void stop_rsync_process(void)
361 {
362 if (!rsync_pid || rsync_stopped)
363 return;
364 kill(SIGSTOP, rsync_pid);
365 rsync_stopped = 1;
366 }
367
368 void restart_rsync_process(void)
369 {
370 if (!rsync_pid || !rsync_stopped)
371 return;
372 kill (SIGCONT, rsync_pid);
373 rsync_stopped = 0;
374 }
375
376 /**
377 * Print a log message about the exit status of a child.
378 */
379 void log_termination_msg(pid_t pid, int status)
380 {
381 if (WIFEXITED(status))
382 DSS_INFO_LOG("child %i exited. Exit status: %i\n", (int)pid,
383 WEXITSTATUS(status));
384 else if (WIFSIGNALED(status))
385 DSS_NOTICE_LOG("child %i was killed by signal %i\n", (int)pid,
386 WTERMSIG(status));
387 else
388 DSS_WARNING_LOG("child %i terminated abormally\n", (int)pid);
389 }
390
391 int wait_for_process(pid_t pid, int *status)
392 {
393 int ret;
394
395 DSS_DEBUG_LOG("Waiting for process %d to terminate\n", (int)pid);
396 for (;;) {
397 fd_set rfds;
398
399 FD_ZERO(&rfds);
400 FD_SET(signal_pipe, &rfds);
401 ret = dss_select(signal_pipe + 1, &rfds, NULL, NULL);
402 if (ret < 0)
403 break;
404 ret = next_signal();
405 if (!ret)
406 continue;
407 if (ret == SIGCHLD) {
408 ret = waitpid(pid, status, 0);
409 if (ret >= 0)
410 break;
411 if (errno != EINTR) { /* error */
412 ret = -ERRNO_TO_DSS_ERROR(errno);
413 break;
414 }
415 }
416 /* SIGINT or SIGTERM */
417 DSS_WARNING_LOG("sending SIGTERM to pid %d\n", (int)pid);
418 kill(pid, SIGTERM);
419 }
420 if (ret < 0)
421 DSS_ERROR_LOG("failed to wait for process %d\n", (int)pid);
422 else
423 log_termination_msg(pid, *status);
424 return ret;
425 }
426
427 int remove_snapshot(struct snapshot *s)
428 {
429 int fds[3] = {0, 0, 0};
430 assert(!rm_pid);
431 char *new_name = being_deleted_name(s);
432 int ret = dss_rename(s->name, new_name);
433 char *argv[] = {"rm", "-rf", new_name, NULL};
434
435 if (ret < 0)
436 goto out;
437 DSS_NOTICE_LOG("removing %s (interval = %i)\n", s->name, s->interval);
438 stop_rsync_process();
439 ret = dss_exec(&rm_pid, argv[0], argv, fds);
440 out:
441 free(new_name);
442 return ret;
443 }
444
445 /*
446 * return: 0: no redundant snapshots, 1: rm process started, negative: error
447 */
448 int remove_redundant_snapshot(struct snapshot_list *sl)
449 {
450 int ret, i, interval;
451 struct snapshot *s;
452 unsigned missing = 0;
453
454 DSS_INFO_LOG("looking for intervals containing too many snapshots\n");
455 for (interval = conf.num_intervals_arg - 1; interval >= 0; interval--) {
456 unsigned keep = num_snapshots(interval);
457 unsigned num = sl->interval_count[interval];
458 struct snapshot *victim = NULL, *prev = NULL;
459 int64_t score = LONG_MAX;
460
461 if (keep >= num)
462 missing += keep - num;
463 // DSS_DEBUG_LOG("interval %i: keep: %u, have: %u, missing: %u\n",
464 // interval, keep, num, missing);
465 if (keep + missing >= num)
466 continue;
467 /* redundant snapshot in this interval, pick snapshot with lowest score */
468 FOR_EACH_SNAPSHOT(s, i, sl) {
469 int64_t this_score;
470
471 //DSS_DEBUG_LOG("checking %s\n", s->name);
472 if (s->interval > interval) {
473 prev = s;
474 continue;
475 }
476 if (s->interval < interval)
477 break;
478 if (!victim) {
479 victim = s;
480 prev = s;
481 continue;
482 }
483 assert(prev);
484 /* check if s is a better victim */
485 this_score = s->creation_time - prev->creation_time;
486 assert(this_score >= 0);
487 //DSS_DEBUG_LOG("%s: score %lli\n", s->name, (long long)score);
488 if (this_score < score) {
489 score = this_score;
490 victim = s;
491 }
492 prev = s;
493 }
494 assert(victim);
495 if (conf.dry_run_given) {
496 dss_msg("%s would be removed (interval = %i)\n",
497 victim->name, victim->interval);
498 continue;
499 }
500 ret = remove_snapshot(victim);
501 return ret < 0? ret : 1;
502 }
503 return 0;
504 }
505
506 int remove_outdated_snapshot(struct snapshot_list *sl)
507 {
508 int i, ret;
509 struct snapshot *s;
510
511 DSS_INFO_LOG("looking for snapshots belonging to intervals greater than %d\n",
512 conf.num_intervals_arg);
513 FOR_EACH_SNAPSHOT(s, i, sl) {
514 if (s->interval <= conf.num_intervals_arg)
515 continue;
516 if (conf.dry_run_given) {
517 dss_msg("%s would be removed (interval = %i)\n",
518 s->name, s->interval);
519 continue;
520 }
521 ret = remove_snapshot(s);
522 if (ret < 0)
523 return ret;
524 return 1;
525 }
526 return 0;
527 }
528
529 int handle_rm_exit(int status)
530 {
531 rm_pid = 0;
532 if (!WIFEXITED(status))
533 return -E_INVOLUNTARY_EXIT;
534 if (WEXITSTATUS(status))
535 return -E_BAD_EXIT_CODE;
536 return 1;
537 }
538
539 int wait_for_rm_process(void)
540 {
541 int status, ret = wait_for_process(rm_pid, &status);
542
543 if (ret < 0)
544 return ret;
545 return handle_rm_exit(status);
546 }
547
548 void kill_process(pid_t pid)
549 {
550 if (!pid)
551 return;
552 DSS_WARNING_LOG("sending SIGTERM to pid %d\n", (int)pid);
553 kill(pid, SIGTERM);
554 }
555
556 int check_config(void)
557 {
558 if (conf.unit_interval_arg <= 0) {
559 DSS_ERROR_LOG("bad unit interval: %i\n", conf.unit_interval_arg);
560 return -E_INVALID_NUMBER;
561 }
562 DSS_DEBUG_LOG("unit interval: %i day(s)\n", conf.unit_interval_arg);
563 if (conf.num_intervals_arg <= 0) {
564 DSS_ERROR_LOG("bad number of intervals %i\n", conf.num_intervals_arg);
565 return -E_INVALID_NUMBER;
566 }
567 DSS_DEBUG_LOG("number of intervals: %i\n", conf.num_intervals_arg);
568 return 1;
569 }
570
571 /* exits on errors */
572 void parse_config_file(int override)
573 {
574 int ret;
575 char *config_file;
576 struct stat statbuf;
577 char *old_logfile_arg = NULL;
578 int old_daemon_given = 0;
579
580 if (conf.config_file_given)
581 config_file = dss_strdup(conf.config_file_arg);
582 else {
583 char *home = get_homedir();
584 config_file = make_message("%s/.dssrc", home);
585 free(home);
586 }
587 if (override) { /* SIGHUP */
588 if (conf.logfile_given)
589 old_logfile_arg = dss_strdup(conf.logfile_arg);
590 old_daemon_given = conf.daemon_given;
591 }
592
593 ret = stat(config_file, &statbuf);
594 if (ret && conf.config_file_given) {
595 ret = -ERRNO_TO_DSS_ERROR(errno);
596 DSS_ERROR_LOG("failed to stat config file %s\n", config_file);
597 goto out;
598 }
599 if (!ret) {
600 struct cmdline_parser_params params = {
601 .override = override,
602 .initialize = 0,
603 .check_required = 1,
604 .check_ambiguity = 0
605 };
606 cmdline_parser_config_file(config_file, &conf, &params);
607 }
608 ret = check_config();
609 if (ret < 0)
610 goto out;
611 if (override) {
612 /* don't change daemon mode on SIGHUP */
613 conf.daemon_given = old_daemon_given;
614 close_log(logfile);
615 logfile = NULL;
616 if (conf.logfile_given)
617 free(old_logfile_arg);
618 else if (conf.daemon_given) { /* re-use old logfile */
619 conf.logfile_arg = old_logfile_arg;
620 conf.logfile_given = 1;
621 }
622 }
623 if (conf.logfile_given) {
624 logfile = open_log(conf.logfile_arg);
625 log_welcome(conf.loglevel_arg);
626 }
627 DSS_EMERG_LOG("loglevel: %d\n", conf.loglevel_arg);
628 // cmdline_parser_dump(logfile? logfile : stdout, &conf);
629 ret = dss_chdir(conf.dest_dir_arg);
630 out:
631 free(config_file);
632 if (ret >= 0)
633 return;
634 DSS_EMERG_LOG("%s\n", dss_strerror(-ret));
635 exit(EXIT_FAILURE);
636 }
637
638 void handle_sighup(void)
639 {
640 DSS_NOTICE_LOG("SIGHUP\n");
641 parse_config_file(1);
642 }
643
644 int rename_incomplete_snapshot(int64_t start)
645 {
646 char *old_name;
647 int ret;
648
649 free(path_to_last_complete_snapshot);
650 ret = complete_name(start, get_current_time(),
651 &path_to_last_complete_snapshot);
652 if (ret < 0)
653 return ret;
654 old_name = incomplete_name(start);
655 ret = dss_rename(old_name, path_to_last_complete_snapshot);
656 if (ret >= 0)
657 DSS_NOTICE_LOG("%s -> %s\n", old_name,
658 path_to_last_complete_snapshot);
659 free(old_name);
660 return ret;
661 }
662
663 void compute_next_snapshot_time(void)
664 {
665 struct timeval now, unit_interval = {.tv_sec = 24 * 3600 * conf.unit_interval_arg},
666 tmp, diff;
667 int64_t x = 0;
668 unsigned wanted = num_snapshots(0), num_complete_snapshots = 0;
669 int i, ret;
670 struct snapshot *s = NULL;
671 struct snapshot_list sl;
672
673 assert(snapshot_creation_status == SCS_READY);
674 current_snapshot_creation_time = 0;
675 get_snapshot_list(&sl);
676 FOR_EACH_SNAPSHOT(s, i, &sl) {
677 if (!(s->flags & SS_COMPLETE))
678 continue;
679 num_complete_snapshots++;
680 x += s->completion_time - s->creation_time;
681 }
682 assert(x >= 0);
683 if (num_complete_snapshots)
684 x /= num_complete_snapshots; /* avg time to create one snapshot */
685 x *= wanted; /* time to create all snapshots in interval 0 */
686 tmp.tv_sec = x;
687 tmp.tv_usec = 0;
688 ret = tv_diff(&unit_interval, &tmp, &diff); /* total sleep time per unit interval */
689 gettimeofday(&now, NULL);
690 if (ret < 0 || !s)
691 goto min_sleep;
692 tv_divide(wanted, &diff, &tmp); /* sleep time betweeen two snapshots */
693 diff.tv_sec = s->completion_time;
694 diff.tv_usec = 0;
695 tv_add(&diff, &tmp, &next_snapshot_time);
696 if (tv_diff(&now, &next_snapshot_time, NULL) < 0)
697 goto out;
698 min_sleep:
699 next_snapshot_time = now;
700 next_snapshot_time.tv_sec += 60;
701 out:
702 free_snapshot_list(&sl);
703 }
704
705 int handle_rsync_exit(int status)
706 {
707 int es, ret;
708
709 if (!WIFEXITED(status)) {
710 DSS_ERROR_LOG("rsync process %d died involuntary\n", (int)rsync_pid);
711 ret = -E_INVOLUNTARY_EXIT;
712 snapshot_creation_status = SCS_READY;
713 compute_next_snapshot_time();
714 goto out;
715 }
716 es = WEXITSTATUS(status);
717 if (es != 0 && es != 23 && es != 24) {
718 DSS_ERROR_LOG("rsync process %d returned %d\n", (int)rsync_pid, es);
719 ret = -E_BAD_EXIT_CODE;
720 snapshot_creation_status = SCS_READY;
721 compute_next_snapshot_time();
722 goto out;
723 }
724 ret = rename_incomplete_snapshot(current_snapshot_creation_time);
725 if (ret < 0)
726 goto out;
727 snapshot_creation_status = SCS_RSYNC_SUCCESS;
728 out:
729 rsync_pid = 0;
730 rsync_stopped = 0;
731 return ret;
732 }
733
734 __malloc char *name_of_newest_complete_snapshot(void)
735 {
736 struct snapshot_list sl;
737 struct snapshot *s;
738 int i;
739 char *name = NULL;
740
741 get_snapshot_list(&sl);
742
743 FOR_EACH_SNAPSHOT_REVERSE(s, i, &sl) {
744 if (s->flags != SS_COMPLETE) /* incomplete or being deleted */
745 continue;
746 name = dss_strdup(s->name);
747 break;
748 }
749 free_snapshot_list(&sl);
750 return name;
751 }
752
753 void create_rsync_argv(char ***argv, int64_t *num)
754 {
755 char *logname, *newest = name_of_newest_complete_snapshot();
756 int i = 0, j;
757
758 *argv = dss_malloc((15 + conf.rsync_option_given) * sizeof(char *));
759 (*argv)[i++] = dss_strdup("rsync");
760 (*argv)[i++] = dss_strdup("-aq");
761 (*argv)[i++] = dss_strdup("--delete");
762 for (j = 0; j < conf.rsync_option_given; j++)
763 (*argv)[i++] = dss_strdup(conf.rsync_option_arg[j]);
764 if (newest) {
765 DSS_INFO_LOG("using %s as reference snapshot\n", newest);
766 (*argv)[i++] = make_message("--link-dest=../%s", newest);
767 free(newest);
768 } else
769 DSS_INFO_LOG("no previous snapshot found\n");
770 if (conf.exclude_patterns_given) {
771 (*argv)[i++] = dss_strdup("--exclude-from");
772 (*argv)[i++] = dss_strdup(conf.exclude_patterns_arg);
773
774 }
775 logname = dss_logname();
776 if (conf.remote_user_given && !strcmp(conf.remote_user_arg, logname))
777 (*argv)[i++] = dss_strdup(conf.source_dir_arg);
778 else
779 (*argv)[i++] = make_message("%s@%s:%s/", conf.remote_user_given?
780 conf.remote_user_arg : logname,
781 conf.remote_host_arg, conf.source_dir_arg);
782 free(logname);
783 *num = get_current_time();
784 (*argv)[i++] = incomplete_name(*num);
785 (*argv)[i++] = NULL;
786 for (j = 0; j < i; j++)
787 DSS_DEBUG_LOG("argv[%d] = %s\n", j, (*argv)[j]);
788 }
789
790 void free_rsync_argv(char **argv)
791 {
792 int i;
793 for (i = 0; argv[i]; i++)
794 free(argv[i]);
795 free(argv);
796 }
797
798 int pre_create_hook(void)
799 {
800 int ret, fds[3] = {0, 0, 0};
801
802 if (!conf.pre_create_hook_given) {
803 snapshot_creation_status = SCS_PRE_HOOK_SUCCESS;
804 return 0;
805 }
806 DSS_NOTICE_LOG("executing %s\n", conf.pre_create_hook_arg);
807 ret = dss_exec_cmdline_pid(&pre_create_hook_pid,
808 conf.pre_create_hook_arg, fds);
809 if (ret < 0)
810 return ret;
811 snapshot_creation_status = SCS_PRE_HOOK_RUNNING;
812 return ret;
813 }
814
815 int post_create_hook(void)
816 {
817 int ret, fds[3] = {0, 0, 0};
818 char *cmd;
819
820 if (!conf.post_create_hook_given) {
821 snapshot_creation_status = SCS_READY;
822 compute_next_snapshot_time();
823 return 0;
824 }
825 cmd = make_message("%s %s", conf.post_create_hook_arg,
826 path_to_last_complete_snapshot);
827 DSS_NOTICE_LOG("executing %s\n", cmd);
828 ret = dss_exec_cmdline_pid(&post_create_hook_pid, cmd, fds);
829 free(cmd);
830 if (ret < 0)
831 return ret;
832 snapshot_creation_status = SCS_POST_HOOK_RUNNING;
833 return ret;
834 }
835
836 int create_snapshot(char **argv)
837 {
838 int ret, fds[3] = {0, 0, 0};
839 char *name;
840
841 name = incomplete_name(current_snapshot_creation_time);
842 DSS_NOTICE_LOG("creating new snapshot %s\n", name);
843 free(name);
844 ret = dss_exec(&rsync_pid, argv[0], argv, fds);
845 if (ret < 0)
846 return ret;
847 snapshot_creation_status = SCS_RSYNC_RUNNING;
848 return ret;
849 }
850
851 int handle_pre_create_hook_exit(int status)
852 {
853 int es, ret;
854
855 if (!WIFEXITED(status)) {
856 snapshot_creation_status = SCS_READY;
857 compute_next_snapshot_time();
858 ret = -E_INVOLUNTARY_EXIT;
859 goto out;
860 }
861 es = WEXITSTATUS(status);
862 if (es) {
863 snapshot_creation_status = SCS_READY;
864 compute_next_snapshot_time();
865 ret = -E_BAD_EXIT_CODE;
866 goto out;
867 }
868 snapshot_creation_status = SCS_PRE_HOOK_SUCCESS;
869 ret = 1;
870 out:
871 pre_create_hook_pid = 0;
872 return ret;
873 }
874
875 int handle_sigchld()
876 {
877 pid_t pid;
878 int status, ret = reap_child(&pid, &status);
879
880 if (ret <= 0)
881 return ret;
882 if (pid == rsync_pid)
883 return handle_rsync_exit(status);
884 if (pid == rm_pid)
885 return handle_rm_exit(status);
886 if (pid == pre_create_hook_pid)
887 return handle_pre_create_hook_exit(status);
888 if (pid == post_create_hook_pid) {
889 snapshot_creation_status = SCS_READY;
890 compute_next_snapshot_time();
891 return 1;
892 }
893 DSS_EMERG_LOG("BUG: unknown process %d died\n", (int)pid);
894 exit(EXIT_FAILURE);
895 }
896
897 void handle_signal(void)
898 {
899 int sig, ret = next_signal();
900
901 if (ret <= 0)
902 goto out;
903 sig = ret;
904 switch (sig) {
905 case SIGINT:
906 case SIGTERM:
907 restart_rsync_process();
908 kill_process(rsync_pid);
909 kill_process(rm_pid);
910 exit(EXIT_FAILURE);
911 case SIGHUP:
912 handle_sighup();
913 ret = 1;
914 break;
915 case SIGCHLD:
916 ret = handle_sigchld();
917 break;
918 }
919 out:
920 if (ret < 0)
921 DSS_ERROR_LOG("%s\n", dss_strerror(-ret));
922 }
923
924 int remove_oldest_snapshot(struct snapshot_list *sl)
925 {
926 struct snapshot *s = oldest_snapshot(sl);
927
928 if (!s) /* no snapshot found */
929 return 0;
930 DSS_INFO_LOG("oldest snapshot: %s\n", s->name);
931 if (s->creation_time == current_snapshot_creation_time)
932 return 0; /* do not remove the snapshot currently being created */
933 return remove_snapshot(s);
934 }
935
936 /* TODO: Also consider number of inodes. */
937 int disk_space_low(void)
938 {
939 struct disk_space ds;
940 int ret = get_disk_space(".", &ds);
941
942 if (ret < 0)
943 return ret;
944 if (conf.min_free_mb_arg)
945 if (ds.free_mb < conf.min_free_mb_arg)
946 return 1;
947 if (conf.min_free_percent_arg)
948 if (ds.percent_free < conf.min_free_percent_arg)
949 return 1;
950 return 0;
951 }
952
953 int try_to_free_disk_space(int low_disk_space)
954 {
955 int ret;
956 struct snapshot_list sl;
957
958 get_snapshot_list(&sl);
959 ret = remove_outdated_snapshot(&sl);
960 if (ret) /* error, or we are removing something */
961 goto out;
962 /* no outdated snapshot */
963 ret = remove_redundant_snapshot(&sl);
964 if (ret)
965 goto out;
966 ret = 0;
967 if (!low_disk_space)
968 goto out;
969 DSS_WARNING_LOG("disk space low and nothing obvious to remove\n");
970 ret = remove_oldest_snapshot(&sl);
971 if (ret)
972 goto out;
973 DSS_CRIT_LOG("uhuhu: not enough disk space for a single snapshot\n");
974 ret= -ENOSPC;
975 out:
976 free_snapshot_list(&sl);
977 return ret;
978 }
979
980 int select_loop(void)
981 {
982 int ret;
983 struct timeval tv = {.tv_sec = 0, .tv_usec = 0};
984
985 for (;;) {
986 fd_set rfds;
987 int low_disk_space;
988 char **rsync_argv;
989 struct timeval now, *tvp = &tv;
990
991 if (rsync_pid)
992 tv.tv_sec = 60; /* check every 60 seconds for free disk space */
993 else if (rm_pid)
994 tvp = NULL; /* sleep until rm process dies */
995 FD_ZERO(&rfds);
996 FD_SET(signal_pipe, &rfds);
997 DSS_DEBUG_LOG("tvp: %p, tv_sec: %lu\n", tvp, (long unsigned) tv.tv_sec);
998 ret = dss_select(signal_pipe + 1, &rfds, NULL, tvp);
999 if (ret < 0)
1000 return ret;
1001 if (FD_ISSET(signal_pipe, &rfds))
1002 handle_signal();
1003 if (rm_pid)
1004 continue;
1005 ret = disk_space_low();
1006 if (ret < 0)
1007 break;
1008 low_disk_space = ret;
1009 if (low_disk_space)
1010 stop_rsync_process();
1011 ret = try_to_free_disk_space(low_disk_space);
1012 if (ret < 0)
1013 break;
1014 if (rm_pid)
1015 continue;
1016 restart_rsync_process();
1017 gettimeofday(&now, NULL);
1018 if (tv_diff(&next_snapshot_time, &now, &tv) > 0)
1019 continue;
1020 switch (snapshot_creation_status) {
1021 case SCS_READY:
1022 ret = pre_create_hook();
1023 if (ret < 0)
1024 goto out;
1025 continue;
1026 case SCS_PRE_HOOK_RUNNING:
1027 continue;
1028 case SCS_PRE_HOOK_SUCCESS:
1029 create_rsync_argv(&rsync_argv, &current_snapshot_creation_time);
1030 ret = create_snapshot(rsync_argv);
1031 free_rsync_argv(rsync_argv);
1032 if (ret < 0)
1033 goto out;
1034 continue;
1035 case SCS_RSYNC_RUNNING:
1036 continue;
1037 case SCS_RSYNC_SUCCESS:
1038 ret = post_create_hook();
1039 if (ret < 0)
1040 goto out;
1041 continue;
1042 case SCS_POST_HOOK_RUNNING:
1043 continue;
1044 }
1045 }
1046 out:
1047 return ret;
1048 }
1049
1050 int com_run(void)
1051 {
1052 int ret;
1053
1054 if (conf.dry_run_given) {
1055 DSS_ERROR_LOG("dry_run not supported by this command\n");
1056 return -E_SYNTAX;
1057 }
1058 ret = install_sighandler(SIGHUP);
1059 if (ret < 0)
1060 return ret;
1061 compute_next_snapshot_time();
1062 return select_loop();
1063 }
1064
1065 int com_prune(void)
1066 {
1067 int ret;
1068 struct snapshot_list sl;
1069 struct disk_space ds;
1070
1071 ret = get_disk_space(".", &ds);
1072 if (ret < 0)
1073 return ret;
1074 log_disk_space(&ds);
1075 for (;;) {
1076 get_snapshot_list(&sl);
1077 ret = remove_outdated_snapshot(&sl);
1078 free_snapshot_list(&sl);
1079 if (ret < 0)
1080 return ret;
1081 if (!ret)
1082 break;
1083 ret = wait_for_rm_process();
1084 if (ret < 0)
1085 goto out;
1086 }
1087 for (;;) {
1088 get_snapshot_list(&sl);
1089 ret = remove_redundant_snapshot(&sl);
1090 free_snapshot_list(&sl);
1091 if (ret < 0)
1092 return ret;
1093 if (!ret)
1094 break;
1095 ret = wait_for_rm_process();
1096 if (ret < 0)
1097 goto out;
1098 }
1099 return 1;
1100 out:
1101 return ret;
1102 }
1103
1104 int com_create(void)
1105 {
1106 int ret, status;
1107 char **rsync_argv;
1108
1109 if (conf.dry_run_given) {
1110 int i;
1111 char *msg = NULL;
1112 create_rsync_argv(&rsync_argv, &current_snapshot_creation_time);
1113 for (i = 0; rsync_argv[i]; i++) {
1114 char *tmp = msg;
1115 msg = make_message("%s%s%s", tmp? tmp : "",
1116 tmp? " " : "", rsync_argv[i]);
1117 free(tmp);
1118 }
1119 free_rsync_argv(rsync_argv);
1120 dss_msg("%s\n", msg);
1121 free(msg);
1122 return 1;
1123 }
1124 ret = pre_create_hook();
1125 if (ret < 0)
1126 return ret;
1127 if (pre_create_hook_pid) {
1128 ret = wait_for_process(pre_create_hook_pid, &status);
1129 if (ret < 0)
1130 return ret;
1131 ret = handle_pre_create_hook_exit(status);
1132 if (ret < 0)
1133 return ret;
1134 }
1135 create_rsync_argv(&rsync_argv, &current_snapshot_creation_time);
1136 ret = create_snapshot(rsync_argv);
1137 if (ret < 0)
1138 goto out;
1139 ret = wait_for_process(rsync_pid, &status);
1140 if (ret < 0)
1141 goto out;
1142 ret = handle_rsync_exit(status);
1143 if (ret < 0)
1144 goto out;
1145 post_create_hook();
1146 if (post_create_hook_pid)
1147 ret = wait_for_process(post_create_hook_pid, &status);
1148 out:
1149 free_rsync_argv(rsync_argv);
1150 return ret;
1151 }
1152
1153 int com_ls(void)
1154 {
1155 int i;
1156 struct snapshot_list sl;
1157 struct snapshot *s;
1158 get_snapshot_list(&sl);
1159 FOR_EACH_SNAPSHOT(s, i, &sl)
1160 dss_msg("%u\t%s\n", s->interval, s->name);
1161 free_snapshot_list(&sl);
1162 return 1;
1163 }
1164
1165 static void setup_signal_handling(void)
1166 {
1167 int ret;
1168
1169 DSS_INFO_LOG("setting up signal handlers\n");
1170 signal_pipe = signal_init(); /* always successful */
1171 ret = install_sighandler(SIGINT);
1172 if (ret < 0)
1173 goto err;
1174 ret = install_sighandler(SIGTERM);
1175 if (ret < 0)
1176 goto err;
1177 ret = install_sighandler(SIGCHLD);
1178 if (ret < 0)
1179 goto err;
1180 return;
1181 err:
1182 DSS_EMERG_LOG("could not install signal handlers\n");
1183 exit(EXIT_FAILURE);
1184 }
1185
1186 int main(int argc, char **argv)
1187 {
1188 int ret;
1189 struct cmdline_parser_params params = {
1190 .override = 0,
1191 .initialize = 1,
1192 .check_required = 0,
1193 .check_ambiguity = 0
1194 };
1195
1196 cmdline_parser_ext(argc, argv, &conf, &params); /* aborts on errors */
1197 parse_config_file(0);
1198
1199 if (conf.daemon_given)
1200 daemon_init();
1201 setup_signal_handling();
1202 ret = call_command_handler();
1203 if (ret < 0)
1204 DSS_EMERG_LOG("%s\n", dss_strerror(-ret));
1205 exit(ret >= 0? EXIT_SUCCESS : EXIT_FAILURE);
1206 }