Remote control your Linux with any mobile Phone

What is anyRemote?

The overall goal of this project is to provide remote control service on Linux through Bluetooth, InfraRed, Wi-Fi or just TCP/IP connection.

anyRemote supports wide range of modern cell phones like Nokia, SonyEricsson, Motorola and others.

It was developed as thin communication layer between Bluetooth (or IR, Wi-Fi) capabled phone and Linux, and in principle could be configured to manage almost any software.

anyRemote is console application, but in addition there are GUI front ends for Gnome and KDE.

Features

Plenty of connection variants

anyRemote can be used by:

bluetooth connection with java client if cell phone is JSR82 compatible

Wi-Fi connection with java client if phone supports Wi-Fi

IR connection with java client if java realization in phone supports access to IR port

Linux Performance Monitoring and Tuning

Linux system administrators should be proficient in Linux performance monitoring and tuning. This article gives a high level overview on how we should approach performance monitoring and tuning in Linux, and the various subsystems (and performance metrics) that needs to be monitored.

To identify system bottlenecks and come up with solutions to fix it, you should understand how various components of Linux works. For example, how the kernel gives preference to one Linux process over others using nice values, how I/O interrupts are handled, how the memory management works, how the Linux file system works, how the network layer is implemented in Linux, etc.,

Please note that understanding how various components (or subsystems) works is not the same as knowing what command to execute to get certain output. For example, you might know that “uptime” or “top” command gives the “load average”. But, if you don’t know what it means, and how the CPU (or process) subsystem works, you might not be able to understand it properly. Understanding the subsystems is an on-going task, which you’ll be constantly learning all the time.

On a very high level, following are the four subsystems that needs to be monitored.

• CPU
• Memory
• I/O
• Network

1. CPU

You should understand the four critical performance metrics for CPU — context switch, run queue, cpu utilization, and load average.

Context Switch

• When CPU switches from one process (or thread) to another, it is called as context switch.
• When a process switch happens, kernel stores the current state of the CPU (of a process or thread) in the memory.
• Kernel also retrieves the previously stored state (of a process or thread) from the memory and puts it in the CPU.
• Context switching is very essential for multitasking of the CPU.
• However, a higher level of context switching can cause performance issues.

Run Queue

• Run queue indicates the total number of active processes in the current queue for CPU.
• When CPU is ready to execute a process, it picks it up from the run queue based on the priority of the process.

20 Linux System Monitoring Tools

20 Linux  System Monitoring Tools Every SysAdmin Should Know

Need to monitor Linux server performance? Try these built-in command and a few add-on tools. Most Linux distributions are equipped with tons of monitoring. These tools provide metrics which can be used to get information about system activities. You can use these tools to find the possible causes of a performance problem. The commands discussed below are some of the most basic commands when it comes to system analysis and debugging server issues such as:

1. Finding out bottlenecks.
2. Disk (storage) bottlenecks.
3. CPU and memory bottlenecks.
4. Network bottlenecks.

#1: top - Process Activity Command

The top program provides a dynamic real-time view of a running system i.e. actual process activity. By default, it displays the most CPU-intensive tasks running on the server and updates the list every five seconds.

Commonly Used Hot Keys

The top command provides several useful hot keys:

Hot Key	Usage
t	Displays summary information off and on.
m	Displays memory information off and on.
A	Sorts the display by top consumers of various system resources. Useful for quick identification of performance-hungry tasks on a system.
f	Enters an interactive configuration screen for top. Helpful for setting up top for a specific task.
o	Enables you to interactively select the ordering within top.
r	Issues renice command.
k	Issues kill command.
z	Turn on or off color/mono

#2: vmstat - System Activity, Hardware and System Information

The command vmstat reports information about processes, memory, paging, block IO, traps, and cpu activity.


# vmstat 3
Sample Outputs:

Play Windows games on Linux with Crossover

 

CrossOver Games is an addition to the popular CrossOver series. Unlike other CrossOver products, which are aimed primarily at office productivity applications, CrossOver Games focuses on the stability of installing Windows games on Linux (and Mac OSX). As the same as PlayOnLinux, CrossOver Games provides a click and install method that makes it simple for anyone to use. The latest version of CrossOver Games has already tested to work with more than a hundred Windows games, including the popular World of Warcraft, Half-Life2 and Counterstrike.

Crossing over

When it comes to playing the games, Crossover Games is relatively straightforward to use. And in comparison to getting certain SecuROM titles to work on Windows, it can be considerably easier. But your first step has to be a check for compatibility.

