github-mirror/linux
1
0
Fork 0
mirror of https://github.com/torvalds/linux.git synced 2026-11-07 06:17:02 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity Graph

tracing: Rename trace_array::entries to capacity

Browse Source 
Since commit 8a5f636378 ("ring-buffer: Fix subbuf resize race with
ring buffer readers"), "capacity" refers to the memory available for
events, while "entries" refers to the number of events in a ring buffer.
As a consequence, rename trace_array::entries to capacity to align with
this convention and avoid any confusion.

Rename also the helper functions trace_set_buffer_entries and
update_buffer_entries.

Link: https://patch.msgid.link/20260908090937.838544-3-vdonnefort@google.com
Signed-off-by: Vincent Donnefort <vdonnefort@google.com>
Signed-off-by: Steven Rostedt <rostedt@goodmis.org>
This commit is contained in:
Vincent Donnefort 2026-09-08 10:09:36 +01:00 committed by Steven Rostedt
parent 4b0c4fb9bc
commit e41338909f
3 changed files with 22 additions and 22 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
kernel/trace/trace.c
View File

@ -4701,20 +4701,20 @@ int tracer_init(struct tracer *t, struct trace_array *tr)
return t->init(tr);
}
void trace_set_buffer_entries(struct array_buffer *buf, unsigned long val)
void trace_set_buffer_capacity(struct array_buffer *buf, unsigned long val)
{
int cpu;
for_each_tracing_cpu(cpu)
per_cpu_ptr(buf->data, cpu)->entries = val;
per_cpu_ptr(buf->data, cpu)->capacity = val;
}
static void update_buffer_entries(struct array_buffer *buf, int cpu)
static void update_buffer_capacity(struct array_buffer *buf, int cpu)
{
if (cpu == RING_BUFFER_ALL_CPUS) {
trace_set_buffer_entries(buf, ring_buffer_capacity(buf->buffer, 0));
trace_set_buffer_capacity(buf, ring_buffer_capacity(buf->buffer, 0));
} else {
per_cpu_ptr(buf->data, cpu)->entries = ring_buffer_capacity(buf->buffer, cpu);
per_cpu_ptr(buf->data, cpu)->capacity = ring_buffer_capacity(buf->buffer, cpu);
}
}
@ -4770,12 +4770,12 @@ static int __tracing_resize_ring_buffer(struct trace_array *tr,
goto out_start;
}
update_buffer_entries(&tr->snapshot_buffer, cpu);
update_buffer_capacity(&tr->snapshot_buffer, cpu);
out:
#endif /* CONFIG_TRACER_SNAPSHOT */
update_buffer_entries(&tr->array_buffer, cpu);
update_buffer_capacity(&tr->array_buffer, cpu);
out_start:
tracing_start_tr(tr);
return ret;
@ -5694,8 +5694,8 @@ tracing_entries_read(struct file *filp, char __user *ubuf,
for_each_tracing_cpu(cpu) {
/* fill in the size from first enabled cpu */
if (size == 0)
size = per_cpu_ptr(tr->array_buffer.data, cpu)->entries;
if (size != per_cpu_ptr(tr->array_buffer.data, cpu)->entries) {
size = per_cpu_ptr(tr->array_buffer.data, cpu)->capacity;
if (size != per_cpu_ptr(tr->array_buffer.data, cpu)->capacity) {
buf_size_same = 0;
break;
}
@ -5711,7 +5711,7 @@ tracing_entries_read(struct file *filp, char __user *ubuf,
} else
r = sprintf(buf, "X\n");
} else
r = sprintf(buf, "%lu\n", per_cpu_ptr(tr->array_buffer.data, cpu)->entries >> 10);
r = sprintf(buf, "%lu\n", per_cpu_ptr(tr->array_buffer.data, cpu)->capacity >> 10);
mutex_unlock(&trace_types_lock);
@ -5758,7 +5758,7 @@ tracing_total_entries_read(struct file *filp, char __user *ubuf,
mutex_lock(&trace_types_lock);
for_each_tracing_cpu(cpu) {
size += per_cpu_ptr(tr->array_buffer.data, cpu)->entries >> 10;
size += per_cpu_ptr(tr->array_buffer.data, cpu)->capacity >> 10;
if (!tr->ring_buffer_expanded)
expanded_size += trace_buf_size >> 10;
}
@ -8519,8 +8519,8 @@ int allocate_trace_buffer(struct trace_array *tr, struct array_buffer *buf, int
}
/* Allocate the first page for all buffers */
trace_set_buffer_entries(&tr->array_buffer,
ring_buffer_capacity(tr->array_buffer.buffer, 0));
trace_set_buffer_capacity(&tr->array_buffer,
ring_buffer_capacity(tr->array_buffer.buffer, 0));
return 0;
}

4
kernel/trace/trace.h
View File

@ -191,7 +191,7 @@ struct trace_array;
struct trace_array_cpu {
local_t disabled;
unsigned long entries;
unsigned long capacity;
unsigned long saved_latency;
unsigned long critical_start;
unsigned long critical_end;
@ -731,7 +731,7 @@ ssize_t tracing_nsecs_read(unsigned long *ptr, char __user *ubuf,
ssize_t tracing_nsecs_write(unsigned long *ptr, const char __user *ubuf,
size_t cnt, loff_t *ppos);
void trace_set_buffer_entries(struct array_buffer *buf, unsigned long val);
void trace_set_buffer_capacity(struct array_buffer *buf, unsigned long val);
/*
* Should be used after trace_array_get(), trace_types_lock

14
kernel/trace/trace_snapshot.c
View File

@ -142,18 +142,18 @@ int resize_buffer_duplicate_size(struct array_buffer *trace_buf,
if (cpu_id == RING_BUFFER_ALL_CPUS) {
for_each_tracing_cpu(cpu) {
ret = ring_buffer_resize(trace_buf->buffer,
per_cpu_ptr(size_buf->data, cpu)->entries, cpu);
per_cpu_ptr(size_buf->data, cpu)->capacity, cpu);
if (ret < 0)
break;
per_cpu_ptr(trace_buf->data, cpu)->entries =
per_cpu_ptr(size_buf->data, cpu)->entries;
per_cpu_ptr(trace_buf->data, cpu)->capacity =
per_cpu_ptr(size_buf->data, cpu)->capacity;
}
} else {
ret = ring_buffer_resize(trace_buf->buffer,
per_cpu_ptr(size_buf->data, cpu_id)->entries, cpu_id);
per_cpu_ptr(size_buf->data, cpu_id)->capacity, cpu_id);
if (ret == 0)
per_cpu_ptr(trace_buf->data, cpu_id)->entries =
per_cpu_ptr(size_buf->data, cpu_id)->entries;
per_cpu_ptr(trace_buf->data, cpu_id)->capacity =
per_cpu_ptr(size_buf->data, cpu_id)->capacity;
}
return ret;
@ -193,7 +193,7 @@ void free_snapshot(struct trace_array *tr)
*/
ring_buffer_subbuf_order_set(tr->snapshot_buffer.buffer, 0);
ring_buffer_resize(tr->snapshot_buffer.buffer, 1, RING_BUFFER_ALL_CPUS);
trace_set_buffer_entries(&tr->snapshot_buffer, 1);
trace_set_buffer_capacity(&tr->snapshot_buffer, 1);
tracing_reset_online_cpus(&tr->snapshot_buffer);
tr->allocated_snapshot = false;
}