版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq_16777851/article/details/82121456
下面是一个最简单的字符驱动程序框架，下面我将一一进行分析里面的内容。
#include <linux/fs.h>
#include <linux/init.h>
/* 定义一个open函数 */
static int first_drv_open(struct inode *inodep, struct file *filep)
{
return 0;
}
/* 定义一个write函数 */
static ssize_t first_drv_write(struct file *filep, const char __user * buf, size_t len, loff_t *ppos)
{
return 0;
}
/* 把自己定义的函数接口集合起来,方便系统使用 */
static const struct file_operations first_drv_file_operation = {
.open = first_drv_open,
.write = first_drv_write,
};
/* 把集合起来的函数接口告诉系统,同时使用111作为该设备的字符设备号 */
static int __init first_drv_init(void)
{
register_chrdev(111,"first_drv",&first_drv_file_operation);
return 0;
}
/* 从系统中卸载掉字符设备号为111的设备 */
static void __exit first_drv_exit(void)
{
unregister_chrdev(111,"first_drv");
}
/* 声明段属性 */
module_init(first_drv_init);
module_exit(first_drv_exit);
MODULE_LICENSE("GPL");其中最前面的头文件包含了下面用到的一些函数，以及数据结构的定义等
#include <linux/fs.h> /* 包含file_operation结构体 */
#include <linux/init.h> /* 包含module_init module_exit */
#include <linux/module.h> /* 包含LICENSE的宏 *open和write则是我们定义的设备的操纵函数（目前为空），他们的书写格式必须遵照struct file_operations结构体里面的函数指针类型定义响应的函数。
/* 定义一个open函数 */
static int first_drv_open(struct inode *inodep, struct file *filep)
{
return 0;
}
/* 定义一个write函数 */
static ssize_t first_drv_write(struct file *filep, const char __user * buf, size_t len, loff_t *ppos)
{
return 0;
}其中struct file_operations的定义如下，它定义了一文件形式操纵的所有函数的函数指针并且把他们进行了打包集合，方便使用。
通常我们不会实现这里面的所有函数，只会实现一些针对某些设备需要用到的函数。
struct file_operations {
struct module *owner;
loff_t (*llseek) (struct file *, loff_t, int);
ssize_t (*read) (struct file *, char __user *, size_t, loff_t *);
ssize_t (*write) (struct file *, const char __user *, size_t, loff_t *);
ssize_t (*aio_read) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
ssize_t (*aio_write) (struct kiocb *, const struct iovec *, unsigned long, loff_t);
ssize_t (*read_iter) (struct kiocb *, struct iov_iter *);
ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
int (*iterate) (struct file *, struct dir_context *);
unsigned int (*poll) (struct file *, struct poll_table_struct *);
long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
int (*mmap) (struct file *, struct vm_area_struct *);
int (*open) (struct inode *, struct file *);
int (*flush) (struct file *, fl_owner_t id);
int (*release) (struct inode *, struct file *);
int (*fsync) (struct file *, loff_t, loff_t, int datasync);
int (*aio_fsync) (struct kiocb *, int datasync);
int (*fasync) (int, struct file *, int);
int (*lock) (struct file *, int, struct file_lock *);
ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
int (*check_flags)(int);
int (*flock) (struct file *, int, struct file_lock *);
ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
int (*setlease)(struct file *, long, struct file_lock **);
long (*fallocate)(struct file *file, int mode, loff_t offset,
loff_t len);
int (*show_fdinfo)(struct seq_file *m, struct file *f);
};
下面就是对我们自己实现的接口函数，定义统一的结构，实现封装，方便管理。
/* 把自己定义的函数接口集合起来,方便系统使用 */
static const struct file_operations first_drv_file_operation = {
.open = first_drv_open,
.write = first_drv_write,
};
下面定义的两个函数分别是把我们打包好的设备的操纵接口函数，注册进系统中，其中字符设备号是用来标识该设备的。在应用层使用的时候是通过设备号来直接找到该设备。
/* 把集合起来的函数接口告诉系统,同时使用111作为该设备的字符设备号 */
static int __init first_drv_init(void)
{
register_chrdev(111,"first_drv",&first_drv_file_operation); /* 注册设备号为111的设备 */
return 0;
}
/* 从系统中卸载掉字符设备号为111的设备 */
static void __exit first_drv_exit(void)
{
unregister_chrdev(111,"first_drv"); /* 卸载设备号为111的设备 */
}注：以这种方法注册时，使用的设备号必须系统中未使用
上面用到的__init和__exit
__init
__exit
#define __init __section(.init.text) __cold notrace __noretpoline
#define __exit __section(.exit.text) __exitused __cold notrace
下面以__init为例来分析
#define __section(S) __attribute__ ((__section__(#S)))
#define __cold __attribute__((__cold__))
#define notrace __attribute__((no_instrument_function))
/* Built-in __init functions needn't be compiled with retpoline */
#if defined(RETPOLINE) && !defined(MODULE)
#define __noretpoline __attribute__((indirect_branch("keep")))
#else
#define __noretpoline /* 我们通常是定义了MODULE */
#endif
分解_init宏可得到
#define __init __attribute__((".init.text")) \
__attribute__((__cold__)) \
__attribute__((no_instrument_function))
查看kernel的链接脚本我们会注意到这么一句
. = ALIGN(8); .init.text : AT(ADDR(.init.text) - 0) { _sinittext = .; *(.init.text) *(.meminit.text) _einittext = .; }
可以看到,连接器最终是把以 __init 修饰的函数都链接到这个自定义的段中去了下面的前两个也是以段属性来声明这个两个函数的。下面我们还是以module_init为例来分析
/* 声明段属性 */
module_init(first_drv_init);
module_exit(first_drv_exit);
MODULE_LICENSE("GPL"); /* 表明该代码遵循GPL协议,没有这句不能状态 */下面分析的是在内核启动阶段调用的驱动模块，而不是在系统启动后用insmod安装的。
/**
* module_init() - driver initialization entry point
* @x: function to be run at kernel boot time or module insertion
*
* module_init() will either be called during do_initcalls() (if
* builtin) or at module insertion time (if a module). There can only
* be one per module.
*/
/* 从上面的注释也可知,该声明就是声明驱动模块的装载入口（即注册） */
#define module_init(x) __initcall(x);
/*__initcall是调用device_initcall */
#define __initcall(fn) device_initcall(fn)
/*
* Early initcalls run before initializing SMP.
*
* Only for built-in code, not modules.
*/
#define early_initcall(fn) __define_initcall(fn, early)
/*
* A "pure" initcall has no dependencies on anything else, and purely
* initializes variables that couldn't be statically initialized.
*
* This only exists for built-in code, not for modules.
* Keep main.c:initcall_level_names[] in sync.
*/
#define pure_initcall(fn) __define_initcall(fn, 0)
#define core_initcall(fn) __define_initcall(fn, 1)
#define core_initcall_sync(fn) __define_initcall(fn, 1s)
#define postcore_initcall(fn) __define_initcall(fn, 2)
#define postcore_initcall_sync(fn) __define_initcall(fn, 2s)
#define arch_initcall(fn) __define_initcall(fn, 3)
#define arch_initcall_sync(fn) __define_initcall(fn, 3s)
#define subsys_initcall(fn) __define_initcall(fn, 4)
#define subsys_initcall_sync(fn) __define_initcall(fn, 4s)
#define fs_initcall(fn) __define_initcall(fn, 5)
#define fs_initcall_sync(fn) __define_initcall(fn, 5s)
#define rootfs_initcall(fn) __define_initcall(fn, rootfs)
#define device_initcall(fn) __define_initcall(fn, 6) /* 注意我们驱动的在这里 */
#define device_initcall_sync(fn) __define_initcall(fn, 6s)
#define late_initcall(fn) __define_initcall(fn, 7)
#define late_initcall_sync(fn) __define_initcall(fn, 7s)
可以看到,和驱动一样有很多的initcall,他们通过__define_initcall(fn, x)后面的的数字来区别
/* __define_initcall 其实也是一系列宏的实现 */
#define __define_initcall(fn, id) \
static initcall_t __initcall_##fn##id __used \
__attribute__((__section__(".initcall" #id ".init"))) = fn; \
LTO_REFERENCE_INITCALL(__initcall_##fn##id)
typedef int (*initcall_t)(void);
/* 查看.config文件我们没定义这个,所以LTO_REFERENCE_INITCALL为空 */
#ifdef CONFIG_LTO
/* Work around a LTO gcc problem: when there is no reference to a variable
* in a module it will be moved to the end of the program. This causes
* reordering of initcalls which the kernel does not like.
* Add a dummy reference function to avoid this. The function is
* deleted by the linker.
*/
#define LTO_REFERENCE_INITCALL(x) \
; /* yes this is needed */ \
static __used __exit void *reference_##x(void) \
{ \
return &x; \
}
#else
#define LTO_REFERENCE_INITCALL(x)
#endif
以我们的module_init（first_drv_init）为例，展开
module_init(first_drv_init); /* 注意; */
#define module_init(x) __initcall(x); /* 注意; */
#define __initcall(fn) device_initcall(fn)
#define __used __attribute__((__unused__))
#define device_initcall(fn) __define_initcall(fn, 6)
#define __define_initcall(fn, id) \
static initcall_t __initcall_##fn##id __used \
__attribute__((__section__(".initcall" #id ".init"))) = fn; \
LTO_REFERENCE_INITCALL(__initcall_##fn##id) /* 这个就直接去掉了 */
/* 展开到device_initcall为 */
device_initcall(first_drv_init);; /* 注意到这里以及有两个; */
#define __define_initcall(first_drv_init, 6)
static initcall_t __initcall_first_drv_init6 __used \
__attribute__((__section__(".initcall6.init"))) = first_drv_init;
typedef int (*initcall_t)(void);
static initcall_t __initcall_first_drv_init6 __attribute__((__unused__)) \
__attribute__((__section__(".initcall6.init"))) = first_drv_init;
/* 到这里我们就很明显的看到了,其实就是定义一个函数指针变量,指针的内容就是我们最初传入的函数名
* 唯一这个函数指针变量是被声明了__attribute__((__section__(".initcall6.init")))属性
* 其作用我想大家已经猜到了,很就是在链接器链接时把这个变量存储在一个特殊的数据段中,下面我们来
* 看一下连接脚本
*/#define early_initcall(fn) __define_initcall(fn, early)
/*
* A "pure" initcall has no dependencies on anything else, and purely
* initializes variables that couldn't be statically initialized.
*
* This only exists for built-in code, not for modules.
* Keep main.c:initcall_level_names[] in sync.
*/
#define pure_initcall(fn) __define_initcall(fn, 0)
#define core_initcall(fn) __define_initcall(fn, 1)
#define core_initcall_sync(fn) __define_initcall(fn, 1s)
#define postcore_initcall(fn) __define_initcall(fn, 2)
#define postcore_initcall_sync(fn) __define_initcall(fn, 2s)
#define arch_initcall(fn) __define_initcall(fn, 3)
#define arch_initcall_sync(fn) __define_initcall(fn, 3s)
#define subsys_initcall(fn) __define_initcall(fn, 4)
#define subsys_initcall_sync(fn) __define_initcall(fn, 4s)
#define fs_initcall(fn) __define_initcall(fn, 5)
#define fs_initcall_sync(fn) __define_initcall(fn, 5s)
#define rootfs_initcall(fn) __define_initcall(fn, rootfs)
#define device_initcall(fn) __define_initcall(fn, 6)
#define device_initcall_sync(fn) __define_initcall(fn, 6s)
#define late_initcall(fn) __define_initcall(fn, 7)
#define late_initcall_sync(fn) __define_initcall(fn, 7s)
/* 前面已经知道了上面定义的这个被调用后都是定义一个函数指针变量他们的命令都是以xxx.init的形式属性定义
* 因为指针变量,所以肯定是在数据段,只不过是自定义的数据段,对比上下可以发现所有的initcall函数都被
* 以它后面待的数字 1 1s 2 2s 3 3s 4 4s 5 5s 6 6s 7 7s按顺序在 init.data段中存放
*/
.init.data : {
*(.init.data) *(.meminit.data) *(.init.rodata) *(.meminit.rodata) . = ALIGN(32); __dtb_start = .; *(.dtb.init.rodata) __dtb_end = .;
. = ALIGN(16); __setup_start = .; *(.init.setup) __setup_end = .;
__initcall_start = .; *(.initcallearly.init) __initcall0_start = .; *(.initcall0.init)\
*(.initcall0s.init) __initcall1_start = .; *(.initcall1.init) *(.initcall1s.init)\
__initcall2_start = .; *(.initcall2.init) *(.initcall2s.init) __initcall3_start = .;\
*(.initcall3.init) *(.initcall3s.init) __initcall4_start = .; *(.initcall4.init)\
*(.initcall4s.init) __initcall5_start = .; *(.initcall5.init) *(.initcall5s.init)\
__initcallrootfs_start = .; *(.initcallrootfs.init) *(.initcallrootfss.init)\
__initcall6_start = .; *(.initcall6.init) *(.initcall6s.init) __initcall7_start = .;\
*(.initcall7.init) *(.initcall7s.init) __initcall_end = .;
__con_initcall_start = .; *(.con_initcall.init) __con_initcall_end = .;
__security_initcall_start = .; *(.security_initcall.init) __security_initcall_end = .;
. = ALIGN(4); __initramfs_start = .; *(.init.ramfs) . = ALIGN(8); *(.init.ramfs.info)
}
前分析了这么多，那么为什么系统要实现这么多的段。意义在哪里？
其实，这样做事非常有必要的，因为在系统的初始化时，所有的东西都必须按照一定的顺序初始化，否则就会出现问题。
比如：驱动注册，是在上面的initcall6里面实现的。而要实现设备驱动的注册，必须要在设备驱动管理（设备驱动模型）初始化完之后才能进行，否则如果设备驱动的管理程序都还没初始化，则驱动的注册肯定就有问题了。而要想让初始化阶段先初始化驱动的管理程序，如果靠函数依次调用，因为内核的内容太庞大，这明显不可能实现。所以初始化阶段，内核又按重要程序（先后顺序）分了16个子阶段阶段。
通常越靠前的是越底层越核心的初始化，通常后面的初始化对前面的都有一定的依赖。
下面看一下，系统是如何使用的。
在连接脚本中我们看到最早的是__initcall_start标号，所以在代码中搜索__initcall_start
它在main函数中被定义和使用，其它几个阶段的也是。
注意：代码中虽然分为了16个段，但在连接脚本和使用时都是把对应的1s 2s段归在了1 2 段里面。
通过查看连接脚本，我们知道最早应该调用的是*(.initcallearly.init)段的内容
__initcall_start = .; *(.initcallearly.init) __initcall0_start = .;它里面的函数指针们都是在__initcall_start 和 __initcall0_start标号之间存储，上面已经对他们进行了声明，所以就可以直接使用。
/* 下面两个函数都在main.c中定义 */
/* 专用函数,只初始化initcallearly.init段中的函数,所以是static修饰 */
static void __init do_pre_smp_initcalls(void)
{
initcall_t *fn;
for (fn = __initcall_start; fn < __initcall0_start; fn++)
do_one_initcall(*fn); /* 每一都传入一个函数指针 */
}
/* 公共函数,任何__init修饰或module类型的都可用,所以没static修饰 */
int __init_or_module do_one_initcall(initcall_t fn)
{
int count = preempt_count();
int ret;
char msgbuf[64];
if (initcall_blacklisted(fn))
return -EPERM;
if (initcall_debug)
ret = do_one_initcall_debug(fn);
else
ret = fn(); /* eraly函数调用 */
msgbuf[0] = 0;
if (preempt_count() != count) {
sprintf(msgbuf, "preemption imbalance ");
preempt_count_set(count);
}
if (irqs_disabled()) {
strlcat(msgbuf, "disabled interrupts ", sizeof(msgbuf));
local_irq_enable();
}
WARN(msgbuf[0], "initcall %pF returned with %s\n", fn, msgbuf);
return ret;
}当然如果你想追do_pre_smp_initcalls在那调用，以及它的调用者在那调用，其实就很简单了。这里就不贴代码了。
看一下系统的早期初始化次序的内容
extern initcall_t __initcall_start[];
extern initcall_t __initcall0_start[];
extern initcall_t __initcall1_start[];
extern initcall_t __initcall2_start[];
extern initcall_t __initcall3_start[];
extern initcall_t __initcall4_start[];
extern initcall_t __initcall5_start[];
extern initcall_t __initcall6_start[];
extern initcall_t __initcall7_start[];
extern initcall_t __initcall_end[];
static initcall_t *initcall_levels[] __initdata = {
__initcall0_start,
__initcall1_start,
__initcall2_start,
__initcall3_start,
__initcall4_start,
__initcall5_start,
__initcall6_start,
__initcall7_start,
__initcall_end,
};
/* Keep these in sync with initcalls in include/linux/init.h */
static char *initcall_level_names[] __initdata = {
"early", /* 早期的 */
"core", /* 核心 */
"postcore", /* 核心内容 */
"arch", /* 架构相关的 */
"subsys", /* 子系统 */
"fs", /* 文件系统 */
"device", /* 设备,驱动 */
"late", /* 不是特别重要的 */
};
除了erlay的其它的都被定义在了一个数组中,很明显,他们应该要一块按次序调用初始化
/* 每个level里面又有好多的具体的 initcallx.init修饰的函数被调用 */
static void __init do_initcall_level(int level)
{
extern const struct kernel_param __start___param[], __stop___param[];
initcall_t *fn;
strcpy(initcall_command_line, saved_command_line);
parse_args(initcall_level_names[level],
initcall_command_line, __start___param,
__stop___param - __start___param,
level, level,
&repair_env_string);
for (fn = initcall_levels[level]; fn < initcall_levels[level+1]; fn++)
do_one_initcall(*fn); /* 可以看到最终还是调用了通用的单个执行函数 */
}
/* 这里是调用八次level */
static void __init do_initcalls(void)
{
int level;
for (level = 0; level < ARRAY_SIZE(initcall_levels) - 1; level++)
do_initcall_level(level);
}关于许可证
MODULE_LICENSE("GPL");在装载驱动时，系统会调用这函数对比符号表的里面的LINENSE信息，如果不对，可能驱动会安装失败。
MODULE_LICENSE("GPL"); // "GPL" 是指明了 这是GNU General Public License的任意版本
MODULE_AUTHOR("xxx") // 声明作者
MODULE_DESCRIPTION("xxx") // 对这个模块作一个简单的描述，这个描述是"human-readable"的
MODULE_VERSION("xxx") // 这个模块的版本
MODULE_ALIAS("xxx") // 这个模块的别名
MODULE_DEVICE_TABLE("xxx") // 告诉用户空间这个模块支持什么样的设备
MODULE_声明可以写在模块的任何地方（但必须在函数外面），但是惯例是写在模块最后。驱动程序没有LICENSE信息，加载会失败。但卸载加载失败的驱动，再次加载就又不报错了。可见内核对license的检测并不严格。
关于驱动程序的Makefile
KERN_DIR = /home/run/work/kernel/linux-3.16.57
.PHONY:all
all:
make -C $(KERN_DIR) M=`pwd` modules
.PHONY:clean
clean:
make -C $(KERN_DIR) M=`pwd` modules clean
obj-m += first_drv.oKERN_DIR=xxxx/xxxx/kernel/linux-3.16.57，这句是定义变量KERN_DIR，确定后面使用内核源码时的内核源码路径。
make -C $(KERN_DIR) M='pwd' modules，这句是makefile的规则：-C选项的作用是指将当前工作目录转移到你所指定的位置，当make的目标为all时，-C $(KDIR) 指明跳转到内核源码目录下读取那里的Makefile。
M=`pwd` 表明然后从内核makefile中返回到当前目录继续读入、执行当前的Makefile。M是内核根目录下的Makefile中使用的变量，"M="选项的作用是，当用户需要以某个内核为基础编译一个外部模块的话，需要在make modules命令中加入"m=dir"，程序会自动到你所指定的dir目录中查找模块源码，将其编译，生成ko文件。M=‘pwd’这句话是用来制定我们编译的驱动的路径。
整个过程是，进入内核源码树读取顶层的Makefile，使用当前目录的obj-m文件，目标是 modules
即使用make modules 命令，用原码树的Makefiel规则，编译当前的目录下的obj-m文件
常用的有
关于装载卸载命令
depmod xxx 可检测模块的相依性，供modprobe在安装模块时使用
insmod xxx 装载驱动
rmmod xxx 卸载驱动
modinfor xxx 查看驱动信息
modprob xxx modprobe会根据depmod所产生的相依关系，决定要载入哪些模块。若在载入过程中发生错误，在modprobe会卸载整组的模块。
lsmod 列出当前已经安装的模块
insmod 与 modprobe 都是载入 kernel module，不过一般差别于 modprobe 能够处理 module 载入的相依问题。
比方你要载入 a module，但是 a module 要求系统先载入 b module 时，直接用 insmod 挂入通常都会出现错误讯息，
不过 modprobe 倒是能够知道先载入 b module 后才载入 a module，如此相依性就会满足。
不过 modprobe 并不是大神，不会厉害到知道 module 之间的相依性为何，该程式是读取 /lib/modules/2.6.xx/modules.dep
档案得知相依性的。而该档案是透过 depmod 程式所建立。
modprobe默认会去/lib/modules/目录下面查找module，而insmod只在给它的参数中去找module（默认在当前目录找）。
无法查看驱动信息，主要是没有在/lib/modules/3.16.57/目录找到modules.dep
处理方法
后面给出上面用到的完整的vmlinux.lds链接脚本文件（去掉了前后注释，否则太长）
OUTPUT_ARCH(arm)
ENTRY(stext)
jiffies = jiffies_64;
SECTIONS
{
/*
* XXX: The linker does not define how output sections are
* assigned to input sections when there are multiple statements
* matching the same input section name. There is no documented
* order of matching.
*
* unwind exit sections must be discarded before the rest of the
* unwind sections get included.
*/
/DISCARD/ : {
*(.ARM.exidx.exit.text)
*(.ARM.extab.exit.text)
*(.ARM.exidx.cpuexit.text)
*(.ARM.extab.cpuexit.text)
*(.exitcall.exit)
*(.alt.smp.init)
*(.discard)
*(.discard.*)
}
. = 0x80000000 + 0x00008000;
.head.text : {
_text = .;
*(.head.text)
}
.text : { /* Real text segment */
_stext = .; /* Text and read-only data */
__exception_text_start = .;
*(.exception.text)
__exception_text_end = .;
. = ALIGN(8); *(.text.hot) *(.text) *(.ref.text) *(.text.unlikely)
. = ALIGN(8); __sched_text_start = .; *(.sched.text) __sched_text_end = .;
. = ALIGN(8); __lock_text_start = .; *(.spinlock.text) __lock_text_end = .;
. = ALIGN(8); __kprobes_text_start = .; *(.kprobes.text) __kprobes_text_end = .;
. = ALIGN(8); __idmap_text_start = .; *(.idmap.text) __idmap_text_end = .; . = ALIGN(32); __hyp_idmap_text_start = .; *(.hyp.idmap.text) __hyp_idmap_text_end = .;
*(.fixup)
*(.gnu.warning)
*(.glue_7)
*(.glue_7t)
. = ALIGN(4);
*(.got) /* Global offset table */
}
. = ALIGN(((1 << 12))); .rodata : AT(ADDR(.rodata) - 0) { __start_rodata = .; *(.rodata) *(.rodata.*) *(__vermagic) . = ALIGN(8); __start___tracepoints_ptrs = .; *(__tracepoints_ptrs) __stop___tracepoints_ptrs = .; *(__tracepoints_strings) } .rodata1 : AT(ADDR(.rodata1) - 0) { *(.rodata1) } . = ALIGN(8); __bug_table : AT(ADDR(__bug_table) - 0) { __start___bug_table = .; *(__bug_table) __stop___bug_table = .; } .pci_fixup : AT(ADDR(.pci_fixup) - 0) { __start_pci_fixups_early = .; *(.pci_fixup_early) __end_pci_fixups_early = .; __start_pci_fixups_header = .; *(.pci_fixup_header) __end_pci_fixups_header = .; __start_pci_fixups_final = .; *(.pci_fixup_final) __end_pci_fixups_final = .; __start_pci_fixups_enable = .; *(.pci_fixup_enable) __end_pci_fixups_enable = .; __start_pci_fixups_resume = .; *(.pci_fixup_resume) __end_pci_fixups_resume = .; __start_pci_fixups_resume_early = .; *(.pci_fixup_resume_early) __end_pci_fixups_resume_early = .; __start_pci_fixups_suspend = .; *(.pci_fixup_suspend) __end_pci_fixups_suspend = .; } .builtin_fw : AT(ADDR(.builtin_fw) - 0) { __start_builtin_fw = .; *(.builtin_fw) __end_builtin_fw = .; } __ksymtab : AT(ADDR(__ksymtab) - 0) { __start___ksymtab = .; *(SORT(___ksymtab+*)) __stop___ksymtab = .; } __ksymtab_gpl : AT(ADDR(__ksymtab_gpl) - 0) { __start___ksymtab_gpl = .; *(SORT(___ksymtab_gpl+*)) __stop___ksymtab_gpl = .; } __ksymtab_unused : AT(ADDR(__ksymtab_unused) - 0) { __start___ksymtab_unused = .; *(SORT(___ksymtab_unused+*)) __stop___ksymtab_unused = .; } __ksymtab_unused_gpl : AT(ADDR(__ksymtab_unused_gpl) - 0) { __start___ksymtab_unused_gpl = .; *(SORT(___ksymtab_unused_gpl+*)) __stop___ksymtab_unused_gpl = .; } __ksymtab_gpl_future : AT(ADDR(__ksymtab_gpl_future) - 0) { __start___ksymtab_gpl_future = .; *(SORT(___ksymtab_gpl_future+*)) __stop___ksymtab_gpl_future = .; } __kcrctab : AT(ADDR(__kcrctab) - 0) { __start___kcrctab = .; *(SORT(___kcrctab+*)) __stop___kcrctab = .; } __kcrctab_gpl : AT(ADDR(__kcrctab_gpl) - 0) { __start___kcrctab_gpl = .; *(SORT(___kcrctab_gpl+*)) __stop___kcrctab_gpl = .; } __kcrctab_unused : AT(ADDR(__kcrctab_unused) - 0) { __start___kcrctab_unused = .; *(SORT(___kcrctab_unused+*)) __stop___kcrctab_unused = .; } __kcrctab_unused_gpl : AT(ADDR(__kcrctab_unused_gpl) - 0) { __start___kcrctab_unused_gpl = .; *(SORT(___kcrctab_unused_gpl+*)) __stop___kcrctab_unused_gpl = .; } __kcrctab_gpl_future : AT(ADDR(__kcrctab_gpl_future) - 0) { __start___kcrctab_gpl_future = .; *(SORT(___kcrctab_gpl_future+*)) __stop___kcrctab_gpl_future = .; } __ksymtab_strings : AT(ADDR(__ksymtab_strings) - 0) { *(__ksymtab_strings) } __init_rodata : AT(ADDR(__init_rodata) - 0) { *(.ref.rodata) } __param : AT(ADDR(__param) - 0) { __start___param = .; *(__param) __stop___param = .; } __modver : AT(ADDR(__modver) - 0) { __start___modver = .; *(__modver) __stop___modver = .; . = ALIGN(((1 << 12))); __end_rodata = .; } . = ALIGN(((1 << 12)));
. = ALIGN(4);
__ex_table : AT(ADDR(__ex_table) - 0) {
__start___ex_table = .;
*(__ex_table)
__stop___ex_table = .;
}
/*
* Stack unwinding tables
*/
. = ALIGN(8);
.ARM.unwind_idx : {
__start_unwind_idx = .;
*(.ARM.exidx*)
__stop_unwind_idx = .;
}
.ARM.unwind_tab : {
__start_unwind_tab = .;
*(.ARM.extab*)
__stop_unwind_tab = .;
}
.notes : AT(ADDR(.notes) - 0) { __start_notes = .; *(.note.*) __stop_notes = .; }
_etext = .; /* End of text and rodata section */
. = ALIGN((1 << 12));
__init_begin = .;
/*
* The vectors and stubs are relocatable code, and the
* only thing that matters is their relative offsets
*/
__vectors_start = .;
.vectors 0 : AT(__vectors_start) {
*(.vectors)
}
. = __vectors_start + SIZEOF(.vectors);
__vectors_end = .;
__stubs_start = .;
.stubs 0x1000 : AT(__stubs_start) {
*(.stubs)
}
. = __stubs_start + SIZEOF(.stubs);
__stubs_end = .;
. = ALIGN(8); .init.text : AT(ADDR(.init.text) - 0) { _sinittext = .; *(.init.text) *(.meminit.text) _einittext = .; }
.exit.text : {
*(.exit.text) *(.memexit.text)
}
.init.proc.info : {
. = ALIGN(4); __proc_info_begin = .; *(.proc.info.init) __proc_info_end = .;
}
.init.arch.info : {
__arch_info_begin = .;
*(.arch.info.init)
__arch_info_end = .;
}
.init.tagtable : {
__tagtable_begin = .;
*(.taglist.init)
__tagtable_end = .;
}
.init.pv_table : {
__pv_table_begin = .;
*(.pv_table)
__pv_table_end = .;
}
.init.data : {
*(.init.data) *(.meminit.data) *(.init.rodata) *(.meminit.rodata) . = ALIGN(32); __dtb_start = .; *(.dtb.init.rodata) __dtb_end = .;
. = ALIGN(16); __setup_start = .; *(.init.setup) __setup_end = .;
__initcall_start = .; *(.initcallearly.init) __initcall0_start = .; *(.initcall0.init) *(.initcall0s.init) __initcall1_start = .; *(.initcall1.init) *(.initcall1s.init) __initcall2_start = .; *(.initcall2.init) *(.initcall2s.init) __initcall3_start = .; *(.initcall3.init) *(.initcall3s.init) __initcall4_start = .; *(.initcall4.init) *(.initcall4s.init) __initcall5_start = .; *(.initcall5.init) *(.initcall5s.init) __initcallrootfs_start = .; *(.initcallrootfs.init) *(.initcallrootfss.init) __initcall6_start = .; *(.initcall6.init) *(.initcall6s.init) __initcall7_start = .; *(.initcall7.init) *(.initcall7s.init) __initcall_end = .;
__con_initcall_start = .; *(.con_initcall.init) __con_initcall_end = .;
__security_initcall_start = .; *(.security_initcall.init) __security_initcall_end = .;
. = ALIGN(4); __initramfs_start = .; *(.init.ramfs) . = ALIGN(8); *(.init.ramfs.info)
}
.exit.data : {
*(.exit.data) *(.memexit.data) *(.memexit.rodata)
}
__init_end = .;
. = ALIGN(8192);
__data_loc = .;
.data : AT(__data_loc) {
_data = .; /* address in memory */
_sdata = .;
/*
* first, the init task union, aligned
* to an 8192 byte boundary.
*/
. = ALIGN(8192); *(.data..init_task)
. = ALIGN((1 << 12)); __nosave_begin = .; *(.data..nosave) . = ALIGN((1 << 12)); __nosave_end = .;
. = ALIGN((1 << 6)); *(.data..cacheline_aligned)
. = ALIGN((1 << 6)); *(.data..read_mostly) . = ALIGN((1 << 6));
/*
* and the usual data section
*/
*(.data) *(.ref.data) *(.data..shared_aligned) *(.data.unlikely) . = ALIGN(32); *(__tracepoints) . = ALIGN(8); __start___jump_table = .; *(__jump_table) __stop___jump_table = .; . = ALIGN(8); __start___verbose = .; *(__verbose) __stop___verbose = .;
CONSTRUCTORS
_edata = .;
}
_edata_loc = __data_loc + SIZEOF(.data);
. = ALIGN(0); __bss_start = .; . = ALIGN(0); .sbss : AT(ADDR(.sbss) - 0) { *(.sbss) *(.scommon) } . = ALIGN(0); .bss : AT(ADDR(.bss) - 0) { *(.bss..page_aligned) *(.dynbss) *(.bss) *(COMMON) } . = ALIGN(0); __bss_stop = .;
_end = .;
.stab 0 : { *(.stab) } .stabstr 0 : { *(.stabstr) } .stab.excl 0 : { *(.stab.excl) } .stab.exclstr 0 : { *(.stab.exclstr) } .stab.index 0 : { *(.stab.index) } .stab.indexstr 0 : { *(.stab.indexstr) } .comment 0 : { *(.comment) }
.comment 0 : { *(.comment) }
}