From patchwork Fri Dec 8 17:24:46 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Adrian Hunter X-Patchwork-Id: 13485725 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 bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 70AE0C4167B for ; Fri, 8 Dec 2023 17:25:43 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=rRdsxG+boB2bFg9oag3Hw6uTZH6g4mDcLAvnJaZVako=; b=E8jMHOMqO96lsf tkgGEbPFOyKzh9B6aHzrfYtjVYPtXhiLLR1ZvUw42GjBPzUBylNZlI5lfrAC6keXxIM9ScPWEs+W1 3nIfLCgmOFfrBpFlAeVFKWysyiivMSYxNmAsEy+722Hv8Aj19ZoM7vcROu0THqG+Z2MZAaMJo/Cs3 MHWD4ThoUhQnY/Canzig/0KtdtBkUpY+r9yKOwQ3MsVsmhPh2FtwXFxVviFEuKqlQkQg7/ITGpZ+z 8XNhDsYORQsCvmHpxXxYTvuJAp3iUCDd5TFlqHVwDkjMeu7oQ2XviC2nd4o/64NLJb3k8CvW2Lqye 4UbAKnvK5e4IT0Q65psA==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.96 #2 (Red Hat Linux)) id 1rBebH-00GAjz-2s; Fri, 08 Dec 2023 17:25:19 +0000 Received: from mgamail.intel.com ([134.134.136.126]) by bombadil.infradead.org with esmtps (Exim 4.96 #2 (Red Hat Linux)) id 1rBebC-00GAhu-06 for linux-arm-kernel@lists.infradead.org; Fri, 08 Dec 2023 17:25:16 +0000 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=intel.com; i=@intel.com; q=dns/txt; s=Intel; t=1702056313; x=1733592313; h=from:to:cc:subject:date:message-id:in-reply-to: references:mime-version:content-transfer-encoding; bh=TUcgfMy2yb3feE8SS3tnrv16X02z4XKbq/aanVseT4A=; b=b0xUkBo+vsfHa785WbvksLPoGBnwbwMs3Vcc4pY8AtIUZqqCK2VmPpWv AQETilHJweNOvFJNeXeuJ6XbXgk8BbZk+aaDHZMGpfll5k0pktnj7ydZq IfKhvNcEIQJNbBKNHuSnniH+lk5R5Q4GNcar4PPZCKBoHHKaM432ugV6c /LD4xWpGoRlrsmqhvATfl+cHQ26QuhFxfKb74vOwx864ShLBgOODTjTea 5dW2vZZjz+JMogLfBXP3+Fc81FkIjjgG1wzgBMSFpQDjFAV/A6JUhbJRg vnp9ngMgTmHlLhkQTjtndNJ2zyP0cfiyyi1IwYi7czT2JP15H7Bqyy3M/ Q==; X-IronPort-AV: E=McAfee;i="6600,9927,10918"; a="379432384" X-IronPort-AV: E=Sophos;i="6.04,261,1695711600"; d="scan'208";a="379432384" Received: from orsmga002.jf.intel.com ([10.7.209.21]) by orsmga106.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 08 Dec 2023 09:25:12 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=McAfee;i="6600,9927,10918"; a="772201575" X-IronPort-AV: E=Sophos;i="6.04,261,1695711600"; d="scan'208";a="772201575" Received: from ahunter6-mobl1.ger.corp.intel.com (HELO ahunter-VirtualBox.home\044ger.corp.intel.com) ([10.249.34.218]) by orsmga002-auth.jf.intel.com with ESMTP/TLS/ECDHE-RSA-AES256-GCM-SHA384; 08 Dec 2023 09:25:07 -0800 From: Adrian Hunter To: Peter Zijlstra Cc: Ingo Molnar , Mark Rutland , Alexander Shishkin , Heiko Carstens , Thomas Richter , Hendrik Brueckner , Suzuki K Poulose , Mike Leach , James Clark , coresight@lists.linaro.org, linux-arm-kernel@lists.infradead.org, Yicong Yang , Jonathan Cameron , Will Deacon , Arnaldo Carvalho de Melo , Jiri Olsa , Namhyung Kim , Ian Rogers , linux-kernel@vger.kernel.org, linux-perf-users@vger.kernel.org Subject: [PATCH RFC V2 1/4] perf/core: Add aux_pause, aux_resume, aux_start_paused Date: Fri, 8 Dec 2023 19:24:46 +0200 Message-Id: <20231208172449.35444-2-adrian.hunter@intel.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20231208172449.35444-1-adrian.hunter@intel.com> References: <20231208172449.35444-1-adrian.hunter@intel.com> MIME-Version: 1.0 Organization: Intel Finland Oy, Registered Address: PL 281, 00181 Helsinki, Business Identity Code: 0357606 - 4, Domiciled in Helsinki X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20231208_092514_130569_013C1509 X-CRM114-Status: GOOD ( 29.11 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=archiver.kernel.org@lists.infradead.org Hardware traces, such as instruction traces, can produce a vast amount of trace data, so being able to reduce tracing to more specific circumstances can be useful. The ability to pause or resume tracing when another event happens, can do that. Add ability for an event to "pause" or "resume" AUX area tracing. Add aux_pause bit to perf_event_attr to indicate that, if the event happens, the associated AUX area tracing should be paused. Ditto aux_resume. Do not allow aux_pause and aux_resume to be set together. Add aux_start_paused bit to perf_event_attr to indicate to an AUX area event that it should start in a "paused" state. Add aux_paused to struct perf_event for AUX area events to keep track of the "paused" state. aux_paused is initialized to aux_start_paused. Add PERF_EF_PAUSE and PERF_EF_RESUME modes for ->stop() and ->start() callbacks. Call as needed, during __perf_event_output(). Add aux_in_pause_resume to struct perf_buffer to prevent races with the NMI handler. Pause/resume in NMI context will miss out if it coincides with another pause/resume. To use aux_pause or aux_resume, an event must be in a group with the AUX area event as the group leader. Example (requires Intel PT and tools patches also): $ perf record --kcore -e '{intel_pt/aux-start-paused/k,syscalls:sys_enter_newuname/aux-resume/,syscalls:sys_exit_newuname/aux-pause/}' uname Linux [ perf record: Woken up 1 times to write data ] [ perf record: Captured and wrote 0.041 MB perf.data ] $ perf script --call-trace uname 5712 [007] 83.855580930: name: 0x7ffd9dcebec0 uname 5712 [007] 83.855582518: psb offs: 0 uname 5712 [007] 83.855582518: cbr: 42 freq: 4205 MHz (150%) uname 5712 [007] 83.855582723: ([kernel.kallsyms]) debug_smp_processor_id uname 5712 [007] 83.855582723: ([kernel.kallsyms]) __x64_sys_newuname uname 5712 [007] 83.855582723: ([kernel.kallsyms]) down_read uname 5712 [007] 83.855582723: ([kernel.kallsyms]) __cond_resched uname 5712 [007] 83.855582932: ([kernel.kallsyms]) preempt_count_add uname 5712 [007] 83.855582932: ([kernel.kallsyms]) in_lock_functions uname 5712 [007] 83.855582932: ([kernel.kallsyms]) preempt_count_sub uname 5712 [007] 83.855582932: ([kernel.kallsyms]) up_read uname 5712 [007] 83.855582932: ([kernel.kallsyms]) preempt_count_add uname 5712 [007] 83.855583348: ([kernel.kallsyms]) in_lock_functions uname 5712 [007] 83.855583348: ([kernel.kallsyms]) preempt_count_sub uname 5712 [007] 83.855583348: ([kernel.kallsyms]) _copy_to_user uname 5712 [007] 83.855583557: ([kernel.kallsyms]) syscall_exit_to_user_mode uname 5712 [007] 83.855583557: ([kernel.kallsyms]) syscall_exit_work uname 5712 [007] 83.855583557: ([kernel.kallsyms]) perf_syscall_exit uname 5712 [007] 83.855583557: ([kernel.kallsyms]) debug_smp_processor_id uname 5712 [007] 83.855583557: ([kernel.kallsyms]) perf_trace_buf_alloc uname 5712 [007] 83.855583557: ([kernel.kallsyms]) perf_swevent_get_recursion_context uname 5712 [007] 83.855583557: ([kernel.kallsyms]) debug_smp_processor_id uname 5712 [007] 83.855583557: ([kernel.kallsyms]) debug_smp_processor_id uname 5712 [007] 83.855583557: ([kernel.kallsyms]) perf_tp_event uname 5712 [007] 83.855583557: ([kernel.kallsyms]) perf_trace_buf_update uname 5712 [007] 83.855583557: ([kernel.kallsyms]) tracing_gen_ctx_irq_test uname 5712 [007] 83.855583557: ([kernel.kallsyms]) perf_swevent_event uname 5712 [007] 83.855583765: ([kernel.kallsyms]) __perf_event_account_interrupt uname 5712 [007] 83.855583765: ([kernel.kallsyms]) __this_cpu_preempt_check uname 5712 [007] 83.855583765: ([kernel.kallsyms]) perf_event_output_forward uname 5712 [007] 83.855583765: ([kernel.kallsyms]) perf_event_aux_pause uname 5712 [007] 83.855583765: ([kernel.kallsyms]) ring_buffer_get uname 5712 [007] 83.855583765: ([kernel.kallsyms]) __rcu_read_lock uname 5712 [007] 83.855583765: ([kernel.kallsyms]) __rcu_read_unlock uname 5712 [007] 83.855583765: ([kernel.kallsyms]) pt_event_stop uname 5712 [007] 83.855583765: ([kernel.kallsyms]) debug_smp_processor_id uname 5712 [007] 83.855583765: ([kernel.kallsyms]) debug_smp_processor_id uname 5712 [007] 83.855583973: ([kernel.kallsyms]) native_write_msr uname 5712 [007] 83.855583973: ([kernel.kallsyms]) native_write_msr uname 5712 [007] 83.855584175: 0x0 Signed-off-by: Adrian Hunter --- include/linux/perf_event.h | 15 +++++++ include/uapi/linux/perf_event.h | 11 ++++- kernel/events/core.c | 72 +++++++++++++++++++++++++++++++-- kernel/events/internal.h | 1 + 4 files changed, 95 insertions(+), 4 deletions(-) diff --git a/include/linux/perf_event.h b/include/linux/perf_event.h index e85cd1c0eaf3..252c4aac3b79 100644 --- a/include/linux/perf_event.h +++ b/include/linux/perf_event.h @@ -291,6 +291,7 @@ struct perf_event_pmu_context; #define PERF_PMU_CAP_NO_EXCLUDE 0x0040 #define PERF_PMU_CAP_AUX_OUTPUT 0x0080 #define PERF_PMU_CAP_EXTENDED_HW_TYPE 0x0100 +#define PERF_PMU_CAP_AUX_PAUSE 0x0200 struct perf_output_handle; @@ -363,6 +364,8 @@ struct pmu { #define PERF_EF_START 0x01 /* start the counter when adding */ #define PERF_EF_RELOAD 0x02 /* reload the counter when starting */ #define PERF_EF_UPDATE 0x04 /* update the counter when stopping */ +#define PERF_EF_PAUSE 0x08 /* AUX area event, pause tracing */ +#define PERF_EF_RESUME 0x10 /* AUX area event, resume tracing */ /* * Adds/Removes a counter to/from the PMU, can be done inside a @@ -402,6 +405,15 @@ struct pmu { * * ->start() with PERF_EF_RELOAD will reprogram the counter * value, must be preceded by a ->stop() with PERF_EF_UPDATE. + * + * ->stop() with PERF_EF_PAUSE will stop as simply as possible. Will not + * overlap another ->stop() with PERF_EF_PAUSE nor ->start() with + * PERF_EF_RESUME. + * + * ->start() with PERF_EF_RESUME will start as simply as possible but + * only if the counter is not otherwise stopped. Will not overlap + * another ->start() with PERF_EF_RESUME nor ->stop() with + * PERF_EF_PAUSE. */ void (*start) (struct perf_event *event, int flags); void (*stop) (struct perf_event *event, int flags); @@ -797,6 +809,9 @@ struct perf_event { /* for aux_output events */ struct perf_event *aux_event; + /* for AUX area events */ + unsigned int aux_paused; + void (*destroy)(struct perf_event *); struct rcu_head rcu_head; diff --git a/include/uapi/linux/perf_event.h b/include/uapi/linux/perf_event.h index 39c6a250dd1b..437bc2a8d50c 100644 --- a/include/uapi/linux/perf_event.h +++ b/include/uapi/linux/perf_event.h @@ -507,7 +507,16 @@ struct perf_event_attr { __u16 sample_max_stack; __u16 __reserved_2; __u32 aux_sample_size; - __u32 __reserved_3; + + union { + __u32 aux_output_cfg; + struct { + __u64 aux_pause : 1, /* on overflow, pause AUX area tracing */ + aux_resume : 1, /* on overflow, resume AUX area tracing */ + aux_start_paused : 1, /* start AUX area tracing paused */ + __reserved_3 : 29; + }; + }; /* * User provided data if sigtrap=1, passed back to user via diff --git a/kernel/events/core.c b/kernel/events/core.c index 4c72a41f11af..c1e11884d06e 100644 --- a/kernel/events/core.c +++ b/kernel/events/core.c @@ -2060,7 +2060,8 @@ static void perf_put_aux_event(struct perf_event *event) static bool perf_need_aux_event(struct perf_event *event) { - return !!event->attr.aux_output || !!event->attr.aux_sample_size; + return event->attr.aux_output || event->attr.aux_sample_size || + event->attr.aux_pause || event->attr.aux_resume; } static int perf_get_aux_event(struct perf_event *event, @@ -2085,6 +2086,10 @@ static int perf_get_aux_event(struct perf_event *event, !perf_aux_output_match(event, group_leader)) return 0; + if ((event->attr.aux_pause || event->attr.aux_resume) && + !(group_leader->pmu->capabilities & PERF_PMU_CAP_AUX_PAUSE)) + return 0; + if (event->attr.aux_sample_size && !group_leader->pmu->snapshot_aux) return 0; @@ -7773,6 +7778,47 @@ void perf_prepare_header(struct perf_event_header *header, WARN_ON_ONCE(header->size & 7); } +static void __perf_event_aux_pause(struct perf_event *event, bool pause) +{ + if (pause) { + if (!READ_ONCE(event->aux_paused)) { + WRITE_ONCE(event->aux_paused, 1); + event->pmu->stop(event, PERF_EF_PAUSE); + } + } else { + if (READ_ONCE(event->aux_paused)) { + WRITE_ONCE(event->aux_paused, 0); + event->pmu->start(event, PERF_EF_RESUME); + } + } +} + +static void perf_event_aux_pause(struct perf_event *event, bool pause) +{ + struct perf_buffer *rb; + unsigned long flags; + + if (WARN_ON_ONCE(!event)) + return; + + rb = ring_buffer_get(event); + if (!rb) + return; + + local_irq_save(flags); + /* Guard against NMI, NMI loses here */ + if (READ_ONCE(rb->aux_in_pause_resume)) + goto out_restore; + WRITE_ONCE(rb->aux_in_pause_resume, 1); + barrier(); + __perf_event_aux_pause(event, pause); + barrier(); + WRITE_ONCE(rb->aux_in_pause_resume, 0); +out_restore: + local_irq_restore(flags); + ring_buffer_put(rb); +} + static __always_inline int __perf_event_output(struct perf_event *event, struct perf_sample_data *data, @@ -7786,6 +7832,9 @@ __perf_event_output(struct perf_event *event, struct perf_event_header header; int err; + if (event->attr.aux_pause) + perf_event_aux_pause(event->aux_event, true); + /* protect the callchain buffers */ rcu_read_lock(); @@ -7802,6 +7851,10 @@ __perf_event_output(struct perf_event *event, exit: rcu_read_unlock(); + + if (event->attr.aux_resume) + perf_event_aux_pause(event->aux_event, false); + return err; } @@ -11941,10 +11994,23 @@ perf_event_alloc(struct perf_event_attr *attr, int cpu, } if (event->attr.aux_output && - !(pmu->capabilities & PERF_PMU_CAP_AUX_OUTPUT)) { + (!(pmu->capabilities & PERF_PMU_CAP_AUX_OUTPUT) || + event->attr.aux_pause || event->attr.aux_resume)) { + err = -EOPNOTSUPP; + goto err_pmu; + } + + if (event->attr.aux_pause && event->attr.aux_resume) { + err = -EINVAL; + goto err_pmu; + } + + if (event->attr.aux_start_paused && + !(pmu->capabilities & PERF_PMU_CAP_AUX_PAUSE)) { err = -EOPNOTSUPP; goto err_pmu; } + event->aux_paused = event->attr.aux_start_paused; if (cgroup_fd != -1) { err = perf_cgroup_connect(cgroup_fd, event, attr, group_leader); @@ -12741,7 +12807,7 @@ perf_event_create_kernel_counter(struct perf_event_attr *attr, int cpu, * Grouping is not supported for kernel events, neither is 'AUX', * make sure the caller's intentions are adjusted. */ - if (attr->aux_output) + if (attr->aux_output || attr->aux_output_cfg) return ERR_PTR(-EINVAL); event = perf_event_alloc(attr, cpu, task, NULL, NULL, diff --git a/kernel/events/internal.h b/kernel/events/internal.h index 5150d5f84c03..3320f78117dc 100644 --- a/kernel/events/internal.h +++ b/kernel/events/internal.h @@ -51,6 +51,7 @@ struct perf_buffer { void (*free_aux)(void *); refcount_t aux_refcount; int aux_in_sampling; + int aux_in_pause_resume; void **aux_pages; void *aux_priv;