Qué es un sistema operativo

1. Una pregunta para empezar

Este es probablemente el primer programa que escribiste, en C o en cualquier otro lenguaje:

#include <stdio.h>

int main(void)
{
    printf("Hola, sistema operativo\n");
    return 0;
}

Funciona, y por eso nunca nos detenemos a pensar en él. Pero mirado de cerca plantea preguntas que el código no responde:

• ¿Quién copió el programa del disco a la memoria y le dijo a la CPU que empezara por main?
• ¿Cómo sabe el programa qué pantalla tienes, qué resolución usa o con qué tipografía se dibuja cada letra?
• Si en el mismo momento hay un navegador, un editor y un reproductor de música en ejecución, ¿por qué el texto no se mezcla con lo que ellos dibujan?
• Cuando el programa termina, ¿quién recupera la memoria que estaba usando?

Ninguna de esas tareas está en las seis líneas del programa. Todas las hace otro software, que ya estaba en ejecución antes de que tu programa empezara y que seguirá en ejecución cuando termine. Ese software es el sistema operativo.

2. Programar sin sistema operativo

La forma más clara de entender qué hace un sistema operativo es imaginar que no está. Supón que tienes una computadora recién fabricada, sin nada instalado, y quieres que muestre «Hola» en pantalla. Tu programa tendría que resolver por sí mismo todo esto:

• Arrancar. Estar ubicado en el lugar exacto del disco donde el firmware busca código al encender, y caber en el espacio que el firmware permite.
• Hablar con la pantalla. Conocer el modelo concreto de la tarjeta de video, configurarla y escribir, píxel por píxel, la forma de cada letra. Con otra tarjeta de video, el programa deja de funcionar.
• Hablar con el teclado y el disco. Lo mismo para cada dispositivo: cada fabricante y cada modelo se maneja de forma distinta.
• Administrar la memoria. Decidir en qué direcciones guarda cada dato, sin que nadie le avise si se equivoca.
• Convivir con otros programas. No hay «otros programas»: la máquina ejecuta uno solo. Para ejecutar otro, hay que reiniciar.

Las primeras computadoras se programaban exactamente así, y cada programa incluía su propio código para manejar la impresora o la cinta. Muy pronto quedó claro que ese código era siempre el mismo y que convenía escribirlo una sola vez, dejarlo cargado en la máquina y permitir que todos los programas lo usaran. De esa idea nacen los sistemas operativos; el recorrido histórico completo está en el tema 3. Si quieres conocer antes cómo surgieron y quiénes los crearon, puedes leer la historia de los sistemas operativos.

3. Una definición

No existe una definición única aceptada por todos los libros, pero casi todas coinciden en lo esencial:

Un sistema operativo es el software que administra el hardware de una computadora y ofrece a los programas un conjunto de servicios para usarlo, de modo que ningún programa tenga que tratar directamente con los dispositivos ni pueda interferir con los demás.

En esa frase hay tres ideas que conviene separar:

1. Administra el hardware. La CPU, la memoria, el disco y los dispositivos son recursos limitados que muchos programas quieren usar al mismo tiempo. El sistema operativo decide quién usa qué y durante cuánto tiempo.
2. Ofrece servicios. En lugar de «escribe estos bytes en el sector 48.213 del disco», tu programa pide «guarda este texto en el archivo notas.txt». El sistema operativo traduce el pedido simple a las operaciones complejas que el hardware necesita.
3. Protege. Un programa con errores, o malintencionado, no debe poder leer la memoria de otro programa, borrar archivos ajenos ni dejar colgada la máquina entera.

Las dos primeras ideas suelen llamarse el sistema operativo como gestor de recursos y como máquina extendida. Son tan importantes que les dedicamos todo el tema 2.

4. Dónde se ubica: las capas

Un sistema informático se entiende mejor como una pila de capas, donde cada una usa los servicios de la que tiene debajo y ofrece servicios a la que tiene arriba:

De abajo hacia arriba:

• Hardware. Los componentes físicos. Solo entienden instrucciones de máquina y señales eléctricas. Los estudiamos en el bloque 2.
• Kernel. El núcleo del sistema operativo: el único software con permiso para controlar el hardware directamente. Se ejecuta en un modo privilegiado de la CPU llamado modo kernel.
• Bibliotecas. Código ya escrito que los programas reutilizan. Funciones como printf son cómodas de usar y, por dentro, terminan pidiéndole el trabajo al kernel.
• Aplicaciones. Todo lo demás, incluidos tus programas. Se ejecutan en modo usuario, un modo restringido en el que la CPU rechaza cualquier intento de tocar el hardware.
• Usuarios. Las personas, que interactúan con las aplicaciones y nunca con el kernel.

La línea punteada del diagrama es la frontera más importante de todo el curso. Un programa en modo usuario no puede saltar al kernel cuando quiere: solo puede cruzar por un mecanismo controlado, la llamada al sistema (en inglés system call o syscall), mediante la cual le pide al kernel que haga algo en su nombre. A esa frontera le dedicamos el bloque 3 completo.

5. Qué forma parte del sistema operativo y qué no

