tawasuyu/brahman

1// =============================================================================
2//  renaser :: kernel/src/interrupts.rs — Fase 2/3 :: la IDT y los reflejos
3// -----------------------------------------------------------------------------
4//  La Interrupt Descriptor Table es la tabla de reflejos del procesador. ante
5//  cada excepcion o IRQ, la CPU abandona lo que hacia y salta a la entrada que
6//  le corresponde. renaser distingue tres naturalezas de impulso:
7//
8//    * RECUPERABLE — el breakpoint (#BP): se atiende y la ejecucion prosigue.
9//    * FATAL       — el resto de excepciones: se entregan al `panic!`.
10//    * HARDWARE    — temporizador, teclado y disco: ya NO escriben estado
11//                    rustico, sino que alimentan el reactor asincrono.
12// =============================================================================
13
14use core::sync::atomic::{AtomicU8, Ordering};
15
16use x86_64::structures::idt::{InterruptDescriptorTable, InterruptStackFrame, PageFaultErrorCode};
17
18use crate::{gdt, pic, CeldaSync};
19
20/// La Interrupt Descriptor Table propia de renaser.
21static IDT: CeldaSync<InterruptDescriptorTable> =
22    CeldaSync::nueva(InterruptDescriptorTable::new());
23
24/// Vector de la IDT asignado a la IRQ del disco. Vale 0 hasta que el montaje
25/// del disco (Fase 6.2) descubra su linea de IRQ y la registre — ninguna IRQ
26/// legitima del disco vive en el vector 0 (reservado a las excepciones).
27static VECTOR_DISCO: AtomicU8 = AtomicU8::new(0);
28
29/// Construye y activa la Interrupt Descriptor Table.
30///
31/// Debe invocarse una sola vez, durante el arranque, DESPUES de [`gdt::init`].
32pub fn init() {
33    // SEGURIDAD: `init` corre una sola vez, en arranque secuencial de un solo
34    // hilo; nada mas referencia la IDT todavia.
35    let idt: &'static mut InterruptDescriptorTable = unsafe { &mut *IDT.puntero() };
36
37    // --- Excepciones de CPU ---
38    idt.breakpoint.set_handler_fn(reflejo_breakpoint);
39    idt.invalid_opcode.set_handler_fn(reflejo_opcode_invalido);
40    idt.divide_error.set_handler_fn(reflejo_division);
41    idt.general_protection_fault
42        .set_handler_fn(reflejo_proteccion_general);
43    idt.page_fault.set_handler_fn(reflejo_fallo_pagina);
44
45    // El doble fallo se atiende SIEMPRE sobre el stack de emergencia del TSS:
46    // ni un desbordamiento de la pila del kernel impedira su diagnostico.
47    // SEGURIDAD: el indice IST referido fue armado previamente por `gdt::init`.
48    unsafe {
49        idt.double_fault
50            .set_handler_fn(reflejo_doble_fallo)
51            .set_stack_index(gdt::IST_DOBLE_FALLO);
52    }
53
54    // --- Interrupciones de hardware, ya remapeadas por el PIC ---
55    idt[pic::VECTOR_TEMPORIZADOR].set_handler_fn(irq_temporizador);
56    idt[pic::VECTOR_TECLADO].set_handler_fn(irq_teclado);
57
58    let idt_estatica: &'static InterruptDescriptorTable = idt;
59    idt_estatica.load();
60}
61
62/// Registra el manejador de la IRQ del disco virtio-blk en la entrada de la IDT
63/// que corresponde a `irq` (Fase 6.2). Lo invoca el montaje del disco, una vez
64/// descubierta la linea de IRQ que el firmware le asigno.
65///
66/// Se llama durante el arranque secuencial, con las interrupciones aun
67/// desactivadas y la linea todavia enmascarada en el PIC: la entrada que se
68/// escribe no puede dispararse mientras se escribe.
69pub fn registrar_irq_disco(irq: u8) {
70    let vector = pic::vector_irq(irq);
71    VECTOR_DISCO.store(vector, Ordering::SeqCst);
72    // SEGURIDAD: el arranque es secuencial y de un solo hilo; las interrupciones
73    // estan desactivadas y la linea del disco, enmascarada. La IDT ya esta
74    // cargada (`init` hizo `lidt`), pero la CPU relee cada entrada en cada
75    // interrupcion: modificar esta entrada en memoria surte efecto de inmediato.
76    let idt: &'static mut InterruptDescriptorTable = unsafe { &mut *IDT.puntero() };
77    idt[vector].set_handler_fn(irq_disco);
78}
79
80// =============================================================================
81//  REFLEJOS DE EXCEPCION — las rutinas a las que la CPU salta ante cada fallo
82// =============================================================================
83
84/// #BP — Breakpoint. Excepcion RECUPERABLE: se atiende sin ruido y, al
85/// retornar, la CPU reanuda la ejecucion justo tras la instruccion `int3`.
86extern "x86-interrupt" fn reflejo_breakpoint(_marco: InterruptStackFrame) {}
87
88/// #UD — Opcode invalido. Fatal: la corriente de instrucciones es incoherente.
89extern "x86-interrupt" fn reflejo_opcode_invalido(marco: InterruptStackFrame) {
90    panic!("EXCEPCION FATAL :: opcode invalido (#UD)\n{marco:#?}");
91}
92
93/// #DE — Error de division. Fatal.
94extern "x86-interrupt" fn reflejo_division(marco: InterruptStackFrame) {
95    panic!("EXCEPCION FATAL :: error de division (#DE)\n{marco:#?}");
96}
97
98/// #GP — Fallo de proteccion general. Fatal.
99extern "x86-interrupt" fn reflejo_proteccion_general(marco: InterruptStackFrame, codigo: u64) {
100    panic!("EXCEPCION FATAL :: proteccion general (#GP) codigo={codigo:#x}\n{marco:#?}");
101}
102
103/// #PF — Fallo de pagina. Fatal en esta fase (sin memoria virtual dinamica).
104extern "x86-interrupt" fn reflejo_fallo_pagina(
105    marco: InterruptStackFrame,
106    codigo: PageFaultErrorCode,
107) {
108    let direccion = x86_64::registers::control::Cr2::read_raw();
109    panic!("EXCEPCION FATAL :: fallo de pagina (#PF) en {direccion:#x} {codigo:?}\n{marco:#?}");
110}
111
112/// #DF — Doble fallo. Fatal e irreversible: por definicion, diverge. Se ejecuta
113/// sobre el stack de emergencia del TSS, nunca sobre la pila comprometida.
114extern "x86-interrupt" fn reflejo_doble_fallo(marco: InterruptStackFrame, _codigo: u64) -> ! {
115    panic!("EXCEPCION FATAL :: doble fallo (#DF)\n{marco:#?}");
116}
117
118// =============================================================================
119//  IMPULSOS DE HARDWARE — productores de eventos para el reactor asincrono
120// =============================================================================
121
122/// IRQ0 — Temporizador. Desde la Fase 5 marca el compas del userspace: cada
123/// pulso avanza el `reloj` y despierta a las tareas que aguardaban su fotograma.
124extern "x86-interrupt" fn irq_temporizador(_marco: InterruptStackFrame) {
125    crate::async_system::reloj::pulso();
126    pic::fin_de_interrupcion(pic::VECTOR_TEMPORIZADOR);
127}
128
129/// IRQ1 — Teclado. Ya no escribe estado rustico: lee el scancode crudo y lo
130/// entrega al reactor asincrono, que despertara a la tarea del teclado.
131extern "x86-interrupt" fn irq_teclado(_marco: InterruptStackFrame) {
132    // SEGURIDAD: 0x60 es el puerto de datos del controlador PS/2, fijo en la
133    // arquitectura PC. Leerlo, ademas, libera al controlador para el siguiente.
134    let scancode: u8 = unsafe { x86_64::instructions::port::Port::new(0x60).read() };
135    crate::async_system::teclado::recibir_scancode(scancode);
136    pic::fin_de_interrupcion(pic::VECTOR_TECLADO);
137}
138
139/// IRQ del disco — virtio-blk (Fase 6.2). El disco ha terminado una
140/// transferencia: `atender_irq` reconoce la interrupcion en el dispositivo
141/// —lo que libera su linea— y despierta a la tarea que aguardaba el bloque.
142/// Asi la E/S de disco deja de bloquear el planificador por sondeo.
143extern "x86-interrupt" fn irq_disco(_marco: InterruptStackFrame) {
144    crate::drivers::disco::atender_irq();
145    // El EOI se cierra DESPUES de reconocer al dispositivo: una IRQ legada de
146    // PCI es de nivel — anunciar el fin sin haber bajado la linea la reavivaria.
147    pic::fin_de_interrupcion(VECTOR_DISCO.load(Ordering::SeqCst));
148}