/git-init-db

/git-interpret-trailers

/git-instaweb

/git-log

/git-ls-files

/git-ls-remote

variables:

NO_PERL: 1

before_script:

- ./ci/install-sdk.ps1 -directory "git-sdk"

script:

- git-sdk/usr/bin/bash.exe -l -c 'ci/make-test-artifacts.sh artifacts'

- job: "build:mingw64"

artifacts: true

before_script:

- git-sdk/usr/bin/bash.exe -l -c 'tar xf artifacts/artifacts.tar.gz'

- New-Item -Path .git/info -ItemType Directory

- New-Item .git/info/exclude -ItemType File -Value "/git-sdk"

tags:

- saas-windows-medium-amd64

before_script:

- choco install -y git meson ninja openssl

- Import-Module $env:ChocolateyInstall\helpers\chocolateyProfile.psm1

- refreshenv

Frédéric Heitzmann <frederic.heitzmann@gmail.com>

Garry Dolley <gdolley@ucla.edu> <gdolley@arpnetworks.com>

Glen Choo <glencbz@gmail.com> <chooglen@google.com>

Greg Price <price@mit.edu> <price@MIT.EDU>

Greg Price <price@mit.edu> <price@ksplice.com>

Heiko Voigt <hvoigt@hvoigt.net> <git-list@hvoigt.net>

+

The command will be removed.

== Superseded features that will not be deprecated

Some features have gained newer replacements that aim to improve the design in

cases. However, it is recommended to find a more descriptive name wherever

possible to improve the readability and maintainability of the code.

For Perl programs:

- Most of the C guidelines above apply.

can be answered if you disconnect and so that others can learn from the

conversation.

[[getting-started]]

== Getting Started

=== Sending a PR to GitGitGadget

In order to have your code tested and formatted for review, you need to start by

Review the PR's title and description, as they're used by GitGitGadget

respectively as the subject and body of the cover letter for your change. Refer

* A new subcommand "git repo" gives users a way to grab various

repository characteristics.

Performance, Internal Implementation, Development Support etc.

--------------------------------------------------------------

* Remove dependency on the_repository and other globals from the

commit-graph code, and other changes unrelated to de-globaling.

Fixes since v2.51

-----------------

ignored") did not work well with "--name-only" and friends.

(merge b55e6d36eb ly/diff-name-only-with-diff-from-content later to maint).

* Other code cleanup, docfix, build fix, etc.

(merge 823d537fa7 kh/doc-git-log-markup-fix later to maint).

(merge cf7efa4f33 rj/t6137-cygwin-fix later to maint).

(merge 741f36c7d9 kr/clone-synopsis-fix later to maint).

(merge a60203a015 dk/t7005-editor-updates later to maint).

(merge 7d4a5fef7d ds/doc-count-objects-fix later to maint).

are:

`gitdir`::

pattern. If the location of the .git directory matches the

pattern, the include condition is met.

+

case-insensitively (e.g. on case-insensitive file systems)

`onbranch`::

pattern with standard globbing wildcards and two additional

ones, `**/` and `/**`, that can match multiple path components.

If we are in a worktree where the name of the branch that is

organized hierarchically and you would like to apply a configuration to

all the branches in that hierarchy.

be a pattern with standard globbing wildcards and two

additional ones, `**/` and `/**`, that can match multiple

components. The first time this keyword is seen, the rest of

** A convenient way to deal with this is to write your script

operations in an inline function that is then called with any

arguments from the command-line. For example `alias.cmd = "!c() {

** Setting `GIT_TRACE=1` can help you debug the command being run for

your alias.

commented, and removes them after the editor returns

(default '#').

+

the beginning character of any line in existing commit messages.

Note that these two variables are aliases of each other, and in modern

versions of Git you are free to use a string (e.g., `//` or `⁑⁕⁑`) with

`commentChar`. Versions of Git prior to v2.45.0 will ignore

compatObjectFormat. As well as being able to use oids encoded in

compatObjectFormat in addition to oids encoded with objectFormat to

locally specify objects.

noop::

This extension does not change git's behavior at all. It is useful only

During a merge, Git will automatically resolve as many conflicts as

possible and write the `$MERGED` file containing conflict markers around

any conflicts that it cannot resolve; `$LOCAL` and `$REMOTE` normally

resolution. This flag causes `$LOCAL` and `$REMOTE` to be overwritten so

that only the unresolved conflicts are presented to the merge tool. Can

be configured per-tool via the `mergetool.<tool>.hideResolved`

sendemail.smtpServerPort::

sendemail.smtpServerOption::

sendemail.smtpUser::

sendemail.thread::

sendemail.transferEncoding::

sendemail.validate::

different locations or environments. Defaults to "false".

+

Note that setting `worktree.useRelativePaths` to "true" implies enabling the

thus making it incompatible with older versions of Git.

--no-all::

Fetch all remotes, except for the ones that has the

`remote.<name>.skipFetchAll` configuration variable set.

-a::

--append::

DESCRIPTION

-----------

This command can be performed multiple times before a commit. It only

adds the content of the specified file(s) at the time the add command is

The `git status` command can be used to obtain a summary of which

files have changes that are staged for the next commit.

Please see linkgit:git-commit[1] for alternative ways to add content to a

commit.

currently impacts only the `export-marks`, `import-marks`, and

`import-marks-if-exists` feature commands.

+

Options for Frontends

~~~~~~~~~~~~~~~~~~~~~

+

Here usually `<dataref>` must be either a mark reference (`:<idnum>`)

set by a prior `blob` command, or a full 40-byte SHA-1 of an

`<dataref>` must be the full 40-byte SHA-1 of an existing

Git tree object or a mark reference set with `--import-marks`.

Approach #1 (add-on)

^^^^^^^^^^^^^^^^^^^^

that you can tick off. Now you can compose the message as you otherwise do

(cut + paste, 'git format-patch' | 'git imap-send', etc), but you have to

insert line breaks manually in any text that you type.

Approach #2 (configuration)

^^^^^^^^^^^^^^^^^^^^^^^^^^^

Three steps:

provided with '--if-exists' overrides the `trailer.ifExists` and any

applicable `trailer.<keyAlias>.ifExists` configuration variables

and applies to all '--trailer' options until the next occurrence of

variables are no longer overridden. Possible actions are `addIfDifferent`,

`addIfDifferentNeighbor`, `add`, `replace` and `doNothing`.

provided with '--if-missing' overrides the `trailer.ifMissing` and any

applicable `trailer.<keyAlias>.ifMissing` configuration variables

and applies to all '--trailer' options until the next occurrence of

configuration variables are no longer overridden. Possible actions are `doNothing`

or `add`.

--no-progress::

Turn progress on/off explicitly. If neither is specified, progress is

shown if standard error is connected to a terminal. Supported by

The following subcommands are available:

DESCRIPTION

-----------

------------

A---B---C topic

D---E---F---G master

------------

------------

A'--B'--C' topic

D---E---F---G master

------------

Here is how you would transplant a topic branch based on one

branch to another, to pretend that you forked the topic branch

part of topicA. Note that the argument to `--onto` and the `<upstream>`

parameter can be any valid commit-ish.

MODE OPTIONS

------------

merge base of A and B if there is exactly one merge base. You can

leave out at most one of A and B, in which case it defaults to HEAD.

--keep-base::

Set the starting point at which to create the new commits to the

merge base of `<upstream>` and `<branch>`. Running

[--contains[=<object>]] [--no-contains[=<object>]]

[(--exclude=<pattern>)...] [--start-after=<marker>]

[ --stdin | (<pattern>...)]

DESCRIPTION

-----------

formatting, and sorting. This subcommand is an alias for

linkgit:git-for-each-ref[1] and offers identical functionality.

OPTIONS

-------

SYNOPSIS

--------

[synopsis]

DESCRIPTION

-----------

COMMANDS

--------

Retrieve metadata-related information about the current repository. Only

the requested data will be returned based on their keys (see "INFO KEYS"

section below).

between the key and the value and using a NUL character after each value.

This format is better suited for being parsed by another applications than

`keyvalue`. Unlike in the `keyvalue` format, the values are never quoted.

INFO KEYS

---------

`layout.shallow`::

`true` if this is a shallow repository, otherwise `false`.

`references.format`::

The reference storage format. The valid values are:

+

commands and replies will be printed. Useful to debug TLS

connection and authentication problems.

--batch-size=<num>::

Some email servers (e.g. 'smtp.163.com') limit the number of emails to be

sent per session (connection) and this will lead to a failure when

----

[sendemail]

smtpServer = smtp.gmail.com

smtpUser = yourname@gmail.com

----

Gmail does not allow using your regular password for `git send-email`.

----

