* [PATCH v1] common-main.c: call exit(), don't return
@ 2021-12-06 16:11 Ævar Arnfjörð Bjarmason
2021-12-06 18:43 ` Junio C Hamano
2021-12-07 10:13 ` [PATCH v2] " Ævar Arnfjörð Bjarmason
0 siblings, 2 replies; 3+ messages in thread
From: Ævar Arnfjörð Bjarmason @ 2021-12-06 16:11 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Jeff Hostetler, Taylor Blau, Jeff King,
Ævar Arnfjörð Bjarmason
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(-)
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));
}
----------------
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);
}
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.
*/
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)))
-
/*
* Emit an 'error' event.
*
--
2.34.1.898.g5a552c2e5f0
^ permalink raw reply related [flat|nested] 3+ messages in thread* Re: [PATCH v1] common-main.c: call exit(), don't return
2021-12-06 16:11 [PATCH v1] common-main.c: call exit(), don't return Ævar Arnfjörð Bjarmason
@ 2021-12-06 18:43 ` Junio C Hamano
2021-12-07 10:13 ` [PATCH v2] " Ævar Arnfjörð Bjarmason
1 sibling, 0 replies; 3+ messages in thread
From: Junio C Hamano @ 2021-12-06 18:43 UTC (permalink / raw)
To: Ævar Arnfjörð Bjarmason
Cc: git, Jeff Hostetler, Taylor Blau, Jeff King
Æ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.
^ permalink raw reply [flat|nested] 3+ messages in thread* [PATCH v2] common-main.c: call exit(), don't return
2021-12-06 16:11 [PATCH v1] common-main.c: call exit(), don't return Ævar Arnfjörð Bjarmason
2021-12-06 18:43 ` Junio C Hamano
@ 2021-12-07 10:13 ` Ævar Arnfjörð Bjarmason
1 sibling, 0 replies; 3+ messages in thread
From: Ævar Arnfjörð Bjarmason @ 2021-12-07 10:13 UTC (permalink / raw)
To: git
Cc: Junio C Hamano, Jeff Hostetler, Taylor Blau, Jeff King,
Ævar Arnfjörð Bjarmason
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(-)
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);
}
diff --git a/t/helper/test-trace2.c b/t/helper/test-trace2.c
index f93633f895a..59b124bb5f1 100644
--- a/t/helper/test-trace2.c
+++ b/t/helper/test-trace2.c
@@ -262,8 +262,9 @@ 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().
+ * 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)
{
--
2.34.1.898.g5a552c2e5f0
^ permalink raw reply related [flat|nested] 3+ messages in thread
end of thread, other threads:[~2021-12-07 10:13 UTC | newest]
Thread overview: 3+ messages (download: mbox.gz follow: Atom feed
-- links below jump to the message on this page --
2021-12-06 16:11 [PATCH v1] common-main.c: call exit(), don't return Ævar Arnfjörð Bjarmason
2021-12-06 18:43 ` Junio C Hamano
2021-12-07 10:13 ` [PATCH v2] " Ævar Arnfjörð Bjarmason
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).