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>

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>
Jason Baron · Greg Kroah-Hartman
1 parent 33376c1c04
Showing 14 changed files with 700 additions and 7 deletions Side-by-side Diff
Documentation/kernel-parameters.txt
include/asm-generic/vmlinux.lds.h
include/linux/device.h
include/linux/dynamic_printk.h
include/linux/kernel.h
include/linux/module.h
kernel/module.c
lib/Kconfig.debug
lib/Makefile
lib/dynamic_printk.c
net/netfilter/nf_conntrack_pptp.c
scripts/Makefile.lib
scripts/basic/Makefile
scripts/basic/hash.c
@@ -1713,6 +1713,11 @@
 			autoconfiguration.
 			Ranges are in pairs (memory base and size).
  
+	dynamic_printk
+			Enables pr_debug()/dev_dbg() calls if
+			CONFIG_DYNAMIC_PRINTK_DEBUG has been enabled. These can also
+			be switched on/off via <debugfs>/dynamic_printk/modules
+
 	print-fatal-signals=
 			[KNL] debug: print fatal signals
 			print-fatal-signals=1: print segfault info to
@@ -268,7 +268,15 @@
 	CPU_DISCARD(init.data)						\
 	CPU_DISCARD(init.rodata)					\
 	MEM_DISCARD(init.data)						\
-	MEM_DISCARD(init.rodata)
+	MEM_DISCARD(init.rodata)					\
+	/* implement dynamic printk debug */				\
+	VMLINUX_SYMBOL(__start___verbose_strings) = .;                  \
+	*(__verbose_strings)                                            \
+	VMLINUX_SYMBOL(__stop___verbose_strings) = .;                   \
+	. = ALIGN(8);							\
+	VMLINUX_SYMBOL(__start___verbose) = .;                          \
+	*(__verbose)                                                    \
+	VMLINUX_SYMBOL(__stop___verbose) = .;
  
 #define INIT_TEXT							\
 	*(.init.text)							\
@@ -550,7 +550,11 @@
 #define dev_info(dev, format, arg...)		\
 	dev_printk(KERN_INFO , dev , format , ## arg)
  
-#ifdef DEBUG
+#if defined(CONFIG_DYNAMIC_PRINTK_DEBUG)
+#define dev_dbg(dev, format, ...) do { \
+	dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
+	} while (0)
+#elif defined(DEBUG)
 #define dev_dbg(dev, format, arg...)		\
 	dev_printk(KERN_DEBUG , dev , format , ## arg)
 #else
+#ifndef _DYNAMIC_PRINTK_H
+#define _DYNAMIC_PRINTK_H
+
+#define DYNAMIC_DEBUG_HASH_BITS 6
+#define DEBUG_HASH_TABLE_SIZE (1 << DYNAMIC_DEBUG_HASH_BITS)
+
+#define TYPE_BOOLEAN 1
+
+#define DYNAMIC_ENABLED_ALL 0
+#define DYNAMIC_ENABLED_NONE 1
+#define DYNAMIC_ENABLED_SOME 2
+
+extern int dynamic_enabled;
+
+/* 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.
+ */
+extern long long dynamic_printk_enabled;
+extern long long dynamic_printk_enabled2;
+
+struct mod_debug {
+	char *modname;
+	char *logical_modname;
+	char *flag_names;
+	int type;
+	int hash;
+	int hash2;
+} __attribute__((aligned(8)));
+
+int register_dynamic_debug_module(char *mod_name, int type, char *share_name,
+					char *flags, int hash, int hash2);
+
+#if defined(CONFIG_DYNAMIC_PRINTK_DEBUG)
+extern int unregister_dynamic_debug_module(char *mod_name);
+extern int __dynamic_dbg_enabled_helper(char *modname, int type,
+					int value, int hash);
+
+#define __dynamic_dbg_enabled(module, type, value, level, hash)  ({	     \
+	int __ret = 0;							     \
+	if (unlikely((dynamic_printk_enabled & (1LL << DEBUG_HASH)) &&	     \
+			(dynamic_printk_enabled2 & (1LL << DEBUG_HASH2))))   \
+			__ret = __dynamic_dbg_enabled_helper(module, type,   \
+								value, hash);\
+	__ret; })
+
+#define dynamic_pr_debug(fmt, ...) do {					    \
+	static char mod_name[]						    \
+	__attribute__((section("__verbose_strings")))			    \
+	 = KBUILD_MODNAME;						    \
+	static struct mod_debug descriptor				    \
+	__used								    \
+	__attribute__((section("__verbose"), aligned(8))) =		    \
+	{ mod_name, mod_name, NULL, TYPE_BOOLEAN, DEBUG_HASH, DEBUG_HASH2 };\
+	if (__dynamic_dbg_enabled(KBUILD_MODNAME, TYPE_BOOLEAN,		    \
+						0, 0, DEBUG_HASH))	    \
+		printk(KERN_DEBUG KBUILD_MODNAME ":" fmt,		    \
+				##__VA_ARGS__);				    \
+	} while (0)
+
+#define dynamic_dev_dbg(dev, format, ...) do {				    \
+	static char mod_name[]						    \
+	__attribute__((section("__verbose_strings")))			    \
+	 = KBUILD_MODNAME;						    \
+	static struct mod_debug descriptor				    \
+	__used								    \
+	__attribute__((section("__verbose"), aligned(8))) =		    \
+	{ mod_name, mod_name, NULL, TYPE_BOOLEAN, DEBUG_HASH, DEBUG_HASH2 };\
+	if (__dynamic_dbg_enabled(KBUILD_MODNAME, TYPE_BOOLEAN,		    \
+						0, 0, DEBUG_HASH))	    \
+			dev_printk(KERN_DEBUG, dev,			    \
+					KBUILD_MODNAME ": " format,	    \
+					##__VA_ARGS__);			    \
+	} while (0)
+
+#else
+
+static inline int unregister_dynamic_debug_module(const char *mod_name)
+{
+	return 0;
+}
+static inline int __dynamic_dbg_enabled_helper(char *modname, int type,
+						int value, int hash)
+{
+	return 0;
+}
+
+#define __dynamic_dbg_enabled(module, type, value, level, hash)  ({ 0; })
+#define dynamic_pr_debug(fmt, ...)  do { } while (0)
+#define dynamic_dev_dbg(dev, format, ...)  do { } while (0)
+#endif
+
+#endif
@@ -16,6 +16,7 @@
 #include <linux/log2.h>
 #include <linux/typecheck.h>
 #include <linux/ratelimit.h>
