HD consists of logical partitions.  IDE has two types of partitions.
Primary and Extended.  At most IDE has 4 primary partitions.  If more
 partitions are needed then convert one to Extended partition and make 
logical partitions in it.
DOS Fdisk and Unix fdisk are similar but not same programs.
DOS Fdisk will show these partitions and extended partitions with less 
details than Unix version.

Partitions need to be assigned a file system type which can be 
understood by its user os.  OS has File System Driver.

On PC bios looks for boot devices a:, cdrom and hard disk.  When booting from
a: you dont need os loader but for hard disk os loader is needed like lilo
or grub.

make boot disk (dd if=/boot/vmlinuz of=/dev/floppy).  It does not have filesystem so cannot do ls /dev/floppy.  Its raw binary data on floppy sectors.
Each partitions is associated with fs type.  When formatted its the fs 
type being assigned and created.

HDD has MBR where Bios partition table (one reported by fdisk) and os 
selector (like lilo which reads partition table to know active partition 
and then lilo.conf info that was pushed to mbr as to what are various os 
to boot and presents us menu.  for linux selection is knows to read the 
vmlinuz image from the partition at /boot/vmlinuz as mentioned in lilo.conf.
  for non-linux it will execute os loader on boot block of that os 
partitions.  lilo also reads initrd which is ram disk having few drivers
 like scsi and filesystem drivers for say ext3.once both image and initrd
 are read lilo hands over control to kernel) are placed.
Each Partition has Boot Blook (ntloader or os specific loader) where os 
loader might be placed if its an os partition.  
After boot block is Super Block.  It keep information of its partition 
and inodes.  
SuperBlock is followed by inodes (table or list).  Inodes map to file on
 filesystem.

Bios boots and look at MBR (sector 0 on primary master).  Then runs os
 selector to choose osloader.
osloader loads os and uses inode table.

dumpe2fs /dev/hda1 could be used to see superblock and block groups 
contents for partition.
Making fs is to make inodes, data blocks and journal.  It is equivalent 
of format in DOS.

unix names hdd as hdX where X=a (primary), b (slave), c (secondary maste r),
 d (secondary slave)
hdXN where N=1,2,3,4 for partitions on that drive.

To convert an ext2 file system to ext3, log in as root and type:

/sbin/tune2fs -j /dev/hdbX
ext2 -> ext3
---------------
In the above command, replace /dev/hdb with the device name and X with 
the partition number.

After doing this, be certain to change the partition type from ext2 to 
ext3 in /etc/fstab.

If you are transitioning your root file system, you will have to use an 
initrd image (or RAM disk) to boot.  To create this, run the mkinitrd 
program. For information on using the mkinitrd command, type man mkinitrd.
 Also make sure your GRUB or LILO configuration loads the initrd.

If you fail to make this change, the system will still boot, but the 
file system will be mounted as ext2 instead of ext3.

The process of converting from ext3 to ext2 is also relatively simple.  
Refer to The Official Red Hat Linux Customization Guide for further 
information.

LVM (logical volume manager) is alternate way to have hdd managed for 
file system.  
It works with volumes.  
Physical HDD is divided into physical volumes.  One HDD can have many PV
 but one PV cannot span more HDD.  Say we have hda and we create pv1, pv 2, 
pv3, pv4 equal sizes.  With pv one creates logical volume groups (lvg). 
 so lvg1=pv1,pv2 and lets keep pv2, pv4 unused.  Now from lvg1 one will
 create logical volumes (lv1, lv2, lv2..) and assign them to file 
system structures like /=lv1, /usr=lv2 etc.  only /boot is going to be 
partition by itself since bios does not understand logical volumes.  
Thus we get flexibility that if lv1 is filled up then add pv3 to lvg1 
and allocate it to lv1.  This makes size changes easier.


So understanding that bios looks up lilo and it looks up kernel and initrd.  
Yet there is no process or filesystem concept.  When kernel takes over
its extracts file system drivers from initrd and now mounts as root partition
the one from lilo.conf.  so we have file system now.  It then 
starts process swapper (0) and init (1).  init then looks into inittab and
does its work.