From patchwork Fri Dec 15 16:44:50 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 122130 Delivered-To: patch@linaro.org Received: by 10.140.22.227 with SMTP id 90csp708365qgn; Fri, 15 Dec 2017 08:47:23 -0800 (PST) X-Google-Smtp-Source: ACJfBou1k5j2wiW76BsU2w0247qx4xwqxB9mIAMP2BB1XXUQ2VljtoJA8/otFFnqYMysitg3KVyr X-Received: by 10.84.235.68 with SMTP id g4mr13936760plt.155.1513356443630; Fri, 15 Dec 2017 08:47:23 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1513356443; cv=none; d=google.com; s=arc-20160816; b=SPbzqRGEiDPWqZUAao4S6MCBu9s2ww1X6YcOzOn7D1dR7aCoBT3IpNYWQsOXiAHOpS 5lY7Og0S7zlvGC3ZX9UiV87HDIy/ih2HpS+Jw+49mwFdEg6GOFOwMu3M3+jRqSGlxmbQ 2MDqa/MgV7nu9HKizGYcdKHTbbZXreTsZN57XiOe8bV8PHzAfUqgb0yL+5SSfU7+zCE7 6atGrCKrAbchHQm/o/ymp6ox/jcdjgr7GF9EQswAf/lovS3E/2Fka5PHhZiaBvUoFut3 +e2UwAKXRCCv9f1rPIIvi1H4Mxhd8LFYAUqdTKFn6ZrNZbOXbdiwbTQpofxZXM+cnYDT oDHQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=byjRUUBzvWyWoP6gwtL9rkjKaybG1ECLzyqFZQQ9zNo=; b=ymhisTc7p6fIuf6SoKEDE7gGkTiZsXWOw3ZpruwZPNQuVNnkBtpLES00zSDo29JkJP 0uzb3S1zcaQZnW7b+wEfCnkYvEg7D4jX4omDff9bnTwcHxAMeIfrOBQADC9UCKkMMFXU 46CL+g6AJ02nW4UmItOZ5TMVo+/PtHbw0ZcUss83BB8C3L/dVirX6Qv7T/Tf/XzpnEjA ZqycMPnj8nipYr8uHBnd3SXrmruuGEcR3+4VBc9QCszjF8PGThWH08ckTaA9ut/PR9S6 iPPwzVPOy9o/t5NGOeYvAewCvMQKh4fZRPSbwLJkPhcJlCq0dSXVndQyX858mETbUiHE WNmw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=ZqJJmWK+; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id 34si5232768plz.598.2017.12.15.08.47.23; Fri, 15 Dec 2017 08:47:23 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=ZqJJmWK+; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932638AbdLOQrT (ORCPT + 24 others); Fri, 15 Dec 2017 11:47:19 -0500 Received: from mail-it0-f67.google.com ([209.85.214.67]:35177 "EHLO mail-it0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756697AbdLOQpF (ORCPT ); Fri, 15 Dec 2017 11:45:05 -0500 Received: by mail-it0-f67.google.com with SMTP id f143so20370523itb.0 for ; Fri, 15 Dec 2017 08:45:05 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=byjRUUBzvWyWoP6gwtL9rkjKaybG1ECLzyqFZQQ9zNo=; b=ZqJJmWK+TZ1jQIG2mLRfHzpgJEeIeNSB3z45voskGftAtBfnW+Y9imsUNPguuWbeSu InfykC41oVo1/N4SMV/E21jqY8bDp48ULcVzqu9o37uWJQVQPCNiZH/V8uGElzbBlKZV cC+RL1++c97TisKmfGsptUxKVRCHnmIBGwEj4= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=byjRUUBzvWyWoP6gwtL9rkjKaybG1ECLzyqFZQQ9zNo=; b=gUluDsnAOXy3k/AKZAzg3sgxEOrfAEEHRgRNioBRjLEKFT++Qzp3G7HLpyG42z9mRP k6mUiajgFcAZ1y3dZlZ/B9t87rmP0l+JYtWmnRF85aNWwKzLiIe9ZZC5v2bcd//0NxfE j6L9SUZBd7jRjLKumq6qtYO84tkNUSwbrXfvDNNzd9oBrqmOOAHTfimQcdICQftnA37r 6M3dudFdSdb2rg9QtyHnKIT2sktEVzf2Xap2O/VHO8cU47R+H+IewM/1ZoY28994W+5M +E5cKUa7SsCWe+rFdxrAz3zpXV1nRS6slHv/3BGmlMZBtj3GbWS/DiqyppqmSKnO/kaa dNxw== X-Gm-Message-State: AKGB3mIiAlUeshtcbSet6uK5jwBao0Gcq7b9CvuNel0KJObwINp7eLoR Yik3KeJn1OKAqdObb7RA/LoKRA== X-Received: by 10.36.145.216 with SMTP id i207mr9048352ite.73.1513356305186; Fri, 15 Dec 2017 08:45:05 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id q132sm3631732iod.26.2017.12.15.08.45.02 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 15 Dec 2017 08:45:03 -0800 (PST) From: Mathieu Poirier To: acme@kernel.org Cc: peterz@infradead.org, mingo@redhat.com, alexander.shishkin@linux.intel.com, namhyung@kernel.org, adrian.hunter@intel.com, mike.leach@arm.com, suzuki.poulosi@arm.com, tor@ti.com, jolsa@redhat.com, mathieu.poirier@linaro.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH 01/10] perf tools: Integrating the CoreSight decoding library Date: Fri, 15 Dec 2017 09:44:50 -0700 Message-Id: <1513356299-26274-2-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> References: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org The Open CoreSight Decoding Library (openCSD) is a free and open library to decode traces collected by the CoreSight hardware infrastructure. This patch adds the required mechanic to recognise the presence of the openCSD library on a system and set up miscellaneous flags to be used in the compilation of the trace decoding feature. Signed-off-by: Mathieu Poirier --- tools/build/Makefile.feature | 6 ++++-- tools/build/feature/Makefile | 6 +++++- tools/build/feature/test-all.c | 5 +++++ tools/build/feature/test-libopencsd.c | 8 ++++++++ tools/perf/Makefile.config | 13 +++++++++++++ 5 files changed, 35 insertions(+), 3 deletions(-) create mode 100644 tools/build/feature/test-libopencsd.c -- 2.7.4 diff --git a/tools/build/Makefile.feature b/tools/build/Makefile.feature index e52fcefee379..dc3d97b248ab 100644 --- a/tools/build/Makefile.feature +++ b/tools/build/Makefile.feature @@ -66,7 +66,8 @@ FEATURE_TESTS_BASIC := \ bpf \ sched_getcpu \ sdt \ - setns + setns \ + libopencsd # FEATURE_TESTS_BASIC + FEATURE_TESTS_EXTRA is the complete list # of all feature tests @@ -108,7 +109,8 @@ FEATURE_DISPLAY ?= \ zlib \ lzma \ get_cpuid \ - bpf + bpf \ + libopencsd # Set FEATURE_CHECK_(C|LD)FLAGS-all for all FEATURE_TESTS features. # If in the future we need per-feature checks/flags for features not diff --git a/tools/build/feature/Makefile b/tools/build/feature/Makefile index cff38f342283..2aae2d3fb5f6 100644 --- a/tools/build/feature/Makefile +++ b/tools/build/feature/Makefile @@ -52,7 +52,8 @@ FILES= \ test-cxx.bin \ test-jvmti.bin \ test-sched_getcpu.bin \ - test-setns.bin + test-setns.bin \ + test-libopencsd.bin FILES := $(addprefix $(OUTPUT),$(FILES)) @@ -104,6 +105,9 @@ $(OUTPUT)test-sched_getcpu.bin: $(OUTPUT)test-setns.bin: $(BUILD) +$(OUTPUT)test-libopencsd.bin: + $(BUILD) -lopencsd_c_api + DWARFLIBS := -ldw ifeq ($(findstring -static,${LDFLAGS}),-static) DWARFLIBS += -lelf -lebl -lz -llzma -lbz2 diff --git a/tools/build/feature/test-all.c b/tools/build/feature/test-all.c index 6fdf83263ab7..38ab0fd7a74c 100644 --- a/tools/build/feature/test-all.c +++ b/tools/build/feature/test-all.c @@ -162,6 +162,10 @@ # include "test-setns.c" #undef main +#define main main_test_setns +# include "test-libopencsd.c" +#undef main + int main(int argc, char *argv[]) { main_test_libpython(); @@ -199,6 +203,7 @@ int main(int argc, char *argv[]) main_test_sched_getcpu(); main_test_sdt(); main_test_setns(); + main_test_libopencsd(); return 0; } diff --git a/tools/build/feature/test-libopencsd.c b/tools/build/feature/test-libopencsd.c new file mode 100644 index 000000000000..cd4fb99eb9d3 --- /dev/null +++ b/tools/build/feature/test-libopencsd.c @@ -0,0 +1,8 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#include + +int main(void) +{ + (void)ocsd_get_version(); + return 0; +} diff --git a/tools/perf/Makefile.config b/tools/perf/Makefile.config index 79b117a03fd7..2d0b99f7b4e7 100644 --- a/tools/perf/Makefile.config +++ b/tools/perf/Makefile.config @@ -346,6 +346,19 @@ ifeq ($(feature-setns), 1) $(call detected,CONFIG_SETNS) endif +ifeq ($(feature-libopencsd), 1) + CFLAGS += -DHAVE_CSTRACE_SUPPORT + LIBCSTRACE = -lopencsd_c_api -lopencsd + EXTLIBS += $(LIBCSTRACE) + $(call detected,CONFIG_LIBOPENCSD) + ifdef CSTRACE_RAW + CFLAGS += -DCS_DEBUG_RAW + ifeq (${CSTRACE_RAW}, packed) + CFLAGS += -DCS_RAW_PACKED + endif + endif +endif + ifndef NO_LIBELF CFLAGS += -DHAVE_LIBELF_SUPPORT EXTLIBS += -lelf From patchwork Fri Dec 15 16:44:51 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 122121 Delivered-To: patch@linaro.org Received: by 10.140.22.227 with SMTP id 90csp706323qgn; Fri, 15 Dec 2017 08:45:17 -0800 (PST) X-Google-Smtp-Source: ACJfBovY8Sce03vCXJO/PVcuY9KsvAcbERUb0gPL2uPhkUwh5+J1K/IhZ1McvLRhUYTXtakYBXT+ X-Received: by 10.84.217.14 with SMTP id o14mr7128642pli.169.1513356317424; Fri, 15 Dec 2017 08:45:17 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1513356317; cv=none; d=google.com; s=arc-20160816; b=S76dNCPiWvjQFwV5MgN15LBnrxDgfUwKCkjNqYr07hgxb9iBsygd01EOil5XDPABhu 6b/xLrz7dFv3x1kokAh0i0l+bD50vdAt2F/9VhjiCnZhrupjysAzLBDsIaToR+I8jB1J 0BoP3EZj+MOquFX8BvdG4BTpMlNlEYXUvrPfilZtXI4gMWzbVXNajTnYbjaMzZelVfOv TEiRqSs2JIz+Hp3wjEGI+5pnB4llm6xkOMPd6qoDj7WmDuSRgm6cRUdYAJu5MpEYKonC tUeKKKbKbt/QU8C6MN3vGMPA5/NcZcmbDRlPjmPhH9I+g+/84Zg8thHBeTN0nGTjXRyt jsnA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=nkJelSPBDg8JpR3T3TGdMqNYqX3NjJTFOmXPdYxFTc8=; b=ZFBCpsUomVp2GY3au81Dz6ZCaqpUxCcQJ40afwKwpI7OzoIlzd3Ix9XQSqhx1u0Q9a SnHGEExFE2bPSplDAf27mXMvkqjeuHdEONyA5Ylk5hvSQ4oYjJyCbLKFJ0AvuR7o8Q0c 70O7WNw48UFQtErLakqM9xaCH4q14GbXIryUcfbSf2aLITOXxL1cEEwVb+2VMJp1PemY TIVFn2fH5q0faTENS4DjDpip5LkpE9/uP5qLj+nANOvFXFzJmVW0ZKWBMvfXpBD3OlMH G3GFUeNinlNAoZLPHECubNHJxVokghhE7+Y/fUsOu8Nti0rTZl0RXqF9EX5uU791N1xe IoQw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=KtQPtlFq; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id x8si5132816plv.554.2017.12.15.08.45.17; Fri, 15 Dec 2017 08:45:17 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=KtQPtlFq; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756881AbdLOQpN (ORCPT + 24 others); Fri, 15 Dec 2017 11:45:13 -0500 Received: from mail-it0-f67.google.com ([209.85.214.67]:41542 "EHLO mail-it0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756767AbdLOQpI (ORCPT ); Fri, 15 Dec 2017 11:45:08 -0500 Received: by mail-it0-f67.google.com with SMTP id x28so21018109ita.0 for ; Fri, 15 Dec 2017 08:45:08 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=nkJelSPBDg8JpR3T3TGdMqNYqX3NjJTFOmXPdYxFTc8=; b=KtQPtlFqSPKoR69gSqy3bwjnJWS9zoeHdEFqw+nipNyR7qxTcOnfd1N2+ha6fQcxal vS4QExuvpykRAdZhyE5dZBpVIhtn/xYU9Q0/iCKg6q8R6P5DHEeL4YAdWNgW4wEkLXd4 I9Wf0CxV8vJsJMkJk8N+AD7NpL9bLldCcKCDI= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=nkJelSPBDg8JpR3T3TGdMqNYqX3NjJTFOmXPdYxFTc8=; b=ko8sC4jmabHaY1KSENlk1lT6/dQ4DlH+h+XUR6ixB0FnegRqZHCGja28Dl/LuIqhTd 8fnws2+S/JvQLY/JfPKGKrL2FvqDdTpjEJZ+w4IDnU1A7piba370sqyWJOHfDVkloEPs ZJhWudB3Ek75C+HsQveFS1f82jIKEjYFecUxFaWeuenpX7ueV1OesOyQ3ZOsZun6Yfyu UXpPPbvFS2LL/euScxHYjc0+AUlLHJ9A8I7Loo43j8j1irsXjbHZHn8gwFIYNS+ZBlYs Q/dzpOjsQVbL5jhMB/0aeQ2CGPwA0Pq3trA4f+OApmeR1A64DV6g+4TVnIWV87lazI9B Iivw== X-Gm-Message-State: AKGB3mJlSqaVOYbIjaHaXr4fObPFS6OLdDaxRFwUrt1cHu2eonTxo6JS Q4CviAY4idi8np+dANP+E1npRQ== X-Received: by 10.36.227.3 with SMTP id d3mr9106493ith.47.1513356307669; Fri, 15 Dec 2017 08:45:07 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id q132sm3631732iod.26.2017.12.15.08.45.05 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 15 Dec 2017 08:45:06 -0800 (PST) From: Mathieu Poirier To: acme@kernel.org Cc: peterz@infradead.org, mingo@redhat.com, alexander.shishkin@linux.intel.com, namhyung@kernel.org, adrian.hunter@intel.com, mike.leach@arm.com, suzuki.poulosi@arm.com, tor@ti.com, jolsa@redhat.com, mathieu.poirier@linaro.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH 02/10] perf tools: Add initial entry point for decoder CoreSight traces Date: Fri, 15 Dec 2017 09:44:51 -0700 Message-Id: <1513356299-26274-3-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> References: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch adds the entry point for CoreSight trace decoding, serving as a jumping board for furhter expansions. Co-authored-by: Tor Jeremiassen Signed-off-by: Mathieu Poirier --- tools/perf/util/Build | 5 ++ tools/perf/util/auxtrace.c | 2 + tools/perf/util/cs-etm.c | 213 +++++++++++++++++++++++++++++++++++++++++++++ tools/perf/util/cs-etm.h | 15 ++++ 4 files changed, 235 insertions(+) create mode 100644 tools/perf/util/cs-etm.c -- 2.7.4 diff --git a/tools/perf/util/Build b/tools/perf/util/Build index a3de7916fe63..49d447ca8644 100644 --- a/tools/perf/util/Build +++ b/tools/perf/util/Build @@ -86,6 +86,11 @@ libperf-$(CONFIG_AUXTRACE) += auxtrace.o libperf-$(CONFIG_AUXTRACE) += intel-pt-decoder/ libperf-$(CONFIG_AUXTRACE) += intel-pt.o libperf-$(CONFIG_AUXTRACE) += intel-bts.o + +ifdef CONFIG_LIBOPENCSD +libperf-$(CONFIG_AUXTRACE) += cs-etm.o +endif + libperf-y += parse-branch-options.o libperf-y += dump-insn.o libperf-y += parse-regs-options.o diff --git a/tools/perf/util/auxtrace.c b/tools/perf/util/auxtrace.c index a33491416400..d07e31bd6120 100644 --- a/tools/perf/util/auxtrace.c +++ b/tools/perf/util/auxtrace.c @@ -55,6 +55,7 @@ #include "debug.h" #include +#include "cs-etm.h" #include "intel-pt.h" #include "intel-bts.h" @@ -914,6 +915,7 @@ int perf_event__process_auxtrace_info(struct perf_tool *tool __maybe_unused, case PERF_AUXTRACE_INTEL_BTS: return intel_bts_process_auxtrace_info(event, session); case PERF_AUXTRACE_CS_ETM: + return cs_etm__process_auxtrace_info(event, session); case PERF_AUXTRACE_UNKNOWN: default: return -EINVAL; diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c new file mode 100644 index 000000000000..f47797101857 --- /dev/null +++ b/tools/perf/util/cs-etm.c @@ -0,0 +1,213 @@ +/* + * SPDX-License-Identifier: GPL-2.0 + * + * Copyright(C) 2015-2018 Linaro Limited. + * + * Author: Tor Jeremiassen + * Author: Mathieu Poirier + */ + +#include +#include +#include +#include +#include + +#include + +#include "auxtrace.h" +#include "color.h" +#include "cs-etm.h" +#include "debug.h" +#include "evlist.h" +#include "intlist.h" +#include "machine.h" +#include "map.h" +#include "perf.h" +#include "thread.h" +#include "thread_map.h" +#include "thread-stack.h" +#include "util.h" + +#define MAX_TIMESTAMP (~0ULL) + +struct cs_etm_auxtrace { + struct auxtrace auxtrace; + struct auxtrace_queues queues; + struct auxtrace_heap heap; + struct itrace_synth_opts synth_opts; + struct perf_session *session; + struct machine *machine; + struct thread *unknown_thread; + + u8 timeless_decoding; + u8 snapshot_mode; + u8 data_queued; + u8 sample_branches; + + int num_cpu; + u32 auxtrace_type; + u64 branches_sample_type; + u64 branches_id; + u64 **metadata; + u64 kernel_start; + unsigned int pmu_type; +}; + +struct cs_etm_queue { + struct cs_etm_auxtrace *etm; + struct thread *thread; + struct cs_etm_decoder *decoder; + struct auxtrace_buffer *buffer; + const struct cs_etm_state *state; + union perf_event *event_buf; + unsigned int queue_nr; + pid_t pid, tid; + int cpu; + u64 time; + u64 timestamp; + u64 offset; +}; + +static int cs_etm__flush_events(struct perf_session *session, + struct perf_tool *tool) +{ + (void) session; + (void) tool; + return 0; +} + +static void cs_etm__free_queue(void *priv) +{ + struct cs_etm_queue *etmq = priv; + + free(etmq); +} + +static void cs_etm__free_events(struct perf_session *session) +{ + unsigned int i; + struct cs_etm_auxtrace *aux = container_of(session->auxtrace, + struct cs_etm_auxtrace, + auxtrace); + struct auxtrace_queues *queues = &aux->queues; + + for (i = 0; i < queues->nr_queues; i++) { + cs_etm__free_queue(queues->queue_array[i].priv); + queues->queue_array[i].priv = NULL; + } + + auxtrace_queues__free(queues); +} + +static void cs_etm__free(struct perf_session *session) +{ + struct cs_etm_auxtrace *aux = container_of(session->auxtrace, + struct cs_etm_auxtrace, + auxtrace); + cs_etm__free_events(session); + session->auxtrace = NULL; + + zfree(&aux); +} + +static int cs_etm__process_event(struct perf_session *session, + union perf_event *event, + struct perf_sample *sample, + struct perf_tool *tool) +{ + (void) session; + (void) event; + (void) sample; + (void) tool; + return 0; +} + +static int cs_etm__process_auxtrace_event(struct perf_session *session, + union perf_event *event, + struct perf_tool *tool) +{ + (void) session; + (void) event; + (void) tool; + return 0; +} + +static bool cs_etm__is_timeless_decoding(struct cs_etm_auxtrace *etm) +{ + struct perf_evsel *evsel; + struct perf_evlist *evlist = etm->session->evlist; + bool timeless_decoding = true; + + /* + * Circle through the list of event and complain if we find one + * with the time bit set. + */ + evlist__for_each_entry(evlist, evsel) { + if ((evsel->attr.sample_type & PERF_SAMPLE_TIME)) + timeless_decoding = false; + } + + return timeless_decoding; +} + +int cs_etm__process_auxtrace_info(union perf_event *event, + struct perf_session *session) +{ + struct auxtrace_info_event *auxtrace_info = &event->auxtrace_info; + struct cs_etm_auxtrace *etm = NULL; + int event_header_size = sizeof(struct perf_event_header); + int info_header_size; + int total_size = auxtrace_info->header.size; + int err = 0; + + /* + * sizeof(auxtrace_info_event::type) + + * sizeof(auxtrace_info_event::reserved) == 8 + */ + info_header_size = 8; + + if (total_size < (event_header_size + info_header_size)) + return -EINVAL; + + etm = zalloc(sizeof(*etm)); + + if (!etm) + err = -ENOMEM; + + err = auxtrace_queues__init(&etm->queues); + if (err) + goto err_free_etm; + + etm->session = session; + etm->machine = &session->machines.host; + + etm->auxtrace_type = auxtrace_info->type; + etm->timeless_decoding = cs_etm__is_timeless_decoding(etm); + + etm->auxtrace.process_event = cs_etm__process_event; + etm->auxtrace.process_auxtrace_event = cs_etm__process_auxtrace_event; + etm->auxtrace.flush_events = cs_etm__flush_events; + etm->auxtrace.free_events = cs_etm__free_events; + etm->auxtrace.free = cs_etm__free; + session->auxtrace = &etm->auxtrace; + + if (dump_trace) + return 0; + + err = auxtrace_queues__process_index(&etm->queues, session); + if (err) + goto err_free_queues; + + etm->data_queued = etm->queues.populated; + + return 0; + +err_free_queues: + auxtrace_queues__free(&etm->queues); + session->auxtrace = NULL; +err_free_etm: + zfree(&etm); + + return -EINVAL; +} diff --git a/tools/perf/util/cs-etm.h b/tools/perf/util/cs-etm.h index 3cc6bc3263fe..5ab6a8ef1b32 100644 --- a/tools/perf/util/cs-etm.h +++ b/tools/perf/util/cs-etm.h @@ -18,6 +18,9 @@ #ifndef INCLUDE__UTIL_PERF_CS_ETM_H__ #define INCLUDE__UTIL_PERF_CS_ETM_H__ +#include "util/event.h" +#include "util/session.h" + /* Versionning header in case things need tro change in the future. That way * decoding of old snapshot is still possible. */ @@ -71,4 +74,16 @@ static const u64 __perf_cs_etmv4_magic = 0x4040404040404040ULL; #define CS_ETMV3_PRIV_SIZE (CS_ETM_PRIV_MAX * sizeof(u64)) #define CS_ETMV4_PRIV_SIZE (CS_ETMV4_PRIV_MAX * sizeof(u64)) +#ifdef HAVE_CSTRACE_SUPPORT +int cs_etm__process_auxtrace_info(union perf_event *event, + struct perf_session *session); +#else +static inline int +cs_etm__process_auxtrace_info(union perf_event *event __maybe_unused, + struct perf_session *session __maybe_unused) +{ + return -1; +} +#endif + #endif From patchwork Fri Dec 15 16:44:52 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 122129 Delivered-To: patch@linaro.org Received: by 10.140.22.227 with SMTP id 90csp707975qgn; Fri, 15 Dec 2017 08:46:59 -0800 (PST) X-Google-Smtp-Source: ACJfBot4YpfSePwQWyUqyuE+IUoh+PohlJvi0bRiNraiIJ5i+e6JPjXhK9CrOPIS4gPXKRL6pkdw X-Received: by 10.84.128.197 with SMTP id a63mr14195447pla.340.1513356419046; Fri, 15 Dec 2017 08:46:59 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1513356419; cv=none; d=google.com; s=arc-20160816; b=SDhfhAfyXlqG9tjvDNjWRiKiJfjJ+fPQv1K3EzBQyypzmfX1u+NQfP07jfQZPCht/y kXG/DRtgwjuDNK7u/dLNkUbw87r6T3csdcm69YB8sxe735iV/DQRBeMBDl3ZGNbnDaXo SC95CZSSlrXrs/J9HQv1CNuOcbJcUXNwg4XlvGdjRCHnGlybmmsXm1nWgKgB/HsTYUw/ 95XkfZ1BsvHN+WDnA8g6mel/c1XR5SGpZv/yF8gduYmCURBZKReIM6vn4KBF9zGFkIcw ELpYiczsIqIC+bJJsEoibWuEBuSNLcLD7X4GZ5TPTMCPc0zoPZEUKLlgaPSv27Bog6/H z4AA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=h6gFYn2Sm/l+6WvRTW5wMs15wdVKln6BIp+8mGTrHes=; b=QRz6a5VfBoDYkwOXkXcLz2t3pvabuQCa5jL5BTcORq7p2NRRd6LoVkAAv27q3cN61m 7MEMArZqNxphCWCIJzS2XFbiaqEq6ZY7VCI9jl13xEUFqvvQ4oAKafWDtvEg5rc5gdrQ nV4yoBB3cMCbWGNkAUcEODan0/xj4OLrcKH5EwsZCMQCCQA7y4TjBM0u9RaHSiz2b4DH q5vQ+8kuo4g5eGlcQGwsyFG9aW3AqGU8D3o4ZTKc5oc64gF1yKUKk24ejjDGpUSRP3Ka x/dB7MpRwbSxplO9kvFZ/2hcNtrff7lB26iAyFrj8P5eGPn74WdpPEe36CDEU2LgIQB1 9rSw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=f/xRqQRE; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id b3si5239597plb.293.2017.12.15.08.46.58; Fri, 15 Dec 2017 08:46:59 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=f/xRqQRE; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932591AbdLOQq4 (ORCPT + 24 others); Fri, 15 Dec 2017 11:46:56 -0500 Received: from mail-it0-f66.google.com ([209.85.214.66]:36047 "EHLO mail-it0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756864AbdLOQpL (ORCPT ); Fri, 15 Dec 2017 11:45:11 -0500 Received: by mail-it0-f66.google.com with SMTP id d16so20382582itj.1 for ; Fri, 15 Dec 2017 08:45:10 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=h6gFYn2Sm/l+6WvRTW5wMs15wdVKln6BIp+8mGTrHes=; b=f/xRqQREaVgqwYqDcinkUumX2xSWz4tkKufzTOJEXQMWUmPjSzjglm+XStroc2YcW2 eNH1XuTzkK/AwGWMWN8sqNi/vkyuTCiKEvIfTsqYauCVrjT2tJttSD7uTGcbjkEBOMm7 YM52xRGziqAYXBi5toO9X78x7SYlZFP7vbHyw= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=h6gFYn2Sm/l+6WvRTW5wMs15wdVKln6BIp+8mGTrHes=; b=c5jbJ8iG/m+hIKwUL/Hk7O6TPUQY2tETVk6zYVL1zVst0N7HvW/DwBMbUZHusWAJBm Ugokfc4SUN3qlJEPrPm2E99ipT3qPRfZxWX3QUfwz9M24rkRCf9OkTVcUZcMh9IUIyOn gKQQylS2h9a6V39VnIi7U4JJd0gU/pSIQWxKqePQlYh5o9V5A19sgWjQiX1GpDf36+K3 Rej1NdtQ6nd0/rAZsNH6Zg2ax+DIkxUvZB4r6EdVV0H2LdifStWTqsWS9UpjhBoIjCqk xtAl2jz8pIjLQekpKhCHy7WxIFYZYEg3TvlVhkEToWWG9tM4TZ/4AvqA+OSkVbGxgBfg 1xhg== X-Gm-Message-State: AKGB3mLc38xKaAkWUzwQpktjavYPYU7Msd3UCvhoAsnlbZgPXOY3eLLt 7Lm6MJlzKHH8extRxTilCjwWyw== X-Received: by 10.107.174.222 with SMTP id n91mr12314615ioo.43.1513356309864; Fri, 15 Dec 2017 08:45:09 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id q132sm3631732iod.26.2017.12.15.08.45.07 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 15 Dec 2017 08:45:08 -0800 (PST) From: Mathieu Poirier To: acme@kernel.org Cc: peterz@infradead.org, mingo@redhat.com, alexander.shishkin@linux.intel.com, namhyung@kernel.org, adrian.hunter@intel.com, mike.leach@arm.com, suzuki.poulosi@arm.com, tor@ti.com, jolsa@redhat.com, mathieu.poirier@linaro.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH 03/10] perf tools: Add processing of coresight metadata Date: Fri, 15 Dec 2017 09:44:52 -0700 Message-Id: <1513356299-26274-4-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> References: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Tor Jeremiassen The auxtrace_info section contains metadata that describes the number of trace capable CPUs, their ETM version and trace configuration, including trace id values. This information is required by the trace decoder in order to properly decode the compressed trace packets. This patch adds code to read and parse this metadata, and store it for use in configuring instances of the cs-etm trace decoder. Co-authored-by: Mathieu Poirier Signed-off-by: Tor Jeremiassen --- tools/perf/util/cs-etm.c | 194 ++++++++++++++++++++++++++++++++++++++++++++++- tools/perf/util/cs-etm.h | 3 + 2 files changed, 194 insertions(+), 3 deletions(-) -- 2.7.4 diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index f47797101857..18894ee7aa0b 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -102,12 +102,24 @@ static void cs_etm__free_events(struct perf_session *session) static void cs_etm__free(struct perf_session *session) { + int i; + struct int_node *inode, *tmp; struct cs_etm_auxtrace *aux = container_of(session->auxtrace, struct cs_etm_auxtrace, auxtrace); cs_etm__free_events(session); session->auxtrace = NULL; + /* First remove all traceID/CPU# nodes for the RB tree */ + intlist__for_each_entry_safe(inode, tmp, traceid_list) + intlist__remove(traceid_list, inode); + /* Then the RB tree itself */ + intlist__delete(traceid_list); + + for (i = 0; i < aux->num_cpu; i++) + zfree(&aux->metadata[i]); + + zfree(&aux->metadata); zfree(&aux); } @@ -151,15 +163,69 @@ static bool cs_etm__is_timeless_decoding(struct cs_etm_auxtrace *etm) return timeless_decoding; } +static const char * const cs_etm_global_header_fmts[] = { + [CS_HEADER_VERSION_0] = " Header version %llx\n", + [CS_PMU_TYPE_CPUS] = " PMU type/num cpus %llx\n", + [CS_ETM_SNAPSHOT] = " Snapshot %llx\n", +}; + +static const char * const cs_etm_priv_fmts[] = { + [CS_ETM_MAGIC] = " Magic number %llx\n", + [CS_ETM_CPU] = " CPU %lld\n", + [CS_ETM_ETMCR] = " ETMCR %llx\n", + [CS_ETM_ETMTRACEIDR] = " ETMTRACEIDR %llx\n", + [CS_ETM_ETMCCER] = " ETMCCER %llx\n", + [CS_ETM_ETMIDR] = " ETMIDR %llx\n", +}; + +static const char * const cs_etmv4_priv_fmts[] = { + [CS_ETM_MAGIC] = " Magic number %llx\n", + [CS_ETM_CPU] = " CPU %lld\n", + [CS_ETMV4_TRCCONFIGR] = " TRCCONFIGR %llx\n", + [CS_ETMV4_TRCTRACEIDR] = " TRCTRACEIDR %llx\n", + [CS_ETMV4_TRCIDR0] = " TRCIDR0 %llx\n", + [CS_ETMV4_TRCIDR1] = " TRCIDR1 %llx\n", + [CS_ETMV4_TRCIDR2] = " TRCIDR2 %llx\n", + [CS_ETMV4_TRCIDR8] = " TRCIDR8 %llx\n", + [CS_ETMV4_TRCAUTHSTATUS] = " TRCAUTHSTATUS %llx\n", +}; + +static void cs_etm__print_auxtrace_info(u64 *val, int num) +{ + int i, j, cpu = 0; + + for (i = 0; i < CS_HEADER_VERSION_0_MAX; i++) + fprintf(stdout, cs_etm_global_header_fmts[i], val[i]); + + for (i = CS_HEADER_VERSION_0_MAX; cpu < num; cpu++) { + if (val[i] == __perf_cs_etmv3_magic) + for (j = 0; j < CS_ETM_PRIV_MAX; j++, i++) + fprintf(stdout, cs_etm_priv_fmts[j], val[i]); + else if (val[i] == __perf_cs_etmv4_magic) + for (j = 0; j < CS_ETMV4_PRIV_MAX; j++, i++) + fprintf(stdout, cs_etmv4_priv_fmts[j], val[i]); + else + /* failure.. return */ + return; + } +} + int cs_etm__process_auxtrace_info(union perf_event *event, struct perf_session *session) { struct auxtrace_info_event *auxtrace_info = &event->auxtrace_info; struct cs_etm_auxtrace *etm = NULL; + struct int_node *inode; + unsigned int pmu_type; int event_header_size = sizeof(struct perf_event_header); int info_header_size; int total_size = auxtrace_info->header.size; - int err = 0; + int priv_size = 0; + int num_cpu; + int err = 0, idx = -1; + int i, j, k; + u64 *ptr, *hdr = NULL; + u64 **metadata = NULL; /* * sizeof(auxtrace_info_event::type) + @@ -170,10 +236,117 @@ int cs_etm__process_auxtrace_info(union perf_event *event, if (total_size < (event_header_size + info_header_size)) return -EINVAL; + priv_size = total_size - event_header_size - info_header_size; + + /* First the global part */ + ptr = (u64 *) auxtrace_info->priv; + + /* Look for version '0' of the header */ + if (ptr[0] != 0) + return -EINVAL; + + hdr = zalloc(sizeof(*hdr) * CS_HEADER_VERSION_0_MAX); + if (!hdr) + return -ENOMEM; + + /* Extract header information - see cs-etm.h for format */ + for (i = 0; i < CS_HEADER_VERSION_0_MAX; i++) + hdr[i] = ptr[i]; + num_cpu = hdr[CS_PMU_TYPE_CPUS] & 0xffffffff; + pmu_type = (unsigned int) ((hdr[CS_PMU_TYPE_CPUS] >> 32) & + 0xffffffff); + + /* + * Create an RB tree for traceID-CPU# tuple. Since the conversion has + * to be made for each packet that gets decoded, optimizing access in + * anything other than a sequential array is worth doing. + */ + traceid_list = intlist__new(NULL); + if (!traceid_list) { + err = -ENOMEM; + goto err_free_hdr; + } + + metadata = zalloc(sizeof(*metadata) * num_cpu); + if (!metadata) { + err = -ENOMEM; + goto err_free_traceid_list; + } + + /* + * The metadata is stored in the auxtrace_info section and encodes + * the configuration of the ARM embedded trace macrocell which is + * required by the trace decoder to properly decode the trace due + * to its highly compressed nature. + */ + for (j = 0; j < num_cpu; j++) { + if (ptr[i] == __perf_cs_etmv3_magic) { + metadata[j] = zalloc(sizeof(*metadata[j]) * + CS_ETM_PRIV_MAX); + if (!metadata[j]) { + err = -ENOMEM; + goto err_free_metadata; + } + for (k = 0; k < CS_ETM_PRIV_MAX; k++) + metadata[j][k] = ptr[i + k]; + + /* The traceID is our handle */ + idx = metadata[j][CS_ETM_ETMTRACEIDR]; + i += CS_ETM_PRIV_MAX; + } else if (ptr[i] == __perf_cs_etmv4_magic) { + metadata[j] = zalloc(sizeof(*metadata[j]) * + CS_ETMV4_PRIV_MAX); + if (!metadata[j]) { + err = -ENOMEM; + goto err_free_metadata; + } + for (k = 0; k < CS_ETMV4_PRIV_MAX; k++) + metadata[j][k] = ptr[i + k]; + + /* The traceID is our handle */ + idx = metadata[j][CS_ETMV4_TRCTRACEIDR]; + i += CS_ETMV4_PRIV_MAX; + } + + /* Get an RB node for this CPU */ + inode = intlist__findnew(traceid_list, idx); + + /* Something went wrong, no need to continue */ + if (!inode) { + err = PTR_ERR(inode); + goto err_free_metadata; + } + + /* + * The node for that CPU should not be taken. + * Back out if that's the case. + */ + if (inode->priv) { + err = -EINVAL; + goto err_free_metadata; + } + /* All good, associate the traceID with the CPU# */ + inode->priv = &metadata[j][CS_ETM_CPU]; + } + + /* + * Each of CS_HEADER_VERSION_0_MAX, CS_ETM_PRIV_MAX and + * CS_ETMV4_PRIV_MAX mark how many double words are in the + * global metadata, and each cpu's metadata respectively. + * The following tests if the correct number of double words was + * present in the auxtrace info section. + */ + if (i * 8 != priv_size) { + err = -EINVAL; + goto err_free_metadata; + } + etm = zalloc(sizeof(*etm)); - if (!etm) + if (!etm) { err = -ENOMEM; + goto err_free_metadata; + } err = auxtrace_queues__init(&etm->queues); if (err) @@ -182,6 +355,10 @@ int cs_etm__process_auxtrace_info(union perf_event *event, etm->session = session; etm->machine = &session->machines.host; + etm->num_cpu = num_cpu; + etm->pmu_type = pmu_type; + etm->snapshot_mode = (hdr[CS_ETM_SNAPSHOT] != 0); + etm->metadata = metadata; etm->auxtrace_type = auxtrace_info->type; etm->timeless_decoding = cs_etm__is_timeless_decoding(etm); @@ -192,8 +369,10 @@ int cs_etm__process_auxtrace_info(union perf_event *event, etm->auxtrace.free = cs_etm__free; session->auxtrace = &etm->auxtrace; - if (dump_trace) + if (dump_trace) { + cs_etm__print_auxtrace_info(auxtrace_info->priv, num_cpu); return 0; + } err = auxtrace_queues__process_index(&etm->queues, session); if (err) @@ -208,6 +387,15 @@ int cs_etm__process_auxtrace_info(union perf_event *event, session->auxtrace = NULL; err_free_etm: zfree(&etm); +err_free_metadata: + /* No need to check @metadata[j], free(NULL) is supported */ + for (j = 0; j < num_cpu; j++) + free(metadata[j]); + zfree(&metadata); +err_free_traceid_list: + intlist__delete(traceid_list); +err_free_hdr: + zfree(&hdr); return -EINVAL; } diff --git a/tools/perf/util/cs-etm.h b/tools/perf/util/cs-etm.h index 5ab6a8ef1b32..5864d5dca616 100644 --- a/tools/perf/util/cs-etm.h +++ b/tools/perf/util/cs-etm.h @@ -64,6 +64,9 @@ enum { CS_ETMV4_PRIV_MAX, }; +/* RB tree for quick conversion between traceID and CPUs */ +struct intlist *traceid_list; + #define KiB(x) ((x) * 1024) #define MiB(x) ((x) * 1024 * 1024) From patchwork Fri Dec 15 16:44:53 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 122122 Delivered-To: patch@linaro.org Received: by 10.140.22.227 with SMTP id 90csp706406qgn; Fri, 15 Dec 2017 08:45:22 -0800 (PST) X-Google-Smtp-Source: ACJfBotysYdOCeuWldmlpteUDJTEos748c3WoxHMSznYtjcCiKKo0K17rLPJ8JCELjNowcVuhYX0 X-Received: by 10.98.144.88 with SMTP id a85mr14008789pfe.127.1513356322073; Fri, 15 Dec 2017 08:45:22 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1513356322; cv=none; d=google.com; s=arc-20160816; b=L/lwlvkdo9yBvmA9aJreA+VpWJUrtLf4fBbh+M/eDc4iiibqZB4kdRjqlrQtOtMb9/ EdCjpby0XaCTNDmcmD5BfCZZLP4SEFKQcb5fc6JZzknr/ShJ6zpDIoAgEzUlHnoj1oCn iedgizRPTXe9c/g5lQeXzApcx9yfTNoUEeYF7nxF2HPG4/FXBk+PrEacanDbB/1Usyjy V7458pGVZJHcc82I61s0yQTp47JdE9mCKQhD0dxoyTY5ijF+yKTWw8uf1AW2YB2DlcZx tnioK7nyYD69PEdl3F+ZSSDdcoB6II9CNo8CX8hpq0nNblnLpycp7sPtwkoSYJqBz4Jk GgFw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=nLKC1Qdics7b3ErZMsjvrujxBDn/7lSLEVxc6/7ZLYI=; b=nOK1n2urSK4z2g7vlHaVra6K2hqV6XIrT0abHYFNvmjIyup2C60n3aIu/JaGAbaLSu O2b1xAhTWGnGBPkT6NAh5kjjgiT/ZX9B3jceqpdUqg7yNNavaZd03oEfORHR0rcNU5TZ C7Ldwf4leatVp2M4Ul0/oQMn9Dri4bgGzXYRjHNcftGLGTgprD+zAWV4RqcEN2YUigSe kQfa2fL4MDYR7uwbEFVxckmRNagPXeQMjhO0JVLqGdcbQdE9qkwS6ROSim+65bpwX6tm DUmjdpkqwavt7TMrS1d+WTFXGxQXXQE+DcCy/UQ8sHXix87zpS+GdOhCRISZurvxIbf3 claA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=MYkBjOFy; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id z6si4837219pgz.111.2017.12.15.08.45.21; Fri, 15 Dec 2017 08:45:22 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=MYkBjOFy; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756904AbdLOQpT (ORCPT + 24 others); Fri, 15 Dec 2017 11:45:19 -0500 Received: from mail-it0-f66.google.com ([209.85.214.66]:35205 "EHLO mail-it0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756767AbdLOQpN (ORCPT ); Fri, 15 Dec 2017 11:45:13 -0500 Received: by mail-it0-f66.google.com with SMTP id f143so20371603itb.0 for ; Fri, 15 Dec 2017 08:45:13 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=nLKC1Qdics7b3ErZMsjvrujxBDn/7lSLEVxc6/7ZLYI=; b=MYkBjOFy/QYm6QEVtePtNuIIeaa1BphNhIBuxJlkuelyO2eaSsqHUlZWwB31t32N/r RnrFke5pdtZi35Bs75ADzXMlQiqxxClXCJX13h8Tph5OYdhqLe4BKiZ5HSaquUxbNB0E apm78kB0fo+s4DLhz7e5VFgdayRguuHDw+4Xo= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=nLKC1Qdics7b3ErZMsjvrujxBDn/7lSLEVxc6/7ZLYI=; b=n+gYXIkli4/IewSl6eSMqpU8QG7yX7l/CT5f/y9HlNAC7VTvN1TaR8AhM0r6z2YvnA nLXKQrWcszdDEcZWWu+h2Okct8YB2PNTRJ6eLujKyv3OfhNvfNE7B0vwP/W/peYZ5OY4 aBMuS9sEbpWyvNBLdSS2OiFXuFIvVtZfgySaxYt8ZNQLmR6gOh4ZUi7TONabAuWgs36y oE9uuIrsYW5rLvIiiCGgZZt6k0GOgnp8TupAY1z+CO0XxqzRVreXF/hsP3T5G1OjIuuv CDTD3uEw4ZVD/3qyygZ9iBMPWDjEHCCaJ2qWO8E9EHnIO3DE4Ta9hGVu5IXDMHzV/1c2 3tLA== X-Gm-Message-State: AKGB3mJsU/SOBchpfY/fkoEvv013NvtXdJ/NCKG0ZvnV6vPjP+sgA6hk DtScrDEiqPyK06d1EmslpfbyMw== X-Received: by 10.36.77.143 with SMTP id l137mr9505478itb.50.1513356312554; Fri, 15 Dec 2017 08:45:12 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id q132sm3631732iod.26.2017.12.15.08.45.09 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 15 Dec 2017 08:45:11 -0800 (PST) From: Mathieu Poirier To: acme@kernel.org Cc: peterz@infradead.org, mingo@redhat.com, alexander.shishkin@linux.intel.com, namhyung@kernel.org, adrian.hunter@intel.com, mike.leach@arm.com, suzuki.poulosi@arm.com, tor@ti.com, jolsa@redhat.com, mathieu.poirier@linaro.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH 04/10] perf tools: Add decoder mechanic to support dumping trace data Date: Fri, 15 Dec 2017 09:44:53 -0700 Message-Id: <1513356299-26274-5-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> References: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch adds the required interface to the openCSD library to support dumping CoreSight trace packet using the "report --dump" command. The information conveyed is related to the type of packets gathered by a trace session rather than full decoding. Co-authored-by: Tor Jeremiassen Signed-off-by: Mathieu Poirier --- tools/perf/util/Build | 1 + tools/perf/util/cs-etm-decoder/Build | 1 + tools/perf/util/cs-etm-decoder/cs-etm-decoder.c | 334 ++++++++++++++++++++++++ tools/perf/util/cs-etm-decoder/cs-etm-decoder.h | 96 +++++++ tools/perf/util/cs-etm.c | 108 +++++++- 5 files changed, 536 insertions(+), 4 deletions(-) create mode 100644 tools/perf/util/cs-etm-decoder/Build create mode 100644 tools/perf/util/cs-etm-decoder/cs-etm-decoder.c create mode 100644 tools/perf/util/cs-etm-decoder/cs-etm-decoder.h -- 2.7.4 diff --git a/tools/perf/util/Build b/tools/perf/util/Build index 49d447ca8644..06225cc98804 100644 --- a/tools/perf/util/Build +++ b/tools/perf/util/Build @@ -89,6 +89,7 @@ libperf-$(CONFIG_AUXTRACE) += intel-bts.o ifdef CONFIG_LIBOPENCSD libperf-$(CONFIG_AUXTRACE) += cs-etm.o +libperf-$(CONFIG_AUXTRACE) += cs-etm-decoder/ endif libperf-y += parse-branch-options.o diff --git a/tools/perf/util/cs-etm-decoder/Build b/tools/perf/util/cs-etm-decoder/Build new file mode 100644 index 000000000000..bc22c39c727f --- /dev/null +++ b/tools/perf/util/cs-etm-decoder/Build @@ -0,0 +1 @@ +libperf-$(CONFIG_AUXTRACE) += cs-etm-decoder.o diff --git a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c new file mode 100644 index 000000000000..6a4c86b1431f --- /dev/null +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c @@ -0,0 +1,334 @@ +/* + * SPDX-License-Identifier: GPL-2.0 + * + * Copyright(C) 2015-2018 Linaro Limited. + * + * Author: Tor Jeremiassen + * Author: Mathieu Poirier + */ + +#include +#include +#include +#include +#include +#include + +#include "cs-etm.h" +#include "cs-etm-decoder.h" +#include "intlist.h" +#include "util.h" + +#define MAX_BUFFER 1024 + +/* use raw logging */ +#ifdef CS_DEBUG_RAW +#define CS_LOG_RAW_FRAMES +#ifdef CS_RAW_PACKED +#define CS_RAW_DEBUG_FLAGS (OCSD_DFRMTR_UNPACKED_RAW_OUT | \ + OCSD_DFRMTR_PACKED_RAW_OUT) +#else +#define CS_RAW_DEBUG_FLAGS (OCSD_DFRMTR_UNPACKED_RAW_OUT) +#endif +#endif + +struct cs_etm_decoder { + void *data; + void (*packet_printer)(const char *msg); + bool trace_on; + dcd_tree_handle_t dcd_tree; + cs_etm_mem_cb_type mem_access; + ocsd_datapath_resp_t prev_return; + u32 packet_count; + u32 head; + u32 tail; + struct cs_etm_packet packet_buffer[MAX_BUFFER]; +}; + +static void cs_etm_decoder__gen_etmv4_config(struct cs_etm_trace_params *params, + ocsd_etmv4_cfg *config) +{ + config->reg_configr = params->etmv4.reg_configr; + config->reg_traceidr = params->etmv4.reg_traceidr; + config->reg_idr0 = params->etmv4.reg_idr0; + config->reg_idr1 = params->etmv4.reg_idr1; + config->reg_idr2 = params->etmv4.reg_idr2; + config->reg_idr8 = params->etmv4.reg_idr8; + config->reg_idr9 = 0; + config->reg_idr10 = 0; + config->reg_idr11 = 0; + config->reg_idr12 = 0; + config->reg_idr13 = 0; + config->arch_ver = ARCH_V8; + config->core_prof = profile_CortexA; +} + +static void cs_etm_decoder__print_str_cb(const void *p_context, + const char *msg, + const int str_len) +{ + if (p_context && str_len) + ((struct cs_etm_decoder *)p_context)->packet_printer(msg); +} + +static int +cs_etm_decoder__init_def_logger_printing(struct cs_etm_decoder_params *d_params, + struct cs_etm_decoder *decoder) +{ + int ret = 0; + + if (d_params->packet_printer == NULL) + return -1; + + decoder->packet_printer = d_params->packet_printer; + + /* + * Set up a library default logger to process any printers + * (packet/raw frame) we add later. + */ + ret = ocsd_def_errlog_init(OCSD_ERR_SEV_ERROR, 1); + if (ret != 0) + return -1; + + /* no stdout / err / file output */ + ret = ocsd_def_errlog_config_output(C_API_MSGLOGOUT_FLG_NONE, NULL); + if (ret != 0) + return -1; + + /* + * Set the string CB for the default logger, passes strings to + * perf print logger. + */ + ret = ocsd_def_errlog_set_strprint_cb(decoder->dcd_tree, + (void *)decoder, + cs_etm_decoder__print_str_cb); + if (ret != 0) + ret = -1; + + return 0; +} + +#ifdef CS_LOG_RAW_FRAMES +static void +cs_etm_decoder__init_raw_frame_logging(struct cs_etm_decoder_params *d_params, + struct cs_etm_decoder *decoder) +{ + /* Only log these during a --dump operation */ + if (d_params->operation == CS_ETM_OPERATION_PRINT) { + /* set up a library default logger to process the + * raw frame printer we add later + */ + ocsd_def_errlog_init(OCSD_ERR_SEV_ERROR, 1); + + /* no stdout / err / file output */ + ocsd_def_errlog_config_output(C_API_MSGLOGOUT_FLG_NONE, NULL); + + /* set the string CB for the default logger, + * passes strings to perf print logger. + */ + ocsd_def_errlog_set_strprint_cb(decoder->dcd_tree, + (void *)decoder, + cs_etm_decoder__print_str_cb); + + /* use the built in library printer for the raw frames */ + ocsd_dt_set_raw_frame_printer(decoder->dcd_tree, + CS_RAW_DEBUG_FLAGS); + } +} +#else +static void +cs_etm_decoder__init_raw_frame_logging( + struct cs_etm_decoder_params *d_params __maybe_unused, + struct cs_etm_decoder *decoder __maybe_unused) +{ +} +#endif + +static int cs_etm_decoder__create_packet_printer(struct cs_etm_decoder *decoder, + const char *decoder_name, + void *trace_config) +{ + u8 csid; + + if (ocsd_dt_create_decoder(decoder->dcd_tree, decoder_name, + OCSD_CREATE_FLG_PACKET_PROC, + trace_config, &csid)) + return -1; + + if (ocsd_dt_set_pkt_protocol_printer(decoder->dcd_tree, csid, 0)) + return -1; + + return 0; +} + +static int +cs_etm_decoder__create_etm_packet_printer(struct cs_etm_trace_params *t_params, + struct cs_etm_decoder *decoder) +{ + const char *decoder_name; + ocsd_etmv4_cfg trace_config_etmv4; + void *trace_config; + + switch (t_params->protocol) { + case CS_ETM_PROTO_ETMV4i: + cs_etm_decoder__gen_etmv4_config(t_params, &trace_config_etmv4); + decoder_name = OCSD_BUILTIN_DCD_ETMV4I; + trace_config = &trace_config_etmv4; + break; + default: + return -1; + } + + return cs_etm_decoder__create_packet_printer(decoder, + decoder_name, + trace_config); +} + +static void cs_etm_decoder__clear_buffer(struct cs_etm_decoder *decoder) +{ + int i; + + decoder->head = 0; + decoder->tail = 0; + decoder->packet_count = 0; + for (i = 0; i < MAX_BUFFER; i++) { + decoder->packet_buffer[i].start_addr = 0xdeadbeefdeadbeefUL; + decoder->packet_buffer[i].end_addr = 0xdeadbeefdeadbeefUL; + decoder->packet_buffer[i].exc = false; + decoder->packet_buffer[i].exc_ret = false; + decoder->packet_buffer[i].cpu = INT_MIN; + } +} + +static int +cs_etm_decoder__create_etm_decoder(struct cs_etm_decoder_params *d_params, + struct cs_etm_trace_params *t_params, + struct cs_etm_decoder *decoder) +{ + if (d_params->operation == CS_ETM_OPERATION_PRINT) + return cs_etm_decoder__create_etm_packet_printer(t_params, + decoder); + return -1; +} + +struct cs_etm_decoder * +cs_etm_decoder__new(int num_cpu, struct cs_etm_decoder_params *d_params, + struct cs_etm_trace_params t_params[]) +{ + struct cs_etm_decoder *decoder; + ocsd_dcd_tree_src_t format; + u32 flags; + int i, ret; + + if ((!t_params) || (!d_params)) + return NULL; + + decoder = zalloc(sizeof(*decoder)); + + if (!decoder) + return NULL; + + decoder->data = d_params->data; + decoder->prev_return = OCSD_RESP_CONT; + cs_etm_decoder__clear_buffer(decoder); + format = (d_params->formatted ? OCSD_TRC_SRC_FRAME_FORMATTED : + OCSD_TRC_SRC_SINGLE); + flags = 0; + flags |= (d_params->fsyncs ? OCSD_DFRMTR_HAS_FSYNCS : 0); + flags |= (d_params->hsyncs ? OCSD_DFRMTR_HAS_HSYNCS : 0); + flags |= (d_params->frame_aligned ? OCSD_DFRMTR_FRAME_MEM_ALIGN : 0); + + /* + * Drivers may add barrier frames when used with perf, set up to + * handle this. Barriers const of FSYNC packet repeated 4 times. + */ + flags |= OCSD_DFRMTR_RESET_ON_4X_FSYNC; + + /* Create decode tree for the data source */ + decoder->dcd_tree = ocsd_create_dcd_tree(format, flags); + + if (decoder->dcd_tree == 0) + goto err_free_decoder; + + /* init library print logging support */ + ret = cs_etm_decoder__init_def_logger_printing(d_params, decoder); + if (ret != 0) + goto err_free_decoder_tree; + + /* init raw frame logging if required */ + cs_etm_decoder__init_raw_frame_logging(d_params, decoder); + + for (i = 0; i < num_cpu; i++) { + ret = cs_etm_decoder__create_etm_decoder(d_params, + &t_params[i], + decoder); + if (ret != 0) + goto err_free_decoder_tree; + } + + return decoder; + +err_free_decoder_tree: + ocsd_destroy_dcd_tree(decoder->dcd_tree); +err_free_decoder: + free(decoder); + return NULL; +} + +int cs_etm_decoder__process_data_block(struct cs_etm_decoder *decoder, + u64 indx, const u8 *buf, + size_t len, size_t *consumed) +{ + int ret = 0; + ocsd_datapath_resp_t cur = OCSD_RESP_CONT; + ocsd_datapath_resp_t prev_return = decoder->prev_return; + size_t processed = 0; + u32 count; + + while (processed < len) { + if (OCSD_DATA_RESP_IS_WAIT(prev_return)) { + cur = ocsd_dt_process_data(decoder->dcd_tree, + OCSD_OP_FLUSH, + 0, + 0, + NULL, + NULL); + } else if (OCSD_DATA_RESP_IS_CONT(prev_return)) { + cur = ocsd_dt_process_data(decoder->dcd_tree, + OCSD_OP_DATA, + indx + processed, + len - processed, + &buf[processed], + &count); + processed += count; + } else { + ret = -EINVAL; + break; + } + + /* + * Return to the input code if the packet buffer is full. + * Flushing will get done once the packet buffer has been + * processed. + */ + if (OCSD_DATA_RESP_IS_WAIT(cur)) + break; + + prev_return = cur; + } + + decoder->prev_return = cur; + *consumed = processed; + + return ret; +} + +void cs_etm_decoder__free(struct cs_etm_decoder *decoder) +{ + if (!decoder) + return; + + ocsd_destroy_dcd_tree(decoder->dcd_tree); + decoder->dcd_tree = NULL; + free(decoder); +} diff --git a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h new file mode 100644 index 000000000000..a1e9b0ac5965 --- /dev/null +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h @@ -0,0 +1,96 @@ +/* + * SPDX-License-Identifier: GPL-2.0 + * + * Copyright(C) 2015-2018 Linaro Limited. + * + * Author: Tor Jeremiassen + * Author: Mathieu Poirier + */ + +#ifndef INCLUDE__CS_ETM_DECODER_H__ +#define INCLUDE__CS_ETM_DECODER_H__ + +#include +#include + +struct cs_etm_decoder; + +struct cs_etm_buffer { + const unsigned char *buf; + size_t len; + u64 offset; + u64 ref_timestamp; +}; + +enum cs_etm_sample_type { + CS_ETM_RANGE = 1 << 0, +}; + +struct cs_etm_packet { + enum cs_etm_sample_type sample_type; + u64 start_addr; + u64 end_addr; + u8 exc; + u8 exc_ret; + int cpu; +}; + +struct cs_etm_queue; + +typedef u32 (*cs_etm_mem_cb_type)(struct cs_etm_queue *, u64, + size_t, u8 *); + +struct cs_etmv4_trace_params { + u32 reg_idr0; + u32 reg_idr1; + u32 reg_idr2; + u32 reg_idr8; + u32 reg_configr; + u32 reg_traceidr; +}; + +struct cs_etm_trace_params { + int protocol; + union { + struct cs_etmv4_trace_params etmv4; + }; +}; + +struct cs_etm_decoder_params { + int operation; + void (*packet_printer)(const char *msg); + cs_etm_mem_cb_type mem_acc_cb; + u8 formatted; + u8 fsyncs; + u8 hsyncs; + u8 frame_aligned; + void *data; +}; + +/* + * The following enums are indexed starting with 1 to align with the + * open source coresight trace decoder library. + */ +enum { + CS_ETM_PROTO_ETMV3 = 1, + CS_ETM_PROTO_ETMV4i, + CS_ETM_PROTO_ETMV4d, +}; + +enum { + CS_ETM_OPERATION_PRINT = 1, + CS_ETM_OPERATION_DECODE, +}; + +int cs_etm_decoder__process_data_block(struct cs_etm_decoder *decoder, + u64 indx, const u8 *buf, + size_t len, size_t *consumed); + +struct cs_etm_decoder * +cs_etm_decoder__new(int num_cpu, + struct cs_etm_decoder_params *d_params, + struct cs_etm_trace_params t_params[]); + +void cs_etm_decoder__free(struct cs_etm_decoder *decoder); + +#endif /* INCLUDE__CS_ETM_DECODER_H__ */ diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index 18894ee7aa0b..cad429ce3c00 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -18,6 +18,7 @@ #include "auxtrace.h" #include "color.h" #include "cs-etm.h" +#include "cs-etm-decoder/cs-etm-decoder.h" #include "debug.h" #include "evlist.h" #include "intlist.h" @@ -69,6 +70,78 @@ struct cs_etm_queue { u64 offset; }; +static void cs_etm__packet_dump(const char *pkt_string) +{ + const char *color = PERF_COLOR_BLUE; + int len = strlen(pkt_string); + + if (len && (pkt_string[len-1] == '\n')) + color_fprintf(stdout, color, " %s", pkt_string); + else + color_fprintf(stdout, color, " %s\n", pkt_string); + + fflush(stdout); +} + +static void cs_etm__dump_event(struct cs_etm_auxtrace *etm, + struct auxtrace_buffer *buffer) +{ + int i, ret; + const char *color = PERF_COLOR_BLUE; + struct cs_etm_decoder_params d_params; + struct cs_etm_trace_params *t_params; + struct cs_etm_decoder *decoder; + size_t buffer_used = 0; + + fprintf(stdout, "\n"); + color_fprintf(stdout, color, + ". ... CoreSight ETM Trace data: size %zu bytes\n", + buffer->size); + + /* Use metadata to fill in trace parameters for trace decoder */ + t_params = zalloc(sizeof(*t_params) * etm->num_cpu); + for (i = 0; i < etm->num_cpu; i++) { + t_params[i].protocol = CS_ETM_PROTO_ETMV4i; + t_params[i].etmv4.reg_idr0 = etm->metadata[i][CS_ETMV4_TRCIDR0]; + t_params[i].etmv4.reg_idr1 = etm->metadata[i][CS_ETMV4_TRCIDR1]; + t_params[i].etmv4.reg_idr2 = etm->metadata[i][CS_ETMV4_TRCIDR2]; + t_params[i].etmv4.reg_idr8 = etm->metadata[i][CS_ETMV4_TRCIDR8]; + t_params[i].etmv4.reg_configr = + etm->metadata[i][CS_ETMV4_TRCCONFIGR]; + t_params[i].etmv4.reg_traceidr = + etm->metadata[i][CS_ETMV4_TRCTRACEIDR]; + } + + /* Set decoder parameters to simply print the trace packets */ + d_params.packet_printer = cs_etm__packet_dump; + d_params.operation = CS_ETM_OPERATION_PRINT; + d_params.formatted = true; + d_params.fsyncs = false; + d_params.hsyncs = false; + d_params.frame_aligned = true; + + decoder = cs_etm_decoder__new(etm->num_cpu, &d_params, t_params); + + zfree(&t_params); + + if (!decoder) + return; + do { + size_t consumed; + + ret = cs_etm_decoder__process_data_block( + decoder, buffer->offset, + &((u8 *)buffer->data)[buffer_used], + buffer->size - buffer_used, &consumed); + if (ret) + break; + + buffer_used += consumed; + } while (buffer_used < buffer->size); + + cs_etm_decoder__free(decoder); +} + static int cs_etm__flush_events(struct perf_session *session, struct perf_tool *tool) { @@ -137,11 +210,38 @@ static int cs_etm__process_event(struct perf_session *session, static int cs_etm__process_auxtrace_event(struct perf_session *session, union perf_event *event, - struct perf_tool *tool) + struct perf_tool *tool __maybe_unused) { - (void) session; - (void) event; - (void) tool; + struct cs_etm_auxtrace *etm = container_of(session->auxtrace, + struct cs_etm_auxtrace, + auxtrace); + if (!etm->data_queued) { + struct auxtrace_buffer *buffer; + off_t data_offset; + int fd = perf_data__fd(session->data); + bool is_pipe = perf_data__is_pipe(session->data); + int err; + + if (is_pipe) + data_offset = 0; + else { + data_offset = lseek(fd, 0, SEEK_CUR); + if (data_offset == -1) + return -errno; + } + + err = auxtrace_queues__add_event(&etm->queues, session, + event, data_offset, &buffer); + if (err) + return err; + + if (dump_trace) + if (auxtrace_buffer__get_data(buffer, fd)) { + cs_etm__dump_event(etm, buffer); + auxtrace_buffer__put_data(buffer); + } + } + return 0; } From patchwork Fri Dec 15 16:44:54 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 122128 Delivered-To: patch@linaro.org Received: by 10.140.22.227 with SMTP id 90csp707635qgn; Fri, 15 Dec 2017 08:46:38 -0800 (PST) X-Google-Smtp-Source: ACJfBouzx7v9VMj7c/nback5Lk+/bIbRu3opgCLAxhz7OC8Z9rAGCRkxuPxotIk5wTkfhB/woXwX X-Received: by 10.84.174.131 with SMTP id r3mr14052237plb.358.1513356398044; Fri, 15 Dec 2017 08:46:38 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1513356398; cv=none; d=google.com; s=arc-20160816; b=cx24T5GryQ4I1fHK7t146FltttOe3hJ91ogApzlummgl0Vb0YkXgCTI5TcjfL/xXMM pPi5r6CQTjWncLfUoHwtPwvwqrBophvdBf4akKmpc5qV+wP+dbLe4lbdOihd3u4J2nsa zvsXB9dIqjxRzdW4rRc5GIUgAdWInIYq+At7C2QmNIAqWSJBOWhq76LYQo3JEhlPSlA/ CcZpfaNQ5KUWMGDaN5OCZyAdBr8UMF4DfFv4mHp+zX0kryeWlVz0HdhkV9vOfMmphlOD NQ+vceeXxFVFU53UcSZ/jwsLCPVTAbE3DFY92r3Ty7sk6p+WFX3jiaysI2rSaTagzyFi 0cGQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=5jFdWvQHmBRzHkJxZHbVXWO2q05IMe9m2gaQjutTajQ=; b=0qlbcGSevoxbMfafnJNf9z8slnJsfvSGD7bwutmnDloPJiROYgqGMeBxqpQ1jTtTiC Y7i14YrLRquFI3Miu2uKM6qhMGCsAHfDH+IgGWrgNsu8qUkXtSyoVgc5aKWfASfR/+Fv 4c3t0Z9VgdA+Ux74Pfjo0M5Ig/vwBYBhL2dN2QH8ZcIu/VM5fPskPY2lRgTh+C8XtAww ZrroYTvUrgTyeBlu6GSN/HkhRI6F3QN8kDqHqiGQ5x7soYO0i63TbIPAm29FYm2pzDOj cWHcP9K3UqkE9FhPLdJp52UVZVLezLTAH+9GhultS6gkuoo1wV6vYLUL0g32J3rcGNIt OxLQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=Oz6PGCrg; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id b3si5239597plb.293.2017.12.15.08.46.37; Fri, 15 Dec 2017 08:46:38 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=Oz6PGCrg; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S932523AbdLOQqe (ORCPT + 24 others); Fri, 15 Dec 2017 11:46:34 -0500 Received: from mail-it0-f67.google.com ([209.85.214.67]:45479 "EHLO mail-it0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756885AbdLOQpP (ORCPT ); Fri, 15 Dec 2017 11:45:15 -0500 Received: by mail-it0-f67.google.com with SMTP id z6so20874175iti.4 for ; Fri, 15 Dec 2017 08:45:15 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=5jFdWvQHmBRzHkJxZHbVXWO2q05IMe9m2gaQjutTajQ=; b=Oz6PGCrgKDuoXcqGb1V1gduCY+GDHKS9QRLYhJBRjnPUJQkpEYJn97xJ1ntSev6771 kxZUKFQPsKX+2g8183Qtok8V3dD+87Hp3E4dEXUHoldS691Mymd36crXmX5ewNDeBQbC gvLQ5DQW37Q2JWFPLJZ6hkrx4OoX1P0/hGfms= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=5jFdWvQHmBRzHkJxZHbVXWO2q05IMe9m2gaQjutTajQ=; b=Shhv/UXc5up8fPFmlPWDqRIwQ8XUdrCAwGTx0CZ72zCY99GoVc+3bkURQOxSa6S/KJ eDbFF5pDVNXodWgBKMB/u082izO+Mvb5RLALS4IoeZ2WgFEMSmvY8Wr4dcefd0F8CVme pS+t4+rgLRUKvqh8Ae0A1ULdY7uRMEuW5bLkn55+U1+91ewGbpdkc+s82zqMYAj/7RCn W2gtKzMjg5aeF/43lDbrjix51PGGDMzaNELclE5l20Z7jVKJYkUWP34ZaJBO/0/SZICk +jQmyl9YhAqtUg9ch3Uw8Xa39V+4C0h6Tye1AnCs7jMT/BEQWUhaPrUztxUaAAcl+Abt KxCw== X-Gm-Message-State: AKGB3mKYxNpNM4kbnY00mWc42ITEMhfEQ45eQOEQ/MiV3zj3/tZTUU3I amsVtfSSiEEmqRw53VTLR4Q7Zg== X-Received: by 10.107.198.67 with SMTP id w64mr12637212iof.264.1513356314871; Fri, 15 Dec 2017 08:45:14 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id q132sm3631732iod.26.2017.12.15.08.45.12 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 15 Dec 2017 08:45:13 -0800 (PST) From: Mathieu Poirier To: acme@kernel.org Cc: peterz@infradead.org, mingo@redhat.com, alexander.shishkin@linux.intel.com, namhyung@kernel.org, adrian.hunter@intel.com, mike.leach@arm.com, suzuki.poulosi@arm.com, tor@ti.com, jolsa@redhat.com, mathieu.poirier@linaro.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH 05/10] perf tools: Add support for decoding CoreSight trace data Date: Fri, 15 Dec 2017 09:44:54 -0700 Message-Id: <1513356299-26274-6-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> References: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Adding functionality to create a CoreSight trace decoder capable of decoding trace data pushed by a client application. Co-authored-by: Tor Jeremiassen Signed-off-by: Mathieu Poirier --- tools/perf/util/cs-etm-decoder/cs-etm-decoder.c | 119 ++++++++++++++++++++++++ 1 file changed, 119 insertions(+) -- 2.7.4 diff --git a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c index 6a4c86b1431f..57b020b0b36f 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c @@ -200,6 +200,121 @@ static void cs_etm_decoder__clear_buffer(struct cs_etm_decoder *decoder) } } +static ocsd_datapath_resp_t +cs_etm_decoder__buffer_packet(struct cs_etm_decoder *decoder, + const ocsd_generic_trace_elem *elem, + const u8 trace_chan_id, + enum cs_etm_sample_type sample_type) +{ + u32 et = 0; + struct int_node *inode = NULL; + + if (decoder->packet_count >= MAX_BUFFER - 1) + return OCSD_RESP_FATAL_SYS_ERR; + + /* Search the RB tree for the cpu associated with this traceID */ + inode = intlist__find(traceid_list, trace_chan_id); + if (!inode) + return OCSD_RESP_FATAL_SYS_ERR; + + et = decoder->tail; + decoder->packet_buffer[et].sample_type = sample_type; + decoder->packet_buffer[et].start_addr = elem->st_addr; + decoder->packet_buffer[et].end_addr = elem->en_addr; + decoder->packet_buffer[et].exc = false; + decoder->packet_buffer[et].exc_ret = false; + decoder->packet_buffer[et].cpu = *((int *)inode->priv); + + /* Wrap around if need be */ + et = (et + 1) & (MAX_BUFFER - 1); + + decoder->tail = et; + decoder->packet_count++; + + if (decoder->packet_count == MAX_BUFFER - 1) + return OCSD_RESP_WAIT; + + return OCSD_RESP_CONT; +} + +static ocsd_datapath_resp_t cs_etm_decoder__gen_trace_elem_printer( + const void *context, + const ocsd_trc_index_t indx __maybe_unused, + const u8 trace_chan_id __maybe_unused, + const ocsd_generic_trace_elem *elem) +{ + ocsd_datapath_resp_t resp = OCSD_RESP_CONT; + struct cs_etm_decoder *decoder = (struct cs_etm_decoder *) context; + + switch (elem->elem_type) { + case OCSD_GEN_TRC_ELEM_UNKNOWN: + break; + case OCSD_GEN_TRC_ELEM_NO_SYNC: + decoder->trace_on = false; + break; + case OCSD_GEN_TRC_ELEM_TRACE_ON: + decoder->trace_on = true; + break; + case OCSD_GEN_TRC_ELEM_INSTR_RANGE: + resp = cs_etm_decoder__buffer_packet(decoder, elem, + trace_chan_id, + CS_ETM_RANGE); + break; + case OCSD_GEN_TRC_ELEM_EXCEPTION: + decoder->packet_buffer[decoder->tail].exc = true; + break; + case OCSD_GEN_TRC_ELEM_EXCEPTION_RET: + decoder->packet_buffer[decoder->tail].exc_ret = true; + break; + case OCSD_GEN_TRC_ELEM_PE_CONTEXT: + case OCSD_GEN_TRC_ELEM_EO_TRACE: + case OCSD_GEN_TRC_ELEM_ADDR_NACC: + case OCSD_GEN_TRC_ELEM_TIMESTAMP: + case OCSD_GEN_TRC_ELEM_CYCLE_COUNT: + case OCSD_GEN_TRC_ELEM_ADDR_UNKNOWN: + case OCSD_GEN_TRC_ELEM_EVENT: + case OCSD_GEN_TRC_ELEM_SWTRACE: + case OCSD_GEN_TRC_ELEM_CUSTOM: + default: + break; + } + + return resp; +} + +static int cs_etm_decoder__create_etm_packet_decoder( + struct cs_etm_trace_params *t_params, + struct cs_etm_decoder *decoder) +{ + const char *decoder_name; + ocsd_etmv4_cfg trace_config_etmv4; + void *trace_config; + u8 csid; + + switch (t_params->protocol) { + case CS_ETM_PROTO_ETMV4i: + cs_etm_decoder__gen_etmv4_config(t_params, &trace_config_etmv4); + decoder_name = OCSD_BUILTIN_DCD_ETMV4I; + trace_config = &trace_config_etmv4; + break; + default: + return -1; + } + + if (ocsd_dt_create_decoder(decoder->dcd_tree, + decoder_name, + OCSD_CREATE_FLG_FULL_DECODER, + trace_config, &csid)) + return -1; + + if (ocsd_dt_set_gen_elem_outfn(decoder->dcd_tree, + cs_etm_decoder__gen_trace_elem_printer, + decoder)) + return -1; + + return 0; +} + static int cs_etm_decoder__create_etm_decoder(struct cs_etm_decoder_params *d_params, struct cs_etm_trace_params *t_params, @@ -208,6 +323,10 @@ cs_etm_decoder__create_etm_decoder(struct cs_etm_decoder_params *d_params, if (d_params->operation == CS_ETM_OPERATION_PRINT) return cs_etm_decoder__create_etm_packet_printer(t_params, decoder); + else if (d_params->operation == CS_ETM_OPERATION_DECODE) + return cs_etm_decoder__create_etm_packet_decoder(t_params, + decoder); + return -1; } From patchwork Fri Dec 15 16:44:55 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 122125 Delivered-To: patch@linaro.org Received: by 10.140.22.227 with SMTP id 90csp707006qgn; Fri, 15 Dec 2017 08:45:55 -0800 (PST) X-Google-Smtp-Source: ACJfBosJfcszdvT56HiEXvbRJAHS8r1afu5wEBs6qFuG7wRWW2aEskdMdM1WynL02wi9lWCk2nMO X-Received: by 10.84.135.101 with SMTP id 92mr14445830pli.172.1513356355002; Fri, 15 Dec 2017 08:45:55 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1513356354; cv=none; d=google.com; s=arc-20160816; b=u7y6U8DQ26xgh5wx67dx5GfXbWs3PGVRGB4OmDNqwMAp7ZpzbuxvJoO4+sNvXx/TJE C9ZDI48VbuhckUSu6XCARIZUXM2qlM0Li8iV3IAed8RC3AsCizZU5tv/0Sz1TzoP05Nb Dl7e6C+6/CWGaaWvOo82igijiMtfpeQoew4d95XZ1UI4waFHGhDpWj9zZDxIEKq9ZC1j ZddDC5ScgZLVEMh5J0JoE1d3rQgkrOwHYhcBT0Q473Z9NUTfSV56vNKqMFtaUfE0+hM8 B4IBUB3mI72N66WC3fwW7KTup18MOBZAlKv5tHNdtG/l+lL6G9VA8+2c11i9270B6Ad7 TmnA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=/ZMSClb7LNeJt9fnv4WSWglgut3CZtYd6v/jP/IUU9w=; b=qHxfyCLSEQgFCQj6HbHRjbjwHYzZi5gTd4+CfDUYqUsCCjJU9VUQPCeM3lJOEBXZKq gWXEFox1RUr3Q8v4viTIxbCq8KQB6Czrjo9VVPD7e+kXEE8abkWIHUv70mPlkfuPluk7 xy3vsU3Ser7mQlOTidUTk6a+0iqK8BLYsoseWUluhXqWeVMT3Sx524Y2cnJRjmd+/yET 54g1ZXSJKMNr5Xh+cK4qUEWnpAQ/sNj1giGvWIFN8qy5LFHvkKc/uTNwrKxwGhFt2ZnU rN5cRcqQz7vX2mGuIB5SxcRv3cecrMZLJPMNyk0anCVggFTtc0QmeeDXaFnz0rREiWzN uYZw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=CKU+myty; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id z6si4837219pgz.111.2017.12.15.08.45.54; Fri, 15 Dec 2017 08:45:54 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=CKU+myty; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756923AbdLOQpZ (ORCPT + 24 others); Fri, 15 Dec 2017 11:45:25 -0500 Received: from mail-it0-f67.google.com ([209.85.214.67]:44937 "EHLO mail-it0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756894AbdLOQpS (ORCPT ); Fri, 15 Dec 2017 11:45:18 -0500 Received: by mail-it0-f67.google.com with SMTP id b5so20960361itc.3 for ; Fri, 15 Dec 2017 08:45:17 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=/ZMSClb7LNeJt9fnv4WSWglgut3CZtYd6v/jP/IUU9w=; b=CKU+myty+SHoNSlkzpOCci7tySJZqeHbVXefD3FD/lsu235ohSHl2FOl289Qxg/apI bFWSHHc1a2zV1ZMWRRdfwjOXEIlCBdQZTVk/aSOyPqrI6chLkYQmXxyc+504YaLiOP0m k3Xzg1RoFZue5584pbxLTBowQhm3tKnndLy5w= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=/ZMSClb7LNeJt9fnv4WSWglgut3CZtYd6v/jP/IUU9w=; b=NOgUxyW1llWWY/1SGej8oSujaWAE8LaFGP0xZ18YOd2Sc8ikOfmpmfePY80bszk1/q JSxQMKSYG5sbcJP9pYjfJPi0u4KpP+KZE2frjSiFZGjbdjx9tHa9TzWo7+cA7eaBtMsZ sS0g7NB0qH+kTq6Vvkv4ol12s/xniGmBvONsmG2K+NlKm1U4LBX7/+o8WLuH4JxMV8Jg a0gqEekf/fWF7BQ+oXneCoK9x8eqZdtbNyTKdVqAw2tNHiqSWr5PilzBA1yOaCpW4sI1 9CxkotGCmXjDRjKpl0+I0QBk79j5/k+82DuHZnQnZWshTy0O3cykVjHYbL2bVfpoDIeZ SpZg== X-Gm-Message-State: AKGB3mKne92670iXUhpnScmg4sztJ8h2Byi/KMMPLQxrUahHtvkAYVjd 8KH2oZV2TWhxf1DlGMtNXPwkbw== X-Received: by 10.107.137.228 with SMTP id t97mr13528514ioi.18.1513356317418; Fri, 15 Dec 2017 08:45:17 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id q132sm3631732iod.26.2017.12.15.08.45.15 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 15 Dec 2017 08:45:16 -0800 (PST) From: Mathieu Poirier To: acme@kernel.org Cc: peterz@infradead.org, mingo@redhat.com, alexander.shishkin@linux.intel.com, namhyung@kernel.org, adrian.hunter@intel.com, mike.leach@arm.com, suzuki.poulosi@arm.com, tor@ti.com, jolsa@redhat.com, mathieu.poirier@linaro.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH 06/10] perf tools: Add functionality to communicate with the openCSD decoder Date: Fri, 15 Dec 2017 09:44:55 -0700 Message-Id: <1513356299-26274-7-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> References: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch adds functions to communicate with the openCSD trace decoder, more specifically to access program memory, fetch trace packets and reset the decoder. Co-authored-by: Tor Jeremiassen Signed-off-by: Mathieu Poirier --- tools/perf/util/cs-etm-decoder/cs-etm-decoder.c | 60 +++++++++++++++++++++++++ tools/perf/util/cs-etm-decoder/cs-etm-decoder.h | 9 ++++ 2 files changed, 69 insertions(+) -- 2.7.4 diff --git a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c index 57b020b0b36f..1fb01849f1c7 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.c @@ -45,6 +45,66 @@ struct cs_etm_decoder { struct cs_etm_packet packet_buffer[MAX_BUFFER]; }; +static u32 +cs_etm_decoder__mem_access(const void *context, + const ocsd_vaddr_t address, + const ocsd_mem_space_acc_t mem_space __maybe_unused, + const u32 req_size, + u8 *buffer) +{ + struct cs_etm_decoder *decoder = (struct cs_etm_decoder *) context; + + return decoder->mem_access(decoder->data, + address, + req_size, + buffer); +} + +int cs_etm_decoder__add_mem_access_cb(struct cs_etm_decoder *decoder, + u64 start, u64 end, + cs_etm_mem_cb_type cb_func) +{ + decoder->mem_access = cb_func; + + if (ocsd_dt_add_callback_mem_acc(decoder->dcd_tree, start, end, + OCSD_MEM_SPACE_ANY, + cs_etm_decoder__mem_access, decoder)) + return -1; + + return 0; +} + +int cs_etm_decoder__reset(struct cs_etm_decoder *decoder) +{ + ocsd_datapath_resp_t dp_ret; + + dp_ret = ocsd_dt_process_data(decoder->dcd_tree, OCSD_OP_RESET, + 0, 0, NULL, NULL); + if (OCSD_DATA_RESP_IS_FATAL(dp_ret)) + return -1; + + return 0; +} + +int cs_etm_decoder__get_packet(struct cs_etm_decoder *decoder, + struct cs_etm_packet *packet) +{ + if (!decoder || !packet) + return -EINVAL; + + /* Nothing to do, might as well just return */ + if (decoder->packet_count == 0) + return 0; + + *packet = decoder->packet_buffer[decoder->head]; + + decoder->head = (decoder->head + 1) & (MAX_BUFFER - 1); + + decoder->packet_count--; + + return 1; +} + static void cs_etm_decoder__gen_etmv4_config(struct cs_etm_trace_params *params, ocsd_etmv4_cfg *config) { diff --git a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h index a1e9b0ac5965..3d2e6205d186 100644 --- a/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h +++ b/tools/perf/util/cs-etm-decoder/cs-etm-decoder.h @@ -93,4 +93,13 @@ cs_etm_decoder__new(int num_cpu, void cs_etm_decoder__free(struct cs_etm_decoder *decoder); +int cs_etm_decoder__add_mem_access_cb(struct cs_etm_decoder *decoder, + u64 start, u64 end, + cs_etm_mem_cb_type cb_func); + +int cs_etm_decoder__get_packet(struct cs_etm_decoder *decoder, + struct cs_etm_packet *packet); + +int cs_etm_decoder__reset(struct cs_etm_decoder *decoder); + #endif /* INCLUDE__CS_ETM_DECODER_H__ */ From patchwork Fri Dec 15 16:44:56 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 122123 Delivered-To: patch@linaro.org Received: by 10.140.22.227 with SMTP id 90csp706642qgn; Fri, 15 Dec 2017 08:45:33 -0800 (PST) X-Google-Smtp-Source: ACJfBotabMLthPtZX0zcgfq9gydbNuuUPBarYK3KABwcufCoX1n16rTeC3HCxAZCu3uPm1xCQ248 X-Received: by 10.99.180.11 with SMTP id s11mr12160651pgf.174.1513356333743; Fri, 15 Dec 2017 08:45:33 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1513356333; cv=none; d=google.com; s=arc-20160816; b=pKhpkvlKMnGASuCHONszWUVCo62FqBjn/sFZzJGM/s1iGckf0QV5LjXoX5lIYMFH/z mEMfxpFxUz4rXrfyElxPFt7bwrRt6dA6rFik/3hAvSY8nswSqEN6NcPi+G6K3UHMHuaG 18/PmCxsmecuhx+Nc5UwjoLMVnOT81wAvIXn6qwgAHBbD0UN6Y7NlZw5gNpTx6DqCrDd zj7UMboklAu/yk5MmHW+bJBZZTrXIzX2RBN1msPh2NFILYlTMqFdwqL076h3O/eSPPAF 3DqBxYf8nN1E9W9IJJhAXHKqmvPv6Ve00Ze81Hp+CjiAO6V7J3SFAt3BfbxOB2qeo5a0 I24g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=nse+24OctCfX1/9soi5qNADvKvzH+f65AljLKc2a034=; b=Nm1V2zGYLgQRR+AUMIsCoMSLitsfgy/6P1dyjOt6j0O+P4j2RyeF2g7wkkSILBK3u3 1oPSm491O6Z/Q5o/E7Y01WWq1NlPnfsc7Wyj/Hv2u/A6abDhn+UbLyZdUfGhV4TKaRsL jMX9ikAr/9wcaIHG/QHAT1hekndEos7pF+b919dpjedS6m055r6jQ0y8N8fwgCFGz+0Q dVr8DaVxewMk4Y5R5jhb2YlPcBpUgMIEdSkmwCcXmLk3TRkCyjIVJJ35o+7rXYQrcBH6 jGWjmqpGheDGRlnA4Hc2AF69Ngjwc0Nt24SdAt239wpPJJUAZ/+a/O79FR6kvfxIz5sQ lfkw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=WVtD6uZF; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id z6si4837219pgz.111.2017.12.15.08.45.33; Fri, 15 Dec 2017 08:45:33 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=WVtD6uZF; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756940AbdLOQpa (ORCPT + 24 others); Fri, 15 Dec 2017 11:45:30 -0500 Received: from mail-it0-f65.google.com ([209.85.214.65]:37991 "EHLO mail-it0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756767AbdLOQpU (ORCPT ); Fri, 15 Dec 2017 11:45:20 -0500 Received: by mail-it0-f65.google.com with SMTP id r6so20323955itr.3 for ; Fri, 15 Dec 2017 08:45:20 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=nse+24OctCfX1/9soi5qNADvKvzH+f65AljLKc2a034=; b=WVtD6uZFoJrtgpvVoLsCh9EOV7Ey2Gh8SztesaAVtZkqYNTfcumObOeLHeWGbKwwLX CbInSoBweyffX8ymoHakahPG6o3kuVkvbwqpY8dBh89Oy3T/akbgdgKkH53qUeVUaJzS LK3vboMSwlMMQTPW1sKjf9xuL3WOyR76bJ5EA= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=nse+24OctCfX1/9soi5qNADvKvzH+f65AljLKc2a034=; b=MvYAyNGZU2A9wH5cOleaPstMFqxEi8rCpt5J8Ho3bsNh6/RFgi4l0VdrMEXS8aGbCg YfzmUO960oz+lLamhO6DwfPh4h1xyUTPUOwH21DJwIoAmrtHA1sKkSqRjx5Qn2c5fl+8 bP5lnlYooOIcLLz4Lyd32Wa/Ihp1tq5FVXE3yMvN2UF0wgXnTULlVWP6qSRD5/UtqXdD npNtT+11zt6PoblWcj0oyHDyqzwAmhXZmCHOYQTCsQpLk09CVqpuuKG3XU7m1OQtvFUS c0U6DsTHT2MUP0s3LbpPnAH5VJ3YywX8mT4LZFu99W2zSwrmSsc4jxLr8jg6MOky8X6i 1UIg== X-Gm-Message-State: AKGB3mLjdnLpRq/MQiYdpCj2dZ8sUCBCqOYKqv1A8M4R/7v6Cgc1XIq4 mtQRE5Sb/UljGS3D9/AfwuM30w== X-Received: by 10.36.116.135 with SMTP id o129mr8390035itc.119.1513356319617; Fri, 15 Dec 2017 08:45:19 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id q132sm3631732iod.26.2017.12.15.08.45.17 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 15 Dec 2017 08:45:18 -0800 (PST) From: Mathieu Poirier To: acme@kernel.org Cc: peterz@infradead.org, mingo@redhat.com, alexander.shishkin@linux.intel.com, namhyung@kernel.org, adrian.hunter@intel.com, mike.leach@arm.com, suzuki.poulosi@arm.com, tor@ti.com, jolsa@redhat.com, mathieu.poirier@linaro.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH 07/10] pert tools: Add queue management functionality Date: Fri, 15 Dec 2017 09:44:56 -0700 Message-Id: <1513356299-26274-8-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> References: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Add functionatlity to setup trace queues so that traces associated with CoreSight auxtrace events found in the perf.data file can be classified properly. The decoder and memory callback associated with each queue are then used to decode the traces that have been assigned to that queue. Co-authored-by: Tor Jeremiassen Signed-off-by: Mathieu Poirier --- tools/perf/util/cs-etm.c | 208 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 204 insertions(+), 4 deletions(-) -- 2.7.4 diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index cad429ce3c00..83eb676274b5 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -196,15 +196,215 @@ static void cs_etm__free(struct perf_session *session) zfree(&aux); } +static u32 cs_etm__mem_access(struct cs_etm_queue *etmq, u64 address, + size_t size, u8 *buffer) +{ + u8 cpumode; + u64 offset; + int len; + struct thread *thread; + struct machine *machine; + struct addr_location al; + + if (!etmq) + return -1; + + machine = etmq->etm->machine; + if (address >= etmq->etm->kernel_start) + cpumode = PERF_RECORD_MISC_KERNEL; + else + cpumode = PERF_RECORD_MISC_USER; + + thread = etmq->thread; + if (!thread) { + if (cpumode != PERF_RECORD_MISC_KERNEL) + return -EINVAL; + thread = etmq->etm->unknown_thread; + } + + thread__find_addr_map(thread, cpumode, MAP__FUNCTION, address, &al); + + if (!al.map || !al.map->dso) + return 0; + + if (al.map->dso->data.status == DSO_DATA_STATUS_ERROR && + dso__data_status_seen(al.map->dso, DSO_DATA_STATUS_SEEN_ITRACE)) + return 0; + + offset = al.map->map_ip(al.map, address); + + map__load(al.map); + + len = dso__data_read_offset(al.map->dso, machine, offset, buffer, size); + + if (len <= 0) + return 0; + + return len; +} + +static struct cs_etm_queue *cs_etm__alloc_queue(struct cs_etm_auxtrace *etm, + unsigned int queue_nr) +{ + int i; + struct cs_etm_decoder_params d_params; + struct cs_etm_trace_params *t_params; + struct cs_etm_queue *etmq; + + etmq = zalloc(sizeof(*etmq)); + if (!etmq) + return NULL; + + etmq->event_buf = malloc(PERF_SAMPLE_MAX_SIZE); + if (!etmq->event_buf) + goto out_free; + + etmq->etm = etm; + etmq->queue_nr = queue_nr; + etmq->pid = -1; + etmq->tid = -1; + etmq->cpu = -1; + + /* Use metadata to fill in trace parameters for trace decoder */ + t_params = zalloc(sizeof(*t_params) * etm->num_cpu); + + if (!t_params) + goto out_free; + + for (i = 0; i < etm->num_cpu; i++) { + t_params[i].protocol = CS_ETM_PROTO_ETMV4i; + t_params[i].etmv4.reg_idr0 = etm->metadata[i][CS_ETMV4_TRCIDR0]; + t_params[i].etmv4.reg_idr1 = etm->metadata[i][CS_ETMV4_TRCIDR1]; + t_params[i].etmv4.reg_idr2 = etm->metadata[i][CS_ETMV4_TRCIDR2]; + t_params[i].etmv4.reg_idr8 = etm->metadata[i][CS_ETMV4_TRCIDR8]; + t_params[i].etmv4.reg_configr = + etm->metadata[i][CS_ETMV4_TRCCONFIGR]; + t_params[i].etmv4.reg_traceidr = + etm->metadata[i][CS_ETMV4_TRCTRACEIDR]; + } + + /* Set decoder parameters to simply print the trace packets */ + d_params.packet_printer = cs_etm__packet_dump; + d_params.operation = CS_ETM_OPERATION_DECODE; + d_params.formatted = true; + d_params.fsyncs = false; + d_params.hsyncs = false; + d_params.frame_aligned = true; + d_params.data = etmq; + + etmq->decoder = cs_etm_decoder__new(etm->num_cpu, &d_params, t_params); + + zfree(&t_params); + + if (!etmq->decoder) + goto out_free; + + /* + * Register a function to handle all memory accesses required by + * the trace decoder library. + */ + if (cs_etm_decoder__add_mem_access_cb(etmq->decoder, + 0x0L, ((u64) -1L), + cs_etm__mem_access)) + goto out_free_decoder; + + etmq->offset = 0; + + return etmq; + +out_free_decoder: + cs_etm_decoder__free(etmq->decoder); +out_free: + zfree(&etmq->event_buf); + free(etmq); + + return NULL; +} + +static int cs_etm__setup_queue(struct cs_etm_auxtrace *etm, + struct auxtrace_queue *queue, + unsigned int queue_nr) +{ + struct cs_etm_queue *etmq = queue->priv; + + if (list_empty(&queue->head) || etmq) + return 0; + + etmq = cs_etm__alloc_queue(etm, queue_nr); + + if (!etmq) + return -ENOMEM; + + queue->priv = etmq; + + if (queue->cpu != -1) + etmq->cpu = queue->cpu; + + etmq->tid = queue->tid; + + return 0; +} + +static int cs_etm__setup_queues(struct cs_etm_auxtrace *etm) +{ + unsigned int i; + int ret; + + for (i = 0; i < etm->queues.nr_queues; i++) { + ret = cs_etm__setup_queue(etm, &etm->queues.queue_array[i], i); + if (ret) + return ret; + } + + return 0; +} + +static int cs_etm__update_queues(struct cs_etm_auxtrace *etm) +{ + if (etm->queues.new_data) { + etm->queues.new_data = false; + return cs_etm__setup_queues(etm); + } + + return 0; +} + static int cs_etm__process_event(struct perf_session *session, union perf_event *event, struct perf_sample *sample, struct perf_tool *tool) { - (void) session; - (void) event; - (void) sample; - (void) tool; + int err = 0; + u64 timestamp; + struct cs_etm_auxtrace *etm = container_of(session->auxtrace, + struct cs_etm_auxtrace, + auxtrace); + + /* Keep compiler happy */ + (void)event; + + if (dump_trace) + return 0; + + if (!tool->ordered_events) { + pr_err("CoreSight ETM Trace requires ordered events\n"); + return -EINVAL; + } + + if (!etm->timeless_decoding) + return -EINVAL; + + if (sample->time && (sample->time != (u64) -1)) + timestamp = sample->time; + else + timestamp = 0; + + if (timestamp || etm->timeless_decoding) { + err = cs_etm__update_queues(etm); + if (err) + return err; + } + return 0; } From patchwork Fri Dec 15 16:44:57 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 122127 Delivered-To: patch@linaro.org Received: by 10.140.22.227 with SMTP id 90csp707385qgn; Fri, 15 Dec 2017 08:46:20 -0800 (PST) X-Google-Smtp-Source: ACJfBousPaD8ipv3atlsHu9ln509xq95T9ArHajz9srmPyPkNJG9217Zb+xjGXzU81VQPM3jpnO3 X-Received: by 10.98.8.210 with SMTP id 79mr14127751pfi.204.1513356380692; Fri, 15 Dec 2017 08:46:20 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1513356380; cv=none; d=google.com; s=arc-20160816; b=JfoMCyksSwQu6swgwZeM8kyV81xKJ1CiDksepBibCoDd7bhhrcAaVOD5EnPgQOJ5/t BImnKILYSf+h4/OBNwdhbQiyG58rcf0G7/8jvd/UgomjX3AQAd9UO/QBVa/gA3yHikP5 L9IAnzYji7E8qHnbxVA6AsYmeqYXxwzsz5ENV8viXLhgnYjYvxsvisOw+nqZQF+WfpQL Z0S/Exj/qmp9h6SafG9v19ukcqOOiZb/e0WzYryb7PQ1qvy7ANXZg2SB22m4hJTWn+wV hPS/yHgMmkMPwumGtfzsk3eW5MBOODaad4TERwGlyNB02PXAJtVfwLhBOyNmLo5NlZFD ritg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=BR7xt2VJtmDUTrTdEJiMj3kNwmYfv+/f0h+P8K5mO8Q=; b=m2gR+iiO1N64x4dMAmEBYpLm13bPsOAmuvmKyWqvbOx/z1WEDS6jP//Br1cfHpfuJ2 r+tZ+yDDHDaFyec1Nh9s6D0IhkruP67DmZrddes3QKoeHlJfYbCIZKC5jMCEDW77hLcY bzZIb+krBIoQqxdR4Ws3Xl+iEAl4p0KfIk1VhaEljQmQ+kZXTWDTgNcjQWGjFpL1aloE 1asrMQH8rGf83Qk+mZZ6ibhhRYSM1/KZnzut36nC3yMQzpkhRmpnEgZ18fGacLP9HRJM FViJj3v0p2jqXFmwdKIJNHsiXUxqaa1qyppQC7QeV70zLOPW/x8tSpmBIQSvmFDAm4+o K1qA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=g02U4Syz; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id b3si5239597plb.293.2017.12.15.08.46.20; Fri, 15 Dec 2017 08:46:20 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=g02U4Syz; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1757016AbdLOQqR (ORCPT + 24 others); Fri, 15 Dec 2017 11:46:17 -0500 Received: from mail-it0-f65.google.com ([209.85.214.65]:38010 "EHLO mail-it0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756908AbdLOQpW (ORCPT ); Fri, 15 Dec 2017 11:45:22 -0500 Received: by mail-it0-f65.google.com with SMTP id r6so20324254itr.3 for ; Fri, 15 Dec 2017 08:45:22 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=BR7xt2VJtmDUTrTdEJiMj3kNwmYfv+/f0h+P8K5mO8Q=; b=g02U4SyzF4zGbmYNXKr5dyo8me+hIXb5gFFr4ZNnZ3G5mqDps6agYFoY/LP7fbZ+9V lAdvBfnSZ3W8aRAlQW8Bf+glU7ZzpznyEIGNGt6vbTW9j0Zg6+GL2B2K+6B5WAjzhmiM wTZ2uguN6bHrAfzn6B7f7EKf3SncQuDPgaIxs= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=BR7xt2VJtmDUTrTdEJiMj3kNwmYfv+/f0h+P8K5mO8Q=; b=XS7ayh5WGe70iS/CVCLKgXLiBWVsKryoC0Y+zmu5ABqdfCXKhJ4uWcEZyMWFDYFOK8 ZP+FOa1omKjuFFNHn8fnNRW81uO8v3su3a0q3gHWykVryM3h5z5qs8PT/z4e70MbvQTe 3sWfHrZwCpHsPEhCj86T8Gv0xNM7KbwbCeWQByLFk7R486Xx6oXOdB1hO8zDjPyhyLoM o8shq/k52NkgOivTOeBjbIki8ddhR32Ic3QYM75skJMVuvQI7ZLPATDwv2wjcZ0fay5F fWNPoqEXLVJpoBQkO5G+Jpb3rI+K+ue23e2R6ldwoJhfkgnobx50WbF/xKZWoJbxSPG/ otng== X-Gm-Message-State: AKGB3mIjW+YG8BCPkXccjlySrP1E7Ph2ge+GKSSvfK3gwxxf6dE61Oy0 jgD20cra8VypHFPgKPhBNPEkRfKqhSQ= X-Received: by 10.36.7.12 with SMTP id f12mr8515711itf.86.1513356321983; Fri, 15 Dec 2017 08:45:21 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id q132sm3631732iod.26.2017.12.15.08.45.19 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 15 Dec 2017 08:45:20 -0800 (PST) From: Mathieu Poirier To: acme@kernel.org Cc: peterz@infradead.org, mingo@redhat.com, alexander.shishkin@linux.intel.com, namhyung@kernel.org, adrian.hunter@intel.com, mike.leach@arm.com, suzuki.poulosi@arm.com, tor@ti.com, jolsa@redhat.com, mathieu.poirier@linaro.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH 08/10] perf tools: Add full support for CoreSight trace decoding Date: Fri, 15 Dec 2017 09:44:57 -0700 Message-Id: <1513356299-26274-9-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> References: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch adds support for complete packet decoding, allowing traces collected during a trace session to be decoder from the "report" infrastructure. Co-authored-by: Tor Jeremiassen Signed-off-by: Mathieu Poirier --- tools/perf/util/cs-etm.c | 166 +++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 160 insertions(+), 6 deletions(-) -- 2.7.4 diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index 83eb676274b5..407095af1456 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -70,6 +70,10 @@ struct cs_etm_queue { u64 offset; }; +static int cs_etm__update_queues(struct cs_etm_auxtrace *etm); +static int cs_etm__process_timeless_queues(struct cs_etm_auxtrace *etm, + pid_t tid, u64 time_); + static void cs_etm__packet_dump(const char *pkt_string) { const char *color = PERF_COLOR_BLUE; @@ -145,9 +149,25 @@ static void cs_etm__dump_event(struct cs_etm_auxtrace *etm, static int cs_etm__flush_events(struct perf_session *session, struct perf_tool *tool) { - (void) session; - (void) tool; - return 0; + int ret; + struct cs_etm_auxtrace *etm = container_of(session->auxtrace, + struct cs_etm_auxtrace, + auxtrace); + if (dump_trace) + return 0; + + if (!tool->ordered_events) + return -EINVAL; + + if (!etm->timeless_decoding) + return -EINVAL; + + ret = cs_etm__update_queues(etm); + + if (ret < 0) + return ret; + + return cs_etm__process_timeless_queues(etm, -1, MAX_TIMESTAMP - 1); } static void cs_etm__free_queue(void *priv) @@ -369,6 +389,138 @@ static int cs_etm__update_queues(struct cs_etm_auxtrace *etm) return 0; } +static int +cs_etm__get_trace(struct cs_etm_buffer *buff, struct cs_etm_queue *etmq) +{ + struct auxtrace_buffer *aux_buffer = etmq->buffer; + struct auxtrace_buffer *old_buffer = aux_buffer; + struct auxtrace_queue *queue; + + queue = &etmq->etm->queues.queue_array[etmq->queue_nr]; + + aux_buffer = auxtrace_buffer__next(queue, aux_buffer); + + /* If no more data, drop the previous auxtrace_buffer and return */ + if (!aux_buffer) { + if (old_buffer) + auxtrace_buffer__drop_data(old_buffer); + buff->len = 0; + return 0; + } + + etmq->buffer = aux_buffer; + + /* If the aux_buffer doesn't have data associated, try to load it */ + if (!aux_buffer->data) { + /* get the file desc associated with the perf data file */ + int fd = perf_data__fd(etmq->etm->session->data); + + aux_buffer->data = auxtrace_buffer__get_data(aux_buffer, fd); + if (!aux_buffer->data) + return -ENOMEM; + } + + /* If valid, drop the previous buffer */ + if (old_buffer) + auxtrace_buffer__drop_data(old_buffer); + + buff->offset = aux_buffer->offset; + buff->len = aux_buffer->size; + buff->buf = aux_buffer->data; + + buff->ref_timestamp = aux_buffer->reference; + + return buff->len; +} + +static void cs_etm__set_pid_tid_cpu(struct cs_etm_auxtrace *etm, + struct auxtrace_queue *queue) +{ + struct cs_etm_queue *etmq = queue->priv; + + /* CPU-wide tracing isn't supported yet */ + if (queue->tid == -1) + return; + + if ((!etmq->thread) && (etmq->tid != -1)) + etmq->thread = machine__find_thread(etm->machine, -1, + etmq->tid); + + if (etmq->thread) { + etmq->pid = etmq->thread->pid_; + if (queue->cpu == -1) + etmq->cpu = etmq->thread->cpu; + } +} + +static int cs_etm__run_decoder(struct cs_etm_queue *etmq) +{ + struct cs_etm_auxtrace *etm = etmq->etm; + struct cs_etm_buffer buffer; + size_t buffer_used, processed; + int err = 0; + + if (!etm->kernel_start) + etm->kernel_start = machine__kernel_start(etm->machine); + + /* Go through each buffer in the queue and decode them one by one */ +more: + buffer_used = 0; + memset(&buffer, 0, sizeof(buffer)); + err = cs_etm__get_trace(&buffer, etmq); + if (err <= 0) + return err; + /* + * We cannot assume consecutive blocks in the data file are contiguous, + * reset the decoder to force re-sync. + */ + err = cs_etm_decoder__reset(etmq->decoder); + if (err != 0) + return err; + + /* Run trace decoder until buffer consumed or end of trace */ + do { + processed = 0; + + err = cs_etm_decoder__process_data_block( + etmq->decoder, + etmq->offset, + &buffer.buf[buffer_used], + buffer.len - buffer_used, + &processed); + + if (err) + return err; + + etmq->offset += processed; + buffer_used += processed; + } while (buffer.len > buffer_used); + +goto more; + + return err; +} + +static int cs_etm__process_timeless_queues(struct cs_etm_auxtrace *etm, + pid_t tid, u64 time_) +{ + unsigned int i; + struct auxtrace_queues *queues = &etm->queues; + + for (i = 0; i < queues->nr_queues; i++) { + struct auxtrace_queue *queue = &etm->queues.queue_array[i]; + struct cs_etm_queue *etmq = queue->priv; + + if (etmq && ((tid == -1) || (etmq->tid == tid))) { + etmq->time = time_; + cs_etm__set_pid_tid_cpu(etm, queue); + cs_etm__run_decoder(etmq); + } + } + + return 0; +} + static int cs_etm__process_event(struct perf_session *session, union perf_event *event, struct perf_sample *sample, @@ -380,9 +532,6 @@ static int cs_etm__process_event(struct perf_session *session, struct cs_etm_auxtrace, auxtrace); - /* Keep compiler happy */ - (void)event; - if (dump_trace) return 0; @@ -405,6 +554,11 @@ static int cs_etm__process_event(struct perf_session *session, return err; } + if (event->header.type == PERF_RECORD_EXIT) + return cs_etm__process_timeless_queues(etm, + event->fork.tid, + sample->time); + return 0; } From patchwork Fri Dec 15 16:44:58 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 122126 Delivered-To: patch@linaro.org Received: by 10.140.22.227 with SMTP id 90csp707103qgn; Fri, 15 Dec 2017 08:46:01 -0800 (PST) X-Google-Smtp-Source: ACJfBovNIxncVsvsfMtntPiZslo/txXpM4Ex5w92k/axQ6ROs2L1D851cmdVuDvkLn9cajjO4A5z X-Received: by 10.99.170.1 with SMTP id e1mr12970956pgf.120.1513356361401; Fri, 15 Dec 2017 08:46:01 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1513356361; cv=none; d=google.com; s=arc-20160816; b=Y/4LGIXjoUDmBUTyFWq1wJGqgc9HKVODxtX2Az/3HsEkQgpDlsql8yg33WX8g+1fC0 nvgsChKM8Wp7aK1GVTSts+NYiZWC7n733erVktArHqS9YBtslvDIGbZzPrEglyq0sRva dnqUpR3pdxqcTNXFAVXXtlBOviSeY0RbxfdkHFvyeO0VypM7v2wVMsOThUUNfLn4kj8W kHeeiVXfrlg5pNQ06fqmeIAB3tRDZhTghtbIVtCEy8NkdVYmYNPD3xHJWQzwY+Zg1+W8 J+PPhbtcsJRQqxSLzqhsOWHJB5F5H6RD7GNosAIngV23Qt61VJuKccqWPqeA+XMSYUog XUHg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=A6W1XtJQdjoZR9NsZdSVjX0dAYL8NIBU+4g7IS13xkg=; b=jbBrLQ/Kq2Pz6m+kskYvMhU0dLegpZuQKrgxIhF2KdDjbSI/vZ7xY0Rmo85IG2p2hk jLBO8BQwHVBWwYGClrUVNPU4UC6K1vKkwFX6lNs6JB0dZTVyirPY2E55qEM3Cu6ZGe2u wV6SFjah1guH4A4OE/lmFYBkMcRa8LiGi5tYhUW9b0Wpm6AyO9KMUs2880Tjln5oWFnM DlZy/zNRH/BFw+YdDAsf7VZ+dn19Vq7gQqyQYN4h8dGVynKhm8dbcjeODqG8ttFYkF47 KrOPE/pcy/pFJgu8SlMlo23k60FCCCo2iuYZdMJK0/V7G4uO1Vif4Y50UsdQgFSg9eJT KsAg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=Nkl9Qiq5; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id z6si4837219pgz.111.2017.12.15.08.46.01; Fri, 15 Dec 2017 08:46:01 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=Nkl9Qiq5; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756990AbdLOQp5 (ORCPT + 24 others); Fri, 15 Dec 2017 11:45:57 -0500 Received: from mail-it0-f46.google.com ([209.85.214.46]:38119 "EHLO mail-it0-f46.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756911AbdLOQpZ (ORCPT ); Fri, 15 Dec 2017 11:45:25 -0500 Received: by mail-it0-f46.google.com with SMTP id r6so20324522itr.3 for ; Fri, 15 Dec 2017 08:45:24 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=A6W1XtJQdjoZR9NsZdSVjX0dAYL8NIBU+4g7IS13xkg=; b=Nkl9Qiq5OH68GOmYw5mjj1DGnpA4L1Fol+t6xu1sFm0A2b/Qwp+GtRlY8oNOfgHYL7 a71DiS57zLyqDN/bDTZgRwqj8cg4AXyWyX812O8rcj9oCofu613p338jws+Y3PJlBR54 z4yJlAFREBFC1sk1mshkElClerM4NMetCnqsk= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=A6W1XtJQdjoZR9NsZdSVjX0dAYL8NIBU+4g7IS13xkg=; b=qFE7EtRSgYhAP5UOMsnROGQ0Fnhz2qHguf8GcAR/X7pb1bRgCo9ZdTbygxGS8tyOxB PbhWmXEw1jip46q07oKPnaVSDfwg3L6ltkTTWiF+zG4q8zf8+UdRq8CbKvsisokyaHut mBxsZL9e4dVQgXqBODyBTCbLs+N5NunP0PcX2YtFsu4TGXr22YEY4LM8vAkYvSDbyzz7 ugQtZmwAVBXVoIDTHbNxYw/LIVgx/aNfpULGJDLOVETHr2O6d7Ui4ykbq6fp09ya17Wk sAq9NdNuSnxgmWcbyF5bHmDWv4Beuq5yZONEzrQJNE0JBKSovhTOPHj99Z7FBuawu5QN tAWg== X-Gm-Message-State: AKGB3mJqN5U+Q8OYcl++M3KOldi/vLl1/xCmp9+SYwln0yX8ff6EQeW+ yBg47o2IKDPjRHlHhmLGJo34eA== X-Received: by 10.107.1.15 with SMTP id 15mr12920616iob.249.1513356324099; Fri, 15 Dec 2017 08:45:24 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id q132sm3631732iod.26.2017.12.15.08.45.22 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 15 Dec 2017 08:45:23 -0800 (PST) From: Mathieu Poirier To: acme@kernel.org Cc: peterz@infradead.org, mingo@redhat.com, alexander.shishkin@linux.intel.com, namhyung@kernel.org, adrian.hunter@intel.com, mike.leach@arm.com, suzuki.poulosi@arm.com, tor@ti.com, jolsa@redhat.com, mathieu.poirier@linaro.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH 09/10] perf tools: Add mechanic to synthesise CoreSight trace packets Date: Fri, 15 Dec 2017 09:44:58 -0700 Message-Id: <1513356299-26274-10-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> References: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Once decoded from trace packets information on trace range needs to be communicated to the perf synthesis infrastructure so that it is available to the perf tools built-in rendering tools and scripts. Co-authored-by: Tor Jeremiassen Signed-off-by: Mathieu Poirier --- tools/perf/util/cs-etm.c | 168 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 168 insertions(+) -- 2.7.4 diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index 407095af1456..b9f0a53dfa65 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -453,6 +453,157 @@ static void cs_etm__set_pid_tid_cpu(struct cs_etm_auxtrace *etm, } } +/* + * The cs etm packet encodes an instruction range between a branch target + * and the next taken branch. Generate sample accordingly. + */ +static int cs_etm__synth_branch_sample(struct cs_etm_queue *etmq, + struct cs_etm_packet *packet) +{ + int ret = 0; + struct cs_etm_auxtrace *etm = etmq->etm; + struct perf_sample sample = {.ip = 0,}; + union perf_event *event = etmq->event_buf; + u64 start_addr = packet->start_addr; + u64 end_addr = packet->end_addr; + + event->sample.header.type = PERF_RECORD_SAMPLE; + event->sample.header.misc = PERF_RECORD_MISC_USER; + event->sample.header.size = sizeof(struct perf_event_header); + + sample.ip = start_addr; + sample.pid = etmq->pid; + sample.tid = etmq->tid; + sample.addr = end_addr; + sample.id = etmq->etm->branches_id; + sample.stream_id = etmq->etm->branches_id; + sample.period = 1; + sample.cpu = packet->cpu; + sample.flags = 0; + sample.cpumode = PERF_RECORD_MISC_USER; + + ret = perf_session__deliver_synth_event(etm->session, event, &sample); + + if (ret) + pr_err( + "CS ETM Trace: failed to deliver instruction event, error %d\n", + ret); + + return ret; +} + +struct cs_etm_synth { + struct perf_tool dummy_tool; + struct perf_session *session; +}; + +static int cs_etm__event_synth(struct perf_tool *tool, + union perf_event *event, + struct perf_sample *sample __maybe_unused, + struct machine *machine __maybe_unused) +{ + struct cs_etm_synth *cs_etm_synth = + container_of(tool, struct cs_etm_synth, dummy_tool); + + return perf_session__deliver_synth_event(cs_etm_synth->session, + event, NULL); +} + +static int cs_etm__synth_event(struct perf_session *session, + struct perf_event_attr *attr, u64 id) +{ + struct cs_etm_synth cs_etm_synth; + + memset(&cs_etm_synth, 0, sizeof(struct cs_etm_synth)); + cs_etm_synth.session = session; + + return perf_event__synthesize_attr(&cs_etm_synth.dummy_tool, attr, 1, + &id, cs_etm__event_synth); +} + +static int cs_etm__synth_events(struct cs_etm_auxtrace *etm, + struct perf_session *session) +{ + struct perf_evlist *evlist = session->evlist; + struct perf_evsel *evsel; + struct perf_event_attr attr; + bool found = false; + u64 id; + int err; + + evlist__for_each_entry(evlist, evsel) { + if (evsel->attr.type == etm->pmu_type) { + found = true; + break; + } + } + + if (!found) { + pr_debug("No selected events with CoreSight Trace data\n"); + return 0; + } + + memset(&attr, 0, sizeof(struct perf_event_attr)); + attr.size = sizeof(struct perf_event_attr); + attr.type = PERF_TYPE_HARDWARE; + attr.sample_type = evsel->attr.sample_type & PERF_SAMPLE_MASK; + attr.sample_type |= PERF_SAMPLE_IP | PERF_SAMPLE_TID | + PERF_SAMPLE_PERIOD; + if (etm->timeless_decoding) + attr.sample_type &= ~(u64)PERF_SAMPLE_TIME; + else + attr.sample_type |= PERF_SAMPLE_TIME; + + attr.exclude_user = evsel->attr.exclude_user; + attr.exclude_kernel = evsel->attr.exclude_kernel; + attr.exclude_hv = evsel->attr.exclude_hv; + attr.exclude_host = evsel->attr.exclude_host; + attr.exclude_guest = evsel->attr.exclude_guest; + attr.sample_id_all = evsel->attr.sample_id_all; + attr.read_format = evsel->attr.read_format; + + /* create new id val to be a fixed offset from evsel id */ + id = evsel->id[0] + 1000000000; + + if (!id) + id = 1; + + if (etm->synth_opts.branches) { + attr.config = PERF_COUNT_HW_BRANCH_INSTRUCTIONS; + attr.sample_period = 1; + attr.sample_type |= PERF_SAMPLE_ADDR; + err = cs_etm__synth_event(session, &attr, id); + if (err) + return err; + etm->sample_branches = true; + etm->branches_sample_type = attr.sample_type; + etm->branches_id = id; + } + + return 0; +} + +static int cs_etm__sample(struct cs_etm_queue *etmq) +{ + int ret; + struct cs_etm_packet packet; + + while (1) { + ret = cs_etm_decoder__get_packet(etmq->decoder, &packet); + if (ret <= 0) + return ret; + + /* + * If the packet contains an instruction range, generate an + * instruction sequence event. + */ + if (packet.sample_type & CS_ETM_RANGE) + cs_etm__synth_branch_sample(etmq, &packet); + } + + return 0; +} + static int cs_etm__run_decoder(struct cs_etm_queue *etmq) { struct cs_etm_auxtrace *etm = etmq->etm; @@ -494,6 +645,12 @@ static int cs_etm__run_decoder(struct cs_etm_queue *etmq) etmq->offset += processed; buffer_used += processed; + + /* + * Nothing to do with an error condition, let's hope the next + * chunk will be better. + */ + err = cs_etm__sample(etmq); } while (buffer.len > buffer_used); goto more; @@ -828,6 +985,17 @@ int cs_etm__process_auxtrace_info(union perf_event *event, return 0; } + if (session->itrace_synth_opts && session->itrace_synth_opts->set) { + etm->synth_opts = *session->itrace_synth_opts; + } else { + itrace_synth_opts__set_default(&etm->synth_opts); + etm->synth_opts.callchain = false; + } + + err = cs_etm__synth_events(etm, session); + if (err) + goto err_free_queues; + err = auxtrace_queues__process_index(&etm->queues, session); if (err) goto err_free_queues; From patchwork Fri Dec 15 16:44:59 2017 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 122124 Delivered-To: patch@linaro.org Received: by 10.140.22.227 with SMTP id 90csp706721qgn; Fri, 15 Dec 2017 08:45:38 -0800 (PST) X-Google-Smtp-Source: ACJfBouvNpMMysj/J6/fIwDntPySCbNqs+VP77W2zMyo3VR/FASJqjaZBQraXAD2TQdaKpwJ4x9x X-Received: by 10.84.128.226 with SMTP id a89mr14026692pla.150.1513356338156; Fri, 15 Dec 2017 08:45:38 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1513356338; cv=none; d=google.com; s=arc-20160816; b=L+J+xPyUXNAjSBIqohoZPFmqJU0+n9UmvXsrhUrypVItN5Di4MfwEKrADuPuc47k0m 4715HuO7Tf7tbxUtlEK/9RoyOiWnQaCe/elyH2jchIOZL89/Zin+8wERHtCptcrLbC2z zMwnvCf1Ug6ApuhfNKI4VSQi7N8SF+yP7Yp2p8ddW0crhzAey+ahfNThMj373MxxscBD UCq3o6Tzwv8+W2rUtw3YJiwJ6DHn1rHFmLLkVRn7xsskMaDjjr3xcvUzR5W0ElWY294r I8S+TFZujPUeNAMlrnAOktGrOJRe2eLT3HUjJM0FCfnth6ShE78bLV5WTZSnNWn6SMLE 0ivA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=TppG3UzXtweClvP/FN1I17r9p5WIXYtishLKyaCUe4Y=; b=P6x1XkbUxV+QzPdhoryEWeHOkX/+aW0btX/gbRHzpYZf40VfApC1FdB0XdJ8x9EUpg 000CeN6T0RtACjS32mkzl+jU+4rha0JYtvlyYrjVFqV9ITfitxa9bTxSk3vWcBdARtdX LDl99QYswZdxeFXGyXWy3Uo9Vuivmye0qQng5LpM0wp9qZwqexXEhCg6iWjEZ1LEvF+e tcZHp3kWLiPouIY3MVHy1e1Sl7iDXr60wY0jWdpo3FmlMSK6zvoxYxz+vIcyLTds/41l 9O7rGfEeMuqm8tQU4fhvuBdX0EzFVGjJU2R9ZJWRWr/B4Y4X+A9AqMGFl6z9xms0XoFD sxhQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=bq1M/C+3; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id z6si4837219pgz.111.2017.12.15.08.45.37; Fri, 15 Dec 2017 08:45:38 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=bq1M/C+3; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1756960AbdLOQpf (ORCPT + 24 others); Fri, 15 Dec 2017 11:45:35 -0500 Received: from mail-it0-f68.google.com ([209.85.214.68]:40775 "EHLO mail-it0-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1756894AbdLOQp1 (ORCPT ); Fri, 15 Dec 2017 11:45:27 -0500 Received: by mail-it0-f68.google.com with SMTP id f190so20294760ita.5 for ; Fri, 15 Dec 2017 08:45:27 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=TppG3UzXtweClvP/FN1I17r9p5WIXYtishLKyaCUe4Y=; b=bq1M/C+3D3LrAMNqeFGP3MyJlh45b0lq3kkM8chvkILjBM+Kz50UTkeaJLBnaXDpWP +eTSw6rSSvogoUtux7YmWpjQT6J1AIFs475ju8NtMGgbyHM+1PzSq0ijdPSIAShoUbpg zFtXUcSAZBY1w1q1oVyTuEvQBcbWf8TPK5xcA= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=TppG3UzXtweClvP/FN1I17r9p5WIXYtishLKyaCUe4Y=; b=DUDP05b9paxtHdIqRZtrkVUQS7ttPto7vc7n/EJY9S0iiYhKKX4HIk0fGhfVz3n7Rl L5rLVzRkT7ATR8Np1mFPUjiN4s0lEsbFLCqacHxlhC6JDXYxpO4LJ4HwHX+Ks+yFlc4Z lVkysWJhCxFkBOtJh1YEhmKuvzezD50Jg6V9zth998Gqf9Cf3E1YGgaqjLbEQQYJ3xkb J1vndjN9tASkltFkQTcuoAIh5jLstHdBoH0v42q0F33ygq3V+uLNCa8JG2YAi6txw+U1 TNtb/A6M18XLIOsvSD8K1WJY4ul+YfDpsNJdMFiowJlUWZpsFMgQyJ7z9V5Q8Vrxtk6J V0qw== X-Gm-Message-State: AKGB3mKnUBQUNzaNExduLT6oLa8cZ0hoXjV8Zpf0apE2jT380CoY4x2V qDadrdRO8m9kUMA/0W2FyGCifw== X-Received: by 10.36.190.199 with SMTP id i190mr8750922itf.84.1513356326749; Fri, 15 Dec 2017 08:45:26 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id q132sm3631732iod.26.2017.12.15.08.45.24 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 15 Dec 2017 08:45:25 -0800 (PST) From: Mathieu Poirier To: acme@kernel.org Cc: peterz@infradead.org, mingo@redhat.com, alexander.shishkin@linux.intel.com, namhyung@kernel.org, adrian.hunter@intel.com, mike.leach@arm.com, suzuki.poulosi@arm.com, tor@ti.com, jolsa@redhat.com, mathieu.poirier@linaro.org, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH 10/10] MAINTAINERS: Adding entry for CoreSight trace decoding Date: Fri, 15 Dec 2017 09:44:59 -0700 Message-Id: <1513356299-26274-11-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> References: <1513356299-26274-1-git-send-email-mathieu.poirier@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Tor Jeremiassen Adding maintainers for Coresight trace decoding via perf tools. Signed-off-by: Tor Jeremiassen --- MAINTAINERS | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) -- 2.7.4 diff --git a/MAINTAINERS b/MAINTAINERS index 82ad0eabce4f..865847aa84bd 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -1313,7 +1313,8 @@ F: tools/perf/arch/arm/util/pmu.c F: tools/perf/arch/arm/util/auxtrace.c F: tools/perf/arch/arm/util/cs-etm.c F: tools/perf/arch/arm/util/cs-etm.h -F: tools/perf/util/cs-etm.h +F: tools/perf/util/cs-etm.* +F: tools/perf/util/cs-etm-decoder/* ARM/CORGI MACHINE SUPPORT M: Richard Purdie