#include "git-compat-util.h"

#include "abspath.h"

#include "blob.h"

#include "chdir-notify.h"

#include "config.h"

#include "gettext.h"

#include "hex.h"

#include "lockfile.h"

#include "object-file.h"

#include "odb.h"

#include "odb/source.h"

#include "odb/source-files.h"

#include "odb/source-loose.h"

#include "pack-objects.h"

#include "packfile.h"

#include "path.h"

#include "promisor-remote.h"

#include "repack.h"

#include "run-command.h"

#include "strbuf.h"

#include "string-list.h"

#include "strmap.h"

#include "strvec.h"

#include "tree.h"

#include "write-or-die.h"

static void odb_source_files_reparent(const char *old_cwd,

              const char *new_cwd,

              void *cb_data)

{

  struct odb_source_files *files = cb_data;

  char *path = reparent_relative_path(old_cwd, new_cwd,

              files->base.path);

  free(files->base.path);

  files->base.path = path;

}

static void odb_source_files_free(struct odb_source *source)

{

  struct odb_source_files *files = odb_source_files_downcast(source);

  chdir_notify_unregister(odb_source_files_reparent, files);

  odb_source_free(&files->loose->base);

  odb_source_free(&files->packed->base);

  odb_source_release(&files->base);

  free(files);

}

static void odb_source_files_close(struct odb_source *source)

{

  struct odb_source_files *files = odb_source_files_downcast(source);

  odb_source_close(&files->loose->base);

  odb_source_close(&files->packed->base);

}

static int odb_source_files_create_on_disk(struct odb_source *source,

             const struct odb_create_on_disk_options *opts)

{

  struct lock_file alternates_lock = LOCK_INIT;

  struct strbuf path = STRBUF_INIT;

  struct strset seen = STRSET_INIT;

  struct strbuf line = STRBUF_INIT;

  int ret;

  safe_create_dir(source->odb->repo, source->path, 1);

  strbuf_addf(&path, "%s/pack", source->path);

  safe_create_dir(source->odb->repo, path.buf, 1);

  strbuf_reset(&path);

  strbuf_addf(&path, "%s/info", source->path);

  safe_create_dir(source->odb->repo, path.buf, 1);

  if (opts->alternates && opts->alternates->nr) {

    FILE *alternates, *orig;

    strbuf_reset(&path);

    strbuf_addf(&path, "%s/info/alternates", source->path);

    repo_hold_lock_file_for_update(source->odb->repo, &alternates_lock,

                 path.buf, LOCK_DIE_ON_ERROR);

    alternates = fdopen_lock_file(&alternates_lock, "w");

    if (!alternates) {

      ret = error_errno(_("unable to fdopen alternates lockfile"));

      goto out;

    }

    /*

     * The alternates file may already exist, e.g. when it has been

     * seeded from a template directory. Read any preexisting

     * entries so that we don't end up writing duplicates.

     */

    orig = fopen(path.buf, "r");

    if (orig) {

      while (strbuf_getline(&line, orig) != EOF) {

        strset_add(&seen, line.buf);

        fprintf(alternates, "%s\n", line.buf);

      }

      if (ferror(orig)) {

        ret = error_errno(_("unable to read alternates file"));

        fclose(orig);

        goto out;

      }

      fclose(orig);

    } else if (errno != ENOENT) {

      ret = error_errno(_("unable to read alternates file"));

      goto out;

    }

    for (size_t i = 0; i < opts->alternates->nr; i++) {

      const char *alternate = opts->alternates->v[i];

      if (!strset_add(&seen, alternate))

        continue;

      fprintf(alternates, "%s\n", alternate);

    }

    if (ferror(alternates)) {

      ret = error_errno(_("unable to write alternates file"));

      goto out;

    }

    if (commit_lock_file(&alternates_lock)) {

      ret = error_errno(_("unable to commit alternates file"));

      goto out;

    }

  }

  /* Reprepare the object database to activate alternates. */

  odb_reprepare(source->odb);

  ret = 0;

out:

  rollback_lock_file(&alternates_lock);

  strbuf_release(&line);

  strbuf_release(&path);

  strset_clear(&seen);

  return ret;

}

