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 /* expose the name of the remote processor via debugfs */
  63 static ssize_t rproc_name_read(struct file *filp, char __user *userbuf,
  64                                size_t count, loff_t *ppos)
  65 {
  66         struct rproc *rproc = filp->private_data;
  67         /* need room for the name, a newline and a terminating null */
  68         char buf[100];
  69         int i;
  70
  71         i = scnprintf(buf, sizeof(buf), "%.98s\n", rproc->name);
  72
  73         return simple_read_from_buffer(userbuf, count, ppos, buf, i);
  74 }
  75
  76 static const struct file_operations rproc_name_ops = {
  77         .read = rproc_name_read,
  78         .open = simple_open,
  79         .llseek = generic_file_llseek,
  80 };
  81
  82 /* expose recovery flag via debugfs */
  83 static ssize_t rproc_recovery_read(struct file *filp, char __user *userbuf,
  84                                    size_t count, loff_t *ppos)
  85 {
  86         struct rproc *rproc = filp->private_data;
  87         char *buf = rproc->recovery_disabled ? "disabled\n" : "enabled\n";
  88
  89         return simple_read_from_buffer(userbuf, count, ppos, buf, strlen(buf));
  90 }
  91
  92 /*
  93  * By writing to the 'recovery' debugfs entry, we control the behavior of the
  94  * recovery mechanism dynamically. The default value of this entry is "enabled".
  95  *
  96  * The 'recovery' debugfs entry supports these commands:
  97  *
  98  * enabled:     When enabled, the remote processor will be automatically
  99  *              recovered whenever it crashes. Moreover, if the remote
 100  *              processor crashes while recovery is disabled, it will
 101  *              be automatically recovered too as soon as recovery is enabled.
 102  *
 103  * disabled:    When disabled, a remote processor will remain in a crashed
 104  *              state if it crashes. This is useful for debugging purposes;
 105  *              without it, debugging a crash is substantially harder.
 106  *
 107  * recover:     This function will trigger an immediate recovery if the
 108  *              remote processor is in a crashed state, without changing
 109  *              or checking the recovery state (enabled/disabled).
 110  *              This is useful during debugging sessions, when one expects
 111  *              additional crashes to happen after enabling recovery. In this
 112  *              case, enabling recovery will make it hard to debug subsequent
 113  *              crashes, so it's recommended to keep recovery disabled, and
 114  *              instead use the "recover" command as needed.
 115  */
 116 static ssize_t
 117 rproc_recovery_write(struct file *filp, const char __user *user_buf,
 118                      size_t count, loff_t *ppos)
 119 {
 120         struct rproc *rproc = filp->private_data;
 121         char buf[10];
 122         int ret;
 123
 124         if (count < 1 || count > sizeof(buf))
 125                 return -EINVAL;
 126
 127         ret = copy_from_user(buf, user_buf, count);
 128         if (ret)
 129                 return -EFAULT;
 130
 131         /* remove end of line */
 132         if (buf[count - 1] == '\n')
 133                 buf[count - 1] = '\0';
 134
 135         if (!strncmp(buf, "enabled", count)) {
 136                 rproc->recovery_disabled = false;
 137                 /* if rproc has crashed, trigger recovery */
 138                 if (rproc->state == RPROC_CRASHED)
 139                         rproc_trigger_recovery(rproc);
 140         } else if (!strncmp(buf, "disabled", count)) {
 141                 rproc->recovery_disabled = true;
 142         } else if (!strncmp(buf, "recover", count)) {
 143                 /* if rproc has crashed, trigger recovery */
 144                 if (rproc->state == RPROC_CRASHED)
 145                         rproc_trigger_recovery(rproc);
 146         }
 147
 148         return count;
 149 }
 150
 151 static const struct file_operations rproc_recovery_ops = {
 152         .read = rproc_recovery_read,
 153         .write = rproc_recovery_write,
 154         .open = simple_open,
 155         .llseek = generic_file_llseek,
 156 };
 157
 158 void rproc_remove_trace_file(struct dentry *tfile)
 159 {
 160         debugfs_remove(tfile);
 161 }
 162
 163 struct dentry *rproc_create_trace_file(const char *name, struct rproc *rproc,
 164                                        struct rproc_mem_entry *trace)
 165 {
 166         struct dentry *tfile;
 167
 168         tfile = debugfs_create_file(name, 0400, rproc->dbg_dir, trace,
 169                                     &trace_rproc_ops);
 170         if (!tfile) {
 171                 dev_err(&rproc->dev, "failed to create debugfs trace entry\n");
 172                 return NULL;
 173         }
 174
 175         return tfile;
 176 }
 177
 178 void rproc_delete_debug_dir(struct rproc *rproc)
 179 {
 180         if (!rproc->dbg_dir)
 181                 return;
 182
 183         debugfs_remove_recursive(rproc->dbg_dir);
 184 }
 185
 186 void rproc_create_debug_dir(struct rproc *rproc)
 187 {
 188         struct device *dev = &rproc->dev;
 189
 190         if (!rproc_dbg)
 191                 return;
 192
 193         rproc->dbg_dir = debugfs_create_dir(dev_name(dev), rproc_dbg);
 194         if (!rproc->dbg_dir)
 195                 return;
 196
 197         debugfs_create_file("name", 0400, rproc->dbg_dir,
 198                             rproc, &rproc_name_ops);
 199         debugfs_create_file("recovery", 0400, rproc->dbg_dir,
 200                             rproc, &rproc_recovery_ops);
 201 }
 202
 203 void __init rproc_init_debugfs(void)
 204 {
 205         if (debugfs_initialized()) {
 206                 rproc_dbg = debugfs_create_dir(KBUILD_MODNAME, NULL);
 207                 if (!rproc_dbg)
 208                         pr_err("can't create debugfs dir\n");
 209         }
 210 }
 211
 212 void __exit rproc_exit_debugfs(void)
 213 {
 214         debugfs_remove(rproc_dbg);
 215 }