bootloader相关_如何在不同芯片上做bootloader

bash$ TARGET_CPU_FAMILY_LIST="8xx 85xx" \   #CPU系列号
> /opt/eldk/build.sh -a ppc \               #CPU构架
> -n 2007-01-19 \                           #编译结果存放目录名
> -p /opt/eldk/build/ppc-2007-01-19 \       #编译前缀，编译目录存放路径
> -r /opt/eldk/build/ppc-2007-01-19/results \#输出存入目录
> -w /opt/eldk/build/ppc-2007-01-19/work \   #工作目录
> trg 47 47              #编译软件包的起始、结束编号，在文件tpckgs.lst与cpckgs.lst中

bash$ export CROSS_COMPILE=ppc_8xx-                 #编译器前缀，组成不同构架编译器
bash$ ${CROSS_COMPILE}gcc -o hello_world hello_world.c #编译源文件
bash$ ${CROSS_COMPILE}rpm -iv <package_name>.src.rpm   #解压缩并安装源代码 
bash$ ${CROSS_COMPILE}rpmbuild -ba <package_name>.spec #编译源代码包

建立开发系统

开发时，主机需要与目标板交互，如：调试程序，控制目标板，下载程序映像到目标板，目标板的调试信息需要反回到主机等。为了与目标板交互，主机必须建立开发环境，如：建立串行终端，配置TFTP服务器、DHCP服务器和NFS服务器。

（1）配置串行终端

开发者在开发时需要访问目标板的串行终端端口，通过在主机上的终端对目标板进行控制台操作。通常，开发者将目标板的串行终端端口绑定在主机的一个串行端口，实现控制台的功能，开发者还需要在主机上使用一个终端仿真程序，如：cu或kermit。

命令cu是软件包UUCP的一部分，UUCP可用作串行终端，还具有简单的文件传输功能，可用于映像文件的下载。

依赖于目标板的波特率，需要改写UUCP的配置文件，典型的配置列出如下：

•配置文件/etc/uucp/sys的内容列出如下:

#

# /dev/ttyS0 at 115200 bps:

#

system S0@115200

port serial0_115200

time any

配置文件/etc/uucp/port的内容列出如下:

#

# /dev/ttyS0 at 115200 bps:

#

port serial0_115200

type direct

device /dev/ttyS0

speed 115200

hardflow false

接着，用户可用下面命令连接到串行线：

$ cu S0@115200

$ ~. #断开连接

命令kermit代表了整个串行线和网络连接通信软件簇，文件~/.kermrc执行kermit的初始化，通过合适的初始化命令可用来定制kermit的行为，U-Boot推荐使用下面的设置：

$cat ~/.kermrc:

set line /dev/ttyS0 #串行端口

set speed 115200 #波特率

set carrier-watch off

set handshake none

set flow-control none

robust

set file type bin

set file name lit

set rec pack 1000

set send pack 1000

set window 5

命令kermit连接串行线的方法如下：

$ kermit –c

（2）配置TFTP服务器

使用 U-Boot装载Linux内核或应用程序的最快捷方式是通过Ethernet传递，U-Boot实现了TFTP协议，通过U-Boot的tftpboot命令下载文件到目标板中，主机应确信安装了TFTP后台程序/usr/sbin/in.tftpd。

（3）配置BOOTTP/DHCP服务器

BOOTP/DHCP服务器用于自动传递配置信息到目标机，目标机仅需要知道它自己的Ethernet硬件MAC地址，主机应安装DHCP包，配置DHCP服务器，一个配置样例列出如下：

subnet 192.168.0.0 netmask 255.255.0.0 {

option routers 192.168.1.1;

option subnet-mask 255.255.0.0;

option domain-name "local.net";

option domain-name-servers ns.local.net;

host trgt { hardware ethernet 00:30:BF:01:02:D0; #目标板MAC地址

fixed-address 192.168.100.6; #目标板固定IP地址

option root-path "/opt/eldk-4.2/ppc_4xx";

option host-name "canyonlands"; #目标板的主机名

next-server 192.168.1.1;

filename "/tftpboot/canyonlands/uImage ";

}

}

用上面的配置，DHCP服务器将回答来自目标板的请求，给出下面的信息：

• 目标板位于子网192.168.0.0，子网掩码为255.255.0.0。
• 目标板的主机名为Canyonlands，IP地址为192.168.100.0。
• IP地址为192.168.1.1的主机给目标板提供启动映像（boot image），当目标板根文件系统通过NFS挂接在主机上，它还提供NFS服务器功能。
• 主机提供文件/tftpboot/canyonlands/uImage作为目标板的启动映像。
• 目标板可以挂接目录/opt/eldk-4.2/ppc_4xx在NFS服务作为根文件系统。

（3）配置NFS服务器

通过NFS，主机和目标板可以共享文件，NFS服务器对外暴露的目录可以挂接作目标板的根文件系统。主机应安装NFS服务器，并开启NFS服务。

NFS服务器的配置样例列出如下：

$cat /etc/exports

/opt/eldk-4.2/ppc_4xx 192.168.0.0/255.255.0.0(rw,no_root_squash,sync)

上述语句含义为暴露目录/opt/eldk-4.2/ppc_4xx，在子网192.168.0.0上的所有主机都可以读写操作该目录。

编译安装Linux内核

ELDK源代码包括了Linux内核，用户可以编译安装内核，方法如下：

bash$ cd /opt/eldk/usr/src/linux-2.6-denx

bash$ make mrproper

bash$ make ARCH=powerpc CROSS_COMPILE=ppc_4xx- canyonlands_defconfig #用户设备目标板的配置

