Make kmod potentially work

Author: bbqsrc

Cargo.lock

@@ -11,36 +11,70 @@ repository = "https://github.com/bbqsrc/box"
 crate-type = ["rlib"]
 
 [dependencies]
+# Core dependencies (no_std compatible)
 box-fst.workspace = true
 byteorder.workspace = true
-mmap-io.workspace = true
-tokio = { workspace = true, features = ["fs", "io-util", "sync"] }
-tokio-util = { workspace = true, features = ["compat"] }
-async-walkdir.workspace = true
-futures.workspace = true
-blake3 = { workspace = true, features = ["traits-preview", "rayon", "mmap"] }
-hex.workspace = true
-pathdiff.workspace = true
-unic-normal.workspace = true
-unic-ucd.workspace = true
-relative-path.workspace = true
-fastvint = { workspace = true, features = ["async-tokio"] }
-tracing.workspace = true
-serde_json.workspace = true
-lru.workspace = true
-thiserror.workspace = true
-digest.workspace = true
-sysinfo.workspace = true
-tempfile.workspace = true
-string-interner.workspace = true
+fastvint.workspace = true
+hashbrown = "0.15"
+
+# Std-only dependencies
+mmap-io = { workspace = true, optional = true }
+tokio = { workspace = true, features = ["fs", "io-util", "sync"], optional = true }
+tokio-util = { workspace = true, features = ["compat"], optional = true }
+async-walkdir = { workspace = true, optional = true }
+futures = { workspace = true, optional = true }
+blake3 = { workspace = true, features = ["traits-preview", "rayon", "mmap"], optional = true }
+hex = { workspace = true, optional = true }
+pathdiff = { workspace = true, optional = true }
+unic-normal = { workspace = true, optional = true }
+unic-ucd = { workspace = true, optional = true }
+relative-path = { workspace = true, optional = true }
+tracing = { workspace = true, optional = true }
+serde_json = { workspace = true, optional = true }
+lru = { workspace = true, optional = true }
+thiserror = { workspace = true, optional = true }
+digest = { workspace = true, optional = true }
+sysinfo = { workspace = true, optional = true }
+tempfile = { workspace = true, optional = true }
+string-interner = { workspace = true, optional = true }
 xattr = { workspace = true, optional = true }
 zstd = { workspace = true, optional = true }
 zstd-safe = { workspace = true, optional = true }
 xz2 = { workspace = true, optional = true }
 
 [features]
-default = ["xz", "zstd", "writer", "reader", "xattr"]
-reader = []
+default = ["std", "xz", "zstd", "writer", "reader", "xattr"]
+
+# no_std support
+std = [
+    "alloc",
+    "box-fst/std",
+    "dep:mmap-io",
+    "dep:tokio",
+    "dep:tokio-util",
+    "dep:async-walkdir",
+    "dep:futures",
+    "dep:blake3",
+    "dep:hex",
+    "dep:pathdiff",
+    "dep:unic-normal",
+    "dep:unic-ucd",
+    "dep:relative-path",
+    "dep:tracing",
+    "dep:serde_json",
+    "dep:lru",
+    "dep:thiserror",
+    "dep:digest",
+    "dep:sysinfo",
+    "dep:tempfile",
+    "dep:string-interner",
+]
+alloc = ["box-fst/alloc"]
+
+# Minimal kernel build (core parsing only)
+kernel = ["alloc"]
+
+reader = ["std"]
 writer = ["reader"]
 
 xz = ["dep:xz2"]
@@ -50,6 +84,7 @@ xattr = ["dep:xattr"]
 [workspace]
 resolver = "3"
 members = ["cli", "crates/*"]
+exclude = ["kmod/rust"]
 
 [workspace.dependencies]
 # Shared dependencies
@@ -120,5 +155,5 @@ block2 = "0.6"
 
 # Workspace crates
 box-format = { version = "0.4.0", path = "." }
-box-fst = { version = "0.1.0", path = "crates/fst" }
+box-fst = { version = "0.1.0", path = "crates/fst", default-features = false }
 mimalloc = { version = "0.1", features = ["v3"] }

Cargo.toml

