CoreSight

coresight@lists.linaro.org

4 participants
2721 discussions

[PATCH v6 0/1] perf cs-etm: Split Coresight decode by aux records

by James Clark

Changes since v5: * Fixed typo in commit message * Indentation fix James Clark (1): perf cs-etm: Split Coresight decode by aux records tools/perf/util/cs-etm.c | 156 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 155 insertions(+), 1 deletion(-) -- 2.28.0

5 years, 5 months

[PATCH v5 0/1] perf cs-etm: Split Coresight decode by aux records

by James Clark

Changes since RFC v4: * Style and indentation fixes * Add a warning when the buffer isn't found (suggested by Leo) * Undo change to set 'etm->data_queued' * Replace 'matchesCpuPid' with early exit when CPU/TID doesn't match * Check more return value errors * Remove TODOs from commit message and code * Add motivation to commit message James Clark (1): perf cs-etm: Split Coresight decode by aux records tools/perf/util/cs-etm.c | 158 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 157 insertions(+), 1 deletion(-) -- 2.28.0

5 years, 5 months

[PATCHv2 0/4] perf/core: Add support to exclude kernel mode PMU tracing

by Sai Prakash Ranjan

Hardware assisted tracing families such as ARM Coresight, Intel PT provides rich tracing capabilities including instruction level tracing and accurate timestamps which are very useful for profiling and also pose a significant security risk. One such example of security risk is when kernel mode tracing is not excluded and these hardware assisted tracing can be used to analyze cryptographic code execution. In this case, even the root user must not be able to infer anything. To explain it more clearly in the words of a security team member (credits: Mattias Nissler), "Consider a system where disk contents are encrypted and the encryption key is set up by the user when mounting the file system. From that point on the encryption key resides in the kernel. It seems reasonable to expect that the disk encryption key be protected from exfiltration even if the system later suffers a root compromise (or even against insiders that have root access), at least as long as the attacker doesn't manage to compromise the kernel." Here the idea is to protect such important information from all users including root users since root privileges does not have to mean full control over the kernel [1] and root compromise does not have to be the end of the world. But "Peter said even the regular counters can be used for full branch trace, the information isn't as accurate as PT and friends and not easier but is good enough to infer plenty". This would mean that a global tunable config for all kernel mode pmu tracing is more appropriate than the one targeting the hardware assisted instruction tracing. Currently we can exclude kernel mode tracing via perf_event_paranoid sysctl but it has following limitations, * No option to restrict kernel mode instruction tracing by the root user. * Not possible to restrict kernel mode instruction tracing when the hardware assisted tracing IPs like ARM Coresight ETMs use an additional interface via sysfs for tracing in addition to perf interface. So introduce a new config CONFIG_EXCLUDE_KERNEL_PMU_TRACE to exclude kernel mode pmu tracing for all users including root which will be generic and applicable to all hardware tracing families and which can also be used with other interfaces like sysfs in case of ETMs. Patch 1 adds this new config and the support in perf core to exclude all kernel mode PMU tracing. Patch 2 adds the perf evsel warning message when the perf tool users attempt to perform a kernel mode trace with the config enabled to exclude the kernel mode tracing. Patch 3 and Patch 4 adds the support for excluding kernel mode for ARM Coresight ETM{4,3}XX sysfs mode using the newly introduced generic config. [1] https://lwn.net/Articles/796866/ Changes in v2: * Move from kernel mode instruction tracing to all kernel level PMU tracing (Peter) * Move the check and warning to the caller mode_store() (Doug) Sai Prakash Ranjan (4): perf/core: Add support to exclude kernel mode PMU tracing perf evsel: Print warning for excluding kernel mode instruction tracing coresight: etm4x: Add support to exclude kernel mode tracing coresight: etm3x: Add support to exclude kernel mode tracing drivers/hwtracing/coresight/coresight-etm3x-core.c | 3 +++ drivers/hwtracing/coresight/coresight-etm3x-sysfs.c | 6 ++++++ drivers/hwtracing/coresight/coresight-etm4x-core.c | 6 +++++- drivers/hwtracing/coresight/coresight-etm4x-sysfs.c | 6 ++++++ init/Kconfig | 11 +++++++++++ kernel/events/core.c | 3 +++ tools/perf/util/evsel.c | 3 ++- 7 files changed, 36 insertions(+), 2 deletions(-) -- QUALCOMM INDIA, on behalf of Qualcomm Innovation Center, Inc. is a member of Code Aurora Forum, hosted by The Linux Foundation

