Redhat9内核升级(网上最完美版本转自CSDN)

kubobo

               
作者：保云
你可以转载或修改除附录之外的任意部分
1.前言
在我写这篇文章的时候，还是一个linux的初学者，经历了n次失败后的成功当然是兴奋的，于是很想把她写下来。
我的操作系统是Redhat9，其内核版本为2.4.20-8 ，需要升级到2.4.26，采用全新的2.4.26内核源码进行升级，主要的参考资料是《The Linux Kernel
HOWTO》，另外还有一些参考资料我想就不提了，免得误导象我一样的初学者。
接下来有三个部分，“步骤索引”、“步骤说明”和“附录”，“步骤索引”真实的记录了我成功升级内核的步骤，“步骤说明”将对“步骤索引”一些注意事项进行说明，“附录”摘录自《The Linux Kernel HOWTO》的相关部分。
2.步骤索引
[root@localhost src]# tar vxfj linux-2.4.26.tar.bz2
[root@localhost src]# ln –s linux2.4.26 linux
[root@localhost src]# cd /usr/src/linux
[root@localhost linux]# cp /boot/config-2.4.20-8 .config
[root@localhost linux]# make menuconfig
[root@localhost linux]# make dep
[root@localhost linux]# make clean
[root@localhost linux]# make bzImage
[root@localhost linux]# make modules
[root@localhost linux]# make modules_install
[root@localhost linux]# cp arch/i386/boot/bzImage /boot/vmlinuz-2.4.26
[root@localhost linux]# cp .config /boot/config-2.4.26
[root@localhost linux]# cp System.map /boot/System.map-2.4.26
[root@localhost linux]# mkinitrd /boot/initrd-2.4.26.img 2.4.26
[root@localhost linux]# cd /boot
[root@localhost boot]# rm -f System.map vmlinuz
[root@localhost boot]# ln -s System.map-2.4.26 System.map
[root@localhost boot]# ln -s vmlinuz-2.4.26 vmlinuz
[root@localhost boot]# cd grub
[root@localhost grub]# vi grub.conf
[root@localhost grub]# reboot
3.步骤说明
源码的升级，我将其归纳为源码准备、工具准备、配置内核、编译内核、安装模块、启动设置和重启7个步骤。我是以root的身份登录的，所以省略了用户切换的过程。
3.1.源码准备
这个没有什么好说的，到
www.kernel.org
去下载就是。我这里下载的是linux-2.4.26.tar.bz2，将其放到/usr/src目录下面，使用下面的方法解压缩：
[root@localhost src]# cd /usr/src
[root@localhost src]# tar vxfj linux-2.4.26.tar.bz2
[root@localhost src]# ln –s linux2.4.26 linux
解压缩完成后得到linux-2.4.26目录。喜欢图形界面的朋友可以不用这样，我在gnome下执行鼠标右键弹出菜单命令“解压缩到这里…”也能达到同样的目的，不过经常出错。
3.2.工具准备
我所使用的两个内核版本跨度不大，所以没有特别安装什么工具，如果是升级到2.6.x版本会需要一些而外的工具。
3.3.配置内核
这是编译内核最麻烦的地方了，我们将要面临一大堆驱动模块的配置选项，对于我这样的菜鸟就头晕了，开始时傻呼呼的按照网站上的一些资料介绍，执行make menuconfig或make xconfig，结果碰得“头破血流”。
在redhat9下执行make xconfig，会提示需要qt，在我看来make menuconfig是最好用的，不过在此之前不需要着急。  内核配置的结果是在源码的顶级目录下生成一个.config文件，其中当然是保存了各种配置项的设定值，如果不想在那么多的似懂非懂的选项中选择的话，先 执行下面的操作：
[root@localhost src]# cd /usr/src/linux
[root@localhost linux]# cp /boot/config-2.4.20-8 .config
在redhat9安装完成后,/boot/config-2.4.20-8就是我们所需要的.config文件，只要将其复制到源码目录并改名成. config就可以了，这样，在执行下面的操作就能得到当前系统的配置，如果需要增加驱动模块，只需要作少量修改就可以了。（注意，如果使用ls的话，结 果中我们看不到.config文件，加上选项 ls –al就可以了。）
[root@localhost linux]# make menuconfig
[root@localhost linux]# make dep
[root@localhost linux]# make clean
关于.config文件的说明请参考附录
.config
部分。
3.4.编译内核
[root@localhost linux]# make bzImage
当你看到类似以下信息，说明编译成功了
tools/build -b bbootsect bsetup
compressed/bvmlinux.out CURRENT > bzImage
Root device is (3, 8)
Boot sector 512 bytes.
Setup is 4886 bytes.
System is 917 kB
make[1]: Leaving directory
`/usr/src/linux-2.4.26/arch/i386/boot'
3.5.安装模块[root@localhost linux]# make modules
[root@localhost linux]# make modules_install
在make
modules_install执行完成后，如果成功了，你将会在/lib/modules目录下看到2.4.26。
3.6.启动设置[root@localhost linux]# cp arch/i386/boot/bzImage /boot/vmlinuz-2.4.26
[root@localhost linux]# cp .config /boot/config-2.4.26
[root@localhost linux]# cp System.map /boot/System.map-2.4.26
[root@localhost linux]# mkinitrd /boot/initrd-2.4.26.img 2.4.26
很多资料上介绍了手工生成ramdisk的过程，mkinitrd可以帮我们完成这个稍微复杂的过程，如果这个操作执行成功，mkinitrd会在/boot目录下生成initrd-2.4.26.img文件。
[root@localhost linux]# cd /boot
[root@localhost boot]# rm -f System.map vmlinuz
[root@localhost boot]# ln -s System.map-2.4.26 System.map
[root@localhost boot]# ln -s vmlinuz-2.4.26 vmlinuz
关于bzImage和System.map请参考附录。
我安装redhat9时选择的是grub，所以需要改变grub.config中的设置。
[root@localhost boot]# cd grub
[root@localhost grub]# vi grub.conf
用vi打开/boot/grub/grub.conf文件，找到下面的两行，将其注释，并增加下面的内容。
#kernel /boot/vmlinuz-2.4.20-8 ro
root=LABEL=/
#initrd /boot/initrd-2.4.20-8.img
kernel /boot/vmlinuz ro root=/dev/hda8
initrd /boot/initrd-2.4.26.img
root指定/挂载点的位置，如果不知道，可以使用df命令查看。
这里有一点需要注意，整个启动设置可以使用一个命令make install来完成，不过会有很多问题，对grub.conf文件的设置就是其中之一，make install修改的grub.conf文件仍然使用”LABEL”符号，而这个符号在2.4.26的内核下已经不起作用了。
3.7.重启
[root@localhost grub]# reboot
但愿你也成功！
4.总结
网上的资料虽然丰富，但多数不系统，也没有随着环境的升级而得到及时的更正，很多时候找下来的资料都不知道实用于那个版本的操作系统或内核。举个小例子，
在www.kernel.org官方网站上有一个readme文件，其中说明如何编译内核，其中有这么几步操作：
      
       cd include
            
rm –rf asm linux scsi
            
ln –s asm-i386 asm
            
ln –s linux linux
            
ln –s scsi scsi
如果执行了这些操作，在编译2.4.26的内核时会出现错误。
在没有人指导的情况下，最好能找比较系统点的资料，或者到书店买本书。我就是这样，多亏找到了《The Linux Kernel HOWTO》才使得我成功编译内核，否则还不知道要失败多少次呢。
5.附录
.config
Everytime you compile and install the
kernel image in /boot, you should also copy the corresponding config
file to /boot area, for documentation and
future reference. Do NOT touch or edit these files!!
bzImage
The bzImage is the compressed kernel image
created with command 'make bzImage' during kernel compile. It
important to note that bzImage is not
compressed with bzip2 !! The name bz in bzImage is misleading!! It
stands for "Big Zimage". The
"b" in bzImage is "big". Both zImage and bzImage are
compressed with gzip.
The kernel includes a mini−gunzip to
uncompress the kernel and boot into it. The difference is that the old
zImage uncompresses the kernel into low
memory (the first 640k), and bzImage uncompresses the kernel into
high memory (over 1M). The only problem is
that there are a very few machines where bzImage is known to
have problems (because the machines are
buggy). The bzImage actually boots faster, but other than that,
there's no difference in the way the system
*runs*. The rule is that if all drivers cannot fit into the zImage,
then you need to modularize more.
If the kernel is small, it will work as
both a zImage and a bzImage, and the booted system runs the same way.
A big kernel will work as a bzImage, but
not as a zImage. Both bootimages are gzipped, (bzImage is not
bzipped as the name would suggest), but are
put together and loaded differently, that allows the kernel to load
in higher address space, that does not
limit it to lower memory in the pathetic intel architecture. So why have
both? Backward compatability. Some older
lilos and loadlins don't handle the bzImage format. Note, they
*boot* differently, but *run* the same.
There is a lot of misinformation given out about what a bzImage file is
(mostly about it being bzip2ed).
System.map
System.map is a "phone directory"
list of function in a particular build of a kernel. It is typically a symlink
to
the System.map of the currently running
kernel. If you use the wrong (or no) System.map, debugging crashes
is harder, but has no other effects.
Without System.map, you may face minor annoyance messages.
Do NOT touch the System.map files.
ls −ld /boot/System.map*
lrwxrwxrwx 1 root root 30 Jan 26 19:26
/boot/System.map −> System.map−2.4.18−−rw−r−−r−− 1 root root 501166 Sep 4
2002 /boot/System.map−2.4.18−14
−rw−r−−r−− 1 root root 510786 Jan 26 01:29
/boot/System.map−2.4.18−19.8.0
−rw−r−−r−− 1 root root 331213 Jan 25 22:21
/boot/System.map−2.4.18−19.8.0BOOT
−rw−r−−r−− 1 root root 503246 Jan 26 19:26
/boot/System.map−2.4.18−19.8.0custom
How The Kernel Symbol Table Is Created ?
System.map is produced by 'nm vmlinux' and
irrelevant or
uninteresting symbols are grepped out, When
you compile the kernel, this file 'System.map' is created at
/usr/src/linux/System.map. Something like
below:
nm /boot/vmlinux−2.4.18−19.8.0 >
System.map
# Below is the line from
/usr/src/linux/Makefile
nm vmlinux | grep −v '\(compiled\)\|\(\.o$$\)\|\(
[aUw] \)\|\(\.\.ng$$\)\|\(LASH[RL]DI\)' cp /usr/src/linux/System.map
/boot/System.map−2.4.18−14 # For v2.4.18
From
"http://www.dirac.org/linux/systemmap.html"
10.9.1. System.map
There seems to be a dearth of information
about the System.map file. It's really nothing mysterious, and in the
scheme of things, it's really not that
important. But a lack of documentation makes it shady. It's like an
earlobe; we all have one, but nobody really
knows why. This is a little web page I cooked up that explains the
The Linux Kernel HOWTO
10. Kernel Files Information 24
why.
Note, I'm not out to be 100[percnt]
correct. For instance, it's possible for a system to not have /proc filesystem
support, but most systems do. I'm going to
assume you "go with the flow" and have a fairly typical system.
Some of the stuff on oopses comes from
Alessandro Rubini's "Linux Device Drivers" which is where I
learned most of what I know about kernel
programming.
10.9.2. What Are Symbols?
In the context of programming, a symbol is
the building block of a program: it is a variable name or a function
name. It should be of no surprise that the
kernel has symbols, just like the programs you write. The difference
is, of course, that the kernel is a very
complicated piece of coding and has many, many global symbols.
10.9.3. What Is The Kernel Symbol Table?
The kernel doesn't use symbol names. It's
much happier knowing a variable or function name by the variable
or function's address. Rather than using
size_t BytesRead, the kernel prefers to refer to this variable as (for
example) c0343f20.
Humans, on the other hand, do not
appreciate names like c0343f20. We prefer to use something like size_t
BytesRead. Normally, this doesn't present
much of a problem. The kernel is mainly written in C, so the
compiler/linker allows us to use symbol
names when we code and allows the kernel to use addresses when it
runs. Everyone is happy.
There are situations, however, where we
need to know the address of a symbol (or the symbol for an address).
This is done by a symbol table, and is very
similar to how gdb can give you the function name from a address
(or an address from a function name). A
symbol table is a listing of all symbols along with their address. Here
is an example of a symbol table:
c03441a0 B dmi_broken
c03441a4 B is_sony_vaio_laptop
c03441c0 b dmi_ident
c0344200 b pci_bios_present
c0344204 b pirq_table
c0344208 b pirq_router
c034420c b pirq_router_dev
c0344220 b ascii_buffer
c0344224 b ascii_buf_bytes
You can see that the variable named
dmi_broken is at the kernel address c03441a0.
10.9.4. What Is The System.map File?
There are 2 files that are used as a symbol
table:
/proc/ksyms 1.
System.map 2.
There. You now know what the System.map
file is.
The Linux Kernel HOWTO
10. Kernel Files Information 25
Every time you compile a new kernel, the
addresses of various symbol names are bound to change.
/proc/ksyms is a "proc file" and
is created on the fly when a kernel boots up. Actually, it's not really a file;
it's
simply a representation of kernel data
which is given the illusion of being a disk file. If you don't believe me,
try finding the filesize of /proc/ksyms.
Therefore, it will always be correct for the kernel that is currently
running..
However, System.map is an actual file on
your filesystem. When you compile a new kernel, your old
System.map has wrong symbol information. A
new System.map is generated with each kernel compile and
you need to replace the old copy with your
new copy.
10.9.5. What Is An Oops?
What is the most common bug in your
homebrewed programs? The segfault. Good ol' signal 11.
What is the most common bug in the Linux
kernel? The segfault. Except here, the notion of a segfault is much
more complicated and can be, as you can
imagine, much more serious. When the kernel dereferences an
invalid pointer, it's not called a segfault
−− it's called an "oops". An oops indicates a kernel bug and should
always be reported and fixed.
Note that an oops is not the same thing as
a segfault. Your program cannot recover from a segfault. The kernel
doesn't necessarily have to be in an
unstable state when an oops occurs. The Linux kernel is very robust; the
oops may just kill the current process and
leave the rest of the kernel in a good, solid state.
An oops is not a kernel panic. In a panic,
the kernel cannot continue; the system grinds to a halt and must be
restarted. An oops may cause a panic if a
vital part of the system is destroyed. An oops in a device driver, for
example, will almost never cause a panic.
When an oops occurs, the system will print
out information that is relevent to debugging the problem, like the
contents of all the CPU registers, and the
location of page descriptor tables. In particular, the contents of the
EIP (instruction pointer) is printed. Like
this:
EIP: 0010:[]
Call Trace: []
10.9.6. What Does An Oops Have To Do With System.map?
You can agree that the information given in
EIP and Call Trace is not very informative. But more importantly,
it's really not informative to a kernel
developer either. Since a symbol doesn't have a fixed address, c010b860
can point anywhere.
To help us use this cryptic oops output,
Linux uses a daemon called klogd, the kernel logging daemon. klogd
intercepts kernel oopses and logs them with
syslogd, changing some of the useless information like c010b860
with information that humans can use. In
other words, klogd is a kernel message logger which can perform
name−address resolution. Once klogd
tranforms the kernel message, it uses whatever logger is in place to log
system wide messages, usually syslogd.
To perform name−address resolution, klogd
uses System.map. Now you know what an oops has to do with
System.map.
The Linux Kernel HOWTO
10. Kernel Files Information 26
Fine print: There
are actually two types of address resolution are performed by klogd.
Static translation, which uses the
System.map file. ·
Dynamic translation which is used with
loadable modules, doesn't use ·
System.map and is therefore not relevant to
this discussion, but I'll describe it briefly anyhow.
Klogd Dynamic Translation
Suppose you load a kernel module which
generates an oops. An oops message is generated, and klogd
intercepts it. It is found that the oops
occured at d00cf810. Since this address belongs to a dynamically loaded
module, it has no entry in the System.map
file. klogd will search for it, find nothing, and conclude that a
loadable module must have generated the
oops. klogd then queries the kernel for symbols that were exported
by loadable modules. Even if the module
author didn't export his symbols, at the very least, klogd will know
what module generated the oops, which is
better than knowing nothing about the oops at all.
There's other software that uses
System.map, and I'll get into that shortly.
10.9.7. Where Should System.map Be Located?
System.map should be located wherever the
software that uses it looks for it. That being said, let me talk
about where klogd looks for it. Upon
bootup, if klogd isn't given the location of System.map as an argument,
it will look for System.map in 3 places, in
the following order:
/boot/System.map 1.
/System.map 2.
/usr/src/linux/System.map 3.
System.map also has versioning information,
and klogd intelligently searches for the correct map file. For
instance, suppose you're running kernel
2.4.18 and the associated map file is /boot/System.map. You now
compile a new kernel 2.5.1 in the tree
/usr/src/linux. During the compiling process, the file
/usr/src/linux/System.map is created. When
you boot your new kernel, klogd will first look at
/boot/System.map, determine it's not the
correct map file for the booting kernel, then look at
/usr/src/linux/System.map, determine that
it is the correct map file for the booting kernel and start reading the
symbols.
A few nota bene's:
Somewhere during the 2.5.x series, the
Linux kernel started to untar into linux−version, rather than
just linux (show of hands −− how many
people have been waiting for this to happen?). I don't know if
klogd has been modified to search in
/usr/src/linux−version/System.map yet. TODO: Look at the
klogd srouce. If someone beats me to it,
please email me and let me know if klogd has been modified
to look in the new directory name for the
linux source code.
·
The man page doesn't tell the whole the
story. Look at this: ·
# strace −f /sbin/klogd | grep 'System.map'
31208
open("/boot/System.map−2.4.18", O_RDONLY|O_LARGEFILE) = 2
Apparently, not only does klogd look for
the correct version of the map in the 3 klogd search directories, but
klogd also knows to look for the name
"System.map" followed by "−kernelversion", like
System.map−2.4.18.
The Linux Kernel HOWTO
10. Kernel Files Information 27
This is undocumented feature of klogd.
A few drivers will need System.map to
resolve symbols (since they're linked against the kernel headers
instead of, say, glibc). They will not work
correctly without the System.map created for the particular kernel
you're currently running. This is NOT the
same thing as a module not loading because of a kernel version
mismatch. That has to do with the kernel
version, not the kernel symbol table which changes between kernels
of the same version!
10.9.8. What else uses the System.map
Don't think that System.map is only useful
for kernel oopses. Although the kernel itself doesn't really use
System.map, other programs such as klogd,
lsof,
satan# strace lsof 2>&1 1>
/dev/null | grep System
readlink("/proc/22711/fd/4",
"/boot/System.map−2.4.18", 4095) = 23
and ps :
satan# strace ps 2>&1 1>
/dev/null | grep System
open("/boot/System.map−2.4.18",
O_RDONLY|O_NONBLOCK|O_NOCTTY) = 6
and many other pieces of software like
dosemu require a correct System.map.
10.9.9. What Happens If I Don't Have A Healthy System.map?
Suppose you have multiple kernels on the
same machine. You need a separate System.map files for each
kernel! If boot a kernel that doesn't have
a System.map file, you'll periodically see a message like:
System.map does not match actual kernel Not
a fatal error, but can be annoying to see everytime you do a ps
ax. Some software, like dosemu, may not
work correctly (although I don't know of anything off the top of my
head). Lastly, your klogd or ksymoops
output will not be reliable in case of a kernel oops.
10.9.10. How Do I Remedy The Above Situation?
The solution is to keep all your System.map
files in /boot and rename them with the kernel version. Suppose
you have multiple kernels like:
/boot/vmlinuz−2.2.14 ·
/boot/vmlinuz−2.2.13 ·
Then just rename your map files according
to the kernel version and put them in /boot, like:
/boot/System.map−2.2.14
/boot/System.map−2.2.13
Now what if you have two copies of the same
kernel? Like:
/boot/vmlinuz−2.2.14 ·
The Linux Kernel HOWTO
10. Kernel Files Information 28
/boot/vmlinuz−2.2.14.nosound ·
The best answer would be if all software
looked for the following files:
/boot/System.map−2.2.14
/boot/System.map−2.2.14.nosound
You can also use symlinks:
System.map−2.2.14
System.map−2.2.14.sound
ln −s System.map−2.2.14.sound System.map #
Creating initrd.img file
The initrd is the "initial
ramdisk". It is enough files stored in a ramdisk to store needed drivers .
You need the
drivers so that the kernel can mount / and
kick off init. The initrd is typically used for temporarily booting the
hardware into a state, that the real kernel
vmlinuz can than take over and continue the booting. For example −
you can't read the kernel off the scsi hard
disk until you have a scsi driver loaded in the kernel. (Solution: boot
an initrd kernel that can read the real
kernel and use initrd to fix scsi booting problems)
You can avoid this file 'initrd.img' and
eliminate the need of 'initrd.img', if you build your scsi drivers right
into the kernel, instead of into modules.
(Many persons recommend this).
14.1. Using mkinitrd
The mkinitrd utility creates an initrd
image in a single command. This is command is peculiar to RedHat.
There may be equivalent command of mkinitrd
in other distributions of Linux. This is very convenient utility.
You can read the mkinitrd man page.
/sbin/mkinitrd −−help # Or simply type
'mkinitrd −−help'
usage: mkinitrd [−−version] [−v] [−f]
[−−preload ]
[−−omit−scsi−modules] [−−omit−raid−modules]
[−−omit−lvm−modules]
[−−with=] [−−image−version]
[−−fstab=] [−−nocompress]
[−−builtin=] [−−nopivot]

(example: mkinitrd
/boot/initrd−2.2.5−15.img 2.2.5−15)
# Read the online manual page with .....
man mkinitrd
su − root
# The command below creates the initrd
image file
mkinitrd ./initrd−2.4.18−19.8.0custom.img
2.4.18−19.8.0custom
ls −l initrd−2.4.18−19.8.0custom.img
−rw−r−−r−− 1 root root 127314 Mar 19 21:54
initrd−2.4.18−19.8.0custom.img
cp ./initrd−2.4.18−19.8.0custom.img /boot
See the following sections for the manual
method of creating an initrd image.
14.2. Kernel Docs
To create /boot/initrd.img see the
documentation at /usr/src/linux/Documentation/initrd.txt and see also
Loopback−Root−mini−HOWTO .
14.3. Linuxman Book
A cut from
"http://www.linuxman.com.cy/rute/node1.html" chapter 31.7.
SCSI Installation Complications and initrd
Some of the following descriptions may be
difficult to understand without knowledge of kernel modules
explained in Chapter 42. You may want to
come back to it later.
Consider a system with zero IDE disks and
one SCSI disk containing a LINUX installation. There are BIOS
interrupts to read the SCSI disk, just as
there were for the IDE, so LILO can happily access a kernel image
somewhere inside the SCSI partition.
However, the kernel is going to be lost without a kernel module [lsqb
]See Chapter 42. The kernel doesn't support
every possible kind of hardware out there all by itself. It is
actually divided into a main part (the
kernel image discussed in this chapter) and hundreds of modules
(loadable parts that reside in
/lib/modules/) that support the many type of SCSI, network, sound etc.,
peripheral devices.] that understands the
particular SCSI driver. So although the kernel can load and execute,
it won't be able to mount its root file
system without loading a SCSI module first. But the module itself resides
in the root file system in /lib/modules/.
This is a tricky situation to solve and is done in one of two ways:
either (a) using a kernel with preenabled
SCSI support or (b) using what is known as an initrd preliminary root
file system image.
The first method is what I recommend. It's
a straightforward (though time−consuming) procedure to create a
kernel with SCSI support for your SCSI card
built−in (and not in a separate module). Built−in SCSI and
network drivers will also autodetect cards
most of the time, allowing immediate access to the device−−they
will work without being given any options
[lsqb ]Discussed in Chapter 42.] and, most importantly, without
your having to read up on how to configure
them. This setup is known as compiled−in support for a hardware
driver (as opposed to module support for
the driver). The resulting kernel image will be larger by an amount
equal to the size of module. Chapter 42
discusses such kernel compiles.
The second method is faster but trickier.
LINUX supports what is known as an initrd image ( initial rAM disk
image). This is a small, +1.5 megabyte file
system that is loaded by LILO and mounted by the kernel instead
of the real file system. The kernel mounts
this file system as a RAM disk, executes the file /linuxrc, and then
only mounts the real file system.
31.6 Creating an initrd Image
Start by creating a small file system. Make
a directory [nbsp ]/initrd and copy the following files into it.
drwxr−xr−x 7 root root 1024 Sep 14 20:12
initrd/
drwxr−xr−x 2 root root 1024 Sep 14 20:12
initrd/bin/
−rwxr−xr−x 1 root root 436328 Sep 14 20:12
initrd/bin/insmod
−rwxr−xr−x 1 root root 424680 Sep 14 20:12
initrd/bin/sash
drwxr−xr−x 2 root root 1024 Sep 14 20:12
initrd/dev/
crw−r−−r−− 1 root root 5, 1 Sep 14 20:12
initrd/dev/console
crw−r−−r−− 1 root root 1, 3 Sep 14 20:12
initrd/dev/null
brw−r−−r−− 1 root root 1, 1 Sep 14 20:12
initrd/dev/ram
crw−r−−r−− 1 root root 4, 0 Sep 14 20:12
initrd/dev/systty
crw−r−−r−− 1 root root 4, 1 Sep 14 20:12
initrd/dev/tty1
crw−r−−r−− 1 root root 4, 1 Sep 14 20:12
initrd/dev/tty2
crw−r−−r−− 1 root root 4, 1 Sep 14 20:12
initrd/dev/tty3
crw−r−−r−− 1 root root 4, 1 Sep 14 20:12
initrd/dev/tty4
drwxr−xr−x 2 root root 1024 Sep 14 20:12
initrd/etc/
drwxr−xr−x 2 root root 1024 Sep 14 20:12
initrd/lib/
−rwxr−xr−x 1 root root 76 Sep 14 20:12
initrd/linuxrc
drwxr−xr−x 2 root root 1024 Sep 14 20:12
initrd/loopfs/
On my system, the file initrd/bin/insmod is
the statically linked [lsqb ]meaning it does not require shared
libraries.] version copied from
/sbin/insmod.static−−a member of the modutils−2.3.13 package. initrd/bin/sash
is a statically linked shell from the
sash−3.4 package. You can recompile insmod from source if you don't
have a statically linked version.
Alternatively, copy the needed DLLs from /lib/ to initrd/lib/. (You can get the
list of required DLLs by running ldd
/sbin/insmod. Don't forget to also copy symlinks and run strip −s {lib} to
reduce the size of the DLLs.)
The Linux Kernel HOWTO
Now copy into the initrd/lib/ directory the
SCSI modules you require. For example, if we have an Adaptec
AIC−7850 SCSI adapter, we would require the
aic7xxx.o module from /lib/modules/{version}/scsi/aic7xxx.o.
Then, place it in the initrd/lib/
directory.
−rw−r−−r−− 1 root root 129448 Sep 27 1999
initrd/lib/aic7xxx.o
The file initrd/linuxrc should contain a
script to load all the modules needed for the kernel to access the SCSI
partition. In this case, just the aic7xxx
module [lsqb ] insmod can take options such as the IRQ and IO−port
for the device. See Chapter 42.]:
#!/bin/sash
aliasall
echo "Loading aic7xxx module"
insmod /lib/aic7xxx.o
Now double−check all your permissions and
then chroot to the file system for testing.
chroot ~/initrd /bin/sash
/linuxrc
Now, create a file system image similar to
that in Section 19.9:
dd if=/dev/zero of=~/file−inird count=2500
bs=1024
losetup /dev/loop0 ~/file−inird
mke2fs /dev/loop0
mkdir ~/mnt
mount /dev/loop0 ~/mnt
cp −a initrd/* ~/mnt/
umount ~/mnt
losetup −d /dev/loop0
Finally, gzip the file system to an
appropriately named file:
gzip −c ~/file−inird > initrd−
31.7 Modifying lilo.conf for initrd
Your lilo.conf file can be changed slightly
to force use of an initrd file system. Simply add the initrd option.
For example:
boot=/dev/sda
prompt
timeout = 50
compact
vga = extended
linear
image = /boot/vmlinuz−2.2.17
initrd = /boot/initrd−2.2.17
The Linux Kernel HOWTO
14. Appendix A − Creating initrd.img file
40
label = linux
root = /dev/sda1
read−only
Notice the use of the linear option. This
is a BIOS trick that you can read about in lilo(5). It is often necessary
but can make SCSI disks nonportable to
different BIOSs (meaning that you will have to rerun lilo if you move
the disk to a different computer).

Trackback:
http://tb.blog.csdn.net/TrackBack.aspx?PostId=445320

               
               

本文来自ChinaUnix博客，如果查看原文请点：http://blog.chinaunix.net/u/15123/showart_106998.html