hold_locked_index(): move from lockfile.c to read-cache.c
[git/git.git] / lockfile.c
1 /*
2 * Copyright (c) 2005, Junio C Hamano
3 */
4 #include "cache.h"
5 #include "sigchain.h"
6
7 /*
8 * File write-locks as used by Git.
9 *
10 * For an overview of how to use the lockfile API, please see
11 *
12 * Documentation/technical/api-lockfile.txt
13 *
14 * This module keeps track of all locked files in lock_file_list for
15 * use at cleanup. This list and the lock_file objects that comprise
16 * it must be kept in self-consistent states at all time, because the
17 * program can be interrupted any time by a signal, in which case the
18 * signal handler will walk through the list attempting to clean up
19 * any open lock files.
20 *
21 * A lockfile is owned by the process that created it. The lock_file
22 * object has an "owner" field that records its owner. This field is
23 * used to prevent a forked process from closing a lockfile created by
24 * its parent.
25 *
26 * The possible states of a lock_file object are as follows:
27 *
28 * - Uninitialized. In this state the object's on_list field must be
29 * zero but the rest of its contents need not be initialized. As
30 * soon as the object is used in any way, it is irrevocably
31 * registered in the lock_file_list, and on_list is set.
32 *
33 * - Locked, lockfile open (after hold_lock_file_for_update(),
34 * hold_lock_file_for_append(), or reopen_lock_file()). In this
35 * state:
36 * - the lockfile exists
37 * - active is set
38 * - filename holds the filename of the lockfile
39 * - fd holds a file descriptor open for writing to the lockfile
40 * - owner holds the PID of the process that locked the file
41 *
42 * - Locked, lockfile closed (after successful close_lock_file()).
43 * Same as the previous state, except that the lockfile is closed
44 * and fd is -1.
45 *
46 * - Unlocked (after commit_lock_file(), commit_lock_file_to(),
47 * rollback_lock_file(), a failed attempt to lock, or a failed
48 * close_lock_file()). In this state:
49 * - active is unset
50 * - filename is empty (usually, though there are transitory
51 * states in which this condition doesn't hold). Client code should
52 * *not* rely on the filename being empty in this state.
53 * - fd is -1
54 * - the object is left registered in the lock_file_list, and
55 * on_list is set.
56 */
57
58 static struct lock_file *volatile lock_file_list;
59
60 static void remove_lock_files(void)
61 {
62 pid_t me = getpid();
63
64 while (lock_file_list) {
65 if (lock_file_list->owner == me)
66 rollback_lock_file(lock_file_list);
67 lock_file_list = lock_file_list->next;
68 }
69 }
70
71 static void remove_lock_files_on_signal(int signo)
72 {
73 remove_lock_files();
74 sigchain_pop(signo);
75 raise(signo);
76 }
77
78 /*
79 * path = absolute or relative path name
80 *
81 * Remove the last path name element from path (leaving the preceding
82 * "/", if any). If path is empty or the root directory ("/"), set
83 * path to the empty string.
84 */
85 static void trim_last_path_component(struct strbuf *path)
86 {
87 int i = path->len;
88
89 /* back up past trailing slashes, if any */
90 while (i && path->buf[i - 1] == '/')
91 i--;
92
93 /*
94 * then go backwards until a slash, or the beginning of the
95 * string
96 */
97 while (i && path->buf[i - 1] != '/')
98 i--;
99
100 strbuf_setlen(path, i);
101 }
102
103
104 /* We allow "recursive" symbolic links. Only within reason, though */
105 #define MAXDEPTH 5
106
107 /*
108 * path contains a path that might be a symlink.
109 *
110 * If path is a symlink, attempt to overwrite it with a path to the
111 * real file or directory (which may or may not exist), following a
112 * chain of symlinks if necessary. Otherwise, leave path unmodified.
113 *
114 * This is a best-effort routine. If an error occurs, path will
115 * either be left unmodified or will name a different symlink in a
116 * symlink chain that started with the original path.
117 */
118 static void resolve_symlink(struct strbuf *path)
119 {
120 int depth = MAXDEPTH;
121 static struct strbuf link = STRBUF_INIT;
122
123 while (depth--) {
124 if (strbuf_readlink(&link, path->buf, path->len) < 0)
125 break;
126
127 if (is_absolute_path(link.buf))
128 /* absolute path simply replaces p */
129 strbuf_reset(path);
130 else
131 /*
132 * link is a relative path, so replace the
133 * last element of p with it.
134 */
135 trim_last_path_component(path);
136
137 strbuf_addbuf(path, &link);
138 }
139 strbuf_reset(&link);
140 }
141
142 /* Make sure errno contains a meaningful value on error */
143 static int lock_file(struct lock_file *lk, const char *path, int flags)
144 {
145 size_t pathlen = strlen(path);
146
147 if (!lock_file_list) {
148 /* One-time initialization */
149 sigchain_push_common(remove_lock_files_on_signal);
150 atexit(remove_lock_files);
151 }
152
153 if (lk->active)
154 die("BUG: cannot lock_file(\"%s\") using active struct lock_file",
155 path);
156 if (!lk->on_list) {
157 /* Initialize *lk and add it to lock_file_list: */
158 lk->fd = -1;
159 lk->active = 0;
160 lk->owner = 0;
161 strbuf_init(&lk->filename, pathlen + LOCK_SUFFIX_LEN);
162 lk->next = lock_file_list;
163 lock_file_list = lk;
164 lk->on_list = 1;
165 } else if (lk->filename.len) {
166 /* This shouldn't happen, but better safe than sorry. */
167 die("BUG: lock_file(\"%s\") called with improperly-reset lock_file object",
168 path);
169 }
170
171 strbuf_add(&lk->filename, path, pathlen);
172 if (!(flags & LOCK_NO_DEREF))
173 resolve_symlink(&lk->filename);
174 strbuf_addstr(&lk->filename, LOCK_SUFFIX);
175 lk->fd = open(lk->filename.buf, O_RDWR | O_CREAT | O_EXCL, 0666);
176 if (lk->fd < 0) {
177 strbuf_reset(&lk->filename);
178 return -1;
179 }
180 lk->owner = getpid();
181 lk->active = 1;
182 if (adjust_shared_perm(lk->filename.buf)) {
183 int save_errno = errno;
184 error("cannot fix permission bits on %s", lk->filename.buf);
185 rollback_lock_file(lk);
186 errno = save_errno;
187 return -1;
188 }
189 return lk->fd;
190 }
191
192 void unable_to_lock_message(const char *path, int err, struct strbuf *buf)
193 {
194 if (err == EEXIST) {
195 strbuf_addf(buf, "Unable to create '%s.lock': %s.\n\n"
196 "If no other git process is currently running, this probably means a\n"
197 "git process crashed in this repository earlier. Make sure no other git\n"
198 "process is running and remove the file manually to continue.",
199 absolute_path(path), strerror(err));
200 } else
201 strbuf_addf(buf, "Unable to create '%s.lock': %s",
202 absolute_path(path), strerror(err));
203 }
204
205 int unable_to_lock_error(const char *path, int err)
206 {
207 struct strbuf buf = STRBUF_INIT;
208
209 unable_to_lock_message(path, err, &buf);
210 error("%s", buf.buf);
211 strbuf_release(&buf);
212 return -1;
213 }
214
215 NORETURN void unable_to_lock_die(const char *path, int err)
216 {
217 struct strbuf buf = STRBUF_INIT;
218
219 unable_to_lock_message(path, err, &buf);
220 die("%s", buf.buf);
221 }
222
223 /* This should return a meaningful errno on failure */
224 int hold_lock_file_for_update(struct lock_file *lk, const char *path, int flags)
225 {
226 int fd = lock_file(lk, path, flags);
227 if (fd < 0 && (flags & LOCK_DIE_ON_ERROR))
228 unable_to_lock_die(path, errno);
229 return fd;
230 }
231
232 int hold_lock_file_for_append(struct lock_file *lk, const char *path, int flags)
233 {
234 int fd, orig_fd;
235
236 fd = lock_file(lk, path, flags);
237 if (fd < 0) {
238 if (flags & LOCK_DIE_ON_ERROR)
239 unable_to_lock_die(path, errno);
240 return fd;
241 }
242
243 orig_fd = open(path, O_RDONLY);
244 if (orig_fd < 0) {
245 if (errno != ENOENT) {
246 int save_errno = errno;
247
248 if (flags & LOCK_DIE_ON_ERROR)
249 die("cannot open '%s' for copying", path);
250 rollback_lock_file(lk);
251 error("cannot open '%s' for copying", path);
252 errno = save_errno;
253 return -1;
254 }
255 } else if (copy_fd(orig_fd, fd)) {
256 int save_errno = errno;
257
258 if (flags & LOCK_DIE_ON_ERROR)
259 exit(128);
260 rollback_lock_file(lk);
261 errno = save_errno;
262 return -1;
263 }
264 return fd;
265 }
266
267 char *get_locked_file_path(struct lock_file *lk)
268 {
269 if (!lk->active)
270 die("BUG: get_locked_file_path() called for unlocked object");
271 if (lk->filename.len <= LOCK_SUFFIX_LEN)
272 die("BUG: get_locked_file_path() called for malformed lock object");
273 return xmemdupz(lk->filename.buf, lk->filename.len - LOCK_SUFFIX_LEN);
274 }
275
276 int close_lock_file(struct lock_file *lk)
277 {
278 int fd = lk->fd;
279
280 if (fd < 0)
281 return 0;
282
283 lk->fd = -1;
284 if (close(fd)) {
285 int save_errno = errno;
286 rollback_lock_file(lk);
287 errno = save_errno;
288 return -1;
289 }
290 return 0;
291 }
292
293 int reopen_lock_file(struct lock_file *lk)
294 {
295 if (0 <= lk->fd)
296 die(_("BUG: reopen a lockfile that is still open"));
297 if (!lk->active)
298 die(_("BUG: reopen a lockfile that has been committed"));
299 lk->fd = open(lk->filename.buf, O_WRONLY);
300 return lk->fd;
301 }
302
303 int commit_lock_file_to(struct lock_file *lk, const char *path)
304 {
305 if (!lk->active)
306 die("BUG: attempt to commit unlocked object to \"%s\"", path);
307
308 if (close_lock_file(lk))
309 return -1;
310
311 if (rename(lk->filename.buf, path)) {
312 int save_errno = errno;
313 rollback_lock_file(lk);
314 errno = save_errno;
315 return -1;
316 }
317
318 lk->active = 0;
319 strbuf_reset(&lk->filename);
320 return 0;
321 }
322
323 int commit_lock_file(struct lock_file *lk)
324 {
325 static struct strbuf result_file = STRBUF_INIT;
326 int err;
327
328 if (!lk->active)
329 die("BUG: attempt to commit unlocked object");
330
331 if (lk->filename.len <= LOCK_SUFFIX_LEN ||
332 strcmp(lk->filename.buf + lk->filename.len - LOCK_SUFFIX_LEN, LOCK_SUFFIX))
333 die("BUG: lockfile filename corrupt");
334
335 /* remove ".lock": */
336 strbuf_add(&result_file, lk->filename.buf,
337 lk->filename.len - LOCK_SUFFIX_LEN);
338 err = commit_lock_file_to(lk, result_file.buf);
339 strbuf_reset(&result_file);
340 return err;
341 }
342
343 void rollback_lock_file(struct lock_file *lk)
344 {
345 if (!lk->active)
346 return;
347
348 if (!close_lock_file(lk)) {
349 unlink_or_warn(lk->filename.buf);
350 lk->active = 0;
351 strbuf_reset(&lk->filename);
352 }
353 }