static void odb_source_files_prepare(struct odb_source *source,

             enum odb_prepare_flags flags)

{

  struct odb_source_files *files = odb_source_files_downcast(source);

  odb_source_prepare(&files->loose->base, flags);

  odb_source_prepare(&files->packed->base, flags);

}

static enum odb_read_status odb_source_files_read_object_info(struct odb_source *source,

                    const struct object_id *oid,

                    struct object_info *oi,

                    enum object_info_flags flags,

                    struct strbuf *errmsg)

{

  struct odb_source_files *files = odb_source_files_downcast(source);

  enum odb_read_status ret_packed, ret_loose;

  ret_packed = odb_source_read_object_info(&files->packed->base, oid, oi,

             flags, errmsg);

  if (!ret_packed)

    return 0;

  ret_loose = odb_source_read_object_info(&files->loose->base, oid, oi, flags,

            ret_packed == ODB_READ_NOT_FOUND ? errmsg : NULL);

  if (!ret_loose)

    return 0;

  /*

   * Reading the packed object may have failed even though the object

   * exists, for example because it is corrupt. Report this failure to

   * the caller in case neither of the sources was able to read the

   * object, and prefer the error of the packed source in case both

   * reads have failed.

   */

  if (ret_packed != ODB_READ_NOT_FOUND)

    return ret_packed;

  return ret_loose;

}

static int odb_source_files_read_object_stream(struct odb_stream **out,

                 struct odb_source *source,

                 const struct object_id *oid)

{

  struct odb_source_files *files = odb_source_files_downcast(source);

  if (!odb_source_read_object_stream(out, &files->packed->base, oid) ||

      !odb_source_read_object_stream(out, &files->loose->base, oid))

    return 0;

  return -1;

}

static int odb_source_files_for_each_object(struct odb_source *source,

              const struct object_info *request,

              odb_for_each_object_cb cb,

              void *cb_data,

              const struct odb_for_each_object_options *opts)

{

  struct odb_source_files *files = odb_source_files_downcast(source);

  int ret;

  if (!(opts->flags & ODB_FOR_EACH_OBJECT_PROMISOR_ONLY)) {

    ret = odb_source_for_each_object(&files->loose->base, request, cb, cb_data, opts);

    if (ret)

      return ret;

  }

  ret = odb_source_for_each_object(&files->packed->base, request, cb, cb_data, opts);

  if (ret)

    return ret;

  return 0;

}

static int odb_source_files_count_objects(struct odb_source *source,

            enum odb_count_objects_flags flags,

            unsigned long *out)

{

  struct odb_source_files *files = odb_source_files_downcast(source);

  unsigned long count;

  int ret;

  ret = odb_source_count_objects(&files->packed->base, flags, &count);

  if (ret < 0)

    goto out;

  if (!(flags & ODB_COUNT_OBJECTS_APPROXIMATE)) {

    unsigned long loose_count;

    ret = odb_source_count_objects(&files->loose->base, flags, &loose_count);

    if (ret < 0)

      goto out;

    count += loose_count;

  }

  *out = count;

  ret = 0;

out:

  return ret;

}

static int odb_source_files_find_abbrev_len(struct odb_source *source,

              const struct object_id *oid,

              unsigned min_len,

              unsigned *out)

{

  struct odb_source_files *files = odb_source_files_downcast(source);

  unsigned len = min_len;

  int ret;

  ret = odb_source_find_abbrev_len(&files->packed->base, oid, len, &len);

  if (ret < 0)

    goto out;

  ret = odb_source_find_abbrev_len(&files->loose->base, oid, len, &len);

  if (ret < 0)

    goto out;

  *out = len;

  ret = 0;

out:

  return ret;

}

static int odb_source_files_freshen_object(struct odb_source *source,

             const struct object_id *oid,

             const time_t *mtime)

{

  struct odb_source_files *files = odb_source_files_downcast(source);

  if (odb_source_freshen_object(&files->packed->base, oid, mtime) ||

      odb_source_freshen_object(&files->loose->base, oid, mtime))

    return 1;

  return 0;

}

static int odb_source_files_write_object(struct odb_source *source,

           const void *buf, size_t len,

           enum object_type type,

           const struct object_id *oid,

           const struct object_id *compat_oid,

           const time_t *mtime,

           enum odb_write_object_flags flags)

