Fix Grub Rescue: Debian 13 Won't Boot After Power Loss

Okay, so you've had a power outage mid-update on your Debian 13 system, and now you're staring at the dreaded grub> prompt. Don't panic! We've all been there (or somewhere similar). This means your GRUB (Grand Unified Bootloader) got interrupted and can't find the boot files it needs. It's like your computer's GPS is broken, and it doesn't know where to load the operating system from.

Understanding the Grub Rescue Situation

First off, let's break down what this “Minimal BASH-like line editing” thing actually is. GRUB, at its core, is a bootloader. It's the first program that runs when your computer starts up. It’s responsible for finding your operating system (Debian 13, in this case) and loading it into memory. When things go smoothly, you see the GRUB menu, where you can choose which OS to boot, or it automatically loads your default OS. But when a power outage hits during a critical update, especially one involving GRUB itself, things can get messy.

The Minimal BASH-like environment is a stripped-down version of GRUB that loads when the main GRUB configuration is missing or corrupted. It provides basic command-line tools, giving you a chance to manually intervene and try to fix things. Think of it as GRUB's emergency mode. It's not pretty, but it's there to help you get back on your feet. This is crucial because if GRUB can't do its job, your operating system is essentially stranded on the hard drive, unable to be launched. The grub> prompt you're seeing is where you'll enter commands to try and locate your boot partition, load the necessary modules, and get your system booting again. It can feel intimidating, but with the right steps, you can navigate this. The key thing to remember is that this situation is usually fixable, and you don't necessarily need to reinstall your entire operating system. We'll walk through some commands and techniques to help you troubleshoot and hopefully get back into your Debian 13 install without too much hassle.

Initial Troubleshooting Steps

Before we dive into complex commands, let's start with some basic checks. The goal here is to help GRUB find its bearings. We need to tell GRUB where to look for the files it needs to boot your system. This often involves identifying the correct partition where your /boot directory resides. The /boot directory is where critical boot files, including the Linux kernel and GRUB configuration, are stored. If GRUB can't find this directory, it won't know how to boot your system. A common first step is to use the ls command within the GRUB rescue environment to list available devices and partitions. This helps you figure out which partition contains your boot files. You'll see devices listed as (hd0), (hd1), etc., representing your hard drives. Each hard drive can have multiple partitions, like (hd0,1), (hd0,2), and so on. The numbers after the comma indicate the partition number. To use the ls command, you would type ls (hd0,1)/ and press Enter. This will list the contents of the first partition on the first hard drive. If you see familiar directories like boot, efi, or vmlinuz (which is the Linux kernel image), you're likely on the right track. If you get an error or don't see those directories, try another partition. It's a bit of a trial-and-error process, but systematically checking each partition is the first step to figuring out where your boot files are located. Once you find the partition containing your /boot directory, you'll have a crucial piece of the puzzle needed to restore your system's boot process. Remember, patience is key here. Take your time, and carefully examine the output of the ls command to identify the correct partition.

1. List Available Devices

Type ls and press Enter. You'll see a list of available devices and partitions, like (hd0), (hd0,1), (hd0,2), etc. These represent your hard drives and their partitions. hd0 is the first hard drive, hd1 the second, and so on. The numbers after the comma indicate the partition number on that drive.

2. Find Your Boot Partition

Now, we need to figure out which partition contains your /boot directory. This is where the kernel and other essential boot files reside. Try listing the contents of each partition using the ls command followed by the partition name. For example:

grubs
ls (hd0,1)/
ls (hd0,2)/
ls (hd1,1)/

Keep trying different partitions until you see something that looks like a Linux filesystem, with directories like boot, efi, and files like vmlinuz (the Linux kernel image). If you find a partition with these contents, you've likely found your /boot partition. This is a critical step because it identifies where GRUB needs to look to load the operating system. It's like finding the correct street address for your house; without it, the delivery truck (GRUB) can't find your door (your operating system). So, take your time, explore each partition systematically, and look for those telltale signs of a Linux filesystem. Remember, the ls command is your friend here, giving you a peek inside each partition to help you piece together the puzzle.

Setting the Root and Prefix

