diff --git a/Cargo.lock b/Cargo.lock index 802b81e93..ab8d24461 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -83,7 +83,7 @@ version = "0.1.0" dependencies = [ "log", "log-server", - "rkyv 0.3.1", + "rkyv 0.4.1", "utralib", "xous", "xous-names", @@ -654,7 +654,7 @@ dependencies = [ "heapless", "log", "log-server", - "rkyv 0.3.1", + "rkyv 0.4.1", "ticktimer-server", "utralib", "xous", @@ -1155,7 +1155,7 @@ dependencies = [ "llio", "log", "log-server", - "rkyv 0.3.1", + "rkyv 0.4.1", "ticktimer-server", "utralib", "xous", diff --git a/kernel/Cargo.lock b/kernel/Cargo.lock index 628529e09..b34760919 100644 --- a/kernel/Cargo.lock +++ b/kernel/Cargo.lock @@ -218,26 +218,6 @@ version = "0.22.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "aaf91faf136cb47367fa430cd46e37a788775e7fa104f8b4bcb3861dc389b724" -[[package]] -name = "hash32" -version = "0.1.1" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "d4041af86e63ac4298ce40e5cca669066e75b6f1aa3390fe2561ffa5e1d9f4cc" -dependencies = [ - "byteorder", -] - -[[package]] -name = "hash32-derive" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebc0efbd154a17cddc3616d83faef479c0076d871a2143c157b310cc7ca799a2" -dependencies = [ - "proc-macro2 0.3.8", - "quote 0.5.2", - "syn 0.13.11", -] - [[package]] name = "hermit-abi" version = "0.1.17" @@ -330,22 +310,13 @@ version = "0.2.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "237a5ed80e274dbc66f86bd59c1e25edc039660be53194b5fe0a482e0f2612ea" -[[package]] -name = "proc-macro2" -version = "0.3.8" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "1b06e2f335f48d24442b35a19df506a835fb3547bc3c06ef27340da9acf5cae7" -dependencies = [ - "unicode-xid 0.1.0", -] - [[package]] name = "proc-macro2" version = "1.0.19" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "04f5f085b5d71e2188cb8271e5da0161ad52c3f227a661a3c135fdf28e258b12" dependencies = [ - "unicode-xid 0.2.1", + "unicode-xid", ] [[package]] @@ -363,9 +334,9 @@ version = "0.1.1" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7bcd6232fa7d7fcd15703da5c07c9f10d203ee4fdf6ecf6d7ac5056db78089a3" dependencies = [ - "proc-macro2 1.0.19", - "quote 1.0.7", - "syn 1.0.38", + "proc-macro2", + "quote", + "syn", ] [[package]] @@ -377,22 +348,13 @@ dependencies = [ "memchr", ] -[[package]] -name = "quote" -version = "0.5.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "9949cfe66888ffe1d53e6ec9d9f3b70714083854be20fd5e271b232a017401e8" -dependencies = [ - "proc-macro2 0.3.8", -] - [[package]] name = "quote" version = "1.0.7" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "aa563d17ecb180e500da1cfd2b028310ac758de548efdd203e18f283af693f37" dependencies = [ - "proc-macro2 1.0.19", + "proc-macro2", ] [[package]] @@ -473,9 +435,9 @@ version = "0.4.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "95a169f6bc5a81033e86ed39d0f4150e2608160b73d2b93c6e8e6a3efa873f14" dependencies = [ - "proc-macro2 1.0.19", - "quote 1.0.7", - "syn 1.0.38", + "proc-macro2", + "quote", + "syn", ] [[package]] @@ -542,26 +504,15 @@ dependencies = [ "quick-xml", ] -[[package]] -name = "syn" -version = "0.13.11" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "14f9bf6292f3a61d2c716723fdb789a41bbe104168e6f496dc6497e531ea1b9b" -dependencies = [ - "proc-macro2 0.3.8", - "quote 0.5.2", - "unicode-xid 0.1.0", -] - [[package]] name = "syn" version = "1.0.38" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e69abc24912995b3038597a7a593be5053eb0fb44f3cc5beec0deb421790c1f4" dependencies = [ - "proc-macro2 1.0.19", - "quote 1.0.7", - "unicode-xid 0.2.1", + "proc-macro2", + "quote", + "unicode-xid", ] [[package]] @@ -585,12 +536,6 @@ version = "0.1.8" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "9337591893a19b88d8d87f2cec1e73fad5cdfd10e5a6f349f498ad6ea2ffb1e3" -[[package]] -name = "unicode-xid" -version = "0.1.0" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "fc72304796d0818e357ead4e000d19c9c174ab23dc11093ac919054d20a6a7fc" - [[package]] name = "unicode-xid" version = "0.2.1" @@ -653,8 +598,6 @@ name = "xous" version = "0.1.2" dependencies = [ "bitflags", - "hash32", - "hash32-derive", "hex", "lazy_static", "rkyv", @@ -665,8 +608,8 @@ dependencies = [ name = "xous-macros" version = "0.1.0" dependencies = [ - "proc-macro2 1.0.19", - "quote 1.0.7", + "proc-macro2", + "quote", "rand", - "syn 1.0.38", + "syn", ] diff --git a/services/benchmark-target/Cargo.toml b/services/benchmark-target/Cargo.toml index 7b453c50f..1a5114d97 100644 --- a/services/benchmark-target/Cargo.toml +++ b/services/benchmark-target/Cargo.toml @@ -7,11 +7,15 @@ description = "Benchmark target for Xous" [dependencies] xous = { path = "../../xous-rs" } -rkyv = { version = "0.3.1", default_features = false } xous-names = { path = "../xous-names" } log-server = { path = "../log-server" } log = "0.4" +[dependencies.rkyv] +version = "0.4.1" +default-features = false +features = ["const_generics"] + [target.'cfg(not(any(windows,unix)))'.dependencies] utralib = { path = "../../utralib"} diff --git a/services/benchmark-target/src/lib.rs b/services/benchmark-target/src/lib.rs index 8e6042762..7e01b3fa9 100644 --- a/services/benchmark-target/src/lib.rs +++ b/services/benchmark-target/src/lib.rs @@ -4,6 +4,7 @@ pub mod api; use api::*; use xous::{CID, send_message}; +use rkyv::ser::Serializer; pub fn test_scalar(cid: CID, testvar: u32) -> Result { let response = send_message(cid, api::Opcode::TestScalar(testvar).into())?; @@ -20,8 +21,9 @@ pub fn test_memory(cid: CID, testvar: u32) -> Result { reg.challenge[0] = testvar; let reg_opcode = api::Opcode::TestMemory(reg); - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(®_opcode).expect("couldn't archive test structure"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); + + let pos = writer.serialize_value(®_opcode).expect("couldn't archive test structure"); let mut xous_buffer = writer.into_inner(); xous_buffer.lend_mut(cid, pos as u32).expect("test failure"); diff --git a/services/benchmark-target/src/main.rs b/services/benchmark-target/src/main.rs index 4d0ce4c9f..12f56fd35 100644 --- a/services/benchmark-target/src/main.rs +++ b/services/benchmark-target/src/main.rs @@ -11,7 +11,8 @@ use log::{error, info}; use rkyv::archived_value_mut; use core::pin::Pin; use core::convert::TryInto; -use rkyv::Serialize, rkyv::Deserialize; +use rkyv::{Serialize, Deserialize}; +use rkyv::ser::Serializer; #[xous::xous_main] fn xmain() -> ! { @@ -44,8 +45,8 @@ fn xmain() -> ! { ret.challenge[0] = reg.challenge[0] + 1; let retop = Opcode::TestMemory(ret); - let mut writer = rkyv::ArchiveBuffer::new(buf); - let pos = writer.archive(&retop).expect("couldn't archive return value"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf); + let pos = writer.serialize_value(&retop).expect("couldn't archive return value"); unsafe{ rkyv::archived_value::(writer.into_inner().as_ref(), pos) }; } _ => panic!("Invalid response from server -- corruption occurred"), diff --git a/services/gam/src/lib.rs b/services/gam/src/lib.rs index 2528d29e4..1847706c4 100644 --- a/services/gam/src/lib.rs +++ b/services/gam/src/lib.rs @@ -4,8 +4,8 @@ pub mod api; use api::*; use xous::send_message; -use rkyv::Write; -use rkyv::Serialize, rkyv::Deserialize; +use rkyv::Deserialize; +use rkyv::ser::Serializer; use graphics_server::api::{TextOp, TextView}; use graphics_server::api::{Point, Gid, Line, Rectangle, Circle, RoundedRectangle}; @@ -34,8 +34,9 @@ pub fn powerdown_request(gam_cid: xous::CID) -> Result { pub fn post_textview(gam_cid: xous::CID, tv: &mut TextView) -> Result<(), xous::Error> { tv.set_op(TextOp::Render); let rkyv_tv = api::Opcode::RenderTextView(*tv); - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&rkyv_tv).expect("GAM_API: couldn't archive textview"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); + + let pos = writer.serialize_value(&rkyv_tv).expect("GAM_API: couldn't archive textview"); let mut xous_buffer = writer.into_inner(); xous_buffer.lend_mut(gam_cid, pos as u32).expect("GAM_API: RenderTextView operation failure"); @@ -43,7 +44,7 @@ pub fn post_textview(gam_cid: xous::CID, tv: &mut TextView) -> Result<(), xous:: // recover the mutable values and mirror the ones we care about back into our local structure let returned = unsafe { rkyv::archived_value::(xous_buffer.as_ref(), pos)}; if let rkyv::Archived::::RenderTextView(result) = returned { - let tvr: TextView = result.deserialize(); + let tvr: TextView = result.deserialize(&mut xous::XousDeserializer).unwrap(); tv.bounds_computed = tvr.bounds_computed; tv.cursor = tvr.cursor; } else { @@ -60,8 +61,9 @@ pub fn draw_line(gam_cid: xous::CID, gid: Gid, line: Line) -> Result<(), xous::E canvas: gid, obj: GamObjectType::Line(line), }); - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&rkyv_tv).expect("GAM_API: couldn't archive GamObject"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); + + let pos = writer.serialize_value(&rkyv_tv).expect("GAM_API: couldn't archive GamObject"); let xous_buffer = writer.into_inner(); xous_buffer.lend(gam_cid, pos as u32).expect("GAM_API: GamObject operation failure"); Ok(()) @@ -72,8 +74,9 @@ pub fn draw_rectangle(gam_cid: xous::CID, gid: Gid, rect: Rectangle) -> Result<( canvas: gid, obj: GamObjectType::Rect(rect), }); - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&rkyv_tv).expect("GAM_API: couldn't archive GamObject"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); + + let pos = writer.serialize_value(&rkyv_tv).expect("GAM_API: couldn't archive GamObject"); let xous_buffer = writer.into_inner(); xous_buffer.lend(gam_cid, pos as u32).expect("GAM_API: GamObject operation failure"); Ok(()) @@ -84,8 +87,9 @@ pub fn draw_rouded_rectangle(gam_cid: xous::CID, gid: Gid, rr: RoundedRectangle) canvas: gid, obj: GamObjectType::RoundRect(rr), }); - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&rkyv_tv).expect("GAM_API: couldn't archive GamObject"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); + + let pos = writer.serialize_value(&rkyv_tv).expect("GAM_API: couldn't archive GamObject"); let xous_buffer = writer.into_inner(); xous_buffer.lend(gam_cid, pos as u32).expect("GAM_API: GamObject operation failure"); Ok(()) @@ -96,8 +100,9 @@ pub fn draw_circle(gam_cid: xous::CID, gid: Gid, circ: Circle) -> Result<(), xou canvas: gid, obj: GamObjectType::Circ(circ), }); - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&rkyv_tv).expect("GAM_API: couldn't archive GamObject"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); + + let pos = writer.serialize_value(&rkyv_tv).expect("GAM_API: couldn't archive GamObject"); let xous_buffer = writer.into_inner(); xous_buffer.lend(gam_cid, pos as u32).expect("GAM_API: GamObject operation failure"); Ok(()) @@ -119,15 +124,16 @@ pub fn get_canvas_bounds(gam_cid: xous::CID, gid: Gid) -> Result Result<(), xous::Error> { let rkyv = api::Opcode::SetCanvasBounds((*req).clone()); - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&rkyv).expect("GAM_API: couldn't archive SetCanvasBounds"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); + + let pos = writer.serialize_value(&rkyv).expect("GAM_API: couldn't archive SetCanvasBounds"); let mut xous_buffer = writer.into_inner(); xous_buffer.lend_mut(gam_cid, pos as u32).expect("GAM_API: SetCanvasBounds operation failure"); // recover the mutable values and mirror the ones we care about back into our local structure let returned = unsafe { rkyv::archived_value::(xous_buffer.as_ref(), pos)}; if let rkyv::Archived::::SetCanvasBounds(result) = returned { - let ret: SetCanvasBoundsRequest = result.deserialize(); + let ret: SetCanvasBoundsRequest = result.deserialize(&mut xous::XousDeserializer).unwrap(); req.granted = ret.granted; } else { panic!("GAM_API: set_canvas_bounds_request view got a return value from the server that isn't expected or handled"); @@ -145,15 +151,16 @@ pub fn request_content_canvas(gam_cid: xous::CID, requestor_name: &str) -> Resul }; let rkyv = api::Opcode::RequestContentCanvas(req); - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&rkyv).expect("GAM_API: couldn't archive RequestContentCanvas"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); + + let pos = writer.serialize_value(&rkyv).expect("GAM_API: couldn't archive RequestContentCanvas"); let mut xous_buffer = writer.into_inner(); xous_buffer.lend_mut(gam_cid, pos as u32).expect("GAM_API: RequestContentCanvas operation failure"); // recover the mutable values and mirror the ones we care about back into our local structure let returned = unsafe { rkyv::archived_value::(xous_buffer.as_ref(), pos)}; if let rkyv::Archived::::RequestContentCanvas(result) = returned { - let ret: ContentCanvasRequest = result.deserialize(); + let ret: ContentCanvasRequest = result.deserialize(&mut xous::XousDeserializer).unwrap(); Ok(ret.canvas) } else { log::error!("GAM_API: request_content_canvas got a return value from the server that isn't expected or handled"); diff --git a/services/gam/src/main.rs b/services/gam/src/main.rs index 8eb263f0a..445494785 100644 --- a/services/gam/src/main.rs +++ b/services/gam/src/main.rs @@ -22,7 +22,9 @@ use core::convert::TryFrom; use heapless::FnvIndexMap; use heapless::consts::*; -use rkyv::{Unarchive, archived_value, archived_value_mut}; +use rkyv::{archived_value, archived_value_mut}; +use rkyv::Deserialize; +use rkyv::ser::Serializer; use core::pin::Pin; #[derive(Debug)] @@ -291,7 +293,7 @@ fn xmain() -> ! { }; match &*value { rkyv::Archived::::RenderTextView(rtv) => { - let mut tv = rtv.deserialize(); + let mut tv = rtv.deserialize(&mut xous::XousDeserializer).unwrap(); if debug1{info!("GAM: rendertextview {:?}", tv);} match tv.get_op() { TextOp::Nop => (), @@ -322,9 +324,8 @@ fn xmain() -> ! { tv.bounds_computed = tv_clone.bounds_computed; // pack our data back into the buffer to return - use rkyv::Write; - let mut writer = rkyv::ArchiveBuffer::new(buf); - writer.archive(&api::Opcode::RenderTextView(tv)).expect("GAM: couldn't re-archive return value"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf); + writer.serialize_value(&api::Opcode::RenderTextView(tv)).expect("GAM: couldn't re-archive return value"); canvas.do_drawn().expect("GAM: couldn't set canvas to drawn"); } else { info!("GAM: attempt to draw TextView on non-drawable canvas. Not fatal, but request ignored."); @@ -337,7 +338,7 @@ fn xmain() -> ! { }; }, rkyv::Archived::::SetCanvasBounds(rcb) => { - let mut cb: SetCanvasBoundsRequest = rcb.deserialize(); + let mut cb: SetCanvasBoundsRequest = rcb.deserialize(&mut xous::XousDeserializer).unwrap(); if debug1{info!("GAM: SetCanvasBoundsRequest {:?}", cb);} // ASSUME: // very few canvases allow dynamic resizing, so we special case these @@ -353,12 +354,11 @@ fn xmain() -> ! { cb.granted = None; } // pack our data back into the buffer to return - use rkyv::Write; - let mut writer = rkyv::ArchiveBuffer::new(buf); - writer.archive(&api::Opcode::SetCanvasBounds(cb)).expect("GAM: SetCanvasBoundsRequest couldn't re-archive return value"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf); + writer.serialize_value(&api::Opcode::SetCanvasBounds(cb)).expect("GAM: SetCanvasBoundsRequest couldn't re-archive return value"); }, rkyv::Archived::::RequestContentCanvas(rcc) => { - let mut req: ContentCanvasRequest = rcc.deserialize(); + let mut req: ContentCanvasRequest = rcc.deserialize(&mut xous::XousDeserializer).unwrap(); if debug1{info!("GAM: RequestContentCanvas {:?}", req);} // for now, we do nothing with the incoming gid value; but, in the future, we can use it // as an authentication token perhaps to control access @@ -373,9 +373,8 @@ fn xmain() -> ! { req.canvas = chatlayout.content; // pack our data back into the buffer to return - use rkyv::Write; - let mut writer = rkyv::ArchiveBuffer::new(buf); - writer.archive(&api::Opcode::RequestContentCanvas(req)).expect("GAM: RequestContentCanvas couldn't re-archive return value"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf); + writer.serialize_value(&api::Opcode::RequestContentCanvas(req)).expect("GAM: RequestContentCanvas couldn't re-archive return value"); }, _ => panic!("GAM: invalid mutable borrow message"), }; @@ -387,7 +386,7 @@ fn xmain() -> ! { }; match &*value { rkyv::Archived::::RenderObject(rtv) => { - let obj: GamObject = rtv.deserialize(); + let obj: GamObject = rtv.deserialize(&mut xous::XousDeserializer).unwrap(); if debug1{info!("GAM: renderobject {:?}", obj);} if let Some(canvas) = canvases.get_mut(&obj.canvas) { // first, figure out if we should even be drawing to this canvas. diff --git a/services/graphics-server/src/lib.rs b/services/graphics-server/src/lib.rs index 7e0b07c92..972c4b18a 100644 --- a/services/graphics-server/src/lib.rs +++ b/services/graphics-server/src/lib.rs @@ -8,7 +8,8 @@ pub use blitstr::{ClipRect, Cursor, GlyphStyle}; use xous::String; pub mod op; -use xous::{send_message, CID}; +use xous::{send_message, CID, XousDeserializer}; +use rkyv::Deserialize; use core::fmt::Write; pub fn draw_line(cid: CID, line: Line) -> Result<(), xous::Error> { @@ -134,13 +135,13 @@ pub fn draw_textview(cid: CID, tv: &mut TextView) -> Result<(), xous::Error> { let returned = unsafe { rkyv::archived_value::(xous_buffer.as_ref(), pos)}; if let rkyv::Archived::::DrawTextView(result) = returned { - let tvr: TextView = result.deserialize(); + let tvr: TextView = result.deserialize(&mut XousDeserializer).expect("draw_textview couldn't deserialize result"); //log::info!("draw_textview: got cursor of {:?}, bounds of {:?}", tvr.cursor, tvr.bounds_computed); tv.bounds_computed = tvr.bounds_computed; tv.cursor = tvr.cursor; Ok(()) } else { - let tvr = returned.deserialize(); + let tvr = returned.deserialize(&mut XousDeserializer).expect("draw_textview couldn't deserialize result"); log::info!("draw_textview saw an unhandled return type of {:?}", tvr); Err(xous::Error::InternalError) } diff --git a/services/graphics-server/src/main.rs b/services/graphics-server/src/main.rs index b29ee4824..bd134403e 100644 --- a/services/graphics-server/src/main.rs +++ b/services/graphics-server/src/main.rs @@ -7,7 +7,9 @@ mod api; use api::{Opcode, ClipObject, ClipObjectType}; use core::pin::Pin; -use rkyv::{archived_value, Unarchive, archived_value_mut}; +use rkyv::{archived_value, archived_value_mut}; +use rkyv::Deserialize; +use rkyv::ser::Serializer; mod backend; use backend::XousDisplay; @@ -107,7 +109,7 @@ fn xmain() -> ! { }; match &*value { rkyv::Archived::::String(rkyv_s) => { - let s: xous::String<4096> = rkyv_s.deserialize(); + let s: xous::String<4096> = rkyv_s.deserialize(&mut xous::XousDeserializer).unwrap(); //info!("GFX: unarchived string: {:?}", s); blitstr::paint_str( display.native_buffer(), @@ -123,7 +125,7 @@ fn xmain() -> ! { //info!("GFX: string painted"); }, rkyv::Archived::::StringXor(rkyv_s) => { - let s: xous::String<4096> = rkyv_s.deserialize(); + let s: xous::String<4096> = rkyv_s.deserialize(&mut xous::XousDeserializer).unwrap(); blitstr::paint_str( display.native_buffer(), current_string_clip.into(), @@ -137,7 +139,7 @@ fn xmain() -> ! { ); }, rkyv::Archived::::DrawClipObject(rco) => { - let obj: ClipObject = rco.deserialize(); + let obj: ClipObject = rco.deserialize(&mut xous::XousDeserializer).unwrap(); if debug1{info!("GFX: DrawClipObject {:?}", obj);} match obj.obj { ClipObjectType::Line(line) => { @@ -164,7 +166,7 @@ fn xmain() -> ! { let debugtv: bool = false; match &*value { rkyv::Archived::::DrawTextView(rtv) => { - let mut tv = rtv.deserialize(); + let mut tv = rtv.deserialize(&mut xous::XousDeserializer).unwrap(); if tv.clip_rect.is_none() { continue } // if no clipping rectangle is specified, nothing to draw let clip_rect = tv.clip_rect.unwrap(); // this is the clipping rectangle of the canvas @@ -367,9 +369,8 @@ fn xmain() -> ! { if debugtv{info!("GFX(TV): returning cursor of {:?}", tv.cursor);} // pack our data back into the buffer to return - use rkyv::Write; - let mut writer = rkyv::ArchiveBuffer::new(buf); - writer.archive(&api::Opcode::DrawTextView(tv)).expect("GFX: couldn't re-archive return value"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf); + writer.serialize_value(&api::Opcode::DrawTextView(tv)).expect("GFX: couldn't re-archive return value"); }, _ => panic!("GFX: invalid mutable borrow message"), }; diff --git a/services/ime-frontend/src/main.rs b/services/ime-frontend/src/main.rs index 467fc757b..77ecf56d6 100644 --- a/services/ime-frontend/src/main.rs +++ b/services/ime-frontend/src/main.rs @@ -15,7 +15,7 @@ use blitstr_ref as blitstr; use core::pin::Pin; use ime_plugin_api::{PredictionTriggers, PredictionPlugin, PredictionApi}; -use rkyv::Serialize, rkyv::Deserialize; +use rkyv::Deserialize; use rkyv::archived_value; use heapless::Vec; @@ -621,14 +621,14 @@ fn xmain() -> ! { }; match &*value { rkyv::Archived::::SetPredictionServer(rkyv_s) => { - let s: xous::String<256> = rkyv_s.deserialize(); + let s: xous::String<256> = rkyv_s.deserialize(&mut xous::XousDeserializer).unwrap(); match xous_names::request_connection(s.as_str().expect("IMEF: SetPrediction received malformed server name")) { Ok(pc) => tracker.set_predictor(ime_plugin_api::PredictionPlugin {connection: Some(pc)}), _ => error!("IMEF: can't find predictive engine {}, retaining existing one.", s.as_str().expect("IMEF: SetPrediction received malformed server name")), } }, rkyv::Archived::::RegisterListener(registration) => { - let s: xous::String<256> = registration.deserialize(); + let s: xous::String<256> = registration.deserialize(&mut xous::XousDeserializer).unwrap(); if dbglistener{info!("IMEF: registering listener {:?}", s);} // note second copy down below, this is put in early-init because we're likely to get these requests early on let cid = xous_names::request_connection_blocking(s.as_str().expect("IMEF: can't decode RegisterListener string")) @@ -677,14 +677,14 @@ fn xmain() -> ! { }; match &*value { rkyv::Archived::::SetPredictionServer(rkyv_s) => { - let s: xous::String<256> = rkyv_s.deserialize(); + let s: xous::String<256> = rkyv_s.deserialize(&mut xous::XousDeserializer).unwrap(); match xous_names::request_connection(s.as_str().expect("IMEF: SetPrediction received malformed server name")) { Ok(pc) => tracker.set_predictor(ime_plugin_api::PredictionPlugin {connection: Some(pc)}), _ => error!("IMEF: can't find predictive engine {}, retaining existing one.", s.as_str().expect("IMEF: SetPrediction received malformed server name")), } }, rkyv::Archived::::RegisterListener(registration) => { - let s: xous::String<256> = registration.deserialize(); + let s: xous::String<256> = registration.deserialize(&mut xous::XousDeserializer).unwrap(); if dbglistener{info!("IMEF: registering listener {:?}", s);} // note first copy above, put in early-init because we're likely to get these requests early on let cid = xous_names::request_connection_blocking(s.as_str().expect("IMEF: can't decode RegisterListener string")) @@ -700,10 +700,11 @@ fn xmain() -> ! { if let Some(line) = tracker.update(keys).expect("IMEF: couldn't update input tracker with latest key presses") { if dbglistener{info!("IMEF: sending listeners {:?}", line);} for &conn in listeners.iter() { - use rkyv::Write; let op = ImefOpcode::GotInputLine(line); - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&op).expect("IMEF: couldn't archive line for sending"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); + + use rkyv::ser::Serializer; + let pos = writer.serialize_value(&op).expect("IMEF: couldn't archive line for sending"); if dbglistener{info!("IMEF: sending to conn {:?}", conn);} writer.into_inner().lend(conn, pos as u32).expect("IMEF: couldn't send input line to listener"); } diff --git a/services/ime-plugin-api/src/lib.rs b/services/ime-plugin-api/src/lib.rs index db7e18a70..2700e9f55 100644 --- a/services/ime-plugin-api/src/lib.rs +++ b/services/ime-plugin-api/src/lib.rs @@ -2,6 +2,7 @@ use xous::{Message, ScalarMessage, String, CID}; use graphics_server::Gid; +use rkyv::ser::Serializer; #[derive(Debug, rkyv::Archive, rkyv::Serialize, rkyv::Deserialize)] pub struct Prediction { @@ -137,12 +138,12 @@ impl PredictionApi for PredictionPlugin { } fn set_input(&self, s: String<4000>) -> Result<(), xous::Error> { - use rkyv::Write; match self.connection { Some(cid) => { let rkyv_input = Opcode::Input(s); - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&rkyv_input).expect("IME|API: couldn't archive input string"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); + + let pos = writer.serialize_value(&rkyv_input).expect("IME|API: couldn't archive input string"); let xous_buffer = writer.into_inner(); xous_buffer.lend(cid, pos as u32).expect("IME|API: set_input operation failure"); @@ -153,12 +154,12 @@ impl PredictionApi for PredictionPlugin { } fn feedback_picked(&self, s: String<4000>) -> Result<(), xous::Error> { - use rkyv::Write; match self.connection { Some(cid) => { let rkyv_picked = Opcode::Picked(s); - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&rkyv_picked).expect("IME|API: couldn't archive picked string"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); + + let pos = writer.serialize_value(&rkyv_picked).expect("IME|API: couldn't archive picked string"); let xous_buffer = writer.into_inner(); xous_buffer.lend(cid, pos as u32).expect("IME|API: feedback_picked operation failure"); @@ -169,8 +170,7 @@ impl PredictionApi for PredictionPlugin { } fn get_prediction(&self, index: u32) -> Result>, xous::Error> { - use rkyv::Write; - use rkyv::Serialize, rkyv::Deserialize; + use rkyv::Deserialize; let debug1 = false; match self.connection { Some(cid) => { @@ -181,8 +181,9 @@ impl PredictionApi for PredictionPlugin { valid: false, }; let pred_op = Opcode::Prediction(prediction); - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&pred_op).expect("IME|API: couldn't archive prediction request"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); + + let pos = writer.serialize_value(&pred_op).expect("IME|API: couldn't archive prediction request"); let mut xous_buffer = writer.into_inner(); if debug1{log::info!("IME|API: lending Prediction with pos {}", pos);} @@ -191,7 +192,7 @@ impl PredictionApi for PredictionPlugin { if debug1{log::info!("IME|API: returned from get_prediction");} let returned = unsafe { rkyv::archived_value::(xous_buffer.as_ref(), pos)}; if let rkyv::Archived::::Prediction(result) = returned { - let pred_r: Prediction = result.deserialize(); + let pred_r: Prediction = result.deserialize(&mut xous::XousDeserializer).unwrap(); if debug1{log::info!("IME|API: got {:?}", pred_r);} if pred_r.valid { let mut ret = xous::String::<4000>::new(); @@ -202,7 +203,7 @@ impl PredictionApi for PredictionPlugin { Ok(None) } } else { - let r = returned.deserialize(); + let r = returned.deserialize(&mut xous::XousDeserializer).unwrap(); log::error!("IME: API get_prediction returned an invalid result {:?}", r); Err(xous::Error::InvalidString) } @@ -306,9 +307,9 @@ impl ImeFrontEndApi for ImeFrontEnd { write!(server, "{}", servername).expect("IMEF: couldn't write set_predictor server name"); let ime_op = ImefOpcode::SetPredictionServer(server); - use rkyv::Write as ArchiveWrite; - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&ime_op).expect("IMEF: couldn't archive SetPredictionServer"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); + + let pos = writer.serialize_value(&ime_op).expect("IMEF: couldn't archive SetPredictionServer"); writer.into_inner().lend(cid, pos as u32).expect("IMEF: SetPredictionServer request failure"); Ok(()) }, @@ -324,9 +325,9 @@ impl ImeFrontEndApi for ImeFrontEnd { write!(server, "{}", servername).expect("IMEF: couldn't write set_predictor server name"); let ime_op = ImefOpcode::RegisterListener(server); - use rkyv::Write as ArchiveWrite; - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&ime_op).expect("IMEF: couldn't archive SetPredictionServer"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(xous::XousBuffer::new(4096)); + + let pos = writer.serialize_value(&ime_op).expect("IMEF: couldn't archive SetPredictionServer"); writer.into_inner().lend(cid, pos as u32).expect("IMEF: SetPredicitonServer request failure"); Ok(()) }, diff --git a/services/ime-plugin-shell/src/main.rs b/services/ime-plugin-shell/src/main.rs index a6cc3f993..bd085f82f 100644 --- a/services/ime-plugin-shell/src/main.rs +++ b/services/ime-plugin-shell/src/main.rs @@ -8,7 +8,8 @@ use log::{error, info}; use heapless::spsc::Queue; use heapless::consts::U4; -use rkyv::Serialize, rkyv::Deserialize; +use rkyv::Deserialize; +use rkyv::ser::Serializer; use core::pin::Pin; use rkyv::{archived_value, archived_value_mut}; @@ -59,7 +60,7 @@ fn xmain() -> ! { // the picked results }, rkyv::Archived::::Picked(rkyv_s) => { - let s: xous::String<4000> = rkyv_s.deserialize(); + let s: xous::String<4000> = rkyv_s.deserialize(&mut xous::XousDeserializer).unwrap(); let mut local_s: xous::String<64> = xous::String::new(); use core::fmt::Write; write!(local_s, "{:32}", s).expect("IME_SH: overflowed history variable"); @@ -79,7 +80,7 @@ fn xmain() -> ! { }; match &*value { rkyv::Archived::::Prediction(pred_r) => { - let mut prediction: Prediction = pred_r.deserialize(); + let mut prediction: Prediction = pred_r.deserialize(&mut xous::XousDeserializer).unwrap(); if debug1{info!("IME_SH: querying prediction index {}", prediction.index);} if debug1{info!("IME_SH: {:?}", prediction);} if history.len() > 0 && ((prediction.index as usize) < history.len()) { @@ -131,10 +132,9 @@ fn xmain() -> ! { if debug1{info!("IME_SH: returning index {} string {:?}", prediction.index, prediction.string);} // pack our data back into the buffer to return - use rkyv::Write; let ret_op = Opcode::Prediction(prediction); - let mut writer = rkyv::ArchiveBuffer::new(buf); - let _pos = writer.archive(&ret_op).expect("IME_SH: Prediction query couldn't re-archive return value"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf); + let _pos = writer.serialize_value(&ret_op).expect("IME_SH: Prediction query couldn't re-archive return value"); if debug1{info!("IME_SH: archived with pos {}", _pos);} }, _ => error!("IME_SH: Got invalid MutableBorrow") diff --git a/services/llio/Cargo.toml b/services/llio/Cargo.toml index 37aed0c2a..ccb520313 100644 --- a/services/llio/Cargo.toml +++ b/services/llio/Cargo.toml @@ -12,7 +12,11 @@ log-server = { path = "../log-server" } ticktimer-server = { path = "../ticktimer-server" } xous-names = { path = "../xous-names" } log = "0.4" -rkyv = { version = "0.3.1", default_features = false } + +[dependencies.rkyv] +version = "0.4.1" +default-features = false +features = ["const_generics"] [target.'cfg(not(any(windows,unix)))'.dependencies] utralib = { path = "../../utralib"} diff --git a/services/llio/src/lib.rs b/services/llio/src/lib.rs index 3b225f223..6d757934d 100644 --- a/services/llio/src/lib.rs +++ b/services/llio/src/lib.rs @@ -4,8 +4,9 @@ /// are calling these functions inside a different process. pub mod api; use api::*; +use rkyv::Deserialize; -use xous::{send_message, CID}; +use xous::{send_message, CID, XousDeserializer}; // used by the LLIO to send a response to other servers pub fn send_i2c_response(cid: CID, transaction: I2cTransaction) -> Result<(), xous::Error> { @@ -28,13 +29,13 @@ pub fn send_i2c_request(cid: CID, transaction: I2cTransaction) -> Result(buf.as_ref(), pos)}; if let rkyv::Archived::::I2cTxRx(result) = returned { - let transaction = result.deserialise(); + let transaction = result.deserialize(&mut XousDeserializer).expect("LLIO_API: Can't deserialize result in send_i2c_request"); Ok(transaction.status()) } else { log::info!("send_i2c_request saw an unhandled return type of {:?}", buf); diff --git a/services/llio/src/main.rs b/services/llio/src/main.rs index 9ec5206d2..9d845386a 100644 --- a/services/llio/src/main.rs +++ b/services/llio/src/main.rs @@ -9,7 +9,8 @@ use i2c::*; use core::convert::TryFrom; use core::pin::Pin; use rkyv::archived_value; -use rkyv::Unarchive; +use rkyv::ser::Serializer; +use rkyv::Deserialize; use log::{error, info}; @@ -597,15 +598,16 @@ fn xmain() -> ! { }; match &*value { rkyv::Archived::::I2cTxRx(rkyv_i2c) => { - let mut i2c_txrx: I2cTransaction = rkyv_i2c.deserialize(); + let mut i2c_txrx: I2cTransaction = rkyv_i2c.deserialize(&mut xous::XousDeserializer).unwrap(); let status = i2c_machine.initiate(i2c_txrx); i2c_txrx.status = status; // pack our data back into the buffer to return - use rkyv::Write; - let mut writer = rkyv::ArchiveBuffer::new(buf); - writer.archive(&Opcode::I2cTxRx(i2c_txrx)).expect("LLIO: couldn't re-archive return value to I2cTxRx"); + let mut writer = rkyv::ser::serializers::BufferSerializer::new(buf); + let pos = writer + .serialize_value(&Opcode::I2cTxRx(i2c_txrx)) + .expect("LLIO: couldn't archive self"); }, _ => panic!("LLIO: invalid MutableBorrow memory message") }; @@ -617,7 +619,7 @@ fn xmain() -> ! { }; match &*value { rkyv::Archived::::I2cSubscribe(registration) => { - let reg: xous::String::<64> = registration.unarchive(); + let reg: xous::String::<64> = registration.deserialize(&mut xous::XousDeserializer).unwrap(); let cid = xous_names::request_connection_blocking(reg.to_str()).expect("KBD: can't connect to requested listener for reporting events"); i2c_machine.register_listener(cid).expect("LLIO: probably ran out of slots for I2C event reporting"); }, diff --git a/services/shellchat/Cargo.toml b/services/shellchat/Cargo.toml index 72f3f5764..d955d7cef 100644 --- a/services/shellchat/Cargo.toml +++ b/services/shellchat/Cargo.toml @@ -16,10 +16,13 @@ graphics-server = {path="../graphics-server"} ime-plugin-api = {path="../ime-plugin-api"} content-plugin-api = {path="../content-plugin-api"} # all content canvas providers must provide this API log = "0.4" -rkyv = { version = "0.3.1", default_features = false } com={path="../com"} llio={path="../llio"} +[dependencies.rkyv] +version = "0.4.1" +default-features = false +features = ["const_generics"] [target.'cfg(not(any(windows,unix)))'.dependencies] utralib = { path = "../../utralib"} diff --git a/services/shellchat/src/main.rs b/services/shellchat/src/main.rs index f4c1df640..fc52792a2 100644 --- a/services/shellchat/src/main.rs +++ b/services/shellchat/src/main.rs @@ -6,7 +6,7 @@ use log::{error, info}; use core::fmt::Write; use core::convert::TryFrom; -use rkyv::Serialize, rkyv::Deserialize; +use rkyv::Deserialize; use rkyv::archived_value; use core::pin::Pin; @@ -220,7 +220,7 @@ fn xmain() -> ! { }; match &*value { rkyv::Archived::::GotInputLine(rkyv_s) => { - let s: xous::String<4000> = rkyv_s.deserialize(); + let s: xous::String<4000> = rkyv_s.deserialize(&mut xous::XousDeserializer).unwrap(); repl.input(s.as_str().expect("SHCH: couldn't convert incoming string")).expect("SHCH: REPL couldn't accept input string"); update_repl = true; // set a flag, instead of calling here, so message can drop and calling server is released }, diff --git a/services/xous-names/src/api.rs b/services/xous-names/src/api.rs index b082742cb..52a5c3bda 100644 --- a/services/xous-names/src/api.rs +++ b/services/xous-names/src/api.rs @@ -1,6 +1,7 @@ #![allow(dead_code)] use xous::CID; +use hash32::{Hash, Hasher}; // bottom 16 bits are reserved for structure re-use by other servers pub const ID_REGISTER_NAME: u32 = 0x1_0000; @@ -86,6 +87,52 @@ impl XousServerName { }) .unwrap() } + pub fn new() -> XousServerName { + XousServerName { + value: [0; 64], + length: 0, + } + } + + pub fn from_str(src: &str) -> XousServerName { + let mut s = Self::new(); + // Copy the string into our backing store. + for (&src_byte, dest_byte) in src.as_bytes().iter().zip(&mut s.value) { + *dest_byte = src_byte; + } + // Set the string length to the length of the passed-in String, + // or the maximum possible length. Which ever is smaller. + s.length = s.value.len().min(src.as_bytes().len()) as u32; + + // If the string is not valid, set its length to 0. + if s.as_str().is_err() { + s.length = 0; + } + + s + } + + pub fn as_bytes(&self) -> [u8; 64] { + self.value + } + + pub fn as_str(&self) -> core::result::Result<&str, core::str::Utf8Error> { + core::str::from_utf8(&self.value[0..self.length as usize]) + } + + pub fn len(&self) -> usize { + self.length as usize + } + + pub fn is_empty(&self) -> bool { + self.length == 0 + } + + /// Clear the contents and set the length to 0 + pub fn clear(&mut self) { + self.length = 0; + self.value = [0; 64]; + } } // Allow using the `write!()` macro to write into a `&XousServerName` diff --git a/services/xous-names/src/main.rs b/services/xous-names/src/main.rs index 559be334d..4274895cd 100644 --- a/services/xous-names/src/main.rs +++ b/services/xous-names/src/main.rs @@ -4,6 +4,7 @@ extern crate hash32_derive; mod api; +use api::*; use xous::buffer; // use heapless::String; @@ -44,7 +45,7 @@ fn xmain() -> ! { }; let new_value = match &*value { rkyv::Archived::::Register(registration_name) => { - let name = xous::String::<64>::from_str(registration_name.as_str()); + let name = XousServerName::from_str(registration_name.as_str()); if debug1{info!("NS: registration request for '{}'", name);} if !name_table.contains_key(&name) { let new_sid = @@ -70,7 +71,7 @@ fn xmain() -> ! { } } rkyv::Archived::::Lookup(lookup_name) => { - let name = xous::String::<64>::from_str(lookup_name.as_str()); + let name = XousServerName::from_str(lookup_name.as_str()); if debug1{info!("NS: Lookup request for '{}'", name);} if let Some(server_sid) = name_table.get(&name) { let sender_pid = envelope diff --git a/xous-rs/src/string.rs b/xous-rs/src/string.rs index df95a0538..230033568 100644 --- a/xous-rs/src/string.rs +++ b/xous-rs/src/string.rs @@ -274,6 +274,12 @@ impl rkyv::Serialize for S }) } } +use rkyv::Fallible; +impl rkyv::Deserialize, D> for ArchivedString { + fn deserialize(&self, _deserializer: &mut D) -> core::result::Result, D::Error> { + Ok(String::::from_str(self.as_str())) + } +} impl PartialEq for String { fn eq(&self, other: &Self) -> bool { @@ -282,4 +288,11 @@ impl PartialEq for String { } } -impl Eq for String {} \ No newline at end of file +impl Eq for String {} + +// a "no-op" deserializer for in-place data, required for rkyv 0.4.1 +// perhaps in rkyv 0.5 this will go away, see https://github.com/djkoloski/rkyv/issues/67 +pub struct XousDeserializer; +impl rkyv::Fallible for XousDeserializer { + type Error = crate::Error; +} \ No newline at end of file