blob: 58fb5fff5f245c33898e27c85296a4a47325c34e [file] [log] [blame]
Linus Torvalds0fcfd162005-04-18 13:04:43 -07001/*
2 * GIT - The information manager from hell
3 *
4 * Copyright (C) Linus Torvalds, 2005
5 */
Junio C Hamano4050c0d2005-12-05 11:54:29 -08006#include "git-compat-util.h"
Clemens Buchacher3bc41812011-07-27 23:32:34 +02007#include "cache.h"
Linus Torvalds0fcfd162005-04-18 13:04:43 -07008
Johannes Sixtebaa79f2010-03-06 16:40:39 +01009void vreportf(const char *prefix, const char *err, va_list params)
Linus Torvalds0fcfd162005-04-18 13:04:43 -070010{
Jeff Kingb5a9e432017-01-11 09:02:03 -050011 char msg[4096];
Johannes Schindelin116d1fa2019-10-30 10:44:36 +000012 char *p, *pend = msg + sizeof(msg);
13 size_t prefix_len = strlen(prefix);
Jeff Kingf4c3edc2015-08-11 14:13:59 -040014
Johannes Schindelin116d1fa2019-10-30 10:44:36 +000015 if (sizeof(msg) <= prefix_len) {
16 fprintf(stderr, "BUG!!! too long a prefix '%s'\n", prefix);
17 abort();
18 }
19 memcpy(msg, prefix, prefix_len);
20 p = msg + prefix_len;
21 if (vsnprintf(p, pend - p, err, params) < 0)
22 *p = '\0'; /* vsnprintf() failed, clip at prefix */
23
24 for (; p != pend - 1 && *p; p++) {
Jeff Kingf2900892017-01-11 09:02:23 -050025 if (iscntrl(*p) && *p != '\t' && *p != '\n')
26 *p = '?';
Jeff Kingf4c3edc2015-08-11 14:13:59 -040027 }
Johannes Schindelin116d1fa2019-10-30 10:44:36 +000028
29 *(p++) = '\n'; /* we no longer need a NUL */
30 fflush(stderr);
31 write_in_full(2, msg, p - msg);
Clemens Buchacher3bc41812011-07-27 23:32:34 +020032}
33
Jonathan Nieder64b1cb72009-11-09 09:05:02 -060034static NORETURN void usage_builtin(const char *err, va_list params)
Linus Torvalds0fcfd162005-04-18 13:04:43 -070035{
Johannes Sixtebaa79f2010-03-06 16:40:39 +010036 vreportf("usage: ", err, params);
Jeff Hostetleree4512e2019-02-22 14:25:01 -080037
38 /*
39 * When we detect a usage error *before* the command dispatch in
40 * cmd_main(), we don't know what verb to report. Force it to this
41 * to facilitate post-processing.
42 */
43 trace2_cmd_name("_usage_");
44
45 /*
46 * Currently, the (err, params) are usually just the static usage
47 * string which isn't very useful here. Usually, the call site
48 * manually calls fprintf(stderr,...) with the actual detailed
49 * syntax error before calling usage().
50 *
51 * TODO It would be nice to update the call sites to pass both
52 * the static usage string and the detailed error message.
53 */
54
Linus Torvalds5d1a5c02005-10-01 13:24:27 -070055 exit(129);
Linus Torvalds0fcfd162005-04-18 13:04:43 -070056}
57
Junio C Hamanoce88ac52006-06-23 22:44:33 -070058static NORETURN void die_builtin(const char *err, va_list params)
Petr Baudis39a3f5e2006-06-24 04:34:38 +020059{
Jeff Hostetleree4512e2019-02-22 14:25:01 -080060 /*
61 * We call this trace2 function first and expect it to va_copy 'params'
62 * before using it (because an 'ap' can only be walked once).
63 */
64 trace2_cmd_error_va(err, params);
65
Johannes Sixtebaa79f2010-03-06 16:40:39 +010066 vreportf("fatal: ", err, params);
Jeff Hostetleree4512e2019-02-22 14:25:01 -080067
Petr Baudis39a3f5e2006-06-24 04:34:38 +020068 exit(128);
69}
70
Junio C Hamanoce88ac52006-06-23 22:44:33 -070071static void error_builtin(const char *err, va_list params)
Petr Baudis39a3f5e2006-06-24 04:34:38 +020072{
Jeff Hostetleree4512e2019-02-22 14:25:01 -080073 /*
74 * We call this trace2 function first and expect it to va_copy 'params'
75 * before using it (because an 'ap' can only be walked once).
76 */
77 trace2_cmd_error_va(err, params);
78
Johannes Sixtebaa79f2010-03-06 16:40:39 +010079 vreportf("error: ", err, params);
Petr Baudis39a3f5e2006-06-24 04:34:38 +020080}
81
Shawn O. Pearcefa39b6b2006-12-21 19:48:32 -050082static void warn_builtin(const char *warn, va_list params)
83{
Johannes Sixtebaa79f2010-03-06 16:40:39 +010084 vreportf("warning: ", warn, params);
Shawn O. Pearcefa39b6b2006-12-21 19:48:32 -050085}
Petr Baudis39a3f5e2006-06-24 04:34:38 +020086
Jeff Kingc19a4902013-04-16 15:46:22 -040087static int die_is_recursing_builtin(void)
88{
89 static int dying;
Ævar Arnfjörð Bjarmason2d3c02f2017-06-21 20:47:42 +000090 /*
91 * Just an arbitrary number X where "a < x < b" where "a" is
92 * "maximum number of pthreads we'll ever plausibly spawn" and
93 * "b" is "something less than Inf", since the point is to
94 * prevent infinite recursion.
95 */
96 static const int recursion_limit = 1024;
97
98 dying++;
99 if (dying > recursion_limit) {
100 return 1;
101 } else if (dying == 2) {
102 warning("die() called many times. Recursion error or racy threaded death!");
103 return 0;
104 } else {
105 return 0;
106 }
Jeff Kingc19a4902013-04-16 15:46:22 -0400107}
108
Petr Baudis39a3f5e2006-06-24 04:34:38 +0200109/* If we are in a dlopen()ed .so write to a global variable would segfault
110 * (ugh), so keep things static. */
Jonathan Nieder64b1cb72009-11-09 09:05:02 -0600111static NORETURN_PTR void (*usage_routine)(const char *err, va_list params) = usage_builtin;
Erik Faye-Lund18660bc2009-09-30 18:05:50 +0000112static NORETURN_PTR void (*die_routine)(const char *err, va_list params) = die_builtin;
Petr Baudis39a3f5e2006-06-24 04:34:38 +0200113static void (*error_routine)(const char *err, va_list params) = error_builtin;
Shawn O. Pearcefa39b6b2006-12-21 19:48:32 -0500114static void (*warn_routine)(const char *err, va_list params) = warn_builtin;
Jeff Kingc19a4902013-04-16 15:46:22 -0400115static int (*die_is_recursing)(void) = die_is_recursing_builtin;
Petr Baudis39a3f5e2006-06-24 04:34:38 +0200116
Erik Faye-Lund18660bc2009-09-30 18:05:50 +0000117void set_die_routine(NORETURN_PTR void (*routine)(const char *err, va_list params))
Petr Baudis39a3f5e2006-06-24 04:34:38 +0200118{
119 die_routine = routine;
120}
121
Clemens Buchacher3bc41812011-07-27 23:32:34 +0200122void set_error_routine(void (*routine)(const char *err, va_list params))
123{
124 error_routine = routine;
125}
126
Christian Couder725149b2016-09-04 22:18:28 +0200127void (*get_error_routine(void))(const char *err, va_list params)
128{
129 return error_routine;
130}
131
Christian Couderb83f1082016-09-04 22:18:27 +0200132void set_warn_routine(void (*routine)(const char *warn, va_list params))
133{
134 warn_routine = routine;
135}
136
Christian Couder725149b2016-09-04 22:18:28 +0200137void (*get_warn_routine(void))(const char *warn, va_list params)
138{
139 return warn_routine;
140}
141
Jeff Kingc19a4902013-04-16 15:46:22 -0400142void set_die_is_recursing_routine(int (*routine)(void))
143{
144 die_is_recursing = routine;
145}
146
Stephen Boydc2e86ad2011-03-22 00:51:05 -0700147void NORETURN usagef(const char *err, ...)
Jonathan Nieder64b1cb72009-11-09 09:05:02 -0600148{
149 va_list params;
150
151 va_start(params, err);
152 usage_routine(err, params);
153 va_end(params);
154}
155
Stephen Boydc2e86ad2011-03-22 00:51:05 -0700156void NORETURN usage(const char *err)
Petr Baudis39a3f5e2006-06-24 04:34:38 +0200157{
Jonathan Nieder64b1cb72009-11-09 09:05:02 -0600158 usagef("%s", err);
Petr Baudis39a3f5e2006-06-24 04:34:38 +0200159}
160
Stephen Boydc2e86ad2011-03-22 00:51:05 -0700161void NORETURN die(const char *err, ...)
Linus Torvalds0fcfd162005-04-18 13:04:43 -0700162{
163 va_list params;
164
Jeff Kingc19a4902013-04-16 15:46:22 -0400165 if (die_is_recursing()) {
Brandon Caseycd163d42012-11-14 17:45:52 -0800166 fputs("fatal: recursion detected in die handler\n", stderr);
167 exit(128);
168 }
Brandon Caseycd163d42012-11-14 17:45:52 -0800169
Linus Torvalds0fcfd162005-04-18 13:04:43 -0700170 va_start(params, err);
Petr Baudis39a3f5e2006-06-24 04:34:38 +0200171 die_routine(err, params);
Linus Torvalds0fcfd162005-04-18 13:04:43 -0700172 va_end(params);
Linus Torvalds0fcfd162005-04-18 13:04:43 -0700173}
174
Nguyễn Thái Ngọc Duy58e4e512016-05-08 16:47:21 +0700175static const char *fmt_with_err(char *buf, int n, const char *fmt)
Thomas Rastb8750362009-06-27 17:58:44 +0200176{
Junio C Hamanof8b5a8e2009-06-27 17:58:45 +0200177 char str_error[256], *err;
178 int i, j;
Thomas Rastb8750362009-06-27 17:58:44 +0200179
Junio C Hamanof8b5a8e2009-06-27 17:58:45 +0200180 err = strerror(errno);
181 for (i = j = 0; err[i] && j < sizeof(str_error) - 1; ) {
182 if ((str_error[j++] = err[i++]) != '%')
183 continue;
184 if (j < sizeof(str_error) - 1) {
185 str_error[j++] = '%';
186 } else {
187 /* No room to double the '%', so we overwrite it with
188 * '\0' below */
189 j--;
190 break;
191 }
192 }
193 str_error[j] = 0;
Jeff Kingac4896f2018-05-18 18:58:44 -0700194 /* Truncation is acceptable here */
Nguyễn Thái Ngọc Duy58e4e512016-05-08 16:47:21 +0700195 snprintf(buf, n, "%s: %s", fmt, str_error);
196 return buf;
197}
198
199void NORETURN die_errno(const char *fmt, ...)
200{
201 char buf[1024];
202 va_list params;
203
204 if (die_is_recursing()) {
205 fputs("fatal: recursion detected in die_errno handler\n",
206 stderr);
207 exit(128);
208 }
Thomas Rastb8750362009-06-27 17:58:44 +0200209
210 va_start(params, fmt);
Nguyễn Thái Ngọc Duy58e4e512016-05-08 16:47:21 +0700211 die_routine(fmt_with_err(buf, sizeof(buf), fmt), params);
Thomas Rastb8750362009-06-27 17:58:44 +0200212 va_end(params);
213}
214
Jeff King4df5e912016-08-30 23:41:22 -0400215#undef error_errno
Nguyễn Thái Ngọc Duyfd1d6722016-05-08 16:47:22 +0700216int error_errno(const char *fmt, ...)
217{
218 char buf[1024];
219 va_list params;
220
221 va_start(params, fmt);
222 error_routine(fmt_with_err(buf, sizeof(buf), fmt), params);
223 va_end(params);
224 return -1;
225}
226
Jeff Kinge208f9c2012-12-15 12:37:36 -0500227#undef error
Linus Torvalds0fcfd162005-04-18 13:04:43 -0700228int error(const char *err, ...)
229{
230 va_list params;
231
232 va_start(params, err);
Petr Baudis39a3f5e2006-06-24 04:34:38 +0200233 error_routine(err, params);
Linus Torvalds0fcfd162005-04-18 13:04:43 -0700234 va_end(params);
235 return -1;
236}
Shawn O. Pearcefa39b6b2006-12-21 19:48:32 -0500237
Nguyễn Thái Ngọc Duyfd1d6722016-05-08 16:47:22 +0700238void warning_errno(const char *warn, ...)
239{
240 char buf[1024];
241 va_list params;
242
243 va_start(params, warn);
244 warn_routine(fmt_with_err(buf, sizeof(buf), warn), params);
245 va_end(params);
246}
247
Theodore Ts'o46efd2d2007-03-30 19:07:05 -0400248void warning(const char *warn, ...)
Shawn O. Pearcefa39b6b2006-12-21 19:48:32 -0500249{
250 va_list params;
251
252 va_start(params, warn);
253 warn_routine(warn, params);
254 va_end(params);
255}
Jeff Kingd8193742017-05-12 23:28:50 -0400256
Johannes Schindelina86303c2018-05-02 11:38:28 +0200257/* Only set this, ever, from t/helper/, when verifying that bugs are caught. */
258int BUG_exit_code;
259
Jeff Kingd8193742017-05-12 23:28:50 -0400260static NORETURN void BUG_vfl(const char *file, int line, const char *fmt, va_list params)
261{
262 char prefix[256];
263
264 /* truncation via snprintf is OK here */
265 if (file)
266 snprintf(prefix, sizeof(prefix), "BUG: %s:%d: ", file, line);
267 else
268 snprintf(prefix, sizeof(prefix), "BUG: ");
269
270 vreportf(prefix, fmt, params);
Johannes Schindelina86303c2018-05-02 11:38:28 +0200271 if (BUG_exit_code)
272 exit(BUG_exit_code);
Jeff Kingd8193742017-05-12 23:28:50 -0400273 abort();
274}
275
276#ifdef HAVE_VARIADIC_MACROS
Ramsay Jones3d7dd2d2017-05-21 23:25:39 +0100277NORETURN void BUG_fl(const char *file, int line, const char *fmt, ...)
Jeff Kingd8193742017-05-12 23:28:50 -0400278{
279 va_list ap;
280 va_start(ap, fmt);
281 BUG_vfl(file, line, fmt, ap);
282 va_end(ap);
283}
284#else
Ramsay Jones3d7dd2d2017-05-21 23:25:39 +0100285NORETURN void BUG(const char *fmt, ...)
Jeff Kingd8193742017-05-12 23:28:50 -0400286{
287 va_list ap;
288 va_start(ap, fmt);
289 BUG_vfl(NULL, 0, fmt, ap);
290 va_end(ap);
291}
292#endif
Jeff King0e5bba52017-09-08 02:38:41 -0400293
294#ifdef SUPPRESS_ANNOTATED_LEAKS
295void unleak_memory(const void *ptr, size_t len)
296{
297 static struct suppressed_leak_root {
298 struct suppressed_leak_root *next;
299 char data[FLEX_ARRAY];
300 } *suppressed_leaks;
301 struct suppressed_leak_root *root;
302
303 FLEX_ALLOC_MEM(root, data, ptr, len);
304 root->next = suppressed_leaks;
305 suppressed_leaks = root;
306}
307#endif