perf sched: Update use of pthread mutex

Switch to the use of mutex wrappers that provide better error
checking. Update cmd_sched so that we always explicitly destroy the
mutexes.

Signed-off-by: Ian Rogers <irogers@google.com>
Reviewed-by: Adrian Hunter <adrian.hunter@intel.com>
Cc: Alexander Shishkin <alexander.shishkin@linux.intel.com>
Cc: Alexandre Truong <alexandre.truong@arm.com>
Cc: Alexey Bayduraev <alexey.v.bayduraev@linux.intel.com>
Cc: Andi Kleen <ak@linux.intel.com>
Cc: Andres Freund <andres@anarazel.de>
Cc: Andrii Nakryiko <andrii@kernel.org>
Cc: André Almeida <andrealmeid@igalia.com>
Cc: Athira Jajeev <atrajeev@linux.vnet.ibm.com>
Cc: Christophe JAILLET <christophe.jaillet@wanadoo.fr>
Cc: Colin Ian King <colin.king@intel.com>
Cc: Dario Petrillo <dario.pk1@gmail.com>
Cc: Darren Hart <dvhart@infradead.org>
Cc: Dave Marchevsky <davemarchevsky@fb.com>
Cc: Davidlohr Bueso <dave@stgolabs.net>
Cc: Fangrui Song <maskray@google.com>
Cc: Hewenliang <hewenliang4@huawei.com>
Cc: Ingo Molnar <mingo@redhat.com>
Cc: James Clark <james.clark@arm.com>
Cc: Jason Wang <wangborong@cdjrlc.com>
Cc: Jiri Olsa <jolsa@kernel.org>
Cc: Kajol Jain <kjain@linux.ibm.com>
Cc: Kim Phillips <kim.phillips@amd.com>
Cc: Leo Yan <leo.yan@linaro.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Martin Liška <mliska@suse.cz>
Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Nathan Chancellor <nathan@kernel.org>
Cc: Nick Desaulniers <ndesaulniers@google.com>
Cc: Pavithra Gurushankar <gpavithrasha@gmail.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Cc: Quentin Monnet <quentin@isovalent.com>
Cc: Ravi Bangoria <ravi.bangoria@amd.com>
Cc: Remi Bernon <rbernon@codeweavers.com>
Cc: Riccardo Mancini <rickyman7@gmail.com>
Cc: Song Liu <songliubraving@fb.com>
Cc: Stephane Eranian <eranian@google.com>
Cc: Thomas Gleixner <tglx@linutronix.de>
Cc: Thomas Richter <tmricht@linux.ibm.com>
Cc: Tom Rix <trix@redhat.com>
Cc: Weiguo Li <liwg06@foxmail.com>
Cc: Wenyu Liu <liuwenyu7@huawei.com>
Cc: William Cohen <wcohen@redhat.com>
Cc: Zechuan Chen <chenzechuan1@huawei.com>
Cc: bpf@vger.kernel.org
Cc: llvm@lists.linux.dev
Cc: yaowenbin <yaowenbin1@huawei.com>
Link: https://lore.kernel.org/r/20220826164242.43412-9-irogers@google.com
Signed-off-by: Arnaldo Carvalho de Melo <acme@redhat.com>

diff --git a/tools/perf/builtin-sched.c b/tools/perf/builtin-sched.c
index a5cf243c337f108c67e42ca13c671b4c1b609fc4..46e3b96457b840ce281fa648f3f8d453544df1c1 100644 (file)
--- a/tools/perf/builtin-sched.c
+++ b/tools/perf/builtin-sched.c
@@ -7,6 +7,7 @@
 #include "util/evlist.h"
 #include "util/evsel.h"
 #include "util/evsel_fprintf.h"
+#include "util/mutex.h"
 #include "util/symbol.h"
 #include "util/thread.h"
 #include "util/header.h"
