From nobody Tue Dec 16 19:54:02 2025 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 2FA94C27C40 for ; Thu, 24 Aug 2023 02:19:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239352AbjHXCTK (ORCPT ); Wed, 23 Aug 2023 22:19:10 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40706 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239266AbjHXCSd (ORCPT ); Wed, 23 Aug 2023 22:18:33 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 2C2D310C4 for ; Wed, 23 Aug 2023 19:18:31 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 9C15B633C6 for ; Thu, 24 Aug 2023 02:18:30 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id F34E6C433C9; Thu, 24 Aug 2023 02:18:29 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.96) (envelope-from ) id 1qYzvu-001hQ7-2H; Wed, 23 Aug 2023 22:18:50 -0400 Message-ID: <20230824021850.515849153@goodmis.org> User-Agent: quilt/0.66 Date: Wed, 23 Aug 2023 22:18:13 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Andrew Morton , Jonathan Corbet , Juri Lelli , Daniel Bristot de Oliveira , Marcelo Tosatti , Leonardo Bras , Frederic Weisbecker , Valentin Schneider Subject: [for-next][PATCH 01/14] tracing/filters: Dynamically allocate filter_pred.regex References: <20230824021812.938245293@goodmis.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Valentin Schneider Every predicate allocation includes a MAX_FILTER_STR_VAL (256) char array in the regex field, even if the predicate function does not use the field. A later commit will introduce a dynamically allocated cpumask to struct filter_pred, which will require a dedicated freeing function. Bite the bullet and make filter_pred.regex dynamically allocated. While at it, reorder the fields of filter_pred to fill in the byte holes. The struct now fits on a single cacheline. No change in behaviour intended. The kfree()'s were patched via Coccinelle: @@ struct filter_pred *pred; @@ -kfree(pred); +free_predicate(pred); Link: https://lkml.kernel.org/r/20230707172155.70873-2-vschneid@redhat.com Cc: Masami Hiramatsu Cc: Jonathan Corbet Cc: Juri Lelli Cc: Daniel Bristot de Oliveira Cc: Marcelo Tosatti Cc: Leonardo Bras Cc: Frederic Weisbecker Signed-off-by: Valentin Schneider Signed-off-by: Steven Rostedt (Google) --- kernel/trace/trace_events_filter.c | 64 ++++++++++++++++++------------ 1 file changed, 39 insertions(+), 25 deletions(-) diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events= _filter.c index 1dad64267878..91fc9990107f 100644 --- a/kernel/trace/trace_events_filter.c +++ b/kernel/trace/trace_events_filter.c @@ -70,15 +70,15 @@ enum filter_pred_fn { }; =20 struct filter_pred { - enum filter_pred_fn fn_num; - u64 val; - u64 val2; - struct regex regex; + struct regex *regex; unsigned short *ops; struct ftrace_event_field *field; - int offset; + u64 val; + u64 val2; + enum filter_pred_fn fn_num; + int offset; int not; - int op; + int op; }; =20 /* @@ -186,6 +186,14 @@ enum { PROCESS_OR =3D 4, }; =20 +static void free_predicate(struct filter_pred *pred) +{ + if (pred) { + kfree(pred->regex); + kfree(pred); + } +} + /* * Without going into a formal proof, this explains the method that is use= d in * parsing the logical expressions. @@ -623,7 +631,7 @@ predicate_parse(const char *str, int nr_parens, int nr_= preds, kfree(inverts); if (prog_stack) { for (i =3D 0; prog_stack[i].pred; i++) - kfree(prog_stack[i].pred); + free_predicate(prog_stack[i].pred); kfree(prog_stack); } return ERR_PTR(ret); @@ -750,7 +758,7 @@ static int filter_pred_string(struct filter_pred *pred,= void *event) char *addr =3D (char *)(event + pred->offset); int cmp, match; =20 - cmp =3D pred->regex.match(addr, &pred->regex, pred->regex.field_len); + cmp =3D pred->regex->match(addr, pred->regex, pred->regex->field_len); =20 match =3D cmp ^ pred->not; =20 @@ -763,7 +771,7 @@ static __always_inline int filter_pchar(struct filter_p= red *pred, char *str) int len; =20 len =3D strlen(str) + 1; /* including tailing '\0' */ - cmp =3D pred->regex.match(str, &pred->regex, len); + cmp =3D pred->regex->match(str, pred->regex, len); =20 match =3D cmp ^ pred->not; =20 @@ -813,7 +821,7 @@ static int filter_pred_strloc(struct filter_pred *pred,= void *event) char *addr =3D (char *)(event + str_loc); int cmp, match; =20 - cmp =3D pred->regex.match(addr, &pred->regex, str_len); + cmp =3D pred->regex->match(addr, pred->regex, str_len); =20 match =3D cmp ^ pred->not; =20 @@ -836,7 +844,7 @@ static int filter_pred_strrelloc(struct filter_pred *pr= ed, void *event) char *addr =3D (char *)(&item[1]) + str_loc; int cmp, match; =20 - cmp =3D pred->regex.match(addr, &pred->regex, str_len); + cmp =3D pred->regex->match(addr, pred->regex, str_len); =20 match =3D cmp ^ pred->not; =20 @@ -874,7 +882,7 @@ static int filter_pred_comm(struct filter_pred *pred, v= oid *event) { int cmp; =20 - cmp =3D pred->regex.match(current->comm, &pred->regex, + cmp =3D pred->regex->match(current->comm, pred->regex, TASK_COMM_LEN); return cmp ^ pred->not; } @@ -1004,7 +1012,7 @@ enum regex_type filter_parse_regex(char *buff, int le= n, char **search, int *not) =20 static void filter_build_regex(struct filter_pred *pred) { - struct regex *r =3D &pred->regex; + struct regex *r =3D pred->regex; char *search; enum regex_type type =3D MATCH_FULL; =20 @@ -1169,7 +1177,7 @@ static void free_prog(struct event_filter *filter) return; =20 for (i =3D 0; prog[i].pred; i++) - kfree(prog[i].pred); + free_predicate(prog[i].pred); kfree(prog); } =20 @@ -1553,9 +1561,12 @@ static int parse_pred(const char *str, void *data, goto err_free; } =20 - pred->regex.len =3D len; - strncpy(pred->regex.pattern, str + s, len); - pred->regex.pattern[len] =3D 0; + pred->regex =3D kzalloc(sizeof(*pred->regex), GFP_KERNEL); + if (!pred->regex) + goto err_mem; + pred->regex->len =3D len; + strncpy(pred->regex->pattern, str + s, len); + pred->regex->pattern[len] =3D 0; =20 /* This is either a string, or an integer */ } else if (str[i] =3D=3D '\'' || str[i] =3D=3D '"') { @@ -1597,9 +1608,12 @@ static int parse_pred(const char *str, void *data, goto err_free; } =20 - pred->regex.len =3D len; - strncpy(pred->regex.pattern, str + s, len); - pred->regex.pattern[len] =3D 0; + pred->regex =3D kzalloc(sizeof(*pred->regex), GFP_KERNEL); + if (!pred->regex) + goto err_mem; + pred->regex->len =3D len; + strncpy(pred->regex->pattern, str + s, len); + pred->regex->pattern[len] =3D 0; =20 filter_build_regex(pred); =20 @@ -1608,7 +1622,7 @@ static int parse_pred(const char *str, void *data, =20 } else if (field->filter_type =3D=3D FILTER_STATIC_STRING) { pred->fn_num =3D FILTER_PRED_FN_STRING; - pred->regex.field_len =3D field->size; + pred->regex->field_len =3D field->size; =20 } else if (field->filter_type =3D=3D FILTER_DYN_STRING) { pred->fn_num =3D FILTER_PRED_FN_STRLOC; @@ -1691,10 +1705,10 @@ static int parse_pred(const char *str, void *data, return i; =20 err_free: - kfree(pred); + free_predicate(pred); return -EINVAL; err_mem: - kfree(pred); + free_predicate(pred); return -ENOMEM; } =20 @@ -2287,8 +2301,8 @@ static int ftrace_function_set_filter_pred(struct fil= ter_pred *pred, return ret; =20 return __ftrace_function_set_filter(pred->op =3D=3D OP_EQ, - pred->regex.pattern, - pred->regex.len, + pred->regex->pattern, + pred->regex->len, data); } =20 --=20 2.40.1 From nobody Tue Dec 16 19:54:02 2025 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 83C98C71145 for ; Thu, 24 Aug 2023 02:19:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239393AbjHXCTS (ORCPT ); Wed, 23 Aug 2023 22:19:18 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40736 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239301AbjHXCSd (ORCPT ); Wed, 23 Aug 2023 22:18:33 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 576AA10C7 for ; Wed, 23 Aug 2023 19:18:31 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id CE45B64A3B for ; Thu, 24 Aug 2023 02:18:30 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 3D2B8C433CD; Thu, 24 Aug 2023 02:18:30 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.96) (envelope-from ) id 1qYzvu-001hQg-2w; Wed, 23 Aug 2023 22:18:50 -0400 Message-ID: <20230824021850.726268959@goodmis.org> User-Agent: quilt/0.66 Date: Wed, 23 Aug 2023 22:18:14 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Andrew Morton , Jonathan Corbet , Juri Lelli , Daniel Bristot de Oliveira , Marcelo Tosatti , Leonardo Bras , Frederic Weisbecker , Valentin Schneider Subject: [for-next][PATCH 02/14] tracing/filters: Enable filtering a cpumask field by another cpumask References: <20230824021812.938245293@goodmis.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Valentin Schneider The recently introduced ipi_send_cpumask trace event contains a cpumask field, but it currently cannot be used in filter expressions. Make event filtering aware of cpumask fields, and allow these to be filtered by a user-provided cpumask. The user-provided cpumask is to be given in cpulist format and wrapped as: "CPUS{$cpulist}". The use of curly braces instead of parentheses is to prevent predicate_parse() from parsing the contents of CPUS{...} as a full-fledged predicate subexpression. This enables e.g.: $ trace-cmd record -e 'ipi_send_cpumask' -f 'cpumask & CPUS{2,4,6,8-32}' Link: https://lkml.kernel.org/r/20230707172155.70873-3-vschneid@redhat.com Cc: Masami Hiramatsu Cc: Jonathan Corbet Cc: Juri Lelli Cc: Daniel Bristot de Oliveira Cc: Marcelo Tosatti Cc: Leonardo Bras Cc: Frederic Weisbecker Signed-off-by: Valentin Schneider Signed-off-by: Steven Rostedt (Google) --- include/linux/trace_events.h | 1 + kernel/trace/trace_events_filter.c | 97 +++++++++++++++++++++++++++++- 2 files changed, 96 insertions(+), 2 deletions(-) diff --git a/include/linux/trace_events.h b/include/linux/trace_events.h index c17623c78029..1600aeb8e1a3 100644 --- a/include/linux/trace_events.h +++ b/include/linux/trace_events.h @@ -808,6 +808,7 @@ enum { FILTER_RDYN_STRING, FILTER_PTR_STRING, FILTER_TRACE_FN, + FILTER_CPUMASK, FILTER_COMM, FILTER_CPU, FILTER_STACKTRACE, diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events= _filter.c index 91fc9990107f..cb1863dfa280 100644 --- a/kernel/trace/trace_events_filter.c +++ b/kernel/trace/trace_events_filter.c @@ -64,6 +64,7 @@ enum filter_pred_fn { FILTER_PRED_FN_PCHAR_USER, FILTER_PRED_FN_PCHAR, FILTER_PRED_FN_CPU, + FILTER_PRED_FN_CPUMASK, FILTER_PRED_FN_FUNCTION, FILTER_PRED_FN_, FILTER_PRED_TEST_VISITED, @@ -71,6 +72,7 @@ enum filter_pred_fn { =20 struct filter_pred { struct regex *regex; + struct cpumask *mask; unsigned short *ops; struct ftrace_event_field *field; u64 val; @@ -94,6 +96,8 @@ struct filter_pred { C(TOO_MANY_OPEN, "Too many '('"), \ C(TOO_MANY_CLOSE, "Too few '('"), \ C(MISSING_QUOTE, "Missing matching quote"), \ + C(MISSING_BRACE_OPEN, "Missing '{'"), \ + C(MISSING_BRACE_CLOSE, "Missing '}'"), \ C(OPERAND_TOO_LONG, "Operand too long"), \ C(EXPECT_STRING, "Expecting string field"), \ C(EXPECT_DIGIT, "Expecting numeric field"), \ @@ -103,6 +107,7 @@ struct filter_pred { C(BAD_SUBSYS_FILTER, "Couldn't find or set field in one of a subsystem's = events"), \ C(TOO_MANY_PREDS, "Too many terms in predicate expression"), \ C(INVALID_FILTER, "Meaningless filter expression"), \ + C(INVALID_CPULIST, "Invalid cpulist"), \ C(IP_FIELD_ONLY, "Only 'ip' field is supported for function trace"), \ C(INVALID_VALUE, "Invalid value (did you forget quotes)?"), \ C(NO_FUNCTION, "Function not found"), \ @@ -190,6 +195,7 @@ static void free_predicate(struct filter_pred *pred) { if (pred) { kfree(pred->regex); + kfree(pred->mask); kfree(pred); } } @@ -877,6 +883,26 @@ static int filter_pred_cpu(struct filter_pred *pred, v= oid *event) } } =20 +/* Filter predicate for cpumask field vs user-provided cpumask */ +static int filter_pred_cpumask(struct filter_pred *pred, void *event) +{ + u32 item =3D *(u32 *)(event + pred->offset); + int loc =3D item & 0xffff; + const struct cpumask *mask =3D (event + loc); + const struct cpumask *cmp =3D pred->mask; + + switch (pred->op) { + case OP_EQ: + return cpumask_equal(mask, cmp); + case OP_NE: + return !cpumask_equal(mask, cmp); + case OP_BAND: + return cpumask_intersects(mask, cmp); + default: + return 0; + } +} + /* Filter predicate for COMM. */ static int filter_pred_comm(struct filter_pred *pred, void *event) { @@ -1244,8 +1270,12 @@ static void filter_free_subsystem_filters(struct tra= ce_subsystem_dir *dir, =20 int filter_assign_type(const char *type) { - if (strstr(type, "__data_loc") && strstr(type, "char")) - return FILTER_DYN_STRING; + if (strstr(type, "__data_loc")) { + if (strstr(type, "char")) + return FILTER_DYN_STRING; + if (strstr(type, "cpumask_t")) + return FILTER_CPUMASK; + } =20 if (strstr(type, "__rel_loc") && strstr(type, "char")) return FILTER_RDYN_STRING; @@ -1357,6 +1387,8 @@ static int filter_pred_fn_call(struct filter_pred *pr= ed, void *event) return filter_pred_pchar(pred, event); case FILTER_PRED_FN_CPU: return filter_pred_cpu(pred, event); + case FILTER_PRED_FN_CPUMASK: + return filter_pred_cpumask(pred, event); case FILTER_PRED_FN_FUNCTION: return filter_pred_function(pred, event); case FILTER_PRED_TEST_VISITED: @@ -1568,6 +1600,67 @@ static int parse_pred(const char *str, void *data, strncpy(pred->regex->pattern, str + s, len); pred->regex->pattern[len] =3D 0; =20 + } else if (!strncmp(str + i, "CPUS", 4)) { + unsigned int maskstart; + char *tmp; + + switch (field->filter_type) { + case FILTER_CPUMASK: + break; + default: + parse_error(pe, FILT_ERR_ILLEGAL_FIELD_OP, pos + i); + goto err_free; + } + + switch (op) { + case OP_EQ: + case OP_NE: + case OP_BAND: + break; + default: + parse_error(pe, FILT_ERR_ILLEGAL_FIELD_OP, pos + i); + goto err_free; + } + + /* Skip CPUS */ + i +=3D 4; + if (str[i++] !=3D '{') { + parse_error(pe, FILT_ERR_MISSING_BRACE_OPEN, pos + i); + goto err_free; + } + maskstart =3D i; + + /* Walk the cpulist until closing } */ + for (; str[i] && str[i] !=3D '}'; i++); + if (str[i] !=3D '}') { + parse_error(pe, FILT_ERR_MISSING_BRACE_CLOSE, pos + i); + goto err_free; + } + + if (maskstart =3D=3D i) { + parse_error(pe, FILT_ERR_INVALID_CPULIST, pos + i); + goto err_free; + } + + /* Copy the cpulist between { and } */ + tmp =3D kmalloc((i - maskstart) + 1, GFP_KERNEL); + strscpy(tmp, str + maskstart, (i - maskstart) + 1); + + pred->mask =3D kzalloc(cpumask_size(), GFP_KERNEL); + if (!pred->mask) + goto err_mem; + + /* Now parse it */ + if (cpulist_parse(tmp, pred->mask)) { + parse_error(pe, FILT_ERR_INVALID_CPULIST, pos + i); + goto err_free; + } + + /* Move along */ + i++; + if (field->filter_type =3D=3D FILTER_CPUMASK) + pred->fn_num =3D FILTER_PRED_FN_CPUMASK; + /* This is either a string, or an integer */ } else if (str[i] =3D=3D '\'' || str[i] =3D=3D '"') { char q =3D str[i]; --=20 2.40.1 From nobody Tue Dec 16 19:54:02 2025 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 64868C71153 for ; Thu, 24 Aug 2023 02:19:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239347AbjHXCTH (ORCPT ); Wed, 23 Aug 2023 22:19:07 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40718 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239292AbjHXCSd (ORCPT ); Wed, 23 Aug 2023 22:18:33 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5839110D0 for ; Wed, 23 Aug 2023 19:18:31 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id E54D664AB2 for ; Thu, 24 Aug 2023 02:18:30 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 55FDEC433CC; Thu, 24 Aug 2023 02:18:30 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.96) (envelope-from ) id 1qYzvv-001hRE-0N; Wed, 23 Aug 2023 22:18:51 -0400 Message-ID: <20230824021850.933540258@goodmis.org> User-Agent: quilt/0.66 Date: Wed, 23 Aug 2023 22:18:15 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Andrew Morton , Jonathan Corbet , Juri Lelli , Daniel Bristot de Oliveira , Marcelo Tosatti , Leonardo Bras , Frederic Weisbecker , Valentin Schneider Subject: [for-next][PATCH 03/14] tracing/filters: Enable filtering a scalar field by a cpumask References: <20230824021812.938245293@goodmis.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Valentin Schneider Several events use a scalar field to denote a CPU: o sched_wakeup.target_cpu o sched_migrate_task.orig_cpu,dest_cpu o sched_move_numa.src_cpu,dst_cpu o ipi_send_cpu.cpu o ... Filtering these currently requires using arithmetic comparison functions, which can be tedious when dealing with interleaved SMT or NUMA CPU ids. Allow these to be filtered by a user-provided cpumask, which enables e.g.: $ trace-cmd record -e 'sched_wakeup' -f 'target_cpu & CPUS{2,4,6,8-32}' Link: https://lkml.kernel.org/r/20230707172155.70873-4-vschneid@redhat.com Cc: Masami Hiramatsu Cc: Jonathan Corbet Cc: Juri Lelli Cc: Daniel Bristot de Oliveira Cc: Marcelo Tosatti Cc: Leonardo Bras Cc: Frederic Weisbecker Signed-off-by: Valentin Schneider Signed-off-by: Steven Rostedt (Google) --- kernel/trace/trace_events_filter.c | 92 ++++++++++++++++++++++++++---- 1 file changed, 81 insertions(+), 11 deletions(-) diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events= _filter.c index cb1863dfa280..1e14f801685a 100644 --- a/kernel/trace/trace_events_filter.c +++ b/kernel/trace/trace_events_filter.c @@ -46,15 +46,19 @@ static const char * ops[] =3D { OPS }; enum filter_pred_fn { FILTER_PRED_FN_NOP, FILTER_PRED_FN_64, + FILTER_PRED_FN_64_CPUMASK, FILTER_PRED_FN_S64, FILTER_PRED_FN_U64, FILTER_PRED_FN_32, + FILTER_PRED_FN_32_CPUMASK, FILTER_PRED_FN_S32, FILTER_PRED_FN_U32, FILTER_PRED_FN_16, + FILTER_PRED_FN_16_CPUMASK, FILTER_PRED_FN_S16, FILTER_PRED_FN_U16, FILTER_PRED_FN_8, + FILTER_PRED_FN_8_CPUMASK, FILTER_PRED_FN_S8, FILTER_PRED_FN_U8, FILTER_PRED_FN_COMM, @@ -643,6 +647,39 @@ predicate_parse(const char *str, int nr_parens, int nr= _preds, return ERR_PTR(ret); } =20 +static inline int +do_filter_cpumask(int op, const struct cpumask *mask, const struct cpumask= *cmp) +{ + switch (op) { + case OP_EQ: + return cpumask_equal(mask, cmp); + case OP_NE: + return !cpumask_equal(mask, cmp); + case OP_BAND: + return cpumask_intersects(mask, cmp); + default: + return 0; + } +} + +/* Optimisation of do_filter_cpumask() for scalar fields */ +static inline int +do_filter_scalar_cpumask(int op, unsigned int cpu, const struct cpumask *m= ask) +{ + switch (op) { + case OP_EQ: + return cpumask_test_cpu(cpu, mask) && + cpumask_nth(1, mask) >=3D nr_cpu_ids; + case OP_NE: + return !cpumask_test_cpu(cpu, mask) || + cpumask_nth(1, mask) < nr_cpu_ids; + case OP_BAND: + return cpumask_test_cpu(cpu, mask); + default: + return 0; + } +} + enum pred_cmp_types { PRED_CMP_TYPE_NOP, PRED_CMP_TYPE_LT, @@ -686,6 +723,18 @@ static int filter_pred_##type(struct filter_pred *pred= , void *event) \ } \ } =20 +#define DEFINE_CPUMASK_COMPARISON_PRED(size) \ +static int filter_pred_##size##_cpumask(struct filter_pred *pred, void *ev= ent) \ +{ \ + u##size *addr =3D (u##size *)(event + pred->offset); \ + unsigned int cpu =3D *addr; \ + \ + if (cpu >=3D nr_cpu_ids) \ + return 0; \ + \ + return do_filter_scalar_cpumask(pred->op, cpu, pred->mask); \ +} + #define DEFINE_EQUALITY_PRED(size) \ static int filter_pred_##size(struct filter_pred *pred, void *event) \ { \ @@ -707,6 +756,11 @@ DEFINE_COMPARISON_PRED(u16); DEFINE_COMPARISON_PRED(s8); DEFINE_COMPARISON_PRED(u8); =20 +DEFINE_CPUMASK_COMPARISON_PRED(64); +DEFINE_CPUMASK_COMPARISON_PRED(32); +DEFINE_CPUMASK_COMPARISON_PRED(16); +DEFINE_CPUMASK_COMPARISON_PRED(8); + DEFINE_EQUALITY_PRED(64); DEFINE_EQUALITY_PRED(32); DEFINE_EQUALITY_PRED(16); @@ -891,16 +945,7 @@ static int filter_pred_cpumask(struct filter_pred *pre= d, void *event) const struct cpumask *mask =3D (event + loc); const struct cpumask *cmp =3D pred->mask; =20 - switch (pred->op) { - case OP_EQ: - return cpumask_equal(mask, cmp); - case OP_NE: - return !cpumask_equal(mask, cmp); - case OP_BAND: - return cpumask_intersects(mask, cmp); - default: - return 0; - } + return do_filter_cpumask(pred->op, mask, cmp); } =20 /* Filter predicate for COMM. */ @@ -1351,24 +1396,32 @@ static int filter_pred_fn_call(struct filter_pred *= pred, void *event) switch (pred->fn_num) { case FILTER_PRED_FN_64: return filter_pred_64(pred, event); + case FILTER_PRED_FN_64_CPUMASK: + return filter_pred_64_cpumask(pred, event); case FILTER_PRED_FN_S64: return filter_pred_s64(pred, event); case FILTER_PRED_FN_U64: return filter_pred_u64(pred, event); case FILTER_PRED_FN_32: return filter_pred_32(pred, event); + case FILTER_PRED_FN_32_CPUMASK: + return filter_pred_32_cpumask(pred, event); case FILTER_PRED_FN_S32: return filter_pred_s32(pred, event); case FILTER_PRED_FN_U32: return filter_pred_u32(pred, event); case FILTER_PRED_FN_16: return filter_pred_16(pred, event); + case FILTER_PRED_FN_16_CPUMASK: + return filter_pred_16_cpumask(pred, event); case FILTER_PRED_FN_S16: return filter_pred_s16(pred, event); case FILTER_PRED_FN_U16: return filter_pred_u16(pred, event); case FILTER_PRED_FN_8: return filter_pred_8(pred, event); + case FILTER_PRED_FN_8_CPUMASK: + return filter_pred_8_cpumask(pred, event); case FILTER_PRED_FN_S8: return filter_pred_s8(pred, event); case FILTER_PRED_FN_U8: @@ -1606,6 +1659,7 @@ static int parse_pred(const char *str, void *data, =20 switch (field->filter_type) { case FILTER_CPUMASK: + case FILTER_OTHER: break; default: parse_error(pe, FILT_ERR_ILLEGAL_FIELD_OP, pos + i); @@ -1658,8 +1712,24 @@ static int parse_pred(const char *str, void *data, =20 /* Move along */ i++; - if (field->filter_type =3D=3D FILTER_CPUMASK) + if (field->filter_type =3D=3D FILTER_CPUMASK) { pred->fn_num =3D FILTER_PRED_FN_CPUMASK; + } else { + switch (field->size) { + case 8: + pred->fn_num =3D FILTER_PRED_FN_64_CPUMASK; + break; + case 4: + pred->fn_num =3D FILTER_PRED_FN_32_CPUMASK; + break; + case 2: + pred->fn_num =3D FILTER_PRED_FN_16_CPUMASK; + break; + case 1: + pred->fn_num =3D FILTER_PRED_FN_8_CPUMASK; + break; + } + } =20 /* This is either a string, or an integer */ } else if (str[i] =3D=3D '\'' || str[i] =3D=3D '"') { --=20 2.40.1 From nobody Tue Dec 16 19:54:02 2025 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 1353CC88CB9 for ; Thu, 24 Aug 2023 02:19:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239343AbjHXCTD (ORCPT ); Wed, 23 Aug 2023 22:19:03 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40724 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239300AbjHXCSd (ORCPT ); Wed, 23 Aug 2023 22:18:33 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A185910D9 for ; Wed, 23 Aug 2023 19:18:31 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 32FA863BC0 for ; Thu, 24 Aug 2023 02:18:31 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 9259EC433A9; Thu, 24 Aug 2023 02:18:30 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.96) (envelope-from ) id 1qYzvv-001hRm-13; Wed, 23 Aug 2023 22:18:51 -0400 Message-ID: <20230824021851.138306628@goodmis.org> User-Agent: quilt/0.66 Date: Wed, 23 Aug 2023 22:18:16 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Andrew Morton , Jonathan Corbet , Juri Lelli , Daniel Bristot de Oliveira , Marcelo Tosatti , Leonardo Bras , Frederic Weisbecker , Valentin Schneider Subject: [for-next][PATCH 04/14] tracing/filters: Enable filtering the CPU common field by a cpumask References: <20230824021812.938245293@goodmis.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Valentin Schneider The tracing_cpumask lets us specify which CPUs are traced in a buffer instance, but doesn't let us do this on a per-event basis (unless one creates an instance per event). A previous commit added filtering scalar fields by a user-given cpumask, make this work with the CPU common field as well. This enables doing things like $ trace-cmd record -e 'sched_switch' -f 'CPU & CPUS{12-52}' \ -e 'sched_wakeup' -f 'target_cpu & CPUS{12-52}' Link: https://lkml.kernel.org/r/20230707172155.70873-5-vschneid@redhat.com Cc: Masami Hiramatsu Cc: Jonathan Corbet Cc: Juri Lelli Cc: Daniel Bristot de Oliveira Cc: Marcelo Tosatti Cc: Leonardo Bras Cc: Frederic Weisbecker Signed-off-by: Valentin Schneider Signed-off-by: Steven Rostedt (Google) --- kernel/trace/trace_events_filter.c | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events= _filter.c index 1e14f801685a..3009d0c61b53 100644 --- a/kernel/trace/trace_events_filter.c +++ b/kernel/trace/trace_events_filter.c @@ -68,6 +68,7 @@ enum filter_pred_fn { FILTER_PRED_FN_PCHAR_USER, FILTER_PRED_FN_PCHAR, FILTER_PRED_FN_CPU, + FILTER_PRED_FN_CPU_CPUMASK, FILTER_PRED_FN_CPUMASK, FILTER_PRED_FN_FUNCTION, FILTER_PRED_FN_, @@ -937,6 +938,14 @@ static int filter_pred_cpu(struct filter_pred *pred, v= oid *event) } } =20 +/* Filter predicate for current CPU vs user-provided cpumask */ +static int filter_pred_cpu_cpumask(struct filter_pred *pred, void *event) +{ + int cpu =3D raw_smp_processor_id(); + + return do_filter_scalar_cpumask(pred->op, cpu, pred->mask); +} + /* Filter predicate for cpumask field vs user-provided cpumask */ static int filter_pred_cpumask(struct filter_pred *pred, void *event) { @@ -1440,6 +1449,8 @@ static int filter_pred_fn_call(struct filter_pred *pr= ed, void *event) return filter_pred_pchar(pred, event); case FILTER_PRED_FN_CPU: return filter_pred_cpu(pred, event); + case FILTER_PRED_FN_CPU_CPUMASK: + return filter_pred_cpu_cpumask(pred, event); case FILTER_PRED_FN_CPUMASK: return filter_pred_cpumask(pred, event); case FILTER_PRED_FN_FUNCTION: @@ -1659,6 +1670,7 @@ static int parse_pred(const char *str, void *data, =20 switch (field->filter_type) { case FILTER_CPUMASK: + case FILTER_CPU: case FILTER_OTHER: break; default: @@ -1714,6 +1726,8 @@ static int parse_pred(const char *str, void *data, i++; if (field->filter_type =3D=3D FILTER_CPUMASK) { pred->fn_num =3D FILTER_PRED_FN_CPUMASK; + } else if (field->filter_type =3D=3D FILTER_CPU) { + pred->fn_num =3D FILTER_PRED_FN_CPU_CPUMASK; } else { switch (field->size) { case 8: --=20 2.40.1 From nobody Tue Dec 16 19:54:02 2025 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 455B9EE49AB for ; Thu, 24 Aug 2023 02:19:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239388AbjHXCTR (ORCPT ); Wed, 23 Aug 2023 22:19:17 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40748 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239303AbjHXCSe (ORCPT ); Wed, 23 Aug 2023 22:18:34 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4842BE6D for ; Wed, 23 Aug 2023 19:18:32 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 8D73F651F5 for ; Thu, 24 Aug 2023 02:18:31 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id F0A9AC433C9; Thu, 24 Aug 2023 02:18:30 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.96) (envelope-from ) id 1qYzvv-001hSK-1i; Wed, 23 Aug 2023 22:18:51 -0400 Message-ID: <20230824021851.347395220@goodmis.org> User-Agent: quilt/0.66 Date: Wed, 23 Aug 2023 22:18:17 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Andrew Morton , Jonathan Corbet , Juri Lelli , Daniel Bristot de Oliveira , Marcelo Tosatti , Leonardo Bras , Frederic Weisbecker , Valentin Schneider Subject: [for-next][PATCH 05/14] tracing/filters: Optimise cpumask vs cpumask filtering when user mask is a single CPU References: <20230824021812.938245293@goodmis.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Valentin Schneider Steven noted that when the user-provided cpumask contains a single CPU, then the filtering function can use a scalar as input instead of a full-fledged cpumask. Reuse do_filter_scalar_cpumask() when the input mask has a weight of one. Link: https://lkml.kernel.org/r/20230707172155.70873-6-vschneid@redhat.com Cc: Masami Hiramatsu Cc: Jonathan Corbet Cc: Juri Lelli Cc: Daniel Bristot de Oliveira Cc: Marcelo Tosatti Cc: Leonardo Bras Cc: Frederic Weisbecker Suggested-by: Steven Rostedt Signed-off-by: Valentin Schneider Signed-off-by: Steven Rostedt (Google) --- kernel/trace/trace_events_filter.c | 35 +++++++++++++++++++++++++++++- 1 file changed, 34 insertions(+), 1 deletion(-) diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events= _filter.c index 3009d0c61b53..2fe65ddeb34e 100644 --- a/kernel/trace/trace_events_filter.c +++ b/kernel/trace/trace_events_filter.c @@ -70,6 +70,7 @@ enum filter_pred_fn { FILTER_PRED_FN_CPU, FILTER_PRED_FN_CPU_CPUMASK, FILTER_PRED_FN_CPUMASK, + FILTER_PRED_FN_CPUMASK_CPU, FILTER_PRED_FN_FUNCTION, FILTER_PRED_FN_, FILTER_PRED_TEST_VISITED, @@ -957,6 +958,22 @@ static int filter_pred_cpumask(struct filter_pred *pre= d, void *event) return do_filter_cpumask(pred->op, mask, cmp); } =20 +/* Filter predicate for cpumask field vs user-provided scalar */ +static int filter_pred_cpumask_cpu(struct filter_pred *pred, void *event) +{ + u32 item =3D *(u32 *)(event + pred->offset); + int loc =3D item & 0xffff; + const struct cpumask *mask =3D (event + loc); + unsigned int cpu =3D pred->val; + + /* + * This inverts the usual usage of the function (field is first element, + * user parameter is second), but that's fine because the (scalar, mask) + * operations used are symmetric. + */ + return do_filter_scalar_cpumask(pred->op, cpu, mask); +} + /* Filter predicate for COMM. */ static int filter_pred_comm(struct filter_pred *pred, void *event) { @@ -1453,6 +1470,8 @@ static int filter_pred_fn_call(struct filter_pred *pr= ed, void *event) return filter_pred_cpu_cpumask(pred, event); case FILTER_PRED_FN_CPUMASK: return filter_pred_cpumask(pred, event); + case FILTER_PRED_FN_CPUMASK_CPU: + return filter_pred_cpumask_cpu(pred, event); case FILTER_PRED_FN_FUNCTION: return filter_pred_function(pred, event); case FILTER_PRED_TEST_VISITED: @@ -1666,6 +1685,7 @@ static int parse_pred(const char *str, void *data, =20 } else if (!strncmp(str + i, "CPUS", 4)) { unsigned int maskstart; + bool single; char *tmp; =20 switch (field->filter_type) { @@ -1724,8 +1744,21 @@ static int parse_pred(const char *str, void *data, =20 /* Move along */ i++; + + /* + * Optimisation: if the user-provided mask has a weight of one + * then we can treat it as a scalar input. + */ + single =3D cpumask_weight(pred->mask) =3D=3D 1; + if (single && field->filter_type =3D=3D FILTER_CPUMASK) { + pred->val =3D cpumask_first(pred->mask); + kfree(pred->mask); + } + if (field->filter_type =3D=3D FILTER_CPUMASK) { - pred->fn_num =3D FILTER_PRED_FN_CPUMASK; + pred->fn_num =3D single ? + FILTER_PRED_FN_CPUMASK_CPU : + FILTER_PRED_FN_CPUMASK; } else if (field->filter_type =3D=3D FILTER_CPU) { pred->fn_num =3D FILTER_PRED_FN_CPU_CPUMASK; } else { --=20 2.40.1 From nobody Tue Dec 16 19:54:02 2025 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 9638FEE49AD for ; Thu, 24 Aug 2023 02:19:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239362AbjHXCTM (ORCPT ); Wed, 23 Aug 2023 22:19:12 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40778 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239327AbjHXCSe (ORCPT ); Wed, 23 Aug 2023 22:18:34 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 512CE10DB for ; Wed, 23 Aug 2023 19:18:32 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 8113964F9D for ; Thu, 24 Aug 2023 02:18:31 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id ED882C433C7; Thu, 24 Aug 2023 02:18:30 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.96) (envelope-from ) id 1qYzvv-001hSs-2P; Wed, 23 Aug 2023 22:18:51 -0400 Message-ID: <20230824021851.552383762@goodmis.org> User-Agent: quilt/0.66 Date: Wed, 23 Aug 2023 22:18:18 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Andrew Morton , Jonathan Corbet , Juri Lelli , Daniel Bristot de Oliveira , Marcelo Tosatti , Leonardo Bras , Frederic Weisbecker , Valentin Schneider Subject: [for-next][PATCH 06/14] tracing/filters: Optimise scalar vs cpumask filtering when the user mask is a single CPU References: <20230824021812.938245293@goodmis.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Valentin Schneider Steven noted that when the user-provided cpumask contains a single CPU, then the filtering function can use a scalar as input instead of a full-fledged cpumask. When the mask contains a single CPU, directly re-use the unsigned field predicate functions. Transform '&' into '=3D=3D' beforehand. Link: https://lkml.kernel.org/r/20230707172155.70873-7-vschneid@redhat.com Cc: Masami Hiramatsu Cc: Jonathan Corbet Cc: Juri Lelli Cc: Daniel Bristot de Oliveira Cc: Marcelo Tosatti Cc: Leonardo Bras Cc: Frederic Weisbecker Suggested-by: Steven Rostedt Signed-off-by: Valentin Schneider Signed-off-by: Steven Rostedt (Google) --- kernel/trace/trace_events_filter.c | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events= _filter.c index 2fe65ddeb34e..54d642fabb7f 100644 --- a/kernel/trace/trace_events_filter.c +++ b/kernel/trace/trace_events_filter.c @@ -1750,7 +1750,7 @@ static int parse_pred(const char *str, void *data, * then we can treat it as a scalar input. */ single =3D cpumask_weight(pred->mask) =3D=3D 1; - if (single && field->filter_type =3D=3D FILTER_CPUMASK) { + if (single && field->filter_type !=3D FILTER_CPU) { pred->val =3D cpumask_first(pred->mask); kfree(pred->mask); } @@ -1761,6 +1761,11 @@ static int parse_pred(const char *str, void *data, FILTER_PRED_FN_CPUMASK; } else if (field->filter_type =3D=3D FILTER_CPU) { pred->fn_num =3D FILTER_PRED_FN_CPU_CPUMASK; + } else if (single) { + pred->op =3D pred->op =3D=3D OP_BAND ? OP_EQ : pred->op; + pred->fn_num =3D select_comparison_fn(pred->op, field->size, false); + if (pred->op =3D=3D OP_NE) + pred->not =3D 1; } else { switch (field->size) { case 8: --=20 2.40.1 From nobody Tue Dec 16 19:54:02 2025 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 40BFAC71134 for ; Thu, 24 Aug 2023 02:19:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239378AbjHXCTP (ORCPT ); Wed, 23 Aug 2023 22:19:15 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40760 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239305AbjHXCSe (ORCPT ); Wed, 23 Aug 2023 22:18:34 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A636C10C4 for ; Wed, 23 Aug 2023 19:18:32 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id A9ACB64D73 for ; Thu, 24 Aug 2023 02:18:31 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 28911C43395; Thu, 24 Aug 2023 02:18:31 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.96) (envelope-from ) id 1qYzvv-001hTS-35; Wed, 23 Aug 2023 22:18:51 -0400 Message-ID: <20230824021851.768193955@goodmis.org> User-Agent: quilt/0.66 Date: Wed, 23 Aug 2023 22:18:19 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Andrew Morton , Jonathan Corbet , Juri Lelli , Daniel Bristot de Oliveira , Marcelo Tosatti , Leonardo Bras , Frederic Weisbecker , Valentin Schneider Subject: [for-next][PATCH 07/14] tracing/filters: Optimise CPU vs cpumask filtering when the user mask is a single CPU References: <20230824021812.938245293@goodmis.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Valentin Schneider Steven noted that when the user-provided cpumask contains a single CPU, then the filtering function can use a scalar as input instead of a full-fledged cpumask. In this case we can directly re-use filter_pred_cpu(), we just need to transform '&' into '=3D=3D' before executing it. Link: https://lkml.kernel.org/r/20230707172155.70873-8-vschneid@redhat.com Cc: Masami Hiramatsu Cc: Jonathan Corbet Cc: Juri Lelli Cc: Daniel Bristot de Oliveira Cc: Marcelo Tosatti Cc: Leonardo Bras Cc: Frederic Weisbecker Suggested-by: Steven Rostedt Signed-off-by: Valentin Schneider Signed-off-by: Steven Rostedt (Google) --- kernel/trace/trace_events_filter.c | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events= _filter.c index 54d642fabb7f..fd72dacc5d1b 100644 --- a/kernel/trace/trace_events_filter.c +++ b/kernel/trace/trace_events_filter.c @@ -1750,7 +1750,7 @@ static int parse_pred(const char *str, void *data, * then we can treat it as a scalar input. */ single =3D cpumask_weight(pred->mask) =3D=3D 1; - if (single && field->filter_type !=3D FILTER_CPU) { + if (single) { pred->val =3D cpumask_first(pred->mask); kfree(pred->mask); } @@ -1760,7 +1760,12 @@ static int parse_pred(const char *str, void *data, FILTER_PRED_FN_CPUMASK_CPU : FILTER_PRED_FN_CPUMASK; } else if (field->filter_type =3D=3D FILTER_CPU) { - pred->fn_num =3D FILTER_PRED_FN_CPU_CPUMASK; + if (single) { + pred->op =3D pred->op =3D=3D OP_BAND ? OP_EQ : pred->op; + pred->fn_num =3D FILTER_PRED_FN_CPU; + } else { + pred->fn_num =3D FILTER_PRED_FN_CPU_CPUMASK; + } } else if (single) { pred->op =3D pred->op =3D=3D OP_BAND ? OP_EQ : pred->op; pred->fn_num =3D select_comparison_fn(pred->op, field->size, false); --=20 2.40.1 From nobody Tue Dec 16 19:54:02 2025 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 F0248C7EE43 for ; Thu, 24 Aug 2023 02:19:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239367AbjHXCTN (ORCPT ); Wed, 23 Aug 2023 22:19:13 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40802 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239328AbjHXCSe (ORCPT ); Wed, 23 Aug 2023 22:18:34 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 004C710DE for ; Wed, 23 Aug 2023 19:18:32 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id E7134652C9 for ; Thu, 24 Aug 2023 02:18:31 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 62D67C433CC; Thu, 24 Aug 2023 02:18:31 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.96) (envelope-from ) id 1qYzvw-001hU0-0X; Wed, 23 Aug 2023 22:18:52 -0400 Message-ID: <20230824021851.978619174@goodmis.org> User-Agent: quilt/0.66 Date: Wed, 23 Aug 2023 22:18:20 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Andrew Morton , Jonathan Corbet , Juri Lelli , Daniel Bristot de Oliveira , Marcelo Tosatti , Leonardo Bras , Frederic Weisbecker , Valentin Schneider Subject: [for-next][PATCH 08/14] tracing/filters: Further optimise scalar vs cpumask comparison References: <20230824021812.938245293@goodmis.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Valentin Schneider Per the previous commits, we now only enter do_filter_scalar_cpumask() with a mask of weight greater than one. Optimise the equality checks. Link: https://lkml.kernel.org/r/20230707172155.70873-9-vschneid@redhat.com Cc: Masami Hiramatsu Cc: Jonathan Corbet Cc: Juri Lelli Cc: Daniel Bristot de Oliveira Cc: Marcelo Tosatti Cc: Leonardo Bras Cc: Frederic Weisbecker Suggested-by: Steven Rostedt Signed-off-by: Valentin Schneider Signed-off-by: Steven Rostedt (Google) --- kernel/trace/trace_events_filter.c | 26 ++++++++++++++++++++------ 1 file changed, 20 insertions(+), 6 deletions(-) diff --git a/kernel/trace/trace_events_filter.c b/kernel/trace/trace_events= _filter.c index fd72dacc5d1b..3a529214a21b 100644 --- a/kernel/trace/trace_events_filter.c +++ b/kernel/trace/trace_events_filter.c @@ -667,6 +667,25 @@ do_filter_cpumask(int op, const struct cpumask *mask, = const struct cpumask *cmp) /* Optimisation of do_filter_cpumask() for scalar fields */ static inline int do_filter_scalar_cpumask(int op, unsigned int cpu, const struct cpumask *m= ask) +{ + /* + * Per the weight-of-one cpumask optimisations, the mask passed in this + * function has a weight >=3D 2, so it is never equal to a single scalar. + */ + switch (op) { + case OP_EQ: + return false; + case OP_NE: + return true; + case OP_BAND: + return cpumask_test_cpu(cpu, mask); + default: + return 0; + } +} + +static inline int +do_filter_cpumask_scalar(int op, const struct cpumask *mask, unsigned int = cpu) { switch (op) { case OP_EQ: @@ -966,12 +985,7 @@ static int filter_pred_cpumask_cpu(struct filter_pred = *pred, void *event) const struct cpumask *mask =3D (event + loc); unsigned int cpu =3D pred->val; =20 - /* - * This inverts the usual usage of the function (field is first element, - * user parameter is second), but that's fine because the (scalar, mask) - * operations used are symmetric. - */ - return do_filter_scalar_cpumask(pred->op, cpu, mask); + return do_filter_cpumask_scalar(pred->op, mask, cpu); } =20 /* Filter predicate for COMM. */ --=20 2.40.1 From nobody Tue Dec 16 19:54:02 2025 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 56693EE49A0 for ; Thu, 24 Aug 2023 02:19:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239383AbjHXCTQ (ORCPT ); Wed, 23 Aug 2023 22:19:16 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40772 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239324AbjHXCSe (ORCPT ); Wed, 23 Aug 2023 22:18:34 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A654A10DC for ; Wed, 23 Aug 2023 19:18:32 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id B4E4D65225 for ; Thu, 24 Aug 2023 02:18:31 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 8D113C433C8; Thu, 24 Aug 2023 02:18:31 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.96) (envelope-from ) id 1qYzvw-001hUa-1D; Wed, 23 Aug 2023 22:18:52 -0400 Message-ID: <20230824021852.187790824@goodmis.org> User-Agent: quilt/0.66 Date: Wed, 23 Aug 2023 22:18:21 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Andrew Morton , Jonathan Corbet , Juri Lelli , Daniel Bristot de Oliveira , Marcelo Tosatti , Leonardo Bras , Frederic Weisbecker , Valentin Schneider Subject: [for-next][PATCH 09/14] tracing/filters: Document cpumask filtering References: <20230824021812.938245293@goodmis.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Valentin Schneider Cpumask, scalar and CPU fields can now be filtered by a user-provided cpumask, document the syntax. Link: https://lkml.kernel.org/r/20230707172155.70873-10-vschneid@redhat.com Cc: Masami Hiramatsu Cc: Jonathan Corbet Cc: Juri Lelli Cc: Daniel Bristot de Oliveira Cc: Marcelo Tosatti Cc: Leonardo Bras Cc: Frederic Weisbecker Signed-off-by: Valentin Schneider Signed-off-by: Steven Rostedt (Google) --- Documentation/trace/events.rst | 14 ++++++++++++++ 1 file changed, 14 insertions(+) diff --git a/Documentation/trace/events.rst b/Documentation/trace/events.rst index f5fcb8e1218f..34108d5a55b4 100644 --- a/Documentation/trace/events.rst +++ b/Documentation/trace/events.rst @@ -219,6 +219,20 @@ the function "security_prepare_creds" and less than th= e end of that function. The ".function" postfix can only be attached to values of size long, and c= an only be compared with "=3D=3D" or "!=3D". =20 +Cpumask fields or scalar fields that encode a CPU number can be filtered u= sing +a user-provided cpumask in cpulist format. The format is as follows:: + + CPUS{$cpulist} + +Operators available to cpumask filtering are: + +& (intersection), =3D=3D, !=3D + +For example, this will filter events that have their .target_cpu field pre= sent +in the given cpumask:: + + target_cpu & CPUS{17-42} + 5.2 Setting filters ------------------- =20 --=20 2.40.1 From nobody Tue Dec 16 19:54:02 2025 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 226D5C88CB2 for ; Thu, 24 Aug 2023 02:19:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239373AbjHXCTO (ORCPT ); Wed, 23 Aug 2023 22:19:14 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40788 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239325AbjHXCSe (ORCPT ); Wed, 23 Aug 2023 22:18:34 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 002FD10D9 for ; Wed, 23 Aug 2023 19:18:32 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id E50EA640A7 for ; Thu, 24 Aug 2023 02:18:31 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id C3423C433C7; Thu, 24 Aug 2023 02:18:31 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.96) (envelope-from ) id 1qYzvw-001hV9-1t; Wed, 23 Aug 2023 22:18:52 -0400 Message-ID: <20230824021852.401456868@goodmis.org> User-Agent: quilt/0.66 Date: Wed, 23 Aug 2023 22:18:22 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Andrew Morton , Yue Haibing Subject: [for-next][PATCH 10/14] tracing: Remove unused function declarations References: <20230824021812.938245293@goodmis.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Yue Haibing Commit 9457158bbc0e ("tracing: Fix reset of time stamps during trace_clock = changes") left behind tracing_reset_current() declaration. Also commit 6954e415264e ("tracing: Place trace_pid_list logic into abstrac= t functions") removed trace_free_pid_list() implementation but leave declaration. Link: https://lore.kernel.org/linux-trace-kernel/20230803144028.25492-1-yue= haibing@huawei.com Cc: Signed-off-by: Yue Haibing Signed-off-by: Steven Rostedt (Google) --- kernel/trace/trace.h | 2 -- 1 file changed, 2 deletions(-) diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h index 5b1f9e24764a..b6e44a39b4ce 100644 --- a/kernel/trace/trace.h +++ b/kernel/trace/trace.h @@ -604,7 +604,6 @@ trace_buffer_iter(struct trace_iterator *iter, int cpu) int tracer_init(struct tracer *t, struct trace_array *tr); int tracing_is_enabled(void); void tracing_reset_online_cpus(struct array_buffer *buf); -void tracing_reset_current(int cpu); void tracing_reset_all_online_cpus(void); void tracing_reset_all_online_cpus_unlocked(void); int tracing_open_generic(struct inode *inode, struct file *filp); @@ -705,7 +704,6 @@ void trace_filter_add_remove_task(struct trace_pid_list= *pid_list, void *trace_pid_next(struct trace_pid_list *pid_list, void *v, loff_t *pos= ); void *trace_pid_start(struct trace_pid_list *pid_list, loff_t *pos); int trace_pid_show(struct seq_file *m, void *v); -void trace_free_pid_list(struct trace_pid_list *pid_list); int trace_pid_write(struct trace_pid_list *filtered_pids, struct trace_pid_list **new_pid_list, const char __user *ubuf, size_t cnt); --=20 2.40.1 From nobody Tue Dec 16 19:54:02 2025 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 77592EE49B0 for ; Thu, 24 Aug 2023 02:19:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239403AbjHXCTU (ORCPT ); Wed, 23 Aug 2023 22:19:20 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40814 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239329AbjHXCSe (ORCPT ); Wed, 23 Aug 2023 22:18:34 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 60347E6D for ; Wed, 23 Aug 2023 19:18:33 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 30C72633C6 for ; Thu, 24 Aug 2023 02:18:33 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id A219DC433C7; Thu, 24 Aug 2023 02:18:32 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.96) (envelope-from ) id 1qYzvw-001hVh-2Y; Wed, 23 Aug 2023 22:18:52 -0400 Message-ID: <20230824021852.606651710@goodmis.org> User-Agent: quilt/0.66 Date: Wed, 23 Aug 2023 22:18:23 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Andrew Morton , Zhang Zekun Subject: [for-next][PATCH 11/14] ftrace: Remove empty declaration ftrace_enable_daemon() and ftrace_disable_daemon() References: <20230824021812.938245293@goodmis.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Zhang Zekun The definition of ftrace_enable_daemon() and ftrace_disable_daemon() has been removed since commit cb7be3b2fc2c ("ftrace: remove daemon"), remain the declarations in the header files, so remove it. Link: https://lore.kernel.org/linux-trace-kernel/20230804013636.115940-1-zh= angzekun11@huawei.com Cc: Cc: Signed-off-by: Zhang Zekun Signed-off-by: Steven Rostedt (Google) --- include/linux/ftrace.h | 5 ----- 1 file changed, 5 deletions(-) diff --git a/include/linux/ftrace.h b/include/linux/ftrace.h index aad9cf8876b5..e8921871ef9a 100644 --- a/include/linux/ftrace.h +++ b/include/linux/ftrace.h @@ -862,13 +862,8 @@ extern int skip_trace(unsigned long ip); extern void ftrace_module_init(struct module *mod); extern void ftrace_module_enable(struct module *mod); extern void ftrace_release_mod(struct module *mod); - -extern void ftrace_disable_daemon(void); -extern void ftrace_enable_daemon(void); #else /* CONFIG_DYNAMIC_FTRACE */ static inline int skip_trace(unsigned long ip) { return 0; } -static inline void ftrace_disable_daemon(void) { } -static inline void ftrace_enable_daemon(void) { } static inline void ftrace_module_init(struct module *mod) { } static inline void ftrace_module_enable(struct module *mod) { } static inline void ftrace_release_mod(struct module *mod) { } --=20 2.40.1 From nobody Tue Dec 16 19:54:02 2025 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 E0E81C83003 for ; Thu, 24 Aug 2023 02:19:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239398AbjHXCTT (ORCPT ); Wed, 23 Aug 2023 22:19:19 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40820 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239332AbjHXCSf (ORCPT ); Wed, 23 Aug 2023 22:18:35 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 9FE0510C4 for ; Wed, 23 Aug 2023 19:18:33 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 7FFA364AB2 for ; Thu, 24 Aug 2023 02:18:33 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id F000DC433C9; Thu, 24 Aug 2023 02:18:32 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.96) (envelope-from ) id 1qYzvx-001hWH-00; Wed, 23 Aug 2023 22:18:53 -0400 Message-ID: <20230824021852.814428025@goodmis.org> User-Agent: quilt/0.66 Date: Wed, 23 Aug 2023 22:18:24 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Andrew Morton , Beau Belgrave , Eric Vaughn Subject: [for-next][PATCH 12/14] tracing/user_events: Optimize safe list traversals References: <20230824021812.938245293@goodmis.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Eric Vaughn Several of the list traversals in the user_events facility use safe list traversals where they could be using the unsafe versions instead. Replace these safe traversals with their unsafe counterparts in the interest of optimization. Link: https://lore.kernel.org/linux-trace-kernel/20230810194337.695983-1-er= vaughn@linux.microsoft.com Suggested-by: Beau Belgrave Signed-off-by: Eric Vaughn Acked-by: Beau Belgrave Signed-off-by: Steven Rostedt (Google) --- kernel/trace/trace_events_user.c | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/kernel/trace/trace_events_user.c b/kernel/trace/trace_events_u= ser.c index 33cb6af31f39..6f046650e527 100644 --- a/kernel/trace/trace_events_user.c +++ b/kernel/trace/trace_events_user.c @@ -1328,14 +1328,14 @@ static int user_field_set_string(struct ftrace_even= t_field *field, =20 static int user_event_set_print_fmt(struct user_event *user, char *buf, in= t len) { - struct ftrace_event_field *field, *next; + struct ftrace_event_field *field; struct list_head *head =3D &user->fields; int pos =3D 0, depth =3D 0; const char *str_func; =20 pos +=3D snprintf(buf + pos, LEN_OR_ZERO, "\""); =20 - list_for_each_entry_safe_reverse(field, next, head, link) { + list_for_each_entry_reverse(field, head, link) { if (depth !=3D 0) pos +=3D snprintf(buf + pos, LEN_OR_ZERO, " "); =20 @@ -1347,7 +1347,7 @@ static int user_event_set_print_fmt(struct user_event= *user, char *buf, int len) =20 pos +=3D snprintf(buf + pos, LEN_OR_ZERO, "\""); =20 - list_for_each_entry_safe_reverse(field, next, head, link) { + list_for_each_entry_reverse(field, head, link) { if (user_field_is_dyn_string(field->type, &str_func)) pos +=3D snprintf(buf + pos, LEN_OR_ZERO, ", %s(%s)", str_func, field->name); @@ -1732,7 +1732,7 @@ static int user_event_create(const char *raw_command) static int user_event_show(struct seq_file *m, struct dyn_event *ev) { struct user_event *user =3D container_of(ev, struct user_event, devent); - struct ftrace_event_field *field, *next; + struct ftrace_event_field *field; struct list_head *head; int depth =3D 0; =20 @@ -1740,7 +1740,7 @@ static int user_event_show(struct seq_file *m, struct= dyn_event *ev) =20 head =3D trace_get_fields(&user->call); =20 - list_for_each_entry_safe_reverse(field, next, head, link) { + list_for_each_entry_reverse(field, head, link) { if (depth =3D=3D 0) seq_puts(m, " "); else @@ -1816,13 +1816,14 @@ static bool user_field_match(struct ftrace_event_fi= eld *field, int argc, static bool user_fields_match(struct user_event *user, int argc, const char **argv) { - struct ftrace_event_field *field, *next; + struct ftrace_event_field *field; struct list_head *head =3D &user->fields; int i =3D 0; =20 - list_for_each_entry_safe_reverse(field, next, head, link) + list_for_each_entry_reverse(field, head, link) { if (!user_field_match(field, argc, argv, &i)) return false; + } =20 if (i !=3D argc) return false; --=20 2.40.1 From nobody Tue Dec 16 19:54:02 2025 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 4F4E6C3DA66 for ; Thu, 24 Aug 2023 02:19:37 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239408AbjHXCTV (ORCPT ); Wed, 23 Aug 2023 22:19:21 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40828 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239335AbjHXCSg (ORCPT ); Wed, 23 Aug 2023 22:18:36 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [IPv6:2604:1380:4641:c500::1]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 3893CE6D for ; Wed, 23 Aug 2023 19:18:35 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id C590B633C6 for ; Thu, 24 Aug 2023 02:18:34 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 462E0C433C8; Thu, 24 Aug 2023 02:18:34 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.96) (envelope-from ) id 1qYzvx-001hWq-0g; Wed, 23 Aug 2023 22:18:53 -0400 Message-ID: <20230824021853.022987766@goodmis.org> User-Agent: quilt/0.66 Date: Wed, 23 Aug 2023 22:18:25 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Andrew Morton , Sishuai Gong Subject: [for-next][PATCH 13/14] tracefs: Avoid changing i_mode to a temp value References: <20230824021812.938245293@goodmis.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: Sishuai Gong Right now inode->i_mode is updated twice to reach the desired value in tracefs_apply_options(). Because there is no lock protecting the two writes, other threads might read the intermediate value of inode->i_mode. Thread-1 Thread-2 // tracefs_apply_options() //e.g., acl_permission_check inode->i_mode &=3D ~S_IALLUGO; unsigned int mode =3D inode->i_mode; inode->i_mode |=3D opts->mode; I think there is no need to introduce a lock but it is better to only update inode->i_mode ONCE, so the readers will either see the old or latest value, rather than an intermediate/temporary value. Note, the race is not a security concern as the intermediate value is more locked down than either the start or end version. This is more just to do the conversion cleanly. Link: https://lore.kernel.org/linux-trace-kernel/AB5B0A1C-75D9-4E82-A7F0-CF= 7D0715587B@gmail.com Signed-off-by: Sishuai Gong Signed-off-by: Steven Rostedt (Google) --- fs/tracefs/inode.c | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/fs/tracefs/inode.c b/fs/tracefs/inode.c index bb6de89eb446..c7a10f965602 100644 --- a/fs/tracefs/inode.c +++ b/fs/tracefs/inode.c @@ -310,6 +310,7 @@ static int tracefs_apply_options(struct super_block *sb= , bool remount) struct tracefs_fs_info *fsi =3D sb->s_fs_info; struct inode *inode =3D d_inode(sb->s_root); struct tracefs_mount_opts *opts =3D &fsi->mount_opts; + umode_t tmp_mode; =20 /* * On remount, only reset mode/uid/gid if they were provided as mount @@ -317,8 +318,9 @@ static int tracefs_apply_options(struct super_block *sb= , bool remount) */ =20 if (!remount || opts->opts & BIT(Opt_mode)) { - inode->i_mode &=3D ~S_IALLUGO; - inode->i_mode |=3D opts->mode; + tmp_mode =3D READ_ONCE(inode->i_mode) & ~S_IALLUGO; + tmp_mode |=3D opts->mode; + WRITE_ONCE(inode->i_mode, tmp_mode); } =20 if (!remount || opts->opts & BIT(Opt_uid)) --=20 2.40.1 From nobody Tue Dec 16 19:54:02 2025 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 AB492EE49B3 for ; Thu, 24 Aug 2023 02:19:38 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S239413AbjHXCTV (ORCPT ); Wed, 23 Aug 2023 22:19:21 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:40844 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S239338AbjHXCSk (ORCPT ); Wed, 23 Aug 2023 22:18:40 -0400 Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B075AE6D for ; Wed, 23 Aug 2023 19:18:38 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (2048 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 4DB4A633C6 for ; Thu, 24 Aug 2023 02:18:38 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id BFE0DC433C8; Thu, 24 Aug 2023 02:18:37 +0000 (UTC) Received: from rostedt by gandalf with local (Exim 4.96) (envelope-from ) id 1qYzvx-001hXP-1L; Wed, 23 Aug 2023 22:18:53 -0400 Message-ID: <20230824021853.230766679@goodmis.org> User-Agent: quilt/0.66 Date: Wed, 23 Aug 2023 22:18:26 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Andrew Morton , "Matthew Wilcox (Oracle)" Subject: [for-next][PATCH 14/14] tracefs: Remove kerneldoc from struct eventfs_file References: <20230824021812.938245293@goodmis.org> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" From: "Steven Rostedt (Google)" The struct eventfs_file is a local structure and should not be parsed by kernel doc. It also does not fully follow the kerneldoc format and is causing kerneldoc to spit out errors. Replace the /** to /* so that kerneldoc no longer processes this structure. Also format the comments of the delete union of the structure to be a bit better. Link: https://lore.kernel.org/linux-trace-kernel/20230818201414.2729745-1-w= illy@infradead.org/ Link: https://lore.kernel.org/linux-trace-kernel/20230822053313.77aa3397@ro= rschach.local.home Cc: Mark Rutland Reported-by: Matthew Wilcox (Oracle) Reviewed-by: Masami Hiramatsu (Google) Signed-off-by: Steven Rostedt (Google) --- fs/tracefs/event_inode.c | 14 ++++++++++---- 1 file changed, 10 insertions(+), 4 deletions(-) diff --git a/fs/tracefs/event_inode.c b/fs/tracefs/event_inode.c index da8d2e73cc47..237c6f370ad9 100644 --- a/fs/tracefs/event_inode.c +++ b/fs/tracefs/event_inode.c @@ -27,7 +27,7 @@ struct eventfs_inode { struct list_head e_top_files; }; =20 -/** +/* * struct eventfs_file - hold the properties of the eventfs files and * directories. * @name: the name of the file or directory to create @@ -48,10 +48,16 @@ struct eventfs_file { struct eventfs_inode *ei; const struct file_operations *fop; const struct inode_operations *iop; + /* + * Union - used for deletion + * @del_list: list of eventfs_file to delete + * @rcu: eventfs_file to delete in RCU + * @is_freed: node is freed if one of the above is set + */ union { - struct list_head del_list; /* list of eventfs_file to delete */ - struct rcu_head rcu; /* eventfs_file to delete */ - unsigned long is_freed; /* Freed if one of the above is set */ + struct list_head del_list; + struct rcu_head rcu; + unsigned long is_freed; }; void *data; umode_t mode; --=20 2.40.1