How did Linux/xBSD boot before GRUB?

Question

According to Wikipedia, GRUB was released in 1995. By that point Linux and xBSD existed for several years. I know early Unix versions were tied to hardware in the 70s and 80s, but Linux and xBSD were free to distribute and install. Which begs the question how would you boot Linux back then? Were distributions shipping with their own implementations of bootloaders?

Answer 1

The first Linux distribution I used back in the 90s (Slackware 3.0 IIRC) used LILO as a bootloader. And many distros used LILO for years even when GRUB was becoming the "default" bootloader.

Moreover, in the early years of Linux it was common to boot Linux from another OS (i.e. DOS or Windows) instead of relying on a bootloader/dual booting. For example there was loadlin.

Don't forget Syslinux, which is a simpler boot loader often used for USB self-bootable installation/recovery distros. Or Isolinux (from the same project) used by many "Live" distros.

Keep in mind that today GRUB can be used to load many operating systems, while LILO was more limited, and specifically targeted at Linux (i.e. LInux LOader), with some support for dual booting to Windows.
GRUB is very useful for dual/multi booting because of its many configurable options, scripting capabilities, etc...
If you just want a single OS on your machine "any" (i.e. whichever bootloader is the default for your Linux/BSD distribution) should be enough.

Answer 2

LILO was the de-facto standard for booting Linux on PCs before Grub, from a very early stage (MCC, one of the first Linux distributions, used it). Various other bootloaders were used contemporaneously. Loadlin was quite common; it booted Linux from DOS, and was even used in some configurations with umsdos to host a Linux environment in a DOS file system... Another common configuration didn’t involve a bootloader at all: the kernel could boot itself from a floppy, and most Linux users kept a known-good pair of “boot and root” floppies, one containing the kernel, the other a basic root file system for rescue purposes.

There were a number of ways of using other operating systems’ bootloaders to boot Linux too; for example, OS/2’s boot manager, or Windows NT’s NTLDR.

Other systems had their own bootloaders:

• SILO on SPARC (Sun workstations and others);
• PALO on PA-RISC (HP workstations);
• YaBoot and Quik on PowerPC;
• aBoot and MILO on Alpha...

Even nowadays Grub isn’t the only bootloader you’ll see. While having the kernel boot directly from floppy is no longer very useful (I haven’t checked whether it’s still possible, assuming you can build a kernel small enough to fit on a floppy), it can boot directly from EFI (which is effectively its own small operating system designed to load other operating systems, as is Grub). On many smaller systems (embedded systems, single-board computers...) you’ll find U-Boot. (And there’s also an EFI layer for U-Boot.)

Answer 3

Up through mid 2.6 kernels, the x86 kernel was directly bootable if copied onto a floppy disk (as though it were a disk image).

This was, in fact, the original way of booting Linux.

If you look at the header of an x86 kernel today you see an error message that says booting from floppies like that doesn't work anymore.

Answer 4

I started with Linux in the late 90s and as mentioned lilo was the default. If you wanted to dual boot with a DOS system, you could do a bare boot without loading stuff into HIMEM or loading CD drivers, etc. and use loadlin. For Win95 dual booting, you could make the drive bootable first with DOS, then install '95, and '95's boot loader would let you boot the DOS kernel still, and then you could use loadlin.

For dual booting with NT4, the trick was to write LILO to the / partition, then strip off the first 512 bytes using dd (dd if=/dev/sda2 of=/path/to/file bs=512 count=1) and put the resulting file where ntldr could see it and you could use it from WinNT's boot loader. The issue with doing that is when you upgraded your kernel you had to remember to repeat all the steps before rebooting, otherwise you'd have issues getting back into the Linux system. Same process worked with Win2k.

With LILO, any time the kernel was updated, you had to remember to update LILO.

With loadlin any time the kernel updated, you had to remember to copy the kernel out to the DOS partition.

One other option that is hinted at in other answers was to write the kernel directly to a floppy using dd if=/path/to/vmlinuz of=/dev/fd0 BUT the root device had to be set properly in the kernel, either at compile time or by using the rdev utility.

When GRUB came around, there was much rejoicing because you no longer had to remember to update LILO, or update LILO and re-strip off the boot info, etc. No more getting left out of your Linux system because you forgot to update the boot loader info...

Answer 5

And before LILO and GRUB, you had to launch it from the command line with some sort of custom bootloader utility.

As an example, the Amiga had Linux available. You had to use a command line utility called amiboot to load the kernel ELF into memory and jump to it.

Here is a video of someone using amiboot from the command line to launch linux on an Amiga 600. His StartInstall script is calling the amiboot executable. You can watch amiboot configure memory, figure out the desired load address, and pass parameters to the kernel at around 0:55.