bash$ make ARCH=powerpc CROSS_COMPILE=ppc_4xx- INSTALL_MOD_PATH=/opt/eldk-4.2/ppc_4xx modules_install

bash$ cp arch/powerpc/boot/uImage /tftpboot/uImage

启动嵌入式Linux

（1）启动内核

当Linux内核和扁平设备树块（Flattened Device Tree Blob，FDT blob）下载到目标板的系统内存（如：RAM、ROM、flash等）时，用户可用bootm命令启动系统。假设内核映像存放在地址0xFC000000处，FDT blob存放在地址0xFC1E0000处，则启动映像文件的命令列出如下：

=>bootm FC000000 – FC1E0000

（2）编译blob

Linux内核运行时，期望知道它运行的硬件信息，这些硬件信息按《开放固件规范》以设备树的形式描述，由于象U-Boot这样的BootLoader没有实现开放固件API（Open Firmware API），硬件信息将以扁平设备树的二进制形式传递给内核，这种二进制形式称为FDT blob或简称blob。在设备树信息文件（如：canyonlands.dts）由dtc编译器编译成二进制文件，ELDK包括了dtc编译器，编译方法列出如下：

dtc -b 0 -V 17 -p 0x1000 -I dts -O dtb -f arch/powerpc/boot/dts/canyonlands.dts > /tftpboot/canyon

编译完后，可使用命令tftp将blob传输到目标机的内存中，接着，系统启动bootm将blob中的硬件信息传递给内核。

U-Boot还提供命令fdt修改blob。

（3）传递内核参数

用户可以传递附加信息（如：根设备或网络配置）给内核。U-Boot通过环境变量bootargs实现该功能。该变量的内容作为启动参数（或命令行参数）自动传递给内核，这样，可以让同一个内核映像有更多的配置，例如：仅改变变量bootargs的内容，就可以让同一个内核映像与initrd内存盘（ ramdisk）映像一起启动，或者与在NFS之上的根文件系统一起启动。

例如：内核映像地址在0x200000，作为根文件系统的initrd ramdisk映像地址在0x400000，FDT blob地址在0x600000，则启动命令列出如下：

=> setenv bootargs root=/dev/ram rw

=> bootm 200000 400000 600000

假设NFS服务器地址为192.168.1.1，输出目录/opt/eldk-4.2/ppc_4xx作为目标板的根文件系统，目标板的地址为192.168.100.6，目标板主机名为canyonlands，子网掩码为255.255.255.0。现由在NFS上的根文件系统启动同样内核，则启动命令列出如下：

=> setenv bootargs root=/dev/nfs rw nfsroot=192.168.1.1:/opt/eldk-4.2/ppc_4xx ip=192.168.100.6:192.168.1.1

=> bootm 200000 - 600000

内核启动后，可用下面命令查看启动的命令行：

$ cat /proc/cmdline

用户还可用U-Boot环境变量存放所有需要的配置参数，方法如下：

=> setenv ipaddr 192.168.100.6

=> setenv serverip 192.168.1.1

=> setenv netmask 255.255.0.0

=> setenv hostname canyonlands

=> setenv rootpath /opt/eldk-4.2/ppc_4xx

=> saveenv

用户可用这些变量构建传递到内核的启动参数，方法如下：

=> setenv nfsargs 'root=/dev/nfs rw nfsroot=${serverip}:${rootpath}'

下面可以定义bootargs环境变量，并一步步构建启动参数：

=> setenv ramargs setenv bootargs root=/dev/ram rw

=> setenv nfsargs 'setenv bootargs root=/dev/nfs rw nfsroot=${serverip}:${rootpath}'

=> setenv addip 'setenv bootargs ${bootargs} ip=${ipaddr}:${serverip}:${gatewayip}:${netmask}:${hostname}::=> setenv ram_root 'run ramargs addip;bootm ${kernel_addr} ${ramdisk_addr} ${fdt_addr} '

=> setenv nfs_root 'run nfsargs addip;bootm ${kernel_addr} - ${fdt_addr} '

上面定义了ram_root和nfs_root两个变量，分别用于从ramdisk映像的根文件系统和NFS上的根文件系统启动。变量通过run命令执行。

（4）用Ramdisk映像单独操作

当应用程序开发完成时，用户希望独立运行嵌入式系统，而不依赖外部系统，如：NFS文件系统，目标板不再通过NFS挂接根文件系统，而是使用压缩的ramdisk映像，该ramdisk映像存储在flash中，在系统启动时装载到RAM中。

装载ramdisk映像到RAM，并将它写入到flash的方法如下：

=> setenv ramdisk_addr FC200000

=>

=> setenv ram_ws 100000

=>

=> prot off FC200000 FC3FFFFF

Un-Protected 16 sectors

=>

=> era FC200000 FC3FFFFF

................ done

Erased 16 sectors

=>

=> tftp 100000 /tftpboot/canyonlands/uRamdisk

=> imi 100000

## Checking Image at 00100000 ...

=>

=> cp.b ${ram_ws} ${ramdisk_addr} ${filesize}

Copy to Flash... done

=>

=> imi ${ramdisk_addr}

=>

=> saveenv

Saving Environment to Flash...

为了告诉Linux内核使用ramdisk映像作为根文件系统，用户必须修改传递给内核的命令行参数，ramdisk映像地址作为命令bootm的第二个参数，第一个参数为内核映像的内存地址，第三个参数是FDT blob的内存地址。

Flash文件系统

（1）MTD

所有可用的Flash文件系统都基于内存技术设备（Memory Technology Devices，MTD）层，因此，用户配置内核时必须打开flash文件系统支持，配置结果如下：

CONFIG_MTD=y

CONFIG_MTD_PARTITIONS=y

CONFIG_MTD_CHAR=y

CONFIG_MTD_BLOCK=y

