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; }