Linux Kernel

Kernel is a mediator for the programs and hardware. The Kernel's major subsystems are Memory Management, Process Management, I/O system, and File System.

Memory Management: Demand paging vs. Swapping
Memory is limited and processes are getting larger. In the old day, an OS typically swaps in and out the whole process into memory. The technique of only loading virtual pages into memory as they are accessed is known as demand paging. Page fault occurs when a process needs to access certain virtual pages which are not available in memory. If a process needs to bring a virtual page into physical memory and there are no free physical pages available, the operating system must make room for this page by discarding another page from physical memory. "Thrashing" occurs when swapping algorithm is not efficient. Dirty page: a page (selected to be discarded) that has been modified requires saving the page into a swap file. The set of pages used by a process is called working set. Least Recently Used (LRU) are swapped out.
Process Management:
Processes have the following states:
Running
The process is either running (it is the current process in the system) or it is ready to run (it is waiting to be assigned to one of the system's CPUs).
Waiting
The process is waiting for an event or for a resource. Linux differentiates between two types of waiting process; interruptible and uninterruptible. Interruptible waiting processes can be interrupted by signals whereas uninterruptible waiting processes are waiting directly on hardware conditions and cannot be interrupted under any circumstances.
Stopped
The process has been stopped, usually by receiving a signal. (e.g. Debugged process can be in a stopped state)
Zombie
This is a halted process which, for some reason, still occupied an entry in process table; i.e. a dead process.

Important processes identifiers:

uid and gid: user identifier and group identifier.
effective uid and gid: privilege rights. "setuid" programs.
Init: pid - 1. Spawns children processes.
I/O: block and character devices
Character devices are accessed as files. Using standard system calls such as open, read, write to access.
Block devices are similar to character devices except it uses buffer cache. (buffer cache contains data buffers).
File System: Linux supports many different file systems. E.g. ex2, NTFS, AFS, FAT, VFAT and etc. VFS: interface layer between OS and the real file systems. A typical Linux native file system is ex2 which has two very important concepts:
inode: inode contains each file's information (owner, permissions, and type)
superblock: Each file system contains many duplicated (for recovery purpose) superblocks which include the description of the basic size and shape (mount point, block size, free blocks, free inodes) of a file system. Usually only the superblock in Block Group 0 (others are duplicates) is read when the file system is mounted.

Major and minor number of a device file: major defines the major type of devices and minor number identifies the unit. (instance of a major type) E.g. the IDE disks on the first IDE controller in the system have a major number of 3 and the first partition of an IDE disk would have a minor number of 1. Examples of block and character devices:
```
brw-rw----   1 root     disk       3,   1 May  5  1998 /dev/hda1
crw--w----   1 klai     tty        4,   1 Oct  2 11:40 tty1
```

Bootable Kernel Floppy

During the installation, you should create a bootable floppy. If you didn't, try to make a new kernel with the latest kernel source code. When adding new HW, RedHat linux will probe those devices and reconfigure the system to load additional device drivers at boot time. You don't need to make a new kernel, unless it does not recognize the newly added devices.

If you selected "Development" mode in OpenLinux installation, the kernel source code will be installed. You may download the latest kernel from the net or install source code from the second CD-ROM.
"rpm -i linux*src*.rpm" (OpenLinux)

"rpm -i kernel*src*.rpm" (RedHat)
You will see a bzipped linux source code ended with bz2 under /usr/src/OpenLinux. For RedHat, the source will be installed under /usr/src/redhat/SOURCES. To unzip and untar the source code, try bz2cat /usr/src/OpenLinux/*bz2 | (cd /usr/src; tar xf -)or zcat /usr/src/redhat/SOURCES/linux*.tar.gz | (cd /usr/src; tar xf -) You may have to install bzip source code and make bz2cat command. To find out what packages are install, enter rmp -qa.
To install a package say "wget*.rpm", enter rmp -i wget*.rpm. You may download the packages from the net, save the packages onto a MS-DOS floppy then copy it to a Linux system via mcopy a:. (assuming your Linux box is not on the net.)

cd /usr/src/linux
make mrproper
Should only be done once when loading the new kernel source code. This step makes appropriate soft links and clean up .config file. (You may try cp .config to the other directory to be safe.)
make menuconfig: refer to kernl Documentation for options information
Code maturity level options --->
Processor type and features ---> ([3-6]86, SMP)
Loadable module support ---> (loading kernel modules at run time)
General setup ---> (network, binary format)
Plug and Play support ---> (unstable)
Block devices ---> (IDE/SCSI) SS
Networking options ---> (Sockets, TCP/IP)
SCSI support ---> (disk, tape, cd-rom)
Network device support ---> (ethernet card selection)
Amateur Radio support --->
IrDA subsystem support ---> (serial infrared interface - wireless )
ISDN subsystem --->
Old CD-ROM drivers (not SCSI, not IDE) --->
Character devices ---> (virtual console, mouse)
Filesystems ---> (DOS, FAT, VFAT and etc.)
Console drivers ---> (VGA text console)
Sound ---> (see Documentation/sound)
kernel Hacking --->

For sound card configuration, chances are that you need to select O (Open Sound System) sound modules for configuring the sound card on your system.
make dep
make clean
make
make modules
make modules_install
make bzImage
Create bootable floopy with the new kernel:

dd if=/usr/src/linux/arch/i386/boot/bzImage of=/dev/fd0 bs=1024b rdev /dev/fd0 /dev/hda2 # set root device assuming it is: /dev/hda2 rdev /dev/fd0 # query root device mkbootdisk --device /dev/fd0 2.2.13 (Note: this also creats a bootable disk of the running kernel.)
Reboot the system with the new kernel image to make sure it works. If so, you may run "make install" to install the new kernel into hard drive as the default kernel. "Make install" will update lilo. But if you would like to boot from the old kernel, you have to modify lilo.conf with a different label for the old kernel. If you don't have the source code or you don't want to recompile a new kernel, you may load modules into kernel at run time via "insmod ModulesName". E.g.: To load a D-link ethernet card driver into a kernel, enter "insmod rtl8139.o". All the modules are installed under /lib/modules/2.2.12/ (assuming 2.2.12 kernel was installed - enter: uname -r). You may test the newly loaded ethernet driver module via "ifconfig eth0 10.10.10.1 netmask 255.0.0.0 up". This will bring up the ethernet card with an IP address 10.10.10.1 and netmask 255.0.0.0" If no errors displayed, you may ping 10.10.10.1 or ping other hosts on the same network. If everything goes well, you may add an entry into /etc/conf.modules for loading modules at boot time: e.g. alias eth0 rtl8139
Alternatively, you may use linuxconf to select kernel module for the ethernet card. Select on Client tasks -> Basic host Information -> Kernel module. A pull down button will show all the ethernet modules. To avoid probing the I/O space, you may pass the following parameters to the kernel: reserve=0x300,32 ehter=0,0x300,eth1

Kernel Hackers' Guide
Use the source of Linux
PCMCIA drivers PnP Linux Driver