The instructions in this section apply to building a modularized
kernel. If you are interested in building a monolithic kernel instead,
see the Section called Building a Monolithic Kernel for an explanation of
the different aspects of building and installing a monolithic kernel.
The following steps will guide you through building a custom kernel for
the x86 architecture:
The most important step is to make sure that you have a working
emergency boot disk in case you make a mistake. If you did not make a
boot disk during the installation, use the
mkbootdisk command to make one now. The standard
command is similar to mkbootdisk --device /dev/fd0
2.4.x (where 2.4.x is the full version of your
kernel such as 2.4.18-7.95). Once done, test the boot disk to make
sure that it will boot the system.
You must have the kernel-source package
installed. Issue the command rpm -q kernel-source
to determine the package version, if it is installed. If it is not
installed, install them from one of the Red Hat Linux CD-ROMs or the Red Hat FTP site
available at ftp://ftp.redhat.com (a list of
mirrors is available at http://www.redhat.com/mirrors.html).
Refer to Chapter 31 for information on installing RPM
packages.
Open a shell prompt and change to the directory
/usr/src/linux-2.4. All commands from this point
forward must be executed from this directory.
It is important that you begin a kernel build with the source tree
in a known condition. Therefore, it is recommended that you begin
with the command make mrproper. This will remove
any configuration files along with the remains of any previous
builds that may be scattered around the source tree. If you already
have an existing configuration file that works
(/usr/src/linux-2.4/.config) and you want to
use, back it up to a different directory before running this
command and copy it back afterward.
Now you need a configuration file that will determine which
components to include in your new kernel.
If you are running the X Window System, the recommended method is to
use the command make xconfig. Components are
listed in different levels of menus and are selected using a
mouse. You can select Y (yes),
N (no), or M (module).
After choosing your components, click the Save and Exit
button to create the configuration file
/usr/src/linux-2.4/.config and exit the
Linux Kernel Configuration program.
If you want to use the settings of a default Red Hat Linux kernel, copy the
the configuration file from the
/usr/src/linux-2.4/configs directory to
/usr/src/linux-2.4/.config. Then, run the
make xconfig command and only make the desired
changes. Be sure to save your changes to the configuration file.
Other available methods for kernel configuration are listed
below:
make config — An interactive text
program. Components are presented in a linear format and you
answer them one at a time. This method does not require the X
Window System and does not allow you to change your answers to
previous questions.
make menuconfig — A text mode, menu
driven program. Components are presented in a menu of
categories; you select the desired components in the same manner
used in the text mode Red Hat Linux installation program. Toggle the
tag corresponding to the item you want included:
[*] (built-in), [
] (exclude), <M>
(module), or < > (module capable).
This method does not require the X Window System.
make oldconfig — This is a
non-interactive script that will set up your configuration file
to contain the default settings. If you are using the default
Red Hat Linux kernel, it will create a configuration file for the kernel
that shipped with Red Hat Linux for your architecture.
This is useful for setting up your kernel
to known working defaults and then turning off features that you
do not want.
 | Note |
|---|
| | To use kmod (see Chapter 30 for details) and kernel modules you
must answer Yes to kmod
support and module version
(CONFIG_MODVERSIONS) support during the
configuration.
|
After creating a /usr/src/linux-2.4/.config
file, use the command make dep to set up all the
dependencies correctly.
Use the command make clean to prepare the source
tree for the build.
It is recommended that you give the custom kernel you are
building a modified version number so that you do not overwrite your
existing kernel. The method described here is the easiest to
recover from in the event of a mishap. If you are interested in
other possibilities, details can be found at http://www.redhat.com/mirrors/LDP/HOWTO/Kernel-HOWTO.html
or in the Makefile in
/usr/src/linux-2.4.
By default, /usr/src/linux-2.4/Makefile
includes the word custom at the end
of the line beginning with EXTRAVERSION.
Appending the string will allow you to have the old working kernel
and the new kernel, version 2.4.18-7.95custom, on your system at
the same time.
To give the kernel an "unique" name, you can also append the date to
the end of the string.
Build the kernel with make bzImage.
Build any modules you configured with make
modules.
Use the command make modules_install to
install the kernel modules (even if you did not build any). Make
sure that you type the underscore (_). This will
install the kernel modules into the directory path
/lib/modules/KERNELVERSION/kernel/drivers
(where KERNELVERSION is the
version specified in the Makefile). In the
example it would be
/lib/modules/2.4.18-7.95custom/kernel/drivers/.
Use make install to copy your new kernel and
its associated files to the proper directories.
In addition to installing the kernel files in the
/boot directory, this command also executes the
/sbin/new-kernel-pkg script that builds a new
initrd image and adds new entries to the boot
loader configuration file.
If you have a SCSI adapter and you compiled the SCSI driver as a
module or if you built your kernel with ext3 support as a module
(the default in Red Hat Linux), the initrd image is
required.
Even though the initrd image and boot
loader modifications are made for you, you should verify that they
were done correctly. Refer to the Section called Making an initrd Image and the Section called Configuring the Boot Loader for details.
jamesthornton.com>