tracing: Remove the backup instance automatically after read

Since the backup instance is readonly, after reading all data via pipe, no
data is left on the instance. Thus it can be removed safely after closing
all files.  This also removes it if user resets the ring buffer manually
via 'trace' file.

Cc: Mathieu Desnoyers <mathieu.desnoyers@efficios.com>
Link: https://patch.msgid.link/177502547711.1311542.12572973358010839400.stgit@mhiramat.tok.corp.google.com
Signed-off-by: Masami Hiramatsu (Google) <mhiramat@kernel.org>
Signed-off-by: Steven Rostedt (Google) <rostedt@goodmis.org>

diff --git a/kernel/trace/trace.c b/kernel/trace/trace.c
index c8e43675ff764370ee16a05d955d8bc7e14076c6..267671b33dd3ae57ee6157358777261b86b82a42 100644 (file)
--- a/kernel/trace/trace.c
+++ b/kernel/trace/trace.c
@@ -578,8 +578,59 @@ void trace_set_ring_buffer_expanded(struct trace_array *tr)
        tr->ring_buffer_expanded = true;
 }
 
+static void trace_array_autoremove(struct work_struct *work)
+{
+       struct trace_array *tr = container_of(work, struct trace_array, autoremove_work);
+
+       trace_array_destroy(tr);
+}
+
+static struct workqueue_struct *autoremove_wq;
+
+static void trace_array_kick_autoremove(struct trace_array *tr)
+{
+       if (autoremove_wq)
+               queue_work(autoremove_wq, &tr->autoremove_work);
+}
+
+static void trace_array_cancel_autoremove(struct trace_array *tr)
+{
+       /*
+        * Since this can be called inside trace_array_autoremove(),
+        * it has to avoid deadlock of the workqueue.
+        */
+       if (work_pending(&tr->autoremove_work))
+               cancel_work_sync(&tr->autoremove_work);
+}
+
+static void trace_array_init_autoremove(struct trace_array *tr)
+{
+       INIT_WORK(&tr->autoremove_work, trace_array_autoremove);
+}
+
+static void trace_array_start_autoremove(void)
+{
+       if (autoremove_wq)
+               return;
+
+       autoremove_wq = alloc_workqueue("tr_autoremove_wq",
+                                       WQ_UNBOUND | WQ_HIGHPRI, 0);
+       if (!autoremove_wq)
+               pr_warn("Unable to allocate tr_autoremove_wq. autoremove disabled.\n");
+}
+
 LIST_HEAD(ftrace_trace_arrays);
 
+static int __trace_array_get(struct trace_array *this_tr)
+{
+       /* When free_on_close is set, this is not available anymore. */
+       if (autoremove_wq && this_tr->free_on_close)
+               return -ENODEV;
+
+       this_tr->ref++;
+       return 0;
+}
+
 int trace_array_get(struct trace_array *this_tr)
 {
        struct trace_array *tr;
@@ -587,8 +638,7 @@ int trace_array_get(struct trace_array *this_tr)
        guard(mutex)(&trace_types_lock);
        list_for_each_entry(tr, &ftrace_trace_arrays, list) {
                if (tr == this_tr) {
-                       tr->ref++;
-                       return 0;
+                       return __trace_array_get(tr);
                }
        }
 
@@ -599,6 +649,12 @@ static void __trace_array_put(struct trace_array *this_tr)
 {
        WARN_ON(!this_tr->ref);
        this_tr->ref--;
+       /*
+        * When free_on_close is set, prepare removing the array
+        * when the last reference is released.
+        */
+       if (this_tr->ref == 1 && this_tr->free_on_close)
+               trace_array_kick_autoremove(this_tr);
 }
 
 /**
@@ -5467,6 +5523,10 @@ static void update_last_data(struct trace_array *tr)
        /* Only if the buffer has previous boot data clear and update it. */
        tr->flags &= ~TRACE_ARRAY_FL_LAST_BOOT;
 
+       /* If this is a backup instance, mark it for autoremove. */
+       if (tr->flags & TRACE_ARRAY_FL_VMALLOC)
+               tr->free_on_close = true;
+
        /* Reset the module list and reload them */
        if (tr->scratch) {
                struct trace_scratch *tscratch = tr->scratch;
@@ -9537,8 +9597,8 @@ struct trace_array *trace_array_find_get(const char *instance)
 
        guard(mutex)(&trace_types_lock);
        tr = trace_array_find(instance);
-       if (tr)
-               tr->ref++;
+       if (tr && __trace_array_get(tr) < 0)
+               tr = NULL;
 
        return tr;
 }
@@ -9635,6 +9695,8 @@ trace_array_create_systems(const char *name, const char *systems,
        if (ftrace_allocate_ftrace_ops(tr) < 0)
                goto out_free_tr;
 
+       trace_array_init_autoremove(tr);
+
        ftrace_init_trace_array(tr);
 
        init_trace_flags_index(tr);
@@ -9745,7 +9807,9 @@ struct trace_array *trace_array_get_by_name(const char *name, const char *system
 
        list_for_each_entry(tr, &ftrace_trace_arrays, list) {
                if (tr->name && strcmp(tr->name, name) == 0) {
-                       tr->ref++;
+                       /* if this fails, @tr is going to be removed. */
+                       if (__trace_array_get(tr) < 0)
+                               tr = NULL;
                        return tr;
                }
        }
@@ -9784,6 +9848,7 @@ static int __remove_instance(struct trace_array *tr)
                        set_tracer_flag(tr, 1ULL << i, 0);
        }
 
+       trace_array_cancel_autoremove(tr);
        tracing_set_nop(tr);
        clear_ftrace_function_probes(tr);
        event_trace_del_tracer(tr);
@@ -10790,8 +10855,10 @@ __init static void enable_instances(void)
                /*
                 * Backup buffers can be freed but need vfree().
                 */
-               if (backup)
+               if (backup) {
                        tr->flags |= TRACE_ARRAY_FL_VMALLOC | TRACE_ARRAY_FL_RDONLY;
+                       trace_array_start_autoremove();
+               }
 
                if (start || backup) {
                        tr->flags |= TRACE_ARRAY_FL_BOOT | TRACE_ARRAY_FL_LAST_BOOT;

diff --git a/kernel/trace/trace.h b/kernel/trace/trace.h
index 366baa43dfab124dd0c5e7fde7cab152570bf6b7..b001fbba08815c43b0d0e6a9f95e16ae50e35dba 100644 (file)
--- a/kernel/trace/trace.h
+++ b/kernel/trace/trace.h
@@ -453,6 +453,12 @@ struct trace_array {
         * we do not waste memory on systems that are not using tracing.
         */
        bool ring_buffer_expanded;
+       /*
+        * If the ring buffer is a read only backup instance, it will be
+        * removed after dumping all data via pipe, because no readable data.
+        */
+       bool free_on_close;
+       struct work_struct      autoremove_work;
 };
 
 enum {