Преглед на файлове

Release o6h-memory-guard 1.0.3

master
psarria преди 1 месец
родител
ревизия
b8a62094d9
променени са 18 файла, в които са добавени 652 реда и са изтрити 242 реда
  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 Целия файл

@@ -1,5 +1,29 @@
# Changelog # 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 ## 1.0.2 — 2026-09-18


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


+ 99
- 0
INCIDENT_PAGEOUT_DEADMAN_2026_09.md Целия файл

@@ -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 Целия файл

@@ -15,7 +15,7 @@ native-check:
o6h-memory-guard: $(SOURCES) src/guard.h | native-check o6h-memory-guard: $(SOURCES) src/guard.h | native-check
$(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ $(SOURCES) $(LDLIBS) $(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 $(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 test-runtime: tests/test_runtime.c src/main.c src/core.c src/config.c src/guard.h


+ 56
- 36
README.md Целия файл

@@ -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, 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, /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, - `CHECKPOINT.md`: checkpoint operativo posterior, incorporado sin cambios,
con la evidencia acumulada de compilación, ejecución y logging de v1.0.2 en 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`. 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. - `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 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 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. 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 ```sh
mkdir -p /opt/custom/src mkdir -p /opt/custom/src
cd /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 cd /opt/custom/src/o6h-memory-guard
gmake CC=gcc gmake CC=gcc
gmake test 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 | | Estado/condición de entrada | Comportamiento predeterminado |
| --- | --- | | --- | --- |
| NORMAL | Sin intervención; muestreo VM de 1 s. | | 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. 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 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 bajo `lotsfree` no cambia el estado. El compromiso virtual tampoco se interpreta
como pageout. como pageout.
Los tiempos son segundos monotónicos transcurridos, no número de filas leídas. 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 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 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 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. 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. `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 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 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 varias veces**: es una aproximación de atribución, no memoria física exclusiva
ni memoria garantizada que se recuperará al terminar un proceso. 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. su cadena. No se promete cero asignaciones ni tiempo real estricto.


El recorrido /proc tiene presupuesto cooperativo de 200 ms (hasta 500 ms por 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; 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í 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. 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; `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. 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 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. UUID `allow` mínimas y verificar antes las protecciones y el laboratorio nativo.
Después de esos cambios, validar config/manifiesto, importar, refrescar y 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 Para actualizar: deshabilitar primero, conservar copias del binario, config y
manifiesto en un directorio de backup nuevo, reemplazar el binario estando parado 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 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 ## Referencias revisadas




+ 17
- 15
SHA256SUMS Целия файл

@@ -1,27 +1,29 @@
887569535302f7deba4d7c6ffb2103f1fb90bd96a40280240ff238eddc2e3a6f ./.gitignore 887569535302f7deba4d7c6ffb2103f1fb90bd96a40280240ff238eddc2e3a6f ./.gitignore
45e39d4bc8c8e3ef59e99167ef87fcc2864c0307693eeb5cb03664a0f6a7a722 ./CHANGELOG.md
8b1e0498bf3b9ccf3a36a4cc1ed0de7573612da2ef27be19e5496287679509f5 ./CHANGELOG.md
ebfca7d4b5eaf0c0cc9910cf49d8c85f6aa7ff69972d7f21d17e61d1a2e23bc2 ./CHECKPOINT.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 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 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 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 32ab75bb6a1ff2bbbeb6a1ea658abcb96a03fcc06246f38d019faec7fdc184b8 ./src/illumos.c
2a9c54014272a78060b73b1863606e87e643cd27359bb77e12b8224b45baf18a ./src/main.c
066473572d8d2d8ca354ab3e718d3ccce618f8cfbb96992d008da3e9592b8815 ./src/main.c
2cb2b4c50fd42051fde4a702e8955e07d63979d5e3216e02420ed9b54fb67578 ./src/support.c 2cb2b4c50fd42051fde4a702e8955e07d63979d5e3216e02420ed9b54fb67578 ./src/support.c
f754e71d91d65403ab8e84e9701cfbb89bdd91e13766e668445e689e6890b369 ./tests/api-sketch/kstat.h f754e71d91d65403ab8e84e9701cfbb89bdd91e13766e668445e689e6890b369 ./tests/api-sketch/kstat.h
f0d06353d2e326c7bdce776bee6f0a8606cda50d5de957dfdd586b6848fca8da ./tests/api-sketch/procfs.h f0d06353d2e326c7bdce776bee6f0a8606cda50d5de957dfdd586b6848fca8da ./tests/api-sketch/procfs.h
1c4fcb7bc48ec0a2774b1ecd73346dd45feb969a9250eb7056809d5d11ad40fe ./tests/api-sketch/sys/swap.h 1c4fcb7bc48ec0a2774b1ecd73346dd45feb969a9250eb7056809d5d11ad40fe ./tests/api-sketch/sys/swap.h
340600b282a0c813323c1a09d5d6635ed4c56aa49a6d04132636851c8e714170 ./tests/api-sketch/vm/anon.h 340600b282a0c813323c1a09d5d6635ed4c56aa49a6d04132636851c8e714170 ./tests/api-sketch/vm/anon.h
9b99e272008ad00ad0abb366e1e8720dd6c51fc050821c5d1d878eae5719c22b ./tests/api-sketch/zone.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 Целия файл

@@ -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 ## Validación obligatoria pendiente en SmartOS


1. Compilar con cabeceras nativas (`gmake CC=gcc`), ejecutar `gmake test CC=gcc` 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 ## 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 Целия файл

@@ -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. # Restart required for configuration changes. Duplicate scalar keys are errors.
ACTION_MODE dry-run ACTION_MODE dry-run


PRE_SECONDS 3
PRESSURE_SECONDS 10
PRE_SECONDS 1
PRESSURE_SECONDS 2
CRITICAL_SECONDS 2 CRITICAL_SECONDS 2
RECOVERY_SECONDS 15 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 NORMAL_SCAN_SECONDS 5
SCAN_BUDGET_MS 200 SCAN_BUDGET_MS 200
COOLDOWN_SECONDS 10 COOLDOWN_SECONDS 10
MAX_VICTIMS_EPISODE 4 MAX_VICTIMS_EPISODE 4
MAX_VICTIMS_MINUTE 4 MAX_VICTIMS_MINUTE 4
MAX_EMERGENCY_VICTIMS_EPISODE 8
MAX_FLOOR_VICTIMS_EPISODE 12
MIN_RSS_KIB 65536 MIN_RSS_KIB 65536
LOG_MAX_MIB 10 LOG_MAX_MIB 10
LOG_KEEP 5 LOG_KEEP 5


+ 6
- 4
logs/example.log Целия файл

@@ -1,10 +1,12 @@
# SYNTHETIC FORMAT EXAMPLE -- NOT HOST TELEMETRY. Fields abridged for readability. # 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=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_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=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: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.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 Целия файл

@@ -2,8 +2,9 @@ PASS strict configuration, safe defaults, explicit UUID authorization
PASS mandatory protections, PID reuse and zone incarnation identity PASS mandatory protections, PID reuse and zone incarnation identity
PASS timestamped 5/15/60s windows, missing data, signed growth, overflow PASS timestamped 5/15/60s windows, missing data, signed growth, overflow
PASS all six states, corroboration, hysteresis, recovery and sampling gaps 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=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 t=105 state=CRITICAL pid=123 WOULD_ACTION=SIGKILL reason=memory_not_recovered
SIMULATED state=EMERGENCY floor=1 WOULD_ACTION=SIGKILL reason=floor SIMULATED state=EMERGENCY floor=1 WOULD_ACTION=SIGKILL reason=floor
PASS TERM/KILL sequencing, emergency grace, floor, cooldown, budgets and no-action protections 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 Целия файл

@@ -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 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 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 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 Целия файл

@@ -1,5 +1,5 @@
ASAN_OPTIONS=detect_leaks=0 make test-sanitize ASAN_OPTIONS=detect_leaks=0 make test-sanitize
GCC 11.4.0; AddressSanitizer + UndefinedBehaviorSanitizer 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. LeakSanitizer was intentionally disabled because the supervised environment can reject ptrace; no leak-check result is claimed.

+ 18
- 4
src/config.c Целия файл

@@ -7,10 +7,13 @@
void defaults(config_t *c) void defaults(config_t *c)
{ {
memset(c, 0, sizeof (*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->scan_budget_ms = 200; c->cooldown_s = 10;
c->max_victims = 4; c->max_per_minute = 4; 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; 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("PRESSURE_SECONDS", pressure_s, 2, 120, 2)
OPT("CRITICAL_SECONDS", critical_s, 1, 10, 3) OPT("CRITICAL_SECONDS", critical_s, 1, 10, 3)
OPT("RECOVERY_SECONDS", recovery_s, 5, 300, 4) 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("NORMAL_SCAN_SECONDS", normal_scan_s, 1, 5, 6)
OPT("SCAN_BUDGET_MS", scan_budget_ms, 10, 500, 7) OPT("SCAN_BUDGET_MS", scan_budget_ms, 10, 500, 7)
OPT("COOLDOWN_SECONDS", cooldown_s, 1, 120, 8) 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("MIN_RSS_KIB", min_rss_kib, 1024, 1073741824UL, 11)
OPT("LOG_MAX_MIB", log_mib, 1, 100, 12) OPT("LOG_MAX_MIB", log_mib, 1, 100, 12)
OPT("LOG_KEEP", log_keep, 1, 20, 13) 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 #undef OPT
goto invalid; 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) { if (c->armed) {
size_t i; int allow = 0; size_t i; int allow = 0;
for (i = 0; i < c->nzones; i++) allow |= c->zones[i].policy == ALLOW; for (i = 0; i < c->nzones; i++) allow |= c->zones[i].policy == ALLOW;


+ 45
- 23
src/core.c Целия файл

@@ -64,52 +64,59 @@ void engine_init(engine_t *e)
void engine_gap(engine_t *e) void engine_gap(engine_t *e)
{ {
e->low_since = e->critical_since = e->recovery_since = -1; 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, 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) delta_t free_d5, delta_t physical_swap_d5, delta_t pageout_d5)
{ {
int stress;
int stress, falling, rapid_fall;
enum state desired = NORMAL; enum state desired = NORMAL;
if (e->have_last && (s->at - e->last_at > 2.5 || s->at <= e->last_at)) if (e->have_last && (s->at - e->last_at > 2.5 || s->at <= e->last_at))
engine_gap(e); 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. */ /* 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 && (physical_swap_d5.valid && physical_swap_d5.value > 0 &&
pageout_d5.valid && pageout_d5.value > 0 && s->free < s->lots); 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 (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 (s->free < s->des && stress) {
if (e->critical_since < 0) e->critical_since = s->at; if (e->critical_since < 0) e->critical_since = s->at;
} else e->critical_since = -1; } 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; 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; desired = PRESSURE;
if (e->critical_since >= 0 && s->at - e->critical_since >= c->critical_s) if (e->critical_since >= 0 && s->at - e->critical_since >= c->critical_s)
desired = CRITICAL; 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) { if (desired >= PRE_PRESSURE && desired <= EMERGENCY) {
e->recovery_since = -1; e->recovery_since = -1;
if (e->state == RECOVERY || desired > e->state) e->state = desired; 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; 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 (e->recovery_since < 0) e->recovery_since = s->at;
if (s->at - e->recovery_since >= c->recovery_s) e->state = NORMAL; if (s->at - e->recovery_since >= c->recovery_s) e->state = NORMAL;
} else e->recovery_since = -1; } 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; 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; plan_t p;
unsigned i, n = 0; unsigned i, n = 0;
memset(&p, 0, sizeof (p)); p.reason = "no_pressure"; memset(&p, 0, sizeof (p)); p.reason = "no_pressure";
p.budget_override = "none";
for (i = 0; i < a->nrate; i++) for (i = 0; i < a->nrate; i++)
if (s->at - a->rate[i] < 60) a->rate[n++] = a->rate[i]; if (s->at - a->rate[i] < 60) a->rate[n++] = a->rate[i];
a->nrate = n; a->nrate = n;
if (e->state == NORMAL) a->nvictims = 0; if (e->state == NORMAL) a->nvictims = 0;
if (s->free >= s->lots) a->has_pending = 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) { if (a->has_pending) {
unsigned grace = c->critical_term_s;
p.reason = "term_grace"; 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.target = a->pending; p.action = KILL;
p.reason = e->floor ? "floor" : "memory_not_recovered"; p.reason = e->floor ? "floor" : "memory_not_recovered";
} }
return p; 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; p.reason = "victim_budget_exhausted"; return p;
} }
/* Emergency bypasses the normal cooldown, not protection or budgets. */ /* 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.reason = "no_authorized_candidate"; return p;
} }
p.target = *candidate; 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"; p.reason = e->floor ? "floor" : s->free < s->min ? "minfree" : "critical";
return p; return p;
} }


+ 11
- 3
src/guard.h Целия файл

@@ -13,7 +13,7 @@
#define CONF_PATH "/opt/custom/etc/o6h-memory-guard.conf" #define CONF_PATH "/opt/custom/etc/o6h-memory-guard.conf"
#define LOG_DIR "/opt/custom/var/log/o6h-memory-guard" #define LOG_DIR "/opt/custom/var/log/o6h-memory-guard"
#define RUN_DIR "/opt/custom/var/run" #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 state { NORMAL, PRE_PRESSURE, PRESSURE, CRITICAL, EMERGENCY, RECOVERY };
enum policy { OBSERVE, ALLOW, PROTECT }; 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 { char uuid[37], alias[64]; enum policy policy; } zone_rule_t;
typedef struct { typedef struct {
int armed; 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 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; unsigned max_per_minute, log_mib, log_keep;
uint64_t min_rss_kib; uint64_t min_rss_kib;
zone_rule_t zones[MAX_ZONES]; size_t nzones; zone_rule_t zones[MAX_ZONES]; size_t nzones;
@@ -50,6 +52,7 @@ typedef struct {
enum state state; enum state state;
double low_since, critical_since, recovery_since, last_at; double low_since, critical_since, recovery_since, last_at;
uint64_t last_free; uint64_t last_free;
unsigned low_samples;
int have_last, danger, floor; int have_last, danger, floor;
} engine_t; } engine_t;
typedef struct { typedef struct {
@@ -59,7 +62,12 @@ typedef struct {
process_t victims[MAX_VICTIMS]; unsigned nvictims; process_t victims[MAX_VICTIMS]; unsigned nvictims;
double rate[64]; unsigned nrate; double rate[64]; unsigned nrate;
} controller_t; } 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 *); void defaults(config_t *);
int config_read(FILE *, config_t *, char *, size_t); int config_read(FILE *, config_t *, char *, size_t);


+ 178
- 45
src/main.c Целия файл

@@ -19,9 +19,20 @@ typedef struct {
char uuid[64]; uint64_t generation, rss; char uuid[64]; uint64_t generation, rss;
history_t history; unsigned seen; double last; int best; history_t history; unsigned seen; double last; int best;
} zone_t; } 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 config_t cfg;
static tracked_t processes[MAX_PROCS]; static tracked_t processes[MAX_PROCS];
static zone_t zone_stats[MAX_ZONES]; static zone_t zone_stats[MAX_ZONES];
static cached_candidate_t candidate_cache[CACHED_CANDIDATES];
enum metric_index { enum metric_index {
METRIC_FREE, METRIC_FREE,
METRIC_KERNEL, METRIC_KERNEL,
@@ -43,11 +54,12 @@ static const char *const metric_names[METRIC_COUNT] = {
static engine_t engine; static engine_t engine;
static controller_t controller; static controller_t controller;
static unsigned scan_generation; static unsigned scan_generation;
static double scan_at, started;
static double scan_at, latest_complete_scan_at, started;
static int scan_complete; static int scan_complete;
static int logfd = -1, log_ok = 1, lockfd = -1; static int logfd = -1, log_ok = 1, lockfd = -1;
static uint64_t log_bytes; static uint64_t log_bytes;
static volatile sig_atomic_t stopping, reopen_log; static volatile sig_atomic_t stopping, reopen_log;
static void delta_text(char *, size_t, delta_t);


static void handler(int sig) static void handler(int sig)
{ {
@@ -158,6 +170,76 @@ static const char *alias_for(const char *uuid)
return r ? r->alias : "unmapped"; 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) static void delta_text(char *out, size_t n, delta_t d)
{ {
if (d.valid) snprintf(out, n, "%+" PRId64 "@%.2fs", d.value, d.age); 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++; scan_at = monotime(); scan_generation++;
if (!scan_generation) scan_generation++; /* practically unreachable */ if (!scan_generation) scan_generation++; /* practically unreachable */
scan_complete = platform_walk(visit, NULL, cfg.scan_budget_ms) == 0; 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++) { for (i = 0; i < MAX_ZONES; i++) {
zone_t *z = &zone_stats[i]; zone_t *z = &zone_stats[i];
char d5[64], d15[64], d60[64]; 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), " 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); z->generation, z->rss, scan_complete, d5, d15, d60);
} }
if (scan_complete) rebuild_candidate_cache();
if (!snapshot) return; if (!snapshot) return;
for (i = 0; i < MAX_PROCS; i++) { for (i = 0; i < MAX_PROCS; i++) {
if (processes[i].seen != scan_generation || !processes[i].p.pid) continue; 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) 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) 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; plan_t plan;
sample_t fresh; sample_t fresh;
engine_t current_engine; 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 (stopping) return;
if (!engine.danger) { if (!engine.danger) {
(void)action_plan(&controller, &cfg, &engine, sample, NULL); (void)action_plan(&controller, &cfg, &engine, sample, NULL);
return; 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) { if (cfg.armed && monotime() - started < 60) {
emit("event=action_blocked reason=armed_startup_60s"); return; 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) { if (platform_sample(&fresh) || monotime() - fresh.at > 2 || fresh.free >= fresh.des) {
emit("event=action_blocked reason=refresh_failed_or_above_desfree"); return; 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 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", 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.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.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. */ /* Consume a budget slot even if the subsequent signal write is ambiguous. */
action_commit(&controller, &cfg, &fresh, &plan); action_commit(&controller, &cfg, &fresh, &plan);
if (cfg.armed && !stopping) { if (cfg.armed && !stopping) {
rc = platform_signal(&cfg, &plan.target, plan.action, 1, 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, 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); plan.action == TERM ? "SIGTERM" : "SIGKILL", rc ? "failed" : "sent", rc ? err : 0);
if (rc) controller.has_pending = 0; if (rc) controller.has_pending = 0;
@@ -425,9 +548,10 @@ int main(int argc, char **argv)
engine_init(&engine); started = monotime(); next = started; engine_init(&engine); started = monotime(); next = started;
/* Touch all fixed working storage before allowing armed operation. */ /* Touch all fixed working storage before allowing armed operation. */
memset(processes, 0, sizeof (processes)); memset(zone_stats, 0, sizeof (zone_stats)); 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", 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), 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 (readyfd >= 0) {
if (write(readyfd, "R", 1) != 1) return 1; if (write(readyfd, "R", 1) != 1) return 1;
close(readyfd); 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_SWAP_PHYSICAL_USED], sample.at, 5),
history_delta(&metrics[METRIC_ANON_PAGEOUT], sample.at, 5)); history_delta(&metrics[METRIC_ANON_PAGEOUT], sample.at, 5));
if (engine.state != previous) 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); 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); act(&sample);
} else { } 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) { 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); int snapshot = sample.at - last_snapshot >= (sample.free < sample.lots ? 5 : 60);
scan_processes(snapshot); last_scan = sample.at; scan_processes(snapshot); last_scan = sample.at;
if (snapshot) last_snapshot = sample.at; if (snapshot) last_snapshot = sample.at;
if (sample.free < sample.lots && !engine.danger) (void)candidate(); 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; next += 1;


+ 6
- 0
tests/fixtures/pageout_deadman_real_incident_2026_09.csv Целия файл

@@ -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 Целия файл

@@ -43,7 +43,9 @@ static int parse(const char *text, config_t *c)
static void configs(void) static void configs(void)
{ {
config_t c; 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 dry-run\nprotect_process postgres\n", &c) == 0);
CHECK(parse("ACTION_MODE armd\n", &c) != 0); CHECK(parse("ACTION_MODE armd\n", &c) != 0);
CHECK(parse("ACTION_MODE armed\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("LOG_KEEP 0\n", &c) != 0);
CHECK(parse("TERM_GRACE_SECONDS -1\n", &c) != 0); CHECK(parse("TERM_GRACE_SECONDS -1\n", &c) != 0);
CHECK(parse("TERM_GRACE_SECONDS 1 garbage\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("UNKNOWN foo\n", &c) != 0);
CHECK(parse("PRE_SECONDS 20\nPRESSURE_SECONDS 10\n", &c) != 0); CHECK(parse("PRE_SECONDS 20\nPRESSURE_SECONDS 10\n", &c) != 0);
CHECK(parse("zone global global allow\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(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("11111111-1111-4111-8111-11111111111g"));
CHECK(!uuid_valid("00000000-0000-0000-0000-000000000000")); 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"); puts("PASS strict configuration, safe defaults, explicit UUID authorization");
} }
static void protections(void) static void protections(void)
@@ -116,21 +127,21 @@ static void states(void)
engine_init(&e); engine_init(&e);
for (i = 0; i < 10; i++) step(&e, &c, i, 425950, 0); for (i = 0; i < 10; i++) step(&e, &c, i, 425950, 0);
CHECK(e.state == NORMAL && !e.danger); 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); CHECK(e.state == PRESSURE && !e.danger);
step(&e, &c, 21, 60000, 1); step(&e, &c, 22, 59000, 1); step(&e, &c, 21, 60000, 1); step(&e, &c, 22, 59000, 1);
CHECK(!e.danger); CHECK(!e.danger);
step(&e, &c, 23, 58000, 1); CHECK(e.state == CRITICAL && 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); 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); CHECK(e.state == NORMAL);
step(&e, &c, 57, 40000, 0); CHECK(e.state == EMERGENCY && e.danger && !e.floor); 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, 58, 20000, 0); CHECK(e.floor);
step(&e, &c, 59, 70000, 0); CHECK(e.state == RECOVERY && !e.danger);
engine_init(&e); engine_init(&e);
for (i = 0; i < 20; i++) step(&e, &c, i, 60000, 0); for (i = 0; i < 20; i++) step(&e, &c, i, 60000, 0);
CHECK(!e.danger); /* low but stable, no scanner */ 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"); 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) static void actions(void)
{ {
config_t c = allowed(); engine_t e; controller_t a = {0}; 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); plan = action_plan(&a, &c, &e, &s, &p); CHECK(plan.action == KILL);
action_commit(&a, &c, &s, &plan); action_commit(&a, &c, &s, &plan);
p.pid++; s.at++; 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; e.state = NORMAL; e.danger = 0; s.free = 160000;
(void)action_plan(&a, &c, &e, &s, &p); CHECK(a.nvictims == 0); (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; 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); plan = action_plan(&a, &c, &e, &s, &p); action_commit(&a, &c, &s, &plan);
s.free = 140000; e.danger = 0; e.state = RECOVERY; s.free = 140000; e.danger = 0; e.state = RECOVERY;
@@ -210,7 +251,7 @@ static void actions(void)
} }
int main(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); printf("PASS %u checks; no native backend linked, no signals sent\n", checks);
return 0; return 0;
} }

+ 47
- 7
tests/test_runtime.c Целия файл

@@ -6,8 +6,8 @@
static double fake_now = 100; static double fake_now = 100;
static sample_t fake_sample; static sample_t fake_sample;
static process_t fixtures[8]; 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) #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; } 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) int platform_walk(int (*fn)(const process_t *, void *), void *arg, unsigned budget)
{ {
unsigned j; (void)budget; unsigned j; (void)budget;
walk_requests++;
for (j = 0; j < nfixtures; j++) if (fn(&fixtures[j], arg)) return -1; for (j = 0; j < nfixtures; j++) if (fn(&fixtures[j], arg)) return -1;
return partial ? -1 : 0; return partial ? -1 : 0;
} }
int platform_signal(const config_t *c, const process_t *p, enum action action, int platform_signal(const config_t *c, const process_t *p, enum action action,
int real, uint64_t ceiling) int real, uint64_t ceiling)
{ {
unsigned j; int found = 0;
CHECK(action == TERM || action == KILL); CHECK(action == TERM || action == KILL);
CHECK(!protected_process(c, p)); 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++; } if (real) { CHECK(c->armed && fake_sample.free < ceiling); real_requests++; }
else validation_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. */ return 0; /* This test backend cannot send any signal. */
} }
static void reset(void) 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].uuid, "22222222-2222-4222-8222-222222222222");
strcpy(cfg.zones[1].alias, "web-b"); cfg.zones[1].policy = ALLOW; 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(processes, 0, sizeof (processes)); memset(zone_stats, 0, sizeof (zone_stats));
memset(candidate_cache, 0, sizeof (candidate_cache));
memset(metrics, 0, sizeof (metrics)); memset(metrics, 0, sizeof (metrics));
memset(&controller, 0, sizeof (controller)); memset(fixtures, 0, sizeof (fixtures)); memset(&controller, 0, sizeof (controller)); memset(fixtures, 0, sizeof (fixtures));
engine_init(&engine); engine.state = CRITICAL; engine.danger = 1; engine_init(&engine); engine.state = CRITICAL; engine.danger = 1;
stopping = 0; started = 0; log_ok = 1; log_bytes = 0; 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; memset(&fake_sample, 0, sizeof (fake_sample)); fake_sample.at = fake_now;
fake_sample.free = 60000; fake_sample.lots = 130875; fake_sample.free = 60000; fake_sample.lots = 130875;
fake_sample.des = 65437; fake_sample.min = 49077; 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); 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; 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; 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_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; 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_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(); cfg.armed = 1; stopping = 1; act(&fake_sample); CHECK(real_requests == 0);
reset(); fake_sample.free = 20000; act(&fake_sample); reset(); fake_sample.free = 20000; act(&fake_sample);
CHECK(!controller.has_pending && controller.nvictims == 1); CHECK(!controller.has_pending && controller.nvictims == 1);
@@ -127,6 +134,39 @@ int main(void)
chosen = candidate(); CHECK(chosen && chosen->pid == 124); chosen = candidate(); CHECK(chosen && chosen->pid == 124);
fixtures[1].zid = 0; fake_now = 163; scan_processes(0); CHECK(candidate() == NULL); 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"); 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); fclose(log);
printf("PASS %u runtime checks; all platform calls mocked, no signals sent\n", checks); printf("PASS %u runtime checks; all platform calls mocked, no signals sent\n", checks);
return 0; return 0;


Loading…
Отказ
Запис