Arch boot process (Español)

From ArchWiki
Revision as of 09:15, 21 September 2012 by Pedro (Talk | contribs) (Actualización: 2012-09-21)

Jump to: navigation, search

Template:Article summary start Template:Article summary text Template:Article summary heading Template:Article summary text Template:Article summary heading Template:Article summary wiki Template:Article summary wiki Template:Article summary wiki Template:Article summary end

Este artículo pretende describir el orden cronológico del proceso de arranque del Arch y de los archivos involucrados, proporcionando enlaces a artículos de la wiki pertinentes cuando sea necesario. Arch como BSD utiliza init, contrariamente al más común SysV. Esto implica una leve distinción entre los niveles de ejecución, dado que el sistema por defecto está configurado para utilizar los mismos módulos y los mismos procesos en todos los niveles de ejecución. La ventaja es que los usuarios tienen una forma sencilla de configurar el proceso de inicio (consulte rc.conf); la desventaja es que algunas opciones de configuración interesantes que ofrece SysV se pierden. Consulte la guía sobre cómo agregar niveles de ejecución para poder utilizar algunas opciones de SysV en Arch. Consulte Wikipedia:init para más información sobre las diferencias entre SysV y el método BSD.

Antes de init

Después de que el sistema está encendido y el POST se ha completado, los BIOS identifica el dispositivo configurado para arrancar y pasa el control al sector de arranque Master Boot Record de este dispositivo. En una máquina GNU/Linux a menudo se instala en el MBR un gestor de arranque como GRUB o LILO. El gestor de arranque presenta al usuario una gama de opciones para el arranque, por ejemplo, Arch Linux y Windows configurando un arranque dual. Una vez que se ha seleccionado Arch, el bootloader carga el kernel (vmlinuz-linux) y el ramdisk inicial (initramfs-linux.img) en la memoria y luego se inicializa el kernel, pasando la dirección a la memoria de la imagen.

El kernel es el núcleo de un sistema operativo. Funciona en un nivel bajo (kernelspace) que interactúan entre el hardware de la máquina y los programas que requieren los recursos para funcionar. Para hacer un uso eficiente de la CPU, el kernel utiliza un sistema de programación para arbitrar qué tareas tienen prioridad en un momento dado, creando la ilusión (para la precepción humana) que varias tareas se están ejecutando simultáneamente.

Después de estar cargado, el Kernel descomprime el initramfs (sistema de archivos RAM inicial), el cual se convierte en el sistema de archivos del root inicial. El kernel, seguidamente, ejecuta /init como primer proceso. El early userspace comienza.

El propósito de initramfs es arrancar el sistema hasta el punto donde se puede acceder al sistema de archivos raíz (consulte FHS para más detalles). Esto significa que los módulos que se requieren para dispositivos como IDE, SCSI, SATA (o USB/FireWire, si se efectúa el arranque desde una de estas unidades) deben ser cargables desde el initramfs si no están compilados en el kernel; una vez que los módulos necesarios se cargan (ya sea a través de un programa, ya sea a través de un script que tramite udev), el proceso de arranque continúa. Por esta razón, el initramfs sólo debe contener los módulos necesarios para acceder al sistema de archivos raíz, no tiene por qué contener todos los módulos que sirven al completo funcionamiento de la máquina. La mayoría de los módulos se cargarán más tarde por udev, durante la fase init.

En la etapa final del early userspace, la verdadera raíz está montada, y reemplaza al sistema de archivos raíz inicial. /sbin/init se ejecuta, sustituyendo el proceso /init.

Consulte también: Early Userspace en Arch Linux

Init y los scripts de arranque de Arch

El principal proceso de arranque del Arch es iniciado por el programa init, que genera todos los demás procesos. El propósito de init es llevar el sistema a un estado que pueda ser utilizado, sirviéndose de los scripts de arranque para hacerlo. Como se mencionó anteriormente, Arch utiliza los script de arranque similares a los de BSD. init lee el archivo /etc/inittab; el archivo inittab, por defecto, comienza con lo siguiente:

/etc/inittab
...

# Boot to console
id:3:initdefault:
# Boot to X11
#id:5:initdefault:

rc::sysinit:/etc/rc.sysinit
rs:S1:wait:/etc/rc.single
rm:2345:wait:/etc/rc.multi
rh:06:wait:/etc/rc.shutdown
su:S:wait:/sbin/sulogin

...

