diff --git a/CHANGELOG.md b/CHANGELOG.md index 2c2fabc..fc3809a 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,22 @@ # Changelog +## 1.0.4 — 2026-09-21 — Global victim ranking fix + +- Sustituido el orden lexicográfico dominado por `zone_score` por un top‑3 + global entre todos los procesos elegibles de todas las zonas `allow`. +- El score usa RSS como base, crecimiento positivo d5/d15/d60 con mayor peso + reciente y un contexto de zona limitado al 25 % del RSS del proceso. +- `candidate_cache` registra los componentes RSS, crecimiento 5/15/60, zona y + total para auditar cada posición. +- Añadido el fixture SmartOS multizona con PHP-FPM de 245–285 MiB, `clamd` de + aproximadamente 1,33 GiB y `mysqld` protegido. El top‑3 esperado es global. +- Añadidas regresiones para crecimiento rápido, zona no dominante, procesos + protegidos, unmapped/global, scan parcial, fallback y reutilización de PID. +- El warmup armed de 60 s registra ahora `reason=armed_warmup`; sólo inhibe + señales, mientras detección y caché continúan funcionando. +- Conservados dry-run, `--force-dry-run`, SMF deshabilitado, presupuestos 4/8/12 + y toda la telemetría validada. No hubo despliegue ni señales reales. + ## 1.0.3 — 2026-09-21 - Endurecida la detección tras un panic real: PRE-PRESSURE tras dos muestras y diff --git a/INCIDENT_PAGEOUT_DEADMAN_2026_09.md b/INCIDENT_PAGEOUT_DEADMAN_2026_09.md index 682a1ac..6535e81 100644 --- a/INCIDENT_PAGEOUT_DEADMAN_2026_09.md +++ b/INCIDENT_PAGEOUT_DEADMAN_2026_09.md @@ -3,9 +3,10 @@ ## 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. +`o6h-memory-guard` v1.0.2 funcionaba correctamente en `dry-run`. v1.0.3 se +desplegó después sólo en `dry-run` y permitió descubrir el sesgo de ranking que +corrige v1.0.4. Ninguna de estas revisiones activó `armed` durante la evidencia +descrita; v1.0.4 aún no se ha desplegado. ## Cronología reconstruida @@ -86,11 +87,28 @@ pruebas del runtime simulado verifican además: - histéresis RECOVERY/NORMAL; - cero solicitudes de señal real en dry-run. +## v1.0.4 — Global victim ranking fix + +La observación nativa posterior de v1.0.3 confirmó servicio estable, telemetría, +scans rápidos y caché persistente, pero mostró un sesgo: los tres candidatos +procedían de la zona `web5` con procesos PHP-FPM de unos 245–285 MiB, mientras +procesos `clamd` elegibles de aproximadamente 1,33 GiB en otras zonas quedaban +fuera. La causa era el orden lexicográfico por score de zona antes del score de +proceso. + +v1.0.4 construye el top‑3 global directamente entre todos los procesos de zonas +`allow`. RSS es la base; d5/d15/d60 elevan crecimientos recientes y el contexto +de zona queda limitado al 25 % del RSS del candidato. El fixture +`global_victim_ranking_smartos_2026_09.csv` reproduce las proporciones observadas +y mantiene `mysqld`, zonas unmapped y global fuera del ranking. Esta revisión no +se ha desplegado: debe confirmarse en SmartOS real exclusivamente en dry-run. + ## Pendiente antes de `armed` -1. Compilar v1.0.3 con cabeceras nativas SmartOS y ejecutar todas las pruebas. +1. Compilar v1.0.4 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. +3. Confirmar que `candidate_cache` es global y que los `clamd` grandes pueden + superar a los PHP-FPM pequeños sin incluir `mysqld` protegido. 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`. diff --git a/Makefile b/Makefile index d14e572..634c556 100644 --- a/Makefile +++ b/Makefile @@ -18,7 +18,7 @@ o6h-memory-guard: $(SOURCES) src/guard.h | native-check 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 +test-runtime: tests/test_runtime.c tests/fixtures/global_victim_ranking_smartos_2026_09.csv src/main.c src/core.c src/config.c src/guard.h $(CC) $(TESTFLAGS) -o $@ tests/test_runtime.c src/core.c src/config.c test: test-guard test-runtime diff --git a/README.md b/README.md index 8db257d..63eaed8 100644 --- a/README.md +++ b/README.md @@ -1,4 +1,4 @@ -# o6h-memory-guard 1.0.3 +# o6h-memory-guard 1.0.4 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, @@ -18,7 +18,7 @@ No se ha desplegado ni se han enviado señales reales durante la preparación. 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. + con v1.0.2, endurecimiento de v1.0.3 y corrección del ranking global en v1.0.4. - `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 @@ -32,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.3.tar.gz`: +Copiar el archivo distribuido a `/var/tmp/o6h-memory-guard-1.0.4.tar.gz`: ```sh mkdir -p /opt/custom/src cd /opt/custom/src -gzip -dc /var/tmp/o6h-memory-guard-1.0.3.tar.gz | tar -xf - +gzip -dc /var/tmp/o6h-memory-guard-1.0.4.tar.gz | tar -xf - cd /opt/custom/src/o6h-memory-guard gmake CC=gcc gmake test CC=gcc @@ -191,25 +191,43 @@ 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. +orden. El episodio sólo se reinicia al volver a NORMAL. En armed, los primeros +60 s desde el arranque monotónico del daemon inhiben únicamente las señales, +también en EMERGENCY, para evitar eludir el límite por minuto mediante reinicios. +La detección, el muestreo, los scans permitidos por estado y la reconstrucción +del `candidate_cache` continúan durante ese warmup. Cada bloqueo se registra como +`event=action_blocked reason=armed_warmup elapsed_seconds=... required_seconds=60`. +Los contadores son en memoria; el presupuesto por episodio sí se reinicia al +reiniciar el daemon. Revisar esta elección antes de usarlo como mecanismo de rescate. No hay garantía de evitar un panic. ## Atribución y protecciones -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. 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. +Cada scan completo recorre todos los procesos elegibles de todas las zonas +`allow` y construye un único top‑3 global; no existe una preselección de la mejor +zona. El score en KiB equivalentes es: + +```text +total_score = RSS + 4*max(d5,0) + 2*max(d15,0) + max(d60,0) + + zone_component +``` + +`zone_component` incorpora `zone_rss/64` y crecimiento positivo de zona +d5/16, d15/32 y d60/64, pero queda limitado a `process_rss/4`. Así una zona +enorme aporta contexto sin poder monopolizar el ranking; un proceso estable de +1,3 GiB supera normalmente a uno de 250 MiB, mientras un proceso menor con +crecimiento explosivo todavía puede ascender. Se usa el mismo top‑3 balanceado +en todos los estados para conservar la ruta CRITICAL/EMERGENCY/FLOOR O(1) y no +expulsar de la caché procesos grandes necesarios para recuperación inmediata. +Empates se resuelven por RSS y después PID. El log expone `rss_component`, +`growth5_component`, `growth15_component`, `growth60_component`, +`zone_component` y `total_score`. + +Cada entrada conserva identidad, alias, RSS y d5/d15/d60. **La suma de RSS por +zona 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. El UUID es el nombre de zona devuelto por el kernel, validado como UUID canónico en minúscula (convención SmartOS). Se conserva además `ZONE_ATTR_UNIQID`; se @@ -305,13 +323,13 @@ 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 +Los eventos `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. +resultado del último scan, componentes del score y cualquier override de presupuesto. -## Preparación de armed (NO GO para v1.0.3 inicial) +## Preparación de armed (NO GO para v1.0.4 inicial) -v1.0.3 debe compilarse y observarse primero en SmartOS exclusivamente en +v1.0.4 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 @@ -357,6 +375,10 @@ 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. +La migración desde v1.0.3 a v1.0.4 no añade parámetros de configuración: cambia +el algoritmo de ranking y su logging. Comparar el top‑3 global en SmartOS real +antes de reemplazar el binario observado y mantener siempre `--force-dry-run`. + ## Referencias revisadas - [SmartOS: servicios personalizados y /opt/custom/smf](https://docs.smartos.org/smf-quick-reference-gz/). diff --git a/SHA256SUMS b/SHA256SUMS index c00fab5..ed32957 100644 --- a/SHA256SUMS +++ b/SHA256SUMS @@ -1,29 +1,30 @@ 887569535302f7deba4d7c6ffb2103f1fb90bd96a40280240ff238eddc2e3a6f ./.gitignore -8b1e0498bf3b9ccf3a36a4cc1ed0de7573612da2ef27be19e5496287679509f5 ./CHANGELOG.md +2e27e56dea5e00b74ccdd2ae2d5d8ff7ca7f01d82c1d2ed27ea976a7bf382856 ./CHANGELOG.md ebfca7d4b5eaf0c0cc9910cf49d8c85f6aa7ff69972d7f21d17e61d1a2e23bc2 ./CHECKPOINT.md -7b96d41da2877a771058ad0b184137ca5a7b5bcf26ddf77145ed067a87e0ce33 ./INCIDENT_PAGEOUT_DEADMAN_2026_09.md -ab718d07e0bab3a4e22b840991fb4586bb8e70e5e04d9bd411d2221f44ef7e0d ./Makefile -edb3d79db79e7ca98c2bc94100835833bfdda37cde917a8b5604344628bac120 ./README.md -290aa8a15ed211e4672b54549a9a7678c2b65ce42dee5a75a3f046f0bb51df31 ./VALIDATION.md -07722b81f7905e3c48f607e55e2aa3eb8498eacfb40e7aff073fc96e98717c8f ./etc/o6h-memory-guard.conf +a0f96300e751d08ceeef1360325ed54008b703fa6bd07df9d5368674e580f113 ./INCIDENT_PAGEOUT_DEADMAN_2026_09.md +df619be1585cd8d6173acba541fcaeeb1e94e55459dc059914863d0e9f316121 ./Makefile +9a841ab6077f10267ee73f23b51be849d391fd0deddee85bf99338601b3b379e ./README.md +c749b5a31b3a9a72de4e2c4bb8903ccc901ddde7aa702ccbebcbfd57c075dcef ./VALIDATION.md +f89457e6fd793911c8e73843ce7f38fe0c119045c66c06fca1cb962737c8c45d ./etc/o6h-memory-guard.conf f6565d0e1ece0a08721c9893f9ed071d2ab0a2818fa93ed0a14e0050d358ce99 ./install.sh -e2430c24466b2c82d5f20b46bc89ce77917d4c50dba6e5d69878c42ff55ca531 ./logs/example.log +b9b5b28aff2d34dd8d544a73a2c4a14b8e622185b68751dd0227671c298cd50a ./logs/example.log b7d6826f353765641a95025344c30e6f5eb228772f29e04399a9ec78e3fb5595 ./logs/policy-tests.log abafc237427b63f38f81d0d1b76ba64eefc64d9f8074fdaa6ed0f1573b5d0a3b ./logs/portability.log -2b617f4070b8ec155f2a7c1ee6048c99cd7c96b6dbbd26b60ebab0c1d3b13c22 ./logs/runtime-tests.log -2e09451d28c59911c1d74ff6195fab0506eb2fc26cb99e5be79e65c47e75668a ./logs/sanitizers.log +ed9246c2a7a82ed42a49dc72439cd452f2ab8a76b4dcd1aaf466ba23eb75fc5c ./logs/runtime-tests.log +2632e52bc306f5ccc947aac41d91f0b7ad54043a4192a0c4d7ed69616b1183c5 ./logs/sanitizers.log b55afd45a72947efdda79d593255c36def9679bcb7a33ab14d55170ebaf9bef7 ./smf/o6h-memory-guard.xml 9a4468d9acc3f1da078b009f764c7cb7bf337682d6584b8cbaf7b540c520d5f5 ./src/config.c c1f81909ec63fdb85948bbe58642478a80105b26a7c64eaf463c0e6fc42de203 ./src/core.c -0b9867e7ae7d1fcb2aab75f94d770471bd21f17c9f1eaf3c0f7c44eeb83e485b ./src/guard.h +df4baeefd240a61916fcdd4a06167fa34621510db027eb20cce0b3559c37b28c ./src/guard.h 32ab75bb6a1ff2bbbeb6a1ea658abcb96a03fcc06246f38d019faec7fdc184b8 ./src/illumos.c -066473572d8d2d8ca354ab3e718d3ccce618f8cfbb96992d008da3e9592b8815 ./src/main.c +4b643eb55f7846c5b1ae5906a13dec3f7ac9b6191778c8352cffd39ca0bf2bfd ./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 +4aa08ded8e98cf25d2a8762543de7a9273f0ebf00b4c7e5b359603ceda46eb56 ./tests/fixtures/global_victim_ranking_smartos_2026_09.csv c5d9d7fc7a39354474d30cd316ea9f122205c2b38e57f927f4a08306b8a62c81 ./tests/fixtures/pageout_deadman_real_incident_2026_09.csv b7ac53f6b26b4e7e2e19d7258b570a64462182ffe85c93374856caf77ec0c871 ./tests/test_guard.c -017b0a8dd3f9444fe63e4f8a6b3c12bf9ac98c25078223900a5672b6afdd11ec ./tests/test_runtime.c +76c0a6d64a3feb74678f0455ad32a4392cea169aee735035f65b17837b82a931 ./tests/test_runtime.c diff --git a/VALIDATION.md b/VALIDATION.md index 6cddf80..14872b8 100644 --- a/VALIDATION.md +++ b/VALIDATION.md @@ -1,14 +1,16 @@ -# Validación de la entrega v1.0.3 +# Validación de la entrega v1.0.4 -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 +Fecha: 2026-09-21. v1.0.3 se desplegó y se está validando en SmartOS real sólo +en `dry-run`; confirmó la telemetría, SMF, scans y caché persistente, pero reveló +que `zone_score` podía monopolizar el top‑3. **v1.0.4 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`. `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. +`INCIDENT_PAGEOUT_DEADMAN_2026_09.md` documenta el incidente, el endurecimiento +v1.0.3 y el hallazgo que motiva v1.0.4. La telemetría nativa ya validada no se ha +refactorizado. ## Evidencia real que motiva esta revisión @@ -20,16 +22,22 @@ 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. -## Comprobaciones automatizadas de v1.0.3 +En la validación posterior de v1.0.3, `candidate_cache` contenía tres PHP-FPM de +`web5` de unos 245–285 MiB mientras el mismo scan mostraba `clamd` elegibles de +aproximadamente 1,33 GiB en cuatro zonas menores. El fixture +`tests/fixtures/global_victim_ranking_smartos_2026_09.csv` conserva esas +proporciones y procesos `mysqld` protegidos. -- `make test` completa 138 comprobaciones de política y 73 de runtime. +## Comprobaciones automatizadas de v1.0.4 + +- `make test` completa 138 comprobaciones de política y 138 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. + la ruta usada por el daemon: top‑3 global multizona, componentes d5/d15/d60, + zona contextual acotada, preservación tras scan incompleto, 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, @@ -63,6 +71,13 @@ Los resultados exactos se guardan en `logs/policy-tests.log`, 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. +11. El fixture multizona sitúa tres `clamd` de más de 1,3 millones de KiB por + delante de PHP-FPM de 245–285 mil KiB aunque `web5` sume unos 8 GiB. +12. `mysqld`, relleno protegido, unmapped y global nunca entran en la caché. +13. Un PHP-FPM todavía menor asciende a rank 1 al crecer con rapidez en d5. +14. El contexto de zona nunca supera el 25 % del RSS del proceso. +15. El warmup armed bloquea sólo la señal con `reason=armed_warmup`; detección, + scan y caché siguen activos durante los 60 s. ## Validación obligatoria pendiente en SmartOS @@ -71,8 +86,8 @@ Los resultados exactos se guardan en `logs/policy-tests.log`, 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`. +4. Confirmar que el top‑3 es global: los `clamd` grandes de zonas menores deben + superar a PHP-FPM pequeños de `web5`, sin incluir ningún `mysqld` protegido. 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 diff --git a/etc/o6h-memory-guard.conf b/etc/o6h-memory-guard.conf index a6d124f..b87d806 100644 --- a/etc/o6h-memory-guard.conf +++ b/etc/o6h-memory-guard.conf @@ -1,4 +1,4 @@ -# o6h-memory-guard 1.0.3 -- whitespace-separated, no shell evaluation. +# o6h-memory-guard 1.0.4 -- whitespace-separated, no shell evaluation. # Restart required for configuration changes. Duplicate scalar keys are errors. ACTION_MODE dry-run diff --git a/logs/example.log b/logs/example.log index d4e45f2..8323f94 100644 --- a/logs/example.log +++ b/logs/example.log @@ -1,10 +1,10 @@ # SYNTHETIC FORMAT EXAMPLE -- NOT HOST TELEMETRY. Fields abridged for readability. -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-21T15:00:00Z mono=100.000 event=start version=1.0.4 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-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: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 rss_component=1048576 growth5_component=400000 growth15_component=0 growth60_component=0 zone_component=32768 total_score=1481344 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-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 diff --git a/logs/runtime-tests.log b/logs/runtime-tests.log index cf4b640..94c7d34 100644 --- a/logs/runtime-tests.log +++ b/logs/runtime-tests.log @@ -1,7 +1,8 @@ PASS actual daemon dry-run path records WOULD_ACTION=SIGTERM/SIGKILL; zero real requests 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 armed-path mock requests, explicit warmup, stale cache, logging/sampling failures, stop and fresh floor +PASS global score uses process RSS/growth; protected zones and global zone excluded +PASS SmartOS fixture produces a global cross-zone top-3 and bounded zone context 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 +PASS 138 runtime checks; all platform calls mocked, no signals sent diff --git a/logs/sanitizers.log b/logs/sanitizers.log index f1d3090..c6ac88b 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: 138 checks; no native backend linked, no signals sent -PASS test-sanitize-runtime: 73 checks; all platform calls mocked, no signals sent +PASS test-sanitize-runtime: 138 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/guard.h b/src/guard.h index dade764..6d28d6d 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.3" +#define VERSION "1.0.4" enum state { NORMAL, PRE_PRESSURE, PRESSURE, CRITICAL, EMERGENCY, RECOVERY }; enum policy { OBSERVE, ALLOW, PROTECT }; diff --git a/src/main.c b/src/main.c index cbdec3a..d5f804a 100644 --- a/src/main.c +++ b/src/main.c @@ -17,13 +17,14 @@ typedef struct { } tracked_t; typedef struct { char uuid[64]; uint64_t generation, rss; - history_t history; unsigned seen; double last; int best; + history_t history; unsigned seen; double last; } zone_t; #define CACHED_CANDIDATES 3 typedef struct { process_t p; delta_t d5, d15, d60; - uint64_t zone_score, process_score; + uint64_t rss_component, growth5_component, growth15_component; + uint64_t growth60_component, zone_component, total_score; double scan_time; unsigned rank; int valid, eligible; @@ -110,12 +111,45 @@ failed: return -1; } -static delta_t growth(const history_t *h) +static uint64_t saturated_add(uint64_t a, uint64_t b) { - delta_t d = history_delta(h, scan_at, 60); - if (!d.valid) d = history_delta(h, scan_at, 15); - if (!d.valid) d = history_delta(h, scan_at, 5); - return d; + return b > UINT64_MAX - a ? UINT64_MAX : a + b; +} + +static uint64_t positive_scaled(delta_t d, uint64_t multiplier, + uint64_t divisor) +{ + uint64_t value; + if (!d.valid || d.value <= 0) return 0; + value = (uint64_t)d.value; + if (value > UINT64_MAX / multiplier) return UINT64_MAX; + return value * multiplier / divisor; +} + +static void score_candidate(cached_candidate_t *entry, const zone_t *z) +{ + delta_t zd5 = history_delta(&z->history, scan_at, 5); + delta_t zd15 = history_delta(&z->history, scan_at, 15); + delta_t zd60 = history_delta(&z->history, scan_at, 60); + uint64_t zone_raw, zone_cap; + entry->rss_component = entry->p.rss_kib; + entry->growth5_component = positive_scaled(entry->d5, 4, 1); + entry->growth15_component = positive_scaled(entry->d15, 2, 1); + entry->growth60_component = positive_scaled(entry->d60, 1, 1); + zone_raw = z->rss / 64; + zone_raw = saturated_add(zone_raw, positive_scaled(zd5, 1, 16)); + zone_raw = saturated_add(zone_raw, positive_scaled(zd15, 1, 32)); + zone_raw = saturated_add(zone_raw, positive_scaled(zd60, 1, 64)); + zone_cap = entry->p.rss_kib / 4; + entry->zone_component = zone_raw < zone_cap ? zone_raw : zone_cap; + entry->total_score = saturated_add(entry->rss_component, + entry->growth5_component); + entry->total_score = saturated_add(entry->total_score, + entry->growth15_component); + entry->total_score = saturated_add(entry->total_score, + entry->growth60_component); + entry->total_score = saturated_add(entry->total_score, + entry->zone_component); } static int visit(const process_t *p, void *unused) @@ -152,15 +186,10 @@ static int visit(const process_t *p, void *unused) if (strcmp(z->uuid, p->uuid) || z->generation != p->zone_generation) { memset(z, 0, sizeof (*z)); strcpy(z->uuid, p->uuid); z->generation = p->zone_generation; } - if (z->seen != scan_generation) { z->rss = 0; z->best = -1; } + if (z->seen != scan_generation) z->rss = 0; z->seen = scan_generation; z->last = scan_at; if (UINT64_MAX - z->rss < p->rss_kib) return -1; z->rss += p->rss_kib; - if (!protected_process(&cfg, p) && !was_victim(&controller, p)) { - if (z->best < 0 || rank_score(p->rss_kib, growth(&t->rss)) > - rank_score(processes[z->best].p.rss_kib, growth(&processes[z->best].rss))) - z->best = (int)slot; - } return 0; } @@ -183,8 +212,9 @@ static zone_t *zone_for_process(const process_t *p) 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; + if (a->total_score != b->total_score) return a->total_score > b->total_score; + if (a->rss_component != b->rss_component) + return a->rss_component > b->rss_component; return a->p.pid < b->p.pid; } @@ -197,7 +227,6 @@ static void rebuild_candidate_cache(void) 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); @@ -206,9 +235,7 @@ static void rebuild_candidate_cache(void) 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)); + score_candidate(&entry, z); 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++) { @@ -229,14 +256,19 @@ static void rebuild_candidate_cache(void) 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, + " rss_component=%" PRIu64 " growth5_component=%" PRIu64 + " growth15_component=%" PRIu64 " growth60_component=%" PRIu64 + " zone_component=%" PRIu64 " total_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); + candidate_cache[i].eligible, candidate_cache[i].rss_component, + candidate_cache[i].growth5_component, + candidate_cache[i].growth15_component, + candidate_cache[i].growth60_component, + candidate_cache[i].zone_component, candidate_cache[i].total_score); } } @@ -380,7 +412,8 @@ static void act(sample_t *sample) emit("event=action_blocked reason=log_failure"); return; } if (cfg.armed && monotime() - started < 60) { - emit("event=action_blocked reason=armed_startup_60s"); return; + emit("event=action_blocked reason=armed_warmup elapsed_seconds=%.1f" + " required_seconds=60", monotime() - started); return; } /* O(1) critical path: kstat refresh + cached identity validation, no walk. */ if (platform_sample(&fresh) || monotime() - fresh.at > 2 || fresh.free >= fresh.des) { diff --git a/tests/fixtures/global_victim_ranking_smartos_2026_09.csv b/tests/fixtures/global_victim_ranking_smartos_2026_09.csv new file mode 100644 index 0000000..42625fe --- /dev/null +++ b/tests/fixtures/global_victim_ranking_smartos_2026_09.csv @@ -0,0 +1,17 @@ +# uuid,alias,zid,generation,pid,comm,rss_kib +11111111-1111-4111-8111-111111111111,web5,11,101,1101,php-fpm,284980 +11111111-1111-4111-8111-111111111111,web5,11,101,1102,php-fpm,248672 +11111111-1111-4111-8111-111111111111,web5,11,101,1103,php-fpm,245016 +11111111-1111-4111-8111-111111111111,web5,11,101,1104,zone-overhead,7609940 +22222222-2222-4222-8222-222222222222,sailandfun,12,102,1201,clamd,1397040 +22222222-2222-4222-8222-222222222222,sailandfun,12,102,1202,mysqld,440320 +22222222-2222-4222-8222-222222222222,sailandfun,12,102,1203,zone-overhead,1308368 +33333333-3333-4333-8333-333333333333,webscorp,13,103,1301,clamd,1395344 +33333333-3333-4333-8333-333333333333,webscorp,13,103,1302,mysqld,388096 +33333333-3333-4333-8333-333333333333,webscorp,13,103,1303,zone-overhead,1676860 +44444444-4444-4444-8444-444444444444,consultaerte,14,104,1401,clamd,1394768 +44444444-4444-4444-8444-444444444444,consultaerte,14,104,1402,mysqld,238592 +44444444-4444-4444-8444-444444444444,consultaerte,14,104,1403,zone-overhead,883222 +55555555-5555-4555-8555-555555555555,03.base0.es,15,105,1501,clamd,1390164 +55555555-5555-4555-8555-555555555555,03.base0.es,15,105,1502,mysqld,206848 +55555555-5555-4555-8555-555555555555,03.base0.es,15,105,1503,zone-overhead,1339001 diff --git a/tests/test_runtime.c b/tests/test_runtime.c index 09d6e6a..5169582 100644 --- a/tests/test_runtime.c +++ b/tests/test_runtime.c @@ -5,7 +5,7 @@ static double fake_now = 100; static sample_t fake_sample; -static process_t fixtures[8]; +static process_t fixtures[32]; 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) @@ -66,6 +66,45 @@ static void reset(void) scan_processes(0); } +static void load_global_ranking_fixture(void) +{ + FILE *f; + char line[256], uuid[64], alias[64], name[32]; + int zid, pid; + uint64_t generation, rss; + reset(); + cfg.nzones = cfg.nnames = 0; + strcpy(cfg.protected_names[cfg.nnames++], "mysqld"); + strcpy(cfg.protected_names[cfg.nnames++], "zone-overhead"); + memset(processes, 0, sizeof (processes)); + memset(zone_stats, 0, sizeof (zone_stats)); + memset(candidate_cache, 0, sizeof (candidate_cache)); + memset(&controller, 0, sizeof (controller)); + memset(fixtures, 0, sizeof (fixtures)); + scan_generation = 0; scan_complete = 0; latest_complete_scan_at = 0; + nfixtures = 0; fake_now = 100; + f = fopen("tests/fixtures/global_victim_ranking_smartos_2026_09.csv", "r"); + CHECK(f != NULL); CHECK(fgets(line, sizeof (line), f) != NULL); + while (fscanf(f, " %63[^,],%63[^,],%d,%" SCNu64 ",%d,%31[^,],%" SCNu64, + uuid, alias, &zid, &generation, &pid, name, &rss) == 7) { + process_t *p; + const zone_rule_t *rule = zone_rule(&cfg, uuid); + CHECK(nfixtures < sizeof (fixtures) / sizeof (fixtures[0])); + if (!rule) { + zone_rule_t *z; + CHECK(cfg.nzones < MAX_ZONES); z = &cfg.zones[cfg.nzones++]; + strcpy(z->uuid, uuid); strcpy(z->alias, alias); z->policy = ALLOW; + } + p = &fixtures[nfixtures++]; + p->pid = pid; p->ppid = 100; p->zid = zid; p->initpid = 9000 + zid; + p->nlwp = 1; p->start_sec = 1000 + pid; p->start_nsec = pid; + p->zone_generation = generation; p->rss_kib = rss; + strcpy(p->uuid, uuid); strcpy(p->name, name); + } + fclose(f); CHECK(nfixtures == 16 && cfg.nzones == 5); + scan_processes(1); +} + int main(void) { FILE *log = tmpfile(); char contents[65536]; size_t n; @@ -111,7 +150,13 @@ int main(void) reset(); cfg.armed = 1; act(&fake_sample); CHECK(real_requests == 1); 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; fake_now = 101; scan_processes(0); + CHECK(candidate_cache[0].valid && engine.danger && walk_requests == 2); + act(&fake_sample); CHECK(real_requests == 0 && candidate_cache[0].valid); + CHECK(fflush(log) == 0 && fseek(log, 0, SEEK_SET) == 0); + n = fread(contents, 1, sizeof (contents) - 1, log); contents[n] = 0; + CHECK(strstr(contents, "event=action_blocked reason=armed_warmup") != NULL); + CHECK(fseek(log, 0, SEEK_END) == 0); reset(); cfg.armed = 1; log_ok = 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); @@ -122,7 +167,7 @@ int main(void) 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); - puts("PASS armed-path mock requests, warmup, stale cache, logging/sampling failures, stop and fresh floor"); + puts("PASS armed-path mock requests, explicit warmup, stale cache, logging/sampling failures, stop and fresh floor"); 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; @@ -133,7 +178,74 @@ int main(void) cfg.zones[0].policy = PROTECT; fake_now = 162; scan_processes(0); 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"); + puts("PASS global score uses process RSS/growth; protected zones and global zone excluded"); + load_global_ranking_fixture(); + CHECK(candidate_cache[0].valid && candidate_cache[1].valid && candidate_cache[2].valid); + CHECK(!strcmp(candidate_cache[0].p.name, "clamd")); + CHECK(!strcmp(candidate_cache[1].p.name, "clamd")); + CHECK(!strcmp(candidate_cache[2].p.name, "clamd")); + CHECK(candidate_cache[0].p.rss_kib > 1300000 && + candidate_cache[2].p.rss_kib > 1300000); + CHECK(strcmp(candidate_cache[0].p.uuid, candidate_cache[1].p.uuid)); + CHECK(strcmp(candidate_cache[1].p.uuid, candidate_cache[2].p.uuid)); + for (second = 0; second < CACHED_CANDIDATES; second++) { + CHECK(strcmp(candidate_cache[second].p.name, "mysqld")); + CHECK(strcmp(candidate_cache[second].p.name, "zone-overhead")); + } + for (second = 0; second < nfixtures; second++) + if (!strcmp(fixtures[second].name, "mysqld")) + CHECK(protected_process(&cfg, &fixtures[second])); + CHECK(fflush(log) == 0 && fseek(log, 0, SEEK_SET) == 0); + n = fread(contents, 1, sizeof (contents) - 1, log); contents[n] = 0; + { + char *mysql = strstr(contents, "comm=mysqld"); + char *ineligible = mysql ? strstr(mysql, "eligible=0") : NULL; + char *line_end = mysql ? strchr(mysql, '\n') : NULL; + CHECK(mysql && ineligible && line_end && ineligible < line_end); + } + CHECK(fseek(log, 0, SEEK_END) == 0); + fixtures[nfixtures] = fixtures[0]; fixtures[nfixtures].pid = 9001; + fixtures[nfixtures].zid = 90; fixtures[nfixtures].zone_generation = 900; + fixtures[nfixtures].rss_kib = UINT64_C(9000000); + strcpy(fixtures[nfixtures].uuid, "66666666-6666-4666-8666-666666666666"); + strcpy(fixtures[nfixtures].name, "unmapped-hog"); nfixtures++; + fixtures[nfixtures] = fixtures[0]; fixtures[nfixtures].pid = 9002; + fixtures[nfixtures].zid = 0; fixtures[nfixtures].rss_kib = UINT64_C(11000000); + strcpy(fixtures[nfixtures].name, "global-hog"); nfixtures++; + fake_now = 101; scan_processes(0); + for (second = 0; second < CACHED_CANDIDATES; second++) + CHECK(candidate_cache[second].p.pid != 9001 && candidate_cache[second].p.pid != 9002); + for (second = 0; second < nfixtures; second++) + if (fixtures[second].pid == 1103) fixtures[second].rss_kib = 600000; + fake_now = 106; scan_processes(0); + CHECK(candidate_cache[0].p.pid == 1103); + CHECK(candidate_cache[0].growth5_component > 0 && + candidate_cache[0].total_score > candidate_cache[1].total_score); + { + cached_candidate_t scored; + zone_t zone; + memset(&scored, 0, sizeof (scored)); memset(&zone, 0, sizeof (zone)); + scored.p.rss_kib = 100000; scored.d5.valid = scored.d15.valid = 1; + scored.d60.valid = 1; scored.d5.value = 1000; + scored.d15.value = 2000; scored.d60.value = 3000; + scan_at = 60; history_add(&zone.history, 0, 1000000); + history_add(&zone.history, 60, 1100000); zone.rss = 1100000; + score_candidate(&scored, &zone); + CHECK(scored.growth5_component == 4000); + CHECK(scored.growth15_component == 4000); + CHECK(scored.growth60_component == 3000); + CHECK(scored.zone_component <= scored.p.rss_kib / 4); + } + CHECK(fflush(log) == 0 && fseek(log, 0, SEEK_SET) == 0); + n = fread(contents, 1, sizeof (contents) - 1, log); contents[n] = 0; + CHECK(strstr(contents, "rss_component=") != NULL); + CHECK(strstr(contents, "growth5_component=") != NULL); + CHECK(strstr(contents, "growth15_component=") != NULL); + CHECK(strstr(contents, "growth60_component=") != NULL); + CHECK(strstr(contents, "zone_component=") != NULL); + CHECK(strstr(contents, "total_score=") != NULL); + CHECK(fseek(log, 0, SEEK_END) == 0); + puts("PASS SmartOS fixture produces a global cross-zone top-3 and bounded zone context"); 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);