---
title: Capítulo 12. El proceso de arranque en FreeBSD
part: Parte III. Administración del sistema
prev: books/handbook/config
next: books/handbook/users
showBookMenu: true
weight: 16
params:
  path: "/books/handbook/boot/"
---

[[boot]]
= El proceso de arranque en FreeBSD
:doctype: book
:toc: macro
:toclevels: 1
:icons: font
:sectnums:
:sectnumlevels: 6
:sectnumoffset: 12
:partnums:
:source-highlighter: rouge
:experimental:
:images-path: books/handbook/boot/

ifdef::env-beastie[]
ifdef::backend-html5[]
:imagesdir: ../../../../images/{images-path}
endif::[]
ifndef::book[]
include::shared/authors.adoc[]
include::shared/mirrors.adoc[]
include::shared/releases.adoc[]
include::shared/attributes/attributes-{{% lang %}}.adoc[]
include::shared/{{% lang %}}/teams.adoc[]
include::shared/{{% lang %}}/mailing-lists.adoc[]
include::shared/{{% lang %}}/urls.adoc[]
toc::[]
endif::[]
ifdef::backend-pdf,backend-epub3[]
include::../../../../../shared/asciidoctor.adoc[]
endif::[]
endif::[]

ifndef::env-beastie[]
toc::[]
include::../../../../../shared/asciidoctor.adoc[]
endif::[]

[[boot-synopsis]]
== Sinopsis

Al proceso de inicio del sistema y carga del sistema operativo se le conoce como "mecanismo de arranque" (bootstrap), o simplemente "arranque" (booting). El proceso de arranque de FreeBSD provee de gran flexibilidad al configurar lo que ocurre cuando se inicia el sistema, permitiendole seleccionar de diferentes sistemas operativos instalados en el mismo ordenador, o inclusive diferentes versiones del mismo sistema oprativo o kernels instalados.

Este capítulo detalla las opciones de configuración que puede manejar y como personalizar el proceso de arranque de FreeBSD. Esto incluye todo lo que sucede hasta que el kernel de FreeBSD comienza con la comprobación de dispositivos y se inicializa man:init[8]. En caso de que usted desconozca cuando ocurre todo esto, esto sucede cuando el color del texto que aparece al iniciar el sistema, cambia de blanco a gris.

Una vez que concluya con la lectura de este capítulo, usted sabrá:

* Cuales son los componentes del mecanismo de arranque de FreeBSD, y como es que interactuan entre sí.
* Las opciones que puede manejar con los componentes del mecanismo de arranque de FreeBSD, para controlar el proceso de inicio del sistema.

[NOTE]
.Sólo x86
====
El presente capítulo describe únicamente el proceso de inicio, para sistemas FreeBSD que corren en plataformas Intel x86.
====

[[boot-introduction]]
== El problema que representa arrancar el sistema

El encender una computadora e iniciar el sistema operativo, trae consigo un dilema interesante. Por definición, la computadora no sabe hacer nada, hasta que el sistema operativo ha sido cargado. Esto incluye la ejecución de programas desde el disco duro. Así que este es el dilema; si la computadora no sabe hacer nada hasta que se cargue el sistema operativo, y el sistema operativo es un conjunto de programas que residen en el disco duro, ?Cómo es que arranca el sistema operativo?

Este problema se asemeja a un problema del libro Las Aventuras del Barón Munchausen. Donde un personaje ha caido parcialmente en un hoyo, y ha podido salir al tomarse de las cintas de sus botas y jalarse hacia fuera. En los años mozos de la computación, el término utilizado para hablar sobre el proceso de carga del sistema operativo era _mecanismo de arranque_ (bootstrap), que por efectos de simplificación ahora conocemos como "arranque" (booting).

En equipos con arquitectura x86, el Sistema Básico de Entrada/Salida (BIOS) es el responsable de cargar el sistema operativo. Para hacer esto, el BIOS busca en el disco duro el Registro Maestro de Arranque (RMA) (N de T. Conocido como MBR-Master Boot Record), el cual debe localizarse en un lugar específico del disco. El BIOS cuenta con suficiente información, para cargar y ejecutar el RMA, y asumir que el RMA puede encargarse del resto de las tareas necesarias en la carga del sistema operativo.

