构建嵌入式linux系统pdf

Ⅰ “干货”嵌入式linux系统移植的四大步骤（上）

在学习系统移植的相关知识，在学习和调试过程中，发现了很多问题，也解决了很多问题，但总是对于我们的开发结果有一种莫名其妙的感觉，纠其原因，主要对于我们的开发环境没有一个深刻的认识，有时候几个简单的命令就可以完成非常复杂的功能，可是我们有没有想过，为什么会有这样的效果？

如果没有去追问，只是机械地完成，并且看到实验效果，这样做其实并没有真正的掌握系统移植的本质。

在做每一个步骤的时候， 首先问问自己，为什么要这样做，然后再问问自己正在做什么？ 搞明白这几个问题，我觉得就差不多了，以后不管更换什么平台，什么芯片，什么开发环境，你都不会迷糊，很快就会上手。对于嵌入式的学习方法，我个人方法就是：从宏观上把握(解决为什么的问题)，微观上研究(解决正在做什么的问题)，下面以自己学习的arm-cortex_a8开发板为目标，介绍下自己的学习方法和经验。

嵌入式Linux系统移植主要由四大部分组成：

一、搭建交叉开发环境
二、bootloader的选择和移植
三、kernel的配置、编译、和移植
四、根文件系统的制作

第一部分：搭建交叉开发环境

先介绍第一分部的内容：搭建交叉开发环境，首先必须得思考两个问题，什么是交叉环境? 为什么需要搭建交叉环境？

先回答第一个问题，在嵌入式开发中，交叉开发是很重要的一个概念，开发的第一个环节就是搭建环境，第一步不能完成，后面的步骤从无谈起，这里所说的交叉开发环境主要指的是：在开发主机上(通常是我的pc机)开发出能够在目标机(通常是我们的开发板)上运行的程序。嵌入式比较特殊的是不能在目标机上开发程序(狭义上来说)，因为对于一个原始的开发板，在没有任何程序的情况下它根本都跑不起来，为了让它能够跑起来，我们还必须要借助pc机进行烧录程序等相关工作，开发板才能跑起来，这里的pc机就是我们说的开发主机，想想如果没有开发主机，我们的目标机基本上就是无法开发，这也就是电子行业的一句名言：搞电子，说白了，就是玩电脑！

然后回答第二个问题，为什么需要交叉开发环境？主要原因有以下几点：

原因 1： 嵌入式系统的硬件资源有很多限制，比如cpu主频相对较低，内存容量较小等，想想让几百MHZ主频的MCU去编译一个Linux kernel会让我们等的不耐烦，相对来说，pc机的速度更快，硬件资源更加丰富，因此利用pc机进行开发会提高开发效率。

原因2： 嵌入式系统MCU体系结构和指令集不同，因此需要安装交叉编译工具进行编译，这样编译的目标程序才能够在相应的平台上比如：ARM、MIPS、 POWEPC上正常运行。

交叉开发环境的硬件组成主要由以下几大部分 ：

1.开发主机
2.目标机（开发板）
3.二者的链接介质，常用的主要有3种方式：(1)串口线 (2)USB线 (3)网线

对应的硬件介质，还必须要有相应的软件“介质”支持：

1.对于串口，通常用的有串口调试助手，putty工具等，工具很多，功能都差不多，会用一两款就可以；

2.对于USB线，当然必须要有USB的驱动才可以，一般芯片公司会提供，比如对于三星的芯片，USB下载主要由DNW软件来完成；

3.对于网线，则必须要有网络协议支持才可以， 常用的服务主要两个

第一：tftp服务：

主要用于实现文件的下载，比如开发调试的过程中，主要用tftp把要测试的bootloader、kernel和文件系统直接下载到内存中运行，而不需要预先烧录到Flash芯片中，一方面，在测试的过程中，往往需要频繁的下载，如果每次把这些要测试的文件都烧录到Flash中然后再运行也可以，但是缺点是：过程比较麻烦，而且Flash的擦写次数是有限的；另外一方面：测试的目的就是把这些目标文件加载到内存中直接运行就可以了，而tftp就刚好能够实现这样的功能，因此，更没有必要把这些文件都烧录到Flash中去。

第二： nfs服务：

主要用于实现网络文件的挂载，实际上是实现网络文件的共享，在开发的过程中，通常在系统移植的最后一步会制作文件系统，那么这是可以把制作好的文件系统放置在我们开发主机PC的相应位置，开发板通过nfs服务进行挂载，从而测试我们制作的文件系统是否正确，在整个过程中并不需要把文件系统烧录到Flash中去，而且挂载是自动进行挂载的，bootload启动后，kernel运行起来后会根据我们设置的启动参数进行自动挂载，因此，对于开发测试来讲，这种方式非常的方便，能够提高开发效率。

另外，还有一个名字叫 samba 的服务也比较重要，主要用于文件的共享，这里说的共享和nfs的文件共享不是同一个概念，nfs的共享是实现网络文件的共享，而samba实现的是开发主机上 Windows主机和Linux虚拟机之间的文件共享，是一种跨平台的文件共享 ，方便的实现文件的传输。

以上这几种开发的工具在嵌入式开发中是必备的工具，对于嵌入式开发的效率提高做出了伟大的贡献，因此，要对这几个工具熟练使用，这样你的开发效率会提高很多。等测试完成以后，就会把相应的目标文件烧录到Flash中去，也就是等发布产品的时候才做的事情，因此对于开发人员来说，所有的工作永远是测试。

通过前面的工作，我们已经准备好了交叉开发环境的硬件部分和一部分软件，最后还缺少交叉编译器，读者可能会有疑问，为什么要用交叉编译器？前面已经讲过，交叉开发环境必然会用到交叉编译工具，通俗地讲就是在一种平台上编译出能运行在体系结构不同的另一种平台上的程序，开发主机PC平台（X86 CPU）上编译出能运行在以ARM为内核的CPU平台上的程序，编译得到的程序在X86 CPU平台上是不能运行的，必须放到ARM CPU平台上才能运行，虽然两个平台用的都是Linux系统。相对于交叉编译，平常做的编译叫本地编译，也就是在当前平台编译，编译得到的程序也是在本地执行。用来编译这种跨平台程序的编译器就叫交叉编译器，相对来说，用来做本地编译的工具就叫本地编译器。所以要生成在目标机上运行的程序，必须要用交叉编译工具链来完成。

这里又有一个问题，不就是一个交叉编译工具吗？为什么又叫交叉工具链呢？原因很简单，程序不能光编译一下就可以运行，还得进行汇编和链接等过程，同时还需要进行调试，对于一个很大工程，还需要进行工程管理等等，所以，这里 说的交叉编译工具是一个由 编译器、连接器和解释器 组成的综合开发环境，交叉编译工具链主要由binutils(主要包括汇编程序as和链接程序ld)、gcc(为GNU系统提供C编译器)和glibc(一些基本的C函数和其他函数的定义) 3个部分组成。有时为了减小libc库的大小，也可以用别的 c 库来代替 glibc，例如 uClibc、dietlibc 和 newlib。

那么，如何得到一个交叉工具链呢？是从网上下载一个“程序”然后安装就可以使用了吗？回答这个问题之前先思考这样一个问题，我们的交叉工具链顾名思义就是在PC机上编译出能够在我们目标开发平台比如ARM上运行的程序，这里就又有一个问题了，我们的ARM处理器型号非常多，难道有专门针对我们某一款的交叉工具链吗？若果有的话，可以想一想，这么多处理器平台，每个平台专门定制一个交叉工具链放在网络上，然后供大家去下载，想想可能需要找很久才能找到适合你的编译器，显然这种做法不太合理，且浪费资源！因此，要得到一个交叉工具链，就像我们移植一个Linux内核一样，我们只关心我们需要的东西，编译我们需要的东西在我们的平台上运行，不需要的东西我们不选择不编译，所以，交叉工具链的制作方法和系统移植有着很多相似的地方，也就是说，交叉开发工具是一个支持很多平台的工具集的集合(类似于Linux源码)，然后我们只需从这些工具集中找出跟我们平台相关的工具就行了，那么如何才能找到跟我们的平台相关的工具，这就是涉及到一个如何制作交叉工具链的问题了。

通常构建交叉工具链有如下三种方法：

方法一 ： 分步编译和安装交叉编译工具链所需要的库和源代码，最终生成交叉编译工具链。该方法相对比较困难，适合想深入学习构建交叉工具链的读者。如果只是想使用交叉工具链，建议使用下列的方法二构建交叉工具链。

方法二： 通过Crosstool-ng脚本工具来实现一次编译，生成交叉编译工具链，该方法相对于方法一要简单许多，并且出错的机会也非常少，建议大多数情况下使用该方法构建交叉编译工具链。

