Montar, desmontar e imágenes loop

1. Montar conecta un sistema de archivos al árbol

Hasta ahora hemos usado rutas como si pertenecieran a un único árbol uniforme. Linux puede construir ese árbol conectando sistemas de archivos distintos en directorios concretos. Montar establece una conexión; no copia todos los archivos de un volumen dentro de la carpeta elegida.

Punto de montaje: ubicación donde queda accesible la raíz de otro sistema de archivos. Origen: recurso que lo proporciona. Tipo: implementación que interpreta ese recurso, como ext4.

El montaje forma parte del espacio de nombres de montajes del proceso. Dos procesos en espacios distintos pueden ver conexiones diferentes bajo el mismo texto de ruta. El tema 31 desarrollará la capa VFS que unifica estas operaciones.

2. Origen, tipo y destino: tres datos diferentes

El directorio de destino debe existir. Si tenía contenido, ese contenido queda cubierto por el montaje en las resoluciones nuevas de esa ruta; no se borra. Tras desmontar vuelve a verse el directorio subyacente.

Un descriptor abierto antes del montaje puede seguir apuntando al directorio cubierto. Por eso conviene separar «lo que ahora resuelve la ruta» de «el objeto que ya tenía abierto el proceso». Montar y formatear son operaciones distintas: montar interpreta un formato existente; mkfs crea sus estructuras.

3. Inspeccionar con findmnt

$ findmnt
$ findmnt --target "$HOME" --output TARGET,SOURCE,FSTYPE,OPTIONS
$ findmnt --target / --output TARGET,SOURCE,FSTYPE,OPTIONS
$ findmnt --mountpoint /ruta/exacta --output TARGET,SOURCE,FSTYPE,OPTIONS

--target busca qué montaje contiene una ruta. --mountpoint pregunta por un punto de montaje exacto: un directorio normal puede estar dentro del sistema raíz sin ser por sí mismo un punto de montaje. Confundir ambas consultas puede llevar a interpretar mal una comprobación después de umount.

findmnt consulta normalmente el estado del espacio de nombres actual. --fstab permite consultar la configuración estática en vez del estado activo. Cuando una salida se procesa en un programa, se eligen columnas y formato explícitos. Véase findmnt(8).

El archivo imagen también pertenece a algún sistema de archivos anfitrión. Consultar --target sobre volumen.img muestra ese anfitrión; consultar sobre el directorio montado muestra el ext4 conectado.

4. mount y autorización

mount -t tipo -o opciones origen punto_de_montaje

# En el laboratorio se usará únicamente una imagen nueva propia:
sudo mount -t ext4 -o loop,nodev,nosuid,noexec "$IMG" "$MNT"

En el montaje habitual de un sistema de bloques se necesita autorización, normalmente CAP_SYS_ADMIN en el contexto pertinente. sudo es una herramienta para ejecutar la orden con la autorización configurada, no una propiedad del formato ext4. Ser UID 0 dentro de un contenedor no asegura disponer de esa capacidad. Véase mount(2).

Hay montajes delegados mediante fstab y mecanismos específicos con reglas propias. Aquí separaremos las operaciones ordinarias sobre el archivo imagen de las órdenes de montaje que sí requieren administración. El retorno de mount se comprueba antes de escribir bajo el destino.

Si no se puede montar en el entorno disponible, se puede crear e inspeccionar la imagen; eso no demuestra que el montaje haya ocurrido. La sintaxis y las opciones se documentan en mount(8).

5. Opciones y límites de la política

Las opciones de montaje y los permisos del objeto son capas diferentes. Una carpeta rw no concede escritura si sus permisos la deniegan, y un archivo 0666 puede seguir sin ser modificable por un montaje ro.

Solo lectura para las operaciones ordinarias tampoco significa que toda implementación deje intacto un medio al montarlo: ext4 puede necesitar recuperación del journal en determinadas condiciones. El ensayo utilizará una imagen nueva y desmontajes limpios; no es un procedimiento de análisis forense.

6. Desmontar y entender un destino ocupado

umount retira la conexión del árbol. Se prefiere nombrar el punto de montaje, porque un mismo origen podría estar conectado en varios destinos. La orden correcta se llama umount, sin la n de «unmount».

$ cd -- "$LAB30"
$ sudo umount "$MNT"
$ findmnt --mountpoint "$MNT"

Un directorio de trabajo dentro del montaje, archivos abiertos u otras referencias pueden impedir un desmontaje normal con «target is busy». Se identifica el proceso o recurso y se cierra antes de repetir. Los montajes hijos también importan. Véase umount(8).

