[PATCHv6,4/5] tracing: Add register read/write tracing support

Commit Message

Sai Prakash Ranjan Dec. 7, 2021, 6:54 a.m. UTC

From: Prasad Sodagudi <[e-mail]>

Generic MMIO read/write i.e., __raw_{read,write}{b,l,w,q} accessors
are typically used to read/write from/to memory mapped registers
and can cause hangs or some undefined behaviour in following few
cases,

* If the access to the register space is unclocked, for example: if
  there is an access to multimedia(MM) block registers without MM
  clocks.

* If the register space is protected and not set to be accessible from
  non-secure world, for example: only EL3 (EL: Exception level) access
  is allowed and any EL2/EL1 access is forbidden.

* If xPU(memory/register protection units) is controlling access to
  certain memory/register space for specific clients.

and more...

Such cases usually results in instant reboot/SErrors/NOC or interconnect
hangs and tracing these register accesses can be very helpful to debug
such issues during initial development stages and also in later stages.

So use ftrace trace events to log such MMIO register accesses which
provides rich feature set such as early enablement of trace events,
filtering capability, dumping ftrace logs on console and many more.

Sample output:

rwmmio_write: __qcom_geni_serial_console_write+0x160/0x1e0 width=32 val=0xa0d5d addr=0xfffffbfffdbff700
rwmmio_post_write: __qcom_geni_serial_console_write+0x160/0x1e0 width=32 val=0xa0d5d addr=0xfffffbfffdbff700
rwmmio_read: qcom_geni_serial_poll_bit+0x94/0x138 width=32 addr=0xfffffbfffdbff610
rwmmio_post_read: qcom_geni_serial_poll_bit+0x94/0x138 width=32 val=0x0 addr=0xfffffbfffdbff610

Signed-off-by: Prasad Sodagudi <[e-mail]>
Co-developed-by: Sai Prakash Ranjan <[e-mail]>
Signed-off-by: Sai Prakash Ranjan <[e-mail]>
---
 arch/Kconfig                   |   3 +
 arch/arm64/Kconfig             |   1 +
 include/trace/events/rwmmio.h  | 112 +++++++++++++++++++++++++++++++++
 kernel/trace/Kconfig           |   7 +++
 kernel/trace/Makefile          |   1 +
 kernel/trace/trace_readwrite.c |  47 ++++++++++++++
 6 files changed, 171 insertions(+)
 create mode 100644 include/trace/events/rwmmio.h
 create mode 100644 kernel/trace/trace_readwrite.c

Comments

Steven Rostedt Jan. 6, 2022, 6:18 p.m. UTC | #1

On Tue, 7 Dec 2021 12:24:48 +0530
Sai Prakash Ranjan <[e-mail]> wrote:

> diff --git a/kernel/trace/trace_readwrite.c b/kernel/trace/trace_readwrite.c

This should not be in the kernel/trace directory. It should be in the
directory of something that calls it.

-- Steve


> new file mode 100644
> index 000000000000..10ebe3c9687a
> --- /dev/null
> +++ b/kernel/trace/trace_readwrite.c
> @@ -0,0 +1,47 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +/*
> + * Register read and write tracepoints
> + *
> + * Copyright (c) 2021 Qualcomm Innovation Center, Inc. All rights reserved.
> + */
> +

Sai Prakash Ranjan Jan. 7, 2022, 5:10 a.m. UTC | #2

Hi Steve,

On 1/6/2022 11:48 PM, Steven Rostedt wrote:
> This should not be in the kernel/trace directory. It should be in the

Hmm these are called from low level generic io header file 
(include/asm-generic/) where
we wouldn't have any Kconfig to control this feature flexibly and as we 
can have this as
a generic feature selectable by other architectures, wouldn't this be 
suited in kernel/trace?
I thought you were ok with the folder structure in the initial versions 
of the series?

Thanks,
Sai

Steven Rostedt Jan. 7, 2022, 2:56 p.m. UTC | #3

On Fri, 7 Jan 2022 10:40:05 +0530
Sai Prakash Ranjan <[e-mail]> wrote:

> Hi Steve,
> 
> On 1/6/2022 11:48 PM, Steven Rostedt wrote:
> > This should not be in the kernel/trace directory. It should be in the  
> 
> Hmm these are called from low level generic io header file 
> (include/asm-generic/) where
> we wouldn't have any Kconfig to control this feature flexibly and as we 
> can have this as
> a generic feature selectable by other architectures, wouldn't this be 
> suited in kernel/trace?

Isn't there a place for generic rwmmio code?

> I thought you were ok with the folder structure in the initial versions 
> of the series?

Sorry, I missed the C file in kernel/trace. The files in kernel/trace tend
to be specific for the internals of tracing. This C file is more to hold
helper functions for mmio, which to me should be someplace for mmio code.
Perhaps in mm/ ?

-- Steve

Sai Prakash Ranjan Jan. 8, 2022, 5:34 a.m. UTC | #4

Hi,

On 1/7/2022 8:26 PM, Steven Rostedt wrote:
> On Fri, 7 Jan 2022 10:40:05 +0530
> Sai Prakash Ranjan <[e-mail]> wrote:
>
>> Hi Steve,
>>
>> On 1/6/2022 11:48 PM, Steven Rostedt wrote:
>>> This should not be in the kernel/trace directory. It should be in the
>> Hmm these are called from low level generic io header file
>> (include/asm-generic/) where
>> we wouldn't have any Kconfig to control this feature flexibly and as we
>> can have this as
>> a generic feature selectable by other architectures, wouldn't this be
>> suited in kernel/trace?
> Isn't there a place for generic rwmmio code?

I am thinking of moving it to lib/ similar to an interface of 
logic_iomem.c which
Arnd had initially suggested to look at.

>> I thought you were ok with the folder structure in the initial versions
>> of the series?
> Sorry, I missed the C file in kernel/trace. The files in kernel/trace tend
> to be specific for the internals of tracing. This C file is more to hold
> helper functions for mmio, which to me should be someplace for mmio code.
> Perhaps in mm/ ?
>

Oh ok, mm would not be the right fit as it is memory management and this 
is about
memory mapped IO, let me try and move it to lib/ as done for logic_iomem.c

Thanks,
Sai

Sai Prakash Ranjan Jan. 15, 2022, 1:18 p.m. UTC | #5

On 1/8/2022 11:04 AM, Sai Prakash Ranjan wrote:
> Hi,
>
> On 1/7/2022 8:26 PM, Steven Rostedt wrote:
>> On Fri, 7 Jan 2022 10:40:05 +0530
>> Sai Prakash Ranjan <[e-mail]> wrote:
>>
>>> Hi Steve,
>>>
>>> On 1/6/2022 11:48 PM, Steven Rostedt wrote:
>>>> This should not be in the kernel/trace directory. It should be in the
>>> Hmm these are called from low level generic io header file
>>> (include/asm-generic/) where
>>> we wouldn't have any Kconfig to control this feature flexibly and as we
>>> can have this as
>>> a generic feature selectable by other architectures, wouldn't this be
>>> suited in kernel/trace?
>> Isn't there a place for generic rwmmio code?
>
> I am thinking of moving it to lib/ similar to an interface of 
> logic_iomem.c which
> Arnd had initially suggested to look at.
>
>>> I thought you were ok with the folder structure in the initial versions
>>> of the series?
>> Sorry, I missed the C file in kernel/trace. The files in kernel/trace 
>> tend
>> to be specific for the internals of tracing. This C file is more to hold
>> helper functions for mmio, which to me should be someplace for mmio 
>> code.
>> Perhaps in mm/ ?
>>
>
> Oh ok, mm would not be the right fit as it is memory management and 
> this is about
> memory mapped IO, let me try and move it to lib/ as done for 
> logic_iomem.c
>
> Thanks,
> Sai

Posted v7 - 
https://lore.kernel.org/lkml/[e-mail]/

Thanks,
Sai

Patch

diff --git a/arch/Kconfig b/arch/Kconfig
index 26b8ed11639d..8980e1c25212 100644
--- a/arch/Kconfig
+++ b/arch/Kconfig
@@ -1299,6 +1299,9 @@  config ARCH_HAS_ELFCORE_COMPAT
 config ARCH_HAS_PARANOID_L1D_FLUSH
 	bool
 
+config ARCH_HAVE_TRACE_MMIO_ACCESS
+	bool
+
 config DYNAMIC_SIGFRAME
 	bool
 
diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig
index c4207cf9bb17..25d1b0fca488 100644
--- a/arch/arm64/Kconfig
+++ b/arch/arm64/Kconfig
@@ -46,6 +46,7 @@  config ARM64
 	select ARCH_HAS_ZONE_DMA_SET if EXPERT
 	select ARCH_HAVE_ELF_PROT
 	select ARCH_HAVE_NMI_SAFE_CMPXCHG
+	select ARCH_HAVE_TRACE_MMIO_ACCESS
 	select ARCH_INLINE_READ_LOCK if !PREEMPTION
 	select ARCH_INLINE_READ_LOCK_BH if !PREEMPTION
 	select ARCH_INLINE_READ_LOCK_IRQ if !PREEMPTION
diff --git a/include/trace/events/rwmmio.h b/include/trace/events/rwmmio.h
new file mode 100644
index 000000000000..f66397007258
--- /dev/null
+++ b/include/trace/events/rwmmio.h
@@ -0,0 +1,112 @@ 
+/* SPDX-License-Identifier: GPL-2.0-only */
+/*
+ * Copyright (c) 2021 Qualcomm Innovation Center, Inc. All rights reserved.
+ */
+#undef TRACE_SYSTEM
+#define TRACE_SYSTEM rwmmio
+
+#if !defined(_TRACE_RWMMIO_H) || defined(TRACE_HEADER_MULTI_READ)
+#define _TRACE_RWMMIO_H
+
+#include <linux/tracepoint.h>
+
+TRACE_EVENT(rwmmio_write,
+
+	TP_PROTO(unsigned long caller, u64 val, u8 width, volatile void __iomem *addr),
+
+	TP_ARGS(caller, val, width, addr),
+
+	TP_STRUCT__entry(
+		__field(u64, caller)
+		__field(u64, val)
+		__field(u64, addr)
+		__field(u8, width)
+	),
+
+	TP_fast_assign(
+		__entry->caller = caller;
+		__entry->val = val;
+		__entry->addr = (unsigned long)(void *)addr;
+		__entry->width = width;
+	),
+
+	TP_printk("%pS width=%d val=%#llx addr=%#llx",
+		(void *)(unsigned long)__entry->caller, __entry->width,
+		__entry->val, __entry->addr)
+);
+
+TRACE_EVENT(rwmmio_post_write,
+
+	TP_PROTO(unsigned long caller, u64 val, u8 width, volatile void __iomem *addr),
+
+	TP_ARGS(caller, val, width, addr),
+
+	TP_STRUCT__entry(
+		__field(u64, caller)
+		__field(u64, val)
+		__field(u64, addr)
+		__field(u8, width)
+	),
+
+	TP_fast_assign(
+		__entry->caller = caller;
+		__entry->val = val;
+		__entry->addr = (unsigned long)(void *)addr;
+		__entry->width = width;
+	),
+
+	TP_printk("%pS width=%d val=%#llx addr=%#llx",
+		(void *)(unsigned long)__entry->caller, __entry->width,
+		__entry->val, __entry->addr)
+);
+
+TRACE_EVENT(rwmmio_read,
+
+	TP_PROTO(unsigned long caller, u8 width, const volatile void __iomem *addr),
+
+	TP_ARGS(caller, width, addr),
+
+	TP_STRUCT__entry(
+		__field(u64, caller)
+		__field(u64, addr)
+		__field(u8, width)
+	),
+
+	TP_fast_assign(
+		__entry->caller = caller;
+		__entry->addr = (unsigned long)(void *)addr;
+		__entry->width = width;
+	),
+
+	TP_printk("%pS width=%d addr=%#llx",
+		 (void *)(unsigned long)__entry->caller, __entry->width, __entry->addr)
+);
+
+TRACE_EVENT(rwmmio_post_read,
+
+	TP_PROTO(unsigned long caller, u64 val, u8 width, const volatile void __iomem *addr),
+
+	TP_ARGS(caller, val, width, addr),
+
+	TP_STRUCT__entry(
+		__field(u64, caller)
+		__field(u64, val)
+		__field(u64, addr)
+		__field(u8, width)
+	),
+
+	TP_fast_assign(
+		__entry->caller = caller;
+		__entry->val = val;
+		__entry->addr = (unsigned long)(void *)addr;
+		__entry->width = width;
+	),
+
+	TP_printk("%pS width=%d val=%#llx addr=%#llx",
+		 (void *)(unsigned long)__entry->caller, __entry->width,
+		 __entry->val, __entry->addr)
+);
+
+#endif /* _TRACE_RWMMIO_H */
+
+#include <trace/define_trace.h>
diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig
index 420ff4bc67fd..2b09a863e07a 100644
--- a/kernel/trace/Kconfig
+++ b/kernel/trace/Kconfig
@@ -95,6 +95,13 @@  config RING_BUFFER_ALLOW_SWAP
 	 Allow the use of ring_buffer_swap_cpu.
 	 Adds a very slight overhead to tracing when enabled.
 
