lk/linux-kernel-test
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merge branch 'master' of /home/davem/src/GIT/linux-2.6/

Browse Source 
Conflicts:
	drivers/net/wimax/i2400m/usb-notif.c
This commit is contained in:
David S. Miller
2009-03-26 15:23:24 -07:00
parent f0de70f8bb 0384e29591
commit 08abe18af1
1630 changed files with 77893 additions and 47292 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
lib/Kconfig
View File

@@ -174,4 +174,10 @@ config DISABLE_OBSOLETE_CPUMASK_FUNCTIONS
bool "Disable obsolete cpumask functions" if DEBUG_PER_CPU_MAPS
depends on EXPERIMENTAL && BROKEN
#
# Netlink attribute parsing support is select'ed if needed
#
config NLATTR
bool
endmenu

74
lib/Kconfig.debug
View File

@@ -847,60 +847,70 @@ config BUILD_DOCSRC
Say N if you are unsure.
config DYNAMIC_PRINTK_DEBUG
bool "Enable dynamic printk() call support"
config DYNAMIC_DEBUG
bool "Enable dynamic printk() support"
default n
depends on PRINTK
depends on DEBUG_FS
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%.
enabled/disabled based on various levels of scope - per source file,
function, module, format string, and line number. 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:
Dynamic debugging is controlled via the 'dynamic_debug/ddebug' file,
which is contained in the 'debugfs' filesystem. Thus, the debugfs
filesystem must first be mounted before making use of this feature.
We refer the control file as: <debugfs>/dynamic_debug/ddebug. This
file contains a list of the debug statements that can be enabled. The
format for each line of the file is:
<module_name> <enabled=0/1>
.
.
.
filename:lineno [module]function flags format
<module_name> : Name of the module in which the debug call resides
<enabled=0/1> : whether the messages are enabled or not
filename : source file of the debug statement
lineno : line number of the debug statement
module : module that contains the debug statement
function : function that contains the debug statement
flags : 'p' means the line is turned 'on' for printing
format : the format used for the debug statement
From a live system:
snd_hda_intel enabled=0
fixup enabled=0
driver enabled=0
nullarbor:~ # cat <debugfs>/dynamic_debug/ddebug
# filename:lineno [module]function flags format
fs/aio.c:222 [aio]__put_ioctx - "__put_ioctx:\040freeing\040%p\012"
fs/aio.c:248 [aio]ioctx_alloc - "ENOMEM:\040nr_events\040too\040high\012"
fs/aio.c:1770 [aio]sys_io_cancel - "calling\040cancel\012"
Enable a module:
Example usage:
$echo "set enabled=1 <module_name>" > dynamic_printk/modules
// enable the message at line 1603 of file svcsock.c
nullarbor:~ # echo -n 'file svcsock.c line 1603 +p' >
<debugfs>/dynamic_debug/ddebug
Disable a module:
// enable all the messages in file svcsock.c
nullarbor:~ # echo -n 'file svcsock.c +p' >
<debugfs>/dynamic_debug/ddebug
$echo "set enabled=0 <module_name>" > dynamic_printk/modules
// enable all the messages in the NFS server module
nullarbor:~ # echo -n 'module nfsd +p' >
<debugfs>/dynamic_debug/ddebug
Enable all modules:
// enable all 12 messages in the function svc_process()
nullarbor:~ # echo -n 'func svc_process +p' >
<debugfs>/dynamic_debug/ddebug
$echo "set enabled=1 all" > dynamic_printk/modules
// disable all 12 messages in the function svc_process()
nullarbor:~ # echo -n 'func svc_process -p' >
<debugfs>/dynamic_debug/ddebug
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.
See Documentation/dynamic-debug-howto.txt for additional information.
source "samples/Kconfig"

4
lib/Makefile
View File

@@ -82,7 +82,9 @@ obj-$(CONFIG_HAVE_LMB) += lmb.o
obj-$(CONFIG_HAVE_ARCH_TRACEHOOK) += syscall.o
obj-$(CONFIG_DYNAMIC_PRINTK_DEBUG) += dynamic_printk.o
obj-$(CONFIG_DYNAMIC_DEBUG) += dynamic_debug.o
obj-$(CONFIG_NLATTR) += nlattr.o
hostprogs-y := gen_crc32table
clean-files := crc32table.h

