tracing/probes: Add more typecast features
Subsystems (3)
Masami Hiramatsu (Google)
maintainerv9 cover tracing/probes: Add more typecast features
Hi,
Here is the 9th version of series to introduce more typecast features to probe events. The previous version is here:
https://lore.kernel.org/all/178231208703.732967.1160700962651040729.stgit@devnote2/
In this version, I removed picked bugfix patch, prohibit percpu access method on non-kernel probes [8/9], and add a test case to check the new syntax[9/9].
This series extends BTF typecast feature and add more options:
1. Expanding BTF typecast to kprobe and fprobe.
(currently only function entry/exit)
2. Introduce container_of like typecast. This adds a "assigned member" option to the typecast.
(STRUCT,MEMBER)VAR->ANOTHER_MEMBER
This casts VAR to STRUCT type but the VAR is as the address of STRUCT.MEMBER. In C, it is:
container_of(VAR, STRUCT, MEMBER)->ANOTHER_MEMBER
3. Support nested typecast, e.g.
(STRUCT)((STRUCT2)VAR->MEMBER2)->MEMBER
the nest level must be smaller than 3.
4. Add $current variable to point "current" task_struct. This is useful with typecast, e.g.
(task_struct)$current->pid
5. per-cpu dereference support.
Intrdouce this_cpu_read(VAR) and this_cpu_ptr(VAR) to access per-cpu data on the current CPU (accessing other CPU data is not stable, because it can be changed.)
You can access the member of per-cpu data structure using typecast like:
(STRUCT)this_cpu_ptr(VAR)->MEMBER
6. Support event fields without $ prefix on eprobes.
Now eprobe events can access its event fields.
And added fetcharg dump feature (for debug) and updated test scripts to test part of them.
Thanks,
---
base-commit: c69b5f959286395e94c237ce6d7d4970bad7f6e3
Masami Hiramatsu (Google) (9):
tracing/probes: Allow eprobe to use variable without $ prefix tracing/probes: Support dumping fetcharg program for debugging dynamic events tracing/probes: Support typecast for various probe events tracing/probes: Support nested typecast
tracing/probes: Type casting always involves nested calls tracing/probes: Support field specifier option for typecast tracing/probes: Add $current variable support
tracing/probes: Add this_cpu_read() and this_cpu_ptr() dereference method to fetcharg tracing/probes: Add a new testcase for BTF typecasts
Documentation/trace/eprobetrace.rst | 9 Documentation/trace/fprobetrace.rst | 10 Documentation/trace/kprobetrace.rst | 11 kernel/trace/Kconfig | 12 kernel/trace/trace.c | 8 kernel/trace/trace_eprobe.c | 2 kernel/trace/trace_fprobe.c | 2 kernel/trace/trace_kprobe.c | 2 kernel/trace/trace_probe.c | 579 ++++++++++++++++---- kernel/trace/trace_probe.h | 100 ++- kernel/trace/trace_probe_tmpl.h | 25 + kernel/trace/trace_uprobe.c | 3 samples/trace_events/trace-events-sample.c | 40 + samples/trace_events/trace-events-sample.h | 34 + .../ftrace/test.d/dynevent/btf_probe_event.tc | 51 ++ .../test.d/dynevent/btf_typecast_accepted.tc | 107 ++++ .../test.d/dynevent/eprobes_syntax_errors.tc | 6 .../ftrace/test.d/dynevent/fprobe_syntax_errors.tc | 12 .../ftrace/test.d/kprobe/kprobe_syntax_errors.tc | 12 .../ftrace/test.d/kprobe/uprobe_syntax_errors.tc | 5 20 files changed, 876 insertions(+), 154 deletions(-) create mode 100644 tools/testing/selftests/ftrace/test.d/dynevent/btf_probe_event.tc create mode 100644 tools/testing/selftests/ftrace/test.d/dynevent/btf_typecast_accepted.tc
--
Masami Hiramatsu (Google) <[email protected]>
Masami Hiramatsu (Google)
maintainerPATCH v9 1/9 tracing/probes: Allow eprobe to use variable without $ prefix
From: Masami Hiramatsu (Google) <[email protected]>
The commit 69efd863a785 ("tracing/eprobes: Allow use of BTF names to dereference pointers") allows eprobe to use event field without "$" prefix when it is used with typecast, it is natual to allow it without typecast.
---
Changes in v8:
- Newly added.
--- kernel/trace/trace_probe.c | 12 +++++++++++- kernel/trace/trace_probe.h | 1 + .../test.d/dynevent/eprobes_syntax_errors.tc | 3 +-- 3 files changed, 13 insertions(+), 3 deletions(-)
kernel/trace/trace_probe.c +11 -1
@@ -1341,7 +1341,17 @@ parse_probe_arg(char *arg, const struct fetch_type *type, ret =handle_typecast (arg, pcode, end, ctx);break ;default : -if (isalpha (arg[0 ]) || arg[0 ] =='_' ) {/* BTF variable */ +if (isalpha (arg[0 ]) || arg[0 ] =='_' ) { +/* BTF variable or event field*/ +if (ctx->flags &TPARG_FL_TEVENT ) { + ret =parse_trace_event (arg, *pcode, ctx); +if (ret <0 ) { +trace_probe_log_err (ctx->offset, +NO_EVENT_FIELD ); +return -EINVAL ; + } +break ; + }if (!tparg_is_function_entry (ctx->flags) && !tparg_is_function_return (ctx->flags)) {trace_probe_log_err (ctx->offset,NOSUP_BTFARG );
kernel/trace/trace_probe.h +1 -0
@@ -559,6 +559,7 @@ extern int traceprobe_define_arg_fields(struct trace_event_call *event_call,C (NO_PTR_STRCT ,"This is not a pointer to union/structure." ), \C (NOSUP_DAT_ARG ,"Non pointer structure/union argument is not supported." ),\C (BAD_HYPHEN ,"Failed to parse single hyphen. Forgot '>'?" ), \ +C (NO_EVENT_FIELD ,"This event field is not found." ), \C (NO_BTF_FIELD ,"This field is not found." ), \C (BAD_BTF_TID ,"Failed to get BTF type info." ),\ C(BAD_TYPE4STR, "This type does not fit for string."),\
tools/testing/selftests/ftrace/test.d/dynevent/eprobes_syntax_errors.tc +1 -2
@@ -10,7 +10,7 @@ check_error() { # command-with-error-pos-by-^ check_error 'e ^a.' # NO_EVENT_INFO check_error 'e ^.b' # NO_EVENT_INFO check_error 'e ^a.b' # BAD_ATTACH_EVENT -check_error 'e syscalls/sys_enter_openat ^foo' # BAD_ATTACH_ARG +check_error 'e syscalls/sys_enter_openat ^foo' # NO_EVENT_FIELD check_error 'e:^/bar syscalls/sys_enter_openat' # NO_GROUP_NAME check_error 'e:^12345678901234567890123456789012345678901234567890123456789012345/bar syscalls/sys_enter_openat' # GROUP_TOO_LONG
@@ -19,7 +19,6 @@ check_error 'e:^ syscalls/sys_enter_openat' # NO_EVENT_NAME check_error 'e:foo/^12345678901234567890123456789012345678901234567890123456789012345 syscalls/sys_enter_openat' # EVENT_TOO_LONG check_error 'e:foo/^bar.1 syscalls/sys_enter_openat' # BAD_EVENT_NAME -check_error 'e:foo/bar syscalls/sys_enter_openat arg=^dfd' # BAD_FETCH_ARG check_error 'e:foo/bar syscalls/sys_enter_openat arg=^$foo' # BAD_ATTACH_ARG if grep -q '<attached-group>\.<attached-event>.*\[if <filter>\]' README; then
Masami Hiramatsu (Google)
maintainerPATCH v9 2/9 tracing/probes: Support dumping fetcharg program for debugging dynamic events
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
For debugging probe events, it is helpful to verify the compiled fetch instructions for each probe argument. This introduces a new kernel config CONFIG_PROBE_EVENTS_DUMP_FETCHARG to decode the instruction sequence of each argument and display it under a commented line starting with '#' immediately following the dynamic event definition (such as in dynamic_events, kprobe_events, uprobe_events, etc.).
For example:
/sys/kernel/tracing # cat dynamic_events p:kprobes/p_vfs_read_0 vfs_read arg1=+0(file):ustring arg2=%ax:x16 # arg1: ARG(0) -> ST_USTRING(offset=0,size=4) -> END
# arg2: REG(80) -> ST_RAW(size=2) -> END
---
Changes in v8:
- State this feature is only for debugging probe events.
- Fix dependency list after description in Kconfig.
Changes in v7:
- Show trace event field name for FETCH_OP_TP_ARG.
- Show immediate string value for FETCH_OP_IMMSTR.
- Fix style issues warned by checkpatch.pl.
Changes in v6:
- Newly added.
--- kernel/trace/Kconfig | 12 +++++ kernel/trace/trace_eprobe.c | 2 + kernel/trace/trace_fprobe.c | 2 + kernel/trace/trace_kprobe.c | 2 + kernel/trace/trace_probe.c | 96 +++++++++++++++++++++++++++++++++++++++++++ kernel/trace/trace_probe.h | 79 +++++++++++++++++++++-------------- kernel/trace/trace_uprobe.c | 3 + 7 files changed, 164 insertions(+), 32 deletions(-)
kernel/trace/Kconfig +12 -0
@@ -779,6 +779,18 @@ config PROBE_EVENTS_BTF_ARGS kernel function entry or a tracepoint. This is available only if BTF (BPF Type Format) support is enabled. +config PROBE_EVENTS_DUMP_FETCHARG + bool "Dump of dynamic probe event fetch-arguments" + depends on PROBE_EVENTS + default n + help + This shows the dump of fetch-arguments of dynamic probe events + alongside their event definitions in the dynamic_events file + as comment lines. This is useful to debug the probe events. + Since this exposes the raw values in the dynamic_events file, + it might be a security risk. Only enable it if you need to debug + probe events themselves. + config KPROBE_EVENTS depends on KPROBES depends on HAVE_REGS_AND_STACK_ACCESS_API
kernel/trace/trace_eprobe.c +2 -0
@@ -87,6 +87,8 @@ static int eprobe_dyn_event_show(struct seq_file *m, struct dyn_event *ev)seq_printf (m," %s=%s" , ep->tp.args[i].name, ep->tp.args[i].comm);seq_putc (m,'\n' ); +trace_probe_dump_args (m, &ep->tp); +return 0 ; }
kernel/trace/trace_fprobe.c +2 -0
@@ -1449,6 +1449,8 @@ static int trace_fprobe_show(struct seq_file *m, struct dyn_event *ev)seq_printf (m," %s=%s" , tf->tp.args[i].name, tf->tp.args[i].comm);seq_putc (m,'\n' ); +trace_probe_dump_args (m, &tf->tp); +return 0 ; }
kernel/trace/trace_kprobe.c +2 -0
@@ -1320,6 +1320,8 @@ static int trace_kprobe_show(struct seq_file *m, struct dyn_event *ev)seq_printf (m," %s=%s" , tk->tp.args[i].name, tk->tp.args[i].comm);seq_putc (m,'\n' ); +trace_probe_dump_args (m, &tk->tp); +return 0 ; }
kernel/trace/trace_probe.c +96 -0
99 lines not on this page · raw message
kernel/trace/trace_probe.h +47 -32
91 lines not on this page · raw message
kernel/trace/trace_uprobe.c +3 -0
@@ -765,6 +765,9 @@ static int trace_uprobe_show(struct seq_file *m, struct dyn_event *ev)seq_printf (m," %s=%s" , tu->tp.args[i].name, tu->tp.args[i].comm);seq_putc (m,'\n' ); + +trace_probe_dump_args (m, &tu->tp); +return 0 ; }
Masami Hiramatsu (Google)
maintainerPATCH v9 3/9 tracing/probes: Support typecast for various probe events
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
Support BTF typecast feature on other probe events, but only if it is kernel function entry or return, and must use function parameter name or $retval. This means you can do:
(STRUCT)PARAM->MEMBER
Note: you can not use other variables like $stackN, %reg etc. That needs nesting support.
To support other probe events, we just need to use last_struct type when we find a function parameter in parse_btf_arg().
This also updates <tracefs>/README file to show struct typecast.
---
Changes in v5:
- Add comments about $retval with typecast.
- Even if the type of retvalue is not known, if user specifies typecast, use it for its type.
Changes in v3:
- Clarify the limitation.
Changes in v2:
- Fix to re-enable typecast on eprobe.
--- Documentation/trace/fprobetrace.rst | 3 +++ Documentation/trace/kprobetrace.rst | 4 ++++ kernel/trace/trace.c | 2 +- kernel/trace/trace_probe.c | 23 +++++++++++++++++------ kernel/trace/trace_probe.h | 5 +++++ 5 files changed, 30 insertions(+), 7 deletions(-)
Documentation/trace/fprobetrace.rst +3 -0
@@ -57,6 +57,9 @@ Synopsis of fprobe-events (u8/u16/u32/u64/s8/s16/s32/s64), hexadecimal types (x8/x16/x32/x64), "char", "string", "ustring", "symbol", "symstr" and bitfield are supported. + (STRUCT)FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to + a pointer to STRUCT and then derference the pointer defined by + ->MEMBER. (\*1) This is available only when BTF is enabled. (\*2) only for the probe on function entry (offs == 0). Note, this argument access
Documentation/trace/kprobetrace.rst +4 -0
@@ -61,6 +61,10 @@ Synopsis of kprobe_events (x8/x16/x32/x64), VFS layer common type(%pd/%pD), "char", "string", "ustring", "symbol", "symstr" and bitfield are supported. + (STRUCT)FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to + a pointer to STRUCT and then derference the pointer defined by + ->MEMBER. Note that this is available only when the probe is + on function entry. (\*1) only for the probe on function entry (offs == 0). Note, this argument access is best effort, because depending on the argument type, it may be passed on
kernel/trace/trace.c +1 -1
@@ -4322,7 +4322,7 @@ static const char readme_msg[] =#ifdef CONFIG_HAVE_FUNCTION_ARG_ACCESS_API "\t $stack<index>, $stack, $retval, $comm, $arg<N>,\n" #ifdef CONFIG_PROBE_EVENTS_BTF_ARGS - "\t <argname>[->field[->field|.field...]],\n" + "\t [(structname)]<argname>[->field[->field|.field...]],\n"#endif #else "\t $stack<index>, $stack, $retval, $comm,\n"
kernel/trace/trace_probe.c +17 -6
@@ -699,7 +699,7 @@ static int parse_btf_arg(char *varname,if (ctx->flags &TPARG_FL_RETURN && !strcmp (varname,"$retval" )) { code->op =FETCH_OP_RETVAL ; -/* Check whether the function return type is not void */ +/* Check whether the function return type is not void, even with typecast. */ if (query_btf_context (ctx) ==0 ) {if (ctx->proto->type ==0 ) {trace_probe_log_err (ctx->offset,NO_RETVAL );
@@ -708,6 +708,13 @@ static int parse_btf_arg(char *varname, tid = ctx->proto->type; goto found; } +/* +* Even if we can not find appropriate BTF info, we can still access +* the field via typecast. +*/ +if (ctx->struct_btf) + goto found; +if (field) {trace_probe_log_err (ctx->offset + field - varname,NO_BTF_ENTRY );
@@ -752,7 +759,10 @@ static int parse_btf_arg(char *varname,return -ENOENT ; found: - type =btf_type_skip_modifiers (ctx->btf, tid,NULL ); +if (ctx->struct_btf) + type = ctx->last_struct; +else + type =btf_type_skip_modifiers (ctx->btf, tid,NULL ); found_type:if (!type) {trace_probe_log_err (ctx->offset,BAD_BTF_TID );
@@ -829,10 +839,11 @@ static int handle_typecast(char *arg, struct fetch_insn **pcode,char *tmp;int ret; -/* Currently this only works for eprobes */ -if (!(ctx->flags &TPARG_FL_TEVENT )) { -trace_probe_log_err (ctx->offset,TYPECAST_NOT_EVENT ); -return -EINVAL ; +if (!(tparg_is_event_probe (ctx->flags) || +tparg_is_function_entry (ctx->flags) || +tparg_is_function_return (ctx->flags))) { +trace_probe_log_err (ctx->offset,NOSUP_BTFARG ); +return -EOPNOTSUPP ; } tmp =strchr (arg,')' );
kernel/trace/trace_probe.h +5 -0
@@ -429,6 +429,11 @@ static inline bool tparg_is_function_return(unsigned int flags)return (flags &TPARG_FL_LOC_MASK ) == (TPARG_FL_KERNEL |TPARG_FL_RETURN ); } +static inline bool tparg_is_event_probe (unsigned int flags) +{ +return !!(flags &TPARG_FL_TEVENT ); +} +struct traceprobe_parse_context {struct trace_event_call *event;/* BTF related parameters */
Masami Hiramatsu (Google)
maintainerPATCH v9 4/9 tracing/probes: Support nested typecast
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
When we hit an open parenthesis right after typecast closing parenthesis, it means we have nested typecast. This allows us to typecast a generic data member in a structure to a pointer to another structure.
For example, to cast a DATA_MEMBER of VAR structure to STRUCT pointer and get MEMBER value.
(STRUCT)(VAR->DATA_MEMBER)->MEMBER
Also, we can nest typecast.
(STRUCT1)((STRUCT2)$ARG->FIELD2)->FIELD1
Currently the max nest level is limited to 3.
This also allows user to use typecasting for registers or stacks on kprobe events. e.g.
(STRUCT)(%ax)->MEMBER
(STRUCT)($stack0)->MEMBER
---
Changes in v6:
- Add a WARN_ON_ONCE check for leaking nested_level (it must not happen.)
Changes in v4:
- Use orig_offset for reporting NO_PTR_STRCT error.
Changes in v2:
- Fix to skip "->" after closing parenthetsis.
--- Documentation/trace/eprobetrace.rst | 2 + Documentation/trace/fprobetrace.rst | 2 + Documentation/trace/kprobetrace.rst | 2 + kernel/trace/trace.c | 1 kernel/trace/trace_probe.c | 81 ++++++++++++++++++++++++++++++++--- kernel/trace/trace_probe.h | 7 +++ 6 files changed, 86 insertions(+), 9 deletions(-)
Documentation/trace/eprobetrace.rst +2 -0
@@ -50,6 +50,8 @@ Synopsis of eprobe_events a pointer to STRUCT and then derference the pointer defined by ->MEMBER. Note that when this is used, the FIELD name does not need to be prefixed with a '$'. + (STRUCT)(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can + also be used with another FETCHARG instead of FIELD. Types -----
Documentation/trace/fprobetrace.rst +2 -0
@@ -60,6 +60,8 @@ Synopsis of fprobe-events (STRUCT)FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to a pointer to STRUCT and then derference the pointer defined by ->MEMBER. + (STRUCT)(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can + also be used with another FETCHARG instead of FIELD. (\*1) This is available only when BTF is enabled. (\*2) only for the probe on function entry (offs == 0). Note, this argument access
Documentation/trace/kprobetrace.rst +2 -0
@@ -65,6 +65,8 @@ Synopsis of kprobe_events a pointer to STRUCT and then derference the pointer defined by ->MEMBER. Note that this is available only when the probe is on function entry. + (STRUCT)(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can + also be used with another FETCHARG instead of FIELD. (\*1) only for the probe on function entry (offs == 0). Note, this argument access is best effort, because depending on the argument type, it may be passed on
kernel/trace/trace.c +1 -0
@@ -4323,6 +4323,7 @@ static const char readme_msg[] ="\t $stack<index>, $stack, $retval, $comm, $arg<N>,\n" #ifdef CONFIG_PROBE_EVENTS_BTF_ARGS"\t [(structname)]<argname>[->field[->field|.field...]],\n" + "\t [(structname)](fetcharg)->field[->field|.field...],\n"#endif #else "\t $stack<index>, $stack, $retval, $comm,\n"
kernel/trace/trace_probe.c +73 -8
108 lines not on this page · raw message
kernel/trace/trace_probe.h +6 -1
@@ -450,8 +450,11 @@ struct traceprobe_parse_context {struct trace_probe *tp;unsigned int flags;int offset; +int nested_level; }; +#define TRACEPROBE_MAX_NESTED_LEVEL 3 +extern int traceprobe_parse_probe_arg (struct trace_probe *tp,int i,const char *argv,struct traceprobe_parse_context *ctx);
@@ -587,7 +590,9 @@ extern int traceprobe_define_arg_fields(struct trace_event_call *event_call,C (TOO_MANY_ARGS ,"Too many arguments are specified" ), \C (TOO_MANY_EARGS ,"Too many entry arguments specified" ), \C (EVENT_TOO_BIG ,"Event too big (too many fields?)" ), \ -C (TYPECAST_NOT_EVENT ,"Typecasts are only for eprobe fields" ), +C (TYPECAST_NOT_EVENT ,"Typecasts are only for eprobe fields" ), \ +C (TYPECAST_REQ_FIELD ,"Typecast requires a field access" ), \ +C (TOO_MANY_NESTED ,"Too many nested typecasts/dereferences" ), #undef C #define C(a, b) TP_ERR_##a
Masami Hiramatsu (Google)
maintainerPATCH v9 5/9 tracing/probes: Type casting always involves nested calls
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
This allows type casting to various fetchargs without parentheses by recursively calling parse_probe_arg on the target when type casting is used.
For example, this allows the following expressions:
- (STRUCT)%REG->FIELD
- (STRUCT)$stackN->FIELD
- (STRUCT)@SYM->FIELD
Note that @SYM+/-OFFSET with typecast needs parentheses like:
- (STRUCT)(@SYM-8)->FIELD
---
Changes in v8:
- Fix caret position in error case.
- Add a comment about @SYM+/-OFFSET without parentheses.
Changes in v7:
- Prohibit using @SYM+/-OFFSET without parentheses.
- Cleanup parse_btf_arg() since ctx->struct_btf is always NULL now.
Changes in v6:
- Newly added.
--- kernel/trace/trace_probe.c | 123 ++++++++++++++++++++++++++------------------ kernel/trace/trace_probe.h | 4 + 2 files changed, 75 insertions(+), 52 deletions(-)
kernel/trace/trace_probe.c +72 -51
@@ -684,19 +684,6 @@ static int parse_btf_arg(char *varname,return -EOPNOTSUPP ; } -if (ctx->flags &TPARG_FL_TEVENT ) { - ret =parse_trace_event (varname, code, ctx); -if (ret <0 ) { -trace_probe_log_err (ctx->offset,BAD_ATTACH_ARG ); -return ret; - } -/* TEVENT is only here via a typecast */ -if (WARN_ON_ONCE (ctx->struct_btf ==NULL )) -return -EINVAL ; - type = ctx->last_struct; - goto found_type; - } -if (ctx->flags &TPARG_FL_RETURN && !strcmp (varname,"$retval" )) { code->op =FETCH_OP_RETVAL ;/* Check whether the function return type is not void, even with typecast. */
@@ -708,13 +695,6 @@ static int parse_btf_arg(char *varname, tid = ctx->proto->type; goto found; } -/* -* Even if we can not find appropriate BTF info, we can still access -* the field via typecast. -*/ -if (ctx->struct_btf) - goto found; -if (field) {trace_probe_log_err (ctx->offset + field - varname,NO_BTF_ENTRY );
@@ -759,11 +739,7 @@ static int parse_btf_arg(char *varname,return -ENOENT ; found: -if (ctx->struct_btf) - type = ctx->last_struct; -else - type =btf_type_skip_modifiers (ctx->btf, tid,NULL ); -found_type: + type =btf_type_skip_modifiers (ctx->btf, tid,NULL );if (!type) {trace_probe_log_err (ctx->offset,BAD_BTF_TID );return -EINVAL ;
@@ -860,7 +836,7 @@ static int handle_typecast(char *arg, struct fetch_insn **pcode, struct traceprobe_parse_context *ctx) {int orig_offset = ctx->offset; -bool nested = false; +char *close;char *tmp;int ret;
@@ -871,6 +847,17 @@ static int handle_typecast(char *arg, struct fetch_insn **pcode,return -EOPNOTSUPP ; } +/* +* Always consider the token after typecast as a nested call +* For example: (STRUCT)VAR->FIELD and (STRUCT)(VAR)->FIELD are same. +* VAR is solved in the nested call. +*/ + ctx->nested_level++; +if (ctx->nested_level >TRACEPROBE_MAX_NESTED_LEVEL ) { +trace_probe_log_err (ctx->offset,TOO_MANY_NESTED ); +return -E2BIG ; + } + tmp =strchr (arg,')' );if (!tmp) { trace_probe_log_err(ctx->offset + strlen(arg),
@@ -879,11 +866,10 @@ static int handle_typecast(char *arg, struct fetch_insn **pcode, } *tmp++ ='\0' ; -/* Handle the nested structure like (STRUCT)(VAR->FIELD)->... */ + ctx->offset += tmp - arg;if (*tmp =='(' ) { -char *close =find_matched_close_paren (tmp); + close =find_matched_close_paren (tmp); - ctx->offset += tmp - arg;if (!close) {trace_probe_log_err (ctx->offset,DEREF_OPEN_BRACE );return -EINVAL ;
@@ -894,27 +880,66 @@ static int handle_typecast(char *arg, struct fetch_insn **pcode, TYPECAST_REQ_FIELD);return -EINVAL ; } - - ctx->nested_level++; -if (ctx->nested_level >TRACEPROBE_MAX_NESTED_LEVEL ) { -trace_probe_log_err (ctx->offset,TOO_MANY_NESTED ); -return -E2BIG ; +/* Skip '(' */ + ctx->offset +=1 ; + tmp++; + }else if (*tmp =='+' || *tmp =='-' ) { +/* Dereference can have another field access inside it. */ +char *open =strchr (tmp +1 ,'(' ); + +if (!open) { +trace_probe_log_err (ctx->offset, +DEREF_NEED_BRACE ); +return -EINVAL ; + } + close =find_matched_close_paren (open); +if (!close) { +trace_probe_log_err (ctx->offset +strlen (tmp), +DEREF_OPEN_BRACE ); +return -EINVAL ; + } + close++; +/* We expect a field access for typecast */ +if (close[0 ] !='-' || close[1 ] !='>' ) { +trace_probe_log_err (ctx->offset + close - tmp, +TYPECAST_REQ_FIELD ); +return -EINVAL ; + } + }else { +if (tmp[0 ] =='@' ) { +/* @sym+offset is not allowed without parenthesized */ + close =strpbrk (tmp,"+-" ); +if (close &&isdigit (close[1 ])) { +trace_probe_log_err (ctx->offset, +TYPECAST_SYM_OFFSET ); +return -EINVAL ; + } } - *close ='\0' ; +/* Inner variable name */ + close =strchr (tmp,'-' ); +if (!close || close[1 ] !='>' ) { +trace_probe_log_err (ctx->offset +strlen (tmp), +TYPECAST_REQ_FIELD ); +return -EINVAL ; + } + } + *close ='\0' ; - ctx->offset +=1 ;/* for the '(' */ -/* We need to parse the nested one */ - ret =parse_probe_arg (tmp +1 ,find_fetch_type (NULL , ctx->flags), - pcode, end, ctx); -if (ret <0 ) -return ret; - ctx->nested_level--; -clear_struct_btf (ctx); +/* We need to parse the nested one */ + ret =parse_probe_arg (tmp,find_fetch_type (NULL , ctx->flags), + pcode, end, ctx); +if (ret <0 ) +return ret; + ctx->nested_level--; +clear_struct_btf (ctx); - tmp = close +3 ;/* Skip "->" after closing parenthesis */ - nested = true; - } +/* Let tmp point the field name. */ +if (close[1 ] =='-' ) + tmp = close +3 ;/* Skip "->" after closing parenthesis */ +else + tmp = close +2 ;/* Skip ">" after inner variable name */ +/* resolve the typecast struct name */ ret =query_btf_struct (arg +1 , ctx);if (ret <0 ) {trace_probe_log_err (orig_offset +1 ,NO_PTR_STRCT );
@@ -922,11 +947,7 @@ static int handle_typecast(char *arg, struct fetch_insn **pcode, } ctx->offset = orig_offset + tmp - arg; -/* If it is nested, tmp points to the field name. */ -if (nested) - ret =parse_btf_field (tmp, ctx->last_struct, pcode, end, ctx); -else - ret =parse_btf_arg (tmp, pcode, end, ctx); + ret =parse_btf_field (tmp, ctx->last_struct, pcode, end, ctx);return ret; }
kernel/trace/trace_probe.h +3 -1
@@ -453,6 +453,7 @@ struct traceprobe_parse_context {int nested_level; }; +/* Each typecast consumes nested level. So the max number of typecast is 3. */ #define TRACEPROBE_MAX_NESTED_LEVEL 3 extern int traceprobe_parse_probe_arg(struct trace_probe *tp, int i,
@@ -592,7 +593,8 @@ extern int traceprobe_define_arg_fields(struct trace_event_call *event_call,C (EVENT_TOO_BIG ,"Event too big (too many fields?)" ), \C (TYPECAST_NOT_EVENT ,"Typecasts are only for eprobe fields" ), \C (TYPECAST_REQ_FIELD ,"Typecast requires a field access" ), \ -C (TOO_MANY_NESTED ,"Too many nested typecasts/dereferences" ), +C (TOO_MANY_NESTED ,"Too many nested typecasts/dereferences" ), \ + C(TYPECAST_SYM_OFFSET, "@SYM+/-OFFSET with typecast needs parentheses")#undef C#define C (a, b) TP_ERR_##a
Masami Hiramatsu (Google)
maintainerPATCH v9 6/9 tracing/probes: Support field specifier option for typecast
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
Add a field specifier option for the typecast. This works like container_of() macro.
(STRUCT[,FIELD[.FIELD2...]])VAR
This is equivalent to :
container_of(VAR, struct STRUCT, FIELD[.FIELD2...])
For example:
echo "f tick_nohz_handler next_tick=(tick_sched,sched_timer)timer->next_tick" >> dynamic_events
This will trace tick_nohz_handler() with its tick_sched::next_tick which is converted from @timer by contianer_of(tick, struct tick_sched, sched_timer). So, if you enabkle both fprobes:tick_nohz_handler__entry and timer:hrtimer_expire_entry events, we will see something like:
<idle>-0 [002] d.h1. 3778.087272: hrtimer_expire_entry: hrtimer=00000000d63db328 f
unction=tick_nohz_handler now=3777450051040
<idle>-0 [002] d.h1. 3778.087281: tick_nohz_handler__entry: (tick_nohz_handler+0x4/0x140) next_tick=3777450000000
---
Changes in v6:
- Update according to the allways nested patch.
Changes in v3:
- Fix error caret position.
Changes in v2:
- Use byteoffset for typecast field offset instead of bitoffset. This fixes negative modulo calculation.
- Check whether a field is specified after typecast.
- Reject if typecast field option has arrow operator.
--- Documentation/trace/eprobetrace.rst | 5 + Documentation/trace/fprobetrace.rst | 8 +- Documentation/trace/kprobetrace.rst | 8 +- kernel/trace/trace.c | 4 - kernel/trace/trace_probe.c | 169 ++++++++++++++++++++++++----------- kernel/trace/trace_probe.h | 5 + 6 files changed, 135 insertions(+), 64 deletions(-)
Documentation/trace/eprobetrace.rst +4 -1
@@ -49,7 +49,10 @@ Synopsis of eprobe_events (STRUCT)FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to a pointer to STRUCT and then derference the pointer defined by ->MEMBER. Note that when this is used, the FIELD name does not - need to be prefixed with a '$'. + need to be prefixed with a '$'. ASGN can be specified optionally. + If ASGN is specified, FIELD will be cast to the same offset + position as the ASGN member, rather than to the beginning of + the STRUCT. (STRUCT)(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can also be used with another FETCHARG instead of FIELD.
Documentation/trace/fprobetrace.rst +5 -3
@@ -57,10 +57,12 @@ Synopsis of fprobe-events (u8/u16/u32/u64/s8/s16/s32/s64), hexadecimal types (x8/x16/x32/x64), "char", "string", "ustring", "symbol", "symstr" and bitfield are supported. - (STRUCT)FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to + (STRUCT[,ASGN])FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to a pointer to STRUCT and then derference the pointer defined by - ->MEMBER. - (STRUCT)(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can + ->MEMBER. ASGN can be specified optionally. If ASGN is specified, + FIELD will be cast to the same offset position as the ASGN member, + rather than to the beginning of the STRUCT. + (STRUCT[,ASGN])(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can also be used with another FETCHARG instead of FIELD. (\*1) This is available only when BTF is enabled.
Documentation/trace/kprobetrace.rst +5 -3
@@ -61,11 +61,13 @@ Synopsis of kprobe_events (x8/x16/x32/x64), VFS layer common type(%pd/%pD), "char", "string", "ustring", "symbol", "symstr" and bitfield are supported. - (STRUCT)FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to + (STRUCT[,ASGN])FIELD->MEMBER[->MEMBER] : If BTF is supported, typecast FIELD to a pointer to STRUCT and then derference the pointer defined by ->MEMBER. Note that this is available only when the probe is - on function entry. - (STRUCT)(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can + on function entry. ASGN can be specified optionally. If ASGN + is specified, FIELD will be cast to the same offset position + as the ASGN member, rather than to the beginning of the STRUCT. + (STRUCT[,ASGN])(FETCHARG)->MEMBER[->MEMBER] : typecast can nest, so the above can also be used with another FETCHARG instead of FIELD. (\*1) only for the probe on function entry (offs == 0). Note, this argument access
kernel/trace/trace.c +2 -2
@@ -4322,8 +4322,8 @@ static const char readme_msg[] =#ifdef CONFIG_HAVE_FUNCTION_ARG_ACCESS_API "\t $stack<index>, $stack, $retval, $comm, $arg<N>,\n" #ifdef CONFIG_PROBE_EVENTS_BTF_ARGS -"\t [(structname)]<argname>[->field[->field|.field...]],\n" - "\t [(structname)](fetcharg)->field[->field|.field...],\n" +"\t [(structname[,field])]<argname>[->field[->field|.field...]],\n" + "\t [(structname[,field])](fetcharg)->field[->field|.field...],\n"#endif #else "\t $stack<index>, $stack, $retval, $comm,\n"
kernel/trace/trace_probe.c +115 -54
216 lines not on this page · raw message
kernel/trace/trace_probe.h +4 -1
@@ -451,6 +451,7 @@ struct traceprobe_parse_context {unsigned int flags;int offset;int nested_level; +int prefix_byteoffs;/* The byte offset of the prefix field of typecast */ };/* Each typecast consumes nested level. So the max number of typecast is 3. */
@@ -594,7 +595,9 @@ extern int traceprobe_define_arg_fields(struct trace_event_call *event_call,C (TYPECAST_NOT_EVENT ,"Typecasts are only for eprobe fields" ), \C (TYPECAST_REQ_FIELD ,"Typecast requires a field access" ), \C (TOO_MANY_NESTED ,"Too many nested typecasts/dereferences" ), \ - C(TYPECAST_SYM_OFFSET, "@SYM+/-OFFSET with typecast needs parentheses") + C(TYPECAST_SYM_OFFSET, "@SYM+/-OFFSET with typecast needs parentheses") \ +C (TYPECAST_NOT_ALIGNED ,"Typecast field option is not byte-aligned" ), \ +C (TYPECAST_BAD_ARROW ,"Typecast field option does not support -> operator" ), #undef C #define C(a, b) TP_ERR_##a
Masami Hiramatsu (Google)
maintainerPATCH v9 7/9 tracing/probes: Add $current variable support
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
Since we can use the BTF to cast value to a structure pointer type, it is useful to introduce "$current" special variable support to fetcharg.
User can define a fetcharg to access current task_struct properties using BTF info. e.g.
$current->cpus_ptr
---
Changes in v8:
- Avoid uninitialized ctx->btf issue on $current without typecast.
Changes in v7:
- Fix to use force-typecast for task_struct implicitly.
Changes in v6:
- Rebased on dump fetcharg patch.
- Remove function name/eprobe requirement for $current.
Changes in v5:
- Use s32 for bof_find_btf_id().
Changes in v4:
- Add $current in README when CONFIG_HAVE_FUNCTION_ARG_ACCESS_API=y case.
- Fix to prohibit using $current in eprobes and address based kprobes.
Changes in v3:
- Remove $current support from eprobes (because eprobes is only for event)
- Prohibit uprobes to use $current.
Changes in v2:
- Support to parse $current in parse_btf_arg().
- If no typecast on $current, it automatically casted to task_struct.
- Check error case if $current follows something except for "-".
--- Documentation/trace/fprobetrace.rst | 1 + Documentation/trace/kprobetrace.rst | 1 + kernel/trace/trace.c | 4 ++-- kernel/trace/trace_probe.c | 37 ++++++++++++++++++++++++++++++++++- kernel/trace/trace_probe.h | 1 + kernel/trace/trace_probe_tmpl.h | 3 +++ 6 files changed, 44 insertions(+), 3 deletions(-)
Documentation/trace/fprobetrace.rst +1 -0
@@ -50,6 +50,7 @@ Synopsis of fprobe-events $argN : Fetch the Nth function argument. (N >= 1) (\*2) $retval : Fetch return value.(\*3) $comm : Fetch current task comm. + $current : Fetch the address of the current task_struct. +|-[u]OFFS(FETCHARG) : Fetch memory at FETCHARG +|- OFFS address.(\*4)(\*5) \IMM : Store an immediate value to the argument. NAME=FETCHARG : Set NAME as the argument name of FETCHARG.
Documentation/trace/kprobetrace.rst +1 -0
@@ -53,6 +53,7 @@ Synopsis of kprobe_events $argN : Fetch the Nth function argument. (N >= 1) (\*1) $retval : Fetch return value.(\*2) $comm : Fetch current task comm. + $current : Fetch the address of the current task_struct. +|-[u]OFFS(FETCHARG) : Fetch memory at FETCHARG +|- OFFS address.(\*3)(\*4) \IMM : Store an immediate value to the argument. NAME=FETCHARG : Set NAME as the argument name of FETCHARG.
kernel/trace/trace.c +2 -2
@@ -4320,13 +4320,13 @@ static const char readme_msg[] = "\t args: <name>=fetcharg[:type]\n" "\t fetcharg: (%<register>|$<efield>), @<address>, @<symbol>[+|-<offset>],\n" #ifdef CONFIG_HAVE_FUNCTION_ARG_ACCESS_API - "\t $stack<index>, $stack, $retval, $comm, $arg<N>,\n" + "\t $stack<index>, $stack, $retval, $comm, $arg<N>, $current\n" #ifdef CONFIG_PROBE_EVENTS_BTF_ARGS "\t [(structname[,field])]<argname>[->field[->field|.field...]],\n" "\t [(structname[,field])](fetcharg)->field[->field|.field...],\n" #endif #else -"\t $stack<index>, $stack, $retval, $comm,\n" +"\t $stack<index>, $stack, $retval, $comm, $current\n" #endif"\t +|-[u]<offset>(<fetcharg>), \\imm-value, \\\"imm-string\"\n" "\t kernel return probes support: $retval, $arg<N>, $comm\n"
kernel/trace/trace_probe.c +36 -1
@@ -692,7 +692,9 @@ static int parse_btf_arg(char *varname,int i, is_ptr, ret;u32 tid; -if (!ctx->funcname && !(ctx->flags &TPARG_FL_TEVENT )) +/* Note: field is not separated at this point, so check prefix. */ +if (!str_has_prefix (varname,"$current" ) && + !ctx->funcname && !(ctx->flags &TPARG_FL_TEVENT ))return -EINVAL ; is_ptr =split_next_field (varname, &field, ctx);
@@ -705,6 +707,20 @@ static int parse_btf_arg(char *varname,return -EOPNOTSUPP ; } +if (!strcmp (varname,"$current" )) { + code->op =FETCH_OP_CURRENT ; +/* If no typecast is specified for $current, use task_struct by default */ + ret =bpf_find_btf_id ("task_struct" ,BTF_KIND_STRUCT , &ctx->struct_btf); +if (ret <0 ) { +trace_probe_log_err (ctx->offset,NO_BTF_ENTRY ); +return -ENOENT ; + } + tid = (u32 )ret; + type = ctx->last_struct = +btf_type_skip_modifiers (ctx->struct_btf, tid,NULL ); + goto found_type; + } +if (ctx->flags &TPARG_FL_RETURN && !strcmp (varname,"$retval" )) { code->op =FETCH_OP_RETVAL ;/* Check whether the function return type is not void, even with typecast. */
@@ -761,6 +777,7 @@ static int parse_btf_arg(char *varname, found: type =btf_type_skip_modifiers (ctx->btf, tid,NULL ); +found_type:if (!type) {trace_probe_log_err (ctx->offset,BAD_BTF_TID );return -EINVAL ;
@@ -1270,6 +1287,24 @@ static int parse_probe_vars(char *orig_arg, const struct fetch_type *t,return 0 ; } +/* $current returns the address of the current task_struct. */ +if (str_has_prefix (arg,"current" )) { +/* $current is only supported by kernel probe. */ +if (!(ctx->flags &TPARG_FL_KERNEL )) { + err =TP_ERR_BAD_VAR ; + goto inval; + } + arg +=strlen ("current" ); +if (*arg =='-' &&IS_ENABLED (CONFIG_PROBE_EVENTS_BTF_ARGS )) +return parse_btf_arg (orig_arg, pcode, end, ctx); + +if (*arg !='\0' ) + goto inval; + + code->op =FETCH_OP_CURRENT ; +return 0 ; + } +#ifdef CONFIG_HAVE_FUNCTION_ARG_ACCESS_API len =str_has_prefix (arg,"arg" );if (len) {
kernel/trace/trace_probe.h +1 -0
@@ -92,6 +92,7 @@ typedef int (*print_type_func_t)(struct trace_seq *, void *, void *);FETCH_OP (RETVAL , none),/* Return value */ \FETCH_OP (IMM , imm),/* Immediate: .immediate */ \FETCH_OP (COMM , none),/* Current comm */ \ +FETCH_OP (CURRENT , none),/* Current task_struct address */ \FETCH_OP (ARG , param),/* Argument: .param = index */ \FETCH_OP (FOFFS , imm),/* File offset: .immediate */ \ FETCH_OP(IMMSTR, string), /* Allocated string: .data */ \
kernel/trace/trace_probe_tmpl.h +3 -0
@@ -112,6 +112,9 @@ process_common_fetch_insn(struct fetch_insn *code, unsigned long *val)case FETCH_OP_IMMSTR : *val = (unsigned long )code->data;break ; +case FETCH_OP_CURRENT : + *val = (unsigned long )current; +break ;default :return -EILSEQ ; }
Masami Hiramatsu (Google)
maintainerPATCH v9 8/9 tracing/probes: Add this_cpu_read() and this_cpu_ptr() dereference method to fetcharg
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
When tracing the kernel local variables, sometimes we need to get the CPU local variables. To access it, current simple dereference is not enough.
Thus, introduce a special this_cpu_read() dereference to access per-cpu variable for the current CPU (accessing other CPU variable may race with updates on other CPUs). Also this_cpu_ptr() is for accessing per-cpu pointer.
Those are working as same as the kernel percpu macro.
---
Changes in v9:
- Prohibit this_cpu_*() for non kernel probes.
Changes in v6:
- Rebased on dump fetcharg patch.
- Fix to fetch static percpu variable with @SYM correctly.
Changes in v5:
- Simplify this_cpu_read() into +0(this_cpu_ptr()).
Changes in v3:
- Remove NULL check for percpu var because it is just an offset, could be 0.
- Simplify process_fetch_insn_bottom() code.
- If the last operation is this_cpu_read(), read only memory of the specific size (of type).
Changes in v2:
- Drop +CPU/+PCPU and introduce this_cpu_read() and this_cpu_ptr().
- Support these method with BTF typecast.
- Just check the base address is NOT NULL instead of is_kernel_percpu_address().
--- Documentation/trace/eprobetrace.rst | 2 Documentation/trace/fprobetrace.rst | 2 Documentation/trace/kprobetrace.rst | 2 kernel/trace/trace.c | 1 kernel/trace/trace_probe.c | 148 ++++++++++++++++++++++++++--------- kernel/trace/trace_probe.h | 6 + kernel/trace/trace_probe_tmpl.h | 22 ++++- 7 files changed, 137 insertions(+), 46 deletions(-)
Documentation/trace/eprobetrace.rst +2 -0
@@ -39,6 +39,8 @@ Synopsis of eprobe_events @SYM[+|-offs] : Fetch memory at SYM +|- offs (SYM should be a data symbol) $comm : Fetch current task comm. +|-[u]OFFS(FETCHARG) : Fetch memory at FETCHARG +|- OFFS address.(\*3)(\*4) + this_cpu_read(FETCHARG) : Read the value of the per-CPU variable FETCHARG on the current CPU. + this_cpu_ptr(FETCHARG) : Get the address of the per-CPU variable FETCHARG on the current CPU. \IMM : Store an immediate value to the argument. NAME=FETCHARG : Set NAME as the argument name of FETCHARG. FETCHARG:TYPE : Set TYPE as the type of FETCHARG. Currently, basic types
Documentation/trace/fprobetrace.rst +2 -0
@@ -52,6 +52,8 @@ Synopsis of fprobe-events $comm : Fetch current task comm. $current : Fetch the address of the current task_struct. +|-[u]OFFS(FETCHARG) : Fetch memory at FETCHARG +|- OFFS address.(\*4)(\*5) + this_cpu_read(FETCHARG) : Read the value of the per-CPU variable FETCHARG on the current CPU. + this_cpu_ptr(FETCHARG) : Get the address of the per-CPU variable FETCHARG on the current CPU. \IMM : Store an immediate value to the argument. NAME=FETCHARG : Set NAME as the argument name of FETCHARG. FETCHARG:TYPE : Set TYPE as the type of FETCHARG. Currently, basic types
Documentation/trace/kprobetrace.rst +2 -0
@@ -55,6 +55,8 @@ Synopsis of kprobe_events $comm : Fetch current task comm. $current : Fetch the address of the current task_struct. +|-[u]OFFS(FETCHARG) : Fetch memory at FETCHARG +|- OFFS address.(\*3)(\*4) + this_cpu_read(FETCHARG) : Read the value of the per-CPU variable FETCHARG on the current CPU. + this_cpu_ptr(FETCHARG) : Get the address of the per-CPU variable FETCHARG on the current CPU. \IMM : Store an immediate value to the argument. NAME=FETCHARG : Set NAME as the argument name of FETCHARG. FETCHARG:TYPE : Set TYPE as the type of FETCHARG. Currently, basic types
kernel/trace/trace.c +1 -0
@@ -4329,6 +4329,7 @@ static const char readme_msg[] = "\t $stack<index>, $stack, $retval, $comm, $current\n"#endif "\t +|-[u]<offset>(<fetcharg>), \\imm-value, \\\"imm-string\"\n" +"\t this_cpu_read(<fetcharg>), this_cpu_ptr(<fetcharg>)\n" "\t kernel return probes support: $retval, $arg<N>, $comm\n" "\t type: s8/16/32/64, u8/16/32/64, x8/16/32/64, char, string, symbol,\n" "\t b<bit-width>@<bit-offset>/<container-size>, ustring,\n"
kernel/trace/trace_probe.c +110 -38
185 lines not on this page · raw message
kernel/trace/trace_probe.h +4 -2
@@ -101,6 +101,7 @@ typedef int (*print_type_func_t)(struct trace_seq *, void *, void *);/* Stage 2 (dereference) ops */ \FETCH_OP (DEREF , offset),/* Dereference: .offset */ \FETCH_OP (UDEREF , offset),/* User-space dereference: .offset */ \ +FETCH_OP (CPU_PTR , none),/* Per-CPU pointer: .offset */ \/* Stage 3 (store) ops */ \FETCH_OP (ST_RAW , store),/* Raw value: .size */ \ FETCH_OP(ST_MEM, store), /* Memory: .offset, .size */ \
@@ -596,9 +597,10 @@ extern int traceprobe_define_arg_fields(struct trace_event_call *event_call,C (TYPECAST_NOT_EVENT ,"Typecasts are only for eprobe fields" ), \C (TYPECAST_REQ_FIELD ,"Typecast requires a field access" ), \C (TOO_MANY_NESTED ,"Too many nested typecasts/dereferences" ), \ - C(TYPECAST_SYM_OFFSET, "@SYM+/-OFFSET with typecast needs parentheses") \ +C (TYPECAST_SYM_OFFSET ,"@SYM+/-OFFSET with typecast needs parentheses" ), \C (TYPECAST_NOT_ALIGNED ,"Typecast field option is not byte-aligned" ), \ -C (TYPECAST_BAD_ARROW ,"Typecast field option does not support -> operator" ), +C (TYPECAST_BAD_ARROW ,"Typecast field option does not support -> operator" ), \ +C (NOSUP_PERCPU ,"Per-cpu variable access is only for kernel probes" ), #undef C #define C(a, b) TP_ERR_##a
kernel/trace/trace_probe_tmpl.h +16 -6
@@ -129,25 +129,35 @@ process_fetch_insn_bottom(struct fetch_insn *code, unsigned long val,struct fetch_insn *s3 =NULL ;int total =0 , ret =0 , i =0 ;u32 loc =0 ; -unsigned long lval = val; +unsigned long lval, llval = val; stage2:/* 2nd stage: dereference memory if needed */ do { -if (code->op ==FETCH_OP_DEREF ) { - lval = val; + lval = val; +switch (code->op) { +case FETCH_OP_DEREF : ret =probe_mem_read (&val, (void *)val + code->offset,sizeof (val)); - }else if (code->op ==FETCH_OP_UDEREF ) { - lval = val; +break ; +case FETCH_OP_UDEREF : ret =probe_mem_read_user (&val, (void *)val + code->offset,sizeof (val)); - }else break ; +case FETCH_OP_CPU_PTR : + val = (unsigned long )this_cpu_ptr ((void __percpu *)val); + ret =0 ; +break ; +default : + lval = llval; + goto out; + }if (ret)return ret; + llval = lval; code++; }while (1 ); +out: s3 = code; stage3:
Masami Hiramatsu (Google)
maintainerPATCH v9 9/9 tracing/probes: Add a new testcase for BTF typecasts
In reply to Masami Hiramatsu (Google)From: Masami Hiramatsu (Google) <[email protected]>
With the introduction of container_of-style BTF typecasting and per-CPU variable access support in trace probes, we need a way to verify their functionality and prevent regressions.
Add a new ftrace kselftest and update the trace event sample module to test and validate these features.
Specifically, update the trace-events-sample module to set up a periodic timer whose callback accesses a per-CPU counter. Introduce a new sample trace event, foo_timer_fn, to trace this callback and log the current counter value.
Then, add a new test case, btf_probe_event.tc, which defines a dynamic probe on the timer callback. The probe uses BTF typecasting to recover the parent structure from the timer argument and this_cpu_read() to fetch the per-CPU counter. The test verifies the integrity of the implementation by ensuring the values recorded by the dynamic probe match those from the static tracepoint.
---
Changes in v9:
- Add a testcase for checking new syntax.
Changes in v8:
- Add more test cases.
Changes in v6:
- Update testcase according to changes.
Changes in v5:
- Add more syntax test cases.
Changes in v4:
- Fix uprobe $current test.
Changes in v3:
- Add syntax test case.
- Update testcase to use this_cpu_read()
Changes in v2:
- Use timer_shutdown_sync() instead of timer_delete_sync() for teardown.
--- samples/trace_events/trace-events-sample.c | 40 +++++++ samples/trace_events/trace-events-sample.h | 34 ++++++ .../ftrace/test.d/dynevent/btf_probe_event.tc | 51 ++++++++++ .../test.d/dynevent/btf_typecast_accepted.tc | 107 ++++++++++++++++++++ .../test.d/dynevent/eprobes_syntax_errors.tc | 3 + .../ftrace/test.d/dynevent/fprobe_syntax_errors.tc | 12 ++ .../ftrace/test.d/kprobe/kprobe_syntax_errors.tc | 12 ++ .../ftrace/test.d/kprobe/uprobe_syntax_errors.tc | 5 + 8 files changed, 259 insertions(+), 5 deletions(-) create mode 100644 tools/testing/selftests/ftrace/test.d/dynevent/btf_probe_event.tc create mode 100644 tools/testing/selftests/ftrace/test.d/dynevent/btf_typecast_accepted.tc
samples/trace_events/trace-events-sample.c +38 -2
@@ -94,6 +94,20 @@ static int simple_thread_fn(void *arg)static DEFINE_MUTEX (thread_mutex);static int simple_thread_cnt; +static struct foo_timer_data *foo_timer_data; + +static void sample_timer_cb (struct timer_list *t) +{ + struct foo_timer_data *data = container_of(t, struct foo_timer_data, timer); + +get_cpu (); +trace_foo_timer_fn (data); + (*this_cpu_ptr (data->counter))++; +put_cpu (); + +mod_timer (t, jiffies +HZ ); +} +int foo_bar_reg (void ) {mutex_lock (&thread_mutex);
@@ -132,9 +146,27 @@ void foo_bar_unreg(void)static int __init trace_event_init (void ) { + foo_timer_data =kzalloc_obj (*foo_timer_data,GFP_KERNEL ); +if (!foo_timer_data) +return -ENOMEM ; + + foo_timer_data->name ="sample_timer_counter" ; + foo_timer_data->counter =alloc_percpu (int); +if (!foo_timer_data->counter) { +kfree (foo_timer_data); +return -ENOMEM ; + } + +timer_setup (&foo_timer_data->timer, sample_timer_cb,0 ); +mod_timer (&foo_timer_data->timer, jiffies +HZ ); + simple_tsk =kthread_run (simple_thread,NULL ,"event-sample" ); -if (IS_ERR (simple_tsk)) -return -1 ; +if (IS_ERR (simple_tsk)) { +timer_shutdown_sync (&foo_timer_data->timer); +free_percpu (foo_timer_data->counter); +kfree (foo_timer_data); +return PTR_ERR (simple_tsk); + }return 0 ; }
@@ -147,6 +179,10 @@ static void __exit trace_event_exit(void)kthread_stop (simple_tsk_fn); simple_tsk_fn =NULL ;mutex_unlock (&thread_mutex); + +timer_shutdown_sync (&foo_timer_data->timer); +free_percpu (foo_timer_data->counter); +kfree (foo_timer_data); }module_init (trace_event_init);
samples/trace_events/trace-events-sample.h +31 -3
@@ -247,12 +247,14 @@*/ /* -* It is OK to have helper functions in the file, but they need to be protected -* from being defined more than once. Remember, this file gets included more -* than once. +* It is OK to have helper functions and data structures in the file, but they +* need to be protected from being defined more than once. Remember, this file +* gets included more than once. */ #ifndef __TRACE_EVENT_SAMPLE_HELPER_FUNCTIONS#define __TRACE_EVENT_SAMPLE_HELPER_FUNCTIONS +#include <linux/timer.h> +static inline int __length_of (const int *list) {int i;
@@ -270,6 +272,13 @@ enum {TRACE_SAMPLE_BAR =4 , TRACE_SAMPLE_ZOO = 8, }; + +struct foo_timer_data { +const char *name; +struct timer_list timer; +int __percpu *counter; +}; +#endif /*
@@ -595,6 +604,25 @@ TRACE_EVENT(foo_rel_loc,__get_rel_bitmask (bitmask), __get_rel_cpumask(cpumask)) ); + +TRACE_EVENT (foo_timer_fn, + + TP_PROTO(struct foo_timer_data *data), + +TP_ARGS (data), + +TP_STRUCT__entry ( + __string( name, data->name ) +__field ( int, count ) + ), + +TP_fast_assign ( + __assign_str(name); + __entry->count = *this_cpu_ptr(data->counter); + ), + +TP_printk ("name=%s count=%d" ,__get_str (name), __entry->count) +);#endif /***** NOTICE! The #if protection ends here. *****/
tools/testing/selftests/ftrace/test.d/dynevent/btf_probe_event.tc new file +51 -0
51 lines not on this page · raw message
tools/testing/selftests/ftrace/test.d/dynevent/btf_typecast_accepted.tc new file +107 -0
107 lines not on this page · raw message
tools/testing/selftests/ftrace/test.d/dynevent/eprobes_syntax_errors.tc +3 -0
@@ -21,6 +21,9 @@ check_error 'e:foo/^bar.1 syscalls/sys_enter_openat' # BAD_EVENT_NAME check_error 'e:foo/bar syscalls/sys_enter_openat arg=^$foo' # BAD_ATTACH_ARG +check_error 'e:foo/bar syscalls/sys_enter_openat arg=^COMM' # NO_EVENT_FIELD +check_error 'e:foo/bar syscalls/sys_enter_openat arg=^current' # NO_EVENT_FIELD + if grep -q '<attached-group>\.<attached-event>.*\[if <filter>\]' README; then check_error 'e:foo/bar syscalls/sys_enter_openat if ^' # NO_EP_FILTER fi
tools/testing/selftests/ftrace/test.d/dynevent/fprobe_syntax_errors.tc +12 -0
@@ -112,6 +112,18 @@ check_error 'f vfs_read%return $retval->^foo' # NO_PTR_STRCT check_error 'f vfs_read file->^foo' # NO_BTF_FIELD check_error 'f vfs_read file^-.foo' # BAD_HYPHEN check_error 'f vfs_read ^file:string' # BAD_TYPE4STR +if grep -qF "[(structname" README ; then +check_error 'f vfs_read arg1=(task_struct)file^' # TYPECAST_REQ_FIELD +check_error 'f vfs_read arg1=(a)((b)((c)(^(d)file->d)->c)->b)->a' # TOO_MANY_NESTED +check_error 'f vfs_read arg1=(task_struct,^in_execve)file->comm' # TYPECAST_NOT_ALIGNED +check_error 'f vfs_read arg1=(task_struct,^foo_bar)file->pid' # NO_BTF_FIELD +check_error 'f vfs_read arg1=(^task_struct1234)file->pid' # NO_PTR_STRCT +check_error 'f vfs_read arg1=(task_struct,se^->group_node)file->comm' # TYPECAST_BAD_ARROW +check_error 'f vfs_read arg1=(task_struct,^->pid)file->comm' # NO_BTF_FIELD +check_error 'f vfs_read arg1=(task_struct,^.pid)file->comm' # NO_BTF_FIELD +check_error 'f vfs_read arg1=(task_struct,^.)file->comm' # NO_BTF_FIELD +check_error 'f vfs_read arg1=(task_struct)^@symbol+10->comm' # TYPECAST_SYM_OFFSET +fi fi else
tools/testing/selftests/ftrace/test.d/kprobe/kprobe_syntax_errors.tc +12 -0
@@ -115,6 +115,18 @@ check_error 'p vfs_read+20 ^$arg*' # NOFENTRY_ARGS check_error 'p vfs_read ^hoge' # NO_BTFARG check_error 'p kfree ^$arg10' # NO_BTFARG (exceed the number of parameters) check_error 'r kfree ^$retval' # NO_RETVAL +if grep -qF "[(structname" README ; then +check_error 'p vfs_read arg1=(task_struct)file^' # TYPECAST_REQ_FIELD +check_error 'p vfs_read arg1=(a)((b)((c)(^(d)file->d)->c)->b)->a' # TOO_MANY_NESTED +check_error 'p vfs_read arg1=(task_struct,^in_execve)file->comm' # TYPECAST_NOT_ALIGNED +check_error 'p vfs_read arg1=(task_struct,^foo_bar)file->pid' # NO_BTF_FIELD +check_error 'p vfs_read arg1=(^task_struct1234)file->pid' # NO_PTR_STRCT +check_error 'p vfs_read arg1=(task_struct,se^->group_node)file->comm' # TYPECAST_BAD_ARROW +check_error 'p vfs_read arg1=(task_struct,^->pid)file->comm' # NO_BTF_FIELD +check_error 'p vfs_read arg1=(task_struct,^.pid)file->comm' # NO_BTF_FIELD +check_error 'p vfs_read arg1=(task_struct,^.)file->comm' # NO_BTF_FIELD +check_error 'p vfs_read arg1=(task_struct)^@symbol+10->comm' # TYPECAST_SYM_OFFSET +fi else check_error 'p vfs_read ^$arg*' # NOSUP_BTFARG fi
tools/testing/selftests/ftrace/test.d/kprobe/uprobe_syntax_errors.tc +5 -0
@@ -28,4 +28,9 @@ if grep -q ".*symstr.*" README; then check_error 'p /bin/sh:10 $stack0:^symstr' # BAD_TYPE fi +# $current is not supported by uprobe +if grep -q "\$current.*" README; then +check_error 'p /bin/sh:10 ^$current:u8' # BAD_VAR +fi + exit 0