tracing: Introduce configurable ring sub buffer size
Subsystems (2)
v2 cover tracing: Introduce configurable ring sub buffer size
From: "Tzvetomir Stoyanov (VMware)" <[email protected]>
Currently the size of one sub buffer page is global for all buffers and it is hard coded to one system page. The patch set introduces configurable ring buffer sub page size, per ring buffer. A new user space interface is introduced, which allows to change the sub page size of the ftrace buffer, per ftrace instance.
v2 changes:
- Split code refactoring in a separate patch.
- Changed the logic to work with order of system pages, instead of page size.
- Fix freeing of the allocated pages, to take into account the actual order.
- Code clean ups.
- Bug fixes.
Tzvetomir Stoyanov (VMware) (4):
[RFC] tracing: Refactor ring buffer implementation [RFC] tracing: Page size per ring buffer
[RFC] tracing: Add interface for configuring trace sub buffer size [WiP] tracing: Set new size of the ring buffer sub page
include/linux/ring_buffer.h | 5 +- kernel/trace/ring_buffer.c | 262 +++++++++++++++++++++++++++--------- kernel/trace/trace.c | 50 ++++++- kernel/trace/trace.h | 1 + kernel/trace/trace_events.c | 50 +++++-- 5 files changed, 293 insertions(+), 75 deletions(-)
Signature · 1 line
2.31.1
RFC PATCH v2 1/4 tracing: Refactor ring buffer implementation
In order to introduce sub-buffer size per ring buffer, some internal refactoring is needed. As ring_buffer_print_page_header() will depend on the trace_buffer structure, it is moved after the structure definition.
--- kernel/trace/ring_buffer.c | 59 +++++++++++++++++++------------------- 1 file changed, 30 insertions(+), 29 deletions(-)
kernel/trace/ring_buffer.c +30 -29
@@ -371,35 +371,6 @@ static inline int test_time_stamp(u64 delta)/* Max payload is BUF_PAGE_SIZE - header (8bytes) */ #define BUF_MAX_DATA_SIZE (BUF_PAGE_SIZE - (sizeof(u32) * 2)) -int ring_buffer_print_page_header (struct trace_seq *s) -{ -struct buffer_data_page field; - -trace_seq_printf (s,"\tfield: u64 timestamp;\t" -"offset:0;\tsize:%u;\tsigned:%u;\n" , - (unsigned int )sizeof (field.time_stamp), - (unsigned int )is_signed_type (u64)); - -trace_seq_printf (s,"\tfield: local_t commit;\t" -"offset:%u;\tsize:%u;\tsigned:%u;\n" , - (unsigned int )offsetof(typeof (field ), commit), - (unsigned int )sizeof (field.commit), - (unsigned int )is_signed_type (long)); - -trace_seq_printf (s,"\tfield: int overwrite;\t" -"offset:%u;\tsize:%u;\tsigned:%u;\n" , - (unsigned int )offsetof(typeof (field ), commit), -1 , - (unsigned int )is_signed_type (long)); - -trace_seq_printf (s,"\tfield: char data;\t" -"offset:%u;\tsize:%u;\tsigned:%u;\n" , - (unsigned int )offsetof(typeof (field ), data), - (unsigned int )BUF_PAGE_SIZE , - (unsigned int )is_signed_type (char)); - -return !trace_seq_has_overflowed (s); -}struct rb_irq_work {struct irq_work work;
@@ -559,6 +530,36 @@ struct ring_buffer_iter {int missed_events; }; +int ring_buffer_print_page_header (struct trace_seq *s) +{ +struct buffer_data_page field; + +trace_seq_printf (s,"\tfield: u64 timestamp;\t" +"offset:0;\tsize:%u;\tsigned:%u;\n" , + (unsigned int )sizeof (field.time_stamp), + (unsigned int )is_signed_type (u64)); + +trace_seq_printf (s,"\tfield: local_t commit;\t" +"offset:%u;\tsize:%u;\tsigned:%u;\n" , + (unsigned int )offsetof(typeof (field ), commit), + (unsigned int )sizeof (field.commit), + (unsigned int )is_signed_type (long)); + +trace_seq_printf (s,"\tfield: int overwrite;\t" +"offset:%u;\tsize:%u;\tsigned:%u;\n" , + (unsigned int )offsetof(typeof (field ), commit), +1 , + (unsigned int )is_signed_type (long)); + +trace_seq_printf (s,"\tfield: char data;\t" +"offset:%u;\tsize:%u;\tsigned:%u;\n" , + (unsigned int )offsetof(typeof (field ), data), + (unsigned int )BUF_PAGE_SIZE , + (unsigned int )is_signed_type (char)); + +return !trace_seq_has_overflowed (s); +} +#ifdef RB_TIME_32 /*
Signature · 1 line
2.31.1
RFC PATCH v2 2/4 tracing: Page size per ring buffer
In reply to Tzvetomir Stoyanov (VMware)Currently the size of one sub buffer page is global for all buffers and it is hard coded to one system page. In order to introduce configurable ring buffer sub page size, the internal logic should be refactored to work with page size per ring buffer.
--- include/linux/ring_buffer.h | 2 +- kernel/trace/ring_buffer.c | 66 ++++++++++++++++++++----------------- kernel/trace/trace.c | 2 +- kernel/trace/trace.h | 1 + kernel/trace/trace_events.c | 50 ++++++++++++++++++++++------ 5 files changed, 79 insertions(+), 42 deletions(-)
include/linux/ring_buffer.h +1 -1
@@ -200,7 +200,7 @@ int ring_buffer_read_page(struct trace_buffer *buffer, void **data_page,struct trace_seq ;int ring_buffer_print_entry_header (struct trace_seq *s); -int ring_buffer_print_page_header (struct trace_seq *s); +int ring_buffer_print_page_header (struct trace_buffer *buffer,struct trace_seq *s);enum ring_buffer_flags {RB_FL_OVERWRITE =1 <<0 ,
kernel/trace/ring_buffer.c +36 -30
220 lines not on this page · raw message
kernel/trace/trace.c +1 -1
@@ -4865,7 +4865,7 @@ static int tracing_release(struct inode *inode, struct file *file)return 0 ; } -static int tracing_release_generic_tr (struct inode *inode,struct file *file) +int tracing_release_generic_tr (struct inode *inode,struct file *file) {struct trace_array *tr = inode->i_private;
kernel/trace/trace.h +1 -0
@@ -580,6 +580,7 @@ void tracing_reset_current(int cpu);void tracing_reset_all_online_cpus (void );int tracing_open_generic (struct inode *inode,struct file *filp);int tracing_open_generic_tr (struct inode *inode,struct file *filp); +int tracing_release_generic_tr (struct inode *inode,struct file *file);bool tracing_is_disabled (void );bool tracer_tracing_is_on (struct trace_array *tr);void tracer_tracing_on (struct trace_array *tr);
kernel/trace/trace_events.c +40 -10
80 lines not on this page · raw message
Signature · 1 line
2.31.1
RFC PATCH v2 3/4 tracing: Add interface for configuring trace sub buffer size
In reply to Tzvetomir Stoyanov (VMware)The trace ring buffer sub page size can be configured, per trace instance. A new ftrace file "buffer_subbuf_order" is added to get and set the size of the ring buffer sub page for current trace instance. The size must be an order of system page size, that's why the new interface works with system page order, instead of absolute page size:
0 means the ring buffer sub page is equal to 1 system page and so forth:
0 - 1 system page
1 - 2 system pages
2 - 4 system pages
...
The ring buffer sub page size is limited between 1 and 128 system pages. The default value is 1 system page.
--- include/linux/ring_buffer.h | 3 ++ kernel/trace/ring_buffer.c | 61 +++++++++++++++++++++++++++++++++++++ kernel/trace/trace.c | 48 +++++++++++++++++++++++++++++ 3 files changed, 112 insertions(+)
include/linux/ring_buffer.h +3 -0
@@ -202,6 +202,9 @@ struct trace_seq;int ring_buffer_print_entry_header (struct trace_seq *s);int ring_buffer_print_page_header (struct trace_buffer *buffer,struct trace_seq *s); +int ring_buffer_subbuf_order_get (struct trace_buffer *buffer); +int ring_buffer_subbuf_order_set (struct trace_buffer *buffer,int order); +enum ring_buffer_flags {RB_FL_OVERWRITE =1 <<0 , };
kernel/trace/ring_buffer.c +61 -0
73 lines not on this page · raw message
kernel/trace/trace.c +48 -0
60 lines not on this page · raw message
Signature · 1 line
2.31.1
PATCH v2 4/4 tracing: Set new size of the ring buffer sub page
In reply to Tzvetomir Stoyanov (VMware)There are two approaches when changing the size of the ring buffer sub page:
1. Destroying all pages and allocating new pages with the new size.
2. Allocating new pages, copying the content of the old pages before destroying them.
The first approach is easier, it is selected in the proposed implementation. Changing the ring buffer sub page size is supposed to not happen frequently. Usually, that size should be set only once, when the buffer is not in use yet and is supposed to be empty.
--- kernel/trace/ring_buffer.c | 82 ++++++++++++++++++++++++++++++++++---- 1 file changed, 75 insertions(+), 7 deletions(-)
kernel/trace/ring_buffer.c +75 -7
@@ -323,6 +323,7 @@ struct buffer_page {unsigned read;/* index for next read */ local_t entries;/* entries on this page */ unsigned long real_end;/* real end of data */ +unsigned order;/* order of the page */ struct buffer_data_page *page;/* Actual data page */ };
@@ -352,7 +353,7 @@ static void rb_init_page(struct buffer_data_page *bpage)*/ static void free_buffer_page (struct buffer_page *bpage) { -free_page ((unsigned long )bpage->page); +free_pages ((unsigned long )bpage->page, bpage->order);kfree (bpage); }
@@ -1551,6 +1552,7 @@ static int __rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,*/ if (user_thread)set_current_oom_origin (); +for (i =0 ; i < nr_pages; i++) {struct page *page;
@@ -1563,10 +1565,12 @@ static int __rb_allocate_pages(struct ring_buffer_per_cpu *cpu_buffer,list_add (&bpage->list, pages); - page =alloc_pages_node (cpu_to_node (cpu_buffer->cpu), mflags,0 ); + page =alloc_pages_node (cpu_to_node (cpu_buffer->cpu), mflags, + cpu_buffer->buffer->subbuf_order);if (!page) goto free_pages; bpage->page =page_address (page); + bpage->order = cpu_buffer->buffer->subbuf_order;rb_init_page (bpage->page);if (user_thread &&fatal_signal_pending (current))
@@ -1645,7 +1649,8 @@ rb_allocate_cpu_buffer(struct trace_buffer *buffer, long nr_pages, int cpu)rb_check_bpage (cpu_buffer, bpage); cpu_buffer->reader_page = bpage; - page =alloc_pages_node (cpu_to_node (cpu),GFP_KERNEL ,0 ); + + page =alloc_pages_node (cpu_to_node (cpu),GFP_KERNEL , cpu_buffer->buffer->subbuf_order);if (!page) goto fail_free_reader; bpage->page =page_address (page);
@@ -1725,6 +1730,7 @@ struct trace_buffer *__ring_buffer_alloc(unsigned long size, unsigned flags, goto fail_free_buffer;/* Default buffer page size - one system page */ + buffer->subbuf_order =0 ; buffer->subbuf_size =PAGE_SIZE -BUF_PAGE_HDR_SIZE ;/* Max payload is buffer page size - header (8bytes) */
@@ -5434,8 +5440,8 @@ void *ring_buffer_alloc_read_page(struct trace_buffer *buffer, int cpu)if (bpage) goto out; - page =alloc_pages_node (cpu_to_node (cpu), -GFP_KERNEL | __GFP_NORETRY,0 ); + page =alloc_pages_node (cpu_to_node (cpu),GFP_KERNEL | __GFP_NORETRY, + cpu_buffer->buffer->subbuf_order);if (!page)return ERR_PTR (-ENOMEM );
@@ -5479,7 +5485,7 @@ void ring_buffer_free_read_page(struct trace_buffer *buffer, int cpu, void *datalocal_irq_restore (flags); out: -free_page ((unsigned long )bpage); +free_pages ((unsigned long )bpage, buffer->subbuf_order); }EXPORT_SYMBOL_GPL (ring_buffer_free_read_page);
@@ -5719,7 +5725,14 @@ EXPORT_SYMBOL_GPL(ring_buffer_subbuf_order_get);*/ int ring_buffer_subbuf_order_set (struct trace_buffer *buffer,int order) { +struct ring_buffer_per_cpu **cpu_buffers; +int old_order, old_size; +int nr_pages; +int ret =0 ;int psize; +int bsize; +int err; +int cpu;if (!buffer || order <0 )return -EINVAL ;
@@ -5731,12 +5744,67 @@ int ring_buffer_subbuf_order_set(struct trace_buffer *buffer, int order)if (psize <=BUF_PAGE_HDR_SIZE )return -EINVAL ; + bsize =sizeof (void *) * buffer->cpus; + cpu_buffers =kzalloc (bsize,GFP_KERNEL ); +if (!cpu_buffers) +return -ENOMEM ; + + old_order = buffer->subbuf_order; + old_size = buffer->subbuf_size; + +/* prevent another thread from changing buffer sizes */ +mutex_lock (&buffer->mutex); +atomic_inc (&buffer->record_disabled); + +/* Make sure all commits have finished */ +synchronize_rcu (); + buffer->subbuf_order = order; buffer->subbuf_size = psize -BUF_PAGE_HDR_SIZE ; -/* Todo: reset the buffer with the new page size */ +/* Make sure all new buffers are allocated, before deleting the old ones */ +for_each_buffer_cpu (buffer, cpu) { +if (!cpumask_test_cpu (cpu, buffer->cpumask)) +continue ; + + nr_pages = buffer->buffers[cpu]->nr_pages; + cpu_buffers[cpu] =rb_allocate_cpu_buffer (buffer, nr_pages, cpu); +if (!cpu_buffers[cpu]) { + err = -ENOMEM ; + goto error; + } + } + +for_each_buffer_cpu (buffer, cpu) { +if (!cpumask_test_cpu (cpu, buffer->cpumask)) +continue ; + +rb_free_cpu_buffer (buffer->buffers[cpu]); + buffer->buffers[cpu] = cpu_buffers[cpu]; + } + +atomic_dec (&buffer->record_disabled); +mutex_unlock (&buffer->mutex); + +kfree (cpu_buffers);return 0 ; + +error: + buffer->subbuf_order = old_order; + buffer->subbuf_size = old_size; + +atomic_dec (&buffer->record_disabled); +mutex_unlock (&buffer->mutex); + +for_each_buffer_cpu (buffer, cpu) { +if (!cpu_buffers[cpu]) +continue ; +kfree (cpu_buffers[cpu]); + } +kfree (cpu_buffers); + +return err; }EXPORT_SYMBOL_GPL (ring_buffer_subbuf_order_set);
Signature · 1 line
2.31.1