Crossover hosts an online database that lists around 200 games titles that are known to work, and a few that don't. Compatibility is graded by gold, silver and bronze awards, and if your game wins any of these, you should be able to play it through without too much difficulty. Crossover judges compatibility against its own very high standards, and tries to be completely truthful about the faithfulness of a working game.

LILO and boot problems

When a computer starts, the number of beeps the BIOS outputs tells you the state of the computer. On some
computers, one beep means all is ok, but 2 beeps mean there is an error. LILO uses the same kind of codes.
The number of letters you see from the word LILO on the screen says what is wrong. The whole word means
everything is fine, only LI means only the first part of LILO could be loaded. A full description of this is
available from the Bootdisk HOWTO.
When LILO can't load, it's a major problem. This often means that the boot code was corrupted. The only
way to boot is from a floppy disk. In RedHat, you can use the rescue disk, in Slackware, you can use the boot
disk with the "mount" image.
When LILO is fine, it's often easier to figure a boot problem. If the kernel panics when it tries to boot, it is
usualy due to a configuration error. You can tell LILO to mount another kernel you may have, like a "safe" or
"old" image you kept for these cases. If the problem is in initialization scripts, you can tell LILO to boot
directly into a shell with the following boot command line:
LILO boot: linux init=/bin/sh
Where "linux" would be your kernel image

Repair A Corrupt MBR And Boot Into Linux with Fedora CD

There are times when you inadvertently overwrite your Master Boot Record. The end result being that you are unable to boot into Linux. This is especially true when you are dual booting between windows and Linux OSes. Once when I was working in Windows XP, I accidentally clicked the hibernate button instead of shutdown. And windows somehow overwrote my MBR which housed the GRUB boot loader. At such times, it pays to have this cool tip at hand.

This is what you do to restore the GRUB boot loader when faced with the above problem. First you need a Linux distribution CD. If you are using Fedora (RedHat) then the first CD is sufficient. But you may also use any of the live CDs like Knoppix, Ubuntu Live CD and so on.

With Fedora CD :
 

Boot your computer with the first CD of Fedora in your CD drive (You have to enable your PC to boot from the cdrom, which you can set in the BIOS settings). At the installation boot prompt that you get, enter the following command:

boot: linux rescue

... and press Enter. The installer will ask you a few questions like the language you would like to use, the type of keyboard etc. Then, if you have linux previously installed on your machine, the Fedora installer will automatically detect it and mount it in the /mnt/sysimage directory. Once the linux partition is mounted, you are dropped into the command shell prompt. The next step is to make your newly mounted directory the root (or parent) directory. This you do by running the chroot command as follows:

what is Master boot record and LILO ?

Master boot record and LILO

What is the master boot record (MBR) and why does LILO erase the old boot loader? Every hard drive has a
top space called the MBR where the BIOS will try to load an operating system. Every system has its own
loader. DOS has DOS-MBR, Windows NT has the NTLDR and Linux has LILO.
When you install LILO, you can install it in the MBR or in a boot record for the Linux partition. If you want
to keep your current boot loader, you can select the Linux partition, and make sure it is the active partition in
fdisk. This way you will be able to boot to LILO, and then boot the old loader from the MBR.
If you plan on only using Linux on your system, you can tell LILO to boot right into Linux and not display a
"boot:" prompt, and you can install it in the MBR.

Master boot record (MBR) is a type of boot sector popularized by the IBM Personal Computer.It consists of a sequence of 512 bytes located at the first sector of a data storage device such as a hard disk. MBRs are usually placed on storage devices intended for use with IBM PC-compatible systems.

The MBR may be used for one or more of the following:

• Holding a partition table which describes the partitions of a storage device. In this context the boot sector may also be known as a partition sector.
• Bootstrapping an operating system. The BIOS built into a PC-compatible computer loads the MBR from the storage device and passes execution to machine code instructions at the beginning of the MBR.
• Uniquely identifying individual disk media, with a 32-bit disk signature, even though it may never be used by the operating system.

The Linux boot prompt

The Linux system uses a program called LILO to boot itself.
This is the LInux LOader, and will load a kernel
and can pass various parameters. This is what the "boot:" prompt is for.
At the "boot:" prompt, you can enter a lot of parameters. You can send parameters to drivers like the ethernet
driver, telling it at which IRQ the ethernet card is located, or you can pass parameters to the kernel, like
memory size or what to do in a panic. Reading the LILO manual will tell you all of the nice things LILO can
be used for.
Note that for device drivers compiled as modules, you need to pass values when you load these drivers, and
not on the "boot:" prompt.

