3f5b699cf740b0d3926be5242e3ab470d55edcd9
   1/*
   2 * Copyright (c) 2005, Junio C Hamano
   3 */
   4#include "cache.h"
   5#include "lockfile.h"
   6#include "sigchain.h"
   7
   8static struct lock_file *volatile lock_file_list;
   9
  10static void remove_lock_files(int skip_fclose)
  11{
  12        pid_t me = getpid();
  13
  14        while (lock_file_list) {
  15                if (lock_file_list->owner == me) {
  16                        /* fclose() is not safe to call in a signal handler */
  17                        if (skip_fclose)
  18                                lock_file_list->fp = NULL;
  19                        rollback_lock_file(lock_file_list);
  20                }
  21                lock_file_list = lock_file_list->next;
  22        }
  23}
  24
  25static void remove_lock_files_on_exit(void)
  26{
  27        remove_lock_files(0);
  28}
  29
  30static void remove_lock_files_on_signal(int signo)
  31{
  32        remove_lock_files(1);
  33        sigchain_pop(signo);
  34        raise(signo);
  35}
  36
  37/*
  38 * path = absolute or relative path name
  39 *
  40 * Remove the last path name element from path (leaving the preceding
  41 * "/", if any).  If path is empty or the root directory ("/"), set
  42 * path to the empty string.
  43 */
  44static void trim_last_path_component(struct strbuf *path)
  45{
  46        int i = path->len;
  47
  48        /* back up past trailing slashes, if any */
  49        while (i && path->buf[i - 1] == '/')
  50                i--;
  51
  52        /*
  53         * then go backwards until a slash, or the beginning of the
  54         * string
  55         */
  56        while (i && path->buf[i - 1] != '/')
  57                i--;
  58
  59        strbuf_setlen(path, i);
  60}
  61
  62
  63/* We allow "recursive" symbolic links. Only within reason, though */
  64#define MAXDEPTH 5
  65
  66/*
  67 * path contains a path that might be a symlink.
  68 *
  69 * If path is a symlink, attempt to overwrite it with a path to the
  70 * real file or directory (which may or may not exist), following a
  71 * chain of symlinks if necessary.  Otherwise, leave path unmodified.
  72 *
  73 * This is a best-effort routine.  If an error occurs, path will
  74 * either be left unmodified or will name a different symlink in a
  75 * symlink chain that started with the original path.
  76 */
  77static void resolve_symlink(struct strbuf *path)
  78{
  79        int depth = MAXDEPTH;
  80        static struct strbuf link = STRBUF_INIT;
  81
  82        while (depth--) {
  83                if (strbuf_readlink(&link, path->buf, path->len) < 0)
  84                        break;
  85
  86                if (is_absolute_path(link.buf))
  87                        /* absolute path simply replaces p */
  88                        strbuf_reset(path);
  89                else
  90                        /*
  91                         * link is a relative path, so replace the
  92                         * last element of p with it.
  93                         */
  94                        trim_last_path_component(path);
  95
  96                strbuf_addbuf(path, &link);
  97        }
  98        strbuf_reset(&link);
  99}
 100
 101/* Make sure errno contains a meaningful value on error */
 102static int lock_file(struct lock_file *lk, const char *path, int flags)
 103{
 104        size_t pathlen = strlen(path);
 105
 106        if (!lock_file_list) {
 107                /* One-time initialization */
 108                sigchain_push_common(remove_lock_files_on_signal);
 109                atexit(remove_lock_files_on_exit);
 110        }
 111
 112        if (lk->active)
 113                die("BUG: cannot lock_file(\"%s\") using active struct lock_file",
 114                    path);
 115        if (!lk->on_list) {
 116                /* Initialize *lk and add it to lock_file_list: */
 117                lk->fd = -1;
 118                lk->fp = NULL;
 119                lk->active = 0;
 120                lk->owner = 0;
 121                strbuf_init(&lk->filename, pathlen + LOCK_SUFFIX_LEN);
 122                lk->next = lock_file_list;
 123                lock_file_list = lk;
 124                lk->on_list = 1;
 125        } else if (lk->filename.len) {
 126                /* This shouldn't happen, but better safe than sorry. */
 127                die("BUG: lock_file(\"%s\") called with improperly-reset lock_file object",
 128                    path);
 129        }
 130
 131        if (flags & LOCK_NO_DEREF) {
 132                strbuf_add_absolute_path(&lk->filename, path);
 133        } else {
 134                struct strbuf resolved_path = STRBUF_INIT;
 135
 136                strbuf_add(&resolved_path, path, pathlen);
 137                resolve_symlink(&resolved_path);
 138                strbuf_add_absolute_path(&lk->filename, resolved_path.buf);
 139                strbuf_release(&resolved_path);
 140        }
 141
 142        strbuf_addstr(&lk->filename, LOCK_SUFFIX);
 143        lk->fd = open(lk->filename.buf, O_RDWR | O_CREAT | O_EXCL, 0666);
 144        if (lk->fd < 0) {
 145                strbuf_reset(&lk->filename);
 146                return -1;
 147        }
 148        lk->owner = getpid();
 149        lk->active = 1;
 150        if (adjust_shared_perm(lk->filename.buf)) {
 151                int save_errno = errno;
 152                error("cannot fix permission bits on %s", lk->filename.buf);
 153                rollback_lock_file(lk);
 154                errno = save_errno;
 155                return -1;
 156        }
 157        return lk->fd;
 158}
 159
 160static int sleep_microseconds(long us)
 161{
 162        struct timeval tv;
 163        tv.tv_sec = 0;
 164        tv.tv_usec = us;
 165        return select(0, NULL, NULL, NULL, &tv);
 166}
 167
 168/*
 169 * Constants defining the gaps between attempts to lock a file. The
 170 * first backoff period is approximately INITIAL_BACKOFF_MS
 171 * milliseconds. The longest backoff period is approximately
 172 * (BACKOFF_MAX_MULTIPLIER * INITIAL_BACKOFF_MS) milliseconds.
 173 */
 174#define INITIAL_BACKOFF_MS 1L
 175#define BACKOFF_MAX_MULTIPLIER 1000
 176
 177/*
 178 * Try locking path, retrying with quadratic backoff for at least
 179 * timeout_ms milliseconds. If timeout_ms is 0, try locking the file
 180 * exactly once. If timeout_ms is -1, try indefinitely.
 181 */
 182static int lock_file_timeout(struct lock_file *lk, const char *path,
 183                             int flags, long timeout_ms)
 184{
 185        int n = 1;
 186        int multiplier = 1;
 187        long remaining_ms = 0;
 188        static int random_initialized = 0;
 189
 190        if (timeout_ms == 0)
 191                return lock_file(lk, path, flags);
 192
 193        if (!random_initialized) {
 194                srand((unsigned int)getpid());
 195                random_initialized = 1;
 196        }
 197
 198        if (timeout_ms > 0)
 199                remaining_ms = timeout_ms;
 200
 201        while (1) {
 202                long backoff_ms, wait_ms;
 203                int fd;
 204
 205                fd = lock_file(lk, path, flags);
 206
 207                if (fd >= 0)
 208                        return fd; /* success */
 209                else if (errno != EEXIST)
 210                        return -1; /* failure other than lock held */
 211                else if (timeout_ms > 0 && remaining_ms <= 0)
 212                        return -1; /* failure due to timeout */
 213
 214                backoff_ms = multiplier * INITIAL_BACKOFF_MS;
 215                /* back off for between 0.75*backoff_ms and 1.25*backoff_ms */
 216                wait_ms = (750 + rand() % 500) * backoff_ms / 1000;
 217                sleep_microseconds(wait_ms*1000);
 218                remaining_ms -= wait_ms;
 219
 220                /* Recursion: (n+1)^2 = n^2 + 2n + 1 */
 221                multiplier += 2*n + 1;
 222                if (multiplier > BACKOFF_MAX_MULTIPLIER)
 223                        multiplier = BACKOFF_MAX_MULTIPLIER;
 224                else
 225                        n++;
 226        }
 227}
 228
 229void unable_to_lock_message(const char *path, int err, struct strbuf *buf)
 230{
 231        if (err == EEXIST) {
 232                strbuf_addf(buf, "Unable to create '%s.lock': %s.\n\n"
 233                    "If no other git process is currently running, this probably means a\n"
 234                    "git process crashed in this repository earlier. Make sure no other git\n"
 235                    "process is running and remove the file manually to continue.",
 236                            absolute_path(path), strerror(err));
 237        } else
 238                strbuf_addf(buf, "Unable to create '%s.lock': %s",
 239                            absolute_path(path), strerror(err));
 240}
 241
 242NORETURN void unable_to_lock_die(const char *path, int err)
 243{
 244        struct strbuf buf = STRBUF_INIT;
 245
 246        unable_to_lock_message(path, err, &buf);
 247        die("%s", buf.buf);
 248}
 249
 250/* This should return a meaningful errno on failure */
 251int hold_lock_file_for_update_timeout(struct lock_file *lk, const char *path,
 252                                      int flags, long timeout_ms)
 253{
 254        int fd = lock_file_timeout(lk, path, flags, timeout_ms);
 255        if (fd < 0 && (flags & LOCK_DIE_ON_ERROR))
 256                unable_to_lock_die(path, errno);
 257        return fd;
 258}
 259
 260int hold_lock_file_for_append(struct lock_file *lk, const char *path, int flags)
 261{
 262        int fd, orig_fd;
 263
 264        fd = lock_file(lk, path, flags);
 265        if (fd < 0) {
 266                if (flags & LOCK_DIE_ON_ERROR)
 267                        unable_to_lock_die(path, errno);
 268                return fd;
 269        }
 270
 271        orig_fd = open(path, O_RDONLY);
 272        if (orig_fd < 0) {
 273                if (errno != ENOENT) {
 274                        int save_errno = errno;
 275
 276                        if (flags & LOCK_DIE_ON_ERROR)
 277                                die("cannot open '%s' for copying", path);
 278                        rollback_lock_file(lk);
 279                        error("cannot open '%s' for copying", path);
 280                        errno = save_errno;
 281                        return -1;
 282                }
 283        } else if (copy_fd(orig_fd, fd)) {
 284                int save_errno = errno;
 285
 286                if (flags & LOCK_DIE_ON_ERROR)
 287                        exit(128);
 288                close(orig_fd);
 289                rollback_lock_file(lk);
 290                errno = save_errno;
 291                return -1;
 292        } else {
 293                close(orig_fd);
 294        }
 295        return fd;
 296}
 297
 298FILE *fdopen_lock_file(struct lock_file *lk, const char *mode)
 299{
 300        if (!lk->active)
 301                die("BUG: fdopen_lock_file() called for unlocked object");
 302        if (lk->fp)
 303                die("BUG: fdopen_lock_file() called twice for file '%s'", lk->filename.buf);
 304
 305        lk->fp = fdopen(lk->fd, mode);
 306        return lk->fp;
 307}
 308
 309char *get_locked_file_path(struct lock_file *lk)
 310{
 311        if (!lk->active)
 312                die("BUG: get_locked_file_path() called for unlocked object");
 313        if (lk->filename.len <= LOCK_SUFFIX_LEN)
 314                die("BUG: get_locked_file_path() called for malformed lock object");
 315        return xmemdupz(lk->filename.buf, lk->filename.len - LOCK_SUFFIX_LEN);
 316}
 317
 318int close_lock_file(struct lock_file *lk)
 319{
 320        int fd = lk->fd;
 321        FILE *fp = lk->fp;
 322        int err;
 323
 324        if (fd < 0)
 325                return 0;
 326
 327        lk->fd = -1;
 328        if (fp) {
 329                lk->fp = NULL;
 330
 331                /*
 332                 * Note: no short-circuiting here; we want to fclose()
 333                 * in any case!
 334                 */
 335                err = ferror(fp) | fclose(fp);
 336        } else {
 337                err = close(fd);
 338        }
 339
 340        if (err) {
 341                int save_errno = errno;
 342                rollback_lock_file(lk);
 343                errno = save_errno;
 344                return -1;
 345        }
 346
 347        return 0;
 348}
 349
 350int reopen_lock_file(struct lock_file *lk)
 351{
 352        if (0 <= lk->fd)
 353                die(_("BUG: reopen a lockfile that is still open"));
 354        if (!lk->active)
 355                die(_("BUG: reopen a lockfile that has been committed"));
 356        lk->fd = open(lk->filename.buf, O_WRONLY);
 357        return lk->fd;
 358}
 359
 360int commit_lock_file_to(struct lock_file *lk, const char *path)
 361{
 362        if (!lk->active)
 363                die("BUG: attempt to commit unlocked object to \"%s\"", path);
 364
 365        if (close_lock_file(lk))
 366                return -1;
 367
 368        if (rename(lk->filename.buf, path)) {
 369                int save_errno = errno;
 370                rollback_lock_file(lk);
 371                errno = save_errno;
 372                return -1;
 373        }
 374
 375        lk->active = 0;
 376        strbuf_reset(&lk->filename);
 377        return 0;
 378}
 379
 380int commit_lock_file(struct lock_file *lk)
 381{
 382        static struct strbuf result_file = STRBUF_INIT;
 383        int err;
 384
 385        if (!lk->active)
 386                die("BUG: attempt to commit unlocked object");
 387
 388        if (lk->filename.len <= LOCK_SUFFIX_LEN ||
 389            strcmp(lk->filename.buf + lk->filename.len - LOCK_SUFFIX_LEN, LOCK_SUFFIX))
 390                die("BUG: lockfile filename corrupt");
 391
 392        /* remove ".lock": */
 393        strbuf_add(&result_file, lk->filename.buf,
 394                   lk->filename.len - LOCK_SUFFIX_LEN);
 395        err = commit_lock_file_to(lk, result_file.buf);
 396        strbuf_reset(&result_file);
 397        return err;
 398}
 399
 400void rollback_lock_file(struct lock_file *lk)
 401{
 402        if (!lk->active)
 403                return;
 404
 405        if (!close_lock_file(lk)) {
 406                unlink_or_warn(lk->filename.buf);
 407                lk->active = 0;
 408                strbuf_reset(&lk->filename);
 409        }
 410}