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