Implement record based Crucible reference counting

nexus/db-model/src/lib.rs

@@ -108,6 +108,7 @@ mod vmm;
 mod vni;
 mod volume;
 mod volume_repair;
+mod volume_resource_usage;
 mod vpc;
 mod vpc_firewall_rule;
 mod vpc_route;
@@ -217,6 +218,7 @@ pub use vmm_state::*;
 pub use vni::*;
 pub use volume::*;
 pub use volume_repair::*;
+pub use volume_resource_usage::*;
 pub use vpc::*;
 pub use vpc_firewall_rule::*;
 pub use vpc_route::*;

nexus/db-model/src/schema.rs

@@ -2024,3 +2024,19 @@ joinable!(instance_ssh_key -> instance (instance_id));
 allow_tables_to_appear_in_same_query!(sled, sled_instance);
 
 joinable!(network_interface -> probe (parent_id));
+
+table! {
+    volume_resource_usage (usage_id) {
+        usage_id -> Uuid,
+
+        volume_id -> Uuid,
+
+        usage_type -> crate::VolumeResourceUsageTypeEnum,
+
+        region_id -> Nullable<Uuid>,
+
+        region_snapshot_dataset_id -> Nullable<Uuid>,
+        region_snapshot_region_id -> Nullable<Uuid>,
+        region_snapshot_snapshot_id -> Nullable<Uuid>,
+    }
+}

nexus/db-model/src/schema_versions.rs

@@ -17,7 +17,7 @@ use std::collections::BTreeMap;
 ///
 /// This must be updated when you change the database schema.  Refer to
 /// schema/crdb/README.adoc in the root of this repository for details.
-pub const SCHEMA_VERSION: SemverVersion = SemverVersion::new(108, 0, 0);
+pub const SCHEMA_VERSION: SemverVersion = SemverVersion::new(109, 0, 0);
 
 /// List of all past database schema versions, in *reverse* order
 ///
