zircon/kernel/lib/page_cache/page_cache_ffi.rs

// Copyright 2021 The Fuchsia Authors
//
// Use of this source code is governed by a MIT-style
// license that can be found in the LICENSE file or at
// https://opensource.org/licenses/MIT

use super::{PageCache, PageList};
use core::ffi::c_int;
use core::mem::MaybeUninit;
use core::pin::Pin;
use zx_types::zx_status_t;

unsafe extern "C" {
    pub(super) fn cpp_global_prng_draw(buffer: *mut u8, len: usize);
    pub(super) fn rand_r(seed: *mut usize) -> c_int;
}

// C++ FFI entry points for `page_cache::PageCache` in `<lib/page_cache.h>`.

/// Initializes a `PageCache` in-place at `out_cache`.
#[unsafe(no_mangle)]
pub extern "C" fn rust_page_cache_create(
    reserve_pages: usize,
    out_cache: &mut MaybeUninit<PageCache>,
) -> zx_status_t {
    match PageCache::new(reserve_pages) {
        Ok(cache) => {
            out_cache.write(cache);
            zx_status::sys::ZX_OK
        }
        Err(status) => status.into_raw(),
    }
}

/// Drops a `PageCache` in-place at `cache`.
///
/// # Safety
///
/// `cache` must point to a valid, initialized `PageCache` that has not yet been dropped.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn rust_page_cache_destroy(cache: *mut PageCache) {
    debug_assert!(!cache.is_null());
    // SAFETY: Caller guarantees `cache` is a valid initialized `PageCache`.
    unsafe {
        core::ptr::drop_in_place(cache);
    }
}

/// Seeds the random should-wait state for all per-CPU caches in `cache`.
#[unsafe(no_mangle)]
pub extern "C" fn rust_page_cache_seed_random_should_wait(cache: &PageCache) {
    cache.seed_random_should_wait();
}

/// Allocates `page_count` pages from `cache` into `out_pages` and writes the
/// remaining available pages to `out_available_pages`.
///
/// # Safety
///
/// `out_pages` must be pinned in memory.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn rust_page_cache_allocate(
    cache: &PageCache,
    page_count: usize,
    alloc_flags: u32,
    out_pages: &mut PageList,
    out_available_pages: &mut usize,
) -> zx_status_t {
    // SAFETY: Caller guarantees `out_pages` is pinned.
    let out_pages = unsafe { Pin::new_unchecked(out_pages) };
    match cache.allocate(page_count, alloc_flags, out_pages) {
        Ok(available_pages) => {
            *out_available_pages = available_pages;
            zx_status::sys::ZX_OK
        }
        Err(status) => status.into_raw(),
    }
}

/// Frees `page_list` into `cache`, returning any excess pages to the PMM.
///
/// # Safety
///
/// `page_list` must be pinned in memory.
#[unsafe(no_mangle)]
pub unsafe extern "C" fn rust_page_cache_free(cache: &PageCache, page_list: &mut PageList) {
    // SAFETY: Caller guarantees `page_list` is pinned.
    let page_list = unsafe { Pin::new_unchecked(page_list) };
    cache.free(page_list);
}