I m a novice of linux. I encounter a problem while installing our own kernal in the linux.
If we want to install our own kernal 2.6 in red hat linux 9.0, then, what is the way of executing (booting) the kernal???
I mean what is the command of executing kernal in "make menuconfig"? I mean:
Kernal has to configure through the command make menuconfig. After configuraion we execute these commands:

make modules // for modules compilation
make modules_install // for modules instslation
make bzImage // for kernal Compilation
make install // for kernal instalation
reboot

When system reboots, then kernal is not booted. The msg shown on screen is "try init passing".
I want to ask that what is the command in the make menuconfig that has to set for the booting of kernal.

once the kernel has been compiled with make bzImage you must copy the newly created kernel to /boot.
If make install already does this, then you need to edit your bootloaders configuration file. That should be either /etc/lilo.conf or /boot/grub/grub.conf. If you are using LILO, once your doned editting the config file, you must run the command lilo from the command line to rewrite the new config to the MBR.

For what I know, there's no part of the kernel that makes itself boot. Perhaps only in the earlier versions of the kernel where it was more focused to i386. Only the bootloader like lilo or grub does this. At boot, the BIOS loads the boot loader from one of the first sectors of the disc, then transfer conrol to it. The the boot loader then loads the kernel image specified (e.g. /boot/bzImage to the memory then transfers control to the kernel. And so boot process continues until it reaches the prompt.

In red had 9 you would create an initrd image;
http://www.openaddict.com/documents/...hy/initrd.html
Most don't use an initrd now, just compile support directly into the kernel;
http://www.linuxquestions.org/questi...d.php?t=457689
not sure if that is what you are talking about but if you are trying to boot your kernel without an initrd you will need to know your hardware.
To create an initrd for your kernel;
ftp://slackware.mirrors.pair.com/sla.../README.initrd

Red Hat 9 support has mostly ended by now, with no new bug reports accepted after tomorrow and no bug fixes after Dec 31 this year.

You really ought to move on to Fedora Core 5 or some other distro rather than trying to continue working with RH9.

Other than that advice, I'd also recommend reading the documentation that comes with the kernel, it tells you how to make and install it properly. It's much easier than your steps suggest (for example running "make" will make the modules and bzImage, no need to do them separately now).

cd /path/to/sources
make xconfig(or menuconfig)
save your config
make
make modules_install install
then do /sbin/lilo
reboot

Actually currently "make install" runs /sbin/lilo. The catch is you still have to copy arch/i386/boot/bzImage to the /boot directory, and whichever name you give it has to be recognized in /etc/lilo.conf before executing "make install".

Again, read the documentation that comes with the downloaded kernel rather than follow any possibly outdated instructions you read anywhere else.

Maybe it'll help you understand things if we review just how the kernel gets made... and, how it gets to be where it is.

"The kernel" is, in one sense, "just an ordinary program," except that it runs in privileged mode, gets loaded when the computer boots up, and stays (more or less) in memory all the time. That, of course, makes it rather special . . .

The first thing that's special about the kernel is how it winds up in memory in the first place. It's loaded by a special program called a "boot loader," and there are two of these: Grub and LILO. Both of these programs know how to get loaded into the computer's memory when you first boot it. Programmatically speaking, they are very complex. But their job is quite simple. Their job is to... select and load the kernel, then jump to it and be forgotten.

When you "make" the kernel, you actually build a kernel image, which is a special disk file that Grub or LILO knows how to find and load into memory when you restart the computer.

The process of "making the kernel [image]" consists of, first, selecting various configuration-options ("make menuconfig") that are needed, then building the actual kernel image based on those options. These options control the compilation process that determines what your kernel-image contains and what it does not. The last step of the kernel-building process will create the files that are needed by Grub or LILO.

Here's a tip... once you understand what in the heck is happening, "it's simple." Until you do, it's butt-confusing. So, "get the big picture first." Ignore the details and try to glom onto the big picture.