/* * 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;Lines 1–500 of 770. Load more
/* * 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;