tracing: Switch trace_events_trigger.c code over to use guard()

There are a few functions in trace_events_trigger.c that have "goto out" or
equivalent on error in order to release locks that were taken. This can be
error prone or just simply make the code more complex.

Switch every location that ends with unlocking a mutex on error over to
using the guard(mutex)() infrastructure to let the compiler worry about
releasing locks. This makes the code easier to read and understand.

Also use __free() for free a temporary buffer in event_trigger_regex_write().

Cc: Masami Hiramatsu <mhiramat@kernel.org>
Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Cc: Peter Zijlstra <peterz@infradead.org>
Link: https://lore.kernel.org/20241220110621.639d3bc8@gandalf.local.home
Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>

diff --git a/kernel/trace/trace_events_trigger.c b/kernel/trace/trace_events_trigger.c
index a5e3d6acf1e1e241ffeef791b9281c47840dfaea..d454489470946499df48294f161e670fac3d097f 100644 (file)
--- a/kernel/trace/trace_events_trigger.c
+++ b/kernel/trace/trace_events_trigger.c
@@ -211,12 +211,10 @@ static int event_trigger_regex_open(struct inode *inode, struct file *file)
        if (ret)
                return ret;
 
-       mutex_lock(&event_mutex);
+       guard(mutex)(&event_mutex);
 
-       if (unlikely(!event_file_file(file))) {
-               mutex_unlock(&event_mutex);
+       if (unlikely(!event_file_file(file)))
                return -ENODEV;
-       }
 
        if ((file->f_mode & FMODE_WRITE) &&
            (file->f_flags & O_TRUNC)) {
@@ -239,8 +237,6 @@ static int event_trigger_regex_open(struct inode *inode, struct file *file)
                }
        }
 
-       mutex_unlock(&event_mutex);
-
        return ret;
 }
 
@@ -248,7 +244,6 @@ int trigger_process_regex(struct trace_event_file *file, char *buff)
 {
        char *command, *next;
        struct event_command *p;
-       int ret = -EINVAL;
 
        next = buff = skip_spaces(buff);
        command = strsep(&next, ": \t");
@@ -259,17 +254,14 @@ int trigger_process_regex(struct trace_event_file *file, char *buff)
        }
        command = (command[0] != '!') ? command : command + 1;
 
-       mutex_lock(&trigger_cmd_mutex);
+       guard(mutex)(&trigger_cmd_mutex);
+
        list_for_each_entry(p, &trigger_commands, list) {
-               if (strcmp(p->name, command) == 0) {
-                       ret = p->parse(p, file, buff, command, next);
-                       goto out_unlock;
-               }
+               if (strcmp(p->name, command) == 0)
+                       return p->parse(p, file, buff, command, next);
        }
- out_unlock:
-       mutex_unlock(&trigger_cmd_mutex);
 
-       return ret;
+       return -EINVAL;
 }
 
 static ssize_t event_trigger_regex_write(struct file *file,
@@ -278,7 +270,7 @@ static ssize_t event_trigger_regex_write(struct file *file,
 {
        struct trace_event_file *event_file;
        ssize_t ret;
-       char *buf;
+       char *buf __free(kfree) = NULL;
 
        if (!cnt)
                return 0;
@@ -292,24 +284,18 @@ static ssize_t event_trigger_regex_write(struct file *file,
 
        strim(buf);
 
-       mutex_lock(&event_mutex);
+       guard(mutex)(&event_mutex);
+
        event_file = event_file_file(file);
-       if (unlikely(!event_file)) {
-               mutex_unlock(&event_mutex);
-               kfree(buf);
+       if (unlikely(!event_file))
                return -ENODEV;
-       }
-       ret = trigger_process_regex(event_file, buf);
-       mutex_unlock(&event_mutex);
 
-       kfree(buf);
+       ret = trigger_process_regex(event_file, buf);
        if (ret < 0)
-               goto out;
+               return ret;
 
        *ppos += cnt;
-       ret = cnt;
- out:
-       return ret;
+       return cnt;
 }
 
 static int event_trigger_regex_release(struct inode *inode, struct file *file)
@@ -359,20 +345,16 @@ const struct file_operations event_trigger_fops = {
 __init int register_event_command(struct event_command *cmd)
 {
        struct event_command *p;
-       int ret = 0;
 
-       mutex_lock(&trigger_cmd_mutex);
+       guard(mutex)(&trigger_cmd_mutex);
+
        list_for_each_entry(p, &trigger_commands, list) {
-               if (strcmp(cmd->name, p->name) == 0) {
-                       ret = -EBUSY;
-                       goto out_unlock;
-               }
+               if (strcmp(cmd->name, p->name) == 0)
+                       return -EBUSY;
        }
        list_add(&cmd->list, &trigger_commands);
- out_unlock:
-       mutex_unlock(&trigger_cmd_mutex);
 
-       return ret;
+       return 0;
 }
 
 /*
@@ -382,20 +364,17 @@ __init int register_event_command(struct event_command *cmd)
 __init int unregister_event_command(struct event_command *cmd)
 {
        struct event_command *p, *n;
-       int ret = -ENODEV;
 
-       mutex_lock(&trigger_cmd_mutex);
+       guard(mutex)(&trigger_cmd_mutex);
+
        list_for_each_entry_safe(p, n, &trigger_commands, list) {
                if (strcmp(cmd->name, p->name) == 0) {
-                       ret = 0;
                        list_del_init(&p->list);
-                       goto out_unlock;
+                       return 0;
                }
        }
- out_unlock:
-       mutex_unlock(&trigger_cmd_mutex);
 
-       return ret;
+       return -ENODEV;
 }
 
 /**