3f5b699cf740b0d3926be5242e3ab470d55edcd9
1/*
2 * Copyright (c) 2005, Junio C Hamano
3 */
4#include "cache.h"
5#include "lockfile.h"
6#include "sigchain.h"
7
8static struct lock_file *volatile lock_file_list;
9
10static void remove_lock_files(int skip_fclose)
11{
12 pid_t me = getpid();
13
14 while (lock_file_list) {
15 if (lock_file_list->owner == me) {
16 /* fclose() is not safe to call in a signal handler */
17 if (skip_fclose)
18 lock_file_list->fp = NULL;
19 rollback_lock_file(lock_file_list);
20 }
21 lock_file_list = lock_file_list->next;
22 }
23}
24
25static void remove_lock_files_on_exit(void)
26{
27 remove_lock_files(0);
28}
29
30static void remove_lock_files_on_signal(int signo)
31{
32 remove_lock_files(1);
33 sigchain_pop(signo);
34 raise(signo);
35}
36
37/*
38 * path = absolute or relative path name
39 *
40 * Remove the last path name element from path (leaving the preceding
41 * "/", if any). If path is empty or the root directory ("/"), set
42 * path to the empty string.
43 */
44static void trim_last_path_component(struct strbuf *path)
45{
46 int i = path->len;
47
48 /* back up past trailing slashes, if any */
49 while (i && path->buf[i - 1] == '/')
50 i--;
51
52 /*
53 * then go backwards until a slash, or the beginning of the
54 * string
55 */
56 while (i && path->buf[i - 1] != '/')
57 i--;
58
59 strbuf_setlen(path, i);
60}
61
62
63/* We allow "recursive" symbolic links. Only within reason, though */
64#define MAXDEPTH 5
65
66/*
67 * path contains a path that might be a symlink.
68 *
69 * If path is a symlink, attempt to overwrite it with a path to the
70 * real file or directory (which may or may not exist), following a
71 * chain of symlinks if necessary. Otherwise, leave path unmodified.
72 *
73 * This is a best-effort routine. If an error occurs, path will
74 * either be left unmodified or will name a different symlink in a
75 * symlink chain that started with the original path.
76 */
77static void resolve_symlink(struct strbuf *path)
78{
79 int depth = MAXDEPTH;
80 static struct strbuf link = STRBUF_INIT;
81
82 while (depth--) {
83 if (strbuf_readlink(&link, path->buf, path->len) < 0)
84 break;
85
86 if (is_absolute_path(link.buf))
87 /* absolute path simply replaces p */
88 strbuf_reset(path);
89 else
90 /*
91 * link is a relative path, so replace the
92 * last element of p with it.
93 */
94 trim_last_path_component(path);
95
96 strbuf_addbuf(path, &link);
97 }
98 strbuf_reset(&link);
99}
100
101/* Make sure errno contains a meaningful value on error */
102static int lock_file(struct lock_file *lk, const char *path, int flags)
103{
104 size_t pathlen = strlen(path);
105
106 if (!lock_file_list) {
107 /* One-time initialization */
108 sigchain_push_common(remove_lock_files_on_signal);
109 atexit(remove_lock_files_on_exit);
110 }
111
112 if (lk->active)
113 die("BUG: cannot lock_file(\"%s\") using active struct lock_file",
114 path);
115 if (!lk->on_list) {
116 /* Initialize *lk and add it to lock_file_list: */
117 lk->fd = -1;
118 lk->fp = NULL;
119 lk->active = 0;
120 lk->owner = 0;
121 strbuf_init(&lk->filename, pathlen + LOCK_SUFFIX_LEN);
122 lk->next = lock_file_list;
123 lock_file_list = lk;
124 lk->on_list = 1;
125 } else if (lk->filename.len) {
126 /* This shouldn't happen, but better safe than sorry. */
127 die("BUG: lock_file(\"%s\") called with improperly-reset lock_file object",
128 path);
129 }
130
131 if (flags & LOCK_NO_DEREF) {
132 strbuf_add_absolute_path(&lk->filename, path);
133 } else {
134 struct strbuf resolved_path = STRBUF_INIT;
135
136 strbuf_add(&resolved_path, path, pathlen);
137 resolve_symlink(&resolved_path);
138 strbuf_add_absolute_path(&lk->filename, resolved_path.buf);
139 strbuf_release(&resolved_path);
140 }
141
142 strbuf_addstr(&lk->filename, LOCK_SUFFIX);
143 lk->fd = open(lk->filename.buf, O_RDWR | O_CREAT | O_EXCL, 0666);
144 if (lk->fd < 0) {
145 strbuf_reset(&lk->filename);
146 return -1;
147 }
148 lk->owner = getpid();
149 lk->active = 1;
150 if (adjust_shared_perm(lk->filename.buf)) {
151 int save_errno = errno;
152 error("cannot fix permission bits on %s", lk->filename.buf);
153 rollback_lock_file(lk);
154 errno = save_errno;
155 return -1;
156 }
157 return lk->fd;
158}
159
160static int sleep_microseconds(long us)
161{
162 struct timeval tv;
163 tv.tv_sec = 0;
164 tv.tv_usec = us;
165 return select(0, NULL, NULL, NULL, &tv);
166}
167
168/*
169 * Constants defining the gaps between attempts to lock a file. The
170 * first backoff period is approximately INITIAL_BACKOFF_MS
171 * milliseconds. The longest backoff period is approximately
172 * (BACKOFF_MAX_MULTIPLIER * INITIAL_BACKOFF_MS) milliseconds.
173 */
174#define INITIAL_BACKOFF_MS 1L
175#define BACKOFF_MAX_MULTIPLIER 1000
176
177/*
178 * Try locking path, retrying with quadratic backoff for at least
179 * timeout_ms milliseconds. If timeout_ms is 0, try locking the file
180 * exactly once. If timeout_ms is -1, try indefinitely.
181 */
182static int lock_file_timeout(struct lock_file *lk, const char *path,
183 int flags, long timeout_ms)
184{
185 int n = 1;
186 int multiplier = 1;
187 long remaining_ms = 0;
188 static int random_initialized = 0;
189
190 if (timeout_ms == 0)
191 return lock_file(lk, path, flags);
192
193 if (!random_initialized) {
194 srand((unsigned int)getpid());
195 random_initialized = 1;
196 }
197
198 if (timeout_ms > 0)
199 remaining_ms = timeout_ms;
200
201 while (1) {
202 long backoff_ms, wait_ms;
203 int fd;
204
205 fd = lock_file(lk, path, flags);
206
207 if (fd >= 0)
208 return fd; /* success */
209 else if (errno != EEXIST)
210 return -1; /* failure other than lock held */
211 else if (timeout_ms > 0 && remaining_ms <= 0)
212 return -1; /* failure due to timeout */
213
214 backoff_ms = multiplier * INITIAL_BACKOFF_MS;
215 /* back off for between 0.75*backoff_ms and 1.25*backoff_ms */
216 wait_ms = (750 + rand() % 500) * backoff_ms / 1000;
217 sleep_microseconds(wait_ms*1000);
218 remaining_ms -= wait_ms;
219
220 /* Recursion: (n+1)^2 = n^2 + 2n + 1 */
221 multiplier += 2*n + 1;
222 if (multiplier > BACKOFF_MAX_MULTIPLIER)
223 multiplier = BACKOFF_MAX_MULTIPLIER;
224 else
225 n++;
226 }
227}
228
229void unable_to_lock_message(const char *path, int err, struct strbuf *buf)
230{
231 if (err == EEXIST) {
232 strbuf_addf(buf, "Unable to create '%s.lock': %s.\n\n"
233 "If no other git process is currently running, this probably means a\n"
234 "git process crashed in this repository earlier. Make sure no other git\n"
235 "process is running and remove the file manually to continue.",
236 absolute_path(path), strerror(err));
237 } else
238 strbuf_addf(buf, "Unable to create '%s.lock': %s",
239 absolute_path(path), strerror(err));
240}
241
242NORETURN void unable_to_lock_die(const char *path, int err)
243{
244 struct strbuf buf = STRBUF_INIT;
245
246 unable_to_lock_message(path, err, &buf);
247 die("%s", buf.buf);
248}
249
250/* This should return a meaningful errno on failure */
251int hold_lock_file_for_update_timeout(struct lock_file *lk, const char *path,
252 int flags, long timeout_ms)
253{
254 int fd = lock_file_timeout(lk, path, flags, timeout_ms);
255 if (fd < 0 && (flags & LOCK_DIE_ON_ERROR))
256 unable_to_lock_die(path, errno);
257 return fd;
258}
259
260int hold_lock_file_for_append(struct lock_file *lk, const char *path, int flags)
261{
262 int fd, orig_fd;
263
264 fd = lock_file(lk, path, flags);
265 if (fd < 0) {
266 if (flags & LOCK_DIE_ON_ERROR)
267 unable_to_lock_die(path, errno);
268 return fd;
269 }
270
271 orig_fd = open(path, O_RDONLY);
272 if (orig_fd < 0) {
273 if (errno != ENOENT) {
274 int save_errno = errno;
275
276 if (flags & LOCK_DIE_ON_ERROR)
277 die("cannot open '%s' for copying", path);
278 rollback_lock_file(lk);
279 error("cannot open '%s' for copying", path);
280 errno = save_errno;
281 return -1;
282 }
283 } else if (copy_fd(orig_fd, fd)) {
284 int save_errno = errno;
285
286 if (flags & LOCK_DIE_ON_ERROR)
287 exit(128);
288 close(orig_fd);
289 rollback_lock_file(lk);
290 errno = save_errno;
291 return -1;
292 } else {
293 close(orig_fd);
294 }
295 return fd;
296}
297
298FILE *fdopen_lock_file(struct lock_file *lk, const char *mode)
299{
300 if (!lk->active)
301 die("BUG: fdopen_lock_file() called for unlocked object");
302 if (lk->fp)
303 die("BUG: fdopen_lock_file() called twice for file '%s'", lk->filename.buf);
304
305 lk->fp = fdopen(lk->fd, mode);
306 return lk->fp;
307}
308
309char *get_locked_file_path(struct lock_file *lk)
310{
311 if (!lk->active)
312 die("BUG: get_locked_file_path() called for unlocked object");
313 if (lk->filename.len <= LOCK_SUFFIX_LEN)
314 die("BUG: get_locked_file_path() called for malformed lock object");
315 return xmemdupz(lk->filename.buf, lk->filename.len - LOCK_SUFFIX_LEN);
316}
317
318int close_lock_file(struct lock_file *lk)
319{
320 int fd = lk->fd;
321 FILE *fp = lk->fp;
322 int err;
323
324 if (fd < 0)
325 return 0;
326
327 lk->fd = -1;
328 if (fp) {
329 lk->fp = NULL;
330
331 /*
332 * Note: no short-circuiting here; we want to fclose()
333 * in any case!
334 */
335 err = ferror(fp) | fclose(fp);
336 } else {
337 err = close(fd);
338 }
339
340 if (err) {
341 int save_errno = errno;
342 rollback_lock_file(lk);
343 errno = save_errno;
344 return -1;
345 }
346
347 return 0;
348}
349
350int reopen_lock_file(struct lock_file *lk)
351{
352 if (0 <= lk->fd)
353 die(_("BUG: reopen a lockfile that is still open"));
354 if (!lk->active)
355 die(_("BUG: reopen a lockfile that has been committed"));
356 lk->fd = open(lk->filename.buf, O_WRONLY);
357 return lk->fd;
358}
359
360int commit_lock_file_to(struct lock_file *lk, const char *path)
361{
362 if (!lk->active)
363 die("BUG: attempt to commit unlocked object to \"%s\"", path);
364
365 if (close_lock_file(lk))
366 return -1;
367
368 if (rename(lk->filename.buf, path)) {
369 int save_errno = errno;
370 rollback_lock_file(lk);
371 errno = save_errno;
372 return -1;
373 }
374
375 lk->active = 0;
376 strbuf_reset(&lk->filename);
377 return 0;
378}
379
380int commit_lock_file(struct lock_file *lk)
381{
382 static struct strbuf result_file = STRBUF_INIT;
383 int err;
384
385 if (!lk->active)
386 die("BUG: attempt to commit unlocked object");
387
388 if (lk->filename.len <= LOCK_SUFFIX_LEN ||
389 strcmp(lk->filename.buf + lk->filename.len - LOCK_SUFFIX_LEN, LOCK_SUFFIX))
390 die("BUG: lockfile filename corrupt");
391
392 /* remove ".lock": */
393 strbuf_add(&result_file, lk->filename.buf,
394 lk->filename.len - LOCK_SUFFIX_LEN);
395 err = commit_lock_file_to(lk, result_file.buf);
396 strbuf_reset(&result_file);
397 return err;
398}
399
400void rollback_lock_file(struct lock_file *lk)
401{
402 if (!lk->active)
403 return;
404
405 if (!close_lock_file(lk)) {
406 unlink_or_warn(lk->filename.buf);
407 lk->active = 0;
408 strbuf_reset(&lk->filename);
409 }
410}