Discos y espacio

1. Disco, partición, sistema de archivos, montaje

Entre el aparato físico y el directorio en que se guardan los archivos hay cuatro niveles. Los nombramos todos en temas anteriores; conviene verlos juntos, porque cada comando de este tema trabaja sobre uno distinto.

El sistema de archivos es el nivel que suele pasarse por alto. Una partición recién creada es espacio en bruto; darle un sistema de archivos es lo que comúnmente se llama formatear. Hay varios, y se los reconoce por su nombre en la salida de los comandos:

2. lsblk: qué dispositivos hay

lsblk, de list block devices, muestra los discos y sus particiones en forma de árbol. Es el comando para saber qué hay conectado y cómo se llama.

$ lsblk
NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
loop0    7:0    0     4K  1 loop /snap/bare/5
loop1    7:1    0  73,9M  1 loop /snap/core22/2139
loop2    7:2    0 251,4M  1 loop /snap/firefox/7024
loop3    7:3    0   516M  1 loop /snap/gnome-42-2204/202
loop4    7:4    0  91,7M  1 loop /snap/gtk-common-themes/1535
loop5    7:5    0  10,8M  1 loop /snap/snap-store/1270
loop6    7:6    0  50,8M  1 loop /snap/snapd/25202
sda      8:0    0 238,5G  0 disk
├─sda1   8:1    0     1G  0 part /boot/efi
└─sda2   8:2    0 237,4G  0 part /

Las siete primeras líneas son la consecuencia que anticipamos en el tema 36: cada snap instalado es un archivo montado como un pequeño disco de solo lectura, y por eso figura como dispositivo loop. No son discos, y estorban. Todos comparten el número mayor 7, y lsblk permite excluir por ese número:

$ lsblk -e 7
NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
sda      8:0    0 238,5G  0 disk
├─sda1   8:1    0     1G  0 part /boot/efi
└─sda2   8:2    0 237,4G  0 part /
$ lsblk -e 7 -o NAME,FSTYPE,LABEL,UUID,MOUNTPOINTS
NAME   FSTYPE LABEL UUID                                 MOUNTPOINTS
sda
├─sda1 vfat         6C1A-9F3E                            /boot/efi
└─sda2 ext4         3b8f2c6e-71d4-4a0b-9c55-0e2f7a91d6b3 /

Con -o se eligen las columnas. La segunda forma agrega los datos del nivel siguiente: el tipo de sistema de archivos, su etiqueta —un nombre que se le puede dar, y que aquí nadie puso— y su UUID, un identificador único que se genera al formatear. Volveremos a él en la sección 13. lsblk -f muestra una selección parecida sin tener que enumerarla.

Los nombres siguen las convenciones del tema 8, según la clase de dispositivo:

La letra de los sd no es fija. Una memoria USB será sdb hoy y quizá sdc mañana, si se conecta después de otra. Por eso el nombre se averigua cada vez, con lsblk, y nunca se da por sabido.

3. df: cuánto espacio queda

df, de disk free, informa el espacio total, usado y libre de cada sistema de archivos montado. Como free, se usa casi siempre con -h.

$ df -h
Filesystem      Size  Used Avail Use% Mounted on
tmpfs           784M  2,1M  782M   1% /run
/dev/sda2       233G   61G  161G  28% /
tmpfs           3,9G   48M  3,8G   2% /dev/shm
tmpfs           5,0M  8,0K  5,0M   1% /run/lock
/dev/loop1       74M   74M     0 100% /snap/core22/2139
/dev/loop2      252M  252M     0 100% /snap/firefox/7024
…
/dev/sda1       1,1G  6,2M  1,1G   1% /boot/efi
tmpfs           784M  128K  784M   1% /run/user/1000

De todas las líneas, en este equipo importa una: la resaltada. Las demás son ruido que hay que aprender a reconocer, y que df permite quitar excluyendo por tipo, con -x:

$ df -h -x tmpfs -x squashfs -x efivarfs
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda2       233G   61G  161G  28% /
/dev/sda1       1,1G  6,2M  1,1G   1% /boot/efi
$ df -hT /
Filesystem     Type  Size  Used Avail Use% Mounted on
/dev/sda2      ext4  233G   61G  161G  28% /

Las versiones recientes de df omiten por su cuenta parte de ese ruido; si en tu sistema no aparecen las líneas loop, tanto mejor. Una línea así es un buen candidato para el alias del tema 5, o para el .bashrc del tema 34.

La última forma es la más útil y la menos conocida. A df se le puede dar cualquier archivo o directorio, y responde con el sistema de archivos que lo contiene:

$ df -h ~/practica
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda2       233G   61G  161G  28% /
$ df -h /tmp /dev/shm /boot/efi
Filesystem      Size  Used Avail Use% Mounted on
/dev/sda2       233G   61G  161G  28% /
tmpfs           3,9G   48M  3,8G   2% /dev/shm
/dev/sda1       1,1G  6,2M  1,1G   1% /boot/efi
$ df -h .                              # «¿cuánto lugar hay donde estoy parado?»

Responde de una vez dos preguntas: en qué disco está realmente un directorio, y cuánto lugar queda allí. Antes de copiar algo grande, df -h . es la verificación que evita quedarse a mitad de camino.

4. Leer df sin equivocarse

Tres detalles de esa salida confunden a quien la mira por primera vez.

Los sistemas de archivos que no son discos

Las líneas tmpfs no ocupan nada del disco: son directorios que viven en la memoria. /run guarda datos de los programas en ejecución, y /dev/shm es el que usamos en el tema 14 como ejemplo de «otro sistema de archivos». Su tamaño es un tope, no una reserva: solo consumen la memoria de lo que contienen. Y las líneas loop de los snaps muestran 100% porque un sistema de archivos de solo lectura está, por definición, completo. No es una alarma.

Las cuentas que no cierran

En la línea de sda2, 61 usados más 161 disponibles dan 222, no 233. Y la partición, según lsblk, medía 237,4. Las dos diferencias tienen explicación:

La reserva tiene un propósito. Cuando un usuario o un programa llenan el disco, a root y a los servicios del sistema les queda todavía un margen para seguir funcionando, iniciar sesión y hacer limpieza. Por eso Use% se calcula sobre lo que un usuario común puede usar, y un disco puede marcar 100% con espacio que solo root ve.

Los inodos también se agotan

En el tema 14 vimos que cada archivo necesita un inodo, y que los inodos están en una tabla del sistema de archivos. En ext4 esa tabla tiene un tamaño fijo, decidido al formatear. Se puede, entonces, quedar sin inodos teniendo espacio de sobra:

$ df -i /
Filesystem       Inodes  IUsed    IFree IUse% Mounted on
/dev/sda2      15564800 412683 15152117    3% /

Quince millones y medio de inodos, de los que hay en uso cuatrocientos mil: este equipo está lejos. El problema aparece en servidores donde algún programa crea millones de archivos diminutos —sesiones, cachés, correos en cola— y nadie los borra. El síntoma es desconcertante: No space left on device al crear un archivo, mientras df -h muestra gigabytes libres. Ante ese mensaje, la segunda verificación es siempre df -i.

5. du: cuánto ocupa un directorio

df dice cuánto hay ocupado, pero no por quién. La pregunta inversa —cuánto pesa este directorio— la responde du, de disk usage, que recorre un directorio y suma lo que ocupa cada archivo que encuentra.

$ cd ~/practica
$ ls -ld fotos
drwxrwxr-x 2 ana ana 4096 oct  3 18:20 fotos
$ du -sh fotos
836K	fotos
$ du -sh .
1,2M	.

