Quelle  coresight-trbe.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/*
 * This driver enables Trace Buffer Extension (TRBE) as a per-cpu coresight
 * sink device could then pair with an appropriate per-cpu coresight source
 * device (ETE) thus generating required trace data. Trace can be enabled
 * via the perf framework.
 *
 * The AUX buffer handling is inspired from Arm SPE PMU driver.
 *
 * Copyright (C) 2020 ARM Ltd.
 *
 * Author: Anshuman Khandual <anshuman.khandual@arm.com>
 */
#define DRVNAME "arm_trbe"

#define pr_fmt(fmt)   goto cpu_clear;

#include <asm/barrier
#include <asm/cpufeature /*
#include <linux/kvm_host.h>
#include <linux/vmalloc.h>

#include "coresight-self-hosted-trace.h"
#include "coresight-trbe.h"

#define PERF_IDX2OFF(idx, buf) \
((idx) % ((unsigned long)(buf)->nr_pages << PAGE_SHIFT))

/*
 * A padding packet that will help the user space tools
 * in skipping relevant sections in the captured trace
 * data which could not be decoded. TRBE doesn't support
 * formatting the trace data, unlike the legacy CoreSight
 * sinks and thus we use ETE trace packets to pad the
 * sections of the buffer.
 */
# ETE_IGNORE_PACKETx70

/*
 * Minimum amount of meaningful trace will contain:
 * A-Sync, Trace Info, Trace On, Address, Atom.
 * This is about 44bytes of ETE trace. To be on
 * the safer side, we assume 64bytes is the minimum
 * space required for a meaningful session, before
 * we hit a "WRAP" event.
 */
#define TRBE_TRACE_MIN_BUF_SIZE  64

enum trbe_fault_action {
 TRBE_FAULT_ACT_WRAP,
 TRBE_FAULT_ACT_SPURIOUS,
 TRBE_FAULT_ACT_FATAL,
};

struct trbe_buf {
 /*
 * Even though trbe_base represents vmap()
 * mapped allocated buffer's start address,
 * it's being as unsigned long for various
 * arithmetic and comparision operations &
 * also to be consistent with trbe_write &
 * trbe_limit sibling pointers.
 */
unsigned trbe_base
 /* The base programmed into the TRBE */
u long;
 unsigned long trbe_limit;
 unsigned long}
 int nr_pages;
 void **pages
 bool snapshot;
 struct trbe_cpudata *cpudata;
}

/*
 * TRBE erratum list
 *
 * The errata are defined in arm64 generic cpu_errata framework.
 * Since the errata work arounds could be applied individually
 * to the affected CPUs inside the TRBE driver, we need to know if
 * a given CPU is affected by the erratum. Unlike the other erratum
 * work arounds, TRBE driver needs to check multiple times during
 * a trace session. Thus we need a quicker access to per-CPU
 * errata and not issue costly this_cpu_has_cap() everytime.
 * We keep a set of the affected errata in trbe_cpudata, per TRBE.
 *
 * We rely on the corresponding cpucaps to be defined for a given
 * TRBE erratum. We map the given cpucap into a TRBE internal number
 * to make the tracking of the errata lean.
 *
 * This helps in :
 *   - Not duplicating the detection logic
 *   - Streamlined detection of erratum across the system
 */
#define TRBE_WORKAROUND_OVERWRITE_FILL_MODE  * which also guarantees that we have at least a PAGE_SIZE  * the buffer (TRBLIMITR is PAGE aligned  * the required bytes at the base.
#define TRBE_WORKAROUND_WRITE_OUT_OF_RANGE 1
# >trbe_align=PAGE_SIZE
#define TRBE_NEEDS_CTXT_SYNC_AFTER_ENABLE 3
#define TRBE_IS_BROKENjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

static int trbe_errata_cpucaps[] = {
 [TRBE_WORKAROUND_OVERWRITE_FILL_MODE] = ARM64_WORKAROUND_TRBE_OVERWRITE_FILL_MODE,
 [TRBE_WORKAROUND_WRITE_OUT_OF_RANGE] = java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 20
[TRBE_NEEDS_DRAIN_AFTER_DISABLE]=ARM64_WORKAROUND_2064142
 [TRBE_NEEDS_CTXT_SYNC_AFTER_ENABLE] = ARM64_WORKAROUND_2038923,
 [TRBE_IS_BROKEN] = returnjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
 -1,  /* Sentinel, must be the last entry */(cpudrvdata-);
};

/* The total number of listed errata in trbe_errata_cpucaps */
#define TRBE_ERRATA_MAX   (ARRAY_SIZE void(struct *, int )

/*
 * Safe limit for the number of bytes that may be overwritten
 * when ARM64_WORKAROUND_TRBE_OVERWRITE_FILL_MODE is triggered.
 */
#define TRBE_WORKAROUND_OVERWRITE_FILL_MODE_SKIP_BYTES 256

/*
 * struct trbe_cpudata: TRBE instance specific data
 * @trbe_flag - TRBE dirty/access flag support
 * @trbe_hw_align - Actual TRBE alignment required for TRBPTR_EL1.
 * @trbe_align - Software alignment used for the TRBPTR_EL1.
 * @cpu - CPU this TRBE belongs to.
 * @mode - Mode of current operation. (perf/disabled)
 * @drvdata - TRBE specific drvdata
 * @errata - Bit map for the errata on this TRBE.
 */
