11 changed files with 177 additions and 375 deletions
--- a/flake.lock
+++ b/flake.lock
@ -11,11 +11,11 @@
        "src-pythonparser": "src-pythonparser"
      },
      "locked": {
-        "lastModified": 1724142594,
-        "narHash": "sha256-Uf33dTP5JpYlw7rRIfnGDc9eJmehSUVFBm2YJNfwvd4=",
+        "lastModified": 1720537135,
+        "narHash": "sha256-zhw4cxck1aOoxZOgw/NKmu2AAogssFTUmDMEIB7D338=",
        "ref": "release-8",
-        "rev": "0808f7bc72e37589e5a129dc4b44592856e13fdb",
-        "revCount": 8948,
+        "rev": "60b1edaf6bd5b355031ba9160bb5630bf91fea9b",
+        "revCount": 8878,
        "type": "git",
        "url": "https://github.com/m-labs/artiq.git"
      },
@ -38,11 +38,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1720768567,
-        "narHash": "sha256-3VoK7o5MtHtbHLrc6Pv+eQWFtaz5Gd/YWyV5TD3c5Ss=",
+        "lastModified": 1717637438,
+        "narHash": "sha256-BXFidNm3Em8iChPGu1L0s2bY+f2yQ0VVid4MuOoTehw=",
        "owner": "m-labs",
        "repo": "artiq-comtools",
