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....@intel.com>
Signed-off-by: Paolo Bonzini <pbonz...@redhat.com>
---
meson.build | 3 +--
rust/hw/char/pl011/src/device.rs | 20 +++++++++++---------
rust/hw/char/pl011/src/lib.rs | 2 +-
rust/hw/char/pl011/src/memory_ops.rs | 10 ++++++----
rust/qemu-api/src/definitions.rs | 2 +-
rust/qemu-api/src/device_class.rs | 8 ++++----
rust/qemu-api/src/lib.rs | 11 +++++++----
rust/qemu-api/tests/tests.rs | 9 ++++-----
8 files changed, 35 insertions(+), 30 deletions(-)
diff --git a/meson.build b/meson.build
index 3c71d129494..94f30033f68 100644
--- a/meson.build
+++ b/meson.build
@@ -3933,14 +3933,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',
diff --git a/rust/hw/char/pl011/src/device.rs b/rust/hw/char/pl011/src/device.rs
index b3d8bc004e0..7be21769ae4 100644
--- a/rust/hw/char/pl011/src/device.rs
+++ b/rust/hw/char/pl011/src/device.rs
@@ -2,9 +2,11 @@
// Author(s): Manos Pitsidianakis <manos.pitsidiana...@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::{
@@ -89,10 +91,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),
+ 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;
}
@@ -151,7 +153,7 @@ pub unsafe fn init(&mut self) {
pub fn read(
&mut self,
offset: hwaddr,
- _size: core::ffi::c_uint,
+ _size: c_uint,
) -> std::ops::ControlFlow<u64, u64> {
use RegisterOffset::*;
@@ -530,9 +532,9 @@ pub fn update(&self) {
///
/// The buffer and size arguments must also be valid.
pub unsafe extern "C" fn pl011_receive(
- opaque: *mut core::ffi::c_void,
+ opaque: *mut c_void,
buf: *const u8,
- size: core::ffi::c_int,
+ size: c_int,
) {
unsafe {
debug_assert!(!opaque.is_null());
@@ -552,7 +554,7 @@ pub fn update(&self) {
/// 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>());
diff --git a/rust/hw/char/pl011/src/lib.rs b/rust/hw/char/pl011/src/lib.rs
index 2939ee50c99..2b157868b0f 100644
--- a/rust/hw/char/pl011/src/lib.rs
+++ b/rust/hw/char/pl011/src/lib.rs
@@ -45,7 +45,7 @@
pub mod device_class;
pub mod memory_ops;
-pub const TYPE_PL011: &::core::ffi::CStr = c"pl011";
+pub const TYPE_PL011: &::std::ffi::CStr = c"pl011";
/// Offset of each register from the base memory address of the device.
///
diff --git a/rust/hw/char/pl011/src/memory_ops.rs
b/rust/hw/char/pl011/src/memory_ops.rs
index 24ac9c870c1..6d822027d51 100644
--- a/rust/hw/char/pl011/src/memory_ops.rs
+++ b/rust/hw/char/pl011/src/memory_ops.rs
@@ -4,6 +4,8 @@
use core::ptr::NonNull;
+use std::os::raw::{c_uint, c_void};
+
use qemu_api::{
bindings::*,
zeroable::Zeroable
@@ -26,9 +28,9 @@
};
unsafe extern "C" fn pl011_read(
- opaque: *mut core::ffi::c_void,
+ opaque: *mut c_void,
addr: hwaddr,
- size: core::ffi::c_uint,
+ size: c_uint,
) -> u64 {
assert!(!opaque.is_null());
let mut state = unsafe {
NonNull::new_unchecked(opaque.cast::<PL011State>()) };
@@ -47,10 +49,10 @@
}
unsafe extern "C" fn pl011_write(
- opaque: *mut core::ffi::c_void,
+ opaque: *mut c_void,
addr: hwaddr,
data: u64,
- _size: core::ffi::c_uint,
+ _size: c_uint,
) {
unsafe {
assert!(!opaque.is_null());
diff --git a/rust/qemu-api/src/definitions.rs b/rust/qemu-api/src/definitions.rs
index 064afe60549..26597934bbd 100644
--- a/rust/qemu-api/src/definitions.rs
+++ b/rust/qemu-api/src/definitions.rs
@@ -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};
diff --git a/rust/qemu-api/src/device_class.rs
b/rust/qemu-api/src/device_class.rs
index ed2d7ce1a54..5c305d945d3 100644
--- a/rust/qemu-api/src/device_class.rs
+++ b/rust/qemu-api/src/device_class.rs
@@ -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,
@@ -75,7 +75,7 @@ macro_rules! vm_state_description {
pub static $name: $crate::bindings::VMStateDescription =
$crate::bindings::VMStateDescription {
$(name: {
#[used]
- static VMSTATE_NAME: &::core::ffi::CStr = $vname;
+ static VMSTATE_NAME: &::std::ffi::CStr = $vname;
$vname.as_ptr()
},)*
unmigratable: true,
diff --git a/rust/qemu-api/src/lib.rs b/rust/qemu-api/src/lib.rs
index e94a15bb823..321c33d2c7b 100644
--- a/rust/qemu-api/src/lib.rs
+++ b/rust/qemu-api/src/lib.rs
@@ -31,7 +31,10 @@ unsafe impl Sync for bindings::VMStateDescription {}
pub mod device_class;
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" {
@@ -45,8 +48,8 @@ fn g_aligned_alloc0(
#[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" {
@@ -111,7 +114,7 @@ fn default() -> Self {
}
// 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 {
diff --git a/rust/qemu-api/tests/tests.rs b/rust/qemu-api/tests/tests.rs
index aa1e0568c69..3396c33fe1e 100644
--- a/rust/qemu-api/tests/tests.rs
+++ b/rust/qemu-api/tests/tests.rs
@@ -2,7 +2,7 @@
// Author(s): Manos Pitsidianakis <manos.pitsidiana...@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::*,
@@ -63,11 +63,10 @@ impl ObjectImpl for DummyState {
}
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;
}
--
2.46.2
