driver core: basic infrastructure for per-module dynamic debug messages

Base infrastructure to enable per-module debug messages.

I've introduced CONFIG_DYNAMIC_PRINTK_DEBUG, which when enabled centralizes
control of debugging statements on a per-module basis in one /proc file,
currently, <debugfs>/dynamic_printk/modules. When, CONFIG_DYNAMIC_PRINTK_DEBUG,
is not set, debugging statements can still be enabled as before, often by
defining 'DEBUG' for the proper compilation unit. Thus, this patch set has no
affect when CONFIG_DYNAMIC_PRINTK_DEBUG is not set.

The infrastructure currently ties into all pr_debug() and dev_dbg() calls. That
is, if CONFIG_DYNAMIC_PRINTK_DEBUG is set, all pr_debug() and dev_dbg() calls
can be dynamically enabled/disabled on a per-module basis.

Future plans include extending this functionality to subsystems, that define 
their own debug levels and flags.

Usage:

Dynamic debugging is controlled by the debugfs file, 
<debugfs>/dynamic_printk/modules. This file contains a list of the modules that
can be enabled. The format of the file is as follows:

	<module_name> <enabled=0/1>
		.
		.
		.

	<module_name> : Name of the module in which the debug call resides
	<enabled=0/1> : whether the messages are enabled or not

For example:

	snd_hda_intel enabled=0
	fixup enabled=1
	driver enabled=0

Enable a module:

	$echo "set enabled=1 <module_name>" > dynamic_printk/modules

Disable a module:

	$echo "set enabled=0 <module_name>" > dynamic_printk/modules

Enable all modules:

	$echo "set enabled=1 all" > dynamic_printk/modules

Disable all modules:

	$echo "set enabled=0 all" > dynamic_printk/modules

Finally, passing "dynamic_printk" at the command line enables
debugging for all modules. This mode can be turned off via the above
disable command.

[gkh: minor cleanups and tweaks to make the build work quietly]

Signed-off-by: Jason Baron <jbaron@redhat.com>
Signed-off-by: Greg Kroah-Hartman <gregkh@suse.de>

1 files changed, 418 insertions, 0 deletions

