OOM killer en Linux: por qué mata procesos y cómo controlarlo

Memoria de un servidor Linux llena de la que se retira un proceso, ilustrando el OOM killer

El OOM killer (out-of-memory killer) es el mecanismo del kernel Linux que entra en acción cuando el sistema se queda sin memoria y no puede liberar más: elige un proceso y lo mata para que la máquina siga funcionando. Para un administrador, sus síntomas son conocidos: una base de datos que desaparece de madrugada, un contenedor que se reinicia sin errores en su log o un servicio crítico que cae mientras el culpable sigue vivo. Entender cómo decide permite prevenirlo y orientarlo.

Las claves del OOM killer en 20 segundos

  • Actúa cuando el kernel no puede conseguir memoria ni liberando caché ni usando swap.
  • Mata el proceso con mayor puntuación, que depende sobre todo de su memoria.
  • Se ajusta con oom_score_adj, de -1000 a 1000, o con OOMScoreAdjust= en systemd.
  • systemd-oomd puede actuar antes, al detectar presión de memoria.

Linux permite por defecto reservar más memoria de la que existe, porque muchos programas piden memoria «por si acaso» y luego no la usan. Es lo que se llama sobreasignación (overcommit). El problema surge cuando los procesos sí la usan a la vez: el kernel intenta recuperar páginas liberando caché y moviendo datos a swap, y si todo eso falla, llama al OOM killer.

Cómo elige a quién matar

El kernel asigna a cada proceso una puntuación de «maldad» (badness) entre 0 y 1000 que refleja, básicamente, qué proporción de la memoria disponible está usando: memoria residente, tablas de páginas y swap. El proceso con la puntuación más alta es el elegido. Esa puntuación se puede consultar en /proc/PID/oom_score y ya incluye el ajuste manual que se le haya aplicado.

El ajuste se hace en /proc/PID/oom_score_adj, que admite valores de -1000 a 1000 y se suma a la puntuación. Con -1000 el proceso queda excluido; con 1000 será casi siempre el primero. La antigua interfaz oom_adj, con valores de -17 a 15, está obsoleta desde que oom_score_adj apareció en Linux 2.6.36, aunque se mantiene por compatibilidad.

# Procesos con mayor puntuación OOM
for p in /proc/[0-9]*; do
  printf "%s %s %sn" "$(cat $p/oom_score 2>/dev/null)" "${p#/proc/}" "$(cat $p/comm 2>/dev/null)"
done | sort -rn | head -10

# Ver y ajustar un proceso concreto
cat /proc/1234/oom_score_adj
echo -500 | sudo tee /proc/1234/oom_score_adjLenguaje del código: PHP (php)

Cómo saber si ha actuado

El OOM killer deja rastro en el log del kernel, con el proceso que lo desencadenó, una tabla de tareas con su consumo y el proceso matado:

sudo dmesg -T | grep -iE "out of memory|oom-kill|killed process"
sudo journalctl -k --since "24 hours ago" | grep -i oom

# En cgroups v2 (contenedores y servicios systemd)
cat /sys/fs/cgroup/system.slice/mi-servicio.service/memory.eventsLenguaje del código: PHP (php)

En memory.events, los contadores oom y oom_kill indican cuántas veces se alcanzó el límite de memoria del cgroup y cuántos procesos se mataron. Es importante distinguir un OOM global, cuando se agota la memoria de toda la máquina, de uno de cgroup, cuando un contenedor o servicio supera su propio límite aunque el servidor tenga memoria libre. En Kubernetes o Docker, el segundo caso es el habitual y aparece como OOMKilled.

Proteger servicios y actuar antes

Escribir en /proc no sobrevive a un reinicio del proceso. Para servicios gestionados por systemd lo correcto es fijarlo en la unidad con OOMScoreAdjust=, y limitar su memoria con MemoryMax= para que un fallo de ese servicio no arrastre a la máquina. Con OOMPolicy= se decide qué hace systemd con el resto del servicio si el kernel mata uno de sus procesos.

sudo systemctl edit postgresql.service

[Service]
OOMScoreAdjust=-500
MemoryMax=12G

Proteger un proceso con -1000 no es gratis: si no puede morir, el kernel matará otro, y si lo que consume memoria es precisamente ese proceso, se puede llegar a un sistema bloqueado. Conviene reservarlo para procesos pequeños y esenciales, como agentes de gestión remota.

El kernel suele llegar tarde: antes de matar nada, una máquina sin memoria puede pasar minutos sin responder, liberando caché y usando swap. Por eso existen herramientas en espacio de usuario que actúan antes. systemd-oomd usa la información de presión (PSI) del kernel, disponible desde Linux 4.20, y cgroups v2 para matar un cgroup completo cuando la presión de memoria o el uso de swap superan un umbral durante un tiempo; se activa por servicio con ManagedOOMMemoryPressure=kill y su estado se consulta con oomctl. Fedora lo trae activado por defecto. La presión actual se ve en /proc/pressure/memory.

Hay otros ajustes del sistema, con cuidado: vm.overcommit_memory=2 desactiva la sobreasignación y hace que las reservas fallen en lugar de invocar al OOM killer, algo que muchas aplicaciones no gestionan bien; y vm.panic_on_oom provoca un pánico del kernel en lugar de matar procesos, útil solo en clústeres donde es preferible reiniciar el nodo. En la mayoría de servidores, lo eficaz es dimensionar bien la memoria, poner límites por servicio y vigilar la presión antes de que el kernel tenga que elegir.

Preguntas frecuentes

¿Qué es el OOM killer?

El mecanismo del kernel Linux que mata un proceso cuando el sistema se queda sin memoria y no puede liberar más, para evitar que la máquina se bloquee.

¿Cómo evito que mate un servicio concreto?

Reduciendo su puntuación con OOMScoreAdjust= en la unidad de systemd o con /proc/PID/oom_score_adj, y limitando la memoria de los demás servicios.

¿Cómo sé si un proceso lo ha matado el OOM killer?

Buscando «Out of memory» o «Killed process» en dmesg o journalctl -k, y revisando el contador oom_kill de memory.events en el cgroup del servicio.

Fuentes:

Suscríbete al boletín SysAdmin

Este es tu recurso para las últimas noticias y consejos sobre administración de sistemas, Linux, Windows, cloud computing, seguridad de la nube, etc. Lo enviamos 2 días a la semana. Recuerda revisar tu email para confirmar la suscripción.

Scroll al inicio
×