5 years, 5 months

[PATCH v2 0/8] perf: Refine barriers for AUX ring buffer

by Leo Yan

Based on the discussion [1], this patch series is to refine the memory barriers for AUX ring buffer. Patches 01 ~ 04 to address the barriers usage in the kernel. The first patch is to make clear comment for how to use the barriers between the data store and aux_head store, this asks the driver to make sure the data is visible. Patches 02 ~ 04 is to refine the drivers for barriers after the data store. Patches 05 ~ 07 is to fix and clean up the memory barries in perf tool for AUX ring buffer. Since the 64-bit value's atomicity is not promised on 32-bit perf, the last patch is to report error and let perf to directly exit for this case. Have testes the patches on Arm64 Juno platform. [1] https://lore.kernel.org/patchwork/patch/1431867/ Leo Yan (8): perf/ring_buffer: Add comment for barriers on AUX ring buffer coresight: tmc-etr: Add barrier after updating AUX ring buffer coresight: tmc-etf: Add comment for store ordering perf/x86: Add barrier after updating bts perf auxtrace: Change to use SMP memory barriers perf auxtrace: Drop legacy __sync functions perf auxtrace: Use WRITE_ONCE() for updating aux_tail perf record: Directly bail out for compat case arch/x86/events/intel/bts.c | 3 +++ .../hwtracing/coresight/coresight-tmc-etf.c | 6 +++++ .../hwtracing/coresight/coresight-tmc-etr.c | 8 ++++++ kernel/events/ring_buffer.c | 9 +++++++ tools/perf/builtin-record.c | 17 ++++++++++++ tools/perf/util/auxtrace.h | 27 +++---------------- 6 files changed, 47 insertions(+), 23 deletions(-) -- 2.25.1

5 years, 5 months

[RFC PATCH v4 0/1] perf cs-etm: Split Coresight decode by aux records

by James Clark

Changes since v3: * Include fix for snapshot mode * Fix typo that was in the initial snapshot fix posted to the previous thread (&& -> &) James Clark (1): perf cs-etm: Split Coresight decode by aux records tools/perf/util/cs-etm.c | 159 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 156 insertions(+), 3 deletions(-) -- 2.28.0

5 years, 5 months

[PATCH 00/34] docs: avoid using ReST :doc:`foo` tag

by Mauro Carvalho Chehab

