Comparar ext4, NTFS y FAT

1. Formato, proveedor y herramienta de copia

Los temas 36, 37 y 38 mostraron estructuras de FAT, ext4 y NTFS. Ahora las compararemos desde la aplicación: no basta con saber qué puede representar el disco si el proveedor utilizado no expone esa función o la herramienta de transferencia no la conserva.

Compatibilidad de una operación: que el conjunto de formato, proveedor, opciones, permisos y herramienta permita realizarla con la semántica requerida. Reconocer un volumen o leer un archivo sencillo es una comprobación más limitada.

Un volumen NTFS bajo el proveedor nativo de Windows, ntfs3 o NTFS-3G no debe tratarse como tres entornos idénticos. Lo mismo ocurre con ext4 y sus características por directorio, o FAT con permisos presentados mediante opciones de montaje.

2. Matriz de características y alcance

En este tema FAT significa FAT32 salvo indicación contraria. FAT12 y FAT16 tienen otros rangos de volumen. exFAT aparece separado porque su formato y sus decisiones de asignación no equivalen a ampliar una FAT32.

La comparación de funcionalidades de Microsoft permite contrastar las familias de Windows. El journal de ext4 puede depender de las características del volumen; no se deduce solo de su nombre. TexFAT es una extensión y queda fuera de la columna exFAT básico.

3. Tamaño de archivo y tamaño de volumen

Espacio libre, máximo de un archivo y capacidad del volumen son límites distintos. También intervienen cuotas, arquitectura, API, versión del proveedor y opciones de creación. No se calcula el máximo de un archivo a partir de df.

Los cálculos de ext4 están en Blocks. Las condiciones de NTFS se explican en NTFS overview, y las de exFAT en su especificación. Una capacidad que cabe en un campo no demuestra soporte de toda la pila.

Archivo de vídeo: 6 GiB
Espacio libre en FAT32: 100 GiB

Resultado: el archivo individual no cabe en el límite de FAT32.
Dividirlo o usar otro formato exige decidir cómo lo consumirá el equipo receptor.

4. Permisos y traducción de identidades

En ext4, UID, GID, modo y ACL forman parte de un modelo de acceso. NTFS conserva descriptores de seguridad con identidades y reglas propias. Una copia puede necesitar traducir identidades, herencia y entradas de acceso; copiar bytes no realiza esa traducción.

En FAT32, una vista Linux puede mostrar propietario y permisos elegidos mediante uid, gid, umask, fmask o dmask. Eso no significa que cada archivo guarde esos valores de manera independiente. Véase VFAT.

Que chmod tenga éxito o que ls muestre rwx no acredita que el destino conserve la intención de seguridad tras otro montaje o desde otro sistema. La prueba debe consultar la representación efectiva y, cuando sea necesario, ensayar accesos con las identidades pertinentes.

La documentación de NTFS3 muestra opciones propias del proveedor Linux. No se presupone una traducción universal entre todas las ACL de NTFS y todas las ACL POSIX.

5. Nombres, mayúsculas y reglas de las API

Los nombres Caso.txt y caso.txt pueden ser distintos o equivalentes según el directorio y el proveedor. ext4 admite configuraciones de casefold; Windows puede habilitar sensibilidad a mayúsculas por directorio en determinados entornos NTFS. No se transforma una observación local en regla de toda la familia.

La codificación, longitud de un componente, caracteres reservados y convenciones de ruta también importan. Un límite expresado en bytes no equivale a otro expresado en unidades Unicode. Un nombre que el formato puede almacenar quizá no sea accesible con una API concreta.

Caso.txt y caso.txt  → posible colisión de nombres
un nombre reservado → posible rechazo o interpretación especial por la API
una ruta extensa    → límite de API distinto del límite por componente
caracteres Unicode  → revisar codificación y comparación del destino

Consulta Case sensitivity, Naming files, paths and namespaces y la guía de ext4. El programa de ensayo crea solo nombres ASCII conocidos y no pretende validar todo Unicode.

6. Journal, persistencia y recuperación

ext4 y NTFS ofrecen mecanismos de recuperación de metadatos, pero no el mismo protocolo ni los mismos modos de datos. FAT32 y exFAT básico no aportan un journal equivalente. Ninguno convierte automáticamente varias escrituras de la aplicación en una transacción lógica completa.

Un journal no sustituye una copia externa ni asegura el contenido más reciente si la aplicación no lo confirmó. Los protocolos de publicación y sincronización deben implementarse con las API y garantías del entorno concreto.

