std.os.uefi.protocol: ziggify function signatures

lib/std/os/uefi.zig

@@ -247,3 +247,11 @@ test {
     _ = tables;
     _ = protocol;
 }
+
+pub const UnexpectedError = error{Unexpected};
+
+pub fn unexpectedStatus(err: Status) UnexpectedError {
+    // TODO: debug printing the encountered error? maybe handle warnings?
+    _ = err;
+    return error.Unexpected;
+}

lib/std/os/uefi/protocol/absolute_pointer.zig

@@ -4,22 +4,36 @@ const Event = uefi.Event;
 const Guid = uefi.Guid;
 const Status = uefi.Status;
 const cc = uefi.cc;
+const Error = Status.Error;
 
 /// Protocol for touchscreens.
 pub const AbsolutePointer = extern struct {
-    _reset: *const fn (*const AbsolutePointer, bool) callconv(cc) Status,
+    _reset: *const fn (*AbsolutePointer, bool) callconv(cc) Status,
     _get_state: *const fn (*const AbsolutePointer, *State) callconv(cc) Status,
     wait_for_input: Event,
     mode: *Mode,
 
+    pub const ResetError = uefi.UnexpectedError || error{DeviceError};
+    pub const GetStateError = uefi.UnexpectedError || error{ NotReady, DeviceError };
+
     /// Resets the pointer device hardware.
-    pub fn reset(self: *const AbsolutePointer, verify: bool) Status {
-        return self._reset(self, verify);
+    pub fn reset(self: *AbsolutePointer, verify: bool) ResetError!void {
+        switch (self._reset(self, verify)) {
+            .success => {},
+            .device_error => return Error.DeviceError,
+            else => |status| return uefi.unexpectedStatus(status),
+        }
     }
 
     /// Retrieves the current state of a pointer device.
-    pub fn getState(self: *const AbsolutePointer, state: *State) Status {
-        return self._get_state(self, state);
+    pub fn getState(self: *const AbsolutePointer) GetStateError!State {
+        var state: State = undefined;
+        switch (self._get_state(self, &state)) {
+            .success => return state,
+            .not_ready => return Error.NotReady,
+            .device_error => return Error.DeviceError,
+            else => |status| return uefi.unexpectedStatus(status),
+        }
     }
 
     pub const guid align(8) = Guid{

lib/std/os/uefi/protocol/block_io.zig

@@ -2,6 +2,7 @@ const std = @import("std");
 const uefi = std.os.uefi;
 const Status = uefi.Status;
 const cc = uefi.cc;
+const Error = Status.Error;
 
 pub const BlockIo = extern struct {
     const Self = @This();
@@ -14,24 +15,69 @@ pub const BlockIo = extern struct {
     _write_blocks: *const fn (*BlockIo, media_id: u32, lba: u64, buffer_size: usize, buf: [*]u8) callconv(cc) Status,
     _flush_blocks: *const fn (*BlockIo) callconv(cc) Status,
 
+    pub const ResetError = uefi.UnexpectedError || error{DeviceError};
+    pub const ReadBlocksError = uefi.UnexpectedError || error{
+        DeviceError,
+        NoMedia,
+        BadBufferSize,
+        InvalidParameter,
+    };
+    pub const WriteBlocksError = uefi.UnexpectedError || error{
+        WriteProtected,
+        NoMedia,
+        MediaChanged,
+        DeviceError,
+        BadBufferSize,
+        InvalidParameter,
+    };
+    pub const FlushBlocksError = uefi.UnexpectedError || error{
+        DeviceError,
+        NoMedia,
+    };
+
     /// Resets the block device hardware.
-    pub fn reset(self: *Self, extended_verification: bool) Status {
-        return self._reset(self, extended_verification);
+    pub fn reset(self: *Self, extended_verification: bool) ResetError!void {
+        switch (self._reset(self, extended_verification)) {
+            .success => {},
+            .device_error => return Error.DeviceError,
+            else => |status| return uefi.unexpectedStatus(status),
+        }
     }
 
     /// Reads the number of requested blocks from the device.
-    pub fn readBlocks(self: *Self, media_id: u32, lba: u64, buffer_size: usize, buf: [*]u8) Status {
-        return self._read_blocks(self, media_id, lba, buffer_size, buf);
+    pub fn readBlocks(self: *Self, media_id: u32, lba: u64, buf: []u8) ReadBlocksError!void {
+        switch (self._read_blocks(self, media_id, lba, buf.len, buf.ptr)) {
+            .success => {},
+            .device_error => return Error.DeviceError,
+            .no_media => return Error.NoMedia,
+            .bad_buffer_size => return Error.BadBufferSize,
+            .invalid_parameter => return Error.InvalidParameter,
+            else => |status| return uefi.unexpectedStatus(status),
+        }
     }
 
     /// Writes a specified number of blocks to the device.
-    pub fn writeBlocks(self: *Self, media_id: u32, lba: u64, buffer_size: usize, buf: [*]u8) Status {
-        return self._write_blocks(self, media_id, lba, buffer_size, buf);
+    pub fn writeBlocks(self: *Self, media_id: u32, lba: u64, buf: []const u8) WriteBlocksError!void {
+        switch (self._write_blocks(self, media_id, lba, buf.len, buf.ptr)) {
+            .success => {},
+            .write_protected => return Error.WriteProtected,
+            .no_media => return Error.NoMedia,
+            .media_changed => return Error.MediaChanged,
+            .device_error => return Error.DeviceError,
+            .bad_buffer_size => return Error.BadBufferSize,
+            .invalid_parameter => return Error.InvalidParameter,
+            else => |status| return uefi.unexpectedStatus(status),
+        }
     }
 
     /// Flushes all modified data to a physical block device.
-    pub fn flushBlocks(self: *Self) Status {
-        return self._flush_blocks(self);
+    pub fn flushBlocks(self: *Self) FlushBlocksError!void {
+        switch (self._flush_blocks(self)) {
+            .success => {},
+            .device_error => return Error.DeviceError,
+            .no_media => return Error.NoMedia,
+            else => |status| return uefi.unexpectedStatus(status),
+        }
     }
 
     pub const guid align(8) = uefi.Guid{

lib/std/os/uefi/protocol/device_path.zig

@@ -13,6 +13,8 @@ pub const DevicePath = extern struct {
     subtype: u8,
     length: u16 align(1),
 
+    pub const CreateFileDevicePathError = Allocator.Error;
+
     pub const guid align(8) = Guid{
         .time_low = 0x09576e91,
         .time_mid = 0x6d3f,
@@ -23,15 +25,15 @@ pub const DevicePath = extern struct {
     };
 
     /// Returns the next DevicePath node in the sequence, if any.
-    pub fn next(self: *DevicePath) ?*DevicePath {
+    pub fn next(self: *const DevicePath) ?*DevicePath {
         if (self.type == .end and @as(uefi.DevicePath.End.Subtype, @enumFromInt(self.subtype)) == .end_entire)
             return null;
 
         return @as(*DevicePath, @ptrCast(@as([*]u8, @ptrCast(self)) + self.length));
     }
 
     /// Calculates the total length of the device path structure in bytes, including the end of device path node.
-    pub fn size(self: *DevicePath) usize {
+    pub fn size(self: *const DevicePath) usize {
         var node = self;
 
         while (node.next()) |next_node| {
@@ -42,7 +44,11 @@ pub const DevicePath = extern struct {
     }
 
     /// Creates a file device path from the existing device path and a file path.
-    pub fn create_file_device_path(self: *DevicePath, allocator: Allocator, path: [:0]align(1) const u16) !*DevicePath {
+    pub fn createFileDevicePath(
+        self: *const DevicePath,
+        allocator: Allocator,
+        path: []const u16,
+    ) CreateFileDevicePathError!*DevicePath {
         const path_size = self.size();
 
         // 2 * (path.len + 1) for the path and its null terminator, which are u16s

lib/std/os/uefi/protocol/edid.zig

@@ -4,6 +4,7 @@ const Guid = uefi.Guid;
 const Handle = uefi.Handle;
 const Status = uefi.Status;
 const cc = uefi.cc;
+const Error = Status.Error;
 
 /// EDID information for an active video output device
 pub const Active = extern struct {
@@ -39,15 +40,28 @@ pub const Discovered = extern struct {
 pub const Override = extern struct {
     _get_edid: *const fn (*const Override, Handle, *Attributes, *usize, *?[*]u8) callconv(cc) Status,
 
+    pub const GetEdidError = uefi.UnexpectedError || error{
+        Unsupported,
+    };
+
     /// Returns policy information and potentially a replacement EDID for the specified video output device.
     pub fn getEdid(
         self: *const Override,
         handle: Handle,
         attributes: *Attributes,
-        edid_size: *usize,
-        edid: *?[*]u8,
-    ) Status {
-        return self._get_edid(self, handle, attributes, edid_size, edid);
+    ) GetEdidError!?[]u8 {
+        var size: usize = undefined;
+        var ptr: ?[*]u8 = undefined;
+        switch (self._get_edid(self, handle, attributes, &size, &ptr)) {
+            .success => {},
+            .unsupported => return Error.Unsupported,
+            else => |status| return uefi.unexpectedStatus(status),
+        }
+
+        if (size == 0 or ptr == null)
+            return null;
+
+        return ptr.?[0..size];
     }
 
     pub const guid align(8) = Guid{