-        "rev": "f93570d8f2ed5a3cfb3e1c16ab00f2540551e994",
+        "rev": "78d27026efe76a13f7b4698a554f55811369ec4d",
        "type": "github"
      },
      "original": {
@ -119,11 +119,11 @@
    },
    "nixpkgs": {
      "locked": {
-        "lastModified": 1722987190,
-        "narHash": "sha256-68hmex5efCiM2aZlAAEcQgmFI4ZwWt8a80vOeB/5w3A=",
+        "lastModified": 1720386169,
+        "narHash": "sha256-NGKVY4PjzwAa4upkGtAMz1npHGoRzWotlSnVlqI40mo=",
        "owner": "NixOS",
        "repo": "nixpkgs",
-        "rev": "21cc704b5e918c5fbf4f9fff22b4ac2681706d90",
+        "rev": "194846768975b7ad2c4988bdb82572c00222c0d7",
        "type": "github"
      },
      "original": {
@ -164,11 +164,11 @@
    "src-migen": {
      "flake": false,
      "locked": {
-        "lastModified": 1721561053,
-        "narHash": "sha256-z3LRhNmKZrjr6rFD0yxtccSa/SWvFIYmb+G/D5d2Jd8=",
+        "lastModified": 1720332047,
+        "narHash": "sha256-FdYVEHVtXHrzPhBqpXOTo9uHQAtuCsDPmAPY8JrfHOY=",
        "owner": "m-labs",
        "repo": "migen",
-        "rev": "9279e8623f8433bc4f23ac51e5e2331bfe544417",
+        "rev": "60739a161e64630ce7ba62d1a5bac1252b66c3b9",
        "type": "github"
      },
      "original": {
@ -235,11 +235,11 @@
        ]
      },
      "locked": {
-        "lastModified": 1720537402,
-        "narHash": "sha256-ybvaQ48SVBqYVqgYmGUdefGZkni7PJ90qYQPHnFOwDs=",
+        "lastModified": 1717654016,
+        "narHash": "sha256-y/c0EZNDNlxb/yLy/D23X9PLoiQ8I9mXAA0zsVOy2t8=",
        "ref": "refs/heads/master",
-        "rev": "b2b3e5c933cbc4b7cb14adde480d7561a3ae71ee",
-        "revCount": 648,
+        "rev": "0efbbe39fe643c03f15e29c208bff3247a987766",
+        "revCount": 647,
        "type": "git",
        "url": "https://git.m-labs.hk/m-labs/zynq-rs"
      },
--- a/src/libboard_artiq/src/drtioaux_proto.rs
+++ b/src/libboard_artiq/src/drtioaux_proto.rs
@ -267,14 +267,12 @@ pub enum Packet {
        exception_src: u8,
    },
    SubkernelExceptionRequest {
-        source: u8,
        destination: u8,
    },
    SubkernelException {
-        destination: u8,
        last: bool,
        length: u16,
-        data: [u8; MASTER_PAYLOAD_MAX_SIZE],
+        data: [u8; SAT_PAYLOAD_MAX_SIZE],
    },
    SubkernelMessage {
        source: u8,
@ -526,17 +524,14 @@ impl Packet {
                exception_src: reader.read_u8()?,
            },
            0xc9 => Packet::SubkernelExceptionRequest {
-                source: reader.read_u8()?,
                destination: reader.read_u8()?,
            },
            0xca => {
-                let destination = reader.read_u8()?;
                let last = reader.read_bool()?;
                let length = reader.read_u16()?;
-                let mut data: [u8; MASTER_PAYLOAD_MAX_SIZE] = [0; MASTER_PAYLOAD_MAX_SIZE];
+                let mut data: [u8; SAT_PAYLOAD_MAX_SIZE] = [0; SAT_PAYLOAD_MAX_SIZE];
                reader.read_exact(&mut data[0..length as usize])?;
                Packet::SubkernelException {
-                    destination: destination,
                    last: last,
                    length: length,
                    data: data,
@ -901,19 +896,12 @@ impl Packet {
                writer.write_bool(with_exception)?;
                writer.write_u8(exception_src)?;
            }
-            Packet::SubkernelExceptionRequest { source, destination } => {
+            Packet::SubkernelExceptionRequest { destination } => {
                writer.write_u8(0xc9)?;
-                writer.write_u8(source)?;
                writer.write_u8(destination)?;
            }
-            Packet::SubkernelException {
-                destination,
-                last,
-                length,
-                data,
-            } => {
+            Packet::SubkernelException { last, length, data } => {
                writer.write_u8(0xca)?;
-                writer.write_u8(destination)?;
                writer.write_bool(last)?;
                writer.write_u16(length)?;
                writer.write_all(&data[0..length as usize])?;
@ -955,8 +943,6 @@ impl Packet {
            Packet::SubkernelLoadRunReply { destination, .. } => Some(*destination),
            Packet::SubkernelMessage { destination, .. } => Some(*destination),
            Packet::SubkernelMessageAck { destination } => Some(*destination),
-            Packet::SubkernelExceptionRequest { destination, .. } => Some(*destination),
-            Packet::SubkernelException { destination, .. } => Some(*destination),
            Packet::DmaPlaybackStatus { destination, .. } => Some(*destination),
            Packet::SubkernelFinished { destination, .. } => Some(*destination),
            _ => None,
--- a/src/libksupport/src/eh_artiq.rs
+++ b/src/libksupport/src/eh_artiq.rs
@ -14,10 +14,8 @@

 use core::mem;

-use core_io::Error as ReadError;
-use cslice::{AsCSlice, CSlice};
+use cslice::CSlice;
 use dwarf::eh::{self, EHAction, EHContext};
-use io::{Cursor, ProtoRead};
 use libc::{c_int, c_void, uintptr_t};
 use log::{error, trace};
 use unwind as uw;
@ -222,6 +220,8 @@ pub unsafe fn artiq_personality(
 }

 pub unsafe extern "C" fn raise(exception: *const Exception) -> ! {
+    use cslice::AsCSlice;
+
    let count = EXCEPTION_BUFFER.exception_count;
    let stack = &mut EXCEPTION_BUFFER.exception_stack;
    let diff = exception as isize - EXCEPTION_BUFFER.exceptions.as_ptr() as isize;
@ -295,60 +295,6 @@ pub unsafe extern "C" fn raise(exception: *const Exception) -> ! {
    unreachable!();
 }

-fn read_exception_string<'a>(reader: &mut Cursor<&[u8]>) -> Result<CSlice<'a, u8>, ReadError> {
-    let len = reader.read_u32()? as usize;
-    if len == usize::MAX {
-        let data = reader.read_u32()?;
-        Ok(unsafe { CSlice::new(data as *const u8, len) })
-    } else {
-        let pos = reader.position();
-        let slice = unsafe {
-            let ptr = reader.get_ref().as_ptr().offset(pos as isize);
-            CSlice::new(ptr, len)
-        };
-        reader.set_position(pos + len);
-        Ok(slice)
-    }
-}
-
-fn read_exception(raw_exception: &[u8]) -> Result<Exception, ReadError> {
-    let mut reader = Cursor::new(raw_exception);
-
-    let mut byte = reader.read_u8()?;
-    // to sync
-    while byte != 0x5a {
-        byte = reader.read_u8()?;
-    }
-    // skip sync bytes, 0x09 indicates exception
-    while byte != 0x09 {
-        byte = reader.read_u8()?;
-    }
-    let _len = reader.read_u32()?;
-    // ignore the remaining exceptions, stack traces etc. - unwinding from another device would be unwise anyway
-    Ok(Exception {
-        id: reader.read_u32()?,
-        message: read_exception_string(&mut reader)?,
-        param: [
-            reader.read_u64()? as i64,
-            reader.read_u64()? as i64,
-            reader.read_u64()? as i64,
-        ],
-        file: read_exception_string(&mut reader)?,
-        line: reader.read_u32()?,
-        column: reader.read_u32()?,
-        function: read_exception_string(&mut reader)?,
-    })
-}
-
-pub fn raise_raw(raw_exception: &[u8]) -> ! {
-    use crate::artiq_raise;
-    if let Ok(exception) = read_exception(raw_exception) {
-        unsafe { raise(&exception) };
-    } else {
-        artiq_raise!("SubkernelError", "Error passing exception");
-    }
-}
-
 pub unsafe extern "C" fn resume() -> ! {
    trace!("resume");
    assert!(EXCEPTION_BUFFER.exception_count != 0);
@ -475,7 +421,7 @@ extern "C" fn stop_fn(
    }
 }

-// Must be kept in sync with preallocate_runtime_exception_names() in `artiq.compiler.embedding`
+// Must be kept in sync with preallocate_runtime_exception_names() in artiq/language/embedding_map.py
 static EXCEPTION_ID_LOOKUP: [(&str, u32); 12] = [
    ("RuntimeError", 0),
    ("RTIOUnderflow", 1),
@ -523,29 +469,3 @@ macro_rules! artiq_raise {
    }};
    ($name:expr, $message:expr) => {{ artiq_raise!($name, $message, 0, 0, 0) }};
 }
-
-/// Takes as input exception id from host
-/// Generates a new exception with:
-///   * `id` set to `exn_id`
-///   * `message` set to corresponding exception name from `EXCEPTION_ID_LOOKUP`
-///
-/// The message is matched on host to ensure correct exception is being referred
-/// This test checks the synchronization of exception ids for runtime errors
-#[no_mangle]
-pub extern "C" fn test_exception_id_sync(exn_id: u32) {
-    let message = EXCEPTION_ID_LOOKUP
-        .iter()
-        .find_map(|&(name, id)| if id == exn_id { Some(name) } else { None })
-        .unwrap_or("unallocated internal exception id");
-
-    let exn = Exception {
-        id: exn_id,
-        file: file!().as_c_slice(),
-        line: 0,
-        column: 0,
-        function: "test_exception_id_sync".as_c_slice(),
-        message: message.as_c_slice(),
-        param: [0, 0, 0],
-    };
-    unsafe { raise(&exn) };
-}
--- a/src/libksupport/src/kernel/api.rs
+++ b/src/libksupport/src/kernel/api.rs
@ -319,13 +319,6 @@ pub fn resolve(required: &[u8]) -> Option<u32> {
            }
            api!(yn = yn)
        },
-        /*
-         * syscall for unit tests
-         * Used in `artiq.tests.coredevice.test_exceptions.ExceptionTest.test_raise_exceptions_kernel`
-         * This syscall checks that the exception IDs used in the Python `EmbeddingMap` (in `artiq.language.embedding`)
-         * match the `EXCEPTION_ID_LOOKUP` defined in the firmware (`libksupport::src::eh_artiq`)
-         */
-        api!(test_exception_id_sync = eh_artiq::test_exception_id_sync)
    ];
    api.iter()
        .find(|&&(exported, _)| exported.as_bytes() == required)
--- a/src/libksupport/src/kernel/mod.rs
+++ b/src/libksupport/src/kernel/mod.rs
@ -23,7 +23,6 @@ pub enum SubkernelStatus {
    Timeout,
    IncorrectState,
    CommLost,
-    Exception(Vec<u8>),
    OtherError,
 }

@ -91,7 +90,9 @@ pub enum Message {
        timeout: i64,
    },
    #[cfg(has_drtio)]
-    SubkernelAwaitFinishReply,
+    SubkernelAwaitFinishReply {
+        status: SubkernelStatus,
+    },
    #[cfg(has_drtio)]
    SubkernelMsgSend {
        id: u32,
@ -108,10 +109,9 @@ pub enum Message {
    },
    #[cfg(has_drtio)]
    SubkernelMsgRecvReply {
+        status: SubkernelStatus,
        count: u8,
    },
-    #[cfg(has_drtio)]
-    SubkernelError(SubkernelStatus),
 }

 static CHANNEL_0TO1: Mutex<Option<sync_channel::Sender<'static, Message>>> = Mutex::new(None);
--- a/src/libksupport/src/kernel/subkernel.rs
+++ b/src/libksupport/src/kernel/subkernel.rs
@ -3,7 +3,7 @@ use alloc::vec::Vec;
 use cslice::CSlice;

 use super::{Message, SubkernelStatus, KERNEL_CHANNEL_0TO1, KERNEL_CHANNEL_1TO0};
-use crate::{artiq_raise, eh_artiq, rpc::send_args};
+use crate::{artiq_raise, rpc::send_args};

 pub extern "C" fn load_run(id: u32, destination: u8, run: bool) {
    unsafe {
@ -36,18 +36,21 @@ pub extern "C" fn await_finish(id: u32, timeout: i64) {
            });
    }
    match unsafe { KERNEL_CHANNEL_0TO1.as_mut().unwrap() }.recv() {
-        Message::SubkernelAwaitFinishReply => (),
-        Message::SubkernelError(SubkernelStatus::IncorrectState) => {
-            artiq_raise!("SubkernelError", "Subkernel not running")
-        }
-        Message::SubkernelError(SubkernelStatus::Timeout) => artiq_raise!("SubkernelError", "Subkernel timed out"),
-        Message::SubkernelError(SubkernelStatus::CommLost) => {
-            artiq_raise!("SubkernelError", "Lost communication with satellite")
-        }
-        Message::SubkernelError(SubkernelStatus::OtherError) => {
-            artiq_raise!("SubkernelError", "An error occurred during subkernel operation")
-        }
-        Message::SubkernelError(SubkernelStatus::Exception(raw_exception)) => eh_artiq::raise_raw(&raw_exception),
+        Message::SubkernelAwaitFinishReply {
+            status: SubkernelStatus::NoError,
+        } => (),
+        Message::SubkernelAwaitFinishReply {
+            status: SubkernelStatus::IncorrectState,
+        } => artiq_raise!("SubkernelError", "Subkernel not running"),
+        Message::SubkernelAwaitFinishReply {
+            status: SubkernelStatus::Timeout,
+        } => artiq_raise!("SubkernelError", "Subkernel timed out"),
+        Message::SubkernelAwaitFinishReply {
+            status: SubkernelStatus::CommLost,
+        } => artiq_raise!("SubkernelError", "Lost communication with satellite"),
+        Message::SubkernelAwaitFinishReply {
+            status: SubkernelStatus::OtherError,
+        } => artiq_raise!("SubkernelError", "An error occurred during subkernel operation"),
        _ => panic!("expected SubkernelAwaitFinishReply after SubkernelAwaitFinishRequest"),
    }
 }
@ -89,22 +92,30 @@ pub extern "C" fn await_message(id: i32, timeout: i64, tags: &CSlice<u8>, min: u
            });
    }
    match unsafe { KERNEL_CHANNEL_0TO1.as_mut().unwrap() }.recv() {
-        Message::SubkernelMsgRecvReply { count } => {
+        Message::SubkernelMsgRecvReply {
+            status: SubkernelStatus::NoError,
+            count,
+        } => {
            if min > count || count > max {
                artiq_raise!("SubkernelError", "Received more or less arguments than required")
            }
        }
-        Message::SubkernelError(SubkernelStatus::IncorrectState) => {
-            artiq_raise!("SubkernelError", "Subkernel not running")
-        }
-        Message::SubkernelError(SubkernelStatus::Timeout) => artiq_raise!("SubkernelError", "Subkernel timed out"),
-        Message::SubkernelError(SubkernelStatus::CommLost) => {
-            artiq_raise!("SubkernelError", "Lost communication with satellite")
-        }
-        Message::SubkernelError(SubkernelStatus::OtherError) => {
-            artiq_raise!("SubkernelError", "An error occurred during subkernel operation")
-        }
-        Message::SubkernelError(SubkernelStatus::Exception(raw_exception)) => eh_artiq::raise_raw(&raw_exception),
+        Message::SubkernelMsgRecvReply {
+            status: SubkernelStatus::IncorrectState,
+            ..
+        } => artiq_raise!("SubkernelError", "Subkernel not running"),
+        Message::SubkernelMsgRecvReply {
+            status: SubkernelStatus::Timeout,
+            ..
+        } => artiq_raise!("SubkernelError", "Subkernel timed out"),
+        Message::SubkernelMsgRecvReply {
+            status: SubkernelStatus::CommLost,
+            ..
+        } => artiq_raise!("SubkernelError", "Lost communication with satellite"),
+        Message::SubkernelMsgRecvReply {
+            status: SubkernelStatus::OtherError,
+            ..
+        } => artiq_raise!("SubkernelError", "An error occurred during subkernel operation"),
        _ => panic!("expected SubkernelMsgRecvReply after SubkernelMsgRecvRequest"),
    }
    // RpcRecvRequest should be called after this to receive message data
--- a/src/runtime/src/comms.rs
+++ b/src/runtime/src/comms.rs
@ -422,23 +422,33 @@ async fn handle_run_kernel(
            #[cfg(has_drtio)]
            kernel::Message::SubkernelAwaitFinishRequest { id, timeout } => {
                let res = subkernel::await_finish(aux_mutex, routing_table, timer, id, timeout).await;
-                let response = match res {
-                    Ok(res) => {
+                let status = match res {
+                    Ok(ref res) => {
                        if res.status == subkernel::FinishStatus::CommLost {
-                            kernel::Message::SubkernelError(kernel::SubkernelStatus::CommLost)
-                        } else if let Some(exception) = res.exception {
-                            kernel::Message::SubkernelError(kernel::SubkernelStatus::Exception(exception))
+                            kernel::SubkernelStatus::CommLost
+                        } else if let Some(exception) = &res.exception {
+                            error!("Exception in subkernel");
+                            match stream {
+                                None => (),
+                                Some(stream) => {
+                                    write_chunk(stream, exception).await?;
+                                }
+                            }
+                            // will not be called after exception is served
+                            kernel::SubkernelStatus::OtherError
                        } else {
-                            kernel::Message::SubkernelAwaitFinishReply
+                            kernel::SubkernelStatus::NoError
                        }
                    }
-                    Err(SubkernelError::Timeout) => kernel::Message::SubkernelError(kernel::SubkernelStatus::Timeout),
-                    Err(SubkernelError::IncorrectState) => {
-                        kernel::Message::SubkernelError(kernel::SubkernelStatus::IncorrectState)
-                    }
-                    Err(_) => kernel::Message::SubkernelError(kernel::SubkernelStatus::OtherError),
+                    Err(SubkernelError::Timeout) => kernel::SubkernelStatus::Timeout,
+                    Err(SubkernelError::IncorrectState) => kernel::SubkernelStatus::IncorrectState,
+                    Err(_) => kernel::SubkernelStatus::OtherError,
                };
-                control.borrow_mut().tx.async_send(response).await;
+                control
+                    .borrow_mut()
+                    .tx
+                    .async_send(kernel::Message::SubkernelAwaitFinishReply { status: status })
+                    .await;
            }
            #[cfg(has_drtio)]
            kernel::Message::SubkernelMsgSend { id, destination, data } => {
@ -459,23 +469,35 @@ async fn handle_run_kernel(
            #[cfg(has_drtio)]
            kernel::Message::SubkernelMsgRecvRequest { id, timeout, tags } => {
                let message_received = subkernel::message_await(id as u32, timeout, timer).await;
-                let response = match message_received {
-                    Ok(ref message) => kernel::Message::SubkernelMsgRecvReply { count: message.count },
-                    Err(SubkernelError::Timeout) => kernel::Message::SubkernelError(kernel::SubkernelStatus::Timeout),
-                    Err(SubkernelError::IncorrectState) => {
-                        kernel::Message::SubkernelError(kernel::SubkernelStatus::IncorrectState)
-                    }
-                    Err(SubkernelError::CommLost) => kernel::Message::SubkernelError(kernel::SubkernelStatus::CommLost),
+                let (status, count) = match message_received {
+                    Ok(ref message) => (kernel::SubkernelStatus::NoError, message.count),
+                    Err(SubkernelError::Timeout) => (kernel::SubkernelStatus::Timeout, 0),
+                    Err(SubkernelError::IncorrectState) => (kernel::SubkernelStatus::IncorrectState, 0),
+                    Err(SubkernelError::CommLost) => (kernel::SubkernelStatus::CommLost, 0),
                    Err(SubkernelError::SubkernelException) => {
+                        error!("Exception in subkernel");
                        // just retrieve the exception
                        let status = subkernel::await_finish(aux_mutex, routing_table, timer, id as u32, timeout)
                            .await
                            .unwrap();
-                        kernel::Message::SubkernelError(kernel::SubkernelStatus::Exception(status.exception.unwrap()))
+                        match stream {
+                            None => (),
+                            Some(stream) => {
+                                write_chunk(stream, &status.exception.unwrap()).await?;
+                            }
+                        }
+                        (kernel::SubkernelStatus::OtherError, 0)
                    }
-                    Err(_) => kernel::Message::SubkernelError(kernel::SubkernelStatus::OtherError),
+                    Err(_) => (kernel::SubkernelStatus::OtherError, 0),
                };
-                control.borrow_mut().tx.async_send(response).await;
+                control
+                    .borrow_mut()
+                    .tx
+                    .async_send(kernel::Message::SubkernelMsgRecvReply {
+                        status: status,
+                        count: count,
+                    })
+                    .await;
                if let Ok(message) = message_received {
                    // receive code almost identical to RPC recv, except we are not reading from a stream
                    let mut reader = Cursor::new(message.data);
@ -507,7 +529,7 @@ async fn handle_run_kernel(
                            .async_send(kernel::Message::RpcRecvReply(Ok(0)))
                            .await;
                        i += 1;
-                        if i < message.count {
+                        if i < count {
                            current_tags = remaining_tags;
                        } else {
                            break;
@ -696,27 +718,6 @@ async fn handle_connection(
    }
 }

-async fn load_and_run_idle_kernel(
-    buffer: &Vec<u8>,
-    control: &Rc<RefCell<kernel::Control>>,
-    up_destinations: &Rc<RefCell<[bool; drtio_routing::DEST_COUNT]>>,
-    aux_mutex: &Rc<Mutex<bool>>,
-    routing_table: &drtio_routing::RoutingTable,
-    timer: GlobalTimer,
-) {
-    info!("Loading idle kernel");
-    let res = handle_flash_kernel(buffer, control, up_destinations, aux_mutex, routing_table, timer).await;
-    match res {
-        Err(_) => warn!("error loading idle kernel"),
-        _ => (),
-    }
-    info!("Running idle kernel");
-    let _ = handle_run_kernel(None, control, up_destinations, aux_mutex, routing_table, timer)
-        .await
-        .map_err(|_| warn!("error running idle kernel"));
-    info!("Idle kernel terminated");
-}
-
 pub fn main(timer: GlobalTimer, cfg: Config) {
    let net_addresses = net_settings::get_addresses(&cfg);
    info!("network addresses: {}", net_addresses);
@ -807,30 +808,8 @@ pub fn main(timer: GlobalTimer, cfg: Config) {
    mgmt::start(cfg);

    task::spawn(async move {
-        let connection = Rc::new(Semaphore::new(0, 1));
+        let connection = Rc::new(Semaphore::new(1, 1));
        let terminate = Rc::new(Semaphore::new(0, 1));
-        {
-            let control = control.clone();
-            let idle_kernel = idle_kernel.clone();
-            let connection = connection.clone();
-            let terminate = terminate.clone();
-            let up_destinations = up_destinations.clone();
-            let aux_mutex = aux_mutex.clone();
-            let routing_table = drtio_routing_table.clone();
-            task::spawn(async move {
-                let routing_table = routing_table.borrow();
-                select_biased! {
-                    _ = (async {
-                        if let Some(buffer) = &*idle_kernel {
-                            load_and_run_idle_kernel(&buffer, &control, &up_destinations, &aux_mutex, &routing_table, timer).await;
-                        }
-                    }).fuse() => (),
-                    _ = terminate.async_wait().fuse() => ()
-                }
-                connection.signal();
-            });
-        }
-
        loop {
            let mut stream = TcpStream::accept(1381, 0x10_000, 0x10_000).await.unwrap();

@ -858,7 +837,22 @@ pub fn main(timer: GlobalTimer, cfg: Config) {
                            .await
                            .map_err(|e| warn!("connection terminated: {}", e));
                        if let Some(buffer) = &*idle_kernel {
-                            load_and_run_idle_kernel(&buffer, &control, &up_destinations, &aux_mutex, &routing_table, timer).await;
+                            info!("Loading idle kernel");
+                            let res = handle_flash_kernel(&buffer, &control, &up_destinations,  &aux_mutex, &routing_table, timer)
+                                .await;
+                            match res {
+                                #[cfg(has_drtio)]
+                                Err(Error::DestinationDown) => {
+                                    let mut countdown = timer.countdown();
+                                    delay(&mut countdown, Milliseconds(500)).await;
+                                }
+                                Err(_) => warn!("error loading idle kernel"),
+                                _ => (),
+                            }
+                            info!("Running idle kernel");
+                            let _ = handle_run_kernel(None, &control, &up_destinations, &aux_mutex, &routing_table, timer)
+                                .await.map_err(|_| warn!("error running idle kernel"));
+                            info!("Idle kernel terminated");
                        }
                    }).fuse() => (),
                    _ = terminate.async_wait().fuse() => ()
--- a/src/runtime/src/rtio_mgt.rs
+++ b/src/runtime/src/rtio_mgt.rs
@ -129,8 +129,6 @@ pub mod drtio {
            | Packet::SubkernelLoadRunReply { destination, .. }
            | Packet::SubkernelMessage { destination, .. }
            | Packet::SubkernelMessageAck { destination, .. }
-            | Packet::SubkernelException { destination, .. }
-            | Packet::SubkernelExceptionRequest { destination, .. }
            | Packet::DmaPlaybackStatus { destination, .. }
            | Packet::SubkernelFinished { destination, .. } => {
                if destination == 0 {
@ -185,7 +183,10 @@ pub mod drtio {

    async fn drain_buffer(linkno: u8, draining_time: Milliseconds, timer: GlobalTimer) {
        let max_time = timer.get_time() + draining_time;
-        while timer.get_time() < max_time {
+        loop {
+            if timer.get_time() > max_time {
+                return;
+            }
            let _ = drtioaux_async::recv(linkno).await;
        }
    }
@ -834,19 +835,13 @@ pub mod drtio {
                linkno,
                routing_table,
                &Packet::SubkernelExceptionRequest {
-                    source: 0,
                    destination: destination,
                },
                timer,
            )
            .await?;
            match reply {
-                Packet::SubkernelException {
-                    destination: 0,
-                    last,
-                    length,
-                    data,
-                } => {
+                Packet::SubkernelException { last, length, data } => {
                    remote_data.extend(&data[0..length as usize]);
                    if last {
                        return Ok(remote_data);
--- a/src/satman/src/main.rs
+++ b/src/satman/src/main.rs
@ -895,7 +895,6 @@ fn process_aux_packet(
            Ok(())
        }
        drtioaux::Packet::SubkernelExceptionRequest {
-            source,
            destination: _destination,
        } => {
            forward!(
@ -908,46 +907,17 @@ fn process_aux_packet(
                &packet,
                timer
            );
-            let mut data_slice: [u8; MASTER_PAYLOAD_MAX_SIZE] = [0; MASTER_PAYLOAD_MAX_SIZE];
+            let mut data_slice: [u8; SAT_PAYLOAD_MAX_SIZE] = [0; SAT_PAYLOAD_MAX_SIZE];
            let meta = kernel_manager.exception_get_slice(&mut data_slice);
-            router.send(
-                drtioaux::Packet::SubkernelException {
-                    destination: source,
+            drtioaux::send(
+                0,
+                &drtioaux::Packet::SubkernelException {
                    last: meta.status.is_last(),
                    length: meta.len,
                    data: data_slice,
                },
-                _routing_table,
-                *rank,
-                *self_destination,
            )
        }
-        drtioaux::Packet::SubkernelException {
-            destination: _destination,
-            last,
-            length,
-            data,
-        } => {
-            forward!(
-                router,
-                _routing_table,
-                _destination,
-                *rank,
-                *self_destination,
-                _repeaters,
-                &packet,
-                timer
-            );
-            kernel_manager.received_exception(
-                &data[..length as usize],
-                last,
-                router,
-                _routing_table,
-                *rank,
-                *self_destination,
-            );
-            Ok(())
-        }
        drtioaux::Packet::SubkernelMessage {
            source,
            destination: _destination,
--- a/src/satman/src/routing.rs
+++ b/src/satman/src/routing.rs
@ -4,7 +4,7 @@ use core::cmp::min;
 #[cfg(has_drtio_routing)]
 use libboard_artiq::pl::csr;
 use libboard_artiq::{drtio_routing, drtioaux,
-                     drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE}};
+                     drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE, SAT_PAYLOAD_MAX_SIZE}};

 pub struct SliceMeta {
    pub destination: u8,
@ -57,6 +57,7 @@ impl Sliceable {
        self.data.extend(data);
    }

+    get_slice_fn!(get_slice_sat, SAT_PAYLOAD_MAX_SIZE);
    get_slice_fn!(get_slice_master, MASTER_PAYLOAD_MAX_SIZE);
 }

--- a/src/satman/src/subkernel.rs
+++ b/src/satman/src/subkernel.rs
@ -11,7 +11,7 @@ use io::{Cursor, ProtoWrite};
 use ksupport::{eh_artiq, kernel, rpc};
 use libboard_artiq::{drtio_routing::RoutingTable,
                     drtioaux,
-                     drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE},
+                     drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE, SAT_PAYLOAD_MAX_SIZE},
                     pl::csr};
 use libboard_zynq::{time::Milliseconds, timer::GlobalTimer};
 use libcortex_a9::sync_channel::Receiver;
@ -47,9 +47,6 @@ enum KernelState {
    DmaAwait {
        max_time: Milliseconds,
    },
-    SubkernelRetrievingException {
-        destination: u8,
-    },
 }

 #[derive(Debug)]
@ -126,11 +123,10 @@ struct MessageManager {
 struct Session {
    id: u32,
    kernel_state: KernelState,
-    last_exception: Option<Sliceable>,   // exceptions raised locally
-    external_exception: Option<Vec<u8>>, // exceptions from sub-subkernels
+    last_exception: Option<Sliceable>,
    messages: MessageManager,
    source: u8, // which destination requested running the kernel
-    subkernels_finished: Vec<(u32, Option<u8>)>,
+    subkernels_finished: Vec<u32>,
 }

 impl Session {
@ -139,7 +135,6 @@ impl Session {
            id: id,
            kernel_state: KernelState::Absent,
            last_exception: None,
-            external_exception: None,
            messages: MessageManager::new(),
            source: 0,
            subkernels_finished: Vec::new(),
@ -415,9 +410,9 @@ impl<'a> Manager<'_> {
        }
    }

-    pub fn exception_get_slice(&mut self, data_slice: &mut [u8; MASTER_PAYLOAD_MAX_SIZE]) -> SliceMeta {
+    pub fn exception_get_slice(&mut self, data_slice: &mut [u8; SAT_PAYLOAD_MAX_SIZE]) -> SliceMeta {
        match self.session.last_exception.as_mut() {
-            Some(exception) => exception.get_slice_master(data_slice),
+            Some(exception) => exception.get_slice_sat(data_slice),
            None => SliceMeta {
                destination: 0,
                len: 0,
@ -545,7 +540,7 @@ impl<'a> Manager<'_> {
            return;
        }

-        match self.process_external_messages(router, routing_table, rank, destination, timer) {
+        match self.process_external_messages(timer) {
            Ok(()) => (),
            Err(Error::AwaitingMessage) => return, // kernel still waiting, do not process kernel messages
            Err(Error::KernelException(exception)) => {
@ -601,41 +596,6 @@ impl<'a> Manager<'_> {
        }
    }

-    fn check_finished_kernels(
-        &mut self,
-        id: u32,
-        router: &mut Router,
-        routing_table: &RoutingTable,
-        rank: u8,
-        self_destination: u8,
-    ) {
-        for (i, (status, exception_source)) in self.session.subkernels_finished.iter().enumerate() {
-            if *status == id {
-                if exception_source.is_none() {
-                    self.control.tx.send(kernel::Message::SubkernelAwaitFinishReply);
-                    self.session.kernel_state = KernelState::Running;
-                    self.session.subkernels_finished.swap_remove(i);
-                } else {
-                    let destination = exception_source.unwrap();
-                    self.session.external_exception = Some(Vec::new());
-                    self.session.kernel_state = KernelState::SubkernelRetrievingException {
-                        destination: destination,
-                    };
-                    router.route(
-                        drtioaux::Packet::SubkernelExceptionRequest {
-                            source: self_destination,
-                            destination: destination,
-                        },
-                        &routing_table,
-                        rank,
-                        self_destination,
-                    );
-                }
-                break;
-            }
-        }
-    }
-
    pub fn subkernel_load_run_reply(&mut self, succeeded: bool) {
        if self.session.kernel_state == KernelState::SubkernelAwaitLoad {
            self.control
@ -648,46 +608,16 @@ impl<'a> Manager<'_> {
    }

    pub fn remote_subkernel_finished(&mut self, id: u32, with_exception: bool, exception_source: u8) {
-        let exception_src = if with_exception { Some(exception_source) } else { None };
-        self.session.subkernels_finished.push((id, exception_src));
-    }
-
-    pub fn received_exception(
-        &mut self,
-        exception_data: &[u8],
-        last: bool,
-        router: &mut Router,
-        routing_table: &RoutingTable,
-        rank: u8,
-        self_destination: u8,
-    ) {
-        if let KernelState::SubkernelRetrievingException { destination } = self.session.kernel_state {
-            self.session
-                .external_exception
-                .as_mut()
-                .unwrap()
-                .extend_from_slice(exception_data);
-            if last {
-                self.control
-                    .tx
-                    .send(kernel::Message::SubkernelError(kernel::SubkernelStatus::Exception(
-                        self.session.external_exception.take().unwrap(),
-                    )));
-                self.session.kernel_state = KernelState::Running;
-            } else {
-                /* fetch another slice */
-                router.route(
-                    drtioaux::Packet::SubkernelExceptionRequest {
-                        source: self_destination,
-                        destination: destination,
-                    },
-                    routing_table,
-                    rank,
-                    self_destination,
-                );
-            }
+        if with_exception {
+            self.kernel_stop();
+            self.last_finished = Some(SubkernelFinished {
+                source: self.session.source,
+                id: self.session.id,
+                with_exception: true,
+                exception_source: exception_source,
+            })
        } else {
-            warn!("Received unsolicited exception data");
+            self.session.subkernels_finished.push(id);
        }
    }

@ -850,35 +780,28 @@ impl<'a> Manager<'_> {
        Ok(false)
    }

-    fn process_external_messages(
-        &mut self,
-        router: &mut Router,
-        routing_table: &RoutingTable,
-        rank: u8,
-        self_destination: u8,
-        timer: &GlobalTimer,
-    ) -> Result<(), Error> {
+    fn process_external_messages(&mut self, timer: &GlobalTimer) -> Result<(), Error> {
        match &self.session.kernel_state {
            KernelState::MsgAwait { max_time, id, tags } => {
                if let Some(max_time) = *max_time {
                    if timer.get_time() > max_time {
-                        self.control
-                            .tx
-                            .send(kernel::Message::SubkernelError(kernel::SubkernelStatus::Timeout));
+                        self.control.tx.send(kernel::Message::SubkernelMsgRecvReply {
+                            status: kernel::SubkernelStatus::Timeout,
+                            count: 0,
+                        });
                        self.session.kernel_state = KernelState::Running;
                        return Ok(());
                    }
                }
                if let Some(message) = self.session.messages.get_incoming(*id) {
-                    self.control
-                        .tx
-                        .send(kernel::Message::SubkernelMsgRecvReply { count: message.count });
+                    self.control.tx.send(kernel::Message::SubkernelMsgRecvReply {
+                        status: kernel::SubkernelStatus::NoError,
+                        count: message.count,
+                    });
                    let tags = tags.clone();
                    self.session.kernel_state = KernelState::Running;
                    self.pass_message_to_kernel(&message, tags, timer)
                } else {
-                    let id = *id;
-                    self.check_finished_kernels(id, router, routing_table, rank, self_destination);
                    Err(Error::AwaitingMessage)
                }
            }
@ -894,18 +817,27 @@ impl<'a> Manager<'_> {
            KernelState::SubkernelAwaitFinish { max_time, id } => {
                if let Some(max_time) = *max_time {
                    if timer.get_time() > max_time {
-                        self.control
-                            .tx
-                            .send(kernel::Message::SubkernelError(kernel::SubkernelStatus::Timeout));
+                        self.control.tx.send(kernel::Message::SubkernelAwaitFinishReply {
+                            status: kernel::SubkernelStatus::Timeout,
+                        });
                        self.session.kernel_state = KernelState::Running;
                        return Ok(());
                    }
                }
-                let id = *id;
-                self.check_finished_kernels(id, router, routing_table, rank, self_destination);
+                let mut i = 0;
+                for status in &self.session.subkernels_finished {
+                    if *status == *id {
+                        self.control.tx.send(kernel::Message::SubkernelAwaitFinishReply {
+                            status: kernel::SubkernelStatus::NoError,
+                        });
+                        self.session.kernel_state = KernelState::Running;
+                        self.session.subkernels_finished.swap_remove(i);
+                        break;
+                    }
+                    i += 1;
+                }
                Ok(())
            }
-            KernelState::SubkernelRetrievingException { .. } => Err(Error::AwaitingMessage),
            KernelState::DmaAwait { max_time } | KernelState::DmaPendingAwait { max_time, .. } => {
                if timer.get_time() > *max_time {
                    self.control.tx.send(kernel::Message::DmaAwaitRemoteReply {