Once you've identified your /boot partition, you need to tell GRUB about it. This involves setting two important variables: root and prefix. Think of root as telling GRUB where the main filesystem containing your bootloader configuration is located, and prefix as pointing to the directory where GRUB's modules are stored. These settings are essential for GRUB to function correctly and load the necessary components to boot your system. Setting these variables correctly is like giving GRUB the precise map coordinates it needs to navigate to the right location. If these are set incorrectly, GRUB will be lost and unable to proceed with the boot process. The root variable tells GRUB which partition to use as its root filesystem. This is typically the partition where your /boot directory is located. The prefix variable, on the other hand, points to the directory within the root filesystem where GRUB's modules are stored. These modules are small pieces of code that GRUB uses to perform various tasks, such as accessing filesystems, loading kernels, and displaying the boot menu. By setting prefix, you're essentially telling GRUB where to find these tools. To set these variables, you'll use the set command in the GRUB rescue environment. We'll walk through the specific syntax in the next section, but the key takeaway here is that root and prefix are crucial for GRUB to locate its files and continue the boot process. Getting these right is a significant step towards rescuing your system.

1. Set the root Variable

Let's say you found your /boot partition on (hd0,2). You would set the root variable like this:

set root=(hd0,2)

This tells GRUB that the root filesystem is located on the second partition of the first hard drive. It's like setting the starting point on a map. Without this, GRUB doesn't know where to begin looking for its files.

2. Set the prefix Variable

The prefix variable tells GRUB where its modules are located. Typically, this is in the /boot/grub directory on your root partition. Set the prefix variable like this:

set prefix=(hd0,2)/boot/grub

This command specifies the exact path to the GRUB modules within the partition you identified earlier. Think of these modules as the tools GRUB needs to do its job – things like filesystem drivers and kernel loaders. By setting the prefix, you're giving GRUB access to its toolbox.

Loading the Kernel and Initrd

Now that GRUB knows where to find its files, we need to manually load the kernel and the initrd (initial ramdisk). The kernel is the heart of your operating system, the core program that manages the system's resources. The initrd is a temporary filesystem that's loaded into memory before the main filesystem. It contains drivers and utilities needed to mount your root partition and get the system booting. Think of the kernel as the engine of your car, and the initrd as the set of tools you need to get the engine running. Without both, your system won't start. Loading the kernel and initrd manually in GRUB rescue is like manually jump-starting a car when the battery is dead. You're providing the essential components needed to get the system going. This is a crucial step because GRUB, in its broken state, can't automatically find and load these files. You'll need to tell it exactly where they are located on your /boot partition. The exact filenames of the kernel and initrd can vary depending on your Debian version and kernel updates. You can usually find them by listing the contents of your /boot directory. Once you know the filenames, you'll use the linux and initrd commands in the GRUB rescue environment to load them into memory. This prepares the system for booting into your operating system. Getting these files loaded correctly is a major step towards getting your system back up and running.

1. Load the Normal Module

Before we load the kernel, load the normal module. This module provides helpful commands and functionalities.

insmod normal

After this, try typing normal and pressing Enter. If you get the normal GRUB menu, you might be able to boot normally from there. If not, continue with the next steps.

2. Load the Linux Kernel

You need to load the Linux kernel image. The filename usually starts with vmlinuz followed by the kernel version. You can list the files in /boot using ls (hd0,2)/boot/ to find the exact filename. Let's say it's vmlinuz-6.1.0-13-amd64. You would load it like this:

linux /boot/vmlinuz-6.1.0-13-amd64 root=/dev/sda2 ro

Important:

• Replace vmlinuz-6.1.0-13-amd64 with the actual kernel filename you found.
• root=/dev/sda2 specifies your root partition. Replace /dev/sda2 with your actual root partition. This is the partition where your main Debian system is installed, not necessarily the /boot partition. You might need to use ls on other partitions to find it. ro mounts the root filesystem in read-only mode, which is a good practice for initial booting to prevent further filesystem corruption.

This command tells GRUB to load the specified kernel image into memory and sets the root filesystem. It's like providing the engine and telling it where to find the fuel. The root=/dev/sda2 part is crucial because it tells the kernel which partition contains your main system. If this is wrong, your system won't boot correctly. Finding the correct root partition might require some detective work using the ls command on different partitions until you recognize your system's files and directories.

3. Load the Initial Ramdisk (initrd)

The initrd is a temporary filesystem that contains drivers and utilities needed to boot the system. The filename usually starts with initrd.img followed by the kernel version. Again, use ls (hd0,2)/boot/ to find the exact filename. Let's say it's initrd.img-6.1.0-13-amd64. Load it like this:

initrd /boot/initrd.img-6.1.0-13-amd64

Remember: Replace initrd.img-6.1.0-13-amd64 with the actual initrd filename.

This command loads the initial ramdisk image into memory. Think of the initrd as the emergency kit in your car – it contains the tools and supplies needed to get things going. It provides the initial drivers and utilities the kernel needs to access your hard drive and mount the root filesystem. Without the initrd, the kernel might not be able to find your root partition or load the necessary drivers, preventing your system from booting.