[sendemail]

smtpServer = smtp.gmail.com

smtpUser = yourname@gmail.com

smtpAuth = OAUTHBEARER

----

`GIT_PROGRESS_DELAY`::

A number controlling how many seconds to delay before showing

`GIT_EDITOR`::

This environment variable overrides `$EDITOR` and `$VISUAL`.

History

-------

'gitk' is actually maintained as an independent project, but stable

versions are distributed as part of the Git suite for the convenience

of end users.

SEE ALSO

--------

'git-init.adoc' : 1,

'git-instaweb.adoc' : 1,

'git-interpret-trailers.adoc' : 1,

'git-log.adoc' : 1,

'git-ls-files.adoc' : 1,

'git-ls-remote.adoc' : 1,

literal formatting codes. These must be used for commas (`%x2C`) and closing

parentheses (`%x29`), due to their role in the option syntax.

+

** `suffix=<value>`: Shown after the list of ref names. Defaults to "+)+".

** `separator=<value>`: Shown between ref names. Defaults to "+,+{nbsp}".

** `pointer=<value>`: Shown between HEAD and the branch it points to, if any.

** `tag=<value>`: Shown before tag names. Defaults to "`tag:`{nbsp}".

+

BUILTIN_OBJS += builtin/index-pack.o

BUILTIN_OBJS += builtin/init-db.o

BUILTIN_OBJS += builtin/interpret-trailers.o

BUILTIN_OBJS += builtin/log.o

BUILTIN_OBJS += builtin/ls-files.o

BUILTIN_OBJS += builtin/ls-remote.o

$(MAKE) -C t/ unit-tests

.PHONY: libgit-sys libgit-rs

ifdef INCLUDE_LIBGIT_RS

endif

LIBGIT_PUB_OBJS += contrib/libgit-sys/public_symbol_export.o

int slab_nr, slab_alloc;

};

{

return xcalloc(1, sizeof(struct alloc_state));

}

{

while (s->slab_nr > 0) {

s->slab_nr--;

free(s->slabs[s->slab_nr]);

}

FREE_AND_NULL(s->slabs);

}

static inline void *alloc_node(struct alloc_state *s, size_t node_size)

void *alloc_tag_node(struct repository *r);

void *alloc_object_node(struct repository *r);

#endif

int cmd_index_pack(int argc, const char **argv, const char *prefix, struct repository *repo);

int cmd_init_db(int argc, const char **argv, const char *prefix, struct repository *repo);

int cmd_interpret_trailers(int argc, const char **argv, const char *prefix, struct repository *repo);

int cmd_log_reflog(int argc, const char **argv, const char *prefix, struct repository *repo);

int cmd_log(int argc, const char **argv, const char *prefix, struct repository *repo);

int cmd_ls_files(int argc, const char **argv, const char *prefix, struct repository *repo);

char *seen = NULL;

char *ps_matched = NULL;

struct lock_file lock_file = LOCK_INIT;

repo_config(repo, add_config, NULL);

string_list_clear(&only_match_skip_worktree, 0);

}

ps_matched = xcalloc(pathspec.nr, 1);

if (add_renormalize)

if (chmod_arg && pathspec.nr)

exit_status |= chmod_pathspec(repo, &pathspec, chmod_arg[0], show_only);

finish:

if (write_locked_index(repo->index, &lock_file,

if (opts.progress)

flags |= COMMIT_GRAPH_WRITE_PROGRESS;

graph_name = get_commit_graph_filename(source);

chain_name = get_commit_graph_chain_filename(source);

if (open_commit_graph(graph_name, &fd, &st))

git_env_bool(GIT_TEST_COMMIT_GRAPH_CHANGED_PATHS, 0))

flags |= COMMIT_GRAPH_WRITE_BLOOM_FILTERS;

if (opts.reachable) {

if (write_commit_graph_reachable(source, flags, &write_opts))

return author_message || force_date;

}

static void adjust_comment_line_char(const struct strbuf *sb)

{

char candidates[] = "#;@!$%^&|:";

free(comment_line_str_to_free);

comment_line_str = comment_line_str_to_free = xstrfmt("%c", *p);

}

static void prepare_amend_commit(struct commit *commit, struct strbuf *sb,

struct pretty_print_context *ctx)

if (fwrite(sb.buf, 1, sb.len, s->fp) < sb.len)

die_errno(_("could not write commit template"));

if (auto_comment_line_char)

adjust_comment_line_char(&sb);

strbuf_release(&sb);

/* This checks if committer ident is explicitly given */

show_usage_with_options_if_asked(argc, argv,

builtin_commit_usage, builtin_commit_options);

prepare_repo_settings(the_repository);

the_repository->settings.command_requires_full_index = 0;

#include "commit-slab.h"

#include "wildmatch.h"

#include "prio-queue.h"

#define MAX_TAGS (FLAG_BITS - 1)

#define DEFAULT_CANDIDATES 10

queue->get_pending = false;

}

{

for (size_t i = queue->get_pending ? 1 : 0; i < queue->queue.nr; i++) {

struct commit *commit = queue->queue.array[i].data;

}

while (!lazy_queue_empty(queue)) {

struct commit *c = lazy_queue_get(queue);

struct commit_list *parents = c->parents;

seen_commits++;

if (c->object.flags & best->flag_within) {

break;

best->depth++;

while (parents) {

struct commit *p = parents->item;

repo_parse_commit(the_repository, p);

lazy_queue_put(queue, p);

p->object.flags |= c->object.flags;

parents = parents->next;

}

}

return seen_commits;

}

repo_find_unique_abbrev(the_repository, oid, abbrev));

}

{

struct lazy_queue queue = LAZY_QUEUE_INIT;

struct commit_name *n;

struct possible_tag all_matches[MAX_TAGS];

unsigned long seen_commits = 0;

unsigned int unannotated_cnt = 0;

n = find_commit_name(&cmit->object.oid);

if (n && (tags || all || n->prio == 2)) {

/*

*/

append_name(n, dst);

if (n->misnamed || longformat)

if (suffix)

strbuf_addstr(dst, suffix);

return;

}

struct process_commit_data {

struct strbuf *dst;

struct rev_info *revs;

};

static void process_commit(struct commit *commit, void *data)

{

struct process_commit_data *pcd = data;

}

static void process_object(struct object *obj, const char *path, void *data)

{

struct process_commit_data *pcd = data;

reset_revision_walk();

free_commit_list(pcd->revs->commits);

pcd->revs->commits = NULL;

}

}

{

struct rev_info revs;

struct strvec args = STRVEC_INIT;

strvec_pushl(&args, "internal: The first arg is not parsed",

NULL);

repo_init_revisions(the_repository, &revs, NULL);

reset_revision_walk();

release_revisions(&revs);

strvec_clear(&args);

}

static void describe(const char *arg, int last_one)

cmit = lookup_commit_reference_gently(the_repository, &oid, 1);

if (cmit)

else if (odb_read_object_info(the_repository->objects,

&oid, NULL) == OBJ_BLOB)

else

die(_("%s is neither a commit nor blob"), arg);

if (!(show_cached || show_stage || show_deleted || show_modified))

return;

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

const struct cache_entry *ce = repo->index->cache[i];

struct stat st;

int stat_err;

construct_fullname(&fullname, repo, ce);

if ((dir->flags & DIR_SHOW_IGNORED) &&

show_usage_with_options_if_asked(argc, argv,

builtin_merge_usage, builtin_merge_options);

prepare_repo_settings(the_repository);

the_repository->settings.command_requires_full_index = 0;

char **value = opt->value;

free(*value);

if (unset)

else

*value = real_pathdup(arg, 1);

return 0;

}

static struct option common_opts[] = {

OPT_CALLBACK(0, "object-dir", &opts.object_dir,

N_("directory"),

N_("refs snapshot for selecting bitmap commits")),

OPT_END(),

};

int ret;

opts.flags |= MIDX_WRITE_BITMAP_HASH_CACHE;

if (argc)

usage_with_options(builtin_multi_pack_index_write_usage,

options);

FREE_AND_NULL(options);

read_packs_from_stdin(&packs);

opts.preferred_pack,

opts.refs_snapshot, opts.flags);

}

opts.refs_snapshot, opts.flags);

free(opts.refs_snapshot);

N_("force progress reporting"), MIDX_PROGRESS),

OPT_END(),

};

options = add_common_options(builtin_multi_pack_index_verify_options);

trace2_cmd_mode(argv[0]);

if (argc)

usage_with_options(builtin_multi_pack_index_verify_usage,

options);

FREE_AND_NULL(options);

}

static int cmd_multi_pack_index_expire(int argc, const char **argv,

N_("force progress reporting"), MIDX_PROGRESS),

