Preparar el entorno: Linux, gcc y Bash

1. Qué necesitamos

El curso no requiere un equipo potente ni software de pago. Hace falta lo siguiente:

Como distribución recomendamos Ubuntu en una versión LTS (de soporte extendido): es la más documentada y la que se instala por defecto en casi todos los caminos que veremos. Si ya usas Debian, Fedora, Arch u otra, sirve igual; solo cambia el comando para instalar paquetes.

2. Tres caminos hacia Linux

No es necesario reemplazar el sistema que usas a diario. Hay tres formas habituales de tener un Linux completo, y se diferencian en cuántas capas quedan entre tus programas y el hardware:

Nuestra recomendación según tu situación:

• Usas Windows: empieza con WSL 2. Cubre casi todo el curso y se instala en minutos. Para el bloque 5, sobre el arranque, podrás añadir una máquina virtual o seguir los temas leyendo.
• Usas macOS: instala una máquina virtual. La terminal de macOS es de la familia Unix y se parece mucho, pero su kernel no es Linux: no tiene /proc ni strace, y varios ejemplos no funcionarían.
• Quieres la experiencia completa sin riesgos: una máquina virtual, en cualquier sistema.
• Ya usas Linux o tienes un equipo de sobra: la instalación nativa es la más fiel.

3. Camino A: WSL 2 en Windows

WSL (Windows Subsystem for Linux) es una función de Windows que ejecuta un kernel de Linux dentro de una máquina virtual muy ligera, integrada con el sistema. No es un emulador: los programas se ejecutan sobre Linux de verdad.

Instalación

1. Abre PowerShell como administrador: clic derecho sobre el botón de Inicio y elige «Terminal (Administrador)».
2. Ejecuta el comando de instalación. Descarga WSL y, por defecto, la distribución Ubuntu:

PS> wsl --install

3. Reinicia el equipo cuando lo pida.
4. Tras el reinicio se abre una ventana de Ubuntu que termina la instalación y te pide crear un usuario y una contraseña de Linux. Son independientes de los de Windows. Al escribir la contraseña no se muestra nada en pantalla, ni siquiera asteriscos; es normal.
5. Comprueba que la distribución usa la versión 2:

PS> wsl --list --verbose
  NAME      STATE           VERSION
* Ubuntu    Running         2

Desde ahora, para entrar a Linux basta con abrir la aplicación Ubuntu del menú Inicio, o una pestaña de Ubuntu en Windows Terminal.

Tres cosas que conviene saber

• Trabaja dentro de Linux. Guarda los archivos del curso en tu carpeta personal de Linux (~), no en el disco de Windows, que aparece montado en /mnt/c. Allí el acceso es mucho más lento y los permisos no se comportan como en Linux.
• Los archivos se ven desde Windows. Ejecutar explorer.exe . dentro de Ubuntu abre la carpeta actual en el Explorador de Windows.
• El kernel es de Microsoft. Es un Linux auténtico, compilado por Microsoft para WSL; lo notarás en que su versión termina en microsoft-standard-WSL2.

4. Camino B: máquina virtual

Una máquina virtual es una computadora simulada por software, dentro de la cual se instala un sistema operativo completo como si fuera un equipo físico. El sistema instalado no puede afectar al equipo real, y eso la convierte en un laboratorio ideal.

Pasos generales

1. Instala el programa de virtualización. En Windows y en Linux, VirtualBox (gratuito). En Mac con Apple Silicon, UTM (gratuito).
2. Descarga la imagen ISO de Ubuntu desde su sitio oficial. Elige la edición Desktop si quieres escritorio gráfico. En un Mac con Apple Silicon, descarga la versión para ARM64.
3. Crea la máquina virtual con estos recursos como mínimo: 2 procesadores, 4 GB de memoria y 25 GB de disco. El disco virtual es un archivo que crece según se usa; no reserva ese espacio de inmediato.
4. Arranca la máquina con la ISO y sigue el instalador de Ubuntu. Las opciones por defecto son adecuadas. Elige «borrar el disco e instalar»: se refiere al disco virtual, no al de tu equipo.
5. Reinicia, inicia sesión y abre la aplicación Terminal.

