Proceso de arranque en Linux

El proceso de arranque en GNU/Linux es la forma en la cual los sistemas operativos basados en el

núcleo Linux se inicializan. Es similar a la forma en que arranca BSD y otros sistemas Unix.

Todo el proceso de arranque se lleva a cabo en 4 etapas reconocidas por el código que en ese
momento tiene control sobre la CPU; al inicio solo el BIOS tiene control, después será el cargador
de arranque quien tenga en control, más adelante el control pasa al propio kernel Linux, y en la
última etapa será cuando tengamos en memoria los programas de usuario conviviendo junto con el
propio sistema operativo y serán ellos quienes tengan el control del CPU.

La etapa del cargador de arranque no es totalmente necesaria, determinadas BIOS pueden cargar
y pasar el control a GNU/Linux sin hacer uso del cargador de arranque, usar un cargador de
arranque facilita al usuario la forma en que el kernel será cargado.

BIOS
Al encender la computadora las primeras operaciones las realiza el BIOS. En esta etapa se
realizan operaciones básicas de hardware. El proceso de arranque será diferente dependiendo de
la arquitectura del procesador y el BIOS.

Una vez reconocido y listo el hardware, el BIOS carga en memoria el código ejecutable del
cargador de arranque y le pasa el control. Hay variedad de BIOS que permiten al usuario definir en
qué dispositivo/partición se encuentra dicho cargador de arranque.
Cargador de arranque
Un cargador de arranque (boot loader en inglés) es un programa diseñado exclusivamente para
cargar un sistema operativo en memoria. La etapa del cargador de arranque es diferente de una
plataforma a otra.

Como en la mayoría de arquitecturas, este programa se encuentra en el MBR, el cual es de 512

bytes, no es suficiente para cargar en su totalidad un sistema operativo. Por eso, el cargador de
arranque consta de varias etapas.

Para las plataformas x86, el BIOS carga la primera etapa del cargador de arranque (típicamente
una parte de LILO o GRUB). El código de esta primera etapa se encuentra en el sector de
arranque (o MBR). La primera etapa del cargador de arranque carga el resto del cargador de
arranque.

Los cargadores de arranque modernos típicamente preguntan al usuario cual sistema operativo (o
tipo de sesión) desea inicializar.

GRUB
GRUB se carga y se ejecuta en 4 etapas:

1.La primera etapa del cargador la lee el BIOS desde el MBR.

2.La primera etapa carga el resto del cargador (segunda etapa). Si la segunda etapa está en un
dispositivo grande, se carga una etapa intermedia (llamada etapa 1.5), la cual contiene código
extra que permite leer cilindros mayores que 1024 o dispositivos tipo LBA.
3.La segunda etapa ejecuta el cargador y muestra el menú de inicio de GRUB. Aquí se permite
elegir un sistema operativo junto con parámetros del sistema.
4.Cuando se elige un sistema operativo, se carga en memoria y se pasa el control.
GRUB soporta métodos de arranque directo, arranque chain-loading, LBA, ext2 y hasta "un pre-
sistema operativo totalmente basado en comandos". Tiene tres interfaces: un menú de selección,
un editor de configuración y una consola de línea de comandos.

Dado que GRUB entiende los sistemas de archivos ext2 y ext3 y además provee una interfaz de
línea de comandos, es más fácil rectificar o modificar cuando se malconfigura o se corrompe. La
nueva versión 2 de GRUB, soporta sistema de archivos ext4.

LILO
LILO es más antiguo, es casi idéntico a GRUB en su proceso, excepto que no contiene una interfaz
de línea de comandos. Por lo tanto todos los cambios en su configuración deben ser escritos en el
MBR, y reiniciar el sistema. Un error en la configuración puede arruinar el proceso de arranque a
tal grado de que sea necesario usar otro dispositivo que contenga un programa que sea capaz de
arreglar ese defecto.

De forma adicional, LILO no entiende sistema de archivos, por lo tanto no hay archivos y todo se
almacena en el MBR directamente.