OPT_END(),

};

options = add_common_options(builtin_multi_pack_index_expire_options);

trace2_cmd_mode(argv[0]);

if (argc)

usage_with_options(builtin_multi_pack_index_expire_usage,

options);

FREE_AND_NULL(options);

}

static int cmd_multi_pack_index_repack(int argc, const char **argv,

N_("force progress reporting"), MIDX_PROGRESS),

OPT_END(),

};

options = add_common_options(builtin_multi_pack_index_repack_options);

if (argc)

usage_with_options(builtin_multi_pack_index_repack_usage,

options);

FREE_AND_NULL(options);

}

int cmd_multi_pack_index(int argc,

struct multi_pack_index *m = get_multi_pack_index(source);

struct pack_entry e;

want = want_object_in_pack_one(e.p, oid, exclude, found_pack, found_offset, found_mtime);

if (want != -1)

return want;

builtin_rebase_usage,

builtin_rebase_options);

prepare_repo_settings(the_repository);

the_repository->settings.command_requires_full_index = 0;

#include "strbuf.h"

#include "worktree.h"

#include "for-each-ref.h"

#define REFS_MIGRATE_USAGE \

N_("git refs migrate --ref-format=<format> [--no-reflog] [--dry-run]")

#define REFS_VERIFY_USAGE \

N_("git refs verify [--strict] [--verbose]")

static int cmd_refs_migrate(int argc, const char **argv, const char *prefix,

struct repository *repo UNUSED)

{

return for_each_ref_core(argc, argv, prefix, repo, refs_list_usage);

}

int cmd_refs(int argc,

const char **argv,

const char *prefix,

REFS_MIGRATE_USAGE,

REFS_VERIFY_USAGE,

"git refs list " COMMON_USAGE_FOR_EACH_REF,

NULL,

};

parse_opt_subcommand_fn *fn = NULL;

OPT_SUBCOMMAND("migrate", &fn, cmd_refs_migrate),

OPT_SUBCOMMAND("verify", &fn, cmd_refs_verify),

OPT_SUBCOMMAND("list", &fn, cmd_refs_list),

OPT_END(),

};

static void remove_redundant_pack(const char *dir_name, const char *base_name)

{

struct strbuf buf = STRBUF_INIT;

strbuf_addf(&buf, "%s.pack", base_name);

clear_midx_file(the_repository);

strbuf_insertf(&buf, 0, "%s/", dir_name);

unlink_pack_path(buf.buf, 1);

unsigned flags = 0;

if (git_env_bool(GIT_TEST_MULTI_PACK_INDEX_WRITE_INCREMENTAL, 0))

flags |= MIDX_WRITE_INCREMENTAL;

NULL, NULL, flags);

}

#include "shallow.h"

static const char *const repo_usage[] = {

NULL

};

return 0;

}

static int get_references_format(struct repository *repo, struct strbuf *buf)

{

strbuf_addstr(buf,

static const struct field repo_info_fields[] = {

{ "layout.bare", get_layout_bare },

{ "layout.shallow", get_layout_shallow },

{ "references.format", get_references_format },

};

return ret;

}

static int repo_info(int argc, const char **argv, const char *prefix,

struct repository *repo)

{

struct option options[] = {

OPT_END()

};

argc = parse_options(argc, argv, prefix, options, repo_usage, 0);

return print_fields(argc, argv, repo, format);

}

#include "builtin.h"

#include "parse-options.h"

#include "diff.h"

#include "gettext.h"

#include "revision.h"

#include "rerere.h"

struct replay_opts opts = REPLAY_OPTS_INIT;

int res;

opts.action = REPLAY_REVERT;

sequencer_init_config(&opts);

res = run_sequencer(argc, argv, prefix, &opts);

struct replay_opts opts = REPLAY_OPTS_INIT;

int res;

opts.action = REPLAY_PICK;

sequencer_init_config(&opts);

res = run_sequencer(argc, argv, prefix, &opts);

{

int i;

unsigned char *hdr = fill(sizeof(struct pack_header));

if (get_be32(hdr) != PACK_SIGNATURE)

die("bad pack file");

progress = start_progress(the_repository,

_("Unpacking objects"), nr_objects);

CALLOC_ARRAY(obj_list, nr_objects);

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

unpack_one(i);

display_progress(progress, i + 1);

}

stop_progress(&progress);

if (delta_list)

* objects invisible while a transaction is active, so flush the

* transaction here before reporting a change made by update-index.

*/

va_start(vp, fmt);

vprintf(fmt, vp);

putchar('\n');

strbuf_getline_fn getline_fn;

int parseopt_state = PARSE_OPT_UNKNOWN;

struct repository *r = the_repository;

struct option options[] = {

OPT_BIT('q', NULL, &refresh_args.flags,

N_("continue refresh even when index needs update"),

* Allow the object layer to optimize adding multiple objects in

* a batch.

*/

while (ctx.argc) {

if (parseopt_state != PARSE_OPT_DONE)

parseopt_state = parse_options_step(&ctx, options,

/*

* By now we have added all of the new objects

*/

if (split_index > 0) {

if (repo_config_get_split_index(the_repository) == 0)

#include "object-file.h"

#include "odb.h"

char *pack_tmp_name;

struct hashfile *f;

off_t offset;

struct pack_idx_entry **written;

uint32_t alloc_written;

uint32_t nr_written;

unsigned char hash[])

{

char *idx_tmp_name = NULL;

free(idx_tmp_name);

}

{

unsigned char hash[GIT_MAX_RAWSZ];

struct strbuf packname = STRBUF_INIT;

CSUM_HASH_IN_STREAM | CSUM_FSYNC | CSUM_CLOSE);

} else {

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

state->nr_written, hash,

state->offset);

close(fd);

}

for (uint32_t i = 0; i < state->nr_written; i++)

free(state->written[i]);

strbuf_release(&packname);

/* Make objects we just wrote available to ourselves */

}

/*

* Cleanup after batch-mode fsync_object_files.

*/

{

struct strbuf temp_path = STRBUF_INIT;

struct tempfile *temp;

return;

/*

* to ensure that the data in each new object file is durable before

* the final name is visible.

*/

temp = xmks_tempfile(temp_path.buf);

fsync_or_die(get_tempfile_fd(temp), get_tempfile_path(temp));

delete_tempfile(&temp);

* Make the object files visible in the primary ODB after their data is

* fully durable.

*/

}

{

/* The object may already exist in the repository */

HAS_OBJECT_RECHECK_PACKED | HAS_OBJECT_FETCH_PROMISOR))

return 1;

/* Might want to keep the list sorted */

return 1;

/* This is a new object we need to keep */

}

/* Lazily create backing packfile for the state */

unsigned flags)

{

if (!(flags & INDEX_WRITE_OBJECT) || state->f)

return;

reset_pack_idx_option(&state->pack_idx_opts);

/* Pretend we are going to write only one object */

die_errno("unable to write pack header");

}

{

off_t seekback, already_hashed_to;

struct git_hash_ctx ctx;

unsigned char obuf[16384];

header_len = format_object_header((char *)obuf, sizeof(obuf),

OBJ_BLOB, size);

git_hash_update(&ctx, obuf, header_len);

/* Note: idx is non-NULL when we are writing */

if ((flags & INDEX_WRITE_OBJECT) != 0) {

CALLOC_ARRAY(idx, 1);

hashfile_checkpoint_init(state->f, &checkpoint);

}

already_hashed_to = 0;

while (1) {

if (idx) {

hashfile_checkpoint(state->f, &checkpoint);

idx->offset = state->offset;

BUG("should not happen");

hashfile_truncate(state->f, &checkpoint);

state->offset = checkpoint.offset;

if (lseek(fd, seekback, SEEK_SET) == (off_t) -1)

return error("cannot seek back");

}

return 0;

idx->crc32 = crc32_end(state->f);

hashfile_truncate(state->f, &checkpoint);

state->offset = checkpoint.offset;

free(idx);

return 0;

}

{

/*

* We lazily create the temporary object directory

* callers may not know whether any objects will be

* added at the time they call begin_odb_transaction.

*/

return;

}

{

/*

* If we have an active ODB transaction, we issue a call that

* before renaming the objects to their final names as part of

* flush_batch_fsync.

*/

git_fsync(fd, FSYNC_WRITEOUT_ONLY) < 0) {

if (errno == ENOSYS)

warning(_("core.fsyncMethod = batch is unsupported on this platform"));

}

}

{

}

{

}

{

BUG("Unbalanced ODB transaction nesting");

return;

}

#define BULK_CHECKIN_H

#include "object.h"

