vchiq_debugfs.c

Version: - FREEBSD - FREEBSD-13-STABLE - FREEBSD-13-0 - FREEBSD-12-STABLE - FREEBSD-12-0 - FREEBSD-11-STABLE - FREEBSD-11-0 - FREEBSD-10-STABLE - FREEBSD-10-0 - FREEBSD-9-STABLE - FREEBSD-9-0 - FREEBSD-8-STABLE - FREEBSD-8-0 - FREEBSD-7-STABLE - FREEBSD-7-0 - FREEBSD-6-STABLE - FREEBSD-6-0 - FREEBSD-5-STABLE - FREEBSD-5-0 - FREEBSD-4-STABLE - FREEBSD-3-STABLE - FREEBSD22 - l41 - OPENBSD - linux-2.6 - MK84 - PLAN9 - xnu-8792
SearchContext: - none - 3 - 10
    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 '':
  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 */
Cache object: f5d7ff585eac1d4136c19f61b6151f7e
[ source navigation ] [ diff markup ] [ identifier search ] [ freetext search ] [ file search ] [ list types ] [ track identifier ]
This page is part of the FreeBSD/Linux Linux Kernel Cross-Reference, and was automatically generated using a modified version of the LXR engine.
FreeBSD/Linux Kernel Cross Reference sys/contrib/vchiq/interface/vchiq_arm/vchiq_debugfs.c

FreeBSD/Linux Kernel Cross Reference
sys/contrib/vchiq/interface/vchiq_arm/vchiq_debugfs.c
