5f5bcfffbe25b6145f1683a989399f44880b3d5d
   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 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
  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 * path contains a path that might be a symlink.
 113 *
 114 * If path is a symlink, attempt to overwrite it with a path to the
 115 * real file or directory (which may or may not exist), following a
 116 * chain of symlinks if necessary.  Otherwise, leave path unmodified.
 117 *
 118 * This is a best-effort routine.  If an error occurs, path will
 119 * either be left unmodified or will name a different symlink in a
 120 * symlink chain that started with the original path.
 121 */
 122static void resolve_symlink(struct strbuf *path)
 123{
 124        int depth = MAXDEPTH;
 125        static struct strbuf link = STRBUF_INIT;
 126
 127        while (depth--) {
 128                if (strbuf_readlink(&link, path->buf, path->len) < 0)
 129                        break;
 130
 131                if (is_absolute_path(link.buf))
 132                        /* absolute path simply replaces p */
 133                        strbuf_reset(path);
 134                else {
 135                        /*
 136                         * link is a relative path, so replace the
 137                         * last element of p with it.
 138                         */
 139                        char *r = last_path_elm(path->buf);
 140                        strbuf_setlen(path, r - path->buf);
 141                }
 142
 143                strbuf_addbuf(path, &link);
 144        }
 145        strbuf_reset(&link);
 146}
 147
 148/* Make sure errno contains a meaningful value on error */
 149static int lock_file(struct lock_file *lk, const char *path, int flags)
 150{
 151        size_t pathlen = strlen(path);
 152
 153        if (!lock_file_list) {
 154                /* One-time initialization */
 155                sigchain_push_common(remove_lock_file_on_signal);
 156                atexit(remove_lock_file);
 157        }
 158
 159        if (lk->active)
 160                die("BUG: cannot lock_file(\"%s\") using active struct lock_file",
 161                    path);
 162        if (!lk->on_list) {
 163                /* Initialize *lk and add it to lock_file_list: */
 164                lk->fd = -1;
 165                lk->active = 0;
 166                lk->owner = 0;
 167                strbuf_init(&lk->filename, pathlen + LOCK_SUFFIX_LEN);
 168                lk->next = lock_file_list;
 169                lock_file_list = lk;
 170                lk->on_list = 1;
 171        } else if (lk->filename.len) {
 172                /* This shouldn't happen, but better safe than sorry. */
 173                die("BUG: lock_file(\"%s\") called with improperly-reset lock_file object",
 174                    path);
 175        }
 176
 177        strbuf_add(&lk->filename, path, pathlen);
 178        if (!(flags & LOCK_NODEREF))
 179                resolve_symlink(&lk->filename);
 180        strbuf_addstr(&lk->filename, LOCK_SUFFIX);
 181        lk->fd = open(lk->filename.buf, O_RDWR | O_CREAT | O_EXCL, 0666);
 182        if (lk->fd < 0) {
 183                strbuf_reset(&lk->filename);
 184                return -1;
 185        }
 186        lk->owner = getpid();
 187        lk->active = 1;
 188        if (adjust_shared_perm(lk->filename.buf)) {
 189                int save_errno = errno;
 190                error("cannot fix permission bits on %s", lk->filename.buf);
 191                rollback_lock_file(lk);
 192                errno = save_errno;
 193                return -1;
 194        }
 195        return lk->fd;
 196}
 197
 198void unable_to_lock_message(const char *path, int err, struct strbuf *buf)
 199{
 200        if (err == EEXIST) {
 201                strbuf_addf(buf, "Unable to create '%s.lock': %s.\n\n"
 202                    "If no other git process is currently running, this probably means a\n"
 203                    "git process crashed in this repository earlier. Make sure no other git\n"
 204                    "process is running and remove the file manually to continue.",
 205                            absolute_path(path), strerror(err));
 206        } else
 207                strbuf_addf(buf, "Unable to create '%s.lock': %s",
 208                            absolute_path(path), strerror(err));
 209}
 210
 211int unable_to_lock_error(const char *path, int err)
 212{
 213        struct strbuf buf = STRBUF_INIT;
 214
 215        unable_to_lock_message(path, err, &buf);
 216        error("%s", buf.buf);
 217        strbuf_release(&buf);
 218        return -1;
 219}
 220
 221NORETURN void unable_to_lock_die(const char *path, int err)
 222{
 223        struct strbuf buf = STRBUF_INIT;
 224
 225        unable_to_lock_message(path, err, &buf);
 226        die("%s", buf.buf);
 227}
 228
 229/* This should return a meaningful errno on failure */
 230int hold_lock_file_for_update(struct lock_file *lk, const char *path, int flags)
 231{
 232        int fd = lock_file(lk, path, flags);
 233        if (fd < 0 && (flags & LOCK_DIE_ON_ERROR))
 234                unable_to_lock_die(path, errno);
 235        return fd;
 236}
 237
 238int hold_lock_file_for_append(struct lock_file *lk, const char *path, int flags)
 239{
 240        int fd, orig_fd;
 241
 242        fd = lock_file(lk, path, flags);
 243        if (fd < 0) {
 244                if (flags & LOCK_DIE_ON_ERROR)
 245                        unable_to_lock_die(path, errno);
 246                return fd;
 247        }
 248
 249        orig_fd = open(path, O_RDONLY);
 250        if (orig_fd < 0) {
 251                if (errno != ENOENT) {
 252                        if (flags & LOCK_DIE_ON_ERROR)
 253                                die("cannot open '%s' for copying", path);
 254                        rollback_lock_file(lk);
 255                        return error("cannot open '%s' for copying", path);
 256                }
 257        } else if (copy_fd(orig_fd, fd)) {
 258                if (flags & LOCK_DIE_ON_ERROR)
 259                        exit(128);
 260                rollback_lock_file(lk);
 261                return -1;
 262        }
 263        return fd;
 264}
 265
 266int close_lock_file(struct lock_file *lk)
 267{
 268        int fd = lk->fd;
 269
 270        if (fd < 0)
 271                return 0;
 272
 273        lk->fd = -1;
 274        if (close(fd)) {
 275                int save_errno = errno;
 276                rollback_lock_file(lk);
 277                errno = save_errno;
 278                return -1;
 279        }
 280        return 0;
 281}
 282
 283int reopen_lock_file(struct lock_file *lk)
 284{
 285        if (0 <= lk->fd)
 286                die(_("BUG: reopen a lockfile that is still open"));
 287        if (!lk->active)
 288                die(_("BUG: reopen a lockfile that has been committed"));
 289        lk->fd = open(lk->filename.buf, O_WRONLY);
 290        return lk->fd;
 291}
 292
 293int commit_lock_file(struct lock_file *lk)
 294{
 295        static struct strbuf result_file = STRBUF_INIT;
 296        int err;
 297
 298        if (!lk->active)
 299                die("BUG: attempt to commit unlocked object");
 300
 301        if (close_lock_file(lk))
 302                return -1;
 303
 304        /* remove ".lock": */
 305        strbuf_add(&result_file, lk->filename.buf,
 306                   lk->filename.len - LOCK_SUFFIX_LEN);
 307        err = rename(lk->filename.buf, result_file.buf);
 308        strbuf_reset(&result_file);
 309        if (err) {
 310                int save_errno = errno;
 311                rollback_lock_file(lk);
 312                errno = save_errno;
 313                return -1;
 314        }
 315
 316        lk->active = 0;
 317        strbuf_reset(&lk->filename);
 318        return 0;
 319}
 320
 321int hold_locked_index(struct lock_file *lk, int die_on_error)
 322{
 323        return hold_lock_file_for_update(lk, get_index_file(),
 324                                         die_on_error
 325                                         ? LOCK_DIE_ON_ERROR
 326                                         : 0);
 327}
 328
 329void rollback_lock_file(struct lock_file *lk)
 330{
 331        if (!lk->active)
 332                return;
 333
 334        if (!close_lock_file(lk)) {
 335                unlink_or_warn(lk->filename.buf);
 336                lk->active = 0;
 337                strbuf_reset(&lk->filename);
 338        }
 339}