请教一个Linux内核安装思路的问题

虚缘

各位高手，请教一个问题，我现在想做以下一个事情：
自己动手定义一个内核、将其做成一个独立的操作系统或者放在安装盘中去启动。最终实现的效果是－生成一个几MB的系统安装在机器中，里面有定义好的功能。

我现在只是知道装好一个系统如何做内核编译去除一些不必要的功能，或者不需要安装大量的软件来对Linux廋身和提升执行速率，但是我怎样才能完整的自定义一个属于我想要的系统呢？

我感觉可能是：
用一个Linux引导盘引导到Linux系统，然后拷贝Linux内核源码到系统中去编译生成一个自定义的系统并安装一些想要的工具，并加载好Grub，然后重启就可以了是吗？


请教高手
多谢

cnhnln

动手制做自己的一张软盘大小的Linux
　　
　　凡是接触计算机久的朋友肯定都使用过DOS启动软盘，至于启动
软盘的重要性大家肯定也都清楚。在Linux底下启动软盘同样重要，
它不仅能测试新内核、恢复系统错误，而且能升级重要的系统文件。
但是在L inux下制做启动盘不象在DOS下那么容易，下面我就一步一
步的教大家制做自己系统的启动软盘。
　　
　　1. Linux启动过程简介 一个启动盘实际上是一个完整系统的缩
影，它能够执行一个完整系统的大部分功能。因此，如果想制做Linux
启动盘，你必须了解Linux系统启动的基本过程。接下来我就先简要
介绍一下L inux的启动过程。
　　
　　所有的PC机都是通过执行ROM中的代码加载启动盘的0柱面0扇区
中的代码来启动整个系统。在Linux系统中启动盘的0柱面0扇区中含
有的是启动装载器L ILO，它定位内核，装载它，最后执行它。一旦
内核装载后，它先是进行基本设备初始化，接着试图加载并登陆磁盘
中根文件系统，如果内核找不到可装载的根文件系统，启动过程会就
此停止。如果根文件系统装载完毕并登陆成功后，你会看到一行信息
：
　　VFS: Mounted root (ext2 filesystem) readonly.  之后，系
统发现init程序并执行它，init程序寻找它的配置文件/etc/inittab，
并开始执行其中的脚本，这些脚本是一些SHELL命令的组合，用来执
行如下命令，如加载所需模块、装载S WAP、初始化网络、装载fstab
中列出的所有驱动器等。最后启动一个叫getty的程序，它负责console
和ttys之间的通信，它在显示器上打印l ogin提示符并激活login程
序，login处理登陆的有效性并建立与用户的对话。至此，启动过程
完毕。
　　
　　2.制做启动盘 创建一个启动盘首先必须创建根文件系统，由于
软盘容量有限，因此常采用压缩的根文件系统。下面我就详细的介绍
怎样创建压缩格式根文件系统。
　　
　　2.1准备 一个根文件系统必须包括支持完整Linux系统的全部东
西，因此，它至少应包括以下几项：
　　·基本文件系统结构 ·至少含有以下目录：/dev, /proc, /bin,
/etc, /lib, /usr, /tmp  ·最基本的应用程序，如sh, ls, cp, mv
等 ·最低限度的配置文件，如rc, inittab, fstab等 ·设备：/dev/hd*,
/dev/tty*, /dev/fd0  ·基本程序运行所需的库函数
　　由于以上所需文件远超过1.44M，因此我们通常的做法是先准备
好内容后再压缩到软盘中，当用软盘启动时，再把文件解压到内存中，
形成一个虚拟盘（R AMDISK），通过RAMDISK控制系统启动。
　　为了能创建以上的根文件系统，你必须有一个空闲的能够放下大
约4M文件的RAMDISK。
　　如果你使用LILO控制启动，先检查一下LILO的配置文件/etc/lilo.conf
中定义的RAMDISK的大小。/etc/lilo.conf中有一行 RAMDISK_SIZE =
nnn  它决定RAMDISK可使用的最大内存为nnn，缺省情况下为4096K，
对我们来说够了，但是顺便说一下，如果你的系统只有8M内存，千万
不要使用4 M的RAMDISK。再检查一下你的系统设备中是否有一个叫/dev/ram0
或/dev/ram的设备，这是RAMDISK的设备名，如果没有，用命令mknod
创建一个设备/ dev/ram0。
　　
　　2.2创建根文件系统 Linux内核识别两种可以直接拷贝到RAMDISK
的文件系统，它们是minix和ext2，ext2性能更好。如果你使用ext2，
你会发现使用-i选项定义比缺省更多的信息节点非常有用。mke2fs缺
省情况下在1.44M的软盘上产生3 60个信息节点，使用压缩格式的根
文件系统需要更多的信息节点，所以使用如下命令创建文件系统可以
创建2000个信息节点，一般不会用光：
　　mke2fs -m 0 -i 2000 /dev/ram0  mke2fs将会自动判断设备容
量的大小并相应的配置自身，-m 0参数防止它给root保留空间，这样
会腾出更多的有用空间。接着把虚拟盘挂在节点/mnt上：
　　mount -t ext2 /dev/ram0 /mnt  如果没有节点/mnt，建一个。
　　接着是创建目录。根文件系统最少应该有如下8个目录：
　　/dev–设备 /proc -- proc文件系统所需目录 /etc–系统配置
文件 /sbin–重要的系统程序 /bin–基本应用程序 /lib–共享函数
库 /mnt–装载其他磁盘节点 /usr–附加应用程序 其中/proc,/mnt
和/usr在此情况下都是空的，只需要用mkdir创建它们既可。其余的
目录应根据需要分别创建，下面我一个一个的详细叙述。
　　·/dev：/dev中含有系统不可缺少的设备文件，虽然该目录很普
通，可以用mkdir创建，然而目录中的设备文件必须用mknod创建，当
然也有捷径，你可以把现有系统中/dev的文件拷贝过来，然后删除不
必要的文件。命令c p -dpR /dev /mnt会拷贝/dev整个目录但不拷贝
文件内容，dp开关保证链结文件仍然不变，不会拷贝链结所指原文件，
而且属性不变。
　　必须注意的是，每一个设备文件占用一个信息节点，而软盘上节
点数是有限的，因此有必要删除没用的设备文件。例如，如果你没有SCSI
设备，删除所有的以sd开头的文件。如果你不想使用串口设备，删除
所有以cua开头的文件。不过记住一定要保留console, kmem, mem, null,
ram, tty1等文件。
　　·/etc：这个目录中含有一些必不可少的系统配置文件，那么到
底哪些文件是必需的，哪些可有可无呢？告诉你一个小窍门，用命令ls
–ltru，该命令会根据最后使用日期反列一下目录/etc中的文件，如
果一些文件很长时间没有被进入过，基本上可以从你的启动盘中删去
。
　　
　　我的启动盘中含有不到15个配置文件，大致可分为3部分：
　　
　　（1）启动盘中必须含有的文件 ·rc.d/* --系统启动脚本 ·fstab
–列出要登陆的文件系统 ·inittab–包含启动过程参数 而且这些
文件都是最简单的。rc应该包括：
　　#!/bin/sh  /bin/mount -av  /bin/hostname yjy  fstab应包
括：
　　/dev/ram0 / ext2 defaults  /dev/fd0 / ext2 defaults  /proc
/proc proc defaults  inittab包括：
　　id:2:initdefault:  si::sysinit:/etc/rc  1:2345:respawn:/sbin/getty
9600 tty1  2:23:respawn:/sbin/getty 9600 tty2  （2）整理系
统所需文件 ·passwd–用户名和目录.  ·group–用户组 ·shadow
–用户加密密码 如果你觉得这不安全，就把passwd和shadow删掉，
这样只有root可以进入系统。
　　（3）偶尔使用的文件，可根据自己的实际情况选择。
　　
　　·/bin和/sbin：该目录中包含有必不可少的应用程序，如ls, mv,
cat，你可以根据自己的需要选择，不过一定要记住包括以下程序：init,
getty，login, mount，运行你的rc的外壳shell。
　　·/lib:该目录中包含有你的启动盘启动过程中所需要的共享函
数库，如果缺少必须的函数库，系统会停止启动或出现一大堆错误信
息，所以一定要注意。
　　几乎所有的程序都需要libc库，列一下目录/lib中的libc：
　　% ls -l /lib/libc*  -rwxr-xr-x 1 root root 4016683 Apr 16
18:48 libc-2.1.1.so*  lrwxrwxrwx 1 root root 13 Apr 10 12:25
libc.so.6 -> libc-2.1.1.so*  libc.so.6的6表示版本号，它指向
的文件才是你真正需要的。
　　查看每一个程序使用的函数库，用命令ldd，如：
　　% ldd /sbin/mke2fs  libext2fs.so.2 => /lib/libext2fs.so.2
(0x40014000)  libcom_err.so.2 => /lib/libcom_err.so.2 (0x40026000)
  libuuid.so.1 => /lib/libuuid.so.1 (0x40028000)  libc.so.6
=> /lib/libc.so.6 (0x4002c000)  /lib/ld-linux.so.2 =>
/lib/ld-linux.so.2
(0x40000000)  输出右边的库都是必须的，有的可能是链结文件。
　　在/lib目录下你还必须有函数库装载器，这个装载器或是ld.so
(对a.out库)或是ld-linux.so (对ELF库)。新版本的ldd一般会告诉
你所需库的加载器。
　　把装载器和库拷贝到/lib后，在仔细检查一遍，一定保证没有遗
漏。
　　
　　2.3模块 如果你有一个模块化的内核，你还得必须考虑需要加载
的模块，它们都位于/lib/modules,你可以把不是很重要的模块放到
别的盘上，当系统启动后在加载，这样会节省启动盘的空间。
　　
　　2.4打包 一旦你完成了上述工作，卸下虚拟盘，拷贝到一个文件
中，然后压缩。
　　umount /mnt  dd if=/dev/ram0 bs=1k│gzip -v9 > rootfs.gz
  压缩结束后，你就拥有了一个压缩的根文件系统，不过你得检查它
的大小，如果大了，你还得去掉一些东西。
　　3.选择内核
　　在你完成了制做压缩的根文件系统后，下一步就是选择或自己创
建一个内核。多数情况下，你可以拷贝现有系统的内核，但是有些情
况下，你不得不自己另外创建一个。最可能出现的问题就是容量限制
：如果你想做单张的启动盘，盘中最大的文件往往是内核，所以你必
须想方设法压缩内核的体积。要想压缩内核体积，创建它时就得把不
必要的功能去掉，如去掉对网络的支持和对不必要设备的支持，但是
一定要记住保留内核对R AMDISK和ext2的支持，否则你的启动盘将不
能工作。还有就是要记住把对你备份所用设备的支持加到内核中去，
因为启动盘的最大用处就是检测和修复损坏的系统，如果你没有把对
备份设备的支持加到内核中去，你将没有办法修复损坏的系统，只能
再重装L inux。
　　
　　创建新内核的方法我就不在此叙述了，如有问题，请查阅相关资
料。重建完内核后记住用“make zImage”压缩内核。
　　
　　4.整合
　　有了根文件系统和内核之后，最后的工作就是把它们整合在一起
。
　　
　　先检查总文件的大小，如果超出1.44M，就得考虑重新创建所需
或用两张磁盘，即使用两张磁盘，你的根文件系统也得小于1.44M。
　　
　　接着就是确定是用LILO控制启动还是直接用拷贝到盘上的内核控
制启动。用LILO的好处是你能增加支持初始化硬件的参数到内核中，
缺点是较复杂且占用珍贵的磁盘空间，不过我还是建议使用L ILO控
制系统启动。下面我就介绍用LILO的过程，直接用拷贝到盘上的内核
控制启动的方法就不作叙述了。
　　
　　用LILO控制启动首先就得写一个LILO配置文件，以下是一个最简
单的配置文件，但是已经够用了。
　　
　　boot =/dev/fd0  
　　install =/boot/boot.b  
　　map =/boot/map  
　　read-write  
　　backup =/dev/null  
　　compact  
　　image = KERNEL  
　　label = Bootdisk  
　　root =/dev/fd0  
　　参数说明见相关资料。然后把它命名为bdlilo.conf。
　　
　　接下来就是创建一个内核文件系统。把一张干净的软盘插入软驱，
在上面创建ext2文件系统。
　　
　　mke2fs -i 8192 -m 0 /dev/fd0 50  
　　“-i 8192”表示每8192位创建一个信息节点。接着登陆系统：
　　
　　mount /dev/fd0 /mnt  
　　rm -rf /mnt/lost+found  
　　mkdir /mnt/{boot,dev}  
　　删去目录/ lost+found,创建两个目录/boot和/dev。
　　
　　再拷贝现有系统中的到目录/dev中，
　　cp -R /dev/{null,fd0} /mnt/dev  
　　接着拷贝启动加载器boot.b到目录/boot中，
　　cp /boot/boot.b /mnt/boot  
　　最后，拷贝你创建的配置文件bdlilo.conf和内核到内核文件系
统的根目录下，
　　cp bdlilo.conf KERNEL /mnt  
　　现在，根文件系统所需所有文件都准备就绪了，你可以运行它了，
运行结果应该没有错误，否则就应该仔细检查一下。最终的文件目录
应该如下所示：
　　--------------------------------------------------------------------------------
  
　　total 361  
　　1 -rw-r--r-- 1 root root 176 Jan 10 07:22 bdlilo.conf  
　　1 drwxr-xr-x 2 root root 1024 Jan 10 07:23 boot/  
　　1 drwxr-xr-x 2 root root 1024 Jan 10 07:22 dev/  
　　358 -rw-r--r-- 1 root root 362707 Jan 10 07:23 vmlinuz

　　boot:  
　　total 8  
　　4 -rw-r--r-- 1 root root 3708 Jan 10 07:22 boot.b  
　　4 -rw------- 1 root root 3584 Jan 10 07:23 map  
　　dev:  
　　total 0  
　　0 brw-r----- 1 root root 2, 0 Jan 10 07:22 fd0  
　　0 crw-r--r-- 1 root root 1, 3 Jan 10 07:22 null  
　　接着设置内核镜像文件中的ramdisk的偏移量以指出如何确定定
位根文件系统。该指示词可以通过命令rdev来设置，它的内容含义如
下所示：
　　
　　bits 0-10: ramdisk开始的偏移量,在1024 byte数据块中
　　bits 11-13:不用
　　bit 14: ramdisk加载的提示标记
　　bit 15:加载根文件系统之前提示标记
　　如果位15被设置，当系统盘启动时将会提示你准备好另一张软盘，
如果你的启动盘是两张的话，这个设置很有用。
　　
　　对于使用单张和两张启动盘的用户，ramdisk的偏移量是不同的
：
　　
　　如果你的启动盘只有一张，那么压缩的根文件系统会被放置在内
核之后，因此偏移量将会是第一个空闲的数据块，bit 14应设置为1，bit
15设置为0。例如，如果你的启动盘根文件系统起始于数据块253
（十进制），你的ramdisk偏移量应该是253 + 214 = 253 + 16384 =
16637。
　　
　　如果你的启动盘有两张，那么你的根文件系统起始于第二张盘的0
数据块，所以偏移量是0，bit 14应设置为1，bit 15应设置为1，最
终值为 214 + 215 = 49152。
　　
　　计算好偏移量后，用命令rdev–r进行设置，记住用十进制：
　　
　　rdev -r /mnt/vmlinuz偏移量
　　设置完后，从/mnt卸下软盘。
　　
　　最后一步是传输根文件系统，分两种情况：
　　·如果你的内核于根文件系统在同一张软盘上，用加选项seek的
命令dd传输，dd if=rootfs.gz of=/dev/fd0 bs=1k seek=内核数据
块数。
　　·如果根文件系统位于第二张软盘上，移走第一张软盘，插入第
二张盘，然后传输根文件系统dd if=rootfs.gz of=/dev/fd0 bs=1k
。
　　
　　祝贺你，你的系统启动盘已经做好了，剩下的就是测试你的启动
盘的正确性了，如果有问题，对不起，你还得从头再来。
　　
　　现在许多Linux的发行套件中都有厂家做好的启动盘，它们的制
做原理和以上我介绍的大同小异，但是它们常常用许多不同的技巧，
因为它们要面对更多的硬件和各种可能发生的情况。大家可以拿一张
来慢慢研究，你会从中学到很多知识。
　　
　　最后祝大家都能作出一张称心如意的启动盘，让你的linux永保
青春。
　　

cnhnln

自己作一张软盘的linux
http://www.chinaunix.net作者:wolf2602
发表于：2003-05-10 09:11:28
　　好些时候，我们需要一个只要一张软盘就能启动Linux的系统，
比如说做路由器。但是我们该怎样做呢？也就是说我们要把Kernel和FileSystem
都做在一张3.5'的盘上。我们先把FileSystem分解成如下几个部分吧
。
　　
　　1. /bin目录下的文件
　　bin目录通常是放置系统的一些基本命令文件的目录，要保证你
的系统能够正常启动而且能够完成必要的功能，你需要在/bin目录下
放置如下文件:  
　　ksh--->shell是不可少的。
　　
　　more-->要知道Linux下可没有type命令哦。
　　
　　dmesg->虽然你很熟悉你的系统硬件，但是有它还是方便多了。
　　
　　ps---->检查系统进程是管理员的良好习惯。
　　
　　login->总不至于不要人家登录吧，再说它也是底层系统的构成
呀。
　　
　　sync-->更新磁盘的Block，很有好处啊。
　　
　　mount->除非你不要文件系统就不需要它。
　　
　　umount->卸载文件系统的东东。
　　
　　kill-->杀掉那些无用或停止响应的进程。
　　
　　setterm->修改终端参数的。
　　
　　hostname->显示当前机器名字。
　　
　　telnet->远程登录，你的Linux不会不干点其他的事吧！
　　
　　ping-->检查网络连接状态。
　　
　　ftp--->虽然什么也放不下，但是留下它也有好处的。
　　
　　tar--->备份很重要！即使你的系统只有一个软驱！
　　
　　killall->shutdown时系统会用它哦。
　　
　　chmod->修改文件属性的。
　　
　　chown->修改文件的归属
　　cp--->拷贝文件，修复系统时可以用啊！
　　
　　dd--->据说好多管理员常用啊，但是我还真没用过！因为我很少
进行介质拷贝。
　　
　　df--->查看磁盘使用情况。
　　
　　du--->查看指定路径的占用空间。
　　
　　ls--->你不会一次都没用过吧！
　　
　　mkdir->建目录是常事，即使在只有一张盘的情况下！
　　
　　mv--->移动文件的命令。
　　
　　rm--->删除文件，万一有多的怎么办？靠它了！
　　
　　ln--->链接文件，当然有用了！
　　
　　dircolors-->设定目录的颜色，当你用的是彩显时。
　　
　　cut-->将文件的一些行送到标准输出设备。
　　
　　cat-->把标准输入送到文件或把文件送到标准输入
　　stty-->很重要的终端命令哦！
　　
　　gzip-->打包和解包的程序
　　domainname-->查看域名。
　　
　　还要把一些东西链接起来哦
　　date@ -> /sbin/clock  less@ -> more  sh@ -> ksh  gunzip@
-> gzip  zcat@ -> gzip  bash@ -> sh  tcsh@ -> sh  
　　
　　2．/etc目录下的文件
　　etc目录是放置系统配置信息的文件目录，同时也放置了一些系
统初始化文件。
　　
　　mtab -->mounted table已经mount的FileSystem列表。
　　
　　kernel -->系统内核。
　　
　　issue -->login时的prompt信息。
　　
　　profile -->bash下的全域用户登陆时执行的批处理文件。
　　
　　psdevtab -->kernel映象的相关文件。
　　
　　inittab -->初始化列表，系统启动时要用到的东东。
　　
　　passwd -->用户的password数据库。
　　
　　motd -->message of today　用户login时显示的信息。
　　
　　fstab -->开机时要自动mount的FileSystem。
　　
　　hosts -->domain name到IP的解析文件。
　　
　　resolv.conf -->本机的IP地址和域名服务器地址配置文件。
　　
　　termcap -->终端字符映射文件。
　　
　　services -->系统启动时加载的服务项目。
　　
　　rpc -->RPC资源解释文件。
　　
　　protocols -->系统协议说明文件。
　　
　　networks -->定义本机IP和子网的配置文件。
　　
　　mtools -->mtools的parameter文件。
　　
　　hosts.deny -->设置那些目的机不能Telnet到此主机。
　　
　　hosts.allow -->和hosts.deny相反，设置可以Telnet到此机的
目的机地址。
　　
　　exports -->NFS的系统档案。
　　
　　DIR_COLORS -->设置ansi-color终端的系统颜色。
　　
　　HOSTNAME -->本机的domain name。
　　
　　inetd.conf -->inetd进程的配置文件。
　　
　　ld.so.cache -->系统lib的缓存信息。
　　
　　shells -->系统可用的shell的记录。
　　
　　host.conf -->本机的网络相关配置。
　　
　　magic -->系统内档案格式的资料。
　　
　　utmp -->当前login用户的记录。
　　
　　group -->用户组参数记录。
　　
　　ld.so.conf -->记录一些lib所在的目录。
　　
　　fastboot -->shutdown命令产生的一个文件，系统重新启动时会
检查该文件。
　　
　　3. /sbin目录下的文件
　　这个目录下放置一些系统扩展命令：
　　
　　swapoff@ -> swapon -->把swapoff连接到swapon命令
　　telinit@ -> init -->把telinit连接到init命令
　　reboot@ -> halt -->把reboot连接到halt命令
　　addswap -->增加一个交换分区，需要自己编辑一个addswap脚本
　　chkhd -->检查硬盘
　　clock -->测定设置时间
　　swapon -->打开交换分区
　　update -->bdflush的守护
　　mkswap -->格式化交换分区
　　agetty -->终端守护
　　init -->系统初始化命令
　　shutdown -->关闭系统
　　halt -->系统停机
　　killall5 -->清出所有进程
　　ifconfig -->网络配置程序
　　route -->路由设置命令
　　bdflushd -->打开buffer回写到磁盘
　　4. /usr目录下的文件
　　用户目录，目录下放置了一些用户经常需要使用的程序和一些配
置数据
　　spool@ -> ../var/adm -->连接到/var/adm  
　　tmp@ -> ../var/adm -->连接到/var/adm  
　　adm@ -> ../var/adm -->连接到/var/adm  
　　/usr/bin目录，用户命令文件目录
　　who -->查询当前登陆用户
　　superformat -->高级格式化工具
　　loadkeys -->加载键盘影射表
　　joe -->一种十分好使的编辑器
　　uptime -->查看系统从启动到现在的运行时间
　　finger -->查询用户信息
　　mcheck -->检查dos系统软盘
　　tput -->初始化终端或者查询终端信息
　　traceroute -->检查路由路径
　　host ->检查当前主机配置信息
　　split -->分割文件
　　sleep -->延迟指定时间
　　setfont -->设置字体
　　grep -->行查询指令，常常配合管道使用
　　reset -->重置系统参数
　　usr/sbin目录下放置了用户需要使用的高级指令，但我们没有使
用到，看看磁盘空间，能放些什么自己放吧。
　　
　　/usr/local目录放置了一些应用程序的配置文件
　　usr/local/lib目录
　　lynx.cfg -->lynx浏览器的配置文件　
　　usr/lib目录
　　es.map -->键盘映射文件
　　t.fnt -->字体文件
　　5. /lib目录下的文件
　　此目录下放置了系统的一些库文件，这里不做解释
　　libgpm.so@ -> libgpm.so.1  libdl.so@ -> libdl.so.1  ld-linux.so.1
  libtermcap.so.2  libm.so.5  libc.so.5  libdl.so.1  libgpm.so.1
  libtermcap.so.2  libcurses.so.1  ld.so  
　　
　　6. /dev目录，系统设备文件目录，按照标准设备定制。
　　
　　7. /var目录，主要放置系统参数和配置。
　　
　　var/adm/  utmp -->空文件，为uucp准备的tmp文件cron -->空
文件，kernel加载时的tmp文件/var/spool/locks目录，放置一些正
在运行的程序的临时文件和进程号文件。
　　
　　
　　8.其他目录都为空目录，有：
　　
　　/dosa  /dosc  /iomega  /tmp@ -> /dosc/onedisk  /root  
　　
　　9. addswap命令脚本脚本，放置在/sbin下。
　　
　　if [ "$1" = "" ];  then  $mide=10000  if  dd if=/dev/zero
of=/tmp/linux.swp bs=1k count=$mida  mkswap -c /tmp/linux.swp
2>/dev/null  sync 2>/dev/null  swapon /tmp/linux.swp 2>/dev/null
  mida=`cat /proc/meminfo | grep SwapTotal | cut -b16-19 `
echo $mida 'KB aCTiu'arxiu=`ls /dosc/ | grep .swp`  
　　
　　系统的基本文件系统就介绍完了，下面我们介绍OLD(one disk Linux)
系统的具体制作。
　　
　　介绍完了主要目录和文件的结构，我们对ODL的大概也比较了解
了。现在你可以找一个Linux把他裁剪一下，把必要的东西放到一张
软盘上，以后用他来启动了你的系统进入Linux了。然后在放进一些
需要的软件，如Linux Router，或者其他的小的应用软件，那么他就
成了一台小的路由器、代理服务器，你的小玩具，你可以用他上网，
读新闻，看信，和浏览。这是多么不可以想象的事情，全不都可以在
一张1.44M的软盘系统上实现。
　　
　　制作ODL的详细过程十分复杂，其基本思想是在一张软盘上做好
可以启动的Kernel，然后再将定制的文件系统传到磁盘的剩余空间里，
启动时先读前面的让系统boot起来，再读后面的，让系统mount到一
个Ramdisk里，然后将定制好的文件系统解压缩，释放到Ramdisk里。
这样整个磁盘系统既有kernel，又有FileSystem，自然可以使用一张
磁盘启动整个Linux系统。由于篇幅的限制，我们不详细说明全部过
程，只把其中最关键的部分，定制文件系统和让系统在无lilo的引导
下启动这两个部分做说明（其他目录的相关文件，请按照开始将的文
件系统结构建立）。
　　
　　定制文件系统的过程如下：
　　
　　dd if=/dev/zero of=DEVICE bs=1k count=3000（分配一段内存
空间做RamDisk）
　　mke2fs -m 0 -i 2000 DEVICE（格式化Ramdisk）
　　mount -t ext2 DEVICE /mnt（装载到/mnt目录下）
　　cp -dpR /dev /mnt（将/dev/下的硬件设备拷贝到/mnt/dev下）
　　mkdir /mnt/etc（建立ODL系统配置文件目录）
　　写/mnt/etc/rc.d文件，其内容如下：
　　#!/bin/sh  /bin/mount -av  /bin/hostname silver 写/mnt/etc/fstab
文件，其内容如下：
　　/dev/ram0 / ext2 defaults  /dev/fd0 / ext2 defaults  /proc
/proc proc defaults 写入/mnt/etc/inittab文件，其内容如下：
　　id:2:initdefault:  si::sysinit:/etc/rc  1:2345:respawn:/sbin/getty
38400 tty1  2:23:respawn:/sbin/getty 38400 tty2  umount /mnt
（卸载Ramdisk）
　　dd if=DEVICE bs=1k | gzip -v9 > root.gz将Ramdisk上的内容
写入root.gz 让系统在无lilo的引导下启动mke2fs -i 8192 -m 0 /dev/fd0
KERNEL_BLOCKS （KERNEL_BLOCKS为内核部分在磁盘上占的空间大小）
　　mount /dev/fd0 /mnt  rm -rf /mnt/lost+found  mkdir /mnt/boot
  mkdir /mnt/dev（建立一些启动时需要的基本文件目录）
　　cp -R /dev/{null,fd0} /mnt/dev （将启动需要的两个设备NULL
和fd0拷贝到启动盘中）
　　cp /boot/boot.b /mnt/boot（建立boot的映象文件）
　　cp bdlilo.conf KERNEL /mnt（KERNEL为OLD需要的内核文件）
　　lilo -v -C bdlilo.conf -r /mnt（将lilo信息写到OLD中）
　　其dblilo.conf的内容如下（可以根据需要修改）：
　　boot =/dev/fd0  install =/boot/boot.b  map =/boot/map  read-write
  backup =/dev/null  compact  image = KERNEL  label = Bootdisk
  root =/dev/fd0  dd if=KERNEL of=/dev/fd0 bs=1k （将内核KERNEL
写到系统的前1024字节，使OLD软盘可以启动系统）
　　dd if=rootfs.gz of=/dev/fd0 bs=1k seek=KERNEL_BLOCKS
（将原来定制的文件系统传到磁盘剩余空间中）
　　
　　
　　此时，你做好的这张磁盘就可以直接将系统启动了。`如果你配
置好了网络系统，那么网络也可以通过他自动启动。如果你对Linux
还不是很了解，自己定制一个系统还比较困难，那么OLD的全部系统
映象文件可以在http://linux.apostols.org/guru/wen/1.x/stone.img
下载得到。将下载的文件用rawrite.exe程序在dos下写入一张1.44M
的软盘中，此张盘就可以启动系统，并将你带入到神奇的Linux世界
。
　　
　　值得注意的是：此映象文件是一个德国人所做，其终端键盘为类
型不是标准的US键盘，所以我们需要修改他的键盘定义。
　　
　　系统启动后，在/usr/lib/下有一个es.map文件，我们需要修改
它，可以在redhat下拷贝一个default.kmap文件，然后执行/bin/loadkeys
default.kmap，此时键盘就可以正常使用了。
　　
　　

cnhnln

发信人: Socrates (Pluto·朝圣), 信区: Linux
标  题: 自己定制软盘上的Linux系统(zz)
发信站: 一塌糊涂 BBS (Thu Apr  8 23:55:22 2004), 本站(ytht.net)

  一.前言

　　嵌入式Linux是由一个几百KB的Linux内核和一个根据需要制定的文件系统所构成了,

由于Linux是开放源代码的操作系统，所以在嵌入式领域有着非常广阔的前景，并已经广泛
应用在许多手机、PDA、MP3播放器等许多电子产品中。本文将介绍一种两张软盘上的Linu
x系统，它可以当作系统应急修复盘、路由器或防火墙等许多地方，通过对它的研究，也可
以加深对嵌入式系统的理解。

二.Linux启动过程

　　所有的PC机在加电之后，BIOS会寻找到启动盘第一个扇区，并将其复制到RAM中来执行
它，对于两种不同的启动方式，这个扇区通常含有两种不同的代码：引导程序(比如Lilo或
Grub等)的代码，引导程序会帮助定位内核的位置。内核的代码，这通常是从软盘启动时使
用的引导的方式。对于前者，通常需要内核支持initrd。如果是后者，使用的Boot
Loader就是arch/i386/boot/bootsect.S。当内核被编译的时候，这段执行代码就被链接到
内核image的最开始的地方。这样很容易就能只要把内核复制到起始位置为第一个扇区的软
盘上就能得到可自启动的软盘。内核会初始化设备驱动和内部的数据结构，之后它会到一
个特定的位置
――Ramdisk
Word来获得根文件系统的位置。内核必须知道去那里寻找这个根文件系统，否则它将停机
。

　　在使用软盘启动的方式时，内核可以把一个压缩的文件系统释放到RAM中，称之为Ram
disk，这是一个内存区域，但内核会把它当作磁盘一样使用。

　　本文中介绍的例子使用Grub做为引导程序，并使用initrd来辅助Linux的启动。两张软
盘分别命名为bootldr盘和rootfs盘，在
bootldr盘中内容为grub、内核、initrd，rootfs盘中是压缩过的根文件系统。系统启动时
bootldr盘的Grub定位并执行内核，然后内核解开initrd，并执行linuxrc文件，这个文件
负责提示用户更换rootfs盘并将其中内容解压至内存中，然后执行刚刚解压的init继续启
动过程。

为了方便理解这个例子，先介绍目录结构如下：

/home/papaya
├─bootldr/
│  ├─grub/
│  ├─kernel/
│  │  ├─images/
│  │  └─linux-2.4.21/
│  └─initrd/
│      ├─mkinitrd.sh
│      ├─local/
│      └─ramdisk/
├─rootfs/
│  ├─mkrootfs.sh
│  ├─ramdisk/
│  └─local/
└─lib/



三.定制Grub引导程序

插入一张软盘，然后将其格式化，然后加载到/mnt/floppy

#mke2fs /dev/fd0
#mount -t ext2 /dev/fd0 /mnt/floppy -o loop
在其中创建/boot/grub目录
#mkdir -p /mnt/floppy/boot/grub



将系统中/boot/grub下的device.map, stage1, stage2
复制到/mnt/floppy/boot/grub中，然后在/mnt/floppy/boot/grub目录下创建grub.conf文
件：

default=0
timeout=10
title Floppy Linux
kernel (fd0)/bzImage root=/dev/ram0
initrd (fd0)/initrd.gz



然后创建一个链接

#ln -s grub.conf menu.lst



执行

/sbin/grub --batch --device-map=/dev/null <
device (fd0) /dev/fd0
root (fd0)
setup (fd0)
quit
EOF



这样grub就被安装到bootldr盘上了。

四.定制Linux内核

由于软盘大小的限制，内核应尽可能只包含必要的一些支持，对于本文中的例子一定要选
上initrd支持。比如如果做为系统修复盘的话，必要的支持包括：
IDE,PCI,和需要的文件系统类型等等就可以了，而没有必要网络支持，当然，如果做为路
由器或者防火墙的话，网络支持是必要的，而其他的这可相应的删除掉。

#make [xconfig | menuconfig | config]
#make bzImage



如果添加了模块的支持，还需要

#make modules



之后就得到了内核镜像bzImage。如果bzImage的大小超出了软盘的限制，就需要重新再来
配置一下。将编译好的bzImage放到bootldr盘的根目录下，如果把bzImage改了名字，要注
意与grub.conf中的名字一致。

五.制定initrd

　　在initrd/local目录下建立bin, dev, etc, lib, proc, sysroot,
usr目录。其中dev目录下包括必要的设备文件，比如tty, ram, console等等，
bin中必要的可执行文件有bzip2, chroot, cp, cpio, dd, echo, mount, pivot_root,
readkey, sh, test等。Busybox提供了其中大部分。 bzip2, dd,
cpio用来解压缩第二张软盘上的内容，chroot, pivot_root用来转换根目录。

编辑initrd/local/linuxrc文件：

#!/bin/sh



把sysroot目录mount到一块内存上，并建立tmpfs文件系统。

echo "Mounting new root filsystem ..."
mount tmpfs /sysroot -t tmpfs
cd /sysroot



　　下面的readkey是一个很简单的程序，当启动过程执行到这里的时候暂停，等待换入第
二章软盘，然后接受任意键输入继续执行启动过程。这个小程序读者可以自己实现，要注
意的是最好使用静态链接。

echo " "
echo -en "Insert the second disk and press ANY key..."
readkey > /dev/null
echo " "



将第二章软盘上的内容解压到sysroot目录(内存)中。

echo "Loading root-archive from floppy ..."
dd if=/dev/fd0 bs=1k | bzip2 -d | cpio -idv



下面将initrd中的文件copy到sysroot/bin目录下，这样可以把根文件系统中一部分内容放
到initrd(第一张软盘)中，因为软盘容量有限，当第一张软盘空间有剩余，而第二章软盘
空间紧张的时候这会非常有用。

echo "Copying:"
for file in bzip2 chroot cp cpio echo readkey; do
echo -en " "; echo -n $file
cp /bin/$file ./bin/$file
done



下面将/目录设定为当前目录，即sysroot，并执行刚刚从rootfs盘中解压出来的init。

echo " "
echo "Pivoting / ..."
pivot_root . mnt/initrd

echo "Starting init process..."
exec chroot . /sbin/init /dev/console 2>&1

echo -en"Something went wrong ..."
/bin/sh || /mnt/initrd/bin/sh



当initrd所有必须的文件都放到bootldr/initrd/local目录下之后，就可以执行bootldr/
initrd/mkinitrd.sh来创建initrd镜像文件。mkinitrd.sh的内容为：

#!/bin/sh
mount -t ext2 /dev/fd0 /mnt/floppy
rm -f /mnt/floppy/initrd.gz
rm -f initrd.gz



取4M大小的内存块格式化为ext2格式，并将其mount到bootldr/initrd/ramdisk上。

dd if=/dev/zero of=/dev/ram9 bs=1k count=4096
mke2fs /dev/ram9
mount -t ext2 /dev/ram9 ramdisk/



把local中的文件复制到ramdisk目录中，也就是那块内存中。

cp -R local/* ramdisk/
umount ramdisk



将内存中的内容压缩为initrd.gz，并复制到bootldr盘中

dd if=/dev/ram9 bs=1k | gzip -v9 > initrd.gz
cp initrd.gz /mnt/floppy/
umount /mnt/floppy



这样，bootldr盘就完成了。

六.定制根文件系统

　　一个根文件系统需要包含支持Linux系统运行的所有文件。通常包括：

基本的文件系统结构

基本的目录： /dev, /proc, /bin, /sbin, /etc, /usr, /tmp等。

基本的工具： sh, ls, cp, cd, mv等。

基本的配置文件： rc, inittab, fstab等。

设备： /dev/hd*, /dev/tty*, /dev/fd0, /dev/ram*, /dev/console等.

基本的运行库。

　　Busybox和Tinylogin是在嵌入式系统上常用的工具包，它们包含了上面提到的常用的
工具和目录结构等，而且经过重新改写后所生成的代码比普通的Linux系统上的工具要小的
多。

　　编辑Busybox的Config.h文件，选择自己需要的工具。修改Busybox和Tinylogin的Mak
efile文件，制定它们使用静态链接方式(DOSTATIC=true)，这样就不需要在生成的系统中
添加运行库了。将编译好的Busybox和Tinylogin文件放到
rootfs/local中。

　　在rootfs/local中在自己创建下面几个目录：dev/, tmp/, etc/, proc/

　　可以将系统中/dev下的设备复制到这个目录下，只需要复制必要的就可以了，例如：


#cp -dpR /dev/tty[0-9] /mnt/rootfs/dev
#cp -dpR /dev/ram* /mnt/rootfs/dev



但是要注意一定要包含必要的接各设备/dev/console, /dev/kmem, /dev/mem, /dev/tty,

/dev/ram0, /dev/null等。

etc/目录下包含了目标系统运行所必须的配置文件，它包括的内容依赖与目标系统所要运
行的程序。最低限度，它包括下面几个文件：inittab、rc、
fstab、passwd、group、shadow、termcap等。做为init进程的参数，inittab可以非常简
单，仅需要包括下面几行即可：

::sysinit:/etc/rc
::askfirst:/bin/login
tty2::askfirst:/bin/login
tty3::askfirst:/bin/login
tty4::askfirst:/bin/login
::ctrlaltdel:/sbin/reboot
::restart:/sbin/init
::shutdown:/bin/umount -a -r
::shutdown:/sbin/swapoff -a



其中sysinit指明系统初始化脚本rc。rc所包含内容也可以非常少：

#!/bin/sh
/bin/mount -av
/bin/umount /mnt/initrd
/bin/hostname papaya



fstab的内容为：

none /proc proc defaults 0 0
none /tmp tmpfs defaults 0 0



其他的配置文件可以从原来的系统中获得，然后修剪掉不必要的内容即可。

现在在/mnt/rootfs中已经包含了运行一个最低限度Linux系统所必须的所有文件和工具，
下面需要将它们压缩成一个文件系统了。插入rootfs软盘并执行bootldr/rootfs/mkrootf
s.sh

#!/bin/sh
rm -f rootfs.cpio.bz2
dd if=/dev/zero of=/dev/ram0 bs=1k count=4096
mke2fs /dev/ram0
mount -t ext2 /dev/ram0 ramdisk/
cp -R local/* ramdisk/
cd ramdisk/
find . -depth -print | cpio -o > ../rootfs.cpio
cd ..
bzip2 rootfs.cpio
umount ramdisk
dd if=rootfs.cpio.bz2 of=/dev/fd0 bs=1k



OK，rootfs盘也完成了，可以重启机器验证了。

七.其他方法

　　将内核与文件系统进行整合，如果不用Grub引导还有两种选择，不过根文件系统就不
能象上面那样打包再压缩，
也不再使用initrd。把所有根文件系统文件放到一个目录中(比如上面的rootfs/local)，
然后执行

dd if=/dev/zero of=/dev/ram0 bs=1k count=4096
mke2fs /dev/ram0
mount -t ext2 /dev/ram0 ramdisk/
cp -R local/* ramdisk/
umount ramdisk
dd if=/dev/ram0 bs=1k | gzip -v9 > rootfs.gz



1.将内核与文件系统放置在一张软盘上

　　确定内核的大小和的大小之合没有超出软盘的限制。记住内核的大小，然后将内核写
到软盘上：

#dd if=bzImage of=/dev/fd0 bs=1k
353＋1 records in
353＋1 records out



之后，设置根设备为软盘本身，并且设置根以读写方式装载

#rdev /dev/fd0 /dev/fd0
#rdev -R /dev/fd0 0



上面这个例子表示dd写了353个完整记录和一个部分记录到软盘上，因此内核占用了软盘的
前354个记录块。记住这个数字，然后设置内核的Ramdisk
Word。Ramdisk Word可以通过rdev命令设置，它的内容为：







如果15位设置的话，内核在加载文件系统之前会进行提示，这在下面将内核与文件系统盘
分开的情况时是必要的。

对于上面的情况，需要在0-10位指出ramdisk的偏移，并将14位置1，所以得出的ramdisk

word十进制表示为：355 + 2^14 = 355 + 16384 = 16739

#rdev -r /dev/fd0 16739

之后

#dd if=rootfs.gz of=/dev/fd0 bs=1k seek=354

这样一张同时包含内核和文件系统的软盘就成功了。

2.内核与文件系统分别占用一张软盘

与上面一样

#dd if=bzImage of=/dev/fd0 bs=1k
#rdev /dev/fd0 /dev/fd0
#rdev -R /dev/fd0 0
不同的是ramdisk word为 0 + 2^14 + 2^15 = 49152
#rdev -r /dev/fd0 49152
然后换零一张软盘
#dd if=rootfs.gz of=/dev/fd0 bs=1k



内核、根文件系统、引导程序之间的整合方法有很多，他们各有各自的特点，有待读者自
己思考。

八.前景

　　按照本文方法所构造的Linux系统虽然还不完善，但通过逐步的改进，将能做出一个有
价值的系统来。真正的Linux嵌入式系统根据不同的应用方向通常还包括图形用户界面或者
是网络浏览器等应用程序。值得庆幸的是很多OpenSource的项目提供了所需要的组件，结
合这些优秀的开源项目，就可以形成一套真正的嵌入式Linux操作系统。



--
        Linux kernel 2.6.5, Gentoo distribution

※ 来源:．一塌糊涂 BBS ytht.net．[FROM: 162.105.76.250]
--
※ 转寄:．一塌糊涂 BBS ytht.net．[FROM: 202.38.126.246]


--
Oops: 0000 CPU:    1
EIP:    0010:[<7262206b>]    Tainted: PF        EFLAGS: 00010286
eax: c88d9060   ebx: c88d9000   ecx: c6c69e0a   edx: c88d918d
esi: c88d9060   edi: 00000001   ebp: 63697571   esp: c6c69f08
ds: 0018   es: 0018   ss: 0018  
Process insmod (pid: 3173, stackpage=c6c69000)


※ 来源:·BBS 兰大思雨站 http://lzusiyu.org·[FROM: 202.38.126.*]

cnhnln

版权信息:该文章版权由岳光所有.可在非商业目的下任意传播和复制.对于商业目的下对本文的任何行为需经作者同意.联系方式:[email protected]

制作软盘Linux(即在软盘上放一个Linux系统)的目的在于可以深入了解Linux的结构,可利用软盘起动机器修复系统,抢救数据.注意!!:软盘Linux和Linux启动盘不同,后者只是将核心放于软盘,引导硬盘上的Linux系统,而前者是存在于软盘上的Linux系统.

成功的制作有用的软盘Linux在于:
1)编译一个足够小而且有一定功能的内核.
2)采用busybox并适当的编译它.(busybox是一个微小的程序可以让系统提供ls,ash,rm,cp,init等多种服务,它只有一个很小的busybox文件,用ls,rm,init联接他,执行这些联接就可运行相应的服务)
3)创建系统必需的目录和文件(如/dev,hda,inittab等)
4)配置引导程序GRUB
5)将以上三点恰当的组织在软盘上.
本文将按照以上顺序介绍制作软盘Linux的方法.

准备:创建/tmp/floppy目录存放临时文件.

I.)编译内核
make mrproper
拷贝../SRC/configs/i386-BOOT(类似文件)到.../SRC/.config
make menuconfig(最好去掉第二项中所有的*以去掉对模块的支持.必需使核心支持RamDisk其余选项自定)注意:!!完全去掉网络功能可能造成编译失败(2.4.20-8内核即如此),但可部分去掉.)
make dep
make clean
make bzImage
../SRC/arch/i386/boot/bzImage即为内核
编译成功的内核应不超过1M
II.)编译busybox
busybox源程序可在RedHat的网站上(ftp://ftp.redhat.com/pub/redhat/linux/9/en/os/i386/SRPMS)找到相应的软件包.假设安装后源码目录为/../src/busybox
修改/../src/busybox/Config.h文件,在不用的功能前加//
修改/../src/busybox/Makefile文件,将DOSTATIC=true
执行 make (生成的名为busybox的文件大小应在650K左右)
make PREFIX=/tmp/floppy install(此时在/tmp/floppy目录下即有Linux启动运行所必须的目录和文件了)
III.)创建系统必需的目录和文件
1.在/tmp/floppy目录下
mkdir proc mnt etc dev
在etc目录下创建inittab文件和rc.S文件(用vi)
执行chmod 777 inittab
chmod 777 rc.S
inittab内容为:
::sysinit:/etc/rc.S
::askfirst:/bin/sh
rc.S文件内容为:
#!/bin/sh
mount -t proc /proc /proc
2.在dev目录下创建设备文件
应创建的设备文件有:console,hda,hda1,hda2,hda3...(根据硬盘分区数而定),hdb,hdc,hdd,tty,tty0,tty1,fd0,null,loop0,ram0,tty5
相应的文件在/dev下都可找到但不能复制,须自己创建:
这里采用mknod命令语法如下:
mknod 文件名 类型 MAJOR MINOR
类型 MAJOR MINOR可用ls -l在/dev下查找.(权限串的前一位即为"类型")
如创建console文件须在/tmp/floppy/dev下执行:mknod console c 5 1
IV.)配置grub并组织软盘.
1.取一张格式化为ext2的空盘.在其上创建boot boot/grub目录
拷贝/boot/grub/stage1和stage2到软盘的boot/grub下
执行:grub
root (fd0)
setup (fd0)
quit
至此grub安装成功!
在软盘的boot/grub目录下创建grub.conf文件
内容为:
default=0
timeout=10
title Linux
root (fd0)
kernel /bzImage
initrd /image.gz
grub配置成功!
拷贝bzImage到软盘根目录下.
2.cd /tmp
dd if=/dev/zero of=image bs=1k count=2048
losetup /dev/loop0 image
mke2fs -m 0 /dev/loop0
mount -t ext2 /dev/loop0 /mnt
cp -R floppy/* /mnt
umount /mnt
losetup -d /dev/loop0
sync
dd if=image|gzip -9>image.gz
拷贝image.gz到软盘根目录下.

至此,软盘Linux制作成功!重新启动用软盘引导看看自己制作的Linux吧!

cnhnln

Linux发行版制作指南

摘要
　　此文档着重介绍了Linux发行版制作过程中的各个步骤。(2002-10-08 13:20:09)

1 2 3 下一页
By Coolee

1.项目整体分析

　　制作Linux发布的目的是为了在系统中能够快速，正确地建立Linux系统环境。制作Linux发布的主要工作是决定各种软件的去留，因为有了RPM(RedHat Package Manager)包对其提供优良的管理能力，所以以目前比较成熟的RedHat 7.1（Linux Kernel Version 2.4.2-12）Linux发布程序作为蓝本，以RPM包作为基本的制定单元，以需求为原则对其进行取舍，得到适合实际需要的Linux系统。

　　由此，项目自然而然的以分析RedHat Linux的光盘安装系统为起点，在掌握了其结构和行为的基础上，在包一级（结构部分）和代码一级（行为部分）进行修改，同时建立相应的测试环境，以便对修改进行及时的规范。

2.项目分步骤实施细节

　　2.1对Linux光盘安装系统的分析

　　●结构部分

　　在安装光盘中，主要的目录结构和文件大致如下：

　　images/ 此目录下包含了制作启动盘的映像文件（文件后缀img），

　　其中boot.img是当安装介质为CD-ROM时负责引导系统的映像文件

　　bootnet.img是当安装介质为FTP,NFS等时负责引导系统的映像文件

　　driver.img是由一些特殊设备驱动程序模块组成的映像文件，在当前内核不支持这些设备的情况下，提供了对它们进行访问的一种方法

　　其中，boot.img映像文件中主要包含以下文件：


　　boot.img
　　|----vmlinuz Linux内核
　　|----ldlinux.sys 引导Linux的系统文件
　　|----syslinux.cfg Linux内核引导参数配置文件
　　|----initrd.img 内存虚拟文件系统映像文件
　　|----*.msg文件 引导时的各种提示信息文件

　　其中，initrd.img为Linux ext2文件系统，构成如下：


　　initrd.img
　　|----/bin
　　|----/dev
　　|----/etc
　　|----/module
　　|----/sbin ------ loader
安装程序装载器
　　|----/tmp
　　|----/var

　　可执行文件/sbin/loader的任务是判断安装介质的有效性，并从中执行安装程序。

　　其实正是boot.img，在系统启动时被执行，经解析之后在内存建立起了Linux内核,并根据配置文件syslinux.cfg装载虚拟文件系统，形成了完整的Linux System，为后续的工作提供了必要的操作系统环境。Boot.img映像的文件系统类型为msdos，而其中的initrd.img映像的文件系统类型必为Linux系统自己的ext2，所以对于它们的解析操作是不同的，具体请参考附录A 。

　　RedHat/ 此目录是RedHat Linux发布的核心目录，主要的目录结构都在这里，其中

　　RPMS/ 包含了RedHat Linux发布的主要部分，即以RPM包的形式将Linux系统中的二进制可执行文件，配置文件，文档等等组织在一起，形成能完成一定功能的比较独立的软件包（文件后缀rpm）。这个目录就是把这些软件包都集合在一起，形成了RedHat Linux发布。

　　base/ 包含了在安装过程中要用到的描述组织结构和安装行为的所有文件，其中comps，hdlist和hdlist2是描述RPM包组织结构的文件。

　　comps 此文件把各个RPM包按一定的原则组织成若干组，即components,这样在安装过程中就不必对每一个包做出取舍，而以组为单位。comps文件为简单文本格式，它的结构如下所示：


　　4 表示RPM包的版本号，当前为4

　　1 base { }
　　 base是此component名，{…}中是此component中所包含的RPM包
　　　 的名称列表，1表示在安装中默认为选中，即默认安装。

0 –hide IDS sensor{
　　　　　　　　snort
　　　libpcap
}
　　　　表示IDS sensor组中包含有snort和lipcap这两个RPM包。0表示
　　　　这个组在安装中默认为不选中即默认不安装，并且由—hide指出
　　　　不在用户界面上显示此组。

　　hdlist和hdlist2 这两个文件维护从RPM包名到真实包文件名的映射过程，例如从snort这个RPM包名到真实包文件名snort-1.8.1-1.1.2.i386.rpm的映射。这两个文件是用特殊的程序生成的，无法用简单的方法察看其中的内容和结构。具体的生成方法请参考附录D。

　　stage2.img , hdstg1.img , hdstg2.img , netstg1.img 和netstg2.img 是描述安装行为的映像文件，其中

　　stage2.img 是当安装介质为CD-ROM时的安装程序映像文件

　　hdstg1.img 是当安装介质为HardDisk时的安装程序映像文件

　　hdstg2.img 是当安装介质为HardDisk时的安装程序映像文件

　　netstg1.img 是当安装介质为FTP,NFS时的安装程序映像文件

　　netstg2.img 是当安装介质为FTP,NFS时的安装程序映像文件

这里主要讨论stage2.img的内容


　　stage2.img
　　|----/etc
|----/modules
|----/proc
|----/usr----/bin----anaconda
安装程序主执行文件
|
|------/lib-----/anaconda
安装程序脚本文件目录
　　　　 | |----/installclasses
| |----/iw
| |----/texttw
| |----*.py
|
|------/share---/anaconda
安装程序资源文件目录
| |----/help
| |----/pixmaps

　　如上所示，stage2.img映像文件中的主要部分是安装程序anaconda，它的主执行体是/usr/bin下的anaconda，由其调用的大量例程分布在/usr/lib/anaconda下，而安装过程中要用到的资源文件分布在/usr/share/anaconda下。stage2.img 的解析方法请参考附录B。

　　●行为部分

　　RedHat 7.1的安装程序被命名为anaconda。如前所述，当boot.img所代表的启动介质被系统引导之后，在内存中就建立了一个完整的Linux系统（包括Linux内核和一个内存虚拟文件系统），之后便执行文件系统中存在的loader命令，从适当的介质中执行安装程序(例：安装介质是CD-ROM,就解析CD-ROM上的stage2.img，并从中执行安装程序)，即执行anaconda，完成Linux系统的安装任务。

　　此次利用RedHat 7.1的安装程序源代码的SRPM包形式：anaconda-7.1-5.src.rpm来获得anaconda的源程序，经解包后在/usr/src/redhat/SOURCES/anaconda-7.1形成了源代码树。


　　anaconda-7.1
　　|-------------------/bootdisk
启动盘目录
　　|-------------------/docs
文档目录
　　|-------------------/help
安装过程帮助系统目录
　　|-------------------/installclasses
安装类型分类目录
　　|-------------------/iw
安装各步骤响应目录
　　|-------------------/loader
安装程序装载器目录
　　|-------------------/pixmap
图形资源目录
　　|-------------------/utils
工具目录
　　|-------------------*.py
各Python脚本文件

　　分析如下：

　　anaconda安装程序主要用Python语言写成，它是一种解释性的，面向对象的脚本语言。源文件后缀为.py，也可生成可执行的字节码，后缀为.pyc或.pyo。其中：

　　installclasses/ 子目录中各文件定义了在安装过程中用户可选择的安装类型，通常由四个文件workstation.py , server.py , laptop.py和custom.py来描述workstation(工作站)安装类型,server(服务器)安装类型,laptop(膝上型电脑)安装类型和custom(自定义)安装类型。每个脚本文件的内部，则是根据自己安装类型的特点对安装步骤，分区策略以及包的取舍做出了不同的方案。

　　iw/ 子目录中各文件定义了在图形界面安装状态时各步骤对Next(下一步)和Prev(上一步)的响应函数。

　　loader/ 安装程序装载器的源代码目录，用C语言写成。

　　pixmap/ 图形资源目录，包括安装过程中使用到的所有位图，图标。

　　utils/ 安装程序实用工具目录。

　　anaconda 是安装程序的主执行文件，它建立了Python语言的运行环境，提供了程序的入口点并以模块的方式将各个子系统结合在一起。

　　gui.py 定义了安装程序图形界面使用的各种窗口类，包括MessageWindow,ProgressWindow,WaitWindow,ExeceptWindow等，和控制这些窗口及图形界面行为的InstallInterface, InstallControlWindow, InstallControlState类。总之，控制gui。

　　todo.py 定义了安装程序的各种行为函数，它是图形界面背后真正进行各项操作的函数集合。

　　harddrive.py 定义了当安装介质为硬盘时，系统该如何找到安装程序的光盘映像，并从中执行程序。

　　安装程序源代码的编译由make和make install组成，完成后在/usr/src/RedHat目录下形成了如下目录结构：


　　instimage
|------/etc
|------/usr
|------/bin
|------/sbin
|------/lib
| |------/anaconda
| | |------installclasses
| | |------iw
| | |------texttw
| | |------*.py
| |
| |------/anaconda-runtime
| |------/boot/loader
|
|------/share------/anaconda
|------/help
|------/pixmaps

　　此目录结构基本与stage2.img的文件结构相同。

　　2.2调试环境的建立：

　　●对源程序的修改

　　在分析完安装程序的基本构成之后，就要建立相应的调试环境。建立此环境的目的是为了可以方便地对修改过的安装程序及裁减后的RPM包进行随时的确认。显然，可以选用CD-ROM或本地硬盘作为调试介质，下表比较了两者的差别：
CDROM 硬盘
对应的安装界面 图形界面 菜单界面
对应的映像文件 stage2.img *.iso中的hdstg1.img , hdstg2.img
优点 图形界面，直接使用映像文件stage2.img 随改随调，调试周期短，效率高
缺点 每次改动都要求刻盘，调试效率低 菜单界面，每次调试都要求提供光盘映像文件*.iso,效率上打折扣

　　在两者各有优缺点的情况下，考虑折衷的方案，即为了首先保证调试的效率，采用硬盘作为调试介质，但对应的映像文件选取stage2.img，这样能达到效率最大化，同时调试界面采取图形方式。采用此方案时，须修改源代码，以达到预期的效果。

　　从前面对安装系统的分析，可以看出在initrd.img中的/sbin/loader程序负责判断安装介质的有效性，并从中执行安装程序。所以要首先修改它的源代码文件loader.c，从中找出硬盘安装时默认读出光盘映像文件*.iso的函数setupIsoImages,并注释掉其中在硬盘目录中寻找映像文件*.iso的相关操作，具体对应Line 582 至 Line590行中包含sprintf和if(){}循环的语句，以避免打开子目录，并在其后加入mountLoopback("/tmp/hdimage/RedHat/base/stage2.img","/mnt/runtime", "loop0");一句以便实现直接使用stage2.img的目的，并注释掉其后从errno=0开始的代码，经过整个while循环到closedir(dir)，但保留umount(“/tmp/hdimage”)；注释掉if(!net) return NULL;一句。以上操作目的是防止程序读出光盘映像文件*.iso。在loader.c的主函数main()中的结尾部分，注释掉if (!FL_TESTING(flags)) { 和 }的条件判断的两条语句，让程序毫无疑问地执行硬盘上的安装程序。至此，对loader.c修改完毕。

　　同时还要对Python脚本的一些相关文件进行修改以保证对stage2.img文件的支持。具体的，在harddrive.py的类class HardDriveInstallMethod中，注释掉函数 mountMedia(self, cdNum)中的所有内容并加Pass语句的方法使此函数失效，同样方法处理umountMedia函数，mountDirectory函数和umountDirectory函数，为了保险起见，在其他函数中注释掉有关上面函数的调用。并在类的构造函数（初始化）中的# Go ahead…语句之前加self.tree=”/tmp/hdimage/”语句，并注释掉后面的所有语句。这样做仍然是要保证废弃iso映像转而对stage2.img实现控制。不仅如此，最好还注释掉todo.py中的Line1781至Line1783调用self.method.systemMounted一段，以确保不出差错。接着进行make和make install,重新编译程序，使修改生效，并把新的loader程序从编译的目标目录中copy到boot.img中initrd.img中的相应目录并覆盖旧的loader文件。为了启动时的快速，修改boot.img中的syslinux.cfg文件，去掉启动提示，延时和其他Linux启动选项，修改后的syslinux.cfg文件，请参考附录F

　　最后，把boot.img做成启动盘，方法请参考附录G。

　　●建立硬盘介质中的调试目录

　　在硬盘的Linux分区中建立形如RedHat安装光盘目录结构的调试目录及相关文件，如下所示：


　　|----/images
　　| |------boot.img
　　|
　　|----/RedHat
|----/base
　　|　　 　　|------comps , hdlist , hdlist2,stage2.img
　　|
|----/RPMS
　　| 　　|----*.rpm

　　建立这种目录结构和相关文件的原因是在安装程序中已经以代码的形式确定了它们的命名及结构。其中，对boot.img和stage2.img的相关修改如前所述，而涉及到对comps,hdlist,hdlist2的修改，则需在后续的裁剪过程中确定。

　　至此，调试环境建立完毕。现在可以用做好的启动盘来引导系统，并且可以从指定的硬盘上测试安装程序和RPM包的正确性。


Linux发行版制作指南

摘要
　　此文档着重介绍了Linux发行版制作过程中的各个步骤。(2002-10-08 13:20:09)

上一页 1 2 3 下一页

　　2.3对安装步骤的简化

　　在对RPM 包的剪裁进行之前，还要对原有的安装步骤做出简化，去掉一些与系统需求大致无关的项目，使安装者可以集中精力地配置Sensor的主要参数，忽略诸如对键盘，鼠标，和多国语言的配置。具体的如下所示：

　　原有的安装步骤有：

　　1．安装语言选择

　　2．键盘配置

　　3．鼠标配置

　　4．欢迎信息

　　5．安装类型选择（包括安装或升级，安装部分又包括workstation，server，laptop,custom四种类型）

　　6．选择分区方式（自动分区，手动分区，专业分区）

　　7．选择以上部分或全部分区格式化

　　8．Lilo操作系统引导器配置

　　9．网卡及网络配置

　　10．防火墙配置

　　11．语言配置

　　12．时区配置

　　13．账户配置

　　14．认证配置

　　15．包组及单RPM包选择

　　16．包独立性检查

　　17．X-Window配置

　　18．安装前确认

　　19．安装过程

　　20．制作启动盘

　　21．安装完毕确认

　　在这些安装步骤中很多都是在确定了RPM包组及调试完成后不必要存在的，所以去掉第1，2，3，4，7，8，10，11，14，16，17和第20项安装步骤，所有去掉步骤的相关设置都采取默认的设置值，如第7步采取分区全部格式化的方案，第8步，采取Lilo放置在MBR上，default boot 为Linux的设置等等，并修改第5步，去掉升级类型和安装类型中的所有4种既定类型，添加IDS sensor类型。修改完成以后的安装步骤如下所示：

　　1．安装类型选择（现有的为IDS sensor一种）

　　2．选择分区方式（自动分区，手动分区，专业分区）

　　3．网卡及网络配置

　　4．时区配置

　　5．账户配置

　　6．包组及单RPM包选择

　　7．安装过程

　　8．安装完毕确认

　　为此，需要修改Python脚本语言

　　● 在安装程序运行之初，需要先禁止掉安装语言选择，键盘配置，鼠标配置和欢迎信息，在anaconda中在判断语言是否有效之前即Line491 if lang:之前加上以下四句:


　　instClass.addToSkipList("language");
　　instClass.addToSkipList("keyboard");
　　instClass.addToSkipList("mouse");
　　instClass.addToSkipList("welcome");

　　并在gui.py中的类class InstallInterface的run函数中注释掉Line371至Line371，即在commonSteps结构中除保留( InstallPathWindow, "installtype" )外，注释掉( LanguageWindow, "language" )，( KeyboardWindow, "keyboard" )，( MouseWindow, "mouse" )和( WelcomeWindow, "welcome" )

　　●对安装类型进行精简。在installclasses目录下去掉upgrateonly.py , workstation.py , server.py , laptop.py和custom.py即去掉升级类型和安装类型中的所有4种既定类型, 添加IDS sensor类型，即在目录中添加sensor.py文件，文件的具体内容请参考附录E。

　　除此之外，还要修改iw/installpath_gui.py脚本文件，以便在图形界面上不显示Install和Upgrate图标和选项，只显示IDS Sensor项目。具体的，注释掉Line223,Line 227,Line 233和Line 234代码，即在类class InstallPathWindow中的getScreen函数的最后部分不执行显示。

　　● 去掉其他多余步骤，主要修改iw/installpath_gui.py脚本文件。注释掉类class InstallPathWindow初始化函数__init__里结构self.installSteps中的( FormatWindow, "format" ) , ( FirewallWindow, "firewall" ) , ( LanguageSupportWindow, "languagesupport" ) , ( AuthWindow, "authentication" ) , ( UnresolvedDependenciesWindow, "dependencies" ) , ( XConfigWindow, "xconfig" ) , ( BootdiskWindow, "bootdisk" )，即对应着去掉的第7，10，11，14，16，17和第20步骤。

　　当这三步完成后，进行make和make install,重新编译程序，使修改生效，并把这些文件Copy至stage2.img中的相关位置，替换掉旧文件。这样就完成了对安装步骤的简化。

　　2.4对RPM 包的剪裁

　　对RPM包的裁剪依这次的需求进行。项目整体分析时已做出说明，制作目的是为了在系统前端Sensor 中能够快速，正确地建立运行Snort的Linux系统环境。所以只需保留Linux基本系统和运行snort所需的环境即可。

　　Linux基本系统的RPM包组成在comps文件中的base部分中有详细的描述，所以就以它为蓝本，去掉除base以外的所有component,并去掉base中以下不必要的RPM包：


　　apmd 　 　 ash 　　autoconfig　 　dhcpcd　
dosfstools 　ed　 　eject　 　gdm　　
gettext 　　gpm gruff ksymoops
lokkit mailcap mailx man
mktemp mouseconfig ncurses
openldap popt procmail pump
raidtool readline redhat-logos
redhat-release rootfiles sendmail
syslinux utemper words

　　在comps文件中增加IDS Sensor component并在此组中添加必要的RPM包，如snort-1.8.1就需要snort , libpcap , mysql , openssl , openssl-clients , perl等RPM包，除此之外，为了方便调试，也保留了一些用于操作和诊断的RPM包，如tcpdump , iputils , zip等，完成的comps请参考附录C。

　　同时，在/RPM目录中依照上面所有确认保留的RPM包名称，删除不予保留的各RPM文件（文件后缀.rpm）。此时在/base中的comps文件和在/RPM中的各rpm文件都已剪裁完成，可以利用genhdlist生成hdlist和hdlist2文件了，genhdlist 在anaconda-7.1的源代码中的utils目录里。具体生成方法见附录D。

3. 存在的问题及今后目标

　　此次对NetCop Linux发布的制作是以RPM包作为裁剪单元进行的，所以必然存在很大缺陷，即对RPM包的内部毫无办法，无法去掉RPM包内部对需求无用的大量文件并且无法对内核，脚本文件等做出制定修改。所以，下一步所要做的工作，是逐一打开每一个候选的RPM包，依需求对包内的每一个文件做出修改或丢弃，这样才能做出真正适合sensor的Linux发布，无疑，工作量是巨大的。

4. 原始资料及参考文献


　　Bootdisk-HOWTO
　　CDROM-HOWTO
　　CD-Writing-HOWTO
　　Distribution-HOWTO
　　HP-HOWTO
　　KickStart-HOWTO
　　Linux-From-Scratch-HOWTO
　　RedHat-CD-HOWTO
　　RPM-HOWTO

　　http://mail.y-min.or.jp/~nob/ml/ ... 99902/msg00150.html


Linux发行版制作指南

摘要
　　此文档着重介绍了Linux发行版制作过程中的各个步骤。(2002-10-08 13:20:09)

上一页 1 2 3

附录

　　附录A boot.img和initrd.img的解析过程

　　1．首先建立两个映像文件解析后的装载点（mount point）：


　　mkdir /mnt/boot /mnt/initrd

2．写shell脚本进行解析和还原：

　　解析脚本命名为up


　　#！/bin/sh
　　mount -o loop -t msdos boot.img /mnt/boot
　　gzip -cd /mnt/boot/initrd.img > /tmp/initrd.ext2
　　mount -o loop –t ext2 /tmp/initrd.ext2 /mnt/initrd

　　还原脚本命名为down


　　#!/bin/sh
　　umount /mnt/initrd
　　gzip -c9 /tmp/initrd.ext2 > /mnt/boot/initrd.img
　　umount /mnt/boot

　　附录B stage2.img解析过程

　　1．首先建立映像文件解析后的装载点（mount point）：


　　mkdir /mnt/stage2

　　2．写shell脚本进行解析和还原：

　　解析脚本命名为up2


　　#!/bin/sh
　　mount -o loop stage2.img /mnt/stage2

　　还原脚本命名为down2


　　#!/bin/sh
　　umount /mnt/stage2

　　附录C comps文件清单


4

1 Base {
MAKEDEV
SysVinit
anacron
at
basesystem
bash
bdflush
bzip2
chkconfig
console-tools
cpio
cracklib
cracklib-dicts
crontabs
cyrus-sasl
openssl
db1
db2
db3
dev
devfsd
diffutils
e2fsprogs
file
filesystem
fileutils
findutils
gawk
glib
glibc
glibc-common
grep
gzip
hdparm
hotplug
lilo
info
initscripts
kbdconfig
kernel
krb5-libs
kudzu
less
libstdc++
libtermcap
logrotate
losetup
mingetty
mkbootdisk
mkinitrd
modutils
mount
net-tools
newt
ntsysv
pam
passwd
pciutils
popt
procps
psmisc
pwdb
quota
rpm
sed
setserial
setup
setuptool
sh-utils
shadow-utils
slang
slocate
sysklogd
tar
termcap
textutils
time
timeconfig
tmpwatch
util-linux
vim-common
vim-minimal
vixie-cron
which
zlib
}

1 --hide IDS Sensor {
iptables
iputils
libpcap
mysql
openssh
openssh-clients
openssl
perl
rdate
snort
tcpdump
traceroute
unzip
zip
}

　　附录D hdlist和hdlist2生成方

　　假设在/tmp/cdimage/RedHat/RPMS目录下收录着RPM包的话，则通过使用


　　genhdlist /tmp/cdimage/

　　生成hdlist和hdlist2文件，文件的生成位置在目录/tmp/cdimage/RedHat/base/下

　　附录E sensor.py文件清单


　　from installclass import BaseInstallClass
　　from translate import *
　　from installclass import FSEDIT_CLEAR_ALL
　　import os
　　import iutil

　　class InstallClass(BaseInstallClass):

　　name = N_("IDS Sensor")
　　pixmap = "sensor.png"
　　sortPriority = 10

　　def __init__(self, expert):
BaseInstallClass.__init__(self)
self.setGroups(["IDS Sensor"])

self.addToSkipList("lilo")

self.addNewPartition('/boot', (48, -1, 0), (None, -1, 0), (0,0))
self.addNewPartition('/', (256, -1, 0), (None, -1, 0), (0,0))
self.addNewPartition('/usr', (512, -1, 1), (None, -1, 0), (0,0))
self.addNewPartition('/var', (256, -1, 0), (None, -1, 0), (0,0))
self.addNewPartition('/home',(512, -1, 1), (None, -1, 0), (0,0))
self.setClearParts(FSEDIT_CLEAR_ALL,
warningText = N_("Automatic partitioning will erase ALL DATA
on your hard "
"drive to make room for your Linux installation."))

# self.addNewPartition('swap', (64, 256, 1), (None, -1, 0), (0,0))

# 2.4 kernel requires more swap, so base amount we try to get
# on amount of memory
(minswap, maxswap) = iutil.swapSuggestion()
self.addNewPartition('swap', (minswap, maxswap, 1),
(None, -1, 0), (0,0))

　　附录F syslinux.cfg文件清单


　　label linux
　　kernel vmlinuz
　　append initrd=initrd.img lang=us devfs=nomount vga=788

　　附录G boot.img制作启动盘方法


　　cat boot.img > /dev/fd0

　　或


　　dd if=boot.img of=/dev/fd0 bs=1440

　　附录H Linux光盘映像制作方法

　　在Linux下光盘映像的制作用mkisofs命令，具体的，假设在/tmp/cdimage/目录下收录着将要被制作的光盘内容，则执行


　　mkisofs –v –r –T –J –V “NetCop Linux” –b images/boot.img
　　 -o /tmp/NetCopLinux.iso

　　即可在/tmp目录下做出一命名为NetCopLinux.iso的光盘映像文件，它以/tmp/cdimage/images/boot.img 作为光盘启动文件。"

cnhnln

制作自己的Floppy-Linux Step By Step




1. 软盘上安装引导器（grub）

一般制作软盘上跑的linux引导器都使用syslinux这个工具（这个工具不支持ext2分区格式，只能支持fat分区格式），因为我对grub比较熟悉，并且我在软盘上安装grub只用了132KB空间，不是很耗磁盘空间。
具体操作如下：

# mke2fs /dev/fd0

创建了 ext2 文件系统后，需要安装该文件系统：

# mount /dev/fd0 /mnt/floppy

现在，需要创建一些目录，并将一些关键文件（原先安装 GRUB 时已安装了这些文件）复制到软盘：

# mkdir /mnt/floppy/boot
# mkdir /mnt/floppy/boot/grub
# cp /boot/grub/stage1 /mnt/floppy/boot/grub
# cp /boot/grub/stage2 /mnt/floppy/boot/grub

再有一个步骤，就能得到可用的引导盘。

在linux bash中，从 root 用户运行“grub”，该程序非常有趣并值得注意，因为它实际上是 GRUB 引导装入器的半功能性版本。尽管 Linux 已经启动并正在运行，您仍可以运行 GRUB 并执行某些任务，而且其界面与使用 GRUB 引导盘或将 GRUB 安装到硬盘 MBR 时看到的界面(即GRUB控制台)完全相同。

在 grub> 提示符处，输入：

grub> root (fd0)
grub> setup (fd0)
grub> quit

现在，引导盘完成了。

2. 安装根文件系统：

一套linux系统要正常启动，根文件系统要包括下列文件夹：

/bin /etc /proc /tmp /var /dev /mnt

要包括下列基本的设备文件：

/dev/console /dev/fd0 /dev/null /dev/ram0 /dev/tty /dev/tty0

要包括下列配置文件：

/etc/rc.d/inittab /etc/rc.d/rc.sysinit /etc/fstab

要实现基本的功能，还要包括一些常用工具：

如：sh，ls，cd，cat……

其中，前面三个部分不要多少空间的，但是常用工具会占用很多空间，要是用原来系统中的这些命令，就是全部用静态编译，不是用动态连接库，大概有2MB~3MB，放不进软盘。网络上解决的方案是使用BusyBox工具。具体可以到官方网站：www.busybox.net看看。

下载BusyBox工具的源代码，编译：

注意：

（1） 译的时候要静态编译，修改 Makefile 中的 DOSTATIC 参数，从false 改为 true，这样，编译出来的代码就不要依赖glibc了。

（2） 因为我们用的是 BusyBox 上的 init，与一般所使用的 init 不太一样，会先执行 /etc/init.d/rcS 而非 /etc/rc.d/rc.sysinit，为了做出来的 FloppyLinux 架构与 Redhat 的架构一样，所以修改了 BusyBox 中的 init.c底下是修到的部分内容∶

#ifndef INIT_SCRIPT
#define INIT_SRCIPT "/etc/rc.d/rc.sysinit"
#endif

具体操作如下：

（1） 官方网站上下载BusyBox的最新版本：busybox-0.60.5.tar.gz解开，按照上面的注意点修改源代码

（2） 运行下列命令：

#make
#make install

（3） 译好的可势行文件放在 ./_install 文件夹里的。

#cp ./_install /tmp/floppy-linux -r

（4） 动建立其它的文件或文件夹：


#cd /tmp/floppy-linux
# mkdir dev etc etc/rc.d proc mnt tmp var
# chmod 755 dev etc etc/rc.d bin mnt tmp var
# chmod 555 proc
# cd dev
# mknod tty c 5 0
# mknod console c 5 1
# chmod 666 tty console
# mknod tty0 c 4 0
# chmod 666 tty0
# mknod ram0 b 1 0
# chmod 600 ram0
# mknod fd0 b 2 0
# chmod 600 fd0
# mknod null c 1 3
# chmod 666 null

（5） 建启动配置文件：（inittab,rc.sysinit,fstab）

initab:
::sysinit:/etc/rc.d/rc.sysinit
::askfirst:/bin/sh
rc.sysinit:
#!/bin/sh
mount -a
# chmod 755 rc.sysinit
fstab:
proc /proc proc defaults 0 0

（6） 作Ramdisk的镜像文件：


# dd if=/dev/zero of=/tmp/initrd bs=1k count=4096
# losetup /dev/loop0 /tmp/initrd
# mke2fs -m 0 /dev/loop0>
# mount -t ext2 /dev/loop0 /mnt
# cp -r /tmp/floppy-linux/* /mnt
# umount /mnt
# losetup -d /dev/loop0
# dd if=/tmp/initrd | gzip -9 > /tmp/initrd.gz
# rm -f /tmp/initrd
# sync

3．编译内核：

这部分内容不详细讲述，主要是去掉了一些不需要的选项，减小内核，编译出来的内核是725920Byte。里面包含了必要的网卡驱动和网络协议栈。

4．整合启动盘

现在所用到了的东西全部搞好了，下面就是整合一下：

全部文件（文件夹）如下：

/lost+found/
/boot/
/boot/grub/
/boot/grub/stage1 =========èGrub启动时用到的两个文件
/boot/grub/stage2
/boot/grub/menu.lst =========èGrub的配置文件指向grub.conf
/boot/grub/grub.conf
/boot/kernel =============è内核
/initrd.gz ===============è内存镜像文件

这样这张软盘就能启动一套Linux系统了，占用1.213MB。


阅读：1924次

责任编辑:Exir

来源：LinuxAid

虚缘

多谢，慢慢研究一下看看