umount -l separa de inmediato el montaje del árbol y difiere la liberación; -f está destinado a situaciones específicas. No son equivalentes a haber terminado limpiamente el ensayo. Tampoco sync sustituye a umount: sincronizar no retira el montaje ni libera todas sus referencias.

7. La cadena archivo → loop → sistema de archivos

Sistema de archivos anfitrión
    └─ volumen.img (archivo regular de 64 MiB)
          └─ /dev/loopN (interfaz de bloques)
                └─ ext4 (interpreta los bloques)
                      └─ punto de montaje (lo conecta al árbol)

Un loop permite presentar un archivo como dispositivo de bloques. El archivo sigue ocupando espacio en su anfitrión; crear un sistema de archivos dentro no genera capacidad física nueva. Puede haber restricciones de espacio, cuota o soporte en ambos niveles.

La imagen del laboratorio contiene ext4 directamente desde el principio del archivo, sin tabla de particiones. Una imagen de disco con particiones es otro caso: no se asume que todo archivo .img pueda montarse del mismo modo.

losetup consulta y administra asociaciones loop. Los números son dinámicos: nunca se supone que el ensayo utilizará loop0. Véase losetup(8).

8. Crear una imagen nueva con dd y mkfs

Usa Bash en Linux, GNU coreutils, util-linux y e2fsprogs. Se necesitan 64 MiB para la imagen y espacio adicional para el laboratorio. En WSL utiliza el sistema de archivos Linux de la distribución. La parte de montaje requiere soporte loop, ext4 y autorización administrativa.

$ LAB30=$(mktemp -d "$HOME/tema30.XXXXXX")
$ IMG="$LAB30/volumen.img"
$ MNT="$LAB30/mnt"
$ mkdir -- "$MNT"
$ printf 'archivo del directorio base\n' > "$MNT/previo.txt"
$ printf 'LAB=%s\nIMG=%s\nMNT=%s\n' "$LAB30" "$IMG" "$MNT"
$ dd if=/dev/zero of="$IMG" bs=1M count=64 conv=excl status=progress
$ stat -c 'nombre=%n tamaño=%s tipo=%F' -- "$IMG"

Con GNU dd, 1M son 1 048 576 bytes: se esperan 67 108 864 bytes. conv=excl exige que el archivo de salida no exista; así no se reutiliza silenciosamente una imagen anterior. dd escribe bytes, pero todavía no crea un sistema de archivos. Véase dd(1).

$ test -f "$IMG" && test ! -L "$IMG" && test "$(stat -c %s -- "$IMG")" -eq 67108864
$ mkfs.ext4 -F -L CURSO30 "$IMG"
$ blkid -p "$IMG"

Ejecuta mkfs solamente si la comprobación anterior fue satisfactoria. La etiqueta CURSO30 ayuda a reconocer el volumen, pero no constituye un identificador único. mkfs.ext4 crea metadatos, inodos y journal según sus opciones y configuración. Véase mke2fs(8).

9. Montar la imagen y escribir un dato propio

Continúa con las mismas variables de la sección anterior. Antes de montar debe poder leerse previo.txt. Después, ese nombre quedará cubierto por la raíz del ext4; la imagen recién creada suele contener lost+found.

$ cat -- "$MNT/previo.txt"
$ sudo mount -t ext4 -o loop,nodev,nosuid,noexec "$IMG" "$MNT"
$ findmnt --mountpoint "$MNT" --output TARGET,SOURCE,FSTYPE,OPTIONS
$ ls -la -- "$MNT"

Si mount falla, se detiene esta etapa. No se escribe bajo MNT suponiendo que el volumen está conectado: se podría estar escribiendo en la carpeta base. Verifica tipo, origen y opciones observadas.

$ sudo install -d -m 0700 -o "$(id -u)" -g "$(id -g)" "$MNT/datos"
$ printf 'datos persistentes\n' > "$MNT/datos/nota.txt"
$ cat -- "$MNT/datos/nota.txt"
$ findmnt --target "$IMG" --output TARGET,SOURCE,FSTYPE
$ findmnt --target "$MNT/datos/nota.txt" --output TARGET,SOURCE,FSTYPE
$ LOOP30=$(findmnt -rn --mountpoint "$MNT" --output SOURCE)
$ sudo losetup --list --output NAME,BACK-FILE,AUTOCLEAR "$LOOP30"

El nuevo ext4 conserva sus propios UID/GID: ser dueño del archivo volumen.img no convierte automáticamente al usuario en dueño de la raíz interna. Por eso se crea datos con propiedad explícita, sin abrir los permisos del volumen a todos.

