Proceso de arranque en Linux

El proceso de arranque en Linux es el proceso de inicialización del sistema operativo que realiza el núcleo Linux, el programa en el sistema que asigna los recursos de la máquina a los otros programas que ejecuta.

Proceso típico

En Linux, el flujo de control durante el arranque es desde el firmware al gestor de arranque y al núcleo (kernel). El núcleo inicia el planificador (para permitir la multitarea) y ejecuta el primer espacio de usuario (es decir, fuera del espacio del núcleo) y el programa de inicialización (que establece el entorno de usuario y permite la interacción del usuario y el inicio de sesión), momento en el que el núcleo se inactiva hasta que sea llamado externamente.

La etapa del cargador de arranque no es totalmente necesaria. Determinadas BIOS pueden cargar y pasar el control a Linux sin hacer uso del cargador. Cada proceso de arranque será diferente dependiendo de la arquitectura del procesador y el BIOS.

El BIOS realiza las tareas de inicio específicas de la plataforma de hardware.
Una vez que el hardware es reconocido y se inicia correctamente, el BIOS carga y ejecuta el código de la partición de arranque del dispositivo de arranque designado, que contiene la fase 1 de un gestor de arranque Linux. La fase 1 carga la fase 2 (la mayor parte del código del gestor de arranque). Algunos cargadores pueden utilizar una fase intermedia (conocida como la fase 1.5) para lograr esto, ya que los modernos discos de gran tamaño no pueden ser totalmente leídos sin código adicional.
El gestor de arranque a menudo presenta al usuario un menú de opciones posibles de arranque. A continuación, carga el sistema operativo, que descomprime en la memoria, y establece las funciones del sistema como del hardware esencial y la paginación de memoria, antes de llamar a la función start_kernel().
La función start_kernel() a continuación realiza la mayor parte de la configuración del sistema (interrupciones, el resto de la gestión de memoria, la inicialización del dispositivo, controladores, etc), antes de continuar por separado el proceso inactivo y planificador, y el proceso de Init (que se ejecuta en el espacio de usuario).
El planificador toma control efectivo de la gestión del sistema, y el núcleo queda dormido (inactivo).
El proceso Init ejecuta secuencias de comandos (Scripts) necesarios para configurar todos los servicios y estructuras que no sean del sistema operativo, a fin de permitir que el entorno de usuario sea creado y pueda presentarse al usuario con una pantalla de inicio de sesión

Para los dispositivos con arranque mediante UEFI, el cargador de arranque se almacena como ejecutable EFI en la partición ESP. EFISTUB es una característica del núcleo Linux que permite ejecutarse a sí mismo mediante la incrustación de código que lo convierte en un ejecutable EFI; los parámetros son pasados al núcleo mediante variables EFI, y este debe ser capaz de encontrar y cargar el archivo initrd.

En el apagado, Init es llamado a cerrar toda las funcionalidades del espacio de usuario de una manera controlada, de nuevo a través de secuencias de comandos, tras lo cual el Init termina y el núcleo ejecuta el apagado.

Espacio de usuario temprano

El espacio de usuario temprano se utiliza en las versiones más recientes del núcleo Linux para sustituir tantas funciones como sea posible que originalmente se harían en el núcleo durante el proceso de inicio. Los usos típicos del espacio de usuario temprano son para detectar que controladores de dispositivos (Drivers) son necesarios para cargar el sistema de archivos del espacio de usuario principal y cargarlos desde un sistema de archivos temporal.

Fase del 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, este espacio no es suficiente para cargar en su totalidad un sistema operativo. Por eso, el cargador de arranque consta de varias etapas. Las primeras operaciones las realiza el BIOS. En esta etapa se realizan operaciones básicas de hardware. En esta primera etapa se localiza el sector de arranque (o MBR) y se carga el cargador de este sector (normalmente una parte de LILO o GRUB).

A partir de ese momento, el proceso de arranque continúa de la siguiente manera:

