From nobody Sun Apr 26 12:18:17 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 3B760C433EF for ; Tue, 28 Jun 2022 14:56:39 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1347520AbiF1O4h (ORCPT ); Tue, 28 Jun 2022 10:56:37 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34378 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1347507AbiF1O4c (ORCPT ); Tue, 28 Jun 2022 10:56:32 -0400 Received: from mail-pj1-x102c.google.com (mail-pj1-x102c.google.com [IPv6:2607:f8b0:4864:20::102c]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7090F31904 for ; Tue, 28 Jun 2022 07:56:30 -0700 (PDT) Received: by mail-pj1-x102c.google.com with SMTP id h9-20020a17090a648900b001ecb8596e43so12908631pjj.5 for ; Tue, 28 Jun 2022 07:56:30 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=AYpCfkimhU2KJvCb6UeI6/1YJCXd4C14utLIgevMLmY=; b=cl3Gwv7F3vCULOLwJDh1kPM6R782xpotv9TZqBJ8c3EQNzk71rJW7E0UZFN0eovH0b vAVhYo/Iifn/msX2QFeGV6KoEhCnTjdpvxm72T9M/VG3fGrzOGTnj0sLJkUhjWnu5o2Z HfDT+l5FfuYfqOz2C3G+v+7qPXetPsUP93j4s28B+thZhxYqS7NN3iNbfUmosZ5n7mu/ Sw0/abTFsdWitKIfbXdoEtaPBwKy7RtZVUn6lvTPW28gmSsyg5vXnzhOeZKws/PPCNHM 6NbNJKFkfT+LMX0EUcUuyH0vWnWPJWTskSBxszgJxqzcvViGdBUhr1+NRmHGy7eXcp35 BRhQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=AYpCfkimhU2KJvCb6UeI6/1YJCXd4C14utLIgevMLmY=; b=fE8OdT/I/BC8Se6FWx1hgya5kNjdBnO/p2BjGezpCq6G+IHTbzSAfPZ0wSvG8ZOEJn UEY4dBsI/ZWDZ4vvhOoda3ndv5GnvmLyO8fLhikHEab4p5q/8FlumwgOdmObGrzMT4Fg VqY8AJUd/jRw3dAIuIWnubyd43HKBGeR4X+Bry5wBWKtvsK1uC6UqCLcNNF/Qzql/cea 8mAYRAYzjHM8So3B1JD+dOgKumua3hx34Nmxq/YdMMnv1HwLUdragzL2E5fyn7Dm9kJS f9JRjuU4MjKqjg0ex1WfgeTPnZBRYSOgyLuZpLbwQPOyp9dciIMCWLpCaa4LPbDVwEEK LuAw== X-Gm-Message-State: AJIora9TBL3j/4RZ727wiCHlS4MxNPUWfBLH2ZIPcrJ388SDxXDeh9ow miC2Bh/14OrB8mSIT+WXWiM= X-Google-Smtp-Source: AGRyM1v1dedYcIkcWllhCqQ+Y55t+1VWiZkDq3d2hxa7fIJVDqOPbaozOhPJFRQk1Toi6wz4NNMxeA== X-Received: by 2002:a17:902:e80a:b0:16a:311a:a672 with SMTP id u10-20020a170902e80a00b0016a311aa672mr5219248plg.161.1656428189764; Tue, 28 Jun 2022 07:56:29 -0700 (PDT) Received: from localhost.localdomain (li567-56.members.linode.com. [192.155.81.56]) by smtp.gmail.com with ESMTPSA id u17-20020a17090341d100b0016909678e2csm9502549ple.292.2022.06.28.07.56.26 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 28 Jun 2022 07:56:29 -0700 (PDT) From: Jeff Xie To: rostedt@goodmis.org Cc: mingo@redhat.com, mhiramat@kernel.org, zanussi@kernel.org, linux-kernel@vger.kernel.org, chensong_2000@189.cn, Jeff Xie Subject: [PATCH v14 1/4] trace: Add trace any kernel object Date: Tue, 28 Jun 2022 22:55:49 +0800 Message-Id: <20220628145552.349839-2-xiehuan09@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220628145552.349839-1-xiehuan09@gmail.com> References: <20220628145552.349839-1-xiehuan09@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Introduce objtrace trigger to get the call flow by tracing any kernel object in the function parameter. The objtrace trigger makes a list of the target object address from the given event parameter, and records all kernel function calls which has the object address in its parameter. Syntax: objtrace:add:obj[:count][if ] Usage: # echo 'p bio_add_page arg1=3D$arg1' > kprobe_events # cd events/kprobes/p_bio_add_page_0 # echo 'objtrace:add:arg1:1 if comm =3D=3D "cat"' > ./trigger # cat /test.txt Signed-off-by: Jeff Xie Acked-by: Masami Hiramatsu (Google) --- include/linux/trace_events.h | 1 + kernel/trace/Kconfig | 10 + kernel/trace/Makefile | 1 + kernel/trace/trace.c | 11 + kernel/trace/trace.h | 21 ++ kernel/trace/trace_entries.h | 17 ++ kernel/trace/trace_events_trigger.c | 5 +- kernel/trace/trace_object.c | 450 ++++++++++++++++++++++++++++ kernel/trace/trace_output.c | 40 +++ 9 files changed, 554 insertions(+), 2 deletions(-) create mode 100644 kernel/trace/trace_object.c diff --git a/include/linux/trace_events.h b/include/linux/trace_events.h index e6e95a9f07a5..f3645166b724 100644 --- a/include/linux/trace_events.h +++ b/include/linux/trace_events.h @@ -693,6 +693,7 @@ enum event_trigger_type { ETT_EVENT_HIST =3D (1 << 4), ETT_HIST_ENABLE =3D (1 << 5), ETT_EVENT_EPROBE =3D (1 << 6), + ETT_TRACE_OBJECT =3D (1 << 7), }; =20 extern int filter_match_preds(struct event_filter *filter, void *rec); diff --git a/kernel/trace/Kconfig b/kernel/trace/Kconfig index 2c43e327a619..30c34d43dc3f 100644 --- a/kernel/trace/Kconfig +++ b/kernel/trace/Kconfig @@ -276,6 +276,16 @@ config FUNCTION_PROFILER =20 If in doubt, say N. =20 +config TRACE_OBJECT + bool "Trace kernel object in function parameter" + depends on FUNCTION_TRACER + depends on HAVE_FUNCTION_ARG_ACCESS_API + select TRACING + default y + help + You can trace the kernel object in the kernel function parameter. + The kernel object is dynamically specified via event trigger. + config STACK_TRACER bool "Trace max stack" depends on HAVE_FUNCTION_TRACER diff --git a/kernel/trace/Makefile b/kernel/trace/Makefile index 0d261774d6f3..90ecc3c6c9d5 100644 --- a/kernel/trace/Makefile +++ b/kernel/trace/Makefile @@ -71,6 +71,7 @@ obj-$(CONFIG_FUNCTION_GRAPH_TRACER) +=3D trace_functions_= graph.o obj-$(CONFIG_TRACE_BRANCH_PROFILING) +=3D trace_branch.o obj-$(CONFIG_BLK_DEV_IO_TRACE) +=3D blktrace.o obj-$(CONFIG_FUNCTION_GRAPH_TRACER) +=3D fgraph.o +obj-$(CONFIG_TRACE_OBJECT) +=3D trace_object.o ifeq ($(CONFIG_BLOCK),y) obj-$(CONFIG_EVENT_TRACING) +=3D blktrace.o endif diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c index f400800bc910..7074ad8bc1a0 100644 --- a/kernel/trace/trace.c +++ b/kernel/trace/trace.c @@ -5627,6 +5627,9 @@ static const char readme_msg[] =3D "\t enable_hist::\n" "\t disable_hist::\n" #endif +#ifdef CONFIG_TRACE_OBJECT + "\t objtrace:add:obj[:count][if ]\n" +#endif #ifdef CONFIG_STACKTRACE "\t\t stacktrace\n" #endif @@ -9272,6 +9275,9 @@ static struct trace_array *trace_array_create(const c= har *name) if (ftrace_allocate_ftrace_ops(tr) < 0) goto out_free_tr; =20 + if (allocate_objtrace_data(tr) < 0) + goto out_free_tr; + ftrace_init_trace_array(tr); =20 init_trace_flags_index(tr); @@ -9291,6 +9297,7 @@ static struct trace_array *trace_array_create(const c= har *name) =20 out_free_tr: ftrace_free_ftrace_ops(tr); + free_objtrace_data(tr); free_trace_buffers(tr); free_cpumask_var(tr->tracing_cpumask); kfree(tr->name); @@ -9384,6 +9391,7 @@ static int __remove_instance(struct trace_array *tr) event_trace_del_tracer(tr); ftrace_clear_pids(tr); ftrace_destroy_function_files(tr); + free_objtrace_data(tr); tracefs_remove(tr->dir); free_percpu(tr->last_func_repeats); free_trace_buffers(tr); @@ -10118,6 +10126,9 @@ __init static int tracer_alloc_buffers(void) goto out_free_savedcmd; } =20 + if (allocate_objtrace_data(&global_trace)) + goto out_free_savedcmd; + if (global_trace.buffer_disabled) tracing_off(); =20 diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index ff816fb41e48..18220b659555 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -54,6 +54,7 @@ enum trace_type { TRACE_TIMERLAT, TRACE_RAW_DATA, TRACE_FUNC_REPEATS, + TRACE_OBJECT, =20 __TRACE_LAST_TYPE, }; @@ -363,6 +364,9 @@ struct trace_array { cpumask_var_t tracing_cpumask; /* only trace on set CPUs */ int ref; int trace_ref; +#ifdef CONFIG_TRACE_OBJECT + struct objtrace_data *obj_data; +#endif #ifdef CONFIG_FUNCTION_TRACER struct ftrace_ops *ops; struct trace_pid_list __rcu *function_pids; @@ -471,6 +475,7 @@ extern void __ftrace_bad_type(void); TRACE_GRAPH_RET); \ IF_ASSIGN(var, ent, struct func_repeats_entry, \ TRACE_FUNC_REPEATS); \ + IF_ASSIGN(var, ent, struct trace_object_entry, TRACE_OBJECT);\ __ftrace_bad_type(); \ } while (0) =20 @@ -1536,6 +1541,16 @@ static inline int register_trigger_hist_cmd(void) { = return 0; } static inline int register_trigger_hist_enable_disable_cmds(void) { return= 0; } #endif =20 +#ifdef CONFIG_TRACE_OBJECT +extern int register_trigger_object_cmd(void); +extern int allocate_objtrace_data(struct trace_array *tr); +extern void free_objtrace_data(struct trace_array *tr); +#else +static inline int register_trigger_object_cmd(void) { return 0; } +static inline int allocate_objtrace_data(struct trace_array *tr) { return = 0; } +static inline void free_objtrace_data(struct trace_array *tr) { }; +#endif + extern int register_trigger_cmds(void); extern void clear_event_triggers(struct trace_array *tr); =20 @@ -1611,6 +1626,12 @@ extern bool event_trigger_check_remove(const char *g= lob); extern bool event_trigger_empty_param(const char *param); extern int event_trigger_separate_filter(char *param_and_filter, char **pa= ram, char **filter, bool param_required); +extern int register_trigger(char *glob, + struct event_trigger_data *data, + struct trace_event_file *file); +extern void unregister_trigger(char *glob, + struct event_trigger_data *test, + struct trace_event_file *file); extern struct event_trigger_data * event_trigger_alloc(struct event_command *cmd_ops, char *cmd, diff --git a/kernel/trace/trace_entries.h b/kernel/trace/trace_entries.h index cd41e863b51c..bb120d9498a9 100644 --- a/kernel/trace/trace_entries.h +++ b/kernel/trace/trace_entries.h @@ -401,3 +401,20 @@ FTRACE_ENTRY(timerlat, timerlat_entry, __entry->context, __entry->timer_latency) ); + +/* + * trace object entry: + */ +FTRACE_ENTRY(object, trace_object_entry, + + TRACE_OBJECT, + + F_STRUCT( + __field( unsigned long, ip ) + __field( unsigned long, parent_ip ) + __field( unsigned long, object ) + ), + + F_printk(" %ps <-- %ps object:%lx\n", + (void *)__entry->ip, (void *)__entry->parent_ip, __entry->object) +); diff --git a/kernel/trace/trace_events_trigger.c b/kernel/trace/trace_event= s_trigger.c index cb866c3141af..8bad4eb3b997 100644 --- a/kernel/trace/trace_events_trigger.c +++ b/kernel/trace/trace_events_trigger.c @@ -560,7 +560,7 @@ void update_cond_flag(struct trace_event_file *file) * * Return: 0 on success, errno otherwise */ -static int register_trigger(char *glob, +int register_trigger(char *glob, struct event_trigger_data *data, struct trace_event_file *file) { @@ -605,7 +605,7 @@ static int register_trigger(char *glob, * Usually used directly as the @unreg method in event command * implementations. */ -static void unregister_trigger(char *glob, +void unregister_trigger(char *glob, struct event_trigger_data *test, struct trace_event_file *file) { @@ -1976,6 +1976,7 @@ __init int register_trigger_cmds(void) register_trigger_enable_disable_cmds(); register_trigger_hist_enable_disable_cmds(); register_trigger_hist_cmd(); + register_trigger_object_cmd(); =20 return 0; } diff --git a/kernel/trace/trace_object.c b/kernel/trace/trace_object.c new file mode 100644 index 000000000000..19ec4b1c0186 --- /dev/null +++ b/kernel/trace/trace_object.c @@ -0,0 +1,450 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * trace the kernel object in the kernel function parameter + * Copyright (C) 2021 Jeff Xie + */ + +#define pr_fmt(fmt) "trace_object: " fmt + +#include "trace_output.h" + +#define MAX_TRACED_OBJECT 5 +#define OBJTRACE_CMD_LEN 16 +#define OBJTRACE_CMD_ADD "add" +static LIST_HEAD(obj_data_head); +static const int max_args_num =3D 6; +static void exit_trace_object(struct trace_array *tr); +static int init_trace_object(struct trace_array *tr); + +struct object_instance { + void *obj; + struct trace_array *tr; +}; + +/* objtrace private data */ +struct objtrace_trigger_data { + struct ftrace_event_field *field; + char objtrace_cmd[OBJTRACE_CMD_LEN]; + struct trace_array *tr; +}; + +/* objtrace data with fops and objtrace_instances */ +struct objtrace_data { + struct list_head head; + struct trace_array *tr; + struct ftrace_ops fops; + int num_traced_obj; + struct object_instance traced_obj[MAX_TRACED_OBJECT]; + raw_spinlock_t obj_data_lock; +}; + +static struct objtrace_data *get_obj_data(struct trace_array *tr) +{ + struct objtrace_data *obj_data =3D NULL; + + list_for_each_entry(obj_data, &obj_data_head, head) { + if (obj_data->tr =3D=3D tr) + break; + } + return obj_data; +} + +static bool object_exist(void *obj, struct trace_array *tr) +{ + int i, max; + struct objtrace_data *obj_data; + + obj_data =3D get_obj_data(tr); + if (!obj_data) + return false; + + max =3D READ_ONCE(obj_data->num_traced_obj); + smp_rmb(); + for (i =3D 0; i < max; i++) { + if (obj_data->traced_obj[i].obj =3D=3D obj) + return true; + } + return false; +} + +static bool object_empty(struct trace_array *tr) +{ + struct objtrace_data *obj_data; + + obj_data =3D get_obj_data(tr); + if (!obj_data) + return false; + + return !READ_ONCE(obj_data->num_traced_obj); +} + +static void set_trace_object(void *obj, struct trace_array *tr) +{ + unsigned long flags; + struct object_instance *obj_ins; + struct objtrace_data *obj_data; + + if (in_nmi()) + return; + + if (!obj && object_exist(obj, tr)) + return; + + obj_data =3D get_obj_data(tr); + if (!obj_data) + return; + + /* only this place has write operations */ + raw_spin_lock_irqsave(&obj_data->obj_data_lock, flags); + if (READ_ONCE(obj_data->num_traced_obj) =3D=3D MAX_TRACED_OBJECT) { + trace_array_printk_buf(tr->array_buffer.buffer, _THIS_IP_, + "object_pool is full, can't trace object:0x%px\n", obj); + goto out; + } + obj_ins =3D &obj_data->traced_obj[READ_ONCE(obj_data->num_traced_obj)]; + obj_ins->obj =3D obj; + obj_ins->tr =3D tr; + /* make sure the num_traced_obj update always appears after traced_obj up= date */ + smp_wmb(); + obj_data->num_traced_obj++; +out: + raw_spin_unlock_irqrestore(&obj_data->obj_data_lock, flags); +} + +static void submit_trace_object(unsigned long ip, unsigned long parent_ip, + unsigned long object, struct trace_array *tr) +{ + + struct trace_buffer *buffer =3D tr->array_buffer.buffer; + struct ring_buffer_event *event; + struct trace_object_entry *entry; + unsigned int trace_ctx =3D 0; + + trace_ctx =3D tracing_gen_ctx(); + event =3D trace_buffer_lock_reserve(buffer, TRACE_OBJECT, + sizeof(*entry), trace_ctx); + if (!event) + return; + entry =3D ring_buffer_event_data(event); + entry->ip =3D ip; + entry->parent_ip =3D parent_ip; + entry->object =3D object; + + trace_buffer_unlock_commit(tr, buffer, event, trace_ctx); +} + +static void +trace_object_events_call(unsigned long ip, unsigned long parent_ip, + struct ftrace_ops *op, struct ftrace_regs *fregs) +{ + struct pt_regs *pt_regs =3D ftrace_get_regs(fregs); + struct trace_array *tr =3D op->private; + struct trace_array_cpu *data; + unsigned long obj; + long disabled; + int cpu, n; + + preempt_disable_notrace(); + + cpu =3D raw_smp_processor_id(); + data =3D per_cpu_ptr(tr->array_buffer.data, cpu); + disabled =3D atomic_inc_return(&data->disabled); + if (likely(disabled =3D=3D 1)) { + if (object_empty(tr)) + goto out; + for (n =3D 0; n < max_args_num; n++) { + obj =3D regs_get_kernel_argument(pt_regs, n); + if (object_exist((void *)obj, tr)) + submit_trace_object(ip, parent_ip, obj, tr); + /* The parameters of a function may match multiple objects */ + } + } +out: + atomic_dec(&data->disabled); + preempt_enable_notrace(); +} + +static void +trace_object_trigger(struct event_trigger_data *data, + struct trace_buffer *buffer, void *rec, + struct ring_buffer_event *event) +{ + struct objtrace_trigger_data *obj_data =3D data->private_data; + struct trace_array *tr =3D obj_data->tr; + struct ftrace_event_field *field; + void *obj =3D NULL; + + field =3D obj_data->field; + memcpy(&obj, rec + field->offset, sizeof(obj)); + set_trace_object(obj, tr); +} + +static void +trace_object_trigger_free(struct event_trigger_data *data) +{ + struct objtrace_trigger_data *obj_data =3D data->private_data; + + if (WARN_ON_ONCE(data->ref <=3D 0)) + return; + + data->ref--; + if (!data->ref) { + exit_trace_object(obj_data->tr); + kfree(data->private_data); + trigger_data_free(data); + } +} + +static void +trace_object_count_trigger(struct event_trigger_data *data, + struct trace_buffer *buffer, void *rec, + struct ring_buffer_event *event) +{ + if (!data->count) + return; + + if (data->count !=3D -1) + (data->count)--; + + trace_object_trigger(data, buffer, rec, event); +} + +static int +event_trigger_print(const char *name, struct seq_file *m, + void *data, char *filter_str, void *objtrace_data) +{ + long count =3D (long)data; + struct objtrace_trigger_data *obj_data =3D objtrace_data; + + seq_puts(m, name); + + seq_printf(m, ":%s", obj_data->objtrace_cmd); + seq_printf(m, ":%s", obj_data->field->name); + + if (count =3D=3D -1) + seq_puts(m, ":unlimited"); + else + seq_printf(m, ":count=3D%ld", count); + + if (filter_str) + seq_printf(m, " if %s\n", filter_str); + else + seq_putc(m, '\n'); + + return 0; +} + +static int event_object_trigger_init(struct event_trigger_data *data) +{ + struct objtrace_trigger_data *obj_data =3D data->private_data; + int ret; + + if (!data->ref) { + ret =3D init_trace_object(obj_data->tr); + if (ret) + return ret; + } + data->ref++; + return 0; +} + +static int +trace_object_trigger_print(struct seq_file *m, struct event_trigger_data *= data) +{ + return event_trigger_print("objtrace", m, (void *)data->count, + data->filter_str, data->private_data); +} + +static struct event_trigger_ops objecttrace_trigger_ops =3D { + .trigger =3D trace_object_trigger, + .print =3D trace_object_trigger_print, + .init =3D event_object_trigger_init, + .free =3D trace_object_trigger_free, +}; + +static struct event_trigger_ops objecttrace_count_trigger_ops =3D { + .trigger =3D trace_object_count_trigger, + .print =3D trace_object_trigger_print, + .init =3D event_object_trigger_init, + .free =3D trace_object_trigger_free, +}; + +static struct event_trigger_ops * +objecttrace_get_trigger_ops(char *cmd, char *param) +{ + return param ? &objecttrace_count_trigger_ops : &objecttrace_trigger_ops; +} + +static bool field_exist(struct trace_event_file *file, + struct event_command *cmd_ops, + const char *field_name) +{ + struct event_trigger_data *data; + struct objtrace_trigger_data *obj_data; + + lockdep_assert_held(&event_mutex); + + list_for_each_entry(data, &file->triggers, list) { + if (data->cmd_ops->trigger_type =3D=3D cmd_ops->trigger_type) { + obj_data =3D data->private_data; + if (!strcmp(obj_data->field->name, field_name)) + return true; + } + } + + return false; +} + +static int +event_object_trigger_parse(struct event_command *cmd_ops, + struct trace_event_file *file, + char *glob, char *cmd, char *param_and_filter) +{ + struct event_trigger_data *trigger_data; + struct objtrace_trigger_data *obj_data; + struct ftrace_event_field *field; + char *objtrace_cmd, *arg; + char *param, *filter; + int ret; + bool remove; + + remove =3D event_trigger_check_remove(glob); + + /* + * separate the param and the filter: + * objtrace:add:OBJ[:COUNT] [if filter] + */ + ret =3D event_trigger_separate_filter(param_and_filter, ¶m, &filter, = true); + if (ret) + return ret; + + objtrace_cmd =3D strsep(¶m, ":"); + if (!objtrace_cmd || strcmp(objtrace_cmd, OBJTRACE_CMD_ADD)) { + pr_err("error objtrace command\n"); + return -EINVAL; + } + + arg =3D strsep(¶m, ":"); + if (!arg) + return -EINVAL; + + field =3D trace_find_event_field(file->event_call, arg); + if (!field) + return -EINVAL; + + if (field->size !=3D sizeof(void *)) { + pr_err("the size of the %s should be:%zu\n", field->name, sizeof(void *)= ); + return -EINVAL; + } + + if (remove && !field_exist(file, cmd_ops, field->name)) + return -ENOENT; + + obj_data =3D kzalloc(sizeof(*obj_data), GFP_KERNEL); + if (!obj_data) + return -ENOMEM; + + obj_data->field =3D field; + obj_data->tr =3D file->tr; + snprintf(obj_data->objtrace_cmd, OBJTRACE_CMD_LEN, objtrace_cmd); + + trigger_data =3D event_trigger_alloc(cmd_ops, cmd, param, obj_data); + if (!trigger_data) { + kfree(obj_data); + return -ENOMEM; + } + if (remove) { + event_trigger_unregister(cmd_ops, file, glob+1, trigger_data); + kfree(obj_data); + kfree(trigger_data); + return 0; + } + + ret =3D event_trigger_parse_num(param, trigger_data); + if (ret) + goto out_free; + + ret =3D event_trigger_set_filter(cmd_ops, file, filter, trigger_data); + if (ret < 0) + goto out_free; + + ret =3D event_trigger_register(cmd_ops, file, glob, trigger_data); + if (ret) + goto out_free; + + return ret; + + out_free: + event_trigger_reset_filter(cmd_ops, trigger_data); + kfree(obj_data); + kfree(trigger_data); + return ret; +} + +static struct event_command trigger_object_cmd =3D { + .name =3D "objtrace", + .trigger_type =3D ETT_TRACE_OBJECT, + .flags =3D EVENT_CMD_FL_NEEDS_REC, + .parse =3D event_object_trigger_parse, + .reg =3D register_trigger, + .unreg =3D unregister_trigger, + .get_trigger_ops =3D objecttrace_get_trigger_ops, + .set_filter =3D set_trigger_filter, +}; + +__init int register_trigger_object_cmd(void) +{ + int ret; + + ret =3D register_event_command(&trigger_object_cmd); + WARN_ON(ret < 0); + + return ret; +} + +int allocate_objtrace_data(struct trace_array *tr) +{ + struct objtrace_data *obj_data; + struct ftrace_ops *fops; + + obj_data =3D kzalloc(sizeof(*obj_data), GFP_KERNEL); + if (!obj_data) + return -ENOMEM; + + raw_spin_lock_init(&obj_data->obj_data_lock); + obj_data->tr =3D tr; + fops =3D &obj_data->fops; + fops->func =3D trace_object_events_call; + fops->flags =3D FTRACE_OPS_FL_SAVE_REGS; + fops->private =3D tr; + list_add(&obj_data->head, &obj_data_head); + + tr->obj_data =3D obj_data; + + return 0; +} + +static int init_trace_object(struct trace_array *tr) +{ + int ret; + + ret =3D register_ftrace_function(&tr->obj_data->fops); + WARN_ON(ret < 0); + + return ret; +} + +void free_objtrace_data(struct trace_array *tr) +{ + kfree(tr->obj_data); + tr->obj_data =3D NULL; +} + +static void exit_trace_object(struct trace_array *tr) +{ + struct objtrace_data *obj_data =3D tr->obj_data; + + obj_data->num_traced_obj =3D 0; + WARN_ONCE(unregister_ftrace_function(&obj_data->fops), + "can't unregister ftrace for trace object\n"); +} diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c index 67f47ea27921..34ff7b4dc521 100644 --- a/kernel/trace/trace_output.c +++ b/kernel/trace/trace_output.c @@ -1551,6 +1551,45 @@ static struct trace_event trace_func_repeats_event = =3D { .funcs =3D &trace_func_repeats_funcs, }; =20 +/* TRACE_OBJECT */ +static enum print_line_t trace_object_print(struct trace_iterator *iter, i= nt flags, + struct trace_event *event) +{ + struct trace_object_entry *field; + struct trace_seq *s =3D &iter->seq; + + trace_assign_type(field, iter->ent); + print_fn_trace(s, field->ip, field->parent_ip, flags); + trace_seq_printf(s, " object:0x%lx", field->object); + trace_seq_putc(s, '\n'); + + return trace_handle_return(s); +} + +static enum print_line_t trace_object_raw(struct trace_iterator *iter, int= flags, + struct trace_event *event) +{ + struct trace_object_entry *field; + + trace_assign_type(field, iter->ent); + + trace_seq_printf(&iter->seq, "%lx %lx\n", + field->ip, + field->parent_ip); + + return trace_handle_return(&iter->seq); +} + +static struct trace_event_functions trace_object_funcs =3D { + .trace =3D trace_object_print, + .raw =3D trace_object_raw, +}; + +static struct trace_event trace_object_event =3D { + .type =3D TRACE_OBJECT, + .funcs =3D &trace_object_funcs, +}; + static struct trace_event *events[] __initdata =3D { &trace_fn_event, &trace_ctx_event, @@ -1565,6 +1604,7 @@ static struct trace_event *events[] __initdata =3D { &trace_timerlat_event, &trace_raw_data_event, &trace_func_repeats_event, + &trace_object_event, NULL }; =20 --=20 2.25.1 From nobody Sun Apr 26 12:18:17 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 9EEA8CCA47E for ; Tue, 28 Jun 2022 14:56:40 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1347527AbiF1O4j (ORCPT ); Tue, 28 Jun 2022 10:56:39 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34412 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1347516AbiF1O4f (ORCPT ); Tue, 28 Jun 2022 10:56:35 -0400 Received: from mail-pf1-x435.google.com (mail-pf1-x435.google.com [IPv6:2607:f8b0:4864:20::435]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7159632EC8 for ; Tue, 28 Jun 2022 07:56:34 -0700 (PDT) Received: by mail-pf1-x435.google.com with SMTP id 65so12206514pfw.11 for ; Tue, 28 Jun 2022 07:56:34 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=/OgrDd4oZ1fAQ6x83rjNWwAy6izCnTWTIeS9iOkqQUk=; b=I0VgnoNBTLhoxFHt6/Z81OzwvRMovSPyRGoIauJTMPyg3t5ubHzYn/QKt2Mi+WI9qs TWNEEPkq90/5Pkkg30JuzzUnmRy4Ehxoed1629Y69cpq/XZIlK2zZ5rr0HR9DAvFd7Ou jvTGA1Kd85RCExvTEFGX+py8ktNOmxvKWQult3ETLn18WvQPfH56PP0KZhKkmRhFM3qM 0ETeGY3f7MIcn7MYnggOYsFINUUSr+OD3j/or58xSGkk1RPtavJ31PV67zLAKvcptR0m VWmZUxjZ2L8o9Ufk6liVGpt3W1esIgSbBcggzQAuySezVzV/A02riJ6ADoVFeP8Vl1As 4gAw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=/OgrDd4oZ1fAQ6x83rjNWwAy6izCnTWTIeS9iOkqQUk=; b=TV8DRebc37y4bC4+ic6JQgnrx4LSrILsF0lNseQ0ZUtFL537QSo68peYNeDLgxYmnt VLOv3Vw7Pky2bK60QxUOrxWwlw8GDAQVTk2cDANpX5Z5yazknWLUtsRsBQhjWkCLEp8P KvagJw/r6yzaJatcIt4KsIwD3R4odArihuGSBuio31IbxJnZbYU/UHDy/yinbPAGhAPe 6/b632YNYdY/vEL7FVGG/AHL1Nx+CDZXSxlZYuavg7vGWBuwCR2O8toNN6Gm0Ym3wbVy 9Vopi+smFmBRTzjseIju/AIOuCWHiEWbyHRKAGuKruL73jmGQfraCff7buojFDveuUXS DhHw== X-Gm-Message-State: AJIora/ywuCzKnDRikkIXcRcVc7a8dUmbGWZdXFnP6lTsFrDsiwfvPjn YvIbJ6pAOENNWy5QMK/LnhM= X-Google-Smtp-Source: AGRyM1tcy5n3EdPk6YXpYC3/vzeE3PQN8wuKxWpMMlwOweNwzhjVWl9MUshVBn0v5U4XBIZnJoK2BA== X-Received: by 2002:a05:6a00:1748:b0:525:4731:7f11 with SMTP id j8-20020a056a00174800b0052547317f11mr5274442pfc.72.1656428193369; Tue, 28 Jun 2022 07:56:33 -0700 (PDT) Received: from localhost.localdomain (li567-56.members.linode.com. [192.155.81.56]) by smtp.gmail.com with ESMTPSA id u17-20020a17090341d100b0016909678e2csm9502549ple.292.2022.06.28.07.56.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 28 Jun 2022 07:56:33 -0700 (PDT) From: Jeff Xie To: rostedt@goodmis.org Cc: mingo@redhat.com, mhiramat@kernel.org, zanussi@kernel.org, linux-kernel@vger.kernel.org, chensong_2000@189.cn, Jeff Xie Subject: [PATCH v14 2/4] trace/objtrace: Get the value of the object Date: Tue, 28 Jun 2022 22:55:50 +0800 Message-Id: <20220628145552.349839-3-xiehuan09@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220628145552.349839-1-xiehuan09@gmail.com> References: <20220628145552.349839-1-xiehuan09@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Using objtrace trigger to get the value of the object which from the kernel function parameter. Syntax: objtrace:add:obj[,offset][:type][:count][if ] Usage: # echo 'p bio_add_page arg1=3D$arg1' > ./kprobe_events # gdb vmlinux (gdb) p &(((struct bio *)0)->bi_iter.bi_size) $1 =3D (unsigned int *) 0x28 # echo 'objtrace:add:arg1,0x28:u32:1 if comm =3D=3D "cat"' > ./events/kpro= bes/ \ p_bio_add_page_0/trigger # cat /test.txt Signed-off-by: Jeff Xie Acked-by: Masami Hiramatsu (Google) --- kernel/trace/trace.c | 2 +- kernel/trace/trace_entries.h | 5 +- kernel/trace/trace_object.c | 187 ++++++++++++++++++++++++++++++++--- kernel/trace/trace_output.c | 6 +- 4 files changed, 181 insertions(+), 19 deletions(-) diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c index 7074ad8bc1a0..37f5cbfa5347 100644 --- a/kernel/trace/trace.c +++ b/kernel/trace/trace.c @@ -5628,7 +5628,7 @@ static const char readme_msg[] =3D "\t disable_hist::\n" #endif #ifdef CONFIG_TRACE_OBJECT - "\t objtrace:add:obj[:count][if ]\n" + "\t objtrace:add:obj[,offset][:type][:count][if ]\n" #endif #ifdef CONFIG_STACKTRACE "\t\t stacktrace\n" diff --git a/kernel/trace/trace_entries.h b/kernel/trace/trace_entries.h index bb120d9498a9..2407c45a568c 100644 --- a/kernel/trace/trace_entries.h +++ b/kernel/trace/trace_entries.h @@ -413,8 +413,9 @@ FTRACE_ENTRY(object, trace_object_entry, __field( unsigned long, ip ) __field( unsigned long, parent_ip ) __field( unsigned long, object ) + __field( unsigned long, value ) ), =20 - F_printk(" %ps <-- %ps object:%lx\n", - (void *)__entry->ip, (void *)__entry->parent_ip, __entry->object) + F_printk(" %ps <-- %ps object:%lx value:%lx\n", (void *)__entry->ip, + (void *)__entry->parent_ip, __entry->object, __entry->value) ); diff --git a/kernel/trace/trace_object.c b/kernel/trace/trace_object.c index 19ec4b1c0186..611341abeb7c 100644 --- a/kernel/trace/trace_object.c +++ b/kernel/trace/trace_object.c @@ -16,8 +16,14 @@ static const int max_args_num =3D 6; static void exit_trace_object(struct trace_array *tr); static int init_trace_object(struct trace_array *tr); =20 +/* + * get the offset from the special object and + * the type size of the value + */ struct object_instance { void *obj; + int obj_offset; + int obj_value_type_size; struct trace_array *tr; }; =20 @@ -25,9 +31,23 @@ struct object_instance { struct objtrace_trigger_data { struct ftrace_event_field *field; char objtrace_cmd[OBJTRACE_CMD_LEN]; + int obj_offset; + int obj_value_type_size; struct trace_array *tr; }; =20 +/* get the type size for the special object */ +struct objtrace_fetch_type { + char *name; + int type_size; +}; + +enum objattr { + OBJ_OFFSET, + OBJ_VAL_TYPE_SIZE, + MAX_OBJ_ATTR +}; + /* objtrace data with fops and objtrace_instances */ struct objtrace_data { struct list_head head; @@ -67,6 +87,35 @@ static bool object_exist(void *obj, struct trace_array *= tr) return false; } =20 +static int get_object_attr(void *obj, int objattr, + struct trace_array *tr, int *result) +{ + int i, max; + struct objtrace_data *obj_data; + + obj_data =3D get_obj_data(tr); + if (!obj_data) + return -EINVAL; + + max =3D READ_ONCE(obj_data->num_traced_obj); + smp_rmb(); + for (i =3D 0; i < max; i++) { + if (obj_data->traced_obj[i].obj =3D=3D obj) { + switch (objattr) { + case OBJ_OFFSET: + *result =3D obj_data->traced_obj[i].obj_offset; + return 0; + case OBJ_VAL_TYPE_SIZE: + *result =3D obj_data->traced_obj[i].obj_value_type_size; + return 0; + default: + return -EINVAL; + } + } + } + return -EINVAL; +} + static bool object_empty(struct trace_array *tr) { struct objtrace_data *obj_data; @@ -78,7 +127,8 @@ static bool object_empty(struct trace_array *tr) return !READ_ONCE(obj_data->num_traced_obj); } =20 -static void set_trace_object(void *obj, struct trace_array *tr) +static void set_trace_object(void *obj, int obj_offset, + int obj_value_type_size, struct trace_array *tr) { unsigned long flags; struct object_instance *obj_ins; @@ -103,6 +153,8 @@ static void set_trace_object(void *obj, struct trace_ar= ray *tr) } obj_ins =3D &obj_data->traced_obj[READ_ONCE(obj_data->num_traced_obj)]; obj_ins->obj =3D obj; + obj_ins->obj_value_type_size =3D obj_value_type_size; + obj_ins->obj_offset =3D obj_offset; obj_ins->tr =3D tr; /* make sure the num_traced_obj update always appears after traced_obj up= date */ smp_wmb(); @@ -112,7 +164,7 @@ static void set_trace_object(void *obj, struct trace_ar= ray *tr) } =20 static void submit_trace_object(unsigned long ip, unsigned long parent_ip, - unsigned long object, struct trace_array *tr) + unsigned long object, unsigned long value, struct trace_array *tr) { =20 struct trace_buffer *buffer =3D tr->array_buffer.buffer; @@ -129,10 +181,43 @@ static void submit_trace_object(unsigned long ip, uns= igned long parent_ip, entry->ip =3D ip; entry->parent_ip =3D parent_ip; entry->object =3D object; + entry->value =3D value; =20 trace_buffer_unlock_commit(tr, buffer, event, trace_ctx); } =20 +static inline long get_object_value(unsigned long *val, void *obj, int typ= e_size) +{ + char tmp[sizeof(u64)]; + long ret =3D 0; + + ret =3D copy_from_kernel_nofault(tmp, obj, sizeof(tmp)); + if (ret) + return ret; + switch (type_size) { + case 1: { + *val =3D (unsigned long)*(u8 *)tmp; + break; + } + case 2: { + *val =3D (unsigned long)*(u16 *)tmp; + break; + } + case 4: { + *val =3D (unsigned long)*(u32 *)tmp; + break; + } + case 8: { + *val =3D (unsigned long)*(u64 *)tmp; + break; + } + default: + return -EINVAL; + } + + return 0; +} + static void trace_object_events_call(unsigned long ip, unsigned long parent_ip, struct ftrace_ops *op, struct ftrace_regs *fregs) @@ -140,7 +225,8 @@ trace_object_events_call(unsigned long ip, unsigned lon= g parent_ip, struct pt_regs *pt_regs =3D ftrace_get_regs(fregs); struct trace_array *tr =3D op->private; struct trace_array_cpu *data; - unsigned long obj; + int ret, val_type_size, obj_offset; + unsigned long obj, val; long disabled; int cpu, n; =20 @@ -154,8 +240,21 @@ trace_object_events_call(unsigned long ip, unsigned lo= ng parent_ip, goto out; for (n =3D 0; n < max_args_num; n++) { obj =3D regs_get_kernel_argument(pt_regs, n); - if (object_exist((void *)obj, tr)) - submit_trace_object(ip, parent_ip, obj, tr); + if (object_exist((void *)obj, tr)) { + ret =3D get_object_attr((void *)obj, OBJ_OFFSET, + tr, &obj_offset); + if (unlikely(ret) < 0) + goto out; + ret =3D get_object_attr((void *)obj, OBJ_VAL_TYPE_SIZE, + tr, &val_type_size); + if (unlikely(ret) < 0) + goto out; + if (get_object_value(&val, (void *)(obj + obj_offset), + val_type_size)) + continue; + + submit_trace_object(ip, parent_ip, obj, val, tr); + } /* The parameters of a function may match multiple objects */ } } @@ -176,9 +275,23 @@ trace_object_trigger(struct event_trigger_data *data, =20 field =3D obj_data->field; memcpy(&obj, rec + field->offset, sizeof(obj)); - set_trace_object(obj, tr); + /* set the offset from the special object and the type size of the value*/ + set_trace_object(obj, obj_data->obj_offset, + obj_data->obj_value_type_size, tr); } =20 +static const struct objtrace_fetch_type objtrace_fetch_types[] =3D { + {"u8", 1}, + {"x8", 1}, + {"u16", 2}, + {"x16", 2}, + {"u32", 4}, + {"x32", 4}, + {"u64", 8}, + {"x64", 8}, + {NULL, 0}, +}; + static void trace_object_trigger_free(struct event_trigger_data *data) { @@ -213,14 +326,25 @@ static int event_trigger_print(const char *name, struct seq_file *m, void *data, char *filter_str, void *objtrace_data) { + int i; long count =3D (long)data; struct objtrace_trigger_data *obj_data =3D objtrace_data; + const char *value_type_name; =20 seq_puts(m, name); =20 seq_printf(m, ":%s", obj_data->objtrace_cmd); seq_printf(m, ":%s", obj_data->field->name); + if (obj_data->obj_offset) + seq_printf(m, ",0x%x", obj_data->obj_offset); =20 + for (i =3D 0; objtrace_fetch_types[i].name; i++) { + if (objtrace_fetch_types[i].type_size =3D=3D obj_data->obj_value_type_si= ze) { + value_type_name =3D objtrace_fetch_types[i].name; + break; + } + } + seq_printf(m, ":%s", value_type_name); if (count =3D=3D -1) seq_puts(m, ":unlimited"); else @@ -303,16 +427,18 @@ event_object_trigger_parse(struct event_command *cmd_= ops, struct event_trigger_data *trigger_data; struct objtrace_trigger_data *obj_data; struct ftrace_event_field *field; - char *objtrace_cmd, *arg; - char *param, *filter; - int ret; + char *objtrace_cmd, *obj; + char *param, *filter, *str, *type; + int ret, i, def_type_size, obj_value_type_size =3D 0; + char *tmp_saved_param; + long offset =3D 0; bool remove; =20 remove =3D event_trigger_check_remove(glob); =20 /* * separate the param and the filter: - * objtrace:add:OBJ[:COUNT] [if filter] + * objtrace:add:OBJ[,OFFS][:TYPE][:COUNT] [if filter] */ ret =3D event_trigger_separate_filter(param_and_filter, ¶m, &filter, = true); if (ret) @@ -324,11 +450,44 @@ event_object_trigger_parse(struct event_command *cmd_= ops, return -EINVAL; } =20 - arg =3D strsep(¶m, ":"); - if (!arg) + obj =3D strsep(¶m, ":"); + if (!obj) return -EINVAL; =20 - field =3D trace_find_event_field(file->event_call, arg); + str =3D strchr(obj, ','); + if (!str) + offset =3D 0; + else { + *str++ =3D '\0'; + ret =3D kstrtol(str, 0, &offset); + if (ret) + return -EINVAL; + } + def_type_size =3D sizeof(void *); + if (!param) { + obj_value_type_size =3D def_type_size; + goto skip_get_type; + } + tmp_saved_param =3D param; + type =3D strsep(¶m, ":"); + if (!type) + obj_value_type_size =3D def_type_size; + /* if this is the trigger count */ + else if (isdigit(type[0])) { + obj_value_type_size =3D def_type_size; + param =3D tmp_saved_param; + } else { + for (i =3D 0; objtrace_fetch_types[i].name; i++) { + if (strcmp(objtrace_fetch_types[i].name, type) =3D=3D 0) { + obj_value_type_size =3D objtrace_fetch_types[i].type_size; + break; + } + } + } + if (!obj_value_type_size) + return -EINVAL; +skip_get_type: + field =3D trace_find_event_field(file->event_call, obj); if (!field) return -EINVAL; =20 @@ -345,6 +504,8 @@ event_object_trigger_parse(struct event_command *cmd_op= s, return -ENOMEM; =20 obj_data->field =3D field; + obj_data->obj_offset =3D offset; + obj_data->obj_value_type_size =3D obj_value_type_size; obj_data->tr =3D file->tr; snprintf(obj_data->objtrace_cmd, OBJTRACE_CMD_LEN, objtrace_cmd); =20 diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c index 34ff7b4dc521..a45871b52dcc 100644 --- a/kernel/trace/trace_output.c +++ b/kernel/trace/trace_output.c @@ -1561,6 +1561,7 @@ static enum print_line_t trace_object_print(struct tr= ace_iterator *iter, int fla trace_assign_type(field, iter->ent); print_fn_trace(s, field->ip, field->parent_ip, flags); trace_seq_printf(s, " object:0x%lx", field->object); + trace_seq_printf(s, " value:0x%lx", field->value); trace_seq_putc(s, '\n'); =20 return trace_handle_return(s); @@ -1573,9 +1574,8 @@ static enum print_line_t trace_object_raw(struct trac= e_iterator *iter, int flags =20 trace_assign_type(field, iter->ent); =20 - trace_seq_printf(&iter->seq, "%lx %lx\n", - field->ip, - field->parent_ip); + trace_seq_printf(&iter->seq, "%lx %lx %lx %lx\n", field->ip, + field->parent_ip, field->object, field->value); =20 return trace_handle_return(&iter->seq); } --=20 2.25.1 From nobody Sun Apr 26 12:18:17 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 34E0BC433EF for ; Tue, 28 Jun 2022 14:56:45 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1347533AbiF1O4m (ORCPT ); Tue, 28 Jun 2022 10:56:42 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34440 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1347522AbiF1O4i (ORCPT ); Tue, 28 Jun 2022 10:56:38 -0400 Received: from mail-pg1-x533.google.com (mail-pg1-x533.google.com [IPv6:2607:f8b0:4864:20::533]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 6A20331904; Tue, 28 Jun 2022 07:56:37 -0700 (PDT) Received: by mail-pg1-x533.google.com with SMTP id r66so12465181pgr.2; Tue, 28 Jun 2022 07:56:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Qd9n1b+aaHwGYwpaofHd32mHepvmEuTUbjkVHr6tEU0=; b=cpJlNn9h4SVQv7Vwgzv4T2CUsc40ee/3Kd6cbpyqTOOAq/0xHNOsGHcKjZC/hOAaJZ dZQ9xdl1eRz6/gFhaHQyJmJAuVURTSuSd+IaE4iSnyipGOXxgyXeu9sn8Ggn85K+CORU PfEy/CL4+JfL8wLVHfZjHylcNbYhdd7vDGV3JrJsg3v0fSZssHBHKhU4Qt0R7U0QRXP5 TqCycyJ3Y/RUx2V7vo7ewq6B1AI8ciJEHupGh1oLFNEfsxAv1rCN042WaxoexHz8dmBd JqYJ25dQT8zSdmia98JhpbPHogcxM+Nzl/Y+RTA9ix5z6K9TYI5GR5Uy2HF5l69hm+UH 9OcQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Qd9n1b+aaHwGYwpaofHd32mHepvmEuTUbjkVHr6tEU0=; b=fn/HAHw7kR+OUo7GLxyLLSIMZPHFxDXvBwvkCaEvy5DbFRoNbSaHHIG01iEgV8fCyk nUDAUkInmwbbKYehrUZlkQLCWLcOIsiXlL329hiMsWIKVONtHYNpX/mE31+oV2ci6kq7 3iwqVz1V/J9JDU7JDF8wvNcQm9ETOHLeF+Os2XDl2Sa9wJ7kEoN1Js4FZdpWMuGGi7a5 MTgV+t3jAPvg9N+sQmDMQ6Jguepk0rC5VW8VHnaY1LDRUvwMvgYb+gCNTS96x5olfegh 6JoXBViUTVV910I4UrCpfspT5n25OfIEjOQPrPBXKKa9Z7JZ97qMeJX83GdRG2XYfgTb 8xuw== X-Gm-Message-State: AJIora8OAwARJfU5abxauqQ+yMeLREnSdSUdLzxdl4gy99Tgdz3aM7tl Ctr2PtymBpwXqqt9GJRfvUza98Gn41APTA== X-Google-Smtp-Source: AGRyM1syfxnneSSKUGWTiyCgnI3fHFAnFyUtdVxacOOtS88eLqXzK17xn4/6VbXtwAglWB0MZa9PvA== X-Received: by 2002:a05:6a00:21c2:b0:4fa:914c:2c2b with SMTP id t2-20020a056a0021c200b004fa914c2c2bmr4013657pfj.56.1656428196956; Tue, 28 Jun 2022 07:56:36 -0700 (PDT) Received: from localhost.localdomain (li567-56.members.linode.com. [192.155.81.56]) by smtp.gmail.com with ESMTPSA id u17-20020a17090341d100b0016909678e2csm9502549ple.292.2022.06.28.07.56.33 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 28 Jun 2022 07:56:36 -0700 (PDT) From: Jeff Xie To: rostedt@goodmis.org Cc: mingo@redhat.com, mhiramat@kernel.org, zanussi@kernel.org, linux-kernel@vger.kernel.org, chensong_2000@189.cn, Jeff Xie , Shuah Khan , linux-kselftest@vger.kernel.org Subject: [PATCH v14 3/4] selftests/ftrace: Add testcases for objtrace Date: Tue, 28 Jun 2022 22:55:51 +0800 Message-Id: <20220628145552.349839-4-xiehuan09@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220628145552.349839-1-xiehuan09@gmail.com> References: <20220628145552.349839-1-xiehuan09@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add a series of testcases to illustrate correct and incorrect usage of objtrace trigger. Cc: Shuah Khan Cc: linux-kselftest@vger.kernel.org Signed-off-by: Jeff Xie Tested-by: Masami Hiramatsu (Google) Acked-by: Masami Hiramatsu (Google) --- .../ftrace/test.d/trigger/trigger-objtrace.tc | 41 +++++++++++++++++++ 1 file changed, 41 insertions(+) create mode 100644 tools/testing/selftests/ftrace/test.d/trigger/trigger-o= bjtrace.tc diff --git a/tools/testing/selftests/ftrace/test.d/trigger/trigger-objtrace= .tc b/tools/testing/selftests/ftrace/test.d/trigger/trigger-objtrace.tc new file mode 100644 index 000000000000..d894442b6a30 --- /dev/null +++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-objtrace.tc @@ -0,0 +1,41 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0 +# description: event trigger - test objtrace-trigger +# requires: kprobe_events "objtrace":README + +fail() { #msg + echo $1 + exit_fail +} + +echo 'p bio_add_page arg1=3D$arg1 arg2=3D$arg2' > kprobe_events + +FEATURE=3D`grep objtrace events/kprobes/p_bio_add_page_0/trigger` +if [ -z "$FEATURE" ]; then + echo "objtrace trigger is not supported" + exit_unsupported +fi + +echo "Test objtrace trigger" +echo 'objtrace:add:arg1,0x28:u32:1 if comm =3D=3D "cat"' > \ + events/kprobes/p_bio_add_page_0/trigger +if [ -z $? ]; then + fail "objtrace trigger syntax error" +fi + +echo "Test objtrace semantic errors" + +# Being lack of objtrace command +! echo 'objtrace:arg1,0x28:u32:1' > events/kprobes/p_bio_add_page_0/trigger +# Bad parameter name +! echo 'objtrace:add:argx:u32:1' > events/kprobes/p_bio_add_page_0/trigger +# The parameter existed on event +! echo 'objtrace:add:arg2:u32:1' > events/kprobes/p_bio_add_page_0/trigger + +echo "reset objtrace trigger" + +echo '!objtrace:add:arg1,0x28:u32' > \ + events/kprobes/p_bio_add_page_0/trigger +echo '-:p_bio_add_page_0' >> ./kprobe_events + +exit 0 --=20 2.25.1 From nobody Sun Apr 26 12:18:17 2026 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id DA196C43334 for ; Tue, 28 Jun 2022 14:56:53 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1345887AbiF1O4w (ORCPT ); Tue, 28 Jun 2022 10:56:52 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:34504 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1347217AbiF1O4m (ORCPT ); Tue, 28 Jun 2022 10:56:42 -0400 Received: from mail-pj1-x102e.google.com (mail-pj1-x102e.google.com [IPv6:2607:f8b0:4864:20::102e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id DE72B3335E; Tue, 28 Jun 2022 07:56:41 -0700 (PDT) Received: by mail-pj1-x102e.google.com with SMTP id dw10-20020a17090b094a00b001ed00a16eb4so12944014pjb.2; Tue, 28 Jun 2022 07:56:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20210112; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=ejGWeAFgEA+ok2503tmhm0ExoFnyPJd66F9hUUqWubQ=; b=ecpN/UeOfXt6qtVag5bsnOZPgLtT16e2gxYvHZEbBfYxvv3J/6C2Y1Afy24+MpnKWV m/TZABVYtefFNlCx7FrI6gGuO8jkbUNfsh5A3hguvfALuTNBMT8kZJut0GHQ9cnVcm4P Mba0/8e0iM+YkbkKU0/TQsIM4WXGYkh3LzyhK12upVy1p4e2N6eg6SKPGr2F5j0Jr6hp +3fPNZPVh733WfRspZgNh2mzYJOppO4QBoObSFx81T/jrnw6CTJT7HExWg5c596VOBXM xwp3pO5BxxHFJ3gTMmTBvtPlj618ktjJ5Z4LLCpERBr0EfkYrheeD7FlX2DYCVmhHBb/ mjGw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20210112; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=ejGWeAFgEA+ok2503tmhm0ExoFnyPJd66F9hUUqWubQ=; b=3LPFas6WfpiL5WQpWcKUeJ4We2cBqNHUd3DRc91yap8PVYZFS8227OtXHEI6l3EWU5 O+fvRoZ+R+Cn7uf5GmFk+Jtq2gofRYRD+DDecrPBue7codgh7Y7XQvv7sk9qyql3vUxV u6EtNCipMiVHsSmgpt9HB8gwIsivSE5q7c3Gua/6H/m9vTzciBET5izIVkM/DVme5SfV Cbzv6EgWY/8t/i20Ikljv7PDitgkCoKZ1SS3/+ySHNfFMYjNRTg6cYwtia+yljzjkSkY iuVfef8gQLx1xkN2TvAugCIpm7QfOPqNhde26zhVbY1pp0uPAo7XaAtzLo0S90sJITqu x4/g== X-Gm-Message-State: AJIora+Uobdyh6c3upJn2GjlI6x2Ce2JMZ4VoiGkwyllh4VubdbaAz7G A4Z9o1r9h6mJsd2yrZ8VhCY= X-Google-Smtp-Source: AGRyM1ttV9hmcNYDLwJtS/XW4naMtVdkf4VOqqWLApAFyhRBjR2/zOEPg7hTh+0tizhf3ZhJ/8lAGA== X-Received: by 2002:a17:902:cf4a:b0:169:a894:3465 with SMTP id e10-20020a170902cf4a00b00169a8943465mr4077498plg.56.1656428201400; Tue, 28 Jun 2022 07:56:41 -0700 (PDT) Received: from localhost.localdomain (li567-56.members.linode.com. [192.155.81.56]) by smtp.gmail.com with ESMTPSA id u17-20020a17090341d100b0016909678e2csm9502549ple.292.2022.06.28.07.56.37 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 28 Jun 2022 07:56:41 -0700 (PDT) From: Jeff Xie To: rostedt@goodmis.org Cc: mingo@redhat.com, mhiramat@kernel.org, zanussi@kernel.org, linux-kernel@vger.kernel.org, chensong_2000@189.cn, Jeff Xie , Jonathan Corbet , Bagas Sanjaya , linux-doc@vger.kernel.org Subject: [PATCH v14 4/4] Documentation: trace/objtrace: Add documentation for objtrace Date: Tue, 28 Jun 2022 22:55:52 +0800 Message-Id: <20220628145552.349839-5-xiehuan09@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220628145552.349839-1-xiehuan09@gmail.com> References: <20220628145552.349839-1-xiehuan09@gmail.com> MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Type: text/plain; charset="utf-8" Add documentation explaining how to use objtrace trigger to get the value of the object. Cc: Jonathan Corbet Cc: Bagas Sanjaya Cc: linux-doc@vger.kernel.org Signed-off-by: Jeff Xie Reviewed-by: Masami Hiramatsu (Google) Reviewed-by: Bagas Sanjaya --- Changelog: v14: - make documentation more readable and fix literal code block by Bagas Sanj= aya Documentation/trace/events.rst | 87 ++++++++++++++++++++++++++++++++++ 1 file changed, 87 insertions(+) diff --git a/Documentation/trace/events.rst b/Documentation/trace/events.rst index c47f381d0c00..c15f1d25d4a0 100644 --- a/Documentation/trace/events.rst +++ b/Documentation/trace/events.rst @@ -546,6 +546,93 @@ The following commands are supported: =20 See Documentation/trace/histogram.rst for details and examples. =20 +- objtrace + + This command provides a way to get the value of any object, The object + can be obtained from the dynamic event (kprobe_event/uprobe_event) or the + static event (tracepoint). + + Usage: + When using the kprobe event, by only need to set the objtrace (a new + trigger), we can get the value of object that is set by kprobe event. + + For example, for the function bio_add_page(): + + .. code-block:: c + + int bio_add_page(struct bio *bio, struct page *page, + unsigned int len, unsigned int offset) + + Firstly, we can set the base of the object as first parameter (arg1) to + to the function: + + .. code-block:: + + # echo 'p bio_add_page arg1=3D$arg1' > ./kprobe_events + + Secondly, we can get the value dynamically based on the object: + + .. code-block:: + + find the offset of the bi_size in struct bio: + $ gdb vmlinux + (gdb) p &(((struct bio *)0)->bi_iter.bi_size) + $1 =3D (unsigned int *) 0x28 + + # echo 'objtrace:add:arg1,0x28:u32:1 if comm =3D=3D "cat"' > ./events= /kprobes/ \ + p_bio_add_page_0/trigger + + # cd /sys/kernel/debug/tracing/ + # echo 'p bio_add_page arg1=3D$arg1' > ./kprobe_events + # echo 'objtrace:add:arg1,0x28:u32:1 if comm =3D=3D "cat"' > ./events= /kprobes/p_bio_add_page_0/trigger + + # du -sh /test.txt + 12.0K /test.txt + + # cat /test.txt > /dev/null + # cat ./trace + # tracer: nop + # + # entries-in-buffer/entries-written: 128/128 #P:4 + # + # _-----=3D> irqs-off/BH-disabled + # / _----=3D> need-resched + # | / _---=3D> hardirq/softirq + # || / _--=3D> preempt-depth + # ||| / _-=3D> migrate-disable + # |||| / delay + # TASK-PID CPU# ||||| TIMESTAMP FUNCTION + # | | | ||||| | | + cat-117 [002] ...1. 1.602243: __bio_try_merge_pa= ge <-bio_add_page object:0xffff88811bee4000 value:0x0 + cat-117 [002] ...1. 1.602244: __bio_add_page <-b= io_add_page object:0xffff88811bee4000 value:0x0 + cat-117 [002] ...2. 1.602244: bio_add_page <-ext= 4_mpage_readpages object:0xffff88811bee4000 value:0x1000 + cat-117 [002] ...1. 1.602245: __bio_try_merge_pa= ge <-bio_add_page object:0xffff88811bee4000 value:0x1000 + cat-117 [002] ...1. 1.602245: __bio_add_page <-b= io_add_page object:0xffff88811bee4000 value:0x1000 + cat-117 [002] ...2. 1.602245: bio_add_page <-ext= 4_mpage_readpages object:0xffff88811bee4000 value:0x2000 + cat-117 [002] ...1. 1.602245: __bio_try_merge_pa= ge <-bio_add_page object:0xffff88811bee4000 value:0x2000 + cat-117 [002] ...1. 1.602245: __bio_add_page <-b= io_add_page object:0xffff88811bee4000 value:0x2000 + cat-117 [002] ...1. 1.602245: submit_bio <-ext4_= mpage_readpages object:0xffff88811bee4000 value:0x3000 + cat-117 [002] ...1. 1.602245: submit_bio_noacct = <-ext4_mpage_readpages object:0xffff88811bee4000 value:0x3000 + cat-117 [002] ...1. 1.602246: __submit_bio <-sub= mit_bio_noacct object:0xffff88811bee4000 value:0x3000 + cat-117 [002] ...1. 1.602246: submit_bio_checks = <-__submit_bio object:0xffff88811bee4000 value:0x3000 + cat-117 [002] ...1. 1.602246: __cond_resched <-s= ubmit_bio_checks object:0xffff88811bee4000 value:0x3000 + cat-117 [002] ...1. 1.602246: should_fail_bio <-= submit_bio_checks object:0xffff88811bee4000 value:0x3000 + cat-117 [002] ...1. 1.602246: blk_mq_submit_bio = <-submit_bio_noacct object:0xffff88811bee4000 value:0x3000 + cat-117 [002] ...1. 1.602246: blk_attempt_plug_m= erge <-blk_mq_submit_bio object:0xffff88811bee4000 value:0x3000 + cat-117 [002] ...1. 1.602246: blk_mq_sched_bio_m= erge <-blk_mq_submit_bio object:0xffff88811bee4000 value:0x3000 + cat-117 [002] ...1. 1.602247: __rcu_read_lock <-= blk_mq_submit_bio object:0xffff88811bee4000 value:0x3000 + cat-117 [002] ...1. 1.602247: __rcu_read_unlock = <-blk_mq_submit_bio object:0xffff88811bee4000 value:0x3000 + cat-117 [002] ...1. 1.602247: __blk_mq_alloc_req= uests <-blk_mq_submit_bio object:0xffff88811bee4000 value:0x3000 + -0 [002] d..3. 1.602298: bio_endio <-blk_up= date_request object:0xffff88811bee4000 value:0x0 + -0 [002] d..3. 1.602298: mpage_end_io <-blk= _update_request object:0xffff88811bee4000 value:0x0 + -0 [002] d..3. 1.602298: __read_end_io <-bl= k_update_request object:0xffff88811bee4000 value:0x0 + -0 [002] d..3. 1.602300: bio_put <-blk_upda= te_request object:0xffff88811bee4000 value:0x0 + -0 [002] d..3. 1.602300: bio_free <-blk_upd= ate_request object:0xffff88811bee4000 value:0x0 + -0 [002] d..3. 1.602300: mempool_free <-blk= _update_request object:0xffff88811bee4000 value:0x0 + -0 [002] d..3. 1.602300: mempool_free_slab = <-blk_update_request object:0xffff88811bee4000 value:0x0 + -0 [002] d..3. 1.602300: kmem_cache_free <-= blk_update_request object:0xffff88811bee4000 value:0x0 + ... + 7. In-kernel trace event API =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D=3D=3D =20 --=20 2.25.1