+ * "git maintenance" scheduler learned to use systemd timers as a

+ possible backend.

+

+ * "git diff --submodule=diff" showed failure from run_command() when

+ trying to run diff inside a submodule, when the user manually

+ removes the submodule directory.

+

+ * "git bundle unbundle" learned to show progress display.

+

+ * In cone mode, the sparse-index code path learned to remove ignored

+ files (like build artifacts) outside the sparse cone, allowing the

+ entire directory outside the sparse cone to be removed, which is

+ especially useful when the sparse patterns change.

+

+ * Teach "test_pause" and "debug" helpers to allow using the HOME and

+ TERM environment variables the user usually uses.

+

+ * "make INSTALL_STRIP=-s install" allows the installation step to use

+ "install -s" to strip the binaries as they get installed.

+

+ * Code that handles large number of refs in the "git fetch" code

+ path has been optimized.

+

+ * The reachability bitmap file used to be generated only for a single

+ pack, but now we've learned to generate bitmaps for history that

+ span across multiple packfiles.

+

+ * The code to make "git grep" recurse into submodules has been

+ updated to migrate away from the "add submodule's object store as

+ an alternate object store" mechanism (which is suboptimal).

+

+ * The tracing of process ancestry information has been enhanced.

+

+ * Reduce number of write(2) system calls while sending the

+ ref advertisement.

+

+ * Update the build procedure to use the "-pedantic" build when

+ DEVELOPER makefile macro is in effect.

+

+ * Large part of "git submodule add" gets rewritten in C.

+

+ * The run-command API has been updated so that the callers can easily

+ ask the file descriptors open for packfiles to be closed immediately

+ before spawning commands that may trigger auto-gc.

+

+ * Recent "diff -m" changes broke "gitk", which has been corrected.

+ (merge 5acffd3473 so/diff-index-regression-fix later to maint).

+

+ * Regression fix.

+ (merge b996f84989 ab/send-email-config-fix later to maint).

+

+ * The "git apply -3" code path learned not to bother the lower level

+ merge machinery when the three-way merge can be trivially resolved

+ without the content level merge. This fixes a regression caused by

+ recent "-3way first and fall back to direct application" change.

+ (merge 57f183b698 jc/trivial-threeway-binary-merge later to maint).

+

+ * The code that optionally creates the *.rev reverse index file has

+ been optimized to avoid needless computation when it is not writing

+ the file out.

+ (merge 8fe8bae9d2 ab/reverse-midx-optim later to maint).

+

+ * "git range-diff -I... <range> <range>" segfaulted, which has been

+ corrected.

+ (merge 709b3f32d3 rs/range-diff-avoid-segfault-with-I later to maint).

+

+ * The order in which various files that make up a single (conceptual)

+ packfile has been reevaluated and straightened up. This matters in

+ correctness, as an incomplete set of files must not be shown to a

+ running Git.

+ (merge 4bc1fd6e39 tb/pack-finalize-ordering later to maint).

+

+ * The "mode" word is useless in a call to open(2) that does not

+ create a new file. Such a call in the files backend of the ref

+ subsystem has been cleaned up.

+ (merge 35cf94eaf6 rs/no-mode-to-open-when-appending later to maint).

+

+ (merge ca0cc98e03 bs/doc-bugreport-outdir later to maint).

+ (merge 72b113e562 ab/no-more-check-bindir later to maint).

+ (merge 92a5d1c9b4 jc/prefix-filename-allocates later to maint).

+ (merge d9a65b6c0a rs/setup-use-xopen-and-xdup later to maint).

+ (merge e8f55568de jk/t5562-racefix later to maint).

+ Revert contents of files involved in the am operation to their

+ pre-am state.

+ Place the resulting bug report file in `<path>` instead of the current

+ directory.

+'git bundle' unbundle [--progress] <file> [<refname>...]

+--progress-title::

+ For internal use only.

++

+Set the title of the progress bar. The title is "Receiving objects" by

+default and "Indexing objects" when `--stdin` is specified.

+

+--scheduler=auto|crontab|systemd-timer|launchctl|schtasks::

+ When combined with the `start` subcommand, specify the scheduler

+ for running the hourly, daily and weekly executions of

+ `git maintenance run`.

+ Possible values for `<scheduler>` are `auto`, `crontab`

+ (POSIX), `systemd-timer` (Linux), `launchctl` (macOS), and

+ `schtasks` (Windows). When `auto` is specified, the

+ appropriate platform-specific scheduler is used; on Linux,

+ `systemd-timer` is used if available, otherwise

+ `crontab`. Default is `auto`.

+

+BACKGROUND MAINTENANCE ON LINUX SYSTEMD SYSTEMS

+-----------------------------------------------

+

+While Linux supports `cron`, depending on the distribution, `cron` may

+be an optional package not necessarily installed. On modern Linux

+distributions, systemd timers are superseding it.

+

+If user systemd timers are available, they will be used as a replacement

+of `cron`.

+

+In this case, `git maintenance start` will create user systemd timer units

+and start the timers. The current list of user-scheduled tasks can be found

+by running `systemctl --user list-timers`. The timers written by `git

+maintenance start` are similar to this:

+

+-----------------------------------------------------------------------

+$ systemctl --user list-timers

+NEXT LEFT LAST PASSED UNIT ACTIVATES

+Thu 2021-04-29 19:00:00 CEST 42min left Thu 2021-04-29 18:00:11 CEST 17min ago git-maintenance@hourly.timer git-maintenance@hourly.service

+Fri 2021-04-30 00:00:00 CEST 5h 42min left Thu 2021-04-29 00:00:11 CEST 18h ago git-maintenance@daily.timer git-maintenance@daily.service

+Mon 2021-05-03 00:00:00 CEST 3 days left Mon 2021-04-26 00:00:11 CEST 3 days ago git-maintenance@weekly.timer git-maintenance@weekly.service

+-----------------------------------------------------------------------

+

+One timer is registered for each `--schedule=<frequency>` option.

+

+The definition of the systemd units can be inspected in the following files:

+

+-----------------------------------------------------------------------

+~/.config/systemd/user/git-maintenance@.timer

+~/.config/systemd/user/git-maintenance@.service

+~/.config/systemd/user/timers.target.wants/git-maintenance@hourly.timer

+~/.config/systemd/user/timers.target.wants/git-maintenance@daily.timer

+~/.config/systemd/user/timers.target.wants/git-maintenance@weekly.timer

+-----------------------------------------------------------------------

+

+`git maintenance start` will overwrite these files and start the timer

+again with `systemctl --user`, so any customization should be done by

+creating a drop-in file, i.e. a `.conf` suffixed file in the

+`~/.config/systemd/user/git-maintenance@.service.d` directory.

+

+`git maintenance stop` will stop the user systemd timers and delete

+the above mentioned files.

+

+For more details, see `systemd.timer(5)`.

+

+

+ [--preferred-pack=<pack>] [--[no-]bitmap] <subcommand>

++

+`<dir>` must be an alternate of the current repository.

+ multiple packs contain the same object. `<pack>` must

+ contain at least one object. If not given, ties are

+ broken in favor of the pack with the lowest mtime.

+

+ --[no-]bitmap::

+ Control whether or not a multi-pack bitmap is written.

+* Write a MIDX file for the packfiles in the current .git folder with a

+corresponding bitmap.

++

+-------------------------------------------------------------

+$ git multi-pack-index write --preferred-pack=<pack> --bitmap

+-------------------------------------------------------------

+

+--http-backend-info-refs::

+ Used by linkgit:git-http-backend[1] to serve up

+ `$GIT_URL/info/refs?service=git-receive-pack` requests. See

+ `--http-backend-info-refs` in linkgit:git-upload-pack[1].

+

+When changing the sparse-checkout patterns in cone mode, Git will inspect each

+tracked directory that is not within the sparse-checkout cone to see if it

+contains any untracked files. If all of those files are ignored due to the

+`.gitignore` patterns, then the directory will be deleted. If any of the

+untracked files within that directory is not ignored, then no deletions will

+occur within that directory and a warning message will appear. If these files

+are important, then reset your sparse-checkout definition so they are included,

+use `git add` and `git commit` to store them, then remove any remaining files

+manually to ensure Git can behave optimally.

+

+--http-backend-info-refs::

+ Used by linkgit:git-http-backend[1] to serve up

+ `$GIT_URL/info/refs?service=git-upload-pack` requests. See

+ "Smart Clients" in link:technical/http-protocol.html[the HTTP

+ transfer protocols] documentation and "HTTP Transport" in

+ link:technical/protocol-v2.html[the Git Wire Protocol, Version

+ 2] documentation. Also understood by

+ linkgit:git-receive-pack[1].

+== Pack and multi-pack bitmaps

+

+Bitmaps store reachability information about the set of objects in a packfile,

+or a multi-pack index (MIDX). The former is defined obviously, and the latter is

+defined as the union of objects in packs contained in the MIDX.

+

+A bitmap may belong to either one pack, or the repository's multi-pack index (if

+it exists). A repository may have at most one bitmap.

+

+An object is uniquely described by its bit position within a bitmap:

+

+ - If the bitmap belongs to a packfile, the __n__th bit corresponds to

+ the __n__th object in pack order. For a function `offset` which maps

+ objects to their byte offset within a pack, pack order is defined as

+ follows:

+

+ o1 <= o2 <==> offset(o1) <= offset(o2)

+

+ - If the bitmap belongs to a MIDX, the __n__th bit corresponds to the

+ __n__th object in MIDX order. With an additional function `pack` which

+ maps objects to the pack they were selected from by the MIDX, MIDX order

+ is defined as follows:

+

+ o1 <= o2 <==> pack(o1) <= pack(o2) /\ offset(o1) <= offset(o2)

+

+ The ordering between packs is done according to the MIDX's .rev file.

+ Notably, the preferred pack sorts ahead of all other packs.

+

+The on-disk representation (described below) of a bitmap is the same regardless

+of whether or not that bitmap belongs to a packfile or a MIDX. The only

+difference is the interpretation of the bits, which is described above.

+

+Certain bitmap extensions are supported (see: Appendix B). No extensions are

+required for bitmaps corresponding to packfiles. For bitmaps that correspond to

+MIDXs, both the bit-cache and rev-cache extensions are required.

+

+== On-disk format

+

+ This flag must always be present. It implies that the

+ bitmap index has been generated for a packfile or

+ multi-pack index (MIDX) with full closure (i.e. where

+ every single object in the packfile/MIDX can find its

+ parent links inside the same packfile/MIDX). This is a

+ requirement for the bitmap index format, also present in

+ JGit, that greatly reduces the complexity of the

+ implementation.

+ pack/MIDX. The format and meaning of the name-hash is

+ The SHA1 checksum of the pack/MIDX this bitmap index

+ belongs to.

+ in the packfile or multi-pack index is of that type.

+ The position **in the index for the packfile or

+ multi-pack index** where the bitmap for this commit is

+ found.

+a cache of 32-bit values, one per object in the pack/MIDX. The value at

+(counting in index or multi-pack index order) in the pack/MIDX can be found.

+This can be fed into the delta heuristics to compare objects with similar

+pathnames.

+Uses the `--http-backend-info-refs` option to

+linkgit:git-upload-pack[1].

+

+- If the multi-pack-index is extended to store a "stable object order"

+ even as the multi-pack-index is updated) then MIDX bitmaps could be

+ updated independently of the MIDX.

+Uses the `--http-backend-info-refs` option to

+linkgit:git-upload-pack[1].

+

+# INSTALL_STRIP can be set to "-s" to strip binaries during installation,

+# if your $(INSTALL) command supports the option.

+#

+# no-pedantic:

+# Disable -pedantic compilation.

+FOUND_SOURCE_FILES = $(shell $(FIND_SOURCE_FILES))

+$(ETAGS_TARGET): $(FOUND_SOURCE_FILES)

+ $(QUIET_GEN)$(RM) $@+ && \

+ echo $(FOUND_SOURCE_FILES) | xargs etags -a -o $@+ && \

+ mv $@+ $@

+tags: $(FOUND_SOURCE_FILES)

+ $(QUIET_GEN)$(RM) $@+ && \

+ echo $(FOUND_SOURCE_FILES) | xargs ctags -a -o $@+ && \

+ mv $@+ $@

+

+cscope.out: $(FOUND_SOURCE_FILES)

+ $(QUIET_GEN)$(RM) $@+ && \

+ echo $(FOUND_SOURCE_FILES) | xargs cscope -f$@+ -b && \

+ mv $@+ $@

+

+.PHONY: cscope

+cscope: cscope.out

+FOUND_C_SOURCES = $(filter %.c,$(FOUND_SOURCE_FILES))

+install_bindir_xprograms := $(patsubst %,%$X,$(BINDIR_PROGRAMS_NEED_X))

+install_bindir_programs := $(install_bindir_xprograms) $(BINDIR_PROGRAMS_NO_X)

+INSTALL_STRIP =

+

+ $(INSTALL) $(INSTALL_STRIP) $(PROGRAMS) '$(DESTDIR_SQ)$(gitexec_instdir_SQ)'