{

  struct odb_source_files *files = odb_source_files_downcast(source);

  return odb_source_write_object(&files->loose->base, buf, len, type,

               oid, compat_oid, mtime, flags);

}

static int odb_source_files_write_object_stream(struct odb_source *source,

            struct odb_stream *stream,

            struct object_id *oid)

{

  struct odb_source_files *files = odb_source_files_downcast(source);

  return odb_source_write_object_stream(&files->loose->base, stream, oid);

}

static int odb_source_files_begin_transaction(struct odb_source *source,

                struct odb_transaction **out,

                enum odb_transaction_flags flags)

{

  return odb_transaction_files_begin(source, out, flags);

}

static int odb_source_files_read_alternates(struct odb_source *source,

              struct strvec *out)

{

  struct strbuf buf = STRBUF_INIT;

  char *path;

  path = xstrfmt("%s/info/alternates", source->path);

  if (strbuf_read_file(&buf, path, 1024) < 0) {

    warn_on_fopen_errors(path);

    free(path);

    return 0;

  }

  parse_alternates(buf.buf, '\n', source->path, out);

  strbuf_release(&buf);

  free(path);

  return 0;

}

static int too_many_loose_objects(struct odb_source_files *files, int limit)

{

  unsigned long loose_count;

  if (limit <= 0)

    return 0;

  if (odb_source_count_objects(&files->loose->base, ODB_COUNT_OBJECTS_APPROXIMATE,

             &loose_count) < 0)

    return 0;

  /*

   * This is weird, but stems from legacy behaviour: the GC auto

   * threshold was always essentially interpreted as if it was rounded up

   * to the next multiple 256 of, so we retain this behaviour for now.

   */

  return loose_count > (DIV_ROUND_UP(((unsigned long) limit), 256) * 256);

}

static struct packed_git *find_base_packs(struct odb_source_files *files,

            struct string_list *packs,

            unsigned long limit)

{

  struct packfile_list_entry *e;

  struct packed_git *base = NULL;

  for (e = packfile_store_get_packs(files->packed); e; e = e->next) {

    if (e->pack->is_cruft)

      continue;

    if (limit) {

      if ((uintmax_t) e->pack->pack_size >= limit)

        string_list_append(packs, e->pack->pack_name);

    } else if (!base || base->pack_size < e->pack->pack_size) {

      base = e->pack;

    }

  }

  if (base)

    string_list_append(packs, base->pack_name);

  return base;

}

static int too_many_packs(struct odb_source_files *files, int gc_auto_pack_limit)

{

  struct packfile_list_entry *e;

  int cnt = 0;

  if (gc_auto_pack_limit <= 0)

    return 0;

  for (e = packfile_store_get_packs(files->packed); e; e = e->next) {

    if (e->pack->pack_keep)

      continue;

    /*

     * Perhaps check the size of the pack and count only

     * very small ones here?

     */

    cnt++;

  }

  return gc_auto_pack_limit < cnt;

}

static uint64_t total_ram(void)

{

#if defined(HAVE_SYSINFO)

  struct sysinfo si;

  if (!sysinfo(&si)) {

    uint64_t total = si.totalram;

    if (si.mem_unit > 1)

      total *= (uint64_t)si.mem_unit;

    return total;

  }

#elif defined(HAVE_BSD_SYSCTL) && (defined(HW_MEMSIZE) || defined(HW_PHYSMEM) || defined(HW_PHYSMEM64))

  uint64_t physical_memory;

  int mib[2];

  size_t length;

  mib[0] = CTL_HW;

# if defined(HW_MEMSIZE)

  mib[1] = HW_MEMSIZE;

# elif defined(HW_PHYSMEM64)

  mib[1] = HW_PHYSMEM64;

# else

  mib[1] = HW_PHYSMEM;

# endif

  length = sizeof(physical_memory);

  if (!sysctl(mib, 2, &physical_memory, &length, NULL, 0)) {

    if (length == 4) {

      uint32_t mem;

      if (!sysctl(mib, 2, &mem, &length, NULL, 0))

        physical_memory = mem;

    }

    return physical_memory;

  }

#elif defined(GIT_WINDOWS_NATIVE)

  MEMORYSTATUSEX memInfo;

  memInfo.dwLength = sizeof(MEMORYSTATUSEX);

  if (GlobalMemoryStatusEx(&memInfo))

    return memInfo.ullTotalPhys;

#endif

  return 0;

}

