Merge branch 'jk/trace-stdin' into HEAD

* jk/trace-stdin:
  run-command config experiment
  trace: add GIT_TRACE_STDIN
  trace: add pid to each output line
  trace: implement %p placeholder for filenames

Author: peff

Documentation/git.adoc

@@ -804,7 +804,8 @@ trace messages into this file descriptor.
 Alternatively, if the variable is set to an absolute path
 (starting with a '/' character), Git will interpret this
 as a file path and will try to append the trace messages
-to it.
+to it. If the filename contains the string `%p`, that string
+will be replaced with the PID of the traced process.
 +
 Unsetting the variable, or setting it to empty, "0" or
 "false" (case insensitive) disables trace messages.

git.c

@@ -913,6 +913,65 @@ static int run_argv(struct strvec *args)
 	return done_alias;
 }
 
+static int copy_stdin(int in, int out, void *data)
+{
+	struct trace_key *key = data;
+	while (1) {
+		char buf[8192];
+		ssize_t len = xread(in, buf, sizeof(buf));
+		if (!len)
+			break;
+		if (len < 0) {
+			warning("error reading stdin trace: %s",
+				strerror(errno));
+			break;
+		}
+
+		trace_verbatim(key, buf, len);
+		if (write_in_full(out, buf, len) < 0) {
+			warning("error writing stdin trace: %s",
+				strerror(errno));
+			break;
+		}
+	}
+	close(in);
+	close(out);
+	return 0;
+}
+
+static void trace_stdin(void)
+{
+	static struct trace_key key = TRACE_KEY_INIT(STDIN);
+	static struct async async;
+
+	if (!trace_want(&key))
+		return;
+
+	memset(&async, 0, sizeof(async));
+	async.proc = copy_stdin;
+	async.data = &key;
+	async.in = dup(0);
+	async.out = -1;
+
+	if (async.in < 0 || start_async(&async) < 0) {
+		warning("unable to trace stdin: %s", strerror(errno));
+		return ;
+	}
+
+	/*
+	 * At this point we've handed stdin off to the async process,
+	 * so there we are past the point of no return.
+	 */
+	if (dup2(async.out, 0))
+		die_errno("unable to redirect stdin from async process");
+	close(async.out);
+
+	/*
+	 * leak async; we would know to finish_async() only when we are
+	 * exiting, and there is no point then
+	 */
+}
+
 int cmd_main(int argc, const char **argv)
 {
 	struct strvec args = STRVEC_INIT;
@@ -929,6 +988,7 @@ int cmd_main(int argc, const char **argv)
 	}
 
 	trace_command_performance(argv);
