lib/machine/src/checkpoint/stream/schema.zig

daab053ee43316e1809a84551d573ddd1e5bf3d2

  1 const os = @import("os");
  2 const owner = @import("../owner/root.zig");
  3 const profile = @import("../../profile/root.zig");
  4 const std = @import("std");
  5 
  6 const manifest = os.boot.kernel.manifest;
  7 const wire = os.abi.wire;
  8 
  9 pub const magic = [8]u8{ 'M', 'C', 'H', 'C', 'K', 'P', '1', 0 };
 10 pub const version: u16 = 1;
 11 pub const flags: u16 = 0;
 12 pub const checkpoint_format: u16 = 1;
 13 pub const abi_major: u16 = 1;
 14 pub const abi_minor: u16 = 2;
 15 pub const load_capacity: u16 = 4;
 16 pub const load_bytes: u16 = 32;
 17 pub const digest_bytes: u16 = 32;
 18 pub const root_bytes: u16 = 96;
 19 pub const semantic_receipt_bytes: u16 = 312;
 20 pub const cpu_bytes: u16 = 72;
 21 pub const immutable_descriptor_bytes: u16 = 168;
 22 pub const page_bytes: u32 = 4096;
 23 pub const ram_bytes: u64 = 67_108_864;
 24 pub const encoded_stream_bytes: u64 = 67_112_960;
 25 
 26 pub const Envelope = struct {
 27     pub const magic_offset: usize = 0;
 28     pub const version_offset: usize = 8;
 29     pub const header_bytes_offset: usize = 10;
 30     pub const flags_offset: usize = 12;
 31     pub const format_offset: usize = 14;
 32     pub const stream_bytes_offset: usize = 16;
 33     pub const ram_bytes_offset: usize = 24;
 34     pub const page_bytes_offset: usize = 32;
 35     pub const abi_major_offset: usize = 36;
 36     pub const abi_minor_offset: usize = 38;
 37     pub const load_capacity_offset: usize = 40;
 38     pub const load_bytes_offset: usize = 42;
 39     pub const digest_bytes_offset: usize = 44;
 40     pub const root_bytes_offset: usize = 46;
 41     pub const semantic_receipt_bytes_offset: usize = 48;
 42     pub const cpu_bytes_offset: usize = 50;
 43     pub const immutable_descriptor_bytes_offset: usize = 52;
 44     pub const reserved_offset: usize = 54;
 45     pub const limit: usize = 64;
 46 };
 47 
 48 pub const RootLayout = struct {
 49     pub const digest_offset: usize = Envelope.limit;
 50     pub const profile_offset: usize = digest_offset + digest_bytes;
 51     pub const state_offset: usize = profile_offset + digest_bytes;
 52     pub const limit: usize = state_offset + digest_bytes;
 53 };
 54 
 55 pub const MemoryLayout = struct {
 56     pub const digest_offset: usize = RootLayout.limit;
 57     pub const limit: usize = digest_offset + digest_bytes;
 58 };
 59 
 60 pub const SemanticLayout = struct {
 61     pub const admission_offset: usize = MemoryLayout.limit;
 62     pub const contract_offset: usize = admission_offset + digest_bytes;
 63     pub const source_root_offset: usize = contract_offset + digest_bytes;
 64     pub const input_frontier_offset: usize = source_root_offset + digest_bytes;
 65     pub const terminal_input_offset: usize = input_frontier_offset + 8;
 66     pub const virtual_time_offset: usize = terminal_input_offset + 8;
 67     pub const entropy_offset: usize = virtual_time_offset + 8;
 68     pub const effect_offset: usize = entropy_offset + 8;
 69     pub const image_offset: usize = effect_offset + 8;
 70     pub const execution_offset: usize = image_offset + digest_bytes;
 71     pub const semantic_frontier_offset: usize = execution_offset + digest_bytes;
 72     pub const block_root_offset: usize = semantic_frontier_offset + 8;
 73     pub const terminal_offset: usize = block_root_offset + digest_bytes;
 74     pub const settled_request_offset: usize = terminal_offset + 8;
 75     pub const event_consumed_offset: usize = settled_request_offset + 8;
 76     pub const event_produced_offset: usize = event_consumed_offset + 8;
 77     pub const k0_offset: usize = event_produced_offset + 8;
 78     pub const reserved_offset: usize = k0_offset + 1;
 79     pub const transcript_offset: usize = reserved_offset + 7;
 80     pub const limit: usize = transcript_offset + digest_bytes;
 81 };
 82 
 83 pub const CpuLayout = struct {
 84     pub const rip_offset: usize = SemanticLayout.limit;
 85     pub const rsp_offset: usize = rip_offset + 8;
 86     pub const rdi_offset: usize = rsp_offset + 8;
 87     pub const rflags_offset: usize = rdi_offset + 8;
 88     pub const cr0_offset: usize = rflags_offset + 8;
 89     pub const cr3_offset: usize = cr0_offset + 8;
 90     pub const cr4_offset: usize = cr3_offset + 8;
 91     pub const efer_offset: usize = cr4_offset + 8;
 92     pub const code_selector_offset: usize = efer_offset + 8;
 93     pub const data_selector_offset: usize = code_selector_offset + 2;
 94     pub const reserved_offset: usize = data_selector_offset + 2;
 95     pub const limit: usize = reserved_offset + 4;
 96 };
 97 
 98 pub const LoadLayout = struct {
 99     pub const source_offset: usize = 0;
100     pub const file_offset: usize = source_offset + 4;
101     pub const memory_offset: usize = file_offset + 4;
102     pub const physical_offset: usize = memory_offset + 4;
103     pub const virtual_offset: usize = physical_offset + 4;
104     pub const flags_offset: usize = virtual_offset + 8;
105     pub const reserved_offset: usize = flags_offset + 4;
106     pub const limit: usize = reserved_offset + 4;
107 };
108 
109 pub const ImmutableLayout = struct {
110     pub const digest_offset: usize = CpuLayout.limit;
111     pub const entry_offset: usize = digest_offset + digest_bytes;
112     pub const load_count_offset: usize = entry_offset + 4;
113     pub const load_bytes_offset: usize = load_count_offset + 2;
114     pub const loads_offset: usize = load_bytes_offset + 2;
115     pub const limit: usize = loads_offset + load_capacity * LoadLayout.limit;
116 };
117 
118 pub const header_bytes: usize = page_bytes;
119 pub const stream_bytes: usize = encoded_stream_bytes;
120 
121 comptime {
122     std.debug.assert(@backingInt(
123         profile.CheckpointFormat.machine_root_v1,
124     ) == checkpoint_format);
125     std.debug.assert(wire.major == abi_major);
126     std.debug.assert(wire.minor == abi_minor);
127     std.debug.assert(wire.digest_bytes == digest_bytes);
128     std.debug.assert(wire.page_bytes == page_bytes);
129     std.debug.assert(manifest.loads_max == load_capacity);
130     std.debug.assert(os.boot.kernel.load_range_bytes == load_bytes);
131     std.debug.assert(owner.ram_alignment == page_bytes);
132     std.debug.assert(owner.ram_bytes == ram_bytes);
133     std.debug.assert(LoadLayout.limit == load_bytes);
134     std.debug.assert(header_bytes == page_bytes);
135     std.debug.assert(stream_bytes == header_bytes + owner.ram_bytes);
136     std.debug.assert(Envelope.limit == RootLayout.digest_offset);
137     std.debug.assert(RootLayout.limit - RootLayout.digest_offset == root_bytes);
138     std.debug.assert(RootLayout.limit == MemoryLayout.digest_offset);
139     std.debug.assert(MemoryLayout.limit == SemanticLayout.admission_offset);
140     std.debug.assert(
141         SemanticLayout.limit - SemanticLayout.admission_offset ==
142             semantic_receipt_bytes,
143     );
144     std.debug.assert(SemanticLayout.limit == CpuLayout.rip_offset);
145     std.debug.assert(CpuLayout.limit - CpuLayout.rip_offset == cpu_bytes);
146     std.debug.assert(CpuLayout.limit == ImmutableLayout.digest_offset);
147     std.debug.assert(
148         ImmutableLayout.limit - ImmutableLayout.digest_offset ==
149             immutable_descriptor_bytes,
150     );
151     std.debug.assert(ImmutableLayout.limit == 744);
152     std.debug.assert(ImmutableLayout.limit <= header_bytes);
153 }