tjh.dev / kernel
Linux kernel mirror (for testing) git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel os linux
1
fork

Configure Feed

Select the types of activity you want to include in your feed.

tracing: Rename trace_array field max_buffer to snapshot_buffer

When tracing was first added, there were latency tracers that would take a
snapshot of the current trace when a new max latency was hit. This
snapshot buffer was called "max_buffer". Since then, a snapshot feature
was added that allowed user space or event triggers to trigger a snapshot
of the current buffer using the same max_buffer of the trace_array.

As this snapshot buffer now has a more generic use case, calling it
"max_buffer" is confusing. Rename it to snapshot_buffer.

Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Mark Rutland <mark.rutland@arm.com>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: Andrew Morton <akpm@linux-foundation.org>
Link: https://patch.msgid.link/20260208183856.428446729@kernel.org
Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>

Steven Rostedt 694b3f6f 98021e37

+48 -47
+36 -36
kernel/trace/trace.c
··· 934 934 935 935 /* Make the snapshot buffer have the same order as main buffer */ 936 936 order = ring_buffer_subbuf_order_get(tr->array_buffer.buffer); 937 - ret = ring_buffer_subbuf_order_set(tr->max_buffer.buffer, order); 937 + ret = ring_buffer_subbuf_order_set(tr->snapshot_buffer.buffer, order); 938 938 if (ret < 0) 939 939 return ret; 940 940 941 941 /* allocate spare buffer */ 942 - ret = resize_buffer_duplicate_size(&tr->max_buffer, 942 + ret = resize_buffer_duplicate_size(&tr->snapshot_buffer, 943 943 &tr->array_buffer, RING_BUFFER_ALL_CPUS); 944 944 if (ret < 0) 945 945 return ret; ··· 957 957 * The max_tr ring buffer has some state (e.g. ring->clock) and 958 958 * we want preserve it. 959 959 */ 960 - ring_buffer_subbuf_order_set(tr->max_buffer.buffer, 0); 961 - ring_buffer_resize(tr->max_buffer.buffer, 1, RING_BUFFER_ALL_CPUS); 962 - set_buffer_entries(&tr->max_buffer, 1); 963 - tracing_reset_online_cpus(&tr->max_buffer); 960 + ring_buffer_subbuf_order_set(tr->snapshot_buffer.buffer, 0); 961 + ring_buffer_resize(tr->snapshot_buffer.buffer, 1, RING_BUFFER_ALL_CPUS); 962 + set_buffer_entries(&tr->snapshot_buffer, 1); 963 + tracing_reset_online_cpus(&tr->snapshot_buffer); 964 964 tr->allocated_snapshot = false; 965 965 } 966 966 ··· 1556 1556 __update_max_tr(struct trace_array *tr, struct task_struct *tsk, int cpu) 1557 1557 { 1558 1558 struct array_buffer *trace_buf = &tr->array_buffer; 1559 - struct array_buffer *max_buf = &tr->max_buffer; 1559 + struct array_buffer *max_buf = &tr->snapshot_buffer; 1560 1560 struct trace_array_cpu *data = per_cpu_ptr(trace_buf->data, cpu); 1561 1561 struct trace_array_cpu *max_data = per_cpu_ptr(max_buf->data, cpu); 1562 1562 ··· 1616 1616 1617 1617 /* Inherit the recordable setting from array_buffer */ 1618 1618 if (ring_buffer_record_is_set_on(tr->array_buffer.buffer)) 1619 - ring_buffer_record_on(tr->max_buffer.buffer); 1619 + ring_buffer_record_on(tr->snapshot_buffer.buffer); 1620 1620 else 1621 - ring_buffer_record_off(tr->max_buffer.buffer); 1621 + ring_buffer_record_off(tr->snapshot_buffer.buffer); 1622 1622 1623 1623 #ifdef CONFIG_TRACER_SNAPSHOT 1624 1624 if (tr->cond_snapshot && !tr->cond_snapshot->update(tr, cond_data)) { ··· 1626 1626 return; 1627 1627 } 1628 1628 #endif 1629 - swap(tr->array_buffer.buffer, tr->max_buffer.buffer); 1629 + swap(tr->array_buffer.buffer, tr->snapshot_buffer.buffer); 1630 1630 1631 1631 __update_max_tr(tr, tsk, cpu); 1632 1632 ··· 1661 1661 1662 1662 arch_spin_lock(&tr->max_lock); 1663 1663 1664 - ret = ring_buffer_swap_cpu(tr->max_buffer.buffer, tr->array_buffer.buffer, cpu); 1664 + ret = ring_buffer_swap_cpu(tr->snapshot_buffer.buffer, tr->array_buffer.buffer, cpu); 1665 1665 1666 1666 if (ret == -EBUSY) { 1667 1667 /* ··· 1671 1671 * and flag that it failed. 1672 1672 * Another reason is resize is in progress. 1673 1673 */ 1674 - trace_array_printk_buf(tr->max_buffer.buffer, _THIS_IP_, 1674 + trace_array_printk_buf(tr->snapshot_buffer.buffer, _THIS_IP_, 1675 1675 "Failed to swap buffers due to commit or resize in progress\n"); 1676 1676 } 1677 1677 ··· 1722 1722 * to happen, this would now be the main buffer. 1723 1723 */ 1724 1724 if (iter->snapshot) 1725 - iter->array_buffer = &iter->tr->max_buffer; 1725 + iter->array_buffer = &iter->tr->snapshot_buffer; 1726 1726 #endif 1727 1727 return ret; 1728 1728 } ··· 1790 1790 if (type->use_max_tr) { 1791 1791 /* If we expanded the buffers, make sure the max is expanded too */ 1792 1792 if (tr->ring_buffer_expanded) 1793 - ring_buffer_resize(tr->max_buffer.buffer, trace_buf_size, 1793 + ring_buffer_resize(tr->snapshot_buffer.buffer, trace_buf_size, 1794 1794 RING_BUFFER_ALL_CPUS); 1795 1795 tr->allocated_snapshot = true; 1796 1796 } ··· 1817 1817 1818 1818 /* Shrink the max buffer again */ 1819 1819 if (tr->ring_buffer_expanded) 1820 - ring_buffer_resize(tr->max_buffer.buffer, 1, 1820 + ring_buffer_resize(tr->snapshot_buffer.buffer, 1, 1821 1821 RING_BUFFER_ALL_CPUS); 1822 1822 } 1823 1823 #endif ··· 2060 2060 tr->clear_trace = false; 2061 2061 tracing_reset_online_cpus(&tr->array_buffer); 2062 2062 #ifdef CONFIG_TRACER_MAX_TRACE 2063 - tracing_reset_online_cpus(&tr->max_buffer); 2063 + tracing_reset_online_cpus(&tr->snapshot_buffer); 2064 2064 #endif 2065 2065 } 2066 2066 } ··· 2100 2100 ring_buffer_record_enable(buffer); 2101 2101 2102 2102 #ifdef CONFIG_TRACER_MAX_TRACE 2103 - buffer = tr->max_buffer.buffer; 2103 + buffer = tr->snapshot_buffer.buffer; 2104 2104 if (buffer) 2105 2105 ring_buffer_record_enable(buffer); 2106 2106 #endif ··· 2136 2136 ring_buffer_record_disable(buffer); 2137 2137 2138 2138 #ifdef CONFIG_TRACER_MAX_TRACE 2139 - buffer = tr->max_buffer.buffer; 2139 + buffer = tr->snapshot_buffer.buffer; 2140 2140 if (buffer) 2141 2141 ring_buffer_record_disable(buffer); 2142 2142 #endif ··· 3943 3943 #ifdef CONFIG_TRACER_MAX_TRACE 3944 3944 /* Currently only the top directory has a snapshot */ 3945 3945 if (tr->current_trace->print_max || snapshot) 3946 - iter->array_buffer = &tr->max_buffer; 3946 + iter->array_buffer = &tr->snapshot_buffer; 3947 3947 else 3948 3948 #endif 3949 3949 iter->array_buffer = &tr->array_buffer; ··· 4146 4146 4147 4147 #ifdef CONFIG_TRACER_MAX_TRACE 4148 4148 if (tr->current_trace->print_max) 4149 - trace_buf = &tr->max_buffer; 4149 + trace_buf = &tr->snapshot_buffer; 4150 4150 #endif 4151 4151 4152 4152 if (cpu == RING_BUFFER_ALL_CPUS) ··· 4359 4359 !cpumask_test_cpu(cpu, tracing_cpumask_new)) { 4360 4360 ring_buffer_record_disable_cpu(tr->array_buffer.buffer, cpu); 4361 4361 #ifdef CONFIG_TRACER_MAX_TRACE 4362 - ring_buffer_record_disable_cpu(tr->max_buffer.buffer, cpu); 4362 + ring_buffer_record_disable_cpu(tr->snapshot_buffer.buffer, cpu); 4363 4363 #endif 4364 4364 } 4365 4365 if (!cpumask_test_cpu(cpu, tr->tracing_cpumask) && 4366 4366 cpumask_test_cpu(cpu, tracing_cpumask_new)) { 4367 4367 ring_buffer_record_enable_cpu(tr->array_buffer.buffer, cpu); 4368 4368 #ifdef CONFIG_TRACER_MAX_TRACE 4369 - ring_buffer_record_enable_cpu(tr->max_buffer.buffer, cpu); 4369 + ring_buffer_record_enable_cpu(tr->snapshot_buffer.buffer, cpu); 4370 4370 #endif 4371 4371 } 4372 4372 } ··· 4576 4576 case TRACE_ITER(OVERWRITE): 4577 4577 ring_buffer_change_overwrite(tr->array_buffer.buffer, enabled); 4578 4578 #ifdef CONFIG_TRACER_MAX_TRACE 4579 - ring_buffer_change_overwrite(tr->max_buffer.buffer, enabled); 4579 + ring_buffer_change_overwrite(tr->snapshot_buffer.buffer, enabled); 4580 4580 #endif 4581 4581 break; 4582 4582 ··· 5294 5294 if (!tr->allocated_snapshot) 5295 5295 goto out; 5296 5296 5297 - ret = ring_buffer_resize(tr->max_buffer.buffer, size, cpu); 5297 + ret = ring_buffer_resize(tr->snapshot_buffer.buffer, size, cpu); 5298 5298 if (ret < 0) { 5299 5299 int r = resize_buffer_duplicate_size(&tr->array_buffer, 5300 5300 &tr->array_buffer, cpu); ··· 5319 5319 goto out_start; 5320 5320 } 5321 5321 5322 - update_buffer_entries(&tr->max_buffer, cpu); 5322 + update_buffer_entries(&tr->snapshot_buffer, cpu); 5323 5323 5324 5324 out: 5325 5325 #endif /* CONFIG_TRACER_MAX_TRACE */ ··· 7036 7036 tracing_reset_online_cpus(&tr->array_buffer); 7037 7037 7038 7038 #ifdef CONFIG_TRACER_MAX_TRACE 7039 - if (tr->max_buffer.buffer) 7040 - ring_buffer_set_clock(tr->max_buffer.buffer, trace_clocks[i].func); 7041 - tracing_reset_online_cpus(&tr->max_buffer); 7039 + if (tr->snapshot_buffer.buffer) 7040 + ring_buffer_set_clock(tr->snapshot_buffer.buffer, trace_clocks[i].func); 7041 + tracing_reset_online_cpus(&tr->snapshot_buffer); 7042 7042 #endif 7043 7043 7044 7044 if (tr->scratch && !(tr->flags & TRACE_ARRAY_FL_LAST_BOOT)) { ··· 7170 7170 ret = 0; 7171 7171 7172 7172 iter->tr = tr; 7173 - iter->array_buffer = &tr->max_buffer; 7173 + iter->array_buffer = &tr->snapshot_buffer; 7174 7174 iter->cpu_file = tracing_get_cpu(inode); 7175 7175 m->private = iter; 7176 7176 file->private_data = m; ··· 7233 7233 return -EINVAL; 7234 7234 #endif 7235 7235 if (tr->allocated_snapshot) 7236 - ret = resize_buffer_duplicate_size(&tr->max_buffer, 7236 + ret = resize_buffer_duplicate_size(&tr->snapshot_buffer, 7237 7237 &tr->array_buffer, iter->cpu_file); 7238 7238 7239 7239 ret = tracing_arm_snapshot_locked(tr); ··· 7254 7254 default: 7255 7255 if (tr->allocated_snapshot) { 7256 7256 if (iter->cpu_file == RING_BUFFER_ALL_CPUS) 7257 - tracing_reset_online_cpus(&tr->max_buffer); 7257 + tracing_reset_online_cpus(&tr->snapshot_buffer); 7258 7258 else 7259 - tracing_reset_cpu(&tr->max_buffer, iter->cpu_file); 7259 + tracing_reset_cpu(&tr->snapshot_buffer, iter->cpu_file); 7260 7260 } 7261 7261 break; 7262 7262 } ··· 7312 7312 } 7313 7313 7314 7314 info->iter.snapshot = true; 7315 - info->iter.array_buffer = &info->iter.tr->max_buffer; 7315 + info->iter.array_buffer = &info->iter.tr->snapshot_buffer; 7316 7316 7317 7317 return ret; 7318 7318 } ··· 9195 9195 if (!tr->allocated_snapshot) 9196 9196 goto out_max; 9197 9197 9198 - ret = ring_buffer_subbuf_order_set(tr->max_buffer.buffer, order); 9198 + ret = ring_buffer_subbuf_order_set(tr->snapshot_buffer.buffer, order); 9199 9199 if (ret) { 9200 9200 /* Put back the old order */ 9201 9201 cnt = ring_buffer_subbuf_order_set(tr->array_buffer.buffer, old_order); ··· 9416 9416 if (tr->range_addr_start) 9417 9417 return 0; 9418 9418 9419 - ret = allocate_trace_buffer(tr, &tr->max_buffer, 9419 + ret = allocate_trace_buffer(tr, &tr->snapshot_buffer, 9420 9420 allocate_snapshot ? size : 1); 9421 9421 if (MEM_FAIL(ret, "Failed to allocate trace buffer\n")) { 9422 9422 free_trace_buffer(&tr->array_buffer); ··· 9439 9439 kfree(tr->module_delta); 9440 9440 9441 9441 #ifdef CONFIG_TRACER_MAX_TRACE 9442 - free_trace_buffer(&tr->max_buffer); 9442 + free_trace_buffer(&tr->snapshot_buffer); 9443 9443 #endif 9444 9444 } 9445 9445
+7 -6
kernel/trace/trace.h
··· 331 331 struct array_buffer array_buffer; 332 332 #ifdef CONFIG_TRACER_MAX_TRACE 333 333 /* 334 - * The max_buffer is used to snapshot the trace when a maximum 334 + * The snapshot_buffer is used to snapshot the trace when a maximum 335 335 * latency is reached, or when the user initiates a snapshot. 336 336 * Some tracers will use this to store a maximum trace while 337 337 * it continues examining live traces. 338 338 * 339 - * The buffers for the max_buffer are set up the same as the array_buffer 340 - * When a snapshot is taken, the buffer of the max_buffer is swapped 341 - * with the buffer of the array_buffer and the buffers are reset for 342 - * the array_buffer so the tracing can continue. 339 + * The buffers for the snapshot_buffer are set up the same as the 340 + * array_buffer. When a snapshot is taken, the buffer of the 341 + * snapshot_buffer is swapped with the buffer of the array_buffer 342 + * and the buffers are reset for the array_buffer so the tracing can 343 + * continue. 343 344 */ 344 - struct array_buffer max_buffer; 345 + struct array_buffer snapshot_buffer; 345 346 bool allocated_snapshot; 346 347 spinlock_t snapshot_trigger_lock; 347 348 unsigned int snapshot;
+5 -5
kernel/trace/trace_selftest.c
··· 1225 1225 /* check both trace buffers */ 1226 1226 ret = trace_test_buffer(&tr->array_buffer, NULL); 1227 1227 if (!ret) 1228 - ret = trace_test_buffer(&tr->max_buffer, &count); 1228 + ret = trace_test_buffer(&tr->snapshot_buffer, &count); 1229 1229 trace->reset(tr); 1230 1230 tracing_start(); 1231 1231 ··· 1287 1287 /* check both trace buffers */ 1288 1288 ret = trace_test_buffer(&tr->array_buffer, NULL); 1289 1289 if (!ret) 1290 - ret = trace_test_buffer(&tr->max_buffer, &count); 1290 + ret = trace_test_buffer(&tr->snapshot_buffer, &count); 1291 1291 trace->reset(tr); 1292 1292 tracing_start(); 1293 1293 ··· 1355 1355 if (ret) 1356 1356 goto out; 1357 1357 1358 - ret = trace_test_buffer(&tr->max_buffer, &count); 1358 + ret = trace_test_buffer(&tr->snapshot_buffer, &count); 1359 1359 if (ret) 1360 1360 goto out; 1361 1361 ··· 1385 1385 if (ret) 1386 1386 goto out; 1387 1387 1388 - ret = trace_test_buffer(&tr->max_buffer, &count); 1388 + ret = trace_test_buffer(&tr->snapshot_buffer, &count); 1389 1389 1390 1390 if (!ret && !count) { 1391 1391 printk(KERN_CONT ".. no entries found .."); ··· 1513 1513 /* check both trace buffers */ 1514 1514 ret = trace_test_buffer(&tr->array_buffer, NULL); 1515 1515 if (!ret) 1516 - ret = trace_test_buffer(&tr->max_buffer, &count); 1516 + ret = trace_test_buffer(&tr->snapshot_buffer, &count); 1517 1517 1518 1518 1519 1519 trace->reset(tr);