和我们通常写程序不同，如果仅仅是全局变量，虽然编译内核的时候能连接成功，但是连接之后再就没有办法使用这个变量了
而模块的加载是运行时的，它引用某个变量时，内核需要解析它，否则模块不能工作，EXPORT_SYMBOL 的定义如下
fine __EXPORT_SYMBOL(sym, sec) /
extern typeof(sym) sym; /
__CRC_SYMBOL(sym, sec) /
static const char __kstrtab_##sym[] /
__attribute__((section("__ksymtab_strings"))) /
= MODULE_SYMBOL_PREFIX #sym; /
static const struct kernel_symbol __ksymtab_##sym /
__attribute_used__ /
__attribute__((section("__ksymtab" sec), unused)) /
= { (unsigned long)&sym, __kstrtab_##sym }
它放在固定的节，这样内核解析的时候就能在这个节里找符号了，找到了的重定位和普通的连接（.o） 原理类似
System.map 中的是链接时的函数地址。 连接完成以后，在内核运行过程中，是不知道哪个符号在那个地址的。而这个文件是给调试用的。其中的内容，kernel并不知道 。
EXPORT_SYMBOL 的符号， 是把这些符号和对应的地址，保存起来，在内核运行的过程中，可以找到这些符号对应的地址的。
而module在加载过程中，其本质就是动态连接到内核，如果在模块中引用了内核或其它模块的符号，就要 EXPORT_SYMBOL 这些符号，这样才能找到对应的地址连接呀。 要不没法连接的。
///
Linux symbol export methord [2007-03-06]
[1] If we want export the symbol in a module, just use the EXPORT_SYMBOL(xxxx) in the C or H file.
And compile the module by adding the compile flag -DEXPORT_SYMTAB.
Then we can use the xxxx in the other module.
[2] If we want export some symbol in Kernel that is not in a module such as xxxx in the /arch/ppc/fec.c.
Firstly, define the xxxx in the fec.c;
Secondly, make a new file which contain the "extern" define the xxxx(for example, extern int xxxx);
Lastly, in the ppc_ksyms.c we includes the new file, and add the EXPORT_SYMBOL(xxxx).
Then we can use the xxxx
insmod mod1.ko 必须先加载，因为函数体在他里面，再加载insmod mod2.ko就正常
编译选项中-DEXPORT_SYMTAB，同时要加上外部说明就少提示警告
下面简单代码:
/*mod1.c*/
#include <linux/init.h>
#include <linux/module.h>
MODULE_LICENSE("Dual BSD/GPL");
static int He1(void)
{
printk(KERN_INFO "He1..\n");
return 0;
}
EXPORT_SYMBOL(He1);
static int __init hello_init(void)
{
printk(KERN_ALERT "Hello, world\n");
return 0;
}
static void __exit hello_exit(void)
{
printk(KERN_ALERT "Goodbye, cruel world\n");
}
module_init(hello_init);
module_exit(hello_exit);
==================================
/*mod2.c*/
#include <linux/init.h>
#include <linux/module.h>
MODULE_LICENSE("Dual BSD/GPL");
static int He2(void)
{
extern int He1(void);
He1();
printk(KERN_INFO "He2..\n");
return 0;
}
static int __init hello_init(void)
{
He2();
printk(KERN_ALERT "Hello, world\n");
return 0;
}
static void __exit hello_exit(void)
{
printk(KERN_ALERT "Goodbye, cruel world\n");
}
module_init(hello_init);
module_exit(hello_exit);
### Makefile ---
## Author: hefuhua@163.com
## Version: $Id: Makefile,v 0.0 2007/01/26 02:02:51 leno Exp $
## Keywords:
## X-URL:
ifneq ($(KERNELRELEASE),)
obj-m := -DEXPORT_SYMTAB #加载该参数的地方
obj-m := mod2.o
else
KERNELDIR ?= /lib/modules/$(shell uname -r)/build
PWD := $(shell pwd)
default:
$(MAKE) -C $(KERNELDIR) M=$(PWD) modules
endif
//
EXPORT_SYMBOL 使用小记
1.基本概念
EXPORT_SYMBOL 的用法就是将 一个函数 以符号的方式导出给其他模块使用。
2.使用时注意事项：
在使用EXPORT_SYMBOL 的.c文件中 需要 #include <linux/module.h> 文件。
// 先写函数
func_a ()
{
}
//再使用EXPORT_SYMBOL
EXPORT_SYMBOL(func_a);
若内核函数或变量要被内核模块调用，则必须使用EXPORT_SYMBOL宏进行处理，作用之一是将该符号连接到二进制文件的各个__ksymtab_xx_xx section（参看include/linux/module.h，使用GCC编译器的__attribute__关键字实现[2]）。内核加载模块时，会先确认该模块调用的各内核函数是否已export（参看__find_symbol() kernel/module.c）。
比如FC5缺省会给vanilla内核打补丁，使其不再export sys_open符号，这一点可搜索该内核对应的System.map文件进行确认，看是否存在__ksymtab_sys_open符号。
[1] The system.map File
http://www.dirac.org/linux/system.map/
[2] Using GNU C __attribute__
http://www.unixwiz.net/techtips/gnu-c-attributes.html
The system.map File
System.map
There seems to be a dearth of information about the System.map file. It's really nothing mysterious, and in the scheme of things, it's really not that important. But a lack of documentation makes it shady. It's like an earlobe; we all have one, but nobody really knows why. This is a little web page I cooked up that explains the why.
Note, I'm not out to be 100% correct. For instance, it's possible for a system to not have /proc filesystem support, but most systems do. I'm going to assume you "go with the flow" and have a fairly typical system.
Some of the stuff on oopses comes from Alessandro Rubini's "Linux Device Drivers" which is where I learned most of what I know about kernel programming.
What Are Symbols?
In the context of programming, a symbol is the building block of a program: it is a variable name or a function name. It should be of no surprise that the kernel has symbols, just like the programs you write. The difference is, of course, that the kernel is a very complicated piece of coding and has many, many global symbols.
What Is The Kernel Symbol Table?
The kernel doesn't use symbol names. It's much happier knowing a variable or function name by the variable or function's address. Rather than using size_t BytesRead(), the kernel prefers to refer to this variable as (for example) c0343f20.
Humans, on the other hand, do not appreciate addresses like c0343f20. We prefer to use something like size_t BytesRead(). Normally, this doesn't present much of a problem. The kernel is mainly written in C, so the compiler/linker allows us to use symbol names when we code and allows the kernel to use addresses when it runs. Everyone is happy.
There are situations, however, where we need to know the address of a symbol (or the symbol for an address). This is done by a symbol table, and is very similar to how gdb can give you the function name from an address (or an address from a function name). A symbol table is a listing of all symbols along with their address. Here is an example of a symbol table:
c03441a0 B dmi_broken
c03441a4 B is_sony_vaio_laptop
c03441c0 b dmi_ident
c0344200 b pci_bios_present
c0344204 b pirq_table
c0344208 b pirq_router
c034420c b pirq_router_dev
c0344220 b ascii_buffer
c0344224 b ascii_buf_bytes
You can see that the variable named dmi_broken is at the kernel address c03441a0.
What Is The System.map File?
There are 2 files that are used as a symbol table:
/proc/ksyms
System.map
There. You now know what the System.map file is.
Every time you compile a new kernel, the addresses of various symbol names are bound to change.
/proc/ksyms is a "proc file" and is created on the fly when a kernel boots up. Actually, it's not really a file; it's simply a representation of kernel data which is given the illusion of being a disk file. If you don't believe me, try finding the filesize of /proc/ksyms. Therefore, it will always be correct for the kernel that is currently running.
However, System.map is an actual file on your filesystem. When you compile a new kernel, your old System.map has wrong symbol information. A new System.map is generated with each kernel compile and you need to replace the old copy with your new copy.
What Is An Oops?
What is the most common bug in your homebrewed programs? The segfault. Good ol' signal 11.
What is the most common bug in the Linux kernel? The segfault. Except here, the notion of a segfault is much more complicated and can be, as you can imagine, much more serious. When the kernel dereferences an invalid pointer, it's not called a segfault -- it's called an "oops". An oops indicates a kernel bug and should always be reported and fixed.
Note that an oops is not the same thing as a segfault. Your program cannot recover from a segfault. The kernel doesn't necessarily have to be in an unstable state when an oops occurs. The Linux kernel is very robust; the oops may just kill the current process and leave the rest of the kernel in a good, solid state.
An oops is not a kernel panic. In a panic, the kernel cannot continue; the system grinds to a halt and must be restarted. An oops may cause a panic if a vital part of the system is destroyed. An oops in a device driver, for example, will almost never cause a panic.
When an oops occurs, the system will print out information that is relevent to debugging the problem, like the contents of all the CPU registers, and the location of page descriptor tables. In particular, the contents of the EIP (instruction pointer) is printed. Like this:
EIP: 0010:[<00000000>]
Call Trace: [<c010b860>]
What Does An Oops Have To Do With System.map?
You can agree that the information given in EIP and Call Trace is not very informative. But more importantly, it's really not informative to a kernel developer either. Since a symbol doesn't have a fixed address, c010b860 can point anywhere.
To help us understand cryptic oops output, Linux uses a daemon called klogd, the kernel logging daemon. klogd intercepts kernel oopses and logs them with syslogd, changing some of the useless information like c010b860 with information that humans can use. In other words, klogd is a kernel message logger which can perform name-address resolution. Once klogd tranforms the kernel message, it uses whatever logger is in place to log system wide messages, usually syslogd.
To perform name-address resolution, klogd uses System.map. Now you know what an oops has to do with System.map.
There's other software besides the kernel logger daemon that uses System.map. I'll get into that shortly.
Fine print:
There are actually two types of address resolutions performed by klogd.
Static translation, which uses the System.map file.
Dynamic translation, which is used with loadable modules. These translations don't use System.map and is therefore not relevant to this discussion, but I'll describe it briefly anyhow:
Klogd Dynamic Translation
Suppose you load a kernel module which generates an oops. An oops message is generated, and klogd intercepts it. It is found that the oops occured at d00cf810. Since this address belongs to a dynamically loaded module, it has no entry in the System.map file. klogd will search for it, find nothing, and conclude that a loadable module must have generated the oops. klogd then queries the kernel for symbols that were exported by loadable modules. Even if the module author didn't export his symbols, at the very least, klogd will know what module generated the oops, which is better than knowing nothing about the oops at all.
Where Should System.map Be Located?
System.map should be located wherever the software that uses it looks for it. That being said, let me talk about where klogd looks for it. Upon bootup, if klogd isn't given the location of System.map as an argument, it will look for System.map in three places, in the following order:
/boot/System.map
/System.map
/usr/src/linux/System.map
System.map also has versioning information, and klogd intelligently searches for the correct map file. For instance, suppose you're running kernel 2.4.18 and the associated map file is /boot/System.map. You now compile a new kernel 2.5.1 in the tree /usr/src/linux. During the compiling process, the file /usr/src/linux/System.map is created. When you boot your new kernel, klogd will first look at /boot/System.map, determine it's not the correct map file for the booting kernel, then look at /usr/src/linux/System.map, determine that it is the correct map file for the booting kernel and start reading the symbols.
A few nota bene's:
Somewhere during the 2.5.x series, the Linux kernel started to untar into linux-version, rather than just linux (show of hands -- how many people have been waiting for this to happen?). I don't know if klogd has been modified to search in /usr/src/linux-version/System.map yet. TODO: Look at the klogd source. If someone beats me to it, please email me and let me know if klogd has been modified to look in the new directory name for the linux source code.
The man page doesn't tell the whole the story. Look at this:
# strace -f /sbin/klogd | grep 'System.map'
31208 open("/boot/System.map-2.4.18", O_RDONLY|O_LARGEFILE) = 2
Apparently, not only does klogd look for the correct version of the map in the 3 klogd search directories, but klogd also knows to look for the name "System.map" followed by "-kernelversion", like System.map-2.4.18. This is undocumented feature of klogd.
A few drivers need System.map to resolve symbols since they're linked against kernel headers instead of glibc). They won't work correctly without the System.map for the particular kernel currently running. This is NOT the same thing as a module not loading because of a kernel version mismatch. That has to do with the kernel version, not the kernel symbol table which changes between kernels of the same version!
What else uses the System.map
System.map isn't just useful for debugging kernel oopses. Other programs like lsof:
satan# strace lsof 2>&1 1> /dev/null | grep System
readlink("/proc/22711/fd/4", "/boot/System.map-2.4.18", 4095) = 23
and ps:
satan# strace ps 2>&1 1> /dev/null | grep System
open("/boot/System.map-2.4.18", O_RDONLY|O_NONBLOCK|O_NOCTTY) = 6
and dosemu require a correct System.map.
What Happens If I Don't Have A Healthy System.map?
Suppose you have multiple kernels on the same machine. You need a separate System.map file for each kernel! If you run a kernel with no (or an incorrect) System.map, you'll periodically see a message like:
System.map does not match actual kernel
Not a fatal error, but can be annoying to see everytime you use ps. Some software, like dosemu, may not work correctly. Lastly, your klogd or ksymoops output will not be reliable in case of a kernel oops.
扫一扫
2562
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
