srenblad/artiq-zynq
1
0
Fork 0
forked from M-Labs/artiq-zynq
Code Pull Requests Activity

fix errors

Browse Source
This commit is contained in:
Simon Renblad 2024-10-24 17:49:54 +08:00
parent 9d1bbff6b2
commit d1d03a02bd
21 changed files with 272 additions and 226 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
flake.nix
View File

@ -10,7 +10,6 @@
pkgs = import artiq.inputs.nixpkgs { system = "x86_64-linux"; overlays = [ (import zynq-rs.inputs.rust-overlay) ]; }; pkgs = import artiq.inputs.nixpkgs { system = "x86_64-linux"; overlays = [ (import zynq-rs.inputs.rust-overlay) ]; };
zynqpkgs = zynq-rs.packages.x86_64-linux; zynqpkgs = zynq-rs.packages.x86_64-linux;
artiqpkgs = artiq.packages.x86_64-linux; artiqpkgs = artiq.packages.x86_64-linux;
llvmPackages_11 = zynq-rs.llvmPackages_11;
rust = zynq-rs.rust; rust = zynq-rs.rust;
rustPlatform = zynq-rs.rustPlatform; rustPlatform = zynq-rs.rustPlatform;
@ -125,7 +124,7 @@
lockFile = src/Cargo.lock; lockFile = src/Cargo.lock;
outputHashes = { outputHashes = {
"tar-no-std-0.1.8" = "sha256-xm17108v4smXOqxdLvHl9CxTCJslmeogjm4Y87IXFuM="; "tar-no-std-0.1.8" = "sha256-xm17108v4smXOqxdLvHl9CxTCJslmeogjm4Y87IXFuM=";
"nalgebra-0.32.6" = "sha256-L/YudkVOtfGYoNQKBD7LMk/sMYgRDzPDdpGL5rO7G2I="; "fatfs-0.4.0" = "sha256-P7IgvhwTPXtNhcyv8cFqwO2UdaEcCGJY7UBG6+yBFSg=";
}; };
}; };
@ -133,12 +132,12 @@
pkgs.gnumake pkgs.gnumake
(pkgs.python3.withPackages(ps: [ ps.jsonschema artiqpkgs.migen migen-axi artiqpkgs.misoc artiqpkgs.artiq ])) (pkgs.python3.withPackages(ps: [ ps.jsonschema artiqpkgs.migen migen-axi artiqpkgs.misoc artiqpkgs.artiq ]))
zynqpkgs.cargo-xbuild zynqpkgs.cargo-xbuild
llvmPackages_11.llvm pkgs.llvmPackages_18.llvm
llvmPackages_11.clang-unwrapped pkgs.llvmPackages_18.clang-unwrapped
]; ];
buildPhase = '' buildPhase = ''
export XARGO_RUST_SRC="${rust}/lib/rustlib/src/rust/library" export XARGO_RUST_SRC="${rust}/lib/rustlib/src/rust/library"
export CLANG_EXTRA_INCLUDE_DIR="${llvmPackages_11.clang-unwrapped.lib}/lib/clang/11.1.0/include" export CLANG_EXTRA_INCLUDE_DIR="${pkgs.llvmPackages_18.clang-unwrapped.lib}/lib/clang/18/include"
export CARGO_HOME=$(mktemp -d cargo-home.XXX) export CARGO_HOME=$(mktemp -d cargo-home.XXX)
export ZYNQ_RS=${zynq-rs} export ZYNQ_RS=${zynq-rs}
make TARGET=${target} GWARGS="${if json == null then "-V ${variant}" else json}" ${fwtype} make TARGET=${target} GWARGS="${if json == null then "-V ${variant}" else json}" ${fwtype}
@ -372,8 +371,8 @@
name = "artiq-zynq-dev-shell"; name = "artiq-zynq-dev-shell";
buildInputs = with pkgs; [ buildInputs = with pkgs; [
rust rust
llvmPackages_11.llvm llvmPackages_18.llvm
llvmPackages_11.clang-unwrapped llvmPackages_18.clang-unwrapped
gnumake gnumake
cacert cacert
zynqpkgs.cargo-xbuild zynqpkgs.cargo-xbuild
@ -387,7 +386,7 @@
pre-commit pre-commit
]; ];
XARGO_RUST_SRC = "${rust}/lib/rustlib/src/rust/library"; XARGO_RUST_SRC = "${rust}/lib/rustlib/src/rust/library";
CLANG_EXTRA_INCLUDE_DIR = "${llvmPackages_11.clang-unwrapped.lib}/lib/clang/11.1.0/include"; CLANG_EXTRA_INCLUDE_DIR = "${pkgs.llvmPackages_18.clang-unwrapped.lib}/lib/clang/18/include";
ZYNQ_RS = "${zynq-rs}"; ZYNQ_RS = "${zynq-rs}";
OPENOCD_ZYNQ = "${zynq-rs}/openocd"; OPENOCD_ZYNQ = "${zynq-rs}/openocd";
SZL = "${zynqpkgs.szl}"; SZL = "${zynqpkgs.szl}";

57
src/Cargo.lock generated
View File

