Junio C Hamano | 021b6e4 | 2006-06-06 12:51:49 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (c) 2005, Junio C Hamano |
| 3 | */ |
Michael Haggerty | 2db69de | 2015-08-10 11:47:36 +0200 | [diff] [blame] | 4 | |
Junio C Hamano | 021b6e4 | 2006-06-06 12:51:49 -0700 | [diff] [blame] | 5 | #include "cache.h" |
Michael Haggerty | 697cc8e | 2014-10-01 12:28:42 +0200 | [diff] [blame] | 6 | #include "lockfile.h" |
Junio C Hamano | 021b6e4 | 2006-06-06 12:51:49 -0700 | [diff] [blame] | 7 | |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 8 | /* |
Michael Haggerty | 0c0d6e8 | 2014-10-01 12:28:35 +0200 | [diff] [blame] | 9 | * path = absolute or relative path name |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 10 | * |
Michael Haggerty | 0c0d6e8 | 2014-10-01 12:28:35 +0200 | [diff] [blame] | 11 | * Remove the last path name element from path (leaving the preceding |
| 12 | * "/", if any). If path is empty or the root directory ("/"), set |
| 13 | * path to the empty string. |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 14 | */ |
Michael Haggerty | 0c0d6e8 | 2014-10-01 12:28:35 +0200 | [diff] [blame] | 15 | static void trim_last_path_component(struct strbuf *path) |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 16 | { |
Michael Haggerty | 0c0d6e8 | 2014-10-01 12:28:35 +0200 | [diff] [blame] | 17 | int i = path->len; |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 18 | |
| 19 | /* back up past trailing slashes, if any */ |
Michael Haggerty | 0c0d6e8 | 2014-10-01 12:28:35 +0200 | [diff] [blame] | 20 | while (i && path->buf[i - 1] == '/') |
| 21 | i--; |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 22 | |
| 23 | /* |
Michael Haggerty | 0c0d6e8 | 2014-10-01 12:28:35 +0200 | [diff] [blame] | 24 | * then go backwards until a slash, or the beginning of the |
| 25 | * string |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 26 | */ |
Michael Haggerty | 0c0d6e8 | 2014-10-01 12:28:35 +0200 | [diff] [blame] | 27 | while (i && path->buf[i - 1] != '/') |
| 28 | i--; |
| 29 | |
| 30 | strbuf_setlen(path, i); |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 31 | } |
| 32 | |
| 33 | |
| 34 | /* We allow "recursive" symbolic links. Only within reason, though */ |
| 35 | #define MAXDEPTH 5 |
| 36 | |
| 37 | /* |
Michael Haggerty | 6cad805 | 2014-10-01 12:28:34 +0200 | [diff] [blame] | 38 | * path contains a path that might be a symlink. |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 39 | * |
Michael Haggerty | 6cad805 | 2014-10-01 12:28:34 +0200 | [diff] [blame] | 40 | * If path is a symlink, attempt to overwrite it with a path to the |
| 41 | * real file or directory (which may or may not exist), following a |
| 42 | * chain of symlinks if necessary. Otherwise, leave path unmodified. |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 43 | * |
Michael Haggerty | 6cad805 | 2014-10-01 12:28:34 +0200 | [diff] [blame] | 44 | * This is a best-effort routine. If an error occurs, path will |
| 45 | * either be left unmodified or will name a different symlink in a |
| 46 | * symlink chain that started with the original path. |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 47 | */ |
Michael Haggerty | 6cad805 | 2014-10-01 12:28:34 +0200 | [diff] [blame] | 48 | static void resolve_symlink(struct strbuf *path) |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 49 | { |
| 50 | int depth = MAXDEPTH; |
Michael Haggerty | 5025d84 | 2014-10-01 12:28:33 +0200 | [diff] [blame] | 51 | static struct strbuf link = STRBUF_INIT; |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 52 | |
| 53 | while (depth--) { |
Michael Haggerty | 6cad805 | 2014-10-01 12:28:34 +0200 | [diff] [blame] | 54 | if (strbuf_readlink(&link, path->buf, path->len) < 0) |
Michael Haggerty | 5025d84 | 2014-10-01 12:28:33 +0200 | [diff] [blame] | 55 | break; |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 56 | |
Michael Haggerty | 6cad805 | 2014-10-01 12:28:34 +0200 | [diff] [blame] | 57 | if (is_absolute_path(link.buf)) |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 58 | /* absolute path simply replaces p */ |
Michael Haggerty | 6cad805 | 2014-10-01 12:28:34 +0200 | [diff] [blame] | 59 | strbuf_reset(path); |
Michael Haggerty | 0c0d6e8 | 2014-10-01 12:28:35 +0200 | [diff] [blame] | 60 | else |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 61 | /* |
Michael Haggerty | 5025d84 | 2014-10-01 12:28:33 +0200 | [diff] [blame] | 62 | * link is a relative path, so replace the |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 63 | * last element of p with it. |
| 64 | */ |
Michael Haggerty | 0c0d6e8 | 2014-10-01 12:28:35 +0200 | [diff] [blame] | 65 | trim_last_path_component(path); |
Michael Haggerty | 6cad805 | 2014-10-01 12:28:34 +0200 | [diff] [blame] | 66 | |
| 67 | strbuf_addbuf(path, &link); |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 68 | } |
Michael Haggerty | 5025d84 | 2014-10-01 12:28:33 +0200 | [diff] [blame] | 69 | strbuf_reset(&link); |
Bradford C. Smith | 5d5a7a6 | 2007-07-26 13:34:14 -0400 | [diff] [blame] | 70 | } |
| 71 | |
Ronnie Sahlberg | 447ff1b | 2014-06-20 07:42:48 -0700 | [diff] [blame] | 72 | /* Make sure errno contains a meaningful value on error */ |
Taylor Blau | fa3bff2 | 2020-04-27 10:27:58 -0600 | [diff] [blame] | 73 | static int lock_file(struct lock_file *lk, const char *path, int flags, |
| 74 | int mode) |
Junio C Hamano | 021b6e4 | 2006-06-06 12:51:49 -0700 | [diff] [blame] | 75 | { |
Michael Haggerty | 1a9d15d | 2015-08-10 11:47:41 +0200 | [diff] [blame] | 76 | struct strbuf filename = STRBUF_INIT; |
Michael Haggerty | 2fbd4f9 | 2013-07-06 21:48:52 +0200 | [diff] [blame] | 77 | |
Michael Haggerty | 1a9d15d | 2015-08-10 11:47:41 +0200 | [diff] [blame] | 78 | strbuf_addstr(&filename, path); |
| 79 | if (!(flags & LOCK_NO_DEREF)) |
| 80 | resolve_symlink(&filename); |
Michael Haggerty | 04e57d4 | 2014-10-01 12:28:13 +0200 | [diff] [blame] | 81 | |
Michael Haggerty | 1a9d15d | 2015-08-10 11:47:41 +0200 | [diff] [blame] | 82 | strbuf_addstr(&filename, LOCK_SUFFIX); |
Taylor Blau | fa3bff2 | 2020-04-27 10:27:58 -0600 | [diff] [blame] | 83 | lk->tempfile = create_tempfile_mode(filename.buf, mode); |
Michael Haggerty | 1a9d15d | 2015-08-10 11:47:41 +0200 | [diff] [blame] | 84 | strbuf_release(&filename); |
Jeff King | 076aa2c | 2017-09-05 08:15:08 -0400 | [diff] [blame] | 85 | return lk->tempfile ? lk->tempfile->fd : -1; |
Junio C Hamano | 021b6e4 | 2006-06-06 12:51:49 -0700 | [diff] [blame] | 86 | } |
| 87 | |
Michael Haggerty | 044b6a9 | 2015-05-11 12:35:25 +0200 | [diff] [blame] | 88 | /* |
| 89 | * Constants defining the gaps between attempts to lock a file. The |
| 90 | * first backoff period is approximately INITIAL_BACKOFF_MS |
| 91 | * milliseconds. The longest backoff period is approximately |
| 92 | * (BACKOFF_MAX_MULTIPLIER * INITIAL_BACKOFF_MS) milliseconds. |
| 93 | */ |
| 94 | #define INITIAL_BACKOFF_MS 1L |
| 95 | #define BACKOFF_MAX_MULTIPLIER 1000 |
| 96 | |
| 97 | /* |
| 98 | * Try locking path, retrying with quadratic backoff for at least |
| 99 | * timeout_ms milliseconds. If timeout_ms is 0, try locking the file |
| 100 | * exactly once. If timeout_ms is -1, try indefinitely. |
| 101 | */ |
| 102 | static int lock_file_timeout(struct lock_file *lk, const char *path, |
Taylor Blau | fa3bff2 | 2020-04-27 10:27:58 -0600 | [diff] [blame] | 103 | int flags, long timeout_ms, int mode) |
Michael Haggerty | 044b6a9 | 2015-05-11 12:35:25 +0200 | [diff] [blame] | 104 | { |
| 105 | int n = 1; |
| 106 | int multiplier = 1; |
Johannes Sixt | a8a1775 | 2015-06-05 21:45:06 +0200 | [diff] [blame] | 107 | long remaining_ms = 0; |
Michael Haggerty | 044b6a9 | 2015-05-11 12:35:25 +0200 | [diff] [blame] | 108 | static int random_initialized = 0; |
| 109 | |
| 110 | if (timeout_ms == 0) |
Taylor Blau | fa3bff2 | 2020-04-27 10:27:58 -0600 | [diff] [blame] | 111 | return lock_file(lk, path, flags, mode); |
Michael Haggerty | 044b6a9 | 2015-05-11 12:35:25 +0200 | [diff] [blame] | 112 | |
| 113 | if (!random_initialized) { |
Johannes Sixt | 1e9676e | 2015-06-05 21:45:04 +0200 | [diff] [blame] | 114 | srand((unsigned int)getpid()); |
Michael Haggerty | 044b6a9 | 2015-05-11 12:35:25 +0200 | [diff] [blame] | 115 | random_initialized = 1; |
| 116 | } |
| 117 | |
Johannes Sixt | a8a1775 | 2015-06-05 21:45:06 +0200 | [diff] [blame] | 118 | if (timeout_ms > 0) |
| 119 | remaining_ms = timeout_ms; |
Michael Haggerty | 044b6a9 | 2015-05-11 12:35:25 +0200 | [diff] [blame] | 120 | |
| 121 | while (1) { |
Johannes Sixt | a8a1775 | 2015-06-05 21:45:06 +0200 | [diff] [blame] | 122 | long backoff_ms, wait_ms; |
Michael Haggerty | 044b6a9 | 2015-05-11 12:35:25 +0200 | [diff] [blame] | 123 | int fd; |
| 124 | |
Taylor Blau | fa3bff2 | 2020-04-27 10:27:58 -0600 | [diff] [blame] | 125 | fd = lock_file(lk, path, flags, mode); |
Michael Haggerty | 044b6a9 | 2015-05-11 12:35:25 +0200 | [diff] [blame] | 126 | |
| 127 | if (fd >= 0) |
| 128 | return fd; /* success */ |
| 129 | else if (errno != EEXIST) |
| 130 | return -1; /* failure other than lock held */ |
Johannes Sixt | a8a1775 | 2015-06-05 21:45:06 +0200 | [diff] [blame] | 131 | else if (timeout_ms > 0 && remaining_ms <= 0) |
Michael Haggerty | 044b6a9 | 2015-05-11 12:35:25 +0200 | [diff] [blame] | 132 | return -1; /* failure due to timeout */ |
| 133 | |
| 134 | backoff_ms = multiplier * INITIAL_BACKOFF_MS; |
| 135 | /* back off for between 0.75*backoff_ms and 1.25*backoff_ms */ |
Johannes Sixt | a8a1775 | 2015-06-05 21:45:06 +0200 | [diff] [blame] | 136 | wait_ms = (750 + rand() % 500) * backoff_ms / 1000; |
Johannes Sixt | 30f8160 | 2015-06-05 21:45:07 +0200 | [diff] [blame] | 137 | sleep_millisec(wait_ms); |
Johannes Sixt | a8a1775 | 2015-06-05 21:45:06 +0200 | [diff] [blame] | 138 | remaining_ms -= wait_ms; |
Michael Haggerty | 044b6a9 | 2015-05-11 12:35:25 +0200 | [diff] [blame] | 139 | |
| 140 | /* Recursion: (n+1)^2 = n^2 + 2n + 1 */ |
| 141 | multiplier += 2*n + 1; |
| 142 | if (multiplier > BACKOFF_MAX_MULTIPLIER) |
| 143 | multiplier = BACKOFF_MAX_MULTIPLIER; |
| 144 | else |
| 145 | n++; |
| 146 | } |
| 147 | } |
| 148 | |
Ronnie Sahlberg | 6af926e | 2014-06-20 07:42:47 -0700 | [diff] [blame] | 149 | void unable_to_lock_message(const char *path, int err, struct strbuf *buf) |
Matthieu Moy | e43a6fd | 2009-02-19 13:54:18 +0100 | [diff] [blame] | 150 | { |
John Tapsell | bdfd739 | 2009-03-04 15:00:44 +0000 | [diff] [blame] | 151 | if (err == EEXIST) { |
Matthieu Moy | 3030c29 | 2016-03-01 18:04:09 +0100 | [diff] [blame] | 152 | strbuf_addf(buf, _("Unable to create '%s.lock': %s.\n\n" |
Matthieu Moy | aed7480 | 2016-03-01 18:04:10 +0100 | [diff] [blame] | 153 | "Another git process seems to be running in this repository, e.g.\n" |
| 154 | "an editor opened by 'git commit'. Please make sure all processes\n" |
| 155 | "are terminated then try again. If it still fails, a git process\n" |
| 156 | "may have crashed in this repository earlier:\n" |
| 157 | "remove the file manually to continue."), |
Carlos Martín Nieto | e2a57aa | 2011-03-17 12:26:46 +0100 | [diff] [blame] | 158 | absolute_path(path), strerror(err)); |
Miklos Vajna | 1b018fd | 2009-09-27 01:15:09 +0200 | [diff] [blame] | 159 | } else |
Matthieu Moy | 3030c29 | 2016-03-01 18:04:09 +0100 | [diff] [blame] | 160 | strbuf_addf(buf, _("Unable to create '%s.lock': %s"), |
Carlos Martín Nieto | e2a57aa | 2011-03-17 12:26:46 +0100 | [diff] [blame] | 161 | absolute_path(path), strerror(err)); |
Miklos Vajna | 1b018fd | 2009-09-27 01:15:09 +0200 | [diff] [blame] | 162 | } |
| 163 | |
Michael Haggerty | e197c21 | 2014-10-01 12:28:05 +0200 | [diff] [blame] | 164 | NORETURN void unable_to_lock_die(const char *path, int err) |
Miklos Vajna | 1b018fd | 2009-09-27 01:15:09 +0200 | [diff] [blame] | 165 | { |
Ronnie Sahlberg | 6af926e | 2014-06-20 07:42:47 -0700 | [diff] [blame] | 166 | struct strbuf buf = STRBUF_INIT; |
| 167 | |
| 168 | unable_to_lock_message(path, err, &buf); |
| 169 | die("%s", buf.buf); |
Matthieu Moy | e43a6fd | 2009-02-19 13:54:18 +0100 | [diff] [blame] | 170 | } |
| 171 | |
Ronnie Sahlberg | 447ff1b | 2014-06-20 07:42:48 -0700 | [diff] [blame] | 172 | /* This should return a meaningful errno on failure */ |
Taylor Blau | fa3bff2 | 2020-04-27 10:27:58 -0600 | [diff] [blame] | 173 | int hold_lock_file_for_update_timeout_mode(struct lock_file *lk, |
| 174 | const char *path, int flags, |
| 175 | long timeout_ms, int mode) |
Junio C Hamano | 40aaae8 | 2006-08-12 01:03:47 -0700 | [diff] [blame] | 176 | { |
Taylor Blau | fa3bff2 | 2020-04-27 10:27:58 -0600 | [diff] [blame] | 177 | int fd = lock_file_timeout(lk, path, flags, timeout_ms, mode); |
Junio C Hamano | 3f061bf | 2016-12-07 10:56:26 -0800 | [diff] [blame] | 178 | if (fd < 0) { |
| 179 | if (flags & LOCK_DIE_ON_ERROR) |
| 180 | unable_to_lock_die(path, errno); |
| 181 | if (flags & LOCK_REPORT_ON_ERROR) { |
| 182 | struct strbuf buf = STRBUF_INIT; |
| 183 | unable_to_lock_message(path, errno, &buf); |
| 184 | error("%s", buf.buf); |
| 185 | strbuf_release(&buf); |
| 186 | } |
| 187 | } |
Junio C Hamano | 40aaae8 | 2006-08-12 01:03:47 -0700 | [diff] [blame] | 188 | return fd; |
| 189 | } |
| 190 | |
Michael Haggerty | ec38b4e | 2014-10-01 12:28:39 +0200 | [diff] [blame] | 191 | char *get_locked_file_path(struct lock_file *lk) |
| 192 | { |
Michael Haggerty | 1a9d15d | 2015-08-10 11:47:41 +0200 | [diff] [blame] | 193 | struct strbuf ret = STRBUF_INIT; |
| 194 | |
Jeff King | 076aa2c | 2017-09-05 08:15:08 -0400 | [diff] [blame] | 195 | strbuf_addstr(&ret, get_tempfile_path(lk->tempfile)); |
Michael Haggerty | 1a9d15d | 2015-08-10 11:47:41 +0200 | [diff] [blame] | 196 | if (ret.len <= LOCK_SUFFIX_LEN || |
| 197 | strcmp(ret.buf + ret.len - LOCK_SUFFIX_LEN, LOCK_SUFFIX)) |
Johannes Schindelin | 033abf9 | 2018-05-02 11:38:39 +0200 | [diff] [blame] | 198 | BUG("get_locked_file_path() called for malformed lock object"); |
Michael Haggerty | 9c77381 | 2015-08-10 11:47:40 +0200 | [diff] [blame] | 199 | /* remove ".lock": */ |
Michael Haggerty | 1a9d15d | 2015-08-10 11:47:41 +0200 | [diff] [blame] | 200 | strbuf_setlen(&ret, ret.len - LOCK_SUFFIX_LEN); |
| 201 | return strbuf_detach(&ret, NULL); |
Junio C Hamano | 021b6e4 | 2006-06-06 12:51:49 -0700 | [diff] [blame] | 202 | } |
| 203 | |
Junio C Hamano | 021b6e4 | 2006-06-06 12:51:49 -0700 | [diff] [blame] | 204 | int commit_lock_file(struct lock_file *lk) |
| 205 | { |
Michael Haggerty | 9c77381 | 2015-08-10 11:47:40 +0200 | [diff] [blame] | 206 | char *result_path = get_locked_file_path(lk); |
Junio C Hamano | 021b6e4 | 2006-06-06 12:51:49 -0700 | [diff] [blame] | 207 | |
Michael Haggerty | 9c77381 | 2015-08-10 11:47:40 +0200 | [diff] [blame] | 208 | if (commit_lock_file_to(lk, result_path)) { |
| 209 | int save_errno = errno; |
| 210 | free(result_path); |
| 211 | errno = save_errno; |
| 212 | return -1; |
Johannes Schindelin | 4723ee9 | 2007-11-13 21:05:03 +0100 | [diff] [blame] | 213 | } |
Michael Haggerty | 9c77381 | 2015-08-10 11:47:40 +0200 | [diff] [blame] | 214 | free(result_path); |
| 215 | return 0; |
Junio C Hamano | 021b6e4 | 2006-06-06 12:51:49 -0700 | [diff] [blame] | 216 | } |