diff --git a/uefi-test-runner/src/main.rs b/uefi-test-runner/src/main.rs
index d6af3b28a..594b9cad5 100644
--- a/uefi-test-runner/src/main.rs
+++ b/uefi-test-runner/src/main.rs
@@ -1,7 +1,7 @@
 #![no_std]
 #![no_main]
 // TODO: temporarily allow deprecated code so that we can continue to test
-// SystemTable/BootServices/RuntimeServices.
+// SystemTable/BootServices.
 #![allow(deprecated)]
 
 #[macro_use]
@@ -63,7 +63,7 @@ fn efi_main(image: Handle, mut st: SystemTable<Boot>) -> Status {
     // probably want to test them after exit_boot_services. However,
     // exit_boot_services is currently called during shutdown.
 
-    runtime::test(st.runtime_services());
+    runtime::test();
 
     shutdown(st);
 }
@@ -218,7 +218,7 @@ fn shutdown(mut st: SystemTable<Boot>) -> ! {
     info!("Testing complete, exiting boot services...");
 
     // Exit boot services as a proof that it works :)
-    let (st, mmap) = unsafe { st.exit_boot_services(MemoryType::LOADER_DATA) };
+    let mmap = unsafe { uefi::boot::exit_boot_services(MemoryType::LOADER_DATA) };
 
     info!("Memory Map:");
     for desc in mmap.entries() {
@@ -235,9 +235,6 @@ fn shutdown(mut st: SystemTable<Boot>) -> ! {
 
     #[cfg(target_arch = "x86_64")]
     {
-        // Prevent unused variable warning.
-        let _ = st;
-
         use qemu_exit::QEMUExit;
         let custom_exit_success = 3;
         let qemu_exit_handle = qemu_exit::X86::new(0xF4, custom_exit_success);
@@ -247,11 +244,6 @@ fn shutdown(mut st: SystemTable<Boot>) -> ! {
     #[cfg(not(target_arch = "x86_64"))]
     {
         // Shut down the system
-        let rt = unsafe { st.runtime_services() };
-        rt.reset(
-            uefi::table::runtime::ResetType::SHUTDOWN,
-            Status::SUCCESS,
-            None,
-        );
+        uefi::runtime::reset(uefi::runtime::ResetType::SHUTDOWN, Status::SUCCESS, None);
     }
 }
diff --git a/uefi-test-runner/src/proto/media.rs b/uefi-test-runner/src/proto/media.rs
index 3ba3a00e7..c4be2a0bd 100644
--- a/uefi-test-runner/src/proto/media.rs
+++ b/uefi-test-runner/src/proto/media.rs
@@ -13,7 +13,7 @@ use uefi::proto::media::file::{
 };
 use uefi::proto::media::fs::SimpleFileSystem;
 use uefi::proto::media::partition::{MbrOsType, PartitionInfo};
-use uefi::table::runtime::{Daylight, Time, TimeParams};
+use uefi::runtime::{Daylight, Time, TimeParams};
 
 /// Test directory entry iteration.
 fn test_existing_dir(directory: &mut Directory) {
diff --git a/uefi-test-runner/src/proto/misc.rs b/uefi-test-runner/src/proto/misc.rs
index c7b1664f7..6fd55b624 100644
--- a/uefi-test-runner/src/proto/misc.rs
+++ b/uefi-test-runner/src/proto/misc.rs
@@ -1,6 +1,6 @@
 use uefi::prelude::*;
 use uefi::proto::misc::ResetNotification;
-use uefi::table::runtime;
+use uefi::runtime::ResetType;
 
 pub fn test(bt: &BootServices) {
     test_reset_notification(bt);
@@ -19,7 +19,7 @@ pub fn test_reset_notification(bt: &BootServices) {
 
     // value efi_reset_fn is the type of ResetSystemFn, a function pointer
     unsafe extern "efiapi" fn efi_reset_fn(
-        rt: runtime::ResetType,
+        rt: ResetType,
         status: Status,
         data_size: usize,
         data: *const u8,
diff --git a/uefi-test-runner/src/runtime/mod.rs b/uefi-test-runner/src/runtime/mod.rs
index 92769bfe4..7b233ab3c 100644
--- a/uefi-test-runner/src/runtime/mod.rs
+++ b/uefi-test-runner/src/runtime/mod.rs
@@ -1,11 +1,10 @@
 mod vars;
 
 use uefi::runtime::{self, Daylight, Time, TimeParams};
-use uefi::table::runtime::RuntimeServices;
 
-pub fn test(rt: &RuntimeServices) {
+pub fn test() {
     info!("Testing runtime services");
-    vars::test(rt);
+    vars::test();
     test_time();
 }
 
diff --git a/uefi-test-runner/src/runtime/vars.rs b/uefi-test-runner/src/runtime/vars.rs
index 208a628fe..930141c02 100644
--- a/uefi-test-runner/src/runtime/vars.rs
+++ b/uefi-test-runner/src/runtime/vars.rs
@@ -1,6 +1,6 @@
 use log::info;
 use uefi::prelude::*;
-use uefi::table::runtime::{VariableAttributes, VariableVendor};
+use uefi::runtime::{VariableAttributes, VariableVendor};
 use uefi::{guid, runtime, CStr16, Error};
 
 /// Test variable name.
@@ -16,63 +16,8 @@ const VALUE: &[u8] = b"TestValue";
 const ATTRS: VariableAttributes =
     VariableAttributes::BOOTSERVICE_ACCESS.union(VariableAttributes::RUNTIME_ACCESS);
 
-fn test_variables(rt: &RuntimeServices) {
-    info!("Testing set_variable");
-    rt.set_variable(NAME, VENDOR, ATTRS, VALUE)
-        .expect("failed to set variable");
-
-    info!("Testing get_variable_size");
-    let size = rt
-        .get_variable_size(NAME, VENDOR)
-        .expect("failed to get variable size");
-    assert_eq!(size, VALUE.len());
-
-    info!("Testing get_variable");
-    let mut buf = [0u8; 9];
-    let (data, attrs) = rt
-        .get_variable(NAME, VENDOR, &mut buf)
-        .expect("failed to get variable");
-    assert_eq!(data, VALUE);
-    assert_eq!(attrs, ATTRS);
-
-    info!("Testing get_variable_boxed");
-    let (data, attrs) = rt
-        .get_variable_boxed(NAME, VENDOR)
-        .expect("failed to get variable");
-    assert_eq!(&*data, VALUE);
-    assert_eq!(attrs, ATTRS);
-
-    info!("Testing variable_keys");
-    let variable_keys = rt.variable_keys().expect("failed to get variable keys");
-    info!("Found {} variables", variable_keys.len());
-    // There are likely a bunch of variables, only print out the first one
-    // during the test to avoid spamming the log.
-    if let Some(key) = variable_keys.first() {
-        info!("First variable: {}", key);
-    }
-
-    // Test that the `runtime::variable_keys` iterator gives exactly the same
-    // list as the `RuntimeServices::variable_keys` function.
-    assert_eq!(
-        runtime::variable_keys()
-            .map(|k| k.unwrap())
-            .collect::<alloc::vec::Vec<_>>(),
-        variable_keys
-    );
-
-    info!("Testing delete_variable()");
-    rt.delete_variable(NAME, VENDOR)
-        .expect("failed to delete variable");
-    assert_eq!(
-        rt.get_variable(NAME, VENDOR, &mut buf)
-            .unwrap_err()
-            .status(),
-        Status::NOT_FOUND
-    );
-}
-
 /// Test the variable functions in `uefi::runtime`.
-fn test_variables_freestanding() {
+fn test_variables() {
     assert!(!runtime::variable_exists(NAME, VENDOR).unwrap());
 
     // Create the test variable.
@@ -121,20 +66,17 @@ fn test_variables_freestanding() {
     assert!(!find_by_key());
 }
 
-fn test_variable_info(rt: &RuntimeServices) {
+fn test_variable_info() {
     let attr = VariableAttributes::BOOTSERVICE_ACCESS | VariableAttributes::NON_VOLATILE;
-    let info = rt.query_variable_info(attr).unwrap();
+    let info = runtime::query_variable_info(attr).unwrap();
     info!("Storage for non-volatile boot-services variables: {info:?}");
-    assert_eq!(info, runtime::query_variable_info(attr).unwrap());
 
     let attr = VariableAttributes::BOOTSERVICE_ACCESS | VariableAttributes::RUNTIME_ACCESS;
-    let info = rt.query_variable_info(attr).unwrap();
+    let info = runtime::query_variable_info(attr).unwrap();
     info!("Storage for volatile runtime variables: {info:?}");
-    assert_eq!(info, runtime::query_variable_info(attr).unwrap());
 }
 
-pub fn test(rt: &RuntimeServices) {
-    test_variables(rt);
-    test_variable_info(rt);
-    test_variables_freestanding();
+pub fn test() {
+    test_variable_info();
+    test_variables();
 }
diff --git a/uefi/CHANGELOG.md b/uefi/CHANGELOG.md
index d6dafc190..bde43e5cc 100644
--- a/uefi/CHANGELOG.md
+++ b/uefi/CHANGELOG.md
@@ -1,7 +1,12 @@
 # uefi - [Unreleased]
 
+See [Deprecating SystemTable/BootServices/RuntimeServices][funcmigrate] for
+details of the deprecated items that were removed in this release.
+
 ## Changed
-- **Breaking:** Deleted deprecated function `helpers::system_table`.
+- **Breaking:** Deleted the deprecated `RuntimeServices` struct.
+- **Breaking:** Deleted deprecated functions `helpers::system_table` and
+  `table::system_table_runtime`.
 - **Breaking:** `FileSystem` no longer has a lifetime parameter, and the
   deprecated conversion from `uefi::table::boot::ScopedProtocol` has been
   removed.
diff --git a/uefi/src/prelude.rs b/uefi/src/prelude.rs
index c346023b2..77dd0218f 100644
--- a/uefi/src/prelude.rs
+++ b/uefi/src/prelude.rs
@@ -10,6 +10,4 @@ pub use crate::{
 #[allow(deprecated)]
 pub use crate::table::boot::BootServices;
 #[allow(deprecated)]
-pub use crate::table::runtime::RuntimeServices;
-#[allow(deprecated)]
 pub use crate::table::{Boot, SystemTable};
diff --git a/uefi/src/table/boot.rs b/uefi/src/table/boot.rs
index 055ea60d2..9f491b1c6 100644
--- a/uefi/src/table/boot.rs
+++ b/uefi/src/table/boot.rs
@@ -882,30 +882,6 @@ impl BootServices {
         )
     }
 
-    /// Exits the UEFI boot services
-    ///
-    /// This unsafe method is meant to be an implementation detail of the safe
-    /// `SystemTable<Boot>::exit_boot_services()` method, which is why it is not
-    /// public.
-    ///
-    /// Everything that is explained in the documentation of the high-level
-    /// `SystemTable<Boot>` method is also true here, except that this function
-    /// is one-shot (no automatic retry) and does not prevent you from shooting
-    /// yourself in the foot by calling invalid boot services after a failure.
-    ///
-    /// # Errors
-    ///
-    /// See section `EFI_BOOT_SERVICES.ExitBootServices()` in the UEFI Specification for more details.
-    ///
-    /// * [`uefi::Status::INVALID_PARAMETER`]
-    pub(super) unsafe fn exit_boot_services(
-        &self,
-        image: Handle,
-        mmap_key: MemoryMapKey,
-    ) -> Result {
-        (self.0.exit_boot_services)(image.as_ptr(), mmap_key.0).to_result()
-    }
-
     /// Stalls the processor for an amount of time.
     ///
     /// The time is in microseconds.
diff --git a/uefi/src/table/mod.rs b/uefi/src/table/mod.rs
index 6cb848a62..c991743c9 100644
--- a/uefi/src/table/mod.rs
+++ b/uefi/src/table/mod.rs
@@ -2,14 +2,13 @@
 
 pub mod boot;
 pub mod cfg;
-pub mod runtime;
 
 mod header;
 mod system;
 
 pub use header::Header;
 #[allow(deprecated)]
-pub use system::{Boot, Runtime, SystemTable};
+pub use system::{Boot, SystemTable};
 pub use uefi_raw::table::Revision;
 
 use core::ptr::{self, NonNull};
@@ -79,25 +78,6 @@ pub fn system_table_boot() -> Option<SystemTable<Boot>> {
     }
 }
 
-/// Get the system table while runtime services are active.
-#[deprecated = "Use the uefi::runtime module instead. See https://github.com/rust-osdev/uefi-rs/blob/HEAD/docs/funcs_migration.md"]
-#[allow(deprecated)]
-pub fn system_table_runtime() -> Option<SystemTable<Runtime>> {
-    let st = SYSTEM_TABLE.load(Ordering::Acquire);
-    if st.is_null() {
-        return None;
-    }
-
-    // SAFETY: the system table is valid per the requirements of `set_system_table`.
-    unsafe {
-        if (*st).runtime_services.is_null() {
-            None
-        } else {
-            Some(SystemTable::<Runtime>::from_ptr(st.cast()).unwrap())
-        }
-    }
-}
-
 /// Common trait implemented by all standard UEFI tables.
 pub trait Table {
     /// A unique number assigned by the UEFI specification
diff --git a/uefi/src/table/runtime.rs b/uefi/src/table/runtime.rs
deleted file mode 100644
index 2c9d4d22a..000000000
--- a/uefi/src/table/runtime.rs
+++ /dev/null
@@ -1,422 +0,0 @@
-//! UEFI services available at runtime, even after the OS boots.
-
-#![allow(deprecated)]
-
-pub use crate::runtime::{
-    CapsuleInfo, Time, TimeByteConversionError, TimeError, TimeParams, VariableStorageInfo,
-};
-pub use uefi_raw::capsule::{CapsuleBlockDescriptor, CapsuleFlags, CapsuleHeader};
-pub use uefi_raw::table::runtime::{
-    ResetType, TimeCapabilities, VariableAttributes, VariableVendor,
-};
-pub use uefi_raw::time::Daylight;
-pub use uefi_raw::PhysicalAddress;
-
-#[cfg(feature = "alloc")]
-pub use crate::runtime::VariableKey;
-
-use super::Revision;
-use crate::{CStr16, Error, Result, Status, StatusExt};
-use core::mem::MaybeUninit;
-use core::ptr;
-#[cfg(feature = "alloc")]
-use {
-    crate::Guid,
-    alloc::boxed::Box,
-    alloc::{vec, vec::Vec},
-    core::mem,
-};
-
-/// Contains pointers to all of the runtime services.
-///
-/// This table, and the function pointers it contains are valid
-/// even after the UEFI OS loader and OS have taken control of the platform.
-///
-/// # Accessing `RuntimeServices`
-///
-/// A reference to `RuntimeServices` can only be accessed by calling [`SystemTable::runtime_services`].
-///
-/// [`SystemTable::runtime_services`]: crate::table::SystemTable::runtime_services
-#[deprecated = "Use the uefi::runtime module instead. See https://github.com/rust-osdev/uefi-rs/blob/HEAD/docs/funcs_migration.md"]
-#[derive(Debug)]
-#[repr(C)]
-pub struct RuntimeServices(uefi_raw::table::runtime::RuntimeServices);
-
-impl RuntimeServices {
-    /// Query the current time and date information
-    pub fn get_time(&self) -> Result<Time> {
-        let mut time = MaybeUninit::<Time>::uninit();
-        unsafe { (self.0.get_time)(time.as_mut_ptr().cast(), ptr::null_mut()) }
-            .to_result_with_val(|| unsafe { time.assume_init() })
-    }
-
-    /// Query the current time and date information and the RTC capabilities
-    pub fn get_time_and_caps(&self) -> Result<(Time, TimeCapabilities)> {
-        let mut time = MaybeUninit::<Time>::uninit();
-        let mut caps = MaybeUninit::<TimeCapabilities>::uninit();
-        unsafe { (self.0.get_time)(time.as_mut_ptr().cast(), caps.as_mut_ptr()) }
-            .to_result_with_val(|| unsafe { (time.assume_init(), caps.assume_init()) })
-    }
-
-    /// Sets the current local time and date information
-    ///
-    /// During runtime, if a PC-AT CMOS device is present in the platform, the
-    /// caller must synchronize access to the device before calling `set_time`.
-    ///
-    /// # Safety
-    ///
-    /// Undefined behavior could happen if multiple tasks try to
-    /// use this function at the same time without synchronisation.
-    pub unsafe fn set_time(&mut self, time: &Time) -> Result {
-        let time: *const Time = time;
-        (self.0.set_time)(time.cast()).to_result()
-    }
-
-    /// Get the size (in bytes) of a variable. This can be used to find out how
-    /// big of a buffer should be passed in to `get_variable`.
-    pub fn get_variable_size(&self, name: &CStr16, vendor: &VariableVendor) -> Result<usize> {
-        let mut data_size = 0;
-        let status = unsafe {
-            (self.0.get_variable)(
-                name.as_ptr().cast(),
-                &vendor.0,
-                ptr::null_mut(),
-                &mut data_size,
-                ptr::null_mut(),
-            )
-        };
-
-        if status == Status::BUFFER_TOO_SMALL {
-            Status::SUCCESS.to_result_with_val(|| data_size)
-        } else {
-            Err(Error::from(status))
-        }
-    }
-
-    /// Get the contents and attributes of a variable. The size of `buf` must
-    /// be at least as big as the variable's size, although it can be
-    /// larger. If it is too small, `BUFFER_TOO_SMALL` is returned.
-    ///
-    /// On success, a tuple containing the variable's value (a slice of `buf`)
-    /// and the variable's attributes is returned.
-    pub fn get_variable<'a>(
-        &self,
-        name: &CStr16,
-        vendor: &VariableVendor,
-        buf: &'a mut [u8],
-    ) -> Result<(&'a [u8], VariableAttributes)> {
-        let mut attributes = VariableAttributes::empty();
-        let mut data_size = buf.len();
-        unsafe {
-            (self.0.get_variable)(
-                name.as_ptr().cast(),
-                &vendor.0,
-                &mut attributes,
-                &mut data_size,
-                buf.as_mut_ptr(),
-            )
-            .to_result_with_val(move || (&buf[..data_size], attributes))
-        }
-    }
-
-    /// Get the contents and attributes of a variable.
-    #[cfg(feature = "alloc")]
-    pub fn get_variable_boxed(
-        &self,
-        name: &CStr16,
-        vendor: &VariableVendor,
-    ) -> Result<(Box<[u8]>, VariableAttributes)> {
-        let mut attributes = VariableAttributes::empty();
-
-        let mut data_size = self.get_variable_size(name, vendor)?;
-        let mut data = Vec::with_capacity(data_size);
-
-        let status = unsafe {
-            (self.0.get_variable)(
-                name.as_ptr().cast(),
-                &vendor.0,
-                &mut attributes,
-                &mut data_size,
-                data.as_mut_ptr(),
-            )
-        };
-        if !status.is_success() {
-            return Err(Error::from(status));
-        }
-
-        unsafe {
-            data.set_len(data_size);
-        }
-
-        Ok((data.into_boxed_slice(), attributes))
-    }
-
-    /// Get the names and vendor GUIDs of all currently-set variables.
-    #[cfg(feature = "alloc")]
-    pub fn variable_keys(&self) -> Result<Vec<VariableKey>> {
-        let mut all_variables = Vec::new();
-
-        // The initial value of name must start with a null character. Start
-        // out with a reasonable size that likely won't need to be increased.
-        let mut name = vec![0u16; 32];
-        // The initial value of vendor is ignored.
-        let mut vendor = Guid::default();
-
-        let mut status;
-        loop {
-            let mut name_size_in_bytes = name.len() * mem::size_of::<u16>();
-            status = unsafe {
-                (self.0.get_next_variable_name)(
-                    &mut name_size_in_bytes,
-                    name.as_mut_ptr(),
-                    &mut vendor,
-                )
-            };
-
-            match status {
-                Status::SUCCESS => {
-                    // CStr16::from_u16_with_nul does not allow interior nulls,
-                    // so make the copy exactly the right size.
-                    let name = if let Some(nul_pos) = name.iter().position(|c| *c == 0) {
-                        name[..=nul_pos].to_vec()
-                    } else {
-                        status = Status::ABORTED;
-                        break;
-                    };
-
-                    all_variables.push(VariableKey {
-                        name,
-                        vendor: VariableVendor(vendor),
-                    });
-                }
-                Status::BUFFER_TOO_SMALL => {
-                    // The name buffer passed in was too small, resize it to be
-                    // big enough for the next variable name.
-                    name.resize(name_size_in_bytes / 2, 0);
-                }
-                Status::NOT_FOUND => {
-                    // This status indicates the end of the list. The final
-                    // variable has already been received at this point, so
-                    // no new variable should be added to the output.
-                    status = Status::SUCCESS;
-                    break;
-                }
-                _ => {
-                    // For anything else, an error has occurred so break out of
-                    // the loop and return it.
-                    break;
-                }
-            }
-        }
-
-        status.to_result_with_val(|| all_variables)
-    }
-
-    /// Set the value of a variable. This can be used to create a new variable,
-    /// update an existing variable, or (when the size of `data` is zero)
-    /// delete a variable.
-    ///
-    /// # Warnings
-    ///
-    /// The [`Status::WARN_RESET_REQUIRED`] warning will be returned when using
-    /// this function to transition the Secure Boot mode to setup mode or audit
-    /// mode if the firmware requires a reboot for that operation.
-    pub fn set_variable(
-        &self,
-        name: &CStr16,
-        vendor: &VariableVendor,
-        attributes: VariableAttributes,
-        data: &[u8],
-    ) -> Result {
-        unsafe {
-            (self.0.set_variable)(
-                name.as_ptr().cast(),
-                &vendor.0,
-                attributes,
-                data.len(),
-                data.as_ptr(),
-            )
-            .to_result()
-        }
-    }
-
-    /// Deletes a UEFI variable.
-    pub fn delete_variable(&self, name: &CStr16, vendor: &VariableVendor) -> Result {
-        self.set_variable(name, vendor, VariableAttributes::empty(), &[])
-    }
-
-    /// Get information about UEFI variable storage space for the type
-    /// of variable specified in `attributes`.
-    ///
-    /// This operation is only supported starting with UEFI 2.0; earlier
-    /// versions will fail with [`Status::UNSUPPORTED`].
-    ///
-    /// See [`VariableStorageInfo`] for details of the information returned.
-    pub fn query_variable_info(
-        &self,
-        attributes: VariableAttributes,
-    ) -> Result<VariableStorageInfo> {
-        if self.0.header.revision < Revision::EFI_2_00 {
-            return Err(Status::UNSUPPORTED.into());
-        }
-
-        let mut info = VariableStorageInfo::default();
-        unsafe {
-            (self.0.query_variable_info)(
-                attributes,
-                &mut info.maximum_variable_storage_size,
-                &mut info.remaining_variable_storage_size,
-                &mut info.maximum_variable_size,
-            )
-            .to_result_with_val(|| info)
-        }
-    }
-
-    /// Resets the computer.
-    pub fn reset(&self, rt: ResetType, status: Status, data: Option<&[u8]>) -> ! {
-        let (size, data) = match data {
-            // FIXME: The UEFI spec states that the data must start with a NUL-
-            //        terminated string, which we should check... but it does not
-            //        specify if that string should be Latin-1 or UCS-2!
-            //
-            //        PlatformSpecific resets should also insert a GUID after the
-            //        NUL-terminated string.
-            Some(data) => (data.len(), data.as_ptr()),
-            None => (0, ptr::null()),
-        };
-
-        unsafe { (self.0.reset_system)(rt, status, size, data) }
-    }
-
-    pub(crate) unsafe fn set_virtual_address_map(
-        &self,
-        map_size: usize,
-        desc_size: usize,
-        desc_version: u32,
-        virtual_map: *mut crate::mem::memory_map::MemoryDescriptor,
-    ) -> Status {
-        (self.0.set_virtual_address_map)(map_size, desc_size, desc_version, virtual_map)
-    }
-
-    /// Passes capsules to the firmware. Capsules are most commonly used to update system firmware.
-    pub fn update_capsule(
-        &self,
-        capsule_header_array: &[&CapsuleHeader],
-        capsule_block_descriptors: &[CapsuleBlockDescriptor],
-    ) -> Result {
-        unsafe {
-            (self.0.update_capsule)(
-                capsule_header_array.as_ptr().cast(),
-                capsule_header_array.len(),
-                capsule_block_descriptors.as_ptr() as PhysicalAddress,
-            )
-            .to_result()
-        }
-    }
-
-    /// Tests whether a capsule or capsules can be updated via [`RuntimeServices::update_capsule`].
-    ///
-    /// See [`CapsuleInfo`] for details of the information returned.
-    pub fn query_capsule_capabilities(
-        &self,
-        capsule_header_array: &[&CapsuleHeader],
-    ) -> Result<CapsuleInfo> {
-        let mut info = CapsuleInfo::default();
-        unsafe {
-            (self.0.query_capsule_capabilities)(
-                capsule_header_array.as_ptr().cast(),
-                capsule_header_array.len(),
-                &mut info.maximum_capsule_size,
-                &mut info.reset_type,
-            )
-            .to_result_with_val(|| info)
-        }
-    }
-}
-
-impl super::Table for RuntimeServices {
-    const SIGNATURE: u64 = 0x5652_4553_544e_5552;
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use alloc::string::ToString;
-    use core::{slice, usize};
-
-    unsafe fn time_as_u8_slice(p: &Time) -> &[u8] {
-        slice::from_raw_parts(core::ptr::addr_of!(*p).cast(), size_of::<Time>())
-    }
-
-    unsafe fn time_as_u8_slice_with_size(p: &Time, len: usize) -> &[u8] {
-        slice::from_raw_parts(core::ptr::addr_of!(*p).cast(), len)
-    }
-
-    #[test]
-    fn test_successful_time_from_bytes() {
-        let mut time;
-        let mut time_from_bytes;
-        let mut time_params = TimeParams {
-            year: 2024,
-            month: 6,
-            day: 13,
-            hour: 4,
-            minute: 29,
-            second: 30,
-            nanosecond: 123_456_789,
-            time_zone: None,
-            daylight: Daylight::empty(),
-        };
-
-        time = Time::new(time_params).unwrap();
-        unsafe {
-            time_from_bytes = Time::try_from(time_as_u8_slice(&time)).unwrap();
-        }
-        assert_eq!(time, time_from_bytes);
-
-        time_params.time_zone = Some(120);
-        time = Time::new(time_params).unwrap();
-        unsafe {
-            time_from_bytes = Time::try_from(time_as_u8_slice(&time)).unwrap();
-        }
-        assert_eq!(time.to_string(), time_from_bytes.to_string());
-
-        time_params.time_zone = Some(150);
-        time = Time::new(time_params).unwrap();
-        unsafe {
-            time_from_bytes = Time::try_from(time_as_u8_slice(&time)).unwrap();
-        }
-        assert_eq!(time.to_string(), time_from_bytes.to_string());
-    }
-
-    #[test]
-    fn test_invalid_fields_in_time_byte_conversion() {
-        let time = Time::invalid();
-        let time_from_bytes;
-        unsafe {
-            time_from_bytes = Time::try_from(time_as_u8_slice(&time)).unwrap_err();
-        }
-        assert_eq!(
-            TimeByteConversionError::InvalidFields(TimeError {
-                year: true,
-                month: true,
-                day: true,
-                ..Default::default()
-            }),
-            time_from_bytes
-        );
-    }
-
-    #[test]
-    fn test_byte_slice_too_small_to_convert_to_time() {
-        let time = Time::invalid();
-        let time_from_bytes;
-        unsafe {
-            time_from_bytes =
-                Time::try_from(time_as_u8_slice_with_size(&time, size_of::<Time>() - 1))
-                    .unwrap_err();
-        }
-        assert_eq!(TimeByteConversionError::InvalidSize, time_from_bytes);
-    }
-}
diff --git a/uefi/src/table/system.rs b/uefi/src/table/system.rs
index 9fc0b8054..2d32219f1 100644
--- a/uefi/src/table/system.rs
+++ b/uefi/src/table/system.rs
@@ -1,17 +1,13 @@
 #![allow(deprecated)]
 
 use super::boot::BootServices;
-use super::runtime::{ResetType, RuntimeServices};
 use super::{cfg, Revision};
 use crate::proto::console::text;
-use crate::{CStr16, Result, Status, StatusExt};
+use crate::CStr16;
 use core::ffi::c_void;
 use core::marker::PhantomData;
 use core::ptr::NonNull;
 use core::slice;
-use uefi::mem::memory_map::{
-    MemoryDescriptor, MemoryMapBackingMemory, MemoryMapMeta, MemoryMapOwned, MemoryType,
-};
 
 /// Marker trait used to provide different views of the UEFI System Table.
 #[deprecated = "Use the uefi::system, uefi::boot, and uefi::runtime modules instead. See https://github.com/rust-osdev/uefi-rs/blob/HEAD/docs/funcs_migration.md"]
@@ -23,12 +19,6 @@ pub trait SystemTableView {}
 pub struct Boot;
 impl SystemTableView for Boot {}
 
-/// Marker struct associated with the run-time view of the UEFI System Table.
-#[deprecated = "Use the uefi::runtime module instead. See https://github.com/rust-osdev/uefi-rs/blob/HEAD/docs/funcs_migration.md"]
-#[derive(Debug)]
-pub struct Runtime;
-impl SystemTableView for Runtime {}
-
 /// UEFI System Table interface
 ///
 /// The UEFI System Table is the gateway to all UEFI services which an UEFI
@@ -146,134 +136,12 @@ impl SystemTable<Boot> {
         unsafe { &mut *(*self.table).stderr.cast() }
     }
 
-    /// Access runtime services
-    #[must_use]
-    pub const fn runtime_services(&self) -> &RuntimeServices {
-        unsafe { &*(*self.table).runtime_services.cast_const().cast() }
-    }
-
     /// Access boot services
     #[must_use]
     pub const fn boot_services(&self) -> &BootServices {
         unsafe { &*(*self.table).boot_services.cast_const().cast() }
     }
 
-    /// Get the current memory map and exit boot services.
-    unsafe fn get_memory_map_and_exit_boot_services(
-        &self,
-        buf: &mut [u8],
-    ) -> Result<MemoryMapMeta> {
-        let boot_services = self.boot_services();
-
-        // Get the memory map.
-        let memory_map = boot_services.get_memory_map(buf)?;
-
-        // Try to exit boot services using the memory map key. Note that after
-        // the first call to `exit_boot_services`, there are restrictions on
-        // what boot services functions can be called. In UEFI 2.8 and earlier,
-        // only `get_memory_map` and `exit_boot_services` are allowed. Starting
-        // in UEFI 2.9 other memory allocation functions may also be called.
-        boot_services
-            .exit_boot_services(boot_services.image_handle(), memory_map.map_key)
-            .map(move |()| memory_map)
-    }
-
-    /// Exit the UEFI boot services.
-    ///
-    /// After this function completes, UEFI hands over control of the hardware
-    /// to the executing OS loader, which implies that the UEFI boot services
-    /// are shut down and cannot be used anymore. Only UEFI configuration tables
-    /// and run-time services can be used, and the latter requires special care
-    /// from the OS loader. We model this situation by consuming the
-    /// `SystemTable<Boot>` view of the System Table and returning a more
-    /// restricted `SystemTable<Runtime>` view as an output.
-    ///
-    /// The memory map at the time of exiting boot services is also
-    /// returned. The map is backed by a allocation with given `memory_type`.
-    /// Since the boot services function to free that memory is no
-    /// longer available after calling `exit_boot_services`, the allocation is
-    /// live until the program ends. The lifetime of the memory map is therefore
-    /// `'static`.
-    ///
-    /// Note that once the boot services are exited, associated loggers and
-    /// allocators can't use the boot services anymore. For the corresponding
-    /// abstractions provided by this crate (see the [`helpers`] module),
-    /// invoking this function will automatically disable them. If the
-    /// `global_allocator` feature is enabled, attempting to use the allocator
-    /// after exiting boot services will panic.
-    ///
-    /// # Safety
-    ///
-    /// The caller is responsible for ensuring that no references to
-    /// boot-services data remain. A non-exhaustive list of resources to check:
-    ///
-    /// * All protocols will be invalid after exiting boot services. This
-    ///   includes the [`Output`] protocols attached to stdout/stderr. The
-    ///   caller must ensure that no protocol references remain.
-    /// * The pool allocator is not usable after exiting boot services. Types
-    ///   such as [`PoolString`] which call [`BootServices::free_pool`] on drop
-    ///   must be cleaned up before calling `exit_boot_services`, or leaked to
-    ///   avoid drop ever being called.
-    /// * All data in the memory map marked as
-    ///   [`MemoryType::BOOT_SERVICES_CODE`] and
-    ///   [`MemoryType::BOOT_SERVICES_DATA`] will become free memory, the caller
-    ///   must ensure that no references to such memory exist.
-    ///
-    /// # Errors
-    ///
-    /// This function will fail if it is unable to allocate memory for
-    /// the memory map, if it fails to retrieve the memory map, or if
-    /// exiting boot services fails (with up to one retry).
-    ///
-    /// All errors are treated as unrecoverable because the system is
-    /// now in an undefined state. Rather than returning control to the
-    /// caller, the system will be reset.
-    ///
-    /// [`helpers`]: crate::helpers
-    /// [`Output`]: crate::proto::console::text::Output
-    /// [`PoolString`]: crate::proto::device_path::text::PoolString
-    #[must_use]
-    pub unsafe fn exit_boot_services(
-        self,
-        memory_type: MemoryType,
-    ) -> (SystemTable<Runtime>, MemoryMapOwned) {
-        crate::helpers::exit();
-
-        // Reboot the device.
-        let reset = |status| -> ! {
-            {
-                log::warn!("Resetting the machine");
-                self.runtime_services().reset(ResetType::COLD, status, None)
-            }
-        };
-
-        let mut buf = MemoryMapBackingMemory::new(memory_type).expect("Failed to allocate memory");
-
-        // Calling `exit_boot_services` can fail if the memory map key is not
-        // current. Retry a second time if that occurs. This matches the
-        // behavior of the Linux kernel:
-        // https://github.com/torvalds/linux/blob/e544a0743/drivers/firmware/efi/libstub/efi-stub-helper.c#L375
-        let mut status = Status::ABORTED;
-        for _ in 0..2 {
-            match unsafe { self.get_memory_map_and_exit_boot_services(buf.as_mut_slice()) } {
-                Ok(memory_map) => {
-                    let st = SystemTable {
-                        table: self.table,
-                        _marker: PhantomData,
-                    };
-                    return (st, MemoryMapOwned::from_initialized_mem(buf, memory_map));
-                }
-                Err(err) => {
-                    log::error!("Error retrieving the memory map for exiting the boot services");
-                    status = err.status()
-                }
-            }
-        }
-
-        // Failed to exit boot services.
-        reset(status)
-    }
-
     /// Clone this boot-time UEFI system table interface
     ///
     /// # Safety
@@ -291,65 +159,6 @@ impl SystemTable<Boot> {
     }
 }
 
-// These parts of the SystemTable struct are only visible after exit from UEFI
-// boot services. They provide unsafe access to the UEFI runtime services, which
-// which were already available before but in safe form.
-impl SystemTable<Runtime> {
-    /// Access runtime services
-    ///
-    /// # Safety
-    ///
-    /// This is unsafe because UEFI runtime services require an elaborate
-    /// CPU configuration which may not be preserved by OS loaders. See the
-    /// "Calling Conventions" chapter of the UEFI specification for details.
-    #[must_use]
-    pub const unsafe fn runtime_services(&self) -> &RuntimeServices {
-        &*(*self.table).runtime_services.cast_const().cast()
-    }
-
-    /// Changes the runtime addressing mode of EFI firmware from physical to virtual.
-    /// It is up to the caller to translate the old SystemTable address to a new virtual
-    /// address and provide it for this function.
-    /// See [`get_current_system_table_addr`]
-    ///
-    /// # Safety
-    ///
-    /// Setting new virtual memory map is unsafe and may cause undefined behaviors.
-    ///
-    /// [`get_current_system_table_addr`]: SystemTable::get_current_system_table_addr
-    pub unsafe fn set_virtual_address_map(
-        self,
-        map: &mut [MemoryDescriptor],
-        new_system_table_virtual_addr: u64,
-    ) -> Result<Self> {
-        // Unsafe Code Guidelines guarantees that there is no padding in an array or a slice
-        // between its elements if the element type is `repr(C)`, which is our case.
-        //
-        // See https://rust-lang.github.io/unsafe-code-guidelines/layout/arrays-and-slices.html
-        let map_size = core::mem::size_of_val(map);
-        let entry_size = core::mem::size_of::<MemoryDescriptor>();
-        let entry_version = MemoryDescriptor::VERSION;
-        let map_ptr = map.as_mut_ptr();
-        self.runtime_services()
-            .set_virtual_address_map(map_size, entry_size, entry_version, map_ptr)
-            .to_result_with_val(|| {
-                let new_table_ref = &mut *(new_system_table_virtual_addr as usize
-                    as *mut uefi_raw::table::system::SystemTable);
-                Self {
-                    table: new_table_ref,
-                    _marker: PhantomData,
-                }
-            })
-    }
-
-    /// Return the address of the SystemTable that resides in a UEFI runtime services
-    /// memory region.
-    #[must_use]
-    pub fn get_current_system_table_addr(&self) -> u64 {
-        self.table as u64
-    }
-}
-
 impl<View: SystemTableView> super::Table for SystemTable<View> {
     const SIGNATURE: u64 = 0x5453_5953_2049_4249;
 }