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

Commit 41cbc01f authored by Linus Torvalds's avatar Linus Torvalds
Browse files

Merge tag 'trace-v3.20' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace 

Pull tracing updates from Steven Rostedt:
 "The updates included in this pull request for ftrace are:

   o Several clean ups to the code

     One such clean up was to convert to 64 bit time keeping, in the
     ring buffer benchmark code.

   o Adding of __print_array() helper macro for TRACE_EVENT()

   o Updating the sample/trace_events/ to add samples of different ways
     to make trace events.  Lots of features have been added since the
     sample code was made, and these features are mostly unknown.
     Developers have been making their own hacks to do things that are
     already available.

   o Performance improvements.  Most notably, I found a performance bug
     where a waiter that is waiting for a full page from the ring buffer
     will see that a full page is not available, and go to sleep.  The
     sched event caused by it going to sleep would cause it to wake up
     again.  It would see that there was still not a full page, and go
     back to sleep again, and that would wake it up again, until finally
     it would see a full page.  This change has been marked for stable.

  Other improvements include removing global locks from fast paths"

* tag 'trace-v3.20' of git://git.kernel.org/pub/scm/linux/kernel/git/rostedt/linux-trace:
  ring-buffer: Do not wake up a splice waiter when page is not full
  tracing: Fix unmapping loop in tracing_mark_write
  tracing: Add samples of DECLARE_EVENT_CLASS() and DEFINE_EVENT()
  tracing: Add TRACE_EVENT_FN example
  tracing: Add TRACE_EVENT_CONDITION sample
  tracing: Update the TRACE_EVENT fields available in the sample code
  tracing: Separate out initializing top level dir from instances
  tracing: Make tracing_init_dentry_tr() static
  trace: Use 64-bit timekeeping
  tracing: Add array printing helper
  tracing: Remove newline from trace_printk warning banner
  tracing: Use IS_ERR() check for return value of tracing_init_dentry()
  tracing: Remove unneeded includes of debugfs.h and fs.h
  tracing: Remove taking of trace_types_lock in pipe files
  tracing: Add ref count to tracer for when they are being read by pipe
parents 12df4289 1e0d6714

include/linux/ftrace_event.h

