Something went wrong. Try again.
[WIP] A toy kernel written in Zig
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233const std = @import("std");const Type = std.builtin.Type;
const kernel = @import("root.zig");
pub const DeviceTree = struct { bytes: struct { toplevel: []const u8, dt_struct: []const u8, dt_strings: []const u8, dt_rsvmap: [*]const u8, },
pub const InitError = std.Io.Reader.Error || error{ InvalidMagic, UnsupportedVersion, };
pub fn init(ptr: *const anyopaque) InitError!DeviceTree { const Header = extern struct { magic: u32, totalsize: u32, off_dt_struct: u32, off_dt_strings: u32, off_mem_rsvmap: u32, version: u32, last_comp_version: u32, boot_cpuid_phys: u32, size_dt_strings: u32, size_dt_struct: u32,
const magic_value: u32 = 0xd00dfeed; };
const bytes_ptr: [*]const u8 = @ptrCast(@alignCast(ptr));
var reader = std.Io.Reader.fixed(bytes_ptr[0..@sizeOf(Header)]); const header = try reader.takeStruct(Header, .big);
if (header.magic != Header.magic_value) { return InitError.InvalidMagic; } if (header.last_comp_version > 17) { return InitError.UnsupportedVersion; }
const dt_total = bytes_ptr[0..header.totalsize]; const dt_struct = bytes_ptr[header.off_dt_struct..][0..header.size_dt_struct]; const dt_strings = bytes_ptr[header.off_dt_strings..][0..header.size_dt_strings]; const dt_rsvmap = bytes_ptr[header.off_mem_rsvmap..];
return .{ .bytes = .{ .toplevel = dt_total, .dt_struct = dt_struct, .dt_strings = dt_strings, .dt_rsvmap = dt_rsvmap, }, }; }
pub const PropEntry = struct { name: [:0]const u8, value: []const u8, };
pub const Entry = union(enum) { begin_node: struct { full_name: [:0]const u8, node_name: []const u8, unit_address: ?[]const u8, }, prop: PropEntry, end_node, };
pub fn entries(dt: *const DeviceTree) EntryIterator { return .{ .dt_strings = dt.bytes.dt_strings, .reader = .fixed(dt.bytes.dt_struct), }; }
pub const EntryIterator = struct { dt_strings: []const u8, reader: ?std.Io.Reader,
pub const Error = std.Io.Reader.Error || std.Io.Reader.TakeEnumError || std.Io.Reader.DelimiterError;
pub fn skip_out_of_node(self: *EntryIterator) Error!void { var depth: u32 = 1; while (depth != 0) { const next_entry = try self.next() orelse return std.Io.Reader.Error.EndOfStream;
switch (next_entry) { .begin_node => depth += 1, .prop => {}, .end_node => depth -= 1, } } }
pub fn skip_begin_root(self: *EntryIterator) Error!void { if (try self.next()) |entry| { switch (entry) { .begin_node => |node| { if (node.full_name.len != 0) { return Error.ReadFailed; } }, .end_node, .prop => return Error.ReadFailed, } } else { return Error.ReadFailed; } }
pub fn next(self: *EntryIterator) Error!?Entry { const EntryType = enum(u32) { begin_node = 1, end_node = 2, prop = 3, nop = 4, end = 9, };
const reader = if (self.reader) |*reader| reader else return null;
const alignment = @sizeOf(u32);
while (true) { switch (try reader.takeEnum(EntryType, .big)) { .begin_node => { const full_name = try reader.takeSentinel(0); alignReader(reader, alignment);
var node_name = full_name[0..full_name.len]; var unit_address: ?[]const u8 = null;
if (std.mem.find(u8, full_name, "@")) |delim_pos| { node_name = full_name[0..delim_pos]; unit_address = full_name[delim_pos..]; } return .{ .begin_node = .{ .full_name = full_name, .node_name = node_name, .unit_address = unit_address, } }; }, .end_node => return .end_node, .prop => { const RawPropEntry = extern struct { len: u32, nameoff: u32, };
const entry = try reader.takeStruct(RawPropEntry, .big); const name_size = std.mem.find(u8, self.dt_strings[entry.nameoff..], &.{0}) orelse return std.Io.Reader.Error.ReadFailed; const name: [:0]const u8 = self.dt_strings[entry.nameoff..][0..name_size :0]; const value = try reader.take(entry.len); alignReader(reader, alignment); return .{ .prop = .{ .name = name, .value = value } }; }, .nop => continue, .end => { self.reader = null; return null; }, } } }
fn alignReader( reader: *std.Io.Reader, alignment: usize, ) void { reader.toss((32 - (@intFromPtr(reader.buffer.ptr) + reader.seek) % alignment) % alignment); } };
pub fn reservations(self: *const DeviceTree) ReservationIterator { return .{ .dt_rsvmap = self.bytes.dt_rsvmap }; }
pub const ReservationIterator = struct { dt_rsvmap: ?[*]const u8,
pub const Error = std.Io.Reader.Error || error{ InvalidAddress, InvalidSize, };
pub fn next(self: *ReservationIterator) Error!?kernel.mem.Range { const dt_rsvmap = if (self.dt_rsvmap) |dt_rsvmap| dt_rsvmap else return null;
const entry_size = @sizeOf(u64) * 2; var reader = std.Io.Reader.fixed(dt_rsvmap[0..entry_size]);
const address_u64 = try reader.takeInt(u64, .big); const address = std.math.cast(usize, address_u64) orelse return Error.InvalidAddress; const size_u64 = try reader.takeInt(u64, .big); const size = std.math.cast(usize, size_u64) orelse return Error.InvalidSize;
if (address == 0 and size == 0) { self.dt_rsvmap = null; return null; } else { self.dt_rsvmap = dt_rsvmap + entry_size; }
return .{ .start = address, .end = address + size, }; } };};