git.oblomov.eu Git - git/blob - 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                         if (flags & LOCK_DIE_ON_ERROR)
 247                                 die("cannot open '%s' for copying", path);
 248                         rollback_lock_file(lk);
 249                         return error("cannot open '%s' for copying", path);
 250                 }
 251         } else if (copy_fd(orig_fd, fd)) {
 252                 if (flags & LOCK_DIE_ON_ERROR)
 253                         exit(128);
 254                 rollback_lock_file(lk);
 255                 return -1;
 256         }
 257         return fd;
 258 }
 259
 260 char *get_locked_file_path(struct lock_file *lk)
 261 {
 262         if (!lk->active)
 263                 die("BUG: get_locked_file_path() called for unlocked object");
 264         if (lk->filename.len <= LOCK_SUFFIX_LEN)
 265                 die("BUG: get_locked_file_path() called for malformed lock object");
 266         return xmemdupz(lk->filename.buf, lk->filename.len - LOCK_SUFFIX_LEN);
 267 }
 268
 269 int close_lock_file(struct lock_file *lk)
 270 {
 271         int fd = lk->fd;
 272
 273         if (fd < 0)
 274                 return 0;
 275
 276         lk->fd = -1;
 277         if (close(fd)) {
 278                 int save_errno = errno;
 279                 rollback_lock_file(lk);
 280                 errno = save_errno;
 281                 return -1;
 282         }
 283         return 0;
 284 }
 285
 286 int reopen_lock_file(struct lock_file *lk)
 287 {
 288         if (0 <= lk->fd)
 289                 die(_("BUG: reopen a lockfile that is still open"));
 290         if (!lk->active)
 291                 die(_("BUG: reopen a lockfile that has been committed"));
 292         lk->fd = open(lk->filename.buf, O_WRONLY);
 293         return lk->fd;
 294 }
 295
 296 int commit_lock_file_to(struct lock_file *lk, const char *path)
 297 {
 298         if (!lk->active)
 299                 die("BUG: attempt to commit unlocked object to \"%s\"", path);
 300
 301         if (close_lock_file(lk))
 302                 return -1;
 303
 304         if (rename(lk->filename.buf, path)) {
 305                 int save_errno = errno;
 306                 rollback_lock_file(lk);
 307                 errno = save_errno;
 308                 return -1;
 309         }
 310
 311         lk->active = 0;
 312         strbuf_reset(&lk->filename);
 313         return 0;
 314 }
 315
 316 int commit_lock_file(struct lock_file *lk)
 317 {
 318         static struct strbuf result_file = STRBUF_INIT;
 319         int err;
 320
 321         if (!lk->active)
 322                 die("BUG: attempt to commit unlocked object");
 323
 324         if (lk->filename.len <= LOCK_SUFFIX_LEN ||
 325             strcmp(lk->filename.buf + lk->filename.len - LOCK_SUFFIX_LEN, LOCK_SUFFIX))
 326                 die("BUG: lockfile filename corrupt");
 327
 328         /* remove ".lock": */
 329         strbuf_add(&result_file, lk->filename.buf,
 330                    lk->filename.len - LOCK_SUFFIX_LEN);
 331         err = commit_lock_file_to(lk, result_file.buf);
 332         strbuf_reset(&result_file);
 333         return err;
 334 }
 335
 336 int hold_locked_index(struct lock_file *lk, int die_on_error)
 337 {
 338         return hold_lock_file_for_update(lk, get_index_file(),
 339                                          die_on_error
 340                                          ? LOCK_DIE_ON_ERROR
 341                                          : 0);
 342 }
 343
 344 void rollback_lock_file(struct lock_file *lk)
 345 {
 346         if (!lk->active)
 347                 return;
 348
 349         if (!close_lock_file(lk)) {
 350                 unlink_or_warn(lk->filename.buf);
 351                 lk->active = 0;
 352                 strbuf_reset(&lk->filename);
 353         }
 354 }