10. Programa en C: descriptor anterior y ruta actual

Guarda observar-montaje.c en LAB30, fuera del punto de montaje. El programa abre un directorio, consulta fstat, espera y vuelve a comparar esa referencia con una resolución nueva de la ruta. Relaciona la conexión de montaje con lo aprendido en el tema 29.

#define _POSIX_C_SOURCE 200809L
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <inttypes.h>
#include <stdio.h>

static void mostrar(const char *etapa, const struct stat *st)
{
    printf("%s dev=%ju ino=%ju uid=%ju modo=%04jo\n", etapa,
           (uintmax_t)st->st_dev, (uintmax_t)st->st_ino,
           (uintmax_t)st->st_uid, (uintmax_t)(st->st_mode & 07777));
}

int main(int argc, char **argv)
{
    if (argc != 2) {
        fprintf(stderr, "Uso: %s directorio\n", argv[0]); return 2;
    }
    int fd = open(argv[1], O_RDONLY | O_DIRECTORY | O_CLOEXEC);
    if (fd == -1) { perror("open directorio"); return 1; }
    struct stat st;
    int resultado = 1;
    if (fstat(fd, &st) == -1) { perror("fstat inicial"); goto fin; }
    mostrar("ANTES_FD", &st);
    puts("LISTO: realizar el montaje en otra terminal y pulsar Enter aquí");
    if (fflush(stdout) == EOF) { perror("fflush"); goto fin; }
    if (getchar() != '\n') {
        fprintf(stderr, "Se esperaba una línea vacía\n"); goto fin;
    }
    if (fstat(fd, &st) == -1) { perror("fstat final"); goto fin; }
    mostrar("DESPUES_FD", &st);
    if (stat(argv[1], &st) == -1) { perror("stat ruta actual"); goto fin; }
    mostrar("DESPUES_RUTA", &st);
    resultado = 0;
fin:
    if (close(fd) == -1) { perror("close"); resultado = 1; }
    return resultado;
}

$ cc -std=c11 -Wall -Wextra -Wpedantic -O2 observar-montaje.c -o observar-montaje

La práctica opcional se hace en un segundo ciclo, cuando la imagen esté desmontada. En la primera terminal ejecuta el programa con MNT y déjalo en LISTO. En otra terminal usa las rutas absolutas que imprimiste para montar esa imagen en ese destino. Vuelve a la primera y pulsa Enter.

$ ./observar-montaje "$MNT"

En la segunda terminal vuelve a definir IMG y MNT con las rutas impresas del laboratorio antes de ejecutar mount. Al terminar la observación, desmonta normalmente ese segundo montaje antes de continuar con otra etapa.

ANTES_FD y DESPUES_FD deben conservar identidad; DESPUES_RUTA observa la raíz del ext4 montado. st_dev no es un identificador único de montaje: un bind mount puede compartir dispositivo. Aquí se contrasta una imagen ext4 diferente con el directorio base.

11. Cambiar a solo lectura y comprobarlo

Con el montaje activo y sin escritores pendientes, solicita un remount de solo lectura. Verifica el resultado observado; una petición de cambio puede fallar.

$ sudo mount -o remount,ro "$MNT"
$ findmnt --mountpoint "$MNT" --output TARGET,SOURCE,OPTIONS
$ python3 - "$MNT/datos/prueba-ro" <<'PY'
import errno
import os
import sys
try:
    fd = os.open(sys.argv[1], os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o600)
except OSError as exc:
    if exc.errno != errno.EROFS:
        raise
    print("Correcto: escritura rechazada con EROFS")
else:
    os.close(fd)
    raise SystemExit("Inesperado: se creó el archivo; revisar montaje y opciones")
PY

El ensayo exige EROFS, no cualquier error. EACCES indicaría una denegación de permisos distinta; EEXIST indicaría un nombre ya usado. La lectura de nota.txt debe seguir siendo posible.

Si necesitas continuar escribiendo, puedes solicitar remount,rw y volver a consultar findmnt. El cambio de montaje no reescribe los bits rwx del archivo.

12. Desmontar, volver a montar y comprobar persistencia

$ cd -- "$LAB30"
$ sudo umount "$MNT"
$ if findmnt -rn --mountpoint "$MNT"; then
    printf 'El destino continúa montado\n'
  else
    printf 'No se encontró un montaje exacto en el destino\n'
  fi
$ cat -- "$MNT/previo.txt"