+	trace_stdin();
 
 	/*
 	 * "git-xxxx" is the same as "git xxxx", but we obviously:

run-command.c

@@ -680,6 +680,9 @@ int start_command(struct child_process *cmd)
 	int failed_errno;
 	const char *str;
 
+	if (cmd->git_cmd)
+		trace_config_for(NULL, cmd->args.v[0], &cmd->env);
+
 	/*
 	 * In case of errors we must keep the promise to close FDs
 	 * that have been passed in via ->in and ->out.

trace.c

@@ -29,6 +29,8 @@
 #include "quote.h"
 #include "setup.h"
 #include "trace.h"
+#include "strvec.h"
+#include "config.h"
 
 struct trace_key trace_default_key = { "GIT_TRACE", 0, 0, 0 };
 struct trace_key trace_perf_key = TRACE_KEY_INIT(PERFORMANCE);
@@ -53,15 +55,28 @@ static int get_trace_fd(struct trace_key *key, const char *override_envvar)
 	else if (strlen(trace) == 1 && isdigit(*trace))
 		key->fd = atoi(trace);
 	else if (is_absolute_path(trace)) {
-		int fd = open(trace, O_WRONLY | O_APPEND | O_CREAT, 0666);
+		struct strbuf name = STRBUF_INIT;
+		int fd;
+
+		while (strbuf_expand_step(&name, &trace)) {
+			if (skip_prefix(trace, "%", &trace))
+				strbuf_addch(&name, '%');
+			else if (skip_prefix(trace, "p", &trace))
+				strbuf_addf(&name, "%lu", (unsigned long)getpid());
+			else
+				strbuf_addch(&name, '%');
+		}
+
+		fd = open(name.buf, O_WRONLY | O_APPEND | O_CREAT, 0666);
 		if (fd == -1) {
 			warning("could not open '%s' for tracing: %s",
-				trace, strerror(errno));
+				name.buf, strerror(errno));
 			trace_disable(key);
 		} else {
 			key->fd = fd;
 			key->need_close = 1;
 		}
+		strbuf_release(&name);
 	} else {
 		warning("unknown trace value for '%s': %s\n"
 			"         If you want to trace into a file, then please set %s\n"
@@ -116,8 +131,9 @@ static int prepare_trace_line(const char *file, int line,
 	localtime_r(&secs, &tm);
 	strbuf_addf(buf, "%02d:%02d:%02d.%06ld %s:%d", tm.tm_hour, tm.tm_min,
 		    tm.tm_sec, (long) tv.tv_usec, file, line);
-	/* align trace output (column 40 catches most files names in git) */
-	while (buf->len < 40)
+	strbuf_addf(buf, "[pid=%lu] ", (unsigned long)getpid());
+	/* align trace output (column 50 catches most files names in git) */
+	while (buf->len < 50)
 		strbuf_addch(buf, ' ');
 
 	return 1;
@@ -428,3 +444,47 @@ void trace_command_performance(const char **argv)
 	sq_quote_argv_pretty(&command_line, argv);
 	trace_performance_enter();
 }
+
+struct trace_config_data {
+	const char *want_cmd;
+	struct strvec *out;
+};
+
+static int trace_config_cb(const char *var, const char *value,
+			   const struct config_context *ctx UNUSED, void *vdata)
+{
+	struct trace_config_data *data = vdata;
+	const char *have_cmd, *key;
+	size_t have_len;
+
+	if (!parse_config_key(var, "trace", &have_cmd, &have_len, &key) &&
+	    have_cmd &&
+	    !strncmp(data->want_cmd, have_cmd, have_len) &&
+	    data->want_cmd[have_len] == '\0') {
+		struct strbuf buf = STRBUF_INIT;
+
+		strbuf_addstr(&buf, "GIT_TRACE_");
+		while (*key)
+			strbuf_addch(&buf, toupper(*key++));
+
+		/*
+		 * Environment always takes precedence over config, so do not
+		 * override existing variables. We cannot rely on setenv()'s
+		 * overwrite flag here, because we may pass the list off to
+		 * a spawn() implementation, which always overwrites.
+		 */
+		if (!getenv(buf.buf))
+			strvec_pushf(data->out, "%s=%s", buf.buf, value);
+
+		strbuf_release(&buf);
+	}
+	return 0;
+}
+
+void trace_config_for(struct repository *r, const char *cmd, struct strvec *out)
+{
+	struct trace_config_data data;
+	data.want_cmd = cmd;
+	data.out = out;
+	repo_config(r, trace_config_cb, &data);
+}

trace.h

@@ -3,6 +3,9 @@
 
 #include "strbuf.h"
 
+struct repository;
+struct strvec;
+
 /**
  * The trace API can be used to print debug messages to stderr or a file. Trace
  * code is inactive unless explicitly enabled by setting `GIT_TRACE*` environment
@@ -127,6 +130,13 @@ void trace_command_performance(const char **argv);
 void trace_verbatim(struct trace_key *key, const void *buf, unsigned len);
 uint64_t trace_performance_enter(void);
 
+/**
+ * Load any trace-related config for git command "cmd", and insert the matching
+ * environment variables into "out", which is suitable for use by run-command
+ * and friends.
+ */
+void trace_config_for(struct repository *r, const char *cmd, struct strvec *out);
+
 /*
  * TRACE_CONTEXT may be set to __FUNCTION__ if the compiler supports it. The
  * default is __FILE__, as it is consistent with assert(), and static function