drivers/remoteproc/remoteproc_debugfs.c

   1 /*
   2  * Remote Processor Framework
   3  *
   4  * Copyright (C) 2011 Texas Instruments, Inc.
   5  * Copyright (C) 2011 Google, Inc.
   6  *
   7  * Ohad Ben-Cohen <ohad@wizery.com>
   8  * Mark Grosen <mgrosen@ti.com>
   9  * Brian Swetland <swetland@google.com>
  10  * Fernando Guzman Lugo <fernando.lugo@ti.com>
  11  * Suman Anna <s-anna@ti.com>
  12  * Robert Tivy <rtivy@ti.com>
  13  * Armando Uribe De Leon <x0095078@ti.com>
  14  *
  15  * This program is free software; you can redistribute it and/or
  16  * modify it under the terms of the GNU General Public License
  17  * version 2 as published by the Free Software Foundation.
  18  *
  19  * This program is distributed in the hope that it will be useful,
  20  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  21  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  22  * GNU General Public License for more details.
  23  */
  24
  25 #define pr_fmt(fmt)    "%s: " fmt, __func__
  26
  27 #include <linux/kernel.h>
  28 #include <linux/debugfs.h>
  29 #include <linux/remoteproc.h>
  30 #include <linux/device.h>
  31 #include <linux/uaccess.h>
  32
  33 #include "remoteproc_internal.h"
  34
  35 /* remoteproc debugfs parent dir */
  36 static struct dentry *rproc_dbg;
  37
  38 /*
  39  * Some remote processors may support dumping trace logs into a shared
  40  * memory buffer. We expose this trace buffer using debugfs, so users
  41  * can easily tell what's going on remotely.
  42  *
  43  * We will most probably improve the rproc tracing facilities later on,
  44  * but this kind of lightweight and simple mechanism is always good to have,
  45  * as it provides very early tracing with little to no dependencies at all.
  46  */
  47 static ssize_t rproc_trace_read(struct file *filp, char __user *userbuf,
  48                                                 size_t count, loff_t *ppos)
  49 {
  50         struct rproc_mem_entry *trace = filp->private_data;
  51         int len = strnlen(trace->va, trace->len);
  52
  53         return simple_read_from_buffer(userbuf, count, ppos, trace->va, len);
  54 }
  55
  56 static const struct file_operations trace_rproc_ops = {
  57         .read = rproc_trace_read,
  58         .open = simple_open,
  59         .llseek = generic_file_llseek,
  60 };
  61
  62 /*
  63  * A state-to-string lookup table, for exposing a human readable state
  64  * via debugfs. Always keep in sync with enum rproc_state
  65  */
  66 static const char * const rproc_state_string[] = {
  67         "offline",
  68         "suspended",
  69         "running",
  70         "crashed",
  71         "invalid",
  72 };
  73
  74 /* expose the state of the remote processor via debugfs */
  75 static ssize_t rproc_state_read(struct file *filp, char __user *userbuf,
  76                                                 size_t count, loff_t *ppos)
  77 {
  78         struct rproc *rproc = filp->private_data;
  79         unsigned int state;
  80         char buf[30];
  81         int i;
  82
  83         state = rproc->state > RPROC_LAST ? RPROC_LAST : rproc->state;
  84
  85         i = scnprintf(buf, 30, "%.28s (%d)\n", rproc_state_string[state],
  86                                                         rproc->state);
  87
  88         return simple_read_from_buffer(userbuf, count, ppos, buf, i);
  89 }
  90
  91 static ssize_t rproc_state_write(struct file *filp, const char __user *userbuf,
  92                                  size_t count, loff_t *ppos)
  93 {
  94         struct rproc *rproc = filp->private_data;
  95         char buf[10];
  96         int ret;
  97
  98         if (count > sizeof(buf) || count <= 0)
  99                 return -EINVAL;
 100
 101         ret = copy_from_user(buf, userbuf, count);
 102         if (ret)
 103                 return -EFAULT;
 104
 105         if (buf[count - 1] == '\n')
 106                 buf[count - 1] = '\0';
 107
 108         if (!strncmp(buf, "start", count)) {
 109                 ret = rproc_boot(rproc);
 110                 if (ret) {
 111                         dev_err(&rproc->dev, "Boot failed: %d\n", ret);
 112                         return ret;
 113                 }
 114         } else if (!strncmp(buf, "stop", count)) {
 115                 rproc_shutdown(rproc);
 116         } else {
 117                 dev_err(&rproc->dev, "Unrecognised option: %s\n", buf);
 118                 return -EINVAL;
 119         }
 120
 121         return count;
 122 }
 123
 124 static const struct file_operations rproc_state_ops = {
 125         .read = rproc_state_read,
 126         .write = rproc_state_write,
 127         .open = simple_open,
 128         .llseek = generic_file_llseek,
 129 };
 130
 131 /* expose the name of the remote processor via debugfs */
 132 static ssize_t rproc_name_read(struct file *filp, char __user *userbuf,
 133                                                 size_t count, loff_t *ppos)
 134 {
 135         struct rproc *rproc = filp->private_data;
 136         /* need room for the name, a newline and a terminating null */
 137         char buf[100];
 138         int i;
 139
 140         i = scnprintf(buf, sizeof(buf), "%.98s\n", rproc->name);
 141
 142         return simple_read_from_buffer(userbuf, count, ppos, buf, i);
 143 }
 144
 145 static const struct file_operations rproc_name_ops = {
 146         .read = rproc_name_read,
 147         .open = simple_open,
 148         .llseek = generic_file_llseek,
 149 };
 150
 151 /* expose recovery flag via debugfs */
 152 static ssize_t rproc_recovery_read(struct file *filp, char __user *userbuf,
 153                                    size_t count, loff_t *ppos)
 154 {
 155         struct rproc *rproc = filp->private_data;
 156         char *buf = rproc->recovery_disabled ? "disabled\n" : "enabled\n";
 157
 158         return simple_read_from_buffer(userbuf, count, ppos, buf, strlen(buf));
 159 }
 160
 161 /*
 162  * By writing to the 'recovery' debugfs entry, we control the behavior of the
 163  * recovery mechanism dynamically. The default value of this entry is "enabled".
 164  *
 165  * The 'recovery' debugfs entry supports these commands:
 166  *
 167  * enabled:     When enabled, the remote processor will be automatically
 168  *              recovered whenever it crashes. Moreover, if the remote
 169  *              processor crashes while recovery is disabled, it will
 170  *              be automatically recovered too as soon as recovery is enabled.
 171  *
 172  * disabled:    When disabled, a remote processor will remain in a crashed
 173  *              state if it crashes. This is useful for debugging purposes;
 174  *              without it, debugging a crash is substantially harder.
 175  *
 176  * recover:     This function will trigger an immediate recovery if the
 177  *              remote processor is in a crashed state, without changing
 178  *              or checking the recovery state (enabled/disabled).
 179  *              This is useful during debugging sessions, when one expects
 180  *              additional crashes to happen after enabling recovery. In this
 181  *              case, enabling recovery will make it hard to debug subsequent
 182  *              crashes, so it's recommended to keep recovery disabled, and
 183  *              instead use the "recover" command as needed.
 184  */
 185 static ssize_t
 186 rproc_recovery_write(struct file *filp, const char __user *user_buf,
 187                      size_t count, loff_t *ppos)
 188 {
 189         struct rproc *rproc = filp->private_data;
 190         char buf[10];
 191         int ret;
 192
 193         if (count < 1 || count > sizeof(buf))
 194                 return -EINVAL;
 195
 196         ret = copy_from_user(buf, user_buf, count);
 197         if (ret)
 198                 return -EFAULT;
 199
 200         /* remove end of line */
 201         if (buf[count - 1] == '\n')
 202                 buf[count - 1] = '\0';
 203
 204         if (!strncmp(buf, "enabled", count)) {
 205                 rproc->recovery_disabled = false;
 206                 /* if rproc has crashed, trigger recovery */
 207                 if (rproc->state == RPROC_CRASHED)
 208                         rproc_trigger_recovery(rproc);
 209         } else if (!strncmp(buf, "disabled", count)) {
 210                 rproc->recovery_disabled = true;
 211         } else if (!strncmp(buf, "recover", count)) {
 212                 /* if rproc has crashed, trigger recovery */
 213                 if (rproc->state == RPROC_CRASHED)
 214                         rproc_trigger_recovery(rproc);
 215         }
 216
 217         return count;
 218 }
 219
 220 static const struct file_operations rproc_recovery_ops = {
 221         .read = rproc_recovery_read,
 222         .write = rproc_recovery_write,
 223         .open = simple_open,
 224         .llseek = generic_file_llseek,
 225 };
 226
 227 void rproc_remove_trace_file(struct dentry *tfile)
 228 {
 229         debugfs_remove(tfile);
 230 }
 231
 232 struct dentry *rproc_create_trace_file(const char *name, struct rproc *rproc,
 233                                         struct rproc_mem_entry *trace)
 234 {
 235         struct dentry *tfile;
 236
 237         tfile = debugfs_create_file(name, 0400, rproc->dbg_dir,
 238                                                 trace, &trace_rproc_ops);
 239         if (!tfile) {
 240                 dev_err(&rproc->dev, "failed to create debugfs trace entry\n");
 241                 return NULL;
 242         }
 243
 244         return tfile;
 245 }
 246
 247 void rproc_delete_debug_dir(struct rproc *rproc)
 248 {
 249         if (!rproc->dbg_dir)
 250                 return;
 251
 252         debugfs_remove_recursive(rproc->dbg_dir);
 253 }
 254
 255 void rproc_create_debug_dir(struct rproc *rproc)
 256 {
 257         struct device *dev = &rproc->dev;
 258
 259         if (!rproc_dbg)
 260                 return;
 261
 262         rproc->dbg_dir = debugfs_create_dir(dev_name(dev), rproc_dbg);
 263         if (!rproc->dbg_dir)
 264                 return;
 265
 266         debugfs_create_file("name", 0400, rproc->dbg_dir,
 267                                         rproc, &rproc_name_ops);
 268         debugfs_create_file("state", 0400, rproc->dbg_dir,
 269                                         rproc, &rproc_state_ops);
 270         debugfs_create_file("recovery", 0400, rproc->dbg_dir,
 271                                         rproc, &rproc_recovery_ops);
 272 }
 273
 274 void __init rproc_init_debugfs(void)
 275 {
 276         if (debugfs_initialized()) {
 277                 rproc_dbg = debugfs_create_dir(KBUILD_MODNAME, NULL);
 278                 if (!rproc_dbg)
 279                         pr_err("can't create debugfs dir\n");
 280         }
 281 }
 282
 283 void __exit rproc_exit_debugfs(void)
 284 {
 285         debugfs_remove(rproc_dbg);
 286 }