As discussed at: https://lore.kernel.org/linux-doc/871r9k6rmy.fsf@meer.lwn.net/ It is better to avoid using :doc:`foo` to refer to Documentation/foo.rst, as the automarkup.py extension should handle it automatically, on most cases. There are a couple of exceptions to this rule: 1. when :doc: tag is used to point to a kernel-doc DOC: markup; 2. when it is used with a named tag, e. g. :doc:`some name <foo>`; It should also be noticed that automarkup.py has currently an issue: if one use a markup like: Documentation/dev-tools/kunit/api/test.rst - documents all of the standard testing API excluding mocking or mocking related features. or, even: Documentation/dev-tools/kunit/api/test.rst documents all of the standard testing API excluding mocking or mocking related features. The automarkup.py will simply ignore it. Not sure why. This patch series avoid the above patterns (which is present only on 4 files), but it would be nice to have a followup patch fixing the issue at automarkup.py. On this series: Patch 1 manually adjust the references inside driver-api/pm/devices.rst, as there it uses :file:`foo` to refer to some Documentation/ files; Patch 2 converts a table at Documentation/dev-tools/kunit/api/index.rst into a list, carefully avoiding the Patch 3 converts the cross-references at the media documentation, also avoiding the automarkup.py bug; Patches 4-34 convert the other occurrences via a replace script. They were manually edited, in order to honour 80-columns where possible. I did a diff between the Sphinx 2.4.4 output before and after this patch series in order to double-check that all converted Documentation/ references will produce <a href=<foo>.rst>foo title</a> tags. Mauro Carvalho Chehab (34): docs: devices.rst: better reference documentation docs docs: dev-tools: kunit: don't use a table for docs name media: docs: */media/index.rst: don't use ReST doc:`foo` media: userspace-api: avoid using ReST :doc:`foo` markup media: driver-api: drivers: avoid using ReST :doc:`foo` markup media: admin-guide: avoid using ReST :doc:`foo` markup docs: admin-guide: pm: avoid using ReSt :doc:`foo` markup docs: admin-guide: hw-vuln: avoid using ReST :doc:`foo` markup docs: admin-guide: sysctl: avoid using ReST :doc:`foo` markup docs: block: biodoc.rst: avoid using ReSt :doc:`foo` markup docs: bpf: bpf_lsm.rst: avoid using ReSt :doc:`foo` markup docs: core-api: avoid using ReSt :doc:`foo` markup docs: dev-tools: testing-overview.rst: avoid using ReSt :doc:`foo` markup docs: dev-tools: kunit: avoid using ReST :doc:`foo` markup docs: devicetree: bindings: submitting-patches.rst: avoid using ReSt :doc:`foo` markup docs: doc-guide: avoid using ReSt :doc:`foo` markup docs: driver-api: avoid using ReSt :doc:`foo` markup docs: driver-api: gpio: using-gpio.rst: avoid using ReSt :doc:`foo` markup docs: driver-api: surface_aggregator: avoid using ReSt :doc:`foo` markup docs: driver-api: usb: avoid using ReSt :doc:`foo` markup docs: firmware-guide: acpi: avoid using ReSt :doc:`foo` markup docs: hwmon: adm1177.rst: avoid using ReSt :doc:`foo` markup docs: i2c: avoid using ReSt :doc:`foo` markup docs: kernel-hacking: hacking.rst: avoid using ReSt :doc:`foo` markup docs: networking: devlink: avoid using ReSt :doc:`foo` markup docs: PCI: endpoint: pci-endpoint-cfs.rst: avoid using ReSt :doc:`foo` markup docs: PCI: pci.rst: avoid using ReSt :doc:`foo` markup docs: process: submitting-patches.rst: avoid using ReSt :doc:`foo` markup docs: security: landlock.rst: avoid using ReSt :doc:`foo` markup docs: trace: coresight: coresight.rst: avoid using ReSt :doc:`foo` markup docs: trace: ftrace.rst: avoid using ReSt :doc:`foo` markup docs: userspace-api: landlock.rst: avoid using ReSt :doc:`foo` markup docs: virt: kvm: s390-pv-boot.rst: avoid using ReSt :doc:`foo` markup docs: x86: avoid using ReSt :doc:`foo` markup .../PCI/endpoint/pci-endpoint-cfs.rst | 2 +- Documentation/PCI/pci.rst | 6 +-- .../special-register-buffer-data-sampling.rst | 3 +- Documentation/admin-guide/media/bt8xx.rst | 15 ++++---- Documentation/admin-guide/media/bttv.rst | 21 ++++++----- Documentation/admin-guide/media/index.rst | 12 +++--- Documentation/admin-guide/media/saa7134.rst | 3 +- Documentation/admin-guide/pm/intel_idle.rst | 16 +++++--- Documentation/admin-guide/pm/intel_pstate.rst | 9 +++-- Documentation/admin-guide/sysctl/abi.rst | 2 +- Documentation/admin-guide/sysctl/kernel.rst | 37 ++++++++++--------- Documentation/block/biodoc.rst | 2 +- Documentation/bpf/bpf_lsm.rst | 13 ++++--- .../core-api/bus-virt-phys-mapping.rst | 2 +- Documentation/core-api/dma-api.rst | 5 ++- Documentation/core-api/dma-isa-lpc.rst | 2 +- Documentation/core-api/index.rst | 4 +- Documentation/dev-tools/kunit/api/index.rst | 8 ++-- Documentation/dev-tools/kunit/faq.rst | 2 +- Documentation/dev-tools/kunit/index.rst | 14 +++---- Documentation/dev-tools/kunit/start.rst | 6 +-- Documentation/dev-tools/kunit/tips.rst | 5 ++- Documentation/dev-tools/kunit/usage.rst | 8 ++-- Documentation/dev-tools/testing-overview.rst | 16 ++++---- .../bindings/submitting-patches.rst | 11 +++--- Documentation/doc-guide/contributing.rst | 8 ++-- Documentation/driver-api/gpio/using-gpio.rst | 4 +- Documentation/driver-api/ioctl.rst | 2 +- .../driver-api/media/drivers/bttv-devel.rst | 2 +- Documentation/driver-api/media/index.rst | 10 +++-- Documentation/driver-api/pm/devices.rst | 8 ++-- .../surface_aggregator/clients/index.rst | 3 +- .../surface_aggregator/internal.rst | 15 ++++---- .../surface_aggregator/overview.rst | 6 ++- Documentation/driver-api/usb/dma.rst | 6 +-- .../acpi/dsd/data-node-references.rst | 3 +- .../firmware-guide/acpi/dsd/graph.rst | 2 +- .../firmware-guide/acpi/enumeration.rst | 7 ++-- Documentation/hwmon/adm1177.rst | 3 +- Documentation/i2c/instantiating-devices.rst | 2 +- Documentation/i2c/old-module-parameters.rst | 3 +- Documentation/i2c/smbus-protocol.rst | 4 +- Documentation/kernel-hacking/hacking.rst | 4 +- .../networking/devlink/devlink-region.rst | 2 +- .../networking/devlink/devlink-trap.rst | 4 +- Documentation/process/submitting-patches.rst | 32 ++++++++-------- Documentation/security/landlock.rst | 3 +- Documentation/trace/coresight/coresight.rst | 8 ++-- Documentation/trace/ftrace.rst | 2 +- Documentation/userspace-api/landlock.rst | 11 +++--- .../userspace-api/media/glossary.rst | 2 +- Documentation/userspace-api/media/index.rst | 12 +++--- Documentation/virt/kvm/s390-pv-boot.rst | 2 +- Documentation/x86/boot.rst | 4 +- Documentation/x86/mtrr.rst | 2 +- 55 files changed, 217 insertions(+), 183 deletions(-) -- 2.31.1

