+ rust-analysis:

+ needs: ci-config

+ if: needs.ci-config.outputs.enabled == 'yes'

+ env:

+ jobname: RustAnalysis

+ CI_JOB_IMAGE: ubuntu:rolling

+ runs-on: ubuntu-latest

+ container: ubuntu:rolling

+ concurrency:

+ group: rust-analysis-${{ github.ref }}

+ cancel-in-progress: ${{ needs.ci-config.outputs.skip_concurrent == 'yes' }}

+ steps:

+ - uses: actions/checkout@v4

+ - run: ci/install-dependencies.sh

+ - run: ci/run-rust-checks.sh

+ - choco install -y git meson ninja rust-ms

+rust-analysis:

+ image: ubuntu:rolling

+ stage: analyze

+ needs: [ ]

+ variables:

+ jobname: RustAnalysis

+ before_script:

+ - ./ci/install-dependencies.sh

+ script:

+ - ./ci/run-rust-checks.sh

+

+rust-version = "1.49.0"

+* Support for `core.preferSymlinkRefs=true` has been deprecated and will be

+ removed in Git 3.0. Writing symbolic refs as symbolic links will be phased

+ out in favor of using plain files using the textual representation of

+ symbolic refs.

++

+Symbolic references were initially always stored as a symbolic link. This was

+changed in 9b143c6e15 (Teach update-ref about a symbolic ref stored in a

+textfile., 2005-09-25), where a new textual symref format was introduced to

+store those symbolic refs in a plain file. In 9f0bb90d16

+(core.prefersymlinkrefs: use symlinks for .git/HEAD, 2006-05-02), the Git

+project switched the default to use the textual symrefs in favor of symbolic

+links.

++

+The migration away from symbolic links has happened almost 20 years ago by now,

+and there is no known reason why one should prefer them nowadays. Furthermore,

+symbolic links are not supported on some platforms.

++

+Note that only the writing side for such symbolic links is deprecated. Reading

+such symbolic links is still supported for now.

+

+TECH_DOCS += technical/large-object-promisors

+Git 2.51.2 Release Notes

+========================

+

+In addition to fixes for an unfortunate regression introduced in Git

+2.51.1 that caused "git diff --quiet -w" to be not so quiet when there

+are additions, deletions and conflicts, this maintenance release merges

+more fixes/improvements that have landed on the master front, primarily

+to make the CI part of the system a bit more robust.

+

+

+Fixes since Git 2.51.1

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

+

+ * Recently we attempted to improve "git diff -w --quiet" and friends

+ to handle cases where patch output would be suppressed, but it

+ introduced a bug that emits unnecessary output, which has been

+ corrected.

+

+ * The code to squelch output from "git diff -w --name-status"

+ etc. for paths that "git diff -w -p" would have stayed silent

+ leaked output from dry-run patch generation, which has been

+ corrected.

+

+ * Windows "real-time monitoring" interferes with the execution of

+ tests and affects negatively in both correctness and performance,

+ which has been disabled in Gitlab CI.

+

+ * An earlier addition to "git diff --no-index A B" to limit the

+ output with pathspec after the two directories misbehaved when

+ these directories were given with a trailing slash, which has been

+ corrected.

+

+ * The "--short" option of "git status" that meant output for humans

+ and "-z" option to show NUL delimited output format did not mix

+ well, and colored some but not all things. The command has been

+ updated to color all elements consistently in such a case.

+

+ * Unicode width table update.

+

+ * Recent OpenSSH creates the Unix domain socket to communicate with

+ ssh-agent under $HOME instead of /tmp, which causes our test to

+ fail doe to overly long pathname in our test environment, which has

+ been worked around by using "ssh-agent -T".

+

+Also contains various documentation updates, code cleanups and minor fixups.

+ * Show 'P'ipe command in "git add -p".

+

+ * "git sparse-checkout" subcommand learned a new "clean" action to

+ prune otherwise unused working-tree files that are outside the

+ areas of interest.

+

+ * "git fast-import" is taught to handle signed tags, just like it

+ recently learned to handle signed commits, in different ways.

+

+ * Build procedure for a few credential helpers (in contrib/) have

+ been updated.

+

+ * CI improvements to handle the recent Rust integration better.

+

+ * The code in "git repack" machinery has been cleaned up to prepare

+ for incremental update of midx files.

+

+ * The above caused regressions, which has been corrected.

+

+

+ * The "--short" option of "git status" that meant output for humans

+ and "-z" option to show NUL delimited output format did not mix

+ well, and colored some but not all things. The command has been

+ updated to color all elements consistently in such a case.

+

+ * Unicode width table update.

+

+ * GPG signing test set-up has been broken for a year, which has been

+ corrected.

+ (merge 516bf45749 jc/t1016-setup-fix later to maint).

+

+ * Recent OpenSSH creates the Unix domain socket to communicate with

+ ssh-agent under $HOME instead of /tmp, which causes our test to

+ fail doe to overly long pathname in our test environment, which has

+ been worked around by using "ssh-agent -T".

+commitGraph.changedPaths::

+ If true, then `git commit-graph write` will compute and write

+ changed-path Bloom filters by default, equivalent to passing

+ `--changed-paths`. If false or unset, changed-paths Bloom filters will

+ be written during `git commit-graph write` only if the filters already

+ exist in the current commit-graph file. This matches the default

+ behavior of `git commit-graph write` without any `--[no-]changed-paths`

+ option. To rewrite a commit-graph file without any filters, use the

+ `--no-changed-paths` option. Command-line option `--[no-]changed-paths`

+ always takes precedence over this configuration. Defaults to unset.

+

++

+This configuration is deprecated and will be removed in Git 3.0. Symbolic refs

+will always be written as textual symrefs.

+ P - print the current hunk using the pager

+data. `--changed-paths` is implied by config `commitGraph.changedPaths=true`.

+--signed-tags=(verbatim|warn-verbatim|warn-strip|strip|abort)::

+ Specify how to handle signed tags. Behaves in the same way

+ as the same option in linkgit:git-fast-export[1], except that

+ default is 'verbatim' (instead of 'abort').

+

+'git sparse-checkout' (init | list | set | add | reapply | disable | check-rules | clean) [<options>]

+'clean'::

+ Opportunistically remove files outside of the sparse-checkout

+ definition. This command requires cone mode to use recursive

+ directory matches to determine which files should be removed. A

+ file is considered for removal if it is contained within a tracked

+ directory that is outside of the sparse-checkout definition.

++

+Some special cases, such as merge conflicts or modified files outside of

+the sparse-checkout definition could lead to keeping files that would

+otherwise be removed. Resolve conflicts, stage modifications, and use

+`git sparse-checkout reapply` in conjunction with `git sparse-checkout

+clean` to resolve these cases.

++

+This command can be used to be sure the sparse index works efficiently,

+though it does not require enabling the sparse index feature via the

+`index.sparse=true` configuration.

++

+To prevent accidental deletion of worktree files, the `clean` subcommand

+will not delete any files without the `-f` or `--force` option, unless

+the `clean.requireForce` config option is set to `false`.

++

+The `--dry-run` option will list the directories that would be removed

+without deleting them. Running in this mode can be helpful to predict the

+behavior of the clean comand or to determine which kinds of files are left

+in the sparse directories.

++

+The `--verbose` option will list every file within the directories that

+are considered for removal. This option is helpful to determine if those

+files are actually important or perhaps to explain why the directory is

+still present despite the current sparse-checkout.

+

+git-tag - Create, list, delete or verify tags

+A cryptographically signed tag object will be created when `-s` or

+`-u <key-id>` is used. The signing backend (GPG, X.509, SSH, etc.) is

+controlled by the `gpg.format` configuration variable, defaulting to

+OpenPGP. When `-u <key-id>` is not used, the committer identity for

+the current user is used to find the key for signing. The

+configuration variable `gpg.program` is used to specify a custom

+signing binary.

+tagging message, and an optional cryptographic signature. Whereas a

+ Make a cryptographically signed tag, using the default signing

+ key. The signing backend used depends on the `gpg.format`

+ configuration variable. The default key is determined by the

+ backend. For GPG, it's based on the committer's email address,

+ while for SSH it may be a specific key file or agent

+ identity. See linkgit:git-config[1].

+ Make a cryptographically signed tag using the given key. The

+ format of the <key-id> and the backend used depend on the

+ `gpg.format` configuration variable. See

+ linkgit:git-config[1].

+ Verify the cryptographic signature of the given tags.

+ signingKey = <key-id>

+The signing backend can be chosen via the `gpg.format` configuration

+variable, which defaults to `openpgp`. See linkgit:git-config[1]

+for a list of other supported formats.

+

+The path to the program used for each signing backend can be specified

+with the `gpg.<format>.program` configuration variable. For the

+`openpgp` backend, `gpg.program` can be used as a synonym for

+`gpg.openpgp.program`. See linkgit:git-config[1] for details.

+

+

+See linkgit:git-config[1] for more details and other configuration

+variables.

+

+File Layout

+~~~~~~~~~~~

+----

+----

+Merging commit-graph files

+~~~~~~~~~~~~~~~~~~~~~~~~~~

+....

+....

+----

+----

+Merge Strategy

+~~~~~~~~~~~~~~

+Handling Mixed Generation Number Chains

+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+Deleting graph-\{hash\} files

+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+Chains across multiple object directories

+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

+Non goals

+---------

+I Issues with the current situation

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

+II Main features of the "Large Object Promisors" solution

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

+^^^^^^

+^^^^^^

+^^^^^^^^^

+^^^^^^^^^^^^^^

+^^^^

+^^^^^^^^^

+^^^^^^^^^^^^^^

+^^^^^^^^^

+^^^^^^^^^

+^^^^^^^^^^^^^^

+^^^^^^^^^

+^^^^^^^^^^^^^^

+^^^^

+^^^^^^^^^

+^^^^^^^^^^^^^^

+^^^^

+^^^^^^^^^

+^^^^^^^^^^^^^^

+III Benefits of using LOPs

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

+IV FAQ

+------

+^^^^^^^^^^^^^

+^^^^^^^^^^^^^^^^^^^^^^^^^^

+V Future improvements

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

+ 'large-object-promisors.adoc',

+ 1. Assumptions

+ 2. How rebasing and cherry-picking work

+ 3. Why the renames on MERGE_SIDE1 in any given pick are *always* a

+ 4. Why any rename on MERGE_SIDE1 in any given pick is _almost_ always also

+ 5. A detailed description of the counter-examples to #4.

