]>
Commit | Line | Data |
---|---|---|
1 | /* | |
2 | * Copyright (c) 2005, Junio C Hamano | |
3 | */ | |
4 | ||
5 | #include "git-compat-util.h" | |
6 | #include "abspath.h" | |
7 | #include "gettext.h" | |
8 | #include "lockfile.h" | |
9 | ||
10 | /* | |
11 | * path = absolute or relative path name | |
12 | * | |
13 | * Remove the last path name element from path (leaving the preceding | |
14 | * "/", if any). If path is empty or the root directory ("/"), set | |
15 | * path to the empty string. | |
16 | */ | |
17 | static void trim_last_path_component(struct strbuf *path) | |
18 | { | |
19 | int i = path->len; | |
20 | ||
21 | /* back up past trailing slashes, if any */ | |
22 | while (i && path->buf[i - 1] == '/') | |
23 | i--; | |
24 | ||
25 | /* | |
26 | * then go backwards until a slash, or the beginning of the | |
27 | * string | |
28 | */ | |
29 | while (i && path->buf[i - 1] != '/') | |
30 | i--; | |
31 | ||
32 | strbuf_setlen(path, i); | |
33 | } | |
34 | ||
35 | ||
36 | /* We allow "recursive" symbolic links. Only within reason, though */ | |
37 | #define MAXDEPTH 5 | |
38 | ||
39 | /* | |
40 | * path contains a path that might be a symlink. | |
41 | * | |
42 | * If path is a symlink, attempt to overwrite it with a path to the | |
43 | * real file or directory (which may or may not exist), following a | |
44 | * chain of symlinks if necessary. Otherwise, leave path unmodified. | |
45 | * | |
46 | * This is a best-effort routine. If an error occurs, path will | |
47 | * either be left unmodified or will name a different symlink in a | |
48 | * symlink chain that started with the original path. | |
49 | */ | |
50 | static void resolve_symlink(struct strbuf *path) | |
51 | { | |
52 | int depth = MAXDEPTH; | |
53 | static struct strbuf link = STRBUF_INIT; | |
54 | ||
55 | while (depth--) { | |
56 | if (strbuf_readlink(&link, path->buf, path->len) < 0) | |
57 | break; | |
58 | ||
59 | if (is_absolute_path(link.buf)) | |
60 | /* absolute path simply replaces p */ | |
61 | strbuf_reset(path); | |
62 | else | |
63 | /* | |
64 | * link is a relative path, so replace the | |
65 | * last element of p with it. | |
66 | */ | |
67 | trim_last_path_component(path); | |
68 | ||
69 | strbuf_addbuf(path, &link); | |
70 | } | |
71 | strbuf_reset(&link); | |
72 | } | |
73 | ||
74 | /* Make sure errno contains a meaningful value on error */ | |
75 | static int lock_file(struct lock_file *lk, const char *path, int flags, | |
76 | int mode) | |
77 | { | |
78 | struct strbuf filename = STRBUF_INIT; | |
79 | ||
80 | strbuf_addstr(&filename, path); | |
81 | if (!(flags & LOCK_NO_DEREF)) | |
82 | resolve_symlink(&filename); | |
83 | ||
84 | strbuf_addstr(&filename, LOCK_SUFFIX); | |
85 | lk->tempfile = create_tempfile_mode(filename.buf, mode); | |
86 | strbuf_release(&filename); | |
87 | return lk->tempfile ? lk->tempfile->fd : -1; | |
88 | } | |
89 | ||
90 | /* | |
91 | * Constants defining the gaps between attempts to lock a file. The | |
92 | * first backoff period is approximately INITIAL_BACKOFF_MS | |
93 | * milliseconds. The longest backoff period is approximately | |
94 | * (BACKOFF_MAX_MULTIPLIER * INITIAL_BACKOFF_MS) milliseconds. | |
95 | */ | |
96 | #define INITIAL_BACKOFF_MS 1L | |
97 | #define BACKOFF_MAX_MULTIPLIER 1000 | |
98 | ||
99 | /* | |
100 | * Try locking path, retrying with quadratic backoff for at least | |
101 | * timeout_ms milliseconds. If timeout_ms is 0, try locking the file | |
102 | * exactly once. If timeout_ms is -1, try indefinitely. | |
103 | */ | |
104 | static int lock_file_timeout(struct lock_file *lk, const char *path, | |
105 | int flags, long timeout_ms, int mode) | |
106 | { | |
107 | int n = 1; | |
108 | int multiplier = 1; | |
109 | long remaining_ms = 0; | |
110 | static int random_initialized = 0; | |
111 | ||
112 | if (timeout_ms == 0) | |
113 | return lock_file(lk, path, flags, mode); | |
114 | ||
115 | if (!random_initialized) { | |
116 | srand((unsigned int)getpid()); | |
117 | random_initialized = 1; | |
118 | } | |
119 | ||
120 | if (timeout_ms > 0) | |
121 | remaining_ms = timeout_ms; | |
122 | ||
123 | while (1) { | |
124 | long backoff_ms, wait_ms; | |
125 | int fd; | |
126 | ||
127 | fd = lock_file(lk, path, flags, mode); | |
128 | ||
129 | if (fd >= 0) | |
130 | return fd; /* success */ | |
131 | else if (errno != EEXIST) | |
132 | return -1; /* failure other than lock held */ | |
133 | else if (timeout_ms > 0 && remaining_ms <= 0) | |
134 | return -1; /* failure due to timeout */ | |
135 | ||
136 | backoff_ms = multiplier * INITIAL_BACKOFF_MS; | |
137 | /* back off for between 0.75*backoff_ms and 1.25*backoff_ms */ | |
138 | wait_ms = (750 + rand() % 500) * backoff_ms / 1000; | |
139 | sleep_millisec(wait_ms); | |
140 | remaining_ms -= wait_ms; | |
141 | ||
142 | /* Recursion: (n+1)^2 = n^2 + 2n + 1 */ | |
143 | multiplier += 2*n + 1; | |
144 | if (multiplier > BACKOFF_MAX_MULTIPLIER) | |
145 | multiplier = BACKOFF_MAX_MULTIPLIER; | |
146 | else | |
147 | n++; | |
148 | } | |
149 | } | |
150 | ||
151 | void unable_to_lock_message(const char *path, int err, struct strbuf *buf) | |
152 | { | |
153 | if (err == EEXIST) { | |
154 | strbuf_addf(buf, _("Unable to create '%s.lock': %s.\n\n" | |
155 | "Another git process seems to be running in this repository, e.g.\n" | |
156 | "an editor opened by 'git commit'. Please make sure all processes\n" | |
157 | "are terminated then try again. If it still fails, a git process\n" | |
158 | "may have crashed in this repository earlier:\n" | |
159 | "remove the file manually to continue."), | |
160 | absolute_path(path), strerror(err)); | |
161 | } else | |
162 | strbuf_addf(buf, _("Unable to create '%s.lock': %s"), | |
163 | absolute_path(path), strerror(err)); | |
164 | } | |
165 | ||
166 | NORETURN void unable_to_lock_die(const char *path, int err) | |
167 | { | |
168 | struct strbuf buf = STRBUF_INIT; | |
169 | ||
170 | unable_to_lock_message(path, err, &buf); | |
171 | die("%s", buf.buf); | |
172 | } | |
173 | ||
174 | /* This should return a meaningful errno on failure */ | |
175 | int hold_lock_file_for_update_timeout_mode(struct lock_file *lk, | |
176 | const char *path, int flags, | |
177 | long timeout_ms, int mode) | |
178 | { | |
179 | int fd = lock_file_timeout(lk, path, flags, timeout_ms, mode); | |
180 | if (fd < 0) { | |
181 | if (flags & LOCK_DIE_ON_ERROR) | |
182 | unable_to_lock_die(path, errno); | |
183 | if (flags & LOCK_REPORT_ON_ERROR) { | |
184 | struct strbuf buf = STRBUF_INIT; | |
185 | unable_to_lock_message(path, errno, &buf); | |
186 | error("%s", buf.buf); | |
187 | strbuf_release(&buf); | |
188 | } | |
189 | } | |
190 | return fd; | |
191 | } | |
192 | ||
193 | char *get_locked_file_path(struct lock_file *lk) | |
194 | { | |
195 | struct strbuf ret = STRBUF_INIT; | |
196 | ||
197 | strbuf_addstr(&ret, get_tempfile_path(lk->tempfile)); | |
198 | if (ret.len <= LOCK_SUFFIX_LEN || | |
199 | strcmp(ret.buf + ret.len - LOCK_SUFFIX_LEN, LOCK_SUFFIX)) | |
200 | BUG("get_locked_file_path() called for malformed lock object"); | |
201 | /* remove ".lock": */ | |
202 | strbuf_setlen(&ret, ret.len - LOCK_SUFFIX_LEN); | |
203 | return strbuf_detach(&ret, NULL); | |
204 | } | |
205 | ||
206 | int commit_lock_file(struct lock_file *lk) | |
207 | { | |
208 | char *result_path = get_locked_file_path(lk); | |
209 | ||
210 | if (commit_lock_file_to(lk, result_path)) { | |
211 | int save_errno = errno; | |
212 | free(result_path); | |
213 | errno = save_errno; | |
214 | return -1; | |
215 | } | |
216 | free(result_path); | |
217 | return 0; | |
218 | } |