i686: fix kernel.sym build

kernel/libk/src/module.rs

@@ -70,12 +70,12 @@ pub fn load_kernel_symbol_table<P: AsRef<Path>>(
         if symbol_file.read(&mut len)? != len.len() {
             break;
         }
-        let len = usize::from_le_bytes(len);
+        let len = u32::from_le_bytes(len) as usize;
         symbol_file.read_exact(&mut string_buffer[..len])?;
         let name = core::str::from_utf8(&string_buffer[..len]).unwrap();
-        let mut value = [0; size_of::<usize>()];
+        let mut value = [0; size_of::<u64>()];
         symbol_file.read_exact(&mut value)?;
-        let value = usize::from_le_bytes(value);
+        let value = u64::from_le_bytes(value).try_into().unwrap();
         map.insert(name.into(), value);
     }
 

kernel/tools/gentables/src/main.rs

@@ -9,7 +9,7 @@ use std::{
 
 use clap::Parser;
 use elf::{
-    abi::{EM_AARCH64, EM_X86_64, PT_LOAD},
+    abi::{EM_386, EM_AARCH64, EM_X86_64, PT_LOAD},
     endian::AnyEndian,
     ElfStream,
 };
@@ -193,9 +193,15 @@ fn into_any<T: Into<AnyTables>, U, V>((x, y, z): (T, U, V)) -> (AnyTables, U, V)
 
 fn build_tables<F: Read + Seek>(
     file: F,
-) -> Result<(AnyTables, u64, HashMap<String, usize>), GenError> {
+) -> Result<(Option<(AnyTables, u64)>, HashMap<String, usize>), GenError> {
     let mut elf = ElfStream::<AnyEndian, F>::open_stream(file)?;
 
+    if elf.ehdr.e_machine == EM_386 {
+        // Locate symbol table
+        let symbol_table = extract_symbols(&mut elf)?;
+        return Ok((None, symbol_table));
+    }
+
     let kernel_virt_offset = kernel_virt_offset(&mut elf)?;
     let (kernel_start, kernel_end) = kernel_image_range(&mut elf, kernel_virt_offset)?;
     let (table_offset, table_virt_addr) = find_tables(&mut elf)?;
@@ -206,7 +212,7 @@ fn build_tables<F: Read + Seek>(
     println!("Kernel image range: {:#x?}", kernel_start..kernel_end);
     println!("KERNEL_VIRT_OFFSET = {:#x}", kernel_virt_offset);
 
-    match elf.ehdr.e_machine {
+    let (tables, table_offset, symbol_table) = match elf.ehdr.e_machine {
         EM_X86_64 => X8664Builder::new(
             elf,
             GenData {
@@ -232,7 +238,9 @@ fn build_tables<F: Read + Seek>(
         .build()
         .map(into_any),
         _ => todo!(),
-    }
+    }?;
+
+    Ok((Some((tables, table_offset)), symbol_table))
 }
 
 fn write_tables<F: Write + Seek>(
@@ -252,7 +260,10 @@ fn write_symbol_table(
     let mut file = File::create(out)?;
 
     for (name, value) in table {
-        file.write_all(&name.len().to_le_bytes())?;
+        let len: u32 = name.len().try_into().unwrap();
+        let value: u64 = value.try_into().unwrap();
+
+        file.write_all(&len.to_le_bytes())?;
         file.write_all(name.as_bytes())?;
         file.write_all(&value.to_le_bytes())?;
     }
@@ -267,9 +278,11 @@ fn gentables(image: impl AsRef<Path>, symbol_out: impl AsRef<Path>) -> Result<()
         .truncate(false)
         .open(image)?;
 
-    let (tables, file_offset, symbol_table) = build_tables(&mut file)?;
+    let (tables, symbol_table) = build_tables(&mut file)?;
     write_symbol_table(symbol_out, symbol_table)?;
-    write_tables(file, file_offset, tables)?;
+    if let Some((tables, file_offset)) = tables {
+        write_tables(file, file_offset, tables)?;
+    }
 
     Ok(())
 }

xtask/src/build/mod.rs

@@ -83,10 +83,8 @@ pub fn build_all(env: BuildEnv) -> Result<AllBuilt, Error> {
     // Kernel stuff
     let tools = build_kernel_tools(&env, check)?;
     let kernel = build_kernel(&env, check)?;
-    let kernel = match env.arch {
-        Arch::i686 => KernelProcessed(kernel),
-        _ => generate_kernel_tables(&env.kernel_symbol_file, kernel, tools)?,
-    };
+    let kernel = generate_kernel_tables(&env.kernel_symbol_file, kernel, tools)?;
+
     let modules = match env.arch {
         Arch::i686 => Vec::new(),
         _ => build_modules(&env, env.workspace_root.join("kernel/modules"))?,

xtask/src/build/userspace.rs

@@ -113,7 +113,7 @@ fn build_rootfs<S: AsRef<Path>, D: AsRef<Path>>(
         util::copy_file(src, rootfs_dir.join(dst))?;
     }
 
-    // util::copy_file(&env.kernel_symbol_file, rootfs_dir.join("kernel.sym"))?;
+    util::copy_file(&env.kernel_symbol_file, rootfs_dir.join("kernel.sym"))?;
 
     // Copy /etc
     util::copy_dir_recursive(user_dir.join("etc"), rootfs_dir.join("etc"))?;