+ 6. Why the special cases in #5 are still fully reasonable to use to pair

+ 7. Interaction with skipping of "irrelevant" renames

+ 8. Additional items that need to be cached

+ 9. How directory rename detection interacts with the above and why this

+== 1. Assumptions ==

+and a third that will hold in sections 3-6 for simplicity, that I'll later

+address in section 9:

+The third assumption makes sections 3-6 simpler, and allows people to

+then I can go back and address the specifics in section 9. It is probably

+this discussion is deferred until section 9.

+== 2. How rebasing and cherry-picking work ==

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

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

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

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

+....

+....

+== 3. Why the renames on MERGE_SIDE1 in any given pick are always a superset of the renames on MERGE_SIDE1 for the next pick. ==

+....

+....

+== 4. Why any rename on MERGE_SIDE1 in any given pick is _almost_ always also a rename on MERGE_SIDE1 for the next pick. ==

+....

+....

+

+....

+....

+

+

+....

+....

+== 5. A detailed description of the counter-examples to #4. ==

+We already noted in section 4 that rename/rename(1to1) (i.e. both sides

+Let's repeat an earlier point that section 4 made:

+....

+....

+

+

+

+....

+ E:oldfile -> G:newfile would be detected as a rename, but A:oldfile and

+ A':newfile would not be.

+....

+== 6. Why the special cases in #5 are still fully reasonable to use to pair up files for three-way content merging in the merge machinery, and why they do not affect the correctness of the merge. ==

+the time discussing in sections 4 and 5. The remainder of this section

+ * As noted in sections 4 and 5, the diff between A:oldfile and A':newfile

+== 7. Interaction with skipping of "irrelevant" renames ==

+== 8. Additional items that need to be cached ==

+....

+....

+

+The reason for `(A)` comes from the irrelevant renames skipping

+optimization discussed in section 7. The fact that irrelevant renames

+The reason for `(B)` is that diffcore_rename_extended() is what

+The reason for `(C)` is that merge-ort's tree traversal will again think

+The reason for `(D)` is that is how we determine whether the remember

+....

+....

+== 9. How directory rename detection interacts with the above and why this optimization is still safe even if merge.directoryRenames is set to "true". ==

+....

+....

+....

+....

+ ** If we need to perform rename-detection again on the given side (e.g.

+ ** If we prune rename/rename(1to1) entries from the cache, then we also

+....

+....

+....

+

+....

+....

+....

+....

+....

+== Terminology ==

+*`cone mode`*::

+ one of two modes for specifying the desired subset of files

+*`SKIP_WORKTREE`*::

+ When tracked files do not match the sparse specification and

++

+Most sparse checkout users are unaware of this implementation

+detail, and the term should generally be avoided in user-facing

+descriptions and command flags. Unfortunately, prior to the

+`sparse-checkout` subcommand this low-level detail was exposed,

+and as of time of writing, is still exposed in various places.

+

+*`sparse-checkout`*::

+ a subcommand in git used to reduce the files present in

+*`sparse cone`*:: see cone mode

+*`sparse directory`*::

+ An entry in the index corresponding to a directory, which

+*`sparse index`*::

+ A special mode for sparse-checkout that also makes the

+*`sparsity patterns`*::

+ patterns from $GIT_DIR/info/sparse-checkout used to

+*`sparse specification`*::

+ The set of paths in the user's area of focus. This

+*`vivifying`*::

+ When a command restores a tracked file to the working tree (and

+== Purpose of sparse-checkouts ==

+[horizontal]

+A):: Users are _only_ interested in the sparse portion of the repo

+A*):: Users are _only_ interested in the sparse portion of the repo

+ that they have downloaded so far

+B):: Users want a sparse working tree, but are working in a larger whole

+C):: sparse-checkout is a behind-the-scenes implementation detail allowing

+=== (Behavior A) Users are _only_ interested in the sparse portion of the repo

+=== (Behavior A*) Users are _only_ interested in the sparse portion of the repo that they have downloaded so far (a variant on the first usecase)

+or `git grep ${SEARCH_TERM} OLDREV` would need to be prepared to provide

+=== (Behavior B) Users want a sparse working tree, but are working in a larger whole

+=== (Behavior C) sparse-checkout is an implementational detail supporting a special VFS.

+== Usecases of primary concern ==

+=== (Behavior A*)

+=== (Behavior C)

+== Oversimplified mental models ==

+(Behavior A):: Restrict worktree and history operations to sparse specification

+(Behavior B):: Restrict worktree operations to sparse specification; have any

+ history operations work across all files

+(Behavior C):: Do not restrict either worktree or history operations to the

+ sparse specification...with the exception of branch checkouts or

+ switches which avoid writing files that will match the index so

+ they can later lazily be populated instead.

+== Desired behavior ==

+ ** commands that only look at files within the sparsity specification

+ *** diff (without --cached or REVISION arguments)

+ *** grep (without --cached or REVISION arguments)

+ *** diff-files

+ ** commands that restore files to the working tree that match sparsity

+ *** switch

+ *** checkout (the switch-like half)

+ *** read-tree

+ *** reset --hard

+ ** commands that write conflicted files to the working tree, but otherwise

+ *** merge

+ *** rebase

+ *** cherry-pick

+ *** revert

+ *** `am` and `apply --cached` should probably be in this section but

+

+ *** `ort` behaves as described above

+ *** `octopus` and `resolve` will always vivify any file changed in the merge

+ ** commands that always ignore sparsity since commits must be full-tree

+ *** archive

+ *** bundle

+ *** commit

+ *** format-patch

+ *** fast-export

+ *** fast-import

+ *** commit-tree

