/* * 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 ret; } 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\n", 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\n", 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); } if (dynamic_enabled == DYNAMIC_ENABLED_ALL) set_all(true); 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; dynamic_enabled = DYNAMIC_ENABLED_ALL; return 0; } /* Use early_param(), so we can get debug output as early as possible */ early_param("dynamic_printk", dynamic_printk_setup);