--- title: "El sistema de archivos /proc en Linux: guía práctica" description: "Aprende a leer /proc en Linux para inspeccionar procesos, memoria, CPU y red, recuperar archivos borrados abiertos y ajustar parámetros del kernel con sysctl." category: "Internos de Linux" language: es source: https://cubepath.com/es/docs/internos-de-linux/sistema-de-archivos-proc-en-profundidad updated: 2026-09-25 --- # El sistema de archivos /proc en Linux: guía práctica `/proc` es un sistema de archivos virtual que el kernel Linux genera en memoria: sus archivos no ocupan espacio en disco y su contenido se calcula en el momento en que los lees. Herramientas como `ps`, `top`, `free` o `uptime` sacan casi toda su información de aquí. En este tutorial aprenderás a leer la información de un proceso concreto, a interpretar los datos de memoria, CPU y red del sistema, a resolver dos problemas reales con `/proc` y a cambiar parámetros del kernel con `sysctl` de forma persistente en Ubuntu 24.04. ## Requisitos previos Para seguir esta guía necesitas: - Un servidor con Ubuntu 24.04 LTS, por ejemplo un VPS de CubePath. Todo lo que se explica funciona igual en Debian 12 y Rocky Linux 9. - Un usuario no root con privilegios `sudo`. Algunos archivos de procesos ajenos solo los puede leer root. - Soltura básica con la terminal (`cat`, `grep`, `less`). ## Paso 1: Entender la estructura de /proc Lista el contenido de `/proc`: ```bash ls /proc ``` Verás dos tipos de entradas: - **Directorios numéricos** (`1`, `842`, `1523`...): uno por cada proceso en ejecución, con el PID como nombre. - **Archivos y directorios con nombre**: información global del sistema, como `cpuinfo`, `meminfo`, `loadavg`, `net/` o `sys/`. Comprueba que es un sistema de archivos virtual de tipo `proc`: ```bash findmnt /proc ``` ```output TARGET SOURCE FSTYPE OPTIONS /proc proc proc rw,nosuid,nodev,noexec,relatime ``` La mayoría de archivos muestran tamaño 0 con `ls -l`, porque el kernel no sabe cuánto ocupará el contenido hasta que lo genera. Por eso conviene leerlos con `cat` o `less` y no fiarse de su tamaño. Hay además un atajo útil: `/proc/self` es un enlace al directorio del proceso que lo está leyendo. ```bash readlink /proc/self ``` Cada ejecución devuelve un PID distinto, el del propio `readlink`. ## Paso 2: Inspeccionar un proceso con /proc/PID Cada directorio `/proc/` describe un proceso. Usa como ejemplo el demonio de SSH. Guarda su PID en una variable: ```bash PID=$(pgrep -o sshd) echo "$PID" ``` `pgrep -o` devuelve el proceso más antiguo que coincide, que es el `sshd` principal. ### Estado y memoria del proceso El archivo `status` resume el proceso en formato legible: ```bash sudo grep -E '^(Name|State|PPid|Uid|Threads|VmRSS|VmSwap)' /proc/$PID/status ``` ```output Name: sshd State: S (sleeping) PPid: 1 Uid: 0 0 0 0 Threads: 1 VmRSS: 8704 kB VmSwap: 0 kB ``` Los campos más útiles son: | Campo | Significado | |---|---| | `State` | `R` ejecutando, `S` durmiendo, `D` esperando E/S (no interrumpible), `Z` zombi | | `PPid` | PID del proceso padre | | `VmRSS` | Memoria física que usa realmente el proceso | | `VmSwap` | Memoria del proceso que está en swap | | `Threads` | Número de hilos | Un proceso que pasa mucho tiempo en estado `D` suele indicar un disco o un montaje NFS lento. ### Línea de comandos, ejecutable y directorio de trabajo `cmdline` contiene los argumentos separados por el carácter nulo, así que hay que convertirlos a espacios para leerlos: ```bash sudo tr '\0' ' ' < /proc/$PID/cmdline; echo ``` ```output sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups ``` Los enlaces `exe` y `cwd` apuntan al binario y al directorio de trabajo: ```bash sudo ls -l /proc/$PID/exe /proc/$PID/cwd ``` ### Descriptores de archivo y límites El directorio `fd` tiene un enlace por cada archivo, socket o tubería abierto. Cuenta cuántos tiene abiertos el proceso y compáralo con su límite: ```bash sudo ls /proc/$PID/fd | wc -l sudo grep 'Max open files' /proc/$PID/limits ``` ```output 7 Max open files 1024 524288 files ``` Si una aplicación registra errores `Too many open files`, esta comparación te dice si está cerca del límite (la primera columna es el límite blando y la segunda el duro). ### Entorno y E/S El archivo `environ` guarda las variables de entorno con las que arrancó el proceso, también separadas por nulos: ```bash sudo tr '\0' '\n' < /proc/$PID/environ ``` Y `io` muestra los bytes que el proceso ha leído y escrito realmente en almacenamiento: ```bash sudo grep -E '^(read_bytes|write_bytes)' /proc/$PID/io ``` > Advertencia: `environ` puede contener contraseñas o tokens pasados como variables de entorno. Por eso solo el dueño del proceso y root pueden leerlo; no lo copies en tickets ni en logs. ## Paso 3: Consultar CPU, memoria y carga del sistema ### CPU `/proc/cpuinfo` describe cada CPU lógica. Para un resumen rápido: ```bash grep -c ^processor /proc/cpuinfo grep -m1 'model name' /proc/cpuinfo ``` ```output 4 model name : AMD EPYC 9454P 48-Core Processor ``` En la práctica, `lscpu` presenta los mismos datos de forma más cómoda, pero lo lee de aquí. ### Memoria `/proc/meminfo` es la fuente de `free`: ```bash grep -E '^(MemTotal|MemFree|MemAvailable|Buffers|Cached|SwapTotal|SwapFree|Dirty)' /proc/meminfo ``` ```output MemTotal: 8131488 kB MemFree: 412332 kB MemAvailable: 6254120 kB Buffers: 118456 kB Cached: 5412876 kB SwapTotal: 2097148 kB SwapFree: 2097148 kB Dirty: 312 kB ``` El valor que importa para saber si falta memoria es `MemAvailable`, no `MemFree`. Linux usa la RAM libre como caché de disco (`Cached`) y la libera cuando una aplicación la necesita, así que un `MemFree` bajo con un `MemAvailable` alto es normal y sano. ### Carga y tiempo encendido ```bash cat /proc/loadavg cat /proc/uptime ``` ```output 0.42 0.35 0.30 2/318 48211 1289374.52 5021133.87 ``` En `loadavg`, los tres primeros números son la carga media de 1, 5 y 15 minutos; `2/318` indica procesos ejecutables frente al total, y el último es el PID más reciente. En `uptime`, el primer valor son los segundos desde el arranque. ### Presión de recursos (PSI) Los kernels modernos exponen en `/proc/pressure/` cuánto tiempo pasan las tareas esperando CPU, memoria o E/S. Es un indicador más directo de saturación que la carga media: ```bash cat /proc/pressure/memory ``` ```output some avg10=0.00 avg60=0.00 avg300=0.00 total=1834512 full avg10=0.00 avg60=0.00 avg300=0.00 total=1021337 ``` `some` es el porcentaje de tiempo en que al menos una tarea estuvo bloqueada por falta de memoria y `full` el tiempo en que todas lo estuvieron. Valores sostenidos por encima de unos pocos puntos en `avg60` indican que el servidor necesita más recursos. ## Paso 4: Revisar estadísticas de red El directorio `/proc/net/` contiene las tablas de red del espacio de nombres actual. Los contadores por interfaz están en `/proc/net/dev`: ```bash cat /proc/net/dev ``` ```output Inter-| Receive | Transmit face |bytes packets errs drop fifo frame compressed multicast|bytes packets errs drop fifo colls carrier compressed lo: 2841220 21530 0 0 0 0 0 0 2841220 21530 0 0 0 0 0 0 eth0: 918273645 1204551 0 12 0 0 0 0 104882733 611204 0 0 0 0 0 0 ``` Las columnas `errs` y `drop` distintas de cero y en aumento apuntan a problemas de driver, de MTU o de saturación. El resumen de sockets es útil para detectar fugas de conexiones: ```bash cat /proc/net/sockstat ``` ```output sockets: used 212 TCP: inuse 14 orphan 0 tw 38 alloc 20 mem 3 UDP: inuse 4 mem 2 ``` Para listar conexiones concretas usa `ss -tunap`, que lee estas mismas tablas y las presenta de forma legible; los archivos `/proc/net/tcp` y `/proc/net/tcp6` muestran direcciones y puertos en hexadecimal y no están pensados para leerse a mano. ## Paso 5: Resolver problemas reales con /proc ### Encontrar archivos borrados que siguen ocupando disco Si borras un log grande mientras un proceso lo tiene abierto, el espacio no se libera hasta que el proceso cierra el archivo. `df` muestra el disco lleno pero `du` no encuentra nada. Localiza esos archivos buscando enlaces marcados como `(deleted)`: ```bash sudo find /proc/[0-9]*/fd -lname '*(deleted)' -printf '%p -> %l\n' 2>/dev/null ``` ```output /proc/1187/fd/5 -> /var/log/myapp/app.log (deleted) ``` La ruta indica el PID (`1187`) y el descriptor (`5`). Tienes dos opciones: - Reiniciar el servicio que lo mantiene abierto, por ejemplo `sudo systemctl restart myapp`, para que libere el espacio. - Vaciar el archivo sin reiniciar nada, truncándolo a través del descriptor: ```bash sudo truncate -s 0 /proc/1187/fd/5 ``` Comprueba con `df -h` que el espacio se ha recuperado. ### Recuperar un archivo borrado que sigue abierto El mismo mecanismo sirve para rescatar un archivo borrado por error mientras un proceso lo mantiene abierto. Copia su contenido desde el descriptor antes de que el proceso termine: ```bash sudo cp /proc/1187/fd/5 /root/app.log.recuperado ``` ## Paso 6: Ajustar parámetros del kernel con /proc/sys y sysctl `/proc/sys/` es la única parte de `/proc` pensada para escribirse: cada archivo es un parámetro del kernel. La ruta se corresponde con el nombre de `sysctl` cambiando `/` por `.`; por ejemplo, `/proc/sys/vm/swappiness` es `vm.swappiness`. Lee un valor de las dos formas: ```bash cat /proc/sys/vm/swappiness sysctl vm.swappiness ``` ```output 60 vm.swappiness = 60 ``` ### Cambios temporales Para probar un valor sin que sobreviva a un reinicio: ```bash sudo sysctl -w vm.swappiness=10 ``` Esto equivale a escribir en `/proc/sys/vm/swappiness`. Si algo va mal, basta con reiniciar o volver a poner el valor anterior. ### Cambios persistentes Cuando el valor funcione, guárdalo en un archivo propio dentro de `/etc/sysctl.d/`. Así no se mezcla con los archivos del sistema y se aplica en cada arranque: ```bash sudo nano /etc/sysctl.d/99-custom.conf ``` ```ini # Preferir mantener aplicaciones en RAM antes que usar swap vm.swappiness = 10 # Cola de conexiones pendientes más larga para servidores web con mucho tráfico net.core.somaxconn = 8192 ``` Aplica todos los archivos de configuración sin reiniciar: ```bash sudo sysctl --system ``` La salida lista cada archivo leído; al final deben aparecer tus dos valores: ```output * Applying /etc/sysctl.d/99-custom.conf ... vm.swappiness = 10 net.core.somaxconn = 8192 ``` Comprueba el valor activo: ```bash sysctl vm.swappiness net.core.somaxconn ``` > Nota: no copies listas de "ajustes de rendimiento" de internet sin entender cada línea. Los valores por defecto de Ubuntu 24.04 son razonables para la mayoría de servidores; cambia un parámetro solo cuando tengas una medición que lo justifique. ## Solución de problemas **`Permission denied` al leer archivos de otro proceso.** `environ`, `fd`, `io` y otros archivos solo los puede leer el dueño del proceso o root. Usa `sudo`. **`No such file or directory` en `/proc/`.** El proceso ha terminado entre que obtuviste el PID y lo consultaste. Vuelve a obtenerlo con `pgrep`. **`sysctl: cannot stat /proc/sys/...`.** El parámetro no existe en tu kernel o depende de un módulo que no está cargado (por ejemplo, los parámetros `net.netfilter.nf_conntrack_*` solo aparecen cuando el módulo `nf_conntrack` está cargado). Revisa el nombre y el módulo. **Un valor de `/etc/sysctl.d/` no se aplica tras reiniciar.** Otro archivo leído después lo sobrescribe. Los archivos se procesan por orden alfabético, así que busca el parámetro en todos ellos: ```bash grep -r 'vm.swappiness' /etc/sysctl.conf /etc/sysctl.d/ /usr/lib/sysctl.d/ ``` ## Conclusión Has visto cómo `/proc` expone el estado de cada proceso, la memoria, la CPU y la red del sistema, cómo usarlo para liberar espacio de archivos borrados que siguen abiertos y cómo ajustar el kernel con `sysctl` de forma persistente. Como siguientes pasos, puedes explorar `/sys`, que expone dispositivos y drivers, revisar los mensajes del kernel con `dmesg` y `journalctl -k`, o gestionar módulos del kernel con `modprobe`.