+ ** commands that write any modified file to the working tree (conflicted

+ *** stash

+ *** apply (without `--index` or `--cached`)

+ ** commands that make modifications to which files are tracked:

+

+ *** add

+ *** rm

+ *** mv

+ *** update-index

+ *** status

+ *** clean

+ ** commands for manually tweaking paths in both the index and the working tree

+

+ *** `restore`

+ *** the restore-like half of `checkout`

+ ** commands that query history

+

+ *** diff (with --cached or REVISION arguments)

+ *** grep (with --cached or REVISION arguments)

+ *** show (when given commit arguments)

+ *** blame (only matters when one or more -C flags are passed)

+ **** and annotate

+ *** log

+ *** whatchanged (may not exist anymore)

+ *** ls-files

+ *** diff-index

+ *** diff-tree

+ *** ls-tree

+ ** range-diff

+ ** cherry

+ ** shortlog

+ ** show-branch

+ ** rev-list

+ ** bisect

+

+ ** branch

+ ** describe

+ ** fetch

+ ** gc

+ ** init

+ ** maintenance

+ ** notes

+ ** pull (merge & rebase have the necessary changes)

+ ** push

+ ** submodule

+ ** tag

+

+ ** config

+ ** filter-branch (works in separate checkout without sparse-checkout setup)

+ ** pack-refs

+ ** prune

+ ** remote

+ ** repack

+ ** replace

+

+ ** bugreport

+ ** count-objects

+ ** fsck

+ ** gitweb

+ ** help

+ ** instaweb

+ ** merge-tree (doesn't touch worktree or index, and merges always compute full-tree)

+ ** rerere

+ ** verify-commit

+ ** verify-tag

+

+ ** commit-graph

+ ** hash-object

+ ** index-pack

+ ** mktag

+ ** mktree

+ ** multi-pack-index

+ ** pack-objects

+ ** prune-packed

+ ** symbolic-ref

+ ** unpack-objects

+ ** update-ref

+ ** write-tree (operates on index, possibly optimized to use sparse dir entries)

+

+ ** for-each-ref

+ ** get-tar-commit-id

+ ** ls-remote

+ ** merge-base (merges are computed full tree, so merge base should be too)

+ ** name-rev

+ ** pack-redundant

+ ** rev-parse

+ ** show-index

+ ** show-ref

+ ** unpack-file

+ ** var

+ ** verify-pack

+

+ ** <Everything under 'Interacting with Others' in 'git help --all'>

+ ** <Everything under 'Low-level...Syncing' in 'git help --all'>

+ ** <Everything under 'Low-level...Internal Helpers' in 'git help --all'>

+ ** <Everything under 'External commands' in 'git help --all'>

+ ** merge-file

+ ** merge-index

+ ** gitk?

+== Behavior classes ==

+

+ (1) they will ignore the sparse specification and write files with

+ conflicts to the working tree (thus temporarily expanding the

+ sparse specification to include such files.)

+ (2) they are grouped with commands which move to a new commit, since

+ they often create a commit and then move to it, even though we

+ know there are many exceptions to moving to the new commit. (For

+ example, the user may rebase a commit that becomes empty, or have

+ a cherry-pick which conflicts, or a user could run `merge

+ --no-commit`, and we also view `apply --index` kind of like `am

+ --no-commit`.) As such, these commands can make changes to index

+ files outside the sparse specification, though they'll mark such

+ files with SKIP_WORKTREE.

+== Subcommand-dependent defaults ==

+

+ ** diff-files

+ ** diff (without --cached or REVISION arguments)

+ ** grep (without --cached or REVISION arguments)

+ ** switch

+ ** checkout (the switch-like half)

+ ** reset (<commit>)

+

+ ** restore

+ ** checkout (the restore-like half)

+ ** checkout-index

+ ** reset (with pathspec)

+ ** merge

+ ** rebase

+ ** cherry-pick

+ ** revert

+

+ ** am

+ ** apply --index (which is kind of like an `am --no-commit`)

+ ** read-tree (especially with -m or -u; is kind of like a --no-commit merge)

+ ** reset (<tree-ish>, due to similarity to read-tree)

+ ** archive

+ ** bundle

+ ** commit

+ ** format-patch

+ ** fast-export

+ ** fast-import

+ ** commit-tree

+

+ ** stash

+ ** apply (without `--index`)

+

+ ** add

+ ** rm

+ ** mv

+ ** update-index

+ ** status

+ ** clean (?)

+

+....

+ Our original implementation for the first three of these commands was

+ "no restrict", but it had some severe usability issues:

+

+ * `git add <somefile>` if honored and outside the sparse

+ specification, can result in the file randomly disappearing later

+ when some subsequent command is run (since various commands

+ automatically clean up unmodified files outside the sparse

+ specification).

+ * `git rm '*.jpg'` could very negatively surprise users if it deletes

+ files outside the range of the user's interest.

+ * `git mv` has similar surprises when moving into or out of the cone,

+ so best to restrict by default

+

+ So, we switched `add` and `rm` to default to "restrict", which made

+ usability problems much less severe and less frequent, but we still got

+ complaints because commands like:

+

+ git add <file-outside-sparse-specification>

+ git rm <file-outside-sparse-specification>

+

+ would silently do nothing. We should instead print an error in those

+ cases to get usability right.

+

+ update-index needs to be updated to match, and status and maybe clean

+ also need to be updated to specially handle untracked paths.

+

+ There may be a difference in here between behavior A and behavior B in

+ terms of verboseness of errors or additional warnings.

+....

+ ** diff (with --cached or REVISION arguments)

+ ** grep (with --cached or REVISION arguments)

+ ** show (when given commit arguments)

+ ** blame (only matters when one or more -C flags passed)

+ *** and annotate

+ ** log

+ *** and variants: shortlog, gitk, show-branch, whatchanged, rev-list

+ ** ls-files

+ ** diff-index

+ ** diff-tree

+ ** ls-tree

+== Sparse specification vs. sparsity patterns ==

+== Implementation Questions ==

+

+ * Do the options --scope={sparse,all} sound good to others? Are there better options?

+

+ ** Names in use, or appearing in patches, or previously suggested:

+

+ *** --sparse/--dense

+ *** --ignore-skip-worktree-bits

+ *** --ignore-skip-worktree-entries

+ *** --ignore-sparsity

+ *** --[no-]restrict-to-sparse-paths

+ *** --full-tree/--sparse-tree

+ *** --[no-]restrict

+ *** --scope={sparse,all}

+ *** --focus/--unfocus

+ *** --limit/--unlimited

+

+ ** Rationale making me lean slightly towards --scope={sparse,all}:

+

+ *** We want a name that works for many commands, so we need a name that

+ *** We know that we have more than two possible usecases, so it is best

+ *** --scope={sparse,all} isn't overly long and seems relatively

+ *** `--sparse`, as used in add/rm/mv, is totally backwards for

+ *** There is a different `--sparse`/`--dense` pair for commands using

+ *** There is also a `--sparse` in both pack-objects and show-branch, which

+ *** The name --ignore-skip-worktree-bits is a double negative, is

+ ** If a config option is added (sparse.scope?) what should the values and

+ ** Is `--no-expand` a good alias for ls-files's `--sparse` option?

+ ** Under Behavior A:

+

+ *** Does ls-files' `--no-expand` override the default `--scope=all`, or

+ *** Does ls-files' `-t` option imply `--scope=all`?

+ *** Does update-index's `--[no-]skip-worktree` option imply `--scope=all`?

+ ** sparse-checkout: once behavior A is fully implemented, should we take

+== Implementation Goals/Plans ==

+

+ ** Make `--sparse` in add/rm/mv a deprecated alias for `--scope=all`

+ ** Make `--ignore-skip-worktree-bits` in checkout-index/checkout/restore

+ ** Create config option (sparse.scope?), tie it to the "Cliff notes"

+ ** Add --scope=sparse (and --scope=all) flag to each of the history querying

+== Known bugs ==

+1. Behavior A is not well supported in Git. (Behavior B didn't used to

+2. am and apply:

+3. reset --hard:

+4. read-tree

+5. Checkout, restore:

+6. checkout and restore --staged, continued:

+7. Performance issues; see:

+

+ https://lore.kernel.org/git/CABPp-BEkJQoKZsQGCYioyga_uoDQ6iBeW+FKr8JhyuuTMK1RDw@mail.gmail.com/

+== Reference Emails ==

+[1] (Original descriptions of behavior A & behavior B):

+

+https://lore.kernel.org/git/CABPp-BGJ_Nvi5TmgriD9Bh6eNXE2EDq2f8e8QKXAeYG3BxZafA@mail.gmail.com/

+

+[2] (Fix stash applications in sparse checkouts; bugs from behavioral differences):

+

+https://lore.kernel.org/git/ccfedc7140dbf63ba26a15f93bd3885180b26517.1606861519.git.gitgitgadget@gmail.com/

+

+[3] (Present-despite-skipped entries):

+

+https://lore.kernel.org/git/11d46a399d26c913787b704d2b7169cafc28d639.1642175983.git.gitgitgadget@gmail.com/

+

+[4] (Clone --no-checkout interaction):

+

+https://lore.kernel.org/git/pull.801.v2.git.git.1591324899170.gitgitgadget@gmail.com/ (clone --no-checkout)

+

+[5] (The need for update_sparsity() and avoiding `read-tree -mu HEAD`):

+

+https://lore.kernel.org/git/3a1f084641eb47515b5a41ed4409a36128913309.1585270142.git.gitgitgadget@gmail.com/

+

+[6] (SKIP_WORKTREE is advisory, not mandatory):

+

+https://lore.kernel.org/git/844306c3e86ef67591cc086decb2b760e7d710a3.1585270142.git.gitgitgadget@gmail.com/

+

+[7] (`worktree add` should copy sparsity settings from current worktree):

+

+https://lore.kernel.org/git/c51cb3714e7b1d2f8c9370fe87eca9984ff4859f.1644269584.git.gitgitgadget@gmail.com/

+

+[8] (Avoid negative surprises in add, rm, and mv):

+

+ * https://lore.kernel.org/git/cover.1617914011.git.matheus.bernardino@usp.br/

+ * https://lore.kernel.org/git/pull.1018.v4.git.1632497954.gitgitgadget@gmail.com/

+

+[9] (Move from out-of-cone to in-cone):

+

+ * https://lore.kernel.org/git/20220630023737.473690-6-shaoxuan.yuan02@gmail.com/

+ * https://lore.kernel.org/git/20220630023737.473690-4-shaoxuan.yuan02@gmail.com/

+

+[10] (Unnecessarily downloading objects outside sparse specification):

+

+https://lore.kernel.org/git/CAOLTT8QfwOi9yx_qZZgyGa8iL8kHWutEED7ok_jxwTcYT_hf9Q@mail.gmail.com/

+

+[11] (Stolee's comments on high-level usecases):

+

+https://lore.kernel.org/git/1a1e33f6-3514-9afc-0a28-5a6b85bd8014@gmail.com/

+

+[13] Previous config name suggestion and description:

+

+ https://lore.kernel.org/git/CABPp-BE6zW0nJSStcVU=_DoDBnPgLqOR8pkTXK3dW11=T01OhA@mail.gmail.com/

+

+https://lore.kernel.org/git/a1b68fd6126eb341ef3637bb93fedad4309b36d0.1650594746.git.gitgitgadget@gmail.com/

+

+https://lore.kernel.org/git/CABPp-BGVO3QdbfE84uF_3QDF0-y2iHHh6G5FAFzNRfeRitkuHw@mail.gmail.com/

+

+https://lore.kernel.org/git/CABPp-BFsCPPNOZ92JQRJeGyNd0e-TCW-LcLyr0i_+VSQJP+GCg@mail.gmail.com/

+

+RUST_TARGET_DIR = target/debug

+RUST_TARGET_DIR = target/release

+endif

+

+ifeq ($(uname_S),Windows)

+RUST_LIB = $(RUST_TARGET_DIR)/gitcore.lib

+else

+RUST_LIB = $(RUST_TARGET_DIR)/libgitcore.a

+LIB_OBJS += repack.o

+LIB_OBJS += repack-cruft.o

+LIB_OBJS += repack-filtered.o

+LIB_OBJS += repack-geometry.o

+LIB_OBJS += repack-midx.o

+LIB_OBJS += repack-promisor.o

+ifeq ($(uname_S),Windows)

+EXTLIBS += -luserenv

+endif

+ "p - print the current hunk\n"

+ "P - print the current hunk using the pager\n"

+ strbuf_addstr(&s->buf, ",p,P");

+ repo_for_each_pack(the_repository, pack) {

+ else if (!strcmp(var, "commitgraph.changedpaths"))

+ opts.enable_changed_paths = git_config_bool(var, value) ? 1 : -1;

+ repo_for_each_pack(the_repository, p) {

+ size_t sig_offset = parse_signed_buffer(message, message_size);

+ if (sig_offset < message_size)

+ message_size = sig_offset;

+static enum sign_mode signed_tag_mode = SIGN_VERBATIM;

+ } else if (find_oid_pack(&oid, packfile_store_get_packs(packs))) {

+ } else if (find_oid_pack(&oid, packfile_store_get_packs(packs))) {

+static void handle_tag_signature(struct strbuf *msg, const char *name)

+{

+ size_t sig_offset = parse_signed_buffer(msg->buf, msg->len);

+

+ /* If there is no signature, there is nothing to do. */

+ if (sig_offset >= msg->len)

+ return;

+

+ switch (signed_tag_mode) {

+

+ /* First, modes that don't change anything */

+ case SIGN_ABORT:

+ die(_("encountered signed tag; use "

+ "--signed-tags=<mode> to handle it"));

+ case SIGN_WARN_VERBATIM:

+ warning(_("importing a tag signature verbatim for tag '%s'"), name);

+ /* fallthru */

+ case SIGN_VERBATIM:

+ /* Nothing to do, the signature will be put into the imported tag. */

+ break;

+

+ /* Second, modes that remove the signature */

+ case SIGN_WARN_STRIP:

+ warning(_("stripping a tag signature for tag '%s'"), name);

+ /* fallthru */

+ case SIGN_STRIP:

+ /* Truncate the buffer to remove the signature */

+ strbuf_setlen(msg, sig_offset);

+ break;

+

+ /* Third, BUG */

+ default:

+ BUG("invalid signed_tag_mode value %d from tag '%s'",

+ signed_tag_mode, name);

+ }

+}

+

+ handle_tag_signature(&msg, t->name);

+

+ } else if (skip_prefix(option, "signed-tags=", &option)) {

+ if (parse_sign_mode(option, &signed_tag_mode))

+ usagef(_("unknown --signed-tags mode '%s'"), option);

+ struct packed_git *p;

+ repo_for_each_pack(r, p)

+ repo_for_each_pack(r, p) {

+ repo_for_each_pack(the_repository, p) {

+

+ repo_for_each_pack(the_repository, p) {

+ repo_for_each_pack(the_repository, p) {

+ int cnt = 0;

+ repo_for_each_pack(the_repository, p) {

+ repo_for_each_pack(the_repository, p) {

+ if (count >= incremental_repack_auto_limit)

+ break;

+ repo_for_each_pack(r, p) {

+ packfile_store_prepare(the_repository->objects->packfiles);

+ repo_for_each_pack(the_repository, p) {

+ repo_for_each_pack(the_repository, p)

+ repo_for_each_pack(the_repository, p) {

+ packfile_store_get_packs(packs);

+ p = packfile_store_get_packs(packs);

+ repo_for_each_pack(the_repository, p) {

+ repo_for_each_pack(the_repository, p) {

+ repo_for_each_pack(the_repository, p)

+ repo_for_each_pack(the_repository, p) {

+ struct packed_git *p;

+ repo_for_each_pack(the_repository, p)

+ struct packed_git *p;

+ repo_for_each_pack(the_repository, p)

+#include "repack.h"

+struct repack_config_ctx {

+ struct pack_objects_args *po_args;

+ struct pack_objects_args *cruft_po_args;

+ struct repack_config_ctx *repack_ctx = cb;

+ struct pack_objects_args *po_args = repack_ctx->po_args;

+ struct pack_objects_args *cruft_po_args = repack_ctx->cruft_po_args;

+ po_args->delta_base_offset = git_config_bool(var, value);

+ po_args->pack_kept_objects = git_config_bool(var, value);

+ struct repository *repo)

+ int i, ret;

+ struct repack_config_ctx config_ctx;

+ struct pack_objects_args po_args = PACK_OBJECTS_ARGS_INIT;

+ struct pack_objects_args cruft_po_args = PACK_OBJECTS_ARGS_INIT;

+ OPT_BOOL(0, "pack-kept-objects", &po_args.pack_kept_objects,

+ memset(&config_ctx, 0, sizeof(config_ctx));

+ config_ctx.po_args = &po_args;

+ config_ctx.cruft_po_args = &cruft_po_args;

+

+ repo_config(repo, repack_config, &config_ctx);

+ if (delete_redundant && repo->repository_format_precious_objects)

+ if (po_args.pack_kept_objects < 0)

+ po_args.pack_kept_objects = write_bitmaps > 0 && !write_midx;

+ odb_has_alternates(repo->objects)) {

+ strbuf_addf(&path, "%s/%s_XXXXXX",

+ repo_get_object_directory(repo),

+ midx_snapshot_refs(repo, refs_snapshot);

+ packdir = mkpathdup("%s/pack", repo_get_object_directory(repo));

+ existing.repo = repo;

+ existing_packs_collect(&existing, &keep_pack_list);

+ pack_geometry_init(&geometry, &existing, &po_args);

+ pack_geometry_split(&geometry);

+ if (repo_has_promisor_remote(repo))

+ repack_promisor_objects(repo, &po_args, &names, packtmp);

+ if (existing_packs_has_non_kept(&existing) &&

+ {

+ struct write_pack_opts opts = {

+ .packdir = packdir,

+ .destination = packdir,

+ .packtmp = packtmp,

+ };

+ ret = finish_pack_objects_cmd(repo->hash_algo, &opts, &cmd,

+ &names);

+ if (ret)

+ goto cleanup;

+ }

+ if (!get_multi_pack_index(repo->objects->sources))

+ struct write_pack_opts opts = {

+ .po_args = &cruft_po_args,

+ .destination = packtmp,

+ .packtmp = packtmp,

+ .packdir = packdir,

+ };

+ cruft_po_args.delta_base_offset = po_args.delta_base_offset;

+ cruft_po_args.pack_kept_objects = 0;

+ ret = write_cruft_pack(&opts, cruft_expiration,

+ opts.destination = expire_to;

+ ret = write_cruft_pack(&opts, NULL, 0ul, &names,

+ struct write_pack_opts opts = {

+ .po_args = &po_args,

+ .destination = filter_to,

+ .packdir = packdir,

+ .packtmp = packtmp,

+ };

+

+ if (!opts.destination)

+ opts.destination = packtmp;

+

+ ret = write_filtered_pack(&opts, &existing, &names);

+ close_object_store(repo->objects);

+ for_each_string_list_item(item, &names)

+ generated_pack_install(item->util, item->string, packdir,

+ packtmp);

+ existing_packs_mark_for_deletion(&existing, &names);

+ struct repack_write_midx_opts opts = {

+ .existing = &existing,

+ .geometry = &geometry,

+ .names = &names,

+ .refs_snapshot = refs_snapshot ? get_tempfile_path(refs_snapshot) : NULL,

+ .packdir = packdir,

+ .show_progress = show_progress,

+ .write_bitmaps = write_bitmaps > 0,

+ .midx_must_contain_cruft = midx_must_contain_cruft

+ };

+

+ ret = write_midx_included_packs(&opts);

+ odb_reprepare(repo->objects);

+ existing_packs_remove_redundant(&existing, packdir);

+ pack_geometry_remove_redundant(&geometry, &names,

+ &existing, packdir);

+ is_repository_shallow(repo))

+ update_server_info(repo, 0);

+ write_midx_file(repo->objects->sources,

+ pack_geometry_release(&geometry);

+#include "abspath.h"

+ N_("git sparse-checkout (init | list | set | add | reapply | disable | check-rules | clean) [<options>]"),

+static int update_working_directory(struct repository *r,

+ struct pattern_list *pl)

+static int write_patterns_and_update(struct repository *repo,

+ struct pattern_list *pl)

+ if (safe_create_leading_directories(repo, sparse_filename))

+ result = update_working_directory(repo, pl);

+ update_working_directory(repo, NULL);

+static int set_config(struct repository *repo,

+ enum sparse_checkout_mode mode)

+ if (init_worktree_config(repo)) {

+ if (repo_config_set_worktree_gently(repo,

+ repo_config_set_worktree_gently(repo,

+ return set_sparse_index_config(repo, 0);

+static int update_modes(struct repository *repo, int *cone_mode, int *sparse_index)

+ if (record_mode && set_config(repo, mode))

+ if (set_sparse_index_config(repo, *sparse_index) < 0)

+ repo_read_index(repo);

+ repo->index->updated_workdir = 1;

+ ensure_full_index(repo->index);

+ struct repository *repo)

+ repo_read_index(repo);

+ if (update_modes(repo, &init_opts.cone_mode, &init_opts.sparse_index))

+ return update_working_directory(repo, NULL);

+ if (repo_get_oid(repo, "HEAD", &oid)) {

+ if (safe_create_leading_directories(repo, sparse_filename))

+ return write_patterns_and_update(repo, &pl);

+static int modify_pattern_list(struct repository *repo,

+ struct strvec *args, int use_stdin,

+ set_config(repo, MODE_ALL_PATTERNS);

+ result = write_patterns_and_update(repo, pl);

+ set_config(repo, MODE_NO_PATTERNS);

+static void sanitize_paths(struct repository *repo,

+ struct strvec *args,

+ struct index_state *index = repo->index;

+ struct repository *repo)

+ repo_read_index(repo);

+ sanitize_paths(repo, &patterns, prefix, add_opts.skip_checks);

+ ret = modify_pattern_list(repo, &patterns, add_opts.use_stdin, ADD);

+ struct repository *repo)

+ repo_read_index(repo);

+ if (update_modes(repo, &set_opts.cone_mode, &set_opts.sparse_index))

+ sanitize_paths(repo, &patterns, prefix, set_opts.skip_checks);

+ ret = modify_pattern_list(repo, &patterns, set_opts.use_stdin, REPLACE);

+ struct repository *repo)

+ repo_read_index(repo);

+ if (update_modes(repo, &reapply_opts.cone_mode, &reapply_opts.sparse_index))

+ return update_working_directory(repo, NULL);

+}

+

+static char const * const builtin_sparse_checkout_clean_usage[] = {

+ "git sparse-checkout clean [-n|--dry-run]",

+ NULL

+};

+

+static int list_file_iterator(const char *path, const void *data)

+{

+ const char *msg = data;

+

+ printf(msg, path);

+ return 0;

+}

+

+static void list_every_file_in_dir(const char *msg,

+ const char *directory)

+{

+ struct strbuf path = STRBUF_INIT;

+

+ strbuf_addstr(&path, directory);

+ for_each_file_in_dir(&path, list_file_iterator, msg);

+ strbuf_release(&path);

+}

+

+static const char *msg_remove = N_("Removing %s\n");

+static const char *msg_would_remove = N_("Would remove %s\n");

+

+static int sparse_checkout_clean(int argc, const char **argv,

+ const char *prefix,

+ struct repository *repo)

+{

+ struct strbuf full_path = STRBUF_INIT;

+ const char *msg = msg_remove;

+ size_t worktree_len;

+ int force = 0, dry_run = 0, verbose = 0;

+ int require_force = 1;

+

+ struct option builtin_sparse_checkout_clean_options[] = {

+ OPT__DRY_RUN(&dry_run, N_("dry run")),

+ OPT__FORCE(&force, N_("force"), PARSE_OPT_NOCOMPLETE),

+ OPT__VERBOSE(&verbose, N_("report each affected file, not just directories")),

+ OPT_END(),

+ };

+

+ setup_work_tree();

+ if (!core_apply_sparse_checkout)

+ die(_("must be in a sparse-checkout to clean directories"));

+ if (!core_sparse_checkout_cone)

+ die(_("must be in a cone-mode sparse-checkout to clean directories"));

+

+ argc = parse_options(argc, argv, prefix,

+ builtin_sparse_checkout_clean_options,

+ builtin_sparse_checkout_clean_usage, 0);

+

+ repo_config_get_bool(repo, "clean.requireforce", &require_force);

+ if (require_force && !force && !dry_run)

+ die(_("for safety, refusing to clean without one of --force or --dry-run"));

+

+ if (dry_run)

+ msg = msg_would_remove;

+

+ if (repo_read_index(repo) < 0)

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

+

+ if (convert_to_sparse(repo->index, SPARSE_INDEX_MEMORY_ONLY) ||

+ repo->index->sparse_index == INDEX_EXPANDED)

+ die(_("failed to convert index to a sparse index; resolve merge conflicts and try again"));

+

+ strbuf_addstr(&full_path, repo->worktree);

+ strbuf_addch(&full_path, '/');

+ worktree_len = full_path.len;

+

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

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

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

+ continue;

+ strbuf_setlen(&full_path, worktree_len);

+ strbuf_add(&full_path, ce->name, ce->ce_namelen);

+

+ if (!is_directory(full_path.buf))

+ continue;

+

+ if (verbose)

+ list_every_file_in_dir(msg, ce->name);

+ else

+ printf(msg, ce->name);

+

+ if (dry_run <= 0 &&

+ remove_dir_recursively(&full_path, 0))

+ warning_errno(_("failed to remove '%s'"), ce->name);

+ }

+

+ strbuf_release(&full_path);

+ return 0;

+ struct repository *repo)

+ repo_read_index(repo);

+ repo->settings.sparse_index = 0;

+ if (update_working_directory(repo, &pl))

+ return set_config(repo, MODE_NO_PATTERNS);

+static int check_rules(struct repository *repo,

+ struct pattern_list *pl,

+ int null_terminated)

+{

+ repo->index->sparse_checkout_patterns = pl;

+ if (path_in_sparse_checkout(path, repo->index))

+ struct repository *repo)

+ ret = check_rules(repo, &pl, check_rules_opts.null_termination);

+ OPT_SUBCOMMAND("clean", &fn, sparse_checkout_clean),

+ prepare_repo_settings(repo);

+ repo->settings.command_requires_full_index = 0;

+CARGO_MSRV_VERSION=0.18.4

+CARGO_MSRV_WHENCE=https://github.com/foresterre/cargo-msrv/releases/download/v$CARGO_MSRV_VERSION/cargo-msrv-x86_64-unknown-linux-musl-v$CARGO_MSRV_VERSION.tgz

+RustAnalysis)

+ sudo apt-get -q -y install rustup

+ rustup default stable

+ rustup component add clippy rustfmt

+

+ wget -q "$CARGO_MSRV_WHENCE" -O "cargo-msvc.tgz"

+ sudo mkdir -p "$CUSTOM_PATH"

+ sudo tar -xf "cargo-msvc.tgz" --strip-components=1 \

+ --directory "$CUSTOM_PATH" --wildcards "*/cargo-msrv"

+ sudo chmod a+x "$CUSTOM_PATH/cargo-msrv"

+ ;;

+#!/bin/sh

+

+. ${0%/*}/lib.sh

+

+set +x

+

+if ! group "Check Rust formatting" cargo fmt --all --check

+then

+ RET=1

+fi

+

+if ! group "Check for common Rust mistakes" cargo clippy --all-targets --all-features -- -Dwarnings

+then

+ RET=1

+fi

+

+if ! group "Check for minimum required Rust version" cargo msrv verify

+then

+ RET=1

+fi

+

+exit $RET

+ repo_for_each_pack(the_repository, p) {

+all:: git-credential-libsecret

+prefix ?= /usr/local

+gitexecdir ?= $(prefix)/libexec/git-core

+

+CC ?= gcc

+CFLAGS ?= -g -O2 -Wall

+PKG_CONFIG ?= pkg-config

+RM ?= rm -f

+

+git-credential-libsecret: git-credential-libsecret.o

+ $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) $(LIBS)

+ $(RM) git-credential-libsecret git-credential-libsecret.o

+

+.PHONY: all clean

+prefix ?= /usr/local

+gitexecdir ?= $(prefix)/libexec/git-core

+

+CC ?= gcc

+CFLAGS ?= -g -O2 -Wall

+RM ?= rm -f

+

+%.o: %.c

+ $(CC) $(CFLAGS) $(CPPFLAGS) -o $@ -c $<

+

+ $(CC) $(CFLAGS) -o $@ $^ $(LDFLAGS) \

+

+.PHONY: all clean

+#include "strbuf.h"

+int for_each_file_in_dir(struct strbuf *path, file_iterator fn, const void *data)

+{

+ struct dirent *e;

+ int res = 0;

+ size_t baselen = path->len;

+ DIR *dir = opendir(path->buf);

+

+ if (!dir)

+ return 0;

+

+ while (!res && (e = readdir_skip_dot_and_dotdot(dir)) != NULL) {

+ unsigned char dtype = get_dtype(e, path, 0);

+ strbuf_setlen(path, baselen);

+ strbuf_addstr(path, e->d_name);

+

+ if (dtype == DT_REG) {

+ res = fn(path->buf, data);

+ } else if (dtype == DT_DIR) {

+ strbuf_addch(path, '/');

+ res = for_each_file_in_dir(path, fn, data);

+ }

+ }

+

+ closedir(dir);

+ return res;

+}

+

+ * This function pointer type is called on each file discovered in

+ * for_each_file_in_dir. The iteration stops if this method returns

+ * non-zero.

+ */

+typedef int (*file_iterator)(const char *path, const void *data);

+

+struct strbuf;

+/*

+ * Given a directory path, recursively visit each file within, including

+ * within subdirectories.

+ */

+int for_each_file_in_dir(struct strbuf *path, file_iterator fn, const void *data);

+

+/*

+ char *fingerprint_ret, *begin, *delim;

+ begin = fingerprint_stdout.buf;

+ delim = strchr(begin, ' ');

+ if (!delim)

+ die(_("failed to get the ssh fingerprint for key %s"),

+ begin = delim + 1;

+ delim = strchr(begin, ' ');

+ if (!delim)

+ die(_("failed to get the ssh fingerprint for key %s"),

+ signing_key);

+ fingerprint_ret = xmemdupz(begin, delim - begin);

+ char *begin, *new_line, *first_line;

+ begin = key_stdout.buf;

+ new_line = strchr(begin, '\n');

+ if (new_line)

+ first_line = xmemdupz(begin, new_line - begin);

+ else

+ first_line = xstrdup(begin);

+ if (is_literal_ssh_key(first_line, &literal_key)) {

+ default_key = first_line;

+ free(first_line);

+ repo_for_each_pack(the_repository, p) {

+ repo_for_each_pack(the_repository, p) {

+ repo_for_each_pack(the_repository, p) {

+ 'repack.c',

+ 'repack-cruft.c',

+ 'repack-filtered.c',

+ 'repack-geometry.c',

+ 'repack-midx.c',

+ 'repack-promisor.c',

+

+ if host_machine.system() == 'windows'

+ libgit_dependencies += compiler.find_library('userenv')

+ endif

+ repo_for_each_pack(ds->repo, p) {

+ if (ds->ambiguous)

+ break;

+ }

+ repo_for_each_pack(mad->repo, p)

+ repo_for_each_pack(r, p) {

+ struct packed_git *p;

+ repo_for_each_pack(r, p) {

+ repo_for_each_pack(pdata->repo, p) {

+ mapping[cnt++] = p;

+ repo_for_each_pack(r, p) {

+ repo_for_each_pack(repo, p) {

+ * Load and iterate through all packs of the given repository. This helper

+ * function will yield packfiles from all object sources connected to the

+ * repository.

+#define repo_for_each_pack(repo, p) \

+ for (p = packfile_store_get_packs(repo->objects->packfiles); p; p = p->next)

+struct packed_git *packfile_store_get_packs(struct packfile_store *store);

+#if defined(NO_SYMLINK_HEAD) || defined(WITH_BREAKING_CHANGES)

+ static int warn_once = 1;

+ char *ref_path;

+ ref_path = get_locked_file_path(&lock->lk);

+

+ if (warn_once)

+ warning(_("'core.preferSymlinkRefs=true' is nominated for removal.\n"

+ "hint: The use of symbolic links for symbolic refs is deprecated\n"

+ "hint: and will be removed in Git 3.0. The configuration that\n"

+ "hint: tells Git to use them is thus going away. You can unset\n"

+ "hint: it with:\n"

+ "hint:\n"

+ "hint:\tgit config unset core.preferSymlinkRefs\n"

+ "hint:\n"

+ "hint: Git will then use the textual symref format instead."));

+ warn_once = 0;

+

+#include "git-compat-util.h"

+#include "repack.h"

+#include "packfile.h"

+#include "repository.h"

+#include "run-command.h"

+

+static void combine_small_cruft_packs(FILE *in, off_t combine_cruft_below_size,

+ struct existing_packs *existing)

+{

+ struct packed_git *p;

+ struct strbuf buf = STRBUF_INIT;

+ size_t i;

+

+ repo_for_each_pack(existing->repo, p) {

+ if (!(p->is_cruft && p->pack_local))

+ continue;

+

+ strbuf_reset(&buf);

+ strbuf_addstr(&buf, pack_basename(p));

+ strbuf_strip_suffix(&buf, ".pack");

+

+ if (!string_list_has_string(&existing->cruft_packs, buf.buf))

+ continue;

+

+ if (p->pack_size < combine_cruft_below_size) {

+ fprintf(in, "-%s\n", pack_basename(p));

+ } else {

+ existing_packs_retain_cruft(existing, p);

+ fprintf(in, "%s\n", pack_basename(p));

+ }

+ }

+

+ for (i = 0; i < existing->non_kept_packs.nr; i++)

+ fprintf(in, "-%s.pack\n",

+ existing->non_kept_packs.items[i].string);

+

+ strbuf_release(&buf);

+}

+

+int write_cruft_pack(const struct write_pack_opts *opts,

+ const char *cruft_expiration,

+ unsigned long combine_cruft_below_size,

+ struct string_list *names,

+ struct existing_packs *existing)

+{

+ struct child_process cmd = CHILD_PROCESS_INIT;

+ struct string_list_item *item;

+ FILE *in;

+ int ret;

+ const char *pack_prefix = write_pack_opts_pack_prefix(opts);

+

+ prepare_pack_objects(&cmd, opts->po_args, opts->destination);

+

+ strvec_push(&cmd.args, "--cruft");

+ if (cruft_expiration)

+ strvec_pushf(&cmd.args, "--cruft-expiration=%s",

+ cruft_expiration);

+

+ strvec_push(&cmd.args, "--non-empty");

+

+ cmd.in = -1;

+

+ ret = start_command(&cmd);

+ if (ret)

+ return ret;

+

+ /*

+ * names has a confusing double use: it both provides the list

+ * of just-written new packs, and accepts the name of the cruft

+ * pack we are writing.

+ *

+ * By the time it is read here, it contains only the pack(s)

+ * that were just written, which is exactly the set of packs we

+ * want to consider kept.

+ *

+ * If `--expire-to` is given, the double-use served by `names`

+ * ensures that the pack written to `--expire-to` excludes any

+ * objects contained in the cruft pack.

+ */

+ in = xfdopen(cmd.in, "w");

+ for_each_string_list_item(item, names)

+ fprintf(in, "%s-%s.pack\n", pack_prefix, item->string);

+ if (combine_cruft_below_size && !cruft_expiration) {

+ combine_small_cruft_packs(in, combine_cruft_below_size,

+ existing);

+ } else {

+ for_each_string_list_item(item, &existing->non_kept_packs)

+ fprintf(in, "-%s.pack\n", item->string);

+ for_each_string_list_item(item, &existing->cruft_packs)

+ fprintf(in, "-%s.pack\n", item->string);

+ }

+ for_each_string_list_item(item, &existing->kept_packs)

+ fprintf(in, "%s.pack\n", item->string);

+ fclose(in);

+

+ return finish_pack_objects_cmd(existing->repo->hash_algo, opts, &cmd,

+ names);

+}

+#include "git-compat-util.h"

+#include "repack.h"

+#include "repository.h"

+#include "run-command.h"

+#include "string-list.h"

+

+int write_filtered_pack(const struct write_pack_opts *opts,

+ struct existing_packs *existing,

+ struct string_list *names)

+{

+ struct child_process cmd = CHILD_PROCESS_INIT;

+ struct string_list_item *item;

+ FILE *in;

+ int ret;

+ const char *caret;

+ const char *pack_prefix = write_pack_opts_pack_prefix(opts);

+

+ prepare_pack_objects(&cmd, opts->po_args, opts->destination);

+

+ strvec_push(&cmd.args, "--stdin-packs");

+

+ for_each_string_list_item(item, &existing->kept_packs)

+ strvec_pushf(&cmd.args, "--keep-pack=%s", item->string);

+

+ cmd.in = -1;

+

+ ret = start_command(&cmd);

+ if (ret)

+ return ret;

+

+ /*

+ * Here 'names' contains only the pack(s) that were just

+ * written, which is exactly the packs we want to keep. Also

+ * 'existing_kept_packs' already contains the packs in

+ * 'keep_pack_list'.

+ */

+ in = xfdopen(cmd.in, "w");

+ for_each_string_list_item(item, names)

+ fprintf(in, "^%s-%s.pack\n", pack_prefix, item->string);

+ for_each_string_list_item(item, &existing->non_kept_packs)

+ fprintf(in, "%s.pack\n", item->string);

+ for_each_string_list_item(item, &existing->cruft_packs)

+ fprintf(in, "%s.pack\n", item->string);

+ caret = opts->po_args->pack_kept_objects ? "" : "^";

+ for_each_string_list_item(item, &existing->kept_packs)

+ fprintf(in, "%s%s.pack\n", caret, item->string);

+ fclose(in);

+

+ return finish_pack_objects_cmd(existing->repo->hash_algo, opts, &cmd,

+ names);

+}

+#define DISABLE_SIGN_COMPARE_WARNINGS

+

+#include "git-compat-util.h"

+#include "repack.h"

+#include "repository.h"

+#include "hex.h"

+#include "packfile.h"

+

+static uint32_t pack_geometry_weight(struct packed_git *p)

+{

+ if (open_pack_index(p))

+ die(_("cannot open index for %s"), p->pack_name);

+ return p->num_objects;

+}

+

+static int pack_geometry_cmp(const void *va, const void *vb)

+{

+ uint32_t aw = pack_geometry_weight(*(struct packed_git **)va),

+ bw = pack_geometry_weight(*(struct packed_git **)vb);

+

+ if (aw < bw)

+ return -1;

+ if (aw > bw)

+ return 1;

+ return 0;

+}

+

+void pack_geometry_init(struct pack_geometry *geometry,

+ struct existing_packs *existing,

+ const struct pack_objects_args *args)

+{

+ struct packed_git *p;

+ struct strbuf buf = STRBUF_INIT;

+

+ repo_for_each_pack(existing->repo, p) {

+ if (args->local && !p->pack_local)

+ /*

+ * When asked to only repack local packfiles we skip

+ * over any packfiles that are borrowed from alternate

+ * object directories.

+ */

+ continue;

+

+ if (!args->pack_kept_objects) {

+ /*

+ * Any pack that has its pack_keep bit set will

+ * appear in existing->kept_packs below, but

+ * this saves us from doing a more expensive

+ * check.

+ */

+ if (p->pack_keep)

+ continue;

+

+ /*

+ * The pack may be kept via the --keep-pack

+ * option; check 'existing->kept_packs' to

+ * determine whether to ignore it.

+ */

+ strbuf_reset(&buf);

+ strbuf_addstr(&buf, pack_basename(p));

+ strbuf_strip_suffix(&buf, ".pack");

+

+ if (string_list_has_string(&existing->kept_packs, buf.buf))

+ continue;

+ }

+ if (p->is_cruft)

+ continue;

+

+ ALLOC_GROW(geometry->pack,

+ geometry->pack_nr + 1,

+ geometry->pack_alloc);

+

+ geometry->pack[geometry->pack_nr] = p;

+ geometry->pack_nr++;

+ }

+

+ QSORT(geometry->pack, geometry->pack_nr, pack_geometry_cmp);

+ strbuf_release(&buf);

+}

+

+void pack_geometry_split(struct pack_geometry *geometry)

+{

+ uint32_t i;

+ uint32_t split;

+ off_t total_size = 0;

+

+ if (!geometry->pack_nr) {

+ geometry->split = geometry->pack_nr;

+ return;

+ }

+

+ /*

+ * First, count the number of packs (in descending order of size) which

+ * already form a geometric progression.

+ */

+ for (i = geometry->pack_nr - 1; i > 0; i--) {

+ struct packed_git *ours = geometry->pack[i];

+ struct packed_git *prev = geometry->pack[i - 1];

+

+ if (unsigned_mult_overflows(geometry->split_factor,

+ pack_geometry_weight(prev)))

+ die(_("pack %s too large to consider in geometric "

+ "progression"),

+ prev->pack_name);

+

+ if (pack_geometry_weight(ours) <

+ geometry->split_factor * pack_geometry_weight(prev))

+ break;

+ }

+

+ split = i;

+

+ if (split) {

+ /*

+ * Move the split one to the right, since the top element in the

+ * last-compared pair can't be in the progression. Only do this

+ * when we split in the middle of the array (otherwise if we got

+ * to the end, then the split is in the right place).

+ */

+ split++;

+ }

+

+ /*

+ * Then, anything to the left of 'split' must be in a new pack. But,

+ * creating that new pack may cause packs in the heavy half to no longer

+ * form a geometric progression.

+ *

+ * Compute an expected size of the new pack, and then determine how many

+ * packs in the heavy half need to be joined into it (if any) to restore

+ * the geometric progression.

+ */

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

+ struct packed_git *p = geometry->pack[i];

+

+ if (unsigned_add_overflows(total_size, pack_geometry_weight(p)))

+ die(_("pack %s too large to roll up"), p->pack_name);

+ total_size += pack_geometry_weight(p);

+ }

+ for (i = split; i < geometry->pack_nr; i++) {

+ struct packed_git *ours = geometry->pack[i];

+

+ if (unsigned_mult_overflows(geometry->split_factor,

+ total_size))

+ die(_("pack %s too large to roll up"), ours->pack_name);

+

+ if (pack_geometry_weight(ours) <

+ geometry->split_factor * total_size) {

+ if (unsigned_add_overflows(total_size,

+ pack_geometry_weight(ours)))

+ die(_("pack %s too large to roll up"),

+ ours->pack_name);

+

+ split++;

+ total_size += pack_geometry_weight(ours);

+ } else

+ break;

+ }

+

+ geometry->split = split;

+}

+

+struct packed_git *pack_geometry_preferred_pack(struct pack_geometry *geometry)

+{

+ uint32_t i;

+

+ if (!geometry) {

+ /*

+ * No geometry means either an all-into-one repack (in which

+ * case there is only one pack left and it is the largest) or an

+ * incremental one.

+ *

+ * If repacking incrementally, then we could check the size of

+ * all packs to determine which should be preferred, but leave

+ * this for later.

+ */

+ return NULL;

+ }

+ if (geometry->split == geometry->pack_nr)

+ return NULL;

+

+ /*

+ * The preferred pack is the largest pack above the split line. In

+ * other words, it is the largest pack that does not get rolled up in

+ * the geometric repack.

+ */

+ for (i = geometry->pack_nr; i > geometry->split; i--)

+ /*

+ * A pack that is not local would never be included in a

+ * multi-pack index. We thus skip over any non-local packs.

+ */

+ if (geometry->pack[i - 1]->pack_local)

+ return geometry->pack[i - 1];

+

+ return NULL;

+}

+

+void pack_geometry_remove_redundant(struct pack_geometry *geometry,

+ struct string_list *names,

+ struct existing_packs *existing,

+ const char *packdir)

+{

+ const struct git_hash_algo *algop = existing->repo->hash_algo;

+ struct strbuf buf = STRBUF_INIT;

+ uint32_t i;

+

+ for (i = 0; i < geometry->split; i++) {

+ struct packed_git *p = geometry->pack[i];

+ if (string_list_has_string(names, hash_to_hex_algop(p->hash,

+ algop)))

+ continue;

+

+ strbuf_reset(&buf);

+ strbuf_addstr(&buf, pack_basename(p));

+ strbuf_strip_suffix(&buf, ".pack");

+

+ if ((p->pack_keep) ||

+ (string_list_has_string(&existing->kept_packs, buf.buf)))

+ continue;

+

+ repack_remove_redundant_pack(existing->repo, packdir, buf.buf);

+ }

+

+ strbuf_release(&buf);

+}

+

+void pack_geometry_release(struct pack_geometry *geometry)

+{

+ if (!geometry)

+ return;

+

+ free(geometry->pack);

+}

+#include "git-compat-util.h"

+#include "repack.h"

+#include "hash.h"

+#include "hex.h"

+#include "odb.h"

+#include "oidset.h"

+#include "pack-bitmap.h"

+#include "refs.h"

+#include "run-command.h"

+#include "tempfile.h"

+

+struct midx_snapshot_ref_data {

+ struct repository *repo;

+ struct tempfile *f;

+ struct oidset seen;

+ int preferred;

+};

+

+static int midx_snapshot_ref_one(const char *refname UNUSED,

+ const char *referent UNUSED,

+ const struct object_id *oid,

+ int flag UNUSED, void *_data)

+{

+ struct midx_snapshot_ref_data *data = _data;

+ struct object_id peeled;

+

+ if (!peel_iterated_oid(data->repo, oid, &peeled))

+ oid = &peeled;

+

+ if (oidset_insert(&data->seen, oid))

+ return 0; /* already seen */

+

+ if (odb_read_object_info(data->repo->objects, oid, NULL) != OBJ_COMMIT)

+ return 0;

+

+ fprintf(data->f->fp, "%s%s\n", data->preferred ? "+" : "",

+ oid_to_hex(oid));

+

+ return 0;

+}

+

+void midx_snapshot_refs(struct repository *repo, struct tempfile *f)

+{

+ struct midx_snapshot_ref_data data;

+ const struct string_list *preferred = bitmap_preferred_tips(repo);

+

+ data.repo = repo;

+ data.f = f;

+ data.preferred = 0;

+ oidset_init(&data.seen, 0);

+

+ if (!fdopen_tempfile(f, "w"))

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

+ get_tempfile_path(f));

+

+ if (preferred) {

+ struct string_list_item *item;

+

+ data.preferred = 1;

+ for_each_string_list_item(item, preferred)

+ refs_for_each_ref_in(get_main_ref_store(repo),

+ item->string,

+ midx_snapshot_ref_one, &data);

+ data.preferred = 0;

+ }

+

+ refs_for_each_ref(get_main_ref_store(repo),

+ midx_snapshot_ref_one, &data);

+

+ if (close_tempfile_gently(f)) {

+ int save_errno = errno;

+ delete_tempfile(&f);

+ errno = save_errno;

+ die_errno(_("could not close refs snapshot tempfile"));

+ }

+

+ oidset_clear(&data.seen);

+}

+

+static int midx_has_unknown_packs(struct string_list *include,

+ struct pack_geometry *geometry,

+ struct existing_packs *existing)

+{

+ struct string_list_item *item;

+

+ string_list_sort(include);

+

+ for_each_string_list_item(item, &existing->midx_packs) {

+ const char *pack_name = item->string;

+

+ /*

+ * Determine whether or not each MIDX'd pack from the existing

+ * MIDX (if any) is represented in the new MIDX. For each pack

+ * in the MIDX, it must either be:

+ *

+ * - In the "include" list of packs to be included in the new

+ * MIDX. Note this function is called before the include

+ * list is populated with any cruft pack(s).

+ *

+ * - Below the geometric split line (if using pack geometry),

+ * indicating that the pack won't be included in the new

+ * MIDX, but its contents were rolled up as part of the

+ * geometric repack.

+ *

+ * - In the existing non-kept packs list (if not using pack

+ * geometry), and marked as non-deleted.

+ */

+ if (string_list_has_string(include, pack_name)) {

+ continue;

+ } else if (geometry) {

+ struct strbuf buf = STRBUF_INIT;

+ uint32_t j;

+

+ for (j = 0; j < geometry->split; j++) {

+ strbuf_reset(&buf);

+ strbuf_addstr(&buf, pack_basename(geometry->pack[j]));

+ strbuf_strip_suffix(&buf, ".pack");

+ strbuf_addstr(&buf, ".idx");

+

+ if (!strcmp(pack_name, buf.buf)) {

+ strbuf_release(&buf);

+ break;

+ }

+ }

+

+ strbuf_release(&buf);

+

+ if (j < geometry->split)

+ continue;

+ } else {

+ struct string_list_item *item;

+

+ item = string_list_lookup(&existing->non_kept_packs,

+ pack_name);

+ if (item && !existing_pack_is_marked_for_deletion(item))

+ continue;

+ }

+

+ /*

+ * If we got to this point, the MIDX includes some pack that we

+ * don't know about.

+ */

+ return 1;

+ }

+

+ return 0;

+}

+

+static void midx_included_packs(struct string_list *include,

+ struct repack_write_midx_opts *opts)

+{

+ struct existing_packs *existing = opts->existing;

+ struct pack_geometry *geometry = opts->geometry;

+ struct string_list *names = opts->names;

+ struct string_list_item *item;

+ struct strbuf buf = STRBUF_INIT;

+

+ for_each_string_list_item(item, &existing->kept_packs) {

+ strbuf_reset(&buf);

+ strbuf_addf(&buf, "%s.idx", item->string);

+ string_list_insert(include, buf.buf);

+ }

+

+ for_each_string_list_item(item, names) {

+ strbuf_reset(&buf);

+ strbuf_addf(&buf, "pack-%s.idx", item->string);

+ string_list_insert(include, buf.buf);

+ }

+

+ if (geometry->split_factor) {

+ uint32_t i;

+

+ for (i = geometry->split; i < geometry->pack_nr; i++) {

+ struct packed_git *p = geometry->pack[i];

+

+ /*

+ * The multi-pack index never refers to packfiles part

+ * of an alternate object database, so we skip these.

+ * While git-multi-pack-index(1) would silently ignore

+ * them anyway, this allows us to skip executing the

+ * command completely when we have only non-local

+ * packfiles.

+ */

+ if (!p->pack_local)

+ continue;

+

+ strbuf_reset(&buf);

+ strbuf_addstr(&buf, pack_basename(p));

+ strbuf_strip_suffix(&buf, ".pack");

+ strbuf_addstr(&buf, ".idx");

+

+ string_list_insert(include, buf.buf);

+ }

+ } else {

+ for_each_string_list_item(item, &existing->non_kept_packs) {

+ if (existing_pack_is_marked_for_deletion(item))

+ continue;

+

+ strbuf_reset(&buf);

+ strbuf_addf(&buf, "%s.idx", item->string);

+ string_list_insert(include, buf.buf);

+ }

+ }

+

+ if (opts->midx_must_contain_cruft ||

+ midx_has_unknown_packs(include, geometry, existing)) {

+ /*

+ * If there are one or more unknown pack(s) present (see

+ * midx_has_unknown_packs() for what makes a pack

+ * "unknown") in the MIDX before the repack, keep them

+ * as they may be required to form a reachability

+ * closure if the MIDX is bitmapped.

+ *

+ * For example, a cruft pack can be required to form a

+ * reachability closure if the MIDX is bitmapped and one

+ * or more of the bitmap's selected commits reaches a

+ * once-cruft object that was later made reachable.

+ */

+ for_each_string_list_item(item, &existing->cruft_packs) {

+ /*

+ * When doing a --geometric repack, there is no

+ * need to check for deleted packs, since we're

+ * by definition not doing an ALL_INTO_ONE

+ * repack (hence no packs will be deleted).

+ * Otherwise we must check for and exclude any

+ * packs which are enqueued for deletion.

+ *

+ * So we could omit the conditional below in the

+ * --geometric case, but doing so is unnecessary

+ * since no packs are marked as pending

+ * deletion (since we only call

+ * `existing_packs_mark_for_deletion()` when

+ * doing an all-into-one repack).

+ */

+ if (existing_pack_is_marked_for_deletion(item))

+ continue;

+

+ strbuf_reset(&buf);

+ strbuf_addf(&buf, "%s.idx", item->string);

+ string_list_insert(include, buf.buf);

+ }

+ } else {

+ /*

+ * Modern versions of Git (with the appropriate

+ * configuration setting) will write new copies of

+ * once-cruft objects when doing a --geometric repack.

+ *

+ * If the MIDX has no cruft pack, new packs written

+ * during a --geometric repack will not rely on the

+ * cruft pack to form a reachability closure, so we can

+ * avoid including them in the MIDX in that case.

+ */

+ ;

+ }

+

+ strbuf_release(&buf);

+}

+

+static void remove_redundant_bitmaps(struct string_list *include,

+ const char *packdir)

+{

+ struct strbuf path = STRBUF_INIT;

+ struct string_list_item *item;

+ size_t packdir_len;

+

+ strbuf_addstr(&path, packdir);

+ strbuf_addch(&path, '/');

+ packdir_len = path.len;

+

+ /*

+ * Remove any pack bitmaps corresponding to packs which are now

+ * included in the MIDX.

+ */

+ for_each_string_list_item(item, include) {

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

+ strbuf_strip_suffix(&path, ".idx");

+ strbuf_addstr(&path, ".bitmap");

+

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

+ warning_errno(_("could not remove stale bitmap: %s"),

+ path.buf);

+

+ strbuf_setlen(&path, packdir_len);

+ }

+ strbuf_release(&path);

+}

+

+int write_midx_included_packs(struct repack_write_midx_opts *opts)

+{

+ struct child_process cmd = CHILD_PROCESS_INIT;

+ struct string_list include = STRING_LIST_INIT_DUP;

+ struct string_list_item *item;

+ struct packed_git *preferred = pack_geometry_preferred_pack(opts->geometry);

+ FILE *in;

+ int ret = 0;

+

+ midx_included_packs(&include, opts);

+ if (!include.nr)

+ goto done;

+

+ cmd.in = -1;

+ cmd.git_cmd = 1;

+

+ strvec_push(&cmd.args, "multi-pack-index");

+ strvec_pushl(&cmd.args, "write", "--stdin-packs", NULL);

+

+ if (opts->show_progress)

+ strvec_push(&cmd.args, "--progress");

+ else

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

+

+ if (opts->write_bitmaps)

+ strvec_push(&cmd.args, "--bitmap");

+

+ if (preferred)

+ strvec_pushf(&cmd.args, "--preferred-pack=%s",

+ pack_basename(preferred));

+ else if (opts->names->nr) {

+ /* The largest pack was repacked, meaning that either

+ * one or two packs exist depending on whether the

+ * repository has a cruft pack or not.

+ *

+ * Select the non-cruft one as preferred to encourage

+ * pack-reuse among packs containing reachable objects

+ * over unreachable ones.

+ *

+ * (Note we could write multiple packs here if

+ * `--max-pack-size` was given, but any one of them

+ * will suffice, so pick the first one.)

+ */

+ for_each_string_list_item(item, opts->names) {

+ struct generated_pack *pack = item->util;

+ if (generated_pack_has_ext(pack, ".mtimes"))

+ continue;

+

+ strvec_pushf(&cmd.args, "--preferred-pack=pack-%s.pack",

+ item->string);

+ break;

+ }

+ } else {

+ /*

+ * No packs were kept, and no packs were written. The

+ * only thing remaining are .keep packs (unless

+ * --pack-kept-objects was given).

+ *

+ * Set the `--preferred-pack` arbitrarily here.

+ */

+ ;

+ }

+

+ if (opts->refs_snapshot)

+ strvec_pushf(&cmd.args, "--refs-snapshot=%s",

+ opts->refs_snapshot);

+

+ ret = start_command(&cmd);

+ if (ret)

+ goto done;

+

+ in = xfdopen(cmd.in, "w");

+ for_each_string_list_item(item, &include)

+ fprintf(in, "%s\n", item->string);

+ fclose(in);

+

+ ret = finish_command(&cmd);

+done:

+ if (!ret && opts->write_bitmaps)

+ remove_redundant_bitmaps(&include, opts->packdir);

+

+ string_list_clear(&include, 0);

+

+ return ret;

+}

+#include "git-compat-util.h"

+#include "repack.h"

+#include "hex.h"

+#include "pack.h"

+#include "packfile.h"

+#include "path.h"

+#include "repository.h"

+#include "run-command.h"

+

+struct write_oid_context {

+ struct child_process *cmd;

+ const struct git_hash_algo *algop;

+};

+

+/*

+ * Write oid to the given struct child_process's stdin, starting it first if

+ * necessary.

+ */

+static int write_oid(const struct object_id *oid,

+ struct packed_git *pack UNUSED,

+ uint32_t pos UNUSED, void *data)

+{

+ struct write_oid_context *ctx = data;

+ struct child_process *cmd = ctx->cmd;

+

+ if (cmd->in == -1) {

+ if (start_command(cmd))

+ die(_("could not start pack-objects to repack promisor objects"));

+ }

+

+ if (write_in_full(cmd->in, oid_to_hex(oid), ctx->algop->hexsz) < 0 ||

+ write_in_full(cmd->in, "\n", 1) < 0)

+ die(_("failed to feed promisor objects to pack-objects"));

+ return 0;

+}

+

+void repack_promisor_objects(struct repository *repo,

+ const struct pack_objects_args *args,

+ struct string_list *names, const char *packtmp)

+{

+ struct write_oid_context ctx;

+ struct child_process cmd = CHILD_PROCESS_INIT;

+ FILE *out;

+ struct strbuf line = STRBUF_INIT;

+

+ prepare_pack_objects(&cmd, args, packtmp);

+ cmd.in = -1;

+

+ /*

+ * NEEDSWORK: Giving pack-objects only the OIDs without any ordering

+ * hints may result in suboptimal deltas in the resulting pack. See if

+ * the OIDs can be sent with fake paths such that pack-objects can use a

+ * {type -> existing pack order} ordering when computing deltas instead

+ * of a {type -> size} ordering, which may produce better deltas.

+ */

+ ctx.cmd = &cmd;

+ ctx.algop = repo->hash_algo;

+ for_each_packed_object(repo, write_oid, &ctx,

+ FOR_EACH_OBJECT_PROMISOR_ONLY);

+

+ if (cmd.in == -1) {

+ /* No packed objects; cmd was never started */

+ child_process_clear(&cmd);

+ return;

+ }

+

+ close(cmd.in);

+

+ out = xfdopen(cmd.out, "r");

+ while (strbuf_getline_lf(&line, out) != EOF) {

+ struct string_list_item *item;

+ char *promisor_name;

+

+ if (line.len != repo->hash_algo->hexsz)

+ die(_("repack: Expecting full hex object ID lines only from pack-objects."));

+ item = string_list_append(names, line.buf);

+

+ /*

+ * pack-objects creates the .pack and .idx files, but not the

+ * .promisor file. Create the .promisor file, which is empty.

+ *

+ * NEEDSWORK: fetch-pack sometimes generates non-empty

+ * .promisor files containing the ref names and associated

+ * hashes at the point of generation of the corresponding

+ * packfile, but this would not preserve their contents. Maybe

+ * concatenate the contents of all .promisor files instead of

+ * just creating a new empty file.

+ */

+ promisor_name = mkpathdup("%s-%s.promisor", packtmp,

+ line.buf);

+ write_promisor_file(promisor_name, NULL, 0);

+

+ item->util = generated_pack_populate(item->string, packtmp);

+

+ free(promisor_name);

+ }

+

+ fclose(out);

+ if (finish_command(&cmd))

+ die(_("could not finish pack-objects to repack promisor objects"));

+ strbuf_release(&line);

+}

+#include "git-compat-util.h"

+#include "dir.h"

+#include "midx.h"

+#include "odb.h"

+#include "packfile.h"

+#include "path.h"

+#include "repack.h"

+#include "repository.h"

+#include "run-command.h"

+#include "tempfile.h"

+

+void prepare_pack_objects(struct child_process *cmd,

+ const struct pack_objects_args *args,

+ const char *out)

+{

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

+ if (args->window)

+ strvec_pushf(&cmd->args, "--window=%s", args->window);

+ if (args->window_memory)

+ strvec_pushf(&cmd->args, "--window-memory=%s", args->window_memory);

+ if (args->depth)

+ strvec_pushf(&cmd->args, "--depth=%s", args->depth);

+ if (args->threads)

+ strvec_pushf(&cmd->args, "--threads=%s", args->threads);

+ if (args->max_pack_size)

+ strvec_pushf(&cmd->args, "--max-pack-size=%lu", args->max_pack_size);

+ if (args->no_reuse_delta)

+ strvec_pushf(&cmd->args, "--no-reuse-delta");

+ if (args->no_reuse_object)

+ strvec_pushf(&cmd->args, "--no-reuse-object");

+ if (args->name_hash_version)

+ strvec_pushf(&cmd->args, "--name-hash-version=%d", args->name_hash_version);

+ if (args->path_walk)

+ strvec_pushf(&cmd->args, "--path-walk");

+ if (args->local)

+ strvec_push(&cmd->args, "--local");

+ if (args->quiet)

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

+ if (args->delta_base_offset)

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

+ if (!args->pack_kept_objects)

+ strvec_push(&cmd->args, "--honor-pack-keep");

+ strvec_push(&cmd->args, out);

+ cmd->git_cmd = 1;

+ cmd->out = -1;

+}

+

+void pack_objects_args_release(struct pack_objects_args *args)

+{

+ free(args->window);

+ free(args->window_memory);

+ free(args->depth);

+ free(args->threads);

+ list_objects_filter_release(&args->filter_options);

+}

+

+void repack_remove_redundant_pack(struct repository *repo, const char *dir_name,

+ const char *base_name)

+{

+ struct strbuf buf = STRBUF_INIT;

+ struct odb_source *source = repo->objects->sources;

+ struct multi_pack_index *m = get_multi_pack_index(source);

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

+ if (m && source->local && midx_contains_pack(m, buf.buf))

+ clear_midx_file(repo);

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

+ unlink_pack_path(buf.buf, 1);

+ strbuf_release(&buf);

+}

+

+const char *write_pack_opts_pack_prefix(const struct write_pack_opts *opts)

+{

+ const char *pack_prefix;

+ if (!skip_prefix(opts->packtmp, opts->packdir, &pack_prefix))

+ die(_("pack prefix %s does not begin with objdir %s"),

+ opts->packtmp, opts->packdir);

+ if (*pack_prefix == '/')

+ pack_prefix++;

+ return pack_prefix;

+}

+

+bool write_pack_opts_is_local(const struct write_pack_opts *opts)

+{

+ return starts_with(opts->destination, opts->packdir);

+}

+

+int finish_pack_objects_cmd(const struct git_hash_algo *algop,

+ const struct write_pack_opts *opts,

+ struct child_process *cmd,

+ struct string_list *names)

+{

+ FILE *out;

+ bool local = write_pack_opts_is_local(opts);

+ struct strbuf line = STRBUF_INIT;

+

+ out = xfdopen(cmd->out, "r");

+ while (strbuf_getline_lf(&line, out) != EOF) {

+ struct string_list_item *item;

+

+ if (line.len != algop->hexsz)

+ die(_("repack: Expecting full hex object ID lines only "

+ "from pack-objects."));

+ /*

+ * Avoid putting packs written outside of the repository in the

+ * list of names.

+ */

+ if (local) {

+ item = string_list_append(names, line.buf);

+ item->util = generated_pack_populate(line.buf,

+ opts->packtmp);

+ }

+ }

+ fclose(out);

+

+ strbuf_release(&line);

+

+ return finish_command(cmd);

+}

+

+#define DELETE_PACK 1

+#define RETAIN_PACK 2

+

+void existing_packs_collect(struct existing_packs *existing,

+ const struct string_list *extra_keep)

+{

+ struct packed_git *p;

+ struct strbuf buf = STRBUF_INIT;

+

+ repo_for_each_pack(existing->repo, p) {

+ size_t i;

+ const char *base;

+

+ if (p->multi_pack_index)

+ string_list_append(&existing->midx_packs,

+ pack_basename(p));

+ if (!p->pack_local)

+ continue;

+

+ base = pack_basename(p);

+

+ for (i = 0; i < extra_keep->nr; i++)

+ if (!fspathcmp(base, extra_keep->items[i].string))

+ break;

+

+ strbuf_reset(&buf);

+ strbuf_addstr(&buf, base);

+ strbuf_strip_suffix(&buf, ".pack");

+

+ if ((extra_keep->nr > 0 && i < extra_keep->nr) || p->pack_keep)

+ string_list_append(&existing->kept_packs, buf.buf);

+ else if (p->is_cruft)

+ string_list_append(&existing->cruft_packs, buf.buf);

+ else

+ string_list_append(&existing->non_kept_packs, buf.buf);

+ }

+

+ string_list_sort(&existing->kept_packs);

+ string_list_sort(&existing->non_kept_packs);

+ string_list_sort(&existing->cruft_packs);

+ string_list_sort(&existing->midx_packs);

+ strbuf_release(&buf);

+}

+

+int existing_packs_has_non_kept(const struct existing_packs *existing)

+{

+ return existing->non_kept_packs.nr || existing->cruft_packs.nr;

+}

+

+static void existing_pack_mark_for_deletion(struct string_list_item *item)

+{

+ item->util = (void*)((uintptr_t)item->util | DELETE_PACK);

+}

+

+static void existing_pack_unmark_for_deletion(struct string_list_item *item)

+{

+ item->util = (void*)((uintptr_t)item->util & ~DELETE_PACK);

+}

+

+int existing_pack_is_marked_for_deletion(struct string_list_item *item)

+{

+ return (uintptr_t)item->util & DELETE_PACK;

+}

+

+static void existing_packs_mark_retained(struct string_list_item *item)

+{

+ item->util = (void*)((uintptr_t)item->util | RETAIN_PACK);

+}

+

+static int existing_pack_is_retained(struct string_list_item *item)

+{

+ return (uintptr_t)item->util & RETAIN_PACK;

+}

+

+static void existing_packs_mark_for_deletion_1(const struct git_hash_algo *algop,

+ struct string_list *names,

+ struct string_list *list)

+{

+ struct string_list_item *item;

+ const size_t hexsz = algop->hexsz;

+

+ for_each_string_list_item(item, list) {

+ char *sha1;

+ size_t len = strlen(item->string);

+ if (len < hexsz)

+ continue;

+ sha1 = item->string + len - hexsz;

+

+ if (existing_pack_is_retained(item)) {