Usando GRUB
From Movaxes
Contents |
GRUB
GRUB es un poderoso bootloader capaz de cargar un SO de 32-bit desde un floppy, un disco duro, a travez de la red, etc.
El desarrollo de un SO debe ser fácil como crear cualquier archivo ejecutable, GRUB se encarga de eso, nos permite crear un solo archivo ejecutable en cualquiera de los formatos reconocidos y se encarga de preparar el sistema para cargarlo en la memoria y ejecutarlo. Claro que no hace todo por nosotros, aún quedan algunas cosas pendientes, pero nos ahorra bastante trabajo (escribir un bootloader no es tarea fácil ni demasiado emocionante).
Para que nuestro SO sea capaz de cargar con GRUB debe tener el Multiboot Header (cabecera). Eso nos permite usar cualquier bootloader capaz de cargar un SO con un multiboot header.
MUltiboot Header
Esta cabecera debe estar contenida completamente en los primeros 8192 bytes de la imagen del SO. Por lo general mientras más pronto se encuentra mejor.
El layout de la cabecera es así:
Offset Tipo Campo Nota 0 u32 magic requerido 4 u32 flags requerido 8 u32 checksum requerido 12 u32 header_addr si la bandera[16] está puesta 16 u32 load_addr si la bandera[16] está puesta 20 u32 load_end_addr si la bandera[16] está puesta 24 u32 bss_end_addr si la bandera[16] está puesta 28 u32 entry_addr si la bandera[16] está puesta 32 u32 mode_type si la bandera[2] está puesta 36 u32 width si la bandera[2] está puesta 40 u32 height si la bandera[2] está puesta 44 u32 depth si la bandera[2] está puesta
Como se puede ver en la tabla solo las primeras 3 son requeridas.
+ El campo 'magic' es el número mágico que identifica la cabecera, debe ser el valor hexadecimal: 0x1BADB002.
+ El campo 'flags' indica que es lo que necesita del bootloader para funcionar bien, los bits 0 al 15 indican los requerimientos, si el bootloader no entiende alguna de estas banderas o no puede cumplir con los requerimientos entonces no carga el SO y avisa al usuario. Los bits 16 al 31 indican otras opciones para el bootloader. Si el bit 0 está puesto todos los modulos cargados con el sistema operativo deben estar alineados a 4bytes. Si el bit 1 está puesto entonces la información disponible al menos por la via de los campos 'mem_' de la estructura de información del multiboot debe ser incluida (ver acá). Si el bootloader es capaz de pasar un mapa de memoria (campos 'mmap_') entonces debe pasarlo. Si el bit 2 está puesto la información acerca de la tabla de modo de video debe estar disponible para el kernel. SI el bit 16 está puesto los campos con offset 12 al 28 en el multiboot header son validos y el bootloader debe usarlos en lugar de los campos actuales en lugar del formato del ejecutable actual para calcular en dónde cargar el SO. Esto es necesario si el ejecutable no está en formato ELF sino en un a.out estandar o algún otro tipo de ejecutable.
+ El campo checksum es un valor de 32 bits sin signo que al sumarlo a los otros campos (magic+flags) debe tener una suma de 32bits sin signo de 0 (cero).
Cargando nuestro Kernel desde el GRUB de Linux
Si ya tienes instalado alguna distro de Linux en tu computadora (con GRUB) y quieres probar tu SO en hardware real, esto es lo que debes hacer:
Primero abre el archivo del menu de GRUB para agregar nuestro kernel usando el comando en un terminal (ejemplo usando UBUNTU):
$ sudo gedit /boot/grub/menu.lst
Ahora que tenemos abierto el archivo en gedit vamos a agregar al final:
title Kernel de Prueva root (fd0) kernel /boot/kernel.bin boot
Eso agrega al menu de GRUB la opción de cargar nuestro kernel de prueva desde un floppy (fd0):
title es el nombre que aparecerá en el menu (puedes poner lo que quieras)
root es el lugar en donde está el kernel (fd0 es nuestro floppy)
kernel le indica a GRUB en donde se encuentra el kernel (en este caso en un folder llamado 'boot' del floppy)
Eso es todo, cuando tengas un kernel listo solo lo grabas en el directorio boot del floppy y reinicias la computadora, cuando veas la opción en el menu de GRUB la seleccionas y presions ENTER, y ya está!!
Creando una imagen de floppy para nuesto kernel
Necesitas tener instalado GRUB (si tienes linux en tu computadora lo mas seguro es que ya lo tienes).
Primero necesitamos crear una imagen de 1.44MiB del floppy:
$dd if=/dev/zero of=floppy.img bs=1024 count=1440
Ahora un loopback:
$sudo losetup /dev/loop1 floppy.img
Ahora creamos nuestro sistema de ficheros Ext2fs:
$sudo mkfs /dev/loop1
Lo montamos:
$sudo mount -o loop /dev/loop1 /mnt
Ahora copiamos grub a la imagen montada (debes buscar stage1 y stage2 en tu sistema de ficheros, normalmente está en /boot/grub):
$sudo mkdir -p /mnt/boot/grub
$sudo cp /boot/grub/stage1 /boot/grub/stage2 /mnt/boot/grub/
Creamos un archivo de texto con la configuración para GRUB (lo llamamos: grub.conf):
$sudo gedit /mnt/boot/grub/grub.conf
Una vez lo tienes abierto escribes:
# Configuración de GRUB title = Kernel de Prueba root (fd0) kernel /kernel.bin
Desmontamos la imagen:
$sudo umount /mnt
Instalamos grub en la imagen:
$sudo grub --device-map=/dev/null
En la interfaz de GRUB ingresa los comandos:
grub> device (fd0) /dev/loop1 grub> root (fd0) grub> setup (fd0) grub> quit
Quitamos el loopback:
$sudo losetup -d /dev/loop1
Listo!!!
Agregar un kernel a la imagen del floppy
Primero montas la imagen:
$sudo losetup /dev/loop1 floppy.img $sudo mount -o loop /dev/loop1 /mnt
Ahora puedes editar el menu de grub o agregar tu kernel (.bin), etc.
Para grabar tu kernel.bin puedes usar este comando:
$sudo cp kernel.bin /mnt
Para editar el menu de GRUB usa el comando:
$sudo gedit /mnt/boot/grub/grub.conf
Por ultimo desmontas la imagen:
$sudo umount /mnt $sudo losetup -d /dev/loop1
Grabar la imagen a un Floppy real
Si quieres probar tu kernel en una computadora real (no usando BOCHS) debes escribir este comando:
$sudo dd if=floppy.img of=/dev/fd0
Cargando el Kernel en BOCHS
Para probar el kernel en BOCHS necesitas buscar el archivo 'bochsrc' (en mi caso está en: /usr/share/doc/bochs/examples dentro del archivo comprimido bhsrc.gz) ahora abre el archivo en tu editor de texto y edita las líneas que dice 'floppya...' y 'boot =...' para que queden:
floppya: 1_44=/dev/fd0, status=inserted
boot: floppy
Grabas tu imagen al floppy (si no lo has hecho antes) con:
$sudo dd if=floppy.img of=/dev/fd0
Montas tu floppy:
pmount /dev/fd0
Abres bochs:
sudo bochs
Pones la opción 5 y ya está!! tu kernel debe estar corriendo ahora en BOCHS.