/*

*

* This also bypasses the usual "convert-to-git" dance, and that is on

* purpose. We could write a streaming version of the converting

* binary blobs, they generally do not want to get any conversion, and

* callers should avoid this code path when filters are requested.

*/

const char *path, unsigned flags);

/*

* and objects are only visible after the outermost transaction

* is complete or the transaction is flushed.

*/

/*

* Make any objects that are currently part of a pending object

* database transaction visible. It is valid to call this function

* even if no transaction is active.

*/

/*

* Tell the object database to make any objects from the

* current transaction visible if this is the final nested

* transaction.

*/

#endif

int cache_tree_update(struct index_state *istate, int flags)

{

int skip, i;

i = verify_cache(istate, flags);

trace_performance_enter();

trace2_region_enter("cache_tree", "update", the_repository);

i = update_one(istate->cache_tree, istate->cache, istate->cache_nr,

"", 0, &skip, flags);

trace2_region_leave("cache_tree", "update", the_repository);

trace_performance_leave("cache_tree_update");

if (i < 0)

git-init mainporcelain init

git-instaweb ancillaryinterrogators complete

git-interpret-trailers purehelpers

git-log mainporcelain info

git-ls-files plumbinginterrogators

git-ls-remote plumbinginterrogators

struct bloom_filter_settings *get_bloom_filter_settings(struct repository *r)

{

while (g) {

if (g->bloom_filter_settings)

return g->bloom_filter_settings;

#include "git-compat-util.h"

#include "abspath.h"

#include "date.h"

#include "branch.h"

#include "config.h"

#include "parse.h"

#include "convert.h"

#include "environment.h"

return 1;

}

/* Functions use to read configuration from a repository */

static void repo_read_config(struct repository *repo)

{

struct config_options opts = { 0 };

opts.respect_includes = 1;

opts.commondir = repo->commondir;

git_configset_clear(repo->config);

git_configset_init(repo->config);

/*

* config_with_options() normally returns only

* zero, as most errors are fatal, and

* immediately.

*/

die(_("unknown error occurred while reading the configuration files"));

}

static void git_config_check_init(struct repository *repo)

char *contents = NULL;

size_t contents_sz;

struct config_store_data store = CONFIG_STORE_INIT;

validate_comment_string(comment);

if (in_fd >= 0)

close(in_fd);

config_store_data_clear(&store);

return ret;

write_err_out:

*/

const char *comment_line_str = "#";

char *comment_line_str_to_free;

int auto_comment_line_char;

/* This is set by setup_git_directory_gently() and/or git_default_config() */

char *git_work_tree_cfg;

if (!strcmp(var, "core.commentchar") ||

!strcmp(var, "core.commentstring")) {

return config_error_nonbool(var);

auto_comment_line_char = 1;

if (strchr(value, '\n'))

return error(_("%s cannot contain newline"), var);

comment_line_str = value;

FREE_AND_NULL(comment_line_str_to_free);

auto_comment_line_char = 0;

} else

return error(_("%s must have at least one character"), var);

return 0;

*/

extern const char *comment_line_str;

extern char *comment_line_str_to_free;

extern int auto_comment_line_char;

# endif /* USE_THE_REPOSITORY_VARIABLE */

#endif /* ENVIRONMENT_H */

commit = lookup_commit_in_graph(the_repository, oid);

if (commit) {

if (mark_tags_complete_and_check_obj_db) {

die_in_commit_graph_only(oid);

}

return commit;

#endif

/**

* CURLOPT_TCP_KEEPCNT was added in 8.9.0, released in July, 2024.

*/

#if LIBCURL_VERSION_NUM >= 0x080900

$(QUIET)$(INSTALL_D0)'$(DESTDIR_SQ)$(gitexecdir_SQ)' $(INSTALL_D1)

$(QUIET)$(INSTALL_X0)git-gui $(INSTALL_X1) '$(DESTDIR_SQ)$(gitexecdir_SQ)'

$(QUIET)$(INSTALL_X0)git-gui--askpass $(INSTALL_X1) '$(DESTDIR_SQ)$(gitexecdir_SQ)'

$(QUIET)$(foreach p,$(GITGUI_BUILT_INS), $(INSTALL_L0)'$(DESTDIR_SQ)$(gitexecdir_SQ)/$p' $(INSTALL_L1)'$(DESTDIR_SQ)$(gitexecdir_SQ)/git-gui' $(INSTALL_L2)'$(DESTDIR_SQ)$(gitexecdir_SQ)/$p' $(INSTALL_L3) &&) true

ifdef GITGUI_WINDOWS_WRAPPER

$(QUIET)$(INSTALL_R0)git-gui.tcl $(INSTALL_R1) '$(DESTDIR_SQ)$(gitexecdir_SQ)'

$(QUIET)$(CLEAN_DST) '$(DESTDIR_SQ)$(gitexecdir_SQ)'

$(QUIET)$(REMOVE_F0)'$(DESTDIR_SQ)$(gitexecdir_SQ)'/git-gui $(REMOVE_F1)

$(QUIET)$(REMOVE_F0)'$(DESTDIR_SQ)$(gitexecdir_SQ)'/git-gui--askpass $(REMOVE_F1)

$(QUIET)$(foreach p,$(GITGUI_BUILT_INS), $(REMOVE_F0)'$(DESTDIR_SQ)$(gitexecdir_SQ)'/$p $(REMOVE_F1) &&) true

ifdef GITGUI_WINDOWS_WRAPPER

$(QUIET)$(REMOVE_F0)'$(DESTDIR_SQ)$(gitexecdir_SQ)'/git-gui.tcl $(REMOVE_F1)

set _path_sep {:}

}

set _path_seen [dict create]

foreach p [split $env(PATH) $_path_sep] {

# Keep only absolute paths, getting rid of ., empty, etc.

}

# Keep only the first occurence of any duplicates.

set norm_p [file normalize $p]

dict set _path_seen $norm_p 1

}

unset _path_seen

set env(PATH) [join $_search_path $_path_sep]

return [open |$run r]

}

proc git {args} {

git_redir $args {}

}

return [safe_open_command $cmdp $redir]

}

}