5 years, 5 months

lists.linaro.org WARNING: The email account "coresight@lists.linaro.org" storage is almost full.

by cPanel on lists.linaro.org

The email account " coresight(a)lists.linaro.org " is almost full. The email account currently uses 91.68% (229.19 MB / 250 MB) of its capacity. You should remove some emails from the mailbox as soon as possible in order to prevent the loss of any future email. Use the Email Disk Usage tool at https://lists.linaro.org:2096/?goto_app=Email_DiskUsage , or ask the system administrator to upgrade your account to a larger quota. The system generated this warning on Friday, September 21, 2018 at 6:27:01 (UTC). You can disable the “Quota :: MailboxWarning” notice type through the cPanel interface: https://lists.linaro.org:2083/?goto_app=ContactInfo_Change Do not reply to this automated message.

5 years, 5 months

CoreSight trace sometimes containing BAD_DECODE_PKT and INCOMPLETE_EOT

by Dominik Huber

Hello, I've successfully written a program that generates trace via sysFS, passes it to the decoder, and uses a callback function to utilize it afterward. When testing it by tracing a small test program over and over again I noticed that occasionally I get a CSD_ERR_BAD_DECODE_PKT-error message. In the few instances I was able to reproduce it the produced OCSD_GEN_TRC_ELEM_INSTR_RANGE packets were always correct and the error always occurred at the end in combination with an I_INCOMPLETE_EOT packet. Therefore, and because the error is very rare, I could just disable the error logger and my program would work, but if possible I would like to avoid that. Does anyone have an idea where the error might come from, whether I am doing something wrong, or where I could look for the cause? I've saved the binary trace data and decoded it using trc_pkt lister, and the output is almost the same, but the broken trace has a few additional lines and is missing one OCSD_GEN_TRC_ELEM_EO_TRACE-element: [equal trace data] + Idx:364; ID:10; [0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x80 ]; I_ASYNC : Alignment Synchronisation. + Idx:377; ID:10; [0x01 0x01 0x00 ]; I_TRACE_INFO : Trace Info.; INFO=0x0 { CC.0 } + Idx:380; ID:10; [0x9d 0x70 0x6a 0x0d 0x10 0x00 0x80 0xff 0xff ]; I_ADDR_L_64IS0 : Address, Long, 64 bit, IS0.; Addr=0xFFFF8000100DD5C0; [equal trace only having varying Idx] + Idx:506; ID:10; [0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x00 0x80 ]; I_ASYNC : Alignment Synchronisation. + Idx:519; ID:10; [0x01 0x01 0x00 ]; I_TRACE_INFO : Trace Info.; INFO=0x0 { CC.0 } + Idx:522; ID:10; [0x9d 0x60 0x57 0xd1 0x10 ]; I_INCOMPLETE_EOT : Incomplete packet at end of trace.[I_ADDR_L_64IS0] + DCD_ETMV4_0016 : 0x0019 (OCSD_ERR_BAD_DECODE_PKT) [Reserved or unknown packet in decoder.]; TrcIdx=522; CS ID=10; Unknown packet type.Idx:522; ID:10; OCSD_GEN_TRC_ELEM_EO_TRACE( [end-of-trace]) - Idx:471; ID:10; OCSD_GEN_TRC_ELEM_EO_TRACE( [end-of-trace]) [Equal EOT trace: ] ID:10 END OF TRACE DATA Idx:0; ID:12; OCSD_GEN_TRC_ELEM_EO_TRACE( [end-of-trace]) ID:12 END OF TRACE DATA Idx:0; ID:14; OCSD_GEN_TRC_ELEM_EO_TRACE( [end-of-trace]) ID:14 END OF TRACE DATA Idx:0; ID:16; OCSD_GEN_TRC_ELEM_EO_TRACE( [end-of-trace]) ID:16 END OF TRACE DATA Idx:0; ID:17; OCSD_GEN_TRC_ELEM_EO_TRACE( [end-of-trace]) ID:17 END OF TRACE DATA Idx:0; ID:18; OCSD_GEN_TRC_ELEM_EO_TRACE( [end-of-trace]) ID:18 END OF TRACE DATA Idx:0; ID:1a; OCSD_GEN_TRC_ELEM_EO_TRACE( [end-of-trace]) ID:1a END OF TRACE DATA Idx:0; ID:1c; OCSD_GEN_TRC_ELEM_EO_TRACE( [end-of-trace]) ID:1c END OF TRACE DATA Trace Packet Lister : Trace buffer done, processed 5xx bytes. I've attached the full decoded traces as well. I don't know if it matters, but my trace very often contains a 0x0e Exceptions (apparently syscalls) but not in this run. Any insight on this would be appreciated. Thanks and regards, Dominik