No se mide tolerancia a fallos matando únicamente un proceso: el kernel sigue activo. El laboratorio compara contenido y observaciones controladas, sin cortes de energía ni reparaciones sobre datos ajenos.

7. Contenido, enlaces, huecos y flujos

Dos archivos con los mismos bytes pueden tener distinta asignación y metadatos. Un archivo disperso puede convertirse en uno completamente asignado al copiarse; conserva su lectura lógica, pero necesita más espacio. Una red de hard links puede convertirse en copias independientes.

En NTFS, el flujo principal no representa todos los $DATA nombrados. Las herramientas deben conservarlos o transformarlos mediante una política explícita. La documentación de flujos distingue sus tamaños y estados.

1. Contenido principal: tamaño y hash de bytes.
2. Estructura: nombres, directorios y relaciones de enlaces.
3. Contenido adicional: flujos nombrados y atributos requeridos.
4. Seguridad: identidades y reglas de acceso previstas.
5. Uso: abrir y restaurar con la aplicación receptora.

Un contenedor o un archivo de respaldo puede preservar metadatos que el destino no representa directamente. En ese caso, no se afirma que los archivos desplegados tengan la misma semántica: la conservación se verifica al restaurar el contenedor.

8. Portabilidad entre equipos y dispositivos

Para un sistema Linux que necesita semántica Unix, ext4 es un candidato natural. Para un entorno Windows con ACL y flujos NTFS, NTFS suele ser el punto de partida. En intercambio de archivos entre equipos puede ser útil exFAT o FAT32, siempre que todos los receptores admitan el formato y los tamaños necesarios.

En una cámara, consola, firmware o equipo antiguo manda la documentación del modelo y su versión. «USB» describe una conexión, no qué sistemas de archivos acepta. Una tabla general no demuestra que un receptor concreto lea exFAT o NTFS.

Lectura y escritura tampoco son el mismo requisito. Hay que comprobar soporte de escritura, extracción segura, herramientas de recuperación, actualizaciones del controlador y comportamiento con las aplicaciones reales. Si el acceso es por red, el cliente observa además el protocolo de red y la configuración del servidor.

9. Qué comparar en una prueba de rendimiento

Una prueba útil fija dispositivo, tamaño de volumen, unidad de asignación, proveedor, opciones, cantidad y tamaño de archivos, caché y punto de confirmación. Cronometrar una copia que acaba en caché y compararla con otra que espera sincronización mezcla objetivos.

Hay cargas con archivos grandes secuenciales, muchas entradas pequeñas, búsquedas por nombre, sobrescrituras o publicación de versiones. Las estructuras explican posibles costes; no determinan por sí solas un ganador para todas las cargas.

Las unidades de asignación grandes pueden aumentar el espacio sobrante del último bloque de muchos archivos pequeños. El caso real también incluye metadatos, residencia NTFS, datos inline, compresión, huecos y reservas. El segundo simulador aísla únicamente el redondeo, sin atribuir un tamaño fijo a cada familia.

Las imágenes del laboratorio no son una prueba de velocidad. Su espacio ocupado en el anfitrión depende, entre otras cosas, de cómo se crearon y de que puedan ser dispersas. No se compara ls -l de tres imágenes de igual longitud para deducir eficiencia interna.

10. Diseñar y verificar una migración

1. Inventariar tamaños, nombres, enlaces, flujos y metadatos necesarios.
2. Definir qué se conserva directamente y qué requiere traducción o contenedor.
3. Comprobar límites, espacio, proveedor y opciones del destino.
4. Copiar un conjunto de prueba representativo sin sustituir el original.
5. Verificar bytes y propiedades necesarias, registrando errores y omisiones.
6. Probar apertura, restauración y operación con el consumidor final.

El inventario debe incluir colisiones previsibles, no solo el tamaño total. Un directorio con dos nombres que el destino considera iguales necesita una decisión previa; el éxito de copiar uno no valida la migración del conjunto.

El hash del flujo principal es una evidencia concreta de contenido, pero no demuestra ACL, ADS ni relaciones entre inodos. Tampoco una copia de lectura de archivos que cambian constantemente constituye una instantánea coherente: coordina el origen cuando sea necesario.

11. Resolver escenarios con requisitos explícitos

El criterio no es sumar casillas «sí». Un solo requisito obligatorio incumplido puede descartar una opción. Si el soporte del receptor es desconocido, el resultado es una comprobación pendiente, no una compatibilidad inventada.

12. Programa en C: consultar el destino abierto

