learn: prototype sandlock learn subcommand

crates/sandlock-cli/Cargo.toml

@@ -21,6 +21,6 @@ serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 jiff = "0.2"
 libc = "0.2"
+tempfile = "3"
 
 [dev-dependencies]
-tempfile = "3"

crates/sandlock-cli/src/main.rs

@@ -7,6 +7,7 @@ use std::path::PathBuf;
 use std::time::SystemTime;
 
 mod network_registry;
+mod learn;
 
 #[derive(Parser)]
 #[command(name = "sandlock", about = "Lightweight process sandbox", version)]
@@ -33,6 +34,8 @@ enum Command {
         #[command(subcommand)]
         action: ProfileAction,
     },
+    /// Observe a workload and emit a sandlock profile
+    Learn(LearnArgs),
 }
 
 /// Arguments for the `run` subcommand.
@@ -200,6 +203,22 @@ enum ProfileAction {
     Delete { name: String },
 }
 
+/// Arguments for the `learn` subcommand.
+#[derive(clap::Args)]
+struct LearnArgs {
+    /// Write observed profile to this file (default: print to stdout)
+    #[arg(short = 'o', long, value_name = "PATH")]
+    output: Option<PathBuf>,
+
+    /// Kill the observed process after this many seconds and write a partial profile
+    #[arg(long, value_name = "SECS")]
+    timeout: Option<u64>,
+
+    /// Command to observe (everything after --)
+    #[arg(last = true, required = true)]
+    cmd: Vec<String>,
+}
+
 #[derive(serde::Serialize)]
 struct SandboxStatus {
     exit_code: i32,
@@ -303,6 +322,10 @@ async fn main() -> Result<()> {
             println!("  Platform: {}", std::env::consts::ARCH);
         }
 
+        Command::Learn(args) => {
+            learn::run(args).await?;
+        }
+
         Command::Profile { action } => {
             match action {
                 ProfileAction::List => {

crates/sandlock-core/src/policy_fn.rs

@@ -105,6 +105,18 @@ pub struct SyscallEvent {
     pub argv: Option<Vec<String>>,
     /// Whether the supervisor denied this syscall.
     pub denied: bool,
+    /// Resolved absolute path for file syscalls (openat, execve/execveat,
+    /// mkdirat, unlinkat, symlinkat, truncate, renameat2 src, linkat src).
+    /// Read from child user memory, not TOCTOU-safe for enforcement but
+    /// sufficient for learn-mode observation.
+    /// `None` for non-file syscalls or when resolution fails.
+    pub path: Option<std::path::PathBuf>,
+    /// Second resolved path for two-path syscalls (renameat2 dst, linkat dst).
+    /// `None` for single-path syscalls.
+    pub path2: Option<std::path::PathBuf>,
+    /// Open flags for openat (the `flags` argument, e.g. `O_RDONLY`,
+    /// `O_WRONLY`, `O_CREAT`). `None` for non-openat syscalls.
+    pub flags: Option<u64>,
 }
 
 impl SyscallEvent {
@@ -483,6 +495,9 @@ mod tests {
             size: None,
             argv: Some(vec!["python3".into(), "-c".into(), "print(1)".into()]),
             denied: false,
+            path: None,
+            path2: None,
+            flags: None,
         };
         assert!(event.argv_contains("python3"));
         assert!(event.argv_contains("-c"));
@@ -502,6 +517,9 @@ mod tests {
             size: None,
             argv: None,
             denied: false,
+            path: None,
+            path2: None,
+            flags: None,
         };
         assert!(!event.argv_contains("anything"));
     }

crates/sandlock-core/src/profile.rs

@@ -1,6 +1,6 @@
 use crate::sandbox::{ByteSize, Sandbox};
 use crate::error::SandlockError;
-use serde::Deserialize;
+use serde::{Deserialize, Serialize};
 use std::path::PathBuf;
 use std::collections::HashMap;
 use std::time::SystemTime;
@@ -14,129 +14,191 @@ pub struct ProgramSpec {
 }
 
 /// Top-level profile input. Each section maps to one schema section.
-#[derive(Debug, Clone, Default, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq)]
 #[serde(deny_unknown_fields, default)]
 pub struct ProfileInput {
+    #[serde(skip_serializing_if = "is_default")]
     pub config: ConfigSection,
+    #[serde(skip_serializing_if = "is_default")]
     pub determinism: DeterminismSection,
+    #[serde(skip_serializing_if = "is_default")]
     pub program: ProgramSection,
+    #[serde(skip_serializing_if = "is_default")]
     pub filesystem: FilesystemSection,
+    #[serde(skip_serializing_if = "is_default")]
     pub network: NetworkSection,
+    #[serde(skip_serializing_if = "is_default")]
     pub http: HttpSection,
+    #[serde(skip_serializing_if = "is_default")]
     pub syscalls: SyscallsSection,
+    #[serde(skip_serializing_if = "is_default")]
     pub limits: LimitsSection,
 }
 
+fn is_false(b: &bool) -> bool { !b }
+fn is_default<T: Default + PartialEq>(v: &T) -> bool { *v == T::default() }
+
 // Field names follow the schema vocabulary and match `Sandbox`'s field names 1:1.
-#[derive(Debug, Clone, Default, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq)]
 #[serde(deny_unknown_fields, default)]
 pub struct ConfigSection {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub http_ca: Option<PathBuf>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub http_key: Option<PathBuf>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub http_inject_ca: Vec<PathBuf>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub http_ca_out: Option<PathBuf>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub fs_storage: Option<PathBuf>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub workdir: Option<PathBuf>,
 }
 
-#[derive(Debug, Clone, Default, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq)]
 #[serde(deny_unknown_fields, default)]
 pub struct DeterminismSection {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub random_seed: Option<u64>,
     /// RFC3339 timestamp string. Maps to `Sandbox::time_start`.
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub time_start: Option<String>,
+    #[serde(skip_serializing_if = "is_false")]
     pub deterministic_dirs: bool,
+    #[serde(skip_serializing_if = "is_false")]
     pub no_randomize_memory: bool,
 }
 
-#[derive(Debug, Clone, Default, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq)]
 #[serde(deny_unknown_fields, default)]
 pub struct ProgramSection {
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub exec: Option<PathBuf>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub args: Vec<String>,
+    #[serde(skip_serializing_if = "HashMap::is_empty")]
     pub env: HashMap<String, String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub cwd: Option<PathBuf>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub uid: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub gid: Option<u32>,
+    #[serde(skip_serializing_if = "is_false")]
     pub clean_env: bool,
+    #[serde(skip_serializing_if = "is_false")]
     pub no_coredump: bool,
+    #[serde(skip_serializing_if = "is_false")]
     pub no_huge_pages: bool,
 }
 
-#[derive(Debug, Clone, Default, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq)]
 #[serde(deny_unknown_fields, default)]
 pub struct FilesystemSection {
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub read: Vec<PathBuf>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub write: Vec<PathBuf>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub deny: Vec<PathBuf>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub chroot: Option<PathBuf>,
     /// Each entry has the form `"VIRTUAL:HOST"`, matching `--fs-mount` syntax.
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub mount: Vec<String>,
     /// One of `"commit"`, `"abort"`, `"keep"`. Maps to `Sandbox::on_exit`.
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub on_exit: Option<String>,
     /// One of `"commit"`, `"abort"`, `"keep"`. Maps to `Sandbox::on_error`.
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub on_error: Option<String>,
 }
 
 /// One `[network].allow_bind` entry: a bare integer port (`8080`) or a
 /// quoted string holding a comma list and/or `lo-hi` range (`"9000-9005"`).
 /// The untagged form lets a TOML array mix the two, e.g.
 /// `allow_bind = [8080, "9000-9005"]`.
-#[derive(Debug, Clone, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
 #[serde(untagged)]
 pub enum PortSpec {
     Port(u16),
     Spec(String),
 }
 
-#[derive(Debug, Clone, Default, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq)]
 #[serde(deny_unknown_fields, default)]
 pub struct NetworkSection {
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub allow_bind: Vec<PortSpec>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub deny_bind: Vec<PortSpec>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub allow: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub deny: Vec<String>,
+    #[serde(skip_serializing_if = "is_false")]
     pub port_remap: bool,
 }
 
-#[derive(Debug, Clone, Default, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq)]
 #[serde(deny_unknown_fields, default)]
 pub struct HttpSection {
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub ports: Vec<u16>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub allow: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub deny: Vec<String>,
 }
 
-#[derive(Debug, Clone, Default, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq)]
 #[serde(deny_unknown_fields, default)]
 pub struct SyscallsSection {
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub extra_allow: Vec<String>,
+    #[serde(skip_serializing_if = "Vec::is_empty")]
     pub extra_deny: Vec<String>,
 }
 
 // Field names drop the `max_` prefix that `Sandbox` uses (`memory`, not
 // `max_memory`) — the section name `[limits]` makes the prefix redundant.
 // `parse_input` maps each of these to the corresponding `Sandbox::max_*` field.
-#[derive(Debug, Clone, Default, Deserialize, PartialEq)]
+#[derive(Debug, Clone, Default, Deserialize, Serialize, PartialEq)]
 #[serde(deny_unknown_fields, default)]
 pub struct LimitsSection {
     /// `ByteSize` string, e.g. `"512M"` (suffixes K/M/G only; IEC `MiB`/`GiB`
     /// not yet supported). Maps to `Sandbox::max_memory`.
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub memory: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub processes: Option<u32>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub open_files: Option<u32>,
     /// CPU cap as a percentage (0–100). Maps to `Sandbox::max_cpu`.
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub cpu: Option<u8>,
     /// `ByteSize` string, e.g. `"256M"` (suffixes K/M/G only; IEC `MiB`/`GiB`
     /// not yet supported). Maps to `Sandbox::max_disk`.
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub disk: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub gpu_devices: Option<Vec<u32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub cpu_cores: Option<Vec<u32>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
     pub num_cpus: Option<u32>,
 }
 
 /// Convert a parsed `ProfileInput` into a `(Sandbox, ProgramSpec)` pair.
 ///
+impl ProfileInput {
+    /// Serialize the profile to a TOML string.
+    pub fn to_toml(&self) -> Result<String, toml::ser::Error> {
+        toml::to_string(self)
+    }
+}
+
 /// Forwards each schema section's fields to the corresponding `SandboxBuilder`
 /// method calls. The two private helpers (`parse_branch_action`,
 /// `parse_mount_spec`) handle string-to-typed-value conversions for fields

crates/sandlock-core/src/sandbox/builder.rs

@@ -197,6 +197,7 @@ pub struct SandboxBuilder {
     // COW fork work function: runs in each COW clone.
     #[cfg_attr(feature = "cli", clap(skip))]
     pub(crate) work_fn: Option<Arc<dyn Fn(u32) + Send + Sync + 'static>>,
+
 }
 
 impl std::fmt::Debug for SandboxBuilder {