/* * lib/dynamic_debug.c * * make pr_debug()/dev_dbg() calls runtime configurable based upon their * source module. * * Copyright (C) 2008 Jason Baron <jbaron@redhat.com> * By Greg Banks <gnb@melbourne.sgi.com> * Copyright (c) 2008 Silicon Graphics Inc. All Rights Reserved. */ #include <linux/kernel.h> #include <linux/module.h> #include <linux/moduleparam.h> #include <linux/kallsyms.h> #include <linux/version.h> #include <linux/types.h> #include <linux/mutex.h> #include <linux/proc_fs.h> #include <linux/seq_file.h> #include <linux/list.h> #include <linux/sysctl.h> #include <linux/ctype.h> #include <linux/string.h> #include <linux/uaccess.h> #include <linux/dynamic_debug.h> #include <linux/debugfs.h> #include <linux/slab.h> extern struct _ddebug __start___verbose[]; extern struct _ddebug __stop___verbose[]; /* dynamic_debug_enabled, and dynamic_debug_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_debug_enabled; EXPORT_SYMBOL_GPL(dynamic_debug_enabled); long long dynamic_debug_enabled2; EXPORT_SYMBOL_GPL(dynamic_debug_enabled2); struct ddebug_table { struct list_head link; char *mod_name; unsigned int num_ddebugs; unsigned int num_enabled; struct _ddebug *ddebugs; }; struct ddebug_query { const char *filename; const char *module; const char *function; const char *format; unsigned int first_lineno, last_lineno; }; struct ddebug_iter { struct ddebug_table *table; unsigned int idx; }; static DEFINE_MUTEX(ddebug_lock); static LIST_HEAD(ddebug_tables); static int verbose = 0; /* Return the last part of a pathname */ static inline const char *basename(const char *path) { const char *tail = strrchr(path, '/'); return tail ? tail+1 : path; } /* format a string into buf[] which describes the _ddebug's flags */ static char *ddebug_describe_flags(struct _ddebug *dp, char *buf, size_t maxlen) { char *p = buf; BUG_ON(maxlen < 4); if (dp->flags & _DPRINTK_FLAGS_PRINT) *p++ = 'p'; if (p == buf) *p++ = '-'; *p = '\0'; return buf; } /* * must be called with ddebug_lock held */ static int disabled_hash(char hash, bool first_table) { struct ddebug_table *dt; char table_hash_value; list_for_each_entry(dt, &ddebug_tables, link) { if (first_table) table_hash_value = dt->ddebugs->primary_hash; else table_hash_value = dt->ddebugs->secondary_hash; if (dt->num_enabled && (hash == table_hash_value)) return 0; } return 1; } /* * Search the tables for _ddebug's which match the given * `query' and apply the `flags' and `mask' to them. Tells * the user which ddebug's were changed, or whether none * were matched. */ static void ddebug_change(const struct ddebug_query *query, unsigned int flags, unsigned int mask) { int i; struct ddebug_table *dt; unsigned int newflags; unsigned int nfound = 0; char flagbuf[8]; /* search for matching ddebugs */ mutex_lock(&ddebug_lock); list_for_each_entry(dt, &ddebug_tables, link) { /* match against the module name */ if (query->module != NULL && strcmp(query->module, dt->mod_name)) continue; for (i = 0 ; i < dt->num_ddebugs ; i++) { struct _ddebug *dp = &dt->ddebugs[i]; /* match against the source filename */ if (query->filename != NULL && strcmp(query->filename, dp->filename) && strcmp(query->filename, basename(dp->filename))) continue; /* match against the function */ if (query->function != NULL && strcmp(query->function, dp->function)) continue; /* match against the format */ if (query->format != NULL && strstr(dp->format, query->format) == NULL) continue; /* match against the line number range */ if (query->first_lineno && dp->lineno < query->first_lineno) continue; if (query->last_lineno && dp->lineno > query->last_lineno) continue; nfound++; newflags = (dp->flags & mask) | flags; if (newflags == dp->flags) continue; if (!newflags) dt->num_enabled--; else if (!dp->flags) dt->num_enabled++; dp->flags = newflags; if (newflags) { dynamic_debug_enabled |= (1LL << dp->primary_hash); dynamic_debug_enabled2 |= (1LL << dp->secondary_hash); } else { if (disabled_hash(dp->primary_hash, true)) dynamic_debug_enabled &= ~(1LL << dp->primary_hash); if (disabled_hash(dp->secondary_hash, false)) dynamic_debug_enabled2 &= ~(1LL << dp->secondary_hash); } if (verbose) printk(KERN_INFO "ddebug: changed %s:%d [%s]%s %s\n", dp->filename, dp->lineno, dt->mod_name, dp->function, ddebug_describe_flags(dp, flagbuf, sizeof(flagbuf))); } } mutex_unlock(&ddebug_lock); if (!nfound && verbose) printk(KERN_INFO "ddebug: no matches for query\n"); } /* * Split the buffer `buf' into space-separated words. * Handles simple " and ' quoting, i.e. without nested, * embedded or escaped \". Return the number of words * or <0 on error. */ static int ddebug_tokenize(char *buf, char *words[], int maxwords) { int nwords = 0; while (*buf) { char *end; /* Skip leading whitespace */ buf = skip_spaces(buf); if (!*buf) break; /* oh, it was trailing whitespace */ /* Run `end' over a word, either whitespace separated or quoted */ if (*buf == '"' || *buf == '\'') { int quote = *buf++; for (end = buf ; *end && *end != quote ; end++) ; if (!*end) return -EINVAL; /* unclosed quote */ } else { for (end = buf ; *end && !isspace(*end) ; end++) ; BUG_ON(end == buf); } /* Here `buf' is the start of the word, `end' is one past the end */ if (nwords == maxwords) return -EINVAL; /* ran out of words[] before bytes */ if (*end) *end++ = '\0'; /* terminate the word */ words[nwords++] = buf; buf = end; } if (verbose) { int i; printk(KERN_INFO "%s: split into words:", __func__); for (i = 0 ; i < nwords ; i++) printk(" \"%s\"", words[i]); printk("\n"); } return nwords; } /* * Parse a single line number. Note that the empty string "" * is treated as a special case and converted to zero, which * is later treated as a "don't care" value. */ static inline int parse_lineno(const char *str, unsigned int *val) { char *end = NULL; BUG_ON(str == NULL); if (*str == '\0') { *val = 0; return 0; } *val = simple_strtoul(str, &end, 10); return end == NULL || end == str || *end != '\0' ? -EINVAL : 0; } /* * Undo octal escaping in a string, inplace. This is useful to * allow the user to express a query which matches a format * containing embedded spaces. */ #define isodigit(c) ((c) >= '0' && (c) <= '7') static char *unescape(char *str) { char *in = str; char *out = str; while (*in) { if (*in == '\\') { if (in[1] == '\\') { *out++ = '\\'; in += 2; continue; } else if (in[1] == 't') { *out++ = '\t'; in += 2; continue; } else if (in[1] == 'n') { *out++ = '\n'; in += 2; continue; } else if (isodigit(in[1]) && isodigit(in[2]) && isodigit(in[3])) { *out++ = ((in[1] - '0')<<6) | ((in[2] - '0')<<3) | (in[3] - '0'); in += 4; continue; } } *out++ = *in++; } *out = '\0'; return str; } /* * Parse words[] as a ddebug query specification, which is a series * of (keyword, value) pairs chosen from these possibilities: * * func <function-name> * file <full-pathname> * file <base-filename> * module <module-name> * format <escaped-string-to-find-in-format> * line <lineno> * line <first-lineno>-<last-lineno> // where either may be empty */ static int ddebug_parse_query(char *words[], int nwords, struct ddebug_query *query) { unsigned int i; /* check we have an even number of words */ if (nwords % 2 != 0) return -EINVAL; memset(query, 0, sizeof(*query)); for (i = 0 ; i < nwords ; i += 2) { if (!strcmp(words[i], "func")) query->function = words[i+1]; else if (!strcmp(words[i], "file")) query->filename = words[i+1]; else if (!strcmp(words[i], "module")) query->module = words[i+1]; else if (!strcmp(words[i], "format")) query->format = unescape(words[i+1]); else if (!strcmp(words[i], "line")) { char *first = words[i+1]; char *last = strchr(first, '-'); if (last) *last++ = '\0'; if (parse_lineno(first, &query->first_lineno) < 0) return -EINVAL; if (last != NULL) { /* range <first>-<last> */ if (parse_lineno(last, &query->last_lineno) < 0) return -EINVAL; } else { query->last_lineno = query->first_lineno; } } else { if (verbose) printk(KERN_ERR "%s: unknown keyword \"%s\"\n", __func__, words[i]); return -EINVAL; } } if (verbose) printk(KERN_INFO "%s: q->function=\"%s\" q->filename=\"%s\" " "q->module=\"%s\" q->format=\"%s\" q->lineno=%u-%u\n", __func__, query->function, query->filename, query->module, query->format, query->first_lineno, query->last_lineno); return 0; } /* * Parse `str' as a flags specification, format [-+=][p]+. * Sets up *maskp and *flagsp to be used when changing the * flags fields of matched _ddebug's. Returns 0 on success * or <0 on error. */ static int ddebug_parse_flags(const char *str, unsigned int *flagsp, unsigned int *maskp) { unsigned flags = 0; int op = '='; switch (*str) { case '+': case '-': case '=': op = *str++; break; default: return -EINVAL; } if (verbose) printk(KERN_INFO "%s: op='%c'\n", __func__, op); for ( ; *str ; ++str) { switch (*str) { case 'p': flags |= _DPRINTK_FLAGS_PRINT; break; default: return -EINVAL; } } if (flags == 0) return -EINVAL; if (verbose) printk(KERN_INFO "%s: flags=0x%x\n", __func__, flags); /* calculate final *flagsp, *maskp according to mask and op */ switch (op) { case '=': *maskp = 0; *flagsp = flags; break; case '+': *maskp = ~0U; *flagsp = flags; break; case '-': *maskp = ~flags; *flagsp = 0; break; } if (verbose) printk(KERN_INFO "%s: *flagsp=0x%x *maskp=0x%x\n", __func__, *flagsp, *maskp); return 0; } /* * File_ops->write method for <debugfs>/dynamic_debug/conrol. Gathers the * command text from userspace, parses and executes it. */ static ssize_t ddebug_proc_write(struct file *file, const char __user *ubuf, size_t len, loff_t *offp) { unsigned int flags = 0, mask = 0; struct ddebug_query query; #define MAXWORDS 9 int nwords; char *words[MAXWORDS]; char tmpbuf[256]; if (len == 0) return 0; /* we don't check *offp -- multiple writes() are allowed */ if (len > sizeof(tmpbuf)-1) return -E2BIG; if (copy_from_user(tmpbuf, ubuf, len)) return -EFAULT; tmpbuf[len] = '\0'; if (verbose) printk(KERN_INFO "%s: read %d bytes from userspace\n", __func__, (int)len); nwords = ddebug_tokenize(tmpbuf, words, MAXWORDS); if (nwords < 0) return -EINVAL; if (ddebug_parse_query(words, nwords-1, &query)) return -EINVAL; if (ddebug_parse_flags(words[nwords-1], &flags, &mask)) return -EINVAL; /* actually go and implement the change */ ddebug_change(&query, flags, mask); *offp += len; return len; } /* * Set the iterator to point to the first _ddebug object * and return a pointer to that first object. Returns * NULL if there are no _ddebugs at all. */ static struct _ddebug *ddebug_iter_first(struct ddebug_iter *iter) { if (list_empty(&ddebug_tables)) { iter->table = NULL; iter->idx = 0; return NULL; } iter->table = list_entry(ddebug_tables.next, struct ddebug_table, link); iter->idx = 0; return &iter->table->ddebugs[iter->idx]; } /* * Advance the iterator to point to the next _ddebug * object from the one the iterator currently points at, * and returns a pointer to the new _ddebug. Returns * NULL if the iterator has seen all the _ddebugs. */ static struct _ddebug *ddebug_iter_next(struct ddebug_iter *iter) { if (iter->table == NULL) return NULL; if (++iter->idx == iter->table->num_ddebugs) { /* iterate to next table */ iter->idx = 0; if (list_is_last(&iter->table->link, &ddebug_tables)) { iter->table = NULL; return NULL; } iter->table = list_entry(iter->table->link.next, struct ddebug_table, link); } return &iter->table->ddebugs[iter->idx]; } /* * Seq_ops start method. Called at the start of every * read() call from userspace. Takes the ddebug_lock and * seeks the seq_file's iterator to the given position. */ static void *ddebug_proc_start(struct seq_file *m, loff_t *pos) { struct ddebug_iter *iter = m->private; struct _ddebug *dp; int n = *pos; if (verbose) printk(KERN_INFO "%s: called m=%p *pos=%lld\n", __func__, m, (unsigned long long)*pos); mutex_lock(&ddebug_lock); if (!n) return SEQ_START_TOKEN; if (n < 0) return NULL; dp = ddebug_iter_first(iter); while (dp != NULL && --n > 0) dp = ddebug_iter_next(iter); return dp; } /* * Seq_ops next method. Called several times within a read() * call from userspace, with ddebug_lock held. Walks to the * next _ddebug object with a special case for the header line. */ static void *ddebug_proc_next(struct seq_file *m, void *p, loff_t *pos) { struct ddebug_iter *iter = m->private; struct _ddebug *dp; if (verbose) printk(KERN_INFO "%s: called m=%p p=%p *pos=%lld\n", __func__, m, p, (unsigned long long)*pos); if (p == SEQ_START_TOKEN) dp = ddebug_iter_first(iter); else dp = ddebug_iter_next(iter); ++*pos; return dp; } /* * Seq_ops show method. Called several times within a read() * call from userspace, with ddebug_lock held. Formats the * current _ddebug as a single human-readable line, with a * special case for the header line. */ static int ddebug_proc_show(struct seq_file *m, void *p) { struct ddebug_iter *iter = m->private; struct _ddebug *dp = p; char flagsbuf[8]; if (verbose) printk(KERN_INFO "%s: called m=%p p=%p\n", __func__, m, p); if (p == SEQ_START_TOKEN) { seq_puts(m, "# filename:lineno [module]function flags format\n"); return 0; } seq_printf(m, "%s:%u [%s]%s %s \"", dp->filename, dp->lineno, iter->table->mod_name, dp->function, ddebug_describe_flags(dp, flagsbuf, sizeof(flagsbuf))); seq_escape(m, dp->format, "\t\r\n\""); seq_puts(m, "\"\n"); return 0; } /* * Seq_ops stop method. Called at the end of each read() * call from userspace. Drops ddebug_lock. */ static void ddebug_proc_stop(struct seq_file *m, void *p) { if (verbose) printk(KERN_INFO "%s: called m=%p p=%p\n", __func__, m, p); mutex_unlock(&ddebug_lock); } static const struct seq_operations ddebug_proc_seqops = { .start = ddebug_proc_start, .next = ddebug_proc_next, .show = ddebug_proc_show, .stop = ddebug_proc_stop }; /* * File_ops->open method for <debugfs>/dynamic_debug/control. Does the seq_file * setup dance, and also creates an iterator to walk the _ddebugs. * Note that we create a seq_file always, even for O_WRONLY files * where it's not needed, as doing so simplifies the ->release method. */ static int ddebug_proc_open(struct inode *inode, struct file *file) { struct ddebug_iter *iter; int err; if (verbose) printk(KERN_INFO "%s: called\n", __func__); iter = kzalloc(sizeof(*iter), GFP_KERNEL); if (iter == NULL) return -ENOMEM; err = seq_open(file, &ddebug_proc_seqops); if (err) { kfree(iter); return err; } ((struct seq_file *) file->private_data)->private = iter; return 0; } static const struct file_operations ddebug_proc_fops = { .owner = THIS_MODULE, .open = ddebug_proc_open, .read = seq_read, .llseek = seq_lseek, .release = seq_release_private, .write = ddebug_proc_write }; /* * Allocate a new ddebug_table for the given module * and add it to the global list. */ int ddebug_add_module(struct _ddebug *tab, unsigned int n, const char *name) { struct ddebug_table *dt; char *new_name; dt = kzalloc(sizeof(*dt), GFP_KERNEL); if (dt == NULL) return -ENOMEM; new_name = kstrdup(name, GFP_KERNEL); if (new_name == NULL) { kfree(dt); return -ENOMEM; } dt->mod_name = new_name; dt->num_ddebugs = n; dt->num_enabled = 0; dt->ddebugs = tab; mutex_lock(&ddebug_lock); list_add_tail(&dt->link, &ddebug_tables); mutex_unlock(&ddebug_lock); if (verbose) printk(KERN_INFO "%u debug prints in module %s\n", n, dt->mod_name); return 0; } EXPORT_SYMBOL_GPL(ddebug_add_module); static void ddebug_table_free(struct ddebug_table *dt) { list_del_init(&dt->link); kfree(dt->mod_name); kfree(dt); } /* * Called in response to a module being unloaded. Removes * any ddebug_table's which point at the module. */ int ddebug_remove_module(char *mod_name) { struct ddebug_table *dt, *nextdt; int ret = -ENOENT; if (verbose) printk(KERN_INFO "%s: removing module \"%s\"\n", __func__, mod_name); mutex_lock(&ddebug_lock); list_for_each_entry_safe(dt, nextdt, &ddebug_tables, link) { if (!strcmp(dt->mod_name, mod_name)) { ddebug_table_free(dt); ret = 0; } } mutex_unlock(&ddebug_lock); return ret; } EXPORT_SYMBOL_GPL(ddebug_remove_module); static void ddebug_remove_all_tables(void) { mutex_lock(&ddebug_lock); while (!list_empty(&ddebug_tables)) { struct ddebug_table *dt = list_entry(ddebug_tables.next, struct ddebug_table, link); ddebug_table_free(dt); } mutex_unlock(&ddebug_lock); } static int __init dynamic_debug_init(void) { struct dentry *dir, *file; struct _ddebug *iter, *iter_start; const char *modname = NULL; int ret = 0; int n = 0; dir = debugfs_create_dir("dynamic_debug", NULL); if (!dir) return -ENOMEM; file = debugfs_create_file("control", 0644, dir, NULL, &ddebug_proc_fops); if (!file) { debugfs_remove(dir); return -ENOMEM; } if (__start___verbose != __stop___verbose) { iter = __start___verbose; modname = iter->modname; iter_start = iter; for (; iter < __stop___verbose; iter++) { if (strcmp(modname, iter->modname)) { ret = ddebug_add_module(iter_start, n, modname); if (ret) goto out_free; n = 0; modname = iter->modname; iter_start = iter; } n++; } ret = ddebug_add_module(iter_start, n, modname); } out_free: if (ret) { ddebug_remove_all_tables(); debugfs_remove(dir); debugfs_remove(file); } return 0; } module_init(dynamic_debug_init);