next up previous contents index
Next: The X Window System Up: Configuration Previous: YaST in Text Mode   Contents   Index


Booting and Boot Managers

This chapter introduces various methods for booting your installed system. First, some of the technical details of the boot process are explained to help understanding the various methods. This is followed by a detailed description of GRUB (the current boot manager of SuSE Linux) and its predecessor LILO.

Booting a PC

After turning on your computer, the first thing that happens is that the BIOS (Basic Input Output System) takes control, initializes the screen and keyboard, and tests the main memory. At this point, no storage media or external devices are known to the system.

After that, the system reads the current date and time as well as information about the most important peripheral devices from the CMOS setup. After reading the CMOS, the BIOS should recognize the first hard disk, including details such as its geometry. It can then start to load the operating system (OS) from there.

To load the OS, the system loads a 512-byte data segment from the first hard disk into main memory and executes the code stored at the beginning of this segment. The instructions contained in it determine the rest of the boot process. This is why the first 512 bytes of the hard disk are often called the Master Boot Record (MBR).

Up to this point (loading the MBR), the boot sequence is independent of the installed operating system and is identical on all PCs. Also, all the PC has to access peripheral hardware are those routines (drivers) stored in the BIOS.

Master Boot Record

The layout of the MBR always follows a standard independent of the operating system. The first 446 bytes are reserved for program code. The next 64 bytes offer space for a partition table for up to four partitions (see Section 1). Without the partition table, no file systems exist on the hard disk -- the disk would be virtually useless without it. The last two bytes must contain a special ``magic number'' (AA55). An MBR containing a different number would be considered as invalid by the BIOS and by any PC operating system.

Boot Sectors

Boot sectors are the first sectors on a hard disk partition, except in the case of extended partitions which are just ``containers'' for other partitions. Boot sectors offer 512 bytes of space and are designed to contain code capable of launching an operating system on this partition. Boot sectors of formatted DOS, Windows, and OS/2 partitions do exactly that (and in addition, they contain some basic data about the file system structure). In contrast, the boot sector of a Linux partition is empty (even after creating a file system on it). Thus, a Linux partition can not bootstrap itself, even if it contains a kernel and a valid root file system.

A boot sector with a valid start code contains the same ``magic number'' as the MBR in its last two bytes (AA55).

Booting DOS or Windows 95/98

The DOS MBR of the first hard disk contains information that determines which partition of a hard disk is ``active'' -- which partition should be searched for the operating system to boot. Therefore, DOS must be installed on the first hard disk. The executable code in the MBR (``first stage boot loader'') tests whether the marked partition contains a valid boot sector.

If this is the case, the ``second stage boot loader'' can be started from there. DOS system programs can now be loaded and you will see the usual DOS prompt. In DOS, only primary partitions can be marked active. Therefore, you cannot use logical partitions inside an extended partition as bootable DOS partitions.

Boot Concepts

The simplest boot concept involves only one machine with one operating system installed. The boot process for this case has already been outlined. The same boot concept can be used for a Linux-only machine. In this case, you could theoretically skip the installation of LILO or GRUB. However, in this case you would not be able to pass additional parameters to the system kernel at boot time. As soon as there is more than one operating system installed, there are several possible boot concepts:

Booting Another OS from a Floppy Disk:

One OS can be booted from the hard disk. Other operating systems can be booted using boot disks.

Booting Another OS from a USB Storage Device:
The system can also use a USB device to drive the boot process, which is very similar to the floppy method, only that the necessary data are fetched from the USB stick.

Installing a Boot Manager:

This allows you to use several operating systems on a single machine, and to choose among the installed systems at boot time. Switching to another operating system requires a reboot. The only condition is that the boot manager must be compatible with all the operating systems installed on the machine.

Map Files, GRUB, and LILO

The main obstacle for booting an operating system is the fact the kernel usually is a file within a file system on a partition on a disk. These concepts are unknown to the BIOS. To circumvent this, ``maps'' and ``map files'' were introduced. These maps simply note the physical block numbers on the disk that comprise the logical files. When such a map is processed, the BIOS loads all the physical blocks in sequence as noted in the map, building the logical file in memory.

The main difference between LILO and GRUB is that LILO relies almost entirely on maps, whereas GRUB tries to get rid of fixed maps during boot as early as possible. This is accomplished by integrating file system code to the boot loader, so that files can be found by their path names rather than block numbers.