Si el programa informa que la virtualización no está disponible, hay que activarla en la configuración del firmware del equipo (BIOS o UEFI), donde aparece como «Intel VT-x», «AMD-V» o «SVM».

5. Camino C: Linux nativo

Instalar Linux directamente en el equipo da el mejor rendimiento y acceso al hardware real. Se puede hacer de dos maneras: como único sistema, o junto al existente en lo que se llama arranque dual, donde al encender se elige cuál iniciar.

El procedimiento consiste en grabar la ISO de Ubuntu en una memoria USB, arrancar el equipo desde ella y seguir el instalador. Los detalles dependen de cada equipo y exceden este tema; el sitio de Ubuntu tiene una guía oficial paso a paso.

6. Primer contacto con la terminal

Abre la terminal. Lo que ves es el prompt, la señal de que la shell espera un comando:

diego@mi-equipo:~$ █

Se lee así: el usuario diego, en el equipo mi-equipo, está ubicado en el directorio ~ (abreviatura de su carpeta personal, /home/diego), y el signo $ indica que es un usuario común. El administrador del sistema, llamado root, ve un # en su lugar.

Estos son los comandos mínimos para moverte. El curso siguiente de la ruta, Terminal y Línea de Comandos en Linux, los trata a fondo; aquí alcanza con reconocerlos.

Y estas teclas ahorran mucho tiempo:

• Tab completa nombres de comandos y de archivos. Es la tecla más útil de la terminal.
• Flecha arriba recupera los comandos anteriores.
• Ctrl+C interrumpe el programa en ejecución. Úsala cuando algo no termina.
• Ctrl+D indica «fin de la entrada». En un prompt vacío, cierra la terminal.
• Ctrl+L limpia la pantalla, igual que clear.

Creemos el directorio de trabajo del curso, con una carpeta por tema:

$ mkdir -p ~/so/tema04           # -p crea también los directorios intermedios
$ cd ~/so/tema04
$ pwd
/home/diego/so/tema04

7. Instalar las herramientas

En Linux el software se instala desde los repositorios de la distribución con un gestor de paquetes. Instalar programas modifica el sistema, así que requiere permisos de administrador: se antepone sudo al comando, que pedirá tu contraseña.

$ sudo apt update                # actualiza la lista de paquetes disponibles
$ sudo apt install build-essential strace gdb manpages-dev

Qué trae cada paquete:

• build-essential: el compilador gcc, la herramienta make y los archivos de la biblioteca de C necesarios para compilar.
• strace: el trazador de llamadas al sistema.
• gdb: el depurador. Lo usaremos poco en este curso, pero conviene tenerlo.
• manpages-dev: las páginas del manual sobre llamadas al sistema y funciones de C.

En otras distribuciones los paquetes equivalentes son:

$ sudo dnf install gcc make glibc-devel strace gdb man-pages

$ sudo pacman -S base-devel strace gdb man-db man-pages

Comprueba que todo quedó instalado pidiendo a cada herramienta su versión. Los números serán distintos en tu equipo:

$ gcc --version | head -1
gcc (Ubuntu 13.2.0-23ubuntu4) 13.2.0
$ strace --version | head -1
strace -- version 6.8
$ bash --version | head -1
GNU bash, version 5.2.21(1)-release (x86_64-pc-linux-gnu)
$ uname -srm
Linux 6.8.0-45-generic x86_64

8. Un editor de texto

Para escribir programas sirve cualquier editor de texto plano. Dos opciones razonables para empezar:

• nano, dentro de la terminal. Viene instalado y es el más sencillo: nano hola.c abre o crea el archivo. Se guarda con Ctrl+O y Enter, y se sale con Ctrl+X. Los atajos están siempre a la vista en la parte inferior.
• Visual Studio Code, gráfico. En WSL, instálalo en Windows junto con su extensión «WSL»; luego, desde la terminal de Ubuntu, code . abre la carpeta actual en el editor, que trabaja directamente sobre los archivos de Linux.

Si ya manejas vim, emacs u otro, úsalo. El curso no depende del editor.

9. El primer programa en C

En lugar del «Hola, mundo» habitual, nuestro primer programa le hace al kernel varias preguntas sobre el entorno que acabas de instalar. Sirve a la vez de verificación y de anticipo: cada dato que imprime proviene de una llamada al sistema. Escríbelo en un archivo llamado entorno.c dentro de ~/so/tema04.

#include <stdio.h>
#include <unistd.h>
#include <sys/utsname.h>

int main(void)
{
    struct utsname so;

    if (uname(&so) == -1) {
        perror("uname");
        return 1;
    }

    printf("Kernel:        %s %s\n", so.sysname, so.release);
    printf("Arquitectura:  %s\n", so.machine);
    printf("Equipo:        %s\n", so.nodename);
    printf("Procesadores:  %ld\n", sysconf(_SC_NPROCESSORS_ONLN));
    printf("Pagina:        %ld bytes\n", sysconf(_SC_PAGESIZE));
    printf("Puntero:       %zu bits\n", sizeof(void *) * 8);
    printf("PID:           %d (padre: %d)\n", (int)getpid(), (int)getppid());
    printf("Usuario (UID): %d\n", (int)getuid());
    return 0;
}

No hace falta entender cada línea todavía. Lo esencial:

• Las líneas #include incorporan las declaraciones de las funciones que usamos. unistd.h es el archivo de cabecera de las llamadas al sistema de Unix; lo verás en casi todos los programas del curso.
• uname le pide al kernel que complete la estructura so con sus datos. Es la misma llamada que usa el comando uname.
• Si uname devuelve -1, falló. En ese caso perror muestra el motivo y el programa termina con return 1. Este patrón —llamar, comprobar el resultado, informar el error— se repite en toda la programación de sistemas.
• getpid, getppid y getuid preguntan al kernel por la identidad del proceso, la de su proceso padre y la del usuario que lo ejecuta.

Compilar

$ gcc -Wall -Wextra -g entorno.c -o entorno

Si no aparece ningún mensaje, la compilación fue correcta: en Unix, el silencio significa éxito. Las opciones significan:

Usaremos esta misma línea, cambiando los nombres, para compilar todos los programas del curso. Qué hace gcc por dentro para pasar del texto al ejecutable es el contenido del tema 9.

Ejecutar

$ ./entorno
Kernel:        Linux 6.8.0-45-generic
Arquitectura:  x86_64
Equipo:        mi-equipo
Procesadores:  8
Pagina:        4096 bytes
Puntero:       64 bits
PID:           3817 (padre: 3120)
Usuario (UID): 1000
$ echo $?                        # código de salida del último programa
0

Dos detalles de esa ejecución merecen explicación:

• El ./ es obligatorio. Cuando escribes un nombre sin ruta, la shell solo lo busca en una lista fija de directorios del sistema, que no incluye el directorio actual. ./entorno significa «el archivo entorno que está aquí».
• El código de salida. El valor que devuelve main llega a la shell, que lo guarda en la variable $?. Por convención, 0 significa que todo fue bien y cualquier otro número indica un error.

Guarda una copia de esta salida. Ejecuta el programa dos veces y compara: el PID cambia, porque cada ejecución es un proceso nuevo, mientras que el PID del padre se mantiene, porque el padre es la shell desde la que lo lanzas. Volveremos sobre cada uno de estos datos: el tamaño de página en el tema 27, los PID en el tema 26 y el UID en el tema 30.

10. Leer los mensajes del compilador

