From patchwork Mon Jan 15 18:13:05 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124556 Delivered-To: patch@linaro.org Received: by 10.46.64.148 with SMTP id r20csp752574lje; Mon, 15 Jan 2018 10:16:31 -0800 (PST) X-Google-Smtp-Source: ACJfBouM6SpkOpY5zIubJKL9BrbOHIaLAOwZTgYbgwKlR3VAEeL1CQwJ3j3DBbNbHPuTc55FzjWA X-Received: by 10.159.230.14 with SMTP id u14mr15434255plq.35.1516040191555; Mon, 15 Jan 2018 10:16:31 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516040191; cv=none; d=google.com; s=arc-20160816; b=cg5Xxjq4SfO2zv4Bv7gfSgVQwRg8XCdNyMbt9yzg9z4Ddl9wVWeFq0Wp28U7kanhf3 RufZIsw/suRDKGZSYWFDVz3sa57M+aS725pkYK8kiJeou23tyKxhZARz1e4xwZ8ECNWF 99qM3/2NMbLZCpz/6KcG9oaP96/TF4XO/+yFLqHDAlVDEn9908w0+Arg1i8wQ/iifBCX gUYsOaD/kUADXRXxlCIUL/Zi4/xTOPTjO2/znUco7CSwesnBsFV9XR3jBITv5kCTEP24 I54ebBRBrNSsstDPktx/BnyCZOaPEeGMddzVG26YkE7bBCak7j9ajbmTBmfvplnVLATK F2Qg== 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=gbkybZ9dJPG5EiwO9Tl9VAvdLd6G3zuKa9jh8789U3Q=; b=YePi8Y0+IY+cxBy5ZKSw9aek3pMAwtPUeEF3NK685HYs2GNZIGrZwpp7hqYWhCOAyT wfuHF8MkvBogRwMmGIBDZsDlAqrmTME+IsSPy0KoW1Bby5FD/vobZ+i8eLzElpbsd0f8 gSWoEEg0DcDdz5RYEq4agtl/rCq0o4cGBB6AuXNciqvsWDn3X+n3Faf+8ByJ7rF2NjV/ EMEEwbZfFWju9G0x1IckAA8mG2BFPEt4qTfKmWwy6bi55lF0oKDVjo/Df++2QY83we+o OpXQWF/y3XgrJO8WLKb8lGoCvFHiJOQVQZGVygFRjnrTCOqIbkJapub6hojtTvpIRxtV VGug== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=CQqr8R+D; 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 u9si182038plr.14.2018.01.15.10.16.31; Mon, 15 Jan 2018 10:16:31 -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=CQqr8R+D; 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 S1751426AbeAOSQa (ORCPT + 28 others); Mon, 15 Jan 2018 13:16:30 -0500 Received: from mail-it0-f67.google.com ([209.85.214.67]:37484 "EHLO mail-it0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751047AbeAOSNU (ORCPT ); Mon, 15 Jan 2018 13:13:20 -0500 Received: by mail-it0-f67.google.com with SMTP id q8so1847053itb.2 for ; Mon, 15 Jan 2018 10:13: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=gbkybZ9dJPG5EiwO9Tl9VAvdLd6G3zuKa9jh8789U3Q=; b=CQqr8R+DROnqEKrcuWP/eiXBszYebAn8Tyh9tYusgd0Nz0g1KzsUAetQi8ZaPaURt7 YnQXksad1JxPlsgiqH6ING2Wo4ml+4OeSK7MteXKntW90eE5s3b2yq8bMz5jl0XlVoB7 ONuL6RJkZVA7nXZTgzAFCRVH9Dj+75JH+I2pE= 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=gbkybZ9dJPG5EiwO9Tl9VAvdLd6G3zuKa9jh8789U3Q=; b=lfxgYCRF9MTVVxLkELrlZlqmg18zy0xXDilKM9YEYs/D18dJtqGBDF74CQQXfXj+v7 weynX2w5GYUdMZSraz8o1N85dfadd91Dt5cAUOyh+5SFcXC87fSryydkn9Ad9stzV4D1 HvmKvlYP/TQlK/PuD2Rj2yamYsltYnPDFdFRuB+TxH7JOWpkVy7P0IYYxpv+AR3eoHpR 7LtGVHIX/wmfCwfslen5lGC131zqPi/3egOd/KlIlzFwe4ZFVPNOAWQZrjuV6SRd4SI1 w7jFy1N5mhzVanOt04KNB71rxiy3wBVUWKubEmnAGgJZ86cQ9T/FnJKH0XUgNyEoy2Oq fYgA== X-Gm-Message-State: AKwxytfPemaduWtBYt6CqT/Rfm1gbJ+u53i0bU7bGaZYhEDmsaA6IPGs g3r61w7RkhtTM1y0iNwoM63tQA== X-Received: by 10.36.170.7 with SMTP id b7mr1199168itf.147.1516039999985; Mon, 15 Jan 2018 10:13:19 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id w142sm231480ita.25.2018.01.15.10.13.17 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 15 Jan 2018 10:13: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, jolsa@redhat.com, kim.phillips@arm.com, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v2 01/10] perf tools: Integrating the CoreSight decoding library Date: Mon, 15 Jan 2018 11:13:05 -0700 Message-Id: <1516039994-314-2-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516039994-314-1-git-send-email-mathieu.poirier@linaro.org> References: <1516039994-314-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 | 7 ++++++- tools/build/feature/test-all.c | 5 +++++ tools/build/feature/test-libopencsd.c | 8 ++++++++ tools/perf/Makefile.config | 25 +++++++++++++++++++++++++ tools/perf/Makefile.perf | 2 ++ 6 files changed, 50 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..2b108a6cfac3 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,10 @@ $(OUTPUT)test-sched_getcpu.bin: $(OUTPUT)test-setns.bin: $(BUILD) +$(OUTPUT)test-libopencsd.bin: + $(BUILD) # -lopencsd_c_api -lopencsd provided by + # $(FEATURE_CHECK_LDFLAGS-libopencsd) + 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 12dec6ea5ed2..15ef1e55c7d0 100644 --- a/tools/perf/Makefile.config +++ b/tools/perf/Makefile.config @@ -105,6 +105,16 @@ FEATURE_CHECK_LDFLAGS-libunwind = $(LIBUNWIND_LDFLAGS) $(LIBUNWIND_LIBS) FEATURE_CHECK_CFLAGS-libunwind-debug-frame = $(LIBUNWIND_CFLAGS) FEATURE_CHECK_LDFLAGS-libunwind-debug-frame = $(LIBUNWIND_LDFLAGS) $(LIBUNWIND_LIBS) +ifdef CSINCLUDES + LIBOPENCSD_CFLAGS := -I$(CSINCLUDES) +endif +OPENCSDLIBS := -lopencsd_c_api -lopencsd +ifdef CSLIBS + LIBOPENCSD_LDFLAGS := -L$(CSLIBS) +endif +FEATURE_CHECK_CFLAGS-libopencsd := $(LIBOPENCSD_CFLAGS) +FEATURE_CHECK_LDFLAGS-libopencsd := $(LIBOPENCSD_LDFLAGS) $(OPENCSDLIBS) + ifeq ($(NO_PERF_REGS),0) CFLAGS += -DHAVE_PERF_REGS_SUPPORT endif @@ -353,6 +363,21 @@ ifeq ($(feature-setns), 1) $(call detected,CONFIG_SETNS) endif +ifndef NO_CORESIGHT + ifeq ($(feature-libopencsd), 1) + CFLAGS += -DHAVE_CSTRACE_SUPPORT $(LIBOPENCSD_CFLAGS) + LDFLAGS += $(LIBOPENCSD_LDFLAGS) + EXTLIBS += $(OPENCSDLIBS) + $(call detected,CONFIG_LIBOPENCSD) + ifdef CSTRACE_RAW + CFLAGS += -DCS_DEBUG_RAW + ifeq (${CSTRACE_RAW}, packed) + CFLAGS += -DCS_RAW_PACKED + endif + endif + endif +endif + ifndef NO_LIBELF CFLAGS += -DHAVE_LIBELF_SUPPORT EXTLIBS += -lelf diff --git a/tools/perf/Makefile.perf b/tools/perf/Makefile.perf index 9fdefd748e2e..92dfa9580eab 100644 --- a/tools/perf/Makefile.perf +++ b/tools/perf/Makefile.perf @@ -98,6 +98,8 @@ include ../scripts/utilities.mak # When selected, pass LLVM_CONFIG=/path/to/llvm-config to `make' if # llvm-config is not in $PATH. +# Define NO_CORESIGHT if you do not want support for CoreSight trace decoding. + # As per kernel Makefile, avoid funny character set dependencies unexport LC_ALL LC_COLLATE=C From patchwork Mon Jan 15 18:13:06 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124547 Delivered-To: patch@linaro.org Received: by 10.46.64.148 with SMTP id r20csp751830lje; Mon, 15 Jan 2018 10:13:33 -0800 (PST) X-Google-Smtp-Source: ACJfBovOLPqo+SAMV6f/J2RXXZ0Ah7xFPOnCXVgAzWuAdHR2sNqNN5VUsWBUNvA6dGTFrc/kBKTn X-Received: by 10.101.81.7 with SMTP id f7mr28084497pgq.443.1516040013515; Mon, 15 Jan 2018 10:13:33 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516040013; cv=none; d=google.com; s=arc-20160816; b=HC9lnd0FhRUAlc52muqJhzqgDqA8q6kO2P6C0Ob9Bl3zHKuQg3Vv8P/aNTPfHzY1dP KEZwwqEluEW1RbgNLa6ZQH9Vclclq5ciUIb3UVHyS5Hpb6+bHrTs1Kn6bcl6tENkF2yP aGSoCFpk0In9NwfynUatbkKScyZo0pQP9ANESFvgIfS2OH01kpP6sbA81cQtImLoQzHS q+dXmPkUmbxJeN5adYaDNuXGzf5987z7qQdevf0WPz4ufAg4D8+62WSjkk5URyCwsNIi lIHrCy6vjxOIOqmJYHP0zMl07BW1O5FRP9p0KYq8kXOREXypcEwFsaVqBqq9CCnN9UO+ ikCQ== 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=k+GfMYH3HvMObLImuNj88koUwUW6expwSPiPS5VgS0M=; b=SAfFqRcK5cajO75FvLz8oGBNr0ZsICTldEKYfsIGkRjA40V2ih5vOmqdEer1NSZ234 tGcSL3pBLWR10pb56aIYjlZiGqQIsGCW+C7m8UpQnqR71bzeSiTsoXLWBJifYnQPxT9q gqZk+B7EqqUWrVDptuL0iMTGEWR25YsKGcRT2u1o/J3UIuqqJEfSmvwOiqX60ZApPDZZ /tN0TYBz6nBrYJ2zZkDkHg6LBPQE9zXZwF6+gz06fzHyok/Y7GZ6uJpQlGJQjq2msUaR cPAcqsJzIe2wAveiJI5NvlXatKGrV0SiakiG4glccq7X5WjSqL2YG+uNq+Zm+UlFWo4a vW4g== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=ES0V0AZt; 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 l11si9530plt.210.2018.01.15.10.13.33; Mon, 15 Jan 2018 10:13: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=ES0V0AZt; 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 S1750926AbeAOSN2 (ORCPT + 28 others); Mon, 15 Jan 2018 13:13:28 -0500 Received: from mail-it0-f67.google.com ([209.85.214.67]:36662 "EHLO mail-it0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751142AbeAOSNW (ORCPT ); Mon, 15 Jan 2018 13:13:22 -0500 Received: by mail-it0-f67.google.com with SMTP id p124so1852864ite.1 for ; Mon, 15 Jan 2018 10:13: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=k+GfMYH3HvMObLImuNj88koUwUW6expwSPiPS5VgS0M=; b=ES0V0AZtVPJafxVKHUNYTQCbapDTuBFKK7lZsEk/8MZteDJ8MqyHMg2LqcWkMCK56J vgNSXXCWmckAubK7eydytSTI5gkGOi9NxJjr5DPZHcNuzAfD5naTCn34xsxTo1EF6/E/ rg715XWCCW1OXjOSwvaNm2VNaXHpeHXKwNcR4= 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=k+GfMYH3HvMObLImuNj88koUwUW6expwSPiPS5VgS0M=; b=nP9iMSZdXQSDbQV93jwRsijnF2vdqKzx60RWvU/8grOn1TVSmX986YpFNetOaEGEU8 mh6DIQ/XY1svFXJMUDDI1vpGwMKlhmmhU7o/fnD8QxgTjnDjXtLSFlKb0ttZ3DABRB/9 7G0aM1l7mvvZza2YPV4tv/BQDBM5LKMbJJQpXNXXVYW8AwWW2I/1T6oyXHssZABoh6HI kv30gi5Ak6KdEyleMNBqPZUmhMis94BmWCHfWovJxA4trR+Kgduizo0tJgh4kw58JINF i7qm6XMFewduynXsMKS67vVEv5PN+7Nc1VSRya/7sQ9aVei5XiWw7i8ljzqi68snXbD2 /hQw== X-Gm-Message-State: AKwxytceC2RgbKSfqIRfvv6bVZ0Rd0GIQd70UBcL/mIae9pxrmbHfOhy HIUMbrjHxkYT5DIz5CVwZ5GeRQ== X-Received: by 10.36.20.145 with SMTP id 139mr7053776itg.15.1516040002182; Mon, 15 Jan 2018 10:13:22 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id w142sm231480ita.25.2018.01.15.10.13.20 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 15 Jan 2018 10:13:21 -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, jolsa@redhat.com, kim.phillips@arm.com, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v2 02/10] perf tools: Add initial entry point for decoder CoreSight traces Date: Mon, 15 Jan 2018 11:13:06 -0700 Message-Id: <1516039994-314-3-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516039994-314-1-git-send-email-mathieu.poirier@linaro.org> References: <1516039994-314-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 7c6a8b461e24..d3c42912264a 100644 --- a/tools/perf/util/Build +++ b/tools/perf/util/Build @@ -88,6 +88,11 @@ libperf-$(CONFIG_AUXTRACE) += intel-pt.o libperf-$(CONFIG_AUXTRACE) += intel-bts.o libperf-$(CONFIG_AUXTRACE) += arm-spe.o libperf-$(CONFIG_AUXTRACE) += arm-spe-pkt-decoder.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 3bba9947ab7f..9faf3b5367db 100644 --- a/tools/perf/util/auxtrace.c +++ b/tools/perf/util/auxtrace.c @@ -52,6 +52,7 @@ #include "debug.h" #include +#include "cs-etm.h" #include "intel-pt.h" #include "intel-bts.h" #include "arm-spe.h" @@ -914,6 +915,7 @@ int perf_event__process_auxtrace_info(struct perf_tool *tool __maybe_unused, case PERF_AUXTRACE_ARM_SPE: return arm_spe_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 Mon Jan 15 18:13:07 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124555 Delivered-To: patch@linaro.org Received: by 10.46.64.148 with SMTP id r20csp752496lje; Mon, 15 Jan 2018 10:16:12 -0800 (PST) X-Google-Smtp-Source: ACJfBovLAjZspkOg6QkJ/oKdJtkh2djP0aBSA89RIp6hyxj/hKU5pKA5Uh0MkwfjrSndeRyT1Is/ X-Received: by 10.101.93.71 with SMTP id e7mr27108373pgt.84.1516040172014; Mon, 15 Jan 2018 10:16:12 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516040172; cv=none; d=google.com; s=arc-20160816; b=jEYCOFHgUFPLN36hdI7gFiqKeONemniDFxQARbMzcPR/fMWO5HyZkjXun9+pjSSWnS jPDCdttV1m8qRrtTyGRqaBBmpRbUPGmWzjremevg0eeqyO0kgKpj0WSUNHICUU/4Rwqk TgqLNgSthS8CphFg3+MY5EE+5pLgNg3HQk5TFxij3iXfqXO0SHvatjLY4HyajZGpVYmb MhFA8whFOZzRrjJz8JHMLrZmA5p3l1xGrgfmTXUZp1xbBwf/Ib8U/zhzEoaNlIyWRF6z 2ZHSEj8jYO9PXZNkzDif+gyMHEyULmvMkx/YGEmMoTHfYa4BHTG6ukyx+DJiKYn0hXgn 1SjQ== 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=j+VWbwjI5DwHAY0/fi0LY44nn4K11ymAIIHvfGbz9Idbz0ySPkZqmgGore8ChlLAmP OG5133MfOItSdHXtn9DjTPDqNrHWNjlrxdfTFKsySg12KBwe03aASgzuxAp9cB9qThVc ubLrhfkczVnKxDkbOAkbXB2KpNpes1lQ9mjTUTA24gMI9yniKeH2jrw+fnUyiXpGNaER flLTAbaVKcjBFQ2ZGFtwgywuZbFiRepII8IrQ5oCGN7XvxB9/7X0QxymKNwVoZvRjk/h +6T/UV/JzsDE2cGDX5mPcF7JA5C3PnvTxmQh2mhAsEWMrRpkpD+z/t6JzWHDd/JkS93G Csug== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=kGElcVGj; 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 u9si182038plr.14.2018.01.15.10.16.11; Mon, 15 Jan 2018 10:16:12 -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=kGElcVGj; 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 S1751407AbeAOSQJ (ORCPT + 28 others); Mon, 15 Jan 2018 13:16:09 -0500 Received: from mail-io0-f194.google.com ([209.85.223.194]:40243 "EHLO mail-io0-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751178AbeAOSNZ (ORCPT ); Mon, 15 Jan 2018 13:13:25 -0500 Received: by mail-io0-f194.google.com with SMTP id t22so1772215ioa.7 for ; Mon, 15 Jan 2018 10:13: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=h6gFYn2Sm/l+6WvRTW5wMs15wdVKln6BIp+8mGTrHes=; b=kGElcVGjjAuxMNpuhZVjT6kh/4747TSDK1AItAGy9TPMnnLwJI29HtOrnswl7SCDOn 8+1ike5EQpu2hSBZ8+255Mi3PHIj5wI7oNYcEW3Ri1/sMD02aJjeSv8RU8oK6apKv9WC WGzRGN7PcNcKEbQkuYpj8YNoLQv9wSrXC4gWM= 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=a71iXXl1Anx2oF04bQa/ZGP/ko0ZKBmuN8YMi0hNw2NLj7Vc1OJC54J4szFDvWt8hE bwNVMG+u1/1ZYUSSgJl8j+Em2OJcPQMefDK3IhdUd5ss3X+fOw1kYSyMVB45gKTjWLf4 ijfGUdFZ0h1H3KOrVM5pGBZ7IixHDujRIsqL97qBaFmshG9PhXqiIo3KqBA89FbGaQcF PuGUUEHOOSBdVepzOUFfmGaaylNwWRG4F9Rk9iSLIDNr/qP5klzpdddqMg1hvWlUp4+q RyRRxdK72qMd9EQFPq6H/+tooMigkI4yr88TCADo6k0iWYXeCs/5lWTcou6E8Ya6REga gh8Q== X-Gm-Message-State: AKGB3mIA9YS1SDfn2A2Pc1C2+Lu6R/3QLSK91DhOmGD1MEgTgih24NIJ GwX0UL1AJuOzcclYnwegkAohkQ== X-Received: by 10.107.26.2 with SMTP id a2mr37924666ioa.77.1516040004390; Mon, 15 Jan 2018 10:13:24 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id w142sm231480ita.25.2018.01.15.10.13.22 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 15 Jan 2018 10:13: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, jolsa@redhat.com, kim.phillips@arm.com, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v2 03/10] perf tools: Add processing of coresight metadata Date: Mon, 15 Jan 2018 11:13:07 -0700 Message-Id: <1516039994-314-4-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516039994-314-1-git-send-email-mathieu.poirier@linaro.org> References: <1516039994-314-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 Mon Jan 15 18:13:08 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124554 Delivered-To: patch@linaro.org Received: by 10.46.64.148 with SMTP id r20csp752358lje; Mon, 15 Jan 2018 10:15:36 -0800 (PST) X-Google-Smtp-Source: ACJfBovSrq/4BtL2b/MFz8dza+/kCeyh0x7kPAYReIwwSgRalI2ggYkpE28qTsW9nfUVA0F0U3F5 X-Received: by 10.99.96.142 with SMTP id u136mr23981348pgb.406.1516040135870; Mon, 15 Jan 2018 10:15:35 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516040135; cv=none; d=google.com; s=arc-20160816; b=It0gelbnrWJfYhePYkcotFVfX37p9Ba7TQwuxQdhggmDdsOtURaotDrMCLzKeH23B/ nEmChd360Awsd6WG/Aosx82U24rWiSK5zhvfyFJ1A9wrpe8D8Z2XEdC3K/44LTHgUeQ8 hHuqG2xsvx+kLGlhFlKc40YaGljdFv5mkINrPu4Gkp1el6aSpX23WJ/DJzXw9XdMzbej n99Beg9jsCt+fKt0wYcckf7WJLuX0aSwnKqNWUtZV07mn1MMjdDJcA43dQCgbOhQn7rJ xZhG3gqZdSwXSTNJX6eho+gCApjDk7UiW0T2XNbKKclPowxk/7FFBWshpJiNT+pDcjYt KpMg== 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=Hhl234OUgIC14AcsGeph6ltDuBaAr/ZOdpr0aId2qFs=; b=CTOwJ9jq9PbrbVy79Gh3sUKRN9JEbaydyJ5jD407A3efcQnnQfTnz+EjKtc2WNsIVz 4jUO2As3raa2Y13Xr9Ay1IUAOiJFpn5nIPPSJzNjtRUA+KlY9lSRWu5ar/MElHDhwGsr CB8DWvQ/MhMl4rJXLU2vOVBmdKdvSQNxO1kQ3uIFbFIBeiC/2qb302OZSMRJjm1u+kwH NtDcQib3uHSxJrcZXhF6NeZsg7B75xYxeq3HkEZag3xUmXtHkmSXYZwnVfEe7+X21dGJ yAmGtBmrEg+b+PxdWiW0IrWBtePz9sd6FEsYm3nDl1QpRQRLglQzT5WUE6JHPwv3mi0o rKQg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=dwS6NC2Q; 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 n6si158561pla.402.2018.01.15.10.15.35; Mon, 15 Jan 2018 10:15:35 -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=dwS6NC2Q; 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 S1751498AbeAOSPd (ORCPT + 28 others); Mon, 15 Jan 2018 13:15:33 -0500 Received: from mail-io0-f194.google.com ([209.85.223.194]:44173 "EHLO mail-io0-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751205AbeAOSN1 (ORCPT ); Mon, 15 Jan 2018 13:13:27 -0500 Received: by mail-io0-f194.google.com with SMTP id k18so13966323ioc.11 for ; Mon, 15 Jan 2018 10:13: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=Hhl234OUgIC14AcsGeph6ltDuBaAr/ZOdpr0aId2qFs=; b=dwS6NC2Q1th7kMvmq4KTJBID61l8BO++1DRUDXWeGp5VDdu2v88IXoUFkK/WjsMSK9 HiS+7eBvjz61A6X9SAyt8XQeEKSd381IYqaBmuj0CFp2uUjDEIDGjaE1tYLux1nltbr+ UeDlMQDdhopipxZi3jEZ4jA80i6qVWa17sa04= 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=Hhl234OUgIC14AcsGeph6ltDuBaAr/ZOdpr0aId2qFs=; b=Y/tTjYk3QceVDVEU44Y/7mPhFWaUauQFRwr0Yj0hA/h4KGNS2pyPV3Z+2r2hVrfiD4 KsJhvwwULZnbFwe56dBfNoB13g3m0kX/FzHFRgUARU9cIyMe2U23FYUPElAKQNp20LOy UqRpMPFAtBYHTSH+GoTzozGyoSf/464J32roHcoqmRT7M07AmcdzWcgRbcxoW9grlngr /YNgDoeSXLPw3XTlzPhI/MNAvA4ppax4XcTxfUSab9XcKqO3J09HlQCthV4d/yH0JRij zVFbQBJgUYgBkMzH22ZJVhTJ5T2UYG2bUMNGyBV1lJXj6cKbLwC0cUOCz7VEjHInAcYL f+SQ== X-Gm-Message-State: AKwxyteQUeDuUF42k8OTSe+T29AuslYtF7Vs3FbToHR/NFjjT7JDX77Y nQJPBumnwabm/1QLbPU6qCP0KA== X-Received: by 10.107.134.76 with SMTP id i73mr13919994iod.29.1516040006630; Mon, 15 Jan 2018 10:13:26 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id w142sm231480ita.25.2018.01.15.10.13.24 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 15 Jan 2018 10:13: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, jolsa@redhat.com, kim.phillips@arm.com, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v2 04/10] perf tools: Add decoder mechanic to support dumping trace data Date: Mon, 15 Jan 2018 11:13:08 -0700 Message-Id: <1516039994-314-5-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516039994-314-1-git-send-email-mathieu.poirier@linaro.org> References: <1516039994-314-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 d3c42912264a..6173155ca2c1 100644 --- a/tools/perf/util/Build +++ b/tools/perf/util/Build @@ -91,6 +91,7 @@ libperf-$(CONFIG_AUXTRACE) += arm-spe-pkt-decoder.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 Mon Jan 15 18:13:09 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124548 Delivered-To: patch@linaro.org Received: by 10.46.64.148 with SMTP id r20csp751847lje; Mon, 15 Jan 2018 10:13:37 -0800 (PST) X-Google-Smtp-Source: ACJfBouyjXEt/TrknRt3cpHTPmHS7lGYTntmlH9YSUrPTxY5RRoB8OvVDfdXf5PrHMeImHNr+Tnz X-Received: by 10.99.143.10 with SMTP id n10mr29423423pgd.212.1516040016827; Mon, 15 Jan 2018 10:13:36 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516040016; cv=none; d=google.com; s=arc-20160816; b=lnHYusbOemvXEkRaxIoBWHws0nbnsYZwO6y3alaZgpjNV9tDBSP5lu10RtO8VVzAZe UwH/vneETtEpLR95+KrJ7fVON3ZleDvPGMeMZiXOP9nNpgvOCo5uKaCX53vFvcEf9rLs FY4bv0lr+FGmuTsKuzy0a+cYKCIFNz6vbd+9C5f5IPTtFfJGReiHOWKDf88yLc1c/aY4 vUDfhPYdlGnvzQJDpNvLx42UI2/NFo+GPqq1BF9vAk+AZFSpmZterMcYzLDkcFpVf1YH ndM/HcW9IdJjgXgnCpslhSdiY8Iq9oTH95i6ggHEIBfrc/lprsXxWE+2DTvzKhSn1caH sPyw== 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=E16CjOn4uim/2qQNxdk5VnOd9JdyOiCnVg7AF9bqu/r7sHCTAjSJjW3JLC9JDCIIpP hn54dgnYcSwe3obfmTfgMoZJ3gzvmAxjthP2MXieF+Q9kLYFigoyS1aP0WQYbIFpFdpS QR5G71oaaJRCVHa6IZ3RPd+Y3QoifRTzp8lfLDRQBqsvsIUS/AdRnRd/IjA/3XwY60/6 Av6CrYg4hKU9xiW4GJzrAj8nQ4WZ9fJWz9dqZrcPy3rgt0ub8slnlQ2w9hhGc354pZXZ hSOSJCR//bcvKOWXZyFgOKUYIV2G9V7CbQfO23F+EnrVytW8fhB4xeAPKkwTH3a5tL+f 4v0w== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=IuShW6u0; 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 t14si130799pgc.793.2018.01.15.10.13.36; Mon, 15 Jan 2018 10:13:36 -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=IuShW6u0; 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 S1751306AbeAOSNe (ORCPT + 28 others); Mon, 15 Jan 2018 13:13:34 -0500 Received: from mail-it0-f65.google.com ([209.85.214.65]:34160 "EHLO mail-it0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751142AbeAOSN3 (ORCPT ); Mon, 15 Jan 2018 13:13:29 -0500 Received: by mail-it0-f65.google.com with SMTP id m11so9119525iti.1 for ; Mon, 15 Jan 2018 10:13:28 -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=IuShW6u0WX/mUwV5k0VxXygFBM6BBXt3FihdHG8sbfW11j5m+XyLutyL3qGTLT/iVC wis6E1ZhoYzl8MRApy4LlTLKLUubqjsmTa6QqfPt+5G+ED/kNtSQchf6Dy2Q6rCQuyCa /njtlWsGRIsvoUjFDjCIMtuygU5aQ3ktJfNrg= 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=NuUkBxHOyV8w55WJS0qoMovXWilQpwaPoas/MOr1MHIQcf7xeQiGmE7kskxFWw+wLt AjpRytthp3RVGDnNrQ/gccv9rWro1XIaeFwtsNK5MIOsQZiqEK4PdUSQzJhzAJCfG+mP ljBaBV8kYDlzslrK/1uCSGZkNDFQVa4nUmAMKXFn5dkTBLXyrCTbfpC7pfP0VrDrv1bX NEv5P9BYdJdCPCsXEjNburY9F/Svjj2q9YYpu88X6bxrn+6ALxUJPDwhhtyn24L9+RMC ynGWo9jr6lTXM9/JP8JHaum00nRWEPnD3GDcHY1W7D13WDlVmhCBLGeQlW3sZBhgqqQ6 hMfw== X-Gm-Message-State: AKwxytfV6YfYcnRQMAp2T9Q7uWig2TZeA4bUbPhOefGu3TlqSn2GNkzy MF2TFCS5EZ976llsJj7ckMhNaw== X-Received: by 10.36.39.138 with SMTP id g132mr15175681ita.89.1516040008597; Mon, 15 Jan 2018 10:13:28 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id w142sm231480ita.25.2018.01.15.10.13.26 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 15 Jan 2018 10:13:27 -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, jolsa@redhat.com, kim.phillips@arm.com, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v2 05/10] perf tools: Add support for decoding CoreSight trace data Date: Mon, 15 Jan 2018 11:13:09 -0700 Message-Id: <1516039994-314-6-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516039994-314-1-git-send-email-mathieu.poirier@linaro.org> References: <1516039994-314-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 Mon Jan 15 18:13:10 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124553 Delivered-To: patch@linaro.org Received: by 10.46.64.148 with SMTP id r20csp752343lje; Mon, 15 Jan 2018 10:15:33 -0800 (PST) X-Google-Smtp-Source: ACJfBou1G7NOmy7LiOlOIT9ZECNy7VLhLPMhTZuKIyywB1HB6tFwM77KE3zISDIBgHmLsKy1w77t X-Received: by 10.98.91.193 with SMTP id p184mr31859360pfb.16.1516040132852; Mon, 15 Jan 2018 10:15:32 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516040132; cv=none; d=google.com; s=arc-20160816; b=WCXWdS/99XOOs89vhuu/1TDZY+iK6je2A/kcMkp11EihMwxeF1PKUUxOOVKBff7zhK anxAY27QIPklxxX+G5gO09Yuku/KIgP6UQ5iE1rg97bGXuaVH2DT8OmP6YvgBeFFYlZi hKLw40rO8NXRhdIuKKfJYiYdKfDc5ygdquN5N6JuZLARTv8QGTfjpmszeB+rj2VbYeHZ y/IukDLUJwSn8v3oD7ftelKOHZkjYGsabAPJ+nQBdnQWlm1gGEyWDadL9bGbH/Dr0f4I 9VBhEaVvwGqg88oE/YfxGHtJTxpzXmsnIVaEcpI4Td8ono8RlMHV1bYBkeejfxVQvkM1 EEQA== 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=kryfLUXrqkYFTkmRcT/OGcJCdeodwk6Ibq8PdPElmy/M+COPtSt3MOnEkzoIlnQyDu SEKCeTboaloDNBEsEBDRAfrnTVErFPCYYqaFH0eVGOb27ZXR6kGCKKkbENqLMi401F+U +SnGhs70NNaYKdGRjojuVuoE113xTrJ8XC0H+5vZGjBVJYdA4jeuAEJxstvJqAlXWnFZ g70Uw2hudAsjWOSvSKnjL88e+vdNelD8QjT0hIH/r0CJRaOBkhDwg8q7Q1SEpj9CQZbq jZSAWULJOLC7IZraPdTEDSKTM82RCbSLkZ517PzwNX8PisJVJklTPNlunkVE36i8K6zi 2kpg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=FSz6CiFY; 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 n6si158561pla.402.2018.01.15.10.15.32; Mon, 15 Jan 2018 10:15:32 -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=FSz6CiFY; 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 S1750997AbeAOSPb (ORCPT + 28 others); Mon, 15 Jan 2018 13:15:31 -0500 Received: from mail-it0-f66.google.com ([209.85.214.66]:44903 "EHLO mail-it0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751195AbeAOSNb (ORCPT ); Mon, 15 Jan 2018 13:13:31 -0500 Received: by mail-it0-f66.google.com with SMTP id b5so1849337itc.3 for ; Mon, 15 Jan 2018 10:13:31 -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=FSz6CiFYydxm7TccS1S2U0jrTx0oOcsw8OPm+Z8iRpIIY8yyUwsTQU52i5okUpbByR gAdNmAbFrpyxE0pcoeePhDZ0aagbk/slALx7+r/+PCO6UJk8RptJMch5C4vnz6l2rPcS CdwLkRFdKrpp9Wozm1KP5OxC3+QK3ASlVfHSE= 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=la73DZ1hxdEHJyfJcm3ayA0SrRNVkgfWExoKu+yGjLzWD/pXJj/xbWUd+MftJQ1xO0 A/zmo287cr2K+EVa+2/Rfctikbvo67UMhbQ3k42ataZamRbs/QpTxVfEvzZ3g5Qsgsk/ Q8A6W2MSmzye24IcsXr444v54jVoJ1N9mRBzLcNf0H4HZGzsb5Q9gjFbO1rQgCqMLDda l++9vzPEtOS81B3QIJhG5ZCglvSs4BEx5ODYDcxeYN4Br/nuJogSAcDjCpBOrs4C7Sks Ay8iSR2m0CFAYAYrTGTynsTKDndfgTaxpoaX3W9GX3oNWbu2IqQ/ViGAGHyr2EhMRgNU 5dLA== X-Gm-Message-State: AKwxytdpngLuvzD204U/2yHH2IeMTbypeFBIN0riQklvjDxkGtOR50S6 9YzPcetDXHBTN4KMoWTYjSUs5eJ9Ncw= X-Received: by 10.36.222.66 with SMTP id d63mr13794614itg.99.1516040010732; Mon, 15 Jan 2018 10:13:30 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id w142sm231480ita.25.2018.01.15.10.13.28 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 15 Jan 2018 10:13:29 -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, jolsa@redhat.com, kim.phillips@arm.com, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v2 06/10] perf tools: Add functionality to communicate with the openCSD decoder Date: Mon, 15 Jan 2018 11:13:10 -0700 Message-Id: <1516039994-314-7-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516039994-314-1-git-send-email-mathieu.poirier@linaro.org> References: <1516039994-314-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 Mon Jan 15 18:13:11 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124552 Delivered-To: patch@linaro.org Received: by 10.46.64.148 with SMTP id r20csp752167lje; Mon, 15 Jan 2018 10:14:51 -0800 (PST) X-Google-Smtp-Source: ACJfBosDh8ezJdRrvHhMuJWhOK331sweQt9dwhWvzeI0zYMQBXy/EU8gEwD+nCuFo3fIUroCRTOS X-Received: by 10.84.135.129 with SMTP id 1mr8686154plj.411.1516040091462; Mon, 15 Jan 2018 10:14:51 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516040091; cv=none; d=google.com; s=arc-20160816; b=JgHuA5m3okHANNljPpamPfd4XlGzqJOaUZUN8E7jAudSD3pd4YXwxlJgK0AJLzWfcW uEp7se3RvvsxNkAcrJA9BMGrLZ2akaTNwgWasFU0SjUF8rJ98sTUxbMffTnCdFpMkcSr oS1hm7tGZWBJX/GEi46J+sa0TPGciW6wFpe84V7GL3EZK164/hj4FRhvJjnN3IYrzeW/ wWLhrpn1LxNCFgGY9pECwMI8BAK6Cfbtmz9NLI06xctuVzzLoAGxGhvYIAx62KydWngu t9SbfTZFVaAKDzC5KU0ci/r9CUHq/GMzGrv1GwjkskpQZMDnn1/mb+pJyDHJF74Swz58 UhVA== 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=LXV2dkBD9sp81Gf8kYQAVqnyx1btApLdkrMK+Vd7KfxZdzsAowKaXwTFRAfV6m0/tM f1OQGwXAXntUnbIbCIkmsyjJDYlv0agjkFWtD46DDmB94+N8Bxr7skp3czBEqvZgX253 uro4jTiYjisYFiUVZ/0pAjQhL0InTiRoUwCJxOFdR1V12B9h4z/OvagVjKP2bhMYNwit +oSZewC9QfeHVi8KfcQZ79pmL9EU88+32m4iz+0yVZmEiq8NGqmrf/aeBKNU+o10LfEr SBpE3KgDBjXVR64e2DZm/hsL+HL8Bc/54b3djzKRyc2pqRs7yJBdmdcXSOSv6zWMyFsW QzoA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=Go89cX19; 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 i188si143936pgc.177.2018.01.15.10.14.51; Mon, 15 Jan 2018 10:14:51 -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=Go89cX19; 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 S1751453AbeAOSOu (ORCPT + 28 others); Mon, 15 Jan 2018 13:14:50 -0500 Received: from mail-it0-f67.google.com ([209.85.214.67]:42838 "EHLO mail-it0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751290AbeAOSNd (ORCPT ); Mon, 15 Jan 2018 13:13:33 -0500 Received: by mail-it0-f67.google.com with SMTP id p139so1859249itb.1 for ; Mon, 15 Jan 2018 10:13:33 -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=Go89cX19gll9C/AECVZZU910ecuesEM5nQDkxfup1Q14YMlkhBDkrHDaRJufNCm31Z z/LDzru29K70cB9/mw50Kg4of5f+LsgJ8IBYpEt5itvWngRvfi1KyvBhvc3ERi8Oxf53 DVbCAkvxhhLLuRzsi1ZY2WmZhRIQ/F14Uy6Zs= 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=rang13WamvxUnWSEkKP9/RtOcNbbsisYZnuYt/vyQ/K/1pdW+b/oPGuzBKbCRuG6bj S1X6HTD2T4rKCHbJ+EqAiFyRm4Nim/pM6b+IlRzOt+sWp0v49gxBa62ZVKaVEc5xgTgQ g+mOMhHXooFHxjupUYGR0zFxsFCab5bZtlXnYEYk+RG7h4H/ISuh1HLaXNAJRJyYGpgq Gb2/g2Y7HHafqcZIYm0cwOW+JhcQOzRixyTeQtDrJnUYmTGQf5QBqrqUY73knvy2dMVe RelapcSb8BlzPqQwkITmisohffdFrxV8ijAgMWapOWhZfCoiiCol/rY6i+Q0qjmwdNyG QKpg== X-Gm-Message-State: AKwxytcThBDRwBCCviXXHsnXMh0ALGUcp9QKL38V93IbzQvSR2jaIxbC 4J5Qmb+FjMErYPd02rPJFTL2CP6q2hA= X-Received: by 10.36.83.21 with SMTP id n21mr15633502itb.74.1516040013026; Mon, 15 Jan 2018 10:13:33 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id w142sm231480ita.25.2018.01.15.10.13.30 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 15 Jan 2018 10:13:31 -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, jolsa@redhat.com, kim.phillips@arm.com, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v2 07/10] pert tools: Add queue management functionality Date: Mon, 15 Jan 2018 11:13:11 -0700 Message-Id: <1516039994-314-8-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516039994-314-1-git-send-email-mathieu.poirier@linaro.org> References: <1516039994-314-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 Mon Jan 15 18:13:12 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124549 Delivered-To: patch@linaro.org Received: by 10.46.64.148 with SMTP id r20csp751872lje; Mon, 15 Jan 2018 10:13:44 -0800 (PST) X-Google-Smtp-Source: ACJfBouI98rM/wYlr6Hd+ISD2oRnrwPId4WFBkFqajEtGENEDE/drrsgx827HCydCOVR/KFxNbts X-Received: by 10.99.114.23 with SMTP id n23mr21497229pgc.407.1516040024141; Mon, 15 Jan 2018 10:13:44 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516040024; cv=none; d=google.com; s=arc-20160816; b=v5Y/4apmkFbcJIv6MaxziFwZ/rdhsDb3tfT54lYa1YNEs9BhNq8Uy1TPgEVYkxjOgb 3zgwuuDGImVA5sjTT/7A6OMi5zzxlghaZ5zdosG2ev18DG/RCx5s+5ioXie/LWtr2/kk SJeKmDsKg/FgQ/51ye99Mmeh73fWDzUq8fOWWmy3KbQPiU6uJyCtMshazuY0bOfQyAb0 GX5BmBBUgAcGU0P3hquxd7KJNTnTGLtFJx5P6aworTLf+VNYuocwOipJgXvpIzJ+pUSU EKV26YPzGfm0rW0cQJU+2yrcfpg7MR4ltjNXsdctMPKhLVgXm9LGGtiNQTt8kEsHF+LJ hMyA== 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=WIHEydR7JV2IaSN+nz67R1TH/iols02OeyIZoesmEa7rtaY6VY3A3KLmpC42YpZO67 jCFy3XUFZaR51E/9hWx1+9pMBglC/G9yG7UwtbBTcFnA4gvzQWFpW6tCV5PFPcuxYjRD lzNb6xJqisp3pP58Z1tHrogzt1AYJ9x6agLv1YCn1JTFrDizahgrW9p7ot7+1Q8DEdGU O8Rin/3gmNY3Fhm8RDMdXiqdEJYWYX3Ykq2xvnhtEeIawbIdTLtvN37b/jddQyJT5nNG PGcnJ4WOC62tNDPDKSR24kGPRAFhu7SHXyElpq9ctf/itQeU4B5g3AeG+oyqqqvPmJsE tQlA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=DlfDoBU2; 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 l59si146420plb.743.2018.01.15.10.13.43; Mon, 15 Jan 2018 10:13:44 -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=DlfDoBU2; 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 S1751356AbeAOSNl (ORCPT + 28 others); Mon, 15 Jan 2018 13:13:41 -0500 Received: from mail-it0-f66.google.com ([209.85.214.66]:42849 "EHLO mail-it0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751309AbeAOSNg (ORCPT ); Mon, 15 Jan 2018 13:13:36 -0500 Received: by mail-it0-f66.google.com with SMTP id p139so1859364itb.1 for ; Mon, 15 Jan 2018 10:13:35 -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=DlfDoBU2kp+0WmYx3iHVqDT7ETkglPrMdreIQ4VGITjus3YI78YXDfsq1tSJuFD+nn fGnNdIyonGEyAbej+47BEp7t+heFxHslHsv/nf1NM2EgDNtzyL9yHXQ2JmQyktOy0k4y vZT3HjVXdPsRe/ocfhKzGtD4HxI2pwRGBjAok= 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=k6Okl0kEJ6SMbPY0kF9Q3Mf/qRdf+7eZ0jtHhE2t83qkUMCZ1ixVo66d1VDQRZvAQE xagv78kVzdtDSDf+L+YPpcZBJ2LCJoTfI7Xjutx7IxbUt8ovaP4cpGuiw5p2ZbBqHc0k 3lEGZaLxKlrRi3dj1ZJVftu+rxjZzqvnXABxlwEzNmNcefI9uerznLjJ73LXA+40J+JA hyvRQz0B4DoUXGW43K5NJjzzdX8pHZtF9MG9UBBYCNU68ttTwnsiZVMgCID2618E/eiG a2FCxJUsF+HwdYpPUgcAlmA078JE7rxUGrlloSQE1MU4hOipr5Qz+vrT2THJ3OzkxXLk omsA== X-Gm-Message-State: AKwxytcRN/eVX76B39PjWItZT1uzG+QKDjhrQ+02nIwU5c+W5UkcapK/ ImI6aYF9EcvtjbYzMJu52013mw== X-Received: by 10.36.104.148 with SMTP id v142mr15873661itb.76.1516040015266; Mon, 15 Jan 2018 10:13:35 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id w142sm231480ita.25.2018.01.15.10.13.33 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 15 Jan 2018 10:13:34 -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, jolsa@redhat.com, kim.phillips@arm.com, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v2 08/10] perf tools: Add full support for CoreSight trace decoding Date: Mon, 15 Jan 2018 11:13:12 -0700 Message-Id: <1516039994-314-9-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516039994-314-1-git-send-email-mathieu.poirier@linaro.org> References: <1516039994-314-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 Mon Jan 15 18:13:13 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124551 Delivered-To: patch@linaro.org Received: by 10.46.64.148 with SMTP id r20csp752000lje; Mon, 15 Jan 2018 10:14:15 -0800 (PST) X-Google-Smtp-Source: ACJfBoteRrDMexkRJ02FykkHVQiifYUZfQvm0b1BOaqcrc0YWeZ4rrxXd6dZ7iEjG0UZOCCJfS4P X-Received: by 10.84.248.68 with SMTP id e4mr36103707pln.296.1516040055014; Mon, 15 Jan 2018 10:14:15 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516040055; cv=none; d=google.com; s=arc-20160816; b=jIm5vSGX5x8nGttx4fudpDxgnqUbkur88S+aT1l/Yj8M5PDfw1/s8prKC/U4zBtM5z 5nKFQ0IIR63FSVDH11ir5SEaz5EgaBsUZnwBBOZvrQtANjmc9madSy/Vf0vA9Sj/733v rwJi1Sj1nHrDpTSCCO9oLxWwzByixicWAJsq8zC3ID68C2D/sn8SUz+qS8Jclhrrg61T LeJq5xjkXBotOj3rrXTj8tRKIe0u55FEhPwqxeikysTWzuSYv5uZy0dfrvIJzrAWeYLn 5ZyiitU1RvxW9YaS9ClPMXNxYBfQfBkNgSwc303N86YfHfKqQKUIjOkn/8CddPOwo84B tP3A== 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=TIER86s3k+tG66RKr82lEoZQLx3IsQfH5BHkOG9u09WRTmgfZKFiPKHs5l3RBF/zGO F2OB8m4AGYTzvuphzo+7s9/ATDWDwKi2tGeVXaxcTKtcl/RjB9d2H/JwQSnMFQSz6cUr fk+Zc8JyeQLbRqxOBARNWRTvsogg+pT9AqMbfGvmOmRBLGl625H2BbW8Sy2I9r/OXAl9 vLUBnZ+5VlHjA0zuMT96MtAW441QiQdKt3cFNexndOAdCuN1/v62tK2wuUTyGH14buL5 weFg7Lp/pcJ6W5b4YBeRK5aeS7qYR7bmUXYFTuKuz6GsyvcZwvm71E7kZwHVJba2mLmb /lBQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=Ezer++od; 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 v8si135030pgt.503.2018.01.15.10.14.14; Mon, 15 Jan 2018 10:14:14 -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=Ezer++od; 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 S1751398AbeAOSON (ORCPT + 28 others); Mon, 15 Jan 2018 13:14:13 -0500 Received: from mail-io0-f175.google.com ([209.85.223.175]:41938 "EHLO mail-io0-f175.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750798AbeAOSNi (ORCPT ); Mon, 15 Jan 2018 13:13:38 -0500 Received: by mail-io0-f175.google.com with SMTP id f6so13955544ioh.8 for ; Mon, 15 Jan 2018 10:13:37 -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=Ezer++odgTbn2GqX1jtm4s6zxTmcBO0Uvtz+2B8tZKPzmBrc7vTkJUAubUupn+HsTI JvHIIWKfb9KEtHMNb6LOOPw1+dAz7WSBUplVJggDsOjU/Ydax2623LceRmHUBwDJLrEZ Wkj3W0sNLpq3KYi7nVfCtOjB1BG0LmfE2TotY= 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=sYjv4pTOggDIrvK0sjQNDrlupZEpUuGX55uiMdzUwlxS4ZfhOY/HqgbLsRIX3H13hq 0YwyXx84EolB6m1Cq3FXKxdVYTcBJEw8R0L5UY1fYyWvC9fACVRrb06a17nopnoPc9iG ajG5itkI5KEAmGC2AaWnpMaUVKiii+FMsufZsuJxgA+MUiWP+yEHet4ECVp5HrRSolN0 qT7xXxFiJTTZVlOErs7xUXgOf3cyZZqJsPgJoESX5KZ8wHpeB5oCdofZXwff5j1p6HqA aETITeKLPEMgnY1UB9yqgrBNDEbJeqlmM5X2ABntFNX+czVer1qbGnsTRyrCUys1+r77 jPQA== X-Gm-Message-State: AKwxytelTByThKEIx+K3ywkF7RhcREjINHBJQrKw2PtLuFODKeHCiwi3 r3VLbqJxcRRuU+Wr2EQfbew12w== X-Received: by 10.107.8.25 with SMTP id 25mr4586839ioi.167.1516040017556; Mon, 15 Jan 2018 10:13:37 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id w142sm231480ita.25.2018.01.15.10.13.35 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 15 Jan 2018 10:13:36 -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, jolsa@redhat.com, kim.phillips@arm.com, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v2 09/10] perf tools: Add mechanic to synthesise CoreSight trace packets Date: Mon, 15 Jan 2018 11:13:13 -0700 Message-Id: <1516039994-314-10-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516039994-314-1-git-send-email-mathieu.poirier@linaro.org> References: <1516039994-314-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 Mon Jan 15 18:13:14 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124550 Delivered-To: patch@linaro.org Received: by 10.46.64.148 with SMTP id r20csp751906lje; Mon, 15 Jan 2018 10:13:54 -0800 (PST) X-Google-Smtp-Source: ACJfBourK+rBpM6jCWQBFbP7q8veCOQLjYeKF5vmcaZQSpRrDIdtEw43sI8MoNfz7rXfYdkgar6d X-Received: by 10.159.202.138 with SMTP id p10mr4528229plo.261.1516040034134; Mon, 15 Jan 2018 10:13:54 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516040034; cv=none; d=google.com; s=arc-20160816; b=vqQNnsIl3ebPou7CN4UdmbLdZNz1Z9Hd44RXZlcdVfUC3Kv1rhJzOhbqpZ6Gvr7tDr cMy1++HGrF3l2VXAgxeDytBQsGafywh2p4MnDI0SPRUHufrJUJxMkwlQknGsVRZW+QXI qyHJMPiLZoniKHFU/mSFC8tc3LmEpLdsOyD4qWsqvp6DU8sbxbO6ndSBnG7JpHpiGoYQ Lq/dP9y4U1x+XlJM4MIzLKAt4H70gZcrwHyZt8aP9NazO7oRPZ9QODIaNbHwbx2siKV8 0eaEDarewh6ybvfVQFxiNflzMccOY5kLBkj7w1etfuA/3Fl0K+XtvFJR1yL3pJi5QlyF DhrA== 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=prwAdALN/BO7JNlBVvNKnIvxwS2kU5wCKG7NlyQdGno=; b=B0ugCfiICuGD0xDnsN2bEMGso6zvSJMeLYNkrEIYBGF2xh1iT24VrVL803xPaw7w8q /Hn1iIDX8JOqaBZmAlMEpefF/n2VsNXR1ml9Si3G2ocodlCqLGvloLzq0ffrrU9Ss1Lk Dvwhewz4RWk+yptmu/G6A33ptyDV5mrT8yRt7OnLSPIlSztGdajmlTjZ7cKcXF9bvXMd rHQDIthg0da52fDeyxrW9jYMiBftQ6iuk9C3Y8eiJm4SUJHjuruKRQYXDvXmnarBjqL8 aiBob5a6H+/q4c80GuWal7GKjFO644D/vWRgC6iyI4fCXx7Q91BuagbBorfG9XRJnCur 9AFQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=SkUs7HYN; 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 b34si175645plc.54.2018.01.15.10.13.53; Mon, 15 Jan 2018 10:13: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=SkUs7HYN; 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 S1751391AbeAOSNw (ORCPT + 28 others); Mon, 15 Jan 2018 13:13:52 -0500 Received: from mail-io0-f195.google.com ([209.85.223.195]:39464 "EHLO mail-io0-f195.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751085AbeAOSNk (ORCPT ); Mon, 15 Jan 2018 13:13:40 -0500 Received: by mail-io0-f195.google.com with SMTP id b198so11289232iof.6 for ; Mon, 15 Jan 2018 10:13:40 -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=prwAdALN/BO7JNlBVvNKnIvxwS2kU5wCKG7NlyQdGno=; b=SkUs7HYNMl0j4Gv3mnIQXs0Uc71gEmfTBoPGuqIzqHt/LOHMN7dgAnugQJNFtU0pUb J6W51laEEIJ/iqLZqFDLJ//EvHUG3c4GwhnflDfGbriIMRmeCkggnCrkzTxEDk2ZAMSM lBVkEI2Yh6ZJVNraT6Y/63X32slSqXZLWpo+Y= 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=prwAdALN/BO7JNlBVvNKnIvxwS2kU5wCKG7NlyQdGno=; b=koErq3jdLoCiIQnvkl490pZsMEnYcpTYIm6nvfL+s0AoJh3zH/9/wp8IQS0IqkDVcR 6QlEG9GY0y70/EpPtXY8+h5BsOzBmBe67lLFNNs93hUDRgD6KIND7wX/SfMVSheVnNvi 8JkHeBTS/G/8o1wpiUzF8pk+N8kVrwdVm7etvQqE/h+o+1/9oh2nKwvU/A3h3u/kaInE bcHj2CpIKxZCB+FoLObFX4IoHH1Ue0haQH4NOI84Zz3RfdrEmkbKLeHCade31YAHSXhz dJBqgBmJpP1mcW4xBpybUtEpcCK3e89hfw4NziB/bXV3AxGEALjxt2lQymR/6aAyvLyT WknA== X-Gm-Message-State: AKwxytdynMkHwmeCcReF3P8szTot7mrmV0td4IaVGFQf4I4qxARs9yS/ sk0Wi79a2oI0JuygU7NNApf6Ag== X-Received: by 10.107.170.142 with SMTP id g14mr11208187ioj.22.1516040019650; Mon, 15 Jan 2018 10:13:39 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id w142sm231480ita.25.2018.01.15.10.13.37 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 15 Jan 2018 10:13:38 -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, jolsa@redhat.com, kim.phillips@arm.com, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v2 10/10] MAINTAINERS: Adding entry for CoreSight trace decoding Date: Mon, 15 Jan 2018 11:13:14 -0700 Message-Id: <1516039994-314-11-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516039994-314-1-git-send-email-mathieu.poirier@linaro.org> References: <1516039994-314-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 95c3fa1f520f..ca333cfce97f 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