drivers/acpi/debug.c

   1 /*
   2  * debug.c - ACPI debug interface to userspace.
   3  */
   4
   5 #include <linux/proc_fs.h>
   6 #include <linux/seq_file.h>
   7 #include <linux/init.h>
   8 #include <linux/module.h>
   9 #include <linux/kernel.h>
  10 #include <linux/moduleparam.h>
  11 #include <linux/debugfs.h>
  12 #include <linux/slab.h>
  13 #include <asm/uaccess.h>
  14 #include <acpi/acpi_drivers.h>
  15
  16 #define _COMPONENT              ACPI_SYSTEM_COMPONENT
  17 ACPI_MODULE_NAME("debug");
  18
  19 struct acpi_dlayer {
  20         const char *name;
  21         unsigned long value;
  22 };
  23 struct acpi_dlevel {
  24         const char *name;
  25         unsigned long value;
  26 };
  27 #define ACPI_DEBUG_INIT(v)      { .name = #v, .value = v }
  28
  29 static const struct acpi_dlayer acpi_debug_layers[] = {
  30         ACPI_DEBUG_INIT(ACPI_UTILITIES),
  31         ACPI_DEBUG_INIT(ACPI_HARDWARE),
  32         ACPI_DEBUG_INIT(ACPI_EVENTS),
  33         ACPI_DEBUG_INIT(ACPI_TABLES),
  34         ACPI_DEBUG_INIT(ACPI_NAMESPACE),
  35         ACPI_DEBUG_INIT(ACPI_PARSER),
  36         ACPI_DEBUG_INIT(ACPI_DISPATCHER),
  37         ACPI_DEBUG_INIT(ACPI_EXECUTER),
  38         ACPI_DEBUG_INIT(ACPI_RESOURCES),
  39         ACPI_DEBUG_INIT(ACPI_CA_DEBUGGER),
  40         ACPI_DEBUG_INIT(ACPI_OS_SERVICES),
  41         ACPI_DEBUG_INIT(ACPI_CA_DISASSEMBLER),
  42         ACPI_DEBUG_INIT(ACPI_COMPILER),
  43         ACPI_DEBUG_INIT(ACPI_TOOLS),
  44
  45         ACPI_DEBUG_INIT(ACPI_BUS_COMPONENT),
  46         ACPI_DEBUG_INIT(ACPI_AC_COMPONENT),
  47         ACPI_DEBUG_INIT(ACPI_BATTERY_COMPONENT),
  48         ACPI_DEBUG_INIT(ACPI_BUTTON_COMPONENT),
  49         ACPI_DEBUG_INIT(ACPI_SBS_COMPONENT),
  50         ACPI_DEBUG_INIT(ACPI_FAN_COMPONENT),
  51         ACPI_DEBUG_INIT(ACPI_PCI_COMPONENT),
  52         ACPI_DEBUG_INIT(ACPI_POWER_COMPONENT),
  53         ACPI_DEBUG_INIT(ACPI_CONTAINER_COMPONENT),
  54         ACPI_DEBUG_INIT(ACPI_SYSTEM_COMPONENT),
  55         ACPI_DEBUG_INIT(ACPI_THERMAL_COMPONENT),
  56         ACPI_DEBUG_INIT(ACPI_MEMORY_DEVICE_COMPONENT),
  57         ACPI_DEBUG_INIT(ACPI_VIDEO_COMPONENT),
  58         ACPI_DEBUG_INIT(ACPI_PROCESSOR_COMPONENT),
  59 };
  60
  61 static const struct acpi_dlevel acpi_debug_levels[] = {
  62         ACPI_DEBUG_INIT(ACPI_LV_INIT),
  63         ACPI_DEBUG_INIT(ACPI_LV_DEBUG_OBJECT),
  64         ACPI_DEBUG_INIT(ACPI_LV_INFO),
  65
  66         ACPI_DEBUG_INIT(ACPI_LV_INIT_NAMES),
  67         ACPI_DEBUG_INIT(ACPI_LV_PARSE),
  68         ACPI_DEBUG_INIT(ACPI_LV_LOAD),
  69         ACPI_DEBUG_INIT(ACPI_LV_DISPATCH),
  70         ACPI_DEBUG_INIT(ACPI_LV_EXEC),
  71         ACPI_DEBUG_INIT(ACPI_LV_NAMES),
  72         ACPI_DEBUG_INIT(ACPI_LV_OPREGION),
  73         ACPI_DEBUG_INIT(ACPI_LV_BFIELD),
  74         ACPI_DEBUG_INIT(ACPI_LV_TABLES),
  75         ACPI_DEBUG_INIT(ACPI_LV_VALUES),
  76         ACPI_DEBUG_INIT(ACPI_LV_OBJECTS),
  77         ACPI_DEBUG_INIT(ACPI_LV_RESOURCES),
  78         ACPI_DEBUG_INIT(ACPI_LV_USER_REQUESTS),
  79         ACPI_DEBUG_INIT(ACPI_LV_PACKAGE),
  80
  81         ACPI_DEBUG_INIT(ACPI_LV_ALLOCATIONS),
  82         ACPI_DEBUG_INIT(ACPI_LV_FUNCTIONS),
  83         ACPI_DEBUG_INIT(ACPI_LV_OPTIMIZATIONS),
  84
  85         ACPI_DEBUG_INIT(ACPI_LV_MUTEX),
  86         ACPI_DEBUG_INIT(ACPI_LV_THREADS),
  87         ACPI_DEBUG_INIT(ACPI_LV_IO),
  88         ACPI_DEBUG_INIT(ACPI_LV_INTERRUPTS),
  89
  90         ACPI_DEBUG_INIT(ACPI_LV_AML_DISASSEMBLE),
  91         ACPI_DEBUG_INIT(ACPI_LV_VERBOSE_INFO),
  92         ACPI_DEBUG_INIT(ACPI_LV_FULL_TABLES),
  93         ACPI_DEBUG_INIT(ACPI_LV_EVENTS),
  94 };
  95
  96 /* --------------------------------------------------------------------------
  97                               FS Interface (/sys)
  98    -------------------------------------------------------------------------- */
  99 static int param_get_debug_layer(char *buffer, struct kernel_param *kp) {
 100         int result = 0;
 101         int i;
 102
 103         result = sprintf(buffer, "%-25s\tHex        SET\n", "Description");
 104
 105         for(i = 0; i <ARRAY_SIZE(acpi_debug_layers); i++) {
 106                 result += sprintf(buffer+result, "%-25s\t0x%08lX [%c]\n",
 107                                         acpi_debug_layers[i].name,
 108                                         acpi_debug_layers[i].value,
 109                                         (acpi_dbg_layer & acpi_debug_layers[i].value) ? '*' : ' ');
 110         }
 111         result += sprintf(buffer+result, "%-25s\t0x%08X [%c]\n", "ACPI_ALL_DRIVERS",
 112                                         ACPI_ALL_DRIVERS,
 113                                         (acpi_dbg_layer & ACPI_ALL_DRIVERS) ==
 114                                         ACPI_ALL_DRIVERS ? '*' : (acpi_dbg_layer &
 115                                         ACPI_ALL_DRIVERS) == 0 ? ' ' : '-');
 116         result += sprintf(buffer+result, "--\ndebug_layer = 0x%08X ( * = enabled)\n", acpi_dbg_layer);
 117
 118         return result;
 119 }
 120
 121 static int param_get_debug_level(char *buffer, struct kernel_param *kp) {
 122         int result = 0;
 123         int i;
 124
 125         result = sprintf(buffer, "%-25s\tHex        SET\n", "Description");
 126
 127         for (i = 0; i < ARRAY_SIZE(acpi_debug_levels); i++) {
 128                 result += sprintf(buffer+result, "%-25s\t0x%08lX [%c]\n",
 129                                      acpi_debug_levels[i].name,
 130                                      acpi_debug_levels[i].value,
 131                                      (acpi_dbg_level & acpi_debug_levels[i].
 132                                       value) ? '*' : ' ');
 133         }
 134         result += sprintf(buffer+result, "--\ndebug_level = 0x%08X (* = enabled)\n",
 135                              acpi_dbg_level);
 136
 137         return result;
 138 }
 139
 140 module_param_call(debug_layer, param_set_uint, param_get_debug_layer, &acpi_dbg_layer, 0644);
 141 module_param_call(debug_level, param_set_uint, param_get_debug_level, &acpi_dbg_level, 0644);
 142
 143 static char trace_method_name[6];
 144 module_param_string(trace_method_name, trace_method_name, 6, 0644);
 145 static unsigned int trace_debug_layer;
 146 module_param(trace_debug_layer, uint, 0644);
 147 static unsigned int trace_debug_level;
 148 module_param(trace_debug_level, uint, 0644);
 149
 150 static int param_set_trace_state(const char *val, struct kernel_param *kp)
 151 {
 152         int result = 0;
 153
 154         if (!strncmp(val, "enable", strlen("enable") - 1)) {
 155                 result = acpi_debug_trace(trace_method_name, trace_debug_level,
 156                                           trace_debug_layer, 0);
 157                 if (result)
 158                         result = -EBUSY;
 159                 goto exit;
 160         }
 161
 162         if (!strncmp(val, "disable", strlen("disable") - 1)) {
 163                 int name = 0;
 164                 result = acpi_debug_trace((char *)&name, trace_debug_level,
 165                                           trace_debug_layer, 0);
 166                 if (result)
 167                         result = -EBUSY;
 168                 goto exit;
 169         }
 170
 171         if (!strncmp(val, "1", 1)) {
 172                 result = acpi_debug_trace(trace_method_name, trace_debug_level,
 173                                           trace_debug_layer, 1);
 174                 if (result)
 175                         result = -EBUSY;
 176                 goto exit;
 177         }
 178
 179         result = -EINVAL;
 180 exit:
 181         return result;
 182 }
 183
 184 static int param_get_trace_state(char *buffer, struct kernel_param *kp)
 185 {
 186         if (!acpi_gbl_trace_method_name)
 187                 return sprintf(buffer, "disable");
 188         else {
 189                 if (acpi_gbl_trace_flags & 1)
 190                         return sprintf(buffer, "1");
 191                 else
 192                         return sprintf(buffer, "enable");
 193         }
 194         return 0;
 195 }
 196
 197 module_param_call(trace_state, param_set_trace_state, param_get_trace_state,
 198                   NULL, 0644);
 199
 200 /* --------------------------------------------------------------------------
 201                                 DebugFS Interface
 202    -------------------------------------------------------------------------- */
 203
 204 static ssize_t cm_write(struct file *file, const char __user *user_buf,
 205                         size_t count, loff_t *ppos)
 206 {
 207         static char *buf;
 208         static int uncopied_bytes;
 209         struct acpi_table_header table;
 210         acpi_status status;
 211
 212         if (!(*ppos)) {
 213                 /* parse the table header to get the table length */
 214                 if (count <= sizeof(struct acpi_table_header))
 215                         return -EINVAL;
 216                 if (copy_from_user(&table, user_buf,
 217                         sizeof(struct acpi_table_header)))
 218                         return -EFAULT;
 219                 uncopied_bytes = table.length;
 220                 buf = kzalloc(uncopied_bytes, GFP_KERNEL);
 221                 if (!buf)
 222                         return -ENOMEM;
 223         }
 224
 225         if (uncopied_bytes < count) {
 226                 kfree(buf);
 227                 return -EINVAL;
 228         }
 229
 230         if (copy_from_user(buf + (*ppos), user_buf, count)) {
 231                 kfree(buf);
 232                 return -EFAULT;
 233         }
 234
 235         uncopied_bytes -= count;
 236         *ppos += count;
 237
 238         if (!uncopied_bytes) {
 239                 status = acpi_install_method(buf);
 240                 kfree(buf);
 241                 if (ACPI_FAILURE(status))
 242                         return -EINVAL;
 243                 add_taint(TAINT_OVERRIDDEN_ACPI_TABLE);
 244         }
 245
 246         return count;
 247 }
 248
 249 static const struct file_operations cm_fops = {
 250         .write = cm_write,
 251 };
 252
 253 static int acpi_debugfs_init(void)
 254 {
 255         struct dentry *acpi_dir, *cm_dentry;
 256
 257         acpi_dir = debugfs_create_dir("acpi", NULL);
 258         if (!acpi_dir)
 259                 goto err;
 260
 261         cm_dentry = debugfs_create_file("custom_method", S_IWUGO,
 262                                         acpi_dir, NULL, &cm_fops);
 263         if (!cm_dentry)
 264                 goto err;
 265
 266         return 0;
 267
 268 err:
 269         if (acpi_dir)
 270                 debugfs_remove(acpi_dir);
 271         return -EINVAL;
 272 }
 273
 274 /* --------------------------------------------------------------------------
 275                               FS Interface (/proc)
 276    -------------------------------------------------------------------------- */
 277 #ifdef CONFIG_ACPI_PROCFS
 278 #define ACPI_SYSTEM_FILE_DEBUG_LAYER    "debug_layer"
 279 #define ACPI_SYSTEM_FILE_DEBUG_LEVEL            "debug_level"
 280
 281 static int acpi_system_debug_proc_show(struct seq_file *m, void *v)
 282 {
 283         unsigned int i;
 284
 285         seq_printf(m, "%-25s\tHex        SET\n", "Description");
 286
 287         switch ((unsigned long)m->private) {
 288         case 0:
 289                 for (i = 0; i < ARRAY_SIZE(acpi_debug_layers); i++) {
 290                         seq_printf(m, "%-25s\t0x%08lX [%c]\n",
 291                                      acpi_debug_layers[i].name,
 292                                      acpi_debug_layers[i].value,
 293                                      (acpi_dbg_layer & acpi_debug_layers[i].
 294                                       value) ? '*' : ' ');
 295                 }
 296                 seq_printf(m, "%-25s\t0x%08X [%c]\n", "ACPI_ALL_DRIVERS",
 297                              ACPI_ALL_DRIVERS,
 298                              (acpi_dbg_layer & ACPI_ALL_DRIVERS) ==
 299                              ACPI_ALL_DRIVERS ? '*' : (acpi_dbg_layer &
 300                                                        ACPI_ALL_DRIVERS) ==
 301                              0 ? ' ' : '-');
 302                 seq_printf(m,
 303                              "--\ndebug_layer = 0x%08X (* = enabled, - = partial)\n",
 304                              acpi_dbg_layer);
 305                 break;
 306         case 1:
 307                 for (i = 0; i < ARRAY_SIZE(acpi_debug_levels); i++) {
 308                         seq_printf(m, "%-25s\t0x%08lX [%c]\n",
 309                                      acpi_debug_levels[i].name,
 310                                      acpi_debug_levels[i].value,
 311                                      (acpi_dbg_level & acpi_debug_levels[i].
 312                                       value) ? '*' : ' ');
 313                 }
 314                 seq_printf(m, "--\ndebug_level = 0x%08X (* = enabled)\n",
 315                              acpi_dbg_level);
 316                 break;
 317         }
 318         return 0;
 319 }
 320
 321 static int acpi_system_debug_proc_open(struct inode *inode, struct file *file)
 322 {
 323         return single_open(file, acpi_system_debug_proc_show, PDE(inode)->data);
 324 }
 325
 326 static ssize_t acpi_system_debug_proc_write(struct file *file,
 327                         const char __user * buffer,
 328                         size_t count, loff_t *pos)
 329 {
 330         char debug_string[12] = { '\0' };
 331
 332
 333         if (count > sizeof(debug_string) - 1)
 334                 return -EINVAL;
 335
 336         if (copy_from_user(debug_string, buffer, count))
 337                 return -EFAULT;
 338
 339         debug_string[count] = '\0';
 340
 341         switch ((unsigned long)PDE(file->f_path.dentry->d_inode)->data) {
 342         case 0:
 343                 acpi_dbg_layer = simple_strtoul(debug_string, NULL, 0);
 344                 break;
 345         case 1:
 346                 acpi_dbg_level = simple_strtoul(debug_string, NULL, 0);
 347                 break;
 348         default:
 349                 return -EINVAL;
 350         }
 351
 352         return count;
 353 }
 354
 355 static const struct file_operations acpi_system_debug_proc_fops = {
 356         .owner          = THIS_MODULE,
 357         .open           = acpi_system_debug_proc_open,
 358         .read           = seq_read,
 359         .llseek         = seq_lseek,
 360         .release        = single_release,
 361         .write          = acpi_system_debug_proc_write,
 362 };
 363 #endif
 364
 365 int __init acpi_procfs_init(void)
 366 {
 367 #ifdef CONFIG_ACPI_PROCFS
 368         struct proc_dir_entry *entry;
 369         int error = 0;
 370         char *name;
 371
 372         /* 'debug_layer' [R/W] */
 373         name = ACPI_SYSTEM_FILE_DEBUG_LAYER;
 374         entry = proc_create_data(name, S_IFREG | S_IRUGO | S_IWUSR,
 375                                  acpi_root_dir, &acpi_system_debug_proc_fops,
 376                                  (void *)0);
 377         if (!entry)
 378                 goto Error;
 379
 380         /* 'debug_level' [R/W] */
 381         name = ACPI_SYSTEM_FILE_DEBUG_LEVEL;
 382         entry = proc_create_data(name, S_IFREG | S_IRUGO | S_IWUSR,
 383                                  acpi_root_dir, &acpi_system_debug_proc_fops,
 384                                  (void *)1);
 385         if (!entry)
 386                 goto Error;
 387
 388       Done:
 389         return error;
 390
 391       Error:
 392         remove_proc_entry(ACPI_SYSTEM_FILE_DEBUG_LEVEL, acpi_root_dir);
 393         remove_proc_entry(ACPI_SYSTEM_FILE_DEBUG_LAYER, acpi_root_dir);
 394         error = -ENODEV;
 395         goto Done;
 396 #else
 397         return 0;
 398 #endif
 399 }
 400
 401 int __init acpi_debug_init(void)
 402 {
 403         acpi_debugfs_init();
 404         acpi_procfs_init();
 405         return 0;
 406 }