1 /* automatically generated by rust-bindgen 0.63.0 */
2 
3 #[repr(C)]
4 #[derive(Default)]
5 pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
6 impl<T> __IncompleteArrayField<T> {
7     #[inline]
new() -> Self8     pub const fn new() -> Self {
9         __IncompleteArrayField(::std::marker::PhantomData, [])
10     }
11     #[inline]
as_ptr(&self) -> *const T12     pub fn as_ptr(&self) -> *const T {
13         self as *const _ as *const T
14     }
15     #[inline]
as_mut_ptr(&mut self) -> *mut T16     pub fn as_mut_ptr(&mut self) -> *mut T {
17         self as *mut _ as *mut T
18     }
19     #[inline]
as_slice(&self, len: usize) -> &[T]20     pub unsafe fn as_slice(&self, len: usize) -> &[T] {
21         ::std::slice::from_raw_parts(self.as_ptr(), len)
22     }
23     #[inline]
as_mut_slice(&mut self, len: usize) -> &mut [T]24     pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
25         ::std::slice::from_raw_parts_mut(self.as_mut_ptr(), len)
26     }
27 }
28 impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result29     fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
30         fmt.write_str("__IncompleteArrayField")
31     }
32 }
33 pub const VRING_DESC_F_NEXT: u32 = 1;
34 pub const VRING_DESC_F_WRITE: u32 = 2;
35 pub const VRING_DESC_F_INDIRECT: u32 = 4;
36 pub const VRING_PACKED_DESC_F_AVAIL: u32 = 7;
37 pub const VRING_PACKED_DESC_F_USED: u32 = 15;
38 pub const VRING_USED_F_NO_NOTIFY: u32 = 1;
39 pub const VRING_AVAIL_F_NO_INTERRUPT: u32 = 1;
40 pub const VRING_PACKED_EVENT_FLAG_ENABLE: u32 = 0;
41 pub const VRING_PACKED_EVENT_FLAG_DISABLE: u32 = 1;
42 pub const VRING_PACKED_EVENT_FLAG_DESC: u32 = 2;
43 pub const VRING_PACKED_EVENT_F_WRAP_CTR: u32 = 15;
44 pub const VIRTIO_RING_F_INDIRECT_DESC: u32 = 28;
45 pub const VIRTIO_RING_F_EVENT_IDX: u32 = 29;
46 pub const VRING_AVAIL_ALIGN_SIZE: u32 = 2;
47 pub const VRING_USED_ALIGN_SIZE: u32 = 4;
48 pub const VRING_DESC_ALIGN_SIZE: u32 = 16;
49 pub type __u16 = ::std::os::raw::c_ushort;
50 pub type __u32 = ::std::os::raw::c_uint;
51 pub type __u64 = ::std::os::raw::c_ulonglong;
52 pub type __le16 = __u16;
53 pub type __le32 = __u32;
54 pub type __le64 = __u64;
55 pub type __virtio16 = __u16;
56 pub type __virtio32 = __u32;
57 pub type __virtio64 = __u64;
58 #[doc = " struct vring_desc - Virtio ring descriptors,\n 16 bytes long. These can chain together via @next.\n\n @addr: buffer address (guest-physical)\n @len: buffer length\n @flags: descriptor flags\n @next: index of the next descriptor in the chain,\n        if the VRING_DESC_F_NEXT flag is set. We chain unused\n        descriptors via this, too."]
59 #[repr(C)]
60 #[derive(Debug, Default, Copy, Clone, PartialEq)]
61 pub struct vring_desc {
62     pub addr: __virtio64,
63     pub len: __virtio32,
64     pub flags: __virtio16,
65     pub next: __virtio16,
66 }
67 #[test]
bindgen_test_layout_vring_desc()68 fn bindgen_test_layout_vring_desc() {
69     const UNINIT: ::std::mem::MaybeUninit<vring_desc> = ::std::mem::MaybeUninit::uninit();
70     let ptr = UNINIT.as_ptr();
71     assert_eq!(
72         ::std::mem::size_of::<vring_desc>(),
73         16usize,
74         concat!("Size of: ", stringify!(vring_desc))
75     );
76     assert_eq!(
77         ::std::mem::align_of::<vring_desc>(),
78         8usize,
79         concat!("Alignment of ", stringify!(vring_desc))
80     );
81     assert_eq!(
82         unsafe { ::std::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
83         0usize,
84         concat!(
85             "Offset of field: ",
86             stringify!(vring_desc),
87             "::",
88             stringify!(addr)
89         )
90     );
91     assert_eq!(
92         unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
93         8usize,
94         concat!(
95             "Offset of field: ",
96             stringify!(vring_desc),
97             "::",
98             stringify!(len)
99         )
100     );
101     assert_eq!(
102         unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
103         12usize,
104         concat!(
105             "Offset of field: ",
106             stringify!(vring_desc),
107             "::",
108             stringify!(flags)
109         )
110     );
111     assert_eq!(
112         unsafe { ::std::ptr::addr_of!((*ptr).next) as usize - ptr as usize },
113         14usize,
114         concat!(
115             "Offset of field: ",
116             stringify!(vring_desc),
117             "::",
118             stringify!(next)
119         )
120     );
121 }
122 #[repr(C)]
123 #[derive(Debug, Default)]
124 pub struct vring_avail {
125     pub flags: __virtio16,
126     pub idx: __virtio16,
127     pub ring: __IncompleteArrayField<__virtio16>,
128 }
129 #[test]
bindgen_test_layout_vring_avail()130 fn bindgen_test_layout_vring_avail() {
131     const UNINIT: ::std::mem::MaybeUninit<vring_avail> = ::std::mem::MaybeUninit::uninit();
132     let ptr = UNINIT.as_ptr();
133     assert_eq!(
134         ::std::mem::size_of::<vring_avail>(),
135         4usize,
136         concat!("Size of: ", stringify!(vring_avail))
137     );
138     assert_eq!(
139         ::std::mem::align_of::<vring_avail>(),
140         2usize,
141         concat!("Alignment of ", stringify!(vring_avail))
142     );
143     assert_eq!(
144         unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
145         0usize,
146         concat!(
147             "Offset of field: ",
148             stringify!(vring_avail),
149             "::",
150             stringify!(flags)
151         )
152     );
153     assert_eq!(
154         unsafe { ::std::ptr::addr_of!((*ptr).idx) as usize - ptr as usize },
155         2usize,
156         concat!(
157             "Offset of field: ",
158             stringify!(vring_avail),
159             "::",
160             stringify!(idx)
161         )
162     );
163     assert_eq!(
164         unsafe { ::std::ptr::addr_of!((*ptr).ring) as usize - ptr as usize },
165         4usize,
166         concat!(
167             "Offset of field: ",
168             stringify!(vring_avail),
169             "::",
170             stringify!(ring)
171         )
172     );
173 }
174 #[repr(C)]
175 #[derive(Debug, Default, Copy, Clone, PartialEq)]
176 pub struct vring_used_elem {
177     pub id: __virtio32,
178     pub len: __virtio32,
179 }
180 #[test]
bindgen_test_layout_vring_used_elem()181 fn bindgen_test_layout_vring_used_elem() {
182     const UNINIT: ::std::mem::MaybeUninit<vring_used_elem> = ::std::mem::MaybeUninit::uninit();
183     let ptr = UNINIT.as_ptr();
184     assert_eq!(
185         ::std::mem::size_of::<vring_used_elem>(),
186         8usize,
187         concat!("Size of: ", stringify!(vring_used_elem))
188     );
189     assert_eq!(
190         ::std::mem::align_of::<vring_used_elem>(),
191         4usize,
192         concat!("Alignment of ", stringify!(vring_used_elem))
193     );
194     assert_eq!(
195         unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
196         0usize,
197         concat!(
198             "Offset of field: ",
199             stringify!(vring_used_elem),
200             "::",
201             stringify!(id)
202         )
203     );
204     assert_eq!(
205         unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
206         4usize,
207         concat!(
208             "Offset of field: ",
209             stringify!(vring_used_elem),
210             "::",
211             stringify!(len)
212         )
213     );
214 }
215 pub type vring_used_elem_t = vring_used_elem;
216 #[repr(C)]
217 #[derive(Debug, Default)]
218 pub struct vring_used {
219     pub flags: __virtio16,
220     pub idx: __virtio16,
221     pub ring: __IncompleteArrayField<vring_used_elem_t>,
222 }
223 #[test]
bindgen_test_layout_vring_used()224 fn bindgen_test_layout_vring_used() {
225     const UNINIT: ::std::mem::MaybeUninit<vring_used> = ::std::mem::MaybeUninit::uninit();
226     let ptr = UNINIT.as_ptr();
227     assert_eq!(
228         ::std::mem::size_of::<vring_used>(),
229         4usize,
230         concat!("Size of: ", stringify!(vring_used))
231     );
232     assert_eq!(
233         ::std::mem::align_of::<vring_used>(),
234         4usize,
235         concat!("Alignment of ", stringify!(vring_used))
236     );
237     assert_eq!(
238         unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
239         0usize,
240         concat!(
241             "Offset of field: ",
242             stringify!(vring_used),
243             "::",
244             stringify!(flags)
245         )
246     );
247     assert_eq!(
248         unsafe { ::std::ptr::addr_of!((*ptr).idx) as usize - ptr as usize },
249         2usize,
250         concat!(
251             "Offset of field: ",
252             stringify!(vring_used),
253             "::",
254             stringify!(idx)
255         )
256     );
257     assert_eq!(
258         unsafe { ::std::ptr::addr_of!((*ptr).ring) as usize - ptr as usize },
259         4usize,
260         concat!(
261             "Offset of field: ",
262             stringify!(vring_used),
263             "::",
264             stringify!(ring)
265         )
266     );
267 }
268 #[doc = " struct vring_desc - Virtio ring descriptors,\n 16 bytes long. These can chain together via @next.\n\n @addr: buffer address (guest-physical)\n @len: buffer length\n @flags: descriptor flags\n @next: index of the next descriptor in the chain,\n        if the VRING_DESC_F_NEXT flag is set. We chain unused\n        descriptors via this, too."]
269 pub type vring_desc_t = vring_desc;
270 pub type vring_avail_t = vring_avail;
271 pub type vring_used_t = vring_used;
272 #[repr(C)]
273 #[derive(Debug, Copy, Clone, PartialEq)]
274 pub struct vring {
275     pub num: ::std::os::raw::c_uint,
276     pub desc: *mut vring_desc_t,
277     pub avail: *mut vring_avail_t,
278     pub used: *mut vring_used_t,
279 }
280 #[test]
bindgen_test_layout_vring()281 fn bindgen_test_layout_vring() {
282     const UNINIT: ::std::mem::MaybeUninit<vring> = ::std::mem::MaybeUninit::uninit();
283     let ptr = UNINIT.as_ptr();
284     assert_eq!(
285         ::std::mem::size_of::<vring>(),
286         32usize,
287         concat!("Size of: ", stringify!(vring))
288     );
289     assert_eq!(
290         ::std::mem::align_of::<vring>(),
291         8usize,
292         concat!("Alignment of ", stringify!(vring))
293     );
294     assert_eq!(
295         unsafe { ::std::ptr::addr_of!((*ptr).num) as usize - ptr as usize },
296         0usize,
297         concat!(
298             "Offset of field: ",
299             stringify!(vring),
300             "::",
301             stringify!(num)
302         )
303     );
304     assert_eq!(
305         unsafe { ::std::ptr::addr_of!((*ptr).desc) as usize - ptr as usize },
306         8usize,
307         concat!(
308             "Offset of field: ",
309             stringify!(vring),
310             "::",
311             stringify!(desc)
312         )
313     );
314     assert_eq!(
315         unsafe { ::std::ptr::addr_of!((*ptr).avail) as usize - ptr as usize },
316         16usize,
317         concat!(
318             "Offset of field: ",
319             stringify!(vring),
320             "::",
321             stringify!(avail)
322         )
323     );
324     assert_eq!(
325         unsafe { ::std::ptr::addr_of!((*ptr).used) as usize - ptr as usize },
326         24usize,
327         concat!(
328             "Offset of field: ",
329             stringify!(vring),
330             "::",
331             stringify!(used)
332         )
333     );
334 }
335 impl Default for vring {
default() -> Self336     fn default() -> Self {
337         let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
338         unsafe {
339             ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
340             s.assume_init()
341         }
342     }
343 }
344 #[repr(C)]
345 #[derive(Debug, Default, Copy, Clone, PartialEq)]
346 pub struct vring_packed_desc_event {
347     pub off_wrap: __le16,
348     pub flags: __le16,
349 }
350 #[test]
bindgen_test_layout_vring_packed_desc_event()351 fn bindgen_test_layout_vring_packed_desc_event() {
352     const UNINIT: ::std::mem::MaybeUninit<vring_packed_desc_event> =
353         ::std::mem::MaybeUninit::uninit();
354     let ptr = UNINIT.as_ptr();
355     assert_eq!(
356         ::std::mem::size_of::<vring_packed_desc_event>(),
357         4usize,
358         concat!("Size of: ", stringify!(vring_packed_desc_event))
359     );
360     assert_eq!(
361         ::std::mem::align_of::<vring_packed_desc_event>(),
362         2usize,
363         concat!("Alignment of ", stringify!(vring_packed_desc_event))
364     );
365     assert_eq!(
366         unsafe { ::std::ptr::addr_of!((*ptr).off_wrap) as usize - ptr as usize },
367         0usize,
368         concat!(
369             "Offset of field: ",
370             stringify!(vring_packed_desc_event),
371             "::",
372             stringify!(off_wrap)
373         )
374     );
375     assert_eq!(
376         unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
377         2usize,
378         concat!(
379             "Offset of field: ",
380             stringify!(vring_packed_desc_event),
381             "::",
382             stringify!(flags)
383         )
384     );
385 }
386 #[repr(C)]
387 #[derive(Debug, Default, Copy, Clone, PartialEq)]
388 pub struct vring_packed_desc {
389     pub addr: __le64,
390     pub len: __le32,
391     pub id: __le16,
392     pub flags: __le16,
393 }
394 #[test]
bindgen_test_layout_vring_packed_desc()395 fn bindgen_test_layout_vring_packed_desc() {
396     const UNINIT: ::std::mem::MaybeUninit<vring_packed_desc> = ::std::mem::MaybeUninit::uninit();
397     let ptr = UNINIT.as_ptr();
398     assert_eq!(
399         ::std::mem::size_of::<vring_packed_desc>(),
400         16usize,
401         concat!("Size of: ", stringify!(vring_packed_desc))
402     );
403     assert_eq!(
404         ::std::mem::align_of::<vring_packed_desc>(),
405         8usize,
406         concat!("Alignment of ", stringify!(vring_packed_desc))
407     );
408     assert_eq!(
409         unsafe { ::std::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
410         0usize,
411         concat!(
412             "Offset of field: ",
413             stringify!(vring_packed_desc),
414             "::",
415             stringify!(addr)
416         )
417     );
418     assert_eq!(
419         unsafe { ::std::ptr::addr_of!((*ptr).len) as usize - ptr as usize },
420         8usize,
421         concat!(
422             "Offset of field: ",
423             stringify!(vring_packed_desc),
424             "::",
425             stringify!(len)
426         )
427     );
428     assert_eq!(
429         unsafe { ::std::ptr::addr_of!((*ptr).id) as usize - ptr as usize },
430         12usize,
431         concat!(
432             "Offset of field: ",
433             stringify!(vring_packed_desc),
434             "::",
435             stringify!(id)
436         )
437     );
438     assert_eq!(
439         unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
440         14usize,
441         concat!(
442             "Offset of field: ",
443             stringify!(vring_packed_desc),
444             "::",
445             stringify!(flags)
446         )
447     );
448 }
449