+ $(INSTALL) $(SCRIPTS) '$(DESTDIR_SQ)$(gitexec_instdir_SQ)'

+ $(INSTALL) $(INSTALL_STRIP) $(install_bindir_xprograms) '$(DESTDIR_SQ)$(bindir_SQ)'

+ $(INSTALL) $(BINDIR_PROGRAMS_NO_X) '$(DESTDIR_SQ)$(bindir_SQ)'

+

+ done

+.PHONY: FORCE

+static int resolve_to(struct image *image, const struct object_id *result_id)

+{

+ unsigned long size;

+ enum object_type type;

+

+ clear_image(image);

+

+ image->buf = read_object_file(result_id, &type, &size);

+ if (!image->buf || type != OBJ_BLOB)

+ die("unable to read blob object %s", oid_to_hex(result_id));

+ image->len = size;

+

+ return 0;

+}

+

+ /* resolve trivial cases first */

+ if (oideq(base, ours))

+ return resolve_to(image, theirs);

+ else if (oideq(base, theirs) || oideq(ours, theirs))

+ return resolve_to(image, ours);

+

+#include "dir.h"

+ /*

+ * The .gitattributes file only applies to files within its

+ * parent directory. In the case of cone-mode sparse-checkout,

+ * the .gitattributes file is sparse if and only if all paths

+ * within that directory are also sparse. Thus, don't load the

+ * .gitattributes file since it will not matter.

+ *

+ * In the case of a sparse index, it is critical that we don't go

+ * looking for a .gitattributes file, as doing so would cause the

+ * index to expand.

+ */

+ if (!path_in_cone_mode_sparse_checkout(path, istate))

+ return NULL;

+

