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(void)
  11 {
  12         pid_t me = getpid();
  13
  14         while (lock_file_list) {
  15                 if (lock_file_list->owner == me)
  16                         rollback_lock_file(lock_file_list);
  17                 lock_file_list = lock_file_list->next;
  18         }
  19 }
  20
  21 static void remove_lock_files_on_signal(int signo)
  22 {
  23         remove_lock_files();
  24         sigchain_pop(signo);
  25         raise(signo);
  26 }
  27
  28 /*
  29  * path = absolute or relative path name
  30  *
  31  * Remove the last path name element from path (leaving the preceding
  32  * "/", if any).  If path is empty or the root directory ("/"), set
  33  * path to the empty string.
  34  */
  35 static void trim_last_path_component(struct strbuf *path)
  36 {
  37         int i = path->len;
  38
  39         /* back up past trailing slashes, if any */
  40         while (i && path->buf[i - 1] == '/')
  41                 i--;
  42
  43         /*
  44          * then go backwards until a slash, or the beginning of the
  45          * string
  46          */
  47         while (i && path->buf[i - 1] != '/')
  48                 i--;
  49
  50         strbuf_setlen(path, i);
  51 }
  52
  53
  54 /* We allow "recursive" symbolic links. Only within reason, though */
  55 #define MAXDEPTH 5
  56
  57 /*
  58  * path contains a path that might be a symlink.
  59  *
  60  * If path is a symlink, attempt to overwrite it with a path to the
  61  * real file or directory (which may or may not exist), following a
  62  * chain of symlinks if necessary.  Otherwise, leave path unmodified.
  63  *
  64  * This is a best-effort routine.  If an error occurs, path will
  65  * either be left unmodified or will name a different symlink in a
  66  * symlink chain that started with the original path.
  67  */
  68 static void resolve_symlink(struct strbuf *path)
  69 {
  70         int depth = MAXDEPTH;
  71         static struct strbuf link = STRBUF_INIT;
  72
  73         while (depth--) {
  74                 if (strbuf_readlink(&link, path->buf, path->len) < 0)
  75                         break;
  76
  77                 if (is_absolute_path(link.buf))
  78                         /* absolute path simply replaces p */
  79                         strbuf_reset(path);
  80                 else
  81                         /*
  82                          * link is a relative path, so replace the
  83                          * last element of p with it.
  84                          */
  85                         trim_last_path_component(path);
  86
  87                 strbuf_addbuf(path, &link);
  88         }
  89         strbuf_reset(&link);
  90 }
  91
  92 /* Make sure errno contains a meaningful value on error */
  93 static int lock_file(struct lock_file *lk, const char *path, int flags)
  94 {
  95         size_t pathlen = strlen(path);
  96
  97         if (!lock_file_list) {
  98                 /* One-time initialization */
  99                 sigchain_push_common(remove_lock_files_on_signal);
 100                 atexit(remove_lock_files);
 101         }
 102
 103         if (lk->active)
 104                 die("BUG: cannot lock_file(\"%s\") using active struct lock_file",
 105                     path);
 106         if (!lk->on_list) {
 107                 /* Initialize *lk and add it to lock_file_list: */
 108                 lk->fd = -1;
 109                 lk->active = 0;
 110                 lk->owner = 0;
 111                 strbuf_init(&lk->filename, pathlen + LOCK_SUFFIX_LEN);
 112                 lk->next = lock_file_list;
 113                 lock_file_list = lk;
 114                 lk->on_list = 1;
 115         } else if (lk->filename.len) {
 116                 /* This shouldn't happen, but better safe than sorry. */
 117                 die("BUG: lock_file(\"%s\") called with improperly-reset lock_file object",
 118                     path);
 119         }
 120
 121         strbuf_add(&lk->filename, path, pathlen);
 122         if (!(flags & LOCK_NO_DEREF))
 123                 resolve_symlink(&lk->filename);
 124         strbuf_addstr(&lk->filename, LOCK_SUFFIX);
 125         lk->fd = open(lk->filename.buf, O_RDWR | O_CREAT | O_EXCL, 0666);
 126         if (lk->fd < 0) {
 127                 strbuf_reset(&lk->filename);
 128                 return -1;
 129         }
 130         lk->owner = getpid();
 131         lk->active = 1;
 132         if (adjust_shared_perm(lk->filename.buf)) {
 133                 int save_errno = errno;
 134                 error("cannot fix permission bits on %s", lk->filename.buf);
 135                 rollback_lock_file(lk);
 136                 errno = save_errno;
 137                 return -1;
 138         }
 139         return lk->fd;
 140 }
 141
 142 void unable_to_lock_message(const char *path, int err, struct strbuf *buf)
 143 {
 144         if (err == EEXIST) {
 145                 strbuf_addf(buf, "Unable to create '%s.lock': %s.\n\n"
 146                     "If no other git process is currently running, this probably means a\n"
 147                     "git process crashed in this repository earlier. Make sure no other git\n"
 148                     "process is running and remove the file manually to continue.",
 149                             absolute_path(path), strerror(err));
 150         } else
 151                 strbuf_addf(buf, "Unable to create '%s.lock': %s",
 152                             absolute_path(path), strerror(err));
 153 }
 154
 155 int unable_to_lock_error(const char *path, int err)
 156 {
 157         struct strbuf buf = STRBUF_INIT;
 158
 159         unable_to_lock_message(path, err, &buf);
 160         error("%s", buf.buf);
 161         strbuf_release(&buf);
 162         return -1;
 163 }
 164
 165 NORETURN void unable_to_lock_die(const char *path, int err)
 166 {
 167         struct strbuf buf = STRBUF_INIT;
 168
 169         unable_to_lock_message(path, err, &buf);
 170         die("%s", buf.buf);
 171 }
 172
 173 /* This should return a meaningful errno on failure */
 174 int hold_lock_file_for_update(struct lock_file *lk, const char *path, int flags)
 175 {
 176         int fd = lock_file(lk, path, flags);
 177         if (fd < 0 && (flags & LOCK_DIE_ON_ERROR))
 178                 unable_to_lock_die(path, errno);
 179         return fd;
 180 }
 181
 182 int hold_lock_file_for_append(struct lock_file *lk, const char *path, int flags)
 183 {
 184         int fd, orig_fd;
 185
 186         fd = lock_file(lk, path, flags);
 187         if (fd < 0) {
 188                 if (flags & LOCK_DIE_ON_ERROR)
 189                         unable_to_lock_die(path, errno);
 190                 return fd;
 191         }
 192
 193         orig_fd = open(path, O_RDONLY);
 194         if (orig_fd < 0) {
 195                 if (errno != ENOENT) {
 196                         int save_errno = errno;
 197
 198                         if (flags & LOCK_DIE_ON_ERROR)
 199                                 die("cannot open '%s' for copying", path);
 200                         rollback_lock_file(lk);
 201                         error("cannot open '%s' for copying", path);
 202                         errno = save_errno;
 203                         return -1;
 204                 }
 205         } else if (copy_fd(orig_fd, fd)) {
 206                 int save_errno = errno;
 207
 208                 if (flags & LOCK_DIE_ON_ERROR)
 209                         exit(128);
 210                 close(orig_fd);
 211                 rollback_lock_file(lk);
 212                 errno = save_errno;
 213                 return -1;
 214         } else {
 215                 close(orig_fd);
 216         }
 217         return fd;
 218 }
 219
 220 char *get_locked_file_path(struct lock_file *lk)
 221 {
 222         if (!lk->active)
 223                 die("BUG: get_locked_file_path() called for unlocked object");
 224         if (lk->filename.len <= LOCK_SUFFIX_LEN)
 225                 die("BUG: get_locked_file_path() called for malformed lock object");
 226         return xmemdupz(lk->filename.buf, lk->filename.len - LOCK_SUFFIX_LEN);
 227 }
 228
 229 int close_lock_file(struct lock_file *lk)
 230 {
 231         int fd = lk->fd;
 232
 233         if (fd < 0)
 234                 return 0;
 235
 236         lk->fd = -1;
 237         if (close(fd)) {
 238                 int save_errno = errno;
 239                 rollback_lock_file(lk);
 240                 errno = save_errno;
 241                 return -1;
 242         }
 243         return 0;
 244 }
 245
 246 int reopen_lock_file(struct lock_file *lk)
 247 {
 248         if (0 <= lk->fd)
 249                 die(_("BUG: reopen a lockfile that is still open"));
 250         if (!lk->active)
 251                 die(_("BUG: reopen a lockfile that has been committed"));
 252         lk->fd = open(lk->filename.buf, O_WRONLY);
 253         return lk->fd;
 254 }
 255
 256 int commit_lock_file_to(struct lock_file *lk, const char *path)
 257 {
 258         if (!lk->active)
 259                 die("BUG: attempt to commit unlocked object to \"%s\"", path);
 260
 261         if (close_lock_file(lk))
 262                 return -1;
 263
 264         if (rename(lk->filename.buf, path)) {
 265                 int save_errno = errno;
 266                 rollback_lock_file(lk);
 267                 errno = save_errno;
 268                 return -1;
 269         }
 270
 271         lk->active = 0;
 272         strbuf_reset(&lk->filename);
 273         return 0;
 274 }
 275
 276 int commit_lock_file(struct lock_file *lk)
 277 {
 278         static struct strbuf result_file = STRBUF_INIT;
 279         int err;
 280
 281         if (!lk->active)
 282                 die("BUG: attempt to commit unlocked object");
 283
 284         if (lk->filename.len <= LOCK_SUFFIX_LEN ||
 285             strcmp(lk->filename.buf + lk->filename.len - LOCK_SUFFIX_LEN, LOCK_SUFFIX))
 286                 die("BUG: lockfile filename corrupt");
 287
 288         /* remove ".lock": */
 289         strbuf_add(&result_file, lk->filename.buf,
 290                    lk->filename.len - LOCK_SUFFIX_LEN);
 291         err = commit_lock_file_to(lk, result_file.buf);
 292         strbuf_reset(&result_file);
 293         return err;
 294 }
 295
 296 void rollback_lock_file(struct lock_file *lk)
 297 {
 298         if (!lk->active)
 299                 return;
 300
 301         if (!close_lock_file(lk)) {
 302                 unlink_or_warn(lk->filename.buf);
 303                 lk->active = 0;
 304                 strbuf_reset(&lk->filename);
 305         }
 306 }