proc git_write {cmd} {

if {![info exists env(SSH_ASKPASS)]} {

set env(SSH_ASKPASS) [file join $argv0dir git-gui--askpass]

}

unset argv0dir

######################################################################

if {![lock_index begin-update]} return

# Common "after" functionality that waits until multiple asynchronous

# operations are complete (by waiting for them to activate their notes

# on the chord).

# The asynchronous operations are each indicated below by a comment

# before the code block that starts the async operation.

set after_chord [SimpleChord::new {

rescan_on_error $err

} else {

unlock_index

--smtp-user <str> * Username for SMTP-AUTH.

--smtp-pass <str> * Password for SMTP-AUTH; not necessary.

--smtp-encryption <str> * tls or ssl; anything else disables.

--smtp-ssl-cert-path <str> * Path to ca-certificates (either directory or file).

Pass an empty string to disable certificate

verification.

--no-smtp-auth * Disable SMTP authentication. Shorthand for

`--smtp-auth=none`

--smtp-debug <0|1> * Disable, enable Net::SMTP debug.

--batch-size <int> * send max <int> message per connection.

--relogin-delay <int> * delay <int> seconds between two successive login.

# Variables we fill in automatically, or via prompting:

my (@to,@cc,@xh,$envelope_sender,

$author,$sender,$smtp_authpass,$annotate,$compose,$time);

# Things we either get from config, *or* are overridden on the

# command-line.

my ($smtp_authuser, $smtp_encryption, $smtp_ssl_cert_path);

my ($batch_size, $relogin_delay);

my ($identity, $aliasfiletype, @alias_files, $smtp_domain, $smtp_auth);

my ($confirm);

my (@suppress_cc);

my ($auto_8bit_encoding);

my $target_xfer_encoding = 'auto';

my $forbid_sendmail_variables = 1;

my $outlook_id_fix = 'auto';

my %config_bool_settings = (

"thread" => \$thread,

"forbidsendmailvariables" => \$forbid_sendmail_variables,

"mailmap" => \$mailmap,

"outlookidfix" => \$outlook_id_fix,

);

my %config_settings = (

"smtpauth" => \$smtp_auth,

"smtpbatchsize" => \$batch_size,

"smtprelogindelay" => \$relogin_delay,

"to" => \@config_to,

"tocmd" => \$to_cmd,

"cc" => \@config_cc,

"smtp-domain:s" => \$smtp_domain,

"smtp-auth=s" => \$smtp_auth,

"no-smtp-auth" => sub {$smtp_auth = 'none'},

"annotate!" => \$annotate,

"compose" => \$compose,

"quiet" => \$quiet,

if ($dry_run) {

# We don't want to send the email.

} elsif (defined $sendmail_cmd || file_name_is_absolute($smtp_server)) {

my $pid = open my $sm, '|-';

defined $pid or die $!;

print "\n";

}

return 1;

}

$smtp->quit if $smtp;

sub apply_transfer_encoding {

my $message = shift;

my $from = shift;

{ "init", cmd_init_db },

{ "init-db", cmd_init_db },

{ "interpret-trailers", cmd_interpret_trailers, RUN_SETUP_GENTLY },

{ "log", cmd_log, RUN_SETUP },

{ "ls-files", cmd_ls_files, RUN_SETUP },

{ "ls-remote", cmd_ls_remote, RUN_SETUP_GENTLY },

return [expr int(-($D / $scroll_D0) * max(1, $kscroll-$koff))]

}

proc bind_mousewheel {} {

global canv cflist ctext

bindall <MouseWheel> {allcanvs yview scroll [scrollval %D] units}

bind $cflist <Alt-MouseWheel> {$cflist yview scroll [scrollval 5*%D 2] units}

bind $cflist <Alt-Shift-MouseWheel> break

bind $canv <Alt-Shift-MouseWheel> {$canv xview scroll [scrollval 5*%D] units}

}

}

set currentsearchhitbgcolor orange

# button for popping up context menus

set ctxbut <Button-2>

} else {

set ctxbut <Button-3>

if (curl_global_init(CURL_GLOBAL_ALL) != CURLE_OK)

die("curl_global_init failed");

if (proactive_auth && http_proactive_auth == PROACTIVE_AUTH_NONE)

http_proactive_auth = PROACTIVE_AUTH_IF_CREDENTIALS;

while (1) {

if (starts_with(p, "From ")) {

}

p = strstr(p+5, "\nFrom ");

if (!p)

* b: ------|

*/

j++;

/*

* b exhausted, or

* a: ----|

assert(out->target.nr == 0);

for (i = 0; i < diff->target.nr; i++) {

j++;

if (j == rs->nr)

return;

long t_cur = t_start;

unsigned int j_last;

while (j < diff->target.nr && diff->target.ranges[j].end < t_start)

j++;

continue;

/* Scan ahead to determine the last diff that falls in this range */

return new_filepair;

}

static int process_all_files(struct line_log_data **range_out,

struct rev_info *rev,

struct diff_queue_struct *queue,

struct line_log_data *range)

{

struct commit *parent = NULL;

struct line_log_data *parent_range;

int changed;

static int process_ranges_merge_commit(struct rev_info *rev, struct commit *commit,

struct line_log_data *range)

{

struct line_log_data **cand;

struct commit_list *p;

int i;

int nparents = commit_list_count(commit->parents);

if (nparents > 1 && rev->first_parent_only)

nparents = 1;

CALLOC_ARRAY(cand, nparents);

int changed;

if (!changed) {

/*

* This parent can take all the blame, so we

* don't follow any other path in history

*/

free_commit_list(commit->parents);

ret = 0;

goto out;

* No single parent took the blame. We add the candidates

* from the above loop to the parents.

*/

ret = 1;

out:

clear_commit_line_range(rev, commit);

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

if (!cand[i])

continue;

free(cand[i]);

}

free(cand);

return ret;

/* NEEDSWORK evil merge detection stuff */

struct line_log_data *prange = line_log_data_copy(range);

add_line_range(rev, commit->parents->item, prange);

clear_commit_line_range(rev, commit);

changed = process_ranges_merge_commit(rev, commit, range);

}

if (!changed)

'builtin/index-pack.c',

'builtin/init-db.c',

'builtin/interpret-trailers.c',

'builtin/log.c',

'builtin/ls-files.c',

'builtin/ls-remote.c',

#include "git-compat-util.h"

#include "abspath.h"

#include "config.h"

#define BITMAP_POS_UNKNOWN (~((uint32_t)0))

#define MIDX_CHUNK_FANOUT_SIZE (sizeof(uint32_t) * 256)

#define MIDX_CHUNK_LARGE_OFFSET_WIDTH (sizeof(uint64_t))

extern int midx_checksum_valid(struct multi_pack_index *m);

const char *keep_hash);

const char *ext,

const char **keep_hashes,

uint32_t hashes_nr);

unsigned large_offsets_needed:1;

uint32_t num_large_offsets;

int incremental;

uint32_t num_multi_pack_indexes_before;

struct string_list *to_include;

struct repository *repo;

};

static int should_include_pack(const struct write_midx_context *ctx,

static void midx_fanout_add_midx_fanout(struct midx_fanout *fanout,

struct multi_pack_index *m,

uint32_t cur_fanout,

{

uint32_t start = m->num_objects_in_base, end;

uint32_t cur_object;

end = m->num_objects_in_base + ntohl(m->chunk_oid_fanout[cur_fanout]);

for (cur_object = start; cur_object < end; cur_object++) {

(preferred_pack == nth_midxed_pack_int_id(m, cur_object))) {

/*

* Objects from preferred packs are added

preferred, cur_fanout);

}

midx_fanout_add_pack_fanout(&fanout, ctx->info,

ctx->preferred_pack_idx, 1,

cur_fanout);

}

static void write_midx_reverse_index(struct write_midx_context *ctx,

unsigned char *midx_hash)

{

struct strbuf buf = STRBUF_INIT;

trace2_region_enter("midx", "write_midx_reverse_index", ctx->repo);

if (ctx->incremental)

else

midx_hash, MIDX_EXT_REV);

tmp_file = write_rev_file_order(ctx->repo, NULL, ctx->pack_order,

}

static int write_midx_bitmap(struct write_midx_context *ctx,

const unsigned char *midx_hash,

struct packing_data *pdata,

struct commit **commits,

uint32_t commits_nr,

unsigned flags)

{

uint16_t options = 0;

struct bitmap_writer writer;

struct pack_idx_entry **index;

trace2_region_enter("midx", "write_midx_bitmap", ctx->repo);

if (ctx->incremental)

else

if (flags & MIDX_WRITE_BITMAP_HASH_CACHE)

options |= BITMAP_OPT_HASH_CACHE;

* this order).

*/

ALLOC_ARRAY(index, pdata->nr_objects);

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

bitmap_writer_init(&writer, ctx->repo, pdata,

* happens between bitmap_writer_build_type_index() and

* bitmap_writer_finish().

*/

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

bitmap_writer_select_commits(&writer, commits, commits_nr);

return ret;

}

{

struct multi_pack_index *m;

uint32_t i;

for (i = 0; i < m->num_packs; i++) {

fill_pack_info(&ctx->info[ctx->nr++], m->packs[i],

m->pack_names[i],

m->num_packs_in_base + i);

for (i = 0; i < ARRAY_SIZE(midx_exts); i++) {

const unsigned char *hash = get_midx_checksum(m);

hash, midx_exts[i].non_split);

midx_exts[i].split);

if (link(from.buf, to.buf) < 0 && errno != ENOENT) {

return ret;

}

const char **hashes, uint32_t hashes_nr,

unsigned incremental)

{

uint32_t i, j;

for (i = 0; i < ARRAY_SIZE(exts); i++) {

hashes, hashes_nr);

for (j = 0; j < hashes_nr; j++)

}

if (incremental)

else

if (unlink(buf.buf) && errno != ENOENT)

die_errno(_("failed to clear multi-pack-index at %s"), buf.buf);

strbuf_release(&buf);

}

struct string_list *packs_to_include,

struct string_list *packs_to_drop,

const char *preferred_pack_name,

const char *refs_snapshot,

unsigned flags)

{

struct strbuf midx_name = STRBUF_INIT;

unsigned char midx_hash[GIT_MAX_RAWSZ];

struct hashfile *f = NULL;

struct lock_file lk;

struct tempfile *incr;

int bitmapped_packs_concat_len = 0;

int pack_name_concat_len = 0;

int dropped_packs = 0;

const char **keep_hashes = NULL;

struct chunkfile *cf;

trace2_region_enter("midx", "write_midx_internal", r);

ctx.repo = r;

ctx.incremental = !!(flags & MIDX_WRITE_INCREMENTAL);

if (ctx.incremental)

strbuf_addf(&midx_name,

"%s/pack/multi-pack-index.d/tmp_midx_XXXXXX",

else

if (safe_create_leading_directories(r, midx_name.buf))

die_errno(_("unable to create leading directories of %s"),

midx_name.buf);

if (!packs_to_include || ctx.incremental) {

if (m && !midx_checksum_valid(m)) {

warning(_("ignoring existing multi-pack-index; checksum mismatch"));

m = NULL;

if (flags & MIDX_WRITE_BITMAP && load_midx_revindex(m)) {

error(_("could not load reverse index for MIDX %s"),

hash_to_hex_algop(get_midx_checksum(m),

goto cleanup;

}

ctx.num_multi_pack_indexes_before++;

m = m->base_midx;

}

goto cleanup;

}

ctx.to_include = packs_to_include;

stop_progress(&ctx.progress);

if ((ctx.m && ctx.nr == ctx.m->num_packs + ctx.m->num_packs_in_base) &&

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

*/

if (!want_bitmap)

goto cleanup;

}

}

goto cleanup; /* nothing to do */

if (preferred_pack_name) {

if (!cmp_idx_or_pack_name(preferred_pack_name,

ctx.info[i].pack_name)) {

ctx.preferred_pack_idx = i;

}

}

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

preferred_pack_name);

} else if (ctx.nr &&

(flags & (MIDX_WRITE_REV_INDEX | MIDX_WRITE_BITMAP))) {

ctx.preferred_pack_idx = 0;

if (packs_to_drop && packs_to_drop->nr)

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

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

* (and not another pack containing a duplicate)

*/

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

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

oldest = p;

ctx.preferred_pack_idx = i;

}

}

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

* matter.

*/

}

} else {

/*

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

* interfering with expiration logic below

*/

}

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);

