1/* 2 * Copyright (c) 2005, Junio C Hamano 3 */ 4 5#include "cache.h" 6#include "lockfile.h" 7 8/* 9 * path = absolute or relative path name 10 * 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. 14 */ 15static void trim_last_path_component(struct strbuf *path) 16{ 17 int i = path->len; 18 19 /* back up past trailing slashes, if any */ 20 while (i && path->buf[i - 1] == '/') 21 i--; 22 23 /* 24 * then go backwards until a slash, or the beginning of the 25 * string 26 */ 27 while (i && path->buf[i - 1] != '/') 28 i--; 29 30 strbuf_setlen(path, i); 31} 32 33 34/* We allow "recursive" symbolic links. Only within reason, though */ 35#define MAXDEPTH 5 36 37/* 38 * path contains a path that might be a symlink. 39 * 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. 43 * 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. 47 */ 48static void resolve_symlink(struct strbuf *path) 49{ 50 int depth = MAXDEPTH; 51 static struct strbuf link = STRBUF_INIT; 52 53 while (depth--) { 54 if (strbuf_readlink(&link, path->buf, path->len) < 0) 55 break; 56 57 if (is_absolute_path(link.buf)) 58 /* absolute path simply replaces p */ 59 strbuf_reset(path); 60 else 61 /* 62 * link is a relative path, so replace the 63 * last element of p with it. 64 */ 65 trim_last_path_component(path); 66 67 strbuf_addbuf(path, &link); 68 } 69 strbuf_reset(&link); 70} 71 72/* Make sure errno contains a meaningful value on error */ 73static int lock_file(struct lock_file *lk, const char *path, int flags) 74{ 75 int fd; 76 struct strbuf filename = STRBUF_INIT; 77 78 strbuf_addstr(&filename, path); 79 if (!(flags & LOCK_NO_DEREF)) 80 resolve_symlink(&filename); 81 82 strbuf_addstr(&filename, LOCK_SUFFIX); 83 fd = create_tempfile(&lk->tempfile, filename.buf); 84 strbuf_release(&filename); 85 return fd; 86} 87 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 */ 102static int lock_file_timeout(struct lock_file *lk, const char *path, 103 int flags, long timeout_ms) 104{ 105 int n = 1; 106 int multiplier = 1; 107 long remaining_ms = 0; 108 static int random_initialized = 0; 109 110 if (timeout_ms == 0) 111 return lock_file(lk, path, flags); 112 113 if (!random_initialized) { 114 srand((unsigned int)getpid()); 115 random_initialized = 1; 116 } 117 118 if (timeout_ms > 0) 119 remaining_ms = timeout_ms; 120 121 while (1) { 122 long backoff_ms, wait_ms; 123 int fd; 124 125 fd = lock_file(lk, path, flags); 126 127 if (fd >= 0) 128 return fd; /* success */ 129 else if (errno != EEXIST) 130 return -1; /* failure other than lock held */ 131 else if (timeout_ms > 0 && remaining_ms <= 0) 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 */ 136 wait_ms = (750 + rand() % 500) * backoff_ms / 1000; 137 sleep_millisec(wait_ms); 138 remaining_ms -= wait_ms; 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 149void unable_to_lock_message(const char *path, int err, struct strbuf *buf) 150{ 151 if (err == EEXIST) { 152 strbuf_addf(buf, _("Unable to create '%s.lock': %s.\n\n" 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."), 158 absolute_path(path), strerror(err)); 159 } else 160 strbuf_addf(buf, _("Unable to create '%s.lock': %s"), 161 absolute_path(path), strerror(err)); 162} 163 164NORETURN void unable_to_lock_die(const char *path, int err) 165{ 166 struct strbuf buf = STRBUF_INIT; 167 168 unable_to_lock_message(path, err, &buf); 169 die("%s", buf.buf); 170} 171 172/* This should return a meaningful errno on failure */ 173int hold_lock_file_for_update_timeout(struct lock_file *lk, const char *path, 174 int flags, long timeout_ms) 175{ 176 int fd = lock_file_timeout(lk, path, flags, timeout_ms); 177 if (fd < 0) { 178 if (flags & LOCK_DIE_ON_ERROR) 179 unable_to_lock_die(path, errno); 180 if (flags & LOCK_REPORT_ON_ERROR) { 181 struct strbuf buf = STRBUF_INIT; 182 unable_to_lock_message(path, errno, &buf); 183 error("%s", buf.buf); 184 strbuf_release(&buf); 185 } 186 } 187 return fd; 188} 189 190char *get_locked_file_path(struct lock_file *lk) 191{ 192 struct strbuf ret = STRBUF_INIT; 193 194 strbuf_addstr(&ret, get_tempfile_path(&lk->tempfile)); 195 if (ret.len <= LOCK_SUFFIX_LEN || 196 strcmp(ret.buf + ret.len - LOCK_SUFFIX_LEN, LOCK_SUFFIX)) 197 die("BUG: get_locked_file_path() called for malformed lock object"); 198 /* remove ".lock": */ 199 strbuf_setlen(&ret, ret.len - LOCK_SUFFIX_LEN); 200 return strbuf_detach(&ret, NULL); 201} 202 203int commit_lock_file(struct lock_file *lk) 204{ 205 char *result_path = get_locked_file_path(lk); 206 207 if (commit_lock_file_to(lk, result_path)) { 208 int save_errno = errno; 209 free(result_path); 210 errno = save_errno; 211 return -1; 212 } 213 free(result_path); 214 return 0; 215}