| 1. | Git User’s Manual |
| 2. | Trace2 documentation |
| 3. | Git concepts chapter of the user-manual |
| 4. | howto |
| 5. | Git API documentation |
| 6. | [email protected] |
| 7. | [email protected] |
NAME
git - the stupid content tracker
SYNOPSIS
git\n [-v | --version] [-h | --help] [-C <path>] [-c <name>=<value>]
\n
[--exec-path[=<path>]] [--html-path] [--man-path] [--info-path]
\n
[-p | --paginate | -P | --no-pager] [--no-replace-objects] [--no-lazy-fetch]
\n
[--no-optional-locks] [--no-advice] [--bare] [--git-dir=<path>]
\n
[--work-tree=<path>] [--namespace=<name>] [--config-env=<name>=<envvar>]
\n
<command> [<args>]DESCRIPTION
Git is a fast, scalable, distributed revision control system with an unusually rich command set that provides both high-level operations and full access to internals.
See gittutorial(7) to get started, then see giteveryday(7) for a useful minimum set of commands. The Git User’s Manual[1] has a more in-depth introduction.
After you mastered the basic concepts, you can come back to this page to learn what commands Git offers. You can learn more about individual Git commands with "git help command". gitcli(7) manual page gives you an overview of the command-line command syntax.
A formatted and hyperlinked copy of the latest Git documentation can be viewed at https://git.github.io/htmldocs/git.html or https://git-scm.com/docs.
OPTIONS
-v, --version
This option is internally converted to git version ... and accepts the same options as the git-version(1) command. If --help is also given, it takes precedence over --version.
-h, --help
Other options are available to control how the manual page is displayed. See git-help(1) for more information, because git --help ... is converted internally into git help ....
-C <path>
This option affects options that expect path name like --git-dir and --work-tree in that their interpretations of the path names would be made relative to the working directory caused by the -C option. For example the following invocations are equivalent:
git --git-dir=a.git --work-tree=b -C c status
git --git-dir=c/a.git --work-tree=c/b status-c <name>=<value>
Note that omitting the = in git -c foo.bar ... is allowed and sets foo.bar to the boolean true value (just like [foo]bar would in a config file). Including the equals but with an empty value (like git -c foo.bar= ...) sets foo.bar to the empty string which git config --type=bool will convert to false.
--config-env=<name>=<envvar>
This is useful for cases where you want to pass transitory configuration options to git, but are doing so on operating systems where other processes might be able to read your command line (e.g. /proc/self/cmdline), but not your environment (e.g. /proc/self/environ). That behavior is the default on Linux, but may not be on your system.
Note that this might add security for variables such as http.extraHeader where the sensitive information is part of the value, but not e.g. url.<base>.insteadOf where the sensitive information can be part of the key.
--exec-path[=<path>]
--html-path
--man-path
--info-path
-p, --paginate
-P, --no-pager
--git-dir=<path>
Specifying the location of the ".git" directory using this option (or GIT_DIR environment variable) turns off the repository discovery that tries to find a directory with ".git" subdirectory (which is how the repository and the top-level of the working tree are discovered), and tells Git that you are at the top level of the working tree. If you are not at the top-level directory of the working tree, you should tell Git where the top-level of the working tree is, with the --work-tree=<path> option (or GIT_WORK_TREE environment variable)
If you just want to run git as if it was started in <path> then use git -C <path>.
--work-tree=<path>
--namespace=<path>
--bare
--no-replace-objects
--no-lazy-fetch
--no-optional-locks
--no-advice
--literal-pathspecs
--glob-pathspecs
--noglob-pathspecs
--icase-pathspecs
--list-cmds=<group>[,<group>...]
--attr-source=<tree-ish>
GIT COMMANDS
We divide Git into high level ("porcelain") commands and low level ("plumbing") commands.
HIGH-LEVEL COMMANDS (PORCELAIN)
We separate the porcelain commands into the main commands and some ancillary user utilities.
Main porcelain commands
git-add(1)
git-am(1)
git-archive(1)
git-bisect(1)
git-branch(1)
git-bundle(1)
git-checkout(1)
git-cherry-pick(1)
git-citool(1)
git-clean(1)
git-clone(1)
git-commit(1)
git-describe(1)
git-diff(1)
git-fetch(1)
git-format-patch(1)
git-gc(1)
git-grep(1)
git-gui(1)
git-init(1)
git-log(1)
git-maintenance(1)
git-merge(1)
git-mv(1)
git-notes(1)
git-pull(1)
git-push(1)
git-range-diff(1)
git-rebase(1)
git-reset(1)
git-restore(1)
git-revert(1)
git-rm(1)
git-shortlog(1)
git-show(1)
git-sparse-checkout(1)
git-stash(1)
git-status(1)
git-submodule(1)
git-switch(1)
git-tag(1)
git-worktree(1)
gitk(1)
scalar(1)
Ancillary Commands
Manipulators:
git-config(1)
git-fast-export(1)
git-fast-import(1)
git-filter-branch(1)
git-mergetool(1)
git-pack-refs(1)
git-prune(1)
git-reflog(1)
git-refs(1)
git-remote(1)
git-repack(1)
git-replace(1)
Interrogators:
git-annotate(1)
git-blame(1)
git-bugreport(1)
git-count-objects(1)
git-diagnose(1)
git-difftool(1)
git-fsck(1)
git-help(1)
git-instaweb(1)
git-merge-tree(1)
git-rerere(1)
git-show-branch(1)
git-verify-commit(1)
git-verify-tag(1)
git-version(1)
git-whatchanged(1)
gitweb(1)
Interacting with Others
These commands are to interact with foreign SCM and with other people via patch over e-mail.
git-archimport(1)
git-cvsexportcommit(1)
git-cvsimport(1)
git-cvsserver(1)
git-imap-send(1)
git-p4(1)
git-quiltimport(1)
git-request-pull(1)
git-send-email(1)
git-svn(1)
Reset, restore and revert
There are three commands with similar names: git reset, git restore and git revert.
git reset can also be used to restore the index, overlapping with git restore.
LOW-LEVEL COMMANDS (PLUMBING)
Although Git includes its own porcelain layer, its low-level commands are sufficient to support development of alternative porcelains. Developers of such porcelains might start by reading about git-update-index(1) and git-read-tree(1).
The interface (input, output, set of options and the semantics) to these low-level commands are meant to be a lot more stable than Porcelain level commands, because these commands are primarily for scripted use. The interface to Porcelain commands on the other hand are subject to change in order to improve the end user experience.
The following description divides the low-level commands into commands that manipulate objects (in the repository, index, and working tree), commands that interrogate and compare objects, and commands that move objects and references between repositories.
Manipulation commands
git-apply(1)
git-checkout-index(1)
git-commit-graph(1)
git-commit-tree(1)
git-hash-object(1)
git-index-pack(1)
git-merge-file(1)
git-merge-index(1)
git-mktag(1)
git-mktree(1)
git-multi-pack-index(1)
git-pack-objects(1)
git-prune-packed(1)
git-read-tree(1)
git-replay(1)
git-symbolic-ref(1)
git-unpack-objects(1)
git-update-index(1)
git-update-ref(1)
git-write-tree(1)
Interrogation commands
git-cat-file(1)
git-cherry(1)
git-diff-files(1)
git-diff-index(1)
git-diff-tree(1)
git-for-each-ref(1)
git-for-each-repo(1)
git-get-tar-commit-id(1)
git-ls-files(1)
git-ls-remote(1)
git-ls-tree(1)
git-merge-base(1)
git-name-rev(1)
git-pack-redundant(1)
git-rev-list(1)
git-rev-parse(1)
git-show-index(1)
git-show-ref(1)
git-unpack-file(1)
git-var(1)
git-verify-pack(1)
In general, the interrogate commands do not touch the files in the working tree.
Syncing repositories
git-daemon(1)
git-fetch-pack(1)
git-http-backend(1)
git-send-pack(1)
git-update-server-info(1)
The following are helper commands used by the above; end users typically do not use them directly.
git-http-fetch(1)
git-http-push(1)
git-receive-pack(1)
git-shell(1)
git-upload-archive(1)
git-upload-pack(1)
Internal helper commands
These are internal helper commands used by other commands; end users typically do not use them directly.
git-check-attr(1)
git-check-ignore(1)
git-check-mailmap(1)
git-check-ref-format(1)
git-column(1)
git-credential(1)
git-credential-cache(1)
git-credential-store(1)
git-fmt-merge-msg(1)
git-hook(1)
git-interpret-trailers(1)
git-mailinfo(1)
git-mailsplit(1)
git-merge-one-file(1)
git-patch-id(1)
git-sh-i18n(1)
git-sh-setup(1)
git-stripspace(1)
GUIDES
The following documentation pages are guides about Git concepts.
gitcore-tutorial(7)
gitcredentials(7)
gitcvs-migration(7)
gitdiffcore(7)
giteveryday(7)
gitfaq(7)
gitglossary(7)
gitnamespaces(7)
gitremote-helpers(7)
gitsubmodules(7)
gittutorial(7)
gittutorial-2(7)
gitworkflows(7)
REPOSITORY, COMMAND AND FILE INTERFACES
This documentation discusses repository and command interfaces which users are expected to interact with directly. See --user-formats in git-help(1) for more details on the criteria.
gitattributes(5)
gitcli(7)
githooks(5)
gitignore(5)
gitmailmap(5)
gitmodules(5)
gitrepository-layout(5)
gitrevisions(7)
FILE FORMATS, PROTOCOLS AND OTHER DEVELOPER INTERFACES
This documentation discusses file formats, over-the-wire protocols and other git developer interfaces. See --developer-interfaces in git-help(1).
gitformat-bundle(5)
gitformat-chunk(5)
gitformat-commit-graph(5)
gitformat-index(5)
gitformat-pack(5)
gitformat-signature(5)
gitprotocol-capabilities(5)
gitprotocol-common(5)
gitprotocol-http(5)
gitprotocol-pack(5)
gitprotocol-v2(5)
CONFIGURATION MECHANISM
Git uses a simple text format to store customizations that are per repository and are per user. Such a configuration file may look like this:
#
# A '#' or ';' character indicates a comment.
#
; core variables
[core]
\n
; Don't trust file modes
\n
filemode = false
; user identity
[user]
\n
name = "Junio C Hamano"
\n
email = "[email protected]"Various commands read from the configuration file and adjust their operation accordingly. See git-config(1) for a list and more details about the configuration mechanism.
IDENTIFIER TERMINOLOGY
<object>
<blob>
<tree>
<commit>
<tree-ish>
<commit-ish>
<type>
<file>
SYMBOLIC IDENTIFIERS
Any Git command accepting any <object> can also use the following symbolic notation:
HEAD
<tag>
<head>
For a more complete list of ways to spell object names, see "SPECIFYING REVISIONS" section in gitrevisions(7).
FILE/DIRECTORY STRUCTURE
Please see the gitrepository-layout(5) document.
Read githooks(5) for more details about each hook.
Higher level SCMs may provide and manage additional information in the $GIT_DIR.
TERMINOLOGY
Please see gitglossary(7).
ENVIRONMENT VARIABLES
Various Git commands pay attention to environment variables and change their behavior. The environment variables marked as "Boolean" take their values the same way as Boolean valued configuration variables, e.g. "true", "yes", "on" and positive numbers are taken as "yes".
Here are the variables:
The Git Repository
These environment variables apply to all core Git commands. Nb: it is worth noting that they may be used/overridden by SCMS sitting above Git so take care if using a foreign front-end.
GIT_INDEX_FILE
GIT_INDEX_VERSION
GIT_OBJECT_DIRECTORY
GIT_ALTERNATE_OBJECT_DIRECTORIES
Entries that begin with " (double-quote) will be interpreted as C-style quoted paths, removing leading and trailing double-quotes and respecting backslash escapes. E.g., the value "path-with-\"-and-:-in-it":vanilla-path has two paths: path-with-"-and-:-in-it and vanilla-path.
GIT_DIR
GIT_WORK_TREE
GIT_NAMESPACE
GIT_CEILING_DIRECTORIES
GIT_DISCOVERY_ACROSS_FILESYSTEM
GIT_COMMON_DIR
GIT_DEFAULT_HASH
GIT_DEFAULT_REF_FORMAT
Git Commits
GIT_AUTHOR_NAME
GIT_AUTHOR_EMAIL
GIT_AUTHOR_DATE
GIT_COMMITTER_NAME
GIT_COMMITTER_EMAIL
GIT_COMMITTER_DATE
Git Diffs
GIT_DIFF_OPTS
GIT_EXTERNAL_DIFF
path old-file old-hex old-mode new-file new-hex new-modewhere:
<old|new>-file
<old|new>-hex
<old|new>-mode
The file parameters can point at the user’s working file (e.g. new-file in "git-diff-files"), /dev/null (e.g. old-file when a new file is added), or a temporary file (e.g. old-file in the index). GIT_EXTERNAL_DIFF should not worry about unlinking the temporary file — it is removed when GIT_EXTERNAL_DIFF exits.
For a path that is unmerged, GIT_EXTERNAL_DIFF is called with 1 parameter, <path>.
For each path GIT_EXTERNAL_DIFF is called, two environment variables, GIT_DIFF_PATH_COUNTER and GIT_DIFF_PATH_TOTAL are set.
GIT_EXTERNAL_DIFF_TRUST_EXIT_CODE
GIT_DIFF_PATH_COUNTER
GIT_DIFF_PATH_TOTAL
other
GIT_MERGE_VERBOSITY
GIT_PAGER
GIT_PROGRESS_DELAY
GIT_EDITOR
GIT_SEQUENCE_EDITOR
GIT_SSH, GIT_SSH_COMMAND
$GIT_SSH_COMMAND takes precedence over $GIT_SSH, and is interpreted by the shell, which allows additional arguments to be included. $GIT_SSH on the other hand must be just the path to a program (which can be a wrapper shell script, if additional arguments are needed).
Usually it is easier to configure any desired options through your personal .ssh/config file. Please consult your ssh documentation for further details.
GIT_SSH_VARIANT
GIT_SSL_NO_VERIFY
GIT_ATTR_SOURCE
GIT_ASKPASS
GIT_TERMINAL_PROMPT
GIT_CONFIG_GLOBAL, GIT_CONFIG_SYSTEM
GIT_CONFIG_NOSYSTEM
GIT_FLUSH
GIT_TRACE
If this variable is set to "1", "2" or "true" (comparison is case insensitive), trace messages will be printed to stderr.
If the variable is set to an integer value greater than 2 and lower than 10 (strictly) then Git will interpret this value as an open file descriptor and will try to write the trace messages into this file descriptor.
Alternatively, if the variable is set to an absolute path (starting with a / character), Git will interpret this as a file path and will try to append the trace messages to it.
Unsetting the variable, or setting it to empty, "0" or "false" (case insensitive) disables trace messages.
GIT_TRACE_FSMONITOR
GIT_TRACE_PACK_ACCESS
GIT_TRACE_PACKET
GIT_TRACE_PACKFILE
Note that this is currently only implemented for the client side of clones and fetches.
GIT_TRACE_PERFORMANCE
GIT_TRACE_REFS
GIT_TRACE_SETUP
GIT_TRACE_SHALLOW
GIT_TRACE_CURL
GIT_TRACE_CURL_NO_DATA
GIT_TRACE2
If this variable is set to "1", "2" or "true" (comparison is case insensitive), trace messages will be printed to stderr.
If the variable is set to an integer value greater than 2 and lower than 10 (strictly) then Git will interpret this value as an open file descriptor and will try to write the trace messages into this file descriptor.
Alternatively, if the variable is set to an absolute path (starting with a / character), Git will interpret this as a file path and will try to append the trace messages to it. If the path already exists and is a directory, the trace messages will be written to files (one per process) in that directory, named according to the last component of the SID and an optional counter (to avoid filename collisions).
In addition, if the variable is set to af_unix:[<socket-type>:]<absolute-pathname>, Git will try to open the path as a Unix Domain Socket. The socket type can be either stream or dgram.
Unsetting the variable, or setting it to empty, "0" or "false" (case insensitive) disables trace messages.
See Trace2 documentation[2] for full details.
GIT_TRACE2_EVENT
GIT_TRACE2_PERF
GIT_TRACE_REDACT
GIT_NO_REPLACE_OBJECTS
GIT_LITERAL_PATHSPECS
GIT_GLOB_PATHSPECS
GIT_NOGLOB_PATHSPECS
GIT_ICASE_PATHSPECS
GIT_NO_LAZY_FETCH
GIT_REFLOG_ACTION
GIT_REF_PARANOIA
GIT_COMMIT_GRAPH_PARANOIA
The default is "false", which disables the aforementioned behavior. Setting this to "true" enables the existence check so that stale commits will never be returned from the commit-graph at the cost of performance.
GIT_ALLOW_PROTOCOL
GIT_PROTOCOL_FROM_USER
GIT_PROTOCOL
Note that servers may need to be configured to allow this variable to pass over some transports. It will be propagated automatically when accessing local repositories (i.e., file:// or a filesystem path), as well as over the git:// protocol. For git-over-http, it should work automatically in most configurations, but see the discussion in git-http-backend(1). For git-over-ssh, the ssh server may need to be configured to allow clients to pass this variable (e.g., by using AcceptEnv GIT_PROTOCOL with OpenSSH).
This configuration is optional. If the variable is not propagated, then clients will fall back to the original "v0" protocol (but may miss out on some performance improvements or features). This variable currently only affects clones and fetches; it is not yet used for pushes (but may be in the future).
GIT_OPTIONAL_LOCKS
GIT_REDIRECT_STDIN, GIT_REDIRECT_STDOUT, GIT_REDIRECT_STDERR
Two special values are supported: off will simply close the corresponding standard handle, and if GIT_REDIRECT_STDERR is 2>&1, standard error will be redirected to the same handle as standard output.
GIT_PRINT_SHA1_ELLIPSIS (deprecated)
GIT_ADVICE
DISCUSSION
More detail on the following is available from the Git concepts chapter of the user-manual[3] and gitcore-tutorial(7).
A Git project normally consists of a working directory with a ".git" subdirectory at the top level. The .git directory contains, among other things, a compressed object database representing the complete history of the project, an "index" file which links that history to the current contents of the working tree, and named pointers into that history such as tags and branch heads.
The object database contains objects of three main types: blobs, which hold file data; trees, which point to blobs and other trees to build up directory hierarchies; and commits, which each reference a single tree and some number of parent commits.
The commit, equivalent to what other systems call a "changeset" or "version", represents a step in the project’s history, and each parent represents an immediately preceding step. Commits with more than one parent represent merges of independent lines of development.
All objects are named by the SHA-1 hash of their contents, normally written as a string of 40 hex digits. Such names are globally unique. The entire history leading up to a commit can be vouched for by signing just that commit. A fourth object type, the tag, is provided for this purpose.
When first created, objects are stored in individual files, but for efficiency may later be compressed together into "pack files".
Named pointers called refs mark interesting points in history. A ref may contain the SHA-1 name of an object or the name of another ref (the latter is called a "symbolic ref"). Refs with names beginning refs/head/ contain the SHA-1 name of the most recent commit (or "head") of a branch under development. SHA-1 names of tags of interest are stored under refs/tags/. A symbolic ref named HEAD contains the name of the currently checked-out branch.
The index file is initialized with a list of all paths and, for each path, a blob object and a set of attributes. The blob object represents the contents of the file as of the head of the current branch. The attributes (last modified time, size, etc.) are taken from the corresponding file in the working tree. Subsequent changes to the working tree can be found by comparing these attributes. The index may be updated with new content, and new commits may be created from the content stored in the index.
The index is also capable of storing multiple entries (called "stages") for a given pathname. These stages are used to hold the various unmerged version of a file when a merge is in progress.
SECURITY
Some configuration options and hook files may cause Git to run arbitrary shell commands. Because configuration and hooks are not copied using git clone, it is generally safe to clone remote repositories with untrusted content, inspect them with git log, and so on.
However, it is not safe to run Git commands in a .git directory (or the working tree that surrounds it) when that .git directory itself comes from an untrusted source. The commands in its config and hooks are executed in the usual way.
By default, Git will refuse to run when the repository is owned by someone other than the user running the command. See the entry for safe.directory in git-config(1). While this can help protect you in a multi-user environment, note that you can also acquire untrusted repositories that are owned by you (for example, if you extract a zip file or tarball from an untrusted source). In such cases, you’d need to "sanitize" the untrusted repository first.
If you have an untrusted .git directory, you should first clone it with git clone --no-local to obtain a clean copy. Git does restrict the set of options and hooks that will be run by upload-pack, which handles the server side of a clone or fetch, but beware that the surface area for attack against upload-pack is large, so this does carry some risk. The safest thing is to serve the repository as an unprivileged user (either via git-daemon(1), ssh, or using other tools to change user ids). See the discussion in the SECURITY section of git-upload-pack(1).
FURTHER DOCUMENTATION
See the references in the "description" section to get started using Git. The following is probably more detail than necessary for a first-time user.
The Git concepts chapter of the user-manual[3] and gitcore-tutorial(7) both provide introductions to the underlying Git architecture.
See gitworkflows(7) for an overview of recommended workflows.
See also the howto[4] documents for some useful examples.
The internals are documented in the Git API documentation[5].
Users migrating from CVS may also want to read gitcvs-migration(7).
AUTHORS
Git was started by Linus Torvalds, and is currently maintained by Junio C Hamano. Numerous contributions have come from the Git mailing list <[email protected][6]>. https://openhub.net/p/git/contributors/summary gives you a more complete list of contributors.
If you have a clone of git.git itself, the output of git-shortlog(1) and git-blame(1) can show you the authors for specific parts of the project.
REPORTING BUGS
Report bugs to the Git mailing list <[email protected][6]> where the development and maintenance is primarily done. You do not have to be subscribed to the list to send a message there. See the list archive at https://lore.kernel.org/git for previous bug reports and other discussions.
Issues which are security relevant should be disclosed privately to the Git Security mailing list <[email protected][7]>.
SEE ALSO
gittutorial(7), gittutorial-2(7), giteveryday(7), gitcvs-migration(7), gitglossary(7), gitcore-tutorial(7), gitcli(7), The Git User’s Manual[1], gitworkflows(7)
GIT
Part of the git(1) suite
NOTES
- 1.
Git User’s Manual
- 2.
Trace2 documentation
- 3.
Git concepts chapter of the user-manual
- 4.
howto
- 5.
Git API documentation