Improve Pipe Protocol

1. Add function pointers to Protocol
2. Using different function pointers for Null Pipes

Signed-off-by: Ayush Singh <ayushsingh1325@gmail.com>

Author: Ayush1325

library/std/src/sys/uefi/pipe.rs

@@ -1,4 +1,4 @@
-//! An implementation of Pipes using UEFI variables
+//! An implementation of Pipes for UEFI
 
 use super::common;
 use crate::io::{self, IoSlice, IoSliceMut};
@@ -47,13 +47,36 @@ impl AnonPipe {
     }
 
     pub fn read(&self, buf: &mut [u8]) -> io::Result<usize> {
-        let protocol = common::open_protocol(self.handle, uefi_pipe_protocol::PROTOCOL_GUID)?;
-        unsafe { uefi_pipe_protocol::Protocol::read(protocol.as_ptr(), buf) }
+        let protocol = common::open_protocol::<uefi_pipe_protocol::Protocol>(
+            self.handle,
+            uefi_pipe_protocol::PROTOCOL_GUID,
+        )?;
+        let mut buf_size = buf.len();
+        let r = unsafe {
+            ((*protocol.as_ptr()).read)(protocol.as_ptr(), &mut buf_size, buf.as_mut_ptr())
+        };
+        if r.is_error() { Err(common::status_to_io_error(r)) } else { Ok(buf_size) }
     }
 
     pub(crate) fn read_to_end(&self, buf: &mut Vec<u8>) -> io::Result<usize> {
-        let protocol = common::open_protocol(self.handle, uefi_pipe_protocol::PROTOCOL_GUID)?;
-        unsafe { uefi_pipe_protocol::Protocol::read_to_end(protocol.as_ptr(), buf) }
+        let protocol = common::open_protocol::<uefi_pipe_protocol::Protocol>(
+            self.handle,
+            uefi_pipe_protocol::PROTOCOL_GUID,
+        )?;
+        let buf_size = unsafe { ((*protocol.as_ptr()).size)(protocol.as_ptr()) };
+        buf.reserve_exact(buf_size);
+        let mut buf_size = buf.capacity();
+        let r = unsafe {
+            ((*protocol.as_ptr()).read)(protocol.as_ptr(), &mut buf_size, buf.as_mut_ptr())
+        };
+        if r.is_error() {
+            Err(common::status_to_io_error(r))
+        } else {
+            unsafe {
+                buf.set_len(buf.len() + buf_size);
+            }
+            Ok(buf_size)
+        }
     }
 
     pub fn read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> io::Result<usize> {
@@ -66,8 +89,14 @@ impl AnonPipe {
     }
 
     pub fn write(&self, buf: &[u8]) -> io::Result<usize> {
-        let protocol = common::open_protocol(self.handle, uefi_pipe_protocol::PROTOCOL_GUID)?;
-        unsafe { uefi_pipe_protocol::Protocol::write(protocol.as_ptr(), buf) }
+        let protocol = common::open_protocol::<uefi_pipe_protocol::Protocol>(
+            self.handle,
+            uefi_pipe_protocol::PROTOCOL_GUID,
+        )?;
+        let mut buf_size = buf.len();
+        let r =
+            unsafe { ((*protocol.as_ptr()).write)(protocol.as_ptr(), &mut buf_size, buf.as_ptr()) };
+        if r.is_error() { Err(common::status_to_io_error(r)) } else { Ok(buf_size) }
     }
 
     pub fn write_vectored(&self, bufs: &[IoSlice<'_>]) -> io::Result<usize> {
@@ -96,6 +125,7 @@ pub(crate) mod uefi_pipe_protocol {
     use crate::sys::uefi::common;
     use io::{Read, Write};
     use r_efi::efi::Guid;
+    use r_efi::{eficall, eficall_abi};
 
     pub(crate) const PROTOCOL_GUID: Guid = Guid::from_fields(
         0x3c4acb49,
@@ -120,26 +150,30 @@ pub(crate) mod uefi_pipe_protocol {
         }
 
         #[inline]
-        pub(crate) unsafe fn read(data: *mut Pipedata, buf: &mut [u8]) -> io::Result<usize> {
+        unsafe fn read(data: *mut Pipedata, buf: &mut [u8]) -> io::Result<usize> {
             unsafe { (*data).data.read(buf) }
         }
 
         #[inline]
-        pub(crate) unsafe fn read_to_end(
-            data: *mut Pipedata,
-            buf: &mut Vec<u8>,
-        ) -> io::Result<usize> {
-            unsafe { (*data).data.read_to_end(buf) }
+        unsafe fn write(data: *mut Pipedata, buf: &[u8]) -> io::Result<usize> {
+            unsafe { (*data).data.write(buf) }
         }
 
         #[inline]
-        pub(crate) unsafe fn write(data: *mut Pipedata, buf: &[u8]) -> io::Result<usize> {
-            unsafe { (*data).data.write(buf) }
+        unsafe fn size(data: *mut Pipedata) -> usize {
+            unsafe { (*data).data.len() }
         }
     }
 
+    type WriteSignature = eficall! {fn(*mut Protocol, *mut usize, *const u8) -> r_efi::efi::Status};
+    type ReadSignature = eficall! {fn(*mut Protocol, *mut usize, *mut u8) -> r_efi::efi::Status};
+    type SizeSignature = eficall! {fn(*mut Protocol) -> usize};
+
     #[repr(C)]
     pub(crate) struct Protocol {
+        pub read: ReadSignature,
+        pub write: WriteSignature,
+        pub size: SizeSignature,
         data: *mut Pipedata,
     }
 
@@ -150,39 +184,98 @@ pub(crate) mod uefi_pipe_protocol {
     impl Protocol {
         #[inline]
         pub(crate) fn with_data(data: &mut Pipedata) -> Self {
-            Self { data }
+            Self {
+                data,
+                read: pipe_protocol_read,
+                write: pipe_protocol_write,
+                size: pipe_protocol_size,
+            }
         }
 
         #[inline]
         pub(crate) fn null() -> Self {
-            Self { data: crate::ptr::null_mut() }
+            Self {
+                data: crate::ptr::null_mut(),
+                read: pipe_protocol_null_read,
+                write: pipe_protocol_null_write,
+                size: pipe_protocol_null_size,
+            }
+        }
+
+        unsafe fn read(protocol: *mut Protocol, buf: &mut [u8]) -> io::Result<usize> {
+            unsafe {
+                assert!(!(*protocol).data.is_null());
+                Pipedata::read((*protocol).data, buf)
+            }
         }
 
-        pub(crate) unsafe fn read(protocol: *mut Protocol, buf: &mut [u8]) -> io::Result<usize> {
-            if unsafe { (*protocol).data.is_null() } {
-                Ok(0)
-            } else {
-                unsafe { Pipedata::read((*protocol).data, buf) }
+        unsafe fn write(protocol: *mut Protocol, buf: &[u8]) -> io::Result<usize> {
+            unsafe {
+                assert!(!(*protocol).data.is_null());
+                Pipedata::write((*protocol).data, buf)
             }
         }
 
-        pub(crate) unsafe fn read_to_end(
-            protocol: *mut Protocol,
-            buf: &mut Vec<u8>,
-        ) -> io::Result<usize> {
-            if unsafe { (*protocol).data.is_null() } {
-                Ok(0)
-            } else {
-                unsafe { Pipedata::read_to_end((*protocol).data, buf) }
+        unsafe fn size(protocol: *mut Protocol) -> usize {
+            unsafe {
+                assert!(!(*protocol).data.is_null());
+                Pipedata::size((*protocol).data)
             }
         }
+    }
 
-        pub(crate) unsafe fn write(protocol: *mut Protocol, buf: &[u8]) -> io::Result<usize> {
-            if unsafe { (*protocol).data.is_null() } {
-                Ok(buf.len())
-            } else {
-                unsafe { Pipedata::write((*protocol).data, buf) }
+    extern "efiapi" fn pipe_protocol_read(
+        protocol: *mut Protocol,
+        buf_size: *mut usize,
+        buf: *mut u8,
+    ) -> r_efi::efi::Status {
+        let buffer = unsafe { crate::slice::from_raw_parts_mut(buf, buf_size.read()) };
+        match unsafe { Protocol::read(protocol, buffer) } {
+            Ok(x) => {
+                unsafe { buf_size.write(x) };
+                r_efi::efi::Status::SUCCESS
             }
+            Err(_) => r_efi::efi::Status::ABORTED,
         }
     }
+
+    extern "efiapi" fn pipe_protocol_write(
+        protocol: *mut Protocol,
+        buf_size: *mut usize,
+        buf: *const u8,
+    ) -> r_efi::efi::Status {
+        let buffer = unsafe { crate::slice::from_raw_parts(buf, buf_size.read()) };
+        match unsafe { Protocol::write(protocol, buffer) } {
+            Ok(x) => {
+                unsafe { buf_size.write(x) };
+                r_efi::efi::Status::SUCCESS
+            }
+            Err(_) => r_efi::efi::Status::ABORTED,
+        }
+    }
+
+    extern "efiapi" fn pipe_protocol_size(protocol: *mut Protocol) -> usize {
+        unsafe { Protocol::size(protocol) }
+    }
+
+    extern "efiapi" fn pipe_protocol_null_write(
+        _protocol: *mut Protocol,
+        _buf_size: *mut usize,
+        _buf: *const u8,
+    ) -> r_efi::efi::Status {
+        r_efi::efi::Status::SUCCESS
+    }
+
+    extern "efiapi" fn pipe_protocol_null_read(
+        _protocol: *mut Protocol,
+        buf_size: *mut usize,
+        _buf: *mut u8,
+    ) -> r_efi::efi::Status {
+        unsafe { buf_size.write(0) };
+        r_efi::efi::Status::SUCCESS
+    }
+
+    extern "efiapi" fn pipe_protocol_null_size(_protocol: *mut Protocol) -> usize {
+        0
+    }
 }