方法三 ： 直接通过网上下载已经制作好的交叉编译工具链。该方法的优点不用多说，当然是简单省事，但与此同时该方法有一定的弊端就是局限性太大，因为毕竟是别人构建好的，也就是固定的，没有灵活性，所以构建所用的库以及编译器的版本也许并不适合你要编译的程序，同时也许会在使用时出现许多莫名其妙的错误，建议读者慎用此方法。

crosstool-ng是一个脚本工具，可以制作出适合不同平台的交叉编译工具链，在进行制作之前要安装一下软件：
$ sudo apt-get install g++ libncurses5-dev bison flex texinfo automake libtool patch gcj cvs cvsd gawk
crosstool脚本工具可以在http://ymorin.is-a-geek.org/projects/crosstool下载到本地，然后解压，接下来就是进行安装配置了，这个配置优点类似内核的配置。主要的过程有以下几点：
1. 设定源码包路径和交叉编译器的安装路径
2. 修改交叉编译器针对的构架

3. 增加编译时的并行进程数，以增加运行效率，加快编译，因为这个编译会比较慢。
4. 关闭JAVA编译器 ，减少编译时间
5. 编译
6. 添加环境变量
7. 刷新环境变量。
8. 测试交叉工具链

到此，嵌入式Linux系统移植四大部分的第一部分工作全部完成，接下来可以进行后续的开发了。

第二部分：bootloader的选择和移植

01 Boot Loader 概念

就是在操作系统内核运行之前运行的一段小程序。通过这段小程序，我们可以初始化硬件设备、建立内存空间的映射图，从而将系统的软硬件环境带到一个合适的状态，以便为最终调用操作系统内核准备好正确的环境，他就是所谓的引导加载程序（Boot Loader）。

02 为什么系统移植之前要先移植BootLoader？

BootLoader的任务是引导操作系统，所谓引导操作系统，就是启动内核，让内核运行就是把内核加载到内存RAM中去运行，那先问两个问题：第一个问题，是谁把内核搬到内存中去运行？第二个问题：我们说的内存是SDRAM，大家都知道，这种内存和SRAM不同，最大的不同就是SRAM只要系统上电就可以运行，而SDRAM需要软件进行初始化才能运行，那么在把内核搬运到内存运行之前必须要先初始化内存吧，那么内存是由谁来初始化的呢？其实这两件事情都是由bootloader来干的，目的是为内核的运行准备好软硬件环境，没有bootloadr我们的系统当然不能跑起来。

03 bootloader的分类

首先更正一个错误的说法，很多人说bootloader就是U-boot，这种说法是错误的，确切来说是u-boot是bootloader的一种。也就是说bootloader具有很多种类，

由上图可以看出，不同的bootloader具有不同的使用范围，其中最令人瞩目的就是有一个叫U-Boot的bootloader，是一个通用的引导程序，而且同时支持X86、ARM和PowerPC等多种处理器架构。U-Boot，全称 Universal Boot Loader，是遵循GPL条款的开放源码项目，是由德国DENX小组开发的用于多种嵌入式CPU的bootloader程序，对于Linux的开发，德国的u-boot做出了巨大的贡献，而且是开源的。

u-boot具有以下特点：

① 开放源码；
② 支持多种嵌入式操作系统内核，如Linux、NetBSD, VxWorks, QNX, RTEMS, ARTOS, LynxOS；
③ 支持多个处理器系列，如PowerPC、ARM、x86、MIPS、XScale；
④ 较高的可靠性和稳定性；
⑤ 高度灵活的功能设置，适合U-Boot调试、操作系统不同引导要求、产品发布等；
⑥ 丰富的设备驱动源码，如串口、以太网、SDRAM、FLASH、LCD、NVRAM、EEPROM、RTC、键盘等；
⑦ 较为丰富的开发调试文档与强大的网络技术支持；
其实，把u-boot可以理解为是一个小型的操作系统。

04 u-boot的目录结构

* board 目标板相关文件，主要包含SDRAM、FLASH驱动；
* common 独立于处理器体系结构的通用代码，如内存大小探测与故障检测；
* cpu 与处理器相关的文件。如mpc8xx子目录下含串口、网口、LCD驱动及中断初始化等文件；
* driver 通用设备驱动，如CFI FLASH驱动(目前对INTEL FLASH支持较好)
* doc U-Boot的说明文档；
* examples可在U-Boot下运行的示例程序；如hello_world.c,timer.c；
* include U-Boot头文件；尤其configs子目录下与目标板相关的配置头文件是移植过程中经常要修改的文件；
* lib_xxx 处理器体系相关的文件，如lib_ppc, lib_arm目录分别包含与PowerPC、ARM体系结构相关的文件；
* net 与网络功能相关的文件目录，如bootp,nfs,tftp；
* post 上电自检文件目录。尚有待于进一步完善；
* rtc RTC驱动程序；
* tools 用于创建U-Boot S-RECORD和BIN镜像文件的工具；

05 u-boot的工作模式

U-Boot的工作模式有 启动加载模式和下载模式 。启动加载模式是Bootloader的正常工作模式，嵌入式产品发布时，Bootloader必须工作在这种模式下，Bootloader将嵌入式操作系统从FLASH中加载到SDRAM中运行，整个过程是自动的。 下载模式 就是Bootloader通过某些通信手段将内核映像或根文件系统映像等从PC机中下载到目标板的SDRAM中运行，用户可以利用Bootloader提供的一些令接口来完成自己想要的操作，这种模式主要用于测试和开发。

06 u-boot的启动过程

大多数BootLoader都分为stage1和stage2两大部分，U-boot也不例外。依赖于cpu体系结构的代码（如设备初始化代码等）通常都放在stage1且可以用汇编语言来实现，而stage2则通常用C语言来实现，这样可以实现复杂的功能，而且有更好的可读性和移植性。

1、 stage1(start.s代码结构)
U-boot的stage1代码通常放在start.s文件中，它用汇编语言写成，其主要代码部分如下：
（1） 定义入口。由于一个可执行的image必须有一个入口点，并且只能有一个全局入口，通常这个入口放在rom(Flash)的0x0地址，因此，必须通知编译器以使其知道这个入口，该工作可通过修改连接器脚本来完成。
（2）设置异常向量(exception vector)。
（3）设置CPU的速度、时钟频率及中断控制寄存器。
（4）初始化内存控制器 。
（5）将rom中的程序复制到ram中。
（6）初始化堆栈 。
（7）转到ram中执行，该工作可使用指令ldrpc来完成。

2、 stage2（C语言代码部分）

lib_arm/board.c中的start armboot是C语言开始的函数，也是整个启动代码中C语言的主函数，同时还是整个u-boot（armboot）的主函数，该函数主要完成如下操作：
（1）调用一系列的初始化函数。
（2）初始化flash设备。
（3）初始化系统内存分配函数。
（4）如果目标系统拥有nand设备，则初始化nand设备。
（5）如果目标系统有显示设备，则初始化该类设备。
（6）初始化相关网络设备，填写ip,c地址等。
（7）进入命令循环（即整个boot的工作循环），接受用户从串口输入的命令，然后进行相应的工作。

07 基于cortex-a8的s5pc100bootloader启动过程分析

s5pc100支持两种启动方式，分别为USB启动方式和NandFlash启动方式：

1. S5PC100 USB启动过程

[1] A8 reset, 执行iROM中的程序
[2] iROM中的程序根据S5PC100的配置管脚(SW1开关4，拨到4对面)，判断从哪里启动(USB)
[3] iROM中的程序会初始化USB，然后等待PC机下载程序
[4] 利用DNW程序，从PC机下载SDRAM的初始化程序到iRAM中运行，初始化SDRAM
[5] SDRAM初始化完毕，iROM中的程序继续接管A8, 然后等待PC下载程序(BootLoader)
[6] PC利用DNW下载BootLoader到SDRAM
[7] 在SDRAM中运行BootLoader

2. S5PC100 Nandflash启动过程

[1] A8 reset, 执行IROM中的程序
[2] iROM中的程序根据S5PC100的配置管脚(SW1开关4，拨到靠4那边)，判断从哪里启动(Nandflash)
[3] iROM中的程序驱动Nandflash
[4] iROM中的程序会拷贝Nandflash前16k到iRAM
[5] 前16k的程序(BootLoader前半部分)初始化SDRAM，然后拷贝完整的BootLoader到SDRAM并运行
[6] BootLoader拷贝内核到SDRAM，并运行它
[7] 内核运行起来后，挂载rootfs，并且运行系统初始化脚本

08 u-boot移植(基于cortex_a8的s5pc100为例)

1.建立自己的平台

