Tutorial de Debian 13 / Diagnosticar bloques, inodos y archivos borrados abiertos con df y du
Cuando no puede escribir archivos en Debian 13, primero debe verificar por separado la capacidad de bloques y los inodos de la ruta en cuestión. Si el espacio usado no disminuye y el espacio libre no aumenta después de eliminar archivos, revise si hay archivos eliminados que aún estén abiertos, y si es un problema de /tmp, verifique el límite de tmpfs, que es independiente del disco raíz. En este tutorial, comparamos tres causas en un pequeño espacio de práctica dedicado sin eliminar archivos de servicios en producción.
Comience con la ruta que falló
Un inodo es un objeto en el sistema de archivos que gestiona información como el tipo de archivo, permisos, propiedad y ubicación de los datos. Incluso los archivos vacíos usan inodos, por lo que puede que no pueda crear nuevos archivos aunque haya mucho espacio a nivel de bytes. Por el contrario, unos pocos archivos grandes pueden agotar los bloques.
Adapte las rutas de los comandos siguientes al lugar donde realmente falló la escritura. Es importante no juzgar /var/tmp y /tmp juntos como un problema del disco raíz.
findmnt --target /var/tmp -o TARGET,SOURCE,FSTYPE,OPTIONS
df -hT /var/tmp
df -i /var/tmp
sudo du -x -h --max-depth=1 /var | sort -h
findmnt muestra el montaje real que contiene la ruta, y df muestra el espacio de ese sistema de archivos. df -i verifica la disponibilidad de inodos. du suma los archivos vinculados bajo el árbol de directorios accesible, y -x evita cruzar hacia otros sistemas de archivos. Si ocurren errores de permisos, el total está incompleto. No oculte esos errores y luego trate el total como preciso. Ejecutar du en un árbol grande lleva tiempo y realiza operaciones de entrada y salida (E/S), así que limite el rango desde la ruta problemática.
| Resultados de la observación | Causas para verificar primero | Determinación de acciones |
|---|---|---|
| Casi no queda espacio de bloques, pero los inodos permanecen | Archivos grandes, registros, aumento de datos reales | Verifique el servicio propietario y la política de retención, y planifique para mover, rotar o expandir. |
| Quedan bloques, pero no inodos | Un número muy grande de archivos pequeños, aumento de caché o cola | Identifique el directorio problemático y la causa de creación, luego use la función de limpieza de la aplicación. |
| df muestra un uso alto, pero el total de du es pequeño | Archivos eliminados abiertos, archivos ocultos por montajes, diferencias de permisos o de alcance de agregación | Compare con el mismo sistema de archivos y permisos, luego investigue el proceso y la estructura de montaje. |
| / tiene espacio disponible, pero escribir en /tmp falla. | Tamaño y límites de inodos de un tmpfs separado o estado de la memoria. | Verifique df y las opciones de montaje de /tmp junto con free. |
Permission denied (permiso denegado), Read-only file system (sistema de archivos de solo lectura) y Disk quota exceeded (cuota excedida) indican causas diferentes de la falta de espacio. Incluso si hay espacio disponible, puede ocurrir un fallo debido a la propiedad, listas de control de acceso (ACL, Access Control Lists), montajes de solo lectura o cuotas. Debido al espacio reservado y los metadatos en ext4, df y el tamaño del contenido del archivo no necesitan coincidir exactamente. Las discrepancias de espacio por sí solas no determinan la corrupción.
Compare el agotamiento de bloques e inodos en un tmpfs de 4 MiB
El laboratorio utiliza Python 3, e2fsprogs (mkfs.ext4 y e2fsck), util-linux (mount, findmnt y losetup), y las herramientas estándar de archivos de GNU. Consulte command -v python3 mkfs.ext4 e2fsck mount findmnt losetup truncate df du primero. Si falta algo, inspeccione los cambios del paquete antes de instalar el paquete de Debian necesario. Ejecute la configuración en una sesión de Bash dedicada: un fallo inesperado bajo set -euo pipefail puede cerrar esa shell. Reconéctese si es necesario, inspeccione el montaje y los archivos del laboratorio, luego use la limpieza dirigida en lugar de recrear los recursos sobre ellos.
Se requiere una VM de práctica separada de Debian 13, un usuario normal que pueda usar sudo y Python 3. El ejemplo a continuación crea un tmpfs dedicado de hasta 4MiB y 32 inodos sin llenar /tmp. tmpfs utiliza memoria virtual, y si el intercambio (swap) está habilitado, algunas páginas pueden ir al swap. No suponga que se almacena solo en RAM física, y los contenidos se pierden cuando se desmonta.
El siguiente bloque debe ejecutarse en el mismo terminal de Bash. Si la ruta ya existe, deténgase y examine su contenido y uso; no la elimine para saltarse esa comprobación. En la VM de la prueba original, el UID y GID del usuario normal eran ambos 1000, pero los comandos usan los valores de la cuenta actual.
set -euo pipefail
tm=/mnt/lf-space24-tmpfs
if test -e "$tm"; then
echo "Path already exists: $tm" >&2
exit 1
fi
sudo mkdir "$tm"
sudo mount -t tmpfs -o "size=4M,nr_inodes=32,uid=$(id -u),gid=$(id -g),mode=0700,nosuid,nodev" tmpfs "$tm"
findmnt --mountpoint "$tm"
Después de verificar que el resultado del montaje es tmpfs y que el tamaño corresponde a 4MiB, ejecute el siguiente ejemplo completo como un usuario normal. Los intentos de escritura están limitados a un máximo de 8MiB, y el número de archivos vacíos está limitado a un máximo de 40. Solo se maneja el error esperado ENOSPC (No space left on device, no queda espacio en el dispositivo), y otros errores detendrán el proceso.
python3 - <<'PY'
import errno, pathlib, subprocess
p=pathlib.Path('/mnt/lf-space24-tmpfs')
try:
with (p/'fill.bin').open('xb') as f:
for i in range(8):
f.write(b'x' * 1048576)
f.flush()
except OSError as e:
if e.errno != errno.ENOSPC: raise
print('BLOCK_LIMIT_ENOSPC', flush=True)
else:
raise RuntimeError('Expected bounded block exhaustion')
subprocess.run(['df','-hT',str(p)],check=True)
subprocess.run(['df','-i',str(p)],check=True)
(p/'fill.bin').unlink()
created=[]
try:
for i in range(40):
f=p/f'empty-{i}'
f.touch(exist_ok=False)
created.append(f)
except OSError as e:
if e.errno != errno.ENOSPC: raise
print('INODE_LIMIT_ENOSPC',len(created),flush=True)
else:
raise RuntimeError('Expected bounded inode exhaustion')
subprocess.run(['df','-hT',str(p)],check=True)
subprocess.run(['df','-i',str(p)],check=True)
for f in created: f.unlink()
PY
La prueba original, con kernel 6.12.107 y Python 3.13.5, produjo los resultados siguientes, correspondientes al agotamiento de dos recursos diferentes. Los 32 inodos incluyen el directorio de nivel superior del montaje, por lo que la falla ocurrió después de crear 31 archivos vacíos.
| Experimento | Uso de bloques | Uso de inodos |
|---|---|---|
| Escribiendo en fill.bin | 4.0MiB / 4.0MiB, libre 0 | 2 / 32, libre 30 |
| Eliminar fill.bin, luego crear archivos vacíos | Usado 0, Libre 4.0MiB | 32 / 32, Libre 0 |
El archivo creado será eliminado cuando el ejemplo termine. Si fue interrumpido por otro error en el medio, primero verifique el objetivo de montaje y los archivos dentro. Este tmpfs es solo para datos de práctica desechables, por lo que puede desmontarlo con el siguiente comando fuera del directorio de trabajo. Si obtiene un error que dice que está en uso, mueva el directorio actual de cada shell relevante fuera de esta ruta y cierre cualquier manejador de archivos mantenido por procesos del laboratorio antes de intentar nuevamente.
cd "$HOME"
sudo umount /mnt/lf-space24-tmpfs
sudo rmdir /mnt/lf-space24-tmpfs
Observe el espacio retenido por un archivo eliminado que sigue abierto
Eliminar un nombre de archivo con la operación unlink y cerrar un archivo abierto son cosas diferentes. Incluso si el último nombre en un directorio desaparece, si un proceso todavía lo tiene abierto, el espacio del archivo puede conservarse. Si elimina siempre los registros con rm, podría crear esta situación y perder los nombres que pretendía investigar.
Lo siguiente es una práctica para crear ext4 dentro de un nuevo archivo regular de 64MiB. Esto no inicializa un dispositivo de disco real. Primero, verifique que haya más de 64MiB de espacio libre en el sistema de archivos raíz y un poco de espacio de trabajo adicional. Si la misma ruta ya existe, deténgase e investigue su uso. Ejecute todo el bloque de preparación a continuación en la misma terminal de Bash también.
set -euo pipefail
base=/var/lib/lf-space24
em=/mnt/lf-space24-ext4
df -hT /var/lib /mnt
for p in "$base" "$em"; do
if test -e "$p"; then
echo "Path already exists: $p" >&2
exit 1
fi
done
sudo install -d -m 700 "$base"
sudo mkdir "$em"
sudo truncate -s 64M "$base/space.img"
sudo mkfs.ext4 "$base/space.img"
sudo mount -o loop,nosuid,nodev "$base/space.img" "$em"
findmnt --mountpoint "$em"
sudo install -d -o "$(id -u)" -g "$(id -g)" "$em/work"
Los archivos creados con truncate son inicialmente archivos dispersos, por lo que el tamaño lógico de 64MiB no se asigna físicamente de inmediato. Los metadatos del sistema de archivos y las escrituras posteriores usan espacio real. El objetivo de mkfs debe ser el archivo recién creado space.img y no debe reemplazarse con un nombre de disco como /dev/sda.
El lost+found de ext4 puede no ser legible por usuarios normales, por lo que sin cambiar la propiedad imprudentemente, solo se mide el directorio de trabajo separado. El siguiente código abre y escribe un archivo de 8MiB, elimina su nombre y compara antes y después de cerrar el archivo dentro del mismo proceso.
python3 - <<'PY'
import os,pathlib,subprocess
p=pathlib.Path('/mnt/lf-space24-ext4/work')
def used():
return int(subprocess.check_output(['df','--output=used','-B1',str(p)],text=True).splitlines()[1])
def show(label):
os.sync()
print(label,flush=True)
subprocess.run(['df','-B1',str(p)],check=True)
subprocess.run(['du','-B1','-s',str(p)],check=True)
baseline=used()
f=(p/'held.bin').open('xb')
for i in range(8): f.write(b'x'*1048576)
f.flush();os.fsync(f.fileno())
show('BEFORE_UNLINK');before=used()
(p/'held.bin').unlink()
print('OPEN_FD',os.readlink(f'/proc/self/fd/{f.fileno()}'),flush=True)
show('UNLINKED_OPEN');held=used()
f.close()
show('AFTER_CLOSE');released=used()
if not (before >= baseline+8388608 and held == before and released < held):
raise RuntimeError((baseline,before,held,released))
print('DELETED_OPEN_FILE_RELEASE_PASSED',baseline,before,held,released,flush=True)
PY
| Tiempo | df bytes usados | du: bytes totales del directorio work |
|---|---|---|
| Después de escribir un archivo de 8MiB | 8 436 736 | 8 389 632 |
| Nombre eliminado, archivo aún abierto | 8 436 736 | 1024 |
| Después de cerrar el archivo | 48 128 | 1024 |
Las cifras anteriores son las mediciones reales de esta imagen de práctica y pueden variar dependiendo de las opciones de creación del sistema de archivos y la versión. El resultado importante es que después de eliminar el nombre, solo disminuyó du mientras que df permaneció igual, y después de cerrar, el uso de df también disminuyó. La salida de /proc/self/fd mostró held.bin (deleted). os.sync solo sincroniza las escrituras antes de la observación y no cierra forzosamente los archivos abiertos.
En los servidores de producción, verifique la función de reapertura de registros del proceso que abrió el archivo y del servicio. Si lsof está instalado, puede investigar archivos abiertos con un recuento de enlaces menor a 1 usando sudo lsof +L1, pero en los resultados, los dispositivos, archivos y procesos deben ser cruzados juntos. Reiniciar afecta las conexiones y operaciones, así que primero revise el método de rotación/reapertura de registros que soporta el servicio. No escriba arbitrariamente en el descriptor de archivo /proc de otro proceso ni termine un proceso directamente.
Verifique la imagen ext4 solo después de desmontarla
La práctica anterior no causó corrupción en ext4. No hay necesidad de ejecutar e2fsck solo porque el espacio esté lleno. El manual de e2fsck de Debian advierte en contra de ejecutarlo en un sistema de archivos montado, y aunque algunas ejecuciones en solo lectura son posibles, los resultados de la comprobación no son válidos mientras el sistema de archivos está montado.
En esta práctica, verificamos que ningún proceso mantenga archivos abiertos dentro de work, liberamos la imagen y luego ejecutamos una verificación en solo lectura con -fn. -f fuerza una verificación completa y -n es el modo de solo lectura que rechaza cambios. El objetivo es un único archivo de imagen de práctica.
cd "$HOME"
sudo umount /mnt/lf-space24-ext4
sudo losetup -j /var/lib/lf-space24/space.img
sudo e2fsck -fn /var/lib/lf-space24/space.img
El resultado de losetup -j debe estar vacío. Si quedan conexiones, no elimine la imagen y verifique qué montaje o proceso la está utilizando. En la práctica normal, la comprobación paso a paso con e2fsck se completa y sale con el código 0. Si no es 0, conserve la salida y el código de salida sin eliminar el archivo de inmediato. Comprobar el sistema de archivos raíz en producción es una tarea de recuperación separada que requiere preparar una consola, copia de seguridad o entorno de arranque de rescate y volver a verificar el UUID de destino mientras la raíz está desmontada.
Después de que la comprobación se complete normalmente, solo se elimina la imagen de práctica. Los discos de datos existentes, LVM de las lecciones anteriores y /etc/fstab no se modifican.
sudo rm -- /var/lib/lf-space24/space.img
sudo rmdir /var/lib/lf-space24 /mnt/lf-space24-ext4
findmnt --target /tmp -o TARGET,SOURCE,FSTYPE,OPTIONS
df -hT / /tmp /var/tmp
Verifique el almacenamiento y la retención de archivos temporales en Debian 13
Según el aviso de cambio de /tmp de Debian 13, el /tmp predeterminado es tmpfs y el límite de tamaño predeterminado es la mitad de la memoria. Ese máximo no representa memoria reservada desde el inicio: el consumo depende de los archivos realmente creados. La configuración separada de /tmp en el fstab existente puede cambiar el resultado, así que primero verifique el montaje real.
findmnt --target /tmp -o TARGET,SOURCE,FSTYPE,OPTIONS
findmnt --target /var/tmp -o TARGET,SOURCE,FSTYPE,OPTIONS
systemctl cat tmp.mount
systemd-tmpfiles --cat-config | less
systemctl cat systemd-tmpfiles-clean.timer
systemctl list-timers systemd-tmpfiles-clean.timer --no-pager
free -h
En less, puede buscar con /tmp.conf y salir con q. Dado que cat-config muestra múltiples configuraciones, verifique no solo los valores predeterminados en /usr/lib/tmpfiles.d sino también cualquier entrada sobrescrita por archivos con el mismo nombre en /etc/tmpfiles.d. No ejecute systemd-tmpfiles --clean con fines de verificación. Este comando puede de hecho realizar eliminaciones.
En la VM de instalación nueva de la prueba original, /tmp era un tmpfs con un máximo de aproximadamente 2 GiB, y /var/tmp estaba incluido en el ext4 raíz. Las reglas predeterminadas aplicadas fueron /tmp 10 días, /var/tmp 30 días, y el temporizador de limpieza se configuró para 15 minutos después del arranque y después en intervalos de un día contados desde la activación anterior de la tarea de limpieza. No hay garantía de que los archivos se eliminen inmediatamente solo porque haya llegado la fecha; las marcas de tiempo de los archivos, las reglas de exclusión y el momento de la ejecución del temporizador entran en efecto.
Guía sobre los cambios en la limpieza de archivos temporales en Debian también explica las diferencias entre instalaciones nuevas y actualizaciones. En los sistemas actualizados de Debian 12 a Debian 13, /etc/tmpfiles.d/tmp.conf puede ser creado para mantener el comportamiento de retención anterior, por lo que no debe asumir el mismo calendario de eliminación que para una instalación nueva. /var/tmp generalmente permanece después de un reinicio, pero no es una ubicación de almacenamiento permanente.
Para archivos temporales pequeños y de corta duración, use /tmp, y para trabajos temporales más grandes, elija una ruta separada con suficiente espacio. Después de asegurarse de que el servicio siga la configuración de TMPDIR, cámbiela en consecuencia y coloque los datos persistentes y las copias de seguridad en rutas dedicadas de estado/respaldo. Según las directrices de systemd para directorios temporales, utilice métodos de creación segura como mktemp en directorios temporales compartidos. Los límites de tmpfs y el comportamiento de intercambio se pueden consultar en la documentación tmpfs del kernel Linux, y la prioridad de las reglas de limpieza y la determinación del tiempo se pueden encontrar en la documentación tmpfiles.d de Debian.




