2 * Copyright (c) 2005, Junio C Hamano
7 static struct lock_file
*lock_file_list
;
9 static void remove_lock_file(void)
13 while (lock_file_list
) {
14 if (lock_file_list
->owner
== me
&&
15 lock_file_list
->filename
[0]) {
16 if (lock_file_list
->fd
>= 0)
17 close(lock_file_list
->fd
);
18 unlink_or_warn(lock_file_list
->filename
);
20 lock_file_list
= lock_file_list
->next
;
24 static void remove_lock_file_on_signal(int signo
)
32 * p = absolute or relative path name
34 * Return a pointer into p showing the beginning of the last path name
35 * element. If p is empty or the root directory ("/"), just return p.
37 static char *last_path_elm(char *p
)
39 /* r starts pointing to null at the end of the string */
40 char *r
= strchr(p
, '\0');
43 return p
; /* just return empty string */
45 r
--; /* back up to last non-null character */
47 /* back up past trailing slashes, if any */
48 while (r
> p
&& *r
== '/')
52 * then go backwards until I hit a slash, or the beginning of
55 while (r
> p
&& *(r
-1) != '/')
61 /* We allow "recursive" symbolic links. Only within reason, though */
65 * p = path that may be a symlink
68 * If p is a symlink, attempt to overwrite p with a path to the real
69 * file or directory (which may or may not exist), following a chain of
70 * symlinks if necessary. Otherwise, leave p unmodified.
72 * This is a best-effort routine. If an error occurs, p will either be
73 * left unmodified or will name a different symlink in a symlink chain
74 * that started with p's initial contents.
79 static char *resolve_symlink(char *p
, size_t s
)
85 int link_len
= readlink(p
, link
, sizeof(link
));
87 /* not a symlink anymore */
90 else if (link_len
< sizeof(link
))
91 /* readlink() never null-terminates */
92 link
[link_len
] = '\0';
94 warning("%s: symlink too long", p
);
98 if (is_absolute_path(link
)) {
99 /* absolute path simply replaces p */
103 warning("%s: symlink too long", p
);
108 * link is a relative path, so I must replace the
109 * last element of p with it.
111 char *r
= (char *)last_path_elm(p
);
112 if (r
- p
+ link_len
< s
)
115 warning("%s: symlink too long", p
);
123 /* Make sure errno contains a meaningful value on error */
124 static int lock_file(struct lock_file
*lk
, const char *path
, int flags
)
127 * subtract 5 from size to make sure there's room for adding
128 * ".lock" for the lock file name
130 static const size_t max_path_len
= sizeof(lk
->filename
) - 5;
132 if (strlen(path
) >= max_path_len
) {
133 errno
= ENAMETOOLONG
;
136 strcpy(lk
->filename
, path
);
137 if (!(flags
& LOCK_NODEREF
))
138 resolve_symlink(lk
->filename
, max_path_len
);
139 strcat(lk
->filename
, ".lock");
140 lk
->fd
= open(lk
->filename
, O_RDWR
| O_CREAT
| O_EXCL
, 0666);
142 if (!lock_file_list
) {
143 sigchain_push_common(remove_lock_file_on_signal
);
144 atexit(remove_lock_file
);
146 lk
->owner
= getpid();
148 lk
->next
= lock_file_list
;
152 if (adjust_shared_perm(lk
->filename
)) {
153 int save_errno
= errno
;
154 error("cannot fix permission bits on %s",
156 rollback_lock_file(lk
);
166 void unable_to_lock_message(const char *path
, int err
, struct strbuf
*buf
)
169 strbuf_addf(buf
, "Unable to create '%s.lock': %s.\n\n"
170 "If no other git process is currently running, this probably means a\n"
171 "git process crashed in this repository earlier. Make sure no other git\n"
172 "process is running and remove the file manually to continue.",
173 absolute_path(path
), strerror(err
));
175 strbuf_addf(buf
, "Unable to create '%s.lock': %s",
176 absolute_path(path
), strerror(err
));
179 int unable_to_lock_error(const char *path
, int err
)
181 struct strbuf buf
= STRBUF_INIT
;
183 unable_to_lock_message(path
, err
, &buf
);
184 error("%s", buf
.buf
);
185 strbuf_release(&buf
);
189 NORETURN
void unable_to_lock_die(const char *path
, int err
)
191 struct strbuf buf
= STRBUF_INIT
;
193 unable_to_lock_message(path
, err
, &buf
);
197 /* This should return a meaningful errno on failure */
198 int hold_lock_file_for_update(struct lock_file
*lk
, const char *path
, int flags
)
200 int fd
= lock_file(lk
, path
, flags
);
201 if (fd
< 0 && (flags
& LOCK_DIE_ON_ERROR
))
202 unable_to_lock_die(path
, errno
);
206 int hold_lock_file_for_append(struct lock_file
*lk
, const char *path
, int flags
)
210 fd
= lock_file(lk
, path
, flags
);
212 if (flags
& LOCK_DIE_ON_ERROR
)
213 unable_to_lock_die(path
, errno
);
217 orig_fd
= open(path
, O_RDONLY
);
219 if (errno
!= ENOENT
) {
220 if (flags
& LOCK_DIE_ON_ERROR
)
221 die("cannot open '%s' for copying", path
);
222 rollback_lock_file(lk
);
223 return error("cannot open '%s' for copying", path
);
225 } else if (copy_fd(orig_fd
, fd
)) {
226 if (flags
& LOCK_DIE_ON_ERROR
)
228 rollback_lock_file(lk
);
234 int close_lock_file(struct lock_file
*lk
)
245 int reopen_lock_file(struct lock_file
*lk
)
248 die(_("BUG: reopen a lockfile that is still open"));
249 if (!lk
->filename
[0])
250 die(_("BUG: reopen a lockfile that has been committed"));
251 lk
->fd
= open(lk
->filename
, O_WRONLY
);
255 int commit_lock_file(struct lock_file
*lk
)
257 char result_file
[PATH_MAX
];
259 if (close_lock_file(lk
))
261 strcpy(result_file
, lk
->filename
);
262 i
= strlen(result_file
) - 5; /* .lock */
264 if (rename(lk
->filename
, result_file
))
270 int hold_locked_index(struct lock_file
*lk
, int die_on_error
)
272 return hold_lock_file_for_update(lk
, get_index_file(),
278 void rollback_lock_file(struct lock_file
*lk
)
280 if (!lk
->filename
[0])
284 unlink_or_warn(lk
->filename
);