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