+4 −0
Original line number Diff line number Diff line
@@ -44,6 +44,10 @@ const char *ftrace_print_bitmask_seq(struct trace_seq *p, void *bitmask_ptr, 
const char *ftrace_print_hex_seq(struct trace_seq *p,

				 const unsigned char *buf, int len);



const char *ftrace_print_array_seq(struct trace_seq *p,

				   const void *buf, int buf_len,

				   size_t el_size);



struct trace_iterator;

struct trace_event;

include/trace/ftrace.h

+9 −0
Original line number Diff line number Diff line
@@ -263,6 +263,14 @@ 
#undef __print_hex

#define __print_hex(buf, buf_len) ftrace_print_hex_seq(p, buf, buf_len)



#undef __print_array

#define __print_array(array, count, el_size)				\

	({								\

		BUILD_BUG_ON(el_size != 1 && el_size != 2 &&		\

			     el_size != 4 && el_size != 8);		\

		ftrace_print_array_seq(p, array, count, el_size);	\

	})



#undef DECLARE_EVENT_CLASS

#define DECLARE_EVENT_CLASS(call, proto, args, tstruct, assign, print)	\

static notrace enum print_line_t					\
@@ -674,6 +682,7 @@ static inline void ftrace_test_probe_##call(void) \ 
#undef __get_dynamic_array_len

#undef __get_str

#undef __get_bitmask

#undef __print_array



#undef TP_printk

#define TP_printk(fmt, args...) "\"" fmt "\", "  __stringify(args)

kernel/trace/ftrace.c

+1 −1
Original line number Diff line number Diff line
@@ -5456,7 +5456,7 @@ static __init int ftrace_init_debugfs(void) 
	struct dentry *d_tracer;



	d_tracer = tracing_init_dentry();

	if (!d_tracer)

	if (IS_ERR(d_tracer))

		return 0;



	ftrace_init_dyn_debugfs(d_tracer);

kernel/trace/ring_buffer.c

+35 −7
Original line number Diff line number Diff line
@@ -9,7 +9,6 @@ 
#include <linux/trace_seq.h>

#include <linux/spinlock.h>

#include <linux/irq_work.h>

#include <linux/debugfs.h>

#include <linux/uaccess.h>

#include <linux/hardirq.h>

#include <linux/kthread.h>	/* for self test */
@@ -23,7 +22,6 @@ 
#include <linux/hash.h>

#include <linux/list.h>

#include <linux/cpu.h>

#include <linux/fs.h>



#include <asm/local.h>
@@ -447,7 +445,10 @@ int ring_buffer_print_page_header(struct trace_seq *s) 
struct rb_irq_work {

	struct irq_work			work;

	wait_queue_head_t		waiters;

	wait_queue_head_t		full_waiters;

	bool				waiters_pending;

	bool				full_waiters_pending;

	bool				wakeup_full;

};



/*
@@ -529,6 +530,10 @@ static void rb_wake_up_waiters(struct irq_work *work) 
	struct rb_irq_work *rbwork = container_of(work, struct rb_irq_work, work);



	wake_up_all(&rbwork->waiters);

	if (rbwork->wakeup_full) {

		rbwork->wakeup_full = false;

		wake_up_all(&rbwork->full_waiters);

	}

}



/**
@@ -553,9 +558,11 @@ int ring_buffer_wait(struct ring_buffer *buffer, int cpu, bool full) 
	 * data in any cpu buffer, or a specific buffer, put the

	 * caller on the appropriate wait queue.

	 */

	if (cpu == RING_BUFFER_ALL_CPUS)

	if (cpu == RING_BUFFER_ALL_CPUS) {

		work = &buffer->irq_work;

	else {

		/* Full only makes sense on per cpu reads */

		full = false;

	} else {

		if (!cpumask_test_cpu(cpu, buffer->cpumask))

			return -ENODEV;

		cpu_buffer = buffer->buffers[cpu];
@@ -564,6 +571,9 @@ int ring_buffer_wait(struct ring_buffer *buffer, int cpu, bool full) 




	while (true) {

		if (full)

			prepare_to_wait(&work->full_waiters, &wait, TASK_INTERRUPTIBLE);

		else

			prepare_to_wait(&work->waiters, &wait, TASK_INTERRUPTIBLE);



		/*
@@ -586,6 +596,9 @@ int ring_buffer_wait(struct ring_buffer *buffer, int cpu, bool full) 
		 * that is necessary is that the wake up happens after

		 * a task has been queued. It's OK for spurious wake ups.

		 */

		if (full)

			work->full_waiters_pending = true;

		else

			work->waiters_pending = true;



		if (signal_pending(current)) {
@@ -615,6 +628,9 @@ int ring_buffer_wait(struct ring_buffer *buffer, int cpu, bool full) 
		schedule();

	}



	if (full)

		finish_wait(&work->full_waiters, &wait);

	else

		finish_wait(&work->waiters, &wait);



	return ret;
@@ -1230,6 +1246,7 @@ rb_allocate_cpu_buffer(struct ring_buffer *buffer, int nr_pages, int cpu) 
	init_completion(&cpu_buffer->update_done);

	init_irq_work(&cpu_buffer->irq_work.work, rb_wake_up_waiters);

	init_waitqueue_head(&cpu_buffer->irq_work.waiters);

	init_waitqueue_head(&cpu_buffer->irq_work.full_waiters);



	bpage = kzalloc_node(ALIGN(sizeof(*bpage), cache_line_size()),

			    GFP_KERNEL, cpu_to_node(cpu));
@@ -2801,6 +2818,8 @@ static void rb_commit(struct ring_buffer_per_cpu *cpu_buffer, 
static __always_inline void

rb_wakeups(struct ring_buffer *buffer, struct ring_buffer_per_cpu *cpu_buffer)

{

	bool pagebusy;



	if (buffer->irq_work.waiters_pending) {

		buffer->irq_work.waiters_pending = false;

		/* irq_work_queue() supplies it's own memory barriers */
@@ -2812,6 +2831,15 @@ rb_wakeups(struct ring_buffer *buffer, struct ring_buffer_per_cpu *cpu_buffer) 
		/* irq_work_queue() supplies it's own memory barriers */

		irq_work_queue(&cpu_buffer->irq_work.work);

	}



	pagebusy = cpu_buffer->reader_page == cpu_buffer->commit_page;



	if (!pagebusy && cpu_buffer->irq_work.full_waiters_pending) {

		cpu_buffer->irq_work.wakeup_full = true;

		cpu_buffer->irq_work.full_waiters_pending = false;

		/* irq_work_queue() supplies it's own memory barriers */

		irq_work_queue(&cpu_buffer->irq_work.work);

	}

}



/**

kernel/trace/ring_buffer_benchmark.c

+8 −10
Original line number Diff line number Diff line
@@ -7,7 +7,7 @@ 
#include <linux/completion.h>

#include <linux/kthread.h>

#include <linux/module.h>

#include <linux/time.h>

#include <linux/ktime.h>

#include <asm/local.h>



struct rb_page {
@@ -17,7 +17,7 @@ struct rb_page { 
};



/* run time and sleep time in seconds */

#define RUN_TIME	10

#define RUN_TIME	10ULL

#define SLEEP_TIME	10



/* number of events for writer to wake up the reader */
@@ -212,8 +212,7 @@ static void ring_buffer_consumer(void) 


static void ring_buffer_producer(void)

{

	struct timeval start_tv;

	struct timeval end_tv;

	ktime_t start_time, end_time, timeout;

	unsigned long long time;

	unsigned long long entries;

	unsigned long long overruns;
@@ -227,7 +226,8 @@ static void ring_buffer_producer(void) 
	 * make the system stall)

	 */

	trace_printk("Starting ring buffer hammer\n");

	do_gettimeofday(&start_tv);

	start_time = ktime_get();

	timeout = ktime_add_ns(start_time, RUN_TIME * NSEC_PER_SEC);

	do {

		struct ring_buffer_event *event;

		int *entry;
@@ -244,7 +244,7 @@ static void ring_buffer_producer(void) 
				ring_buffer_unlock_commit(buffer, event);

			}

		}

		do_gettimeofday(&end_tv);

		end_time = ktime_get();



		cnt++;

		if (consumer && !(cnt % wakeup_interval))
@@ -264,7 +264,7 @@ static void ring_buffer_producer(void) 
			cond_resched();

#endif



	} while (end_tv.tv_sec < (start_tv.tv_sec + RUN_TIME) && !kill_test);

	} while (ktime_before(end_time, timeout) && !kill_test);

	trace_printk("End ring buffer hammer\n");



	if (consumer) {
@@ -280,9 +280,7 @@ static void ring_buffer_producer(void) 
		wait_for_completion(&read_done);

	}



	time = end_tv.tv_sec - start_tv.tv_sec;

	time *= USEC_PER_SEC;

	time += (long long)((long)end_tv.tv_usec - (long)start_tv.tv_usec);

	time = ktime_us_delta(end_time, start_time);



	entries = ring_buffer_entries(buffer);

	overruns = ring_buffer_overruns(buffer);