Installing Linux with no CD-ROM drive or modem

Most Linux distributions come on a CD-ROM. You can also download them from an FTP site, but that
requires an Internet connection. What if you have a system with no CD-ROM drive or Internet connection,
like an old 486 laptop? The trick here is to have another desktop system with a CD-ROM drive, and a
null-modem serial cable.
I will show you how to do it with Slackware. It is also possible with most other Linux distributions. Insert the
Linux CD-ROM in the drive on the desktop and copy the A (base) and N (networking) packages on diskettes.
You need at least those in order to use a serial cable to transfer the rest of the packages.
Now you need to enable NFS networking on the desktop, and allow the laptop to connect. You can give a
temporary IP address to the laptop, like 192.168.1.11 that you need to add to your /etc/exports file on your
desktop.

To link the two systems together, this is what you need to type on the laptop:

/usr/sbin/pppd -detach crtscts lock 192.168.1.11:192.168.1.10 /dev/ttyS1 115200

And this on the PC:

/usr/sbin/pppd -detach crtscts lock 192.168.1.10:192.168.1.11 /dev/ttyS1 115200

This is assuming the cable is linked to ttyS1 (COM2) on both systems.
With NFS, you can mount the CD-ROM drive remotely and tell the installation program to use a specific
path to install the remaining packages.

Mount the CD-ROM with a command like this:

mount -tnfs 192.168.1.10:/cdrom /mnt

Then run the installation program:
setup

and enter the new path for the packages files.

How To Create A linux Boot CD

The kernel in Fedora Core 2 and higher is too big to fit on a floppy disk, so you'll have to create a boot CD instead. Here are the steps.

1. Each installed kernel has a dedicated subdirectory for its modules in the /lib/modules directory. Get a listing of this directory. Here there are two installed kernels; versions 2.6.5-1.358custom and 2.6.8-1.521.

[root@bigboy tmp]# ls /lib/modules/
2.6.5-1.358custom  2.6.8-1.521
[root@bigboy tmp]#

2. Select the desired kernel and use the mkbootdisk command to create a CD ISO image named /tmp/boot.iso of one of the kernels, in this case 2.6.8-1.521:

[root@bigboy tmp]# mkbootdisk --iso --device /tmp/boot.iso \
                     2.6.8-1.521

3. Burn a CD using the image. This creates a boot CD with the specified kernel, named vmlinuz, and a scaled-down version of the grub.conf configuration file named isolinux.cfg, both located in the isolinux subdirectory of the CD. This example mounts the newly created CD-ROM and takes a look at the isolinux.cfg file to confirm that everything is okay.

[root@bigboy tmp]# mount /mnt/cdrom
[root@bigboy tmp]# ls /mnt/cdrom/isolinux/
boot.cat  boot.msg  initrd.img  isolinux.bin  isolinux.cfg   TRANS.TBL  vmlinuz
[root@bigboy tmp]# cat /mnt/cdrom/isolinux/isolinux.cfg
default linux
prompt 1
display boot.msg
timeout 100
label linux
        kernel vmlinuz
        append initrd=initrd.img ro  root=/dev/hda2
[root@bigboy tmp]#

When you reboot your system with the CD, the boot process automatically attempts to access your files in the /root partition and boot normally. The only difference being that the kernel used is on the CD.

Updating The Kernel Using RPMs

It is also possible to install a new standardized kernel from an RPM file. As you can see, it is much simpler than creating a customized one.

To create an additional kernel using RPMs, use the command

[root@bigboy tmp]# rpm -ivh kernel-file.rpm

To replace an existing kernel using RPMs, you need only one line

[root@bigboy tmp]# rpm -Uvh kernel-file.rpm

Conclusion

Building a customized Linux kernel is probably something that most systems administrators won't do themselves. The risk of having a kernel that may fail in some unpredictable way is higher when you modify it, and, therefore, many system administrators hire experts to do the work for them. After reading this chapter, at least you will have an idea of what is going on when the expert arrives, which can help considerably when things don't go according to plan.

Modifying the Linux Kernel to Improve Performance

*/

Introduction

Like a government that rules a nation and all its provinces, the Linux kernel is the central program that not only governs how programs interact with one another, but also provides the guidelines on how they should use the computer's core infrastructure, such as memory, disks, and other input/output (I/O) devices for the user's benefit.

