lockfile.c

   1 /*
   2  * Copyright (c) 2005, Junio C Hamano
   3  */
   4 #include "cache.h"
   5 #include "lockfile.h"
   6 #include "sigchain.h"
   7
   8 static struct lock_file *volatile lock_file_list;
   9
  10 static 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
  25 static void remove_lock_files_on_exit(void)
  26 {
  27         remove_lock_files(0);
  28 }
  29
  30 static 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  */
  44 static 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  */
  77 static 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 */
 102 static 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         strbuf_add(&lk->filename, path, pathlen);
 132         if (!(flags & LOCK_NO_DEREF))
 133                 resolve_symlink(&lk->filename);
 134         strbuf_addstr(&lk->filename, LOCK_SUFFIX);
 135         lk->fd = open(lk->filename.buf, O_RDWR | O_CREAT | O_EXCL, 0666);
 136         if (lk->fd < 0) {
 137                 strbuf_reset(&lk->filename);
 138                 return -1;
 139         }
 140         lk->owner = getpid();
 141         lk->active = 1;
 142         if (adjust_shared_perm(lk->filename.buf)) {
 143                 int save_errno = errno;
 144                 error("cannot fix permission bits on %s", lk->filename.buf);
 145                 rollback_lock_file(lk);
 146                 errno = save_errno;
 147                 return -1;
 148         }
 149         return lk->fd;
 150 }
 151
 152 void unable_to_lock_message(const char *path, int err, struct strbuf *buf)
 153 {
 154         if (err == EEXIST) {
 155                 strbuf_addf(buf, "Unable to create '%s.lock': %s.\n\n"
 156                     "If no other git process is currently running, this probably means a\n"
 157                     "git process crashed in this repository earlier. Make sure no other git\n"
 158                     "process is running and remove the file manually to continue.",
 159                             absolute_path(path), strerror(err));
 160         } else
 161                 strbuf_addf(buf, "Unable to create '%s.lock': %s",
 162                             absolute_path(path), strerror(err));
 163 }
 164
 165 int unable_to_lock_error(const char *path, int err)
 166 {
 167         struct strbuf buf = STRBUF_INIT;
 168
 169         unable_to_lock_message(path, err, &buf);
 170         error("%s", buf.buf);
 171         strbuf_release(&buf);
 172         return -1;
 173 }
 174
 175 NORETURN void unable_to_lock_die(const char *path, int err)
 176 {
 177         struct strbuf buf = STRBUF_INIT;
 178
 179         unable_to_lock_message(path, err, &buf);
 180         die("%s", buf.buf);
 181 }
 182
 183 /* This should return a meaningful errno on failure */
 184 int hold_lock_file_for_update(struct lock_file *lk, const char *path, int flags)
 185 {
 186         int fd = lock_file(lk, path, flags);
 187         if (fd < 0 && (flags & LOCK_DIE_ON_ERROR))
 188                 unable_to_lock_die(path, errno);
 189         return fd;
 190 }
 191
 192 int hold_lock_file_for_append(struct lock_file *lk, const char *path, int flags)
 193 {
 194         int fd, orig_fd;
 195
 196         fd = lock_file(lk, path, flags);
 197         if (fd < 0) {
 198                 if (flags & LOCK_DIE_ON_ERROR)
 199                         unable_to_lock_die(path, errno);
 200                 return fd;
 201         }
 202
 203         orig_fd = open(path, O_RDONLY);
 204         if (orig_fd < 0) {
 205                 if (errno != ENOENT) {
 206                         int save_errno = errno;
 207
 208                         if (flags & LOCK_DIE_ON_ERROR)
 209                                 die("cannot open '%s' for copying", path);
 210                         rollback_lock_file(lk);
 211                         error("cannot open '%s' for copying", path);
 212                         errno = save_errno;
 213                         return -1;
 214                 }
 215         } else if (copy_fd(orig_fd, fd)) {
 216                 int save_errno = errno;
 217
 218                 if (flags & LOCK_DIE_ON_ERROR)
 219                         exit(128);
 220                 close(orig_fd);
 221                 rollback_lock_file(lk);
 222                 errno = save_errno;
 223                 return -1;
 224         } else {
 225                 close(orig_fd);
 226         }
 227         return fd;
 228 }
 229
 230 FILE *fdopen_lock_file(struct lock_file *lk, const char *mode)
 231 {
 232         if (!lk->active)
 233                 die("BUG: fdopen_lock_file() called for unlocked object");
 234         if (lk->fp)
 235                 die("BUG: fdopen_lock_file() called twice for file '%s'", lk->filename.buf);
 236
 237         lk->fp = fdopen(lk->fd, mode);
 238         return lk->fp;
 239 }
 240
 241 char *get_locked_file_path(struct lock_file *lk)
 242 {
 243         if (!lk->active)
 244                 die("BUG: get_locked_file_path() called for unlocked object");
 245         if (lk->filename.len <= LOCK_SUFFIX_LEN)
 246                 die("BUG: get_locked_file_path() called for malformed lock object");
 247         return xmemdupz(lk->filename.buf, lk->filename.len - LOCK_SUFFIX_LEN);
 248 }
 249
 250 int close_lock_file(struct lock_file *lk)
 251 {
 252         int fd = lk->fd;
 253         FILE *fp = lk->fp;
 254         int err;
 255
 256         if (fd < 0)
 257                 return 0;
 258
 259         lk->fd = -1;
 260         if (fp) {
 261                 lk->fp = NULL;
 262
 263                 /*
 264                  * Note: no short-circuiting here; we want to fclose()
 265                  * in any case!
 266                  */
 267                 err = ferror(fp) | fclose(fp);
 268         } else {
 269                 err = close(fd);
 270         }
 271
 272         if (err) {
 273                 int save_errno = errno;
 274                 rollback_lock_file(lk);
 275                 errno = save_errno;
 276                 return -1;
 277         }
 278
 279         return 0;
 280 }
 281
 282 int reopen_lock_file(struct lock_file *lk)
 283 {
 284         if (0 <= lk->fd)
 285                 die(_("BUG: reopen a lockfile that is still open"));
 286         if (!lk->active)
 287                 die(_("BUG: reopen a lockfile that has been committed"));
 288         lk->fd = open(lk->filename.buf, O_WRONLY);
 289         return lk->fd;
 290 }
 291
 292 int commit_lock_file_to(struct lock_file *lk, const char *path)
 293 {
 294         if (!lk->active)
 295                 die("BUG: attempt to commit unlocked object to \"%s\"", path);
 296
 297         if (close_lock_file(lk))
 298                 return -1;
 299
 300         if (rename(lk->filename.buf, path)) {
 301                 int save_errno = errno;
 302                 rollback_lock_file(lk);
 303                 errno = save_errno;
 304                 return -1;
 305         }
 306
 307         lk->active = 0;
 308         strbuf_reset(&lk->filename);
 309         return 0;
 310 }
 311
 312 int commit_lock_file(struct lock_file *lk)
 313 {
 314         static struct strbuf result_file = STRBUF_INIT;
 315         int err;
 316
 317         if (!lk->active)
 318                 die("BUG: attempt to commit unlocked object");
 319
 320         if (lk->filename.len <= LOCK_SUFFIX_LEN ||
 321             strcmp(lk->filename.buf + lk->filename.len - LOCK_SUFFIX_LEN, LOCK_SUFFIX))
 322                 die("BUG: lockfile filename corrupt");
 323
 324         /* remove ".lock": */
 325         strbuf_add(&result_file, lk->filename.buf,
 326                    lk->filename.len - LOCK_SUFFIX_LEN);
 327         err = commit_lock_file_to(lk, result_file.buf);
 328         strbuf_reset(&result_file);
 329         return err;
 330 }
 331
 332 void rollback_lock_file(struct lock_file *lk)
 333 {
 334         if (!lk->active)
 335                 return;
 336
 337         if (!close_lock_file(lk)) {
 338                 unlink_or_warn(lk->filename.buf);
 339                 lk->active = 0;
 340                 strbuf_reset(&lk->filename);
 341         }
 342 }