Merge branches 'tracing/hw-branch-tracing' and 'tracing/power-tracer' into tracing/core (c4e2b432) · Commits · e / devices / android_kernel_xiaomi_markw

arch/x86/kernel/cpu/cpufreq/acpi-cpufreq.c

+2 −0

Original line number	Original line	Diff line number	Diff line
	@@ -70,6 +70,8 @@ struct acpi_cpufreq_data {

	static DEFINE_PER_CPU(struct acpi_cpufreq_data *, drv_data);		static DEFINE_PER_CPU(struct acpi_cpufreq_data *, drv_data);

			DEFINE_TRACE(power_mark);

	/* acpi_perf_data is a pointer to percpu data. */		/* acpi_perf_data is a pointer to percpu data. */
	static struct acpi_processor_performance *acpi_perf_data;		static struct acpi_processor_performance *acpi_perf_data;

arch/x86/kernel/process.c

+3 −0

Original line number	Original line	Diff line number	Diff line
	@@ -19,6 +19,9 @@ EXPORT_SYMBOL(idle_nomwait);

	struct kmem_cache *task_xstate_cachep;		struct kmem_cache *task_xstate_cachep;

			DEFINE_TRACE(power_start);
			DEFINE_TRACE(power_end);

	int arch_dup_task_struct(struct task_struct dst, struct task_struct src)		int arch_dup_task_struct(struct task_struct dst, struct task_struct src)
	{		{
	dst = src;		dst = src;

include/trace/power.h

+12 −13

Original line number	Original line	Diff line number	Diff line
	@@ -2,6 +2,7 @@
	#define _TRACE_POWER_H		#define _TRACE_POWER_H

	#include <linux/ktime.h>		#include <linux/ktime.h>
			#include <linux/tracepoint.h>

	enum {		enum {
	POWER_NONE = 0,		POWER_NONE = 0,
	@@ -18,18 +19,16 @@ struct power_trace {
	#endif		#endif
	};		};

	#ifdef CONFIG_POWER_TRACER		DECLARE_TRACE(power_start,
	extern void trace_power_start(struct power_trace *it, unsigned int type,		TPPROTO(struct power_trace *it, unsigned int type, unsigned int state),
	unsigned int state);		TPARGS(it, type, state));
	extern void trace_power_mark(struct power_trace *it, unsigned int type,
	unsigned int state);		DECLARE_TRACE(power_mark,
	extern void trace_power_end(struct power_trace *it);		TPPROTO(struct power_trace *it, unsigned int type, unsigned int state),
	#else		TPARGS(it, type, state));
	static inline void trace_power_start(struct power_trace *it, unsigned int type,
	unsigned int state) { }		DECLARE_TRACE(power_end,
	static inline void trace_power_mark(struct power_trace *it, unsigned int type,		TPPROTO(struct power_trace *it),
	unsigned int state) { }		TPARGS(it));
	static inline void trace_power_end(struct power_trace *it) { }
	#endif

	#endif /* _TRACE_POWER_H */		#endif /* _TRACE_POWER_H */

kernel/trace/trace_power.c

+102 −71

Original line number	Original line	Diff line number	Diff line
	@@ -21,15 +21,116 @@
	static struct trace_array *power_trace;		static struct trace_array *power_trace;
	static int __read_mostly trace_power_enabled;		static int __read_mostly trace_power_enabled;

			static void probe_power_start(struct power_trace *it, unsigned int type,
			unsigned int level)
			{
			if (!trace_power_enabled)
			return;

			memset(it, 0, sizeof(struct power_trace));
			it->state = level;
			it->type = type;
			it->stamp = ktime_get();
			}


			static void probe_power_end(struct power_trace *it)
			{
			struct ring_buffer_event *event;
			struct trace_power *entry;
			struct trace_array_cpu *data;
			struct trace_array *tr = power_trace;

			if (!trace_power_enabled)
			return;

			preempt_disable();
			it->end = ktime_get();
			data = tr->data[smp_processor_id()];

			event = trace_buffer_lock_reserve(tr, TRACE_POWER,
			sizeof(*entry), 0, 0);
			if (!event)
			goto out;
			entry = ring_buffer_event_data(event);
			entry->state_data = *it;
			trace_buffer_unlock_commit(tr, event, 0, 0);
			out:
			preempt_enable();
			}

			static void probe_power_mark(struct power_trace *it, unsigned int type,
			unsigned int level)
			{
			struct ring_buffer_event *event;
			struct trace_power *entry;
			struct trace_array_cpu *data;
			struct trace_array *tr = power_trace;

			if (!trace_power_enabled)
			return;

			memset(it, 0, sizeof(struct power_trace));
			it->state = level;
			it->type = type;
			it->stamp = ktime_get();
			preempt_disable();
			it->end = it->stamp;
			data = tr->data[smp_processor_id()];

			event = trace_buffer_lock_reserve(tr, TRACE_POWER,
			sizeof(*entry), 0, 0);
			if (!event)
			goto out;
			entry = ring_buffer_event_data(event);
			entry->state_data = *it;
			trace_buffer_unlock_commit(tr, event, 0, 0);
			out:
			preempt_enable();
			}

			static int tracing_power_register(void)
			{
			int ret;

			ret = register_trace_power_start(probe_power_start);
			if (ret) {
			pr_info("power trace: Couldn't activate tracepoint"
			" probe to trace_power_start\n");
			return ret;
			}
			ret = register_trace_power_end(probe_power_end);
			if (ret) {
			pr_info("power trace: Couldn't activate tracepoint"
			" probe to trace_power_end\n");
			goto fail_start;
			}
			ret = register_trace_power_mark(probe_power_mark);
			if (ret) {
			pr_info("power trace: Couldn't activate tracepoint"
			" probe to trace_power_mark\n");
			goto fail_end;
			}
			return ret;
			fail_end:
			unregister_trace_power_end(probe_power_end);
			fail_start:
			unregister_trace_power_start(probe_power_start);
			return ret;
			}

	static void start_power_trace(struct trace_array *tr)		static void start_power_trace(struct trace_array *tr)
	{		{
	trace_power_enabled = 1;		trace_power_enabled = 1;
			tracing_power_register();
	}		}

	static void stop_power_trace(struct trace_array *tr)		static void stop_power_trace(struct trace_array *tr)
	{		{
	trace_power_enabled = 0;		trace_power_enabled = 0;
			unregister_trace_power_start(probe_power_start);
			unregister_trace_power_end(probe_power_end);
			unregister_trace_power_mark(probe_power_mark);
	}		}


	@@ -39,6 +140,7 @@ static int power_trace_init(struct trace_array *tr)
	power_trace = tr;		power_trace = tr;

	trace_power_enabled = 1;		trace_power_enabled = 1;
			tracing_power_register();

	for_each_cpu(cpu, cpu_possible_mask)		for_each_cpu(cpu, cpu_possible_mask)
	tracing_reset(tr, cpu);		tracing_reset(tr, cpu);
	@@ -95,74 +197,3 @@ static int init_power_trace(void)
	return register_tracer(&power_tracer);		return register_tracer(&power_tracer);
	}		}
	device_initcall(init_power_trace);		device_initcall(init_power_trace);

	void trace_power_start(struct power_trace *it, unsigned int type,
	unsigned int level)
	{
	if (!trace_power_enabled)
	return;

	memset(it, 0, sizeof(struct power_trace));
	it->state = level;
	it->type = type;
	it->stamp = ktime_get();
	}
	EXPORT_SYMBOL_GPL(trace_power_start);


	void trace_power_end(struct power_trace *it)
	{
	struct ring_buffer_event *event;
	struct trace_power *entry;
	struct trace_array_cpu *data;
	struct trace_array *tr = power_trace;

	if (!trace_power_enabled)
	return;

	preempt_disable();
	it->end = ktime_get();
	data = tr->data[smp_processor_id()];

	event = trace_buffer_lock_reserve(tr, TRACE_POWER,
	sizeof(*entry), 0, 0);
	if (!event)
	goto out;
	entry = ring_buffer_event_data(event);
	entry->state_data = *it;
	trace_buffer_unlock_commit(tr, event, 0, 0);
	out:
	preempt_enable();
	}
	EXPORT_SYMBOL_GPL(trace_power_end);

	void trace_power_mark(struct power_trace *it, unsigned int type,
	unsigned int level)
	{
	struct ring_buffer_event *event;
	struct trace_power *entry;
	struct trace_array_cpu *data;
	struct trace_array *tr = power_trace;

	if (!trace_power_enabled)
	return;

	memset(it, 0, sizeof(struct power_trace));
	it->state = level;
	it->type = type;
	it->stamp = ktime_get();
	preempt_disable();
	it->end = it->stamp;
	data = tr->data[smp_processor_id()];

	event = trace_buffer_lock_reserve(tr, TRACE_POWER,
	sizeof(*entry), 0, 0);
	if (!event)
	goto out;
	entry = ring_buffer_event_data(event);
	entry->state_data = *it;
	trace_buffer_unlock_commit(tr, event, 0, 0);
	out:
	preempt_enable();
	}
	EXPORT_SYMBOL_GPL(trace_power_mark);