coresight: tmc-etr: Add support for CPU-wide trace scenarios

This patch adds support for CPU-wide trace scenarios by making sure that
only the sources monitoring the same process have access to a common sink.
Because the sink is shared between sources, the first source to use the
sink switches it on while the last one does the cleanup.  Any attempt to
modify the HW is overlooked for as long as more than one source is using
a sink.

Signed-off-by: Mathieu Poirier <mathieu.poirier@linaro.org>
Tested-by: Leo Yan <leo.yan@linaro.org>
Tested-by: Robert Walker <robert.walker@arm.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@linuxfoundation.org>

diff --git a/drivers/hwtracing/coresight/coresight-tmc-etr.c b/drivers/hwtracing/coresight/coresight-tmc-etr.c
index 8c75800003d27329f825da1d68f390165ac84149..df6e4b0b84e9319eb32a7f91830e9add166ce46a 100644 (file)
--- a/drivers/hwtracing/coresight/coresight-tmc-etr.c
+++ b/drivers/hwtracing/coresight/coresight-tmc-etr.c
@@ -1474,6 +1474,13 @@ tmc_update_etr_buffer(struct coresight_device *csdev,
        struct etr_buf *etr_buf = etr_perf->etr_buf;
 
        spin_lock_irqsave(&drvdata->spinlock, flags);
+
+       /* Don't do anything if another tracer is using this sink */
+       if (atomic_read(csdev->refcnt) != 1) {
+               spin_unlock_irqrestore(&drvdata->spinlock, flags);
+               goto out;
+       }
+
        if (WARN_ON(drvdata->perf_data != etr_perf)) {
                lost = true;
                spin_unlock_irqrestore(&drvdata->spinlock, flags);
@@ -1513,17 +1520,15 @@ out:
 static int tmc_enable_etr_sink_perf(struct coresight_device *csdev, void *data)
 {
        int rc = 0;
+       pid_t pid;
        unsigned long flags;
        struct tmc_drvdata *drvdata = dev_get_drvdata(csdev->dev.parent);
        struct perf_output_handle *handle = data;
        struct etr_perf_buffer *etr_perf = etm_perf_sink_config(handle);
 
        spin_lock_irqsave(&drvdata->spinlock, flags);
-       /*
-        * There can be only one writer per sink in perf mode. If the sink
-        * is already open in SYSFS mode, we can't use it.
-        */
-       if (drvdata->mode != CS_MODE_DISABLED || WARN_ON(drvdata->perf_data)) {
+        /* Don't use this sink if it is already claimed by sysFS */
+       if (drvdata->mode == CS_MODE_SYSFS) {
                rc = -EBUSY;
                goto unlock_out;
        }
@@ -1533,10 +1538,31 @@ static int tmc_enable_etr_sink_perf(struct coresight_device *csdev, void *data)
                goto unlock_out;
        }
 
+       /* Get a handle on the pid of the process to monitor */
+       pid = etr_perf->pid;
+
+       /* Do not proceed if this device is associated with another session */
+       if (drvdata->pid != -1 && drvdata->pid != pid) {
+               rc = -EBUSY;
+               goto unlock_out;
+       }
+
        etr_perf->head = PERF_IDX2OFF(handle->head, etr_perf);
        drvdata->perf_data = etr_perf;
+
+       /*
+        * No HW configuration is needed if the sink is already in
+        * use for this session.
+        */
+       if (drvdata->pid == pid) {
+               atomic_inc(csdev->refcnt);
+               goto unlock_out;
+       }
+
        rc = tmc_etr_enable_hw(drvdata, etr_perf->etr_buf);
        if (!rc) {
+               /* Associate with monitored process. */
+               drvdata->pid = pid;
                drvdata->mode = CS_MODE_PERF;
                atomic_inc(csdev->refcnt);
        }
@@ -1580,6 +1606,8 @@ static int tmc_disable_etr_sink(struct coresight_device *csdev)
        /* Complain if we (somehow) got out of sync */
        WARN_ON_ONCE(drvdata->mode == CS_MODE_DISABLED);
        tmc_etr_disable_hw(drvdata);
+       /* Dissociate from monitored process. */
+       drvdata->pid = -1;
        drvdata->mode = CS_MODE_DISABLED;
 
        spin_unlock_irqrestore(&drvdata->spinlock, flags);

diff --git a/drivers/hwtracing/coresight/coresight-tmc.c b/drivers/hwtracing/coresight/coresight-tmc.c
index 9f9b2c514566f0ad88151396bfcbc1ad5f36bfe9..3f718729d741060eff20002cdf78c74655983e21 100644 (file)
--- a/drivers/hwtracing/coresight/coresight-tmc.c
+++ b/drivers/hwtracing/coresight/coresight-tmc.c
@@ -422,6 +422,8 @@ static int tmc_probe(struct amba_device *adev, const struct amba_id *id)
        devid = readl_relaxed(drvdata->base + CORESIGHT_DEVID);
        drvdata->config_type = BMVAL(devid, 6, 7);
        drvdata->memwidth = tmc_get_memwidth(devid);
+       /* This device is not associated with a session */
+       drvdata->pid = -1;
 
        if (drvdata->config_type == TMC_CONFIG_TYPE_ETR) {
                if (np)

diff --git a/drivers/hwtracing/coresight/coresight-tmc.h b/drivers/hwtracing/coresight/coresight-tmc.h
index c1b1700b2df7e9a938550d21863e84f955557bfb..503f1b3a374130a72b2dafdc6907a77395ffea26 100644 (file)
--- a/drivers/hwtracing/coresight/coresight-tmc.h
+++ b/drivers/hwtracing/coresight/coresight-tmc.h
@@ -165,6 +165,8 @@ struct etr_buf {
  * @csdev:     component vitals needed by the framework.
  * @miscdev:   specifics to handle "/dev/xyz.tmc" entry.
  * @spinlock:  only one at a time pls.
+ * @pid:       Process ID of the process being monitored by the session
+ *             that is using this component.
  * @buf:       Snapshot of the trace data for ETF/ETB.
  * @etr_buf:   details of buffer used in TMC-ETR
  * @len:       size of the available trace for ETF/ETB.
@@ -186,6 +188,7 @@ struct tmc_drvdata {
        struct coresight_device *csdev;
        struct miscdevice       miscdev;
        spinlock_t              spinlock;
+       pid_t                   pid;
        bool                    reading;
        union {
                char            *buf;           /* TMC ETB */