rusticl/mesa/screen: convert to ThreadSafeCPtr

Signed-off-by: Karol Herbst <kherbst@redhat.com>
Part-of: <https://gitlab.freedesktop.org/mesa/mesa/-/merge_requests/26040>
This commit is contained in:
Karol Herbst 2023-07-09 02:36:46 +02:00 committed by Marge Bot
parent ef8461b84f
commit 1166944124

View file

@ -6,6 +6,7 @@ use crate::util::disk_cache::*;
use mesa_rust_gen::*;
use mesa_rust_util::has_required_feature;
use mesa_rust_util::ptr::ThreadSafeCPtr;
use mesa_rust_util::string::*;
use std::convert::TryInto;
@ -20,7 +21,7 @@ use std::sync::Arc;
#[derive(PartialEq)]
pub struct PipeScreen {
ldev: PipeLoaderDevice,
screen: *mut pipe_screen,
screen: ThreadSafeCPtr<pipe_screen>,
}
pub const UUID_SIZE: usize = PIPE_UUID_SIZE as usize;
@ -99,14 +100,24 @@ impl PipeScreen {
return None;
}
Some(Self { ldev, screen })
Some(Self {
ldev,
// SAFETY: `pipe_screen` is considered a thread-safe type
screen: unsafe { ThreadSafeCPtr::new(screen)? },
})
}
fn screen(&self) -> &pipe_screen {
// SAFETY: We own the pointer, so it's valid for every caller of this function as we are
// responsible of freeing it.
unsafe { self.screen.as_ref() }
}
pub fn create_context(self: &Arc<Self>) -> Option<PipeContext> {
PipeContext::new(
unsafe {
(*self.screen).context_create.unwrap()(
self.screen,
self.screen().context_create.unwrap()(
self.screen.as_ptr(),
ptr::null_mut(),
PIPE_CONTEXT_COMPUTE_ONLY | PIPE_CONTEXT_NO_LOD_BIAS,
)
@ -117,7 +128,7 @@ impl PipeScreen {
fn resource_create(&self, tmpl: &pipe_resource) -> Option<PipeResource> {
PipeResource::new(
unsafe { (*self.screen).resource_create.unwrap()(self.screen, tmpl) },
unsafe { self.screen().resource_create.unwrap()(self.screen.as_ptr(), tmpl) },
false,
)
}
@ -127,13 +138,10 @@ impl PipeScreen {
tmpl: &pipe_resource,
mem: *mut c_void,
) -> Option<PipeResource> {
unsafe {
if let Some(func) = (*self.screen).resource_from_user_memory {
PipeResource::new(func(self.screen, tmpl, mem), true)
} else {
None
}
}
PipeResource::new(
unsafe { self.screen().resource_from_user_memory?(self.screen.as_ptr(), tmpl, mem) },
true,
)
}
pub fn resource_create_buffer(
@ -263,24 +271,29 @@ impl PipeScreen {
unsafe {
PipeResource::new(
(*self.screen).resource_from_handle.unwrap()(self.screen, &tmpl, &mut handle, 0),
self.screen().resource_from_handle.unwrap()(
self.screen.as_ptr(),
&tmpl,
&mut handle,
0,
),
false,
)
}
}
pub fn param(&self, cap: pipe_cap) -> i32 {
unsafe { (*self.screen).get_param.unwrap()(self.screen, cap) }
unsafe { self.screen().get_param.unwrap()(self.screen.as_ptr(), cap) }
}
pub fn shader_param(&self, t: pipe_shader_type, cap: pipe_shader_cap) -> i32 {
unsafe { (*self.screen).get_shader_param.unwrap()(self.screen, t, cap) }
unsafe { self.screen().get_shader_param.unwrap()(self.screen.as_ptr(), t, cap) }
}
fn compute_param_wrapped(&self, cap: pipe_compute_cap, ptr: *mut c_void) -> i32 {
unsafe {
(*self.screen).get_compute_param.unwrap()(
self.screen,
self.screen().get_compute_param.unwrap()(
self.screen.as_ptr(),
pipe_shader_ir::PIPE_SHADER_IR_NIR,
cap,
ptr,
@ -293,18 +306,18 @@ impl PipeScreen {
}
pub fn name(&self) -> String {
unsafe { c_string_to_string((*self.screen).get_name.unwrap()(self.screen)) }
unsafe { c_string_to_string(self.screen().get_name.unwrap()(self.screen.as_ptr())) }
}
pub fn device_node_mask(&self) -> Option<u32> {
unsafe { Some((*self.screen).get_device_node_mask?(self.screen)) }
unsafe { Some(self.screen().get_device_node_mask?(self.screen.as_ptr())) }
}
pub fn device_uuid(&self) -> Option<[c_uchar; UUID_SIZE]> {
let mut uuid = [0; UUID_SIZE];
let ptr = uuid.as_mut_ptr();
unsafe {
(*self.screen).get_device_uuid?(self.screen, ptr.cast());
self.screen().get_device_uuid?(self.screen.as_ptr(), ptr.cast());
}
Some(uuid)
@ -313,13 +326,17 @@ impl PipeScreen {
pub fn device_luid(&self) -> Option<[c_uchar; LUID_SIZE]> {
let mut luid = [0; LUID_SIZE];
let ptr = luid.as_mut_ptr();
unsafe { (*self.screen).get_device_luid?(self.screen, ptr.cast()) }
unsafe { self.screen().get_device_luid?(self.screen.as_ptr(), ptr.cast()) }
Some(luid)
}
pub fn device_vendor(&self) -> String {
unsafe { c_string_to_string((*self.screen).get_device_vendor.unwrap()(self.screen)) }
unsafe {
c_string_to_string(self.screen().get_device_vendor.unwrap()(
self.screen.as_ptr(),
))
}
}
pub fn device_type(&self) -> pipe_loader_device_type {
@ -330,7 +347,7 @@ impl PipeScreen {
let mut uuid = [0; UUID_SIZE];
let ptr = uuid.as_mut_ptr();
unsafe {
(*self.screen).get_driver_uuid?(self.screen, ptr.cast());
self.screen().get_driver_uuid?(self.screen.as_ptr(), ptr.cast());
}
Some(uuid)
@ -338,10 +355,11 @@ impl PipeScreen {
pub fn cl_cts_version(&self) -> &CStr {
unsafe {
let ptr = (*self.screen)
let ptr = self
.screen()
.get_cl_cts_version
.map_or(ptr::null(), |get_cl_cts_version| {
get_cl_cts_version(self.screen)
get_cl_cts_version(self.screen.as_ptr())
});
if ptr.is_null() {
// this string is good enough to pass the CTS
@ -359,24 +377,28 @@ impl PipeScreen {
bindings: u32,
) -> bool {
unsafe {
(*self.screen).is_format_supported.unwrap()(self.screen, format, target, 0, 0, bindings)
self.screen().is_format_supported.unwrap()(
self.screen.as_ptr(),
format,
target,
0,
0,
bindings,
)
}
}
pub fn get_timestamp(&self) -> u64 {
// We have get_timestamp in has_required_cbs, so it will exist
unsafe {
(*self.screen)
self.screen()
.get_timestamp
.expect("get_timestamp should be required")(self.screen)
.expect("get_timestamp should be required")(self.screen.as_ptr())
}
}
pub fn is_res_handle_supported(&self) -> bool {
unsafe {
(*self.screen).resource_from_handle.is_some()
&& (*self.screen).resource_get_handle.is_some()
}
self.screen().resource_from_handle.is_some() && self.screen().resource_get_handle.is_some()
}
pub fn nir_shader_compiler_options(
@ -384,8 +406,8 @@ impl PipeScreen {
shader: pipe_shader_type,
) -> *const nir_shader_compiler_options {
unsafe {
(*self.screen).get_compiler_options.unwrap()(
self.screen,
self.screen().get_compiler_options.unwrap()(
self.screen.as_ptr(),
pipe_shader_ir::PIPE_SHADER_IR_NIR,
shader,
)
@ -394,33 +416,33 @@ impl PipeScreen {
}
pub fn shader_cache(&self) -> Option<DiskCacheBorrowed> {
let ptr = if let Some(func) = unsafe { *self.screen }.get_disk_shader_cache {
unsafe { func(self.screen) }
} else {
ptr::null_mut()
};
let ptr = unsafe { self.screen().get_disk_shader_cache?(self.screen.as_ptr()) };
DiskCacheBorrowed::from_ptr(ptr)
}
pub fn finalize_nir(&self, nir: &NirShader) {
if let Some(func) = unsafe { *self.screen }.finalize_nir {
if let Some(func) = self.screen().finalize_nir {
unsafe {
func(self.screen, nir.get_nir().cast());
func(self.screen.as_ptr(), nir.get_nir().cast());
}
}
}
pub(super) fn unref_fence(&self, mut fence: *mut pipe_fence_handle) {
unsafe {
(*self.screen).fence_reference.unwrap()(self.screen, &mut fence, ptr::null_mut());
self.screen().fence_reference.unwrap()(
self.screen.as_ptr(),
&mut fence,
ptr::null_mut(),
);
}
}
pub(super) fn fence_finish(&self, fence: *mut pipe_fence_handle) {
unsafe {
(*self.screen).fence_finish.unwrap()(
self.screen,
self.screen().fence_finish.unwrap()(
self.screen.as_ptr(),
ptr::null_mut(),
fence,
OS_TIMEOUT_INFINITE as u64,
@ -431,9 +453,7 @@ impl PipeScreen {
impl Drop for PipeScreen {
fn drop(&mut self) {
unsafe {
(*self.screen).destroy.unwrap()(self.screen);
}
unsafe { self.screen().destroy.unwrap()(self.screen.as_ptr()) }
}
}