El desarrollo de Hurd continúa avanzando... lentamente... aún así ya empieza a ser usable por intrépidos usuarios como nosotros que deseamos aprender más y más. Por eso me he decidido a intentar crear una serie de recetas sobre Hurd. La primera de ellas es ésta: probar hurd en una máquina virtual.

¿Qué es GNU/Hurd?

Desde sus inicios, el objetivo del proyecto GNU ha sido crear un sistema operativo completo y libre. En sus inicios el proyecto contaba con diversas herramientas de desarrollo, aplicaciones de sistema, etc. Pero carecían de un elemento bastante importante: un kernel que ejecutase todo eso. Decidieron crear uno: Hurd, pero lamentáblemente eso es un proceso lento y costoso; por ello decidieron adoptar temporalmente el conocido kernel linux. Actualmente HURD no es usable en entornos de producción pero se encuentra activamente en desarrollo.

Arquitectura Hurd

Como todos sabéis, linux es un núcleo monolítico, como lo era el MS-DOS. Esto significa que todos los componentes del sistema operativo funcionan como un gran programa, esta concepción está ya muy obsoleta (o así debería ser) y actualmente se opta por crear sistemas con sus componentes bien diferenciados e independientes colaborando unos con otros. Esto es hurd: una colección de servidores en la que cada uno implementa el sistema de archivos, la red, etc. Todos estos servidores no pueden ejecutarse ellos sólos, necesitan de un microkernel que gestione el paso de mensajes, la sincronización, etc. entre ellos; este programa es el GNU Mach. En nuestros sistemas GNU/Linux convencionales tenemos la máquina, sobre ella el linux y sobre éste las aplicaciones. Ahora, en un sistema GNU/Hurd (llamado símplemente: sistema GNU :D) tendremos la máquina, sobre ésta gnumach y hurd y las aplicaciones de usuario que realizaran las llamadas a los servidores de hurd. En parte, la lentitud del desarrollo de hurd se debe a que éste modelo de servidores es muy difícil de depurar.

Qué necesitamos

Pues instalado en el sistema: qemu (evidentemente).
A la hora de probar hurd me he encontrado con que al usar la aceleración de kqemu el sistema no arrancaba en la máquina virtual, por tanto no recomiendo instalarlo.
Aparte, necesitaremos una ISO (o el CD ya quemado) con una live que tenga grub, por ejemplo: molinux, gnesis, debian netinstall, etc. Finalmente necesitamos el CD de instalación de hurd, yo he usado: http://ftp.gnuab.org/pub/debian-cd/current/hurd-i386/debian-K14-hurd-i386-mini.iso No hace falta quemar la ISO, con bajarnos el archivo nos sobra ;).

Creando el sistema base

En primer lugar creamos un directorio donde guarrear:
$ mkdir hurdvm
$ cd hurdvm
$ wget http://ftp.gnuab.org/pub/debian-cd/current/hurd-i386/debian-K14-hurd-i386-mini.iso
Ahora crearemos nuestro disco duro falsete:
$ qemu-img create hd0.img 4G
Ya podemos arrancar nuestra máquina virtual, iniciando desde la ISO para ejecutar la instalación:
$ qemu -hda hd0.img -cdrom debian-K14-hurd-i386-mini.iso -boot d

Instalando el sistema

Un "bonito" menú nos va a permitir realizar la instalación de una forma fácil y cómoda, empezamos eligiendo la configuración de teclado (opción 1). Después comenzamos con el particionado (opción 2), donde seleccionamos nuestro disco virtual (/dev/hda en nuestro caso). Como no tenemos ninguna tabla de particiones ahí nos preguntará lo siguiente:
No partition table or unknown signature on partition table
Do you wish to start with a zero table [y/N]?
...y le diremos que (es decir, y). Ahora nos aparecerá cfdisk y crearemos dos particiones: la swap y la del sistema. Para ello seleccionamos New, Primary, un tamaño de unos 200MB, Beginning, Type e introducimos un 82. Ya tenemos la swap creada, ahora la partición del sistema: Seleccionamos Free Space (cursor abajo), New, Primary y el tamaño por defecto (el máximo posible); ya tenemos la segunda partición. Ahora seleccionamos Write, le decimos que yes y finalmente seleccionamos Quit. Ahora inicializamos y activamos la partición swap (opción 3) y le decimos que yes a las dos preguntas. Hacemos lo mismo con la partición GNU/Hurd (opción 4). Después de terminar el proceso nos preguntará si queremos montar esa partición como Root Filesystem, a lo que también diremos que Yes. Ahora ya podemos instalar el sistema base (opción 6) y seleccionamos como origen CD-ROM drive. Nos preguntará el punto de montaje del mismo, que es el que aparece por defecto. Cuando finalice, reinciamos la máquina virtual (opción 7) y cuando vuelva a aparecer lilo cerraremos qemu para cambiar las opciones de la máquina virtual y no usar esa imagen de CD.