Es la respuesta que quedó pendiente en el tema 7. Los 4096 bytes que muestra ls -l son lo que ocupa el directorio en sí, su lista de nombres; du informa lo que ocupa con todo lo que tiene dentro. Sin opciones, du escribe una línea por cada subdirectorio, en bloques de un kibibyte, lo que rara vez se quiere. Las dos letras de -sh lo arreglan:

Con varios argumentos, o con un comodín, da un total por cada uno. Es la forma de comparar los contenidos de un directorio:

$ du -sh ~/Descargas ~/Vídeos ~/practica
12G	/home/ana/Descargas
23G	/home/ana/Vídeos
1,2M	/home/ana/practica
$ du -sch *.txt | tail -n 1             # cuánto suman los .txt de aquí
56K	total

Dos advertencias de uso. du tiene que leer cada directorio que recorre, de modo que sobre un árbol grande tarda —la primera vez; la segunda, la caché del tema 37 lo acelera—, y donde no tiene permiso de lectura responde Permission denied y no cuenta lo que hay. Para medir fuera del directorio personal se usa con sudo.

6. Ordenar y profundizar

La utilidad real de du aparece al combinarlo. La pregunta habitual no es cuánto pesa un directorio, sino cuál de sus subdirectorios es el que pesa. Se arma con tres piezas conocidas: du a un nivel de profundidad, el sort -h del tema 26, que ordena cantidades con unidades, y tail.

$ du -h --max-depth=1 ~ | sort -h | tail -n 7
1,2M	/home/ana/practica
310M	/home/ana/.config
1,4G	/home/ana/snap
3,6G	/home/ana/.cache
12G	/home/ana/Descargas
23G	/home/ana/Vídeos
41G	/home/ana

du -h --max-depth=1 ~ | sort -h | tail -n 7
       │                   │         │
       │                   │         └─ quedarse con los siete mayores
       │                   └─ ordenar entendiendo K, M y G
       └─ un total por cada subdirectorio inmediato

La última línea es el total del directorio, y las anteriores, sus partes, de menor a mayor. Aparecen también los directorios ocultos, y es una de las razones para preferir esta forma a du -sh *: el asterisco, como vimos en el tema 9, no incluye los nombres que empiezan con punto, y es justamente en ~/.cache y ~/.local donde suelen esconderse los gigabytes.

El método es repetir el comando, bajando cada vez por la rama más pesada. Para el sistema entero:

$ sudo du -xh --max-depth=1 / 2> /dev/null | sort -h | tail -n 5
212M	/boot
7,4G	/var
9,8G	/usr
41G	/home
61G	/
$ sudo du -xh --max-depth=1 /var | sort -h | tail -n 4
212M	/var/cache
1,3G	/var/log
5,9G	/var/lib
7,4G	/var

Aquí la opción -x es imprescindible. Sin ella, du entraría en /proc, en /run, en cada snap montado y en cualquier disco externo conectado, y sumaría como espacio del disco cosas que no están en él. Con ella, el total de la última línea —61 G— coincide con el Used de df. Las partes listadas no llegan a sumar ese total porque --max-depth muestra directorios, y en la raíz hay también un archivo: los 2 G de /swap.img.

7. Por qué los tamaños no coinciden

ls -l y du miden cosas distintas, y por eso dan números distintos para el mismo archivo.

El tamaño de un archivo es la cantidad de bytes de su contenido. El espacio ocupado es la cantidad de bloques del disco que tiene asignados. ls -l muestra lo primero; du, lo segundo.

$ ls -l estado.txt
-rw-rw-r-- 1 ana ana 437 oct 13 09:58 estado.txt
$ du -h estado.txt
4,0K	estado.txt
$ du -h --apparent-size estado.txt
437	estado.txt