Guarda consultar-destino.c. En Linux abre un directorio, obtiene el tipo que informa fstatfs y consulta unidades y espacio disponible con fstatvfs. También pregunta NAME_MAX y LINK_MAX mediante fpathconf. No escribe ni identifica un formato leyendo su sector inicial.

#define _POSIX_C_SOURCE 200809L
#include <sys/vfs.h>
#include <sys/statvfs.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdio.h>
#include <errno.h>

static const char *familia(unsigned long tipo)
{
    switch (tipo) {
    case 0xef53: return "familia_ext_no_distingue_ext2_ext3_ext4";
    case 0x4d44: return "familia_FAT_no_distingue_FAT12_FAT16_FAT32";
    case 0x5346544e: return "NTFS_segun_el_proveedor";
    case 0x2011bab0: return "exFAT_segun_el_proveedor";
    case 0x65735546: return "FUSE_no_identifica_el_formato_subyacente";
    default: return "otro_o_no_identificado";
    }
}
static int limite(int fd, int clave, const char *nombre)
{
    errno = 0;
    long n = fpathconf(fd, clave);
    if (n == -1) {
        if (errno) { perror(nombre); return 1; }
        printf("%s=indeterminado\n", nombre);
    } else printf("%s=%ld\n", nombre, n);
    return 0;
}
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 | O_NOFOLLOW);
    if (fd == -1) { perror("open"); return 1; }
    int estado = 0;
    struct statfs tipo;
    struct statvfs v;
    if (fstatfs(fd, &tipo) == -1) { perror("fstatfs"); estado = 1; }
    else {
        unsigned long magic = (unsigned long)tipo.f_type;
        printf("TYPE=0x%lx\nFAMILY=%s\n", magic, familia(magic));
    }
    if (fstatvfs(fd, &v) == -1) { perror("fstatvfs"); estado = 1; }
    else {
        uintmax_t unidad = (uintmax_t)v.f_frsize, disponibles = (uintmax_t)v.f_bavail;
        printf("FRSIZE=%ju\nBAVAIL=%ju\n", unidad, disponibles);
        if (unidad && disponibles <= UINTMAX_MAX / unidad)
            printf("AVAILABLE_BYTES=%ju\n", unidad * disponibles);
        else puts("AVAILABLE_BYTES=no_calculable_con_estas_unidades");
        printf("READ_ONLY=%s\n", (v.f_flag & ST_RDONLY) ? "si" : "no");
    }
    if (limite(fd, _PC_NAME_MAX, "NAME_MAX")) estado = 1;
    if (limite(fd, _PC_LINK_MAX, "LINK_MAX")) estado = 1;
    if (close(fd) == -1) { perror("close"); estado = 1; }
    return estado;
}

fpathconf puede devolver -1 sin error para un resultado indeterminado; por eso se pone errno a cero antes. NAME_MAX describe la consulta de esa interfaz y no demuestra que todos los nombres de esa longitud sean aceptables. Véase fpathconf(3).

f_type identifica lo que informa el proveedor. La familia ext comparte una firma y FUSE puede ocultar el formato interno. Contrasta con findmnt; consulta statfs(2). AVAILABLE_BYTES es una observación, no una reserva ni el límite por archivo; sus unidades se describen en statvfs(3).

13. Programa en C: observar semántica en un directorio propio

Guarda ensayar-semantica.c. Crea un subdirectorio exclusivo dentro de una ubicación propia y prueba dos nombres, un hard link, un cambio de modo y una escritura tras un hueco. Conserva los archivos para inspección. No modifica archivos preexistentes ni borra nada.

#define _POSIX_C_SOURCE 200809L
#define _FILE_OFFSET_BITS 64
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <stdio.h>
#include <stdint.h>
#include <inttypes.h>
#include <stdlib.h>
#include <errno.h>

