From nobody Tue Apr 28 06:32:16 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 56705CCA473 for ; Fri, 3 Jun 2022 23:57:12 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1349701AbiFCX5I (ORCPT ); Fri, 3 Jun 2022 19:57:08 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:49352 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231916AbiFCX5G (ORCPT ); Fri, 3 Jun 2022 19:57:06 -0400 Received: from mail-pj1-x102f.google.com (mail-pj1-x102f.google.com [IPv6:2607:f8b0:4864:20::102f]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 82A6A286FB; Fri, 3 Jun 2022 16:56:59 -0700 (PDT) Received: by mail-pj1-x102f.google.com with SMTP id mh16-20020a17090b4ad000b001e8313301f1so1896782pjb.1; Fri, 03 Jun 2022 16:56:59 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=m0eyMgwIk3CPtPFDkJwbRK4xZhRS0F0NmwDS3qIiC7U=; b=h7hibdVw1RJjLOsrW7x70TF8MkUajgOc/Niv5PGZmCXHlxOFvnf3Z1rTU15ei90Ud7 CbSiZQDSuLBADEeFWbR/qUKtERHpS61W+ZotdqhMmlwlpQGhGKEkt1J3DG0d/eXs6Ko6 Cwh6pD5da5bVFOFl/Imcbe3lPZtX9m+zWKlI9nUOaT+z/9c6L8xKOvXi1jI0AHgnSPlU IMMRsE6A67G8v6H1/hwgJ9UAsIXj0YxZiB6x4G9Yv7EhGn1kSZV5/ik4yZ/Z90OqVWEa vFUNZs2thQENXBGv4OBpBoP5pg0OqF/492p/O6ulew/jh50D9AZqbOoIKllluHzkyXc8 dOlA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-transfer-encoding; bh=m0eyMgwIk3CPtPFDkJwbRK4xZhRS0F0NmwDS3qIiC7U=; b=lnyeJjWV6wsmS9IBPPp4CdnFM/oaRoOUt1jrl55qLpv8ORd2WINHgWnTsTM0QBkflz lMp+9hTjGgioHI/51lXuFbQHaX074WJRj6R/Y5QEcrnAgUtsA/XfTU7qPyDZeShaikh2 G7SsGASIkIwNa/hUd6In3KYEJhHEBXslUfZQamLuslSdxgB4mGGmDdMD0giJPJ6vJjUg pqDVgF94NgV+Qn5hdqxM0aGy5YF60Yg3iBf9WOOlAmiYQQV9ppZ9niWNXnpOC3xkoQJr XA6nV6M8iILn5Hj0y2vOeeTlNKJGmhRnf2YlOffyQDbyIvBozC7fkt2oO+9Wmx913bhT n8+A== X-Gm-Message-State: AOAM532hCE0l/QcAedaZwhBffAipI9oFj/WVrQFNeERidJY+HXoS8Hhj fZeAmMUT3mrnLBLw3RwZS7c= X-Google-Smtp-Source: ABdhPJz5LUhit0DcmfnU3RSZ0cjrjxXBYfuUT2yih2Kh5sKe/H1ELT8i6kocpycNtnADJEpntZzPZw== X-Received: by 2002:a17:90a:5515:b0:1dc:c1f1:59bd with SMTP id b21-20020a17090a551500b001dcc1f159bdmr48375568pji.81.1654300619040; Fri, 03 Jun 2022 16:56:59 -0700 (PDT) Received: from balhae.hsd1.ca.comcast.net ([2601:647:6780:cb0:e599:3567:7c60:5f5a]) by smtp.gmail.com with ESMTPSA id a37-20020a631a65000000b003c14af50626sm5868289pgm.62.2022.06.03.16.56.58 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 03 Jun 2022 16:56:58 -0700 (PDT) Sender: Namhyung Kim From: Namhyung Kim To: Arnaldo Carvalho de Melo , Jiri Olsa Cc: Ingo Molnar , Peter Zijlstra , LKML , Ian Rogers , linux-perf-users@vger.kernel.org, Will Deacon , Waiman Long , Boqun Feng , Davidlohr Bueso Subject: [PATCH 1/5] perf lock: Print wait times with unit Date: Fri, 3 Jun 2022 16:56:52 -0700 Message-Id: <20220603235656.715800-2-namhyung@kernel.org> X-Mailer: git-send-email 2.36.1.255.ge46751e96f-goog In-Reply-To: <20220603235656.715800-1-namhyung@kernel.org> References: <20220603235656.715800-1-namhyung@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Currently it only prints the time in nsec but it's a bit hard to read and takes longer in the screen. We can change it to use different units and keep the number small to save the space. Before: $ perf lock report Name acquired contended avg wait (ns) total wait (ns) = max wait (ns) min wait (ns) jiffies_lock 433 32 2778 88908 = 13570 692 &lruvec->lru_lock 747 5 11254 56272 = 18317 1412 slock-AF_INET6 7 1 23543 23543 = 23543 23543 &newf->file_lock 706 15 1025 15388 = 2279 618 slock-AF_INET6 8 1 10379 10379 = 10379 10379 &rq->__lock 2143 5 2037 10185 = 3462 939 After: Name acquired contended avg wait total wait ma= x wait min wait jiffies_lock 433 32 2.78 us 88.91 us 13= .57 us 692 ns &lruvec->lru_lock 747 5 11.25 us 56.27 us 18= .32 us 1.41 us slock-AF_INET6 7 1 23.54 us 23.54 us 23= .54 us 23.54 us &newf->file_lock 706 15 1.02 us 15.39 us 2= .28 us 618 ns slock-AF_INET6 8 1 10.38 us 10.38 us 10= .38 us 10.38 us &rq->__lock 2143 5 2.04 us 10.19 us 3= .46 us 939 ns Signed-off-by: Namhyung Kim Acked-by: Ian Rogers --- tools/perf/builtin-lock.c | 48 ++++++++++++++++++++++++++++++++------- 1 file changed, 40 insertions(+), 8 deletions(-) diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c index 23a33ac15e68..57e396323d05 100644 --- a/tools/perf/builtin-lock.c +++ b/tools/perf/builtin-lock.c @@ -251,6 +251,31 @@ struct lock_key { struct list_head list; }; =20 +static void lock_stat_key_print_time(unsigned long long nsec, int len) +{ + static const struct { + float base; + const char *unit; + } table[] =3D { + { 1e9 * 3600, "h " }, + { 1e9 * 60, "m " }, + { 1e9, "s " }, + { 1e6, "ms" }, + { 1e3, "us" }, + { 0, NULL }, + }; + + for (int i =3D 0; table[i].unit; i++) { + if (nsec < table[i].base) + continue; + + pr_info("%*.2f %s", len - 3, nsec / table[i].base, table[i].unit); + return; + } + + pr_info("%*llu %s", len - 3, nsec, "ns"); +} + #define PRINT_KEY(member) \ static void lock_stat_key_print_ ## member(struct lock_key *key, \ struct lock_stat *ls) \ @@ -258,11 +283,18 @@ static void lock_stat_key_print_ ## member(struct loc= k_key *key, \ pr_info("%*llu", key->len, (unsigned long long)ls->member); \ } =20 +#define PRINT_TIME(member) \ +static void lock_stat_key_print_ ## member(struct lock_key *key, \ + struct lock_stat *ls) \ +{ \ + lock_stat_key_print_time((unsigned long long)ls->member, key->len); \ +} + PRINT_KEY(nr_acquired) PRINT_KEY(nr_contended) -PRINT_KEY(avg_wait_time) -PRINT_KEY(wait_time_total) -PRINT_KEY(wait_time_max) +PRINT_TIME(avg_wait_time) +PRINT_TIME(wait_time_total) +PRINT_TIME(wait_time_max) =20 static void lock_stat_key_print_wait_time_min(struct lock_key *key, struct lock_stat *ls) @@ -272,7 +304,7 @@ static void lock_stat_key_print_wait_time_min(struct lo= ck_key *key, if (wait_time =3D=3D ULLONG_MAX) wait_time =3D 0; =20 - pr_info("%*"PRIu64, key->len, wait_time); + lock_stat_key_print_time(wait_time, key->len); } =20 =20 @@ -291,10 +323,10 @@ static const char *output_fields; struct lock_key keys[] =3D { DEF_KEY_LOCK(acquired, "acquired", nr_acquired, 10), DEF_KEY_LOCK(contended, "contended", nr_contended, 10), - DEF_KEY_LOCK(avg_wait, "avg wait (ns)", avg_wait_time, 15), - DEF_KEY_LOCK(wait_total, "total wait (ns)", wait_time_total, 15), - DEF_KEY_LOCK(wait_max, "max wait (ns)", wait_time_max, 15), - DEF_KEY_LOCK(wait_min, "min wait (ns)", wait_time_min, 15), + DEF_KEY_LOCK(avg_wait, "avg wait", avg_wait_time, 12), + DEF_KEY_LOCK(wait_total, "total wait", wait_time_total, 12), + DEF_KEY_LOCK(wait_max, "max wait", wait_time_max, 12), + DEF_KEY_LOCK(wait_min, "min wait", wait_time_min, 12), =20 /* extra comparisons much complicated should be here */ { } --=20 2.36.1.255.ge46751e96f-goog From nobody Tue Apr 28 06:32:16 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id B2433C43334 for ; Fri, 3 Jun 2022 23:57:33 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1349798AbiFCX5a (ORCPT ); Fri, 3 Jun 2022 19:57:30 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:49354 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231924AbiFCX5G (ORCPT ); Fri, 3 Jun 2022 19:57:06 -0400 Received: from mail-pj1-x102c.google.com (mail-pj1-x102c.google.com [IPv6:2607:f8b0:4864:20::102c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A29D32B19E; Fri, 3 Jun 2022 16:57:00 -0700 (PDT) Received: by mail-pj1-x102c.google.com with SMTP id gc3-20020a17090b310300b001e33092c737so8203800pjb.3; Fri, 03 Jun 2022 16:57:00 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=EHrPNtgTpbjgDc4LmyfqxOYA7SRUHR6rzrdM1rqaC4I=; b=F7scXzHpZJpjS8CUuPwmLMPCXEKmI25baPdDEPbQV6PmBMTFGiKBcwTttyxzEmdb1l GrBOyIG10yyUYI3fFUXKf5NkSIRwABMVipcxu5ay1NO7CEsPgOnZ5klzGnwcfO3gxdrd A+l8qM/G3AMUtJyLxLsnVA3vBj7ml8BIhiJZSYjkNKywzxItYyS1O6q5Hm30x1SCN/Bv SBCBjqcVbB4ujLB718fhJMehROuZAf3aMV+ekU8Z6yBqYxSyMCsvsgMDz92qQqoSJLli uXEat2jhVy6LTkb4jQw2d/qZW4cORKEQB7y2DY/2nUKzAXrj1f8uuB0zmdZA7oBrLS6o YE3w== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-transfer-encoding; bh=EHrPNtgTpbjgDc4LmyfqxOYA7SRUHR6rzrdM1rqaC4I=; b=z8bXP3Ia5Aw9RJlkLYQF8Uf98hlX4NQXK3Wsw4kD2Gl+m141yGenikk4uAl3IZMjD7 cOq6TmU8PmolScAtv5wazM6etxTF51BdkO2o5xdX+qS+rgdPZALpaIzGSkBZIK+nfXni ITWjGSHpMzEwi3E0cW/oODj30ONj453lirKfQoImJN7YPUn3NLOTrW9mCfHNmEDa3DNa LTjXuDD9vs0h+BoiI2h18j6XgT9exyQ9/gK+sPdTwlepDqi9i2/BomNslghKtVQsjnte J6X6ui6PwsVTJBMCLT9+1jHuAgFVOiaVjs+dfHozQMjvi3fPMC8FCJqKd+9imybvGGfI gClQ== X-Gm-Message-State: AOAM532e4woa+UaIkp1qgh48vPVAZrSRlL+l7HvLIbUUVBIjbxV6UJd0 XONzLc5BcOKf5dyT90cuuiU= X-Google-Smtp-Source: ABdhPJz/opoBzwKfnFM+pquTNqX6yxwIb5z7dOwk62DswxroC3+pjlSchzjpug29Oxfsh5f0ZuQ5SQ== X-Received: by 2002:a17:90b:3141:b0:1e0:6062:9c10 with SMTP id ip1-20020a17090b314100b001e060629c10mr48188874pjb.84.1654300620150; Fri, 03 Jun 2022 16:57:00 -0700 (PDT) Received: from balhae.hsd1.ca.comcast.net ([2601:647:6780:cb0:e599:3567:7c60:5f5a]) by smtp.gmail.com with ESMTPSA id a37-20020a631a65000000b003c14af50626sm5868289pgm.62.2022.06.03.16.56.59 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 03 Jun 2022 16:56:59 -0700 (PDT) Sender: Namhyung Kim From: Namhyung Kim To: Arnaldo Carvalho de Melo , Jiri Olsa Cc: Ingo Molnar , Peter Zijlstra , LKML , Ian Rogers , linux-perf-users@vger.kernel.org, Will Deacon , Waiman Long , Boqun Feng , Davidlohr Bueso Subject: [PATCH 2/5] perf lock: Add lock contention tracepoints record support Date: Fri, 3 Jun 2022 16:56:53 -0700 Message-Id: <20220603235656.715800-3-namhyung@kernel.org> X-Mailer: git-send-email 2.36.1.255.ge46751e96f-goog In-Reply-To: <20220603235656.715800-1-namhyung@kernel.org> References: <20220603235656.715800-1-namhyung@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" When LOCKDEP and LOCK_STAT events are not available, it falls back to record the new lock contention tracepoints. Signed-off-by: Namhyung Kim --- tools/perf/builtin-lock.c | 74 +++++++++++++++++++++++++++++++++++---- 1 file changed, 67 insertions(+), 7 deletions(-) diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c index 57e396323d05..60a45973744d 100644 --- a/tools/perf/builtin-lock.c +++ b/tools/perf/builtin-lock.c @@ -516,17 +516,27 @@ static struct lock_stat *lock_stat_findnew(u64 addr, = const char *name) } =20 struct trace_lock_handler { + /* it's used on CONFIG_LOCKDEP */ int (*acquire_event)(struct evsel *evsel, struct perf_sample *sample); =20 + /* it's used on CONFIG_LOCK_STAT */ int (*acquired_event)(struct evsel *evsel, struct perf_sample *sample); =20 + /* it's used on CONFIG_LOCK_STAT */ int (*contended_event)(struct evsel *evsel, struct perf_sample *sample); =20 + /* it's used on CONFIG_LOCKDEP */ int (*release_event)(struct evsel *evsel, struct perf_sample *sample); + + int (*contention_begin_event)(struct evsel *evsel, + struct perf_sample *sample); + + int (*contention_end_event)(struct evsel *evsel, + struct perf_sample *sample); }; =20 static struct lock_seq_stat *get_seq(struct thread_stat *ts, u64 addr) @@ -854,6 +864,20 @@ static int evsel__process_lock_release(struct evsel *e= vsel, struct perf_sample * return 0; } =20 +static int evsel__process_contention_begin(struct evsel *evsel, struct per= f_sample *sample) +{ + if (trace_handler->contention_begin_event) + return trace_handler->contention_begin_event(evsel, sample); + return 0; +} + +static int evsel__process_contention_end(struct evsel *evsel, struct perf_= sample *sample) +{ + if (trace_handler->contention_end_event) + return trace_handler->contention_end_event(evsel, sample); + return 0; +} + static void print_bad_events(int bad, int total) { /* Output for debug, this have to be removed */ @@ -1055,6 +1079,11 @@ static const struct evsel_str_handler lock_tracepoin= ts[] =3D { { "lock:lock_release", evsel__process_lock_release, }, /* CONFIG_LOCKD= EP */ }; =20 +static const struct evsel_str_handler contention_tracepoints[] =3D { + { "lock:contention_begin", evsel__process_contention_begin, }, + { "lock:contention_end", evsel__process_contention_end, }, +}; + static bool force; =20 static int __cmd_report(bool display_info) @@ -1118,20 +1147,41 @@ static int __cmd_record(int argc, const char **argv) "record", "-R", "-m", "1024", "-c", "1", "--synth", "task", }; unsigned int rec_argc, i, j, ret; + unsigned int nr_tracepoints; const char **rec_argv; + bool has_lock_stat =3D true; =20 for (i =3D 0; i < ARRAY_SIZE(lock_tracepoints); i++) { if (!is_valid_tracepoint(lock_tracepoints[i].name)) { - pr_err("tracepoint %s is not enabled. " - "Are CONFIG_LOCKDEP and CONFIG_LOCK_STAT enabled?\n", - lock_tracepoints[i].name); - return 1; + pr_debug("tracepoint %s is not enabled. " + "Are CONFIG_LOCKDEP and CONFIG_LOCK_STAT enabled?\n", + lock_tracepoints[i].name); + has_lock_stat =3D false; + break; + } + } + + if (has_lock_stat) + goto setup_args; + + for (i =3D 0; i < ARRAY_SIZE(contention_tracepoints); i++) { + if (!is_valid_tracepoint(contention_tracepoints[i].name)) { + pr_err("tracepoint %s is not enabled.\n", + contention_tracepoints[i].name); + return 1; } } =20 +setup_args: rec_argc =3D ARRAY_SIZE(record_args) + argc - 1; + + if (has_lock_stat) + nr_tracepoints =3D ARRAY_SIZE(lock_tracepoints); + else + nr_tracepoints =3D ARRAY_SIZE(contention_tracepoints); + /* factor of 2 is for -e in front of each tracepoint */ - rec_argc +=3D 2 * ARRAY_SIZE(lock_tracepoints); + rec_argc +=3D 2 * nr_tracepoints; =20 rec_argv =3D calloc(rec_argc + 1, sizeof(char *)); if (!rec_argv) @@ -1140,9 +1190,19 @@ static int __cmd_record(int argc, const char **argv) for (i =3D 0; i < ARRAY_SIZE(record_args); i++) rec_argv[i] =3D strdup(record_args[i]); =20 - for (j =3D 0; j < ARRAY_SIZE(lock_tracepoints); j++) { + for (j =3D 0; j < nr_tracepoints; j++) { + const char *ev_name; + + if (has_lock_stat) + ev_name =3D strdup(lock_tracepoints[j].name); + else + ev_name =3D strdup(contention_tracepoints[j].name); + + if (!ev_name) + return -ENOMEM; + rec_argv[i++] =3D "-e"; - rec_argv[i++] =3D strdup(lock_tracepoints[j].name); + rec_argv[i++] =3D ev_name; } =20 for (j =3D 1; j < (unsigned int)argc; j++, i++) --=20 2.36.1.255.ge46751e96f-goog From nobody Tue Apr 28 06:32:16 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id E6154C43334 for ; Fri, 3 Jun 2022 23:57:27 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1349788AbiFCX5Y (ORCPT ); Fri, 3 Jun 2022 19:57:24 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:49374 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231934AbiFCX5G (ORCPT ); Fri, 3 Jun 2022 19:57:06 -0400 Received: from mail-pl1-x629.google.com (mail-pl1-x629.google.com [IPv6:2607:f8b0:4864:20::629]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CA53F2DD53; Fri, 3 Jun 2022 16:57:01 -0700 (PDT) Received: by mail-pl1-x629.google.com with SMTP id n18so7856303plg.5; Fri, 03 Jun 2022 16:57:01 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=5Ow3L4ws25yvgLaBaixFVYkezSMKCufZfoN+YQGdlbY=; b=Zc5GMs95DUVv/E9YGQ4K314V8Vf8f94NO3JjxLvuQj/Z8NJCKWoGzZdtJVdfPqgMGp 8s1PH1crY8458ugAlijsB/k2J6uIuCegHA8qhUucmVhryH+oPJamKfDcENft7h3VxeWB R7moV9d86zYJr4mRgY35B0j5eU9qYFgs6zWt9hu82WbGJhMykDObKUeKhDliXeins5Hn Hhwsx9jWgmEa/Nz2XeznKTi5tgmYXqXI/KeBjVXDMAgQhqCnTSKD5Iw/7Vz7D09jdXzs MkPNquwFHcs+MG1ETl2W4Ai9aVloXBImATpTQ76OcbYtM0tpocP5EQY1MzVWe7decTu/ f7Rg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-transfer-encoding; bh=5Ow3L4ws25yvgLaBaixFVYkezSMKCufZfoN+YQGdlbY=; b=7cUOBQivFynFanEHdhRTGiK8UBGDhOyLuAIbvMqvpgsk0yjFGPwz2tBGiab8wLH/+n s+aHpweSRN1cc70X4LnejYpWzErMWNLDCmZ0mjaL+9BqaTNcQnQVCaT6xjpC/ieu68xA gLYXsIHsgko9D0dlwDScNq6qm2vHlHvV8afPHApVgrpat68s7g6mQ9WIovJ+zmEVXAYJ LnlvQ+aJ+D/jFudw4yO/BI5Y/65Hb4O+GRa15eWV5ZFzuttZwyHO4YxcByv6/eRk12+o iS78+IzyeP4V6HEyjrG39ZJJK5SEt0PBXaVkAArxRE9WO3inWWRi3IgoQTmJ0yOm+qhc pp1g== X-Gm-Message-State: AOAM532pjIylQu1ClUYBr0EHrPjg99/yq01cH/JzLvTJVZFwVlX+kFx7 SW7FQhY0Qm+NyY0eMW8e/zA= X-Google-Smtp-Source: ABdhPJxa/ZMGDKY4qkrpd69b++jcpeG37Vpy8DcS9on4grI1/EY1nCupqsCnno4LSrAZB5iwUlTydA== X-Received: by 2002:a17:90b:3b4c:b0:1e0:2c34:fbe8 with SMTP id ot12-20020a17090b3b4c00b001e02c34fbe8mr13566171pjb.70.1654300621271; Fri, 03 Jun 2022 16:57:01 -0700 (PDT) Received: from balhae.hsd1.ca.comcast.net ([2601:647:6780:cb0:e599:3567:7c60:5f5a]) by smtp.gmail.com with ESMTPSA id a37-20020a631a65000000b003c14af50626sm5868289pgm.62.2022.06.03.16.57.00 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 03 Jun 2022 16:57:00 -0700 (PDT) Sender: Namhyung Kim From: Namhyung Kim To: Arnaldo Carvalho de Melo , Jiri Olsa Cc: Ingo Molnar , Peter Zijlstra , LKML , Ian Rogers , linux-perf-users@vger.kernel.org, Will Deacon , Waiman Long , Boqun Feng , Davidlohr Bueso Subject: [PATCH 3/5] perf lock: Handle lock contention tracepoints Date: Fri, 3 Jun 2022 16:56:54 -0700 Message-Id: <20220603235656.715800-4-namhyung@kernel.org> X-Mailer: git-send-email 2.36.1.255.ge46751e96f-goog In-Reply-To: <20220603235656.715800-1-namhyung@kernel.org> References: <20220603235656.715800-1-namhyung@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" When the lock contention events are used, there's no tracking of acquire and release. So the state machine is simplified to use UNINITIALIZED -> CONTENDED -> ACQUIRED only. Note that CONTENDED state is re-entrant since mutex locks can hit two or more consecutive contention_begin events for optimistic spinning and sleep. Acked-by: Ian Rogers Signed-off-by: Namhyung Kim --- tools/perf/builtin-lock.c | 125 ++++++++++++++++++++++++++++++++++++++ 1 file changed, 125 insertions(+) diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c index 60a45973744d..d571d487fc6f 100644 --- a/tools/perf/builtin-lock.c +++ b/tools/perf/builtin-lock.c @@ -825,6 +825,124 @@ static int report_lock_release_event(struct evsel *ev= sel, return 0; } =20 +static int report_lock_contention_begin_event(struct evsel *evsel, + struct perf_sample *sample) +{ + struct lock_stat *ls; + struct thread_stat *ts; + struct lock_seq_stat *seq; + u64 addr =3D evsel__intval(evsel, sample, "lock_addr"); + + if (show_thread_stats) + addr =3D sample->tid; + + ls =3D lock_stat_findnew(addr, "No name"); + if (!ls) + return -ENOMEM; + + ts =3D thread_stat_findnew(sample->tid); + if (!ts) + return -ENOMEM; + + seq =3D get_seq(ts, addr); + if (!seq) + return -ENOMEM; + + switch (seq->state) { + case SEQ_STATE_UNINITIALIZED: + case SEQ_STATE_ACQUIRED: + break; + case SEQ_STATE_CONTENDED: + /* + * It can have nested contention begin with mutex spinning, + * then we would use the original contention begin event and + * ignore the second one. + */ + goto end; + case SEQ_STATE_ACQUIRING: + case SEQ_STATE_READ_ACQUIRED: + case SEQ_STATE_RELEASED: + /* broken lock sequence */ + if (!ls->broken) { + ls->broken =3D 1; + bad_hist[BROKEN_CONTENDED]++; + } + list_del_init(&seq->list); + free(seq); + goto end; + default: + BUG_ON("Unknown state of lock sequence found!\n"); + break; + } + + if (seq->state !=3D SEQ_STATE_CONTENDED) { + seq->state =3D SEQ_STATE_CONTENDED; + seq->prev_event_time =3D sample->time; + ls->nr_contended++; + } +end: + return 0; +} + +static int report_lock_contention_end_event(struct evsel *evsel, + struct perf_sample *sample) +{ + struct lock_stat *ls; + struct thread_stat *ts; + struct lock_seq_stat *seq; + u64 contended_term; + u64 addr =3D evsel__intval(evsel, sample, "lock_addr"); + + if (show_thread_stats) + addr =3D sample->tid; + + ls =3D lock_stat_findnew(addr, "No name"); + if (!ls) + return -ENOMEM; + + ts =3D thread_stat_findnew(sample->tid); + if (!ts) + return -ENOMEM; + + seq =3D get_seq(ts, addr); + if (!seq) + return -ENOMEM; + + switch (seq->state) { + case SEQ_STATE_UNINITIALIZED: + goto end; + case SEQ_STATE_CONTENDED: + contended_term =3D sample->time - seq->prev_event_time; + ls->wait_time_total +=3D contended_term; + if (contended_term < ls->wait_time_min) + ls->wait_time_min =3D contended_term; + if (ls->wait_time_max < contended_term) + ls->wait_time_max =3D contended_term; + break; + case SEQ_STATE_ACQUIRING: + case SEQ_STATE_ACQUIRED: + case SEQ_STATE_READ_ACQUIRED: + case SEQ_STATE_RELEASED: + /* broken lock sequence */ + if (!ls->broken) { + ls->broken =3D 1; + bad_hist[BROKEN_CONTENDED]++; + } + list_del_init(&seq->list); + free(seq); + goto end; + default: + BUG_ON("Unknown state of lock sequence found!\n"); + break; + } + + seq->state =3D SEQ_STATE_ACQUIRED; + ls->nr_acquired++; + ls->avg_wait_time =3D ls->wait_time_total/ls->nr_acquired; +end: + return 0; +} + /* lock oriented handlers */ /* TODO: handlers for CPU oriented, thread oriented */ static struct trace_lock_handler report_lock_ops =3D { @@ -832,6 +950,8 @@ static struct trace_lock_handler report_lock_ops =3D { .acquired_event =3D report_lock_acquired_event, .contended_event =3D report_lock_contended_event, .release_event =3D report_lock_release_event, + .contention_begin_event =3D report_lock_contention_begin_event, + .contention_end_event =3D report_lock_contention_end_event, }; =20 static struct trace_lock_handler *trace_handler; @@ -1117,6 +1237,11 @@ static int __cmd_report(bool display_info) goto out_delete; } =20 + if (perf_session__set_tracepoints_handlers(session, contention_tracepoint= s)) { + pr_err("Initializing perf session tracepoint handlers failed\n"); + goto out_delete; + } + if (setup_output_field(output_fields)) goto out_delete; =20 --=20 2.36.1.255.ge46751e96f-goog From nobody Tue Apr 28 06:32:16 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 04AE0CCA473 for ; Fri, 3 Jun 2022 23:57:27 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1349771AbiFCX5V (ORCPT ); Fri, 3 Jun 2022 19:57:21 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:49376 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1348179AbiFCX5G (ORCPT ); Fri, 3 Jun 2022 19:57:06 -0400 Received: from mail-pj1-x102a.google.com (mail-pj1-x102a.google.com [IPv6:2607:f8b0:4864:20::102a]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id E03A6BE19; Fri, 3 Jun 2022 16:57:02 -0700 (PDT) Received: by mail-pj1-x102a.google.com with SMTP id n13-20020a17090a394d00b001e30a60f82dso13219462pjf.5; Fri, 03 Jun 2022 16:57:02 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=CWHqqF01MR1hRCUv+JftvZxTCLeuaSF/IGUn/jKBQVI=; b=bvLB0tB91sc5OP4Cx9RpfzMIQCntlGl65UdtCUTji8gEczrLHlA8vphgUKVyCM62tH xf24reUm8P8o+uxBBJa62OkaaQTFbbdxjlNX0t05ISM8EVatAOBdCoAKBsT/aZW/FASq EEyZf0pWSeQU/s07XwCr/SiVhVq98m7lLif/ZsYnHfk1DQMZbSKFVxRlPQfLktqr+hz9 R6loU8FarC8GyFEA0LS4ZYN3jp1Oou4xsx0HJDS2CSsj23Uk2NkBIq9iA0fqT8AF5C+t rvvQ4vV01sP72KaEAkxI2FY5hsSzUlzvpbRdJXPeep8/wlvNUlQIcw3d0eNbVg9cjgFm vKmA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-transfer-encoding; bh=CWHqqF01MR1hRCUv+JftvZxTCLeuaSF/IGUn/jKBQVI=; b=jD8B7jiHpPkjqotWTKl6cf5uKoaLU1rgYKQowyo8WOmkUeDmhJzqmXirXlzdwJHz/1 /MtdtndvBU948Km5527xrXFqZwcbLq5JeAFgkNNjVgVjWPth4mlZYdH2AlHodPe/lm1i hszaWpFMuXn5cWbW6OHOcrdC7Ujp0jM/uvlATrvBmktuVramik7SyY8QyXZLyTofw/lq 9j/D+8RBv/FPROO/9hEDc/qb5hOKFXqMG+noxZT/AhpQFzuTTy3UuJ4OKLAoxzD4E/lE mJ3KFOHnUsFQIToJ1FYgxFS8Zjm2zwq853v6Cr+iNKGjJBb5JS54FSm3+MkV9+7gTYNk uGeg== X-Gm-Message-State: AOAM533uZ/f0s/sBcRkqRj1uZVQ8HH8kbrtFuQH9jd5463zqUpsZ/rRk lvufRZgd3lHffd009E66FEI= X-Google-Smtp-Source: ABdhPJyD+Wh1DqzXpIx6Z2OjkFhYJF2YU1qvPrp1ZgW/EEAhzP7jOj/FmYTZ+tTBxuXZ9ilqWNYf6A== X-Received: by 2002:a17:90a:2c43:b0:1e0:b3fe:1bf5 with SMTP id p3-20020a17090a2c4300b001e0b3fe1bf5mr48384101pjm.27.1654300622383; Fri, 03 Jun 2022 16:57:02 -0700 (PDT) Received: from balhae.hsd1.ca.comcast.net ([2601:647:6780:cb0:e599:3567:7c60:5f5a]) by smtp.gmail.com with ESMTPSA id a37-20020a631a65000000b003c14af50626sm5868289pgm.62.2022.06.03.16.57.01 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 03 Jun 2022 16:57:02 -0700 (PDT) Sender: Namhyung Kim From: Namhyung Kim To: Arnaldo Carvalho de Melo , Jiri Olsa Cc: Ingo Molnar , Peter Zijlstra , LKML , Ian Rogers , linux-perf-users@vger.kernel.org, Will Deacon , Waiman Long , Boqun Feng , Davidlohr Bueso Subject: [PATCH 4/5] perf record: Allow to specify max stack depth of fp callchain Date: Fri, 3 Jun 2022 16:56:55 -0700 Message-Id: <20220603235656.715800-5-namhyung@kernel.org> X-Mailer: git-send-email 2.36.1.255.ge46751e96f-goog In-Reply-To: <20220603235656.715800-1-namhyung@kernel.org> References: <20220603235656.715800-1-namhyung@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Currently it has no interface to specify the max stack depth for perf record. Extend the command line parameter to accept a number after 'fp' to specify the depth like '--call-graph fp,32'. Signed-off-by: Namhyung Kim --- tools/perf/Documentation/perf-record.txt | 5 +++++ tools/perf/util/callchain.c | 18 ++++++++++++------ 2 files changed, 17 insertions(+), 6 deletions(-) diff --git a/tools/perf/Documentation/perf-record.txt b/tools/perf/Document= ation/perf-record.txt index cf8ad50f3de1..772777c2a52e 100644 --- a/tools/perf/Documentation/perf-record.txt +++ b/tools/perf/Documentation/perf-record.txt @@ -275,6 +275,11 @@ OPTIONS User can change the size by passing the size after comma like "--call-graph dwarf,4096". =20 + When "fp" recording is used, perf tries to save stack enties + up to the number specified in sysctl.kernel.perf_event_max_stack + by default. User can change the number by passing it after comma + like "--call-graph fp,32". + -q:: --quiet:: Don't print any message, useful for scripting. diff --git a/tools/perf/util/callchain.c b/tools/perf/util/callchain.c index 5c27a4b2e7a7..7e663673f79f 100644 --- a/tools/perf/util/callchain.c +++ b/tools/perf/util/callchain.c @@ -31,6 +31,7 @@ #include "callchain.h" #include "branch.h" #include "symbol.h" +#include "util.h" #include "../perf.h" =20 #define CALLCHAIN_PARAM_DEFAULT \ @@ -266,12 +267,17 @@ int parse_callchain_record(const char *arg, struct ca= llchain_param *param) do { /* Framepointer style */ if (!strncmp(name, "fp", sizeof("fp"))) { - if (!strtok_r(NULL, ",", &saveptr)) { - param->record_mode =3D CALLCHAIN_FP; - ret =3D 0; - } else - pr_err("callchain: No more arguments " - "needed for --call-graph fp\n"); + ret =3D 0; + param->record_mode =3D CALLCHAIN_FP; + + tok =3D strtok_r(NULL, ",", &saveptr); + if (tok) { + unsigned long size; + + size =3D strtoul(tok, &name, 0); + if (size < (unsigned) sysctl__max_stack()) + param->max_stack =3D size; + } break; =20 /* Dwarf style */ --=20 2.36.1.255.ge46751e96f-goog From nobody Tue Apr 28 06:32:16 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id A45F4C43334 for ; Fri, 3 Jun 2022 23:57:35 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230239AbiFCX5d (ORCPT ); Fri, 3 Jun 2022 19:57:33 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:49402 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1348197AbiFCX5G (ORCPT ); Fri, 3 Jun 2022 19:57:06 -0400 Received: from mail-pj1-x102b.google.com (mail-pj1-x102b.google.com [IPv6:2607:f8b0:4864:20::102b]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id EAFAA3150E; Fri, 3 Jun 2022 16:57:03 -0700 (PDT) Received: by mail-pj1-x102b.google.com with SMTP id n13-20020a17090a394d00b001e30a60f82dso13219499pjf.5; Fri, 03 Jun 2022 16:57:03 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=sender:from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=3hkbhX/6MOkK3rip8U7mxVX59zVmn2+YKFP5KrECSL0=; b=eM30wWR/RxbPLANC0lJTWX/saDl5LBZHE2RN7FZGbxg9AS5eWhVE7iI6qKTFXiv/7x Yc8odZiMmb43ODXTaGnK+5vhIOUrzCZoCt/T0Qt14NxNyj3qZ3IF9QABdfgYG/gJdiz2 Ly1z4Ussid07mCnN9DslynXWPQbdKUuh/spaC2QCEDzfwliaN2H1AcleOq5VX8QC1cmL l5nd01XzObXqkMhj0xtdjr6KTZyz8UV5vOgHq5Ba78+2zl1o3YwLLktHziyOKeyj1b2u vkiAQJEJGCqyb7ixXvRM4ZNWYwtuhXboQ6KTL9MO2d8pSKWxopyTUvdV1/Img8BEBq4U 3aXQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:sender:from:to:cc:subject:date:message-id :in-reply-to:references:mime-version:content-transfer-encoding; bh=3hkbhX/6MOkK3rip8U7mxVX59zVmn2+YKFP5KrECSL0=; b=HVDYQGREkfg8QtioIyPGNRUO0TsC0PNwj3chhaQgM/SOKsvtdsMcPn2Xdhz1ANUNBz 1MHgMMif4It0Eh3H7pkRCA67u5a21b+/nEfQChd95x+rauDwZBxaKfwibo+FfNe7/krK 3oH8yhdhxm+vV3/1bemQmZkoxCgchYSpasSqFEw+h4EqJXmBmkTsGPpbsC5Xs2Yt1u1t rnOAs4wyf2QK8cIeX7w/nTvJ4QBXrkc5iZsWX0c2PtLdWjA+TTwdSCDPS+FlRhmFxAXv 180t065LwC6hqO7ltLuqSZCbJBPbR5SEavVJ59PdnVM0zodgAOhIeizUylkX2+Ncq1sQ hv8A== X-Gm-Message-State: AOAM532NBdAFZjNUyG3+xomTbFjK9C8a9vpMhc72eFLPcO+LVOU3v9l0 aSJGMLhZaIzqKZ18i3V5/ds= X-Google-Smtp-Source: ABdhPJwsOXjLNHbOWCfDICFDMkojvGspfhK0w01uX5/0A3SlNJ9Kq3xHdj6X1MiGSH7YjpeOY7sdiw== X-Received: by 2002:a17:90a:5291:b0:1e0:cf4a:b6fa with SMTP id w17-20020a17090a529100b001e0cf4ab6famr13402024pjh.197.1654300623464; Fri, 03 Jun 2022 16:57:03 -0700 (PDT) Received: from balhae.hsd1.ca.comcast.net ([2601:647:6780:cb0:e599:3567:7c60:5f5a]) by smtp.gmail.com with ESMTPSA id a37-20020a631a65000000b003c14af50626sm5868289pgm.62.2022.06.03.16.57.02 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 03 Jun 2022 16:57:03 -0700 (PDT) Sender: Namhyung Kim From: Namhyung Kim To: Arnaldo Carvalho de Melo , Jiri Olsa Cc: Ingo Molnar , Peter Zijlstra , LKML , Ian Rogers , linux-perf-users@vger.kernel.org, Will Deacon , Waiman Long , Boqun Feng , Davidlohr Bueso Subject: [PATCH 5/5] perf lock: Look up callchain for the contended locks Date: Fri, 3 Jun 2022 16:56:56 -0700 Message-Id: <20220603235656.715800-6-namhyung@kernel.org> X-Mailer: git-send-email 2.36.1.255.ge46751e96f-goog In-Reply-To: <20220603235656.715800-1-namhyung@kernel.org> References: <20220603235656.715800-1-namhyung@kernel.org> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" The lock contention tracepoints don't provide lock names. All we can do is to get stack traces and show the caller instead. To minimize the overhead it's limited to up to 8 stack traces and display the first non-lock function symbol name as a caller. $ perf lock report -F acquired,contended,avg_wait,wait_total Name acquired contended avg wait total wait update_blocked_a... 40 40 3.61 us 144.45 us kernfs_fop_open+... 5 5 3.64 us 18.18 us _nohz_idle_balance 3 3 2.65 us 7.95 us tick_do_update_j... 1 1 6.04 us 6.04 us ep_scan_ready_list 1 1 3.93 us 3.93 us ... Acked-by: Ian Rogers Signed-off-by: Namhyung Kim --- tools/perf/builtin-lock.c | 172 +++++++++++++++++++++++++++++++++++++- 1 file changed, 168 insertions(+), 4 deletions(-) diff --git a/tools/perf/builtin-lock.c b/tools/perf/builtin-lock.c index d571d487fc6f..162655556037 100644 --- a/tools/perf/builtin-lock.c +++ b/tools/perf/builtin-lock.c @@ -9,6 +9,7 @@ #include "util/symbol.h" #include "util/thread.h" #include "util/header.h" +#include "util/callchain.h" =20 #include #include @@ -19,6 +20,7 @@ #include "util/tool.h" #include "util/data.h" #include "util/string2.h" +#include "util/map.h" =20 #include #include @@ -32,6 +34,7 @@ #include #include #include +#include =20 static struct perf_session *session; =20 @@ -120,6 +123,24 @@ static struct rb_root thread_stats; static bool combine_locks; static bool show_thread_stats; =20 +/* + * CONTENTION_STACK_DEPTH + * Number of stack trace entries to find callers + */ +#define CONTENTION_STACK_DEPTH 8 + +/* + * CONTENTION_STACK_SKIP + * Number of stack trace entries to skip when finding callers. + * The first few entries belong to the locking implementation itself. + */ +#define CONTENTION_STACK_DEPTH 3 + +static u64 sched_text_start; +static u64 sched_text_end; +static u64 lock_text_start; +static u64 lock_text_end; + static struct thread_stat *thread_stat_find(u32 tid) { struct rb_node *node; @@ -483,6 +504,18 @@ static struct lock_stat *pop_from_result(void) return container_of(node, struct lock_stat, rb); } =20 +static struct lock_stat *lock_stat_find(u64 addr) +{ + struct hlist_head *entry =3D lockhashentry(addr); + struct lock_stat *ret; + + hlist_for_each_entry(ret, entry, hash_entry) { + if (ret->addr =3D=3D addr) + return ret; + } + return NULL; +} + static struct lock_stat *lock_stat_findnew(u64 addr, const char *name) { struct hlist_head *entry =3D lockhashentry(addr); @@ -825,6 +858,116 @@ static int report_lock_release_event(struct evsel *ev= sel, return 0; } =20 +static bool is_lock_function(u64 addr) +{ + if (!sched_text_start) { + struct machine *machine =3D &session->machines.host; + struct map *kmap; + struct symbol *sym; + + sym =3D machine__find_kernel_symbol_by_name(machine, + "__sched_text_start", + &kmap); + if (!sym) { + /* to avoid retry */ + sched_text_start =3D 1; + return false; + } + + sched_text_start =3D kmap->unmap_ip(kmap, sym->start); + + /* should not fail from here */ + sym =3D machine__find_kernel_symbol_by_name(machine, + "__sched_text_end", + &kmap); + sched_text_end =3D kmap->unmap_ip(kmap, sym->start); + + sym =3D machine__find_kernel_symbol_by_name(machine, + "__lock_text_start", + &kmap); + lock_text_start =3D kmap->unmap_ip(kmap, sym->start); + + sym =3D machine__find_kernel_symbol_by_name(machine, + "__lock_text_end", + &kmap); + lock_text_start =3D kmap->unmap_ip(kmap, sym->start); + } + + /* failed to get kernel symbols */ + if (sched_text_start =3D=3D 1) + return false; + + /* mutex and rwsem functions are in sched text section */ + if (sched_text_start <=3D addr && addr < sched_text_end) + return true; + + /* spinlock functions are in lock text section */ + if (lock_text_start <=3D addr && addr < lock_text_end) + return true; + + return false; +} + +static int lock_contention_caller(struct evsel *evsel, struct perf_sample = *sample, + char *buf, int size) +{ + struct thread *thread; + struct callchain_cursor *cursor =3D &callchain_cursor; + struct symbol *sym; + int skip =3D 0; + int ret; + + /* lock names will be replaced to task name later */ + if (show_thread_stats) + return -1; + + thread =3D machine__findnew_thread(&session->machines.host, + -1, sample->pid); + if (thread =3D=3D NULL) + return -1; + + /* use caller function name from the callchain */ + ret =3D thread__resolve_callchain(thread, cursor, evsel, sample, + NULL, NULL, CONTENTION_STACK_DEPTH); + if (ret !=3D 0) { + thread__put(thread); + return -1; + } + + callchain_cursor_commit(cursor); + thread__put(thread); + + while (true) { + struct callchain_cursor_node *node; + + node =3D callchain_cursor_current(cursor); + if (node =3D=3D NULL) + break; + + /* skip first few entries - for lock functions */ + if (++skip <=3D CONTENTION_STACK_SKIP) + goto next; + + sym =3D node->ms.sym; + if (sym && !is_lock_function(node->ip)) { + struct map *map =3D node->ms.map; + u64 offset; + + offset =3D map->map_ip(map, node->ip) - sym->start; + + if (offset) + scnprintf(buf, size, "%s+%#lx", sym->name, offset); + else + strlcpy(buf, sym->name, size); + return 0; + } + +next: + callchain_cursor_advance(cursor); + } + return -1; +} + static int report_lock_contention_begin_event(struct evsel *evsel, struct perf_sample *sample) { @@ -836,9 +979,18 @@ static int report_lock_contention_begin_event(struct e= vsel *evsel, if (show_thread_stats) addr =3D sample->tid; =20 - ls =3D lock_stat_findnew(addr, "No name"); - if (!ls) - return -ENOMEM; + ls =3D lock_stat_find(addr); + if (!ls) { + char buf[128]; + const char *caller =3D buf; + + if (lock_contention_caller(evsel, sample, buf, sizeof(buf)) < 0) + caller =3D "Unknown"; + + ls =3D lock_stat_findnew(addr, caller); + if (!ls) + return -ENOMEM; + } =20 ts =3D thread_stat_findnew(sample->tid); if (!ts) @@ -1212,6 +1364,7 @@ static int __cmd_report(bool display_info) struct perf_tool eops =3D { .sample =3D process_sample_event, .comm =3D perf_event__process_comm, + .mmap =3D perf_event__process_mmap, .namespaces =3D perf_event__process_namespaces, .ordered_events =3D true, }; @@ -1227,6 +1380,8 @@ static int __cmd_report(bool display_info) return PTR_ERR(session); } =20 + /* for lock function check */ + symbol_conf.sort_by_name =3D true; symbol__init(&session->header.env); =20 if (!perf_session__has_traces(session, "lock record")) @@ -1271,8 +1426,12 @@ static int __cmd_record(int argc, const char **argv) const char *record_args[] =3D { "record", "-R", "-m", "1024", "-c", "1", "--synth", "task", }; + const char *callgraph_args[] =3D { + "--call-graph", "fp," __stringify(CONTENTION_STACK_DEPTH), + }; unsigned int rec_argc, i, j, ret; unsigned int nr_tracepoints; + unsigned int nr_callgraph_args =3D 0; const char **rec_argv; bool has_lock_stat =3D true; =20 @@ -1297,8 +1456,10 @@ static int __cmd_record(int argc, const char **argv) } } =20 + nr_callgraph_args =3D ARRAY_SIZE(callgraph_args); + setup_args: - rec_argc =3D ARRAY_SIZE(record_args) + argc - 1; + rec_argc =3D ARRAY_SIZE(record_args) + nr_callgraph_args + argc - 1; =20 if (has_lock_stat) nr_tracepoints =3D ARRAY_SIZE(lock_tracepoints); @@ -1330,6 +1491,9 @@ static int __cmd_record(int argc, const char **argv) rec_argv[i++] =3D ev_name; } =20 + for (j =3D 0; j < nr_callgraph_args; j++, i++) + rec_argv[i] =3D callgraph_args[j]; + for (j =3D 1; j < (unsigned int)argc; j++, i++) rec_argv[i] =3D argv[j]; =20 --=20 2.36.1.255.ge46751e96f-goog