From patchwork Mon Jan 15 18:13:11 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Mathieu Poirier X-Patchwork-Id: 124552 Delivered-To: patch@linaro.org Received: by 10.46.64.148 with SMTP id r20csp752167lje; Mon, 15 Jan 2018 10:14:51 -0800 (PST) X-Google-Smtp-Source: ACJfBosDh8ezJdRrvHhMuJWhOK331sweQt9dwhWvzeI0zYMQBXy/EU8gEwD+nCuFo3fIUroCRTOS X-Received: by 10.84.135.129 with SMTP id 1mr8686154plj.411.1516040091462; Mon, 15 Jan 2018 10:14:51 -0800 (PST) ARC-Seal: i=1; a=rsa-sha256; t=1516040091; cv=none; d=google.com; s=arc-20160816; b=JgHuA5m3okHANNljPpamPfd4XlGzqJOaUZUN8E7jAudSD3pd4YXwxlJgK0AJLzWfcW uEp7se3RvvsxNkAcrJA9BMGrLZ2akaTNwgWasFU0SjUF8rJ98sTUxbMffTnCdFpMkcSr oS1hm7tGZWBJX/GEi46J+sa0TPGciW6wFpe84V7GL3EZK164/hj4FRhvJjnN3IYrzeW/ wWLhrpn1LxNCFgGY9pECwMI8BAK6Cfbtmz9NLI06xctuVzzLoAGxGhvYIAx62KydWngu t9SbfTZFVaAKDzC5KU0ci/r9CUHq/GMzGrv1GwjkskpQZMDnn1/mb+pJyDHJF74Swz58 UhVA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:message-id:date :subject:cc:to:from:dkim-signature:arc-authentication-results; bh=nse+24OctCfX1/9soi5qNADvKvzH+f65AljLKc2a034=; b=LXV2dkBD9sp81Gf8kYQAVqnyx1btApLdkrMK+Vd7KfxZdzsAowKaXwTFRAfV6m0/tM f1OQGwXAXntUnbIbCIkmsyjJDYlv0agjkFWtD46DDmB94+N8Bxr7skp3czBEqvZgX253 uro4jTiYjisYFiUVZ/0pAjQhL0InTiRoUwCJxOFdR1V12B9h4z/OvagVjKP2bhMYNwit +oSZewC9QfeHVi8KfcQZ79pmL9EU88+32m4iz+0yVZmEiq8NGqmrf/aeBKNU+o10LfEr SBpE3KgDBjXVR64e2DZm/hsL+HL8Bc/54b3djzKRyc2pqRs7yJBdmdcXSOSv6zWMyFsW QzoA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=Go89cX19; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id i188si143936pgc.177.2018.01.15.10.14.51; Mon, 15 Jan 2018 10:14:51 -0800 (PST) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=Go89cX19; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751453AbeAOSOu (ORCPT + 28 others); Mon, 15 Jan 2018 13:14:50 -0500 Received: from mail-it0-f67.google.com ([209.85.214.67]:42838 "EHLO mail-it0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751290AbeAOSNd (ORCPT ); Mon, 15 Jan 2018 13:13:33 -0500 Received: by mail-it0-f67.google.com with SMTP id p139so1859249itb.1 for ; Mon, 15 Jan 2018 10:13:33 -0800 (PST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=nse+24OctCfX1/9soi5qNADvKvzH+f65AljLKc2a034=; b=Go89cX19gll9C/AECVZZU910ecuesEM5nQDkxfup1Q14YMlkhBDkrHDaRJufNCm31Z z/LDzru29K70cB9/mw50Kg4of5f+LsgJ8IBYpEt5itvWngRvfi1KyvBhvc3ERi8Oxf53 DVbCAkvxhhLLuRzsi1ZY2WmZhRIQ/F14Uy6Zs= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=nse+24OctCfX1/9soi5qNADvKvzH+f65AljLKc2a034=; b=rang13WamvxUnWSEkKP9/RtOcNbbsisYZnuYt/vyQ/K/1pdW+b/oPGuzBKbCRuG6bj S1X6HTD2T4rKCHbJ+EqAiFyRm4Nim/pM6b+IlRzOt+sWp0v49gxBa62ZVKaVEc5xgTgQ g+mOMhHXooFHxjupUYGR0zFxsFCab5bZtlXnYEYk+RG7h4H/ISuh1HLaXNAJRJyYGpgq Gb2/g2Y7HHafqcZIYm0cwOW+JhcQOzRixyTeQtDrJnUYmTGQf5QBqrqUY73knvy2dMVe RelapcSb8BlzPqQwkITmisohffdFrxV8ijAgMWapOWhZfCoiiCol/rY6i+Q0qjmwdNyG QKpg== X-Gm-Message-State: AKwxytcThBDRwBCCviXXHsnXMh0ALGUcp9QKL38V93IbzQvSR2jaIxbC 4J5Qmb+FjMErYPd02rPJFTL2CP6q2hA= X-Received: by 10.36.83.21 with SMTP id n21mr15633502itb.74.1516040013026; Mon, 15 Jan 2018 10:13:33 -0800 (PST) Received: from xps15.cg.shawcable.net (S0106002369de4dac.cg.shawcable.net. [68.147.8.254]) by smtp.gmail.com with ESMTPSA id w142sm231480ita.25.2018.01.15.10.13.30 (version=TLS1_2 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Mon, 15 Jan 2018 10:13:31 -0800 (PST) From: Mathieu Poirier To: acme@kernel.org Cc: peterz@infradead.org, mingo@redhat.com, alexander.shishkin@linux.intel.com, namhyung@kernel.org, adrian.hunter@intel.com, mike.leach@arm.com, suzuki.poulosi@arm.com, jolsa@redhat.com, kim.phillips@arm.com, linux-kernel@vger.kernel.org, linux-arm-kernel@lists.infradead.org Subject: [PATCH v2 07/10] pert tools: Add queue management functionality Date: Mon, 15 Jan 2018 11:13:11 -0700 Message-Id: <1516039994-314-8-git-send-email-mathieu.poirier@linaro.org> X-Mailer: git-send-email 2.7.4 In-Reply-To: <1516039994-314-1-git-send-email-mathieu.poirier@linaro.org> References: <1516039994-314-1-git-send-email-mathieu.poirier@linaro.org> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Add functionatlity to setup trace queues so that traces associated with CoreSight auxtrace events found in the perf.data file can be classified properly. The decoder and memory callback associated with each queue are then used to decode the traces that have been assigned to that queue. Co-authored-by: Tor Jeremiassen Signed-off-by: Mathieu Poirier --- tools/perf/util/cs-etm.c | 208 ++++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 204 insertions(+), 4 deletions(-) -- 2.7.4 diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index cad429ce3c00..83eb676274b5 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -196,15 +196,215 @@ static void cs_etm__free(struct perf_session *session) zfree(&aux); } +static u32 cs_etm__mem_access(struct cs_etm_queue *etmq, u64 address, + size_t size, u8 *buffer) +{ + u8 cpumode; + u64 offset; + int len; + struct thread *thread; + struct machine *machine; + struct addr_location al; + + if (!etmq) + return -1; + + machine = etmq->etm->machine; + if (address >= etmq->etm->kernel_start) + cpumode = PERF_RECORD_MISC_KERNEL; + else + cpumode = PERF_RECORD_MISC_USER; + + thread = etmq->thread; + if (!thread) { + if (cpumode != PERF_RECORD_MISC_KERNEL) + return -EINVAL; + thread = etmq->etm->unknown_thread; + } + + thread__find_addr_map(thread, cpumode, MAP__FUNCTION, address, &al); + + if (!al.map || !al.map->dso) + return 0; + + if (al.map->dso->data.status == DSO_DATA_STATUS_ERROR && + dso__data_status_seen(al.map->dso, DSO_DATA_STATUS_SEEN_ITRACE)) + return 0; + + offset = al.map->map_ip(al.map, address); + + map__load(al.map); + + len = dso__data_read_offset(al.map->dso, machine, offset, buffer, size); + + if (len <= 0) + return 0; + + return len; +} + +static struct cs_etm_queue *cs_etm__alloc_queue(struct cs_etm_auxtrace *etm, + unsigned int queue_nr) +{ + int i; + struct cs_etm_decoder_params d_params; + struct cs_etm_trace_params *t_params; + struct cs_etm_queue *etmq; + + etmq = zalloc(sizeof(*etmq)); + if (!etmq) + return NULL; + + etmq->event_buf = malloc(PERF_SAMPLE_MAX_SIZE); + if (!etmq->event_buf) + goto out_free; + + etmq->etm = etm; + etmq->queue_nr = queue_nr; + etmq->pid = -1; + etmq->tid = -1; + etmq->cpu = -1; + + /* Use metadata to fill in trace parameters for trace decoder */ + t_params = zalloc(sizeof(*t_params) * etm->num_cpu); + + if (!t_params) + goto out_free; + + for (i = 0; i < etm->num_cpu; i++) { + t_params[i].protocol = CS_ETM_PROTO_ETMV4i; + t_params[i].etmv4.reg_idr0 = etm->metadata[i][CS_ETMV4_TRCIDR0]; + t_params[i].etmv4.reg_idr1 = etm->metadata[i][CS_ETMV4_TRCIDR1]; + t_params[i].etmv4.reg_idr2 = etm->metadata[i][CS_ETMV4_TRCIDR2]; + t_params[i].etmv4.reg_idr8 = etm->metadata[i][CS_ETMV4_TRCIDR8]; + t_params[i].etmv4.reg_configr = + etm->metadata[i][CS_ETMV4_TRCCONFIGR]; + t_params[i].etmv4.reg_traceidr = + etm->metadata[i][CS_ETMV4_TRCTRACEIDR]; + } + + /* Set decoder parameters to simply print the trace packets */ + d_params.packet_printer = cs_etm__packet_dump; + d_params.operation = CS_ETM_OPERATION_DECODE; + d_params.formatted = true; + d_params.fsyncs = false; + d_params.hsyncs = false; + d_params.frame_aligned = true; + d_params.data = etmq; + + etmq->decoder = cs_etm_decoder__new(etm->num_cpu, &d_params, t_params); + + zfree(&t_params); + + if (!etmq->decoder) + goto out_free; + + /* + * Register a function to handle all memory accesses required by + * the trace decoder library. + */ + if (cs_etm_decoder__add_mem_access_cb(etmq->decoder, + 0x0L, ((u64) -1L), + cs_etm__mem_access)) + goto out_free_decoder; + + etmq->offset = 0; + + return etmq; + +out_free_decoder: + cs_etm_decoder__free(etmq->decoder); +out_free: + zfree(&etmq->event_buf); + free(etmq); + + return NULL; +} + +static int cs_etm__setup_queue(struct cs_etm_auxtrace *etm, + struct auxtrace_queue *queue, + unsigned int queue_nr) +{ + struct cs_etm_queue *etmq = queue->priv; + + if (list_empty(&queue->head) || etmq) + return 0; + + etmq = cs_etm__alloc_queue(etm, queue_nr); + + if (!etmq) + return -ENOMEM; + + queue->priv = etmq; + + if (queue->cpu != -1) + etmq->cpu = queue->cpu; + + etmq->tid = queue->tid; + + return 0; +} + +static int cs_etm__setup_queues(struct cs_etm_auxtrace *etm) +{ + unsigned int i; + int ret; + + for (i = 0; i < etm->queues.nr_queues; i++) { + ret = cs_etm__setup_queue(etm, &etm->queues.queue_array[i], i); + if (ret) + return ret; + } + + return 0; +} + +static int cs_etm__update_queues(struct cs_etm_auxtrace *etm) +{ + if (etm->queues.new_data) { + etm->queues.new_data = false; + return cs_etm__setup_queues(etm); + } + + return 0; +} + static int cs_etm__process_event(struct perf_session *session, union perf_event *event, struct perf_sample *sample, struct perf_tool *tool) { - (void) session; - (void) event; - (void) sample; - (void) tool; + int err = 0; + u64 timestamp; + struct cs_etm_auxtrace *etm = container_of(session->auxtrace, + struct cs_etm_auxtrace, + auxtrace); + + /* Keep compiler happy */ + (void)event; + + if (dump_trace) + return 0; + + if (!tool->ordered_events) { + pr_err("CoreSight ETM Trace requires ordered events\n"); + return -EINVAL; + } + + if (!etm->timeless_decoding) + return -EINVAL; + + if (sample->time && (sample->time != (u64) -1)) + timestamp = sample->time; + else + timestamp = 0; + + if (timestamp || etm->timeless_decoding) { + err = cs_etm__update_queues(etm); + if (err) + return err; + } + return 0; }