static void fallo(const char *s) { perror(s); exit(1); }
static void cerrar(int fd) { if (close(fd) == -1) fallo("close"); }
static void escribir(int fd, const char *p, size_t n)
{
    while (n) {
        ssize_t r = write(fd, p, n);
        if (r > 0) { p += r; n -= (size_t)r; }
        else if (r == -1 && errno == EINTR) continue;
        else { if (r == 0) errno = EIO; fallo("write"); }
    }
}
static void confirmar(int fd)
{
    int r;
    do { r = fsync(fd); } while (r == -1 && errno == EINTR);
    if (r == -1) fallo("fsync archivo");
}
int main(int argc, char **argv)
{
    if (argc != 2) { fprintf(stderr, "Uso: %s directorio-propio\n", argv[0]); return 2; }
    int padre = open(argv[1], O_RDONLY | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW);
    if (padre == -1) fallo("open padre");
    char nombre[80];
    int creado = 0;
    for (unsigned i = 0; i < 100; i++) {
        snprintf(nombre, sizeof nombre, "prueba39-%ld-%u", (long)getpid(), i);
        if (mkdirat(padre, nombre, 0700) == 0) { creado = 1; break; }
        if (errno != EEXIST) fallo("mkdirat");
    }
    if (!creado) { fprintf(stderr, "No se obtuvo un nombre exclusivo.\n"); return 1; }
    int dir = openat(padre, nombre, O_RDONLY | O_DIRECTORY | O_CLOEXEC | O_NOFOLLOW);
    if (dir == -1) fallo("openat ensayo");
    printf("ENSAYO=%s\n", nombre);
    int a = openat(dir, "Caso.txt", O_RDWR | O_CREAT | O_EXCL | O_CLOEXEC, 0600);
    if (a == -1) fallo("crear Caso.txt");
    escribir(a, "A\n", 2); confirmar(a);
    int b = openat(dir, "caso.txt", O_RDWR | O_CREAT | O_EXCL | O_CLOEXEC, 0600);
    if (b != -1) {
        escribir(b, "B\n", 2); confirmar(b); cerrar(b);
        puts("CASE=distintos_en_este_directorio");
    } else if (errno == EEXIST) puts("CASE=equivalentes_en_este_directorio");
    else fallo("crear caso.txt");
    if (linkat(dir, "Caso.txt", dir, "enlace.txt", 0) == -1)
        printf("HARDLINK=no_observado errno=%d\n", errno);
    else {
        struct stat origen, enlace;
        if (fstat(a, &origen) == -1 || fstatat(dir, "enlace.txt", &enlace, 0) == -1)
            fallo("stat hardlink");
        if (origen.st_dev != enlace.st_dev || origen.st_ino != enlace.st_ino) {
            fprintf(stderr, "Identidad inesperada del enlace.\n"); return 1;
        }
        puts("HARDLINK=OK");
    }
    if (fchmod(a, 0640) == -1) printf("CHMOD=no_observado errno=%d\n", errno);
    else puts("CHMOD=llamada_exitosa");
    struct stat modo;
    if (fstat(a, &modo) == -1) fallo("fstat modo");
    printf("MODE_REQUESTED=0640 MODE_OBSERVED=%04o\n", (unsigned)(modo.st_mode & 0777));
    cerrar(a);
    int hueco = openat(dir, "separado.bin", O_RDWR | O_CREAT | O_EXCL | O_CLOEXEC, 0600);
    if (hueco == -1) fallo("crear separado.bin");
    if (lseek(hueco, 1048575, SEEK_SET) == (off_t)-1) fallo("lseek");
    escribir(hueco, "Z", 1); confirmar(hueco);
    struct stat s;
    if (fstat(hueco, &s) == -1) fallo("fstat separado");
    if (s.st_size != 1048576) { fprintf(stderr, "Tamano logico inesperado.\n"); return 1; }
    printf("LOGICAL_BYTES=%" PRIuMAX " ST_BLOCKS_512=%" PRIuMAX "\n",
           (uintmax_t)s.st_size, (uintmax_t)s.st_blocks);
    cerrar(hueco); cerrar(dir); cerrar(padre);
    puts("Resultados locales; no certifican persistencia de nombres ni todas las funciones.");
    return 0;
}

La ubicación debe ser propia, escribible y sin cambios adversarios de sus entradas. HARDLINK=no_observado conserva errno: el motivo puede ser formato, proveedor, permisos o política. Un fallo de enlace no demuestra por sí solo que el formato no pueda representarlo; véase link(2).

El archivo separado.bin mide 1 MiB y termina en Z. Su región anterior se lee como ceros, pero la asignación real depende del proveedor. ST_BLOCKS_512 no es una medida universal de bytes físicos exclusivos. El modo observado es el de esa sesión; no prueba conservación tras otro montaje.

14. Laboratorio de contenido en ext4, FAT32 y NTFS

Usa una sesión Bash en Linux con compilador C, Python 3, e2fsprogs, dosfstools, mtools y utilidades NTFS-3G. No se requiere montar ni ejecutar como administrador. Las tres imágenes nuevas tendrán 128 MiB lógicos cada una; comprueba antes espacio en el anfitrión.

