mirror of
https://github.com/ziglang/zig.git
synced 2025-12-06 14:23:09 +00:00
4771ac298b
Beyond adding default zero-initialization, this commit changes undefined initialization to zero, as some cases reserved the padding and on other cases, I've found some systems act strange when giving uninit instead of zero even when it shouldn't be an issue, one example being FileProtocol.Open's attributes, which *should* be ignored when not creating a file, but ended up giving an unrelated error.
136 lines
3.8 KiB
Zig
136 lines
3.8 KiB
Zig
const std = @import("../std.zig");
|
|
|
|
/// A protocol is an interface identified by a GUID.
|
|
pub const protocols = @import("uefi/protocols.zig");
|
|
|
|
/// Status codes returned by EFI interfaces
|
|
pub const Status = @import("uefi/status.zig").Status;
|
|
pub const tables = @import("uefi/tables.zig");
|
|
|
|
/// The memory type to allocate when using the pool
|
|
/// Defaults to .LoaderData, the default data allocation type
|
|
/// used by UEFI applications to allocate pool memory.
|
|
pub var efi_pool_memory_type: tables.MemoryType = .LoaderData;
|
|
pub const pool_allocator = @import("uefi/pool_allocator.zig").pool_allocator;
|
|
pub const raw_pool_allocator = @import("uefi/pool_allocator.zig").raw_pool_allocator;
|
|
|
|
/// The EFI image's handle that is passed to its entry point.
|
|
pub var handle: Handle = undefined;
|
|
|
|
/// A pointer to the EFI System Table that is passed to the EFI image's entry point.
|
|
pub var system_table: *tables.SystemTable = undefined;
|
|
|
|
/// A handle to an event structure.
|
|
pub const Event = *opaque {};
|
|
|
|
pub const MacAddress = extern struct {
|
|
address: [32]u8,
|
|
};
|
|
|
|
pub const Ipv4Address = extern struct {
|
|
address: [4]u8,
|
|
};
|
|
|
|
pub const Ipv6Address = extern struct {
|
|
address: [16]u8,
|
|
};
|
|
|
|
/// GUIDs must be align(8)
|
|
pub const Guid = extern struct {
|
|
time_low: u32,
|
|
time_mid: u16,
|
|
time_high_and_version: u16,
|
|
clock_seq_high_and_reserved: u8,
|
|
clock_seq_low: u8,
|
|
node: [6]u8,
|
|
|
|
/// Format GUID into hexadecimal lowercase xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx format
|
|
pub fn format(
|
|
self: @This(),
|
|
comptime f: []const u8,
|
|
options: std.fmt.FormatOptions,
|
|
writer: anytype,
|
|
) !void {
|
|
_ = options;
|
|
if (f.len == 0) {
|
|
return std.fmt.format(writer, "{x:0>8}-{x:0>4}-{x:0>4}-{x:0>2}{x:0>2}-{x:0>12}", .{
|
|
self.time_low,
|
|
self.time_mid,
|
|
self.time_high_and_version,
|
|
self.clock_seq_high_and_reserved,
|
|
self.clock_seq_low,
|
|
self.node,
|
|
});
|
|
} else {
|
|
@compileError("Unknown format character: '" ++ f ++ "'");
|
|
}
|
|
}
|
|
|
|
pub fn eql(a: std.os.uefi.Guid, b: std.os.uefi.Guid) bool {
|
|
return a.time_low == b.time_low and
|
|
a.time_mid == b.time_mid and
|
|
a.time_high_and_version == b.time_high_and_version and
|
|
a.clock_seq_high_and_reserved == b.clock_seq_high_and_reserved and
|
|
a.clock_seq_low == b.clock_seq_low and
|
|
std.mem.eql(u8, &a.node, &b.node);
|
|
}
|
|
};
|
|
|
|
/// An EFI Handle represents a collection of related interfaces.
|
|
pub const Handle = *opaque {};
|
|
|
|
/// This structure represents time information.
|
|
pub const Time = extern struct {
|
|
/// 1900 - 9999
|
|
year: u16,
|
|
|
|
/// 1 - 12
|
|
month: u8,
|
|
|
|
/// 1 - 31
|
|
day: u8,
|
|
|
|
/// 0 - 23
|
|
hour: u8,
|
|
|
|
/// 0 - 59
|
|
minute: u8,
|
|
|
|
/// 0 - 59
|
|
second: u8,
|
|
|
|
/// 0 - 999999999
|
|
nanosecond: u32,
|
|
|
|
/// The time's offset in minutes from UTC.
|
|
/// Allowed values are -1440 to 1440 or unspecified_timezone
|
|
timezone: i16,
|
|
daylight: packed struct {
|
|
_pad1: u6,
|
|
|
|
/// If true, the time has been adjusted for daylight savings time.
|
|
in_daylight: bool,
|
|
|
|
/// If true, the time is affected by daylight savings time.
|
|
adjust_daylight: bool,
|
|
},
|
|
|
|
/// Time is to be interpreted as local time
|
|
pub const unspecified_timezone: i16 = 0x7ff;
|
|
};
|
|
|
|
/// Capabilities of the clock device
|
|
pub const TimeCapabilities = extern struct {
|
|
/// Resolution in Hz
|
|
resolution: u32,
|
|
|
|
/// Accuracy in an error rate of 1e-6 parts per million.
|
|
accuracy: u32,
|
|
|
|
/// If true, a time set operation clears the device's time below the resolution level.
|
|
sets_to_zero: bool,
|
|
};
|
|
|
|
/// File Handle as specified in the EFI Shell Spec
|
|
pub const FileHandle = *opaque {};
|