drivers/staging/vc04_services/interface/vchiq_arm/vchiq_debugfs.c

   1 /**
   2  * Copyright (c) 2014 Raspberry Pi (Trading) Ltd. All rights reserved.
   3  * Copyright (c) 2010-2012 Broadcom. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions, and the following disclaimer,
  10  *    without modification.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. The names of the above-listed copyright holders may not be used
  15  *    to endorse or promote products derived from this software without
  16  *    specific prior written permission.
  17  *
  18  * ALTERNATIVELY, this software may be distributed under the terms of the
  19  * GNU General Public License ("GPL") version 2, as published by the Free
  20  * Software Foundation.
  21  *
  22  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  23  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  24  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  25  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  26  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  27  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  28  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
  29  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  30  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  31  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
  32  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  33  */
  34
  35
  36 #include <linux/debugfs.h>
  37 #include "vchiq_core.h"
  38 #include "vchiq_arm.h"
  39 #include "vchiq_debugfs.h"
  40
  41 #ifdef CONFIG_DEBUG_FS
  42
  43 /****************************************************************************
  44 *
  45 *   log category entries
  46 *
  47 ***************************************************************************/
  48 #define DEBUGFS_WRITE_BUF_SIZE 256
  49
  50 #define VCHIQ_LOG_ERROR_STR   "error"
  51 #define VCHIQ_LOG_WARNING_STR "warning"
  52 #define VCHIQ_LOG_INFO_STR    "info"
  53 #define VCHIQ_LOG_TRACE_STR   "trace"
  54
  55
  56 /* Top-level debug info */
  57 struct vchiq_debugfs_info {
  58         /* Global 'vchiq' debugfs entry used by all instances */
  59         struct dentry *vchiq_cfg_dir;
  60
  61         /* one entry per client process */
  62         struct dentry *clients;
  63
  64         /* log categories */
  65         struct dentry *log_categories;
  66 };
  67
  68 static struct vchiq_debugfs_info debugfs_info;
  69
  70 /* Log category debugfs entries */
  71 struct vchiq_debugfs_log_entry {
  72         const char *name;
  73         int *plevel;
  74         struct dentry *dir;
  75 };
  76
  77 static struct vchiq_debugfs_log_entry vchiq_debugfs_log_entries[] = {
  78         { "core", &vchiq_core_log_level },
  79         { "msg",  &vchiq_core_msg_log_level },
  80         { "sync", &vchiq_sync_log_level },
  81         { "susp", &vchiq_susp_log_level },
  82         { "arm",  &vchiq_arm_log_level },
  83 };
  84 static int n_log_entries =
  85         sizeof(vchiq_debugfs_log_entries)/sizeof(vchiq_debugfs_log_entries[0]);
  86
  87
  88 static struct dentry *vchiq_clients_top(void);
  89 static struct dentry *vchiq_debugfs_top(void);
  90
  91 static int debugfs_log_show(struct seq_file *f, void *offset)
  92 {
  93         int *levp = f->private;
  94         char *log_value = NULL;
  95
  96         switch (*levp) {
  97         case VCHIQ_LOG_ERROR:
  98                 log_value = VCHIQ_LOG_ERROR_STR;
  99                 break;
 100         case VCHIQ_LOG_WARNING:
 101                 log_value = VCHIQ_LOG_WARNING_STR;
 102                 break;
 103         case VCHIQ_LOG_INFO:
 104                 log_value = VCHIQ_LOG_INFO_STR;
 105                 break;
 106         case VCHIQ_LOG_TRACE:
 107                 log_value = VCHIQ_LOG_TRACE_STR;
 108                 break;
 109         default:
 110                 break;
 111         }
 112
 113         seq_printf(f, "%s\n", log_value ? log_value : "(null)");
 114
 115         return 0;
 116 }
 117
 118 static int debugfs_log_open(struct inode *inode, struct file *file)
 119 {
 120         return single_open(file, debugfs_log_show, inode->i_private);
 121 }
 122
 123 static int debugfs_log_write(struct file *file,
 124         const char __user *buffer,
 125         size_t count, loff_t *ppos)
 126 {
 127         struct seq_file *f = (struct seq_file *)file->private_data;
 128         int *levp = f->private;
 129         char kbuf[DEBUGFS_WRITE_BUF_SIZE + 1];
 130
 131         memset(kbuf, 0, DEBUGFS_WRITE_BUF_SIZE + 1);
 132         if (count >= DEBUGFS_WRITE_BUF_SIZE)
 133                 count = DEBUGFS_WRITE_BUF_SIZE;
 134
 135         if (copy_from_user(kbuf, buffer, count) != 0)
 136                 return -EFAULT;
 137         kbuf[count - 1] = 0;
 138
 139         if (strncmp("error", kbuf, strlen("error")) == 0)
 140                 *levp = VCHIQ_LOG_ERROR;
 141         else if (strncmp("warning", kbuf, strlen("warning")) == 0)
 142                 *levp = VCHIQ_LOG_WARNING;
 143         else if (strncmp("info", kbuf, strlen("info")) == 0)
 144                 *levp = VCHIQ_LOG_INFO;
 145         else if (strncmp("trace", kbuf, strlen("trace")) == 0)
 146                 *levp = VCHIQ_LOG_TRACE;
 147         else
 148                 *levp = VCHIQ_LOG_DEFAULT;
 149
 150         *ppos += count;
 151
 152         return count;
 153 }
 154
 155 static const struct file_operations debugfs_log_fops = {
 156         .owner          = THIS_MODULE,
 157         .open           = debugfs_log_open,
 158         .write          = debugfs_log_write,
 159         .read           = seq_read,
 160         .llseek         = seq_lseek,
 161         .release        = single_release,
 162 };
 163
 164 /* create an entry under <debugfs>/vchiq/log for each log category */
 165 static int vchiq_debugfs_create_log_entries(struct dentry *top)
 166 {
 167         struct dentry *dir;
 168         size_t i;
 169         int ret = 0;
 170         dir = debugfs_create_dir("log", vchiq_debugfs_top());
 171         if (!dir)
 172                 return -ENOMEM;
 173         debugfs_info.log_categories = dir;
 174
 175         for (i = 0; i < n_log_entries; i++) {
 176                 void *levp = (void *)vchiq_debugfs_log_entries[i].plevel;
 177                 dir = debugfs_create_file(vchiq_debugfs_log_entries[i].name,
 178                                           0644,
 179                                           debugfs_info.log_categories,
 180                                           levp,
 181                                           &debugfs_log_fops);
 182                 if (!dir) {
 183                         ret = -ENOMEM;
 184                         break;
 185                 }
 186
 187                 vchiq_debugfs_log_entries[i].dir = dir;
 188         }
 189         return ret;
 190 }
 191
 192 static int debugfs_usecount_show(struct seq_file *f, void *offset)
 193 {
 194         VCHIQ_INSTANCE_T instance = f->private;
 195         int use_count;
 196
 197         use_count = vchiq_instance_get_use_count(instance);
 198         seq_printf(f, "%d\n", use_count);
 199
 200         return 0;
 201 }
 202
 203 static int debugfs_usecount_open(struct inode *inode, struct file *file)
 204 {
 205         return single_open(file, debugfs_usecount_show, inode->i_private);
 206 }
 207
 208 static const struct file_operations debugfs_usecount_fops = {
 209         .owner          = THIS_MODULE,
 210         .open           = debugfs_usecount_open,
 211         .read           = seq_read,
 212         .llseek         = seq_lseek,
 213         .release        = single_release,
 214 };
 215
 216 static int debugfs_trace_show(struct seq_file *f, void *offset)
 217 {
 218         VCHIQ_INSTANCE_T instance = f->private;
 219         int trace;
 220
 221         trace = vchiq_instance_get_trace(instance);
 222         seq_printf(f, "%s\n", trace ? "Y" : "N");
 223
 224         return 0;
 225 }
 226
 227 static int debugfs_trace_open(struct inode *inode, struct file *file)
 228 {
 229         return single_open(file, debugfs_trace_show, inode->i_private);
 230 }
 231
 232 static int debugfs_trace_write(struct file *file,
 233         const char __user *buffer,
 234         size_t count, loff_t *ppos)
 235 {
 236         struct seq_file *f = (struct seq_file *)file->private_data;
 237         VCHIQ_INSTANCE_T instance = f->private;
 238         char firstchar;
 239
 240         if (copy_from_user(&firstchar, buffer, 1) != 0)
 241                 return -EFAULT;
 242
 243         switch (firstchar) {
 244         case 'Y':
 245         case 'y':
 246         case '1':
 247                 vchiq_instance_set_trace(instance, 1);
 248                 break;
 249         case 'N':
 250         case 'n':
 251         case '0':
 252                 vchiq_instance_set_trace(instance, 0);
 253                 break;
 254         default:
 255                 break;
 256         }
 257
 258         *ppos += count;
 259
 260         return count;
 261 }
 262
 263 static const struct file_operations debugfs_trace_fops = {
 264         .owner          = THIS_MODULE,
 265         .open           = debugfs_trace_open,
 266         .write          = debugfs_trace_write,
 267         .read           = seq_read,
 268         .llseek         = seq_lseek,
 269         .release        = single_release,
 270 };
 271
 272 /* add an instance (process) to the debugfs entries */
 273 int vchiq_debugfs_add_instance(VCHIQ_INSTANCE_T instance)
 274 {
 275         char pidstr[16];
 276         struct dentry *top, *use_count, *trace;
 277         struct dentry *clients = vchiq_clients_top();
 278
 279         snprintf(pidstr, sizeof(pidstr), "%d",
 280                  vchiq_instance_get_pid(instance));
 281
 282         top = debugfs_create_dir(pidstr, clients);
 283         if (!top)
 284                 goto fail_top;
 285
 286         use_count = debugfs_create_file("use_count",
 287                                         0444, top,
 288                                         instance,
 289                                         &debugfs_usecount_fops);
 290         if (!use_count)
 291                 goto fail_use_count;
 292
 293         trace = debugfs_create_file("trace",
 294                                     0644, top,
 295                                     instance,
 296                                     &debugfs_trace_fops);
 297         if (!trace)
 298                 goto fail_trace;
 299
 300         vchiq_instance_get_debugfs_node(instance)->dentry = top;
 301
 302         return 0;
 303
 304 fail_trace:
 305         debugfs_remove(use_count);
 306 fail_use_count:
 307         debugfs_remove(top);
 308 fail_top:
 309         return -ENOMEM;
 310 }
 311
 312 void vchiq_debugfs_remove_instance(VCHIQ_INSTANCE_T instance)
 313 {
 314         VCHIQ_DEBUGFS_NODE_T *node = vchiq_instance_get_debugfs_node(instance);
 315         debugfs_remove_recursive(node->dentry);
 316 }
 317
 318
 319 int vchiq_debugfs_init(void)
 320 {
 321         BUG_ON(debugfs_info.vchiq_cfg_dir != NULL);
 322
 323         debugfs_info.vchiq_cfg_dir = debugfs_create_dir("vchiq", NULL);
 324         if (debugfs_info.vchiq_cfg_dir == NULL)
 325                 goto fail;
 326
 327         debugfs_info.clients = debugfs_create_dir("clients",
 328                                 vchiq_debugfs_top());
 329         if (!debugfs_info.clients)
 330                 goto fail;
 331
 332         if (vchiq_debugfs_create_log_entries(vchiq_debugfs_top()) != 0)
 333                 goto fail;
 334
 335         return 0;
 336
 337 fail:
 338         vchiq_debugfs_deinit();
 339         vchiq_log_error(vchiq_arm_log_level,
 340                 "%s: failed to create debugfs directory",
 341                 __func__);
 342
 343         return -ENOMEM;
 344 }
 345
 346 /* remove all the debugfs entries */
 347 void vchiq_debugfs_deinit(void)
 348 {
 349         debugfs_remove_recursive(vchiq_debugfs_top());
 350 }
 351
 352 static struct dentry *vchiq_clients_top(void)
 353 {
 354         return debugfs_info.clients;
 355 }
 356
 357 static struct dentry *vchiq_debugfs_top(void)
 358 {
 359         BUG_ON(debugfs_info.vchiq_cfg_dir == NULL);
 360         return debugfs_info.vchiq_cfg_dir;
 361 }
 362
 363 #else /* CONFIG_DEBUG_FS */
 364
 365 int vchiq_debugfs_init(void)
 366 {
 367         return 0;
 368 }
 369
 370 void vchiq_debugfs_deinit(void)
 371 {
 372 }
 373
 374 int vchiq_debugfs_add_instance(VCHIQ_INSTANCE_T instance)
 375 {
 376         return 0;
 377 }
 378
 379 void vchiq_debugfs_remove_instance(VCHIQ_INSTANCE_T instance)
 380 {
 381 }
 382
 383 #endif /* CONFIG_DEBUG_FS */