diff --git a/lib/dynamic_printk.c b/lib/dynamic_printk.c
new file mode 100644
index 000000000000..d640f87bdc9e
--- /dev/null
+++ b/lib/dynamic_printk.c
@@ -0,0 +1,418 @@
+/*
+ * lib/dynamic_printk.c
+ *
+ * make pr_debug()/dev_dbg() calls runtime configurable based upon their
+ * their source module.
+ *
+ * Copyright (C) 2008 Red Hat, Inc., Jason Baron <jbaron@redhat.com>
+ */
+
+#include <linux/kernel.h>
+#include <linux/module.h>
+#include <linux/uaccess.h>
+#include <linux/seq_file.h>
+#include <linux/debugfs.h>
+#include <linux/fs.h>
+
+extern struct mod_debug __start___verbose[];
+extern struct mod_debug __stop___verbose[];
+
+struct debug_name {
+        struct hlist_node hlist;
+        struct hlist_node hlist2;
+        int hash1;
+        int hash2;
+        char *name;
+        int enable;
+        int type;
+};
+
+static int nr_entries;
+static int num_enabled;
+int dynamic_enabled = DYNAMIC_ENABLED_NONE;
+static struct hlist_head module_table[DEBUG_HASH_TABLE_SIZE] =
+        { [0 ... DEBUG_HASH_TABLE_SIZE-1] = HLIST_HEAD_INIT };
+static struct hlist_head module_table2[DEBUG_HASH_TABLE_SIZE] =
+        { [0 ... DEBUG_HASH_TABLE_SIZE-1] = HLIST_HEAD_INIT };
+static DECLARE_MUTEX(debug_list_mutex);
+
+/* dynamic_printk_enabled, and dynamic_printk_enabled2 are bitmasks in which
+ * bit n is set to 1 if any modname hashes into the bucket n, 0 otherwise. They
+ * use independent hash functions, to reduce the chance of false positives.
+ */
+long long dynamic_printk_enabled;
+EXPORT_SYMBOL_GPL(dynamic_printk_enabled);
+long long dynamic_printk_enabled2;
+EXPORT_SYMBOL_GPL(dynamic_printk_enabled2);
+
+/* returns the debug module pointer. */
+static struct debug_name *find_debug_module(char *module_name)
+{
+        int i;
+        struct hlist_head *head;
+        struct hlist_node *node;
+        struct debug_name *element;
+
+        element = NULL;
+        for (i = 0; i < DEBUG_HASH_TABLE_SIZE; i++) {
+                head = &module_table[i];
+                hlist_for_each_entry_rcu(element, node, head, hlist)
+                        if (!strcmp(element->name, module_name))
+                                return element;
+        }
+        return NULL;
+}
+
+/* returns the debug module pointer. */
+static struct debug_name *find_debug_module_hash(char *module_name, int hash)
+{
+        struct hlist_head *head;
+        struct hlist_node *node;
+        struct debug_name *element;
+
+        element = NULL;
+        head = &module_table[hash];
+        hlist_for_each_entry_rcu(element, node, head, hlist)
+                if (!strcmp(element->name, module_name))
+                        return element;
+        return NULL;
+}
+
+/* caller must hold mutex*/
+static int __add_debug_module(char *mod_name, int hash, int hash2)
+{
+        struct debug_name *new;
+        char *module_name;
+        int ret = 0;
+
+        if (find_debug_module(mod_name)) {
+                ret = -EINVAL;
+                goto out;
+        }
+        module_name = kmalloc(strlen(mod_name) + 1, GFP_KERNEL);
+        if (!module_name) {
+                ret = -ENOMEM;
+                goto out;
+        }
+        module_name = strcpy(module_name, mod_name);
+        module_name[strlen(mod_name)] = '\0';
+        new = kzalloc(sizeof(struct debug_name), GFP_KERNEL);
+        if (!new) {
+                kfree(module_name);
+                ret = -ENOMEM;
+                goto out;
+        }
+        INIT_HLIST_NODE(&new->hlist);
+        INIT_HLIST_NODE(&new->hlist2);
+        new->name = module_name;
+        new->hash1 = hash;
+        new->hash2 = hash2;
+        hlist_add_head_rcu(&new->hlist, &module_table[hash]);
+        hlist_add_head_rcu(&new->hlist2, &module_table2[hash2]);
+        nr_entries++;
+out:
+        return ret;
+}
+
+int unregister_dynamic_debug_module(char *mod_name)
+{
+        struct debug_name *element;
+        int ret = 0;
+
+        down(&debug_list_mutex);
+        element = find_debug_module(mod_name);
+        if (!element) {
+                ret = -EINVAL;
+                goto out;
+        }
+        hlist_del_rcu(&element->hlist);
+        hlist_del_rcu(&element->hlist2);
+        synchronize_rcu();
+        kfree(element->name);
+        if (element->enable)
+                num_enabled--;
+        kfree(element);
+        nr_entries--;
+out:
+        up(&debug_list_mutex);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(unregister_dynamic_debug_module);
+
+int register_dynamic_debug_module(char *mod_name, int type, char *share_name,
+                                        char *flags, int hash, int hash2)
+{
+        struct debug_name *elem;
+        int ret = 0;
+
+        down(&debug_list_mutex);
+        elem = find_debug_module(mod_name);
+        if (!elem) {
+                if (__add_debug_module(mod_name, hash, hash2))
+                        goto out;
+                elem = find_debug_module(mod_name);
+                if (dynamic_enabled == DYNAMIC_ENABLED_ALL &&
+                                !strcmp(mod_name, share_name)) {
+                        elem->enable = true;
+                        num_enabled++;
+                }
+        }
+        elem->type |= type;
+out:
+        up(&debug_list_mutex);
+        return ret;
+}
+EXPORT_SYMBOL_GPL(register_dynamic_debug_module);
+
+int __dynamic_dbg_enabled_helper(char *mod_name, int type, int value, int hash)
+{
+        struct debug_name *elem;
+        int ret = 0;
+
+        if (dynamic_enabled == DYNAMIC_ENABLED_ALL)
+                return 1;
+        rcu_read_lock();
+        elem = find_debug_module_hash(mod_name, hash);
+        if (elem && elem->enable)
+                ret = 1;
+        rcu_read_unlock();
+        return ret;
+}
+EXPORT_SYMBOL_GPL(__dynamic_dbg_enabled_helper);
+
+static void set_all(bool enable)
+{
+        struct debug_name *e;
+        struct hlist_node *node;
+        int i;
+        long long enable_mask;
+
+        for (i = 0; i < DEBUG_HASH_TABLE_SIZE; i++) {
+                if (module_table[i].first != NULL) {
+                        hlist_for_each_entry(e, node, &module_table[i], hlist) {
+                                e->enable = enable;
+                        }
+                }
+        }
+        if (enable)
+                enable_mask = ULLONG_MAX;
+        else
+                enable_mask = 0;
+        dynamic_printk_enabled = enable_mask;
+        dynamic_printk_enabled2 = enable_mask;
+}
+
+static int disabled_hash(int i, bool first_table)
+{
+        struct debug_name *e;
+        struct hlist_node *node;
+
+        if (first_table) {
+                hlist_for_each_entry(e, node, &module_table[i], hlist) {
+                        if (e->enable)
+                                return 0;
+                }
+        } else {
+                hlist_for_each_entry(e, node, &module_table2[i], hlist2) {
+                        if (e->enable)
+                                return 0;
+                }
+        }
+        return 1;
+}
+
+static ssize_t pr_debug_write(struct file *file, const char __user *buf,
+                                size_t length, loff_t *ppos)
+{
+        char *buffer, *s, *value_str, *setting_str;
+        int err, value;
+        struct debug_name *elem = NULL;
+        int all = 0;
+
+        if (length > PAGE_SIZE || length < 0)
+                return -EINVAL;
+
+        buffer = (char *)__get_free_page(GFP_KERNEL);
+        if (!buffer)
+                return -ENOMEM;
+
+        err = -EFAULT;
+        if (copy_from_user(buffer, buf, length))
+                goto out;
+
+        err = -EINVAL;
+        if (length < PAGE_SIZE)
+                buffer[length] = '\0';
+        else if (buffer[PAGE_SIZE-1])
+                goto out;
+
+        err = -EINVAL;
+        down(&debug_list_mutex);
+
+        if (strncmp("set", buffer, 3))
+                goto out_up;
+        s = buffer + 3;
+        setting_str = strsep(&s, "=");
+        if (s == NULL)
+                goto out_up;
+        setting_str = strstrip(setting_str);
+        value_str = strsep(&s, " ");
+        if (s == NULL)
+                goto out_up;
+        s = strstrip(s);
+        if (!strncmp(s, "all", 3))
+                all = 1;
+        else
+                elem = find_debug_module(s);
+        if (!strncmp(setting_str, "enable", 6)) {
+                value = !!simple_strtol(value_str, NULL, 10);
+                if (all) {
+                        if (value) {
+                                set_all(true);
+                                num_enabled = nr_entries;
+                                dynamic_enabled = DYNAMIC_ENABLED_ALL;
+                        } else {
+                                set_all(false);
+                                num_enabled = 0;
+                                dynamic_enabled = DYNAMIC_ENABLED_NONE;
+                        }
+                        err = 0;
+                } else {
+                        if (elem) {
+                                if (value && (elem->enable == 0)) {
+                                        dynamic_printk_enabled |=
+                                                        (1LL << elem->hash1);
+                                        dynamic_printk_enabled2 |=
+                                                        (1LL << elem->hash2);
+                                        elem->enable = 1;
+                                        num_enabled++;
+                                        dynamic_enabled = DYNAMIC_ENABLED_SOME;
+                                        err = 0;
+                                        printk(KERN_DEBUG
+                                               "debugging enabled for module %s",
+                                               elem->name);
+                                } else if (!value && (elem->enable == 1)) {
+                                        elem->enable = 0;
+                                        num_enabled--;
+                                        if (disabled_hash(elem->hash1, true))
+                                                dynamic_printk_enabled &=
+                                                        ~(1LL << elem->hash1);
+                                        if (disabled_hash(elem->hash2, false))
+                                                dynamic_printk_enabled2 &=
+                                                        ~(1LL << elem->hash2);
+                                        if (num_enabled)
+                                                dynamic_enabled =
+                                                        DYNAMIC_ENABLED_SOME;
+                                        else
+                                                dynamic_enabled =
+                                                        DYNAMIC_ENABLED_NONE;
+                                        err = 0;
+                                        printk(KERN_DEBUG
+                                               "debugging disabled for module "
+                                               "%s", elem->name);
+                                }
+                        }
+                }
+        }
+        if (!err)
+                err = length;
+out_up:
+        up(&debug_list_mutex);
+out:
+        free_page((unsigned long)buffer);
+        return err;
+}
+
+static void *pr_debug_seq_start(struct seq_file *f, loff_t *pos)
+{
+        return (*pos < DEBUG_HASH_TABLE_SIZE) ? pos : NULL;
+}
+
+static void *pr_debug_seq_next(struct seq_file *s, void *v, loff_t *pos)
+{
+        (*pos)++;
+        if (*pos >= DEBUG_HASH_TABLE_SIZE)
+                return NULL;
+        return pos;
+}
+
+static void pr_debug_seq_stop(struct seq_file *s, void *v)
+{
+        /* Nothing to do */
+}
+
+static int pr_debug_seq_show(struct seq_file *s, void *v)
+{
+        struct hlist_head *head;
+        struct hlist_node *node;
+        struct debug_name *elem;
+        unsigned int i = *(loff_t *) v;
+
+        rcu_read_lock();
+        head = &module_table[i];
+        hlist_for_each_entry_rcu(elem, node, head, hlist) {
+                seq_printf(s, "%s enabled=%d", elem->name, elem->enable);
+                seq_printf(s, "\n");
+        }
+        rcu_read_unlock();
+        return 0;
+}
+
+static struct seq_operations pr_debug_seq_ops = {
+        .start = pr_debug_seq_start,
+        .next  = pr_debug_seq_next,
+        .stop  = pr_debug_seq_stop,
+        .show  = pr_debug_seq_show
+};
+
+static int pr_debug_open(struct inode *inode, struct file *filp)
+{
+        return seq_open(filp, &pr_debug_seq_ops);
+}
+
+static const struct file_operations pr_debug_operations = {
+        .open           = pr_debug_open,
+        .read           = seq_read,
+        .write          = pr_debug_write,
+        .llseek         = seq_lseek,
+        .release        = seq_release,
+};
+
+static int __init dynamic_printk_init(void)
+{
+        struct dentry *dir, *file;
+        struct mod_debug *iter;
+        unsigned long value;
+
+        dir = debugfs_create_dir("dynamic_printk", NULL);
+        if (!dir)
+                return -ENOMEM;
+        file = debugfs_create_file("modules", 0644, dir, NULL,
+                                        &pr_debug_operations);
+        if (!file) {
+                debugfs_remove(dir);
+                return -ENOMEM;
+        }
+        for (value = (unsigned long)__start___verbose;
+                value < (unsigned long)__stop___verbose;
+                value += sizeof(struct mod_debug)) {
+                        iter = (struct mod_debug *)value;
+                        register_dynamic_debug_module(iter->modname,
+                                iter->type,
+                                iter->logical_modname,
+                                iter->flag_names, iter->hash, iter->hash2);
+        }
+        return 0;
+}
+module_init(dynamic_printk_init);
+/* may want to move this earlier so we can get traces as early as possible */
+
+static int __init dynamic_printk_setup(char *str)
+{
+        if (str)
+                return -ENOENT;
+        set_all(true);
+        return 0;
+}
+/* Use early_param(), so we can get debug output as early as possible */
+early_param("dynamic_printk", dynamic_printk_setup);