tracing: Fixes for v7.2
Subsystems (3)
cover tracing: Fixes for v7.2
tracing fixes for v7.2:
- Add selftest that tests deferred event teardown
- Fix leak in error path of trace_remote_alloc_buffer()
If page allocation fails, the desc->nr_cpus is not incremented for the current CPU and the allocations done for it are not freed.
- Fix allocation length in trace_remote_alloc_buffer()
The logic to calculate the struct_len was doing a double count and setting the value too large. Calculate the size upfront to fix the error and simplify the logic.
- Fix sparse CPU masks in ring_buffer_desc()
If there are sparse CPUs (gaps in the numbering), the ring_buffer_desc() will fail as it tests the CPU number against the number of CPUs that are used.
git://git.kernel.org/pub/scm/linux/kernel/git/trace/linux-trace.git
trace/fixes
Head SHA1: 601ddaceb861be7eb557278109966320a6f3478c
Michael Bommarito (1):
selftests/user_events: Wait for deferred event teardown after unregister
Vincent Donnefort (3):
tracing/remotes: Fix leak in trace_remote_alloc_buffer() error path tracing/remotes: Fix struct_len in trace_remote_alloc_buffer()
ring-buffer: Allow sparse CPU masks in ring_buffer_desc()
----
kernel/trace/ring_buffer.c | 5 +---- kernel/trace/trace_remote.c | 18 +++++---------- tools/testing/selftests/user_events/abi_test.c | 29 ++++++++++++++++++++++++- tools/testing/selftests/user_events/perf_test.c | 26 +++++++++++++++++++--- 4 files changed, 58 insertions(+), 20 deletions(-)
PATCH 1/4 selftests/user_events: Wait for deferred event teardown after unregister
From: Michael Bommarito <[email protected]>
Unregistering a user event now defers the drop of the enabler's event reference (and the freeing of the enabler) past an RCU grace period. As a result DIAG_IOCSDEL can transiently fail with -EBUSY while that last reference is still being dropped, where it previously succeeded immediately.
Two tests assumed the delete takes effect the instant the unregister returns:
- abi_test "flags" deletes the event right after disabling it.
- perf_test's fixture teardown clear() deletes __test_event before the next test registers the same name; a stale event makes the following registration fail with -EADDRINUSE.
Retry the delete until it succeeds (or the event is already gone) with a bounded wait, matching the existing wait_for_delete() idiom in the same suite, so the tests are robust to the deferred teardown.
--- .../testing/selftests/user_events/abi_test.c | 29 ++++++++++++++++++- .../testing/selftests/user_events/perf_test.c | 26 +++++++++++++++-- 2 files changed, 51 insertions(+), 4 deletions(-)
tools/testing/selftests/user_events/abi_test.c +28 -1
@@ -132,6 +132,33 @@ static int event_delete(void)return ret; } +/* +* Deleting an event drops its last reference, but an unregister may defer +* that put (and the freeing of the associated enabler) past an RCU grace +* period. The delete can therefore transiently fail with -EBUSY while the +* previous reference is still being dropped. Retry only on that transient +* failure; treat an already-deleted event (-ENOENT) as success and return +* any other error immediately rather than spinning for the full timeout. +*/ +static int wait_for_event_delete (void ) +{ +int i, ret; + +for (i =0 ; i <10000 ; ++i) { + ret =event_delete (); + +if (ret ==0 || errno ==ENOENT ) +return 0 ; + +if (errno !=EBUSY ) +return ret; + +usleep (1000 ); + } + +return ret; +} +static int reg_enable_multi (void *enable,int size,int bit,int flags,char *args) {
@@ -262,7 +289,7 @@ TEST_F(user, flags) {ASSERT_TRUE (event_exists ());/* Ensure we can delete it */ -ASSERT_EQ (0 ,event_delete ()); +ASSERT_EQ (0 ,wait_for_event_delete ());/* USER_EVENT_REG_MAX or above is not allowed */ ASSERT_EQ(-1, reg_enable_flags(&self->check, sizeof(int), 0,
tools/testing/selftests/user_events/perf_test.c +23 -3
@@ -85,6 +85,7 @@ static int get_offset(void)static int clear (int *check) {struct user_unreg unreg = {0 }; +int i, ret; unreg.size =sizeof (unreg); unreg.disable_bit =31 ;
@@ -99,13 +100,32 @@ static int clear(int *check)if (errno !=ENOENT )return -1 ; -if (ioctl (fd,DIAG_IOCSDEL ,"__test_event" ) ==-1 ) -if (errno !=ENOENT ) +/* +* Deleting the event drops its last reference, but the unregister +* above defers that put (and the freeing of the enabler) past an RCU +* grace period. The delete can therefore transiently fail with -EBUSY +* until that reference is dropped. Retry for up to ~10 seconds so the +* event is actually gone before the next test registers the same name. +*/ +for (i =0 ; i <10000 ; ++i) { + ret =ioctl (fd,DIAG_IOCSDEL ,"__test_event" ); + +if (ret ==0 || errno ==ENOENT ) { + ret =0 ; +break ; + } + +if (errno !=EBUSY ) { +close (fd);return -1 ; + } + +usleep (1000 ); + }close (fd); -return 0 ; +return ret; }FIXTURE (user) {
Signature · 1 line
2.53.0
PATCH 2/4 tracing/remotes: Fix leak in trace_remote_alloc_buffer() error path
In reply to Steven RostedtFrom: Vincent Donnefort <[email protected]>
If page allocation fails in trace_remote_alloc_buffer(), desc->nr_cpus is not yet incremented for the current CPU. As a consequence, on error, half-allocated rb_desc will not be freed in trace_remote_free_buffer().
Increment desc->nr_cpus as soon as the first allocation for the current CPU has succeeded.
--- kernel/trace/trace_remote.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
kernel/trace/trace_remote.c +2 -1
@@ -1006,6 +1006,8 @@ int trace_remote_alloc_buffer(struct trace_buffer_desc *desc, size_t desc_size,if (!rb_desc->meta_va) goto err; + desc->nr_cpus++; +for (id =0 ; id < nr_pages; id++) { rb_desc->page_va[id] = (unsigned long )__get_free_page (GFP_KERNEL );if (!rb_desc->page_va[id])
@@ -1013,7 +1015,6 @@ int trace_remote_alloc_buffer(struct trace_buffer_desc *desc, size_t desc_size, rb_desc->nr_page_va++; } - desc->nr_cpus++; desc->struct_len += offsetof(struct ring_buffer_desc , page_va); desc->struct_len +=struct_size (rb_desc, page_va, rb_desc->nr_page_va); rb_desc =__next_ring_buffer_desc (rb_desc);
Signature · 1 line
2.53.0
PATCH 3/4 tracing/remotes: Fix struct_len in trace_remote_alloc_buffer()
In reply to Steven RostedtFrom: Vincent Donnefort <[email protected]>
Pre-calculate desc->struct_len up-front in trace_remote_alloc_buffer() with trace_buffer_desc_size() to fix double-counting.
While at it, use the accessor __first_ring_buffer_desc().
--- kernel/trace/trace_remote.c | 15 ++++----------- 1 file changed, 4 insertions(+), 11 deletions(-)
kernel/trace/trace_remote.c +4 -11
@@ -979,27 +979,22 @@ EXPORT_SYMBOL_GPL(trace_remote_free_buffer);int trace_remote_alloc_buffer (struct trace_buffer_desc *desc,size_t desc_size,size_t buffer_size,const struct cpumask *cpumask) { +size_t min_desc_size =trace_buffer_desc_size (buffer_size,cpumask_weight (cpumask));unsigned int nr_pages =max (DIV_ROUND_UP (buffer_size,PAGE_SIZE ),2UL ) +1 ; -void *desc_end = desc + desc_size;struct ring_buffer_desc *rb_desc;int cpu, ret = -ENOMEM ; -if (desc_size <struct_size (desc, __data,0 )) +if (desc_size < min_desc_size)return -EINVAL ; desc->nr_cpus =0 ; - desc->struct_len =struct_size (desc, __data,0 ); + desc->struct_len = min_desc_size; - rb_desc = (struct ring_buffer_desc *)&desc->__data[0 ]; + rb_desc =__first_ring_buffer_desc (desc);for_each_cpu (cpu, cpumask) {unsigned int id; -if ((void *)rb_desc +struct_size (rb_desc, page_va, nr_pages) > desc_end) { - ret = -EINVAL ; - goto err; - } - rb_desc->cpu = cpu; rb_desc->nr_page_va =0 ; rb_desc->meta_va = (unsigned long )__get_free_page (GFP_KERNEL );
@@ -1015,8 +1010,6 @@ int trace_remote_alloc_buffer(struct trace_buffer_desc *desc, size_t desc_size, rb_desc->nr_page_va++; } - desc->struct_len += offsetof(struct ring_buffer_desc , page_va); - desc->struct_len +=struct_size (rb_desc, page_va, rb_desc->nr_page_va); rb_desc =__next_ring_buffer_desc (rb_desc); }
Signature · 1 line
2.53.0
PATCH 4/4 ring-buffer: Allow sparse CPU masks in ring_buffer_desc()
In reply to Steven RostedtFrom: Vincent Donnefort <[email protected]>
No user currently relies on sparse CPU masks, but the descriptor logic already supports them via linear fallback. Remove the arbitrary limitation.
--- kernel/trace/ring_buffer.c | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-)
kernel/trace/ring_buffer.c +1 -4
@@ -2330,10 +2330,7 @@ static struct ring_buffer_desc *ring_buffer_desc(struct trace_buffer_desc *tracesize_t len;int i; -if (!trace_desc) -return NULL ; - -if (cpu >= trace_desc->nr_cpus) +if (!trace_desc || !trace_desc->nr_cpus)return NULL ; end = (struct ring_buffer_desc *)((void *)trace_desc + trace_desc->struct_len);
Signature · 1 line
2.53.0