From nobody Tue Jun 30 16:38:53 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 8B6C9C433F5 for ; Thu, 13 Jan 2022 01:38:57 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231393AbiAMBi4 (ORCPT ); Wed, 12 Jan 2022 20:38:56 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59800 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231376AbiAMBiv (ORCPT ); Wed, 12 Jan 2022 20:38:51 -0500 Received: from mail-pj1-x1034.google.com (mail-pj1-x1034.google.com [IPv6:2607:f8b0:4864:20::1034]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id AD36FC06173F for ; Wed, 12 Jan 2022 17:38:51 -0800 (PST) Received: by mail-pj1-x1034.google.com with SMTP id n30-20020a17090a5aa100b001b2b6509685so8505425pji.3 for ; Wed, 12 Jan 2022 17:38:51 -0800 (PST) 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=2w1+ajhTE1QQVwZvKTIk5u0ht+pTpglNcKV2ta4bguU=; b=qUgyF8cX6Q0fFDjasWS16B8AEuywRvv287PnHnxS+dcDXEDZr0IzyldzHwIYpNJrAL TKJ/TuZz8rc8/X/CNn98O5/GAC1wv5R/ROaHt1Pi89J4lVsZ6h+DiklycQFGwU10g0E0 aMI6R3uBbj7/gJ+Xbt4Zv9aNAbxVZsF4Q+oLKswtEKkjRTiUCJmwX5rp+gs/MaTcrOiq DzBEnyINvQnOtn/ubUyUfOXLYUGKJjs5fYt2yJ42nWv/F5D0BqSgaaQwNqsQ7fXBHd3D YnvlukyDdYPQsgEqWv+dmT96eTXllCNHhpMsaM+Nn+YGF5EgXuuvYObYl8nREHSd5uWL Y4Uw== 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=2w1+ajhTE1QQVwZvKTIk5u0ht+pTpglNcKV2ta4bguU=; b=eixutOPUsoP6F7c8CZY6jIQoERnomHQvl0E2dQzH9wVl7RV0FKnkSc3ylZUbN2RUQJ g7bu/e1dPtSFnwmxF/q8DSV8Qi7fPKFoET70d9JcXiTwbi9NwKK8Wkd4euowl8ip1t8j p0YSbHWZd3fmF9Zqiobl9OQutFPZcOXnq7+el/ybwrirhXHnOIJLXtMhd0O/s46pspR8 5ox27jB6i7jVbHoeclBLuxeiFTzm2WMuFdPfkSn6pTBt2m5sNY9c8KCUadqJkgzd6Eff pGnMiw3fEQoTLa331XWlToB8zp28iaT7MSMjTZuiU3EjHDK10poUWN4if7OUWF4UlJ02 8tag== X-Gm-Message-State: AOAM533efDtErfT3wZex8PdE1ATguD9UD0wTXikkotv4LLA7/fcQmOtN oT1Q1SgH7xeW2wJ6IASYDY3XeWR8kxyMgQ== X-Google-Smtp-Source: ABdhPJwOpsI1BtFTG7iCsDP6gRDNKkOjTD7Fk4cAHwKV95ctRPpqnMkgjkgKAWvWWfTpgM2Vh7S0zw== X-Received: by 2002:a63:ab4a:: with SMTP id k10mr2010471pgp.105.1642037931166; Wed, 12 Jan 2022 17:38:51 -0800 (PST) Received: from localhost.localdomain (li567-56.members.linode.com. [192.155.81.56]) by smtp.gmail.com with ESMTPSA id b4sm799990pfl.101.2022.01.12.17.38.48 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 12 Jan 2022 17:38:50 -0800 (PST) From: Jeff Xie To: rostedt@goodmis.org Cc: mhiramat@kernel.org, mingo@redhat.com, zanussi@kernel.org, linux-kernel@vger.kernel.org, Jeff Xie Subject: [PATCH v7 1/4] trace: Add trace any kernel object Date: Thu, 13 Jan 2022 09:38:32 +0800 Message-Id: <20220113013835.503285-2-xiehuan09@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220113013835.503285-1-xiehuan09@gmail.com> References: <20220113013835.503285-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 --- include/linux/trace_events.h | 1 + kernel/trace/Kconfig | 10 + kernel/trace/Makefile | 1 + kernel/trace/trace.c | 3 + kernel/trace/trace.h | 8 + kernel/trace/trace_entries.h | 17 + kernel/trace/trace_events_trigger.c | 1 + kernel/trace/trace_object.c | 460 ++++++++++++++++++++++++++++ kernel/trace/trace_output.c | 40 +++ 9 files changed, 541 insertions(+) create mode 100644 kernel/trace/trace_object.c diff --git a/include/linux/trace_events.h b/include/linux/trace_events.h index 2d167ac3452c..54baec78ce62 100644 --- a/include/linux/trace_events.h +++ b/include/linux/trace_events.h @@ -684,6 +684,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 420ff4bc67fd..f69761cbfaaa 100644 --- a/kernel/trace/Kconfig +++ b/kernel/trace/Kconfig @@ -237,6 +237,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 bedc5caceec7..b924b8e55922 100644 --- a/kernel/trace/Makefile +++ b/kernel/trace/Makefile @@ -67,6 +67,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 78ea542ce3bc..0b627963e343 100644 --- a/kernel/trace/trace.c +++ b/kernel/trace/trace.c @@ -5590,6 +5590,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 diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index 38715aa6cfdf..46a1301ac47a 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, }; @@ -469,6 +470,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 @@ -1531,6 +1533,12 @@ 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); +#else +static inline int register_trigger_object_cmd(void) { return 0; } +#endif + extern int register_trigger_cmds(void); extern void clear_event_triggers(struct trace_array *tr); =20 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 3d5c07239a2a..da2d871fa809 100644 --- a/kernel/trace/trace_events_trigger.c +++ b/kernel/trace/trace_events_trigger.c @@ -1687,6 +1687,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..4af1c117cbfa --- /dev/null +++ b/kernel/trace/trace_object.c @@ -0,0 +1,460 @@ +// 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 +static DEFINE_RAW_SPINLOCK(trace_obj_lock); +static struct trace_event_file event_trace_file; +static const int max_args_num =3D 6; +static atomic_t trace_object_ref; +static atomic_t num_traced_obj; +static int exit_trace_object(void); +static int init_trace_object(void); + +static struct object_instance { + void *obj; +} traced_obj[MAX_TRACED_OBJECT]; + +static bool object_exist(void *obj) +{ + int i, max; + + max =3D atomic_read(&num_traced_obj); + smp_rmb(); + for (i =3D 0; i < max; i++) { + if (traced_obj[i].obj =3D=3D obj) + return true; + } + return false; +} + +static bool object_empty(void) +{ + return !atomic_read(&num_traced_obj); +} + +static void set_trace_object(void *obj) +{ + unsigned long flags; + + if (in_nmi()) + return; + + if (!obj) + return; + + if (object_exist(obj)) + return; + + /* only this place has write operations */ + raw_spin_lock_irqsave(&trace_obj_lock, flags); + if (atomic_read(&num_traced_obj) =3D=3D MAX_TRACED_OBJECT) { + trace_printk("object_pool is full, can't trace object:0x%px\n", obj); + goto out; + } + traced_obj[atomic_read(&num_traced_obj)].obj =3D obj; + /* make sure the num_traced_obj update always appears after traced_obj up= date */ + smp_wmb(); + atomic_inc(&num_traced_obj); +out: + raw_spin_unlock_irqrestore(&trace_obj_lock, flags); +} + +static void submit_trace_object(unsigned long ip, unsigned long parent_ip, + unsigned long object) +{ + + struct trace_buffer *buffer; + struct ring_buffer_event *event; + struct trace_object_entry *entry; + int pc; + + pc =3D preempt_count(); + event =3D trace_event_buffer_lock_reserve(&buffer, &event_trace_file, + TRACE_OBJECT, sizeof(*entry), pc); + if (!event) + return; + entry =3D ring_buffer_event_data(event); + entry->ip =3D ip; + entry->parent_ip =3D parent_ip; + entry->object =3D object; + + event_trigger_unlock_commit(&event_trace_file, buffer, event, + entry, pc); +} + +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); + unsigned long obj; + int bit, n; + + bit =3D ftrace_test_recursion_trylock(ip, parent_ip); + if (bit < 0) + return; + + if (object_empty()) + 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)) + submit_trace_object(ip, parent_ip, obj); + /* The parameters of a function may match multiple objects */ + } +out: + ftrace_test_recursion_unlock(bit); +} + +static struct ftrace_ops trace_ops =3D { + .func =3D trace_object_events_call, + .flags =3D FTRACE_OPS_FL_SAVE_REGS, +}; + +static void +trace_object_trigger(struct event_trigger_data *data, + struct trace_buffer *buffer, void *rec, + struct ring_buffer_event *event) +{ + + struct ftrace_event_field *field =3D data->private_data; + void *obj =3D NULL; + + memcpy(&obj, rec + field->offset, sizeof(obj)); + set_trace_object(obj); +} + +static void +trace_object_trigger_free(struct event_trigger_ops *ops, + struct event_trigger_data *data) +{ + if (WARN_ON_ONCE(data->ref <=3D 0)) + return; + + data->ref--; + if (!data->ref) + 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_object_trigger_init(struct event_trigger_ops *ops, + struct event_trigger_data *data) +{ + data->ref++; + return 0; +} + +static int +event_trigger_print(const char *name, struct seq_file *m, + void *data, char *filter_str) +{ + long count =3D (long)data; + + seq_puts(m, 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 +trace_object_trigger_print(struct seq_file *m, struct event_trigger_ops *o= ps, + struct event_trigger_data *data) +{ + return event_trigger_print("objtrace", m, (void *)data->count, + data->filter_str); +} + +static struct event_trigger_ops objecttrace_trigger_ops =3D { + .func =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 { + .func =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 int register_object_trigger(char *glob, struct event_trigger_ops *o= ps, + struct event_trigger_data *data, + struct trace_event_file *file) +{ + struct event_trigger_data *test; + int ret =3D 0; + + lockdep_assert_held(&event_mutex); + + list_for_each_entry(test, &file->triggers, list) { + if (test->cmd_ops->trigger_type =3D=3D data->cmd_ops->trigger_type) { + ret =3D -EEXIST; + goto out; + } + } + + if (data->ops->init) { + ret =3D data->ops->init(data->ops, data); + if (ret < 0) + goto out; + } + + list_add_rcu(&data->list, &file->triggers); + ret++; + + update_cond_flag(file); + if (trace_event_trigger_enable_disable(file, 1) < 0) { + list_del_rcu(&data->list); + update_cond_flag(file); + ret--; + } + init_trace_object(); +out: + return ret; +} + +static void unregister_object_trigger(char *glob, struct event_trigger_ops= *ops, + struct event_trigger_data *test, + struct trace_event_file *file) +{ + struct event_trigger_data *data; + bool unregistered =3D false; + + lockdep_assert_held(&event_mutex); + + list_for_each_entry(data, &file->triggers, list) { + if (data->cmd_ops->trigger_type =3D=3D test->cmd_ops->trigger_type) { + unregistered =3D true; + list_del_rcu(&data->list); + trace_event_trigger_enable_disable(file, 0); + update_cond_flag(file); + break; + } + } + + if (unregistered) { + if (data->ops->free) + data->ops->free(data->ops, data); + exit_trace_object(); + } +} + +static int +event_object_trigger_callback(struct event_command *cmd_ops, + struct trace_event_file *file, + char *glob, char *cmd, char *param) +{ + struct event_trigger_data *trigger_data; + struct event_trigger_ops *trigger_ops; + struct trace_event_call *call; + struct ftrace_event_field *field; + char *objtrace_cmd; + char *trigger =3D NULL; + char *arg; + char *number; + int ret; + + ret =3D -EINVAL; + if (!param) + goto out; + + /* separate the trigger from the filter (c:a:n [if filter]) */ + trigger =3D strsep(¶m, " \t"); + if (!trigger) + goto out; + if (param) { + param =3D skip_spaces(param); + if (!*param) + param =3D NULL; + } + + objtrace_cmd =3D strsep(&trigger, ":"); + if (!objtrace_cmd || strcmp(objtrace_cmd, "add")) + goto out; + + arg =3D strsep(&trigger, ":"); + if (!arg) + goto out; + call =3D file->event_call; + field =3D trace_find_event_field(call, arg); + if (!field) + goto out; + + if (field->size !=3D sizeof(void *)) + goto out; + + trigger_ops =3D cmd_ops->get_trigger_ops(cmd, trigger); + + ret =3D -ENOMEM; + trigger_data =3D kzalloc(sizeof(*trigger_data), GFP_KERNEL); + if (!trigger_data) + goto out; + + trigger_data->count =3D -1; + trigger_data->ops =3D trigger_ops; + trigger_data->cmd_ops =3D cmd_ops; + trigger_data->private_data =3D field; + INIT_LIST_HEAD(&trigger_data->list); + INIT_LIST_HEAD(&trigger_data->named_list); + + if (glob[0] =3D=3D '!') { + cmd_ops->unreg(glob+1, trigger_ops, trigger_data, file); + kfree(trigger_data); + ret =3D 0; + goto out; + } + + if (trigger) { + number =3D strsep(&trigger, ":"); + + ret =3D -EINVAL; + if (!strlen(number)) + goto out_free; + + /* + * We use the callback data field (which is a pointer) + * as our counter. + */ + ret =3D kstrtoul(number, 0, &trigger_data->count); + if (ret) + goto out_free; + } + + if (!param) /* if param is non-empty, it's supposed to be a filter */ + goto out_reg; + + if (!cmd_ops->set_filter) + goto out_reg; + + ret =3D cmd_ops->set_filter(param, trigger_data, file); + if (ret < 0) + goto out_free; + + out_reg: + /* Up the trigger_data count to make sure reg doesn't free it on failure = */ + event_object_trigger_init(trigger_ops, trigger_data); + ret =3D cmd_ops->reg(glob, trigger_ops, trigger_data, file); + /* + * The above returns on success the # of functions enabled, + * but if it didn't find any functions it returns zero. + * Consider no functions a failure too. + */ + if (!ret) { + cmd_ops->unreg(glob, trigger_ops, trigger_data, file); + ret =3D -ENOENT; + } else if (ret > 0) + ret =3D 0; + + /* Down the counter of trigger_data or free it if not used anymore */ + trace_object_trigger_free(trigger_ops, trigger_data); + out: + return ret; + + out_free: + if (cmd_ops->set_filter) + cmd_ops->set_filter(NULL, trigger_data, NULL); + kfree(trigger_data); + goto out; +} + +static struct event_command trigger_object_cmd =3D { + .name =3D "objtrace", + .trigger_type =3D ETT_TRACE_OBJECT, + .flags =3D EVENT_CMD_FL_NEEDS_REC, + .func =3D event_object_trigger_callback, + .reg =3D register_object_trigger, + .unreg =3D unregister_object_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; +} + +static int init_trace_object(void) +{ + int ret; + + if (atomic_inc_return(&trace_object_ref) !=3D 1) { + ret =3D 0; + goto out; + } + + event_trace_file.tr =3D top_trace_array(); + if (WARN_ON(!event_trace_file.tr)) { + ret =3D -1; + atomic_dec(&trace_object_ref); + goto out; + } + ret =3D register_ftrace_function(&trace_ops); +out: + return ret; +} + +static int exit_trace_object(void) +{ + int ret; + + if (WARN_ON_ONCE(atomic_read(&trace_object_ref) <=3D 0)) { + ret =3D -1; + goto out; + } + + if (atomic_dec_return(&trace_object_ref) !=3D 0) { + ret =3D 0; + goto out; + } + + ret =3D unregister_ftrace_function(&trace_ops); + if (ret) { + pr_err("can't unregister ftrace for trace object\n"); + goto out; + } + atomic_set(&num_traced_obj, 0); +out: + return ret; +} diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c index 3547e7176ff7..d747aed27104 100644 --- a/kernel/trace/trace_output.c +++ b/kernel/trace/trace_output.c @@ -1543,6 +1543,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, @@ -1557,6 +1596,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 Tue Jun 30 16:38:53 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 AB5AAC433F5 for ; Thu, 13 Jan 2022 01:39:03 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231424AbiAMBi7 (ORCPT ); Wed, 12 Jan 2022 20:38:59 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59814 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231388AbiAMBiy (ORCPT ); Wed, 12 Jan 2022 20:38:54 -0500 Received: from mail-pj1-x1034.google.com (mail-pj1-x1034.google.com [IPv6:2607:f8b0:4864:20::1034]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id CB0B4C06173F for ; Wed, 12 Jan 2022 17:38:54 -0800 (PST) Received: by mail-pj1-x1034.google.com with SMTP id a1-20020a17090a688100b001b3fd52338eso7430156pjd.1 for ; Wed, 12 Jan 2022 17:38:54 -0800 (PST) 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=bX0J0QvBkrSACNB0AIqODgrORCPOYwdsklTN5tXEe1U=; b=fpAHsAVXw5UCngeHLrb7wP1mpvyfVGHjpjP1W+L4U4shgZsZBw658JfalDvxgr4k/b lJg5KHyHxSBbplP27z4SMQI9+2dFhPIchO6mO4rC9XNwuNNTkyFoE7Dgaqcm1BIGflFM beTAdQfOi89WS0bjAph8Of77zoswIJANkwoQmrvpebBy2vCau5qWn6FpkRWSo/q2l59s X3bWPZ0EXwwboowzK+2D7zasV7ct++tSsCGZ70Q7FI63/vSGR6jPZq7USLS+gUBQklV8 Eh5uH2E4hoPl1U50VqIijEQs0Z+LX9OlsCef/c1U1WN2oKG27/DSxUTv46yBE4bvx8z5 ga+g== 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=bX0J0QvBkrSACNB0AIqODgrORCPOYwdsklTN5tXEe1U=; b=tM/3Z4VsN26Pt4NvmgPCEfyB9l4GlHTl8itJHteHnLrbC7xkN/iXvWMRTmu4yLdCo1 IasfocghilVV/PZF3cub+gFm9IkV5TvLMStG46wXj87VszjUN7tdr/iIbBZXCmCdiDeU D60x3uNUJ3TSbnjJlbou+33FLvQUG1xbJp/4IYSGSLoH7knna/JoZq00KSoUmWfhS3rQ Fes4OijqshM8kIe6L7ZCOuJ8QFUydcWi6uZhEO5n+BfV+8Px+A99d8UayV6UG+srmlGv /mCyhfK2HcEtxQ4TIoqtDtA/rV/CIeGqRx5wGk6T/slD+RptkPuNP1o6rVZjykuOhIPk TkPQ== X-Gm-Message-State: AOAM533urLvzRStAaHhv0UkwLLCgpoNG+PrQi8aAHa6RrReCHU1WFw7u stIq46GZgvp7euiMDlPnrCWaSwf21TDntw== X-Google-Smtp-Source: ABdhPJwl3dReaxYrIgKriTiuS0gfAyEWhjC3HjF/5IcIOFCTmGGc0eGPoj8cLHZ8JQVi5jx58r6wnA== X-Received: by 2002:a63:470a:: with SMTP id u10mr2046918pga.346.1642037934349; Wed, 12 Jan 2022 17:38:54 -0800 (PST) Received: from localhost.localdomain (li567-56.members.linode.com. [192.155.81.56]) by smtp.gmail.com with ESMTPSA id b4sm799990pfl.101.2022.01.12.17.38.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 12 Jan 2022 17:38:53 -0800 (PST) From: Jeff Xie To: rostedt@goodmis.org Cc: mhiramat@kernel.org, mingo@redhat.com, zanussi@kernel.org, linux-kernel@vger.kernel.org, Jeff Xie Subject: [PATCH v7 2/4] trace/objtrace: get the value of the object Date: Thu, 13 Jan 2022 09:38:33 +0800 Message-Id: <20220113013835.503285-3-xiehuan09@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220113013835.503285-1-xiehuan09@gmail.com> References: <20220113013835.503285-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 --- kernel/trace/trace.c | 2 +- kernel/trace/trace_entries.h | 5 +- kernel/trace/trace_object.c | 190 +++++++++++++++++++++++++++++------ kernel/trace/trace_output.c | 6 +- 4 files changed, 169 insertions(+), 34 deletions(-) diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c index 0b627963e343..d5332ece4c67 100644 --- a/kernel/trace/trace.c +++ b/kernel/trace/trace.c @@ -5591,7 +5591,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 4af1c117cbfa..774a9dff4d0a 100644 --- a/kernel/trace/trace_object.c +++ b/kernel/trace/trace_object.c @@ -11,7 +11,6 @@ #define MAX_TRACED_OBJECT 5 static DEFINE_RAW_SPINLOCK(trace_obj_lock); static struct trace_event_file event_trace_file; -static const int max_args_num =3D 6; static atomic_t trace_object_ref; static atomic_t num_traced_obj; static int exit_trace_object(void); @@ -19,8 +18,22 @@ static int init_trace_object(void); =20 static struct object_instance { void *obj; + int obj_type_size; } traced_obj[MAX_TRACED_OBJECT]; =20 +/* objtrace private data */ +struct objtrace_trigger_data { + struct ftrace_event_field *field; + int offset; + int obj_type_size; +}; + +/* get the type size for the special object */ +struct objtrace_fetch_type { + char *name; + int type_size; +}; + static bool object_exist(void *obj) { int i, max; @@ -39,7 +52,7 @@ static bool object_empty(void) return !atomic_read(&num_traced_obj); } =20 -static void set_trace_object(void *obj) +static void set_trace_object(void *obj, int obj_type_size) { unsigned long flags; =20 @@ -59,6 +72,7 @@ static void set_trace_object(void *obj) goto out; } traced_obj[atomic_read(&num_traced_obj)].obj =3D obj; + traced_obj[atomic_read(&num_traced_obj)].obj_type_size =3D obj_type_size; /* make sure the num_traced_obj update always appears after traced_obj up= date */ smp_wmb(); atomic_inc(&num_traced_obj); @@ -67,7 +81,7 @@ static void set_trace_object(void *obj) } =20 static void submit_trace_object(unsigned long ip, unsigned long parent_ip, - unsigned long object) + unsigned long object, unsigned long value) { =20 struct trace_buffer *buffer; @@ -84,18 +98,66 @@ static void submit_trace_object(unsigned long ip, unsig= ned long parent_ip, entry->ip =3D ip; entry->parent_ip =3D parent_ip; entry->object =3D object; + entry->value =3D value; =20 event_trigger_unlock_commit(&event_trace_file, buffer, event, entry, pc); } =20 +static inline long get_object_value(unsigned long *val, void *obj, int typ= e_size) +{ + long ret =3D 0; + + switch (type_size) { + case 1: { + u8 tmp; + + ret =3D copy_from_kernel_nofault(&tmp, obj, sizeof(tmp)); + if (ret) + goto out; + *val =3D tmp; + break; + } + case 2: { + u16 tmp; + + ret =3D copy_from_kernel_nofault(&tmp, obj, sizeof(tmp)); + if (ret) + goto out; + *val =3D tmp; + break; + } + case 4: { + u32 tmp; + + ret =3D copy_from_kernel_nofault(&tmp, obj, sizeof(tmp)); + if (ret) + goto out; + *val =3D tmp; + break; + } + case 8: { + u64 tmp; + + ret =3D copy_from_kernel_nofault(&tmp, obj, sizeof(tmp)); + if (ret) + goto out; + *val =3D tmp; + break; + } + default: + return -EINVAL; + } +out: + return ret; +} + 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); - unsigned long obj; - int bit, n; + unsigned long val =3D 0; + int bit, n, max; =20 bit =3D ftrace_test_recursion_trylock(ip, parent_ip); if (bit < 0) @@ -104,11 +166,12 @@ trace_object_events_call(unsigned long ip, unsigned l= ong parent_ip, if (object_empty()) goto out; =20 - for (n =3D 0; n < max_args_num; n++) { - obj =3D regs_get_kernel_argument(pt_regs, n); - if (object_exist((void *)obj)) - submit_trace_object(ip, parent_ip, obj); - /* The parameters of a function may match multiple objects */ + max =3D atomic_read(&num_traced_obj); + smp_rmb(); + for (n =3D 0; n < max; n++) { + if (get_object_value(&val, traced_obj[n].obj, traced_obj[n].obj_type_siz= e)) + goto out; + submit_trace_object(ip, parent_ip, (unsigned long)traced_obj[n].obj, val= ); } out: ftrace_test_recursion_unlock(bit); @@ -124,12 +187,15 @@ 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 ftrace_event_field *field; + void *obj, *val =3D NULL; =20 - struct ftrace_event_field *field =3D data->private_data; - void *obj =3D NULL; - - memcpy(&obj, rec + field->offset, sizeof(obj)); - set_trace_object(obj); + field =3D obj_data->field; + memcpy(&val, rec + field->offset, sizeof(val)); + /* get the final object */ + obj =3D val + obj_data->offset; + set_trace_object(obj, obj_data->obj_type_size); } =20 static void @@ -140,8 +206,10 @@ trace_object_trigger_free(struct event_trigger_ops *op= s, return; =20 data->ref--; - if (!data->ref) + if (!data->ref) { + kfree(data->private_data); trigger_data_free(data); + } } =20 static void @@ -276,6 +344,22 @@ static void unregister_object_trigger(char *glob, stru= ct event_trigger_ops *ops, } } =20 +static const struct objtrace_fetch_type objtrace_fetch_types[] =3D { + {"u8", 1}, + {"s8", 1}, + {"x8", 1}, + {"u16", 2}, + {"s16", 2}, + {"x16", 2}, + {"u32", 4}, + {"s32", 4}, + {"x32", 4}, + {"u64", 8}, + {"s64", 8}, + {"x64", 8}, + {} +}; + static int event_object_trigger_callback(struct event_command *cmd_ops, struct trace_event_file *file, @@ -283,19 +367,22 @@ event_object_trigger_callback(struct event_command *c= md_ops, { struct event_trigger_data *trigger_data; struct event_trigger_ops *trigger_ops; + struct objtrace_trigger_data *obj_data; struct trace_event_call *call; struct ftrace_event_field *field; - char *objtrace_cmd; - char *trigger =3D NULL; - char *arg; - char *number; - int ret; + char *type, *tr, *obj, *tmp, *trigger =3D NULL; + char *number, *objtrace_cmd; + int ret, i, def_type_size, obj_type_size =3D 0; + long offset =3D 0; =20 ret =3D -EINVAL; if (!param) goto out; =20 - /* separate the trigger from the filter (c:a:n [if filter]) */ + /* + * separate the trigger from the filter: + * objtrace:add:OBJ[,OFFS][:TYPE][:COUNT] [if filter] + */ trigger =3D strsep(¶m, " \t"); if (!trigger) goto out; @@ -309,33 +396,79 @@ event_object_trigger_callback(struct event_command *c= md_ops, if (!objtrace_cmd || strcmp(objtrace_cmd, "add")) goto out; =20 - arg =3D strsep(&trigger, ":"); - if (!arg) + obj =3D strsep(&trigger, ":"); + if (!obj) goto out; + + tr =3D strchr(obj, ','); + if (!tr) + offset =3D 0; + else { + *tr++ =3D '\0'; + ret =3D kstrtol(tr, 0, &offset); + if (ret) + goto out; + } + + ret =3D -EINVAL; call =3D file->event_call; - field =3D trace_find_event_field(call, arg); + field =3D trace_find_event_field(call, obj); if (!field) goto out; =20 if (field->size !=3D sizeof(void *)) goto out; + def_type_size =3D sizeof(void *); + if (!trigger) { + obj_type_size =3D def_type_size; + goto skip_get_type; + } =20 + tmp =3D trigger; + type =3D strsep(&trigger, ":"); + if (!type) + obj_type_size =3D def_type_size; + else if (isdigit(type[0])) { + obj_type_size =3D def_type_size; + trigger =3D tmp; + } else { + for (i =3D 0; objtrace_fetch_types[i].name; i++) { + if (strcmp(objtrace_fetch_types[i].name, type) =3D=3D 0) { + obj_type_size =3D objtrace_fetch_types[i].type_size; + break; + } + } + } + if (!obj_type_size) + goto out; +skip_get_type: trigger_ops =3D cmd_ops->get_trigger_ops(cmd, trigger); =20 ret =3D -ENOMEM; + obj_data =3D kzalloc(sizeof(*obj_data), GFP_KERNEL); + if (!obj_data) + goto out; + + obj_data->field =3D field; + obj_data->offset =3D offset; + obj_data->obj_type_size =3D obj_type_size; + trigger_data =3D kzalloc(sizeof(*trigger_data), GFP_KERNEL); - if (!trigger_data) + if (!trigger_data) { + kfree(obj_data); goto out; + } =20 trigger_data->count =3D -1; trigger_data->ops =3D trigger_ops; trigger_data->cmd_ops =3D cmd_ops; - trigger_data->private_data =3D field; + trigger_data->private_data =3D obj_data; INIT_LIST_HEAD(&trigger_data->list); INIT_LIST_HEAD(&trigger_data->named_list); =20 if (glob[0] =3D=3D '!') { cmd_ops->unreg(glob+1, trigger_ops, trigger_data, file); + kfree(obj_data); kfree(trigger_data); ret =3D 0; goto out; @@ -390,6 +523,7 @@ event_object_trigger_callback(struct event_command *cmd= _ops, out_free: if (cmd_ops->set_filter) cmd_ops->set_filter(NULL, trigger_data, NULL); + kfree(obj_data); kfree(trigger_data); goto out; } diff --git a/kernel/trace/trace_output.c b/kernel/trace/trace_output.c index d747aed27104..12a971927d8c 100644 --- a/kernel/trace/trace_output.c +++ b/kernel/trace/trace_output.c @@ -1553,6 +1553,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); @@ -1565,9 +1566,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 Tue Jun 30 16:38:53 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 9B830C433EF for ; Thu, 13 Jan 2022 01:39:17 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231417AbiAMBjQ (ORCPT ); Wed, 12 Jan 2022 20:39:16 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59826 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231406AbiAMBi5 (ORCPT ); Wed, 12 Jan 2022 20:38:57 -0500 Received: from mail-pj1-x1030.google.com (mail-pj1-x1030.google.com [IPv6:2607:f8b0:4864:20::1030]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 9DD41C06173F for ; Wed, 12 Jan 2022 17:38:57 -0800 (PST) Received: by mail-pj1-x1030.google.com with SMTP id n30-20020a17090a5aa100b001b2b6509685so8505852pji.3 for ; Wed, 12 Jan 2022 17:38:57 -0800 (PST) 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=kryIRj8itYCF1TTsF9+Gx7ZLlBZd5qrSWyChaI+fLhg=; b=coAPwOqiiQXqDLnQJHZghIMfurOOSA/kL6ULbmhw0jkGFdTvcflOkqj4RbMWaPBidm G5S0SfDfRQsHUW41U6NyKQ4CHfYCIQ5iTrXWHm+fVd5zFVFi58TaqpLnL9jacFYu8Fff GtKDClPQkFlKU971PtKkeqG6iFj0XKo6ridlM6wfM4XTt2fG7aiCnz9rS8kfUq1c76F9 1KNoNckxuWnQLqzZ7I084YnQZCu9ANVjZy80Z/OwJ/jAs7wAF8t/mILDwkeJ6pAsUKtt nvA4W1ha8lWXrZdXeH6P5WAuKM1gcc+3eL6KRw91GahiAlozoF362MUBtM8k4v5dYnAW 4v2w== 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=kryIRj8itYCF1TTsF9+Gx7ZLlBZd5qrSWyChaI+fLhg=; b=Q0gO11sgrGBTwLbaM2o+8DpVkohq0+myrvCahPJ0Mw+FQDljVrJHk2iotLNN1xfY/B vwSXIq42yORma6BDmHYSTPFZkPg7vc2AV616FP8jsrN8UmZhC47SH2AB2YfzU8/Ij9rN blif4MPM6hNNOxB5XVgdu4TXINlr3x4/cp3NZnlEEblY5YhkPcb3rfTgMd+z8azpHVLm jnulDpaAwXTOHCgRJPSgkCqOEfxPOt0l1qkH6isq/e+KeP0UoLX0ujWYkEsFRjITwKzX CAGU1hYScCLnNEPnNn2kYYVjuWjREHXeJjat01TPcl/5X+k5QL9Tv3KaOthxTE6CElxW h3Vg== X-Gm-Message-State: AOAM533X2+sYK6rniury4Vm6SVN6TXPC2V4yw6KrmcWqNfFwsg5X8vue aPn1uktnkuOyUPHP0Mr7f+Y= X-Google-Smtp-Source: ABdhPJxTcev08Xzdeh3YZqERwYxHpi7tG1M7pgvAu/On7naj+Y+gLn05OPwqS1yLr/o3ltL93GgoBA== X-Received: by 2002:a17:902:c651:b0:148:b0af:6f80 with SMTP id s17-20020a170902c65100b00148b0af6f80mr2206709pls.130.1642037937222; Wed, 12 Jan 2022 17:38:57 -0800 (PST) Received: from localhost.localdomain (li567-56.members.linode.com. [192.155.81.56]) by smtp.gmail.com with ESMTPSA id b4sm799990pfl.101.2022.01.12.17.38.54 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 12 Jan 2022 17:38:56 -0800 (PST) From: Jeff Xie To: rostedt@goodmis.org Cc: mhiramat@kernel.org, mingo@redhat.com, zanussi@kernel.org, linux-kernel@vger.kernel.org, Jeff Xie Subject: [PATCH v7 3/4] trace/objtrace: Add testcases for objtrace Date: Thu, 13 Jan 2022 09:38:34 +0800 Message-Id: <20220113013835.503285-4-xiehuan09@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220113013835.503285-1-xiehuan09@gmail.com> References: <20220113013835.503285-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. Signed-off-by: Jeff Xie --- .../ftrace/test.d/trigger/trigger-objtrace.tc | 39 +++++++++++++++++++ 1 file changed, 39 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..d71eb157c51f --- /dev/null +++ b/tools/testing/selftests/ftrace/test.d/trigger/trigger-objtrace.tc @@ -0,0 +1,39 @@ +#!/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' > 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 + +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 Tue Jun 30 16:38:53 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 25BAEC433F5 for ; Thu, 13 Jan 2022 01:39:19 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231404AbiAMBjS (ORCPT ); Wed, 12 Jan 2022 20:39:18 -0500 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:59842 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231388AbiAMBjB (ORCPT ); Wed, 12 Jan 2022 20:39:01 -0500 Received: from mail-pj1-x102d.google.com (mail-pj1-x102d.google.com [IPv6:2607:f8b0:4864:20::102d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 9DF8BC061751 for ; Wed, 12 Jan 2022 17:39:00 -0800 (PST) Received: by mail-pj1-x102d.google.com with SMTP id 59-20020a17090a09c100b001b34a13745eso16022652pjo.5 for ; Wed, 12 Jan 2022 17:39:00 -0800 (PST) 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=d70MY5lEBmu1XtB6lDZrJCZ/ytxDWn0OrAuqeIp5b3w=; b=AqxT7TnsbYfIukbc3pj25IEx3b5q0QujB0q1L6XEIwTMTShu+R9ew6DHKqWVp7Izaz MIbffhsi9QrnlDFqV5hns19goyWoP6qiNFh0ttgJPsrkZP4goLQkp8qzFnwlmgWEe/A4 yfXoZ0ZFfqaPLAe7Rt/CE7cdlaPFiFv8J+1M2SVrDtu5tJAcphjmqVOY1fp8DJ5MCf1/ Ixy6X+FVROGavIfjTXsa0JfFXrNYmRDaF32Sy1fscjhYRAkDWuOL3XA5/f6AKuFdtyH1 iS7mlnY4Ynpf3yK7UKKonoZiuPzJBHiZMXw/qtHJdljhG2tVZ6graoSA0rHoH3WnUGUF a4rw== 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=d70MY5lEBmu1XtB6lDZrJCZ/ytxDWn0OrAuqeIp5b3w=; b=rt3yiFRJo0x4Hc0IV5O0hlR6It05hDBwcUnhRe1pREBqHVcB1qanq1upL1HuklVRHh M3TAmBhGq1lnewbg1ozvOd/TGbKat04ravm9BJVS523ZUcsDCZu/xx4TD2ay5jdRh2VH jc/5sHfB2VfLeJvFIdOYewXgbknxJPSPUtf4Jp/QLacu5OHo+TuQIUUTcaQzfmeXpchE BKqPXWPpG0Epj2BaUqmxurX2gNL96ibLa1jEoE+6gY6PXvP1EXvwtBmDp8evtj0tk9t0 QKJMnpoSF4oUAzdYPZE8OEZJz7a9+Byr2pLxLDK5pUPplgvL9l7N0Eek54oHg+XkLUio ffIQ== X-Gm-Message-State: AOAM531t7iZYtYHzew3TgbN20a/tlGNo6uDwVUZV0kz2b213zNDvUOuj D90NU/NUP83/TgXu2Hp4f+U= X-Google-Smtp-Source: ABdhPJzuEUaVh3pEygB6vOGFoDOh84RNuVIFV7txie9lTE2q4ZRWCoCLJAxyQ2yUf1AYsfpaGcKq3Q== X-Received: by 2002:a17:90b:4d0e:: with SMTP id mw14mr12126213pjb.44.1642037940170; Wed, 12 Jan 2022 17:39:00 -0800 (PST) Received: from localhost.localdomain (li567-56.members.linode.com. [192.155.81.56]) by smtp.gmail.com with ESMTPSA id b4sm799990pfl.101.2022.01.12.17.38.57 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 12 Jan 2022 17:38:59 -0800 (PST) From: Jeff Xie To: rostedt@goodmis.org Cc: mhiramat@kernel.org, mingo@redhat.com, zanussi@kernel.org, linux-kernel@vger.kernel.org, Jeff Xie Subject: [PATCH v7 4/4] trace/objtrace: Add documentation for objtrace Date: Thu, 13 Jan 2022 09:38:35 +0800 Message-Id: <20220113013835.503285-5-xiehuan09@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20220113013835.503285-1-xiehuan09@gmail.com> References: <20220113013835.503285-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" Added documentation explaining how to use objtrace trigger to get the value of the object. Signed-off-by: Jeff Xie --- Documentation/trace/events.rst | 114 +++++++++++++++++++++++++++++++++ 1 file changed, 114 insertions(+) diff --git a/Documentation/trace/events.rst b/Documentation/trace/events.rst index 8ddb9b09451c..5e5d5dc31ad2 100644 --- a/Documentation/trace/events.rst +++ b/Documentation/trace/events.rst @@ -527,6 +527,120 @@ 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, only need to set the objtrace(a new trigger= ), + we can get the value of the object. The object is from the setting of the + kprobe event. + + For example: + For the function bio_add_page(): + + 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, thus the first string "arg1" + stands for the value of the first parameter of this function bio_add_gag= e(), + + # echo 'p bio_add_page arg1=3D$arg1' >> ./kprobe_events + + Secondly, we can get the value dynamically base the above object. + + 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/kp= robes/ \ + p_bio_add_page_0/trigger + + The best way to use this is that we can set the entrance event and exit + event, for example, the following example is to set the read_papes as + the entrance event, and set the __blk_account_io_start as the exit event. + + # cd /sys/kernel/debug/tracing/ + # echo 0 > ./tracing_on + # echo 'p read_pages' >> ./kprobe_events + # echo 'p __blk_account_io_start' >> ./kprobe_events + # echo 'traceon if comm =3D=3D "cat"' > ./events/kprobes/p_read_pages_0/= trigger + # echo 'traceoff if comm =3D=3D "cat"' > ./events/kprobes/p___blk_accoun= t_io_start_0/trigger + # echo 'p bio_add_page arg1=3D$arg1' >> ./kprobe_events + # echo 'objtrace:add:arg1,0x28:u32:1 if comm =3D=3D "cat"' > ./events/kp= robes/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: 50/50 #P:1 + # + # _-----=3D> irqs-off + # / _----=3D> need-resched + # | / _---=3D> hardirq/softirq + # || / _--=3D> preempt-depth + # ||| / _-=3D> migrate-disable + # |||| / delay + # TASK-PID CPU# ||||| TIMESTAMP FUNCTION + # | | | ||||| | | + cat-95 [000] ..... 1.412065: _raw_spin_unlock_irqres= tore <-event_triggers_call object:0xffff888108af6328 value:0x0 + cat-95 [000] ..... 1.412066: __bio_try_merge_page <-= bio_add_page object:0xffff888108af6328 value:0x0 + cat-95 [000] ..... 1.412066: __bio_add_page <-bio_ad= d_page object:0xffff888108af6328 value:0x0 + cat-95 [000] ..... 1.412066: rcu_read_unlock_strict = <-xa_load object:0xffff888108af6328 value:0x1000 + cat-95 [000] ..... 1.412066: bio_add_page <-ext4_mpa= ge_readpages object:0xffff888108af6328 value:0x1000 + cat-95 [000] ..... 1.412066: kprobe_ftrace_handler <= -ftrace_ops_list_func object:0xffff888108af6328 value:0x1000 + cat-95 [000] ..... 1.412067: get_kprobe <-kprobe_ftr= ace_handler object:0xffff888108af6328 value:0x1000 + cat-95 [000] ..... 1.412067: __bio_try_merge_page <-= bio_add_page object:0xffff888108af6328 value:0x1000 + cat-95 [000] ..... 1.412067: __bio_add_page <-bio_ad= d_page object:0xffff888108af6328 value:0x1000 + cat-95 [000] ..... 1.412067: rcu_read_unlock_strict = <-xa_load object:0xffff888108af6328 value:0x2000 + cat-95 [000] ..... 1.412067: bio_add_page <-ext4_mpa= ge_readpages object:0xffff888108af6328 value:0x2000 + cat-95 [000] ..... 1.412067: kprobe_ftrace_handler <= -ftrace_ops_list_func object:0xffff888108af6328 value:0x2000 + cat-95 [000] ..... 1.412067: get_kprobe <-kprobe_ftr= ace_handler object:0xffff888108af6328 value:0x2000 + cat-95 [000] ..... 1.412067: __bio_try_merge_page <-= bio_add_page object:0xffff888108af6328 value:0x2000 + cat-95 [000] ..... 1.412068: submit_bio <-ext4_mpage= _readpages object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412068: submit_bio_noacct <-ext= 4_mpage_readpages object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412068: __submit_bio <-submit_b= io_noacct object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412068: blk_try_enter_queue <-_= _submit_bio object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412068: rcu_read_unlock_strict = <-blk_try_enter_queue object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412068: rcu_read_unlock_strict = <-blk_try_enter_queue object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412068: submit_bio_checks <-__s= ubmit_bio object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412068: __cond_resched <-submit= _bio_checks object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412068: rcu_all_qs <-__cond_res= ched object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412068: should_fail_bio <-submi= t_bio_checks object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412069: create_task_io_context = <-submit_bio_checks object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412069: kmem_cache_alloc_node <= -create_task_io_context object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412069: should_failslab <-kmem_= cache_alloc_node object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412069: _raw_spin_lock <-create= _task_io_context object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412069: blk_mq_submit_bio <-__s= ubmit_bio object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412069: __blk_queue_split <-blk= _mq_submit_bio object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412069: bvec_split_segs <-__blk= _queue_split object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412069: blk_attempt_plug_merge = <-blk_mq_submit_bio object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412070: __blk_mq_sched_bio_merg= e <-blk_mq_submit_bio object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412070: dd_bio_merge <-blk_mq_s= ubmit_bio object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412070: _raw_spin_lock <-dd_bio= _merge object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412070: blk_mq_sched_try_merge = <-dd_bio_merge object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412070: elv_merge <-blk_mq_sche= d_try_merge object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412070: elv_rqhash_find <-elv_m= erge object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412070: dd_request_merge <-blk_= mq_sched_try_merge object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412070: elv_rb_find <-dd_reques= t_merge object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412070: __blk_mq_alloc_request = <-blk_mq_submit_bio object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412071: dd_limit_depth <-__blk_= mq_alloc_request object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412071: blk_mq_get_tag <-__blk_= mq_alloc_request object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412071: __blk_mq_get_tag <-blk_= mq_get_tag object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412071: blk_mq_rq_ctx_init.isra= .0 <-blk_mq_submit_bio object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412071: ktime_get <-blk_mq_rq_c= tx_init.isra.0 object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412071: dd_prepare_request <-bl= k_mq_rq_ctx_init.isra.0 object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412071: __blk_account_io_start = <-blk_mq_submit_bio object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412071: kprobe_ftrace_handler <= -ftrace_ops_list_func object:0xffff888108af6328 value:0x3000 + cat-95 [000] ..... 1.412071: get_kprobe <-kprobe_ftr= ace_handler object:0xffff888108af6328 value:0x3000 + 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