goto cleanup;

}

}

compute_sorted_entries(&ctx, start_pack);

ctx.large_offsets_needed = 0;

if (ctx.entries[i].offset > 0x7fffffff)

ctx.num_large_offsets++;

if (ctx.entries[i].offset > 0xffffffff)

QSORT(ctx.info, ctx.nr, pack_info_compare);

if (packs_to_drop && packs_to_drop->nr) {

int missing_drops = 0;

int cmp = strcmp(ctx.info[i].pack_name,

packs_to_drop->items[drop_index].string);

}

}

goto cleanup;

}

/*

* pack_perm[old_id] = new_id

*/

ALLOC_ARRAY(ctx.pack_perm, ctx.nr);

if (ctx.info[i].expired) {

dropped_packs++;

ctx.pack_perm[ctx.info[i].orig_pack_int_id] = PACK_EXPIRED;

}

}

if (ctx.info[i].expired)

continue;

pack_name_concat_len += strlen(ctx.info[i].pack_name) + 1;

if (ctx.nr - dropped_packs == 0) {

error(_("no pack files to index."));

goto cleanup;

}

if (ctx.incremental) {

struct strbuf lock_name = STRBUF_INIT;

hold_lock_file_for_update(&lk, lock_name.buf, LOCK_DIE_ON_ERROR);

strbuf_release(&lock_name);

incr = mks_tempfile_m(midx_name.buf, 0444);

if (!incr) {

error(_("unable to create temporary MIDX layer"));

}

if (adjust_shared_perm(r, get_tempfile_path(incr))) {

error(_("unable to adjust shared permissions for '%s'"),

get_tempfile_path(incr));

}

f = hashfd(r->hash_algo, get_tempfile_fd(incr),

if (flags & MIDX_WRITE_REV_INDEX &&

git_env_bool("GIT_TEST_MIDX_WRITE_REV", 0))

if (flags & MIDX_WRITE_BITMAP) {

struct packing_data pdata;

FREE_AND_NULL(ctx.entries);

ctx.entries_nr = 0;

midx_hash, &pdata, commits, commits_nr,

flags) < 0) {

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

clear_packing_data(&pdata);

free(commits);

goto cleanup;

* have been freed in the previous if block.

*/

CALLOC_ARRAY(keep_hashes, ctx.num_multi_pack_indexes_before + 1);

if (ctx.incremental) {

if (!chainf) {

error_errno(_("unable to open multi-pack-index chain file"));

}

if (link_midx_to_chain(ctx.base_midx) < 0)

if (rename_tempfile(&incr, final_midx_name.buf) < 0) {

error_errno(_("unable to rename new multi-pack-index layer"));

}

strbuf_release(&final_midx_name);

keep_hashes[ctx.num_multi_pack_indexes_before] =

xstrdup(hash_to_hex_algop(midx_hash, r->hash_algo));

uint32_t j = ctx.num_multi_pack_indexes_before - i - 1;

keep_hashes[j] = xstrdup(hash_to_hex_algop(get_midx_checksum(m),

m = m->base_midx;

}

fprintf(get_lock_file_fp(&lk), "%s\n", keep_hashes[i]);

} else {

keep_hashes[ctx.num_multi_pack_indexes_before] =

if (commit_lock_file(&lk) < 0)

die_errno(_("could not write multi-pack-index"));

ctx.num_multi_pack_indexes_before + 1,

ctx.incremental);

cleanup:

if (ctx.info[i].p) {

close_pack(ctx.info[i].p);

free(ctx.info[i].p);

free(ctx.pack_perm);

free(ctx.pack_order);

if (keep_hashes) {

free((char *)keep_hashes[i]);

free(keep_hashes);

}

return result;

}

const char *preferred_pack_name,

const char *refs_snapshot, unsigned flags)

{

preferred_pack_name, refs_snapshot,

flags);

}

struct string_list *packs_to_include,

const char *preferred_pack_name,

const char *refs_snapshot, unsigned flags)

{

preferred_pack_name, refs_snapshot, flags);

}

{

uint32_t i, *count, result = 0;

struct string_list packs_to_drop = STRING_LIST_INIT_DUP;

struct progress *progress = NULL;

if (!m)

if (flags & MIDX_PROGRESS)

progress = start_delayed_progress(

_("Counting referenced objects"),

m->num_objects);

for (i = 0; i < m->num_objects; i++) {

if (flags & MIDX_PROGRESS)

progress = start_delayed_progress(

_("Finding and deleting unreferenced packfiles"),

m->num_packs);

for (i = 0; i < m->num_packs; i++) {

if (count[i])

continue;

continue;

if (m->packs[i]->pack_keep || m->packs[i]->is_cruft)

free(count);

if (packs_to_drop.nr)

&packs_to_drop, NULL, NULL, flags);

string_list_clear(&packs_to_drop, 0);

return 0;

}

int pack_kept_objects,

uint32_t pack_int_id)

{

struct packed_git *p;

return 0;

p = m->packs[pack_int_id];

if (!pack_kept_objects && p->pack_keep)

repo_config_get_bool(r, "repack.packkeptobjects", &pack_kept_objects);

for (i = 0; i < m->num_packs; i++) {

continue;

include_pack[i] = 1;

for (i = 0; i < m->num_packs; i++) {

pack_info[i].pack_int_id = i;

continue;

pack_info[i].mtime = m->packs[i]->mtime;

struct packed_git *p = m->packs[pack_int_id];

uint64_t expected_size;

continue;

/*

free(pack_info);

}

{

int result = 0;

uint32_t i, packs_to_repack = 0;

unsigned char *include_pack;

struct child_process cmd = CHILD_PROCESS_INIT;

FILE *cmd_in;

/*

* When updating the default for these configuration

strvec_push(&cmd.args, "pack-objects");

if (delta_base_offset)

strvec_push(&cmd.args, "--delta-base-offset");

goto cleanup;

}

flags);

cleanup:

#define MIDX_PACK_ERROR ((void *)(intptr_t)-1)

int midx_checksum_valid(struct multi_pack_index *m);

const char *keep_hash);

char **keep_hashes,

uint32_t hashes_nr);

int cmp_idx_or_pack_name(const char *idx_or_pack_name,

const unsigned char *get_midx_checksum(struct multi_pack_index *m)

{

}

{

}

const unsigned char *hash, const char *ext)

{

if (ext)

}

static int midx_read_oid_fanout(const unsigned char *chunk_start,

return 0;

}

{

struct multi_pack_index *m = NULL;

int fd;

struct stat st;

midx_map = xmmap(NULL, midx_size, PROT_READ, MAP_PRIVATE, fd, 0);

close(fd);

m->data = midx_map;

m->data_len = midx_size;

m->signature = get_be32(m->data);

if (m->signature != MIDX_SIGNATURE)

return NULL;

}

{

}

{

strbuf_addstr(buf, "/multi-pack-index-chain");

}

const unsigned char *hash, const char *ext)

{

strbuf_addf(buf, "/multi-pack-index-%s.%s",

}

static int open_multi_pack_index_chain(const struct git_hash_algo *hash_algo,

return 1;

}

int fd, struct stat *st,

int *incomplete_chain)

{

struct multi_pack_index *midx_chain = NULL;

struct strbuf buf = STRBUF_INIT;

int valid = 1;

uint32_t i, count;

FILE *fp = xfdopen(fd, "r");

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

struct multi_pack_index *m;

if (strbuf_getline_lf(&buf, fp) == EOF)

break;

warning(_("invalid multi-pack-index chain: line '%s' "

"not a hash"),

buf.buf);

valid = 0;

strbuf_reset(&buf);

layer.hash, MIDX_EXT_MIDX);

if (m) {

if (add_midx_to_chain(m, midx_chain)) {

return midx_chain;

}

{

struct strbuf chain_file = STRBUF_INIT;

struct stat st;

int fd;

struct multi_pack_index *m = NULL;

int incomplete;

/* ownership of fd is taken over by load function */

}

strbuf_release(&chain_file);

return m;

}

{

struct strbuf midx_name = STRBUF_INIT;

struct multi_pack_index *m;

if (!m)

strbuf_release(&midx_name);

return pack_int_id - m->num_packs_in_base;

}

uint32_t pack_int_id)

