Arranque: una pulsación de encendido y todo lo aprendido sube al escenario

Pulsa el encendido: una computadora vacía despierta

Imagina una computadora con el encendido apagado. La memoria está borrada por completo. El kernel del que tanto aprendimos, y los procesos que de él se ramificaban, no están en la memoria ahora mismo, ni una sola línea. Sin electricidad fluyendo, claro que no. Pero pulsa el botón de encendido y algo extraño empieza. Alguien tiene que dar el primer paso. Quien da ese primer paso no es el grandioso kernel, sino un programa muy pequeño siempre grabado dentro de un chip. Lo llamamos el programa de arranque, o firmware. El firmware está fijado en su sitio desde el principio, para ser el primero en despertar en cuanto llega la corriente.

Toca el encendido. La memoria empieza vacía, luego el pequeño programa de arranque dentro del chip (firmware, azul) despierta primero. El kernel todavía no está en ninguna parte.

Solo ha despertado un pequeño firmware. La memoria sigue casi vacía. El firmware no es listo. No sabe adornar la pantalla con elegancia ni abrir apps. El firmware sabe una sola cosa: cómo traer al verdadero trabajador. Y ese verdadero trabajador es el kernel. Pero el kernel no está en la memoria ahora mismo. Mientras el equipo estuvo apagado, el kernel dormía en el disco como un archivo. Así que la tarea del firmware es clara. Ir al disco y traer ese kernel. Veamos esa escena a continuación.

El firmware sube el kernel del disco a la memoria

Aquí, recuerda una promesa de una lección pasada. Dijimos que el kernel siempre reside en la memoria, gestionando todo. Pero piénsalo: hasta un kernel que se dice siempre residente tiene que cargarse en la memoria por primera vez en algún momento. Ese momento es ahora mismo. El firmware encuentra el archivo del kernel en el disco y lo lleva a la memoria, trozo a trozo. Por fin el kernel toma su lugar en la memoria antes vacía. Ese kernel que seguimos llamando el protagonista de cada acto a lo largo de esta área por fin sube al escenario por primera vez, en esta única escena del arranque.

Toca el firmware. El kernel (dorado), dormido como un archivo en el disco, sube a la memoria trozo a trozo. El kernel que llamábamos siempre residente toma su lugar por primera vez, ahora mismo.

Una vez que el kernel está del todo en la memoria, el firmware entrega calladamente su deber. El papel del pequeño programa de arranque termina justo aquí. Tras despertar al verdadero trabajador y sentarlo, el escenario es ahora del kernel. ¿Qué hace primero el kernel despierto? El kernel solo no puede hacer ni una cosa que veamos. Los iconos en la pantalla, la entrada del teclado, las apps que abrimos, todo eso solo ocurre una vez que algo se pone a correr. Así que lo primerísimo que hace el kernel es dar a luz a un primer proceso. Veámoslo a continuación.

El kernel engendra un primer proceso, y de ahí se ramifican

Recuerda la lección sobre procesos. Un programa es un archivo dormido en el disco, y el estado de él corriendo y vivo es un proceso. En el arranque, el kernel hace exactamente eso, por primera vez. Elige un programa dormido en el disco y lo ejecuta, convirtiéndolo en el primer proceso vivo en esta computadora. Pero el kernel no lanza cada app una por una él mismo. En cambio, este primer proceso engendra otro proceso, y ese hijo engendra sus propios hijos, extendiéndose como un solo árbol que echa ramas. Los muchos programas que usamos son todos ramas que se bifurcaron de este primer proceso.

Toca el kernel para engendrar el primer proceso. Toca otra vez y sus procesos hijos se ramifican. Del kernel (dorado) al primer proceso, del primer proceso a muchos (verde).

Un toque trajo a la existencia el primer proceso, y otro hizo que los hijos se extendieran debajo de él. Este es el punto de partida de la misma pantalla que vemos cada día. El programa que pinta el escritorio, el reloj, las notificaciones, todos ellos son procesos en algún lugar entre estas ramas. Y estos procesos guardan cada uno su propio espacio de memoria, y siempre que necesitan algo, se lo piden al kernel con una llamada al sistema. Las piezas que aprendimos por separado a lo largo del área van encajando en su sitio, una por una, dentro de esta única escena del arranque. Ahora apilemos esas piezas, capa por capa, en una sola imagen.

Se completa, apilado en capas (del hardware a las apps)

Ahora veamos el todo como una imagen. En el fondo está el hardware. Las partes reales como el disco, la memoria, la pantalla y el teclado. Encima, el pequeño firmware despierta y da el primer paso, y ese firmware carga el kernel. El kernel se sienta justo encima del hardware, hablando directamente con cada parte, levantando muros en la memoria y gestionando la planificación. Sobre el kernel está el primer proceso, y sobre eso las apps que usamos se apilan por turno. La capa de abajo debe sostenerse firme para que la de arriba se mantenga. Sin hardware no hay firmware, sin firmware no hay kernel, sin kernel no hay procesos, sin procesos ninguna app puede mantenerse.

Toca desde abajo para encender una capa a la vez. Hardware, firmware, kernel, primer proceso, apps, en ese orden. Una capa inferior debe sostenerse antes de poder subir la siguiente.

Una vez que la luz llega a las apps de lo más alto, la pantalla que vemos queda por fin completa. La computadora antes oscura está ahora viva. Lo curioso es que, una vez construida esta torre, lo que hizo el firmware casi se olvida. Al usar una app, apenas notamos que debajo de ella está el kernel, y debajo de eso el firmware y el hardware lo sostienen todo. Sin embargo, cada una de esas capas se levantó de abajo arriba, con orden, en el único momento del arranque. Ahora, como último paso, tracemos de principio a fin cómo una pulsación de encendido une todo esto en una sola línea.

Una pulsación de encendido, todo ello: el área en un panel

Unido en una línea, va así. Pulsa el encendido, el pequeño firmware dentro del chip despierta, el firmware sube el kernel del disco a la memoria, el kernel engendra el primer proceso y de él las apps se ramifican. Dentro de esta única línea que se despliega en apenas unos segundos cabe casi todo lo que aprendimos en el área. Los archivos dormidos en el disco y la memoria, el kernel siempre residente, los procesos vivos, el espacio de memoria propio de cada proceso, los controladores que hablan con las partes, los permisos que deciden quién puede hacer qué, y las llamadas al sistema con que un proceso pide al kernel. Arrancar es la escena donde todas estas piezas aparecen juntas por primera vez, y además en un orden fijo.

Toca los pasos en orden para seguir un arranque completo. Encendido, despertar del firmware, carga del kernel, primer proceso, la pila de apps. Las piezas que aprendiste en el área se hilan en una sola línea.

Ahora el breve momento de pulsar el botón de encendido se verá distinto que antes. Dentro de él un pequeño programa de arranque despierta al kernel, el kernel engendra un primer proceso, y nuestras apps suben capa por capa, un vasto ensamblaje en marcha. Empezamos esta área preguntando qué clase de ama de casa es un sistema operativo. Arrancar es la escena misma de esa ama de casa despertando por la mañana y montando el hogar, paso a paso, desde el principio. El único momento, repetido en silencio cada día, en que una máquina oscura termina de prepararse para recibirnos.