La primera línea no comentada define el nivel de ejecución por defecto del sistema (3). Cuando el kernel llama a init:

  • En primer lugar, el script de inicialización principal se ejecuta, /etc/rc.sysinit (un script Bash).
  • Seguidamente, si se inicia en modo monousuario (nivel 1 ó S), el script /etc/rc.single será lanzado.
  • Si, por el contrario, se ejecuta otro nivel (2-5), será lanzado en su lugar /etc/rc.multi.
  • La última secuencia de comandos a ejecutar es /etc/rc.local (a través de /etc/rc.multi) que está vacío de forma predeterminada.
Nota: Usted puede obtener mas información acerca de init e inittab aquí

/etc/rc.sysinit

El archivo etc/rc.sysinit es un gran script que se ocupa de toda la configuración del hardware, y realiza tareas generales de inicialización. Puede ser identificado por una de sus primeras tareas, imprimiendo las líneas:

Arch Linux
http://www.archlinux.org

Las tareas de rc.sysinit son los siguientes:

  1. Incluir el archivo /etc/rc.conf.
  2. Incluir el archivo de script /etc/rc.d/functions.
  3. Mostrar un mensaje de bienvenida.
  4. Montar varios sistemas de archivos virtuales.
  5. Asegurarse que rootfs se monta en sólo lectura (si es necesario).
  6. Iniciar bootlogd.
  7. Mostrar advertencias de desaprobación.
  8. Configurar el reloj del hardware.
  9. Iniciar udev, cargar módulos desde la matriz MODULES definidos en rc.conf, y esperar a que termine de procesar udev eventos coldplug.
  10. Iniciar la interfaz de loopback .
  11. Configurar RAID, btrfs y las asignaciones del sistema de archivos cifrados.
  12. Verificar particiones (fsck).
  13. Volver a montar rootfs con el fin de aplicar las opciones de /etc/fstab.
  14. Montar sistemas de archivos locales (unidades de red no se montan antes de un perfil de red está arriba).
  15. Iniciar la supervisión de los grupos de volúmenes LVM.
  16. Activar áreas swaps .
  17. Configurar la zona horaria.
  18. Inicializar la semilla random.
  19. Eliminar los residuos de los diversos archivos temporales, como /tmp/*.
  20. Ajustar el nombre de la máquina (hostname), locale y reloj del sistema tal como se define en rc.conf.
  21. Configurar locale, la consola y la distribución del teclado.
  22. Establecer la fuente de la consola.
  23. Escribir la salida del comando en /var/log/dmesg.log.

/etc/rc.sysinit es un script y no un archivo de configuración. Ésto incluye (cuando obtiene las variables de) rc.conf para las configuracines y /etc/rc.d/functions para las funciones que producen salida gráfica (colores, alineaciones, cambiar del demonio 'busy' a 'done', etc.) Este archivo no debe modificarse manualmente dado que se sobreescribe en la actualización de initscripts. Para añadir personalizaciones es aconsejable utilizar los hooks como se describe a continuación.

/etc/rc.single

La modalidad de usuario único (single-user mode) se iniciará como usuario root y sólo debe utilizarse si el sistema no puede arrancar normalmente o en caso de recuperación del sistema. Este script asegura que no se inicien otros demonios que no sean los esenciales: syslog-ng y udev. El modo single-user es útil para la recuperación del sistema impidiendo a usuarios remotos conectarse previniendo así que puedan hacer cualquier cosa que pudiera causar pérdida de datos o daños. En el modo de un solo usuario, los usuarios pueden volver a acceder a la sesión normal (multi-user) escribiendo "exit" en el prompt del sistema.

/etc/rc.multi

/etc/rc.multi se ejecuta por todos los runlevel multiusuario (esto es, 2, 3, 4, y 5), es decir, en cada arranque normal. Por lo general, los usuarios no se dan cuenta de la transición de rc.sysinit a rc.multi porque también utiliza /etc/rc.d/functions para el manejo de video. Este script:

  1. inicia sysctl (para modificar los parámetros del kernel en runtime) haciendo referencia a la configuración presente en /etc/sysctl.conf. Arch tiene muy pocas opciones de éstos por defecto (principalmente la configuración de red).
  2. se ocupa de iniciar los demonios, según lo dispuesto en la matriz DAEMONS en rc.conf.
  3. ejecuta /etc/rc.local para tratar las personalizaciones de usuario.

/etc/rc.local

/etc/rc.local es el script del arranque local para las sesiones multiusuarios. Vacío por defecto, es un buen lugar donde insertar eventuales comandos de última hora que deben ser iniciados al final del proceso de arranque. La mayoría de las tareas comunes de configuración del sistema (carga de módulos, cambio de fuente de consola, encendido de periféricos), por lo general, tienen un lugar especial en el que se introducen. Para evitar confusiones, asegúrese de que los comandos introducidos en rc.local no sea posible insertarlos en /etc/profile.d, o en cualquier otro archivo de configuración.

Al editar este archivo, tenga en cuenta que se ejecutará después de la configuración básica (módulos/demonios), se iniciará como usuario root, y tanto si el servidor gráfico (X) se inicia como si no. En este ejemplo, el archivo rc.local se utiliza para quitar el silencio a algunos canales de audio de ALSA:

/etc/rc.local
#!/bin/bash

# /etc/rc.local: Local multi-user startup script.

amixer sset 'Master Mono' 50% unmute &> /dev/null
amixer sset 'Master' 50% unmute &> /dev/null
amixer sset 'PCM' 75% unmute &> /dev/null

Hooks personalizados

Los Hooks se pueden usar para incluir códigos personalizados en varias partes del script rc.*

Nombre del Hook Tiempo de ejecución del hook
sysinit_start Al comienzo de rc.sysinit
sysinit_udevlaunched Después que udev ha sido lanzado en rc.sysinit
sysinit_udevsettled Después que uevents se ha estabilizado en rc.sysinit
sysinit_prefsck Antes que fsck se ejecute en rc.sysinit
sysinit_postfsck Después que fsck se ejecute en rc.sysinit
sysinit_premount Antes que los sistemas de archivos locales sean montados, pero después de que la raíz está montada en modo lectura y escritura en rc.sysinit
sysinit_end Al final de rc.sysinit
multi_start Al comienzo de rc.multi
multi_end Al final de rc.multi
single_start Al comienzo de rc.single
single_prekillall Antes que todos los procesos estén terminando en rc.single
single_postkillall Después que todos los procesos estén terminando en rc.single
single_udevlaunched Después que udev ha sido lanzado en rc.single
single_udevsettled Después que uevents se ha estabilizado en rc.single
single_end Al final de rc.single
shutdown_start Al comienzo de rc.shutdown
shutdown_prekillall Antes que todos los procesos que están acabando en rc.shutdown
shutdown_postkillall Después que todos los procesos han acabado en rc.shutdown
shutdown_preumount Después de la última escritura del sistema de archivos (demonios han sido terminados), antes de desmontar el sistema de archivos
shutdown_postumount Después que los sistemas de archivos se han desmontado
shutdown_poweroff Justo antes de apagar en rc.shutdown

Para definir una función hook, cree un archivo en /etc/rc.d/functions.d usando:

function_name() {
   ...
}
add_hook hook_name function_name

Los archivos en /etc/rc.d/functions.d proceden de /etc/rc.d/functions. Se pueden registrar múltiples funciones hooks para el mismo hook, así como registrar la misma función hook por hook múltiples. No defina funciones denominadas add_hook o run_hook en estos archivos, ya que están definidas en /etc/rc.d/functions.

Ejemplo

Agregando el siguiente archivo se permite la desactivación de la caché write-back en un disco duro antes que todos los daemons se inicien (útil para unidades que contienen archivos de MySQL InnoDB).

/etc/rc.d/functions.d/hd_settings
hd_settings() {
    /sbin/hdparm -W0 /dev/sdb
}
add_hook sysinit_udevsettled hd_settings
add_hook single_udevsettled  hd_settings

En primer lugar, se define la función hd_settings, y luego la registra para los hooks single_udevsettled y sysinit_udevsettled. La función se llamará inmediatamente después que uvents se haya estabilizado en /etc/rc.d/rc.sysinit o /etc/rc.d/rc.single.

init: Login

Por defecto, después que los scripts de arranque de Arch se han completado, el programa /sbin/agetty pide a los usuarios el nombre del login. Después que el nombre de usuario se recibe, /sbin/agetty solicita /bin/login el cual solicita la contraseña.

Finalmente, una vez efectuado el acceso, /bin/login iniciará la shell predeterminada del usuario. El shell por defecto y las variables de entorno pueden ser definidos en el archivo /etc/profile. Todas las variables dentro del directorio personal tendrán prioridad para sustituir las definidas en /etc. Por ejemplo, si una misma variable está definida en /etc/profile y en ~/.bashrc, la definida en ~/.bashrc prevalecerá.

Otras alternativas son mingetty, que permite el inicio de sesión automático (agetty tiene la opción de inicio de sesión automático a partir de la versión 2.20 con util-linux) o rungetty, donde el primero permite auto-login y el segundo la ejecución automática de comandos y programas, por ejemplo htop.

La mayoría de los usuarios que deseen iniciar un servidor gráfico X durante el proceso de arranque, deberían instalar un gestor de ventanas para efectuar el acceso (consulte Display Manager para más detalles). Alternativamente, este artículo describe métodos que no implican un gestor de ventanas.

Véase también