Aquí aparece una confusión habitual, porque la expresión «sistema operativo» se usa con dos sentidos:

• Sentido estricto: el sistema operativo es el kernel. Es el programa que está siempre en ejecución y el único que corre en modo privilegiado. En este sentido, «Linux» es solo el kernel.
• Sentido amplio: el sistema operativo es todo lo que viene instalado para que el equipo sea utilizable: el kernel más las bibliotecas, la shell, las utilidades básicas y, a menudo, el entorno gráfico. En este sentido hablamos de Windows 11, macOS o Ubuntu.

Las dos formas de hablar son correctas; lo importante es saber cuál se está usando. En este curso, cuando haga falta precisión diremos kernel, y usaremos «sistema operativo» para el conjunto.

6. El rastro de un «Hola»

Volvamos al programa del principio y sigamos su única línea útil a través de las capas. Para compilarlo y ejecutarlo en Linux:

$ gcc hola.c -o hola
$ ./hola
Hola, sistema operativo

Entre que pulsas Enter y aparece el texto ocurre lo siguiente. Fíjate en qué modo trabaja la CPU en cada paso:

1. Tu programa llama a printf. printf no es parte del kernel: es una función de la biblioteca de C, código común que se ejecuta dentro de tu propio programa. modo usuario
2. printf prepara el texto. Arma la cadena final, la guarda en una zona de memoria temporal (un búfer) y, cuando decide enviarla, llama a otra función de la biblioteca: write. modo usuario
3. write ejecuta una llamada al sistema. Coloca en registros de la CPU qué se pide (escribir), dónde (el descriptor 1, la salida estándar), qué bytes y cuántos. Luego ejecuta una instrucción especial que detiene el programa y transfiere el control al kernel. cambio a modo kernel
4. El kernel verifica el pedido. ¿Este programa tiene abierto el descriptor 1? ¿Hacia dónde apunta? ¿La dirección de memoria que indicó le pertenece de verdad? Si algo falla, devuelve un error en lugar de obedecer. modo kernel
5. El kernel entrega los bytes a su destino. En este caso, el descriptor 1 está conectado a la terminal, así que los bytes pasan al controlador correspondiente y terminan dibujados en la ventana. Si hubieras redirigido la salida a un archivo, el kernel los habría enviado al disco, sin que tu programa cambiara una sola línea. modo kernel
6. El kernel devuelve el resultado. Informa cuántos bytes escribió (24), la CPU vuelve al modo restringido y tu programa continúa en la instrucción siguiente. vuelta a modo usuario

Esto no es una descripción teórica: se puede observar. La herramienta strace muestra las llamadas al sistema que hace un programa. Le pedimos que registre solo las de tipo write y que guarde el resultado en un archivo:

$ strace -e trace=write -o traza.txt ./hola
Hola, sistema operativo
$ cat traza.txt
write(1, "Hola, sistema operativo\n", 24) = 24
+++ exited with 0 +++

Ahí está el paso 3 con todos sus datos: el descriptor 1, el texto, la cantidad de bytes (23 caracteres más el salto de línea) y, después del signo igual, la respuesta del kernel. Aprenderás a usar strace en detalle en el tema 16.

Para confirmar que printf es solo un intermediario cómodo, este otro programa prescinde de él y hace el pedido al kernel directamente:

#include <unistd.h>

int main(void)
{
    const char mensaje[] = "Hola, kernel\n";

    /* 1 = salida estándar; sizeof incluye el '\0' final, que no enviamos */
    write(1, mensaje, sizeof(mensaje) - 1);
    return 0;
}

El texto aparece en pantalla igual que antes, y ya no interviene printf. Lo que no puedes hacer es saltarte también al kernel: no existe ninguna instrucción en modo usuario que escriba en la pantalla. Todo programa, en cualquier lenguaje, termina pasando por una llamada al sistema para producir un efecto fuera de su propia memoria.

7. Verlo desde la terminal

El sistema operativo es discreto, pero responde si le preguntas. Estos comandos de Bash consultan información que solo el kernel conoce (los valores que veas serán distintos en tu equipo):

$ uname -srm                 # nombre del kernel, versión y arquitectura
Linux 6.8.0-45-generic x86_64

$ head -2 /etc/os-release     # la distribución instalada
PRETTY_NAME="Ubuntu 24.04.1 LTS"
NAME="Ubuntu"

$ nproc                      # procesadores que el kernel administra
8

$ free -h                    # memoria total, usada y libre
               total        used        free      shared  buff/cache   available
Mem:            15Gi       4.2Gi       6.9Gi       412Mi       4.4Gi        10Gi
Swap:          2.0Gi          0B       2.0Gi

$ ps -e | wc -l              # programas en ejecución en este momento
287

Dos observaciones sobre esa salida:

• uname informa el kernel («Linux 6.8») y /etc/os-release informa la distribución («Ubuntu 24.04»). Son las dos acepciones de «sistema operativo» de la sección 5, cada una con su versión.
• El último comando muestra cientos de programas en ejecución en un equipo con ocho procesadores. Que todos avancen sin estorbarse, cuando hay muchos más programas que procesadores, es trabajo del kernel.

