diff --git a/CHANGELOG.md b/CHANGELOG.md index 6441b7c..2c2fabc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,29 @@ # Changelog +## 1.0.3 — 2026-09-21 + +- Endurecida la detección tras un panic real: PRE-PRESSURE tras dos muestras y + PRESSURE a los dos segundos bajo `lotsfree`, sin esperar a `nscan`. +- Añadida caché persistente top‑3 con identidad completa, alias, RSS, + d5/d15/d60 y ranking. Sólo un scan completo reemplaza la caché anterior. +- Eliminada la dependencia de un recorrido `/proc` en + CRITICAL/EMERGENCY/FLOOR. La decisión usa selección O(1), revalidación del + proceso concreto y fallback ante desaparición o reutilización de PID. +- Separadas las gracias configurables de CRITICAL (5 s), EMERGENCY (1 s) y + floor (0 s por defecto). +- Rediseñado el presupuesto a límites jerárquicos 4/8/12, con overrides + explícitos de emergencia/floor y límite absoluto; todas las protecciones UUID + permanecen obligatorias. +- RECOVERY comienza al recuperar `desfree`; NORMAL exige 15 s por encima de + `lotsfree` con scanner inactivo. Se cancela la escalada pendiente al recuperar. +- Añadidos `state_transition`, `candidate_cache`, `action_decision` y + `recovery_check`, con edad/origen/rank del candidato y override de presupuesto. +- Añadido el fixture real `pageout_deadman_real_incident_2026_09` y pruebas de + scan incompleto, acción sin walk, fallback, PID reuse, presupuesto e histéresis. +- Añadido `INCIDENT_PAGEOUT_DEADMAN_2026_09.md`. +- Conservados dry-run, `--force-dry-run`, SMF deshabilitado, cero UUID `allow` + y entrega source-only. No hubo despliegue ni señales reales. + ## 1.0.2 — 2026-09-18 - Revisión exclusivamente documental del paquete: añadido `CHECKPOINT.md` con diff --git a/INCIDENT_PAGEOUT_DEADMAN_2026_09.md b/INCIDENT_PAGEOUT_DEADMAN_2026_09.md new file mode 100644 index 0000000..682a1ac --- /dev/null +++ b/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**. diff --git a/Makefile b/Makefile index b6c1b57..d14e572 100644 --- a/Makefile +++ b/Makefile @@ -15,7 +15,7 @@ native-check: o6h-memory-guard: $(SOURCES) src/guard.h | native-check $(CC) $(CPPFLAGS) $(CFLAGS) $(LDFLAGS) -o $@ $(SOURCES) $(LDLIBS) -test-guard: tests/test_guard.c src/core.c src/config.c src/guard.h +test-guard: tests/test_guard.c tests/fixtures/pageout_deadman_real_incident_2026_09.csv src/core.c src/config.c src/guard.h $(CC) $(TESTFLAGS) -o $@ tests/test_guard.c src/core.c src/config.c test-runtime: tests/test_runtime.c src/main.c src/core.c src/config.c src/guard.h diff --git a/README.md b/README.md index 8de960e..8db257d 100644 --- a/README.md +++ b/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, /proc, identidad UUID + generación de zona + PID + instante de creación, @@ -17,6 +17,8 @@ No se ha desplegado ni se han enviado señales reales durante la preparación. - `CHECKPOINT.md`: checkpoint operativo posterior, incorporado sin cambios, con la evidencia acumulada de compilación, ejecución y logging de v1.0.2 en SmartOS real, además del estado exacto y los requisitos antes de `armed`. +- `INCIDENT_PAGEOUT_DEADMAN_2026_09.md`: cronología del panic real observado + con v1.0.2 y justificación del endurecimiento de v1.0.3. - `CHANGELOG.md`: evolución de versiones y revisión documental del paquete. El checkpoint es cronológicamente posterior a `VALIDATION.md`; por ello amplía @@ -30,12 +32,12 @@ Si no hay herramientas de desarrollo, compilar en una **zona nativa SmartOS** de la misma plataforma (no LX), ejecutar allí `gmake test`, y copiar el binario junto a este árbol al host. No instalar un compilador en un nodo bajo presión. -Copiar el archivo distribuido a `/var/tmp/o6h-memory-guard-1.0.2.tar.gz`: +Copiar el archivo distribuido a `/var/tmp/o6h-memory-guard-1.0.3.tar.gz`: ```sh mkdir -p /opt/custom/src cd /opt/custom/src -gzip -dc /var/tmp/o6h-memory-guard-1.0.2.tar.gz | tar -xf - +gzip -dc /var/tmp/o6h-memory-guard-1.0.3.tar.gz | tar -xf - cd /opt/custom/src/o6h-memory-guard gmake CC=gcc gmake test CC=gcc @@ -158,35 +160,38 @@ una prueba de que un proceso concreto causó la presión. | Estado/condición de entrada | Comportamiento predeterminado | | --- | --- | | NORMAL | Sin intervención; muestreo VM de 1 s. | -| PRE-PRESSURE | `free < lotsfree` continuo durante 3 s; atribución de 1 s. | -| PRESSURE | Bajo `lotsfree` durante 10 s y scanner activo o libre descendiendo. | -| CRITICAL | Bajo `desfree` con presión corroborada continua durante 2 s; TERM. | -| EMERGENCY | `free < minfree`; entrada en la misma muestra, sin confirmación. TERM a nuevo candidato; KILL tras 1 s al pendiente. | -| Floor | `free < minfree/2`; KILL directo o escalada inmediata al pendiente. | -| RECOVERY | Al recuperar `lotsfree` se cancela la escalada. NORMAL requiere 15 s con `free >= lotsfree*1.10` y `nscan=0`. | - -La presión se corrobora con `nscan > 0`, caída respecto a la muestra anterior o -delta libre de 5 s negativo. Además, bajo `lotsfree`, el crecimiento simultáneo +| PRE-PRESSURE | Dos muestras bajo `lotsfree` (1 s por defecto); refresca candidatos, sin señales. | +| PRESSURE | Bajo `lotsfree` durante 2 s, o caída rápida corroborada; no exige que `nscan` haya arrancado. Refresca candidatos cada segundo. | +| CRITICAL | Bajo `desfree` con presión corroborada continua durante 2 s; usa caché, sin scan nuevo, y propone TERM. | +| EMERGENCY | `free <= minfree`; entrada inmediata. Usa caché y gracia TERM de 1 s. | +| Floor | `free <= minfree/2`; KILL directo por defecto (`FLOOR_KILL_DELAY_SECONDS=0`). | +| RECOVERY | Desde CRITICAL/EMERGENCY al recuperar `desfree`; NORMAL sólo tras 15 s estables con `free >= lotsfree` y `nscan=0`. | + +La entrada temprana a PRESSURE depende de persistencia bajo `lotsfree` o caída +clara y no espera a que el scanner arranque. `nscan > 0`, caída respecto a la +muestra anterior y delta libre negativo siguen corroborando gravedad. Bajo +`lotsfree`, el crecimiento simultáneo en 5 s de `swap_physical_used_bytes` y `anon_pageout_pages` corrobora presión. La ocupación física jamás es un trigger único: sin pageout creciente y memoria bajo `lotsfree` no cambia el estado. El compromiso virtual tampoco se interpreta como pageout. Los tiempos son segundos monotónicos transcurridos, no número de filas leídas. Un hueco de más de 2,5 s reinicia las confirmaciones. La gravedad se retiene -hasta recuperación; `action_pressure` indica si **la condición actual** permite -actuar. Por eso un estado retenido CRITICAL no autoriza una señal por sí solo. - -TERM tiene 5 s de gracia en CRITICAL. Sólo se escala si la condición crítica -sigue confirmada y la lectura fresca sigue bajo `desfree`. Por encima de -`desfree` se suspenden señales; alcanzar `lotsfree` cancela el pendiente. Tras -KILL se puede elegir otro candidato si sigue la presión. EMERGENCY evita la -espera normal entre víctimas de 10 s. Se mantiene como máximo una decisión de -señal por tick; un pendiente desaparecido puede sustituirse en ese mismo tick. - -Hay un máximo predeterminado de 4 víctimas por episodio y 4 por ventana móvil -de 60 s, tanto en simulación como en armed. TERM+KILL del mismo proceso cuentan -como una víctima. El presupuesto del episodio sólo se reinicia al volver a -NORMAL; el de 60 s sobrevive a ese cambio. En armed, un arranque o reinicio tiene +hasta recuperar `desfree`; `action_pressure` indica si el estado retenido aún +permite una decisión de rescate. + +Las gracias son configurables: 5 s en CRITICAL, 1 s en EMERGENCY y 0 s al floor +por defecto. Una lectura kstat fresca debe seguir bajo `desfree`. Recuperar +`desfree` cancela cualquier TERM pendiente y entra en RECOVERY. Se mantiene como +máximo una decisión de señal por tick; si una identidad desaparece o reutiliza +el PID se prueba el siguiente candidato cacheado sin recorrer `/proc` completo. + +En NORMAL/PRESSURE/CRITICAL rigen 4 víctimas por episodio y 4 por ventana móvil +de 60 s. EMERGENCY puede superar esos límites normales hasta 8 víctimas por +episodio; floor tiene un límite absoluto de 12. Cada override se registra como +`victim_budget_override=emergency|floor`. TERM+KILL del mismo proceso cuentan +como una víctima. Los límites 4/8/12 son configurables pero deben mantener ese +orden. El episodio sólo se reinicia al volver a NORMAL. En armed, un reinicio tiene 60 s de inhibición obligatoria de señales (también en EMERGENCY), para evitar eludir el límite por minuto mediante reinicios repetidos. Los contadores son en memoria; el presupuesto por episodio sí se reinicia al reiniciar el daemon. @@ -199,7 +204,10 @@ Se suma RSS por UUID/generación de zona y se puntúa como `RSS + 2*max(crecimiento,0)`, usando preferentemente 60 s, después 15 s y 5 s. Se elige la zona elegible con mayor puntuación y dentro de ella el proceso elegible con mayor puntuación. Sin historia se usa RSS. Empates conservan el -primer candidato encontrado. **La suma de RSS puede contar memoria compartida +primer candidato encontrado. Cada scan completo conserva en memoria los tres +mejores procesos, con identidad, alias, RSS, d5/d15/d60 y puntuaciones. El orden +es lexicográfico: puntuación de zona y luego de proceso, preservando la política +anterior. **La suma de RSS puede contar memoria compartida varias veces**: es una aproximación de atribución, no memoria física exclusiva ni memoria garantizada que se recuperará al terminar un proceso. @@ -249,12 +257,14 @@ el daemon. libkstat/libc sí pueden reservar memoria internamente al actualizar su cadena. No se promete cero asignaciones ni tiempo real estricto. El recorrido /proc tiene presupuesto cooperativo de 200 ms (hasta 500 ms por -configuración). Si faltan permisos, se excede capacidad/plazo o hay errores, -el scan se marca incompleto y bloquea acciones. La desaparición normal de un -proceso no se trata como fallo total. Se usa caché completa de como máximo 2 s -en emergencias y siempre se revalida. Si no hay caché válida se intenta el -recorrido antes de actuar. Una llamada del kernel bloqueada puede exceder el -presupuesto; no es un límite duro. Los overruns quedan registrados. +configuración). Un scan incompleto queda registrado pero no sustituye la última +caché completa. NORMAL actualiza cada 5 s; PRE-PRESSURE/PRESSURE, cada segundo. +CRITICAL/EMERGENCY/FLOOR no ejecutan scans completos: su ruta es lectura kstat, +selección O(1) entre tres entradas, validación barata de identidad y decisión. +La edad máxima predeterminada es 15 s. Si la caché es vieja o no tiene candidato +válido, la acción se bloquea de forma segura; no se intenta descubrir uno bajo +presión extrema. Una llamada del kernel durante un scan previo todavía puede +exceder el presupuesto; queda registrada como overrun sin borrar la buena caché. Muestras obligatorias ausentes/invalidas o demasiado lentas inhiben señales; ARC/swap/pageout opcionales ausentes se marcan con `*_ok=0` y no bloquean por sí @@ -295,10 +305,15 @@ Las muestras de 1 s posteriores a las acciones permiten revisar la recuperación en 1/2/5/10 s, siempre que no haya overruns. No se registran argumentos de procesos. `logs/policy-tests.log` y `logs/runtime-tests.log` proceden de pruebas locales; no son datos del nodo. `logs/example.log` es un ejemplo sintético de formato. +Los eventos nuevos `state_transition`, `candidate_cache`, `action_decision` y +`recovery_check` permiten reconstruir el estado, origen/rank/edad del candidato, +resultado del último scan y cualquier override de presupuesto. -## Preparación de armed (no ejecutar durante la evaluación inicial) +## Preparación de armed (NO GO para v1.0.3 inicial) -Se necesitan deliberadamente dos cambios: `ACTION_MODE armed` en la config y +v1.0.3 debe compilarse y observarse primero en SmartOS exclusivamente en +`dry-run`; el incidente real aún no autoriza señales. En una fase futura se +necesitarían deliberadamente dos cambios: `ACTION_MODE armed` en la config y retirar `--force-dry-run` del método start del manifiesto. Mantener las reglas UUID `allow` mínimas y verificar antes las protecciones y el laboratorio nativo. Después de esos cambios, validar config/manifiesto, importar, refrescar y @@ -335,7 +350,12 @@ una instancia viva. Restaurar el manifiesto e importarlo permite reinstalar SMF. Para actualizar: deshabilitar primero, conservar copias del binario, config y manifiesto en un directorio de backup nuevo, reemplazar el binario estando parado y validar los tres archivos. No reemplazar automáticamente la config ni perder -las protecciones. El instalador inicial se niega a hacerlo por ese motivo. +las protecciones. Al migrar desde v1.0.2 es obligatorio fusionar explícitamente +`PRE_SECONDS=1`, `PRESSURE_SECONDS=2`, las tres nuevas gracias, +`MAX_CACHED_CANDIDATE_AGE_SECONDS` y los límites 8/12 del fichero distribuido; +conservar 3/10 mantendría la detección lenta anterior. Validar con +`--check-config --force-dry-run` antes de reiniciar. El instalador inicial se +niega a sobrescribir por ese motivo. ## Referencias revisadas diff --git a/SHA256SUMS b/SHA256SUMS index ac7381d..c00fab5 100644 --- a/SHA256SUMS +++ b/SHA256SUMS @@ -1,27 +1,29 @@ 887569535302f7deba4d7c6ffb2103f1fb90bd96a40280240ff238eddc2e3a6f ./.gitignore -45e39d4bc8c8e3ef59e99167ef87fcc2864c0307693eeb5cb03664a0f6a7a722 ./CHANGELOG.md +8b1e0498bf3b9ccf3a36a4cc1ed0de7573612da2ef27be19e5496287679509f5 ./CHANGELOG.md ebfca7d4b5eaf0c0cc9910cf49d8c85f6aa7ff69972d7f21d17e61d1a2e23bc2 ./CHECKPOINT.md -ff7a0c102a9ce90b0eab3ec3e4f9fc6c37a186e2852c740a5a3433e605da750b ./Makefile -8bd0f7d52b9cfbba4c8b5076bbe58f790982a6adf6b594f9cdbf717984ff6c70 ./README.md -cf519f00a0eb382faf214bf050009fd6391887d1bf4c78e901ff466108f0cdfc ./VALIDATION.md -e5f98d46a5908f640709c262f9c64ceffbad825ac413059e8b3c7aa4358afc90 ./etc/o6h-memory-guard.conf +7b96d41da2877a771058ad0b184137ca5a7b5bcf26ddf77145ed067a87e0ce33 ./INCIDENT_PAGEOUT_DEADMAN_2026_09.md +ab718d07e0bab3a4e22b840991fb4586bb8e70e5e04d9bd411d2221f44ef7e0d ./Makefile +edb3d79db79e7ca98c2bc94100835833bfdda37cde917a8b5604344628bac120 ./README.md +290aa8a15ed211e4672b54549a9a7678c2b65ce42dee5a75a3f046f0bb51df31 ./VALIDATION.md +07722b81f7905e3c48f607e55e2aa3eb8498eacfb40e7aff073fc96e98717c8f ./etc/o6h-memory-guard.conf f6565d0e1ece0a08721c9893f9ed071d2ab0a2818fa93ed0a14e0050d358ce99 ./install.sh -059e1842336384e9364e763a998ca7a18ad8f330dab0f7c46cc4cf1664f0cc50 ./logs/example.log -77f710beb230b7f0285cf071dd8e59cef204f1d87aafec0ed36249f182e2481d ./logs/policy-tests.log +e2430c24466b2c82d5f20b46bc89ce77917d4c50dba6e5d69878c42ff55ca531 ./logs/example.log +b7d6826f353765641a95025344c30e6f5eb228772f29e04399a9ec78e3fb5595 ./logs/policy-tests.log abafc237427b63f38f81d0d1b76ba64eefc64d9f8074fdaa6ed0f1573b5d0a3b ./logs/portability.log -b1b51e63d266d70eabde686d904451640c1088d44d36412bb6bcc756d7b82928 ./logs/runtime-tests.log -7be49939ef5450c0f3a2be609c2a63c67dc4f90e1f2294b74d5b17d549a54e37 ./logs/sanitizers.log +2b617f4070b8ec155f2a7c1ee6048c99cd7c96b6dbbd26b60ebab0c1d3b13c22 ./logs/runtime-tests.log +2e09451d28c59911c1d74ff6195fab0506eb2fc26cb99e5be79e65c47e75668a ./logs/sanitizers.log b55afd45a72947efdda79d593255c36def9679bcb7a33ab14d55170ebaf9bef7 ./smf/o6h-memory-guard.xml -ada10059e26d94d796218108c031f7591d6e346d931da304643a74dd934b6656 ./src/config.c -f3b5bc0404a00f38bf2ae60a6aa924a9bc7ba080e1e9a9e72b2ae49d53835d41 ./src/core.c -5c741525f6b7ea7771adacb8aa40ca1a1eefbaba0f2c37f2eda53a7cf9a11402 ./src/guard.h +9a4468d9acc3f1da078b009f764c7cb7bf337682d6584b8cbaf7b540c520d5f5 ./src/config.c +c1f81909ec63fdb85948bbe58642478a80105b26a7c64eaf463c0e6fc42de203 ./src/core.c +0b9867e7ae7d1fcb2aab75f94d770471bd21f17c9f1eaf3c0f7c44eeb83e485b ./src/guard.h 32ab75bb6a1ff2bbbeb6a1ea658abcb96a03fcc06246f38d019faec7fdc184b8 ./src/illumos.c -2a9c54014272a78060b73b1863606e87e643cd27359bb77e12b8224b45baf18a ./src/main.c +066473572d8d2d8ca354ab3e718d3ccce618f8cfbb96992d008da3e9592b8815 ./src/main.c 2cb2b4c50fd42051fde4a702e8955e07d63979d5e3216e02420ed9b54fb67578 ./src/support.c f754e71d91d65403ab8e84e9701cfbb89bdd91e13766e668445e689e6890b369 ./tests/api-sketch/kstat.h f0d06353d2e326c7bdce776bee6f0a8606cda50d5de957dfdd586b6848fca8da ./tests/api-sketch/procfs.h 1c4fcb7bc48ec0a2774b1ecd73346dd45feb969a9250eb7056809d5d11ad40fe ./tests/api-sketch/sys/swap.h 340600b282a0c813323c1a09d5d6635ed4c56aa49a6d04132636851c8e714170 ./tests/api-sketch/vm/anon.h 9b99e272008ad00ad0abb366e1e8720dd6c51fc050821c5d1d878eae5719c22b ./tests/api-sketch/zone.h -af6e89c7058394a67f24e8cd7c5ab3e106bfa36c564901af001b7e781ea15ba6 ./tests/test_guard.c -217001c36c4e878ad365f127a12d03f714476d6ff32580407f8f0522fe564d83 ./tests/test_runtime.c +c5d9d7fc7a39354474d30cd316ea9f122205c2b38e57f927f4a08306b8a62c81 ./tests/fixtures/pageout_deadman_real_incident_2026_09.csv +b7ac53f6b26b4e7e2e19d7258b570a64462182ffe85c93374856caf77ec0c871 ./tests/test_guard.c +017b0a8dd3f9444fe63e4f8a6b3c12bf9ac98c25078223900a5672b6afdd11ec ./tests/test_runtime.c diff --git a/VALIDATION.md b/VALIDATION.md index f92ab8e..6cddf80 100644 --- a/VALIDATION.md +++ b/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 1. Compilar con cabeceras nativas (`gmake CC=gcc`), ejecutar `gmake test CC=gcc` - y comprobar ELF de 64 bits y dependencias con `file`/`ldd`. -2. Ejecutar `svccfg validate` nativo. Instalar/importar sólo siguiendo el - procedimiento del README y mantener `--force-dry-run`; no añadir UUID `allow`. -3. Repetir `--probe --force-dry-run` y contrastar las tres fuentes con `swap -s`, - `swap -l` y `kstat cpu::vm:anonpgout`. -4. Bajo SMF, verificar en cada `event=sample`: - `swap_committed_ok/swap_committed_pages`, - `swap_physical_used_ok/swap_physical_used_bytes` y - `anon_pageout_ok/anon_pageout_pages`. Confirmar líneas `event=delta` con los - tres nombres exactos y ventanas 5/15/60; buscar y exigir cero apariciones de - `swap_used_pages`. -5. Confirmar cadencia, recorrido `/proc`, identidades de zona, lock, rotación y - recuperación del servicio durante carga natural. No generar presión artificial - en producción. -6. La ruta PCKILL sólo debe ensayarse posteriormente en un laboratorio nativo - desechable, con procesos y zonas expresamente creados para esa prueba. Esta - entrega no autoriza ni realiza esa fase. + y comprobar ELF de 64 bits y dependencias. +2. Ejecutar `--probe --force-dry-run` y contrastar la telemetría ya conocida. +3. Validar el manifiesto con `svccfg validate`, importar y ejecutar SMF sólo con + `--force-dry-run`. +4. Confirmar en carga natural `NORMAL → PRE-PRESSURE → PRESSURE` con varios + segundos de margen y presencia previa de `candidate_cache`. +5. Confirmar que un scan lento/incompleto no retrasa ni borra la decisión + cacheada; medir `candidate_age_ms` y latencia de `action_decision`. +6. Revisar manualmente todos los UUID y eventos `WOULD_ACTION` de varios + episodios. No provocar presión peligrosa en producción para obtenerlos. +7. Sólo en laboratorio desechable y en una fase posterior: probar PCKILL, + supervisores, cooldown, 4/8/12 y rollback. `armed` continúa siendo NO GO. ## Límites conocidos -La atribución por RSS es heurística y sobrecuenta memoria compartida. Una señal -puede no liberar memoria de inmediato y un supervisor puede recrear procesos. -El presupuesto `/proc` es cooperativo; libkstat, libc, ZFS y el logging pueden -bloquear. No hay `fsync` por muestra, por lo que un panic puede perder las últimas -líneas. Las protecciones y presupuestos prevalecen incluso al floor. Este guard -no constituye una garantía de evitar `pageout_deadman` ni un certificado para -activar acciones en producción. +La caché sólo contiene tres procesos y puede quedar sin candidato si todos +cambian o superan 15 s de edad. En ese caso el diseño falla cerrado y no recorre +todo `/proc` bajo emergencia. RSS sobrecuenta memoria compartida y una señal no +garantiza liberar páginas. Kstat, ZFS, libc, logging y la revalidación puntual +todavía pueden bloquear. No hay fsync por muestra. Este guard reduce una ventana +de riesgo; no garantiza evitar `pageout_deadman`. diff --git a/etc/o6h-memory-guard.conf b/etc/o6h-memory-guard.conf index 9d6dccd..a6d124f 100644 --- a/etc/o6h-memory-guard.conf +++ b/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. ACTION_MODE dry-run -PRE_SECONDS 3 -PRESSURE_SECONDS 10 +PRE_SECONDS 1 +PRESSURE_SECONDS 2 CRITICAL_SECONDS 2 RECOVERY_SECONDS 15 -TERM_GRACE_SECONDS 5 +CRITICAL_TERM_GRACE_SECONDS 5 +EMERGENCY_TERM_GRACE_SECONDS 1 +FLOOR_KILL_DELAY_SECONDS 0 +MAX_CACHED_CANDIDATE_AGE_SECONDS 15 NORMAL_SCAN_SECONDS 5 SCAN_BUDGET_MS 200 COOLDOWN_SECONDS 10 MAX_VICTIMS_EPISODE 4 MAX_VICTIMS_MINUTE 4 +MAX_EMERGENCY_VICTIMS_EPISODE 8 +MAX_FLOOR_VICTIMS_EPISODE 12 MIN_RSS_KIB 65536 LOG_MAX_MIB 10 LOG_KEEP 5 diff --git a/logs/example.log b/logs/example.log index 514c197..d4e45f2 100644 --- a/logs/example.log +++ b/logs/example.log @@ -1,10 +1,12 @@ # SYNTHETIC FORMAT EXAMPLE -- NOT HOST TELEMETRY. Fields abridged for readability. -2026-09-18T15:00:00Z mono=100.000 event=start version=1.0.2 pid=999 mode=dry-run page_bytes=4096 armed_warmup=60 +2026-09-21T15:00:00Z mono=100.000 event=start version=1.0.3 pid=999 mode=dry-run page_bytes=4096 armed_warmup=60 2026-09-18T15:00:01Z mono=101.000 event=sample state=NORMAL action_pressure=0 floor=0 free_pages=425950 lotsfree=130875 desfree=65437 minfree=49077 nscan=0 pp_kernel=2976170 pageslocked=3002379 arc_ok=1 arc_bytes=1073741824 swap_committed_ok=1 swap_committed_pages=7480128 swap_physical_used_ok=1 swap_physical_used_bytes=4143648768 anon_pageout_ok=1 anon_pageout_pages=1000 swap_alloc_pages=7000000 swap_reserved_pages=480128 swap_available_pages=6135486 2026-09-18T15:00:01Z mono=101.000 event=delta metric=swap_committed_pages d5=NA d15=NA d60=NA 2026-09-18T15:00:01Z mono=101.000 event=delta metric=swap_physical_used_bytes d5=NA d15=NA d60=NA 2026-09-18T15:00:01Z mono=101.000 event=delta metric=anon_pageout_pages d5=NA d15=NA d60=NA -2026-09-18T15:01:00Z mono=160.000 event=transition from=PRESSURE to=CRITICAL +2026-09-21T15:00:05Z mono=105.020 event=candidate_cache rank=1 UUID=11111111-1111-4111-8111-111111111111 alias=fixture-web zone_generation=20 pid=123 start=1000.000000123 comm=php-fpm rss_kib=1048576 d5_kib=+100000@5.00s d15_kib=NA d60_kib=NA age_ms=0 eligible=1 zone_score=2097152 process_score=1248576 +2026-09-21T15:01:00Z mono=160.000 event=state_transition from=PRESSURE to=CRITICAL free_pages=60000 lotsfree=130875 desfree=65437 minfree=49077 low_samples=12 2026-09-18T15:01:00Z mono=160.020 event=candidate UUID=11111111-1111-4111-8111-111111111111 alias=fixture-web zone_id=9 zone_generation=20 pid=123 start=1000.000000123 comm=php-fpm rss_kib=1048576 d5_kib=+100000@5.00s d15_kib=+200000@15.00s d60_kib=+500000@60.00s eligible=1 -2026-09-18T15:01:00Z mono=160.030 event=action WOULD_ACTION=SIGTERM reason=critical UUID=11111111-1111-4111-8111-111111111111 alias=fixture-web zone_generation=20 pid=123 start=1000.000000123 comm=php-fpm rss_kib=1048576 free_pages=60000 -2026-09-18T15:01:05Z mono=165.030 event=action WOULD_ACTION=SIGKILL reason=memory_not_recovered UUID=11111111-1111-4111-8111-111111111111 alias=fixture-web zone_generation=20 pid=123 start=1000.000000123 comm=php-fpm rss_kib=1048576 free_pages=57000 +2026-09-21T15:01:00Z mono=160.025 event=action_decision state=CRITICAL candidate_source=cached_candidate rank=1 scan_complete=1 candidate_age_ms=980.0 victim_budget_override=none pid=123 UUID=11111111-1111-4111-8111-111111111111 +2026-09-21T15:01:00Z mono=160.030 event=action WOULD_ACTION=SIGTERM reason=critical UUID=11111111-1111-4111-8111-111111111111 alias=fixture-web zone_generation=20 pid=123 start=1000.000000123 comm=php-fpm rss_kib=1048576 free_pages=60000 victim_budget_override=none +2026-09-21T15:01:05Z mono=165.030 event=action WOULD_ACTION=SIGKILL reason=memory_not_recovered UUID=11111111-1111-4111-8111-111111111111 alias=fixture-web zone_generation=20 pid=123 start=1000.000000123 comm=php-fpm rss_kib=1048576 free_pages=57000 victim_budget_override=none diff --git a/logs/policy-tests.log b/logs/policy-tests.log index 4cf1c8b..8112e15 100644 --- a/logs/policy-tests.log +++ b/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 timestamped 5/15/60s windows, missing data, signed growth, overflow PASS all six states, corroboration, hysteresis, recovery and sampling gaps +PASS pageout_deadman_real_incident_2026_09 exits NORMAL before minfree SIMULATED t=100 state=CRITICAL UUID=11111111-1111-4111-8111-111111111111 pid=123 WOULD_ACTION=SIGTERM SIMULATED t=105 state=CRITICAL pid=123 WOULD_ACTION=SIGKILL reason=memory_not_recovered SIMULATED state=EMERGENCY floor=1 WOULD_ACTION=SIGKILL reason=floor PASS TERM/KILL sequencing, emergency grace, floor, cooldown, budgets and no-action protections -PASS 113 checks; no native backend linked, no signals sent +PASS 138 checks; no native backend linked, no signals sent diff --git a/logs/runtime-tests.log b/logs/runtime-tests.log index c839228..cf4b640 100644 --- a/logs/runtime-tests.log +++ b/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 armed-path mock requests, warmup, stale cache, logging/sampling failures, stop and fresh floor PASS actual daemon ranking by zone/PID RSS and growth; protected zones and global zone excluded -PASS 50 runtime checks; all platform calls mocked, no signals sent +PASS incomplete scan preserves cache; emergency uses O(1) fallback without a new walk +PASS PID/start-time reuse rejects rank 1 and selects cached fallback +PASS 73 runtime checks; all platform calls mocked, no signals sent diff --git a/logs/sanitizers.log b/logs/sanitizers.log index b485042..f1d3090 100644 --- a/logs/sanitizers.log +++ b/logs/sanitizers.log @@ -1,5 +1,5 @@ ASAN_OPTIONS=detect_leaks=0 make test-sanitize GCC 11.4.0; AddressSanitizer + UndefinedBehaviorSanitizer -PASS test-sanitize-guard: 113 checks; no native backend linked, no signals sent -PASS test-sanitize-runtime: 50 checks; all platform calls mocked, no signals sent +PASS test-sanitize-guard: 138 checks; no native backend linked, no signals sent +PASS test-sanitize-runtime: 73 checks; all platform calls mocked, no signals sent LeakSanitizer was intentionally disabled because the supervised environment can reject ptrace; no leak-check result is claimed. diff --git a/src/config.c b/src/config.c index 9fbd7b8..e23ec92 100644 --- a/src/config.c +++ b/src/config.c @@ -7,10 +7,13 @@ void defaults(config_t *c) { memset(c, 0, sizeof (*c)); - c->pre_s = 3; c->pressure_s = 10; c->critical_s = 2; - c->recovery_s = 15; c->term_s = 5; c->normal_scan_s = 5; + c->pre_s = 1; c->pressure_s = 2; c->critical_s = 2; + c->recovery_s = 15; c->critical_term_s = 5; + c->emergency_term_s = 1; c->floor_kill_delay_s = 0; + c->max_cached_candidate_age_s = 15; c->normal_scan_s = 5; c->scan_budget_ms = 200; c->cooldown_s = 10; c->max_victims = 4; c->max_per_minute = 4; + c->max_emergency_victims = 8; c->max_floor_victims = 12; c->min_rss_kib = 65536; c->log_mib = 10; c->log_keep = 5; } @@ -129,7 +132,11 @@ int config_read(FILE *f, config_t *c, char *error, size_t cap) OPT("PRESSURE_SECONDS", pressure_s, 2, 120, 2) OPT("CRITICAL_SECONDS", critical_s, 1, 10, 3) OPT("RECOVERY_SECONDS", recovery_s, 5, 300, 4) - OPT("TERM_GRACE_SECONDS", term_s, 1, 30, 5) + if (!strcmp(key, "TERM_GRACE_SECONDS") || + !strcmp(key, "CRITICAL_TERM_GRACE_SECONDS")) { + if ((seen & (1u << 5)) || number(value, 1, 30, &n)) goto invalid; + seen |= 1u << 5; c->critical_term_s = n; continue; + } OPT("NORMAL_SCAN_SECONDS", normal_scan_s, 1, 5, 6) OPT("SCAN_BUDGET_MS", scan_budget_ms, 10, 500, 7) OPT("COOLDOWN_SECONDS", cooldown_s, 1, 120, 8) @@ -138,10 +145,17 @@ int config_read(FILE *f, config_t *c, char *error, size_t cap) OPT("MIN_RSS_KIB", min_rss_kib, 1024, 1073741824UL, 11) OPT("LOG_MAX_MIB", log_mib, 1, 100, 12) OPT("LOG_KEEP", log_keep, 1, 20, 13) + OPT("EMERGENCY_TERM_GRACE_SECONDS", emergency_term_s, 0, 10, 14) + OPT("FLOOR_KILL_DELAY_SECONDS", floor_kill_delay_s, 0, 5, 15) + OPT("MAX_CACHED_CANDIDATE_AGE_SECONDS", max_cached_candidate_age_s, 5, 60, 16) + OPT("MAX_EMERGENCY_VICTIMS_EPISODE", max_emergency_victims, 1, MAX_VICTIMS, 17) + OPT("MAX_FLOOR_VICTIMS_EPISODE", max_floor_victims, 1, MAX_VICTIMS, 18) #undef OPT goto invalid; } - if (ferror(f) || c->pressure_s < c->pre_s) goto invalid; + if (ferror(f) || c->pressure_s < c->pre_s || + c->max_emergency_victims < c->max_victims || + c->max_floor_victims < c->max_emergency_victims) goto invalid; if (c->armed) { size_t i; int allow = 0; for (i = 0; i < c->nzones; i++) allow |= c->zones[i].policy == ALLOW; diff --git a/src/core.c b/src/core.c index cc655f6..8b3ec0f 100644 --- a/src/core.c +++ b/src/core.c @@ -64,52 +64,59 @@ void engine_init(engine_t *e) void engine_gap(engine_t *e) { e->low_since = e->critical_since = e->recovery_since = -1; - e->have_last = 0; e->danger = 0; e->floor = 0; + e->low_samples = 0; e->have_last = 0; e->danger = 0; e->floor = 0; } void engine_step(engine_t *e, const config_t *c, const sample_t *s, delta_t free_d5, delta_t physical_swap_d5, delta_t pageout_d5) { - int stress; + int stress, falling, rapid_fall; enum state desired = NORMAL; if (e->have_last && (s->at - e->last_at > 2.5 || s->at <= e->last_at)) engine_gap(e); + falling = (free_d5.valid && free_d5.value < 0) || + (e->have_last && s->free < e->last_free); + rapid_fall = e->have_last && e->last_free > s->free && + e->last_free - s->free >= s->lots / 10; /* Physical swap growth is corroboration only, never an independent trigger. */ - stress = s->scan > 0 || (free_d5.valid && free_d5.value < 0) || - (e->have_last && s->free < e->last_free) || + stress = s->scan > 0 || falling || (physical_swap_d5.valid && physical_swap_d5.value > 0 && pageout_d5.valid && pageout_d5.value > 0 && s->free < s->lots); - e->floor = s->free < s->min / 2; + e->floor = s->free <= s->min / 2; if (s->free < s->lots) { - if (e->low_since < 0) e->low_since = s->at; - } else e->low_since = -1; + if (e->low_since < 0) { e->low_since = s->at; e->low_samples = 1; } + else if (e->low_samples < UINT_MAX) e->low_samples++; + } else { e->low_since = -1; e->low_samples = 0; } if (s->free < s->des && stress) { if (e->critical_since < 0) e->critical_since = s->at; } else e->critical_since = -1; - if (e->low_since >= 0 && s->at - e->low_since >= c->pre_s) + if (e->low_since >= 0 && e->low_samples >= 2 && + s->at - e->low_since >= c->pre_s) desired = PRE_PRESSURE; - if (e->low_since >= 0 && s->at - e->low_since >= c->pressure_s && stress) + if (e->low_since >= 0 && (s->at - e->low_since >= c->pressure_s || + (e->low_samples >= 3 && rapid_fall))) desired = PRESSURE; if (e->critical_since >= 0 && s->at - e->critical_since >= c->critical_s) desired = CRITICAL; - if (s->free < s->min) desired = EMERGENCY; - e->danger = desired == CRITICAL || desired == EMERGENCY; - /* State hysteresis never authorizes an action on its own. */ + if (s->free <= s->min) desired = EMERGENCY; if (desired >= PRE_PRESSURE && desired <= EMERGENCY) { e->recovery_since = -1; if (e->state == RECOVERY || desired > e->state) e->state = desired; } - if (s->free >= s->lots && e->state != NORMAL) { + /* A prior critical episode is not recovered until at least desfree. */ + if ((e->state == CRITICAL || e->state == EMERGENCY) && s->free >= s->des && + desired < CRITICAL) { + e->state = RECOVERY; e->recovery_since = -1; + } else if (s->free >= s->lots && e->state != NORMAL) { e->state = RECOVERY; - /* 10% exit margin, and no active scanner, for a full recovery. */ - if (s->free - s->lots >= s->lots / 10 && s->scan == 0) { + } + if (e->state == RECOVERY) { + if (s->free >= s->lots && s->scan == 0) { if (e->recovery_since < 0) e->recovery_since = s->at; if (s->at - e->recovery_since >= c->recovery_s) e->state = NORMAL; } else e->recovery_since = -1; - } else if (s->free < s->lots) { - e->recovery_since = -1; - if (e->state == RECOVERY) e->state = PRE_PRESSURE; } + e->danger = e->state == CRITICAL || e->state == EMERGENCY; e->last_at = s->at; e->last_free = s->free; e->have_last = 1; } @@ -134,22 +141,37 @@ plan_t action_plan(controller_t *a, const config_t *c, const engine_t *e, plan_t p; unsigned i, n = 0; memset(&p, 0, sizeof (p)); p.reason = "no_pressure"; + p.budget_override = "none"; for (i = 0; i < a->nrate; i++) if (s->at - a->rate[i] < 60) a->rate[n++] = a->rate[i]; a->nrate = n; if (e->state == NORMAL) a->nvictims = 0; if (s->free >= s->lots) a->has_pending = 0; - if (!e->danger) return p; + if (!e->danger) { a->has_pending = 0; return p; } if (a->has_pending) { + unsigned grace = c->critical_term_s; p.reason = "term_grace"; - if (e->floor || (s->free < s->min && s->at - a->term_at >= 1) || - s->at - a->term_at >= c->term_s) { + if (e->floor) grace = c->floor_kill_delay_s; + else if (e->state == EMERGENCY) grace = c->emergency_term_s; + if (s->at - a->term_at >= grace) { p.target = a->pending; p.action = KILL; p.reason = e->floor ? "floor" : "memory_not_recovered"; } return p; } - if (a->nvictims >= c->max_victims || a->nrate >= c->max_per_minute) { + if (e->floor) { + if (a->nvictims >= c->max_floor_victims) { + p.reason = "absolute_victim_budget_exhausted"; return p; + } + if (a->nvictims >= c->max_victims || a->nrate >= c->max_per_minute) + p.budget_override = "floor"; + } else if (e->state == EMERGENCY) { + if (a->nvictims >= c->max_emergency_victims) { + p.reason = "emergency_victim_budget_exhausted"; return p; + } + if (a->nvictims >= c->max_victims || a->nrate >= c->max_per_minute) + p.budget_override = "emergency"; + } else if (a->nvictims >= c->max_victims || a->nrate >= c->max_per_minute) { p.reason = "victim_budget_exhausted"; return p; } /* Emergency bypasses the normal cooldown, not protection or budgets. */ @@ -160,7 +182,7 @@ plan_t action_plan(controller_t *a, const config_t *c, const engine_t *e, p.reason = "no_authorized_candidate"; return p; } p.target = *candidate; - p.action = e->floor ? KILL : TERM; + p.action = e->floor && c->floor_kill_delay_s == 0 ? KILL : TERM; p.reason = e->floor ? "floor" : s->free < s->min ? "minfree" : "critical"; return p; } diff --git a/src/guard.h b/src/guard.h index 684a3a2..dade764 100644 --- a/src/guard.h +++ b/src/guard.h @@ -13,7 +13,7 @@ #define CONF_PATH "/opt/custom/etc/o6h-memory-guard.conf" #define LOG_DIR "/opt/custom/var/log/o6h-memory-guard" #define RUN_DIR "/opt/custom/var/run" -#define VERSION "1.0.2" +#define VERSION "1.0.3" enum state { NORMAL, PRE_PRESSURE, PRESSURE, CRITICAL, EMERGENCY, RECOVERY }; enum policy { OBSERVE, ALLOW, PROTECT }; @@ -31,8 +31,10 @@ typedef struct { typedef struct { char uuid[37], alias[64]; enum policy policy; } zone_rule_t; typedef struct { int armed; - unsigned pre_s, pressure_s, critical_s, recovery_s, term_s; + unsigned pre_s, pressure_s, critical_s, recovery_s, critical_term_s; + unsigned emergency_term_s, floor_kill_delay_s, max_cached_candidate_age_s; unsigned normal_scan_s, scan_budget_ms, cooldown_s, max_victims; + unsigned max_emergency_victims, max_floor_victims; unsigned max_per_minute, log_mib, log_keep; uint64_t min_rss_kib; zone_rule_t zones[MAX_ZONES]; size_t nzones; @@ -50,6 +52,7 @@ typedef struct { enum state state; double low_since, critical_since, recovery_since, last_at; uint64_t last_free; + unsigned low_samples; int have_last, danger, floor; } engine_t; typedef struct { @@ -59,7 +62,12 @@ typedef struct { process_t victims[MAX_VICTIMS]; unsigned nvictims; double rate[64]; unsigned nrate; } controller_t; -typedef struct { enum action action; process_t target; const char *reason; } plan_t; +typedef struct { + enum action action; + process_t target; + const char *reason; + const char *budget_override; +} plan_t; void defaults(config_t *); int config_read(FILE *, config_t *, char *, size_t); diff --git a/src/main.c b/src/main.c index 3ad775e..cbdec3a 100644 --- a/src/main.c +++ b/src/main.c @@ -19,9 +19,20 @@ typedef struct { char uuid[64]; uint64_t generation, rss; history_t history; unsigned seen; double last; int best; } zone_t; +#define CACHED_CANDIDATES 3 +typedef struct { + process_t p; + delta_t d5, d15, d60; + uint64_t zone_score, process_score; + double scan_time; + unsigned rank; + int valid, eligible; + char alias[64]; +} cached_candidate_t; static config_t cfg; static tracked_t processes[MAX_PROCS]; static zone_t zone_stats[MAX_ZONES]; +static cached_candidate_t candidate_cache[CACHED_CANDIDATES]; enum metric_index { METRIC_FREE, METRIC_KERNEL, @@ -43,11 +54,12 @@ static const char *const metric_names[METRIC_COUNT] = { static engine_t engine; static controller_t controller; static unsigned scan_generation; -static double scan_at, started; +static double scan_at, latest_complete_scan_at, started; static int scan_complete; static int logfd = -1, log_ok = 1, lockfd = -1; static uint64_t log_bytes; static volatile sig_atomic_t stopping, reopen_log; +static void delta_text(char *, size_t, delta_t); static void handler(int sig) { @@ -158,6 +170,76 @@ static const char *alias_for(const char *uuid) return r ? r->alias : "unmapped"; } +static zone_t *zone_for_process(const process_t *p) +{ + unsigned i; + for (i = 0; i < MAX_ZONES; i++) + if (zone_stats[i].seen == scan_generation && + zone_stats[i].generation == p->zone_generation && + !strcmp(zone_stats[i].uuid, p->uuid)) return &zone_stats[i]; + return NULL; +} + +static int cache_better(const cached_candidate_t *a, const cached_candidate_t *b) +{ + if (!b->valid) return 1; + if (a->zone_score != b->zone_score) return a->zone_score > b->zone_score; + if (a->process_score != b->process_score) return a->process_score > b->process_score; + return a->p.pid < b->p.pid; +} + +static void rebuild_candidate_cache(void) +{ + cached_candidate_t next[CACHED_CANDIDATES]; + unsigned i, j; + memset(next, 0, sizeof (next)); + for (i = 0; i < MAX_PROCS; i++) { + cached_candidate_t entry; + tracked_t *t = &processes[i]; + zone_t *z; + delta_t zgrowth; + if (t->seen != scan_generation || !t->p.pid || + protected_process(&cfg, &t->p) || was_victim(&controller, &t->p)) continue; + z = zone_for_process(&t->p); + if (!z) continue; + memset(&entry, 0, sizeof (entry)); + entry.p = t->p; entry.d5 = history_delta(&t->rss, scan_at, 5); + entry.d15 = history_delta(&t->rss, scan_at, 15); + entry.d60 = history_delta(&t->rss, scan_at, 60); + zgrowth = growth(&z->history); + entry.zone_score = rank_score(z->rss, zgrowth); + entry.process_score = rank_score(t->p.rss_kib, growth(&t->rss)); + entry.scan_time = scan_at; entry.valid = entry.eligible = 1; + snprintf(entry.alias, sizeof (entry.alias), "%s", alias_for(t->p.uuid)); + for (j = 0; j < CACHED_CANDIDATES; j++) { + unsigned k; + if (!cache_better(&entry, &next[j])) continue; + for (k = CACHED_CANDIDATES - 1; k > j; k--) next[k] = next[k - 1]; + next[j] = entry; break; + } + } + memcpy(candidate_cache, next, sizeof (candidate_cache)); + latest_complete_scan_at = scan_at; + for (i = 0; i < CACHED_CANDIDATES && candidate_cache[i].valid; i++) { + char d5[64], d15[64], d60[64]; + candidate_cache[i].rank = i + 1; + delta_text(d5, sizeof (d5), candidate_cache[i].d5); + delta_text(d15, sizeof (d15), candidate_cache[i].d15); + delta_text(d60, sizeof (d60), candidate_cache[i].d60); + emit("event=candidate_cache rank=%u UUID=%s alias=%s zone_generation=%" PRIu64 + " pid=%d start=%" PRId64 ".%09" PRId64 " comm=%s rss_kib=%" PRIu64 + " d5_kib=%s d15_kib=%s d60_kib=%s age_ms=0 eligible=%d" + " zone_score=%" PRIu64 " process_score=%" PRIu64, + candidate_cache[i].rank, candidate_cache[i].p.uuid, + candidate_cache[i].alias, candidate_cache[i].p.zone_generation, + candidate_cache[i].p.pid, candidate_cache[i].p.start_sec, + candidate_cache[i].p.start_nsec, candidate_cache[i].p.name, + candidate_cache[i].p.rss_kib, d5, d15, d60, + candidate_cache[i].eligible, candidate_cache[i].zone_score, + candidate_cache[i].process_score); + } +} + static void delta_text(char *out, size_t n, delta_t d) { if (d.valid) snprintf(out, n, "%+" PRId64 "@%.2fs", d.value, d.age); @@ -185,8 +267,10 @@ static void scan_processes(int snapshot) scan_at = monotime(); scan_generation++; if (!scan_generation) scan_generation++; /* practically unreachable */ scan_complete = platform_walk(visit, NULL, cfg.scan_budget_ms) == 0; - emit("event=proc_scan complete=%d duration_ms=%.1f capacity=%d", scan_complete, - 1000 * (monotime() - scan_at), MAX_PROCS); + emit("event=proc_scan complete=%d duration_ms=%.1f capacity=%d" + " latest_complete_age_ms=%.1f", scan_complete, + 1000 * (monotime() - scan_at), MAX_PROCS, + latest_complete_scan_at > 0 ? 1000 * (scan_at - latest_complete_scan_at) : -1.0); for (i = 0; i < MAX_ZONES; i++) { zone_t *z = &zone_stats[i]; char d5[64], d15[64], d60[64]; @@ -201,6 +285,7 @@ static void scan_processes(int snapshot) " complete=%d d5_kib=%s d15_kib=%s d60_kib=%s", z->uuid, alias_for(z->uuid), z->generation, z->rss, scan_complete, d5, d15, d60); } + if (scan_complete) rebuild_candidate_cache(); if (!snapshot) return; for (i = 0; i < MAX_PROCS; i++) { if (processes[i].seen != scan_generation || !processes[i].p.pid) continue; @@ -216,18 +301,14 @@ static void scan_processes(int snapshot) static const process_t *candidate(void) { - unsigned i; zone_t *best = NULL; - if (!scan_complete || monotime() - scan_at > 2) return NULL; - for (i = 0; i < MAX_ZONES; i++) { - zone_t *z = &zone_stats[i]; - if (z->seen != scan_generation || z->best < 0) continue; - if (was_victim(&controller, &processes[z->best].p)) continue; - if (!best || rank_score(z->rss, growth(&z->history)) > rank_score(best->rss, growth(&best->history))) - best = z; + unsigned i; double now = monotime(); + for (i = 0; i < CACHED_CANDIDATES; i++) { + cached_candidate_t *entry = &candidate_cache[i]; + if (!entry->valid || now - entry->scan_time > cfg.max_cached_candidate_age_s || + protected_process(&cfg, &entry->p) || was_victim(&controller, &entry->p)) continue; + return &entry->p; } - if (!best) return NULL; - log_process("candidate", &processes[best->best]); - return &processes[best->best].p; + return NULL; } static int metric_valid(enum metric_index metric, const sample_t *s) @@ -286,50 +367,92 @@ static void act(sample_t *sample) plan_t plan; sample_t fresh; engine_t current_engine; - const process_t *p; - int err, rc; + const char *source = "pending", *blocked_reason = "no_valid_cached_candidate"; + double candidate_age = -1; + unsigned i, rank = 0; + int err, rc, validated = 0; if (stopping) return; if (!engine.danger) { (void)action_plan(&controller, &cfg, &engine, sample, NULL); return; } - if (!log_ok || !scan_complete) { - emit("event=action_blocked reason=log_or_incomplete_scan"); return; + if (!log_ok) { + emit("event=action_blocked reason=log_failure"); return; } if (cfg.armed && monotime() - started < 60) { emit("event=action_blocked reason=armed_startup_60s"); return; } - /* Refresh after /proc traversal and logging, before authorizing a signal. */ + /* O(1) critical path: kstat refresh + cached identity validation, no walk. */ if (platform_sample(&fresh) || monotime() - fresh.at > 2 || fresh.free >= fresh.des) { emit("event=action_blocked reason=refresh_failed_or_above_desfree"); return; } - p = candidate(); - current_engine = engine; current_engine.floor = fresh.free < fresh.min / 2; - plan = action_plan(&controller, &cfg, ¤t_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, ¤t_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, ¤t_engine, &fresh, &entry->p); + if (plan.action == NONE) { blocked_reason = plan.reason; break; } + if (platform_signal(&cfg, &plan.target, plan.action, 0, 0)) { + err = errno; entry->valid = 0; + emit("event=action_rejected reason=identity_or_protection" + " source=%s rank=%u pid=%d errno=%d", + i == 0 ? "cached_candidate" : "fallback_candidate", + i + 1, plan.target.pid, err); + continue; + } + rank = i + 1; + source = i == 0 ? "cached_candidate" : "fallback_candidate"; + validated = 1; break; + } + if (!validated) { + emit("event=action_blocked reason=%s state=%s scan_complete=%d" + " latest_complete_age_ms=%.1f", blocked_reason, + state_name(current_engine.state), scan_complete, + latest_complete_scan_at > 0 ? + 1000 * (fresh.at - latest_complete_scan_at) : -1.0); + return; } - return; } + emit("event=action_decision state=%s candidate_source=%s rank=%u" + " scan_complete=%d candidate_age_ms=%.1f victim_budget_override=%s" + " pid=%d UUID=%s", state_name(current_engine.state), source, rank, + scan_complete, candidate_age >= 0 ? 1000 * candidate_age : -1.0, + plan.budget_override, plan.target.pid, plan.target.uuid); if (emit("event=action %s=%s reason=%s UUID=%s alias=%s zone_generation=%" PRIu64 - " pid=%d start=%" PRId64 ".%09" PRId64 " comm=%s rss_kib=%" PRIu64 " free_pages=%" PRIu64, + " pid=%d start=%" PRId64 ".%09" PRId64 " comm=%s rss_kib=%" PRIu64 + " free_pages=%" PRIu64 " victim_budget_override=%s", cfg.armed ? "ACTION_INTENT" : "WOULD_ACTION", plan.action == TERM ? "SIGTERM" : "SIGKILL", plan.reason, plan.target.uuid, alias_for(plan.target.uuid), plan.target.zone_generation, plan.target.pid, plan.target.start_sec, plan.target.start_nsec, plan.target.name, - plan.target.rss_kib, fresh.free)) return; + plan.target.rss_kib, fresh.free, plan.budget_override)) return; /* Consume a budget slot even if the subsequent signal write is ambiguous. */ action_commit(&controller, &cfg, &fresh, &plan); if (cfg.armed && !stopping) { rc = platform_signal(&cfg, &plan.target, plan.action, 1, - !strcmp(plan.reason, "floor") ? fresh.min / 2 : fresh.des); err = errno; + !strcmp(plan.reason, "floor") ? fresh.min / 2 + 1 : fresh.des); err = errno; emit("event=action_result pid=%d signal=%s result=%s errno=%d", plan.target.pid, plan.action == TERM ? "SIGTERM" : "SIGKILL", rc ? "failed" : "sent", rc ? err : 0); if (rc) controller.has_pending = 0; @@ -425,9 +548,10 @@ int main(int argc, char **argv) engine_init(&engine); started = monotime(); next = started; /* Touch all fixed working storage before allowing armed operation. */ memset(processes, 0, sizeof (processes)); memset(zone_stats, 0, sizeof (zone_stats)); + memset(candidate_cache, 0, sizeof (candidate_cache)); if (emit("event=start version=%s pid=%ld mode=%s page_bytes=%ld fixed_storage_bytes=%zu armed_warmup=60", VERSION, (long)getpid(), cfg.armed ? "armed" : "dry-run", sysconf(_SC_PAGESIZE), - sizeof (processes) + sizeof (zone_stats))) return 1; + sizeof (processes) + sizeof (zone_stats) + sizeof (candidate_cache))) return 1; if (readyfd >= 0) { if (write(readyfd, "R", 1) != 1) return 1; close(readyfd); @@ -453,23 +577,32 @@ int main(int argc, char **argv) history_delta(&metrics[METRIC_SWAP_PHYSICAL_USED], sample.at, 5), history_delta(&metrics[METRIC_ANON_PAGEOUT], sample.at, 5)); if (engine.state != previous) - emit("event=transition from=%s to=%s", state_name(previous), state_name(engine.state)); + emit("event=state_transition from=%s to=%s free_pages=%" PRIu64 + " lotsfree=%" PRIu64 " desfree=%" PRIu64 " minfree=%" PRIu64 + " low_samples=%u", state_name(previous), state_name(engine.state), + sample.free, sample.lots, sample.des, sample.min, engine.low_samples); log_sample(&sample); - /* Use a recent complete cache first in emergencies. Revalidation is mandatory. */ - if (sample.free < sample.min && scan_complete && sample.at - scan_at <= 2) { + if (previous != RECOVERY && engine.state == RECOVERY) + emit("event=recovery_check free_pages=%" PRIu64 + " target=desfree target_pages=%" PRIu64 " reached=%d", + sample.free, sample.des, sample.free >= sample.des); + else if (engine.state == RECOVERY) + emit("event=recovery_check free_pages=%" PRIu64 + " target=lotsfree target_pages=%" PRIu64 " stable_seconds=%.1f", + sample.free, sample.lots, engine.recovery_since >= 0 ? + sample.at - engine.recovery_since : 0.0); + /* CRITICAL/EMERGENCY is O(1): never wait for a full /proc walk. */ + if (engine.danger) { act(&sample); } else { + /* Cancel pending escalation/reset episode budgets before rebuilding cache. */ + act(&sample); if (sample.free < sample.lots || sample.at - last_scan >= cfg.normal_scan_s) { int snapshot = sample.at - last_snapshot >= (sample.free < sample.lots ? 5 : 60); scan_processes(snapshot); last_scan = sample.at; if (snapshot) last_snapshot = sample.at; if (sample.free < sample.lots && !engine.danger) (void)candidate(); } - act(&sample); - } - /* Refresh cache even during an ongoing emergency. */ - if (sample.free < sample.min && sample.at - last_scan >= 0.9) { - scan_processes(0); last_scan = sample.at; } } next += 1; diff --git a/tests/fixtures/pageout_deadman_real_incident_2026_09.csv b/tests/fixtures/pageout_deadman_real_incident_2026_09.csv new file mode 100644 index 0000000..80ae951 --- /dev/null +++ b/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 diff --git a/tests/test_guard.c b/tests/test_guard.c index bbd07d0..bde9820 100644 --- a/tests/test_guard.c +++ b/tests/test_guard.c @@ -43,7 +43,9 @@ static int parse(const char *text, config_t *c) static void configs(void) { config_t c; - CHECK(parse("# defaults\n", &c) == 0 && !c.armed); + CHECK(parse("# defaults\n", &c) == 0 && !c.armed && c.pre_s == 1 && + c.pressure_s == 2 && c.max_cached_candidate_age_s == 15 && + c.max_emergency_victims == 8 && c.max_floor_victims == 12); CHECK(parse("ACTION_MODE dry-run\nprotect_process postgres\n", &c) == 0); CHECK(parse("ACTION_MODE armd\n", &c) != 0); CHECK(parse("ACTION_MODE armed\n", &c) != 0); @@ -51,6 +53,10 @@ static void configs(void) CHECK(parse("LOG_KEEP 0\n", &c) != 0); CHECK(parse("TERM_GRACE_SECONDS -1\n", &c) != 0); CHECK(parse("TERM_GRACE_SECONDS 1 garbage\n", &c) != 0); + CHECK(parse("CRITICAL_TERM_GRACE_SECONDS 4\nEMERGENCY_TERM_GRACE_SECONDS 1\n" + "FLOOR_KILL_DELAY_SECONDS 0\nMAX_CACHED_CANDIDATE_AGE_SECONDS 15\n", &c) == 0); + CHECK(parse("MAX_EMERGENCY_VICTIMS_EPISODE 3\n", &c) != 0); + CHECK(parse("MAX_FLOOR_VICTIMS_EPISODE 7\n", &c) != 0); CHECK(parse("UNKNOWN foo\n", &c) != 0); CHECK(parse("PRE_SECONDS 20\nPRESSURE_SECONDS 10\n", &c) != 0); CHECK(parse("zone global global allow\n", &c) != 0); @@ -58,6 +64,11 @@ static void configs(void) CHECK(parse("zone 11111111-1111-4111-8111-111111111111 web allow\nzone 11111111-1111-4111-8111-111111111111 db protect\n", &c) != 0); CHECK(!uuid_valid("11111111-1111-4111-8111-11111111111g")); CHECK(!uuid_valid("00000000-0000-0000-0000-000000000000")); + { + FILE *f = fopen("etc/o6h-memory-guard.conf", "r"); char error[128]; + CHECK(f != NULL); CHECK(config_read(f, &c, error, sizeof (error)) == 0); + fclose(f); CHECK(!c.armed && c.pre_s == 1 && c.pressure_s == 2); + } puts("PASS strict configuration, safe defaults, explicit UUID authorization"); } static void protections(void) @@ -116,21 +127,21 @@ static void states(void) engine_init(&e); for (i = 0; i < 10; i++) step(&e, &c, i, 425950, 0); CHECK(e.state == NORMAL && !e.danger); - for (i = 10; i <= 12; i++) step(&e, &c, i, 100000, 1); - CHECK(e.state == NORMAL); - step(&e, &c, 13, 100000, 1); CHECK(e.state == PRE_PRESSURE); - for (i = 14; i <= 20; i++) step(&e, &c, i, 100000, 1); + step(&e, &c, 10, 100000, 0); CHECK(e.state == NORMAL); + step(&e, &c, 11, 100000, 0); CHECK(e.state == PRE_PRESSURE); + step(&e, &c, 12, 100000, 0); CHECK(e.state == PRESSURE && !e.danger); step(&e, &c, 21, 60000, 1); step(&e, &c, 22, 59000, 1); CHECK(!e.danger); step(&e, &c, 23, 58000, 1); CHECK(e.state == CRITICAL && e.danger); step(&e, &c, 24, 140000, 0); CHECK(e.state == RECOVERY && !e.danger); - for (i = 25; i <= 40; i++) step(&e, &c, i, 140000, 0); - CHECK(e.state == RECOVERY); /* below 10% margin */ - for (i = 41; i <= 56; i++) step(&e, &c, i, 150000, 0); + for (i = 25; i <= 39; i++) step(&e, &c, i, 140000, 0); + CHECK(e.state == NORMAL); + for (i = 40; i <= 56; i++) step(&e, &c, i, 150000, 0); CHECK(e.state == NORMAL); step(&e, &c, 57, 40000, 0); CHECK(e.state == EMERGENCY && e.danger && !e.floor); step(&e, &c, 58, 20000, 0); CHECK(e.floor); + step(&e, &c, 59, 70000, 0); CHECK(e.state == RECOVERY && !e.danger); engine_init(&e); for (i = 0; i < 20; i++) step(&e, &c, i, 60000, 0); CHECK(!e.danger); /* low but stable, no scanner */ @@ -158,6 +169,23 @@ static void states(void) } puts("PASS all six states, corroboration, hysteresis, recovery and sampling gaps"); } +static void real_incident_fixture(void) +{ + config_t c = allowed(); engine_t e; FILE *f; + unsigned t, rows = 0; uint64_t free_pages, nscan; + char line[128]; + engine_init(&e); + f = fopen("tests/fixtures/pageout_deadman_real_incident_2026_09.csv", "r"); + CHECK(f != NULL); CHECK(fgets(line, sizeof (line), f) != NULL); + while (fscanf(f, "%u,%" SCNu64 ",%" SCNu64, &t, &free_pages, &nscan) == 3) { + step(&e, &c, t, free_pages, nscan); rows++; + if (t == 2) CHECK(e.state == PRE_PRESSURE); + if (t == 3) CHECK(e.state == PRESSURE); + } + fclose(f); + CHECK(rows == 5); CHECK(e.state == EMERGENCY && e.danger); + puts("PASS pageout_deadman_real_incident_2026_09 exits NORMAL before minfree"); +} static void actions(void) { config_t c = allowed(); engine_t e; controller_t a = {0}; @@ -188,12 +216,25 @@ static void actions(void) plan = action_plan(&a, &c, &e, &s, &p); CHECK(plan.action == KILL); action_commit(&a, &c, &s, &plan); p.pid++; s.at++; - CHECK(action_plan(&a, &c, &e, &s, &p).action == NONE); /* even at floor */ + plan = action_plan(&a, &c, &e, &s, &p); CHECK(plan.action == KILL); + CHECK(!strcmp(plan.budget_override, "floor")); e.state = NORMAL; e.danger = 0; s.free = 160000; (void)action_plan(&a, &c, &e, &s, &p); CHECK(a.nvictims == 0); - e.state = EMERGENCY; e.danger = 1; s.free = 20000; - CHECK(action_plan(&a, &c, &e, &s, &p).action == NONE); /* minute budget persists */ - s.at = 180; CHECK(action_plan(&a, &c, &e, &s, &p).action == KILL); + e.state = EMERGENCY; e.danger = 1; e.floor = 0; s.free = 40000; + a.nvictims = c.max_victims; a.nrate = c.max_per_minute; + e.state = CRITICAL; + CHECK(action_plan(&a, &c, &e, &s, &p).action == NONE); + e.state = EMERGENCY; + a.nvictims = c.max_victims; a.nrate = c.max_per_minute; + plan = action_plan(&a, &c, &e, &s, &p); CHECK(plan.action == TERM); + CHECK(!strcmp(plan.budget_override, "emergency")); + a.nvictims = c.max_emergency_victims; + CHECK(action_plan(&a, &c, &e, &s, &p).action == NONE); + e.floor = 1; s.free = 20000; + plan = action_plan(&a, &c, &e, &s, &p); CHECK(plan.action == KILL); + CHECK(!strcmp(plan.budget_override, "floor")); + a.nvictims = c.max_floor_victims; + CHECK(action_plan(&a, &c, &e, &s, &p).action == NONE); memset(&a, 0, sizeof (a)); e.floor = 0; e.state = CRITICAL; s.free = 60000; plan = action_plan(&a, &c, &e, &s, &p); action_commit(&a, &c, &s, &plan); s.free = 140000; e.danger = 0; e.state = RECOVERY; @@ -210,7 +251,7 @@ static void actions(void) } int main(void) { - configs(); protections(); histories(); states(); actions(); + configs(); protections(); histories(); states(); real_incident_fixture(); actions(); printf("PASS %u checks; no native backend linked, no signals sent\n", checks); return 0; } diff --git a/tests/test_runtime.c b/tests/test_runtime.c index c5e094d..09d6e6a 100644 --- a/tests/test_runtime.c +++ b/tests/test_runtime.c @@ -6,8 +6,8 @@ static double fake_now = 100; static sample_t fake_sample; static process_t fixtures[8]; -static unsigned nfixtures, real_requests, validation_requests, checks; -static int fail_validation, fail_sample, partial; +static unsigned nfixtures, real_requests, validation_requests, walk_requests, checks; +static int fail_validation, fail_sample, partial, invalid_pid; #define CHECK(x) do { if (!(x)) { fprintf(stderr, "FAIL runtime line %d: %s\n", __LINE__, #x); exit(1); } checks++; } while (0) double monotime(void) { return fake_now; } @@ -21,17 +21,21 @@ int platform_sample(sample_t *s) int platform_walk(int (*fn)(const process_t *, void *), void *arg, unsigned budget) { unsigned j; (void)budget; + walk_requests++; for (j = 0; j < nfixtures; j++) if (fn(&fixtures[j], arg)) return -1; return partial ? -1 : 0; } int platform_signal(const config_t *c, const process_t *p, enum action action, int real, uint64_t ceiling) { + unsigned j; int found = 0; CHECK(action == TERM || action == KILL); CHECK(!protected_process(c, p)); + for (j = 0; j < nfixtures; j++) + if (fixtures[j].pid == p->pid && same_process(&fixtures[j], p)) { found = 1; break; } if (real) { CHECK(c->armed && fake_sample.free < ceiling); real_requests++; } else validation_requests++; - if (fail_validation) { errno = ESTALE; return -1; } + if (fail_validation || p->pid == invalid_pid || !found) { errno = ESTALE; return -1; } return 0; /* This test backend cannot send any signal. */ } static void reset(void) @@ -43,12 +47,14 @@ static void reset(void) strcpy(cfg.zones[1].uuid, "22222222-2222-4222-8222-222222222222"); strcpy(cfg.zones[1].alias, "web-b"); cfg.zones[1].policy = ALLOW; memset(processes, 0, sizeof (processes)); memset(zone_stats, 0, sizeof (zone_stats)); + memset(candidate_cache, 0, sizeof (candidate_cache)); memset(metrics, 0, sizeof (metrics)); memset(&controller, 0, sizeof (controller)); memset(fixtures, 0, sizeof (fixtures)); engine_init(&engine); engine.state = CRITICAL; engine.danger = 1; stopping = 0; started = 0; log_ok = 1; log_bytes = 0; - scan_generation = 0; fake_now = 100; partial = fail_sample = fail_validation = 0; - real_requests = validation_requests = 0; + scan_generation = 0; scan_complete = 0; latest_complete_scan_at = 0; + fake_now = 100; partial = fail_sample = fail_validation = invalid_pid = 0; + real_requests = validation_requests = walk_requests = 0; memset(&fake_sample, 0, sizeof (fake_sample)); fake_sample.at = fake_now; fake_sample.free = 60000; fake_sample.lots = 130875; fake_sample.des = 65437; fake_sample.min = 49077; @@ -107,11 +113,12 @@ int main(void) fake_now += 5; scan_processes(0); act(&fake_sample); CHECK(real_requests == 2); reset(); cfg.armed = 1; started = 80; act(&fake_sample); CHECK(real_requests == 0); reset(); cfg.armed = 1; log_ok = 0; act(&fake_sample); CHECK(real_requests == 0); - reset(); cfg.armed = 1; partial = 1; scan_processes(0); act(&fake_sample); CHECK(real_requests == 0); + reset(); cfg.armed = 1; partial = 1; fake_now++; scan_processes(0); + act(&fake_sample); CHECK(real_requests == 1 && !scan_complete); reset(); cfg.armed = 1; fail_sample = 1; act(&fake_sample); CHECK(real_requests == 0); reset(); cfg.armed = 1; fail_validation = 1; act(&fake_sample); CHECK(real_requests == 0); reset(); cfg.armed = 1; fake_sample.free = 150000; act(&fake_sample); CHECK(real_requests == 0); - reset(); cfg.armed = 1; fake_now += 3; act(&fake_sample); CHECK(real_requests == 0); + reset(); cfg.armed = 1; fake_now += 16; act(&fake_sample); CHECK(real_requests == 0); reset(); cfg.armed = 1; stopping = 1; act(&fake_sample); CHECK(real_requests == 0); reset(); fake_sample.free = 20000; act(&fake_sample); CHECK(!controller.has_pending && controller.nvictims == 1); @@ -127,6 +134,39 @@ int main(void) chosen = candidate(); CHECK(chosen && chosen->pid == 124); fixtures[1].zid = 0; fake_now = 163; scan_processes(0); CHECK(candidate() == NULL); puts("PASS actual daemon ranking by zone/PID RSS and growth; protected zones and global zone excluded"); + reset(); fixtures[1] = fixtures[0]; fixtures[1].pid = 124; + fixtures[1].rss_kib = 900000; fixtures[1].zid = 10; + strcpy(fixtures[1].uuid, cfg.zones[1].uuid); + fixtures[2] = fixtures[0]; fixtures[2].pid = 125; fixtures[2].rss_kib = 800000; + nfixtures = 3; fake_now = 101; scan_processes(0); + CHECK(candidate_cache[0].valid && candidate_cache[1].valid && candidate_cache[2].valid); + invalid_pid = candidate_cache[0].p.pid; + partial = 1; fake_now = 102; scan_processes(0); + CHECK(!scan_complete && candidate_cache[0].p.pid == invalid_pid); + { + unsigned walks_before = walk_requests; + engine.state = EMERGENCY; engine.danger = 1; fake_sample.free = 40000; + act(&fake_sample); + CHECK(walk_requests == walks_before); /* O(1): no /proc walk in action path. */ + CHECK(controller.has_pending && controller.pending.pid != invalid_pid); + CHECK(validation_requests >= 2 && real_requests == 0); + } + CHECK(fflush(log) == 0 && fseek(log, 0, SEEK_SET) == 0); + n = fread(contents, 1, sizeof (contents) - 1, log); contents[n] = 0; + CHECK(strstr(contents, "candidate_source=fallback_candidate") != NULL); + CHECK(strstr(contents, "scan_complete=0") != NULL); + CHECK(fseek(log, 0, SEEK_END) == 0); + puts("PASS incomplete scan preserves cache; emergency uses O(1) fallback without a new walk"); + reset(); fixtures[1] = fixtures[0]; fixtures[1].pid = 124; + fixtures[1].rss_kib = 900000; fixtures[1].zid = 10; + strcpy(fixtures[1].uuid, cfg.zones[1].uuid); nfixtures = 2; + fake_now = 101; scan_processes(0); + for (second = 0; second < nfixtures; second++) + if (fixtures[second].pid == candidate_cache[0].p.pid) fixtures[second].start_nsec++; + engine.state = EMERGENCY; engine.danger = 1; fake_sample.free = 40000; + act(&fake_sample); + CHECK(controller.has_pending && !same_process(&controller.pending, &candidate_cache[0].p)); + puts("PASS PID/start-time reuse rejects rank 1 and selects cached fallback"); fclose(log); printf("PASS %u runtime checks; all platform calls mocked, no signals sent\n", checks); return 0;