Cuando el usuario selecciona una opción del menú de carga de LILO, dependiendo de la
respuesta, carga los 512 bytes del MBR para sistemas como Microsoft Windows, o la imagen del
kernel Linux.
Loadlin
Otra forma de cargar GNU/Linux es desde DOS o Windows 9x, dado que ambos sistemas permiten
ser reemplazados, se puede reemplazar por el kernel Linux sobre el sistema operativo ya cargado.
Esto puede ser útil en el caso en que el hardware está solo disponible para DOS y no para
GNU/Linux, dado a cuestiones de secretos industriales y código propietario. Sin embargo, esta
tediosa forma de arranque ya no es necesaria en la actualidad ya que GNU/Linux tiene drivers para
multitud de dispositivos hardware, aun así, esto fue muy útil en el pasado.

Otro caso es cuando GNU/Linux se encuentra en un dispositivo que el BIOS no lo tiene disponible
para el arranque. Entonces, DOS o Windows pueden cargar el driver apropiado para dicho
dispositivo superando dicha limitación del BIOS, y a partir de entonces cargar el núcleo Linux.

Kernel
El kernel Linux se encarga de lo principal del sistema operativo, como el manejo de memoria,
planificador de tareas, entradas y salidas, comunicación interprocesos, y demás sistemas de
control.

El proceso del kernel se lleva en dos etapas; la etapa de carga y la etapa de ejecución.

El kernel generalmente se almacena en un archivo comprimido con zlib. Este archivo comprimido
se carga y se descomprime en memoria, también se cargan los drivers necesarios por medio de un
disco RAM (initrd). El disco RAM es un sistema de archivos temporal usado en la fase de ejecución
del kernel.

Una vez que el kernel se ha cargado en memoria y está listo, se lleva a cabo su ejecución. Esto se
realiza llamando la función startup del kernel (en los procesadores x86, se encuentra en la función
startup_32() del archivo /arch/i386/boot/head), esta función establece el manejo de memoria (tablas
de paginación y paginación de memoria), detecta el tipo del CPU y funcionalidad adicional como
capacidades de punto flotante. Después cambia a funcionalidades que no dependen del hardware
por medio de la llamada a la función start_kernel().

El proceso de arranque en GNU/Linux monta el disco RAM que fue cargado anteriormente como
un sistema de archivos temporal. Esto permite que los módulos que contienen drivers puedan ser
cargados sin depender de otros drivers de dispositivos físicos, y además mantiene el kernel más
pequeño.
Se inicializan dispositivos virtuales con la intención de ser usados para crear sistemas de archivos,
como LVM o software RAID antes de desmontar la imagen initrd. El sistema de archivos es
cambiado por medio de la función pivot_root() la cual desmonta el sistema de archivos temporal y
lo reemplaza con el real, el cual más tarde estará totalmente disponible liberando la memoria que
ocupaba el temporal.

Una vez listo el manejador de excepciones, el planificador de tareas y demás, por fin el sistema se
considera totalmente operacional a nivel de procesos, por lo tanto se ejecuta el proceso init (el
primer proceso en espacio de usuario), y luego inicia una tarea de inactividad por medio de
cpu_idle().

Proceso init
El proceso init establece el entorno de usuario. Verifica y monta los sistemas de archivos, inicia
servicios de usuario necesarios y cambia a un entorno basado en usuario cuando el proceso de
inicio termina.

Es similar a los procesos init de Unix y BSD del cual deriva, pero en algunos casos tiene
diferencias y personalizaciones. En un sistema GNU/Linux estándar, init se ejecuta con un
parámetro, conocido como runlevel, que toma un valor de 0 a 6, y que determina cuales
subsistemas serán operacionales.

Cada runlevel tiene sus propios scripts los cuales involucran un conjunto de programas. Estos
scripts se guardan en directorios con nombres como "/etc/rc...". El archivo de configuración de init
es /etc/inittab.

Cuando el sistema se arranca, se verifica si existe un runlevel predeterminado en el archivo

/etc/inittab, si no, se debe introducir por medio de la consola del sistema. Después se procede a
ejecutar todos los scripts relativos al runlevel especificado.