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(), 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
  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
 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 */
 171 static 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
 225 void 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
 238 int 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
 248 NORETURN 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 */
 257 int 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
 265 int 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
 293 int 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
 310 int 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
 320 int 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
 346 int 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
 354 void 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 }