perf util: Add helpers to parse task state string from libtraceevent

Perf uses a hard coded string "RSDTtXZPI" to index the sched_switch
prev_state field raw bitmask value. This works well except for when
the kernel changes this string, in which case this will break again.

Instead we add a new way to parse task state string from tracepoint
print format already recorded by perf, which eliminates the further
dependencies with this hardcode and unmaintainable macro, and this
is exactly what libtraceevent[1] does for now.

So we borrow the print flags parsing logic from libtraceevent[1].
And in get_states(), we walk the print arguments until the
__print_flags() for the target state field is found, and use that to
build the states string for future parsing.

[1]: https://lore.kernel.org/linux-trace-devel/20231224140732.7d41698d@rorschach.local.home/

Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>
Signed-off-by: Ze Gao <zegao@tencent.com>
Link: https://lore.kernel.org/r/20240122070859.1394479-4-zegao@tencent.com
Signed-off-by: Namhyung Kim <namhyung@kernel.org>

diff --git a/tools/perf/util/evsel.c b/tools/perf/util/evsel.c
index 6d7c9c58a9bcb8b7ed70e38286026cac16543163..e08294c51cd437fc8518fef9bcb8e74f8f6da28c 100644 (file)
--- a/tools/perf/util/evsel.c
+++ b/tools/perf/util/evsel.c
@@ -2851,6 +2851,118 @@ u64 evsel__intval_common(struct evsel *evsel, struct perf_sample *sample, const
        return field ? format_field__intval(field, sample, evsel->needs_swap) : 0;
 }
 
+/*
+ * prev_state is of size long, which is 32 bits on 32 bit architectures.
+ * As it needs to have the same bits for both 32 bit and 64 bit architectures
+ * we can just assume that the flags we care about will all be within
+ * the 32 bits.
+ */
+#define MAX_STATE_BITS 32
+
+static const char *convert_sym(struct tep_print_flag_sym *sym)
+{
+       static char save_states[MAX_STATE_BITS + 1];
+
+       memset(save_states, 0, sizeof(save_states));
+
+       /* This is the flags for the prev_state_field, now make them into a string */
+       for (; sym; sym = sym->next) {
+               long bitmask = strtoul(sym->value, NULL, 0);
+               int i;
+
+               for (i = 0; !(bitmask & 1); i++)
+                       bitmask >>= 1;
+
+               if (i >= MAX_STATE_BITS)
+                       continue;
+
+               save_states[i] = sym->str[0];
+       }
+
+       return save_states;
+}
+
+static struct tep_print_arg_field *
+find_arg_field(struct tep_format_field *prev_state_field, struct tep_print_arg *arg)
+{
+       struct tep_print_arg_field *field;
+
+       if (!arg)
+               return NULL;
+
+       if (arg->type == TEP_PRINT_FIELD)
+               return &arg->field;
+
+       if (arg->type == TEP_PRINT_OP) {
+               field = find_arg_field(prev_state_field, arg->op.left);
+               if (field && field->field == prev_state_field)
+                       return field;
+               field = find_arg_field(prev_state_field, arg->op.right);
+               if (field && field->field == prev_state_field)
+                       return field;
+       }
+       return NULL;
+}
+
+static struct tep_print_flag_sym *
+test_flags(struct tep_format_field *prev_state_field, struct tep_print_arg *arg)
+{
+       struct tep_print_arg_field *field;
+
+       field = find_arg_field(prev_state_field, arg->flags.field);
+       if (!field)
+               return NULL;
+
+       return arg->flags.flags;
+}
+
+static struct tep_print_flag_sym *
+search_op(struct tep_format_field *prev_state_field, struct tep_print_arg *arg)
+{
+       struct tep_print_flag_sym *sym = NULL;
+
+       if (!arg)
+               return NULL;
+
+       if (arg->type == TEP_PRINT_OP) {
+               sym = search_op(prev_state_field, arg->op.left);
+               if (sym)
+                       return sym;
+
+               sym = search_op(prev_state_field, arg->op.right);
+               if (sym)
+                       return sym;
+       } else if (arg->type == TEP_PRINT_FLAGS) {
+               sym = test_flags(prev_state_field, arg);
+       }
+
+       return sym;
+}
+
+static __maybe_unused const char *get_states(struct tep_format_field *prev_state_field)
+{
+       struct tep_print_flag_sym *sym;
+       struct tep_print_arg *arg;
+       struct tep_event *event;
+
+       event = prev_state_field->event;
+
+       /*
+        * Look at the event format fields, and search for where
+        * the prev_state is parsed via the format flags.
+        */
+       for (arg = event->print_fmt.args; arg; arg = arg->next) {
+               /*
+                * Currently, the __print_flags() for the prev_state
+                * is embedded in operations, so they too must be
+                * searched.
+                */
+               sym = search_op(prev_state_field, arg);
+               if (sym)
+                       return convert_sym(sym);
+       }
+       return NULL;
+}
 #endif
 
 bool evsel__fallback(struct evsel *evsel, struct target *target, int err,