tracing: Remove size restriction on tracing_log_err cmd strings

Currently, tracing_log_err.cmd strings are restricted to a length of
MAX_FILTER_STR_VAL (256), which is too short for some commands already
seen in the wild (with cmd strings longer than that showing up
truncated).

Remove the restriction so that no command string is ever truncated.

Link: https://lkml.kernel.org/r/ca965f23256b350ebd94b3dc1a319f28e8267f5f.1643319703.git.zanussi@kernel.org
Signed-off-by: Tom Zanussi <zanussi@kernel.org>
Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>

diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index 7c2578e..7c85ce9 100644 (file)
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -7723,7 +7723,7 @@ const struct file_operations trace_min_max_fops = {
 struct err_info {
        const char      **errs; /* ptr to loc-specific array of err strings */
        u8              type;   /* index into errs -> specific err string */
-       u8              pos;    /* MAX_FILTER_STR_VAL = 256 */
+       u16             pos;    /* caret position */
        u64             ts;
 };
 
@@ -7731,26 +7731,52 @@ struct tracing_log_err {
        struct list_head        list;
        struct err_info         info;
        char                    loc[TRACING_LOG_LOC_MAX]; /* err location */
-       char                    cmd[MAX_FILTER_STR_VAL]; /* what caused err */
+       char                    *cmd;                     /* what caused err */
 };
 
 static DEFINE_MUTEX(tracing_err_log_lock);
 
-static struct tracing_log_err *get_tracing_log_err(struct trace_array *tr)
+static struct tracing_log_err *alloc_tracing_log_err(int len)
+{
+       struct tracing_log_err *err;
+
+       err = kzalloc(sizeof(*err), GFP_KERNEL);
+       if (!err)
+               return ERR_PTR(-ENOMEM);
+
+       err->cmd = kzalloc(len, GFP_KERNEL);
+       if (!err->cmd) {
+               kfree(err);
+               return ERR_PTR(-ENOMEM);
+       }
+
+       return err;
+}
+
+static void free_tracing_log_err(struct tracing_log_err *err)
+{
+       kfree(err->cmd);
+       kfree(err);
+}
+
+static struct tracing_log_err *get_tracing_log_err(struct trace_array *tr,
+                                                  int len)
 {
        struct tracing_log_err *err;
 
        if (tr->n_err_log_entries < TRACING_LOG_ERRS_MAX) {
-               err = kzalloc(sizeof(*err), GFP_KERNEL);
-               if (!err)
-                       err = ERR_PTR(-ENOMEM);
-               else
+               err = alloc_tracing_log_err(len);
+               if (PTR_ERR(err) != -ENOMEM)
                        tr->n_err_log_entries++;
 
                return err;
        }
 
        err = list_first_entry(&tr->err_log, struct tracing_log_err, list);
+       kfree(err->cmd);
+       err->cmd = kzalloc(len, GFP_KERNEL);
+       if (!err->cmd)
+               return ERR_PTR(-ENOMEM);
        list_del(&err->list);
 
        return err;
@@ -7811,22 +7837,25 @@ unsigned int err_pos(char *cmd, const char *str)
  */
 void tracing_log_err(struct trace_array *tr,
                     const char *loc, const char *cmd,
-                    const char **errs, u8 type, u8 pos)
+                    const char **errs, u8 type, u16 pos)
 {
        struct tracing_log_err *err;
+       int len = 0;
 
        if (!tr)
                tr = &global_trace;
 
+       len += sizeof(CMD_PREFIX) + 2 * sizeof("\n") + strlen(cmd) + 1;
+
        mutex_lock(&tracing_err_log_lock);
-       err = get_tracing_log_err(tr);
+       err = get_tracing_log_err(tr, len);
        if (PTR_ERR(err) == -ENOMEM) {
                mutex_unlock(&tracing_err_log_lock);
                return;
        }
 
        snprintf(err->loc, TRACING_LOG_LOC_MAX, "%s: error: ", loc);
-       snprintf(err->cmd, MAX_FILTER_STR_VAL,"\n" CMD_PREFIX "%s\n", cmd);
+       snprintf(err->cmd, len, "\n" CMD_PREFIX "%s\n", cmd);
 
        err->info.errs = errs;
        err->info.type = type;
@@ -7844,7 +7873,7 @@ static void clear_tracing_err_log(struct trace_array *tr)
        mutex_lock(&tracing_err_log_lock);
        list_for_each_entry_safe(err, next, &tr->err_log, list) {
                list_del(&err->list);
-               kfree(err);
+               free_tracing_log_err(err);
        }
 
        tr->n_err_log_entries = 0;
@@ -7872,9 +7901,9 @@ static void tracing_err_log_seq_stop(struct seq_file *m, void *v)
        mutex_unlock(&tracing_err_log_lock);
 }
 
-static void tracing_err_log_show_pos(struct seq_file *m, u8 pos)
+static void tracing_err_log_show_pos(struct seq_file *m, u16 pos)
 {
-       u8 i;
+       u16 i;
 
        for (i = 0; i < sizeof(CMD_PREFIX) - 1; i++)
                seq_putc(m, ' ');

diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index d038ddb..0f5e222 100644 (file)
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -1878,7 +1878,7 @@ extern ssize_t trace_parse_run_command(struct file *file,
 extern unsigned int err_pos(char *cmd, const char *str);
 extern void tracing_log_err(struct trace_array *tr,
                            const char *loc, const char *cmd,
-                           const char **errs, u8 type, u8 pos);
+                           const char **errs, u8 type, u16 pos);
 
 /*
  * Normal trace_printk() and friends allocates special buffers