1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
|
// Copyright 2024 Red Hat, Inc.
// Author(s): Paolo Bonzini <pbonzini@redhat.com>
// SPDX-License-Identifier: GPL-2.0-or-later
//! Bindings for `MemoryRegion`, `MemoryRegionOps` and `MemTxAttrs`
use std::{
ffi::{CStr, CString},
marker::{PhantomData, PhantomPinned},
os::raw::{c_uint, c_void},
ptr::addr_of,
};
pub use bindings::{hwaddr, MemTxAttrs};
use crate::{
bindings::{self, device_endian, memory_region_init_io},
callbacks::FnCall,
prelude::*,
zeroable::Zeroable,
};
pub struct MemoryRegionOps<T>(
bindings::MemoryRegionOps,
// Note: quite often you'll see PhantomData<fn(&T)> mentioned when discussing
// covariance and contravariance; you don't need any of those to understand
// this usage of PhantomData. Quite simply, MemoryRegionOps<T> *logically*
// holds callbacks that take an argument of type &T, except the type is erased
// before the callback is stored in the bindings::MemoryRegionOps field.
// The argument of PhantomData is a function pointer in order to represent
// that relationship; while that will also provide desirable and safe variance
// for T, variance is not the point but just a consequence.
PhantomData<fn(&T)>,
);
// SAFETY: When a *const T is passed to the callbacks, the call itself
// is done in a thread-safe manner. The invocation is okay as long as
// T itself is `Sync`.
unsafe impl<T: Sync> Sync for MemoryRegionOps<T> {}
#[derive(Clone)]
pub struct MemoryRegionOpsBuilder<T>(bindings::MemoryRegionOps, PhantomData<fn(&T)>);
unsafe extern "C" fn memory_region_ops_read_cb<T, F: for<'a> FnCall<(&'a T, hwaddr, u32), u64>>(
opaque: *mut c_void,
addr: hwaddr,
size: c_uint,
) -> u64 {
F::call((unsafe { &*(opaque.cast::<T>()) }, addr, size))
}
unsafe extern "C" fn memory_region_ops_write_cb<T, F: for<'a> FnCall<(&'a T, hwaddr, u64, u32)>>(
opaque: *mut c_void,
addr: hwaddr,
data: u64,
size: c_uint,
) {
F::call((unsafe { &*(opaque.cast::<T>()) }, addr, data, size))
}
impl<T> MemoryRegionOpsBuilder<T> {
#[must_use]
pub const fn read<F: for<'a> FnCall<(&'a T, hwaddr, u32), u64>>(mut self, _f: &F) -> Self {
self.0.read = Some(memory_region_ops_read_cb::<T, F>);
self
}
#[must_use]
pub const fn write<F: for<'a> FnCall<(&'a T, hwaddr, u64, u32)>>(mut self, _f: &F) -> Self {
self.0.write = Some(memory_region_ops_write_cb::<T, F>);
self
}
#[must_use]
pub const fn big_endian(mut self) -> Self {
self.0.endianness = device_endian::DEVICE_BIG_ENDIAN;
self
}
#[must_use]
pub const fn little_endian(mut self) -> Self {
self.0.endianness = device_endian::DEVICE_LITTLE_ENDIAN;
self
}
#[must_use]
pub const fn native_endian(mut self) -> Self {
self.0.endianness = device_endian::DEVICE_NATIVE_ENDIAN;
self
}
#[must_use]
pub const fn valid_sizes(mut self, min: u32, max: u32) -> Self {
self.0.valid.min_access_size = min;
self.0.valid.max_access_size = max;
self
}
#[must_use]
pub const fn valid_unaligned(mut self) -> Self {
self.0.valid.unaligned = true;
self
}
#[must_use]
pub const fn impl_sizes(mut self, min: u32, max: u32) -> Self {
self.0.impl_.min_access_size = min;
self.0.impl_.max_access_size = max;
self
}
#[must_use]
pub const fn impl_unaligned(mut self) -> Self {
self.0.impl_.unaligned = true;
self
}
#[must_use]
pub const fn build(self) -> MemoryRegionOps<T> {
MemoryRegionOps::<T>(self.0, PhantomData)
}
#[must_use]
pub const fn new() -> Self {
Self(bindings::MemoryRegionOps::ZERO, PhantomData)
}
}
impl<T> Default for MemoryRegionOpsBuilder<T> {
fn default() -> Self {
Self::new()
}
}
/// A safe wrapper around [`bindings::MemoryRegion`]. Compared to the
/// underlying C struct it is marked as pinned because the QOM tree
/// contains a pointer to it.
pub struct MemoryRegion {
inner: bindings::MemoryRegion,
_pin: PhantomPinned,
}
impl MemoryRegion {
// inline to ensure that it is not included in tests, which only
// link to hwcore and qom. FIXME: inlining is actually the opposite
// of what we want, since this is the type-erased version of the
// init_io function below. Look into splitting the qemu_api crate.
#[inline(always)]
unsafe fn do_init_io(
slot: *mut bindings::MemoryRegion,
owner: *mut Object,
ops: &'static bindings::MemoryRegionOps,
name: &'static str,
size: u64,
) {
unsafe {
let cstr = CString::new(name).unwrap();
memory_region_init_io(
slot,
owner.cast::<Object>(),
ops,
owner.cast::<c_void>(),
cstr.as_ptr(),
size,
);
}
}
pub fn init_io<T: IsA<Object>>(
&mut self,
owner: *mut T,
ops: &'static MemoryRegionOps<T>,
name: &'static str,
size: u64,
) {
unsafe {
Self::do_init_io(&mut self.inner, owner.cast::<Object>(), &ops.0, name, size);
}
}
pub(crate) const fn as_mut_ptr(&self) -> *mut bindings::MemoryRegion {
addr_of!(self.inner) as *mut _
}
}
unsafe impl ObjectType for MemoryRegion {
type Class = bindings::MemoryRegionClass;
const TYPE_NAME: &'static CStr =
unsafe { CStr::from_bytes_with_nul_unchecked(bindings::TYPE_MEMORY_REGION) };
}
qom_isa!(MemoryRegion: Object);
/// A special `MemTxAttrs` constant, used to indicate that no memory
/// attributes are specified.
///
/// Bus masters which don't specify any attributes will get this,
/// which has all attribute bits clear except the topmost one
/// (so that we can distinguish "all attributes deliberately clear"
/// from "didn't specify" if necessary).
pub const MEMTXATTRS_UNSPECIFIED: MemTxAttrs = MemTxAttrs {
unspecified: true,
..Zeroable::ZERO
};
|
