Lesson 12

This module introduced you to issues and procedures related to configuring and compiling the Linux kernel. The module began with a discussion of monolithic and modularized kernels. You learned that monolithic kernels include all hardware and filesystem support compiled into the kernel. Depending on the number of supported components, the kernel can grow to a critical size very quickly. Modularized kernels, on the other hand, load modules as needed so the kernel is not inflated with unused component support.
Next, you explored the use of modprobe as a method to intelligently controlling the loading of kernel modules. When the kernel sees the need for a module, the kernel thread kmod uses modprobe to load the necessary module.
Next, you explored the advantages and disadvantages of building a custom kernel. One of the reasons you might want to build a custom kernel include is to enable advanced routing options or capabilities not enabled in the standard Red Hat kernel. However, unless it is absolutely necessary, building a custom kernel is not recommended.
Finally, you explored the steps involved in configuring, compiling, and installing the Linux kernel and modules. You learned the many steps required to actually build and install the kernel and modules, then you learned the post-installation issues including ramdisks and the LILO map installer.

Having completed this module, you should be able to

1. Explain the differences between modular and monolithic kernels
2. List available modules
3. Load kernel modules
4. Configure kernel modules
5. List the advantages and disadvantages of building a custom Linux kernel
6. Describe preliminary kernel-building procedures
7. Configure kernel options before compilation
8. Compile and install the kernel and modules
9. Describe common post-installation procedures
10. Use the LILO map installer to install first- and second-stage boot loaders

This module introduced you to the following terms.

1. Compiler: A program that converts source code into an executable machine binary.
2. Demand loading: Loading functionality only when it is needed.
3. Developmental: Developmental modules are still being tested and improved. If you chose to use one, be aware that it may include many unresolved bugs.
4. Device drivers: A unit of code written to interact with a specific hardware device.
5. Extra-version specification: The extra-version specification is used to distinguish between various configurations of the same kernel version. It is separated from the traditional version by a hyphen.
6. Instance: A particular session of any object, where each session has particular characteristics that identify it uniquely. For example, a red car is an instance of the general "car" object, and you can identify the car by its red characteristic.
7. IrDA: An acronym for Infrared Data Association, IrDA is an international standards body that plans the hardware and software requirements for wireless, infrared data communication.
8. ISDN: An acronym for Integrated Services Digital Network, ISDN is a standards specification for data transmission over telephone wires and other land-based media.
9. Kernel: The core component of an operating system. The kernel is responsible for interfacing with the system hardware on user program's behalf, managing system memory and scheduling tasks to run.
10. Kernel thread: The Linux kernel is multi-threaded, meaning that multiple actions occur within the kernel simultaneously.
11. Major version: The major version is the first number included in the standard module naming convention. It specifies the kernel version.
12. Memory footprint: The total amount of physical and swap memory a process uses.
13. Minor version: The minor version is the second number included in the standard module naming convention. It specifies the version of the kernel version. Odd numbers indicate developmental versions of a particular kernel and even numbers indicate a production or stable version of a particular kernel.
14. Modular kernel: A modular kernel is one in which some drivers are built as object files, or modules, that the kernel can load on demand.
15. Monolithic kernel A monolithic kernel is one in which support for all hardware, network protocols, and file systems is built within a single file.
16. Object files: Compiled source code (such as C or C++).
17. Patch level: The patch level is the third number included in the standard module naming convention. The greater the number, the more recent the patch is and the more likely bug fixes are implemented and security holes closed.
18. Process: The computer's representation of a task. When a program is run from the command line, the binary is loaded into memory as a "process." The kernel shuffles processes around very quickly, simulating "simultaneous" program execution.
19. Ramdisk: Ramdisks are block devices like hard disks and CD-ROM drives. However, ramdisks store their data in random access memory, as opposed to on disk. This is useful during installation.
20. RPM: An acronym for Red Hat Package Manager, an RPM is a group of files stored in a single portable file.
21. Stable: A stable version is indicated by even minor version numbers and should not contain any crippling bugs.
22. Stanza: A block of commands in the /etc/lilo.conf file that define configuration values for a specific operating system.

The next module discusses how to administer Linux serial and networking devices.

Before moving on to the next module, click the Quiz link below to test your knowledge of configuring and compiling the Linux kernel.
Compiling Linux Kernel - Quiz