This difference has historical reasons: in the early days of Linux, many file systems were competing for dominance. Werner Almesberger wrote a boot loader that did not need to know in what kind of file system the kernel to boot actually resided. The idea behind the GRUB approach, however, is even older, from the ages of traditional Unix and BSD. These usually had a single file system of choice and often had a reserved space at its beginning in which to embed a boot loader. This boot loader knew the data structures of the file system in which it was embedded and kernels could be found by name in the root directory of that file system.

The following section describes the installation and configuration of a boot manager, using the Linux boot manager GRUB as an example. This is followed by a description of the differences when using LILO. A complete description of LILO is available in (), which is located in /usr/share/doc/packages/lilo/user.dvi.

You can view the text on screen with an application such as kdvi, or print it with the command: lpr /usr/share/doc/packages/lilo/user.dvi.


[Which boot manager will be installed by default?]If you update from a previous version of SuSE Linux where LILO was the boot manager, the new system will continue to use LILO. If you install SuSE Linux from scratch, the system will use GRUB, except where the root partition is installed on a RAID system of the following types:

Booting with GRUB

Similar to LILO, GRUB (the Grand Unified Boot loader) consists of two stages. The first stage is just 512 bytes long. It is written to the MBR or to the boot sector of a disk partition or floppy disk. The second, larger stage is loaded after that and holds the program code as such. The only purpose of the first stage is to load the second one.

From here, however, GRUB works differently than LILO, because the second stage contains code to read file systems. Currently supported are Ext2, Ext3, ReiserFS, JFS, XFS, Minix, and the DOS FAT file system used by Windows. GRUB has the ability to access file systems even before the boot process as such, as long as they are on devices handled by the BIOS (floppies or hard disks). This means that changes to the GRUB configuration do not require a reinstallation of the boot manager. On booting, GRUB just rereads its menu file to gather information about the paths and partitions where the kernel and the initial RAM disk (initrd) reside and is then able to find these files itself.

Another big advantage of GRUB is that all boot parameters can easily be changed before the actual booting. If it turns out that the menu file contains an error, it is still possible to fix it ``on the fly.'' GRUB also allows entering boot commands interactively through a prompt, which makes it possible to boot a system for which no entry has been written into the boot menu. Finally, GRUB is able to locate kernel and initrd images before the actual boot procedure.

The GRUB Boot Menu

GRUB displays a graphical splash screen or a text mode interface with a boot menu. The contents of this screen are controlled by the configuration file /boot/grub/menu.lst. This file contains all the information about the partitions or operating systems that can be selected from the boot menu.

This menu file is loaded by GRUB directly from the file system on each boot, so there is no need to update GRUB when the file has been modified. To reconfigure the boot loader, just edit the file via YaST or with your favorite editor.

The menu file contains commands GRUB should execute and its syntax is quite easy to grasp. Each line consists of a command, optionally followed by arguments that must be seperated by spaces, as is the case with shell commands. For historical reasons, there are some commands that allow an `=' before their first argument. Lines beginning with a hash (`#') are comments.

Each entry that should appear in the boot menu corresponds to a name in the configuration file, which must be preceded by the title keyword. In other words, the text string coming after title (including any spaces) is displayed as a selectable menu item. The following entries up to the next title entry are considered commands to execute when the menu item is selected.

A simple case of such a command is the chain loading of another operating system's boot loader. The command is called chainloader and the argument is usually another partition's boot block, written in the block notation of GRUB, for example:

chainloader (hd0,3)+1

GRUB's device naming scheme is explained in Section 4. The above example specifies the first block of the fourth partition on the first hard disk.

The command to specify a kernel image is just kernel. The first argument is the path to the kernel image on a partition. The remainder are parameters to pass to that kernel upon booting.

If the kernel does not have the necessary built-in file system or disk drivers to access the root partition, also include the initrd command. This GRUB command takes only one argument, which is the path to the initrd file. The initrd command must follow after the kernel command, because the kernel (already loaded at this point) assumes a certain loading address of the initrd image.

The root command simplifies the specification of kernel and initrd images. root takes a device or partition (in GRUB notation) as its only argument.

GRUB then appends the value of root to the beginning of all kernel, initrd, or other file paths that do not explicitly specify a device. This applies up to the next root command. The command is not used in the default menu.lst file created during the installation.

The boot command is implied and thus automatically executed at the end of each menu entry, so it does not need to be written into the menu file. On the other hand, if you should ever be in a situation where you have to enter GRUB commands interactively at the prompt, remember to issue the boot command at the end. The command itself has no arguments, it just boots the corresponding kernel image or chain loader.