+ !path_in_sparse_checkout(path, &the_index)) {

+ if (clean_index(&curr_head, &orig_head))

+ die(_("failed to clean index"));

+ int progress = isatty(2);

+

+ OPT_BOOL(0, "progress", &progress,

+ N_("show progress meter")),

+ struct strvec extra_index_pack_args = STRVEC_INIT;

+ if (progress)

+ strvec_pushl(&extra_index_pack_args, "-v", "--progress-title",

+ _("Unbundling objects"), NULL);

+ ret = !!unbundle(the_repository, &header, bundle_fd,

+ &extra_index_pack_args) ||

+static const struct object_id *iterate_ref_map(void *cb_data)

+ return NULL;

+ return &ref->old_oid;

+ dir = git_url_basename(repo_name, is_bundle, option_bare);

+ strip_dir_trailing_slashes(dir);

+ * We need (some of) diff for merges options (e.g., --cc), and we need

+ * to avoid conflict with our own meaning of "-m".

+ diff_merges_suppress_m_parsing();

+ if (!repo_has_object_file(the_repository, &ref->new_oid))

+static const struct object_id *iterate_ref_map(void *cb_data)

+ return NULL;

+ return &ref->old_oid;

+ struct commit *commit = NULL;

+ /*

+ * References in "refs/tags/" are often going to point

+ * to annotated tags, which are not part of the

+ * commit-graph. We thus only try to look up refs in

+ * the graph which are not in that namespace to not

+ * regress performance in repositories with many

+ * annotated tags.

+ */

+ if (!starts_with(rm->name, "refs/tags/"))

+ commit = lookup_commit_in_graph(the_repository, &rm->old_oid);

+ if (!commit) {

+ commit = lookup_commit_reference_gently(the_repository,

+ &rm->old_oid,

+ 1);

+ if (!commit)

+ rm->fetch_head_status = FETCH_HEAD_NOT_FOR_MERGE;

+ }

+static int fetch_and_consume_refs(struct transport *transport, struct ref *ref_map)

+ int connectivity_checked = 1;

+ int ret;

+

+ /*

+ * We don't need to perform a fetch in case we can already satisfy all

+ * refs.

+ */

+ ret = check_exist_and_connected(ref_map);

+ if (ret)

+ goto out;

+ connectivity_checked = transport->smart_options ?

+ transport->smart_options->connectivity_checked : 0;

+

+out:

+ transport_unlock_pack(transport);

+ fetch_and_consume_refs(transport, ref_map);

+ if (fetch_and_consume_refs(transport, ref_map)) {

+ if (run_command_v_opt(repack.v,

+ RUN_GIT_CMD | RUN_CLOSE_OBJECT_STORE))

+ child.git_cmd = child.close_object_store = 1;

+ child.git_cmd = child.close_object_store = 1;

+ child.git_cmd = child.close_object_store = 1;

+ child.git_cmd = child.close_object_store = 1;

+/*

+ * get_schedule_cmd` reads the GIT_TEST_MAINT_SCHEDULER environment variable

+ * to mock the schedulers that `git maintenance start` rely on.

+ *

+ * For test purpose, GIT_TEST_MAINT_SCHEDULER can be set to a comma-separated

+ * list of colon-separated key/value pairs where each pair contains a scheduler

+ * and its corresponding mock.

+ *

+ * * If $GIT_TEST_MAINT_SCHEDULER is not set, return false and leave the

+ * arguments unmodified.

+ *

+ * * If $GIT_TEST_MAINT_SCHEDULER is set, return true.

+ * In this case, the *cmd value is read as input.

+ *

+ * * if the input value *cmd is the key of one of the comma-separated list

+ * item, then *is_available is set to true and *cmd is modified and becomes

+ * the mock command.

+ *

+ * * if the input value *cmd isn’t the key of any of the comma-separated list

+ * item, then *is_available is set to false.

+ *

+ * Ex.:

+ * GIT_TEST_MAINT_SCHEDULER not set

+ * +-------+-------------------------------------------------+

+ * | Input | Output |

+ * | *cmd | return code | *cmd | *is_available |

+ * +-------+-------------+-------------------+---------------+

+ * | "foo" | false | "foo" (unchanged) | (unchanged) |

+ * +-------+-------------+-------------------+---------------+

+ *

+ * GIT_TEST_MAINT_SCHEDULER set to “foo:./mock_foo.sh,bar:./mock_bar.sh”

+ * +-------+-------------------------------------------------+

+ * | Input | Output |

+ * | *cmd | return code | *cmd | *is_available |

+ * +-------+-------------+-------------------+---------------+

+ * | "foo" | true | "./mock.foo.sh" | true |

+ * | "qux" | true | "qux" (unchanged) | false |

+ * +-------+-------------+-------------------+---------------+

+ */

+static int get_schedule_cmd(const char **cmd, int *is_available)

+{

+ char *testing = xstrdup_or_null(getenv("GIT_TEST_MAINT_SCHEDULER"));

+ struct string_list_item *item;

+ struct string_list list = STRING_LIST_INIT_NODUP;

+

+ if (!testing)

+ return 0;

+

+ if (is_available)

+ *is_available = 0;

+

+ string_list_split_in_place(&list, testing, ',', -1);

+ for_each_string_list_item(item, &list) {

+ struct string_list pair = STRING_LIST_INIT_NODUP;

+

+ if (string_list_split_in_place(&pair, item->string, ':', 2) != 2)

+ continue;

+

+ if (!strcmp(*cmd, pair.items[0].string)) {

+ *cmd = pair.items[1].string;

+ if (is_available)

+ *is_available = 1;

+ string_list_clear(&list, 0);

+ UNLEAK(testing);

+ return 1;

+ }

+ }

+

+ string_list_clear(&list, 0);

+ free(testing);

+ return 1;

+}

+

+static int is_launchctl_available(void)

+{

+ const char *cmd = "launchctl";

+ int is_available;

+ if (get_schedule_cmd(&cmd, &is_available))

+ return is_available;

+

+#ifdef __APPLE__

+ return 1;

+#else

+ return 0;

+#endif

+}

+

+static int launchctl_boot_plist(int enable, const char *filename)

+ const char *cmd = "launchctl";

+ get_schedule_cmd(&cmd, NULL);

+ strvec_pushl(&child.args, enable ? "bootstrap" : "bootout", uid,

+ filename, NULL);

+static int launchctl_remove_plist(enum schedule_priority schedule)

+ int result = launchctl_boot_plist(0, filename);

+static int launchctl_remove_plists(void)

+ return launchctl_remove_plist(SCHEDULE_HOURLY) ||

+ launchctl_remove_plist(SCHEDULE_DAILY) ||

+ launchctl_remove_plist(SCHEDULE_WEEKLY);

+static int launchctl_schedule_plist(const char *exec_path, enum schedule_priority schedule)

+ const char *cmd = "launchctl";

+ get_schedule_cmd(&cmd, NULL);

+ launchctl_boot_plist(0, filename);

+ if (launchctl_boot_plist(1, filename))

+static int launchctl_add_plists(void)

+ return launchctl_schedule_plist(exec_path, SCHEDULE_HOURLY) ||

+ launchctl_schedule_plist(exec_path, SCHEDULE_DAILY) ||

+ launchctl_schedule_plist(exec_path, SCHEDULE_WEEKLY);

+static int launchctl_update_schedule(int run_maintenance, int fd)

+ return launchctl_add_plists();

+ return launchctl_remove_plists();

+}

+

+static int is_schtasks_available(void)

+{

+ const char *cmd = "schtasks";

+ int is_available;

+ if (get_schedule_cmd(&cmd, &is_available))

+ return is_available;

+

+#ifdef GIT_WINDOWS_NATIVE

+ return 1;

+#else

+ return 0;

+#endif

+static int schtasks_remove_task(enum schedule_priority schedule)

+ const char *cmd = "schtasks";

+ get_schedule_cmd(&cmd, NULL);

+static int schtasks_remove_tasks(void)

+ return schtasks_remove_task(SCHEDULE_HOURLY) ||

+ schtasks_remove_task(SCHEDULE_DAILY) ||

+ schtasks_remove_task(SCHEDULE_WEEKLY);

+static int schtasks_schedule_task(const char *exec_path, enum schedule_priority schedule)

+ const char *cmd = "schtasks";

+ get_schedule_cmd(&cmd, NULL);

+

+static int schtasks_schedule_tasks(void)

+ return schtasks_schedule_task(exec_path, SCHEDULE_HOURLY) ||

+ schtasks_schedule_task(exec_path, SCHEDULE_DAILY) ||

+ schtasks_schedule_task(exec_path, SCHEDULE_WEEKLY);

+static int schtasks_update_schedule(int run_maintenance, int fd)

+ return schtasks_schedule_tasks();

+ return schtasks_remove_tasks();

+}

+

+static int is_crontab_available(void)

+{

+ const char *cmd = "crontab";

+ int is_available;

+ struct child_process child = CHILD_PROCESS_INIT;

+

+ if (get_schedule_cmd(&cmd, &is_available))

+ return is_available;

+

+ strvec_split(&child.args, cmd);

+ strvec_push(&child.args, "-l");

+ child.no_stdin = 1;

+ child.no_stdout = 1;

+ child.no_stderr = 1;

+ child.silent_exec_failure = 1;

+

+ if (start_command(&child))

+ return 0;

+ /* Ignore exit code, as an empty crontab will return error. */

+ finish_command(&child);

+ return 1;

+static int crontab_update_schedule(int run_maintenance, int fd)

+ const char *cmd = "crontab";

+ get_schedule_cmd(&cmd, NULL);

+static int real_is_systemd_timer_available(void)

+{

+ struct child_process child = CHILD_PROCESS_INIT;

+

+ strvec_pushl(&child.args, "systemctl", "--user", "list-timers", NULL);

+ child.no_stdin = 1;

+ child.no_stdout = 1;

+ child.no_stderr = 1;

+ child.silent_exec_failure = 1;

+

+ if (start_command(&child))

+ return 0;

+ if (finish_command(&child))

+ return 0;

+ return 1;

+}

+

+static int is_systemd_timer_available(void)

+{

+ const char *cmd = "systemctl";

+ int is_available;

+

+ if (get_schedule_cmd(&cmd, &is_available))

+ return is_available;

+

+ return real_is_systemd_timer_available();

+}

+

+static char *xdg_config_home_systemd(const char *filename)

+{

+ return xdg_config_home_for("systemd/user", filename);

+}

+

+static int systemd_timer_enable_unit(int enable,

+ enum schedule_priority schedule)

+{

+ const char *cmd = "systemctl";

+ struct child_process child = CHILD_PROCESS_INIT;

+ const char *frequency = get_frequency(schedule);

+

+ /*

+ * Disabling the systemd unit while it is already disabled makes

+ * systemctl print an error.

+ * Let's ignore it since it means we already are in the expected state:

+ * the unit is disabled.

+ *

+ * On the other hand, enabling a systemd unit which is already enabled

+ * produces no error.

+ */

+ if (!enable)

+ child.no_stderr = 1;

+

+ get_schedule_cmd(&cmd, NULL);

+ strvec_split(&child.args, cmd);

+ strvec_pushl(&child.args, "--user", enable ? "enable" : "disable",

+ "--now", NULL);

+ strvec_pushf(&child.args, "git-maintenance@%s.timer", frequency);

+

+ if (start_command(&child))

+ return error(_("failed to start systemctl"));

+ if (finish_command(&child))

+ /*

+ * Disabling an already disabled systemd unit makes

+ * systemctl fail.

+ * Let's ignore this failure.

+ *

+ * Enabling an enabled systemd unit doesn't fail.

+ */

+ if (enable)

+ return error(_("failed to run systemctl"));

+ return 0;

+}

+

+static int systemd_timer_delete_unit_templates(void)

+{

+ int ret = 0;

+ char *filename = xdg_config_home_systemd("git-maintenance@.timer");

+ if (unlink(filename) && !is_missing_file_error(errno))

+ ret = error_errno(_("failed to delete '%s'"), filename);

+ FREE_AND_NULL(filename);

+

+ filename = xdg_config_home_systemd("git-maintenance@.service");

+ if (unlink(filename) && !is_missing_file_error(errno))

+ ret = error_errno(_("failed to delete '%s'"), filename);

+

+ free(filename);

+ return ret;

+}

+

+static int systemd_timer_delete_units(void)

+{

+ return systemd_timer_enable_unit(0, SCHEDULE_HOURLY) ||

+ systemd_timer_enable_unit(0, SCHEDULE_DAILY) ||

+ systemd_timer_enable_unit(0, SCHEDULE_WEEKLY) ||

+ systemd_timer_delete_unit_templates();

+}

+

+static int systemd_timer_write_unit_templates(const char *exec_path)

+{

+ char *filename;

+ FILE *file;

+ const char *unit;

+

+ filename = xdg_config_home_systemd("git-maintenance@.timer");

+ if (safe_create_leading_directories(filename)) {

+ error(_("failed to create directories for '%s'"), filename);

+ goto error;

+ }

+ file = fopen_or_warn(filename, "w");

+ if (file == NULL)

+ goto error;

+

+ unit = "# This file was created and is maintained by Git.\n"

+ "# Any edits made in this file might be replaced in the future\n"

+ "# by a Git command.\n"

+ "\n"

+ "[Unit]\n"

+ "Description=Optimize Git repositories data\n"

+ "\n"

+ "[Timer]\n"

+ "OnCalendar=%i\n"

+ "Persistent=true\n"

+ "\n"

+ "[Install]\n"

+ "WantedBy=timers.target\n";

+ if (fputs(unit, file) == EOF) {

+ error(_("failed to write to '%s'"), filename);

+ fclose(file);

+ goto error;

+ }

+ if (fclose(file) == EOF) {

+ error_errno(_("failed to flush '%s'"), filename);

+ goto error;

+ }

+ free(filename);

+

+ filename = xdg_config_home_systemd("git-maintenance@.service");

+ file = fopen_or_warn(filename, "w");

+ if (file == NULL)

+ goto error;

+

+ unit = "# This file was created and is maintained by Git.\n"

+ "# Any edits made in this file might be replaced in the future\n"

+ "# by a Git command.\n"

+ "\n"

+ "[Unit]\n"

+ "Description=Optimize Git repositories data\n"

+ "\n"

+ "[Service]\n"

+ "Type=oneshot\n"

+ "ExecStart=\"%s/git\" --exec-path=\"%s\" for-each-repo --config=maintenance.repo maintenance run --schedule=%%i\n"

+ "LockPersonality=yes\n"

+ "MemoryDenyWriteExecute=yes\n"

+ "NoNewPrivileges=yes\n"

+ "RestrictAddressFamilies=AF_UNIX AF_INET AF_INET6\n"

+ "RestrictNamespaces=yes\n"

+ "RestrictRealtime=yes\n"

+ "RestrictSUIDSGID=yes\n"

+ "SystemCallArchitectures=native\n"

+ "SystemCallFilter=@system-service\n";

+ if (fprintf(file, unit, exec_path, exec_path) < 0) {

+ error(_("failed to write to '%s'"), filename);

+ fclose(file);

+ goto error;

+ }

+ if (fclose(file) == EOF) {

+ error_errno(_("failed to flush '%s'"), filename);

+ goto error;

+ }

+ free(filename);

+ return 0;

+

+error:

+ free(filename);

+ systemd_timer_delete_unit_templates();

+ return -1;

+}

+

+static int systemd_timer_setup_units(void)

+{

+ const char *exec_path = git_exec_path();

+

+ int ret = systemd_timer_write_unit_templates(exec_path) ||

+ systemd_timer_enable_unit(1, SCHEDULE_HOURLY) ||

+ systemd_timer_enable_unit(1, SCHEDULE_DAILY) ||

+ systemd_timer_enable_unit(1, SCHEDULE_WEEKLY);

+ if (ret)

+ systemd_timer_delete_units();

+ return ret;

+}

+

+static int systemd_timer_update_schedule(int run_maintenance, int fd)

+{

+ if (run_maintenance)

+ return systemd_timer_setup_units();

+ else

+ return systemd_timer_delete_units();

+}

+

+enum scheduler {

+ SCHEDULER_INVALID = -1,

+ SCHEDULER_AUTO,

+ SCHEDULER_CRON,

+ SCHEDULER_SYSTEMD,

+ SCHEDULER_LAUNCHCTL,

+ SCHEDULER_SCHTASKS,

+};

+

+static const struct {

+ const char *name;

+ int (*is_available)(void);

+ int (*update_schedule)(int run_maintenance, int fd);

+} scheduler_fn[] = {

+ [SCHEDULER_CRON] = {

+ .name = "crontab",

+ .is_available = is_crontab_available,

+ .update_schedule = crontab_update_schedule,

+ },

+ [SCHEDULER_SYSTEMD] = {

+ .name = "systemctl",

+ .is_available = is_systemd_timer_available,

+ .update_schedule = systemd_timer_update_schedule,

+ },

+ [SCHEDULER_LAUNCHCTL] = {

+ .name = "launchctl",

+ .is_available = is_launchctl_available,

+ .update_schedule = launchctl_update_schedule,

+ },

+ [SCHEDULER_SCHTASKS] = {

+ .name = "schtasks",

+ .is_available = is_schtasks_available,

+ .update_schedule = schtasks_update_schedule,

+ },

+};

+

+static enum scheduler parse_scheduler(const char *value)

+{

+ if (!value)

+ return SCHEDULER_INVALID;

+ else if (!strcasecmp(value, "auto"))

+ return SCHEDULER_AUTO;

+ else if (!strcasecmp(value, "cron") || !strcasecmp(value, "crontab"))

+ return SCHEDULER_CRON;

+ else if (!strcasecmp(value, "systemd") ||

+ !strcasecmp(value, "systemd-timer"))

+ return SCHEDULER_SYSTEMD;

+ else if (!strcasecmp(value, "launchctl"))

+ return SCHEDULER_LAUNCHCTL;

+ else if (!strcasecmp(value, "schtasks"))

+ return SCHEDULER_SCHTASKS;

+ else

+ return SCHEDULER_INVALID;

+}

+

+static int maintenance_opt_scheduler(const struct option *opt, const char *arg,

+ int unset)

+{

+ enum scheduler *scheduler = opt->value;

+

+ BUG_ON_OPT_NEG(unset);

+

+ *scheduler = parse_scheduler(arg);

+ if (*scheduler == SCHEDULER_INVALID)

+ return error(_("unrecognized --scheduler argument '%s'"), arg);

+ return 0;

+}

+

+struct maintenance_start_opts {

+ enum scheduler scheduler;

+};

+

+static enum scheduler resolve_scheduler(enum scheduler scheduler)

+{

+ if (scheduler != SCHEDULER_AUTO)

+ return scheduler;

+

+ return SCHEDULER_LAUNCHCTL;

+

+ return SCHEDULER_SCHTASKS;

+

+#elif defined(__linux__)

+ if (is_systemd_timer_available())

+ return SCHEDULER_SYSTEMD;

+ else if (is_crontab_available())

+ return SCHEDULER_CRON;

+ else

+ die(_("neither systemd timers nor crontab are available"));

+

+ return SCHEDULER_CRON;

+}

+static void validate_scheduler(enum scheduler scheduler)

+ if (scheduler == SCHEDULER_INVALID)

+ BUG("invalid scheduler");

+ if (scheduler == SCHEDULER_AUTO)

+ BUG("resolve_scheduler should have been called before");

+

+ if (!scheduler_fn[scheduler].is_available())

+ die(_("%s scheduler is not available"),

+ scheduler_fn[scheduler].name);

+}

+

+static int update_background_schedule(const struct maintenance_start_opts *opts,

+ int enable)

+{

+ unsigned int i;

+ int result = 0;

+ if (hold_lock_file_for_update(&lk, lock_path, LOCK_NO_DEREF) < 0) {

+ free(lock_path);

+ return error(_("another process is scheduling background maintenance"));

+ for (i = 1; i < ARRAY_SIZE(scheduler_fn); i++) {

+ if (enable && opts->scheduler == i)

+ continue;

+ if (!scheduler_fn[i].is_available())

+ continue;

+ scheduler_fn[i].update_schedule(0, get_lock_file_fd(&lk));

+ if (enable)

+ result = scheduler_fn[opts->scheduler].update_schedule(

+ 1, get_lock_file_fd(&lk));

+static const char *const builtin_maintenance_start_usage[] = {

+ N_("git maintenance start [--scheduler=<scheduler>]"),

+ NULL

+};

+

+static int maintenance_start(int argc, const char **argv, const char *prefix)

+ struct maintenance_start_opts opts = { 0 };

+ struct option options[] = {

+ OPT_CALLBACK_F(

+ 0, "scheduler", &opts.scheduler, N_("scheduler"),

+ N_("scheduler to trigger git maintenance run"),

+ PARSE_OPT_NONEG, maintenance_opt_scheduler),

+ OPT_END()

+ };

+

+ argc = parse_options(argc, argv, prefix, options,

+ builtin_maintenance_start_usage, 0);

+ if (argc)

+ usage_with_options(builtin_maintenance_start_usage, options);

+

+ opts.scheduler = resolve_scheduler(opts.scheduler);

+ validate_scheduler(opts.scheduler);

+

+ return update_background_schedule(&opts, 1);

+ return update_background_schedule(NULL, 0);

+ return maintenance_start(argc - 1, argv + 1, prefix);

+static struct repository **repos_to_free;

+static size_t repos_to_free_nr, repos_to_free_alloc;

+

+static void free_repos(void)

+{

+ int i;

+

+ for (i = 0; i < repos_to_free_nr; i++) {

+ repo_clear(repos_to_free[i]);

+ free(repos_to_free[i]);

+ }

+ FREE_AND_NULL(repos_to_free);

+ repos_to_free_nr = 0;

+ repos_to_free_alloc = 0;

+}

+

+ grep_source_init_oid(&gs, pathbuf.buf, path, oid, opt->repo);

+ grep_source_init_file(&gs, buf.buf, filename);

+ struct repository *subrepo;

+ int hit = 0;

+ subrepo = xmalloc(sizeof(*subrepo));

+ if (repo_submodule_init(subrepo, superproject, sub)) {

+ free(subrepo);

+ }

+ ALLOC_GROW(repos_to_free, repos_to_free_nr + 1, repos_to_free_alloc);

+ repos_to_free[repos_to_free_nr++] = subrepo;

+ repo_read_gitmodules(subrepo, 0);

+ * All code paths tested by test code no longer need submodule ODBs to

+ * be added as alternates, but add it to the list just in case.

+ * Submodule ODBs added through add_submodule_odb_by_path() will be

+ * lazily registered as alternates when needed (and except in an

+ * unexpected code interaction, it won't be needed).

+ add_submodule_odb_by_path(subrepo->objects->odb->path);

+ subopt.repo = subrepo;

+ enum object_type object_type;

+ object_type = oid_object_info(subrepo, oid, NULL);

+ data = read_object_with_reference(subrepo,

+ oid, tree_type,

+ die(_("unable to read tree (%s)"), oid_to_hex(oid));

+ object_type == OBJ_COMMIT);

+ free_repos();

+ vpath = prefix_filename(prefix, vpath);

+static const char *progress_title;

+ progress_title ? progress_title :

+static void rename_tmp_packfile(const char **final_name,

+ const char *curr_name,

+ struct strbuf *name, unsigned char *hash,

+ const char *ext, int make_read_only_if_same)

+{

+ if (*final_name != curr_name) {

+ if (!*final_name)

+ *final_name = odb_pack_name(name, hash, ext);

+ if (finalize_object_file(curr_name, *final_name))

+ die(_("unable to rename temporary '*.%s' file to '%s"),

+ ext, *final_name);

+ } else if (make_read_only_if_same) {

+ chmod(*final_name, 0444);

+ }

+}

+

+ rename_tmp_packfile(&final_pack_name, curr_pack_name, &pack_name,

+ hash, "pack", from_stdin);

+ if (curr_rev_index_name)

+ rename_tmp_packfile(&final_rev_index_name, curr_rev_index_name,

+ &rev_index_name, hash, "rev", 1);

+ rename_tmp_packfile(&final_index_name, curr_index_name, &index_name,

+ hash, "idx", 1);

+ } else if (!strcmp(arg, "--progress-title")) {

+ if (progress_title || (i+1) >= argc)

+ usage(index_pack_usage);

+ progress_title = argv[++i];

+ prepare_repo_settings(the_repository);

+ the_repository->settings.command_requires_full_index = 0;

+

+ OPT_BIT(0, "bitmap", &opts.flags, N_("write multi-pack bitmap"),

+ MIDX_WRITE_BITMAP | MIDX_WRITE_REV_INDEX),

+ /*

+ * Can use bit positions directly, even for MIDX

+ * bitmaps. See comment in try_partial_reuse()

+ * for why.

+ */

+ char *idx_tmp_name = NULL;

+ strbuf_addf(&tmpname, "%s-%s.", base_name,

+ hash_to_hex(hash));

+ stage_tmp_packfiles(&tmpname, pack_tmp_name,

+ &pack_idx_opts, hash, &idx_tmp_name);

+ size_t tmpname_len = tmpname.len;

+ strbuf_addstr(&tmpname, "bitmap");

+ if (bitmap_writer_build(&to_pack) < 0)

+ die(_("failed to write bitmap index"));

+ strbuf_setlen(&tmpname, tmpname_len);

+ rename_tmp_packfile_idx(&tmpname, &idx_tmp_name);

+

+ free(idx_tmp_name);

+#include "packfile.h"

+ ret = run_command_v_opt(args.v, RUN_GIT_CMD | RUN_CLOSE_OBJECT_STORE);

+ prepare_repo_settings(the_repository);

+ the_repository->settings.command_requires_full_index = 0;

+

+ prepare_repo_settings(the_repository);

+ the_repository->settings.command_requires_full_index = 0;

+

+static const struct object_id *command_singleton_iterator(void *cb_data);

+static const struct object_id *command_singleton_iterator(void *cb_data)

+ return NULL;

+ return &cmd->new_oid;

+static const struct object_id *iterate_receive_command_list(void *cb_data)

+ return &cmd->new_oid;

+ return NULL;

+ OPT_HIDDEN_BOOL(0, "http-backend-info-refs", &advertise_refs, NULL),

+ OPT_ALIAS(0, "advertise-refs", "http-backend-info-refs"),

+ proc.git_cmd = proc.close_object_store = 1;

+ {".idx"},

+ } else if (write_bitmaps &&

+ git_env_bool(GIT_TEST_MULTI_PACK_INDEX, 0) &&

+ git_env_bool(GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP, 0)) {

+ write_bitmaps = 0;

+ if (git_env_bool(GIT_TEST_MULTI_PACK_INDEX, 0)) {

+ unsigned flags = 0;

+ if (git_env_bool(GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP, 0))

+ flags |= MIDX_WRITE_BITMAP | MIDX_WRITE_REV_INDEX;

+ write_midx_file(get_object_directory(), NULL, flags);

+ }

+ prepare_repo_settings(the_repository);

+ the_repository->settings.command_requires_full_index = 0;

+

+static void clean_tracked_sparse_directories(struct repository *r)

+{

+ int i, was_full = 0;

+ struct strbuf path = STRBUF_INIT;

+ size_t pathlen;

+ struct string_list_item *item;

+ struct string_list sparse_dirs = STRING_LIST_INIT_DUP;

+

+ /*

+ * If we are not using cone mode patterns, then we cannot

+ * delete directories outside of the sparse cone.

+ */

+ if (!r || !r->index || !r->worktree)

+ return;

+ if (init_sparse_checkout_patterns(r->index) ||

+ !r->index->sparse_checkout_patterns->use_cone_patterns)

+ return;

+

+ /*

+ * Use the sparse index as a data structure to assist finding

+ * directories that are safe to delete. This conversion to a

+ * sparse index will not delete directories that contain

+ * conflicted entries or submodules.

+ */

+ if (!r->index->sparse_index) {

+ /*

+ * If something, such as a merge conflict or other concern,

+ * prevents us from converting to a sparse index, then do

+ * not try deleting files.

+ */

+ if (convert_to_sparse(r->index, SPARSE_INDEX_MEMORY_ONLY))

+ return;

+ was_full = 1;

+ }

+

+ strbuf_addstr(&path, r->worktree);

+ strbuf_complete(&path, '/');

+ pathlen = path.len;

+

+ /*

+ * Collect directories that have gone out of scope but also

+ * exist on disk, so there is some work to be done. We need to

+ * store the entries in a list before exploring, since that might

+ * expand the sparse-index again.

+ */

+ for (i = 0; i < r->index->cache_nr; i++) {

+ struct cache_entry *ce = r->index->cache[i];

+

+ if (S_ISSPARSEDIR(ce->ce_mode) &&

+ repo_file_exists(r, ce->name))

+ string_list_append(&sparse_dirs, ce->name);

+ }

+

+ for_each_string_list_item(item, &sparse_dirs) {

+ struct dir_struct dir = DIR_INIT;

+ struct pathspec p = { 0 };

+ struct strvec s = STRVEC_INIT;

+

+ strbuf_setlen(&path, pathlen);

+ strbuf_addstr(&path, item->string);

+

+ dir.flags |= DIR_SHOW_IGNORED_TOO;

+

+ setup_standard_excludes(&dir);

+ strvec_push(&s, path.buf);

+

+ parse_pathspec(&p, PATHSPEC_GLOB, 0, NULL, s.v);

+ fill_directory(&dir, r->index, &p);

+

+ if (dir.nr) {

+ warning(_("directory '%s' contains untracked files,"

+ " but is not in the sparse-checkout cone"),

+ item->string);

+ } else if (remove_dir_recursively(&path, 0)) {

+ /*

+ * Removal is "best effort". If something blocks

+ * the deletion, then continue with a warning.

+ */

+ warning(_("failed to remove directory '%s'"),

+ item->string);

+ }

+

+ dir_clear(&dir);

+ }

+

+ string_list_clear(&sparse_dirs, 0);

+ strbuf_release(&path);

+

+ if (was_full)

+ ensure_full_index(r->index);

+}

+

+ clean_tracked_sparse_directories(r);

+

+static char *resolve_relative_url(const char *rel_url, const char *up_path, int quiet)

+ char *remoteurl, *resolved_url;

+ struct strbuf remotesb = STRBUF_INIT;

+ strbuf_addf(&remotesb, "remote.%s.url", remote);

+ if (git_config_get_string(remotesb.buf, &remoteurl)) {

+ if (!quiet)

+ warning(_("could not look up configuration '%s'. "

+ "Assuming this repository is its own "

+ "authoritative upstream."),

+ remotesb.buf);

+ }

+ resolved_url = relative_url(remoteurl, rel_url, up_path);

+ free(remote);

+ strbuf_release(&remotesb);

+

+ return resolved_url;

+ url = resolve_relative_url(oldurl, NULL, 0);

+ char *up_path = get_up_path(path);

+ sub_origin_url = resolve_relative_url(sub->url, up_path, 1);

+ super_config_url = resolve_relative_url(sub->url, NULL, 1);

+struct update_data {

+ const char *recursive_prefix;

+ const char *sm_path;

+ const char *displaypath;

+ struct object_id oid;

+ struct object_id suboid;

+ struct submodule_update_strategy update_strategy;

+ int depth;

+ unsigned int force: 1;

+ unsigned int quiet: 1;

+ unsigned int nofetch: 1;

+ unsigned int just_cloned: 1;

+};

+#define UPDATE_DATA_INIT { .update_strategy = SUBMODULE_UPDATE_STRATEGY_INIT }

+ url = resolve_relative_url(sub->url, NULL, 0);

+static int is_tip_reachable(const char *path, struct object_id *oid)

+{

+ struct child_process cp = CHILD_PROCESS_INIT;

+ struct strbuf rev = STRBUF_INIT;

+ char *hex = oid_to_hex(oid);

+

+ cp.git_cmd = 1;

+ cp.dir = xstrdup(path);

+ cp.no_stderr = 1;

+ strvec_pushl(&cp.args, "rev-list", "-n", "1", hex, "--not", "--all", NULL);

+

+ prepare_submodule_repo_env(&cp.env_array);

+

+ if (capture_command(&cp, &rev, GIT_MAX_HEXSZ + 1) || rev.len)

+ return 0;

+

+ return 1;

+}

+

+static int fetch_in_submodule(const char *module_path, int depth, int quiet, struct object_id *oid)

+{

+ struct child_process cp = CHILD_PROCESS_INIT;

+

+ prepare_submodule_repo_env(&cp.env_array);

+ cp.git_cmd = 1;

+ cp.dir = xstrdup(module_path);

+

+ strvec_push(&cp.args, "fetch");

+ if (quiet)

+ strvec_push(&cp.args, "--quiet");

+ if (depth)

+ strvec_pushf(&cp.args, "--depth=%d", depth);

+ if (oid) {

+ char *hex = oid_to_hex(oid);

+ char *remote = get_default_remote();

+ strvec_pushl(&cp.args, remote, hex, NULL);

+ }

+

+ return run_command(&cp);

+}

+

+static int run_update_command(struct update_data *ud, int subforce)

+{

+ struct strvec args = STRVEC_INIT;

+ struct strvec child_env = STRVEC_INIT;

+ char *oid = oid_to_hex(&ud->oid);

+ int must_die_on_failure = 0;

+ int git_cmd;

+

+ switch (ud->update_strategy.type) {

+ case SM_UPDATE_CHECKOUT:

+ git_cmd = 1;

+ strvec_pushl(&args, "checkout", "-q", NULL);

+ if (subforce)

+ strvec_push(&args, "-f");

+ break;

+ case SM_UPDATE_REBASE:

+ git_cmd = 1;

+ strvec_push(&args, "rebase");

+ if (ud->quiet)

+ strvec_push(&args, "--quiet");

+ must_die_on_failure = 1;

+ break;

+ case SM_UPDATE_MERGE:

+ git_cmd = 1;

+ strvec_push(&args, "merge");

+ if (ud->quiet)

+ strvec_push(&args, "--quiet");

+ must_die_on_failure = 1;

+ break;

+ case SM_UPDATE_COMMAND:

+ git_cmd = 0;

+ strvec_push(&args, ud->update_strategy.command);

+ must_die_on_failure = 1;

+ break;

+ default:

+ BUG("unexpected update strategy type: %s",

+ submodule_strategy_to_string(&ud->update_strategy));

+ }

+ strvec_push(&args, oid);

+

+ prepare_submodule_repo_env(&child_env);

+ if (run_command_v_opt_cd_env(args.v, git_cmd ? RUN_GIT_CMD : RUN_USING_SHELL,

+ ud->sm_path, child_env.v)) {

+ switch (ud->update_strategy.type) {

+ case SM_UPDATE_CHECKOUT:

+ printf(_("Unable to checkout '%s' in submodule path '%s'"),

+ oid, ud->displaypath);

+ break;

+ case SM_UPDATE_REBASE:

+ printf(_("Unable to rebase '%s' in submodule path '%s'"),

+ oid, ud->displaypath);

+ break;

+ case SM_UPDATE_MERGE:

+ printf(_("Unable to merge '%s' in submodule path '%s'"),

+ oid, ud->displaypath);

+ break;

+ case SM_UPDATE_COMMAND:

+ printf(_("Execution of '%s %s' failed in submodule path '%s'"),

+ ud->update_strategy.command, oid, ud->displaypath);

+ break;

+ default:

+ BUG("unexpected update strategy type: %s",

+ submodule_strategy_to_string(&ud->update_strategy));

+ }

+ /*

+ * NEEDSWORK: We are currently printing to stdout with error

+ * return so that the shell caller handles the error output

+ * properly. Once we start handling the error messages within

+ * C, we should use die() instead.

+ */

+ if (must_die_on_failure)

+ return 2;

+ /*

+ * This signifies to the caller in shell that the command

+ * failed without dying

+ */

+ return 1;

+ }

+

+ switch (ud->update_strategy.type) {

+ case SM_UPDATE_CHECKOUT:

+ printf(_("Submodule path '%s': checked out '%s'\n"),

+ ud->displaypath, oid);

+ break;

+ case SM_UPDATE_REBASE:

+ printf(_("Submodule path '%s': rebased into '%s'\n"),

+ ud->displaypath, oid);

+ break;

+ case SM_UPDATE_MERGE:

+ printf(_("Submodule path '%s': merged in '%s'\n"),

+ ud->displaypath, oid);

+ break;

+ case SM_UPDATE_COMMAND:

+ printf(_("Submodule path '%s': '%s %s'\n"),

+ ud->displaypath, ud->update_strategy.command, oid);

+ break;

+ default:

+ BUG("unexpected update strategy type: %s",

+ submodule_strategy_to_string(&ud->update_strategy));

+ }

+

+ return 0;

+}

+

+static int do_run_update_procedure(struct update_data *ud)

+{

+ int subforce = is_null_oid(&ud->suboid) || ud->force;

+

+ if (!ud->nofetch) {

+ /*

+ * Run fetch only if `oid` isn't present or it

+ * is not reachable from a ref.

+ */

+ if (!is_tip_reachable(ud->sm_path, &ud->oid) &&

+ fetch_in_submodule(ud->sm_path, ud->depth, ud->quiet, NULL) &&

+ !ud->quiet)

+ fprintf_ln(stderr,

+ _("Unable to fetch in submodule path '%s'; "

+ "trying to directly fetch %s:"),

+ ud->displaypath, oid_to_hex(&ud->oid));

+ /*

+ * Now we tried the usual fetch, but `oid` may

+ * not be reachable from any of the refs.

+ */

+ if (!is_tip_reachable(ud->sm_path, &ud->oid) &&

+ fetch_in_submodule(ud->sm_path, ud->depth, ud->quiet, &ud->oid))

+ die(_("Fetched in submodule path '%s', but it did not "

+ "contain %s. Direct fetching of that commit failed."),

+ ud->displaypath, oid_to_hex(&ud->oid));

+ }

+

+ return run_update_command(ud, subforce);

+}

+

+static int run_update_procedure(int argc, const char **argv, const char *prefix)

+{

+ int force = 0, quiet = 0, nofetch = 0, just_cloned = 0;

+ char *prefixed_path, *update = NULL;

+ struct update_data update_data = UPDATE_DATA_INIT;

+

+ struct option options[] = {

+ OPT__QUIET(&quiet, N_("suppress output for update by rebase or merge")),

+ OPT__FORCE(&force, N_("force checkout updates"), 0),

+ OPT_BOOL('N', "no-fetch", &nofetch,

+ N_("don't fetch new objects from the remote site")),

+ OPT_BOOL(0, "just-cloned", &just_cloned,

+ N_("overrides update mode in case the repository is a fresh clone")),

+ OPT_INTEGER(0, "depth", &update_data.depth, N_("depth for shallow fetch")),

+ OPT_STRING(0, "prefix", &prefix,

+ N_("path"),

+ N_("path into the working tree")),

+ OPT_STRING(0, "update", &update,

+ N_("string"),

+ N_("rebase, merge, checkout or none")),

+ OPT_STRING(0, "recursive-prefix", &update_data.recursive_prefix, N_("path"),

+ N_("path into the working tree, across nested "

+ "submodule boundaries")),

+ OPT_CALLBACK_F(0, "oid", &update_data.oid, N_("sha1"),

+ N_("SHA1 expected by superproject"), PARSE_OPT_NONEG,

+ parse_opt_object_id),

+ OPT_CALLBACK_F(0, "suboid", &update_data.suboid, N_("subsha1"),

+ N_("SHA1 of submodule's HEAD"), PARSE_OPT_NONEG,

+ parse_opt_object_id),

+ OPT_END()

+ };

+

+ const char *const usage[] = {

+ N_("git submodule--helper run-update-procedure [<options>] <path>"),

+ NULL

+ };

+

+ argc = parse_options(argc, argv, prefix, options, usage, 0);

+

+ if (argc != 1)

+ usage_with_options(usage, options);

+

+ update_data.force = !!force;

+ update_data.quiet = !!quiet;

+ update_data.nofetch = !!nofetch;

+ update_data.just_cloned = !!just_cloned;

+ update_data.sm_path = argv[0];

+

+ if (update_data.recursive_prefix)

+ prefixed_path = xstrfmt("%s%s", update_data.recursive_prefix, update_data.sm_path);

+ else

+ prefixed_path = xstrdup(update_data.sm_path);

+

+ update_data.displaypath = get_submodule_displaypath(prefixed_path, prefix);

+

+ determine_submodule_update_strategy(the_repository, update_data.just_cloned,

+ update_data.sm_path, update,

+ &update_data.update_strategy);

+

+ free(prefixed_path);

+

+ if (!oideq(&update_data.oid, &update_data.suboid) || update_data.force)

+ return do_run_update_procedure(&update_data);

+

+ return 3;

+}

+

+ char *sm_path;

+static int config_submodule_in_gitmodules(const char *name, const char *var, const char *value)

+{

+ char *key;

+ int ret;

+

+ if (!is_writing_gitmodules_ok())

+ die(_("please make sure that the .gitmodules file is in the working tree"));

+

+ key = xstrfmt("submodule.%s.%s", name, var);

+ ret = config_set_in_gitmodules_file_gently(key, value);

+ free(key);

+

+ return ret;

+}

+

+static void configure_added_submodule(struct add_data *add_data)

+{

+ char *key;

+ char *val = NULL;

+ struct child_process add_submod = CHILD_PROCESS_INIT;

+ struct child_process add_gitmodules = CHILD_PROCESS_INIT;

+

+ key = xstrfmt("submodule.%s.url", add_data->sm_name);

+ git_config_set_gently(key, add_data->realrepo);

+ free(key);

+

+ add_submod.git_cmd = 1;

+ strvec_pushl(&add_submod.args, "add",

+ "--no-warn-embedded-repo", NULL);

+ if (add_data->force)

+ strvec_push(&add_submod.args, "--force");

+ strvec_pushl(&add_submod.args, "--", add_data->sm_path, NULL);

+

+ if (run_command(&add_submod))

+ die(_("Failed to add submodule '%s'"), add_data->sm_path);

+

+ if (config_submodule_in_gitmodules(add_data->sm_name, "path", add_data->sm_path) ||

+ config_submodule_in_gitmodules(add_data->sm_name, "url", add_data->repo))

+ die(_("Failed to register submodule '%s'"), add_data->sm_path);

+

+ if (add_data->branch) {

+ if (config_submodule_in_gitmodules(add_data->sm_name,

+ "branch", add_data->branch))

+ die(_("Failed to register submodule '%s'"), add_data->sm_path);

+ }

+

+ add_gitmodules.git_cmd = 1;

+ strvec_pushl(&add_gitmodules.args,

+ "add", "--force", "--", ".gitmodules", NULL);

+

+ if (run_command(&add_gitmodules))

+ die(_("Failed to register submodule '%s'"), add_data->sm_path);

+

+ /*

+ * NEEDSWORK: In a multi-working-tree world this needs to be

+ * set in the per-worktree config.

+ */

+ /*

+ * NEEDSWORK: In the longer run, we need to get rid of this

+ * pattern of querying "submodule.active" before calling

+ * is_submodule_active(), since that function needs to find

+ * out the value of "submodule.active" again anyway.

+ */

+ if (!git_config_get_string("submodule.active", &val) && val) {

+ /*

+ * If the submodule being added isn't already covered by the

+ * current configured pathspec, set the submodule's active flag

+ */

+ if (!is_submodule_active(the_repository, add_data->sm_path)) {

+ key = xstrfmt("submodule.%s.active", add_data->sm_name);

+ git_config_set_gently(key, "true");

+ free(key);

+ }

+ } else {

+ key = xstrfmt("submodule.%s.active", add_data->sm_name);

+ git_config_set_gently(key, "true");

+ free(key);

+ }

+}

+

+static void die_on_index_match(const char *path, int force)

+{

+ struct pathspec ps;

+ const char *args[] = { path, NULL };

+ parse_pathspec(&ps, 0, PATHSPEC_PREFER_CWD, NULL, args);

+

+ if (read_cache_preload(NULL) < 0)

+ die(_("index file corrupt"));

+

+ if (ps.nr) {

+ int i;

+ char *ps_matched = xcalloc(ps.nr, 1);

+

+ /* TODO: audit for interaction with sparse-index. */

+ ensure_full_index(&the_index);

+

+ /*

+ * Since there is only one pathspec, we just need

+ * need to check ps_matched[0] to know if a cache

+ * entry matched.

+ */

+ for (i = 0; i < active_nr; i++) {

+ ce_path_match(&the_index, active_cache[i], &ps,

+ ps_matched);

+

+ if (ps_matched[0]) {

+ if (!force)

+ die(_("'%s' already exists in the index"),

+ path);

+ if (!S_ISGITLINK(active_cache[i]->ce_mode))

+ die(_("'%s' already exists in the index "

+ "and is not a submodule"), path);

+ break;

+ }

+ }

+ free(ps_matched);

+ }

+}

+

+static void die_on_repo_without_commits(const char *path)

+{

+ struct strbuf sb = STRBUF_INIT;

+ strbuf_addstr(&sb, path);

+ if (is_nonbare_repository_dir(&sb)) {

+ struct object_id oid;

+ if (resolve_gitlink_ref(path, "HEAD", &oid) < 0)

+ die(_("'%s' does not have a commit checked out"), path);

+ }

+}

+

+static int module_add(int argc, const char **argv, const char *prefix)

+ int force = 0, quiet = 0, progress = 0, dissociate = 0;

+ OPT_STRING('b', "branch", &add_data.branch, N_("branch"),

+ N_("branch of repository to add as submodule")),

+ OPT__QUIET(&quiet, N_("print only error messages")),

+ OPT_BOOL(0, "progress", &progress, N_("force cloning progress")),

+ OPT_STRING(0, "reference", &add_data.reference_path, N_("repository"),

+ N_("reference repository")),

+ OPT_BOOL(0, "dissociate", &dissociate, N_("borrow the objects from reference repositories")),

+ OPT_STRING(0, "name", &add_data.sm_name, N_("name"),

+ N_("sets the submodule’s name to the given string "

+ "instead of defaulting to its path")),

+ OPT_INTEGER(0, "depth", &add_data.depth, N_("depth for shallow clones")),

+ N_("git submodule--helper add [<options>] [--] <repository> [<path>]"),

+ if (!is_writing_gitmodules_ok())

+ die(_("please make sure that the .gitmodules file is in the working tree"));

+

+ if (prefix && *prefix &&

+ add_data.reference_path && !is_absolute_path(add_data.reference_path))

+ add_data.reference_path = xstrfmt("%s%s", prefix, add_data.reference_path);

+

+ if (argc == 0 || argc > 2)

+ add_data.repo = argv[0];

+ if (argc == 1)

+ add_data.sm_path = git_url_basename(add_data.repo, 0, 0);

+ else

+ add_data.sm_path = xstrdup(argv[1]);

+

+ if (prefix && *prefix && !is_absolute_path(add_data.sm_path))

+ add_data.sm_path = xstrfmt("%s%s", prefix, add_data.sm_path);

+

+ if (starts_with_dot_dot_slash(add_data.repo) ||

+ starts_with_dot_slash(add_data.repo)) {

+ if (prefix)

+ die(_("Relative path can only be used from the toplevel "

+ "of the working tree"));

+

+ /* dereference source url relative to parent's url */

+ add_data.realrepo = resolve_relative_url(add_data.repo, NULL, 1);

+ } else if (is_dir_sep(add_data.repo[0]) || strchr(add_data.repo, ':')) {

+ add_data.realrepo = add_data.repo;

+ } else {

+ die(_("repo URL: '%s' must be absolute or begin with ./|../"),

+ add_data.repo);

+ }

+

+ /*

+ * normalize path:

+ * multiple //; leading ./; /./; /../;

+ */

+ normalize_path_copy(add_data.sm_path, add_data.sm_path);

+ strip_dir_trailing_slashes(add_data.sm_path);

+

+ die_on_index_match(add_data.sm_path, force);

+ die_on_repo_without_commits(add_data.sm_path);

+

+ if (!force) {

+ int exit_code = -1;

+ struct strbuf sb = STRBUF_INIT;

+ struct child_process cp = CHILD_PROCESS_INIT;

+ cp.git_cmd = 1;

+ cp.no_stdout = 1;

+ strvec_pushl(&cp.args, "add", "--dry-run", "--ignore-missing",

+ "--no-warn-embedded-repo", add_data.sm_path, NULL);

+ if ((exit_code = pipe_command(&cp, NULL, 0, NULL, 0, &sb, 0))) {

+ strbuf_complete_line(&sb);

+ fputs(sb.buf, stderr);

+ free(add_data.sm_path);

+ return exit_code;

+ }

+ strbuf_release(&sb);

+ }

+

+ if(!add_data.sm_name)

+ add_data.sm_name = add_data.sm_path;

+

+ if (check_submodule_name(add_data.sm_name))

+ die(_("'%s' is not a valid submodule name"), add_data.sm_name);

+

+ add_data.progress = !!progress;

+ add_data.dissociate = !!dissociate;

+ if (add_submodule(&add_data)) {

+ free(add_data.sm_path);

+ }

+ configure_added_submodule(&add_data);

+ free(add_data.sm_path);

+ {"add", module_add, SUPPORT_SUPER_PREFIX},

+ {"run-update-procedure", run_update_procedure, 0},

+static void report_ok(const char *command)

+{

+ fprintf(stdout, "%s: ok\n", command);

+ fflush(stdout);

+}

+

+ report_ok("start");

+ report_ok("prepare");

+ report_ok("abort");

+ report_ok("commit");

+ int advertise_refs = 0;

+ int stateless_rpc = 0;

+ int timeout = 0;

+ OPT_BOOL(0, "stateless-rpc", &stateless_rpc,

+ OPT_HIDDEN_BOOL(0, "http-backend-info-refs", &advertise_refs,

+ N_("serve up the info/refs for git-http-backend")),

+ OPT_ALIAS(0, "advertise-refs", "http-backend-info-refs"),

+ OPT_INTEGER(0, "timeout", &timeout,

+ if (advertise_refs)

+ protocol_v2_advertise_capabilities();

+ else

+ protocol_v2_serve_loop(stateless_rpc);

+ if (advertise_refs || !stateless_rpc)

+ upload_pack(advertise_refs, stateless_rpc, timeout);

+static void finish_tmp_packfile(struct strbuf *basename,

+ const char *pack_tmp_name,

+ struct pack_idx_entry **written_list,

+ uint32_t nr_written,

+ struct pack_idx_option *pack_idx_opts,

+ unsigned char hash[])

+{

+ char *idx_tmp_name = NULL;

+

+ stage_tmp_packfiles(basename, pack_tmp_name, written_list, nr_written,

+ pack_idx_opts, hash, &idx_tmp_name);

+ rename_tmp_packfile_idx(basename, &idx_tmp_name);

+

+ free(idx_tmp_name);

+}

+

+ unsigned char hash[GIT_MAX_RAWSZ];

+ finalize_hashfile(state->f, hash, CSUM_HASH_IN_STREAM | CSUM_FSYNC | CSUM_CLOSE);

+ int fd = finalize_hashfile(state->f, hash, 0);

+ fixup_pack_header_footer(fd, hash, state->pack_tmp_name,

+ state->nr_written, hash,

+ strbuf_addf(&packname, "%s/pack/pack-%s.", get_object_directory(),

+ hash_to_hex(hash));

+ &state->pack_idx_opts, hash);

+ int bundle_fd, struct strvec *extra_index_pack_args)

+ strvec_pushl(&ip.args, "index-pack", "--fix-thin", "--stdin", NULL);

+ if (extra_index_pack_args) {

+ strvec_pushv(&ip.args, extra_index_pack_args->v);

+ strvec_clear(extra_index_pack_args);

+ }

+

+/**

+ * Unbundle after reading the header with read_bundle_header().

+ *

+ * We'll invoke "git index-pack --stdin --fix-thin" for you on the

+ * provided `bundle_fd` from read_bundle_header().

+ *

+ * Provide "extra_index_pack_args" to pass any extra arguments

+ * (e.g. "-v" for verbose/progress), NULL otherwise. The provided

+ * "extra_index_pack_args" (if any) will be strvec_clear()'d for you.

+ */

+ int bundle_fd, struct strvec *extra_index_pack_args);

+ * "$XDG_CONFIG_HOME/$subdir/$filename" if $XDG_CONFIG_HOME is non-empty, otherwise

+ * "$HOME/.config/$subdir/$filename". Return NULL upon error.

+ */

+char *xdg_config_home_for(const char *subdir, const char *filename);

+

+/**

+ * Return a newly allocated string with the evaluation of

+void fwrite_or_die(FILE *f, const void *buf, size_t count);

+void fflush_or_die(FILE *f);

+ export GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP=1

+ clear_commit_graph_data_slab(&commit_graph_data_slab);

+ display_progress(ctx->progress, i + 1);

+/*

+ * We need more complex parsing in stat_parent_pid() and

+ * parse_proc_stat() below than a dumb fscanf(). That's because while

+ * the statcomm field is surrounded by parentheses, the process itself

+ * is free to insert any arbitrary byte sequence its its name. That

+ * can include newlines, spaces, closing parentheses etc.

+ *

+ * See do_task_stat() in fs/proc/array.c in linux.git, this is in

+ * contrast with the escaped version of the name found in

+ * /proc/%d/status.

+ *

+ * So instead of using fscanf() we'll read N bytes from it, look for

+ * the first "(", and then the last ")", anything in-between is our

+ * process name.

+ *

+ * How much N do we need? On Linux /proc/sys/kernel/pid_max is 2^15 by

+ * default, but it can be raised set to values of up to 2^22. So

+ * that's 7 digits for a PID. We have 2 PIDs in the first four fields

+ * we're interested in, so 2 * 7 = 14.

+ *

+ * We then have 3 spaces between those four values, and we'd like to

+ * get to the space between the 4th and the 5th (the "pgrp" field) to

+ * make sure we read the entire "ppid" field. So that brings us up to

+ * 14 + 3 + 1 = 18. Add the two parentheses around the "comm" value

+ * and it's 20. The "state" value itself is then one character (now at

+ * 21).

+ *

+ * Finally the maximum length of the "comm" name itself is 15

+ * characters, e.g. a setting of "123456789abcdefg" will be truncated

+ * to "123456789abcdef". See PR_SET_NAME in prctl(2). So all in all

+ * we'd need to read 21 + 15 = 36 bytes.

+ *

+ * Let's just read 2^6 (64) instead for good measure. If PID_MAX ever

+ * grows past 2^22 we'll be future-proof. We'll then anchor at the

+ * last ")" we find to locate the parent PID.

+ */

+#define STAT_PARENT_PID_READ_N 64

+

+static int parse_proc_stat(struct strbuf *sb, struct strbuf *name,

+ int *statppid)

+ const char *comm_lhs = strchr(sb->buf, '(');

+ const char *comm_rhs = strrchr(sb->buf, ')');

+ const char *ppid_lhs, *ppid_rhs;

+ char *p;

+ pid_t ppid;

+

+ if (!comm_lhs || !comm_rhs)

+ goto bad_kernel;

+

+ /*

+ * We're at the ")", that's followed by " X ", where X is a

+ * single "state" character. So advance by 4 bytes.

+ */

+ ppid_lhs = comm_rhs + 4;

+

+ /*

+ * Read until the space between the "ppid" and "pgrp" fields

+ * to make sure we're anchored after the untruncated "ppid"

+ * field..

+ */

+ ppid_rhs = strchr(ppid_lhs, ' ');

+ if (!ppid_rhs)

+ goto bad_kernel;

+

+ ppid = strtol(ppid_lhs, &p, 10);

+ if (ppid_rhs == p) {

+ const char *comm = comm_lhs + 1;

+ size_t commlen = comm_rhs - comm;

+

+ strbuf_add(name, comm, commlen);

+ *statppid = ppid;

+

+ return 0;

+ }

+

+bad_kernel:

+ * We were able to read our STAT_PARENT_PID_READ_N bytes from

+ * /proc/%d/stat, but the content is bad. Broken kernel?

+ * Should not happen, but handle it gracefully.

+ return -1;

+}

+

+static int stat_parent_pid(pid_t pid, struct strbuf *name, int *statppid)

+{

+ struct strbuf sb = STRBUF_INIT;

+ FILE *fp;

+ int ret = -1;

+ strbuf_addf(&procfs_path, "/proc/%d/stat", pid);

+ fp = fopen(procfs_path.buf, "r");

+ if (!fp)

+ goto cleanup;

+

+ /*

+ * We could be more strict here and assert that we read at

+ * least STAT_PARENT_PID_READ_N. My reading of procfs(5) is

+ * that on any modern kernel (at least since 2.6.0 released in

+ * 2003) even if all the mandatory numeric fields were zero'd

+ * out we'd get at least 100 bytes, but let's just check that

+ * we got anything at all and trust the parse_proc_stat()

+ * function to handle its "Bad Kernel?" error checking.

+ */

+ if (!strbuf_fread(&sb, STAT_PARENT_PID_READ_N, fp))

+ goto cleanup;

+ if (parse_proc_stat(&sb, name, statppid) < 0)

+ goto cleanup;

+

+ ret = 0;

+cleanup:

+ if (fp)

+ fclose(fp);

+ strbuf_release(&procfs_path);

+ strbuf_release(&sb);

+

+ return ret;

+}

+

+static void push_ancestry_name(struct strvec *names, pid_t pid)

+{

+ struct strbuf name = STRBUF_INIT;

+ int ppid;

+

+ if (stat_parent_pid(pid, &name, &ppid) < 0)

+ goto cleanup;

+

+ strvec_push(names, name.buf);

+

+ /*

+ * Both errors and reaching the end of the process chain are

+ * reported as fields of 0 by proc(5)

+ */

+ if (ppid)

+ push_ancestry_name(names, ppid);

+cleanup:

+ strbuf_release(&name);

+ struct strvec names = STRVEC_INIT;

+ if (!trace2_is_enabled())

+ switch (reason) {

+ case TRACE2_PROCESS_INFO_EXIT:

+ * The Windows version of this calls its

+ * get_peak_memory_info() here. We may want to insert

+ * similar process-end statistics here in the future.

+ break;

+ case TRACE2_PROCESS_INFO_STARTUP:

+ push_ancestry_name(&names, getppid());

+ break;

+ fprintf(stderr, "Attempt to free already freed memory block %p - aborting!\n", (void *)tck);

+static inline FARPROC get_proc_addr(struct proc_addr *proc)

+ struct repository *repo,

+ buf = repo_read_object_file(repo, oid, &type, &size);

+ struct repository *repo,

+ if (repo_get_oid(repo, name, &oid) < 0)

+ return git_config_from_blob_oid(fn, name, repo, &oid, data);

+ if (config_source && config_source->use_stdin) {

+ } else if (config_source && config_source->file) {

+ } else if (config_source && config_source->blob) {

+ struct repository *repo = config_source->repo ?

+ config_source->repo : the_repository;

+ return git_config_from_blob_ref(fn, repo, config_source->blob,

+ data);

+ }

+ /* The repository if blob is not NULL; leave blank for the_repository */

+ struct repository *repo;

+ struct repository *repo,

+ifndef COMPILER_FEATURES

+COMPILER_FEATURES := $(shell ./detect-compiler $(CC))

+endif

+

+DEVELOPER_CFLAGS += -Wall

+ifeq ($(filter no-pedantic,$(DEVOPTS)),)

+DEVELOPER_CFLAGS += -Wpedantic

+ifneq ($(filter gcc5,$(COMPILER_FEATURES)),)

+DEVELOPER_CFLAGS += -Wno-pedantic-ms-format

+DEVELOPER_CFLAGS += -Wno-incompatible-pointer-types

+endif

+ const struct object_id *oid;

+ oid = fn(cb_data);

+ if (!oid) {

+ if (find_pack_entry_one(oid->hash, p))

+ } while ((oid = fn(cb_data)) != NULL);

+ if (new_pack && find_pack_entry_one(oid->hash, new_pack))

+ if (fprintf(rev_list_in, "%s\n", oid_to_hex(oid)) < 0)

+ } while ((oid = fn(cb_data)) != NULL);

+typedef const struct object_id *(*oid_iterate_fn)(void *);

+static int suppress_m_parsing;

+void diff_merges_suppress_m_parsing(void)

+ suppress_m_parsing = 1;

+ if (!suppress_m_parsing && !strcmp(arg, "-m")) {

+void diff_merges_suppress_m_parsing(void);

+#include "dir.h"

+ /*

+ * If this path does not match our sparse-checkout definition,

+ * then the file will not be in the working directory.

+ */

+ if (!path_in_sparse_checkout(name, istate))

+ return 0;

+

+int init_sparse_checkout_patterns(struct index_state *istate)

+{

+ if (!core_apply_sparse_checkout)

+ return 1;

+ if (istate->sparse_checkout_patterns)

+ return 0;

+

+ CALLOC_ARRAY(istate->sparse_checkout_patterns, 1);

+

+ if (get_sparse_checkout_patterns(istate->sparse_checkout_patterns) < 0) {

+ FREE_AND_NULL(istate->sparse_checkout_patterns);

+ return -1;

+ }

+

+ return 0;

+}

+

+static int path_in_sparse_checkout_1(const char *path,

+ struct index_state *istate,

+ int require_cone_mode)

+{

+ const char *base;

+ int dtype = DT_REG;

+

+ /*

+ * We default to accepting a path if there are no patterns or

+ * they are of the wrong type.

+ */

+ if (init_sparse_checkout_patterns(istate) ||

+ (require_cone_mode &&

+ !istate->sparse_checkout_patterns->use_cone_patterns))

+ return 1;

+

+ base = strrchr(path, '/');

+ return path_matches_pattern_list(path, strlen(path), base ? base + 1 : path,

+ &dtype,

+ istate->sparse_checkout_patterns,

+ istate) > 0;

+}

+

+int path_in_sparse_checkout(const char *path,

+ struct index_state *istate)

+{

+ return path_in_sparse_checkout_1(path, istate, 0);

+}

+

+int path_in_cone_mode_sparse_checkout(const char *path,

+ struct index_state *istate)

+{

+ return path_in_sparse_checkout_1(path, istate, 1);

+}

+

+char *git_url_basename(const char *repo, int is_bundle, int is_bare)

+{

+ const char *end = repo + strlen(repo), *start, *ptr;

+ size_t len;

+ char *dir;

+

+ /*

+ * Skip scheme.

+ */

+ start = strstr(repo, "://");

+ if (start == NULL)

+ start = repo;

+ else

+ start += 3;

+

+ /*

+ * Skip authentication data. The stripping does happen

+ * greedily, such that we strip up to the last '@' inside

+ * the host part.

+ */

+ for (ptr = start; ptr < end && !is_dir_sep(*ptr); ptr++) {

+ if (*ptr == '@')

+ start = ptr + 1;

+ }

+

+ /*

+ * Strip trailing spaces, slashes and /.git

+ */

+ while (start < end && (is_dir_sep(end[-1]) || isspace(end[-1])))

+ end--;

+ if (end - start > 5 && is_dir_sep(end[-5]) &&

+ !strncmp(end - 4, ".git", 4)) {

+ end -= 5;

+ while (start < end && is_dir_sep(end[-1]))

+ end--;

+ }

+

+ /*

+ * Strip trailing port number if we've got only a

+ * hostname (that is, there is no dir separator but a

+ * colon). This check is required such that we do not

+ * strip URI's like '/foo/bar:2222.git', which should

+ * result in a dir '2222' being guessed due to backwards

+ * compatibility.

+ */

+ if (memchr(start, '/', end - start) == NULL

+ && memchr(start, ':', end - start) != NULL) {

+ ptr = end;

+ while (start < ptr && isdigit(ptr[-1]) && ptr[-1] != ':')

+ ptr--;

+ if (start < ptr && ptr[-1] == ':')

+ end = ptr - 1;

+ }

+

+ /*

+ * Find last component. To remain backwards compatible we

+ * also regard colons as path separators, such that

+ * cloning a repository 'foo:bar.git' would result in a

+ * directory 'bar' being guessed.

+ */

+ ptr = end;

+ while (start < ptr && !is_dir_sep(ptr[-1]) && ptr[-1] != ':')

+ ptr--;

+ start = ptr;

+

+ /*

+ * Strip .{bundle,git}.

+ */

+ len = end - start;

+ strip_suffix_mem(start, &len, is_bundle ? ".bundle" : ".git");

+

+ if (!len || (len == 1 && *start == '/'))

+ die(_("No directory name could be guessed.\n"

+ "Please specify a directory on the command line"));

+

+ if (is_bare)

+ dir = xstrfmt("%.*s.git", (int)len, start);

+ else

+ dir = xstrndup(start, len);

+ /*

+ * Replace sequences of 'control' characters and whitespace

+ * with one ascii space, remove leading and trailing spaces.

+ */

+ if (*dir) {

+ char *out = dir;

+ int prev_space = 1 /* strip leading whitespace */;

+ for (end = dir; *end; ++end) {

+ char ch = *end;

+ if ((unsigned char)ch < '\x20')

+ ch = '\x20';

+ if (isspace(ch)) {

+ if (prev_space)

+ continue;

+ prev_space = 1;

+ } else

+ prev_space = 0;

+ *out++ = ch;

+ }

+ *out = '\0';

+ if (out > dir && prev_space)

+ out[-1] = '\0';

+ }

+ return dir;

+}

+

+void strip_dir_trailing_slashes(char *dir)

+{

+ char *end = dir + strlen(dir);

+

+ while (dir < end - 1 && is_dir_sep(end[-1]))

+ end--;

+ *end = '\0';

+}

+

+

+int init_sparse_checkout_patterns(struct index_state *state);

+

+int path_in_sparse_checkout(const char *path,

+ struct index_state *istate);

+int path_in_cone_mode_sparse_checkout(const char *path,

+ struct index_state *istate);

+

+/*

+ * Retrieve the "humanish" basename of the given Git URL.

+ *

+ * For example:

+ * /path/to/repo.git => "repo"

+ * host.xz:foo/.git => "foo"

+ * http://example.com/user/bar.baz => "bar.baz"

+ */

+char *git_url_basename(const char *repo, int is_bundle, int is_bare);

+void strip_dir_trailing_slashes(char *dir);

+

+ unsigned processed_paths = 0;

+ struct progress *progress = NULL;

+ if (show_progress)

+ progress = start_delayed_progress(_("Filtering content"), dco->paths.nr);

+ display_progress(progress, ++processed_paths);

+ struct commit *commit;

+

+ commit = lookup_commit_in_graph(the_repository, oid);

+ if (commit)

+ return commit;

+static const struct object_id *iterate_ref_map(void *cb_data)

+ return NULL;

+ return &ref->old_oid;

+ my $v = $known_keys->{$key}->[-1];

+ if test -z "$1"

+ git ${wt_prefix:+-C "$wt_prefix"} ${prefix:+--super-prefix "$prefix"} submodule--helper add ${GIT_QUIET:+--quiet} ${force:+--force} ${progress:+"--progress"} ${branch:+--branch "$branch"} ${reference_path:+--reference "$reference_path"} ${dissociate:+--dissociate} ${custom_name:+--name "$custom_name"} ${depth:+"$depth"} -- "$@"

+ just_cloned=

+ out=$(git submodule--helper run-update-procedure \

+ ${wt_prefix:+--prefix "$wt_prefix"} \

+ ${GIT_QUIET:+--quiet} \

+ ${force:+--force} \

+ ${just_cloned:+--just-cloned} \

+ ${nofetch:+--no-fetch} \

+ ${depth:+"$depth"} \

+ ${update:+--update "$update"} \

+ ${prefix:+--recursive-prefix "$prefix"} \

+ ${sha1:+--oid "$sha1"} \

+ ${subsha1:+--suboid "$subsha1"} \

+ "--" \

+ "$sm_path")

+

+ # exit codes for run-update-procedure:

+ # 0: update was successful, say command output

+ # 1: update procedure failed, but should not die

+ # 2 or 128: subcommand died during execution

+ # 3: no update procedure was run

+ res="$?"

+ case $res in

+ 0)

+ say "$out"

+ ;;

+ 1)

+ err="${err};fatal: $out"

+ continue

+ ;;

+ 2|128)

+ die_with_status $res "fatal: $out"

+ ;;

+ esac

+ { "multi-pack-index", cmd_multi_pack_index, RUN_SETUP },

+static void grep_source_init_buf(struct grep_source *gs, char *buf,

+ unsigned long size)

+{

+ gs->type = GREP_SOURCE_BUF;

+ gs->name = NULL;

+ gs->path = NULL;

+ gs->buf = buf;

+ gs->size = size;

+ gs->driver = NULL;

+ gs->identifier = NULL;

+}

+

+ grep_source_init_buf(&gs, buf, size);

+void grep_source_init_file(struct grep_source *gs, const char *name,

+ const char *path)

+ gs->type = GREP_SOURCE_FILE;

+ gs->identifier = xstrdup(path);

+}

+void grep_source_init_oid(struct grep_source *gs, const char *name,

+ const char *path, const struct object_id *oid,

+ struct repository *repo)

+{

+ gs->type = GREP_SOURCE_OID;

+ gs->name = xstrdup_or_null(name);

+ gs->path = xstrdup_or_null(path);

+ gs->buf = NULL;

+ gs->size = 0;

+ gs->driver = NULL;

+ gs->identifier = oiddup(oid);

+ gs->repo = repo;

+ gs->buf = repo_read_object_file(gs->repo, gs->identifier, &type,

+ &gs->size);

+

+ /*

+ * NEEDSWORK: See if we can remove this field, because the repository

+ * should probably be per-source. That is, grep.c functions using this

+ * field should probably start using "repo" in "struct grep_source"

+ * instead.

+ *

+ * This is potentially the cause of at least one bug - "git grep"

+ * ignoring the textconv attributes from submodules. See [1] for more

+ * information.

+ * [1] https://lore.kernel.org/git/CAHd-oW5iEQarYVxEXoTG-ua2zdoybTrSjCBKtO0YT292fm0NQQ@mail.gmail.com/

+ */

+

+ struct repository *repo; /* if GREP_SOURCE_OID */

+void grep_source_init_file(struct grep_source *gs, const char *name,

+ const char *path);

+void grep_source_init_oid(struct grep_source *gs, const char *name,

+ const char *path, const struct object_id *oid,

+ struct repository *repo);

+ "--http-backend-info-refs",

+ packet_fwrite(stdout, data->buf.buf, data->buf.len);

+int ls_refs(struct repository *r, struct packet_reader *request)

+ packet_fflush(stdout);

+int ls_refs(struct repository *r, struct packet_reader *request);

+ /*

+ * We are in a conflicted state. These conflicts might be inside

+ * sparse-directory entries, so check if any entries are outside

+ * of the sparse-checkout cone preemptively.

+ *

+ * We set original_cache_nr below, but that might change if

+ * index_name_pos() calls ask for paths within sparse directories.

+ */

+ strmap_for_each_entry(&opt->priv->conflicted, &iter, e) {

+ if (!path_in_sparse_checkout(e->key, index)) {

+ ensure_full_index(index);

+ break;

+ }

+ }

+

+ prepare_repo_settings(opt->repo);

+ opt->repo->settings.command_requires_full_index = 1;

+

+#include "pack-bitmap.h"

+#include "refs.h"

+#include "revision.h"

+#include "list-objects.h"

+const unsigned char *get_midx_checksum(struct multi_pack_index *m)

+char *get_midx_filename(const char *object_dir)

+ close_midx(m->next);

+

+ free(m);

+static void clear_midx_files_ext(const char *object_dir, const char *ext,

+static void prepare_midx_packing_data(struct packing_data *pdata,

+ struct write_midx_context *ctx)

+{

+ uint32_t i;

+

+ memset(pdata, 0, sizeof(struct packing_data));

+ prepare_packing_data(the_repository, pdata);

+

+ for (i = 0; i < ctx->entries_nr; i++) {

+ struct pack_midx_entry *from = &ctx->entries[ctx->pack_order[i]];

+ struct object_entry *to = packlist_alloc(pdata, &from->oid);

+

+ oe_set_in_pack(pdata, to,

+ ctx->info[ctx->pack_perm[from->pack_int_id]].p);

+ }

+}

+

+static int add_ref_to_pending(const char *refname,

+ const struct object_id *oid,

+ int flag, void *cb_data)

+{

+ struct rev_info *revs = (struct rev_info*)cb_data;

+ struct object *object;

+

+ if ((flag & REF_ISSYMREF) && (flag & REF_ISBROKEN)) {

+ warning("symbolic ref is dangling: %s", refname);

+ return 0;

+ }

+

+ object = parse_object_or_die(oid, refname);

+ if (object->type != OBJ_COMMIT)

+ return 0;

+

+ add_pending_object(revs, object, "");

+ if (bitmap_is_preferred_refname(revs->repo, refname))

+ object->flags |= NEEDS_BITMAP;

+ return 0;

+}

+

+struct bitmap_commit_cb {

+ struct commit **commits;

+ size_t commits_nr, commits_alloc;

+

+ struct write_midx_context *ctx;

+};

+

+static const struct object_id *bitmap_oid_access(size_t index,

+ const void *_entries)

+{

+ const struct pack_midx_entry *entries = _entries;

+ return &entries[index].oid;

+}

+

+static void bitmap_show_commit(struct commit *commit, void *_data)

+{

+ struct bitmap_commit_cb *data = _data;

+ int pos = oid_pos(&commit->object.oid, data->ctx->entries,

+ data->ctx->entries_nr,

+ bitmap_oid_access);

+ if (pos < 0)

+ return;

+

+ ALLOC_GROW(data->commits, data->commits_nr + 1, data->commits_alloc);

+ data->commits[data->commits_nr++] = commit;

+}

+

+static struct commit **find_commits_for_midx_bitmap(uint32_t *indexed_commits_nr_p,

+ struct write_midx_context *ctx)

+{

+ struct rev_info revs;

+ struct bitmap_commit_cb cb = {0};

+

+ cb.ctx = ctx;

+

+ repo_init_revisions(the_repository, &revs, NULL);

+ setup_revisions(0, NULL, &revs, NULL);

+ for_each_ref(add_ref_to_pending, &revs);

+

+ /*

+ * Skipping promisor objects here is intentional, since it only excludes

+ * them from the list of reachable commits that we want to select from

+ * when computing the selection of MIDX'd commits to receive bitmaps.

+ *

+ * Reachability bitmaps do require that their objects be closed under

+ * reachability, but fetching any objects missing from promisors at this

+ * point is too late. But, if one of those objects can be reached from

+ * an another object that is included in the bitmap, then we will

+ * complain later that we don't have reachability closure (and fail

+ * appropriately).

+ */

+ fetch_if_missing = 0;

+ revs.exclude_promisor_objects = 1;

+

+ if (prepare_revision_walk(&revs))

+ die(_("revision walk setup failed"));

+

+ traverse_commit_list(&revs, bitmap_show_commit, NULL, &cb);

+ if (indexed_commits_nr_p)

+ *indexed_commits_nr_p = cb.commits_nr;

+

+ return cb.commits;

+}

+

+static int write_midx_bitmap(char *midx_name, unsigned char *midx_hash,

+ struct write_midx_context *ctx,

+ unsigned flags)

+{

+ struct packing_data pdata;

+ struct pack_idx_entry **index;

+ struct commit **commits = NULL;

+ uint32_t i, commits_nr;

+ char *bitmap_name = xstrfmt("%s-%s.bitmap", midx_name, hash_to_hex(midx_hash));

+ int ret;

+

+ prepare_midx_packing_data(&pdata, ctx);

+

+ commits = find_commits_for_midx_bitmap(&commits_nr, ctx);

+

+ /*

+ * Build the MIDX-order index based on pdata.objects (which is already

+ * in MIDX order; c.f., 'midx_pack_order_cmp()' for the definition of

+ * this order).

+ */

+ ALLOC_ARRAY(index, pdata.nr_objects);

+ for (i = 0; i < pdata.nr_objects; i++)

+ index[i] = &pdata.objects[i].idx;

+

+ bitmap_writer_show_progress(flags & MIDX_PROGRESS);

+ bitmap_writer_build_type_index(&pdata, index, pdata.nr_objects);

+

+ /*

+ * bitmap_writer_finish expects objects in lex order, but pack_order

+ * gives us exactly that. use it directly instead of re-sorting the

+ * array.

+ *

+ * This changes the order of objects in 'index' between

+ * bitmap_writer_build_type_index and bitmap_writer_finish.

+ *

+ * The same re-ordering takes place in the single-pack bitmap code via

+ * write_idx_file(), which is called by finish_tmp_packfile(), which

+ * happens between bitmap_writer_build_type_index() and

+ * bitmap_writer_finish().

+ */

+ for (i = 0; i < pdata.nr_objects; i++)

+ index[ctx->pack_order[i]] = &pdata.objects[i].idx;

+

+ bitmap_writer_select_commits(commits, commits_nr, -1);

+ ret = bitmap_writer_build(&pdata);

+ if (ret < 0)

+ goto cleanup;

+

+ bitmap_writer_set_checksum(midx_hash);

+ bitmap_writer_finish(index, pdata.nr_objects, bitmap_name, 0);

+

+cleanup:

+ free(index);

+ free(bitmap_name);

+ return ret;

+}

+

+static int write_midx_internal(const char *object_dir,

+ struct multi_pack_index *cur;

+ /* Ensure the given object_dir is local, or a known alternate. */

+ find_odb(the_repository, object_dir);

+

+ for (cur = get_multi_pack_index(the_repository); cur; cur = cur->next) {

+ if (!strcmp(object_dir, cur->object_dir)) {

+ ctx.m = cur;

+ break;

+ }

+ }

+ ctx.info[ctx.nr].p = ctx.m->packs[i];

+

+ if (flags & MIDX_WRITE_REV_INDEX) {

+ /*

+ * If generating a reverse index, need to have

+ * packed_git's loaded to compare their

+ * mtimes and object count.

+ */

+ if (prepare_midx_pack(the_repository, ctx.m, i)) {

+ error(_("could not load pack"));

+ result = 1;

+ goto cleanup;

+ }

+

+ if (open_pack_index(ctx.m->packs[i]))

+ die(_("could not open index for %s"),

+ ctx.m->packs[i]->pack_name);

+ ctx.info[ctx.nr].p = ctx.m->packs[i];

+ }

+

+ if (ctx.m && ctx.nr == ctx.m->num_packs && !packs_to_drop) {

+ struct bitmap_index *bitmap_git;

+ int bitmap_exists;

+ int want_bitmap = flags & MIDX_WRITE_BITMAP;

+

+ bitmap_git = prepare_midx_bitmap_git(ctx.m);

+ bitmap_exists = bitmap_git && bitmap_is_midx(bitmap_git);

+ free_bitmap_index(bitmap_git);

+

+ if (bitmap_exists || !want_bitmap) {

+ /*

+ * The correct MIDX already exists, and so does a

+ * corresponding bitmap (or one wasn't requested).

+ */

+ if (!want_bitmap)

+ clear_midx_files_ext(object_dir, ".bitmap",

+ NULL);

+ goto cleanup;

+ }

+ }

+ int found = 0;

+ found = 1;

+

+ if (!found)

+ warning(_("unknown preferred pack: '%s'"),

+ preferred_pack_name);

+ } else if (ctx.nr &&

+ (flags & (MIDX_WRITE_REV_INDEX | MIDX_WRITE_BITMAP))) {

+ struct packed_git *oldest = ctx.info[ctx.preferred_pack_idx].p;

+ ctx.preferred_pack_idx = 0;

+

+ if (packs_to_drop && packs_to_drop->nr)

+ BUG("cannot write a MIDX bitmap during expiration");

+

+ /*

+ * set a preferred pack when writing a bitmap to ensure that

+ * the pack from which the first object is selected in pseudo

+ * pack-order has all of its objects selected from that pack

+ * (and not another pack containing a duplicate)

+ */

+ for (i = 1; i < ctx.nr; i++) {

+ struct packed_git *p = ctx.info[i].p;

+

+ if (!oldest->num_objects || p->mtime < oldest->mtime) {

+ oldest = p;

+ ctx.preferred_pack_idx = i;

+ }

+ }

+

+ if (!oldest->num_objects) {

+ /*

+ * If all packs are empty; unset the preferred index.

+ * This is acceptable since there will be no duplicate

+ * objects to resolve, so the preferred value doesn't

+ * matter.

+ */

+ ctx.preferred_pack_idx = -1;

+ }

+ } else {

+ /*

+ * otherwise don't mark any pack as preferred to avoid

+ * interfering with expiration logic below

+ */

+ ctx.preferred_pack_idx = -1;

+ }

+

+ if (ctx.preferred_pack_idx > -1) {

+ struct packed_git *preferred = ctx.info[ctx.preferred_pack_idx].p;

+ if (!preferred->num_objects) {

+ error(_("cannot select preferred pack %s with no objects"),

+ preferred->pack_name);

+ result = 1;

+ goto cleanup;

+ }

+ if (preferred) {

+ if (flags & (MIDX_WRITE_REV_INDEX | MIDX_WRITE_BITMAP))

+ if (flags & MIDX_WRITE_BITMAP) {

+ if (write_midx_bitmap(midx_name, midx_hash, &ctx, flags) < 0) {

+ error(_("could not write multi-pack bitmap"));

+ result = 1;

+ goto cleanup;

+ }

+ }

+

+ if (ctx.m)

+ close_object_store(the_repository->objects);

+ clear_midx_files_ext(object_dir, ".bitmap", midx_hash);

+ clear_midx_files_ext(object_dir, ".rev", midx_hash);

+

+

+ return write_midx_internal(object_dir, NULL, preferred_pack_name, flags);

+static void clear_midx_files_ext(const char *object_dir, const char *ext,

+ for_each_file_in_pack_dir(object_dir,

+ clear_midx_files_ext(r->objects->odb->path, ".bitmap", NULL);

+ clear_midx_files_ext(r->objects->odb->path, ".rev", NULL);

+ if (packs_to_drop.nr) {

+ result = write_midx_internal(object_dir, &packs_to_drop, NULL, flags);

+ m = NULL;

+ }

+ result = write_midx_internal(object_dir, NULL, NULL, flags);

+#define GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP \

+ "GIT_TEST_MULTI_PACK_INDEX_WRITE_BITMAP"

+#define MIDX_WRITE_BITMAP (1 << 2)

+const unsigned char *get_midx_checksum(struct multi_pack_index *m);

+char *get_midx_filename(const char *object_dir);

+#include "submodule.h"

+struct object_directory *find_odb(struct repository *r, const char *obj_dir)

+{

+ struct object_directory *odb;

+ char *obj_dir_real = real_pathdup(obj_dir, 1);

+ struct strbuf odb_path_real = STRBUF_INIT;

+

+ prepare_alt_odb(r);

+ for (odb = r->objects->odb; odb; odb = odb->next) {

+ strbuf_realpath(&odb_path_real, odb->path, 1);

+ if (!strcmp(obj_dir_real, odb_path_real.buf))

+ break;

+ }

+

+ free(obj_dir_real);

+ strbuf_release(&odb_path_real);

+

+ if (!odb)

+ die(_("could not find object directory matching %s"), obj_dir);

+ return odb;

+}

+

+ if (register_all_submodule_odb_as_alternates())

+ /* We added some alternates; retry */

+ continue;

+

+struct object_directory *find_odb(struct repository *r, const char *obj_dir);

+ * Build the initial type index for the packfile or multi-pack-index

+static uint32_t find_object_pos(const struct object_id *oid, int *found)

+ if (found)

+ *found = 0;

+ warning("Failed to write bitmap index. Packfile doesn't have full closure "

+ return 0;

+ if (found)

+ *found = 1;

+static int fill_bitmap_tree(struct bitmap *bitmap,

+ struct tree *tree)

+ int found;

+ pos = find_object_pos(&tree->object.oid, &found);

+ if (!found)

+ return -1;

+ return 0;

+ if (fill_bitmap_tree(bitmap,

+ lookup_tree(the_repository, &entry.oid)) < 0)

+ return -1;

+ pos = find_object_pos(&entry.oid, &found);

+ if (!found)

+ return -1;

+ bitmap_set(bitmap, pos);

+ return 0;

+static int fill_bitmap_commit(struct bb_commit *ent,

+ struct commit *commit,

+ struct prio_queue *queue,

+ struct prio_queue *tree_queue,

+ struct bitmap_index *old_bitmap,

+ const uint32_t *mapping)

+ int found;

+ uint32_t pos;

+ pos = find_object_pos(&c->object.oid, &found);

+ if (!found)

+ return -1;

+ bitmap_set(ent->bitmap, pos);

+ pos = find_object_pos(&p->item->object.oid, &found);

+ if (!found)

+ return -1;

+ while (tree_queue->nr) {

+ if (fill_bitmap_tree(ent->bitmap,

+ prio_queue_get(tree_queue)) < 0)

+ return -1;

+ }

+ return 0;

+int bitmap_writer_build(struct packing_data *to_pack)

+ int closed = 1; /* until proven otherwise */

+ if (fill_bitmap_commit(ent, commit, &queue, &tree_queue,

+ old_bitmap, mapping) < 0) {

+ closed = 0;

+ break;

+ }

+ free_bitmap_index(old_bitmap);

+ if (closed)

+ compute_xor_offsets();

+ return closed ? 0 : -1;

+#include "midx.h"

+ /*

+ * The pack or multi-pack index (MIDX) that this bitmap index belongs

+ * to.

+ *

+ * Exactly one of these must be non-NULL; this specifies the object

+ * order used to interpret this bitmap.

+ */

+ struct multi_pack_index *midx;

+ /* The checksum of the packfile or MIDX; points into map. */

+ const unsigned char *checksum;

+

+static uint32_t bitmap_num_objects(struct bitmap_index *index)

+{

+ if (index->midx)

+ return index->midx->num_objects;

+ return index->pack->num_objects;

+}

+

+ size_t cache_size = st_mult(bitmap_num_objects(index), sizeof(uint32_t));

+ index->checksum = header->checksum;

+static int nth_bitmap_object_oid(struct bitmap_index *index,

+ struct object_id *oid,

+ uint32_t n)

+{

+ if (index->midx)

+ return nth_midxed_object_oid(oid, index->midx, n) ? 0 : -1;

+ return nth_packed_object_id(oid, index->pack, n);

+}

+

+ if (nth_bitmap_object_oid(index, &oid, commit_idx_pos) < 0)

+char *midx_bitmap_filename(struct multi_pack_index *midx)

+{

+ return xstrfmt("%s-%s.bitmap",

+ get_midx_filename(midx->object_dir),

+ hash_to_hex(get_midx_checksum(midx)));

+}

+

+char *pack_bitmap_filename(struct packed_git *p)

+static int open_midx_bitmap_1(struct bitmap_index *bitmap_git,

+ struct multi_pack_index *midx)

+{

+ struct stat st;

+ char *idx_name = midx_bitmap_filename(midx);

+ int fd = git_open(idx_name);

+

+ free(idx_name);

+

+ if (fd < 0)

+ return -1;

+

+ if (fstat(fd, &st)) {

+ close(fd);

+ return -1;

+ }

+

+ if (bitmap_git->pack || bitmap_git->midx) {

+ /* ignore extra bitmap file; we can only handle one */

+ warning("ignoring extra bitmap file: %s",

+ get_midx_filename(midx->object_dir));

+ close(fd);

+ return -1;

+ }

+

+ bitmap_git->midx = midx;

+ bitmap_git->map_size = xsize_t(st.st_size);

+ bitmap_git->map_pos = 0;

+ bitmap_git->map = xmmap(NULL, bitmap_git->map_size, PROT_READ,

+ MAP_PRIVATE, fd, 0);

+ close(fd);

+

+ if (load_bitmap_header(bitmap_git) < 0)

+ goto cleanup;

+

+ if (!hasheq(get_midx_checksum(bitmap_git->midx), bitmap_git->checksum))

+ goto cleanup;

+

+ if (load_midx_revindex(bitmap_git->midx) < 0) {

+ warning(_("multi-pack bitmap is missing required reverse index"));

+ goto cleanup;

+ }

+ return 0;

+

+cleanup:

+ munmap(bitmap_git->map, bitmap_git->map_size);

+ bitmap_git->map_size = 0;

+ bitmap_git->map = NULL;

+ return -1;

+}

+

+ if (bitmap_git->pack || bitmap_git->midx) {

+ /* ignore extra bitmap file; we can only handle one */

+static int load_reverse_index(struct bitmap_index *bitmap_git)

+{

+ if (bitmap_is_midx(bitmap_git)) {

+ uint32_t i;

+ int ret;

+

+ /*

+ * The multi-pack-index's .rev file is already loaded via

+ * open_pack_bitmap_1().

+ *