Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 6ffb3905 authored by Rishabh Bhatnagar's avatar Rishabh Bhatnagar
Browse files

trace: rtb: add msm_rtb register tracing feature snapshot 



This is a snapshot of the msm_rtb driver from kernel/trace taken as of
msm-4.14 commit <55e5efd553c10ef>.(Merge "nl80211: Fix external_auth
check for offloaded authentication")

Change-Id: Ib6a141a81ba42ed895880cb2a3c4b4a2c3efe541
Signed-off-by: default avatarRishabh Bhatnagar <rishabhb@codeaurora.org>
parent 40f58568

Documentation/devicetree/bindings/arm/msm/msm_rtb.txt

0 → 100644
+22 −0
Original line number Original line Diff line number Diff line 
Register Trace Buffer (RTB)



The RTB is used to log discrete events in the system in an uncached buffer that

can be post processed from RAM dumps. The RTB must reserve memory using

the msm specific memory reservation bindings (see

Documentation/devicetree/bindings/arm/msm/memory-reserve.txt).



Required properties



- compatible: "qcom,msm-rtb"

- qcom,rtb-size: size of the RTB buffer in bytes



Optional properties:



- linux,contiguous-region: phandle reference to a CMA region



Example:



	qcom,msm-rtb {

		compatible = "qcom,msm-rtb";

		qcom,rtb-size = <0x100000>;

	};

include/linux/msm_rtb.h

0 → 100644
+81 −0
Original line number Original line Diff line number Diff line 
/* SPDX-License-Identifier: GPL-2.0 */

/*

 * Copyright (c) 2012-2014, 2016, 2018, The Linux Foundation. All rights reserved.

 */



#ifndef __MSM_RTB_H__

#define __MSM_RTB_H__



/*

 * These numbers are used from the kernel command line and sysfs

 * to control filtering. Remove items from here with extreme caution.

 */

enum logk_event_type {

	LOGK_NONE = 0,

	LOGK_READL = 1,

	LOGK_WRITEL = 2,

	LOGK_LOGBUF = 3,

	LOGK_HOTPLUG = 4,

	LOGK_CTXID = 5,

	LOGK_TIMESTAMP = 6,

	LOGK_L2CPREAD = 7,

	LOGK_L2CPWRITE = 8,

	LOGK_IRQ = 9,

};



#define LOGTYPE_NOPC 0x80



struct msm_rtb_platform_data {

	unsigned int size;

};



#if defined(CONFIG_QCOM_RTB)

/*

 * returns 1 if data was logged, 0 otherwise

 */

int uncached_logk_pc(enum logk_event_type log_type, void *caller,

				void *data);



/*

 * returns 1 if data was logged, 0 otherwise

 */

int uncached_logk(enum logk_event_type log_type, void *data);



#define ETB_WAYPOINT  do { \

				BRANCH_TO_NEXT_ISTR; \

				nop(); \

				BRANCH_TO_NEXT_ISTR; \

				nop(); \

			} while (0)



#define BRANCH_TO_NEXT_ISTR \

	do { \

		asm volatile("b .+4\n" : : : "memory"); \

	} while (0)



/*

 * both the mb and the isb are needed to ensure enough waypoints for

 * etb tracing

 */

#define LOG_BARRIER	do { \

				mb(); \

				isb(); \

			} while (0)

#else



static inline int uncached_logk_pc(enum logk_event_type log_type,

					void *caller,

					void *data) { return 0; }



static inline int uncached_logk(enum logk_event_type log_type,

					void *data) { return 0; }



#define ETB_WAYPOINT

#define BRANCH_TO_NEXT_ISTR

/*

 * Due to a GCC bug, we need to have a nop here in order to prevent an extra

 * read from being generated after the write.

 */

#define LOG_BARRIER		nop()

#endif

#endif

kernel/trace/Kconfig

+19 −0
Original line number Original line Diff line number Diff line
@@ -82,6 +82,25 @@ config RING_BUFFER_ALLOW_SWAP 
	 Allow the use of ring_buffer_swap_cpu.

	 Allow the use of ring_buffer_swap_cpu.

	 Adds a very slight overhead to tracing when enabled.

	 Adds a very slight overhead to tracing when enabled.





