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 /* also checks if . is a mountpoint, if --mountpoint was given */
1057 static int change_to_dest_dir(void)
1058 {
1059         int ret;
1060         const char *dd = OPT_STRING_VAL(DSS, DEST_DIR);
1061         struct stat dot, dotdot;
1062
1063         DSS_INFO_LOG(("changing cwd to %s\n", dd));
1064         if (chdir(dd) < 0) {
1065                 ret = -ERRNO_TO_DSS_ERROR(errno);
1066                 DSS_ERROR_LOG(("could not change cwd to %s\n", dd));
1067                 return ret;
1068         }
1069         if (!OPT_GIVEN(DSS, MOUNTPOINT))
1070                 return 0;
1071         if (stat(".", &dot) < 0) {
1072                 ret = -ERRNO_TO_DSS_ERROR(errno);
1073                 DSS_ERROR_LOG(("could not stat .\n"));
1074                 return ret;
1075         }
1076         if (stat("..", &dotdot) < 0) {
1077                 ret = -ERRNO_TO_DSS_ERROR(errno);
1078                 DSS_ERROR_LOG(("could not stat ..\n"));
1079                 return ret;
1080         }
1081         if (dot.st_dev == dotdot.st_dev && dot.st_ino != dotdot.st_ino) {
1082                 DSS_ERROR_LOG(("mountpoint check failed for %s\n", dd));
1083                 return -E_MOUNTPOINT;
1084         }
1085         return 1;
1086 }
1087
1088 static int check_config(const struct lls_command *cmd)
1089 {
1090         int ret;
1091         uint32_t unit_interval = OPT_UINT32_VAL(DSS, UNIT_INTERVAL);
1092         uint32_t num_intervals = OPT_UINT32_VAL(DSS, NUM_INTERVALS);
1093
1094         if (unit_interval == 0) {
1095                 DSS_ERROR_LOG(("bad unit interval: %i\n", unit_interval));
1096                 return -E_INVALID_NUMBER;
1097         }
1098         DSS_DEBUG_LOG(("unit interval: %i day(s)\n", unit_interval));
1099
1100         if (num_intervals == 0 || num_intervals > 30) {
1101                 DSS_ERROR_LOG(("bad number of intervals: %i\n", num_intervals));
1102                 return -E_INVALID_NUMBER;
1103         }
1104         if (cmd == CMD_PTR(RUN) || cmd == CMD_PTR(CREATE))
1105                 if (!OPT_GIVEN(DSS, SOURCE_DIR)) {
1106                         DSS_ERROR_LOG(("--source-dir required\n"));
1107                         return -E_SYNTAX;
1108                 }
1109         if (cmd == CMD_PTR(RUN) || cmd == CMD_PTR(CREATE)
1110                         || cmd == CMD_PTR(LS) || cmd == CMD_PTR(PRUNE)) {
1111                 if (!OPT_GIVEN(DSS, DEST_DIR)) {
1112                         DSS_ERROR_LOG(("--dest-dir required\n"));
1113                         return -E_SYNTAX;
1114                 }
1115                 ret = change_to_dest_dir();
1116                 if (ret < 0)
1117                         return ret;
1118         }
1119         DSS_DEBUG_LOG(("number of intervals: %i\n", num_intervals));
1120         return 1;
1121 }
1122
1123 static int lopsub_error(int lopsub_ret, char **errctx)
1124 {
1125         const char *msg = lls_strerror(-lopsub_ret);
1126         if (*errctx)
1127                 DSS_ERROR_LOG(("%s: %s\n", *errctx, msg));
1128         else
1129                 DSS_ERROR_LOG(("%s\n", msg));
1130         free(*errctx);
1131         *errctx = NULL;
1132         return -E_LOPSUB;
1133 }
1134
1135 static int parse_config_file(bool sighup, const struct lls_command *cmd)
1136 {
1137         int ret, fd = -1;
1138         char *config_file = get_config_file_name();
1139         struct stat statbuf;
1140         void *map;
1141         size_t sz;
1142         int cf_argc;
1143         char **cf_argv, *errctx = NULL;
1144         struct lls_parse_result *cf_lpr, *merged_lpr, *clpr;
1145         const char *subcmd_name;
1146
1147         ret = open(config_file, O_RDONLY);
1148         if (ret < 0) {
1149                 if (errno != ENOENT || OPT_GIVEN(DSS, CONFIG_FILE)) {
1150                         ret = -ERRNO_TO_DSS_ERROR(errno);
1151                         DSS_ERROR_LOG(("config file %s can not be opened\n",
1152                                 config_file));
1153                         goto out;
1154                 }
1155                 /* no config file -- nothing to do */
1156                 ret = 0;
1157                 goto success;
1158         }
1159         fd = ret;
1160         ret = fstat(fd, &statbuf);
1161         if (ret < 0) {
1162                 ret = -ERRNO_TO_DSS_ERROR(errno);
1163                 DSS_ERROR_LOG(("failed to stat config file %s\n", config_file));
1164                 goto close_fd;
1165         }
1166         sz = statbuf.st_size;
1167         if (sz == 0) { /* config file is empty -- nothing to do */
1168                 ret = 0;
1169                 goto success;
1170         }
1171         map = mmap(NULL, sz, PROT_READ, MAP_PRIVATE, fd, 0);
1172         if (map == MAP_FAILED) {
1173                 ret = -ERRNO_TO_DSS_ERROR(errno);
1174                 DSS_ERROR_LOG(("failed to mmap config file %s\n",
1175                         config_file));
1176                 goto close_fd;
1177         }
1178         if (cmd == CMD_PTR(DSS))
1179                 subcmd_name = NULL;
1180         else
1181                 subcmd_name = lls_command_name(cmd);
1182         ret = lls_convert_config(map, sz, subcmd_name, &cf_argv, &errctx);
1183         munmap(map, sz);
1184         if (ret < 0) {
1185                 DSS_ERROR_LOG(("failed to convert config file %s\n",
1186                         config_file));
1187                 ret = lopsub_error(ret, &errctx);
1188                 goto close_fd;
1189         }
1190         cf_argc = ret;
1191         ret = lls_parse(cf_argc, cf_argv, cmd, &cf_lpr, &errctx);
1192         lls_free_argv(cf_argv);
1193         if (ret < 0) {
1194                 ret = lopsub_error(ret, &errctx);
1195                 goto close_fd;
1196         }
1197         clpr = cmd == CMD_PTR(DSS)? cmdline_lpr : cmdline_sublpr;
1198         if (sighup) /* config file overrides command line */
1199                 ret = lls_merge(cf_lpr, clpr, cmd, &merged_lpr, &errctx);
1200         else /* command line options overrride config file options */
1201                 ret = lls_merge(clpr, cf_lpr, cmd, &merged_lpr, &errctx);
1202         lls_free_parse_result(cf_lpr, cmd);
1203         if (ret < 0) {
1204                 ret = lopsub_error(ret, &errctx);
1205                 goto close_fd;
1206         }
1207         ret = 1;
1208 success:
1209         assert(ret >= 0);
1210         DSS_DEBUG_LOG(("loglevel: %d\n", OPT_UINT32_VAL(DSS, LOGLEVEL)));
1211         if (cmd != CMD_PTR(DSS)) {
1212                 if (ret > 0) {
1213                         if (sublpr != cmdline_sublpr)
1214                                 lls_free_parse_result(sublpr, cmd);
1215                         sublpr = merged_lpr;
1216                 } else
1217                         sublpr = cmdline_sublpr;
1218         } else {
1219                 if (ret > 0) {
1220                         if (lpr != cmdline_lpr)
1221                                 lls_free_parse_result(lpr, cmd);
1222                         lpr = merged_lpr;
1223                 } else
1224                         lpr = cmdline_lpr;
1225         }
1226 close_fd:
1227         if (fd >= 0)
1228                 close(fd);
1229 out:
1230         free(config_file);
1231         if (ret < 0)
1232                 DSS_EMERG_LOG(("%s\n", dss_strerror(-ret)));
1233         return ret;
1234 }
1235
1236 static int handle_sighup(void)
1237 {
1238         int ret;
1239
1240         DSS_NOTICE_LOG(("SIGHUP, re-reading config\n"));
1241         dump_dss_config("old");
1242         ret = parse_config_file(true /* SIGHUP */, CMD_PTR(DSS));
1243         if (ret < 0)
1244                 return ret;
1245         ret = parse_config_file(true /* SIGHUP */, CMD_PTR(RUN));
1246         if (ret < 0)
1247                 return ret;
1248         ret = check_config(CMD_PTR(RUN));
1249         if (ret < 0)
1250                 return ret;
1251         close_log(logfile);
1252         logfile = NULL;
1253         if (OPT_GIVEN(RUN, DAEMON) || daemonized) {
1254                 logfile = open_log(OPT_STRING_VAL(RUN, LOGFILE));
1255                 log_welcome(OPT_UINT32_VAL(DSS, LOGLEVEL));
1256                 daemonized = true;
1257         }
1258         dump_dss_config("reloaded");
1259         invalidate_next_snapshot_time();
1260         return 1;
1261 }
1262
1263 static void kill_children(void)
1264 {
1265         restart_create_process();
1266         dss_kill(create_pid, SIGTERM, NULL);
1267         dss_kill(remove_pid, SIGTERM, NULL);
1268 }
1269
1270 static int handle_signal(void)
1271 {
1272         int sig, ret = next_signal();
1273
1274         if (ret <= 0)
1275                 goto out;
1276         sig = ret;
1277         switch (sig) {
1278         case SIGINT:
1279         case SIGTERM:
1280                 kill_children();
1281                 ret = -E_SIGNAL;
1282                 break;
1283         case SIGHUP:
1284                 ret = handle_sighup();
1285                 break;
1286         case SIGCHLD:
1287                 ret = handle_sigchld();
1288                 break;
1289         }
1290 out:
1291         if (ret < 0)
1292                 DSS_ERROR_LOG(("%s\n", dss_strerror(-ret)));
1293         return ret;
1294 }
1295
1296 /*
1297  * We can not use rsync locally if the local user is different from the remote
1298  * user or if the src dir is not on the local host (or both).
1299  */
1300 static int use_rsync_locally(char *logname)
1301 {
1302         const char *h = OPT_STRING_VAL(DSS, REMOTE_HOST);
1303
1304         if (strcmp(h, "localhost") && strcmp(h, "127.0.0.1"))
1305                 return 0;
1306         if (OPT_GIVEN(DSS, REMOTE_USER) &&
1307                         strcmp(OPT_STRING_VAL(DSS, REMOTE_USER), logname))
1308                 return 0;
1309         return 1;
1310 }
1311
1312 static int rename_resume_snap(int64_t creation_time)
1313 {
1314         struct snapshot_list sl;
1315         struct snapshot *s = NULL;
1316         char *new_name = incomplete_name(creation_time);
1317         int ret;
1318         const char *why;
1319
1320         sl.num_snapshots = 0;
1321
1322         ret = 0;
1323         dss_get_snapshot_list(&sl);
1324         /*
1325          * Snapshot recycling: We first look at the newest snapshot. If this
1326          * snapshot happens to be incomplete, the last rsync process was
1327          * aborted and we reuse this one. Otherwise we look at snapshots which
1328          * could be removed (outdated and redundant snapshots) as candidates
1329          * for recycling. If no outdated/redundant snapshot exists, we check if
1330          * there is an orphaned snapshot, which likely is useless anyway.
1331          *
1332          * Only if no existing snapshot is suitable for recycling, we bite the
1333          * bullet and create a new one.
1334          */
1335         s = get_newest_snapshot(&sl);
1336         if (!s) /* no snapshots at all */
1337                 goto out;
1338         /* re-use last snapshot if it is incomplete */
1339         why = "aborted";
1340         if ((s->flags & SS_COMPLETE) == 0)
1341                 goto out;
1342         why = "outdated";
1343         s = find_outdated_snapshot(&sl);
1344         if (s)
1345                 goto out;
1346         why = "redundant";
1347         s = find_redundant_snapshot(&sl);
1348         if (s)
1349                 goto out;
1350         why = "orphaned";
1351         s = find_orphaned_snapshot(&sl);
1352 out:
1353         if (s) {
1354                 DSS_NOTICE_LOG(("recycling %s snapshot %s\n", why, s->name));
1355                 ret = dss_rename(s->name, new_name);
1356         }
1357         if (ret >= 0)
1358                 DSS_NOTICE_LOG(("creating %s\n", new_name));
1359         free(new_name);
1360         free_snapshot_list(&sl);
1361         return ret;
1362 }
1363
1364 static void create_rsync_argv(char ***argv, int64_t *num)
1365 {
1366         char *logname;
1367         int i = 0, j, N = OPT_GIVEN(DSS, RSYNC_OPTION);
1368         struct snapshot_list sl;
1369         static bool seeded;
1370
1371         dss_get_snapshot_list(&sl);
1372         assert(!name_of_reference_snapshot);
1373         name_of_reference_snapshot = name_of_newest_complete_snapshot(&sl);
1374         free_snapshot_list(&sl);
1375
1376         *argv = dss_malloc((15 + N) * sizeof(char *));
1377         (*argv)[i++] = dss_strdup("rsync");
1378         (*argv)[i++] = dss_strdup("-a");
1379         (*argv)[i++] = dss_strdup("--delete");
1380         if (!seeded) {
1381                 srandom((unsigned)time(NULL)); /* no need to be fancy here */
1382                 seeded = true;
1383         }
1384         if (1000 * (random() / (RAND_MAX + 1.0)) < OPT_UINT32_VAL(DSS, CHECKSUM)) {
1385                 DSS_NOTICE_LOG(("adding --checksum to rsync options\n"));
1386                 (*argv)[i++] = dss_strdup("--checksum");
1387         }
1388         for (j = 0; j < N; j++)
1389                 (*argv)[i++] = dss_strdup(lls_string_val(j,
1390                         OPT_RESULT(DSS, RSYNC_OPTION)));
1391         if (name_of_reference_snapshot) {
1392                 DSS_INFO_LOG(("using %s as reference\n", name_of_reference_snapshot));
1393                 (*argv)[i++] = make_message("--link-dest=../%s",
1394                         name_of_reference_snapshot);
1395         } else
1396                 DSS_INFO_LOG(("no suitable reference snapshot found\n"));
1397         logname = dss_logname();
1398         if (use_rsync_locally(logname))
1399                 (*argv)[i++] = dss_strdup(OPT_STRING_VAL(DSS, SOURCE_DIR));
1400         else
1401                 (*argv)[i++] = make_message("%s@%s:%s/",
1402                         OPT_GIVEN(DSS, REMOTE_USER)?
1403                                 OPT_STRING_VAL(DSS, REMOTE_USER) : logname,
1404                         OPT_STRING_VAL(DSS, REMOTE_HOST),
1405                         OPT_STRING_VAL(DSS, SOURCE_DIR));
1406         free(logname);
1407         *num = get_current_time();
1408         (*argv)[i++] = incomplete_name(*num);
1409         (*argv)[i++] = NULL;
1410         for (j = 0; j < i; j++)
1411                 DSS_DEBUG_LOG(("argv[%d] = %s\n", j, (*argv)[j]));
1412 }
1413
1414 static void free_rsync_argv(char **argv)
1415 {
1416         int i;
1417
1418         if (!argv)
1419                 return;
1420         for (i = 0; argv[i]; i++)
1421                 free(argv[i]);
1422         free(argv);
1423 }
1424
1425 static int create_snapshot(char **argv)
1426 {
1427         int ret;
1428
1429         ret = rename_resume_snap(current_snapshot_creation_time);
1430         if (ret < 0)
1431                 return ret;
1432         dss_exec(&create_pid, argv[0], argv);
1433         snapshot_creation_status = HS_RUNNING;
1434         return ret;
1435 }
1436
1437 static int select_loop(void)
1438 {
1439         int ret;
1440         /* check every 60 seconds for free disk space */
1441         struct timeval tv;
1442         char **rsync_argv = NULL;
1443
1444         for (;;) {
1445                 fd_set rfds;
1446                 struct timeval *tvp;
1447
1448                 if (remove_pid)
1449                         tvp = NULL; /* sleep until rm hook/process dies */
1450                 else { /* sleep one minute */
1451                         tv.tv_sec = 60;
1452                         tv.tv_usec = 0;
1453                         tvp = &tv;
1454                 }
1455                 FD_ZERO(&rfds);
1456                 FD_SET(signal_pipe, &rfds);
1457                 ret = dss_select(signal_pipe + 1, &rfds, NULL, tvp);
1458                 if (ret < 0)
1459                         goto out;
1460                 if (FD_ISSET(signal_pipe, &rfds)) {
1461                         ret = handle_signal();
1462                         if (ret < 0)
1463                                 goto out;
1464                 }
1465                 if (remove_pid)
1466                         continue;
1467                 if (snapshot_removal_status == HS_PRE_SUCCESS) {
1468                         ret = exec_rm();
1469                         if (ret < 0)
1470                                 goto out;
1471                         continue;
1472                 }
1473                 if (snapshot_removal_status == HS_SUCCESS) {
1474                         post_remove_hook();
1475                         continue;
1476                 }
1477                 ret = try_to_free_disk_space();
1478                 if (ret < 0)
1479                         goto out;
1480                 if (snapshot_removal_status != HS_READY) {
1481                         stop_create_process();
1482                         continue;
1483                 }
1484                 restart_create_process();
1485                 switch (snapshot_creation_status) {
1486                 case HS_READY:
1487                         if (!next_snapshot_is_due())
1488                                 continue;
1489                         pre_create_hook();
1490                         continue;
1491                 case HS_PRE_RUNNING:
1492                 case HS_RUNNING:
1493                 case HS_POST_RUNNING:
1494                         continue;
1495                 case HS_PRE_SUCCESS:
1496                         if (!name_of_reference_snapshot) {
1497                                 free_rsync_argv(rsync_argv);
1498                                 create_rsync_argv(&rsync_argv, &current_snapshot_creation_time);
1499                         }
1500                         ret = create_snapshot(rsync_argv);
1501                         if (ret < 0)
1502                                 goto out;
1503                         continue;
1504                 case HS_NEEDS_RESTART:
1505                         if (!next_snapshot_is_due())
1506                                 continue;
1507                         ret = create_snapshot(rsync_argv);
1508                         if (ret < 0)
1509                                 goto out;
1510                         continue;
1511                 case HS_SUCCESS:
1512                         post_create_hook();
1513                         continue;
1514                 }
1515         }
1516 out:
1517         return ret;
1518 }
1519
1520 static void exit_hook(int exit_code)
1521 {
1522         const char *argv[3];
1523         pid_t pid;
1524
1525         argv[0] = OPT_STRING_VAL(DSS, EXIT_HOOK);
1526         argv[1] = dss_strerror(-exit_code);
1527         argv[2] = NULL;
1528
1529         DSS_NOTICE_LOG(("executing %s %s\n", argv[0], argv[1]));
1530         dss_exec(&pid, argv[0], (char **)argv);
1531 }
1532
1533 static void lock_dss_or_die(void)
1534 {
1535         char *config_file = get_config_file_name();
1536         int ret = lock_dss(config_file);
1537
1538         free(config_file);
1539         if (ret < 0) {
1540                 DSS_EMERG_LOG(("failed to lock: %s\n", dss_strerror(-ret)));
1541                 exit(EXIT_FAILURE);
1542         }
1543 }
1544
1545 static int com_run(void)
1546 {
1547         int ret, fd = -1;
1548         char *config_file;
1549         pid_t pid;
1550
1551         if (OPT_GIVEN(DSS, DRY_RUN)) {
1552                 DSS_ERROR_LOG(("dry run not supported by this command\n"));
1553                 return -E_SYNTAX;
1554         }
1555         config_file = get_config_file_name();
1556         ret = get_dss_pid(config_file, &pid);
1557         free(config_file);
1558         if (ret >= 0) {
1559                 DSS_ERROR_LOG(("pid %d\n", (int)pid));
1560                 return -E_ALREADY_RUNNING;
1561         }
1562         if (OPT_GIVEN(RUN, DAEMON)) {
1563                 fd = daemon_init();
1564                 daemonized = true;
1565                 logfile = open_log(OPT_STRING_VAL(RUN, LOGFILE));
1566         }
1567         lock_dss_or_die();
1568         dump_dss_config("startup");
1569         ret = install_sighandler(SIGHUP);
1570         if (ret < 0)
1571                 return ret;
1572         if (fd >= 0) {
1573                 ret = write(fd, "\0", 1);
1574                 if (ret != 1) {
1575                         DSS_ERROR_LOG(("write to daemon pipe returned %d\n",
1576                                 ret));
1577                         if (ret < 0)
1578                                 return -ERRNO_TO_DSS_ERROR(errno);
1579                         return -E_BUG;
1580                 }
1581         }
1582         ret = select_loop();
1583         if (ret >= 0) /* impossible */
1584                 ret = -E_BUG;
1585         kill_children();
1586         exit_hook(ret);
1587         return ret;
1588 }
1589 EXPORT_CMD_HANDLER(run);
1590
1591 static int com_prune(void)
1592 {
1593         int ret;
1594         struct snapshot_list sl;
1595         struct snapshot *victim;
1596         struct disk_space ds;
1597         const char *why;
1598
1599         lock_dss_or_die();
1600         ret = get_disk_space(".", &ds);
1601         if (ret < 0)
1602                 return ret;
1603         log_disk_space(&ds);
1604         dss_get_snapshot_list(&sl);
1605         why = "outdated";
1606         victim = find_outdated_snapshot(&sl);
1607         if (victim)
1608                 goto rm;
1609         why = "redundant";
1610         victim = find_redundant_snapshot(&sl);
1611         if (victim)
1612                 goto rm;
1613         ret = 0;
1614         goto out;
1615 rm:
1616         if (OPT_GIVEN(DSS, DRY_RUN)) {
1617                 dss_msg("%s snapshot %s (interval = %i)\n",
1618                         why, victim->name, victim->interval);
1619                 ret = 0;
1620                 goto out;
1621         }
1622         pre_remove_hook(victim, why);
1623         if (snapshot_removal_status == HS_PRE_RUNNING) {
1624                 ret = wait_for_remove_process();
1625                 if (ret < 0)
1626                         goto out;
1627                 if (snapshot_removal_status != HS_PRE_SUCCESS)
1628                         goto out;
1629         }
1630         ret = exec_rm();
1631         if (ret < 0)
1632                 goto out;
1633         ret = wait_for_remove_process();
1634         if (ret < 0)
1635                 goto out;
1636         if (snapshot_removal_status != HS_SUCCESS)
1637                 goto out;
1638         post_remove_hook();
1639         if (snapshot_removal_status != HS_POST_RUNNING)
1640                 goto out;
1641         ret = wait_for_remove_process();
1642         if (ret < 0)
1643                 goto out;
1644         ret = 1;
1645 out:
1646         free_snapshot_list(&sl);
1647         return ret;
1648 }
1649 EXPORT_CMD_HANDLER(prune);
1650
1651 static int com_create(void)
1652 {
1653         int ret, status;
1654         char **rsync_argv;
1655
1656         lock_dss_or_die();
1657         if (OPT_GIVEN(DSS, DRY_RUN)) {
1658                 int i;
1659                 char *msg = NULL;
1660                 create_rsync_argv(&rsync_argv, &current_snapshot_creation_time);
1661                 for (i = 0; rsync_argv[i]; i++) {
1662                         char *tmp = msg;
1663                         msg = make_message("%s%s%s", tmp? tmp : "",
1664                                 tmp? " " : "", rsync_argv[i]);
1665                         free(tmp);
1666                 }
1667                 free_rsync_argv(rsync_argv);
1668                 dss_msg("%s\n", msg);
1669                 free(msg);
1670                 return 1;
1671         }
1672         pre_create_hook();
1673         if (create_pid) {
1674                 ret = wait_for_process(create_pid, &status);
1675                 if (ret < 0)
1676                         return ret;
1677                 ret = handle_pre_create_hook_exit(status);
1678                 if (ret <= 0) /* error, or pre-create failed */
1679                         return ret;
1680         }
1681         create_rsync_argv(&rsync_argv, &current_snapshot_creation_time);
1682         ret = create_snapshot(rsync_argv);
1683         if (ret < 0)
1684                 goto out;
1685         ret = wait_for_process(create_pid, &status);
1686         if (ret < 0)
1687                 goto out;
1688         ret = handle_rsync_exit(status);
1689         if (ret < 0)
1690                 goto out;
1691         post_create_hook();
1692         if (create_pid)
1693                 ret = wait_for_process(create_pid, &status);
1694 out:
1695         free_rsync_argv(rsync_argv);
1696         return ret;
1697 }
1698 EXPORT_CMD_HANDLER(create);
1699
1700 static int com_ls(void)
1701 {
1702         int i;
1703         struct snapshot_list sl;
1704         struct snapshot *s;
1705
1706         dss_get_snapshot_list(&sl);
1707         FOR_EACH_SNAPSHOT(s, i, &sl) {
1708                 int64_t d = 0;
1709                 if (s->flags & SS_COMPLETE)
1710                         d = (s->completion_time - s->creation_time) / 60;
1711                 dss_msg("%u\t%s\t%3" PRId64 ":%02" PRId64 "\n", s->interval, s->name, d/60, d%60);
1712         }
1713         free_snapshot_list(&sl);
1714         return 1;
1715 }
1716 EXPORT_CMD_HANDLER(ls);
1717
1718 static int setup_signal_handling(void)
1719 {
1720         int ret;
1721
1722         DSS_INFO_LOG(("setting up signal handlers\n"));
1723         signal_pipe = signal_init(); /* always successful */
1724         ret = install_sighandler(SIGINT);
1725         if (ret < 0)
1726                 return ret;
1727         ret = install_sighandler(SIGTERM);
1728         if (ret < 0)
1729                 return ret;
1730         return install_sighandler(SIGCHLD);
1731 }
1732
1733 static void handle_version_and_help(void)
1734 {
1735         char *txt;
1736
1737         if (OPT_GIVEN(DSS, DETAILED_HELP))
1738                 txt = lls_long_help(CMD_PTR(DSS));
1739         else if (OPT_GIVEN(DSS, HELP))
1740                 txt = lls_short_help(CMD_PTR(DSS));
1741         else if (OPT_GIVEN(DSS, VERSION))
1742                 txt = dss_strdup(VERSION_STRING);
1743         else
1744                 return;
1745         printf("%s", txt);
1746         free(txt);
1747         exit(EXIT_SUCCESS);
1748 }
1749
1750 static void show_subcommand_summary(void)
1751 {
1752         const struct lls_command *cmd;
1753         int i;
1754
1755         printf("Available subcommands:\n");
1756         for (i = 1; (cmd = lls_cmd(i, dss_suite)); i++) {
1757                 const char *name = lls_command_name(cmd);
1758                 const char *purpose = lls_purpose(cmd);
1759                 printf("%-10s%s\n", name, purpose);
1760         }
1761         exit(EXIT_SUCCESS);
1762 }
1763
1764 int main(int argc, char **argv)
1765 {
1766         int ret;
1767         const struct lls_command *cmd = CMD_PTR(DSS);
1768         char *errctx = NULL;
1769         unsigned num_inputs;
1770         const struct dss_user_data *ud = NULL;
1771
1772         ret = lls_parse(argc, argv, cmd, &cmdline_lpr, &errctx);
1773         if (ret < 0) {
1774                 ret = lopsub_error(ret, &errctx);
1775                 goto out;
1776         }
1777         lpr = cmdline_lpr;
1778         ret = parse_config_file(false /* no SIGHUP */, cmd);
1779         if (ret < 0)
1780                 goto out;
1781         handle_version_and_help();
1782         num_inputs = lls_num_inputs(lpr);
1783         if (num_inputs == 0)
1784                 show_subcommand_summary();
1785         ret = lls_lookup_subcmd(argv[argc - num_inputs], dss_suite, &errctx);
1786         if (ret < 0) {
1787                 ret = lopsub_error(ret, &errctx);
1788                 goto out;
1789         }
1790         cmd = lls_cmd(ret, dss_suite);
1791         ret = lls_parse(num_inputs, argv + argc - num_inputs, cmd,
1792                 &cmdline_sublpr, &errctx);
1793         if (ret < 0) {
1794                 ret = lopsub_error(ret, &errctx);
1795                 goto out;
1796         }
1797         sublpr = cmdline_sublpr;
1798         ret = parse_config_file(false /* no SIGHUP */, cmd);
1799         if (ret < 0)
1800                 goto out;
1801         ret = check_config(cmd);
1802         if (ret < 0)
1803                 goto out;
1804         ret = setup_signal_handling();
1805         if (ret < 0)
1806                 goto out;
1807         ud = lls_user_data(cmd);
1808         ret = ud->handler();
1809         signal_shutdown();
1810 out:
1811         if (ret < 0) {
1812                 if (errctx)
1813                         DSS_ERROR_LOG(("%s\n", errctx));
1814                 DSS_EMERG_LOG(("%s\n", dss_strerror(-ret)));
1815         }
1816         free(errctx);
1817         lls_free_parse_result(lpr, CMD_PTR(DSS));
1818         if (lpr != cmdline_lpr)
1819                 lls_free_parse_result(cmdline_lpr, CMD_PTR(DSS));
1820         lls_free_parse_result(sublpr, cmd);
1821         if (sublpr != cmdline_sublpr)
1822                 lls_free_parse_result(cmdline_sublpr, cmd);
1823         exit(ret >= 0? EXIT_SUCCESS : EXIT_FAILURE);
1824 }