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