Ver código fonte

Release o6h-memory-guard 1.0.3

master
psarria 1 mês atrás
pai
commit
b8a62094d9
18 arquivos alterados com 652 adições e 242 exclusões
  1. +24
    -0
      CHANGELOG.md
  2. +99
    -0
      INCIDENT_PAGEOUT_DEADMAN_2026_09.md
  3. +1
    -1
      Makefile
  4. +56
    -36
      README.md
  5. +17
    -15
      SHA256SUMS
  6. +74
    -83
      VALIDATION.md
  7. +9
    -4
      etc/o6h-memory-guard.conf
  8. +6
    -4
      logs/example.log
  9. +2
    -1
      logs/policy-tests.log
  10. +3
    -1
      logs/runtime-tests.log
  11. +2
    -2
      logs/sanitizers.log
  12. +18
    -4
      src/config.c
  13. +45
    -23
      src/core.c
  14. +11
    -3
      src/guard.h
  15. +178
    -45
      src/main.c
  16. +6
    -0
      tests/fixtures/pageout_deadman_real_incident_2026_09.csv
  17. +54
    -13
      tests/test_guard.c
  18. +47
    -7
      tests/test_runtime.c

+ 24
- 0
CHANGELOG.md Ver arquivo

@@ -1,5 +1,29 @@
# Changelog

## 1.0.3 — 2026-09-21

- Endurecida la detección tras un panic real: PRE-PRESSURE tras dos muestras y
PRESSURE a los dos segundos bajo `lotsfree`, sin esperar a `nscan`.
- Añadida caché persistente top‑3 con identidad completa, alias, RSS,
d5/d15/d60 y ranking. Sólo un scan completo reemplaza la caché anterior.
- Eliminada la dependencia de un recorrido `/proc` en
CRITICAL/EMERGENCY/FLOOR. La decisión usa selección O(1), revalidación del
proceso concreto y fallback ante desaparición o reutilización de PID.
- Separadas las gracias configurables de CRITICAL (5 s), EMERGENCY (1 s) y
floor (0 s por defecto).
- Rediseñado el presupuesto a límites jerárquicos 4/8/12, con overrides
explícitos de emergencia/floor y límite absoluto; todas las protecciones UUID
permanecen obligatorias.
- RECOVERY comienza al recuperar `desfree`; NORMAL exige 15 s por encima de
`lotsfree` con scanner inactivo. Se cancela la escalada pendiente al recuperar.
- Añadidos `state_transition`, `candidate_cache`, `action_decision` y
`recovery_check`, con edad/origen/rank del candidato y override de presupuesto.
- Añadido el fixture real `pageout_deadman_real_incident_2026_09` y pruebas de
scan incompleto, acción sin walk, fallback, PID reuse, presupuesto e histéresis.
- Añadido `INCIDENT_PAGEOUT_DEADMAN_2026_09.md`.
- Conservados dry-run, `--force-dry-run`, SMF deshabilitado, cero UUID `allow`
y entrega source-only. No hubo despliegue ni señales reales.

## 1.0.2 — 2026-09-18

- Revisión exclusivamente documental del paquete: añadido `CHECKPOINT.md` con


+ 99
- 0
INCIDENT_PAGEOUT_DEADMAN_2026_09.md Ver arquivo

@@ -0,0 +1,99 @@
# Incidente `pageout_deadman` de septiembre de 2026

## Alcance

Este documento registra el panic real observado mientras
`o6h-memory-guard` v1.0.2 funcionaba correctamente en `dry-run`. La revisión
v1.0.3 se entrega también en `dry-run`: no se desplegó, no activó `armed` y no
envió señales durante su desarrollo o validación local.

## Cronología reconstruida

Los valores se conservan como fixture en
`tests/fixtures/pageout_deadman_real_incident_2026_09.csv`.

| Hora aproximada | `free_pages` | Estado/observación |
| --- | ---: | --- |
| 07:33:10Z | 143.127 | NORMAL, por encima de `lotsfree=130875` |
| 07:33:11Z | 115.727 | Primer cruce bajo `lotsfree`; v1.0.2 seguía NORMAL |
| 07:33:12–13Z | 103.000–107.000 | Persistencia bajo `lotsfree` |
| 07:33:17Z | 48.893 | EMERGENCY, `minfree=49077`, `nscan=1060408` |

El host pasó de `lotsfree` a `minfree` en unos seis segundos. Después, v1.0.2
registró decisiones dry-run TERM/KILL sobre varios procesos PHP-FPM, pero no
envió señales, como exigía su configuración. El host terminó en
`pageout_deadman`.

Durante el episodio, un `proc_scan` que normalmente tardaba 10–15 ms alcanzó
aproximadamente 9,5 s y quedó incompleto. También aparecieron bloqueos
`log_or_incomplete_scan` y `victim_budget_exhausted`.

## Qué detectó correctamente v1.0.2

- El cruce de umbrales dinámicos del kernel y la llegada a EMERGENCY.
- Scanner intenso y telemetría continua de memoria, swap y pageout.
- Inventario UUID, elegibilidad, RSS y ranking por zona/proceso.
- Identidades de proceso y decisiones `WOULD_ACTION` en `dry-run`.
- La salvaguarda fundamental: no se envió ninguna señal real.

Dry-run no podía evitar el panic: sólo registra la acción que habría propuesto.
El incidente sirve para validar detección y exponer defectos de preparación de
la ruta de rescate, no como evidencia de que el daemon causara el panic.

## Fallos de diseño revelados

1. PRE-PRESSURE/PRESSURE llegaban demasiado tarde para una caída de seis
segundos.
2. La acción exigía el scan completo más reciente; bajo presión, ese trabajo
podía bloquear durante segundos.
3. Un scan parcial invalidaba de hecho la posibilidad de actuar aunque existiera
atribución previa útil.
4. El presupuesto normal podía bloquear indefinidamente una emergencia.
5. Faltaba una traza explícita del origen, rank y edad del candidato usado.

## Cambios de v1.0.3

- PRE-PRESSURE tras dos muestras bajo `lotsfree` y PRESSURE a los dos segundos,
sin exigir `nscan`; scanner/pageout/swap siguen siendo corroboradores.
- Caché persistente top‑3 actualizada sólo por scans completos en
NORMAL/PRE-PRESSURE/PRESSURE. Conserva UUID, alias, generación, PID, inicio,
nombre, RSS, d5/d15/d60, tiempo, elegibilidad y puntuaciones.
- Un scan incompleto se registra pero no sustituye la caché buena anterior.
- CRITICAL/EMERGENCY/FLOOR no recorren `/proc`: selección cacheada O(1), lectura
kstat fresca y revalidación barata del candidato concreto.
- Si rank 1 desaparece, cambia de identidad o deja de ser elegible, se intenta
rank 2 y después rank 3 sin scan completo.
- Gracias configurables: 5 s CRITICAL, 1 s EMERGENCY y KILL inmediato al floor
por defecto.
- Presupuesto jerárquico 4/8/12: límite normal, override EMERGENCY y límite
absoluto floor. Ningún override relaja UUID `allow` ni protecciones.
- EMERGENCY sale hacia RECOVERY al alcanzar `desfree`; NORMAL requiere 15 s
estables por encima de `lotsfree` con scanner inactivo.
- Nuevos eventos `state_transition`, `candidate_cache`, `action_decision` y
`recovery_check`, incluidos origen, rank, edad y override de presupuesto.

## Evidencia automatizada

El fixture real exige que el guard abandone NORMAL antes de `minfree`. Las
pruebas del runtime simulado verifican además:

- persistencia de caché tras scan incompleto;
- cero recorridos `/proc` dentro de `act()`;
- fallback top‑2/top‑3;
- rechazo de reutilización PID por instante de inicio;
- límites normales y overrides controlados;
- allow/protect/observe/unmapped/global;
- histéresis RECOVERY/NORMAL;
- cero solicitudes de señal real en dry-run.

## Pendiente antes de `armed`

1. Compilar v1.0.3 con cabeceras nativas SmartOS y ejecutar todas las pruebas.
2. Validar `--probe --force-dry-run` y después SMF con `--force-dry-run`.
3. Observar transiciones tempranas y `candidate_cache` durante carga real.
4. Confirmar que un scan lento/incompleto no retrasa `action_decision`.
5. Revisar cada UUID y política literal; mantener infraestructura crítica fuera
de `allow`.
6. Validar en laboratorio desechable TERM/KILL, cooldown, supervisores que
recrean procesos y límites 4/8/12.
7. Obtener aceptación humana explícita. Hasta entonces `armed` es **NO GO**.

+ 1
- 1
Makefile Ver arquivo

@@ -15,7 +15,7 @@ native-check:
o6h-memory-guard: $(SOURCES) src/guard.h | native-check
$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ $(SOURCES) $(LDLIBS)

test-guard: tests/test_guard.c src/core.c src/config.c src/guard.h
test-guard: tests/test_guard.c tests/fixtures/pageout_deadman_real_incident_2026_09.csv src/core.c src/config.c src/guard.h
$(CC) $(TESTFLAGS) -o $@ tests/test_guard.c src/core.c src/config.c

test-runtime: tests/test_runtime.c src/main.c src/core.c src/config.c src/guard.h


+ 56
- 36
README.md Ver arquivo

@@ -1,4 +1,4 @@
# o6h-memory-guard 1.0.2
# o6h-memory-guard 1.0.3

Primera implementación para SmartOS global zone: daemon C de 64 bits, libkstat,
/proc, identidad UUID + generación de zona + PID + instante de creación,
@@ -17,6 +17,8 @@ No se ha desplegado ni se han enviado señales reales durante la preparación.
- `CHECKPOINT.md`: checkpoint operativo posterior, incorporado sin cambios,
con la evidencia acumulada de compilación, ejecución y logging de v1.0.2 en
SmartOS real, además del estado exacto y los requisitos antes de `armed`.
- `INCIDENT_PAGEOUT_DEADMAN_2026_09.md`: cronología del panic real observado
con v1.0.2 y justificación del endurecimiento de v1.0.3.
- `CHANGELOG.md`: evolución de versiones y revisión documental del paquete.

El checkpoint es cronológicamente posterior a `VALIDATION.md`; por ello amplía
@@ -30,12 +32,12 @@ Si no hay herramientas de desarrollo, compilar en una **zona nativa SmartOS**
de la misma plataforma (no LX), ejecutar allí `gmake test`, y copiar el binario
junto a este árbol al host. No instalar un compilador en un nodo bajo presión.

Copiar el archivo distribuido a `/var/tmp/o6h-memory-guard-1.0.2.tar.gz`:
Copiar el archivo distribuido a `/var/tmp/o6h-memory-guard-1.0.3.tar.gz`:

```sh
mkdir -p /opt/custom/src
cd /opt/custom/src
gzip -dc /var/tmp/o6h-memory-guard-1.0.2.tar.gz | tar -xf -
gzip -dc /var/tmp/o6h-memory-guard-1.0.3.tar.gz | tar -xf -
cd /opt/custom/src/o6h-memory-guard
gmake CC=gcc
gmake test CC=gcc
@@ -158,35 +160,38 @@ una prueba de que un proceso concreto causó la presión.
| Estado/condición de entrada | Comportamiento predeterminado |
| --- | --- |
| NORMAL | Sin intervención; muestreo VM de 1 s. |
| PRE-PRESSURE | `free < lotsfree` continuo durante 3 s; atribución de 1 s. |
| PRESSURE | Bajo `lotsfree` durante 10 s y scanner activo o libre descendiendo. |
| CRITICAL | Bajo `desfree` con presión corroborada continua durante 2 s; TERM. |
| EMERGENCY | `free < minfree`; entrada en la misma muestra, sin confirmación. TERM a nuevo candidato; KILL tras 1 s al pendiente. |
| Floor | `free < minfree/2`; KILL directo o escalada inmediata al pendiente. |
| RECOVERY | Al recuperar `lotsfree` se cancela la escalada. NORMAL requiere 15 s con `free >= lotsfree*1.10` y `nscan=0`. |

La presión se corrobora con `nscan > 0`, caída respecto a la muestra anterior o
delta libre de 5 s negativo. Además, bajo `lotsfree`, el crecimiento simultáneo
| PRE-PRESSURE | Dos muestras bajo `lotsfree` (1 s por defecto); refresca candidatos, sin señales. |
| PRESSURE | Bajo `lotsfree` durante 2 s, o caída rápida corroborada; no exige que `nscan` haya arrancado. Refresca candidatos cada segundo. |
| CRITICAL | Bajo `desfree` con presión corroborada continua durante 2 s; usa caché, sin scan nuevo, y propone TERM. |
| EMERGENCY | `free <= minfree`; entrada inmediata. Usa caché y gracia TERM de 1 s. |
| Floor | `free <= minfree/2`; KILL directo por defecto (`FLOOR_KILL_DELAY_SECONDS=0`). |
| RECOVERY | Desde CRITICAL/EMERGENCY al recuperar `desfree`; NORMAL sólo tras 15 s estables con `free >= lotsfree` y `nscan=0`. |

La entrada temprana a PRESSURE depende de persistencia bajo `lotsfree` o caída
clara y no espera a que el scanner arranque. `nscan > 0`, caída respecto a la
muestra anterior y delta libre negativo siguen corroborando gravedad. Bajo
`lotsfree`, el crecimiento simultáneo
en 5 s de `swap_physical_used_bytes` y `anon_pageout_pages` corrobora presión.
La ocupación física jamás es un trigger único: sin pageout creciente y memoria
bajo `lotsfree` no cambia el estado. El compromiso virtual tampoco se interpreta
como pageout.
Los tiempos son segundos monotónicos transcurridos, no número de filas leídas.
Un hueco de más de 2,5 s reinicia las confirmaciones. La gravedad se retiene
hasta recuperación; `action_pressure` indica si **la condición actual** permite
actuar. Por eso un estado retenido CRITICAL no autoriza una señal por sí solo.

TERM tiene 5 s de gracia en CRITICAL. Sólo se escala si la condición crítica
sigue confirmada y la lectura fresca sigue bajo `desfree`. Por encima de
`desfree` se suspenden señales; alcanzar `lotsfree` cancela el pendiente. Tras
KILL se puede elegir otro candidato si sigue la presión. EMERGENCY evita la
espera normal entre víctimas de 10 s. Se mantiene como máximo una decisión de
señal por tick; un pendiente desaparecido puede sustituirse en ese mismo tick.

Hay un máximo predeterminado de 4 víctimas por episodio y 4 por ventana móvil
de 60 s, tanto en simulación como en armed. TERM+KILL del mismo proceso cuentan
como una víctima. El presupuesto del episodio sólo se reinicia al volver a
NORMAL; el de 60 s sobrevive a ese cambio. En armed, un arranque o reinicio tiene
hasta recuperar `desfree`; `action_pressure` indica si el estado retenido aún
permite una decisión de rescate.

Las gracias son configurables: 5 s en CRITICAL, 1 s en EMERGENCY y 0 s al floor
por defecto. Una lectura kstat fresca debe seguir bajo `desfree`. Recuperar
`desfree` cancela cualquier TERM pendiente y entra en RECOVERY. Se mantiene como
máximo una decisión de señal por tick; si una identidad desaparece o reutiliza
el PID se prueba el siguiente candidato cacheado sin recorrer `/proc` completo.

En NORMAL/PRESSURE/CRITICAL rigen 4 víctimas por episodio y 4 por ventana móvil
de 60 s. EMERGENCY puede superar esos límites normales hasta 8 víctimas por
episodio; floor tiene un límite absoluto de 12. Cada override se registra como
`victim_budget_override=emergency|floor`. TERM+KILL del mismo proceso cuentan
como una víctima. Los límites 4/8/12 son configurables pero deben mantener ese
orden. El episodio sólo se reinicia al volver a NORMAL. En armed, un reinicio tiene
60 s de inhibición obligatoria de señales (también en EMERGENCY), para evitar
eludir el límite por minuto mediante reinicios repetidos. Los contadores son
en memoria; el presupuesto por episodio sí se reinicia al reiniciar el daemon.
@@ -199,7 +204,10 @@ Se suma RSS por UUID/generación de zona y se puntúa como
`RSS + 2*max(crecimiento,0)`, usando preferentemente 60 s, después 15 s y 5 s.
Se elige la zona elegible con mayor puntuación y dentro de ella el proceso
elegible con mayor puntuación. Sin historia se usa RSS. Empates conservan el
primer candidato encontrado. **La suma de RSS puede contar memoria compartida
primer candidato encontrado. Cada scan completo conserva en memoria los tres
mejores procesos, con identidad, alias, RSS, d5/d15/d60 y puntuaciones. El orden
es lexicográfico: puntuación de zona y luego de proceso, preservando la política
anterior. **La suma de RSS puede contar memoria compartida
varias veces**: es una aproximación de atribución, no memoria física exclusiva
ni memoria garantizada que se recuperará al terminar un proceso.

@@ -249,12 +257,14 @@ el daemon. libkstat/libc sí pueden reservar memoria internamente al actualizar
su cadena. No se promete cero asignaciones ni tiempo real estricto.

El recorrido /proc tiene presupuesto cooperativo de 200 ms (hasta 500 ms por
configuración). Si faltan permisos, se excede capacidad/plazo o hay errores,
el scan se marca incompleto y bloquea acciones. La desaparición normal de un
proceso no se trata como fallo total. Se usa caché completa de como máximo 2 s
en emergencias y siempre se revalida. Si no hay caché válida se intenta el
recorrido antes de actuar. Una llamada del kernel bloqueada puede exceder el
presupuesto; no es un límite duro. Los overruns quedan registrados.
configuración). Un scan incompleto queda registrado pero no sustituye la última
caché completa. NORMAL actualiza cada 5 s; PRE-PRESSURE/PRESSURE, cada segundo.
CRITICAL/EMERGENCY/FLOOR no ejecutan scans completos: su ruta es lectura kstat,
selección O(1) entre tres entradas, validación barata de identidad y decisión.
La edad máxima predeterminada es 15 s. Si la caché es vieja o no tiene candidato
válido, la acción se bloquea de forma segura; no se intenta descubrir uno bajo
presión extrema. Una llamada del kernel durante un scan previo todavía puede
exceder el presupuesto; queda registrada como overrun sin borrar la buena caché.

Muestras obligatorias ausentes/invalidas o demasiado lentas inhiben señales;
ARC/swap/pageout opcionales ausentes se marcan con `*_ok=0` y no bloquean por sí
@@ -295,10 +305,15 @@ Las muestras de 1 s posteriores a las acciones permiten revisar la recuperación
en 1/2/5/10 s, siempre que no haya overruns. No se registran argumentos de procesos.
`logs/policy-tests.log` y `logs/runtime-tests.log` proceden de pruebas locales;
no son datos del nodo. `logs/example.log` es un ejemplo sintético de formato.
Los eventos nuevos `state_transition`, `candidate_cache`, `action_decision` y
`recovery_check` permiten reconstruir el estado, origen/rank/edad del candidato,
resultado del último scan y cualquier override de presupuesto.

## Preparación de armed (no ejecutar durante la evaluación inicial)
## Preparación de armed (NO GO para v1.0.3 inicial)

Se necesitan deliberadamente dos cambios: `ACTION_MODE armed` en la config y
v1.0.3 debe compilarse y observarse primero en SmartOS exclusivamente en
`dry-run`; el incidente real aún no autoriza señales. En una fase futura se
necesitarían deliberadamente dos cambios: `ACTION_MODE armed` en la config y
retirar `--force-dry-run` del método start del manifiesto. Mantener las reglas
UUID `allow` mínimas y verificar antes las protecciones y el laboratorio nativo.
Después de esos cambios, validar config/manifiesto, importar, refrescar y
@@ -335,7 +350,12 @@ una instancia viva. Restaurar el manifiesto e importarlo permite reinstalar SMF.
Para actualizar: deshabilitar primero, conservar copias del binario, config y
manifiesto en un directorio de backup nuevo, reemplazar el binario estando parado
y validar los tres archivos. No reemplazar automáticamente la config ni perder
las protecciones. El instalador inicial se niega a hacerlo por ese motivo.
las protecciones. Al migrar desde v1.0.2 es obligatorio fusionar explícitamente
`PRE_SECONDS=1`, `PRESSURE_SECONDS=2`, las tres nuevas gracias,
`MAX_CACHED_CANDIDATE_AGE_SECONDS` y los límites 8/12 del fichero distribuido;
conservar 3/10 mantendría la detección lenta anterior. Validar con
`--check-config --force-dry-run` antes de reiniciar. El instalador inicial se
niega a sobrescribir por ese motivo.

## Referencias revisadas



+ 17
- 15
SHA256SUMS Ver arquivo

@@ -1,27 +1,29 @@
887569535302f7deba4d7c6ffb2103f1fb90bd96a40280240ff238eddc2e3a6f ./.gitignore
45e39d4bc8c8e3ef59e99167ef87fcc2864c0307693eeb5cb03664a0f6a7a722 ./CHANGELOG.md
8b1e0498bf3b9ccf3a36a4cc1ed0de7573612da2ef27be19e5496287679509f5 ./CHANGELOG.md
ebfca7d4b5eaf0c0cc9910cf49d8c85f6aa7ff69972d7f21d17e61d1a2e23bc2 ./CHECKPOINT.md
ff7a0c102a9ce90b0eab3ec3e4f9fc6c37a186e2852c740a5a3433e605da750b ./Makefile
8bd0f7d52b9cfbba4c8b5076bbe58f790982a6adf6b594f9cdbf717984ff6c70 ./README.md
cf519f00a0eb382faf214bf050009fd6391887d1bf4c78e901ff466108f0cdfc ./VALIDATION.md
e5f98d46a5908f640709c262f9c64ceffbad825ac413059e8b3c7aa4358afc90 ./etc/o6h-memory-guard.conf
7b96d41da2877a771058ad0b184137ca5a7b5bcf26ddf77145ed067a87e0ce33 ./INCIDENT_PAGEOUT_DEADMAN_2026_09.md
ab718d07e0bab3a4e22b840991fb4586bb8e70e5e04d9bd411d2221f44ef7e0d ./Makefile
edb3d79db79e7ca98c2bc94100835833bfdda37cde917a8b5604344628bac120 ./README.md
290aa8a15ed211e4672b54549a9a7678c2b65ce42dee5a75a3f046f0bb51df31 ./VALIDATION.md
07722b81f7905e3c48f607e55e2aa3eb8498eacfb40e7aff073fc96e98717c8f ./etc/o6h-memory-guard.conf
f6565d0e1ece0a08721c9893f9ed071d2ab0a2818fa93ed0a14e0050d358ce99 ./install.sh
059e1842336384e9364e763a998ca7a18ad8f330dab0f7c46cc4cf1664f0cc50 ./logs/example.log
77f710beb230b7f0285cf071dd8e59cef204f1d87aafec0ed36249f182e2481d ./logs/policy-tests.log
e2430c24466b2c82d5f20b46bc89ce77917d4c50dba6e5d69878c42ff55ca531 ./logs/example.log
b7d6826f353765641a95025344c30e6f5eb228772f29e04399a9ec78e3fb5595 ./logs/policy-tests.log
abafc237427b63f38f81d0d1b76ba64eefc64d9f8074fdaa6ed0f1573b5d0a3b ./logs/portability.log
b1b51e63d266d70eabde686d904451640c1088d44d36412bb6bcc756d7b82928 ./logs/runtime-tests.log
7be49939ef5450c0f3a2be609c2a63c67dc4f90e1f2294b74d5b17d549a54e37 ./logs/sanitizers.log
2b617f4070b8ec155f2a7c1ee6048c99cd7c96b6dbbd26b60ebab0c1d3b13c22 ./logs/runtime-tests.log
2e09451d28c59911c1d74ff6195fab0506eb2fc26cb99e5be79e65c47e75668a ./logs/sanitizers.log
b55afd45a72947efdda79d593255c36def9679bcb7a33ab14d55170ebaf9bef7 ./smf/o6h-memory-guard.xml
ada10059e26d94d796218108c031f7591d6e346d931da304643a74dd934b6656 ./src/config.c
f3b5bc0404a00f38bf2ae60a6aa924a9bc7ba080e1e9a9e72b2ae49d53835d41 ./src/core.c
5c741525f6b7ea7771adacb8aa40ca1a1eefbaba0f2c37f2eda53a7cf9a11402 ./src/guard.h
9a4468d9acc3f1da078b009f764c7cb7bf337682d6584b8cbaf7b540c520d5f5 ./src/config.c
c1f81909ec63fdb85948bbe58642478a80105b26a7c64eaf463c0e6fc42de203 ./src/core.c
0b9867e7ae7d1fcb2aab75f94d770471bd21f17c9f1eaf3c0f7c44eeb83e485b ./src/guard.h
32ab75bb6a1ff2bbbeb6a1ea658abcb96a03fcc06246f38d019faec7fdc184b8 ./src/illumos.c
2a9c54014272a78060b73b1863606e87e643cd27359bb77e12b8224b45baf18a ./src/main.c
066473572d8d2d8ca354ab3e718d3ccce618f8cfbb96992d008da3e9592b8815 ./src/main.c
2cb2b4c50fd42051fde4a702e8955e07d63979d5e3216e02420ed9b54fb67578 ./src/support.c
f754e71d91d65403ab8e84e9701cfbb89bdd91e13766e668445e689e6890b369 ./tests/api-sketch/kstat.h
f0d06353d2e326c7bdce776bee6f0a8606cda50d5de957dfdd586b6848fca8da ./tests/api-sketch/procfs.h
1c4fcb7bc48ec0a2774b1ecd73346dd45feb969a9250eb7056809d5d11ad40fe ./tests/api-sketch/sys/swap.h
340600b282a0c813323c1a09d5d6635ed4c56aa49a6d04132636851c8e714170 ./tests/api-sketch/vm/anon.h
9b99e272008ad00ad0abb366e1e8720dd6c51fc050821c5d1d878eae5719c22b ./tests/api-sketch/zone.h
af6e89c7058394a67f24e8cd7c5ab3e106bfa36c564901af001b7e781ea15ba6 ./tests/test_guard.c
217001c36c4e878ad365f127a12d03f714476d6ff32580407f8f0522fe564d83 ./tests/test_runtime.c
c5d9d7fc7a39354474d30cd316ea9f122205c2b38e57f927f4a08306b8a62c81 ./tests/fixtures/pageout_deadman_real_incident_2026_09.csv
b7ac53f6b26b4e7e2e19d7258b570a64462182ffe85c93374856caf77ec0c871 ./tests/test_guard.c
017b0a8dd3f9444fe63e4f8a6b3c12bf9ac98c25078223900a5672b6afdd11ec ./tests/test_runtime.c

+ 74
- 83
VALIDATION.md Ver arquivo

@@ -1,99 +1,90 @@
# Validación de la entrega
# Validación de la entrega v1.0.3

Fecha: 2026-09-18. Esta entrega es v1.0.2. Se ha validado localmente su código,
pero **no se ha desplegado v1.0.2 en SmartOS**, no se ha activado `armed` y no se
han enviado señales reales. El paquete conserva dos barreras de fábrica:
`ACTION_MODE dry-run` y `--force-dry-run` en SMF; además no contiene reglas de
zona `allow` y la instancia SMF está inicialmente deshabilitada.
Fecha: 2026-09-21. Esta revisión se construyó tras un panic real
`pageout_deadman` observado con v1.0.2 en `dry-run`. **v1.0.3 no se ha desplegado,
no ha activado `armed` y no ha enviado señales reales.** El manifiesto mantiene
`--force-dry-run`, la configuración mantiene `ACTION_MODE dry-run`, la instancia
SMF viene deshabilitada y no se distribuye ningún UUID `allow`.

Nota cronológica: `CHECKPOINT.md`, añadido posteriormente al mismo paquete
v1.0.2, conserva la evidencia de la validación nativa y operativa que se realizó
después de este corte local. Esa evidencia posterior completa los pendientes de
compilación, probe y logging continuo descritos aquí, pero mantiene `armed` como
NO GO y no modifica el código de la entrega.
`CHECKPOINT.md` conserva la validación operativa previa de v1.0.2.
`INCIDENT_PAGEOUT_DEADMAN_2026_09.md` documenta el nuevo incidente y el motivo de
los cambios. La telemetría nativa ya validada no se ha refactorizado.

## Evidencia real recibida de SmartOS
## Evidencia real que motiva esta revisión

En el nodo real `o6hsmartos10`, v1.0.1 validó correctamente mediante
`--probe --force-dry-run` las fuentes nuevas:
El host pasó de 143.127 páginas libres a 48.893 en unos siete segundos y cruzó
`lotsfree=130875` hasta `minfree=49077` en aproximadamente seis. V1.0.2 llegó a
EMERGENCY y produjo `WOULD_ACTION`, pero permaneció correctamente en dry-run.
Un `proc_scan` degradó de 10–15 ms a unos 9,5 s, quedó incompleto y la ruta de
acción registró bloqueos por scan/presupuesto. El fixture
`tests/fixtures/pageout_deadman_real_incident_2026_09.csv` reproduce los puntos
de la cronología disponibles.

- `swap_committed_pages` coincidió con `allocated + reserved` de `swap -s`.
- `swap_physical_used_bytes` coincidió con la suma de `(blocks-free)*512` de
`swap -l`: `67024888 - 58931824 = 8093064` bloques = 4.143.648.768 bytes.
- `anon_pageout_pages` coincidió exactamente con la suma de
`cpu:*:vm:anonpgout`: 6.553.284 páginas. No se sumaron también los duplicados
`cpu_stat:*:cpu_stat*:anonpgout`.
## Comprobaciones automatizadas de v1.0.3

La ejecución persistente de v1.0.1 bajo SMF permaneció estable, muestreó cada
segundo y clasificó correctamente `state=NORMAL`, `action_pressure=0`, `floor=0`
con `nscan=0` y entre unas 589.193 y 602.818 páginas libres, muy por encima de
`lotsfree=130875`. Sus deltas de 5 y 15 segundos fueron coherentes; por ejemplo,
una caída rápida de libre y aumento de compromiso virtual no se confundieron
con presión real mientras el scanner permaneció inactivo.
- `make test` completa 138 comprobaciones de política y 73 de runtime.
- La suite de política cubre configuración estricta, seis estados, transición
temprana, fixture real, telemetría, identidades, protecciones, TERM/KILL,
recuperación y presupuesto jerárquico.
- La suite runtime incluye `src/main.c` con backend totalmente simulado y prueba
la ruta usada por el daemon: caché top‑3, preservación tras scan incompleto,
selección/fallback O(1), rechazo de PID reutilizado y cero señales reales en
dry-run.
- Un contador de backend demuestra que `act()` no llama `platform_walk()` en
EMERGENCY, incluso cuando el último scan fue incompleto.
- Se conserva la regresión del contrato de logging de v1.0.2 para compromiso,
swap físico y pageout anónimo con ventanas 5/15/60.
- `make test-sanitize` ejecuta AddressSanitizer y UndefinedBehaviorSanitizer.
Cuando el entorno supervisado impide LeakSanitizer se usa
`ASAN_OPTIONS=detect_leaks=0`; no se atribuye una comprobación de fugas.
- `make portability` aplica C99 estricto, warnings como errores, GCC
`-fanalyzer` por unidad, `sh -n` y XML bien formado con `xmllint`.
- Los `tests/api-sketch` sólo permiten comprobar consistencia C en Linux; no
sustituyen cabeceras, ABI, enlace ni ejecución nativa illumos.
- La búsqueda de producción no encuentra `system`, `popen`, `exec*` ni
`kill(2)`. El envío real sigue aislado en el backend nativo y no se enlaza en
las pruebas.

Esa prueba descubrió el defecto corregido aquí: el daemon continuo v1.0.1 aún
mostraba la nomenclatura antigua (`swap_ok`, `swap_alloc_pages`,
`swap_reserved_pages`, `swap_available_pages`, `metric=swap_used_pages`) y no
exponía `swap_physical_used_bytes`, `anon_pageout_pages` ni sus deltas. Por tanto,
la evidencia real valida las lecturas nativas y la estabilidad básica, pero no
el nuevo contrato de logging v1.0.2. Antes de armar nada debe repetirse la prueba
continua en SmartOS.

## Comprobaciones de v1.0.2
Los resultados exactos se guardan en `logs/policy-tests.log`,
`logs/runtime-tests.log`, `logs/sanitizers.log` y `logs/portability.log`.

- `make test` ejecuta pruebas de configuración, política y la ruta real del
daemon con backend simulado. La prueba de logging genera 61 muestras a cadencia
de 1 s y exige los tres pares de valor/flag, los deltas exactos 5/15/60 s de
`swap_committed_pages`, `swap_physical_used_bytes` y `anon_pageout_pages`, y
que no aparezca `swap_used_pages`.
- La política cubre los seis estados, histéresis y huecos. Verifica que el
crecimiento de swap físico por sí solo, el pageout por sí solo, o ambas
señales con `freemem >= lotsfree` no corroboran presión. Juntas sólo pueden
corroborarla bajo `lotsfree`; no autorizan acciones por sí mismas.
- La ruta simulada confirma que dry-run registra `WOULD_ACTION` y realiza cero
solicitudes de señal real. También cubre protecciones, revalidación, warmup,
caché, fallos de muestra/log/identidad, límites y parada.
- `make test-sanitize` ejecuta ambas suites con AddressSanitizer y
UndefinedBehaviorSanitizer. En entornos donde LeakSanitizer no pueda operar
por restricciones de ptrace se usa `ASAN_OPTIONS=detect_leaks=0` y se deja
constancia explícita; esto no equivale a una comprobación de fugas.
- `make portability` aplica C99 estricto, warnings como errores, `-fanalyzer` a
cada unidad, sintaxis shell y XML bien formado. Los `tests/api-sketch` sólo
comprueban consistencia C en Linux; no sustituyen cabeceras, ABI, enlace ni
ejecución nativos de illumos.
- Se inspecciona que producción no invoque `system`, `popen`, `exec*` ni
`kill(2)`. Las pruebas no enlazan el backend nativo y no pueden enviar señales.
## Propiedades verificadas por las pruebas nuevas

Los resultados exactos de esta ejecución se guardan en `logs/policy-tests.log`,
`logs/runtime-tests.log`, `logs/sanitizers.log` y `logs/portability.log`.
1. El fixture sale de NORMAL en la segunda muestra bajo `lotsfree` y alcanza
PRESSURE antes de `minfree`.
2. Sólo un scan completo reemplaza la caché; un parcial conserva top‑1/2/3.
3. Una acción puede decidir con `scan_complete=0` usando una caché reciente.
4. La ruta de acción no inicia un scan completo.
5. Una identidad rank 1 obsoleta cae a rank 2/3.
6. PID + instante de inicio detectan reutilización.
7. `allow` sigue siendo obligatorio; protect/observe/unmapped/global quedan fuera.
8. CRITICAL respeta el límite normal; EMERGENCY y floor sólo amplían hasta sus
límites configurados y registran el override.
9. Recuperar `desfree` entra en RECOVERY y cancela el pendiente; NORMAL requiere
estabilidad sobre `lotsfree`.
10. Dry-run produce `WOULD_ACTION` y cero solicitudes de señal real.

## Validación obligatoria pendiente en SmartOS

1. Compilar con cabeceras nativas (`gmake CC=gcc`), ejecutar `gmake test CC=gcc`
y comprobar ELF de 64 bits y dependencias con `file`/`ldd`.
2. Ejecutar `svccfg validate` nativo. Instalar/importar sólo siguiendo el
procedimiento del README y mantener `--force-dry-run`; no añadir UUID `allow`.
3. Repetir `--probe --force-dry-run` y contrastar las tres fuentes con `swap -s`,
`swap -l` y `kstat cpu::vm:anonpgout`.
4. Bajo SMF, verificar en cada `event=sample`:
`swap_committed_ok/swap_committed_pages`,
`swap_physical_used_ok/swap_physical_used_bytes` y
`anon_pageout_ok/anon_pageout_pages`. Confirmar líneas `event=delta` con los
tres nombres exactos y ventanas 5/15/60; buscar y exigir cero apariciones de
`swap_used_pages`.
5. Confirmar cadencia, recorrido `/proc`, identidades de zona, lock, rotación y
recuperación del servicio durante carga natural. No generar presión artificial
en producción.
6. La ruta PCKILL sólo debe ensayarse posteriormente en un laboratorio nativo
desechable, con procesos y zonas expresamente creados para esa prueba. Esta
entrega no autoriza ni realiza esa fase.
y comprobar ELF de 64 bits y dependencias.
2. Ejecutar `--probe --force-dry-run` y contrastar la telemetría ya conocida.
3. Validar el manifiesto con `svccfg validate`, importar y ejecutar SMF sólo con
`--force-dry-run`.
4. Confirmar en carga natural `NORMAL → PRE-PRESSURE → PRESSURE` con varios
segundos de margen y presencia previa de `candidate_cache`.
5. Confirmar que un scan lento/incompleto no retrasa ni borra la decisión
cacheada; medir `candidate_age_ms` y latencia de `action_decision`.
6. Revisar manualmente todos los UUID y eventos `WOULD_ACTION` de varios
episodios. No provocar presión peligrosa en producción para obtenerlos.
7. Sólo en laboratorio desechable y en una fase posterior: probar PCKILL,
supervisores, cooldown, 4/8/12 y rollback. `armed` continúa siendo NO GO.

## Límites conocidos

La atribución por RSS es heurística y sobrecuenta memoria compartida. Una señal
puede no liberar memoria de inmediato y un supervisor puede recrear procesos.
El presupuesto `/proc` es cooperativo; libkstat, libc, ZFS y el logging pueden
bloquear. No hay `fsync` por muestra, por lo que un panic puede perder las últimas
líneas. Las protecciones y presupuestos prevalecen incluso al floor. Este guard
no constituye una garantía de evitar `pageout_deadman` ni un certificado para
activar acciones en producción.
La caché sólo contiene tres procesos y puede quedar sin candidato si todos
cambian o superan 15 s de edad. En ese caso el diseño falla cerrado y no recorre
todo `/proc` bajo emergencia. RSS sobrecuenta memoria compartida y una señal no
garantiza liberar páginas. Kstat, ZFS, libc, logging y la revalidación puntual
todavía pueden bloquear. No hay fsync por muestra. Este guard reduce una ventana
de riesgo; no garantiza evitar `pageout_deadman`.

+ 9
- 4
etc/o6h-memory-guard.conf Ver arquivo

@@ -1,17 +1,22 @@
# o6h-memory-guard 1.0.2 -- whitespace-separated, no shell evaluation.
# o6h-memory-guard 1.0.3 -- whitespace-separated, no shell evaluation.
# Restart required for configuration changes. Duplicate scalar keys are errors.
ACTION_MODE dry-run

PRE_SECONDS 3
PRESSURE_SECONDS 10
PRE_SECONDS 1
PRESSURE_SECONDS 2
CRITICAL_SECONDS 2
RECOVERY_SECONDS 15
TERM_GRACE_SECONDS 5
CRITICAL_TERM_GRACE_SECONDS 5
EMERGENCY_TERM_GRACE_SECONDS 1
FLOOR_KILL_DELAY_SECONDS 0
MAX_CACHED_CANDIDATE_AGE_SECONDS 15
NORMAL_SCAN_SECONDS 5
SCAN_BUDGET_MS 200
COOLDOWN_SECONDS 10
MAX_VICTIMS_EPISODE 4
MAX_VICTIMS_MINUTE 4
MAX_EMERGENCY_VICTIMS_EPISODE 8
MAX_FLOOR_VICTIMS_EPISODE 12
MIN_RSS_KIB 65536
LOG_MAX_MIB 10
LOG_KEEP 5


+ 6
- 4
logs/example.log Ver arquivo

@@ -1,10 +1,12 @@
# SYNTHETIC FORMAT EXAMPLE -- NOT HOST TELEMETRY. Fields abridged for readability.
2026-09-18T15:00:00Z mono=100.000 event=start version=1.0.2 pid=999 mode=dry-run page_bytes=4096 armed_warmup=60
2026-09-21T15:00:00Z mono=100.000 event=start version=1.0.3 pid=999 mode=dry-run page_bytes=4096 armed_warmup=60
2026-09-18T15:00:01Z mono=101.000 event=sample state=NORMAL action_pressure=0 floor=0 free_pages=425950 lotsfree=130875 desfree=65437 minfree=49077 nscan=0 pp_kernel=2976170 pageslocked=3002379 arc_ok=1 arc_bytes=1073741824 swap_committed_ok=1 swap_committed_pages=7480128 swap_physical_used_ok=1 swap_physical_used_bytes=4143648768 anon_pageout_ok=1 anon_pageout_pages=1000 swap_alloc_pages=7000000 swap_reserved_pages=480128 swap_available_pages=6135486
2026-09-18T15:00:01Z mono=101.000 event=delta metric=swap_committed_pages d5=NA d15=NA d60=NA
2026-09-18T15:00:01Z mono=101.000 event=delta metric=swap_physical_used_bytes d5=NA d15=NA d60=NA
2026-09-18T15:00:01Z mono=101.000 event=delta metric=anon_pageout_pages d5=NA d15=NA d60=NA
2026-09-18T15:01:00Z mono=160.000 event=transition from=PRESSURE to=CRITICAL
2026-09-21T15:00:05Z mono=105.020 event=candidate_cache rank=1 UUID=11111111-1111-4111-8111-111111111111 alias=fixture-web zone_generation=20 pid=123 start=1000.000000123 comm=php-fpm rss_kib=1048576 d5_kib=+100000@5.00s d15_kib=NA d60_kib=NA age_ms=0 eligible=1 zone_score=2097152 process_score=1248576
2026-09-21T15:01:00Z mono=160.000 event=state_transition from=PRESSURE to=CRITICAL free_pages=60000 lotsfree=130875 desfree=65437 minfree=49077 low_samples=12
2026-09-18T15:01:00Z mono=160.020 event=candidate UUID=11111111-1111-4111-8111-111111111111 alias=fixture-web zone_id=9 zone_generation=20 pid=123 start=1000.000000123 comm=php-fpm rss_kib=1048576 d5_kib=+100000@5.00s d15_kib=+200000@15.00s d60_kib=+500000@60.00s eligible=1
2026-09-18T15:01:00Z mono=160.030 event=action WOULD_ACTION=SIGTERM reason=critical UUID=11111111-1111-4111-8111-111111111111 alias=fixture-web zone_generation=20 pid=123 start=1000.000000123 comm=php-fpm rss_kib=1048576 free_pages=60000
2026-09-18T15:01:05Z mono=165.030 event=action WOULD_ACTION=SIGKILL reason=memory_not_recovered UUID=11111111-1111-4111-8111-111111111111 alias=fixture-web zone_generation=20 pid=123 start=1000.000000123 comm=php-fpm rss_kib=1048576 free_pages=57000
2026-09-21T15:01:00Z mono=160.025 event=action_decision state=CRITICAL candidate_source=cached_candidate rank=1 scan_complete=1 candidate_age_ms=980.0 victim_budget_override=none pid=123 UUID=11111111-1111-4111-8111-111111111111
2026-09-21T15:01:00Z mono=160.030 event=action WOULD_ACTION=SIGTERM reason=critical UUID=11111111-1111-4111-8111-111111111111 alias=fixture-web zone_generation=20 pid=123 start=1000.000000123 comm=php-fpm rss_kib=1048576 free_pages=60000 victim_budget_override=none
2026-09-21T15:01:05Z mono=165.030 event=action WOULD_ACTION=SIGKILL reason=memory_not_recovered UUID=11111111-1111-4111-8111-111111111111 alias=fixture-web zone_generation=20 pid=123 start=1000.000000123 comm=php-fpm rss_kib=1048576 free_pages=57000 victim_budget_override=none

+ 2
- 1
logs/policy-tests.log Ver arquivo

@@ -2,8 +2,9 @@ PASS strict configuration, safe defaults, explicit UUID authorization
PASS mandatory protections, PID reuse and zone incarnation identity
PASS timestamped 5/15/60s windows, missing data, signed growth, overflow
PASS all six states, corroboration, hysteresis, recovery and sampling gaps
PASS pageout_deadman_real_incident_2026_09 exits NORMAL before minfree
SIMULATED t=100 state=CRITICAL UUID=11111111-1111-4111-8111-111111111111 pid=123 WOULD_ACTION=SIGTERM
SIMULATED t=105 state=CRITICAL pid=123 WOULD_ACTION=SIGKILL reason=memory_not_recovered
SIMULATED state=EMERGENCY floor=1 WOULD_ACTION=SIGKILL reason=floor
PASS TERM/KILL sequencing, emergency grace, floor, cooldown, budgets and no-action protections
PASS 113 checks; no native backend linked, no signals sent
PASS 138 checks; no native backend linked, no signals sent

+ 3
- 1
logs/runtime-tests.log Ver arquivo

@@ -2,4 +2,6 @@ PASS actual daemon dry-run path records WOULD_ACTION=SIGTERM/SIGKILL; zero real
PASS continuous sample contract and 5/15/60 deltas for commitment, physical swap and pageout
PASS armed-path mock requests, warmup, stale cache, logging/sampling failures, stop and fresh floor
PASS actual daemon ranking by zone/PID RSS and growth; protected zones and global zone excluded
PASS 50 runtime checks; all platform calls mocked, no signals sent
PASS incomplete scan preserves cache; emergency uses O(1) fallback without a new walk
PASS PID/start-time reuse rejects rank 1 and selects cached fallback
PASS 73 runtime checks; all platform calls mocked, no signals sent

+ 2
- 2
logs/sanitizers.log Ver arquivo

@@ -1,5 +1,5 @@
ASAN_OPTIONS=detect_leaks=0 make test-sanitize
GCC 11.4.0; AddressSanitizer + UndefinedBehaviorSanitizer
PASS test-sanitize-guard: 113 checks; no native backend linked, no signals sent
PASS test-sanitize-runtime: 50 checks; all platform calls mocked, no signals sent
PASS test-sanitize-guard: 138 checks; no native backend linked, no signals sent
PASS test-sanitize-runtime: 73 checks; all platform calls mocked, no signals sent
LeakSanitizer was intentionally disabled because the supervised environment can reject ptrace; no leak-check result is claimed.

+ 18
- 4
src/config.c Ver arquivo

@@ -7,10 +7,13 @@
void defaults(config_t *c)
{
memset(c, 0, sizeof (*c));
c->pre_s = 3; c->pressure_s = 10; c->critical_s = 2;
c->recovery_s = 15; c->term_s = 5; c->normal_scan_s = 5;
c->pre_s = 1; c->pressure_s = 2; c->critical_s = 2;
c->recovery_s = 15; c->critical_term_s = 5;
c->emergency_term_s = 1; c->floor_kill_delay_s = 0;
c->max_cached_candidate_age_s = 15; c->normal_scan_s = 5;
c->scan_budget_ms = 200; c->cooldown_s = 10;
c->max_victims = 4; c->max_per_minute = 4;
c->max_emergency_victims = 8; c->max_floor_victims = 12;
c->min_rss_kib = 65536; c->log_mib = 10; c->log_keep = 5;
}

@@ -129,7 +132,11 @@ int config_read(FILE *f, config_t *c, char *error, size_t cap)
OPT("PRESSURE_SECONDS", pressure_s, 2, 120, 2)
OPT("CRITICAL_SECONDS", critical_s, 1, 10, 3)
OPT("RECOVERY_SECONDS", recovery_s, 5, 300, 4)
OPT("TERM_GRACE_SECONDS", term_s, 1, 30, 5)
if (!strcmp(key, "TERM_GRACE_SECONDS") ||
!strcmp(key, "CRITICAL_TERM_GRACE_SECONDS")) {
if ((seen & (1u << 5)) || number(value, 1, 30, &n)) goto invalid;
seen |= 1u << 5; c->critical_term_s = n; continue;
}
OPT("NORMAL_SCAN_SECONDS", normal_scan_s, 1, 5, 6)
OPT("SCAN_BUDGET_MS", scan_budget_ms, 10, 500, 7)
OPT("COOLDOWN_SECONDS", cooldown_s, 1, 120, 8)
@@ -138,10 +145,17 @@ int config_read(FILE *f, config_t *c, char *error, size_t cap)
OPT("MIN_RSS_KIB", min_rss_kib, 1024, 1073741824UL, 11)
OPT("LOG_MAX_MIB", log_mib, 1, 100, 12)
OPT("LOG_KEEP", log_keep, 1, 20, 13)
OPT("EMERGENCY_TERM_GRACE_SECONDS", emergency_term_s, 0, 10, 14)
OPT("FLOOR_KILL_DELAY_SECONDS", floor_kill_delay_s, 0, 5, 15)
OPT("MAX_CACHED_CANDIDATE_AGE_SECONDS", max_cached_candidate_age_s, 5, 60, 16)
OPT("MAX_EMERGENCY_VICTIMS_EPISODE", max_emergency_victims, 1, MAX_VICTIMS, 17)
OPT("MAX_FLOOR_VICTIMS_EPISODE", max_floor_victims, 1, MAX_VICTIMS, 18)
#undef OPT
goto invalid;
}
if (ferror(f) || c->pressure_s < c->pre_s) goto invalid;
if (ferror(f) || c->pressure_s < c->pre_s ||
c->max_emergency_victims < c->max_victims ||
c->max_floor_victims < c->max_emergency_victims) goto invalid;
if (c->armed) {
size_t i; int allow = 0;
for (i = 0; i < c->nzones; i++) allow |= c->zones[i].policy == ALLOW;


+ 45
- 23
src/core.c Ver arquivo

@@ -64,52 +64,59 @@ void engine_init(engine_t *e)
void engine_gap(engine_t *e)
{
e->low_since = e->critical_since = e->recovery_since = -1;
e->have_last = 0; e->danger = 0; e->floor = 0;
e->low_samples = 0; e->have_last = 0; e->danger = 0; e->floor = 0;
}

void engine_step(engine_t *e, const config_t *c, const sample_t *s,
delta_t free_d5, delta_t physical_swap_d5, delta_t pageout_d5)
{
int stress;
int stress, falling, rapid_fall;
enum state desired = NORMAL;
if (e->have_last && (s->at - e->last_at > 2.5 || s->at <= e->last_at))
engine_gap(e);
falling = (free_d5.valid && free_d5.value < 0) ||
(e->have_last && s->free < e->last_free);
rapid_fall = e->have_last && e->last_free > s->free &&
e->last_free - s->free >= s->lots / 10;
/* Physical swap growth is corroboration only, never an independent trigger. */
stress = s->scan > 0 || (free_d5.valid && free_d5.value < 0) ||
(e->have_last && s->free < e->last_free) ||
stress = s->scan > 0 || falling ||
(physical_swap_d5.valid && physical_swap_d5.value > 0 &&
pageout_d5.valid && pageout_d5.value > 0 && s->free < s->lots);
e->floor = s->free < s->min / 2;
e->floor = s->free <= s->min / 2;
if (s->free < s->lots) {
if (e->low_since < 0) e->low_since = s->at;
} else e->low_since = -1;
if (e->low_since < 0) { e->low_since = s->at; e->low_samples = 1; }
else if (e->low_samples < UINT_MAX) e->low_samples++;
} else { e->low_since = -1; e->low_samples = 0; }
if (s->free < s->des && stress) {
if (e->critical_since < 0) e->critical_since = s->at;
} else e->critical_since = -1;
if (e->low_since >= 0 && s->at - e->low_since >= c->pre_s)
if (e->low_since >= 0 && e->low_samples >= 2 &&
s->at - e->low_since >= c->pre_s)
desired = PRE_PRESSURE;
if (e->low_since >= 0 && s->at - e->low_since >= c->pressure_s && stress)
if (e->low_since >= 0 && (s->at - e->low_since >= c->pressure_s ||
(e->low_samples >= 3 && rapid_fall)))
desired = PRESSURE;
if (e->critical_since >= 0 && s->at - e->critical_since >= c->critical_s)
desired = CRITICAL;
if (s->free < s->min) desired = EMERGENCY;
e->danger = desired == CRITICAL || desired == EMERGENCY;
/* State hysteresis never authorizes an action on its own. */
if (s->free <= s->min) desired = EMERGENCY;
if (desired >= PRE_PRESSURE && desired <= EMERGENCY) {
e->recovery_since = -1;
if (e->state == RECOVERY || desired > e->state) e->state = desired;
}
if (s->free >= s->lots && e->state != NORMAL) {
/* A prior critical episode is not recovered until at least desfree. */
if ((e->state == CRITICAL || e->state == EMERGENCY) && s->free >= s->des &&
desired < CRITICAL) {
e->state = RECOVERY; e->recovery_since = -1;
} else if (s->free >= s->lots && e->state != NORMAL) {
e->state = RECOVERY;
/* 10% exit margin, and no active scanner, for a full recovery. */
if (s->free - s->lots >= s->lots / 10 && s->scan == 0) {
}
if (e->state == RECOVERY) {
if (s->free >= s->lots && s->scan == 0) {
if (e->recovery_since < 0) e->recovery_since = s->at;
if (s->at - e->recovery_since >= c->recovery_s) e->state = NORMAL;
} else e->recovery_since = -1;
} else if (s->free < s->lots) {
e->recovery_since = -1;
if (e->state == RECOVERY) e->state = PRE_PRESSURE;
}
e->danger = e->state == CRITICAL || e->state == EMERGENCY;
e->last_at = s->at; e->last_free = s->free; e->have_last = 1;
}

@@ -134,22 +141,37 @@ plan_t action_plan(controller_t *a, const config_t *c, const engine_t *e,
plan_t p;
unsigned i, n = 0;
memset(&p, 0, sizeof (p)); p.reason = "no_pressure";
p.budget_override = "none";
for (i = 0; i < a->nrate; i++)
if (s->at - a->rate[i] < 60) a->rate[n++] = a->rate[i];
a->nrate = n;
if (e->state == NORMAL) a->nvictims = 0;
if (s->free >= s->lots) a->has_pending = 0;
if (!e->danger) return p;
if (!e->danger) { a->has_pending = 0; return p; }
if (a->has_pending) {
unsigned grace = c->critical_term_s;
p.reason = "term_grace";
if (e->floor || (s->free < s->min && s->at - a->term_at >= 1) ||
s->at - a->term_at >= c->term_s) {
if (e->floor) grace = c->floor_kill_delay_s;
else if (e->state == EMERGENCY) grace = c->emergency_term_s;
if (s->at - a->term_at >= grace) {
p.target = a->pending; p.action = KILL;
p.reason = e->floor ? "floor" : "memory_not_recovered";
}
return p;
}
if (a->nvictims >= c->max_victims || a->nrate >= c->max_per_minute) {
if (e->floor) {
if (a->nvictims >= c->max_floor_victims) {
p.reason = "absolute_victim_budget_exhausted"; return p;
}
if (a->nvictims >= c->max_victims || a->nrate >= c->max_per_minute)
p.budget_override = "floor";
} else if (e->state == EMERGENCY) {
if (a->nvictims >= c->max_emergency_victims) {
p.reason = "emergency_victim_budget_exhausted"; return p;
}
if (a->nvictims >= c->max_victims || a->nrate >= c->max_per_minute)
p.budget_override = "emergency";
} else if (a->nvictims >= c->max_victims || a->nrate >= c->max_per_minute) {
p.reason = "victim_budget_exhausted"; return p;
}
/* Emergency bypasses the normal cooldown, not protection or budgets. */
@@ -160,7 +182,7 @@ plan_t action_plan(controller_t *a, const config_t *c, const engine_t *e,
p.reason = "no_authorized_candidate"; return p;
}
p.target = *candidate;
p.action = e->floor ? KILL : TERM;
p.action = e->floor && c->floor_kill_delay_s == 0 ? KILL : TERM;
p.reason = e->floor ? "floor" : s->free < s->min ? "minfree" : "critical";
return p;
}


+ 11
- 3
src/guard.h Ver arquivo

@@ -13,7 +13,7 @@
#define CONF_PATH "/opt/custom/etc/o6h-memory-guard.conf"
#define LOG_DIR "/opt/custom/var/log/o6h-memory-guard"
#define RUN_DIR "/opt/custom/var/run"
#define VERSION "1.0.2"
#define VERSION "1.0.3"

enum state { NORMAL, PRE_PRESSURE, PRESSURE, CRITICAL, EMERGENCY, RECOVERY };
enum policy { OBSERVE, ALLOW, PROTECT };
@@ -31,8 +31,10 @@ typedef struct {
typedef struct { char uuid[37], alias[64]; enum policy policy; } zone_rule_t;
typedef struct {
int armed;
unsigned pre_s, pressure_s, critical_s, recovery_s, term_s;
unsigned pre_s, pressure_s, critical_s, recovery_s, critical_term_s;
unsigned emergency_term_s, floor_kill_delay_s, max_cached_candidate_age_s;
unsigned normal_scan_s, scan_budget_ms, cooldown_s, max_victims;
unsigned max_emergency_victims, max_floor_victims;
unsigned max_per_minute, log_mib, log_keep;
uint64_t min_rss_kib;
zone_rule_t zones[MAX_ZONES]; size_t nzones;
@@ -50,6 +52,7 @@ typedef struct {
enum state state;
double low_since, critical_since, recovery_since, last_at;
uint64_t last_free;
unsigned low_samples;
int have_last, danger, floor;
} engine_t;
typedef struct {
@@ -59,7 +62,12 @@ typedef struct {
process_t victims[MAX_VICTIMS]; unsigned nvictims;
double rate[64]; unsigned nrate;
} controller_t;
typedef struct { enum action action; process_t target; const char *reason; } plan_t;
typedef struct {
enum action action;
process_t target;
const char *reason;
const char *budget_override;
} plan_t;

void defaults(config_t *);
int config_read(FILE *, config_t *, char *, size_t);


+ 178
- 45
src/main.c Ver arquivo

@@ -19,9 +19,20 @@ typedef struct {
char uuid[64]; uint64_t generation, rss;
history_t history; unsigned seen; double last; int best;
} zone_t;
#define CACHED_CANDIDATES 3
typedef struct {
process_t p;
delta_t d5, d15, d60;
uint64_t zone_score, process_score;
double scan_time;
unsigned rank;
int valid, eligible;
char alias[64];
} cached_candidate_t;
static config_t cfg;
static tracked_t processes[MAX_PROCS];
static zone_t zone_stats[MAX_ZONES];
static cached_candidate_t candidate_cache[CACHED_CANDIDATES];
enum metric_index {
METRIC_FREE,
METRIC_KERNEL,
@@ -43,11 +54,12 @@ static const char *const metric_names[METRIC_COUNT] = {
static engine_t engine;
static controller_t controller;
static unsigned scan_generation;
static double scan_at, started;
static double scan_at, latest_complete_scan_at, started;
static int scan_complete;
static int logfd = -1, log_ok = 1, lockfd = -1;
static uint64_t log_bytes;
static volatile sig_atomic_t stopping, reopen_log;
static void delta_text(char *, size_t, delta_t);

static void handler(int sig)
{
@@ -158,6 +170,76 @@ static const char *alias_for(const char *uuid)
return r ? r->alias : "unmapped";
}

static zone_t *zone_for_process(const process_t *p)
{
unsigned i;
for (i = 0; i < MAX_ZONES; i++)
if (zone_stats[i].seen == scan_generation &&
zone_stats[i].generation == p->zone_generation &&
!strcmp(zone_stats[i].uuid, p->uuid)) return &zone_stats[i];
return NULL;
}

static int cache_better(const cached_candidate_t *a, const cached_candidate_t *b)
{
if (!b->valid) return 1;
if (a->zone_score != b->zone_score) return a->zone_score > b->zone_score;
if (a->process_score != b->process_score) return a->process_score > b->process_score;
return a->p.pid < b->p.pid;
}

static void rebuild_candidate_cache(void)
{
cached_candidate_t next[CACHED_CANDIDATES];
unsigned i, j;
memset(next, 0, sizeof (next));
for (i = 0; i < MAX_PROCS; i++) {
cached_candidate_t entry;
tracked_t *t = &processes[i];
zone_t *z;
delta_t zgrowth;
if (t->seen != scan_generation || !t->p.pid ||
protected_process(&cfg, &t->p) || was_victim(&controller, &t->p)) continue;
z = zone_for_process(&t->p);
if (!z) continue;
memset(&entry, 0, sizeof (entry));
entry.p = t->p; entry.d5 = history_delta(&t->rss, scan_at, 5);
entry.d15 = history_delta(&t->rss, scan_at, 15);
entry.d60 = history_delta(&t->rss, scan_at, 60);
zgrowth = growth(&z->history);
entry.zone_score = rank_score(z->rss, zgrowth);
entry.process_score = rank_score(t->p.rss_kib, growth(&t->rss));
entry.scan_time = scan_at; entry.valid = entry.eligible = 1;
snprintf(entry.alias, sizeof (entry.alias), "%s", alias_for(t->p.uuid));
for (j = 0; j < CACHED_CANDIDATES; j++) {
unsigned k;
if (!cache_better(&entry, &next[j])) continue;
for (k = CACHED_CANDIDATES - 1; k > j; k--) next[k] = next[k - 1];
next[j] = entry; break;
}
}
memcpy(candidate_cache, next, sizeof (candidate_cache));
latest_complete_scan_at = scan_at;
for (i = 0; i < CACHED_CANDIDATES && candidate_cache[i].valid; i++) {
char d5[64], d15[64], d60[64];
candidate_cache[i].rank = i + 1;
delta_text(d5, sizeof (d5), candidate_cache[i].d5);
delta_text(d15, sizeof (d15), candidate_cache[i].d15);
delta_text(d60, sizeof (d60), candidate_cache[i].d60);
emit("event=candidate_cache rank=%u UUID=%s alias=%s zone_generation=%" PRIu64
" pid=%d start=%" PRId64 ".%09" PRId64 " comm=%s rss_kib=%" PRIu64
" d5_kib=%s d15_kib=%s d60_kib=%s age_ms=0 eligible=%d"
" zone_score=%" PRIu64 " process_score=%" PRIu64,
candidate_cache[i].rank, candidate_cache[i].p.uuid,
candidate_cache[i].alias, candidate_cache[i].p.zone_generation,
candidate_cache[i].p.pid, candidate_cache[i].p.start_sec,
candidate_cache[i].p.start_nsec, candidate_cache[i].p.name,
candidate_cache[i].p.rss_kib, d5, d15, d60,
candidate_cache[i].eligible, candidate_cache[i].zone_score,
candidate_cache[i].process_score);
}
}

static void delta_text(char *out, size_t n, delta_t d)
{
if (d.valid) snprintf(out, n, "%+" PRId64 "@%.2fs", d.value, d.age);
@@ -185,8 +267,10 @@ static void scan_processes(int snapshot)
scan_at = monotime(); scan_generation++;
if (!scan_generation) scan_generation++; /* practically unreachable */
scan_complete = platform_walk(visit, NULL, cfg.scan_budget_ms) == 0;
emit("event=proc_scan complete=%d duration_ms=%.1f capacity=%d", scan_complete,
1000 * (monotime() - scan_at), MAX_PROCS);
emit("event=proc_scan complete=%d duration_ms=%.1f capacity=%d"
" latest_complete_age_ms=%.1f", scan_complete,
1000 * (monotime() - scan_at), MAX_PROCS,
latest_complete_scan_at > 0 ? 1000 * (scan_at - latest_complete_scan_at) : -1.0);
for (i = 0; i < MAX_ZONES; i++) {
zone_t *z = &zone_stats[i];
char d5[64], d15[64], d60[64];
@@ -201,6 +285,7 @@ static void scan_processes(int snapshot)
" complete=%d d5_kib=%s d15_kib=%s d60_kib=%s", z->uuid, alias_for(z->uuid),
z->generation, z->rss, scan_complete, d5, d15, d60);
}
if (scan_complete) rebuild_candidate_cache();
if (!snapshot) return;
for (i = 0; i < MAX_PROCS; i++) {
if (processes[i].seen != scan_generation || !processes[i].p.pid) continue;
@@ -216,18 +301,14 @@ static void scan_processes(int snapshot)

static const process_t *candidate(void)
{
unsigned i; zone_t *best = NULL;
if (!scan_complete || monotime() - scan_at > 2) return NULL;
for (i = 0; i < MAX_ZONES; i++) {
zone_t *z = &zone_stats[i];
if (z->seen != scan_generation || z->best < 0) continue;
if (was_victim(&controller, &processes[z->best].p)) continue;
if (!best || rank_score(z->rss, growth(&z->history)) > rank_score(best->rss, growth(&best->history)))
best = z;
unsigned i; double now = monotime();
for (i = 0; i < CACHED_CANDIDATES; i++) {
cached_candidate_t *entry = &candidate_cache[i];
if (!entry->valid || now - entry->scan_time > cfg.max_cached_candidate_age_s ||
protected_process(&cfg, &entry->p) || was_victim(&controller, &entry->p)) continue;
return &entry->p;
}
if (!best) return NULL;
log_process("candidate", &processes[best->best]);
return &processes[best->best].p;
return NULL;
}

static int metric_valid(enum metric_index metric, const sample_t *s)
@@ -286,50 +367,92 @@ static void act(sample_t *sample)
plan_t plan;
sample_t fresh;
engine_t current_engine;
const process_t *p;
int err, rc;
const char *source = "pending", *blocked_reason = "no_valid_cached_candidate";
double candidate_age = -1;
unsigned i, rank = 0;
int err, rc, validated = 0;
if (stopping) return;
if (!engine.danger) {
(void)action_plan(&controller, &cfg, &engine, sample, NULL);
return;
}
if (!log_ok || !scan_complete) {
emit("event=action_blocked reason=log_or_incomplete_scan"); return;
if (!log_ok) {
emit("event=action_blocked reason=log_failure"); return;
}
if (cfg.armed && monotime() - started < 60) {
emit("event=action_blocked reason=armed_startup_60s"); return;
}
/* Refresh after /proc traversal and logging, before authorizing a signal. */
/* O(1) critical path: kstat refresh + cached identity validation, no walk. */
if (platform_sample(&fresh) || monotime() - fresh.at > 2 || fresh.free >= fresh.des) {
emit("event=action_blocked reason=refresh_failed_or_above_desfree"); return;
}
p = candidate();
current_engine = engine; current_engine.floor = fresh.free < fresh.min / 2;
plan = action_plan(&controller, &cfg, &current_engine, &fresh, p);
if (plan.action == NONE) { emit("event=action_blocked reason=%s", plan.reason); return; }
/* A fresh floor crossing must not wait for the next tick. */
if (fresh.free < fresh.min / 2) { plan.action = KILL; plan.reason = "floor"; }
if (platform_signal(&cfg, &plan.target, plan.action, 0, 0)) {
err = errno;
emit("event=action_rejected reason=identity_or_protection pid=%d errno=%d", plan.target.pid, err);
if (controller.has_pending && same_process(&controller.pending, &plan.target)) {
controller.has_pending = 0;
/* A vanished pending victim must not consume another emergency tick. */
if (fresh.free < fresh.min) act(&fresh);
current_engine = engine;
current_engine.floor = fresh.free <= fresh.min / 2;
if (fresh.free <= fresh.min) {
current_engine.state = EMERGENCY; current_engine.danger = 1;
}
retry_candidate:
if (controller.has_pending) {
plan = action_plan(&controller, &cfg, &current_engine, &fresh, NULL);
if (plan.action == NONE) {
emit("event=action_blocked reason=%s state=%s", plan.reason,
state_name(current_engine.state)); return;
}
if (platform_signal(&cfg, &plan.target, plan.action, 0, 0)) {
err = errno; controller.has_pending = 0;
emit("event=action_rejected reason=identity_or_protection source=pending"
" pid=%d errno=%d", plan.target.pid, err);
goto retry_candidate;
}
validated = 1;
} else {
for (i = 0; i < CACHED_CANDIDATES; i++) {
cached_candidate_t *entry = &candidate_cache[i];
candidate_age = fresh.at - entry->scan_time;
if (!entry->valid || candidate_age < 0 ||
candidate_age > cfg.max_cached_candidate_age_s ||
protected_process(&cfg, &entry->p) ||
was_victim(&controller, &entry->p)) continue;
plan = action_plan(&controller, &cfg, &current_engine, &fresh, &entry->p);
if (plan.action == NONE) { blocked_reason = plan.reason; break; }
if (platform_signal(&cfg, &plan.target, plan.action, 0, 0)) {
err = errno; entry->valid = 0;
emit("event=action_rejected reason=identity_or_protection"
" source=%s rank=%u pid=%d errno=%d",
i == 0 ? "cached_candidate" : "fallback_candidate",
i + 1, plan.target.pid, err);
continue;
}
rank = i + 1;
source = i == 0 ? "cached_candidate" : "fallback_candidate";
validated = 1; break;
}
if (!validated) {
emit("event=action_blocked reason=%s state=%s scan_complete=%d"
" latest_complete_age_ms=%.1f", blocked_reason,
state_name(current_engine.state), scan_complete,
latest_complete_scan_at > 0 ?
1000 * (fresh.at - latest_complete_scan_at) : -1.0);
return;
}
return;
}
emit("event=action_decision state=%s candidate_source=%s rank=%u"
" scan_complete=%d candidate_age_ms=%.1f victim_budget_override=%s"
" pid=%d UUID=%s", state_name(current_engine.state), source, rank,
scan_complete, candidate_age >= 0 ? 1000 * candidate_age : -1.0,
plan.budget_override, plan.target.pid, plan.target.uuid);
if (emit("event=action %s=%s reason=%s UUID=%s alias=%s zone_generation=%" PRIu64
" pid=%d start=%" PRId64 ".%09" PRId64 " comm=%s rss_kib=%" PRIu64 " free_pages=%" PRIu64,
" pid=%d start=%" PRId64 ".%09" PRId64 " comm=%s rss_kib=%" PRIu64
" free_pages=%" PRIu64 " victim_budget_override=%s",
cfg.armed ? "ACTION_INTENT" : "WOULD_ACTION", plan.action == TERM ? "SIGTERM" : "SIGKILL",
plan.reason, plan.target.uuid, alias_for(plan.target.uuid), plan.target.zone_generation,
plan.target.pid, plan.target.start_sec, plan.target.start_nsec, plan.target.name,
plan.target.rss_kib, fresh.free)) return;
plan.target.rss_kib, fresh.free, plan.budget_override)) return;
/* Consume a budget slot even if the subsequent signal write is ambiguous. */
action_commit(&controller, &cfg, &fresh, &plan);
if (cfg.armed && !stopping) {
rc = platform_signal(&cfg, &plan.target, plan.action, 1,
!strcmp(plan.reason, "floor") ? fresh.min / 2 : fresh.des); err = errno;
!strcmp(plan.reason, "floor") ? fresh.min / 2 + 1 : fresh.des); err = errno;
emit("event=action_result pid=%d signal=%s result=%s errno=%d", plan.target.pid,
plan.action == TERM ? "SIGTERM" : "SIGKILL", rc ? "failed" : "sent", rc ? err : 0);
if (rc) controller.has_pending = 0;
@@ -425,9 +548,10 @@ int main(int argc, char **argv)
engine_init(&engine); started = monotime(); next = started;
/* Touch all fixed working storage before allowing armed operation. */
memset(processes, 0, sizeof (processes)); memset(zone_stats, 0, sizeof (zone_stats));
memset(candidate_cache, 0, sizeof (candidate_cache));
if (emit("event=start version=%s pid=%ld mode=%s page_bytes=%ld fixed_storage_bytes=%zu armed_warmup=60",
VERSION, (long)getpid(), cfg.armed ? "armed" : "dry-run", sysconf(_SC_PAGESIZE),
sizeof (processes) + sizeof (zone_stats))) return 1;
sizeof (processes) + sizeof (zone_stats) + sizeof (candidate_cache))) return 1;
if (readyfd >= 0) {
if (write(readyfd, "R", 1) != 1) return 1;
close(readyfd);
@@ -453,23 +577,32 @@ int main(int argc, char **argv)
history_delta(&metrics[METRIC_SWAP_PHYSICAL_USED], sample.at, 5),
history_delta(&metrics[METRIC_ANON_PAGEOUT], sample.at, 5));
if (engine.state != previous)
emit("event=transition from=%s to=%s", state_name(previous), state_name(engine.state));
emit("event=state_transition from=%s to=%s free_pages=%" PRIu64
" lotsfree=%" PRIu64 " desfree=%" PRIu64 " minfree=%" PRIu64
" low_samples=%u", state_name(previous), state_name(engine.state),
sample.free, sample.lots, sample.des, sample.min, engine.low_samples);
log_sample(&sample);
/* Use a recent complete cache first in emergencies. Revalidation is mandatory. */
if (sample.free < sample.min && scan_complete && sample.at - scan_at <= 2) {
if (previous != RECOVERY && engine.state == RECOVERY)
emit("event=recovery_check free_pages=%" PRIu64
" target=desfree target_pages=%" PRIu64 " reached=%d",
sample.free, sample.des, sample.free >= sample.des);
else if (engine.state == RECOVERY)
emit("event=recovery_check free_pages=%" PRIu64
" target=lotsfree target_pages=%" PRIu64 " stable_seconds=%.1f",
sample.free, sample.lots, engine.recovery_since >= 0 ?
sample.at - engine.recovery_since : 0.0);
/* CRITICAL/EMERGENCY is O(1): never wait for a full /proc walk. */
if (engine.danger) {
act(&sample);
} else {
/* Cancel pending escalation/reset episode budgets before rebuilding cache. */
act(&sample);
if (sample.free < sample.lots || sample.at - last_scan >= cfg.normal_scan_s) {
int snapshot = sample.at - last_snapshot >= (sample.free < sample.lots ? 5 : 60);
scan_processes(snapshot); last_scan = sample.at;
if (snapshot) last_snapshot = sample.at;
if (sample.free < sample.lots && !engine.danger) (void)candidate();
}
act(&sample);
}
/* Refresh cache even during an ongoing emergency. */
if (sample.free < sample.min && sample.at - last_scan >= 0.9) {
scan_processes(0); last_scan = sample.at;
}
}
next += 1;


+ 6
- 0
tests/fixtures/pageout_deadman_real_incident_2026_09.csv Ver arquivo

@@ -0,0 +1,6 @@
# seconds,free_pages,nscan_pages
0,143127,0
1,115727,0
2,103000,0
3,107000,0
6,48893,1060408

+ 54
- 13
tests/test_guard.c Ver arquivo

@@ -43,7 +43,9 @@ static int parse(const char *text, config_t *c)
static void configs(void)
{
config_t c;
CHECK(parse("# defaults\n", &c) == 0 && !c.armed);
CHECK(parse("# defaults\n", &c) == 0 && !c.armed && c.pre_s == 1 &&
c.pressure_s == 2 && c.max_cached_candidate_age_s == 15 &&
c.max_emergency_victims == 8 && c.max_floor_victims == 12);
CHECK(parse("ACTION_MODE dry-run\nprotect_process postgres\n", &c) == 0);
CHECK(parse("ACTION_MODE armd\n", &c) != 0);
CHECK(parse("ACTION_MODE armed\n", &c) != 0);
@@ -51,6 +53,10 @@ static void configs(void)
CHECK(parse("LOG_KEEP 0\n", &c) != 0);
CHECK(parse("TERM_GRACE_SECONDS -1\n", &c) != 0);
CHECK(parse("TERM_GRACE_SECONDS 1 garbage\n", &c) != 0);
CHECK(parse("CRITICAL_TERM_GRACE_SECONDS 4\nEMERGENCY_TERM_GRACE_SECONDS 1\n"
"FLOOR_KILL_DELAY_SECONDS 0\nMAX_CACHED_CANDIDATE_AGE_SECONDS 15\n", &c) == 0);
CHECK(parse("MAX_EMERGENCY_VICTIMS_EPISODE 3\n", &c) != 0);
CHECK(parse("MAX_FLOOR_VICTIMS_EPISODE 7\n", &c) != 0);
CHECK(parse("UNKNOWN foo\n", &c) != 0);
CHECK(parse("PRE_SECONDS 20\nPRESSURE_SECONDS 10\n", &c) != 0);
CHECK(parse("zone global global allow\n", &c) != 0);
@@ -58,6 +64,11 @@ static void configs(void)
CHECK(parse("zone 11111111-1111-4111-8111-111111111111 web allow\nzone 11111111-1111-4111-8111-111111111111 db protect\n", &c) != 0);
CHECK(!uuid_valid("11111111-1111-4111-8111-11111111111g"));
CHECK(!uuid_valid("00000000-0000-0000-0000-000000000000"));
{
FILE *f = fopen("etc/o6h-memory-guard.conf", "r"); char error[128];
CHECK(f != NULL); CHECK(config_read(f, &c, error, sizeof (error)) == 0);
fclose(f); CHECK(!c.armed && c.pre_s == 1 && c.pressure_s == 2);
}
puts("PASS strict configuration, safe defaults, explicit UUID authorization");
}
static void protections(void)
@@ -116,21 +127,21 @@ static void states(void)
engine_init(&e);
for (i = 0; i < 10; i++) step(&e, &c, i, 425950, 0);
CHECK(e.state == NORMAL && !e.danger);
for (i = 10; i <= 12; i++) step(&e, &c, i, 100000, 1);
CHECK(e.state == NORMAL);
step(&e, &c, 13, 100000, 1); CHECK(e.state == PRE_PRESSURE);
for (i = 14; i <= 20; i++) step(&e, &c, i, 100000, 1);
step(&e, &c, 10, 100000, 0); CHECK(e.state == NORMAL);
step(&e, &c, 11, 100000, 0); CHECK(e.state == PRE_PRESSURE);
step(&e, &c, 12, 100000, 0);
CHECK(e.state == PRESSURE && !e.danger);
step(&e, &c, 21, 60000, 1); step(&e, &c, 22, 59000, 1);
CHECK(!e.danger);
step(&e, &c, 23, 58000, 1); CHECK(e.state == CRITICAL && e.danger);
step(&e, &c, 24, 140000, 0); CHECK(e.state == RECOVERY && !e.danger);
for (i = 25; i <= 40; i++) step(&e, &c, i, 140000, 0);
CHECK(e.state == RECOVERY); /* below 10% margin */
for (i = 41; i <= 56; i++) step(&e, &c, i, 150000, 0);
for (i = 25; i <= 39; i++) step(&e, &c, i, 140000, 0);
CHECK(e.state == NORMAL);
for (i = 40; i <= 56; i++) step(&e, &c, i, 150000, 0);
CHECK(e.state == NORMAL);
step(&e, &c, 57, 40000, 0); CHECK(e.state == EMERGENCY && e.danger && !e.floor);
step(&e, &c, 58, 20000, 0); CHECK(e.floor);
step(&e, &c, 59, 70000, 0); CHECK(e.state == RECOVERY && !e.danger);
engine_init(&e);
for (i = 0; i < 20; i++) step(&e, &c, i, 60000, 0);
CHECK(!e.danger); /* low but stable, no scanner */
@@ -158,6 +169,23 @@ static void states(void)
}
puts("PASS all six states, corroboration, hysteresis, recovery and sampling gaps");
}
static void real_incident_fixture(void)
{
config_t c = allowed(); engine_t e; FILE *f;
unsigned t, rows = 0; uint64_t free_pages, nscan;
char line[128];
engine_init(&e);
f = fopen("tests/fixtures/pageout_deadman_real_incident_2026_09.csv", "r");
CHECK(f != NULL); CHECK(fgets(line, sizeof (line), f) != NULL);
while (fscanf(f, "%u,%" SCNu64 ",%" SCNu64, &t, &free_pages, &nscan) == 3) {
step(&e, &c, t, free_pages, nscan); rows++;
if (t == 2) CHECK(e.state == PRE_PRESSURE);
if (t == 3) CHECK(e.state == PRESSURE);
}
fclose(f);
CHECK(rows == 5); CHECK(e.state == EMERGENCY && e.danger);
puts("PASS pageout_deadman_real_incident_2026_09 exits NORMAL before minfree");
}
static void actions(void)
{
config_t c = allowed(); engine_t e; controller_t a = {0};
@@ -188,12 +216,25 @@ static void actions(void)
plan = action_plan(&a, &c, &e, &s, &p); CHECK(plan.action == KILL);
action_commit(&a, &c, &s, &plan);
p.pid++; s.at++;
CHECK(action_plan(&a, &c, &e, &s, &p).action == NONE); /* even at floor */
plan = action_plan(&a, &c, &e, &s, &p); CHECK(plan.action == KILL);
CHECK(!strcmp(plan.budget_override, "floor"));
e.state = NORMAL; e.danger = 0; s.free = 160000;
(void)action_plan(&a, &c, &e, &s, &p); CHECK(a.nvictims == 0);
e.state = EMERGENCY; e.danger = 1; s.free = 20000;
CHECK(action_plan(&a, &c, &e, &s, &p).action == NONE); /* minute budget persists */
s.at = 180; CHECK(action_plan(&a, &c, &e, &s, &p).action == KILL);
e.state = EMERGENCY; e.danger = 1; e.floor = 0; s.free = 40000;
a.nvictims = c.max_victims; a.nrate = c.max_per_minute;
e.state = CRITICAL;
CHECK(action_plan(&a, &c, &e, &s, &p).action == NONE);
e.state = EMERGENCY;
a.nvictims = c.max_victims; a.nrate = c.max_per_minute;
plan = action_plan(&a, &c, &e, &s, &p); CHECK(plan.action == TERM);
CHECK(!strcmp(plan.budget_override, "emergency"));
a.nvictims = c.max_emergency_victims;
CHECK(action_plan(&a, &c, &e, &s, &p).action == NONE);
e.floor = 1; s.free = 20000;
plan = action_plan(&a, &c, &e, &s, &p); CHECK(plan.action == KILL);
CHECK(!strcmp(plan.budget_override, "floor"));
a.nvictims = c.max_floor_victims;
CHECK(action_plan(&a, &c, &e, &s, &p).action == NONE);
memset(&a, 0, sizeof (a)); e.floor = 0; e.state = CRITICAL; s.free = 60000;
plan = action_plan(&a, &c, &e, &s, &p); action_commit(&a, &c, &s, &plan);
s.free = 140000; e.danger = 0; e.state = RECOVERY;
@@ -210,7 +251,7 @@ static void actions(void)
}
int main(void)
{
configs(); protections(); histories(); states(); actions();
configs(); protections(); histories(); states(); real_incident_fixture(); actions();
printf("PASS %u checks; no native backend linked, no signals sent\n", checks);
return 0;
}

+ 47
- 7
tests/test_runtime.c Ver arquivo

@@ -6,8 +6,8 @@
static double fake_now = 100;
static sample_t fake_sample;
static process_t fixtures[8];
static unsigned nfixtures, real_requests, validation_requests, checks;
static int fail_validation, fail_sample, partial;
static unsigned nfixtures, real_requests, validation_requests, walk_requests, checks;
static int fail_validation, fail_sample, partial, invalid_pid;
#define CHECK(x) do { if (!(x)) { fprintf(stderr, "FAIL runtime line %d: %s\n", __LINE__, #x); exit(1); } checks++; } while (0)

double monotime(void) { return fake_now; }
@@ -21,17 +21,21 @@ int platform_sample(sample_t *s)
int platform_walk(int (*fn)(const process_t *, void *), void *arg, unsigned budget)
{
unsigned j; (void)budget;
walk_requests++;
for (j = 0; j < nfixtures; j++) if (fn(&fixtures[j], arg)) return -1;
return partial ? -1 : 0;
}
int platform_signal(const config_t *c, const process_t *p, enum action action,
int real, uint64_t ceiling)
{
unsigned j; int found = 0;
CHECK(action == TERM || action == KILL);
CHECK(!protected_process(c, p));
for (j = 0; j < nfixtures; j++)
if (fixtures[j].pid == p->pid && same_process(&fixtures[j], p)) { found = 1; break; }
if (real) { CHECK(c->armed && fake_sample.free < ceiling); real_requests++; }
else validation_requests++;
if (fail_validation) { errno = ESTALE; return -1; }
if (fail_validation || p->pid == invalid_pid || !found) { errno = ESTALE; return -1; }
return 0; /* This test backend cannot send any signal. */
}
static void reset(void)
@@ -43,12 +47,14 @@ static void reset(void)
strcpy(cfg.zones[1].uuid, "22222222-2222-4222-8222-222222222222");
strcpy(cfg.zones[1].alias, "web-b"); cfg.zones[1].policy = ALLOW;
memset(processes, 0, sizeof (processes)); memset(zone_stats, 0, sizeof (zone_stats));
memset(candidate_cache, 0, sizeof (candidate_cache));
memset(metrics, 0, sizeof (metrics));
memset(&controller, 0, sizeof (controller)); memset(fixtures, 0, sizeof (fixtures));
engine_init(&engine); engine.state = CRITICAL; engine.danger = 1;
stopping = 0; started = 0; log_ok = 1; log_bytes = 0;
scan_generation = 0; fake_now = 100; partial = fail_sample = fail_validation = 0;
real_requests = validation_requests = 0;
scan_generation = 0; scan_complete = 0; latest_complete_scan_at = 0;
fake_now = 100; partial = fail_sample = fail_validation = invalid_pid = 0;
real_requests = validation_requests = walk_requests = 0;
memset(&fake_sample, 0, sizeof (fake_sample)); fake_sample.at = fake_now;
fake_sample.free = 60000; fake_sample.lots = 130875;
fake_sample.des = 65437; fake_sample.min = 49077;
@@ -107,11 +113,12 @@ int main(void)
fake_now += 5; scan_processes(0); act(&fake_sample); CHECK(real_requests == 2);
reset(); cfg.armed = 1; started = 80; act(&fake_sample); CHECK(real_requests == 0);
reset(); cfg.armed = 1; log_ok = 0; act(&fake_sample); CHECK(real_requests == 0);
reset(); cfg.armed = 1; partial = 1; scan_processes(0); act(&fake_sample); CHECK(real_requests == 0);
reset(); cfg.armed = 1; partial = 1; fake_now++; scan_processes(0);
act(&fake_sample); CHECK(real_requests == 1 && !scan_complete);
reset(); cfg.armed = 1; fail_sample = 1; act(&fake_sample); CHECK(real_requests == 0);
reset(); cfg.armed = 1; fail_validation = 1; act(&fake_sample); CHECK(real_requests == 0);
reset(); cfg.armed = 1; fake_sample.free = 150000; act(&fake_sample); CHECK(real_requests == 0);
reset(); cfg.armed = 1; fake_now += 3; act(&fake_sample); CHECK(real_requests == 0);
reset(); cfg.armed = 1; fake_now += 16; act(&fake_sample); CHECK(real_requests == 0);
reset(); cfg.armed = 1; stopping = 1; act(&fake_sample); CHECK(real_requests == 0);
reset(); fake_sample.free = 20000; act(&fake_sample);
CHECK(!controller.has_pending && controller.nvictims == 1);
@@ -127,6 +134,39 @@ int main(void)
chosen = candidate(); CHECK(chosen && chosen->pid == 124);
fixtures[1].zid = 0; fake_now = 163; scan_processes(0); CHECK(candidate() == NULL);
puts("PASS actual daemon ranking by zone/PID RSS and growth; protected zones and global zone excluded");
reset(); fixtures[1] = fixtures[0]; fixtures[1].pid = 124;
fixtures[1].rss_kib = 900000; fixtures[1].zid = 10;
strcpy(fixtures[1].uuid, cfg.zones[1].uuid);
fixtures[2] = fixtures[0]; fixtures[2].pid = 125; fixtures[2].rss_kib = 800000;
nfixtures = 3; fake_now = 101; scan_processes(0);
CHECK(candidate_cache[0].valid && candidate_cache[1].valid && candidate_cache[2].valid);
invalid_pid = candidate_cache[0].p.pid;
partial = 1; fake_now = 102; scan_processes(0);
CHECK(!scan_complete && candidate_cache[0].p.pid == invalid_pid);
{
unsigned walks_before = walk_requests;
engine.state = EMERGENCY; engine.danger = 1; fake_sample.free = 40000;
act(&fake_sample);
CHECK(walk_requests == walks_before); /* O(1): no /proc walk in action path. */
CHECK(controller.has_pending && controller.pending.pid != invalid_pid);
CHECK(validation_requests >= 2 && real_requests == 0);
}
CHECK(fflush(log) == 0 && fseek(log, 0, SEEK_SET) == 0);
n = fread(contents, 1, sizeof (contents) - 1, log); contents[n] = 0;
CHECK(strstr(contents, "candidate_source=fallback_candidate") != NULL);
CHECK(strstr(contents, "scan_complete=0") != NULL);
CHECK(fseek(log, 0, SEEK_END) == 0);
puts("PASS incomplete scan preserves cache; emergency uses O(1) fallback without a new walk");
reset(); fixtures[1] = fixtures[0]; fixtures[1].pid = 124;
fixtures[1].rss_kib = 900000; fixtures[1].zid = 10;
strcpy(fixtures[1].uuid, cfg.zones[1].uuid); nfixtures = 2;
fake_now = 101; scan_processes(0);
for (second = 0; second < nfixtures; second++)
if (fixtures[second].pid == candidate_cache[0].p.pid) fixtures[second].start_nsec++;
engine.state = EMERGENCY; engine.danger = 1; fake_sample.free = 40000;
act(&fake_sample);
CHECK(controller.has_pending && !same_process(&controller.pending, &candidate_cache[0].p));
puts("PASS PID/start-time reuse rejects rank 1 and selects cached fallback");
fclose(log);
printf("PASS %u runtime checks; all platform calls mocked, no signals sent\n", checks);
return 0;


Carregando…
Cancelar
Salvar