$ cc -std=c11 -Wall -Wextra -Wpedantic -O2 consultar-destino.c -o consultar-destino
$ cc -std=c11 -Wall -Wextra -Wpedantic -O2 ensayar-semantica.c -o ensayar-semantica
$ BIN39="$PWD"
$ LAB39=$(mktemp -d "$HOME/comparar39.XXXXXX")
$ cd -- "$LAB39"
$ mkdir fuente sondas
$ printf 'contenido portatil\n' > fuente/nota.txt
$ python3 - <<'PY'
from pathlib import Path
with Path('fuente/datos.bin').open('xb') as f:
    f.write(bytes(range(256)) * 4096)
PY
$ findmnt --target "$LAB39/sondas" --output TARGET,SOURCE,FSTYPE,OPTIONS
$ "$BIN39/consultar-destino" "$LAB39/sondas"
$ "$BIN39/ensayar-semantica" "$LAB39/sondas"

Estas primeras consultas y pruebas corresponden al anfitrión. No observan todavía la semántica de los archivos interiores de las imágenes. Esa separación evita atribuir los permisos o inodos del archivo imagen al sistema que contiene.

Preparar tres volúmenes con el mismo contenido sencillo

$ truncate -s 128M ext4.img
$ truncate -s 128M fat32.img
$ truncate -s 128M ntfs.img
$ mkfs.ext4 -b 4096 -I 256 -m 0 -E lazy_itable_init=0,lazy_journal_init=0 -d fuente ext4.img
$ mkfs.fat -F 32 fat32.img
$ mkntfs -F -Q -s 512 -c 4096 -L CURSO39 ntfs.img
$ mcopy -i fat32.img fuente/nota.txt ::nota.txt
$ mcopy -i fat32.img fuente/datos.bin ::datos.bin
$ ntfscp ntfs.img fuente/nota.txt /nota.txt
$ ntfscp ntfs.img fuente/datos.bin /datos.bin

Detén la secuencia ante cualquier fallo. -F de mkntfs permite usar el archivo regular nuevo; no se aplica a dispositivos reales. No se añaden opciones para forzar acceso a volúmenes montados. Los nombres elegidos son deliberadamente simples y el conjunto no incluye ACL, ADS ni relaciones de enlaces.

Inspeccionar y extraer por la herramienta de cada formato

$ dumpe2fs -h ext4.img
$ mdir -i fat32.img ::
$ ntfsinfo -m ntfs.img
$ debugfs -R 'dump /nota.txt ext4-nota.txt' ext4.img
$ debugfs -R 'dump /datos.bin ext4-datos.bin' ext4.img
$ mcopy -i fat32.img ::nota.txt fat32-nota.txt
$ mcopy -i fat32.img ::datos.bin fat32-datos.bin
$ ntfscat ntfs.img /nota.txt > ntfs-nota.txt
$ ntfscat ntfs.img /datos.bin > ntfs-datos.bin

Comprueba los retornos y mensajes: una redirección puede crear su salida antes de que falle la extracción. debugfs se usa sin -w, en lectura. Mantén todas las imágenes desmontadas y estables durante estas consultas.

Para observar la semántica montada de cada formato, repite la sonda en directorios propios ya preparados dentro de esos montajes e identifica el proveedor con findmnt. Esa práctica requiere el soporte y autorización de montaje del entorno. El laboratorio offline no necesita esa capacidad ni pretende sustituir esa prueba.

15. Verificador de contenido y de operaciones

Ejecuta desde LAB39. El verificador compara tamaño y SHA-256 de las seis extracciones, crea un nuevo ensayo de operaciones en sondas y contrasta sus observaciones con los archivos que produjo. No exige que todos los proveedores permitan hard links o modos Unix.

$ python3 - "$BIN39/ensayar-semantica" <<'PY'
from pathlib import Path
import hashlib
import re
import subprocess
import sys

def resumen(ruta):
    h = hashlib.sha256()
    with ruta.open('rb') as f:
        for bloque in iter(lambda: f.read(1024 * 1024), b''):
            h.update(bloque)
    return ruta.stat().st_size, h.digest()

for nombre in ('nota.txt', 'datos.bin'):
    esperado = resumen(Path('fuente') / nombre)
    for formato in ('ext4', 'fat32', 'ntfs'):
        salida = Path(formato + '-' + nombre)
        if resumen(salida) != esperado:
            raise SystemExit('Contenido diferente: ' + str(salida))
        print('OK contenido:', salida)