Si usted sólo cuenta con un sistema operativo instalado en su disco duro, el RMA estándar será suficiente. Este RMA buscará la primer partición del disco que pueda arrancar, y posteriormente ejecutará el código restante de dicha partición, para efecto de completar la carga del sistema operativo.

Si usted cuenta con varios sistemas operativos instalados en su disco, entonces puede hacer uso de un RMA diferente, uno que despliegue una lista de los diferentes sistemas operativos, y le permita escoger cual de ellos desea que se cargue. FreeBSD cuenta con un RMA de este tipo que puede ser instalado, así como otros distribuidores de sistemas operativos cuentan con RMAs alternativos.

En el caso de FreeBSD, el resto del mecanismo de arranque, está dividido en tres etapas. La primer etapa es ejecutada por al RMA, que sabe lo suficiente como para poner a la computadora en un estado específico y ejecutar la segunda etapa. La segunda etapa puede hacer un poco más que esto, antes de ejecutar la tercer etapa. La tercer etapa finaliza el trabajo de carga del sistema operativo. El trabajo es dividido en tres etapas, debido a las limitantes que tiene una PC, en cuanto al tamaño de los programas a ejecutar, durante las etapas uno y dos. El encadenar estas tareas, le permiten a FreeBSD contar con un arrancador más flexible.

Posteriormente el kernel es inicializado y comienza con la comprobación de dispositivos, y prepararlos para su uso. Una vez que el proceso de arranque del kernel ha finalizado, el kernel transfiere el control al proceso de usuario man:init[8], quien se asegura de que los discos se encuentren en buen estado para su uso. Posteriormente man:init[8] inicia la configuración fuente a nivel de usuario, que monta los sistemas de ficheros, configura las tarjetas de red para que pueden comunicarse en la red, y comunmente inicia todos los procesos que normalmente son ejecutados en un sistema FreeBSD al arrancar el mismo.

[[boot-blocks]]
== El RMA y las etapas de arranque uno, dos y tres

[[boot-boot0]]
=== RMA, [.filename]#/boot/boot0#

El RMA de FreeBSD, se localiza en [.filename]#/boot/boot0#. Este es una _copia_ del RMA, ya que el RMA real debe localizarse en una parte especial del disco duro, fuera de la área de FreeBSD.

El fichero [.filename]#boot0# es muy simple, dado que el programa en el  sólo puede ser de 512 bytes. Si usted ha instalado el RMA de FreeBSD y ha instalado varios sistemas operativos en sus discos duros, entonces al momento de arrancar el sistema, visualizará una pantalla similar a la siguiente.

[[boot-boot0-example]]
.Pantalla [.filename]#boot0#
[example]
====

[source,shell]
....
F1 DOS
F2 FreeBSD
F3 Linux
F4 ??
F5 Drive 1

Default: F2
....

====

Es sabido que otros sistemas, en particular Windows 95, sobreescriben el RMA con el suyo. Si esto le sucede, o bien desea reemplazar su RMA actual con el RMA de FreeBSD, entonces puede utilizar las siguientes órdenes.

[source,shell]
....
# fdisk -B -b /boot/boot0 dispositivo
....

Donde _dispositivo_ es aquel, desde el cual usted pretende arrancar el sistema, tal como [.filename]#ad0# para el disco conectado al primer IDE, [.filename]#ad2# para el disco maestro conectado al IDE secundario, [.filename]#da0# para el primer disco SCSI, y así sucesivamente.

Por otro lado, si usted es un usuario de Linux, y prefiere que la aplicación LILO controle el proceso de arranque, puede editar el fichero [.filename]#/etc/lilo.conf# para incluir a FreeBSD, o bien seleccionar la opción `Leave The Master Boot Record Untouched` durante el proceso de instalación. Si ha instalado el gestor de arranque de FreeBSD, puede arrancar Linux y modificar el fichero de configuración de LILO, [.filename]#/etc/lilo.conf#, añadiendo la siguiente opción:

[.programlisting]
....
other=/dev/hdXY
table=/dev/hdb
loader=/boot/chain.b
label=FreeBSD
....

