perf lock contention: Simplify parse_lock_type()

The get_type_flag() should check both str and name fields in the
lock_type_table so that it can find the appropriate flag without retrying
with ':R' or ':W' suffix from the caller.

Also fix a typo in the rt-mutex.

Signed-off-by: Namhyung Kim <namhyung@kernel.org>
Acked-by: Ian Rogers <irogers@google.com>
Cc: Adrian Hunter <adrian.hunter@intel.com>
Cc: Hao Luo <haoluo@google.com>
Cc: Ingo Molnar <mingo@kernel.org>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Juri Lelli <juri.lelli@redhat.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Song Liu <song@kernel.org>
Cc: bpf@vger.kernel.org
Link: https://lore.kernel.org/r/20230406210611.1622492-2-namhyung@kernel.org
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c
index 32ec58fb80e46ba0cc1c4e7fb464241247eac600..695ce6bd64f7f9cdf8dae0682f9a99638ae4f062 100644 (file)
--- a/tools/perf/builtin-lock.c
+++ b/tools/perf/builtin-lock.c
@@ -1557,7 +1557,7 @@ static const struct {
        { LCB_F_SPIN | LCB_F_WRITE,     "rwlock:W",     "rwlock" },
        { LCB_F_READ,                   "rwsem:R",      "rwsem" },
        { LCB_F_WRITE,                  "rwsem:W",      "rwsem" },
-       { LCB_F_RT,                     "rt=mutex",     "rt-mutex" },
+       { LCB_F_RT,                     "rt-mutex",     "rt-mutex" },
        { LCB_F_RT | LCB_F_READ,        "rwlock-rt:R",  "rwlock-rt" },
        { LCB_F_RT | LCB_F_WRITE,       "rwlock-rt:W",  "rwlock-rt" },
        { LCB_F_PERCPU | LCB_F_READ,    "pcpu-sem:R",   "percpu-rwsem" },
@@ -1596,6 +1596,10 @@ static unsigned int get_type_flag(const char *str)
                if (!strcmp(lock_type_table[i].name, str))
                        return lock_type_table[i].flags;
        }
+       for (unsigned int i = 0; i < ARRAY_SIZE(lock_type_table); i++) {
+               if (!strcmp(lock_type_table[i].str, str))
+                       return lock_type_table[i].flags;
+       }
        return UINT_MAX;
 }
 
@@ -2121,46 +2125,15 @@ static int parse_lock_type(const struct option *opt __maybe_unused, const char *
                unsigned int flags = get_type_flag(tok);
 
                if (flags == -1U) {
-                       char buf[32];
-
-                       if (strchr(tok, ':'))
-                           continue;
-
-                       /* try :R and :W suffixes for rwlock, rwsem, ... */
-                       scnprintf(buf, sizeof(buf), "%s:R", tok);
-                       flags = get_type_flag(buf);
-                       if (flags != UINT_MAX) {
-                               if (!add_lock_type(flags)) {
-                                       ret = -1;
-                                       break;
-                               }
-                       }
-
-                       scnprintf(buf, sizeof(buf), "%s:W", tok);
-                       flags = get_type_flag(buf);
-                       if (flags != UINT_MAX) {
-                               if (!add_lock_type(flags)) {
-                                       ret = -1;
-                                       break;
-                               }
-                       }
-                       continue;
+                       pr_err("Unknown lock flags: %s\n", tok);
+                       ret = -1;
+                       break;
                }
 
                if (!add_lock_type(flags)) {
                        ret = -1;
                        break;
                }
-
-               if (!strcmp(tok, "mutex")) {
-                       flags = get_type_flag("mutex-spin");
-                       if (flags != UINT_MAX) {
-                               if (!add_lock_type(flags)) {
-                                       ret = -1;
-                                       break;
-                               }
-                       }
-               }
        }
 
        free(s);