Next
Previous
Contents
The kernel does quite a lot really. I think a fair way of summing it up is that it makes the hardware do what the programs want, fairly and efficiently.
The processor can only execute one instruction at a time, but Linux systems
appear to be running lots of things simultaneously. The kernel acheives this by
switching from task to task really quickly. It makes the best use of the processor
by keeping track of which processes are ready to go, and which ones are waiting
for something like a record from a hard disk file, or some keyboard input.
This kernel task is called scheduling.
If a program isn't doing anything, then it doesn't need to be in RAM. Even a
program that is doing something, might have parts that aren't doing anything.
The address space of each process is divided into pages. The Kernel keeps track of
which pages of which processes are being used the most. The pages that aren't
used so much can be moved out to the swap partition. When they are needed again,
another unused page can be paged out to make way for it. This is virtual memory
management.
If you have ever compiled your own Kernel, you will have noticed that there are
many many options for specific devices. The kernel contains a lot of specific
code to talk to diverse kinds of hardware, and present it all in a nice uniform
way to the application programs.
The Kernel also manages the filesystem, interprocess communication, and a lot
of networking stuff.
Once the kernel is loaded, the first thing it does is look for an init program to run.
Most of the configuration of the kernel is done when you build it, using
make menuconfig, or make xconfig in /usr/src/linux/
(or wherever your Linux kernel source is). You can reset the default video
mode, root filesystem, swap device and RAM disk size using rdev. These
parameters and more can also be passed to the kernel from lilo. You can give lilo
parameters to pass to the kernel either in lilo.conf, or at the lilo prompt.
For example if you wanted to use hda3 as your root file system instead of hda2,
you might type
LILO: linux root=/dev/hda3
If you are building a system from source, you can make life a lot simpler by
creating a ``monolithic'' kernel. That is one with no modules. Then you don't
have to copy kernel modules to the target system.
NOTE: The System.map file is used by the kernel logger to determine
the module names generating messages. The program top also uses this
information. When you copy the kernel to the target system, copy
System.map too.
Think about this: /dev/hda3 is a special type of file that
describes a hard disk partition. But it lives on a file system just like all
other files. The kernel wants to know which partition to mount as the root
filesystem - it doesn't have a file system yet. So how can it read
/dev/hda3 to find out which partition to mount?
If you haven't already: build your own kernel. Read all the help information
for each option.
See how small a kernel you can make that still works. You can learn a lot by leaving the wrong things out!
Read ``The Linux Kernel'' (URL below) and as you do, find the parts of the source code that it refers to. The book (as I write) refers to kernel version 2.0.33, which is pretty out of date. It might be easier to follow if you download this old version and read the source there. Its amazing to find bits of C code called ``process'' and ``page''.
Hack! See if you can make it spit out some extra messages or something.
Next
Previous
Contents
| 
Take our 
