1 files changed, 83 insertions, 2 deletions

diff --git a/drivers/remoteproc/remoteproc_debugfs.c b/drivers/remoteproc/remoteproc_debugfs.c
index 03833850f214..157a57309601 100644
--- a/drivers/remoteproc/remoteproc_debugfs.c
+++ b/drivers/remoteproc/remoteproc_debugfs.c
@@ -28,6 +28,9 @@
 #include <linux/debugfs.h>
 #include <linux/remoteproc.h>
 #include <linux/device.h>
+#include <linux/uaccess.h>
+
+#include "remoteproc_internal.h"
 
 /* remoteproc debugfs parent dir */
 static struct dentry *rproc_dbg;
@@ -79,7 +82,7 @@ static ssize_t rproc_state_read(struct file *filp, char __user *userbuf,
 
         state = rproc->state > RPROC_LAST ? RPROC_LAST : rproc->state;
 
-        i = snprintf(buf, 30, "%.28s (%d)\n", rproc_state_string[state],
+        i = scnprintf(buf, 30, "%.28s (%d)\n", rproc_state_string[state],
                                                         rproc->state);
 
         return simple_read_from_buffer(userbuf, count, ppos, buf, i);
@@ -100,7 +103,7 @@ static ssize_t rproc_name_read(struct file *filp, char __user *userbuf,
         char buf[100];
         int i;
 
-        i = snprintf(buf, sizeof(buf), "%.98s\n", rproc->name);
+        i = scnprintf(buf, sizeof(buf), "%.98s\n", rproc->name);
 
         return simple_read_from_buffer(userbuf, count, ppos, buf, i);
 }
@@ -111,6 +114,82 @@ static const struct file_operations rproc_name_ops = {
         .llseek = generic_file_llseek,
 };
 
+/* expose recovery flag via debugfs */
+static ssize_t rproc_recovery_read(struct file *filp, char __user *userbuf,
+                                   size_t count, loff_t *ppos)
+{
+        struct rproc *rproc = filp->private_data;
+        char *buf = rproc->recovery_disabled ? "disabled\n" : "enabled\n";
+
+        return simple_read_from_buffer(userbuf, count, ppos, buf, strlen(buf));
+}
+
+/*
+ * By writing to the 'recovery' debugfs entry, we control the behavior of the
+ * recovery mechanism dynamically. The default value of this entry is "enabled".
+ *
+ * The 'recovery' debugfs entry supports these commands:
+ *
+ * enabled:     When enabled, the remote processor will be automatically
+ *              recovered whenever it crashes. Moreover, if the remote
+ *              processor crashes while recovery is disabled, it will
+ *              be automatically recovered too as soon as recovery is enabled.
+ *
+ * disabled:    When disabled, a remote processor will remain in a crashed
+ *              state if it crashes. This is useful for debugging purposes;
+ *              without it, debugging a crash is substantially harder.
+ *
+ * recover:     This function will trigger an immediate recovery if the
+ *              remote processor is in a crashed state, without changing
+ *              or checking the recovery state (enabled/disabled).
+ *              This is useful during debugging sessions, when one expects
+ *              additional crashes to happen after enabling recovery. In this
+ *              case, enabling recovery will make it hard to debug subsequent
+ *              crashes, so it's recommended to keep recovery disabled, and
+ *              instead use the "recover" command as needed.
+ */
+static ssize_t
+rproc_recovery_write(struct file *filp, const char __user *user_buf,
+                     size_t count, loff_t *ppos)
+{
+        struct rproc *rproc = filp->private_data;
+        char buf[10];
+        int ret;
+
+        if (count > sizeof(buf))
+                return count;
+
+        ret = copy_from_user(buf, user_buf, count);
+        if (ret)
+                return -EFAULT;
+
+        /* remove end of line */
+        if (buf[count - 1] == '\n')
+                buf[count - 1] = '\0';
+
+        if (!strncmp(buf, "enabled", count)) {
+                rproc->recovery_disabled = false;
+                /* if rproc has crashed, trigger recovery */
+                if (rproc->state == RPROC_CRASHED)
+                        rproc_trigger_recovery(rproc);
+        } else if (!strncmp(buf, "disabled", count)) {
+                rproc->recovery_disabled = true;
+        } else if (!strncmp(buf, "recover", count)) {
+                /* if rproc has crashed, trigger recovery */
+                if (rproc->state == RPROC_CRASHED)
+                        rproc_trigger_recovery(rproc);
+        }
+
+        return count;
+}
+
+static const struct file_operations rproc_recovery_ops = {
+        .read = rproc_recovery_read,
+        .write = rproc_recovery_write,
+        .open = simple_open,
+        .llseek = generic_file_llseek,
+};
+
 void rproc_remove_trace_file(struct dentry *tfile)
 {
         debugfs_remove(tfile);
@@ -154,6 +233,8 @@ void rproc_create_debug_dir(struct rproc *rproc)
                                         rproc, &rproc_name_ops);
         debugfs_create_file("state", 0400, rproc->dbg_dir,
                                         rproc, &rproc_state_ops);
+        debugfs_create_file("recovery", 0400, rproc->dbg_dir,
+                                        rproc, &rproc_recovery_ops);
 }
 
 void __init rproc_init_debugfs(void)