16
lib/bitmap.c
View File

@@ -948,15 +948,15 @@ done:
*/
int bitmap_find_free_region(unsigned long *bitmap, int bits, int order)
{
int pos; /* scans bitmap by regions of size order */
int pos, end; /* scans bitmap by regions of size order */
for (pos = 0; pos < bits; pos += (1 << order))
if (__reg_op(bitmap, pos, order, REG_OP_ISFREE))
break;
if (pos == bits)
return -ENOMEM;
__reg_op(bitmap, pos, order, REG_OP_ALLOC);
return pos;
for (pos = 0 ; (end = pos + (1 << order)) <= bits; pos = end) {
if (!__reg_op(bitmap, pos, order, REG_OP_ISFREE))
continue;
__reg_op(bitmap, pos, order, REG_OP_ALLOC);
return pos;
}
return -ENOMEM;
}
EXPORT_SYMBOL(bitmap_find_free_region);

769
lib/dynamic_debug.c Normal file
View File

@@ -0,0 +1,769 @@
/*
* 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/uaccess.h>
#include <linux/dynamic_debug.h>
#include <linux/debugfs.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 */
while (*buf && isspace(*buf))
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);

414
lib/dynamic_printk.c
View File

@@ -1,414 +0,0 @@
/*
* 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);

2
lib/idr.c
View File

@@ -449,6 +449,7 @@ void idr_remove_all(struct idr *idp)
n = idp->layers * IDR_BITS;
p = idp->top;
rcu_assign_pointer(idp->top, NULL);
max = 1 << n;
id = 0;
@@ -467,7 +468,6 @@ void idr_remove_all(struct idr *idp)
p = *--paa;
}
}
rcu_assign_pointer(idp->top, NULL);
idp->layers = 0;
}
EXPORT_SYMBOL(idr_remove_all);

2
lib/kobject.c
View File

@@ -212,7 +212,7 @@ static int kobject_add_internal(struct kobject *kobj)
* @fmt: format string used to build the name
* @vargs: vargs to format the string.
*/
static int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
va_list vargs)
{
const char *old_name = kobj->name;

9
lib/kobject_uevent.c
View File

@@ -118,6 +118,13 @@ int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
kset = top_kobj->kset;
uevent_ops = kset->uevent_ops;
/* skip the event, if uevent_suppress is set*/
if (kobj->uevent_suppress) {
pr_debug("kobject: '%s' (%p): %s: uevent_suppress "
"caused the event to drop!\n",
kobject_name(kobj), kobj, __func__);
return 0;
}
/* skip the event, if the filter returns zero. */
if (uevent_ops && uevent_ops->filter)
if (!uevent_ops->filter(kset, kobj)) {
@@ -251,7 +258,7 @@ int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
goto exit;
retval = call_usermodehelper(argv[0], argv,
env->envp, UMH_WAIT_EXEC);
env->envp, UMH_NO_WAIT);
}
exit:

475
lib/nlattr.c Normal file
View File