lo que permitirá el arranque de FreeBSD y Linux, por medio de LILO. En nuestro ejemplo hemos utilizado _XY_ para especificar el disco utilizado y su partición. Si usted utiliza un sistema SCSI, deberá cambiar _/dev/hdXY_ por algo similar a _/dev/sdXY_, que nuevamente utiliza la sintáxis _XY_. La opción `loader=/boot/chain.b` puede omitirse si usted cuenta con ambos sistemas operativos en el mismo disco. Una vez que esto se ha completado, puede ejecutar `/sbin/lilo -v` para que se actualicen los cambios en el sistema, lo cual deberá verificarse con los mensajes que aparezcan en pantalla.

[NOTE]
====
N de T: La opción mencionada como; `Leave The Master Boot Record Untouched`, se mostrará "tal cual" aparece en este documento, una vez que ha terminado la fase de partición del disco duro.
====

[[boot-boot1]]
=== Etapa uno, [.filename]#/boot/boot1#, y etapa dos, [.filename]#/boot/boot2#

Conceptualmente las estapas uno y dos, son parte del mismo programa, en la misma área del disco. Por cuestiones de espacio se han dividido en dos, pero estas siempre se instalaran de manera conjunta.

Estas son localizadas en el sector de arranque, de la partición de arranque, que es donde <<boot-boot0,boot0>>, o cualquier otro programa del  espera encontrar el programa que dará continuación al proceso de arranque. Los ficheros localizados bajo el directorio [.filename]#/boot# son copias de los ficheros reales, que se localizan fuera del sistema de ficheros de FreeBSD.

El fichero [.filename]#boot1# es muy simple, en virtud de que sólo puede tener un tamaño de 512 bytes, y conocer simplemente del etiquetador de discos de FreeBSD (_disklabel_), el cual almacena la información de las particiones, para efecto de localizar y ejecutar [.filename]#boot2#.

El fichero [.filename]#boot2# es un poco más sofisticado, y comprende lo suficiente del sistema de ficheros de FreeBSD como para localizar ficheros en el, y puede proveer una interfaz simple, para seleccionar el kernel o cargador que deberá ejecutarse.

En virtud de que el <<boot-loader,cargador>> (loader) es mucho más sofisticado, y provee una configuración de arranque más sencilla de utilizar, [.filename]#boot2# la ejecuta normalmente, una vez que ha terminado de solicitar el arranque del kernel directamente.

[[boot-boot2-example]]
.Pantalla de [.filename]#boot2#
[example]
====

[source,shell]
....
>> FreeBSD/i386 BOOT
Default: 0:ad(0,a)/kernel
boot:
....

====

Si alguna vez requiere reemplazar los ficheros [.filename]#boot1# y [.filename]#boot2# instalados, utilice man:disklabel[8].

[source,shell]
....
# disklabel -B partición
....

Donde _partición_ es el disco y partición del cual pretende arrancar el sistema, tal como [.filename]#ad0s1# para la primer partición del disco Mastro-Primario.

[WARNING]
.Modo peligrosamente dedicado
====
Si sólo utiliza el nombre del disco, tal como [.filename]#ad0#, al usar man:disklabel[8] creará un disco peligrosamente dedicado, sin partición alguna. Seguramente esto no es lo que desea hacer, así que asegurese dos veces antes de presionar la tecla kbd:[Return] cuando utilice man:disklabel[8].
====

[[boot-loader]]
=== Etapa tres, [.filename]#/boot/loader# (cargador de arranque)

El cargador es la etapa final de las tres etapas del mecanismo de arranque, y esta localizado en el sistema de ficheros, normalmente como [.filename]#/boot/loader#.

El cargador pretende ser un metodo amistoso de configuración, utilizando una serie de órdenes integradas de fácil uso, respaldado por un intérprete más poderoso, con una serie de órdenes de mayor complejidad.

[[boot-loader-flow]]
==== Flujo del programa cargador

Durante la inicialización del sistema, el cargador hará una comprobación en busca de una consola y discos, y sabra de que disco se encuentra arrancando. Establecerá las variables necesarias, y posteriormente es iniciado el intérprete donde se pueden introducir órdenes desde un "script" o de manera interactiva.

Posteriormente el cargador leerá el fichero [.filename]#/boot/loader.rc#, que por default lee la información del fichero [.filename]#/boot/defaults/loader.conf# que a su vez, establece las variables correspondientes y verifica en el fichero [.filename]#/boot/loader.conf# los cambios locales que se hayan hecho, para establecer valores de las variables modificadas. Una vez llevado a cabo esto, [.filename]#loader.rc# actua sobre estas variables, cargando cualquier módulo y kernel seleccionado.