{

struct strbuf pack_name = STRBUF_INIT;

struct strbuf key = STRBUF_INIT;

struct packed_git *p;

if (m->packs[pack_int_id])

return 0;

m->pack_names[pack_int_id]);

/* pack_map holds the ".pack" name, but we have the .idx */

strhash(key.buf), key.buf,

struct packed_git, packmap_ent);

if (!p) {

if (p) {

install_packed_git(r, p);

list_add_tail(&p->mru, &r->objects->packed_git_mru);

#define MIDX_CHUNK_BITMAPPED_PACKS_WIDTH (2 * sizeof(uint32_t))

struct bitmapped_pack *bp, uint32_t pack_int_id)

{

uint32_t local_pack_int_id = midx_for_pack(&m, pack_int_id);

if (!m->chunk_bitmapped_packs)

return error(_("MIDX does not contain the BTMP chunk"));

return error(_("could not load bitmapped pack %"PRIu32), pack_int_id);

bp->p = m->packs[local_pack_int_id];

uint32_t *result)

{

int ret = bsearch_hash(oid->hash, m->chunk_oid_fanout,

result);

if (result)

*result += m->num_objects_in_base;

n = midx_for_object(&m, n);

oidread(oid, m->chunk_oid_lookup + st_mult(m->hash_len, n),

return oid;

}

(off_t)pos * MIDX_CHUNK_OFFSET_WIDTH);

}

const struct object_id *oid,

{

uint32_t pos;

uint32_t pack_int_id;

midx_for_object(&m, pos);

pack_int_id = nth_midxed_pack_int_id(m, pos);

return 0;

p = m->packs[pack_int_id - m->num_packs_in_base];

return 0;

}

{

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

if (source->midx)

return 1;

return !!source->midx;

}

int midx_checksum_valid(struct multi_pack_index *m)

{

m->data, m->data_len);

}

die_errno(_("failed to remove %s"), full_path);

}

const char *keep_hash)

{

struct clear_midx_data data;

}

data.ext = ext;

clear_midx_file_ext,

&data);

free(data.keep);

}

char **keep_hashes,

uint32_t hashes_nr)

{

data.keep_nr = hashes_nr;

data.ext = ext;

clear_midx_file_ext, &data);

for (i = 0; i < hashes_nr; i++)

{

struct strbuf midx = STRBUF_INIT;

if (r->objects) {

struct odb_source *source;

if (remove_path(midx.buf))

die(_("failed to clear multi-pack-index at %s"), midx.buf);

strbuf_release(&midx);

}

display_progress(progress, _n); \

} while (0)

{

struct pair_pos_vs_id *pairs = NULL;

uint32_t i;

struct progress *progress = NULL;

struct multi_pack_index *curr;

verify_midx_error = 0;

struct stat sb;

struct strbuf filename = STRBUF_INIT;

if (!stat(filename.buf, &sb)) {

error(_("multi-pack-index file exists, but failed to parse"));

_("Looking for referenced packfiles"),

m->num_packs + m->num_packs_in_base);

for (i = 0; i < m->num_packs + m->num_packs_in_base; i++) {

midx_report("failed to load pack in position %d", i);

display_progress(progress, i + 1);

nth_midxed_object_oid(&oid, m, pairs[i].pos);

midx_report(_("failed to load pack entry for oid[%d] = %s"),

pairs[i].pos, oid_to_hex(&oid));

continue;

"GIT_TEST_MULTI_PACK_INDEX_WRITE_INCREMENTAL"

struct multi_pack_index {

const unsigned char *data;

size_t data_len;

uint32_t num_objects;

int preferred_pack_idx;

int has_chain;

const unsigned char *chunk_pack_names;

const char **pack_names;

struct packed_git **packs;

};

#define MIDX_PROGRESS (1 << 0)

#define MIDX_EXT_MIDX "midx"

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

const unsigned char *hash, const char *ext);

const unsigned char *hash, const char *ext);

struct packed_git *nth_midxed_pack(struct multi_pack_index *m,

uint32_t pack_int_id);

struct bitmapped_pack *bp, uint32_t pack_int_id);

int bsearch_one_midx(const struct object_id *oid, struct multi_pack_index *m,

uint32_t *result);

struct object_id *nth_midxed_object_oid(struct object_id *oid,

struct multi_pack_index *m,

uint32_t n);

int midx_contains_pack(struct multi_pack_index *m,

const char *idx_or_pack_name);

int midx_preferred_pack(struct multi_pack_index *m, uint32_t *pack_int_id);

/*

* Variant of write_midx_file which writes a MIDX containing only the packs

* specified in packs_to_include.

*/

const char *preferred_pack_name, const char *refs_snapshot,

unsigned flags);

struct string_list *packs_to_include,

const char *preferred_pack_name,

const char *refs_snapshot, unsigned flags);

void clear_midx_file(struct repository *r);

void close_midx(struct multi_pack_index *m);

goto out;

if (batch_fsync_enabled(FSYNC_COMPONENT_LOOSE_OBJECT))

else if (fsync_object_files > 0)

fsync_or_die(fd, filename);

else

static struct strbuf filename = STRBUF_INIT;

if (batch_fsync_enabled(FSYNC_COMPONENT_LOOSE_OBJECT))

odb_loose_path(source, &filename, oid);

int hdrlen;

if (batch_fsync_enabled(FSYNC_COMPONENT_LOOSE_OBJECT))

/* Since oid is not determined, save tmp file to odb path. */

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

* Call xsize_t() only when needed to avoid potentially unnecessary

* die() for large files.

*/

ret = index_stream_convert_blob(istate, oid, fd, path, flags);

ret = index_pipe(istate, oid, fd, type, path, flags);

ret = index_core(istate, oid, fd, xsize_t(st->st_size),

type, path, flags);

close(fd);

return ret;

}

return hex[oid->hash[pos >> 1] & 0xf];

}

{

unsigned int i = mad->init_len;

while (mad->hex[i] && mad->hex[i] == get_hex_char_from_oid(oid, i))

i++;

mad->cur_len = i + 1;

return 0;

memset(o, 0, sizeof(*o));

o->repo = repo;

o->is_shallow = -1;

CALLOC_ARRAY(o->shallow_stat, 1);

o->buffer_slab = NULL;

parsed_object_pool_reset_commit_grafts(o);

stat_validity_clear(o->shallow_stat);

FREE_AND_NULL(o->shallow_stat);

}

const char *relative_base,

int depth);

{

struct strbuf pathbuf = STRBUF_INIT;

struct strbuf tmp = STRBUF_INIT;

khiter_t pos;

strbuf_realpath(&pathbuf, relative_base, 1);

strbuf_addch(&pathbuf, '/');

}