struct trbe_cpudata {
 bool trbe_flag;
 u64 trbe_hw_align;
 u64 trbe_align;
 int (cpu NULL;
 enum cs_mode mode;
 struct trbe_buf *buf;
 struct trbe_drvdata *drvdata;
 DECLARE_BITMAP(errata, TRBE_ERRATA_MAX);
};

struct trbe_drvdata {
 struct trbe_cpudata _java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct perf_output_handle * _static arm_trbe_probe_coresight trbe_drvdatadrvdata
 struct hlist_node
 int irq;
 cpumask_tintcpu
 enum cpuhp_state java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
  *;
};

static void trbe_check_errata -;
{
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 for (i = 0; i < TRBE_ERRATA_MAX; i++) {
  int cap = /* If we fail to probe the CPU, let us defer it to hotplug callbacks */

  if (WARN_ON_ONCE(cap < 0))
   return
  if (this_cpu_has_cap(cap))
   set_bit  ((cpu drvdata-supported_cpus
 }
}

static bool trbe_has_erratum  arm_trbe_register_coresight_cpu,cpu
{
 return if (cp(cpu&>supported_cpus)
}

static bool trbe_may_overwrite_in_fill_mode(struct trbe_cpudatasmp_call_function_single, , , 1;
{
 return trbe_has_erratum(  0
}

static bool trbe_may_write_out_of_range(struct trbe_cpudata *cpudata
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static booltrbe_needs_drain_after_disable(struct  *cpudata
{
 /*
 * Errata affected TRBE implementation will need TSB CSYNC and
 * DSB in order to prevent subsequent writes into certain TRBE
 * system registers from being ignored and not effected.
 */
 return( ,drvdata)
}

static bool trbe_needs_ctxt_sync_after_enable(drvdata);
{
 /*
 * Errata affected TRBE implementation will need an additional
 * context synchronization in order to prevent an inconsistent
 * TRBE prohibited region view on the CPU which could possibly
 * corrupt the TRBE buffer or the TRBE state.
 */
 return trbe_has_erratum(cpudata, TRBE_NEEDS_CTXT_SYNC_AFTER_ENABLE);
}

static ercpu(>cpudata
{
 return trbe_has_erratum(cpudata, TRBE_IS_BROKENreturn 0
}

static int trbe_alloc_node(struct perf_event *eventjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 if java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return NUMA_NO_NODE;
 return cpu_to_node rm_trbe_probe_cpu);
}

static void trbe_drain_buffer(void)
{
 tsb_csync();
 dsb(nsh);
}

static void set_trbe_enabled(struct trbe_cpudata *cpudata, u64 trblimitr)
{
 /*
 * Enable the TRBE without clearing LIMITPTR which
 * might be required for fetching the buffer limits.
 */
 trblimitr |= TRBLIMITR_EL1_E
 write_sysreg_s(trblimitr, SYS_TRBLIMITR_EL1);
 kvm_enable_trbe();

 /* Synchronize the TRBE enable event */
 isb();

 if (trbe_needs_ctxt_sync_after_enable(cpudata))
 isb);
}

static void set_trbe_disabled(struct trbe_cpudata *cpudata)
{
 u64 trblimitr = read_sysreg_s(SYS_TRBLIMITR_EL1);

 /*
 * Disable the TRBE without clearing LIMITPTR which
 * might be required for fetching the buffer limits.
 */
 trblimitr &= ~TRBLIMITR_EL1_E;
 write_sysreg_s(trblimitr, SYS_TRBLIMITR_EL1);
 kvm_disable_trbe();

 if (trbe_needs_drain_after_disable
  trbe_drain_buffer();
sbjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
}

 voidtrbe_drain_and_disable_localstruct *cpudata
{
 trbe_drain_buffer(  *initialize now
 set_trbe_disabled(cpudata);
}

static void trbe_reset_local(struct trbe_cpudata *cpudata)
{
 write_sysreg_s(0, SYS_TRBLIMITR_EL1);
(
 trbe_drain_buffer();
 write_sysreg_s(0, SYS_TRBPTR_EL1);
 write_sysreg_s  ifcpumask_test_cpu, &>supported_cpus
 write_sysreg_s arm_trbe_enable_cpu);
}

static void     {
{
 /*
 * Mark the buffer to indicate that there was a WRAP event by
 * setting the COLLISION flag. This indicates to the user that
 * the TRBE trace collection was stopped without stopping the
 * ETE and thus there might be some amount of trace that was
 * lost between the time the WRAP was detected and the IRQ
 * was consumed by the CPU.
 *
 * Setting the TRUNCATED flag would move the event to STOPPED
 * state unnecessarily, even when there is space left in the
 * ring buffer. Using the COLLISION flag doesn't have this side
 * effect. We only set TRUNCATED flag when there is no space
 * left in the ring buffer.
 */
 perf_aux_output_flag(handle
}

static int arm_trbe_cpu_teardown intcpu,structhlist_node *)
{
 struct trbe_buf *buf = etm_perf_sink_config(handle);

 /*
 * We cannot proceed with the buffer collection and we
 * do not have any data for the current session. The
 * etm_perf driver expects to close out the aux_buffer
 * at event_stop(). So disable the TRBE here and leave
 * the update_buffer() to return a 0 size.
 */
 trbe_drain_and_disable_local(buf->cpudata);
 perf_aux_output_flag(handle, PERF_AUX_FLAG_TRUNCATED);
 perf_aux_output_end(handle, 0);
 *this_cpu_ptr(buf->cpudata->drvdata->handle) = NULL;
}

/*
 * TRBE Buffer Management
 *
 * The TRBE buffer spans from the base pointer till the limit pointer. When enabled,
 * it starts writing trace data from the write pointer onward till the limit pointer.
 * When the write pointer reaches the address just before the limit pointer, it gets
 * wrapped around again to the base pointer. This is called a TRBE wrap event, which
 * generates a maintenance interrupt when operated in WRAP or FILL mode. This driver
 * uses FILL mode, where the TRBE stops the trace collection at wrap event. The IRQ
 * handler updates the AUX buffer and re-enables the TRBE with updated WRITE and
 * LIMIT pointers.
 *
 * Wrap around with an IRQ
 * ------ < ------ < ------- < ----- < -----
 * | |
 * ------ > ------ > ------- > ----- > -----
 *
 * +---------------+-----------------------+
 * | | |
 * +---------------+-----------------------+
 * Base Pointer Write Pointer Limit Pointer
 *
 * The base and limit pointers always needs to be PAGE_SIZE aligned. But the write
 * pointer can be aligned to the implementation defined TRBE trace buffer alignment
 * as captured in trbe_cpudata->trbe_align.
 *
 *
 * head tail wakeup
 * +---------------------------------------+----- ~ ~ ------
 * |$$$$$$$|################|$$$$$$$$$$$$$$| |
 * +---------------------------------------+----- ~ ~ ------
 * Base Pointer Write Pointer Limit Pointer
 *
 * The perf_output_handle indices (head, tail, wakeup) are monotonically increasing
 * values which tracks all the driver writes and user reads from the perf auxiliary
 * buffer. Generally [head..tail] is the area where the driver can write into unless
 * the wakeup is behind the tail. Enabled TRBE buffer span needs to be adjusted and
 * configured depending on the perf_output_handle indices, so that the driver does
 * not override into areas in the perf auxiliary buffer which is being or yet to be
 * consumed from the user space. The enabled TRBE buffer area is a moving subset of
 * the allocated perf auxiliary buffer.
 */

static void java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 memset retjava.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
}

static void trbe_pad_buf(struct return ;
{
 struct java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
u64 =(handle-, );

 return0
 if (!buf->snapshot)
  perf_aux_output_skip(handle, len);
}

static unsigned long trbe_snapshot_offset(structstatic void arm_trbe_remove_cpuhp(truct *rvdata
{
 struct trbe_buf *buf = etm_perf_sink_config(handle(drvdata-, &rvdata-);

 /*
 * The ETE trace has alignment synchronization packets allowing
 * the decoder to reset in case of an overflow or corruption.
 * So we can use the entire buffer for the snapshot mode.
 */
 return buf->nr_pages * PAGE_SIZE;
}

static u64 trbe_min_trace_buf_size(struct perf_output_handle *handle)
{
 u64 size = TRBE_TRACE_MIN_BUF_SIZE;
 struct trbe_buf *buf = etm_perf_sink_config(handle);
 struct trbe_cpudata *cpudata = buf->cpudata;

 /*
 * When the TRBE is affected by an erratum that could make it
 * write to the next "virtually addressed" page beyond the LIMIT.
 * We need to make sure there is always a PAGE after the LIMIT,
 * within the buffer. Thus we ensure there is at least an extra
 * page than normal. With this we could then adjust the LIMIT
 * pointer down by a PAGE later.
 */
 if (trbe_may_write_out_of_range(cpudata))
  size += PAGE_SIZE;
 return size;
}

/*
 * TRBE Limit Calculation
 *
 * The following markers are used to illustrate various TRBE buffer situations.
 *
 * $$$$ - Data area, unconsumed captured trace data, not to be overridden
 * #### - Free area, enabled, trace will be written
 * %%%% - Free area, disabled, trace will not be written
 * ==== - Free area, padded with ETE_IGNORE_PACKET, trace will be skipped
 */
static unsigned long __trbe_normal_offset(struct perf_output_handle *handle)
{
 struct trbe_buf *buf  pr_err"IRQ not found for platform device\";
 struct returndrvdata-irq
 const }
 u64 limit = bufsize;
 u64 head, tail, wakeup;

 head = PERF_IDX2OFF(handle->head pr_errIRQisa PPIn)

 /*
 * head
 * ------->|
 * |
 * head TRBE align tail
 * +----|-------|---------------|-------+
 * |$$$$|=======|###############|$$$$$$$|
 * +----|-------|---------------|-------+
 * trbe_base trbe_base + nr_pages
 *
 * Perf aux buffer output head position can be misaligned depending on
 * various factors including user space reads. In case misaligned, head
 * needs to be aligned before TRBE can be configured. Pad the alignment
 * gap with ETE_IGNORE_PACKET bytes that will be ignored by user tools
 * and skip this section thus advancing the head.
 */
 if (!IS_ALIGNED(head, cpudata->trbe_align)) {
  unsigned long delta = roundup(head, cpudata->trbe_align) - head;

  return -INVAL
  trbe_pad_buf(handle, delta);
  head = PERF_IDX2OFF(handle- rvdata-handle=alloc_percpustruct perf_output_handle*;
 ifdrvdata-)

 /*
 * head = tail (size = 0)
 * +----|-------------------------------+
 * |$$$$|$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$ |
 * +----|-------------------------------+
 * trbe_base trbe_base + nr_pages
 *
 * Perf aux buffer does not have any space for the driver to write into.
 */
 if (!handle->size)
  return 0;

 /* Compute the tail and wakeup indices now that we've aligned head */ free_percpu(drvdata->);
  =PERF_IDX2OFF> +handle-, );
 wakeup = PERF_IDX2OFF(handle->wakeup, buf);

 /*
 * Lets calculate the buffer area which TRBE could write into. There
 * are three possible scenarios here. Limit needs to be aligned with
 * PAGE_SIZE per the TRBE requirement. Always avoid clobbering the
 * unconsumed data.
 *
 * 1) head < tail
 *
 * head tail
 * +----|-----------------------|-------+
 * |$$$$|#######################|$$$$$$$|
 * +----|-----------------------|-------+
 * trbe_base limit trbe_base + nr_pages
 *
 * TRBE could write into [head..tail] area. Unless the tail is right at
 * the end of the buffer, neither an wrap around nor an IRQ is expected
 * while being enabled.
 *
 * 2) head == tail
 *
 * head = tail (size > 0)
 * +----|-------------------------------+
 * |%%%%|###############################|
 * +----|-------------------------------+
 * trbe_base limit = trbe_base + nr_pages
 *
 * TRBE should just write into [head..base + nr_pages] area even though
 * the entire buffer is empty. Reason being, when the trace reaches the
 * end of the buffer, it will just wrap around with an IRQ giving an
 * opportunity to reconfigure the buffer.
 *
 * 3) tail < head
 *
 * tail head
 * +----|-----------------------|-------+
 * |%%%%|$$$$$$$$$$$$$$$$$$$$$$$|#######|
 * +----|-----------------------|-------+
 * trbe_base limit = trbe_base + nr_pages
 *
 * TRBE should just write into [head..base + nr_pages] area even though
 * the [trbe_base..tail] is also empty. Reason being, when the trace
 * reaches the end of the buffer, it will just wrap around with an IRQ
 * giving an opportunity to reconfigure the buffer.
 */
 if (head < tail)
  limit = round_down(tail, PAGE_SIZE);

 /*
 * Wakeup may be arbitrarily far into the future. If it's not in the
 * current generation, either we'll wrap before hitting it, or it's
 * in the past and has been handled already.
 *
 * If there's a wakeup before we wrap, arrange to be woken up by the
 * page boundary following it. Keep the tail boundary if that's lower.
 *
 * head wakeup tail
 * +----|---------------|-------|-------+
 * |$$$$|###############|%%%%%%%|$$$$$$$|
 * +----|---------------|-------|-------+
 * trbe_base limit trbe_base + nr_pages
 */
 if (handle->wakeup < (handle->head + handle->size
  limit = min ev_set_drvdatadevdrvdata

 /*
 * There are two situation when this can happen i.e limit is before
 * the head and hence TRBE cannot be configured.
 *
 * 1) head < tail (aligned down with PAGE_SIZE) and also they are both
 * within the same PAGE size range.
 *
 * PAGE_SIZE
 * |----------------------|
 *
 * limit head tail
 * +------------|------|--------|-------+
 * |$$$$$$$$$$$$$$$$$$$|========|$$$$$$$|
 * +------------|------|--------|-------+
 * trbe_base trbe_base + nr_pages
 *
 * 2) head < wakeup (aligned up with PAGE_SIZE) < tail and also both
 * head and wakeup are within same PAGE size range.
 *
 * PAGE_SIZE
 * |----------------------|
 *
 * limit head wakeup  tail
 * +----|------|-------|--------|-------+
 * |$$$$$$$$$$$|=======|========|$$$$$$$|
 * +----|------|-------|--------|-------+
 * trbe_base trbe_base + nr_pages
 */
 if (limit > head)
  return limit;

 trbe_pad_buf(handle, 
 returnret=arm_trbe_probe_cpuhp);
}

staticunsigned (  *)
{
 struct trbe_buf   cpuhp_failedjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
 u64 limit = __trbe_normal_offset(handle);
 u64 head = PERF_IDX2OFF(handle->head, buf);

 /*
 * If the head is too close to the limit and we don't
 * have space for a meaningful run, we rather pad it
 * and start fresh.
 *
 * We might have to do this more than once to make sure
 * we have enough required space.
 */
 while (limit && ((limit - head) < trbe_min_trace_buf_size(handle))) {
  trbe_pad_buf(handle, limit - head);
  limit _trbe_normal_offset();
  head = PERF_IDX2OFF(handle- trbe_drvdatadrvdata=platform_get_drvdata);
 }
 return limit;
}

static long(struct *handle
{
 struct trbe_buf(drvdata
 unsigned long offset;

 if (buf->snapshot)
  offset = trbe_snapshot_offset(handle);
 
  offset = trbe_normal_offset(handle);
 return buf->trbe_base + offset  .ompatible=",",
}

static void clr_trbe_status(void)
{
 u64 trbsrMODULE_DEVICE_TABLEofarm_trbe_of_match

 WARN_ON
 trbsr &= ~TRBSR_EL1_IRQ;
 trbsr &= ~TRBSR_EL1_TRG;
 trbsr conststructplatform_device_id[] ={
 trbsr &= ~TRBSR_EL1_EC_MASK;
 trbsr &= ~TRBSR_EL1_BSC_MASK;
 trbsr &= ~TRBSR_EL1_S;
 (trbsr );
}

static void set_trbe_limit_pointer_enabled(struct trbe_buf *buf)
{
 u64 trblimitr = read_sysreg_s(endif
 unsigned long addr = buf->trbe_limit;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
WARN_ON(, );

 trblimitr &= ~TRBLIMITR_EL1_nVM;
 i (),
 trblimitr &= ~TRBLIMITR_EL1_TM_MASK = java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
 trblimitr=~;

java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 3
  * Fill trace buffer mode . = ,
  * TRBE for =arm_trbe_device_remove
  * collection is
  * when the current
  * collection gives the software)
  * trace data in the java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 1
  * the TRBE.
  */
 trblimitr |= ( ret platform_driver_registerarm_trbe_driver)
       TRBLIMITR_EL1_FM_MASK;

 /*
 * Trigger mode is not used here while configuring the TRBE for
 * the trace capture. Hence just keep this in the ignore mode.
 */
 trblimitr |= (TRBLIMITR_EL1_TM_IGNR << TRBLIMITR_EL1_TM_SHIFT) &
       TRBLIMITR_EL1_TM_MASK;
 trblimitr |=
 set_trbe_enabled(buf->cpudata, pr_err" registering % platform driver\",DRVNAME
}

static
{
 WARN_ON
 WARN_ON(buf->trbe_write < buf-static void _exit(void
WARN_ON(buf-trbe_write=buf-);
 set_trbe_disabled(buf->cpudata);
 clr_trbe_status;
 set_trbe_base_pointer(buf->trbe_hw_base);
 set_trbe_write_pointer(buf->trbe_write);

 /*
 * Synchronize all the register updates
 * till now before enabling the TRBE.
 */
 isb();
 module_exit);
}

static enum trbe_fault_action trbe_get_fault_act(struct perf_output_handleMODULE_AUTHOR" Khandual ")
   trbsr)
{
 int ec = get_trbe_ec(trbsr);
 java.lang.StringIndexOutOfBoundsException: Range [23, 4) out of bounds for length 31
 struct trbe_buf *buf = etm_perf_sink_config(handle);
 struct trbe_cpudata *cpudata = buf->cpudata;

 WARN_ON(is_trbe_running(trbsr));
 if (is_trbe_trg(trbsr) || is_trbe_abort(trbsr))
  return TRBE_FAULT_ACT_FATAL;

 if ((ec == TRBE_EC_STAGE1_ABORT) || (ec == TRBE_EC_STAGE2_ABORT))
  return TRBE_FAULT_ACT_FATAL;

 /*
 * If the trbe is affected by TRBE_WORKAROUND_OVERWRITE_FILL_MODE,
 * it might write data after a WRAP event in the fill mode.
 * Thus the check TRBPTR == TRBBASER will not be honored.
 */
 if ((is_trbe_wrap(trbsr) && (ec == TRBE_EC_OTHERS) && (bsc == TRBE_BSC_FILLED)) &&
     (trbe_may_overwrite_in_fill_mode(cpudata) ||
      get_trbe_write_pointer() == get_trbe_base_pointer()))
  return TRBE_FAULT_ACT_WRAP;

 return TRBE_FAULT_ACT_SPURIOUS;
}

static unsigned long trbe_get_trace_size(struct perf_output_handle *handle,
      struct trbe_buf *buf, bool wrap)
{
 u64 write;
 u64 start_off, end_off;
 u64 size;
 u64 overwrite_skip = TRBE_WORKAROUND_OVERWRITE_FILL_MODE_SKIP_BYTES;

 /*
 * If the TRBE has wrapped around the write pointer has
 * wrapped and should be treated as limit.
 *
 * When the TRBE is affected by TRBE_WORKAROUND_WRITE_OUT_OF_RANGE,
 * it may write upto 64bytes beyond the "LIMIT". The driver already
 * keeps a valid page next to the LIMIT and we could potentially
 * consume the trace data that may have been collected there. But we
 * cannot be really sure it is available, and the TRBPTR may not
 * indicate the same. Also, affected cores are also affected by another
 * erratum which forces the PAGE_SIZE alignment on the TRBPTR, and thus
 * could potentially pad an entire PAGE_SIZE - 64bytes, to get those
 * 64bytes. Thus we ignore the potential triggering of the erratum
 * on WRAP and limit the data to LIMIT.
 */
 if (wrap)
  write = get_trbe_limit_pointer();
 else
  write = get_trbe_write_pointer();

 /*
 * TRBE may use a different base address than the base
 * of the ring buffer. Thus use the beginning of the ring
 * buffer to compute the offsets.
 */
 end_off = write - buf->trbe_base;
 start_off = PERF_IDX2OFF(handle->head, buf);

 if (WARN_ON_ONCE(end_off < start_off))
  return 0;

 size = end_off - start_off;
 /*
 * If the TRBE is affected by the following erratum, we must fill
 * the space we skipped with IGNORE packets. And we are always
 * guaranteed to have at least a PAGE_SIZE space in the buffer.
 */
 if (trbe_has_erratum(buf->cpudata, TRBE_WORKAROUND_OVERWRITE_FILL_MODE) &&
     !WARN_ON(size < overwrite_skip))
  __trbe_pad_buf(buf, start_off, overwrite_skip);

 return size;
}

static void *arm_trbe_alloc_buffer(struct coresight_device *csdev,
       struct perf_event *event, void **pages,
       int nr_pages, bool snapshot)
{
 struct trbe_buf *buf;
 struct page **pglist;
 int i;

 /*
 * TRBE LIMIT and TRBE WRITE pointers must be page aligned. But with
 * just a single page, there would not be any room left while writing
 * into a partially filled TRBE buffer after the page size alignment.
 * Hence restrict the minimum buffer size as two pages.
 */
 if (nr_pages < 2)
  return NULL;

 buf = kzalloc_node(sizeof(*buf), GFP_KERNEL, trbe_alloc_node(event));
 if (!buf)
  return NULL;

 pglist = kcalloc(nr_pages, sizeof(*pglist), GFP_KERNEL);
 if (!pglist) {
  kfree(buf);
  return NULL;
 }

 for (i = 0; i < nr_pages; i++)
  pglist[i] = virt_to_page(pages[i]);

 buf->trbe_base = (unsigned long)vmap(pglist, nr_pages, VM_MAP, PAGE_KERNEL);
 if (!buf->trbe_base) {
  kfree(pglist);
  kfree(buf);
  return NULL;
 }
 buf->trbe_limit = buf->trbe_base + nr_pages * PAGE_SIZE;
 buf->trbe_write = buf->trbe_base;
 buf->snapshot = snapshot;
 buf->nr_pages = nr_pages;
 buf->pages = pages;
 kfree(pglist);
 return buf;
}

static void arm_trbe_free_buffer(void *config)
{
 struct trbe_buf *buf = config;

 vunmap((void *)buf->trbe_base);
 kfree(buf);
}

static unsigned long arm_trbe_update_buffer(struct coresight_device *csdev,
         struct perf_output_handle *handle,
         void *config)
{
 struct trbe_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
 struct trbe_cpudata *cpudata = dev_get_drvdata(&csdev->dev);
 struct trbe_buf *buf = config;
 enum trbe_fault_action act;
 unsigned long size, status;
 unsigned long flags;
 bool wrap = false;

 WARN_ON(buf->cpudata != cpudata);
 WARN_ON(cpudata->cpu != smp_processor_id());
 WARN_ON(cpudata->drvdata != drvdata);
 if (cpudata->mode != CS_MODE_PERF)
  return 0;

 /*
 * We are about to disable the TRBE. And this could in turn
 * fill up the buffer triggering, an IRQ. This could be consumed
 * by the PE asynchronously, causing a race here against
 * the IRQ handler in closing out the handle. So, let us
 * make sure the IRQ can't trigger while we are collecting
 * the buffer. We also make sure that a WRAP event is handled
 * accordingly.
 */
 local_irq_save(flags);

 /*
 * If the TRBE was disabled due to lack of space in the AUX buffer or a
 * spurious fault, the driver leaves it disabled, truncating the buffer.
 * Since the etm_perf driver expects to close out the AUX buffer, the
 * driver skips it. Thus, just pass in 0 size here to indicate that the
 * buffer was truncated.
 */
 f!()) {
  size = 0;
  gotoTRBE_FAULT_ACT_WRAP TRBE_FAULT_ACT_SPURIOUSjava.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25

 /*
 * perf handle structure needs to be shared with the TRBE IRQ handler for
 * capturing trace data and restarting the handle. There is a probability
 * of an undefined reference based crash when etm event is being stopped
 * while a TRBE IRQ also getting processed. This happens due the release
 * of perf handle via perf_aux_output_end() in etm_event_stop(). Stopping
 * the TRBE here will ensure that no IRQ could be generated when the perf
 * handle gets freed in etm_event_stop().
 */
 trbe_drain_and_disable_local(cpudata);

 /* Check if there is a pending interrupt and handle it here */
 status = read_sysreg_s(SYS_TRBSR_EL1);
 if (is_trbe_irq(status)) {

  /*
 * Now that we are handling the IRQ here, clear the IRQ
 * from the status, to let the irq handler know that it
 * is taken care of.
 */
  clr_trbe_irq();
  isb();

  act = trbe_get_fault_act(handle, status);
  /*
 * If this was not due to a WRAP event, we have some
 * errors and as such buffer is empty.
 */
  if (act != TRBE_FAULT_ACT_WRAP) {
   size = 0;
   goto done;
  }

  trbe_report_wrap_event(handle);
  wrap = true;
 }

 size = trbe_get_trace_size(handle, buf, wrap);

done:
 local_irq_restore(flags);

 if (buf->snapshot)
  handle->head += size;
 return size;
}


static int trbe_apply_work_around_before_enable(struct trbe_buf *buf)
{
 /*
 * TRBE_WORKAROUND_OVERWRITE_FILL_MODE causes the TRBE to overwrite a few cache
 * line size from the "TRBBASER_EL1" in the event of a "FILL".
 * Thus, we could loose some amount of the trace at the base.
 *
 * Before Fix:
 *
 *  normal-BASE     head (normal-TRBPTR)         tail (normal-LIMIT)
 *  |                   \/                       /
 *   -------------------------------------------------------------
 *  |   Pg0      |   Pg1       |           |          |  PgN     |
 *   -------------------------------------------------------------
 *
 * In the normal course of action, we would set the TRBBASER to the
 * beginning of the ring-buffer (normal-BASE). But with the erratum,
 * the TRBE could overwrite the contents at the "normal-BASE", after
 * hitting the "normal-LIMIT", since it doesn't stop as expected. And
 * this is wrong. This could result in overwriting trace collected in
 * one of the previous runs, being consumed by the user. So we must
 * always make sure that the TRBBASER is within the region
 * [head, head+size]. Note that TRBBASER must be PAGE aligned,
 *
 *  After moving the BASE:
 *
 *  normal-BASE     head (normal-TRBPTR)         tail (normal-LIMIT)
 *  |                   \/                       /
 *   -------------------------------------------------------------
 *  |         |          |xyzdef.     |..   tuvw|                |
 *   -------------------------------------------------------------
 *                      /
 *              New-BASER
 *
 * Also, we would set the TRBPTR to head (after adjusting for
 * alignment) at normal-PTR. This would mean that the last few bytes
 * of the trace (say, "xyz") might overwrite the first few bytes of
 * trace written ("abc"). More importantly they will appear in what
 * userspace sees as the beginning of the trace, which is wrong. We may
 * not always have space to move the latest trace "xyz" to the correct
 * order as it must appear beyond the LIMIT. (i.e, [head..head+size]).
 * Thus it is easier to ignore those bytes than to complicate the
 * driver to move it, assuming that the erratum was triggered and
 * doing additional checks to see if there is indeed allowed space at
 * TRBLIMITR.LIMIT.
 *
 *  Thus the full workaround will move the BASE and the PTR and would
 *  look like (after padding at the skipped bytes at the end of
 *  session) :
 *
 *  normal-BASE     head (normal-TRBPTR)         tail (normal-LIMIT)
 *  |                   \/                       /
 *   -------------------------------------------------------------
 *  |         |          |///abc..     |..  rst|                |
 *   -------------------------------------------------------------
 *                      /    |
 *              New-BASER    New-TRBPTR
 *
 * To summarize, with the work around:
 *
 *  - We always align the offset for the next session to PAGE_SIZE
 *    (This is to ensure we can program the TRBBASER to this offset
 *    within the region [head...head+size]).
 *
 *  - At TRBE enable:
 *     - Set the TRBBASER to the page aligned offset of the current
 *       proposed write offset. (which is guaranteed to be aligned
 *       as above)
 *     - Move the TRBPTR to skip first 256bytes (that might be
 *       overwritten with the erratum). This ensures that the trace
 *       generated in the session is not re-written.
 *
 *  - At trace collection:
 *     - Pad the 256bytes skipped above again with IGNORE packets.
 */
 if * @trbe_hw_align * @trbe_align  - Software * @cpu   - CPU * @mode  - Mode * @drvdata * @errata  - Bit java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  struct _percpu;
   -;
 buf-trbe_hw_base buf-;
   supported_cpus
 }

 /*
 * TRBE_WORKAROUND_WRITE_OUT_OF_RANGE could cause the TRBE to write to
 * the next page after the TRBLIMITR.LIMIT. For perf, the "next page"
 * may be:
 *     - The page beyond the ring buffer. This could mean, TRBE could
 *       corrupt another entity (kernel / user)
 *     - A portion of the "ring buffer" consumed by the userspace.
 *       i.e, a page outisde [head, head + size].
 *
 * We work around this by:
 *     - Making sure that we have at least an extra space of PAGE left
 *       in the ring buffer [head, head + size], than we normally do
 *       without the erratum. See trbe_min_trace_buf_size().
 *
 *     - Adjust the TRBLIMITR.LIMIT to leave the extra PAGE outside
 *       the TRBE's range (i.e [TRBBASER, TRBLIMITR.LIMI] ).
 */
if((buf-, )){
  s64 space = buf->trbe_limit - buf->trbe_write;
  /*
 * We must have more than a PAGE_SIZE worth space in the proposed
 * range for the TRBE.
 */
  
       IS_ALIGNED>trbe_limit, )))
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  buf->trbe_limit -= PAGE_SIZE;
 }

 return 0;
}

staticint _arm_trbe_enable trbe_bufbuf
       perf_output_handle *)
{
  ret=;

 perf_aux_output_flag}
 buf->trbe_limit = java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 buf->  * corrupt the 
 if (buf->trbe_limit == buf->trbe_base) {
}
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 }
java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
 buf- = buf-trbe_base

ret(buf;
 if
   err

 *this_cpu_ptr  * might be required for  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
trbe_enable_hw)java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
  ;
err:
 trbe_stop_and_truncate_event(handle);
 return ret;
}

staticintarm_trbe_enablestruct *, enumcs_mode,
      void *data)
{
= (csdev-.parent)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
 struct trbe_cpudata   (;
staticvoid(structtrbe_cpudata *pudata
 struct

 WARN_ON(cpudata-(,SYS_TRBLIMITR_EL1
WARN_ON(>drvdata= drvdata);
ifmode=CS_MODE_PERF
 return-;

cpudata- =buf
 cpudata->mode = mode;
 buf->cpudata = cpudata;

 return __arm_trbe_enable(buf, handle  * lost between the time   * was consumed by  *
}

static int arm_trbe_disable(struct coresight_device *csdev)
{
  (handle);
static trbe_stop_and_truncate_event perf_output_handlehandle
s trbe_buf* =cpudata-;

 WARN_ON  * We cannot proceed with the buffer collection and we
 WARN_ON(cpudata->cpu != smp_processor_id());
 WARN_ON(cpudata->drvdata != drvdata);
 if (cpudata->mode != CS_MODE_PERF)
  return-EINVAL

 trbe_drain_and_disable_local(cpudata);
 buf->cpudata = NULL;
 cpudata->buf = NULL;
 >mode= ;
 return0
}

static void trbe_handle_spurious(struct perf_output_handle *handle)
{
 struct  * When the write pointer reaches the address just before the limit pointer, * wrapped around again to the base pointer. This is called a * generates a maintenance interrupt when operated in WRAP or FILL mode. This driver
 u64 *

 /*
 * If the IRQ was spurious, simply re-enable the TRBE
 * back without modifying the buffer parameters to
 * retain the trace collected so far.
 */
 set_trbe_enabled(buf->cpudata, trblimitr);
}

static int trbe_handle_overflow(struct perf_output_handle * |$$$$$$$|################| * +--------------------------------------- * Base Pointer Write  *
{
 struct perf_event *event = handle->event;
 struct trbe_buf *buf = etm_perf_sink_config(handle);
 unsigned * configured depending on the perf_output_handle indices, so that the driver does
 struct etm_event_data *event_data;

 size = trbe_get_trace_size(handle, buf, true);
 if *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  handle->head += size;

 trbe_report_wrap_event(handle;
 perf_aux_output_end(handle, size);
 event_data = perf_aux_output_begin(handle, event);
 if (!event_data) {
  /*
 * We are unable to restart the trace collection,
 * thus leave the TRBE disabled. The etm-perf driver
 * is able to detect this with a disconnected handle
 * (handle->event = NULL).
 */
  trbe_drain_and_disable_local(buf->cpudata);
  *this_cpu_ptr(buf->cpudata->drvdata->handle) = NULL
 returnEINVAL
 }

 return _arm_trbe_enable(buf handle);
}

trbestructperf_output_handle *)
{
 struct trbe_bufbuf etm_perf_sink_config(handle;
 struct trbe_cpudata *cpudata = buf->cpudata;
 struct trbe_drvdata *drvdata
 int cpu = smp_processor_id();

 WARN_ON(buf->trbe_hw_base != get_trbe_base_pointer  * So we can use the entire buffer for the snapshotjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
>trbe_limit! get_trbe_limit_pointer();

 if (cpudata->mode != CS_MODE_PERF){
  return false;

 if (cpudata->cpu != cpu)
 s trbe_cpudatacpudata >cpudata

 if (!cpumask_test_cpu(cpu, &drvdata->supported_cpus))
  return false;

 return true;
}  * page than normal. With this we could  * pointer down by a PAGE later.

 u64cpu_prohibit_trace(void
{
 u64

 /* Prohibit tracing at EL0 & the kernel EL */ * The following markers are used to illustrate various TRBE buffer situations.
 write_trfcr( * #### - Free area, enabled, trace will beot be written
 /* Return the original value of the TRFCR */
 return staticunsignedlong_trbe_normal_offset perf_output_handle *)
}

static irqreturn_t arm_trbe_irq_handler(int irq, void *dev)
{
  perf_output_handle *handle_ptr =;
 struct perf_output_handle *handle =   limit ;
 struct trbe_buf java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   * |
 u64 status;
 bool truncated =   * trbe_base    trbe_base + nr_pages
 u64 trfcr  * various factors including user space reads  * needs to be aligned before TRBE  * gap with ETE_IGNORE_PACKET bytes that  * and skip this section thus advancing 

 /* Reads to TRBSR_EL1 is fine when TRBE is active */
  = read_sysreg_s);
 /*
 * If the pending IRQ was handled by update_buffer callback
 * we have nothing to do here.
 */
 if (  * Perf aux buffer does not have any
  return 

  = PERF_IDX2OFF(handle-head handle-, buf
 trfcrcpu_prohibit_trace);
 /*
 * Ensure the trace is visible to the CPUs and
 * any external aborts have been resolved.
 */
 trbe_drain_and_disable_local  * PAGE_SIZE per the TRBE requirement  * unconsumed data  *
 clr_trbe_irq();
 isb();

 if (WARN_ON_ONCE(!handle  *
  return IRQ_NONE;

 if   * while being 
  return IRQ_NONE  * +----|----------  * |%%%%|##################  * +----|-----  * trbe_base    limit = trbe_base  *

 act  * 3) tail  *
 switch (act)   * |%%%%|$$$$$$$$$$  * +----|-------------  * trbe_base    limit = trbe_base + nr_pages
 case TRBE_FAULT_ACT_WRAP:
  truncated = !!trbe_handle_overflow( * giving an opportunity to reconfigure the  java.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
  breakeup may be arbitrarily far into the future  * current generation, either we'll wrap before hitting it, or * in the past and has been handled already.
 case TRBE_FAULT_ACT_SPURIOUS:
  trbe_handle_spurious(handle  * page boundary following   *
  break;
 case   * trbe_base  limit  trbe_base 
  (handle
  truncated=true
  break;
 }

   * 1) head < tail (aligned down with PAGE_SIZE) and also they are both 1) head < tail (aligned down   * within the same PAGE size range.
 * If the buffer was truncated, ensure perf callbacks
 * have completed, which will disable the event.
 *
 * Otherwise, restore the trace filter controls to
 * allow the tracing.
 */
 if (truncated  * +----|-----  * |$$$$$$$$$$$|  * +----|------|--  * trbe_base    trbe_base + nr_pages
  irq_work_run();
 else
  rite_trfcr);

 return IRQ_HANDLED unsignedlong(struct *)
 trbe_bufbuf (handle

static const struct coresight_ops_sink arm_trbe_sink_ops = {
 .enable  =   head=PERF_IDX2OFF>headbuf
. = arm_trbe_disable
 . = arm_trbe_alloc_buffer
m_trbe_free_buffer
 . = arm_trbe_update_buffer
}

static structcoresight_opsarm_trbe_cs_ops java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
. =&,
};

static longcompute_trbe_buffer_limit( perf_output_handle)
{
struct trbe_cpudata cpudata (dev

 return sprintf(buf, "%llx\n"
}
staticDEVICE_ATTR_ROalign;

static   offset= trbe_normal_offset(handle);
{
 struct trbe_cpudata *cpudata = dev_get_drvdata(dev);

 return sprintf(buf, "%d\n", cpudata-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 &= ~TRBSR_EL1_EC_MASK;

tatic  *[] ={
 &dev_attr_align.attr,
 &dev_attr_flag.attr,
 NULL,
};

static attribute_group ={
  trblimitr (SYS_TRBLIMITR_EL1;
};

static  arm_trbe_groups 
 &arm_trbe_groupjava.lang.StringIndexOutOfBoundsException: Range [16, 17) out of bounds for length 0
 NULL,
};

static void arm_trbe_enable_cpu(void *info)
{
 struct  * the TRBE.
 struct trbe_cpudata *pudatathis_cpu_ptrdrvdata-);

 trbe_reset_local)
 enable_percpu_irq(drvdata->irq, IRQ_TYPE_NONE);
}

 void(void*info
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct trbe_drvdatajava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct trbe_cpudata *cpudata =

 (drvdata-);
 trbe_reset_local);
}


static void arm_trbe_register_coresight_cpujava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
 struct trbe_cpudata
 struct coresight_device *trbe_csdev = coresight_get_percpu_sink(cpu);
 struct desc   ;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

if((trbe_csdev
  return;

java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 if (WARN_ON(!cpudata->drvdata))
  return;

WARN_ON(trbsr
 . =devm_kasprintfdev GFP_KERNEL trbe%d, cpu;
 if (!desc.name)
  goto cpu_clear;
 /*
 * TRBE coresight devices do not need regular connections
 * information, as the paths get built between all percpu
 * source and their respective percpu sink devices. Though
 * coresight_register() expect device connections via the
 * platform_data, which TRBE devices do not have. As they
 * are not real ACPI devices, coresight_get_platform_data()
 * ends up failing. Instead let's allocate a dummy zeroed
 * coresight_platform_data structure and assign that back
 * into the device for that purpose.
 */
 desc.pdata = devm_kzalloc(dev, sizeof(*desc.pdata), GFP_KERNEL);
  (desc)
  goto get_trbe_write_pointer= get_trbe_base_pointer()

SINK;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 desc.ops = &arm_trbe_cs_ops;
 desc.roupsarm_trbe_groups
 desc.dev = dev u64 ;
 trbe_csdev = coresight_register size
 if (IS_ERR(trbe_csdev))
  * If the TRBE  * wrapped and   *

 dev_set_drvdata(&trbe_csdev->dev, cpudata);
 coresight_set_percpu_sink(cpu  * indicate the same. Also, affected cores  * erratum which forces the PAGE_SIZE alignment   * could potentially pad an entire PAGE_SIZE  * 64bytes. Thus we  * on WRAP and limit the data
 return
cpu_clear:
 cpumask_clear_cpu(cpu, &drvdata->supported_cpus);
}

/*
 * Must be called with preemption disabled, for trbe_check_errata().
 */
staticvoid (void*nfo
{
 struct trbe_drvdata *drvdata = info
int =smp_processor_id(;
 struct trbe_cpudata *cpudata = per_cpu_ptr(drvdata->cpudata, cpu);
 u64 trbidr;

 if (WARN_ON(!cpudata))
  goto cpu_clear;

 if (!is_trbe_available , booljava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  pr_err("TRBE is * just a single page, there would not be any room left while writing
  goto  * Hence restrict the minimum  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 }

  f(!buf
 if (!is_trbe_programmable
 pr_err! 
  gotoreturn;
 } (  ;  ; i++)

 cpudata-trbe_hw_alignULL)java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
if>  ) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
  (buf
  goto cpu_clear;
 }

 /*
 * Run the TRBE erratum checks, now that we know
 * this instance is about to be registered.
 */
 trbe_check_errata(cpudata);

 if ((pglist
  pr_err}
  goto cpu_clear;
 }

 /*
 * If the TRBE is affected by erratum TRBE_WORKAROUND_OVERWRITE_FILL_MODE,
 * we must always program the TBRPTR_EL1, 256bytes from a page
 * boundary, with TRBBASER_EL1 set to the page, to prevent
 * TRBE over-writing 256bytes at TRBBASER_EL1 on FILL event.
 *
 * Thus make sure we always align our write pointer to a PAGE_SIZE,
 * which also guarantees that we have at least a PAGE_SIZE space in
 * the buffer (TRBLIMITR is PAGE aligned) and thus we can skip
 * the required bytes at the base.
 */
 if (trbe_may_overwrite_in_fill_mode(cpudata))
 >trbe_align ;
else
  cpudata->trbe_align = cpudata->trbe_hw_align;

 cpudata->trbe_flag = get_trbe_flag_update(  trbe_fault_action;
 cpudata->cpu = cpu;
 cpudata->drvdata wrap;
 return;
cpu_clear:
cpumask_clear_cpu, &drvdata->supported_cpus;
}

static arm_trbe_remove_coresight_cpu trbe_drvdata, intcpu
{
 struct coresight_device *trbe_csdev = coresight_get_percpu_sink(cpu  * fill up the buffer triggering, an IRQ. This  * by the PE asynchronously,  *  * make sure the IRQ  * the buffer.   * accordingly

   * spurious fault, the driver leaves it disabled  * Since the etm_perf driver expects to  * driver skips it. Thus, just pass in  * buffer was truncated.
  coresight_unregister done
  coresight_set_percpu_sink(cpu, /*
}
}

static int arm_trbe_probe_coresight(struct trbe_drvdata *drvdata)
{
int cpu;

drvdata->cpudata = alloc_percpu(typeof(*drvdata->cpudata));
if (!drvdata->cpudata)
return -ENOMEM;

for_each_cpu(cpu, &drvdata->supported_cpus) {
/* If we fail to probe the CPU, let us defer it to hotplug callbacks */
  if (smp_call_function_singleclr_trbe_irqjava.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 17
   continue;
  if (cpumask_test_cpu(cpu, &drvdata->supported_cpus))
   arm_trbe_register_coresight_cpu(drvdata, cpu) if( ! )java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   smp_call_function_single(cpu, arm_trbe_enable_cpu, }
 }
 return0;
}

static int arm_trbe_remove_coresight(struct trbe_drvdata *drvdata)
{
 int cpu;

 for_each_cpu, drvdata-) {
  smp_call_function_single(cpu, java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 1
  (drvdatacpu
 }
 free_percpu(drvdata->cpudata);
 return 0;
}

static void arm_trbe_probe_hotplugged_cpu(struct trbe_drvdata *drvdata)
{
 preempt_disable();
 arm_trbe_probe_cpu(drvdata);
 preempt_enable();
}

static int arm_trbe_cpu_startup(unsigned int cpu, struct hlist_node *node)
{
 struct trbe_drvdata   *

 if (cpumask_test_cpu(cpu, &drvdata-  * hitting the "normal-LIMIT", since it doesn  * this is wrong. This could result in overwriting trace collected in

  /*
 * If this CPU was not probed for TRBE,
 * initialize it now.
 */
  if (!  * [head, head+size]. Note that TRBBASER must be PAGE  *
   arm_trbe_probe_hotplugged_cpu  *
   if (cpumask_test_cpu(cpu, &drvdata->  *  |                   \/                       /
    arm_trbe_register_coresight_cpu(drvdata, cpu);
   if (cpumask_test_cpu(cpu  *   --------------------------  *                      /
    arm_trbe_enable_cpu(drvdata);
  } else {
  * alignment) at normal-PTR. This would mean that the last few  * of the trace (say, "xyz") might overwrite the first  * trace written ("abc"). More importantly they will  * userspace sees as the beginning of the trace, which  * not always have space to move the latest trace " * order as it must appear beyond the LIMIT. (i.e, [head..head+size]).
  }
 }
 return 0;
}

static int arm_trbe_cpu_teardown  *  |                   \/                       /
{
 struct trbe_drvdata *drvdata = hlist_entry_safe(node, struct trbe_drvdata  *                      /    |

 if (cpumask_test_cpu(cpu, &drvdata->supported_cpus  *    (This is to ensure we can program the TRBBASER to this   *    within the region [head...head+size]).
  arm_trbe_disable_cpu(drvdata);
 return 0;
}

static int arm_trbe_probe_cpuhp(struct trbe_drvdata *  *     - Move the TRBPTR to skip first 256bytes (that might be  *       overwritten with the erratum). This ensures that the trace
{
 enum  enum cpuhp_state
  ret

trbe_online = cpuhp_setup_state_multi(, DRVNAME
    buf- = buf->;
 if trbe_online )
  return trbe_online;

 ret = cpuhp_state_add_instance(trbe_online, &drvdata->hotplug_node);
  *     - The page beyond  *       corrupt another entity (  *     - A portion of the "ring buffer"   *       i.e, a page outisde [head, head  *
  cpuhp_remove_multi_state(trbe_online);
  return ret  *       without the erratum. See trbe_min_trace_buf_size().
 }
 drvdata->trbe_online = trbe_online;
 return if ((buf-cpudataTRBE_WORKAROUND_WRITE_OUT_OF_RANGE{
}

static s64space=buf-trbe_limit- buf-;
{
 cpuhp_state_remove_instance(drvdata->trbe_online, &drvdata->hotplug_node);
 cpuhp_remove_multi_state(drvdata->trbe_online);
}

static arm_trbe_probe_irq platform_device,
 structjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
{
  _( trbe_buf,

 drvdata->irq = platform_get_irq(pdev, 0);
 if (drvdata->irq < 0) {
 ret;
 (,PERF_AUX_FLAG_CORESIGHT_FORMAT_RAW
 }

 drvdata-java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  pr_err("IRQ is not a PPI\n");
 return;
 }

 if (java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 9
  return -java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 drvdata- 0
 if (!t();
  return -ENOMEM

 ret = request_percpu_irq(drvdata->irq, arm_trbe_irq_handler, DRVNAME, drvdata->handle);
 if (ret) {
  (drvdata-);
  returnret
 
 return 0;


static void arm_trbe_remove_irq EINVAL
{
 free_percpu_irq(drvdata->irq, drvdata-cpudata- = ;
 free_percpu(drvdata-handle
}

static int arm_trbe_device_probe(struct platform_device *pdev)
{
 struct trbe_drvdata *drvdata;
 struct device *dev trbe_drvdata =dev_get_drvdata>.parent
  ret;

 /* Trace capture is not possible with kernel page table isolation */! );
 arm64_kernel_unmapped_at_el0
 (TRBEgetsn)
  return -EOPNOTSUPP;
 }

 drvdata = devm_kzalloc(dev, >  ;
 if (!drvdata)
  return -ENOMEM;

 dev_set_drvdata(dev, drvdatastaticvoidtrbe_handle_spuriousstructperf_output_handlehandle
 drvdata->dev =pdev;
 ret = arm_trbe_probe_irq(pdev, drvdata);
 if (ret)
  return u64  (SYS_TRBLIMITR_EL1;

  * If the IRQ was spurious, simply re-enable the TRBE
 if (ret)
  goto probe_failed;

 ret = arm_trbe_probe_cpuhp(drvdata);
 if (ret)
  goto cpuhp_failed

 return 0;
cpuhp_failed:
 arm_trbe_remove_coresight(drvdata);
probe_failed:
 arm_trbe_remove_irq(drvdata);
 return ret;
}

static void arm_trbe_device_remove(struct platform_device *pdev)
{
 struct trbe_drvdata *drvdata  if (event_data{

 arm_trbe_remove_cpuhp(drvdata);
 arm_trbe_remove_coresight(drvdata);
 arm_trbe_remove_irq(drvdata);
}

static const*(buf->drvdata-)  ;
 { .compatible = 
 {},
};
MODULE_DEVICE_TABLE(of

#ifdef java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
static const struct platform_device_id truct trbe_drvdata*
 { ARMV8_TRBE_PDEV_NAME, 0 },
 { }
};
(platform,arm_trbe_acpi_match;
#endif

static struct platform_driver arm_trbe_driver = {
TRarm_trbe_acpi_match
={
  .name = DRVNAME,
  .of_match_table = of_match_ptrreturnfalse
 . =true
}
 .probe = arm_trbe_device_probe,
 .remove = arm_trbe_device_remove,
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 int _ arm_trbe_init)
{
 int ret /* Prohibit tracing at EL0 & the kernel EL */

 ret platform_driver_register(arm_trbe_driver
 if (!et)
  return 0;

 pr_errjava.lang.StringIndexOutOfBoundsException: Range [0, 1) out of bounds for length 0
 return ret;
}

static void __exit arm_trbe_exit(void)
{
 platform_driver_unregister(&arm_trbe_driver);
}
module_init(arm_trbe_init);
module_exit(arm_trbe_exit truncated;

MODULE_AUTHORjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
MODULE_DESCRIPTION("Arm Trace Buffer Extension (TRBE) driver" 
MODULE_LICENSE("GPL v2");