From nobody Thu Apr 9 09:25:49 2026 Received: from mail-oo1-f51.google.com (mail-oo1-f51.google.com [209.85.161.51]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 62221332612 for ; Mon, 9 Mar 2026 21:27:33 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.161.51 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1773091654; cv=none; b=ifOCtuFWzmQ7etV76ctacnZBVkAFHRuV8jrJO/77EkIqeB44xpGxdr/kFckNfCCGcZPqpIo6zyh2k4xn36RKHHjAjsrNfsobYp/LBbrXQIhByA2oBYZpuwzg1Xi7xdXjMFJCyx8YijGe0IaR9gvglfCuEY+byWPflBMHDt4H2vo= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1773091654; c=relaxed/simple; bh=6stQYyOxMRnUStvEWwSG/+EyIdCyR+1lCeFjXm/jGoU=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=AkQq3Dmw2Uk+X4+rdzlgEwReMxqU0SigCZGQPsYd6GccndzxzM8fnPHUzeIy7XXokvS3ToKZxKEWx8FSsg2exe+N7ZpFVvSYJZRuaiicBgwbm9S87rDeYVy3t7i0UijnSa1xtlGgzv2QfOqbZaoiTCIWNjyAoGLocnpwK8dOTdQ= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=hGkcLKZS; arc=none smtp.client-ip=209.85.161.51 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="hGkcLKZS" Received: by mail-oo1-f51.google.com with SMTP id 006d021491bc7-66f3e7d9eccso7676785eaf.1 for ; Mon, 09 Mar 2026 14:27:33 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1773091652; x=1773696452; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=cZQ7pa4QZtyeqTGy8hRuNrpZ4pJ+pX/bVyCr6bI4rKo=; b=hGkcLKZSYUNaKLD9x22C1FnKSjO4i/Uh/bIjR/JX/6JdlyTUqwgQBy0nqdU47tZYbN bAu8LKI1A8FElGo6y0R/2NCR9mzYfoVmQQmQ78xEA90bs1samcWYVMHCw7hMJCS51pwj bwgkvwysFojHVtK6c5QDcywS26v3KM+6yh03efJcSmKDRxuEgbhIjI8eqwyAoo3LMSyj nNmMDINPOmWQZBFkGs9ykq6pVw8LMfutIAM4rAAEczH3O/Tjxh/8bAZPVQxrM9pK87N7 S3aghgHsweG+X6rfuDSmiixPeKbjCipMUQNT9TnaSB1Fp2acOblMpMj1yYU2k6Mg4niU NeQA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1773091652; x=1773696452; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=cZQ7pa4QZtyeqTGy8hRuNrpZ4pJ+pX/bVyCr6bI4rKo=; b=Cj8qynH71VTrB0+E0yzaSd6hGvmkdsdvTpQaC7lLrwrHWKNVnMfERmInleOsX7a72C iDnyXbspOjY/dpqkWnix1I/8Zk6RjHtcLBjG9Ze60YEo+fn8pqTMLdYK0rKQJ5wVzwNR 5FwV5v3Mr3Yzbk5BzTVH6a0UkQPqBwkPtkIxPJzr3SVa0d55kM2q0tR5bDeCfURA/dpD ItChpx9RkuK8IQMga3lgMvLBB7DWRwBiia6SUWucSHOWG58ULk2w2lIr8RLxGDz75V8w fUCAkkecEx9pMbXkdYkjeHYhknc9ZCQH0HNbYfaIzT6WW3/ln9mB+6T9ZnkLTGDOt54N M6bg== X-Forwarded-Encrypted: i=1; AJvYcCVVhZlwk+1NW9+yXAbMFhAkdyF561uqVFvLkY9FF75XrvHFL4TH371P8zllzve43XKoVpns/pHT9FEGBNw=@vger.kernel.org X-Gm-Message-State: AOJu0YyUCZLsdmf7gD4RJA9D0Ve1jqMVKmA+Oucjrg/2UjosRl7F5MeE 3pWuMIOM+WVO69TO98BlUu2BHGuc3dDglq5fu7biHUBzLbwXA1Xkxq6X X-Gm-Gg: ATEYQzygDV19yP+wZh3BWX2GMny7lGLNyK4keyWnq9LbFUuKgAWIDQ5WimXLTeAd6aa LLsFgbIJBgCSdjJC6NkOq4StBzeDqiPIYxBfuRnc3CQWilGXyP38N0oyVmvRlartio2o63WUhpQ E5jBlo3/iNc8ODPEuME5fXA1NkYnOr5A5iJFazMZHGdtCdWLNBstavGKyeVcpvbBkJBXdWBT7tC aNmn490WS4OE0T143l130++wTDKN9mbPnqoxAUy8tQe3U17Qof8o4IPvdsxVyR9ShSxJxKRpL4w TlpG0DuFa/j5HtSrNOLSa5bnZ/MHjaggDLDlLRXGLG2aVUXOZh9a/G010gY6+pExIrvKEmuPjTj rMJfEBrmd6Kn0jKV8Uu7aMNlwIt+L9gns4PACFB9EDI18rz4vao7bNpTUOyepvm6uRLiV2qm3St ItJLkyFTaGvitC4Bg/cu/5YW8zdcyDXloR0ydt4qLeAsaXkKY1VfdN0O3gVIbZOTWoHEgCN0KEi 5fH1C10Jx9EzUhwAovuiKmvqwaEXwADJZ3RRo4YsKwNRAeV X-Received: by 2002:a05:6820:189a:b0:67b:af93:92d0 with SMTP id 006d021491bc7-67baf9395dcmr4115115eaf.28.1773091652273; Mon, 09 Mar 2026 14:27:32 -0700 (PDT) Received: from localhost.localdomain (108-212-132-20.lightspeed.irvnca.sbcglobal.net. [108.212.132.20]) by smtp.gmail.com with ESMTPSA id 006d021491bc7-67bb3bb67fbsm2639289eaf.15.2026.03.09.14.27.31 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 09 Mar 2026 14:27:31 -0700 (PDT) From: Wesley Atwell To: rostedt@goodmis.org Cc: mhiramat@kernel.org, mark.rutland@arm.com, mathieu.desnoyers@efficios.com, linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, Wesley Atwell Subject: [PATCH v2 1/2] tracing: preserve repeated boot-time tracing parameters Date: Mon, 9 Mar 2026 15:27:01 -0600 Message-Id: <20260309212702.13622-2-atwellwea@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260309212702.13622-1-atwellwea@gmail.com> References: <20260309212702.13622-1-atwellwea@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Bootconfig expands arrays into repeated param=3Dvalue entries, and the kernel command line can repeat the same tracing parameter as well. Several tracing __setup() handlers still overwrite their boot buffers, so only the last ftrace filter, graph filter, trace option, kprobe event, or trace trigger entry survives boot. Preserve repeated values in the format their existing parsers already consume: comma-delimited lists for ftrace filters and trace options, semicolon-delimited lists for kprobe events, and per-chunk parsing for trace_trigger=3D. The trace_trigger parser tokenizes its storage in place, so keep a running length and only parse the newly appended chunk into bootup_triggers[]. Fixes: 2af15d6a44b8 ("ftrace: add kernel command line function filtering") Fixes: 7bcfaf54f591 ("tracing: Add trace_options kernel command line parame= ter") Fixes: a01fdc897fa5 ("tracing: Add trace_trigger kernel command line option= ") Fixes: 970988e19eb0 ("tracing/kprobe: Add kprobe_event=3D boot parameter") Signed-off-by: Wesley Atwell --- v2: - No changes kernel/trace/ftrace.c | 29 +++++++++++++++++++++++++---- kernel/trace/trace.c | 23 ++++++++++++++++++++++- kernel/trace/trace_events.c | 23 ++++++++++++++++++++--- kernel/trace/trace_kprobe.c | 23 ++++++++++++++++++++++- 4 files changed, 89 insertions(+), 9 deletions(-) diff --git a/kernel/trace/ftrace.c b/kernel/trace/ftrace.c index 8df69e702706..cdd46f639333 100644 --- a/kernel/trace/ftrace.c +++ b/kernel/trace/ftrace.c @@ -6835,13 +6835,34 @@ EXPORT_SYMBOL_GPL(ftrace_set_global_notrace); static char ftrace_notrace_buf[FTRACE_FILTER_SIZE] __initdata; static char ftrace_filter_buf[FTRACE_FILTER_SIZE] __initdata; =20 +static void __init append_ftrace_boot_param(char *buf, const char *str, + char sep) +{ + size_t len, str_len; + + if (buf[0] =3D=3D '\0') { + strscpy(buf, str, FTRACE_FILTER_SIZE); + return; + } + + len =3D strlen(buf); + str_len =3D strlen(str); + if (!str_len) + return; + if (str_len >=3D FTRACE_FILTER_SIZE - len - 1) + return; + + buf[len] =3D sep; + strscpy(buf + len + 1, str, FTRACE_FILTER_SIZE - len - 1); +} + /* Used by function selftest to not test if filter is set */ bool ftrace_filter_param __initdata; =20 static int __init set_ftrace_notrace(char *str) { ftrace_filter_param =3D true; - strscpy(ftrace_notrace_buf, str, FTRACE_FILTER_SIZE); + append_ftrace_boot_param(ftrace_notrace_buf, str, ','); return 1; } __setup("ftrace_notrace=3D", set_ftrace_notrace); @@ -6849,7 +6870,7 @@ __setup("ftrace_notrace=3D", set_ftrace_notrace); static int __init set_ftrace_filter(char *str) { ftrace_filter_param =3D true; - strscpy(ftrace_filter_buf, str, FTRACE_FILTER_SIZE); + append_ftrace_boot_param(ftrace_filter_buf, str, ','); return 1; } __setup("ftrace_filter=3D", set_ftrace_filter); @@ -6861,14 +6882,14 @@ static int ftrace_graph_set_hash(struct ftrace_hash= *hash, char *buffer); =20 static int __init set_graph_function(char *str) { - strscpy(ftrace_graph_buf, str, FTRACE_FILTER_SIZE); + append_ftrace_boot_param(ftrace_graph_buf, str, ','); return 1; } __setup("ftrace_graph_filter=3D", set_graph_function); =20 static int __init set_graph_notrace_function(char *str) { - strscpy(ftrace_graph_notrace_buf, str, FTRACE_FILTER_SIZE); + append_ftrace_boot_param(ftrace_graph_notrace_buf, str, ','); return 1; } __setup("ftrace_graph_notrace=3D", set_graph_notrace_function); diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c index ebd996f8710e..42d03d36ae39 100644 --- a/kernel/trace/trace.c +++ b/kernel/trace/trace.c @@ -327,9 +327,30 @@ __setup("trace_instance=3D", boot_instance); =20 static char trace_boot_options_buf[MAX_TRACER_SIZE] __initdata; =20 +static void __init append_trace_boot_options(const char *str) +{ + size_t len, str_len; + + if (trace_boot_options_buf[0] =3D=3D '\0') { + strscpy(trace_boot_options_buf, str, MAX_TRACER_SIZE); + return; + } + + len =3D strlen(trace_boot_options_buf); + str_len =3D strlen(str); + if (!str_len) + return; + if (str_len >=3D MAX_TRACER_SIZE - len - 1) + return; + + trace_boot_options_buf[len] =3D ','; + strscpy(trace_boot_options_buf + len + 1, str, + MAX_TRACER_SIZE - len - 1); +} + static int __init set_trace_boot_options(char *str) { - strscpy(trace_boot_options_buf, str, MAX_TRACER_SIZE); + append_trace_boot_options(str); return 1; } __setup("trace_options=3D", set_trace_boot_options); diff --git a/kernel/trace/trace_events.c b/kernel/trace/trace_events.c index 249d1cba72c0..c3981f62e4bc 100644 --- a/kernel/trace/trace_events.c +++ b/kernel/trace/trace_events.c @@ -3679,20 +3679,37 @@ static struct boot_triggers { } bootup_triggers[MAX_BOOT_TRIGGERS]; =20 static char bootup_trigger_buf[COMMAND_LINE_SIZE]; +static int bootup_trigger_buf_len; static int nr_boot_triggers; =20 static __init int setup_trace_triggers(char *str) { char *trigger; char *buf; + ssize_t copied; int i; + int start; =20 - strscpy(bootup_trigger_buf, str, COMMAND_LINE_SIZE); + if (bootup_trigger_buf_len >=3D COMMAND_LINE_SIZE) + return 1; + + start =3D bootup_trigger_buf_len; + if (start && !*str) + return 1; + + copied =3D strscpy(bootup_trigger_buf + start, str, + COMMAND_LINE_SIZE - start); + if (copied < 0) { + if (start) + return 1; + copied =3D strlen(bootup_trigger_buf + start); + } + bootup_trigger_buf_len +=3D copied + 1; trace_set_ring_buffer_expanded(NULL); disable_tracing_selftest("running event triggers"); =20 - buf =3D bootup_trigger_buf; - for (i =3D 0; i < MAX_BOOT_TRIGGERS; i++) { + buf =3D bootup_trigger_buf + start; + for (i =3D nr_boot_triggers; i < MAX_BOOT_TRIGGERS; i++) { trigger =3D strsep(&buf, ","); if (!trigger) break; diff --git a/kernel/trace/trace_kprobe.c b/kernel/trace/trace_kprobe.c index a5dbb72528e0..a63a56b55570 100644 --- a/kernel/trace/trace_kprobe.c +++ b/kernel/trace/trace_kprobe.c @@ -29,9 +29,30 @@ /* Kprobe early definition from command line */ static char kprobe_boot_events_buf[COMMAND_LINE_SIZE] __initdata; =20 +static void __init append_kprobe_boot_event(const char *str) +{ + size_t len, str_len; + + if (kprobe_boot_events_buf[0] =3D=3D '\0') { + strscpy(kprobe_boot_events_buf, str, COMMAND_LINE_SIZE); + return; + } + + len =3D strlen(kprobe_boot_events_buf); + str_len =3D strlen(str); + if (!str_len) + return; + if (str_len >=3D COMMAND_LINE_SIZE - len - 1) + return; + + kprobe_boot_events_buf[len] =3D ';'; + strscpy(kprobe_boot_events_buf + len + 1, str, + COMMAND_LINE_SIZE - len - 1); +} + static int __init set_kprobe_boot_events(char *str) { - strscpy(kprobe_boot_events_buf, str, COMMAND_LINE_SIZE); + append_kprobe_boot_event(str); disable_tracing_selftest("running kprobe events"); =20 return 1; --=20 2.34.1 From nobody Thu Apr 9 09:25:49 2026 Received: from mail-oo1-f48.google.com (mail-oo1-f48.google.com [209.85.161.48]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 4E49935B647 for ; Mon, 9 Mar 2026 21:27:34 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.161.48 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1773091656; cv=none; b=VO8b11fUDXT16urQxuqV0mpzuUKgb7S13aCJCj0XJPJwGcXNFNVmA9tLoPPaFxnqWwu2busRVm8XIuwSehtfwqKXfOk2QtgSBu7UNAFyTBk/f6YyRfNq7pubAhzzr+hZhNDqTqZf3s++fLP4WjO2YaILnvu+sUpiWYkQzmvlb6Q= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1773091656; c=relaxed/simple; bh=6uUkqbS1peCg656T6d9eFVBNAReBUwqE9WarCDhm26M=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=BE3tw1Qp2/zfmSDMoCtNFa4J40T21aZxGLM49jdedOkEvgC0OufGwhI8OSpIRwW6lN9xiCxGJG+3dfh81kj3pxg9oJVAd3UI0L77RQeoAHcoh++t8OhXz7PCeKTZ9yrqTbrDvUJB5DvZIQM0l+l3NQHRpeRi1JG+0iTHTyGlfcs= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=RhOW/IH8; arc=none smtp.client-ip=209.85.161.48 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="RhOW/IH8" Received: by mail-oo1-f48.google.com with SMTP id 006d021491bc7-67bb3fe55a5so497421eaf.2 for ; Mon, 09 Mar 2026 14:27:34 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20230601; t=1773091653; x=1773696453; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to; bh=4Ig39XgKJvqjYKJDvVYNDNH+8fk8f4kr1nnRK9rVXmY=; b=RhOW/IH8rJlbjiC5bVwGRCpbaoOYCb0zZVStLFN5KVns1CC9n9ZWf3vxZ+92pxiBRa QOvG8WSmj9BmRtN+qtdC2pcszZVXli/7v2z/YzWNC0PCaTchARGhVj1b+9PUaH8e2/CT HO8sz4z/O/L9FcHn2nK2AqaYQeesXREQSV/ccVwFX0ZLA0cIbQsr5XAONa7i2DjGo/+h rRxG5PG9j4dN7pOkj7xVZueXJVJsT9MViBcNL6P6kfZSQXyBskHoCRdAqWl/T3Ev3WNG KG0r70NcK3aT2P8j5MtnSSKgyXmSekF0I91BWscPxT+jU6yTt0uChVJO4cYnnHf9xZww jPSQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1773091653; x=1773696453; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to; bh=4Ig39XgKJvqjYKJDvVYNDNH+8fk8f4kr1nnRK9rVXmY=; b=XnnaHE+5bOqY1lwh1cFFR0x3JpJWSEXcx44VXvS/ul3NuNn0ZXe+EHanE/eFHhnHn6 A3pf62VHQ2UPDs73sxTScVjUjVoM5Jsi3YAvzsyytL55cV5ZbWAxKH1m+U2W/Ac4r+DB vw7PztJVGALnhYjFrGl/Zmm/5md9oeXtn2qtfpqqtX9/Xr+a0e582XiDN4yrhYjrNHi2 54mieDacme4/axfunzyllIbr9cdrgvT+TTNrS2fUbzPaNMPYvF35iv+KKC3AjVsFGM6W bgP64ChV85nn5hRmoMDgD5uQeLktlPHC3YC7SIo3mlhT0XBTxQWibqZBbAAVHUB+TLRS A9SQ== X-Forwarded-Encrypted: i=1; AJvYcCXa1wirNJjLymPs9YMOEFBH1hjpjyhWlaXwXHJvuO8kjuHpydeeE75vCArz/Sw49br/g26RLI1nu5fOpms=@vger.kernel.org X-Gm-Message-State: AOJu0Yzjxc6Nt61LLil3mbA28KL2c2Ov4APRyRnqnVo1kIX4Ax0EpByw zkJTuflVMT4+8ns6Vd+Zp2Ezq/yNaIFOLZYZoifZ6KuMkthbPwj/2B0z X-Gm-Gg: ATEYQzxjsKdOMqrLn7HYwtVnT896DsCkrF/h6MOe9FHS5YIgK5B54zO+AfzctXRUyKI 8DBxf/iGJbnIEgfPB4e3UbPIqTGGehfixfrxWIsZhemkVdYnmSRW3ZWrxpyaGOEUpDS1Hgj+lDG rRQEvy54iJgpciw1MHi0qe+8oJS7dbhZMgxAKk2FvfoeB24e6UqvdewinNpnz55ihWIu4Glr+g7 qwHK8bS+a4iW49Yfv6tSRzD1UyUs025FweMQFs8mL390VjW/ZKgYmdGWqwI1/N26BpVdE3tijoA m2rgoqSUBLKvsJdm3sgJPb3pMg5R2M5RsQfGE+8lgSW2T6Zic454BeM/uoCIcI1Jij4pLJqvxVP 0J3Bypl2c3/NeZ1IjknZElAlTwClc6Adic9KJZUGTVnie+HzHzX+uNnYJ5B9iJYJhbVKS4LyO0P EpG3Cl39r/uQEZnjauPDKfyO2VQzXiye0WonuYtCvOg3dHFW6JrX7e4V3/qiozOSi3sFzjOJUVw R1YbSjH8+nV+rqLK432UYJJ7VzbXtTgOjHhJuswjzLMeXBS X-Received: by 2002:a05:6820:229a:b0:67b:b432:5fbe with SMTP id 006d021491bc7-67bb4326165mr2802956eaf.26.1773091653174; Mon, 09 Mar 2026 14:27:33 -0700 (PDT) Received: from localhost.localdomain (108-212-132-20.lightspeed.irvnca.sbcglobal.net. [108.212.132.20]) by smtp.gmail.com with ESMTPSA id 006d021491bc7-67bb3bb67fbsm2639289eaf.15.2026.03.09.14.27.32 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 09 Mar 2026 14:27:32 -0700 (PDT) From: Wesley Atwell To: rostedt@goodmis.org Cc: mhiramat@kernel.org, mark.rutland@arm.com, mathieu.desnoyers@efficios.com, linux-kernel@vger.kernel.org, linux-trace-kernel@vger.kernel.org, Wesley Atwell Subject: [PATCH v2 2/2] tracing: drain deferred trigger frees if kthread startup fails Date: Mon, 9 Mar 2026 15:27:02 -0600 Message-Id: <20260309212702.13622-3-atwellwea@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260309212702.13622-1-atwellwea@gmail.com> References: <20260309212702.13622-1-atwellwea@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Boot-time trigger registration can fail before the trigger-data cleanup kthread exists. Deferring those frees until late init is fine, but the post-boot fallback must still drain the deferred list if kthread creation never succeeds. Otherwise, boot-deferred nodes can accumulate on trigger_data_free_list, later frees fall back to synchronously freeing only the current object, and the older queued entries are leaked forever. Keep the deferred boot-time behavior, but when kthread creation fails, drain the whole queued list synchronously. Do the same in the late-init drain path so queued entries are not stranded there either. Fixes: 61d445af0a7c ("tracing: Add bulk garbage collection of freeing event= _trigger_data") Signed-off-by: Wesley Atwell --- v2: - Restore the dropped mutex recheck comment - Clarify the synchronous fallback drain path kernel/trace/trace_events_trigger.c | 79 ++++++++++++++++++++++++----- 1 file changed, 66 insertions(+), 13 deletions(-) diff --git a/kernel/trace/trace_events_trigger.c b/kernel/trace/trace_event= s_trigger.c index d5230b759a2d..428b46272ac8 100644 --- a/kernel/trace/trace_events_trigger.c +++ b/kernel/trace/trace_events_trigger.c @@ -22,6 +22,39 @@ static struct task_struct *trigger_kthread; static struct llist_head trigger_data_free_list; static DEFINE_MUTEX(trigger_data_kthread_mutex); =20 +static int trigger_kthread_fn(void *ignore); + +static void trigger_start_kthread_locked(void) +{ + lockdep_assert_held(&trigger_data_kthread_mutex); + + if (!trigger_kthread) { + struct task_struct *kthread; + + kthread =3D kthread_create(trigger_kthread_fn, NULL, + "trigger_data_free"); + if (!IS_ERR(kthread)) + WRITE_ONCE(trigger_kthread, kthread); + } +} + +static void trigger_data_free_queued_locked(void) +{ + struct event_trigger_data *data, *tmp; + struct llist_node *llnodes; + + lockdep_assert_held(&trigger_data_kthread_mutex); + + llnodes =3D llist_del_all(&trigger_data_free_list); + if (!llnodes) + return; + + tracepoint_synchronize_unregister(); + + llist_for_each_entry_safe(data, tmp, llnodes, llist) + kfree(data); +} + /* Bulk garbage collection of event_trigger_data elements */ static int trigger_kthread_fn(void *ignore) { @@ -56,30 +89,50 @@ void trigger_data_free(struct event_trigger_data *data) if (data->cmd_ops->set_filter) data->cmd_ops->set_filter(NULL, data, NULL); =20 + /* + * Boot-time trigger registration can fail before kthread creation + * works. Keep the deferred-free semantics during boot and let late + * init start the kthread to drain the list. + */ + if (system_state =3D=3D SYSTEM_BOOTING && !trigger_kthread) { + llist_add(&data->llist, &trigger_data_free_list); + return; + } + if (unlikely(!trigger_kthread)) { guard(mutex)(&trigger_data_kthread_mutex); + + trigger_start_kthread_locked(); /* Check again after taking mutex */ if (!trigger_kthread) { - struct task_struct *kthread; - - kthread =3D kthread_create(trigger_kthread_fn, NULL, - "trigger_data_free"); - if (!IS_ERR(kthread)) - WRITE_ONCE(trigger_kthread, kthread); + llist_add(&data->llist, &trigger_data_free_list); + /* Drain the queued frees synchronously if startup failed. */ + trigger_data_free_queued_locked(); + return; } } =20 - if (!trigger_kthread) { - /* Do it the slow way */ - tracepoint_synchronize_unregister(); - kfree(data); - return; - } - llist_add(&data->llist, &trigger_data_free_list); wake_up_process(trigger_kthread); } =20 +static int __init trigger_data_free_init(void) +{ + guard(mutex)(&trigger_data_kthread_mutex); + + if (llist_empty(&trigger_data_free_list)) + return 0; + + trigger_start_kthread_locked(); + if (trigger_kthread) + wake_up_process(trigger_kthread); + else + trigger_data_free_queued_locked(); + + return 0; +} +late_initcall(trigger_data_free_init); + static inline void data_ops_trigger(struct event_trigger_data *data, struct trace_buffer *buffer, void *rec, struct ring_buffer_event *event) --=20 2.34.1