CONFIG_MTD_CFI=y

CONFIG_MTD_GEN_PROBE=y

CONFIG_MTD_CFI_AMDSTD=y

CONFIG_MTD_ROM=y

CONFIG_MTD_canyonlands=y

目标板flash设备的分区设计由MTD映射例程（源代码在drivers/mtd/maps/）定义，canyonlands的分区设计列出如下：

-bash-3.2# cat /proc/mtd

dev: size erasesize name

mtd0: 001e0000 00020000 "kernel"

mtd1: 00020000 00020000 "dtb"

mtd2: 00200000 00020000 "root"

mtd3: 03b60000 00020000 "user"

mtd4: 00040000 00020000 "env"

mtd5: 00060000 00020000 "u-boot"

mtd6: 02000000 00004000 "NAND 32MiB 3,3V 8-bit"

mtd7: 00060000 00004000 "u-boot"

mtd8: 00008000 00004000 "env"

mtd9: 01f98000 00004000 "content"

用户还可以运行一些基本的测试，验证flash驱动程序例程和分区，方法如下：

-bash-3.2# xxd /dev/mtd3 | head -4

0000000: 5468 7520 4a61 6e20 2031 2030 313a 3034 Thu Jan 1 01:04

0000010: 3a35 3120 4345 5420 3139 3730 0aff ffff :51 CET 1970....

0000020: ffff ffff ffff ffff ffff ffff ffff ffff ................

0000030: ffff ffff ffff ffff ffff ffff ffff ffff ................

在MTD设备16进制转储中，用户可以鉴别一些字符串，验证U-Boot环境、一个Linux内核、ramdisk映像或一个空的分区。如：上面的转储显示表明该分区是空的，用户可以写数据到该分区，方法如下：

-bash-3.2# date > /dev/mtd3

-bash-3.2#

-bash-3.2# head -1 /dev/mtd3

Thu Jan 1 01:04:51 CET 1970

-bash-3.2#

-bash-3.2# date > /dev/mtd3

上述命令中，第一次写是正确的，第二次写将得到一个错误，因为flash内存必须先擦除，再进行写操作。

用户可使用Linux命令eraseall擦除整个MTD分区，再进行写操作，方法如下：

-bash-3.2# flash_eraseall /dev/mtd3

-bash-3.2#

-bash-3.2# date > /dev/mtd3

-bash-3.2#

-bash-3.2# head -1 /dev/mtd3

Thu Jan 1 01:04:51 CET 1970

（2）JFFS2

JFFS（Journalling Flash File System）是嵌入式设备flash上最合适的文件系统，JFFS2为嵌入式系统闪存的使用而设计，它是一个日志结构的文件系统，这意味着它对掉电、系统崩溃或其他意外关闭等系统异常具有有效保护措施，如：仅丢失正在写的数据，重启动后，不需要任何的文件系统检查。

配置内核时，需要打开JFFS配置选项，配置结果列出如下：

CONFIG_JFFS_FS=y

CONFIG_JFFS_FS_VERBOSE=0

对flash的直接读写或擦除操作一般使用MTD层的字符设备接口/dev/mtd*，文件系统操作（如：mount）必须使用块设备接口/dev/mtdblock*。JFFS2还提供了透明的压缩功能，让flash可以存储更多的内容。擦除、挂接并查看分区的方法列出如下：

# eraseall /dev/mtd2 //擦除分区

Erased 4096 Kibyte @ 0 -- 100% complete.

# mount -t jffs2 /dev/mtdblock2 /mnt //挂接文件系统

# mount //查看分区挂接情况

/dev/root on / type nfs (rw,v2,rsize=4096,wsize=4096,hard,udp,nolock,addr=10.0.0.2)

proc on /proc type proc (rw)

devpts on /dev/pts type devpts (rw)

/dev/mtdblock2 on /mnt type jffs (rw)

# df //查看磁盘使用情况

Filesystem 1k-blocks Used Available Use% Mounted on

/dev/root 2087212 1232060 855152 60% /

/dev/mtdblock2 3584 0 3584 0% /mnt

可以用工具mkfs.jffs2创建JFFS2文件系统映像，下面的样例给flash分区创建了3MB的JFFS2映像文件image.jffs2，并移入目录/tmp/flashtools/中的数据，然后，擦除分区/dev/mtd4，并将映像image.jffs2拷贝到分区mtd4中。最后，挂接分区mtd4。这些操作的命令列出如下：

# mkfs.jffs2 --pad=3145728 --eraseblock=262144 \

--root=/tmp/flashtools/ --output image.jffs2

# eraseall /dev/mtd4

Erased 3072 Kibyte @ 0 -- 100% complete.

# dd if=image.jffs2 of=/dev/mtd4 bs=256k

12+0 records in

12+0 records out

# mount -t jffs2 /dev/mtdblock4 /mnt

# df /mnt

Filesystem 1k-blocks Used Available Use% Mounted on

/dev/mtdblock4 3072 2488 584 81% /mnt

（3）CramFS

用户有时希望文件系统是仅读的，可压缩仅读文件系统（Compressed ROM Filesystem） CramFs实现了文件系统仅读与压缩的功能。用工具mkcramfs创建可压缩仅读文件系统映像的方法列出如下：

$ mkdir /tmp/test

$ cp ... /tmp/test

$ du -sk /tmp/test

64 /tmp/test

$ mkcramfs /tmp/test test.cramfs.img

Super block: 76 bytes

erase

eraseall

mkfs.jffs

lock

unlock

Directory data: 176 bytes

-54.96% (-4784 bytes) erase

-55.46% (-5010 bytes) eraseall

-51.94% (-8863 bytes) mkfs.jffs