@@ -5,9 +5,14 @@ edition = "2024"
 license = "Apache-2.0 OR MIT"
 description = "A radix tree that serializes as an FST for fast path lookups"
 
+[features]
+default = ["std"]
+std = ["alloc"]
+alloc = []
+
 [dependencies]
-thiserror.workspace = true
 fastvint.workspace = true
+hashbrown = "0.15"
 
 [dev-dependencies]
 criterion = "0.5"

crates/fst/Cargo.toml

@@ -1,3 +1,11 @@
+#[cfg(feature = "alloc")]
+use alloc::{collections::VecDeque, vec::Vec};
+
+use core::cmp::Ordering;
+use core::mem::take;
+
+use hashbrown::{HashMap, HashSet};
+
 use crate::error::BuildError;
 use crate::node::{
     EdgeData, HEADER_SIZE, Header, INDEX_ENTRY_SIZE, INDEXED_THRESHOLD, NodeData, NodeIndex,
@@ -44,9 +52,9 @@ impl FstBuilder {
         // Validate ordering
         if let Some(ref last) = self.last_key {
             match key.cmp(last.as_slice()) {
-                std::cmp::Ordering::Less => return Err(BuildError::OutOfOrder),
-                std::cmp::Ordering::Equal => return Err(BuildError::DuplicateKey),
-                std::cmp::Ordering::Greater => {}
+                Ordering::Less => return Err(BuildError::OutOfOrder),
+                Ordering::Equal => return Err(BuildError::DuplicateKey),
+                Ordering::Greater => {}
             }
         }
 
@@ -182,8 +190,8 @@ impl FstBuilder {
                     Self::insert_into_node(&mut edge.target, &key[common_len..], value);
                 } else {
                     // Need to split the edge
-                    let old_label = std::mem::take(&mut edge.label);
-                    let old_target = std::mem::take(&mut edge.target);
+                    let old_label = take(&mut edge.label);
+                    let old_target = take(&mut edge.target);
 
                     // Create new intermediate node
                     let mut intermediate = BuilderNode::default();
@@ -240,12 +248,12 @@ impl FstBuilder {
     /// Collect nodes breadth-first for better cache locality.
     /// Returns the root node ID (always 0 in BFS order).
     fn collect_nodes(&self, root: &BuilderNode, nodes: &mut Vec<NodeData>) -> u32 {
-        use std::collections::VecDeque;
+        use VecDeque;
 
         // Phase 1: Assign node IDs in BFS order
         // Map from node pointer to assigned ID
-        let mut node_ids: std::collections::HashMap<*const BuilderNode, u32> =
-            std::collections::HashMap::new();
+        let mut node_ids: HashMap<*const BuilderNode, u32> =
+            HashMap::new();
         let mut queue: VecDeque<&BuilderNode> = VecDeque::new();
 
         queue.push_back(root);
@@ -267,8 +275,8 @@ impl FstBuilder {
 
         // Phase 2: Build NodeData in BFS order
         queue.push_back(root);
-        let mut visited: std::collections::HashSet<*const BuilderNode> =
-            std::collections::HashSet::new();
+        let mut visited: HashSet<*const BuilderNode> =
+            HashSet::new();
 
         while let Some(node) = queue.pop_front() {
             let ptr = node as *const BuilderNode;

crates/fst/src/builder.rs

@@ -1,31 +1,60 @@
-use thiserror::Error;
+use core::fmt;
 
-#[derive(Debug, Error)]
+#[derive(Debug)]
 pub enum BuildError {
-    #[error("keys must be inserted in lexicographic order")]
     OutOfOrder,
-
-    #[error("duplicate key")]
     DuplicateKey,
-
-    #[error("FST is empty (no keys inserted)")]
     Empty,
+    #[cfg(feature = "std")]
+    Io(std::io::Error),
+}
+
+impl fmt::Display for BuildError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            BuildError::OutOfOrder => write!(f, "keys must be inserted in lexicographic order"),
+            BuildError::DuplicateKey => write!(f, "duplicate key"),
+            BuildError::Empty => write!(f, "FST is empty (no keys inserted)"),
+            #[cfg(feature = "std")]
+            BuildError::Io(e) => write!(f, "I/O error: {}", e),
+        }
+    }
+}
+
+impl core::error::Error for BuildError {
+    fn source(&self) -> Option<&(dyn core::error::Error + 'static)> {
+        match self {
+            #[cfg(feature = "std")]
+            BuildError::Io(e) => Some(e),
+            _ => None,
+        }
+    }
+}
 
-    #[error("I/O error: {0}")]
-    Io(#[from] std::io::Error),
+#[cfg(feature = "std")]
+impl From<std::io::Error> for BuildError {
+    fn from(e: std::io::Error) -> Self {
+        BuildError::Io(e)
+    }
 }
 
-#[derive(Debug, Error)]
+#[derive(Debug)]
 pub enum FstError {
-    #[error("invalid magic bytes")]
     InvalidMagic,
-
-    #[error("unsupported version: {0}")]
     UnsupportedVersion(u8),
-
-    #[error("data too short")]
     TooShort,
-
-    #[error("corrupted data")]
     Corrupted,
 }
+
+impl fmt::Display for FstError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            FstError::InvalidMagic => write!(f, "invalid magic bytes"),
+            FstError::UnsupportedVersion(v) => write!(f, "unsupported version: {}", v),
+            FstError::TooShort => write!(f, "data too short"),
+            FstError::Corrupted => write!(f, "corrupted data"),
+        }
+    }
+}
+
+impl core::error::Error for FstError {}

crates/fst/src/error.rs

@@ -1,3 +1,6 @@
+#[cfg(feature = "alloc")]
+use alloc::vec::Vec;
+
 use crate::error::FstError;
 use crate::node::{HEADER_SIZE, Header, INDEX_ENTRY_SIZE, NodeIndex, NodeRef, read_header};
 
@@ -6,11 +9,11 @@ use crate::node::{HEADER_SIZE, Header, INDEX_ENTRY_SIZE, NodeIndex, NodeRef, rea
 fn prefetch_read(ptr: *const u8) {
     #[cfg(target_arch = "aarch64")]
     unsafe {
-        std::arch::asm!("prfm pldl1keep, [{ptr}]", ptr = in(reg) ptr, options(nostack, preserves_flags));
+        core::arch::asm!("prfm pldl1keep, [{ptr}]", ptr = in(reg) ptr, options(nostack, preserves_flags));
     }
     #[cfg(all(target_arch = "x86_64", target_feature = "sse"))]
     unsafe {
-        std::arch::x86_64::_mm_prefetch(ptr as *const i8, std::arch::x86_64::_MM_HINT_T0);
+        core::arch::x86_64::_mm_prefetch(ptr as *const i8, core::arch::x86_64::_MM_HINT_T0);
     }
 }
 
@@ -38,7 +41,7 @@ fn fast_eq(a: &[u8], b: &[u8]) -> bool {
 #[cfg(all(target_arch = "aarch64", target_feature = "neon"))]
 #[inline]
 fn fast_eq_simd_neon(a: &[u8], b: &[u8]) -> bool {
-    use std::arch::aarch64::*;
+    use core::arch::aarch64::*;
 
     unsafe {
         let mut i = 0;
@@ -64,7 +67,7 @@ fn fast_eq_simd_neon(a: &[u8], b: &[u8]) -> bool {
 #[cfg(all(target_arch = "x86_64", target_feature = "sse2"))]
 #[inline]
 fn fast_eq_simd_sse2(a: &[u8], b: &[u8]) -> bool {
-    use std::arch::x86_64::*;
+    use core::arch::x86_64::*;
 
     unsafe {
         let mut i = 0;

crates/fst/src/fst.rs

@@ -1,8 +1,15 @@
+#![cfg_attr(not(feature = "std"), no_std)]
+
+#[cfg(feature = "alloc")]
+extern crate alloc;
+
+#[cfg(feature = "std")]
 mod builder;
 mod error;
 mod fst;
 mod node;
 
+#[cfg(feature = "std")]
 pub use builder::FstBuilder;
 pub use error::{BuildError, FstError};
 pub use fst::{Fst, PrefixIter};