static uint64_t estimate_repack_memory(struct odb_source_files *files,

               struct packed_git *pack)

{

  unsigned long max_delta_cache_size = DEFAULT_DELTA_CACHE_SIZE;

  unsigned long delta_base_cache_limit = DEFAULT_DELTA_BASE_CACHE_LIMIT;

  unsigned long nr_objects;

  size_t os_cache, heap;

  if (odb_source_count_objects(&files->base, ODB_COUNT_OBJECTS_APPROXIMATE,

             &nr_objects) < 0)

    return 0;

  if (!pack || !nr_objects)

    return 0;

  repo_config_get_ulong(files->base.odb->repo, "pack.deltacachesize",

            &max_delta_cache_size);

  repo_config_get_ulong(files->base.odb->repo, "core.deltabasecachelimit",

            &delta_base_cache_limit);

  /*

   * First we have to scan through at least one pack.

   * Assume enough room in OS file cache to keep the entire pack

   * or we may accidentally evict data of other processes from

   * the cache.

   */

  os_cache = pack->pack_size + pack->index_size;

  /* then pack-objects needs lots more for book keeping */

  heap = sizeof(struct object_entry) * nr_objects;

  /*

   * internal rev-list --all --objects takes up some memory too,

   * let's say half of it is for blobs

   */

  heap += sizeof(struct blob) * nr_objects / 2;

  /*

   * and the other half is for trees (commits and tags are

   * usually insignificant)

   */

  heap += sizeof(struct tree) * nr_objects / 2;

  /* and then obj_hash[], underestimated in fact */

  heap += sizeof(struct object *) * nr_objects;

  /* revindex is used also */

  heap += (sizeof(off_t) + sizeof(uint32_t)) * nr_objects;

  /*

   * read_sha1_file() (either at delta calculation phase, or

   * writing phase) also fills up the delta base cache

   */

  heap += delta_base_cache_limit;

  /* and of course pack-objects has its own delta cache */

  heap += max_delta_cache_size;

  return os_cache + heap;

}

static int keep_one_pack(struct string_list_item *item, void *data)

{

  struct strvec *args = data;

  strvec_pushf(args, "--keep-pack=%s", basename(item->string));

  return 0;

}

static void add_repack_all_option(struct repository *repo,

          const struct odb_optimize_options *opts,

          struct string_list *keep_pack,

          struct strvec *args)

{

  char *repack_filter = NULL;

  char *repack_filter_to = NULL;

  repo_config_get_string(repo, "gc.repackfilter", &repack_filter);

  repo_config_get_string(repo, "gc.repackfilterto", &repack_filter_to);

  if (opts->prune_expire && !strcmp(opts->prune_expire, "now") &&

      !(opts->cruft_packs && opts->expire_to))

    strvec_push(args, "-a");

  else if (opts->cruft_packs) {

    strvec_push(args, "--cruft");

    if (opts->prune_expire)

      strvec_pushf(args, "--cruft-expiration=%s", opts->prune_expire);

    if (opts->max_cruft_size)

      strvec_pushf(args, "--max-cruft-size=%lu",

             opts->max_cruft_size);

    if (opts->expire_to)

      strvec_pushf(args, "--expire-to=%s", opts->expire_to);

  } else {

    strvec_push(args, "-A");

    if (opts->prune_expire)

      strvec_pushf(args, "--unpack-unreachable=%s", opts->prune_expire);

  }

  if (keep_pack)

    for_each_string_list(keep_pack, keep_one_pack, args);

  if (repack_filter && *repack_filter)

    strvec_pushf(args, "--filter=%s", repack_filter);

  if (repack_filter_to && *repack_filter_to)

    strvec_pushf(args, "--filter-to=%s", repack_filter_to);

  free(repack_filter);

  free(repack_filter_to);

}

static void add_repack_incremental_option(struct strvec *args)

