tracing/synthetic: Use union instead of casts
Subsystems (5)
A message that is not in the archive (sent off-list or not yet received): [email protected]
Steven Rostedt
maintainerPATCH 1/8 tracing: Fix cpu buffers unavailable due to record_disabled missed
From: Zheng Yejian <[email protected]>
Trace ring buffer can no longer record anything after executing following commands at the shell prompt:
# cd /sys/kernel/tracing # cat tracing_cpumask fff # echo 0 > tracing_cpumask # echo 1 > snapshot # echo fff > tracing_cpumask # echo 1 > tracing_on # echo "hello world" > trace_marker -bash: echo: write error: Bad file descriptor
The root cause is that:
1. After echo 0 > tracing_cpumask, 'record_disabled' of cpu buffers
in 'tr->array_buffer.buffer' became 1 (see tracing_set_cpumask());
2. After `echo 1 > snapshot`, 'tr->array_buffer.buffer' is swapped
with 'tr->max_buffer.buffer', then the 'record_disabled' became 0
(see update_max_tr()); 3. After echo fff > tracing_cpumask, the 'record_disabled' become -1;
Then array_buffer and max_buffer are both unavailable due to value of 'record_disabled' is not 0.
To fix it, enable or disable both array_buffer and max_buffer at the same time in tracing_set_cpumask().
--- kernel/trace/trace.c | 6 ++++++ 1 file changed, 6 insertions(+)
kernel/trace/trace.c +6 -0
@@ -5277,11 +5277,17 @@ int tracing_set_cpumask(struct trace_array *tr, !cpumask_test_cpu(cpu, tracing_cpumask_new)) {atomic_inc (&per_cpu_ptr (tr->array_buffer.data, cpu)->disabled);ring_buffer_record_disable_cpu (tr->array_buffer.buffer, cpu); +#ifdef CONFIG_TRACER_MAX_TRACE +ring_buffer_record_disable_cpu (tr->max_buffer.buffer, cpu); +#endif }if (!cpumask_test_cpu (cpu, tr->tracing_cpumask) &&cpumask_test_cpu (cpu, tracing_cpumask_new)) {atomic_dec (&per_cpu_ptr (tr->array_buffer.data, cpu)->disabled);ring_buffer_record_enable_cpu (tr->array_buffer.buffer, cpu); +#ifdef CONFIG_TRACER_MAX_TRACE +ring_buffer_record_enable_cpu (tr->max_buffer.buffer, cpu); +#endif } }arch_spin_unlock (&tr->max_lock);
Signature · 1 line
2.40.1
Steven Rostedt
maintainerPATCH 2/8 selftests/ftrace: Add a basic testcase for snapshot
In reply to a message not in the archiveFrom: Zheng Yejian <[email protected]>
This testcase is constrived to reproduce a problem that the cpu buffers become unavailable which is due to 'record_disabled' of array_buffer and max_buffer being messed up.
Local test result after bugfix:
# ./ftracetest test.d/00basic/snapshot1.tc === Ftrace unit tests === [1] Snapshot and tracing_cpumask [PASS] [2] (instance) Snapshot and tracing_cpumask [PASS]
# of passed: 2 # of failed: 0 # of unresolved: 0 # of untested: 0 # of unsupported: 0 # of xfailed: 0 # of undefined(test bug): 0
--- .../ftrace/test.d/00basic/snapshot1.tc | 31 +++++++++++++++++++ 1 file changed, 31 insertions(+) create mode 100644 tools/testing/selftests/ftrace/test.d/00basic/snapshot1.tc
tools/testing/selftests/ftrace/test.d/00basic/snapshot1.tc new file +31 -0
@@ -0,0 +1,31 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0 +# description: Snapshot and tracing_cpumask +# requires: trace_marker tracing_cpumask snapshot +# flags: instance + +# This testcase is constrived to reproduce a problem that the cpu buffers +# become unavailable which is due to 'record_disabled' of array_buffer and +# max_buffer being messed up. + +# Store origin cpumask +ORIG_CPUMASK=`cat tracing_cpumask` + +# Stop tracing all cpu +echo 0 > tracing_cpumask + +# Take a snapshot of the main buffer +echo 1 > snapshot + +# Restore origin cpumask, note that there should be some cpus being traced +echo ${ORIG_CPUMASK} > tracing_cpumask + +# Set tracing on +echo 1 > tracing_on + +# Write a log into buffer +echo "test input 1" > trace_marker + +# Ensure the log writed so that cpu buffers are still available +grep -q "test input 1" trace +exit 0
Signature · 1 line
2.40.1
Steven Rostedt
maintainerPATCH 3/8 tracing/synthetic: Use union instead of casts
In reply to a message not in the archiveFrom: Sven Schnelle <[email protected]>
The current code uses a lot of casts to access the fields member in struct synth_trace_events with different sizes. This makes the code hard to read, and had already introduced an endianness bug. Use a union and struct instead.
--- include/linux/trace_events.h | 11 ++++ kernel/trace/trace.h | 8 +++ kernel/trace/trace_events_synth.c | 87 +++++++++++++------------------ 3 files changed, 56 insertions(+), 50 deletions(-)
include/linux/trace_events.h +11 -0
@@ -59,6 +59,17 @@ int trace_raw_output_prep(struct trace_iterator *iter, extern __printf(2, 3) void trace_event_printf(struct trace_iterator *iter, const char *fmt, ...); +/* Used to find the offset and length of dynamic fields in trace events */ +struct trace_dynamic_info { +#ifdef CONFIG_CPU_BIG_ENDIAN + u16 offset; + u16 len; +#else + u16 len; + u16 offset; +#endif +}; + /* * The trace entry - the most basic unit of tracing. This is what * is printed in the end as a single line in the trace output, such as:
kernel/trace/trace.h +8 -0
@@ -1295,6 +1295,14 @@ static inline void trace_branch_disable(void)/* set ring buffers to default size if not already done so */ int tracing_update_buffers (void ); +union trace_synth_field { +u8 as_u8; +u16 as_u16; +u32 as_u32; +u64 as_u64; +struct trace_dynamic_info as_dynamic; +}; +struct ftrace_event_field {struct list_head link;const char *name;
kernel/trace/trace_events_synth.c +37 -50
223 lines not on this page · raw message
Signature · 1 line
2.40.1
Steven Rostedt
maintainerPATCH 4/8 tracing/synthetic: Skip first entry for stack traces
In reply to a message not in the archiveFrom: Sven Schnelle <[email protected]>
While debugging another issue I noticed that the stack trace output contains the number of entries on top:
<idle>-0 [000] d..4. 203.322502: wake_lat: pid=0 delta=2268270616 stack=STACK:
=> 0x10
=> __schedule+0xac6/0x1a98
=> schedule+0x126/0x2c0
=> schedule_timeout+0x242/0x2c0
=> __wait_for_common+0x434/0x680
=> __wait_rcu_gp+0x198/0x3e0
=> synchronize_rcu+0x112/0x138
=> ring_buffer_reset_online_cpus+0x140/0x2e0
=> tracing_reset_online_cpus+0x15c/0x1d0
=> tracing_set_clock+0x180/0x1d8
=> hist_register_trigger+0x486/0x670
=> event_hist_trigger_parse+0x494/0x1318
=> trigger_process_regex+0x1d4/0x258
=> event_trigger_write+0xb4/0x170
=> vfs_write+0x210/0xad0
=> ksys_write+0x122/0x208
Fix this by skipping the first element. Also replace the pointer logic with an index variable which is easier to read.
--- kernel/trace/trace_events_synth.c | 17 ++++------------- 1 file changed, 4 insertions(+), 13 deletions(-)
kernel/trace/trace_events_synth.c +4 -13
@@ -350,7 +350,7 @@ static enum print_line_t print_synth_event(struct trace_iterator *iter,struct trace_seq *s = &iter->seq;struct synth_trace_event *entry;struct synth_event *se; -unsigned int i, n_u64; +unsigned int i, j, n_u64;char print_fmt[32 ];const char *fmt;
@@ -389,18 +389,13 @@ static enum print_line_t print_synth_event(struct trace_iterator *iter, n_u64 +=STR_VAR_LEN_MAX /sizeof (u64); } }else if (se->fields[i]->is_stack) { -unsigned long *p, *end;union trace_synth_field *data = &entry->fields[n_u64]; - - p = (void *)entry + data->as_dynamic.offset; - end = (void *)p + data->as_dynamic.len - (sizeof (long ) -1 ); +unsigned long *p = (void *)entry + data->as_dynamic.offset;trace_seq_printf (s,"%s=STACK:\n" , se->fields[i]->name); - -for (; *p && p < end; p++) -trace_seq_printf (s,"=> %pS\n" , (void *)*p); +for (j =1 ; j < data->as_dynamic.len /sizeof (long ); j++) +trace_seq_printf (s,"=> %pS\n" , (void *)p[j]); n_u64++; - }else {struct trace_print_flags __flags[] = { __def_gfpflag_names, {-1 ,NULL } };
@@ -490,10 +485,6 @@ static unsigned int trace_stack(struct synth_trace_event *entry,break ; } -/* Include the zero'd element if it fits */ -if (len <HIST_STACKTRACE_DEPTH ) - len++; - len *=sizeof (long );/* Find the dynamic section to copy the stack into. */
Signature · 1 line
2.40.1
Steven Rostedt
maintainerPATCH 5/8 tracing/synthetic: Allocate one additional element for size
In reply to a message not in the archiveFrom: Sven Schnelle <[email protected]>
While debugging another issue I noticed that the stack trace contains one invalid entry at the end:
<idle>-0 [008] d..4. 26.484201: wake_lat: pid=0 delta=2629976084 000000009cc24024 stack=STACK:
=> __schedule+0xac6/0x1a98
=> schedule+0x126/0x2c0
=> schedule_timeout+0x150/0x2c0
=> kcompactd+0x9ca/0xc20
=> kthread+0x2f6/0x3d8
=> __ret_from_fork+0x8a/0xe8
=> 0x6b6b6b6b6b6b6b6b
This is because the code failed to add the one element containing the number of entries to field_size.
--- kernel/trace/trace_events_synth.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
kernel/trace/trace_events_synth.c +2 -1
@@ -528,7 +528,8 @@ static notrace void trace_event_raw_event_synth(void *__data, str_val = (char *)(long )var_ref_vals[val_idx];if (event->dynamic_fields[i]->is_stack) { - len = *((unsigned long *)str_val); +/* reserve one extra element for size */ + len = *((unsigned long *)str_val) +1 ; len *=sizeof (unsigned long ); }else { len =fetch_store_strlen ((unsigned long )str_val);
Signature · 1 line
2.40.1
Steven Rostedt
maintainerPATCH 6/8 tracing: Fix memleak due to race between current_tracer and trace
In reply to a message not in the archiveFrom: Zheng Yejian <[email protected]>
Kmemleak report a leak in graph_trace_open():
unreferenced object 0xffff0040b95f4a00 (size 128):
comm "cat", pid 204981, jiffies 4301155872 (age 99771.964s)
hex dump (first 32 bytes):
e0 05 e7 b4 ab 7d 00 00 0b 00 01 00 00 00 00 00 .....}..........
f4 00 01 10 00 a0 ff ff 00 00 00 00 65 00 10 00 ............e...
backtrace:
[<000000005db27c8b>] kmem_cache_alloc_trace+0x348/0x5f0
[<000000007df90faa>] graph_trace_open+0xb0/0x344
[<00000000737524cd>] __tracing_open+0x450/0xb10
[<0000000098043327>] tracing_open+0x1a0/0x2a0
[<00000000291c3876>] do_dentry_open+0x3c0/0xdc0
[<000000004015bcd6>] vfs_open+0x98/0xd0
[<000000002b5f60c9>] do_open+0x520/0x8d0
[<00000000376c7820>] path_openat+0x1c0/0x3e0
[<00000000336a54b5>] do_filp_open+0x14c/0x324
[<000000002802df13>] do_sys_openat2+0x2c4/0x530
[<0000000094eea458>] __arm64_sys_openat+0x130/0x1c4
[<00000000a71d7881>] el0_svc_common.constprop.0+0xfc/0x394
[<00000000313647bf>] do_el0_svc+0xac/0xec
[<000000002ef1c651>] el0_svc+0x20/0x30
[<000000002fd4692a>] el0_sync_handler+0xb0/0xb4
[<000000000c309c35>] el0_sync+0x160/0x180The root cause is descripted as follows:
__tracing_open() { // 1. File 'trace' is being opened;
...
*iter->trace = *tr->current_trace; // 2. Tracer 'function_graph' is
// currently set;
...
iter->trace->open(iter); // 3. Call graph_trace_open() here,
// and memory are allocated in it;
...}
s_start() { // 4. The opened file is being read;
...
*iter->trace = *tr->current_trace; // 5. If tracer is switched to
// 'nop' or others, then memory
// in step 3 are leaked!!!
...}
To fix it, in s_start(), close tracer before switching then reopen the new tracer after switching. And some tracers like 'wakeup' may not update 'iter->private' in some cases when reopen, then it should be cleared to avoid being mistakenly closed again.
--- kernel/trace/trace.c | 9 ++++++++- kernel/trace/trace_irqsoff.c | 3 ++- kernel/trace/trace_sched_wakeup.c | 2 ++ 3 files changed, 12 insertions(+), 2 deletions(-)
kernel/trace/trace.c +8 -1
@@ -4213,8 +4213,15 @@ static void *s_start(struct seq_file *m, loff_t *pos)* will point to the same string as current_trace->name. */ mutex_lock (&trace_types_lock); -if (unlikely (tr->current_trace && iter->trace->name != tr->current_trace->name)) +if (unlikely (tr->current_trace && iter->trace->name != tr->current_trace->name)) { +/* Close iter->trace before switching to the new current tracer */ +if (iter->trace->close) + iter->trace->close (iter); *iter->trace = *tr->current_trace; +/* Reopen the new current tracer */ +if (iter->trace->open) + iter->trace->open (iter); + }mutex_unlock (&trace_types_lock);#ifdef CONFIG_TRACER_MAX_TRACE
kernel/trace/trace_irqsoff.c +2 -1
@@ -231,7 +231,8 @@ static void irqsoff_trace_open(struct trace_iterator *iter) {if (is_graph (iter->tr))graph_trace_open (iter); - +else + iter->private =NULL ; }static void irqsoff_trace_close (struct trace_iterator *iter)
kernel/trace/trace_sched_wakeup.c +2 -0
@@ -168,6 +168,8 @@ static void wakeup_trace_open(struct trace_iterator *iter) {if (is_graph (iter->tr))graph_trace_open (iter); +else + iter->private =NULL ; }static void wakeup_trace_close (struct trace_iterator *iter)
Signature · 1 line
2.40.1
Steven Rostedt
maintainerPATCH 7/8 tracing: Introduce pipe_cpumask to avoid race on trace_pipes
In reply to a message not in the archiveFrom: Zheng Yejian <[email protected]>
There is race issue when concurrently splice_read main trace_pipe and per_cpu trace_pipes which will result in data read out being different from what actually writen.
As suggested by Steven:
Quoted 11 lines
I believe we should add a ref count to
trace_pipeand theper_cputrace_pipes, where if they are opened, nothing else can read it.Opening
trace_pipelocks allper_cpuref counts, if any of them are open, then thetrace_pipeopen will fail (and releases any ref counts it had taken).Opening a
per_cputrace_pipewill up the ref count for just that CPU buffer. This will allow multiple tasks to read differentper_cputrace_pipefiles, but will prevent the maintrace_pipefile from being opened.
But because we only need to know whether per_cpu trace_pipe is open or not, using a cpumask instead of using ref count may be easier.
After this patch, users will find that:
- Main trace_pipe can be opened by only one user, and if it is opened, all per_cpu trace_pipes cannot be opened;
- Per_cpu trace_pipes can be opened by multiple users, but each per_cpu trace_pipe can only be opened by one user. And if one of them is opened, main trace_pipe cannot be opened.
--- kernel/trace/trace.c | 55 ++++++++++++++++++++++++++++++++++++++------ kernel/trace/trace.h | 2 ++ 2 files changed, 50 insertions(+), 7 deletions(-)
kernel/trace/trace.c +48 -7
@@ -6718,10 +6718,36 @@ tracing_max_lat_write(struct file *filp, const char __user *ubuf,#endif +static int open_pipe_on_cpu (struct trace_array *tr,int cpu) +{ +if (cpu ==RING_BUFFER_ALL_CPUS ) { +if (cpumask_empty (tr->pipe_cpumask)) { +cpumask_setall (tr->pipe_cpumask); +return 0 ; + } + }else if (!cpumask_test_cpu (cpu, tr->pipe_cpumask)) { +cpumask_set_cpu (cpu, tr->pipe_cpumask); +return 0 ; + } +return -EBUSY ; +} + +static void close_pipe_on_cpu (struct trace_array *tr,int cpu) +{ +if (cpu ==RING_BUFFER_ALL_CPUS ) { +WARN_ON (!cpumask_full (tr->pipe_cpumask)); +cpumask_clear (tr->pipe_cpumask); + }else { +WARN_ON (!cpumask_test_cpu (cpu, tr->pipe_cpumask)); +cpumask_clear_cpu (cpu, tr->pipe_cpumask); + } +} +static int tracing_open_pipe (struct inode *inode,struct file *filp) {struct trace_array *tr = inode->i_private;struct trace_iterator *iter; +int cpu;int ret; ret =tracing_check_open_get_tr (tr);
@@ -6729,13 +6755,16 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)return ret;mutex_lock (&trace_types_lock); + cpu =tracing_get_cpu (inode); + ret =open_pipe_on_cpu (tr, cpu); +if (ret) + goto fail_pipe_on_cpu;/* create a buffer to store the information to pass to userspace */ iter =kzalloc (sizeof (*iter),GFP_KERNEL );if (!iter) { ret = -ENOMEM ; -__trace_array_put (tr); - goto out; + goto fail_alloc_iter; }trace_seq_init (&iter->seq);
@@ -6758,7 +6787,7 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp) iter->tr = tr; iter->array_buffer = &tr->array_buffer; - iter->cpu_file =tracing_get_cpu (inode); + iter->cpu_file = cpu;mutex_init (&iter->mutex); filp->private_data = iter;
@@ -6768,12 +6797,15 @@ static int tracing_open_pipe(struct inode *inode, struct file *filp)nonseekable_open (inode, filp); tr->trace_ref++; -out: +mutex_unlock (&trace_types_lock);return ret; fail:kfree (iter); +fail_alloc_iter: +close_pipe_on_cpu (tr, cpu); +fail_pipe_on_cpu:__trace_array_put (tr);mutex_unlock (&trace_types_lock);return ret;
@@ -6790,7 +6822,7 @@ static int tracing_release_pipe(struct inode *inode, struct file *file)if (iter->trace->pipe_close) iter->trace->pipe_close (iter); - +close_pipe_on_cpu (tr, iter->cpu_file);mutex_unlock (&trace_types_lock);free_cpumask_var (iter->started);
@@ -9454,6 +9486,9 @@ static struct trace_array *trace_array_create(const char *name)if (!alloc_cpumask_var (&tr->tracing_cpumask,GFP_KERNEL )) goto out_free_tr; +if (!alloc_cpumask_var (&tr->pipe_cpumask,GFP_KERNEL )) + goto out_free_tr; + tr->trace_flags = global_trace.trace_flags & ~ZEROED_TRACE_FLAGS ;cpumask_copy (tr->tracing_cpumask, cpu_all_mask);
@@ -9495,6 +9530,7 @@ static struct trace_array *trace_array_create(const char *name) out_free_tr:ftrace_free_ftrace_ops (tr);free_trace_buffers (tr); +free_cpumask_var (tr->pipe_cpumask);free_cpumask_var (tr->tracing_cpumask);kfree (tr->name);kfree (tr);
@@ -9597,6 +9633,7 @@ static int __remove_instance(struct trace_array *tr) }kfree (tr->topts); +free_cpumask_var (tr->pipe_cpumask);free_cpumask_var (tr->tracing_cpumask);kfree (tr->name);kfree (tr);
@@ -10394,12 +10431,14 @@ __init static int tracer_alloc_buffers(void)if (trace_create_savedcmd () <0 ) goto out_free_temp_buffer; +if (!alloc_cpumask_var (&global_trace.pipe_cpumask,GFP_KERNEL )) + goto out_free_savedcmd; +/* TODO: make the number of buffers hot pluggable with CPUS */ if (allocate_trace_buffers (&global_trace, ring_buf_size) <0 ) {MEM_FAIL (1 ,"tracer: failed to allocate ring buffer!\n" ); - goto out_free_savedcmd; + goto out_free_pipe_cpumask; } -if (global_trace.buffer_disabled)tracing_off ();
@@ -10452,6 +10491,8 @@ __init static int tracer_alloc_buffers(void)return 0 ; +out_free_pipe_cpumask: +free_cpumask_var (global_trace.pipe_cpumask); out_free_savedcmd:free_saved_cmdlines_buffer (savedcmd); out_free_temp_buffer:
kernel/trace/trace.h +2 -0
@@ -377,6 +377,8 @@ struct trace_array {struct list_head events;struct trace_event_file *trace_marker_file;cpumask_var_t tracing_cpumask;/* only trace on set CPUs */ +/* one per_cpu trace_pipe can be opened by only one user */ +cpumask_var_t pipe_cpumask;int ref;int trace_ref;#ifdef CONFIG_FUNCTION_TRACER
Signature · 1 line
2.40.1
Steven Rostedt
maintainerPATCH 8/8 samples: ftrace: Replace bti assembly with hint for older compiler
In reply to a message not in the archiveFrom: "GONG, Ruiqi" <[email protected]>
When cross-building the arm64 kernel with allmodconfig using GCC 9.4, the following error occurs on multiple files under samples/ftrace/:
/tmp/ccPC1ODs.s: Assembler messages:/tmp/ccPC1ODs.s:8: Error: selected processor does not support `bti c'
Fix this issue by replacing bti c with hint 34, which is compatible for the older compiler.
--- samples/ftrace/ftrace-direct-modify.c | 4 ++-- samples/ftrace/ftrace-direct-multi-modify.c | 4 ++-- samples/ftrace/ftrace-direct-multi.c | 2 +- samples/ftrace/ftrace-direct-too.c | 2 +- samples/ftrace/ftrace-direct.c | 2 +- 5 files changed, 7 insertions(+), 7 deletions(-)
samples/ftrace/ftrace-direct-modify.c +2 -2
@@ -105,7 +105,7 @@ asm (" .type my_tramp1, @function\n" " .globl my_tramp1\n" " my_tramp1:" -" bti c\n" +" hint 34\n" // bti c " sub sp, sp, #16\n" " stp x9, x30, [sp]\n" " bl my_direct_func1\n"
@@ -117,7 +117,7 @@ asm (" .type my_tramp2, @function\n" " .globl my_tramp2\n" " my_tramp2:" -" bti c\n" +" hint 34\n" // bti c " sub sp, sp, #16\n" " stp x9, x30, [sp]\n" " bl my_direct_func2\n"
samples/ftrace/ftrace-direct-multi-modify.c +2 -2
@@ -112,7 +112,7 @@ asm (" .type my_tramp1, @function\n" " .globl my_tramp1\n" " my_tramp1:" -" bti c\n" +" hint 34\n" // bti c " sub sp, sp, #32\n" " stp x9, x30, [sp]\n" " str x0, [sp, #16]\n"
@@ -127,7 +127,7 @@ asm (" .type my_tramp2, @function\n" " .globl my_tramp2\n" " my_tramp2:" -" bti c\n" +" hint 34\n" // bti c " sub sp, sp, #32\n" " stp x9, x30, [sp]\n" " str x0, [sp, #16]\n"
samples/ftrace/ftrace-direct-multi.c +1 -1
@@ -75,7 +75,7 @@ asm (" .type my_tramp, @function\n" " .globl my_tramp\n" " my_tramp:" -" bti c\n" +" hint 34\n" // bti c " sub sp, sp, #32\n" " stp x9, x30, [sp]\n" " str x0, [sp, #16]\n"
samples/ftrace/ftrace-direct-too.c +1 -1
@@ -81,7 +81,7 @@ asm (" .type my_tramp, @function\n" " .globl my_tramp\n" " my_tramp:" -" bti c\n" +" hint 34\n" // bti c " sub sp, sp, #48\n" " stp x9, x30, [sp]\n" " stp x0, x1, [sp, #16]\n"
samples/ftrace/ftrace-direct.c +1 -1
@@ -72,7 +72,7 @@ asm (" .type my_tramp, @function\n" " .globl my_tramp\n" " my_tramp:" -" bti c\n" +" hint 34\n" // bti c " sub sp, sp, #32\n" " stp x9, x30, [sp]\n" " str x0, [sp, #16]\n"
Signature · 1 line
2.40.1