8. Los servicios que ofrece

Vistos desde un programa, los servicios del sistema operativo se agrupan en unas pocas familias. Cada una se corresponde con una parte del kernel y con uno o más cursos de esta ruta:

En el bloque 7 de este curso recorremos cada servicio a vista de pájaro, y los cursos de nivel intermedio los estudian uno por uno.

9. Sistemas operativos que ya usas

Hay sistemas operativos en muchos más lugares que en una PC. Todos cumplen la definición de la sección 3, aunque estén diseñados para necesidades muy distintas:

La tabla muestra algo útil: Android y Ubuntu comparten kernel aunque sean irreconocibles entre sí, porque lo que cambia es todo lo que se construye encima. Clasificamos los tipos de sistemas en el tema 23 y comparamos las grandes familias en el tema 25.

En este curso trabajamos sobre Linux por tres razones: su código es abierto y se puede leer, ofrece herramientas para observar lo que hace el kernel, y es el sistema sobre el que se despliega la mayor parte del software actual. Los conceptos, sin embargo, valen para cualquier sistema operativo moderno.

10. Ideas equivocadas frecuentes

«El sistema operativo es lo que veo en pantalla»

El escritorio, las ventanas y los iconos son la parte visible, pero no la esencial. Un servidor Linux suele funcionar sin ningún entorno gráfico y sigue teniendo un sistema operativo completo. La interfaz es un programa más, que usa los servicios del kernel como cualquier otro.

«El sistema operativo está siempre ejecutándose en segundo plano»

En un procesador, en cada instante se ejecuta una sola cosa: o tu programa, o el kernel. El kernel no «vigila» mientras tu programa corre; está detenido. Solo se ejecuta cuando algo lo activa: una llamada al sistema, una interrupción de un dispositivo o un error del programa. Cómo logra entonces mantener el control es una de las ideas más elegantes del curso, y la vemos en el bloque 4.

«Mi programa habla con el hardware»

Salvo que escribas un controlador de dispositivo o programes un microcontrolador, tu programa nunca toca el hardware. Habla con el kernel, y el kernel habla con el hardware.

«El sistema operativo ejecuta mi programa»

Tu programa no es interpretado por el sistema operativo: sus instrucciones las ejecuta directamente la CPU, a toda velocidad. El sistema operativo lo prepara, le asigna recursos, lo interrumpe cuando corresponde y atiende sus pedidos, pero no participa en cada instrucción.

«Linux es un sistema operativo como Windows»

En sentido estricto, Linux es un kernel. Lo comparable con Windows es una distribución completa, como Ubuntu.

11. Por qué le importa a un programador

Se puede programar durante años sin estudiar sistemas operativos, del mismo modo que se puede conducir sin saber cómo funciona un motor. Pero hay problemas que solo se entienden mirando debajo del lenguaje:

• Rendimiento. Por qué leer un archivo byte a byte es mucho más lento que leerlo en bloques, o por qué un programa con muchos hilos no siempre es más rápido.
• Errores difíciles. Qué significa realmente «Segmentation fault», «Permission denied», «Too many open files» o «Out of memory».
• Concurrencia. Por qué dos partes del programa que funcionan bien por separado fallan de vez en cuando al ejecutarse juntas.
• Despliegue. Qué es en realidad un contenedor, cómo aísla un programa y por qué no es una máquina virtual.
• Seguridad. Por qué un programa no debe ejecutarse como administrador y qué puede hacer un atacante si lo consigue.

Todas esas respuestas están en el sistema operativo, y cada una corresponde a un curso de esta ruta. Este primer curso construye el vocabulario y el modelo mental que los demás dan por sabido.

12. El mapa del curso

Los 34 temas siguen el mismo orden que las capas del diagrama, de abajo hacia arriba:

Al llegar al tema 32 podrás explicar con precisión lo que en la sección 6 vimos a grandes rasgos.

13. Resumen

• Un sistema operativo es el software que administra el hardware y ofrece servicios a los programas, protegiéndolos entre sí.
• Existe porque, sin él, cada programa tendría que manejar cada dispositivo por su cuenta y la máquina solo podría ejecutar uno a la vez.
• Se ubica entre el hardware y las aplicaciones. Su núcleo, el kernel, es el único software que se ejecuta en modo privilegiado.
• «Sistema operativo» puede significar solo el kernel o el conjunto de kernel, bibliotecas, shell y utilidades. Linux es un kernel; Ubuntu es una distribución.
• Los programas se ejecutan en modo usuario y solo pueden pedir servicios al kernel mediante llamadas al sistema.
• Incluso printf("Hola") termina en una llamada al sistema, write, que se puede observar con strace.
• El kernel no se ejecuta todo el tiempo: se activa ante una llamada al sistema, una interrupción o un error.

14. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Elige tres equipos que tengas cerca (teléfono, televisor, router, consola, reloj) y averigua qué sistema operativo y qué kernel usa cada uno.
2. Cuando tengas Linux disponible, ejecuta los comandos de la sección 7 y anota la versión del kernel y la distribución.
3. Compila hola.c y hola_write.c, y compara con strace -e trace=write la llamada que hace cada uno.