5 years, 5 months

[RFC PATCH v3] perf cs-etm: Split Coresight decode by aux records

by James Clark

Populate the auxtrace queues using AUX records rather than whole auxtrace buffers. This is similar to the auxtrace_queues__process_index() -> auxtrace_queues__add_indexed_event() flow where perf_session__peek_event() is used to read AUXTRACE events out of random positions in the file based on the auxtrace index. Now there is a second pass using perf_session__peek_events() which loops over all PERF_RECORD_AUX events, finds the corresponding auxtrace buffer, and adds a fragment of that buffer to the auxtrace queues, rather than the whole buffer. This is a completely new implementation compared to v1 and v2 of the patchset where significant modifications were made to the decoding flow, including saving all of the AUX records, and changing the point where decoding started. These changes had effects on the outcome of decoding, but with this implementation, the output of decoding is identical to perf/core, except in the case where decoding failed due to the issue that this change addresses. No changes to decoding were made, apart from populating the auxtrace queues. Because the decoder is already reset between each auxtrace buffer, populating the queues with fragments of whole buffers based on AUX records has the same affect as resetting the decoder on the AUX record bounds during decode. But this approach only requires a change to one part of the whole flow, rather than many parts. There is still one TODO about how buffers are found. Currently there is a plain loop as a search, but this could be improved with a binary search or keeping a record of which buffers have already been added and starting the search from the last used place. AUX records and buffers will come in similar orders in the file so the latter would be simpler and probably be good enough. But I'm looking for feedback about the approach as a whole before ironing out all of the details. Other issues that were fixed by the previous patchsets such as fixing the case where the first aux record comes before the first MMAP record can now be fixed as completely independent issues. Testing ======= Testing was done with the following script, to diff the decoding results between the patched and un-patched versions of perf: #!/bin/bash set -ex $1 script -i $3 $4 > split.script $2 script -i $3 $4 > default.script diff split.script default.script | head -n 20 And it was run like this, with various itrace options depending on the quantity of synthesised events: compare.sh ./perf-patched ./perf-default perf-per-cpu-2-threads.data --itrace=i100000ns No changes in output were observed in the following scenarios: * Simple per-cpu perf record -e cs_etm/@tmc_etr0/u top * Per-thread, single thread perf record -e cs_etm/@tmc_etr0/u --per-thread ./threads_C * Per-thread multiple threads (but only one thread collected data): perf record -e cs_etm/@tmc_etr0/u --per-thread --pid 4596,4597 * Per-thread multiple threads (both threads collected data): perf record -e cs_etm/@tmc_etr0/u --per-thread --pid 4596,4597 * Per-cpu explicit threads: perf record -e cs_etm/@tmc_etr0/u --pid 853,854 * System-wide (per-cpu): perf record -e cs_etm/@tmc_etr0/u -a * No data collected (no aux buffers) Can happen with any command when run for a short period * Containing truncated records Can happen with any command * Containing aux records with 0 size Can happen with any command Snapshot mode still needs to be tested. Signed-off-by: James Clark <james.clark(a)arm.com> --- tools/perf/util/cs-etm.c | 151 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 148 insertions(+), 3 deletions(-) diff --git a/tools/perf/util/cs-etm.c b/tools/perf/util/cs-etm.c index 64536a6ed10a..5d6c03488187 100644 --- a/tools/perf/util/cs-etm.c +++ b/tools/perf/util/cs-etm.c @@ -2679,6 +2679,153 @@ static u64 *cs_etm__create_meta_blk(u64 *buff_in, int *buff_in_offset, return metadata; } +/** + * Puts a fragment of an auxtrace buffer into the auxtrace queues based + * on the bounds of aux_event, if it matches with the buffer that's at + * file_offset. + * + * Normally, whole auxtrace buffers would be added to the queue. But we + * want to reset the decoder for every PERF_RECORD_AUX event, and the decoder + * is reset across each buffer, so splitting the buffers up in advance has + * the same effect. + */ +static int cs_etm__queue_aux_fragment(struct perf_session *session, + off_t file_offset, size_t sz, + struct perf_record_aux *aux_event, + struct perf_sample *sample) +{ + int err; + char buf[PERF_SAMPLE_MAX_SIZE]; + union perf_event *auxtrace_event_union; + struct perf_record_auxtrace *auxtrace_event; + union perf_event auxtrace_fragment; + bool matchesCpuPid; + struct cs_etm_auxtrace *etm = container_of(session->auxtrace, + struct cs_etm_auxtrace, + auxtrace); + + /* + * There should be a PERF_RECORD_AUXTRACE event at the file_offset that we got + * from looping through the auxtrace index. + */ + err = perf_session__peek_event(session, file_offset, buf, + PERF_SAMPLE_MAX_SIZE, &auxtrace_event_union, NULL); + if (err) + return err; + auxtrace_event = &auxtrace_event_union->auxtrace; + if (auxtrace_event->header.type != PERF_RECORD_AUXTRACE) + return -EINVAL; + + if (auxtrace_event->header.size < sizeof(struct perf_record_auxtrace) || + auxtrace_event->header.size != sz) { + return -EINVAL; + } + + /* + * In per-thread mode, CPU is set to -1, but TID will be set instead. + * See auxtrace_mmap_params__set_idx() + */ + if (auxtrace_event->cpu == (__u32) -1) + matchesCpuPid = auxtrace_event->tid == sample->tid; + else + matchesCpuPid = auxtrace_event->cpu == sample->cpu; + + if (matchesCpuPid && + aux_event->aux_offset >= auxtrace_event->offset && + aux_event->aux_offset + aux_event->aux_size <= + auxtrace_event->offset + auxtrace_event->size) { + /* + * If this AUX event was inside this buffer somewhere, create a new auxtrace event + * based on the sizes of the aux event, and queue that fragment. + */ + auxtrace_fragment.auxtrace = *auxtrace_event; + auxtrace_fragment.auxtrace.size = aux_event->aux_size; + auxtrace_fragment.auxtrace.offset = aux_event->aux_offset; + file_offset += aux_event->aux_offset - auxtrace_event->offset + + auxtrace_event->header.size; + return auxtrace_queues__add_event(&etm->queues, + session, + &auxtrace_fragment, + file_offset, + NULL); + } + + /* Wasn't inside this buffer, but there were no parse errors. 1 == 'not found' */ + return 1; +} + +static int cs_etm__queue_aux_records_cb(struct perf_session *session, + union perf_event *event, u64 offset __maybe_unused, + void *data __maybe_unused) +{ + struct perf_sample sample; + int ret; + struct auxtrace_index_entry *ent; + struct auxtrace_index *auxtrace_index; + struct evsel *evsel; + size_t i; + struct cs_etm_auxtrace *etm = container_of(session->auxtrace, + struct cs_etm_auxtrace, + auxtrace); + + /* Don't care about any other events, we're only queuing buffers for AUX events */ + if (event->header.type != PERF_RECORD_AUX) + return 0; + + if (event->header.size < sizeof(struct perf_record_aux)) + return -EINVAL; + + /* Truncated Aux records can have 0 size and shouldn't result in anything being queued. */ + if (!event->aux.aux_size) + return 0; + + /* + * Parse the sample, we need the sample_id_all data that comes after the event so that the + * CPU or PID can be matched to an AUXTRACE buffer's CPU or PID. + */ + evsel = evlist__event2evsel(session->evlist, event); + evsel__parse_sample(evsel, event, &sample); + + /* + * Loop throuch the auxtrace index to find the buffer that matches up with this + * aux event. + * TODO: binary search? + */ + list_for_each_entry(auxtrace_index, &session->auxtrace_index, list) { + for (i = 0; i < auxtrace_index->nr; i++) { + ent = &auxtrace_index->entries[i]; + ret = cs_etm__queue_aux_fragment(session, ent->file_offset, + ent->sz, &event->aux, &sample); + if (!ret) { + etm->data_queued = true; + return 0; + } else if (ret < 0) { + /* + * Anything other than 1 is an error. Positive values are 'not + * found' we just want to go onto the next one in that case. + */ + return ret; + } + } + } + + /* + * We would get here if there are no entries in the index (either no auxtrace buffers or + * no index). Fail silently as there is the possibility of queueing them in + * cs_etm__process_auxtrace_event() if etm->data_queued is still false; + * + * In that scenario, buffers will not be split by AUX records. + */ + return 0; +} + +static int cs_etm__queue_aux_records(struct perf_session *session) +{ + return perf_session__peek_events(session, session->header.data_offset, + session->header.data_size, + cs_etm__queue_aux_records_cb, NULL); +} + int cs_etm__process_auxtrace_info(union perf_event *event, struct perf_session *session) { @@ -2879,12 +3026,10 @@ int cs_etm__process_auxtrace_info(union perf_event *event, if (err) goto err_delete_thread; - err = auxtrace_queues__process_index(&etm->queues, session); + err = cs_etm__queue_aux_records(session); if (err) goto err_delete_thread; - etm->data_queued = etm->queues.populated; - return 0; err_delete_thread: -- 2.28.0

5 years, 5 months

[PATCH] coresight: Constify static attribute_group struct

by Shaokun Zhang

Make 'coresight_conns_group' const to allow the compiler to put it in read-only memory. Cc: Mathieu Poirier <mathieu.poirier(a)linaro.org> Cc: Suzuki K Poulose <suzuki.poulose(a)arm.com> Cc: Mike Leach <mike.leach(a)linaro.org> Cc: Leo Yan <leo.yan(a)linaro.org> Signed-off-by: Shaokun Zhang <zhangshaokun(a)hisilicon.com> --- drivers/hwtracing/coresight/coresight-sysfs.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/drivers/hwtracing/coresight/coresight-sysfs.c b/drivers/hwtracing/coresight/coresight-sysfs.c index 34d2a2d31d00..34e944efc357 100644 --- a/drivers/hwtracing/coresight/coresight-sysfs.c +++ b/drivers/hwtracing/coresight/coresight-sysfs.c @@ -28,7 +28,7 @@ static struct attribute *coresight_conns_attrs[] = { NULL, }; -static struct attribute_group coresight_conns_group = { +static const struct attribute_group coresight_conns_group = { .attrs = coresight_conns_attrs, .name = "connections", }; -- 2.7.4

5 years, 5 months

Jump to page:

2026

2025

2024

2023

2022

2021

2020

2019

2018

2017

2016

2015

CoreSight