🌐 AI搜索 & 代理 主页
Google Git
Sign in
chromium / external / github.com / git / git / refs/tags/v2.35.6 / . / usage.c
blob: 9943dd8742e8adb2d283be453d7cb9da478a0a7e [file] [log] [blame]
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]1/*
2 * GIT - The information manager from hell
3 *
4 * Copyright (C) Linus Torvalds, 2005
5 */
Junio C Hamano4050c0d2005-12-05 19:54:29[diff] [blame]6#include "git-compat-util.h"
Clemens Buchacher3bc41812011-07-27 21:32:34[diff] [blame]7#include "cache.h"
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]8
Ævar Arnfjörð Bjarmasonf5c39c32021-12-07 18:26:34[diff] [blame]9static void vreportf(const char *prefix, const char *err, va_list params)
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]10{
Jeff Kingb5a9e432017-01-11 14:02:03[diff] [blame]11 char msg[4096];
Johannes Schindelin116d1fa2019-10-30 10:44:36[diff] [blame]12 char *p, *pend = msg + sizeof(msg);
13 size_t prefix_len = strlen(prefix);
Jeff Kingf4c3edc2015-08-11 18:13:59[diff] [blame]14
Johannes Schindelin116d1fa2019-10-30 10:44:36[diff] [blame]15 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 14:02:23[diff] [blame]25 if (iscntrl(*p) && *p != '\t' && *p != '\n')
26 *p = '?';
Jeff Kingf4c3edc2015-08-11 18:13:59[diff] [blame]27 }
Johannes Schindelin116d1fa2019-10-30 10:44:36[diff] [blame]28
29 *(p++) = '\n'; /* we no longer need a NUL */
30 fflush(stderr);
31 write_in_full(2, msg, p - msg);
Clemens Buchacher3bc41812011-07-27 21:32:34[diff] [blame]32}
33
Jonathan Nieder64b1cb72009-11-09 15:05:02[diff] [blame]34static NORETURN void usage_builtin(const char *err, va_list params)
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]35{
Johannes Sixtebaa79f2010-03-06 15:40:39[diff] [blame]36 vreportf("usage: ", err, params);
Jeff Hostetleree4512e2019-02-22 22:25:01[diff] [blame]37
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 20:24:27[diff] [blame]55 exit(129);
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]56}
57
Ævar Arnfjörð Bjarmason18568ee2021-12-07 18:26:29[diff] [blame]58static void die_message_builtin(const char *err, va_list params)
59{
60 trace2_cmd_error_va(err, params);
61 vreportf("fatal: ", err, params);
62}
63
Ævar Arnfjörð Bjarmasonc00c7382021-04-13 09:08:19[diff] [blame]64/*
65 * We call trace2_cmd_error_va() in the below functions first and
66 * expect it to va_copy 'params' before using it (because an 'ap' can
67 * only be walked once).
68 */
Junio C Hamanoce88ac52006-06-24 05:44:33[diff] [blame]69static NORETURN void die_builtin(const char *err, va_list params)
Petr Baudis39a3f5e2006-06-24 02:34:38[diff] [blame]70{
Ævar Arnfjörð Bjarmason18568ee2021-12-07 18:26:29[diff] [blame]71 report_fn die_message_fn = get_die_message_routine();
Jeff Hostetleree4512e2019-02-22 22:25:01[diff] [blame]72
Ævar Arnfjörð Bjarmason18568ee2021-12-07 18:26:29[diff] [blame]73 die_message_fn(err, params);
Petr Baudis39a3f5e2006-06-24 02:34:38[diff] [blame]74 exit(128);
75}
76
Junio C Hamanoce88ac52006-06-24 05:44:33[diff] [blame]77static void error_builtin(const char *err, va_list params)
Petr Baudis39a3f5e2006-06-24 02:34:38[diff] [blame]78{
Jeff Hostetleree4512e2019-02-22 22:25:01[diff] [blame]79 trace2_cmd_error_va(err, params);
80
Johannes Sixtebaa79f2010-03-06 15:40:39[diff] [blame]81 vreportf("error: ", err, params);
Petr Baudis39a3f5e2006-06-24 02:34:38[diff] [blame]82}
83
Shawn O. Pearcefa39b6b2006-12-22 00:48:32[diff] [blame]84static void warn_builtin(const char *warn, va_list params)
85{
Jonathan Tan0ee10fd2020-11-23 20:45:22[diff] [blame]86 trace2_cmd_error_va(warn, params);
87
Johannes Sixtebaa79f2010-03-06 15:40:39[diff] [blame]88 vreportf("warning: ", warn, params);
Shawn O. Pearcefa39b6b2006-12-22 00:48:32[diff] [blame]89}
Petr Baudis39a3f5e2006-06-24 02:34:38[diff] [blame]90
Jeff Kingc19a4902013-04-16 19:46:22[diff] [blame]91static int die_is_recursing_builtin(void)
92{
93 static int dying;
Ævar Arnfjörð Bjarmason2d3c02f2017-06-21 20:47:42[diff] [blame]94 /*
95 * Just an arbitrary number X where "a < x < b" where "a" is
96 * "maximum number of pthreads we'll ever plausibly spawn" and
97 * "b" is "something less than Inf", since the point is to
98 * prevent infinite recursion.
99 */
100 static const int recursion_limit = 1024;
101
102 dying++;
103 if (dying > recursion_limit) {
104 return 1;
105 } else if (dying == 2) {
106 warning("die() called many times. Recursion error or racy threaded death!");
107 return 0;
108 } else {
109 return 0;
110 }
Jeff Kingc19a4902013-04-16 19:46:22[diff] [blame]111}
112
Petr Baudis39a3f5e2006-06-24 02:34:38[diff] [blame]113/* If we are in a dlopen()ed .so write to a global variable would segfault
114 * (ugh), so keep things static. */
Jeff King5710dcc2020-10-15 19:30:04[diff] [blame]115static NORETURN_PTR report_fn usage_routine = usage_builtin;
116static NORETURN_PTR report_fn die_routine = die_builtin;
Ævar Arnfjörð Bjarmason18568ee2021-12-07 18:26:29[diff] [blame]117static report_fn die_message_routine = die_message_builtin;
Jeff King5710dcc2020-10-15 19:30:04[diff] [blame]118static report_fn error_routine = error_builtin;
119static report_fn warn_routine = warn_builtin;
Jeff Kingc19a4902013-04-16 19:46:22[diff] [blame]120static int (*die_is_recursing)(void) = die_is_recursing_builtin;
Petr Baudis39a3f5e2006-06-24 02:34:38[diff] [blame]121
Jeff King5710dcc2020-10-15 19:30:04[diff] [blame]122void set_die_routine(NORETURN_PTR report_fn routine)
Petr Baudis39a3f5e2006-06-24 02:34:38[diff] [blame]123{
124 die_routine = routine;
125}
126
Ævar Arnfjörð Bjarmason18568ee2021-12-07 18:26:29[diff] [blame]127report_fn get_die_message_routine(void)
128{
129 return die_message_routine;
130}
131
Jeff King5710dcc2020-10-15 19:30:04[diff] [blame]132void set_error_routine(report_fn routine)
Clemens Buchacher3bc41812011-07-27 21:32:34[diff] [blame]133{
134 error_routine = routine;
135}
136
Jeff King5710dcc2020-10-15 19:30:04[diff] [blame]137report_fn get_error_routine(void)
Christian Couder725149b2016-09-04 20:18:28[diff] [blame]138{
139 return error_routine;
140}
141
Jeff King5710dcc2020-10-15 19:30:04[diff] [blame]142void set_warn_routine(report_fn routine)
Christian Couderb83f1082016-09-04 20:18:27[diff] [blame]143{
144 warn_routine = routine;
145}
146
Jeff King5710dcc2020-10-15 19:30:04[diff] [blame]147report_fn get_warn_routine(void)
Christian Couder725149b2016-09-04 20:18:28[diff] [blame]148{
149 return warn_routine;
150}
151
Jeff Kingc19a4902013-04-16 19:46:22[diff] [blame]152void set_die_is_recursing_routine(int (*routine)(void))
153{
154 die_is_recursing = routine;
155}
156
Stephen Boydc2e86ad2011-03-22 07:51:05[diff] [blame]157void NORETURN usagef(const char *err, ...)
Jonathan Nieder64b1cb72009-11-09 15:05:02[diff] [blame]158{
159 va_list params;
160
161 va_start(params, err);
162 usage_routine(err, params);
163 va_end(params);
164}
165
Stephen Boydc2e86ad2011-03-22 07:51:05[diff] [blame]166void NORETURN usage(const char *err)
Petr Baudis39a3f5e2006-06-24 02:34:38[diff] [blame]167{
Jonathan Nieder64b1cb72009-11-09 15:05:02[diff] [blame]168 usagef("%s", err);
Petr Baudis39a3f5e2006-06-24 02:34:38[diff] [blame]169}
170
Stephen Boydc2e86ad2011-03-22 07:51:05[diff] [blame]171void NORETURN die(const char *err, ...)
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]172{
173 va_list params;
174
Jeff Kingc19a4902013-04-16 19:46:22[diff] [blame]175 if (die_is_recursing()) {
Brandon Caseycd163d42012-11-15 01:45:52[diff] [blame]176 fputs("fatal: recursion detected in die handler\n", stderr);
177 exit(128);
178 }
Brandon Caseycd163d42012-11-15 01:45:52[diff] [blame]179
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]180 va_start(params, err);
Petr Baudis39a3f5e2006-06-24 02:34:38[diff] [blame]181 die_routine(err, params);
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]182 va_end(params);
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]183}
184
Nguyễn Thái Ngọc Duy58e4e512016-05-08 09:47:21[diff] [blame]185static const char *fmt_with_err(char *buf, int n, const char *fmt)
Thomas Rastb8750362009-06-27 15:58:44[diff] [blame]186{
Junio C Hamanof8b5a8e2009-06-27 15:58:45[diff] [blame]187 char str_error[256], *err;
188 int i, j;
Thomas Rastb8750362009-06-27 15:58:44[diff] [blame]189
Junio C Hamanof8b5a8e2009-06-27 15:58:45[diff] [blame]190 err = strerror(errno);
191 for (i = j = 0; err[i] && j < sizeof(str_error) - 1; ) {
192 if ((str_error[j++] = err[i++]) != '%')
193 continue;
194 if (j < sizeof(str_error) - 1) {
195 str_error[j++] = '%';
196 } else {
197 /* No room to double the '%', so we overwrite it with
198 * '\0' below */
199 j--;
200 break;
201 }
202 }
203 str_error[j] = 0;
Jeff Kingac4896f2018-05-19 01:58:44[diff] [blame]204 /* Truncation is acceptable here */
Nguyễn Thái Ngọc Duy58e4e512016-05-08 09:47:21[diff] [blame]205 snprintf(buf, n, "%s: %s", fmt, str_error);
206 return buf;
207}
208
209void NORETURN die_errno(const char *fmt, ...)
210{
211 char buf[1024];
212 va_list params;
213
214 if (die_is_recursing()) {
215 fputs("fatal: recursion detected in die_errno handler\n",
216 stderr);
217 exit(128);
218 }
Thomas Rastb8750362009-06-27 15:58:44[diff] [blame]219
220 va_start(params, fmt);
Nguyễn Thái Ngọc Duy58e4e512016-05-08 09:47:21[diff] [blame]221 die_routine(fmt_with_err(buf, sizeof(buf), fmt), params);
Thomas Rastb8750362009-06-27 15:58:44[diff] [blame]222 va_end(params);
223}
224
Ævar Arnfjörð Bjarmason18568ee2021-12-07 18:26:29[diff] [blame]225#undef die_message
226int die_message(const char *err, ...)
227{
228 va_list params;
229
230 va_start(params, err);
231 die_message_routine(err, params);
232 va_end(params);
233 return 128;
234}
235
Ævar Arnfjörð Bjarmason24f6e6d2021-12-07 18:26:33[diff] [blame]236#undef die_message_errno
237int die_message_errno(const char *fmt, ...)
238{
239 char buf[1024];
240 va_list params;
241
242 va_start(params, fmt);
243 die_message_routine(fmt_with_err(buf, sizeof(buf), fmt), params);
244 va_end(params);
245 return 128;
246}
247
Jeff King4df5e912016-08-31 03:41:22[diff] [blame]248#undef error_errno
Nguyễn Thái Ngọc Duyfd1d6722016-05-08 09:47:22[diff] [blame]249int error_errno(const char *fmt, ...)
250{
251 char buf[1024];
252 va_list params;
253
254 va_start(params, fmt);
255 error_routine(fmt_with_err(buf, sizeof(buf), fmt), params);
256 va_end(params);
257 return -1;
258}
259
Jeff Kinge208f9c2012-12-15 17:37:36[diff] [blame]260#undef error
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]261int error(const char *err, ...)
262{
263 va_list params;
264
265 va_start(params, err);
Petr Baudis39a3f5e2006-06-24 02:34:38[diff] [blame]266 error_routine(err, params);
Linus Torvalds0fcfd162005-04-18 20:04:43[diff] [blame]267 va_end(params);
268 return -1;
269}
Shawn O. Pearcefa39b6b2006-12-22 00:48:32[diff] [blame]270
Nguyễn Thái Ngọc Duyfd1d6722016-05-08 09:47:22[diff] [blame]271void warning_errno(const char *warn, ...)
272{
273 char buf[1024];
274 va_list params;
275
276 va_start(params, warn);
277 warn_routine(fmt_with_err(buf, sizeof(buf), warn), params);
278 va_end(params);
279}
280
Theodore Ts'o46efd2d2007-03-30 23:07:05[diff] [blame]281void warning(const char *warn, ...)
Shawn O. Pearcefa39b6b2006-12-22 00:48:32[diff] [blame]282{
283 va_list params;
284
285 va_start(params, warn);
286 warn_routine(warn, params);
287 va_end(params);
288}
Jeff Kingd8193742017-05-13 03:28:50[diff] [blame]289
Johannes Schindelina86303c2018-05-02 09:38:28[diff] [blame]290/* Only set this, ever, from t/helper/, when verifying that bugs are caught. */
291int BUG_exit_code;
292
Jeff Kingd8193742017-05-13 03:28:50[diff] [blame]293static NORETURN void BUG_vfl(const char *file, int line, const char *fmt, va_list params)
294{
295 char prefix[256];
Jonathan Tan0a9dde42021-02-05 20:09:08[diff] [blame]296 va_list params_copy;
297 static int in_bug;
298
299 va_copy(params_copy, params);
Jeff Kingd8193742017-05-13 03:28:50[diff] [blame]300
301 /* truncation via snprintf is OK here */
302 if (file)
303 snprintf(prefix, sizeof(prefix), "BUG: %s:%d: ", file, line);
304 else
305 snprintf(prefix, sizeof(prefix), "BUG: ");
306
307 vreportf(prefix, fmt, params);
Jonathan Tan0a9dde42021-02-05 20:09:08[diff] [blame]308
309 if (in_bug)
310 abort();
311 in_bug = 1;
312
313 trace2_cmd_error_va(fmt, params_copy);
314
Johannes Schindelina86303c2018-05-02 09:38:28[diff] [blame]315 if (BUG_exit_code)
316 exit(BUG_exit_code);
Jeff Kingd8193742017-05-13 03:28:50[diff] [blame]317 abort();
318}
319
320#ifdef HAVE_VARIADIC_MACROS
Ramsay Jones3d7dd2d2017-05-21 22:25:39[diff] [blame]321NORETURN void BUG_fl(const char *file, int line, const char *fmt, ...)
Jeff Kingd8193742017-05-13 03:28:50[diff] [blame]322{
323 va_list ap;
324 va_start(ap, fmt);
325 BUG_vfl(file, line, fmt, ap);
326 va_end(ap);
327}
328#else
Ramsay Jones3d7dd2d2017-05-21 22:25:39[diff] [blame]329NORETURN void BUG(const char *fmt, ...)
Jeff Kingd8193742017-05-13 03:28:50[diff] [blame]330{
331 va_list ap;
332 va_start(ap, fmt);
333 BUG_vfl(NULL, 0, fmt, ap);
334 va_end(ap);
335}
336#endif
Jeff King0e5bba52017-09-08 06:38:41[diff] [blame]337
338#ifdef SUPPRESS_ANNOTATED_LEAKS
339void unleak_memory(const void *ptr, size_t len)
340{
341 static struct suppressed_leak_root {
342 struct suppressed_leak_root *next;
343 char data[FLEX_ARRAY];
344 } *suppressed_leaks;
345 struct suppressed_leak_root *root;
346
347 FLEX_ALLOC_MEM(root, data, ptr, len);
348 root->next = suppressed_leaks;
349 suppressed_leaks = root;
350}
351#endif