Add exec() builtin function for executing Python scripts.

This commit introduces the exec() function, allowing users to replace the current process with a Python script while inheriting eBPF maps. It includes validation for the argument type and generates a corresponding Python wrapper for seamless integration.

Signed-off-by: Cong Wang <cwang@multikernel.io>

Author: congwang-mk

examples/python_demo.py

@@ -0,0 +1,110 @@
+#!/usr/bin/env python3
+"""
+Demo Python Script - Called via exec() from KernelScript
+
+This script demonstrates the CORRECT usage pattern:
+- Import the auto-generated wrapper (test_exec.py) 
+- Use maps directly as module-level variables
+"""
+
+import sys
+
+# Import the auto-generated KernelScript wrapper
+# The wrapper handles all the file descriptor inheritance internally
+try:
+    import test_exec as ks
+except ImportError:
+    print("❌ Error: Could not import test_exec.py", file=sys.stderr)
+    print("   Make sure the KernelScript wrapper was generated correctly", file=sys.stderr)
+    sys.exit(1)
+
+def main():
+    """Main function - called via exec() from KernelScript"""
+    print("🚀 KernelScript Python Integration Demo")
+    print("=" * 40)
+    
+    # 1. Reading from maps
+    print("\n📖 Reading from eBPF maps:")
+    try:
+        # Read from array map
+        value = ks.packet_stats[0]
+        print(f"   packet_stats[0] = {value}")
+        
+        value = ks.packet_stats[5]
+        print(f"   packet_stats[5] = {value}")
+    except Exception as e:
+        print(f"   packet_stats read: {e}")
+    
+    try:
+        # Read from hash map  
+        value = ks.bandwidth_usage[1]
+        print(f"   bandwidth_usage[1] = {value}")
+    except Exception as e:
+        print(f"   bandwidth_usage read: {e}")
+    
+    # 2. Writing to maps
+    print("\n✏️ Writing to eBPF maps:")
+    try:
+        # Write to array map
+        ks.packet_stats[0] = 100
+        ks.packet_stats[1] = 200
+        print("   packet_stats[0] = 100")
+        print("   packet_stats[1] = 200")
+        
+        # Write to hash map
+        ks.bandwidth_usage[10] = 1024
+        ks.bandwidth_usage[20] = 2048
+        print("   bandwidth_usage[10] = 1024")
+        print("   bandwidth_usage[20] = 2048")
+    except Exception as e:
+        print(f"   Map write error: {e}")
+    
+    # 3. Reading back written values
+    print("\n🔄 Reading back written values:")
+    try:
+        print(f"   packet_stats[0] = {ks.packet_stats[0]}")
+        print(f"   packet_stats[1] = {ks.packet_stats[1]}")
+        print(f"   bandwidth_usage[10] = {ks.bandwidth_usage[10]}")
+        print(f"   bandwidth_usage[20] = {ks.bandwidth_usage[20]}")
+    except Exception as e:
+        print(f"   Read back error: {e}")
+    
+    # 4. Using auto-generated structs
+    print("\n🏗️ Using auto-generated structs:")
+    ctx = ks.xdp_md()
+    ctx.data = 0x1000
+    ctx.data_end = 0x2000
+    ctx.ingress_ifindex = 5
+    ctx.rx_queue_index = 2
+    ctx.egress_ifindex = 8
+    
+    packet_size = ctx.data_end - ctx.data
+    print(f"   Created xdp_md struct:")
+    print(f"     data: 0x{ctx.data:x}")
+    print(f"     data_end: 0x{ctx.data_end:x}")
+    print(f"     packet_size: {packet_size} bytes")
+    print(f"     ingress_ifindex: {ctx.ingress_ifindex}")
+    print(f"     rx_queue_index: {ctx.rx_queue_index}")
+    print(f"     egress_ifindex: {ctx.egress_ifindex}")
+    
+    # 5. Map operations
+    print("\n🗑️ Map operations:")
+    try:
+        # Delete from hash map
+        del ks.bandwidth_usage[10]
+        print("   Deleted bandwidth_usage[10]")
+        
+        # Try to read deleted key
+        try:
+            value = ks.bandwidth_usage[10]
+            print(f"   bandwidth_usage[10] = {value}")
+        except KeyError:
+            print("   bandwidth_usage[10] not found (expected after deletion)")
+    except Exception as e:
+        print(f"   Delete operation: {e}")
+    
+    print("\n✅ Demo completed successfully!")
+    return 0
+
+if __name__ == "__main__":
+    exit(main())

examples/test_exec.ks