programa = str(Path(sys.argv[1]).resolve())
r = subprocess.run([programa, str(Path('sondas').resolve())],
                   capture_output=True, text=True, check=True)
m = re.search(r'^ENSAYO=(prueba39-[0-9]+-[0-9]+)$', r.stdout, re.M)
if not m:
    raise SystemExit('No se identifico el directorio creado')
ensayo = Path('sondas') / m.group(1)
mayor, menor = ensayo / 'Caso.txt', ensayo / 'caso.txt'
if mayor.read_bytes() != b'A\n':
    raise SystemExit('Contenido original inesperado')
if 'CASE=distintos_en_este_directorio' in r.stdout:
    if menor.read_bytes() != b'B\n' or mayor.samefile(menor):
        raise SystemExit('La distincion de nombres no coincide')
elif not mayor.samefile(menor):
    raise SystemExit('La equivalencia de nombres no coincide')
if 'HARDLINK=OK' in r.stdout and not mayor.samefile(ensayo / 'enlace.txt'):
    raise SystemExit('El enlace no comparte identidad')
datos = (ensayo / 'separado.bin').read_bytes()
if datos != b'\x00' * 1048575 + b'Z':
    raise SystemExit('Contenido logico del archivo separado incorrecto')
modo = re.search(r'MODE_OBSERVED=([0-7]{4})', r.stdout)
if not modo or (mayor.stat().st_mode & 0o777) != int(modo.group(1), 8):
    raise SystemExit('El modo observado no coincide')
print(r.stdout, end='')
print('OK: contenido en tres formatos y observaciones locales de la sonda')
PY

El éxito significa que el contenido principal probado se conserva y que la sonda describe sus resultados locales. No prueba portabilidad de ACL, ADS, Unicode complejo, rendimiento ni recuperación frente a cortes. Para migrar esos casos, amplía el conjunto y la verificación según los requisitos.

16. Simuladores de requisitos y asignación

Descartar por requisitos y registrar comprobaciones pendientes

El filtro considera archivos ordinarios de hasta 1 TiB, journal habilitado cuando corresponde y conservación nativa de metadatos. Solo descarta por los requisitos modelados: no decide el soporte de un receptor ni ejecuta formateos. En FAT32 usa el límite exacto 4294967295; los demás tamaños requieren comprobar configuración real.

El coste del redondeo a una unidad de asignación

Supone archivos de igual tamaño, datos externos ordinarios y una unidad completa para cada tramo final. Compara unidades posibles, no asigna una unidad fija a ext4, NTFS o FAT. Omite metadatos, residencia, datos inline, compresión, huecos y reservas.

17. Diagnóstico y resumen

• Una comparación útil declara entorno y requisitos obligatorios.
• FAT32 y exFAT tienen límites y modelos distintos; no se mezclan bajo una única columna.
• Espacio libre, límite por archivo y capacidad del volumen son dimensiones separadas.
• Permisos, nombres, enlaces y flujos requieren pruebas además de comparar bytes.
• Journal y persistencia de la aplicación no son garantías equivalentes.
• Proveedor y opciones pueden cambiar la semántica observable de un mismo formato.
• Las pruebas de rendimiento deben fijar carga y punto de confirmación.
• La elección termina con una prueba en el receptor y una restauración verificable cuando corresponda.

18. Preguntas de repaso y práctica

Para practicar

1. Define requisitos obligatorios para un disco de sistema Linux, un conjunto Windows y un medio de intercambio.
2. Explica por qué el archivo de 6 GiB descarta FAT32 aunque sobren 100 GiB.
3. Ejecuta ambos programas en una ubicación propia e interpreta los resultados sin generalizarlos.
4. Contrasta f_type con findmnt y distingue familia de formato exacto.
5. Completa las seis extracciones y el verificador de contenido.
6. Diseña un conjunto adicional que incluya dos nombres que solo difieran en mayúsculas.
7. Formula una prueba para conservar un hard link y otra para conservar un ADS.
8. Explica qué cambia si un archivo sparse termina completamente asignado en el destino.
9. En el primer simulador, combina exigencia de ADS y archivo mayor que el límite FAT32.
10. En el segundo, calcula el sobrante para archivos vacíos, pequeños y múltiplos exactos de la unidad.
11. Propón una comparación de rendimiento que declare si mide caché o persistencia.
12. Escribe una lista de propiedades cuya restauración exigirías a un respaldo de tu proyecto.

En el tema 40 volveremos al formato en disco para leer el superbloque de ext4 desde C, interpretar sus campos y verificar la firma 0xEF53 con límites explícitos.