@@ -0,0 +1,475 @@
/*
* NETLINK Netlink attributes
*
* Authors: Thomas Graf <tgraf@suug.ch>
* Alexey Kuznetsov <kuznet@ms2.inr.ac.ru>
*/
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/errno.h>
#include <linux/jiffies.h>
#include <linux/netdevice.h>
#include <linux/skbuff.h>
#include <linux/string.h>
#include <linux/types.h>
#include <net/netlink.h>
static u16 nla_attr_minlen[NLA_TYPE_MAX+1] __read_mostly = {
[NLA_U8] = sizeof(u8),
[NLA_U16] = sizeof(u16),
[NLA_U32] = sizeof(u32),
[NLA_U64] = sizeof(u64),
[NLA_NESTED] = NLA_HDRLEN,
};
static int validate_nla(struct nlattr *nla, int maxtype,
const struct nla_policy *policy)
{
const struct nla_policy *pt;
int minlen = 0, attrlen = nla_len(nla), type = nla_type(nla);
if (type <= 0 || type > maxtype)
return 0;
pt = &policy[type];
BUG_ON(pt->type > NLA_TYPE_MAX);
switch (pt->type) {
case NLA_FLAG:
if (attrlen > 0)
return -ERANGE;
break;
case NLA_NUL_STRING:
if (pt->len)
minlen = min_t(int, attrlen, pt->len + 1);
else
minlen = attrlen;
if (!minlen || memchr(nla_data(nla), '\0', minlen) == NULL)
return -EINVAL;
/* fall through */
case NLA_STRING:
if (attrlen < 1)
return -ERANGE;
if (pt->len) {
char *buf = nla_data(nla);
if (buf[attrlen - 1] == '\0')
attrlen--;
if (attrlen > pt->len)
return -ERANGE;
}
break;
case NLA_BINARY:
if (pt->len && attrlen > pt->len)
return -ERANGE;
break;
case NLA_NESTED_COMPAT:
if (attrlen < pt->len)
return -ERANGE;
if (attrlen < NLA_ALIGN(pt->len))
break;
if (attrlen < NLA_ALIGN(pt->len) + NLA_HDRLEN)
return -ERANGE;
nla = nla_data(nla) + NLA_ALIGN(pt->len);
if (attrlen < NLA_ALIGN(pt->len) + NLA_HDRLEN + nla_len(nla))
return -ERANGE;
break;
case NLA_NESTED:
/* a nested attributes is allowed to be empty; if its not,
* it must have a size of at least NLA_HDRLEN.
*/
if (attrlen == 0)
break;
default:
if (pt->len)
minlen = pt->len;
else if (pt->type != NLA_UNSPEC)
minlen = nla_attr_minlen[pt->type];
if (attrlen < minlen)
return -ERANGE;
}
return 0;
}
/**
* nla_validate - Validate a stream of attributes
* @head: head of attribute stream
* @len: length of attribute stream
* @maxtype: maximum attribute type to be expected
* @policy: validation policy
*
* Validates all attributes in the specified attribute stream against the
* specified policy. Attributes with a type exceeding maxtype will be
* ignored. See documenation of struct nla_policy for more details.
*
* Returns 0 on success or a negative error code.
*/
int nla_validate(struct nlattr *head, int len, int maxtype,
const struct nla_policy *policy)
{
struct nlattr *nla;
int rem, err;
nla_for_each_attr(nla, head, len, rem) {
err = validate_nla(nla, maxtype, policy);
if (err < 0)
goto errout;
}
err = 0;
errout:
return err;
}
/**
* nla_parse - Parse a stream of attributes into a tb buffer
* @tb: destination array with maxtype+1 elements
* @maxtype: maximum attribute type to be expected
* @head: head of attribute stream
* @len: length of attribute stream
* @policy: validation policy
*
* Parses a stream of attributes and stores a pointer to each attribute in
* the tb array accessable via the attribute type. Attributes with a type
* exceeding maxtype will be silently ignored for backwards compatibility
* reasons. policy may be set to NULL if no validation is required.
*
* Returns 0 on success or a negative error code.
*/
int nla_parse(struct nlattr *tb[], int maxtype, struct nlattr *head, int len,
const struct nla_policy *policy)
{
struct nlattr *nla;
int rem, err;
memset(tb, 0, sizeof(struct nlattr *) * (maxtype + 1));
nla_for_each_attr(nla, head, len, rem) {
u16 type = nla_type(nla);
if (type > 0 && type <= maxtype) {
if (policy) {
err = validate_nla(nla, maxtype, policy);
if (err < 0)
goto errout;
}
tb[type] = nla;
}
}
if (unlikely(rem > 0))
printk(KERN_WARNING "netlink: %d bytes leftover after parsing "
"attributes.\n", rem);
err = 0;
errout:
return err;
}
/**
* nla_find - Find a specific attribute in a stream of attributes
* @head: head of attribute stream
* @len: length of attribute stream
* @attrtype: type of attribute to look for
*
* Returns the first attribute in the stream matching the specified type.
*/
struct nlattr *nla_find(struct nlattr *head, int len, int attrtype)
{
struct nlattr *nla;
int rem;
nla_for_each_attr(nla, head, len, rem)
if (nla_type(nla) == attrtype)
return nla;
return NULL;
}
/**
* nla_strlcpy - Copy string attribute payload into a sized buffer
* @dst: where to copy the string to
* @nla: attribute to copy the string from
* @dstsize: size of destination buffer
*
* Copies at most dstsize - 1 bytes into the destination buffer.
* The result is always a valid NUL-terminated string. Unlike
* strlcpy the destination buffer is always padded out.
*
* Returns the length of the source buffer.
*/
size_t nla_strlcpy(char *dst, const struct nlattr *nla, size_t dstsize)
{
size_t srclen = nla_len(nla);
char *src = nla_data(nla);
if (srclen > 0 && src[srclen - 1] == '\0')
srclen--;
if (dstsize > 0) {
size_t len = (srclen >= dstsize) ? dstsize - 1 : srclen;
memset(dst, 0, dstsize);
memcpy(dst, src, len);
}
return srclen;
}
/**
* nla_memcpy - Copy a netlink attribute into another memory area
* @dest: where to copy to memcpy
* @src: netlink attribute to copy from
* @count: size of the destination area
*
* Note: The number of bytes copied is limited by the length of
* attribute's payload. memcpy
*
* Returns the number of bytes copied.
*/
int nla_memcpy(void *dest, const struct nlattr *src, int count)
{
int minlen = min_t(int, count, nla_len(src));
memcpy(dest, nla_data(src), minlen);
return minlen;
}
/**
* nla_memcmp - Compare an attribute with sized memory area
* @nla: netlink attribute
* @data: memory area
* @size: size of memory area
*/
int nla_memcmp(const struct nlattr *nla, const void *data,
size_t size)
{
int d = nla_len(nla) - size;
if (d == 0)
d = memcmp(nla_data(nla), data, size);
return d;
}
/**
* nla_strcmp - Compare a string attribute against a string
* @nla: netlink string attribute
* @str: another string
*/
int nla_strcmp(const struct nlattr *nla, const char *str)
{
int len = strlen(str) + 1;
int d = nla_len(nla) - len;
if (d == 0)
d = memcmp(nla_data(nla), str, len);
return d;
}
#ifdef CONFIG_NET
/**
* __nla_reserve - reserve room for attribute on the skb
* @skb: socket buffer to reserve room on
* @attrtype: attribute type
* @attrlen: length of attribute payload
*
* Adds a netlink attribute header to a socket buffer and reserves
* room for the payload but does not copy it.
*
* The caller is responsible to ensure that the skb provides enough
* tailroom for the attribute header and payload.
*/
struct nlattr *__nla_reserve(struct sk_buff *skb, int attrtype, int attrlen)
{
struct nlattr *nla;
nla = (struct nlattr *) skb_put(skb, nla_total_size(attrlen));
nla->nla_type = attrtype;
nla->nla_len = nla_attr_size(attrlen);
memset((unsigned char *) nla + nla->nla_len, 0, nla_padlen(attrlen));
return nla;
}
EXPORT_SYMBOL(__nla_reserve);
/**
* __nla_reserve_nohdr - reserve room for attribute without header
* @skb: socket buffer to reserve room on
* @attrlen: length of attribute payload
*
* Reserves room for attribute payload without a header.
*
* The caller is responsible to ensure that the skb provides enough
* tailroom for the payload.
*/
void *__nla_reserve_nohdr(struct sk_buff *skb, int attrlen)
{
void *start;
start = skb_put(skb, NLA_ALIGN(attrlen));
memset(start, 0, NLA_ALIGN(attrlen));
return start;
}
EXPORT_SYMBOL(__nla_reserve_nohdr);
/**
* nla_reserve - reserve room for attribute on the skb
* @skb: socket buffer to reserve room on
* @attrtype: attribute type
* @attrlen: length of attribute payload
*
* Adds a netlink attribute header to a socket buffer and reserves
* room for the payload but does not copy it.
*
* Returns NULL if the tailroom of the skb is insufficient to store
* the attribute header and payload.
*/
struct nlattr *nla_reserve(struct sk_buff *skb, int attrtype, int attrlen)
{
if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
return NULL;
return __nla_reserve(skb, attrtype, attrlen);
}
EXPORT_SYMBOL(nla_reserve);
/**
* nla_reserve_nohdr - reserve room for attribute without header
* @skb: socket buffer to reserve room on
* @attrlen: length of attribute payload
*
* Reserves room for attribute payload without a header.
*
* Returns NULL if the tailroom of the skb is insufficient to store
* the attribute payload.
*/
void *nla_reserve_nohdr(struct sk_buff *skb, int attrlen)
{
if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
return NULL;
return __nla_reserve_nohdr(skb, attrlen);
}
EXPORT_SYMBOL(nla_reserve_nohdr);
/**
* __nla_put - Add a netlink attribute to a socket buffer
* @skb: socket buffer to add attribute to
* @attrtype: attribute type
* @attrlen: length of attribute payload
* @data: head of attribute payload
*
* The caller is responsible to ensure that the skb provides enough
* tailroom for the attribute header and payload.
*/
void __nla_put(struct sk_buff *skb, int attrtype, int attrlen,
const void *data)
{
struct nlattr *nla;
nla = __nla_reserve(skb, attrtype, attrlen);
memcpy(nla_data(nla), data, attrlen);
}
EXPORT_SYMBOL(__nla_put);
/**
* __nla_put_nohdr - Add a netlink attribute without header
* @skb: socket buffer to add attribute to
* @attrlen: length of attribute payload
* @data: head of attribute payload
*
* The caller is responsible to ensure that the skb provides enough
* tailroom for the attribute payload.
*/
void __nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
{
void *start;
start = __nla_reserve_nohdr(skb, attrlen);
memcpy(start, data, attrlen);
}
EXPORT_SYMBOL(__nla_put_nohdr);
/**
* nla_put - Add a netlink attribute to a socket buffer
* @skb: socket buffer to add attribute to
* @attrtype: attribute type
* @attrlen: length of attribute payload
* @data: head of attribute payload
*
* Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
* the attribute header and payload.
*/
int nla_put(struct sk_buff *skb, int attrtype, int attrlen, const void *data)
{
if (unlikely(skb_tailroom(skb) < nla_total_size(attrlen)))
return -EMSGSIZE;
__nla_put(skb, attrtype, attrlen, data);
return 0;
}
EXPORT_SYMBOL(nla_put);
/**
* nla_put_nohdr - Add a netlink attribute without header
* @skb: socket buffer to add attribute to
* @attrlen: length of attribute payload
* @data: head of attribute payload
*
* Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
* the attribute payload.
*/
int nla_put_nohdr(struct sk_buff *skb, int attrlen, const void *data)
{
if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
return -EMSGSIZE;
__nla_put_nohdr(skb, attrlen, data);
return 0;
}
EXPORT_SYMBOL(nla_put_nohdr);
/**
* nla_append - Add a netlink attribute without header or padding
* @skb: socket buffer to add attribute to
* @attrlen: length of attribute payload
* @data: head of attribute payload
*
* Returns -EMSGSIZE if the tailroom of the skb is insufficient to store
* the attribute payload.
*/
int nla_append(struct sk_buff *skb, int attrlen, const void *data)
{
if (unlikely(skb_tailroom(skb) < NLA_ALIGN(attrlen)))
return -EMSGSIZE;
memcpy(skb_put(skb, attrlen), data, attrlen);
return 0;
}
EXPORT_SYMBOL(nla_append);
#endif
EXPORT_SYMBOL(nla_validate);
EXPORT_SYMBOL(nla_parse);
EXPORT_SYMBOL(nla_find);
EXPORT_SYMBOL(nla_strlcpy);
EXPORT_SYMBOL(nla_memcpy);
EXPORT_SYMBOL(nla_memcmp);
EXPORT_SYMBOL(nla_strcmp);