-58.76% (-4383 bytes) lock

-59.68% (-4215 bytes) unlock

Everything: 24 kilobytes

$ ls -l test.cramfs.img

-rw-r--r-- 1 wd users 24576 Nov 10 23:44 test.cramfs.img

由于CramFs映像是压缩的，因此，输入的目录数据为64kB，而映像文件为24kB大小。

写CramFs映像到flash分区的方法列出如下：

# cp test.cramfs.img /dev/mtd3

# mount -t cramfs /dev/mtdblock3 /mnt

# mount

/dev/root on / type nfs (rw,v2,rsize=4096,wsize=4096,hard,udp,nolock,addr=10.0.0.2)

proc on /proc type proc (rw)

devpts on /dev/pts type devpts (rw)

/dev/mtdblock3 on /mnt type cramfs (rw)

# ls -l /mnt

total 54

-rwxr-xr-x 1 wd users 8704 Jan 9 16:32 erase

-rwxr-xr-x 1 wd users 9034 Jan 1 01:00 eraseall

-rwxr-xr-x 1 wd users 7459 Jan 1 01:00 lock

-rwxr-xr-x 1 wd users 17063 Jan 1 01:00 mkfs.jffs

根文件系统的设计与编译

嵌入式系统的根文件系统（Root File System）设计包括存放的内容、文件系统类型、在哪里存放文件系统和如何启动它。

根文件系统通常存放在目标板的闪存（flash memory）中或CF、SD、MMC卡等中，可以使用像ELDK这样的Linux发布版本创建根文件系统的内容。

下面使用来自ELDK的SELF（Simple Embedded Linux Framework）映像创建根文件系统。

在ELDK软件包中，各种平台构架的SELF映像文件在目录/opt/eldk/<architecture>/images/下，文件名为ramdisk_image.gz，是个压缩的ramdisk映像。

由SELF创建根文件系统tar包的方法列出如下：

//解压缩ramdisk映像

bash$ gzip -d -c -v /opt/eldk/ppc_8xx/images/ramdisk_image.gz >/tmp/ramdisk_image

/opt/eldk/ppc_8xx/images/ramdisk_image.gz: 61.4%

//下面的操作需要root权限

//挂接ramdisk映像

bash# mount -o loop /tmp/ramdisk_image /mnt/tmp

//创建tar包，为了避免需要root权限，这里不包括在tar包中的设备（device）文件

bash# cd /mnt/tmp

bash# tar -zc --exclude='dev/*' -f /tmp/rootfs.tar.gz *

//需要时，为CramFs创建一个单独的tar包，用来包括设备条目

bash# tar -zcf /tmp/devices.tar.gz dev/

bash# cd /tmp

//卸载ramdisk映像

bash# umount /mnt/tmp

（1）根文件系统在ramdisk上

ramdisk常用于存放嵌入式系统的根文件系统，但很少情况将ramdisk映像作为嵌入式系统的根文件系统解决方案。

根文件系统包括在ramdisk中的优点是：编译简单；基于RAM，速度快；Linux内核支持完美；容易使用，甚至可将带有Linux内核的ramdisk放在一个映像文件中；根文件系统是可写的；每次重启动郈的初始状态容易恢复。 缺点是：每次必须将整个文件系统装入RAM，造成启动慢，需要附加存储器存放可写的永久数据。

在ramdisk映像中，根文件系统常用ext2文件系统类型，创建在ramdisk上根文件系统的方法说明如下：

• 通过解开tar包创建目标板根文件系统内容的目录树

$ mkdir rootfs

$ cd rootfs

$ tar zxf /tmp/rootfs.tar.gz

• 使用工具genext2fs创建ramdisk映像，可用设备表文本文件定义在产生的文件系统映像中应创建的设备，这意味着需要root权限。设备表rootfs_devices.tab部分内容列出如表2所示。

表2 设备表文件rootfs_devices.tab部分内容

使用工具genext2fs 创建文件系统映像的方法如下：

$ ROOTFS_DIR=rootfs # 根文件系统内容目录

$ ROOTFS_SIZE=3700 # 文件系统映像的大小

$ ROOTFS_FREE=100 # 期望的空闲空间

$ ROOTFS_INODES=380 # 节点(inode)数

$ ROOTFS_DEVICES=rootfs_devices.tab # 设备描述表文件

$ ROOTFS_IMAGE=ramdisk.img # 产生的文件系统映像

$ genext2fs -U \

-d ${ROOTFS_DIR} \

-D ${ROOTFS_DEVICES} \

-b ${ROOTFS_SIZE} \

-r ${ROOTFS_FREE} \

-i ${ROOTFS_INODES} \

${ROOTFS_IMAGE}

• 压缩文件系统映像，方法如下：

$ gzip -v9 ramdisk.img

rootfs.img: 55.6% -- replaced with ramdisk.img.gz

• 创建U-Boot使用的根文件系统映像uRamdisk，方法如下：

$ mkimage -T ramdisk -C gzip -n 'Test Ramdisk Image' \

> -d ramdisk.img.gz uRamdisk

Image Name: Test Ramdisk Image

Created: Sun Jun 12 16:58:06 2005

Image Type: PowerPC Linux RAMDisk Image (gzip compressed)

Data Size: 1618547 Bytes = 1580.61 kB = 1.54 MB

Load Address: 0x00000000

Entry Point: 0x00000000

We now have a root file system image uRamdisk that can be used with U-Boot.

（2）根文件系统在JFFS2文件系统上

在嵌入式系统中，JFFS2作为根文件系统的优点是：文件系统使用压缩，可有效利用闪存空间；它是日志结构的文件系统，对无序的关机是强壮的；它是可写闪存文件系统。缺点是：挂接时间长；由于压缩/解压缩，造成读写操作时间长；垃圾回收线程可在任何时间启动，消耗CPU时间，阻塞对文件系统的访问。