La primera etapa del cargador de arranque carga el resto del gestor de arranque, que normalmente da un mensaje que pregunta que sistema operativo (o tipo de sesión) el usuario desea inicializar. Bajo LILO, esto se hace a través del mapa instalado que lee el archivo de configuración /etc/lilo.conf para identificar los sistemas disponibles. Incluye datos como la partición de arranque y la localización del kernel para cada uno, así como las opciones personalizadas en su caso. El sistema operativo seleccionado es cargado en la memoria RAM, un sistema de archivos mínimo inicial se establece en la memoria RAM desde un archivo de imagen (" initrd "), y junto con los parámetros adecuados, el control se pasa al sistema operativo activado recientemente.

LILO y GRUB difieren en algunos aspectos:

LILO no entiende los sistemas de archivos, por lo que utiliza desplazamientos de disco sin procesar y el BIOS para cargar los datos. Se carga el código del menú y, a continuación, en función de la respuesta, carga, o el sector MBR del disco de 512 bytes como en Microsoft Windows, o la imagen del núcleo Linux.
GRUB por el contrario comprende los sistemas de archivos comunes ext2, ext3 y ext4. Debido a que GRUB almacena sus datos en un archivo de configuración en vez de en el MBR y a que contiene una interfaz de línea de comandos, a menudo es más fácil rectificar o modificar GRUB si está mal configurado o corrupto.

GRUB

GRUB se carga y se ejecuta en 4 etapas:

La primera etapa del cargador la lee el BIOS desde el MBR.
La primera etapa carga el resto del gestor de arranque (segunda etapa). Si la segunda etapa está en una unidad grande, en ocasiones se carga una fase intermedia 1.5, que contiene código adicional para permitir que los cilindros por encima de 1024, o unidades tipo LBA, puedan leerse. El gestor de arranque 1.5 es almacenado (si es necesario) en el MBR o en la partición de arranque.
La segunda etapa del gestor de arranque ejecuta y muestra el menú de inicio de GRUB que permite al usuario elegir un sistema operativo y examinar y modificar los parámetros de inicio.
Después de elegir un sistema operativo, se carga y se le pasa el control.

GRUB soporta métodos de arranque directo, arranque chain-loading, LBA, ext2, ext3, ext4 y hasta "un pre-sistema operativo en máquinas x86 totalmente basado en comandos". Contiene tres interfaces: un menú de selección, un editor de configuración y una consola de línea de comandos.

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 luego reiniciar el sistema. Un error en la configuración puede dejar el disco inservible para el proceso de arranque hasta tal grado, que sea necesario usar otro dispositivo (disquete, etc) que contenga un programa capaz de arreglar el error. Además, no entiende el sistema de archivos. En su lugar, la ubicación de los archivos de imagen se almacenan directamente en el MBR y el BIOS se utiliza para acceder a ellos directamente.

Loadlin

Otra forma de cargar Linux es desde DOS o Windows 9x, donde el núcleo Linux reemplaza completamente la copia de funcionamiento de estos sistemas operativos. Esto puede ser útil en el caso de hardware que necesita ser conectado a través del software y la configuración de estos programas solo está disponible para DOS y no para Linux, debido 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 Linux tiene drivers para multitud de dispositivos hardware. Aun así, esto era muy útil en el pasado.

Otro caso es cuando 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 el dispositivo superando dicha limitación del BIOS, y cargar Linux desde allí.

Fase del kernel

El kernel de Linux se encarga de todos los procesos del sistema operativo, como la gestión de memoria, planificador de tareas, I/O, comunicación entre procesos, y el control general del sistema. Este se carga en dos etapas: en la primera etapa el kernel (como un archivo imagen comprimido) se carga y se descomprime en memoria, y algunas funciones fundamentales como la gestión de memoria de base se establecen. El control entonces se cambia a la etapa final para iniciar el kernel principal. Una vez que el núcleo está en pleno funcionamiento - y como parte de su puesta en marcha, después de ser cargado y ejecutado - el kernel busca un proceso de inicio para ejecutar, que (separadamente) fija un espacio de usuario y los procesos necesarios para un entorno de usuario y ultimar la entrada . Al núcleo en sí entonces se le permite pasar a inactivo, sujeto a las llamadas de otros procesos.