Finalmente, y por default, el cargador hace una pausa contando 10 segundos y en espera de que al presionar una tecla se interrumpa el proceso, de no ser así, procederá a arrancar el kernel. En el caso de que al hacer esta pausa, se haya presionado una tecla (diferente de kbd:[Return]), el proceso será interrumpido y se nos mostrará un "prompt", que entiende el conjunto de órdenes de fácil-uso, y donde el usuario puede ajustar ciertas variables, cargar y descargar todos los módulos, y también arrancar o reiniciar el sistema.

[[boot-loader-commands]]
==== Órdenes internas del cargador

A continuación se presentan las órdenes más comunes del cargador. Para ver una descripción detallada de los mismos, por favor consulte la página de manual de man:loader[8]

autoboot _segundos_::
Procede a iniciar el arranque del sistema, si es que no es interrumpido el periodo dado, en segundos. Despliega una cuenta regresiva, y el tiempo dado es de 10 segundos.

boot [-opciones] [nombre_del_kernel]::
Procede a iniciar el kernel de manera inmediata, con las opciones dadas, si es que fuera el caso y el kernel especificado, si es que se especifica alguno.

boot-conf::
Rehace la configuración automática de modulos en función a las variables definidas, como sucede al arrancar. Esta opción sólo tiene sentido utilizarla, si en primer lugar hemos usado `unload`, y hemos modificado alguna variable, siendo lo más común el `kernel`.

help [tema]::
Muestra la ayuda de un tema específico, que lee del fichero [.filename]#/boot/loader.help#. Si el tema que se indica es `index`, entonces se mostrará una lista de todos los temas disponibles.

include _fichero_ ...::
Procesa el fichero que se ha especificado. El fichero se lee e interpreta línea por línea. Cualquier error detendrá inmediatamente a include.

load [-t tipo] _fichero_::
Carga el kernel, modulo del kernel, o el fichero del tipo dado, en base al fichero especificado. Cualquier argumento que se añada, será pasado al fichero.

ls [-l] [ruta]::
Despliega un listado de todos los ficheros que se localizan en la ruta especificada, o en el directorio raíz, si es que no se le especifica ruta alguna. Si se utiliza la opción `-l`, también se mostrara el tamaño de los ficheros.

lsdev [-v]::
Nos muestra una lista de todos los dispositivos desde los cuales puede ser posible cargar modulos. Si se incluye la opción `-v`, el listado que se obtiene cuenta con más detalle.

lsmod [-v]::
Despliega los módulos cargados. Si se utiliza la opción `-v`, se mostraran más detalles.

more _fichero_::
Despliega el contenido del fichero especificado, haciendo una pausa a cada numero determinado de `LINEAS` mostradas.

reboot::
Reinicia el sistema de forma inmediata.

set _variable_::
Especifica los valores de las variables de entorno del cargador.

unload::
Remueve todos los módulos cargados.

[[boot-loader-examples]]
==== Ejemplos de uso del cargador

He aqui unos ejemplos prácticos sobre el uso correcto del cargador.

* Para arrancar simplemente su kernel usual, pero en modo mono-usuario, deberá hacer lo siguiente:
+
[source,shell]
....
 boot -s
....

* Para descargar su kernel usual y sus módulos correspondientes, y posteriormente cargar su kernel anterior (o cualquier otro):
+
[source,shell]
....
unload
load kernel.old
....
+ 
Puede utilizar [.filename]#kernel.GENERIC# para referirse al kernel generico actual que viene con la instalación, o bien puede utilizar [.filename]#kernel.old# para hacer referencia al kernel anterior (por ejemplo, cuando ha actualizado su sistema o ha recompilado su propio kernel).
+
[NOTE]
====
Utilice lo siguiente para cargar sus módulos actuales con otro kernel:

[source,shell]
....
unload
set kernel="kernel.old"
boot-conf
....

====

* Para cargar un escrito de configuración (script que de forma automática hará todo lo que normalmente hace usted de forma manual al momento de ejecutarse el configurador de arranque):
+
[source,shell]
....
 load -t escrito_de_configuración /boot/kernel.conf
....

[[boot-kernel]]
== Interacción con el kernel durante el arranque

