lib/dynamic_printk.c

   1 /*
   2  * lib/dynamic_printk.c
   3  *
   4  * make pr_debug()/dev_dbg() calls runtime configurable based upon their
   5  * their source module.
   6  *
   7  * Copyright (C) 2008 Red Hat, Inc., Jason Baron <jbaron@redhat.com>
   8  */
   9
  10 #include <linux/kernel.h>
  11 #include <linux/module.h>
  12 #include <linux/uaccess.h>
  13 #include <linux/seq_file.h>
  14 #include <linux/debugfs.h>
  15 #include <linux/fs.h>
  16
  17 extern struct mod_debug __start___verbose[];
  18 extern struct mod_debug __stop___verbose[];
  19
  20 struct debug_name {
  21         struct hlist_node hlist;
  22         struct hlist_node hlist2;
  23         int hash1;
  24         int hash2;
  25         char *name;
  26         int enable;
  27         int type;
  28 };
  29
  30 static int nr_entries;
  31 static int num_enabled;
  32 int dynamic_enabled = DYNAMIC_ENABLED_NONE;
  33 static struct hlist_head module_table[DEBUG_HASH_TABLE_SIZE] =
  34         { [0 ... DEBUG_HASH_TABLE_SIZE-1] = HLIST_HEAD_INIT };
  35 static struct hlist_head module_table2[DEBUG_HASH_TABLE_SIZE] =
  36         { [0 ... DEBUG_HASH_TABLE_SIZE-1] = HLIST_HEAD_INIT };
  37 static DECLARE_MUTEX(debug_list_mutex);
  38
  39 /* dynamic_printk_enabled, and dynamic_printk_enabled2 are bitmasks in which
  40  * bit n is set to 1 if any modname hashes into the bucket n, 0 otherwise. They
  41  * use independent hash functions, to reduce the chance of false positives.
  42  */
  43 long long dynamic_printk_enabled;
  44 EXPORT_SYMBOL_GPL(dynamic_printk_enabled);
  45 long long dynamic_printk_enabled2;
  46 EXPORT_SYMBOL_GPL(dynamic_printk_enabled2);
  47
  48 /* returns the debug module pointer. */
  49 static struct debug_name *find_debug_module(char *module_name)
  50 {
  51         int i;
  52         struct hlist_head *head;
  53         struct hlist_node *node;
  54         struct debug_name *element;
  55
  56         element = NULL;
  57         for (i = 0; i < DEBUG_HASH_TABLE_SIZE; i++) {
  58                 head = &module_table[i];
  59                 hlist_for_each_entry_rcu(element, node, head, hlist)
  60                         if (!strcmp(element->name, module_name))
  61                                 return element;
  62         }
  63         return NULL;
  64 }
  65
  66 /* returns the debug module pointer. */
  67 static struct debug_name *find_debug_module_hash(char *module_name, int hash)
  68 {
  69         struct hlist_head *head;
  70         struct hlist_node *node;
  71         struct debug_name *element;
  72
  73         element = NULL;
  74         head = &module_table[hash];
  75         hlist_for_each_entry_rcu(element, node, head, hlist)
  76                 if (!strcmp(element->name, module_name))
  77                         return element;
  78         return NULL;
  79 }
  80
  81 /* caller must hold mutex*/
  82 static int __add_debug_module(char *mod_name, int hash, int hash2)
  83 {
  84         struct debug_name *new;
  85         char *module_name;
  86         int ret = 0;
  87
  88         if (find_debug_module(mod_name)) {
  89                 ret = -EINVAL;
  90                 goto out;
  91         }
  92         module_name = kmalloc(strlen(mod_name) + 1, GFP_KERNEL);
  93         if (!module_name) {
  94                 ret = -ENOMEM;
  95                 goto out;
  96         }
  97         module_name = strcpy(module_name, mod_name);
  98         module_name[strlen(mod_name)] = '\0';
  99         new = kzalloc(sizeof(struct debug_name), GFP_KERNEL);
 100         if (!new) {
 101                 kfree(module_name);
 102                 ret = -ENOMEM;
 103                 goto out;
 104         }
 105         INIT_HLIST_NODE(&new->hlist);
 106         INIT_HLIST_NODE(&new->hlist2);
 107         new->name = module_name;
 108         new->hash1 = hash;
 109         new->hash2 = hash2;
 110         hlist_add_head_rcu(&new->hlist, &module_table[hash]);
 111         hlist_add_head_rcu(&new->hlist2, &module_table2[hash2]);
 112         nr_entries++;
 113 out:
 114         return ret;
 115 }
 116
 117 int unregister_dynamic_debug_module(char *mod_name)
 118 {
 119         struct debug_name *element;
 120         int ret = 0;
 121
 122         down(&debug_list_mutex);
 123         element = find_debug_module(mod_name);
 124         if (!element) {
 125                 ret = -EINVAL;
 126                 goto out;
 127         }
 128         hlist_del_rcu(&element->hlist);
 129         hlist_del_rcu(&element->hlist2);
 130         synchronize_rcu();
 131         kfree(element->name);
 132         if (element->enable)
 133                 num_enabled--;
 134         kfree(element);
 135         nr_entries--;
 136 out:
 137         up(&debug_list_mutex);
 138         return 0;
 139 }
 140 EXPORT_SYMBOL_GPL(unregister_dynamic_debug_module);
 141
 142 int register_dynamic_debug_module(char *mod_name, int type, char *share_name,
 143                                         char *flags, int hash, int hash2)
 144 {
 145         struct debug_name *elem;
 146         int ret = 0;
 147
 148         down(&debug_list_mutex);
 149         elem = find_debug_module(mod_name);
 150         if (!elem) {
 151                 if (__add_debug_module(mod_name, hash, hash2))
 152                         goto out;
 153                 elem = find_debug_module(mod_name);
 154                 if (dynamic_enabled == DYNAMIC_ENABLED_ALL &&
 155                                 !strcmp(mod_name, share_name)) {
 156                         elem->enable = true;
 157                         num_enabled++;
 158                 }
 159         }
 160         elem->type |= type;
 161 out:
 162         up(&debug_list_mutex);
 163         return ret;
 164 }
 165 EXPORT_SYMBOL_GPL(register_dynamic_debug_module);
 166
 167 int __dynamic_dbg_enabled_helper(char *mod_name, int type, int value, int hash)
 168 {
 169         struct debug_name *elem;
 170         int ret = 0;
 171
 172         if (dynamic_enabled == DYNAMIC_ENABLED_ALL)
 173                 return 1;
 174         rcu_read_lock();
 175         elem = find_debug_module_hash(mod_name, hash);
 176         if (elem && elem->enable)
 177                 ret = 1;
 178         rcu_read_unlock();
 179         return ret;
 180 }
 181 EXPORT_SYMBOL_GPL(__dynamic_dbg_enabled_helper);
 182
 183 static void set_all(bool enable)
 184 {
 185         struct debug_name *e;
 186         struct hlist_node *node;
 187         int i;
 188         long long enable_mask;
 189
 190         for (i = 0; i < DEBUG_HASH_TABLE_SIZE; i++) {
 191                 if (module_table[i].first != NULL) {
 192                         hlist_for_each_entry(e, node, &module_table[i], hlist) {
 193                                 e->enable = enable;
 194                         }
 195                 }
 196         }
 197         if (enable)
 198                 enable_mask = ULLONG_MAX;
 199         else
 200                 enable_mask = 0;
 201         dynamic_printk_enabled = enable_mask;
 202         dynamic_printk_enabled2 = enable_mask;
 203 }
 204
 205 static int disabled_hash(int i, bool first_table)
 206 {
 207         struct debug_name *e;
 208         struct hlist_node *node;
 209
 210         if (first_table) {
 211                 hlist_for_each_entry(e, node, &module_table[i], hlist) {
 212                         if (e->enable)
 213                                 return 0;
 214                 }
 215         } else {
 216                 hlist_for_each_entry(e, node, &module_table2[i], hlist2) {
 217                         if (e->enable)
 218                                 return 0;
 219                 }
 220         }
 221         return 1;
 222 }
 223
 224 static ssize_t pr_debug_write(struct file *file, const char __user *buf,
 225                                 size_t length, loff_t *ppos)
 226 {
 227         char *buffer, *s, *value_str, *setting_str;
 228         int err, value;
 229         struct debug_name *elem = NULL;
 230         int all = 0;
 231
 232         if (length > PAGE_SIZE || length < 0)
 233                 return -EINVAL;
 234
 235         buffer = (char *)__get_free_page(GFP_KERNEL);
 236         if (!buffer)
 237                 return -ENOMEM;
 238
 239         err = -EFAULT;
 240         if (copy_from_user(buffer, buf, length))
 241                 goto out;
 242
 243         err = -EINVAL;
 244         if (length < PAGE_SIZE)
 245                 buffer[length] = '\0';
 246         else if (buffer[PAGE_SIZE-1])
 247                 goto out;
 248
 249         err = -EINVAL;
 250         down(&debug_list_mutex);
 251
 252         if (strncmp("set", buffer, 3))
 253                 goto out_up;
 254         s = buffer + 3;
 255         setting_str = strsep(&s, "=");
 256         if (s == NULL)
 257                 goto out_up;
 258         setting_str = strstrip(setting_str);
 259         value_str = strsep(&s, " ");
 260         if (s == NULL)
 261                 goto out_up;
 262         s = strstrip(s);
 263         if (!strncmp(s, "all", 3))
 264                 all = 1;
 265         else
 266                 elem = find_debug_module(s);
 267         if (!strncmp(setting_str, "enable", 6)) {
 268                 value = !!simple_strtol(value_str, NULL, 10);
 269                 if (all) {
 270                         if (value) {
 271                                 set_all(true);
 272                                 num_enabled = nr_entries;
 273                                 dynamic_enabled = DYNAMIC_ENABLED_ALL;
 274                         } else {
 275                                 set_all(false);
 276                                 num_enabled = 0;
 277                                 dynamic_enabled = DYNAMIC_ENABLED_NONE;
 278                         }
 279                         err = 0;
 280                 } else {
 281                         if (elem) {
 282                                 if (value && (elem->enable == 0)) {
 283                                         dynamic_printk_enabled |=
 284                                                         (1LL << elem->hash1);
 285                                         dynamic_printk_enabled2 |=
 286                                                         (1LL << elem->hash2);
 287                                         elem->enable = 1;
 288                                         num_enabled++;
 289                                         dynamic_enabled = DYNAMIC_ENABLED_SOME;
 290                                         err = 0;
 291                                         printk(KERN_DEBUG
 292                                                "debugging enabled for module %s",
 293                                                elem->name);
 294                                 } else if (!value && (elem->enable == 1)) {
 295                                         elem->enable = 0;
 296                                         num_enabled--;
 297                                         if (disabled_hash(elem->hash1, true))
 298                                                 dynamic_printk_enabled &=
 299                                                         ~(1LL << elem->hash1);
 300                                         if (disabled_hash(elem->hash2, false))
 301                                                 dynamic_printk_enabled2 &=
 302                                                         ~(1LL << elem->hash2);
 303                                         if (num_enabled)
 304                                                 dynamic_enabled =
 305                                                         DYNAMIC_ENABLED_SOME;
 306                                         else
 307                                                 dynamic_enabled =
 308                                                         DYNAMIC_ENABLED_NONE;
 309                                         err = 0;
 310                                         printk(KERN_DEBUG
 311                                                "debugging disabled for module "
 312                                                "%s", elem->name);
 313                                 }
 314                         }
 315                 }
 316         }
 317         if (!err)
 318                 err = length;
 319 out_up:
 320         up(&debug_list_mutex);
 321 out:
 322         free_page((unsigned long)buffer);
 323         return err;
 324 }
 325
 326 static void *pr_debug_seq_start(struct seq_file *f, loff_t *pos)
 327 {
 328         return (*pos < DEBUG_HASH_TABLE_SIZE) ? pos : NULL;
 329 }
 330
 331 static void *pr_debug_seq_next(struct seq_file *s, void *v, loff_t *pos)
 332 {
 333         (*pos)++;
 334         if (*pos >= DEBUG_HASH_TABLE_SIZE)
 335                 return NULL;
 336         return pos;
 337 }
 338
 339 static void pr_debug_seq_stop(struct seq_file *s, void *v)
 340 {
 341         /* Nothing to do */
 342 }
 343
 344 static int pr_debug_seq_show(struct seq_file *s, void *v)
 345 {
 346         struct hlist_head *head;
 347         struct hlist_node *node;
 348         struct debug_name *elem;
 349         unsigned int i = *(loff_t *) v;
 350
 351         rcu_read_lock();
 352         head = &module_table[i];
 353         hlist_for_each_entry_rcu(elem, node, head, hlist) {
 354                 seq_printf(s, "%s enabled=%d", elem->name, elem->enable);
 355                 seq_printf(s, "\n");
 356         }
 357         rcu_read_unlock();
 358         return 0;
 359 }
 360
 361 static struct seq_operations pr_debug_seq_ops = {
 362         .start = pr_debug_seq_start,
 363         .next  = pr_debug_seq_next,
 364         .stop  = pr_debug_seq_stop,
 365         .show  = pr_debug_seq_show
 366 };
 367
 368 static int pr_debug_open(struct inode *inode, struct file *filp)
 369 {
 370         return seq_open(filp, &pr_debug_seq_ops);
 371 }
 372
 373 static const struct file_operations pr_debug_operations = {
 374         .open           = pr_debug_open,
 375         .read           = seq_read,
 376         .write          = pr_debug_write,
 377         .llseek         = seq_lseek,
 378         .release        = seq_release,
 379 };
 380
 381 static int __init dynamic_printk_init(void)
 382 {
 383         struct dentry *dir, *file;
 384         struct mod_debug *iter;
 385         unsigned long value;
 386
 387         dir = debugfs_create_dir("dynamic_printk", NULL);
 388         if (!dir)
 389                 return -ENOMEM;
 390         file = debugfs_create_file("modules", 0644, dir, NULL,
 391                                         &pr_debug_operations);
 392         if (!file) {
 393                 debugfs_remove(dir);
 394                 return -ENOMEM;
 395         }
 396         for (value = (unsigned long)__start___verbose;
 397                 value < (unsigned long)__stop___verbose;
 398                 value += sizeof(struct mod_debug)) {
 399                         iter = (struct mod_debug *)value;
 400                         register_dynamic_debug_module(iter->modname,
 401                                 iter->type,
 402                                 iter->logical_modname,
 403                                 iter->flag_names, iter->hash, iter->hash2);
 404         }
 405         if (dynamic_enabled == DYNAMIC_ENABLED_ALL)
 406                 set_all(true);
 407         return 0;
 408 }
 409 module_init(dynamic_printk_init);
 410 /* may want to move this earlier so we can get traces as early as possible */
 411
 412 static int __init dynamic_printk_setup(char *str)
 413 {
 414         if (str)
 415                 return -ENOENT;
 416         dynamic_enabled = DYNAMIC_ENABLED_ALL;
 417         return 0;
 418 }
 419 /* Use early_param(), so we can get debug output as early as possible */
 420 early_param("dynamic_printk", dynamic_printk_setup);