2005-04-16 22:20:36 +00:00
|
|
|
#ifndef _LINUX_MODULE_H
|
|
|
|
#define _LINUX_MODULE_H
|
|
|
|
/*
|
|
|
|
* Dynamic loading of modules into the kernel.
|
|
|
|
*
|
|
|
|
* Rewritten by Richard Henderson <rth@tamu.edu> Dec 1996
|
|
|
|
* Rewritten again by Rusty Russell, 2002
|
|
|
|
*/
|
|
|
|
#include <linux/list.h>
|
|
|
|
#include <linux/stat.h>
|
|
|
|
#include <linux/compiler.h>
|
|
|
|
#include <linux/cache.h>
|
|
|
|
#include <linux/kmod.h>
|
|
|
|
#include <linux/elf.h>
|
|
|
|
#include <linux/stringify.h>
|
|
|
|
#include <linux/kobject.h>
|
|
|
|
#include <linux/moduleparam.h>
|
2007-10-19 06:41:06 +00:00
|
|
|
#include <linux/marker.h>
|
2005-04-16 22:20:36 +00:00
|
|
|
#include <asm/local.h>
|
|
|
|
|
|
|
|
#include <asm/module.h>
|
|
|
|
|
|
|
|
/* Not Yet Implemented */
|
|
|
|
#define MODULE_SUPPORTED_DEVICE(name)
|
|
|
|
|
|
|
|
/* v850 toolchain uses a `_' prefix for all user symbols */
|
|
|
|
#ifndef MODULE_SYMBOL_PREFIX
|
|
|
|
#define MODULE_SYMBOL_PREFIX ""
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#define MODULE_NAME_LEN (64 - sizeof(unsigned long))
|
|
|
|
|
|
|
|
struct kernel_symbol
|
|
|
|
{
|
|
|
|
unsigned long value;
|
|
|
|
const char *name;
|
|
|
|
};
|
|
|
|
|
|
|
|
struct modversion_info
|
|
|
|
{
|
|
|
|
unsigned long crc;
|
|
|
|
char name[MODULE_NAME_LEN];
|
|
|
|
};
|
|
|
|
|
|
|
|
struct module;
|
|
|
|
|
|
|
|
struct module_attribute {
|
|
|
|
struct attribute attr;
|
|
|
|
ssize_t (*show)(struct module_attribute *, struct module *, char *);
|
|
|
|
ssize_t (*store)(struct module_attribute *, struct module *,
|
|
|
|
const char *, size_t count);
|
[PATCH] modules: add version and srcversion to sysfs
This patch adds version and srcversion files to
/sys/module/${modulename} containing the version and srcversion fields
of the module's modinfo section (if present).
/sys/module/e1000
|-- srcversion
`-- version
This patch differs slightly from the version posted in January, as it
now uses the new kstrdup() call in -mm.
Why put this in sysfs?
a) Tools like DKMS, which deal with changing out individual kernel
modules without replacing the whole kernel, can behave smarter if they
can tell the version of a given module. The autoinstaller feature, for
example, which determines if your system has a "good" version of a
driver (i.e. if the one provided by DKMS has a newer verson than that
provided by the kernel package installed), and to automatically compile
and install a newer version if DKMS has it but your kernel doesn't yet
have that version.
b) Because sysadmins manually, or with tools like DKMS, can switch out
modules on the file system, you can't count on 'modinfo foo.ko', which
looks at /lib/modules/${kernelver}/... actually matching what is loaded
into the kernel already. Hence asking sysfs for this.
c) as the unbind-driver-from-device work takes shape, it will be
possible to rebind a driver that's built-in (no .ko to modinfo for the
version) to a newly loaded module. sysfs will have the
currently-built-in version info, for comparison.
d) tech support scripts can then easily grab the version info for what's
running presently - a question I get often.
There has been renewed interest in this patch on linux-scsi by driver
authors.
As the idea originated from GregKH, I leave his Signed-off-by: intact,
though the implementation is nearly completely new. Compiled and run on
x86 and x86_64.
From: Matthew Dobson <colpatch@us.ibm.com>
build fix
From: Thierry Vignaud <tvignaud@mandriva.com>
build fix
From: Matthew Dobson <colpatch@us.ibm.com>
warning fix
Signed-off-by: Greg Kroah-Hartman <greg@kroah.com>
Signed-off-by: Matt Domsch <Matt_Domsch@dell.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-24 05:05:15 +00:00
|
|
|
void (*setup)(struct module *, const char *);
|
|
|
|
int (*test)(struct module *);
|
|
|
|
void (*free)(struct module *);
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
struct module_kobject
|
|
|
|
{
|
|
|
|
struct kobject kobj;
|
|
|
|
struct module *mod;
|
2007-01-15 19:22:02 +00:00
|
|
|
struct kobject *drivers_dir;
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
|
|
|
|
|
|
|
/* These are either module local, or the kernel's dummy ones. */
|
|
|
|
extern int init_module(void);
|
|
|
|
extern void cleanup_module(void);
|
|
|
|
|
|
|
|
/* Archs provide a method of finding the correct exception table. */
|
|
|
|
struct exception_table_entry;
|
|
|
|
|
|
|
|
const struct exception_table_entry *
|
|
|
|
search_extable(const struct exception_table_entry *first,
|
|
|
|
const struct exception_table_entry *last,
|
|
|
|
unsigned long value);
|
|
|
|
void sort_extable(struct exception_table_entry *start,
|
|
|
|
struct exception_table_entry *finish);
|
|
|
|
void sort_main_extable(void);
|
|
|
|
|
|
|
|
#ifdef MODULE
|
|
|
|
#define MODULE_GENERIC_TABLE(gtype,name) \
|
|
|
|
extern const struct gtype##_id __mod_##gtype##_table \
|
|
|
|
__attribute__ ((unused, alias(__stringify(name))))
|
|
|
|
|
|
|
|
extern struct module __this_module;
|
|
|
|
#define THIS_MODULE (&__this_module)
|
|
|
|
#else /* !MODULE */
|
|
|
|
#define MODULE_GENERIC_TABLE(gtype,name)
|
|
|
|
#define THIS_MODULE ((struct module *)0)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Generic info of form tag = "info" */
|
|
|
|
#define MODULE_INFO(tag, info) __MODULE_INFO(tag, tag, info)
|
|
|
|
|
|
|
|
/* For userspace: you can also call me... */
|
|
|
|
#define MODULE_ALIAS(_alias) MODULE_INFO(alias, _alias)
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The following license idents are currently accepted as indicating free
|
|
|
|
* software modules
|
|
|
|
*
|
|
|
|
* "GPL" [GNU Public License v2 or later]
|
|
|
|
* "GPL v2" [GNU Public License v2]
|
|
|
|
* "GPL and additional rights" [GNU Public License v2 rights and more]
|
|
|
|
* "Dual BSD/GPL" [GNU Public License v2
|
|
|
|
* or BSD license choice]
|
2006-06-23 09:05:13 +00:00
|
|
|
* "Dual MIT/GPL" [GNU Public License v2
|
|
|
|
* or MIT license choice]
|
2005-04-16 22:20:36 +00:00
|
|
|
* "Dual MPL/GPL" [GNU Public License v2
|
|
|
|
* or Mozilla license choice]
|
|
|
|
*
|
|
|
|
* The following other idents are available
|
|
|
|
*
|
|
|
|
* "Proprietary" [Non free products]
|
|
|
|
*
|
|
|
|
* There are dual licensed components, but when running with Linux it is the
|
|
|
|
* GPL that is relevant so this is a non issue. Similarly LGPL linked with GPL
|
|
|
|
* is a GPL combined work.
|
|
|
|
*
|
|
|
|
* This exists for several reasons
|
|
|
|
* 1. So modinfo can show license info for users wanting to vet their setup
|
|
|
|
* is free
|
|
|
|
* 2. So the community can ignore bug reports including proprietary modules
|
|
|
|
* 3. So vendors can do likewise based on their own policies
|
|
|
|
*/
|
|
|
|
#define MODULE_LICENSE(_license) MODULE_INFO(license, _license)
|
|
|
|
|
2007-05-11 05:22:50 +00:00
|
|
|
/* Author, ideally of form NAME[, NAME]*[ and NAME] */
|
2005-04-16 22:20:36 +00:00
|
|
|
#define MODULE_AUTHOR(_author) MODULE_INFO(author, _author)
|
|
|
|
|
|
|
|
/* What your module does. */
|
|
|
|
#define MODULE_DESCRIPTION(_description) MODULE_INFO(description, _description)
|
|
|
|
|
|
|
|
/* One for each parameter, describing how to use it. Some files do
|
|
|
|
multiple of these per line, so can't just use MODULE_INFO. */
|
|
|
|
#define MODULE_PARM_DESC(_parm, desc) \
|
|
|
|
__MODULE_INFO(parm, _parm, #_parm ":" desc)
|
|
|
|
|
|
|
|
#define MODULE_DEVICE_TABLE(type,name) \
|
|
|
|
MODULE_GENERIC_TABLE(type##_device,name)
|
|
|
|
|
|
|
|
/* Version of form [<epoch>:]<version>[-<extra-version>].
|
|
|
|
Or for CVS/RCS ID version, everything but the number is stripped.
|
|
|
|
<epoch>: A (small) unsigned integer which allows you to start versions
|
|
|
|
anew. If not mentioned, it's zero. eg. "2:1.0" is after
|
|
|
|
"1:2.0".
|
|
|
|
<version>: The <version> may contain only alphanumerics and the
|
|
|
|
character `.'. Ordered by numeric sort for numeric parts,
|
|
|
|
ascii sort for ascii parts (as per RPM or DEB algorithm).
|
|
|
|
<extraversion>: Like <version>, but inserted for local
|
|
|
|
customizations, eg "rh3" or "rusty1".
|
|
|
|
|
|
|
|
Using this automatically adds a checksum of the .c files and the
|
|
|
|
local headers in "srcversion".
|
|
|
|
*/
|
|
|
|
#define MODULE_VERSION(_version) MODULE_INFO(version, _version)
|
|
|
|
|
2006-08-28 22:08:21 +00:00
|
|
|
/* Optional firmware file (or files) needed by the module
|
|
|
|
* format is simply firmware file name. Multiple firmware
|
|
|
|
* files require multiple MODULE_FIRMWARE() specifiers */
|
|
|
|
#define MODULE_FIRMWARE(_firmware) MODULE_INFO(firmware, _firmware)
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Given an address, look for it in the exception tables */
|
|
|
|
const struct exception_table_entry *search_exception_tables(unsigned long add);
|
|
|
|
|
|
|
|
struct notifier_block;
|
|
|
|
|
|
|
|
#ifdef CONFIG_MODULES
|
|
|
|
|
|
|
|
/* Get/put a kernel symbol (calls must be symmetric) */
|
|
|
|
void *__symbol_get(const char *symbol);
|
|
|
|
void *__symbol_get_gpl(const char *symbol);
|
|
|
|
#define symbol_get(x) ((typeof(&x))(__symbol_get(MODULE_SYMBOL_PREFIX #x)))
|
|
|
|
|
|
|
|
#ifndef __GENKSYMS__
|
|
|
|
#ifdef CONFIG_MODVERSIONS
|
|
|
|
/* Mark the CRC weak since genksyms apparently decides not to
|
|
|
|
* generate a checksums for some symbols */
|
|
|
|
#define __CRC_SYMBOL(sym, sec) \
|
|
|
|
extern void *__crc_##sym __attribute__((weak)); \
|
|
|
|
static const unsigned long __kcrctab_##sym \
|
2008-01-24 21:16:20 +00:00
|
|
|
__used \
|
2005-04-16 22:20:36 +00:00
|
|
|
__attribute__((section("__kcrctab" sec), unused)) \
|
|
|
|
= (unsigned long) &__crc_##sym;
|
|
|
|
#else
|
|
|
|
#define __CRC_SYMBOL(sym, sec)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* For every exported symbol, place a struct in the __ksymtab section */
|
|
|
|
#define __EXPORT_SYMBOL(sym, sec) \
|
2006-03-24 06:07:34 +00:00
|
|
|
extern typeof(sym) sym; \
|
2005-04-16 22:20:36 +00:00
|
|
|
__CRC_SYMBOL(sym, sec) \
|
|
|
|
static const char __kstrtab_##sym[] \
|
2008-03-13 09:02:17 +00:00
|
|
|
__attribute__((section("__ksymtab_strings"), aligned(1))) \
|
2005-04-16 22:20:36 +00:00
|
|
|
= MODULE_SYMBOL_PREFIX #sym; \
|
|
|
|
static const struct kernel_symbol __ksymtab_##sym \
|
2008-01-24 21:16:20 +00:00
|
|
|
__used \
|
2005-04-16 22:20:36 +00:00
|
|
|
__attribute__((section("__ksymtab" sec), unused)) \
|
|
|
|
= { (unsigned long)&sym, __kstrtab_##sym }
|
|
|
|
|
|
|
|
#define EXPORT_SYMBOL(sym) \
|
|
|
|
__EXPORT_SYMBOL(sym, "")
|
|
|
|
|
|
|
|
#define EXPORT_SYMBOL_GPL(sym) \
|
|
|
|
__EXPORT_SYMBOL(sym, "_gpl")
|
|
|
|
|
2006-03-20 21:17:13 +00:00
|
|
|
#define EXPORT_SYMBOL_GPL_FUTURE(sym) \
|
|
|
|
__EXPORT_SYMBOL(sym, "_gpl_future")
|
|
|
|
|
2006-06-28 11:26:45 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_UNUSED_SYMBOLS
|
|
|
|
#define EXPORT_UNUSED_SYMBOL(sym) __EXPORT_SYMBOL(sym, "_unused")
|
|
|
|
#define EXPORT_UNUSED_SYMBOL_GPL(sym) __EXPORT_SYMBOL(sym, "_unused_gpl")
|
|
|
|
#else
|
|
|
|
#define EXPORT_UNUSED_SYMBOL(sym)
|
|
|
|
#define EXPORT_UNUSED_SYMBOL_GPL(sym)
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
struct module_ref
|
|
|
|
{
|
|
|
|
local_t count;
|
|
|
|
} ____cacheline_aligned;
|
|
|
|
|
|
|
|
enum module_state
|
|
|
|
{
|
|
|
|
MODULE_STATE_LIVE,
|
|
|
|
MODULE_STATE_COMING,
|
|
|
|
MODULE_STATE_GOING,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct module
|
|
|
|
{
|
|
|
|
enum module_state state;
|
|
|
|
|
|
|
|
/* Member of list of modules */
|
|
|
|
struct list_head list;
|
|
|
|
|
|
|
|
/* Unique handle for this module */
|
|
|
|
char name[MODULE_NAME_LEN];
|
|
|
|
|
|
|
|
/* Sysfs stuff. */
|
|
|
|
struct module_kobject mkobj;
|
|
|
|
struct module_param_attrs *param_attrs;
|
2006-02-16 21:50:23 +00:00
|
|
|
struct module_attribute *modinfo_attrs;
|
[PATCH] modules: add version and srcversion to sysfs
This patch adds version and srcversion files to
/sys/module/${modulename} containing the version and srcversion fields
of the module's modinfo section (if present).
/sys/module/e1000
|-- srcversion
`-- version
This patch differs slightly from the version posted in January, as it
now uses the new kstrdup() call in -mm.
Why put this in sysfs?
a) Tools like DKMS, which deal with changing out individual kernel
modules without replacing the whole kernel, can behave smarter if they
can tell the version of a given module. The autoinstaller feature, for
example, which determines if your system has a "good" version of a
driver (i.e. if the one provided by DKMS has a newer verson than that
provided by the kernel package installed), and to automatically compile
and install a newer version if DKMS has it but your kernel doesn't yet
have that version.
b) Because sysadmins manually, or with tools like DKMS, can switch out
modules on the file system, you can't count on 'modinfo foo.ko', which
looks at /lib/modules/${kernelver}/... actually matching what is loaded
into the kernel already. Hence asking sysfs for this.
c) as the unbind-driver-from-device work takes shape, it will be
possible to rebind a driver that's built-in (no .ko to modinfo for the
version) to a newly loaded module. sysfs will have the
currently-built-in version info, for comparison.
d) tech support scripts can then easily grab the version info for what's
running presently - a question I get often.
There has been renewed interest in this patch on linux-scsi by driver
authors.
As the idea originated from GregKH, I leave his Signed-off-by: intact,
though the implementation is nearly completely new. Compiled and run on
x86 and x86_64.
From: Matthew Dobson <colpatch@us.ibm.com>
build fix
From: Thierry Vignaud <tvignaud@mandriva.com>
build fix
From: Matthew Dobson <colpatch@us.ibm.com>
warning fix
Signed-off-by: Greg Kroah-Hartman <greg@kroah.com>
Signed-off-by: Matt Domsch <Matt_Domsch@dell.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2005-06-24 05:05:15 +00:00
|
|
|
const char *version;
|
|
|
|
const char *srcversion;
|
2007-01-18 12:26:15 +00:00
|
|
|
struct kobject *holders_dir;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Exported symbols */
|
|
|
|
const struct kernel_symbol *syms;
|
|
|
|
const unsigned long *crcs;
|
2008-07-23 00:24:26 +00:00
|
|
|
unsigned int num_syms;
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* GPL-only exported symbols. */
|
|
|
|
unsigned int num_gpl_syms;
|
2008-07-23 00:24:26 +00:00
|
|
|
const struct kernel_symbol *gpl_syms;
|
2005-04-16 22:20:36 +00:00
|
|
|
const unsigned long *gpl_crcs;
|
|
|
|
|
2008-07-23 00:24:26 +00:00
|
|
|
#ifdef CONFIG_UNUSED_SYMBOLS
|
2006-06-28 11:26:45 +00:00
|
|
|
/* unused exported symbols. */
|
|
|
|
const struct kernel_symbol *unused_syms;
|
|
|
|
const unsigned long *unused_crcs;
|
2008-07-23 00:24:26 +00:00
|
|
|
unsigned int num_unused_syms;
|
|
|
|
|
2006-06-28 11:26:45 +00:00
|
|
|
/* GPL-only, unused exported symbols. */
|
|
|
|
unsigned int num_unused_gpl_syms;
|
2008-07-23 00:24:26 +00:00
|
|
|
const struct kernel_symbol *unused_gpl_syms;
|
2006-06-28 11:26:45 +00:00
|
|
|
const unsigned long *unused_gpl_crcs;
|
2008-07-23 00:24:26 +00:00
|
|
|
#endif
|
2006-06-28 11:26:45 +00:00
|
|
|
|
2006-03-20 21:17:13 +00:00
|
|
|
/* symbols that will be GPL-only in the near future. */
|
|
|
|
const struct kernel_symbol *gpl_future_syms;
|
|
|
|
const unsigned long *gpl_future_crcs;
|
2008-07-23 00:24:26 +00:00
|
|
|
unsigned int num_gpl_future_syms;
|
2006-03-20 21:17:13 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Exception table */
|
|
|
|
unsigned int num_exentries;
|
|
|
|
const struct exception_table_entry *extable;
|
|
|
|
|
|
|
|
/* Startup function. */
|
|
|
|
int (*init)(void);
|
|
|
|
|
|
|
|
/* If this is non-NULL, vfree after init() returns */
|
|
|
|
void *module_init;
|
|
|
|
|
|
|
|
/* Here is the actual code + data, vfree'd on unload. */
|
|
|
|
void *module_core;
|
|
|
|
|
|
|
|
/* Here are the sizes of the init and core sections */
|
|
|
|
unsigned long init_size, core_size;
|
|
|
|
|
|
|
|
/* The size of the executable code in each section. */
|
|
|
|
unsigned long init_text_size, core_text_size;
|
|
|
|
|
2006-06-26 11:57:28 +00:00
|
|
|
/* The handle returned from unwind_add_table. */
|
|
|
|
void *unwind_info;
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Arch-specific module values */
|
|
|
|
struct mod_arch_specific arch;
|
|
|
|
|
2006-10-02 09:17:02 +00:00
|
|
|
unsigned int taints; /* same bits as kernel:tainted */
|
|
|
|
|
[PATCH] Generic BUG implementation
This patch adds common handling for kernel BUGs, for use by architectures as
they wish. The code is derived from arch/powerpc.
The advantages of having common BUG handling are:
- consistent BUG reporting across architectures
- shared implementation of out-of-line file/line data
- implement CONFIG_DEBUG_BUGVERBOSE consistently
This means that in inline impact of BUG is just the illegal instruction
itself, which is an improvement for i386 and x86-64.
A BUG is represented in the instruction stream as an illegal instruction,
which has file/line information associated with it. This extra information is
stored in the __bug_table section in the ELF file.
When the kernel gets an illegal instruction, it first confirms it might
possibly be from a BUG (ie, in kernel mode, the right illegal instruction).
It then calls report_bug(). This searches __bug_table for a matching
instruction pointer, and if found, prints the corresponding file/line
information. If report_bug() determines that it wasn't a BUG which caused the
trap, it returns BUG_TRAP_TYPE_NONE.
Some architectures (powerpc) implement WARN using the same mechanism; if the
illegal instruction was the result of a WARN, then report_bug(Q) returns
CONFIG_DEBUG_BUGVERBOSE; otherwise it returns BUG_TRAP_TYPE_BUG.
lib/bug.c keeps a list of loaded modules which can be searched for __bug_table
entries. The architecture must call
module_bug_finalize()/module_bug_cleanup() from its corresponding
module_finalize/cleanup functions.
Unsetting CONFIG_DEBUG_BUGVERBOSE will reduce the kernel size by some amount.
At the very least, filename and line information will not be recorded for each
but, but architectures may decide to store no extra information per BUG at
all.
Unfortunately, gcc doesn't have a general way to mark an asm() as noreturn, so
architectures will generally have to include an infinite loop (or similar) in
the BUG code, so that gcc knows execution won't continue beyond that point.
gcc does have a __builtin_trap() operator which may be useful to achieve the
same effect, unfortunately it cannot be used to actually implement the BUG
itself, because there's no way to get the instruction's address for use in
generating the __bug_table entry.
[randy.dunlap@oracle.com: Handle BUG=n, GENERIC_BUG=n to prevent build errors]
[bunk@stusta.de: include/linux/bug.h must always #include <linux/module.h]
Signed-off-by: Jeremy Fitzhardinge <jeremy@goop.org>
Cc: Andi Kleen <ak@muc.de>
Cc: Hugh Dickens <hugh@veritas.com>
Cc: Michael Ellerman <michael@ellerman.id.au>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:36:19 +00:00
|
|
|
#ifdef CONFIG_GENERIC_BUG
|
|
|
|
/* Support for BUG */
|
2008-07-23 00:24:26 +00:00
|
|
|
unsigned num_bugs;
|
[PATCH] Generic BUG implementation
This patch adds common handling for kernel BUGs, for use by architectures as
they wish. The code is derived from arch/powerpc.
The advantages of having common BUG handling are:
- consistent BUG reporting across architectures
- shared implementation of out-of-line file/line data
- implement CONFIG_DEBUG_BUGVERBOSE consistently
This means that in inline impact of BUG is just the illegal instruction
itself, which is an improvement for i386 and x86-64.
A BUG is represented in the instruction stream as an illegal instruction,
which has file/line information associated with it. This extra information is
stored in the __bug_table section in the ELF file.
When the kernel gets an illegal instruction, it first confirms it might
possibly be from a BUG (ie, in kernel mode, the right illegal instruction).
It then calls report_bug(). This searches __bug_table for a matching
instruction pointer, and if found, prints the corresponding file/line
information. If report_bug() determines that it wasn't a BUG which caused the
trap, it returns BUG_TRAP_TYPE_NONE.
Some architectures (powerpc) implement WARN using the same mechanism; if the
illegal instruction was the result of a WARN, then report_bug(Q) returns
CONFIG_DEBUG_BUGVERBOSE; otherwise it returns BUG_TRAP_TYPE_BUG.
lib/bug.c keeps a list of loaded modules which can be searched for __bug_table
entries. The architecture must call
module_bug_finalize()/module_bug_cleanup() from its corresponding
module_finalize/cleanup functions.
Unsetting CONFIG_DEBUG_BUGVERBOSE will reduce the kernel size by some amount.
At the very least, filename and line information will not be recorded for each
but, but architectures may decide to store no extra information per BUG at
all.
Unfortunately, gcc doesn't have a general way to mark an asm() as noreturn, so
architectures will generally have to include an infinite loop (or similar) in
the BUG code, so that gcc knows execution won't continue beyond that point.
gcc does have a __builtin_trap() operator which may be useful to achieve the
same effect, unfortunately it cannot be used to actually implement the BUG
itself, because there's no way to get the instruction's address for use in
generating the __bug_table entry.
[randy.dunlap@oracle.com: Handle BUG=n, GENERIC_BUG=n to prevent build errors]
[bunk@stusta.de: include/linux/bug.h must always #include <linux/module.h]
Signed-off-by: Jeremy Fitzhardinge <jeremy@goop.org>
Cc: Andi Kleen <ak@muc.de>
Cc: Hugh Dickens <hugh@veritas.com>
Cc: Michael Ellerman <michael@ellerman.id.au>
Cc: Paul Mackerras <paulus@samba.org>
Cc: Benjamin Herrenschmidt <benh@kernel.crashing.org>
Cc: Rusty Russell <rusty@rustcorp.com.au>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-12-08 10:36:19 +00:00
|
|
|
struct list_head bug_list;
|
|
|
|
struct bug_entry *bug_table;
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
#ifdef CONFIG_KALLSYMS
|
|
|
|
/* We keep the symbol and string tables for kallsyms. */
|
|
|
|
Elf_Sym *symtab;
|
|
|
|
unsigned long num_symtab;
|
|
|
|
char *strtab;
|
|
|
|
|
|
|
|
/* Section attributes */
|
|
|
|
struct module_sect_attrs *sect_attrs;
|
2007-10-17 06:26:40 +00:00
|
|
|
|
|
|
|
/* Notes attributes */
|
|
|
|
struct module_notes_attrs *notes_attrs;
|
2005-04-16 22:20:36 +00:00
|
|
|
#endif
|
|
|
|
|
|
|
|
/* Per-cpu data. */
|
|
|
|
void *percpu;
|
|
|
|
|
|
|
|
/* The command line arguments (may be mangled). People like
|
|
|
|
keeping pointers to this stuff */
|
|
|
|
char *args;
|
2007-10-19 06:41:06 +00:00
|
|
|
#ifdef CONFIG_MARKERS
|
|
|
|
struct marker *markers;
|
|
|
|
unsigned int num_markers;
|
|
|
|
#endif
|
2008-07-23 00:24:26 +00:00
|
|
|
|
|
|
|
#ifdef CONFIG_MODULE_UNLOAD
|
|
|
|
/* What modules depend on me? */
|
|
|
|
struct list_head modules_which_use_me;
|
|
|
|
|
|
|
|
/* Who is waiting for us to be unloaded */
|
|
|
|
struct task_struct *waiter;
|
|
|
|
|
|
|
|
/* Destruction function. */
|
|
|
|
void (*exit)(void);
|
|
|
|
|
|
|
|
/* Reference counts */
|
|
|
|
struct module_ref ref[NR_CPUS];
|
|
|
|
#endif
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
};
|
2007-05-09 09:35:15 +00:00
|
|
|
#ifndef MODULE_ARCH_INIT
|
|
|
|
#define MODULE_ARCH_INIT {}
|
|
|
|
#endif
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* FIXME: It'd be nice to isolate modules during init, too, so they
|
|
|
|
aren't used before they (may) fail. But presently too much code
|
|
|
|
(IDE & SCSI) require entry into the module during init.*/
|
|
|
|
static inline int module_is_live(struct module *mod)
|
|
|
|
{
|
|
|
|
return mod->state != MODULE_STATE_GOING;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Is this address in a module? (second is with no locks, for oops) */
|
|
|
|
struct module *module_text_address(unsigned long addr);
|
|
|
|
struct module *__module_text_address(unsigned long addr);
|
2006-07-03 07:24:24 +00:00
|
|
|
int is_module_address(unsigned long addr);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
2007-05-08 07:28:39 +00:00
|
|
|
/* Returns 0 and fills in value, defined and namebuf, or -ERANGE if
|
2005-04-16 22:20:36 +00:00
|
|
|
symnum out of range. */
|
2007-05-08 07:28:39 +00:00
|
|
|
int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
|
|
|
|
char *name, char *module_name, int *exported);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Look for this name: can be of form module:name. */
|
|
|
|
unsigned long module_kallsyms_lookup_name(const char *name);
|
|
|
|
|
|
|
|
extern void __module_put_and_exit(struct module *mod, long code)
|
|
|
|
__attribute__((noreturn));
|
|
|
|
#define module_put_and_exit(code) __module_put_and_exit(THIS_MODULE, code);
|
|
|
|
|
|
|
|
#ifdef CONFIG_MODULE_UNLOAD
|
|
|
|
unsigned int module_refcount(struct module *mod);
|
|
|
|
void __symbol_put(const char *symbol);
|
|
|
|
#define symbol_put(x) __symbol_put(MODULE_SYMBOL_PREFIX #x)
|
|
|
|
void symbol_put_addr(void *addr);
|
|
|
|
|
|
|
|
/* Sometimes we know we already have a refcount, and it's easier not
|
|
|
|
to handle the error case (which only happens with rmmod --wait). */
|
|
|
|
static inline void __module_get(struct module *module)
|
|
|
|
{
|
|
|
|
if (module) {
|
|
|
|
BUG_ON(module_refcount(module) == 0);
|
|
|
|
local_inc(&module->ref[get_cpu()].count);
|
|
|
|
put_cpu();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int try_module_get(struct module *module)
|
|
|
|
{
|
|
|
|
int ret = 1;
|
|
|
|
|
|
|
|
if (module) {
|
|
|
|
unsigned int cpu = get_cpu();
|
|
|
|
if (likely(module_is_live(module)))
|
|
|
|
local_inc(&module->ref[cpu].count);
|
|
|
|
else
|
|
|
|
ret = 0;
|
|
|
|
put_cpu();
|
|
|
|
}
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2006-10-18 05:47:25 +00:00
|
|
|
extern void module_put(struct module *module);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
#else /*!CONFIG_MODULE_UNLOAD*/
|
|
|
|
static inline int try_module_get(struct module *module)
|
|
|
|
{
|
|
|
|
return !module || module_is_live(module);
|
|
|
|
}
|
|
|
|
static inline void module_put(struct module *module)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
static inline void __module_get(struct module *module)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
#define symbol_put(x) do { } while(0)
|
|
|
|
#define symbol_put_addr(p) do { } while(0)
|
|
|
|
|
|
|
|
#endif /* CONFIG_MODULE_UNLOAD */
|
|
|
|
|
|
|
|
/* This is a #define so the string doesn't get put in every .o file */
|
|
|
|
#define module_name(mod) \
|
|
|
|
({ \
|
|
|
|
struct module *__mod = (mod); \
|
|
|
|
__mod ? __mod->name : "kernel"; \
|
|
|
|
})
|
|
|
|
|
2008-01-29 22:13:22 +00:00
|
|
|
/* For kallsyms to ask for address resolution. namebuf should be at
|
|
|
|
* least KSYM_NAME_LEN long: a pointer to namebuf is returned if
|
|
|
|
* found, otherwise NULL. */
|
2008-02-08 12:18:43 +00:00
|
|
|
const char *module_address_lookup(unsigned long addr,
|
2008-01-29 22:13:22 +00:00
|
|
|
unsigned long *symbolsize,
|
|
|
|
unsigned long *offset,
|
|
|
|
char **modname,
|
|
|
|
char *namebuf);
|
2007-05-08 07:28:43 +00:00
|
|
|
int lookup_module_symbol_name(unsigned long addr, char *symname);
|
2007-05-08 07:28:47 +00:00
|
|
|
int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* For extable.c to search modules' exception tables. */
|
|
|
|
const struct exception_table_entry *search_module_extables(unsigned long addr);
|
|
|
|
|
|
|
|
int register_module_notifier(struct notifier_block * nb);
|
|
|
|
int unregister_module_notifier(struct notifier_block * nb);
|
|
|
|
|
|
|
|
extern void print_modules(void);
|
|
|
|
|
Linux Kernel Markers: support multiple probes
RCU style multiple probes support for the Linux Kernel Markers. Common case
(one probe) is still fast and does not require dynamic allocation or a
supplementary pointer dereference on the fast path.
- Move preempt disable from the marker site to the callback.
Since we now have an internal callback, move the preempt disable/enable to the
callback instead of the marker site.
Since the callback change is done asynchronously (passing from a handler that
supports arguments to a handler that does not setup the arguments is no
arguments are passed), we can safely update it even if it is outside the
preempt disable section.
- Move probe arm to probe connection. Now, a connected probe is automatically
armed.
Remove MARK_MAX_FORMAT_LEN, unused.
This patch modifies the Linux Kernel Markers API : it removes the probe
"arm/disarm" and changes the probe function prototype : it now expects a
va_list * instead of a "...".
If we want to have more than one probe connected to a marker at a given
time (LTTng, or blktrace, ssytemtap) then we need this patch. Without it,
connecting a second probe handler to a marker will fail.
It allow us, for instance, to do interesting combinations :
Do standard tracing with LTTng and, eventually, to compute statistics
with SystemTAP, or to have a special trigger on an event that would call
a systemtap script which would stop flight recorder tracing.
Signed-off-by: Mathieu Desnoyers <mathieu.desnoyers@polymtl.ca>
Cc: Christoph Hellwig <hch@infradead.org>
Cc: Mike Mason <mmlnx@us.ibm.com>
Cc: Dipankar Sarma <dipankar@in.ibm.com>
Cc: David Smith <dsmith@redhat.com>
Cc: "Paul E. McKenney" <paulmck@us.ibm.com>
Cc: "Frank Ch. Eigler" <fche@redhat.com>
Cc: Steven Rostedt <rostedt@goodmis.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>
2008-02-13 23:03:37 +00:00
|
|
|
extern void module_update_markers(void);
|
2007-10-19 06:41:06 +00:00
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#else /* !CONFIG_MODULES... */
|
|
|
|
#define EXPORT_SYMBOL(sym)
|
|
|
|
#define EXPORT_SYMBOL_GPL(sym)
|
2006-03-20 21:17:13 +00:00
|
|
|
#define EXPORT_SYMBOL_GPL_FUTURE(sym)
|
2006-06-28 11:26:45 +00:00
|
|
|
#define EXPORT_UNUSED_SYMBOL(sym)
|
|
|
|
#define EXPORT_UNUSED_SYMBOL_GPL(sym)
|
2005-04-16 22:20:36 +00:00
|
|
|
|
|
|
|
/* Given an address, look for it in the exception tables. */
|
|
|
|
static inline const struct exception_table_entry *
|
|
|
|
search_module_extables(unsigned long addr)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Is this address in a module? */
|
|
|
|
static inline struct module *module_text_address(unsigned long addr)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Is this address in a module? (don't take a lock, we're oopsing) */
|
|
|
|
static inline struct module *__module_text_address(unsigned long addr)
|
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2006-07-03 07:24:24 +00:00
|
|
|
static inline int is_module_address(unsigned long addr)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
/* Get/put a kernel symbol (calls should be symmetric) */
|
|
|
|
#define symbol_get(x) ({ extern typeof(x) x __attribute__((weak)); &(x); })
|
|
|
|
#define symbol_put(x) do { } while(0)
|
|
|
|
#define symbol_put_addr(x) do { } while(0)
|
|
|
|
|
|
|
|
static inline void __module_get(struct module *module)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int try_module_get(struct module *module)
|
|
|
|
{
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void module_put(struct module *module)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
#define module_name(mod) "kernel"
|
|
|
|
|
|
|
|
/* For kallsyms to ask for address resolution. NULL means not found. */
|
2008-02-08 12:18:43 +00:00
|
|
|
static inline const char *module_address_lookup(unsigned long addr,
|
2008-01-29 22:13:22 +00:00
|
|
|
unsigned long *symbolsize,
|
|
|
|
unsigned long *offset,
|
|
|
|
char **modname,
|
|
|
|
char *namebuf)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2007-05-08 07:28:43 +00:00
|
|
|
static inline int lookup_module_symbol_name(unsigned long addr, char *symname)
|
|
|
|
{
|
|
|
|
return -ERANGE;
|
|
|
|
}
|
|
|
|
|
2007-05-08 07:28:47 +00:00
|
|
|
static inline int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name)
|
|
|
|
{
|
|
|
|
return -ERANGE;
|
|
|
|
}
|
|
|
|
|
2007-05-08 07:28:39 +00:00
|
|
|
static inline int module_get_kallsym(unsigned int symnum, unsigned long *value,
|
|
|
|
char *type, char *name,
|
|
|
|
char *module_name, int *exported)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-05-08 07:28:39 +00:00
|
|
|
return -ERANGE;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
static inline unsigned long module_kallsyms_lookup_name(const char *name)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int register_module_notifier(struct notifier_block * nb)
|
|
|
|
{
|
|
|
|
/* no events will happen anyway, so this can always succeed */
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline int unregister_module_notifier(struct notifier_block * nb)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
#define module_put_and_exit(code) do_exit(code)
|
|
|
|
|
|
|
|
static inline void print_modules(void)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2008-02-15 03:31:20 +00:00
|
|
|
static inline void module_update_markers(void)
|
2007-10-19 06:41:06 +00:00
|
|
|
{
|
|
|
|
}
|
|
|
|
|
2007-02-13 23:19:06 +00:00
|
|
|
#endif /* CONFIG_MODULES */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
struct device_driver;
|
2007-02-13 23:19:06 +00:00
|
|
|
#ifdef CONFIG_SYSFS
|
2005-04-16 22:20:36 +00:00
|
|
|
struct module;
|
|
|
|
|
2007-11-01 17:39:50 +00:00
|
|
|
extern struct kset *module_kset;
|
|
|
|
extern struct kobj_type module_ktype;
|
|
|
|
extern int module_sysfs_initialized;
|
2007-02-13 23:19:06 +00:00
|
|
|
|
|
|
|
int mod_sysfs_init(struct module *mod);
|
|
|
|
int mod_sysfs_setup(struct module *mod,
|
|
|
|
struct kernel_param *kparam,
|
|
|
|
unsigned int num_params);
|
|
|
|
int module_add_modinfo_attrs(struct module *mod);
|
|
|
|
void module_remove_modinfo_attrs(struct module *mod);
|
|
|
|
|
|
|
|
#else /* !CONFIG_SYSFS */
|
|
|
|
|
|
|
|
static inline int mod_sysfs_init(struct module *mod)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-02-13 23:19:06 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-02-13 23:19:06 +00:00
|
|
|
static inline int mod_sysfs_setup(struct module *mod,
|
|
|
|
struct kernel_param *kparam,
|
|
|
|
unsigned int num_params)
|
2005-04-16 22:20:36 +00:00
|
|
|
{
|
2007-02-13 23:19:06 +00:00
|
|
|
return 0;
|
2005-04-16 22:20:36 +00:00
|
|
|
}
|
|
|
|
|
2007-02-13 23:19:06 +00:00
|
|
|
static inline int module_add_modinfo_attrs(struct module *mod)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
static inline void module_remove_modinfo_attrs(struct module *mod)
|
|
|
|
{ }
|
|
|
|
|
|
|
|
#endif /* CONFIG_SYSFS */
|
|
|
|
|
2005-04-16 22:20:36 +00:00
|
|
|
#define symbol_request(x) try_then_request_module(symbol_get(x), "symbol:" #x)
|
|
|
|
|
|
|
|
/* BELOW HERE ALL THESE ARE OBSOLETE AND WILL VANISH */
|
|
|
|
|
|
|
|
#define __MODULE_STRING(x) __stringify(x)
|
|
|
|
|
|
|
|
#endif /* _LINUX_MODULE_H */
|