From 062a17b9edb738e8ea7ff15fde2380e95fde8f12 Mon Sep 17 00:00:00 2001 From: occheung Date: Fri, 16 Aug 2024 17:47:41 +0800 Subject: [PATCH] init --- bare_zynq.json | 8 + bare_zynq_master.json | 8 + bare_zynq_sat1.json | 7 + bare_zynq_sat2.json | 7 + flake.lock | 39 +- flake.nix | 9 +- src/Cargo.lock | 222 +++----- src/libboard_artiq/src/drtioaux_proto.rs | 257 ++++++++++ src/runtime/src/comms.rs | 4 +- src/runtime/src/mgmt.rs | 617 ++++++++++++++++++++--- src/runtime/src/rtio_mgt.rs | 364 ++++++++++++- src/satman/Cargo.toml.tpl | 3 + src/satman/src/main.rs | 292 ++++++++++- src/satman/src/mgmt.rs | 307 +++++++++++ src/satman/src/routing.rs | 3 +- 15 files changed, 1898 insertions(+), 249 deletions(-) create mode 100644 bare_zynq.json create mode 100644 bare_zynq_master.json create mode 100644 bare_zynq_sat1.json create mode 100644 bare_zynq_sat2.json create mode 100644 src/satman/src/mgmt.rs diff --git a/bare_zynq.json b/bare_zynq.json new file mode 100644 index 0000000..007a9c7 --- /dev/null +++ b/bare_zynq.json @@ -0,0 +1,8 @@ +{ + "target": "kasli_soc", + "variant": "bare_zynq", + "hw_rev": "v1.1", + "drtio_role": "standalone", + "core_addr": "192.168.1.200", + "peripherals": [] +} diff --git a/bare_zynq_master.json b/bare_zynq_master.json new file mode 100644 index 0000000..c08fab3 --- /dev/null +++ b/bare_zynq_master.json @@ -0,0 +1,8 @@ +{ + "target": "kasli_soc", + "variant": "bare_zynq_master", + "hw_rev": "v1.1", + "drtio_role": "master", + "core_addr": "192.168.1.200", + "peripherals": [] +} diff --git a/bare_zynq_sat1.json b/bare_zynq_sat1.json new file mode 100644 index 0000000..8292102 --- /dev/null +++ b/bare_zynq_sat1.json @@ -0,0 +1,7 @@ +{ + "target": "kasli_soc", + "variant": "bare_zynq_sat1", + "hw_rev": "v1.1", + "drtio_role": "satellite", + "peripherals": [] +} diff --git a/bare_zynq_sat2.json b/bare_zynq_sat2.json new file mode 100644 index 0000000..b5d9cd9 --- /dev/null +++ b/bare_zynq_sat2.json @@ -0,0 +1,7 @@ +{ + "target": "kasli_soc", + "variant": "bare_zynq_sat2", + "hw_rev": "v1.1", + "drtio_role": "satellite", + "peripherals": [] +} diff --git a/flake.lock b/flake.lock index a2c79f0..9617cfe 100644 --- a/flake.lock +++ b/flake.lock @@ -11,17 +11,16 @@ "src-pythonparser": "src-pythonparser" }, "locked": { - "lastModified": 1722417433, - "narHash": "sha256-QEbcVdL1sUQEbMCvCUvPM8DKqwOth3gJpdiLTf4hPN8=", - "ref": "refs/heads/master", - "rev": "0623480c82c28d57e14dc4f363374758a52284d3", - "revCount": 8952, + "dirtyRev": "378d962edb37a7c2a94e963251822246be009b0e-dirty", + "dirtyShortRev": "378d962ed-dirty", + "lastModified": 1721962540, + "narHash": "sha256-BJG4l1V7kJXBWgBkfYKq8xW8rCfc7fnjCSp5xMiGvsU=", "type": "git", - "url": "https://github.com/m-labs/artiq.git" + "url": "file:///home/occheung/artiq" }, "original": { "type": "git", - "url": "https://github.com/m-labs/artiq.git" + "url": "file:///home/occheung/artiq" } }, "artiq-comtools": { @@ -37,11 +36,11 @@ ] }, "locked": { - "lastModified": 1720768567, - "narHash": "sha256-3VoK7o5MtHtbHLrc6Pv+eQWFtaz5Gd/YWyV5TD3c5Ss=", + "lastModified": 1717637438, + "narHash": "sha256-BXFidNm3Em8iChPGu1L0s2bY+f2yQ0VVid4MuOoTehw=", "owner": "m-labs", "repo": "artiq-comtools", - "rev": "f93570d8f2ed5a3cfb3e1c16ab00f2540551e994", + "rev": "78d27026efe76a13f7b4698a554f55811369ec4d", "type": "github" }, "original": { @@ -102,16 +101,16 @@ }, "nixpkgs": { "locked": { - "lastModified": 1721924956, - "narHash": "sha256-Sb1jlyRO+N8jBXEX9Pg9Z1Qb8Bw9QyOgLDNMEpmjZ2M=", + "lastModified": 1720386169, + "narHash": "sha256-NGKVY4PjzwAa4upkGtAMz1npHGoRzWotlSnVlqI40mo=", "owner": "NixOS", "repo": "nixpkgs", - "rev": "5ad6a14c6bf098e98800b091668718c336effc95", + "rev": "194846768975b7ad2c4988bdb82572c00222c0d7", "type": "github" }, "original": { "owner": "NixOS", - "ref": "nixos-unstable", + "ref": "nixos-24.05", "repo": "nixpkgs", "type": "github" } @@ -131,11 +130,11 @@ ] }, "locked": { - "lastModified": 1722046723, - "narHash": "sha256-G7/gHz8ORRvHd1/RIURrdcswKRPe9K0FsIYR4v5jSWo=", + "lastModified": 1720491570, + "narHash": "sha256-PHS2BcQ9kxBpu9GKlDg3uAlrX/ahQOoAiVmwGl6BjD4=", "owner": "oxalica", "repo": "rust-overlay", - "rev": "56baac5e6b2743d4730e664ea64f6d8a2aad0fbb", + "rev": "b970af40fdc4bd80fd764796c5f97c15e2b564eb", "type": "github" }, "original": { @@ -168,11 +167,11 @@ "src-migen": { "flake": false, "locked": { - "lastModified": 1721561053, - "narHash": "sha256-z3LRhNmKZrjr6rFD0yxtccSa/SWvFIYmb+G/D5d2Jd8=", + "lastModified": 1720332047, + "narHash": "sha256-FdYVEHVtXHrzPhBqpXOTo9uHQAtuCsDPmAPY8JrfHOY=", "owner": "m-labs", "repo": "migen", - "rev": "9279e8623f8433bc4f23ac51e5e2331bfe544417", + "rev": "60739a161e64630ce7ba62d1a5bac1252b66c3b9", "type": "github" }, "original": { diff --git a/flake.nix b/flake.nix index ff055e9..7aace75 100644 --- a/flake.nix +++ b/flake.nix @@ -1,7 +1,8 @@ { description = "ARTIQ port to the Zynq-7000 platform"; - inputs.artiq.url = git+https://github.com/m-labs/artiq.git; + # inputs.artiq.url = git+https://github.com/m-labs/artiq.git; + inputs.artiq.url = git+file:///home/occheung/artiq; inputs.mozilla-overlay = { url = github:mozilla/nixpkgs-mozilla; flake = false; }; inputs.zynq-rs.url = git+https://git.m-labs.hk/m-labs/zynq-rs; inputs.zynq-rs.inputs.nixpkgs.follows = "artiq/nixpkgs"; @@ -109,7 +110,7 @@ fsblTargets = ["zc702" "zc706" "zed"]; sat_variants = [ # kasli-soc satellite variants - "satellite" + "satellite" "bare_zynq_sat1" "bare_zynq_sat2" # zc706 satellite variants "nist_clock_satellite" "nist_qc2_satellite" "acpki_nist_clock_satellite" "acpki_nist_qc2_satellite" "nist_clock_satellite_100mhz" "nist_qc2_satellite_100mhz" "acpki_nist_clock_satellite_100mhz" "acpki_nist_qc2_satellite_100mhz" @@ -364,6 +365,10 @@ (board-package-set { target = "zc706"; variant = "acpki_nist_qc2_satellite_100mhz"; }) // (board-package-set { target = "kasli_soc"; variant = "demo"; json = ./demo.json; }) // (board-package-set { target = "kasli_soc"; variant = "master"; json = ./kasli-soc-master.json; }) // + (board-package-set { target = "kasli_soc"; variant = "bare_zynq"; json = ./bare_zynq.json; }) // + (board-package-set { target = "kasli_soc"; variant = "bare_zynq_master"; json = ./bare_zynq_master.json; }) // + (board-package-set { target = "kasli_soc"; variant = "bare_zynq_sat1"; json = ./bare_zynq_sat1.json; }) // + (board-package-set { target = "kasli_soc"; variant = "bare_zynq_sat2"; json = ./bare_zynq_sat2.json; }) // (board-package-set { target = "kasli_soc"; variant = "satellite"; json = ./kasli-soc-satellite.json; }); hydraJobs = packages.x86_64-linux // { inherit zc706-hitl-tests; inherit gateware-sim; inherit fmt-check; }; diff --git a/src/Cargo.lock b/src/Cargo.lock index c14d523..cbcb2d3 100644 --- a/src/Cargo.lock +++ b/src/Cargo.lock @@ -2,6 +2,15 @@ # It is not intended for manual editing. version = 3 +[[package]] +name = "approx" +version = "0.5.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6" +dependencies = [ + "num-traits", +] + [[package]] name = "arrayvec" version = "0.7.4" @@ -246,10 +255,10 @@ dependencies = [ "libsupport_zynq", "log", "log_buffer", + "nalgebra", "nb 0.1.3", "unwind", "vcell", - "nalgebra", "void", ] @@ -383,6 +392,19 @@ version = "0.7.2" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "c75de51135344a4f8ed3cfe2720dc27736f7711989703a0b43aadf3753c55577" +[[package]] +name = "nalgebra" +version = "0.32.6" +source = "git+https://git.m-labs.hk/M-labs/nalgebra?rev=dd00f9b#dd00f9b46046e0b931d1b470166db02fd29591be" +dependencies = [ + "approx", + "num-complex", + "num-rational", + "num-traits", + "simba", + "typenum", +] + [[package]] name = "nb" version = "0.1.3" @@ -398,6 +420,15 @@ version = "1.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "546c37ac5d9e56f55e73b677106873d9d9f5190605e41a856503623648488cae" +[[package]] +name = "num-complex" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "26873667bbbb7c5182d4a37c1add32cdf09f841af72da53318fdb81543c15085" +dependencies = [ + "num-traits", +] + [[package]] name = "num-derive" version = "0.3.3" @@ -409,6 +440,26 @@ dependencies = [ "syn", ] +[[package]] +name = "num-integer" +version = "0.1.46" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" +dependencies = [ + "num-traits", +] + +[[package]] +name = "num-rational" +version = "0.4.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "d41702bd167c2df5520b384281bc111a4b5efcf7fbc4c9c222c815b07e0a6a6a" +dependencies = [ + "autocfg", + "num-integer", + "num-traits", +] + [[package]] name = "num-traits" version = "0.2.15" @@ -416,8 +467,15 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd" dependencies = [ "autocfg", + "libm", ] +[[package]] +name = "paste" +version = "1.0.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" + [[package]] name = "pin-project-lite" version = "0.2.9" @@ -501,6 +559,7 @@ name = "satman" version = "0.0.0" dependencies = [ "build_zynq", + "byteorder", "core_io", "cslice", "embedded-hal", @@ -515,6 +574,8 @@ dependencies = [ "libregister", "libsupport_zynq", "log", + "num-derive", + "num-traits", "unwind", ] @@ -524,6 +585,18 @@ version = "0.1.20" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "d4f410fedcf71af0345d7607d246e7ad15faaadd49d240ee3b24e5dc21a820ac" +[[package]] +name = "simba" +version = "0.8.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "50582927ed6f77e4ac020c057f37a268fc6aebc29225050365aacbb9deeeddc4" +dependencies = [ + "approx", + "num-complex", + "num-traits", + "paste", +] + [[package]] name = "smoltcp" version = "0.7.5" @@ -556,6 +629,12 @@ dependencies = [ "log", ] +[[package]] +name = "typenum" +version = "1.17.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" + [[package]] name = "unicode-ident" version = "1.0.5" @@ -572,147 +651,6 @@ dependencies = [ "libc", ] -[[package]] -name = "nalgebra" -version = "0.32.6" -source = "git+https://git.m-labs.hk/M-labs/nalgebra?rev=dd00f9b#dd00f9b46046e0b931d1b470166db02fd29591be" -dependencies = [ - "approx", - "matrixmultiply", - "nalgebra-macros", - "num-complex", - "num-rational", - "num-traits", - "simba", - "typenum", -] - -[[package]] -name = "approx" -version = "0.5.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cab112f0a86d568ea0e627cc1d6be74a1e9cd55214684db5561995f6dad897c6" -dependencies = [ - "num-traits", -] - -[[package]] -name = "matrixmultiply" -version = "0.3.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7574c1cf36da4798ab73da5b215bbf444f50718207754cb522201d78d1cd0ff2" -dependencies = [ - "autocfg", - "rawpointer", -] - -[[package]] -name = "nalgebra-macros" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "91761aed67d03ad966ef783ae962ef9bbaca728d2dd7ceb7939ec110fffad998" -dependencies = [ - "proc-macro2", - "quote", - "syn", -] - -[[package]] -name = "num-complex" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "26873667bbbb7c5182d4a37c1add32cdf09f841af72da53318fdb81543c15085" -dependencies = [ - "num-traits", -] - -[[package]] -name = "num-rational" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d41702bd167c2df5520b384281bc111a4b5efcf7fbc4c9c222c815b07e0a6a6a" -dependencies = [ - "num-bigint", - "num-integer", - "num-traits", -] - -[[package]] -name = "simba" -version = "0.8.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "50582927ed6f77e4ac020c057f37a268fc6aebc29225050365aacbb9deeeddc4" -dependencies = [ - "approx", - "num-complex", - "num-traits", - "paste", - "wide", -] - -[[package]] -name = "typenum" -version = "1.17.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825" - -[[package]] -name = "rawpointer" -version = "0.2.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "60a357793950651c4ed0f3f52338f53b2f809f32d83a07f72909fa13e4c6c1e3" - -[[package]] -name = "num-bigint" -version = "0.4.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "4e0d047c1062aa51e256408c560894e5251f08925980e53cf1aa5bd00eec6512" -dependencies = [ - "num-integer", - "num-traits", -] - -[[package]] -name = "num-integer" -version = "0.1.46" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f" -dependencies = [ - "num-traits", -] - -[[package]] -name = "paste" -version = "1.0.15" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a" - -[[package]] -name = "wide" -version = "0.7.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "cd89cf484471f953ee84f07c0dff0ea20e9ddf976f03cabdf5dda48b221f22e7" -features = ["no_std"] -dependencies = [ - "bytemuck", - "safe_arch", -] - -[[package]] -name = "bytemuck" -version = "1.16.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b236fc92302c97ed75b38da1f4917b5cdda4984745740f153a5d3059e48d725e" - -[[package]] -name = "safe_arch" -version = "0.6.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "794821e4ccb0d9f979512f9c1973480123f9bd62a90d74ab0f9426fcf8f4a529" -dependencies = [ - "bytemuck", -] - [[package]] name = "vcell" version = "0.1.3" diff --git a/src/libboard_artiq/src/drtioaux_proto.rs b/src/libboard_artiq/src/drtioaux_proto.rs index 6232260..4bb9520 100644 --- a/src/libboard_artiq/src/drtioaux_proto.rs +++ b/src/libboard_artiq/src/drtioaux_proto.rs @@ -8,6 +8,11 @@ const MAX_PACKET: usize = 1024; pub const SAT_PAYLOAD_MAX_SIZE: usize = /*max size*/MAX_PACKET - /*CRC*/4 - /*packet ID*/1 - /*last*/1 - /*length*/2; // used by DDMA, subkernel program data (need to provide extra ID and destination) pub const MASTER_PAYLOAD_MAX_SIZE: usize = SAT_PAYLOAD_MAX_SIZE - /*source*/1 - /*destination*/1 - /*ID*/4; +// used by core device management, core_mgmt packet +// FIXME: packet size +pub const CORE_MGMT_PAYLOAD_MAX_SIZE: usize = MASTER_PAYLOAD_MAX_SIZE; +// pub const CORE_MGMT_CONFIG_MAX_SIZE: usize = /*max size*/MAX_PACKET - /*destination*/1 - /*last*/1 - /*length*/2; +pub const CORE_MGMT_CONFIG_MAX_SIZE: usize = MASTER_PAYLOAD_MAX_SIZE; #[derive(Debug)] pub enum Error { @@ -287,6 +292,72 @@ pub enum Packet { SubkernelMessageAck { destination: u8, }, + + CoreMgmtGetLogRequest { + destination: u8, + }, + CoreMgmtGetLogReply { + last: bool, + length: u16, + data: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE], + }, + CoreMgmtClearLogRequest { + destination: u8, + }, + CoreMgmtPullLogRequest { + destination: u8, + }, + CoreMgmtPullLogReply { + destination: u8, + last: bool, + length: u16, + data: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE], + }, + CoreMgmtSetLogLevelRequest { + destination: u8, + log_level: u8, + }, + CoreMgmtSetUartLogLevelRequest { + destination: u8, + log_level: u8, + }, + CoreMgmtConfigReadRequest { + destination: u8, + length: u16, + key: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE], + }, + CoreMgmtConfigReadContinue { + destination: u8, + }, + CoreMgmtConfigReadReply { + succeeded: bool, + length: u16, + last: bool, + value: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE], + }, + CoreMgmtConfigWriteRequest { + destination: u8, + length: u16, + last: bool, + data: [u8; CORE_MGMT_CONFIG_MAX_SIZE], + }, + CoreMgmtConfigRemoveRequest { + destination: u8, + length: u16, + key: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE], + }, + CoreMgmtConfigEraseRequest { + destination: u8, + }, + CoreMgmtRebootRequest { + destination: u8, + }, + CoreMgmtAllocatorDebugRequest { + destination: u8, + }, + CoreMgmtAck { + succeeded: bool + }, } impl Packet { @@ -563,6 +634,111 @@ impl Packet { destination: reader.read_u8()?, }, + 0xd0 => Packet::CoreMgmtGetLogRequest { + destination: reader.read_u8()?, + }, + 0xd1 => { + let last = reader.read_bool()?; + let length = reader.read_u16()?; + let mut data: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE]; + reader.read_exact(&mut data[0..length as usize])?; + Packet::CoreMgmtGetLogReply { + last: last, + length: length, + data: data, + } + }, + 0xd2 => Packet::CoreMgmtClearLogRequest { + destination: reader.read_u8()?, + }, + 0xd3 => Packet::CoreMgmtPullLogRequest { + destination: reader.read_u8()?, + }, + 0xd4 => { + let destination = reader.read_u8()?; + let last = reader.read_bool()?; + let length = reader.read_u16()?; + let mut data: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE]; + reader.read_exact(&mut data[0..length as usize])?; + Packet::CoreMgmtPullLogReply { + destination: destination, + last: last, + length: length, + data: data, + } + }, + 0xd5 => Packet::CoreMgmtSetLogLevelRequest { + destination: reader.read_u8()?, + log_level: reader.read_u8()?, + }, + 0xd6 => Packet::CoreMgmtSetUartLogLevelRequest { + destination: reader.read_u8()?, + log_level: reader.read_u8()?, + }, + 0xd7 => { + let destination = reader.read_u8()?; + let length = reader.read_u16()?; + let mut key: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE]; + reader.read_exact(&mut key[0..length as usize])?; + Packet::CoreMgmtConfigReadRequest { + destination: destination, + length: length, + key: key, + } + }, + 0xd8 => { + let succeeded = reader.read_bool()?; + let length = reader.read_u16()?; + let last = reader.read_bool()?; + let mut value: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE]; + reader.read_exact(&mut value[0..length as usize])?; + Packet::CoreMgmtConfigReadReply { + succeeded: succeeded, + length: length, + last: last, + value: value, + } + }, + 0xd9 => { + let destination = reader.read_u8()?; + let length = reader.read_u16()?; + let last = reader.read_bool()?; + let mut data: [u8; CORE_MGMT_CONFIG_MAX_SIZE] = [0; CORE_MGMT_CONFIG_MAX_SIZE]; + reader.read_exact(&mut data[0..length as usize])?; + Packet::CoreMgmtConfigWriteRequest { + destination: destination, + length: length, + last: last, + data: data, + } + }, + 0xda => { + let destination = reader.read_u8()?; + let length = reader.read_u16()?; + let mut key: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE]; + reader.read_exact(&mut key[0..length as usize])?; + Packet::CoreMgmtConfigRemoveRequest { + destination: destination, + length: length, + key: key, + } + }, + 0xdb => Packet::CoreMgmtConfigEraseRequest { + destination: reader.read_u8()?, + }, + 0xdc => Packet::CoreMgmtRebootRequest { + destination: reader.read_u8()?, + }, + 0xdd => Packet::CoreMgmtAllocatorDebugRequest { + destination: reader.read_u8()?, + }, + 0xde => Packet::CoreMgmtAck { + succeeded: reader.read_bool()?, + }, + 0xdf => Packet::CoreMgmtConfigReadContinue { + destination: reader.read_u8()?, + }, + ty => return Err(Error::UnknownPacket(ty)), }) } @@ -938,6 +1114,87 @@ impl Packet { writer.write_u8(0xcc)?; writer.write_u8(destination)?; } + Packet::CoreMgmtGetLogRequest { destination } => { + writer.write_u8(0xd0)?; + writer.write_u8(destination)?; + } + Packet::CoreMgmtGetLogReply { last, length, data } => { + writer.write_u8(0xd1)?; + writer.write_bool(last)?; + writer.write_u16(length)?; + writer.write_all(&data[0..length as usize])?; + } + Packet::CoreMgmtClearLogRequest { destination } => { + writer.write_u8(0xd2)?; + writer.write_u8(destination)?; + } + Packet::CoreMgmtPullLogRequest { destination } => { + writer.write_u8(0xd3)?; + writer.write_u8(destination)?; + } + Packet::CoreMgmtPullLogReply { destination, last, length, data } => { + writer.write_u8(0xd4)?; + writer.write_u8(destination)?; + writer.write_bool(last)?; + writer.write_u16(length)?; + writer.write_all(&data[0..length as usize])?; + } + Packet::CoreMgmtSetLogLevelRequest { destination, log_level } => { + writer.write_u8(0xd5)?; + writer.write_u8(destination)?; + writer.write_u8(log_level)?; + } + Packet::CoreMgmtSetUartLogLevelRequest { destination, log_level } => { + writer.write_u8(0xd6)?; + writer.write_u8(destination)?; + writer.write_u8(log_level)?; + } + Packet::CoreMgmtConfigReadRequest { destination, length, key } => { + writer.write_u8(0xd7)?; + writer.write_u8(destination)?; + writer.write_u16(length)?; + writer.write_all(&key[0..length as usize])?; + } + Packet::CoreMgmtConfigReadReply { succeeded, length, last, value } => { + writer.write_u8(0xd8)?; + writer.write_bool(succeeded)?; + writer.write_u16(length)?; + writer.write_bool(last)?; + writer.write_all(&value[0..length as usize])?; + } + Packet::CoreMgmtConfigWriteRequest { destination, length, last, data } => { + writer.write_u8(0xd9)?; + writer.write_u8(destination)?; + writer.write_u16(length)?; + writer.write_bool(last)?; + writer.write_all(&data[0..length as usize])?; + } + Packet::CoreMgmtConfigRemoveRequest { destination, length, key } => { + writer.write_u8(0xda)?; + writer.write_u8(destination)?; + writer.write_u16(length)?; + writer.write_all(&key[0..length as usize])?; + } + Packet::CoreMgmtConfigEraseRequest { destination } => { + writer.write_u8(0xdb)?; + writer.write_u8(destination)?; + } + Packet::CoreMgmtRebootRequest { destination } => { + writer.write_u8(0xdc)?; + writer.write_u8(destination)?; + } + Packet::CoreMgmtAllocatorDebugRequest { destination } => { + writer.write_u8(0xdd)?; + writer.write_u8(destination)?; + } + Packet::CoreMgmtAck { succeeded } => { + writer.write_u8(0xde)?; + writer.write_bool(succeeded)?; + } + Packet::CoreMgmtConfigReadContinue { destination } => { + writer.write_u8(0xdf)?; + writer.write_u8(destination)?; + } } Ok(()) } diff --git a/src/runtime/src/comms.rs b/src/runtime/src/comms.rs index e6abfb4..f59adcc 100644 --- a/src/runtime/src/comms.rs +++ b/src/runtime/src/comms.rs @@ -783,7 +783,7 @@ pub fn main(timer: GlobalTimer, cfg: Config) { } } - mgmt::start(cfg); + mgmt::start(cfg, &aux_mutex, &drtio_routing_table, timer); task::spawn(async move { let connection = Rc::new(Semaphore::new(1, 1)); @@ -886,7 +886,7 @@ pub fn soft_panic_main(timer: GlobalTimer, cfg: Config) -> ! { Sockets::init(32); - mgmt::start(cfg); + // mgmt::start(cfg); // getting eth settings disables the LED as it resets GPIO // need to re-enable it here diff --git a/src/runtime/src/mgmt.rs b/src/runtime/src/mgmt.rs index bfeed9b..11ed426 100644 --- a/src/runtime/src/mgmt.rs +++ b/src/runtime/src/mgmt.rs @@ -3,14 +3,16 @@ use core::cell::RefCell; use futures::{future::poll_fn, task::Poll}; use libasync::{smoltcp::TcpStream, task}; -use libboard_artiq::logger::{BufferLogger, LogBufferRef}; -use libboard_zynq::{slcr, smoltcp}; +use libboard_artiq::{logger::{BufferLogger, LogBufferRef}, drtio_routing, drtio_routing::RoutingTable}; +use libboard_zynq::{slcr, smoltcp, timer::GlobalTimer}; use libconfig::Config; +use libcortex_a9::mutex::Mutex; use log::{self, debug, error, info, warn, LevelFilter}; use num_derive::FromPrimitive; use num_traits::FromPrimitive; use crate::proto_async::*; +use crate::rtio_mgt::*; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum Error { @@ -18,6 +20,11 @@ pub enum Error { UnknownLogLevel(u8), UnexpectedPattern, UnrecognizedPacket, + ReadConfigFail, + WriteConfigFail, + RemoveConfigFail, + #[cfg(has_drtio)] + DrtioError(drtio::Error), } type Result = core::result::Result; @@ -29,6 +36,11 @@ impl core::fmt::Display for Error { &Error::UnknownLogLevel(lvl) => write!(f, "unknown log level {}", lvl), &Error::UnexpectedPattern => write!(f, "unexpected pattern"), &Error::UnrecognizedPacket => write!(f, "unrecognized packet"), + &Error::ReadConfigFail => write!(f, "error reading config"), + &Error::WriteConfigFail => write!(f, "error writing config"), + &Error::RemoveConfigFail => write!(f, "error removing config"), + #[cfg(has_drtio)] + &Error::DrtioError(error) => write!(f, "drtio error: {}", error), } } } @@ -39,6 +51,13 @@ impl From for Error { } } +#[cfg(has_drtio)] +impl From for Error { + fn from(error: drtio::Error) -> Self { + Error::DrtioError(error) + } +} + #[derive(Debug, FromPrimitive)] pub enum Request { GetLog = 1, @@ -62,18 +81,24 @@ pub enum Reply { ConfigData = 7, } -async fn read_log_level_filter(stream: &mut TcpStream) -> Result { - Ok(match read_i8(stream).await? { +pub fn byte_to_level_filter(level_byte: u8) -> Result { + Ok(match level_byte { 0 => log::LevelFilter::Off, 1 => log::LevelFilter::Error, 2 => log::LevelFilter::Warn, 3 => log::LevelFilter::Info, 4 => log::LevelFilter::Debug, 5 => log::LevelFilter::Trace, - lv => return Err(Error::UnknownLogLevel(lv as u8)), + lv => return Err(Error::UnknownLogLevel(lv)), }) } +async fn read_log_level_filter(stream: &mut TcpStream) -> Result { + let level_byte = read_i8(stream).await? as u8; + + byte_to_level_filter(level_byte) +} + async fn get_logger_buffer_pred(f: F) -> LogBufferRef<'static> where F: Fn(&LogBufferRef) -> bool { poll_fn(|ctx| { @@ -111,10 +136,429 @@ async fn read_key(stream: &mut TcpStream) -> Result { Ok(String::from_utf8(buffer).unwrap()) } -async fn handle_connection(stream: &mut TcpStream, pull_id: Rc>, cfg: Rc) -> Result<()> { +mod local_coremgmt { + use super::*; + + pub async fn get_log() -> Result> { + let buffer = get_logger_buffer().await.extract().as_bytes().to_vec(); + Ok(buffer) + } + + pub async fn clear_log() -> Result<()> { + let mut buffer = get_logger_buffer().await; + buffer.clear(); + Ok(()) + } + + pub async fn pull_log<'a>(stream: &'a mut TcpStream, pull_id: Rc>) -> Result<()> { + let id = { + let mut guard = pull_id.borrow_mut(); + *guard += 1; + *guard + }; + loop { + let mut buffer = get_logger_buffer_pred(|b| !b.is_empty()).await; + if id != *pull_id.borrow() { + // another connection attempts to pull the log... + // abort this connection... + break; + } + let bytes = buffer.extract().as_bytes().to_vec(); + buffer.clear(); + core::mem::drop(buffer); + write_chunk(stream, &bytes).await?; + if log::max_level() == LevelFilter::Trace { + // temporarily discard all trace level log + let logger = unsafe { BufferLogger::get_logger().as_mut().unwrap() }; + logger.set_buffer_log_level(LevelFilter::Debug); + stream.flush().await?; + logger.set_buffer_log_level(LevelFilter::Trace); + } + } + Ok(()) + } + + pub async fn set_log_filter(lvl: LevelFilter) -> Result<()> { + info!("Changing log level to {}", lvl); + log::set_max_level(lvl); + Ok(()) + } + + pub async fn set_uart_log_filter(lvl: LevelFilter) -> Result<()> { + info!("Changing UART log level to {}", lvl); + unsafe { + BufferLogger::get_logger().as_ref().unwrap().set_uart_log_level(lvl); + } + Ok(()) + } + + pub async fn config_read(cfg: &Rc, key: &String) -> Result>{ + debug!("read key: {}", key); + cfg.read(&key).map_err(|_| Error::ReadConfigFail) + } + + pub async fn config_write<'a>(cfg: &Rc, key: &'a String, value: Vec) -> Result<()> { + cfg.write(&key, value).map_err(|_| Error::WriteConfigFail) + } + + pub async fn config_remove<'a>(cfg: &Rc, key: &'a String) -> Result<()> { + debug!("erase key: {}", key); + let value = cfg.remove(&key); + if value.is_ok() { + debug!("erase success"); + Ok(()) + } else { + warn!("erase failed"); + Err(Error::RemoveConfigFail) + } + } +} + +#[cfg(has_drtio)] +mod remote_coremgmt { + use crate::rtio_mgt::drtio; + use super::*; + use libboard_artiq::drtioaux_proto::{Packet, CORE_MGMT_PAYLOAD_MAX_SIZE}; + use io::{Cursor, ProtoWrite}; + + pub async fn get_log( + aux_mutex: &Rc>, + routing_table: &drtio_routing::RoutingTable, + timer: GlobalTimer, + linkno: u8, + destination: u8, + ) -> Result> { + let mut buffer = Vec::new(); + loop { + match drtio::aux_transact( + aux_mutex, + linkno, + routing_table, + &Packet::CoreMgmtGetLogRequest { + destination + }, + timer, + ).await? { + Packet::CoreMgmtGetLogReply { + last, length, data, + } => { + buffer.extend(&data[..length as usize]); + if last { + return Ok(buffer); + } + }, + _ => return Err(drtio::Error::UnexpectedReply.into()), + } + } + } + + pub async fn clear_log( + aux_mutex: &Rc>, + routing_table: &drtio_routing::RoutingTable, + timer: GlobalTimer, + linkno: u8, + destination: u8, + ) -> Result<()> { + let reply = drtio::aux_transact( + aux_mutex, + linkno, + routing_table, + &Packet::CoreMgmtClearLogRequest { + destination + }, + timer, + ).await?; + + match reply { + Packet::CoreMgmtAck { + succeeded: true + } => Ok(()), + _ => Err(drtio::Error::UnexpectedReply.into()), + } + } + + pub async fn pull_log( + aux_mutex: &Rc>, + routing_table: &drtio_routing::RoutingTable, + timer: GlobalTimer, + linkno: u8, + destination: u8, + stream: &mut TcpStream, + ) -> Result<()> { + todo!() + } + + pub async fn set_log_filter( + aux_mutex: &Rc>, + routing_table: &drtio_routing::RoutingTable, + timer: GlobalTimer, + linkno: u8, + destination: u8, + level: LevelFilter, + ) -> Result<()> { + let reply = drtio::aux_transact( + aux_mutex, + linkno, + routing_table, + &Packet::CoreMgmtSetLogLevelRequest { + destination, + log_level: level as u8, + }, + timer, + ).await?; + + match reply { + Packet::CoreMgmtAck { + succeeded: true + } => Ok(()), + Packet::CoreMgmtAck { + succeeded: false + } => { + error!("satellite misinterpret log level, corrupted packet?"); + Err(drtio::Error::AuxError.into()) + }, + _ => Err(drtio::Error::UnexpectedReply.into()), + } + } + + pub async fn set_uart_log_filter( + aux_mutex: &Rc>, + routing_table: &drtio_routing::RoutingTable, + timer: GlobalTimer, + linkno: u8, + destination: u8, + level: LevelFilter, + ) -> Result<()> { + let reply = drtio::aux_transact( + aux_mutex, + linkno, + routing_table, + &Packet::CoreMgmtSetUartLogLevelRequest { + destination, + log_level: level as u8, + }, + timer, + ).await?; + + match reply { + Packet::CoreMgmtAck { + succeeded: true + } => Ok(()), + Packet::CoreMgmtAck { + succeeded: false + } => { + error!("satellite misinterpret log level, corrupted packet?"); + Err(drtio::Error::AuxError.into()) + }, + _ => Err(drtio::Error::UnexpectedReply.into()), + } + } + + pub async fn config_read( + aux_mutex: &Rc>, + routing_table: &drtio_routing::RoutingTable, + timer: GlobalTimer, + linkno: u8, + destination: u8, + _cfg: &Rc, + key: &String, + ) -> Result> { + let mut config_key: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE]; + let len = key.len(); + if len > CORE_MGMT_PAYLOAD_MAX_SIZE { + error!("key is too long"); + return Err(Error::ReadConfigFail); + } + config_key[..len].clone_from_slice(key.as_bytes()); + + let mut reply = drtio::aux_transact( + aux_mutex, + linkno, + routing_table, + &Packet::CoreMgmtConfigReadRequest { + destination: destination, + length: len as u16, + key: config_key, + }, + timer, + ).await?; + + let mut buffer = Vec::new(); + loop { + match reply { + Packet::CoreMgmtConfigReadReply { + succeeded: true, + length, + last, + value, + } => { + buffer.extend(&value[..length as usize]); + + if last { + return Ok(buffer); + } + + reply = drtio::aux_transact( + aux_mutex, + linkno, + routing_table, + &Packet::CoreMgmtConfigReadContinue { + destination: destination, + }, + timer, + ).await?; + } + + Packet::CoreMgmtConfigReadReply { + succeeded:false, .. + } => { + return Err(Error::ReadConfigFail); + } + + _ => return Err(drtio::Error::UnexpectedReply.into()), + } + } + } + + pub async fn config_write( + aux_mutex: &Rc>, + routing_table: &drtio_routing::RoutingTable, + timer: GlobalTimer, + linkno: u8, + destination: u8, + _cfg: &Rc, + key: &String, + value: Vec, + ) -> Result<()> { + let mut message = Cursor::new(Vec::with_capacity(key.len() + value.len() + 4 * 2)); + message.write_string(key).unwrap(); + message.write_bytes(&value).unwrap(); + + drtio::partition_data( + linkno, + aux_mutex, + routing_table, + timer, + message.get_ref(), + |slice, status, len: usize| Packet::CoreMgmtConfigWriteRequest { + destination: destination, + length: len as u16, + last: status.is_last(), + data: *slice + }, + |reply| match reply { + Packet::CoreMgmtAck { succeeded: true } => { + Ok(()) + }, + Packet::CoreMgmtAck { succeeded: false } => { + error!("config write failed"); + Err(Error::WriteConfigFail) + }, + _ => { + error!("received unknown packet"); + Err(drtio::Error::UnexpectedReply.into()) + }, + } + ).await + } + + pub async fn config_remove( + aux_mutex: &Rc>, + routing_table: &drtio_routing::RoutingTable, + timer: GlobalTimer, + linkno: u8, + destination: u8, + _cfg: &Rc, + key: &String, + ) -> Result<()> { + let mut config_key: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE]; + let len = key.len(); + if len > CORE_MGMT_PAYLOAD_MAX_SIZE { + error!("key is too long"); + return Err(Error::RemoveConfigFail); + } + config_key[..len].clone_from_slice(key.as_bytes()); + + let reply = drtio::aux_transact( + aux_mutex, + linkno, + routing_table, + &Packet::CoreMgmtConfigRemoveRequest { + destination: destination, + length: len as u16, + key: config_key, + }, + timer, + ).await?; + + match reply { + Packet::CoreMgmtAck { succeeded: true } => Ok(()), + Packet::CoreMgmtAck { succeeded: false } => Err(Error::RemoveConfigFail), + _ => Err(drtio::Error::UnexpectedReply.into()), + } + } + + pub async fn reboot( + aux_mutex: &Rc>, + routing_table: &drtio_routing::RoutingTable, + timer: GlobalTimer, + linkno: u8, + destination: u8, + ) -> Result<()> { + info!("initited reboot request to satellite destination {}", destination); + let reply = drtio::aux_transact( + aux_mutex, + linkno, + routing_table, + &Packet::CoreMgmtRebootRequest { + destination: destination, + }, + timer, + ).await?; + + match reply { + Packet::CoreMgmtAck { succeeded: true } => Ok(()), + _ => { + error!("received unknown packet"); + Err(drtio::Error::UnexpectedReply.into()) + }, + } + } +} + +#[cfg(has_drtio)] +macro_rules! process { + ($timer:ident, $aux_mutex:ident, $routing_table:ident, $destination:expr, $func:ident $(, $param:expr)*) => {{ + if $destination == 0 { + local_coremgmt::$func($($param, )*).await + } else { + let linkno = $routing_table.0[$destination as usize][0] - 1 as u8; + remote_coremgmt::$func($aux_mutex, $routing_table, $timer, linkno, $destination, $($param, )*).await + } + }} +} + +#[cfg(not(has_drtio))] +macro_rules! process { + ($timer:ident, $aux_mutex:ident, $routing_table:ident, $destination:expr, $func:ident $(, $param:expr)*) => {{ + local_coremgmt::$func($($param, )*).await + }} +} + + +async fn handle_connection( + stream: &mut TcpStream, + pull_id: Rc>, + cfg: Rc, + _aux_mutex: &Rc>, + _routing_table: &RoutingTable, + timer: GlobalTimer, +) -> Result<()> { if !expect(&stream, b"ARTIQ management\n").await? { return Err(Error::UnexpectedPattern); } + + let destination: u8 = read_i8(stream).await? as u8; stream.send_slice("e".as_bytes()).await?; loop { @@ -125,68 +569,70 @@ async fn handle_connection(stream: &mut TcpStream, pull_id: Rc>, cf let msg: Request = FromPrimitive::from_i8(msg?).ok_or(Error::UnrecognizedPacket)?; match msg { Request::GetLog => { - let buffer = get_logger_buffer().await.extract().as_bytes().to_vec(); - write_i8(stream, Reply::LogContent as i8).await?; - write_chunk(stream, &buffer).await?; - } - Request::ClearLog => { - let mut buffer = get_logger_buffer().await; - buffer.clear(); - write_i8(stream, Reply::Success as i8).await?; - } - Request::PullLog => { - let id = { - let mut guard = pull_id.borrow_mut(); - *guard += 1; - *guard - }; - loop { - let mut buffer = get_logger_buffer_pred(|b| !b.is_empty()).await; - if id != *pull_id.borrow() { - // another connection attempts to pull the log... - // abort this connection... - break; + match dispatch!(timer, _aux_mutex, _routing_table, destination, get_log) { + Ok(buffer) => { + write_i8(stream, Reply::LogContent as i8).await?; + write_chunk(stream, &buffer).await?; } - let bytes = buffer.extract().as_bytes().to_vec(); - buffer.clear(); - core::mem::drop(buffer); - write_chunk(stream, &bytes).await?; - if log::max_level() == LevelFilter::Trace { - // temporarily discard all trace level log - let logger = unsafe { BufferLogger::get_logger().as_mut().unwrap() }; - logger.set_buffer_log_level(LevelFilter::Debug); - stream.flush().await?; - logger.set_buffer_log_level(LevelFilter::Trace); + Err(_) => { + write_i8(stream, Reply::Error as i8).await?; } } + }, + + Request::ClearLog => { + match dispatch!(timer, _aux_mutex, _routing_table, destination, clear_log) { + Ok(()) => { + write_i8(stream, Reply::Success as i8).await?; + } + Err(_) => { + write_i8(stream, Reply::Error as i8).await?; + } + } + }, + + Request::PullLog => { + todo!() } + Request::SetLogFilter => { let lvl = read_log_level_filter(stream).await?; - info!("Changing log level to {}", lvl); - log::set_max_level(lvl); - write_i8(stream, Reply::Success as i8).await?; - } + match dispatch!(timer, _aux_mutex, _routing_table, destination, set_log_filter, lvl) { + Ok(()) => { + write_i8(stream, Reply::Success as i8).await?; + } + Err(_) => { + write_i8(stream, Reply::Error as i8).await?; + } + } + }, + Request::SetUartLogFilter => { let lvl = read_log_level_filter(stream).await?; - info!("Changing UART log level to {}", lvl); - unsafe { - BufferLogger::get_logger().as_ref().unwrap().set_uart_log_level(lvl); + match dispatch!(timer, _aux_mutex, _routing_table, destination, set_uart_log_filter, lvl) { + Ok(()) => { + write_i8(stream, Reply::Success as i8).await?; + } + Err(_) => { + write_i8(stream, Reply::Error as i8).await?; + } } - write_i8(stream, Reply::Success as i8).await?; - } + }, + Request::ConfigRead => { let key = read_key(stream).await?; debug!("read key: {}", key); - let value = cfg.read(&key); - if let Ok(value) = value { - debug!("got value"); - write_i8(stream, Reply::ConfigData as i8).await?; - write_chunk(stream, &value).await?; - } else { - warn!("read error: no such key"); - write_i8(stream, Reply::Error as i8).await?; + match dispatch!(timer, _aux_mutex, _routing_table, destination, config_read, &cfg, &key) { + Ok(value) => { + write_i8(stream, Reply::ConfigData as i8).await?; + write_chunk(stream, &value).await?; + } + Err(_) => { + write_i8(stream, Reply::Error as i8).await?; + } } - } + }, + Request::ConfigWrite => { let key = read_key(stream).await?; debug!("write key: {}", key); @@ -197,39 +643,55 @@ async fn handle_connection(stream: &mut TcpStream, pull_id: Rc>, cf buffer.set_len(len); } read_chunk(stream, &mut buffer).await?; - let value = cfg.write(&key, buffer); - if value.is_ok() { - debug!("write success"); - write_i8(stream, Reply::Success as i8).await?; - } else { - // this is an error because we do not expect write to fail - error!("failed to write: {:?}", value); - write_i8(stream, Reply::Error as i8).await?; + match dispatch!(timer, _aux_mutex, _routing_table, destination, config_write, &cfg, &key, buffer) { + Ok(()) => write_i8(stream, Reply::Success as i8).await?, + Err(_) => write_i8(stream, Reply::Error as i8).await?, } - } + }, + Request::ConfigRemove => { let key = read_key(stream).await?; - debug!("erase key: {}", key); - let value = cfg.remove(&key); + let value = dispatch!(timer, _aux_mutex, _routing_table, destination, config_remove, &cfg, &key); if value.is_ok() { - debug!("erase success"); write_i8(stream, Reply::Success as i8).await?; } else { - warn!("erase failed"); write_i8(stream, Reply::Error as i8).await?; } - } + }, + Request::Reboot => { - info!("rebooting"); - write_i8(stream, Reply::RebootImminent as i8).await?; - stream.flush().await?; - slcr::reboot(); - } + if destination == 0 { + info!("rebooting"); + write_i8(stream, Reply::RebootImminent as i8).await?; + stream.flush().await?; + slcr::reboot(); + } + + #[cfg(has_drtio)] + { + let linkno = _routing_table.0[destination as usize][0] - 1; + match remote_coremgmt::reboot( + _aux_mutex, _routing_table, timer, linkno, destination + ).await { + Ok(()) => write_i8(stream, Reply::Success as i8).await?, + Err(_) => write_i8(stream, Reply::Error as i8).await?, + } + } + }, + _ => todo!() } } } -pub fn start(cfg: Config) { + +pub fn start( + cfg: Config, + aux_mutex: &Rc>, + routing_table: &Rc>, + timer: GlobalTimer, +) { + let aux_mutex = aux_mutex.clone(); + let routing_table = routing_table.clone(); task::spawn(async move { let pull_id = Rc::new(RefCell::new(0u32)); let cfg = Rc::new(cfg); @@ -237,9 +699,12 @@ pub fn start(cfg: Config) { let mut stream = TcpStream::accept(1380, 2048, 2048).await.unwrap(); let pull_id = pull_id.clone(); let cfg = cfg.clone(); + let aux_mutex = aux_mutex.clone(); + let routing_table = routing_table.clone(); task::spawn(async move { info!("received connection"); - let _ = handle_connection(&mut stream, pull_id, cfg) + let routing_table = routing_table.borrow(); + let _ = handle_connection(&mut stream, pull_id, cfg, &aux_mutex, &routing_table, timer) .await .map_err(|e| warn!("connection terminated: {:?}", e)); let _ = stream.flush().await; diff --git a/src/runtime/src/rtio_mgt.rs b/src/runtime/src/rtio_mgt.rs index 53a3b8b..52a8462 100644 --- a/src/runtime/src/rtio_mgt.rs +++ b/src/runtime/src/rtio_mgt.rs @@ -540,7 +540,7 @@ pub mod drtio { } } - async fn partition_data( + pub async fn partition_data( linkno: u8, aux_mutex: &Rc>, routing_table: &RoutingTable, @@ -548,10 +548,11 @@ pub mod drtio { data: &[u8], packet_f: PacketF, reply_handler_f: HandlerF, - ) -> Result<(), Error> + ) -> Result<(), E> where PacketF: Fn(&[u8; MASTER_PAYLOAD_MAX_SIZE], PayloadStatus, usize) -> Packet, - HandlerF: Fn(&Packet) -> Result<(), Error>, + HandlerF: Fn(&Packet) -> Result<(), E>, + E: From, { let mut i = 0; while i < data.len() { @@ -887,6 +888,363 @@ pub mod drtio { ) .await } + + // pub async fn destination_get_log( + // aux_mutex: &Rc>, + // routing_table: &RoutingTable, + // timer: GlobalTimer, + // destination: u8, + // ) -> Result, Error> { + // let linkno = routing_table.0[destination as usize][0] - 1; + // let mut remote_log: Vec = Vec::new(); + // loop { + // let reply = aux_transact( + // aux_mutex, + // linkno, + // routing_table, + // &Packet::DestinationGetLogRequest { + // destination: destination, + // }, + // timer, + // ) + // .await?; + // match reply { + // Packet::DestinationGetLogReply { + // last, + // length, + // data, + // } => { + // remote_log.extend(&data[0..length as usize]); + // if last { + // return Ok(remote_log); + // } + // } + // _ => return Err(Error::UnexpectedReply), + // } + // } + // } + + // pub async fn destination_clear_log( + // aux_mutex: &Rc>, + // routing_table: &RoutingTable, + // timer: GlobalTimer, + // destination: u8, + // ) -> Result<(), Error> { + // let linkno = routing_table.0[destination as usize][0] - 1; + // let reply = aux_transact( + // aux_mutex, + // linkno, + // routing_table, + // &Packet::DestinationClearLogRequest { + // destination: destination, + // }, + // timer, + // ) + // .await?; + // match reply { + // Packet::DestinationMgmtAck { + // succeeded: true, + // } => Ok(()), + // Packet::DestinationMgmtAck { + // succeeded: false, + // } => return Err(Error::ClearLogFail(destination)), + // _ => Err(Error::UnexpectedReply), + // } + // } + + // pub async fn destination_pull_log( + // aux_mutex: &Rc>, + // routing_table: &RoutingTable, + // timer: GlobalTimer, + // destination: u8, + // ) -> Result, Error> { + // let linkno = routing_table.0[destination as usize][0] - 1; + // let mut remote_log: Vec = Vec::new(); + // loop { + // let reply = aux_transact( + // aux_mutex, + // linkno, + // routing_table, + // &Packet::DestinationPullLogRequest { + // destination: destination, + // }, + // timer, + // ) + // .await?; + // match reply { + // Packet::DestinationPullLogReply { + // destination: 0, + // last, + // length, + // data, + // } => { + // remote_log.extend(&data[0..length as usize]); + // if last { + // return Ok(remote_log); + // } + // } + // _ => return Err(Error::UnexpectedReply), + // } + // } + // } + + // pub async fn destination_set_log_level( + // aux_mutex: &Rc>, + // routing_table: &RoutingTable, + // timer: GlobalTimer, + // destination: u8, + // log_level: log::LevelFilter, + // ) -> Result<(), Error> { + // let linkno = routing_table.0[destination as usize][0] - 1; + // let reply = aux_transact( + // aux_mutex, + // linkno, + // routing_table, + // &Packet::DestinationSetLogLevelRequest { + // destination: destination, + // log_level: log_level as u8, + // }, + // timer, + // ) + // .await?; + // match reply { + // Packet::DestinationMgmtAck { + // succeeded: true, + // } => Ok(()), + // Packet::DestinationMgmtAck { + // succeeded: false, + // } => return Err(Error::SetLogLevelFail(destination)), + // _ => Err(Error::UnexpectedReply), + // } + // } + + // pub async fn destination_set_uart_log_level( + // aux_mutex: &Rc>, + // routing_table: &RoutingTable, + // timer: GlobalTimer, + // destination: u8, + // log_level: log::LevelFilter, + // ) -> Result<(), Error> { + // let linkno = routing_table.0[destination as usize][0] - 1; + // let reply = aux_transact( + // aux_mutex, + // linkno, + // routing_table, + // &Packet::DestinationSetUartLogLevelRequest { + // destination: destination, + // log_level: log_level as u8, + // }, + // timer, + // ) + // .await?; + // match reply { + // Packet::DestinationMgmtAck { + // succeeded: true, + // } => Ok(()), + // Packet::DestinationMgmtAck { + // succeeded: false, + // } => return Err(Error::SetUartLogLevelFail(destination)), + // _ => Err(Error::UnexpectedReply), + // } + // } + + // pub async fn destination_read_config( + // aux_mutex: &Rc>, + // routing_table: &RoutingTable, + // timer: GlobalTimer, + // destination: u8, + // key: &[u8], + // ) -> Result, Error> { + // let linkno = routing_table.0[destination as usize][0] - 1; + // let length = key.len(); + // // Assume key and value can fit within a DRTIO AUX packet together + // let mut key_slice: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE]; + // key_slice[..length].clone_from_slice(key); + + // let reply = aux_transact( + // aux_mutex, + // linkno, + // routing_table, + // &Packet::DestinationConfigReadRequest { + // destination: destination, + // length: length as u16, + // key: key_slice, + // }, + // timer, + // ) + // .await?; + // match reply { + // Packet::DestinationConfigReadReply { + // destination: 0, + // succeeded: true, + // length, + // value, + // } => Ok(Vec::from(&value[..length as usize])), + // Packet::DestinationConfigReadReply { + // destination: 0, + // succeeded: false, + // .. + // } => Err(Error::ReadConfigFail(destination)), + // _ => Err(Error::UnexpectedReply), + // } + // } + + // pub async fn destination_write_config( + // aux_mutex: &Rc>, + // routing_table: &RoutingTable, + // timer: GlobalTimer, + // destination: u8, + // key: &str, + // value: &[u8], + // ) -> Result<(), Error> { + // let linkno = routing_table.0[destination as usize][0] - 1; + + // let total_len = 4 + key.len() + 4 + value.len(); + // let mut payload = Cursor::new(Vec::with_capacity(total_len)); + + // payload.write_string(key).unwrap(); + // payload.write_bytes(value).unwrap(); + // assert_eq!(value[value.len()-1], payload.get_ref()[total_len-1]); + + // partition_data( + // linkno, + // aux_mutex, + // routing_table, + // timer, + // &payload.get_ref(), + // |slice, status, len| Packet::DestinationConfigWriteRequest { + // destination: destination, + // length: len as u16, + // last: status.is_last(), + // data: *slice, + // }, + // |reply| match reply { + // Packet::DestinationMgmtAck { + // succeeded: true, + // } => Ok(()), + // Packet::DestinationMgmtAck { + // succeeded: false, + // } => Err(Error::WriteConfigFail(destination)), + // _ => Err(Error::UnexpectedReply), + // }, + // ).await + // } + + // pub async fn destination_remove_config( + // aux_mutex: &Rc>, + // routing_table: &RoutingTable, + // timer: GlobalTimer, + // destination: u8, + // key: &[u8], + // ) -> Result<(), Error> { + // let linkno = routing_table.0[destination as usize][0] - 1; + // let length = key.len(); + // let mut key_slice: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE]; + // key_slice[..length].clone_from_slice(key); + + // let reply = aux_transact( + // aux_mutex, + // linkno, + // routing_table, + // &Packet::DestinationConfigRemoveRequest { + // destination: destination, + // length: length as u16, + // key: key_slice, + // }, + // timer, + // ) + // .await?; + // match reply { + // Packet::DestinationMgmtAck { + // succeeded: true, + // } => Ok(()), + // Packet::DestinationMgmtAck { + // succeeded: false, + // } => Err(Error::RemoveConfigFail(destination)), + // _ => Err(Error::UnexpectedReply), + // } + // } + + // pub async fn destination_erase_config( + // aux_mutex: &Rc>, + // routing_table: &RoutingTable, + // timer: GlobalTimer, + // destination: u8, + // ) -> Result<(), Error> { + // let linkno = routing_table.0[destination as usize][0] - 1; + // let reply = aux_transact( + // aux_mutex, + // linkno, + // routing_table, + // &Packet::DestinationConfigEraseRequest { + // destination: destination, + // }, + // timer, + // ) + // .await?; + // match reply { + // Packet::DestinationMgmtAck { + // succeeded: true, + // } => Ok(()), + // Packet::DestinationMgmtAck { + // succeeded: false, + // } => Err(Error::EraseConfigFail(destination)), + // _ => Err(Error::UnexpectedReply), + // } + // } + + // pub async fn destination_reboot( + // aux_mutex: &Rc>, + // routing_table: &RoutingTable, + // timer: GlobalTimer, + // destination: u8, + // ) -> Result<(), Error> { + // let linkno = routing_table.0[destination as usize][0] - 1; + // let reply = aux_transact( + // aux_mutex, + // linkno, + // routing_table, + // &Packet::DestinationRebootRequest { + // destination: destination, + // }, + // timer, + // ) + // .await?; + // match reply { + // Packet::DestinationMgmtAck { + // succeeded: true, + // } => Ok(()), + // Packet::DestinationMgmtAck { + // succeeded: false, + // } => Err(Error::RebootFail(destination)), + // _ => Err(Error::UnexpectedReply), + // } + // } + + // pub async fn destination_allocator_debug( + // aux_mutex: &Rc>, + // routing_table: &RoutingTable, + // timer: GlobalTimer, + // destination: u8, + // ) -> Result<(), Error> { + // let linkno = routing_table.0[destination as usize][0] - 1; + // let reply = aux_transact( + // aux_mutex, + // linkno, + // routing_table, + // &Packet::DestinationAllocatorDebugRequest { + // destination: destination, + // }, + // timer, + // ) + // .await?; + // match reply { + // Packet::DestinationMgmtAck { + // succeeded: true, + // } => Ok(()), + // _ => Err(Error::UnexpectedReply), + // } + // } } #[cfg(not(has_drtio))] diff --git a/src/satman/Cargo.toml.tpl b/src/satman/Cargo.toml.tpl index d4fa63c..6880be4 100644 --- a/src/satman/Cargo.toml.tpl +++ b/src/satman/Cargo.toml.tpl @@ -14,8 +14,11 @@ default = ["target_zc706", ] build_zynq = { path = "../libbuild_zynq" } [dependencies] +num-traits = { version = "0.2", default-features = false } +num-derive = "0.3" log = { version = "0.4", default-features = false } core_io = { version = "0.1", features = ["collections"] } +byteorder = { version = "1.3", default-features = false } cslice = "0.3" embedded-hal = "0.2" diff --git a/src/satman/src/main.rs b/src/satman/src/main.rs index aebd9d6..6a09298 100644 --- a/src/satman/src/main.rs +++ b/src/satman/src/main.rs @@ -5,8 +5,11 @@ #[macro_use] extern crate log; extern crate core_io; +extern crate byteorder; extern crate cslice; extern crate embedded_hal; +extern crate num_derive; +extern crate num_traits; extern crate io; extern crate ksupport; @@ -33,24 +36,26 @@ use libboard_artiq::si5324; #[cfg(has_si549)] use libboard_artiq::si549; use libboard_artiq::{drtio_routing, drtioaux, - drtioaux_proto::{MASTER_PAYLOAD_MAX_SIZE, SAT_PAYLOAD_MAX_SIZE}, + drtioaux_proto::{MASTER_PAYLOAD_MAX_SIZE, SAT_PAYLOAD_MAX_SIZE, CORE_MGMT_PAYLOAD_MAX_SIZE}, identifier_read, logger, pl::csr}; #[cfg(feature = "target_kasli_soc")] use libboard_zynq::error_led::ErrorLED; -use libboard_zynq::{i2c::I2c, print, println, time::Milliseconds, timer::GlobalTimer}; +use libboard_zynq::{i2c::I2c, print, println, slcr, time::Milliseconds, timer::GlobalTimer}; use libconfig::Config; use libcortex_a9::{l2c::enable_l2_cache, regs::MPIDR}; use libregister::RegisterR; use libsupport_zynq::{exception_vectors, ram}; use routing::Router; use subkernel::Manager as KernelManager; +use mgmt::Manager as CoreManager; mod analyzer; mod dma; mod repeater; mod routing; mod subkernel; +mod mgmt; // linker symbols extern "C" { @@ -149,6 +154,7 @@ fn process_aux_packet( dma_manager: &mut DmaManager, analyzer: &mut Analyzer, kernel_manager: &mut KernelManager, + core_manager: &mut CoreManager, router: &mut Router, ) -> Result<(), drtioaux::Error> { // In the code below, *_chan_sel_write takes an u8 if there are fewer than 256 channels, @@ -1010,6 +1016,282 @@ fn process_aux_packet( } Ok(()) } + drtioaux::Packet::CoreMgmtGetLogRequest { + destination: _destination, + } => { + forward!( + router, + _routing_table, + _destination, + *rank, + *self_destination, + _repeaters, + &packet, + timer + ); + let mut data_slice: [u8; CORE_MGMT_PAYLOAD_MAX_SIZE] = [0; CORE_MGMT_PAYLOAD_MAX_SIZE]; + let meta = core_manager.log_get_slice(&mut data_slice); + drtioaux::send(0, + &drtioaux::Packet::CoreMgmtGetLogReply { + last: meta.status.is_last(), + length: meta.len as u16, + data: data_slice, + }, + ) + } + drtioaux::Packet::CoreMgmtClearLogRequest { + destination: _destination, + } => { + forward!( + router, + _routing_table, + _destination, + *rank, + *self_destination, + _repeaters, + &packet, + timer + ); + mgmt::clear_log(); + drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck { + succeeded: true + }) + } + drtioaux::Packet::CoreMgmtSetLogLevelRequest { + destination: _destination, + log_level, + } => { + forward!( + router, + _routing_table, + _destination, + *rank, + *self_destination, + _repeaters, + &packet, + timer + ); + + match mgmt::byte_to_level_filter(log_level) { + Ok(level_filter) => { + info!("Changing log level to {}", log_level); + log::set_max_level(level_filter); + drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck { + succeeded: true + }) + } + Err(_) => { + error!("Unknown log level: {}", log_level); + drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck { + succeeded: false + }) + } + } + } + drtioaux::Packet::CoreMgmtSetUartLogLevelRequest { + destination: _destination, + log_level, + } => { + forward!( + router, + _routing_table, + _destination, + *rank, + *self_destination, + _repeaters, + &packet, + timer + ); + + match mgmt::byte_to_level_filter(log_level) { + Ok(level_filter) => { + info!("Changing UART log level to {}", log_level); + unsafe { + logger::BufferLogger::get_logger().as_ref().unwrap().set_uart_log_level(level_filter); + } + drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck { + succeeded: true + }) + } + Err(_) => { + error!("Unknown log level: {}", log_level); + drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck { + succeeded: false + }) + } + } + } + drtioaux::Packet::CoreMgmtConfigReadRequest { + destination: _destination, + length, + key, + } => { + forward!( + router, + _routing_table, + _destination, + *rank, + *self_destination, + _repeaters, + &packet, + timer + ); + + let mut value_slice = [0; CORE_MGMT_PAYLOAD_MAX_SIZE]; + + let key_slice = &key[..length as usize]; + if !key_slice.is_ascii() { + error!("invalid key"); + drtioaux::send(0, &drtioaux::Packet::CoreMgmtConfigReadReply { + succeeded: false, + length: 0, + last: true, + value: value_slice, + }) + } else { + let key = core::str::from_utf8(key_slice).unwrap(); + if !core_manager.fetch_config_value(key) { + warn!("read error: no such key"); + drtioaux::send(0, &drtioaux::Packet::CoreMgmtConfigReadReply { + succeeded: false, + length: 0, + last: true, + value: value_slice, + }) + } else { + let meta = core_manager.get_config_value_slice(&mut value_slice); + drtioaux::send(0, + &drtioaux::Packet::CoreMgmtConfigReadReply { + succeeded: true, + length: meta.len as u16, + last: meta.status.is_last(), + value: value_slice, + }, + ) + } + } + } + drtioaux::Packet::CoreMgmtConfigReadContinue { + destination: _destination, + } => { + forward!( + router, + _routing_table, + _destination, + *rank, + *self_destination, + _repeaters, + &packet, + timer + ); + + let mut value_slice = [0; CORE_MGMT_PAYLOAD_MAX_SIZE]; + let meta = core_manager.get_config_value_slice(&mut value_slice); + drtioaux::send(0, + &drtioaux::Packet::CoreMgmtConfigReadReply { + succeeded: true, + length: meta.len as u16, + last: meta.status.is_last(), + value: value_slice, + }, + ) + } + drtioaux::Packet::CoreMgmtConfigWriteRequest { + destination: _destination, + length, + last, + data, + } => { + forward!( + router, + _routing_table, + _destination, + *rank, + *self_destination, + _repeaters, + &packet, + timer + ); + + core_manager.add_data(&data, length as usize); + + let mut succeeded = true; + if last { + if !core_manager.write_config() { + succeeded = false; + } + } + + drtioaux::send(0, + &drtioaux::Packet::CoreMgmtAck { + succeeded: succeeded, + }, + )?; + + Ok(()) + } + drtioaux::Packet::CoreMgmtConfigRemoveRequest { + destination: _destination, + length, + key, + } => { + forward!( + router, + _routing_table, + _destination, + *rank, + *self_destination, + _repeaters, + &packet, + timer + ); + + let key_slice = &key[..length as usize]; + if !key_slice.is_ascii() { + error!("invalid key"); + drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck { + succeeded: false, + }) + } else { + let key = core::str::from_utf8(key_slice).unwrap(); + debug!("erase key: {}", key); + if core_manager.remove_config(key) { + debug!("erase success"); + drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck { + succeeded: true, + }) + } else { + warn!("erase failed"); + drtioaux::send(0, &drtioaux::Packet::CoreMgmtAck { + succeeded: false, + }) + } + } + } + drtioaux::Packet::CoreMgmtRebootRequest { + destination: _destination, + } => { + info!("received reboot request"); + forward!( + router, + _routing_table, + _destination, + *rank, + *self_destination, + _repeaters, + &packet, + timer + ); + + drtioaux::send(0, + &drtioaux::Packet::CoreMgmtAck { + succeeded: true, + }, + )?; + info!("reboot imminent"); + slcr::reboot(); + Ok(()) + } p => { warn!("received unexpected aux packet: {:?}", p); @@ -1028,6 +1310,7 @@ fn process_aux_packets( dma_manager: &mut DmaManager, analyzer: &mut Analyzer, kernel_manager: &mut KernelManager, + core_manager: &mut CoreManager, router: &mut Router, ) { let result = drtioaux::recv(0).and_then(|packet| { @@ -1043,6 +1326,7 @@ fn process_aux_packets( dma_manager, analyzer, kernel_manager, + core_manager, router, ) } else { @@ -1239,7 +1523,7 @@ pub extern "C" fn main_core0() -> i32 { #[cfg(has_si549)] si549::helper_setup(&mut timer, &SI549_SETTINGS).expect("cannot initialize helper Si549"); - let cfg = match Config::new() { + let mut cfg = match Config::new() { Ok(cfg) => cfg, Err(err) => { warn!("config initialization failed: {}", err); @@ -1314,6 +1598,7 @@ pub extern "C" fn main_core0() -> i32 { let mut dma_manager = DmaManager::new(); let mut analyzer = Analyzer::new(); let mut kernel_manager = KernelManager::new(&mut control); + let mut core_manager = CoreManager::new(&mut cfg); drtioaux::reset(0); drtiosat_reset(false); @@ -1331,6 +1616,7 @@ pub extern "C" fn main_core0() -> i32 { &mut dma_manager, &mut analyzer, &mut kernel_manager, + &mut core_manager, &mut router, ); #[allow(unused_mut)] diff --git a/src/satman/src/mgmt.rs b/src/satman/src/mgmt.rs new file mode 100644 index 0000000..3a0bb6c --- /dev/null +++ b/src/satman/src/mgmt.rs @@ -0,0 +1,307 @@ +use alloc::vec::Vec; + +use libboard_artiq::logger::{BufferLogger, LogBufferRef}; +use libboard_zynq::smoltcp; +use libconfig::Config; +use log::{self, debug, error, info, warn, LevelFilter}; +use libboard_artiq::drtioaux_proto::CORE_MGMT_PAYLOAD_MAX_SIZE; + +use crate::routing::{Sliceable, SliceMeta}; +use io::{Cursor, ProtoRead, ProtoWrite}; + +#[derive(Debug, Clone, Copy, PartialEq, Eq)] +pub enum Error { + NetworkError(smoltcp::Error), + UnknownLogLevel(u8), + UnexpectedPattern, + UnrecognizedPacket, +} + +type Result = core::result::Result; + +impl core::fmt::Display for Error { + fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result { + match self { + &Error::NetworkError(error) => write!(f, "network error: {}", error), + &Error::UnknownLogLevel(lvl) => write!(f, "unknown log level {}", lvl), + &Error::UnexpectedPattern => write!(f, "unexpected pattern"), + &Error::UnrecognizedPacket => write!(f, "unrecognized packet"), + } + } +} + +// impl From for Error { +// fn from(error: smoltcp::Error) -> Self { +// Error::NetworkError(error) +// } +// } + +// #[derive(Debug, FromPrimitive)] +// pub enum Request { +// GetLog = 1, +// ClearLog = 2, +// PullLog = 7, +// SetLogFilter = 3, +// Reboot = 5, +// SetUartLogFilter = 6, + +// ConfigRead = 12, +// ConfigWrite = 13, +// ConfigRemove = 14, +// } + +// #[repr(i8)] +// pub enum Reply { +// Success = 1, +// LogContent = 2, +// RebootImminent = 3, +// Error = 6, +// ConfigData = 7, +// } + +pub fn byte_to_level_filter(level_byte: u8) -> Result { + Ok(match level_byte { + 0 => log::LevelFilter::Off, + 1 => log::LevelFilter::Error, + 2 => log::LevelFilter::Warn, + 3 => log::LevelFilter::Info, + 4 => log::LevelFilter::Debug, + 5 => log::LevelFilter::Trace, + lv => return Err(Error::UnknownLogLevel(lv)), + }) +} + +fn get_logger_buffer_pred() -> LogBufferRef<'static> { + let logger = unsafe { BufferLogger::get_logger().as_mut().unwrap() }; + loop { + if let Some(buffer_ref) = logger.buffer() { + return buffer_ref; + } + } +} + +fn get_logger_buffer() -> LogBufferRef<'static> { + get_logger_buffer_pred() +} + +pub fn clear_log() { + let mut buffer = get_logger_buffer(); + buffer.clear(); +} + +// async fn read_key(stream: &mut TcpStream) -> Result { +// let len = read_i32(stream).await?; +// if len <= 0 { +// write_i8(stream, Reply::Error as i8).await?; +// return Err(Error::UnexpectedPattern); +// } +// let mut buffer = Vec::with_capacity(len as usize); +// for _ in 0..len { +// buffer.push(0); +// } +// read_chunk(stream, &mut buffer).await?; +// if !buffer.is_ascii() { +// write_i8(stream, Reply::Error as i8).await?; +// return Err(Error::UnexpectedPattern); +// } +// Ok(String::from_utf8(buffer).unwrap()) +// } + +pub struct Manager<'a> { + cfg: &'a mut Config, + last_log: Sliceable, + current_payload: Cursor>, + last_value: Sliceable, +} + +impl<'a> Manager<'_> { + pub fn new(cfg: &mut Config) -> Manager { + Manager { + cfg: cfg, + last_log: Sliceable::new(0, Vec::new()), + current_payload: Cursor::new(Vec::new()), + last_value: Sliceable::new(0, Vec::new()), + } + } + + pub fn log_get_slice(&mut self, data_slice: &mut [u8; CORE_MGMT_PAYLOAD_MAX_SIZE]) -> SliceMeta { + // Populate buffer if depleted + if self.last_log.at_end() { + self.last_log.extend(get_logger_buffer().extract().as_bytes()); + } + + self.last_log.get_slice_core_mgmt(data_slice) + } + + pub fn fetch_config_value(&mut self, key: &str) -> bool { + let value = self.cfg.read(&key); + if let Ok(value) = value { + debug!("got value"); + self.last_value = Sliceable::new(0, value); + true + } else { + warn!("read error: no such key"); + false + } + } + + pub fn get_config_value_slice(&mut self, data_slice: &mut [u8; CORE_MGMT_PAYLOAD_MAX_SIZE]) -> SliceMeta { + self.last_value.get_slice_core_mgmt(data_slice) + } + + pub fn add_data(&mut self, data: &[u8], data_len: usize) { + self.current_payload.write_all(&data[..data_len]).unwrap(); + } + + pub fn clear_data(&mut self) { + self.current_payload.get_mut().clear(); + self.current_payload.set_position(0); + } + + pub fn write_config(&mut self) -> bool { + let key = self.current_payload.read_string().unwrap(); + let value = self.current_payload.read_bytes().unwrap(); + + let status = self.cfg.write(&key, value); + if status.is_ok() { + debug!("write success"); + } else { + // this is an error because we do not expect write to fail + error!("failed to write: {:?}", status); + } + + self.clear_data(); + status.is_ok() + } + + pub fn remove_config(&mut self, key: &str) -> bool { + debug!("erase key: {}", key); + let status = self.cfg.remove(&key); + if status.is_ok() { + debug!("erase success"); + } else { + warn!("erase failed"); + } + status.is_ok() + } +} + + + +// async fn handle_connection(stream: &mut TcpStream, pull_id: Rc>, cfg: Rc) -> Result<()> { +// if !expect(&stream, b"ARTIQ management\n").await? { +// return Err(Error::UnexpectedPattern); +// } +// stream.send_slice("e".as_bytes()).await?; + +// loop { +// let msg = read_i8(stream).await; +// if let Err(smoltcp::Error::Finished) = msg { +// return Ok(()); +// } +// let msg: Request = FromPrimitive::from_i8(msg?).ok_or(Error::UnrecognizedPacket)?; +// match msg { +// Request::GetLog => { +// let buffer = get_logger_buffer().await.extract().as_bytes().to_vec(); +// write_i8(stream, Reply::LogContent as i8).await?; +// write_chunk(stream, &buffer).await?; +// } +// Request::ClearLog => { +// let mut buffer = get_logger_buffer().await; +// buffer.clear(); +// write_i8(stream, Reply::Success as i8).await?; +// } +// Request::PullLog => { +// let id = { +// let mut guard = pull_id.borrow_mut(); +// *guard += 1; +// *guard +// }; +// loop { +// let mut buffer = get_logger_buffer_pred(|b| !b.is_empty()).await; +// if id != *pull_id.borrow() { +// // another connection attempts to pull the log... +// // abort this connection... +// break; +// } +// let bytes = buffer.extract().as_bytes().to_vec(); +// buffer.clear(); +// core::mem::drop(buffer); +// write_chunk(stream, &bytes).await?; +// if log::max_level() == LevelFilter::Trace { +// // temporarily discard all trace level log +// let logger = unsafe { BufferLogger::get_logger().as_mut().unwrap() }; +// logger.set_buffer_log_level(LevelFilter::Debug); +// stream.flush().await?; +// logger.set_buffer_log_level(LevelFilter::Trace); +// } +// } +// } +// Request::SetLogFilter => { +// let lvl = read_log_level_filter(stream).await?; +// info!("Changing log level to {}", lvl); +// log::set_max_level(lvl); +// write_i8(stream, Reply::Success as i8).await?; +// } +// Request::SetUartLogFilter => { +// let lvl = read_log_level_filter(stream).await?; +// info!("Changing UART log level to {}", lvl); +// unsafe { +// BufferLogger::get_logger().as_ref().unwrap().set_uart_log_level(lvl); +// } +// write_i8(stream, Reply::Success as i8).await?; +// } +// Request::ConfigRead => { +// let key = read_key(stream).await?; +// debug!("read key: {}", key); +// let value = cfg.read(&key); +// if let Ok(value) = value { +// debug!("got value"); +// write_i8(stream, Reply::ConfigData as i8).await?; +// write_chunk(stream, &value).await?; +// } else { +// warn!("read error: no such key"); +// write_i8(stream, Reply::Error as i8).await?; +// } +// } +// Request::ConfigWrite => { +// let key = read_key(stream).await?; +// debug!("write key: {}", key); +// let len = read_i32(stream).await?; +// let len = if len <= 0 { 0 } else { len as usize }; +// let mut buffer = Vec::with_capacity(len); +// unsafe { +// buffer.set_len(len); +// } +// read_chunk(stream, &mut buffer).await?; +// let value = cfg.write(&key, buffer); +// if value.is_ok() { +// debug!("write success"); +// write_i8(stream, Reply::Success as i8).await?; +// } else { +// // this is an error because we do not expect write to fail +// error!("failed to write: {:?}", value); +// write_i8(stream, Reply::Error as i8).await?; +// } +// } +// Request::ConfigRemove => { +// let key = read_key(stream).await?; +// debug!("erase key: {}", key); +// let value = cfg.remove(&key); +// if value.is_ok() { +// debug!("erase success"); +// write_i8(stream, Reply::Success as i8).await?; +// } else { +// warn!("erase failed"); +// write_i8(stream, Reply::Error as i8).await?; +// } +// } +// Request::Reboot => { +// info!("rebooting"); +// write_i8(stream, Reply::RebootImminent as i8).await?; +// stream.flush().await?; +// slcr::reboot(); +// } +// } +// } +// } diff --git a/src/satman/src/routing.rs b/src/satman/src/routing.rs index 87d5f09..dbbb958 100644 --- a/src/satman/src/routing.rs +++ b/src/satman/src/routing.rs @@ -4,7 +4,7 @@ use core::cmp::min; #[cfg(has_drtio_routing)] use libboard_artiq::pl::csr; use libboard_artiq::{drtio_routing, drtioaux, - drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE}}; + drtioaux_proto::{PayloadStatus, MASTER_PAYLOAD_MAX_SIZE, CORE_MGMT_PAYLOAD_MAX_SIZE}}; pub struct SliceMeta { pub destination: u8, @@ -58,6 +58,7 @@ impl Sliceable { } get_slice_fn!(get_slice_master, MASTER_PAYLOAD_MAX_SIZE); + get_slice_fn!(get_slice_core_mgmt, CORE_MGMT_PAYLOAD_MAX_SIZE); } // Packets from downstream (further satellites) are received and routed appropriately.