Once you have written all your menu entries, specify which entry to use as the default. Otherwise, the first one (number 0) is booted by default. You can also specify a time-out in seconds after which this should occur. The timeout and default lines are usually written before the menu entries. A sample configuration file is described in Section 4.

Naming Conventions for Hard Disks and Partitions

GRUB names hard disks and partitions according to conventions which differ from the Linux device names that you might expect (such as /dev/hda1). The first hard disk is always referred to as /dev/hd0. The floppy drive is called /dev/fd0.


[Counting Partitions]With GRUB, partitions are counted beginning from zero. Accordingly, hd0,0 refers to the first partition on the first hard disk. On a typical desktop machine with just one hard drive connected as primary master, this corresponds to the Linux device called /dev/hda1.

The four primary partitions that are allowed per disk are numbered from 0 to 3, and logical partitions are counted beginning with 4:

(hd0,0)   first primary partition on first hard disk
(hd0,1)   second primary partition
(hd0,2)   third primary partition
(hd0,3)   fourth primary partition (usually an extended partition)
(hd0,4)   first logical partition
(hd0,5)   second logical partition


[IDE, SCSI, and RAID] GRUB does not distinguish between IDE, SCSI, or RAID devices. All hard disks as detected by the BIOS or other disk controllers are counted according to the boot sequence as set in the BIOS itself.