{

  strvec_push(args, "--no-write-bitmap-index");

}

bool odb_source_files_optimize_required(struct odb_source *source,

          const struct odb_optimize_options *opts)

{

  struct odb_source_files *files = odb_source_files_downcast(source);

  struct repository *repo = source->odb->repo;

  switch (opts->strategy) {

  case ODB_OPTIMIZE_INCREMENTAL: {

    int gc_auto_threshold = 6700;

    int gc_auto_pack_limit = 50;

    repo_config_get_int(repo, "gc.auto", &gc_auto_threshold);

    repo_config_get_int(repo, "gc.autopacklimit", &gc_auto_pack_limit);

    /*

     * Setting gc.auto to 0 or negative can disable the

     * automatic gc.

     */

    if (gc_auto_threshold <= 0)

      return false;

    if (!too_many_packs(files, gc_auto_pack_limit) &&

        !too_many_loose_objects(files, gc_auto_threshold))

      return false;

    return true;

  }

  case ODB_OPTIMIZE_GEOMETRIC: {

    struct pack_geometry geometry = {

      .split_factor = 2,

    };

    struct pack_objects_args po_args = {

      .local = 1,

    };

    struct existing_packs existing_packs = EXISTING_PACKS_INIT;

    struct string_list kept_packs = STRING_LIST_INIT_DUP;

    int auto_value = 6700;

    bool ret;

    repo_config_get_int(repo, "maintenance.geometric-repack.auto",

            &auto_value);

    if (!auto_value)

      return false;

    if (auto_value < 0)

      return true;

    repo_config_get_int(repo, "maintenance.geometric-repack.splitFactor",

            &geometry.split_factor);

    existing_packs.repo = repo;

    existing_packs_collect(&existing_packs, &kept_packs);

    pack_geometry_init(&geometry, &existing_packs, &po_args);

    pack_geometry_split(&geometry);

    /*

     * When we'd merge at least two packs with one another we always

     * perform the repack.

     */

    if (geometry.split) {

      ret = true;

      goto out;

    }

    /*

     * Otherwise, we estimate the number of loose objects to determine

     * whether we want to create a new packfile or not.

     */

    if (too_many_loose_objects(files, auto_value)) {

      ret = true;

      goto out;

    }

    ret = false;

  out:

    existing_packs_release(&existing_packs);

    pack_geometry_release(&geometry);

    return ret;

  }

  default:

    BUG("unknown maintenance strategy '%d'", opts->strategy);

  }

}

int odb_source_files_optimize(struct odb_source *source,

            const struct odb_optimize_options *opts)

