From patchwork Mon Mar 28 09:03:45 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Tzvetomir Stoyanov (VMware)" X-Patchwork-Id: 12793314 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 04D5FC433F5 for ; Mon, 28 Mar 2022 09:03:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239631AbiC1JFg (ORCPT ); Mon, 28 Mar 2022 05:05:36 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32846 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239028AbiC1JFe (ORCPT ); Mon, 28 Mar 2022 05:05:34 -0400 Received: from mail-ej1-x629.google.com (mail-ej1-x629.google.com [IPv6:2a00:1450:4864:20::629]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id EC4F76348 for ; Mon, 28 Mar 2022 02:03:52 -0700 (PDT) Received: by mail-ej1-x629.google.com with SMTP id bi12so27270384ejb.3 for ; Mon, 28 Mar 2022 02:03:52 -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=kBhj0/NEgUimxIMkQ24jodTD6TZd71mZRuPIpmP3CmE=; b=mkuzrO1PUSmQKulmFByfKpqCFKlRbwX1rQRDw71N5SPjGcuNbdJwXK28cLMCjEMUuh 6PFrl03X0OKb056vdbHZbrvpS1N6NlE9yJkDrfKNnMkTmosYEw9m99TbAgzzNZO/Xa8G W1JV0pBZ+cMThz9moY8++DtzCGKHZAOqSEgXXgqgjzkgtUP0o1XGq99n9JiWJtKKeANS dm7swNc3DDgNf3WTtAjivrtJLsitwaxAh3+svVnj56JcAbJJxCEhFPoiFKuGB7gKQMu3 RgXBA4c5rUoboQjv6D/xLFhHDvKSUOOXctMOY1ny/2LXLROXT6va19YjBRFnihxkskaL Z4Jw== 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=kBhj0/NEgUimxIMkQ24jodTD6TZd71mZRuPIpmP3CmE=; b=NgcYGzeaMdtOAY+dH4YQAz2RWlWgmGiUQWaSvG/CX2z3onA1u2r/JTeixrm18wHBOX Ir9808cT3Y+6KJ0j+Aegj7GXQDb3YpWk08IIFivcHFyshN2BsAHfBi6pK4bpdX7ecwoS 7OYedeIWDcyuJBCvAZe99nS+70UtYGZLxHoVXeFshY6jIwKyXmbTv/QzdzCnn/+OyBf1 NufgvGIvVfn4gfDCqT3QOuMZ9OhL1y4wUSFjlI7jJB9a/up4DbZk2c6znYFYcpXQaRBv vsw3pdbboetIWYibilf7h1LH5C5YGHRVT7NT6cJheaSV/gFmJk5CV5Y/RodVFGjCrzHs Gn2Q== X-Gm-Message-State: AOAM530L84zlmYdKjorCr+e2MALaPiuey+OECDjWqM2Mr+yFmMHh2Onr R2R229ClHFFMbFCGThWKBUixSO7WE5E= X-Google-Smtp-Source: ABdhPJyOPdeaWH48XnZKRpjFIFRbceNWjXp9UmqPeQF8sPT3wqf6cMWHy2Uy83VdVs4WIKhrXnDBew== X-Received: by 2002:a17:906:9c8e:b0:6df:f6bf:7902 with SMTP id fj14-20020a1709069c8e00b006dff6bf7902mr26317365ejc.191.1648458231357; Mon, 28 Mar 2022 02:03:51 -0700 (PDT) Received: from oberon.zico.biz ([83.222.187.186]) by smtp.gmail.com with ESMTPSA id dm11-20020a170907948b00b006cf488e72e3sm5647973ejc.25.2022.03.28.02.03.50 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 28 Mar 2022 02:03:50 -0700 (PDT) From: "Tzvetomir Stoyanov (VMware)" To: rostedt@goodmis.org Cc: linux-trace-devel@vger.kernel.org Subject: [PATCH 1/3] libtracefs: New APIs for ftrace uprobes Date: Mon, 28 Mar 2022 12:03:45 +0300 Message-Id: <20220328090347.107849-2-tz.stoyanov@gmail.com> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220328090347.107849-1-tz.stoyanov@gmail.com> References: <20220328090347.107849-1-tz.stoyanov@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-trace-devel@vger.kernel.org The tracefs library has APIs for allocating almost all types of ftrace dynamic events. Uprobe is the only dynamic event that has no corresponding tracefs API. These two APIs are proposed: tracefs_uprobe_alloc() tracefs_uretprobe_alloc() They allocate context for new uprobe/uretprobe, without creating events in the system. The regular dynamic events APIs can be used to work with newly created uprobes. Signed-off-by: Tzvetomir Stoyanov (VMware) --- include/tracefs.h | 6 +++ src/Makefile | 1 + src/tracefs-uprobes.c | 90 +++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 97 insertions(+) create mode 100644 src/tracefs-uprobes.c diff --git a/include/tracefs.h b/include/tracefs.h index 05f3352..27954a4 100644 --- a/include/tracefs.h +++ b/include/tracefs.h @@ -280,6 +280,12 @@ tracefs_dynevent_get_event(struct tep_handle *tep, struct tracefs_dynevent *dyne struct tracefs_dynevent * tracefs_eprobe_alloc(const char *system, const char *event, const char *target_system, const char *target_event, const char *fetchargs); +struct tracefs_dynevent * +tracefs_uprobe_alloc(const char *system, const char *event, + const char *file, unsigned long long offset, const char *fetchargs); +struct tracefs_dynevent * +tracefs_uretprobe_alloc(const char *system, const char *event, + const char *file, unsigned long long offset, const char *fetchargs); struct tracefs_dynevent * tracefs_kprobe_alloc(const char *system, const char *event, const char *addr, const char *format); diff --git a/src/Makefile b/src/Makefile index e8afab5..645d518 100644 --- a/src/Makefile +++ b/src/Makefile @@ -13,6 +13,7 @@ OBJS += tracefs-hist.o OBJS += tracefs-filter.o OBJS += tracefs-dynevents.o OBJS += tracefs-eprobes.o +OBJS += tracefs-uprobes.o # Order matters for the the three below OBJS += sqlhist-lex.o diff --git a/src/tracefs-uprobes.c b/src/tracefs-uprobes.c new file mode 100644 index 0000000..aa39b75 --- /dev/null +++ b/src/tracefs-uprobes.c @@ -0,0 +1,90 @@ +// SPDX-License-Identifier: LGPL-2.1 +/* + * Copyright (C) 2022, VMware, Tzvetomir Stoyanov + * + */ +#include +#include + +#include "tracefs.h" +#include "tracefs-local.h" + +#define UPROBE_DEFAULT_GROUP "uprobes" + +static struct tracefs_dynevent * +uprobe_alloc(enum tracefs_dynevent_type type, const char *system, const char *event, + const char *file, unsigned long long offset, const char *fetchargs) +{ + struct tracefs_dynevent *kp; + char *target; + + if (!event || !file) { + errno = EINVAL; + return NULL; + } + + if (!system) + system = UPROBE_DEFAULT_GROUP; + + if (asprintf(&target, "%s:0x%0*llx", file, (int)(sizeof(void *) * 2), offset) < 0) + return NULL; + + kp = dynevent_alloc(type, system, event, target, fetchargs); + free(target); + + return kp; +} + +/** + * tracefs_uprobe_alloc - Allocate new user probe (uprobe) + * @system: The system name (NULL for the default uprobes) + * @event: The name of the event to create + * @file: The full path to the binary file, where the uprobe will be set + * @offset: Offset within the @file + * @fetchargs: String with arguments, that will be fetched with the uprobe + * + * Allocate new uprobe context that will be in the @system group + * (or uprobes if @system is NULL) and with @event name. The new uprobe will be + * attached to @offset within the @file. The arguments described in @fetchargs + * will fetched with the uprobe. See linux/Documentation/trace/uprobetracer.rst + * for more details. + * + * The uprobe is not created in the system. + * + * Return a pointer to a uprobe context on success, or NULL on error. + * The returned pointer must be freed with tracefs_dynevent_free() + * + */ +struct tracefs_dynevent * +tracefs_uprobe_alloc(const char *system, const char *event, + const char *file, unsigned long long offset, const char *fetchargs) +{ + return uprobe_alloc(TRACEFS_DYNEVENT_UPROBE, system, event, file, offset, fetchargs); +} + +/** + * tracefs_uretprobe_alloc - Allocate new user return probe (uretprobe) + * @system: The system name (NULL for the default uprobes) + * @event: The name of the event to create + * @file: The full path to the binary file, where the uretprobe will be set + * @offset: Offset within the @file + * @fetchargs: String with arguments, that will be fetched with the uretprobe + * + * Allocate mew uretprobe context that will be in the @system group + * (or uprobes if @system is NULL) and with @event name. The new uretprobe will + * be attached to @offset within the @file. The arguments described in @fetchargs + * will fetched with the uprobe. See linux/Documentation/trace/uprobetracer.rst + * for more details. + * + * The uretprobe is not created in the system. + * + * Return a pointer to a uretprobe context on success, or NULL on error. + * The returned pointer must be freed with tracefs_dynevent_free() + * + */ +struct tracefs_dynevent * +tracefs_uretprobe_alloc(const char *system, const char *event, + const char *file, unsigned long long offset, const char *fetchargs) +{ + return uprobe_alloc(TRACEFS_DYNEVENT_URETPROBE, system, event, file, offset, fetchargs); +} From patchwork Mon Mar 28 09:03:46 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Tzvetomir Stoyanov (VMware)" X-Patchwork-Id: 12793315 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 A7F69C433FE for ; Mon, 28 Mar 2022 09:03:58 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239028AbiC1JFg (ORCPT ); Mon, 28 Mar 2022 05:05:36 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32908 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S231442AbiC1JFe (ORCPT ); Mon, 28 Mar 2022 05:05:34 -0400 Received: from mail-ej1-x62d.google.com (mail-ej1-x62d.google.com [IPv6:2a00:1450:4864:20::62d]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 099016353 for ; Mon, 28 Mar 2022 02:03:54 -0700 (PDT) Received: by mail-ej1-x62d.google.com with SMTP id bq8so13252740ejb.10 for ; Mon, 28 Mar 2022 02:03:53 -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=K/W6b4CszSD1CvgOsspLEaJRiT44hTPeugvoHnhQJiI=; b=B/+lOV8CGGaKfrjWsLt+hYYst/Ej5BsOecYZB2jPv5bgn7GbHY1xS69kRKP7/LzBds W3oz6MlFqRJIqOHYa+TTRPBqZ4KkR5M8yKIf/WUDkNaRsIoYvZnYZUvepFhg6KTW3O1m PjwZA4ek2HtBFSaj9/JqXZwRAwHTi7SAfS6HC577z6qm5aRCrZI1dbY8jLeVc0TWzgu8 KnH44zGEAgIbA0yFHpi935lzXRuRFUMNdwTVRBX+nXFr/6x9laMJvHfcSWUm4CIOuEYz ULx0q8ocotQBw61osva8jAMyfe0N3E4ndbN7RTt5w9nh9/ozapvtbFfsY731xCS1J+c3 wTDw== 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=K/W6b4CszSD1CvgOsspLEaJRiT44hTPeugvoHnhQJiI=; b=FNB6k93VpadxfKCD5tC7lHtZ2WMF4s4aAW1uiVHV5STzG3yL8VCgcCSo2R75Ukm+/t hvHzMG/SG97/bT3KJbnrzYxbPZUDhIdhg+Hro1wGw0XjYZR0C0iVaYIUAzPWnGGwE9gn 2KP5F0xok+EBYFtwAnBcLh67/gqMa3hcV4Wnvk7v3adheiUsl3mY5yAZ/gvy/vRzT/BO 5tTjAT/UtVn+br7+SrpjeagnVHGiVrIkjLkJPTqX4q6vrzQfk8V7353LnapoBjqAMZZ4 iOYrh1vSBs7EljSQ1czSE7eIzvVCm0RssiX0UooWUkSrUvzi/3U3zzUkxai9+uzrtSxR D8IA== X-Gm-Message-State: AOAM532KXSX42MnoNTO06BysF+p19R9yx+4Ld/pl677gMY978LBqyYts lw23bKT6yDhp7qoi9PC69jzSTXfsZ1E= X-Google-Smtp-Source: ABdhPJzz2ZB3df0LwbH6EnrmZl/C/9AfTAa4cJ3uNbEexa4xbhjwKfTv6Ab5tYd+bdFnWZ3LpIGQxg== X-Received: by 2002:a17:907:8687:b0:6d7:8f6a:3c0e with SMTP id qa7-20020a170907868700b006d78f6a3c0emr26303138ejc.500.1648458232555; Mon, 28 Mar 2022 02:03:52 -0700 (PDT) Received: from oberon.zico.biz ([83.222.187.186]) by smtp.gmail.com with ESMTPSA id dm11-20020a170907948b00b006cf488e72e3sm5647973ejc.25.2022.03.28.02.03.51 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 28 Mar 2022 02:03:51 -0700 (PDT) From: "Tzvetomir Stoyanov (VMware)" To: rostedt@goodmis.org Cc: linux-trace-devel@vger.kernel.org Subject: [PATCH 2/3] libtracefs: Document uprobes APIs Date: Mon, 28 Mar 2022 12:03:46 +0300 Message-Id: <20220328090347.107849-3-tz.stoyanov@gmail.com> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220328090347.107849-1-tz.stoyanov@gmail.com> References: <20220328090347.107849-1-tz.stoyanov@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-trace-devel@vger.kernel.org The newly introduced uprobe APIs should be described in a man page. Signed-off-by: Tzvetomir Stoyanov (VMware) --- Documentation/libtracefs-uprobes.txt | 188 +++++++++++++++++++++++++++ 1 file changed, 188 insertions(+) create mode 100644 Documentation/libtracefs-uprobes.txt diff --git a/Documentation/libtracefs-uprobes.txt b/Documentation/libtracefs-uprobes.txt new file mode 100644 index 0000000..dae0fc9 --- /dev/null +++ b/Documentation/libtracefs-uprobes.txt @@ -0,0 +1,188 @@ +libtracefs(3) +============= + +NAME +---- +tracefs_uprobe_alloc,tracefs_uretprobe_alloc - Allocate new user (return) probe + +SYNOPSIS +-------- +[verse] +-- +*#include * + +struct tracefs_dynevent pass:[*] +*tracefs_uprobe_alloc*(const char pass:[*]_system_, const char pass:[*]_event_, + const char pass:[*]_file_, unsigned long long _offset_, const char pass:[*]_fetchargs_) +struct tracefs_dynevent pass:[*] +*tracefs_uretprobe_alloc*(const char pass:[*]_system_, const char pass:[*]_event_, + const char pass:[*]_file_, unsigned long long _offset_, const char pass:[*]_fetchargs_) +-- + +DESCRIPTION +----------- +*tracefs_uprobe_alloc*() allocates a new uprobe context. It will be in the _system_ group +(or uprobes if _system_ is NULL) and with _event_ name. The uprobe will be attached to _offset_ +within the _file_. The list of arguments, described in _fetchargs_, will be fetched with the uprobe. +The returned pointer to the user probe context must be freed with *tracefs_dynevent_free*(). +The ubrobe is not configured in the system, tracefs_dynevent_* set of APIs can be used to configure +it. + +The *tracefs_uretprobe_alloc*() behaves the same as *tracefs_uprobe_alloc*(), the only difference is +that it allocates context to user return probe (uretprobe). + +RETURN VALUE +------------ +The *tracefs_uprobe_alloc*() and *tracefs_uretprobe_alloc*() APIs return a pointer to an allocated +tracefs_dynevent structure, describing the user probe. This pointer must be freed with +*tracefs_dynevent_free*(3). Note, this only allocates a descriptor representing the uprobe. It does +not modify the running system. On error NULL is returned. + +EXAMPLE +------- +[source,c] +-- + +#include +#include +#include + +#include + +static int callback(struct tep_event *event, struct tep_record *record, + int cpu, void *data) +{ + struct trace_seq seq; + + trace_seq_init(&seq); + tep_print_event(event->tep, &seq, record, "%d-%s: %s", + TEP_PRINT_PID, TEP_PRINT_COMM, TEP_PRINT_NAME); + trace_seq_puts(&seq, "'\n"); + + trace_seq_terminate(&seq); + trace_seq_do_printf(&seq); + trace_seq_destroy(&seq); + + return 0; +} + +static pid_t run_exec(char **argv, char **env) +{ + pid_t pid; + + pid = fork(); + if (pid) + return pid; + + execve(argv[0], argv, env); + perror("exec"); + exit(-1); +} + +const char *myprobe = "my_urobes"; + +int main (int argc, char **argv, char **env) +{ + struct tracefs_dynevent *uprobe, *uretprobe; + struct tep_handle *tep; + struct tracefs_instance *instance; + const char *sysnames[] = { myprobe, NULL }; + long addr; + pid_t pid; + + if (argc < 3) { + printf("usage: %s file_offset command\n", argv[0]); + exit(-1); + } + addr = strtol(argv[1], NULL, 0); + + instance = tracefs_instance_create("exec_open"); + if (!instance) { + perror("creating instance"); + exit(-1); + } + + tracefs_dynevent_destroy_all(TRACEFS_DYNEVENT_UPROBE|TRACEFS_DYNEVENT_URETPROBE, true); + + uprobe = tracefs_uprobe_alloc(myprobe, "user_probe", argv[2], addr, NULL); + uretprobe = tracefs_uretprobe_alloc(myprobe, "user_retprobe", argv[2], addr, NULL); + if (!uprobe || !uretprobe) { + perror("allocating user probes"); + exit(-1); + } + + if (tracefs_dynevent_create(uprobe) || + tracefs_dynevent_create(uretprobe)) { + perror("creating user probes"); + exit(-1); + } + + tep = tracefs_local_events_system(NULL, sysnames); + if (!tep) { + perror("reading events"); + exit(-1); + } + + tracefs_event_enable(instance, myprobe, "user_probe"); + tracefs_event_enable(instance, myprobe, "user_retprobe"); + + pid = run_exec(&argv[2], env); + + /* Let the child start to run */ + sched_yield(); + + do { + tracefs_load_cmdlines(NULL, tep); + tracefs_iterate_raw_events(tep, instance, NULL, 0, callback, NULL); + } while (waitpid(pid, NULL, WNOHANG) != pid); + + /* disable and destroy the events */ + tracefs_dynevent_destroy(uprobe, true); + tracefs_dynevent_destroy(uretprobe, true); + tracefs_dynevent_free(uprobe); + tracefs_dynevent_free(uretprobe); + tracefs_instance_destroy(instance); + + return 0; +-- + +FILES +----- +[verse] +-- +*tracefs.h* + Header file to include in order to have access to the library APIs. +*-ltracefs* + Linker switch to add when building a program that uses the library. +-- + +SEE ALSO +-------- +*libtracefs*(3), +*libtraceevent*(3), +*trace-cmd*(1) + +AUTHOR +------ +[verse] +-- +*Steven Rostedt* +*Tzvetomir Stoyanov* +-- + +REPORTING BUGS +-------------- +Report bugs to + +LICENSE +------- +libtracefs is Free Software licensed under the GNU LGPL 2.1 + +RESOURCES +--------- +https://git.kernel.org/pub/scm/libs/libtrace/libtracefs.git/ + +COPYING +------- +Copyright \(C) 2022 VMware, Inc. Free use of this software is granted under +the terms of the GNU Public License (GPL). From patchwork Mon Mar 28 09:03:47 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "Tzvetomir Stoyanov (VMware)" X-Patchwork-Id: 12793316 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 46D9BC433EF for ; Mon, 28 Mar 2022 09:04:02 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239632AbiC1JFk (ORCPT ); Mon, 28 Mar 2022 05:05:40 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:33058 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239637AbiC1JFi (ORCPT ); Mon, 28 Mar 2022 05:05:38 -0400 Received: from mail-ed1-x534.google.com (mail-ed1-x534.google.com [IPv6:2a00:1450:4864:20::534]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 9B5FE6356 for ; Mon, 28 Mar 2022 02:03:55 -0700 (PDT) Received: by mail-ed1-x534.google.com with SMTP id u26so16057509eda.12 for ; Mon, 28 Mar 2022 02:03:54 -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=4cQlmkS7/uVCOtTEk8cBfqFy5x6T1JTgV+3GShSO0KI=; b=Fe6TwUiljdxIYdJxTRf8oeNNlYEnq5dJMTxS5NvriqySviel97BxTfjm/dg+9wDJAJ fjGVyKe7hgIYP1EMUilIPIQ6BnsdO91Z+dTk3S09U/cyprA9ul5AS/P4DDtiOmtHr+vt cxosgzETjQmucUlyHVwWh2QWetSAKuizsbl5KTchB1/RtZC1+Dt0U0VQmSW27pWHVbDt QzIglqzh4grt/T3fSZQ94NK+P9xiELapZ7YGaeTml7xYbwLQZCuUyPyDqm6ePXLqW39n zSrh0IWnzfImi/04MdZGh0GFHloTluQ0y5PmrRcvCprzsagSob0+WeRp6o2zPylyj4n/ Lkmg== 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=4cQlmkS7/uVCOtTEk8cBfqFy5x6T1JTgV+3GShSO0KI=; b=vsy08KZxWnqVLm1UQDs0EKs/RH15IbTUh32yA7U7hFlFhDTRlstAhoeFweV+GHC1ap MqyKRN0NtZzNBLUM9vjziprLuCBpXb7G6lsz+VXIL4rnXeX3Y52jfHAidHosXJ5RtoV5 dMDlyGPXlxX3u88BNBCqD4XNEBmV17T5MtPrdJMx9g1FuWsOondCBrQL1F4CaN1h1Ck5 P6Ty4vH6Xa+bsSingZkgPzEVZTGJ5j/BM4lvK7jBYdvPYEK2mJcSnJPLrqEA8bsCE/e9 ybxEg7MvgOTinypr+9AqQ1ptydfTBR57BGpBxNvC30E5CE4opDgcAd14ho759Z8YN44A XH7g== X-Gm-Message-State: AOAM532YUjQy1cus6GvtZAoe7RZQQYMmHDKd3Inub88kJSc6Ck8Bvey/ PY+e1W5rcKlhBSIjXq6OWv/JgOCGi90= X-Google-Smtp-Source: ABdhPJz+HoZTYolv6giDHYYlrdQ4++Q6+IsZZdn52Z/paGA7Lz7slRa599Hao1HCIc4DKidhagFs2w== X-Received: by 2002:a05:6402:492:b0:404:c4bf:8b7e with SMTP id k18-20020a056402049200b00404c4bf8b7emr14425248edv.318.1648458233560; Mon, 28 Mar 2022 02:03:53 -0700 (PDT) Received: from oberon.zico.biz ([83.222.187.186]) by smtp.gmail.com with ESMTPSA id dm11-20020a170907948b00b006cf488e72e3sm5647973ejc.25.2022.03.28.02.03.52 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 28 Mar 2022 02:03:53 -0700 (PDT) From: "Tzvetomir Stoyanov (VMware)" To: rostedt@goodmis.org Cc: linux-trace-devel@vger.kernel.org Subject: [PATCH 3/3] libtracefs: Unit tests for uprobes APIs Date: Mon, 28 Mar 2022 12:03:47 +0300 Message-Id: <20220328090347.107849-4-tz.stoyanov@gmail.com> X-Mailer: git-send-email 2.35.1 In-Reply-To: <20220328090347.107849-1-tz.stoyanov@gmail.com> References: <20220328090347.107849-1-tz.stoyanov@gmail.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-trace-devel@vger.kernel.org The newly introduced uprobes APIs should be covered by the library unit tests. Signed-off-by: Tzvetomir Stoyanov (VMware) --- utest/tracefs-utest.c | 74 +++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 74 insertions(+) diff --git a/utest/tracefs-utest.c b/utest/tracefs-utest.c index 7042fa9..3f63837 100644 --- a/utest/tracefs-utest.c +++ b/utest/tracefs-utest.c @@ -873,6 +873,79 @@ static void test_eprobes(void) test_eprobes_instance(test_instance); } +#define FOFFSET 1000ll +static void test_uprobes_instance(struct tracefs_instance *instance) +{ + struct probe_test utests[] = { + { TRACEFS_DYNEVENT_UPROBE, "p", "utest", "utest_u", NULL, "arg1=$stack2" }, + { TRACEFS_DYNEVENT_URETPROBE, "r", "utest", "utest_r", NULL, "arg1=$retval" }, + }; + int count = sizeof(utests) / sizeof((utests)[0]); + struct tracefs_dynevent **duprobes; + struct tracefs_dynevent **duvents; + char self[PATH_MAX] = { 0 }; + struct tep_handle *tep; + char *target = NULL; + int i; + + tep = tep_alloc(); + CU_TEST(tep != NULL); + + duprobes = calloc(count + 1, sizeof(*duvents)); + CU_TEST(duprobes != NULL); + CU_TEST(readlink("/proc/self/exe", self, sizeof(self)) > 0); + CU_TEST(asprintf(&target, "%s:0x%0*llx", self, (int)(sizeof(void *) * 2), FOFFSET) > 0); + + for (i = 0; i < count; i++) + utests[i].address = target; + + /* Invalid parameters */ + CU_TEST(tracefs_uprobe_alloc(NULL, NULL, self, 0, NULL) == NULL); + CU_TEST(tracefs_uprobe_alloc(NULL, "test", NULL, 0, NULL) == NULL); + CU_TEST(tracefs_uretprobe_alloc(NULL, NULL, self, 0, NULL) == NULL); + CU_TEST(tracefs_uretprobe_alloc(NULL, "test", NULL, 0, NULL) == NULL); + + for (i = 0; i < count; i++) { + if (utests[i].type == TRACEFS_DYNEVENT_UPROBE) + duprobes[i] = tracefs_uprobe_alloc(utests[i].system, utests[i].event, + self, FOFFSET, utests[i].format); + else + duprobes[i] = tracefs_uretprobe_alloc(utests[i].system, utests[i].event, + self, FOFFSET, utests[i].format); + CU_TEST(duprobes[i] != NULL); + } + duprobes[i] = NULL; + + get_dynevents_check(TRACEFS_DYNEVENT_UPROBE | TRACEFS_DYNEVENT_URETPROBE, 0); + CU_TEST(check_probes(utests, count, duprobes, false, instance, tep)); + + for (i = 0; i < count; i++) { + CU_TEST(tracefs_dynevent_create(duprobes[i]) == 0); + } + + duvents = get_dynevents_check(TRACEFS_DYNEVENT_UPROBE | TRACEFS_DYNEVENT_URETPROBE, count); + CU_TEST(check_probes(utests, count, duvents, true, instance, tep)); + tracefs_dynevent_list_free(duvents); + + for (i = 0; i < count; i++) { + CU_TEST(tracefs_dynevent_destroy(duprobes[i], false) == 0); + } + get_dynevents_check(TRACEFS_DYNEVENT_UPROBE | TRACEFS_DYNEVENT_URETPROBE, 0); + CU_TEST(check_probes(utests, count, duprobes, false, instance, tep)); + + for (i = 0; i < count; i++) + tracefs_dynevent_free(duprobes[i]); + + free(duprobes); + free(target); + tep_free(tep); +} + +static void test_uprobes(void) +{ + test_uprobes_instance(test_instance); +} + static void test_instance_file(void) { struct tracefs_instance *instance = NULL; @@ -1708,4 +1781,5 @@ void test_tracefs_lib(void) CU_add_test(suite, "kprobes", test_kprobes); CU_add_test(suite, "synthetic events", test_synthetic); CU_add_test(suite, "eprobes", test_eprobes); + CU_add_test(suite, "uprobes", test_uprobes); }