summaryrefslogtreecommitdiff
path: root/Documentation/git-update-ref.txt
blob: 969bfab2ab422ca8b7bdf2eb3ba45edc92fcd00b (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
git-update-ref(1)
=================
 
NAME
----
git-update-ref - Update the object name stored in a ref safely
 
SYNOPSIS
--------
[verse]
'git update-ref' [-m <reason>] (-d <ref> [<oldvalue>] | [--no-deref] [--create-reflog] <ref> <newvalue> [<oldvalue>] | --stdin [-z])
 
DESCRIPTION
-----------
Given two arguments, stores the <newvalue> in the <ref>, possibly
dereferencing the symbolic refs.  E.g. `git update-ref HEAD
<newvalue>` updates the current branch head to the new object.
 
Given three arguments, stores the <newvalue> in the <ref>,
possibly dereferencing the symbolic refs, after verifying that
the current value of the <ref> matches <oldvalue>.
E.g. `git update-ref refs/heads/master <newvalue> <oldvalue>`
updates the master branch head to <newvalue> only if its current
value is <oldvalue>.  You can specify 40 "0" or an empty string
as <oldvalue> to make sure that the ref you are creating does
not exist.
 
It also allows a "ref" file to be a symbolic pointer to another
ref file by starting with the four-byte header sequence of
"ref:".
 
More importantly, it allows the update of a ref file to follow
these symbolic pointers, whether they are symlinks or these
"regular file symbolic refs".  It follows *real* symlinks only
if they start with "refs/": otherwise it will just try to read
them and update them as a regular file (i.e. it will allow the
filesystem to follow them, but will overwrite such a symlink to
somewhere else with a regular filename).
 
If --no-deref is given, <ref> itself is overwritten, rather than
the result of following the symbolic pointers.
 
In general, using
 
	git update-ref HEAD "$head"
 
should be a _lot_ safer than doing
 
	echo "$head" > "$GIT_DIR/HEAD"
 
both from a symlink following standpoint *and* an error checking
standpoint.  The "refs/" rule for symlinks means that symlinks
that point to "outside" the tree are safe: they'll be followed
for reading but not for writing (so we'll never write through a
ref symlink to some other tree, if you have copied a whole
archive by creating a symlink tree).
 
With `-d` flag, it deletes the named <ref> after verifying it
still contains <oldvalue>.
 
With `--stdin`, update-ref reads instructions from standard input and
performs all modifications together.  Specify commands of the form:
 
	update SP <ref> SP <newvalue> [SP <oldvalue>] LF
	create SP <ref> SP <newvalue> LF
	delete SP <ref> [SP <oldvalue>] LF
	verify SP <ref> [SP <oldvalue>] LF
	option SP <opt> LF
 
With `--create-reflog`, update-ref will create a reflog for each ref
even if one would not ordinarily be created.
 
Quote fields containing whitespace as if they were strings in C source
code; i.e., surrounded by double-quotes and with backslash escapes.
Use 40 "0" characters or the empty string to specify a zero value.  To
specify a missing value, omit the value and its preceding SP entirely.
 
Alternatively, use `-z` to specify in NUL-terminated format, without
quoting:
 
	update SP <ref> NUL <newvalue> NUL [<oldvalue>] NUL
	create SP <ref> NUL <newvalue> NUL
	delete SP <ref> NUL [<oldvalue>] NUL
	verify SP <ref> NUL [<oldvalue>] NUL
	option SP <opt> NUL
 
In this format, use 40 "0" to specify a zero value, and use the empty
string to specify a missing value.
 
In either format, values can be specified in any form that Git
recognizes as an object name.  Commands in any other format or a
repeated <ref> produce an error.  Command meanings are:
 
update::
	Set <ref> to <newvalue> after verifying <oldvalue>, if given.
	Specify a zero <newvalue> to ensure the ref does not exist
	after the update and/or a zero <oldvalue> to make sure the
	ref does not exist before the update.
 
create::
	Create <ref> with <newvalue> after verifying it does not
	exist.  The given <newvalue> may not be zero.
 
delete::
	Delete <ref> after verifying it exists with <oldvalue>, if
	given.  If given, <oldvalue> may not be zero.
 
verify::
	Verify <ref> against <oldvalue> but do not change it.  If
	<oldvalue> zero or missing, the ref must not exist.
 
option::
	Modify behavior of the next command naming a <ref>.
	The only valid option is `no-deref` to avoid dereferencing
	a symbolic ref.
 
If all <ref>s can be locked with matching <oldvalue>s
simultaneously, all modifications are performed.  Otherwise, no
modifications are performed.  Note that while each individual
<ref> is updated or deleted atomically, a concurrent reader may
still see a subset of the modifications.
 
Logging Updates
---------------
If config parameter "core.logAllRefUpdates" is true and the ref is one under
"refs/heads/", "refs/remotes/", "refs/notes/", or the symbolic ref HEAD; or
the file "$GIT_DIR/logs/<ref>" exists then `git update-ref` will append
a line to the log file "$GIT_DIR/logs/<ref>" (dereferencing all
symbolic refs before creating the log name) describing the change
in ref value.  Log lines are formatted as:
 
    . oldsha1 SP newsha1 SP committer LF
+
Where "oldsha1" is the 40 character hexadecimal value previously
stored in <ref>, "newsha1" is the 40 character hexadecimal value of
<newvalue> and "committer" is the committer's name, email address
and date in the standard Git committer ident format.
 
Optionally with -m:
 
    . oldsha1 SP newsha1 SP committer TAB message LF
+
Where all fields are as described above and "message" is the
value supplied to the -m option.
 
An update will fail (without changing <ref>) if the current user is
unable to create a new log file, append to the existing log file
or does not have committer information available.
 
GIT
---
Part of the linkgit:git[1] suite