send simple messages between cores

runtime/src/comms.rs

@@ -154,26 +154,21 @@ async fn handle_connection(stream: &TcpStream, control: Rc<RefCell<kernel::Contr
             },
             Request::LoadKernel => {
                 let length = read_i32(&stream).await? as usize;
-                let kernel_buffer = unsafe { &mut kernel::KERNEL_BUFFER };
+                if length < 1024*1024 {
-                if kernel_buffer.len() < length {
+                    let mut buffer = vec![0; length];
+                    read_chunk(&stream, &mut buffer).await?;
+
+                    let mut control = control.borrow_mut();
+                    control.restart();
+                    control.tx.async_send(kernel::Message::LoadRequest).await;
+                    let reply = control.rx.async_recv().await;
+                    println!("core0 received: {:?}", reply);
+
+                    send_header(&stream, Reply::LoadCompleted).await?;
+                } else {
                     read_drain(&stream, length).await?;
                     send_header(&stream, Reply::LoadFailed).await?;
-                } else {
-                    read_chunk(&stream, &mut kernel_buffer[..length]).await?;
-                    send_header(&stream, Reply::LoadCompleted).await?;
                 }
-                println!("length={}, {:?}", length, &kernel_buffer[..256]);
-
-                let mut control = control.borrow_mut();
-                control.restart();
-                for i in 0..10 {
-                    control.tx.async_send(i).await;
-                    let j = control.rx.async_recv().await;
-                    println!("{} -> {}", i, j);
-                }
-
-                // TODO: dyld
-
             }
             _ => return Err(Error::UnrecognizedPacket)
         }

runtime/src/kernel.rs

@@ -1,15 +1,25 @@
 use alloc::{vec, vec::Vec};
+
 use libcortex_a9::{mutex::Mutex, sync_channel::{self, sync_channel}};
 use libboard_zynq::println;
 use libsupport_zynq::boot::Core1;
 
-static CHANNEL_0TO1: Mutex<Option<sync_channel::Receiver<usize>>> = Mutex::new(None);
+use dyld;
-static CHANNEL_1TO0: Mutex<Option<sync_channel::Sender<usize>>> = Mutex::new(None);
+
+
+#[derive(Debug)]
+pub enum Message {
+    LoadRequest,
+    LoadReply,
+}
+
+static CHANNEL_0TO1: Mutex<Option<sync_channel::Receiver<Message>>> = Mutex::new(None);
+static CHANNEL_1TO0: Mutex<Option<sync_channel::Sender<Message>>> = Mutex::new(None);
 
 pub struct Control {
     core1: Core1<Vec<u32>>,
-    pub tx: sync_channel::Sender<usize>,
+    pub tx: sync_channel::Sender<Message>,
-    pub rx: sync_channel::Receiver<usize>,
+    pub rx: sync_channel::Receiver<Message>,
 }
 
 impl Control {
@@ -44,8 +54,6 @@ impl Control {
     }
 }
 
-pub static mut KERNEL_BUFFER: [u8; 16384] = [0; 16384];
-
 #[no_mangle]
 pub fn main_core1() {
     println!("Core1 started");
@@ -62,9 +70,11 @@ pub fn main_core1() {
     }
     let core1_rx = core1_rx.unwrap();
 
-    for i in core1_rx {
+    for message in core1_rx {
-        core1_tx.send(*i * *i);
+        println!("core1 received: {:?}", message);
+        match *message {
+            Message::LoadRequest => core1_tx.send(Message::LoadReply),
+            _ => println!("Core1 received unexpected message: {:?}", message),
+        }
     }
-
-    loop {}
 }