1 // Copyright 2024, Linaro Limited 2 // Author(s): Manos Pitsidianakis <manos.pitsidianakis@linaro.org> 3 // SPDX-License-Identifier: GPL-2.0-or-later 4 5 #![cfg_attr(not(MESON), doc = include_str!("../README.md"))] 6 7 #[allow( 8 dead_code, 9 improper_ctypes_definitions, 10 improper_ctypes, 11 non_camel_case_types, 12 non_snake_case, 13 non_upper_case_globals, 14 unsafe_op_in_unsafe_fn, 15 clippy::missing_const_for_fn, 16 clippy::too_many_arguments, 17 clippy::approx_constant, 18 clippy::use_self, 19 clippy::useless_transmute, 20 clippy::missing_safety_doc, 21 )] 22 #[rustfmt::skip] 23 pub mod bindings; 24 25 unsafe impl Send for bindings::Property {} 26 unsafe impl Sync for bindings::Property {} 27 unsafe impl Sync for bindings::TypeInfo {} 28 unsafe impl Sync for bindings::VMStateDescription {} 29 unsafe impl Sync for bindings::VMStateField {} 30 unsafe impl Sync for bindings::VMStateInfo {} 31 32 pub mod c_str; 33 pub mod definitions; 34 pub mod device_class; 35 pub mod offset_of; 36 pub mod vmstate; 37 pub mod zeroable; 38 39 use std::{ 40 alloc::{GlobalAlloc, Layout}, 41 os::raw::c_void, 42 }; 43 44 #[cfg(HAVE_GLIB_WITH_ALIGNED_ALLOC)] 45 extern "C" { 46 fn g_aligned_alloc0( 47 n_blocks: bindings::gsize, 48 n_block_bytes: bindings::gsize, 49 alignment: bindings::gsize, 50 ) -> bindings::gpointer; 51 fn g_aligned_free(mem: bindings::gpointer); 52 } 53 54 #[cfg(not(HAVE_GLIB_WITH_ALIGNED_ALLOC))] 55 extern "C" { 56 fn qemu_memalign(alignment: usize, size: usize) -> *mut c_void; 57 fn qemu_vfree(ptr: *mut c_void); 58 } 59 60 extern "C" { 61 fn g_malloc0(n_bytes: bindings::gsize) -> bindings::gpointer; 62 fn g_free(mem: bindings::gpointer); 63 } 64 65 /// An allocator that uses the same allocator as QEMU in C. 66 /// 67 /// It is enabled by default with the `allocator` feature. 68 /// 69 /// To set it up manually as a global allocator in your crate: 70 /// 71 /// ```ignore 72 /// use qemu_api::QemuAllocator; 73 /// 74 /// #[global_allocator] 75 /// static GLOBAL: QemuAllocator = QemuAllocator::new(); 76 /// ``` 77 #[derive(Clone, Copy, Debug)] 78 #[repr(C)] 79 pub struct QemuAllocator { 80 _unused: [u8; 0], 81 } 82 83 #[cfg_attr(all(feature = "allocator", not(test)), global_allocator)] 84 pub static GLOBAL: QemuAllocator = QemuAllocator::new(); 85 86 impl QemuAllocator { 87 // From the glibc documentation, on GNU systems, malloc guarantees 16-byte 88 // alignment on 64-bit systems and 8-byte alignment on 32-bit systems. See 89 // https://www.gnu.org/software/libc/manual/html_node/Malloc-Examples.html. 90 // This alignment guarantee also applies to Windows and Android. On Darwin 91 // and OpenBSD, the alignment is 16 bytes on both 64-bit and 32-bit systems. 92 #[cfg(all( 93 target_pointer_width = "32", 94 not(any(target_os = "macos", target_os = "openbsd")) 95 ))] 96 pub const DEFAULT_ALIGNMENT_BYTES: Option<usize> = Some(8); 97 #[cfg(all( 98 target_pointer_width = "64", 99 not(any(target_os = "macos", target_os = "openbsd")) 100 ))] 101 pub const DEFAULT_ALIGNMENT_BYTES: Option<usize> = Some(16); 102 #[cfg(all( 103 any(target_pointer_width = "32", target_pointer_width = "64"), 104 any(target_os = "macos", target_os = "openbsd") 105 ))] 106 pub const DEFAULT_ALIGNMENT_BYTES: Option<usize> = Some(16); 107 #[cfg(not(any(target_pointer_width = "32", target_pointer_width = "64")))] 108 pub const DEFAULT_ALIGNMENT_BYTES: Option<usize> = None; 109 110 pub const fn new() -> Self { 111 Self { _unused: [] } 112 } 113 } 114 115 impl Default for QemuAllocator { 116 fn default() -> Self { 117 Self::new() 118 } 119 } 120 121 // Sanity check. 122 const _: [(); 8] = [(); ::core::mem::size_of::<*mut c_void>()]; 123 124 unsafe impl GlobalAlloc for QemuAllocator { 125 unsafe fn alloc(&self, layout: Layout) -> *mut u8 { 126 if matches!(Self::DEFAULT_ALIGNMENT_BYTES, Some(default) if default.checked_rem(layout.align()) == Some(0)) 127 { 128 // SAFETY: g_malloc0() is safe to call. 129 unsafe { g_malloc0(layout.size().try_into().unwrap()).cast::<u8>() } 130 } else { 131 #[cfg(HAVE_GLIB_WITH_ALIGNED_ALLOC)] 132 { 133 // SAFETY: g_aligned_alloc0() is safe to call. 134 unsafe { 135 g_aligned_alloc0( 136 layout.size().try_into().unwrap(), 137 1, 138 layout.align().try_into().unwrap(), 139 ) 140 .cast::<u8>() 141 } 142 } 143 #[cfg(not(HAVE_GLIB_WITH_ALIGNED_ALLOC))] 144 { 145 // SAFETY: qemu_memalign() is safe to call. 146 unsafe { qemu_memalign(layout.align(), layout.size()).cast::<u8>() } 147 } 148 } 149 } 150 151 unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { 152 if matches!(Self::DEFAULT_ALIGNMENT_BYTES, Some(default) if default.checked_rem(layout.align()) == Some(0)) 153 { 154 // SAFETY: `ptr` must have been allocated by Self::alloc thus a valid 155 // glib-allocated pointer, so `g_free`ing is safe. 156 unsafe { g_free(ptr.cast::<_>()) } 157 } else { 158 #[cfg(HAVE_GLIB_WITH_ALIGNED_ALLOC)] 159 { 160 // SAFETY: `ptr` must have been allocated by Self::alloc thus a valid aligned 161 // glib-allocated pointer, so `g_aligned_free`ing is safe. 162 unsafe { g_aligned_free(ptr.cast::<_>()) } 163 } 164 #[cfg(not(HAVE_GLIB_WITH_ALIGNED_ALLOC))] 165 { 166 // SAFETY: `ptr` must have been allocated by Self::alloc thus a valid aligned 167 // glib-allocated pointer, so `qemu_vfree`ing is safe. 168 unsafe { qemu_vfree(ptr.cast::<_>()) } 169 } 170 } 171 } 172 } 173 174 #[cfg(has_offset_of)] 175 pub use core::mem::offset_of; 176