2 * GIT - The information manager from hell
4 * Copyright (C) 2000-2002 Michael R. Elkins <me@mutt.org>
5 * Copyright (C) 2002-2004 Oswald Buddenhagen <ossi@users.sf.net>
6 * Copyright (C) 2004 Theodore Y. Ts'o <tytso@mit.edu>
7 * Copyright (C) 2006 Mike McCormack
8 * Copyright (C) 2006 Christian Couder
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
15 * This program is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 * GNU General Public License for more details.
20 * You should have received a copy of the GNU General Public License
21 * along with this program; if not, see <http://www.gnu.org/licenses/>.
26 #include "environment.h"
30 struct trace_key trace_default_key
= { "GIT_TRACE", 0, 0, 0 };
31 struct trace_key trace_perf_key
= TRACE_KEY_INIT(PERFORMANCE
);
32 struct trace_key trace_setup_key
= TRACE_KEY_INIT(SETUP
);
34 /* Get a trace file descriptor from "key" env variable. */
35 static int get_trace_fd(struct trace_key
*key
, const char *override_envvar
)
39 /* don't open twice */
43 trace
= override_envvar
? override_envvar
: getenv(key
->key
);
45 if (!trace
|| !strcmp(trace
, "") ||
46 !strcmp(trace
, "0") || !strcasecmp(trace
, "false"))
48 else if (!strcmp(trace
, "1") || !strcasecmp(trace
, "true"))
49 key
->fd
= STDERR_FILENO
;
50 else if (strlen(trace
) == 1 && isdigit(*trace
))
51 key
->fd
= atoi(trace
);
52 else if (is_absolute_path(trace
)) {
53 int fd
= open(trace
, O_WRONLY
| O_APPEND
| O_CREAT
, 0666);
55 warning("could not open '%s' for tracing: %s",
56 trace
, strerror(errno
));
63 warning("unknown trace value for '%s': %s\n"
64 " If you want to trace into a file, then please set %s\n"
65 " to an absolute pathname (starting with /)",
66 key
->key
, trace
, key
->key
);
74 void trace_override_envvar(struct trace_key
*key
, const char *value
)
80 * Invoke get_trace_fd() to initialize key using the given value
81 * instead of the value of the environment variable.
83 get_trace_fd(key
, value
);
86 void trace_disable(struct trace_key
*key
)
95 static int prepare_trace_line(const char *file
, int line
,
96 struct trace_key
*key
, struct strbuf
*buf
)
98 static struct trace_key trace_bare
= TRACE_KEY_INIT(BARE
);
103 if (!trace_want(key
))
106 /* unit tests may want to disable additional trace output */
107 if (trace_want(&trace_bare
))
110 /* print current timestamp */
111 gettimeofday(&tv
, NULL
);
113 localtime_r(&secs
, &tm
);
114 strbuf_addf(buf
, "%02d:%02d:%02d.%06ld %s:%d", tm
.tm_hour
, tm
.tm_min
,
115 tm
.tm_sec
, (long) tv
.tv_usec
, file
, line
);
116 /* align trace output (column 40 catches most files names in git) */
117 while (buf
->len
< 40)
118 strbuf_addch(buf
, ' ');
123 static void trace_write(struct trace_key
*key
, const void *buf
, unsigned len
)
125 if (write_in_full(get_trace_fd(key
, NULL
), buf
, len
) < 0) {
126 warning("unable to write trace for %s: %s",
127 key
->key
, strerror(errno
));
132 void trace_verbatim(struct trace_key
*key
, const void *buf
, unsigned len
)
134 if (!trace_want(key
))
136 trace_write(key
, buf
, len
);
139 static void print_trace_line(struct trace_key
*key
, struct strbuf
*buf
)
141 strbuf_complete_line(buf
);
142 trace_write(key
, buf
->buf
, buf
->len
);
145 static void trace_vprintf_fl(const char *file
, int line
, struct trace_key
*key
,
146 const char *format
, va_list ap
)
148 struct strbuf buf
= STRBUF_INIT
;
150 if (!prepare_trace_line(file
, line
, key
, &buf
))
153 strbuf_vaddf(&buf
, format
, ap
);
154 print_trace_line(key
, &buf
);
155 strbuf_release(&buf
);
158 static void trace_argv_vprintf_fl(const char *file
, int line
,
159 const char **argv
, const char *format
,
162 struct strbuf buf
= STRBUF_INIT
;
164 if (!prepare_trace_line(file
, line
, &trace_default_key
, &buf
))
167 strbuf_vaddf(&buf
, format
, ap
);
169 sq_quote_argv_pretty(&buf
, argv
);
170 print_trace_line(&trace_default_key
, &buf
);
171 strbuf_release(&buf
);
174 void trace_strbuf_fl(const char *file
, int line
, struct trace_key
*key
,
175 const struct strbuf
*data
)
177 struct strbuf buf
= STRBUF_INIT
;
179 if (!prepare_trace_line(file
, line
, key
, &buf
))
182 strbuf_addbuf(&buf
, data
);
183 print_trace_line(key
, &buf
);
184 strbuf_release(&buf
);
187 static uint64_t perf_start_times
[10];
188 static int perf_indent
;
190 uint64_t trace_performance_enter(void)
194 if (!trace_want(&trace_perf_key
))
198 perf_start_times
[perf_indent
] = now
;
199 if (perf_indent
+ 1 < ARRAY_SIZE(perf_start_times
))
202 BUG("Too deep indentation");
206 static void trace_performance_vprintf_fl(const char *file
, int line
,
207 uint64_t nanos
, const char *format
,
210 static const char space
[] = " ";
211 struct strbuf buf
= STRBUF_INIT
;
213 if (!prepare_trace_line(file
, line
, &trace_perf_key
, &buf
))
216 strbuf_addf(&buf
, "performance: %.9f s", (double) nanos
/ 1000000000);
218 if (format
&& *format
) {
219 if (perf_indent
>= strlen(space
))
220 BUG("Too deep indentation");
222 strbuf_addf(&buf
, ":%.*s ", perf_indent
, space
);
223 strbuf_vaddf(&buf
, format
, ap
);
226 print_trace_line(&trace_perf_key
, &buf
);
227 strbuf_release(&buf
);
230 void trace_printf_key_fl(const char *file
, int line
, struct trace_key
*key
,
231 const char *format
, ...)
234 va_start(ap
, format
);
235 trace_vprintf_fl(file
, line
, key
, format
, ap
);
239 void trace_argv_printf_fl(const char *file
, int line
, const char **argv
,
240 const char *format
, ...)
243 va_start(ap
, format
);
244 trace_argv_vprintf_fl(file
, line
, argv
, format
, ap
);
248 void trace_performance_fl(const char *file
, int line
, uint64_t nanos
,
249 const char *format
, ...)
252 va_start(ap
, format
);
253 trace_performance_vprintf_fl(file
, line
, nanos
, format
, ap
);
257 void trace_performance_leave_fl(const char *file
, int line
,
258 uint64_t nanos
, const char *format
, ...)
266 if (!format
) /* Allow callers to leave without tracing anything */
269 since
= perf_start_times
[perf_indent
];
270 va_start(ap
, format
);
271 trace_performance_vprintf_fl(file
, line
, nanos
- since
, format
, ap
);
275 static const char *quote_crnl(const char *path
)
277 static struct strbuf new_path
= STRBUF_INIT
;
282 strbuf_reset(&new_path
);
286 case '\\': strbuf_addstr(&new_path
, "\\\\"); break;
287 case '\n': strbuf_addstr(&new_path
, "\\n"); break;
288 case '\r': strbuf_addstr(&new_path
, "\\r"); break;
290 strbuf_addch(&new_path
, *path
);
297 void trace_repo_setup(void)
299 const char *git_work_tree
, *prefix
= startup_info
->prefix
;
302 if (!trace_want(&trace_setup_key
))
307 if (!(git_work_tree
= get_git_work_tree()))
308 git_work_tree
= "(null)";
310 if (!startup_info
->prefix
)
313 trace_printf_key(&trace_setup_key
, "setup: git_dir: %s\n", quote_crnl(get_git_dir()));
314 trace_printf_key(&trace_setup_key
, "setup: git_common_dir: %s\n", quote_crnl(get_git_common_dir()));
315 trace_printf_key(&trace_setup_key
, "setup: worktree: %s\n", quote_crnl(git_work_tree
));
316 trace_printf_key(&trace_setup_key
, "setup: cwd: %s\n", quote_crnl(cwd
));
317 trace_printf_key(&trace_setup_key
, "setup: prefix: %s\n", quote_crnl(prefix
));
322 int trace_want(struct trace_key
*key
)
324 return !!get_trace_fd(key
, NULL
);
327 #if defined(HAVE_CLOCK_GETTIME) && defined(HAVE_CLOCK_MONOTONIC)
329 static inline uint64_t highres_nanos(void)
332 if (clock_gettime(CLOCK_MONOTONIC
, &ts
))
334 return (uint64_t) ts
.tv_sec
* 1000000000 + ts
.tv_nsec
;
337 #elif defined (GIT_WINDOWS_NATIVE)
339 static inline uint64_t highres_nanos(void)
341 static uint64_t high_ns
, scaled_low_ns
;
346 if (!QueryPerformanceFrequency(&cnt
))
349 /* high_ns = number of ns per cnt.HighPart */
350 high_ns
= (1000000000LL << 32) / (uint64_t) cnt
.QuadPart
;
353 * Number of ns per cnt.LowPart is 10^9 / frequency (or
354 * high_ns >> 32). For maximum precision, we scale this factor
355 * so that it just fits within 32 bit (i.e. won't overflow if
356 * multiplied with cnt.LowPart).
358 scaled_low_ns
= high_ns
;
360 while (scaled_low_ns
>= 0x100000000LL
) {
366 /* if QPF worked on initialization, we expect QPC to work as well */
367 QueryPerformanceCounter(&cnt
);
369 return (high_ns
* cnt
.HighPart
) +
370 ((scaled_low_ns
* cnt
.LowPart
) >> scale
);
374 # define highres_nanos() 0
377 static inline uint64_t gettimeofday_nanos(void)
380 gettimeofday(&tv
, NULL
);
381 return (uint64_t) tv
.tv_sec
* 1000000000 + tv
.tv_usec
* 1000;
385 * Returns nanoseconds since the epoch (01/01/1970), for performance tracing
386 * (i.e. favoring high precision over wall clock time accuracy).
388 uint64_t getnanotime(void)
390 static uint64_t offset
;
392 /* initialization succeeded, return offset + high res time */
393 return offset
+ highres_nanos();
394 } else if (offset
== 1) {
395 /* initialization failed, fall back to gettimeofday */
396 return gettimeofday_nanos();
398 /* initialize offset if high resolution timer works */
399 uint64_t now
= gettimeofday_nanos();
400 uint64_t highres
= highres_nanos();
402 offset
= now
- highres
;
409 static struct strbuf command_line
= STRBUF_INIT
;
411 static void print_command_performance_atexit(void)
413 trace_performance_leave("git command:%s", command_line
.buf
);
416 void trace_command_performance(const char **argv
)
418 if (!trace_want(&trace_perf_key
))
421 if (!command_line
.len
)
422 atexit(print_command_performance_atexit
);
424 strbuf_reset(&command_line
);
425 sq_quote_argv_pretty(&command_line
, argv
);
426 trace_performance_enter();