Simplify ring buffer initialization by removing unnecessary spawn_blocking

- Changed ring_buffer_processor to take &Map reference instead of owned Map
- Removed spawn_blocking wrapper around ring buffer creation since Map reference is sufficient
- Simplified error handling by building ring buffer synchronously in the async context

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: harrison001

kernel-agent/src/lib.rs

@@ -228,9 +228,9 @@ impl EbpfLoader {
         let shutdown = Arc::clone(&self.shutdown_signal);
         let config = self.config.clone();
 
-        // Spawn the processor with the map (transfer ownership)
+        // Spawn the processor with the map reference
         tokio::spawn(Self::ring_buffer_processor(
-            rb_map,
+            &rb_map,
             sender,
             metrics,
             rate_limiter,
@@ -243,7 +243,7 @@ impl EbpfLoader {
 
     #[cfg(target_os = "linux")]
     async fn ring_buffer_processor(
-        rb_map: libbpf_rs::Map,
+        rb_map: &libbpf_rs::Map,
         sender: mpsc::Sender<RawEvent>,
         metrics: Arc<RwLock<EbpfMetrics>>,
         rate_limiter: Arc<Semaphore>,
@@ -255,33 +255,25 @@ impl EbpfLoader {
         // Create a channel for events from the ring buffer callback
         let (event_tx, mut event_rx) = mpsc::unbounded_channel::<Vec<u8>>();
 
-        // Build ring buffer in a blocking context to avoid Send issues
-        let rb_result = tokio::task::spawn_blocking(move || -> anyhow::Result<_> {
-            let mut rb_builder = RingBufferBuilder::new();
-            
-            rb_builder.add(&rb_map, {
-                let event_tx = event_tx.clone();
-                move |data: &[u8]| {
-                    // Copy data and send through channel for async processing
-                    if let Err(_) = event_tx.send(data.to_vec()) {
-                        // Channel closed, stop processing
-                        return -1;
-                    }
-                    0
+        // Build ring buffer synchronously since Map doesn't implement Send
+        let mut rb_builder = RingBufferBuilder::new();
+        
+        rb_builder.add(rb_map, {
+            let event_tx = event_tx.clone();
+            move |data: &[u8]| {
+                // Copy data and send through channel for async processing
+                if let Err(_) = event_tx.send(data.to_vec()) {
+                    // Channel closed, stop processing
+                    return -1;
                 }
-            });
-
-            rb_builder.build().map_err(|e| anyhow::anyhow!("Ring buffer build error: {}", e))
-        }).await;
-
-        let rb = match rb_result {
-            Ok(Ok(rb)) => rb,
-            Ok(Err(e)) => {
-                error!("Cannot create ring buffer: {}", e);
-                return;
+                0
             }
+        });
+
+        let rb = match rb_builder.build() {
+            Ok(rb) => rb,
             Err(e) => {
-                error!("Ring buffer task error: {}", e);
+                error!("Cannot create ring buffer: {}", e);
                 return;
             }
         };