tree ba8be232f44e80eac8a9047f9bbb87fae6b346c1
parent 6a6c0f10a70a6eb101c213b09ae82a9cad252743
author Derrick Stolee <dstolee@microsoft.com> 1557517466 -0700
committer Junio C Hamano <gitster@pobox.com> 1557755642 +0900

trace2: add variable description to git.txt

Documentation/technical/api-trace2.txt contains the full details
of the trace2 API and the GIT_TR2* environment variables. However,
most environment variables are included in Documentation/git.txt,
including the GIT_TRACE* variables.

Add a brief description of the GIT_TR2* variables with links to
the full technical details. The biggest difference from the
original variables is that we can specify a Unix Domain Socket.
Mention this difference, but leave the details to the technical
documents.

Reported-by: Szeder Gábor <szeder.dev@gmail.com>
Signed-off-by: Derrick Stolee <dstolee@microsoft.com>
Signed-off-by: Junio C Hamano <gitster@pobox.com>
