dss.c

   1 /*
   2  * Copyright (C) 2008-2011 Andre Noll <maan@tuebingen.mpg.de>
   3  *
   4  * Licensed under the GPL v2. For licencing details see COPYING.
   5  */
   6 #include <string.h>
   7 #include <stdlib.h>
   8 #include <stdio.h>
   9 #include <stdarg.h>
  10 #include <assert.h>
  11 #include <errno.h>
  12 #include <sys/types.h>
  13 #include <signal.h>
  14 #include <ctype.h>
  15 #include <stdbool.h>
  16 #include <sys/stat.h>
  17 #include <unistd.h>
  18 #include <inttypes.h>
  19 #include <sys/time.h>
  20 #include <time.h>
  21 #include <sys/wait.h>
  22 #include <fnmatch.h>
  23 #include <limits.h>
  24
  25
  26 #include "gcc-compat.h"
  27 #include "cmdline.h"
  28 #include "log.h"
  29 #include "str.h"
  30 #include "err.h"
  31 #include "file.h"
  32 #include "exec.h"
  33 #include "daemon.h"
  34 #include "sig.h"
  35 #include "df.h"
  36 #include "tv.h"
  37 #include "snap.h"
  38 #include "ipc.h"
  39
  40 /** Command line and config file options. */
  41 static struct gengetopt_args_info conf;
  42 /** Non-NULL if we log to a file. */
  43 static FILE *logfile;
  44 /** The read end of the signal pipe */
  45 static int signal_pipe;
  46 /** Process id of current pre-create-hook/rsync/post-create-hook process. */
  47 static pid_t create_pid;
  48 /** Whether the pre-create-hook/rsync/post-create-hook is currently stopped. */
  49 static int create_process_stopped;
  50 /** How many times in a row the rsync command failed. */
  51 static int num_consecutive_rsync_errors;
  52 /** Process id of current pre-remove/rm/post-remove process. */
  53 static pid_t remove_pid;
  54 /** When the next snapshot is due. */
  55 static int64_t next_snapshot_time;
  56 /** When to try to remove something. */
  57 static struct timeval next_removal_check;
  58 /** Creation time of the snapshot currently being created. */
  59 static int64_t current_snapshot_creation_time;
  60 /** The snapshot currently being removed. */
  61 struct snapshot *snapshot_currently_being_removed;
  62 /** Needed by the post-create hook. */
  63 static char *path_to_last_complete_snapshot;
  64 static char *name_of_reference_snapshot;
  65 /** \sa \ref snap.h for details. */
  66 enum hook_status snapshot_creation_status;
  67 /** \sa \ref snap.h for details. */
  68 enum hook_status snapshot_removal_status;
  69
  70
  71 DEFINE_DSS_ERRLIST;
  72 static const char *hook_status_description[] = {HOOK_STATUS_ARRAY};
  73
  74 /* may be called with ds == NULL. */
  75 static int disk_space_low(struct disk_space *ds)
  76 {
  77         struct disk_space ds_struct;
  78
  79         if (!ds) {
  80                 int ret = get_disk_space(".", &ds_struct);
  81                 if (ret < 0)
  82                         return ret;
  83                 ds = &ds_struct;
  84         }
  85         if (conf.min_free_mb_arg)
  86                 if (ds->free_mb < conf.min_free_mb_arg)
  87                         return 1;
  88         if (conf.min_free_percent_arg)
  89                 if (ds->percent_free < conf.min_free_percent_arg)
  90                         return 1;
  91         if (conf.min_free_percent_inodes_arg)
  92                 if (ds->percent_free_inodes < conf.min_free_percent_inodes_arg)
  93                         return 1;
  94         return 0;
  95 }
  96
  97 static void dump_dss_config(const char *msg)
  98 {
  99         const char dash[] = "-----------------------------";
 100         int ret;
 101         FILE *log = logfile? logfile : stderr;
 102         struct disk_space ds;
 103         int64_t now = get_current_time();
 104
 105         if (conf.loglevel_arg > INFO)
 106                 return;
 107
 108         fprintf(log, "%s <%s config> %s\n", dash, msg, dash);
 109         fprintf(log, "\n*** disk space ***\n\n");
 110         ret = get_disk_space(".", &ds);
 111         if (ret >= 0) {
 112                 DSS_INFO_LOG(("disk space low: %s\n", disk_space_low(&ds)?
 113                         "yes" : "no"));
 114                 log_disk_space(&ds);
 115         } else
 116                 DSS_ERROR_LOG(("can not get free disk space: %s\n",
 117                         dss_strerror(-ret)));
 118
 119         /* we continue on errors from get_disk_space */
 120
 121         fprintf(log, "\n*** command line and config file options ***\n\n");
 122         cmdline_parser_dump(log, &conf);
 123         fprintf(log, "\n*** internal state ***\n\n");
 124         fprintf(log,
 125                 "pid: %d\n"
 126                 "logile: %s\n"
 127                 "snapshot_currently_being_removed: %s\n"
 128                 "path_to_last_complete_snapshot: %s\n"
 129                 "reference_snapshot: %s\n"
 130                 "snapshot_creation_status: %s\n"
 131                 "snapshot_removal_status: %s\n"
 132                 "num_consecutive_rsync_errors: %d\n"
 133                 ,
 134                 (int) getpid(),
 135                 logfile? conf.logfile_arg : "stderr",
 136                 snapshot_currently_being_removed?
 137                         snapshot_currently_being_removed->name : "(none)",
 138                 path_to_last_complete_snapshot?
 139                         path_to_last_complete_snapshot : "(none)",
 140                 name_of_reference_snapshot?
 141                         name_of_reference_snapshot : "(none)",
 142                 hook_status_description[snapshot_creation_status],
 143                 hook_status_description[snapshot_removal_status],
 144                 num_consecutive_rsync_errors
 145         );
 146         if (create_pid != 0)
 147                 fprintf(log,
 148                         "create_pid: %" PRId32 "\n"
 149                         "create process is %sstopped\n"
 150                         ,
 151                         create_pid,
 152                         create_process_stopped? "" : "not "
 153                 );
 154         if (remove_pid != 0)
 155                 fprintf(log, "remove_pid: %" PRId32 "\n", remove_pid);
 156         if (next_snapshot_time != 0)
 157                 fprintf(log, "next snapshot due in %" PRId64 " seconds\n",
 158                         next_snapshot_time - now);
 159         if (current_snapshot_creation_time != 0)
 160                 fprintf(log, "current_snapshot_creation_time: %"
 161                         PRId64 " (%" PRId64 " seconds ago)\n",
 162                         current_snapshot_creation_time,
 163                         now - current_snapshot_creation_time
 164                 );
 165         if (next_removal_check.tv_sec != 0) {
 166                 fprintf(log, "next removal check: %llu (%llu seconds ago)\n",
 167                         (long long unsigned)next_removal_check.tv_sec,
 168                         now - (long long unsigned)next_removal_check.tv_sec
 169                 );
 170
 171         }
 172         fprintf(log, "%s </%s config> %s\n", dash, msg, dash);
 173 }
 174
 175 /* a litte cpp magic helps to DRY */
 176 #define COMMANDS \
 177         COMMAND(ls) \
 178         COMMAND(create) \
 179         COMMAND(prune) \
 180         COMMAND(run) \
 181         COMMAND(kill) \
 182         COMMAND(reload) \
 183
 184 #define COMMAND(x) static int com_ ##x(void);
 185 COMMANDS
 186 #undef COMMAND
 187 #define COMMAND(x) if (conf.x ##_given) return com_ ##x();
 188 static int call_command_handler(void)
 189 {
 190         COMMANDS
 191         DSS_EMERG_LOG(("BUG: did not find command handler\n"));
 192         return -E_BUG;
 193 }
 194 #undef COMMAND
 195 #undef COMMANDS
 196
 197 static int loglevel = -1;
 198 static const char *location_file = NULL;
 199 static int         location_line = -1;
 200 static const char *location_func = NULL;
 201
 202 void dss_log_set_params(int ll, const char *file, int line, const char *func)
 203 {
 204         loglevel = ll;
 205         location_file = file;
 206         location_line = line;
 207         location_func = func;
 208 }
 209
 210 /**
 211  * The log function of dss.
 212  *
 213  * \param ll Loglevel.
 214  * \param fml Usual format string.
 215  *
 216  * All DSS_XXX_LOG() macros use this function.
 217  */
 218 __printf_1_2 void dss_log(const char* fmt,...)
 219 {
 220         va_list argp;
 221         FILE *outfd;
 222         struct tm *tm;
 223         time_t t1;
 224         char str[255] = "";
 225
 226         if (loglevel < conf.loglevel_arg)
 227                 return;
 228         outfd = logfile? logfile : stderr;
 229         time(&t1);
 230         tm = localtime(&t1);
 231         strftime(str, sizeof(str), "%b %d %H:%M:%S", tm);
 232         fprintf(outfd, "%s ", str);
 233         if (conf.loglevel_arg <= INFO)
 234                 fprintf(outfd, "%i: ", loglevel);
 235 #ifdef DSS_NO_FUNC_NAMES
 236         fprintf(outfd, "%s:%d: ", location_file, location_line);
 237 #else
 238         fprintf(outfd, "%s: ", location_func);
 239 #endif
 240         va_start(argp, fmt);
 241         vfprintf(outfd, fmt, argp);
 242         va_end(argp);
 243 }
 244
 245 /**
 246  * Print a message either to stdout or to the log file.
 247  */
 248 static __printf_1_2 void dss_msg(const char* fmt,...)
 249 {
 250         FILE *outfd = conf.daemon_given? logfile : stdout;
 251         va_list argp;
 252         va_start(argp, fmt);
 253         vfprintf(outfd, fmt, argp);
 254         va_end(argp);
 255 }
 256
 257 static char *get_config_file_name(void)
 258 {
 259         char *home, *config_file;
 260
 261         if (conf.config_file_given)
 262                 return dss_strdup(conf.config_file_arg);
 263         home = get_homedir();
 264         config_file = make_message("%s/.dssrc", home);
 265         free(home);
 266         return config_file;
 267 }
 268
 269 static int send_signal(int sig)
 270 {
 271         pid_t pid;
 272         char *config_file = get_config_file_name();
 273         int ret = get_dss_pid(config_file, &pid);
 274
 275         free(config_file);
 276         if (ret < 0)
 277                 return ret;
 278         if (conf.dry_run_given) {
 279                 dss_msg("%d\n", (int)pid);
 280                 return 0;
 281         }
 282         ret = kill(pid, sig);
 283         if (ret < 0)
 284                 return -ERRNO_TO_DSS_ERROR(errno);
 285         return 1;
 286 }
 287
 288 static int com_kill(void)
 289 {
 290         return send_signal(SIGTERM);
 291 }
 292
 293 static int com_reload(void)
 294 {
 295         return send_signal(SIGHUP);
 296 }
 297
 298 static void dss_get_snapshot_list(struct snapshot_list *sl)
 299 {
 300         get_snapshot_list(sl, conf.unit_interval_arg, conf.num_intervals_arg);
 301 }
 302
 303 static int64_t compute_next_snapshot_time(void)
 304 {
 305         int64_t x = 0, now = get_current_time(), unit_interval
 306                 = 24 * 3600 * conf.unit_interval_arg, ret;
 307         unsigned wanted = desired_number_of_snapshots(0, conf.num_intervals_arg),
 308                 num_complete = 0;
 309         int i;
 310         struct snapshot *s = NULL;
 311         struct snapshot_list sl;
 312
 313         dss_get_snapshot_list(&sl);
 314         FOR_EACH_SNAPSHOT(s, i, &sl) {
 315                 if (!(s->flags & SS_COMPLETE))
 316                         continue;
 317                 num_complete++;
 318                 x += s->completion_time - s->creation_time;
 319         }
 320         assert(x >= 0);
 321
 322         ret = now;
 323         if (num_complete == 0)
 324                 goto out;
 325         x /= num_complete; /* avg time to create one snapshot */
 326         if (unit_interval < x * wanted) /* oops, no sleep at all */
 327                 goto out;
 328         ret = s->completion_time + unit_interval / wanted - x;
 329 out:
 330         free_snapshot_list(&sl);
 331         return ret;
 332 }
 333
 334 static inline void invalidate_next_snapshot_time(void)
 335 {
 336         next_snapshot_time = 0;
 337 }
 338
 339 static inline int next_snapshot_time_is_valid(void)
 340 {
 341         return next_snapshot_time != 0;
 342 }
 343
 344 static int next_snapshot_is_due(void)
 345 {
 346         int64_t now = get_current_time();
 347
 348         if (!next_snapshot_time_is_valid())
 349                 next_snapshot_time = compute_next_snapshot_time();
 350         if (next_snapshot_time <= now) {
 351                 DSS_DEBUG_LOG(("next snapshot: now\n"));
 352                 return 1;
 353         }
 354         DSS_DEBUG_LOG(("next snapshot due in %" PRId64 " seconds\n",
 355                 next_snapshot_time - now));
 356         return 0;
 357 }
 358
 359 static void pre_create_hook(void)
 360 {
 361         assert(snapshot_creation_status == HS_READY);
 362         /* make sure that the next snapshot time will be recomputed */
 363         invalidate_next_snapshot_time();
 364         DSS_DEBUG_LOG(("executing %s\n", conf.pre_create_hook_arg));
 365         dss_exec_cmdline_pid(&create_pid, conf.pre_create_hook_arg);
 366         snapshot_creation_status = HS_PRE_RUNNING;
 367 }
 368
 369 static void pre_remove_hook(struct snapshot *s, const char *why)
 370 {
 371         char *cmd;
 372
 373         if (!s)
 374                 return;
 375         DSS_DEBUG_LOG(("%s snapshot %s\n", why, s->name));
 376         assert(snapshot_removal_status == HS_READY);
 377         assert(remove_pid == 0);
 378         assert(!snapshot_currently_being_removed);
 379
 380         snapshot_currently_being_removed = dss_malloc(sizeof(struct snapshot));
 381         *snapshot_currently_being_removed = *s;
 382         snapshot_currently_being_removed->name = dss_strdup(s->name);
 383
 384         cmd = make_message("%s %s/%s", conf.pre_remove_hook_arg,
 385                 conf.dest_dir_arg, s->name);
 386         DSS_DEBUG_LOG(("executing %s\n", cmd));
 387         dss_exec_cmdline_pid(&remove_pid, cmd);
 388         free(cmd);
 389         snapshot_removal_status = HS_PRE_RUNNING;
 390 }
 391
 392 static int exec_rm(void)
 393 {
 394         struct snapshot *s = snapshot_currently_being_removed;
 395         char *new_name = being_deleted_name(s);
 396         char *argv[4];
 397         int ret;
 398
 399         argv[0] = "rm";
 400         argv[1] = "-rf";
 401         argv[2] = new_name;
 402         argv[3] = NULL;
 403
 404         assert(snapshot_removal_status == HS_PRE_SUCCESS);
 405         assert(remove_pid == 0);
 406
 407         DSS_NOTICE_LOG(("removing %s (interval = %i)\n", s->name, s->interval));
 408         ret = dss_rename(s->name, new_name);
 409         if (ret < 0)
 410                 goto out;
 411         dss_exec(&remove_pid, argv[0], argv);
 412         snapshot_removal_status = HS_RUNNING;
 413 out:
 414         free(new_name);
 415         return ret;
 416 }
 417
 418 static int snapshot_is_being_created(struct snapshot *s)
 419 {
 420         return s->creation_time == current_snapshot_creation_time;
 421 }
 422
 423 static struct snapshot *find_orphaned_snapshot(struct snapshot_list *sl)
 424 {
 425         struct snapshot *s;
 426         int i;
 427
 428         DSS_DEBUG_LOG(("looking for orphaned snapshots\n"));
 429         FOR_EACH_SNAPSHOT(s, i, sl) {
 430                 if (snapshot_is_being_created(s))
 431                         continue;
 432                 /*
 433                  * We know that no rm is currently running, so if s is marked
 434                  * as being deleted, a previously started rm must have failed.
 435                  */
 436                 if (s->flags & SS_BEING_DELETED)
 437                         return s;
 438
 439                 if (s->flags & SS_COMPLETE) /* good snapshot */
 440                         continue;
 441                 /*
 442                  * This snapshot is incomplete and it is not the snapshot
 443                  * currently being created. However, we must not remove it if
 444                  * rsync is about to be restarted. As only the newest snapshot
 445                  * can be restarted, this snapshot is orphaned if it is not the
 446                  * newest snapshot or if we are not about to restart rsync.
 447                  */
 448                 if (get_newest_snapshot(sl) != s)
 449                         return s;
 450                 if (snapshot_creation_status != HS_NEEDS_RESTART)
 451                         return s;
 452         }
 453         /* no orphaned snapshots */
 454         return NULL;
 455 }
 456
 457 static int is_reference_snapshot(struct snapshot *s)
 458 {
 459         if (!name_of_reference_snapshot)
 460                 return 0;
 461         return strcmp(s->name, name_of_reference_snapshot)? 0 : 1;
 462 }
 463
 464 /*
 465  * return: 0: no redundant snapshots, 1: rm process started, negative: error
 466  */
 467 static struct snapshot *find_redundant_snapshot(struct snapshot_list *sl)
 468 {
 469         int i, interval;
 470         struct snapshot *s;
 471         unsigned missing = 0;
 472
 473         DSS_DEBUG_LOG(("looking for intervals containing too many snapshots\n"));
 474         for (interval = conf.num_intervals_arg - 1; interval >= 0; interval--) {
 475                 unsigned keep = desired_number_of_snapshots(interval, conf.num_intervals_arg);
 476                 unsigned num = sl->interval_count[interval];
 477                 struct snapshot *victim = NULL, *prev = NULL;
 478                 int64_t score = LONG_MAX;
 479
 480                 if (keep >= num)
 481                         missing += keep - num;
 482                 if (keep + missing >= num)
 483                         continue;
 484                 /* redundant snapshot in this interval, pick snapshot with lowest score */
 485                 FOR_EACH_SNAPSHOT(s, i, sl) {
 486                         int64_t this_score;
 487
 488                         if (snapshot_is_being_created(s))
 489                                 continue;
 490                         if (is_reference_snapshot(s))
 491                                 continue;
 492                         if (s->interval > interval) {
 493                                 prev = s;
 494                                 continue;
 495                         }
 496                         if (s->interval < interval)
 497                                 break;
 498                         if (!victim) {
 499                                 victim = s;
 500                                 prev = s;
 501                                 continue;
 502                         }
 503                         assert(prev);
 504                         /* check if s is a better victim */
 505                         this_score = s->creation_time - prev->creation_time;
 506                         assert(this_score >= 0);
 507                         if (this_score < score) {
 508                                 score = this_score;
 509                                 victim = s;
 510                         }
 511                         prev = s;
 512                 }
 513                 assert(victim);
 514                 return victim;
 515         }
 516         return NULL;
 517 }
 518
 519 static struct snapshot *find_outdated_snapshot(struct snapshot_list *sl)
 520 {
 521         int i;
 522         struct snapshot *s;
 523
 524         DSS_DEBUG_LOG(("looking for snapshots belonging to intervals >= %d\n",
 525                 conf.num_intervals_arg));
 526         FOR_EACH_SNAPSHOT(s, i, sl) {
 527                 if (snapshot_is_being_created(s))
 528                         continue;
 529                 if (is_reference_snapshot(s))
 530                         continue;
 531                 if (s->interval < conf.num_intervals_arg)
 532                         continue;
 533                 return s;
 534         }
 535         return NULL;
 536 }
 537
 538 static struct snapshot *find_oldest_removable_snapshot(struct snapshot_list *sl)
 539 {
 540         int i, num_complete;
 541         struct snapshot *s, *ref = NULL;
 542
 543         num_complete = num_complete_snapshots(sl);
 544         if (num_complete <= conf.min_complete_arg)
 545                 return NULL;
 546         FOR_EACH_SNAPSHOT(s, i, sl) {
 547                 if (snapshot_is_being_created(s))
 548                         continue;
 549                 if (is_reference_snapshot(s)) { /* avoid this one */
 550                         ref = s;
 551                         continue;
 552                 }
 553                 DSS_INFO_LOG(("oldest removable snapshot: %s\n", s->name));
 554                 return s;
 555         }
 556         assert(ref);
 557         DSS_WARNING_LOG(("removing reference snapshot %s\n", ref->name));
 558         return ref;
 559 }
 560
 561 static int rename_incomplete_snapshot(int64_t start)
 562 {
 563         char *old_name;
 564         int ret;
 565         int64_t now;
 566
 567         /*
 568          * We don't want the dss_rename() below to fail with EEXIST because the
 569          * last complete snapshot was created (and completed) in the same
 570          * second as this one.
 571          */
 572         while ((now = get_current_time()) == start)
 573                 sleep(1);
 574         free(path_to_last_complete_snapshot);
 575         ret = complete_name(start, now, &path_to_last_complete_snapshot);
 576         if (ret < 0)
 577                 return ret;
 578         old_name = incomplete_name(start);
 579         ret = dss_rename(old_name, path_to_last_complete_snapshot);
 580         if (ret >= 0)
 581                 DSS_NOTICE_LOG(("%s -> %s\n", old_name,
 582                         path_to_last_complete_snapshot));
 583         free(old_name);
 584         return ret;
 585 }
 586
 587 static int try_to_free_disk_space(void)
 588 {
 589         int ret;
 590         struct snapshot_list sl;
 591         struct snapshot *victim;
 592         struct timeval now;
 593         const char *why;
 594         int low_disk_space;
 595
 596         ret = disk_space_low(NULL);
 597         if (ret < 0)
 598                 return ret;
 599         low_disk_space = ret;
 600         gettimeofday(&now, NULL);
 601         if (tv_diff(&next_removal_check, &now, NULL) > 0)
 602                 return 0;
 603         if (!low_disk_space) {
 604                 if (conf.keep_redundant_given)
 605                         return 0;
 606                 if (snapshot_creation_status != HS_READY)
 607                         return 0;
 608                 if (next_snapshot_is_due())
 609                         return 0;
 610         }
 611         /*
 612          * Idle and --keep_redundant not given, or low disk space. Look at
 613          * existing snapshots.
 614          */
 615         dss_get_snapshot_list(&sl);
 616         ret = 0;
 617         /*
 618          * Don't remove anything if there is free space and we have fewer
 619          * snapshots than configured, plus one. This way there is always one
 620          * snapshot that can be recycled.
 621          */
 622         if (!low_disk_space && sl.num_snapshots <= 1 << conf.num_intervals_arg)
 623                 goto out;
 624         why = "outdated";
 625         victim = find_outdated_snapshot(&sl);
 626         if (victim)
 627                 goto remove;
 628         why = "redundant";
 629         victim = find_redundant_snapshot(&sl);
 630         if (victim)
 631                 goto remove;
 632         why = "orphaned";
 633         victim = find_orphaned_snapshot(&sl);
 634         if (victim)
 635                 goto remove;
 636         /* try harder only if disk space is low */
 637         if (!low_disk_space)
 638                 goto out;
 639         DSS_WARNING_LOG(("disk space low and nothing obvious to remove\n"));
 640         why = "oldest";
 641         victim = find_oldest_removable_snapshot(&sl);
 642         if (victim)
 643                 goto remove;
 644         DSS_CRIT_LOG(("uhuhu: disk space low and nothing to remove\n"));
 645         ret = -ERRNO_TO_DSS_ERROR(ENOSPC);
 646         goto out;
 647 remove:
 648         pre_remove_hook(victim, why);
 649 out:
 650         free_snapshot_list(&sl);
 651         return ret;
 652 }
 653
 654 static void post_create_hook(void)
 655 {
 656         char *cmd = make_message("%s %s/%s", conf.post_create_hook_arg,
 657                 conf.dest_dir_arg, path_to_last_complete_snapshot);
 658         DSS_NOTICE_LOG(("executing %s\n", cmd));
 659         dss_exec_cmdline_pid(&create_pid, cmd);
 660         free(cmd);
 661         snapshot_creation_status = HS_POST_RUNNING;
 662 }
 663
 664 static void post_remove_hook(void)
 665 {
 666         char *cmd;
 667         struct snapshot *s = snapshot_currently_being_removed;
 668
 669         assert(s);
 670
 671         cmd = make_message("%s %s/%s", conf.post_remove_hook_arg,
 672                 conf.dest_dir_arg, s->name);
 673         DSS_NOTICE_LOG(("executing %s\n", cmd));
 674         dss_exec_cmdline_pid(&remove_pid, cmd);
 675         free(cmd);
 676         snapshot_removal_status = HS_POST_RUNNING;
 677 }
 678
 679 static void dss_kill(pid_t pid, int sig, const char *msg)
 680 {
 681         const char *signame, *process_name;
 682
 683         if (pid == 0)
 684                 return;
 685         switch (sig) {
 686         case SIGTERM: signame = "TERM"; break;
 687         case SIGSTOP: signame = "STOP"; break;
 688         case SIGCONT: signame = "CONT"; break;
 689         default: signame = "????";
 690         }
 691
 692         if (pid == create_pid)
 693                 process_name = "create";
 694         else if (pid == remove_pid)
 695                 process_name = "remove";
 696         else process_name = "??????";
 697
 698         if (msg)
 699                 DSS_INFO_LOG(("%s\n", msg));
 700         DSS_DEBUG_LOG(("sending signal %d (%s) to pid %d (%s process)\n",
 701                 sig, signame, (int)pid, process_name));
 702         if (kill(pid, sig) >= 0)
 703                 return;
 704         DSS_INFO_LOG(("failed to send signal %d (%s) to pid %d (%s process)\n",
 705                 sig, signame, (int)pid, process_name));
 706 }
 707
 708 static void stop_create_process(void)
 709 {
 710         if (create_process_stopped)
 711                 return;
 712         dss_kill(create_pid, SIGSTOP, "suspending create process");
 713         create_process_stopped = 1;
 714 }
 715
 716 static void restart_create_process(void)
 717 {
 718         if (!create_process_stopped)
 719                 return;
 720         dss_kill(create_pid, SIGCONT, "resuming create process");
 721         create_process_stopped = 0;
 722 }
 723
 724 /**
 725  * Print a log message about the exit status of a child.
 726  */
 727 static void log_termination_msg(pid_t pid, int status)
 728 {
 729         if (WIFEXITED(status))
 730                 DSS_INFO_LOG(("child %i exited. Exit status: %i\n", (int)pid,
 731                         WEXITSTATUS(status)));
 732         else if (WIFSIGNALED(status))
 733                 DSS_NOTICE_LOG(("child %i was killed by signal %i\n", (int)pid,
 734                         WTERMSIG(status)));
 735         else
 736                 DSS_WARNING_LOG(("child %i terminated abormally\n", (int)pid));
 737 }
 738
 739 static int wait_for_process(pid_t pid, int *status)
 740 {
 741         int ret;
 742
 743         DSS_DEBUG_LOG(("Waiting for process %d to terminate\n", (int)pid));
 744         for (;;) {
 745                 fd_set rfds;
 746
 747                 FD_ZERO(&rfds);
 748                 FD_SET(signal_pipe, &rfds);
 749                 ret = dss_select(signal_pipe + 1, &rfds, NULL, NULL);
 750                 if (ret < 0)
 751                         break;
 752                 ret = next_signal();
 753                 if (!ret)
 754                         continue;
 755                 if (ret == SIGCHLD) {
 756                         ret = waitpid(pid, status, 0);
 757                         if (ret >= 0)
 758                                 break;
 759                         if (errno != EINTR) { /* error */
 760                                 ret = -ERRNO_TO_DSS_ERROR(errno);
 761                                 break;
 762                         }
 763                 }
 764                 /* SIGINT or SIGTERM */
 765                 dss_kill(pid, SIGTERM, "killing child process");
 766         }
 767         if (ret < 0)
 768                 DSS_ERROR_LOG(("failed to wait for process %d\n", (int)pid));
 769         else
 770                 log_termination_msg(pid, *status);
 771         return ret;
 772 }
 773
 774 static void handle_pre_remove_exit(int status)
 775 {
 776         if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
 777                 snapshot_removal_status = HS_READY;
 778                 gettimeofday(&next_removal_check, NULL);
 779                 next_removal_check.tv_sec += 60;
 780                 return;
 781         }
 782         snapshot_removal_status = HS_PRE_SUCCESS;
 783 }
 784
 785 static int handle_rm_exit(int status)
 786 {
 787         if (!WIFEXITED(status)) {
 788                 snapshot_removal_status = HS_READY;
 789                 return -E_INVOLUNTARY_EXIT;
 790         }
 791         if (WEXITSTATUS(status)) {
 792                 snapshot_removal_status = HS_READY;
 793                 return -E_BAD_EXIT_CODE;
 794         }
 795         snapshot_removal_status = HS_SUCCESS;
 796         return 1;
 797 }
 798
 799 static void handle_post_remove_exit(void)
 800 {
 801         snapshot_removal_status = HS_READY;
 802 }
 803
 804 static int handle_remove_exit(int status)
 805 {
 806         int ret;
 807         struct snapshot *s = snapshot_currently_being_removed;
 808
 809         assert(s);
 810         switch (snapshot_removal_status) {
 811         case HS_PRE_RUNNING:
 812                 handle_pre_remove_exit(status);
 813                 ret = 1;
 814                 break;
 815         case HS_RUNNING:
 816                 ret = handle_rm_exit(status);
 817                 break;
 818         case HS_POST_RUNNING:
 819                 handle_post_remove_exit();
 820                 ret = 1;
 821                 break;
 822         default:
 823                 ret = -E_BUG;
 824         }
 825         if (snapshot_removal_status == HS_READY) {
 826                 free(s->name);
 827                 free(s);
 828                 snapshot_currently_being_removed = NULL;
 829         }
 830         remove_pid = 0;
 831         return ret;
 832 }
 833
 834 static int wait_for_remove_process(void)
 835 {
 836         int status, ret;
 837
 838         assert(remove_pid);
 839         assert(
 840                 snapshot_removal_status == HS_PRE_RUNNING ||
 841                 snapshot_removal_status == HS_RUNNING ||
 842                 snapshot_removal_status == HS_POST_RUNNING
 843         );
 844         ret = wait_for_process(remove_pid, &status);
 845         if (ret < 0)
 846                 return ret;
 847         return handle_remove_exit(status);
 848 }
 849
 850 static int handle_rsync_exit(int status)
 851 {
 852         int es, ret;
 853
 854         if (!WIFEXITED(status)) {
 855                 DSS_ERROR_LOG(("rsync process %d died involuntary\n", (int)create_pid));
 856                 ret = -E_INVOLUNTARY_EXIT;
 857                 snapshot_creation_status = HS_READY;
 858                 goto out;
 859         }
 860         es = WEXITSTATUS(status);
 861         /*
 862          * Restart rsync on non-fatal errors:
 863          * 24: Partial transfer due to vanished source files
 864          */
 865         if (es != 0 && es != 24) {
 866                 DSS_WARNING_LOG(("rsync exit code %d, error count %d\n",
 867                         es, ++num_consecutive_rsync_errors));
 868                 if (conf.create_given) {
 869                         ret = -E_BAD_EXIT_CODE;
 870                         goto out;
 871                 }
 872                 if (num_consecutive_rsync_errors > conf.max_rsync_errors_arg) {
 873                         ret = -E_TOO_MANY_RSYNC_ERRORS;
 874                         snapshot_creation_status = HS_READY;
 875                         goto out;
 876                 }
 877                 DSS_WARNING_LOG(("restarting rsync process\n"));
 878                 snapshot_creation_status = HS_NEEDS_RESTART;
 879                 next_snapshot_time = get_current_time() + 60;
 880                 ret = 1;
 881                 goto out;
 882         }
 883         num_consecutive_rsync_errors = 0;
 884         ret = rename_incomplete_snapshot(current_snapshot_creation_time);
 885         if (ret < 0)
 886                 goto out;
 887         snapshot_creation_status = HS_SUCCESS;
 888         free(name_of_reference_snapshot);
 889         name_of_reference_snapshot = NULL;
 890 out:
 891         create_process_stopped = 0;
 892         return ret;
 893 }
 894
 895 static int handle_pre_create_hook_exit(int status)
 896 {
 897         int es, ret;
 898         static int warn_count;
 899
 900         if (!WIFEXITED(status)) {
 901                 snapshot_creation_status = HS_READY;
 902                 ret = -E_INVOLUNTARY_EXIT;
 903                 goto out;
 904         }
 905         es = WEXITSTATUS(status);
 906         if (es) {
 907                 if (!warn_count--) {
 908                         DSS_NOTICE_LOG(("pre_create_hook %s returned %d\n",
 909                                 conf.pre_create_hook_arg, es));
 910                         DSS_NOTICE_LOG(("deferring snapshot creation...\n"));
 911                         warn_count = 60; /* warn only once per hour */
 912                 }
 913                 next_snapshot_time = get_current_time() + 60;
 914                 snapshot_creation_status = HS_READY;
 915                 ret = 0;
 916                 goto out;
 917         }
 918         warn_count = 0;
 919         snapshot_creation_status = HS_PRE_SUCCESS;
 920         ret = 1;
 921 out:
 922         return ret;
 923 }
 924
 925 static int handle_sigchld(void)
 926 {
 927         pid_t pid;
 928         int status, ret = reap_child(&pid, &status);
 929
 930         if (ret <= 0)
 931                 return ret;
 932
 933         if (pid == create_pid) {
 934                 switch (snapshot_creation_status) {
 935                 case HS_PRE_RUNNING:
 936                         ret = handle_pre_create_hook_exit(status);
 937                         break;
 938                 case HS_RUNNING:
 939                         ret = handle_rsync_exit(status);
 940                         break;
 941                 case HS_POST_RUNNING:
 942                         snapshot_creation_status = HS_READY;
 943                         ret = 1;
 944                         break;
 945                 default:
 946                         DSS_EMERG_LOG(("BUG: create can't die in status %d\n",
 947                                 snapshot_creation_status));
 948                         return -E_BUG;
 949                 }
 950                 create_pid = 0;
 951                 return ret;
 952         }
 953         if (pid == remove_pid) {
 954                 ret = handle_remove_exit(status);
 955                 if (ret < 0)
 956                         return ret;
 957                 return ret;
 958         }
 959         DSS_EMERG_LOG(("BUG: unknown process %d died\n", (int)pid));
 960         return -E_BUG;
 961 }
 962
 963 static int check_config(void)
 964 {
 965         if (conf.unit_interval_arg <= 0) {
 966                 DSS_ERROR_LOG(("bad unit interval: %i\n", conf.unit_interval_arg));
 967                 return -E_INVALID_NUMBER;
 968         }
 969         DSS_DEBUG_LOG(("unit interval: %i day(s)\n", conf.unit_interval_arg));
 970         if (conf.num_intervals_arg <= 0 || conf.num_intervals_arg > 30) {
 971                 DSS_ERROR_LOG(("bad number of intervals: %i\n",
 972                         conf.num_intervals_arg));
 973                 return -E_INVALID_NUMBER;
 974         }
 975         DSS_DEBUG_LOG(("number of intervals: %i\n", conf.num_intervals_arg));
 976         return 1;
 977 }
 978
 979 /*
 980  * Returns < 0 on errors, 0 if no config file is given and > 0 if the config
 981  * file was read successfully.
 982  */
 983 static int parse_config_file(bool sighup)
 984 {
 985         int ret, config_file_exists;
 986         char *config_file = get_config_file_name();
 987         struct stat statbuf;
 988         char *old_logfile_arg = NULL;
 989         int old_daemon_given = 0;
 990
 991         if (sighup) {
 992                 if (conf.logfile_given)
 993                         old_logfile_arg = dss_strdup(conf.logfile_arg);
 994                 old_daemon_given = conf.daemon_given;
 995         }
 996
 997         config_file_exists = !stat(config_file, &statbuf);
 998         if (!config_file_exists && conf.config_file_given) {
 999                 ret = -ERRNO_TO_DSS_ERROR(errno);
1000                 DSS_ERROR_LOG(("failed to stat config file %s\n", config_file));
1001                 goto out;
1002         }
1003         if (config_file_exists) {
1004                 struct cmdline_parser_params params;
1005                 params.override = sighup;
1006                 params.initialize = 0;
1007                 params.check_required = 1;
1008                 params.check_ambiguity = 0;
1009                 params.print_errors = 1;
1010                 if (sighup) { /* invalidate all rsync options */
1011                         int i;
1012
1013                         for (i = 0; i < conf.rsync_option_given; i++) {
1014                                 free(conf.rsync_option_arg[i]);
1015                                 conf.rsync_option_arg[i] = NULL;
1016                         }
1017                         conf.rsync_option_given = 0;
1018                 }
1019                 cmdline_parser_config_file(config_file, &conf, &params);
1020         }
1021         ret = check_config();
1022         if (ret < 0)
1023                 goto out;
1024         if (sighup) {
1025                 /* don't change daemon mode on SIGHUP */
1026                 conf.daemon_given = old_daemon_given;
1027                 close_log(logfile);
1028                 logfile = NULL;
1029                 if (conf.logfile_given)
1030                         free(old_logfile_arg);
1031                 else if (conf.daemon_given) { /* re-use old logfile */
1032                         conf.logfile_arg = old_logfile_arg;
1033                         conf.logfile_given = 1;
1034                 }
1035         }
1036         if (conf.logfile_given && conf.run_given && conf.daemon_given) {
1037                 logfile = open_log(conf.logfile_arg);
1038                 log_welcome(conf.loglevel_arg);
1039         }
1040         DSS_DEBUG_LOG(("loglevel: %d\n", conf.loglevel_arg));
1041         ret = config_file_exists;
1042 out:
1043         free(config_file);
1044         if (ret < 0)
1045                 DSS_EMERG_LOG(("%s\n", dss_strerror(-ret)));
1046         return ret;
1047 }
1048
1049 static int change_to_dest_dir(void)
1050 {
1051         DSS_INFO_LOG(("changing cwd to %s\n", conf.dest_dir_arg));
1052         return dss_chdir(conf.dest_dir_arg);
1053 }
1054
1055 static int handle_sighup(void)
1056 {
1057         int ret;
1058
1059         DSS_NOTICE_LOG(("SIGHUP, re-reading config\n"));
1060         dump_dss_config("old");
1061         ret = parse_config_file(true /* SIGHUP */);
1062         if (ret < 0)
1063                 return ret;
1064         dump_dss_config("reloaded");
1065         invalidate_next_snapshot_time();
1066         return change_to_dest_dir();
1067 }
1068
1069 static void kill_children(void)
1070 {
1071         restart_create_process();
1072         dss_kill(create_pid, SIGTERM, NULL);
1073         dss_kill(remove_pid, SIGTERM, NULL);
1074 }
1075
1076 static int handle_signal(void)
1077 {
1078         int sig, ret = next_signal();
1079
1080         if (ret <= 0)
1081                 goto out;
1082         sig = ret;
1083         switch (sig) {
1084         case SIGINT:
1085         case SIGTERM:
1086                 kill_children();
1087                 ret = -E_SIGNAL;
1088                 break;
1089         case SIGHUP:
1090                 ret = handle_sighup();
1091                 break;
1092         case SIGCHLD:
1093                 ret = handle_sigchld();
1094                 break;
1095         }
1096 out:
1097         if (ret < 0)
1098                 DSS_ERROR_LOG(("%s\n", dss_strerror(-ret)));
1099         return ret;
1100 }
1101
1102 /*
1103  * We can not use rsync locally if the local user is different from the remote
1104  * user or if the src dir is not on the local host (or both).
1105  */
1106 static int use_rsync_locally(char *logname)
1107 {
1108         char *h = conf.remote_host_arg;
1109
1110         if (strcmp(h, "localhost") && strcmp(h, "127.0.0.1"))
1111                 return 0;
1112         if (conf.remote_user_given && strcmp(conf.remote_user_arg, logname))
1113                 return 0;
1114         return 1;
1115 }
1116
1117 static int rename_resume_snap(int64_t creation_time)
1118 {
1119         struct snapshot_list sl;
1120         struct snapshot *s = NULL;
1121         char *new_name = incomplete_name(creation_time);
1122         int ret;
1123         const char *why;
1124
1125         sl.num_snapshots = 0;
1126
1127         ret = 0;
1128         if (conf.no_resume_given)
1129                 goto out;
1130         dss_get_snapshot_list(&sl);
1131         /*
1132          * Snapshot recycling: We first look at the newest snapshot. If this
1133          * snapshot happens to be incomplete, the last rsync process was
1134          * aborted and we reuse this one. Otherwise we look at snapshots which
1135          * could be removed (outdated and redundant snapshots) as candidates
1136          * for recycling. If no outdated/redundant snapshot exists, we check if
1137          * there is an orphaned snapshot, which likely is useless anyway.
1138          *
1139          * Only if no existing snapshot is suitable for recycling, we bite the
1140          * bullet and create a new one.
1141          */
1142         s = get_newest_snapshot(&sl);
1143         if (!s) /* no snapshots at all */
1144                 goto out;
1145         /* re-use last snapshot if it is incomplete */
1146         why = "aborted";
1147         if ((s->flags & SS_COMPLETE) == 0)
1148                 goto out;
1149         why = "outdated";
1150         s = find_outdated_snapshot(&sl);
1151         if (s)
1152                 goto out;
1153         why = "redundant";
1154         s = find_redundant_snapshot(&sl);
1155         if (s)
1156                 goto out;
1157         why = "orphaned";
1158         s = find_orphaned_snapshot(&sl);
1159 out:
1160         if (s) {
1161                 DSS_NOTICE_LOG(("recycling %s snapshot %s\n", why, s->name));
1162                 ret = dss_rename(s->name, new_name);
1163         }
1164         if (ret >= 0)
1165                 DSS_NOTICE_LOG(("creating %s\n", new_name));
1166         free(new_name);
1167         free_snapshot_list(&sl);
1168         return ret;
1169 }
1170
1171 static void create_rsync_argv(char ***argv, int64_t *num)
1172 {
1173         char *logname;
1174         int i = 0, j;
1175         struct snapshot_list sl;
1176
1177         dss_get_snapshot_list(&sl);
1178         assert(!name_of_reference_snapshot);
1179         name_of_reference_snapshot = name_of_newest_complete_snapshot(&sl);
1180         free_snapshot_list(&sl);
1181
1182         *argv = dss_malloc((15 + conf.rsync_option_given) * sizeof(char *));
1183         (*argv)[i++] = dss_strdup("rsync");
1184         (*argv)[i++] = dss_strdup("-a");
1185         (*argv)[i++] = dss_strdup("--delete");
1186         for (j = 0; j < conf.rsync_option_given; j++)
1187                 (*argv)[i++] = dss_strdup(conf.rsync_option_arg[j]);
1188         if (name_of_reference_snapshot) {
1189                 DSS_INFO_LOG(("using %s as reference\n", name_of_reference_snapshot));
1190                 (*argv)[i++] = make_message("--link-dest=../%s",
1191                         name_of_reference_snapshot);
1192         } else
1193                 DSS_INFO_LOG(("no suitable reference snapshot found\n"));
1194         logname = dss_logname();
1195         if (use_rsync_locally(logname))
1196                 (*argv)[i++] = dss_strdup(conf.source_dir_arg);
1197         else
1198                 (*argv)[i++] = make_message("%s@%s:%s/", conf.remote_user_given?
1199                         conf.remote_user_arg : logname,
1200                         conf.remote_host_arg, conf.source_dir_arg);
1201         free(logname);
1202         *num = get_current_time();
1203         (*argv)[i++] = incomplete_name(*num);
1204         (*argv)[i++] = NULL;
1205         for (j = 0; j < i; j++)
1206                 DSS_DEBUG_LOG(("argv[%d] = %s\n", j, (*argv)[j]));
1207 }
1208
1209 static void free_rsync_argv(char **argv)
1210 {
1211         int i;
1212
1213         if (!argv)
1214                 return;
1215         for (i = 0; argv[i]; i++)
1216                 free(argv[i]);
1217         free(argv);
1218 }
1219
1220 static int create_snapshot(char **argv)
1221 {
1222         int ret;
1223
1224         ret = rename_resume_snap(current_snapshot_creation_time);
1225         if (ret < 0)
1226                 return ret;
1227         dss_exec(&create_pid, argv[0], argv);
1228         snapshot_creation_status = HS_RUNNING;
1229         return ret;
1230 }
1231
1232 static int select_loop(void)
1233 {
1234         int ret;
1235         /* check every 60 seconds for free disk space */
1236         struct timeval tv;
1237         char **rsync_argv = NULL;
1238
1239         for (;;) {
1240                 fd_set rfds;
1241                 struct timeval *tvp;
1242
1243                 if (remove_pid)
1244                         tvp = NULL; /* sleep until rm hook/process dies */
1245                 else { /* sleep one minute */
1246                         tv.tv_sec = 60;
1247                         tv.tv_usec = 0;
1248                         tvp = &tv;
1249                 }
1250                 FD_ZERO(&rfds);
1251                 FD_SET(signal_pipe, &rfds);
1252                 ret = dss_select(signal_pipe + 1, &rfds, NULL, tvp);
1253                 if (ret < 0)
1254                         goto out;
1255                 if (FD_ISSET(signal_pipe, &rfds)) {
1256                         ret = handle_signal();
1257                         if (ret < 0)
1258                                 goto out;
1259                 }
1260                 if (remove_pid)
1261                         continue;
1262                 if (snapshot_removal_status == HS_PRE_SUCCESS) {
1263                         ret = exec_rm();
1264                         if (ret < 0)
1265                                 goto out;
1266                         continue;
1267                 }
1268                 if (snapshot_removal_status == HS_SUCCESS) {
1269                         post_remove_hook();
1270                         continue;
1271                 }
1272                 ret = try_to_free_disk_space();
1273                 if (ret < 0)
1274                         goto out;
1275                 if (snapshot_removal_status != HS_READY) {
1276                         stop_create_process();
1277                         continue;
1278                 }
1279                 restart_create_process();
1280                 switch (snapshot_creation_status) {
1281                 case HS_READY:
1282                         if (!next_snapshot_is_due())
1283                                 continue;
1284                         pre_create_hook();
1285                         continue;
1286                 case HS_PRE_RUNNING:
1287                 case HS_RUNNING:
1288                 case HS_POST_RUNNING:
1289                         continue;
1290                 case HS_PRE_SUCCESS:
1291                         if (!name_of_reference_snapshot) {
1292                                 free_rsync_argv(rsync_argv);
1293                                 create_rsync_argv(&rsync_argv, &current_snapshot_creation_time);
1294                         }
1295                         ret = create_snapshot(rsync_argv);
1296                         if (ret < 0)
1297                                 goto out;
1298                         continue;
1299                 case HS_NEEDS_RESTART:
1300                         if (!next_snapshot_is_due())
1301                                 continue;
1302                         ret = create_snapshot(rsync_argv);
1303                         if (ret < 0)
1304                                 goto out;
1305                         continue;
1306                 case HS_SUCCESS:
1307                         post_create_hook();
1308                         continue;
1309                 }
1310         }
1311 out:
1312         return ret;
1313 }
1314
1315 static void exit_hook(int exit_code)
1316 {
1317         char *argv[3];
1318         pid_t pid;
1319
1320         argv[0] = conf.exit_hook_arg;
1321         argv[1] = dss_strerror(-exit_code);
1322         argv[2] = NULL;
1323
1324         DSS_NOTICE_LOG(("executing %s %s\n", argv[0], argv[1]));
1325         dss_exec(&pid, conf.exit_hook_arg, argv);
1326 }
1327
1328 static void lock_dss_or_die(void)
1329 {
1330         char *config_file = get_config_file_name();
1331         int ret = lock_dss(config_file);
1332
1333         free(config_file);
1334         if (ret < 0) {
1335                 DSS_EMERG_LOG(("failed to lock: %s\n", dss_strerror(-ret)));
1336                 exit(EXIT_FAILURE);
1337         }
1338 }
1339
1340 static int com_run(void)
1341 {
1342         int ret;
1343
1344         lock_dss_or_die();
1345         if (conf.dry_run_given) {
1346                 DSS_ERROR_LOG(("dry_run not supported by this command\n"));
1347                 return -E_SYNTAX;
1348         }
1349         ret = install_sighandler(SIGHUP);
1350         if (ret < 0)
1351                 return ret;
1352         ret = select_loop();
1353         if (ret >= 0) /* impossible */
1354                 ret = -E_BUG;
1355         kill_children();
1356         exit_hook(ret);
1357         return ret;
1358 }
1359
1360 static int com_prune(void)
1361 {
1362         int ret;
1363         struct snapshot_list sl;
1364         struct snapshot *victim;
1365         struct disk_space ds;
1366         const char *why;
1367
1368         lock_dss_or_die();
1369         ret = get_disk_space(".", &ds);
1370         if (ret < 0)
1371                 return ret;
1372         log_disk_space(&ds);
1373         dss_get_snapshot_list(&sl);
1374         why = "outdated";
1375         victim = find_outdated_snapshot(&sl);
1376         if (victim)
1377                 goto rm;
1378         why = "redundant";
1379         victim = find_redundant_snapshot(&sl);
1380         if (victim)
1381                 goto rm;
1382         ret = 0;
1383         goto out;
1384 rm:
1385         if (conf.dry_run_given) {
1386                 dss_msg("%s snapshot %s (interval = %i)\n",
1387                         why, victim->name, victim->interval);
1388                 ret = 0;
1389                 goto out;
1390         }
1391         pre_remove_hook(victim, why);
1392         if (snapshot_removal_status == HS_PRE_RUNNING) {
1393                 ret = wait_for_remove_process();
1394                 if (ret < 0)
1395                         goto out;
1396                 if (snapshot_removal_status != HS_PRE_SUCCESS)
1397                         goto out;
1398         }
1399         ret = exec_rm();
1400         if (ret < 0)
1401                 goto out;
1402         ret = wait_for_remove_process();
1403         if (ret < 0)
1404                 goto out;
1405         if (snapshot_removal_status != HS_SUCCESS)
1406                 goto out;
1407         post_remove_hook();
1408         if (snapshot_removal_status != HS_POST_RUNNING)
1409                 goto out;
1410         ret = wait_for_remove_process();
1411         if (ret < 0)
1412                 goto out;
1413         ret = 1;
1414 out:
1415         free_snapshot_list(&sl);
1416         return ret;
1417 }
1418
1419 static int com_create(void)
1420 {
1421         int ret, status;
1422         char **rsync_argv;
1423
1424         lock_dss_or_die();
1425         if (conf.dry_run_given) {
1426                 int i;
1427                 char *msg = NULL;
1428                 create_rsync_argv(&rsync_argv, &current_snapshot_creation_time);
1429                 for (i = 0; rsync_argv[i]; i++) {
1430                         char *tmp = msg;
1431                         msg = make_message("%s%s%s", tmp? tmp : "",
1432                                 tmp? " " : "", rsync_argv[i]);
1433                         free(tmp);
1434                 }
1435                 free_rsync_argv(rsync_argv);
1436                 dss_msg("%s\n", msg);
1437                 free(msg);
1438                 return 1;
1439         }
1440         pre_create_hook();
1441         if (create_pid) {
1442                 ret = wait_for_process(create_pid, &status);
1443                 if (ret < 0)
1444                         return ret;
1445                 ret = handle_pre_create_hook_exit(status);
1446                 if (ret <= 0) /* error, or pre-create failed */
1447                         return ret;
1448         }
1449         create_rsync_argv(&rsync_argv, &current_snapshot_creation_time);
1450         ret = create_snapshot(rsync_argv);
1451         if (ret < 0)
1452                 goto out;
1453         ret = wait_for_process(create_pid, &status);
1454         if (ret < 0)
1455                 goto out;
1456         ret = handle_rsync_exit(status);
1457         if (ret < 0)
1458                 goto out;
1459         post_create_hook();
1460         if (create_pid)
1461                 ret = wait_for_process(create_pid, &status);
1462 out:
1463         free_rsync_argv(rsync_argv);
1464         return ret;
1465 }
1466
1467 static int com_ls(void)
1468 {
1469         int i;
1470         struct snapshot_list sl;
1471         struct snapshot *s;
1472
1473         dss_get_snapshot_list(&sl);
1474         FOR_EACH_SNAPSHOT(s, i, &sl) {
1475                 int64_t d = 0;
1476                 if (s->flags & SS_COMPLETE)
1477                         d = (s->completion_time - s->creation_time) / 60;
1478                 dss_msg("%u\t%s\t%3" PRId64 ":%02" PRId64 "\n", s->interval, s->name, d/60, d%60);
1479         }
1480         free_snapshot_list(&sl);
1481         return 1;
1482 }
1483
1484 static int setup_signal_handling(void)
1485 {
1486         int ret;
1487
1488         DSS_INFO_LOG(("setting up signal handlers\n"));
1489         signal_pipe = signal_init(); /* always successful */
1490         ret = install_sighandler(SIGINT);
1491         if (ret < 0)
1492                 return ret;
1493         ret = install_sighandler(SIGTERM);
1494         if (ret < 0)
1495                 return ret;
1496         return install_sighandler(SIGCHLD);
1497 }
1498
1499 int main(int argc, char **argv)
1500 {
1501         int ret;
1502         struct cmdline_parser_params params;
1503
1504         params.override = 0;
1505         params.initialize = 1;
1506         params.check_required = 0;
1507         params.check_ambiguity = 0;
1508         params.print_errors = 1;
1509
1510         cmdline_parser_ext(argc, argv, &conf, &params); /* aborts on errors */
1511         ret = parse_config_file(0);
1512         ret = parse_config_file(false /* no SIGHUP */);
1513         if (ret < 0)
1514                 goto out;
1515         if (ret == 0) { /* no config file given */
1516                 /*
1517                  * Parse the command line options again, but this time check
1518                  * that all required options are given.
1519                  */
1520                 params.override = 1;
1521                 params.initialize = 1;
1522                 params.check_required = 1;
1523                 params.check_ambiguity = 1;
1524                 params.print_errors = 1;
1525                 cmdline_parser_ext(argc, argv, &conf, &params); /* aborts on errors */
1526         }
1527         if (conf.daemon_given)
1528                 daemon_init();
1529         ret = change_to_dest_dir();
1530         if (ret < 0)
1531                 goto out;
1532         dump_dss_config("startup");
1533         ret = setup_signal_handling();
1534         if (ret < 0)
1535                 goto out;
1536         ret = call_command_handler();
1537         signal_shutdown();
1538 out:
1539         if (ret < 0)
1540                 DSS_EMERG_LOG(("%s\n", dss_strerror(-ret)));
1541         exit(ret >= 0? EXIT_SUCCESS : EXIT_FAILURE);
1542 }