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(), rollback_lock_file(), a 47 * failed attempt to lock, or a failed close_lock_file()). In this 48 * state: 49 * - active is unset 50 * - filename[0] == '\0' (usually, though there are transitory states 51 * in which this condition doesn't hold). Client code should *not* 52 * rely on this fact! 53 * - fd is -1 54 * - the object is left registered in the lock_file_list, and 55 * on_list is set. 56 */ 57 58static struct lock_file *volatile lock_file_list; 59 60static void remove_lock_file(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 71static void remove_lock_file_on_signal(int signo) 72{ 73 remove_lock_file(); 74 sigchain_pop(signo); 75 raise(signo); 76} 77 78/* 79 * p = absolute or relative path name 80 * 81 * Return a pointer into p showing the beginning of the last path name 82 * element. If p is empty or the root directory ("/"), just return p. 83 */ 84static char *last_path_elm(char *p) 85{ 86 /* r starts pointing to null at the end of the string */ 87 char *r = strchr(p, '\0'); 88 89 if (r == p) 90 return p; /* just return empty string */ 91 92 r--; /* back up to last non-null character */ 93 94 /* back up past trailing slashes, if any */ 95 while (r > p && *r == '/') 96 r--; 97 98 /* 99 * then go backwards until I hit a slash, or the beginning of 100 * the string 101 */ 102 while (r > p && *(r-1) != '/') 103 r--; 104 return r; 105} 106 107 108/* We allow "recursive" symbolic links. Only within reason, though */ 109#define MAXDEPTH 5 110 111/* 112 * p = path that may be a symlink 113 * s = full size of p 114 * 115 * If p is a symlink, attempt to overwrite p with a path to the real 116 * file or directory (which may or may not exist), following a chain of 117 * symlinks if necessary. Otherwise, leave p unmodified. 118 * 119 * This is a best-effort routine. If an error occurs, p will either be 120 * left unmodified or will name a different symlink in a symlink chain 121 * that started with p's initial contents. 122 * 123 * Always returns p. 124 */ 125 126static char *resolve_symlink(char *p, size_t s) 127{ 128 int depth = MAXDEPTH; 129 130 while (depth--) { 131 char link[PATH_MAX]; 132 int link_len = readlink(p, link, sizeof(link)); 133 if (link_len < 0) { 134 /* not a symlink anymore */ 135 return p; 136 } 137 else if (link_len < sizeof(link)) 138 /* readlink() never null-terminates */ 139 link[link_len] = '\0'; 140 else { 141 warning("%s: symlink too long", p); 142 return p; 143 } 144 145 if (is_absolute_path(link)) { 146 /* absolute path simply replaces p */ 147 if (link_len < s) 148 strcpy(p, link); 149 else { 150 warning("%s: symlink too long", p); 151 return p; 152 } 153 } else { 154 /* 155 * link is a relative path, so I must replace the 156 * last element of p with it. 157 */ 158 char *r = (char *)last_path_elm(p); 159 if (r - p + link_len < s) 160 strcpy(r, link); 161 else { 162 warning("%s: symlink too long", p); 163 return p; 164 } 165 } 166 } 167 return p; 168} 169 170/* Make sure errno contains a meaningful value on error */ 171static int lock_file(struct lock_file *lk, const char *path, int flags) 172{ 173 /* 174 * subtract LOCK_SUFFIX_LEN from size to make sure there's 175 * room for adding ".lock" for the lock file name: 176 */ 177 static const size_t max_path_len = sizeof(lk->filename) - 178 LOCK_SUFFIX_LEN; 179 180 if (!lock_file_list) { 181 /* One-time initialization */ 182 sigchain_push_common(remove_lock_file_on_signal); 183 atexit(remove_lock_file); 184 } 185 186 if (lk->active) 187 die("BUG: cannot lock_file(\"%s\") using active struct lock_file", 188 path); 189 if (!lk->on_list) { 190 /* Initialize *lk and add it to lock_file_list: */ 191 lk->fd = -1; 192 lk->active = 0; 193 lk->owner = 0; 194 lk->filename[0] = 0; 195 lk->next = lock_file_list; 196 lock_file_list = lk; 197 lk->on_list = 1; 198 } 199 200 if (strlen(path) >= max_path_len) { 201 errno = ENAMETOOLONG; 202 return -1; 203 } 204 strcpy(lk->filename, path); 205 if (!(flags & LOCK_NODEREF)) 206 resolve_symlink(lk->filename, max_path_len); 207 strcat(lk->filename, LOCK_SUFFIX); 208 lk->fd = open(lk->filename, O_RDWR | O_CREAT | O_EXCL, 0666); 209 if (lk->fd < 0) { 210 lk->filename[0] = 0; 211 return -1; 212 } 213 lk->owner = getpid(); 214 lk->active = 1; 215 if (adjust_shared_perm(lk->filename)) { 216 int save_errno = errno; 217 error("cannot fix permission bits on %s", lk->filename); 218 rollback_lock_file(lk); 219 errno = save_errno; 220 return -1; 221 } 222 return lk->fd; 223} 224 225void unable_to_lock_message(const char *path, int err, struct strbuf *buf) 226{ 227 if (err == EEXIST) { 228 strbuf_addf(buf, "Unable to create '%s.lock': %s.\n\n" 229 "If no other git process is currently running, this probably means a\n" 230 "git process crashed in this repository earlier. Make sure no other git\n" 231 "process is running and remove the file manually to continue.", 232 absolute_path(path), strerror(err)); 233 } else 234 strbuf_addf(buf, "Unable to create '%s.lock': %s", 235 absolute_path(path), strerror(err)); 236} 237 238int unable_to_lock_error(const char *path, int err) 239{ 240 struct strbuf buf = STRBUF_INIT; 241 242 unable_to_lock_message(path, err, &buf); 243 error("%s", buf.buf); 244 strbuf_release(&buf); 245 return -1; 246} 247 248NORETURN void unable_to_lock_die(const char *path, int err) 249{ 250 struct strbuf buf = STRBUF_INIT; 251 252 unable_to_lock_message(path, err, &buf); 253 die("%s", buf.buf); 254} 255 256/* This should return a meaningful errno on failure */ 257int hold_lock_file_for_update(struct lock_file *lk, const char *path, int flags) 258{ 259 int fd = lock_file(lk, path, flags); 260 if (fd < 0 && (flags & LOCK_DIE_ON_ERROR)) 261 unable_to_lock_die(path, errno); 262 return fd; 263} 264 265int hold_lock_file_for_append(struct lock_file *lk, const char *path, int flags) 266{ 267 int fd, orig_fd; 268 269 fd = lock_file(lk, path, flags); 270 if (fd < 0) { 271 if (flags & LOCK_DIE_ON_ERROR) 272 unable_to_lock_die(path, errno); 273 return fd; 274 } 275 276 orig_fd = open(path, O_RDONLY); 277 if (orig_fd < 0) { 278 if (errno != ENOENT) { 279 if (flags & LOCK_DIE_ON_ERROR) 280 die("cannot open '%s' for copying", path); 281 rollback_lock_file(lk); 282 return error("cannot open '%s' for copying", path); 283 } 284 } else if (copy_fd(orig_fd, fd)) { 285 if (flags & LOCK_DIE_ON_ERROR) 286 exit(128); 287 rollback_lock_file(lk); 288 return -1; 289 } 290 return fd; 291} 292 293int close_lock_file(struct lock_file *lk) 294{ 295 int fd = lk->fd; 296 297 if (fd < 0) 298 return 0; 299 300 lk->fd = -1; 301 if (close(fd)) { 302 int save_errno = errno; 303 rollback_lock_file(lk); 304 errno = save_errno; 305 return -1; 306 } 307 return 0; 308} 309 310int reopen_lock_file(struct lock_file *lk) 311{ 312 if (0 <= lk->fd) 313 die(_("BUG: reopen a lockfile that is still open")); 314 if (!lk->active) 315 die(_("BUG: reopen a lockfile that has been committed")); 316 lk->fd = open(lk->filename, O_WRONLY); 317 return lk->fd; 318} 319 320int commit_lock_file(struct lock_file *lk) 321{ 322 char result_file[PATH_MAX]; 323 324 if (!lk->active) 325 die("BUG: attempt to commit unlocked object"); 326 327 if (close_lock_file(lk)) 328 return -1; 329 330 strcpy(result_file, lk->filename); 331 /* remove ".lock": */ 332 result_file[strlen(result_file) - LOCK_SUFFIX_LEN] = 0; 333 334 if (rename(lk->filename, result_file)) { 335 int save_errno = errno; 336 rollback_lock_file(lk); 337 errno = save_errno; 338 return -1; 339 } 340 341 lk->active = 0; 342 lk->filename[0] = 0; 343 return 0; 344} 345 346int hold_locked_index(struct lock_file *lk, int die_on_error) 347{ 348 return hold_lock_file_for_update(lk, get_index_file(), 349 die_on_error 350 ? LOCK_DIE_ON_ERROR 351 : 0); 352} 353 354void rollback_lock_file(struct lock_file *lk) 355{ 356 if (!lk->active) 357 return; 358 359 if (!close_lock_file(lk)) { 360 unlink_or_warn(lk->filename); 361 lk->active = 0; 362 lk->filename[0] = 0; 363 } 364}