patchcommon-main.c: call exit(), don't return

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.

There is already code immediately downstream of our "main()" which has a hard reliance on that, e.g. the various "exit()" calls downstream of "cmd_main()" in "git.c".

We even had a comment in "t/helper/test-trace2.c" that seemed to be confused about how the "exit()" wrapper interacted with uses of "return", even though it was introduced in the same trace2 series in a15860dca3f (trace2: t/helper/test-trace2, t0210.sh, t0211.sh, t0212.sh, 2019-02-22), after the aforementioned ee4512ed481. Perhaps it pre-dated the "exit()" wrapper?

Let's also update both the documentation and comments accordingly: The documentation added in e544221d97a (trace2: Documentation/technical/api-trace2.txt, 2019-02-22) already said of the "exit" event that "[it] is emitted when git calls `exit()". But the "main()" example then called trace2_cmd_exit(). Let's have it invoke "exit()" instead, as the code in "common-main.c" now does.

Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
---

The diffstat here is neutral, and as noted this changes no behavior, so this isn't really needed for anything.

But as argued above I think this makes things a lot easier for readers of the code. I've had at least a couple of traces through git's execution from command-main.c downwards and thought that the "exit()" calls in git.c might be a bug, until I (re-)discovered that we're defining an exit() wrapper via a macro.

It might be a good follow-up at some point to see if we could hoist some of the cleanups we do in run_builtin() to to this level. I.e. the code referenced in my 338abb0f045 (builtins + test helpers: use return instead of exit() in cmd_*, 2021-06-08) (and similar).

Even that code could probably do with some tweaks, e.g. we should probably try to fflush() stdout/stderr even if we're about to return non-zero (now we'll only do it on success).

But for now this is one small readability improvement to some code central to git's execution.

A version of this was originally submitted as https://lore.kernel.org/git/RFC-patch-07.21-3f897bf6b0e-20211115T220831Z-avarab@gmail.com/; range-diff against that initial version below.

