Библиотека сайта rus-linux.net
If you are running Linux on a system with hardware or wish to use features not supported in the stock kernels, or perhaps you wish to reduce the kernel memory footprint to make better use of your system memory, you may find it necessary to build your own custom kernel.
Upgrading the kernel involves configuring desired modules,
compiling the kernel and modules, and finally installing the kernel
image. This is followed by a system reboot (with fingers crossed!) to
load the new kernel. All of this is documented in the
'' file which comes with
each kernel package. Further information can be found in the
A particularly helpful file there is
'' which contains
detailed information on the available kernel compile options and
The following is a sample session demonstrating the build of a custom kernel, version 2.0.36 on the Intel platform. While building a custom kernel is usually just a matter of configuring, compiling & installing, sometimes (usually in the case of new hardware) it is necessary to download additional driver software should your hardware not yet be supported by the kernel version you are compiling.
The first step in building a custom kernel is to download and install the kernel sources from either RPM (preferred) or from tarball. See Section 10.4 for details on obtaining the appropriate files.
Next, use the ``
rpm'' utility (or
tar'', as appropriate) to install the kernel source
tree and header files. For example, to install the 2.0.36-3 kernel RPM
(If you are running Linux on a notebook, you would also likely
file, which provides power management features.)
After installing the kernel files, you should be able to find the
new source tree in the
The next step is to download any additional driver files (if
applicable) and install them in the new kernel source tree. For example,
to add support for the Mylex DAC960 hardware RAID controller, I would
download the driver software from the http://www.dandelion.com/ web
site. Unfortunately, such driver software are usually only offered as
tarballs and need to be installed using the ``
utility. For example:
You should read the documentation provided with your additional
driver software, if applicable. For example, the DAC960 driver includes
'' file which gives
instructions on where the newly downloaded files should be located, and
how to apply the kernel patch:
The next step is to ensure your system's symbolic file links are consistent with the new kernel tree. Actually, this step only needs to be done once, so the following needs to be done only if you haven't compiled a custom kernel before:
Note: Note: The above step is no longer necessary for 2.2.x or higher kernel versions.
The next step is to configure your kernel settings. This is the most important step in building the custom kernel. If you disable the wrong settings, you may leave out support for features or hardware you need. However, if you enable the wrong settings, you will be needlessly enlarging the kernel and wasting your valuable system memory (that being said, it is probably better to err on the side of the latter rather than the former).
The best way of ensuring you compile the kernel properly is to know what features you will need to use, and what hardware is in your system that you will require support for. After you have gained experience in customizing your kernel a few times, the process will become "old hat" and won't seem so intimidating!
Type the following to begin the configuration process:
(You could type ``
make xconfig'' instead of
make menuconfig'' if you have the X Window System
running; see Chapter 5 for details on how
to get X working.)
To configure your kernel, go through the various settings and select
(enable) whichever ones you require, and de-select (disable) the ones you
do not require. You can choose between having such support built right
into the kernel, or having it built as a module which is loaded and
unloaded by the kernel as needed. (If you compile a feature that is
actually needed to boot your system, such as a SCSI driver, as a module,
you will need to create a RAMdisk image or your system will not boot. This
is done with the ``
mkinitrd'' command; this procedure is
described a little further down.)
When going through the configuration settings, you can select
<Help> for a description of what a given kernel
option is for.
After you have configured your kernel settings, type the following commands to compile your kernel:
If you are recompiling the same kernel as you have previously (2.0.36-3 in this example), you will likely want to move the existing modules to a backup directory as with the following command:
Now, type the following command to actually install the new modules:
The next step is to copy the kernel into the
'' directory and use LILO
to update the boot record so that the new kernel is recognized. The
following commands will make a backup copy of your existing kernel, copy
the new kernel over, and then refresh the LILO boot record:
Finally, you will need to edit your
'' file, and make
sure the "image" reference is pointing to the new kernel.
You should also add a section which points to your backup kernel, called,
perhaps, "OldLinux". Here is an example file:
boot=/dev/hda map=/boot/map install=/boot/boot.b prompt timeout=50 image=/boot/vmlinuz label=Linux root=/dev/hdb1 read-only image=/boot/vmlinuz.OLD label=OldLinux read-only
By adding your backup kernel information in this way, should your
new kernel fail to boot properly (perhaps a device is not recognized, or
a daemon doesn't start as it should), you can simply type
OldLinux'' to boot from the old kernel and
investigate the problem.
Note: Note: As mentioned previously, if you've compiled a feature required to boot your system as a module, you will need to create an initial RAMdisk image in order to boot your system. (Don't forget to compile your kernel with support for such an initial boot image.)
The procedure to create and use an initial RAMdisk image is as follows:
Add an entry in your ``
'' to boot off the initial RAMdisk image; this is shown as an addition to the example configuration file shown earlier:
image=/boot/vmlinuz label=Linux root=/dev/hdb1 initrd=/boot/initrd-2.2.4-4.img read-only
The loopback device needs to be loaded before you are able to use the mkinitrd command. Make sure the loopback device module is loaded:
(If you get an error message about not being able to load the loopback module, you may need to specify the full path to the module for the current kernel your system is still running on, for example ``
Use the ``
mkinitrd'' command to actually create the image:
/sbin/mkinitrd /boot/initrd-2.0.36-3.img 2.0.36-3
/sbin/lilo'' to update your boot loader.
Now, shut down your system and boot the new kernel!
If your kernel refuses to boot altogether, don't panic. Boot off the boot disk that was created during the installation of Linux . If you don't have copies of this disks, you should be able to create one from the Red Hat CD. Insert the boot diskette into the drive and reboot the computer. When you see the "boot:" prompt, type:
The above command assumes your "/" (root) partition is located on /dev/hda1.
Linux should then boot normally (although since you are using the
kernel from the boot disk, not all services or devices may operate
properly for this session), and then you can restore your old kernel and
reinstall the LILO boot loader information (ie. ``
/vmlinuz ; /sbin/lilo'') and shutdown/restart. You can then try
recompiling the kernel with different options and try again.