include/linux/trace_events.h | 1 + kernel/trace/trace.h | 3 ++- kernel/trace/trace_events.c | 1 + kernel/trace/trace_events_filter.c | 40 ++++++++++++++++++++++++++++-- 4 files changed, 42 insertions(+), 3 deletions(-)
Low-level functions have many call paths, and sometimes
we only care about the calls on a specific call path.
Add a new filter to filter based on the call stack.
Usage:
1. echo 'caller=="$function_name"' > events/../filter
Only support OP_EQ and OP_NE
Signed-off-by: Chen Jun <chenjun102@huawei.com>
---
include/linux/trace_events.h | 1 +
kernel/trace/trace.h | 3 ++-
kernel/trace/trace_events.c | 1 +
kernel/trace/trace_events_filter.c | 40 ++++++++++++++++++++++++++++--
4 files changed, 42 insertions(+), 3 deletions(-)
diff --git a/include/linux/trace_events.h b/include/linux/trace_events.h
index 40a43a4c7caf..1f109669a391 100644
--- a/include/linux/trace_events.h
+++ b/include/linux/trace_events.h
@@ -851,6 +851,7 @@ enum {
FILTER_COMM,
FILTER_CPU,
FILTER_STACKTRACE,
+ FILTER_CALLER,
};
extern int trace_event_raw_init(struct trace_event_call *call);
diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 80fe152af1dd..4e4b92ce264f 100644
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -1825,7 +1825,8 @@ static inline bool is_string_field(struct ftrace_event_field *field)
field->filter_type == FILTER_RDYN_STRING ||
field->filter_type == FILTER_STATIC_STRING ||
field->filter_type == FILTER_PTR_STRING ||
- field->filter_type == FILTER_COMM;
+ field->filter_type == FILTER_COMM ||
+ field->filter_type == FILTER_CALLER;
}
static inline bool is_function_field(struct ftrace_event_field *field)
diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
index c46e623e7e0d..6d220d7eec73 100644
--- a/kernel/trace/trace_events.c
+++ b/kernel/trace/trace_events.c
@@ -199,6 +199,7 @@ static int trace_define_generic_fields(void)
__generic_field(char *, comm, FILTER_COMM);
__generic_field(char *, stacktrace, FILTER_STACKTRACE);
__generic_field(char *, STACKTRACE, FILTER_STACKTRACE);
+ __generic_field(char *, caller, FILTER_CALLER);
return ret;
}
diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
index 609325f57942..1cf040065abe 100644
--- a/kernel/trace/trace_events_filter.c
+++ b/kernel/trace/trace_events_filter.c
@@ -72,6 +72,7 @@ enum filter_pred_fn {
FILTER_PRED_FN_CPUMASK,
FILTER_PRED_FN_CPUMASK_CPU,
FILTER_PRED_FN_FUNCTION,
+ FILTER_PRED_FN_CALLER,
FILTER_PRED_FN_,
FILTER_PRED_TEST_VISITED,
};
@@ -1009,6 +1010,21 @@ static int filter_pred_function(struct filter_pred *pred, void *event)
return pred->op == OP_EQ ? ret : !ret;
}
+/* Filter predicate for caller. */
+static int filter_pred_caller(struct filter_pred *pred, void *event)
+{
+ unsigned long entries[32];
+ unsigned int nr_entries;
+ int i;
+
+ nr_entries = stack_trace_save(entries, ARRAY_SIZE(entries), 0);
+ for (i = 0; i < nr_entries ; i++)
+ if (pred->val <= entries[i] && entries[i] < pred->val2)
+ return !pred->not;
+
+ return pred->not;
+}
+
/*
* regex_match_foo - Basic regex callbacks
*
@@ -1617,6 +1633,8 @@ static int filter_pred_fn_call(struct filter_pred *pred, void *event)
return filter_pred_cpumask_cpu(pred, event);
case FILTER_PRED_FN_FUNCTION:
return filter_pred_function(pred, event);
+ case FILTER_PRED_FN_CALLER:
+ return filter_pred_caller(pred, event);
case FILTER_PRED_TEST_VISITED:
return test_pred_visited_fn(pred, event);
default:
@@ -2002,10 +2020,28 @@ static int parse_pred(const char *str, void *data,
} else if (field->filter_type == FILTER_DYN_STRING) {
pred->fn_num = FILTER_PRED_FN_STRLOC;
- } else if (field->filter_type == FILTER_RDYN_STRING)
+ } else if (field->filter_type == FILTER_RDYN_STRING) {
pred->fn_num = FILTER_PRED_FN_STRRELLOC;
- else {
+ } else if (field->filter_type == FILTER_CALLER) {
+ unsigned long caller;
+
+ if (op == OP_GLOB)
+ goto err_free;
+ pred->fn_num = FILTER_PRED_FN_CALLER;
+ caller = kallsyms_lookup_name(pred->regex->pattern);
+ if (!caller) {
+ parse_error(pe, FILT_ERR_NO_FUNCTION, pos + i);
+ goto err_free;
+ }
+ /* Now find the function start and end address */
+ if (!kallsyms_lookup_size_offset(caller, &size, &offset)) {
+ parse_error(pe, FILT_ERR_NO_FUNCTION, pos + i);
+ goto err_free;
+ }
+ pred->val = caller - offset;
+ pred->val2 = pred->val + size;
+ } else {
if (!ustring_per_cpu) {
/* Once allocated, keep it around for good */
ustring_per_cpu = alloc_percpu(struct ustring_buffer);
--
2.22.0On Fri, 8 May 2026 20:26:23 +0800
Chen Jun <chenjun102@huawei.com> wrote:
> Low-level functions have many call paths, and sometimes
> we only care about the calls on a specific call path.
> Add a new filter to filter based on the call stack.
>
> Usage:
> 1. echo 'caller=="$function_name"' > events/../filter
>
> Only support OP_EQ and OP_NE
Cute.
>
> Signed-off-by: Chen Jun <chenjun102@huawei.com>
> ---
> include/linux/trace_events.h | 1 +
> kernel/trace/trace.h | 3 ++-
> kernel/trace/trace_events.c | 1 +
> kernel/trace/trace_events_filter.c | 40 ++++++++++++++++++++++++++++--
> 4 files changed, 42 insertions(+), 3 deletions(-)
>
> diff --git a/include/linux/trace_events.h b/include/linux/trace_events.h
> index 40a43a4c7caf..1f109669a391 100644
> --- a/include/linux/trace_events.h
> +++ b/include/linux/trace_events.h
> @@ -851,6 +851,7 @@ enum {
> FILTER_COMM,
> FILTER_CPU,
> FILTER_STACKTRACE,
> + FILTER_CALLER,
> };
>
> extern int trace_event_raw_init(struct trace_event_call *call);
> diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
> index 80fe152af1dd..4e4b92ce264f 100644
> --- a/kernel/trace/trace.h
> +++ b/kernel/trace/trace.h
> @@ -1825,7 +1825,8 @@ static inline bool is_string_field(struct ftrace_event_field *field)
> field->filter_type == FILTER_RDYN_STRING ||
> field->filter_type == FILTER_STATIC_STRING ||
> field->filter_type == FILTER_PTR_STRING ||
> - field->filter_type == FILTER_COMM;
> + field->filter_type == FILTER_COMM ||
> + field->filter_type == FILTER_CALLER;
> }
>
> static inline bool is_function_field(struct ftrace_event_field *field)
> diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
> index c46e623e7e0d..6d220d7eec73 100644
> --- a/kernel/trace/trace_events.c
> +++ b/kernel/trace/trace_events.c
> @@ -199,6 +199,7 @@ static int trace_define_generic_fields(void)
> __generic_field(char *, comm, FILTER_COMM);
> __generic_field(char *, stacktrace, FILTER_STACKTRACE);
> __generic_field(char *, STACKTRACE, FILTER_STACKTRACE);
> + __generic_field(char *, caller, FILTER_CALLER);
>
> return ret;
> }
> diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
> index 609325f57942..1cf040065abe 100644
> --- a/kernel/trace/trace_events_filter.c
> +++ b/kernel/trace/trace_events_filter.c
> @@ -72,6 +72,7 @@ enum filter_pred_fn {
> FILTER_PRED_FN_CPUMASK,
> FILTER_PRED_FN_CPUMASK_CPU,
> FILTER_PRED_FN_FUNCTION,
> + FILTER_PRED_FN_CALLER,
> FILTER_PRED_FN_,
> FILTER_PRED_TEST_VISITED,
> };
> @@ -1009,6 +1010,21 @@ static int filter_pred_function(struct filter_pred *pred, void *event)
> return pred->op == OP_EQ ? ret : !ret;
> }
>
> +/* Filter predicate for caller. */
> +static int filter_pred_caller(struct filter_pred *pred, void *event)
> +{
> + unsigned long entries[32];
Let's make that only 16 in size. Having 256 bytes added to the stack in
random places may cause an overflow. 128 bytes isn't as bad. Either that,
or we need to preallocate per-cpu memory and use that. But that makes the
patch much more complex. I rather just use 16 entries instead for now. If
we need more, then we can add the extra complexity.
Also, you need to update Documentation/trace/events.rst.
Thanks,
-- Steve
> + unsigned int nr_entries;
> + int i;
> +
> + nr_entries = stack_trace_save(entries, ARRAY_SIZE(entries), 0);
> + for (i = 0; i < nr_entries ; i++)
> + if (pred->val <= entries[i] && entries[i] < pred->val2)
> + return !pred->not;
> +
> + return pred->not;
> +}
> +
> /*
> * regex_match_foo - Basic regex callbacks
> *
> @@ -1617,6 +1633,8 @@ static int filter_pred_fn_call(struct filter_pred *pred, void *event)
> return filter_pred_cpumask_cpu(pred, event);
> case FILTER_PRED_FN_FUNCTION:
> return filter_pred_function(pred, event);
> + case FILTER_PRED_FN_CALLER:
> + return filter_pred_caller(pred, event);
> case FILTER_PRED_TEST_VISITED:
> return test_pred_visited_fn(pred, event);
> default:
> @@ -2002,10 +2020,28 @@ static int parse_pred(const char *str, void *data,
>
> } else if (field->filter_type == FILTER_DYN_STRING) {
> pred->fn_num = FILTER_PRED_FN_STRLOC;
> - } else if (field->filter_type == FILTER_RDYN_STRING)
> + } else if (field->filter_type == FILTER_RDYN_STRING) {
> pred->fn_num = FILTER_PRED_FN_STRRELLOC;
> - else {
> + } else if (field->filter_type == FILTER_CALLER) {
> + unsigned long caller;
> +
> + if (op == OP_GLOB)
> + goto err_free;
>
> + pred->fn_num = FILTER_PRED_FN_CALLER;
> + caller = kallsyms_lookup_name(pred->regex->pattern);
> + if (!caller) {
> + parse_error(pe, FILT_ERR_NO_FUNCTION, pos + i);
> + goto err_free;
> + }
> + /* Now find the function start and end address */
> + if (!kallsyms_lookup_size_offset(caller, &size, &offset)) {
> + parse_error(pe, FILT_ERR_NO_FUNCTION, pos + i);
> + goto err_free;
> + }
> + pred->val = caller - offset;
> + pred->val2 = pred->val + size;
> + } else {
> if (!ustring_per_cpu) {
> /* Once allocated, keep it around for good */
> ustring_per_cpu = alloc_percpu(struct ustring_buffer);
On Fri, 8 May 2026 20:26:23 +0800
Chen Jun <chenjun102@huawei.com> wrote:
> Low-level functions have many call paths, and sometimes
> we only care about the calls on a specific call path.
> Add a new filter to filter based on the call stack.
>
> Usage:
> 1. echo 'caller=="$function_name"' > events/../filter
Thanks for interesting idea :)
BTW, we already have "stacktrace". Since this actually checks
stacktrace, not caller, so I think we should reuse it.
Also, I think OP_GLOB is more suitable for this case.
(and more useful)
Thank you,
>
> Only support OP_EQ and OP_NE
>
> Signed-off-by: Chen Jun <chenjun102@huawei.com>
> ---
> include/linux/trace_events.h | 1 +
> kernel/trace/trace.h | 3 ++-
> kernel/trace/trace_events.c | 1 +
> kernel/trace/trace_events_filter.c | 40 ++++++++++++++++++++++++++++--
> 4 files changed, 42 insertions(+), 3 deletions(-)
>
> diff --git a/include/linux/trace_events.h b/include/linux/trace_events.h
> index 40a43a4c7caf..1f109669a391 100644
> --- a/include/linux/trace_events.h
> +++ b/include/linux/trace_events.h
> @@ -851,6 +851,7 @@ enum {
> FILTER_COMM,
> FILTER_CPU,
> FILTER_STACKTRACE,
> + FILTER_CALLER,
> };
>
> extern int trace_event_raw_init(struct trace_event_call *call);
> diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
> index 80fe152af1dd..4e4b92ce264f 100644
> --- a/kernel/trace/trace.h
> +++ b/kernel/trace/trace.h
> @@ -1825,7 +1825,8 @@ static inline bool is_string_field(struct ftrace_event_field *field)
> field->filter_type == FILTER_RDYN_STRING ||
> field->filter_type == FILTER_STATIC_STRING ||
> field->filter_type == FILTER_PTR_STRING ||
> - field->filter_type == FILTER_COMM;
> + field->filter_type == FILTER_COMM ||
> + field->filter_type == FILTER_CALLER;
> }
>
> static inline bool is_function_field(struct ftrace_event_field *field)
> diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c
> index c46e623e7e0d..6d220d7eec73 100644
> --- a/kernel/trace/trace_events.c
> +++ b/kernel/trace/trace_events.c
> @@ -199,6 +199,7 @@ static int trace_define_generic_fields(void)
> __generic_field(char *, comm, FILTER_COMM);
> __generic_field(char *, stacktrace, FILTER_STACKTRACE);
> __generic_field(char *, STACKTRACE, FILTER_STACKTRACE);
> + __generic_field(char *, caller, FILTER_CALLER);
>
> return ret;
> }
> diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events_filter.c
> index 609325f57942..1cf040065abe 100644
> --- a/kernel/trace/trace_events_filter.c
> +++ b/kernel/trace/trace_events_filter.c
> @@ -72,6 +72,7 @@ enum filter_pred_fn {
> FILTER_PRED_FN_CPUMASK,
> FILTER_PRED_FN_CPUMASK_CPU,
> FILTER_PRED_FN_FUNCTION,
> + FILTER_PRED_FN_CALLER,
> FILTER_PRED_FN_,
> FILTER_PRED_TEST_VISITED,
> };
> @@ -1009,6 +1010,21 @@ static int filter_pred_function(struct filter_pred *pred, void *event)
> return pred->op == OP_EQ ? ret : !ret;
> }
>
> +/* Filter predicate for caller. */
> +static int filter_pred_caller(struct filter_pred *pred, void *event)
> +{
> + unsigned long entries[32];
> + unsigned int nr_entries;
> + int i;
> +
> + nr_entries = stack_trace_save(entries, ARRAY_SIZE(entries), 0);
> + for (i = 0; i < nr_entries ; i++)
> + if (pred->val <= entries[i] && entries[i] < pred->val2)
> + return !pred->not;
> +
> + return pred->not;
> +}
> +
> /*
> * regex_match_foo - Basic regex callbacks
> *
> @@ -1617,6 +1633,8 @@ static int filter_pred_fn_call(struct filter_pred *pred, void *event)
> return filter_pred_cpumask_cpu(pred, event);
> case FILTER_PRED_FN_FUNCTION:
> return filter_pred_function(pred, event);
> + case FILTER_PRED_FN_CALLER:
> + return filter_pred_caller(pred, event);
> case FILTER_PRED_TEST_VISITED:
> return test_pred_visited_fn(pred, event);
> default:
> @@ -2002,10 +2020,28 @@ static int parse_pred(const char *str, void *data,
>
> } else if (field->filter_type == FILTER_DYN_STRING) {
> pred->fn_num = FILTER_PRED_FN_STRLOC;
> - } else if (field->filter_type == FILTER_RDYN_STRING)
> + } else if (field->filter_type == FILTER_RDYN_STRING) {
> pred->fn_num = FILTER_PRED_FN_STRRELLOC;
> - else {
> + } else if (field->filter_type == FILTER_CALLER) {
> + unsigned long caller;
> +
> + if (op == OP_GLOB)
> + goto err_free;
>
> + pred->fn_num = FILTER_PRED_FN_CALLER;
> + caller = kallsyms_lookup_name(pred->regex->pattern);
> + if (!caller) {
> + parse_error(pe, FILT_ERR_NO_FUNCTION, pos + i);
> + goto err_free;
> + }
> + /* Now find the function start and end address */
> + if (!kallsyms_lookup_size_offset(caller, &size, &offset)) {
> + parse_error(pe, FILT_ERR_NO_FUNCTION, pos + i);
> + goto err_free;
> + }
> + pred->val = caller - offset;
> + pred->val2 = pred->val + size;
> + } else {
> if (!ustring_per_cpu) {
> /* Once allocated, keep it around for good */
> ustring_per_cpu = alloc_percpu(struct ustring_buffer);
> --
> 2.22.0
>
--
Masami Hiramatsu (Google) <mhiramat@kernel.org>
On Tue, 12 May 2026 08:47:50 +0900 Masami Hiramatsu (Google) <mhiramat@kernel.org> wrote: > On Fri, 8 May 2026 20:26:23 +0800 > Chen Jun <chenjun102@huawei.com> wrote: > > > Low-level functions have many call paths, and sometimes > > we only care about the calls on a specific call path. > > Add a new filter to filter based on the call stack. > > > > Usage: > > 1. echo 'caller=="$function_name"' > events/../filter > > Thanks for interesting idea :) > > BTW, we already have "stacktrace". Since this actually checks > stacktrace, not caller, so I think we should reuse it. > Also, I think OP_GLOB is more suitable for this case. > (and more useful) Actually, it's not a stack trace, it's a function that is called from other functions. But since "caller" sounds like a direct called function (stack trace of the first instance), I think perhaps it should be "called_within" or something similar. :-/ Also, OP_GLOB can't work because it only works for a single function. At the time of parsing, it finds the function (and should probably error out if there's more than one function with a given name). It then records the start and end address of the function so it only needs to find if one of the entries in the stack trace is between the start and end of the function. I don't think this is possible with GLOB. We don't want to do a search of the functions when the event is triggered. -- Steve
On Wed, 13 May 2026 12:40:17 -0400 Steven Rostedt <rostedt@goodmis.org> wrote: > On Tue, 12 May 2026 08:47:50 +0900 > Masami Hiramatsu (Google) <mhiramat@kernel.org> wrote: > > > On Fri, 8 May 2026 20:26:23 +0800 > > Chen Jun <chenjun102@huawei.com> wrote: > > > > > Low-level functions have many call paths, and sometimes > > > we only care about the calls on a specific call path. > > > Add a new filter to filter based on the call stack. > > > > > > Usage: > > > 1. echo 'caller=="$function_name"' > events/../filter > > > > Thanks for interesting idea :) > > > > BTW, we already have "stacktrace". Since this actually checks > > stacktrace, not caller, so I think we should reuse it. > > Also, I think OP_GLOB is more suitable for this case. > > (and more useful) > > Actually, it's not a stack trace, it's a function that is called from other > functions. But since "caller" sounds like a direct called function (stack > trace of the first instance), I think perhaps it should be "called_within" or > something similar. :-/ Yeah, what about "callers"? > > Also, OP_GLOB can't work because it only works for a single function. At > the time of parsing, it finds the function (and should probably error out > if there's more than one function with a given name). It then records the > start and end address of the function so it only needs to find if one of > the entries in the stack trace is between the start and end of the function. Ah, OK. It is just comparing address, not name. > > I don't think this is possible with GLOB. We don't want to do a search of > the functions when the event is triggered. Agreed. Thanks, > > -- Steve -- Masami Hiramatsu (Google) <mhiramat@kernel.org>
Hi Chen, Do you plan on sending updates to address the comments that Masami and I have made? -- Steve On Thu, 14 May 2026 13:19:01 +0900 Masami Hiramatsu (Google) <mhiramat@kernel.org> wrote: > On Wed, 13 May 2026 12:40:17 -0400 > Steven Rostedt <rostedt@goodmis.org> wrote: > > > On Tue, 12 May 2026 08:47:50 +0900 > > Masami Hiramatsu (Google) <mhiramat@kernel.org> wrote: > > > > > On Fri, 8 May 2026 20:26:23 +0800 > > > Chen Jun <chenjun102@huawei.com> wrote: > > > > > > > Low-level functions have many call paths, and sometimes > > > > we only care about the calls on a specific call path. > > > > Add a new filter to filter based on the call stack. > > > > > > > > Usage: > > > > 1. echo 'caller=="$function_name"' > events/../filter > > > > > > Thanks for interesting idea :) > > > > > > BTW, we already have "stacktrace". Since this actually checks > > > stacktrace, not caller, so I think we should reuse it. > > > Also, I think OP_GLOB is more suitable for this case. > > > (and more useful) > > > > Actually, it's not a stack trace, it's a function that is called from other > > functions. But since "caller" sounds like a direct called function (stack > > trace of the first instance), I think perhaps it should be "called_within" or > > something similar. :-/ > > Yeah, what about "callers"? > > > > > Also, OP_GLOB can't work because it only works for a single function. At > > the time of parsing, it finds the function (and should probably error out > > if there's more than one function with a given name). It then records the > > start and end address of the function so it only needs to find if one of > > the entries in the stack trace is between the start and end of the function. > > Ah, OK. It is just comparing address, not name. > > > > > I don't think this is possible with GLOB. We don't want to do a search of > > the functions when the event is triggered. > > Agreed. > > Thanks, > > > > > -- Steve > >
在 2026/5/29 22:38, Steven Rostedt 写道: > > Hi Chen, > > Do you plan on sending updates to address the comments that Masami and > I have made? > > -- Steve Hi， Sorry, I've been busy with other things lately. I'll release the patch v2 next week. One thing I'd like to confirm is whether to use `called_within` as the filter name. Thanks -- Chen Jun > > > On Thu, 14 May 2026 13:19:01 +0900 > Masami Hiramatsu (Google) <mhiramat@kernel.org> wrote: > >> On Wed, 13 May 2026 12:40:17 -0400 >> Steven Rostedt <rostedt@goodmis.org> wrote: >> >>> On Tue, 12 May 2026 08:47:50 +0900 >>> Masami Hiramatsu (Google) <mhiramat@kernel.org> wrote: >>> >>>> On Fri, 8 May 2026 20:26:23 +0800 >>>> Chen Jun <chenjun102@huawei.com> wrote: >>>> >>>>> Low-level functions have many call paths, and sometimes >>>>> we only care about the calls on a specific call path. >>>>> Add a new filter to filter based on the call stack. >>>>> >>>>> Usage: >>>>> 1. echo 'caller=="$function_name"' > events/../filter >>>> >>>> Thanks for interesting idea :) >>>> >>>> BTW, we already have "stacktrace". Since this actually checks >>>> stacktrace, not caller, so I think we should reuse it. >>>> Also, I think OP_GLOB is more suitable for this case. >>>> (and more useful) >>> >>> Actually, it's not a stack trace, it's a function that is called from other >>> functions. But since "caller" sounds like a direct called function (stack >>> trace of the first instance), I think perhaps it should be "called_within" or >>> something similar. :-/ >> >> Yeah, what about "callers"? >> >>> >>> Also, OP_GLOB can't work because it only works for a single function. At >>> the time of parsing, it finds the function (and should probably error out >>> if there's more than one function with a given name). It then records the >>> start and end address of the function so it only needs to find if one of >>> the entries in the stack trace is between the start and end of the function. >> >> Ah, OK. It is just comparing address, not name. >> >>> >>> I don't think this is possible with GLOB. We don't want to do a search of >>> the functions when the event is triggered. >> >> Agreed. >> >> Thanks, >> >>> >>> -- Steve >> >> > > >
On Sat, 30 May 2026 10:46:35 +0000 "chenjun (AM)" <chenjun102@huawei.com> wrote: > > Hi Chen, > > > > Do you plan on sending updates to address the comments that Masami and > > I have made? > > > > -- Steve > > Hi， > > Sorry, I've been busy with other things lately. I'll release the patch > v2 next week. > > One thing I'd like to confirm is whether to use `called_within` as the > filter name. I was talking with my wife about this (who isn't technical at all, but wanted to get her thoughts on terminology) and we came up with simply using "within". That is, we want the event to trigger if it is called "within" a function. Hence, if you use: echo 'within=="$function_name"' > events/../filter I think it's pretty obvious to what it means. Thanks, -- Steve
© 2016 - 2026 Red Hat, Inc.