Tarde o temprano el compilador protestará, y saber leer sus mensajes ahorra mucho tiempo. Este programa tiene dos defectos a propósito:

#include <stdio.h>

int main(void)
{
    int sin_usar;
    printf("Hola\n")
    return 0;
}

$ gcc -Wall -Wextra -g aviso.c -o aviso
aviso.c: In function ‘main’:
aviso.c:6:21: error: expected ‘;’ before ‘return’
    6 |     printf("Hola\n")
      |                     ^
      |                     ;
aviso.c:5:9: warning: unused variable ‘sin_usar’ [-Wunused-variable]
    5 |     int sin_usar;
      |         ^~~~~~~~

Todos los mensajes siguen el formato archivo:línea:columna: tipo: descripción, y debajo se muestra la línea con una marca en el punto exacto. Hay dos tipos:

• error: el código no es C válido. No se genera el ejecutable. Aquí falta el punto y coma al final de la línea 6.
• warning: el código es válido y se compila, pero algo parece un descuido. Aquí, una variable declarada que nunca se usa.

Dos consejos prácticos: corrige siempre el primer error y vuelve a compilar, porque los siguientes suelen ser consecuencia de él; y trata las advertencias como errores, sin dejar ninguna pendiente.

11. El primer script en Bash

Un script es un archivo de texto con comandos que la shell ejecuta en orden, como si los escribieras uno tras otro. El siguiente comprueba que el entorno del curso esté completo. Guárdalo como verificar.sh.

#!/bin/bash
# Verifica que el entorno del curso este completo.

echo "Kernel:       $(uname -sr)"
echo "Distribucion: $(. /etc/os-release && echo "$PRETTY_NAME")"
echo "Shell:        Bash $BASH_VERSION"
echo

faltan=0
for herramienta in gcc make strace gdb man; do
    if command -v "$herramienta" > /dev/null; then
        echo "  [ok]     $herramienta"
    else
        echo "  [FALTA]  $herramienta"
        faltan=1
    fi
done

exit $faltan

Las piezas nuevas:

• La primera línea, #!/bin/bash, le indica al kernel con qué programa debe interpretar el archivo. Tiene que ser exactamente la primera línea.
• $(comando) ejecuta un comando y coloca su salida en ese lugar del texto.
• command -v nombre termina con éxito si existe un comando con ese nombre. Su salida se descarta enviándola a /dev/null, un archivo especial que ignora todo lo que recibe.
• exit $faltan fija el código de salida del script: 0 si está todo, 1 si falta algo. Es el mismo mecanismo que el return de main en C.

Un archivo recién creado no tiene permiso de ejecución. Hay que dárselo una vez con chmod:

$ chmod +x verificar.sh          # añade el permiso de ejecución
$ ./verificar.sh
Kernel:       Linux 6.8.0-45-generic
Distribucion: Ubuntu 24.04.1 LTS
Shell:        Bash 5.2.21(1)-release

  [ok]     gcc
  [ok]     make
  [ok]     strace
  [ok]     gdb
  [ok]     man

Si alguna línea dice [FALTA], vuelve a la sección 7. Observa que entorno y verificar.sh informan el mismo kernel por dos vías distintas: un programa compilado que llama al kernel directamente y un script que lo hace a través de comandos. Los scripts tienen su propio curso en la ruta, Automatización con Scripts en Bash.

12. El manual: man

Linux trae su documentación de referencia instalada, y es la fuente más confiable sobre el sistema que tienes delante. Se consulta con man seguido del nombre de lo que buscas. El manual está dividido en secciones, y tres de ellas nos interesan especialmente:

La división entre las secciones 2 y 3 es exactamente la frontera entre el kernel y la biblioteca que vimos en el tema 1: write está en la sección 2 porque es una llamada al sistema, y printf en la 3 porque es una función de la biblioteca de C. Cuando un mismo nombre existe en varias secciones, el número evita la ambigüedad: man 1 printf describe el comando de la shell y man 3 printf la función de C.

