Re: [PATCH v1] common-main.c: call exit(), don't return

[Junio C Hamano <gitster@pobox.com>]

Ævar Arnfjörð Bjarmason  <avarab@gmail.com> writes:

> Change the main() function to call "exit()" instead of ending with a
> "return" statement. The "exit()" function is our own wrapper that
> calls trace2_cmd_exit_fl() for us, from git-compat-util.h:
>
> 	#define exit(code) exit(trace2_cmd_exit_fl(__FILE__, __LINE__, (code)))
>
> That "exit()" wrapper has been in use ever since ee4512ed481 (trace2:
> create new combined trace facility, 2019-02-22).
>
> This changes nothing about how we "exit()", as we'd invoke
> "trace2_cmd_exit_fl()" in both cases due to the wrapper, this change
> makes it easier to reason about this code, as we're now always
> obviously relying on our "exit()" wrapper.

Up to this point, this makes readers expect that the result would be
a simple patch

    diff --git i/common-main.c w/common-main.c
    index 71e21dd20a..f6b3a18c7f 100644
    --- i/common-main.c
    +++ w/common-main.c
    @@ -49,9 +49,5 @@ int main(int argc, const char **argv)
            trace2_cmd_start(argv);
            trace2_collect_process_info(TRACE2_PROCESS_INFO_STARTUP);

    -	result = cmd_main(argc, argv);
    -
    -	trace2_cmd_exit(result);
    -
    -	return result;
    +	exit(cmd_main(argc, argv));
     }

and that would have been justified quite well.  trace2_cmd_exit() is 
a thin wrapper around trace2_cmd_exit_fl and the whole thing amounts
to the same thing given how exit() is defined in compat-util as the
earlier part of the log message showed us.

>  Documentation/technical/api-trace2.txt | 9 ++-------
>  common-main.c                          | 9 ++++++---
>  t/helper/test-trace2.c                 | 8 ++++++--
>  trace2.h                               | 2 --
>  4 files changed, 14 insertions(+), 14 deletions(-)

So readers would naturally wonder why do we have all other changes.
Let's find out.

> diff --git a/Documentation/technical/api-trace2.txt b/Documentation/technical/api-trace2.txt
> index bb13ca3db8b..568a909222a 100644
> --- a/Documentation/technical/api-trace2.txt
> +++ b/Documentation/technical/api-trace2.txt
> @@ -828,16 +828,11 @@ Initialization::
>  ----------------
>  int main(int argc, const char **argv)
>  {
> -	int exit_code;
> -
>  	trace2_initialize();
>  	trace2_cmd_start(argv);
>  
> -	exit_code = cmd_main(argc, argv);
> -
> -	trace2_cmd_exit(exit_code);
> -
> -	return exit_code;
> +	/* Our exit() will call trace2_cmd_exit_fl() */
> +	exit(cmd_main(argc, argv));
>  }
>  ----------------

The comment above this hunk says

    == Example Trace2 API Usage

    Here is a hypothetical usage of the Trace2 API showing the intended
    usage (without worrying about the actual Git details).

    Initialization::

            Initialization happens in `main()`.  Behind the scenes, an
            `atexit` and `signal` handler are registered.

I doubt that "Our exit() does this, so trace2_cmd_exit() is not
necessary" sits well in that context.

> diff --git a/common-main.c b/common-main.c
> index 71e21dd20a3..eafc70718a5 100644
> --- a/common-main.c
> +++ b/common-main.c
> @@ -51,7 +51,10 @@ int main(int argc, const char **argv)
>  
>  	result = cmd_main(argc, argv);
>  
> -	trace2_cmd_exit(result);
> -
> -	return result;
> +	/*
> +	 * We define exit() to call trace2_cmd_exit_fl() in
> +	 * git-compat-util.h. Whether we reach this or exit()
> +	 * elsewhere we'll always run our trace2 exit handler.
> +	 */
> +	exit(result);
>  }

This is good; the new comment is also good.

> diff --git a/t/helper/test-trace2.c b/t/helper/test-trace2.c
> index f93633f895a..9954010bc89 100644
> --- a/t/helper/test-trace2.c
> +++ b/t/helper/test-trace2.c
> @@ -262,8 +262,12 @@ static int print_usage(void)
>   *    [] the "cmd_name" event has been generated.
>   *    [] this writes various "def_param" events for interesting config values.
>   *
> - * We further assume that if we return (rather than exit()), trace2_cmd_exit()
> - * will be called by test-tool.c:cmd_main().
> + * It doesn't matter if we "return" here or call "exit()", since our
> + * "exit()" is a wrapper that will call trace2_cmd_exit_fl. It would
> + * matter if we bypassed it and called "_exit()". Even if it doesn't
> + * matter for the narrow case of trace2 testing, let's be nice to
> + * test-tool.c's "cmd_main()" and common-main.c's "main()" and
> + * "return" here.
>   */

Hmph.  While nothing is technically incorrect in the new text, I
think small fixup to the original should suffice.

    We return from here and let test-tool.c::cmd_main() pass the
    exit code to common-main.c::main(), which will use it to call
    trace2_cmd_exit().

There is nothing gained by saying "we assume it is OK to do this"
when "we do this" is enough.  "it does not matter if we did this
or did this some other way, but we chose this because" is something
you'd want in the log message but not here.

>  int cmd__trace2(int argc, const char **argv)
>  {
> diff --git a/trace2.h b/trace2.h
> index 0cc7b5f5312..73876781294 100644
> --- a/trace2.h
> +++ b/trace2.h
> @@ -110,8 +110,6 @@ void trace2_cmd_start_fl(const char *file, int line, const char **argv);
>   */
>  int trace2_cmd_exit_fl(const char *file, int line, int code);
>  
> -#define trace2_cmd_exit(code) (trace2_cmd_exit_fl(__FILE__, __LINE__, (code)))
> -

This is documented in Documentation/technical/api-trace2.txt and I
do not think the proposed update in this patch is a good idea, which
makes it better to keep this #define here.