Debe reaparecer previo.txt, y datos/nota.txt ya no se resuelve bajo la carpeta base. Eso no significa que los datos internos se borraron. Con la asociación automática de mount -o loop, las herramientas modernas suelen gestionar la liberación del loop mediante autoclear; se comprueba con losetup -j sobre la imagen.

$ sudo losetup -j "$IMG"
$ sudo mount -t ext4 -o loop,ro,nodev,nosuid,noexec "$IMG" "$MNT"
$ cat -- "$MNT/datos/nota.txt"
$ sudo umount "$MNT"
$ e2fsck -fn "$IMG"

Ejecuta e2fsck únicamente después de un desmontaje satisfactorio y cuando la imagen no esté en uso en otro destino. -n abre en modo de solo lectura y responde no a cambios; -f solicita una comprobación completa. Si hay errores, se investigan; no se añade una reparación automática a un ensayo aún montado. Véase e2fsck(8).

13. Asociación loop explícita y ciclo de vida

La alternativa explícita separa la asociación de bloques y el montaje. Úsala como otro ciclo con la misma imagen ya desmontada, no a la vez que el anterior. El valor devuelto por losetup es el único dispositivo que administra este ensayo.

$ LOOP30=$(sudo losetup --find --show -- "$IMG")
$ printf 'Loop asignado: %s\n' "$LOOP30"
$ sudo mount -t ext4 -o nodev,nosuid,noexec "$LOOP30" "$MNT"
$ findmnt --mountpoint "$MNT" --output TARGET,SOURCE,FSTYPE,OPTIONS
$ cat -- "$MNT/datos/nota.txt"
$ sudo umount "$MNT"
$ sudo losetup --detach "$LOOP30"
$ sudo losetup -j "$IMG"

Si mount falla después de crear la asociación, queda pendiente liberar ese loop concreto. Si umount falla, primero se resuelven sus referencias. No se usa losetup -D, porque afectaría asociaciones ajenas al ensayo.

El kernel puede diferir la destrucción de una asociación ocupada. Por eso una solicitud de detach no equivale a demostrar que nadie la usa. El flujo de práctica desmonta normalmente y luego libera la asociación explícita.

14. fstab: configuración, no fotografía del estado

/etc/fstab describe sistemas que pueden montarse y sus políticas. Cada línea habitual tiene seis campos: origen, destino, tipo, opciones, frecuencia de dump y orden de comprobación. No se modifica la configuración del equipo para realizar este laboratorio.

# origen             destino        tipo  opciones                         dump pass
UUID=uuid-real       /srv/datos     ext4  defaults,nodev,nosuid              0    2
/ruta/volumen.img    /ruta/mnt      ext4  loop,noauto,nodev,nosuid,noexec    0    0

UUID identifica el sistema de archivos; copiar una imagen puede duplicarlo. noauto evita la participación normal en mount -a. defaults no es una política restrictiva universal. El último campo se interpreta por las herramientas de comprobación, con el valor 1 tradicionalmente reservado para la raíz y 2 para otros sistemas que correspondan. Véase fstab(5).

Para practicar, escribe una tabla candidata dentro de LAB30. Los espacios y tabuladores en los campos de rutas necesitan escapes; las comillas de shell no son el formato de escape de fstab.

$ python3 - "$IMG" "$MNT" "$LAB30/fstab.ejemplo" <<'PY'
import sys
from pathlib import Path
def campo(s):
    return s.replace("\\", "\\134").replace(" ", "\\040").replace("\t", "\\011")
origen, destino, salida = sys.argv[1:]
Path(salida).write_text(
    f"{campo(origen)} {campo(destino)} ext4 loop,noauto,nodev,nosuid,noexec 0 0\n")
PY
$ findmnt --verify --tab-file "$LAB30/fstab.ejemplo"

Validar la tabla no ejecuta sus montajes ni demuestra que el kernel los aceptará. Una instalación permanente también requiere revisar cómo el sistema de inicio consume los cambios; no se usa mount -a como prueba global de un único ejemplo.

Algunas versiones de findmnt --verify muestran una advertencia porque la fuente es un archivo regular. En esta entrada loop ese origen es intencional; se contrasta la advertencia con la configuración concreta, sin ignorar errores de rutas, opciones o sintaxis.

15. Verificador final del laboratorio

Tras las etapas anteriores deja la imagen desmontada y sin la asociación explícita. Guarda verificar-tema30.py en LAB30. El programa observa la imagen y usa debugfs en lectura para comprobar un archivo interno sin volver a montar. Sin -w, esa herramienta abre el sistema de archivos en solo lectura; véase debugfs(8).

import os
from pathlib import Path
import stat
import subprocess
import sys