(1).下载源码包2010.03版本，比较稳定
(2).解压后添加我们自己的平台信息，以smdkc100为参考版，移植自己s5pc100的开发板
(3).修改相应目录的文件名，和相应目录的Makefile，指定交叉工具链。
(4).编译
(5).针对我们的平台进行相应的移植，主要包括修改SDRAM的运行地址，从0x20000000
(6).“开关”相应的宏定义
(7).添加Nand和网卡的驱动代码
(8).优化go命令
(9).重新编译 make distclean(彻底删除中间文件和配置文件) make s5pc100_config(配置我们的开发板) make(编译出我们的u-boot.bin镜像文件)
(10).设置环境变量，即启动参数，把编译好的u-boot下载到内存中运行，过程如下：
1. 配置开发板网络
ip地址配置:
$setenv ipaddr 192.168.0.6 配置ip地址到内存的环境变量
$saveenv 保存环境变量的值到nandflash的参数区

网络测试:
在开发开发板上ping虚拟机：
$ ping 192.168.0.157(虚拟机的ip地址)

如果网络测试失败,从下面几个方面检查网络：
1. 网线连接好
2. 开发板和虚拟机的ip地址是否配置在同一个网段
3. 虚拟机网络一定要采用桥接(VM--Setting-->option)
4. 连接开发板时，虚拟机需要设置成 静态ip地址

2. 在开发板上，配置tftp服务器(虚拟机)的ip地址
$setenv serverip 192.168.0.157(虚拟机的ip地址)
$saveenv
3. 拷贝u-boot.bin到/tftpboot(虚拟机上的目录)
4. 通过tftp下载u-boot.bin到开发板内存
$ tftp 20008000(内存地址即可) u-boot.bin(要下载的文件名)

如果上面的命令无法正常下载:
1. serverip配置是否正确
2. tftp服务启动失败，重启tftp服务
#sudo service tftpd-hpa restart

