From nobody Sat Feb 7 21:14:37 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id C934E3358C8 for ; Wed, 29 Oct 2025 14:40:44 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761748844; cv=none; b=n+3y50b+h2WJoTWecjKcU9yUTWRpTrOmnM/jh50/wKqf6zIbRvzYWqcttTHE6mOMzJWXIEVPIO5t9Uvj4RemPwo+WQ7MOf2JnDgLTUjyFvkOxY5ZW1qGAAth/HYR5h1hwDXiC12iFpzeCMBquox1PLS8uDsc+KPGfAfsaRkNSew= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1761748844; c=relaxed/simple; bh=2Srbg2Kj4p1NwOSAgbIL8bzgeOl+TxsgknPmAtyuzig=; h=Message-ID:Date:From:To:Cc:Subject:References:MIME-Version: Content-Type; b=ePsHE0N3DnRfcjlSFgpcp7jcC6pmvPbO82ji4Z/aQDGsxG5LKgQ8Y/Cvcxt5qklvjVIqztkcv6iWFRLoZ8IGVI+5LlaSt9Fjjf7EEBy7IfmAgUChB8u+CVFbBsJjK0/3dIG1XAcwC0Zi7/9cSt6zovFyGoWmWZM1Kg+1yKFCsGE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=UVLv5Oyi; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="UVLv5Oyi" Received: by smtp.kernel.org (Postfix) with ESMTPSA id 998FAC4CEFD; Wed, 29 Oct 2025 14:40:44 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1761748844; bh=2Srbg2Kj4p1NwOSAgbIL8bzgeOl+TxsgknPmAtyuzig=; h=Date:From:To:Cc:Subject:References:From; b=UVLv5Oyi/ih3t7g5Q2wvyaW9PvPreQgH+2J0gdIGiBIXVu6Z3yvI5ar7Mdq4LYCMm 9V/0cIeu558/YJR5xvySm8tSPlL/B1pKwk1nAuHGK7p47JyV3DmvruT3B6wgprOvnJ b1Mwd0u1w9Kr3WwR3ZgpUzh9yAOq91+A+ORXFIHIUjsb1QFFjgvx0EOJABnWikI4mh ZxSP3fZCPIXWvCRvFIchexU6rsQcrkCl8D5L9CBTlnzyHJMFOCIeX5d/7DW7Iuetyr +itDSGZgHoO8lCEpUhBNLqNLSFHr07Bl/3GQhcPfeKa61UDVnKRhpEZL2oBihTzwdH kFPvqoylozpHw== Received: from rostedt by gandalf with local (Exim 4.98.2) (envelope-from ) id 1vE7Mb-000000052zC-1rdY; Wed, 29 Oct 2025 10:41:25 -0400 Message-ID: <20251029144125.295040814@kernel.org> User-Agent: quilt/0.68 Date: Wed, 29 Oct 2025 10:40:52 -0400 From: Steven Rostedt To: linux-kernel@vger.kernel.org Cc: Masami Hiramatsu , Mark Rutland , Mathieu Desnoyers , Andrew Morton , Peter Zijlstra , Namhyung Kim , Takaya Saeki , Tom Zanussi , Thomas Gleixner , Ian Rogers , Douglas Raillard , Arnaldo Carvalho de Melo , Jiri Olsa , Adrian Hunter , Ingo Molnar Subject: [for-next][PATCH 11/13] tracing: Add parsing of flags to the sys_enter_openat trace event References: <20251029144041.475297995@kernel.org> 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" From: Steven Rostedt Add some logic to give the openat system call trace event a bit more human readable information: syscalls:sys_enter_openat: dfd: 0xffffff9c, filename: 0x7f0053dc121c "/e= tc/ld.so.cache", flags: O_RDONLY|O_CLOEXEC, mode: 0000 The above is output from "perf script" and now shows the flags used by the openat system call. Since the output from tracing is in the kernel, it can also remove the mode field when not used (when flags does not contain O_CREATE|O_TMPFILE) touch-1185 [002] ...1. 1291.690154: sys_openat(dfd: 4294967196, file= name: 139785545139344 "/usr/lib/locale/locale-archive", flags: O_RDONLY|O_C= LOEXEC) touch-1185 [002] ...1. 1291.690504: sys_openat(dfd: 1844674407370955= 1516, filename: 140733603151330 "/tmp/x", flags: O_WRONLY|O_CREAT|O_NOCTTY|= O_NONBLOCK, mode: 0666) As system calls have a fixed ABI, their trace events can be extended. This currently only updates the openat system call, but others may be extended in the future. Cc: Masami Hiramatsu Cc: Mark Rutland Cc: Mathieu Desnoyers Cc: Andrew Morton Cc: Peter Zijlstra Cc: Namhyung Kim Cc: Takaya Saeki Cc: Tom Zanussi Cc: Thomas Gleixner Cc: Ian Rogers Cc: Douglas Raillard Cc: Arnaldo Carvalho de Melo Cc: Jiri Olsa Cc: Adrian Hunter Cc: Ingo Molnar Link: https://lore.kernel.org/20251028231148.763161484@kernel.org Signed-off-by: Steven Rostedt (Google) --- kernel/trace/trace_syscalls.c | 192 ++++++++++++++++++++++++++++++++-- 1 file changed, 182 insertions(+), 10 deletions(-) diff --git a/kernel/trace/trace_syscalls.c b/kernel/trace/trace_syscalls.c index 2d1307f13e13..47d9771e8f7c 100644 --- a/kernel/trace/trace_syscalls.c +++ b/kernel/trace/trace_syscalls.c @@ -127,6 +127,116 @@ const char *get_syscall_name(int syscall) /* Added to user strings or arrays when max limit is reached */ #define EXTRA "..." =20 +static void get_dynamic_len_ptr(struct syscall_trace_enter *trace, + struct syscall_metadata *entry, + int *offset_p, int *len_p, unsigned char **ptr_p) +{ + unsigned char *ptr; + int offset =3D *offset_p; + int val; + + /* This arg points to a user space string */ + ptr =3D (void *)trace->args + sizeof(long) * entry->nb_args + offset; + val =3D *(int *)ptr; + + /* The value is a dynamic string (len << 16 | offset) */ + ptr =3D (void *)trace + (val & 0xffff); + *len_p =3D val >> 16; + offset +=3D 4; + + *ptr_p =3D ptr; + *offset_p =3D offset; +} + +static enum print_line_t +sys_enter_openat_print(struct syscall_trace_enter *trace, struct syscall_m= etadata *entry, + struct trace_seq *s, struct trace_event *event) +{ + unsigned char *ptr; + int offset =3D 0; + int bits, len; + bool done =3D false; + static const struct trace_print_flags __flags[] =3D + { + { O_TMPFILE, "O_TMPFILE" }, + { O_WRONLY, "O_WRONLY" }, + { O_RDWR, "O_RDWR" }, + { O_CREAT, "O_CREAT" }, + { O_EXCL, "O_EXCL" }, + { O_NOCTTY, "O_NOCTTY" }, + { O_TRUNC, "O_TRUNC" }, + { O_APPEND, "O_APPEND" }, + { O_NONBLOCK, "O_NONBLOCK" }, + { O_DSYNC, "O_DSYNC" }, + { O_DIRECT, "O_DIRECT" }, + { O_LARGEFILE, "O_LARGEFILE" }, + { O_DIRECTORY, "O_DIRECTORY" }, + { O_NOFOLLOW, "O_NOFOLLOW" }, + { O_NOATIME, "O_NOATIME" }, + { O_CLOEXEC, "O_CLOEXEC" }, + { -1, NULL } + }; + + trace_seq_printf(s, "%s(", entry->name); + + for (int i =3D 0; !done && i < entry->nb_args; i++) { + + if (trace_seq_has_overflowed(s)) + goto end; + + if (i) + trace_seq_puts(s, ", "); + + switch (i) { + case 2: + bits =3D trace->args[2]; + + trace_seq_puts(s, "flags: "); + + /* No need to show mode when not creating the file */ + if (!(bits & (O_CREAT|O_TMPFILE))) + done =3D true; + + if (!(bits & O_ACCMODE)) { + if (!bits) { + trace_seq_puts(s, "O_RDONLY"); + continue; + } + trace_seq_puts(s, "O_RDONLY|"); + } + + trace_print_flags_seq(s, "|", bits, __flags); + /* + * trace_print_flags_seq() adds a '\0' to the + * buffer, but this needs to append more to the seq. + */ + if (!trace_seq_has_overflowed(s)) + trace_seq_pop(s); + + continue; + case 3: + trace_seq_printf(s, "%s: 0%03o", entry->args[i], + (unsigned int)trace->args[i]); + continue; + } + + trace_seq_printf(s, "%s: %lu", entry->args[i], + trace->args[i]); + + if (!(BIT(i) & entry->user_mask)) + continue; + + get_dynamic_len_ptr(trace, entry, &offset, &len, &ptr); + trace_seq_printf(s, " \"%.*s\"", len, ptr); + } + + trace_seq_putc(s, ')'); +end: + trace_seq_putc(s, '\n'); + + return trace_handle_return(s); +} + static enum print_line_t print_syscall_enter(struct trace_iterator *iter, int flags, struct trace_event *event) @@ -152,6 +262,15 @@ print_syscall_enter(struct trace_iterator *iter, int f= lags, goto end; } =20 + switch (entry->syscall_nr) { + case __NR_openat: + if (!tr || !(tr->trace_flags & TRACE_ITER_VERBOSE)) + return sys_enter_openat_print(trace, entry, s, event); + break; + default: + break; + } + trace_seq_printf(s, "%s(", entry->name); =20 for (i =3D 0; i < entry->nb_args; i++) { @@ -179,14 +298,7 @@ print_syscall_enter(struct trace_iterator *iter, int f= lags, if (!(BIT(i) & entry->user_mask)) continue; =20 - /* This arg points to a user space string */ - ptr =3D (void *)trace->args + sizeof(long) * entry->nb_args + offset; - val =3D *(int *)ptr; - - /* The value is a dynamic string (len << 16 | offset) */ - ptr =3D (void *)ent + (val & 0xffff); - len =3D val >> 16; - offset +=3D 4; + get_dynamic_len_ptr(trace, entry, &offset, &len, &ptr); =20 if (entry->user_arg_size < 0 || entry->user_arg_is_str) { trace_seq_printf(s, " \"%.*s\"", len, ptr); @@ -269,6 +381,62 @@ print_syscall_exit(struct trace_iterator *iter, int fl= ags, .size =3D sizeof(_type), .align =3D __alignof__(_type), \ .is_signed =3D is_signed_type(_type), .filter_type =3D FILTER_OTHER } =20 +/* When len=3D0, we just calculate the needed length */ +#define LEN_OR_ZERO (len ? len - pos : 0) + +static int __init +sys_enter_openat_print_fmt(struct syscall_metadata *entry, char *buf, int = len) +{ + int pos =3D 0; + + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "\"dfd: 0x%%08lx, filename: 0x%%08lx \\\"%%s\\\", flags: %%s%%s, mode: = 0%%03o\","); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + " ((unsigned long)(REC->dfd)),"); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + " ((unsigned long)(REC->filename)),"); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + " __get_str(__filename_val),"); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + " (REC->flags & ~3) && !(REC->flags & 3) ? \"O_RDONLY|\" : \"\", "); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + " REC->flags ? __print_flags(REC->flags, \"|\", "); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "{ 0x%x, \"O_WRONLY\" }, ", O_WRONLY); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "{ 0x%x, \"O_RDWR\" }, ", O_RDWR); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "{ 0x%x, \"O_CREAT\" }, ", O_CREAT); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "{ 0x%x, \"O_EXCL\" }, ", O_EXCL); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "{ 0x%x, \"O_NOCTTY\" }, ", O_NOCTTY); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "{ 0x%x, \"O_TRUNC\" }, ", O_TRUNC); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "{ 0x%x, \"O_APPEND\" }, ", O_APPEND); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "{ 0x%x, \"O_NONBLOCK\" }, ", O_NONBLOCK); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "{ 0x%x, \"O_DSYNC\" }, ", O_DSYNC); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "{ 0x%x, \"O_DIRECT\" }, ", O_DIRECT); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "{ 0x%x, \"O_LARGEFILE\" }, ", O_LARGEFILE); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "{ 0x%x, \"O_DIRECTORY\" }, ", O_DIRECTORY); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "{ 0x%x, \"O_NOFOLLOW\" }, ", O_NOFOLLOW); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "{ 0x%x, \"O_NOATIME\" }, ", O_NOATIME); + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + "{ 0x%x, \"O_CLOEXEC\" }) : \"O_RDONLY\", ", O_CLOEXEC); + + pos +=3D snprintf(buf + pos, LEN_OR_ZERO, + " ((unsigned long)(REC->mode))"); + return pos; +} + static int __init __set_enter_print_fmt(struct syscall_metadata *entry, char *buf, int len) { @@ -276,8 +444,12 @@ __set_enter_print_fmt(struct syscall_metadata *entry, = char *buf, int len) int i; int pos =3D 0; =20 - /* When len=3D0, we just calculate the needed length */ -#define LEN_OR_ZERO (len ? len - pos : 0) + switch (entry->syscall_nr) { + case __NR_openat: + return sys_enter_openat_print_fmt(entry, buf, len); + default: + break; + } =20 pos +=3D snprintf(buf + pos, LEN_OR_ZERO, "\""); for (i =3D 0; i < entry->nb_args; i++) { --=20 2.51.0