config QCOM_RTB

	bool "Register tracing"

	help

	  Enable the kernel to trace every kernel function. This is done

	  Add support for logging different events to a small uncached

	  region. This is designed to aid in debugging reset cases where the

	  caches may not be flushed before the target resets.



config QCOM_RTB_SEPARATE_CPUS

	bool "Separate entries for each cpu"

	depends on QCOM_RTB

	depends on SMP

	help

	  Under some circumstances, it may be beneficial to give dedicated space

	  for each cpu to log accesses. Selecting this option will log each cpu

	  separately. This will guarantee that the last acesses for each cpu

	  will be logged but there will be fewer entries per cpu





# All tracer options should select GENERIC_TRACER. For those options that are

# All tracer options should select GENERIC_TRACER. For those options that are

# enabled by all tracers (context switch and event tracer) they select TRACING.

# enabled by all tracers (context switch and event tracer) they select TRACING.

# This allows those options to appear when no other tracer is selected. But the

# This allows those options to appear when no other tracer is selected. But the

kernel/trace/Makefile

+1 −0
Original line number Original line Diff line number Diff line
@@ -71,5 +71,6 @@ obj-$(CONFIG_PROBE_EVENTS) += trace_probe.o 
obj-$(CONFIG_UPROBE_EVENTS) += trace_uprobe.o

obj-$(CONFIG_UPROBE_EVENTS) += trace_uprobe.o





obj-$(CONFIG_TRACEPOINT_BENCHMARK) += trace_benchmark.o

obj-$(CONFIG_TRACEPOINT_BENCHMARK) += trace_benchmark.o

obj-$(CONFIG_QCOM_RTB) += msm_rtb.o





libftrace-y := ftrace.o
 
libftrace-y := ftrace.o

kernel/trace/msm_rtb.c

0 → 100644
+328 −0
Original line number Original line Diff line number Diff line 
// SPDX-License-Identifier: GPL-2.0

/*

 * Copyright (c) 2013-2018, The Linux Foundation. All rights reserved.

 */



#include <linux/atomic.h>

#include <linux/export.h>

#include <linux/kernel.h>

#include <linux/module.h>

#include <linux/dma-mapping.h>

#include <linux/mod_devicetable.h>

#include <linux/platform_device.h>

#include <linux/sched/clock.h>

#include <linux/slab.h>

#include <linux/string.h>

#include <linux/atomic.h>

#include <linux/of.h>

#include <linux/of_address.h>

#include <linux/io.h>

#include <asm-generic/sizes.h>

#include <linux/msm_rtb.h>

#include <asm/timex.h>

#include <soc/qcom/minidump.h>



#define SENTINEL_BYTE_1 0xFF

#define SENTINEL_BYTE_2 0xAA

#define SENTINEL_BYTE_3 0xFF



#define RTB_COMPAT_STR	"qcom,msm-rtb"



/* Write

 * 1) 3 bytes sentinel

 * 2) 1 bytes of log type

 * 3) 8 bytes of where the caller came from

 * 4) 4 bytes index

 * 4) 8 bytes extra data from the caller

 * 5) 8 bytes of timestamp

 * 6) 8 bytes of cyclecount

 *

 * Total = 40 bytes.

 */

struct msm_rtb_layout {

	unsigned char sentinel[3];

	unsigned char log_type;

	uint32_t idx;

	uint64_t caller;

	uint64_t data;

	uint64_t timestamp;

	uint64_t cycle_count;

} __attribute__ ((__packed__));





struct msm_rtb_state {

	struct msm_rtb_layout *rtb;

	phys_addr_t phys;

	int nentries;

	int size;

	int enabled;

	int initialized;

	uint32_t filter;

	int step_size;

};



#if defined(CONFIG_QCOM_RTB_SEPARATE_CPUS)

DEFINE_PER_CPU(atomic_t, msm_rtb_idx_cpu);

#else