Linux drivers, the programs that manage each I/O device, are the staff that keeps all the government departments running. Continuing with the analogy, the more departments you make the kernel manage, the slower Linux becomes. Large kernels also reduce the amount of memory left over for user applications. These may then be forced to juggle their memory needs between RAM and the much slower swap partitions of disk drives, causing the whole system to become sluggish.

The Fedora installation CDs have a variety of kernel RPMs, and the installation process autodetects the one best suited to your needs. For this reason, the Fedora Linux kernel installed on your system is probably sufficient. The installation process chooses one of several prebuilt kernel types depending on the type of CPU and configuration you intend to use (Table 33-1).

 Kernels Found On Fedora Installation CDs

Processor Type	Configuration
i586	Single processor
i586	Multiprocessor (SMP)
i686	Single processor
i686	Multiprocessor (SMP)

The Pros And Cons Of Kernel Upgrades

Despite this best fit installation, you may want to rebuild the kernel at times. For example, there is no installation RPM for multiprocessor systems with large amounts of memory. You may also want to experiment in making a high-speed Linux router without support for SCSI, USB, Bluetooth, and sound but with support for a few NIC drivers, an IDE hard drive, and a basic VGA console. This would require a kernel rebuild.

Rebuilding the kernel in a small business environment is usually unnecessary. If your system starts to slow down and you can't afford to replace hardware or are unable to add more RAM, however, you may want to tune the kernel by making it support only necessary functions or updating built-in parameters to make it perform better. Sometimes new features within the new kernel are highly desirable; for example, the version 2.6 kernel has much more efficient data handling capabilities than the older version 2.4, providing new life for old hardware.

Kernel tuning on a production server shouldn't be taken lightly, because the wrong parameters could cause your system to fail to boot, software to malfunction, or hardware peripherals to become unavailable. Always practice on a test system and keep a backup copy of your old kernel. Whenever possible, hire a consultant with kernel experience to help, and use this chapter and other references as a guide to prepare you for what to expect.

This chapter provides only an overview of the steps to take. It won't make you an expert, but it will expose you to the general process and provide greater confidence when you need to research the task with a specialized guide.

The Kernel Sources Package

You will need to install the kernel source code on your system prior to modifying your kernel. As of Fedora Core 3, the kernel sources come as a source RPM package that matches the version of the kernel you are running. In Fedora Core 2 and earlier, the Kernel sources came as a generic RPM package called kernel-source, the installation of which is covered in Appendix III, "Fedora Version Differences".