if (!strbuf_realpath(&tmp, pathbuf.buf, 0)) {

error(_("unable to normalize alternate object path: %s"),

while (pathbuf.len && pathbuf.buf[pathbuf.len - 1] == '/')

strbuf_setlen(&pathbuf, pathbuf.len - 1);

goto error;

CALLOC_ARRAY(alternate, 1);

alternate->odb = odb;

/* pathbuf.buf is already in r->objects->source_by_path */

alternate->path = strbuf_detach(&pathbuf, NULL);

/* recursively add alternates */

read_info_alternates(odb, alternate->path, depth + 1);

error:

strbuf_release(&tmp);

strbuf_release(&pathbuf);

}

static const char *parse_alt_odb_entry(const char *string,

static void link_alt_odb_entries(struct object_database *odb, const char *alt,

int sep, const char *relative_base, int depth)

{

if (!alt || !*alt)

return;

return;

}

while (*alt) {

continue;

}

}

static void read_info_alternates(struct object_database *odb,

}

void odb_add_to_alternates_file(struct object_database *odb,

{

struct lock_file lock = LOCK_INIT;

char *alts = repo_git_path(odb->repo, "objects/info/alternates");

struct strbuf line = STRBUF_INIT;

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

found = 1;

break;

}

if (found) {

rollback_lock_file(&lock);

} else {

if (commit_lock_file(&lock))

die_errno(_("unable to move new alternates file into place"));

if (odb->loaded_alternates)

}

free(alts);

}

{

/*

* Make sure alternates are initialized, or else our entry may be

* overwritten when they are.

*/

odb_prepare_alternates(odb);

}

struct odb_source *odb_set_temporary_primary_source(struct object_database *odb,

free(obj_dir_real);

strbuf_release(&odb_path_real);

if (!source)

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

return source;

struct multi_pack_index *midx;

/*

* This is a temporary object store created by the tmp_objdir

* facility. Disable ref updates since the objects in the store

* might be discarded on rollback.

struct packed_git;

struct cached_object_entry;

/*

* The object database encapsulates access to objects in a repository. It

struct repository *repo;

/*

* Set of all object directories; the main directory is first (and

* cannot be NULL after initialization). Subsequent directories are

* alternates.

void odb_clear(struct object_database *o);

/*

*/

struct odb_source *odb_find_source(struct object_database *odb, const char *obj_dir);

/*

* Replace the current writable object directory with the specified temporary

* object directory; returns the former primary source.

* recursive alternates it points to), but do not modify the on-disk alternates

* file.

*/

/*

* Read an object from the database. Returns the object data and assigns object

static struct repository *bitmap_repo(struct bitmap_index *bitmap_git)

{

if (bitmap_is_midx(bitmap_git))

return bitmap_git->pack->repo;

}

{

struct strbuf buf = STRBUF_INIT;

if (midx->has_chain)

get_midx_checksum(midx),

MIDX_EXT_BITMAP);

else

MIDX_EXT_BITMAP);

return strbuf_detach(&buf, NULL);

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

struct strbuf buf = STRBUF_INIT;

trace2_data_string("bitmap", bitmap_repo(bitmap_git),

"ignoring extra midx bitmap file", buf.buf);

close(fd);

}

for (i = 0; i < bitmap_git->midx->num_packs + bitmap_git->midx->num_packs_in_base; i++) {

warning(_("could not open pack %s"),

bitmap_git->midx->pack_names[i]);

goto cleanup;

struct multi_pack_index *m = bitmap_git->midx;

for (i = 0; i < m->num_packs + m->num_packs_in_base; i++) {

struct bitmapped_pack pack;

warning(_("unable to load pack: '%s', disabling pack-reuse"),

bitmap_git->midx->pack_names[i]);

free(packs);

* not want to accidentally call munmap() in the middle of the

* MIDX.

*/

"source", "midx");

m->revindex_data = (const uint32_t *)m->chunk_revindex;

return 0;

}

"source", "rev");

if (m->has_chain)

MIDX_EXT_REV);

else

MIDX_EXT_REV);

revindex_name.buf,

m->num_objects,

&m->revindex_map,

report_garbage(PACKDIR_FILE_GARBAGE, full_name);

}

{

struct string_list garbage = STRING_LIST_INIT_DUP;

struct prepare_pack_data data = {

.m = source->midx,

.r = source->odb->repo,

.garbage = &garbage,

};

for_each_file_in_pack_dir(source->path, prepare_pack, &data);

odb_prepare_alternates(r->objects);

for (source = r->objects->sources; source; source = source->next) {

}

rearrange_packed_git(r);

if (!m)

continue;

for (uint32_t i = 0; i < m->num_packs + m->num_packs_in_base; i++)

}

return r->objects->packed_git;

prepare_packed_git(r);

for (struct odb_source *source = r->objects->sources; source; source = source->next)

return 1;

if (!r->objects->packed_git)

prio_queue_put(&ctx->path_stack, xstrdup(path));

}

static int add_tree_entries(struct path_walk_context *ctx,

const char *base_path,

struct object_id *oid)

init_tree_desc(&desc, &tree->object.oid, tree->buffer, tree->size);

while (tree_entry(&desc, &entry)) {

struct object *o;

/* Not actually true, but we will ignore submodules later. */

enum object_type type = S_ISDIR(entry.mode) ? OBJ_TREE : OBJ_BLOB;

continue;

}

}

free_tree_buffer(tree);

if (!info->trees)

continue;

if (pending->path) {

char *path = *pending->path ? xstrfmt("%s/", pending->path)

: xstrdup("");

free(path);

} else {

/* assume a root tree, such as a lightweight tag. */

case OBJ_BLOB:

if (!info->blobs)

continue;

oid_array_append(&tagged_blobs->oids, &obj->oid);

break;

case OBJ_COMMIT:

const char *tp;

struct strbuf *counters_sb = &progress->counters_sb;

int show_update = 0;

int last_count_len = counters_sb->len;

return;

progress->last_value = n;

tp = (progress->throughput) ? progress->throughput->display.buf : "";

if (progress->total) {

unsigned percent = n * 100 / progress->total;

progress->last_percent = percent;

strbuf_reset(counters_sb);

tp);

show_update = 1;

}

strbuf_reset(counters_sb);

strbuf_addf(counters_sb, "%"PRIuMAX"%s", (uintmax_t)n, tp);

show_update = 1;

}

fflush(stderr);

}

}

}

static int delay_in_secs = -1;

if (delay_in_secs < 0)

return delay_in_secs;

}

const struct pathspec *pathspec, char *ps_matched,

int include_sparse, int flags)

{

struct update_callback_data data;

struct rev_info rev;

* This function is invoked from commands other than 'add', which

* may not have their own transaction active.

*/

run_diff_files(&rev, DIFF_RACY_IS_MODIFIED);

release_revisions(&rev);

return !!data.add_errors;

*/

static enum ref_transaction_error check_old_oid(struct ref_update *update,

struct object_id *oid,

struct strbuf *err)

{

if (update->flags & REF_LOG_ONLY ||

return 0;

if (is_null_oid(&update->old_oid)) {

strbuf_addf(err, "cannot lock ref '%s': "

"reference already exists",

if (update->old_target)

ret = ref_update_check_old_target(referent.buf, update, err);

else

if (ret)

goto out;

} else {

ret = REF_TRANSACTION_ERROR_EXPECTED_SYMREF;

goto out;

} else {

if (ret) {

goto out;

}

if (!arg) {

struct reftable_addition *addition;

ret = reftable_stack_new_addition(&addition, be->stack,

REFTABLE_STACK_NEW_ADDITION_RELOAD);

if (ret) {

ret = ref_update_check_old_target(referent->buf, u, err);

if (ret)

return ret;

strbuf_addf(err, _("cannot lock ref '%s': "

"reference already exists"),

ref_update_original_update_refname(u));

ret = backend_for(&arg.be, refs, newrefname, &newrefname, 1);

if (ret)

goto done;

done:

assert(ret != REFTABLE_API_ERROR);

ret = backend_for(&arg.be, refs, newrefname, &newrefname, 1);

if (ret)

goto done;

done:

assert(ret != REFTABLE_API_ERROR);

goto done;

arg.stack = be->stack;

done:

return ret;

return ret;

arg.stack = be->stack;

assert(ret != REFTABLE_API_ERROR);

return ret;

if (ret < 0)

goto done;

if (ret < 0)

goto done;

if (ret < 0)

goto done;

if (ret < 0)

goto done;

* transaction. Releases the lock if held. */

void reftable_addition_destroy(struct reftable_addition *add);

int reftable_stack_add(struct reftable_stack *st,

int (*write_table)(struct reftable_writer *wr,

void *write_arg),

struct reftable_iterator;

the records before adding them, reordering the records array passed in.

*/

int reftable_writer_add_refs(struct reftable_writer *w,

/*

adds reftable_log_records. Log records are keyed by (refname, decreasing

the records before adding them, reordering records array passed in.

*/

int reftable_writer_add_logs(struct reftable_writer *w,

/* reftable_writer_close finalizes the reftable. The writer is retained so

* statistics can be inspected. */

#include "table.h"

#include "writer.h"

static int stack_filename(struct reftable_buf *dest, struct reftable_stack *st,

const char *name)

{

return stack_fsync(writer->opts, writer->fd);

}

static int fd_read_lines(int fd, char ***namesp)

{

char *buf = NULL;

return err;

}

static int stack_uptodate(struct reftable_stack *st)

{

char **names = NULL;

return err;

}

struct reftable_addition {

struct reftable_flock tables_list_lock;

struct reftable_stack *stack;

uint64_t next_update_index;

};

static int reftable_stack_init_addition(struct reftable_addition *add,

struct reftable_stack *st,

struct reftable_buf lock_file_name = REFTABLE_BUF_INIT;

int err;

add->stack = st;

err = flock_acquire(&add->tables_list_lock, st->list_file,

st->opts.lock_timeout_ms);