@@ -184,8 +185,8 @@ struct perf_sched {
        struct task_desc **pid_to_task;
        struct task_desc **tasks;
        const struct trace_sched_handler *tp_handler;
-       pthread_mutex_t  start_work_mutex;
-       pthread_mutex_t  work_done_wait_mutex;
+       struct mutex     start_work_mutex;
+       struct mutex     work_done_wait_mutex;
        int              profile_cpu;
 /*
  * Track the current task - that way we can know whether there's any
@@ -635,10 +636,8 @@ static void *thread_func(void *ctx)
 again:
        ret = sem_post(&this_task->ready_for_work);
        BUG_ON(ret);
-       ret = pthread_mutex_lock(&sched->start_work_mutex);
-       BUG_ON(ret);
-       ret = pthread_mutex_unlock(&sched->start_work_mutex);
-       BUG_ON(ret);
+       mutex_lock(&sched->start_work_mutex);
+       mutex_unlock(&sched->start_work_mutex);
 
        cpu_usage_0 = get_cpu_usage_nsec_self(fd);
 
@@ -652,10 +651,8 @@ again:
        ret = sem_post(&this_task->work_done_sem);
        BUG_ON(ret);
 
-       ret = pthread_mutex_lock(&sched->work_done_wait_mutex);
-       BUG_ON(ret);
-       ret = pthread_mutex_unlock(&sched->work_done_wait_mutex);
-       BUG_ON(ret);
+       mutex_lock(&sched->work_done_wait_mutex);
+       mutex_unlock(&sched->work_done_wait_mutex);
 
        goto again;
 }
@@ -672,10 +669,8 @@ static void create_tasks(struct perf_sched *sched)
        err = pthread_attr_setstacksize(&attr,
                        (size_t) max(16 * 1024, (int)PTHREAD_STACK_MIN));
        BUG_ON(err);
-       err = pthread_mutex_lock(&sched->start_work_mutex);
-       BUG_ON(err);
-       err = pthread_mutex_lock(&sched->work_done_wait_mutex);
-       BUG_ON(err);
+       mutex_lock(&sched->start_work_mutex);
+       mutex_lock(&sched->work_done_wait_mutex);
        for (i = 0; i < sched->nr_tasks; i++) {
                struct sched_thread_parms *parms = malloc(sizeof(*parms));
                BUG_ON(parms == NULL);
@@ -699,7 +694,7 @@ static void wait_for_tasks(struct perf_sched *sched)
 
        sched->start_time = get_nsecs();
        sched->cpu_usage = 0;
-       pthread_mutex_unlock(&sched->work_done_wait_mutex);
+       mutex_unlock(&sched->work_done_wait_mutex);
 
        for (i = 0; i < sched->nr_tasks; i++) {
                task = sched->tasks[i];
@@ -707,12 +702,11 @@ static void wait_for_tasks(struct perf_sched *sched)
                BUG_ON(ret);
                sem_init(&task->ready_for_work, 0, 0);
        }
-       ret = pthread_mutex_lock(&sched->work_done_wait_mutex);
-       BUG_ON(ret);
+       mutex_lock(&sched->work_done_wait_mutex);
 
        cpu_usage_0 = get_cpu_usage_nsec_parent();
 
-       pthread_mutex_unlock(&sched->start_work_mutex);
+       mutex_unlock(&sched->start_work_mutex);
 
        for (i = 0; i < sched->nr_tasks; i++) {
                task = sched->tasks[i];
@@ -734,8 +728,7 @@ static void wait_for_tasks(struct perf_sched *sched)
        sched->runavg_parent_cpu_usage = (sched->runavg_parent_cpu_usage * (sched->replay_repeat - 1) +
                                         sched->parent_cpu_usage)/sched->replay_repeat;
 
-       ret = pthread_mutex_lock(&sched->start_work_mutex);
-       BUG_ON(ret);
+       mutex_lock(&sched->start_work_mutex);
 
        for (i = 0; i < sched->nr_tasks; i++) {
                task = sched->tasks[i];
@@ -3444,8 +3437,6 @@ int cmd_sched(int argc, const char **argv)
                },
                .cmp_pid              = LIST_HEAD_INIT(sched.cmp_pid),
                .sort_list            = LIST_HEAD_INIT(sched.sort_list),
-               .start_work_mutex     = PTHREAD_MUTEX_INITIALIZER,
-               .work_done_wait_mutex = PTHREAD_MUTEX_INITIALIZER,
                .sort_order           = default_sort_order,
                .replay_repeat        = 10,
                .profile_cpu          = -1,
@@ -3559,8 +3550,10 @@ int cmd_sched(int argc, const char **argv)
                .fork_event         = replay_fork_event,
        };
        unsigned int i;
-       int ret;
+       int ret = 0;
 
+       mutex_init(&sched.start_work_mutex);
+       mutex_init(&sched.work_done_wait_mutex);
        for (i = 0; i < ARRAY_SIZE(sched.curr_pid); i++)
                sched.curr_pid[i] = -1;
 
@@ -3572,11 +3565,10 @@ int cmd_sched(int argc, const char **argv)
        /*
         * Aliased to 'perf script' for now:
         */
-       if (!strcmp(argv[0], "script"))
-               return cmd_script(argc, argv);
-
-       if (strlen(argv[0]) > 2 && strstarts("record", argv[0])) {
-               return __cmd_record(argc, argv);
+       if (!strcmp(argv[0], "script")) {
+               ret = cmd_script(argc, argv);
+       } else if (strlen(argv[0]) > 2 && strstarts("record", argv[0])) {
+               ret = __cmd_record(argc, argv);
        } else if (strlen(argv[0]) > 2 && strstarts("latency", argv[0])) {
                sched.tp_handler = &lat_ops;
                if (argc > 1) {
@@ -3585,7 +3577,7 @@ int cmd_sched(int argc, const char **argv)
                                usage_with_options(latency_usage, latency_options);
                }
                setup_sorting(&sched, latency_options, latency_usage);
-               return perf_sched__lat(&sched);
+               ret = perf_sched__lat(&sched);
        } else if (!strcmp(argv[0], "map")) {
                if (argc) {
                        argc = parse_options(argc, argv, map_options, map_usage, 0);
@@ -3594,7 +3586,7 @@ int cmd_sched(int argc, const char **argv)
                }
                sched.tp_handler = &map_ops;
                setup_sorting(&sched, latency_options, latency_usage);
-               return perf_sched__map(&sched);
+               ret = perf_sched__map(&sched);
        } else if (strlen(argv[0]) > 2 && strstarts("replay", argv[0])) {
                sched.tp_handler = &replay_ops;
                if (argc) {
@@ -3602,7 +3594,7 @@ int cmd_sched(int argc, const char **argv)
                        if (argc)
                                usage_with_options(replay_usage, replay_options);
                }
-               return perf_sched__replay(&sched);
+               ret = perf_sched__replay(&sched);
        } else if (!strcmp(argv[0], "timehist")) {
                if (argc) {
                        argc = parse_options(argc, argv, timehist_options,
@@ -3618,16 +3610,21 @@ int cmd_sched(int argc, const char **argv)
                                parse_options_usage(NULL, timehist_options, "w", true);
                        if (sched.show_next)
                                parse_options_usage(NULL, timehist_options, "n", true);
-                       return -EINVAL;
+                       ret = -EINVAL;
+                       goto out;
                }
                ret = symbol__validate_sym_arguments();
                if (ret)
-                       return ret;
+                       goto out;
 
-               return perf_sched__timehist(&sched);
+               ret = perf_sched__timehist(&sched);
        } else {
                usage_with_options(sched_usage, sched_options);
        }
 
-       return 0;
+out:
+       mutex_destroy(&sched.start_work_mutex);
+       mutex_destroy(&sched.work_done_wait_mutex);
+
+       return ret;
 }