RPi5 G7a CPU0 kooperatif scheduler paketi hazırlandı

/// Validate a complete G7a physical UART transcript.
///
/// `SEC` lines are optional. If present, they must start at second 1, remain
/// contiguous, and satisfy `ticks == second * 100` for every sample.
pub fn verify_transcript(input: &[u8]) -> Result<G7aEvidence, ValidationError> {
    let leading_nuls = input.iter().take_while(|&&byte| byte == 0).count();
    let mut errors = Vec::new();
    if leading_nuls > 5 {
        errors.push(format!(
            "leading NUL prefix exceeds capture allowance: observed {leading_nuls}, maximum 5"
        ));
    }

    // Some UART capture stacks prepend a short NUL run while opening the port.
    // Only that bounded prefix is ignored; NULs after transcript text begins are
    // evidence corruption and are rejected by the control-byte scan below.
    let payload = &input[leading_nuls..];
    let transcript = match std::str::from_utf8(payload) {
        Ok(value) => value,
        Err(error) => {
            errors.push(format!("transcript is not valid UTF-8: {error}"));
            return Err(ValidationError { messages: errors });
        }
    };

    for (payload_offset, character) in transcript.char_indices() {
        if character.is_control() && !matches!(character, '\n' | '\r' | '\t') {
            let offset = leading_nuls + payload_offset;
            if character.is_ascii() {
                errors.push(format!(
                    "forbidden control byte 0x{:02x} at byte offset {offset}",
                    character as u32
                ));
            } else {
                errors.push(format!(
                    "forbidden Unicode control U+{:04X} at byte offset {offset}",
                    character as u32
                ));
            }
        }
    }

    let mut sequence = Vec::new();
    let mut counts: BTreeMap<&'static str, usize> = EXPECTED_SEQUENCE
        .iter()
        .copied()
        .map(|name| (name, 0))
        .collect();
    let mut start_ticks = None;
    let mut end_ticks = None;
    let mut sec_samples = Vec::new();

    for (index, raw_line) in transcript.lines().enumerate() {
        let line_number = index + 1;
        let line = raw_line.trim_end_matches('\r').trim();
        let lowercase = line.to_ascii_lowercase();

        for marker in FORBIDDEN_MARKERS {
            if lowercase.contains(marker) {
                errors.push(format!("line {line_number}: forbidden marker {marker:?}"));
            }
        }
        if lowercase.contains("[exc]") || lowercase.contains("bilinmeyen irq") {
            errors.push(format!(
                "line {line_number}: forbidden exception/unknown IRQ marker"
            ));
        }

        if line.starts_with("[SEC") {
            match parse_sec(line) {
                Ok((second, ticks)) => sec_samples.push((line_number, second, ticks)),
                Err(reason) => errors.push(format!("line {line_number}: {reason}")),
            }
        }

        let label = if line.starts_with("ASELSAN/BOOT0") {
            require_exact(line, "ASELSAN/BOOT0 BCM2712", line_number, &mut errors);
            Some("BOOT0")
        } else if line.starts_with("ASELSAN/BOOT1") {
            if line != "ASELSAN/BOOT1 CurrentEL=1" && line != "ASELSAN/BOOT1 CurrentEL=2" {
                errors.push(format!("line {line_number}: invalid BOOT1 marker {line:?}"));
            }
            Some("BOOT1")
        } else if line.starts_with("ASELSAN/BOOT2") {
            require_exact(line, "ASELSAN/BOOT2 EL1", line_number, &mut errors);
            Some("BOOT2")
        } else if line.starts_with("ASELSAN/BOOT3") {
            require_exact(line, "ASELSAN/BOOT3 DTB=OK", line_number, &mut errors);
            Some("BOOT3")
        } else if line.starts_with("ASELSAN/BOOT4") {
            require_exact(line, "ASELSAN/BOOT4 MMU=ON", line_number, &mut errors);
            Some("BOOT4")
        } else if line.starts_with("ASELSAN/BOOT5") {
            match parse_fields(line, "ASELSAN/BOOT5") {
                Ok(fields) => {
                    require_field(&fields, "GIC+TIMER", "OK", line_number, &mut errors);
                    require_field(&fields, "ticks", "100", line_number, &mut errors);
                }
                Err(reason) => errors.push(format!("line {line_number}: {reason}")),
            }
            Some("BOOT5")
        } else if line.starts_with("ASELSAN/BOOT6") {
            match parse_fields(line, "ASELSAN/BOOT6") {
                Ok(fields) => {
                    require_field(&fields, "DT+RAM+HEAP", "OK", line_number, &mut errors);
                    require_field(&fields, "BOX", "0xa5a51234", line_number, &mut errors);
                }
                Err(reason) => errors.push(format!("line {line_number}: {reason}")),
            }
            Some("BOOT6")
        } else if line.starts_with("ASELSAN/G7S0") {
            match parse_fields(line, "ASELSAN/G7S0") {
                Ok(fields) => {
                    require_field(&fields, "FPEN", "3", line_number, &mut errors);
                    require_field(&fields, "CPU", "0", line_number, &mut errors);
                    require_field(&fields, "MODE", "COOP", line_number, &mut errors);
                    require_field(&fields, "TASKS", "2", line_number, &mut errors);
                    start_ticks =
                        parse_tick_field(&fields, "START_TICKS", line_number, &mut errors);
                }
                Err(reason) => errors.push(format!("line {line_number}: {reason}")),
            }
            Some("G7S0")
        } else if line.starts_with("ASELSAN/G7S1") {
            match parse_fields(line, "ASELSAN/G7S1") {
                Ok(fields) => {
                    let task = fields.get("TASK").copied();
                    let step = fields.get("STEP").copied();
                    match (task, step) {
                        (Some("A"), Some("1")) => Some("A1"),
                        (Some("B"), Some("1")) => Some("B1"),
                        (Some("A"), Some("2")) => Some("A2"),
                        (Some("B"), Some("2")) => Some("B2"),
                        _ => {
                            errors.push(format!(
                                "line {line_number}: unexpected G7S1 TASK/STEP pair"
                            ));
                            None
                        }
                    }
                }
                Err(reason) => {
                    errors.push(format!("line {line_number}: {reason}"));
                    None
                }
            }
        } else if has_marker_tag(line, "ASELSAN/BOOT7") {
            match parse_fields(line, "ASELSAN/BOOT7") {
                Ok(fields) => {
                    require_field(&fields, "SCHED", "OK", line_number, &mut errors);
                    require_field(&fields, "ORDER", "ABAB", line_number, &mut errors);
                    require_field(&fields, "STEPS", "4", line_number, &mut errors);
                    end_ticks = parse_tick_field(&fields, "TICKS", line_number, &mut errors);
                }
                Err(reason) => errors.push(format!("line {line_number}: {reason}")),
            }
            Some("BOOT7")
        } else {
            if (line.starts_with("ASELSAN/BOOT") || line.starts_with("ASELSAN/G7S"))
                && !has_marker_tag(line, "ASELSAN/BOOT7B")
                && !has_marker_tag(line, "ASELSAN/BOOT7C")
                && !has_marker_tag(line, "ASELSAN/BOOT7D")
                && !has_marker_tag(line, "ASELSAN/BOOT8")
                && !has_marker_tag(line, "ASELSAN/BOOT8B")
                && !has_marker_tag(line, "ASELSAN/BOOT8C")
                && !has_marker_tag(line, "ASELSAN/BOOT8D")
            {
                errors.push(format!(
                    "line {line_number}: unexpected milestone marker {line:?}"
                ));
            }
            None
        };

        if let Some(label) = label {
            sequence.push(label);
            *counts.get_mut(label).expect("known evidence label") += 1;
        }
    }

    for expected in EXPECTED_SEQUENCE {
        let count = counts[expected];
        if count != 1 {
            errors.push(format!(
                "marker {expected} must occur exactly once, observed {count}"
            ));
        }
    }
    if sequence != EXPECTED_SEQUENCE {
        errors.push(format!(
            "milestone order mismatch: expected {}, observed {}",
            EXPECTED_SEQUENCE.join(" -> "),
            sequence.join(" -> ")
        ));
    }

    validate_sec_samples(&sec_samples, &mut errors);

    match (start_ticks, end_ticks) {
        (Some(start), Some(end)) if end >= start => {
            let delta = end - start;
            if delta < 100 {
                errors.push(format!(
                    "timer progress is too short: start={start}, end={end}, delta={delta} (<100)"
                ));
            }
        }
        (Some(start), Some(end)) => {
            errors.push(format!("timer moved backwards: start={start}, end={end}"))
        }
        _ => {}
    }

    if errors.is_empty() {
        let start_ticks = start_ticks.expect("validated G7S0 has START_TICKS");
        let end_ticks = end_ticks.expect("validated BOOT7 has TICKS");
        Ok(G7aEvidence {
            start_ticks,
            end_ticks,
            sec_samples: sec_samples.len(),
        })
    } else {
        Err(ValidationError { messages: errors })
    }
}

