]>
Commit | Line | Data |
---|---|---|
1 | git-update-index(1) | |
2 | =================== | |
3 | ||
4 | NAME | |
5 | ---- | |
6 | git-update-index - Register file contents in the working tree to the index | |
7 | ||
8 | ||
9 | SYNOPSIS | |
10 | -------- | |
11 | [verse] | |
12 | 'git update-index' | |
13 | [--add] [--remove | --force-remove] [--replace] | |
14 | [--refresh] [-q] [--unmerged] [--ignore-missing] | |
15 | [--cacheinfo <mode> <object> <file>]* | |
16 | [--chmod=(+|-)x] | |
17 | [--assume-unchanged | --no-assume-unchanged] | |
18 | [--skip-worktree | --no-skip-worktree] | |
19 | [--ignore-submodules] | |
20 | [--really-refresh] [--unresolve] [--again | -g] | |
21 | [--info-only] [--index-info] | |
22 | [-z] [--stdin] | |
23 | [--verbose] | |
24 | [--] [<file>]* | |
25 | ||
26 | DESCRIPTION | |
27 | ----------- | |
28 | Modifies the index or directory cache. Each file mentioned is updated | |
29 | into the index and any 'unmerged' or 'needs updating' state is | |
30 | cleared. | |
31 | ||
32 | See also linkgit:git-add[1] for a more user-friendly way to do some of | |
33 | the most common operations on the index. | |
34 | ||
35 | The way 'git update-index' handles files it is told about can be modified | |
36 | using the various options: | |
37 | ||
38 | OPTIONS | |
39 | ------- | |
40 | --add:: | |
41 | If a specified file isn't in the index already then it's | |
42 | added. | |
43 | Default behaviour is to ignore new files. | |
44 | ||
45 | --remove:: | |
46 | If a specified file is in the index but is missing then it's | |
47 | removed. | |
48 | Default behavior is to ignore removed file. | |
49 | ||
50 | --refresh:: | |
51 | Looks at the current index and checks to see if merges or | |
52 | updates are needed by checking stat() information. | |
53 | ||
54 | -q:: | |
55 | Quiet. If --refresh finds that the index needs an update, the | |
56 | default behavior is to error out. This option makes | |
57 | 'git update-index' continue anyway. | |
58 | ||
59 | --ignore-submodules:: | |
60 | Do not try to update submodules. This option is only respected | |
61 | when passed before --refresh. | |
62 | ||
63 | --unmerged:: | |
64 | If --refresh finds unmerged changes in the index, the default | |
65 | behavior is to error out. This option makes 'git update-index' | |
66 | continue anyway. | |
67 | ||
68 | --ignore-missing:: | |
69 | Ignores missing files during a --refresh | |
70 | ||
71 | --cacheinfo <mode> <object> <path>:: | |
72 | Directly insert the specified info into the index. | |
73 | ||
74 | --index-info:: | |
75 | Read index information from stdin. | |
76 | ||
77 | --chmod=(+|-)x:: | |
78 | Set the execute permissions on the updated files. | |
79 | ||
80 | --assume-unchanged:: | |
81 | --no-assume-unchanged:: | |
82 | When these flags are specified, the object names recorded | |
83 | for the paths are not updated. Instead, these options | |
84 | set and unset the "assume unchanged" bit for the | |
85 | paths. When the "assume unchanged" bit is on, git stops | |
86 | checking the working tree files for possible | |
87 | modifications, so you need to manually unset the bit to | |
88 | tell git when you change the working tree file. This is | |
89 | sometimes helpful when working with a big project on a | |
90 | filesystem that has very slow lstat(2) system call | |
91 | (e.g. cifs). | |
92 | + | |
93 | This option can be also used as a coarse file-level mechanism | |
94 | to ignore uncommitted changes in tracked files (akin to what | |
95 | `.gitignore` does for untracked files). | |
96 | Git will fail (gracefully) in case it needs to modify this file | |
97 | in the index e.g. when merging in a commit; | |
98 | thus, in case the assumed-untracked file is changed upstream, | |
99 | you will need to handle the situation manually. | |
100 | ||
101 | --really-refresh:: | |
102 | Like '--refresh', but checks stat information unconditionally, | |
103 | without regard to the "assume unchanged" setting. | |
104 | ||
105 | --skip-worktree:: | |
106 | --no-skip-worktree:: | |
107 | When one of these flags is specified, the object name recorded | |
108 | for the paths are not updated. Instead, these options | |
109 | set and unset the "skip-worktree" bit for the paths. See | |
110 | section "Skip-worktree bit" below for more information. | |
111 | ||
112 | -g:: | |
113 | --again:: | |
114 | Runs 'git update-index' itself on the paths whose index | |
115 | entries are different from those from the `HEAD` commit. | |
116 | ||
117 | --unresolve:: | |
118 | Restores the 'unmerged' or 'needs updating' state of a | |
119 | file during a merge if it was cleared by accident. | |
120 | ||
121 | --info-only:: | |
122 | Do not create objects in the object database for all | |
123 | <file> arguments that follow this flag; just insert | |
124 | their object IDs into the index. | |
125 | ||
126 | --force-remove:: | |
127 | Remove the file from the index even when the working directory | |
128 | still has such a file. (Implies --remove.) | |
129 | ||
130 | --replace:: | |
131 | By default, when a file `path` exists in the index, | |
132 | 'git update-index' refuses an attempt to add `path/file`. | |
133 | Similarly if a file `path/file` exists, a file `path` | |
134 | cannot be added. With --replace flag, existing entries | |
135 | that conflict with the entry being added are | |
136 | automatically removed with warning messages. | |
137 | ||
138 | --stdin:: | |
139 | Instead of taking list of paths from the command line, | |
140 | read list of paths from the standard input. Paths are | |
141 | separated by LF (i.e. one path per line) by default. | |
142 | ||
143 | --verbose:: | |
144 | Report what is being added and removed from index. | |
145 | ||
146 | -z:: | |
147 | Only meaningful with `--stdin`; paths are separated with | |
148 | NUL character instead of LF. | |
149 | ||
150 | \--:: | |
151 | Do not interpret any more arguments as options. | |
152 | ||
153 | <file>:: | |
154 | Files to act on. | |
155 | Note that files beginning with '.' are discarded. This includes | |
156 | `./file` and `dir/./file`. If you don't want this, then use | |
157 | cleaner names. | |
158 | The same applies to directories ending '/' and paths with '//' | |
159 | ||
160 | Using --refresh | |
161 | --------------- | |
162 | '--refresh' does not calculate a new sha1 file or bring the index | |
163 | up-to-date for mode/content changes. But what it *does* do is to | |
164 | "re-match" the stat information of a file with the index, so that you | |
165 | can refresh the index for a file that hasn't been changed but where | |
166 | the stat entry is out of date. | |
167 | ||
168 | For example, you'd want to do this after doing a 'git read-tree', to link | |
169 | up the stat index details with the proper files. | |
170 | ||
171 | Using --cacheinfo or --info-only | |
172 | -------------------------------- | |
173 | '--cacheinfo' is used to register a file that is not in the | |
174 | current working directory. This is useful for minimum-checkout | |
175 | merging. | |
176 | ||
177 | To pretend you have a file with mode and sha1 at path, say: | |
178 | ||
179 | ---------------- | |
180 | $ git update-index --cacheinfo mode sha1 path | |
181 | ---------------- | |
182 | ||
183 | '--info-only' is used to register files without placing them in the object | |
184 | database. This is useful for status-only repositories. | |
185 | ||
186 | Both '--cacheinfo' and '--info-only' behave similarly: the index is updated | |
187 | but the object database isn't. '--cacheinfo' is useful when the object is | |
188 | in the database but the file isn't available locally. '--info-only' is | |
189 | useful when the file is available, but you do not wish to update the | |
190 | object database. | |
191 | ||
192 | ||
193 | Using --index-info | |
194 | ------------------ | |
195 | ||
196 | `--index-info` is a more powerful mechanism that lets you feed | |
197 | multiple entry definitions from the standard input, and designed | |
198 | specifically for scripts. It can take inputs of three formats: | |
199 | ||
200 | . mode SP sha1 TAB path | |
201 | + | |
202 | The first format is what "git-apply --index-info" | |
203 | reports, and used to reconstruct a partial tree | |
204 | that is used for phony merge base tree when falling | |
205 | back on 3-way merge. | |
206 | ||
207 | . mode SP type SP sha1 TAB path | |
208 | + | |
209 | The second format is to stuff 'git ls-tree' output | |
210 | into the index file. | |
211 | ||
212 | . mode SP sha1 SP stage TAB path | |
213 | + | |
214 | This format is to put higher order stages into the | |
215 | index file and matches 'git ls-files --stage' output. | |
216 | ||
217 | To place a higher stage entry to the index, the path should | |
218 | first be removed by feeding a mode=0 entry for the path, and | |
219 | then feeding necessary input lines in the third format. | |
220 | ||
221 | For example, starting with this index: | |
222 | ||
223 | ------------ | |
224 | $ git ls-files -s | |
225 | 100644 8a1218a1024a212bb3db30becd860315f9f3ac52 0 frotz | |
226 | ------------ | |
227 | ||
228 | you can feed the following input to `--index-info`: | |
229 | ||
230 | ------------ | |
231 | $ git update-index --index-info | |
232 | 0 0000000000000000000000000000000000000000 frotz | |
233 | 100644 8a1218a1024a212bb3db30becd860315f9f3ac52 1 frotz | |
234 | 100755 8a1218a1024a212bb3db30becd860315f9f3ac52 2 frotz | |
235 | ------------ | |
236 | ||
237 | The first line of the input feeds 0 as the mode to remove the | |
238 | path; the SHA1 does not matter as long as it is well formatted. | |
239 | Then the second and third line feeds stage 1 and stage 2 entries | |
240 | for that path. After the above, we would end up with this: | |
241 | ||
242 | ------------ | |
243 | $ git ls-files -s | |
244 | 100644 8a1218a1024a212bb3db30becd860315f9f3ac52 1 frotz | |
245 | 100755 8a1218a1024a212bb3db30becd860315f9f3ac52 2 frotz | |
246 | ------------ | |
247 | ||
248 | ||
249 | Using ``assume unchanged'' bit | |
250 | ------------------------------ | |
251 | ||
252 | Many operations in git depend on your filesystem to have an | |
253 | efficient `lstat(2)` implementation, so that `st_mtime` | |
254 | information for working tree files can be cheaply checked to see | |
255 | if the file contents have changed from the version recorded in | |
256 | the index file. Unfortunately, some filesystems have | |
257 | inefficient `lstat(2)`. If your filesystem is one of them, you | |
258 | can set "assume unchanged" bit to paths you have not changed to | |
259 | cause git not to do this check. Note that setting this bit on a | |
260 | path does not mean git will check the contents of the file to | |
261 | see if it has changed -- it makes git to omit any checking and | |
262 | assume it has *not* changed. When you make changes to working | |
263 | tree files, you have to explicitly tell git about it by dropping | |
264 | "assume unchanged" bit, either before or after you modify them. | |
265 | ||
266 | In order to set "assume unchanged" bit, use `--assume-unchanged` | |
267 | option. To unset, use `--no-assume-unchanged`. | |
268 | ||
269 | The command looks at `core.ignorestat` configuration variable. When | |
270 | this is true, paths updated with `git update-index paths...` and | |
271 | paths updated with other git commands that update both index and | |
272 | working tree (e.g. 'git apply --index', 'git checkout-index -u', | |
273 | and 'git read-tree -u') are automatically marked as "assume | |
274 | unchanged". Note that "assume unchanged" bit is *not* set if | |
275 | `git update-index --refresh` finds the working tree file matches | |
276 | the index (use `git update-index --really-refresh` if you want | |
277 | to mark them as "assume unchanged"). | |
278 | ||
279 | ||
280 | Examples | |
281 | -------- | |
282 | To update and refresh only the files already checked out: | |
283 | ||
284 | ---------------- | |
285 | $ git checkout-index -n -f -a && git update-index --ignore-missing --refresh | |
286 | ---------------- | |
287 | ||
288 | On an inefficient filesystem with `core.ignorestat` set:: | |
289 | + | |
290 | ------------ | |
291 | $ git update-index --really-refresh <1> | |
292 | $ git update-index --no-assume-unchanged foo.c <2> | |
293 | $ git diff --name-only <3> | |
294 | $ edit foo.c | |
295 | $ git diff --name-only <4> | |
296 | M foo.c | |
297 | $ git update-index foo.c <5> | |
298 | $ git diff --name-only <6> | |
299 | $ edit foo.c | |
300 | $ git diff --name-only <7> | |
301 | $ git update-index --no-assume-unchanged foo.c <8> | |
302 | $ git diff --name-only <9> | |
303 | M foo.c | |
304 | ------------ | |
305 | + | |
306 | <1> forces lstat(2) to set "assume unchanged" bits for paths that match index. | |
307 | <2> mark the path to be edited. | |
308 | <3> this does lstat(2) and finds index matches the path. | |
309 | <4> this does lstat(2) and finds index does *not* match the path. | |
310 | <5> registering the new version to index sets "assume unchanged" bit. | |
311 | <6> and it is assumed unchanged. | |
312 | <7> even after you edit it. | |
313 | <8> you can tell about the change after the fact. | |
314 | <9> now it checks with lstat(2) and finds it has been changed. | |
315 | ||
316 | ||
317 | Skip-worktree bit | |
318 | ----------------- | |
319 | ||
320 | Skip-worktree bit can be defined in one (long) sentence: When reading | |
321 | an entry, if it is marked as skip-worktree, then Git pretends its | |
322 | working directory version is up to date and read the index version | |
323 | instead. | |
324 | ||
325 | To elaborate, "reading" means checking for file existence, reading | |
326 | file attributes or file content. The working directory version may be | |
327 | present or absent. If present, its content may match against the index | |
328 | version or not. Writing is not affected by this bit, content safety | |
329 | is still first priority. Note that Git _can_ update working directory | |
330 | file, that is marked skip-worktree, if it is safe to do so (i.e. | |
331 | working directory version matches index version) | |
332 | ||
333 | Although this bit looks similar to assume-unchanged bit, its goal is | |
334 | different from assume-unchanged bit's. Skip-worktree also takes | |
335 | precedence over assume-unchanged bit when both are set. | |
336 | ||
337 | ||
338 | Configuration | |
339 | ------------- | |
340 | ||
341 | The command honors `core.filemode` configuration variable. If | |
342 | your repository is on a filesystem whose executable bits are | |
343 | unreliable, this should be set to 'false' (see linkgit:git-config[1]). | |
344 | This causes the command to ignore differences in file modes recorded | |
345 | in the index and the file mode on the filesystem if they differ only on | |
346 | executable bit. On such an unfortunate filesystem, you may | |
347 | need to use 'git update-index --chmod='. | |
348 | ||
349 | Quite similarly, if `core.symlinks` configuration variable is set | |
350 | to 'false' (see linkgit:git-config[1]), symbolic links are checked out | |
351 | as plain files, and this command does not modify a recorded file mode | |
352 | from symbolic link to regular file. | |
353 | ||
354 | The command looks at `core.ignorestat` configuration variable. See | |
355 | 'Using "assume unchanged" bit' section above. | |
356 | ||
357 | The command also looks at `core.trustctime` configuration variable. | |
358 | It can be useful when the inode change time is regularly modified by | |
359 | something outside Git (file system crawlers and backup systems use | |
360 | ctime for marking files processed) (see linkgit:git-config[1]). | |
361 | ||
362 | ||
363 | SEE ALSO | |
364 | -------- | |
365 | linkgit:git-config[1], | |
366 | linkgit:git-add[1] | |
367 | ||
368 | ||
369 | Author | |
370 | ------ | |
371 | Written by Linus Torvalds <torvalds@osdl.org> | |
372 | ||
373 | Documentation | |
374 | -------------- | |
375 | Documentation by David Greaves, Junio C Hamano and the git-list <git@vger.kernel.org>. | |
376 | ||
377 | GIT | |
378 | --- | |
379 | Part of the linkgit:git[1] suite |