Booting the System

With the kernel and initrd loaded, you're ready to boot the system!

boot

This command tells GRUB to start the boot process. It's like turning the ignition key after jump-starting your car. If everything has been set up correctly, your system should start booting into Debian 13. You'll likely see the usual boot messages scrolling across the screen, and hopefully, you'll be greeted with your login prompt.

Fixing GRUB Permanently

If you successfully booted your system using the above steps, congratulations! However, this fix is temporary. The next time you reboot, you'll likely be back at the grub> prompt. To fix GRUB permanently, you need to reinstall it.

1. Boot into Your System

Make sure you've booted into your Debian 13 system using the steps outlined above.

2. Open a Terminal

Open a terminal window as an administrator.

3. Reinstall GRUB

Use the following command to reinstall GRUB:

sudo grub-install /dev/sda

Important:

• Replace /dev/sda with the disk where you want to install GRUB. This is usually the disk where your /boot partition resides. Be very careful to specify the correct disk; choosing the wrong disk can make your system unbootable. You can use the lsblk command to list your disks and partitions and identify the correct disk.

This command tells the system to reinstall GRUB on the specified disk. It's like permanently repairing the car's electrical system so you don't need to jump-start it every time. This step overwrites the corrupted GRUB installation with a fresh one, ensuring that GRUB can boot your system correctly in the future. Specifying the correct disk is critical here. If you choose the wrong disk, you could overwrite the bootloader on the wrong drive, potentially making other operating systems on your system unbootable. So, double-check your disk names using lsblk before running this command.

4. Update GRUB Configuration

After reinstalling GRUB, you need to update the GRUB configuration file. This ensures that GRUB knows about all your operating systems and boot options.

sudo update-grub

This command scans your system for installed operating systems and generates a new GRUB configuration file. It's like updating the car's GPS with the latest map data. This step ensures that GRUB knows about all your installed operating systems and can generate a boot menu that allows you to choose which one to boot. It also incorporates any changes you've made to your system, such as new kernel versions or different boot options. Running update-grub after reinstalling GRUB is essential to ensure that your boot menu is accurate and up-to-date.

GPT and EFI Systems

If your system uses GPT (GUID Partition Table) and EFI (Extensible Firmware Interface), which is common on modern systems, the steps are slightly different. EFI systems boot from an EFI System Partition (ESP), which is a dedicated partition for boot files.

1. Identify Your EFI System Partition (ESP)

The ESP is usually formatted as FAT32 and often mounted at /boot/efi. You can check your /etc/fstab file to confirm this.

2. Mount the ESP (if necessary)

If the ESP is not mounted, you need to mount it:

sudo mount /dev/sda1 /boot/efi

Important:

• Replace /dev/sda1 with the actual partition of your ESP. You can use lsblk to identify it.

This command mounts the EFI System Partition, making it accessible to the system. It's like connecting the car's GPS antenna so it can receive signals. The ESP is where EFI-based systems store their bootloaders and related files. If it's not mounted, GRUB can't access these files, and your system won't boot correctly. Mounting the ESP is a necessary step for reinstalling GRUB on EFI systems.

3. Reinstall GRUB for EFI

Use the following command to reinstall GRUB for EFI systems:

sudo grub-install --target=x86_64-efi --efi-directory=/boot/efi --bootloader-id=debian

Explanation of the options:

• --target=x86_64-efi: Specifies that you're installing GRUB for an EFI system.
• --efi-directory=/boot/efi: Specifies the directory where the EFI boot files should be installed.
• --bootloader-id=debian: Sets the bootloader ID, which will appear in the EFI boot menu.

This command installs GRUB specifically for EFI-based systems. It's like installing a specialized navigation system designed for modern cars. The --target option tells GRUB that it's being installed on an EFI system. The --efi-directory option specifies where the EFI boot files should be placed, which is typically the ESP. The --bootloader-id option sets a name for the boot entry in the EFI boot menu, making it easier to identify. Using this command ensures that GRUB is installed correctly for your system's firmware.

4. Update GRUB Configuration

Run sudo update-grub to update the GRUB configuration file, as mentioned earlier.

LVM Considerations

