K1/MEM0–MEM2: runtime PMM, muhasebe, pressure, ASID ve task lifecycle/reaper temelleri doğrulandı

impl PressureController {
    pub const fn new(thresholds: PressureThresholds) -> Self {
        Self {
            thresholds,
            level: PressureLevel::Normal,
            oom_epoch: 0,
            oom_selection_issued: false,
        }
    }

    pub const fn level(&self) -> PressureLevel {
        self.level
    }

    pub const fn thresholds(&self) -> PressureThresholds {
        self.thresholds
    }

    pub const fn oom_epoch(&self) -> u64 {
        self.oom_epoch
    }

    /// Open one further selection epoch only after the supervisor has
    /// observed completion or failure of the preceding OOM attempt.
    pub fn rearm_oom_selection(&mut self) -> Result<u64, PressureError> {
        if self.level != PressureLevel::Critical {
            return Err(PressureError::NotCritical);
        }
        self.oom_epoch = self
            .oom_epoch
            .checked_add(1)
            .ok_or(PressureError::ArithmeticOverflow)?;
        self.oom_selection_issued = false;
        Ok(self.oom_epoch)
    }

    pub fn observe(&mut self, free_frames: u64) -> Result<PressureObservation, PressureError> {
        if free_frames > self.thresholds.total_frames {
            return Err(PressureError::FreeExceedsTotal);
        }

        let previous = self.level;
        let current = match previous {
            PressureLevel::Normal => {
                if free_frames <= self.thresholds.critical_free_frames {
                    PressureLevel::Critical
                } else if free_frames <= self.thresholds.warn_free_frames {
                    PressureLevel::Warn
                } else {
                    PressureLevel::Normal
                }
            }
            PressureLevel::Warn => {
                if free_frames <= self.thresholds.critical_free_frames {
                    PressureLevel::Critical
                } else if free_frames >= self.thresholds.warn_recovery() {
                    PressureLevel::Normal
                } else {
                    PressureLevel::Warn
                }
            }
            PressureLevel::Critical => {
                if free_frames >= self.thresholds.warn_recovery() {
                    PressureLevel::Normal
                } else if free_frames >= self.thresholds.critical_recovery() {
                    PressureLevel::Warn
                } else {
                    PressureLevel::Critical
                }
            }
        };

        if current == PressureLevel::Critical && previous != PressureLevel::Critical {
            self.oom_epoch = self
                .oom_epoch
                .checked_add(1)
                .ok_or(PressureError::ArithmeticOverflow)?;
            self.oom_selection_issued = false;
        } else if current != PressureLevel::Critical {
            self.oom_selection_issued = false;
        }
        self.level = current;

        let action = match self.level {
            PressureLevel::Normal => PressureAction::None,
            PressureLevel::Warn => PressureAction::Reclaim,
            PressureLevel::Critical
                if previous == PressureLevel::Critical && !self.oom_selection_issued =>
            {
                self.oom_selection_issued = true;
                PressureAction::SelectOomVictim
            }
            PressureLevel::Critical => PressureAction::ThrottleAndReclaim,
        };

        Ok(PressureObservation {
            previous,
            current: self.level,
            free_frames,
            action,
            oom_epoch: self.oom_epoch,
        })
    }
}