$ man 2 getpid                   # abre la página; se sale con la tecla q
$ man -k directory               # busca páginas que mencionen una palabra

Dentro de una página, las flechas y la barra espaciadora desplazan el texto, /palabra busca, n salta a la siguiente coincidencia y q cierra. Las páginas de la sección 2 tienen siempre la misma estructura; las partes que más consultarás son SYNOPSIS (qué archivos incluir y qué parámetros recibe), RETURN VALUE (qué devuelve) y ERRORS (por qué puede fallar).

13. Probar strace

Para terminar, verifiquemos la herramienta que más usaremos en el bloque 3. Le pedimos a strace que ejecute nuestro programa y muestre únicamente su llamada a uname:

$ strace -e trace=uname ./entorno
uname({sysname="Linux", nodename="mi-equipo", ...}) = 0
Kernel:        Linux 6.8.0-45-generic
Arquitectura:  x86_64
…
+++ exited with 0 +++

La línea resaltada es el pedido que el programa hizo al kernel y la respuesta que recibió: los datos con que el kernel completó la estructura y el valor de retorno 0, que indica éxito. Con la opción -c, en cambio, strace muestra un resumen con la cantidad de llamadas de cada tipo:

$ strace -c ./entorno > /dev/null
% time     seconds  usecs/call     calls    errors syscall
------ ----------- ----------- --------- --------- ----------------
  0.00    0.000000           0         8           mmap
  0.00    0.000000           0         3           mprotect
  0.00    0.000000           0         2           openat
  0.00    0.000000           0         1           write
  0.00    0.000000           0         1           uname
…
------ ----------- ----------- --------- --------- ----------------
100.00    0.000000           0        37         1 total

Un programa de veinte líneas hizo decenas de llamadas al sistema, la mayoría antes de llegar a main: son el trabajo de cargar el ejecutable y la biblioteca de C. Las cantidades exactas varían según el sistema. Aprenderemos a interpretar esta salida en el tema 16; por ahora basta con que funcione.

14. Problemas frecuentes

Ante cualquier otro error, lee el mensaje completo antes de buscar ayuda: casi siempre indica el archivo, la línea o el comando exactos que fallaron.

15. Resumen y lista de control

• El curso necesita un kernel de Linux real, Bash, gcc, strace, las páginas man y un editor.
• WSL 2 es el camino más rápido en Windows; una máquina virtual ofrece la experiencia completa sin riesgo; la instalación nativa es la más fiel.
• En los ejemplos, el $ representa el prompt y no se escribe.
• Todos los programas se compilan con gcc -Wall -Wextra -g archivo.c -o nombre y se ejecutan con ./nombre.
• Un programa informa su resultado con un código de salida, visible en $?: 0 es éxito.
• Un script empieza con #!/bin/bash y necesita permiso de ejecución (chmod +x).
• man 2 documenta las llamadas al sistema y man 3 las funciones de biblioteca.

Antes de pasar al bloque 2, confirma que puedes marcar los cinco puntos:

1. uname -s responde Linux.
2. entorno.c compila sin errores ni advertencias, y ./entorno muestra los datos de tu sistema.
3. ./verificar.sh muestra [ok] en las cinco herramientas.
4. man 2 write abre una página del manual.
5. strace -e trace=uname ./entorno muestra la llamada a uname.

16. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Compila ahora hola.c y hola_write.c del tema 1 y copiar.c, ilusion.c e invasor.c del tema 2, y repite sus experimentos.
2. Modifica entorno.c para que termine con return 3 y comprueba el valor de $?.
3. Abre man 2 uname y averigua qué otros campos tiene la estructura utsname. Añade uno al programa.
4. Añade ltrace a la lista de herramientas de verificar.sh. Si aparece como faltante, instálalo y vuelve a ejecutar el script.
5. Si usas una máquina virtual, toma una instantánea con el nombre «entorno listo».