Instalando GRUB

Ahora nos encontramos con un problema: este proceso prepara una partición y copia unos ficheros, pero no instala grub, por tanto no podemos iniciar nuestro disco virtual con qemu. La forma en la que yo he instalado grub es la siguiente: vamos a arrancar el liveCD con qemu de la misma forma que arrancábamos la instalación de hurd y restauraremos GRUB (en el ejemplo he usado el CD de instalación de debian):
$ qemu -hda hd0.img -cdrom debian-testing-i386-netinst.iso -boot d
Para continuar con el ejemplo, abriríamos una shell, montaríamos /dev/hda2 en /mnt y ejecutaríamos lo siguiente:
# grub-install /dev/hda --root-directory /mnt
Y con ello ya tendríamos instalado el gestor de arranque. Aunque no lo he dicho antes, es indispensable el gestor grub, cualquier otro como lilo o yaboot no nos sirve para nada. Una vez instalado, apagamos la máquina virtual y cerramos qemu, vamos a inciar por primera vez hurd.

Configurando nuestro sistema

Ahora arrancamos qemu ya sin imágenes de cd-rom, directamente desde nuestro disco virtual:
$ qemu -hda hd0.img
Para conseguir una mayor estabilidad de hurd dentro de qemu yo utilizo las siguientes opciones:
$ qemu -hda hd0.img -std-vga -no-acpi -net none
Y ahora, para empezar a usar nuestro nuevo sistema, debemos configurarlo primero: se tienen que crear los nodos para los dispositivos, configurar los paquetes base, etc. Arrancaremos el sistema en modo single, esto lo podemos hacer con los siguientes comandos en la shell de grub (a la que accedemos pulsando c estando en el menú de arranque):
grub> kernel (hd0,1)/boot/gnumach.gz root=device:hd0s2 -s
grub> module (hd0,1)/hurd/ext2fs.static --multiboot-command-line=${kernel-command-line} --host-priv-port=${host-port} --device-master-port=${device-port} --exec-server-task=${exec-task} -T typed ${root} $(task-create) $(task-resume)
grub> module (hd0,1)/lib/ld.so.1 /hurd/exec $(exec-task=task-create)
grub> boot
En cuanto a la notación de unidades de grub es la siguiente:
(hdD,P)
Donde D es el disco duro, empezando por 0 como primario maestro y 3 como secundario esclavo; y P es la partición, comenzando desde 0 para la primera partición. La notación en hurd es del estilo BSD, es decir:
hdDsP
Donde D es igual que en grub y P también es la partición pero comenzando desde 1 (igual que en grub pero sumando 1).
¡Y ahí va! comienza el arranque de nuestro sistema GNU. Ahora sólo nos queda ejecutar el script de autoconfiguración:
sh-3.1# ./native-install
Esto creará los dispositivos iniciales y configurará algunos paquetes iniciales; cuando termine, reiniciamos otra vez el sistema, volvemos a arrancar en modo single (la misma secuencia de comandos en el grub que antes) y volvemos a ejecutar el script para terminar de configurar el sistema y los paquetes:
sh-3.1# ./native-install
Nos preguntará por nuestra zona geográfica, indicaremos Europe (código 8 ) y después nuestra zona horaria, teclearemos Madrid. Continuará configurando paquetes, cuando finalice podremos reiniciar la máquina virtual y ya tenemos nuestro sistema gnu listo para funcionar!.