尽管有上面一些不利因素，但基于JFFS2 的根文件系统容易编译，可有效利用可用的资源，并能可靠运行。

创建基于JFFS2的根文件系统的方法如下：

• 通过解开tar包创建目标板根文件系统的内容，方法如下：

$ mkdir rootfs

$ cd rootfs

$ tar zxf /tmp/rootfs.tar.gz

• 使用工具mkfs.jffs2创建一个JFFSW文件系统映像，方法如下：

$ ROOTFS_DIR=rootfs # 根文件系统内容目录

$ ROOTFS_EBSIZE=0x20000 # 闪存的擦除块大小

$ ROOTFS_ENDIAN=b # 目标板系统是大端字节序

$ ROOTFS_DEVICES=rootfs_devices.tab # 设备描述表文件

$ ROOTFS_IMAGE=jffs2.img # 产生的文件系统映像

$ mkfs.jffs2 -U \

-d ${ROOTFS_DIR} \

-D ${ROOTFS_DEVICES} \

-${ROOTFS_ENDIAN} \

-e ${ROOTFS_EBSIZE} \

-o ${ROOTFS_IMAGE}

mkfs.jffs2: skipping device_table entry '/dev': no parent directory!

注意：如果写JFFSW文件系统到NAND flash设备中时，不需要加"-n"或"选项，--no-cleanmarkers"，因为不需要清除的标识。

启动内核时，终端显示缺省的分区映射表，列出如下：

0x00000000-0x00040000 : "u-boot"

0x00040000-0x00100000 : "kernel"

0x00100000-0x00200000 : "user"

0x00200000-0x00400000 : "initrd"

0x00400000-0x00600000 : "cramfs"

0x00600000-0x00800000 : "jffs"

0x00400000-0x00800000 : "big_fs"

使用U-Boot装载和存储JFFS2映像到最后一个分区，并建立Linux启动参数，将该映像作为根设备，方法如下：

• 擦除flash

=> era 40400000 407FFFFF

................. done

Erased 35 sectors

• 下载JFFS2映像

=> tftp 100000 /tftpboot/TQM860L/jffs2.img

Using FEC ETHERNET device

TFTP from server 192.168.3.1; our IP address is 192.168.3.80

Filename '/tftpboot/TQM860L/jffs2.img'.

Load address: 0x100000

Loading: #################################################################

done

Bytes transferred = 2033888 (1f08e0 hex)

• 拷贝映像到flash

=> cp.b 100000 40400000 ${filesize}

Copy to Flash... done

• 建立使用flash分区6作为根设备的启动参数

=> setenv mtd_args setenv bootargs root=/dev/mtdblock6 rw rootfstype=jffs2

=> printenv addip