@@ -29,6 +29,7 @@ static KNOWN_VERSIONS: Lazy<Vec<KnownVersion>> = Lazy::new(|| {
         // |  leaving the first copy as an example for the next person.
         // v
         // KnownVersion::new(next_int, "unique-dirname-with-the-sql-files"),
+        KnownVersion::new(109, "crucible-ref-count-records"),
         KnownVersion::new(108, "internet-gateway"),
         KnownVersion::new(107, "add-instance-boot-disk"),
         KnownVersion::new(106, "dataset-kinds-update"),

nexus/db-model/src/volume_resource_usage.rs

@@ -0,0 +1,132 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+use super::impl_enum_type;
+use crate::schema::volume_resource_usage;
+use uuid::Uuid;
+
+impl_enum_type!(
+    #[derive(SqlType, Debug, QueryId)]
+    #[diesel(
+        postgres_type(name = "volume_resource_usage_type", schema = "public")
+    )]
+    pub struct VolumeResourceUsageTypeEnum;
+
+    #[derive(Copy, Clone, Debug, AsExpression, FromSqlRow, PartialEq, Eq, Hash)]
+    #[diesel(sql_type = VolumeResourceUsageTypeEnum)]
+    pub enum VolumeResourceUsageType;
+
+    ReadOnlyRegion => b"read_only_region"
+    RegionSnapshot => b"region_snapshot"
+);
+
+/// Crucible volumes are created by layering read-write regions over a hierarchy
+/// of read-only resources. Originally only a region snapshot could be used as a
+/// read-only resource for a volume. With the introduction of read-only regions
+/// (created during the region snapshot replacement process) this is no longer
+/// true.
+///
+/// Read-only resources can be used by many volumes, and because of this they
+/// need to have a reference count so they can be deleted when they're not
+/// referenced anymore. The region_snapshot table uses a `volume_references`
+/// column, which counts how many uses there are. The region table does not have
+/// this column, and more over a simple integer works for reference counting but
+/// does not tell you _what_ volume that use is from. This can be determined
+/// (see omdb's validate volume references command) but it's information that is
+/// tossed out, as Nexus knows what volumes use what resources! Instead, record
+/// what read-only resources a volume uses here.
+///
+/// Note: users should not use this object directly, and instead use the
+/// [`VolumeResourceUsage`] enum, which is type-safe and will convert to and
+/// from a [`VolumeResourceUsageRecord`] when interacting with the DB.
+#[derive(
+    Queryable, Insertable, Debug, Clone, Selectable, PartialEq, Eq, Hash,
+)]
+#[diesel(table_name = volume_resource_usage)]
+pub struct VolumeResourceUsageRecord {
+    pub usage_id: Uuid,
+
+    pub volume_id: Uuid,
+
+    pub usage_type: VolumeResourceUsageType,
+
+    pub region_id: Option<Uuid>,
+
+    pub region_snapshot_dataset_id: Option<Uuid>,
+    pub region_snapshot_region_id: Option<Uuid>,
+    pub region_snapshot_snapshot_id: Option<Uuid>,
+}
+
+#[derive(Debug, Clone)]
+pub enum VolumeResourceUsage {
+    ReadOnlyRegion { region_id: Uuid },
+
+    RegionSnapshot { dataset_id: Uuid, region_id: Uuid, snapshot_id: Uuid },
+}
+
+impl VolumeResourceUsageRecord {
+    pub fn new(volume_id: Uuid, usage: VolumeResourceUsage) -> Self {
+        match usage {
+            VolumeResourceUsage::ReadOnlyRegion { region_id } => {
+                VolumeResourceUsageRecord {
+                    usage_id: Uuid::new_v4(),
+                    volume_id,
+                    usage_type: VolumeResourceUsageType::ReadOnlyRegion,
+
+                    region_id: Some(region_id),
+
+                    region_snapshot_dataset_id: None,
+                    region_snapshot_region_id: None,
+                    region_snapshot_snapshot_id: None,
+                }
+            }
+
+            VolumeResourceUsage::RegionSnapshot {
+                dataset_id,
+                region_id,
+                snapshot_id,
+            } => VolumeResourceUsageRecord {
+                usage_id: Uuid::new_v4(),
+                volume_id,
+                usage_type: VolumeResourceUsageType::RegionSnapshot,
+
+                region_id: None,
+
+                region_snapshot_dataset_id: Some(dataset_id),
+                region_snapshot_region_id: Some(region_id),
+                region_snapshot_snapshot_id: Some(snapshot_id),
+            },
+        }
+    }
+}
+
+impl From<VolumeResourceUsageRecord> for VolumeResourceUsage {
+    fn from(record: VolumeResourceUsageRecord) -> VolumeResourceUsage {
+        match record.usage_type {
+            VolumeResourceUsageType::ReadOnlyRegion => {
+                VolumeResourceUsage::ReadOnlyRegion {
+                    region_id: record
+                        .region_id
+                        .expect("valid read-only region usage record"),
+                }
+            }
+
+            VolumeResourceUsageType::RegionSnapshot => {
+                VolumeResourceUsage::RegionSnapshot {
+                    dataset_id: record
+                        .region_snapshot_dataset_id
+                        .expect("valid region snapshot usage record"),
+
+                    region_id: record
+                        .region_snapshot_region_id
+                        .expect("valid region snapshot usage record"),
+
+                    snapshot_id: record
+                        .region_snapshot_snapshot_id
+                        .expect("valid region snapshot usage record"),
+                }
+            }
+        }
+    }
+}

nexus/db-queries/src/db/datastore/mod.rs

@@ -793,7 +793,7 @@ mod test {
     }
 
     #[derive(Debug)]
-    struct TestDatasets {
+    pub(crate) struct TestDatasets {
         // eligible and ineligible aren't currently used, but are probably handy
         // for the future.
         #[allow(dead_code)]
@@ -810,7 +810,7 @@ mod test {
     type SledToDatasetMap = HashMap<SledUuid, Vec<Uuid>>;
 
     impl TestDatasets {
-        async fn create(
+        pub(crate) async fn create(
             opctx: &OpContext,
             datastore: Arc<DataStore>,
             num_eligible_sleds: usize,

nexus/db-queries/src/db/datastore/region.rs

@@ -264,7 +264,7 @@ impl DataStore {
                 block_size,
                 blocks_per_extent,
                 extent_count,
-                read_only: false,
+                read_only: maybe_snapshot_id.is_some(),
             },
             allocation_strategy,
             num_regions_required,