RepoMirrors/haproxy
1
0
Fork 0
mirror of http://git.haproxy.org/git/haproxy.git/ synced 2024-12-21 11:58:03 +00:00
Code Issues Packages Projects Releases Wiki Activity
4aa573da6f
haproxy/include/proto/trace.h

162 lines
7.2 KiB
C
Raw Normal View History

MINOR: trace: start to create a new trace subsystem The principle of this subsystem will be to support taking live traces at various places in the code with conditional triggers, filters, and ability to lock on some elements. The traces will support typed events and will be sent into sinks made of ring buffers, file descriptors or remote servers.
2019-08-08 16:21:26 +00:00
/*
* include/proto/trace.h
* This file provides functions for runtime tracing
*
* Copyright (C) 2000-2019 Willy Tarreau - w@1wt.eu
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation, version 2.1
* exclusively.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
#ifndef _PROTO_TRACE_H
#define _PROTO_TRACE_H
REORG: include: update all files to use haproxy/api.h or api-t.h if needed All files that were including one of the following include files have been updated to only include haproxy/api.h or haproxy/api-t.h once instead: - common/config.h - common/compat.h - common/compiler.h - common/defaults.h - common/initcall.h - common/tools.h The choice is simple: if the file only requires type definitions, it includes api-t.h, otherwise it includes the full api.h. In addition, in these files, explicit includes for inttypes.h and limits.h were dropped since these are now covered by api.h and api-t.h. No other change was performed, given that this patch is large and affects 201 files. At least one (tools.h) was already freestanding and didn't get the new one added.
2020-05-27 10:58:42 +00:00
#include <haproxy/api.h>
REORG: tools: split common/standard.h into haproxy/tools{,-t}.h And also rename standard.c to tools.c. The original split between tools.h and standard.h dates from version 1.3-dev and was mostly an accident. This patch moves the files back to what they were expected to be, and takes care of not changing anything else. However this time tools.h was split between functions and types, because it contains a small number of commonly used macros and structures (e.g. name_desc) which in turn cause the massive list of includes of tools.h to conflict with the callers. They remain the ugliest files of the whole project and definitely need to be cleaned and split apart. A few types are defined there only for functions provided there, and some parts are even OS-specific and should move somewhere else, such as the symbol resolution code.
2020-06-03 16:09:46 +00:00
#include <haproxy/tools.h>
REORG: include: move ist.h from common/ to import/ Fortunately that file wasn't made dependent upon haproxy since it was integrated, better isolate it before it's too late. Its dependency on api.h was the result of the change from config.h, which in turn wasn't correct. It was changed back to stddef.h for size_t and sys/types.h for ssize_t. The recently added reference to MAX() was changed as it was placed only to avoid a zero length in the non-free-standing version and was causing a build warning in the hpack encoder.
2020-05-27 14:21:26 +00:00
#include <import/ist.h>
REORG: include: split mini-clist into haproxy/list and list-t.h Half of the users of this include only need the type definitions and not the manipulation macros nor the inline functions. Moves the various types into mini-clist-t.h makes the files cleaner. The other one had all its includes grouped at the top. A few files continued to reference it without using it and were cleaned. In addition it was about time that we'd rename that file, it's not "mini" anymore and contains a bit more than just circular lists.
2020-05-27 16:01:47 +00:00
#include <haproxy/list.h>
MINOR: trace: start to create a new trace subsystem The principle of this subsystem will be to support taking live traces at various places in the code with conditional triggers, filters, and ability to lock on some elements. The traces will support typed events and will be sent into sinks made of ring buffers, file descriptors or remote servers.
2019-08-08 16:21:26 +00:00
#include <types/log.h>
REORG: include: move sink.h to haproxy/sink{,-t}.h The sink files could be moved with almost no change at since they didn't rely on anything fancy. ssize_t required sys/types.h and thread.h was needed for the locks.
2020-06-03 18:02:28 +00:00
#include <haproxy/sink-t.h>
MINOR: trace: start to create a new trace subsystem The principle of this subsystem will be to support taking live traces at various places in the code with conditional triggers, filters, and ability to lock on some elements. The traces will support typed events and will be sent into sinks made of ring buffers, file descriptors or remote servers.
2019-08-08 16:21:26 +00:00
#include <types/trace.h>
MINOR: trace: add per-level macros to produce traces The new TRACE_<level>() macros take a mask, 4 args, a callback and a static message. From this they also inherit the TRACE_SOURCE macro from the caller, which contains the pointer to the trace source (so that it's not required to paste it everywhere), and an ist string is also made by the concatenation of the file name and the line number. This uses string concatenation by the preprocessor, and turns it into an ist by the compiler so that there is no operation at all to perform to adjust the data length as the compiler knows where to cut during the optimization phase. Last, the message is also automatically turned into an ist so that it's trivial to put it into an iovec without having to run strlen() on it. All arguments and the callback may be empty and will then automatically be replaced with a NULL pointer. This makes the TRACE calls slightly lighter especially since arguments are not always used. Several other options were considered to use variadic macros but there's no outstanding rule that justifies to place an argument before another one, and it still looks convenient to have the message be the last one to encourage copy- pasting of the trace statements. A generic TRACE() macro takes TRACE_LEVEL in from the source file as the trace level instead of taking it from its name. This may slightly simplify the production of traces that always run at the same level (internal core parts may probably only be called at developer level).
2019-08-12 15:27:09 +00:00
/* Make a string from the location of the trace producer as "file:line" */
#define TRC_LOC _TRC_LOC(__FILE__, __LINE__)
#define _TRC_LOC(f,l) __TRC_LOC(f, ":", l)
#define __TRC_LOC(f,c,l) f c #l
MINOR: trace: change the TRACE() calling convention to put the args and cb last Previously the callback was almost mandatory so it made sense to have it before the message. Now that it can default to the one declared in the trace source, most TRACE() calls contain series of empty args and callbacks, which make them suitable for being at the end and being totally omitted. This patch thus reverses the TRACE arguments so that the message appears first, then the mask, then arg1..arg4, then the callback. In practice we'll mostly see 1 arg, or 2 args and nothing else, and it will not be needed anymore to pass long series of commas in the middle of the arguments. However if a source is enforced, the empty commas will still be needed for all omitted arguments.
2019-08-28 08:35:16 +00:00
/* truncate a macro arg list to exactly 5 args and replace missing ones with NULL */
#define TRC_5ARGS(a1,a2,a3,a4,a5,...) DEFNULL(a1),DEFNULL(a2),DEFNULL(a3),DEFNULL(a4),DEFNULL(a5)
MINOR: trace: add per-level macros to produce traces The new TRACE_<level>() macros take a mask, 4 args, a callback and a static message. From this they also inherit the TRACE_SOURCE macro from the caller, which contains the pointer to the trace source (so that it's not required to paste it everywhere), and an ist string is also made by the concatenation of the file name and the line number. This uses string concatenation by the preprocessor, and turns it into an ist by the compiler so that there is no operation at all to perform to adjust the data length as the compiler knows where to cut during the optimization phase. Last, the message is also automatically turned into an ist so that it's trivial to put it into an iovec without having to run strlen() on it. All arguments and the callback may be empty and will then automatically be replaced with a NULL pointer. This makes the TRACE calls slightly lighter especially since arguments are not always used. Several other options were considered to use variadic macros but there's no outstanding rule that justifies to place an argument before another one, and it still looks convenient to have the message be the last one to encourage copy- pasting of the trace statements. A generic TRACE() macro takes TRACE_LEVEL in from the source file as the trace level instead of taking it from its name. This may slightly simplify the production of traces that always run at the same level (internal core parts may probably only be called at developer level).
2019-08-12 15:27:09 +00:00
/* For convenience, TRACE() alone uses the file's default TRACE_LEVEL, most
MINOR: trace: change the TRACE() calling convention to put the args and cb last Previously the callback was almost mandatory so it made sense to have it before the message. Now that it can default to the one declared in the trace source, most TRACE() calls contain series of empty args and callbacks, which make them suitable for being at the end and being totally omitted. This patch thus reverses the TRACE arguments so that the message appears first, then the mask, then arg1..arg4, then the callback. In practice we'll mostly see 1 arg, or 2 args and nothing else, and it will not be needed anymore to pass long series of commas in the middle of the arguments. However if a source is enforced, the empty commas will still be needed for all omitted arguments.
2019-08-28 08:35:16 +00:00
* likely TRACE_LEVEL_DEVELOPER, though the other explicit variants specify
* the desired level and will work when TRACE_LEVEL is not set. The 5 optional
* arguments are the 4 source-specific arguments that are passed to the cb()
* callback dedicated to decoding, and which may be used for special tracking.
* These 4 arguments as well as the cb() function pointer may all be NULL, or
* simply omitted (in which case they will be replaced by a NULL). This
* ordering allows many TRACE() calls to be placed using copy-paste and just
MINOR: trace: prepend the function name for developer level traces Working on adding traces to mux-h2 revealed that the function names are manually copied a lot in developer traces. The reason is that they are not preprocessor macros and as such cannot be concatenated. Let's slightly adjust the trace() function call to take a function name just after the file:line argument. This argument is only added for the TRACE_DEVEL and 3 new TRACE_ENTER, TRACE_LEAVE, and TRACE_POINT macros and left NULL for others. This way the function name is only reported for traces aimed at the developers. The pretty-print callback was also extended to benefit from this. This will also significantly shrink the data segment as the "entering" and "leaving" strings will now be merged. One technical point worth mentioning is that the function name is *not* passed as an ist to the inline function because it's not considered as a builtin constant by the compiler, and would lead to strlen() being run on it from all call places before calling the inline function. Thus instead we pass the const char * (that the compiler knows where to find) and it's the __trace() function that converts it to an ist for internal consumption and for the pretty-print callback. Doing this avoids losing 5-10% peak performance.
2019-08-29 06:40:59 +00:00
* change the message at the beginning. Only TRACE_DEVEL(), TRACE_ENTER() and
* TRACE_LEAVE() will report the calling function's name.
MINOR: trace: add per-level macros to produce traces The new TRACE_<level>() macros take a mask, 4 args, a callback and a static message. From this they also inherit the TRACE_SOURCE macro from the caller, which contains the pointer to the trace source (so that it's not required to paste it everywhere), and an ist string is also made by the concatenation of the file name and the line number. This uses string concatenation by the preprocessor, and turns it into an ist by the compiler so that there is no operation at all to perform to adjust the data length as the compiler knows where to cut during the optimization phase. Last, the message is also automatically turned into an ist so that it's trivial to put it into an iovec without having to run strlen() on it. All arguments and the callback may be empty and will then automatically be replaced with a NULL pointer. This makes the TRACE calls slightly lighter especially since arguments are not always used. Several other options were considered to use variadic macros but there's no outstanding rule that justifies to place an argument before another one, and it still looks convenient to have the message be the last one to encourage copy- pasting of the trace statements. A generic TRACE() macro takes TRACE_LEVEL in from the source file as the trace level instead of taking it from its name. This may slightly simplify the production of traces that always run at the same level (internal core parts may probably only be called at developer level).
2019-08-12 15:27:09 +00:00
*/
MINOR: trace: change the TRACE() calling convention to put the args and cb last Previously the callback was almost mandatory so it made sense to have it before the message. Now that it can default to the one declared in the trace source, most TRACE() calls contain series of empty args and callbacks, which make them suitable for being at the end and being totally omitted. This patch thus reverses the TRACE arguments so that the message appears first, then the mask, then arg1..arg4, then the callback. In practice we'll mostly see 1 arg, or 2 args and nothing else, and it will not be needed anymore to pass long series of commas in the middle of the arguments. However if a source is enforced, the empty commas will still be needed for all omitted arguments.
2019-08-28 08:35:16 +00:00
#define TRACE(msg, mask, ...) \
MINOR: trace: prepend the function name for developer level traces Working on adding traces to mux-h2 revealed that the function names are manually copied a lot in developer traces. The reason is that they are not preprocessor macros and as such cannot be concatenated. Let's slightly adjust the trace() function call to take a function name just after the file:line argument. This argument is only added for the TRACE_DEVEL and 3 new TRACE_ENTER, TRACE_LEAVE, and TRACE_POINT macros and left NULL for others. This way the function name is only reported for traces aimed at the developers. The pretty-print callback was also extended to benefit from this. This will also significantly shrink the data segment as the "entering" and "leaving" strings will now be merged. One technical point worth mentioning is that the function name is *not* passed as an ist to the inline function because it's not considered as a builtin constant by the compiler, and would lead to strlen() being run on it from all call places before calling the inline function. Thus instead we pass the const char * (that the compiler knows where to find) and it's the __trace() function that converts it to an ist for internal consumption and for the pretty-print callback. Doing this avoids losing 5-10% peak performance.
2019-08-29 06:40:59 +00:00
trace(TRACE_LEVEL, (mask), TRACE_SOURCE, ist(TRC_LOC), NULL, TRC_5ARGS(__VA_ARGS__,,,,,), ist(msg))
MINOR: trace: change the TRACE() calling convention to put the args and cb last Previously the callback was almost mandatory so it made sense to have it before the message. Now that it can default to the one declared in the trace source, most TRACE() calls contain series of empty args and callbacks, which make them suitable for being at the end and being totally omitted. This patch thus reverses the TRACE arguments so that the message appears first, then the mask, then arg1..arg4, then the callback. In practice we'll mostly see 1 arg, or 2 args and nothing else, and it will not be needed anymore to pass long series of commas in the middle of the arguments. However if a source is enforced, the empty commas will still be needed for all omitted arguments.
2019-08-28 08:35:16 +00:00
#define TRACE_USER(msg, mask, ...) \
MINOR: trace: prepend the function name for developer level traces Working on adding traces to mux-h2 revealed that the function names are manually copied a lot in developer traces. The reason is that they are not preprocessor macros and as such cannot be concatenated. Let's slightly adjust the trace() function call to take a function name just after the file:line argument. This argument is only added for the TRACE_DEVEL and 3 new TRACE_ENTER, TRACE_LEAVE, and TRACE_POINT macros and left NULL for others. This way the function name is only reported for traces aimed at the developers. The pretty-print callback was also extended to benefit from this. This will also significantly shrink the data segment as the "entering" and "leaving" strings will now be merged. One technical point worth mentioning is that the function name is *not* passed as an ist to the inline function because it's not considered as a builtin constant by the compiler, and would lead to strlen() being run on it from all call places before calling the inline function. Thus instead we pass the const char * (that the compiler knows where to find) and it's the __trace() function that converts it to an ist for internal consumption and for the pretty-print callback. Doing this avoids losing 5-10% peak performance.
2019-08-29 06:40:59 +00:00
trace(TRACE_LEVEL_USER, (mask), TRACE_SOURCE, ist(TRC_LOC), NULL, TRC_5ARGS(__VA_ARGS__,,,,,), ist(msg))
MINOR: trace: change the TRACE() calling convention to put the args and cb last Previously the callback was almost mandatory so it made sense to have it before the message. Now that it can default to the one declared in the trace source, most TRACE() calls contain series of empty args and callbacks, which make them suitable for being at the end and being totally omitted. This patch thus reverses the TRACE arguments so that the message appears first, then the mask, then arg1..arg4, then the callback. In practice we'll mostly see 1 arg, or 2 args and nothing else, and it will not be needed anymore to pass long series of commas in the middle of the arguments. However if a source is enforced, the empty commas will still be needed for all omitted arguments.
2019-08-28 08:35:16 +00:00
MINOR: trace: change the "payload" level to "data" and move it The "payload" trace level was ambigous because its initial purpose was to be able to dump received data. But it doesn't make sense to force to report data transfers just to be able to report state changes. For example, all snd_buf()/rcv_buf() operations coming from the application layer should be tagged at this level. So here we move this payload level above the state transitions and rename it to avoid the ambiguity making one think it's only about request/response payload. Now it clearly is about any data transfer and is thus just below the developer level. The help messages on the CLI and the doc were slightly reworded to help remove this ambiguity.
2019-08-29 06:01:48 +00:00
#define TRACE_DATA(msg, mask, ...) \
MINOR: trace: prepend the function name for developer level traces Working on adding traces to mux-h2 revealed that the function names are manually copied a lot in developer traces. The reason is that they are not preprocessor macros and as such cannot be concatenated. Let's slightly adjust the trace() function call to take a function name just after the file:line argument. This argument is only added for the TRACE_DEVEL and 3 new TRACE_ENTER, TRACE_LEAVE, and TRACE_POINT macros and left NULL for others. This way the function name is only reported for traces aimed at the developers. The pretty-print callback was also extended to benefit from this. This will also significantly shrink the data segment as the "entering" and "leaving" strings will now be merged. One technical point worth mentioning is that the function name is *not* passed as an ist to the inline function because it's not considered as a builtin constant by the compiler, and would lead to strlen() being run on it from all call places before calling the inline function. Thus instead we pass the const char * (that the compiler knows where to find) and it's the __trace() function that converts it to an ist for internal consumption and for the pretty-print callback. Doing this avoids losing 5-10% peak performance.
2019-08-29 06:40:59 +00:00
trace(TRACE_LEVEL_DATA, (mask), TRACE_SOURCE, ist(TRC_LOC), NULL, TRC_5ARGS(__VA_ARGS__,,,,,), ist(msg))
MINOR: trace: change the TRACE() calling convention to put the args and cb last Previously the callback was almost mandatory so it made sense to have it before the message. Now that it can default to the one declared in the trace source, most TRACE() calls contain series of empty args and callbacks, which make them suitable for being at the end and being totally omitted. This patch thus reverses the TRACE arguments so that the message appears first, then the mask, then arg1..arg4, then the callback. In practice we'll mostly see 1 arg, or 2 args and nothing else, and it will not be needed anymore to pass long series of commas in the middle of the arguments. However if a source is enforced, the empty commas will still be needed for all omitted arguments.
2019-08-28 08:35:16 +00:00
#define TRACE_PROTO(msg, mask, ...) \
MINOR: trace: prepend the function name for developer level traces Working on adding traces to mux-h2 revealed that the function names are manually copied a lot in developer traces. The reason is that they are not preprocessor macros and as such cannot be concatenated. Let's slightly adjust the trace() function call to take a function name just after the file:line argument. This argument is only added for the TRACE_DEVEL and 3 new TRACE_ENTER, TRACE_LEAVE, and TRACE_POINT macros and left NULL for others. This way the function name is only reported for traces aimed at the developers. The pretty-print callback was also extended to benefit from this. This will also significantly shrink the data segment as the "entering" and "leaving" strings will now be merged. One technical point worth mentioning is that the function name is *not* passed as an ist to the inline function because it's not considered as a builtin constant by the compiler, and would lead to strlen() being run on it from all call places before calling the inline function. Thus instead we pass the const char * (that the compiler knows where to find) and it's the __trace() function that converts it to an ist for internal consumption and for the pretty-print callback. Doing this avoids losing 5-10% peak performance.
2019-08-29 06:40:59 +00:00
trace(TRACE_LEVEL_PROTO, (mask), TRACE_SOURCE, ist(TRC_LOC), NULL, TRC_5ARGS(__VA_ARGS__,,,,,), ist(msg))
MINOR: trace: add per-level macros to produce traces The new TRACE_<level>() macros take a mask, 4 args, a callback and a static message. From this they also inherit the TRACE_SOURCE macro from the caller, which contains the pointer to the trace source (so that it's not required to paste it everywhere), and an ist string is also made by the concatenation of the file name and the line number. This uses string concatenation by the preprocessor, and turns it into an ist by the compiler so that there is no operation at all to perform to adjust the data length as the compiler knows where to cut during the optimization phase. Last, the message is also automatically turned into an ist so that it's trivial to put it into an iovec without having to run strlen() on it. All arguments and the callback may be empty and will then automatically be replaced with a NULL pointer. This makes the TRACE calls slightly lighter especially since arguments are not always used. Several other options were considered to use variadic macros but there's no outstanding rule that justifies to place an argument before another one, and it still looks convenient to have the message be the last one to encourage copy- pasting of the trace statements. A generic TRACE() macro takes TRACE_LEVEL in from the source file as the trace level instead of taking it from its name. This may slightly simplify the production of traces that always run at the same level (internal core parts may probably only be called at developer level).
2019-08-12 15:27:09 +00:00
MINOR: trace: change the TRACE() calling convention to put the args and cb last Previously the callback was almost mandatory so it made sense to have it before the message. Now that it can default to the one declared in the trace source, most TRACE() calls contain series of empty args and callbacks, which make them suitable for being at the end and being totally omitted. This patch thus reverses the TRACE arguments so that the message appears first, then the mask, then arg1..arg4, then the callback. In practice we'll mostly see 1 arg, or 2 args and nothing else, and it will not be needed anymore to pass long series of commas in the middle of the arguments. However if a source is enforced, the empty commas will still be needed for all omitted arguments.
2019-08-28 08:35:16 +00:00
#define TRACE_STATE(msg, mask, ...) \
MINOR: trace: prepend the function name for developer level traces Working on adding traces to mux-h2 revealed that the function names are manually copied a lot in developer traces. The reason is that they are not preprocessor macros and as such cannot be concatenated. Let's slightly adjust the trace() function call to take a function name just after the file:line argument. This argument is only added for the TRACE_DEVEL and 3 new TRACE_ENTER, TRACE_LEAVE, and TRACE_POINT macros and left NULL for others. This way the function name is only reported for traces aimed at the developers. The pretty-print callback was also extended to benefit from this. This will also significantly shrink the data segment as the "entering" and "leaving" strings will now be merged. One technical point worth mentioning is that the function name is *not* passed as an ist to the inline function because it's not considered as a builtin constant by the compiler, and would lead to strlen() being run on it from all call places before calling the inline function. Thus instead we pass the const char * (that the compiler knows where to find) and it's the __trace() function that converts it to an ist for internal consumption and for the pretty-print callback. Doing this avoids losing 5-10% peak performance.
2019-08-29 06:40:59 +00:00
trace(TRACE_LEVEL_STATE, (mask), TRACE_SOURCE, ist(TRC_LOC), NULL, TRC_5ARGS(__VA_ARGS__,,,,,), ist(msg))
MINOR: trace: add per-level macros to produce traces The new TRACE_<level>() macros take a mask, 4 args, a callback and a static message. From this they also inherit the TRACE_SOURCE macro from the caller, which contains the pointer to the trace source (so that it's not required to paste it everywhere), and an ist string is also made by the concatenation of the file name and the line number. This uses string concatenation by the preprocessor, and turns it into an ist by the compiler so that there is no operation at all to perform to adjust the data length as the compiler knows where to cut during the optimization phase. Last, the message is also automatically turned into an ist so that it's trivial to put it into an iovec without having to run strlen() on it. All arguments and the callback may be empty and will then automatically be replaced with a NULL pointer. This makes the TRACE calls slightly lighter especially since arguments are not always used. Several other options were considered to use variadic macros but there's no outstanding rule that justifies to place an argument before another one, and it still looks convenient to have the message be the last one to encourage copy- pasting of the trace statements. A generic TRACE() macro takes TRACE_LEVEL in from the source file as the trace level instead of taking it from its name. This may slightly simplify the production of traces that always run at the same level (internal core parts may probably only be called at developer level).
2019-08-12 15:27:09 +00:00
MINOR: trace: change the TRACE() calling convention to put the args and cb last Previously the callback was almost mandatory so it made sense to have it before the message. Now that it can default to the one declared in the trace source, most TRACE() calls contain series of empty args and callbacks, which make them suitable for being at the end and being totally omitted. This patch thus reverses the TRACE arguments so that the message appears first, then the mask, then arg1..arg4, then the callback. In practice we'll mostly see 1 arg, or 2 args and nothing else, and it will not be needed anymore to pass long series of commas in the middle of the arguments. However if a source is enforced, the empty commas will still be needed for all omitted arguments.
2019-08-28 08:35:16 +00:00
#define TRACE_DEVEL(msg, mask, ...) \
MINOR: trace: prepend the function name for developer level traces Working on adding traces to mux-h2 revealed that the function names are manually copied a lot in developer traces. The reason is that they are not preprocessor macros and as such cannot be concatenated. Let's slightly adjust the trace() function call to take a function name just after the file:line argument. This argument is only added for the TRACE_DEVEL and 3 new TRACE_ENTER, TRACE_LEAVE, and TRACE_POINT macros and left NULL for others. This way the function name is only reported for traces aimed at the developers. The pretty-print callback was also extended to benefit from this. This will also significantly shrink the data segment as the "entering" and "leaving" strings will now be merged. One technical point worth mentioning is that the function name is *not* passed as an ist to the inline function because it's not considered as a builtin constant by the compiler, and would lead to strlen() being run on it from all call places before calling the inline function. Thus instead we pass the const char * (that the compiler knows where to find) and it's the __trace() function that converts it to an ist for internal consumption and for the pretty-print callback. Doing this avoids losing 5-10% peak performance.
2019-08-29 06:40:59 +00:00
trace(TRACE_LEVEL_DEVELOPER, (mask), TRACE_SOURCE, ist(TRC_LOC), __FUNCTION__, TRC_5ARGS(__VA_ARGS__,,,,,), ist(msg))
#define TRACE_ENTER(mask, ...) \
trace(TRACE_LEVEL_DEVELOPER, (mask), TRACE_SOURCE, ist(TRC_LOC), __FUNCTION__, TRC_5ARGS(__VA_ARGS__,,,,,), ist("entering"))
#define TRACE_LEAVE(mask, ...) \
trace(TRACE_LEVEL_DEVELOPER, (mask), TRACE_SOURCE, ist(TRC_LOC), __FUNCTION__, TRC_5ARGS(__VA_ARGS__,,,,,), ist("leaving"))
#define TRACE_POINT(mask, ...) \
trace(TRACE_LEVEL_DEVELOPER, (mask), TRACE_SOURCE, ist(TRC_LOC), __FUNCTION__, TRC_5ARGS(__VA_ARGS__,,,,,), ist("in"))
MINOR: trace: add per-level macros to produce traces The new TRACE_<level>() macros take a mask, 4 args, a callback and a static message. From this they also inherit the TRACE_SOURCE macro from the caller, which contains the pointer to the trace source (so that it's not required to paste it everywhere), and an ist string is also made by the concatenation of the file name and the line number. This uses string concatenation by the preprocessor, and turns it into an ist by the compiler so that there is no operation at all to perform to adjust the data length as the compiler knows where to cut during the optimization phase. Last, the message is also automatically turned into an ist so that it's trivial to put it into an iovec without having to run strlen() on it. All arguments and the callback may be empty and will then automatically be replaced with a NULL pointer. This makes the TRACE calls slightly lighter especially since arguments are not always used. Several other options were considered to use variadic macros but there's no outstanding rule that justifies to place an argument before another one, and it still looks convenient to have the message be the last one to encourage copy- pasting of the trace statements. A generic TRACE() macro takes TRACE_LEVEL in from the source file as the trace level instead of taking it from its name. This may slightly simplify the production of traces that always run at the same level (internal core parts may probably only be called at developer level).
2019-08-12 15:27:09 +00:00
MINOR: trace: Add a set of macros to trace events if HA is compiled with debug The macros DBG_TRACE_*() can be used instead of existing trace macros to emit trace messages in debug mode only, ie, when HAProxy is compiled with DEBUG_FULL or DEBUG_DEV. Otherwise, these macros do nothing. So it is possible to add traces for development purpose without impacting performance of production instances.
2019-11-04 10:40:10 +00:00
#if defined(DEBUG_DEV) || defined(DEBUG_FULL)
# define DBG_TRACE(msg, mask, ...) TRACE(msg, mask, __VA_ARGS__)
# define DBG_TRACE_USER(msg, mask, ...) TRACE_USER(msg, mask, __VA_ARGS__)
# define DBG_TRACE_DATA(msg, mask, ...) TRACE_DATA(msg, mask, __VA_ARGS__)
# define DBG_TRACE_PROTO(msg, mask, ...) TRACE_PROTO(msg, mask, __VA_ARGS__)
# define DBG_TRACE_STATE(msg, mask, ...) TRACE_STATE(msg, mask, __VA_ARGS__)
# define DBG_TRACE_DEVEL(msg, mask, ...) TRACE_DEVEL(msg, mask, __VA_ARGS__)
# define DBG_TRACE_ENTER(mask, ...) TRACE_ENTER(mask, __VA_ARGS__)
# define DBG_TRACE_LEAVE(mask, ...) TRACE_LEAVE(mask, __VA_ARGS__)
# define DBG_TRACE_POINT(mask, ...) TRACE_POINT(mask, __VA_ARGS__)
#else
# define DBG_TRACE(msg, mask, ...) do { /* do nothing */ } while(0)
# define DBG_TRACE_USER(msg, mask, ...) do { /* do nothing */ } while(0)
# define DBG_TRACE_DATA(msg, mask, ...) do { /* do nothing */ } while(0)
# define DBG_TRACE_PROTO(msg, mask, ...) do { /* do nothing */ } while(0)
# define DBG_TRACE_STATE(msg, mask, ...) do { /* do nothing */ } while(0)
# define DBG_TRACE_DEVEL(msg, mask, ...) do { /* do nothing */ } while(0)
# define DBG_TRACE_ENTER(mask, ...) do { /* do nothing */ } while(0)
# define DBG_TRACE_LEAVE(mask, ...) do { /* do nothing */ } while(0)
# define DBG_TRACE_POINT(mask, ...) do { /* do nothing */ } while(0)
#endif
MINOR: trace: start to create a new trace subsystem The principle of this subsystem will be to support taking live traces at various places in the code with conditional triggers, filters, and ability to lock on some elements. The traces will support typed events and will be sent into sinks made of ring buffers, file descriptors or remote servers.
2019-08-08 16:21:26 +00:00
extern struct list trace_sources;
MINOR: trace: add allocation of buffer-sized trace buffers This will be needed so that we can implement protocol decoders which will have to emit their contents into such a buffer.
2019-08-19 13:55:34 +00:00
extern THREAD_LOCAL struct buffer trace_buf;
MINOR: trace: start to create a new trace subsystem The principle of this subsystem will be to support taking live traces at various places in the code with conditional triggers, filters, and ability to lock on some elements. The traces will support typed events and will be sent into sinks made of ring buffers, file descriptors or remote servers.
2019-08-08 16:21:26 +00:00
MINOR: trace: prepend the function name for developer level traces Working on adding traces to mux-h2 revealed that the function names are manually copied a lot in developer traces. The reason is that they are not preprocessor macros and as such cannot be concatenated. Let's slightly adjust the trace() function call to take a function name just after the file:line argument. This argument is only added for the TRACE_DEVEL and 3 new TRACE_ENTER, TRACE_LEAVE, and TRACE_POINT macros and left NULL for others. This way the function name is only reported for traces aimed at the developers. The pretty-print callback was also extended to benefit from this. This will also significantly shrink the data segment as the "entering" and "leaving" strings will now be merged. One technical point worth mentioning is that the function name is *not* passed as an ist to the inline function because it's not considered as a builtin constant by the compiler, and would lead to strlen() being run on it from all call places before calling the inline function. Thus instead we pass the const char * (that the compiler knows where to find) and it's the __trace() function that converts it to an ist for internal consumption and for the pretty-print callback. Doing this avoids losing 5-10% peak performance.
2019-08-29 06:40:59 +00:00
void __trace(enum trace_level level, uint64_t mask, struct trace_source *src,
const struct ist where, const char *func,
MINOR: trace: implement a call to a decode function The trace() call will support an optional decoding callback and 4 arguments that this function is supposed to know how to use to provide extra information. The output remains unchanged when the function is NULL. Otherwise, the message is pre-filled into the thread-local trace_buf, and the function is called with all arguments so that it completes the buffer in a readable form depending on the expected level of detail.
2019-08-19 14:28:07 +00:00
const void *a1, const void *a2, const void *a3, const void *a4,
MINOR: trace: prepend the function name for developer level traces Working on adding traces to mux-h2 revealed that the function names are manually copied a lot in developer traces. The reason is that they are not preprocessor macros and as such cannot be concatenated. Let's slightly adjust the trace() function call to take a function name just after the file:line argument. This argument is only added for the TRACE_DEVEL and 3 new TRACE_ENTER, TRACE_LEAVE, and TRACE_POINT macros and left NULL for others. This way the function name is only reported for traces aimed at the developers. The pretty-print callback was also extended to benefit from this. This will also significantly shrink the data segment as the "entering" and "leaving" strings will now be merged. One technical point worth mentioning is that the function name is *not* passed as an ist to the inline function because it's not considered as a builtin constant by the compiler, and would lead to strlen() being run on it from all call places before calling the inline function. Thus instead we pass the const char * (that the compiler knows where to find) and it's the __trace() function that converts it to an ist for internal consumption and for the pretty-print callback. Doing this avoids losing 5-10% peak performance.
2019-08-29 06:40:59 +00:00
void (*cb)(enum trace_level level, uint64_t mask, const struct trace_source *src,
const struct ist where, const struct ist func,
MINOR: trace: implement a call to a decode function The trace() call will support an optional decoding callback and 4 arguments that this function is supposed to know how to use to provide extra information. The output remains unchanged when the function is NULL. Otherwise, the message is pre-filled into the thread-local trace_buf, and the function is called with all arguments so that it completes the buffer in a readable form depending on the expected level of detail.
2019-08-19 14:28:07 +00:00
const void *a1, const void *a2, const void *a3, const void *a4),
const struct ist msg);
MINOR: trace: implement a very basic trace() function For now it remains quite basic. It performs a few state checks, calls the source's sink if defined, and performs the transitions between RUNNING, STOPPED and WAITING when the configured events match.
2019-08-12 13:51:58 +00:00
MINOR: trace/cli: register the "trace" CLI keyword to list the sources For now it lists the sources if one is not provided, and checks for the source's existence. It lists the events if not provided, checks for their existence if provided, and adjusts reported events/start/stop/pause events, and performs state transitions. It lists sinks and adjusts them as well. Filters, lock, and level are not implemented yet.
2019-08-08 16:48:12 +00:00
/* return a single char to describe a trace state */
static inline char trace_state_char(enum trace_state st)
{
return (st == TRACE_STATE_RUNNING) ? 'R' :
(st == TRACE_STATE_WAITING) ? 'w' :
'.';
}
/* return a single char to describe an event state */
static inline char trace_event_char(uint64_t conf, uint64_t ev)
{
return (conf & ev) ? '+' : '-';
}
MINOR: trace: start to create a new trace subsystem The principle of this subsystem will be to support taking live traces at various places in the code with conditional triggers, filters, and ability to lock on some elements. The traces will support typed events and will be sent into sinks made of ring buffers, file descriptors or remote servers.
2019-08-08 16:21:26 +00:00
/* registers trace source <source>. Modifies the list element!
* The {start,pause,stop,report} events are not changed so the source may
* preset them.
*/
static inline void trace_register_source(struct trace_source *source)
{
source->lockon = TRACE_LOCKON_NOTHING;
source->level = TRACE_LEVEL_USER;
MINOR: trace: change the detail_level to per-source verbosity The detail level initially based on syslog levels is not used, while something related is missing, trace verbosity, to indicate whether or not we want to call the decoding callback and what level of decoding we want (raw captures etc). Let's change the field to "verbosity" for this. A verbosity of zero means that the decoding callback is not called, and all other levels are handled by this callback and are source-specific. The source is now prompted to list the levels that are proposed to the user. When the source doesn't define anything, "quiet" and "default" are available.
2019-08-29 06:24:16 +00:00
source->verbosity = 1;
MINOR: trace: start to create a new trace subsystem The principle of this subsystem will be to support taking live traces at various places in the code with conditional triggers, filters, and ability to lock on some elements. The traces will support typed events and will be sent into sinks made of ring buffers, file descriptors or remote servers.
2019-08-08 16:21:26 +00:00
source->sink = NULL;
source->state = TRACE_STATE_STOPPED;
source->lockon_ptr = NULL;
LIST_ADDQ(&trace_sources, &source->source_link);
}
MINOR: trace: implement a very basic trace() function For now it remains quite basic. It performs a few state checks, calls the source's sink if defined, and performs the transitions between RUNNING, STOPPED and WAITING when the configured events match.
2019-08-12 13:51:58 +00:00
/* sends a trace for the given source */
MINOR: trace: prepend the function name for developer level traces Working on adding traces to mux-h2 revealed that the function names are manually copied a lot in developer traces. The reason is that they are not preprocessor macros and as such cannot be concatenated. Let's slightly adjust the trace() function call to take a function name just after the file:line argument. This argument is only added for the TRACE_DEVEL and 3 new TRACE_ENTER, TRACE_LEAVE, and TRACE_POINT macros and left NULL for others. This way the function name is only reported for traces aimed at the developers. The pretty-print callback was also extended to benefit from this. This will also significantly shrink the data segment as the "entering" and "leaving" strings will now be merged. One technical point worth mentioning is that the function name is *not* passed as an ist to the inline function because it's not considered as a builtin constant by the compiler, and would lead to strlen() being run on it from all call places before calling the inline function. Thus instead we pass the const char * (that the compiler knows where to find) and it's the __trace() function that converts it to an ist for internal consumption and for the pretty-print callback. Doing this avoids losing 5-10% peak performance.
2019-08-29 06:40:59 +00:00
static inline void trace(enum trace_level level, uint64_t mask, struct trace_source *src,
const struct ist where, const char *func,
MINOR: trace: implement a call to a decode function The trace() call will support an optional decoding callback and 4 arguments that this function is supposed to know how to use to provide extra information. The output remains unchanged when the function is NULL. Otherwise, the message is pre-filled into the thread-local trace_buf, and the function is called with all arguments so that it completes the buffer in a readable form depending on the expected level of detail.
2019-08-19 14:28:07 +00:00
const void *a1, const void *a2, const void *a3, const void *a4,
MINOR: trace: prepend the function name for developer level traces Working on adding traces to mux-h2 revealed that the function names are manually copied a lot in developer traces. The reason is that they are not preprocessor macros and as such cannot be concatenated. Let's slightly adjust the trace() function call to take a function name just after the file:line argument. This argument is only added for the TRACE_DEVEL and 3 new TRACE_ENTER, TRACE_LEAVE, and TRACE_POINT macros and left NULL for others. This way the function name is only reported for traces aimed at the developers. The pretty-print callback was also extended to benefit from this. This will also significantly shrink the data segment as the "entering" and "leaving" strings will now be merged. One technical point worth mentioning is that the function name is *not* passed as an ist to the inline function because it's not considered as a builtin constant by the compiler, and would lead to strlen() being run on it from all call places before calling the inline function. Thus instead we pass the const char * (that the compiler knows where to find) and it's the __trace() function that converts it to an ist for internal consumption and for the pretty-print callback. Doing this avoids losing 5-10% peak performance.
2019-08-29 06:40:59 +00:00
void (*cb)(enum trace_level level, uint64_t mask, const struct trace_source *src,
const struct ist where, const struct ist func,
MINOR: trace: implement a call to a decode function The trace() call will support an optional decoding callback and 4 arguments that this function is supposed to know how to use to provide extra information. The output remains unchanged when the function is NULL. Otherwise, the message is pre-filled into the thread-local trace_buf, and the function is called with all arguments so that it completes the buffer in a readable form depending on the expected level of detail.
2019-08-19 14:28:07 +00:00
const void *a1, const void *a2, const void *a3, const void *a4),
const struct ist msg)
MINOR: trace: implement a very basic trace() function For now it remains quite basic. It performs a few state checks, calls the source's sink if defined, and performs the transitions between RUNNING, STOPPED and WAITING when the configured events match.
2019-08-12 13:51:58 +00:00
{
if (unlikely(src->state != TRACE_STATE_STOPPED))
MINOR: trace: prepend the function name for developer level traces Working on adding traces to mux-h2 revealed that the function names are manually copied a lot in developer traces. The reason is that they are not preprocessor macros and as such cannot be concatenated. Let's slightly adjust the trace() function call to take a function name just after the file:line argument. This argument is only added for the TRACE_DEVEL and 3 new TRACE_ENTER, TRACE_LEAVE, and TRACE_POINT macros and left NULL for others. This way the function name is only reported for traces aimed at the developers. The pretty-print callback was also extended to benefit from this. This will also significantly shrink the data segment as the "entering" and "leaving" strings will now be merged. One technical point worth mentioning is that the function name is *not* passed as an ist to the inline function because it's not considered as a builtin constant by the compiler, and would lead to strlen() being run on it from all call places before calling the inline function. Thus instead we pass the const char * (that the compiler knows where to find) and it's the __trace() function that converts it to an ist for internal consumption and for the pretty-print callback. Doing this avoids losing 5-10% peak performance.
2019-08-29 06:40:59 +00:00
__trace(level, mask, src, where, func, a1, a2, a3, a4, cb, msg);
MINOR: trace: implement a very basic trace() function For now it remains quite basic. It performs a few state checks, calls the source's sink if defined, and performs the transitions between RUNNING, STOPPED and WAITING when the configured events match.
2019-08-12 13:51:58 +00:00
}
MINOR: trace: start to create a new trace subsystem The principle of this subsystem will be to support taking live traces at various places in the code with conditional triggers, filters, and ability to lock on some elements. The traces will support typed events and will be sent into sinks made of ring buffers, file descriptors or remote servers.
2019-08-08 16:21:26 +00:00
#endif /* _PROTO_TRACE_H */
/*
* Local variables:
* c-indent-level: 8
* c-basic-offset: 8
* End:
*/
Reference in New Issue Copy Permalink