@ -46,6 +46,12 @@ version = "1.3.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a" checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
[[package]]
name = "bitflags"
version = "2.6.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"
[[package]] [[package]]
name = "build_const" name = "build_const"
version = "0.2.2" version = "0.2.2"
@ -82,18 +88,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
[[package]] [[package]]
name = "compiler_builtins" name = "compiler_builtins"
version = "0.1.39" version = "0.1.109"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3748f82c7d366a0b4950257d19db685d4958d2fa27c6d164a3f069fec42b748b" checksum = "f11973008a8cf741fe6d22f339eba21fd0ca81e2760a769ba8243ed6c21edd7e"
[[package]]
name = "core_io"
version = "0.1.20210325"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "97f8932064288cc79feb4d343a399d353a6f6f001e586ece47fe518a9e8507df"
dependencies = [
"rustc_version",
]
[[package]] [[package]]
name = "crc" name = "crc"
@ -141,13 +138,10 @@ dependencies = [
[[package]] [[package]]
name = "fatfs" name = "fatfs"
version = "0.3.5" version = "0.4.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "git+https://github.com/rafalh/rust-fatfs?rev=85f06e0#85f06e08edbd3368e1b0562f2fc1b6d178bf7b8a"
checksum = "e18f80a87439240dac45d927fd8f8081b6f1e34c03e97271189fa8a8c2e96c8f"
dependencies = [ dependencies = [
"bitflags", "bitflags 2.6.0",
"byteorder",
"core_io",
"log", "log",
] ]
@ -319,7 +313,6 @@ dependencies = [
name = "libconfig" name = "libconfig"
version = "0.1.0" version = "0.1.0"
dependencies = [ dependencies = [
"core_io",
"fatfs", "fatfs",
"libboard_zynq", "libboard_zynq",
"log", "log",
@ -391,8 +384,9 @@ checksum = "c75de51135344a4f8ed3cfe2720dc27736f7711989703a0b43aadf3753c55577"
[[package]] [[package]]
name = "nalgebra" name = "nalgebra"
version = "0.32.6" version = "0.33.0"
source = "git+https://git.m-labs.hk/M-Labs/nalgebra.git?rev=dd00f9b#dd00f9b46046e0b931d1b470166db02fd29591be" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3c4b5f057b303842cf3262c27e465f4c303572e7f6b0648f60e16248ac3397f4"
dependencies = [ dependencies = [
"approx", "approx",
"num-complex", "num-complex",
@ -541,15 +535,6 @@ dependencies = [
"void", "void",
] ]
[[package]]
name = "rustc_version"
version = "0.1.7"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c5f5376ea5e30ce23c03eb77cbe4962b988deead10910c372b226388b594c084"
dependencies = [
"semver",
]
[[package]] [[package]]
name = "satman" name = "satman"
version = "0.0.0" version = "0.0.0"
@ -573,17 +558,11 @@ dependencies = [
"unwind", "unwind",
] ]
[[package]]
name = "semver"
version = "0.1.20"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "d4f410fedcf71af0345d7607d246e7ad15faaadd49d240ee3b24e5dc21a820ac"
[[package]] [[package]]
name = "simba" name = "simba"
version = "0.8.0" version = "0.9.0"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "50582927ed6f77e4ac020c057f37a268fc6aebc29225050365aacbb9deeeddc4" checksum = "b3a386a501cd104797982c15ae17aafe8b9261315b5d07e3ec803f2ea26be0fa"
dependencies = [ dependencies = [
"approx", "approx",
"num-complex", "num-complex",
@ -597,7 +576,7 @@ version = "0.7.5"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "3e4a069bef843d170df47e7c0a8bf8d037f217d9f5b325865acc3e466ffe40d3" checksum = "3e4a069bef843d170df47e7c0a8bf8d037f217d9f5b325865acc3e466ffe40d3"
dependencies = [ dependencies = [
"bitflags", "bitflags 1.3.2",
"byteorder", "byteorder",
"managed", "managed",
] ]
@ -619,7 +598,7 @@ version = "0.1.8"
source = "git+https://git.m-labs.hk/M-Labs/tar-no-std?rev=2ab6dc5#2ab6dc58e5249c59c4eb03eaf3a119bcdd678d32" source = "git+https://git.m-labs.hk/M-Labs/tar-no-std?rev=2ab6dc5#2ab6dc58e5249c59c4eb03eaf3a119bcdd678d32"
dependencies = [ dependencies = [
"arrayvec", "arrayvec",
"bitflags", "bitflags 1.3.2",
"log", "log",
] ]

28
src/libboard_artiq/src/drtioaux.rs
View File

@ -9,7 +9,7 @@ pub use crate::drtioaux_proto::Packet;
use crate::{drtioaux_proto::Error as ProtocolError, mem::mem::DRTIOAUX_MEM, pl::csr::DRTIOAUX}; use crate::{drtioaux_proto::Error as ProtocolError, mem::mem::DRTIOAUX_MEM, pl::csr::DRTIOAUX};
#[derive(Debug)] #[derive(Debug)]
pub enum Error { pub enum Error<T> {
GatewareError, GatewareError,
CorruptedPacket, CorruptedPacket,
@ -19,17 +19,17 @@ pub enum Error {
RoutingError, RoutingError,
Protocol(ProtocolError), Protocol(ProtocolError<T>),
} }
impl From<ProtocolError> for Error { impl<T> From<ProtocolError<T>> for Error<T> {
fn from(value: ProtocolError) -> Error { fn from(value: ProtocolError<T>) -> Error<T> {
Error::Protocol(value) Error::Protocol(value)
} }
} }
impl From<IoError> for Error { impl<T> From<IoError<T>> for Error<T> {
fn from(value: IoError) -> Error { fn from(value: IoError<T>) -> Error<T> {
Error::Protocol(ProtocolError::Io(value)) Error::Protocol(ProtocolError::Io(value))
} }
} }
@ -56,8 +56,8 @@ pub fn has_rx_error(linkno: u8) -> bool {
} }
} }
fn receive<F, T>(linkno: u8, f: F) -> Result<Option<T>, Error> fn receive<F, T>(linkno: u8, f: F) -> Result<Option<T>, Error<!>>
where F: FnOnce(&[u8]) -> Result<T, Error> { where F: FnOnce(&[u8]) -> Result<T, Error<!>> {
let linkidx = linkno as usize; let linkidx = linkno as usize;
unsafe { unsafe {
if (DRTIOAUX[linkidx].aux_rx_present_read)() == 1 { if (DRTIOAUX[linkidx].aux_rx_present_read)() == 1 {
@ -72,14 +72,14 @@ where F: FnOnce(&[u8]) -> Result<T, Error> {
} }
} }
pub fn recv(linkno: u8) -> Result<Option<Packet>, Error> { pub fn recv(linkno: u8) -> Result<Option<Packet>, Error<!>> {
if has_rx_error(linkno) { if has_rx_error(linkno) {
return Err(Error::GatewareError); return Err(Error::GatewareError);
} }
receive(linkno, |buffer| { receive(linkno, |buffer| {
if buffer.len() < 8 { if buffer.len() < 8 {
return Err(IoError::UnexpectedEnd).into()); return Err(IoError::UnexpectedEnd.into());
} }
let mut reader = Cursor::new(buffer); let mut reader = Cursor::new(buffer);
@ -96,7 +96,7 @@ pub fn recv(linkno: u8) -> Result<Option<Packet>, Error> {
}) })
} }
pub fn recv_timeout(linkno: u8, timeout_ms: Option<u64>, timer: GlobalTimer) -> Result<Packet, Error> { pub fn recv_timeout(linkno: u8, timeout_ms: Option<u64>, timer: GlobalTimer) -> Result<Packet, Error<!>> {
let timeout_ms = Milliseconds(timeout_ms.unwrap_or(10)); let timeout_ms = Milliseconds(timeout_ms.unwrap_or(10));
let limit = timer.get_time() + timeout_ms; let limit = timer.get_time() + timeout_ms;
while timer.get_time() < limit { while timer.get_time() < limit {
@ -108,8 +108,8 @@ pub fn recv_timeout(linkno: u8, timeout_ms: Option<u64>, timer: GlobalTimer) ->
Err(Error::TimedOut) Err(Error::TimedOut)
} }
fn transmit<F>(linkno: u8, f: F) -> Result<(), Error> fn transmit<F>(linkno: u8, f: F) -> Result<(), Error<!>>
where F: FnOnce(&mut [u8]) -> Result<usize, Error> { where F: FnOnce(&mut [u8]) -> Result<usize, Error<!>> {
let linkno = linkno as usize; let linkno = linkno as usize;
unsafe { unsafe {
while (DRTIOAUX[linkno].aux_tx_read)() != 0 {} while (DRTIOAUX[linkno].aux_tx_read)() != 0 {}
@ -121,7 +121,7 @@ where F: FnOnce(&mut [u8]) -> Result<usize, Error> {
} }
} }
pub fn send(linkno: u8, packet: &Packet) -> Result<(), Error> { pub fn send(linkno: u8, packet: &Packet) -> Result<(), Error<!>> {
transmit(linkno, |buffer| { transmit(linkno, |buffer| {
let mut writer = Cursor::new(buffer); let mut writer = Cursor::new(buffer);

16
src/libboard_artiq/src/drtioaux_async.rs
View File

@ -34,8 +34,8 @@ fn tx_ready(linkno: usize) -> nb::Result<(), Void> {
} }
} }
async fn receive<F, T>(linkno: u8, f: F) -> Result<Option<T>, Error> async fn receive<F, T>(linkno: u8, f: F) -> Result<Option<T>, Error<!>>
where F: FnOnce(&[u8]) -> Result<T, Error> { where F: FnOnce(&[u8]) -> Result<T, Error<!>> {
let linkidx = linkno as usize; let linkidx = linkno as usize;
unsafe { unsafe {
if (DRTIOAUX[linkidx].aux_rx_present_read)() == 1 { if (DRTIOAUX[linkidx].aux_rx_present_read)() == 1 {
@ -50,14 +50,14 @@ where F: FnOnce(&[u8]) -> Result<T, Error> {
} }
} }
pub async fn recv(linkno: u8) -> Result<Option<Packet>, Error> { pub async fn recv(linkno: u8) -> Result<Option<Packet>, Error<!>> {
if has_rx_error(linkno) { if has_rx_error(linkno) {
return Err(Error::GatewareError); return Err(Error::GatewareError);
} }
receive(linkno, |buffer| { receive(linkno, |buffer| {
if buffer.len() < 8 { if buffer.len() < 8 {
return Err(IoError::UnexpectedEnd).into()); return Err(IoError::UnexpectedEnd.into());
} }
let mut reader = Cursor::new(buffer); let mut reader = Cursor::new(buffer);
@ -75,7 +75,7 @@ pub async fn recv(linkno: u8) -> Result<Option<Packet>, Error> {
.await .await
} }
pub async fn recv_timeout(linkno: u8, timeout_ms: Option<u64>, timer: GlobalTimer) -> Result<Packet, Error> { pub async fn recv_timeout(linkno: u8, timeout_ms: Option<u64>, timer: GlobalTimer) -> Result<Packet, Error<!>> {
let timeout_ms = Milliseconds(timeout_ms.unwrap_or(10)); let timeout_ms = Milliseconds(timeout_ms.unwrap_or(10));
let limit = timer.get_time() + timeout_ms; let limit = timer.get_time() + timeout_ms;
let mut would_block = false; let mut would_block = false;
@ -95,8 +95,8 @@ pub async fn recv_timeout(linkno: u8, timeout_ms: Option<u64>, timer: GlobalTime
Err(Error::TimedOut) Err(Error::TimedOut)
} }
async fn transmit<F>(linkno: u8, f: F) -> Result<(), Error> async fn transmit<F>(linkno: u8, f: F) -> Result<(), Error<!>>
where F: FnOnce(&mut [u8]) -> Result<usize, Error> { where F: FnOnce(&mut [u8]) -> Result<usize, Error<!>> {
let linkno = linkno as usize; let linkno = linkno as usize;
unsafe { unsafe {
let _ = block_async!(tx_ready(linkno)).await; let _ = block_async!(tx_ready(linkno)).await;
@ -108,7 +108,7 @@ where F: FnOnce(&mut [u8]) -> Result<usize, Error> {
} }
} }
pub async fn send(linkno: u8, packet: &Packet) -> Result<(), Error> { pub async fn send(linkno: u8, packet: &Packet) -> Result<(), Error<!>> {
transmit(linkno, |buffer| { transmit(linkno, |buffer| {
let mut writer = Cursor::new(buffer); let mut writer = Cursor::new(buffer);

1
src/libboard_artiq/src/fiq.rs
View File

@ -1,5 +1,6 @@
use libboard_zynq::{println, stdio}; use libboard_zynq::{println, stdio};
use libcortex_a9::{interrupt_handler, regs::MPIDR}; use libcortex_a9::{interrupt_handler, regs::MPIDR};
use core::arch::asm;
use libregister::RegisterR; use libregister::RegisterR;
#[cfg(has_si549)] #[cfg(has_si549)]

2
src/libboard_artiq/src/lib.rs
View File

@ -1,7 +1,7 @@
#![no_std] #![no_std]
#![feature(never_type)] #![feature(never_type)]
#![feature(naked_functions)] #![feature(naked_functions)]
#![feature(asm)] #![allow(unexpected_cfgs)]
extern crate crc; extern crate crc;
extern crate embedded_hal; extern crate embedded_hal;

2
src/libbuild_zynq/lib.rs
View File

@ -1,3 +1,5 @@
#![allow(unexpected_cfgs)]
use std::{env, use std::{env,
fs::File, fs::File,
io::{BufRead, BufReader, Write}, io::{BufRead, BufReader, Write},

1
src/libio/lib.rs
View File

@ -1,5 +1,6 @@
#![no_std] #![no_std]
#![feature(never_type)] #![feature(never_type)]
#![allow(unexpected_cfgs)]
#[cfg(feature = "alloc")] #[cfg(feature = "alloc")]
extern crate alloc; extern crate alloc;

7
src/libksupport/Cargo.toml.tpl
View File

@ -17,6 +17,7 @@ void = { version = "1", default-features = false }
log_buffer = { version = "1.2" } log_buffer = { version = "1.2" }
libm = { version = "0.2", features = ["unstable"] } libm = { version = "0.2", features = ["unstable"] }
vcell = "0.1" vcell = "0.1"
nalgebra = { version = "0.33.0", default-features = false, features = ["libm", "alloc"]}
libboard_zynq = { path = "@@ZYNQ_RS@@/libboard_zynq", features = ["ipv6"]} libboard_zynq = { path = "@@ZYNQ_RS@@/libboard_zynq", features = ["ipv6"]}
libsupport_zynq = { path = "@@ZYNQ_RS@@/libsupport_zynq", default-features = false, features = ["alloc_core"] } libsupport_zynq = { path = "@@ZYNQ_RS@@/libsupport_zynq", default-features = false, features = ["alloc_core"] }
@ -31,9 +32,3 @@ unwind = { path = "../libunwind" }
libc = { path = "../libc" } libc = { path = "../libc" }
io = { path = "../libio" } io = { path = "../libio" }
libboard_artiq = { path = "../libboard_artiq" } libboard_artiq = { path = "../libboard_artiq" }
[dependencies.nalgebra]
git = "https://git.m-labs.hk/M-Labs/nalgebra.git"
rev = "dd00f9b"
default-features = false
features = ["libm", "alloc"]

12
src/libksupport/src/eh_artiq.rs
View File

@ -95,30 +95,30 @@ struct ExceptionBuffer {
} }
static mut EXCEPTION_BUFFER: ExceptionBuffer = ExceptionBuffer { static mut EXCEPTION_BUFFER: ExceptionBuffer = ExceptionBuffer {
uw_exceptions: [uw::_Unwind_Exception { uw_exceptions: [ const { uw::_Unwind_Exception {
exception_class: EXCEPTION_CLASS, exception_class: EXCEPTION_CLASS,
exception_cleanup: cleanup, exception_cleanup: cleanup,
private: [0; uw::unwinder_private_data_size], private: [0; uw::unwinder_private_data_size],
}; MAX_INFLIGHT_EXCEPTIONS], } }; MAX_INFLIGHT_EXCEPTIONS],
exceptions: [None; MAX_INFLIGHT_EXCEPTIONS + 1], exceptions: [None; MAX_INFLIGHT_EXCEPTIONS + 1],
exception_stack: [-1; MAX_INFLIGHT_EXCEPTIONS + 1], exception_stack: [-1; MAX_INFLIGHT_EXCEPTIONS + 1],
backtrace: [(0, 0); MAX_BACKTRACE_SIZE], backtrace: [(0, 0); MAX_BACKTRACE_SIZE],
backtrace_size: 0, backtrace_size: 0,
stack_pointers: [StackPointerBacktrace { stack_pointers: [ const { StackPointerBacktrace {
stack_pointer: 0, stack_pointer: 0,
initial_backtrace_size: 0, initial_backtrace_size: 0,
current_backtrace_size: 0, current_backtrace_size: 0,
}; MAX_INFLIGHT_EXCEPTIONS + 1], } }; MAX_INFLIGHT_EXCEPTIONS + 1],
exception_count: 0, exception_count: 0,
}; };
pub unsafe extern "C" fn reset_exception_buffer() { pub unsafe extern "C" fn reset_exception_buffer() {
trace!("reset exception buffer"); trace!("reset exception buffer");
EXCEPTION_BUFFER.uw_exceptions = [uw::_Unwind_Exception { EXCEPTION_BUFFER.uw_exceptions = [ const { uw::_Unwind_Exception {
exception_class: EXCEPTION_CLASS, exception_class: EXCEPTION_CLASS,
exception_cleanup: cleanup, exception_cleanup: cleanup,
private: [0; uw::unwinder_private_data_size], private: [0; uw::unwinder_private_data_size],
}; MAX_INFLIGHT_EXCEPTIONS]; } }; MAX_INFLIGHT_EXCEPTIONS];
EXCEPTION_BUFFER.exceptions = [None; MAX_INFLIGHT_EXCEPTIONS + 1]; EXCEPTION_BUFFER.exceptions = [None; MAX_INFLIGHT_EXCEPTIONS + 1];
EXCEPTION_BUFFER.exception_stack = [-1; MAX_INFLIGHT_EXCEPTIONS + 1]; EXCEPTION_BUFFER.exception_stack = [-1; MAX_INFLIGHT_EXCEPTIONS + 1];
EXCEPTION_BUFFER.backtrace_size = 0; EXCEPTION_BUFFER.backtrace_size = 0;

2
src/libksupport/src/irq.rs
View File

@ -1,5 +1,5 @@
use core::sync::atomic::{AtomicBool, Ordering}; use core::sync::atomic::{AtomicBool, Ordering};
use core::arch::asm;
use libboard_zynq::{gic, mpcore, println, stdio}; use libboard_zynq::{gic, mpcore, println, stdio};
use libcortex_a9::{asm, interrupt_handler, notify_spin_lock, regs::MPIDR, spin_lock_yield}; use libcortex_a9::{asm, interrupt_handler, notify_spin_lock, regs::MPIDR, spin_lock_yield};
use libregister::RegisterR; use libregister::RegisterR;

14
src/libksupport/src/rpc.rs
View File

@ -44,7 +44,7 @@ unsafe fn recv_elements<F, R, E>(
alloc: &mut F, alloc: &mut F,
) -> Result<(), E> ) -> Result<(), E>
where where
F: FnMut(usize) -> *mut (), F: FnMut(usize) -> Result<*mut (), E>,
R: Read + ?Sized, R: Read + ?Sized,
E: From<Error<R::ReadError>>, E: From<Error<R::ReadError>>,
{ {
@ -57,7 +57,6 @@ where
let ptr = storage as *mut u32; let ptr = storage as *mut u32;
let dest = core::slice::from_raw_parts_mut(ptr as *mut u8, length * 4); let dest = core::slice::from_raw_parts_mut(ptr as *mut u8, length * 4);
reader.read_exact(dest)?; reader.read_exact(dest)?;
drop(dest);
let dest = core::slice::from_raw_parts_mut(ptr, length); let dest = core::slice::from_raw_parts_mut(ptr, length);
NativeEndian::from_slice_u32(dest); NativeEndian::from_slice_u32(dest);
} }
@ -65,7 +64,6 @@ where
let ptr = storage as *mut u64; let ptr = storage as *mut u64;
let dest = core::slice::from_raw_parts_mut(ptr as *mut u8, length * 8); let dest = core::slice::from_raw_parts_mut(ptr as *mut u8, length * 8);
reader.read_exact(dest)?; reader.read_exact(dest)?;
drop(dest);
let dest = core::slice::from_raw_parts_mut(ptr, length); let dest = core::slice::from_raw_parts_mut(ptr, length);
NativeEndian::from_slice_u64(dest); NativeEndian::from_slice_u64(dest);
} }
@ -81,7 +79,7 @@ where
unsafe fn recv_value<F, R, E>(reader: &mut R, tag: Tag, data: &mut *mut (), alloc: &mut F) -> Result<(), E> unsafe fn recv_value<F, R, E>(reader: &mut R, tag: Tag, data: &mut *mut (), alloc: &mut F) -> Result<(), E>
where where
F: FnMut(usize) -> *mut (), F: FnMut(usize) -> Result<*mut (), E>,
R: Read + ?Sized, R: Read + ?Sized,
E: From<Error<R::ReadError>>, E: From<Error<R::ReadError>>,
{ {
@ -110,7 +108,7 @@ where
Tag::String | Tag::Bytes | Tag::ByteArray => { Tag::String | Tag::Bytes | Tag::ByteArray => {
consume_value!(CMutSlice<u8>, |ptr| { consume_value!(CMutSlice<u8>, |ptr| {
let length = reader.read_u32()? as usize; let length = reader.read_u32()? as usize;
*ptr = CMutSlice::new(alloc(length) as *mut u8, length); *ptr = CMutSlice::new(alloc(length)? as *mut u8, length);
reader.read_exact((*ptr).as_mut())?; reader.read_exact((*ptr).as_mut())?;
Ok(()) Ok(())
}) })
@ -140,7 +138,7 @@ where
let storage_offset = round_up(list_size, tag.alignment()); let storage_offset = round_up(list_size, tag.alignment());
let storage_size = tag.size() * length; let storage_size = tag.size() * length;
let allocation = alloc(storage_offset + storage_size) as *mut u8; let allocation = alloc(storage_offset + storage_size)? as *mut u8;
*ptr_to_list = allocation as *mut List; *ptr_to_list = allocation as *mut List;
let storage = allocation.offset(storage_offset as isize) as *mut (); let storage = allocation.offset(storage_offset as isize) as *mut ();
@ -159,7 +157,7 @@ where
} }
let elt_tag = it.clone().next().expect("truncated tag"); let elt_tag = it.clone().next().expect("truncated tag");
*buffer = alloc(elt_tag.size() * total_len); *buffer = alloc(elt_tag.size() * total_len)?;
recv_elements(reader, elt_tag, total_len, *buffer, alloc) recv_elements(reader, elt_tag, total_len, *buffer, alloc)
}) })
} }
@ -183,7 +181,7 @@ pub fn recv_return<'a, F, R, E>(
alloc: &mut F, alloc: &mut F,
) -> Result<&'a [u8], E> ) -> Result<&'a [u8], E>
where where
F: FnMut(usize) -> *mut (), F: FnMut(usize) -> Result<*mut (), E>,
R: Read + ?Sized, R: Read + ?Sized,
E: From<Error<R::ReadError>>, E: From<Error<R::ReadError>>,
{ {

17
src/libunwind/lib.rs
View File

@ -1,8 +1,5 @@
#![no_std] #![no_std]
#![feature(link_cfg)] #![feature(link_cfg)]
#![feature(nll)]
#![feature(unwind_attributes)]
#![feature(static_nobundle)]
#![cfg_attr(not(target_env = "msvc"), feature(libc))] #![cfg_attr(not(target_env = "msvc"), feature(libc))]
cfg_if::cfg_if! { cfg_if::cfg_if! {
@ -17,17 +14,3 @@ cfg_if::cfg_if! {
pub use backtrace::backtrace; pub use backtrace::backtrace;
} }
} }
#[cfg(target_env = "musl")]
#[link(name = "unwind", kind = "static", cfg(target_feature = "crt-static"))]
#[link(name = "gcc_s", cfg(not(target_feature = "crt-static")))]
extern "C" {}
#[cfg(target_os = "redox")]
#[link(name = "gcc_eh", kind = "static-nobundle", cfg(target_feature = "crt-static"))]
#[link(name = "gcc_s", cfg(not(target_feature = "crt-static")))]
extern "C" {}
#[cfg(all(target_vendor = "fortanix", target_env = "sgx"))]
#[link(name = "unwind", kind = "static-nobundle")]
extern "C" {}

9
src/libunwind/libunwind.rs
View File

@ -77,8 +77,7 @@ pub type _Unwind_Exception_Cleanup_Fn =
all(feature = "llvm-libunwind", any(target_os = "fuchsia", target_os = "linux")), all(feature = "llvm-libunwind", any(target_os = "fuchsia", target_os = "linux")),
link(name = "unwind", kind = "static") link(name = "unwind", kind = "static")
)] )]
extern "C" { extern "C-unwind" {
#[unwind(allowed)]
pub fn _Unwind_Resume(exception: *mut _Unwind_Exception) -> !; pub fn _Unwind_Resume(exception: *mut _Unwind_Exception) -> !;
pub fn _Unwind_DeleteException(exception: *mut _Unwind_Exception); pub fn _Unwind_DeleteException(exception: *mut _Unwind_Exception);
pub fn _Unwind_GetLanguageSpecificData(ctx: *mut _Unwind_Context) -> *mut c_void; pub fn _Unwind_GetLanguageSpecificData(ctx: *mut _Unwind_Context) -> *mut c_void;
@ -226,8 +225,7 @@ if #[cfg(not(all(target_os = "ios", target_arch = "arm")))] {
#[cfg_attr(all(feature = "llvm-libunwind", #[cfg_attr(all(feature = "llvm-libunwind",
any(target_os = "fuchsia", target_os = "linux")), any(target_os = "fuchsia", target_os = "linux")),
link(name = "unwind", kind = "static"))] link(name = "unwind", kind = "static"))]
extern "C" { extern "C-unwind" {
#[unwind(allowed)]
pub fn _Unwind_RaiseException(exception: *mut _Unwind_Exception) -> _Unwind_Reason_Code; pub fn _Unwind_RaiseException(exception: *mut _Unwind_Exception) -> _Unwind_Reason_Code;
pub fn _Unwind_Backtrace(trace: _Unwind_Trace_Fn, pub fn _Unwind_Backtrace(trace: _Unwind_Trace_Fn,
trace_argument: *mut c_void) trace_argument: *mut c_void)
@ -238,8 +236,7 @@ if #[cfg(not(all(target_os = "ios", target_arch = "arm")))] {
#[cfg_attr(all(feature = "llvm-libunwind", #[cfg_attr(all(feature = "llvm-libunwind",
any(target_os = "fuchsia", target_os = "linux")), any(target_os = "fuchsia", target_os = "linux")),
link(name = "unwind", kind = "static"))] link(name = "unwind", kind = "static"))]
extern "C" { extern "C-unwind" {
#[unwind(allowed)]
pub fn _Unwind_SjLj_RaiseException(e: *mut _Unwind_Exception) -> _Unwind_Reason_Code; pub fn _Unwind_SjLj_RaiseException(e: *mut _Unwind_Exception) -> _Unwind_Reason_Code;
} }

1
src/runtime/build.rs
View File

@ -1,3 +1,4 @@
#![allow(unexpected_cfgs)]
extern crate build_zynq; extern crate build_zynq;
fn main() { fn main() {

4
src/runtime/src/main.rs
View File

@ -1,9 +1,9 @@
#![no_std] #![no_std]
#![no_main] #![no_main]
#![recursion_limit = "1024"] // for futures_util::select! #![recursion_limit = "1024"] // for futures_util::select!
#![allow(unexpected_cfgs)]
#![feature(alloc_error_handler)] #![feature(alloc_error_handler)]
#![feature(const_btree_new)] #![feature(const_btree_len)]
#![feature(panic_info_message)]
#[macro_use] #[macro_use]
extern crate alloc; extern crate alloc;

4
src/runtime/src/panic.rs
View File

@ -22,7 +22,7 @@ fn panic(info: &core::panic::PanicInfo) -> ! {
} else { } else {
print!("unknown location"); print!("unknown location");
} }
if let Some(message) = info.message() { if let Some(message) = info.message().as_str() {
println!(": {}", message); println!(": {}", message);
} else { } else {
println!(""); println!("");
@ -61,7 +61,7 @@ fn soft_panic(info: &core::panic::PanicInfo) -> ! {
} else { } else {
error!("panic at unknown location"); error!("panic at unknown location");
} }
if let Some(message) = info.message() { if let Some(message) = info.message().as_str() {
error!("panic message: {}", message); error!("panic message: {}", message);
} }
let timer = GlobalTimer::start(); let timer = GlobalTimer::start();

7
src/satman/src/main.rs
View File

@ -1,6 +1,7 @@
#![no_std] #![no_std]
#![no_main] #![no_main]
#![feature(alloc_error_handler, try_trait, never_type, panic_info_message)] #![feature(alloc_error_handler, never_type)]
#![allow(unexpected_cfgs)]
#[macro_use] #[macro_use]
extern crate log; extern crate log;
@ -154,7 +155,7 @@ fn process_aux_packet(
kernel_manager: &mut KernelManager, kernel_manager: &mut KernelManager,
core_manager: &mut CoreManager, core_manager: &mut CoreManager,
router: &mut Router, router: &mut Router,
) -> Result<(), drtioaux::Error> { ) -> Result<(), drtioaux::Error<!>> {
// In the code below, *_chan_sel_write takes an u8 if there are fewer than 256 channels, // In the code below, *_chan_sel_write takes an u8 if there are fewer than 256 channels,
// and u16 otherwise; hence the `as _` conversion. // and u16 otherwise; hence the `as _` conversion.
match packet { match packet {
@ -1796,7 +1797,7 @@ pub fn panic_fmt(info: &core::panic::PanicInfo) -> ! {
} else { } else {
print!("unknown location"); print!("unknown location");
} }
if let Some(message) = info.message() { if let Some(message) = info.message().as_str() {
println!(": {}", message); println!(": {}", message);
} else { } else {
println!(""); println!("");

20
src/satman/src/repeater.rs
View File

@ -191,7 +191,7 @@ impl Repeater {
} }
} }
fn recv_aux_timeout(&self, timeout: u32, timer: &mut GlobalTimer) -> Result<drtioaux::Packet, drtioaux::Error> { fn recv_aux_timeout(&self, timeout: u32, timer: &mut GlobalTimer) -> Result<drtioaux::Packet, drtioaux::Error<!>> {
let max_time = timer.get_time() + Milliseconds(timeout.into()); let max_time = timer.get_time() + Milliseconds(timeout.into());
loop { loop {
if !rep_link_rx_up(self.repno) { if !rep_link_rx_up(self.repno) {
@ -216,7 +216,7 @@ impl Repeater {
rank: u8, rank: u8,
self_destination: u8, self_destination: u8,
timer: &mut GlobalTimer, timer: &mut GlobalTimer,
) -> Result<(), drtioaux::Error> { ) -> Result<(), drtioaux::Error<!>> {
self.aux_send(request)?; self.aux_send(request)?;
loop { loop {
let reply = self.recv_aux_timeout(200, timer)?; let reply = self.recv_aux_timeout(200, timer)?;
@ -242,14 +242,14 @@ impl Repeater {
Ok(()) Ok(())
} }
pub fn aux_send(&self, request: &drtioaux::Packet) -> Result<(), drtioaux::Error> { pub fn aux_send(&self, request: &drtioaux::Packet) -> Result<(), drtioaux::Error<!>> {
if self.state != RepeaterState::Up { if self.state != RepeaterState::Up {
return Err(drtioaux::Error::LinkDown); return Err(drtioaux::Error::LinkDown);
} }
drtioaux::send(self.auxno, request) drtioaux::send(self.auxno, request)
} }
pub fn sync_tsc(&self, timer: &mut GlobalTimer) -> Result<(), drtioaux::Error> { pub fn sync_tsc(&self, timer: &mut GlobalTimer) -> Result<(), drtioaux::Error<!>> {
if self.state != RepeaterState::Up { if self.state != RepeaterState::Up {
return Ok(()); return Ok(());
} }
@ -275,7 +275,7 @@ impl Repeater {
destination: u8, destination: u8,
hops: &[u8; drtio_routing::MAX_HOPS], hops: &[u8; drtio_routing::MAX_HOPS],
timer: &mut GlobalTimer, timer: &mut GlobalTimer,
) -> Result<(), drtioaux::Error> { ) -> Result<(), drtioaux::Error<!>> {
if self.state != RepeaterState::Up { if self.state != RepeaterState::Up {
return Ok(()); return Ok(());
} }
@ -299,14 +299,14 @@ impl Repeater {
&self, &self,
routing_table: &drtio_routing::RoutingTable, routing_table: &drtio_routing::RoutingTable,
timer: &mut GlobalTimer, timer: &mut GlobalTimer,
) -> Result<(), drtioaux::Error> { ) -> Result<(), drtioaux::Error<!>> {
for i in 0..drtio_routing::DEST_COUNT { for i in 0..drtio_routing::DEST_COUNT {
self.set_path(i as u8, &routing_table.0[i], timer)?; self.set_path(i as u8, &routing_table.0[i], timer)?;
} }
Ok(()) Ok(())
} }
pub fn set_rank(&self, rank: u8, timer: &mut GlobalTimer) -> Result<(), drtioaux::Error> { pub fn set_rank(&self, rank: u8, timer: &mut GlobalTimer) -> Result<(), drtioaux::Error<!>> {
if self.state != RepeaterState::Up { if self.state != RepeaterState::Up {
return Ok(()); return Ok(());
} }
@ -318,7 +318,7 @@ impl Repeater {
Ok(()) Ok(())
} }
pub fn rtio_reset(&self, timer: &mut GlobalTimer) -> Result<(), drtioaux::Error> { pub fn rtio_reset(&self, timer: &mut GlobalTimer) -> Result<(), drtioaux::Error<!>> {
let repno = self.repno as usize; let repno = self.repno as usize;
unsafe { unsafe {
(csr::DRTIOREP[repno].reset_write)(1); (csr::DRTIOREP[repno].reset_write)(1);
@ -361,11 +361,11 @@ impl Repeater {
) { ) {
} }
pub fn sync_tsc(&self, _timer: &mut GlobalTimer) -> Result<(), drtioaux::Error> { pub fn sync_tsc(&self, _timer: &mut GlobalTimer) -> Result<(), drtioaux::Error<!>> {
Ok(()) Ok(())
} }
pub fn rtio_reset(&self, _timer: &mut GlobalTimer) -> Result<(), drtioaux::Error> { pub fn rtio_reset(&self, _timer: &mut GlobalTimer) -> Result<(), drtioaux::Error<!>> {
Ok(()) Ok(())
} }
} }

2
src/satman/src/routing.rs
View File

@ -130,7 +130,7 @@ impl Router {
_routing_table: &drtio_routing::RoutingTable, _routing_table: &drtio_routing::RoutingTable,
_rank: u8, _rank: u8,
_destination: u8, _destination: u8,
) -> Result<(), drtioaux::Error> { ) -> Result<(), drtioaux::Error<!>> {
#[cfg(has_drtio_routing)] #[cfg(has_drtio_routing)]
{ {
let destination = packet.routable_destination(); let destination = packet.routable_destination();

277
src/satman/src/subkernel.rs
View File

@ -1,17 +1,21 @@
use alloc::{collections::BTreeMap, use alloc::{
format, collections::BTreeMap,
string::{String, ToString}, format,
vec::Vec}; string::{String, ToString},
use core::{option::NoneError, slice, str}; vec::Vec,
};
use core::{slice, str};
use cslice::AsCSlice; use cslice::AsCSlice;
use dma::{Error as DmaError, Manager as DmaManager}; use dma::{Error as DmaError, Manager as DmaManager};
use io::{Cursor, Error as IoError, ProtoWrite, Write}; use io::{Cursor, Error as IoError, ProtoWrite, Write};
use ksupport::{eh_artiq, kernel, rpc}; use ksupport::{eh_artiq, kernel, rpc};
use libboard_artiq::{drtio_routing::RoutingTable, use libboard_artiq::{
drtioaux, drtio_routing::RoutingTable,
drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE}, drtioaux,
pl::csr}; drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE},
pl::csr,
};
use libboard_zynq::{time::Milliseconds, timer::GlobalTimer}; use libboard_zynq::{time::Milliseconds, timer::GlobalTimer};
use libcortex_a9::sync_channel::Receiver; use libcortex_a9::sync_channel::Receiver;
use log::warn; use log::warn;
@ -51,6 +55,7 @@ enum KernelState {
}, },
} }
#[allow(dead_code)]
#[derive(Debug)] #[derive(Debug)]
pub enum Error { pub enum Error {
Load(String), Load(String),
@ -64,14 +69,8 @@ pub enum Error {
DmaError(DmaError), DmaError(DmaError),
} }
impl From<NoneError> for Error { impl<T> From<IoError<T>> for Error {
fn from(_: NoneError) -> Error { fn from(_value: IoError<T>) -> Error {
Error::KernelNotFound
}
}
impl From<IoError> for Error {
fn from(_value: IoError) -> Error {
Error::SubkernelIoError Error::SubkernelIoError
} }
} }
@ -88,8 +87,8 @@ impl From<()> for Error {
} }
} }
impl From<drtioaux::Error> for Error { impl<T> From<drtioaux::Error<T>> for Error {
fn from(_value: drtioaux::Error) -> Error { fn from(_value: drtioaux::Error<T>) -> Error {
Error::DrtioError Error::DrtioError
} }
} }
@ -125,7 +124,7 @@ struct MessageManager {
struct Session { struct Session {
id: u32, id: u32,
kernel_state: KernelState, kernel_state: KernelState,
last_exception: Option<Sliceable>, // exceptions raised locally last_exception: Option<Sliceable>, // exceptions raised locally
external_exception: Option<Vec<u8>>, // exceptions from sub-subkernels external_exception: Option<Vec<u8>>, // exceptions from sub-subkernels
messages: MessageManager, messages: MessageManager,
source: u8, // which destination requested running the kernel source: u8, // which destination requested running the kernel
@ -221,7 +220,10 @@ impl MessageManager {
} }
} }
pub fn get_outgoing_slice(&mut self, data_slice: &mut [u8; MASTER_PAYLOAD_MAX_SIZE]) -> Option<SliceMeta> { pub fn get_outgoing_slice(
&mut self,
data_slice: &mut [u8; MASTER_PAYLOAD_MAX_SIZE],
) -> Option<SliceMeta> {
if self.out_state != OutMessageState::MessageBeingSent { if self.out_state != OutMessageState::MessageBeingSent {
return None; return None;
} }
@ -302,7 +304,13 @@ impl<'a> Manager<'_> {
} }
} }
pub fn add(&mut self, id: u32, status: PayloadStatus, data: &[u8], data_len: usize) -> Result<(), Error> { pub fn add(
&mut self,
id: u32,
status: PayloadStatus,
data: &[u8],
data_len: usize,
) -> Result<(), Error> {
let kernel = match self.kernels.get_mut(&id) { let kernel = match self.kernels.get_mut(&id) {
Some(kernel) => { Some(kernel) => {
if kernel.complete || status.is_first() { if kernel.complete || status.is_first() {
@ -315,7 +323,7 @@ impl<'a> Manager<'_> {
complete: false, complete: false,
}, },
); );
self.kernels.get_mut(&id)? self.kernels.get_mut(&id).ok_or(Error::KernelNotFound)?
} else { } else {
kernel kernel
} }
@ -328,7 +336,7 @@ impl<'a> Manager<'_> {
complete: false, complete: false,
}, },
); );
self.kernels.get_mut(&id)? self.kernels.get_mut(&id).ok_or(Error::KernelNotFound)?
} }
}; };
kernel.library.extend(&data[0..data_len]); kernel.library.extend(&data[0..data_len]);
@ -373,10 +381,15 @@ impl<'a> Manager<'_> {
if !self.running() { if !self.running() {
return; return;
} }
self.session.messages.handle_incoming(status, id, length, slice); self.session
.messages
.handle_incoming(status, id, length, slice);
} }
pub fn message_get_slice(&mut self, slice: &mut [u8; MASTER_PAYLOAD_MAX_SIZE]) -> Option<SliceMeta> { pub fn message_get_slice(
&mut self,
slice: &mut [u8; MASTER_PAYLOAD_MAX_SIZE],
) -> Option<SliceMeta> {
if !self.running() { if !self.running() {
return None; return None;
} }
@ -395,15 +408,19 @@ impl<'a> Manager<'_> {
if self.session.id == id && self.session.kernel_state == KernelState::Loaded { if self.session.id == id && self.session.kernel_state == KernelState::Loaded {
return Ok(()); return Ok(());
} }
if !self.kernels.get(&id)?.complete { if !self.kernels.get(&id).ok_or(Error::KernelNotFound)?.complete {
return Err(Error::KernelNotFound); return Err(Error::KernelNotFound);
} }
self.session = Session::new(id); self.session = Session::new(id);
self.control.restart(); self.control.restart();
self.control self.control.tx.send(kernel::Message::LoadRequest(
.tx self.kernels
.send(kernel::Message::LoadRequest(self.kernels.get(&id)?.library.clone())); .get(&id)
.ok_or(Error::KernelNotFound)?
.library
.clone(),
));
let reply = self.control.rx.recv(); let reply = self.control.rx.recv();
match reply { match reply {
kernel::Message::LoadCompleted => Ok(()), kernel::Message::LoadCompleted => Ok(()),
@ -415,7 +432,10 @@ 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; MASTER_PAYLOAD_MAX_SIZE],
) -> SliceMeta {
match self.session.last_exception.as_mut() { match self.session.last_exception.as_mut() {
Some(exception) => exception.get_slice_master(data_slice), Some(exception) => exception.get_slice_master(data_slice),
None => SliceMeta { None => SliceMeta {
@ -569,7 +589,14 @@ impl<'a> Manager<'_> {
} }
} }
match self.process_kern_message(router, routing_table, rank, destination, dma_manager, timer) { match self.process_kern_message(
router,
routing_table,
rank,
destination,
dma_manager,
timer,
) {
Ok(true) => { Ok(true) => {
self.last_finished = Some(SubkernelFinished { self.last_finished = Some(SubkernelFinished {
id: self.session.id, id: self.session.id,
@ -612,7 +639,9 @@ impl<'a> Manager<'_> {
for (i, (status, exception_source)) in self.session.subkernels_finished.iter().enumerate() { for (i, (status, exception_source)) in self.session.subkernels_finished.iter().enumerate() {
if *status == id { if *status == id {
if exception_source.is_none() { if exception_source.is_none() {
self.control.tx.send(kernel::Message::SubkernelAwaitFinishReply); self.control
.tx
.send(kernel::Message::SubkernelAwaitFinishReply);
self.session.kernel_state = KernelState::Running; self.session.kernel_state = KernelState::Running;
self.session.subkernels_finished.swap_remove(i); self.session.subkernels_finished.swap_remove(i);
} else { } else {
@ -640,15 +669,26 @@ impl<'a> Manager<'_> {
if self.session.kernel_state == KernelState::SubkernelAwaitLoad { if self.session.kernel_state == KernelState::SubkernelAwaitLoad {
self.control self.control
.tx .tx
.send(kernel::Message::SubkernelLoadRunReply { succeeded: succeeded }); .send(kernel::Message::SubkernelLoadRunReply {
succeeded: succeeded,
});
self.session.kernel_state = KernelState::Running; self.session.kernel_state = KernelState::Running;
} else { } else {
warn!("received unsolicited SubkernelLoadRunReply"); warn!("received unsolicited SubkernelLoadRunReply");
} }
} }
pub fn remote_subkernel_finished(&mut self, id: u32, with_exception: bool, exception_source: u8) { pub fn remote_subkernel_finished(
let exception_src = if with_exception { Some(exception_source) } else { None }; &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)); self.session.subkernels_finished.push((id, exception_src));
} }
@ -661,18 +701,19 @@ impl<'a> Manager<'_> {
rank: u8, rank: u8,
self_destination: u8, self_destination: u8,
) { ) {
if let KernelState::SubkernelRetrievingException { destination } = self.session.kernel_state { if let KernelState::SubkernelRetrievingException { destination } = self.session.kernel_state
{
self.session self.session
.external_exception .external_exception
.as_mut() .as_mut()
.unwrap() .unwrap()
.extend_from_slice(exception_data); .extend_from_slice(exception_data);
if last { if last {
self.control self.control.tx.send(kernel::Message::SubkernelError(
.tx kernel::SubkernelStatus::Exception(
.send(kernel::Message::SubkernelError(kernel::SubkernelStatus::Exception(
self.session.external_exception.take().unwrap(), self.session.external_exception.take().unwrap(),
))); ),
));
self.session.kernel_state = KernelState::Running; self.session.kernel_state = KernelState::Running;
} else { } else {
/* fetch another slice */ /* fetch another slice */
@ -707,7 +748,12 @@ impl<'a> Manager<'_> {
dma_manager.cleanup(router, rank, self_destination, routing_table); dma_manager.cleanup(router, rank, self_destination, routing_table);
return Ok(true); return Ok(true);
} }
kernel::Message::KernelException(exceptions, stack_pointers, backtrace, async_errors) => { kernel::Message::KernelException(
exceptions,
stack_pointers,
backtrace,
async_errors,
) => {
error!("exception in kernel"); error!("exception in kernel");
for exception in exceptions { for exception in exceptions {
error!("{:?}", exception.unwrap()); error!("{:?}", exception.unwrap());
@ -716,12 +762,21 @@ impl<'a> Manager<'_> {
error!("backtrace: {:?}", backtrace); error!("backtrace: {:?}", backtrace);
let buf: Vec<u8> = Vec::new(); let buf: Vec<u8> = Vec::new();
let mut writer = Cursor::new(buf); let mut writer = Cursor::new(buf);
match write_exception(&mut writer, exceptions, stack_pointers, backtrace, async_errors) { match write_exception(
&mut writer,
exceptions,
stack_pointers,
backtrace,
async_errors,
) {
Ok(()) => (), Ok(()) => (),
Err(_) => error!("Error writing exception data"), Err(_) => error!("Error writing exception data"),
} }
self.kernel_stop(); self.kernel_stop();
return Err(Error::KernelException(Sliceable::new(0, writer.into_inner()))); return Err(Error::KernelException(Sliceable::new(
0,
writer.into_inner(),
)));
} }
kernel::Message::CachePutRequest(key, value) => { kernel::Message::CachePutRequest(key, value) => {
self.cache.insert(key, value); self.cache.insert(key, value);
@ -769,11 +824,13 @@ impl<'a> Manager<'_> {
let max_time = timer.get_time() + Milliseconds(10000); let max_time = timer.get_time() + Milliseconds(10000);
self.session.kernel_state = match self.session.kernel_state { self.session.kernel_state = match self.session.kernel_state {
// if we are still waiting for the traces to be uploaded, extend the state by timeout // if we are still waiting for the traces to be uploaded, extend the state by timeout
KernelState::DmaPendingPlayback { id, timestamp } => KernelState::DmaPendingAwait { KernelState::DmaPendingPlayback { id, timestamp } => {
id: id, KernelState::DmaPendingAwait {
timestamp: timestamp, id: id,
max_time: max_time, timestamp: timestamp,
}, max_time: max_time,
}
}
_ => KernelState::DmaAwait { max_time: max_time }, _ => KernelState::DmaAwait { max_time: max_time },
}; };
} }
@ -846,7 +903,10 @@ impl<'a> Manager<'_> {
)); ));
} }
_ => { _ => {
unexpected!("unexpected message from core1 while kernel was running: {:?}", reply); unexpected!(
"unexpected message from core1 while kernel was running: {:?}",
reply
);
} }
} }
Ok(false) Ok(false)
@ -864,9 +924,9 @@ impl<'a> Manager<'_> {
KernelState::MsgAwait { max_time, id, tags } => { KernelState::MsgAwait { max_time, id, tags } => {
if let Some(max_time) = *max_time { if let Some(max_time) = *max_time {
if timer.get_time() > max_time { if timer.get_time() > max_time {
self.control self.control.tx.send(kernel::Message::SubkernelError(
.tx kernel::SubkernelStatus::Timeout,
.send(kernel::Message::SubkernelError(kernel::SubkernelStatus::Timeout)); ));
self.session.kernel_state = KernelState::Running; self.session.kernel_state = KernelState::Running;
return Ok(()); return Ok(());
} }
@ -874,7 +934,9 @@ impl<'a> Manager<'_> {
if let Some(message) = self.session.messages.get_incoming(*id) { if let Some(message) = self.session.messages.get_incoming(*id) {
self.control self.control
.tx .tx
.send(kernel::Message::SubkernelMsgRecvReply { count: message.count }); .send(kernel::Message::SubkernelMsgRecvReply {
count: message.count,
});
let tags = tags.clone(); let tags = tags.clone();
self.session.kernel_state = KernelState::Running; self.session.kernel_state = KernelState::Running;
self.pass_message_to_kernel(&message, tags, timer) self.pass_message_to_kernel(&message, tags, timer)
@ -896,9 +958,9 @@ impl<'a> Manager<'_> {
KernelState::SubkernelAwaitFinish { max_time, id } => { KernelState::SubkernelAwaitFinish { max_time, id } => {
if let Some(max_time) = *max_time { if let Some(max_time) = *max_time {
if timer.get_time() > max_time { if timer.get_time() > max_time {
self.control self.control.tx.send(kernel::Message::SubkernelError(
.tx kernel::SubkernelStatus::Timeout,
.send(kernel::Message::SubkernelError(kernel::SubkernelStatus::Timeout)); ));
self.session.kernel_state = KernelState::Running; self.session.kernel_state = KernelState::Running;
return Ok(()); return Ok(());
} }
@ -924,7 +986,12 @@ impl<'a> Manager<'_> {
} }
} }
fn pass_message_to_kernel(&mut self, message: &Message, tags: Vec<u8>, timer: &GlobalTimer) -> Result<(), Error> { fn pass_message_to_kernel(
&mut self,
message: &Message,
tags: Vec<u8>,
timer: &GlobalTimer,
) -> Result<(), Error> {
let mut reader = Cursor::new(&message.data); let mut reader = Cursor::new(&message.data);
let mut current_tags: &[u8] = &tags; let mut current_tags: &[u8] = &tags;
let mut i = message.count; let mut i = message.count;
@ -935,33 +1002,54 @@ impl<'a> Manager<'_> {
}; };
let mut exception: Option<Sliceable> = None; let mut exception: Option<Sliceable> = None;
let mut unexpected: Option<String> = None; let mut unexpected: Option<String> = None;
let remaining_tags = rpc::recv_return(&mut reader, current_tags, slot, &mut |size| { let remaining_tags =
if size == 0 { rpc::recv_return(&mut reader, current_tags, slot, &mut |size| -> Result<
0 as *mut () _,
} else { Error,
self.control.tx.send(kernel::Message::RpcRecvReply(Ok(size))); > {
match recv_w_timeout(&mut self.control.rx, timer, 100) { if size == 0 {
Ok(kernel::Message::RpcRecvRequest(slot)) => slot, Ok(0 as *mut ())
Ok(kernel::Message::KernelException(exceptions, stack_pointers, backtrace, async_errors)) => { } else {
let buf: Vec<u8> = Vec::new(); self.control
let mut writer = Cursor::new(buf); .tx
match write_exception(&mut writer, exceptions, stack_pointers, backtrace, async_errors) { .send(kernel::Message::RpcRecvReply(Ok(size)));
Ok(()) => { match recv_w_timeout(&mut self.control.rx, timer, 100) {
exception = Some(Sliceable::new(0, writer.into_inner())); Ok(kernel::Message::RpcRecvRequest(slot)) => Ok(slot),
} Ok(kernel::Message::KernelException(
Err(_) => { exceptions,
unexpected = Some("Error writing exception data".to_string()); stack_pointers,
} backtrace,
}; async_errors,
0 as *mut () )) => {
} let buf: Vec<u8> = Vec::new();
other => { let mut writer = Cursor::new(buf);
unexpected = Some(format!("expected nested value slot from kernel CPU, not {:?}", other)); match write_exception(
0 as *mut () &mut writer,
exceptions,
stack_pointers,
backtrace,
async_errors,
) {
Ok(()) => {
exception = Some(Sliceable::new(0, writer.into_inner()));
}
Err(_) => {
unexpected =
Some("Error writing exception data".to_string());
}
};
Ok(0 as *mut ())
}
other => {
unexpected = Some(format!(
"expected nested value slot from kernel CPU, not {:?}",
other
));
Ok(0 as *mut ())
}
} }
} }
} })?;
})?;
if let Some(exception) = exception { if let Some(exception) = exception {
self.kernel_stop(); self.kernel_stop();
return Err(Error::KernelException(exception)); return Err(Error::KernelException(exception));
@ -1003,17 +1091,18 @@ where
writer.write_u32(u32::MAX)?; writer.write_u32(u32::MAX)?;
writer.write_u32(exception.message.as_ptr() as u32)?; writer.write_u32(exception.message.as_ptr() as u32)?;
} else { } else {
let msg = let msg = str::from_utf8(unsafe {
str::from_utf8(unsafe { slice::from_raw_parts(exception.message.as_ptr(), exception.message.len()) }) slice::from_raw_parts(exception.message.as_ptr(), exception.message.len())
.unwrap() })
.replace( .unwrap()
"{rtio_channel_info:0}", .replace(
&format!( "{rtio_channel_info:0}",
"0x{:04x}:{}", &format!(
exception.param[0], "0x{:04x}:{}",
ksupport::resolve_channel_name(exception.param[0] as u32) exception.param[0],
), ksupport::resolve_channel_name(exception.param[0] as u32)
); ),
);
writer.write_string(&msg)?; writer.write_string(&msg)?;
} }
writer.write_u64(exception.param[0] as u64)?; writer.write_u64(exception.param[0] as u64)?;