mirror of
https://github.com/saymrwulf/xous-core.git
synced 2026-11-20 09:03:28 +00:00
Merge branch 'bunnie-dev' of github.com:betrusted-io/xous-core into bunnie-dev
This commit is contained in:
commit
758bb64578
75 changed files with 1734 additions and 363 deletions
12
Cargo.lock
generated
12
Cargo.lock
generated
|
|
@ -1508,6 +1508,16 @@ dependencies = [
|
||||||
"xous-names",
|
"xous-names",
|
||||||
]
|
]
|
||||||
|
|
||||||
|
[[package]]
|
||||||
|
name = "svd2repl"
|
||||||
|
version = "0.1.0"
|
||||||
|
dependencies = [
|
||||||
|
"anyhow",
|
||||||
|
"clap",
|
||||||
|
"convert_case",
|
||||||
|
"quick-xml",
|
||||||
|
]
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "svd2utra"
|
name = "svd2utra"
|
||||||
version = "0.1.0"
|
version = "0.1.0"
|
||||||
|
|
@ -1922,7 +1932,7 @@ checksum = "b07db065a5cf61a7e4ba64f29e67db906fb1787316516c4e6e5ff0fea1efcd8a"
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "xous"
|
name = "xous"
|
||||||
version = "0.8.0"
|
version = "0.8.3"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"bitflags",
|
"bitflags",
|
||||||
"compiler_builtins",
|
"compiler_builtins",
|
||||||
|
|
|
||||||
|
|
@ -47,6 +47,7 @@ members = [
|
||||||
"services/rkyv-test-server",
|
"services/rkyv-test-server",
|
||||||
"services/rkyv-test-client",
|
"services/rkyv-test-client",
|
||||||
"services/shellchat",
|
"services/shellchat",
|
||||||
|
"svd2repl",
|
||||||
"svd2utra",
|
"svd2utra",
|
||||||
"xtask",
|
"xtask",
|
||||||
"imports/blitstr-ref",
|
"imports/blitstr-ref",
|
||||||
|
|
|
||||||
|
|
@ -64,6 +64,37 @@ of wear leveling, however.
|
||||||
+-----------+----------------------------------------+
|
+-----------+----------------------------------------+
|
||||||
|
|
||||||
```
|
```
|
||||||
|
The EC update block is further structured as follows:
|
||||||
|
```
|
||||||
|
+-----------+----------------------------------------+
|
||||||
|
+ 27F8_0000 | wf200 firmware control page |
|
||||||
|
+ +1000 | |
|
||||||
|
+-----------+----------------------------------------+
|
||||||
|
+ 27F8_1000 | up to 311k for wf200 firmware |
|
||||||
|
+ +4_D000 | padded with trailing 0xFF |
|
||||||
|
+-----------+----------------------------------------+
|
||||||
|
+ 27FC_E000 | EC firmware control page |
|
||||||
|
+ +1000 | |
|
||||||
|
+-----------+----------------------------------------+
|
||||||
|
+ 27FC_F000 | up to 199k EC fw |
|
||||||
|
+ +3_1000 | padded with trailing 0xFF |
|
||||||
|
+-----------+----------------------------------------+
|
||||||
|
|
||||||
|
```
|
||||||
|
|
||||||
|
The firmware control pages have the following structure:
|
||||||
|
```
|
||||||
|
base + 0x0000: [u8; 32] = SHA-512/256 hash from base+0x20 to last byte of firmware
|
||||||
|
base + 0x0020: [u8; 4] = EC: [0x70, 0x72, 0x65, 0x63]; // signature 'cerp' ('prec' in big endian) or WF200: [0x77, 0x66, 0x32, 0x30]; // 'wf20'
|
||||||
|
base + 0x0024: u32 = firmware control page version number (currently 1)
|
||||||
|
base + 0x0028: u32 = length of firmware in bytes, computed from start of first firmware page
|
||||||
|
base + 0x002c: [u8; 4052] = [0xff as u8; 4052] 0xff padding to start of first firmware page
|
||||||
|
base + 0x1000: [u8; FW_LEN] = actual firmware
|
||||||
|
|
||||||
|
remainder of unused sectors are 0xff pad. The 0xff pad is not hashed for performance reasons, and should
|
||||||
|
be considered insecure/untrusted.
|
||||||
|
```
|
||||||
|
|
||||||
|
|
||||||
The csr.csv block is further structured as follows:
|
The csr.csv block is further structured as follows:
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -44,6 +44,7 @@ the need from ever switching back to process 1.
|
||||||
Note that the kernel takes up a single 4 MB megapage, so it can be
|
Note that the kernel takes up a single 4 MB megapage, so it can be
|
||||||
assigned to every process simply by mapping megapage 1023 (`0xffc00000`).
|
assigned to every process simply by mapping megapage 1023 (`0xffc00000`).
|
||||||
|
|
||||||
|
```
|
||||||
| Address | Description
|
| Address | Description
|
||||||
| ---------- | -----------
|
| ---------- | -----------
|
||||||
| 0x00100000 | Default entrypoint for riscv64-unknown-elf-ld (as shown by `riscv64-unknown-elf-ld --verbose`)
|
| 0x00100000 | Default entrypoint for riscv64-unknown-elf-ld (as shown by `riscv64-unknown-elf-ld --verbose`)
|
||||||
|
|
@ -54,12 +55,14 @@ assigned to every process simply by mapping megapage 1023 (`0xffc00000`).
|
||||||
| 0xff801000 | Context data (registers, etc.)
|
| 0xff801000 | Context data (registers, etc.)
|
||||||
| 0xff802000 | Return address from syscalls (never allocated)
|
| 0xff802000 | Return address from syscalls (never allocated)
|
||||||
| 0xffc00000 | Kernel arguments, allocation tables
|
| 0xffc00000 | Kernel arguments, allocation tables
|
||||||
|
| 0xffcd0000 | Kernel WFI CSR page
|
||||||
| 0xffce0000 | Kernel TRNG CSR page
|
| 0xffce0000 | Kernel TRNG CSR page
|
||||||
| 0xffcf0000 | Supervisor UART CSR page
|
| 0xffcf0000 | Supervisor UART CSR page
|
||||||
| 0xffd00000 | Kernel binary image and data section
|
| 0xffd00000 | Kernel binary image and data section
|
||||||
| 0xfffefffc | "default" stack pointer (used by interrupt handlers)
|
| 0xfffefffc | "default" stack pointer (used by interrupt handlers)
|
||||||
| 0xffff0000 | Kernel stack top
|
| 0xffff0000 | Kernel stack top
|
||||||
| 0xfff00000 | {unused}
|
| 0xfff00000 | {unused}
|
||||||
|
```
|
||||||
|
|
||||||
Note that the stack pointer is not necessarily fixed, and may be changed
|
Note that the stack pointer is not necessarily fixed, and may be changed
|
||||||
in a later revision.
|
in a later revision.
|
||||||
|
|
|
||||||
|
|
@ -21,7 +21,7 @@ namespace Antmicro.Renode.Peripherals.Timers
|
||||||
[AllowedTranslations(AllowedTranslation.ByteToDoubleWord)]
|
[AllowedTranslations(AllowedTranslation.ByteToDoubleWord)]
|
||||||
public class TickTimer : BasicDoubleWordPeripheral, IKnownSize
|
public class TickTimer : BasicDoubleWordPeripheral, IKnownSize
|
||||||
{
|
{
|
||||||
public TickTimer(Machine machine, ulong periodInMs) : base(machine)
|
public TickTimer(Machine machine, ulong periodInMs = 1) : base(machine)
|
||||||
{
|
{
|
||||||
machine.ClockSource.AddClockEntry(new ClockEntry(periodInMs, ClockEntry.FrequencyToRatio(this, 1000), OnTick, this, "TickTimer"));
|
machine.ClockSource.AddClockEntry(new ClockEntry(periodInMs, ClockEntry.FrequencyToRatio(this, 1000), OnTick, this, "TickTimer"));
|
||||||
this.IRQ = new GPIO();
|
this.IRQ = new GPIO();
|
||||||
|
|
|
||||||
|
|
@ -14,6 +14,7 @@ namespace Antmicro.Renode.Peripherals.Miscellaneous
|
||||||
{
|
{
|
||||||
public BetrustedRNGKernel(Machine machine) : base(machine)
|
public BetrustedRNGKernel(Machine machine) : base(machine)
|
||||||
{
|
{
|
||||||
|
this.IRQ = new GPIO();
|
||||||
DefineRegisters();
|
DefineRegisters();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -35,6 +36,7 @@ namespace Antmicro.Renode.Peripherals.Miscellaneous
|
||||||
}
|
}
|
||||||
|
|
||||||
private readonly PseudorandomNumberGenerator rng = EmulationManager.Instance.CurrentEmulation.RandomGenerator;
|
private readonly PseudorandomNumberGenerator rng = EmulationManager.Instance.CurrentEmulation.RandomGenerator;
|
||||||
|
public GPIO IRQ { get; private set; }
|
||||||
|
|
||||||
private enum Registers
|
private enum Registers
|
||||||
{
|
{
|
||||||
|
|
|
||||||
|
|
@ -14,6 +14,7 @@ namespace Antmicro.Renode.Peripherals.Miscellaneous
|
||||||
{
|
{
|
||||||
public BetrustedRNGServer(Machine machine) : base(machine)
|
public BetrustedRNGServer(Machine machine) : base(machine)
|
||||||
{
|
{
|
||||||
|
this.IRQ = new GPIO();
|
||||||
DefineRegisters();
|
DefineRegisters();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -35,6 +36,7 @@ namespace Antmicro.Renode.Peripherals.Miscellaneous
|
||||||
}
|
}
|
||||||
|
|
||||||
private readonly PseudorandomNumberGenerator rng = EmulationManager.Instance.CurrentEmulation.RandomGenerator;
|
private readonly PseudorandomNumberGenerator rng = EmulationManager.Instance.CurrentEmulation.RandomGenerator;
|
||||||
|
public GPIO IRQ { get; private set; }
|
||||||
|
|
||||||
private enum Registers
|
private enum Registers
|
||||||
{
|
{
|
||||||
|
|
|
||||||
|
|
@ -1,62 +1,115 @@
|
||||||
|
// Renode Platform file generated by svd2repl
|
||||||
|
// This file is automatically generated
|
||||||
cpu: CPU.VexRiscv @ sysbus
|
cpu: CPU.VexRiscv @ sysbus
|
||||||
cpuType: "rv32imac"
|
cpuType: "rv32imac"
|
||||||
privilegeArchitecture: PrivilegeArchitecture.Priv1_10
|
privilegeArchitecture: PrivilegeArchitecture.Priv1_10
|
||||||
PerformanceInMips: 120
|
PerformanceInMips: 120
|
||||||
|
// Platform Peripherals
|
||||||
|
// Unrecognized peripheral: reboot
|
||||||
|
|
||||||
uart: UART.LiteX_UART @ {
|
// Unrecognized peripheral: crg
|
||||||
sysbus 0xF0004000 // shadow
|
|
||||||
}
|
|
||||||
-> cpu@1002
|
|
||||||
|
|
||||||
console: UART.LiteX_UART @ {
|
// Unrecognized peripheral: gpio
|
||||||
sysbus 0xF0006000
|
|
||||||
}
|
|
||||||
-> cpu@1003
|
|
||||||
|
|
||||||
app_uart: UART.LiteX_UART @ {
|
uart: UART.LiteX_UART @ sysbus 0xf0004000
|
||||||
sysbus 0xF0008000
|
-> cpu @ 1002
|
||||||
}
|
|
||||||
-> cpu@1004
|
|
||||||
|
|
||||||
timer0: Timers.LiteX_Timer_32 @ {
|
console: UART.LiteX_UART @ sysbus 0xf0006000
|
||||||
sysbus 0xF0022000
|
-> cpu @ 1003
|
||||||
}
|
|
||||||
frequency: 100000000
|
|
||||||
-> cpu@1001
|
|
||||||
|
|
||||||
rom: Memory.MappedMemory @ {
|
app_uart: UART.LiteX_UART @ sysbus 0xf0008000
|
||||||
sysbus 0x00000000;
|
-> cpu @ 1004
|
||||||
sysbus 0x80000000 // shadow
|
|
||||||
}
|
|
||||||
size: 0x00002000
|
|
||||||
|
|
||||||
sram: Memory.MappedMemory @ {
|
// Unrecognized peripheral: info
|
||||||
sysbus 0x40000000;
|
|
||||||
sysbus 0x90000000 // shadow
|
|
||||||
}
|
|
||||||
size: 16777216
|
|
||||||
|
|
||||||
fbmem: Memory.MappedMemory @ sysbus 0xB0000000
|
// Unrecognized peripheral: sram_ext
|
||||||
size: 0x6000
|
|
||||||
|
|
||||||
memlcd: Video.BetrustedLCD @ sysbus 0xF000B000
|
memlcd: Video.BetrustedLCD @ sysbus 0xf000b000
|
||||||
|
|
||||||
keyboard: Input.BetrustedKbd @ sysbus 0xF0015000
|
// Unrecognized peripheral: com
|
||||||
-> cpu @ 1011
|
|
||||||
|
|
||||||
trng_kernel: Miscellaneous.BetrustedRNGKernel @ sysbus 0xF001A000
|
// Unrecognized peripheral: i2c
|
||||||
|
|
||||||
trng_server: Miscellaneous.BetrustedRNGServer @ sysbus 0xF001B000
|
// Unrecognized peripheral: btevents
|
||||||
|
|
||||||
ticktimer: Timers.TickTimer @ sysbus 0xF0011000
|
// Unrecognized peripheral: messible
|
||||||
periodInMs: 1
|
|
||||||
|
// Unrecognized peripheral: messible2
|
||||||
|
|
||||||
|
ticktimer: Timers.TickTimer @ sysbus 0xf0011000
|
||||||
-> cpu @ 1008
|
-> cpu @ 1008
|
||||||
|
|
||||||
flash_mem: Memory.MappedMemory @ {
|
// Unrecognized peripheral: susres
|
||||||
sysbus 0x20000000;
|
|
||||||
sysbus 0xA0000000 // shadow
|
// Unrecognized peripheral: power
|
||||||
}
|
|
||||||
size: 0x8000000
|
// Unrecognized peripheral: spinor
|
||||||
|
|
||||||
|
keyboard: Input.BetrustedKbd @ sysbus 0xf0015000
|
||||||
|
-> cpu @ 1011
|
||||||
|
|
||||||
|
// Unrecognized peripheral: keyinject
|
||||||
|
|
||||||
|
// Unrecognized peripheral: seed
|
||||||
|
|
||||||
|
// Unrecognized peripheral: keyrom
|
||||||
|
|
||||||
|
// Unrecognized peripheral: audio
|
||||||
|
|
||||||
|
trng_kernel: Miscellaneous.BetrustedRNGKernel @ sysbus 0xf001a000
|
||||||
|
-> cpu @ 1013
|
||||||
|
|
||||||
|
trng_server: Miscellaneous.BetrustedRNGServer @ sysbus 0xf001b000
|
||||||
|
-> cpu @ 1014
|
||||||
|
|
||||||
|
// Unrecognized peripheral: trng
|
||||||
|
|
||||||
|
// Unrecognized peripheral: sha512
|
||||||
|
|
||||||
|
// Unrecognized peripheral: engine
|
||||||
|
|
||||||
|
// Unrecognized peripheral: jtag
|
||||||
|
|
||||||
|
// Unrecognized peripheral: wdt
|
||||||
|
|
||||||
|
// Unrecognized peripheral: d11ctime
|
||||||
|
|
||||||
|
// Unrecognized peripheral: identifier_mem
|
||||||
|
|
||||||
|
timer0: Timers.LiteX_Timer_32 @ sysbus 0xf0023000
|
||||||
|
frequency: 100000000
|
||||||
|
-> cpu @ 1000
|
||||||
|
|
||||||
|
|
||||||
|
// Physical base addresses of memory regions
|
||||||
|
rom: Memory.MappedMemory @ sysbus 0x00000000
|
||||||
|
size: 0x00008000
|
||||||
|
|
||||||
|
sram: Memory.MappedMemory @ sysbus 0x10000000
|
||||||
|
size: 0x00020000
|
||||||
|
|
||||||
|
vexriscv_debug: Memory.MappedMemory @ sysbus 0xefff0000
|
||||||
|
size: 0x00001000
|
||||||
|
|
||||||
|
sram_ext: Memory.MappedMemory @ sysbus 0x40000000
|
||||||
|
size: 0x01000000
|
||||||
|
|
||||||
|
fbmem: Memory.MappedMemory @ sysbus 0xb0000000
|
||||||
|
size: 0x00006000
|
||||||
|
|
||||||
|
spiflash: Memory.MappedMemory @ sysbus 0x20000000
|
||||||
|
size: 0x08000000
|
||||||
|
|
||||||
|
audio: Memory.MappedMemory @ sysbus 0xe0000000
|
||||||
|
size: 0x00001000
|
||||||
|
|
||||||
|
sha512: Memory.MappedMemory @ sysbus 0xe0002000
|
||||||
|
size: 0x00001000
|
||||||
|
|
||||||
|
engine: Memory.MappedMemory @ sysbus 0xe0020000
|
||||||
|
size: 0x00020000
|
||||||
|
|
||||||
|
|
||||||
|
|
||||||
sysbus:
|
sysbus:
|
||||||
init:
|
init:
|
||||||
|
|
|
||||||
4
kernel/Cargo.lock
generated
4
kernel/Cargo.lock
generated
|
|
@ -247,7 +247,7 @@ checksum = "67c21572b4949434e4fc1e1978b99c5f77064153c59d998bf13ecd96fb5ecba7"
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "kernel"
|
name = "kernel"
|
||||||
version = "0.8.0"
|
version = "0.8.2"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"bitflags",
|
"bitflags",
|
||||||
"crossbeam-channel",
|
"crossbeam-channel",
|
||||||
|
|
@ -551,7 +551,7 @@ checksum = "712e227841d057c1ee1cd2fb22fa7e5a5461ae8e48fa2ca79ec42cfc1931183f"
|
||||||
|
|
||||||
[[package]]
|
[[package]]
|
||||||
name = "xous"
|
name = "xous"
|
||||||
version = "0.8.0"
|
version = "0.8.3"
|
||||||
dependencies = [
|
dependencies = [
|
||||||
"bitflags",
|
"bitflags",
|
||||||
"hex",
|
"hex",
|
||||||
|
|
|
||||||
|
|
@ -1,18 +1,18 @@
|
||||||
[package]
|
[package]
|
||||||
name = "kernel"
|
|
||||||
version = "0.8.0"
|
|
||||||
authors = ["Sean Cross <sean@xobs.io>"]
|
authors = ["Sean Cross <sean@xobs.io>"]
|
||||||
edition = "2018"
|
|
||||||
description = "Core kernel for Xous, including task switching and memory management"
|
description = "Core kernel for Xous, including task switching and memory management"
|
||||||
|
edition = "2018"
|
||||||
|
name = "kernel"
|
||||||
|
version = "0.8.2"
|
||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
bitflags = "1.2.1"
|
bitflags = "1.2.1"
|
||||||
xous-kernel = { package = "xous", path = "../xous-rs", features = ["forget-memory-messages"] }
|
sha3 = {default-features = false, version = "0.8.2"}
|
||||||
stats_alloc = { version = "0.1.8", optional = true }
|
stats_alloc = {version = "0.1.8", optional = true}
|
||||||
sha3 = { default-features = false, version = "0.8.2" }
|
xous-kernel = {package = "xous", path = "../xous-rs", features = ["forget-memory-messages"]}
|
||||||
|
|
||||||
[target.'cfg(not(any(windows, unix)))'.dependencies]
|
[target.'cfg(not(any(windows, unix)))'.dependencies]
|
||||||
utralib = { path = "../utralib"}
|
utralib = {path = "../utralib"}
|
||||||
|
|
||||||
[target.'cfg(target_arch = "riscv32")'.dependencies]
|
[target.'cfg(target_arch = "riscv32")'.dependencies]
|
||||||
riscv = "0.5.6"
|
riscv = "0.5.6"
|
||||||
|
|
@ -22,15 +22,15 @@ debug-print = []
|
||||||
print-panics = []
|
print-panics = []
|
||||||
report-memory = ["stats_alloc"]
|
report-memory = ["stats_alloc"]
|
||||||
wrap-print = []
|
wrap-print = []
|
||||||
#default = ["print-panics", "debug-print"]
|
# default = ["print-panics", "debug-print", "wrap-print"]
|
||||||
default = ["print-panics"]
|
default = ["print-panics"]
|
||||||
|
|
||||||
[target.'cfg(any(windows, unix))'.dependencies]
|
[target.'cfg(any(windows, unix))'.dependencies]
|
||||||
|
crossbeam-channel = "0.5"
|
||||||
|
debug-here = "0.2.2"
|
||||||
|
hex = "0.4"
|
||||||
lazy_static = "1.4"
|
lazy_static = "1.4"
|
||||||
rand = "0.7"
|
rand = "0.7"
|
||||||
hex = "0.4"
|
|
||||||
debug-here = "0.2.2"
|
|
||||||
crossbeam-channel = "0.5"
|
|
||||||
|
|
||||||
[profile.release]
|
[profile.release]
|
||||||
codegen-units = 1 # 1 better optimizations
|
codegen-units = 1 # 1 better optimizations
|
||||||
|
|
|
||||||
|
|
@ -241,7 +241,12 @@ fn handle_connection(
|
||||||
| xous_kernel::Message::BlockingScalar(_) => (),
|
| xous_kernel::Message::BlockingScalar(_) => (),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
SysCall::ReturnMemory(ref _sender, ref mut buf, ref _offset, ref _valid) => {
|
SysCall::ReturnMemory(
|
||||||
|
ref _sender,
|
||||||
|
ref mut buf,
|
||||||
|
ref _offset,
|
||||||
|
ref _valid,
|
||||||
|
) => {
|
||||||
let sliced_data = data.into_boxed_slice();
|
let sliced_data = data.into_boxed_slice();
|
||||||
assert_eq!(
|
assert_eq!(
|
||||||
sliced_data.len(),
|
sliced_data.len(),
|
||||||
|
|
@ -275,7 +280,7 @@ fn handle_connection(
|
||||||
chn.send(ThreadMessage::SysCall(
|
chn.send(ThreadMessage::SysCall(
|
||||||
pid,
|
pid,
|
||||||
1,
|
1,
|
||||||
xous_kernel::SysCall::TerminateProcess,
|
xous_kernel::SysCall::TerminateProcess(0),
|
||||||
))
|
))
|
||||||
.unwrap();
|
.unwrap();
|
||||||
}
|
}
|
||||||
|
|
@ -537,7 +542,7 @@ pub fn idle() -> bool {
|
||||||
|
|
||||||
// If the call being made is to terminate the current process, we need to know
|
// If the call being made is to terminate the current process, we need to know
|
||||||
// because we won't be able to send a response.
|
// because we won't be able to send a response.
|
||||||
let is_terminate = call == SysCall::TerminateProcess;
|
let is_terminate = call == SysCall::TerminateProcess(0);
|
||||||
let is_shutdown = call == SysCall::Shutdown;
|
let is_shutdown = call == SysCall::Shutdown;
|
||||||
|
|
||||||
// For a "Shutdown" command, send the response before we issue the shutdown.
|
// For a "Shutdown" command, send the response before we issue the shutdown.
|
||||||
|
|
@ -557,7 +562,7 @@ pub fn idle() -> bool {
|
||||||
"Unable to send response to process: {:?} -- terminating",
|
"Unable to send response to process: {:?} -- terminating",
|
||||||
_e
|
_e
|
||||||
);
|
);
|
||||||
crate::syscall::handle(pid, thread_id, false, SysCall::TerminateProcess)
|
crate::syscall::handle(pid, thread_id, false, SysCall::TerminateProcess(0))
|
||||||
.ok();
|
.ok();
|
||||||
});
|
});
|
||||||
// println!("KERNEL: Done sending");
|
// println!("KERNEL: Done sending");
|
||||||
|
|
@ -599,7 +604,7 @@ pub fn idle() -> bool {
|
||||||
"KERNEL({}): Unable to send response to process: {:?} -- terminating",
|
"KERNEL({}): Unable to send response to process: {:?} -- terminating",
|
||||||
pid, _e
|
pid, _e
|
||||||
);
|
);
|
||||||
crate::syscall::handle(pid, thread_id, false, SysCall::TerminateProcess)
|
crate::syscall::handle(pid, thread_id, false, SysCall::TerminateProcess(0))
|
||||||
.ok();
|
.ok();
|
||||||
});
|
});
|
||||||
crate::arch::process::set_current_pid(existing_pid);
|
crate::arch::process::set_current_pid(existing_pid);
|
||||||
|
|
|
||||||
|
|
@ -1,10 +1,14 @@
|
||||||
// SPDX-FileCopyrightText: 2020 Sean Cross <sean@xobs.io>
|
// SPDX-FileCopyrightText: 2020 Sean Cross <sean@xobs.io>
|
||||||
// SPDX-License-Identifier: Apache-2.0
|
// SPDX-License-Identifier: Apache-2.0
|
||||||
|
|
||||||
use xous_kernel::{TID, PID};
|
use xous_kernel::{PID, TID};
|
||||||
|
|
||||||
pub fn enable_irq(_irq_no: usize) {
|
pub fn enable_irq(_irq_no: usize) {
|
||||||
unimplemented!();
|
unimplemented!()
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn disable_irq(_irq_no: usize) -> Result<(), xous_kernel::Error> {
|
||||||
|
unimplemented!()
|
||||||
}
|
}
|
||||||
|
|
||||||
pub unsafe fn set_isr_return_pair(_pid: PID, _ctx: TID) {
|
pub unsafe fn set_isr_return_pair(_pid: PID, _ctx: TID) {
|
||||||
|
|
|
||||||
|
|
@ -100,10 +100,6 @@ pub fn return_page_inner(
|
||||||
unimplemented!()
|
unimplemented!()
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn ensure_page_exists_inner(address: usize) -> Result<usize, xous_kernel::Error> {
|
|
||||||
unimplemented!()
|
|
||||||
}
|
|
||||||
|
|
||||||
pub fn unmap_page_inner(_mm: &mut MemoryManager, virt: usize) -> Result<usize, Error> {
|
pub fn unmap_page_inner(_mm: &mut MemoryManager, virt: usize) -> Result<usize, Error> {
|
||||||
Ok(virt)
|
Ok(virt)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -272,6 +272,10 @@ impl Process {
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn thread_exists(&self, _tid: TID) -> bool {
|
||||||
|
false
|
||||||
|
}
|
||||||
|
|
||||||
pub fn set_thread_result(&mut self, tid: TID, result: xous_kernel::Result) {
|
pub fn set_thread_result(&mut self, tid: TID, result: xous_kernel::Result) {
|
||||||
assert!(tid > 0);
|
assert!(tid > 0);
|
||||||
PROCESS_TABLE.with(|pt| {
|
PROCESS_TABLE.with(|pt| {
|
||||||
|
|
|
||||||
|
|
@ -1,9 +1,9 @@
|
||||||
// SPDX-FileCopyrightText: 2020 Sean Cross <sean@xobs.io>
|
// SPDX-FileCopyrightText: 2020 Sean Cross <sean@xobs.io>
|
||||||
// SPDX-License-Identifier: Apache-2.0
|
// SPDX-License-Identifier: Apache-2.0
|
||||||
|
|
||||||
#[cfg(any(windows,unix))]
|
#[cfg(any(windows, unix))]
|
||||||
mod hosted;
|
mod hosted;
|
||||||
#[cfg(any(windows,unix))]
|
#[cfg(any(windows, unix))]
|
||||||
pub use hosted::*;
|
pub use hosted::*;
|
||||||
|
|
||||||
#[cfg(target_arch = "riscv32")]
|
#[cfg(target_arch = "riscv32")]
|
||||||
|
|
@ -16,7 +16,7 @@ mod riscv;
|
||||||
#[cfg(all(target_arch = "riscv64", not(target_os = "xous")))]
|
#[cfg(all(target_arch = "riscv64", not(target_os = "xous")))]
|
||||||
pub use riscv::*;
|
pub use riscv::*;
|
||||||
|
|
||||||
#[cfg(all(target_arch = "x86_64", not(any(windows,unix))))]
|
#[cfg(all(target_arch = "x86_64", not(any(windows, unix))))]
|
||||||
mod x86_64;
|
mod x86_64;
|
||||||
#[cfg(all(target_arch = "x86_64", not(any(windows,unix))))]
|
#[cfg(all(target_arch = "x86_64", not(any(windows, unix))))]
|
||||||
pub use x86_64::*;
|
pub use x86_64::*;
|
||||||
|
|
|
||||||
|
|
@ -60,7 +60,7 @@ pub fn idle() -> bool {
|
||||||
// Issue `wfi`. This will return as soon as an external interrupt
|
// Issue `wfi`. This will return as soon as an external interrupt
|
||||||
// is available.
|
// is available.
|
||||||
if false {
|
if false {
|
||||||
// "traditional" path for stopping a clock
|
// "traditional" path for stopping a clock - effectively a NOP, doesn't do anything
|
||||||
unsafe { riscv::asm::wfi() };
|
unsafe { riscv::asm::wfi() };
|
||||||
} else {
|
} else {
|
||||||
// this invokes Precusor-SoC specific path to gate clocks:
|
// this invokes Precusor-SoC specific path to gate clocks:
|
||||||
|
|
|
||||||
|
|
@ -213,9 +213,7 @@ impl RiscvException {
|
||||||
15 => StorePageFault(epc, tval),
|
15 => StorePageFault(epc, tval),
|
||||||
x @ 10 | x @ 14 | x @ 16..=0x7fffffff => ReservedFault(x, epc, tval),
|
x @ 10 | x @ 14 | x @ 16..=0x7fffffff => ReservedFault(x, epc, tval),
|
||||||
|
|
||||||
x => {
|
x => ReservedInterrupt(x & 0x7fffffff, epc),
|
||||||
ReservedInterrupt(x & 0x7fffffff, epc)
|
|
||||||
}
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -4,7 +4,7 @@
|
||||||
use crate::arch::current_pid;
|
use crate::arch::current_pid;
|
||||||
use crate::arch::mem::MemoryMapping;
|
use crate::arch::mem::MemoryMapping;
|
||||||
use crate::arch::process::Process as ArchProcess;
|
use crate::arch::process::Process as ArchProcess;
|
||||||
use crate::arch::process::{Thread, RETURN_FROM_ISR};
|
use crate::arch::process::{Thread, EXIT_THREAD, RETURN_FROM_ISR};
|
||||||
use crate::services::SystemServices;
|
use crate::services::SystemServices;
|
||||||
use riscv::register::{scause, sepc, sstatus, stval, vexriscv::sim, vexriscv::sip};
|
use riscv::register::{scause, sepc, sstatus, stval, vexriscv::sim, vexriscv::sip};
|
||||||
use xous_kernel::{SysCall, PID, TID};
|
use xous_kernel::{SysCall, PID, TID};
|
||||||
|
|
@ -77,7 +77,7 @@ pub extern "C" fn trap_handler(
|
||||||
panic!("Ran out of kernel stack");
|
panic!("Ran out of kernel stack");
|
||||||
}
|
}
|
||||||
|
|
||||||
let pid = crate::arch::current_pid();
|
let pid = current_pid();
|
||||||
|
|
||||||
if (sc.bits() == 9) || (sc.bits() == 8) {
|
if (sc.bits() == 9) || (sc.bits() == 8) {
|
||||||
// We got here because of an `ecall` instruction. When we return, skip
|
// We got here because of an `ecall` instruction. When we return, skip
|
||||||
|
|
@ -149,6 +149,18 @@ pub extern "C" fn trap_handler(
|
||||||
);
|
);
|
||||||
println!("Page was not allocated");
|
println!("Page was not allocated");
|
||||||
}
|
}
|
||||||
|
RiscvException::InstructionPageFault(EXIT_THREAD, _offset) => {
|
||||||
|
let tid = ArchProcess::with_current(|process| process.current_tid());
|
||||||
|
|
||||||
|
// This address indicates a thread has exited. Destroy the thread.
|
||||||
|
// This activates another thread within this process.
|
||||||
|
SystemServices::with_mut(|ss| ss.destroy_thread(pid, tid)).unwrap();
|
||||||
|
|
||||||
|
// Resume the new thread within the same process.
|
||||||
|
ArchProcess::with_current_mut(|p| {
|
||||||
|
crate::arch::syscall::resume(current_pid().get() == 1, p.current_thread())
|
||||||
|
});
|
||||||
|
}
|
||||||
RiscvException::InstructionPageFault(RETURN_FROM_ISR, _offset) => {
|
RiscvException::InstructionPageFault(RETURN_FROM_ISR, _offset) => {
|
||||||
// If we hit this address, then an ISR has just returned. Since
|
// If we hit this address, then an ISR has just returned. Since
|
||||||
// we're in an interrupt context, it is safe to access this
|
// we're in an interrupt context, it is safe to access this
|
||||||
|
|
|
||||||
|
|
@ -21,6 +21,15 @@ extern "C" {
|
||||||
fn flush_mmu();
|
fn flush_mmu();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub unsafe fn memset(s: *mut u8, c: i32, n: usize) -> *mut u8 {
|
||||||
|
let mut i = 0;
|
||||||
|
while i < n {
|
||||||
|
*s.offset(i as isize) = c as u8;
|
||||||
|
i += 1;
|
||||||
|
}
|
||||||
|
s
|
||||||
|
}
|
||||||
|
|
||||||
bitflags! {
|
bitflags! {
|
||||||
pub struct MMUFlags: usize {
|
pub struct MMUFlags: usize {
|
||||||
const NONE = 0b00_0000_0000;
|
const NONE = 0b00_0000_0000;
|
||||||
|
|
@ -199,7 +208,7 @@ impl MemoryMapping {
|
||||||
|
|
||||||
// Zero-out the new page
|
// Zero-out the new page
|
||||||
let page_addr = l0pt_virt as *mut usize;
|
let page_addr = l0pt_virt as *mut usize;
|
||||||
unsafe { page_addr.write_bytes(0, PAGE_SIZE / core::mem::size_of::<usize>()) };
|
unsafe { memset(page_addr as *mut u8, 0, PAGE_SIZE) };
|
||||||
}
|
}
|
||||||
|
|
||||||
let ref mut l0_pt = unsafe { &mut (*(l0pt_virt as *mut LeafPageTable)) };
|
let ref mut l0_pt = unsafe { &mut (*(l0pt_virt as *mut LeafPageTable)) };
|
||||||
|
|
@ -337,46 +346,52 @@ pub fn map_page_inner(
|
||||||
assert!((virt & 0xfff) == 0);
|
assert!((virt & 0xfff) == 0);
|
||||||
|
|
||||||
// The root (l1) pagetable is defined to be mapped into our virtual
|
// The root (l1) pagetable is defined to be mapped into our virtual
|
||||||
// address space at this address.
|
// address space at 0xff80_0000.
|
||||||
let l1_pt = unsafe { &mut (*(PAGE_TABLE_ROOT_OFFSET as *mut RootPageTable)) };
|
let l1_pt = PAGE_TABLE_ROOT_OFFSET as *mut usize;
|
||||||
let ref mut l1_pt = l1_pt.entries;
|
|
||||||
|
|
||||||
// Subsequent pagetables are defined as being mapped starting at
|
// Subsequent pagetables are defined as being mapped starting at
|
||||||
// offset 0x0020_0004, so 4 must be added to the ppn1 value.
|
// offset 0xff40_0000.
|
||||||
let l0pt_virt = PAGE_TABLE_OFFSET + vpn1 * PAGE_SIZE;
|
let l0_pt = (PAGE_TABLE_OFFSET + vpn1 * PAGE_SIZE) as *mut usize;
|
||||||
let ref mut l0_pt = unsafe { &mut (*(l0pt_virt as *mut LeafPageTable)) };
|
|
||||||
|
|
||||||
// Allocate a new level 1 pagetable entry if one doesn't exist.
|
// Allocate a new level 1 pagetable entry if one doesn't exist.
|
||||||
if l1_pt[vpn1 as usize] & MMUFlags::VALID.bits() == 0 {
|
if unsafe { l1_pt.add(vpn1).read_volatile() } & MMUFlags::VALID.bits() == 0 {
|
||||||
// Allocate a fresh page
|
// Allocate a fresh page for the level 1 page table.
|
||||||
let l0pt_phys = mm.alloc_page(pid)?;
|
let l0_pt_phys = mm.alloc_page(pid)?;
|
||||||
|
|
||||||
// Mark this entry as a leaf node (WRX as 0), and indicate
|
// Mark this entry as a leaf node (WRX as 0), and indicate
|
||||||
// it is a valid page by setting "V".
|
// it is a valid page by setting "V".
|
||||||
l1_pt[vpn1 as usize] = ((l0pt_phys >> 12) << 10) | MMUFlags::VALID.bits();
|
unsafe {
|
||||||
unsafe { flush_mmu() };
|
l1_pt
|
||||||
|
.add(vpn1)
|
||||||
|
.write_volatile(((l0_pt_phys >> 12) << 10) | MMUFlags::VALID.bits());
|
||||||
|
flush_mmu();
|
||||||
|
}
|
||||||
|
|
||||||
// Map the new physical page to the virtual page, so we can access it.
|
// Map the new physical page to the virtual page, so we can access it.
|
||||||
map_page_inner(
|
map_page_inner(
|
||||||
mm,
|
mm,
|
||||||
pid,
|
pid,
|
||||||
l0pt_phys,
|
l0_pt_phys,
|
||||||
l0pt_virt,
|
l0_pt as usize,
|
||||||
MemoryFlags::W | MemoryFlags::R,
|
MemoryFlags::W | MemoryFlags::R,
|
||||||
false,
|
false,
|
||||||
)?;
|
)?;
|
||||||
|
|
||||||
// Zero-out the new page
|
// Zero-out the new page
|
||||||
let page_addr = l0pt_virt as *mut usize;
|
unsafe { memset(l0_pt as *mut u8, 0, PAGE_SIZE) };
|
||||||
unsafe { page_addr.write_bytes(0, PAGE_SIZE / core::mem::size_of::<usize>()) };
|
|
||||||
}
|
}
|
||||||
|
|
||||||
// Ensure the entry hasn't already been mapped.
|
// Ensure the entry hasn't already been mapped.
|
||||||
if l0_pt.entries[vpn0 as usize] & 1 != 0 {
|
if unsafe { l0_pt.add(vpn0).read_volatile() } & 1 != 0 {
|
||||||
panic!("Page {:08x} already allocated!", virt);
|
panic!("Page {:08x} already allocated!", virt);
|
||||||
}
|
}
|
||||||
l0_pt.entries[vpn0 as usize] =
|
unsafe {
|
||||||
(ppn1 << 20) | (ppn0 << 10) | (flags | MMUFlags::VALID | MMUFlags::D | MMUFlags::A).bits();
|
l0_pt.add(vpn0).write_volatile(
|
||||||
|
(ppn1 << 20)
|
||||||
|
| (ppn0 << 10)
|
||||||
|
| (flags | MMUFlags::VALID | MMUFlags::D | MMUFlags::A).bits(),
|
||||||
|
)
|
||||||
|
};
|
||||||
unsafe { flush_mmu() };
|
unsafe { flush_mmu() };
|
||||||
|
|
||||||
Ok(())
|
Ok(())
|
||||||
|
|
@ -462,6 +477,16 @@ pub fn move_page_inner(
|
||||||
result
|
result
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Determine if a page has been lent.
|
||||||
|
pub fn page_is_lent(src_addr: *mut u8) -> bool {
|
||||||
|
let entry = if let Ok(val) = pagetable_entry(src_addr as usize) {
|
||||||
|
val
|
||||||
|
} else {
|
||||||
|
return false;
|
||||||
|
};
|
||||||
|
*entry & MMUFlags::S.bits() != 0
|
||||||
|
}
|
||||||
|
|
||||||
/// Mark the given virtual address as being lent. If `writable`, clear the
|
/// Mark the given virtual address as being lent. If `writable`, clear the
|
||||||
/// `valid` bit so that this process can't accidentally write to this page while
|
/// `valid` bit so that this process can't accidentally write to this page while
|
||||||
/// it is lent.
|
/// it is lent.
|
||||||
|
|
@ -650,7 +675,7 @@ pub fn ensure_page_exists_inner(address: usize) -> Result<usize, xous_kernel::Er
|
||||||
flush_mmu();
|
flush_mmu();
|
||||||
|
|
||||||
// Zero-out the page
|
// Zero-out the page
|
||||||
(virt as *mut usize).write_bytes(0, PAGE_SIZE / core::mem::size_of::<usize>());
|
memset(virt as *mut u8, 0, PAGE_SIZE);
|
||||||
|
|
||||||
// Move the page into userspace
|
// Move the page into userspace
|
||||||
*entry = (ppn1 << 20)
|
*entry = (ppn1 << 20)
|
||||||
|
|
|
||||||
|
|
@ -19,7 +19,7 @@ pub const MAX_PROCESS_COUNT: usize = 64;
|
||||||
pub const RETURN_FROM_ISR: usize = 0xff80_2000;
|
pub const RETURN_FROM_ISR: usize = 0xff80_2000;
|
||||||
|
|
||||||
/// This is the address a thread will return to when it exits.
|
/// This is the address a thread will return to when it exits.
|
||||||
const EXIT_THREAD: usize = 0xff80_3000;
|
pub const EXIT_THREAD: usize = 0xff80_3000;
|
||||||
|
|
||||||
// Thread IDs have three possible meaning:
|
// Thread IDs have three possible meaning:
|
||||||
// Logical Thread ID: What the user sees
|
// Logical Thread ID: What the user sees
|
||||||
|
|
@ -35,13 +35,16 @@ const EXIT_THREAD: usize = 0xff80_3000;
|
||||||
// Therefore, the first Logical Thread ID is 1, which maps
|
// Therefore, the first Logical Thread ID is 1, which maps
|
||||||
// to Hardware Thread ID 2, which is Thread Context Index 1.
|
// to Hardware Thread ID 2, which is Thread Context Index 1.
|
||||||
//
|
//
|
||||||
// +----------------+---------------+------------------+
|
// +-----------------+-----------------+-----------------+
|
||||||
// | Logical Thread | Context Index | Hardware Thread |
|
// | Thread ID | Context Index | Hardware Thread |
|
||||||
// +================+===============+==================+
|
// +=================+=================+=================+
|
||||||
// | ISR Context | 0 | 1 |
|
// | ISR Context | 0 | 1 |
|
||||||
// | 1 | 1 | 2 |
|
// | 1 | 1 | 2 |
|
||||||
// | 2 | 2 | 3 |
|
// | 2 | 2 | 3 |
|
||||||
|
|
||||||
|
// ProcessImpl occupies a multiple of pages mapped to virtual address `0xff80_1000`.
|
||||||
|
// Each thread is 128 bytes (32 4-byte registers). The first "thread" does not exist,
|
||||||
|
// and instead is any bookkeeping information related to the process.
|
||||||
#[derive(Debug, Copy, Clone)]
|
#[derive(Debug, Copy, Clone)]
|
||||||
#[repr(C)]
|
#[repr(C)]
|
||||||
struct ProcessImpl {
|
struct ProcessImpl {
|
||||||
|
|
@ -70,16 +73,13 @@ struct ProcessTable {
|
||||||
/// The process upon which the current syscall is operating
|
/// The process upon which the current syscall is operating
|
||||||
current: PID,
|
current: PID,
|
||||||
|
|
||||||
/// The number of processes that exist
|
/// The actual table contents. `true` if a process is allocated,
|
||||||
// total: usize,
|
/// `false` if it is free.
|
||||||
|
|
||||||
/// The actual table contents
|
|
||||||
table: [bool; MAX_PROCESS_COUNT],
|
table: [bool; MAX_PROCESS_COUNT],
|
||||||
}
|
}
|
||||||
|
|
||||||
static mut PROCESS_TABLE: ProcessTable = ProcessTable {
|
static mut PROCESS_TABLE: ProcessTable = ProcessTable {
|
||||||
current: unsafe { PID::new_unchecked(1) },
|
current: unsafe { PID::new_unchecked(1) },
|
||||||
// total: 0,
|
|
||||||
table: [false; MAX_PROCESS_COUNT],
|
table: [false; MAX_PROCESS_COUNT],
|
||||||
};
|
};
|
||||||
|
|
||||||
|
|
@ -185,6 +185,10 @@ impl Process {
|
||||||
process.hardware_thread - 1
|
process.hardware_thread - 1
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn thread_exists(&self, tid: TID) -> bool {
|
||||||
|
self.thread(tid).sepc != 0
|
||||||
|
}
|
||||||
|
|
||||||
/// Set the current thread number.
|
/// Set the current thread number.
|
||||||
pub fn set_thread(&mut self, thread: TID) -> Result<(), xous_kernel::Error> {
|
pub fn set_thread(&mut self, thread: TID) -> Result<(), xous_kernel::Error> {
|
||||||
let mut process = unsafe { &mut *PROCESS };
|
let mut process = unsafe { &mut *PROCESS };
|
||||||
|
|
@ -208,15 +212,15 @@ impl Process {
|
||||||
&mut process.threads[thread]
|
&mut process.threads[thread]
|
||||||
}
|
}
|
||||||
|
|
||||||
// pub fn thread(&self, thread: TID) -> &Thread {
|
pub fn thread(&self, thread: TID) -> &Thread {
|
||||||
// let process = unsafe { &mut *PROCESS };
|
let process = unsafe { &mut *PROCESS };
|
||||||
// assert!(
|
assert!(
|
||||||
// thread <= process.threads.len(),
|
thread <= process.threads.len(),
|
||||||
// "attempt to retrieve an invalid thread {}",
|
"attempt to retrieve an invalid thread {}",
|
||||||
// thread
|
thread
|
||||||
// );
|
);
|
||||||
// &process.threads[thread]
|
&process.threads[thread]
|
||||||
// }
|
}
|
||||||
|
|
||||||
pub fn find_free_thread(&self) -> Option<TID> {
|
pub fn find_free_thread(&self) -> Option<TID> {
|
||||||
let process = unsafe { &mut *PROCESS };
|
let process = unsafe { &mut *PROCESS };
|
||||||
|
|
@ -353,6 +357,38 @@ impl Process {
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Destroy a given thread and return its return value.
|
||||||
|
///
|
||||||
|
/// # Returns
|
||||||
|
/// The return value of the function
|
||||||
|
///
|
||||||
|
/// # Errors
|
||||||
|
/// xous::ThreadNotAvailable - the thread did not exist
|
||||||
|
pub fn destroy_thread(&mut self, tid: TID) -> Result<usize, xous_kernel::Error> {
|
||||||
|
let thread = self.thread_mut(tid);
|
||||||
|
|
||||||
|
// Ensure this thread is valid
|
||||||
|
if thread.sepc == 0 || tid == IRQ_TID {
|
||||||
|
Err(xous_kernel::Error::ThreadNotAvailable)?;
|
||||||
|
}
|
||||||
|
|
||||||
|
// thread.registers[0] == x1
|
||||||
|
// thread.registers[1] == x2
|
||||||
|
// ...
|
||||||
|
// thread.registers[4] == x5 == t0
|
||||||
|
// ...
|
||||||
|
// thread.registers[9] == x10 == a0
|
||||||
|
// thread.registers[10] == x11 == a1
|
||||||
|
let return_value = thread.registers[9];
|
||||||
|
|
||||||
|
for val in &mut thread.registers {
|
||||||
|
*val = 0;
|
||||||
|
}
|
||||||
|
thread.sepc = 0;
|
||||||
|
|
||||||
|
Ok(return_value)
|
||||||
|
}
|
||||||
|
|
||||||
pub fn print_all_threads(&self) {
|
pub fn print_all_threads(&self) {
|
||||||
let process = unsafe { &mut *PROCESS };
|
let process = unsafe { &mut *PROCESS };
|
||||||
&mut process.threads[process.hardware_thread - 1];
|
&mut process.threads[process.hardware_thread - 1];
|
||||||
|
|
@ -432,17 +468,30 @@ impl Process {
|
||||||
todo!();
|
todo!();
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn destroy(_pid: PID) -> Result<(), xous_kernel::Error> {
|
pub fn destroy(pid: PID) -> Result<(), xous_kernel::Error> {
|
||||||
todo!();
|
let mut process_table = unsafe { &mut PROCESS_TABLE };
|
||||||
// let mut process_table = unsafe { &mut *PROCESS };
|
let pid_idx = pid.get() as usize - 1;
|
||||||
// let pid_idx = pid.get() as usize - 1;
|
if pid_idx >= process_table.table.len() {
|
||||||
// if pid_idx >= process_table.table.len() {
|
panic!("attempted to destroy PID that exceeds table index: {}", pid);
|
||||||
// panic!("attempted to destroy PID that exceeds table index: {}", pid);
|
}
|
||||||
// }
|
process_table.table[pid_idx] = false;
|
||||||
// let process = process_table.table[pid_idx].as_mut().unwrap();
|
Ok(())
|
||||||
// process_table.table[pid_idx] = None;
|
}
|
||||||
// process_table.total -= 1;
|
|
||||||
// Ok(())
|
pub fn find_thread<F>(&self, op: F) -> Option<(TID, &mut Thread)>
|
||||||
|
where
|
||||||
|
F: Fn(TID, &Thread) -> bool,
|
||||||
|
{
|
||||||
|
let process = unsafe { &mut *PROCESS };
|
||||||
|
for (idx, thread) in process.threads.iter_mut().enumerate() {
|
||||||
|
if thread.sepc == 0 {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
if op(idx, thread) {
|
||||||
|
return Some((idx, thread));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
None
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -451,6 +500,15 @@ impl Thread {
|
||||||
pub fn stack_pointer(&self) -> usize {
|
pub fn stack_pointer(&self) -> usize {
|
||||||
self.registers[1]
|
self.registers[1]
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn a0(&self) -> usize {
|
||||||
|
self.registers[9]
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn a1(&self) -> usize {
|
||||||
|
self.registers[10]
|
||||||
|
}
|
||||||
|
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn set_current_pid(pid: PID) {
|
pub fn set_current_pid(pid: PID) {
|
||||||
|
|
@ -473,31 +531,3 @@ pub fn current_pid() -> PID {
|
||||||
pub fn current_tid() -> TID {
|
pub fn current_tid() -> TID {
|
||||||
unsafe { ((*PROCESS).hardware_thread) - 1 }
|
unsafe { ((*PROCESS).hardware_thread) - 1 }
|
||||||
}
|
}
|
||||||
|
|
||||||
// pub struct ProcessHandle<'a> {
|
|
||||||
// process: &'a mut Process,
|
|
||||||
// }
|
|
||||||
|
|
||||||
// /// Wraps the MemoryManager in a safe mutex. Because of this, accesses
|
|
||||||
// /// to the Memory Manager should only be made during interrupt contexts.
|
|
||||||
// impl<'a> ProcessHandle<'a> {
|
|
||||||
// /// Get the singleton Process.
|
|
||||||
// pub fn get() -> ProcessHandle<'a> {
|
|
||||||
// ProcessHandle {
|
|
||||||
// process: unsafe { &mut *PROCESS },
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
|
|
||||||
// use core::ops::{Deref, DerefMut};
|
|
||||||
// impl Deref for ProcessHandle<'_> {
|
|
||||||
// type Target = Process;
|
|
||||||
// fn deref(&self) -> &Process {
|
|
||||||
// &*self.process
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
// impl DerefMut for ProcessHandle<'_> {
|
|
||||||
// fn deref_mut(&mut self) -> &mut Process {
|
|
||||||
// &mut *self.process
|
|
||||||
// }
|
|
||||||
// }
|
|
||||||
|
|
|
||||||
|
|
@ -1,8 +1,8 @@
|
||||||
// SPDX-FileCopyrightText: 2020 Sean Cross <sean@xobs.io>
|
// SPDX-FileCopyrightText: 2020 Sean Cross <sean@xobs.io>
|
||||||
// SPDX-License-Identifier: Apache-2.0
|
// SPDX-License-Identifier: Apache-2.0
|
||||||
|
|
||||||
use utralib::generated::*;
|
|
||||||
use crate::mem::MemoryManager;
|
use crate::mem::MemoryManager;
|
||||||
|
use utralib::generated::*;
|
||||||
use xous_kernel::{MemoryFlags, MemoryType, PID};
|
use xous_kernel::{MemoryFlags, MemoryType, PID};
|
||||||
|
|
||||||
pub const TRNG_KERNEL: Trng = Trng {
|
pub const TRNG_KERNEL: Trng = Trng {
|
||||||
|
|
|
||||||
|
|
@ -53,7 +53,7 @@ pub mod syscall {
|
||||||
|
|
||||||
pub mod mem {
|
pub mod mem {
|
||||||
use crate::mem::MemoryManager;
|
use crate::mem::MemoryManager;
|
||||||
use xous::{MemoryFlags, Error, PID};
|
use xous::{Error, MemoryFlags, PID};
|
||||||
#[derive(Copy, Clone, Default, PartialEq)]
|
#[derive(Copy, Clone, Default, PartialEq)]
|
||||||
pub struct MemoryMapping {}
|
pub struct MemoryMapping {}
|
||||||
impl MemoryMapping {
|
impl MemoryMapping {
|
||||||
|
|
@ -101,10 +101,7 @@ pub mod mem {
|
||||||
unimplemented!();
|
unimplemented!();
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn unmap_page_inner(
|
pub fn unmap_page_inner(mm: &mut MemoryManager, virt: usize) -> Result<usize, XousError> {
|
||||||
mm: &mut MemoryManager,
|
|
||||||
virt: usize,
|
|
||||||
) -> Result<usize, XousError> {
|
|
||||||
unimplemented!();
|
unimplemented!();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -28,7 +28,9 @@ pub struct KernelArgumentsIterator {
|
||||||
#[allow(dead_code)]
|
#[allow(dead_code)]
|
||||||
impl KernelArguments {
|
impl KernelArguments {
|
||||||
pub fn get() -> Self {
|
pub fn get() -> Self {
|
||||||
KernelArguments { base: unsafe { KERNEL_ARGUMENTS_BASE } }
|
KernelArguments {
|
||||||
|
base: unsafe { KERNEL_ARGUMENTS_BASE },
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub unsafe fn init(base: *const u32) {
|
pub unsafe fn init(base: *const u32) {
|
||||||
|
|
@ -58,14 +60,8 @@ pub struct KernelArgument {
|
||||||
impl KernelArgument {
|
impl KernelArgument {
|
||||||
pub fn new(base: *const u32, offset: usize) -> Self {
|
pub fn new(base: *const u32, offset: usize) -> Self {
|
||||||
let name = unsafe { base.add(offset / 4).read() } as u32;
|
let name = unsafe { base.add(offset / 4).read() } as u32;
|
||||||
let size = unsafe {
|
let size = unsafe { (base.add(offset / 4 + 1) as *const u16).add(1).read() } as usize;
|
||||||
(base.add(offset / 4 + 1) as *const u16)
|
let data = unsafe { core::slice::from_raw_parts(base.add(offset / 4 + 2), size) };
|
||||||
.add(1)
|
|
||||||
.read()
|
|
||||||
} as usize;
|
|
||||||
let data = unsafe {
|
|
||||||
core::slice::from_raw_parts(base.add(offset / 4 + 2), size)
|
|
||||||
};
|
|
||||||
KernelArgument {
|
KernelArgument {
|
||||||
name,
|
name,
|
||||||
size: size * 4,
|
size: size * 4,
|
||||||
|
|
|
||||||
|
|
@ -60,9 +60,7 @@ macro_rules! println
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(baremetal)]
|
#[cfg(baremetal)]
|
||||||
pub struct Uart {
|
pub struct Uart {}
|
||||||
// pub base: *mut usize,
|
|
||||||
}
|
|
||||||
#[cfg(baremetal)]
|
#[cfg(baremetal)]
|
||||||
static mut INITIALIZED: bool = false;
|
static mut INITIALIZED: bool = false;
|
||||||
|
|
||||||
|
|
@ -140,7 +138,11 @@ pub fn irq(_irq_number: usize, _arg: *mut usize) {
|
||||||
let current_pid = system_services.current_pid();
|
let current_pid = system_services.current_pid();
|
||||||
for process in &system_services.processes {
|
for process in &system_services.processes {
|
||||||
if !process.free() {
|
if !process.free() {
|
||||||
println!("PID {} {}:", process.pid, system_services.process_name(process.pid).unwrap_or(""));
|
println!(
|
||||||
|
"PID {} {}:",
|
||||||
|
process.pid,
|
||||||
|
system_services.process_name(process.pid).unwrap_or("")
|
||||||
|
);
|
||||||
process.activate().unwrap();
|
process.activate().unwrap();
|
||||||
crate::arch::mem::MemoryMapping::current().print_map();
|
crate::arch::mem::MemoryMapping::current().print_map();
|
||||||
println!();
|
println!();
|
||||||
|
|
@ -159,7 +161,11 @@ pub fn irq(_irq_number: usize, _arg: *mut usize) {
|
||||||
let current_pid = system_services.current_pid();
|
let current_pid = system_services.current_pid();
|
||||||
for process in &system_services.processes {
|
for process in &system_services.processes {
|
||||||
if !process.free() {
|
if !process.free() {
|
||||||
println!("PID {} {}:", process.pid, system_services.process_name(process.pid).unwrap_or(""));
|
println!(
|
||||||
|
"{:?} {}:",
|
||||||
|
process,
|
||||||
|
system_services.process_name(process.pid).unwrap_or("")
|
||||||
|
);
|
||||||
process.activate().unwrap();
|
process.activate().unwrap();
|
||||||
crate::arch::process::Process::with_current_mut(|arch_process| {
|
crate::arch::process::Process::with_current_mut(|arch_process| {
|
||||||
arch_process.print_all_threads()
|
arch_process.print_all_threads()
|
||||||
|
|
|
||||||
|
|
@ -65,3 +65,18 @@ pub fn interrupt_claim(
|
||||||
result
|
result
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Iterate through the IRQ handlers and remove any handler that exists
|
||||||
|
/// for the given PID.
|
||||||
|
pub fn release_interrupts_for_pid(pid: PID) {
|
||||||
|
unsafe {
|
||||||
|
for (irq, handler) in IRQ_HANDLERS.iter_mut().enumerate() {
|
||||||
|
if let Some(h) = handler {
|
||||||
|
if h.0 == pid {
|
||||||
|
arch::irq::disable_irq(irq).unwrap();
|
||||||
|
*handler = None;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
|
||||||
|
|
@ -63,6 +63,8 @@ pub extern "C" fn init(arg_offset: *const u32, init_offset: *const u32, rpt_offs
|
||||||
#[cfg(any(feature = "debug-print", feature = "print-panics"))]
|
#[cfg(any(feature = "debug-print", feature = "print-panics"))]
|
||||||
{
|
{
|
||||||
use utralib::generated::*;
|
use utralib::generated::*;
|
||||||
|
xous_kernel::claim_interrupt(utra::uart::UART_IRQ, debug::irq, 0 as *mut usize)
|
||||||
|
.expect("Couldn't claim debug interrupt");
|
||||||
// Map the serial port so println!() works as expected.
|
// Map the serial port so println!() works as expected.
|
||||||
mem::MemoryManager::with_mut(|memory_manager| {
|
mem::MemoryManager::with_mut(|memory_manager| {
|
||||||
memory_manager
|
memory_manager
|
||||||
|
|
@ -76,11 +78,9 @@ pub extern "C" fn init(arg_offset: *const u32, init_offset: *const u32, rpt_offs
|
||||||
)
|
)
|
||||||
.expect("unable to map serial port")
|
.expect("unable to map serial port")
|
||||||
});
|
});
|
||||||
debug::Uart{}.init();
|
debug::Uart {}.init();
|
||||||
println!("KMAIN (clean boot): Supervisor mode started...");
|
println!("KMAIN (clean boot): Supervisor mode started...");
|
||||||
println!("Claiming IRQ {} via syscall...", utra::uart::UART_IRQ);
|
println!("Claiming IRQ {} via syscall...", utra::uart::UART_IRQ);
|
||||||
xous_kernel::claim_interrupt(utra::uart::UART_IRQ, debug::irq, 0 as *mut usize)
|
|
||||||
.expect("Couldn't claim debug interrupt");
|
|
||||||
print!("}} ");
|
print!("}} ");
|
||||||
|
|
||||||
// Print the processed kernel arguments
|
// Print the processed kernel arguments
|
||||||
|
|
@ -168,7 +168,7 @@ pub extern "C" fn kmain() {
|
||||||
#[cfg(feature = "debug-print")]
|
#[cfg(feature = "debug-print")]
|
||||||
SystemServices::with(|system_services| {
|
SystemServices::with(|system_services| {
|
||||||
for (test_idx, process) in system_services.processes.iter().enumerate() {
|
for (test_idx, process) in system_services.processes.iter().enumerate() {
|
||||||
if ! process.free() {
|
if !process.free() {
|
||||||
println!("PID {}: {:?}", test_idx + 1, process);
|
println!("PID {}: {:?}", test_idx + 1, process);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -2,8 +2,6 @@
|
||||||
// SPDX-License-Identifier: Apache-2.0
|
// SPDX-License-Identifier: Apache-2.0
|
||||||
|
|
||||||
use core::fmt;
|
use core::fmt;
|
||||||
use core::slice;
|
|
||||||
use core::str;
|
|
||||||
|
|
||||||
pub use crate::arch::mem::{MemoryMapping, PAGE_SIZE};
|
pub use crate::arch::mem::{MemoryMapping, PAGE_SIZE};
|
||||||
use crate::arch::process::Process;
|
use crate::arch::process::Process;
|
||||||
|
|
@ -27,18 +25,13 @@ pub struct MemoryRangeExtra {
|
||||||
|
|
||||||
impl fmt::Display for MemoryRangeExtra {
|
impl fmt::Display for MemoryRangeExtra {
|
||||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||||
let tag_name_bytes = self.mem_tag.to_le_bytes();
|
|
||||||
let s = unsafe {
|
|
||||||
// First, we build a &[u8]...
|
|
||||||
let slice = slice::from_raw_parts(tag_name_bytes.as_ptr(), 4);
|
|
||||||
// ... and then convert that slice into a string slice
|
|
||||||
str::from_utf8_unchecked(slice)
|
|
||||||
};
|
|
||||||
|
|
||||||
write!(
|
write!(
|
||||||
f,
|
f,
|
||||||
"{} ({:08x}) {:08x} - {:08x} {} bytes",
|
"{}{}{}{} - ({:08x}) {:08x} - {:08x} {} bytes",
|
||||||
s,
|
((self.mem_tag >> 0) & 0xff) as u8 as char,
|
||||||
|
((self.mem_tag >> 8) & 0xff) as u8 as char,
|
||||||
|
((self.mem_tag >> 16) & 0xff) as u8 as char,
|
||||||
|
((self.mem_tag >> 24) & 0xff) as u8 as char,
|
||||||
self.mem_tag,
|
self.mem_tag,
|
||||||
self.mem_start,
|
self.mem_start,
|
||||||
self.mem_start + self.mem_size,
|
self.mem_start + self.mem_size,
|
||||||
|
|
@ -114,6 +107,7 @@ impl MemoryManager {
|
||||||
MEMORY_MANAGER.with(|ss| f(&mut ss.borrow_mut()))
|
MEMORY_MANAGER.with(|ss| f(&mut ss.borrow_mut()))
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[cfg(baremetal)]
|
||||||
pub fn with<F, R>(f: F) -> R
|
pub fn with<F, R>(f: F) -> R
|
||||||
where
|
where
|
||||||
F: FnOnce(&MemoryManager) -> R,
|
F: FnOnce(&MemoryManager) -> R,
|
||||||
|
|
@ -132,6 +126,7 @@ impl MemoryManager {
|
||||||
base: *mut u32,
|
base: *mut u32,
|
||||||
args: &crate::args::KernelArguments,
|
args: &crate::args::KernelArguments,
|
||||||
) -> Result<(), xous_kernel::Error> {
|
) -> Result<(), xous_kernel::Error> {
|
||||||
|
use core::slice;
|
||||||
let mut args_iter = args.iter();
|
let mut args_iter = args.iter();
|
||||||
let xarg_def = args_iter.next().expect("mm: no kernel arguments found");
|
let xarg_def = args_iter.next().expect("mm: no kernel arguments found");
|
||||||
unsafe {
|
unsafe {
|
||||||
|
|
@ -195,11 +190,6 @@ impl MemoryManager {
|
||||||
owned_bytes
|
owned_bytes
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(not(baremetal))]
|
|
||||||
pub fn ram_used_by(&self, _pid: PID) -> usize {
|
|
||||||
0
|
|
||||||
}
|
|
||||||
|
|
||||||
#[cfg(all(baremetal, feature = "print-debug"))]
|
#[cfg(all(baremetal, feature = "print-debug"))]
|
||||||
pub fn print_ownership(&self) {
|
pub fn print_ownership(&self) {
|
||||||
println!("Ownership ({} bytes in all):", unsafe {
|
println!("Ownership ({} bytes in all):", unsafe {
|
||||||
|
|
@ -594,6 +584,7 @@ impl MemoryManager {
|
||||||
)
|
)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[cfg(baremetal)]
|
||||||
pub fn ensure_page_exists(&mut self, address: usize) -> Result<(), xous_kernel::Error> {
|
pub fn ensure_page_exists(&mut self, address: usize) -> Result<(), xous_kernel::Error> {
|
||||||
crate::arch::mem::ensure_page_exists_inner(address).and(Ok(()))
|
crate::arch::mem::ensure_page_exists_inner(address).and(Ok(()))
|
||||||
}
|
}
|
||||||
|
|
@ -699,4 +690,57 @@ impl MemoryManager {
|
||||||
fn release_page(&mut self, addr: *mut usize, pid: PID) -> Result<(), xous_kernel::Error> {
|
fn release_page(&mut self, addr: *mut usize, pid: PID) -> Result<(), xous_kernel::Error> {
|
||||||
self.claim_release_move(addr, pid, ClaimReleaseMove::Release)
|
self.claim_release_move(addr, pid, ClaimReleaseMove::Release)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Convert an offset in the `MEMORY_ALLOCATIONS` array into a physical address.
|
||||||
|
#[cfg(baremetal)]
|
||||||
|
fn allocation_offset_to_address(&self, offset: usize) -> Option<usize> {
|
||||||
|
// If the offset is within the RAM size, simply turn it into
|
||||||
|
// an address.
|
||||||
|
if offset < self.ram_size as usize / PAGE_SIZE {
|
||||||
|
Some(self.ram_start as usize + offset * PAGE_SIZE)
|
||||||
|
} else {
|
||||||
|
// The offset is not within RAM, so it must be in the extra
|
||||||
|
// regions list. Loop through all regions looking for the
|
||||||
|
// address. NOTE: This needs to be linear because each memory
|
||||||
|
// region has a different length.
|
||||||
|
let mut offset_in_region = offset - (self.ram_size as usize / PAGE_SIZE);
|
||||||
|
unsafe {
|
||||||
|
for region in EXTRA_REGIONS {
|
||||||
|
// If the offset exceeds the current region, skip to the
|
||||||
|
// next region.
|
||||||
|
if offset_in_region >= (region.mem_size as usize / PAGE_SIZE) {
|
||||||
|
offset_in_region -= region.mem_size as usize / PAGE_SIZE;
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
return Some(region.mem_start as usize + (offset_in_region * PAGE_SIZE));
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// No region was found.
|
||||||
|
None
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Free all memory that belongs to a process. This does not unmap the
|
||||||
|
/// memory from the process, it only marks it as free.
|
||||||
|
/// This is very unsafe because the memory can immediately be re-allocated
|
||||||
|
/// to another process, so only call this as part of destroying a process.
|
||||||
|
pub unsafe fn release_all_memory_for_process(&mut self, _pid: PID) {
|
||||||
|
#[cfg(baremetal)]
|
||||||
|
for (idx, owner) in MEMORY_ALLOCATIONS.iter_mut().enumerate() {
|
||||||
|
// If this address has been allocated to this process, consider
|
||||||
|
// freeing it or reparenting it.
|
||||||
|
if owner == &mut Some(_pid) {
|
||||||
|
let phys_addr = self.allocation_offset_to_address(idx).unwrap();
|
||||||
|
if crate::arch::mem::page_is_lent(phys_addr as *mut u8) {
|
||||||
|
// If the page is lent, reparent it to PID 1 so it will
|
||||||
|
// get freed when it is returned.
|
||||||
|
*owner = PID::new(1);
|
||||||
|
} else {
|
||||||
|
// Mark this page as free, which allows it to be re-allocated.
|
||||||
|
*owner = None;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -308,11 +308,7 @@ impl Server {
|
||||||
/// Take a current slot and replace it with `None`, clearing out the contents of the queue.
|
/// Take a current slot and replace it with `None`, clearing out the contents of the queue.
|
||||||
/// Returns an error if the queue has any waiting elements.
|
/// Returns an error if the queue has any waiting elements.
|
||||||
/// Returns a list of threads that should be readied.
|
/// Returns a list of threads that should be readied.
|
||||||
pub fn destroy(
|
pub fn destroy(mut self, ss: &mut SystemServices) -> Result<(), Self> {
|
||||||
mut self,
|
|
||||||
ss: &mut SystemServices,
|
|
||||||
) -> Result<(), Self> {
|
|
||||||
|
|
||||||
// First determine if the server has any Waiting messages. That is, any messages
|
// First determine if the server has any Waiting messages. That is, any messages
|
||||||
// that are currently sitting in the memory space of the Server. These cannot
|
// that are currently sitting in the memory space of the Server. These cannot
|
||||||
// safely be handled, and will cause an error if we try to mess with them.
|
// safely be handled, and will cause an error if we try to mess with them.
|
||||||
|
|
|
||||||
|
|
@ -194,11 +194,15 @@ impl Process {
|
||||||
return Err(xous_kernel::Error::ProcessNotFound);
|
return Err(xous_kernel::Error::ProcessNotFound);
|
||||||
}
|
}
|
||||||
|
|
||||||
// TODO: Free all pages
|
// Free all associated memory pages
|
||||||
|
unsafe {
|
||||||
|
crate::mem::MemoryManager::with_mut(|mm| mm.release_all_memory_for_process(self.pid))
|
||||||
|
};
|
||||||
|
|
||||||
// TODO: Free all IRQs
|
// Free all claimed IRQs
|
||||||
|
crate::irq::release_interrupts_for_pid(self.pid);
|
||||||
|
|
||||||
// TODO: Free memory mapping
|
// Remove this PID from the process table
|
||||||
crate::arch::process::Process::destroy(self.pid)?;
|
crate::arch::process::Process::destroy(self.pid)?;
|
||||||
self.state = ProcessState::Free;
|
self.state = ProcessState::Free;
|
||||||
Ok(())
|
Ok(())
|
||||||
|
|
@ -567,10 +571,7 @@ impl SystemServices {
|
||||||
pid, tid, other
|
pid, tid, other
|
||||||
),
|
),
|
||||||
};
|
};
|
||||||
// println!(
|
klog!("Readying ({}:{}) -> {:?}", pid, tid, process.state);
|
||||||
// "KERNEL({}): Readying context {} -> {:?}",
|
|
||||||
// pid, context, process.state
|
|
||||||
// );
|
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -585,12 +586,12 @@ impl SystemServices {
|
||||||
tid: Option<TID>,
|
tid: Option<TID>,
|
||||||
) -> Result<(), xous_kernel::Error> {
|
) -> Result<(), xous_kernel::Error> {
|
||||||
let process = self.get_process_mut(pid)?;
|
let process = self.get_process_mut(pid)?;
|
||||||
// println!(
|
// klog!(
|
||||||
// "switch_to_thread({}:{:?}): Old state was {:?}",
|
// "switch_to_thread({}:{:?}): Old state was {:?}",
|
||||||
// pid, tid, process.state
|
// pid, tid, process.state
|
||||||
// );
|
// );
|
||||||
|
|
||||||
// Determine which context number to switch to
|
// Determine which thread to switch to
|
||||||
process.state = match process.state {
|
process.state = match process.state {
|
||||||
ProcessState::Free => return Err(xous_kernel::Error::ProcessNotFound),
|
ProcessState::Free => return Err(xous_kernel::Error::ProcessNotFound),
|
||||||
ProcessState::Sleeping => return Err(xous_kernel::Error::ProcessNotFound),
|
ProcessState::Sleeping => return Err(xous_kernel::Error::ProcessNotFound),
|
||||||
|
|
@ -1289,6 +1290,10 @@ impl SystemServices {
|
||||||
Err(xous_kernel::Error::BadAddress)?;
|
Err(xous_kernel::Error::BadAddress)?;
|
||||||
}
|
}
|
||||||
|
|
||||||
|
// If memory is getting returned to the kernel, then it is memory that was
|
||||||
|
// borrowed but
|
||||||
|
if dest_pid.get() == 1 {}
|
||||||
|
|
||||||
// Iterators and `ptr.wrapping_add()` operate on `usize` types,
|
// Iterators and `ptr.wrapping_add()` operate on `usize` types,
|
||||||
// which effectively lowers the `len`.
|
// which effectively lowers the `len`.
|
||||||
let usize_len = len / core::mem::size_of::<usize>();
|
let usize_len = len / core::mem::size_of::<usize>();
|
||||||
|
|
@ -1306,9 +1311,7 @@ impl SystemServices {
|
||||||
let mut error = None;
|
let mut error = None;
|
||||||
|
|
||||||
// Lend each subsequent page.
|
// Lend each subsequent page.
|
||||||
for offset in (0..usize_len)
|
for offset in (0..usize_len).step_by(usize_page) {
|
||||||
.step_by(usize_page)
|
|
||||||
{
|
|
||||||
assert!(((src_virt.wrapping_add(offset) as usize) & 0xfff) == 0);
|
assert!(((src_virt.wrapping_add(offset) as usize) & 0xfff) == 0);
|
||||||
assert!(((dest_virt.wrapping_add(offset) as usize) & 0xfff) == 0);
|
assert!(((dest_virt.wrapping_add(offset) as usize) & 0xfff) == 0);
|
||||||
mm.unlend_page(
|
mm.unlend_page(
|
||||||
|
|
@ -1330,7 +1333,8 @@ impl SystemServices {
|
||||||
});
|
});
|
||||||
}
|
}
|
||||||
error.map_or_else(|| Ok(dest_virt), |e| Err(e))
|
error.map_or_else(|| Ok(dest_virt), |e| Err(e))
|
||||||
}).map(|val| val as *mut usize)
|
})
|
||||||
|
.map(|val| val as *mut usize)
|
||||||
}
|
}
|
||||||
|
|
||||||
#[cfg(not(baremetal))]
|
#[cfg(not(baremetal))]
|
||||||
|
|
@ -1405,6 +1409,78 @@ impl SystemServices {
|
||||||
Ok(new_tid)
|
Ok(new_tid)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Destroy the given thread.
|
||||||
|
/// NOTE: You MUST immediately switch away from this process.
|
||||||
|
/// # Errors
|
||||||
|
///
|
||||||
|
/// * **ThreadNotAvailable**: The thread does not exist in this process
|
||||||
|
#[cfg(baremetal)]
|
||||||
|
pub fn destroy_thread(&mut self, pid: PID, tid: TID) -> Result<usize, xous_kernel::Error> {
|
||||||
|
let current_pid = self.current_pid();
|
||||||
|
assert_eq!(pid, current_pid);
|
||||||
|
|
||||||
|
let mut waiting_threads = match self.get_process_mut(pid)?.state {
|
||||||
|
ProcessState::Running(x) => x,
|
||||||
|
state => panic!("Process was in an invalid state: {:?}", state),
|
||||||
|
};
|
||||||
|
|
||||||
|
// Destroy the thread at a hardware level
|
||||||
|
let mut arch_process = crate::arch::process::Process::current();
|
||||||
|
let return_value = arch_process.destroy_thread(tid).unwrap();
|
||||||
|
|
||||||
|
// If there's another thread waiting on the return value of this thread,
|
||||||
|
// wake it up and set its return value.
|
||||||
|
if let Some((waiting_tid, _thread)) = arch_process.find_thread(|waiting_tid, thr| {
|
||||||
|
(waiting_threads & (1 << waiting_tid)) == 0 // Thread is waiting (i.e. not ready to run)
|
||||||
|
&& thr.a0() == (xous_kernel::SysCallNumber::JoinThread as usize) // Thread called `JoinThread`
|
||||||
|
&& thr.a1() == (tid as usize) // It is waiting on our thread
|
||||||
|
}) {
|
||||||
|
// Wake up the thread
|
||||||
|
self.set_thread_result(pid, waiting_tid, xous_kernel::Result::Scalar1(return_value))?;
|
||||||
|
waiting_threads |= 1 << waiting_tid;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Mark this process as `Ready`.
|
||||||
|
// We can do this because the current thread has just exited. Note that if there
|
||||||
|
// are no threads available, this is an error.
|
||||||
|
self.get_process_mut(pid)?.state = ProcessState::Ready(waiting_threads);
|
||||||
|
|
||||||
|
// Switch to the next available TID. This moves the process back to a `Running` state.
|
||||||
|
self.switch_to_thread(pid, None)?;
|
||||||
|
|
||||||
|
Ok(return_value)
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Park this thread if the target thread is currently running. Otherwise,
|
||||||
|
/// return the value of the given thread.
|
||||||
|
pub fn join_thread(
|
||||||
|
&mut self,
|
||||||
|
pid: PID,
|
||||||
|
tid: TID,
|
||||||
|
join_tid: TID,
|
||||||
|
) -> Result<xous_kernel::Result, xous_kernel::Error> {
|
||||||
|
let current_pid = self.current_pid();
|
||||||
|
assert_eq!(pid, current_pid);
|
||||||
|
|
||||||
|
// We cannot wait on ourselves.
|
||||||
|
if tid == join_tid {
|
||||||
|
Err(xous_kernel::Error::ThreadNotAvailable)?
|
||||||
|
}
|
||||||
|
|
||||||
|
// If the target thread exists, put this thread to sleep.
|
||||||
|
let arch_process = crate::arch::process::Process::current();
|
||||||
|
if arch_process.thread_exists(join_tid) {
|
||||||
|
// The target thread exists -- put this thread to sleep
|
||||||
|
let ppid = self.get_process(pid).unwrap().ppid;
|
||||||
|
self.activate_process_thread(tid, ppid, 0, false)
|
||||||
|
.map(|_| Ok(xous_kernel::Result::ResumeProcess))
|
||||||
|
.unwrap_or(Err(xous_kernel::Error::ProcessNotFound))
|
||||||
|
} else {
|
||||||
|
// The thread does not exist -- continue execution
|
||||||
|
Err(xous_kernel::Error::ThreadNotAvailable)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
/// Allocate a new server ID for this process and return the address. If the
|
/// Allocate a new server ID for this process and return the address. If the
|
||||||
/// server table is full, or if there is not enough memory to map the server queue,
|
/// server table is full, or if there is not enough memory to map the server queue,
|
||||||
/// return an error.
|
/// return an error.
|
||||||
|
|
@ -1572,7 +1648,6 @@ impl SystemServices {
|
||||||
// yet connected.
|
// yet connected.
|
||||||
|
|
||||||
let pid = crate::arch::process::current_pid();
|
let pid = crate::arch::process::current_pid();
|
||||||
// println!("KERNEL({}): Server table: {:?}", _pid.get(), self.servers);
|
|
||||||
ArchProcess::with_inner_mut(|process_inner| {
|
ArchProcess::with_inner_mut(|process_inner| {
|
||||||
assert_eq!(pid, process_inner.pid);
|
assert_eq!(pid, process_inner.pid);
|
||||||
let mut slot_idx = None;
|
let mut slot_idx = None;
|
||||||
|
|
@ -1846,6 +1921,8 @@ impl SystemServices {
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
let process = self.processes[(server.pid.get() - 1) as usize];
|
||||||
|
process.activate().unwrap();
|
||||||
// Look through this server's memory space to determine if this process
|
// Look through this server's memory space to determine if this process
|
||||||
// is mentioned there as having some memory lent out.
|
// is mentioned there as having some memory lent out.
|
||||||
server.discard_messages_for_pid(target_pid);
|
server.discard_messages_for_pid(target_pid);
|
||||||
|
|
@ -1855,10 +1932,8 @@ impl SystemServices {
|
||||||
process.activate()?;
|
process.activate()?;
|
||||||
let parent_pid = process.ppid;
|
let parent_pid = process.ppid;
|
||||||
process.terminate()?;
|
process.terminate()?;
|
||||||
// println!("KERNEL({}): Terminated", target_pid);
|
|
||||||
|
|
||||||
let process = self.get_process(parent_pid)?;
|
self.switch_to_thread(parent_pid, None).unwrap();
|
||||||
process.activate().unwrap();
|
|
||||||
|
|
||||||
Ok(parent_pid)
|
Ok(parent_pid)
|
||||||
}
|
}
|
||||||
|
|
@ -1883,6 +1958,7 @@ impl SystemServices {
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Returns the process name, if any, of a given PID
|
/// Returns the process name, if any, of a given PID
|
||||||
|
#[cfg(baremetal)]
|
||||||
pub fn process_name(&self, pid: PID) -> Option<&str> {
|
pub fn process_name(&self, pid: PID) -> Option<&str> {
|
||||||
let args = crate::args::KernelArguments::get();
|
let args = crate::args::KernelArguments::get();
|
||||||
for arg in args.iter() {
|
for arg in args.iter() {
|
||||||
|
|
@ -1896,17 +1972,27 @@ impl SystemServices {
|
||||||
};
|
};
|
||||||
let mut offset = 0;
|
let mut offset = 0;
|
||||||
while offset <= arg.size {
|
while offset <= arg.size {
|
||||||
let check_pid = u32::from_le_bytes([data[offset+0],data[offset+1],data[offset+2],data[offset+3]]);
|
let check_pid = u32::from_le_bytes([
|
||||||
let str_len = u32::from_le_bytes([data[offset+4],data[offset+5],data[offset+6],data[offset+7]]) as usize;
|
data[offset + 0],
|
||||||
|
data[offset + 1],
|
||||||
|
data[offset + 2],
|
||||||
|
data[offset + 3],
|
||||||
|
]);
|
||||||
|
let str_len = u32::from_le_bytes([
|
||||||
|
data[offset + 4],
|
||||||
|
data[offset + 5],
|
||||||
|
data[offset + 6],
|
||||||
|
data[offset + 7],
|
||||||
|
]) as usize;
|
||||||
if check_pid == pid.get() as _ {
|
if check_pid == pid.get() as _ {
|
||||||
if let Ok(s) = core::str::from_utf8(&data[offset+8..offset+8+str_len]){
|
if let Ok(s) = core::str::from_utf8(&data[offset + 8..offset + 8 + str_len]) {
|
||||||
return Some(s);
|
return Some(s);
|
||||||
} else {
|
} else {
|
||||||
return None;
|
return None;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
offset += str_len + 8;
|
offset += str_len + 8;
|
||||||
offset += (4-(offset & 3))&3;
|
offset += (4 - (offset & 3)) & 3;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
None
|
None
|
||||||
|
|
|
||||||
|
|
@ -256,8 +256,8 @@ fn send_message(pid: PID, thread: TID, cid: CID, message: Message) -> SysCallRes
|
||||||
}
|
}
|
||||||
|
|
||||||
fn return_memory(
|
fn return_memory(
|
||||||
pid: PID,
|
server_pid: PID,
|
||||||
tid: TID,
|
server_tid: TID,
|
||||||
in_irq: bool,
|
in_irq: bool,
|
||||||
sender: MessageSender,
|
sender: MessageSender,
|
||||||
buf: MemoryRange,
|
buf: MemoryRange,
|
||||||
|
|
@ -270,12 +270,12 @@ fn return_memory(
|
||||||
let server = ss
|
let server = ss
|
||||||
.server_from_sidx_mut(sender.sidx)
|
.server_from_sidx_mut(sender.sidx)
|
||||||
.ok_or(xous_kernel::Error::ServerNotFound)?;
|
.ok_or(xous_kernel::Error::ServerNotFound)?;
|
||||||
if server.pid != pid {
|
if server.pid != server_pid {
|
||||||
return Err(xous_kernel::Error::ServerNotFound);
|
return Err(xous_kernel::Error::ServerNotFound);
|
||||||
}
|
}
|
||||||
let result = server.take_waiting_message(sender.idx, Some(&buf))?;
|
let result = server.take_waiting_message(sender.idx, Some(&buf))?;
|
||||||
klog!("waiting message was: {:?}", result);
|
klog!("waiting message was: {:?}", result);
|
||||||
let (client_pid, client_tid, server_addr, client_addr, len) = match result {
|
let (client_pid, client_tid, _server_addr, client_addr, len) = match result {
|
||||||
WaitingMessage::BorrowedMemory(
|
WaitingMessage::BorrowedMemory(
|
||||||
client_pid,
|
client_pid,
|
||||||
client_ctx,
|
client_ctx,
|
||||||
|
|
@ -318,14 +318,14 @@ fn return_memory(
|
||||||
// "KERNEL({}): Returning {} bytes from {:08x} in PID {} to {:08x} in PID {} in context {}",
|
// "KERNEL({}): Returning {} bytes from {:08x} in PID {} to {:08x} in PID {} in context {}",
|
||||||
// pid,
|
// pid,
|
||||||
// len,
|
// len,
|
||||||
// server_addr.get(),
|
// _server_addr.get(),
|
||||||
// pid,
|
// pid,
|
||||||
// client_addr.get(),
|
// client_addr.get(),
|
||||||
// client_pid,
|
// client_pid,
|
||||||
// client_tid
|
// client_tid
|
||||||
// );
|
// );
|
||||||
#[cfg(baremetal)]
|
#[cfg(baremetal)]
|
||||||
let src_virt = server_addr.get() as _;
|
let src_virt = _server_addr.get() as _;
|
||||||
#[cfg(not(baremetal))]
|
#[cfg(not(baremetal))]
|
||||||
let src_virt = buf.addr.get() as _;
|
let src_virt = buf.addr.get() as _;
|
||||||
|
|
||||||
|
|
@ -354,9 +354,9 @@ fn return_memory(
|
||||||
Ok(xous_kernel::Result::Ok)
|
Ok(xous_kernel::Result::Ok)
|
||||||
} else {
|
} else {
|
||||||
// Switch away from the server, but leave it as Runnable
|
// Switch away from the server, but leave it as Runnable
|
||||||
ss.switch_from_thread(pid, tid)?;
|
ss.switch_from_thread(server_pid, server_tid)?;
|
||||||
ss.ready_thread(pid, tid)?;
|
ss.ready_thread(server_pid, server_tid)?;
|
||||||
ss.set_thread_result(pid, tid, xous_kernel::Result::Ok)?;
|
ss.set_thread_result(server_pid, server_tid, xous_kernel::Result::Ok)?;
|
||||||
|
|
||||||
// Switch to the client
|
// Switch to the client
|
||||||
ss.ready_thread(client_pid, client_tid)?;
|
ss.ready_thread(client_pid, client_tid)?;
|
||||||
|
|
@ -579,7 +579,7 @@ pub fn handle(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallResult
|
||||||
|
|
||||||
#[cfg(feature = "debug-print")]
|
#[cfg(feature = "debug-print")]
|
||||||
println!(
|
println!(
|
||||||
" -> ({}:{}) {:?}",
|
" -> ({}:{}) {:x?}",
|
||||||
crate::arch::current_pid(),
|
crate::arch::current_pid(),
|
||||||
crate::arch::process::Process::current().current_tid(),
|
crate::arch::process::Process::current().current_tid(),
|
||||||
result
|
result
|
||||||
|
|
@ -718,7 +718,8 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
|
||||||
unsafe {
|
unsafe {
|
||||||
assert!(
|
assert!(
|
||||||
SWITCHTO_CALLER.is_none(),
|
SWITCHTO_CALLER.is_none(),
|
||||||
"SWITCHTO_CALLER was not None, indicating SwitchTo was called twice"
|
"SWITCHTO_CALLER was {:?} and not None, indicating SwitchTo was called twice",
|
||||||
|
SWITCHTO_CALLER,
|
||||||
);
|
);
|
||||||
SWITCHTO_CALLER = Some((pid, tid));
|
SWITCHTO_CALLER = Some((pid, tid));
|
||||||
}
|
}
|
||||||
|
|
@ -799,15 +800,12 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
|
||||||
return_scalar2(pid, tid, in_irq, sender, arg1, arg2)
|
return_scalar2(pid, tid, in_irq, sender, arg1, arg2)
|
||||||
}
|
}
|
||||||
SysCall::TrySendMessage(cid, message) => send_message(pid, tid, cid, message),
|
SysCall::TrySendMessage(cid, message) => send_message(pid, tid, cid, message),
|
||||||
SysCall::TerminateProcess => SystemServices::with_mut(|ss| {
|
SysCall::TerminateProcess(_ret) => SystemServices::with_mut(|ss| {
|
||||||
ss.switch_from_thread(pid, tid)?;
|
ss.switch_from_thread(pid, tid)?;
|
||||||
let ppid = ss.terminate_process(pid)?;
|
ss.terminate_process(pid)?;
|
||||||
if cfg!(baremetal) {
|
// Clear out `SWITCHTO_CALLER` since we're resuming the parent process.
|
||||||
ss.switch_to_thread(ppid, None)
|
unsafe { SWITCHTO_CALLER = None };
|
||||||
.map(|_| xous_kernel::Result::ResumeProcess)
|
Ok(xous_kernel::Result::ResumeProcess)
|
||||||
} else {
|
|
||||||
Ok(xous_kernel::Result::Ok)
|
|
||||||
}
|
|
||||||
}),
|
}),
|
||||||
SysCall::Shutdown => {
|
SysCall::Shutdown => {
|
||||||
SystemServices::with_mut(|ss| ss.shutdown().map(|_| xous_kernel::Result::Ok))
|
SystemServices::with_mut(|ss| ss.shutdown().map(|_| xous_kernel::Result::Ok))
|
||||||
|
|
@ -852,6 +850,12 @@ pub fn handle_inner(pid: PID, tid: TID, in_irq: bool, call: SysCall) -> SysCallR
|
||||||
SysCall::DestroyServer(sid) => SystemServices::with_mut(|ss| {
|
SysCall::DestroyServer(sid) => SystemServices::with_mut(|ss| {
|
||||||
ss.destroy_server(pid, sid).and(Ok(xous_kernel::Result::Ok))
|
ss.destroy_server(pid, sid).and(Ok(xous_kernel::Result::Ok))
|
||||||
}),
|
}),
|
||||||
|
SysCall::JoinThread(other_tid) => {
|
||||||
|
SystemServices::with_mut(|ss| ss.join_thread(pid, tid, other_tid)).map(|ret| {
|
||||||
|
unsafe { SWITCHTO_CALLER = None };
|
||||||
|
ret
|
||||||
|
})
|
||||||
|
}
|
||||||
_ => Err(xous_kernel::Error::UnhandledSyscall),
|
_ => Err(xous_kernel::Error::UnhandledSyscall),
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -4,12 +4,10 @@
|
||||||
use crate::kmain;
|
use crate::kmain;
|
||||||
use std::thread::JoinHandle;
|
use std::thread::JoinHandle;
|
||||||
|
|
||||||
use std::net::ToSocketAddrs;
|
|
||||||
use crossbeam_channel::unbounded;
|
use crossbeam_channel::unbounded;
|
||||||
|
use std::net::ToSocketAddrs;
|
||||||
use xous_kernel::{rsyscall, SysCall};
|
use xous_kernel::{rsyscall, SysCall};
|
||||||
|
|
||||||
mod shutdown;
|
|
||||||
|
|
||||||
#[cfg(feature = "report-memory")]
|
#[cfg(feature = "report-memory")]
|
||||||
use stats_alloc::{Region, Stats, StatsAlloc, INSTRUMENTED_SYSTEM};
|
use stats_alloc::{Region, Stats, StatsAlloc, INSTRUMENTED_SYSTEM};
|
||||||
#[cfg(feature = "report-memory")]
|
#[cfg(feature = "report-memory")]
|
||||||
|
|
@ -170,7 +168,8 @@ fn connect_for_process() {
|
||||||
} else {
|
} else {
|
||||||
panic!("Unexpected return value");
|
panic!("Unexpected return value");
|
||||||
};
|
};
|
||||||
xous_kernel::return_scalar(envelope.sender, new_cid as usize).expect("couldn't return scalar");
|
xous_kernel::return_scalar(envelope.sender, new_cid as usize)
|
||||||
|
.expect("couldn't return scalar");
|
||||||
}),
|
}),
|
||||||
)
|
)
|
||||||
.expect("couldn't spawn client process");
|
.expect("couldn't spawn client process");
|
||||||
|
|
|
||||||
|
|
@ -76,5 +76,5 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(sid).unwrap();
|
xns.unregister_server(sid).unwrap();
|
||||||
xous::destroy_server(sid).unwrap();
|
xous::destroy_server(sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -76,5 +76,5 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(sid).unwrap();
|
xns.unregister_server(sid).unwrap();
|
||||||
xous::destroy_server(sid).unwrap();
|
xous::destroy_server(sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -163,7 +163,7 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(codec_sid).unwrap();
|
xns.unregister_server(codec_sid).unwrap();
|
||||||
xous::destroy_server(codec_sid).unwrap();
|
xous::destroy_server(codec_sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
||||||
|
|
|
||||||
|
|
@ -600,5 +600,5 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(com_sid).unwrap();
|
xns.unregister_server(com_sid).unwrap();
|
||||||
xous::destroy_server(com_sid).unwrap();
|
xous::destroy_server(com_sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -250,6 +250,7 @@ mod implementation {
|
||||||
#[cfg(not(target_os = "none"))]
|
#[cfg(not(target_os = "none"))]
|
||||||
mod implementation {
|
mod implementation {
|
||||||
use log::info;
|
use log::info;
|
||||||
|
use crate::Sha2Config;
|
||||||
|
|
||||||
pub(crate) struct Engine512 {
|
pub(crate) struct Engine512 {
|
||||||
}
|
}
|
||||||
|
|
@ -265,6 +266,16 @@ mod implementation {
|
||||||
}
|
}
|
||||||
pub(crate) fn reset(&self) {
|
pub(crate) fn reset(&self) {
|
||||||
}
|
}
|
||||||
|
pub(crate) fn setup(&mut self, _config: Sha2Config) {
|
||||||
|
}
|
||||||
|
pub(crate) fn update(&mut self, _buf: &[u8]) {
|
||||||
|
}
|
||||||
|
pub(crate) fn finalize(&mut self) -> ([u8; 64], u64) {
|
||||||
|
([0; 64], 0)
|
||||||
|
}
|
||||||
|
pub(crate) fn is_idle(&mut self) -> bool {
|
||||||
|
false
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -460,5 +471,5 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(engine512_sid).unwrap();
|
xns.unregister_server(engine512_sid).unwrap();
|
||||||
xous::destroy_server(engine512_sid).unwrap();
|
xous::destroy_server(engine512_sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -443,5 +443,5 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(gam_sid).unwrap();
|
xns.unregister_server(gam_sid).unwrap();
|
||||||
xous::destroy_server(gam_sid).unwrap();
|
xous::destroy_server(gam_sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -394,5 +394,5 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(sid).unwrap();
|
xns.unregister_server(sid).unwrap();
|
||||||
xous::destroy_server(sid).unwrap();
|
xous::destroy_server(sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -740,5 +740,5 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(imef_sid).unwrap();
|
xns.unregister_server(imef_sid).unwrap();
|
||||||
xous::destroy_server(imef_sid).unwrap();
|
xous::destroy_server(imef_sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -129,5 +129,5 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(ime_sh_sid).unwrap();
|
xns.unregister_server(ime_sh_sid).unwrap();
|
||||||
xous::destroy_server(ime_sh_sid).unwrap();
|
xous::destroy_server(ime_sh_sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -1003,5 +1003,5 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(kbd_sid).unwrap();
|
xns.unregister_server(kbd_sid).unwrap();
|
||||||
xous::destroy_server(kbd_sid).unwrap();
|
xous::destroy_server(kbd_sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -534,6 +534,15 @@ mod implementation {
|
||||||
}
|
}
|
||||||
pub fn usb_int_ena(self, _ena: bool) {
|
pub fn usb_int_ena(self, _ena: bool) {
|
||||||
}
|
}
|
||||||
|
pub fn debug_powerdown(&mut self, _ena: bool) {
|
||||||
|
}
|
||||||
|
pub fn debug_wakeup(&mut self, _ena: bool) {
|
||||||
|
}
|
||||||
|
pub fn activity_get_period(&mut self) -> u32 {
|
||||||
|
12_000_000
|
||||||
|
}
|
||||||
|
pub fn wfi_override(&mut self, _override_: bool) {
|
||||||
|
}
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -868,7 +877,7 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(llio_sid).unwrap();
|
xns.unregister_server(llio_sid).unwrap();
|
||||||
xous::destroy_server(llio_sid).unwrap();
|
xous::destroy_server(llio_sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn do_hook(hookdata: ScalarHook, cb_conns: &mut [Option<ScalarCallback>; 32]) {
|
fn do_hook(hookdata: ScalarHook, cb_conns: &mut [Option<ScalarCallback>; 32]) {
|
||||||
|
|
|
||||||
|
|
@ -2,7 +2,7 @@
|
||||||
use std::env;
|
use std::env;
|
||||||
|
|
||||||
extern crate vergen;
|
extern crate vergen;
|
||||||
use vergen::{ConstantsFlags, generate_cargo_keys};
|
use vergen::{generate_cargo_keys, ConstantsFlags};
|
||||||
|
|
||||||
fn main() {
|
fn main() {
|
||||||
let target = env::var("TARGET").unwrap();
|
let target = env::var("TARGET").unwrap();
|
||||||
|
|
@ -16,7 +16,10 @@ fn main() {
|
||||||
println!("cargo:rustc-cfg=baremetal");
|
println!("cargo:rustc-cfg=baremetal");
|
||||||
}
|
}
|
||||||
|
|
||||||
generate_cargo_keys(ConstantsFlags::SHA /*| ConstantsFlags::BUILD_TIMESTAMP*/).unwrap();
|
generate_cargo_keys(
|
||||||
|
ConstantsFlags::SHA, /*| ConstantsFlags::BUILD_TIMESTAMP*/
|
||||||
|
)
|
||||||
|
.unwrap();
|
||||||
// BUILD_TIMESTAMP doesn't work -- it doesn't update because of the below line
|
// BUILD_TIMESTAMP doesn't work -- it doesn't update because of the below line
|
||||||
// removing the below line causes a lengthy full-rebuild just to capture a timestamp.
|
// removing the below line causes a lengthy full-rebuild just to capture a timestamp.
|
||||||
// so, we're removing the timestamp.
|
// so, we're removing the timestamp.
|
||||||
|
|
|
||||||
|
|
@ -12,13 +12,13 @@ pub enum Opcode {
|
||||||
/// A `LogRecord` message, delivering structured log output
|
/// A `LogRecord` message, delivering structured log output
|
||||||
LogRecord = 0,
|
LogRecord = 0,
|
||||||
|
|
||||||
/// A `xous::String` destined for stdout
|
/// A `&[u8]` destined for stdout
|
||||||
StandardOutput = 1,
|
StandardOutput = 1,
|
||||||
|
|
||||||
/// A `xous::String` destined for stderr
|
/// A `&[u8]` destined for stderr
|
||||||
StandardError = 2,
|
StandardError = 2,
|
||||||
|
|
||||||
/// A `xous::String` containing this program's name
|
/// A `xous::StringBuffer` containing this program's name
|
||||||
ProgramName = 3,
|
ProgramName = 3,
|
||||||
|
|
||||||
/// A panic occurred, and a panic log is forthcoming
|
/// A panic occurred, and a panic log is forthcoming
|
||||||
|
|
|
||||||
|
|
@ -86,6 +86,20 @@ mod implementation {
|
||||||
pub fn putc(&self, c: u8) {
|
pub fn putc(&self, c: u8) {
|
||||||
self.tx.send(ControlMessage::Byte(c)).unwrap();
|
self.tx.send(ControlMessage::Byte(c)).unwrap();
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Write a buffer to the output and return the number of
|
||||||
|
/// bytes written. This is mostly compatible with `std::io::Write`,
|
||||||
|
/// except it is infallible.
|
||||||
|
pub fn write(&mut self, buf: &[u8]) -> usize {
|
||||||
|
for c in buf {
|
||||||
|
self.putc(*c);
|
||||||
|
}
|
||||||
|
buf.len()
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn write_all(&mut self, buf: &[u8]) -> core::result::Result<usize, ()> {
|
||||||
|
Ok(self.write(buf))
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Write for OutputWriter {
|
impl Write for OutputWriter {
|
||||||
|
|
@ -177,6 +191,20 @@ mod implementation {
|
||||||
uart_csr.wo(utra::uart::RXTX, c as u32);
|
uart_csr.wo(utra::uart::RXTX, c as u32);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Write a buffer to the output and return the number of
|
||||||
|
/// bytes written. This is mostly compatible with `std::io::Write`,
|
||||||
|
/// except it is infallible.
|
||||||
|
pub fn write(&mut self, buf: &[u8]) -> usize {
|
||||||
|
for c in buf {
|
||||||
|
self.putc(*c);
|
||||||
|
}
|
||||||
|
buf.len()
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn write_all(&mut self, buf: &[u8]) -> core::result::Result<usize, ()> {
|
||||||
|
Ok(self.write(buf))
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
impl Write for OutputWriter {
|
impl Write for OutputWriter {
|
||||||
|
|
@ -199,7 +227,7 @@ fn handle_scalar(
|
||||||
sender_pid: xous::PID,
|
sender_pid: xous::PID,
|
||||||
) {
|
) {
|
||||||
match msg.id {
|
match msg.id {
|
||||||
1000 => writeln!(output, "PANIC from PID {} | {}", sender_pid, sender).unwrap(),
|
1000 => writeln!(output, "PANIC in PID {}:", sender_pid).unwrap(),
|
||||||
1100 => (),
|
1100 => (),
|
||||||
1101..=1132 => {
|
1101..=1132 => {
|
||||||
let mut output_bfr = [0u8; core::mem::size_of::<usize>() * 4];
|
let mut output_bfr = [0u8; core::mem::size_of::<usize>() * 4];
|
||||||
|
|
@ -279,8 +307,29 @@ fn handle_opcode(
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
api::Opcode::StandardOutput | api::Opcode::StandardError => {
|
api::Opcode::StandardOutput | api::Opcode::StandardError => {
|
||||||
let string = unsafe { xous::stringbuffer::StringBuffer::from_memory_message(mem) };
|
// let mut buffer_start_offset = mem.offset.map(|o| o.get()).unwrap_or(0);
|
||||||
write!(output, "{}", string).unwrap();
|
let mut buffer_start_offset = 0;
|
||||||
|
let mut buffer_length = mem.valid.map(|v| v.get()).unwrap_or(mem.buf.len());
|
||||||
|
|
||||||
|
// Ensure that `buffer_start_offset` is within the range of `buffer`.
|
||||||
|
if buffer_start_offset >= mem.buf.len() {
|
||||||
|
buffer_start_offset = mem.buf.len() - 1;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Clamp the buffer length so that it fits within the buffer
|
||||||
|
if buffer_start_offset + buffer_length >= mem.buf.len() {
|
||||||
|
buffer_length = mem.buf.len() - buffer_start_offset;
|
||||||
|
}
|
||||||
|
|
||||||
|
// Safe because we validated the offsets above
|
||||||
|
let buffer = unsafe {
|
||||||
|
core::slice::from_raw_parts(
|
||||||
|
mem.buf.as_ptr().add(buffer_start_offset),
|
||||||
|
buffer_length,
|
||||||
|
)
|
||||||
|
};
|
||||||
|
output.write_all(buffer).unwrap();
|
||||||
|
// TODO: If the buffer is mutable, set `length` to 0.
|
||||||
}
|
}
|
||||||
_ => {
|
_ => {
|
||||||
writeln!(output, "Unhandled opcode").unwrap();
|
writeln!(output, "Unhandled opcode").unwrap();
|
||||||
|
|
@ -345,7 +394,7 @@ fn reader_thread(arg: usize) {
|
||||||
log::trace!("main loop exit, destroying servers");
|
log::trace!("main loop exit, destroying servers");
|
||||||
xous::destroy_server(server_addr).unwrap();
|
xous::destroy_server(server_addr).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
*/
|
*/
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
|
||||||
12
services/log-test-client/Cargo.toml
Normal file
12
services/log-test-client/Cargo.toml
Normal file
|
|
@ -0,0 +1,12 @@
|
||||||
|
[package]
|
||||||
|
authors = ["Sean Cross <sean@xobs.io>"]
|
||||||
|
description = "Program to test the log server"
|
||||||
|
edition = "2018"
|
||||||
|
name = "log-test-client"
|
||||||
|
version = "0.1.0"
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
xous = {path = "../../xous-rs"}
|
||||||
|
|
||||||
|
[features]
|
||||||
|
default = []
|
||||||
5
services/log-test-client/README.md
Normal file
5
services/log-test-client/README.md
Normal file
|
|
@ -0,0 +1,5 @@
|
||||||
|
# Kernel Test
|
||||||
|
|
||||||
|
Run various tests inside the kernel.
|
||||||
|
|
||||||
|
This is supposed to be the only program running.
|
||||||
22
services/log-test-client/src/main.rs
Normal file
22
services/log-test-client/src/main.rs
Normal file
|
|
@ -0,0 +1,22 @@
|
||||||
|
#![cfg_attr(target_os = "none", no_std)]
|
||||||
|
#![cfg_attr(target_os = "none", no_main)]
|
||||||
|
|
||||||
|
use xous::StringBuffer;
|
||||||
|
use core::fmt::Write;
|
||||||
|
|
||||||
|
#[xous::xous_main]
|
||||||
|
fn test_main() -> ! {
|
||||||
|
let connection = xous::connect(xous::SID::from_bytes(b"xous-log-server ").unwrap()).unwrap();
|
||||||
|
|
||||||
|
let mut log_string= StringBuffer::new();
|
||||||
|
for i in 0.. {
|
||||||
|
log_string.clear();
|
||||||
|
writeln!(log_string, "Hello, world! Loop {}", i).unwrap();
|
||||||
|
log_string.lend(connection, 1).unwrap();
|
||||||
|
|
||||||
|
log_string.lend_mut(connection, 1).unwrap();
|
||||||
|
log_string.lend(connection, 1).unwrap();
|
||||||
|
xous::yield_slice();
|
||||||
|
}
|
||||||
|
panic!("Finished an infinite loop");
|
||||||
|
}
|
||||||
|
|
@ -179,5 +179,5 @@ fn test_main() -> ! {
|
||||||
xns.unregister_server(sid).unwrap();
|
xns.unregister_server(sid).unwrap();
|
||||||
xous::destroy_server(sid).unwrap();
|
xous::destroy_server(sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -675,5 +675,5 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(rtc_sid).unwrap();
|
xns.unregister_server(rtc_sid).unwrap();
|
||||||
xous::destroy_server(rtc_sid).unwrap();
|
xous::destroy_server(rtc_sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -186,18 +186,35 @@ fn ecupdate_thread(sid0: usize, sid1: usize, sid2: usize, sid3: usize) {
|
||||||
log::error!("couldn't acquire exclusive access to the EC updater mechanism. All other operations will fail!");
|
log::error!("couldn't acquire exclusive access to the EC updater mechanism. All other operations will fail!");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
#[cfg(target_os = "none")]
|
||||||
let ec_package = xous::syscall::map_memory(
|
let ec_package = xous::syscall::map_memory(
|
||||||
xous::MemoryAddress::new(xous::EC_FW_PKG_LOC as usize),
|
xous::MemoryAddress::new(xous::EC_FW_PKG_LOC as usize),
|
||||||
None,
|
None,
|
||||||
xous::EC_FW_PKG_LEN as usize,
|
xous::EC_FW_PKG_LEN as usize,
|
||||||
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||||
).expect("couldn't map EC firmware package memory range");
|
).expect("couldn't map EC firmware package memory range");
|
||||||
|
#[cfg(target_os = "none")]
|
||||||
let wf_package = xous::syscall::map_memory(
|
let wf_package = xous::syscall::map_memory(
|
||||||
xous::MemoryAddress::new(xous::EC_WF200_PKG_LOC as usize),
|
xous::MemoryAddress::new(xous::EC_WF200_PKG_LOC as usize),
|
||||||
None,
|
None,
|
||||||
xous::EC_WF200_PKG_LEN as usize,
|
xous::EC_WF200_PKG_LEN as usize,
|
||||||
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||||
).expect("couldn't map EC wf200 package memory range");
|
).expect("couldn't map EC wf200 package memory range");
|
||||||
|
#[cfg(not(target_os = "none"))]
|
||||||
|
let ec_package = xous::syscall::map_memory(
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
xous::EC_FW_PKG_LEN as usize,
|
||||||
|
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||||
|
).expect("couldn't map EC firmware package memory range");
|
||||||
|
#[cfg(not(target_os = "none"))]
|
||||||
|
let wf_package = xous::syscall::map_memory(
|
||||||
|
None,
|
||||||
|
None,
|
||||||
|
xous::EC_WF200_PKG_LEN as usize,
|
||||||
|
xous::MemoryFlags::R | xous::MemoryFlags::W,
|
||||||
|
).expect("couldn't map EC wf200 package memory range");
|
||||||
|
|
||||||
loop {
|
loop {
|
||||||
let msg = xous::receive_message(sid).unwrap();
|
let msg = xous::receive_message(sid).unwrap();
|
||||||
log::debug!("EC updater got msg {:?}", msg);
|
log::debug!("EC updater got msg {:?}", msg);
|
||||||
|
|
|
||||||
|
|
@ -321,5 +321,5 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(shch_sid).unwrap();
|
xns.unregister_server(shch_sid).unwrap();
|
||||||
xous::destroy_server(shch_sid).unwrap();
|
xous::destroy_server(shch_sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -116,5 +116,5 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(codec_sid).unwrap();
|
xns.unregister_server(codec_sid).unwrap();
|
||||||
xous::destroy_server(codec_sid).unwrap();
|
xous::destroy_server(codec_sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -690,7 +690,7 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(susres_sid).unwrap();
|
xns.unregister_server(susres_sid).unwrap();
|
||||||
xous::destroy_server(susres_sid).unwrap();
|
xous::destroy_server(susres_sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
||||||
fn do_hook(hookdata: ScalarHook, cb_conns: &mut [Option<ScalarCallback>; 32]) {
|
fn do_hook(hookdata: ScalarHook, cb_conns: &mut [Option<ScalarCallback>; 32]) {
|
||||||
|
|
|
||||||
|
|
@ -1,14 +1,14 @@
|
||||||
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
|
#[derive(num_derive::FromPrimitive, num_derive::ToPrimitive, Debug)]
|
||||||
pub(crate) enum Opcode {
|
pub(crate) enum Opcode {
|
||||||
/// Get the elapsed time in milliseconds
|
/// Get the elapsed time in milliseconds
|
||||||
ElapsedMs,
|
ElapsedMs = 0,
|
||||||
|
|
||||||
/// Sleep for the specified numer of milliseconds
|
/// Sleep for the specified numer of milliseconds
|
||||||
SleepMs,
|
SleepMs = 1,
|
||||||
|
|
||||||
/// Recalculate the sleep time
|
/// Recalculate the sleep time
|
||||||
RecalculateSleep,
|
RecalculateSleep = 2,
|
||||||
|
|
||||||
/// Suspend/resume callback
|
/// Suspend/resume callback
|
||||||
SuspendResume,
|
SuspendResume = 3,
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -559,5 +559,5 @@ fn xmain() -> ! {
|
||||||
log::trace!("main loop exit, destroying servers");
|
log::trace!("main loop exit, destroying servers");
|
||||||
xous::destroy_server(ticktimer_server).unwrap();
|
xous::destroy_server(ticktimer_server).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0);
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -413,5 +413,5 @@ fn xmain() -> ! {
|
||||||
xns.unregister_server(trng_sid).unwrap();
|
xns.unregister_server(trng_sid).unwrap();
|
||||||
xous::destroy_server(trng_sid).unwrap();
|
xous::destroy_server(trng_sid).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -238,5 +238,5 @@ fn xmain() -> ! {
|
||||||
log::trace!("main loop exit, destroying servers");
|
log::trace!("main loop exit, destroying servers");
|
||||||
xous::destroy_server(name_server).unwrap();
|
xous::destroy_server(name_server).unwrap();
|
||||||
log::trace!("quitting");
|
log::trace!("quitting");
|
||||||
xous::terminate_process(); loop {}
|
xous::terminate_process(0);
|
||||||
}
|
}
|
||||||
|
|
|
||||||
14
svd2repl/Cargo.toml
Normal file
14
svd2repl/Cargo.toml
Normal file
|
|
@ -0,0 +1,14 @@
|
||||||
|
[package]
|
||||||
|
name = "svd2repl"
|
||||||
|
description = "Convert an SVD file into a Renode Platform description"
|
||||||
|
version = "0.1.0"
|
||||||
|
authors = ["Sean Cross <sean@xobs.io>"]
|
||||||
|
edition = "2018"
|
||||||
|
|
||||||
|
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||||
|
|
||||||
|
[dependencies]
|
||||||
|
quick-xml = "0.19"
|
||||||
|
clap = "2"
|
||||||
|
anyhow = "1.0"
|
||||||
|
convert_case = "0.4"
|
||||||
51
svd2repl/build.rs
Normal file
51
svd2repl/build.rs
Normal file
|
|
@ -0,0 +1,51 @@
|
||||||
|
use std::env;
|
||||||
|
use std::error::Error;
|
||||||
|
use std::fs::File;
|
||||||
|
use std::io::Write;
|
||||||
|
use std::path::PathBuf;
|
||||||
|
use std::process::Command;
|
||||||
|
|
||||||
|
struct IgnoredError {}
|
||||||
|
|
||||||
|
impl<E> From<E> for IgnoredError
|
||||||
|
where
|
||||||
|
E: Error,
|
||||||
|
{
|
||||||
|
fn from(_: E) -> IgnoredError {
|
||||||
|
IgnoredError {}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn main() {
|
||||||
|
let out_dir = PathBuf::from(env::var_os("OUT_DIR").unwrap());
|
||||||
|
|
||||||
|
File::create(out_dir.join("commit-info.txt"))
|
||||||
|
.unwrap()
|
||||||
|
.write_all(commit_info().as_bytes())
|
||||||
|
.unwrap();
|
||||||
|
}
|
||||||
|
|
||||||
|
fn commit_info() -> String {
|
||||||
|
match (commit_hash(), commit_date()) {
|
||||||
|
(Ok(hash), Ok(date)) => format!(" ({} {})", hash.trim(), date.trim()),
|
||||||
|
_ => String::new(),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn commit_hash() -> Result<String, IgnoredError> {
|
||||||
|
Ok(String::from_utf8(
|
||||||
|
Command::new("git")
|
||||||
|
.args(&["rev-parse", "--short", "HEAD"])
|
||||||
|
.output()?
|
||||||
|
.stdout,
|
||||||
|
)?)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn commit_date() -> Result<String, IgnoredError> {
|
||||||
|
Ok(String::from_utf8(
|
||||||
|
Command::new("git")
|
||||||
|
.args(&["log", "-1", "--date=short", "--pretty=format:%cd"])
|
||||||
|
.output()?
|
||||||
|
.stdout,
|
||||||
|
)?)
|
||||||
|
}
|
||||||
630
svd2repl/src/generate.rs
Normal file
630
svd2repl/src/generate.rs
Normal file
|
|
@ -0,0 +1,630 @@
|
||||||
|
use quick_xml::events::Event;
|
||||||
|
use quick_xml::Reader;
|
||||||
|
use std::io::{BufRead, BufReader, Read, Write};
|
||||||
|
#[derive(Debug)]
|
||||||
|
pub enum ParseError {
|
||||||
|
UnexpectedTag,
|
||||||
|
MissingValue,
|
||||||
|
ParseIntError,
|
||||||
|
NonUTF8,
|
||||||
|
WriteError,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Default, Debug)]
|
||||||
|
pub struct Field {
|
||||||
|
name: String,
|
||||||
|
lsb: usize,
|
||||||
|
msb: usize,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Default, Debug)]
|
||||||
|
pub struct Register {
|
||||||
|
name: String,
|
||||||
|
offset: usize,
|
||||||
|
description: Option<String>,
|
||||||
|
fields: Vec<Field>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Default, Debug)]
|
||||||
|
pub struct Interrupt {
|
||||||
|
name: String,
|
||||||
|
value: usize,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Default, Debug)]
|
||||||
|
pub struct Peripheral {
|
||||||
|
name: String,
|
||||||
|
pub base: usize,
|
||||||
|
size: usize,
|
||||||
|
interrupt: Vec<Interrupt>,
|
||||||
|
registers: Vec<Register>,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Default, Debug)]
|
||||||
|
pub struct MemoryRegion {
|
||||||
|
pub name: String,
|
||||||
|
pub base: usize,
|
||||||
|
pub size: usize,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Default, Debug)]
|
||||||
|
pub struct Constant {
|
||||||
|
pub name: String,
|
||||||
|
pub value: String,
|
||||||
|
}
|
||||||
|
|
||||||
|
#[derive(Default, Debug)]
|
||||||
|
pub struct Description {
|
||||||
|
pub peripherals: Vec<Peripheral>,
|
||||||
|
pub memory_regions: Vec<MemoryRegion>,
|
||||||
|
pub constants: Vec<Constant>,
|
||||||
|
}
|
||||||
|
|
||||||
|
impl core::fmt::Display for ParseError {
|
||||||
|
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
|
||||||
|
use ParseError::*;
|
||||||
|
match *self {
|
||||||
|
UnexpectedTag => write!(f, "unexpected XML tag encountered"),
|
||||||
|
MissingValue => write!(f, "XML tag should have contained a value"),
|
||||||
|
ParseIntError => write!(f, "unable to parse number"),
|
||||||
|
NonUTF8 => write!(f, "file is not UTF-8"),
|
||||||
|
WriteError => write!(f, "unable to write destination file"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
impl std::error::Error for ParseError {}
|
||||||
|
|
||||||
|
pub fn get_base(value: &str) -> (&str, u32) {
|
||||||
|
if value.starts_with("0x") {
|
||||||
|
(value.trim_start_matches("0x"), 16)
|
||||||
|
} else if value.starts_with("0X") {
|
||||||
|
(value.trim_start_matches("0X"), 16)
|
||||||
|
} else if value.starts_with("0b") {
|
||||||
|
(value.trim_start_matches("0b"), 2)
|
||||||
|
} else if value.starts_with("0B") {
|
||||||
|
(value.trim_start_matches("0B"), 2)
|
||||||
|
} else if value.starts_with('0') && value != "0" {
|
||||||
|
(value.trim_start_matches('0'), 8)
|
||||||
|
} else {
|
||||||
|
(value, 10)
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn parse_usize(value: &[u8]) -> Result<usize, ParseError> {
|
||||||
|
let value_as_str = String::from_utf8(value.to_vec()).or(Err(ParseError::NonUTF8))?;
|
||||||
|
let (value, base) = get_base(&value_as_str);
|
||||||
|
usize::from_str_radix(value, base).or(Err(ParseError::ParseIntError))
|
||||||
|
}
|
||||||
|
|
||||||
|
fn extract_contents<T: BufRead>(reader: &mut Reader<T>) -> Result<String, ParseError> {
|
||||||
|
let mut buf = Vec::new();
|
||||||
|
let contents = reader
|
||||||
|
.read_event(&mut buf)
|
||||||
|
.map_err(|_| ParseError::UnexpectedTag)?;
|
||||||
|
match contents {
|
||||||
|
Event::Text(t) => t
|
||||||
|
.unescape_and_decode(reader)
|
||||||
|
.map_err(|_| ParseError::NonUTF8),
|
||||||
|
_ => Err(ParseError::UnexpectedTag),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
fn generate_field<T: BufRead>(reader: &mut Reader<T>) -> Result<Field, ParseError> {
|
||||||
|
let mut buf = Vec::new();
|
||||||
|
let mut name = None;
|
||||||
|
let mut lsb = None;
|
||||||
|
let mut msb = None;
|
||||||
|
loop {
|
||||||
|
match reader.read_event(&mut buf) {
|
||||||
|
Ok(Event::Start(ref e)) => {
|
||||||
|
let tag_name = e
|
||||||
|
.unescape_and_decode(reader)
|
||||||
|
.map_err(|_| ParseError::NonUTF8)?;
|
||||||
|
match tag_name.as_str() {
|
||||||
|
"name" => name = Some(extract_contents(reader)?),
|
||||||
|
"lsb" => lsb = Some(parse_usize(extract_contents(reader)?.as_bytes())?),
|
||||||
|
"msb" => msb = Some(parse_usize(extract_contents(reader)?.as_bytes())?),
|
||||||
|
_ => (),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(Event::End(ref e)) => {
|
||||||
|
if let b"field" = e.name() {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(_) => (),
|
||||||
|
Err(e) => panic!("error parsing: {:?}", e),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(Field {
|
||||||
|
name: name.ok_or(ParseError::MissingValue)?,
|
||||||
|
lsb: lsb.ok_or(ParseError::MissingValue)?,
|
||||||
|
msb: msb.ok_or(ParseError::MissingValue)?,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn generate_fields<T: BufRead>(
|
||||||
|
reader: &mut Reader<T>,
|
||||||
|
fields: &mut Vec<Field>,
|
||||||
|
) -> Result<(), ParseError> {
|
||||||
|
let mut buf = Vec::new();
|
||||||
|
loop {
|
||||||
|
match reader.read_event(&mut buf) {
|
||||||
|
Ok(Event::Start(ref e)) => match e.name() {
|
||||||
|
b"field" => fields.push(generate_field(reader)?),
|
||||||
|
_ => panic!("unexpected tag in <field>: {:?}", e),
|
||||||
|
},
|
||||||
|
Ok(Event::End(ref e)) => match e.name() {
|
||||||
|
b"fields" => {
|
||||||
|
// println!("End fields");
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
e => panic!("unhandled value: {:?}", e),
|
||||||
|
},
|
||||||
|
Ok(Event::Text(_)) => (),
|
||||||
|
e => panic!("unhandled value: {:?}", e),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn generate_register<T: BufRead>(reader: &mut Reader<T>) -> Result<Register, ParseError> {
|
||||||
|
let mut buf = Vec::new();
|
||||||
|
let mut name = None;
|
||||||
|
let mut offset = None;
|
||||||
|
let description = None;
|
||||||
|
let mut fields = vec![];
|
||||||
|
loop {
|
||||||
|
match reader.read_event(&mut buf) {
|
||||||
|
Ok(Event::Start(ref e)) => {
|
||||||
|
let tag_name = e
|
||||||
|
.unescape_and_decode(reader)
|
||||||
|
.map_err(|_| ParseError::NonUTF8)?;
|
||||||
|
match tag_name.as_str() {
|
||||||
|
"name" => name = Some(extract_contents(reader)?),
|
||||||
|
"addressOffset" => {
|
||||||
|
offset = Some(parse_usize(extract_contents(reader)?.as_bytes())?)
|
||||||
|
}
|
||||||
|
"fields" => generate_fields(reader, &mut fields)?,
|
||||||
|
_ => (),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(Event::End(ref e)) => {
|
||||||
|
if let b"register" = e.name() {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(_) => (),
|
||||||
|
Err(e) => panic!("error parsing: {:?}", e),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(Register {
|
||||||
|
name: name.ok_or(ParseError::MissingValue)?,
|
||||||
|
offset: offset.ok_or(ParseError::MissingValue)?,
|
||||||
|
description,
|
||||||
|
fields,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn generate_interrupts<T: BufRead>(
|
||||||
|
reader: &mut Reader<T>,
|
||||||
|
interrupts: &mut Vec<Interrupt>,
|
||||||
|
) -> Result<(), ParseError> {
|
||||||
|
let mut buf = Vec::new();
|
||||||
|
let mut name = None;
|
||||||
|
let mut value = None;
|
||||||
|
loop {
|
||||||
|
match reader.read_event(&mut buf) {
|
||||||
|
Ok(Event::Start(ref e)) => {
|
||||||
|
let tag_name = e
|
||||||
|
.unescape_and_decode(reader)
|
||||||
|
.map_err(|_| ParseError::NonUTF8)?;
|
||||||
|
match tag_name.as_str() {
|
||||||
|
"name" => name = Some(extract_contents(reader)?),
|
||||||
|
"value" => value = Some(parse_usize(extract_contents(reader)?.as_bytes())?),
|
||||||
|
_ => (),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(Event::End(ref e)) => {
|
||||||
|
if let b"interrupt" = e.name() {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(_) => (),
|
||||||
|
Err(e) => panic!("error parsing: {:?}", e),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
interrupts.push(Interrupt {
|
||||||
|
name: name.ok_or(ParseError::MissingValue)?,
|
||||||
|
value: value.ok_or(ParseError::MissingValue)?,
|
||||||
|
});
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn generate_registers<T: BufRead>(
|
||||||
|
reader: &mut Reader<T>,
|
||||||
|
registers: &mut Vec<Register>,
|
||||||
|
) -> Result<(), ParseError> {
|
||||||
|
let mut buf = Vec::new();
|
||||||
|
loop {
|
||||||
|
match reader.read_event(&mut buf) {
|
||||||
|
Ok(Event::Start(ref e)) => match e.name() {
|
||||||
|
b"register" => registers.push(generate_register(reader)?),
|
||||||
|
_ => panic!("unexpected tag in <registers>: {:?}", e),
|
||||||
|
},
|
||||||
|
Ok(Event::End(ref e)) => match e.name() {
|
||||||
|
b"registers" => {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
e => panic!("unhandled value: {:?}", e),
|
||||||
|
},
|
||||||
|
Ok(Event::Text(_)) => (),
|
||||||
|
e => panic!("unhandled value: {:?}", e),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn generate_peripheral<T: BufRead>(reader: &mut Reader<T>) -> Result<Peripheral, ParseError> {
|
||||||
|
let mut buf = Vec::new();
|
||||||
|
let mut name = None;
|
||||||
|
let mut base = None;
|
||||||
|
let mut size = None;
|
||||||
|
let mut registers = vec![];
|
||||||
|
let mut interrupts = vec![];
|
||||||
|
loop {
|
||||||
|
match reader.read_event(&mut buf) {
|
||||||
|
Ok(Event::Start(ref e)) => {
|
||||||
|
let tag_name = e
|
||||||
|
.unescape_and_decode(reader)
|
||||||
|
.map_err(|_| ParseError::NonUTF8)?;
|
||||||
|
match tag_name.as_str() {
|
||||||
|
"name" => name = Some(extract_contents(reader)?),
|
||||||
|
"baseAddress" => {
|
||||||
|
base = Some(parse_usize(extract_contents(reader)?.as_bytes())?)
|
||||||
|
}
|
||||||
|
"size" => size = Some(parse_usize(extract_contents(reader)?.as_bytes())?),
|
||||||
|
"registers" => generate_registers(reader, &mut registers)?,
|
||||||
|
"interrupt" => generate_interrupts(reader, &mut interrupts)?,
|
||||||
|
_ => (),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(Event::End(ref e)) => {
|
||||||
|
if let b"peripheral" = e.name() {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(_) => (),
|
||||||
|
Err(e) => panic!("error parsing: {:?}", e),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(Peripheral {
|
||||||
|
name: name.ok_or(ParseError::MissingValue)?,
|
||||||
|
base: base.ok_or(ParseError::MissingValue)?,
|
||||||
|
size: size.ok_or(ParseError::MissingValue)?,
|
||||||
|
interrupt: interrupts,
|
||||||
|
registers,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn generate_peripherals<T: BufRead>(reader: &mut Reader<T>) -> Result<Vec<Peripheral>, ParseError> {
|
||||||
|
let mut buf = Vec::new();
|
||||||
|
let mut peripherals = vec![];
|
||||||
|
loop {
|
||||||
|
match reader.read_event(&mut buf) {
|
||||||
|
Ok(Event::Start(ref e)) => match e.name() {
|
||||||
|
b"peripheral" => peripherals.push(generate_peripheral(reader)?),
|
||||||
|
_ => panic!("unexpected tag in <peripherals>: {:?}", e),
|
||||||
|
},
|
||||||
|
Ok(Event::End(ref e)) => match e.name() {
|
||||||
|
b"peripherals" => {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
e => panic!("unhandled value: {:?}", e),
|
||||||
|
},
|
||||||
|
Ok(Event::Text(_)) => (),
|
||||||
|
e => panic!("unhandled value: {:?}", e),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(peripherals)
|
||||||
|
}
|
||||||
|
|
||||||
|
fn generate_memory_region<T: BufRead>(reader: &mut Reader<T>) -> Result<MemoryRegion, ParseError> {
|
||||||
|
let mut buf = Vec::new();
|
||||||
|
let mut name = None;
|
||||||
|
let mut base = None;
|
||||||
|
let mut size = None;
|
||||||
|
|
||||||
|
loop {
|
||||||
|
match reader.read_event(&mut buf) {
|
||||||
|
Ok(Event::Start(ref e)) => {
|
||||||
|
let tag_name = e
|
||||||
|
.unescape_and_decode(reader)
|
||||||
|
.map_err(|_| ParseError::NonUTF8)?;
|
||||||
|
match tag_name.as_str() {
|
||||||
|
"name" => name = Some(extract_contents(reader)?),
|
||||||
|
"baseAddress" => {
|
||||||
|
base = Some(parse_usize(extract_contents(reader)?.as_bytes())?)
|
||||||
|
}
|
||||||
|
"size" => size = Some(parse_usize(extract_contents(reader)?.as_bytes())?),
|
||||||
|
_ => (),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(Event::End(ref e)) => {
|
||||||
|
if let b"memoryRegion" = e.name() {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(_) => (),
|
||||||
|
Err(e) => panic!("error parsing: {:?}", e),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
Ok(MemoryRegion {
|
||||||
|
name: name.ok_or(ParseError::MissingValue)?,
|
||||||
|
base: base.ok_or(ParseError::MissingValue)?,
|
||||||
|
size: size.ok_or(ParseError::MissingValue)?,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
fn parse_memory_regions<T: BufRead>(
|
||||||
|
reader: &mut Reader<T>,
|
||||||
|
description: &mut Description,
|
||||||
|
) -> Result<(), ParseError> {
|
||||||
|
let mut buf = Vec::new();
|
||||||
|
loop {
|
||||||
|
match reader.read_event(&mut buf) {
|
||||||
|
Ok(Event::Start(ref e)) => match e.name() {
|
||||||
|
b"memoryRegion" => description
|
||||||
|
.memory_regions
|
||||||
|
.push(generate_memory_region(reader)?),
|
||||||
|
_ => panic!("unexpected tag in <memoryRegions>: {:?}", e),
|
||||||
|
},
|
||||||
|
Ok(Event::End(ref e)) => match e.name() {
|
||||||
|
b"memoryRegions" => {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
e => panic!("unhandled value: {:?}", e),
|
||||||
|
},
|
||||||
|
Ok(Event::Text(_)) => (),
|
||||||
|
e => panic!("unhandled value: {:?}", e),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn generate_constants<T: BufRead>(
|
||||||
|
reader: &mut Reader<T>,
|
||||||
|
description: &mut Description,
|
||||||
|
) -> Result<(), ParseError> {
|
||||||
|
let mut buf = Vec::new();
|
||||||
|
loop {
|
||||||
|
match reader.read_event(&mut buf) {
|
||||||
|
Ok(Event::Empty(ref e)) => match e.name() {
|
||||||
|
b"constant" => {
|
||||||
|
let mut constant_descriptor = Constant::default();
|
||||||
|
for maybe_att in e.attributes() {
|
||||||
|
match maybe_att {
|
||||||
|
Ok(att) => {
|
||||||
|
let att_name = String::from_utf8(att.key.to_vec())
|
||||||
|
.expect("constant: error parsing attribute name");
|
||||||
|
let att_value = String::from_utf8(att.value.to_vec())
|
||||||
|
.expect("constant: error parsing attribute value");
|
||||||
|
match att_name {
|
||||||
|
_ if att_name == "name" => constant_descriptor.name = att_value,
|
||||||
|
_ if att_name == "value" => {
|
||||||
|
constant_descriptor.value = att_value
|
||||||
|
}
|
||||||
|
_ => panic!("unexpected attribute name"),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
_ => panic!("unexpected value in constant: {:?}", maybe_att),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
description.constants.push(constant_descriptor)
|
||||||
|
}
|
||||||
|
_ => panic!("unexpected tag in <constants>: {:?}", e),
|
||||||
|
},
|
||||||
|
// note to future self: if Litex goe away from attributes to nested elements, you would want
|
||||||
|
// Ok(Event::Start(ref e) => match e.name() ... to descend into the next tag level, and then
|
||||||
|
// use the tag_name match and extract_contents methods from other functions to generate
|
||||||
|
// the structure.
|
||||||
|
// note that the two formats could be mutually exclusively compatible within the same code base:
|
||||||
|
// if there are no attributes, the attribute iterator would do nothing; and if there are no
|
||||||
|
// child elements, the recursive descent would also do nothing.
|
||||||
|
Ok(Event::End(ref e)) => match e.name() {
|
||||||
|
b"constants" => break,
|
||||||
|
e => panic!("unhandled value: {:?}", e),
|
||||||
|
},
|
||||||
|
Ok(Event::Text(_)) => (),
|
||||||
|
e => panic!("unhandled value: {:?}", e),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn parse_vendor_extensions<T: BufRead>(
|
||||||
|
reader: &mut Reader<T>,
|
||||||
|
description: &mut Description,
|
||||||
|
) -> Result<(), ParseError> {
|
||||||
|
let mut buf = Vec::new();
|
||||||
|
loop {
|
||||||
|
match reader.read_event(&mut buf) {
|
||||||
|
Ok(Event::Start(ref e)) => match e.name() {
|
||||||
|
b"memoryRegions" => parse_memory_regions(reader, description)?,
|
||||||
|
b"constants" => generate_constants(reader, description)?,
|
||||||
|
_ => panic!("unexpected tag in <vendorExtensions>: {:?}", e),
|
||||||
|
},
|
||||||
|
Ok(Event::End(ref e)) => match e.name() {
|
||||||
|
b"vendorExtensions" => {
|
||||||
|
break;
|
||||||
|
}
|
||||||
|
e => panic!("unhandled value: {:?}", e),
|
||||||
|
},
|
||||||
|
Ok(Event::Text(_)) => (),
|
||||||
|
e => panic!("unhandled value: {:?}", e),
|
||||||
|
}
|
||||||
|
}
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn print_header<U: Write>(out: &mut U) -> std::io::Result<()> {
|
||||||
|
let s = r####"// Renode Platform file generated by svd2repl
|
||||||
|
// This file is automatically generated
|
||||||
|
cpu: CPU.VexRiscv @ sysbus
|
||||||
|
cpuType: "rv32imac"
|
||||||
|
privilegeArchitecture: PrivilegeArchitecture.Priv1_10
|
||||||
|
PerformanceInMips: 120
|
||||||
|
"####;
|
||||||
|
out.write_all(s.as_bytes())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn print_footer<U: Write>(out: &mut U) -> std::io::Result<()> {
|
||||||
|
let s = r####"
|
||||||
|
sysbus:
|
||||||
|
init:
|
||||||
|
ApplySVD @soc/renode.svd
|
||||||
|
"####;
|
||||||
|
out.write_all(s.as_bytes())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn print_memory_regions<U: Write>(regions: &[MemoryRegion], out: &mut U) -> std::io::Result<()> {
|
||||||
|
writeln!(out, "// Physical base addresses of memory regions")?;
|
||||||
|
for region in regions {
|
||||||
|
let mut region_name = region.name.to_lowercase();
|
||||||
|
let region_size = if region.size < 4096 {
|
||||||
|
4096
|
||||||
|
} else {
|
||||||
|
if region.size & 4095 != 0 {
|
||||||
|
region.size + 4096 - (region.size & 4095)
|
||||||
|
} else {
|
||||||
|
region.size
|
||||||
|
}
|
||||||
|
};
|
||||||
|
|
||||||
|
// Ignore the CSR region, since we explicitly define registers there.
|
||||||
|
if region_name == "csr" {
|
||||||
|
continue;
|
||||||
|
}
|
||||||
|
|
||||||
|
// The current design doubles-up on this identifier, so bodge in a new name.
|
||||||
|
if region_name == "memlcd" {
|
||||||
|
region_name = "fbmem".to_string();
|
||||||
|
}
|
||||||
|
|
||||||
|
writeln!(
|
||||||
|
out,
|
||||||
|
"{}: Memory.MappedMemory @ sysbus 0x{:08x}",
|
||||||
|
region_name, region.base
|
||||||
|
)?;
|
||||||
|
writeln!(out, " size: 0x{:08x}", region_size)?;
|
||||||
|
writeln!(out)?;
|
||||||
|
}
|
||||||
|
writeln!(out)?;
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
fn print_peripherals<U: Write>(
|
||||||
|
peripherals: &[Peripheral],
|
||||||
|
constants: &[Constant],
|
||||||
|
out: &mut U,
|
||||||
|
) -> std::io::Result<()> {
|
||||||
|
use std::collections::HashMap;
|
||||||
|
let mut known_peripherals = HashMap::new();
|
||||||
|
known_peripherals.insert("console", "UART.LiteX_UART");
|
||||||
|
known_peripherals.insert("uart", "UART.LiteX_UART");
|
||||||
|
known_peripherals.insert("app_uart", "UART.LiteX_UART");
|
||||||
|
known_peripherals.insert("timer0", "Timers.LiteX_Timer_32");
|
||||||
|
|
||||||
|
known_peripherals.insert("memlcd", "Video.BetrustedLCD");
|
||||||
|
known_peripherals.insert("keyboard", "Input.BetrustedKbd");
|
||||||
|
known_peripherals.insert("trng_kernel", "Miscellaneous.BetrustedRNGKernel");
|
||||||
|
known_peripherals.insert("trng_server", "Miscellaneous.BetrustedRNGServer");
|
||||||
|
known_peripherals.insert("ticktimer", "Timers.TickTimer");
|
||||||
|
writeln!(out, "// Platform Peripherals")?;
|
||||||
|
for peripheral in peripherals {
|
||||||
|
let lc_name = peripheral.name.to_lowercase();
|
||||||
|
// let peripheral_size = if peripheral.size < 4096 {
|
||||||
|
// 4096
|
||||||
|
// } else {
|
||||||
|
// peripheral.size
|
||||||
|
// };
|
||||||
|
if let Some(renode_device) = known_peripherals.get(lc_name.as_str()) {
|
||||||
|
writeln!(
|
||||||
|
out,
|
||||||
|
"{}: {} @ sysbus 0x{:08x}",
|
||||||
|
lc_name, renode_device, peripheral.base
|
||||||
|
)?;
|
||||||
|
|
||||||
|
// TODO: Get the frequency from the `constants` table under `CONFIG_CLOCK_FREQUENCY`
|
||||||
|
if lc_name == "timer0" {
|
||||||
|
let mut freq_found = false;
|
||||||
|
for constant in constants {
|
||||||
|
if constant.name == "CONFIG_CLOCK_FREQUENCY" {
|
||||||
|
writeln!(out, " frequency: {}", constant.value)?;
|
||||||
|
freq_found = true;
|
||||||
|
}
|
||||||
|
}
|
||||||
|
if !freq_found {
|
||||||
|
panic!("Couldn't discover clock frequency when creating timer0 object");
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
// Note: we skip the `size` value here, since peripherals don't have a known size.
|
||||||
|
|
||||||
|
// Add the interrupt, if one exists.
|
||||||
|
if let Some(irq) = peripheral.interrupt.get(0) {
|
||||||
|
writeln!(out, " -> cpu @ {}", 1000 + irq.value)?;
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
writeln!(out, "// Unrecognized peripheral: {}", lc_name)?;
|
||||||
|
}
|
||||||
|
writeln!(out)?;
|
||||||
|
}
|
||||||
|
writeln!(out)?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn parse_svd<T: Read>(src: T) -> Result<Description, ParseError> {
|
||||||
|
let mut buf = Vec::new();
|
||||||
|
let buf_reader = BufReader::new(src);
|
||||||
|
let mut reader = Reader::from_reader(buf_reader);
|
||||||
|
let mut description = Description::default();
|
||||||
|
loop {
|
||||||
|
match reader.read_event(&mut buf) {
|
||||||
|
Ok(Event::Start(ref e)) => match e.name() {
|
||||||
|
b"peripherals" => {
|
||||||
|
description.peripherals = generate_peripherals(&mut reader)?;
|
||||||
|
}
|
||||||
|
b"vendorExtensions" => {
|
||||||
|
parse_vendor_extensions(&mut reader, &mut description)?;
|
||||||
|
}
|
||||||
|
_ => (),
|
||||||
|
},
|
||||||
|
Ok(Event::Eof) => break,
|
||||||
|
Err(e) => panic!("Error at position {}: {:?}", reader.buffer_position(), e),
|
||||||
|
_ => (),
|
||||||
|
}
|
||||||
|
buf.clear();
|
||||||
|
}
|
||||||
|
Ok(description)
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn generate<T: Read, U: Write>(src: T, dest: &mut U) -> Result<(), ParseError> {
|
||||||
|
let description = parse_svd(src)?;
|
||||||
|
|
||||||
|
print_header(dest).or(Err(ParseError::WriteError))?;
|
||||||
|
print_peripherals(&description.peripherals, &description.constants, dest)
|
||||||
|
.or(Err(ParseError::WriteError))?;
|
||||||
|
print_memory_regions(&description.memory_regions, dest).or(Err(ParseError::WriteError))?;
|
||||||
|
print_footer(dest).or(Err(ParseError::WriteError))?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
15
svd2repl/src/lib.rs
Normal file
15
svd2repl/src/lib.rs
Normal file
|
|
@ -0,0 +1,15 @@
|
||||||
|
mod generate;
|
||||||
|
pub use generate::*;
|
||||||
|
|
||||||
|
#[cfg(test)]
|
||||||
|
mod tests {
|
||||||
|
use super::*;
|
||||||
|
use std::fs::{DirBuilder, File};
|
||||||
|
#[test]
|
||||||
|
fn basic_generate() {
|
||||||
|
let src = File::open("examples/soc.svd").unwrap();
|
||||||
|
DirBuilder::new().recursive(true).create("target").unwrap();
|
||||||
|
let mut dest = File::create("target/example.rs").unwrap();
|
||||||
|
generate(src, &mut dest).unwrap();
|
||||||
|
}
|
||||||
|
}
|
||||||
44
svd2repl/src/main.rs
Normal file
44
svd2repl/src/main.rs
Normal file
|
|
@ -0,0 +1,44 @@
|
||||||
|
mod generate;
|
||||||
|
|
||||||
|
use anyhow::Context;
|
||||||
|
use clap::{App, Arg};
|
||||||
|
use std::fs::File;
|
||||||
|
use std::io::{Read, Write};
|
||||||
|
|
||||||
|
fn main() -> anyhow::Result<()> {
|
||||||
|
let matches = App::new("svd2repl")
|
||||||
|
.about("Generate a Rebide Platform description from SVD files")
|
||||||
|
.arg(
|
||||||
|
Arg::with_name("input")
|
||||||
|
.help("Input SVD file")
|
||||||
|
.short("i")
|
||||||
|
.takes_value(true)
|
||||||
|
.value_name("FILE"),
|
||||||
|
)
|
||||||
|
.arg(
|
||||||
|
Arg::with_name("output")
|
||||||
|
.help("Output .repl file or directory")
|
||||||
|
.short("o")
|
||||||
|
.takes_value(true)
|
||||||
|
.value_name("FILE"),
|
||||||
|
)
|
||||||
|
.version(concat!(
|
||||||
|
env!("CARGO_PKG_VERSION"),
|
||||||
|
include_str!(concat!(env!("OUT_DIR"), "/commit-info.txt"))
|
||||||
|
))
|
||||||
|
.get_matches();
|
||||||
|
|
||||||
|
let src: Box<dyn Read> = match matches.value_of("input") {
|
||||||
|
Some(file) => Box::new(File::open(file).context("Cannot open the SVD file")?),
|
||||||
|
None => Box::new(std::io::stdin()),
|
||||||
|
};
|
||||||
|
|
||||||
|
let mut dest: Box<dyn Write> = match matches.value_of("output") {
|
||||||
|
None => Box::new(std::io::stdout()),
|
||||||
|
Some(path) => Box::new(File::create(path).context("Cannot open destination file")?),
|
||||||
|
};
|
||||||
|
|
||||||
|
generate::generate(src, &mut dest).context("Cannot generate output file")?;
|
||||||
|
|
||||||
|
Ok(())
|
||||||
|
}
|
||||||
|
|
@ -1,7 +1,7 @@
|
||||||
use crate::xous_arguments::{XousArgument, XousArgumentCode, XousSize};
|
use crate::xous_arguments::{XousArgument, XousArgumentCode, XousSize};
|
||||||
|
use std::collections::BTreeMap;
|
||||||
use std::fmt;
|
use std::fmt;
|
||||||
use std::io;
|
use std::io;
|
||||||
use std::collections::BTreeMap;
|
|
||||||
|
|
||||||
#[derive(Debug)]
|
#[derive(Debug)]
|
||||||
pub struct ProcessNames {
|
pub struct ProcessNames {
|
||||||
|
|
@ -21,7 +21,9 @@ impl fmt::Display for ProcessNames {
|
||||||
|
|
||||||
impl ProcessNames {
|
impl ProcessNames {
|
||||||
pub fn new() -> ProcessNames {
|
pub fn new() -> ProcessNames {
|
||||||
ProcessNames { names: BTreeMap::new() }
|
ProcessNames {
|
||||||
|
names: BTreeMap::new(),
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn set(&mut self, pid: u32, name: &str) {
|
pub fn set(&mut self, pid: u32, name: &str) {
|
||||||
|
|
@ -41,7 +43,7 @@ impl XousArgument for ProcessNames {
|
||||||
size += 4;
|
size += 4;
|
||||||
size += val.len();
|
size += val.len();
|
||||||
// Pad it to 4-bytes
|
// Pad it to 4-bytes
|
||||||
size += (4-(val.len() & 3))&3;
|
size += (4 - (val.len() & 3)) & 3;
|
||||||
}
|
}
|
||||||
size as XousSize
|
size as XousSize
|
||||||
}
|
}
|
||||||
|
|
@ -54,7 +56,7 @@ impl XousArgument for ProcessNames {
|
||||||
written += output.write(name.as_bytes())?;
|
written += output.write(name.as_bytes())?;
|
||||||
|
|
||||||
// Pad it to 4-bytes
|
// Pad it to 4-bytes
|
||||||
for _ in 0..(4-(name.len() & 3))&3 {
|
for _ in 0..(4 - (name.len() & 3)) & 3 {
|
||||||
written += output.write(&[0])?;
|
written += output.write(&[0])?;
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -436,7 +436,7 @@ def main():
|
||||||
LOC_WF200 = 0x07F80000
|
LOC_WF200 = 0x07F80000
|
||||||
LOC_EC = 0x07FCE000
|
LOC_EC = 0x07FCE000
|
||||||
else:
|
else:
|
||||||
print("SoC is from an unknow rev, use --force to continue anyways with v0.8 firmware offsets")
|
print("SoC is from an unknow rev '{}', use --force to continue anyways with v0.8 firmware offsets".format(pc_usb.load_csrs()))
|
||||||
exit(1)
|
exit(1)
|
||||||
|
|
||||||
vexdbg_addr = int(pc_usb.regions['vexriscv_debug'][0], 0)
|
vexdbg_addr = int(pc_usb.regions['vexriscv_debug'][0], 0)
|
||||||
|
|
|
||||||
|
|
@ -1,10 +1,12 @@
|
||||||
[package]
|
[package]
|
||||||
name = "xous"
|
name = "xous"
|
||||||
version = "0.8.0"
|
version = "0.8.3"
|
||||||
authors = ["Sean Cross <sean@xobs.io>"]
|
authors = ["Sean Cross <sean@xobs.io>"]
|
||||||
edition = "2018"
|
edition = "2018"
|
||||||
license = "MIT OR Apache-2.0"
|
license = "MIT OR Apache-2.0"
|
||||||
description = "System call interface for Xous"
|
description = "System call interface for Xous"
|
||||||
|
repository = "https://github.com/betrusted-io/xous-core/"
|
||||||
|
homepage = "https://betrusted.io/"
|
||||||
|
|
||||||
[dependencies]
|
[dependencies]
|
||||||
bitflags = {version = "1", optional = true }
|
bitflags = {version = "1", optional = true }
|
||||||
|
|
|
||||||
|
|
@ -297,9 +297,7 @@ fn xous_address() -> SocketAddr {
|
||||||
.unwrap_or_else(default_xous_address)
|
.unwrap_or_else(default_xous_address)
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn create_thread_0_pre<U>(
|
pub fn create_thread_0_pre<U>(_f: &fn() -> U) -> core::result::Result<ThreadInit, crate::Error>
|
||||||
_f: &fn() -> U,
|
|
||||||
) -> core::result::Result<ThreadInit, crate::Error>
|
|
||||||
where
|
where
|
||||||
U: Send + 'static,
|
U: Send + 'static,
|
||||||
{
|
{
|
||||||
|
|
|
||||||
|
|
@ -70,7 +70,10 @@ pub struct ProcessInit {
|
||||||
pub key: ProcessKey,
|
pub key: ProcessKey,
|
||||||
}
|
}
|
||||||
|
|
||||||
pub struct WaitHandle<T>(core::marker::PhantomData<T>);
|
pub struct WaitHandle<T> {
|
||||||
|
tid: TID,
|
||||||
|
data: core::marker::PhantomData<T>,
|
||||||
|
}
|
||||||
pub struct ProcessHandle(());
|
pub struct ProcessHandle(());
|
||||||
|
|
||||||
pub fn thread_to_args(syscall: usize, init: &ThreadInit) -> [usize; 8] {
|
pub fn thread_to_args(syscall: usize, init: &ThreadInit) -> [usize; 8] {
|
||||||
|
|
@ -130,8 +133,9 @@ where
|
||||||
todo!()
|
todo!()
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn wait_thread<T>(_joiner: WaitHandle<T>) -> crate::SysCallResult {
|
pub fn wait_thread<T>(joiner: WaitHandle<T>) -> crate::SysCallResult {
|
||||||
todo!()
|
let call = crate::SysCall::JoinThread(joiner.tid);
|
||||||
|
crate::syscall::rsyscall(call)
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn process_to_args(call: usize, init: &ProcessInit) -> [usize; 8] {
|
pub fn process_to_args(call: usize, init: &ProcessInit) -> [usize; 8] {
|
||||||
|
|
@ -359,12 +363,15 @@ pub fn create_thread_n_post<U>(
|
||||||
_arg2: usize,
|
_arg2: usize,
|
||||||
_arg3: usize,
|
_arg3: usize,
|
||||||
_arg4: usize,
|
_arg4: usize,
|
||||||
_thread_id: TID,
|
thread_id: TID,
|
||||||
) -> core::result::Result<WaitHandle<U>, crate::Error>
|
) -> core::result::Result<WaitHandle<U>, crate::Error>
|
||||||
where
|
where
|
||||||
U: Send + 'static,
|
U: Send + 'static,
|
||||||
{
|
{
|
||||||
Ok(WaitHandle(core::marker::PhantomData))
|
Ok(WaitHandle {
|
||||||
|
tid: thread_id,
|
||||||
|
data: core::marker::PhantomData,
|
||||||
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn wait_process(_joiner: ProcessHandle) -> crate::SysCallResult {
|
pub fn wait_process(_joiner: ProcessHandle) -> crate::SysCallResult {
|
||||||
|
|
|
||||||
|
|
@ -413,6 +413,34 @@ impl Message {
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
|
pub fn new_lend(
|
||||||
|
id: usize,
|
||||||
|
buf: MemoryRange,
|
||||||
|
offset: Option<MemoryAddress>,
|
||||||
|
valid: Option<MemorySize>,
|
||||||
|
) -> crate::Message {
|
||||||
|
Message::Borrow(crate::MemoryMessage {
|
||||||
|
id,
|
||||||
|
buf,
|
||||||
|
offset,
|
||||||
|
valid,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn new_lend_mut(
|
||||||
|
id: usize,
|
||||||
|
buf: MemoryRange,
|
||||||
|
offset: Option<MemoryAddress>,
|
||||||
|
valid: Option<MemorySize>,
|
||||||
|
) -> crate::Message {
|
||||||
|
Message::MutableBorrow(crate::MemoryMessage {
|
||||||
|
id,
|
||||||
|
buf,
|
||||||
|
offset,
|
||||||
|
valid,
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
/// Determine whether the specified Message will block
|
/// Determine whether the specified Message will block
|
||||||
pub fn is_blocking(&self) -> bool {
|
pub fn is_blocking(&self) -> bool {
|
||||||
match *self {
|
match *self {
|
||||||
|
|
|
||||||
|
|
@ -155,8 +155,7 @@ macro_rules! maybe_main {
|
||||||
try_send_message(conn, Message::Scalar(panic_start_msg)).ok();
|
try_send_message(conn, Message::Scalar(panic_start_msg)).ok();
|
||||||
}
|
}
|
||||||
wait_event();
|
wait_event();
|
||||||
terminate_process();
|
terminate_process(1);
|
||||||
loop {}
|
|
||||||
}
|
}
|
||||||
|
|
||||||
extern "Rust" {
|
extern "Rust" {
|
||||||
|
|
|
||||||
|
|
@ -26,7 +26,7 @@ Here is the allocation so far:
|
||||||
|
|
||||||
*/
|
*/
|
||||||
|
|
||||||
pub const GID_KEYBOARD_KEYSTATE_EVENT: usize = 0x01_000000;
|
pub const GID_KEYBOARD_KEYSTATE_EVENT: usize = 0x01_000000;
|
||||||
pub const GID_KEYBOARD_RAW_KEYSTATE_EVENT: usize = 0x01_000001;
|
pub const GID_KEYBOARD_RAW_KEYSTATE_EVENT: usize = 0x01_000001;
|
||||||
|
|
||||||
pub const GID_COM_BATTSTATS_EVENT: usize = 0x02_000000;
|
pub const GID_COM_BATTSTATS_EVENT: usize = 0x02_000000;
|
||||||
|
|
|
||||||
|
|
@ -1,13 +1,13 @@
|
||||||
use crate::{
|
use crate::{
|
||||||
map_memory, send_message, unmap_memory, Error, MemoryFlags, MemoryMessage, MemoryRange,
|
map_memory, send_message, unmap_memory, Error, MemoryMessage, MemoryRange, MemorySize, Message,
|
||||||
MemorySize, Message, Result, CID,
|
Result, CID,
|
||||||
};
|
};
|
||||||
|
|
||||||
/// A buffered String suitable for sending across as a message
|
/// A buffered String suitable for sending across as a message
|
||||||
pub struct StringBuffer<'a> {
|
pub struct StringBuffer<'a> {
|
||||||
/// The backing store for this string, as a mutable pointer to
|
/// The backing store for this string, as a mutable pointer to
|
||||||
/// page-aligned memory.
|
/// page-aligned memory.
|
||||||
bytes: &'a mut [u8],
|
bytes: Option<&'a mut [u8]>,
|
||||||
|
|
||||||
// Current length of the string, in bytes
|
// Current length of the string, in bytes
|
||||||
length: u32,
|
length: u32,
|
||||||
|
|
@ -28,9 +28,7 @@ impl<'a> StringBuffer<'a> {
|
||||||
/// resized as soon as data is written to it.
|
/// resized as soon as data is written to it.
|
||||||
pub fn new() -> Self {
|
pub fn new() -> Self {
|
||||||
StringBuffer {
|
StringBuffer {
|
||||||
bytes: unsafe {
|
bytes: None,
|
||||||
core::slice::from_raw_parts_mut(core::ptr::NonNull::dangling().as_ptr(), 0)
|
|
||||||
},
|
|
||||||
length: 0,
|
length: 0,
|
||||||
should_free: true,
|
should_free: true,
|
||||||
memory_message: None,
|
memory_message: None,
|
||||||
|
|
@ -46,7 +44,10 @@ impl<'a> StringBuffer<'a> {
|
||||||
0x1000 - (capacity & 0xFFF)
|
0x1000 - (capacity & 0xFFF)
|
||||||
};
|
};
|
||||||
|
|
||||||
let flags = MemoryFlags::R | MemoryFlags::W;
|
#[cfg(feature = "bit-flags")]
|
||||||
|
let flags = crate::MemoryFlags::R | crate::MemoryFlags::W;
|
||||||
|
#[cfg(not(feature = "bit-flags"))]
|
||||||
|
let flags = 0b0000_0010 | 0b0000_0100;
|
||||||
|
|
||||||
// Allocate enough memory to hold the requested data
|
// Allocate enough memory to hold the requested data
|
||||||
let new_mem = map_memory(
|
let new_mem = map_memory(
|
||||||
|
|
@ -62,9 +63,9 @@ impl<'a> StringBuffer<'a> {
|
||||||
valid.size = MemorySize::new(capacity + remainder).unwrap();
|
valid.size = MemorySize::new(capacity + remainder).unwrap();
|
||||||
|
|
||||||
StringBuffer {
|
StringBuffer {
|
||||||
bytes: unsafe {
|
bytes: Some(unsafe {
|
||||||
core::slice::from_raw_parts_mut(new_mem.as_mut_ptr(), capacity + remainder)
|
core::slice::from_raw_parts_mut(new_mem.as_mut_ptr(), capacity + remainder)
|
||||||
},
|
}),
|
||||||
length: 0,
|
length: 0,
|
||||||
should_free: true,
|
should_free: true,
|
||||||
memory_message: None,
|
memory_message: None,
|
||||||
|
|
@ -85,29 +86,40 @@ impl<'a> StringBuffer<'a> {
|
||||||
|
|
||||||
// If the new size is the same as the current size, don't do anything.
|
// If the new size is the same as the current size, don't do anything.
|
||||||
let rounded_new_capacity = new_capacity + remainder;
|
let rounded_new_capacity = new_capacity + remainder;
|
||||||
if rounded_new_capacity == self.bytes.len() {
|
if rounded_new_capacity == self.bytes.as_ref().map(|b| b.len()).unwrap_or(0) {
|
||||||
return;
|
return;
|
||||||
}
|
}
|
||||||
|
|
||||||
let flags = MemoryFlags::R | MemoryFlags::W;
|
#[cfg(feature = "bit-flags")]
|
||||||
|
let flags = crate::MemoryFlags::R | crate::MemoryFlags::W;
|
||||||
|
#[cfg(not(feature = "bit-flags"))]
|
||||||
|
let flags = 0b0000_0010 | 0b0000_0100;
|
||||||
|
|
||||||
// Allocate enough memory to hold the new requested data
|
// Allocate enough memory to hold the new requested data
|
||||||
let new_mem = map_memory(None, None, rounded_new_capacity, flags)
|
let new_slice = if rounded_new_capacity > 0 {
|
||||||
.expect("Buffer: error in new()/map_memory");
|
let new_mem = map_memory(None, None, rounded_new_capacity, flags)
|
||||||
let new_slice =
|
.expect("Buffer: error in new()/map_memory");
|
||||||
unsafe { core::slice::from_raw_parts_mut(new_mem.as_mut_ptr(), rounded_new_capacity) };
|
let new_slice = unsafe {
|
||||||
|
core::slice::from_raw_parts_mut(new_mem.as_mut_ptr(), rounded_new_capacity)
|
||||||
|
};
|
||||||
|
// Copy the existing string to the new slice
|
||||||
|
for (dest_byte, src_byte) in new_slice
|
||||||
|
.iter_mut()
|
||||||
|
.zip(self.as_bytes()[0..self.len()].iter())
|
||||||
|
{
|
||||||
|
*dest_byte = *src_byte;
|
||||||
|
}
|
||||||
|
Some(new_slice)
|
||||||
|
} else {
|
||||||
|
None
|
||||||
|
};
|
||||||
|
|
||||||
// Copy the existing string to the new slice
|
if let Some(old_slice) = self.bytes.take() {
|
||||||
for (dest_byte, src_byte) in new_slice.iter_mut().zip(self.bytes[0..self.len()].iter()) {
|
let old_addr = old_slice.as_ptr();
|
||||||
*dest_byte = *src_byte;
|
let old_length = old_slice.len();
|
||||||
}
|
|
||||||
|
|
||||||
let old_addr = self.bytes.as_ptr();
|
|
||||||
let old_length = self.bytes.len();
|
|
||||||
self.bytes = new_slice;
|
|
||||||
if old_length != 0 {
|
|
||||||
unmap_memory(MemoryRange::new(old_addr as usize, old_length).unwrap()).unwrap();
|
unmap_memory(MemoryRange::new(old_addr as usize, old_length).unwrap()).unwrap();
|
||||||
}
|
}
|
||||||
|
self.bytes = new_slice;
|
||||||
|
|
||||||
// If the string has shrunk, truncate the string.
|
// If the string has shrunk, truncate the string.
|
||||||
if new_capacity < self.len() {
|
if new_capacity < self.len() {
|
||||||
|
|
@ -122,12 +134,12 @@ impl<'a> StringBuffer<'a> {
|
||||||
let src = src.as_ref();
|
let src = src.as_ref();
|
||||||
let mut s = Self::with_capacity(src.len());
|
let mut s = Self::with_capacity(src.len());
|
||||||
// Copy the string into our backing store.
|
// Copy the string into our backing store.
|
||||||
for (dest_byte, src_byte) in s.bytes.iter_mut().zip(src.as_bytes()) {
|
for (dest_byte, src_byte) in s.bytes.as_mut().unwrap().iter_mut().zip(src.as_bytes()) {
|
||||||
*dest_byte = *src_byte;
|
*dest_byte = *src_byte;
|
||||||
}
|
}
|
||||||
// Set the string length to the length of the passed-in String,
|
// Set the string length to the length of the passed-in String,
|
||||||
// or the maximum possible length. Which ever is smaller.
|
// or the maximum possible length. Which ever is smaller.
|
||||||
s.length = s.bytes.len().min(src.as_bytes().len()) as u32;
|
s.length = s.as_bytes().len().min(src.as_bytes().len()) as u32;
|
||||||
|
|
||||||
// If the string is not valid, set its length to 0.
|
// If the string is not valid, set its length to 0.
|
||||||
if s.as_str().is_err() {
|
if s.as_str().is_err() {
|
||||||
|
|
@ -138,11 +150,27 @@ impl<'a> StringBuffer<'a> {
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn as_bytes(&self) -> &[u8] {
|
pub fn as_bytes(&self) -> &[u8] {
|
||||||
self.bytes
|
if let Some(bytes) = &self.bytes {
|
||||||
|
bytes
|
||||||
|
} else {
|
||||||
|
&[]
|
||||||
|
}
|
||||||
|
}
|
||||||
|
|
||||||
|
pub fn as_bytes_mut(&mut self) -> &mut [u8] {
|
||||||
|
if let Some(bytes) = self.bytes.as_mut() {
|
||||||
|
bytes
|
||||||
|
} else {
|
||||||
|
&mut []
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn as_str(&self) -> core::result::Result<&str, core::str::Utf8Error> {
|
pub fn as_str(&self) -> core::result::Result<&str, core::str::Utf8Error> {
|
||||||
core::str::from_utf8(&self.bytes[0..self.len()])
|
if let Some(bytes) = &self.bytes {
|
||||||
|
core::str::from_utf8(&bytes[0..self.len()])
|
||||||
|
} else {
|
||||||
|
Ok("")
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn len(&self) -> usize {
|
pub fn len(&self) -> usize {
|
||||||
|
|
@ -162,23 +190,34 @@ impl<'a> StringBuffer<'a> {
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn to_str(&self) -> &str {
|
pub fn to_str(&self) -> &str {
|
||||||
unsafe { core::str::from_utf8_unchecked(&self.bytes[0..self.len()]) }
|
if let Some(bytes) = &self.bytes {
|
||||||
|
unsafe { core::str::from_utf8_unchecked(&bytes[0..self.len()]) }
|
||||||
|
} else {
|
||||||
|
""
|
||||||
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
fn create_memory_message(&self, id: u32) -> MemoryMessage {
|
fn create_memory_message(&self, id: u32) -> MemoryMessage {
|
||||||
let backing_store = MemoryRange::new(self.bytes.as_ptr() as _, self.bytes.len()).unwrap();
|
if let Some(bytes) = &self.bytes {
|
||||||
MemoryMessage {
|
let backing_store = MemoryRange::new(bytes.as_ptr() as _, bytes.len()).unwrap();
|
||||||
id: id as usize,
|
MemoryMessage {
|
||||||
buf: backing_store,
|
id: id as usize,
|
||||||
offset: None,
|
buf: backing_store,
|
||||||
valid: MemorySize::new(self.len()),
|
offset: None,
|
||||||
|
valid: MemorySize::new(self.len()),
|
||||||
|
}
|
||||||
|
} else {
|
||||||
|
panic!("Tried to create a memory message with no string!");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub unsafe fn from_memory_message(mem: &'a MemoryMessage) -> Self {
|
pub unsafe fn from_memory_message(mem: &'a MemoryMessage) -> Self {
|
||||||
StringBuffer {
|
StringBuffer {
|
||||||
// range: mem.buf,
|
// range: mem.buf,
|
||||||
bytes: core::slice::from_raw_parts_mut(mem.buf.as_mut_ptr(), mem.buf.len()),
|
bytes: Some(core::slice::from_raw_parts_mut(
|
||||||
|
mem.buf.as_mut_ptr(),
|
||||||
|
mem.buf.len(),
|
||||||
|
)),
|
||||||
length: mem.valid.map(|v| v.get()).unwrap_or(0) as u32,
|
length: mem.valid.map(|v| v.get()).unwrap_or(0) as u32,
|
||||||
// offset: mem.offset,
|
// offset: mem.offset,
|
||||||
should_free: false,
|
should_free: false,
|
||||||
|
|
@ -189,7 +228,10 @@ impl<'a> StringBuffer<'a> {
|
||||||
pub unsafe fn from_memory_message_mut(mem: &'a mut MemoryMessage) -> Self {
|
pub unsafe fn from_memory_message_mut(mem: &'a mut MemoryMessage) -> Self {
|
||||||
StringBuffer {
|
StringBuffer {
|
||||||
// range: mem.buf,
|
// range: mem.buf,
|
||||||
bytes: core::slice::from_raw_parts_mut(mem.buf.as_mut_ptr(), mem.buf.len()),
|
bytes: Some(core::slice::from_raw_parts_mut(
|
||||||
|
mem.buf.as_mut_ptr(),
|
||||||
|
mem.buf.len(),
|
||||||
|
)),
|
||||||
length: mem.valid.map(|v| v.get()).unwrap_or(0) as u32,
|
length: mem.valid.map(|v| v.get()).unwrap_or(0) as u32,
|
||||||
// valid: mem.buf,
|
// valid: mem.buf,
|
||||||
// offset: mem.offset,
|
// offset: mem.offset,
|
||||||
|
|
@ -239,7 +281,7 @@ impl<'a> core::fmt::Write for StringBuffer<'a> {
|
||||||
|
|
||||||
// Copy the data over
|
// Copy the data over
|
||||||
let length = self.len();
|
let length = self.len();
|
||||||
for (dest, src) in self.bytes[length..].iter_mut().zip(s.as_bytes()) {
|
for (dest, src) in self.as_bytes_mut()[length..].iter_mut().zip(s.as_bytes()) {
|
||||||
*dest = *src;
|
*dest = *src;
|
||||||
}
|
}
|
||||||
self.length += s.len() as u32;
|
self.length += s.len() as u32;
|
||||||
|
|
@ -264,7 +306,8 @@ impl<'a> core::convert::AsRef<str> for StringBuffer<'a> {
|
||||||
|
|
||||||
impl<'a> PartialEq for StringBuffer<'a> {
|
impl<'a> PartialEq for StringBuffer<'a> {
|
||||||
fn eq(&self, other: &Self) -> bool {
|
fn eq(&self, other: &Self) -> bool {
|
||||||
self.length == other.length && self.bytes[..self.len()] == other.bytes[..other.len()]
|
self.length == other.length
|
||||||
|
&& self.as_bytes()[..self.len()] == other.as_bytes()[..other.len()]
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -272,8 +315,9 @@ impl<'a> Eq for StringBuffer<'a> {}
|
||||||
|
|
||||||
impl<'a> Drop for StringBuffer<'a> {
|
impl<'a> Drop for StringBuffer<'a> {
|
||||||
fn drop(&mut self) {
|
fn drop(&mut self) {
|
||||||
if self.should_free {
|
if self.should_free && self.as_bytes().len() != 0 {
|
||||||
let range = MemoryRange::new(self.bytes.as_ptr() as _, self.bytes.len()).unwrap();
|
let range =
|
||||||
|
MemoryRange::new(self.as_bytes().as_ptr() as _, self.as_bytes().len()).unwrap();
|
||||||
unmap_memory(range).expect("Buffer: failed to drop memory");
|
unmap_memory(range).expect("Buffer: failed to drop memory");
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -274,7 +274,7 @@ pub enum SysCall {
|
||||||
CreateProcess(ProcessInit),
|
CreateProcess(ProcessInit),
|
||||||
|
|
||||||
/// Terminate the current process, closing all server connections.
|
/// Terminate the current process, closing all server connections.
|
||||||
TerminateProcess,
|
TerminateProcess(u32),
|
||||||
|
|
||||||
/// Shut down the entire system
|
/// Shut down the entire system
|
||||||
Shutdown,
|
Shutdown,
|
||||||
|
|
@ -318,6 +318,9 @@ pub enum SysCall {
|
||||||
/// in a future reconnection.
|
/// in a future reconnection.
|
||||||
Disconnect(CID),
|
Disconnect(CID),
|
||||||
|
|
||||||
|
/// Waits for a thread to finish, and returns the return value of that thread.
|
||||||
|
JoinThread(TID),
|
||||||
|
|
||||||
/// This syscall does not exist. It captures all possible
|
/// This syscall does not exist. It captures all possible
|
||||||
/// arguments so detailed analysis can be performed.
|
/// arguments so detailed analysis can be performed.
|
||||||
Invalid(usize, usize, usize, usize, usize, usize, usize),
|
Invalid(usize, usize, usize, usize, usize, usize, usize),
|
||||||
|
|
@ -359,6 +362,7 @@ pub enum SysCallNumber {
|
||||||
GetProcessId = 33,
|
GetProcessId = 33,
|
||||||
DestroyServer = 34,
|
DestroyServer = 34,
|
||||||
Disconnect = 35,
|
Disconnect = 35,
|
||||||
|
JoinThread = 36,
|
||||||
Invalid,
|
Invalid,
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -400,6 +404,7 @@ impl SysCallNumber {
|
||||||
33 => GetProcessId,
|
33 => GetProcessId,
|
||||||
34 => DestroyServer,
|
34 => DestroyServer,
|
||||||
35 => Disconnect,
|
35 => Disconnect,
|
||||||
|
36 => JoinThread,
|
||||||
_ => Invalid,
|
_ => Invalid,
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
@ -630,9 +635,9 @@ impl SysCall {
|
||||||
SysCall::CreateProcess(init) => {
|
SysCall::CreateProcess(init) => {
|
||||||
crate::arch::process_to_args(SysCallNumber::CreateProcess as usize, init)
|
crate::arch::process_to_args(SysCallNumber::CreateProcess as usize, init)
|
||||||
}
|
}
|
||||||
SysCall::TerminateProcess => [
|
SysCall::TerminateProcess(exit_code) => [
|
||||||
SysCallNumber::TerminateProcess as usize,
|
SysCallNumber::TerminateProcess as usize,
|
||||||
0,
|
*exit_code as usize,
|
||||||
0,
|
0,
|
||||||
0,
|
0,
|
||||||
0,
|
0,
|
||||||
|
|
@ -721,6 +726,16 @@ impl SysCall {
|
||||||
0,
|
0,
|
||||||
0,
|
0,
|
||||||
],
|
],
|
||||||
|
SysCall::JoinThread(tid) => [
|
||||||
|
SysCallNumber::JoinThread as usize,
|
||||||
|
*tid as usize,
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
0,
|
||||||
|
],
|
||||||
SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7) => [
|
SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7) => [
|
||||||
SysCallNumber::Invalid as usize,
|
SysCallNumber::Invalid as usize,
|
||||||
*a1,
|
*a1,
|
||||||
|
|
@ -810,7 +825,7 @@ impl SysCall {
|
||||||
SysCallNumber::CreateProcess => {
|
SysCallNumber::CreateProcess => {
|
||||||
SysCall::CreateProcess(crate::arch::args_to_process(a1, a2, a3, a4, a5, a6, a7)?)
|
SysCall::CreateProcess(crate::arch::args_to_process(a1, a2, a3, a4, a5, a6, a7)?)
|
||||||
}
|
}
|
||||||
SysCallNumber::TerminateProcess => SysCall::TerminateProcess,
|
SysCallNumber::TerminateProcess => SysCall::TerminateProcess(a1 as u32),
|
||||||
SysCallNumber::Shutdown => SysCall::Shutdown,
|
SysCallNumber::Shutdown => SysCall::Shutdown,
|
||||||
SysCallNumber::TryConnect => {
|
SysCallNumber::TryConnect => {
|
||||||
SysCall::TryConnect(SID::from_u32(a1 as _, a2 as _, a3 as _, a4 as _))
|
SysCall::TryConnect(SID::from_u32(a1 as _, a2 as _, a3 as _, a4 as _))
|
||||||
|
|
@ -882,6 +897,7 @@ impl SysCall {
|
||||||
SysCall::DestroyServer(SID::from_u32(a1 as _, a2 as _, a3 as _, a4 as _))
|
SysCall::DestroyServer(SID::from_u32(a1 as _, a2 as _, a3 as _, a4 as _))
|
||||||
}
|
}
|
||||||
SysCallNumber::Disconnect => SysCall::Disconnect(a1 as _),
|
SysCallNumber::Disconnect => SysCall::Disconnect(a1 as _),
|
||||||
|
SysCallNumber::JoinThread => SysCall::JoinThread(a1 as _),
|
||||||
SysCallNumber::Invalid => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7),
|
SysCallNumber::Invalid => SysCall::Invalid(a1, a2, a3, a4, a5, a6, a7),
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
@ -1338,8 +1354,8 @@ pub fn send_message(connection: CID, message: Message) -> core::result::Result<R
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
||||||
pub fn terminate_process() {
|
pub fn terminate_process(exit_code: u32) -> ! {
|
||||||
rsyscall(SysCall::TerminateProcess).expect("terminate_process returned an error");
|
rsyscall(SysCall::TerminateProcess(exit_code)).expect("terminate_process returned an error");
|
||||||
panic!("process didn't terminate");
|
panic!("process didn't terminate");
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -1481,7 +1497,7 @@ where
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
/// Wait for a thread to finish
|
/// Wait for a thread to finish. This is equivalent to `join_thread`
|
||||||
pub fn wait_thread<T>(joiner: crate::arch::WaitHandle<T>) -> SysCallResult {
|
pub fn wait_thread<T>(joiner: crate::arch::WaitHandle<T>) -> SysCallResult {
|
||||||
crate::arch::wait_thread(joiner)
|
crate::arch::wait_thread(joiner)
|
||||||
}
|
}
|
||||||
|
|
@ -1560,6 +1576,9 @@ pub fn destroy_server(sid: SID) -> core::result::Result<(), Error> {
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Disconnect the specified connection ID and mark it as free. This
|
||||||
|
/// connection ID may be reused by the server in the future, so ensure
|
||||||
|
/// no other threads are using the connection ID before disposing of it.
|
||||||
pub unsafe fn disconnect(cid: CID) -> core::result::Result<(), Error> {
|
pub unsafe fn disconnect(cid: CID) -> core::result::Result<(), Error> {
|
||||||
rsyscall(SysCall::Disconnect(cid)).and_then(|result| {
|
rsyscall(SysCall::Disconnect(cid)).and_then(|result| {
|
||||||
if let Result::Ok = result {
|
if let Result::Ok = result {
|
||||||
|
|
@ -1570,6 +1589,26 @@ pub unsafe fn disconnect(cid: CID) -> core::result::Result<(), Error> {
|
||||||
})
|
})
|
||||||
}
|
}
|
||||||
|
|
||||||
|
/// Block the current thread and wait for the specified thread to
|
||||||
|
/// return. Returns the return value of the thread.
|
||||||
|
///
|
||||||
|
/// # Errors
|
||||||
|
///
|
||||||
|
/// * **ThreadNotAvailable**: The thread could not be found, or was not sleeping.
|
||||||
|
pub fn join_thread(tid: TID) -> core::result::Result<usize, Error> {
|
||||||
|
rsyscall(SysCall::JoinThread(tid)).and_then(|result| {
|
||||||
|
if let Result::Scalar1(val) = result {
|
||||||
|
Ok(val)
|
||||||
|
} else if let Result::Error(Error::ThreadNotAvailable) = result {
|
||||||
|
Err(Error::ThreadNotAvailable)
|
||||||
|
} else {
|
||||||
|
Err(Error::InternalError)
|
||||||
|
}
|
||||||
|
})
|
||||||
|
}
|
||||||
|
|
||||||
|
/// Perform a raw syscall and return the result. This will transform
|
||||||
|
/// `xous::Result::Error(e)` into an `Err(e)`.
|
||||||
pub fn rsyscall(call: SysCall) -> SysCallResult {
|
pub fn rsyscall(call: SysCall) -> SysCallResult {
|
||||||
let mut ret = Result::Ok;
|
let mut ret = Result::Ok;
|
||||||
let args = call.as_args();
|
let args = call.as_args();
|
||||||
|
|
|
||||||
|
|
@ -102,22 +102,31 @@ fn try_main() -> Result<(), DynError> {
|
||||||
let task = env::args().nth(1);
|
let task = env::args().nth(1);
|
||||||
match task.as_deref() {
|
match task.as_deref() {
|
||||||
Some("renode-image") => renode_image(false, &hw_pkgs)?,
|
Some("renode-image") => renode_image(false, &hw_pkgs)?,
|
||||||
Some("renode-test") => renode_image(
|
Some("renode-test") => renode_image(false, &cbtest_pkgs)?,
|
||||||
false,
|
|
||||||
&cbtest_pkgs,
|
|
||||||
)?,
|
|
||||||
Some("renode-image-debug") => renode_image(true, &hw_pkgs)?,
|
Some("renode-image-debug") => renode_image(true, &hw_pkgs)?,
|
||||||
Some("run") => run(false, &hw_pkgs)?,
|
Some("run") => run(false, &hw_pkgs)?,
|
||||||
Some("hw-image") => build_hw_image(false, env::args().nth(2), &hw_pkgs, None)?,
|
Some("hw-image") => build_hw_image(false, env::args().nth(2), &hw_pkgs, None)?,
|
||||||
Some("benchmark") => build_hw_image(false, env::args().nth(2), &benchmark_pkgs, None)?,
|
Some("benchmark") => build_hw_image(false, env::args().nth(2), &benchmark_pkgs, None)?,
|
||||||
Some("minimal") => build_hw_image(false, env::args().nth(2), &minimal_pkgs, None)?,
|
Some("minimal") => build_hw_image(false, env::args().nth(2), &minimal_pkgs, None)?,
|
||||||
Some("cbtest") => build_hw_image(false, env::args().nth(2), &cbtest_pkgs, None)?,
|
Some("cbtest") => build_hw_image(false, env::args().nth(2), &cbtest_pkgs, None)?,
|
||||||
Some("trng-test") => build_hw_image(false, env::args().nth(2), &hw_pkgs,
|
Some("trng-test") => build_hw_image(
|
||||||
Some(&["--features", "ringosctest", "--features", "avalanchetest"]))?,
|
false,
|
||||||
Some("ro-test") => build_hw_image(false, env::args().nth(2), &hw_pkgs,
|
env::args().nth(2),
|
||||||
Some(&["--features", "ringosctest"]))?,
|
&hw_pkgs,
|
||||||
Some("av-test") => build_hw_image(false, env::args().nth(2), &hw_pkgs,
|
Some(&["--features", "ringosctest", "--features", "avalanchetest"]),
|
||||||
Some(&["--features", "avalanchetest"]))?,
|
)?,
|
||||||
|
Some("ro-test") => build_hw_image(
|
||||||
|
false,
|
||||||
|
env::args().nth(2),
|
||||||
|
&hw_pkgs,
|
||||||
|
Some(&["--features", "ringosctest"]),
|
||||||
|
)?,
|
||||||
|
Some("av-test") => build_hw_image(
|
||||||
|
false,
|
||||||
|
env::args().nth(2),
|
||||||
|
&hw_pkgs,
|
||||||
|
Some(&["--features", "avalanchetest"]),
|
||||||
|
)?,
|
||||||
Some("sr-test") => build_hw_image(false, env::args().nth(2), &sr_pkgs, None)?,
|
Some("sr-test") => build_hw_image(false, env::args().nth(2), &sr_pkgs, None)?,
|
||||||
Some("debug") => run(true, &hw_pkgs)?,
|
Some("debug") => run(true, &hw_pkgs)?,
|
||||||
Some("burn-kernel") => update_usb(true, false, false)?,
|
Some("burn-kernel") => update_usb(true, false, false)?,
|
||||||
|
|
@ -209,7 +218,12 @@ fn update_usb(do_kernel: bool, do_loader: bool, do_soc: bool) -> Result<(), DynE
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
fn build_hw_image(debug: bool, svd: Option<String>, packages: &[&str], extra_args: Option<&[&str]>) -> Result<(), DynError> {
|
fn build_hw_image(
|
||||||
|
debug: bool,
|
||||||
|
svd: Option<String>,
|
||||||
|
packages: &[&str],
|
||||||
|
extra_args: Option<&[&str]>,
|
||||||
|
) -> Result<(), DynError> {
|
||||||
let svd_file = match svd {
|
let svd_file = match svd {
|
||||||
Some(s) => s,
|
Some(s) => s,
|
||||||
None => return Err("svd file not specified".into()),
|
None => return Err("svd file not specified".into()),
|
||||||
|
|
@ -233,7 +247,13 @@ fn build_hw_image(debug: bool, svd: Option<String>, packages: &[&str], extra_arg
|
||||||
pkg_path.push(pkg);
|
pkg_path.push(pkg);
|
||||||
init.push(pkg_path);
|
init.push(pkg_path);
|
||||||
}
|
}
|
||||||
let mut loader = build(&["loader"], debug, Some(TARGET), Some("loader".into()), None)?;
|
let mut loader = build(
|
||||||
|
&["loader"],
|
||||||
|
debug,
|
||||||
|
Some(TARGET),
|
||||||
|
Some("loader".into()),
|
||||||
|
None,
|
||||||
|
)?;
|
||||||
loader.push(PathBuf::from("loader"));
|
loader.push(PathBuf::from("loader"));
|
||||||
|
|
||||||
let output_bundle = create_image(&kernel, &init, debug, MemorySpec::SvdFile(svd_file))?;
|
let output_bundle = create_image(&kernel, &init, debug, MemorySpec::SvdFile(svd_file))?;
|
||||||
|
|
@ -256,7 +276,8 @@ fn build_hw_image(debug: bool, svd: Option<String>, packages: &[&str], extra_arg
|
||||||
"--",
|
"--",
|
||||||
loader.as_os_str().to_str().unwrap(),
|
loader.as_os_str().to_str().unwrap(),
|
||||||
loader_bin.as_os_str().to_str().unwrap(),
|
loader_bin.as_os_str().to_str().unwrap(),
|
||||||
]).status()?;
|
])
|
||||||
|
.status()?;
|
||||||
if !status.success() {
|
if !status.success() {
|
||||||
return Err("cargo build failed".into());
|
return Err("cargo build failed".into());
|
||||||
}
|
}
|
||||||
|
|
@ -290,7 +311,13 @@ fn renode_image(debug: bool, packages: &[&str]) -> Result<(), DynError> {
|
||||||
pkg_path.push(pkg);
|
pkg_path.push(pkg);
|
||||||
init.push(pkg_path);
|
init.push(pkg_path);
|
||||||
}
|
}
|
||||||
build(&["loader"], debug, Some(TARGET), Some("loader".into()), None)?;
|
build(
|
||||||
|
&["loader"],
|
||||||
|
debug,
|
||||||
|
Some(TARGET),
|
||||||
|
Some("loader".into()),
|
||||||
|
None,
|
||||||
|
)?;
|
||||||
|
|
||||||
create_image(
|
create_image(
|
||||||
&kernel,
|
&kernel,
|
||||||
|
|
@ -299,6 +326,24 @@ fn renode_image(debug: bool, packages: &[&str]) -> Result<(), DynError> {
|
||||||
MemorySpec::SvdFile("emulation/soc/renode.svd".into()),
|
MemorySpec::SvdFile("emulation/soc/renode.svd".into()),
|
||||||
)?;
|
)?;
|
||||||
|
|
||||||
|
// Regenerate the Platform file
|
||||||
|
let status = Command::new(cargo())
|
||||||
|
.current_dir(project_root())
|
||||||
|
.args(&[
|
||||||
|
"run",
|
||||||
|
"-p",
|
||||||
|
"svd2repl",
|
||||||
|
"--",
|
||||||
|
"-i",
|
||||||
|
"emulation/soc/renode.svd",
|
||||||
|
"-o",
|
||||||
|
"emulation/soc/betrusted-soc.repl",
|
||||||
|
])
|
||||||
|
.status()?;
|
||||||
|
if !status.success() {
|
||||||
|
Err("Unable to regenerate Renode platform file")?;
|
||||||
|
}
|
||||||
|
|
||||||
Ok(())
|
Ok(())
|
||||||
}
|
}
|
||||||
|
|
||||||
|
|
@ -346,7 +391,13 @@ fn run(debug: bool, init: &[&str]) -> Result<(), DynError> {
|
||||||
}
|
}
|
||||||
|
|
||||||
fn build_kernel(debug: bool) -> Result<PathBuf, DynError> {
|
fn build_kernel(debug: bool) -> Result<PathBuf, DynError> {
|
||||||
let mut path = build(&["kernel"], debug, Some(TARGET), Some("kernel".into()), None)?;
|
let mut path = build(
|
||||||
|
&["kernel"],
|
||||||
|
debug,
|
||||||
|
Some(TARGET),
|
||||||
|
Some("kernel".into()),
|
||||||
|
None,
|
||||||
|
)?;
|
||||||
path.push("kernel");
|
path.push("kernel");
|
||||||
Ok(path)
|
Ok(path)
|
||||||
}
|
}
|
||||||
|
|
|
||||||
Loading…
Reference in a new issue