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    idt[pic::vector_irq(12)].set_handler_fn(irq_raton);
58
59    let idt_estatica: &'static InterruptDescriptorTable = idt;
60    idt_estatica.load();
61}
62
63/// Registra el manejador de la IRQ del disco virtio-blk en la entrada de la IDT
64/// que corresponde a `irq` (Fase 6.2). Lo invoca el montaje del disco, una vez
65/// descubierta la linea de IRQ que el firmware le asigno.
66///
67/// Se llama durante el arranque secuencial, con las interrupciones aun
68/// desactivadas y la linea todavia enmascarada en el PIC: la entrada que se
69/// escribe no puede dispararse mientras se escribe.
70pub fn registrar_irq_disco(irq: u8) {
71    let vector = pic::vector_irq(irq);
72    VECTOR_DISCO.store(vector, Ordering::SeqCst);
73    // SEGURIDAD: el arranque es secuencial y de un solo hilo; las interrupciones
74    // estan desactivadas y la linea del disco, enmascarada. La IDT ya esta
75    // cargada (`init` hizo `lidt`), pero la CPU relee cada entrada en cada
76    // interrupcion: modificar esta entrada en memoria surte efecto de inmediato.
77    let idt: &'static mut InterruptDescriptorTable = unsafe { &mut *IDT.puntero() };
78    idt[vector].set_handler_fn(irq_disco);
79}
80
81// =============================================================================
82//  REFLEJOS DE EXCEPCION — las rutinas a las que la CPU salta ante cada fallo
83// =============================================================================
84
85/// #BP — Breakpoint. Excepcion RECUPERABLE: se atiende sin ruido y, al
86/// retornar, la CPU reanuda la ejecucion justo tras la instruccion `int3`.
87extern "x86-interrupt" fn reflejo_breakpoint(_marco: InterruptStackFrame) {}
88
89/// #UD — Opcode invalido. Fatal: la corriente de instrucciones es incoherente.
90extern "x86-interrupt" fn reflejo_opcode_invalido(marco: InterruptStackFrame) {
91    panic!("EXCEPCION FATAL :: opcode invalido (#UD)\n{marco:#?}");
92}
93
94/// #DE — Error de division. Fatal.
95extern "x86-interrupt" fn reflejo_division(marco: InterruptStackFrame) {
96    panic!("EXCEPCION FATAL :: error de division (#DE)\n{marco:#?}");
97}
98
99/// #GP — Fallo de proteccion general. Fatal.
100extern "x86-interrupt" fn reflejo_proteccion_general(marco: InterruptStackFrame, codigo: u64) {
101    panic!("EXCEPCION FATAL :: proteccion general (#GP) codigo={codigo:#x}\n{marco:#?}");
102}
103
104/// #PF — Fallo de pagina. Fatal en esta fase (sin memoria virtual dinamica).
105extern "x86-interrupt" fn reflejo_fallo_pagina(
106    marco: InterruptStackFrame,
107    codigo: PageFaultErrorCode,
108) {
109    let direccion = x86_64::registers::control::Cr2::read_raw();
110    panic!("EXCEPCION FATAL :: fallo de pagina (#PF) en {direccion:#x} {codigo:?}\n{marco:#?}");
111}
112
113/// #DF — Doble fallo. Fatal e irreversible: por definicion, diverge. Se ejecuta
114/// sobre el stack de emergencia del TSS, nunca sobre la pila comprometida.
115extern "x86-interrupt" fn reflejo_doble_fallo(marco: InterruptStackFrame, _codigo: u64) -> ! {
116    panic!("EXCEPCION FATAL :: doble fallo (#DF)\n{marco:#?}");
117}
118
119// =============================================================================
120//  IMPULSOS DE HARDWARE — productores de eventos para el reactor asincrono
121// =============================================================================
122
123/// IRQ0 — Temporizador. Desde la Fase 5 marca el compas del userspace: cada
124/// pulso avanza el `reloj` y despierta a las tareas que aguardaban su fotograma.
125extern "x86-interrupt" fn irq_temporizador(_marco: InterruptStackFrame) {
126    crate::async_system::reloj::pulso();
127    pic::fin_de_interrupcion(pic::VECTOR_TEMPORIZADOR);
128}
129
130/// IRQ1 — Teclado. Ya no escribe estado rustico: lee el scancode crudo y lo
131/// entrega al reactor asincrono, que despertara a la tarea del teclado.
132extern "x86-interrupt" fn irq_teclado(_marco: InterruptStackFrame) {
133    // SEGURIDAD: 0x60 es el puerto de datos del controlador PS/2, fijo en la
134    // arquitectura PC. Leerlo, ademas, libera al controlador para el siguiente.
135    let scancode: u8 = unsafe { x86_64::instructions::port::Port::new(0x60).read() };
136    crate::async_system::teclado::recibir_scancode(scancode);
137    pic::fin_de_interrupcion(pic::VECTOR_TECLADO);
138}
139
140/// IRQ12 — Raton PS/2 (Fase 13). Lee un byte del puerto de datos del 8042 —el
141/// mismo que sirve al teclado—; el ensamblador de paquetes del raton se ocupa
142/// de juntar tres bytes y entregar el evento al compositor.
143extern "x86-interrupt" fn irq_raton(_marco: InterruptStackFrame) {
144    // SEGURIDAD: 0x60 es el puerto de datos del 8042 en la arquitectura PC.
145    // Que la IRQ12 ha disparado garantiza que el byte es del raton, no del
146    // teclado: el controlador alza una linea distinta para cada dispositivo.
147    let byte: u8 = unsafe { x86_64::instructions::port::Port::new(0x60).read() };
148    crate::drivers::raton::recibir_byte(byte);
149    pic::fin_de_interrupcion(pic::vector_irq(12));
150}
151
152/// IRQ del disco — virtio-blk (Fase 6.2). El disco ha terminado una
153/// transferencia: `atender_irq` reconoce la interrupcion en el dispositivo
154/// —lo que libera su linea— y despierta a la tarea que aguardaba el bloque.
155/// Asi la E/S de disco deja de bloquear el planificador por sondeo.
156extern "x86-interrupt" fn irq_disco(_marco: InterruptStackFrame) {
157    crate::drivers::disco::atender_irq();
158    // El EOI se cierra DESPUES de reconocer al dispositivo: una IRQ legada de
159    // PCI es de nivel — anunciar el fin sin haber bajado la linea la reavivaria.
160    pic::fin_de_interrupcion(VECTOR_DISCO.load(Ordering::SeqCst));
161}