addip=setenv bootargs ${bootargs} ip=${ipaddr}:${serverip}:${gatewayip}:${netmask}:${hostname}:${=> setenv flash_mtd 'run mtd_args addip;bootm ${kernel_addr}'

=> run flash_mtd

Using FEC ETHERNET device

TFTP from server 192.168.3.1; our IP address is 192.168.3.80

Filename '/tftpboot/TQM860L/uImage'.

Load address: 0x200000

Loading: #################################################################

done

Bytes transferred = 719233 (af981 hex)

## Booting image at 40040000 ...

（3）根文件系统在cramfs文件系统上

cramfs是压缩的仅读文件系统，作为根文件系统的优点是：文件系统是压缩的，可有效利用闪存空间；允许快速启动，因为仅装载使用的文件，且仅解压缩。缺点是：仅能替换整个映像文件而非单个文件；需要附加的存储空间给可写的永久数据；工具mkcramfs不支持设备表。

创建基于cramfs的根文件系统的方法列出如下：

• 通过解开tar包创建目标板根文件系统的内容，方法如下：

$ mkdir rootfs

$ cd rootfs

$ tar zxf /tmp/rootfs.tar.gz

• 创建需要的设备文件，这里通过解开仅含有设备文件条目的tar包来实现，方法列出如下：

# cd rootfs

• # tar -zxf /tmp/devices.tar.gz
• 许多工具需要一些存储地方，这里提供了一个小的可写文件系统。临时文件系统tmpfs是一个选择，为了创建tmpfs文件系统，需要将下面的行加入到脚本/etc/rc.sh中：

# 挂接tmpfs，是因为根文件系统仅读

/bin/mount -t tmpfs -o size=2M tmpfs /tmpfs

• 一些工具需要对某些设备节点有写权限，如：改变属主和权限，可动态创建设备节点，如：/dev/log。这些设备文件需要放在一个可写的文件系统中，仅读的根文件系统用符号链接指向可读设备到新的位置（即在可读写文件系统中的位置），对应符号链接位置部分列出如下：

dev/ptyp0 € /tmpfs/dev/ptyp0 dev/ttyp0 € /tmpfs/dev/ttyp0

dev/ptyp1 € /tmpfs/dev/ptyp1 dev/ttyp1 € /tmpfs/dev/ttyp1

dev/ptyp2 € /tmpfs/dev/ptyp2 dev/ttyp2 € /tmpfs/dev/ttyp2

• 为了放置相应的目录与设备文件在tmpfs文件系统，放置下面的代码在/etc/rc.sh脚本中：

mkdir -p /tmpfs/tmp /tmpfs/dev \

/tmpfs/var/lib/dhcp /tmpfs/var/lock /tmpfs/var/run

while read name minor

do

mknod /tmpfs/dev/ptyp$name c 2 $minor

mknod /tmpfs/dev/ttyp$name c 3 $minor

done <<__EOD__

0 0

1 1

2 2

……

e 14

f 15

__EOD__

chmod 0666 /tmpfs/dev/*

• 使用工具mkcramfs创建cramfs文件系统映像，方法如下：

$ ROOTFS_DIR=rootfs # 带有根文件系统内容的目录

$ ROOTFS_ENDIAN="-r" # 目标板系统有相反的字符序列

$ ROOTFS_IMAGE=cramfs.img # 产生的文件系统映像

PATH=/opt/eldk/usr/bin:$PATH

mkcramfs ${ROOTFS_ENDIAN} ${DEVICES} ${ROOTFS_DIR} ${ROOTFS_IMAGE}

Swapping filesystem endian-ness

bin

dev

etc

...

-48.78% (-86348 bytes) in.ftpd

-46.02% (-16280 bytes) in.telnetd

-45.31% (-74444 bytes) xinetd

Everything: 1864 kilobytes

Super block: 76 bytes

CRC: c166be6d

warning: gids truncated to 8 bits. (This may be a security concern.)

• 可以使用前面JFFS2文件系统的方法建立启动参数，只是将启动参数设置到"rootfstype=cramfs "。

（4）根文件系统在仅读的ext2文件系统上

在闪存上使用标准的ext2文件系统不合适，因为它不含有任何类型的wear leveling，在闪存上的可写文件系统需要有wear leveling保护，需要对无序异常系统关闭有强壮的保护。使用仅读的ext2文件系统将可不需要这些保护。

挂接ext2文件系统时可挂接成仅读的，在某些情况下仅读的ext2文件系统很有用，如：根文件系统在闪存卡上。

仅读ext2文件系统优点是速度快，占用较少的RAM。缺省是由于没有压缩而占用较多的闪存。

与cramfs文件系统作为根文件系统一样，仅读ext2文件系统作为根文件系统，还需要使用tmpfs这样的可写文件系统，存放可写的文件数据。

仅读ext2文件系统作为根文件系统的操作步骤与cramfs文件系统一样，创建方法列出如下：

• 通过解开tar包创建目标板根文件系统的内容，方法如下：

$ mkdir rootfs

$ cd rootfs

$ tar zxf /tmp/rootfs.tar.gz

• 像cramfs根文件系统一样，这里使用tmpfs作为可写的文件系统，并添加下面的行在/etc/rc.sh脚本中：

# 因为根文件系统是仅读，所以挂接tmpfs文件系统作为可写的文件系统

/bin/mount -t tmpfs -o size=2M tmpfs /tmpfs

• 创建设备文件的符号链接放在可写的文件系统中，符号链接从仅读文件系统到可写文件系统，符号链接的目录如下：

dev/ptyp0 € /tmpfs/dev/ptyp0 dev/ttyp0 € /tmpfs/dev/ttyp0

dev/ptyp1 € /tmpfs/dev/ptyp1 dev/ttyp1 € /tmpfs/dev/ttyp1

• 放置相应目录和设备文件在tmpfs文件系统中，将下面的代码放在/etc/rc.sh脚本中：

mkdir -p /tmpfs/tmp /tmpfs/dev \

/tmpfs/var/lib/dhcp /tmpfs/var/lock /tmpfs/var/run

while read name minor

do

mknod /tmpfs/dev/ptyp$name c 2 $minor

mknod /tmpfs/dev/ttyp$name c 3 $minor

done <<__EOD__

0 0

1 1

2 2

3 3

4 4

5 5

6 6

7 7

8 8

9 9

a 10

b 11

c 12

d 13

e 14

f 15

__EOD__

chmod 0666 /tmpfs/dev/*

• 使用genext2fs工具创建ext2文件系统映像，方法如下：

$ ROOTFS_DIR=rootfs # 根文件系统内容的目录

$ ROOTFS_SIZE=3700 # 文件系统映像的大小

$ ROOTFS_FREE=100 # 期望的空闲空间

$ ROOTFS_INODES=380 # 节点号

$ ROOTFS_DEVICES=rootfs_devices.tab # 设备描述文件

$ ROOTFS_IMAGE=ext2.img # 产生的文件系统映像

$ genext2fs -U \

-d ${ROOTFS_DIR} \

-D ${ROOTFS_DEVICES} \

-b ${ROOTFS_SIZE} \

-r ${ROOTFS_FREE} \

-i ${ROOTFS_INODES} \

${ROOTFS_IMAGE}

• 可以使用前面JFFS2文件系统的方法建立启动参数，只是将启动参数设置到"rootfstype=ext2 "。

（5）根文件系统在闪存卡上

可在闪存卡（如：CF、SD、MMC等）上使用仅读ext2文件系统 作为根文件系统，用于启动系统。方法如下：

• 将用工具genext2fs制作的ext2文件系统映像文件ext2.img拷贝到CF卡上，下面列出使用U-Boot拷贝映像文件到CF卡上的方法：

=> tftp 100000 /tftpboot/TQM860L/ext2.img

Using FEC ETHERNET device

TFTP from server 192.168.3.1; our IP address is 192.168.3.80

Filename '/tftpboot/TQM860L/ext2.img'.

Load address: 0x100000

Loading: #################################################################

done

Bytes transferred = 3788800 (39d000 hex)

=> ide part

Partition Map for IDE device 0 -- Partition Type: DOS

Partition Start Sector Num Sectors Type

1 32 500704 6

=> ide write 100000 20 1ce8 #装载地址，第一个分区的起始扇区，扇区数

IDE write: device 0 block # 32, count 7400 ... 7400 blocks written: OK

命令ide write用16进制参数，每个扇区数为512字节，0x20为第一个分区的起始扇区，扇区数计算方法为：3788800/512 = 7400 = 0x1CE8 。

• 设置启动参数，将CF的分区作为仅读根设备，方法如下：

=> setenv cf_args setenv bootargs root=/dev/hda1 ro

=> setenv flash_cf 'run cf_args addip;bootm ${kernel_addr} - ${fdt_addr}'

=> setenv bootcmd run flash_cf

（6）根文件系统在FAT文件系统的一个仅读文件中

在用户嵌入式设备上，用户可使用CF、MMC或SD卡等通用存储介质存储Linux内核和根文件系统。用户可能期望Internet发布软件更新：客户可以从用户的网站下载更新文件，或者将映像文件通过Email发送给客户，客户可将文件拷贝到CF卡上，该CF卡仅有一个FAT或VFAT文件系统，不能直接用作Linux根文件系统，这需要进行一些处理，下面是其中的一种解决方法。

用户的发布软件由两个文件组成，第一个文件是Linux内核带有一个很小的ramdisk映像（U-Boot使用多个文件映像），U-boot能从FAT或VFAT文件系统装载和启动这些映像文件。第二个文件是根文件系统。为了方便和速度，这里使用ext2文件系统作为根文件系统。当Linux启动时，启动刚开始时，它使用附加的ramdisk作为根文件系统。在ramdisk中的程序会以仅读的方式挂接FAT或VFAT文件系统。接着，可使用loop设备将根文件系统与块设备联系起来。最后使用pivot_root切换根文件系统到CF卡上的映像。详细步骤说明如下：

• 用前面制作仅读ext2根文件系统的方法制作ext2.img映像文件。
• 用前面制作ramdisk映像的方法制作初始ramdisk，需要加入空目录bin、dev、etc、lib、loopfs、mnt、proc和sysroot，加入文件bin/nash（脚本解释器）、linuxrc脚本和从sbin到bin的符号链接，列出如下：

drwxr-xr-x 2 wd users 4096 Apr 13 01:11 bin

-rwxr-xr-x 1 wd users 469512 Apr 11 22:47 bin/nash

drwxr-xr-x 2 wd users 4096 Apr 12 00:04 dev

drwxr-xr-x 2 wd users 4096 Apr 12 00:04 etc

drwxr-xr-x 2 wd users 4096 Apr 12 00:04 lib

-rwxr-xr-x 1 wd users 511 Apr 13 01:28 linuxrc

drwxr-xr-x 2 wd users 4096 Apr 12 00:04 loopfs

drwxr-xr-x 2 wd users 4096 Apr 12 00:09 mnt

drwxr-xr-x 2 wd users 4096 Apr 12 00:04 proc

lrwxrwxrwx 1 wd users 3 Jun 12 18:54 sbin -> bin

drwxr-xr-x 2 wd users 4096 Apr 12 00:04 sysroot

• 还需要用于创建初始ramdisk的小规模设备表，列出如表3。

表3 创建初始ramdisk的小规模设备表

• 创建初始ramdisk，方法如下：

$ INITRD_DIR=initrd

$ INITRD_SIZE=490

$ INITRD_FREE=0

$ INITRD_INODES=54

$ INITRD_DEVICES=initrd_devices.tab

$ INITRD_IMAGE=initrd.img

$ genext2fs -U \

-d ${INITRD_DIR} \

-D ${INITRD_DEVICES} \

-b ${INITRD_SIZE} \

-r ${INITRD_FREE} \

-i ${INITRD_INODES} \

${INITRD_IMAGE}

$ gzip -v9 ${INITRD_IMAGE}

结果产生了一个233KB的压缩的ramdisk映像。

• 假定用户已编译了Linux内核映像，现可以用mkimage编译一个U-Boot多文件映像，将Linux内核与初始的ramdisk组合起来，方法如下：

$ LINUX_KERNEL=linuxppc_2_4_devel/arch/ppc/boot/images/vmlinux.gz

$ mkimage -A ppc -O Linux -T multi -C gzip \

> -n 'Linux with Pivot Root Helper' \

> -d ${LINUX_KERNEL}:${INITRD_IMAGE}.gz linux.img

Image Name: Linux with Pivot Root Helper

Created: Mon Jun 13 01:48:11 2005

Image Type: PowerPC Linux Multi-File Image (gzip compressed)

Data Size: 1020665 Bytes = 996.74 kB = 0.97 MB

Load Address: 0x00000000

Entry Point: 0x00000000

Contents:

Image 0: 782219 Bytes = 763 kB = 0 MB

Image 1: 238433 Bytes = 232 kB = 0 MB

新创建的linux.img是必须拷贝到CF卡中的第二个映像文件。

• linuxrc脚本用于完成根文件系统的设置，其内容列出如下：

#!/bin/nash #用nash脚本解释器解析此文件

echo Mounting /proc filesystem

mount -t proc /proc /proc #挂接/proc文件系统，用于查询一些需要信息

echo Creating block devices

mkdevices /dev #为列在/proc/partitions中的所有分区创建块设备条目

echo Creating root device

mkrootdev /dev/root #为新根文件系统创建块设备

echo 0x0100 > /proc/sys/kernel/real-root-dev

echo Mounting flash card

mount -o noatime -t vfat /dev/hda1 /mnt #挂接CF卡，假定它仅有一个分区在/dev/hda1上

echo losetup for filesystem image

#在CF卡上的根文件系统映像名为rootfs.img，使用用loop设备挂接

losetup /dev/loop0 /mnt/rootfs.img

echo Mounting root filesystem image

mount -o defaults --ro -t ext2 /dev/loop0 /sysroot

echo Running pivot_root

pivot_root /sysroot /sysroot/initrd #将/sysroot作为新的根文件系统

上面的脚本有点小缺陷：由于CF卡挂接在ramdisk中一个目录下，以便能够从根文件系统映像访问。这意味着用户不能卸载（umount）CF卡，阻止用户释放初始ramdisk的空间，将永久失去450kb左右的RAM（用于ramdisk）。

• 首先，在目标板上拷贝2个映像文件到CF卡，方法如下：

bash-2.05b# fdisk -l /dev/hda

Disk /dev/hda: 256 MB, 256376832 bytes

16 heads, 32 sectors/track, 978 cylinders

Units = cylinders of 512 * 512 = 262144 bytes

Device Boot Start End Blocks Id System

/dev/hda1 * 1 978 250352 6 FAT16

bash-2.05b# mkfs.vfat /dev/hda1

mkfs.vfat 2.8 (28 Feb 2001)

bash-2.05b# mount -t vfat /dev/hda1 /mnt

bash-2.05b# cp -v linux.img rootfs.img /mnt/

`linux.img' -> `/mnt/linux.img'

`rootfs.img' -> `/mnt/rootfs.img'

bash-2.05b# ls -l /mnt

total 4700

-rwxr--r-- 1 root root 1020729 Jun 14 05:36 linux.img

-rwxr--r-- 1 root root 3788800 Jun 14 05:36 rootfs.img

bash-2.05b# umount /mnt

• 现准备用U-Boot从CF卡装载uMulti文件（将Linux内核和初始ramdisk组合在一起），并启动它，方法如下：

=> setenv fat_args setenv bootargs rw

=> setenv fat_boot 'run fat_args addip;fatload ide 0:1 200000 linux.img;bootm'

=> setenv bootcmd run fat_boot

覆盖层文件系统

覆盖层文件系统（Overlay File System）mini_fo是一个虚拟内核文件系统，作为附加层插入在VFS（虚拟文件系统）与本地文件系统之间，能让仅读文件系统成为可写的。它通过重定向修改操作到可写的存储目录来实现的，并保留初始数据在仅读的基本目录中。在读操作时，操作系统整合修改的和初始的数据，让读操作读出最新的数据。这些对用户都是透明的，用户访问数据就像在可读写文件系统中一样进行操作。

在嵌入式系统中，mini_fo覆盖根文件系统，它被挂接在常规根文件系统的顶部，允许用户透明地进行修改操作，并将修改定向到不同的目录位置。这样，仅读的根文件系统变成可读写操作的文件系统。

嵌入式系统的根文件系统通常是仅读的，如：cramfs或仅读的ext2。但有时需要修改根文件系统，如：应用较小的软件更新而不必烧录整个根文件系统映像到flash，开发时需要对根文件系统进行频繁修改。这时，可通过挂接在根文件系统上面的mini_fo，将修改操作定向到可写的文件系统，如：在闪存上的JFFS2文件系统，甚至于在开发时，还可定向到外部的硬盘。

当根文件系统需要非永久性修改时，常使用ramdisk，不好的方面是：ramdisk使用大量的RAM，并且在启动时将ramdisk映像拷贝到RAM花费时间较多。作为替换，可使用覆盖层文件系统覆盖在仅读文件系统上，用tmpfs文件系统作为可写的文件系统，仅将修改的文件存放在RAM中，这样，可节省启动时间和RAM。

使用覆盖层文件系统mini_fo可以很容易复位到出厂时的缺省配置，恢复缺省配置仅需要删除修改操作所存储的目录内容。

通常在根文件系统上覆盖mini_fo文件系统，用于两种 场景：启动单个应用程序和启动整个系统，分别说明如下：

（1）在改变根目录的覆盖文件系统中启动单个应用程序

假定"/"是仅读的根文件系统，/dev/mtdblock5含有一个小的JFFS2闪存分区，用于存放应用程序"/usr/bin/autopilot"的修改。

# mount -t jffs2 /dev/mtdblock5 /tmp/sto //挂接用于存放数据的文件系统

# insmod mini_fo.o //插入文件系统mini_fo的内核模块

//基目录为"/"，存储目录为"/tmp/sto/"，挂接点为"/mnt/mini_fo/"

# mount -t mini_fo -o base=/,sto=/tmp/sto/ / /mnt/mini_fo/

# cd /mnt/mini_fo/

# chroot . /usr/bin/autopilot //将当前目录作为应用程序autopilot的根目录

（2）在改变根目录的覆盖文件系统中启动整个系统

在根文件系统已经挂接之后，在init启动之前，需要挂接mini_fo文件系统，这样做的最好办法是使用脚本，将mini_fo文件系统挂接在根文件系统之上，接着在改变了根目录的覆盖文件系统中启动init。假定脚本名为overlay_init，存储在/sbin中。脚本的内容列出如下：

#!/bin/bash

#

# mount mini_fo overlay file system and execute init

#

# make sure these exist in the read-only file system

STORAGE=/tmp/sto

MOUNT_POINT=/mnt/mini_fo/

# mount tmpfs as storage file system with a maximum size of 32MB

mount -t tmpfs -o rw,size=32M none $STORAGE

/sbin/modprobe mini_fo

mount -t mini_fo -o base=/,sto=$STORAGE / $MOUNT_POINT

exec /usr/sbin/chroot $MOUNT_POINT /sbin/init

echo "exec chroot failed, bad!"

exec /bin/sh

exit 1

在boot loader中，将"init"内核参数设置为"init=/sbin/overlay_init"。

如果需要覆盖文件系统访问最初的非覆盖的文件系统的根目录，可使用命令pivot_root。

调试

嵌入式系统同样使用GNU调试器gdb进行调试，gdb的图形前端常用ddd，嵌入式系统还用BDM/JTAG调试器工具（如：BDI2000）协助调试。