+#include <linux/dynamic_printk.h>
 #include <asm/byteorder.h>
 #include <asm/bug.h>
  
  
@@ -303,8 +304,12 @@
 #define pr_info(fmt, arg...) \
 	printk(KERN_INFO fmt, ##arg)
  
-#ifdef DEBUG
 /* If you are writing a driver, please use dev_dbg instead */
+#if defined(CONFIG_DYNAMIC_PRINTK_DEBUG)
+#define pr_debug(fmt, ...) do { \
+	dynamic_pr_debug(fmt, ##__VA_ARGS__); \
+	} while (0)
+#elif defined(DEBUG)
 #define pr_debug(fmt, arg...) \
 	printk(KERN_DEBUG fmt, ##arg)
 #else
@@ -345,7 +345,6 @@
 	/* Reference counts */
 	struct module_ref ref[NR_CPUS];
 #endif
-
 };
 #ifndef MODULE_ARCH_INIT
 #define MODULE_ARCH_INIT {}
@@ -784,6 +784,7 @@
 	mutex_lock(&module_mutex);
 	/* Store the name of the last unloaded module for diagnostic purposes */
 	strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));
+	unregister_dynamic_debug_module(mod->name);
 	free_module(mod);
  
  out:
@@ -1783,6 +1784,33 @@
 }
 #endif /* CONFIG_KALLSYMS */
  