{

  struct odb_source_files *files = odb_source_files_downcast(source);

  struct repository *repo = source->odb->repo;

  struct child_process repack_cmd = CHILD_PROCESS_INIT;

  unsigned long big_pack_threshold = 0;

  int gc_auto_threshold = 6700;

  int gc_auto_pack_limit = 50;

  int ret;

  repo_config_get_int(repo, "gc.auto", &gc_auto_threshold);

  repo_config_get_int(repo, "gc.autopacklimit", &gc_auto_pack_limit);

  repo_config_get_ulong(repo, "gc.bigpackthreshold", &big_pack_threshold);

  if (repo->repository_format_precious_objects)

    return 0;

  repack_cmd.git_cmd = 1;

  repack_cmd.odb_to_close = repo->objects;

  strvec_pushl(&repack_cmd.args, "repack", "-d", "-l", NULL);

  if (opts->flags & ODB_OPTIMIZE_NO_REUSE_DELTAS)

    strvec_push(&repack_cmd.args, "-f");

  if (opts->depth > 0)

    strvec_pushf(&repack_cmd.args, "--depth=%d", opts->depth);

  if (opts->window > 0)

    strvec_pushf(&repack_cmd.args, "--window=%d", opts->window);

  if (!(opts->flags & ODB_OPTIMIZE_VERBOSE))

    strvec_push(&repack_cmd.args, "-q");

  /*

   * There's three cases we need to consider:

   *

   *   - If we're invoked without `--auto` we'll need to perform a full

   *     repack.

   *

   *   - If we're invoked with `--auto` and there's too many packs, then

   *     we perform a full repack, as well.

   *

   *   - Otherwise we perform an incremental repack.

   */

  switch (opts->strategy) {

  case ODB_OPTIMIZE_INCREMENTAL:

    if (!(opts->flags & ODB_OPTIMIZE_AUTO)) {

      struct string_list keep_pack = STRING_LIST_INIT_NODUP;

      if (opts->keep_largest_pack != -1) {

        if (opts->keep_largest_pack)

          find_base_packs(files, &keep_pack, 0);

      } else if (big_pack_threshold) {

        find_base_packs(files, &keep_pack, big_pack_threshold);

      }

      add_repack_all_option(repo, opts, &keep_pack, &repack_cmd.args);

      string_list_clear(&keep_pack, 0);

    } else {

      if (too_many_packs(files, gc_auto_pack_limit)) {

        struct string_list keep_pack = STRING_LIST_INIT_NODUP;

        if (big_pack_threshold) {

          find_base_packs(files, &keep_pack, big_pack_threshold);

          if (keep_pack.nr >= (unsigned long) gc_auto_pack_limit) {

            string_list_clear(&keep_pack, 0);

            find_base_packs(files, &keep_pack, 0);

          }

        } else {

          struct packed_git *p = find_base_packs(files, &keep_pack, 0);

          uint64_t mem_have, mem_want;

          mem_have = total_ram();

          mem_want = estimate_repack_memory(files, p);

          /*

           * Only allow 1/2 of memory for pack-objects, leave

           * the rest for the OS and other processes in the

           * system.

           */

          if (!mem_have || mem_want < mem_have / 2)

            string_list_clear(&keep_pack, 0);

        }

        add_repack_all_option(repo, opts, &keep_pack, &repack_cmd.args);

        string_list_clear(&keep_pack, 0);

      } else {

        add_repack_incremental_option(&repack_cmd.args);

      }

    }

    break;

  case ODB_OPTIMIZE_GEOMETRIC: {

    struct pack_geometry geometry = {

      .split_factor = 2,

    };

    struct pack_objects_args po_args = {

      .local = 1,

    };

    struct existing_packs existing_packs = EXISTING_PACKS_INIT;

    struct string_list kept_packs = STRING_LIST_INIT_DUP;

    repo_config_get_int(repo, "maintenance.geometric-repack.splitFactor",

            &geometry.split_factor);

    existing_packs.repo = repo;

    existing_packs_collect(&existing_packs, &kept_packs);

    pack_geometry_init(&geometry, &existing_packs, &po_args);

    pack_geometry_split(&geometry);

    if (geometry.split < geometry.pack_nr) {

      strvec_pushf(&repack_cmd.args, "--geometric=%d",

             geometry.split_factor);

    } else {

      add_repack_all_option(repo, opts, NULL, &repack_cmd.args);

    }

    if (repo->settings.core_multi_pack_index)

      strvec_push(&repack_cmd.args, "--write-midx");

    existing_packs_release(&existing_packs);

    pack_geometry_release(&geometry);

    break;

  }

  default:

    die("unknown maintenance strategy '%d'", opts->strategy);

  }

  if (run_command(&repack_cmd)) {

    ret = error("failed to run %s", repack_cmd.args.v[0]);

    goto out;

  }

  /* Geometric repacking uses cruft packs, so we don't have to prune separately. */

  if (opts->strategy != ODB_OPTIMIZE_GEOMETRIC && opts->prune_expire) {

    struct child_process prune_cmd = CHILD_PROCESS_INIT;

    strvec_pushl(&prune_cmd.args, "prune", "--expire", NULL);

    /* run `git prune` even if using cruft packs */

    strvec_push(&prune_cmd.args, opts->prune_expire);

    if (!(opts->flags & ODB_OPTIMIZE_VERBOSE))

      strvec_push(&prune_cmd.args, "--no-progress");

    if (repo_has_promisor_remote(repo))

      strvec_push(&prune_cmd.args,

            "--exclude-promisor-objects");

    prune_cmd.git_cmd = 1;

    if (run_command(&prune_cmd)) {

      ret = error("failed to run %s", prune_cmd.args.v[0]);

      goto out;

    }

  }

  if (opts->flags & ODB_OPTIMIZE_AUTO && too_many_loose_objects(files, gc_auto_threshold))

    warning(_("There are too many unreachable loose objects; "

      "run 'git prune' to remove them."));

  ret = 0;

out:

  return ret;

}