#[test]
fn scheduler_contract_fields_are_enforced() {
    for (from, to, expected_error) in [
        ("FPEN=3", "FPEN=0", "field FPEN expected"),
        ("CPU=0", "CPU=1", "field CPU expected"),
        ("MODE=COOP", "MODE=PREEMPT", "field MODE expected"),
        ("TASKS=2", "TASKS=3", "field TASKS expected"),
        ("ORDER=ABAB", "ORDER=AABB", "field ORDER expected"),
        ("STEPS=4", "STEPS=3", "field STEPS expected"),
    ] {
        let messages = failure_messages(PASS.replacen(from, to, 1));
        assert!(
            has_message(&messages, expected_error),
            "missing {expected_error:?} for mutation {from:?} -> {to:?}: {messages:?}"
        );
    }
}

  {
    id: "rpi5-g7a-cooperative-scheduler-package-staged",
    date: "2026-08-20",
    sequence: 25,
    status: "partial",
    title: "RPi5 G7a CPU0 kooperatif scheduler paketi hazırlandı",
    summary:
      "G6 fiziksel BOOT6 sınırı korunarak yalnız CPU0'da iki EL1 kernel görevinin açık yield noktalarıyla A1→B1→A2→B2 sırasını kanıtlayacak G7a yolu hazırlandı. Kod, fail-closed UART doğrulayıcısı, tam test matrisi ve 3/3 paket bütünlüğü geçti; 50a802e7…b266 imajı henüz microSD'ye yazılmadığı ve gerçek Pi 5'te BOOT7 alınmadığı için kayıt staged/partial tutuluyor.",
    evidence: [
      "G7a yolu MPIDR_EL1.Aff0 üzerinden CPU=0'ı ve CPACR_EL1.FPEN=3 readback'ini doğruluyor; iki sabit EL1 kernel görevi MODE=COOP sözleşmesiyle başlatılıyor.",
      "Görev A ve B yalnız açık yield_now çağrılarıyla A1, B1, A2, B2 marker'larını üretir. Atomic sıra sayacı beklenmeyen adımda G7ERR ORDER ile, yanlış CPU/FPEN/tick veya tekrar BOOT7 durumlarında ayrı G7ERR nedenleriyle fail-closed durur.",
      "Başarı sözleşmesi ASELSAN/G7S0 CPU=0 MODE=COOP TASKS=2 FPEN=3 START_TICKS=<n>, dört G7S1 adımı ve en az 100 ek tick sonrasında ASELSAN/BOOT7 SCHED=OK ORDER=ABAB STEPS=4 TICKS=<m> zinciridir.",
      "RPi5 timer IRQ yolu scheduler_tick çağırmadan çalışmaya devam eder; bu nedenle staged paket timer-preemptive scheduler, EL0 veya secondary-core kanıtı değildir. BOOT0–BOOT6 marker'ları G7a validator zincirinde regresyon ön koşulu olarak korunur.",
      "cargo test --workspace toplam 37/37 PASS verdi: 4 simülasyon davranış testi, 14 erken bellek testi ve 19 G7a UART validator testi. Validator; sıra/tekillik, sözleşme alanları, en az 100 tick farkı, SEC tutarlılığı, bounded leading NUL ve yasaklı fault marker negatif vakalarını kapsıyor.",
      "Tam make verify exit 0 verdi; QEMU runtime ile QEMU, RPi4 ve RPi5 build/image kapıları birlikte geçti.",
      "Yeni aselsanos-rpi5.img 131264 bayt ve SHA-256 50a802e7b1e3a791bb4386c2812ed051b844e44817c99066a248f76adec1b266 olarak üretildi.",
      "Sabitlenmiş bcm2712-rpi-5-b.dtb 78703 bayt / 40a2fbe9c29e8b9a4912cf726a943068defb779fc052ec38e457a79c58abca00 ve config.txt 501 bayt / 1248275cdc6f6ce951ce0ff2183471d194c5b9bb58c3dc3f66efa9156f91d76b olarak kaldı; SHA256SUMS imaj, DTB ve config için 3/3 OK verdi.",
    ],
    commands: [
      "make verify",
      "cargo test --workspace",
      "cargo test -p aselsan_microkernel_simulation --test rpi5_g7a_uart",
      "make image-rpi5",
      "cd build/rpi5 && shasum -a 256 -c SHA256SUMS",
    ],
    limitations: [
      "50a802e7…b266 G7a paketi henüz fiziksel microSD'ye yazılmadı; kartta son doğrulanan 5630758c…f26b G6 paketi bulunuyor.",
      "G7S0, A1/B1/A2/B2 ve BOOT7 marker'ları gerçek Raspberry Pi 5 UART10 kaydında henüz gözlenmedi; G7a fiziksel PASS değildir.",
      "Bu dilim yalnız CPU0 üzerinde iki EL1 kernel görevinin kooperatif context-switch smoke kanıtını hedefler. Kernel stack lifecycle/deallocation ve gerçek guard izolasyonu kanıtlanmaz.",
      "G7b reserved-aware fiziksel sayfa yöneticisi, G7c EL0 hello/SVC/exit, G7d timer-preemptive scheduling ve G8 PSCI/SMP ayrı fiziksel kapılar olarak açık kalır.",
    ],
  },