+#ifdef CONFIG_DYNAMIC_PRINTK_DEBUG
+static void dynamic_printk_setup(Elf_Shdr *sechdrs, unsigned int verboseindex)
+{
+	struct mod_debug *debug_info;
+	unsigned long pos, end;
+	unsigned int num_verbose;
+
+	pos = sechdrs[verboseindex].sh_addr;
+	num_verbose = sechdrs[verboseindex].sh_size /
+				sizeof(struct mod_debug);
+	end = pos + (num_verbose * sizeof(struct mod_debug));
+
+	for (; pos < end; pos += sizeof(struct mod_debug)) {
+		debug_info = (struct mod_debug *)pos;
+		register_dynamic_debug_module(debug_info->modname,
+			debug_info->type, debug_info->logical_modname,
+			debug_info->flag_names, debug_info->hash,
+			debug_info->hash2);
+	}
+}
+#else
+static inline void dynamic_printk_setup(Elf_Shdr *sechdrs,
+					unsigned int verboseindex)
+{
+}
+#endif /* CONFIG_DYNAMIC_PRINTK_DEBUG */
+
 static void *module_alloc_update_bounds(unsigned long size)
 {
 	void *ret = module_alloc(size);
@@ -1831,6 +1859,7 @@
 #endif
 	unsigned int markersindex;
 	unsigned int markersstringsindex;
+	unsigned int verboseindex;
 	struct module *mod;
 	long err = 0;
 	void *percpu = NULL, *ptr = NULL; /* Stops spurious gcc warning */
@@ -2117,6 +2146,7 @@
 	markersindex = find_sec(hdr, sechdrs, secstrings, "__markers");
  	markersstringsindex = find_sec(hdr, sechdrs, secstrings,
 					"__markers_strings");
+	verboseindex = find_sec(hdr, sechdrs, secstrings, "__verbose");
  
 	/* Now do relocations. */
 	for (i = 1; i < hdr->e_shnum; i++) {
@@ -2167,6 +2197,7 @@
 		marker_update_probe_range(mod->markers,
 			mod->markers + mod->num_markers);
 #endif
+	dynamic_printk_setup(sechdrs, verboseindex);
 	err = module_finalize(hdr, sechdrs, mod);
 	if (err < 0)
 		goto cleanup;
@@ -807,6 +807,61 @@
  
 	  Say N if you are unsure.
  
+config DYNAMIC_PRINTK_DEBUG
+	bool "Enable dynamic printk() call support"
+	default n
+	depends on PRINTK
+	select PRINTK_DEBUG
+	help
+
+	  Compiles debug level messages into the kernel, which would not
+	  otherwise be available at runtime. These messages can then be
+	  enabled/disabled on a per module basis. This mechanism implicitly
+	  enables all pr_debug() and dev_dbg() calls. The impact of this
+	  compile option is a larger kernel text size of about 2%.
+
+	  Usage:
+
+	  Dynamic debugging is controlled by the debugfs file,
+	  dynamic_printk/modules. This file contains a list of the modules that
+	  can be enabled. The format of the file is the module name, followed
+	  by a set of flags that can be enabled. The first flag is always the
+	  'enabled' flag. For example:
+
+		<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
+
+	  From a live system:
+
+		snd_hda_intel enabled=0
+		fixup enabled=0
+		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.
+
 source "samples/Kconfig"
  
 source "lib/Kconfig.kgdb"
@@ -81,6 +81,8 @@
  
 obj-$(CONFIG_HAVE_ARCH_TRACEHOOK) += syscall.o
  
+obj-$(CONFIG_DYNAMIC_PRINTK_DEBUG) += dynamic_printk.o
+
 hostprogs-y	:= gen_crc32table
 clean-files	:= crc32table.h
  
+/*
+ * 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);
@@ -65,7 +65,7 @@
 			     struct nf_conntrack_expect *exp) __read_mostly;
 EXPORT_SYMBOL_GPL(nf_nat_pptp_hook_expectfn);
  
-#ifdef DEBUG
+#if defined(DEBUG) || defined(CONFIG_DYNAMIC_PRINTK_DEBUG)
 /* PptpControlMessageType names */
 const char *const pptp_msg_name[] = {
 	"UNKNOWN_MESSAGE",
@@ -96,6 +96,14 @@
 modname_flags  = $(if $(filter 1,$(words $(modname))),\
                  -D"KBUILD_MODNAME=KBUILD_STR($(call name-fix,$(modname)))")
  
+#hash values
+ifdef CONFIG_DYNAMIC_PRINTK_DEBUG
+debug_flags = -D"DEBUG_HASH=$(shell ./scripts/basic/hash djb2 $(@D)$(modname))"\
+              -D"DEBUG_HASH2=$(shell ./scripts/basic/hash r5 $(@D)$(modname))"
+else
+debug_flags =
+endif
+
 orig_c_flags   = $(KBUILD_CFLAGS) $(ccflags-y) $(CFLAGS_$(basetarget).o)
 _c_flags       = $(filter-out $(CFLAGS_REMOVE_$(basetarget).o), $(orig_c_flags))
 _a_flags       = $(KBUILD_AFLAGS) $(asflags-y) $(AFLAGS_$(basetarget).o)
@@ -121,7 +129,8 @@
  
 c_flags        = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(KBUILD_CPPFLAGS) \
 		 $(__c_flags) $(modkern_cflags) \
-		 -D"KBUILD_STR(s)=\#s" $(basename_flags) $(modname_flags)
+		 -D"KBUILD_STR(s)=\#s" $(basename_flags) $(modname_flags) \
+		  $(debug_flags)
  
 a_flags        = -Wp,-MD,$(depfile) $(NOSTDINC_FLAGS) $(KBUILD_CPPFLAGS) \
 		 $(__a_flags) $(modkern_aflags)
@@ -9,7 +9,7 @@
 # fixdep: 	 Used to generate dependency information during build process
 # docproc:	 Used in Documentation/DocBook
  
-hostprogs-y	:= fixdep docproc
+hostprogs-y	:= fixdep docproc hash
 always		:= $(hostprogs-y)
  
 # fixdep is needed to compile other host programs
+/*
+ * Copyright (C) 2008 Red Hat, Inc., Jason Baron <jbaron@redhat.com>
+ *
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#define DYNAMIC_DEBUG_HASH_BITS 6
+
+static const char *program;
+
+static void usage(void)
+{
+	printf("Usage: %s <djb2|r5> <modname>\n", program);
+	exit(1);
+}
+
+/* djb2 hashing algorithm by Dan Bernstein. From:
+ * http://www.cse.yorku.ca/~oz/hash.html
+ */
+
+unsigned int djb2_hash(char *str)
+{
+	unsigned long hash = 5381;
+	int c;
+
+	c = *str;
+	while (c) {
+		hash = ((hash << 5) + hash) + c;
+		c = *++str;
+	}
+	return (unsigned int)(hash & ((1 << DYNAMIC_DEBUG_HASH_BITS) - 1));
+}
+
+unsigned int r5_hash(char *str)
+{
+	unsigned long hash = 0;
+	int c;
+
+	c = *str;
+	while (c) {
+		hash = (hash + (c << 4) + (c >> 4)) * 11;
+		c = *++str;
+	}
+	return (unsigned int)(hash & ((1 << DYNAMIC_DEBUG_HASH_BITS) - 1));
+}
+
+int main(int argc, char *argv[])
+{
+	program = argv[0];
+
+	if (argc != 3)
+		usage();
+	if (!strcmp(argv[1], "djb2"))
+		printf("%d\n", djb2_hash(argv[2]));
+	else if (!strcmp(argv[1], "r5"))
+		printf("%d\n", r5_hash(argv[2]));
+	else
+		usage();
+	exit(0);
+}
...	...	@@ -1713,6 +1713,11 @@
1713	1713	autoconfiguration.
1714	1714	Ranges are in pairs (memory base and size).
1715	1715
	1716	+ dynamic_printk
	1717	+ Enables pr_debug()/dev_dbg() calls if
	1718	+ CONFIG_DYNAMIC_PRINTK_DEBUG has been enabled. These can also
	1719	+ be switched on/off via <debugfs>/dynamic_printk/modules
	1720	+
1716	1721	print-fatal-signals=
1717	1722	[KNL] debug: print fatal signals
1718	1723	print-fatal-signals=1: print segfault info to
...	...	@@ -268,7 +268,15 @@
268	268	CPU_DISCARD(init.data) \
269	269	CPU_DISCARD(init.rodata) \
270	270	MEM_DISCARD(init.data) \
271		- MEM_DISCARD(init.rodata)
	271	+ MEM_DISCARD(init.rodata) \
	272	+ /* implement dynamic printk debug */ \
	273	+ VMLINUX_SYMBOL(__start___verbose_strings) = .; \
	274	+ *(__verbose_strings) \
	275	+ VMLINUX_SYMBOL(__stop___verbose_strings) = .; \
	276	+ . = ALIGN(8); \
	277	+ VMLINUX_SYMBOL(__start___verbose) = .; \
	278	+ *(__verbose) \
	279	+ VMLINUX_SYMBOL(__stop___verbose) = .;
272	280
273	281	#define INIT_TEXT \
274	282	*(.init.text) \
...	...	@@ -550,7 +550,11 @@
550	550	#define dev_info(dev, format, arg...) \
551	551	dev_printk(KERN_INFO , dev , format , ## arg)
552	552
553		-#ifdef DEBUG
	553	+#if defined(CONFIG_DYNAMIC_PRINTK_DEBUG)
	554	+#define dev_dbg(dev, format, ...) do { \
	555	+ dynamic_dev_dbg(dev, format, ##__VA_ARGS__); \
	556	+ } while (0)
	557	+#elif defined(DEBUG)
554	558	#define dev_dbg(dev, format, arg...) \
555	559	dev_printk(KERN_DEBUG , dev , format , ## arg)
556	560	#else
	1	+#ifndef _DYNAMIC_PRINTK_H
	2	+#define _DYNAMIC_PRINTK_H
	3	+
	4	+#define DYNAMIC_DEBUG_HASH_BITS 6
	5	+#define DEBUG_HASH_TABLE_SIZE (1 << DYNAMIC_DEBUG_HASH_BITS)
	6	+
	7	+#define TYPE_BOOLEAN 1
	8	+
	9	+#define DYNAMIC_ENABLED_ALL 0
	10	+#define DYNAMIC_ENABLED_NONE 1
	11	+#define DYNAMIC_ENABLED_SOME 2
	12	+
	13	+extern int dynamic_enabled;
	14	+
	15	+/* dynamic_printk_enabled, and dynamic_printk_enabled2 are bitmasks in which
	16	+ * bit n is set to 1 if any modname hashes into the bucket n, 0 otherwise. They
	17	+ * use independent hash functions, to reduce the chance of false positives.
	18	+ */
	19	+extern long long dynamic_printk_enabled;
	20	+extern long long dynamic_printk_enabled2;
	21	+
	22	+struct mod_debug {
	23	+ char *modname;
	24	+ char *logical_modname;
	25	+ char *flag_names;
	26	+ int type;
	27	+ int hash;
	28	+ int hash2;
	29	+} __attribute__((aligned(8)));
	30	+
	31	+int register_dynamic_debug_module(char mod_name, int type, char share_name,
	32	+ char *flags, int hash, int hash2);
	33	+
	34	+#if defined(CONFIG_DYNAMIC_PRINTK_DEBUG)
	35	+extern int unregister_dynamic_debug_module(char *mod_name);
	36	+extern int __dynamic_dbg_enabled_helper(char *modname, int type,
	37	+ int value, int hash);
	38	+
	39	+#define __dynamic_dbg_enabled(module, type, value, level, hash) ({ \
	40	+ int __ret = 0; \
	41	+ if (unlikely((dynamic_printk_enabled & (1LL << DEBUG_HASH)) && \
	42	+ (dynamic_printk_enabled2 & (1LL << DEBUG_HASH2)))) \
	43	+ __ret = __dynamic_dbg_enabled_helper(module, type, \
	44	+ value, hash);\
	45	+ __ret; })
	46	+
	47	+#define dynamic_pr_debug(fmt, ...) do { \
	48	+ static char mod_name[] \
	49	+ __attribute__((section("__verbose_strings"))) \
	50	+ = KBUILD_MODNAME; \
	51	+ static struct mod_debug descriptor \
	52	+ __used \
	53	+ __attribute__((section("__verbose"), aligned(8))) = \
	54	+ { mod_name, mod_name, NULL, TYPE_BOOLEAN, DEBUG_HASH, DEBUG_HASH2 };\
	55	+ if (__dynamic_dbg_enabled(KBUILD_MODNAME, TYPE_BOOLEAN, \
	56	+ 0, 0, DEBUG_HASH)) \
	57	+ printk(KERN_DEBUG KBUILD_MODNAME ":" fmt, \
	58	+ ##__VA_ARGS__); \
	59	+ } while (0)
	60	+
	61	+#define dynamic_dev_dbg(dev, format, ...) do { \
	62	+ static char mod_name[] \
	63	+ __attribute__((section("__verbose_strings"))) \
	64	+ = KBUILD_MODNAME; \
	65	+ static struct mod_debug descriptor \
	66	+ __used \
	67	+ __attribute__((section("__verbose"), aligned(8))) = \
	68	+ { mod_name, mod_name, NULL, TYPE_BOOLEAN, DEBUG_HASH, DEBUG_HASH2 };\
	69	+ if (__dynamic_dbg_enabled(KBUILD_MODNAME, TYPE_BOOLEAN, \
	70	+ 0, 0, DEBUG_HASH)) \
	71	+ dev_printk(KERN_DEBUG, dev, \
	72	+ KBUILD_MODNAME ": " format, \
	73	+ ##__VA_ARGS__); \
	74	+ } while (0)
	75	+
	76	+#else
	77	+
	78	+static inline int unregister_dynamic_debug_module(const char *mod_name)
	79	+{
	80	+ return 0;
	81	+}
	82	+static inline int __dynamic_dbg_enabled_helper(char *modname, int type,
	83	+ int value, int hash)
	84	+{
	85	+ return 0;
	86	+}
	87	+
	88	+#define __dynamic_dbg_enabled(module, type, value, level, hash) ({ 0; })
	89	+#define dynamic_pr_debug(fmt, ...) do { } while (0)
	90	+#define dynamic_dev_dbg(dev, format, ...) do { } while (0)
	91	+#endif
	92	+
	93	+#endif
...	...	@@ -16,6 +16,7 @@
16	16	#include <linux/log2.h>
17	17	#include <linux/typecheck.h>
18	18	#include <linux/ratelimit.h>
	19	+#include <linux/dynamic_printk.h>
19	20	#include <asm/byteorder.h>
20	21	#include <asm/bug.h>
21	22
22	23
...	...	@@ -303,8 +304,12 @@
303	304	#define pr_info(fmt, arg...) \
304	305	printk(KERN_INFO fmt, ##arg)
305	306
306		-#ifdef DEBUG
307	307	/* If you are writing a driver, please use dev_dbg instead */
	308	+#if defined(CONFIG_DYNAMIC_PRINTK_DEBUG)
	309	+#define pr_debug(fmt, ...) do { \
	310	+ dynamic_pr_debug(fmt, ##__VA_ARGS__); \
	311	+ } while (0)
	312	+#elif defined(DEBUG)
308	313	#define pr_debug(fmt, arg...) \
309	314	printk(KERN_DEBUG fmt, ##arg)
310	315	#else
...	...	@@ -345,7 +345,6 @@
345	345	/* Reference counts */
346	346	struct module_ref ref[NR_CPUS];
347	347	#endif
348		-
349	348	};
350	349	#ifndef MODULE_ARCH_INIT
351	350	#define MODULE_ARCH_INIT {}
...	...	@@ -784,6 +784,7 @@
784	784	mutex_lock(&module_mutex);
785	785	/* Store the name of the last unloaded module for diagnostic purposes */
786	786	strlcpy(last_unloaded_module, mod->name, sizeof(last_unloaded_module));
	787	+ unregister_dynamic_debug_module(mod->name);
787	788	free_module(mod);
788	789
789	790	out:
...	...	@@ -1783,6 +1784,33 @@
1783	1784	}
1784	1785	#endif /* CONFIG_KALLSYMS */
1785	1786
	1787	+#ifdef CONFIG_DYNAMIC_PRINTK_DEBUG
	1788	+static void dynamic_printk_setup(Elf_Shdr *sechdrs, unsigned int verboseindex)
	1789	+{
	1790	+ struct mod_debug *debug_info;
	1791	+ unsigned long pos, end;
	1792	+ unsigned int num_verbose;
	1793	+
	1794	+ pos = sechdrs[verboseindex].sh_addr;
	1795	+ num_verbose = sechdrs[verboseindex].sh_size /
	1796	+ sizeof(struct mod_debug);
	1797	+ end = pos + (num_verbose * sizeof(struct mod_debug));
	1798	+
	1799	+ for (; pos < end; pos += sizeof(struct mod_debug)) {
	1800	+ debug_info = (struct mod_debug *)pos;
	1801	+ register_dynamic_debug_module(debug_info->modname,
	1802	+ debug_info->type, debug_info->logical_modname,
	1803	+ debug_info->flag_names, debug_info->hash,
	1804	+ debug_info->hash2);
	1805	+ }
	1806	+}
	1807	+#else
	1808	+static inline void dynamic_printk_setup(Elf_Shdr *sechdrs,
	1809	+ unsigned int verboseindex)
	1810	+{
	1811	+}
	1812	+#endif /* CONFIG_DYNAMIC_PRINTK_DEBUG */
	1813	+
1786	1814	static void *module_alloc_update_bounds(unsigned long size)
1787	1815	{
1788	1816	void *ret = module_alloc(size);
...	...	@@ -1831,6 +1859,7 @@
1831	1859	#endif
1832	1860	unsigned int markersindex;
1833	1861	unsigned int markersstringsindex;
	1862	+ unsigned int verboseindex;
1834	1863	struct module *mod;
1835	1864	long err = 0;
1836	1865	void percpu = NULL, ptr = NULL; /* Stops spurious gcc warning */
...	...	@@ -2117,6 +2146,7 @@
2117	2146	markersindex = find_sec(hdr, sechdrs, secstrings, "__markers");
2118	2147	markersstringsindex = find_sec(hdr, sechdrs, secstrings,
2119	2148	"__markers_strings");
	2149	+ verboseindex = find_sec(hdr, sechdrs, secstrings, "__verbose");
2120	2150
2121	2151	/* Now do relocations. */
2122	2152	for (i = 1; i < hdr->e_shnum; i++) {
...	...	@@ -2167,6 +2197,7 @@
2167	2197	marker_update_probe_range(mod->markers,
2168	2198	mod->markers + mod->num_markers);
2169	2199	#endif
	2200	+ dynamic_printk_setup(sechdrs, verboseindex);
2170	2201	err = module_finalize(hdr, sechdrs, mod);
2171	2202	if (err < 0)
2172	2203	goto cleanup;
...	...	@@ -807,6 +807,61 @@
807	807
808	808	Say N if you are unsure.
809	809
	810	+config DYNAMIC_PRINTK_DEBUG
	811	+ bool "Enable dynamic printk() call support"
	812	+ default n
	813	+ depends on PRINTK
	814	+ select PRINTK_DEBUG
	815	+ help
	816	+
	817	+ Compiles debug level messages into the kernel, which would not
	818	+ otherwise be available at runtime. These messages can then be
	819	+ enabled/disabled on a per module basis. This mechanism implicitly
	820	+ enables all pr_debug() and dev_dbg() calls. The impact of this
	821	+ compile option is a larger kernel text size of about 2%.
	822	+
	823	+ Usage:
	824	+
	825	+ Dynamic debugging is controlled by the debugfs file,
	826	+ dynamic_printk/modules. This file contains a list of the modules that
	827	+ can be enabled. The format of the file is the module name, followed
	828	+ by a set of flags that can be enabled. The first flag is always the
	829	+ 'enabled' flag. For example:
	830	+
	831	+ <module_name> <enabled=0/1>
	832	+ .
	833	+ .
	834	+ .
	835	+
	836	+ <module_name> : Name of the module in which the debug call resides
	837	+ <enabled=0/1> : whether the messages are enabled or not
	838	+
	839	+ From a live system:
	840	+
	841	+ snd_hda_intel enabled=0
	842	+ fixup enabled=0
	843	+ driver enabled=0
	844	+
	845	+ Enable a module:
	846	+
	847	+ $echo "set enabled=1 <module_name>" > dynamic_printk/modules
	848	+
	849	+ Disable a module:
	850	+
	851	+ $echo "set enabled=0 <module_name>" > dynamic_printk/modules
	852	+
	853	+ Enable all modules:
	854	+
	855	+ $echo "set enabled=1 all" > dynamic_printk/modules
	856	+
	857	+ Disable all modules:
	858	+
	859	+ $echo "set enabled=0 all" > dynamic_printk/modules
	860	+
	861	+ Finally, passing "dynamic_printk" at the command line enables
	862	+ debugging for all modules. This mode can be turned off via the above
	863	+ disable command.
	864	+
810	865	source "samples/Kconfig"
811	866
812	867	source "lib/Kconfig.kgdb"
...	...	@@ -81,6 +81,8 @@
81	81
82	82	obj-$(CONFIG_HAVE_ARCH_TRACEHOOK) += syscall.o
83	83
	84	+obj-$(CONFIG_DYNAMIC_PRINTK_DEBUG) += dynamic_printk.o
	85	+
84	86	hostprogs-y := gen_crc32table
85	87	clean-files := crc32table.h
86	88
	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	+ return 0;
	406	+}
	407	+module_init(dynamic_printk_init);
	408	+/* may want to move this earlier so we can get traces as early as possible */
	409	+
	410	+static int __init dynamic_printk_setup(char *str)
	411	+{
	412	+ if (str)
	413	+ return -ENOENT;
	414	+ set_all(true);
	415	+ return 0;
	416	+}
	417	+/* Use early_param(), so we can get debug output as early as possible */
	418	+early_param("dynamic_printk", dynamic_printk_setup);