Una vez que el kernel ha sido iniciado, ya sea por el <<boot-loader,cargador>> (que es lo común) o bien por <<boot-boot1,boot2>> (sobrepasando el cargador), examinará las opciones de arranque, en busca de cambios, y ajustar su comportamiento en caso de ser necesario.

[[boot-kernel-bootflags]]
=== Opciones de arranque del kernel

He aqui las opciones de arranque más comunes:

`-a`::
durante la inicialización del kernel, pregunta por los dispositivos a utilizar, para montar el sistema de ficheros raíz.

`-C`::
arranque desde una unidad de CDROM.

`-c`::
ejecuta UserConfig, la utilidad de configuración de arranque del kernel.

`-s`::
arranca el sistem en modo mono-usuario.

`-v`::
imprime mensajes informativos durante el arranque del kernel

[NOTE]
====
Existen otras opciones de arranque, por favor vea la página de ayuda man:boot[8] para más información al respecto. 
====

[[device-hints]]
== Device Hints

Pendiente de Traducción

[[boot-init]]
== Init: inicialización del proceso de control

Ya que el kernel ha finalizado de arrancar, pasará el control a un proceso de usuario llamado `init`, el cual se localiza en [.filename]#/sbin/init#, o bien en la ruta especificada por la variable de entorno `init_path` del cargador.

[[boot-autoreboot]]
=== Secuencia automática de reinicio

La secuencia automática de reinicio se asegura de que los sistemas de ficheros disponibles en el sistema sean consistentes. Si no lo son, y el programa `fsck` no puede arreglar estas inconsistencias, `init` envia el sistema a modo <<boot-singleuser,monousuario>>, de tal forma que el administrador pueda ingresar en él y arreglar los problemas directamente.

[[boot-singleuser]]
=== Modo monousuario

A este modo se puede llegar por medio de la <<boot-autoreboot,secuencia automática de reinicio>>, o por medio de la opción `-s` en el arranque de usuario o al establecer la variable `boot_single` en el cargador.

También desde el modo <<boot-multiuser,multi-usuario>> se puede acceder, al utilizar `shutdown` sin la opción de reinicio (`-r`) o la de apagado (`-h`) del sistema.

Si la consola del sistema esta configurada de modo `inseguro` en el fichero [.filename]#/etc/ttys#, entonces el sistema solicitará la contraseña del `superusuario` (root), antes de ingresar al sistema en modo mono-usuario.

[[boot-insecure-console]]
.Una consola insegura en /etc/ttys
[example]
====
[.programlisting]
....
# name  getty                           type    status          comments
#
# If console is marked "insecure", then init will ask for the root password
# when going to single-user mode.
console none                            unknown off insecure
....

====

[NOTE]
====
Una consola `insegura` significa que usted considera como insegura físicamente su consola, por lo que desea asegurarse de que sólo quien conoce la contraseña del `superusuario` puede ingresar al sistema en modo mono-usuario, y no que desea ejecutar la consola inseguramente. Esto es, si desea contar con seguridad escoja la opción `insecure`, y no `secure`.
====

[[boot-multiuser]]
=== Modo multiusuario

En el caso de que `init` encuentre en buen estado al sistema de ficheros, o una vez que el usuario ha terminado del modo <<boot-singleuser,mono-usuario>>, el sistema entrará al modo multi-usuario, en donde comienzan los ficheros de configuración-fuente del sistema.

[[boot-rc]]
==== Configuración-Fuente(rc)

La configuración fuente lee la configuración por default del fichero [.filename]#/etc/defaults/rc.conf#, y detalles específicos del sistema desde el fichero [.filename]#/etc/rc.conf#, y posteriormente procede a montar los sistemas de ficheros del sistema, descritos en [.filename]#/etc/fstab#, iniciar servicios de red, así como varios demonios del sistema, para finalmente ejecutar los escritos (scripts) de configuración instalados por paquetes, localmente.

La página de ayuda man:rc[8] es una buena referencia para conocer más de este tipo de ficheros, así como examinar los mismos ficheros.

[[boot-shutdown]]
== Secuencia de apagado

Una vez que el apagado sea controlado, por medio de `shutdown`, `init` ejecutará el escrito [.filename]#/etc/rc.shutdown#, para posteriormente enviar a todos los procesos la señal `TERM`, y subsecuentemente la señal `KILL` a cualquiera que no haya terminado en tiempo.
