feat(renaser): Fase 7b — boot siembra la imagen, muere el include_bytes!
El kernel deja de empotrar el userspace por completo. Ya no carga ni un
solo .wasm: es boot quien siembra el disco con el grafo poblado.
- kernel/almacen.rs y manifiesto.rs migran al nucleo compartido `formato`
(tipos, postcard, BLAKE3, trazado de registros). El kernel pierde los
include_bytes!, genesis() y sembrar_genesis().
- boot::sembrar_grafo siembra un disco virgen con el bytecode de las apps
(deduplicado) y el Manifiesto de Genesis anclado en el superbloque.
- cargar_userspace sin rama de siembra; wasm/mod.rs sin TECHO_MEMORIA.
- alias `cargo kernel` -> --manifest-path (esquiva un ICE de cargo con
formato compartido entre el kernel y boot via artifact-dep).
Verificado en QEMU (screendump): disco virgen -> boot siembra 5 objetos,
el kernel monta su grafo; segundo arranque -> boot respeta el disco, la
cronista persiste. formato: 5/5 pruebas.
Nota: el crate `formato` y los 3 Cargo.toml entraron antes en 43e6b32 por
un `git add -A` de un trabajo concurrente; este commit cierra el resto.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
sergio
@@ -16,63 +16,27 @@
|
||||
// El disco se organiza como un LOG: el sector 0 es el superbloque —el ancla
|
||||
// del grafo—, y tras el se anexan los registros de objetos, uno tras otro. Un
|
||||
// indice en memoria (hash -> sector) se reconstruye al arrancar recorriendo el
|
||||
// log. La serializacion la hace `postcard`: binaria, compacta, determinista.
|
||||
// log.
|
||||
//
|
||||
// El FORMATO en disco —los tipos `Objeto`/`SuperBloque`, su (de)serializacion
|
||||
// `postcard`, el hash BLAKE3 y el trazado de cada registro— ya no vive aqui:
|
||||
// habita la crate `formato` (Fase 7b), un nucleo `no_std` COMPARTIDO con el
|
||||
// constructor de imagen `boot`. Este modulo es solo el almacen VIVO: el
|
||||
// cursor, el indice y la E/S contra el disco virtio-blk.
|
||||
// =============================================================================
|
||||
|
||||
use alloc::collections::BTreeMap;
|
||||
use alloc::vec;
|
||||
use alloc::vec::Vec;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use spin::{Mutex, Once};
|
||||
|
||||
use crate::drivers::disco::{self, TAM_SECTOR};
|
||||
use crate::drivers::disco;
|
||||
|
||||
/// Firma magica del superbloque — «RENASer GRaFo». Distingue un disco de
|
||||
/// renaser de uno virgen o ajeno.
|
||||
const MAGIA: [u8; 8] = *b"RENASGRF";
|
||||
|
||||
/// Version del formato en disco. Un disco con otra version se reformatea.
|
||||
/// v2 (Fase 7) — el superbloque gana el ancla `manifiesto`; un disco v1 se
|
||||
/// reformatea al arrancar, como cualquier disco ajeno.
|
||||
const VERSION: u32 = 2;
|
||||
|
||||
/// Techo del tamaño de un objeto serializado: 1 MiB. Acota los buferes de E/S
|
||||
/// y permite descartar un registro corrupto sin intentar leer un disparate.
|
||||
const MAX_OBJETO: usize = 1024 * 1024;
|
||||
|
||||
/// El identificador de un objeto: el hash BLAKE3 de su forma serializada. En un
|
||||
/// almacen direccionado por contenido, la identidad ES el contenido.
|
||||
pub type Hash = [u8; 32];
|
||||
|
||||
/// Un objeto del grafo: una carga util opaca y las aristas que lo enlazan con
|
||||
/// otros objetos. Los `hijos` hacen del almacen un DAG —no un arbol, no una
|
||||
/// lista—: un objeto puede ser hijo de muchos, y el direccionamiento por
|
||||
/// contenido garantiza que cada contenido distinto se guarda una sola vez.
|
||||
#[derive(Serialize, Deserialize, Clone)]
|
||||
pub struct Objeto {
|
||||
/// La carga util del objeto: bytes crudos, que el kernel no interpreta.
|
||||
pub datos: Vec<u8>,
|
||||
/// Los hashes de los objetos hijos: las aristas salientes del DAG.
|
||||
pub hijos: Vec<Hash>,
|
||||
}
|
||||
|
||||
/// El superbloque: el sector 0 del disco. Ancla el grafo entero — dice por
|
||||
/// donde continua el log, cual es el objeto raiz y cual el manifiesto.
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct SuperBloque {
|
||||
/// Firma magica: debe ser [`MAGIA`].
|
||||
magia: [u8; 8],
|
||||
/// Version del formato: debe ser [`VERSION`].
|
||||
version: u32,
|
||||
/// Proximo sector libre del log — donde se anexara el siguiente objeto.
|
||||
cursor: u64,
|
||||
/// El objeto raiz del DAG: el punto de entrada que el userspace fija y lee.
|
||||
raiz: Option<Hash>,
|
||||
/// El Manifiesto de Genesis (Fase 7): el objeto que dicta que apps nacen
|
||||
/// del grafo al arrancar. Ancla del kernel, gemela de `raiz` (del userspace).
|
||||
manifiesto: Option<Hash>,
|
||||
}
|
||||
// El identificador y el objeto del grafo los define `formato`; se reexportan
|
||||
// para que el resto del kernel siga nombrandolos `almacen::Hash` y
|
||||
// `almacen::Objeto`, sin enterarse de donde viven realmente.
|
||||
pub use formato::{Hash, Objeto};
|
||||
|
||||
/// El estado vivo del almacen: el cursor del log, la raiz, el manifiesto y el
|
||||
/// indice en memoria que traduce cada hash al sector donde habita su registro.
|
||||
@@ -104,12 +68,6 @@ pub struct Resumen {
|
||||
pub formateado: bool,
|
||||
}
|
||||
|
||||
/// Numero de sectores que ocupa un registro cuyo payload mide `longitud` bytes.
|
||||
/// Cada registro en disco es: `[longitud: u32 LE][payload postcard][relleno 0]`.
|
||||
fn sectores_registro(longitud: usize) -> u64 {
|
||||
(4 + longitud).div_ceil(TAM_SECTOR) as u64
|
||||
}
|
||||
|
||||
/// Funda el almacen de objetos: monta el disco, lee el superbloque y, si el
|
||||
/// disco ya es de renaser, reconstruye el indice recorriendo el log; si es
|
||||
/// virgen o ajeno, lo formatea. Toda falla se devuelve como `Err`.
|
||||
@@ -120,13 +78,13 @@ pub fn init() -> Result<Resumen, &'static str> {
|
||||
}
|
||||
|
||||
// Leer el sector 0 e intentar interpretarlo como superbloque de renaser.
|
||||
let mut sector0 = [0u8; TAM_SECTOR];
|
||||
let mut sector0 = [0u8; formato::TAM_SECTOR];
|
||||
disco::leer_sectores(0, &mut sector0)?;
|
||||
|
||||
let (cursor, raiz, manifiesto, indice, formateado) =
|
||||
match postcard::take_from_bytes::<SuperBloque>(§or0) {
|
||||
match formato::SuperBloque::deserializar(§or0) {
|
||||
// Disco de renaser, con la version corriente: adoptar su grafo.
|
||||
Ok((sb, _)) if sb.magia == MAGIA && sb.version == VERSION => {
|
||||
Ok(sb) if sb.magia == formato::MAGIA && sb.version == formato::VERSION_SUPERBLOQUE => {
|
||||
let indice = reconstruir_indice(sb.cursor)?;
|
||||
(sb.cursor, sb.raiz, sb.manifiesto, indice, false)
|
||||
}
|
||||
@@ -166,13 +124,11 @@ fn reconstruir_indice(cursor: u64) -> Result<BTreeMap<Hash, u64>, &'static str>
|
||||
let mut indice = BTreeMap::new();
|
||||
let mut sector: u64 = 1;
|
||||
while sector < cursor {
|
||||
let payload = leer_registro(sector)?;
|
||||
match payload {
|
||||
match leer_registro(sector)? {
|
||||
// Un payload valido: hashearlo e indexarlo.
|
||||
Some(payload) => {
|
||||
let n = sectores_registro(payload.len());
|
||||
let hash = *blake3::hash(&payload).as_bytes();
|
||||
indice.insert(hash, sector);
|
||||
let n = formato::sectores_registro(payload.len());
|
||||
indice.insert(formato::hash(&payload), sector);
|
||||
sector += n;
|
||||
}
|
||||
// Cabecera a cero o longitud imposible: fin (o corrupcion) del log.
|
||||
@@ -186,19 +142,18 @@ fn reconstruir_indice(cursor: u64) -> Result<BTreeMap<Hash, u64>, &'static str>
|
||||
/// (sin la cabecera de longitud ni el relleno). `None` si la cabecera dice
|
||||
/// longitud cero —fin del log— o una longitud imposible —corrupcion—.
|
||||
fn leer_registro(sector: u64) -> Result<Option<Vec<u8>>, &'static str> {
|
||||
let mut cabecera = [0u8; TAM_SECTOR];
|
||||
let mut cabecera = [0u8; formato::TAM_SECTOR];
|
||||
disco::leer_sectores(sector, &mut cabecera)?;
|
||||
let longitud =
|
||||
u32::from_le_bytes([cabecera[0], cabecera[1], cabecera[2], cabecera[3]]) as usize;
|
||||
if longitud == 0 || longitud > MAX_OBJETO {
|
||||
return Ok(None);
|
||||
}
|
||||
let n = sectores_registro(longitud) as usize;
|
||||
let longitud = match formato::longitud_registro(&cabecera) {
|
||||
Some(longitud) => longitud,
|
||||
None => return Ok(None),
|
||||
};
|
||||
let n = formato::sectores_registro(longitud) as usize;
|
||||
// Si el registro cabe en el sector ya leido, evitar una segunda lectura.
|
||||
let payload = if n == 1 {
|
||||
cabecera[4..4 + longitud].to_vec()
|
||||
} else {
|
||||
let mut buf = vec![0u8; n * TAM_SECTOR];
|
||||
let mut buf = vec![0u8; n * formato::TAM_SECTOR];
|
||||
disco::leer_sectores(sector, &mut buf)?;
|
||||
buf[4..4 + longitud].to_vec()
|
||||
};
|
||||
@@ -207,18 +162,18 @@ fn leer_registro(sector: u64) -> Result<Option<Vec<u8>>, &'static str> {
|
||||
|
||||
/// Graba el superbloque —el ancla del grafo— en el sector 0.
|
||||
fn persistir(almacen: &Almacen) -> Result<(), &'static str> {
|
||||
let sb = SuperBloque {
|
||||
magia: MAGIA,
|
||||
version: VERSION,
|
||||
let sb = formato::SuperBloque {
|
||||
magia: formato::MAGIA,
|
||||
version: formato::VERSION_SUPERBLOQUE,
|
||||
cursor: almacen.cursor,
|
||||
raiz: almacen.raiz,
|
||||
manifiesto: almacen.manifiesto,
|
||||
};
|
||||
let bytes = postcard::to_allocvec(&sb).map_err(|_| "no se pudo serializar el superbloque")?;
|
||||
if bytes.len() > TAM_SECTOR {
|
||||
let bytes = sb.serializar()?;
|
||||
if bytes.len() > formato::TAM_SECTOR {
|
||||
return Err("el superbloque no cabe en un sector");
|
||||
}
|
||||
let mut sector0 = [0u8; TAM_SECTOR];
|
||||
let mut sector0 = [0u8; formato::TAM_SECTOR];
|
||||
sector0[..bytes.len()].copy_from_slice(&bytes);
|
||||
disco::escribir_sectores(0, §or0)
|
||||
}
|
||||
@@ -228,13 +183,12 @@ fn persistir(almacen: &Almacen) -> Result<(), &'static str> {
|
||||
/// se devuelve el hash que ya tenia. El grafo nunca guarda dos veces lo mismo.
|
||||
pub fn almacenar(datos: Vec<u8>, hijos: Vec<Hash>) -> Result<Hash, &'static str> {
|
||||
let objeto = Objeto { datos, hijos };
|
||||
let bytes =
|
||||
postcard::to_allocvec(&objeto).map_err(|_| "no se pudo serializar el objeto")?;
|
||||
if bytes.is_empty() || bytes.len() > MAX_OBJETO {
|
||||
let bytes = objeto.serializar()?;
|
||||
if bytes.is_empty() || bytes.len() > formato::MAX_OBJETO {
|
||||
return Err("el objeto tiene un tamaño invalido");
|
||||
}
|
||||
// La identidad del objeto: el hash de su forma serializada.
|
||||
let hash = *blake3::hash(&bytes).as_bytes();
|
||||
let hash = formato::hash(&bytes);
|
||||
|
||||
let mutex = ALMACEN.get().ok_or("almacen no inicializado")?;
|
||||
let mut almacen = mutex.lock();
|
||||
@@ -245,16 +199,14 @@ pub fn almacenar(datos: Vec<u8>, hijos: Vec<Hash>) -> Result<Hash, &'static str>
|
||||
}
|
||||
|
||||
// Reservar los sectores del registro al final del log.
|
||||
let n = sectores_registro(bytes.len());
|
||||
let n = formato::sectores_registro(bytes.len());
|
||||
if almacen.cursor + n > almacen.capacidad {
|
||||
return Err("el grafo de objetos esta lleno");
|
||||
}
|
||||
let sector = almacen.cursor;
|
||||
|
||||
// Componer el registro: [longitud][payload][relleno a cero] y grabarlo.
|
||||
let mut registro = vec![0u8; n as usize * TAM_SECTOR];
|
||||
registro[0..4].copy_from_slice(&(bytes.len() as u32).to_le_bytes());
|
||||
registro[4..4 + bytes.len()].copy_from_slice(&bytes);
|
||||
// Componer el registro —[longitud][payload][relleno]— y grabarlo.
|
||||
let registro = formato::componer_registro(&bytes);
|
||||
disco::escribir_sectores(sector, ®istro)?;
|
||||
|
||||
// El objeto ya esta en disco: avanzar el cursor, indexarlo y RE-anclar el
|
||||
@@ -279,12 +231,10 @@ pub fn recuperar(hash: &Hash) -> Result<Option<Objeto>, &'static str> {
|
||||
let payload = leer_registro(sector)?.ok_or("registro de objeto corrupto")?;
|
||||
// Verificacion de integridad: el contenido leido DEBE rehashear al hash
|
||||
// pedido. Si no, el disco ha mentido — y se delata.
|
||||
if *blake3::hash(&payload).as_bytes() != *hash {
|
||||
if formato::hash(&payload) != *hash {
|
||||
return Err("el objeto no supero la verificacion de integridad");
|
||||
}
|
||||
let (objeto, _) = postcard::take_from_bytes::<Objeto>(&payload)
|
||||
.map_err(|_| "no se pudo deserializar el objeto")?;
|
||||
Ok(Some(objeto))
|
||||
Ok(Some(Objeto::deserializar(&payload)?))
|
||||
}
|
||||
|
||||
/// El hash del objeto raiz del grafo, si lo hay.
|
||||
@@ -309,6 +259,7 @@ pub fn manifiesto() -> Option<Hash> {
|
||||
|
||||
/// Ancla un objeto como el Manifiesto de Genesis y graba el cambio en el
|
||||
/// superbloque. Gemelo de [`fijar_raiz`].
|
||||
#[allow(dead_code)] // Lo usara la Fase 7c (persistencia inter-sesion).
|
||||
pub fn fijar_manifiesto(hash: Hash) -> Result<(), &'static str> {
|
||||
let mutex = ALMACEN.get().ok_or("almacen no inicializado")?;
|
||||
let mut almacen = mutex.lock();
|
||||
|
||||
+14
-18
@@ -134,7 +134,7 @@ async fn tarea_sonda_disco() {
|
||||
/// corrupto, o la carga fracasa, se salda pintando la region de la app con
|
||||
/// la baliza de desalojo — el kernel no se inmuta y sigue con las demas.
|
||||
fn encender_app(ejecutor: &mut Executor, entrada: &manifiesto::EntradaApp) {
|
||||
let region = entrada.region();
|
||||
let region = manifiesto::region(entrada);
|
||||
// Recuperar el bytecode del grafo. `recuperar` recomputa el hash del
|
||||
// objeto y verifica su integridad: un bytecode corrupto se delata aqui
|
||||
// —y la app se niega, no se instancia un modulo en el que no se confia.
|
||||
@@ -163,24 +163,20 @@ fn reportar(linea: &str) {
|
||||
}
|
||||
|
||||
/// FASE 7 :: puebla el userspace DESDE EL GRAFO. Carga el Manifiesto de
|
||||
/// Genesis; si el disco no tiene uno —disco virgen—, lo siembra y lo vuelve a
|
||||
/// cargar. Por cada `EntradaApp`, enciende su aplicacion. Toda falla se
|
||||
/// reporta a la consola y NO detiene el arranque: el kernel se levanta con
|
||||
/// las apps que pueda — o con ninguna, si el grafo no tiene userspace.
|
||||
/// Genesis que `boot` sembro en la imagen de disco y, por cada `EntradaApp`,
|
||||
/// enciende su aplicacion. Toda falla se reporta a la consola y NO detiene el
|
||||
/// arranque: el kernel se levanta con las apps que pueda — o con ninguna, si
|
||||
/// el grafo no tiene userspace.
|
||||
fn cargar_userspace(ejecutor: &mut Executor) {
|
||||
let manifiesto = match manifiesto::cargar() {
|
||||
Ok(Some(m)) => Some(m),
|
||||
// Disco sin manifiesto: sembrar la genesis y volver a cargarlo.
|
||||
Ok(None) => match manifiesto::sembrar_genesis() {
|
||||
Ok(_) => {
|
||||
reportar("manifiesto :: genesis sembrada en disco virgen");
|
||||
manifiesto::cargar().ok().flatten()
|
||||
}
|
||||
Err(motivo) => {
|
||||
reportar(&format!("manifiesto :: siembra fallida -- {motivo}"));
|
||||
None
|
||||
}
|
||||
},
|
||||
// Disco sin manifiesto anclado: `boot` no lo sembro. El kernel se
|
||||
// levanta sin userspace —pero se levanta—; en la practica, ninguna
|
||||
// imagen forjada por `boot` llega aqui sin su Manifiesto de Genesis.
|
||||
Ok(None) => {
|
||||
reportar("manifiesto :: el disco no trae uno -- el kernel se levanta solo");
|
||||
None
|
||||
}
|
||||
Err(motivo) => {
|
||||
reportar(&format!("manifiesto :: carga fallida -- {motivo}"));
|
||||
None
|
||||
@@ -333,10 +329,10 @@ fn kernel_main(boot_info: &'static mut BootInfo) -> ! {
|
||||
|
||||
// --- 7. FASE 7 :: levantar el reactor y poblar el userspace DESDE EL
|
||||
// GRAFO. El kernel ya no empotra los modulos WASM: lee el
|
||||
// Manifiesto de Genesis —si el disco esta virgen, lo siembra— e
|
||||
// Manifiesto de Genesis que `boot` sembro en la imagen de disco e
|
||||
// instancia cada `EntradaApp` recuperando su bytecode del grafo de
|
||||
// objetos. Las cinco apps de genesis (dos instancias de hello, la
|
||||
// discola, la glotona y la cronista) nacen ahora del disco, no del
|
||||
// discola, la glotona y la cronista) nacen del disco, no del
|
||||
// binario del kernel.
|
||||
//
|
||||
// Las interrupciones se habilitan AHORA: el temporizador marcara el
|
||||
|
||||
@@ -3,216 +3,54 @@
|
||||
// -----------------------------------------------------------------------------
|
||||
// Hasta la Fase 6, el userspace venia EMPOTRADO en el binario del kernel:
|
||||
// `include_bytes!` de cada `.wasm` y regiones escritas a mano. La Fase 7 lo
|
||||
// destierra: las aplicaciones pasan a ser OBJETOS DEL GRAFO, y lo que arranca
|
||||
// —con que cuota, en que region— lo dicta este Manifiesto de Genesis, que
|
||||
// tambien habita el grafo. El superbloque guarda su hash en un ancla propia.
|
||||
// desterro: las aplicaciones son OBJETOS DEL GRAFO, y lo que arranca —con que
|
||||
// cuota, en que region— lo dicta este Manifiesto de Genesis, que tambien
|
||||
// habita el grafo. El superbloque guarda su hash en un ancla propia.
|
||||
//
|
||||
// El kernel, al despertar: lee el ancla del superbloque, recupera el objeto
|
||||
// del manifiesto, lo deserializa, y por cada `EntradaApp` recupera el objeto
|
||||
// de bytecode —verificado por su hash— y lo inyecta en `wasmi`.
|
||||
// ESTADO: Fase 7b. El kernel ya NO empotra una sola app. La siembra de la
|
||||
// imagen —grabar los objetos de bytecode y el manifiesto en un disco virgen—
|
||||
// la hace por completo el constructor de imagen `boot`, en el anfitrion. Este
|
||||
// modulo se reduce a su esencia: LEER el manifiesto del grafo al arrancar.
|
||||
//
|
||||
// ESTADO: Fase 7a. Tipos, (de)serializacion, carga desde el grafo y siembra
|
||||
// de la genesis, implementados. La siembra es TRANSITORIA — el bytecode aun
|
||||
// viaja empotrado (`include_bytes!`, abajo); la Fase 7b lo movera al
|
||||
// constructor de imagen `boot` y el kernel dejara de empotrar una sola app.
|
||||
// Ver `FASE7.md` para el plan completo.
|
||||
// Los tipos `Manifiesto` / `EntradaApp` y su (de)serializacion viven en la
|
||||
// crate `formato`, el nucleo `no_std` compartido con `boot`. Aqui solo queda
|
||||
// lo que es del kernel: recuperar el manifiesto del grafo y traducir las
|
||||
// regiones de su formato en disco (`u32`) a la `RegionPantalla` del kernel.
|
||||
// =============================================================================
|
||||
|
||||
use alloc::string::String;
|
||||
use alloc::vec::Vec;
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::almacen::Hash;
|
||||
use crate::almacen;
|
||||
use crate::grafico::RegionPantalla;
|
||||
|
||||
/// Version del formato del manifiesto serializado. Independiente de la
|
||||
/// version del superbloque (`almacen::VERSION`): el manifiesto es un objeto
|
||||
/// del grafo, no una estructura de disco.
|
||||
pub const VERSION_MANIFIESTO: u32 = 1;
|
||||
// Los tipos del manifiesto los define `formato`; se reexportan para que el
|
||||
// resto del kernel los nombre `manifiesto::EntradaApp` / `manifiesto::Manifiesto`.
|
||||
pub use formato::{EntradaApp, Manifiesto};
|
||||
|
||||
/// El Manifiesto de Genesis: la lista de aplicaciones que el kernel instancia
|
||||
/// al arrancar. Vive como un objeto del grafo de objetos; el superbloque
|
||||
/// guarda su hash en el campo `manifiesto`.
|
||||
#[derive(Serialize, Deserialize, Clone)]
|
||||
pub struct Manifiesto {
|
||||
/// Version del formato — debe ser [`VERSION_MANIFIESTO`].
|
||||
pub version: u32,
|
||||
/// Las aplicaciones del userspace, en orden de arranque.
|
||||
pub apps: Vec<EntradaApp>,
|
||||
}
|
||||
|
||||
/// Una entrada del manifiesto: una aplicacion del userspace y todo lo que el
|
||||
/// kernel necesita para darle vida — su bytecode, su ventana, su cuota de
|
||||
/// memoria y, si lo tuviera, su ultimo estado persistido.
|
||||
#[derive(Serialize, Deserialize, Clone)]
|
||||
pub struct EntradaApp {
|
||||
/// Nombre legible — para los rotulos de la consola y la baliza.
|
||||
pub nombre: String,
|
||||
/// Hash del objeto del grafo que contiene el bytecode WASM de la app.
|
||||
pub bytecode: Hash,
|
||||
/// Sub-region del framebuffer asignada a la app. Campos de ancho fijo
|
||||
/// `u32` A PROPOSITO: esto es un formato EN DISCO. `RegionPantalla` usa
|
||||
/// `usize` (ancho dependiente de plataforma) y no sirve para serializar.
|
||||
pub region_x: u32,
|
||||
pub region_y: u32,
|
||||
pub region_ancho: u32,
|
||||
pub region_alto: u32,
|
||||
/// Techo de memoria lineal de la app, en bytes. Sustituye a la constante
|
||||
/// global `wasm::TECHO_MEMORIA` — cada app lleva su cuota.
|
||||
pub techo_memoria: u32,
|
||||
/// Hash del ultimo estado persistido de la app (Fase 7c). `None` hasta
|
||||
/// que la app guarde estado por primera vez.
|
||||
pub estado: Option<Hash>,
|
||||
}
|
||||
|
||||
impl EntradaApp {
|
||||
/// Construye la `RegionPantalla` que el kernel entiende a partir de los
|
||||
/// campos de ancho fijo del manifiesto.
|
||||
pub fn region(&self) -> RegionPantalla {
|
||||
RegionPantalla {
|
||||
x: self.region_x as usize,
|
||||
y: self.region_y as usize,
|
||||
ancho: self.region_ancho as usize,
|
||||
alto: self.region_alto as usize,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Manifiesto {
|
||||
/// Serializa el manifiesto a su forma binaria `postcard` — la carga util
|
||||
/// del objeto del grafo que lo aloja.
|
||||
pub fn serializar(&self) -> Result<Vec<u8>, &'static str> {
|
||||
postcard::to_allocvec(self).map_err(|_| "manifiesto :: serializacion fallida")
|
||||
}
|
||||
|
||||
/// Reconstruye un manifiesto desde la carga util de su objeto. Rechaza
|
||||
/// un formato de version desconocida en lugar de malinterpretarlo.
|
||||
pub fn deserializar(bytes: &[u8]) -> Result<Manifiesto, &'static str> {
|
||||
let (manifiesto, _) = postcard::take_from_bytes::<Manifiesto>(bytes)
|
||||
.map_err(|_| "manifiesto :: deserializacion fallida")?;
|
||||
if manifiesto.version != VERSION_MANIFIESTO {
|
||||
return Err("manifiesto :: version de formato desconocida");
|
||||
}
|
||||
Ok(manifiesto)
|
||||
/// Traduce la sub-region de una `EntradaApp` —campos `u32` de ancho fijo, el
|
||||
/// formato en disco— a la `RegionPantalla` que el kernel entiende (`usize`,
|
||||
/// ancho de plataforma). El puente entre lo que el disco guarda y lo que el
|
||||
/// compositor dibuja.
|
||||
pub fn region(entrada: &EntradaApp) -> RegionPantalla {
|
||||
RegionPantalla {
|
||||
x: entrada.region_x as usize,
|
||||
y: entrada.region_y as usize,
|
||||
ancho: entrada.region_ancho as usize,
|
||||
alto: entrada.region_alto as usize,
|
||||
}
|
||||
}
|
||||
|
||||
/// Lee el manifiesto del grafo: toma su hash del ancla del superbloque,
|
||||
/// recupera el objeto y lo deserializa. `Ok(None)` si el disco aun no tiene
|
||||
/// manifiesto anclado — el caller debe entonces sembrar la genesis.
|
||||
/// recupera el objeto y lo deserializa. `Ok(None)` si el disco no tiene
|
||||
/// manifiesto anclado —un disco que `boot` no sembro—; el kernel se levanta
|
||||
/// entonces sin userspace, pero se levanta.
|
||||
pub fn cargar() -> Result<Option<Manifiesto>, &'static str> {
|
||||
let hash = match crate::almacen::manifiesto() {
|
||||
let hash = match almacen::manifiesto() {
|
||||
Some(hash) => hash,
|
||||
None => return Ok(None),
|
||||
};
|
||||
// `recuperar` recomputa el hash del objeto y verifica su integridad: un
|
||||
// manifiesto corrupto se delata aqui.
|
||||
let objeto = crate::almacen::recuperar(&hash)?
|
||||
let objeto = almacen::recuperar(&hash)?
|
||||
.ok_or("manifiesto :: el objeto anclado no existe en el grafo")?;
|
||||
let manifiesto = Manifiesto::deserializar(&objeto.datos)?;
|
||||
Ok(Some(manifiesto))
|
||||
}
|
||||
|
||||
// =============================================================================
|
||||
// La genesis — la semilla transitoria de la Fase 7a
|
||||
// -----------------------------------------------------------------------------
|
||||
// El bytecode de las apps de genesis viaja, POR AHORA, empotrado en el kernel.
|
||||
// Es el unico `include_bytes!` que sobrevive a la Fase 7a — y solo como
|
||||
// semilla: en un disco virgen, `sembrar_genesis` lo graba en el grafo una vez.
|
||||
// La Fase 7b lo movera al constructor de imagen `boot` y este bloque morira.
|
||||
// =============================================================================
|
||||
|
||||
static APP_WASM: &[u8] = include_bytes!("../assets/app.wasm");
|
||||
static DISCOLA_WASM: &[u8] = include_bytes!("../assets/discola.wasm");
|
||||
static GLOTONA_WASM: &[u8] = include_bytes!("../assets/glotona.wasm");
|
||||
static CRONISTA_WASM: &[u8] = include_bytes!("../assets/cronista.wasm");
|
||||
|
||||
/// Descriptor de una app de genesis: lo que el kernel sabe de ella ANTES de
|
||||
/// que exista en el grafo. `region` es `(x, y, ancho, alto)` en pixeles.
|
||||
struct AppGenesis {
|
||||
nombre: &'static str,
|
||||
bytecode: &'static [u8],
|
||||
region: (u32, u32, u32, u32),
|
||||
techo_memoria: u32,
|
||||
}
|
||||
|
||||
/// El userspace de genesis: las cinco aplicaciones que pueblan un disco
|
||||
/// virgen, con las regiones de la Fase 6.2. `app.wasm` aparece dos veces
|
||||
/// —dos instancias del mismo bytecode—; el grafo, direccionado por contenido,
|
||||
/// lo guarda una sola vez.
|
||||
fn genesis() -> [AppGenesis; 5] {
|
||||
let techo = crate::wasm::TECHO_MEMORIA as u32;
|
||||
[
|
||||
AppGenesis {
|
||||
nombre: "hola-izq",
|
||||
bytecode: APP_WASM,
|
||||
region: (100, 120, 480, 560),
|
||||
techo_memoria: techo,
|
||||
},
|
||||
AppGenesis {
|
||||
nombre: "hola-der",
|
||||
bytecode: APP_WASM,
|
||||
region: (700, 120, 480, 560),
|
||||
techo_memoria: techo,
|
||||
},
|
||||
AppGenesis {
|
||||
nombre: "discola",
|
||||
bytecode: DISCOLA_WASM,
|
||||
region: (60, 700, 360, 80),
|
||||
techo_memoria: techo,
|
||||
},
|
||||
AppGenesis {
|
||||
nombre: "glotona",
|
||||
bytecode: GLOTONA_WASM,
|
||||
region: (460, 700, 360, 80),
|
||||
techo_memoria: techo,
|
||||
},
|
||||
AppGenesis {
|
||||
nombre: "cronista",
|
||||
bytecode: CRONISTA_WASM,
|
||||
region: (860, 700, 360, 80),
|
||||
techo_memoria: techo,
|
||||
},
|
||||
]
|
||||
}
|
||||
|
||||
/// Siembra el grafo en un disco sin manifiesto: graba el bytecode de cada app
|
||||
/// de genesis como un objeto, compone un `Manifiesto` con sus regiones y
|
||||
/// cuotas, lo graba —con las aristas hacia los objetos de bytecode— y lo
|
||||
/// ancla en el superbloque. Devuelve el hash del manifiesto recien anclado.
|
||||
pub fn sembrar_genesis() -> Result<Hash, &'static str> {
|
||||
let mut apps: Vec<EntradaApp> = Vec::new();
|
||||
let mut hijos: Vec<Hash> = Vec::new();
|
||||
|
||||
for app in genesis() {
|
||||
// Grabar el bytecode como objeto del grafo. Idempotente: dos
|
||||
// instancias de la misma app comparten un unico objeto.
|
||||
let bytecode = crate::almacen::almacenar(app.bytecode.to_vec(), Vec::new())?;
|
||||
if !hijos.contains(&bytecode) {
|
||||
hijos.push(bytecode);
|
||||
}
|
||||
let (x, y, ancho, alto) = app.region;
|
||||
apps.push(EntradaApp {
|
||||
nombre: String::from(app.nombre),
|
||||
bytecode,
|
||||
region_x: x,
|
||||
region_y: y,
|
||||
region_ancho: ancho,
|
||||
region_alto: alto,
|
||||
techo_memoria: app.techo_memoria,
|
||||
estado: None,
|
||||
});
|
||||
}
|
||||
|
||||
// El objeto del manifiesto: sus `hijos` son los objetos de bytecode, de
|
||||
// modo que el grafo lo lea como el nodo padre del userspace.
|
||||
let manifiesto = Manifiesto {
|
||||
version: VERSION_MANIFIESTO,
|
||||
apps,
|
||||
};
|
||||
let bytes = manifiesto.serializar()?;
|
||||
let hash = crate::almacen::almacenar(bytes, hijos)?;
|
||||
crate::almacen::fijar_manifiesto(hash)?;
|
||||
Ok(hash)
|
||||
}
|
||||
|
||||
@@ -32,15 +32,6 @@ const FUEL_ARRANQUE: u64 = 20_000_000;
|
||||
/// milisegundos y es desalojada. Este numero ES el techo temporal del userspace.
|
||||
const FUEL_FOTOGRAMA: u64 = 2_000_000;
|
||||
|
||||
/// Techo de memoria lineal por aplicacion: 4 MiB. Un modulo que intente crecer
|
||||
/// su memoria mas alla es desalojado — el aislamiento ESPACIAL del userspace,
|
||||
/// gemelo del techo TEMPORAL que impone el combustible.
|
||||
///
|
||||
/// Desde la Fase 7 el techo es POR-APP: cada `EntradaApp` del manifiesto
|
||||
/// lleva el suyo. Esta constante es el valor por DEFECTO — el que usan las
|
||||
/// apps de genesis (ver `manifiesto::genesis`).
|
||||
pub(crate) const TECHO_MEMORIA: usize = 4 * 1024 * 1024;
|
||||
|
||||
/// Por que el kernel da por terminada —desaloja— una aplicacion WASM.
|
||||
#[derive(Clone, Copy)]
|
||||
pub enum FallaApp {
|
||||
|
||||
Reference in New Issue
Block a user