Creación de un disquete de arranque personalizado

Cómo crear un disquete de arranque decente

Aquí la intención es crear un "disco de rescate" que cargará suficiente 'linux' para permitirte hacer operaciones de rescate. Con lo que aquí se presenta serás capaz de manipular ficheros, montar y desmontar, y otras tareas. Sin embargo, este no es el límite. Aquí se describe el disco mínimo, y puedes añadir todo lo que puedas meter en el disquete.

Disco de Arranque/Disco de Rescate

Primero crearemos un fichero de bucle cerrado (loopback) en el que construiremos nuestro disco de rescate. Después crearemos un sistema de ficheros en el fichero imagen. Entonces usaremos 'mount' para montar el fichero como un disco normal, permitiéndonos leer y escribir ficheros desde el fichero de bucle cerrado. Los siguientes comandos nos construirá una imagen de 4MB.

dd if=/dev/zero of=/tmp/rfloppy bs=1k count=4096 &&
mke2fs -m 0 -N 2000 /tmp/rfloppy &&
mount -o loop /tmp/rfloppy /mnt/loop1 &&
rmdir /mnt/loop1/lost+found/

Ahora que tenemos un fichero montado y utilizable, vamos a prepararlo para meter material útil. Puesto que solamente es un disquete de rescate, sólo necesitamos establecer los directorios fundamentales.

mkdir /mnt/loop1/{dev,proc,etc,sbin,bin,lib,mnt,usr,var}

Lo siguiente es configurar los ficheros de dispositivo. Yo utilizo devfs en mi sistema, por lo que el siguiente comando me funciona bien y sólo tengo los dispositivos que utilizo. Si usaste MAKEDEV para crear tus dispositivos, querrás purgar el directorio /mnt/loop1/dev para recuperar el espacio gastado por los inodos de todos los dispositivos que no utilices.

cp -dpR /dev/* /mnt/loop1/dev

Ahora pasemos al directorio /etc. Para empezar, todo lo que tenemos que hacer es utilizar los ficheros passwd y group que funcionaban con nuestro entorno chroot estático cuando construimos LFS. También copiaremos los guiones de arranque y unos cuantos ficheros que servirán como punto de partida.

cp -ax /etc/rc* /mnt/loop1/etc cp -ax /etc/fstab /mnt/loop1/etc echo "root:x:0:0:root:/root:/bin/bash" > /mnt/loop1/etc/passwd cat > /mnt/loop1/etc/group << "EOF" root:x:0: bin:x:1: sys:x:2: kmem:x:3: tty:x:4: tape:x:5: daemon:x:6: floppy:x:7: disk:x:8: lp:x:9: dialout:x:10: audio:x:11: EOF

Para prevenir el montaje automático de las particiones del disco duro, asegúrate de añadir la opción noauto a sus entradas en fstab. También, añade las siguientes entradas a /mnt/loop1/etc/fstab para ayudarle con el montaje de nuestro disquete y la imagen RAM:

/dev/ram0 / ext2 defaults /dev/fd0 / ext2 defaults

A continuación instalaremos busybox sobre la imagen. Busybox incorpora muchas de las funciones Unix dentro de un fichero ejecutable pequeño.

make &&
make PREFIX=/mnt/loop1 install &&
cp -ax /var/utmp /mnt/loop1/var &&
mkdir /mnt/loop1/var/log

También, sin olvidar tus limitaciones de espacio, copia a la imagen cualquier otro binario y librería que necesites. Utiliza el comando ldd para ver qué librerías necesitarás copiar para los ejecutables.

Ahora, puesto que yo uso devfs para crear dispositivos al vuelo y liberar preciosos inodos en el disquete, instalaremos también devfsd para suministrar los dispositivos que busybox espera encontrar.

mv GNUmakefile Makefile &&
make &&
make PREFIX=/mnt/loop1 install &&
cp /lib/libc.so.6 /lib/ld-linux.so.2 /lib/libdl.so.2 /tmp &&
strip --strip-deb /tmp/ld-linux.so.2 /tmp/libc.so.6 /tmp/libdl.so.2 &&
mv /tmp/ld-linux.so.2 /tmp/libc.so.6 /tmp/libdl.so.2 /mnt/loop1/lib/

También necesitaremos configurar un guión rc para manejar el arranque de devfsd. Pon esto en /mnt/loop1/etc/init.d/rcS

#!/bin/sh
mount -t devfs devfs /dev
/sbin/devfsd /dev

Seguidamente crea tu sistema de ficheros raíz comprimido. Utilizamos -9 con gzip para hacer la imagen comprimida lo más pequeña posible.

umount /mnt/loop1 && dd if=/tmp/rfloppy bs=1k | gzip -v9 > rootfs.gz

ls -l rootfs.gz
# para asegurarte de que cabe en el disquete.

Crea un núcleo personalizado optimizado en el tamaño. Incluye sólo aquellas características que necesitarás para rescatar tu sistema. No tiene sentido incluir soporte para cosas como xfree86, dri, etc, pues la mayoría de rescates se realizan mediante la línea de comandos.

dd if=rescueimg of=/dev/floppy/0 bs=1k
        429+1 records in
        429+1 records out
rdev /dev/floppy/0 /dev/floppy/0
rdev -R /dev/floppy/0 0

En este ejemplo, rescueimage (EL NÚCLEO) tenía un tamaño de 429+1 bloques. Recordaremos esto para el siguiente comando. Ahora escribimos en el disquete el sistema de ficheros raíz a continuación del núcleo, haciendo 16384+429+1=16814

rdev -r /dev/floppy/0 16814

dd if=rootfs.gz of=/dev/floppy/0 bs=1k seek=430

En este comando usamos seek para encontrar el final del núcleo (429+1) y escribir el sistema de ficheros raíz al disquete.