Arranque normal del sistema gnu

La secuencia de comandos de grub para arrancar el sistema de forma normal es:
grub> kernel (hd0,1)/boot/gnumach.gz root=device:hd0s2
grub> module (hd0,1)/hurd/ext2fs.static --multiboot-command-line=${kernel-command-line} --host-priv-port=${host-port} --device-master-port=${device-port} --exec-server-task=${exec-task} -T typed ${root} $(task-create) $(task-resume)
grub> module (hd0,1)/lib/ld.so.1 /hurd/exec $(exec-task=task-create)
grub> boot
Una vez arrancado nos aparecerá una shell que nos permite hacer login, podremos entrar como root:
login> login root
Y ya podemos empezar a guarrear con nuestro sistema gnu!! :)

Apéndice A: Menú de arranque para grub

Evidentemente es un rollo tener que escribir esos comandos tan largos en el grub para poder arrancar el sistema, éste es el menu que uso yo:
title GNU/Hurd
kernel (hd0,1)/boot/gnumach.gz root=device:hd0s2
module (hd0,1)/hurd/ext2fs.static --multiboot-command-line=${kernel-command-line} --host-priv-port=${host-port} --device-master-port=${device-port} --exec-server-task=${exec-task} -T typed ${root} $(task-create) $(task-resume)
module (hd0,1)/lib/ld.so.1 /hurd/exec $(exec-task=task-create)

title GNU/Hurd (single mode)
kernel (hd0,1)/boot/gnumach.gz root=device:hd0s2 -s
module (hd0,1)/hurd/ext2fs.static --multiboot-command-line=${kernel-command-line} --host-priv-port=${host-port} --device-master-port=${device-port} --exec-server-task=${exec-task} -T typed ${root} $(task-create) $(task-resume)
module (hd0,1)/lib/ld.so.1 /hurd/exec $(exec-task=task-create)
Pero he de decir que por alguna razón, puede ser que no arranque el sistema de esta forma (se queda congelado en el inicio), si sucede esto no hay más remedio que iniciar como se ha explicado antes: con los comandos en la shell de grub.

Apéndice B: Instalación nativa desde Debian

Si queremos ir más allá que ejecutar hurd en una máquina virtual, podemos instalarlo en nuestra propia máquina. Este proceso es aún más sencillo que el anterior, sólo necesitamos una partición de un par de gigas, por compatibilidad con todo lo anterior, supongamos que esa partición es /dev/hda2 en nuestro disco duro, primero la formateamos (debe ser de tipo 83 - linux):
# mke2fs -b 4096 -o hurd /dev/hda2
Ahora instalamos un paquetito muy chulo:
# apt-get install crosshurd
Este paquete nos permite realizar una instalación cross-system de diversos sistemas operativos. Montamos la partición formateada en algún sitio:
# mount /dev/hda2 /mnt/hurd -t ext2 
...y ejecutamos la instalación:
# crosshurd
Esto nos pedirá el punto de montaje, introducimos /mnt/hurd o el que hayamos usado y seleccionamos el tipo de instalación, gnu en nuestro caso. Esto copiará todos los archivos necesarios en esa partición. Una vez terminado añadimos los items en el archivo /boot/grub/menu.lst del apéndice A y realizamos el proceso de configuración de la misma forma que lo hacíamos en la máquina virtual.
Es muy normal que hurd no arranque y se quede colgado en el inicio, esto se debe a que aún no está implementada la capacidad de cargar/descargar módulos del núcleo, por tanto se compilan todos de forma estática, esto provoca que en determinados hardwares se quede colgado, la única solución es recompilar hurd para la máquina específica... que esto puede ser motivo para una nueva receta :P

Enlaces

Gracias a nuestro amigo Arturo, si no queremos instalar ni configurar nada, sólamente queremos probar hurd sobre qemu podemos usar la imagen de este blog: Zaborowski. Hay muchos más enlaces... todos los podéis encontrar a partir del enlace en Debian. Espero que os sea útil o por lo menos tan entretenido como a mi! ;)

Máquinas PPC

Cuando uclmwifi y euroroam soporten pump y se hiele el infierno }:).


blog comments powered by Disqus