5. 烧写u-boot.bin到nandflash的0地址
$nand erase 0(起始地址) 40000(大小) 擦出nandflash 0 - 256k的区域
$nand write 20008000((缓存u-boot.bin的内存地址) 0(nandflash上u-boot的位置) 40000(烧写大小)

6. 切换开发板的启动方式到nandflash
1. 关闭开发板
2. 把SW1的开关4拨到4的那边
3. 启动开发板，它就从nandflash启动

Ⅱ Linux嵌入式系统开发的目录

第1章 嵌入式系统概述 1
1.1 嵌入式系统的概念 1
1.1.1 嵌入式系统的定义 1
1.1.2 嵌入式系统的特点 2
1.2 嵌入式系统的组成 2
1.2.1 嵌入式处理器 2
1.2.2 外围设备 3
1.2.3 嵌入式操作系统 3
1.2.4 应用软件 3
1.3 嵌入式处理器 4
1.3.1 嵌入式处理器的分类 4
1.3.2 嵌入式微处理器 5
1.3.3 嵌入式微控制器 5
1.3.4 嵌入式DSP处理器 6
1.3.5 嵌入式片上系统 6
1.3.6 选择嵌入式处理器 7
1.4 嵌入式操作系统 7
1.4.1 操作系统的概念和分类 7
1.4.2 实时操作系统 8
1.4.3 常用的嵌入式操作系统 10
1.5 新型的嵌入式操作系统 13
1.5.1 Android 13
1.5.2 MontaVista 14
1.6 嵌入式系统的应用 15
1.7 嵌入式系统的发展趋势 18
1.7.1 嵌入式系统面临的挑战 18
1.7.2 嵌入式系统的发展前景 18
1.8 本章小结 19
第2章 嵌入式系统开发过程 20
2.1 嵌入式软件开发介绍 20
2.1.1 嵌入式软件开发的特殊性 20
2.1.2 嵌入式软件的分类 21
2.1.3 嵌入式软件的开发流程 21
2.1.4 嵌入式软件开发工具的发展趋势 23
2.2 嵌入式软件的调试技术 24
2.2.1 调试技术介绍 24
2.2.2 基于JTAG的ARM系统调试 25
2.3 嵌入式软件测试技术 26
2.3.1 宿主机-目标机开发模式 26
2.3.2 目标监控器 27
2.4 嵌入式系统集成开发环境 29
2.4.1 ADS的介绍 29
2.4.2 ADS建立工程的使用介绍 31
2.4.3 AXD调试器的使用介绍 36
实例2-1：ARM开发环境ADS的使用实例 38
2.5 本章小结 42
第3章 ARM体系结构 43
3.1 ARM体系结构概述 43
3.1.1 ARM体系结构简介 44
3.1.2 ARM体系结构的技术特征 46
3.1.3 CISC的体系结构 47
3.1.4 RISC的体系结构 47
3.1.5 RISC系统和CISC系统的比较 49
3.2 ARM微处理器的分类 50
3.2.1 ARM7微处理器 50
3.2.2 ARM9微处理器 51
3.2.3 ARM9E微处理器 51
3.2.4 ARM10E微处理器 52
3.2.5 ARM11微处理器 53
3.2.6 SecurCore微处理器 53
3.2.7 trongARM微处理器 53
3.2.8 XScale微处理器 54
3.3 ARM微处理器的应用 54
3.3.1 ARM微处理器的应用选型 54
3.3.2 S3C2410处理器 55
3.4 存储器 56
3.4. 1 存储器简介 56
3.4.2 SDRAM操作 58
3.4.3 Flash 59
3.5 ARM编程模型 60
3.5.1 数据类型 60
3.5.2 存储器格式 61
3.5.3 处理器工作状态 61
3.5.4 处理器运行模式 62
3.5.5 寄存器组织 62
3.5.6 内部寄存器 65
3.6 ARM指令的寻址方式 66
3.6.1 立即寻址 66
3.6.2 寄存器寻址 67
3.6.3 寄存器间接寻址 67
3.6.4 相对寻址 68
3.6.5 堆栈寻址 68
3.6.6 块复制寻址 69
3.6.7 变址寻址 69
3.6.8 多寄存器寻址 70
3.7 ARM指令集 70
3.7.1 ARM指令的格式 70
3.7.2 ARM指令分类 71
3.7.3 Thumb指令介绍 77
3.7.4 Thumb指令分类 78
3.7.5 ARM指令集和Thumb指令集的区别 81
3.8 ARM微处理器的异常 82
3.8.1 ARM体系结构所支持的异常类型 83
3.8.2 异常向量表 84
3.8.3 异常优先级 84
3.8.4 应用程序中的异常处理 85
3.8.5 各类异常的具体描述 86
3.9 本章小结 90
第4章 Linux基本操作 91
4.1 Linux系统的介绍 91
4.1.1 Linux的概况 91
4.1.2 Linux操作系统的构成 93
4.1.3 Linux常见的发行版本 94
4.1.4 Linux内核的特点 95
4.2 Linux命令的使用 96
4.3 vi编辑器的使用 106
4.3.1 vi编辑器的进入 107
4.3.2 命令模式的命令 107
4.3.3 末行模式的命令 108
实例4-1：vi编辑器使用实例 109
4.4 Shell编程 110
4.4.1 Shell基础介绍 110
4.4.2 Shell程序的变量和参数 113
4.4.3 运行Shell程序 114
4.4.4 Shell程序设计的流程控制 115
4.4.5 Shell输入与输出 120
4.4.6 bash介绍 121
4.5 综合实例 123
实例4-2：编写清除/var/log下的log文件综合实例 123
实例4-3：编写寻找死链接文件综合实例 126
4.6 本章小结 129
第5章 Linux进程 130
5.1 进程概述 130
5.1.1 进程结构 131
5.1.2 进程的控制操作 132
5.1.3 进程的属性 134
5.1.4 进程的创建和调度 135
5.1.5 Linux进程命令 137
5.2 系统调用 141
5.2.1 系统调用简述 141
5.2.2 系统调用的进入 142
5.2.3 与进程管理相关的系统调用 142
5.3 管道 143
5.3.1 管道系统调用 143
5.3.2 管道的分类 144
实例5-1：管道通信实例 145
5.4 信号 147
5.4.1 常见的信号种类 147
5.4.2 系统调用函数 148
5.4.3 信号的处理 149
5.4.4 信号与系统调用的关系 150
实例5-2：信号实例 151
5.5 信号量 152
5.5.1 信号量概述 152
5.5.2 相关的数据结构 153
5.5.3 相关的函数 155
实例5-3：信号量实例 156
5.6 共享内存 161
5.6.1 共享内存原理 161
5.6.2 共享内存对象的结构 162
5.6.3 相关的函数 162
实例5-4：共享内存实例 163
5.7 消息队列 169
5.7.1 有关的数据结构 169
5.7.2 相关的函数 171
实例5-5：消息队列实例 173
5.8 综合实例 177
实例5-6：多线程编程实例 177
5.9 本章小结 178
第6章 建立Linux开发环境 179
6.1 建立Linux开发环境 179
6.1.1 Cygwin开发环境 179
6.1.2 VMware Workstation开发环境 181
6.2 交叉编译的使用 183
6.2.1 GNU交叉工具链的设置 183
6.2.2 ARM GNU常用汇编语言 186
6.2.3 GNU交叉工具链的常用工具 188
6.2.4 交叉编译环境 191
6.3 Linux下的C编程 194
6.3.1 Linux程序设计特点 194
6.3.2 Linux下C语言编码的风格 195
6.3.3 Linux程序基础 195
6.3.4 Linux下C编程的库依赖 197
6.4 gcc的使用与开发 197
6.4.1 gcc简介和使用 197
6.4.2 gcc选项 198
6.4.3 gcc的错误类型 201
实例6-1：gcc编译器环境的应用实例 202
6.5 gdb调试器的介绍和使用 203
6.5.1 gdb调试器的使用 203
6.5.2 在gdb中运行程序 204
6.5.3 暂停和恢复程序运行 206
6.5.4 远程调试 209
实例6-2：gdb调试器环境的应用实例 209
6.6 GNU make和Makefile的使用 211
6.6.1 Makefile的基本结构 212
6.6.2 Makefile的变量 213
6.6.3 Makefile的隐含规则 215
6.6.4 Makefile的命令使用 218
6.6.5 Makefile的函数使用 219
6.6.6 Makefile文件的运行 221
6.6.7 Makefile规则书写命令 223
实例6-3：Makefile的命令使用实例 229
6.7 autoconf和automake的使用 231
6.7.1 autoconf的使用 231
6.7.2 Makefile的编写 234
6.7.3 automake的使用 234
6.7.4 使用automake和autoconf产生Makefile 235
6.7.5 自动生成Makefile的方法 235
6.8 综合实例 236
实例6-4：gcc编译器的综合实例 236
实例6-5：gdb调试器的综合实例 239
实例6-6：Makefile的综合实例 242
6.9 本章小结 244
第7章 Linux操作系统移植 245
7.1 移植的概念 245
7.1.1 Linux可移植性发展 246
7.1.2 Linux的移植性 246
7.2 Linux内核结构 247
7.2.1 Linux内核组成 247
7.2.2 子系统相互间的关系 251
7.2.3 系统数据结构 252
7.2.4 Linux内核源代码 252
7.3 Linux内核配置 256
实例7-1：Linux内核配置实例 256
7.4 Linux操作系统移植介绍 259
7.4.1 Linux系统移植的两大部分 259
7.4.2 内核文件的修改 261
7.4.3 系统移植所必需的环境 265
7.5 综合实例 268
实例7-2：编译Linux内核应用实例 268
实例7-3：Linux内核的烧写实例 270
实例7-4：使用Kgdb构建Linux内核调试环境 271
7.6 本章小结 280
第8章 Bootloader的使用 281
8.1 Bootloader 概述 281
8.1.1 Bootloader的作用 282
8.1.2 Bootloader的功能 283
8.1.3 Bootloader的种类 283
8.1.4 Bootloader的工作模式 285
8.1.5 Bootloader的启动方式 285
8.1.6 Bootloader的启动流程 287
8.1.7 Bootloader与主机的通信 287
8.2 vivi 287
8.2.1 vivi的常用命令和文件结构 288
8.2.2 vivi第一阶段的分析 288
8.2.3 vivi第二阶段的分析 295
8.2.4 vivi的配置与编译 297
8.3 U-boot 298
8.3.1 U-boot常用命令和源代码目录结构 298
8.3.2 U-boot支持的主要功能 301
8.3.3 U-boot的编译和添加命令 302
8.3.4 U-boot的启动介绍 305
8.3.5 U-boot的移植和使用 307
8.3.6 U-boot的启动过程 308
8.3.7 U-boot的调试 310
8.4 其他常见的Bootloader 312
8.5 综合实例 313
实例8-1：vivi编译实例 314
实例8-2：U-boot在S3C2410上的移植实例 315
实例8-3：Bootloader设计实例 317
8.6 本章小结 319
第9章 构建Linux根文件系统 320
9.1 Linux文件系统概述 320
9.1.1 Linux文件系统的特点 320
9.1.2 其他常见的嵌入式文件系统 322
9.1.3 Linux根文件目录结构 324
9.1.4 Linux文件属性介绍 324
9.2 使用BusyBox生成工具集 325
9.2.1 BusyBox概述 325
9.2.2 BusyBox进程和用户程序启动过程 326
9.2.3 编译/安装BusyBox 327
实例9-1：用BusyBox建立简单的根文件系统 331
9.3 构建根文件系统 333
实例9-2：构建根文件系统 337
9.4 配置yaffs文件 339
9.4.1 yaffs文件系统设置 340
9.4.2 yaffs文件系统测试 341
9.5 综合实例 343
实例9-3：制作/使用yaffs文件系统映像文件 343
实例9-4：制作/使用jffs2文件系统映像文件 345
9.6 本章小结 347
第10章 设备驱动程序开发 348
10.1 设备驱动程序概述 348
10.1.1 驱动程序的简介 349
10.1.2 设备分类 349
10.1.3 设备号 350
10.1.4 设备节点 350
10.1.5 驱动层次结构 351
10.1.6 设备驱动程序的特点 352
10.2 设备驱动程序与文件系统 353
10.2.1 设备驱动程序与文件系统的关系 353
10.2.2 设备驱动程序与操作系统的关系 353
10.2.3 Linux设备驱动程序的接口 353
10.2.4 设备驱动程序开发的基本函数 359
10.2.5 Linux驱动程序的加载 359
10.3 设备驱动程序的使用 364
10.3.1 驱动程序模块的加载 364
10.3.2 创建设备文件 364
10.3.3 使用设备 364
10.4 网络设备基础知识 365
10.4.1 网络协议 365
10.4.2 网络设备接口基础 366
10.5 网络设备驱动程序的架构 369
10.5.1 网络设备驱动程序体系结构 369
10.5.2 网络设备驱动程序模块分析 369
10.5.3 网络设备驱动程序的实现模式 376
10.5.4 网络设备驱动程序的数据结构 376
10.6 综合实例 381
实例10-1：键盘驱动开发实例 381
实例10-2：I2C总线驱动的编写实例 384
实例10-3：TFT-LCD显示驱动实例 388
10.7 本章小结 393
第11章 嵌入式GUI开发 394
11.1 嵌入式系统中的GUI简介 395
11.1.1 嵌入式GUI系统的介绍 395
11.1.2 基于嵌入式Linux的GUI系统底层实现基础 397
11.1.3 嵌入式GUI系统的分析与比较 397
11.2 嵌入式系统下MiniGUI的实现 399
11.2.1 图形用户界面MiniGUI简介 399
11.2.2 MiniGUI的发布版本 401
11.2.3 MiniGUI在S3C2410处理器上的移植过程 404
11.3 Qt/Embedded嵌入式图形开发基础 407
11.3.1 Qt/Embedded开发环境的安装 407
11.3.2 Qt/Embedded底层支持及实现代码分析 411
11.3.3 Qt/Embedded信号和插槽机制 412
11.3.4 Qt/Embedded窗口部件 415
11.3.5 Qt/Embedded图形界面编程 418
11.3.6 Qt/Embedded对话框设计 419
11.3.7 数据库 420
实例11-1：Qt/Embedded图形开发应用实例 423
11.4 Qtopia移植 424
11.4.1 Qtopia简介 424
11.4.2 交叉编译、安装Qtopia 424
实例11-2：Qtopia移植应用实例 426
11.5 Qt/Embedded应用开发 427
11.5.1 嵌入式硬件开发平台的选择 427
11.5.2 Qt/Embedded常用工具的介绍 429
11.5.3 交叉编译Qt/Embedded的库 430
11.5.4 Qt/E程序的编译与执行 431
实例11-3：Qt/Embedded实战演练 432
11.6 综合实例 436
实例11-4：Hello，Qt/Embedded应用程序 436
实例11-5：基本绘图应用程序的编写 439
11.7 本章小结 443
第12章 综合工程实例 444
12.1 文件系统的生成与烧写 444
12.1.1 yaffs文件系统的制作与生成 445
12.1.2 jffs2文件系统的制作与生成 449
12.2 基于Linux的数码相框 452
12.2.1 系统需求分析 452
12.2.2 系统总体设计 453
12.2.3 软件设计实现 454
12.2.4 软硬件集成 460
12.3 基于Linux的MPlayer解码播放器 461
12.3.1 可行性分析报告 461
12.3.2 系统总体设计 462
12.3.3 软件总体设计 463
12.3.4 软件详细设计 467
12.3.5 软硬件集成 477
12.4 基于Linux的GPS导航系统的开发 478
12.4.1 嵌入式开发流程图 479
12.4.2 GPS导航定位系统的系统定义 481
12.4.3 GPS导航系统的可行性分析报告 486
12.4.4 GPS导航系统需求分析 487
12.4.5 GPS导航系统总体设计实现 489
12.4.6 GPS导航系统硬件设计实现 491
12.4.7 GPS导航系统软件概括设计 495
12.4.8 GPS导航系统软件详细设计 495
12.4.9 GPS导航系统数据库的配置设计 522
12.4.10 GPS导航系统软件实现 534
12.5 本章小结 538

Ⅲ 嵌入式系统Linux内核开发实战指南的目录

第1部分 嵌入式系统硬件开发
第1章 嵌入式系统概述 2
这一章对嵌入式系统的概念及其特点和应用作了概括介绍，笔者根据自己多年的经验阐述了对嵌入式系统的理解，并对一些常见的嵌入式处理器的硬件数据进行了比较。
1.1 嵌入式系统概念 2
1.2 嵌入式处理器 3
1.3 嵌入式系统应用 4
1.4 嵌入式系统发展 4
1.5 一些嵌入式处理器的硬件特性比较 5
第2章 ARM处理器概述 16
为了使本书内容完整，从第2章到第7章中的内容大部分是笔者阅读《ARM体系结构与编程》（详情参见附录中的参考文献）的笔记和心得，把与嵌入式系统开发和Linux内核密切相关的硬件知识进行了概括和整理，本章主要介绍了ARM处理器的特点、ARM处理器的体系架构版本和ARM处理器系列。
2.1 ARM发展历程 16
2.2 ARM处理器特点 17
2.3 ARM处理器应用 17
2.4 ARM体系架构 18
2.4.1 ARM体系架构版本 18
2.4.2 ARM体系架构变种（Variant） 20
2.4.3 ARM体系架构版本命名格式 22
2.5 ARM处理器 22
2.5.1 ARM7系列处理器 23
2.5.2 ARM9系列处理器 24
2.5.3 ARM9E系列处理器 24
2.5.4 ARM10E系列处理器 25
2.5.5 SecurCore系列处理器 25
2.5.6 StrongARM处理器 26
2.5.7 Xscale处理器 26
第3章 ARM指令及其寻址方式 27
本章主要介绍了ARM处理器的指令和寻址方式以及ARM汇编伪指令，这是做ARM处理器应用系统底层软件开发必备的知识。
3.1 ARM处理器的程序状态寄存器（PSR） 27
3.2 ARM指令的条件码 28
3.3 ARM指令介绍 29
3.3.1 跳转指令 29
3.3.2 数据处理指令 30
3.3.3 乘法指令 31
3.3.4 杂类算术指令 32
3.3.5 状态寄存器访问指令 32
3.3.6 Load/Store内存访问指令 33
3.3.7 批量Load/Store内存访问指令 34
3.3.8 LDREX和STREX指令 35
3.3.9 信号量操作指令 37
3.3.10 异常中断产生指令 37
3.3.11 ARM协处理器指令 37
3.4 ARM指令寻址方式 39
3.4.1 数据处理指令的操作数的寻址方式 39
3.4.2 字及无符号字节的Load/Store指令的寻址方式 43
3.4.3 杂类Load/Store指令的寻址方式 47
3.4.4 批量Load/Store指令的寻址方式 49
3.4.5 协处理器Load/Store指令的寻址方式 51
3.4.6 ARM指令的寻址方式总结 52
3.5 ARM汇编伪操作（Directive） 53
3.5.1 符号定义伪操作 54
3.5.2 数据定义伪操作 54
3.5.3 汇编控制伪操作 56
3.5.4 栈中数据帧描述伪操作 57
3.5.5 信息报告伪操作 57
3.5.6 其他伪操作 58
3.6 ARM汇编伪指令 59
3.7 Thumb指令介绍 60
第4章 ARM处理器内存管理单元（MMU） 61
本章主要介绍了ARM处理器内存管理单元（MMU）的工作原理，Linux内存管理功能是通过处理器硬件MMU实现的，在没有MMU的处理器系统中，Linux只能工作在物理地址模式，没有虚拟（线性）地址空间的概念。
4.1 ARM处理器中CP15协处理器的寄存器 61
4.1.1 访问CP15寄存器的指令 61
4.1.2 CP15寄存器介绍 62
4.2 MMU简介 70
4.3 系统访问存储空间的过程 71
4.3.1 使能MMU时的情况 71
4.3.2 禁止MMU时的情况 71
4.3.3 使能/禁止MMU时应注意的问题 72
4.4 ARM处理器地址变换过程 72
4.4.1 MMU的一级映射描述符 73
4.4.2 MMU的二级映射描述符 74
4.4.3 基于段的地址变换过程 75
4.4.4 粗粒度大页地址变换过程 75
4.4.5 粗粒度小页地址变换过程 76
4.4.6 细粒度大页地址变换过程 76
4.4.7 细粒度小页地址变换过程 77
4.4.8 细粒度极小页地址变换过程 77
4.5 ARM存储空间访问权限控制 78
4.6 TLB操作 79
4.6.1 使TLB内容无效 79
4.6.2 锁定TLB内容 79
4.6.3 解除TLB中被锁定的地址变换条目 80
4.7 存储访问失效 80
4.7.1 MMU失效（MMU Fault） 80
4.7.2 外部存储访问失效（External Abort） 81
第5章 ARM处理器的Cache和Write Buffer 82
本章主要介绍了ARM处理器高速缓存（Cache）和写缓存（Write Buffer）的工作原理，使读者了解如何提高处理器的性能。
5.1 Cache和Write Buffer一般性介绍 82
5.1.1 Cache工作原理 82
5.1.2 地址映像方式 83
5.1.3 Cache写入方式原理简介 84
5.1.4 关于Write-through和Write-back 85
5.1.5 Cache替换策略 86
5.1.6 使用Cache的必要性 87
5.1.7 使用Cache的可行性 87
5.2 ARM处理器中的Cache和Write Buffer 88
5.2.1 基本概念 88
5.2.2 Cache工作原理 88
5.2.3 Cache地址映射和变换方法 89
5.2.4 Cache分类 90
5.2.5 Cache替换算法 91
5.2.6 Cache内容锁定 91
5.2.7 MMU映射描述符中B位和C位的含义 92
5.2.8 Cache和Writer Buffer编程接口 93
5.3 ARM处理器的快速上下文切换技术 94
5.3.1 FCSE概述 94
5.3.2 FCSE原理 94
5.3.3 FCSE编程接口 95
第6章 ARM处理器存储访问一致性问题 97
本章介绍了在支持MMU、Cache和DMA的系统中可能出现的存储访问一致性问题，以及Linux中解决类似问题的方法。
6.1 存储访问一致性问题介绍 97
6.1.1 地址映射关系变化造成的数据不一致性 97
6.1.2 指令cache的数据不一致性问题 98
6.1.3 DMA造成的数据不一致问题 99
6.1.4 指令预取和自修改代码 99
6.2 Linux中解决存储访问一致性问题的方法 99
第7章 ARM处理器工作模式与异常中断处理 101
本章主要介绍了ARM处理器的工作模式和异常中断处理过程，这是ARM处理器系统启动程序编写者或Bootloader开发人员的必备知识。
7.1 ARM处理器工作模式 101
7.2 ARM处理器异常中断向量表和优先级 103
7.3 ARM处理器异常中断处理 104
7.3.1 进入异常中断处理 104
7.3.2 退出异常中断处理 105
7.4 ARM处理器的中断（IRQ或FIQ） 109
第8章 ARM处理器启动过程 110
本章根据笔者的开发经验介绍了ARM处理器系统的启动过程以及编写ARM处理器系统启动程序需要注意的事项。
8.1 ARM处理器上电/复位操作 110
8.2 ARM处理器系统初始化过程 111
8.3 ARM处理器系统初始化编程注意事项 111
第9章 嵌入式系统设计与调试 113
本章根据笔者10多年的开发经验介绍了嵌入式系统的设计流程和调试方法，列举了大量笔者工作中碰到的实际案例。本章内容对于嵌入式系统硬件开发和调试有较高的参考、指导价值。
9.1 嵌入式系统设计流程 113
9.2 嵌入式系统硬件原理设计与审核 114
9.3 硬件设计工具软件 117
9.4 嵌入式系统调试仿真工具 117
9.5 嵌入式系统调试诊断方法 118
第10章 自制简易JTAG下载烧写工具 123
本章根据笔者自己制作简易JTAG线缆的经验，介绍了简易JTAG线缆的硬件原理和软件流程，这是初学者必备的最廉价的工具，必须掌握。
10.1 JTAG简介 123
10.1.1 一些基本概念 124
10.1.2 JTAG接口信号 124
10.1.3 TAP控制器的状态机 125
10.1.4 JTAG接口指令集 129
10.2 简易JTAG线缆原理 130
10.2.1 PC并口定义 130
10.2.2 PC并口的寄存器 131
10.2.3 简易JTAG线缆原理图 133
10.2.4 简易JTAG线缆烧写连接图（见图10-5） 134
10.3 简易JTAG烧写代码分析 135
10.3.1 简易JTAG烧写程序（flashp）使用说明 135
10.3.2 flash与CPU连接及flash属性描述文件 136
10.3.3 简易JTAG烧写程序的执行逻辑和流程 138
第2部分 Linux内核开发初步
第11章 Bootloader 142
本章根据笔者的工作经验介绍了流行的几种Bootloader、Bootloader应该具备的基本功能以及Bootloader的裁剪与移植。
11.1 Bootloader的任务和作用 142
11.2 各种各样的Bootloader 143
11.3 Bootloader编译环境 144
11.4 Bootloader的移植与裁减 145
11.5 编译Bootloader 145
11.6 烧写Bootloader 146
11.7 Bootloader使用举例 148
11.8 Bootloader修改举例 149
第12章 创建嵌入式Linux开发环境 151
本章介绍了如何创建嵌入式系统Linux内核交叉开发环境，本章和后续3章的内容是嵌入式系统Linux内核开发的基础，必须掌握。
12.1 安装Linux host 151
12.2 在虚拟机中安装Linux host 152
12.3 安装Linux交叉编译环境 157
12.4 在主机上设置TFTP Server 160
12.5 在主机上设置DHCP Server 161
12.6 在主机上设置Telnet server 161
12.7 在开发过程中使用NFS 162
12.8 设置超级终端 163
第13章 编译Linux内核 166
本章介绍了Linux内核的配置和编译方法。
13.1 获取Linux内核源代码 166
13.2 Linux内核目录结构 166
13.3 配置Linux内核 167
13.4 编译Linux内核 168
第14章 创建Linux根文件系统 170
本章介绍了Linux的根文件系统的结构以及创建根文件系统的方法。
14.1 根文件系统概述 170
14.2 根文件系统目录结构 171
14.3 获取根文件系统组件源代码 171
14.4 编译根文件系统源代码 171
14.5 创建一个32MB的RAMDISK根文件系统 173
14.6 在根文件系统中添加驱动模块或者应用程序 173
第15章 固化Linux内核和根文件系统 174
本章介绍了固化（烧写）Linux内核和根文件系统的方法。
第16章 关于Clinux 176
本章简要介绍了Clinux与标准Linux的区别。
16.1 Clinux简介 176
16.2 Clinux源代码目录结构 177
16.3 Clinux与标准Linux的区别 178
16.4 编译Clinux 179
第3部分 Linux 2.6内核原理
第17章 Linux 2.6.10@ARM启动过程 182
本章以start_kernel()和init()函数中调用到的函数说明的方式，介绍了从Linux汇编代码入口到init内核进程最后调用用户空间init命令的Linux整个启动过程。本章内容是笔者第一次阅读Linux内核源代码时对这些函数的注释，仅供读者了解start_kernel()和init()函数中调用到的每个函数的大致功能时使用。
17.1 Linux 2.6.10中与ARM处理器平台硬件相关的结构和全局变量 182
17.1.1 相关数据结构 182
17.1.2 相关全局变量 187
17.2 Linux汇编代码入口 189
17.3 Linux汇编入口处CPU的状态 189
17.4 start_kernel()函数之前的汇编代码执行过程 190
17.5 start_kernel()函数中调用的函数介绍 192
17.5.1 lock_kernel()函数 192
17.5.2 page_address_init()函数 192
17.5.3 printk(linux_banner) 193
17.5.4 setup_arch(&command_line)函数 193
17.5.5 setup_per_cpu_areas()函数 198
17.5.6 smp_prepare_boot_cpu()函数 199
17.5.7 sched_init()函数 199
17.5.8 build_all_zonelists()函数 200
17.5.9 page_alloc_init()函数 200
17.5.10 printk(Kernel command line: %s , saved_command_line) 201
17.5.11 parse_early_param()函数 201
17.5.12 parse_args()函数 201
17.5.13 sort_main_extable()函数 202
17.5.14 trap_init()函数 202
17.5.15 rcu_init()函数 202
17.5.16 init_IRQ()函数 203
17.5.17 pidhash_init()函数 203
17.5.18 init_timers()函数 203
17.5.19 softirq_init()函数 204
17.5.20 time_init()函数 204
17.5.21 console_init()函数 205
17.5.22 profile_init()函数 206
17.5.23 local_irq_enable()函数 207
17.5.24 vfs_caches_init_early()函数 207
17.5.25 mem_init()函数 208
17.5.26 kmem_cache_init()函数 210
17.5.27 numa_policy_init()函数 225
17.5.28 calibrate_delay()函数 227
17.5.29 pidmap_init()函数 228
17.5.30 pgtable_cache_init()函数 229
17.5.31 prio_tree_init()函数 229
17.5.32 anon_vma_init()函数 229
17.5.33 fork_init(num_physpages)函数 229
17.5.34 proc_caches_init()函数 230
17.5.35 buffer_init()函数 231
17.5.36 unnamed_dev_init()函数 231
17.5.37 security_init()函数 231
17.5.38 vfs_caches_init(num_physpages)函数 232
17.5.39 radix_tree_init()函数 237
17.5.40 signals_init()函数 237
17.5.41 page_writeback_init()函数 237
17.5.42 proc_root_init()函数 238
17.5.43 check_bugs()函数 240
17.5.44 acpi_early_init()函数 244
17.5.45 rest_init()函数 244
17.6 init()进程执行过程 265
17.6.1 smp_prepare_cpus(max_cpus)函数 265
17.6.2 do_pre_smp_initcalls()函数 265
17.6.3 fixup_cpu_present_map()函数 267
17.6.4 smp_init()函数 267
17.6.5 sched_init_smp()函数 268
17.6.6 populate_rootfs()函数 268
17.6.7 do_basic_setup()函数 283
17.6.8 sys_access()函数 292
17.6.9 free_initmem()函数 301
17.6.10 unlock_kernel()函数 301
17.6.11 numa_default_policy()函数 302
17.6.12 sys_p()函数 302
17.6.13 execve()函数 302
第18章 Linux内存管理 305
从本章开始，笔者将带领读者走进神秘的Linux内核世界。笔者在阅读内核源代码以及两本相关参考书（见参考文献）的基础上，以自己的理解和语言总结概括了Linux内核每个组件的原理。笔者对与每个内核组件相关的关键数据结构和全局变量作了尽量详尽的说明，并且对核心函数进行了详细注释，在向读者灌输理论知识的同时引导读者自己去阅读、分析Linux内核源代码。本章讲解了Linux内核第一大核心组件“内存管理”的原理和实现内幕。
18.1 Linux内存管理概述 305
18.1.1 Linux内存管理的一些基本概念 305
18.1.2 内存管理相关数据结构 309
18.1.3 内存管理相关宏和全局变量 330
18.1.4 Linux内存管理的任务 341
18.1.5 Linux中的物理和虚拟存储空间布局 341
18.2 为虚拟（线性地址）存储空间建立页表 345
18.3 设置存储空间的访问控制属性 348
18.4 Linux中的内存分配和释放 350
18.4.1 在系统启动初期申请内存 350
18.4.2 系统启动之后的内存分配与释放 360
第19章 Linux进程管理 480
本章讲解了Linux内核第二大核心组件“进程管理”的原理和实现内幕。
19.1 进程管理概述 480
19.1.1 进程相关概念 480
19.1.2 进程分类 481
19.1.3 0号进程 481
19.1.4 1号进程 481
19.1.5 其他一些内核线程 482
19.1.6 进程描述符（struct task_struct） 482
19.1.7 进程状态 482
19.1.8 进程标识符（PID） 483
19.1.9 current宏定义 484
19.1.10 进程链表 484
19.1.11 PID hash表和链表 485
19.1.12 硬件上下文（Hardware Context） 485
19.1.13 进程资源限制 485
19.1.14 进程管理相关数据结构 486
19.1.15 进程管理相关宏定义 502
19.1.16 进程管理相关全局变量 514
19.2 进程管理相关初始化 520
19.3 进程创建与删除 529
19.4 进程调度 551
19.4.1 进程类型 553
19.4.2 进程调度类型 554
19.4.3 基本时间片计算方法 555
19.4.4 动态优先级算法 556
19.4.5 交互式进程 556
19.4.6 普通进程调度 557
19.4.7 实时进程调度 557
19.4.8 进程调度函数分析 558
19.5 进程切换 576
19.6 用户态进程间通信 581
19.6.1 信号（Signal） 581
19.6.2 管道（pipe）和FIFO（命名管道） 627
19.6.3 进程间通信原语（System V IPC） 641
第20章 Linux文件管理 651
本章讲解了Linux内核第三大核心组件“文件系统”的原理和实现内幕。
20.1 文件系统概述 651
20.1.1 Linux文件管理相关概念 652
20.1.2 Linux文件管理相关数据结构 657
20.1.3 Linux文件管理相关宏定义 682
20.1.4 Linux文件管理相关全局变量 691
20.2 文件管理相关初始化 699
20.3 文件系统类型注册 711
20.4 挂接文件系统 712
20.5 文件系统类型超级块读取 730
20.5.1 get_sb_single()通用超级块读取函数 731
20.5.2 get_sb_nodev()通用超级块读取函数 737
20.5.3 get_sb_bdev()通用超级块读取函数 738
20.5.4 get_sb_pseudo()通用超级块读取函数 740
20.6 路径名查找 747
20.7 访问文件操作 759
20.7.1 打开文件 759
20.7.2 关闭文件 766
20.7.3 读文件 768
20.7.4 写文件 785
20.8 异步I/O系统调用 792
20.9 Linux特殊文件系统 792
20.9.1 rootfs文件系统 793
20.9.2 sysfs文件系统 797
20.9.3 devfs设备文件系统 800
20.9.4 bdev块设备文件系统 803
20.9.5 ramfs文件系统 804
20.9.6 proc文件系统 804
20.10 磁盘文件系统 813
20.10.1 ext2文件系统相关数据结构 813
20.10.2 ext2文件系统磁盘分区格式 819
20.10.3 ext2文件系统的各种文件 820
20.10.4 创建ext2文件系统 821
20.10.5 ext2文件系统的操作方法 822
20.11 关于initramfs 824
20.11.1 initramfs概述 824
20.11.2 initramfs与initrd的区别 824
20.11.3 initramfs相关全局变量 825
20.11.4 initramfs被编译链接的位置 825
20.11.5 initramfs文件的生成过程 825
20.11.6 initramfs二进制文件格式说明（cpio格式） 828
20.11.7 initramfs二进制文件和列表文件对照示例 829
20.11.8 initramfs利弊 830
20.12 关于initrd 830
20.12.1 initrd概述 830
20.12.2 initrd相关全局变量 831
20.13 关于gzip压缩文件 832
第21章 Linux模块设计 834
本章讲解了Linux内核模块程序与应用程序的区别以及如何编写和加载Linux内核模块程序。
21.1 Linux模块设计概述 834
21.2 Linux的内核空间和用户空间 834
21.3 内核模块与应用程序的区别 835
21.4 编译模块 837
21.5 装载和卸载模块 837
21.6 模块层叠 838
21.7 模块版本依赖 839
21.8 模块编程示例 839
第22章 Linux系统异常中断管理 841
本章讲解了Linux内核如何管理系统异常中断以及Linux系统调用的实现内幕。
22.1 Linux异常中断处理 841
22.2 指令预取和数据访问中止异常中断处理 849
22.2.1 指令预取中止异常中断处理 850
22.2.2 数据访问中止异常中断处理 858
22.3 Linux中断处理 863
22.3.1 内核模式下的中断处理 863
22.3.2 用户模式下的中断处理 867
22.4 从中断返回 868
22.5 Linux中断管理 869
22.5.1 Linux中断管理相关数据结构与全局变量 870
22.5.2 Linux中断管理初始化 872
22.5.3 安装和卸载中断处理程序 874
22.5.4 使能和禁止中断 878
22.6 Linux系统调用 880
22.6.1 Linux系统调用内核实现过程 880
22.6.2 从系统调用返回 889
22.6.3 Linux系统调用用户程序接口函数 890
22.6.4 Linux系统调用用户接口函数与内核实现函数之间参数传递 899
第23章 Linux软中断和工作队列 901
本章讲解了Linux内核中的两种延迟处理机制“软中断”和“工作队列”的原理和实现。
23.1 概述 901
23.2 Linux软中断 902
23.2.1 软中断相关数据结构和全局变量 903
23.2.2 软中断初始化 904
23.2.3 软中断的核心操作函数do_softirq() 908
23.2.4 软中断看护进程执行函数ksoftirqd() 912
23.2.5 如何使用软中断 913
23.3 Linux工作队列 918
23.3.1 Linux工作队列相关数据结构和全局变量 918
23.3.2 Linux工作队列初始化 921
23.3.3 将工作加入到工作队列中 924
23.3.4 工作者进程执行函数worker_thread() 928
23.3.5 使用Linux工作队列 931
第24章 Linux并发与竞态 933
本章讲解了Linux内核同步机制，包括几种锁定技术以及免锁算法。
24.1 并发与竞态概述 933
24.1.1 Linux中的并发源 934
24.1.2 竞态可能导致的后果 934
24.1.3 避免竞态的规则 934
24.2 消除竞态的“锁定”技术 935
24.2.1 信号量（semphore）和互斥体（mutual exclusion） 935
24.2.2 读写信号量（rw_semaphore） 938
24.2.3 完成量（completion） 941
24.2.4 自旋锁（spinlock_t） 942
24.2.5 读写自旋锁（rwlock_t） 946
24.2.6 使用“锁定”技术的注意事项 949
24.3 消除竞态的非“锁定”方法 949
24.3.1 免锁算法 949
24.3.2 原子操作 950
24.3.3 位操作 951
24.3.4 顺序锁 952
24.3.5 读-复制-更新（Read-Copy-Update，RCU） 954
第25章 Linux设备驱动程序 958
本章讲解了Linux内核第四大核心组件“设备驱动”的原理和实现内幕。同时还总结归纳了编写各种设备驱动程序的方法和步骤。
25.1 设备驱动程序概述 958
25.1.1 设备驱动程序组成部分 959
25.1.2 设备号 959
25.1.3 设备文件 960
25.1.4 编写设备驱动程序的关键 961
25.2 字符设备驱动程序 961
25.2.1 字符设备相关数据结构 961
25.2.2 字符设备相关全局变量 963
25.2.3 字符设备驱动程序全局初始化 963
25.2.4 为字符设备分配设备号 964
25.2.5 注册字符设备驱动程序 968
25.2.6 字符设备的操作方法 971
25.2.7 用户对字符设备驱动程序的调用过程 972
25.2.8 如何编写字符设备驱动程序 974
25.2.9 关于TTY设备驱动程序 974
25.2.10 控制台设备驱动程序 975
25.3 块设备驱动程序 986
25.3.1 块设备相关数据结构 986
25.3.2 块设备相关宏定义 997
25.3.3 块设备相关全局变量 999
25.3.4 块设备驱动程序全局初始化 1004
25.3.5 为块设备分配主设备号 1006
25.3.6 注册块设备驱动程序 1009
25.3.7 块设备驱动程序的操作方法 1017
25.3.8 调用块设备驱动程序过程 1017
25.3.9 I/O调度 1031
25.3.10 如何编写块设备驱动程序 1032
25.4 网络设备驱动程序 1033
25.4.1 网络设备驱动程序概述 1033
25.4.2 网络设备相关数据结构 1034
25.4.3 网络设备相关宏定义 1044
25.4.4 网络设备相关全局变量 1045
25.4.5 创建net_device结构 1046
25.4.6 注册网络设备 1048
25.4.7 网络设备的操作方法 1050
25.4.8 网络设备中断服务程序 1051
25.4.9 如何编写网络设备驱动程序 1051
25.5 PCI设备驱动程序 1052
25.5.1 PCI接口定义 1053
25.5.2 PCI设备的三个地址空间 1057
25.5.3 PCI总线仲裁 1058
25.5.4 PCI设备编号 1059
25.5.5 如何访问PCI配置空间 1059
25.5.6 如何配置PCI设备 1061
25.5.7 PCI驱动程序相关数据结构 1062
25.5.8 PCI驱动程序相关宏定义 1068
25.5.9 PCI驱动程序相关全局变量 1068
25.5.10 Bootloader和内核做的事 1069
25.5.11 PCI驱动程序注册 1069
25.5.12 PCI驱动程序接口函数 1071
25.5.13 如何编写PCI驱动程序 1072
第4部分 Linux内核开发高级指南
第26章 Linux系统参数设置 1076
从本章开始的后续章节主要讲解了比较高级或者平时较少关注的Linux内核方面的知识，本章讲解了Linux中的4种系统参数格式和设置方法。
26.1 旗语系统参数（tag） 1076
26.1.1 与旗语系统参数相关数据结构和全局变量 1076
26.1.2 旗语系统参数说明 1082
26.1.3 旗语系统参数设置方法 1084
26.2 前期命令行设置的系统参数 1084
26.2.1 与前期命令行系统参数相关数据结构和全局变量 1084
26.2.2 前期命令行设置的系统参数说明 1085
26.2.3 前期命令行系统参数设置方法 1086
26.2.4 如何添加自己的前期命令行设置的系统参数 1087
26.3 老式命令行系统参数 1087
26.3.1 与老式命令行系统参数相关数据结构和全局变量 1087
26.3.2 老式命令行设置的系统参数说明 1088
26.3.3 老式命令行设置的系统参数设置方法 1089
26.3.4 如何添加自己的老式命令行设置的系统参数 1089
26.4 命令行系统参数 1089
26.4.1 与命令行系统参数相关数据结构和全局变量 1089
26.4.2 命令行设置的系统参数说明 1090
26.4.3 命令行设置的系统参数设置方法 1090
第27章 Linux内核调试 1091
本章介绍了Linux内核的调试方法。
27.1 打开Linux内核及其各模块自带的调试开关 1091
27.2 内核剖析（Profiling） 1093
27.3 通过打印调试（printk） 1095
27.3.1 关于printk() 1095
27.3.2 内核信息级别 1096
27.3.3 打印速度限制 1097
27.3.4 控制台重定向 1098
27.4 使用proc文件系统调试 1098
27.5 oops消息 1098
27.6 通过跟踪命令strace调试 1099
27.7 使用gdb、kdb、kgdb调试 1099
第28章 Linux内核移植 1101
本章介绍了Linux内核的移植方法。
第29章 Linux内核优化 1104
本章介绍了Linux内核的优化方法。
29.1 编译优化 1104
29.2 根据CPU特性进行优化 1105
29.3 对内核进行裁减 1105
29.4 优化系统内存配置 1106
29.5 优化系统启动过程以缩减系统启动时间 1106
29.6 内存映射优化 1107
29.7 工具软件辅助优化 1107
第30章 Linux定时器 1109
本章介绍了Linux内核的软件定时器。
30.1 定时器相关数据结构 1109
30.2 定时器相关宏定义 1111
30.3 定时器相关全局变量 1112
30.4 定时器和时钟初始化 1113
30.5 获取系统时间 1114
30.6 延迟函数 1115
30.7 与定时器相关系统调用 1115
30.8 使用定时器方法 1116
第31章 杂项 1117
本章介绍了PER_CPU变量以及Linux中的数据类型定义。
31.1 per_cpu变量 1117
31.2 Linux中的数据类型定义 1118
第32章 编译链接文件说明 1119
本章注释了ARM处理器系统中Linux内核的链接文件，以帮助读者了解编译出来的Linux内核各区段在内存中的存放位置。
参考文献 1125

Ⅳ 嵌入式linux怎么用qt做pdf阅读器

1.想要在开发板上运行,你需要移植QTE.添加arm-linux-交叉编译工具链. 把原有的工程交叉编译生产开发板上可以运行的程序.把可执行程序和QTE库考到开发板上.再改一下环境变量就ok了. 2.用Qt Creator啊.

Ⅳ arm嵌入式linux系统开发详解

http://ishare.iask.sina.com.cn/search.php?key=%C7%B6%C8%EB%CA%BDlinux%CF%B5%CD%B3%BF%AA%B7%A2%CF%EA%BD%E2&from=index&format=pdf%7Ehtm

http://wenku..com/search?word=linux%CF%B5%CD%B3%BF%AA%B7%A2%CF%EA%BD%E2&lm=0&od=0

Ⅵ 如何制作嵌入式Linux文件系统

简单的说：
先配置文件系统的基本目录，
包含/bin /sbin /etc /usr /tmp /root 等基本目录，
把应用程序放到这些目录中，
再用mkcamfs等工具来打包文件系统即可。
细节上的话要说的就多了

Ⅶ 有没有专门介绍 bootloader 这块内容的书籍

一般Bootloader和Linux的启动过程的讲解都是嵌入式书籍的一个章节而已，从我自身的学习经验来给出一些建议：
1.可以看 Embedded Linux Primer (豆瓣) 第二版，网上有英文版（建议）和中文版的pdf下载，里面的Chapter5和7分别简述了Linux的初始化启动过程和Bootloader基础。还有后面的Busybox章节也不错。另外构建嵌入式LINUX系统 (豆瓣)也可以作为参考。
2. 找一下韦东山的第一期和毕业班免费视频，里面也讲到了Bootloader和Linux如何初始化以及如何执行第一个用户程序。尽管其实只讲了一部分，但是对于Linux的启动流程的学习还是很有帮组的。跟着写一个Bootloader绝对是学习Bootloader的一种好方式。如同在stackoverflow里面对于如何学习Bootloader给出的答案一样“The best method to learn it, is to recreate one”。如果自己写一个有困难，那么就先学习移植吧。
3. 其实Bootloader就是裸机程序，因此如果你对裸机程序熟悉，那么Bootloader甚至说不上需要学习，给出一本书籍用于参考：ARM处理器裸机开发实战:机制而非策略(附CD-ROM光盘1张)/王小强

其他国人写的书籍中的Bootloader大都是泛泛而谈，对于有经验的人用不着，对于初学者更多的是雾里看花，例如：
杨铸与人合着的两本书：深入浅出:嵌入式底层软件开发/杨铸和构建嵌入式Linux核心软件系统实战(附光盘1张)/杨铸
韦东山写的那本书：嵌入式Linux应用开发完全手册(附CD光盘1张)/韦东山
以及各类“精通”与“实战”之流。
但，不管如何，开卷有益，同时也因人而异。还是需要题主自己考究。

最后：
如果你学得很痛苦，那么很可能没有走在正确的路上。我觉得学习过程应该是不断+1的过程，看，看得懂的代码和书。否则继续学习基础，或者直接跳过这些东西直接到Linux上面学习驱动开发或者应用开发，其实这些知识点没有那么多牵连，很多人给出的嵌入式学习步骤绝对是带人入坑。

Ⅷ 谁有最新的 嵌入式系统设计师教程 pdf

可以到嵌入式学习网上下载，有嵌入式系统超多的教程
网址是http://www..com/s?bs=%C7%B6%C8%EB%CA%BD%D1%A7%CF%B0%CD%F8+%C7%B6%C8%EB%CA%BD%D1%A7%CF%B0%CD%F8+-+EmbedStudy&f=8&wd=%C7%B6%C8%EB%CA%BD%D1%A7%CF%B0%CD%F8++EmbedStudy

Ⅸ 利用Busybox如何构建一个最小的Linux系统

为了方便和简化嵌入式Linux开发过程中的调试过程，主要研究了如何使用Busybox构建出基本的嵌入式Linux根文件系统，包括Busybox的配置、编译和安装。在此基础上，进一步构建出基于NFS的嵌入式Linux根文件系统，并给出了启动脚本和配置文件。这种根文件系统可以方便地在线更改、调试程序，降低了嵌入式系统的开发门槛。
随着信息技术的发展，嵌入式系统技术已经广泛应用于国防、通信、工业控制、消费电子等诸多领域。其中，Linux作为一款开源、成熟且高效稳定的多任务操作系统，先天具有许多不可比拟的优势，已成为目前最具潜力的嵌入式操作系统。众所周知，构建根文件系统对于嵌入式Linux开发至关重要，它是内核启动后加载的第1个文件系统，是决定系统能否正常启动的关键所在。在开发阶段，程序往往需要反复多次的调试，鉴于此，构建基于NFS(Network File System)的根文件系统就尤为重要；这样就免去了对目标开发板的反复烧写，方便地在线对程序进行更改与调试。本文以Busybox软件为基础，介绍了一种实用的NFS根文件系统构建方法。
1 嵌入式根文件系统简介
Linux启动时，第一个必须挂载的就是根文件系统；若系统不能从指定设备上挂载根文件系统，则系统会报错进而退出启动。系统成功启动之后，才可以自动或手动挂载其他的文件系统。
Linux系统各个分区存储文件时，需要遵循一定的格式，这种文件格式称为文件系统类型，比如常见的有ext2，ext3，ext4等。在存储设备方面，FLASH是目前嵌入式系统中广泛采用的主流存储设备，它是一种可电擦写的非易失性存储器，具有体积小，功耗低，密度高等优点。目前FLASH中常见的文件系统主要有Cramfs，Jffs2，Yaffs2等。嵌入式Linux基本的根文件目录结构如表1所示。 2 Busybox简介 Busybox常被形象地称为嵌入式Linux系统开发中的“瑞士军刀”，它将许多常用的UNIX命令和工具结合到了一个单独的可执行程序中。虽然与相应的GNU工具相比较，Busybox所提供的功能和参数略少，但在比较小的系统或者嵌入式系统中已经足够了。它仅用一个可执行文件就可以提供基本的Linux操作系统所需的命令，体积很小，配置起来也很方便。

Ⅹ 构建一个嵌入式ARM Linux系统时,你是如何进行FLASH存储器分区规划的,并说明各个部分的作用.

flash中一般需要装下
启动区（bootstrap,uboot)，内核区(kernel），文件系统(filesystem)
具体安装大小，要看各个部分的软件被你编译成了多少。
在你编译后的size的基础上，再适当增加一点，作为个分区的容量。
给你一个atmel的官方arm linux的分区示意图。
http://www.at91.com/linux4sam/bin/view/Linux4SAM/GettingStarted
上面只是对初学者的简要说明。每一部分都是可变的，关键看你自己的制作环境是什么。
想了解更详细的，你需要了解了每一部分的启动原理，存储位置等，才能充分明白。
或者把上面的网站里，左侧菜单的所有内容熟悉一遍，也会加深理解的。