feat: add log-server (ring buffer) and permission-manager (grant/revoke/check) system servers

crates/servers/log-server/src/protocol.rs

@@ -0,0 +1,99 @@
+use server_framework::{Decode, Encode};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum LogLevel {
+    Error,
+    Warn,
+    Info,
+    Debug,
+}
+
+#[derive(Debug, PartialEq)]
+pub enum LogRequest {
+    Write { level: LogLevel, tag: u16, payload: usize },
+    GetCount,
+    GetEntry { index: usize },
+}
+
+#[derive(Debug, PartialEq)]
+pub enum LogResponse {
+    Ok,
+    Count(usize),
+    Entry { level: LogLevel, tag: u16, payload: usize },
+    NotFound,
+}
+
+fn encode_level(level: LogLevel) -> usize {
+    match level {
+        LogLevel::Error => 0,
+        LogLevel::Warn => 1,
+        LogLevel::Info => 2,
+        LogLevel::Debug => 3,
+    }
+}
+
+fn decode_level(v: usize) -> Option<LogLevel> {
+    match v {
+        0 => Some(LogLevel::Error),
+        1 => Some(LogLevel::Warn),
+        2 => Some(LogLevel::Info),
+        3 => Some(LogLevel::Debug),
+        _ => None,
+    }
+}
+
+impl Encode for LogRequest {
+    fn encode(&self) -> [usize; 4] {
+        match self {
+            LogRequest::Write { level, tag, payload } => {
+                [0, encode_level(*level) | ((*tag as usize) << 8), *payload, 0]
+            }
+            LogRequest::GetCount => [1, 0, 0, 0],
+            LogRequest::GetEntry { index } => [2, *index, 0, 0],
+        }
+    }
+}
+
+impl Decode for LogRequest {
+    fn decode(words: [usize; 4]) -> Option<Self> {
+        match words[0] {
+            0 => {
+                let level = decode_level(words[1] & 0xFF)?;
+                let tag = ((words[1] >> 8) & 0xFFFF) as u16;
+                Some(LogRequest::Write { level, tag, payload: words[2] })
+            }
+            1 => Some(LogRequest::GetCount),
+            2 => Some(LogRequest::GetEntry { index: words[1] }),
+            _ => None,
+        }
+    }
+}
+
+impl Encode for LogResponse {
+    fn encode(&self) -> [usize; 4] {
+        match self {
+            LogResponse::Ok => [0, 0, 0, 0],
+            LogResponse::Count(n) => [1, *n, 0, 0],
+            LogResponse::Entry { level, tag, payload } => {
+                [2, encode_level(*level) | ((*tag as usize) << 8), *payload, 0]
+            }
+            LogResponse::NotFound => [3, 0, 0, 0],
+        }
+    }
+}
+
+impl Decode for LogResponse {
+    fn decode(words: [usize; 4]) -> Option<Self> {
+        match words[0] {
+            0 => Some(LogResponse::Ok),
+            1 => Some(LogResponse::Count(words[1])),
+            2 => {
+                let level = decode_level(words[1] & 0xFF)?;
+                let tag = ((words[1] >> 8) & 0xFFFF) as u16;
+                Some(LogResponse::Entry { level, tag, payload: words[2] })
+            }
+            3 => Some(LogResponse::NotFound),
+            _ => None,
+        }
+    }
+}