/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:

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:

findmnt /proc

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.

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/<PID> describe un proceso. Usa como ejemplo el demonio de SSH. Guarda su PID en una variable:

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:

sudo grep -E '^(Name|State|PPid|Uid|Threads|VmRSS|VmSwap)' /proc/$PID/status

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:

CampoSignificado
StateR ejecutando, S durmiendo, D esperando E/S (no interrumpible), Z zombi
PPidPID del proceso padre
VmRSSMemoria física que usa realmente el proceso
VmSwapMemoria del proceso que está en swap
ThreadsNú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:

sudo tr '\0' ' ' < /proc/$PID/cmdline; echo

sshd: /usr/sbin/sshd -D [listener] 0 of 10-100 startups

Los enlaces exe y cwd apuntan al binario y al directorio de trabajo:

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:

sudo ls /proc/$PID/fd | wc -l
sudo grep 'Max open files' /proc/$PID/limits

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:

sudo tr '\0' '\n' < /proc/$PID/environ

Y io muestra los bytes que el proceso ha leído y escrito realmente en almacenamiento:

sudo grep -E '^(read_bytes|write_bytes)' /proc/$PID/io

Paso 3: Consultar CPU, memoria y carga del sistema

CPU

/proc/cpuinfo describe cada CPU lógica. Para un resumen rápido:

grep -c ^processor /proc/cpuinfo
grep -m1 'model name' /proc/cpuinfo

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:

grep -E '^(MemTotal|MemFree|MemAvailable|Buffers|Cached|SwapTotal|SwapFree|Dirty)' /proc/meminfo

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

cat /proc/loadavg
cat /proc/uptime

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:

cat /proc/pressure/memory

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:

cat /proc/net/dev

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:

cat /proc/net/sockstat

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):

sudo find /proc/[0-9]*/fd -lname '*(deleted)' -printf '%p -> %l\n' 2>/dev/null

/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:
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:

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:

cat /proc/sys/vm/swappiness
sysctl vm.swappiness

60
vm.swappiness = 60

Cambios temporales

Para probar un valor sin que sobreviva a un reinicio:

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:

sudo nano /etc/sysctl.d/99-custom.conf

# 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:

sudo sysctl --system

La salida lista cada archivo leído; al final deben aparecer tus dos valores:

* Applying /etc/sysctl.d/99-custom.conf ...
vm.swappiness = 10
net.core.somaxconn = 8192

Comprueba el valor activo:

sysctl vm.swappiness net.core.somaxconn

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/<PID>. 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:

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.