Merge branch 'master' into next

* master:
  Simplify split_args().

diff --combined dss.c
index 4396e6e5975c79d2806aa39625fea99d23a2ee90,217dfafd25c55741e564c0feb13c1ccfbad317d0..1354aa757128d1ec6069290f7c8303991e6eeb5c
--- 1/dss.c
--- 2/dss.c
+++ b/dss.c
@@@ -651,7 -651,6 +651,7 @@@ static struct snapshot *find_oldest_rem
        int i, num_complete;
        struct snapshot *s, *ref = NULL;
  
 +      DSS_DEBUG_LOG(("picking snapshot with earliest creation time\n"));
        num_complete = num_complete_snapshots(sl);
        if (num_complete <= OPT_UINT32_VAL(DSS, MIN_COMPLETE))
                return NULL;
@@@ -662,6 -661,7 +662,6 @@@
                        ref = s;
                        continue;
                }
 -              DSS_INFO_LOG(("oldest removable snapshot: %s\n", s->name));
                return s;
        }
        assert(ref);
@@@ -669,50 -669,6 +669,50 @@@
        return ref;
  }
  
 +/* returns NULL <==> *reason is set to NULL */
 +static struct snapshot *find_removable_snapshot(struct snapshot_list *sl,
 +              bool try_hard, char **reason)
 +{
 +      struct snapshot *victim;
 +
 +      /*
 +       * Don't remove anything if there is free space and we have fewer
 +       * snapshots than configured, plus one. This way there is always one
 +       * snapshot that can be recycled.
 +       */
 +      if (!try_hard && sl->num_snapshots <=
 +                      1 << OPT_UINT32_VAL(DSS, NUM_INTERVALS))
 +              goto nope;
 +      victim = find_orphaned_snapshot(sl);
 +      if (victim) {
 +              *reason = make_message("orphaned");
 +              return victim;
 +      }
 +      victim = find_outdated_snapshot(sl);
 +      if (victim) {
 +              *reason = make_message("outdated");
 +              return victim;
 +      }
 +      if (!OPT_GIVEN(DSS, KEEP_REDUNDANT)) {
 +              victim = find_redundant_snapshot(sl);
 +              if (victim) {
 +                      *reason = make_message("redundant");
 +                      return victim;
 +              }
 +      }
 +      if (!try_hard)
 +              goto nope;
 +      DSS_WARNING_LOG(("nothing obvious to remove\n"));
 +      victim = find_oldest_removable_snapshot(sl);
 +      if (victim) {
 +              *reason = make_message("oldest");
 +              return victim;
 +      }
 +nope:
 +      *reason = NULL;
 +      return NULL;
 +}
 +
  static int rename_incomplete_snapshot(int64_t start)
  {
        char *old_name;
@@@ -745,7 -701,7 +745,7 @@@ static int try_to_free_disk_space(void
        struct snapshot_list sl;
        struct snapshot *victim;
        struct timeval now;
 -      const char *why;
 +      char *why;
        int low_disk_space;
  
        ret = disk_space_low(NULL);
@@@ -756,25 -712,55 +756,25 @@@
        if (tv_diff(&next_removal_check, &now, NULL) > 0)
                return 0;
        if (!low_disk_space) {
 -              if (OPT_GIVEN(DSS, KEEP_REDUNDANT))
 -                      return 0;
                if (snapshot_creation_status != HS_READY)
                        return 0;
                if (next_snapshot_is_due())
                        return 0;
        }
 -      /*
 -       * Idle and --keep_redundant not given, or low disk space. Look at
 -       * existing snapshots.
 -       */
 +      /* Idle or low disk space, look at existing snapshots. */
        dss_get_snapshot_list(&sl);
 -      ret = 0;
 -      /*
 -       * Don't remove anything if there is free space and we have fewer
 -       * snapshots than configured, plus one. This way there is always one
 -       * snapshot that can be recycled.
 -       */
 -      if (!low_disk_space && sl.num_snapshots <=
 -                      1 << OPT_UINT32_VAL(DSS, NUM_INTERVALS))
 -              goto out;
 -      why = "outdated";
 -      victim = find_outdated_snapshot(&sl);
 -      if (victim)
 -              goto remove;
 -      why = "redundant";
 -      victim = find_redundant_snapshot(&sl);
 -      if (victim)
 -              goto remove;
 -      why = "orphaned";
 -      victim = find_orphaned_snapshot(&sl);
 +      victim = find_removable_snapshot(&sl, low_disk_space, &why);
 +      if (victim) {
 +              pre_remove_hook(victim, why);
 +              free(why);
 +      }
 +      free_snapshot_list(&sl);
        if (victim)
 -              goto remove;
 -      /* try harder only if disk space is low */
 +              return 1;
        if (!low_disk_space)
 -              goto out;
 -      DSS_WARNING_LOG(("disk space low and nothing obvious to remove\n"));
 -      why = "oldest";
 -      victim = find_oldest_removable_snapshot(&sl);
 -      if (victim)
 -              goto remove;
 +              return 0;
        DSS_CRIT_LOG(("uhuhu: disk space low and nothing to remove\n"));
 -      ret = -ERRNO_TO_DSS_ERROR(ENOSPC);
 -      goto out;
 -remove:
 -      pre_remove_hook(victim, why);
 -out:
 -      free_snapshot_list(&sl);
 -      return ret;
 +      return -ERRNO_TO_DSS_ERROR(ENOSPC);
  }
  
  static void post_create_hook(void)
@@@ -1581,7 -1567,7 +1581,7 @@@ static void exit_hook(int exit_code
  {
        pid_t pid;
        char **argv, *tmp = dss_strdup(OPT_STRING_VAL(DSS, EXIT_HOOK));
-       unsigned n = split_args(tmp, &argv, " \t");
+       unsigned n = split_args(tmp, &argv);
  
        n++;
        argv = dss_realloc(argv, (n + 1) * sizeof(char *));
@@@ -1659,55 -1645,55 +1659,55 @@@ static int com_prune(void
        struct snapshot_list sl;
        struct snapshot *victim;
        struct disk_space ds;
 -      const char *why;
 +      char *why;
 +      bool try_hard;
  
        lock_dss_or_die();
 -      ret = get_disk_space(".", &ds);
 -      if (ret < 0)
 -              return ret;
 -      log_disk_space(&ds);
 +      switch (OPT_UINT32_VAL(PRUNE, DISK_SPACE)) {
 +      case FDS_LOW: try_hard = true; break;
 +      case FDS_HIGH: try_hard = false; break;
 +      default:
 +              ret = get_disk_space(".", &ds);
 +              if (ret < 0)
 +                      return ret;
 +              log_disk_space(&ds);
 +              try_hard = disk_space_low(&ds);
 +      }
        dss_get_snapshot_list(&sl);
 -      why = "outdated";
 -      victim = find_outdated_snapshot(&sl);
 -      if (victim)
 -              goto rm;
 -      why = "redundant";
 -      victim = find_redundant_snapshot(&sl);
 -      if (victim)
 -              goto rm;
 -      ret = 0;
 -      goto out;
 -rm:
 +      victim = find_removable_snapshot(&sl, try_hard, &why);
 +      if (!victim) {
 +              dss_msg("nothing to prune\n");
 +              ret = 0;
 +              goto free_sl;
 +      }
        if (OPT_GIVEN(DSS, DRY_RUN)) {
 -              dss_msg("%s snapshot %s (interval = %i)\n",
 +              dss_msg("picking %s snapshot %s (interval = %i)\n",
                        why, victim->name, victim->interval);
                ret = 0;
 -              goto out;
 +              goto free_why;
        }
        pre_remove_hook(victim, why);
        if (snapshot_removal_status == HS_PRE_RUNNING) {
                ret = wait_for_remove_process();
                if (ret < 0)
 -                      goto out;
 +                      goto free_why;
 +              ret = -E_HOOK_FAILED;
                if (snapshot_removal_status != HS_PRE_SUCCESS)
 -                      goto out;
 +                      goto free_why;
        }
        ret = exec_rm();
        if (ret < 0)
 -              goto out;
 +              goto free_why;
        ret = wait_for_remove_process();
        if (ret < 0)
 -              goto out;
 -      if (snapshot_removal_status != HS_SUCCESS)
 -              goto out;
 +              goto free_why;
 +      assert(snapshot_removal_status == HS_SUCCESS);
        post_remove_hook();
 -      if (snapshot_removal_status != HS_POST_RUNNING)
 -              goto out;
 +      assert(snapshot_removal_status == HS_POST_RUNNING);
        ret = wait_for_remove_process();
 -      if (ret < 0)
 -              goto out;
 -      ret = 1;
 -out:
 +free_why:
 +      free(why);
 +free_sl:
        free_snapshot_list(&sl);
        return ret;
  }