Doubt in Booting Sequence.
 

Hello friends,
I am a new member to this group and new to Linux also...
Just starting to digest the concepts and i got stuck .......The Problem ...............BOOT SEQUENCE!!!!!!!!

Let me first tell you in short what i understood.. so that u may point out if there's anything wrong in it.

First the computer initiates post and after that the bios passes control to the very first sector of the hard disk. This area on the hard disk also known as the MBR contains the IPL(Initial Program Loader). Passing control to the IPL by the BIOS is the first Stage. The IPL then loads the grub.conf file to the memory. This grub.conf file resides in /boot/grub/grub.conf .

QUESTION 1: If the IPL cannot understand the filesystem how can it understand /boot.....? It shouldn't unless the filesystem is loaded.

Then the grub.conf file loads in memory.
Then grub decides the location of a splash image(hd0,0-which means first partition in first harddrive) and loads it along with the menu
. The Menu helps us to choose the OS or Kernel or whatever. Here again there is a line of code ---- root(hd0,0).

QUESTION 2: What is the use of the line root(hd0,0)?

I couldn't understand what happens after that. I just know that the kernel and the initrd loads into memory and the init process takes over. I understood what happens after init process takes over.

So Can anyone please explain the process which takes place after the line stating root and before initrd?????

Grub can't read a filing system

If Grub cannot read a filing system, like NTFS, then Grub boots that system by chainloading. In chainloading Grub boots up the boot loader of another operating system. It does so at the "+1" position of the 2nd sector of the partition. Booting with a sector is done at a hardware level.

Grub can use chainloading to boot an operating system that

(1) has a filing system Grub cannot understand (like Win2k, Xp, Vista, BSD)

or

(2) has no kernel inside (like a Dos)


What most Linux users do not realise is chainloading can be used equally well on fellow Linux and is good enough to boot any operating system that has been invented on a PC.

What is root (hd0,0)?

MS systems, Solaris and the majority of BSD systems has a MBR that boots any of the 4 primary partitions as long as it has the booting flag switched on. A booting flag is the first byte in the 16-byte partition table of a primary partition. When it is marked "bootable" in Linux it is the same or interpreted as "active" in a MS system.

Fundamentally the MBR of a MS Dos/Windows does not know which primary partition it will boot and cannot boot a system residing in logical partition. Thus a user can put Grub in a data-only primary partition, instructs a Vista or XP to make the data-only partition active and get a MS system to boot up Grub.

Linux boot loaders Grub and Lilo broke this rule by "declaring" which partition to be booted up front.

Grub does this by the command "root" and Lilo does this by command "other=" or "root=". Thus that explains why Linux can be booted even from a logical partition. Grub calls a disk and partition by number and counts from 0.

1st disk is (hd0) and its 1st partition is (hd0,0).

Grub and Lilo never use the booting flag.

A little bit about the kernel and initrd statements

Grub has stage1 and stage2. (there is a stage1.5 too but that can be regarded as a special case). The stage1 is 512 byte long to fit in with any MBR. The stage1's duty is to load stage2 which is the intelligence of Grub.

Grub operates flawless with just stage1 and stage2.

When the stage2 is loaded Grub will try to find menu.lst (symbolic-linked with grub.conf) in either /grub or /boot/grub directory specified in the root directory. If none is found Grub defaults to a Grub prompt. If one is loaded then the user is left to pick a system from the choices displayable in menu.lst.

When a Linux is asked to be booted the "kernel" statement instructs Grub the location of the kernel and the manner it is to be loaded. The "initrd" does the same for the ramdisk file. If the kernel and the ramdisk files are loadable then Grub finishes its tasks and will disappear from the scene.

Thereafter it is the Linux kernel's job to load the Linux.

Thanks for ur answers friends,, but i still have some confusions.
I have a red hat distribution and the grub.conf has the following lines...

root (hd0,0)
kernel /vmlinuz-2.6.18-8.1.1.el5 ro root=LABEL=/ rhgb quiet
initrd /initrd-2.6.18-8.1.1.el5.img

As far as i have understood the first line root(hd0,0) says that the kernel is in the first partition of the first drive..So it is being loaded into memory.
The next line loads the kernel which is in (hd0,0)/vmlinuz, but i could not understand what is the purpose of
ro root=LABEL=/ in the same line

This is a typical Red Hat Linux booting instruction.

The information inside the "kernel" statement is always in Linux and not in Grub notation because by such time the kernel would have take over. The kernel and the root filing system ("/") are stored in separate location in a Red Hat Linux. The latter can be in an ordinary partition like /dev/sda3 or in a LVM partition. It is Red Hat tradition to identify this partition by a label.

Red Hat typical stores the /boot separately so that the rest can be all inside a LVM. The former is the address of required by the "root" statement in Grub while the latter is the address for the root filing system. If a Red Hat Linux has multi partitions then the root is always referred to the partition holding "/".

There is nothing to stop /boot as a subdirectory of / and a Red Hat can run happily in a single partition. Thus my Red Hat family distros typically boot by

There are several method the "root=" can be pointed to. Among them are

(1) by-path
(2) by-label
(3) by-id
(4) by-uuid

I have no by-label in my Ubuntu box and the above information is all contained in the /dev directory
You can see the same /dev/hda5 can be called different names in different methods, all applicable in Linux. Ubuntu starts using by-uuid method and OpenSuse homes in the by-id method. Red Hat always sticks with the by-label method.