Fase de carga del kernel

El kernel es cargado normalmente como un archivo imagen, comprimido dentro de otro con zlib como zImage o bzImage. Contiene una cabecera de programa que hace una cantidad mínima de instalación del hardware, descomprime la imagen completamente en la memoria alta, teniendo en cuenta cualquier disco RAM si está configurado. A continuación, lleva a cabo su ejecución. Esto se realiza llamando la función startup del kernel (en los procesadores x86 a través de la función startup_32() del archivo /arch/i386/boot/head).

Fase de inicio del kernel

La función de arranque para el kernel (también llamado intercambiador o proceso 0) establece la gestión de memoria (tablas de paginación y paginación de memoria), detecta el tipo de CPU y cualquier funcionalidad adicional como capacidades de punto flotante, y después cambia a las funcionalidades del kernel para arquitectura no específicas de Linux, a través de una llamada a la función start_kernel().

start_kernel ejecuta una amplia gama de funciones de inicialización. Establece el manejo de interrupciones (IRQ), configura memoria adicional, comienza el proceso de inicialización (procesa el espacio del primer usuario), y luego comienza la tarea inactiva a través de cpu_idle(). En particular, el proceso de inicio del kernel también monta el disco RAM inicial ("initrd") que se ha cargado anteriormente como el sistema raíz temporal durante la fase de arranque. Esto permite que los módulos controladores se carguen sin depender de otros dispositivos físicos y drivers y mantiene el kernel más pequeño. El sistema de archivos raíz es cambiado más tarde a través de la llamada a pivot_root(), que desmonta el sistema de archivos temporal y lo reemplaza por el real una vez que éste sea accesible. La memoria utilizada por el sistema de archivos temporal es entonces recuperada.

Por lo tanto, el núcleo inicializa los dispositivos, monta el sistema de archivos raíz especificado por el gestor de arranque como de solo lectura, y se ejecuta Init (/sbin/init), que es designado como el primer proceso ejecutado por el sistema (PID=1). También puede ejecutar opcionalmente initrd para permitir instalar y cargar dispositivos relacionados (disco RAM o similar), para ser manipulados antes de que el sistema de archivos raíz está montado.

En este punto, con las interrupciones habilitadas, el programador puede tomar el control de la gestión general del sistema, para proporcionar multitarea preventiva, e iniciar el proceso para continuar con la carga del entorno de usuario en el espacio de usuario.

El proceso de inicio

El trabajo de Init es "conseguir que todo funcione como debe ser" una vez que el kernel está totalmente en funcionamiento. En esencia, establece y opera todo el espacio de usuario. Esto incluye la comprobación y montaje de sistemas de archivos, la puesta en marcha de los servicios de usuario necesarios y, en última instancia, cambiar al entorno de usuario cuando el inicio del sistema se ha completado. Es similar a los procesos Init de Unix y BSD, de la que deriva, pero en algunos casos se ha apartado o se hicieron a la medida. En un sistema Linux estándar, Init se ejecuta con un parámetro, conocido como nivel de ejecución, que tiene un valor entre 1 y 6, y que determina qué subsistemas pueden ser operacionales. Cada nivel de ejecución tiene sus propios scripts que codifican los diferentes procesos involucrados en la creación o salida del nivel de ejecución determinado, y son estas secuencias de comandos los necesarios en el proceso de arranque. Los scripts de Init se localizan normalmente en directorios con nombres como "/etc/rc...". El archivo de configuración de más alto nivel para Init es /etc/inittab.

Durante el arranque del sistema, se verifica si existe un nivel de ejecución 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 nivel de ejecución especificado.

Después de que se han dado lugar todos los procesos especificados, Init se aletarga, y espera a que uno de estos tres eventos sucedan:- que procesos comenzados finalicen o mueran; un fallo de la señal de potencia (energía); o una petición a través de /sbin/telinit para cambiar el nivel de ejecución.

Enlaces externos

El código de un IPL en GNU ensamblador

Datos: Q1068500