The newer method is more complicated as it requires a number of post installation steps. Though the process is well documented in the release notes section of the Fedora website (http://fedora.redhat.com/docs/release-notes/) there are some clarifications that are needed. These are explained in the following section.

Installing Kernel Sources

The installation process for the kernel sources is long, but not very complicated. Here is how it's done:

1. Determine the version of your kernel with the uname command. In this case it is version 2.6.14-1.1644.

[root@bigboy tmp]# uname -r
2.6.14-1.1644_FC4smp
[root@bigboy tmp]#

2. Visit your favorite Fedora operating system download mirror and get the corresponding source RPM package. If you are running the original version of the kernel that came with your installation discs, then the sources will be located in the /core/<version>/i386/os/SRPMS/ directory. If the kernel has been updated using yum or some other method, the sources will be located in the /core/updates/<version>/SRPMS/ directory. In this example the sources of an updated Core 4 kernel is downloaded from the /core/updates/4/SRPMS/ directory of http://download.fedora.redhat.com using wget.

[root@bigboy tmp]# wget
http://download.fedora.redhat.com/pub/fedora/linux/core/updates/4/SRPMS/kernel-2.6.14-1.1644_FC4.src.rpm
--15:32:22-- 
http://download.fedora.redhat.com/pub/fedora/linux/core/updates/4/SRPMS/kernel-2.6.14-1.1644_FC4.src.rpm
           => `kernel-2.6.14-1.1644_FC4.src.rpm'
Resolving download.fedora.redhat.com... 66.187.224.20,
209.132.176.20, 209.132.176.220, ...
Connecting to
download.fedora.redhat.com|66.187.224.20|:80...
connected.
HTTP request sent, awaiting response... 200 OK
Length: 40,454,218 (39M) [application/x-rpm]

100%[=========================>] 40,454,218   862.89K/s    ETA 00:00

15:33:10 (842.22 KB/s) -
`kernel-2.6.14-1.1644_FC4.src.rpm' saved
[40454218/40454218]

[root@bigboy tmp]#

3. Install the contents of the RPM file into the /usr/src/redhat/SOURCES and /usr/src/redhat/SPECS directories using the rpm command.

[root@bigboy tmp]# rpm -Uvh kernel-2.6.14-1.1644_FC4.src.rpm 
   1:kernel                 ########################################### [100%]
[root@bigboy tmp]#

4. The kernel source directory tree will have to be created next. Enter the /usr/src/redhat/SPECS directory and create the tree using the rpmbuild command with the -bp option.

[root@bigboy tmp]# cd /usr/src/redhat/SPECS
[root@bigboy SPECS]# ls
kernel-2.6.spec
[root@bigboy SPECS]# rpmbuild -bp --target $(arch) kernel-2.6.spec
Building target platforms: i686
Building for target i686
Executing(%prep): /bin/sh -e /var/tmp/rpm-tmp.44004
+ umask 022
+ cd /usr/src/redhat/BUILD
...
...
...
removed `./init/Kconfig.orig'
removed `./init/main.c.orig'
+ find . -name '*~' -exec rm -fv '{}' ';'
+ exit 0
[root@bigboy SPECS]#

5. The tree has now been created in the /usr/src/redhat/BUILD/kernel-<version> directory. You can link, move or copy this directory to become /usr/src/linux depending on your needs and the likelihood of you compiling multiple kernel versions in future. In this case, the tree is moved and then linked.

[root@bigboy SPECS]# cd /usr/src/redhat/BUILD/kernel-2.6.14/
[root@bigboy kernel-2.6.14]# ls
linux-2.6.14  vanilla
[root@bigboy kernel-2.6.14]# mv linux-2.6.14 /usr/src/
[root@bigboy kernel-2.6.14]# cd /usr/src
[root@bigboy src]# ln -s ./linux-2.6.14 linux
[root@bigboy src]# ls
kernels  linux  linux-2.6.14  redhat
[root@bigboy src]#

6. The configuration files for specific kernels shipped in Fedora Core will be located in the configs/ directory. In this case the uname -a command is used to determine the systems CPU type (686) and the kernel type (SMP, Symmetrical Multi Processor), and the relevant configuration file is then copied to become the new /usr/src/linux/.config file to be used during the kernel compilation.

[root@bigboy src]# cd /usr/src/linux
[root@bigboy linux]# uname -a
Linux bigboy.my-web-site.org 2.6.14-1.1644_FC4smp #1 SMP
Sun Nov 27 03:39:31 EST 2005 i686 i686 i386 GNU/Linux
[root@bigboy linux]# cp configs/kernel-2.6.14-i686-smp.config .config
cp: overwrite `.config'? y
[root@bigboy linux]#

7. You can also automatically copy the correct file from the /usr/src/linux/configs/ directory to /usr/src/linux/.config using the make oldconfig command.

[root@bigboy linux]# cd /usr/src/linux
[root@bigboy linux]# make oldconfig

You should now be ready to compile a customized kernel at your leisure, but first I'll discuss Kernel modules.

Kernel Modules

Over the years the Linux kernel has evolved, in the past device drivers were included as part of this core program, whereas now they are loaded on demand as modules.

Reasons For Kernel Modules

There are a number of advantages to this new architecture:

• Updates to a driver, such as a USB controller module, don't require a complete recompilation of the kernel; just the module itself needs recompiling. This reduces the likelihood of errors and ensures that the good, working base kernel remains unchanged.
• An error in a device driver is less likely to cause a fault that prevents your system from booting. A faulty device driver can be prevented from loading at boot time by commenting out its entry in the /etc/modprobe.conf file, or by using the rmmod command after boot time. In the past, the kernel would have to be recompiled.
• Updates to a driver don't require a reboot either, just the unloading of the old and reloading of the new module.
• You can add new devices to your system without requiring a new kernel, only the new module driver is needed. This adds a great deal of flexibility without a lot of systems administrator overhead.

There are some drivers that will always need to be compiled into the kernel to make sure your system boots correctly. For example, routines for basic system functions used in reading and writing files, are an indispensable integrated part of any kernel.

Loadable kernel modules now include device drivers to manage various types of filesystems, network cards, and terminal devices to name a few. As they work so closely with the kernel, the modules need to be compiled specifically for the kernel they are intended to support. The kernel always looks for modules for its version number in the /lib/modules/<kernel version> directory and permanently loads them into RAM memory for faster access. Some critical modules are loaded automatically, others need to be specified in the /etc/modprobe.conf file.

The kernel recompilation process provides you with the option of compiling only the loadable modules. I won't specifically cover this, but simultaneous recompilation of all modules will be covered as part of the overall recompilation of your kernel.

How Kernel Modules Load When Booting

One question that must come to mind is "How does the kernel boot if the disk controller modules reside on a filesystem that isn't mounted yet?"

As stated in Chapter 7, "The Linux Boot Process", the GRUB boot loader resides on its own dedicated partition and uses the /boot/grub/grub.conf file to determine the valid kernels and their locations. The grub.conf file not only defines the available kernels, but also the location of the root partition and an associated ramdisk image that is automatically loaded into memory and that contains just enough modules to get the root filesystem mounted.

Note: In Fedora Linux, the /boot/grub/grub.conf file can also be referenced via the symbolic link file named /etc/grub.conf.

Modules And The grub.conf File

In this example of the /boot/grub/grub.conf file, the kernel in the /boot directory is named vmlinuz-2.6.8-1.521, its RAM disk image file is named initrd-2.6.8-1.521.img, and the root partition is (hd0,0).

#
# File: /boot/grub/grub.conf
#
default=0
timeout=10
splashimage=(hd0,0)/grub/splash.xpm.gz
title Fedora Core (2.6.8-1.521)
        root (hd0,0)
        kernel /vmlinuz-2.6.8-1.521 ro root=LABEL=/
        initrd /initrd-2.6.8-1.521.img
 

The .img file is created as part of the kernel compilation process, but can also be created on demand with the mkinitrd command.

The (hd0,0).disk definition may seem strange, but there is a file that maps the GRUB device nomenclature to that expected by Linux in the /boot/grub/device.map file.

#
# File: /boot/grub/device.map
#
(fd0)     /dev/fd0
(hd0)     /dev/hda

During the next phase of the boot process, the loaded kernel executes the init program located on the RAM disk, which mounts the root filesystem and loads the remaining modules defined in the /etc/modprobe.conf file before continuing with the rest of the startup process.

Loading Kernel Modules On Demand

It is possible to load add-on modules located under the /lib/modules/<kernel version> directory with the modprobe command. For example, the iptables firewall application installs kernel modules that it uses to execute NAT and pass FTP traffic. In this example: these modules are loaded with the modprobe command with the aid of the /etc/rc.local script.

#
# File: /etc/rc.local
#
# Load iptables FTP module when required
modprobe ip_conntrack_ftp

# Load iptables NAT module when required
modprobe iptable_nat

Kernel module drivers that are referenced by the operating system by their device aliases are placed in the /etc/modprobe.conf file and are loaded automatically at boot time. In the example, you can see that devices eth1 and eth0 use the natsemi and orinoco_pci drivers respectively.

#
# /etc/modprobe.conf
#
alias eth1 natsemi
alias eth0 orinoco_pci

Linux has a number of commands to help you with modules. The lsmod command lists all the ones loaded. In the example, you can see that iptables, NFS, and the Orinoco drivers are all kernel modules. You can use the modprobe command to load and unload modules or use the insmod and rmmod commands. See the man pages for details.

[root@bigboy tmp]# lsmod
Module                  Size  Used by
...
...
iptable_filter          2048  0
ip_tables              13440  1 iptable_filter
...
...
exportfs                4224  1 nfsd
nfs                   142912  0
lockd                  47944  3 nfsd,nfs
autofs4                10624  1
sunrpc                101064  20 nfsd,nfs,lockd
...
...
natsemi                18016  0
orinoco_pci             4876  0
orinoco                31500  1 orinoco_pci
hermes                  6528  2 orinoco_pci,orinoco
...
...
[root@bigboy tmp]#

Finally, when in doubt about a device driver, try using the lspci command to take a look at the devices that use your PCI expansion bus. Here you can see that the natsemi module listed in the lsmod command has a high probability of belonging to the 01:08.0 Ethernet controller: device made by National Semiconductor.

[root@bigboy tmp]# lspci
...
...
01:07.0 Network controller: Intersil Corporation Prism 2.5 Wavelan chipset (rev 01)
01:08.0 Ethernet controller: National Semiconductor Corporation DP83815 (MacPhyter) Ethernet Controller
01:0c.0 Ethernet controller: 3Com Corporation 3c905C-TX/TX-M [Tornado] (rev 78)
[root@bigboy tmp]#

Creating A Custom Kernel

The installation of the kernel sources creates a file called README in the /usr/src/linux directory that briefly outlines the steps needed to create a new kernel. Take a look at a more detailed explanation of the required steps.

Make Sure Your Source Files Are In Order

Cleaning up the various source files is the first step. This isn't so important for a first time rebuild, but it is vital for subsequent attempts. You use the make mrproper command to do this; it must be executed in the Linux kernel version's subdirectory located under /usr/src. In this case, the subdirectory's name is /usr/src/linux-2.6.5-1.358.

[root@bigboy tmp]# cd /usr/src/linux
[root@bigboy linux]# make mrproper
...
...
...
[root@bigboy linux]#

The ".config" File

You next need to run scripts to create a kernel configuration file called /usr/src/linux/.config. This file lists all the kernel options you wish to use.

Backup Your Configuration

The .config file won't exist if you've never created a custom kernel on your system before, but fortunately, RedHat stores a number of default .config files in the /usr/src/linux/configs directory. You can automatically copy the .config file that matches your installed kernel by running the make oldconfig command in the /usr/src/linux directory.

[root@bigboy tmp]# cd /usr/src/linux
[root@bigboy linux]# ls .config
ls: .config: No such file or directory
[root@bigboy linux]# make oldconfig
...
...
...
[root@bigboy linux]#

If you've created a custom kernel before, the .config file that the previous custom kernel build used will already exist. Copy it to a safe location before proceeding.

Customizing The ".config" File

Table 33-2 lists three commands that you can run in the /usr/src/linux directory to update the .config file.

Table 33-2 Scripts For Modifying The .config File

Command	Description
make config	Text based utility that prompts you line by line. This method can become laborious.
make menuconfig	Text menu based utility.
make gconfig	X-Windows GUI based utility.

 Kernel Option Choices

Kernel Option Choice	Description
M	The kernel will load the drivers for this option on an as needed basis. Only the code required to load the driver on demand will be included in the kernel.
Y	Include all the code for the drivers needed for this option into the kernel itself. This will generally make the kernel larger and slower but will make it more self sufficient. The "Y" option is frequently used in cases in which a stripped down kernel is one of the only programs Linux will run, such as purpose built home firewall appliances you can buy in a store. There is a limit to the overall size of a kernel. It will fail to compile if you select parameters that will make it too big.
N	Don't make the kernel support this option at all.

 Kernel Configuration Options

Option	Description
Code maturity level options	Determines whether Linux prompts you for certain types of development code or drivers.
Loadable module support	Support for loadable modules versus a monolithic kernel. Most of the remaining kernel options use loadable modules by default. It is best to leave this alone in most cases.
Processor type and features	SMP, Large memory, BIOS and CPU type settings.
General setup	Support for power management, networking, and systems buses such as PCI, PCMCIA, EISA, ISA
Memory technology devices	Linux subsystem for memory devices, especially Flash devices
Parallel port support	Self explanatory
Plug and Play configuration	Support of the automatic new hardware detection method called plug and play
Block devices	Support for a number of parallel-port-based and ATAPI type devices. Support for your loopback interface and RAM disks can be found here too.
Multidevice support (RAID, LVM)	Support for RAID, 0, 1, and 5, as well as LVM.
Cryptography support (CryptoAPI)	Support for various types of encryption
Networking options	TCP/IP, DECnet, Appletalk, IPX, ATM/LANE
Telephony support	Support for voice to data I/O cards
ATA/IDE/MFM/RLL support	Support for a variety of disk controller chipsets
SCSI support	Support for a variety of disk controller chipsets. Also sets limits on the maximum number of supported SCSI disks and CDROMs.
Fusion MPT support	High speed SCSI chipset support.
I2O device support	Support for specialized Intelligent I/O cards
Network device support	Support for Ethernet, Fibre Channel, FDDI, SLIP, PPP, ARCnet, Token Ring, ATM, PCMCIA networking, and specialized WAN cards.
Amateur Radio support	Support for packet radio
IrDA subsystem support	Infrared wireless network support
ISDN subsystem	Support for ISDN
Old CD-ROM drivers (not SCSI, not IDE)	Support for non-SCSI, non-IDE, non ATAPI CDROMs
Input core support	Keyboard, mouse, and joystick support in addition to the default VGA resolution.
Character devices	Support for virtual terminals and various serial cards for modems, joysticks and basic parallel port printing.
Multimedia devices	Streaming video and radio I/O card support
Crypto Hardware support	Web-based SSL hardware accelerator card support
Console drivers	Support for various console video cards
Filesystems	Support for all the various filesystems and strangely, the native languages supported by Linux.
Sound	Support for a variety of sound cards
USB support	Support for a variety of USB devices
Additional device driver support	Miscellaneous driver support
Bluetooth support	Support for a variety of Bluetooth devices
Kernel hacking	Support for detailed error messages for persons writing device drivers

Configure Dependencies

As I mentioned before, the .config file you just created lists the options you'll need in your kernel. In version 2.4 of the kernel and older, the make dep command was needed at this step to prepare the needed source files for compiling. This step has been eliminated as of version 2.6 of the kernel.

Edit The Makefile To Give The Kernel A Unique Name

Edit the file Makefile and change the line "EXTRAVERSION =" to create a unique suffix at the end of the default name of the kernel.

For example, if your current kernel version is 2.6.5-1.358, and your EXTRAVERSION is set to -6-new, your new additional kernel will have the name vmlinuz-2.6.5-6-new.

Remember to change this for each new version of the kernel you create.

Compile A New Kernel

You can now use the make command to create a compressed version of your new kernel and its companion .img RAM disk file. This could take several hours on a 386 or 486 system. It will take about 20 minutes on a 400MHz Celeron.

[root@bigboy linux-2.6.5-1.358]# make 
...
...
...
[root@bigboy linux-2.6.5-1.358]#

Note: In older versions of Fedora the command to do this would have been make bzImage.

Build The Kernel's Modules

You can now use the make modules_install command to copy all the modules created in the previous step to the conventional module locations.

[root@bigboy linux]# make modules_install
...
...
...
[root@bigboy linux]#

Note: In versions of Fedora before Core 3, this was a two step process. The make modules command would compile the modules, but locate them within the Linux kernel source directory tree under the directory /usr/src/. The make modules_install command would then relocates them to where they should finally reside under the /lib/modules/<kernel version> directory.

Copy The New Kernel To The /boot Partition

The kernel and the .img you just created needs to be copied to the /boot partition where all your systems active kernel files normally reside. This is done with the make install command.

This partition has a default size of 100MB, which is enough to hold a number of kernels. You may have to delete some older kernels to create enough space.

[root@bigboy linux]# make install
...
...
...
[root@bigboy linux]#

Here you can see that the new kernel vmlinuz-2.6.5-1.358-new is installed in the /boot directory.

[root@bigboy linux]# ls -l /boot/vmlinuz*
lrwxrwxrwx 1 root root       22 Nov 28 01:20 /boot/vmlinuz -> vmlinuz-2.6.5-1.358-new
-rw-r--r-- 1 root root  1122363 Feb 27  2003 /boot/vmlinuz-2.6.5-1.358
-rw-r--r-- 1 root root  1122291 Nov 28 01:20 /boot/vmlinuz-2.6.5-1.358-new
[root@bigboy linux]#

Updating GRUB

You should now update your /etc/grub.conf file to include an option to boot the new kernel. The make install command does this for you automatically.

In this example, default is set to 1, which means the system boots the second kernel entry, which happens to be that of the original kernel 2.6.5-1.358. You can set this value to 0, which makes it boot your newly compiled kernel (the first entry).

default=1
timeout=10
splashimage=(hd0,0)/grub/splash.xpm.gz
title Red Hat Linux (2.6.5-1.358-new)
        root (hd0,0)
        kernel /vmlinuz-2.6.5-1.358-new ro root=LABEL=/
        initrd /initrd-2.6.5-1.358-new.img
title Red Hat Linux (2.6.5-1.358)
        root (hd0,0)
        kernel /vmlinuz-2.6.5-1.358 ro root=LABEL=/
        initrd /initrd-2.6.5-1.358.img

Kernel Crash Recovery

Sometimes the new default kernel will fail to boot or work correctly with the new kernel. A simple way of recovering from this is to reboot your system, selecting the old version of the kernel from the Fedora splash screen. Once the system has booted with this stable version, edit the grub.conf file and set the default parameter to point to the older version instead. If this fails, you may want to boot from a CD with the original kernel. You can then try to either reinstall a good kernel RPM or rebuild the failed one over again after fixing the configuration problem that caused the trouble in the first place.

*//