static atomic_t msm_rtb_idx;

#endif



static struct msm_rtb_state msm_rtb = {

	.filter = 1 << LOGK_LOGBUF,

	.enabled = 1,

};



module_param_named(filter, msm_rtb.filter, uint, 0644);

module_param_named(enable, msm_rtb.enabled, int, 0644);



static int msm_rtb_panic_notifier(struct notifier_block *this,

					unsigned long event, void *ptr)

{

	msm_rtb.enabled = 0;

	return NOTIFY_DONE;

}



static struct notifier_block msm_rtb_panic_blk = {

	.notifier_call  = msm_rtb_panic_notifier,

	.priority = INT_MAX,

};



int notrace msm_rtb_event_should_log(enum logk_event_type log_type)

{

	return msm_rtb.initialized && msm_rtb.enabled &&

		((1 << (log_type & ~LOGTYPE_NOPC)) & msm_rtb.filter);

}

EXPORT_SYMBOL(msm_rtb_event_should_log);



static void msm_rtb_emit_sentinel(struct msm_rtb_layout *start)

{

	start->sentinel[0] = SENTINEL_BYTE_1;

	start->sentinel[1] = SENTINEL_BYTE_2;

	start->sentinel[2] = SENTINEL_BYTE_3;

}



static void msm_rtb_write_type(enum logk_event_type log_type,

			struct msm_rtb_layout *start)

{

	start->log_type = (char)log_type;

}



static void msm_rtb_write_caller(uint64_t caller, struct msm_rtb_layout *start)

{

	start->caller = caller;

}



static void msm_rtb_write_idx(uint32_t idx,

				struct msm_rtb_layout *start)

{

	start->idx = idx;

}



static void msm_rtb_write_data(uint64_t data, struct msm_rtb_layout *start)

{

	start->data = data;

}



static void msm_rtb_write_timestamp(struct msm_rtb_layout *start)

{

	start->timestamp = sched_clock();

}



static void msm_rtb_write_cyclecount(struct msm_rtb_layout *start)

{

	start->cycle_count = get_cycles();

}



static void uncached_logk_pc_idx(enum logk_event_type log_type, uint64_t caller,

				 uint64_t data, int idx)

{

	struct msm_rtb_layout *start;



	start = &msm_rtb.rtb[idx & (msm_rtb.nentries - 1)];



	msm_rtb_emit_sentinel(start);

	msm_rtb_write_type(log_type, start);

	msm_rtb_write_caller(caller, start);

	msm_rtb_write_idx(idx, start);

	msm_rtb_write_data(data, start);

	msm_rtb_write_timestamp(start);

	msm_rtb_write_cyclecount(start);

	mb();



}



static void uncached_logk_timestamp(int idx)

{

	unsigned long long timestamp;



	timestamp = sched_clock();

	uncached_logk_pc_idx(LOGK_TIMESTAMP|LOGTYPE_NOPC,

			(uint64_t)lower_32_bits(timestamp),

			(uint64_t)upper_32_bits(timestamp), idx);

}



#if defined(CONFIG_QCOM_RTB_SEPARATE_CPUS)

static int msm_rtb_get_idx(void)

{

	int cpu, i, offset;

	atomic_t *index;



	/*

	 * ideally we would use get_cpu but this is a close enough

	 * approximation for our purposes.

	 */

	cpu = raw_smp_processor_id();



	index = &per_cpu(msm_rtb_idx_cpu, cpu);



	i = atomic_add_return(msm_rtb.step_size, index);

	i -= msm_rtb.step_size;



	/* Check if index has wrapped around */

	offset = (i & (msm_rtb.nentries - 1)) -

		 ((i - msm_rtb.step_size) & (msm_rtb.nentries - 1));

	if (offset < 0) {

		uncached_logk_timestamp(i);

		i = atomic_add_return(msm_rtb.step_size, index);

		i -= msm_rtb.step_size;

	}



	return i;

}

#else

static int msm_rtb_get_idx(void)