+config TRACE_MMIO_ACCESS
+	bool "Register read/write tracing"
+	depends on TRACING && ARCH_HAVE_TRACE_MMIO_ACCESS
+	help
+	  Create tracepoints for MMIO read/write operations. These trace events
+	  can be used for logging all MMIO read/write operations.
+
 config PREEMPTIRQ_TRACEPOINTS
 	bool
 	depends on TRACE_PREEMPT_TOGGLE || TRACE_IRQFLAGS
diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile
index bedc5caceec7..a3d16e1a5abd 100644
--- a/kernel/trace/Makefile
+++ b/kernel/trace/Makefile
@@ -99,5 +99,6 @@  obj-$(CONFIG_BOOTTIME_TRACING) += trace_boot.o
 obj-$(CONFIG_FTRACE_RECORD_RECURSION) += trace_recursion_record.o
 
 obj-$(CONFIG_TRACEPOINT_BENCHMARK) += trace_benchmark.o
+obj-$(CONFIG_TRACE_MMIO_ACCESS) += trace_readwrite.o
 
 libftrace-y := ftrace.o
diff --git a/kernel/trace/trace_readwrite.c b/kernel/trace/trace_readwrite.c
new file mode 100644
index 000000000000..10ebe3c9687a
--- /dev/null
+++ b/kernel/trace/trace_readwrite.c
@@ -0,0 +1,47 @@ 
+// SPDX-License-Identifier: GPL-2.0-only
+/*
+ * Register read and write tracepoints
+ *
+ * Copyright (c) 2021 Qualcomm Innovation Center, Inc. All rights reserved.
+ */
+
+#include <linux/ftrace.h>
+#include <linux/module.h>
+#include <asm-generic/io.h>
+
+#define CREATE_TRACE_POINTS
+#include <trace/events/rwmmio.h>
+
+#ifdef CONFIG_TRACE_MMIO_ACCESS
+void log_write_mmio(u64 val, u8 width, volatile void __iomem *addr,
+		    unsigned long caller_addr)
+{
+	trace_rwmmio_write(caller_addr, val, width, addr);
+}
+EXPORT_SYMBOL_GPL(log_write_mmio);
+EXPORT_TRACEPOINT_SYMBOL_GPL(rwmmio_write);
+
+void log_post_write_mmio(u64 val, u8 width, volatile void __iomem *addr,
+			 unsigned long caller_addr)
+{
+	trace_rwmmio_post_write(caller_addr, val, width, addr);
+}
+EXPORT_SYMBOL_GPL(log_post_write_mmio);
+EXPORT_TRACEPOINT_SYMBOL_GPL(rwmmio_post_write);
+
+void log_read_mmio(u8 width, const volatile void __iomem *addr,
+		   unsigned long caller_addr)
+{
+	trace_rwmmio_read(caller_addr, width, addr);
+}
+EXPORT_SYMBOL_GPL(log_read_mmio);
+EXPORT_TRACEPOINT_SYMBOL_GPL(rwmmio_read);
+
+void log_post_read_mmio(u64 val, u8 width, const volatile void __iomem *addr,
+			unsigned long caller_addr)
+{
+	trace_rwmmio_post_read(caller_addr, val, width, addr);
+}
+EXPORT_SYMBOL_GPL(log_post_read_mmio);
+EXPORT_TRACEPOINT_SYMBOL_GPL(rwmmio_post_read);
+#endif /* CONFIG_TRACE_MMIO_ACCESS */