If your system uses LVM (Logical Volume Management), the process is slightly more complex because you need to activate your LVM volumes before GRUB can access them. LVM is a system for managing logical volumes, which can span multiple physical disks. It provides flexibility in partitioning and storage management. If your system uses LVM, your root and /boot partitions might be located within logical volumes. This means that before GRUB can access these partitions, you need to activate the LVM volume group. Activating the volume group makes the logical volumes within it accessible to the system. Without activating LVM, GRUB won't be able to find your boot files, and you'll be stuck at the grub> prompt. The steps for activating LVM involve using the insmod command to load the LVM module in GRUB rescue and then using the lvscan, vgchange, and lvdisplay commands to identify and activate your LVM volumes. Once the LVM volumes are activated, you can proceed with setting the root and prefix variables and loading the kernel and initrd as described earlier. Understanding LVM is crucial for rescuing systems that use it, as it adds an extra layer of complexity to the boot process.

1. Load the LVM Module

In the GRUB rescue prompt, load the LVM module:

insmod lvm

This command loads the LVM module, allowing GRUB to recognize and interact with LVM volumes. It's like installing a specialized adapter that allows your car's navigation system to read data from a particular type of storage device. The LVM module provides the necessary tools for GRUB to access the logical volumes on your system. Without loading this module, GRUB won't be able to see your LVM volumes, and you won't be able to boot your system. Loading the LVM module is a crucial first step when dealing with GRUB rescue on systems that use LVM.

2. List LVM Volume Groups

Use the lvscan or vgscan command to list available LVM volume groups. You may need to use the full path /sbin/lvscan or /sbin/vgscan.

/sbin/lvscan

This command scans for LVM logical volumes and displays their information. It's like running a diagnostic tool to identify the different storage units within your car. The output of lvscan will show you the names and paths of the logical volumes on your system. This information is essential for identifying your root and /boot volumes, which you'll need to specify when loading the kernel. If you don't see any output from lvscan, it could indicate a problem with your LVM configuration, which might require further troubleshooting.

3. Activate Your Volume Group

Activate your volume group using the vgchange command. You need to know the name of your volume group, which you can find from the lvscan output. Let's say your volume group is named debian-vg:

/sbin/vgchange -ay debian-vg

Important:

• Replace debian-vg with your actual volume group name.

This command activates the specified LVM volume group, making its logical volumes accessible. It's like turning on the power switch to your car's storage system. The -ay option tells vgchange to activate all logical volumes within the volume group. Activating the volume group is a necessary step before you can access the logical volumes, including your root and /boot partitions. Without activating the volume group, GRUB won't be able to find your boot files. So, it's crucial to identify your volume group name and activate it using the vgchange command.

4. Identify Root and /boot Logical Volumes

Use lvdisplay to identify the logical volumes for your root and /boot partitions. Again, you might need to use the full path /sbin/lvdisplay.

/sbin/lvdisplay

This command displays detailed information about the LVM logical volumes on your system. It's like getting a detailed map of your car's storage system, showing you the location of each individual storage unit. The output of lvdisplay will show you the names, paths, and sizes of your logical volumes. You need to identify the logical volumes that correspond to your root and /boot partitions. This information is crucial for setting the root variable in GRUB and for specifying the correct root device when loading the kernel. So, carefully examine the output of lvdisplay to find the logical volumes you need.

5. Use Logical Volume Path in GRUB Commands

When setting the root and loading the kernel, use the logical volume paths. For example, if your root logical volume is /dev/debian-vg/root and your /boot partition is /dev/debian-vg/boot, you would use these paths in the set root and linux commands:

set root=(hd0,gpt2)
linux /vmlinuz-6.1.0-13-amd64 root=/dev/mapper/debian--vg-root ro
initrd /initrd.img-6.1.0-13-amd64

Important:

• Replace /dev/mapper/debian--vg-root with the actual path to your root logical volume.
• Note that the root variable in GRUB sometimes requires the partition in (hdX,gptY) format, while the root parameter in the linux command requires the full device mapper path.

These commands tell GRUB where to find the kernel and initrd images within your LVM logical volumes. It's like providing the precise coordinates for your car's navigation system to reach its destination. When using LVM, the paths to your partitions are different from standard partitions. You need to use the device mapper paths, which are typically in the format /dev/mapper/volume_group-logical_volume. Specifying the correct paths is crucial for GRUB to load the kernel and boot your system. So, double-check the output of lvdisplay to ensure you're using the correct paths for your logical volumes.

Conclusion

Booting from the GRUB minimal BASH-like line can be intimidating, but by following these steps, you should be able to get your Debian 13 system back up and running. Remember to identify your partitions, set the root and prefix, load the kernel and initrd, and then boot. If you have an EFI system or use LVM, pay special attention to those sections. And most importantly, don't panic! With a little patience and the right commands, you can rescue your system. Good luck, guys!