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 */ 384