@@ -0,0 +1,62 @@
+// Test exec() builtin with Python integration
+
+// XDP context struct (from BTF)
+struct xdp_md {
+  data: u64,
+  data_end: u64,
+  data_meta: u64,
+  ingress_ifindex: u32,
+  rx_queue_index: u32,
+  egress_ifindex: u32,
+}
+
+// XDP action enum (from BTF)
+enum xdp_action {
+  XDP_ABORTED = 0,
+  XDP_DROP = 1,
+  XDP_PASS = 2,
+  XDP_REDIRECT = 3,
+  XDP_TX = 4,
+}
+
+// Global maps for sharing with Python
+var packet_stats : array<u32, u64>(256)
+var bandwidth_usage : hash<u32, u64>(1024)
+var test_map : hash<u32, u32>(100)
+
+@helper
+fn get_packet_size() -> u32 {
+    return 64 // Demo packet size
+}
+
+@xdp fn packet_monitor(ctx: *xdp_md) -> xdp_action {
+    var size = get_packet_size()
+    var bucket = size / 64
+    if (bucket < 256) {
+        packet_stats[bucket] += 1
+    }
+    
+    var interface = ctx->ingress_ifindex
+    var size_u64: u64 = size
+    bandwidth_usage[interface] += size_u64
+    
+    return XDP_PASS
+}
+
+fn main() -> i32 {
+    var prog = load(packet_monitor)
+    var result = attach(prog, "lo", 0)
+    
+    if (result == 0) {
+        print("eBPF program attached successfully")
+        print("Switching to Python for data analysis...")
+        
+        // Replace current process with Python - never returns
+        exec("./python_demo.py")
+    } else {
+        print("Failed to attach eBPF program")
+        return 1
+    }
+    
+    return 0
+}

src/main.ml

@@ -1016,7 +1016,7 @@ let compile_source input_file output_dir _verbose generate_makefile btf_vmlinux_
   (* Phase 6: Advanced multi-target code generation *)
     current_phase := "Code Generation";
     Printf.printf "Phase 6: %s\n" !current_phase;
-    let _resource_plan = Multi_program_ir_optimizer.plan_system_resources ir_with_ring_buffer_analysis.programs multi_prog_analysis in
+    let _resource_plan = Multi_program_ir_optimizer.plan_system_resources ir_with_ring_buffer_analysis.programs ir_with_ring_buffer_analysis in
     let _optimization_strategies = Multi_program_ir_optimizer.generate_optimization_strategies multi_prog_analysis in
 
     (* Extract type aliases from original AST *)

src/multi_program_ir_optimizer.ml

@@ -100,9 +100,9 @@ let validate_cross_program_constraints _programs multi_prog_analysis =
     Printf.printf "  ⚠️  Found %d constraint issues (see above)\n" !issues
 
 (** Resource planning for multi-program systems *)
-let plan_system_resources programs multi_prog_analysis =
+let plan_system_resources programs ir_multi_prog =
   let total_programs = List.length programs in
-  let total_maps = List.length multi_prog_analysis.global_maps in
+  let total_maps = List.length ir_multi_prog.Ir.global_maps in
   let estimated_instructions = total_programs * 1000 in
   let estimated_stack = total_programs * 512 in
   let estimated_memory = total_maps * 1024 * 1024 in
@@ -182,7 +182,7 @@ let generate_optimized_ir (annotated_ast: declaration list)
 
   (* Step 5: Resource planning *)
   Printf.printf "Step 5: Resource planning and validation...\n";
-  let resource_plan = plan_system_resources optimized_programs multi_prog_analysis in
+  let resource_plan = plan_system_resources optimized_programs baseline_ir in
   print_resource_plan resource_plan;
 
   Printf.printf "\n✅ Advanced Multi-Program IR Optimization completed successfully!\n\n";

src/stdlib.ml

@@ -61,6 +61,17 @@ let validate_dispatch_function arg_types _ast_context _pos =
     else
       (false, Some "dispatch() only accepts ring buffer arguments")
 
+(** Validation function for exec() - validates Python file suffix *)
+let validate_exec_function arg_types _ast_context _pos =
+  if List.length arg_types <> 1 then
+    (false, Some "exec() takes exactly one argument")
+  else
+    (* The argument should be a string type *)
+    let arg_type = List.hd arg_types in
+    match arg_type with
+    | Str _ -> (true, None) (* Actual file suffix validation happens during codegen *)
+    | _ -> (false, Some "exec() requires a string argument (Python file path)")
+
 (** Validation function for register() - only accepts impl block arguments *)
 let validate_register_function arg_types ast_context _pos =
   if List.length arg_types <> 1 then
@@ -188,6 +199,17 @@ let builtin_functions = [
     kernel_impl = ""; (* Not available in kernel context *)
     validate = None;
   };
+  {
+    name = "exec";
+    param_types = [Str 256]; (* Python script file path *)
+    return_type = Void; (* Never returns - replaces current process *)
+    description = "Replace current process with Python script, inheriting eBPF maps (userspace only)";
+    is_variadic = false;
+    ebpf_impl = ""; (* Not available in eBPF context *)
+    userspace_impl = "exec_builtin"; (* Custom implementation in userspace *)
+    kernel_impl = ""; (* Not available in kernel context *)
+    validate = Some validate_exec_function;
+  };
 
 ]