From 9857a9bcb2e0cd843c03f8ea362fd318a2c9c59b Mon Sep 17 00:00:00 2001 From: Marko Vejnovic Date: Mon, 16 Nov 2026 02:47:43 +0000 Subject: [PATCH] refactor(suidhelper): derive fork_delta's metadata device from the pool The caller no longer names the metadata device: the helper opens the one the pool's live table names, at /dev/ from sysfs, and refuses a node there that is not that device. A foreign pool's metadata can no longer be passed in at all, so the request loses its meta field and ThinPool stops tracking its metadata loop. --- lib/hyper/node/img/thin_pool.ex | 13 +- lib/hyper/suid_helper/fork_delta.ex | 5 +- native/.cargo/mutants.toml | 4 - native/hyperrs-fs/src/dev.rs | 149 +++++++++++++++++- native/suidhelper/src/cli/fork_delta.rs | 31 +--- native/suidhelper/src/cli/mod.rs | 7 +- native/suidhelper/tests/e2e/dm_hostile.rs | 40 ++--- native/suidhelper/tests/e2e/fork_delta.rs | 20 +-- .../suidhelper/tests/e2e/fork_delta_live.rs | 5 +- .../suidhelper/tests/fixtures/requests.json | 2 +- test/hyper/node/img/thin_pool_test.exs | 5 +- .../suid_helper/request_contract_test.exs | 1 - 12 files changed, 186 insertions(+), 96 deletions(-) diff --git a/lib/hyper/node/img/thin_pool.ex b/lib/hyper/node/img/thin_pool.ex index 2fa4c6d5..8945a1ab 100644 --- a/lib/hyper/node/img/thin_pool.ex +++ b/lib/hyper/node/img/thin_pool.ex @@ -27,8 +27,7 @@ defmodule Hyper.Node.Img.ThinPool do defmodule State do @moduledoc false - @enforce_keys [:meta_loop] - defstruct [:meta_loop, next: 0, freed: []] + defstruct next: 0, freed: [] end @spec start_link(keyword()) :: GenServer.on_start() @@ -47,11 +46,11 @@ defmodule Hyper.Node.Img.ThinPool do {:ok, %{scanned: non_neg_integer(), written: non_neg_integer()}} | {:error, term()} @decorate with_span("Hyper.Node.Img.ThinPool.fork_delta", include: [:parent, :cow]) def fork_delta(parent, origin, cow) do - {scratch_id, meta_loop} = GenServer.call(__MODULE__, :reserve_scratch) + scratch_id = GenServer.call(__MODULE__, :reserve_scratch) result = serialized_on(parent, fn -> - SuidHelper.ForkDelta.run(@pool_name, meta_loop, parent, scratch_id, origin, cow) + SuidHelper.ForkDelta.run(@pool_name, parent, scratch_id, origin, cow) end) GenServer.call(__MODULE__, {:release_scratch, scratch_id, result}) @@ -77,9 +76,9 @@ defmodule Hyper.Node.Img.ThinPool do with :ok <- File.mkdir_p(Hyper.Cfg.Dirs.scratch_dir()), {:ok, meta} <- ensure_backing(@meta_file, ImgConfig.thin_pool_meta_size()), {:ok, data} <- ensure_backing(@data_file, ImgConfig.thin_pool_data_size()), - {:ok, _pool_dev, meta_loop} <- + {:ok, _pool_dev, _meta_loop} <- SuidHelper.Thin.create_pool(@pool_name, meta, data, ImgConfig.thin_block_sectors(), 0) do - {:ok, %State{meta_loop: meta_loop}} + {:ok, %State{}} else {:error, reason} -> {:stop, reason} end @@ -98,7 +97,7 @@ defmodule Hyper.Node.Img.ThinPool do @impl true def handle_call(:reserve_scratch, _from, state) do {id, state} = id_alloc(state) - {:reply, {id, state.meta_loop}, state} + {:reply, id, state} end @impl true diff --git a/lib/hyper/suid_helper/fork_delta.ex b/lib/hyper/suid_helper/fork_delta.ex index d6f91b77..dfeece31 100644 --- a/lib/hyper/suid_helper/fork_delta.ex +++ b/lib/hyper/suid_helper/fork_delta.ex @@ -7,14 +7,13 @@ defmodule Hyper.SuidHelper.ForkDelta do @type err :: SuidHelper.err() - @spec run(String.t(), Path.t(), String.t(), non_neg_integer(), Path.t(), Path.t()) :: + @spec run(String.t(), String.t(), non_neg_integer(), Path.t(), Path.t()) :: {:ok, %{scanned: non_neg_integer(), written: non_neg_integer()}} | {:error, err()} @decorate with_span("Hyper.SuidHelper.ForkDelta.run", include: [:parent, :cow]) - def run(pool, meta_dev, parent, scratch_id, origin, cow) do + def run(pool, parent, scratch_id, origin, cow) do request = %{ op: "thin_fork_delta", pool: pool, - meta: meta_dev, parent: parent, scratch_id: scratch_id, origin: origin, diff --git a/native/.cargo/mutants.toml b/native/.cargo/mutants.toml index 0e313c0d..6aea6231 100644 --- a/native/.cargo/mutants.toml +++ b/native/.cargo/mutants.toml @@ -26,10 +26,6 @@ exclude_re = [ "suidhelper/src/net/vm\\.rs:.*VmNet<'_>::", "suidhelper/src/cli/vm/claim\\.rs:.*SocketPin<'_>::", "suidhelper/src/cli/vm/teardown\\.rs:.*Teardown::unpin_sockets", - # The metadata-device check runs as root against a fake dmsetup; killed by suidhelper's - # a_meta_that_is_not_the_pools_metadata_is_refused_before_any_snapshot_as_root (tests/e2e/ - # fork_delta.rs) in the privileged E2E job. - "suidhelper/src/cli/fork_delta\\.rs:.*replace != with == in ::run$", # Guest network setup runs inside a booted guest; killed by test/e2e/guest_network_test.exs # in the KVM integration job. "guest-agent/src/net\\.rs:.*GuestNet::(from_proc|configure)", diff --git a/native/hyperrs-fs/src/dev.rs b/native/hyperrs-fs/src/dev.rs index b1f8cbb0..9d988c44 100644 --- a/native/hyperrs-fs/src/dev.rs +++ b/native/hyperrs-fs/src/dev.rs @@ -1,8 +1,12 @@ -use super::file::DeviceType; +use super::file::{self, Any, DeviceType, IsBlockDevice, OpenFlags, SafeFile}; +use super::path::{self, IsAbsolute, SafePath, StrictComponents}; use derive_more::{Constructor, Display}; use nix::libc::dev_t; use nix::sys::stat::{major, makedev, minor, Mode}; +use std::fs; +use std::io; use std::marker::PhantomData; +use std::path::{Path, PathBuf}; use std::str::FromStr; use thiserror::Error as ThisError; @@ -80,11 +84,93 @@ impl DeviceNode { } } +#[derive(Debug, ThisError)] +pub enum OpenDeviceError { + #[error("reading {path}: {source}")] + Sysfs { + path: PathBuf, + #[source] + source: io::Error, + }, + #[error("sysfs gives block device {dev} no DEVNAME")] + NoName { dev: DeviceNumber }, + #[error("block device {dev}'s name {name:?}: {source}")] + Name { + dev: DeviceNumber, + name: String, + #[source] + source: path::ValidationError, + }, + #[error("opening block device {dev}: {source}")] + Open { + dev: DeviceNumber, + #[source] + source: file::ValidationError, + }, + #[error("{} is block device {got}, not {want}", path.display())] + Mismatch { + path: PathBuf, + want: DeviceNumber, + got: DeviceNumber, + }, +} + +impl SafeFile { + /// Open block device `dev` at `/dev/`, the name the kernel gives it in sysfs. + /// Whatever node sits at that path must be `dev` itself, or the open is refused. + pub fn open_block(dev: DeviceNumber, flags: OpenFlags) -> Result { + let uevent = PathBuf::from(format!("/sys/dev/block/{dev}/uevent")); + let text = fs::read_to_string(&uevent).map_err(|source| OpenDeviceError::Sysfs { + path: uevent, + source, + })?; + let name = dev_name(&text).ok_or(OpenDeviceError::NoName { dev })?; + let node = Path::new("/dev").join(name); + let safe = <&SafePath>::try_from(node.as_path()).map_err( + |source| OpenDeviceError::Name { + dev, + name: name.to_owned(), + source, + }, + )?; + open_numbered(safe, dev, flags) + } +} + +fn dev_name(uevent: &str) -> Option<&str> { + uevent + .lines() + .find_map(|line| line.strip_prefix("DEVNAME=")) + .filter(|name| !name.is_empty()) +} + +fn open_numbered( + node: &SafePath, + want: DeviceNumber, + flags: OpenFlags, +) -> Result, OpenDeviceError> { + let open = |source| OpenDeviceError::Open { dev: want, source }; + let file = SafeFile::open(node, flags).map_err(open)?; + let got = file.rdev().map_err(open)?; + if got == want { + Ok(file) + } else { + Err(OpenDeviceError::Mismatch { + path: node.as_path().to_path_buf(), + want, + got, + }) + } +} + #[cfg(test)] mod tests { - use super::DeviceNumber; + use super::{dev_name, open_numbered, DeviceNumber, OpenDeviceError}; + use crate::file::{Any, IsBlockDevice, OpenFlags, SafeFile}; + use crate::path::{IsAbsolute, SafePath, StrictComponents}; use pretty_assertions::assert_eq; use rstest::rstest; + use std::path::{Path, PathBuf}; use test_strategy::proptest; #[proptest] @@ -106,4 +192,63 @@ mod tests { fn from_str_refuses_anything_but_major_colon_minor(#[case] raw: &str) { assert!(raw.parse::().is_err(), "{raw:?}"); } + + #[rstest] + #[case::loop_device("MAJOR=7\nMINOR=3\nDEVNAME=loop3\nDEVTYPE=disk\n", Some("loop3"))] + #[case::nested_name("MAJOR=104\nMINOR=0\nDEVNAME=cciss/c0d0\n", Some("cciss/c0d0"))] + #[case::first_line("DEVNAME=dm-0\n", Some("dm-0"))] + #[case::missing("MAJOR=7\nMINOR=3\n", None)] + #[case::empty_name("DEVNAME=\n", None)] + #[case::only_a_suffix_match("XDEVNAME=loop3\n", None)] + fn dev_name_is_the_devname_line_of_the_uevent( + #[case] uevent: &str, + #[case] want: Option<&str>, + ) { + assert_eq!(dev_name(uevent), want); + } + + /// Every block device the kernel lists, by number and by its `/dev` node. + fn block_devices() -> Vec<(DeviceNumber, PathBuf)> { + std::fs::read_dir("/sys/dev/block") + .unwrap() + .filter_map(|entry| { + let entry = entry.unwrap(); + let dev = entry.file_name().to_str()?.parse().ok()?; + let uevent = std::fs::read_to_string(entry.path().join("uevent")).ok()?; + let node = Path::new("/dev").join(dev_name(&uevent)?); + node.exists().then_some((dev, node)) + }) + .collect() + } + + // O_PATH needs no read permission on the node, so this runs unprivileged. + #[test] + fn open_block_yields_the_device_it_was_asked_for() { + let devices = block_devices(); + assert!(!devices.is_empty(), "no block devices in /sys/dev/block"); + for (dev, _) in devices { + let file = SafeFile::::open_block(dev, OpenFlags::PATH) + .unwrap_or_else(|e| panic!("{dev}: {e}")); + assert_eq!(file.rdev().unwrap(), dev); + } + } + + #[test] + fn a_node_that_is_another_device_is_refused() { + let devices = block_devices(); + let [(_, node), (other, _), ..] = devices.as_slice() else { + eprintln!( + "SKIP a_node_that_is_another_device_is_refused: fewer than two block devices" + ); + return; + }; + let node = <&SafePath>::try_from(node.as_path()).unwrap(); + + let got = open_numbered(node, *other, OpenFlags::PATH); + + assert!( + matches!(got, Err(OpenDeviceError::Mismatch { want, .. }) if want == *other), + "{got:?}" + ); + } } diff --git a/native/suidhelper/src/cli/fork_delta.rs b/native/suidhelper/src/cli/fork_delta.rs index 832227f3..0a047543 100644 --- a/native/suidhelper/src/cli/fork_delta.rs +++ b/native/suidhelper/src/cli/fork_delta.rs @@ -3,9 +3,8 @@ use crate::cli::MapperPath; use crate::cli::Op; use crate::config::Config; use crate::dm::{HyperDmName, HyperDmTable, NameError, TableError}; -use hyperrs_fs::dev::DeviceNumber; -use hyperrs_fs::file::{self, Any, IsBlockDevice, OpenFlags, SafeFile}; -use hyperrs_fs::path; +use hyperrs_fs::dev::OpenDeviceError; +use hyperrs_fs::file::{Any, IsBlockDevice, OpenFlags, SafeFile}; use hyperrs_linux::dm::thin_dump::{ self as dump, DumpError, MappingsError, MetadataDump, ParseError, ThinMappings, }; @@ -13,7 +12,6 @@ use hyperrs_linux::dm::{ self, DevPath, DmTable, OpenThinError, Origin, Persistence, RemoveMode, RunError, SnapshotError, SnapshotTable, ThinId, ThinMessage, ThinPoolError, }; -use hyperrs_linux::loopdev::LoopDevNum; use hyperrs_linux::Access; use hyperrs_process::binary::RootSafeBinError; use hyperrs_process::privilege::{PrivilegeError, Unprivileged}; @@ -34,7 +32,6 @@ const CHUNK_BYTES: usize = 1 << 20; #[serde(deny_unknown_fields)] pub struct ThinForkDelta { pool: HyperDmName, - meta: LoopDevNum, parent: HyperDmName, scratch_id: ThinId, #[serde_as(as = "MapperPath")] @@ -45,15 +42,8 @@ pub struct ThinForkDelta { #[derive(Debug, ThisError)] pub enum ForkDeltaError { - #[error("metadata device path: {0}")] - Path(#[from] path::ValidationError), - #[error("opening metadata device: {0}")] - Open(#[from] file::ValidationError), - #[error("{meta} is not the pool's metadata device {pool}")] - NotPoolMetadata { - meta: DeviceNumber, - pool: DeviceNumber, - }, + #[error("opening the pool's metadata device: {0}")] + Metadata(#[from] OpenDeviceError), #[error("locking metadata device: {0}")] Lock(#[source] io::Error), #[error(transparent)] @@ -106,7 +96,6 @@ impl Op for ThinForkDelta { let config = Config::get(); let dmsetup = dm::Dmsetup::new(config.dmsetup()?); let thin_dump = dump::ThinDump::new(config.thin_dump()?); - let meta = self.meta.path()?; let origin = Origin::Device((*self.origin).clone()); let target = HyperDmTable::new(DmTable::Snapshot(SnapshotTable { sectors: 0, @@ -121,14 +110,10 @@ impl Op for ThinForkDelta { let _root = token.elevate()?; let sectors = self.origin.sectors().map_err(DmError::from)?; let pool = dmsetup.thin_pool(&self.pool)?; - let meta = SafeFile::::open(&meta, OpenFlags::RDONLY)?; - let (got, want) = (meta.rdev()?, pool.metadata()); - if got != want { - return Err(ForkDeltaError::NotPoolMetadata { - meta: got, - pool: want, - }); - } + let meta = SafeFile::::open_block( + pool.metadata(), + OpenFlags::RDONLY, + )?; let snapshot = match pool.open_thin(&self.parent)?.snapshot(self.scratch_id) { Ok(snapshot) => snapshot, Err(e @ SnapshotError::Resume { created: true, .. }) => { diff --git a/native/suidhelper/src/cli/mod.rs b/native/suidhelper/src/cli/mod.rs index 1069dd43..d5a04767 100644 --- a/native/suidhelper/src/cli/mod.rs +++ b/native/suidhelper/src/cli/mod.rs @@ -222,11 +222,14 @@ mod tests { #[case::retired_prepare_op(json!({"op": "vm_prepare", "id": "v1", "uid": 900_001}))] #[case::retired_stage_op(json!({"op": "vm_stage", "id": "v1", "kernel": "/srv/hyper/vmlinux", "device": "/dev/mapper/hyper-v1", "uid": 900_001, "gid": 900_001}))] + #[case::fork_delta_caller_named_meta(json!({"op": "thin_fork_delta", "pool": "hyper-pool", + "meta": "/dev/loop3", "parent": "hyper-v1", "scratch_id": 9, + "origin": "/dev/mapper/hyper-img", "cow": "/srv/hyper/cow.img", "chunk_sectors": 8}))] #[case::fork_delta_caller_named_source(json!({"op": "thin_fork_delta", "pool": "hyper-pool", - "meta": "/dev/loop3", "parent": "hyper-v1", "scratch_id": 9, "src": "/dev/mapper/hyper-a", + "parent": "hyper-v1", "scratch_id": 9, "src": "/dev/mapper/hyper-a", "origin": "/dev/mapper/hyper-img", "cow": "/srv/hyper/cow.img", "chunk_sectors": 8}))] #[case::fork_delta_scratch_id_past_24_bits(json!({"op": "thin_fork_delta", "pool": "hyper-pool", - "meta": "/dev/loop3", "parent": "hyper-v1", "scratch_id": 16_777_216, + "parent": "hyper-v1", "scratch_id": 16_777_216, "origin": "/dev/mapper/hyper-img", "cow": "/srv/hyper/cow.img", "chunk_sectors": 8}))] #[case::retired_thin_copy_op(json!({"op": "thin_copy", "pool": "hyper-pool", "meta": "/dev/loop3", "src": "/dev/mapper/hyper-a", "origin": "/dev/mapper/hyper-img", diff --git a/native/suidhelper/tests/e2e/dm_hostile.rs b/native/suidhelper/tests/e2e/dm_hostile.rs index af2d83a6..59d92e21 100644 --- a/native/suidhelper/tests/e2e/dm_hostile.rs +++ b/native/suidhelper/tests/e2e/dm_hostile.rs @@ -2,8 +2,8 @@ //! real dm-thin pool. The caller is in the helper's group but may name any //! device, id or file it likes. Laws: //! * `thin_fork_delta` reads mappings only from the pool's own metadata -//! device: a `meta` that is not that pool's metadata is refused, never -//! dumped and copied from; +//! device, which it derives from the pool's live table: another pool holding +//! the same thin id never changes what the fork copies; //! * a `scratch_id` already provisioned in the pool is refused and the //! volume holding it keeps its id and its bytes; //! * a device the call did not create (a pre-existing `hyper-scratch-N` or @@ -93,7 +93,7 @@ fn live_table(name: &str) -> Option { struct Pool { name: String, pool: DmDevice, - meta: LoopDevice, + _meta: LoopDevice, _data: LoopDevice, } @@ -115,7 +115,7 @@ impl Pool { Some(Self { name: name.to_string(), pool, - meta, + _meta: meta, _data: data, }) } @@ -180,7 +180,7 @@ impl Live { ) } - fn fork(&self, parent: &DmDevice, scratch_id: u32, meta: &str) -> (bool, String, PathBuf) { + fn fork(&self, parent: &DmDevice, scratch_id: u32) -> (bool, String, PathBuf) { let cow = self.base.join(format!("cow-{scratch_id}.img")); sparse(&cow, 8 << 20); let out = run( @@ -188,7 +188,6 @@ impl Live { json!({ "op": "thin_fork_delta", "pool": self.a.name, - "meta": meta, "parent": parent.path().trim_start_matches("/dev/mapper/"), "scratch_id": scratch_id, "origin": self.origin.path(), @@ -234,7 +233,7 @@ macro_rules! live { } #[test] -fn fork_delta_refuses_a_meta_device_that_is_not_the_pools_metadata_as_root() { +fn fork_delta_copies_from_its_own_pool_beside_another_holding_the_same_id_as_root() { let live = live!("meta"); const SCRATCH: u32 = 700; let parent = live.parent(1); @@ -245,26 +244,13 @@ fn fork_delta_refuses_a_meta_device_that_is_not_the_pools_metadata_as_root() { let decoy = b.thin(&format!("{}-decoy", live.tag), SCRATCH, None); write_block(&decoy.path(), 5, 0x33); drop(decoy); - assert!(b.pool.message("reserve_metadata_snap")); - let (ok, stderr, cow) = live.fork(&parent, SCRATCH, b.meta.path()); - let _ = b.pool.message("release_metadata_snap"); - let detail = if ok { - format!( - "the fork succeeded and its replay {} the parent", - if live.replay(&cow) == want { - "matches" - } else { - "DIFFERS FROM" - } - ) - } else { - stderr - }; + let (ok, stderr, cow) = live.fork(&parent, SCRATCH); + + assert!(ok, "{stderr}"); assert!( - !ok, - "meta {} belongs to another pool, yet: {detail}", - b.meta.path() + live.replay(&cow) == want, + "the fork's replay differs from its parent" ); } @@ -281,7 +267,7 @@ fn fork_delta_with_a_scratch_id_in_use_leaves_that_volume_untouched_as_root(#[ca let before = read_all(&victim.path()); let table = live_table(victim.path().trim_start_matches("/dev/mapper/")); - let (ok, stderr, _) = live.fork(&parent, scratch, live.a.meta.path()); + let (ok, stderr, _) = live.fork(&parent, scratch); assert!(!ok, "a fork into a provisioned id {scratch} succeeded"); assert!( @@ -323,7 +309,7 @@ fn fork_delta_never_removes_a_device_it_did_not_create_as_root( .expect("pre-existing device"); let table = live_table(&squatter_name); - let (ok, stderr, _) = live.fork(&parent, scratch, live.a.meta.path()); + let (ok, stderr, _) = live.fork(&parent, scratch); assert!(!ok, "fork succeeded despite {squatter_name} existing"); assert_eq!( diff --git a/native/suidhelper/tests/e2e/fork_delta.rs b/native/suidhelper/tests/e2e/fork_delta.rs index 77b2a8c9..96869f1f 100644 --- a/native/suidhelper/tests/e2e/fork_delta.rs +++ b/native/suidhelper/tests/e2e/fork_delta.rs @@ -173,7 +173,6 @@ esac let mut request = json!({ "op": "thin_fork_delta", "pool": "hyper-pool", - "meta": "/dev/loop3", "parent": "hyper-vm1", "scratch_id": SCRATCH_ID, "origin": self.origin.path(), @@ -332,23 +331,7 @@ fn nothing_is_snapshotted_unless_pool_and_parent_check_out_as_root( } #[rstest] -fn a_meta_that_is_not_the_pools_metadata_is_refused_before_any_snapshot_as_root( - pool: Option, -) { - let pool = require!(pool); - - pool.fork_delta(json!({"meta": "/dev/loop4"})) - .failure() - .stderr(contains("is not the pool's metadata device 7:3")); - - assert_eq!(pool.dmsetup_calls(), [TABLE]); - assert!(!pool.thin_dump_ran()); -} - -#[rstest] -#[case::system_disk_as_meta(json!({"meta": "/dev/sda"}))] -#[case::traversing_meta(json!({"meta": "/dev/loop0/../sda"}))] -#[case::dm_device_as_meta(json!({"meta": "/dev/mapper/hyper-pool"}))] +#[case::caller_named_meta(json!({"meta": "/dev/loop3"}))] #[case::foreign_pool(json!({"pool": "vg0-pool"}))] #[case::foreign_parent(json!({"parent": "root"}))] #[case::foreign_origin(json!({"origin": "/dev/mapper/root"}))] @@ -450,7 +433,6 @@ fn forks_exactly_the_parents_provisioned_ranges_into_the_cow_store_as_root() { json!({ "op": "thin_fork_delta", "pool": pool_name, - "meta": meta.path(), "parent": parent_name, "scratch_id": REAL_POOL_SCRATCH_ID, "origin": origin.path(), diff --git a/native/suidhelper/tests/e2e/fork_delta_live.rs b/native/suidhelper/tests/e2e/fork_delta_live.rs index 0d9436c9..421d0060 100644 --- a/native/suidhelper/tests/e2e/fork_delta_live.rs +++ b/native/suidhelper/tests/e2e/fork_delta_live.rs @@ -51,7 +51,7 @@ struct Live { origin: MapperDevice, pool: DmDevice, _data: LoopDevice, - meta: LoopDevice, + _meta: LoopDevice, config: PathBuf, base: PathBuf, _dir: TempDir, @@ -100,7 +100,7 @@ impl Live { origin, pool, _data: data, - meta, + _meta: meta, config, base, _dir: dir, @@ -133,7 +133,6 @@ impl Live { json!({ "op": "thin_fork_delta", "pool": self.pool_name(), - "meta": self.meta.path(), "parent": parent.path().trim_start_matches("/dev/mapper/"), "scratch_id": scratch_id, "origin": self.origin.path(), diff --git a/native/suidhelper/tests/fixtures/requests.json b/native/suidhelper/tests/fixtures/requests.json index 23124791..cd5913e7 100644 --- a/native/suidhelper/tests/fixtures/requests.json +++ b/native/suidhelper/tests/fixtures/requests.json @@ -19,7 +19,7 @@ "thin_volume_create_forked": {"op": "thin_volume_create", "pool": "hyper-pool", "thin_id": 2, "name": "hyper-v2", "origin": "/dev/mapper/hyper-img", "parent": "hyper-v1"}, "thin_destroy": {"op": "thin_destroy", "pool": "hyper-pool", "name": "hyper-v1"}, - "thin_fork_delta": {"op": "thin_fork_delta", "pool": "hyper-pool", "meta": "/dev/loop3", + "thin_fork_delta": {"op": "thin_fork_delta", "pool": "hyper-pool", "parent": "hyper-v1", "scratch_id": 9, "origin": "/dev/mapper/hyper-img", "cow": "/srv/hyper/cow.img", "chunk_sectors": 8}, "host_init": {"op": "host_init"}, diff --git a/test/hyper/node/img/thin_pool_test.exs b/test/hyper/node/img/thin_pool_test.exs index 19a41c25..2f653a6c 100644 --- a/test/hyper/node/img/thin_pool_test.exs +++ b/test/hyper/node/img/thin_pool_test.exs @@ -33,10 +33,7 @@ defmodule Hyper.Node.Img.ThinPoolTest do SuidHelperStub.install!(tmp, helper) {:reply, _, state} = - ThinPool.handle_call(request, {self(), make_ref()}, %ThinPool.State{ - meta_loop: "/dev/loop3", - next: 6 - }) + ThinPool.handle_call(request, {self(), make_ref()}, %ThinPool.State{next: 6}) assert state.freed == freed, label end diff --git a/test/hyper/suid_helper/request_contract_test.exs b/test/hyper/suid_helper/request_contract_test.exs index 36664775..bba4e7a8 100644 --- a/test/hyper/suid_helper/request_contract_test.exs +++ b/test/hyper/suid_helper/request_contract_test.exs @@ -87,7 +87,6 @@ defmodule Hyper.SuidHelper.RequestContractTest do fn -> SuidHelper.ForkDelta.run( "hyper-pool", - "/dev/loop3", "hyper-v1", 9, "/dev/mapper/hyper-img",