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 #include <fcntl.h>
  25 #include <lopsub.h>
  26 #include <sys/mman.h>
  27
  28 #include "gcc-compat.h"
  29 #include "log.h"
  30 #include "str.h"
  31 #include "err.h"
  32 #include "file.h"
  33 #include "exec.h"
  34 #include "daemon.h"
  35 #include "sig.h"
  36 #include "df.h"
  37 #include "tv.h"
  38 #include "snap.h"
  39 #include "ipc.h"
  40 #include "dss.lsg.h"
  41
  42 #define CMD_PTR(_cname) lls_cmd(LSG_DSS_CMD_ ## _cname, dss_suite)
  43 #define OPT_RESULT(_cname, _oname) (lls_opt_result(\
  44         LSG_DSS_ ## _cname ## _OPT_ ## _oname, (CMD_PTR(_cname) == CMD_PTR(DSS))? lpr : sublpr))
  45 #define OPT_GIVEN(_cname, _oname) (lls_opt_given(OPT_RESULT(_cname, _oname)))
  46 #define OPT_STRING_VAL(_cname, _oname) (lls_string_val(0, \
  47         OPT_RESULT(_cname, _oname)))
  48 #define OPT_UINT32_VAL(_cname, _oname) (lls_uint32_val(0, \
  49                 OPT_RESULT(_cname, _oname)))
  50
  51 struct dss_user_data {int (*handler)(void);};
  52 #define EXPORT_CMD_HANDLER(_cmd) const struct dss_user_data \
  53         lsg_dss_com_ ## _cmd ## _user_data = { \
  54                 .handler = com_ ## _cmd \
  55         };
  56
  57 /*
  58  * Command line and active options. We need to keep a copy of the parsed
  59  * command line options for the SIGHUP case where we merge the command line
  60  * options and the new config file options.
  61  */
  62 static struct lls_parse_result *cmdline_lpr, *lpr;
  63
  64 /** Parsed subcommand options. */
  65 static struct lls_parse_result *cmdline_sublpr, *sublpr;
  66 /** Wether daemon_init() was called. */
  67 static bool daemonized;
  68 /** Non-NULL if we log to a file. */
  69 static FILE *logfile;
  70 /** The read end of the signal pipe */
  71 static int signal_pipe;
  72 /** Process id of current pre-create-hook/rsync/post-create-hook process. */
  73 static pid_t create_pid;
  74 /** Whether the pre-create-hook/rsync/post-create-hook is currently stopped. */
  75 static int create_process_stopped;
  76 /** How many times in a row the rsync command failed. */
  77 static int num_consecutive_rsync_errors;
  78 /** Process id of current pre-remove/rm/post-remove process. */
  79 static pid_t remove_pid;
  80 /** When the next snapshot is due. */
  81 static int64_t next_snapshot_time;
  82 /** When to try to remove something. */
  83 static struct timeval next_removal_check;
  84 /** Creation time of the snapshot currently being created. */
  85 static int64_t current_snapshot_creation_time;
  86 /** The snapshot currently being removed. */
  87 struct snapshot *snapshot_currently_being_removed;
  88 /** Needed by the post-create hook. */
  89 static char *path_to_last_complete_snapshot;
  90 static char *name_of_reference_snapshot;
  91 /** \sa \ref snap.h for details. */
  92 enum hook_status snapshot_creation_status;
  93 /** \sa \ref snap.h for details. */
  94 enum hook_status snapshot_removal_status;
  95
  96
  97 DEFINE_DSS_ERRLIST;
  98 static const char *hook_status_description[] = {HOOK_STATUS_ARRAY};
  99
 100 /* may be called with ds == NULL. */
 101 static int disk_space_low(struct disk_space *ds)
 102 {
 103         struct disk_space ds_struct;
 104         uint32_t val;
 105
 106         if (!ds) {
 107                 int ret = get_disk_space(".", &ds_struct);
 108                 if (ret < 0)
 109                         return ret;
 110                 ds = &ds_struct;
 111         }
 112         val = OPT_UINT32_VAL(DSS, MIN_FREE_MB);
 113         if (val != 0)
 114                 if (ds->free_mb < val)
 115                         return 1;
 116         val = OPT_UINT32_VAL(DSS, MIN_FREE_PERCENT);
 117         if (val != 0)
 118                 if (ds->percent_free < val)
 119                         return 1;
 120         val = OPT_UINT32_VAL(DSS, MIN_FREE_PERCENT_INODES);
 121         if (val != 0)
 122                 if (ds->percent_free_inodes < val)
 123                         return 1;
 124         return 0;
 125 }
 126
 127 static void dump_dss_config(const char *msg)
 128 {
 129         const char dash[] = "-----------------------------";
 130         char *lopsub_dump;
 131         int ret;
 132         FILE *log = logfile? logfile : stderr;
 133         struct disk_space ds;
 134         int64_t now = get_current_time();
 135
 136         if (OPT_UINT32_VAL(DSS, LOGLEVEL) > INFO)
 137                 return;
 138
 139         fprintf(log, "%s <%s config> %s\n", dash, msg, dash);
 140         fprintf(log, "\n*** disk space ***\n\n");
 141         ret = get_disk_space(".", &ds);
 142         if (ret >= 0) {
 143                 DSS_INFO_LOG(("disk space low: %s\n", disk_space_low(&ds)?
 144                         "yes" : "no"));
 145                 log_disk_space(&ds);
 146         } else
 147                 DSS_ERROR_LOG(("can not get free disk space: %s\n",
 148                         dss_strerror(-ret)));
 149
 150         /* we continue on errors from get_disk_space */
 151
 152         fprintf(log, "\n*** non-default options ***\n\n");
 153         lopsub_dump = lls_dump_parse_result(lpr, CMD_PTR(DSS), true);
 154         fprintf(log, "%s", lopsub_dump);
 155         free(lopsub_dump);
 156         fprintf(log, "\n*** non-default options for \"run\" ***\n\n");
 157         lopsub_dump = lls_dump_parse_result(lpr, CMD_PTR(RUN), true);
 158         fprintf(log, "%s", lopsub_dump);
 159         free(lopsub_dump);
 160         fprintf(log, "\n*** internal state ***\n\n");
 161         fprintf(log,
 162                 "pid: %d\n"
 163                 "logile: %s\n"
 164                 "snapshot_currently_being_removed: %s\n"
 165                 "path_to_last_complete_snapshot: %s\n"
 166                 "reference_snapshot: %s\n"
 167                 "snapshot_creation_status: %s\n"
 168                 "snapshot_removal_status: %s\n"
 169                 "num_consecutive_rsync_errors: %d\n"
 170                 ,
 171                 (int) getpid(),
 172                 logfile? OPT_STRING_VAL(RUN, LOGFILE) : "stderr",
 173                 snapshot_currently_being_removed?
 174                         snapshot_currently_being_removed->name : "(none)",
 175                 path_to_last_complete_snapshot?
 176                         path_to_last_complete_snapshot : "(none)",
 177                 name_of_reference_snapshot?
 178                         name_of_reference_snapshot : "(none)",
 179                 hook_status_description[snapshot_creation_status],
 180                 hook_status_description[snapshot_removal_status],
 181                 num_consecutive_rsync_errors
 182         );
 183         if (create_pid != 0)
 184                 fprintf(log,
 185                         "create_pid: %" PRId32 "\n"
 186                         "create process is %sstopped\n"
 187                         ,
 188                         create_pid,
 189                         create_process_stopped? "" : "not "
 190                 );
 191         if (remove_pid != 0)
 192                 fprintf(log, "remove_pid: %" PRId32 "\n", remove_pid);
 193         if (next_snapshot_time != 0)
 194                 fprintf(log, "next snapshot due in %" PRId64 " seconds\n",
 195                         next_snapshot_time - now);
 196         if (current_snapshot_creation_time != 0)
 197                 fprintf(log, "current_snapshot_creation_time: %"
 198                         PRId64 " (%" PRId64 " seconds ago)\n",
 199                         current_snapshot_creation_time,
 200                         now - current_snapshot_creation_time
 201                 );
 202         if (next_removal_check.tv_sec != 0) {
 203                 fprintf(log, "next removal check: %llu (%llu seconds ago)\n",
 204                         (long long unsigned)next_removal_check.tv_sec,
 205                         now - (long long unsigned)next_removal_check.tv_sec
 206                 );
 207
 208         }
 209         fprintf(log, "%s </%s config> %s\n", dash, msg, dash);
 210 }
 211
 212 static int loglevel = -1;
 213 static const char *location_file = NULL;
 214 static int         location_line = -1;
 215 static const char *location_func = NULL;
 216
 217 void dss_log_set_params(int ll, const char *file, int line, const char *func)
 218 {
 219         loglevel = ll;
 220         location_file = file;
 221         location_line = line;
 222         location_func = func;
 223 }
 224
 225 /**
 226  * The log function of dss.
 227  *
 228  * \param ll Loglevel.
 229  * \param fml Usual format string.
 230  *
 231  * All DSS_XXX_LOG() macros use this function.
 232  */
 233 __printf_1_2 void dss_log(const char* fmt,...)
 234 {
 235         va_list argp;
 236         FILE *outfd;
 237         struct tm *tm;
 238         time_t t1;
 239         char str[255] = "";
 240         int lpr_ll = lpr? OPT_UINT32_VAL(DSS, LOGLEVEL) : WARNING;
 241
 242         if (loglevel < lpr_ll)
 243                 return;
 244         outfd = logfile? logfile : stderr;
 245         time(&t1);
 246         tm = localtime(&t1);
 247         strftime(str, sizeof(str), "%b %d %H:%M:%S", tm);
 248         fprintf(outfd, "%s ", str);
 249         if (lpr_ll <= INFO)
 250                 fprintf(outfd, "%i: ", loglevel);
 251 #ifdef DSS_NO_FUNC_NAMES
 252         fprintf(outfd, "%s:%d: ", location_file, location_line);
 253 #else
 254         fprintf(outfd, "%s: ", location_func);
 255 #endif
 256         va_start(argp, fmt);
 257         vfprintf(outfd, fmt, argp);
 258         va_end(argp);
 259 }
 260
 261 /**
 262  * Print a message either to stdout or to the log file.
 263  */
 264 static __printf_1_2 void dss_msg(const char* fmt,...)
 265 {
 266         FILE *outfd = logfile? logfile : stdout;
 267         va_list argp;
 268         va_start(argp, fmt);
 269         vfprintf(outfd, fmt, argp);
 270         va_end(argp);
 271 }
 272
 273 static char *get_config_file_name(void)
 274 {
 275         char *home, *config_file;
 276
 277         if (OPT_GIVEN(DSS, CONFIG_FILE))
 278                 return dss_strdup(OPT_STRING_VAL(DSS, CONFIG_FILE));
 279         home = get_homedir();
 280         config_file = make_message("%s/.dssrc", home);
 281         free(home);
 282         return config_file;
 283 }
 284
 285 static int send_signal(int sig)
 286 {
 287         pid_t pid;
 288         char *config_file = get_config_file_name();
 289         int ret = get_dss_pid(config_file, &pid);
 290
 291         free(config_file);
 292         if (ret < 0)
 293                 return ret;
 294         if (OPT_GIVEN(DSS, DRY_RUN)) {
 295                 dss_msg("%d\n", (int)pid);
 296                 return 0;
 297         }
 298         ret = kill(pid, sig);
 299         if (ret < 0)
 300                 return -ERRNO_TO_DSS_ERROR(errno);
 301         return 1;
 302 }
 303
 304 struct signal_info {
 305         const char * const name;
 306         int num;
 307 };
 308
 309 /*
 310  * The table below was taken 2016 from proc/sig.c of procps-3.2.8. Copyright
 311  * 1998-2003 by Albert Cahalan, GPLv2.
 312  */
 313 static const struct signal_info signal_table[] = {
 314         {"ABRT",   SIGABRT},  /* IOT */
 315         {"ALRM",   SIGALRM},
 316         {"BUS",    SIGBUS},
 317         {"CHLD",   SIGCHLD},  /* CLD */
 318         {"CONT",   SIGCONT},
 319         {"FPE",    SIGFPE},
 320         {"HUP",    SIGHUP},
 321         {"ILL",    SIGILL},
 322         {"INT",    SIGINT},
 323         {"KILL",   SIGKILL},
 324         {"PIPE",   SIGPIPE},
 325 #ifdef SIGPOLL
 326         {"POLL",   SIGPOLL},  /* IO */
 327 #endif
 328         {"PROF",   SIGPROF},
 329 #ifdef SIGPWR
 330         {"PWR",    SIGPWR},
 331 #endif
 332         {"QUIT",   SIGQUIT},
 333         {"SEGV",   SIGSEGV},
 334 #ifdef SIGSTKFLT
 335         {"STKFLT", SIGSTKFLT},
 336 #endif
 337         {"STOP",   SIGSTOP},
 338         {"SYS",    SIGSYS},   /* UNUSED */
 339         {"TERM",   SIGTERM},
 340         {"TRAP",   SIGTRAP},
 341         {"TSTP",   SIGTSTP},
 342         {"TTIN",   SIGTTIN},
 343         {"TTOU",   SIGTTOU},
 344         {"URG",    SIGURG},
 345         {"USR1",   SIGUSR1},
 346         {"USR2",   SIGUSR2},
 347         {"VTALRM", SIGVTALRM},
 348         {"WINCH",  SIGWINCH},
 349         {"XCPU",   SIGXCPU},
 350         {"XFSZ",   SIGXFSZ}
 351 };
 352
 353 #define SIGNAL_TABLE_SIZE (sizeof(signal_table) / sizeof(signal_table[0]))
 354 #ifndef SIGRTMAX
 355 #define SIGRTMAX 64
 356 #endif
 357
 358 static int com_kill(void)
 359 {
 360         const char *arg = OPT_STRING_VAL(KILL, SIGNAL);
 361         int ret, i;
 362
 363         if (*arg >= '0' && *arg <= '9') {
 364                 int64_t val;
 365                 ret = dss_atoi64(arg, &val);
 366                 if (ret < 0)
 367                         return ret;
 368                 if (val < 0 || val > SIGRTMAX)
 369                         return -ERRNO_TO_DSS_ERROR(EINVAL);
 370                 return send_signal(val);
 371         }
 372         if (strncasecmp(arg, "sig", 3) == 0)
 373                 arg += 3;
 374         if (strcasecmp(arg, "CLD") == 0)
 375                 return send_signal(SIGCHLD);
 376         if (strcasecmp(arg, "IOT") == 0)
 377                 return send_signal(SIGABRT);
 378         for (i = 0; i < SIGNAL_TABLE_SIZE; i++)
 379                 if (strcasecmp(arg, signal_table[i].name) == 0)
 380                         return send_signal(signal_table[i].num);
 381         DSS_ERROR_LOG(("invalid sigspec: %s\n", arg));
 382         return -ERRNO_TO_DSS_ERROR(EINVAL);
 383 }
 384 EXPORT_CMD_HANDLER(kill);
 385
 386 static void dss_get_snapshot_list(struct snapshot_list *sl)
 387 {
 388         get_snapshot_list(sl, OPT_UINT32_VAL(DSS, UNIT_INTERVAL),
 389                 OPT_UINT32_VAL(DSS, NUM_INTERVALS));
 390 }
 391
 392 static int64_t compute_next_snapshot_time(void)
 393 {
 394         int64_t x = 0, now = get_current_time(), unit_interval
 395                 = 24 * 3600 * OPT_UINT32_VAL(DSS, UNIT_INTERVAL), ret;
 396         unsigned wanted = desired_number_of_snapshots(0,
 397                 OPT_UINT32_VAL(DSS, NUM_INTERVALS)),
 398                 num_complete = 0;
 399         int i;
 400         struct snapshot *s = NULL;
 401         struct snapshot_list sl;
 402
 403         dss_get_snapshot_list(&sl);
 404         FOR_EACH_SNAPSHOT(s, i, &sl) {
 405                 if (!(s->flags & SS_COMPLETE))
 406                         continue;
 407                 num_complete++;
 408                 x += s->completion_time - s->creation_time;
 409         }
 410         assert(x >= 0);
 411
 412         ret = now;
 413         if (num_complete == 0)
 414                 goto out;
 415         x /= num_complete; /* avg time to create one snapshot */
 416         if (unit_interval < x * wanted) /* oops, no sleep at all */
 417                 goto out;
 418         ret = s->completion_time + unit_interval / wanted - x;
 419 out:
 420         free_snapshot_list(&sl);
 421         return ret;
 422 }
 423
 424 static inline void invalidate_next_snapshot_time(void)
 425 {
 426         next_snapshot_time = 0;
 427 }
 428
 429 static inline int next_snapshot_time_is_valid(void)
 430 {
 431         return next_snapshot_time != 0;
 432 }
 433
 434 static int next_snapshot_is_due(void)
 435 {
 436         int64_t now = get_current_time();
 437
 438         if (!next_snapshot_time_is_valid())
 439                 next_snapshot_time = compute_next_snapshot_time();
 440         if (next_snapshot_time <= now) {
 441                 DSS_DEBUG_LOG(("next snapshot: now\n"));
 442                 return 1;
 443         }
 444         DSS_DEBUG_LOG(("next snapshot due in %" PRId64 " seconds\n",
 445                 next_snapshot_time - now));
 446         return 0;
 447 }
 448
 449 static void pre_create_hook(void)
 450 {
 451         assert(snapshot_creation_status == HS_READY);
 452         /* make sure that the next snapshot time will be recomputed */
 453         invalidate_next_snapshot_time();
 454         DSS_DEBUG_LOG(("executing %s\n", OPT_STRING_VAL(DSS, PRE_CREATE_HOOK)));
 455         dss_exec_cmdline_pid(&create_pid, OPT_STRING_VAL(DSS, PRE_CREATE_HOOK));
 456         snapshot_creation_status = HS_PRE_RUNNING;
 457 }
 458
 459 static void pre_remove_hook(struct snapshot *s, const char *why)
 460 {
 461         char *cmd;
 462
 463         if (!s)
 464                 return;
 465         DSS_DEBUG_LOG(("%s snapshot %s\n", why, s->name));
 466         assert(snapshot_removal_status == HS_READY);
 467         assert(remove_pid == 0);
 468         assert(!snapshot_currently_being_removed);
 469
 470         snapshot_currently_being_removed = dss_malloc(sizeof(struct snapshot));
 471         *snapshot_currently_being_removed = *s;
 472         snapshot_currently_being_removed->name = dss_strdup(s->name);
 473
 474         cmd = make_message("%s %s/%s", OPT_STRING_VAL(DSS, PRE_REMOVE_HOOK),
 475                 OPT_STRING_VAL(DSS, DEST_DIR), s->name);
 476         DSS_DEBUG_LOG(("executing %s\n", cmd));
 477         dss_exec_cmdline_pid(&remove_pid, cmd);
 478         free(cmd);
 479         snapshot_removal_status = HS_PRE_RUNNING;
 480 }
 481
 482 static int exec_rm(void)
 483 {
 484         struct snapshot *s = snapshot_currently_being_removed;
 485         char *new_name = being_deleted_name(s);
 486         char *argv[4];
 487         int ret;
 488
 489         argv[0] = "rm";
 490         argv[1] = "-rf";
 491         argv[2] = new_name;
 492         argv[3] = NULL;
 493
 494         assert(snapshot_removal_status == HS_PRE_SUCCESS);
 495         assert(remove_pid == 0);
 496
 497         DSS_NOTICE_LOG(("removing %s (interval = %i)\n", s->name, s->interval));
 498         ret = dss_rename(s->name, new_name);
 499         if (ret < 0)
 500                 goto out;
 501         dss_exec(&remove_pid, argv[0], argv);
 502         snapshot_removal_status = HS_RUNNING;
 503 out:
 504         free(new_name);
 505         return ret;
 506 }
 507
 508 static int snapshot_is_being_created(struct snapshot *s)
 509 {
 510         return s->creation_time == current_snapshot_creation_time;
 511 }
 512
 513 static struct snapshot *find_orphaned_snapshot(struct snapshot_list *sl)
 514 {
 515         struct snapshot *s;
 516         int i;
 517
 518         DSS_DEBUG_LOG(("looking for orphaned snapshots\n"));
 519         FOR_EACH_SNAPSHOT(s, i, sl) {
 520                 if (snapshot_is_being_created(s))
 521                         continue;
 522                 /*
 523                  * We know that no rm is currently running, so if s is marked
 524                  * as being deleted, a previously started rm must have failed.
 525                  */
 526                 if (s->flags & SS_BEING_DELETED)
 527                         return s;
 528
 529                 if (s->flags & SS_COMPLETE) /* good snapshot */
 530                         continue;
 531                 /*
 532                  * This snapshot is incomplete and it is not the snapshot
 533                  * currently being created. However, we must not remove it if
 534                  * rsync is about to be restarted. As only the newest snapshot
 535                  * can be restarted, this snapshot is orphaned if it is not the
 536                  * newest snapshot or if we are not about to restart rsync.
 537                  */
 538                 if (get_newest_snapshot(sl) != s)
 539                         return s;
 540                 if (snapshot_creation_status != HS_NEEDS_RESTART)
 541                         return s;
 542         }
 543         /* no orphaned snapshots */
 544         return NULL;
 545 }
 546
 547 static int is_reference_snapshot(struct snapshot *s)
 548 {
 549         if (!name_of_reference_snapshot)
 550                 return 0;
 551         return strcmp(s->name, name_of_reference_snapshot)? 0 : 1;
 552 }
 553
 554 /*
 555  * return: 0: no redundant snapshots, 1: rm process started, negative: error
 556  */
 557 static struct snapshot *find_redundant_snapshot(struct snapshot_list *sl)
 558 {
 559         int i, interval;
 560         struct snapshot *s;
 561         unsigned missing = 0;
 562         uint32_t N = OPT_UINT32_VAL(DSS, NUM_INTERVALS);
 563
 564         DSS_DEBUG_LOG(("looking for intervals containing too many snapshots\n"));
 565         for (interval = N - 1; interval >= 0; interval--) {
 566                 unsigned keep = desired_number_of_snapshots(interval, N);
 567                 unsigned num = sl->interval_count[interval];
 568                 struct snapshot *victim = NULL, *prev = NULL;
 569                 int64_t score = LONG_MAX;
 570
 571                 if (keep >= num)
 572                         missing += keep - num;
 573                 if (keep + missing >= num)
 574                         continue;
 575                 /* redundant snapshot in this interval, pick snapshot with lowest score */
 576                 FOR_EACH_SNAPSHOT(s, i, sl) {
 577                         int64_t this_score;
 578
 579                         if (snapshot_is_being_created(s))
 580                                 continue;
 581                         if (is_reference_snapshot(s))
 582                                 continue;
 583                         if (s->interval > interval) {
 584                                 prev = s;
 585                                 continue;
 586                         }
 587                         if (s->interval < interval)
 588                                 break;
 589                         if (!victim) {
 590                                 victim = s;
 591                                 prev = s;
 592                                 continue;
 593                         }
 594                         assert(prev);
 595                         /* check if s is a better victim */
 596                         this_score = s->creation_time - prev->creation_time;
 597                         assert(this_score >= 0);
 598                         if (this_score < score) {
 599                                 score = this_score;
 600                                 victim = s;
 601                         }
 602                         prev = s;
 603                 }
 604                 assert(victim);
 605                 return victim;
 606         }
 607         return NULL;
 608 }
 609
 610 static struct snapshot *find_outdated_snapshot(struct snapshot_list *sl)
 611 {
 612         int i;
 613         struct snapshot *s;
 614
 615         DSS_DEBUG_LOG(("looking for snapshots belonging to intervals >= %d\n",
 616                 OPT_UINT32_VAL(DSS, NUM_INTERVALS)));
 617         FOR_EACH_SNAPSHOT(s, i, sl) {
 618                 if (snapshot_is_being_created(s))
 619                         continue;
 620                 if (is_reference_snapshot(s))
 621                         continue;
 622                 if (s->interval < OPT_UINT32_VAL(DSS, NUM_INTERVALS))
 623                         continue;
 624                 return s;
 625         }
 626         return NULL;
 627 }
 628
 629 static struct snapshot *find_oldest_removable_snapshot(struct snapshot_list *sl)
 630 {
 631         int i, num_complete;
 632         struct snapshot *s, *ref = NULL;
 633
 634         num_complete = num_complete_snapshots(sl);
 635         if (num_complete <= OPT_UINT32_VAL(DSS, MIN_COMPLETE))
 636                 return NULL;
 637         FOR_EACH_SNAPSHOT(s, i, sl) {
 638                 if (snapshot_is_being_created(s))
 639                         continue;
 640                 if (is_reference_snapshot(s)) { /* avoid this one */
 641                         ref = s;
 642                         continue;
 643                 }
 644                 DSS_INFO_LOG(("oldest removable snapshot: %s\n", s->name));
 645                 return s;
 646         }
 647         assert(ref);
 648         DSS_WARNING_LOG(("removing reference snapshot %s\n", ref->name));
 649         return ref;
 650 }
 651
 652 static int rename_incomplete_snapshot(int64_t start)
 653 {
 654         char *old_name;
 655         int ret;
 656         int64_t now;
 657
 658         /*
 659          * We don't want the dss_rename() below to fail with EEXIST because the
 660          * last complete snapshot was created (and completed) in the same
 661          * second as this one.
 662          */
 663         while ((now = get_current_time()) == start)
 664                 sleep(1);
 665         free(path_to_last_complete_snapshot);
 666         ret = complete_name(start, now, &path_to_last_complete_snapshot);
 667         if (ret < 0)
 668                 return ret;
 669         old_name = incomplete_name(start);
 670         ret = dss_rename(old_name, path_to_last_complete_snapshot);
 671         if (ret >= 0)
 672                 DSS_NOTICE_LOG(("%s -> %s\n", old_name,
 673                         path_to_last_complete_snapshot));
 674         free(old_name);
 675         return ret;
 676 }
 677
 678 static int try_to_free_disk_space(void)
 679 {
 680         int ret;
 681         struct snapshot_list sl;
 682         struct snapshot *victim;
 683         struct timeval now;
 684         const char *why;
 685         int low_disk_space;
 686
 687         ret = disk_space_low(NULL);
 688         if (ret < 0)
 689                 return ret;
 690         low_disk_space = ret;
 691         gettimeofday(&now, NULL);
 692         if (tv_diff(&next_removal_check, &now, NULL) > 0)
 693                 return 0;
 694         if (!low_disk_space) {
 695                 if (OPT_GIVEN(DSS, KEEP_REDUNDANT))
 696                         return 0;
 697                 if (snapshot_creation_status != HS_READY)
 698                         return 0;
 699                 if (next_snapshot_is_due())
 700                         return 0;
 701         }
 702         /*
 703          * Idle and --keep_redundant not given, or low disk space. Look at
 704          * existing snapshots.
 705          */
 706         dss_get_snapshot_list(&sl);
 707         ret = 0;
 708         /*
 709          * Don't remove anything if there is free space and we have fewer
 710          * snapshots than configured, plus one. This way there is always one
 711          * snapshot that can be recycled.
 712          */
 713         if (!low_disk_space && sl.num_snapshots <=
 714                         1 << OPT_UINT32_VAL(DSS, NUM_INTERVALS))
 715                 goto out;
 716         why = "outdated";
 717         victim = find_outdated_snapshot(&sl);
 718         if (victim)
 719                 goto remove;
 720         why = "redundant";
 721         victim = find_redundant_snapshot(&sl);
 722         if (victim)
 723                 goto remove;
 724         why = "orphaned";
 725         victim = find_orphaned_snapshot(&sl);
 726         if (victim)
 727                 goto remove;
 728         /* try harder only if disk space is low */
 729         if (!low_disk_space)
 730                 goto out;
 731         DSS_WARNING_LOG(("disk space low and nothing obvious to remove\n"));
 732         why = "oldest";
 733         victim = find_oldest_removable_snapshot(&sl);
 734         if (victim)
 735                 goto remove;
 736         DSS_CRIT_LOG(("uhuhu: disk space low and nothing to remove\n"));
 737         ret = -ERRNO_TO_DSS_ERROR(ENOSPC);
 738         goto out;
 739 remove:
 740         pre_remove_hook(victim, why);
 741 out:
 742         free_snapshot_list(&sl);
 743         return ret;
 744 }
 745
 746 static void post_create_hook(void)
 747 {
 748         char *cmd = make_message("%s %s/%s",
 749                 OPT_STRING_VAL(DSS, POST_CREATE_HOOK),
 750                 OPT_STRING_VAL(DSS, DEST_DIR), path_to_last_complete_snapshot);
 751         DSS_NOTICE_LOG(("executing %s\n", cmd));
 752         dss_exec_cmdline_pid(&create_pid, cmd);
 753         free(cmd);
 754         snapshot_creation_status = HS_POST_RUNNING;
 755 }
 756
 757 static void post_remove_hook(void)
 758 {
 759         char *cmd;
 760         struct snapshot *s = snapshot_currently_being_removed;
 761
 762         assert(s);
 763
 764         cmd = make_message("%s %s/%s", OPT_STRING_VAL(DSS, POST_REMOVE_HOOK),
 765                 OPT_STRING_VAL(DSS, DEST_DIR), s->name);
 766         DSS_NOTICE_LOG(("executing %s\n", cmd));
 767         dss_exec_cmdline_pid(&remove_pid, cmd);
 768         free(cmd);
 769         snapshot_removal_status = HS_POST_RUNNING;
 770 }
 771
 772 static void dss_kill(pid_t pid, int sig, const char *msg)
 773 {
 774         const char *signame, *process_name;
 775
 776         if (pid == 0)
 777                 return;
 778         switch (sig) {
 779         case SIGTERM: signame = "TERM"; break;
 780         case SIGSTOP: signame = "STOP"; break;
 781         case SIGCONT: signame = "CONT"; break;
 782         default: signame = "????";
 783         }
 784
 785         if (pid == create_pid)
 786                 process_name = "create";
 787         else if (pid == remove_pid)
 788                 process_name = "remove";
 789         else process_name = "??????";
 790
 791         if (msg)
 792                 DSS_INFO_LOG(("%s\n", msg));
 793         DSS_DEBUG_LOG(("sending signal %d (%s) to pid %d (%s process)\n",
 794                 sig, signame, (int)pid, process_name));
 795         if (kill(pid, sig) >= 0)
 796                 return;
 797         DSS_INFO_LOG(("failed to send signal %d (%s) to pid %d (%s process)\n",
 798                 sig, signame, (int)pid, process_name));
 799 }
 800
 801 static void stop_create_process(void)
 802 {
 803         if (create_process_stopped)
 804                 return;
 805         dss_kill(create_pid, SIGSTOP, "suspending create process");
 806         create_process_stopped = 1;
 807 }
 808
 809 static void restart_create_process(void)
 810 {
 811         if (!create_process_stopped)
 812                 return;
 813         dss_kill(create_pid, SIGCONT, "resuming create process");
 814         create_process_stopped = 0;
 815 }
 816
 817 /**
 818  * Print a log message about the exit status of a child.
 819  */
 820 static void log_termination_msg(pid_t pid, int status)
 821 {
 822         if (WIFEXITED(status))
 823                 DSS_INFO_LOG(("child %i exited. Exit status: %i\n", (int)pid,
 824                         WEXITSTATUS(status)));
 825         else if (WIFSIGNALED(status))
 826                 DSS_NOTICE_LOG(("child %i was killed by signal %i\n", (int)pid,
 827                         WTERMSIG(status)));
 828         else
 829                 DSS_WARNING_LOG(("child %i terminated abormally\n", (int)pid));
 830 }
 831
 832 static int wait_for_process(pid_t pid, int *status)
 833 {
 834         int ret;
 835
 836         DSS_DEBUG_LOG(("Waiting for process %d to terminate\n", (int)pid));
 837         for (;;) {
 838                 fd_set rfds;
 839
 840                 FD_ZERO(&rfds);
 841                 FD_SET(signal_pipe, &rfds);
 842                 ret = dss_select(signal_pipe + 1, &rfds, NULL, NULL);
 843                 if (ret < 0)
 844                         break;
 845                 ret = next_signal();
 846                 if (!ret)
 847                         continue;
 848                 if (ret == SIGCHLD) {
 849                         ret = waitpid(pid, status, 0);
 850                         if (ret >= 0)
 851                                 break;
 852                         if (errno != EINTR) { /* error */
 853                                 ret = -ERRNO_TO_DSS_ERROR(errno);
 854                                 break;
 855                         }
 856                 }
 857                 /* SIGINT or SIGTERM */
 858                 dss_kill(pid, SIGTERM, "killing child process");
 859         }
 860         if (ret < 0)
 861                 DSS_ERROR_LOG(("failed to wait for process %d\n", (int)pid));
 862         else
 863                 log_termination_msg(pid, *status);
 864         return ret;
 865 }
 866
 867 static void handle_pre_remove_exit(int status)
 868 {
 869         if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
 870                 snapshot_removal_status = HS_READY;
 871                 gettimeofday(&next_removal_check, NULL);
 872                 next_removal_check.tv_sec += 60;
 873                 return;
 874         }
 875         snapshot_removal_status = HS_PRE_SUCCESS;
 876 }
 877
 878 static int handle_rm_exit(int status)
 879 {
 880         if (!WIFEXITED(status)) {
 881                 snapshot_removal_status = HS_READY;
 882                 return -E_INVOLUNTARY_EXIT;
 883         }
 884         if (WEXITSTATUS(status)) {
 885                 snapshot_removal_status = HS_READY;
 886                 return -E_BAD_EXIT_CODE;
 887         }
 888         snapshot_removal_status = HS_SUCCESS;
 889         return 1;
 890 }
 891
 892 static void handle_post_remove_exit(void)
 893 {
 894         snapshot_removal_status = HS_READY;
 895 }
 896
 897 static int handle_remove_exit(int status)
 898 {
 899         int ret;
 900         struct snapshot *s = snapshot_currently_being_removed;
 901
 902         assert(s);
 903         switch (snapshot_removal_status) {
 904         case HS_PRE_RUNNING:
 905                 handle_pre_remove_exit(status);
 906                 ret = 1;
 907                 break;
 908         case HS_RUNNING:
 909                 ret = handle_rm_exit(status);
 910                 break;
 911         case HS_POST_RUNNING:
 912                 handle_post_remove_exit();
 913                 ret = 1;
 914                 break;
 915         default:
 916                 ret = -E_BUG;
 917         }
 918         if (snapshot_removal_status == HS_READY) {
 919                 free(s->name);
 920                 free(s);
 921                 snapshot_currently_being_removed = NULL;
 922         }
 923         remove_pid = 0;
 924         return ret;
 925 }
 926
 927 static int wait_for_remove_process(void)
 928 {
 929         int status, ret;
 930
 931         assert(remove_pid);
 932         assert(
 933                 snapshot_removal_status == HS_PRE_RUNNING ||
 934                 snapshot_removal_status == HS_RUNNING ||
 935                 snapshot_removal_status == HS_POST_RUNNING
 936         );
 937         ret = wait_for_process(remove_pid, &status);
 938         if (ret < 0)
 939                 return ret;
 940         return handle_remove_exit(status);
 941 }
 942
 943 static int handle_rsync_exit(int status)
 944 {
 945         int es, ret;
 946
 947         if (!WIFEXITED(status)) {
 948                 DSS_ERROR_LOG(("rsync process %d died involuntary\n", (int)create_pid));
 949                 ret = -E_INVOLUNTARY_EXIT;
 950                 snapshot_creation_status = HS_READY;
 951                 goto out;
 952         }
 953         es = WEXITSTATUS(status);
 954         /*
 955          * Restart rsync on non-fatal errors:
 956          * 24: Partial transfer due to vanished source files
 957          */
 958         if (es != 0 && es != 24) {
 959                 DSS_WARNING_LOG(("rsync exit code %d, error count %d\n",
 960                         es, ++num_consecutive_rsync_errors));
 961                 if (!logfile) { /* called by com_run() */
 962                         ret = -E_BAD_EXIT_CODE;
 963                         goto out;
 964                 }
 965                 if (num_consecutive_rsync_errors >
 966                                 OPT_UINT32_VAL(RUN, MAX_RSYNC_ERRORS)) {
 967                         ret = -E_TOO_MANY_RSYNC_ERRORS;
 968                         snapshot_creation_status = HS_READY;
 969                         goto out;
 970                 }
 971                 DSS_WARNING_LOG(("restarting rsync process\n"));
 972                 snapshot_creation_status = HS_NEEDS_RESTART;
 973                 next_snapshot_time = get_current_time() + 60;
 974                 ret = 1;
 975                 goto out;
 976         }
 977         num_consecutive_rsync_errors = 0;
 978         ret = rename_incomplete_snapshot(current_snapshot_creation_time);
 979         if (ret < 0)
 980                 goto out;
 981         snapshot_creation_status = HS_SUCCESS;
 982         free(name_of_reference_snapshot);
 983         name_of_reference_snapshot = NULL;
 984 out:
 985         create_process_stopped = 0;
 986         return ret;
 987 }
 988
 989 static int handle_pre_create_hook_exit(int status)
 990 {
 991         int es, ret;
 992         static int warn_count;
 993
 994         if (!WIFEXITED(status)) {
 995                 snapshot_creation_status = HS_READY;
 996                 ret = -E_INVOLUNTARY_EXIT;
 997                 goto out;
 998         }
 999         es = WEXITSTATUS(status);
1000         if (es) {
1001                 if (!warn_count--) {
1002                         DSS_NOTICE_LOG(("pre_create_hook %s returned %d\n",
1003                                 OPT_STRING_VAL(DSS, PRE_CREATE_HOOK), es));
1004                         DSS_NOTICE_LOG(("deferring snapshot creation...\n"));
1005                         warn_count = 60; /* warn only once per hour */
1006                 }
1007                 next_snapshot_time = get_current_time() + 60;
1008                 snapshot_creation_status = HS_READY;
1009                 ret = 0;
1010                 goto out;
1011         }
1012         warn_count = 0;
1013         snapshot_creation_status = HS_PRE_SUCCESS;
1014         ret = 1;
1015 out:
1016         return ret;
1017 }
1018
1019 static int handle_sigchld(void)
1020 {
1021         pid_t pid;
1022         int status, ret = reap_child(&pid, &status);
1023
1024         if (ret <= 0)
1025                 return ret;
1026
1027         if (pid == create_pid) {
1028                 switch (snapshot_creation_status) {
1029                 case HS_PRE_RUNNING:
1030                         ret = handle_pre_create_hook_exit(status);
1031                         break;
1032                 case HS_RUNNING:
1033                         ret = handle_rsync_exit(status);
1034                         break;
1035                 case HS_POST_RUNNING:
1036                         snapshot_creation_status = HS_READY;
1037                         ret = 1;
1038                         break;
1039                 default:
1040                         DSS_EMERG_LOG(("BUG: create can't die in status %d\n",
1041                                 snapshot_creation_status));
1042                         return -E_BUG;
1043                 }
1044                 create_pid = 0;
1045                 return ret;
1046         }
1047         if (pid == remove_pid) {
1048                 ret = handle_remove_exit(status);
1049                 if (ret < 0)
1050                         return ret;
1051                 return ret;
1052         }
1053         DSS_EMERG_LOG(("BUG: unknown process %d died\n", (int)pid));
1054         return -E_BUG;
1055 }
1056
1057 static int change_to_dest_dir(void)
1058 {
1059         int ret;
1060         const char *dd = OPT_STRING_VAL(DSS, DEST_DIR);
1061
1062         DSS_INFO_LOG(("changing cwd to %s\n", dd));
1063         if (chdir(dd) >= 0)
1064                 return 1;
1065         ret = -ERRNO_TO_DSS_ERROR(errno);
1066         DSS_ERROR_LOG(("could not change cwd to %s\n", dd));
1067         return ret;
1068 }
1069
1070 static int check_config(const struct lls_command *cmd)
1071 {
1072         int ret;
1073         uint32_t unit_interval = OPT_UINT32_VAL(DSS, UNIT_INTERVAL);
1074         uint32_t num_intervals = OPT_UINT32_VAL(DSS, NUM_INTERVALS);
1075
1076         if (unit_interval == 0) {
1077                 DSS_ERROR_LOG(("bad unit interval: %i\n", unit_interval));
1078                 return -E_INVALID_NUMBER;
1079         }
1080         DSS_DEBUG_LOG(("unit interval: %i day(s)\n", unit_interval));
1081
1082         if (num_intervals == 0 || num_intervals > 30) {
1083                 DSS_ERROR_LOG(("bad number of intervals: %i\n", num_intervals));
1084                 return -E_INVALID_NUMBER;
1085         }
1086         if (cmd == CMD_PTR(RUN) || cmd == CMD_PTR(CREATE))
1087                 if (!OPT_GIVEN(DSS, SOURCE_DIR)) {
1088                         DSS_ERROR_LOG(("--source-dir required\n"));
1089                         return -E_SYNTAX;
1090                 }
1091         if (cmd == CMD_PTR(RUN) || cmd == CMD_PTR(CREATE)
1092                         || cmd == CMD_PTR(LS) || cmd == CMD_PTR(PRUNE)) {
1093                 if (!OPT_GIVEN(DSS, DEST_DIR)) {
1094                         DSS_ERROR_LOG(("--dest-dir required\n"));
1095                         return -E_SYNTAX;
1096                 }
1097                 ret = change_to_dest_dir();
1098                 if (ret < 0)
1099                         return ret;
1100         }
1101         DSS_DEBUG_LOG(("number of intervals: %i\n", num_intervals));
1102         return 1;
1103 }
1104
1105 static int lopsub_error(int lopsub_ret, char **errctx)
1106 {
1107         const char *msg = lls_strerror(-lopsub_ret);
1108         if (*errctx)
1109                 DSS_ERROR_LOG(("%s: %s\n", *errctx, msg));
1110         else
1111                 DSS_ERROR_LOG(("%s\n", msg));
1112         free(*errctx);
1113         *errctx = NULL;
1114         return -E_LOPSUB;
1115 }
1116
1117 static int parse_config_file(bool sighup, const struct lls_command *cmd)
1118 {
1119         int ret, fd = -1;
1120         char *config_file = get_config_file_name();
1121         struct stat statbuf;
1122         void *map;
1123         size_t sz;
1124         int cf_argc;
1125         char **cf_argv, *errctx = NULL;
1126         struct lls_parse_result *cf_lpr, *merged_lpr, *clpr;
1127         const char *subcmd_name;
1128
1129         ret = open(config_file, O_RDONLY);
1130         if (ret < 0) {
1131                 if (errno != ENOENT || OPT_GIVEN(DSS, CONFIG_FILE)) {
1132                         ret = -ERRNO_TO_DSS_ERROR(errno);
1133                         DSS_ERROR_LOG(("config file %s can not be opened\n",
1134                                 config_file));
1135                         goto out;
1136                 }
1137                 /* no config file -- nothing to do */
1138                 ret = 0;
1139                 goto success;
1140         }
1141         fd = ret;
1142         ret = fstat(fd, &statbuf);
1143         if (ret < 0) {
1144                 ret = -ERRNO_TO_DSS_ERROR(errno);
1145                 DSS_ERROR_LOG(("failed to stat config file %s\n", config_file));
1146                 goto close_fd;
1147         }
1148         sz = statbuf.st_size;
1149         if (sz == 0) { /* config file is empty -- nothing to do */
1150                 ret = 0;
1151                 goto success;
1152         }
1153         map = mmap(NULL, sz, PROT_READ, MAP_PRIVATE, fd, 0);
1154         if (map == MAP_FAILED) {
1155                 ret = -ERRNO_TO_DSS_ERROR(errno);
1156                 DSS_ERROR_LOG(("failed to mmap config file %s\n",
1157                         config_file));
1158                 goto close_fd;
1159         }
1160         if (cmd == CMD_PTR(DSS))
1161                 subcmd_name = NULL;
1162         else
1163                 subcmd_name = lls_command_name(cmd);
1164         ret = lls_convert_config(map, sz, subcmd_name, &cf_argv, &errctx);
1165         munmap(map, sz);
1166         if (ret < 0) {
1167                 DSS_ERROR_LOG(("failed to convert config file %s\n",
1168                         config_file));
1169                 ret = lopsub_error(ret, &errctx);
1170                 goto close_fd;
1171         }
1172         cf_argc = ret;
1173         ret = lls_parse(cf_argc, cf_argv, cmd, &cf_lpr, &errctx);
1174         lls_free_argv(cf_argv);
1175         if (ret < 0) {
1176                 ret = lopsub_error(ret, &errctx);
1177                 goto close_fd;
1178         }
1179         clpr = cmd == CMD_PTR(DSS)? cmdline_lpr : cmdline_sublpr;
1180         if (sighup) /* config file overrides command line */
1181                 ret = lls_merge(cf_lpr, clpr, cmd, &merged_lpr, &errctx);
1182         else /* command line options overrride config file options */
1183                 ret = lls_merge(clpr, cf_lpr, cmd, &merged_lpr, &errctx);
1184         lls_free_parse_result(cf_lpr, cmd);
1185         if (ret < 0) {
1186                 ret = lopsub_error(ret, &errctx);
1187                 goto close_fd;
1188         }
1189         ret = 1;
1190 success:
1191         assert(ret >= 0);
1192         DSS_DEBUG_LOG(("loglevel: %d\n", OPT_UINT32_VAL(DSS, LOGLEVEL)));
1193         if (cmd != CMD_PTR(DSS)) {
1194                 if (ret > 0) {
1195                         if (sublpr != cmdline_sublpr)
1196                                 lls_free_parse_result(sublpr, cmd);
1197                         sublpr = merged_lpr;
1198                 } else
1199                         sublpr = cmdline_sublpr;
1200         } else {
1201                 if (ret > 0) {
1202                         if (lpr != cmdline_lpr)
1203                                 lls_free_parse_result(lpr, cmd);
1204                         lpr = merged_lpr;
1205                 } else
1206                         lpr = cmdline_lpr;
1207         }
1208 close_fd:
1209         if (fd >= 0)
1210                 close(fd);
1211 out:
1212         free(config_file);
1213         if (ret < 0)
1214                 DSS_EMERG_LOG(("%s\n", dss_strerror(-ret)));
1215         return ret;
1216 }
1217
1218 static int handle_sighup(void)
1219 {
1220         int ret;
1221
1222         DSS_NOTICE_LOG(("SIGHUP, re-reading config\n"));
1223         dump_dss_config("old");
1224         ret = parse_config_file(true /* SIGHUP */, CMD_PTR(DSS));
1225         if (ret < 0)
1226                 return ret;
1227         ret = parse_config_file(true /* SIGHUP */, CMD_PTR(RUN));
1228         if (ret < 0)
1229                 return ret;
1230         ret = check_config(CMD_PTR(RUN));
1231         if (ret < 0)
1232                 return ret;
1233         close_log(logfile);
1234         logfile = NULL;
1235         if (OPT_GIVEN(RUN, DAEMON) || daemonized) {
1236                 logfile = open_log(OPT_STRING_VAL(RUN, LOGFILE));
1237                 log_welcome(OPT_UINT32_VAL(DSS, LOGLEVEL));
1238                 daemonized = true;
1239         }
1240         dump_dss_config("reloaded");
1241         invalidate_next_snapshot_time();
1242         return 1;
1243 }
1244
1245 static void kill_children(void)
1246 {
1247         restart_create_process();
1248         dss_kill(create_pid, SIGTERM, NULL);
1249         dss_kill(remove_pid, SIGTERM, NULL);
1250 }
1251
1252 static int handle_signal(void)
1253 {
1254         int sig, ret = next_signal();
1255
1256         if (ret <= 0)
1257                 goto out;
1258         sig = ret;
1259         switch (sig) {
1260         case SIGINT:
1261         case SIGTERM:
1262                 kill_children();
1263                 ret = -E_SIGNAL;
1264                 break;
1265         case SIGHUP:
1266                 ret = handle_sighup();
1267                 break;
1268         case SIGCHLD:
1269                 ret = handle_sigchld();
1270                 break;
1271         }
1272 out:
1273         if (ret < 0)
1274                 DSS_ERROR_LOG(("%s\n", dss_strerror(-ret)));
1275         return ret;
1276 }
1277
1278 /*
1279  * We can not use rsync locally if the local user is different from the remote
1280  * user or if the src dir is not on the local host (or both).
1281  */
1282 static int use_rsync_locally(char *logname)
1283 {
1284         const char *h = OPT_STRING_VAL(DSS, REMOTE_HOST);
1285
1286         if (strcmp(h, "localhost") && strcmp(h, "127.0.0.1"))
1287                 return 0;
1288         if (OPT_GIVEN(DSS, REMOTE_USER) &&
1289                         strcmp(OPT_STRING_VAL(DSS, REMOTE_USER), logname))
1290                 return 0;
1291         return 1;
1292 }
1293
1294 static int rename_resume_snap(int64_t creation_time)
1295 {
1296         struct snapshot_list sl;
1297         struct snapshot *s = NULL;
1298         char *new_name = incomplete_name(creation_time);
1299         int ret;
1300         const char *why;
1301
1302         sl.num_snapshots = 0;
1303
1304         ret = 0;
1305         dss_get_snapshot_list(&sl);
1306         /*
1307          * Snapshot recycling: We first look at the newest snapshot. If this
1308          * snapshot happens to be incomplete, the last rsync process was
1309          * aborted and we reuse this one. Otherwise we look at snapshots which
1310          * could be removed (outdated and redundant snapshots) as candidates
1311          * for recycling. If no outdated/redundant snapshot exists, we check if
1312          * there is an orphaned snapshot, which likely is useless anyway.
1313          *
1314          * Only if no existing snapshot is suitable for recycling, we bite the
1315          * bullet and create a new one.
1316          */
1317         s = get_newest_snapshot(&sl);
1318         if (!s) /* no snapshots at all */
1319                 goto out;
1320         /* re-use last snapshot if it is incomplete */
1321         why = "aborted";
1322         if ((s->flags & SS_COMPLETE) == 0)
1323                 goto out;
1324         why = "outdated";
1325         s = find_outdated_snapshot(&sl);
1326         if (s)
1327                 goto out;
1328         why = "redundant";
1329         s = find_redundant_snapshot(&sl);
1330         if (s)
1331                 goto out;
1332         why = "orphaned";
1333         s = find_orphaned_snapshot(&sl);
1334 out:
1335         if (s) {
1336                 DSS_NOTICE_LOG(("recycling %s snapshot %s\n", why, s->name));
1337                 ret = dss_rename(s->name, new_name);
1338         }
1339         if (ret >= 0)
1340                 DSS_NOTICE_LOG(("creating %s\n", new_name));
1341         free(new_name);
1342         free_snapshot_list(&sl);
1343         return ret;
1344 }
1345
1346 static void create_rsync_argv(char ***argv, int64_t *num)
1347 {
1348         char *logname;
1349         int i = 0, j, N = OPT_GIVEN(DSS, RSYNC_OPTION);
1350         struct snapshot_list sl;
1351         static bool seeded;
1352
1353         dss_get_snapshot_list(&sl);
1354         assert(!name_of_reference_snapshot);
1355         name_of_reference_snapshot = name_of_newest_complete_snapshot(&sl);
1356         free_snapshot_list(&sl);
1357
1358         *argv = dss_malloc((15 + N) * sizeof(char *));
1359         (*argv)[i++] = dss_strdup("rsync");
1360         (*argv)[i++] = dss_strdup("-a");
1361         (*argv)[i++] = dss_strdup("--delete");
1362         if (!seeded) {
1363                 srandom((unsigned)time(NULL)); /* no need to be fancy here */
1364                 seeded = true;
1365         }
1366         if (1000 * (random() / (RAND_MAX + 1.0)) < OPT_UINT32_VAL(DSS, CHECKSUM)) {
1367                 DSS_NOTICE_LOG(("adding --checksum to rsync options\n"));
1368                 (*argv)[i++] = dss_strdup("--checksum");
1369         }
1370         for (j = 0; j < N; j++)
1371                 (*argv)[i++] = dss_strdup(lls_string_val(j,
1372                         OPT_RESULT(DSS, RSYNC_OPTION)));
1373         if (name_of_reference_snapshot) {
1374                 DSS_INFO_LOG(("using %s as reference\n", name_of_reference_snapshot));
1375                 (*argv)[i++] = make_message("--link-dest=../%s",
1376                         name_of_reference_snapshot);
1377         } else
1378                 DSS_INFO_LOG(("no suitable reference snapshot found\n"));
1379         logname = dss_logname();
1380         if (use_rsync_locally(logname))
1381                 (*argv)[i++] = dss_strdup(OPT_STRING_VAL(DSS, SOURCE_DIR));
1382         else
1383                 (*argv)[i++] = make_message("%s@%s:%s/",
1384                         OPT_GIVEN(DSS, REMOTE_USER)?
1385                                 OPT_STRING_VAL(DSS, REMOTE_USER) : logname,
1386                         OPT_STRING_VAL(DSS, REMOTE_HOST),
1387                         OPT_STRING_VAL(DSS, SOURCE_DIR));
1388         free(logname);
1389         *num = get_current_time();
1390         (*argv)[i++] = incomplete_name(*num);
1391         (*argv)[i++] = NULL;
1392         for (j = 0; j < i; j++)
1393                 DSS_DEBUG_LOG(("argv[%d] = %s\n", j, (*argv)[j]));
1394 }
1395
1396 static void free_rsync_argv(char **argv)
1397 {
1398         int i;
1399
1400         if (!argv)
1401                 return;
1402         for (i = 0; argv[i]; i++)
1403                 free(argv[i]);
1404         free(argv);
1405 }
1406
1407 static int create_snapshot(char **argv)
1408 {
1409         int ret;
1410
1411         ret = rename_resume_snap(current_snapshot_creation_time);
1412         if (ret < 0)
1413                 return ret;
1414         dss_exec(&create_pid, argv[0], argv);
1415         snapshot_creation_status = HS_RUNNING;
1416         return ret;
1417 }
1418
1419 static int select_loop(void)
1420 {
1421         int ret;
1422         /* check every 60 seconds for free disk space */
1423         struct timeval tv;
1424         char **rsync_argv = NULL;
1425
1426         for (;;) {
1427                 fd_set rfds;
1428                 struct timeval *tvp;
1429
1430                 if (remove_pid)
1431                         tvp = NULL; /* sleep until rm hook/process dies */
1432                 else { /* sleep one minute */
1433                         tv.tv_sec = 60;
1434                         tv.tv_usec = 0;
1435                         tvp = &tv;
1436                 }
1437                 FD_ZERO(&rfds);
1438                 FD_SET(signal_pipe, &rfds);
1439                 ret = dss_select(signal_pipe + 1, &rfds, NULL, tvp);
1440                 if (ret < 0)
1441                         goto out;
1442                 if (FD_ISSET(signal_pipe, &rfds)) {
1443                         ret = handle_signal();
1444                         if (ret < 0)
1445                                 goto out;
1446                 }
1447                 if (remove_pid)
1448                         continue;
1449                 if (snapshot_removal_status == HS_PRE_SUCCESS) {
1450                         ret = exec_rm();
1451                         if (ret < 0)
1452                                 goto out;
1453                         continue;
1454                 }
1455                 if (snapshot_removal_status == HS_SUCCESS) {
1456                         post_remove_hook();
1457                         continue;
1458                 }
1459                 ret = try_to_free_disk_space();
1460                 if (ret < 0)
1461                         goto out;
1462                 if (snapshot_removal_status != HS_READY) {
1463                         stop_create_process();
1464                         continue;
1465                 }
1466                 restart_create_process();
1467                 switch (snapshot_creation_status) {
1468                 case HS_READY:
1469                         if (!next_snapshot_is_due())
1470                                 continue;
1471                         pre_create_hook();
1472                         continue;
1473                 case HS_PRE_RUNNING:
1474                 case HS_RUNNING:
1475                 case HS_POST_RUNNING:
1476                         continue;
1477                 case HS_PRE_SUCCESS:
1478                         if (!name_of_reference_snapshot) {
1479                                 free_rsync_argv(rsync_argv);
1480                                 create_rsync_argv(&rsync_argv, &current_snapshot_creation_time);
1481                         }
1482                         ret = create_snapshot(rsync_argv);
1483                         if (ret < 0)
1484                                 goto out;
1485                         continue;
1486                 case HS_NEEDS_RESTART:
1487                         if (!next_snapshot_is_due())
1488                                 continue;
1489                         ret = create_snapshot(rsync_argv);
1490                         if (ret < 0)
1491                                 goto out;
1492                         continue;
1493                 case HS_SUCCESS:
1494                         post_create_hook();
1495                         continue;
1496                 }
1497         }
1498 out:
1499         return ret;
1500 }
1501
1502 static void exit_hook(int exit_code)
1503 {
1504         const char *argv[3];
1505         pid_t pid;
1506
1507         argv[0] = OPT_STRING_VAL(DSS, EXIT_HOOK);
1508         argv[1] = dss_strerror(-exit_code);
1509         argv[2] = NULL;
1510
1511         DSS_NOTICE_LOG(("executing %s %s\n", argv[0], argv[1]));
1512         dss_exec(&pid, argv[0], (char **)argv);
1513 }
1514
1515 static void lock_dss_or_die(void)
1516 {
1517         char *config_file = get_config_file_name();
1518         int ret = lock_dss(config_file);
1519
1520         free(config_file);
1521         if (ret < 0) {
1522                 DSS_EMERG_LOG(("failed to lock: %s\n", dss_strerror(-ret)));
1523                 exit(EXIT_FAILURE);
1524         }
1525 }
1526
1527 static int com_run(void)
1528 {
1529         int ret, fd = -1;
1530         char *config_file;
1531         pid_t pid;
1532
1533         if (OPT_GIVEN(DSS, DRY_RUN)) {
1534                 DSS_ERROR_LOG(("dry run not supported by this command\n"));
1535                 return -E_SYNTAX;
1536         }
1537         config_file = get_config_file_name();
1538         ret = get_dss_pid(config_file, &pid);
1539         free(config_file);
1540         if (ret >= 0) {
1541                 DSS_ERROR_LOG(("pid %d\n", (int)pid));
1542                 return -E_ALREADY_RUNNING;
1543         }
1544         if (OPT_GIVEN(RUN, DAEMON)) {
1545                 fd = daemon_init();
1546                 daemonized = true;
1547                 logfile = open_log(OPT_STRING_VAL(RUN, LOGFILE));
1548         }
1549         lock_dss_or_die();
1550         dump_dss_config("startup");
1551         ret = install_sighandler(SIGHUP);
1552         if (ret < 0)
1553                 return ret;
1554         if (fd >= 0) {
1555                 ret = write(fd, "\0", 1);
1556                 if (ret != 1) {
1557                         DSS_ERROR_LOG(("write to daemon pipe returned %d\n",
1558                                 ret));
1559                         if (ret < 0)
1560                                 return -ERRNO_TO_DSS_ERROR(errno);
1561                         return -E_BUG;
1562                 }
1563         }
1564         ret = select_loop();
1565         if (ret >= 0) /* impossible */
1566                 ret = -E_BUG;
1567         kill_children();
1568         exit_hook(ret);
1569         return ret;
1570 }
1571 EXPORT_CMD_HANDLER(run);
1572
1573 static int com_prune(void)
1574 {
1575         int ret;
1576         struct snapshot_list sl;
1577         struct snapshot *victim;
1578         struct disk_space ds;
1579         const char *why;
1580
1581         lock_dss_or_die();
1582         ret = get_disk_space(".", &ds);
1583         if (ret < 0)
1584                 return ret;
1585         log_disk_space(&ds);
1586         dss_get_snapshot_list(&sl);
1587         why = "outdated";
1588         victim = find_outdated_snapshot(&sl);
1589         if (victim)
1590                 goto rm;
1591         why = "redundant";
1592         victim = find_redundant_snapshot(&sl);
1593         if (victim)
1594                 goto rm;
1595         ret = 0;
1596         goto out;
1597 rm:
1598         if (OPT_GIVEN(DSS, DRY_RUN)) {
1599                 dss_msg("%s snapshot %s (interval = %i)\n",
1600                         why, victim->name, victim->interval);
1601                 ret = 0;
1602                 goto out;
1603         }
1604         pre_remove_hook(victim, why);
1605         if (snapshot_removal_status == HS_PRE_RUNNING) {
1606                 ret = wait_for_remove_process();
1607                 if (ret < 0)
1608                         goto out;
1609                 if (snapshot_removal_status != HS_PRE_SUCCESS)
1610                         goto out;
1611         }
1612         ret = exec_rm();
1613         if (ret < 0)
1614                 goto out;
1615         ret = wait_for_remove_process();
1616         if (ret < 0)
1617                 goto out;
1618         if (snapshot_removal_status != HS_SUCCESS)
1619                 goto out;
1620         post_remove_hook();
1621         if (snapshot_removal_status != HS_POST_RUNNING)
1622                 goto out;
1623         ret = wait_for_remove_process();
1624         if (ret < 0)
1625                 goto out;
1626         ret = 1;
1627 out:
1628         free_snapshot_list(&sl);
1629         return ret;
1630 }
1631 EXPORT_CMD_HANDLER(prune);
1632
1633 static int com_create(void)
1634 {
1635         int ret, status;
1636         char **rsync_argv;
1637
1638         lock_dss_or_die();
1639         if (OPT_GIVEN(DSS, DRY_RUN)) {
1640                 int i;
1641                 char *msg = NULL;
1642                 create_rsync_argv(&rsync_argv, &current_snapshot_creation_time);
1643                 for (i = 0; rsync_argv[i]; i++) {
1644                         char *tmp = msg;
1645                         msg = make_message("%s%s%s", tmp? tmp : "",
1646                                 tmp? " " : "", rsync_argv[i]);
1647                         free(tmp);
1648                 }
1649                 free_rsync_argv(rsync_argv);
1650                 dss_msg("%s\n", msg);
1651                 free(msg);
1652                 return 1;
1653         }
1654         pre_create_hook();
1655         if (create_pid) {
1656                 ret = wait_for_process(create_pid, &status);
1657                 if (ret < 0)
1658                         return ret;
1659                 ret = handle_pre_create_hook_exit(status);
1660                 if (ret <= 0) /* error, or pre-create failed */
1661                         return ret;
1662         }
1663         create_rsync_argv(&rsync_argv, &current_snapshot_creation_time);
1664         ret = create_snapshot(rsync_argv);
1665         if (ret < 0)
1666                 goto out;
1667         ret = wait_for_process(create_pid, &status);
1668         if (ret < 0)
1669                 goto out;
1670         ret = handle_rsync_exit(status);
1671         if (ret < 0)
1672                 goto out;
1673         post_create_hook();
1674         if (create_pid)
1675                 ret = wait_for_process(create_pid, &status);
1676 out:
1677         free_rsync_argv(rsync_argv);
1678         return ret;
1679 }
1680 EXPORT_CMD_HANDLER(create);
1681
1682 static int com_ls(void)
1683 {
1684         int i;
1685         struct snapshot_list sl;
1686         struct snapshot *s;
1687
1688         dss_get_snapshot_list(&sl);
1689         FOR_EACH_SNAPSHOT(s, i, &sl) {
1690                 int64_t d = 0;
1691                 if (s->flags & SS_COMPLETE)
1692                         d = (s->completion_time - s->creation_time) / 60;
1693                 dss_msg("%u\t%s\t%3" PRId64 ":%02" PRId64 "\n", s->interval, s->name, d/60, d%60);
1694         }
1695         free_snapshot_list(&sl);
1696         return 1;
1697 }
1698 EXPORT_CMD_HANDLER(ls);
1699
1700 static int com_configtest(void)
1701 {
1702         printf("Syntax Ok\n");
1703         return 0;
1704 }
1705 EXPORT_CMD_HANDLER(configtest);
1706
1707 static int setup_signal_handling(void)
1708 {
1709         int ret;
1710
1711         DSS_INFO_LOG(("setting up signal handlers\n"));
1712         signal_pipe = signal_init(); /* always successful */
1713         ret = install_sighandler(SIGINT);
1714         if (ret < 0)
1715                 return ret;
1716         ret = install_sighandler(SIGTERM);
1717         if (ret < 0)
1718                 return ret;
1719         return install_sighandler(SIGCHLD);
1720 }
1721
1722 static void handle_version_and_help(void)
1723 {
1724         char *txt;
1725
1726         if (OPT_GIVEN(DSS, DETAILED_HELP))
1727                 txt = lls_long_help(CMD_PTR(DSS));
1728         else if (OPT_GIVEN(DSS, HELP))
1729                 txt = lls_short_help(CMD_PTR(DSS));
1730         else if (OPT_GIVEN(DSS, VERSION))
1731                 txt = dss_strdup(VERSION_STRING);
1732         else
1733                 return;
1734         printf("%s", txt);
1735         free(txt);
1736         exit(EXIT_SUCCESS);
1737 }
1738
1739 static void show_subcommand_summary(void)
1740 {
1741         const struct lls_command *cmd;
1742         int i;
1743
1744         printf("Available subcommands:\n");
1745         for (i = 1; (cmd = lls_cmd(i, dss_suite)); i++) {
1746                 const char *name = lls_command_name(cmd);
1747                 const char *purpose = lls_purpose(cmd);
1748                 printf("%-11s%s\n", name, purpose);
1749         }
1750         exit(EXIT_SUCCESS);
1751 }
1752
1753 int main(int argc, char **argv)
1754 {
1755         int ret;
1756         const struct lls_command *cmd = CMD_PTR(DSS);
1757         char *errctx = NULL;
1758         unsigned num_inputs;
1759         const struct dss_user_data *ud = NULL;
1760
1761         ret = lls_parse(argc, argv, cmd, &cmdline_lpr, &errctx);
1762         if (ret < 0) {
1763                 ret = lopsub_error(ret, &errctx);
1764                 goto out;
1765         }
1766         lpr = cmdline_lpr;
1767         ret = parse_config_file(false /* no SIGHUP */, cmd);
1768         if (ret < 0)
1769                 goto out;
1770         handle_version_and_help();
1771         num_inputs = lls_num_inputs(lpr);
1772         if (num_inputs == 0)
1773                 show_subcommand_summary();
1774         ret = lls_lookup_subcmd(argv[argc - num_inputs], dss_suite, &errctx);
1775         if (ret < 0) {
1776                 ret = lopsub_error(ret, &errctx);
1777                 goto out;
1778         }
1779         cmd = lls_cmd(ret, dss_suite);
1780         ret = lls_parse(num_inputs, argv + argc - num_inputs, cmd,
1781                 &cmdline_sublpr, &errctx);
1782         if (ret < 0) {
1783                 ret = lopsub_error(ret, &errctx);
1784                 goto out;
1785         }
1786         sublpr = cmdline_sublpr;
1787         ret = parse_config_file(false /* no SIGHUP */, cmd);
1788         if (ret < 0)
1789                 goto out;
1790         ret = check_config(cmd);
1791         if (ret < 0)
1792                 goto out;
1793         ret = setup_signal_handling();
1794         if (ret < 0)
1795                 goto out;
1796         ud = lls_user_data(cmd);
1797         ret = ud->handler();
1798         signal_shutdown();
1799 out:
1800         if (ret < 0) {
1801                 if (errctx)
1802                         DSS_ERROR_LOG(("%s\n", errctx));
1803                 DSS_EMERG_LOG(("%s\n", dss_strerror(-ret)));
1804         }
1805         free(errctx);
1806         lls_free_parse_result(lpr, CMD_PTR(DSS));
1807         if (lpr != cmdline_lpr)
1808                 lls_free_parse_result(cmdline_lpr, CMD_PTR(DSS));
1809         lls_free_parse_result(sublpr, cmd);
1810         if (sublpr != cmdline_sublpr)
1811                 lls_free_parse_result(cmdline_sublpr, cmd);
1812         exit(ret >= 0? EXIT_SUCCESS : EXIT_FAILURE);
1813 }