From patchwork Wed Jan 17 17:52: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: 124901 Delivered-To: patch@linaro.org Received: by 10.46.62.1 with SMTP id l1csp132185lja; Wed, 17 Jan 2018 09:54:51 -0800 (PST) X-Google-Smtp-Source: ACJfBovPIVFP3y77mNdrjwFqO0yivIQahwm1Rgz6/qSzAAvBcalpCFe15hW32NTI7u4lvFHwT+yO X-Received: by 10.98.107.71 with SMTP id g68mr16278609pfc.96.1516211691174; Wed, 17 Jan 2018 09:54:51 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516211691; cv=none; d=google.com; s=arc-20160816; b=mnflZRr1MwzbRwXcZlV5rAUIS6ltY4LIN4G8Sr60jMUgq67bLdBVsCfdDH+n/+YQki P3r8MWZ4BI4Z9AUbsjGXUYPc+xK3w6w+W3/3qtw3zM51SF4qt7M8GTRQaG6r2Dqp7tQW K4pkgmLJJ1zOKCCVQCpmFgmK/slsyVwi56zzt3MGLdnn7L8rHmE3x1kez7OOU6RB4vjD JdBCIhJFJ4JJWi2PDIApP6FFW4eYMqbDALIhJ1DqdryLbpiu3yTWMNVn53BVjkgOrreL lvJMODxu3AzeVSa3gQJxz/rEPoFKzfNSvundfERkOPEFcNTT+aozv5T1lnH6f5aq5/19 EV1w== 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=Yhw3DrebPPpm6qW/sB4u+tJBc4LEz89K65qZ47eikhw=; b=I1NHn80QEElQTQXpr3Rl4EMUZx2nAuFSvJMJJSRoGMla5osPNFb4G8o178+QwlIGvP WUQDnVgXZUITx/3R/1+tSHUrTZ3fNbo7OHP4aQJ9BOEuGKsn/epyjIqe+2vVAZYVxV3k 5z6bTej+sO4foufYFgyH+4AvIQt8cQ4RgmcbxICu/VmJabkOsAG47N/3XogIpn0rN2G3 eScYcPrBX0LGehgjaF2LMhJE3J0aVATHRed7jBTcUYIhppkdIyg/nUp1M0n3/04dGpNy Ar11APnCqZRuHe9NjLpC86w1+xieTS/J+hgU8A1AARajZQVgSbWIR8AkNNo8zdK7I99A QB0w== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=EGedUN2l; 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 h1si4588318pfg.412.2018.01.17.09.54.50; Wed, 17 Jan 2018 09:54: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=EGedUN2l; 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 S1754641AbeAQRyt (ORCPT + 28 others); Wed, 17 Jan 2018 12:54:49 -0500 Received: from mail-it0-f66.google.com ([209.85.214.66]:40260 "EHLO mail-it0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754278AbeAQRw0 (ORCPT ); Wed, 17 Jan 2018 12:52:26 -0500 Received: by mail-it0-f66.google.com with SMTP id 196so10239688iti.5 for ; Wed, 17 Jan 2018 09:52:25 -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=Yhw3DrebPPpm6qW/sB4u+tJBc4LEz89K65qZ47eikhw=; b=EGedUN2luWnwfswL/wTHQj4AfL6LPoXy/cKOHSQagqSo3lEgb/+x1yCrUsUWMc2/mg mYY8L9Eqk45t7ZnJN4yFGfKrgMrSPNT6ZDVrP70F0mHBom+xSyjuRVSaSEgFNgSNzZON sykJCnWjtR5BdJ8x+PoQ/xYUn3JA9AnPl2+Y4= 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=Yhw3DrebPPpm6qW/sB4u+tJBc4LEz89K65qZ47eikhw=; b=Sdv5RZcitoI6CvN0OfBIw7HKlKPwm8USeZtozxkNQepUyB1njCLCRvHLAOqDISHgGg LRNMmoDla0M6ODrNcB80Z6W0APt+o7yUEBdc3MKXZLnQmkb7g4LA+C7nCBXi/dDAlzeq G7cKqvwwPPhvl4R2dp1/L0re4CxMydLXhJuFKQlnt0tvq3ApIhr+nX6XanZs4aNSQ9eW jiRlhz71o13cyBgtgtVdFjoMzgazBOdSq2Y+pLkihiGGNKHbt34IvHJ2w1mxt/VZwzcp G0eSQUC1PEoKt/x7/UvMk2VBdPHPjTNRR18/sCzEN24Qoa3BhjNmeDevxtA+ajxgfwmd OcVA== X-Gm-Message-State: AKwxytd5lwUtsYctdh7o5ZWmszOC5qGwtcqewqMYGLY1Y7Jea8ulWMvf FNHnPajG63UWOuo3WELauL2JgQ== X-Received: by 10.36.146.196 with SMTP id l187mr14365805itd.115.1516211545219; Wed, 17 Jan 2018 09:52:25 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id h72sm2694392ioe.61.2018.01.17.09.52.22 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 17 Jan 2018 09:52: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 v3 01/10] perf tools: Integrating the CoreSight decoding library Date: Wed, 17 Jan 2018 10:52:10 -0700 Message-Id: <1516211539-5166-2-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516211539-5166-1-git-send-email-mathieu.poirier@linaro.org> References: <1516211539-5166-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 | 3 ++- tools/build/feature/Makefile | 7 ++++++- tools/build/feature/test-all.c | 5 +++++ tools/perf/Makefile.config | 25 +++++++++++++++++++++++++ tools/perf/Makefile.perf | 2 ++ 5 files changed, 40 insertions(+), 2 deletions(-) -- 2.7.4 diff --git a/tools/build/Makefile.feature b/tools/build/Makefile.feature index e52fcefee379..c378f003b007 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 diff --git a/tools/build/feature/Makefile b/tools/build/feature/Makefile index cff38f342283..59585fe20221 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..8dc20a61341f 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_libopencsd +# 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/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 Wed Jan 17 17:52: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: 124892 Delivered-To: patch@linaro.org Received: by 10.46.62.1 with SMTP id l1csp131517lja; Wed, 17 Jan 2018 09:52:35 -0800 (PST) X-Google-Smtp-Source: ACJfBosaXjN6kXAbPHULga2qcRkMrzXUhysWFy8NXmk0CgI4uDC8ZS78iRGf7bjRH3DRfzBBzFRB X-Received: by 10.84.232.197 with SMTP id x5mr34648376plm.80.1516211555098; Wed, 17 Jan 2018 09:52:35 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516211555; cv=none; d=google.com; s=arc-20160816; b=GNbUAsk0t/P6XfTVb4YYp+t469WrcsKrtsL2CQDdTr015Lm8KHKq1/zZGdbrHiqXaD zyDED+/A1dozWKbwpBMy7GrzKeLbUqCwq82JpPWcf+tbpczxT8yOIUfRwbOYY1S9XS6K 3Yyd0cBQYyv1ty/TmVbnSC5S0hsVH0rbKe/TSAnOs8rC4r6q8v1p/rmBgpA6tLvJ2QNp 9ylWL/wmV+ZnaOpOwhjNgvIRe+1EEwKdj3ZmZHx5tedgVMBo/FzePO407Wv7WnSbqw/Z sWMBbFMF3KQ1DL2VDn+iGWeIZ1SaE7m9Z4tnj8u5dw59Z2sfjErlf14G+kjQ3k4k8RRV Nctg== 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=jrzxqZ/vaIRRKLo9gqxU7RScqPIzWOmNeRD2bUaf8XB4iCN1U/faUTpUb/eGi3viJm sxlWkun/63Ys6VZp9flOeWeHNAjdRgrrqodi1TFRJRKrB1+C3g8Zh0a1d0o7d5TS5H6B zQETUlei4rfhgrXk/AeZlmf3YCek6ZHe+XbZ6uypjuf4dK0VNK+abN3GV3QfXL5NTLQY mFzaE+3cy0HwDQB93JWBwCp3L1rY0vvoY7ImSK6DqLJ1YGcFD2vGBHBIv7BNklM2gVEQ DraFdL0nW+lwntNmIeoKe8ifDan/At/joyOpDIYPlNmkKrzSdEYxXNKkUoR9/zJx+Yaw Zl3g== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=M/9VREXP; 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 i1si4268715pgo.426.2018.01.17.09.52.34; Wed, 17 Jan 2018 09:52: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=M/9VREXP; 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 S1754363AbeAQRwc (ORCPT + 28 others); Wed, 17 Jan 2018 12:52:32 -0500 Received: from mail-it0-f66.google.com ([209.85.214.66]:37212 "EHLO mail-it0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754220AbeAQRw2 (ORCPT ); Wed, 17 Jan 2018 12:52:28 -0500 Received: by mail-it0-f66.google.com with SMTP id q8so10258627itb.2 for ; Wed, 17 Jan 2018 09:52: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=k+GfMYH3HvMObLImuNj88koUwUW6expwSPiPS5VgS0M=; b=M/9VREXPnIid6/YRjwBVYaoYR7Umhd+Lw/QnrTVP8UjRmgD6ZT8j9JoEWcR5B1OcFP +H99xklirmQ+tx4VSW+bO/i0FVU/klATyG6oyZ4VjYq8wy8cWPuhMogcCgqPPCOA/pMm yHsPlc96vyUrWqo3Wre0/e3nh89pkq3GQ3ucs= 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=WKnddbyXrvR5wOZFLpLVPb8XynKk5M6ZS7I4g2BMjtGDfaSu9xq/cgw/aHxng8+CXQ QC9mmmmY+UL3Bn/mmxG8Q6Awh0Fu0H9JiddWGEqTckM5cKCpGVkaZZJnPD3PRBDnFRhc zL/C18vDPmr4OQYzRJsaKK7fWTgo6jbq+1idZxpJSY/xV3OLR+XSf2ElRLLAmSEPjRtw 0Hw22EzwLopAErvDBDtQ12kJBnKxAB9/UmxLVF8cQvso1gjaEKcplcDHugci+iFuhoOh KNJ9e3TeHeqRr6CEmrPigtmo43UOy+q0od/GkiTLC/O+z7Kz4FanbglO/oz07zvFJ9QU k6qQ== X-Gm-Message-State: AKwxytfYJbdA2D9Xs/aqc48g9VC/jIuCPpuh/xyHUKktXA/U57nbbX+M CTQzgvgSiO8za0J6cPiW3EZbew== X-Received: by 10.36.77.139 with SMTP id l133mr22008376itb.52.1516211547629; Wed, 17 Jan 2018 09:52:27 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id h72sm2694392ioe.61.2018.01.17.09.52.25 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 17 Jan 2018 09:52:26 -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 v3 02/10] perf tools: Add initial entry point for decoder CoreSight traces Date: Wed, 17 Jan 2018 10:52:11 -0700 Message-Id: <1516211539-5166-3-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516211539-5166-1-git-send-email-mathieu.poirier@linaro.org> References: <1516211539-5166-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 Wed Jan 17 17:52: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: 124900 Delivered-To: patch@linaro.org Received: by 10.46.62.1 with SMTP id l1csp132182lja; Wed, 17 Jan 2018 09:54:50 -0800 (PST) X-Google-Smtp-Source: ACJfBouMQE6WsNLU/Sk7b4h9PTlmwvH5AM5eHOSaAzP80wGeg3HZy7n7NC/yUHrB8OY507rB/kQZ X-Received: by 10.98.215.30 with SMTP id b30mr19120184pfh.50.1516211690749; Wed, 17 Jan 2018 09:54:50 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516211690; cv=none; d=google.com; s=arc-20160816; b=km94ZXRdiWBPZkabfZGo8w32ffOdZ43LU6eqCSHHVLJgCqCvq5yRtknTQdi931YxFd efK+39zUDLoeKUhAkQ4NyenooFJhkdAhvApBoOTzwncgti6dA7N57hjfOGZVd7pGsEYC Vwc4DWlsdO+V+0Xn3hCvduNKJy458n5nl7qMCDriH4wbc6/KnAWehtvV912HkbYz5qOQ c/4VcD8Q5sQMqthtPTOSW4AjG5P5R597IAfrwn0wOa12WFH4Zl7NsFhkEBVmgj0rKwpA SAa91mw7OmPR1bwXwdBAdn2rJFn1ojvYKObiITO6eEy2nm3pywTXUehwbwYfX01G9/s0 KHYw== 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=ABxgMtvF5t8LizemyJBMapytB5yXX/USKy/Jpj6hPvKG+RIynqz7T04L7UiwAm7ilH ejSD0MI/ekhIjnr+rzkRXMYVCm50Gkckm113C7Az1RJuSECv7HUzXB2CBnz9HldIojIT Hjju/YJBmopyA3Fn5d2Te6DekSjh5146fR/yivdD+oyY7cGh1N1lR06IQqXznE+6QxVY 81nV26oYc4lR3Nm1bRbNtMJgUYYwWiw9dK5hZUA9tSHyFosQsN4xVHoQjNskspJpIU/M 27xU2erVUGvsLo9Tnj48JFfBTZAE70T+23ubxblZLlWUDsShPPafkbur7693zmWybFV/ 1sNg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=j6tAKhDQ; 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 h1si4588318pfg.412.2018.01.17.09.54.50; Wed, 17 Jan 2018 09:54:50 -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=j6tAKhDQ; 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 S1754626AbeAQRyr (ORCPT + 28 others); Wed, 17 Jan 2018 12:54:47 -0500 Received: from mail-it0-f65.google.com ([209.85.214.65]:45153 "EHLO mail-it0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754316AbeAQRwa (ORCPT ); Wed, 17 Jan 2018 12:52:30 -0500 Received: by mail-it0-f65.google.com with SMTP id x42so10199472ita.4 for ; Wed, 17 Jan 2018 09:52:30 -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=j6tAKhDQV52HJBV7ionfSia9GLXxGrIpP928Pmo6r/e9Z72IFCZcK9fEqredrXH5+c Yq8uRYYPQEDnlOO6rnluMssjRSFITexUbrAqJ+ZDb95sme/hclcT291P+20pWrnsoGuo BqK7Orf7Dde4U3yVEuGKn70rL99GOBwESiZF4= 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=fM4sL52lA2JDwkxqB7dfKa6TjKoMDtR4OeVPwxsnbbl65BTct92Fz/Fd3xiY7tl5ru G2o1ScSOobnNhZ0JwCAEjsodFl2uf1T6BCUNzFlHGpT07hNgcJeOdUjpKjKfmBC4npMR gZ+P+u6Ar9X61DUWrETHrk0G9q4uZlJNqgjyvqnWhM4xkLHxUMIIhDutqPbPxgBQlAzE utG8ZAb1ibrz+VOnOE2cnFCxEqJCcicX6gn+o0M9rYSyjGPtiwZ3MSLimKfZ8CNOxerw Oxg2tTA0jYyAwJw8g4S/rd6q9orOE/sKKTXQRs6uYiiO5QrRzzrgdV1FxryY2sKukTAw El2Q== X-Gm-Message-State: AKwxytf6QOT+uVsOPSxX4dUU+1o3mw7Pw9LL2pigdXvC7ytWXrSvdgNl gv4oCF004nrrpjnRVgtdE9NY+A== X-Received: by 10.36.218.196 with SMTP id z187mr22633935itg.122.1516211550007; Wed, 17 Jan 2018 09:52:30 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id h72sm2694392ioe.61.2018.01.17.09.52.27 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 17 Jan 2018 09:52:28 -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 v3 03/10] perf tools: Add processing of coresight metadata Date: Wed, 17 Jan 2018 10:52:12 -0700 Message-Id: <1516211539-5166-4-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516211539-5166-1-git-send-email-mathieu.poirier@linaro.org> References: <1516211539-5166-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 Wed Jan 17 17:52: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: 124893 Delivered-To: patch@linaro.org Received: by 10.46.62.1 with SMTP id l1csp131556lja; Wed, 17 Jan 2018 09:52:42 -0800 (PST) X-Google-Smtp-Source: ACJfBoug3pPu81xDi3FLpW6Gih75PRylOnV6huD9uiBoqeefzbtxBm9LSblWQSbVs8lKpHkZapqG X-Received: by 10.84.194.195 with SMTP id h61mr650654pld.269.1516211562138; Wed, 17 Jan 2018 09:52:42 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516211562; cv=none; d=google.com; s=arc-20160816; b=q2kQ1BgHkm6MlC5D5KXBG5poklUBHuQxzJAh0+5notCAdyWhjR9ZMIQcSrbzZejKD5 uRGY1FTx51uZ8BPIpxUOmsEh0Jq1HMSTgHExBlhpRGvhC5T1DaK5E2DqkHL0vD+Sx/GU ycILpQhAyEP8q4/LEsBpbFxbqqpaHFNyPk6QrQadw3xpVdmLiQuWlwj376VIlrmt0yQY 4v4Ui48wsPkF7AnBNjXu/QHoj3VyTX1EvMynxDFO8euodrVY7+6JHMXOpB/VsvXJ/KMQ e9j5In+8mZGx051wKEeU7dhxuFqXloz5CgOrGafGko2FPFgyDTIsXFEDy+uDyAieRjHw rBpQ== 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=T+hA1nZgYU7qpu3L+HD2/D5iAm1Uky8Wcb5WhJLGRqXJFArlMN1kaVukKn9tLLVr+d NezmBLDUf57ErsoN5qhhnyB8R+cr2vR8bMT+P/W+dvpwchbd6eQfJm/LIsCApsUW9b1j bB1LcMPOKckZyc6gNhXW6JlhjIdcaGpzoBbFsGRTr/Iy7dlfhW99wya2J+P0xUE0S6G2 yWbhqFHC6XPZUzsXaeg9l07PlMuIMqseU26QsWtcs02bizIFTchRBluFf4UoFNZF8KmB wqx4fXmiwnhkZh1Dk+68dOt+xFu/gIFuCTXMln+ILiSR1PcWL0H4hfFN5vM74lFp+60C 0oMA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=f/9ea9U+; 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 y7si5083763plh.84.2018.01.17.09.52.41; Wed, 17 Jan 2018 09:52:42 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=f/9ea9U+; 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 S1754433AbeAQRwh (ORCPT + 28 others); Wed, 17 Jan 2018 12:52:37 -0500 Received: from mail-io0-f193.google.com ([209.85.223.193]:36368 "EHLO mail-io0-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754220AbeAQRwd (ORCPT ); Wed, 17 Jan 2018 12:52:33 -0500 Received: by mail-io0-f193.google.com with SMTP id l17so11894374ioc.3 for ; Wed, 17 Jan 2018 09:52:32 -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=f/9ea9U+fXHWwzW+IQzX9TrTJNjmeO0xC0hF7N+y6nHE/v7kGqKLHuuw/33ke3DQqg /HvdcH60fwAyN46jeXzyjVN6Kk37/4vWiQ7E6/auokudRPBwiX5bbXdBP3sw9jBVvUMB QKP/Dd65lvEaqLNf4HoKDjuJ6lfGYQ4rzz8h8= 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=Hufj1COFsYMaS0ErRizMe9UnHBizyFeXWKSFVhA6BlYU+vIkReFezlX+G8OJy4eudq u4C0eSoP1o0QHVYJf+drvlnr0HUaqXO/yGKH4bO67mK49e74XJZsG7/pFwPlhQpEpgK8 UHZOUtaWAASeIRhmCdgu0PshPOWUgkVsooQAVlW5hOt9Ci7mOjjTKFb9wwNWQGAoV0nf 4zrE+QtFDoo+MAjqNNp60v8YYC6uaVl5sPhawkhe4AT75RzMSccpqbriaOsGeSDavnGW LBowpvXuL9rzBbqPIRmFMOFDY8fDT1+jja3x3V5lNuVHniYrHsrf+AinSRWYzet89SyG di5g== X-Gm-Message-State: AKwxytc03VIFb2txdIQnASJD9kUVba+uf3/trJDspk1S+zmXTyh2UNvi EXjOBdCj2g1iqB7VKajvPG2uNg== X-Received: by 10.107.36.77 with SMTP id k74mr43154329iok.19.1516211552341; Wed, 17 Jan 2018 09:52:32 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id h72sm2694392ioe.61.2018.01.17.09.52.30 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 17 Jan 2018 09:52: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 v3 04/10] perf tools: Add decoder mechanic to support dumping trace data Date: Wed, 17 Jan 2018 10:52:13 -0700 Message-Id: <1516211539-5166-5-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516211539-5166-1-git-send-email-mathieu.poirier@linaro.org> References: <1516211539-5166-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 Wed Jan 17 17:52: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: 124899 Delivered-To: patch@linaro.org Received: by 10.46.62.1 with SMTP id l1csp132080lja; Wed, 17 Jan 2018 09:54:28 -0800 (PST) X-Google-Smtp-Source: ACJfBose7t8KlZzcyv2ET2IaWaigrYDwen+r0tvZpKLI9sq6e7Qrn9WUqf7Rn4IswcsszP0l3oQ5 X-Received: by 10.98.91.193 with SMTP id p184mr38714661pfb.16.1516211668529; Wed, 17 Jan 2018 09:54:28 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516211668; cv=none; d=google.com; s=arc-20160816; b=wBzo/HXkvDj/8EBSJvgUV+FxFR4WwQ5imx2tT3syeUu0RSrO691MiZlZS8SEDzTHy+ HOPrt9fuDZwMMpomVc9xtDTEg3ykOzAwJ6wImWUO7Q2kqqiZcYMHDoSPO2egwUbFdRhI 0Yz7IEq+/va1cN11TgSySRGGYkwJpoH/W15+a8Gy5yzQQJXidENuahz/X/6o5KFgt/Xr nW8KH3D5DDU3N1gL+qFGNdq7Wsh8/s65nPry+hYm48ZoehfiS/yBR//VFnAoLIVnA4Mm 6HKtPv8M4/tasRw3J94oMA7AppuylUlUkBKC00hoiErP2DK9x78eSIAbuf5Ppexfj8jh 7jow== 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=ml/7DsdbbMCUqt+7JyRd8YNJdyY6ZQk0fwPkbRoodIfLTJ8dbblGBgEDuKmH6Po25s VwSV6LAT0dS/1MY4SZ+jJXXgk88YYkaTGYaZ8wx3z/EmTQ/PwIehUCCDnpwbN5PM0E2g s8u0gUFmAXz3/RBDfC5efTWGXsfexN39BWPOU9gggogViK6zNzxY1ZW+EuKXqW3udPAR MlEoQPd5dExKqgkqZ73wKUFKLmMl7/DpabqOIY7hEdAgK/iWrOh6BEMnMNYHoQEVXScg grT6CXvQlPL1JxAayxBfLx15tjly04xM2Pl3WHVU5q7ZhRpJOOBuKNvjc2Z4F/L2xb62 CAoA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=DOWC0VB3; 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 c24si4459941plo.608.2018.01.17.09.54.28; Wed, 17 Jan 2018 09:54:28 -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=DOWC0VB3; 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 S1754612AbeAQRy1 (ORCPT + 28 others); Wed, 17 Jan 2018 12:54:27 -0500 Received: from mail-io0-f193.google.com ([209.85.223.193]:37223 "EHLO mail-io0-f193.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754381AbeAQRwf (ORCPT ); Wed, 17 Jan 2018 12:52:35 -0500 Received: by mail-io0-f193.google.com with SMTP id f89so13722890ioj.4 for ; Wed, 17 Jan 2018 09:52: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=5jFdWvQHmBRzHkJxZHbVXWO2q05IMe9m2gaQjutTajQ=; b=DOWC0VB3Nyl+LlXVUWtDKW1wIy3cOw5pY0vpcB6JwInHcx6TX/1d0f+b0IvbEEy8qF jsAtqpYPV6jNqS44+ZG7NwGJs/jPKMqyLH2o4vK475Ta4cBRF0fehJ2WwMfBY4x8jKKL zC0dIZLWkaiQqd9/GMTfOoH/cCu70/gtiWzT4= 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=DaMeOLnmAu1pFkLKaDthssCS8TZyCNPuRENtud3xy5WY/loWnCHfj9hgCnnAyLx2LK BAPE7YDLZ0ilJguCplVm4d1s3X4d2+63OT3v91FGKS68K9Snf5MFV0BaIe/XQCVd0+5f AkMBHSoxyK4BnsaNfrZs+fFz4kR9QCKwWnkYyaEj2AXxbRRHTXQeuDRIJz8eGc/2jvsl iohcLAyRZ7ioC2j/UICc/BLMRVKPCHaFqL6OIW8N+9hAuNTH/9dVDSF2c1kM0jquYL+k lOZTvdEaCIzdzNFT44ICuMIJ+DT+2K6tJar8EQ1umQteM+w50xBrOMzvKZ/EYXERcNCC oG4w== X-Gm-Message-State: AKwxytdxOZmm5+2vKZOkDDdSiS6ijXYEhayLnoE1EXqSzYM6Xc8MqCD4 ETTq3GyXyq0I7xBstdMhI/3unw== X-Received: by 10.107.9.69 with SMTP id j66mr22528624ioi.91.1516211554768; Wed, 17 Jan 2018 09:52:34 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id h72sm2694392ioe.61.2018.01.17.09.52.32 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 17 Jan 2018 09:52:33 -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 v3 05/10] perf tools: Add support for decoding CoreSight trace data Date: Wed, 17 Jan 2018 10:52:14 -0700 Message-Id: <1516211539-5166-6-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516211539-5166-1-git-send-email-mathieu.poirier@linaro.org> References: <1516211539-5166-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 Wed Jan 17 17:52:15 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124894 Delivered-To: patch@linaro.org Received: by 10.46.62.1 with SMTP id l1csp131579lja; Wed, 17 Jan 2018 09:52:46 -0800 (PST) X-Google-Smtp-Source: ACJfBotjShv8oKeqrgq41OaJI9lSH2PS0EKues4ohf9O/l41NKvNBNDHSVP6Yjys/szsMfkXV3RF X-Received: by 10.99.120.203 with SMTP id t194mr7691079pgc.39.1516211566320; Wed, 17 Jan 2018 09:52:46 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516211566; cv=none; d=google.com; s=arc-20160816; b=f4um2GzfXy5EjR6i+iSslsORuXyrX+qAMkCUWvpHcyPGDTuvFZLHNy3/2Mfug0Ncb1 ja+l8TbBwGPK30it76gbr5Ge8EFr0pw7u6fII0CPiRoa3U8jh0Qc+pLNbm7qBneAeyA2 qZYYvsmEuO/RcbLANY0JJdcO2Vl7bjPXL2v6DU9aWXk0PXSxoOj3fHp7laXfLrzEPSHO B9LFM5ETHAXyo+UR+989n/aR4hu2hderurD8Lmf3eISfP6WLAEHAjx40aiOjA9yH3Crt APg3VvA+fEAhy6MEz2lFM8Oc2tJhGYgiyiRUSkAeTxS31+Aw0GN9K17To9TL/KWm5nwh OIBA== 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=ftsm+k3m4CVhL04P6fzJmkwYy+M2xUXq7EFCxHFnkTVrl3N3gSgG5O6WjXcXzbyai9 zSfcq91p7AdJOxISQKl1FyVqm5xgkIixbIP4HR6hZhLtv9mxKLc/YqykeVa6p2gh8Kxy fSypDdmP4YB53/Qe7rOKvdAHaoZ5ki7HC2zmG1f1lHOmccvqamCcyp7ImyhjF7/wEVJw qtPfVS4oOyGUyiyyQRUsH71qVOqBsUZPi0CTMsRBFNCRa5EfLyV2xKPDjTIb8jVfLA94 sbokpxfXld5cEyE5MClWZ8CKn1O+BN+ywW778kPiXDMapqF3n+Wq9xnYoqzv5bdCRbTY 1YvA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=RkYR82if; 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 m64si4278678pgm.88.2018.01.17.09.52.45; Wed, 17 Jan 2018 09:52:46 -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=RkYR82if; 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 S1754482AbeAQRwn (ORCPT + 28 others); Wed, 17 Jan 2018 12:52:43 -0500 Received: from mail-it0-f66.google.com ([209.85.214.66]:46934 "EHLO mail-it0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754432AbeAQRwi (ORCPT ); Wed, 17 Jan 2018 12:52:38 -0500 Received: by mail-it0-f66.google.com with SMTP id c16so10187451itc.5 for ; Wed, 17 Jan 2018 09:52: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=/ZMSClb7LNeJt9fnv4WSWglgut3CZtYd6v/jP/IUU9w=; b=RkYR82ifdLKCrUBQwY8ytfrBAjwoVSczG27OE51wfMHsTlthy/UvW+QmtzoYFpTlzS qAe41ThRxzwDBt8mxrbl4LWE0GDMUhwkkPTGv8blKiJMOn8hNl+34752ZmcCSpOzWonn 2sG9nWWVbkCAmu7crU6QrQekPWdNiY2asXKNI= 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=U31Zrn24Pf2FY7zdwDUruJ5kfEau1+V6z9Um74qpx1hsk58xCl9lEBJpZhgupozsfN 1fjTKYKK8ZeGlM5P1zKqtXOkWWeZPbl1rnTBFo4XBcU8jhy4+5Mr7/M7GeX1cFs5yrJn Q9xUHKbzYYIbgSF/9SPuJsgWlaf4qLUDYjDWt+ADp752NGtdDnLS0EVQ+CZPE64FjdpJ VaQ1t+SAQRJr4ahBC11ilaHHZy2YWxYyUW0ReJtqyTPVXnGVXu15MMt8uH7W+Jr8t9wz UbE8iJLaiJW/5OteK1WYAqAfkMwGpboftwNKi6CeHX7mVnLhI96ufB+OyEbID6LIwVpO MTBg== X-Gm-Message-State: AKwxytdt0qExkxxAKZV5LqmNRLH6x4w0Sfw1aC6c/pTyjxbJUR8yo2nT MeoKEUgCx4+T4Kj0fG5SruKxGixbNks= X-Received: by 10.36.118.77 with SMTP id z74mr22715404itb.37.1516211557215; Wed, 17 Jan 2018 09:52:37 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id h72sm2694392ioe.61.2018.01.17.09.52.34 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 17 Jan 2018 09:52: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 v3 06/10] perf tools: Add functionality to communicate with the openCSD decoder Date: Wed, 17 Jan 2018 10:52:15 -0700 Message-Id: <1516211539-5166-7-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516211539-5166-1-git-send-email-mathieu.poirier@linaro.org> References: <1516211539-5166-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 Wed Jan 17 17:52:16 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124898 Delivered-To: patch@linaro.org Received: by 10.46.62.1 with SMTP id l1csp131827lja; Wed, 17 Jan 2018 09:53:38 -0800 (PST) X-Google-Smtp-Source: ACJfBov17/4YUYGMUmCKCU9WrNplnUdZgGEwJNSlgE/xsIdPgccGiqPt8t2oveuN9a3l8wYsF3Rd X-Received: by 10.84.212.151 with SMTP id e23mr4058729pli.194.1516211618035; Wed, 17 Jan 2018 09:53:38 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516211618; cv=none; d=google.com; s=arc-20160816; b=zG0Mx4Bps/ug07D18eC7MupkMutjLjG1L1ZH37EkIZkv5Ag+Sm2WjdibGPTmiTrack 6BPadEKSV2ol0NMhHWe6vcnL7iP7/2bzvsYSOJXRlhsL8ZfcAQ+/kkRVZvHPPwUKgLmU d6xHsU+yddAPpZ+ASvi4xdqQpRYTkRMZBLuFXSRU9TTyYVND38ARj+B8vU12CfW/5AU6 d6f2sju+lbH90PCHYOeedtyKAwS37R7OvvTIcgWINgBhpDoj9x0Cj4R1+w1V4dHGcXtc x6B2tQx6FA8F1alk0gl0w5x/VL7gD56YuNjxuErbfDw829IRZzfeGDm6LZPd4I5zluqX IOYw== 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=oWQovt1RdfiatkntjgMIxvPyniYzV+JW7kryH5ShGdHp9bnxXCNd/JHwJKtq8F4HUf VN8nayExA7T9tsCKqUFNlbxveuCi4c/W8U6C5IpotO0MgBfsRbNcfaosMtiKuOwtfMPL SLpw7Md0uy4tWwpgEmH/WOziew/MC57xV6ddJqRyzmU2edQYaK/Zi1i/noKMmSQeApRl q7j5nJnEXSHgB4C5j2z4lbI4qD3YksyPwPx3DPht25aHAhp5hTmjoxdvUqitjZK7aiE+ ioa9QQFD2cb++vk6hui5UBS1IwMTU7a8Lm6EIkya9XDX2UMl8aIw0SoQXGdR7BNHapdY VIRg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=A9Azerqb; 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 p25si4350262pgn.288.2018.01.17.09.53.37; Wed, 17 Jan 2018 09:53:38 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=A9Azerqb; 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 S1754433AbeAQRxg (ORCPT + 28 others); Wed, 17 Jan 2018 12:53:36 -0500 Received: from mail-it0-f68.google.com ([209.85.214.68]:37252 "EHLO mail-it0-f68.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754431AbeAQRwk (ORCPT ); Wed, 17 Jan 2018 12:52:40 -0500 Received: by mail-it0-f68.google.com with SMTP id q8so10259339itb.2 for ; Wed, 17 Jan 2018 09:52:39 -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=A9Azerqbzc56O3jU5uHF4NpVDO0O3wTtpeTaadJl5RYFw05PeDUhqK4927cJS88Jfq O/7JHG6r/p4ia3RTQvmjzG153sBc/0438B/nMPRqOD5eDCkBIkt/VCmqqd7e+2Ol8XlR l9PdJGrw6sFiAtOIPKn7pFlBxjyXIHdebVsdk= 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=Tg2Gzlu6TL03oIAe1iLCZcUtbG/AwUmRd6h5krI9XboP3zgSjQksPc/gp4pkcd5Bja 7nLYsxDCD3/YR2RexywNynB6PwaewsF6kt+kFxl2MeC9NYeu7/vNq+mJZVXHbupCuhBN cdQXJw6NICOuhIo2LTyEACz7DRtSTy0lVjue2qqrQysaqprr/7NgxJlQxjWLWMKENmDW 1jB7JhF1Zk+gffb0c1y5FPE9S4IpKMbUWrXNqbYOjBL960YKsFsK5UdfY1LtSUfQ293G mdTwwNAV13nBApEz+B6nsq4WPfQAIhNTyP4G+f5dJSvvuWUbfzf0idkwDuS6Ww4VFOI4 afrw== X-Gm-Message-State: AKwxyte+sGUD7VxXobqSY5VR2xflfu1sTs7jMZ7gzNBH+JZ7jB4JNgbb sHnueLqM93JxBmA+e8utYsM79w== X-Received: by 10.36.73.102 with SMTP id z99mr25558679ita.72.1516211559387; Wed, 17 Jan 2018 09:52:39 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id h72sm2694392ioe.61.2018.01.17.09.52.37 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 17 Jan 2018 09:52: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 v3 07/10] pert tools: Add queue management functionality Date: Wed, 17 Jan 2018 10:52:16 -0700 Message-Id: <1516211539-5166-8-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516211539-5166-1-git-send-email-mathieu.poirier@linaro.org> References: <1516211539-5166-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 Wed Jan 17 17:52:17 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124897 Delivered-To: patch@linaro.org Received: by 10.46.62.1 with SMTP id l1csp131742lja; Wed, 17 Jan 2018 09:53:16 -0800 (PST) X-Google-Smtp-Source: ACJfBosJsGTlWTvFUc3aMVryump9lGuiaH0/vJdIfld4BqEzX5rvUsnsnexPIUPV2jBqG0G1m0Qg X-Received: by 10.84.179.129 with SMTP id b1mr8567117plc.20.1516211596730; Wed, 17 Jan 2018 09:53:16 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516211596; cv=none; d=google.com; s=arc-20160816; b=XnWGPPSoB76yrejb5aZaF6LVQOR1PqEXyuK2T9vEbNXyQf3MPn3a3NZmBCkouwNDbM MxPg3K4OiIxxOL5sG0ygZSk22OEP9EVDEzk2IrCNQM57TUeCAi5ZKxMsuIsKE5tsoGax 4mSrEQ2BWt9/KAsXlEU9B9bPIbT/TosxOfNHqVSrjglwDbPonr9B1JYBClEWwbL7nRr3 V9or1NTkV9Bd8FAEA1vVaQdYrPBeVeY3obCUguqVyWuFIkdAIXYZ12rE2RYGZpKSSFhT durrymtrPyqx6tTgod1WdpCkMl+w0VrFXyCgxXaeOTcF9Vw281Nk3bMvYtAqDARCleKk 0AqQ== 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=hkuL/zm5NT7NdRXctI+U2wkSzDPjwNiVSCUGrNkyh98sZEAk+Qtsu+/swXlsAkTCgs m8FTRKaQIHxWdAwvUwvAM1i0XjDUkeZwqLwyfdShJuhz/G+05t4EdHXhPNUwVAGoV9Hu p/yCE0l+DZeo3rldrpRtKBKfOGyhlsLB4M8AFibZirC8kvyfR4MLEZpj5EAXJ6QVp39b iqIu3bwiiYOIAmZTB9YnJSGwZmX0DZCMPzUFOuFKvwRO4rd+5zDyEhbXhCDxAxW5gvfZ 6bbJ0RYdpbpMsTXbZuG1dO9lE/hVZGANIDv1AGXW0KPM2akIqlQU6CCdf5h/YyelDLCu A8Zw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=ibq1n1j+; 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 t17si4625133plo.806.2018.01.17.09.53.16; Wed, 17 Jan 2018 09:53:16 -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=ibq1n1j+; 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 S1754540AbeAQRxP (ORCPT + 28 others); Wed, 17 Jan 2018 12:53:15 -0500 Received: from mail-it0-f65.google.com ([209.85.214.65]:40303 "EHLO mail-it0-f65.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754460AbeAQRwm (ORCPT ); Wed, 17 Jan 2018 12:52:42 -0500 Received: by mail-it0-f65.google.com with SMTP id 196so10240726iti.5 for ; Wed, 17 Jan 2018 09:52:42 -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=ibq1n1j+XyJ3hfhWuwHI9YrRd4vDZRXsdNNRMuJueUotIARv05MfiAVVhH4yHYs79b QQl+B1jlgMAXbIc2Rn+sW2psiWydIXwMqdDfRDJVFmCufzR/pUKPKYMzHpb3Xta862OB EFIIj5pxqzLDbwCv5UNMCv7qv2mhGWDASmtTg= 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=m1T/ZdhqbG81Y+B1mObTS3RJQFC2XziTuqoDFEmMuBJyy9351lyAWZhmu+5s/1nvhR wri042BKkirXZFi693UI8dmJeOkGc8Gf5q79osHxrYmU0I7qfmLLNTLjlLwjAIQUgkwL p7BFcCWFU64X3Vjve64A+v7YJpd07mroAeQYZzr8bP5auGfRQ3fNB6PCLADS74kXyxum Gaq0bu3U+YKX/xyKu7y4ClYa8XTfvo1uhy1EiAhxxrQjztffbFbNxKg7BC7dWwe6wHs4 HrCOXA38VlAVDgE5fHiOXjmpyjHzwK4XC/12brw3Wp6HIIQAj9YH26tERLZslmMqF7+R GDOQ== X-Gm-Message-State: AKwxytf4gR0RTwl062auxQEx8GEUTdggfoTVRWu85shudjqxX7QrwmOT 33uzRD/6rqKt1tE+cR3QIQR58g== X-Received: by 10.36.196.215 with SMTP id v206mr22687471itf.80.1516211562066; Wed, 17 Jan 2018 09:52:42 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id h72sm2694392ioe.61.2018.01.17.09.52.39 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 17 Jan 2018 09:52:40 -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 v3 08/10] perf tools: Add full support for CoreSight trace decoding Date: Wed, 17 Jan 2018 10:52:17 -0700 Message-Id: <1516211539-5166-9-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516211539-5166-1-git-send-email-mathieu.poirier@linaro.org> References: <1516211539-5166-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 Wed Jan 17 17:52:18 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124895 Delivered-To: patch@linaro.org Received: by 10.46.62.1 with SMTP id l1csp131605lja; Wed, 17 Jan 2018 09:52:50 -0800 (PST) X-Google-Smtp-Source: ACJfBosM6Dgv0NDPEjvSKDKNiwHxYf36oSBWKGdWzXZmZ4UiZQI1SHwHDHq/eZ6AJ1cPNkEfyyuI X-Received: by 10.84.241.194 with SMTP id t2mr44299882plm.318.1516211570569; Wed, 17 Jan 2018 09:52:50 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516211570; cv=none; d=google.com; s=arc-20160816; b=SHUrAbYSnpbZO0vZapMWfCPaEPb+ZTpC0PrYeZIj6mFYL+WCHweDXWXnxQWqEXao4W OuginT+DlpK7GnDBXRwNzrKWOWNa6TjTsVgutUahAIROS1fQkgDWiTwhMNh2YBskDz5Y 4evkKqj+bbn0dFuvYFPiHnlDq7gMfbVbd6H5KhsvxuBnBbIVrYvjlXUX6tGNAfKwnGb6 BhLlo30QeVVD1aWhtErieKdsR8rQpkZo3tObBaqIVymgv9oyKWtzxwAOD355hw2Ier5/ nU33fdVuqVgDgfWZBwdZuIa+srFruWqtRK5n7ww2m3jfsCAH+m9qCRzQFv0+Hol5QsCJ MjdQ== 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=FFpO7QKtF5gYzcLGDLYjEZ4LJy7F/+vMuZ8EK02d+awYpiZayk1EZZKAnR7h4XSsb3 iqXhlGmgUoI2T6NmtdRlCLaxMrY5ER8gIHV0A/J6d82ePPkNZznvY/P8L+oaepC30k3f FKeY0lngsArKcwfE8LtD4orqZFWULyB1VCV2lkKqaBRiYxCK5IcUyPOI86yJ5Z8s/ISz JJ+irJA11xOOCNA9FfV+LORzw2hB+6siDwx5B+htpwJ2rOLD3HHMvVup07N7jzEf2z8X z9t609s1Ln7aBhhucG7TI+oAKeOYT+Q+kXSvli2721fp25pZcJgKb/QLyx0s0hL9FBP6 vPaw== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=G0D371tB; 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 z3si4747166plk.594.2018.01.17.09.52.50; Wed, 17 Jan 2018 09:52:50 -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=G0D371tB; 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 S1754511AbeAQRwr (ORCPT + 28 others); Wed, 17 Jan 2018 12:52:47 -0500 Received: from mail-it0-f44.google.com ([209.85.214.44]:36718 "EHLO mail-it0-f44.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754487AbeAQRwp (ORCPT ); Wed, 17 Jan 2018 12:52:45 -0500 Received: by mail-it0-f44.google.com with SMTP id p124so10254871ite.1 for ; Wed, 17 Jan 2018 09:52:44 -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=G0D371tBpvXWxk4KTm6tO8pfLmBIVK7eTisQXWAdV7SxDVv5MzK1uvxKJSIzug4ix4 8efO76aqrFbCUv/3XezUsrGg8s/WGVtJ3xVFL3ZZ0Wy3+7S9qPeGwrdUpz1+Nsi1tYVe kdoDlAsCusOZ2lm1kqa5+Nbdxn0UkLuwT0GkM= 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=CregrDg0BpaO3fLrft6xWV++J6aob3Au23zuI7zCxCIf5+X7Fp0Uy8j4PlUOyPA8sM wiWqZ/14EkWoXlFrhTijXOfrQKqHuQOsFPu4Pd8may334vg4R96cfoHQmx0W3jhspGVe g6Uu9H4WYua728Odqwtln+uGgh7qEDh1m9yhmYGnBgIpXMgU4of17tcUMwbusUamBZVX HER81JHRYz+aPHE2PXWzftzui/eYlJydl2T+w1Ha3D1EDIH8Fvp+0022DeUvWFYwk5YJ ZN0tfSYMdvJuj5/TR8DcQL2eJ6SxdXfyXv5s7LV6yvrAbFmja9r6tM8ZIietEQvKFmJE spxg== X-Gm-Message-State: AKwxytcQ5Q/OifAfzS62bXlQbgWrNluEyiF7/bzzXWT9IGudMkISjrRe mX3CCs8nf4U0LE7eo3NSJ0XFvA== X-Received: by 10.36.76.68 with SMTP id a65mr22217278itb.57.1516211564328; Wed, 17 Jan 2018 09:52:44 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id h72sm2694392ioe.61.2018.01.17.09.52.42 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 17 Jan 2018 09:52:43 -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 v3 09/10] perf tools: Add mechanic to synthesise CoreSight trace packets Date: Wed, 17 Jan 2018 10:52:18 -0700 Message-Id: <1516211539-5166-10-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516211539-5166-1-git-send-email-mathieu.poirier@linaro.org> References: <1516211539-5166-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 Wed Jan 17 17:52:19 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124896 Delivered-To: patch@linaro.org Received: by 10.46.62.1 with SMTP id l1csp131624lja; Wed, 17 Jan 2018 09:52:53 -0800 (PST) X-Google-Smtp-Source: ACJfBotQmVypCsV1Ee6jLCVmymtKqCYyU4rSTxT66ooEx7S6PELDsazfPW9BVQiNiFrl1WV/rN7y X-Received: by 10.98.234.4 with SMTP id t4mr39298916pfh.74.1516211573640; Wed, 17 Jan 2018 09:52:53 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516211573; cv=none; d=google.com; s=arc-20160816; b=uMW2iQRzD3ZWGHlUS7v7MtQZqIQzU+Hg7Mfa+OdCLZndRVOeeLC3oj4/aJWx2hRxsz N95FyxDy863jnE3nMm22U4LJZJ4w/PxumLWOwJ8SkzgGHhXs/X0RjIyiL6gJ5NWDm/BI uUoABzy+dYoc9xp/F20I8cKgjSoRSKxaO0kfs6XqKky3MC46hw8XaAwLseunVuI7fbmJ pynSp6s0J0SX4F4+RLlv8y78FoAVA3kypH3pAGeB3+l4h1CgxSeiO8FU6+Q+0cVJTPNP BtHHJtZ0xeo9yL8Os87SsWUvGTw3AOAMly2mbVR/NpaI5W7HidlQBMnX6U+TC2tzcNzB xLug== 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=r/G76IRWWP+3tf2v+3mruzhNFT7JaB7pDrbQQ+i86Lk=; b=YwcBkIFkNRO+Te8IkcHQsd/ApXG3BhKmqLOCTUNlNStAVcwlK2v4Vq6avwl+HJ28Kg iUDVJ7tvXSmiIDAdSAMkNhQDaCHnGprVG/zTZGW8F6QqGxZ77mkx/IIZovrfIrM0Alnq nM2a2IB2fZc8duI4IMWBb+uT9/XJWooUY34kVDOPJcUsFdRTNO8bEm2USDtWvTTTaRDF MCUFYRAI3VRgCg+Wy3epohgb4URJaSOEhQHZEnQw0wD5TDX/k4yHjcfQoseS5G+Sgsf+ 1eKtVqe95fZh+LeIXGKQsiT/rFOzyAPib3tdmv7FgEVJXhMYC/QKwxeliRu4mpivqH/+ Y9Cg== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=ckF8GWBM; 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 z27si4808758pfk.131.2018.01.17.09.52.53; Wed, 17 Jan 2018 09:52:53 -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=ckF8GWBM; 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 S1754530AbeAQRww (ORCPT + 28 others); Wed, 17 Jan 2018 12:52:52 -0500 Received: from mail-it0-f66.google.com ([209.85.214.66]:41425 "EHLO mail-it0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754501AbeAQRwr (ORCPT ); Wed, 17 Jan 2018 12:52:47 -0500 Received: by mail-it0-f66.google.com with SMTP id b77so10220853itd.0 for ; Wed, 17 Jan 2018 09:52:46 -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=r/G76IRWWP+3tf2v+3mruzhNFT7JaB7pDrbQQ+i86Lk=; b=ckF8GWBMYC/5jgObtaz255Ja6eGmxUQY3h4fgqpndK+S2CDFh2C6eUz64Bs1SnL8Q0 MPSwBJ8NCwz75roOrowA40TM14OWD2kz0conMOZzNUhYKXpeR2bm35P25kLU2aqkUlah 5KdwHehNzSwgKR/Q4Rom0pFpPCE4jPgmxdLKs= 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=r/G76IRWWP+3tf2v+3mruzhNFT7JaB7pDrbQQ+i86Lk=; b=m14HM6M71y5aWPHi808Zdv4LIRbVLylQ7ldgUHXkHbmsMcB1R9fFmtYVH05OYM3bhl LZucoLAnb2lgleH1spW+Jp9t/8fIiLc/Vx+MOSjlGRzLJwLgTF4jUn/dBXxiViS/N/K4 hCd/JA1JiqKZnsG1IgZT1pZp6ZaHvs/qsyRxxZcSeJENvvF7dND6rTZXpMcxiOa3qRLn ssF5aS1SjIITwI4YuKF+gcSsNdVihnM/zBeoTB3PtKB0LBxBaQgV388e5nGPfynubdJG r1qfnKMaBSRZJ6r2Z/2DZlrxwQ9kpI0rurWam1Kv+qJAEHkUCZxNEUx12QgdQfCvTskZ tQoA== X-Gm-Message-State: AKwxytejslaS8TBVd0p6WiU4pCfvFN2i9uEVxbCpTUKZNTmyA3xTzL3S TCWYnfUm/QESq7BhrUVow4sqxA== X-Received: by 10.36.77.139 with SMTP id l133mr22009346itb.52.1516211566612; Wed, 17 Jan 2018 09:52:46 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id h72sm2694392ioe.61.2018.01.17.09.52.44 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Wed, 17 Jan 2018 09:52:45 -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 v3 10/10] MAINTAINERS: Adding entry for CoreSight trace decoding Date: Wed, 17 Jan 2018 10:52:19 -0700 Message-Id: <1516211539-5166-11-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516211539-5166-1-git-send-email-mathieu.poirier@linaro.org> References: <1516211539-5166-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 d76af75a653a..7eafa087dda3 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