#[test]
fn domain_quota_pin_and_release_are_transactional() {
    assert!(matches!(
        MemoryDomain::try_new(7, 0),
        Err(DomainError::EmptyLimit)
    ));
    let mut domain = MemoryDomain::try_new(7, 10).unwrap();
    let baseline = domain.snapshot();

    domain.try_charge(8).unwrap();
    domain.pin(3).unwrap();
    assert_eq!(domain.snapshot().reclaimable_frames, 5);
    let before_error = domain.snapshot();

    assert_eq!(domain.try_charge(3), Err(DomainError::QuotaExceeded));
    assert_eq!(domain.release(6), Err(DomainError::ReleaseUnderflow));
    assert_eq!(domain.pin(6), Err(DomainError::PinExceedsAllocation));
    assert_eq!(domain.snapshot(), before_error);

    domain.unpin(3).unwrap();
    domain.release(8).unwrap();
    assert_eq!(domain.snapshot(), baseline);
    assert_eq!(domain.unpin(1), Err(DomainError::UnpinUnderflow));
}

  {
    id: "k1-runtime-memory-lifecycle-foundations-partial",
    date: "2026-08-22",
    sequence: 111,
    status: "passed",
    umbrella_status: "partial",
    title:
      "K1/MEM0–MEM2: runtime PMM, muhasebe, pressure, ASID ve task lifecycle/reaper temelleri doğrulandı",
    summary:
      "Bump-only bellek yolunun yanına allocation-free runtime PMM, transactional domain/pin muhasebesi ve bounded pressure/OOM politika çekirdeği eklendi. ASID0 kernel için ayrıldı; 255 kullanıcı ASID'si bitmap ile yönetiliyor, TTBR0/TLBI ASID bit yerleşimi ortak helper'da kodlanıyor. User task stack/page-root sahipliği, daha sonraki scheduler girişinde çalışan deferred reaper ve tracked lower-EL fault izolasyonu kaynakta uygulandı. Bu kayıt K1 ile MEM0–MEM2'nin uygulanmış temellerini gösterir; tam memory lifecycle/reclaim kabulü değildir.",
    evidence: [
      "Runtime PMM focused testleri 11/11 ve allocator-dışı no-allocation testi 1/1 PASS; contiguous run alanları private ve pin snapshot invariant'ları fail-closed.",
      "Memory accounting allocate/free/domain charge rollback ve pin-ledger rollback testleri 9/9 PASS; pressure controller testleri 4/4 PASS ve epoch başına en fazla bir OOM victim seçer.",
      "Runtime ASID allocator testleri 2/2 ve AArch64 ASID encoding testleri 2/2 PASS; ASID0 reserved, TLBI operand `asid << 48`, TTBR0 ASID bits [55:48].",
      "User spawn artık `Result` döndürür ve `try_allocate_asid` çağrısını root/stack allocation'dan önce yapar; panic tabanlı `allocate_asid` ile ASID0/kernel-root fallback kaldırıldı, AddressSpace kısmi kurulum hatalarını RAII ile temizler.",
      "Host/source K1 lifecycle/ASID/IPC uyumluluk focused matrisi 18/18 PASS: task lifecycle 5/5 + spawn-ASID source 4/4 + runtime-ASID 2/2 + IPC compatibility 7/7; bu davranış/source kanıtı board runtime sonucu değildir.",
      "Birleşik serialized workspace regresyonu exact 394/394 PASS; `cargo test --workspace -- --list` envanteri 62 test group'u doğruladı.",
      "Task lifecycle 5/5: owned kernel/user heap stack, raw-ELF PMM stack için non-owning sınır, deferred single-slot reaper ve ASID sıfırlanmadan page-root bırakmama sözleşmesi.",
      "Source-contract kanıtında tracked live user task'ın non-SVC lower-EL synchronous fault'u yalnız o task'ı sonlandırır; privileged/no-owner ve same-EL fault fail-closed panic sınırında kalır.",
      "QEMU/RPi4/RPi5 `aarch64-unknown-none` no_std cargo check'leri yalnız compile applicability için PASS; bu üç board etiketi host/source davranış testlerinin board runtime'da çalıştığı anlamına gelmez.",
      "`make verify-qemu` genel smoke'u hello ELF + IPC ELF + scheduler SEC5 akışını generic fault marker olmadan PASS verdi; lower-EL fault enjekte etmedi, dolayısıyla fault-containment runtime injection kanıtı değildir.",
      "Rustfmt ve diff whitespace kontrolleri PASS.",
    ],
    commands: [
      "cargo test -p aselsan_microkernel_simulation --test runtime_pmm --test runtime_pmm_no_alloc",
      "cargo test -p aselsan_microkernel_simulation --test memory_accounting --test memory_pressure",
      "cargo test -p aselsan_microkernel_simulation --test runtime_asid --test aarch64_asid_encoding",
      "cargo test -p aselsan_microkernel_simulation --test task_lifecycle_source --test task_spawn_asid_source --test runtime_asid --test ipc_queue_host --test ipc_queue_source -- --test-threads=1",
      "cargo test --workspace -- --test-threads=1",
      "cargo test --workspace -- --list",
      "make verify-qemu",
      "cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-qemu",
      "cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-rpi4",
      "cargo check -p aselsan_kernel --target aarch64-unknown-none --no-default-features --features board-rpi5",
    ],
    limitations: [
      "K1 COMPLETE ve genel reclaim değildir: başarılı ELF mapping'inin PMM stack/segment frame'leri Task ownership ledger'ına alınmıyor; static intermediate page table'lar ve bazı capability/provenance kaynakları bütünüyle geri kazanılmıyor.",
      "Legacy BumpAllocator `deallocate_frame` no-op kalır; RuntimePmm henüz kernel production allocation yolunun tamamının yerine geçmez.",
      "Runtime PMM/accounting bugün dış tekil kilit veya interrupt exclusion ister; per-frame domain ownership ve SMP-grade reaper yoktur.",
      "ASID exhaustion'ın user-spawn zincirinde panic-free yayılımı doğrulandı; fail-closed ASID retirement hatasında task kaynakları bilinçli olarak quarantine/leak edilir.",
      "Gerçek idle task yoktur; dead/no-ready task mevcut stack üzerinde WFI ile tutulur ve deferred reaper tek slotlu/globaldir.",
      "MEM3 shared-memory loan/immutable text ve ölçüme bağlı MEM4 compression/freeze uygulanmış sayılmaz.",
      "CARD_WRITE=0, PHYSICAL_CARD_READBACK=0, SYNC=0, EJECT=0, UART=STOP, POWER=STOP ve PHYSICAL_BOOT8H=STOP.",
    ],
  },