{

	int i, offset;



	i = atomic_inc_return(&msm_rtb_idx);

	i--;



	/* Check if index has wrapped around */

	offset = (i & (msm_rtb.nentries - 1)) -

		 ((i - 1) & (msm_rtb.nentries - 1));

	if (offset < 0) {

		uncached_logk_timestamp(i);

		i = atomic_inc_return(&msm_rtb_idx);

		i--;

	}



	return i;

}

#endif



int notrace uncached_logk_pc(enum logk_event_type log_type, void *caller,

				void *data)

{

	int i;



	if (!msm_rtb_event_should_log(log_type))

		return 0;



	i = msm_rtb_get_idx();

	uncached_logk_pc_idx(log_type, (uint64_t)((unsigned long) caller),

				(uint64_t)((unsigned long) data), i);



	return 1;

}

EXPORT_SYMBOL(uncached_logk_pc);



noinline int notrace uncached_logk(enum logk_event_type log_type, void *data)

{

	return uncached_logk_pc(log_type, __builtin_return_address(0), data);

}

EXPORT_SYMBOL(uncached_logk);



static int msm_rtb_probe(struct platform_device *pdev)

{

	struct msm_rtb_platform_data *d = pdev->dev.platform_data;

	struct md_region md_entry;

#if defined(CONFIG_QCOM_RTB_SEPARATE_CPUS)

	unsigned int cpu;

#endif

	int ret;



	if (!pdev->dev.of_node) {

		msm_rtb.size = d->size;

	} else {

		u64 size;

		struct device_node *pnode;



		pnode = of_parse_phandle(pdev->dev.of_node,

						"linux,contiguous-region", 0);

		if (pnode != NULL) {

			const u32 *addr;



			addr = of_get_address(pnode, 0, &size, NULL);

			if (!addr) {

				of_node_put(pnode);

				return -EINVAL;

			}

			of_node_put(pnode);

		} else {

			ret = of_property_read_u32(pdev->dev.of_node,

					"qcom,rtb-size",

					(u32 *)&size);

			if (ret < 0)

				return ret;



		}



		msm_rtb.size = size;

	}



	if (msm_rtb.size <= 0 || msm_rtb.size > SZ_1M)

		return -EINVAL;



	msm_rtb.rtb = dma_alloc_coherent(&pdev->dev, msm_rtb.size,

						&msm_rtb.phys,

						GFP_KERNEL);



	if (!msm_rtb.rtb)

		return -ENOMEM;



	msm_rtb.nentries = msm_rtb.size / sizeof(struct msm_rtb_layout);



	/* Round this down to a power of 2 */

	msm_rtb.nentries = __rounddown_pow_of_two(msm_rtb.nentries);



	memset(msm_rtb.rtb, 0, msm_rtb.size);



	strlcpy(md_entry.name, "KRTB_BUF", sizeof(md_entry.name));

	md_entry.virt_addr = (uintptr_t)msm_rtb.rtb;

	md_entry.phys_addr = msm_rtb.phys;

	md_entry.size = msm_rtb.size;

	if (msm_minidump_add_region(&md_entry))

		pr_info("Failed to add RTB in Minidump\n");



#if defined(CONFIG_QCOM_RTB_SEPARATE_CPUS)

	for_each_possible_cpu(cpu) {

		atomic_t *a = &per_cpu(msm_rtb_idx_cpu, cpu);



		atomic_set(a, cpu);

	}

	msm_rtb.step_size = num_possible_cpus();

#else

	atomic_set(&msm_rtb_idx, 0);

	msm_rtb.step_size = 1;

#endif



	atomic_notifier_chain_register(&panic_notifier_list,

						&msm_rtb_panic_blk);

	msm_rtb.initialized = 1;

	return 0;

}



static const struct of_device_id msm_match_table[] = {

	{.compatible = RTB_COMPAT_STR},

	{},

};



static struct platform_driver msm_rtb_driver = {

	.probe = msm_rtb_probe,

	.driver         = {

		.name = "msm_rtb",

		.owner = THIS_MODULE,

		.of_match_table = msm_match_table

	},

};

module_platform_driver(msm_rtb_driver);