Cómo arranca una computadora

Pulsas el botón y una computadora vacía despierta

Imagina una computadora apagada. Su memoria está completamente vacía. El kernel del que tanto hemos aprendido, y los procesos que se ramificaban a partir de él, no tienen ahora ni una línea en la memoria. Sin corriente, es lo natural.
Al pulsar el botón de encendido, alguien tiene que dar el primer paso. No es el kernel, sino un programa muy pequeño guardado de forma permanente en un chip de la placa base. Se llama programa de arranque, o firmware.
El firmware está ahí desde el principio, listo para ser lo primero en despertar cuando llega la corriente.

Pulsa el botón de encendido: en una computadora con la memoria vacía, el pequeño programa de arranque del chip (firmware, azul) es lo primero que despierta. El kernel todavía no está en ninguna parte.

Solo ha despertado el pequeño firmware, y la memoria sigue casi vacía. El firmware no es listo. Aparte de comprobar rápidamente que las piezas están conectadas, no sabe decorar la pantalla ni abrir apps.
Lo que sí sabe es cómo traer al verdadero trabajador, y ese trabajador es el kernel. Pero el kernel no está ahora en la memoria: mientras la computadora estaba apagada, dormía en el disco en forma de archivo.
Así que la tarea del firmware está clara: ir al disco y traer el kernel.

El firmware sube el kernel del disco a la memoria

Recordemos lo que dijimos en la lección anterior: el kernel permanece en memoria y lo administra todo. Pero incluso un kernel que siempre está en memoria tiene que llegar a ella por primera vez en algún momento. Ese momento es ahora.
El firmware encuentra el archivo del kernel en el disco y lo lleva a la memoria trozo a trozo. En las computadoras reales, el firmware suele cargar primero un pequeño programa llamado cargador de arranque, y es ese cargador el que sube el kernel. Sea como sea, el kernel por fin se instala en una memoria que hasta hace un momento estaba vacía.
El kernel al que en toda esta área hemos llamado protagonista de cada escena sube al escenario por primera vez justo aquí, en esta escena del arranque.

Cada vez que pulsas el botón, un trozo más del kernel (dorado), que dormía como archivo en el disco, sube a la memoria. Cuando han subido los cuatro trozos, el kernel que siempre está en memoria ocupa su sitio por primera vez.

En cuanto todo el kernel está en memoria, el firmware le pasa el relevo en silencio. El papel del pequeño programa de arranque termina aquí: ya despertó al verdadero trabajador y lo sentó en su sitio, y el escenario es ahora del kernel.
¿Qué hace primero el kernel? Por sí solo no puede hacer nada que nosotros veamos. Los iconos de la pantalla, la ventana que recibe lo que tecleamos, las apps que abrimos: todo existe solo cuando algún programa se pone en marcha.
A partir de este momento, el kernel se hace cargo de toda la computadora. Por eso lo primero que hace es dar a luz al primer proceso.

El kernel crea el primer proceso, y de él nacen las ramas

Recuerda la lección sobre los procesos. Un programa es un archivo dormido en el disco, y un proceso es ese programa en marcha, vivo. Durante el arranque, el kernel hace justamente eso por primera vez.
Elige un programa que dormía en el disco y lo ejecuta, convirtiéndolo en el primer proceso vivo de esta computadora. En Linux, a este primer proceso se le asigna el número 1. Eso sí, el kernel no abre cada app por su cuenta. El primer proceso crea otros procesos, y esos hijos crean a su vez los suyos, ramificándose como un árbol.
Todos los programas que usamos son ramas que salieron de este primer proceso.

Pulsa el botón una vez y nace el primer proceso bajo el kernel (dorado); púlsalo otra vez y los procesos hijos (verde) se ramifican a partir de él.

Una pulsación creó el primer proceso, y la siguiente hizo brotar a sus hijos por debajo. Ahí empieza la pantalla que vemos cada día. El programa que dibuja el escritorio, el reloj, las notificaciones: cada uno es un proceso en algún punto de estas ramas.
Cada uno de estos procesos tiene su propio espacio de memoria, y cuando necesita algo se lo pide al kernel con una llamada al sistema. Las piezas que aprendimos una por una en esta área van encajando en su sitio dentro de la escena del arranque.
Ahora podemos apilar esas piezas, capa por capa, en una sola imagen.

Se completa por capas (del hardware a las apps)

Veamos todo en una imagen. Abajo del todo está el hardware, las piezas físicas como el disco, la memoria, la pantalla y el teclado. Encima, el pequeño firmware despierta y da el primer paso, y el firmware carga el kernel.
El kernel se sienta justo sobre el hardware, habla directamente con cada pieza, levanta muros en la memoria y organiza los turnos. Sobre el kernel está el primer proceso, y encima se apilan, una tras otra, las apps que usamos.
Una capa inferior tiene que sostenerse firme para que la de arriba se mantenga en pie. Sin hardware no hay firmware, sin firmware no hay kernel, sin kernel no hay procesos y sin procesos no hay apps. Una organización así, en la que cada capa sostiene a la de arriba, suele llamarse estructura en capas.

Cada vez que pulsas el botón se enciende una capa más, empezando por abajo: hardware, firmware, kernel, primer proceso y apps. Una capa inferior tiene que estar en pie antes de poder subir la siguiente.

Cuando la luz llega a las apps de arriba del todo, la pantalla que vemos por fin está completa. La computadora que estaba a oscuras ahora está viva.
Lo curioso es que, una vez levantada esta torre, lo que hizo el firmware queda casi olvidado. Mientras usamos una app, casi nunca pensamos en el kernel que la sostiene desde abajo, ni en el firmware y el hardware que hay debajo de él.
Sin embargo, todas esas capas se levantaron de abajo arriba, en orden, en el único instante del arranque. El logotipo del fabricante que aparece un momento al encender la computadora es justo el firmware trabajando, y hacia el momento en que desaparece, el kernel toma el relevo.

Una pulsación del botón y todo esto: el área entera en una página

Enhebrado en una línea, va así. Pulsas el botón de encendido, el pequeño firmware del chip despierta, el firmware sube el kernel del disco a la memoria, el kernel crea el primer proceso y de él se ramifican las apps.
Esa línea, que se recorre en pocos segundos, contiene casi todo lo que aprendimos en esta área: los archivos dormidos en el disco y la memoria, el kernel que siempre está en memoria, los procesos vivos, el espacio de memoria propio de cada proceso, los controladores que hablan con las piezas, los permisos que deciden quién puede hacer qué y las llamadas al sistema con las que un proceso le pide ayuda al kernel.
El arranque es la escena en la que todas estas piezas aparecen juntas por primera vez, y además en un orden fijo.

Pulsa los cinco pasos en orden y un arranque completo se enhebra en una sola línea: encendido, despertar del firmware, carga del kernel, primer proceso y apilado de las apps.

A partir de ahora, el breve instante de pulsar el botón de encendido debería verse distinto. Dentro de él, un pequeño programa de arranque despierta al kernel, el kernel crea el primer proceso y nuestras apps suben capa a capa en un gran montaje.
Esta área empezó preguntando qué hace el administrador invisible que hay detrás de la pantalla. El arranque es ese administrador levantándose por la mañana y poniendo en orden toda la casa, paso a paso, desde el principio. Es el instante, repetido en silencio cada día, en que una máquina a oscuras termina de prepararse para recibirnos.