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         victim = find_oldest_removable_snapshot(&sl);
 733         if (victim)
 734                 goto remove;
 735         DSS_CRIT_LOG(("uhuhu: disk space low and nothing to remove\n"));
 736         ret = -ERRNO_TO_DSS_ERROR(ENOSPC);
 737         goto out;
 738 remove:
 739         pre_remove_hook(victim, why);
 740 out:
 741         free_snapshot_list(&sl);
 742         return ret;
 743 }
 744
 745 static void post_create_hook(void)
 746 {
 747         char *cmd = make_message("%s %s/%s",
 748                 OPT_STRING_VAL(DSS, POST_CREATE_HOOK),
 749                 OPT_STRING_VAL(DSS, DEST_DIR), path_to_last_complete_snapshot);
 750         DSS_NOTICE_LOG(("executing %s\n", cmd));
 751         dss_exec_cmdline_pid(&create_pid, cmd);
 752         free(cmd);
 753         snapshot_creation_status = HS_POST_RUNNING;
 754 }
 755
 756 static void post_remove_hook(void)
 757 {
 758         char *cmd;
 759         struct snapshot *s = snapshot_currently_being_removed;
 760
 761         assert(s);
 762
 763         cmd = make_message("%s %s/%s", OPT_STRING_VAL(DSS, POST_REMOVE_HOOK),
 764                 OPT_STRING_VAL(DSS, DEST_DIR), s->name);
 765         DSS_NOTICE_LOG(("executing %s\n", cmd));
 766         dss_exec_cmdline_pid(&remove_pid, cmd);
 767         free(cmd);
 768         snapshot_removal_status = HS_POST_RUNNING;
 769 }
 770
 771 static void dss_kill(pid_t pid, int sig, const char *msg)
 772 {
 773         const char *signame, *process_name;
 774
 775         if (pid == 0)
 776                 return;
 777         switch (sig) {
 778         case SIGTERM: signame = "TERM"; break;
 779         case SIGSTOP: signame = "STOP"; break;
 780         case SIGCONT: signame = "CONT"; break;
 781         default: signame = "????";
 782         }
 783
 784         if (pid == create_pid)
 785                 process_name = "create";
 786         else if (pid == remove_pid)
 787                 process_name = "remove";
 788         else process_name = "??????";
 789
 790         if (msg)
 791                 DSS_INFO_LOG(("%s\n", msg));
 792         DSS_DEBUG_LOG(("sending signal %d (%s) to pid %d (%s process)\n",
 793                 sig, signame, (int)pid, process_name));
 794         if (kill(pid, sig) >= 0)
 795                 return;
 796         DSS_INFO_LOG(("failed to send signal %d (%s) to pid %d (%s process)\n",
 797                 sig, signame, (int)pid, process_name));
 798 }
 799
 800 static void stop_create_process(void)
 801 {
 802         if (create_process_stopped)
 803                 return;
 804         dss_kill(create_pid, SIGSTOP, "suspending create process");
 805         create_process_stopped = 1;
 806 }
 807
 808 static void restart_create_process(void)
 809 {
 810         if (!create_process_stopped)
 811                 return;
 812         dss_kill(create_pid, SIGCONT, "resuming create process");
 813         create_process_stopped = 0;
 814 }
 815
 816 /**
 817  * Print a log message about the exit status of a child.
 818  */
 819 static void log_termination_msg(pid_t pid, int status)
 820 {
 821         if (WIFEXITED(status))
 822                 DSS_INFO_LOG(("child %i exited. Exit status: %i\n", (int)pid,
 823                         WEXITSTATUS(status)));
 824         else if (WIFSIGNALED(status))
 825                 DSS_NOTICE_LOG(("child %i was killed by signal %i\n", (int)pid,
 826                         WTERMSIG(status)));
 827         else
 828                 DSS_WARNING_LOG(("child %i terminated abormally\n", (int)pid));
 829 }
 830
 831 static int wait_for_process(pid_t pid, int *status)
 832 {
 833         int ret;
 834
 835         DSS_DEBUG_LOG(("Waiting for process %d to terminate\n", (int)pid));
 836         for (;;) {
 837                 fd_set rfds;
 838
 839                 FD_ZERO(&rfds);
 840                 FD_SET(signal_pipe, &rfds);
 841                 ret = dss_select(signal_pipe + 1, &rfds, NULL, NULL);
 842                 if (ret < 0)
 843                         break;
 844                 ret = next_signal();
 845                 if (!ret)
 846                         continue;
 847                 if (ret == SIGCHLD) {
 848                         ret = waitpid(pid, status, 0);
 849                         if (ret >= 0)
 850                                 break;
 851                         if (errno != EINTR) { /* error */
 852                                 ret = -ERRNO_TO_DSS_ERROR(errno);
 853                                 break;
 854                         }
 855                 }
 856                 /* SIGINT or SIGTERM */
 857                 dss_kill(pid, SIGTERM, "killing child process");
 858         }
 859         if (ret < 0)
 860                 DSS_ERROR_LOG(("failed to wait for process %d\n", (int)pid));
 861         else
 862                 log_termination_msg(pid, *status);
 863         return ret;
 864 }
 865
 866 static void handle_pre_remove_exit(int status)
 867 {
 868         if (!WIFEXITED(status) || WEXITSTATUS(status) != 0) {
 869                 snapshot_removal_status = HS_READY;
 870                 gettimeofday(&next_removal_check, NULL);
 871                 next_removal_check.tv_sec += 60;
 872                 return;
 873         }
 874         snapshot_removal_status = HS_PRE_SUCCESS;
 875 }
 876
 877 static int handle_rm_exit(int status)
 878 {
 879         if (!WIFEXITED(status)) {
 880                 snapshot_removal_status = HS_READY;
 881                 return -E_INVOLUNTARY_EXIT;
 882         }
 883         if (WEXITSTATUS(status)) {
 884                 snapshot_removal_status = HS_READY;
 885                 return -E_BAD_EXIT_CODE;
 886         }
 887         snapshot_removal_status = HS_SUCCESS;
 888         return 1;
 889 }
 890
 891 static void handle_post_remove_exit(void)
 892 {
 893         snapshot_removal_status = HS_READY;
 894 }
 895
 896 static int handle_remove_exit(int status)
 897 {
 898         int ret;
 899         struct snapshot *s = snapshot_currently_being_removed;
 900
 901         assert(s);
 902         switch (snapshot_removal_status) {
 903         case HS_PRE_RUNNING:
 904                 handle_pre_remove_exit(status);
 905                 ret = 1;
 906                 break;
 907         case HS_RUNNING:
 908                 ret = handle_rm_exit(status);
 909                 break;
 910         case HS_POST_RUNNING:
 911                 handle_post_remove_exit();
 912                 ret = 1;
 913                 break;
 914         default:
 915                 ret = -E_BUG;
 916         }
 917         if (snapshot_removal_status == HS_READY) {
 918                 free(s->name);
 919                 free(s);
 920                 snapshot_currently_being_removed = NULL;
 921         }
 922         remove_pid = 0;
 923         return ret;
 924 }
 925
 926 static int wait_for_remove_process(void)
 927 {
 928         int status, ret;
 929
 930         assert(remove_pid);
 931         assert(
 932                 snapshot_removal_status == HS_PRE_RUNNING ||
 933                 snapshot_removal_status == HS_RUNNING ||
 934                 snapshot_removal_status == HS_POST_RUNNING
 935         );
 936         ret = wait_for_process(remove_pid, &status);
 937         if (ret < 0)
 938                 return ret;
 939         return handle_remove_exit(status);
 940 }
 941
 942 static int handle_rsync_exit(int status)
 943 {
 944         int es, ret;
 945
 946         if (!WIFEXITED(status)) {
 947                 DSS_ERROR_LOG(("rsync process %d died involuntary\n", (int)create_pid));
 948                 ret = -E_INVOLUNTARY_EXIT;
 949                 snapshot_creation_status = HS_READY;
 950                 goto out;
 951         }
 952         es = WEXITSTATUS(status);
 953         /*
 954          * Restart rsync on non-fatal errors:
 955          * 24: Partial transfer due to vanished source files
 956          */
 957         if (es != 0 && es != 24) {
 958                 DSS_WARNING_LOG(("rsync exit code %d, error count %d\n",
 959                         es, ++num_consecutive_rsync_errors));
 960                 if (!logfile) { /* called by com_run() */
 961                         ret = -E_BAD_EXIT_CODE;
 962                         goto out;
 963                 }
 964                 if (num_consecutive_rsync_errors >
 965                                 OPT_UINT32_VAL(RUN, MAX_RSYNC_ERRORS)) {
 966                         ret = -E_TOO_MANY_RSYNC_ERRORS;
 967                         snapshot_creation_status = HS_READY;
 968                         goto out;
 969                 }
 970                 DSS_WARNING_LOG(("restarting rsync process\n"));
 971                 snapshot_creation_status = HS_NEEDS_RESTART;
 972                 next_snapshot_time = get_current_time() + 60;
 973                 ret = 1;
 974                 goto out;
 975         }
 976         num_consecutive_rsync_errors = 0;
 977         ret = rename_incomplete_snapshot(current_snapshot_creation_time);
 978         if (ret < 0)
 979                 goto out;
 980         snapshot_creation_status = HS_SUCCESS;
 981         free(name_of_reference_snapshot);
 982         name_of_reference_snapshot = NULL;
 983 out:
 984         create_process_stopped = 0;
 985         return ret;
 986 }
 987
 988 static int handle_pre_create_hook_exit(int status)
 989 {
 990         int es, ret;
 991         static int warn_count;
 992
 993         if (!WIFEXITED(status)) {
 994                 snapshot_creation_status = HS_READY;
 995                 ret = -E_INVOLUNTARY_EXIT;
 996                 goto out;
 997         }
 998         es = WEXITSTATUS(status);
 999         if (es) {
1000                 if (!warn_count--) {
1001                         DSS_NOTICE_LOG(("pre_create_hook %s returned %d\n",
1002                                 OPT_STRING_VAL(DSS, PRE_CREATE_HOOK), es));
1003                         DSS_NOTICE_LOG(("deferring snapshot creation...\n"));
1004                         warn_count = 60; /* warn only once per hour */
1005                 }
1006                 next_snapshot_time = get_current_time() + 60;
1007                 snapshot_creation_status = HS_READY;
1008                 ret = 0;
1009                 goto out;
1010         }
1011         warn_count = 0;
1012         snapshot_creation_status = HS_PRE_SUCCESS;
1013         ret = 1;
1014 out:
1015         return ret;
1016 }
1017
1018 static int handle_sigchld(void)
1019 {
1020         pid_t pid;
1021         int status, ret = reap_child(&pid, &status);
1022
1023         if (ret <= 0)
1024                 return ret;
1025
1026         if (pid == create_pid) {
1027                 switch (snapshot_creation_status) {
1028                 case HS_PRE_RUNNING:
1029                         ret = handle_pre_create_hook_exit(status);
1030                         break;
1031                 case HS_RUNNING:
1032                         ret = handle_rsync_exit(status);
1033                         break;
1034                 case HS_POST_RUNNING:
1035                         snapshot_creation_status = HS_READY;
1036                         ret = 1;
1037                         break;
1038                 default:
1039                         DSS_EMERG_LOG(("BUG: create can't die in status %d\n",
1040                                 snapshot_creation_status));
1041                         return -E_BUG;
1042                 }
1043                 create_pid = 0;
1044                 return ret;
1045         }
1046         if (pid == remove_pid) {
1047                 ret = handle_remove_exit(status);
1048                 if (ret < 0)
1049                         return ret;
1050                 return ret;
1051         }
1052         DSS_EMERG_LOG(("BUG: unknown process %d died\n", (int)pid));
1053         return -E_BUG;
1054 }
1055
1056 static int change_to_dest_dir(void)
1057 {
1058         int ret;
1059         const char *dd = OPT_STRING_VAL(DSS, DEST_DIR);
1060
1061         DSS_INFO_LOG(("changing cwd to %s\n", dd));
1062         if (chdir(dd) >= 0)
1063                 return 1;
1064         ret = -ERRNO_TO_DSS_ERROR(errno);
1065         DSS_ERROR_LOG(("could not change cwd to %s\n", dd));
1066         return ret;
1067 }
1068
1069 static int check_config(const struct lls_command *cmd)
1070 {
1071         int ret;
1072         uint32_t unit_interval = OPT_UINT32_VAL(DSS, UNIT_INTERVAL);
1073         uint32_t num_intervals = OPT_UINT32_VAL(DSS, NUM_INTERVALS);
1074
1075         if (unit_interval == 0) {
1076                 DSS_ERROR_LOG(("bad unit interval: %i\n", unit_interval));
1077                 return -E_INVALID_NUMBER;
1078         }
1079         DSS_DEBUG_LOG(("unit interval: %i day(s)\n", unit_interval));
1080
1081         if (num_intervals == 0 || num_intervals > 30) {
1082                 DSS_ERROR_LOG(("bad number of intervals: %i\n", num_intervals));
1083                 return -E_INVALID_NUMBER;
1084         }
1085         if (cmd == CMD_PTR(RUN) || cmd == CMD_PTR(CREATE))
1086                 if (!OPT_GIVEN(DSS, SOURCE_DIR)) {
1087                         DSS_ERROR_LOG(("--source-dir required\n"));
1088                         return -E_SYNTAX;
1089                 }
1090         if (cmd == CMD_PTR(RUN) || cmd == CMD_PTR(CREATE)
1091                         || cmd == CMD_PTR(LS) || cmd == CMD_PTR(PRUNE)) {
1092                 if (!OPT_GIVEN(DSS, DEST_DIR)) {
1093                         DSS_ERROR_LOG(("--dest-dir required\n"));
1094                         return -E_SYNTAX;
1095                 }
1096                 ret = change_to_dest_dir();
1097                 if (ret < 0)
1098                         return ret;
1099         }
1100         DSS_DEBUG_LOG(("number of intervals: %i\n", num_intervals));
1101         return 1;
1102 }
1103
1104 static int lopsub_error(int lopsub_ret, char **errctx)
1105 {
1106         const char *msg = lls_strerror(-lopsub_ret);
1107         if (*errctx)
1108                 DSS_ERROR_LOG(("%s: %s\n", *errctx, msg));
1109         else
1110                 DSS_ERROR_LOG(("%s\n", msg));
1111         free(*errctx);
1112         *errctx = NULL;
1113         return -E_LOPSUB;
1114 }
1115
1116 static int parse_config_file(bool sighup, const struct lls_command *cmd)
1117 {
1118         int ret, fd = -1;
1119         char *config_file = get_config_file_name();
1120         struct stat statbuf;
1121         void *map;
1122         size_t sz;
1123         int cf_argc;
1124         char **cf_argv, *errctx = NULL;
1125         struct lls_parse_result *cf_lpr, *merged_lpr, *clpr;
1126         const char *subcmd_name;
1127
1128         ret = open(config_file, O_RDONLY);
1129         if (ret < 0) {
1130                 if (errno != ENOENT || OPT_GIVEN(DSS, CONFIG_FILE)) {
1131                         ret = -ERRNO_TO_DSS_ERROR(errno);
1132                         DSS_ERROR_LOG(("config file %s can not be opened\n",
1133                                 config_file));
1134                         goto out;
1135                 }
1136                 /* no config file -- nothing to do */
1137                 ret = 0;
1138                 goto success;
1139         }
1140         fd = ret;
1141         ret = fstat(fd, &statbuf);
1142         if (ret < 0) {
1143                 ret = -ERRNO_TO_DSS_ERROR(errno);
1144                 DSS_ERROR_LOG(("failed to stat config file %s\n", config_file));
1145                 goto close_fd;
1146         }
1147         sz = statbuf.st_size;
1148         if (sz == 0) { /* config file is empty -- nothing to do */
1149                 ret = 0;
1150                 goto success;
1151         }
1152         map = mmap(NULL, sz, PROT_READ, MAP_PRIVATE, fd, 0);
1153         if (map == MAP_FAILED) {
1154                 ret = -ERRNO_TO_DSS_ERROR(errno);
1155                 DSS_ERROR_LOG(("failed to mmap config file %s\n",
1156                         config_file));
1157                 goto close_fd;
1158         }
1159         if (cmd == CMD_PTR(DSS))
1160                 subcmd_name = NULL;
1161         else
1162                 subcmd_name = lls_command_name(cmd);
1163         ret = lls_convert_config(map, sz, subcmd_name, &cf_argv, &errctx);
1164         munmap(map, sz);
1165         if (ret < 0) {
1166                 DSS_ERROR_LOG(("failed to convert config file %s\n",
1167                         config_file));
1168                 ret = lopsub_error(ret, &errctx);
1169                 goto close_fd;
1170         }
1171         cf_argc = ret;
1172         ret = lls_parse(cf_argc, cf_argv, cmd, &cf_lpr, &errctx);
1173         lls_free_argv(cf_argv);
1174         if (ret < 0) {
1175                 ret = lopsub_error(ret, &errctx);
1176                 goto close_fd;
1177         }
1178         clpr = cmd == CMD_PTR(DSS)? cmdline_lpr : cmdline_sublpr;
1179         if (sighup) /* config file overrides command line */
1180                 ret = lls_merge(cf_lpr, clpr, cmd, &merged_lpr, &errctx);
1181         else /* command line options overrride config file options */
1182                 ret = lls_merge(clpr, cf_lpr, cmd, &merged_lpr, &errctx);
1183         lls_free_parse_result(cf_lpr, cmd);
1184         if (ret < 0) {
1185                 ret = lopsub_error(ret, &errctx);
1186                 goto close_fd;
1187         }
1188         ret = 1;
1189 success:
1190         assert(ret >= 0);
1191         DSS_DEBUG_LOG(("loglevel: %d\n", OPT_UINT32_VAL(DSS, LOGLEVEL)));
1192         if (cmd != CMD_PTR(DSS)) {
1193                 if (ret > 0) {
1194                         if (sublpr != cmdline_sublpr)
1195                                 lls_free_parse_result(sublpr, cmd);
1196                         sublpr = merged_lpr;
1197                 } else
1198                         sublpr = cmdline_sublpr;
1199         } else {
1200                 if (ret > 0) {
1201                         if (lpr != cmdline_lpr)
1202                                 lls_free_parse_result(lpr, cmd);
1203                         lpr = merged_lpr;
1204                 } else
1205                         lpr = cmdline_lpr;
1206         }
1207 close_fd:
1208         if (fd >= 0)
1209                 close(fd);
1210 out:
1211         free(config_file);
1212         if (ret < 0)
1213                 DSS_EMERG_LOG(("%s\n", dss_strerror(-ret)));
1214         return ret;
1215 }
1216
1217 static int handle_sighup(void)
1218 {
1219         int ret;
1220
1221         DSS_NOTICE_LOG(("SIGHUP, re-reading config\n"));
1222         dump_dss_config("old");
1223         ret = parse_config_file(true /* SIGHUP */, CMD_PTR(DSS));
1224         if (ret < 0)
1225                 return ret;
1226         ret = parse_config_file(true /* SIGHUP */, CMD_PTR(RUN));
1227         if (ret < 0)
1228                 return ret;
1229         ret = check_config(CMD_PTR(RUN));
1230         if (ret < 0)
1231                 return ret;
1232         close_log(logfile);
1233         logfile = NULL;
1234         if (OPT_GIVEN(RUN, DAEMON) || daemonized) {
1235                 logfile = open_log(OPT_STRING_VAL(RUN, LOGFILE));
1236                 log_welcome(OPT_UINT32_VAL(DSS, LOGLEVEL));
1237                 daemonized = true;
1238         }
1239         dump_dss_config("reloaded");
1240         invalidate_next_snapshot_time();
1241         return 1;
1242 }
1243
1244 static void kill_children(void)
1245 {
1246         restart_create_process();
1247         dss_kill(create_pid, SIGTERM, NULL);
1248         dss_kill(remove_pid, SIGTERM, NULL);
1249 }
1250
1251 static int handle_signal(void)
1252 {
1253         int sig, ret = next_signal();
1254
1255         if (ret <= 0)
1256                 goto out;
1257         sig = ret;
1258         switch (sig) {
1259         case SIGINT:
1260         case SIGTERM:
1261                 kill_children();
1262                 ret = -E_SIGNAL;
1263                 break;
1264         case SIGHUP:
1265                 ret = handle_sighup();
1266                 break;
1267         case SIGCHLD:
1268                 ret = handle_sigchld();
1269                 break;
1270         }
1271 out:
1272         if (ret < 0)
1273                 DSS_ERROR_LOG(("%s\n", dss_strerror(-ret)));
1274         return ret;
1275 }
1276
1277 /*
1278  * We can not use rsync locally if the local user is different from the remote
1279  * user or if the src dir is not on the local host (or both).
1280  */
1281 static int use_rsync_locally(char *logname)
1282 {
1283         const char *h = OPT_STRING_VAL(DSS, REMOTE_HOST);
1284
1285         if (strcmp(h, "localhost") && strcmp(h, "127.0.0.1"))
1286                 return 0;
1287         if (OPT_GIVEN(DSS, REMOTE_USER) &&
1288                         strcmp(OPT_STRING_VAL(DSS, REMOTE_USER), logname))
1289                 return 0;
1290         return 1;
1291 }
1292
1293 static int rename_resume_snap(int64_t creation_time)
1294 {
1295         struct snapshot_list sl;
1296         struct snapshot *s = NULL;
1297         char *new_name = incomplete_name(creation_time);
1298         int ret;
1299         const char *why;
1300
1301         sl.num_snapshots = 0;
1302
1303         ret = 0;
1304         dss_get_snapshot_list(&sl);
1305         /*
1306          * Snapshot recycling: We first look at the newest snapshot. If this
1307          * snapshot happens to be incomplete, the last rsync process was
1308          * aborted and we reuse this one. Otherwise we look at snapshots which
1309          * could be removed (outdated and redundant snapshots) as candidates
1310          * for recycling. If no outdated/redundant snapshot exists, we check if
1311          * there is an orphaned snapshot, which likely is useless anyway.
1312          *
1313          * Only if no existing snapshot is suitable for recycling, we bite the
1314          * bullet and create a new one.
1315          */
1316         s = get_newest_snapshot(&sl);
1317         if (!s) /* no snapshots at all */
1318                 goto out;
1319         /* re-use last snapshot if it is incomplete */
1320         why = "aborted";
1321         if ((s->flags & SS_COMPLETE) == 0)
1322                 goto out;
1323         why = "outdated";
1324         s = find_outdated_snapshot(&sl);
1325         if (s)
1326                 goto out;
1327         why = "redundant";
1328         s = find_redundant_snapshot(&sl);
1329         if (s)
1330                 goto out;
1331         why = "orphaned";
1332         s = find_orphaned_snapshot(&sl);
1333 out:
1334         if (s) {
1335                 DSS_NOTICE_LOG(("recycling %s snapshot %s\n", why, s->name));
1336                 ret = dss_rename(s->name, new_name);
1337         }
1338         if (ret >= 0)
1339                 DSS_NOTICE_LOG(("creating %s\n", new_name));
1340         free(new_name);
1341         free_snapshot_list(&sl);
1342         return ret;
1343 }
1344
1345 static void create_rsync_argv(char ***argv, int64_t *num)
1346 {
1347         char *logname;
1348         int i = 0, j, N = OPT_GIVEN(DSS, RSYNC_OPTION);
1349         struct snapshot_list sl;
1350         static bool seeded;
1351
1352         dss_get_snapshot_list(&sl);
1353         assert(!name_of_reference_snapshot);
1354         name_of_reference_snapshot = name_of_newest_complete_snapshot(&sl);
1355         free_snapshot_list(&sl);
1356
1357         *argv = dss_malloc((15 + N) * sizeof(char *));
1358         (*argv)[i++] = dss_strdup("rsync");
1359         (*argv)[i++] = dss_strdup("-a");
1360         (*argv)[i++] = dss_strdup("--delete");
1361         if (!seeded) {
1362                 srandom((unsigned)time(NULL)); /* no need to be fancy here */
1363                 seeded = true;
1364         }
1365         if (1000 * (random() / (RAND_MAX + 1.0)) < OPT_UINT32_VAL(DSS, CHECKSUM)) {
1366                 DSS_NOTICE_LOG(("adding --checksum to rsync options\n"));
1367                 (*argv)[i++] = dss_strdup("--checksum");
1368         }
1369         for (j = 0; j < N; j++)
1370                 (*argv)[i++] = dss_strdup(lls_string_val(j,
1371                         OPT_RESULT(DSS, RSYNC_OPTION)));
1372         if (name_of_reference_snapshot) {
1373                 DSS_INFO_LOG(("using %s as reference\n", name_of_reference_snapshot));
1374                 (*argv)[i++] = make_message("--link-dest=../%s",
1375                         name_of_reference_snapshot);
1376         } else
1377                 DSS_INFO_LOG(("no suitable reference snapshot found\n"));
1378         logname = dss_logname();
1379         if (use_rsync_locally(logname))
1380                 (*argv)[i++] = dss_strdup(OPT_STRING_VAL(DSS, SOURCE_DIR));
1381         else
1382                 (*argv)[i++] = make_message("%s@%s:%s/",
1383                         OPT_GIVEN(DSS, REMOTE_USER)?
1384                                 OPT_STRING_VAL(DSS, REMOTE_USER) : logname,
1385                         OPT_STRING_VAL(DSS, REMOTE_HOST),
1386                         OPT_STRING_VAL(DSS, SOURCE_DIR));
1387         free(logname);
1388         *num = get_current_time();
1389         (*argv)[i++] = incomplete_name(*num);
1390         (*argv)[i++] = NULL;
1391         for (j = 0; j < i; j++)
1392                 DSS_DEBUG_LOG(("argv[%d] = %s\n", j, (*argv)[j]));
1393 }
1394
1395 static void free_rsync_argv(char **argv)
1396 {
1397         int i;
1398
1399         if (!argv)
1400                 return;
1401         for (i = 0; argv[i]; i++)
1402                 free(argv[i]);
1403         free(argv);
1404 }
1405
1406 static int create_snapshot(char **argv)
1407 {
1408         int ret;
1409
1410         ret = rename_resume_snap(current_snapshot_creation_time);
1411         if (ret < 0)
1412                 return ret;
1413         dss_exec(&create_pid, argv[0], argv);
1414         snapshot_creation_status = HS_RUNNING;
1415         return ret;
1416 }
1417
1418 static int select_loop(void)
1419 {
1420         int ret;
1421         /* check every 60 seconds for free disk space */
1422         struct timeval tv;
1423         char **rsync_argv = NULL;
1424
1425         for (;;) {
1426                 fd_set rfds;
1427                 struct timeval *tvp;
1428
1429                 if (remove_pid)
1430                         tvp = NULL; /* sleep until rm hook/process dies */
1431                 else { /* sleep one minute */
1432                         tv.tv_sec = 60;
1433                         tv.tv_usec = 0;
1434                         tvp = &tv;
1435                 }
1436                 FD_ZERO(&rfds);
1437                 FD_SET(signal_pipe, &rfds);
1438                 ret = dss_select(signal_pipe + 1, &rfds, NULL, tvp);
1439                 if (ret < 0)
1440                         goto out;
1441                 if (FD_ISSET(signal_pipe, &rfds)) {
1442                         ret = handle_signal();
1443                         if (ret < 0)
1444                                 goto out;
1445                 }
1446                 if (remove_pid)
1447                         continue;
1448                 if (snapshot_removal_status == HS_PRE_SUCCESS) {
1449                         ret = exec_rm();
1450                         if (ret < 0)
1451                                 goto out;
1452                         continue;
1453                 }
1454                 if (snapshot_removal_status == HS_SUCCESS) {
1455                         post_remove_hook();
1456                         continue;
1457                 }
1458                 ret = try_to_free_disk_space();
1459                 if (ret < 0)
1460                         goto out;
1461                 if (snapshot_removal_status != HS_READY) {
1462                         stop_create_process();
1463                         continue;
1464                 }
1465                 restart_create_process();
1466                 switch (snapshot_creation_status) {
1467                 case HS_READY:
1468                         if (!next_snapshot_is_due())
1469                                 continue;
1470                         pre_create_hook();
1471                         continue;
1472                 case HS_PRE_RUNNING:
1473                 case HS_RUNNING:
1474                 case HS_POST_RUNNING:
1475                         continue;
1476                 case HS_PRE_SUCCESS:
1477                         if (!name_of_reference_snapshot) {
1478                                 free_rsync_argv(rsync_argv);
1479                                 create_rsync_argv(&rsync_argv, &current_snapshot_creation_time);
1480                         }
1481                         ret = create_snapshot(rsync_argv);
1482                         if (ret < 0)
1483                                 goto out;
1484                         continue;
1485                 case HS_NEEDS_RESTART:
1486                         if (!next_snapshot_is_due())
1487                                 continue;
1488                         ret = create_snapshot(rsync_argv);
1489                         if (ret < 0)
1490                                 goto out;
1491                         continue;
1492                 case HS_SUCCESS:
1493                         post_create_hook();
1494                         continue;
1495                 }
1496         }
1497 out:
1498         return ret;
1499 }
1500
1501 static void exit_hook(int exit_code)
1502 {
1503         const char *argv[3];
1504         pid_t pid;
1505
1506         argv[0] = OPT_STRING_VAL(DSS, EXIT_HOOK);
1507         argv[1] = dss_strerror(-exit_code);
1508         argv[2] = NULL;
1509
1510         DSS_NOTICE_LOG(("executing %s %s\n", argv[0], argv[1]));
1511         dss_exec(&pid, argv[0], (char **)argv);
1512 }
1513
1514 static void lock_dss_or_die(void)
1515 {
1516         char *config_file = get_config_file_name();
1517         int ret = lock_dss(config_file);
1518
1519         free(config_file);
1520         if (ret < 0) {
1521                 DSS_EMERG_LOG(("failed to lock: %s\n", dss_strerror(-ret)));
1522                 exit(EXIT_FAILURE);
1523         }
1524 }
1525
1526 static int com_run(void)
1527 {
1528         int ret, fd = -1;
1529         char *config_file;
1530         pid_t pid;
1531
1532         if (OPT_GIVEN(DSS, DRY_RUN)) {
1533                 DSS_ERROR_LOG(("dry run not supported by this command\n"));
1534                 return -E_SYNTAX;
1535         }
1536         config_file = get_config_file_name();
1537         ret = get_dss_pid(config_file, &pid);
1538         free(config_file);
1539         if (ret >= 0) {
1540                 DSS_ERROR_LOG(("pid %d\n", (int)pid));
1541                 return -E_ALREADY_RUNNING;
1542         }
1543         if (OPT_GIVEN(RUN, DAEMON)) {
1544                 fd = daemon_init();
1545                 daemonized = true;
1546                 logfile = open_log(OPT_STRING_VAL(RUN, LOGFILE));
1547         }
1548         lock_dss_or_die();
1549         dump_dss_config("startup");
1550         ret = install_sighandler(SIGHUP);
1551         if (ret < 0)
1552                 return ret;
1553         if (fd >= 0) {
1554                 ret = write(fd, "\0", 1);
1555                 if (ret != 1) {
1556                         DSS_ERROR_LOG(("write to daemon pipe returned %d\n",
1557                                 ret));
1558                         if (ret < 0)
1559                                 return -ERRNO_TO_DSS_ERROR(errno);
1560                         return -E_BUG;
1561                 }
1562         }
1563         ret = select_loop();
1564         if (ret >= 0) /* impossible */
1565                 ret = -E_BUG;
1566         kill_children();
1567         exit_hook(ret);
1568         return ret;
1569 }
1570 EXPORT_CMD_HANDLER(run);
1571
1572 static int com_prune(void)
1573 {
1574         int ret;
1575         struct snapshot_list sl;
1576         struct snapshot *victim;
1577         struct disk_space ds;
1578         const char *why;
1579
1580         lock_dss_or_die();
1581         ret = get_disk_space(".", &ds);
1582         if (ret < 0)
1583                 return ret;
1584         log_disk_space(&ds);
1585         dss_get_snapshot_list(&sl);
1586         why = "outdated";
1587         victim = find_outdated_snapshot(&sl);
1588         if (victim)
1589                 goto rm;
1590         why = "redundant";
1591         victim = find_redundant_snapshot(&sl);
1592         if (victim)
1593                 goto rm;
1594         ret = 0;
1595         goto out;
1596 rm:
1597         if (OPT_GIVEN(DSS, DRY_RUN)) {
1598                 dss_msg("%s snapshot %s (interval = %i)\n",
1599                         why, victim->name, victim->interval);
1600                 ret = 0;
1601                 goto out;
1602         }
1603         pre_remove_hook(victim, why);
1604         if (snapshot_removal_status == HS_PRE_RUNNING) {
1605                 ret = wait_for_remove_process();
1606                 if (ret < 0)
1607                         goto out;
1608                 if (snapshot_removal_status != HS_PRE_SUCCESS)
1609                         goto out;
1610         }
1611         ret = exec_rm();
1612         if (ret < 0)
1613                 goto out;
1614         ret = wait_for_remove_process();
1615         if (ret < 0)
1616                 goto out;
1617         if (snapshot_removal_status != HS_SUCCESS)
1618                 goto out;
1619         post_remove_hook();
1620         if (snapshot_removal_status != HS_POST_RUNNING)
1621                 goto out;
1622         ret = wait_for_remove_process();
1623         if (ret < 0)
1624                 goto out;
1625         ret = 1;
1626 out:
1627         free_snapshot_list(&sl);
1628         return ret;
1629 }
1630 EXPORT_CMD_HANDLER(prune);
1631
1632 static int com_create(void)
1633 {
1634         int ret, status;
1635         char **rsync_argv;
1636
1637         lock_dss_or_die();
1638         if (OPT_GIVEN(DSS, DRY_RUN)) {
1639                 int i;
1640                 char *msg = NULL;
1641                 create_rsync_argv(&rsync_argv, &current_snapshot_creation_time);
1642                 for (i = 0; rsync_argv[i]; i++) {
1643                         char *tmp = msg;
1644                         msg = make_message("%s%s%s", tmp? tmp : "",
1645                                 tmp? " " : "", rsync_argv[i]);
1646                         free(tmp);
1647                 }
1648                 free_rsync_argv(rsync_argv);
1649                 dss_msg("%s\n", msg);
1650                 free(msg);
1651                 return 1;
1652         }
1653         pre_create_hook();
1654         if (create_pid) {
1655                 ret = wait_for_process(create_pid, &status);
1656                 if (ret < 0)
1657                         return ret;
1658                 ret = handle_pre_create_hook_exit(status);
1659                 if (ret <= 0) /* error, or pre-create failed */
1660                         return ret;
1661         }
1662         create_rsync_argv(&rsync_argv, &current_snapshot_creation_time);
1663         ret = create_snapshot(rsync_argv);
1664         if (ret < 0)
1665                 goto out;
1666         ret = wait_for_process(create_pid, &status);
1667         if (ret < 0)
1668                 goto out;
1669         ret = handle_rsync_exit(status);
1670         if (ret < 0)
1671                 goto out;
1672         post_create_hook();
1673         if (create_pid)
1674                 ret = wait_for_process(create_pid, &status);
1675 out:
1676         free_rsync_argv(rsync_argv);
1677         return ret;
1678 }
1679 EXPORT_CMD_HANDLER(create);
1680
1681 static int com_ls(void)
1682 {
1683         int i;
1684         struct snapshot_list sl;
1685         struct snapshot *s;
1686
1687         dss_get_snapshot_list(&sl);
1688         FOR_EACH_SNAPSHOT(s, i, &sl) {
1689                 int64_t d = 0;
1690                 if (s->flags & SS_COMPLETE)
1691                         d = (s->completion_time - s->creation_time) / 60;
1692                 dss_msg("%u\t%s\t%3" PRId64 ":%02" PRId64 "\n", s->interval, s->name, d/60, d%60);
1693         }
1694         free_snapshot_list(&sl);
1695         return 1;
1696 }
1697 EXPORT_CMD_HANDLER(ls);
1698
1699 static int setup_signal_handling(void)
1700 {
1701         int ret;
1702
1703         DSS_INFO_LOG(("setting up signal handlers\n"));
1704         signal_pipe = signal_init(); /* always successful */
1705         ret = install_sighandler(SIGINT);
1706         if (ret < 0)
1707                 return ret;
1708         ret = install_sighandler(SIGTERM);
1709         if (ret < 0)
1710                 return ret;
1711         return install_sighandler(SIGCHLD);
1712 }
1713
1714 static void handle_version_and_help(void)
1715 {
1716         char *txt;
1717
1718         if (OPT_GIVEN(DSS, DETAILED_HELP))
1719                 txt = lls_long_help(CMD_PTR(DSS));
1720         else if (OPT_GIVEN(DSS, HELP))
1721                 txt = lls_short_help(CMD_PTR(DSS));
1722         else if (OPT_GIVEN(DSS, VERSION))
1723                 txt = dss_strdup(VERSION_STRING);
1724         else
1725                 return;
1726         printf("%s", txt);
1727         free(txt);
1728         exit(EXIT_SUCCESS);
1729 }
1730
1731 static void show_subcommand_summary(void)
1732 {
1733         const struct lls_command *cmd;
1734         int i;
1735
1736         printf("Available subcommands:\n");
1737         for (i = 1; (cmd = lls_cmd(i, dss_suite)); i++) {
1738                 const char *name = lls_command_name(cmd);
1739                 const char *purpose = lls_purpose(cmd);
1740                 printf("%-10s%s\n", name, purpose);
1741         }
1742         exit(EXIT_SUCCESS);
1743 }
1744
1745 int main(int argc, char **argv)
1746 {
1747         int ret;
1748         const struct lls_command *cmd = CMD_PTR(DSS);
1749         char *errctx = NULL;
1750         unsigned num_inputs;
1751         const struct dss_user_data *ud;
1752
1753         ret = lls_parse(argc, argv, cmd, &cmdline_lpr, &errctx);
1754         if (ret < 0) {
1755                 ret = lopsub_error(ret, &errctx);
1756                 goto out;
1757         }
1758         lpr = cmdline_lpr;
1759         ret = parse_config_file(false /* no SIGHUP */, cmd);
1760         if (ret < 0)
1761                 goto out;
1762         handle_version_and_help();
1763         num_inputs = lls_num_inputs(lpr);
1764         if (num_inputs == 0)
1765                 show_subcommand_summary();
1766         ret = lls_lookup_subcmd(argv[argc - num_inputs], dss_suite, &errctx);
1767         if (ret < 0) {
1768                 ret = lopsub_error(ret, &errctx);
1769                 goto out;
1770         }
1771         cmd = lls_cmd(ret, dss_suite);
1772         ret = lls_parse(num_inputs, argv + argc - num_inputs, cmd,
1773                 &cmdline_sublpr, &errctx);
1774         if (ret < 0) {
1775                 ret = lopsub_error(ret, &errctx);
1776                 goto out;
1777         }
1778         sublpr = cmdline_sublpr;
1779         ret = parse_config_file(false /* no SIGHUP */, cmd);
1780         if (ret < 0)
1781                 goto out;
1782         ret = check_config(cmd);
1783         if (ret < 0)
1784                 goto out;
1785         ret = setup_signal_handling();
1786         if (ret < 0)
1787                 goto out;
1788         ud = lls_user_data(cmd);
1789         ret = ud->handler();
1790         signal_shutdown();
1791 out:
1792         if (ret < 0) {
1793                 if (errctx)
1794                         DSS_ERROR_LOG(("%s\n", errctx));
1795                 DSS_EMERG_LOG(("%s\n", dss_strerror(-ret)));
1796         }
1797         free(errctx);
1798         lls_free_parse_result(lpr, CMD_PTR(DSS));
1799         if (lpr != cmdline_lpr)
1800                 lls_free_parse_result(cmdline_lpr, CMD_PTR(DSS));
1801         lls_free_parse_result(sublpr, cmd);
1802         if (sublpr != cmdline_sublpr)
1803                 lls_free_parse_result(cmdline_sublpr, cmd);
1804         exit(ret >= 0? EXIT_SUCCESS : EXIT_FAILURE);
1805 }