Range-diff against v0:
1:  3f897bf6b0e ! 1:  6fedf9969b6 common-main.c: call exit(), don't return
    @@ Metadata
      ## Commit message ##
         common-main.c: call exit(), don't return
     
    -    Refactor the main() function so that we always take the same path
    -    towards trace2_cmd_exit() whether exit() is invoked, or we end up in
    -    the "return" in the pre-image. This contains no functional change, and
    -    is only intended for the benefit of readers of the code, who'll now be
    -    pointed to our exit() wrapper.
    -
    -    Since ee4512ed481 (trace2: create new combined trace facility,
    -    2019-02-22) we've defined "exit" with a macro to call
    -    trace2_cmd_exit() for us in "git-compat-util.h". So in cases where an
    -    exit() is invoked (such as in several places in "git.c") we don't
    -    reach the trace2_cmd_exit() in the pre-image. This makes it so that
    -    we'll always take that same exit() path.
    +    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.
    +
    +    There is already code immediately downstream of our "main()" which has
    +    a hard reliance on that, e.g. the various "exit()" calls downstream of
    +    "cmd_main()" in "git.c".
    +
    +    We even had a comment in "t/helper/test-trace2.c" that seemed to be
    +    confused about how the "exit()" wrapper interacted with uses of
    +    "return", even though it was introduced in the same trace2 series in
    +    a15860dca3f (trace2: t/helper/test-trace2, t0210.sh, t0211.sh,
    +    t0212.sh, 2019-02-22), after the aforementioned ee4512ed481. Perhaps
    +    it pre-dated the "exit()" wrapper?
    +
    +    Let's also update both the documentation and comments accordingly: The
    +    documentation added in e544221d97a (trace2:
    +    Documentation/technical/api-trace2.txt, 2019-02-22) already said of
    +    the "exit" event that "[it] is emitted when git calls `exit()". But
    +    the "main()" example then called trace2_cmd_exit(). Let's have it
    +    invoke "exit()" instead, as the code in "common-main.c" now does.
     
         Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
     
    + ## Documentation/technical/api-trace2.txt ##
    +@@ Documentation/technical/api-trace2.txt: 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));
    + }
    + ----------------
    + 
    +
      ## common-main.c ##
     @@ common-main.c: int main(int argc, const char **argv)
      
    @@ common-main.c: int main(int argc, const char **argv)
     +	 */
     +	exit(result);
      }
    +
    + ## t/helper/test-trace2.c ##
    +@@ t/helper/test-trace2.c: 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.
    +  */
    + int cmd__trace2(int argc, const char **argv)
    + {
    +
    + ## trace2.h ##
    +@@ trace2.h: 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)))
    +-
    + /*
    +  * Emit an 'error' event.
    +  *

 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(-)

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

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.

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

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.

This is good; the new comment is also good.

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.

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.

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.

There is already code immediately downstream of our "main()" which has a hard reliance on that, e.g. the various "exit()" calls downstream of "cmd_main()" in "git.c".

We even had a comment in "t/helper/test-trace2.c" that seemed to be confused about how the "exit()" wrapper interacted with uses of "return", even though it was introduced in the same trace2 series in a15860dca3f (trace2: t/helper/test-trace2, t0210.sh, t0211.sh, t0212.sh, 2019-02-22), after the aforementioned ee4512ed481. Perhaps it pre-dated the "exit()" wrapper?

This change makes the "trace2_cmd_exit()" macro orphaned, we now always use "trace2_cmd_exit_fl()" directly, but let's keep that simpler example in place. Even if we're unlikely to get another "main()" other than the one in our "common-main.c", there's some value in having the API documentation and example discuss a simpler version that doesn't require an "exit()" wrapper macro.

Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
---

Junio: I think this addresses all the feedback you had on the v1 in
[1]. Thanks for the review.

I wasn't sure what trade-off to strike with leaving that small amount of dead in-tree code, but per the updated commit message I think it makes sense to have the API docs discuss the simpler example & keep the macro, as you suggest.

1. https://lore.kernel.org/git/xmqqzgpdfub1.fsf@gitster.g/

Range-diff against v1:
1:  6fedf9969b6 ! 1:  4f52ecc94ba common-main.c: call exit(), don't return
    @@ Commit message
         t0212.sh, 2019-02-22), after the aforementioned ee4512ed481. Perhaps
         it pre-dated the "exit()" wrapper?
     
    -    Let's also update both the documentation and comments accordingly: The
    -    documentation added in e544221d97a (trace2:
    -    Documentation/technical/api-trace2.txt, 2019-02-22) already said of
    -    the "exit" event that "[it] is emitted when git calls `exit()". But
    -    the "main()" example then called trace2_cmd_exit(). Let's have it
    -    invoke "exit()" instead, as the code in "common-main.c" now does.
    +    This change makes the "trace2_cmd_exit()" macro orphaned, we now
    +    always use "trace2_cmd_exit_fl()" directly, but let's keep that
    +    simpler example in place. Even if we're unlikely to get another
    +    "main()" other than the one in our "common-main.c", there's some value
    +    in having the API documentation and example discuss a simpler version
    +    that doesn't require an "exit()" wrapper macro.
     
         Signed-off-by: Ævar Arnfjörð Bjarmason <avarab@gmail.com>
     
    - ## Documentation/technical/api-trace2.txt ##
    -@@ Documentation/technical/api-trace2.txt: 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));
    - }
    - ----------------
    - 
    -
      ## common-main.c ##
     @@ common-main.c: int main(int argc, const char **argv)
      
    @@ t/helper/test-trace2.c: static int print_usage(void)
       *
     - * 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.
    ++ * 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().
       */
      int cmd__trace2(int argc, const char **argv)
      {
    -
    - ## trace2.h ##
    -@@ trace2.h: 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)))
    --
    - /*
    -  * Emit an 'error' event.
    -  *

 common-main.c          | 9 ++++++---
 t/helper/test-trace2.c | 5 +++--
 2 files changed, 9 insertions(+), 5 deletions(-)