if len(sys.argv) != 2:
    raise SystemExit("Uso: python3 verificar-tema30.py directorio-laboratorio")
lab = Path(sys.argv[1]).resolve(strict=True)
imagen = lab / "volumen.img"
punto = lab / "mnt"
assert not imagen.is_symlink() and stat.S_ISREG(imagen.stat().st_mode)
assert imagen.stat().st_size == 64 * 1024 * 1024
p = subprocess.run(["findmnt", "-rn", "--mountpoint", str(punto)],
                   capture_output=True, text=True)
assert p.returncode == 1 and not p.stdout, "Desmontar antes de verificar"
assert (punto / "previo.txt").read_text() == "archivo del directorio base\n"
assert not (punto / "datos").exists(), "Debe verse nuevamente el directorio base"
with imagen.open("rb") as f:
    f.seek(1024 + 56)
    assert f.read(2) == b"\x53\xef", "Firma ext compatible esperada"
# La firma sola no distingue ext2, ext3 y ext4.
tipo = subprocess.check_output(
    ["blkid", "-p", "-s", "TYPE", "-o", "value", str(imagen)], text=True).strip()
assert tipo == "ext4", tipo
contenido = subprocess.run(
    ["debugfs", "-R", "cat /datos/nota.txt", str(imagen)],
    capture_output=True, text=True, check=True)
assert contenido.stdout == "datos persistentes\n", contenido.stderr
print("Correctos: imagen de 64 MiB, ext4, montaje retirado y contenido persistente")
print("Imagen conservada en", imagen)

$ python3 verificar-tema30.py "$LAB30"
$ printf 'Laboratorio conservado en %s\n' "$LAB30"

El verificador exige un destino exacto desmontado y el contenido esperado de la carpeta base y del ext4. La firma 0xEF53 por sí sola solo reconoce la familia ext; blkid aporta la identificación de ext4. No es una verificación completa de integridad: para eso está la etapa separada de e2fsck.

Conserva la imagen para repetir las consultas. Antes de cualquier limpieza, comprueba que no queda un montaje activo ni una asociación que necesites retirar. El tamaño lógico del archivo y su ocupación física pueden diferir; el tema 32 estudiará estadísticas del volumen.

16. Simuladores de árbol y ciclo de montaje

Qué objeto se ve bajo el mismo nombre

La carpeta base contiene previo.txt. El ext4 contiene datos/nota.txt. El espacio B no tiene ese montaje. El modelo solo representa conexiones y nombres, sin permisos ni errores del kernel.

Respetar el orden de las operaciones

Este panel representa una asociación loop explícita. Abrir un recurso agrega una referencia que impide el desmontaje normal del modelo. Para guiar el flujo, el panel rechaza liberar un loop montado; no simula la liberación diferida del kernel.

17. Diagnóstico y resumen

• Montar conecta un sistema de archivos al árbol visible del proceso.
• Origen, tipo y destino cumplen funciones diferentes.
• Los archivos cubiertos permanecen en el directorio base.
• Una imagen, un loop y un montaje son tres recursos distintos.
• dd crea bytes; mkfs crea estructuras; mount las hace accesibles.
• Las opciones del montaje se combinan con la protección de los objetos.
• Se cierran referencias antes de desmontar y liberar el loop explícito.
• fstab expresa configuración; findmnt permite contrastarla con el estado.
• El contenido debe persistir tras desmontar y volver a montar limpiamente.

18. Preguntas de repaso y práctica

Para practicar

1. Consulta el montaje que contiene tu HOME y distingue origen, tipo y destino.
2. Realiza el laboratorio y conserva las salidas de findmnt antes y después.
3. Explica por qué previo.txt reaparece al desmontar.
4. Compara las vistas de los dos espacios en el primer simulador.
5. Ejecuta el observador C durante un segundo montaje y compara los tres registros de identidad.
6. Comprueba ro mediante EROFS y explica por qué un cambio de chmod no lo corrige.
7. Provoca y resuelve un montaje ocupado manteniendo otra terminal dentro de MNT.
8. Usa el segundo simulador para completar el ciclo sin recursos pendientes.
9. Compara la asociación automática con la explícita y registra AUTOCLEAR.
10. Valida fstab.ejemplo y explica por qué eso no monta el volumen.
11. Identifica qué espacio ocupa la imagen en el anfitrión y qué capacidad reporta el ext4 interno.
12. Enumera lo que debe comprobarse antes de reutilizar o eliminar una imagen de práctica.

En el tema 31 estudiaremos el VFS y los sistemas de archivos especiales: la capa común que permite trabajar con recursos de orígenes muy diferentes.