2 * Copyright (c) 2005, Junio C Hamano
8 static struct lock_file
*volatile lock_file_list
;
10 static void remove_lock_files(int skip_fclose
)
14 while (lock_file_list
) {
15 if (lock_file_list
->owner
== me
) {
16 /* fclose() is not safe to call in a signal handler */
18 lock_file_list
->fp
= NULL
;
19 rollback_lock_file(lock_file_list
);
21 lock_file_list
= lock_file_list
->next
;
25 static void remove_lock_files_on_exit(void)
30 static void remove_lock_files_on_signal(int signo
)
38 * path = absolute or relative path name
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.
44 static void trim_last_path_component(struct strbuf
*path
)
48 /* back up past trailing slashes, if any */
49 while (i
&& path
->buf
[i
- 1] == '/')
53 * then go backwards until a slash, or the beginning of the
56 while (i
&& path
->buf
[i
- 1] != '/')
59 strbuf_setlen(path
, i
);
63 /* We allow "recursive" symbolic links. Only within reason, though */
67 * path contains a path that might be a symlink.
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.
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.
77 static void resolve_symlink(struct strbuf
*path
)
80 static struct strbuf link
= STRBUF_INIT
;
83 if (strbuf_readlink(&link
, path
->buf
, path
->len
) < 0)
86 if (is_absolute_path(link
.buf
))
87 /* absolute path simply replaces p */
91 * link is a relative path, so replace the
92 * last element of p with it.
94 trim_last_path_component(path
);
96 strbuf_addbuf(path
, &link
);
101 /* Make sure errno contains a meaningful value on error */
102 static int lock_file(struct lock_file
*lk
, const char *path
, int flags
)
104 size_t pathlen
= strlen(path
);
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
);
113 die("BUG: cannot lock_file(\"%s\") using active struct lock_file",
116 /* Initialize *lk and add it to lock_file_list: */
121 strbuf_init(&lk
->filename
, pathlen
+ LOCK_SUFFIX_LEN
);
122 lk
->next
= lock_file_list
;
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",
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);
137 strbuf_reset(&lk
->filename
);
140 lk
->owner
= getpid();
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
);
152 void unable_to_lock_message(const char *path
, int err
, struct strbuf
*buf
)
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
));
161 strbuf_addf(buf
, "Unable to create '%s.lock': %s",
162 absolute_path(path
), strerror(err
));
165 int unable_to_lock_error(const char *path
, int err
)
167 struct strbuf buf
= STRBUF_INIT
;
169 unable_to_lock_message(path
, err
, &buf
);
170 error("%s", buf
.buf
);
171 strbuf_release(&buf
);
175 NORETURN
void unable_to_lock_die(const char *path
, int err
)
177 struct strbuf buf
= STRBUF_INIT
;
179 unable_to_lock_message(path
, err
, &buf
);
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
)
186 int fd
= lock_file(lk
, path
, flags
);
187 if (fd
< 0 && (flags
& LOCK_DIE_ON_ERROR
))
188 unable_to_lock_die(path
, errno
);
192 int hold_lock_file_for_append(struct lock_file
*lk
, const char *path
, int flags
)
196 fd
= lock_file(lk
, path
, flags
);
198 if (flags
& LOCK_DIE_ON_ERROR
)
199 unable_to_lock_die(path
, errno
);
203 orig_fd
= open(path
, O_RDONLY
);
205 if (errno
!= ENOENT
) {
206 int save_errno
= errno
;
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
);
215 } else if (copy_fd(orig_fd
, fd
)) {
216 int save_errno
= errno
;
218 if (flags
& LOCK_DIE_ON_ERROR
)
220 rollback_lock_file(lk
);
227 FILE *fdopen_lock_file(struct lock_file
*lk
, const char *mode
)
230 die("BUG: fdopen_lock_file() called for unlocked object");
232 die("BUG: fdopen_lock_file() called twice for file '%s'", lk
->filename
.buf
);
234 lk
->fp
= fdopen(lk
->fd
, mode
);
238 char *get_locked_file_path(struct lock_file
*lk
)
241 die("BUG: get_locked_file_path() called for unlocked object");
242 if (lk
->filename
.len
<= LOCK_SUFFIX_LEN
)
243 die("BUG: get_locked_file_path() called for malformed lock object");
244 return xmemdupz(lk
->filename
.buf
, lk
->filename
.len
- LOCK_SUFFIX_LEN
);
247 int close_lock_file(struct lock_file
*lk
)
261 * Note: no short-circuiting here; we want to fclose()
264 err
= ferror(fp
) | fclose(fp
);
270 int save_errno
= errno
;
271 rollback_lock_file(lk
);
279 int reopen_lock_file(struct lock_file
*lk
)
282 die(_("BUG: reopen a lockfile that is still open"));
284 die(_("BUG: reopen a lockfile that has been committed"));
285 lk
->fd
= open(lk
->filename
.buf
, O_WRONLY
);
289 int commit_lock_file_to(struct lock_file
*lk
, const char *path
)
292 die("BUG: attempt to commit unlocked object to \"%s\"", path
);
294 if (close_lock_file(lk
))
297 if (rename(lk
->filename
.buf
, path
)) {
298 int save_errno
= errno
;
299 rollback_lock_file(lk
);
305 strbuf_reset(&lk
->filename
);
309 int commit_lock_file(struct lock_file
*lk
)
311 static struct strbuf result_file
= STRBUF_INIT
;
315 die("BUG: attempt to commit unlocked object");
317 if (lk
->filename
.len
<= LOCK_SUFFIX_LEN
||
318 strcmp(lk
->filename
.buf
+ lk
->filename
.len
- LOCK_SUFFIX_LEN
, LOCK_SUFFIX
))
319 die("BUG: lockfile filename corrupt");
321 /* remove ".lock": */
322 strbuf_add(&result_file
, lk
->filename
.buf
,
323 lk
->filename
.len
- LOCK_SUFFIX_LEN
);
324 err
= commit_lock_file_to(lk
, result_file
.buf
);
325 strbuf_reset(&result_file
);
329 void rollback_lock_file(struct lock_file
*lk
)
334 if (!close_lock_file(lk
)) {
335 unlink_or_warn(lk
->filename
.buf
);
337 strbuf_reset(&lk
->filename
);