El sistema de archivos reparte el espacio en bloques, que en ext4 son de 4096 bytes. Un archivo de 437 bytes ocupa un bloque entero, y uno de 4097, dos. La diferencia es insignificante en un archivo, y considerable en un millón: un directorio con muchísimos archivos pequeños ocupa bastante más que la suma de sus tamaños. Los dos números están, por lo demás, en la salida de stat, en los campos Size y Blocks.

La diferencia también puede ir en el otro sentido. Un archivo puede declarar un tamaño enorme y no ocupar casi nada, si tiene tramos que nunca se escribieron: el sistema de archivos no les asigna bloques. Se llaman archivos dispersos, y se fabrica uno con truncate, que fija el tamaño de un archivo sin escribir en él:

$ truncate -s 1G hueco.img
$ ls -lh hueco.img
-rw-rw-r-- 1 ana ana 1,0G oct 13 10:31 hueco.img
$ du -h hueco.img
0	hueco.img
$ rm hueco.img

No es una curiosidad: así son las imágenes de disco de las máquinas virtuales, que declaran 40 G y ocupan lo que realmente tengan escrito. Quien las mide con ls se asusta sin motivo.

Para saber cuánto lugar se va a recuperar borrando algo, el número que vale es el de du. Para saber cuánto se va a transferir al copiarlo a otro equipo, el de du --apparent-size.

8. Encontrar qué llena el disco

El caso práctico del tema: df muestra un sistema de archivos al 95 %, y hay que encontrar adónde fue el espacio. Es un procedimiento, y siempre el mismo.

1. Identificar cuál se llena: df -h. Anotar el punto de montaje. dónde
2. Descartar los inodos: df -i, si hay espacio y aun así no se puede escribir. dónde
3. Medir el primer nivel: sudo du -xh --max-depth=1 /punto | sort -h | tail. quién
4. Bajar por la rama más pesada, repitiendo el comando, hasta dar con el directorio o el archivo. quién
5. Decidir qué hacer con lo encontrado, con el método que corresponda a cada cosa. limpiar

Los pasos tres y cuatro tienen una versión interactiva, que hace el recorrido una sola vez y deja navegar el resultado. Es ncdu, el paquete que instalamos en el tema 35:

