mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

rust: use std::os::raw instead of core::ffi

Browse Source 
core::ffi::c_* types were introduced in Rust 1.64.0.  Use the older types
in std::os::raw, which are now aliases of the types in core::ffi.  There is
no need to compile QEMU as no_std, so this is acceptable as long as we support
a version of Debian with Rust 1.63.0.

Reviewed-by: Zhao Liu <zhao1.liu@intel.com>
Signed-off-by: Paolo Bonzini <pbonzini@redhat.com>
This commit is contained in:
Paolo Bonzini 2024-10-24 13:53:59 +02:00
parent 646b5378e0
commit 9f7d4520d6
9 changed files with 39 additions and 55 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
meson.build
View File

@ -3953,14 +3953,13 @@ if have_rust and have_system
bindgen_args = [
'--disable-header-comment',
'--raw-line', '// @generated',
'--ctypes-prefix', 'core::ffi',
'--ctypes-prefix', 'std::os::raw',
'--formatter', 'rustfmt',
'--generate-block',
'--generate-cstr',
'--impl-debug',
'--merge-extern-blocks',
'--no-doc-comments',
'--use-core',
'--with-derive-default',
'--no-layout-tests',
'--no-prepend-enum-name',

35
rust/hw/char/pl011/src/device.rs
View File

@ -2,9 +2,10 @@
// Author(s): Manos Pitsidianakis <manos.pitsidianakis@linaro.org>
// SPDX-License-Identifier: GPL-2.0-or-later
use core::{
ffi::{c_int, c_uchar, c_uint, c_void, CStr},
ptr::{addr_of, addr_of_mut, NonNull},
use core::ptr::{addr_of, addr_of_mut, NonNull};
use std::{
ffi::CStr,
os::raw::{c_int, c_uchar, c_uint, c_void},
};
use qemu_api::{
@ -117,11 +118,10 @@ pub struct PL011Class {
}
impl qemu_api::definitions::Class for PL011Class {
const CLASS_INIT: Option<
unsafe extern "C" fn(klass: *mut ObjectClass, data: *mut core::ffi::c_void),
> = Some(crate::device_class::pl011_class_init);
const CLASS_INIT: Option<unsafe extern "C" fn(klass: *mut ObjectClass, data: *mut c_void)> =
Some(crate::device_class::pl011_class_init);
const CLASS_BASE_INIT: Option<
unsafe extern "C" fn(klass: *mut ObjectClass, data: *mut core::ffi::c_void),
unsafe extern "C" fn(klass: *mut ObjectClass, data: *mut c_void),
> = None;
}
@ -176,11 +176,7 @@ impl PL011State {
}
}
pub fn read(
&mut self,
offset: hwaddr,
_size: core::ffi::c_uint,
) -> std::ops::ControlFlow<u64, u64> {
pub fn read(&mut self, offset: hwaddr, _size: c_uint) -> std::ops::ControlFlow<u64, u64> {
use RegisterOffset::*;
std::ops::ControlFlow::Break(match RegisterOffset::try_from(offset) {
@ -562,11 +558,7 @@ pub unsafe extern "C" fn pl011_can_receive(opaque: *mut c_void) -> c_int {
/// readable/writeable from one thread at any time.
///
/// The buffer and size arguments must also be valid.
pub unsafe extern "C" fn pl011_receive(
opaque: *mut core::ffi::c_void,
buf: *const u8,
size: core::ffi::c_int,
) {
pub unsafe extern "C" fn pl011_receive(opaque: *mut c_void, buf: *const u8, size: c_int) {
unsafe {
debug_assert!(!opaque.is_null());
let mut state = NonNull::new_unchecked(opaque.cast::<PL011State>());
@ -585,7 +577,7 @@ pub unsafe extern "C" fn pl011_receive(
/// We expect the FFI user of this function to pass a valid pointer, that has
/// the same size as [`PL011State`]. We also expect the device is
/// readable/writeable from one thread at any time.
pub unsafe extern "C" fn pl011_event(opaque: *mut core::ffi::c_void, event: QEMUChrEvent) {
pub unsafe extern "C" fn pl011_event(opaque: *mut c_void, event: QEMUChrEvent) {
unsafe {
debug_assert!(!opaque.is_null());
let mut state = NonNull::new_unchecked(opaque.cast::<PL011State>());
@ -656,11 +648,10 @@ pub unsafe extern "C" fn pl011_luminary_init(obj: *mut Object) {
}
impl qemu_api::definitions::Class for PL011LuminaryClass {
const CLASS_INIT: Option<
unsafe extern "C" fn(klass: *mut ObjectClass, data: *mut core::ffi::c_void),
> = None;
const CLASS_INIT: Option<unsafe extern "C" fn(klass: *mut ObjectClass, data: *mut c_void)> =
None;
const CLASS_BASE_INIT: Option<
unsafe extern "C" fn(klass: *mut ObjectClass, data: *mut core::ffi::c_void),
unsafe extern "C" fn(klass: *mut ObjectClass, data: *mut c_void),
> = None;
}

4
rust/hw/char/pl011/src/lib.rs
View File

@ -46,8 +46,8 @@ pub mod device;
pub mod device_class;
pub mod memory_ops;
pub const TYPE_PL011: &::core::ffi::CStr = c"pl011";
pub const TYPE_PL011_LUMINARY: &::core::ffi::CStr = c"pl011_luminary";
pub const TYPE_PL011: &::std::ffi::CStr = c"pl011";
pub const TYPE_PL011_LUMINARY: &::std::ffi::CStr = c"pl011_luminary";
/// Offset of each register from the base memory address of the device.
///

14
rust/hw/char/pl011/src/memory_ops.rs
View File

@ -3,6 +3,7 @@
// SPDX-License-Identifier: GPL-2.0-or-later
use core::ptr::NonNull;
use std::os::raw::{c_uint, c_void};
use qemu_api::{bindings::*, zeroable::Zeroable};
@ -22,11 +23,7 @@ pub static PL011_OPS: MemoryRegionOps = MemoryRegionOps {
},
};
unsafe extern "C" fn pl011_read(
opaque: *mut core::ffi::c_void,
addr: hwaddr,
size: core::ffi::c_uint,
) -> u64 {
unsafe extern "C" fn pl011_read(opaque: *mut c_void, addr: hwaddr, size: c_uint) -> u64 {
assert!(!opaque.is_null());
let mut state = unsafe { NonNull::new_unchecked(opaque.cast::<PL011State>()) };
let val = unsafe { state.as_mut().read(addr, size) };
@ -43,12 +40,7 @@ unsafe extern "C" fn pl011_read(
}
}
unsafe extern "C" fn pl011_write(
opaque: *mut core::ffi::c_void,
addr: hwaddr,
data: u64,
_size: core::ffi::c_uint,
) {
unsafe extern "C" fn pl011_write(opaque: *mut c_void, addr: hwaddr, data: u64, _size: c_uint) {
unsafe {
assert!(!opaque.is_null());
let mut state = NonNull::new_unchecked(opaque.cast::<PL011State>());

2
rust/qemu-api/src/definitions.rs
View File

@ -4,7 +4,7 @@
//! Definitions required by QEMU when registering a device.
use ::core::ffi::{c_void, CStr};
use std::{ffi::CStr, os::raw::c_void};
use crate::bindings::{Object, ObjectClass, TypeInfo};

6
rust/qemu-api/src/device_class.rs
View File

@ -7,7 +7,7 @@ macro_rules! device_class_init {
($func:ident, props => $props:ident, realize_fn => $realize_fn:expr, legacy_reset_fn => $legacy_reset_fn:expr, vmsd => $vmsd:ident$(,)*) => {
pub unsafe extern "C" fn $func(
klass: *mut $crate::bindings::ObjectClass,
_: *mut ::core::ffi::c_void,
_: *mut ::std::os::raw::c_void,
) {
let mut dc =
::core::ptr::NonNull::new(klass.cast::<$crate::bindings::DeviceClass>()).unwrap();
@ -26,7 +26,7 @@ macro_rules! define_property {
($name:expr, $state:ty, $field:expr, $prop:expr, $type:expr, default = $defval:expr$(,)*) => {
$crate::bindings::Property {
// use associated function syntax for type checking
name: ::core::ffi::CStr::as_ptr($name),
name: ::std::ffi::CStr::as_ptr($name),
info: $prop,
offset: ::core::mem::offset_of!($state, $field) as isize,
set_default: true,
@ -37,7 +37,7 @@ macro_rules! define_property {
($name:expr, $state:ty, $field:expr, $prop:expr, $type:expr$(,)*) => {
$crate::bindings::Property {
// use associated function syntax for type checking
name: ::core::ffi::CStr::as_ptr($name),
name: ::std::ffi::CStr::as_ptr($name),
info: $prop,
offset: ::core::mem::offset_of!($state, $field) as isize,
set_default: false,

11
rust/qemu-api/src/lib.rs
View File

@ -34,7 +34,10 @@ pub mod device_class;
pub mod vmstate;
pub mod zeroable;
use std::alloc::{GlobalAlloc, Layout};
use std::{
alloc::{GlobalAlloc, Layout},
os::raw::c_void,
};
#[cfg(HAVE_GLIB_WITH_ALIGNED_ALLOC)]
extern "C" {
@ -48,8 +51,8 @@ extern "C" {
#[cfg(not(HAVE_GLIB_WITH_ALIGNED_ALLOC))]
extern "C" {
fn qemu_memalign(alignment: usize, size: usize) -> *mut ::core::ffi::c_void;
fn qemu_vfree(ptr: *mut ::core::ffi::c_void);
fn qemu_memalign(alignment: usize, size: usize) -> *mut c_void;
fn qemu_vfree(ptr: *mut c_void);
}
extern "C" {
@ -114,7 +117,7 @@ impl Default for QemuAllocator {
}
// Sanity check.
const _: [(); 8] = [(); ::core::mem::size_of::<*mut ::core::ffi::c_void>()];
const _: [(); 8] = [(); ::core::mem::size_of::<*mut c_void>()];
unsafe impl GlobalAlloc for QemuAllocator {
unsafe fn alloc(&self, layout: Layout) -> *mut u8 {

10
rust/qemu-api/src/vmstate.rs
View File

@ -56,7 +56,7 @@ macro_rules! vmstate_single_test {
$crate::bindings::VMStateField {
name: ::core::concat!(::core::stringify!($field_name), 0)
.as_bytes()
.as_ptr() as *const ::core::ffi::c_char,
.as_ptr() as *const ::std::os::raw::c_char,
err_hint: ::core::ptr::null(),
offset: ::core::mem::offset_of!($struct_name, $field_name),
size: $size,
@ -133,7 +133,7 @@ macro_rules! vmstate_array {
$crate::bindings::VMStateField {
name: ::core::concat!(::core::stringify!($field_name), 0)
.as_bytes()
.as_ptr() as *const ::core::ffi::c_char,
.as_ptr() as *const ::std::os::raw::c_char,
err_hint: ::core::ptr::null(),
offset: ::core::mem::offset_of!($struct_name, $field_name),
size: $size,
@ -181,7 +181,7 @@ macro_rules! vmstate_struct_pointer_v {
$crate::bindings::VMStateField {
name: ::core::concat!(::core::stringify!($field_name), 0)
.as_bytes()
.as_ptr() as *const ::core::ffi::c_char,
.as_ptr() as *const ::std::os::raw::c_char,
err_hint: ::core::ptr::null(),
offset: ::core::mem::offset_of!($struct_name, $field_name),
size: ::core::mem::size_of::<*const $type>(),
@ -206,7 +206,7 @@ macro_rules! vmstate_array_of_pointer {
$crate::bindings::VMStateField {
name: ::core::concat!(::core::stringify!($field_name), 0)
.as_bytes()
.as_ptr() as *const ::core::ffi::c_char,
.as_ptr() as *const ::std::os::raw::c_char,
version_id: $version_id,
num: $num as _,
info: unsafe { $info },
@ -231,7 +231,7 @@ macro_rules! vmstate_array_of_pointer_to_struct {
$crate::bindings::VMStateField {
name: ::core::concat!(::core::stringify!($field_name), 0)
.as_bytes()
.as_ptr() as *const ::core::ffi::c_char,
.as_ptr() as *const ::std::os::raw::c_char,
version_id: $version_id,
num: $num as _,
vmsd: unsafe { $vmsd },

9
rust/qemu-api/tests/tests.rs
View File

@ -2,7 +2,7 @@
// Author(s): Manos Pitsidianakis <manos.pitsidianakis@linaro.org>
// SPDX-License-Identifier: GPL-2.0-or-later
use core::ffi::CStr;
use std::{ffi::CStr, os::raw::c_void};
use qemu_api::{
bindings::*,
@ -64,11 +64,10 @@ fn test_device_decl_macros() {
}
impl Class for DummyClass {
const CLASS_INIT: Option<
unsafe extern "C" fn(klass: *mut ObjectClass, data: *mut core::ffi::c_void),
> = Some(dummy_class_init);
const CLASS_INIT: Option<unsafe extern "C" fn(klass: *mut ObjectClass, data: *mut c_void)> =
Some(dummy_class_init);
const CLASS_BASE_INIT: Option<
unsafe extern "C" fn(klass: *mut ObjectClass, data: *mut core::ffi::c_void),
unsafe extern "C" fn(klass: *mut ObjectClass, data: *mut c_void),
> = None;
}