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 | 35 +++++++++++-----------------
rust/hw/char/pl011/src/lib.rs | 4 ++--
rust/hw/char/pl011/src/memory_ops.rs | 14 +++--------
rust/qemu-api/src/definitions.rs | 2 +-
rust/qemu-api/src/device_class.rs | 6 ++---
rust/qemu-api/src/lib.rs | 11 +++++----
rust/qemu-api/src/vmstate.rs | 10 ++++----
rust/qemu-api/tests/tests.rs | 9 ++++---
9 files changed, 39 insertions(+), 55 deletions(-)
diff --git a/meson.build b/meson.build
index 5e2b0fb82b2..e819148f36c 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 788b47203b1..036757f7f3a 100644
--- a/rust/hw/char/pl011/src/device.rs
+++ b/rust/hw/char/pl011/src/device.rs
@@ -2,9 +2,10 @@
// 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::{
@@ -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 @@ unsafe fn init(&mut self) {
}
}
- 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 fn post_load(&mut self, _version_id: u32) ->
Result<(), ()> {
/// 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 fn post_load(&mut self, _version_id: u32) -> Result<(),
()> {
/// 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 struct PL011LuminaryClass {
}
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;
}
diff --git a/rust/hw/char/pl011/src/lib.rs b/rust/hw/char/pl011/src/lib.rs
index c6bb76a7926..a539062aa30 100644
--- a/rust/hw/char/pl011/src/lib.rs
+++ b/rust/hw/char/pl011/src/lib.rs
@@ -45,8 +45,8 @@
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.
///
diff --git a/rust/hw/char/pl011/src/memory_ops.rs
b/rust/hw/char/pl011/src/memory_ops.rs
index fc69922fbf3..169d485a4d2 100644
--- a/rust/hw/char/pl011/src/memory_ops.rs
+++ b/rust/hw/char/pl011/src/memory_ops.rs
@@ -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 @@
},
};
-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_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>());
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 3d40256f60f..cb4573ca6ef 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,
diff --git a/rust/qemu-api/src/lib.rs b/rust/qemu-api/src/lib.rs
index 10ab3d7e639..ed840ee2f72 100644
--- a/rust/qemu-api/src/lib.rs
+++ b/rust/qemu-api/src/lib.rs
@@ -34,7 +34,10 @@ unsafe impl Sync for bindings::VMStateInfo {}
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 @@ 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" {
@@ -114,7 +117,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/src/vmstate.rs b/rust/qemu-api/src/vmstate.rs
index 2a626137e25..5dd783a902a 100644
--- a/rust/qemu-api/src/vmstate.rs
+++ b/rust/qemu-api/src/vmstate.rs
@@ -55,7 +55,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,
@@ -132,7 +132,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,
@@ -180,7 +180,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>(),
@@ -205,7 +205,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: $info,
@@ -230,7 +230,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: $vmsd,
diff --git a/rust/qemu-api/tests/tests.rs b/rust/qemu-api/tests/tests.rs
index 37c4dd44f81..c7089f0cf21 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::*,
@@ -64,11 +64,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.47.0