struct odb_pack_generator_files {

  struct odb_pack_generator base;

  struct child_process cp;

};

static int odb_pack_generator_files_finish(struct odb_pack_generator *_generator)

{

  struct odb_pack_generator_files *generator =

    (struct odb_pack_generator_files *)_generator;

  int ret;

  ret = finish_command(&generator->cp);

  free(generator);

  if (ret) {

    /*

     * On failure, pack-objects is expected to have written a

     * useful error message to its standard error stream already.

     * Death by signal is worth mentioning, though, with the

     * exception of SIGPIPE: that is a normal occurrence when the

     * consumer of the pack hangs up.

     */

    if (ret > 128 && ret - 128 == SIGPIPE)

      return -1;

    if (ret > 128)

      error(_("pack-objects died of signal %d"), ret - 128);

    return -1;

  }

  return 0;

}

static int odb_source_files_generate_pack(struct odb_source *source UNUSED,

            struct odb_pack_generator **out,

            const struct odb_generate_pack_options *opts)

{

  struct odb_pack_generator_files *generator;

  struct child_process *cp;

  FILE *in;

  CALLOC_ARRAY(generator, 1);

  child_process_init(&generator->cp);

  cp = &generator->cp;

  /*

   * The hook is expected to spawn "$hook git pack-objects <args...>"

   * and to behave like git-pack-objects(1) would have. This can for

   * example be used to serve precomputed packfiles.

   */

  if (opts->pack_objects_hook) {

    strvec_push(&cp->args, opts->pack_objects_hook);

    strvec_push(&cp->args, "git");

    cp->use_shell = 1;

  } else {

    cp->git_cmd = 1;

  }

  /*

   * The caller-provided shallow boundary overrides any shallow state

   * that the repository itself may have, so the shallow file needs to

   * be neutralized.

   */

  if (opts->shallows.nr) {

    strvec_push(&cp->args, "--shallow-file");

    strvec_push(&cp->args, "");

  }

  strvec_push(&cp->args, "pack-objects");

  strvec_push(&cp->args, "--revs");

  strvec_push(&cp->args, "--stdout");

  if (opts->thin)

    strvec_push(&cp->args, "--thin");

  if (opts->shallow)

    strvec_push(&cp->args, "--shallow");

  if (opts->ofs_delta)

    strvec_push(&cp->args, "--delta-base-offset");

  if (opts->include_tag)

    strvec_push(&cp->args, "--include-tag");

  if (opts->missing_allow_promisor)

    strvec_push(&cp->args, "--missing=allow-promisor");

  if (opts->disable_bitmaps)

    strvec_push(&cp->args, "--no-use-bitmap-index");

  switch (opts->progress) {

  case ODB_GENERATE_PACK_PROGRESS_NONE:

    strvec_push(&cp->args, "--quiet");

    break;

  case ODB_GENERATE_PACK_PROGRESS_STANDARD:

    strvec_push(&cp->args, "--progress");

    break;

  case ODB_GENERATE_PACK_PROGRESS_VERBOSE:

    strvec_push(&cp->args, "--all-progress");

    break;

  default:

    BUG("unknown progress option %d", opts->progress);

  }

  if (opts->filter_spec)

    strvec_pushf(&cp->args, "--filter=%s", opts->filter_spec);

  if (opts->uri_protocols)

    for (size_t i = 0; i < opts->uri_protocols->nr; i++)

      strvec_pushf(&cp->args, "--uri-protocol=%s",

             opts->uri_protocols->items[i].string);

  cp->in = -1;

  cp->out = opts->pack_fd;

  cp->err = opts->progress_fd;

  cp->clean_on_exit = 1;

  if (start_command(cp)) {

    free(generator);

    return error(_("could not spawn pack-objects"));

  }

  /*

   * Feed the objects to pack-objects. This is safe to do synchronously

   * because pack-objects consumes all of its standard input before it

   * starts to generate the pack.

   */