The fact that BIOS device names do not correspond to Linux devices is a problem that exists for both LILO and GRUB. Both use similar algorithms to establish a mapping. GRUB, however, stores the result in a file ( which can be edited. For more information about, refer to Section 4.

For GRUB, a path name must be specified as a device name written in parentheses, followed by a file name together with its full path on that device or partition. The path must always start with a slash. For example, on a system with a single IDE disk and Linux on the first partition, the bootable kernel might be specified with:


A Sample Menu File

The following example shows how the GRUB menu file works. This imaginary machine has a Linux boot partition on /dev/hda5, a root partition on /dev/hda7, and a Windows installation on /dev/hda1.

gfxmenu (hd0,4)/message
color white/blue black/light-gray
default 0
timeout 8

title linux
   kernel (hd0,4)/vmlinuz root=/dev/hda7 vga=791
   initrd (hd0,4)/initrd
title windows
title floppy
title failsafe
   kernel (hd0,4)/vmlinuz.shipped root=/dev/hda7 ide=nodma \
   apm=off acpi=off vga=normal nosmp maxcpus=0 3
   initrd (hd0,4)/initrd.shipped

The first part defines the splash screen configuration:

gfxmenu (hd0,4)/message
The background image is located on /dev/hda5 and has the name message.

The color scheme: white as normal foreground, blue as normal background, black for the foreground of selected items, and light gray as the selection background. These colors do not affect the graphical splash screen as defined under gfxmenu, but the standard GRUB interface. On a SuSE Linux system, this interface can be accessed from the splash screen by pressing .

default 0
The first menu entry title linux shall be booted by default.
timeout 8
After 8 seconds without user input, GRUB automatically boots the default entry.

The second, larger part defines the different operating systems to boot:

The menu file can be modified at any time. GRUB automatically reads the changes on the next boot. To make changes to the boot procedure that should be permanent, modify this file with the corresponding YaST module or with your favorite editor. To change the GRUB behavior on a temporary basis only, use the interactive edit function provided by GRUB.

Editing the Menu Entries

The graphical interface of GRUB not only allows selection of the system to boot (moving the cursor with the arrow keys), but also allows kernel parameters to be appended at the boot prompt (provided that the selection represents a Linux system). This was already possible with LILO, but GRUB takes this one step further. If you press to leave the splash screen then E, GRUB enters editing mode, allowing you to directly change individual menu items. Changes made in this way are valid for the current boot action only. They are not be written to the configuration file.


[Keyboard Layout during the Boot Phase]The US keyboard layout is the only one available at boot time. Thus, you need to remember that some characters may need to be produced with different keys.

After enabling the editing mode, use the arrow keys to navigate to the entry to change. To make the selected item editable, press E again. You can now correct any partitions or paths that may be wrong to avoid that they affect the boot procedure. Leave the editing mode with and go back to the menu, where the changed entry can be booted by pressing E. In the lower part of the screen, GRUB displays some hints on other actions that you may take.

To make the changed boot options permanent, edit the file menu.lst as SuSE @nohyphen root and append any additional kernel parameters at the end of the existing line, each separated by a space:

title linux
   kernel (hd0,0)/vmlinuz root=/dev/hda3 <additional parameter>
   initrd (hd0,0)/initrd

GRUB takes any new parameters into account upon the next boot. An alternative way to make these changes is through the YaST boot loader module. Again, any new parameters need to be appended at the end, after a separating space.

The File

The previously-mentioned file maps GRUB device names to Linux device names. If your system has a hardware mix that includes both IDE and SCSI disks, GRUB tries determine the boot sequence according to a certain algorithm. However, GRUB is not able to access the BIOS setup to obtain this information. GRUB stores the result of this check in the file /boot/grub/ For a system where the BIOS is set up to boot IDE devices before any SCSI devices, the file could look like this:

(fd0)  /dev/fd0
(hd0)  /dev/hda
(hd1)  /dev/hdb
(hd2)  /dev/sda
(hd3)  /dev/sdb

If GRUB boots with a given file and encounters any problems, check the order of the devices in the file and use the GRUB shell to change it if necessary. Once you have successfully booted your Linux system, you can change the file with the boot loader module of YaST or with any editor.

Any manual change to the file requires that you update your GRUB installation. This is done with the following command:

grub -batch < /etc/grub.conf

The File /etc/grub.conf

In addition to menu.lst and, GRUB stores another important part of its configuration in the file grub.conf. This file defines the parameters and options needed by the grub command to correctly install the boot loader:

root (hd0,4)
install /grub/stage1 d (hd0) /grub/stage2 0x8000 (hd0,4)/grub/menu.lst

The individual entries have the following meaning:

root (hd0,4)
This tells GRUB that all the following commands should be applied to the first logical partition on the first hard drive, where the boot files are located.
install <parameter>
This tells grub to run its internal install command, specifying that it should install the first stage of the boot loader in the MBR of the first hard disk (/grub/stage1 d (hd0)) and that the memory address at which to load stage2 is 0x8000 (/grub/stage2 0x8000). The last parameter ((hd0,4)/grub/menu.lst) tells GRUB where to look for the menu file.

The GRUB Shell

GRUB actually consists of two parts: the boot loader and a normal Linux program (/usr/sbin/grub). This program is also called the GRUB shell. The functionality to install the boot loader on a hard disk or floppy is integrated into the GRUB shell through the internal commands install and setup. In other words, these commands can be executed using the GRUB shell on a running Linux system. However, these commands are also available while the system is booting with GRUB-- before Linux is even running. This makes the repair of a defective system much easier.

The device mapping algorithm as mentioned above only matters when GRUB runs its shell. It then reads the file to map GRUB device names to Linux devices as indicated by each line. Given that the order in which the BIOS addresses IDE, SCSI, and other hard drives depends on several factors and given that Linux cannot reliably determine this order, GRUB uses the file where the correct order can specified by hand. If you have difficulties booting your machine, check that the order in this file is in line with your BIOS settings. The file is found in the directory /boot/grub. To learn more about the topic, read Section 4.

Setting a Boot Password

Because GRUB is able to access file systems upon booting, it could also be used to read files that would not be accessible under normal circumstances -- on a running system, users would need SuSE @nohyphen root permissions to read them. To put a stop to this, set a boot password. Such a password can be used to prevent unauthorized access to file systems at boot time and to prevent users from booting certain systems that are installed.

To create a boot password, log in as root SuSE @nohyphen root and perform these steps:


[Boot Password and Splash Screen]Setting a boot password for GRUB disables the graphical splash screen as displayed by default.

Troubleshooting and Further Reading


[Boot Errors with GRUB]The geometry of attached hard disks is checked by GRUB only upon booting. In those rare cases where the BIOS reports inconsistent values, GRUB aborts with a ``GRUB Geom Error''. You may then need to use LILO instead or, if at all possible, update the BIOS.

Extensive information about GRUB in English, German, and Japanese can be obtained at, but the online GRUB manual itself is only available in English.

If you have texinfo installed on your system, you can view the GRUB info pages from a shell prompt by entering info grub. You can also look up ``GRUB'' as a keyword in the support database at to obtain information about special issues.

Booting with LILO

The Linux boot loader LILO is suitable for installation in the MBR. LILO has access to two real-mode hard disks and is able to find all the data it needs from the raw hard drives without any partitioning data. Therefore, operating systems can also be booted from the second hard disk. Unlike with the DOS boot process, the entries in the partition table are ignored when using LILO.

The main difference from the standard DOS boot process is the possibility to load diverse installed operating systems when booting. After loading the MBR into memory, LILO is started, allowing the user to select from the list of preinstalled systems. At system start-up, it can load boot sectors from partitions to boot an operating system from the respective partition or load the Linux kernel and boot Linux. It also provides the important possibility of passing a command to the kernel. For security reasons, some or all LILO services can be protected with a password.


The LILO boot mechanism consists of the following components:


Any write access (even through file movements) to any of these files corrupts the map file - unless LILO is updated (see 4). This is especially important when changing kernels.

The following locations are suitable for storing the LILO boot sector:

On a floppy disk
This is the simplest, but also the slowest method for booting with LILO. Choose this alternative if you do not want to change the existing boot sector.

In the boot sector of a primary Linux partition on the first hard disk
This leaves the MBR untouched. Before it can be booted, the partition must be marked active. Start fdisk as SuSE @nohyphen root with the command fdisk -s <partition>. The program will ask for a command. You can obtain a list of the available commands by entering `m'. The `a' command can be used to mark a partition as active.

In the Master Boot Record
This variation offers the highest flexibility. It is the only possible alternative if all the Linux partitions reside on the second hard disk, and if there is no extended partition on the first drive. Every setting of the MBR must be edited with extreme care because errors may have severe consequences.

In a boot sector booted by another boot manager
Try this if you are using another boot manager and want to continue using it. Depending on its flexibility and power, there are several variations. A common case: you have a primary Linux partition on the second hard disk from which you want to boot Linux. If your boot manager is able to boot this partition through its boot sector, you may install LILO into this boot sector and then tell your boot manager that the partition is active.

Configuring LILO

LILO is a flexible boot manager that offers many ways of adapting a configuration to your needs. The most important options and meanings are described below. For more detail, look at ().

The configuration of LILO is stored in the file /etc/lilo.conf. You should always make a backup of the last working lilo.conf file before changing it. On the other hand, any changes in this file take effect only when reinstalling LILO i.e. after running the lilo command against the changed /etc/lilo.conf file. For details on this, refer to Section 4.

Structure of lilo.conf

/etc/lilo.conf starts with a global section, followed by one or more system sections for each operating system LILO should start. Each system section starts with a line beginning with either image or other.

The order of entries in /etc/lilo.conf does matter, in the sense that the first one in the list is booted automatically if there is no user input at the boot screen (and unless the default option is used). This may happen after a certain interval which can be set with the delay and timeout options as explained below.

A sample configuration for a computer with both Windows and Linux is shown in File 2. The bootable systems include a newly installed Linux kernel (/boot/vmlinuz) and the original kernel which is used as a fallback (/boot/vmlinuz.shipped). There is also an entry to boot Windows on /dev/hda1, and an additional one to start the program MemTest86.

File: Sample Configuration of /etc/lilo.conf

### LILO global section
boot    = /dev/hda           # LILO installation target: MBR
backup  = /boot/MBR.hda.990428  # backup file for the old MBR
                                # 1999-04-28
vga     = normal             # normal text mode (80x25 chars)
menu-scheme = Wg:kw:Wg:Wg
lba32                        # Use BIOS to ignore
                             # 1024 cylinder limit
password = q99iwr4           # LILO password (example)
timeout = 80                 # Wait at prompt for 8 s before
                             # default is booted
message = /boot/message      # LILO's greeting

### LILO Linux section (default)
  image  = /boot/vmlinuz     # Default
  label  = linux
  root   = /dev/hda7         # Root partition for the kernel
  initrd = /boot/initrd

### LILO Linux section (fallback)
  image  = /boot/vmlinuz.shipped
  label  = Failsafe
  root   = /dev/hda7
  initrd = /boot/initrd.suse

### LILO other system section (Windows)
  other  = /dev/hda1         # Windows partition
  label  = windows

### LILO memory test section (memtest)
  image  = /boot/memtest.bin
  label  = memtest86

Anything between a `#' and the end of a line is regarded as a comment. Spaces and comments are ignored by LILO and can be used to improve readability. The entries in the above sample file include mandatory options which are explained in the list below, and others which are described in Section 4.

This section merely covers the basic entries required in /etc/lilo.conf. Other useful settings can be found in lilo.conf.

Installing and Uninstalling LILO


Before you install LILO, make sure that any other existing operating systems can be booted from floppy disk (not possible for Windows XP/2000/NT). In particular, make sure that fdisk is available. As far as SuSE Linux is concerned, you can use the installation CD or DVD as a fallback boot medium.

Updating After Changing the Configuration

If any of the LILO components have changed, or if you have modified your configuration in /etc/lilo.conf, you must update the LILO boot loader. This is easily done by launching the map installer as SuSE @nohyphen root:


LILO creates a backup of the target boot sector, writes its first stage into the boot sector, then generates a new map file (also see 4). LILO issues a report on each installed system In the case of the sample configuration described above, it should look like this:

aus:lilo.install.outputOutput After Launching LILO
Added linux *
Added suse
Added windows
Added memtest86

When the boot loader update is completed, you can reboot the machine by issuing this command as SuSE @nohyphen root:

shutdown -r now

While rebooting, the BIOS first performs its system test. Immediately afterwards, you should see LILO and its command prompt, where you can enter parameters and select a boot image. You can also hit to see a list of the systems installed.

Uninstalling the Linux Boot Loader

To uninstall GRUB or LILO, the boot sector on which the boot loader is located needs to be overwritten with its original contents. With SuSE Linux, this is easily done provided that there is a valid backup of that former content. The YaST boot loader module can be used to create such a backup, to integrate such a backup in the boot loader menu later on, and to restore a standard MBR. The YaST boot loader module is described in the installation chapter of the User Guide.


A boot sector backup is no longer valid if the partition in question has a new file system. The partition table of an MBR backup becomes invalid if the hard disk in question has been repartitioned since the backup was created. Obsolete ``backups'' are time bombs. It is best to delete them as soon as possible.

Restoring the MBR (DOS/Win9x/ME

It is very simple to restore a DOS or Windows MBR. Just enter the MS-DOS command (available since DOS version 5.0):

fdisk /MBR

or, on OS/2:

fdisk /newmbr

These commands only write the first 446 bytes (the boot code) into the MBR and leave the partition table untouched, unless the MBR as a whole (see sec:lilo.MBR) is treated as invalid due to an incorrect magic number. In this case, the partition table is set to zero. After restoring the MBR, make sure that you mark the desired start partition as bootable (using fdisk again). This is required for the MBR routines of DOS, Windows, and OS/2.

Restoring the MBR of Windows XP

Boot from the Windows XP CD and press the R key during the setup to start the recovery console. Select your Windows XP installation from the list and enter the administrator password. At the input prompt, enter the command FIXMBR and confirm with y when asked to do so. Then reboot the computer with exit.

Restoring the MBR of Windows 2000

Boot from the Windows 2000 CD and press the R key and then C in the next menu to start the recovery console. Select your Windows 2000 installation from the list and enter the administrator password. At the input prompt, enter the command FIXMBR and confirm with y when asked to do so. Then reboot the computer with exit.

Booting Linux after Restoring the MBR

After restoring the standard Windows MBR, you can set up one of the Linux boot managers available, to continue using the Linux system installed on your machine.


Even when installed in the MBR, GRUB will write its stage1 data into the Linux partition. After having restoring the MBR with YaST or with the Windows tools mentioned above, you need to mark that partition as active, which can be done with fdisk. To do so, log in as SuSE @nohyphen root und execute the command fdisk /dev/<harddisk>. The fdisk screen will prompt you for a command to run. Enter ` m' to obtain a list of the commands that are available. The ` a' command allows you to select one of the existing primary partitions as active, which in our case should be the Linux partition which holds the stage1 copy. After making this change, you can check the partition table by entering ` p' (print) from within fdisk.


LILO can be reinstalled after restoring the Windows MBR if there is a backup file available. Check whether the size of the backup file is exactly 512 bytes, then restore the sector with the following commands:

The last command is a safe version which does not overwrite the partition table. Again, you still need to use fdisk to mark the corresponding partition as active (bootable).

Creating Boot CDs

This concerns problems arising when attempting to boot a system with the LILO boot manager configured with YaST. The creation of a system boot disk fails with more recent SuSE Linux versions because the space available on a floppy disk is no longer sufficient for the start-up files.


It is possible to create a bootable CD-ROM containing the Linux start-up files if your system has an installed CD writer. This solution is only a work-around. It should normally be possible to configure LILO properly. Refer to the documentation about this subject in /usr/share/doc/packages/lilo/README, lilo.conf, and lilo.


It is easiest to create a bootable CD with the ISOLINUX boot manager. The SuSE installation CDs are also made bootable with isolinux.


next up previous contents index
Next: The X Window System Up: Configuration Previous: YaST in Text Mode   Contents   Index
root 2003-11-05