RepoMirrors
/
haproxy
mirror of http://git.haproxy.org/git/haproxy.git/
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
haproxy/dev/flags/flags.c

177 lines
6.5 KiB
C
Raw Normal View History

CONTRIB: initiate a debugging suite to make debugging easier The goal is to have a collection of quick-n-dirty utilities that make debugging easier and that can easily be modified when needed. The first utility in this series is called "flags". For a given numeric argument, it reports the various known combinations of flags for channels, streams and so on. This way it's easy to copy-paste values from the CLI or from gdb and immediately know what state a stream-interface or connection is in.
2015-12-20 22:21:57 +00:00
#include <stdio.h>
#include <stdlib.h>
BUILD: flags: really restrict the cases where flags are exposed A number of internal flags started to be exposed to external programs at the location of their definition since commit 77acaf5af ("MINOR: flags: add a new file to host flag dumping macros"). This allowed the "flags" utility to decode many more of them and always correctly. The condition to expose them was to rely on the preliminary definition of EOF that indicates that stdio is already included. But this was a wrong approach. It only guarantees that snprintf() can safely be used but still causes large functions to be built. But stdio is often included before some of these includes, so these heavy inline functions actually have to be compiled in many cases. The result is that the build time significantly increased, especially with fast compilers like gcc -O0 which took +50% or TCC which took +100%! This patch addresses the problem by instead relying on an explicit macro HA_EXPOSE_FLAGS that the calling program must explicitly define before including these files. flags.c does this and that's all. The previous build time is now restored with a speed up of 20 to 50% depending on the build options.
2022-11-24 07:22:40 +00:00
/* make the include files below expose their flags */
#define HA_EXPOSE_FLAGS
REORG: include: move channel.h to haproxy/channel{,-t}.h The files were moved with no change. The callers were cleaned up a bit and a few of them had channel.h removed since not needed.
2020-06-04 19:07:02 +00:00
#include <haproxy/channel-t.h>
REORG: include: move connection.h to haproxy/connection{,-t}.h The type file is becoming a mess, half of it is for the proxy protocol, another good part describes conn_streams and mux ops, it would deserve being split again. At least it was reordered so that elements are easier to find, with the PP-stuff left at the end. The MAX_SEND_FD macro was moved to compat.h as it's said to be the value for Linux.
2020-06-04 16:02:10 +00:00
#include <haproxy/connection-t.h>
MINOR: flags/fd: decode FD flags states The new function is fd_show_flags() and it reports known FD flags: $ ./dev/flags/flags fd 0x000121 fd->flags = FD_POLL_IN | FD_EV_READY_W | FD_EV_ACTIVE_R
2022-09-12 16:53:06 +00:00
#include <haproxy/fd-t.h>
REORG: include: move http_ana.h to haproxy/http_ana{,-t}.h It was moved without any change, however many callers didn't need it at all. This was a consequence of the split of proto_http.c into several parts that resulted in many locations to still reference it.
2020-06-04 19:21:03 +00:00
#include <haproxy/http_ana-t.h>
MINOR: flags/htx: use flag dumping to show htx and start-line flags The function are respectively htx_show_flags() and hsl_show_flags().
2022-09-09 14:59:29 +00:00
#include <haproxy/htx-t.h>
MINOR: flags/mux-fcgi: Decode FCGI connection and stream flags The new functions fconn_show_flags() and fstrm_show_flags() decode the flags state into a string, and are used by dev/flags: $ /dev/flags/flags fconn 0x3100 fconn->flags = FCGI_CF_GET_VALUES | FCGI_CF_KEEP_CONN | FCGI_CF_MPXS_CONNS ./dev/flags/flags fstrm 0x3300 fstrm->flags = FCGI_SF_WANT_SHUTW | FCGI_SF_WANT_SHUTR | FCGI_SF_OUTGOING_DATA | FCGI_SF_BEGIN_SENT
2022-10-12 15:00:13 +00:00
#include <haproxy/mux_fcgi-t.h>
MINOR: flags/mux-h2: decode H2C and H2S flags The new functions h2c_show_flags() and h2s_show_flags() decode the flags state into a string, and are used by dev/flags: $ ./dev/flags/flags h2c 0x0600 h2c->flags = H2_CF_DEM_IN_PROGRESS | H2_CF_DEM_SHORT_READ $ ./dev/flags/flags h2s 0x7003 h2s->flags = H2_SF_HEADERS_RCVD | H2_SF_OUTGOING_DATA | H2_SF_HEADERS_SENT \ | H2_SF_ES_SENT | H2_SF_ES_RCVD
2022-09-12 17:20:23 +00:00
#include <haproxy/mux_h2-t.h>
MINOR: flags/mux-h1: decode H1C and H1S flags The new functions h1c_show_flags() and h1s_show_flags() decode the flags state into a string, and are used by dev/flags: $ /dev/flags/flags h1c 0x2200 h1c->flags = H1C_F_ST_READY | H1C_F_ST_ATTACHED ./dev/flags/flags h1s 0x190 h1s->flags = H1S_F_BODYLESS_RESP | H1S_F_NOT_FIRST | H1S_F_WANT_KAL
2022-09-15 08:54:36 +00:00
#include <haproxy/mux_h1-t.h>
MINOR: flags/mux-quic: decode qcc and qcs flags Decode QUIC MUX connection and stream elements via qcc_show_flags() and qcs_show_flags(). Flags definition have been moved outside of USE_QUIC to ease compilation of flags binary.
2024-07-31 15:58:02 +00:00
#include <haproxy/mux_quic-t.h>
MEDIUM: mux-spop: Introduce the SPOP multiplexer It is no possible yet to use it. Idles connections and pipelining mode are not supported for now. But it should be possible to open a SPOP connection, perform the HELLO handshake, send a NOTIFY frame based on data produced by the client side and receive the corresponding ACK frame to transfer its content to the client side. The related issue is #2502.
2024-07-04 09:37:23 +00:00
#include <haproxy/mux_spop-t.h>
DEV: flags/peers: Decode PEER and PEERS flags Decode peer and peers flags via peer_show_flags() and peers_show_flags() functions.
2024-04-25 07:43:16 +00:00
#include <haproxy/peers-t.h>
DEV: flags/quic: decode quic_conn flags Decode quic_conn flags via qc_show_flags() function. To support this, quic flags definition have been put outside of USE_QUIC directive.
2024-06-17 13:36:08 +00:00
#include <haproxy/quic_conn-t.h>
MINOR: flags/fd: decode FD flags states The new function is fd_show_flags() and it reports known FD flags: $ ./dev/flags/flags fd 0x000121 fd->flags = FD_POLL_IN | FD_EV_READY_W | FD_EV_ACTIVE_R
2022-09-12 16:53:06 +00:00
#include <haproxy/stconn-t.h>
REORG: include: move stream.h to haproxy/stream{,-t}.h This one was not easy because it was embarking many includes with it, which other files would automatically find. At least global.h, arg.h and tools.h were identified. 93 total locations were identified, 8 additional includes had to be added. In the rare files where it was possible to finalize the sorting of includes by adjusting only one or two extra lines, it was done. But all files would need to be rechecked and cleaned up now. It was the last set of files in types/ and proto/ and these directories must not be reused anymore.
2020-06-04 21:46:14 +00:00
#include <haproxy/stream-t.h>
REORG: include: move task.h to haproxy/task{,-t}.h The TASK_IS_TASKLET() macro was moved to the proto file instead of the type one. The proto part was a bit reordered to remove a number of ugly forward declaration of static inline functions. About a tens of C and H files had their dependency dropped since they were not using anything from task.h.
2020-06-04 15:25:40 +00:00
#include <haproxy/task-t.h>
CONTRIB: initiate a debugging suite to make debugging easier The goal is to have a collection of quick-n-dirty utilities that make debugging easier and that can easily be modified when needed. The first utility in this series is called "flags". For a given numeric argument, it reports the various known combinations of flags for channels, streams and so on. This way it's easy to copy-paste values from the CLI or from gdb and immediately know what state a stream-interface or connection is in.
2015-12-20 22:21:57 +00:00
CONTRIB: debug: add the possibility to decode the value as certain types only It's often confusing to have a whole dump on the screen while only checking for a set of task or stream flags, and appending "|grep ^chn" isn't very convenient to repeat the opeation. Instead let's add the ability to filter the output as certain types only by prepending their name(s) before the value.
2020-02-06 07:33:08 +00:00
// 1 bit per flag, no hole permitted here
#define SHOW_AS_ANA 0x00000001
#define SHOW_AS_CHN 0x00000002
#define SHOW_AS_CONN 0x00000004
DEV: flags: use "sc" for stream conns instead of "cs" "cs" used to stand for "conn_stream" while these objects are now called "stream connectors", "stconn" or "sc". Let's just use "sc" here.
2022-05-27 07:57:31 +00:00
#define SHOW_AS_SC 0x00000008
DEV: flags: No longer dump SI flags stream-interface API is no longer used. And there is no more SI flags. Thus, the stream-interface's flags are no longer dumped by "flags" tool.
2022-04-04 09:28:27 +00:00
#define SHOW_AS_SET 0x00000010
#define SHOW_AS_STRM 0x00000020
#define SHOW_AS_TASK 0x00000040
#define SHOW_AS_TXN 0x00000080
DEV: flags: rename the "endp" shortcut to "sd" for "stream descriptor" This way we don't keep the possibly confusing endp one anymore.
2022-05-27 14:29:30 +00:00
#define SHOW_AS_SD 0x00000100
MINOR: flags/htx: use flag dumping to show htx and start-line flags The function are respectively htx_show_flags() and hsl_show_flags().
2022-09-09 14:59:29 +00:00
#define SHOW_AS_HSL 0x00000200
#define SHOW_AS_HTX 0x00000400
MINOR: flags/http_ana: use flag dumping to show http msg states The function is hmsg_show_flags(). It shows the HTTP_MSGF_* flags.
2022-09-09 15:18:57 +00:00
#define SHOW_AS_HMSG 0x00000800
MINOR: flags/fd: decode FD flags states The new function is fd_show_flags() and it reports known FD flags: $ ./dev/flags/flags fd 0x000121 fd->flags = FD_POLL_IN | FD_EV_READY_W | FD_EV_ACTIVE_R
2022-09-12 16:53:06 +00:00
#define SHOW_AS_FD 0x00001000
MINOR: flags/mux-h2: decode H2C and H2S flags The new functions h2c_show_flags() and h2s_show_flags() decode the flags state into a string, and are used by dev/flags: $ ./dev/flags/flags h2c 0x0600 h2c->flags = H2_CF_DEM_IN_PROGRESS | H2_CF_DEM_SHORT_READ $ ./dev/flags/flags h2s 0x7003 h2s->flags = H2_SF_HEADERS_RCVD | H2_SF_OUTGOING_DATA | H2_SF_HEADERS_SENT \ | H2_SF_ES_SENT | H2_SF_ES_RCVD
2022-09-12 17:20:23 +00:00
#define SHOW_AS_H2C 0x00002000
#define SHOW_AS_H2S 0x00004000
MINOR: flags/mux-h1: decode H1C and H1S flags The new functions h1c_show_flags() and h1s_show_flags() decode the flags state into a string, and are used by dev/flags: $ /dev/flags/flags h1c 0x2200 h1c->flags = H1C_F_ST_READY | H1C_F_ST_ATTACHED ./dev/flags/flags h1s 0x190 h1s->flags = H1S_F_BODYLESS_RESP | H1S_F_NOT_FIRST | H1S_F_WANT_KAL
2022-09-15 08:54:36 +00:00
#define SHOW_AS_H1C 0x00008000
#define SHOW_AS_H1S 0x00010000
MINOR: flags/mux-fcgi: Decode FCGI connection and stream flags The new functions fconn_show_flags() and fstrm_show_flags() decode the flags state into a string, and are used by dev/flags: $ /dev/flags/flags fconn 0x3100 fconn->flags = FCGI_CF_GET_VALUES | FCGI_CF_KEEP_CONN | FCGI_CF_MPXS_CONNS ./dev/flags/flags fstrm 0x3300 fstrm->flags = FCGI_SF_WANT_SHUTW | FCGI_SF_WANT_SHUTR | FCGI_SF_OUTGOING_DATA | FCGI_SF_BEGIN_SENT
2022-10-12 15:00:13 +00:00
#define SHOW_AS_FCONN 0x00020000
#define SHOW_AS_FSTRM 0x00040000
DEV: flags/peers: Decode PEER and PEERS flags Decode peer and peers flags via peer_show_flags() and peers_show_flags() functions.
2024-04-25 07:43:16 +00:00
#define SHOW_AS_PEERS 0x00080000
#define SHOW_AS_PEER 0x00100000
DEV: flags/quic: decode quic_conn flags Decode quic_conn flags via qc_show_flags() function. To support this, quic flags definition have been put outside of USE_QUIC directive.
2024-06-17 13:36:08 +00:00
#define SHOW_AS_QC 0x00200000
MEDIUM: mux-spop: Introduce the SPOP multiplexer It is no possible yet to use it. Idles connections and pipelining mode are not supported for now. But it should be possible to open a SPOP connection, perform the HELLO handshake, send a NOTIFY frame based on data produced by the client side and receive the corresponding ACK frame to transfer its content to the client side. The related issue is #2502.
2024-07-04 09:37:23 +00:00
#define SHOW_AS_SPOPC 0x00400000
#define SHOW_AS_SPOPS 0x00800000
MINOR: flags/mux-quic: decode qcc and qcs flags Decode QUIC MUX connection and stream elements via qcc_show_flags() and qcs_show_flags(). Flags definition have been moved outside of USE_QUIC to ease compilation of flags binary.
2024-07-31 15:58:02 +00:00
#define SHOW_AS_QCC 0x01000000
#define SHOW_AS_QCS 0x02000000
CONTRIB: debug: add the possibility to decode the value as certain types only It's often confusing to have a whole dump on the screen while only checking for a set of task or stream flags, and appending "|grep ^chn" isn't very convenient to repeat the opeation. Instead let's add the ability to filter the output as certain types only by prepending their name(s) before the value.
2020-02-06 07:33:08 +00:00
// command line names, must be in exact same order as the SHOW_AS_* flags above
// so that show_as_words[i] matches flag 1U<<i.
DEV: flags/peers: Decode PEER and PEERS flags Decode peer and peers flags via peer_show_flags() and peers_show_flags() functions.
2024-04-25 07:43:16 +00:00
const char *show_as_words[] = { "ana", "chn", "conn", "sc", "stet", "strm", "task", "txn", "sd", "hsl", "htx", "hmsg", "fd", "h2c", "h2s", "h1c", "h1s", "fconn", "fstrm",
MINOR: flags/mux-quic: decode qcc and qcs flags Decode QUIC MUX connection and stream elements via qcc_show_flags() and qcs_show_flags(). Flags definition have been moved outside of USE_QUIC to ease compilation of flags binary.
2024-07-31 15:58:02 +00:00
"peers", "peer", "qc", "spopc", "spops", "qcc", "qcs"};
CONTRIB: debug: add the possibility to decode the value as certain types only It's often confusing to have a whole dump on the screen while only checking for a set of task or stream flags, and appending "|grep ^chn" isn't very convenient to repeat the opeation. Instead let's add the ability to filter the output as certain types only by prepending their name(s) before the value.
2020-02-06 07:33:08 +00:00
MINOR: flags/channel: use flag dumping for channel flags and analysers The two new functions are chn_show_analysers() and chn_show_flags(). They work on an existing buffer so one was declared in flags.c for this purpose. File flags.c does not have to know about channel flags anymore.
2022-09-09 12:51:57 +00:00
/* will be sufficient for even largest flag names */
DEV: flags: remove the now useless intermediary functions There's no more point keeping functions that are just wrappers around other ones, let's directly call them from the main entry point. It helps visually control the mapping between output formats and their definition and doesn't require to invent long names. For a bit more readability, the tmpbuf and its size adopted slightly shorter names.
2022-09-09 14:47:43 +00:00
static char buf[4096];
static size_t bsz = sizeof(buf);
MINOR: flags/channel: use flag dumping for channel flags and analysers The two new functions are chn_show_analysers() and chn_show_flags(). They work on an existing buffer so one was declared in flags.c for this purpose. File flags.c does not have to know about channel flags anymore.
2022-09-09 12:51:57 +00:00
CONTRIB: debug: add the possibility to decode the value as certain types only It's often confusing to have a whole dump on the screen while only checking for a set of task or stream flags, and appending "|grep ^chn" isn't very convenient to repeat the opeation. Instead let's add the ability to filter the output as certain types only by prepending their name(s) before the value.
2020-02-06 07:33:08 +00:00
unsigned int get_show_as(const char *word)
{
int w = 0;
while (1) {
if (w == sizeof(show_as_words) / sizeof(*show_as_words))
return 0;
if (strcmp(word, show_as_words[w]) == 0)
return 1U << w;
w++;
}
}
void usage_exit(const char *name)
{
DEV: flags: fix usage message to reflect available options The proposed decoding options were not updated after the changes in 2.6, let's fix that by taking the names from the existing declaration. This should be backported to 2.6.
2022-09-09 12:16:49 +00:00
int word, nbword;
fprintf(stderr, "Usage: %s [", name);
nbword = sizeof(show_as_words) / sizeof(*show_as_words);
for (word = 0; word < nbword; word++)
fprintf(stderr, "%s%s", word ? "|" : "", show_as_words[word]);
fprintf(stderr, "]* { [+-][0x]value* | - }\n");
CONTRIB: debug: add the possibility to decode the value as certain types only It's often confusing to have a whole dump on the screen while only checking for a set of task or stream flags, and appending "|grep ^chn" isn't very convenient to repeat the opeation. Instead let's add the ability to filter the output as certain types only by prepending their name(s) before the value.
2020-02-06 07:33:08 +00:00
exit(1);
}
CONTRIB: initiate a debugging suite to make debugging easier The goal is to have a collection of quick-n-dirty utilities that make debugging easier and that can easily be modified when needed. The first utility in this series is called "flags". For a given numeric argument, it reports the various known combinations of flags for channels, streams and so on. This way it's easy to copy-paste values from the CLI or from gdb and immediately know what state a stream-interface or connection is in.
2015-12-20 22:21:57 +00:00
int main(int argc, char **argv)
{
unsigned int flags;
CONTRIB: debug: add the possibility to decode the value as certain types only It's often confusing to have a whole dump on the screen while only checking for a set of task or stream flags, and appending "|grep ^chn" isn't very convenient to repeat the opeation. Instead let's add the ability to filter the output as certain types only by prepending their name(s) before the value.
2020-02-06 07:33:08 +00:00
unsigned int show_as = 0;
unsigned int f;
const char *name = argv[0];
CONTRIB: debug: also support reading values from stdin This is convenient when processing large dumps, it allows to copy-paste values to inspect from one window to another, or to directly transfer a "show fd"/"show stream" output through sed. In order to do this, simply pass "-" alone instead of the value and they will all be read one line at a time from stdin. For example, in order to quickly print the different set of connection flags from "show fd", this is sufficient: sed -ne 's/^.* cflg=\([^ ]*\).*/\1/p' | contrib/debug/flags conn -
2020-02-06 17:17:50 +00:00
char line[20];
char *value;
CONTRIB: debug: support reporting multiple values at once It's often convenient, for example to dump two channels or two stream-int at once. Now all input values are decoded and the value is recalled before the dump when there is more than one to display.
2020-02-06 07:48:16 +00:00
int multi = 0;
CONTRIB: debug: also support reading values from stdin This is convenient when processing large dumps, it allows to copy-paste values to inspect from one window to another, or to directly transfer a "show fd"/"show stream" output through sed. In order to do this, simply pass "-" alone instead of the value and they will all be read one line at a time from stdin. For example, in order to quickly print the different set of connection flags from "show fd", this is sufficient: sed -ne 's/^.* cflg=\([^ ]*\).*/\1/p' | contrib/debug/flags conn -
2020-02-06 17:17:50 +00:00
int use_stdin = 0;
CONTRIB: debug: add the possibility to decode the value as certain types only It's often confusing to have a whole dump on the screen while only checking for a set of task or stream flags, and appending "|grep ^chn" isn't very convenient to repeat the opeation. Instead let's add the ability to filter the output as certain types only by prepending their name(s) before the value.
2020-02-06 07:33:08 +00:00
char *err;
while (argc > 0) {
argv++; argc--;
if (argc < 1)
usage_exit(name);
f = get_show_as(argv[0]);
CONTRIB: debug: support reporting multiple values at once It's often convenient, for example to dump two channels or two stream-int at once. Now all input values are decoded and the value is recalled before the dump when there is more than one to display.
2020-02-06 07:48:16 +00:00
if (!f)
break;
CONTRIB: debug: add the possibility to decode the value as certain types only It's often confusing to have a whole dump on the screen while only checking for a set of task or stream flags, and appending "|grep ^chn" isn't very convenient to repeat the opeation. Instead let's add the ability to filter the output as certain types only by prepending their name(s) before the value.
2020-02-06 07:33:08 +00:00
show_as |= f;
CONTRIB: initiate a debugging suite to make debugging easier The goal is to have a collection of quick-n-dirty utilities that make debugging easier and that can easily be modified when needed. The first utility in this series is called "flags". For a given numeric argument, it reports the various known combinations of flags for channels, streams and so on. This way it's easy to copy-paste values from the CLI or from gdb and immediately know what state a stream-interface or connection is in.
2015-12-20 22:21:57 +00:00
}
CONTRIB: debug: add the possibility to decode the value as certain types only It's often confusing to have a whole dump on the screen while only checking for a set of task or stream flags, and appending "|grep ^chn" isn't very convenient to repeat the opeation. Instead let's add the ability to filter the output as certain types only by prepending their name(s) before the value.
2020-02-06 07:33:08 +00:00
if (!show_as)
show_as = ~0U;
CONTRIB: debug: support reporting multiple values at once It's often convenient, for example to dump two channels or two stream-int at once. Now all input values are decoded and the value is recalled before the dump when there is more than one to display.
2020-02-06 07:48:16 +00:00
if (argc > 1)
multi = 1;
CONTRIB: initiate a debugging suite to make debugging easier The goal is to have a collection of quick-n-dirty utilities that make debugging easier and that can easily be modified when needed. The first utility in this series is called "flags". For a given numeric argument, it reports the various known combinations of flags for channels, streams and so on. This way it's easy to copy-paste values from the CLI or from gdb and immediately know what state a stream-interface or connection is in.
2015-12-20 22:21:57 +00:00
CONTRIB: debug: also support reading values from stdin This is convenient when processing large dumps, it allows to copy-paste values to inspect from one window to another, or to directly transfer a "show fd"/"show stream" output through sed. In order to do this, simply pass "-" alone instead of the value and they will all be read one line at a time from stdin. For example, in order to quickly print the different set of connection flags from "show fd", this is sufficient: sed -ne 's/^.* cflg=\([^ ]*\).*/\1/p' | contrib/debug/flags conn -
2020-02-06 17:17:50 +00:00
if (strcmp(argv[0], "-") == 0)
use_stdin = 1;
CONTRIB: debug: support reporting multiple values at once It's often convenient, for example to dump two channels or two stream-int at once. Now all input values are decoded and the value is recalled before the dump when there is more than one to display.
2020-02-06 07:48:16 +00:00
while (argc > 0) {
CONTRIB: debug: also support reading values from stdin This is convenient when processing large dumps, it allows to copy-paste values to inspect from one window to another, or to directly transfer a "show fd"/"show stream" output through sed. In order to do this, simply pass "-" alone instead of the value and they will all be read one line at a time from stdin. For example, in order to quickly print the different set of connection flags from "show fd", this is sufficient: sed -ne 's/^.* cflg=\([^ ]*\).*/\1/p' | contrib/debug/flags conn -
2020-02-06 17:17:50 +00:00
if (use_stdin) {
value = fgets(line, sizeof(line), stdin);
if (!value)
break;
CLEANUP: assorted typo fixes in the code and comments This is sixth iteration of typo fixes
2020-04-02 10:25:26 +00:00
/* skip common leading delimiters that slip from copy-paste */
CONTRIB: debug: also support reading values from stdin This is convenient when processing large dumps, it allows to copy-paste values to inspect from one window to another, or to directly transfer a "show fd"/"show stream" output through sed. In order to do this, simply pass "-" alone instead of the value and they will all be read one line at a time from stdin. For example, in order to quickly print the different set of connection flags from "show fd", this is sufficient: sed -ne 's/^.* cflg=\([^ ]*\).*/\1/p' | contrib/debug/flags conn -
2020-02-06 17:17:50 +00:00
while (*value == ' ' || *value == '\t' || *value == ':' || *value == '=')
value++;
/* stop at the end of the number and trim any C suffix like "UL" */
err = value;
while (*err == '-' || *err == '+' ||
CONTRIB: halog: fix issue with array of type char I just noticed this in the windows build after moving the file to dev/: In file included from include/import/ist.h:32, from include/haproxy/connection-t.h:32, from dev/flags/flags.c:5: dev/flags/flags.c: In function `main': dev/flags/flags.c:442:20: error: array subscript has type `char' [-Werror=char-subscripts] 442 | (isalnum(*err) && toupper(*err) != 'U' && toupper(*err) != 'L')) | ^~~~ LD haproxy cc1: all warnings being treated as errors make: *** [Makefile:932: dev/flags/flags.o] Error 1 make: *** Waiting for unfinished jobs.... Error: Process completed with exit code 2. Let's just cast it to uchar as is done everywhere else.
2021-04-02 15:47:21 +00:00
(isalnum((unsigned char)*err) && toupper((unsigned char)*err) != 'U' && toupper((unsigned char)*err) != 'L'))
CONTRIB: debug: also support reading values from stdin This is convenient when processing large dumps, it allows to copy-paste values to inspect from one window to another, or to directly transfer a "show fd"/"show stream" output through sed. In order to do this, simply pass "-" alone instead of the value and they will all be read one line at a time from stdin. For example, in order to quickly print the different set of connection flags from "show fd", this is sufficient: sed -ne 's/^.* cflg=\([^ ]*\).*/\1/p' | contrib/debug/flags conn -
2020-02-06 17:17:50 +00:00
err++;
CLEANUP: dev/flags: remove useless test in the stdin number parser The test on "if (err)" after parsing a number was meant to be "if (*err)" but in practise it will always be true since we at least have a '\n' there, so no need for testing before writing zero. This fixes issue #1211.
2021-04-03 13:26:56 +00:00
*err = 0;
CONTRIB: debug: also support reading values from stdin This is convenient when processing large dumps, it allows to copy-paste values to inspect from one window to another, or to directly transfer a "show fd"/"show stream" output through sed. In order to do this, simply pass "-" alone instead of the value and they will all be read one line at a time from stdin. For example, in order to quickly print the different set of connection flags from "show fd", this is sufficient: sed -ne 's/^.* cflg=\([^ ]*\).*/\1/p' | contrib/debug/flags conn -
2020-02-06 17:17:50 +00:00
} else {
value = argv[0];
argv++; argc--;
}
flags = strtoul(value, &err, 0);
if (!*value || *err) {
fprintf(stderr, "Unparsable value: <%s>\n", value);
CONTRIB: debug: support reporting multiple values at once It's often convenient, for example to dump two channels or two stream-int at once. Now all input values are decoded and the value is recalled before the dump when there is more than one to display.
2020-02-06 07:48:16 +00:00
usage_exit(name);
}
CONTRIB: debug: also support reading values from stdin This is convenient when processing large dumps, it allows to copy-paste values to inspect from one window to another, or to directly transfer a "show fd"/"show stream" output through sed. In order to do this, simply pass "-" alone instead of the value and they will all be read one line at a time from stdin. For example, in order to quickly print the different set of connection flags from "show fd", this is sufficient: sed -ne 's/^.* cflg=\([^ ]*\).*/\1/p' | contrib/debug/flags conn -
2020-02-06 17:17:50 +00:00
if (multi || use_stdin)
CONTRIB: debug: support reporting multiple values at once It's often convenient, for example to dump two channels or two stream-int at once. Now all input values are decoded and the value is recalled before the dump when there is more than one to display.
2020-02-06 07:48:16 +00:00
printf("### 0x%08x:\n", flags);
DEV: flags: remove the now useless intermediary functions There's no more point keeping functions that are just wrappers around other ones, let's directly call them from the main entry point. It helps visually control the mapping between output formats and their definition and doesn't require to invent long names. For a bit more readability, the tmpbuf and its size adopted slightly shorter names.
2022-09-09 14:47:43 +00:00
if (show_as & SHOW_AS_ANA) printf("chn->ana = %s\n", (chn_show_analysers(buf, bsz, " | ", flags), buf));
if (show_as & SHOW_AS_CHN) printf("chn->flags = %s\n", (chn_show_flags (buf, bsz, " | ", flags), buf));
if (show_as & SHOW_AS_CONN) printf("conn->flags = %s\n", (conn_show_flags (buf, bsz, " | ", flags), buf));
if (show_as & SHOW_AS_SC) printf("sc->flags = %s\n", (sc_show_flags (buf, bsz, " | ", flags), buf));
if (show_as & SHOW_AS_SD) printf("sd->flags = %s\n", (se_show_flags (buf, bsz, " | ", flags), buf));
if (show_as & SHOW_AS_SET) printf("strm->et = %s\n", (strm_et_show_flags(buf, bsz, " | ", flags), buf));
if (show_as & SHOW_AS_STRM) printf("strm->flags = %s\n", (strm_show_flags (buf, bsz, " | ", flags), buf));
if (show_as & SHOW_AS_TASK) printf("task->state = %s\n", (task_show_state (buf, bsz, " | ", flags), buf));
if (show_as & SHOW_AS_TXN) printf("txn->flags = %s\n", (txn_show_flags (buf, bsz, " | ", flags), buf));
MINOR: flags/htx: use flag dumping to show htx and start-line flags The function are respectively htx_show_flags() and hsl_show_flags().
2022-09-09 14:59:29 +00:00
if (show_as & SHOW_AS_HSL) printf("sl->flags = %s\n", (hsl_show_flags (buf, bsz, " | ", flags), buf));
if (show_as & SHOW_AS_HTX) printf("htx->flags = %s\n", (htx_show_flags (buf, bsz, " | ", flags), buf));
MINOR: flags/http_ana: use flag dumping to show http msg states The function is hmsg_show_flags(). It shows the HTTP_MSGF_* flags.
2022-09-09 15:18:57 +00:00
if (show_as & SHOW_AS_HMSG) printf("hmsg->flags = %s\n", (hmsg_show_flags (buf, bsz, " | ", flags), buf));
MINOR: flags/fd: decode FD flags states The new function is fd_show_flags() and it reports known FD flags: $ ./dev/flags/flags fd 0x000121 fd->flags = FD_POLL_IN | FD_EV_READY_W | FD_EV_ACTIVE_R
2022-09-12 16:53:06 +00:00
if (show_as & SHOW_AS_FD) printf("fd->flags = %s\n", (fd_show_flags (buf, bsz, " | ", flags), buf));
MINOR: flags/mux-h2: decode H2C and H2S flags The new functions h2c_show_flags() and h2s_show_flags() decode the flags state into a string, and are used by dev/flags: $ ./dev/flags/flags h2c 0x0600 h2c->flags = H2_CF_DEM_IN_PROGRESS | H2_CF_DEM_SHORT_READ $ ./dev/flags/flags h2s 0x7003 h2s->flags = H2_SF_HEADERS_RCVD | H2_SF_OUTGOING_DATA | H2_SF_HEADERS_SENT \ | H2_SF_ES_SENT | H2_SF_ES_RCVD
2022-09-12 17:20:23 +00:00
if (show_as & SHOW_AS_H2C) printf("h2c->flags = %s\n", (h2c_show_flags (buf, bsz, " | ", flags), buf));
if (show_as & SHOW_AS_H2S) printf("h2s->flags = %s\n", (h2s_show_flags (buf, bsz, " | ", flags), buf));
MINOR: flags/mux-h1: decode H1C and H1S flags The new functions h1c_show_flags() and h1s_show_flags() decode the flags state into a string, and are used by dev/flags: $ /dev/flags/flags h1c 0x2200 h1c->flags = H1C_F_ST_READY | H1C_F_ST_ATTACHED ./dev/flags/flags h1s 0x190 h1s->flags = H1S_F_BODYLESS_RESP | H1S_F_NOT_FIRST | H1S_F_WANT_KAL
2022-09-15 08:54:36 +00:00
if (show_as & SHOW_AS_H1C) printf("h1c->flags = %s\n", (h1c_show_flags (buf, bsz, " | ", flags), buf));
if (show_as & SHOW_AS_H1S) printf("h1s->flags = %s\n", (h1s_show_flags (buf, bsz, " | ", flags), buf));
MINOR: flags/mux-fcgi: Decode FCGI connection and stream flags The new functions fconn_show_flags() and fstrm_show_flags() decode the flags state into a string, and are used by dev/flags: $ /dev/flags/flags fconn 0x3100 fconn->flags = FCGI_CF_GET_VALUES | FCGI_CF_KEEP_CONN | FCGI_CF_MPXS_CONNS ./dev/flags/flags fstrm 0x3300 fstrm->flags = FCGI_SF_WANT_SHUTW | FCGI_SF_WANT_SHUTR | FCGI_SF_OUTGOING_DATA | FCGI_SF_BEGIN_SENT
2022-10-12 15:00:13 +00:00
if (show_as & SHOW_AS_FCONN) printf("fconn->flags = %s\n",(fconn_show_flags (buf, bsz, " | ", flags), buf));
if (show_as & SHOW_AS_FSTRM) printf("fstrm->flags = %s\n",(fstrm_show_flags (buf, bsz, " | ", flags), buf));
DEV: flags/peers: Decode PEER and PEERS flags Decode peer and peers flags via peer_show_flags() and peers_show_flags() functions.
2024-04-25 07:43:16 +00:00
if (show_as & SHOW_AS_PEERS) printf("peers->flags = %s\n",(peers_show_flags (buf, bsz, " | ", flags), buf));
if (show_as & SHOW_AS_PEER) printf("peer->flags = %s\n", (peer_show_flags (buf, bsz, " | ", flags), buf));
DEV: flags/quic: decode quic_conn flags Decode quic_conn flags via qc_show_flags() function. To support this, quic flags definition have been put outside of USE_QUIC directive.
2024-06-17 13:36:08 +00:00
if (show_as & SHOW_AS_QC) printf("qc->flags = %s\n", (qc_show_flags (buf, bsz, " | ", flags), buf));
MEDIUM: mux-spop: Introduce the SPOP multiplexer It is no possible yet to use it. Idles connections and pipelining mode are not supported for now. But it should be possible to open a SPOP connection, perform the HELLO handshake, send a NOTIFY frame based on data produced by the client side and receive the corresponding ACK frame to transfer its content to the client side. The related issue is #2502.
2024-07-04 09:37:23 +00:00
if (show_as & SHOW_AS_SPOPC) printf("spopc->flags = %s\n",(spop_conn_show_flags(buf, bsz, " | ", flags), buf));
if (show_as & SHOW_AS_SPOPS) printf("spops->flags = %s\n",(spop_strm_show_flags(buf, bsz, " | ", flags), buf));
MINOR: flags/mux-quic: decode qcc and qcs flags Decode QUIC MUX connection and stream elements via qcc_show_flags() and qcs_show_flags(). Flags definition have been moved outside of USE_QUIC to ease compilation of flags binary.
2024-07-31 15:58:02 +00:00
if (show_as & SHOW_AS_QCC) printf("qcc->flags = %s\n", (qcc_show_flags (buf, bsz, " | ", flags), buf));
if (show_as & SHOW_AS_QCS) printf("qcs->flags = %s\n", (qcs_show_flags (buf, bsz, " | ", flags), buf));
CONTRIB: debug: support reporting multiple values at once It's often convenient, for example to dump two channels or two stream-int at once. Now all input values are decoded and the value is recalled before the dump when there is more than one to display.
2020-02-06 07:48:16 +00:00
}
CONTRIB: initiate a debugging suite to make debugging easier The goal is to have a collection of quick-n-dirty utilities that make debugging easier and that can easily be modified when needed. The first utility in this series is called "flags". For a given numeric argument, it reports the various known combinations of flags for channels, streams and so on. This way it's easy to copy-paste values from the CLI or from gdb and immediately know what state a stream-interface or connection is in.
2015-12-20 22:21:57 +00:00
return 0;
}