$ ncdu ~
ncdu 1.19 ~ Use the arrow keys to navigate, press ? for help
--- /home/ana -----------------------------------------------------------------
   23,0 GiB [##########] /Vídeos
   12,0 GiB [#####     ] /Descargas
    3,6 GiB [#         ] /.cache
    1,4 GiB [          ] /snap
  310,2 MiB [          ] /.config
  188,4 MiB [          ] /.local
    1,2 MiB [          ] /practica
…
 Total disk usage:  41,0 GiB  Apparent size:  40,8 GiB  Items: 184213

Para el disco del sistema se lo invoca como sudo ncdu -x /, con la misma -x que du y por la misma razón. La tecla d borra de verdad, sin papelera, y con sudo puede borrar cualquier cosa: conviene usar ncdu para encontrar, y borrar después con el comando adecuado.

Un tercer camino, cuando se sospecha de archivos sueltos y no de directorios, es el find del tema 10: sudo find / -xdev -type f -size +500M lista todos los archivos de más de 500 MiB del sistema de archivos raíz.

Los lugares donde el espacio suele irse, y la manera correcta de recuperarlo en cada uno:

La regla general: lo que pertenece a un programa se limpia con ese programa. Borrar con rm dentro de /var/lib o /usr deja inconsistente la base de datos de quien administra esos archivos, por lo que vimos en el tema 35.

9. Cuando df y du no están de acuerdo

A veces el procedimiento anterior no cierra: df dice que hay 200 G usados, y du, sumando todo, encuentra 120. Faltan 80 que no están en ningún directorio. Tiene tres explicaciones posibles, y la primera es la más frecuente.

Archivos borrados que siguen abiertos

En el tema 14 vimos qué hace rm en realidad: quita un nombre, y el espacio se libera cuando no queda ningún nombre y ningún programa tiene el archivo abierto. Si un servicio escribe en un registro y alguien lo borra para hacer lugar, el archivo desaparece de los directorios —du ya no lo ve— pero sigue existiendo y creciendo, y df lo cuenta. Se los encuentra con lsof, que lista los archivos abiertos por los procesos:

$ sudo lsof +L1
COMMAND   PID   USER   FD   TYPE DEVICE    SIZE/OFF NLINK    NODE NAME
rsyslogd  812 syslog   7w   REG    8,2 85899345920     0 1311045 /var/log/syslog.1 (deleted)

La opción +L1 pide los archivos abiertos con menos de un enlace, es decir, sin ningún nombre. Aquí hay uno de 80 G, marcado (deleted), en manos del proceso 812. El espacio vuelve en el momento en que ese proceso lo cierra, lo que se consigue reiniciando el servicio, como veremos en el tema 39. La lección es de método: un registro que crece no se borra. Se lo vacía, con > archivo, la redirección sin comando del tema 23, que deja el mismo archivo con cero bytes.

Archivos tapados por un montaje

Si se monta un disco sobre un directorio que no estaba vacío, lo que había queda oculto —no borrado— mientras dure el montaje, como veremos en la sección 11. Sigue ocupando lugar en el disco de abajo, y ningún du puede llegar a verlo.

La reserva y lo que du no pudo leer

La reserva del 5 % de la sección 4 explica diferencias en el espacio disponible, no en el usado. Y un du ejecutado sin sudo saltea todo lo que no puede leer: si hubo mensajes de Permission denied, el total es incompleto.

10. Montar: el árbol único

Queda la segunda deuda. En el tema 6 dijimos que Linux no tiene letras de unidad: hay un solo árbol, y un segundo disco aparece como un directorio más.

Montar un sistema de archivos es asociarlo a un directorio del árbol, el punto de montaje. A partir de ese momento, lo que se ve al entrar en ese directorio es el contenido del sistema de archivos montado. Desmontar es deshacer la asociación.

Todo el árbol se arma así. Al arrancar, el kernel monta un sistema de archivos en /, y sobre él se van montando los demás: la partición de arranque en /boot/efi, los de memoria en /run y /dev/shm, el de /proc, cada snap en su directorio. La consecuencia práctica es la que venimos aprovechando desde el tema 6: ningún comando necesita saber en qué disco está un archivo. cp, grep y find trabajan con rutas, y cruzan de un disco a otro sin enterarse.

Para ver qué hay montado, y dónde, el comando es findmnt:

$ findmnt -t ext4,vfat
TARGET      SOURCE    FSTYPE OPTIONS
/           /dev/sda2 ext4   rw,relatime
└─/boot/efi /dev/sda1 vfat   rw,relatime,fmask=0077,dmask=0077,codepage=437,…
$ findmnt -T ~/practica                 # ¿a qué montaje pertenece esta ruta?
TARGET SOURCE    FSTYPE OPTIONS
/      /dev/sda2 ext4   rw,relatime

Sin opciones, findmnt muestra el árbol completo de montajes, que en un sistema actual tiene varias decenas de líneas; el filtro -t lo reduce a los tipos que interesan. La misma información, sin formato, la da mount ejecutado sin argumentos, y viene de /proc/mounts.

En un escritorio, montar ocurre solo. Al conectar una memoria USB, el sistema la detecta, la monta en /media/usuario/ETIQUETA y la muestra en el administrador de archivos:

$ lsblk -e 7
NAME   MAJ:MIN RM   SIZE RO TYPE MOUNTPOINTS
sda      8:0    0 238,5G  0 disk
├─sda1   8:1    0     1G  0 part /boot/efi
└─sda2   8:2    0 237,4G  0 part /
sdb      8:16   1  14,9G  0 disk
└─sdb1   8:17   1  14,9G  0 part /media/ana/DATOS
$ ls /media/ana/DATOS
fotos  informe.pdf
$ df -h /media/ana/DATOS
Filesystem      Size  Used Avail Use% Mounted on
/dev/sdb1        15G  3,2G   12G  22% /media/ana/DATOS

Las dos líneas nuevas son el disco sdb, con un 1 en la columna RM porque es extraíble, y su única partición, ya montada. DATOS es la etiqueta de la memoria; si no tuviera, el directorio llevaría su UUID. Comparar la salida de lsblk antes y después de conectar es la manera segura de saber qué nombre recibió el dispositivo.

11. mount: montar a mano

En un servidor no hay escritorio que monte nada, y aun en un escritorio a veces hace falta elegir dónde o con qué opciones. El comando es mount, con dos argumentos: qué se monta y dónde.

sudo mount /dev/sdb1 /mnt
             │        │
             │        └─ el punto de montaje: un directorio que ya existe
             └─ el dispositivo: la partición, no el disco

Para probarlo con la memoria, primero se deshace el montaje automático, con el comando que usa el propio escritorio y que no pide privilegios:

$ udisksctl unmount -b /dev/sdb1
Unmounted /dev/sdb1.
$ ls /mnt                              # vacío: es un directorio común
$ sudo mount /dev/sdb1 /mnt
$ ls -l /mnt
total 2180
drwxr-xr-x 2 root root   16384 sep 20 11:05 fotos
-rwxr-xr-x 1 root root 2213894 oct  2 17:44 informe.pdf
$ touch /mnt/prueba.txt
touch: cannot touch '/mnt/prueba.txt': Permission denied

El montaje funcionó: mount detectó por su cuenta el tipo de sistema de archivos, y el contenido de la memoria está en /mnt, el directorio que el tema 8 reservó para esto. Pero todo figura como propiedad de root, y no se puede escribir. La causa está en la tabla de la sección 1: vfat no guarda dueños ni permisos. Linux tiene que inventarlos, y sin otra indicación le asigna todo a quien montó. Se corrige con una opción de montaje, usando el id del tema 16 para no tener que recordar el propio número de usuario:

$ sudo umount /mnt
$ sudo mount -o uid=$(id -u),gid=$(id -g) /dev/sdb1 /mnt
$ ls -l /mnt | tail -n 1
-rwxr-xr-x 1 ana ana 2213894 oct  2 17:44 informe.pdf
$ touch /mnt/prueba.txt               # ahora sí

Esto explica también por qué en una memoria USB chmod y chown no tienen efecto, y por qué todos los archivos aparecen como ejecutables: no hay dónde guardar esos datos. Un disco externo formateado con ext4 se comporta como el resto del sistema, con sus dueños y permisos de verdad.

La opción loop cierra el círculo abierto con los snaps. Un archivo que contiene un sistema de archivos —típicamente la imagen .iso de un disco de instalación— se puede montar y recorrer sin grabarlo en ningún lado:

$ sudo mount -o loop ~/Descargas/ubuntu-24.04.3-desktop-amd64.iso /mnt
mount: /mnt: WARNING: source write-protected, mounted read-only.
$ ls /mnt
boot  boot.catalog  casper  dists  EFI  install  md5sum.txt  pool
$ sudo umount /mnt

La advertencia es informativa: una imagen ISO es de solo lectura por naturaleza. Mientras está montada, aparece en lsblk como un loop más.

Quien no tenga una memoria a mano puede practicar igual. Un sistema de archivos en memoria no necesita ningún dispositivo:

$ sudo mount -t tmpfs -o size=64M tmpfs /mnt
$ df -h /mnt
Filesystem      Size  Used Avail Use% Mounted on
tmpfs            64M     0   64M   0% /mnt
$ sudo cp /etc/hostname /mnt/ && ls /mnt
hostname
$ sudo umount /mnt && ls /mnt          # desmontado: /mnt vuelve a estar vacío

12. umount: desmontar

El comando se llama umount, sin la primera n de unmount: es una abreviatura de los años setenta, y el error de tipeo más repetido del tema. Recibe el punto de montaje o el dispositivo, indistintamente.

$ cd /mnt/fotos
$ sudo umount /mnt
umount: /mnt: target is busy.
$ cd ~
$ sudo umount /mnt
$ ls /mnt                              # vacío otra vez

Un sistema de archivos no se puede desmontar mientras alguien lo usa, y «usarlo» incluye lo más inocente: tener una shell parada dentro, que fue lo que ocurrió aquí. Es el error que todos cometen, y casi siempre el culpable es uno mismo, en esa terminal o en otra.

Hay una opción para forzar la salida, umount -l, que desprende el montaje del árbol de inmediato y lo desmonta de verdad cuando deja de estar en uso. Sirve para destrabar una carpeta de red que no responde. No sirve como atajo antes de desconectar un dispositivo, porque no garantiza que la escritura haya terminado.

13. /etc/fstab: los montajes permanentes

Lo montado con mount dura hasta que se lo desmonta, o hasta el próximo reinicio. Los sistemas de archivos que deben estar siempre —empezando por la raíz— se declaran en un archivo de texto, que el sistema lee al arrancar.

$ cat /etc/fstab
# <file system> <mount point>   <type>  <options>       <dump>  <pass>
# / was on /dev/sda2 during curtin installation
/dev/disk/by-uuid/3b8f2c6e-71d4-4a0b-9c55-0e2f7a91d6b3 / ext4 defaults 0 1
# /boot/efi was on /dev/sda1 during curtin installation
/dev/disk/by-uuid/6C1A-9F3E /boot/efi vfat defaults 0 1
/swap.img	none	swap	sw	0	0

Cada línea es un montaje, con seis campos separados por espacios o tabulaciones:

La tercera línea es el área de intercambio del tema 37, que se declara aquí aunque no se monte en ningún directorio. Y el primer campo explica para qué sirve el UUID: como la letra de sdb puede cambiar de un arranque a otro, identificar un disco por su nombre es frágil. El UUID viaja con el sistema de archivos, y lo señala sin ambigüedad esté donde esté conectado. Se lo consulta con lsblk -f, o con sudo blkid:

$ sudo blkid /dev/sdb1
/dev/sdb1: LABEL="DATOS" UUID="4C2B-91A7" BLOCK_SIZE="512" TYPE="vfat"
$ ls -l /dev/disk/by-uuid/ | awk '{print $9, $10, $11}'

3b8f2c6e-71d4-4a0b-9c55-0e2f7a91d6b3 -> ../../sda2
4C2B-91A7 -> ../../sdb1
6C1A-9F3E -> ../../sda1

El directorio /dev/disk/by-uuid está hecho de enlaces simbólicos, uno por cada sistema de archivos, que el sistema mantiene al día: una aplicación directa del tema 14.

Para que un disco de datos se monte en cada arranque se agrega una línea. Por ejemplo, para un disco externo que debe aparecer en /datos:

UUID=9d1c5e20-4f6a-4b7e-a2c3-58e0b1f7d944  /datos  ext4  defaults,nofail  0  2

Una ventaja adicional: lo que está en fstab se puede montar nombrando solo el punto de montaje, sudo mount /datos, porque el resto de los datos ya está escrito.

14. Recetas y errores comunes

La referencia del tema:

Con este tema el sistema queda inventariado: procesador, memoria y discos. Pero un sistema no es solo sus recursos. Buena parte de lo que hace lo hacen programas que nadie lanzó desde una terminal y que trabajan en silencio: el que atiende la red, el que registra los eventos, el que ejecuta las actualizaciones automáticas. Varias veces en este bloque dijimos «se reinicia el servicio» o «queda anotado en el registro». En el tema 39 aprendemos a hacer las dos cosas, con systemctl y journalctl.

15. Resumen

• Un disco se divide en particiones; cada partición lleva un sistema de archivos, y cada sistema de archivos se hace visible en un punto de montaje.
• lsblk lista los discos y particiones. Los loop son archivos montados, como los snaps, y se excluyen con -e 7. El nombre de un dispositivo extraíble se averigua cada vez.
• df -h muestra el espacio de cada sistema de archivos montado. df -h ruta muestra el que contiene a esa ruta.
• Los tmpfs están en la memoria, no en el disco. En ext4, un 5 % se reserva para root.
• Los inodos también se agotan: df -i es la segunda verificación ante un No space left on device.
• du -sh informa cuánto ocupa un directorio con todo su contenido, que es lo que ls -l no dice.
• du -h --max-depth=1 | sort -h muestra qué subdirectorio pesa más. Con -x, sin salir del sistema de archivos.
• ls -l muestra el tamaño de un archivo y du, el espacio que ocupa, que se asigna en bloques de 4 K. Un archivo disperso puede ocupar mucho menos que su tamaño.
• Un disco lleno se investiga en orden: df para saber dónde, du o ncdu para saber quién, y la herramienta de cada programa para limpiar.
• Un archivo borrado que un proceso mantiene abierto sigue ocupando espacio: lo ve df y no du. Se lo encuentra con lsof +L1.
• Montar es asociar un sistema de archivos a un directorio del árbol. findmnt muestra lo montado.
• sudo mount dispositivo directorio monta; -o ro en solo lectura, -o loop una imagen. Se monta sobre un directorio vacío.
• vfat no guarda dueños ni permisos: se asignan al montar, con uid y gid.
• umount desmonta, y no vuelve hasta que todo está escrito: por eso se desmonta antes de desconectar. Si responde target is busy, algo lo está usando.
• /etc/fstab declara los montajes permanentes, identificados por UUID. Se prueba con sudo mount -a antes de reiniciar.

16. Preguntas de repaso

Intenta responder cada una antes de abrir la respuesta.

Para practicar

1. Ejecuta lsblk, lsblk -e 7 y lsblk -f. ¿Cuántos discos reales tienes, cuántas particiones, y qué sistema de archivos tiene cada una?
2. Muestra el espacio de los sistemas de archivos reales, excluyendo los de memoria y los snaps. Crea un alias para ese comando y agrégalo a tu .bashrc.
3. Averigua con df -h en qué sistema de archivos están ~, /tmp, /dev/shm, /boot y /run. ¿Cuáles están en el disco y cuáles en la memoria?
4. Compara df -h / con df -H /, y con df -i /. Calcula qué porcentaje de los inodos está en uso.
5. Mide ~/practica con du -sh. Luego lista sus elementos con du -ah, ordenados por tamaño. ¿Cuál es el archivo más grande?
6. Encuentra los cinco subdirectorios más pesados de tu directorio personal. Compara el resultado con el de du -sh ~/*: ¿qué directorios no aparecen en el segundo?
7. Crea un archivo con una sola letra y compara ls -l, du -h y du -h --apparent-size. Repite con un archivo disperso de 500 MiB creado con truncate, y bórralo.
8. Con sudo du -xh --max-depth=1, recorre el disco del sistema desde /, bajando tres niveles por la rama más pesada. Haz el mismo recorrido con sudo ncdu -x /, sin borrar nada.
9. Ejecuta findmnt -t ext4,vfat y cat /etc/fstab. Relaciona cada línea del archivo con un montaje, y cada UUID con la salida de lsblk -f.
10. Monta en /mnt un tmpfs de 32 MiB. Compruébalo con df -h /mnt y findmnt /mnt, copia dentro un archivo, intenta desmontarlo desde adentro, sal y desmóntalo. Si tienes una memoria USB, repite montándola a mano con tus permisos, y expúlsala con udisksctl.