From patchwork Thu Oct 5 01:53:13 2023 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Steven Rostedt X-Patchwork-Id: 148667 Return-Path: Delivered-To: ouuuleilei@gmail.com Received: by 2002:a05:612c:2016:b0:403:3b70:6f57 with SMTP id fe22csp14343vqb; Wed, 4 Oct 2023 18:53:04 -0700 (PDT) X-Google-Smtp-Source: AGHT+IGmUxhxnAxxW4RoQGi5a3Y7wWfW8cT6Dr119Ii17PyogfOHL1hF4ZhMHVpxkGArVPIhgzd6 X-Received: by 2002:a05:6808:2918:b0:3ae:5e6a:46d4 with SMTP id ev24-20020a056808291800b003ae5e6a46d4mr3619488oib.37.1696470784134; Wed, 04 Oct 2023 18:53:04 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1696470784; cv=none; d=google.com; s=arc-20160816; b=ateJuycNz+XRH6QJFwFp8LI0GqFacRY36EJXr1FdKMaKLWcGJkbw0BoqZnYa8KDbpM +DPeSD3OxPrhRcmCN4YprEw6oMc+mZO1w/bNoDYeDax6Dv3ChY1hcPxVOXnb5ybcRzj0 IPwvjo7iqqlEhRCDVLcCgVo2XgfDZC2IFWh5hC2YFUS+pKnmp9mwysMWxESPfQanxnbW PZPFy3ALgfrL4e/UEmY3NZ5irnug1kGIf43ZI/g8xTpyf/csVsqjvcRzAdQ4yPljK5iC saFcp+pTKL9G1VR0jL88E3ZKoliDNJCANt29NQdCgFAx5XJL7KP22kU84SNQVotWPf54 LwuA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:mime-version:references:subject:cc:to:from:date :user-agent:message-id; bh=/8Q0c86Za4I5kaW6wf7yfM7VZ2jrDJEx4pCiiz90TT0=; fh=ozzW+1tVKI85SOasb1/L7GiS+b2ejaUssMTcKhKt6Zw=; b=QycIp7Rd08luZmSprrSkCo5PeCSRiG6eLo8mhr7uSRPo2sraxTEoK1tNULvrphzifY I+PnEyXS/3y/S1WSCb4SVtT/Vy30yQw/i+6X7QlvK4zfB4dCEEnjYKJCEG6z4YsVdAS/ 9+1csFmXowbWYBIeXJ92SpJRsEkt7cyziq0znvQY9fRF/MorJPxm+QYeEk23/sym6dkd U7YtQd6xdBa2dycErPyoFQxIOUG8r0YD9FnOKK+MHbN7amDzRQtgtmwXFTFO/Tmrbn75 TDXYv5NymvuqvfqgeHCHHgG91761PFN8AWeZECT6dd0eJZC1+ZKANRod6PYUHy60oEBu Vy8A== ARC-Authentication-Results: i=1; mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: from howler.vger.email (howler.vger.email. [23.128.96.34]) by mx.google.com with ESMTPS id m16-20020a63fd50000000b005638179cecasi395294pgj.833.2023.10.04.18.53.03 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 04 Oct 2023 18:53:04 -0700 (PDT) Received-SPF: pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) client-ip=23.128.96.34; Authentication-Results: mx.google.com; spf=pass (google.com: domain of linux-kernel-owner@vger.kernel.org designates 23.128.96.34 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org Received: from out1.vger.email (depot.vger.email [IPv6:2620:137:e000::3:0]) by howler.vger.email (Postfix) with ESMTP id 5917E85632A9; Wed, 4 Oct 2023 18:53:01 -0700 (PDT) X-Virus-Status: Clean X-Virus-Scanned: clamav-milter 0.103.10 at howler.vger.email Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S244524AbjJEBwz (ORCPT + 19 others); Wed, 4 Oct 2023 21:52:55 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:32950 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S244350AbjJEBwq (ORCPT ); Wed, 4 Oct 2023 21:52:46 -0400 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A8423D8 for ; Wed, 4 Oct 2023 18:52:42 -0700 (PDT) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 4DDC7C433D9; Thu, 5 Oct 2023 01:52:42 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.96) (envelope-from ) id 1qoDYl-005FJW-0c; Wed, 04 Oct 2023 21:53:51 -0400 Message-ID: <20231005015351.006166381@goodmis.org> User-Agent: quilt/0.66 Date: Wed, 04 Oct 2023 21:53:13 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Andrew Morton , Beau Belgrave Subject: [for-next][PATCH 3/7] tracing/user_events: Allow events to persist for perfmon_capable users References: <20231005015310.859143353@goodmis.org> MIME-Version: 1.0 X-Spam-Status: No, score=-1.6 required=5.0 tests=BAYES_00, HEADER_FROM_DIFFERENT_DOMAINS,RCVD_IN_DNSWL_BLOCKED,SPF_HELO_NONE, SPF_PASS autolearn=no autolearn_force=no version=3.4.6 X-Spam-Checker-Version: SpamAssassin 3.4.6 (2021-04-09) on lindbergh.monkeyblade.net Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org X-Greylist: Sender passed SPF test, not delayed by milter-greylist-4.6.4 (howler.vger.email [0.0.0.0]); Wed, 04 Oct 2023 18:53:01 -0700 (PDT) X-getmail-retrieved-from-mailbox: INBOX X-GMAIL-THRID: 1778878549311238451 X-GMAIL-MSGID: 1778878549311238451 From: Beau Belgrave There are several scenarios that have come up where having a user_event persist even if the process that registered it exits. The main one is having a daemon create events on bootup that shouldn't get deleted if the daemon has to exit or reload. Another is within OpenTelemetry exporters, they wish to potentially check if a user_event exists on the system to determine if exporting the data out should occur. The user_event in this case must exist even in the absence of the owning process running (such as the above daemon case). Expose the previously internal flag USER_EVENT_REG_PERSIST to user processes. Upon register or delete of events with this flag, ensure the user is perfmon_capable to prevent random user processes with access to tracefs from creating events that persist after exit. Link: https://lkml.kernel.org/r/20230912180704.1284-2-beaub@linux.microsoft.com Signed-off-by: Beau Belgrave Signed-off-by: Steven Rostedt (Google) --- include/uapi/linux/user_events.h | 11 +++++++++- kernel/trace/trace_events_user.c | 36 +++++++++++++++++++------------- 2 files changed, 32 insertions(+), 15 deletions(-) diff --git a/include/uapi/linux/user_events.h b/include/uapi/linux/user_events.h index 2984aae4a2b4..f74f3aedd49c 100644 --- a/include/uapi/linux/user_events.h +++ b/include/uapi/linux/user_events.h @@ -17,6 +17,15 @@ /* Create dynamic location entry within a 32-bit value */ #define DYN_LOC(offset, size) ((size) << 16 | (offset)) +/* List of supported registration flags */ +enum user_reg_flag { + /* Event will not delete upon last reference closing */ + USER_EVENT_REG_PERSIST = 1U << 0, + + /* This value or above is currently non-ABI */ + USER_EVENT_REG_MAX = 1U << 1, +}; + /* * Describes an event registration and stores the results of the registration. * This structure is passed to the DIAG_IOCSREG ioctl, callers at a minimum @@ -33,7 +42,7 @@ struct user_reg { /* Input: Enable size in bytes at address */ __u8 enable_size; - /* Input: Flags for future use, set to 0 */ + /* Input: Flags to use, if any */ __u16 flags; /* Input: Address to update when enabled */ diff --git a/kernel/trace/trace_events_user.c b/kernel/trace/trace_events_user.c index b87f41187c6a..9365ce407426 100644 --- a/kernel/trace/trace_events_user.c +++ b/kernel/trace/trace_events_user.c @@ -49,18 +49,6 @@ #define EVENT_STATUS_PERF BIT(1) #define EVENT_STATUS_OTHER BIT(7) -/* - * User register flags are not allowed yet, keep them here until we are - * ready to expose them out to the user ABI. - */ -enum user_reg_flag { - /* Event will not delete upon last reference closing */ - USER_EVENT_REG_PERSIST = 1U << 0, - - /* This value or above is currently non-ABI */ - USER_EVENT_REG_MAX = 1U << 1, -}; - /* * Stores the system name, tables, and locks for a group of events. This * allows isolation for events by various means. @@ -220,6 +208,17 @@ static u32 user_event_key(char *name) return jhash(name, strlen(name), 0); } +static bool user_event_capable(u16 reg_flags) +{ + /* Persistent events require CAP_PERFMON / CAP_SYS_ADMIN */ + if (reg_flags & USER_EVENT_REG_PERSIST) { + if (!perfmon_capable()) + return false; + } + + return true; +} + static struct user_event *user_event_get(struct user_event *user) { refcount_inc(&user->refcnt); @@ -1811,6 +1810,9 @@ static int user_event_free(struct dyn_event *ev) if (!user_event_last_ref(user)) return -EBUSY; + if (!user_event_capable(user->reg_flags)) + return -EPERM; + return destroy_user_event(user); } @@ -1926,10 +1928,13 @@ static int user_event_parse(struct user_event_group *group, char *name, int argc = 0; char **argv; - /* User register flags are not ready yet */ - if (reg_flags != 0 || flags != NULL) + /* Currently don't support any text based flags */ + if (flags != NULL) return -EINVAL; + if (!user_event_capable(reg_flags)) + return -EPERM; + /* Prevent dyn_event from racing */ mutex_lock(&event_mutex); user = find_user_event(group, name, &key); @@ -2062,6 +2067,9 @@ static int delete_user_event(struct user_event_group *group, char *name) if (!user_event_last_ref(user)) return -EBUSY; + if (!user_event_capable(user->reg_flags)) + return -EPERM; + return destroy_user_event(user); }