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 VIRTIO_GPU_F_VIRGL: u32 = 0;
34 pub const VIRTIO_GPU_F_EDID: u32 = 1;
35 pub const VIRTIO_GPU_F_RESOURCE_UUID: u32 = 2;
36 pub const VIRTIO_GPU_F_RESOURCE_BLOB: u32 = 3;
37 pub const VIRTIO_GPU_F_CONTEXT_INIT: u32 = 4;
38 pub const VIRTIO_GPU_FLAG_FENCE: u32 = 1;
39 pub const VIRTIO_GPU_FLAG_INFO_RING_IDX: u32 = 2;
40 pub const VIRTIO_GPU_MAX_SCANOUTS: u32 = 16;
41 pub const VIRTIO_GPU_RESOURCE_FLAG_Y_0_TOP: u32 = 1;
42 pub const VIRTIO_GPU_CONTEXT_INIT_CAPSET_ID_MASK: u32 = 255;
43 pub const VIRTIO_GPU_CAPSET_VIRGL: u32 = 1;
44 pub const VIRTIO_GPU_CAPSET_VIRGL2: u32 = 2;
45 pub const VIRTIO_GPU_EVENT_DISPLAY: u32 = 1;
46 pub const VIRTIO_GPU_BLOB_MEM_GUEST: u32 = 1;
47 pub const VIRTIO_GPU_BLOB_MEM_HOST3D: u32 = 2;
48 pub const VIRTIO_GPU_BLOB_MEM_HOST3D_GUEST: u32 = 3;
49 pub const VIRTIO_GPU_BLOB_FLAG_USE_MAPPABLE: u32 = 1;
50 pub const VIRTIO_GPU_BLOB_FLAG_USE_SHAREABLE: u32 = 2;
51 pub const VIRTIO_GPU_BLOB_FLAG_USE_CROSS_DEVICE: u32 = 4;
52 pub const VIRTIO_GPU_MAP_CACHE_MASK: u32 = 15;
53 pub const VIRTIO_GPU_MAP_CACHE_NONE: u32 = 0;
54 pub const VIRTIO_GPU_MAP_CACHE_CACHED: u32 = 1;
55 pub const VIRTIO_GPU_MAP_CACHE_UNCACHED: u32 = 2;
56 pub const VIRTIO_GPU_MAP_CACHE_WC: u32 = 3;
57 pub type __u8 = ::std::os::raw::c_uchar;
58 pub type __u32 = ::std::os::raw::c_uint;
59 pub type __u64 = ::std::os::raw::c_ulonglong;
60 pub type __le32 = __u32;
61 pub type __le64 = __u64;
62 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_UNDEFINED: virtio_gpu_ctrl_type = 0;
63 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_GET_DISPLAY_INFO: virtio_gpu_ctrl_type = 256;
64 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_CREATE_2D: virtio_gpu_ctrl_type = 257;
65 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_UNREF: virtio_gpu_ctrl_type = 258;
66 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_SET_SCANOUT: virtio_gpu_ctrl_type = 259;
67 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_FLUSH: virtio_gpu_ctrl_type = 260;
68 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D: virtio_gpu_ctrl_type = 261;
69 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING: virtio_gpu_ctrl_type = 262;
70 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING: virtio_gpu_ctrl_type = 263;
71 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_GET_CAPSET_INFO: virtio_gpu_ctrl_type = 264;
72 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_GET_CAPSET: virtio_gpu_ctrl_type = 265;
73 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_GET_EDID: virtio_gpu_ctrl_type = 266;
74 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_ASSIGN_UUID: virtio_gpu_ctrl_type = 267;
75 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_CREATE_BLOB: virtio_gpu_ctrl_type = 268;
76 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_SET_SCANOUT_BLOB: virtio_gpu_ctrl_type = 269;
77 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_CTX_CREATE: virtio_gpu_ctrl_type = 512;
78 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_CTX_DESTROY: virtio_gpu_ctrl_type = 513;
79 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_CTX_ATTACH_RESOURCE: virtio_gpu_ctrl_type = 514;
80 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_CTX_DETACH_RESOURCE: virtio_gpu_ctrl_type = 515;
81 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_CREATE_3D: virtio_gpu_ctrl_type = 516;
82 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_TRANSFER_TO_HOST_3D: virtio_gpu_ctrl_type = 517;
83 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_TRANSFER_FROM_HOST_3D: virtio_gpu_ctrl_type = 518;
84 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_SUBMIT_3D: virtio_gpu_ctrl_type = 519;
85 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_MAP_BLOB: virtio_gpu_ctrl_type = 520;
86 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_UNMAP_BLOB: virtio_gpu_ctrl_type = 521;
87 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_UPDATE_CURSOR: virtio_gpu_ctrl_type = 768;
88 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_MOVE_CURSOR: virtio_gpu_ctrl_type = 769;
89 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_NODATA: virtio_gpu_ctrl_type = 4352;
90 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_DISPLAY_INFO: virtio_gpu_ctrl_type = 4353;
91 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_CAPSET_INFO: virtio_gpu_ctrl_type = 4354;
92 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_CAPSET: virtio_gpu_ctrl_type = 4355;
93 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_EDID: virtio_gpu_ctrl_type = 4356;
94 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_RESOURCE_UUID: virtio_gpu_ctrl_type = 4357;
95 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_MAP_INFO: virtio_gpu_ctrl_type = 4358;
96 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_UNSPEC: virtio_gpu_ctrl_type = 4608;
97 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY: virtio_gpu_ctrl_type = 4609;
98 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID: virtio_gpu_ctrl_type = 4610;
99 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID: virtio_gpu_ctrl_type = 4611;
100 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_INVALID_CONTEXT_ID: virtio_gpu_ctrl_type = 4612;
101 pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER: virtio_gpu_ctrl_type = 4613;
102 pub type virtio_gpu_ctrl_type = ::std::os::raw::c_uint;
103 pub const virtio_gpu_shm_id_VIRTIO_GPU_SHM_ID_UNDEFINED: virtio_gpu_shm_id = 0;
104 pub const virtio_gpu_shm_id_VIRTIO_GPU_SHM_ID_HOST_VISIBLE: virtio_gpu_shm_id = 1;
105 pub type virtio_gpu_shm_id = ::std::os::raw::c_uint;
106 #[repr(C)]
107 #[derive(Debug, Default, Copy, Clone, PartialEq)]
108 pub struct virtio_gpu_ctrl_hdr {
109 pub type_: __le32,
110 pub flags: __le32,
111 pub fence_id: __le64,
112 pub ctx_id: __le32,
113 pub ring_idx: __u8,
114 pub padding: [__u8; 3usize],
115 }
116 #[test]
bindgen_test_layout_virtio_gpu_ctrl_hdr()117 fn bindgen_test_layout_virtio_gpu_ctrl_hdr() {
118 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_ctrl_hdr> = ::std::mem::MaybeUninit::uninit();
119 let ptr = UNINIT.as_ptr();
120 assert_eq!(
121 ::std::mem::size_of::<virtio_gpu_ctrl_hdr>(),
122 24usize,
123 concat!("Size of: ", stringify!(virtio_gpu_ctrl_hdr))
124 );
125 assert_eq!(
126 ::std::mem::align_of::<virtio_gpu_ctrl_hdr>(),
127 8usize,
128 concat!("Alignment of ", stringify!(virtio_gpu_ctrl_hdr))
129 );
130 assert_eq!(
131 unsafe { ::std::ptr::addr_of!((*ptr).type_) as usize - ptr as usize },
132 0usize,
133 concat!(
134 "Offset of field: ",
135 stringify!(virtio_gpu_ctrl_hdr),
136 "::",
137 stringify!(type_)
138 )
139 );
140 assert_eq!(
141 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
142 4usize,
143 concat!(
144 "Offset of field: ",
145 stringify!(virtio_gpu_ctrl_hdr),
146 "::",
147 stringify!(flags)
148 )
149 );
150 assert_eq!(
151 unsafe { ::std::ptr::addr_of!((*ptr).fence_id) as usize - ptr as usize },
152 8usize,
153 concat!(
154 "Offset of field: ",
155 stringify!(virtio_gpu_ctrl_hdr),
156 "::",
157 stringify!(fence_id)
158 )
159 );
160 assert_eq!(
161 unsafe { ::std::ptr::addr_of!((*ptr).ctx_id) as usize - ptr as usize },
162 16usize,
163 concat!(
164 "Offset of field: ",
165 stringify!(virtio_gpu_ctrl_hdr),
166 "::",
167 stringify!(ctx_id)
168 )
169 );
170 assert_eq!(
171 unsafe { ::std::ptr::addr_of!((*ptr).ring_idx) as usize - ptr as usize },
172 20usize,
173 concat!(
174 "Offset of field: ",
175 stringify!(virtio_gpu_ctrl_hdr),
176 "::",
177 stringify!(ring_idx)
178 )
179 );
180 assert_eq!(
181 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
182 21usize,
183 concat!(
184 "Offset of field: ",
185 stringify!(virtio_gpu_ctrl_hdr),
186 "::",
187 stringify!(padding)
188 )
189 );
190 }
191 #[repr(C)]
192 #[derive(Debug, Default, Copy, Clone, PartialEq)]
193 pub struct virtio_gpu_cursor_pos {
194 pub scanout_id: __le32,
195 pub x: __le32,
196 pub y: __le32,
197 pub padding: __le32,
198 }
199 #[test]
bindgen_test_layout_virtio_gpu_cursor_pos()200 fn bindgen_test_layout_virtio_gpu_cursor_pos() {
201 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_cursor_pos> =
202 ::std::mem::MaybeUninit::uninit();
203 let ptr = UNINIT.as_ptr();
204 assert_eq!(
205 ::std::mem::size_of::<virtio_gpu_cursor_pos>(),
206 16usize,
207 concat!("Size of: ", stringify!(virtio_gpu_cursor_pos))
208 );
209 assert_eq!(
210 ::std::mem::align_of::<virtio_gpu_cursor_pos>(),
211 4usize,
212 concat!("Alignment of ", stringify!(virtio_gpu_cursor_pos))
213 );
214 assert_eq!(
215 unsafe { ::std::ptr::addr_of!((*ptr).scanout_id) as usize - ptr as usize },
216 0usize,
217 concat!(
218 "Offset of field: ",
219 stringify!(virtio_gpu_cursor_pos),
220 "::",
221 stringify!(scanout_id)
222 )
223 );
224 assert_eq!(
225 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
226 4usize,
227 concat!(
228 "Offset of field: ",
229 stringify!(virtio_gpu_cursor_pos),
230 "::",
231 stringify!(x)
232 )
233 );
234 assert_eq!(
235 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
236 8usize,
237 concat!(
238 "Offset of field: ",
239 stringify!(virtio_gpu_cursor_pos),
240 "::",
241 stringify!(y)
242 )
243 );
244 assert_eq!(
245 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
246 12usize,
247 concat!(
248 "Offset of field: ",
249 stringify!(virtio_gpu_cursor_pos),
250 "::",
251 stringify!(padding)
252 )
253 );
254 }
255 #[repr(C)]
256 #[derive(Debug, Default, Copy, Clone, PartialEq)]
257 pub struct virtio_gpu_update_cursor {
258 pub hdr: virtio_gpu_ctrl_hdr,
259 pub pos: virtio_gpu_cursor_pos,
260 pub resource_id: __le32,
261 pub hot_x: __le32,
262 pub hot_y: __le32,
263 pub padding: __le32,
264 }
265 #[test]
bindgen_test_layout_virtio_gpu_update_cursor()266 fn bindgen_test_layout_virtio_gpu_update_cursor() {
267 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_update_cursor> =
268 ::std::mem::MaybeUninit::uninit();
269 let ptr = UNINIT.as_ptr();
270 assert_eq!(
271 ::std::mem::size_of::<virtio_gpu_update_cursor>(),
272 56usize,
273 concat!("Size of: ", stringify!(virtio_gpu_update_cursor))
274 );
275 assert_eq!(
276 ::std::mem::align_of::<virtio_gpu_update_cursor>(),
277 8usize,
278 concat!("Alignment of ", stringify!(virtio_gpu_update_cursor))
279 );
280 assert_eq!(
281 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
282 0usize,
283 concat!(
284 "Offset of field: ",
285 stringify!(virtio_gpu_update_cursor),
286 "::",
287 stringify!(hdr)
288 )
289 );
290 assert_eq!(
291 unsafe { ::std::ptr::addr_of!((*ptr).pos) as usize - ptr as usize },
292 24usize,
293 concat!(
294 "Offset of field: ",
295 stringify!(virtio_gpu_update_cursor),
296 "::",
297 stringify!(pos)
298 )
299 );
300 assert_eq!(
301 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
302 40usize,
303 concat!(
304 "Offset of field: ",
305 stringify!(virtio_gpu_update_cursor),
306 "::",
307 stringify!(resource_id)
308 )
309 );
310 assert_eq!(
311 unsafe { ::std::ptr::addr_of!((*ptr).hot_x) as usize - ptr as usize },
312 44usize,
313 concat!(
314 "Offset of field: ",
315 stringify!(virtio_gpu_update_cursor),
316 "::",
317 stringify!(hot_x)
318 )
319 );
320 assert_eq!(
321 unsafe { ::std::ptr::addr_of!((*ptr).hot_y) as usize - ptr as usize },
322 48usize,
323 concat!(
324 "Offset of field: ",
325 stringify!(virtio_gpu_update_cursor),
326 "::",
327 stringify!(hot_y)
328 )
329 );
330 assert_eq!(
331 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
332 52usize,
333 concat!(
334 "Offset of field: ",
335 stringify!(virtio_gpu_update_cursor),
336 "::",
337 stringify!(padding)
338 )
339 );
340 }
341 #[repr(C)]
342 #[derive(Debug, Default, Copy, Clone, PartialEq)]
343 pub struct virtio_gpu_rect {
344 pub x: __le32,
345 pub y: __le32,
346 pub width: __le32,
347 pub height: __le32,
348 }
349 #[test]
bindgen_test_layout_virtio_gpu_rect()350 fn bindgen_test_layout_virtio_gpu_rect() {
351 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_rect> = ::std::mem::MaybeUninit::uninit();
352 let ptr = UNINIT.as_ptr();
353 assert_eq!(
354 ::std::mem::size_of::<virtio_gpu_rect>(),
355 16usize,
356 concat!("Size of: ", stringify!(virtio_gpu_rect))
357 );
358 assert_eq!(
359 ::std::mem::align_of::<virtio_gpu_rect>(),
360 4usize,
361 concat!("Alignment of ", stringify!(virtio_gpu_rect))
362 );
363 assert_eq!(
364 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
365 0usize,
366 concat!(
367 "Offset of field: ",
368 stringify!(virtio_gpu_rect),
369 "::",
370 stringify!(x)
371 )
372 );
373 assert_eq!(
374 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
375 4usize,
376 concat!(
377 "Offset of field: ",
378 stringify!(virtio_gpu_rect),
379 "::",
380 stringify!(y)
381 )
382 );
383 assert_eq!(
384 unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
385 8usize,
386 concat!(
387 "Offset of field: ",
388 stringify!(virtio_gpu_rect),
389 "::",
390 stringify!(width)
391 )
392 );
393 assert_eq!(
394 unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
395 12usize,
396 concat!(
397 "Offset of field: ",
398 stringify!(virtio_gpu_rect),
399 "::",
400 stringify!(height)
401 )
402 );
403 }
404 #[repr(C)]
405 #[derive(Debug, Default, Copy, Clone, PartialEq)]
406 pub struct virtio_gpu_resource_unref {
407 pub hdr: virtio_gpu_ctrl_hdr,
408 pub resource_id: __le32,
409 pub padding: __le32,
410 }
411 #[test]
bindgen_test_layout_virtio_gpu_resource_unref()412 fn bindgen_test_layout_virtio_gpu_resource_unref() {
413 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_unref> =
414 ::std::mem::MaybeUninit::uninit();
415 let ptr = UNINIT.as_ptr();
416 assert_eq!(
417 ::std::mem::size_of::<virtio_gpu_resource_unref>(),
418 32usize,
419 concat!("Size of: ", stringify!(virtio_gpu_resource_unref))
420 );
421 assert_eq!(
422 ::std::mem::align_of::<virtio_gpu_resource_unref>(),
423 8usize,
424 concat!("Alignment of ", stringify!(virtio_gpu_resource_unref))
425 );
426 assert_eq!(
427 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
428 0usize,
429 concat!(
430 "Offset of field: ",
431 stringify!(virtio_gpu_resource_unref),
432 "::",
433 stringify!(hdr)
434 )
435 );
436 assert_eq!(
437 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
438 24usize,
439 concat!(
440 "Offset of field: ",
441 stringify!(virtio_gpu_resource_unref),
442 "::",
443 stringify!(resource_id)
444 )
445 );
446 assert_eq!(
447 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
448 28usize,
449 concat!(
450 "Offset of field: ",
451 stringify!(virtio_gpu_resource_unref),
452 "::",
453 stringify!(padding)
454 )
455 );
456 }
457 #[repr(C)]
458 #[derive(Debug, Default, Copy, Clone, PartialEq)]
459 pub struct virtio_gpu_resource_create_2d {
460 pub hdr: virtio_gpu_ctrl_hdr,
461 pub resource_id: __le32,
462 pub format: __le32,
463 pub width: __le32,
464 pub height: __le32,
465 }
466 #[test]
bindgen_test_layout_virtio_gpu_resource_create_2d()467 fn bindgen_test_layout_virtio_gpu_resource_create_2d() {
468 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_create_2d> =
469 ::std::mem::MaybeUninit::uninit();
470 let ptr = UNINIT.as_ptr();
471 assert_eq!(
472 ::std::mem::size_of::<virtio_gpu_resource_create_2d>(),
473 40usize,
474 concat!("Size of: ", stringify!(virtio_gpu_resource_create_2d))
475 );
476 assert_eq!(
477 ::std::mem::align_of::<virtio_gpu_resource_create_2d>(),
478 8usize,
479 concat!("Alignment of ", stringify!(virtio_gpu_resource_create_2d))
480 );
481 assert_eq!(
482 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
483 0usize,
484 concat!(
485 "Offset of field: ",
486 stringify!(virtio_gpu_resource_create_2d),
487 "::",
488 stringify!(hdr)
489 )
490 );
491 assert_eq!(
492 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
493 24usize,
494 concat!(
495 "Offset of field: ",
496 stringify!(virtio_gpu_resource_create_2d),
497 "::",
498 stringify!(resource_id)
499 )
500 );
501 assert_eq!(
502 unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
503 28usize,
504 concat!(
505 "Offset of field: ",
506 stringify!(virtio_gpu_resource_create_2d),
507 "::",
508 stringify!(format)
509 )
510 );
511 assert_eq!(
512 unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
513 32usize,
514 concat!(
515 "Offset of field: ",
516 stringify!(virtio_gpu_resource_create_2d),
517 "::",
518 stringify!(width)
519 )
520 );
521 assert_eq!(
522 unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
523 36usize,
524 concat!(
525 "Offset of field: ",
526 stringify!(virtio_gpu_resource_create_2d),
527 "::",
528 stringify!(height)
529 )
530 );
531 }
532 #[repr(C)]
533 #[derive(Debug, Default, Copy, Clone, PartialEq)]
534 pub struct virtio_gpu_set_scanout {
535 pub hdr: virtio_gpu_ctrl_hdr,
536 pub r: virtio_gpu_rect,
537 pub scanout_id: __le32,
538 pub resource_id: __le32,
539 }
540 #[test]
bindgen_test_layout_virtio_gpu_set_scanout()541 fn bindgen_test_layout_virtio_gpu_set_scanout() {
542 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_set_scanout> =
543 ::std::mem::MaybeUninit::uninit();
544 let ptr = UNINIT.as_ptr();
545 assert_eq!(
546 ::std::mem::size_of::<virtio_gpu_set_scanout>(),
547 48usize,
548 concat!("Size of: ", stringify!(virtio_gpu_set_scanout))
549 );
550 assert_eq!(
551 ::std::mem::align_of::<virtio_gpu_set_scanout>(),
552 8usize,
553 concat!("Alignment of ", stringify!(virtio_gpu_set_scanout))
554 );
555 assert_eq!(
556 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
557 0usize,
558 concat!(
559 "Offset of field: ",
560 stringify!(virtio_gpu_set_scanout),
561 "::",
562 stringify!(hdr)
563 )
564 );
565 assert_eq!(
566 unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
567 24usize,
568 concat!(
569 "Offset of field: ",
570 stringify!(virtio_gpu_set_scanout),
571 "::",
572 stringify!(r)
573 )
574 );
575 assert_eq!(
576 unsafe { ::std::ptr::addr_of!((*ptr).scanout_id) as usize - ptr as usize },
577 40usize,
578 concat!(
579 "Offset of field: ",
580 stringify!(virtio_gpu_set_scanout),
581 "::",
582 stringify!(scanout_id)
583 )
584 );
585 assert_eq!(
586 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
587 44usize,
588 concat!(
589 "Offset of field: ",
590 stringify!(virtio_gpu_set_scanout),
591 "::",
592 stringify!(resource_id)
593 )
594 );
595 }
596 #[repr(C)]
597 #[derive(Debug, Default, Copy, Clone, PartialEq)]
598 pub struct virtio_gpu_resource_flush {
599 pub hdr: virtio_gpu_ctrl_hdr,
600 pub r: virtio_gpu_rect,
601 pub resource_id: __le32,
602 pub padding: __le32,
603 }
604 #[test]
bindgen_test_layout_virtio_gpu_resource_flush()605 fn bindgen_test_layout_virtio_gpu_resource_flush() {
606 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_flush> =
607 ::std::mem::MaybeUninit::uninit();
608 let ptr = UNINIT.as_ptr();
609 assert_eq!(
610 ::std::mem::size_of::<virtio_gpu_resource_flush>(),
611 48usize,
612 concat!("Size of: ", stringify!(virtio_gpu_resource_flush))
613 );
614 assert_eq!(
615 ::std::mem::align_of::<virtio_gpu_resource_flush>(),
616 8usize,
617 concat!("Alignment of ", stringify!(virtio_gpu_resource_flush))
618 );
619 assert_eq!(
620 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
621 0usize,
622 concat!(
623 "Offset of field: ",
624 stringify!(virtio_gpu_resource_flush),
625 "::",
626 stringify!(hdr)
627 )
628 );
629 assert_eq!(
630 unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
631 24usize,
632 concat!(
633 "Offset of field: ",
634 stringify!(virtio_gpu_resource_flush),
635 "::",
636 stringify!(r)
637 )
638 );
639 assert_eq!(
640 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
641 40usize,
642 concat!(
643 "Offset of field: ",
644 stringify!(virtio_gpu_resource_flush),
645 "::",
646 stringify!(resource_id)
647 )
648 );
649 assert_eq!(
650 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
651 44usize,
652 concat!(
653 "Offset of field: ",
654 stringify!(virtio_gpu_resource_flush),
655 "::",
656 stringify!(padding)
657 )
658 );
659 }
660 #[repr(C)]
661 #[derive(Debug, Default, Copy, Clone, PartialEq)]
662 pub struct virtio_gpu_transfer_to_host_2d {
663 pub hdr: virtio_gpu_ctrl_hdr,
664 pub r: virtio_gpu_rect,
665 pub offset: __le64,
666 pub resource_id: __le32,
667 pub padding: __le32,
668 }
669 #[test]
bindgen_test_layout_virtio_gpu_transfer_to_host_2d()670 fn bindgen_test_layout_virtio_gpu_transfer_to_host_2d() {
671 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_transfer_to_host_2d> =
672 ::std::mem::MaybeUninit::uninit();
673 let ptr = UNINIT.as_ptr();
674 assert_eq!(
675 ::std::mem::size_of::<virtio_gpu_transfer_to_host_2d>(),
676 56usize,
677 concat!("Size of: ", stringify!(virtio_gpu_transfer_to_host_2d))
678 );
679 assert_eq!(
680 ::std::mem::align_of::<virtio_gpu_transfer_to_host_2d>(),
681 8usize,
682 concat!("Alignment of ", stringify!(virtio_gpu_transfer_to_host_2d))
683 );
684 assert_eq!(
685 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
686 0usize,
687 concat!(
688 "Offset of field: ",
689 stringify!(virtio_gpu_transfer_to_host_2d),
690 "::",
691 stringify!(hdr)
692 )
693 );
694 assert_eq!(
695 unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
696 24usize,
697 concat!(
698 "Offset of field: ",
699 stringify!(virtio_gpu_transfer_to_host_2d),
700 "::",
701 stringify!(r)
702 )
703 );
704 assert_eq!(
705 unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
706 40usize,
707 concat!(
708 "Offset of field: ",
709 stringify!(virtio_gpu_transfer_to_host_2d),
710 "::",
711 stringify!(offset)
712 )
713 );
714 assert_eq!(
715 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
716 48usize,
717 concat!(
718 "Offset of field: ",
719 stringify!(virtio_gpu_transfer_to_host_2d),
720 "::",
721 stringify!(resource_id)
722 )
723 );
724 assert_eq!(
725 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
726 52usize,
727 concat!(
728 "Offset of field: ",
729 stringify!(virtio_gpu_transfer_to_host_2d),
730 "::",
731 stringify!(padding)
732 )
733 );
734 }
735 #[repr(C)]
736 #[derive(Debug, Default, Copy, Clone, PartialEq)]
737 pub struct virtio_gpu_mem_entry {
738 pub addr: __le64,
739 pub length: __le32,
740 pub padding: __le32,
741 }
742 #[test]
bindgen_test_layout_virtio_gpu_mem_entry()743 fn bindgen_test_layout_virtio_gpu_mem_entry() {
744 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_mem_entry> = ::std::mem::MaybeUninit::uninit();
745 let ptr = UNINIT.as_ptr();
746 assert_eq!(
747 ::std::mem::size_of::<virtio_gpu_mem_entry>(),
748 16usize,
749 concat!("Size of: ", stringify!(virtio_gpu_mem_entry))
750 );
751 assert_eq!(
752 ::std::mem::align_of::<virtio_gpu_mem_entry>(),
753 8usize,
754 concat!("Alignment of ", stringify!(virtio_gpu_mem_entry))
755 );
756 assert_eq!(
757 unsafe { ::std::ptr::addr_of!((*ptr).addr) as usize - ptr as usize },
758 0usize,
759 concat!(
760 "Offset of field: ",
761 stringify!(virtio_gpu_mem_entry),
762 "::",
763 stringify!(addr)
764 )
765 );
766 assert_eq!(
767 unsafe { ::std::ptr::addr_of!((*ptr).length) as usize - ptr as usize },
768 8usize,
769 concat!(
770 "Offset of field: ",
771 stringify!(virtio_gpu_mem_entry),
772 "::",
773 stringify!(length)
774 )
775 );
776 assert_eq!(
777 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
778 12usize,
779 concat!(
780 "Offset of field: ",
781 stringify!(virtio_gpu_mem_entry),
782 "::",
783 stringify!(padding)
784 )
785 );
786 }
787 #[repr(C)]
788 #[derive(Debug, Default, Copy, Clone, PartialEq)]
789 pub struct virtio_gpu_resource_attach_backing {
790 pub hdr: virtio_gpu_ctrl_hdr,
791 pub resource_id: __le32,
792 pub nr_entries: __le32,
793 }
794 #[test]
bindgen_test_layout_virtio_gpu_resource_attach_backing()795 fn bindgen_test_layout_virtio_gpu_resource_attach_backing() {
796 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_attach_backing> =
797 ::std::mem::MaybeUninit::uninit();
798 let ptr = UNINIT.as_ptr();
799 assert_eq!(
800 ::std::mem::size_of::<virtio_gpu_resource_attach_backing>(),
801 32usize,
802 concat!("Size of: ", stringify!(virtio_gpu_resource_attach_backing))
803 );
804 assert_eq!(
805 ::std::mem::align_of::<virtio_gpu_resource_attach_backing>(),
806 8usize,
807 concat!(
808 "Alignment of ",
809 stringify!(virtio_gpu_resource_attach_backing)
810 )
811 );
812 assert_eq!(
813 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
814 0usize,
815 concat!(
816 "Offset of field: ",
817 stringify!(virtio_gpu_resource_attach_backing),
818 "::",
819 stringify!(hdr)
820 )
821 );
822 assert_eq!(
823 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
824 24usize,
825 concat!(
826 "Offset of field: ",
827 stringify!(virtio_gpu_resource_attach_backing),
828 "::",
829 stringify!(resource_id)
830 )
831 );
832 assert_eq!(
833 unsafe { ::std::ptr::addr_of!((*ptr).nr_entries) as usize - ptr as usize },
834 28usize,
835 concat!(
836 "Offset of field: ",
837 stringify!(virtio_gpu_resource_attach_backing),
838 "::",
839 stringify!(nr_entries)
840 )
841 );
842 }
843 #[repr(C)]
844 #[derive(Debug, Default, Copy, Clone, PartialEq)]
845 pub struct virtio_gpu_resource_detach_backing {
846 pub hdr: virtio_gpu_ctrl_hdr,
847 pub resource_id: __le32,
848 pub padding: __le32,
849 }
850 #[test]
bindgen_test_layout_virtio_gpu_resource_detach_backing()851 fn bindgen_test_layout_virtio_gpu_resource_detach_backing() {
852 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_detach_backing> =
853 ::std::mem::MaybeUninit::uninit();
854 let ptr = UNINIT.as_ptr();
855 assert_eq!(
856 ::std::mem::size_of::<virtio_gpu_resource_detach_backing>(),
857 32usize,
858 concat!("Size of: ", stringify!(virtio_gpu_resource_detach_backing))
859 );
860 assert_eq!(
861 ::std::mem::align_of::<virtio_gpu_resource_detach_backing>(),
862 8usize,
863 concat!(
864 "Alignment of ",
865 stringify!(virtio_gpu_resource_detach_backing)
866 )
867 );
868 assert_eq!(
869 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
870 0usize,
871 concat!(
872 "Offset of field: ",
873 stringify!(virtio_gpu_resource_detach_backing),
874 "::",
875 stringify!(hdr)
876 )
877 );
878 assert_eq!(
879 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
880 24usize,
881 concat!(
882 "Offset of field: ",
883 stringify!(virtio_gpu_resource_detach_backing),
884 "::",
885 stringify!(resource_id)
886 )
887 );
888 assert_eq!(
889 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
890 28usize,
891 concat!(
892 "Offset of field: ",
893 stringify!(virtio_gpu_resource_detach_backing),
894 "::",
895 stringify!(padding)
896 )
897 );
898 }
899 #[repr(C)]
900 #[derive(Debug, Default, Copy, Clone, PartialEq)]
901 pub struct virtio_gpu_resp_display_info {
902 pub hdr: virtio_gpu_ctrl_hdr,
903 pub pmodes: [virtio_gpu_resp_display_info_virtio_gpu_display_one; 16usize],
904 }
905 #[repr(C)]
906 #[derive(Debug, Default, Copy, Clone, PartialEq)]
907 pub struct virtio_gpu_resp_display_info_virtio_gpu_display_one {
908 pub r: virtio_gpu_rect,
909 pub enabled: __le32,
910 pub flags: __le32,
911 }
912 #[test]
bindgen_test_layout_virtio_gpu_resp_display_info_virtio_gpu_display_one()913 fn bindgen_test_layout_virtio_gpu_resp_display_info_virtio_gpu_display_one() {
914 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resp_display_info_virtio_gpu_display_one> =
915 ::std::mem::MaybeUninit::uninit();
916 let ptr = UNINIT.as_ptr();
917 assert_eq!(
918 ::std::mem::size_of::<virtio_gpu_resp_display_info_virtio_gpu_display_one>(),
919 24usize,
920 concat!(
921 "Size of: ",
922 stringify!(virtio_gpu_resp_display_info_virtio_gpu_display_one)
923 )
924 );
925 assert_eq!(
926 ::std::mem::align_of::<virtio_gpu_resp_display_info_virtio_gpu_display_one>(),
927 4usize,
928 concat!(
929 "Alignment of ",
930 stringify!(virtio_gpu_resp_display_info_virtio_gpu_display_one)
931 )
932 );
933 assert_eq!(
934 unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
935 0usize,
936 concat!(
937 "Offset of field: ",
938 stringify!(virtio_gpu_resp_display_info_virtio_gpu_display_one),
939 "::",
940 stringify!(r)
941 )
942 );
943 assert_eq!(
944 unsafe { ::std::ptr::addr_of!((*ptr).enabled) as usize - ptr as usize },
945 16usize,
946 concat!(
947 "Offset of field: ",
948 stringify!(virtio_gpu_resp_display_info_virtio_gpu_display_one),
949 "::",
950 stringify!(enabled)
951 )
952 );
953 assert_eq!(
954 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
955 20usize,
956 concat!(
957 "Offset of field: ",
958 stringify!(virtio_gpu_resp_display_info_virtio_gpu_display_one),
959 "::",
960 stringify!(flags)
961 )
962 );
963 }
964 #[test]
bindgen_test_layout_virtio_gpu_resp_display_info()965 fn bindgen_test_layout_virtio_gpu_resp_display_info() {
966 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resp_display_info> =
967 ::std::mem::MaybeUninit::uninit();
968 let ptr = UNINIT.as_ptr();
969 assert_eq!(
970 ::std::mem::size_of::<virtio_gpu_resp_display_info>(),
971 408usize,
972 concat!("Size of: ", stringify!(virtio_gpu_resp_display_info))
973 );
974 assert_eq!(
975 ::std::mem::align_of::<virtio_gpu_resp_display_info>(),
976 8usize,
977 concat!("Alignment of ", stringify!(virtio_gpu_resp_display_info))
978 );
979 assert_eq!(
980 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
981 0usize,
982 concat!(
983 "Offset of field: ",
984 stringify!(virtio_gpu_resp_display_info),
985 "::",
986 stringify!(hdr)
987 )
988 );
989 assert_eq!(
990 unsafe { ::std::ptr::addr_of!((*ptr).pmodes) as usize - ptr as usize },
991 24usize,
992 concat!(
993 "Offset of field: ",
994 stringify!(virtio_gpu_resp_display_info),
995 "::",
996 stringify!(pmodes)
997 )
998 );
999 }
1000 #[repr(C)]
1001 #[derive(Debug, Default, Copy, Clone, PartialEq)]
1002 pub struct virtio_gpu_box {
1003 pub x: __le32,
1004 pub y: __le32,
1005 pub z: __le32,
1006 pub w: __le32,
1007 pub h: __le32,
1008 pub d: __le32,
1009 }
1010 #[test]
bindgen_test_layout_virtio_gpu_box()1011 fn bindgen_test_layout_virtio_gpu_box() {
1012 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_box> = ::std::mem::MaybeUninit::uninit();
1013 let ptr = UNINIT.as_ptr();
1014 assert_eq!(
1015 ::std::mem::size_of::<virtio_gpu_box>(),
1016 24usize,
1017 concat!("Size of: ", stringify!(virtio_gpu_box))
1018 );
1019 assert_eq!(
1020 ::std::mem::align_of::<virtio_gpu_box>(),
1021 4usize,
1022 concat!("Alignment of ", stringify!(virtio_gpu_box))
1023 );
1024 assert_eq!(
1025 unsafe { ::std::ptr::addr_of!((*ptr).x) as usize - ptr as usize },
1026 0usize,
1027 concat!(
1028 "Offset of field: ",
1029 stringify!(virtio_gpu_box),
1030 "::",
1031 stringify!(x)
1032 )
1033 );
1034 assert_eq!(
1035 unsafe { ::std::ptr::addr_of!((*ptr).y) as usize - ptr as usize },
1036 4usize,
1037 concat!(
1038 "Offset of field: ",
1039 stringify!(virtio_gpu_box),
1040 "::",
1041 stringify!(y)
1042 )
1043 );
1044 assert_eq!(
1045 unsafe { ::std::ptr::addr_of!((*ptr).z) as usize - ptr as usize },
1046 8usize,
1047 concat!(
1048 "Offset of field: ",
1049 stringify!(virtio_gpu_box),
1050 "::",
1051 stringify!(z)
1052 )
1053 );
1054 assert_eq!(
1055 unsafe { ::std::ptr::addr_of!((*ptr).w) as usize - ptr as usize },
1056 12usize,
1057 concat!(
1058 "Offset of field: ",
1059 stringify!(virtio_gpu_box),
1060 "::",
1061 stringify!(w)
1062 )
1063 );
1064 assert_eq!(
1065 unsafe { ::std::ptr::addr_of!((*ptr).h) as usize - ptr as usize },
1066 16usize,
1067 concat!(
1068 "Offset of field: ",
1069 stringify!(virtio_gpu_box),
1070 "::",
1071 stringify!(h)
1072 )
1073 );
1074 assert_eq!(
1075 unsafe { ::std::ptr::addr_of!((*ptr).d) as usize - ptr as usize },
1076 20usize,
1077 concat!(
1078 "Offset of field: ",
1079 stringify!(virtio_gpu_box),
1080 "::",
1081 stringify!(d)
1082 )
1083 );
1084 }
1085 #[repr(C)]
1086 #[derive(Debug, Default, Copy, Clone, PartialEq)]
1087 pub struct virtio_gpu_transfer_host_3d {
1088 pub hdr: virtio_gpu_ctrl_hdr,
1089 pub box_: virtio_gpu_box,
1090 pub offset: __le64,
1091 pub resource_id: __le32,
1092 pub level: __le32,
1093 pub stride: __le32,
1094 pub layer_stride: __le32,
1095 }
1096 #[test]
bindgen_test_layout_virtio_gpu_transfer_host_3d()1097 fn bindgen_test_layout_virtio_gpu_transfer_host_3d() {
1098 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_transfer_host_3d> =
1099 ::std::mem::MaybeUninit::uninit();
1100 let ptr = UNINIT.as_ptr();
1101 assert_eq!(
1102 ::std::mem::size_of::<virtio_gpu_transfer_host_3d>(),
1103 72usize,
1104 concat!("Size of: ", stringify!(virtio_gpu_transfer_host_3d))
1105 );
1106 assert_eq!(
1107 ::std::mem::align_of::<virtio_gpu_transfer_host_3d>(),
1108 8usize,
1109 concat!("Alignment of ", stringify!(virtio_gpu_transfer_host_3d))
1110 );
1111 assert_eq!(
1112 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
1113 0usize,
1114 concat!(
1115 "Offset of field: ",
1116 stringify!(virtio_gpu_transfer_host_3d),
1117 "::",
1118 stringify!(hdr)
1119 )
1120 );
1121 assert_eq!(
1122 unsafe { ::std::ptr::addr_of!((*ptr).box_) as usize - ptr as usize },
1123 24usize,
1124 concat!(
1125 "Offset of field: ",
1126 stringify!(virtio_gpu_transfer_host_3d),
1127 "::",
1128 stringify!(box_)
1129 )
1130 );
1131 assert_eq!(
1132 unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
1133 48usize,
1134 concat!(
1135 "Offset of field: ",
1136 stringify!(virtio_gpu_transfer_host_3d),
1137 "::",
1138 stringify!(offset)
1139 )
1140 );
1141 assert_eq!(
1142 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
1143 56usize,
1144 concat!(
1145 "Offset of field: ",
1146 stringify!(virtio_gpu_transfer_host_3d),
1147 "::",
1148 stringify!(resource_id)
1149 )
1150 );
1151 assert_eq!(
1152 unsafe { ::std::ptr::addr_of!((*ptr).level) as usize - ptr as usize },
1153 60usize,
1154 concat!(
1155 "Offset of field: ",
1156 stringify!(virtio_gpu_transfer_host_3d),
1157 "::",
1158 stringify!(level)
1159 )
1160 );
1161 assert_eq!(
1162 unsafe { ::std::ptr::addr_of!((*ptr).stride) as usize - ptr as usize },
1163 64usize,
1164 concat!(
1165 "Offset of field: ",
1166 stringify!(virtio_gpu_transfer_host_3d),
1167 "::",
1168 stringify!(stride)
1169 )
1170 );
1171 assert_eq!(
1172 unsafe { ::std::ptr::addr_of!((*ptr).layer_stride) as usize - ptr as usize },
1173 68usize,
1174 concat!(
1175 "Offset of field: ",
1176 stringify!(virtio_gpu_transfer_host_3d),
1177 "::",
1178 stringify!(layer_stride)
1179 )
1180 );
1181 }
1182 #[repr(C)]
1183 #[derive(Debug, Default, Copy, Clone, PartialEq)]
1184 pub struct virtio_gpu_resource_create_3d {
1185 pub hdr: virtio_gpu_ctrl_hdr,
1186 pub resource_id: __le32,
1187 pub target: __le32,
1188 pub format: __le32,
1189 pub bind: __le32,
1190 pub width: __le32,
1191 pub height: __le32,
1192 pub depth: __le32,
1193 pub array_size: __le32,
1194 pub last_level: __le32,
1195 pub nr_samples: __le32,
1196 pub flags: __le32,
1197 pub padding: __le32,
1198 }
1199 #[test]
bindgen_test_layout_virtio_gpu_resource_create_3d()1200 fn bindgen_test_layout_virtio_gpu_resource_create_3d() {
1201 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_create_3d> =
1202 ::std::mem::MaybeUninit::uninit();
1203 let ptr = UNINIT.as_ptr();
1204 assert_eq!(
1205 ::std::mem::size_of::<virtio_gpu_resource_create_3d>(),
1206 72usize,
1207 concat!("Size of: ", stringify!(virtio_gpu_resource_create_3d))
1208 );
1209 assert_eq!(
1210 ::std::mem::align_of::<virtio_gpu_resource_create_3d>(),
1211 8usize,
1212 concat!("Alignment of ", stringify!(virtio_gpu_resource_create_3d))
1213 );
1214 assert_eq!(
1215 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
1216 0usize,
1217 concat!(
1218 "Offset of field: ",
1219 stringify!(virtio_gpu_resource_create_3d),
1220 "::",
1221 stringify!(hdr)
1222 )
1223 );
1224 assert_eq!(
1225 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
1226 24usize,
1227 concat!(
1228 "Offset of field: ",
1229 stringify!(virtio_gpu_resource_create_3d),
1230 "::",
1231 stringify!(resource_id)
1232 )
1233 );
1234 assert_eq!(
1235 unsafe { ::std::ptr::addr_of!((*ptr).target) as usize - ptr as usize },
1236 28usize,
1237 concat!(
1238 "Offset of field: ",
1239 stringify!(virtio_gpu_resource_create_3d),
1240 "::",
1241 stringify!(target)
1242 )
1243 );
1244 assert_eq!(
1245 unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
1246 32usize,
1247 concat!(
1248 "Offset of field: ",
1249 stringify!(virtio_gpu_resource_create_3d),
1250 "::",
1251 stringify!(format)
1252 )
1253 );
1254 assert_eq!(
1255 unsafe { ::std::ptr::addr_of!((*ptr).bind) as usize - ptr as usize },
1256 36usize,
1257 concat!(
1258 "Offset of field: ",
1259 stringify!(virtio_gpu_resource_create_3d),
1260 "::",
1261 stringify!(bind)
1262 )
1263 );
1264 assert_eq!(
1265 unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
1266 40usize,
1267 concat!(
1268 "Offset of field: ",
1269 stringify!(virtio_gpu_resource_create_3d),
1270 "::",
1271 stringify!(width)
1272 )
1273 );
1274 assert_eq!(
1275 unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
1276 44usize,
1277 concat!(
1278 "Offset of field: ",
1279 stringify!(virtio_gpu_resource_create_3d),
1280 "::",
1281 stringify!(height)
1282 )
1283 );
1284 assert_eq!(
1285 unsafe { ::std::ptr::addr_of!((*ptr).depth) as usize - ptr as usize },
1286 48usize,
1287 concat!(
1288 "Offset of field: ",
1289 stringify!(virtio_gpu_resource_create_3d),
1290 "::",
1291 stringify!(depth)
1292 )
1293 );
1294 assert_eq!(
1295 unsafe { ::std::ptr::addr_of!((*ptr).array_size) as usize - ptr as usize },
1296 52usize,
1297 concat!(
1298 "Offset of field: ",
1299 stringify!(virtio_gpu_resource_create_3d),
1300 "::",
1301 stringify!(array_size)
1302 )
1303 );
1304 assert_eq!(
1305 unsafe { ::std::ptr::addr_of!((*ptr).last_level) as usize - ptr as usize },
1306 56usize,
1307 concat!(
1308 "Offset of field: ",
1309 stringify!(virtio_gpu_resource_create_3d),
1310 "::",
1311 stringify!(last_level)
1312 )
1313 );
1314 assert_eq!(
1315 unsafe { ::std::ptr::addr_of!((*ptr).nr_samples) as usize - ptr as usize },
1316 60usize,
1317 concat!(
1318 "Offset of field: ",
1319 stringify!(virtio_gpu_resource_create_3d),
1320 "::",
1321 stringify!(nr_samples)
1322 )
1323 );
1324 assert_eq!(
1325 unsafe { ::std::ptr::addr_of!((*ptr).flags) as usize - ptr as usize },
1326 64usize,
1327 concat!(
1328 "Offset of field: ",
1329 stringify!(virtio_gpu_resource_create_3d),
1330 "::",
1331 stringify!(flags)
1332 )
1333 );
1334 assert_eq!(
1335 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
1336 68usize,
1337 concat!(
1338 "Offset of field: ",
1339 stringify!(virtio_gpu_resource_create_3d),
1340 "::",
1341 stringify!(padding)
1342 )
1343 );
1344 }
1345 #[repr(C)]
1346 #[derive(Debug, Copy, Clone, PartialEq)]
1347 pub struct virtio_gpu_ctx_create {
1348 pub hdr: virtio_gpu_ctrl_hdr,
1349 pub nlen: __le32,
1350 pub context_init: __le32,
1351 pub debug_name: [::std::os::raw::c_char; 64usize],
1352 }
1353 #[test]
bindgen_test_layout_virtio_gpu_ctx_create()1354 fn bindgen_test_layout_virtio_gpu_ctx_create() {
1355 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_ctx_create> =
1356 ::std::mem::MaybeUninit::uninit();
1357 let ptr = UNINIT.as_ptr();
1358 assert_eq!(
1359 ::std::mem::size_of::<virtio_gpu_ctx_create>(),
1360 96usize,
1361 concat!("Size of: ", stringify!(virtio_gpu_ctx_create))
1362 );
1363 assert_eq!(
1364 ::std::mem::align_of::<virtio_gpu_ctx_create>(),
1365 8usize,
1366 concat!("Alignment of ", stringify!(virtio_gpu_ctx_create))
1367 );
1368 assert_eq!(
1369 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
1370 0usize,
1371 concat!(
1372 "Offset of field: ",
1373 stringify!(virtio_gpu_ctx_create),
1374 "::",
1375 stringify!(hdr)
1376 )
1377 );
1378 assert_eq!(
1379 unsafe { ::std::ptr::addr_of!((*ptr).nlen) as usize - ptr as usize },
1380 24usize,
1381 concat!(
1382 "Offset of field: ",
1383 stringify!(virtio_gpu_ctx_create),
1384 "::",
1385 stringify!(nlen)
1386 )
1387 );
1388 assert_eq!(
1389 unsafe { ::std::ptr::addr_of!((*ptr).context_init) as usize - ptr as usize },
1390 28usize,
1391 concat!(
1392 "Offset of field: ",
1393 stringify!(virtio_gpu_ctx_create),
1394 "::",
1395 stringify!(context_init)
1396 )
1397 );
1398 assert_eq!(
1399 unsafe { ::std::ptr::addr_of!((*ptr).debug_name) as usize - ptr as usize },
1400 32usize,
1401 concat!(
1402 "Offset of field: ",
1403 stringify!(virtio_gpu_ctx_create),
1404 "::",
1405 stringify!(debug_name)
1406 )
1407 );
1408 }
1409 impl Default for virtio_gpu_ctx_create {
default() -> Self1410 fn default() -> Self {
1411 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1412 unsafe {
1413 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1414 s.assume_init()
1415 }
1416 }
1417 }
1418 #[repr(C)]
1419 #[derive(Debug, Default, Copy, Clone, PartialEq)]
1420 pub struct virtio_gpu_ctx_destroy {
1421 pub hdr: virtio_gpu_ctrl_hdr,
1422 }
1423 #[test]
bindgen_test_layout_virtio_gpu_ctx_destroy()1424 fn bindgen_test_layout_virtio_gpu_ctx_destroy() {
1425 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_ctx_destroy> =
1426 ::std::mem::MaybeUninit::uninit();
1427 let ptr = UNINIT.as_ptr();
1428 assert_eq!(
1429 ::std::mem::size_of::<virtio_gpu_ctx_destroy>(),
1430 24usize,
1431 concat!("Size of: ", stringify!(virtio_gpu_ctx_destroy))
1432 );
1433 assert_eq!(
1434 ::std::mem::align_of::<virtio_gpu_ctx_destroy>(),
1435 8usize,
1436 concat!("Alignment of ", stringify!(virtio_gpu_ctx_destroy))
1437 );
1438 assert_eq!(
1439 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
1440 0usize,
1441 concat!(
1442 "Offset of field: ",
1443 stringify!(virtio_gpu_ctx_destroy),
1444 "::",
1445 stringify!(hdr)
1446 )
1447 );
1448 }
1449 #[repr(C)]
1450 #[derive(Debug, Default, Copy, Clone, PartialEq)]
1451 pub struct virtio_gpu_ctx_resource {
1452 pub hdr: virtio_gpu_ctrl_hdr,
1453 pub resource_id: __le32,
1454 pub padding: __le32,
1455 }
1456 #[test]
bindgen_test_layout_virtio_gpu_ctx_resource()1457 fn bindgen_test_layout_virtio_gpu_ctx_resource() {
1458 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_ctx_resource> =
1459 ::std::mem::MaybeUninit::uninit();
1460 let ptr = UNINIT.as_ptr();
1461 assert_eq!(
1462 ::std::mem::size_of::<virtio_gpu_ctx_resource>(),
1463 32usize,
1464 concat!("Size of: ", stringify!(virtio_gpu_ctx_resource))
1465 );
1466 assert_eq!(
1467 ::std::mem::align_of::<virtio_gpu_ctx_resource>(),
1468 8usize,
1469 concat!("Alignment of ", stringify!(virtio_gpu_ctx_resource))
1470 );
1471 assert_eq!(
1472 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
1473 0usize,
1474 concat!(
1475 "Offset of field: ",
1476 stringify!(virtio_gpu_ctx_resource),
1477 "::",
1478 stringify!(hdr)
1479 )
1480 );
1481 assert_eq!(
1482 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
1483 24usize,
1484 concat!(
1485 "Offset of field: ",
1486 stringify!(virtio_gpu_ctx_resource),
1487 "::",
1488 stringify!(resource_id)
1489 )
1490 );
1491 assert_eq!(
1492 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
1493 28usize,
1494 concat!(
1495 "Offset of field: ",
1496 stringify!(virtio_gpu_ctx_resource),
1497 "::",
1498 stringify!(padding)
1499 )
1500 );
1501 }
1502 #[repr(C)]
1503 #[derive(Debug, Default, Copy, Clone, PartialEq)]
1504 pub struct virtio_gpu_cmd_submit {
1505 pub hdr: virtio_gpu_ctrl_hdr,
1506 pub size: __le32,
1507 pub padding: __le32,
1508 }
1509 #[test]
bindgen_test_layout_virtio_gpu_cmd_submit()1510 fn bindgen_test_layout_virtio_gpu_cmd_submit() {
1511 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_cmd_submit> =
1512 ::std::mem::MaybeUninit::uninit();
1513 let ptr = UNINIT.as_ptr();
1514 assert_eq!(
1515 ::std::mem::size_of::<virtio_gpu_cmd_submit>(),
1516 32usize,
1517 concat!("Size of: ", stringify!(virtio_gpu_cmd_submit))
1518 );
1519 assert_eq!(
1520 ::std::mem::align_of::<virtio_gpu_cmd_submit>(),
1521 8usize,
1522 concat!("Alignment of ", stringify!(virtio_gpu_cmd_submit))
1523 );
1524 assert_eq!(
1525 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
1526 0usize,
1527 concat!(
1528 "Offset of field: ",
1529 stringify!(virtio_gpu_cmd_submit),
1530 "::",
1531 stringify!(hdr)
1532 )
1533 );
1534 assert_eq!(
1535 unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
1536 24usize,
1537 concat!(
1538 "Offset of field: ",
1539 stringify!(virtio_gpu_cmd_submit),
1540 "::",
1541 stringify!(size)
1542 )
1543 );
1544 assert_eq!(
1545 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
1546 28usize,
1547 concat!(
1548 "Offset of field: ",
1549 stringify!(virtio_gpu_cmd_submit),
1550 "::",
1551 stringify!(padding)
1552 )
1553 );
1554 }
1555 #[repr(C)]
1556 #[derive(Debug, Default, Copy, Clone, PartialEq)]
1557 pub struct virtio_gpu_get_capset_info {
1558 pub hdr: virtio_gpu_ctrl_hdr,
1559 pub capset_index: __le32,
1560 pub padding: __le32,
1561 }
1562 #[test]
bindgen_test_layout_virtio_gpu_get_capset_info()1563 fn bindgen_test_layout_virtio_gpu_get_capset_info() {
1564 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_get_capset_info> =
1565 ::std::mem::MaybeUninit::uninit();
1566 let ptr = UNINIT.as_ptr();
1567 assert_eq!(
1568 ::std::mem::size_of::<virtio_gpu_get_capset_info>(),
1569 32usize,
1570 concat!("Size of: ", stringify!(virtio_gpu_get_capset_info))
1571 );
1572 assert_eq!(
1573 ::std::mem::align_of::<virtio_gpu_get_capset_info>(),
1574 8usize,
1575 concat!("Alignment of ", stringify!(virtio_gpu_get_capset_info))
1576 );
1577 assert_eq!(
1578 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
1579 0usize,
1580 concat!(
1581 "Offset of field: ",
1582 stringify!(virtio_gpu_get_capset_info),
1583 "::",
1584 stringify!(hdr)
1585 )
1586 );
1587 assert_eq!(
1588 unsafe { ::std::ptr::addr_of!((*ptr).capset_index) as usize - ptr as usize },
1589 24usize,
1590 concat!(
1591 "Offset of field: ",
1592 stringify!(virtio_gpu_get_capset_info),
1593 "::",
1594 stringify!(capset_index)
1595 )
1596 );
1597 assert_eq!(
1598 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
1599 28usize,
1600 concat!(
1601 "Offset of field: ",
1602 stringify!(virtio_gpu_get_capset_info),
1603 "::",
1604 stringify!(padding)
1605 )
1606 );
1607 }
1608 #[repr(C)]
1609 #[derive(Debug, Default, Copy, Clone, PartialEq)]
1610 pub struct virtio_gpu_resp_capset_info {
1611 pub hdr: virtio_gpu_ctrl_hdr,
1612 pub capset_id: __le32,
1613 pub capset_max_version: __le32,
1614 pub capset_max_size: __le32,
1615 pub padding: __le32,
1616 }
1617 #[test]
bindgen_test_layout_virtio_gpu_resp_capset_info()1618 fn bindgen_test_layout_virtio_gpu_resp_capset_info() {
1619 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resp_capset_info> =
1620 ::std::mem::MaybeUninit::uninit();
1621 let ptr = UNINIT.as_ptr();
1622 assert_eq!(
1623 ::std::mem::size_of::<virtio_gpu_resp_capset_info>(),
1624 40usize,
1625 concat!("Size of: ", stringify!(virtio_gpu_resp_capset_info))
1626 );
1627 assert_eq!(
1628 ::std::mem::align_of::<virtio_gpu_resp_capset_info>(),
1629 8usize,
1630 concat!("Alignment of ", stringify!(virtio_gpu_resp_capset_info))
1631 );
1632 assert_eq!(
1633 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
1634 0usize,
1635 concat!(
1636 "Offset of field: ",
1637 stringify!(virtio_gpu_resp_capset_info),
1638 "::",
1639 stringify!(hdr)
1640 )
1641 );
1642 assert_eq!(
1643 unsafe { ::std::ptr::addr_of!((*ptr).capset_id) as usize - ptr as usize },
1644 24usize,
1645 concat!(
1646 "Offset of field: ",
1647 stringify!(virtio_gpu_resp_capset_info),
1648 "::",
1649 stringify!(capset_id)
1650 )
1651 );
1652 assert_eq!(
1653 unsafe { ::std::ptr::addr_of!((*ptr).capset_max_version) as usize - ptr as usize },
1654 28usize,
1655 concat!(
1656 "Offset of field: ",
1657 stringify!(virtio_gpu_resp_capset_info),
1658 "::",
1659 stringify!(capset_max_version)
1660 )
1661 );
1662 assert_eq!(
1663 unsafe { ::std::ptr::addr_of!((*ptr).capset_max_size) as usize - ptr as usize },
1664 32usize,
1665 concat!(
1666 "Offset of field: ",
1667 stringify!(virtio_gpu_resp_capset_info),
1668 "::",
1669 stringify!(capset_max_size)
1670 )
1671 );
1672 assert_eq!(
1673 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
1674 36usize,
1675 concat!(
1676 "Offset of field: ",
1677 stringify!(virtio_gpu_resp_capset_info),
1678 "::",
1679 stringify!(padding)
1680 )
1681 );
1682 }
1683 #[repr(C)]
1684 #[derive(Debug, Default, Copy, Clone, PartialEq)]
1685 pub struct virtio_gpu_get_capset {
1686 pub hdr: virtio_gpu_ctrl_hdr,
1687 pub capset_id: __le32,
1688 pub capset_version: __le32,
1689 }
1690 #[test]
bindgen_test_layout_virtio_gpu_get_capset()1691 fn bindgen_test_layout_virtio_gpu_get_capset() {
1692 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_get_capset> =
1693 ::std::mem::MaybeUninit::uninit();
1694 let ptr = UNINIT.as_ptr();
1695 assert_eq!(
1696 ::std::mem::size_of::<virtio_gpu_get_capset>(),
1697 32usize,
1698 concat!("Size of: ", stringify!(virtio_gpu_get_capset))
1699 );
1700 assert_eq!(
1701 ::std::mem::align_of::<virtio_gpu_get_capset>(),
1702 8usize,
1703 concat!("Alignment of ", stringify!(virtio_gpu_get_capset))
1704 );
1705 assert_eq!(
1706 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
1707 0usize,
1708 concat!(
1709 "Offset of field: ",
1710 stringify!(virtio_gpu_get_capset),
1711 "::",
1712 stringify!(hdr)
1713 )
1714 );
1715 assert_eq!(
1716 unsafe { ::std::ptr::addr_of!((*ptr).capset_id) as usize - ptr as usize },
1717 24usize,
1718 concat!(
1719 "Offset of field: ",
1720 stringify!(virtio_gpu_get_capset),
1721 "::",
1722 stringify!(capset_id)
1723 )
1724 );
1725 assert_eq!(
1726 unsafe { ::std::ptr::addr_of!((*ptr).capset_version) as usize - ptr as usize },
1727 28usize,
1728 concat!(
1729 "Offset of field: ",
1730 stringify!(virtio_gpu_get_capset),
1731 "::",
1732 stringify!(capset_version)
1733 )
1734 );
1735 }
1736 #[repr(C)]
1737 #[derive(Debug, Default)]
1738 pub struct virtio_gpu_resp_capset {
1739 pub hdr: virtio_gpu_ctrl_hdr,
1740 pub capset_data: __IncompleteArrayField<__u8>,
1741 }
1742 #[test]
bindgen_test_layout_virtio_gpu_resp_capset()1743 fn bindgen_test_layout_virtio_gpu_resp_capset() {
1744 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resp_capset> =
1745 ::std::mem::MaybeUninit::uninit();
1746 let ptr = UNINIT.as_ptr();
1747 assert_eq!(
1748 ::std::mem::size_of::<virtio_gpu_resp_capset>(),
1749 24usize,
1750 concat!("Size of: ", stringify!(virtio_gpu_resp_capset))
1751 );
1752 assert_eq!(
1753 ::std::mem::align_of::<virtio_gpu_resp_capset>(),
1754 8usize,
1755 concat!("Alignment of ", stringify!(virtio_gpu_resp_capset))
1756 );
1757 assert_eq!(
1758 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
1759 0usize,
1760 concat!(
1761 "Offset of field: ",
1762 stringify!(virtio_gpu_resp_capset),
1763 "::",
1764 stringify!(hdr)
1765 )
1766 );
1767 assert_eq!(
1768 unsafe { ::std::ptr::addr_of!((*ptr).capset_data) as usize - ptr as usize },
1769 24usize,
1770 concat!(
1771 "Offset of field: ",
1772 stringify!(virtio_gpu_resp_capset),
1773 "::",
1774 stringify!(capset_data)
1775 )
1776 );
1777 }
1778 #[repr(C)]
1779 #[derive(Debug, Default, Copy, Clone, PartialEq)]
1780 pub struct virtio_gpu_cmd_get_edid {
1781 pub hdr: virtio_gpu_ctrl_hdr,
1782 pub scanout: __le32,
1783 pub padding: __le32,
1784 }
1785 #[test]
bindgen_test_layout_virtio_gpu_cmd_get_edid()1786 fn bindgen_test_layout_virtio_gpu_cmd_get_edid() {
1787 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_cmd_get_edid> =
1788 ::std::mem::MaybeUninit::uninit();
1789 let ptr = UNINIT.as_ptr();
1790 assert_eq!(
1791 ::std::mem::size_of::<virtio_gpu_cmd_get_edid>(),
1792 32usize,
1793 concat!("Size of: ", stringify!(virtio_gpu_cmd_get_edid))
1794 );
1795 assert_eq!(
1796 ::std::mem::align_of::<virtio_gpu_cmd_get_edid>(),
1797 8usize,
1798 concat!("Alignment of ", stringify!(virtio_gpu_cmd_get_edid))
1799 );
1800 assert_eq!(
1801 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
1802 0usize,
1803 concat!(
1804 "Offset of field: ",
1805 stringify!(virtio_gpu_cmd_get_edid),
1806 "::",
1807 stringify!(hdr)
1808 )
1809 );
1810 assert_eq!(
1811 unsafe { ::std::ptr::addr_of!((*ptr).scanout) as usize - ptr as usize },
1812 24usize,
1813 concat!(
1814 "Offset of field: ",
1815 stringify!(virtio_gpu_cmd_get_edid),
1816 "::",
1817 stringify!(scanout)
1818 )
1819 );
1820 assert_eq!(
1821 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
1822 28usize,
1823 concat!(
1824 "Offset of field: ",
1825 stringify!(virtio_gpu_cmd_get_edid),
1826 "::",
1827 stringify!(padding)
1828 )
1829 );
1830 }
1831 #[repr(C)]
1832 #[derive(Debug, Copy, Clone, PartialEq)]
1833 pub struct virtio_gpu_resp_edid {
1834 pub hdr: virtio_gpu_ctrl_hdr,
1835 pub size: __le32,
1836 pub padding: __le32,
1837 pub edid: [__u8; 1024usize],
1838 }
1839 #[test]
bindgen_test_layout_virtio_gpu_resp_edid()1840 fn bindgen_test_layout_virtio_gpu_resp_edid() {
1841 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resp_edid> = ::std::mem::MaybeUninit::uninit();
1842 let ptr = UNINIT.as_ptr();
1843 assert_eq!(
1844 ::std::mem::size_of::<virtio_gpu_resp_edid>(),
1845 1056usize,
1846 concat!("Size of: ", stringify!(virtio_gpu_resp_edid))
1847 );
1848 assert_eq!(
1849 ::std::mem::align_of::<virtio_gpu_resp_edid>(),
1850 8usize,
1851 concat!("Alignment of ", stringify!(virtio_gpu_resp_edid))
1852 );
1853 assert_eq!(
1854 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
1855 0usize,
1856 concat!(
1857 "Offset of field: ",
1858 stringify!(virtio_gpu_resp_edid),
1859 "::",
1860 stringify!(hdr)
1861 )
1862 );
1863 assert_eq!(
1864 unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
1865 24usize,
1866 concat!(
1867 "Offset of field: ",
1868 stringify!(virtio_gpu_resp_edid),
1869 "::",
1870 stringify!(size)
1871 )
1872 );
1873 assert_eq!(
1874 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
1875 28usize,
1876 concat!(
1877 "Offset of field: ",
1878 stringify!(virtio_gpu_resp_edid),
1879 "::",
1880 stringify!(padding)
1881 )
1882 );
1883 assert_eq!(
1884 unsafe { ::std::ptr::addr_of!((*ptr).edid) as usize - ptr as usize },
1885 32usize,
1886 concat!(
1887 "Offset of field: ",
1888 stringify!(virtio_gpu_resp_edid),
1889 "::",
1890 stringify!(edid)
1891 )
1892 );
1893 }
1894 impl Default for virtio_gpu_resp_edid {
default() -> Self1895 fn default() -> Self {
1896 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
1897 unsafe {
1898 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
1899 s.assume_init()
1900 }
1901 }
1902 }
1903 #[repr(C)]
1904 #[derive(Debug, Default, Copy, Clone, PartialEq)]
1905 pub struct virtio_gpu_config {
1906 pub events_read: __le32,
1907 pub events_clear: __le32,
1908 pub num_scanouts: __le32,
1909 pub num_capsets: __le32,
1910 }
1911 #[test]
bindgen_test_layout_virtio_gpu_config()1912 fn bindgen_test_layout_virtio_gpu_config() {
1913 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_config> = ::std::mem::MaybeUninit::uninit();
1914 let ptr = UNINIT.as_ptr();
1915 assert_eq!(
1916 ::std::mem::size_of::<virtio_gpu_config>(),
1917 16usize,
1918 concat!("Size of: ", stringify!(virtio_gpu_config))
1919 );
1920 assert_eq!(
1921 ::std::mem::align_of::<virtio_gpu_config>(),
1922 4usize,
1923 concat!("Alignment of ", stringify!(virtio_gpu_config))
1924 );
1925 assert_eq!(
1926 unsafe { ::std::ptr::addr_of!((*ptr).events_read) as usize - ptr as usize },
1927 0usize,
1928 concat!(
1929 "Offset of field: ",
1930 stringify!(virtio_gpu_config),
1931 "::",
1932 stringify!(events_read)
1933 )
1934 );
1935 assert_eq!(
1936 unsafe { ::std::ptr::addr_of!((*ptr).events_clear) as usize - ptr as usize },
1937 4usize,
1938 concat!(
1939 "Offset of field: ",
1940 stringify!(virtio_gpu_config),
1941 "::",
1942 stringify!(events_clear)
1943 )
1944 );
1945 assert_eq!(
1946 unsafe { ::std::ptr::addr_of!((*ptr).num_scanouts) as usize - ptr as usize },
1947 8usize,
1948 concat!(
1949 "Offset of field: ",
1950 stringify!(virtio_gpu_config),
1951 "::",
1952 stringify!(num_scanouts)
1953 )
1954 );
1955 assert_eq!(
1956 unsafe { ::std::ptr::addr_of!((*ptr).num_capsets) as usize - ptr as usize },
1957 12usize,
1958 concat!(
1959 "Offset of field: ",
1960 stringify!(virtio_gpu_config),
1961 "::",
1962 stringify!(num_capsets)
1963 )
1964 );
1965 }
1966 pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_B8G8R8A8_UNORM: virtio_gpu_formats = 1;
1967 pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM: virtio_gpu_formats = 2;
1968 pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM: virtio_gpu_formats = 3;
1969 pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_X8R8G8B8_UNORM: virtio_gpu_formats = 4;
1970 pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_R8G8B8A8_UNORM: virtio_gpu_formats = 67;
1971 pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_X8B8G8R8_UNORM: virtio_gpu_formats = 68;
1972 pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM: virtio_gpu_formats = 121;
1973 pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM: virtio_gpu_formats = 134;
1974 pub type virtio_gpu_formats = ::std::os::raw::c_uint;
1975 #[repr(C)]
1976 #[derive(Debug, Default, Copy, Clone, PartialEq)]
1977 pub struct virtio_gpu_resource_assign_uuid {
1978 pub hdr: virtio_gpu_ctrl_hdr,
1979 pub resource_id: __le32,
1980 pub padding: __le32,
1981 }
1982 #[test]
bindgen_test_layout_virtio_gpu_resource_assign_uuid()1983 fn bindgen_test_layout_virtio_gpu_resource_assign_uuid() {
1984 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_assign_uuid> =
1985 ::std::mem::MaybeUninit::uninit();
1986 let ptr = UNINIT.as_ptr();
1987 assert_eq!(
1988 ::std::mem::size_of::<virtio_gpu_resource_assign_uuid>(),
1989 32usize,
1990 concat!("Size of: ", stringify!(virtio_gpu_resource_assign_uuid))
1991 );
1992 assert_eq!(
1993 ::std::mem::align_of::<virtio_gpu_resource_assign_uuid>(),
1994 8usize,
1995 concat!("Alignment of ", stringify!(virtio_gpu_resource_assign_uuid))
1996 );
1997 assert_eq!(
1998 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
1999 0usize,
2000 concat!(
2001 "Offset of field: ",
2002 stringify!(virtio_gpu_resource_assign_uuid),
2003 "::",
2004 stringify!(hdr)
2005 )
2006 );
2007 assert_eq!(
2008 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
2009 24usize,
2010 concat!(
2011 "Offset of field: ",
2012 stringify!(virtio_gpu_resource_assign_uuid),
2013 "::",
2014 stringify!(resource_id)
2015 )
2016 );
2017 assert_eq!(
2018 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
2019 28usize,
2020 concat!(
2021 "Offset of field: ",
2022 stringify!(virtio_gpu_resource_assign_uuid),
2023 "::",
2024 stringify!(padding)
2025 )
2026 );
2027 }
2028 #[repr(C)]
2029 #[derive(Debug, Default, Copy, Clone, PartialEq)]
2030 pub struct virtio_gpu_resp_resource_uuid {
2031 pub hdr: virtio_gpu_ctrl_hdr,
2032 pub uuid: [__u8; 16usize],
2033 }
2034 #[test]
bindgen_test_layout_virtio_gpu_resp_resource_uuid()2035 fn bindgen_test_layout_virtio_gpu_resp_resource_uuid() {
2036 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resp_resource_uuid> =
2037 ::std::mem::MaybeUninit::uninit();
2038 let ptr = UNINIT.as_ptr();
2039 assert_eq!(
2040 ::std::mem::size_of::<virtio_gpu_resp_resource_uuid>(),
2041 40usize,
2042 concat!("Size of: ", stringify!(virtio_gpu_resp_resource_uuid))
2043 );
2044 assert_eq!(
2045 ::std::mem::align_of::<virtio_gpu_resp_resource_uuid>(),
2046 8usize,
2047 concat!("Alignment of ", stringify!(virtio_gpu_resp_resource_uuid))
2048 );
2049 assert_eq!(
2050 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
2051 0usize,
2052 concat!(
2053 "Offset of field: ",
2054 stringify!(virtio_gpu_resp_resource_uuid),
2055 "::",
2056 stringify!(hdr)
2057 )
2058 );
2059 assert_eq!(
2060 unsafe { ::std::ptr::addr_of!((*ptr).uuid) as usize - ptr as usize },
2061 24usize,
2062 concat!(
2063 "Offset of field: ",
2064 stringify!(virtio_gpu_resp_resource_uuid),
2065 "::",
2066 stringify!(uuid)
2067 )
2068 );
2069 }
2070 #[repr(C)]
2071 #[derive(Debug, Default, Copy, Clone, PartialEq)]
2072 pub struct virtio_gpu_resource_create_blob {
2073 pub hdr: virtio_gpu_ctrl_hdr,
2074 pub resource_id: __le32,
2075 pub blob_mem: __le32,
2076 pub blob_flags: __le32,
2077 pub nr_entries: __le32,
2078 pub blob_id: __le64,
2079 pub size: __le64,
2080 }
2081 #[test]
bindgen_test_layout_virtio_gpu_resource_create_blob()2082 fn bindgen_test_layout_virtio_gpu_resource_create_blob() {
2083 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_create_blob> =
2084 ::std::mem::MaybeUninit::uninit();
2085 let ptr = UNINIT.as_ptr();
2086 assert_eq!(
2087 ::std::mem::size_of::<virtio_gpu_resource_create_blob>(),
2088 56usize,
2089 concat!("Size of: ", stringify!(virtio_gpu_resource_create_blob))
2090 );
2091 assert_eq!(
2092 ::std::mem::align_of::<virtio_gpu_resource_create_blob>(),
2093 8usize,
2094 concat!("Alignment of ", stringify!(virtio_gpu_resource_create_blob))
2095 );
2096 assert_eq!(
2097 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
2098 0usize,
2099 concat!(
2100 "Offset of field: ",
2101 stringify!(virtio_gpu_resource_create_blob),
2102 "::",
2103 stringify!(hdr)
2104 )
2105 );
2106 assert_eq!(
2107 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
2108 24usize,
2109 concat!(
2110 "Offset of field: ",
2111 stringify!(virtio_gpu_resource_create_blob),
2112 "::",
2113 stringify!(resource_id)
2114 )
2115 );
2116 assert_eq!(
2117 unsafe { ::std::ptr::addr_of!((*ptr).blob_mem) as usize - ptr as usize },
2118 28usize,
2119 concat!(
2120 "Offset of field: ",
2121 stringify!(virtio_gpu_resource_create_blob),
2122 "::",
2123 stringify!(blob_mem)
2124 )
2125 );
2126 assert_eq!(
2127 unsafe { ::std::ptr::addr_of!((*ptr).blob_flags) as usize - ptr as usize },
2128 32usize,
2129 concat!(
2130 "Offset of field: ",
2131 stringify!(virtio_gpu_resource_create_blob),
2132 "::",
2133 stringify!(blob_flags)
2134 )
2135 );
2136 assert_eq!(
2137 unsafe { ::std::ptr::addr_of!((*ptr).nr_entries) as usize - ptr as usize },
2138 36usize,
2139 concat!(
2140 "Offset of field: ",
2141 stringify!(virtio_gpu_resource_create_blob),
2142 "::",
2143 stringify!(nr_entries)
2144 )
2145 );
2146 assert_eq!(
2147 unsafe { ::std::ptr::addr_of!((*ptr).blob_id) as usize - ptr as usize },
2148 40usize,
2149 concat!(
2150 "Offset of field: ",
2151 stringify!(virtio_gpu_resource_create_blob),
2152 "::",
2153 stringify!(blob_id)
2154 )
2155 );
2156 assert_eq!(
2157 unsafe { ::std::ptr::addr_of!((*ptr).size) as usize - ptr as usize },
2158 48usize,
2159 concat!(
2160 "Offset of field: ",
2161 stringify!(virtio_gpu_resource_create_blob),
2162 "::",
2163 stringify!(size)
2164 )
2165 );
2166 }
2167 #[repr(C)]
2168 #[derive(Debug, Default, Copy, Clone, PartialEq)]
2169 pub struct virtio_gpu_set_scanout_blob {
2170 pub hdr: virtio_gpu_ctrl_hdr,
2171 pub r: virtio_gpu_rect,
2172 pub scanout_id: __le32,
2173 pub resource_id: __le32,
2174 pub width: __le32,
2175 pub height: __le32,
2176 pub format: __le32,
2177 pub padding: __le32,
2178 pub strides: [__le32; 4usize],
2179 pub offsets: [__le32; 4usize],
2180 }
2181 #[test]
bindgen_test_layout_virtio_gpu_set_scanout_blob()2182 fn bindgen_test_layout_virtio_gpu_set_scanout_blob() {
2183 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_set_scanout_blob> =
2184 ::std::mem::MaybeUninit::uninit();
2185 let ptr = UNINIT.as_ptr();
2186 assert_eq!(
2187 ::std::mem::size_of::<virtio_gpu_set_scanout_blob>(),
2188 96usize,
2189 concat!("Size of: ", stringify!(virtio_gpu_set_scanout_blob))
2190 );
2191 assert_eq!(
2192 ::std::mem::align_of::<virtio_gpu_set_scanout_blob>(),
2193 8usize,
2194 concat!("Alignment of ", stringify!(virtio_gpu_set_scanout_blob))
2195 );
2196 assert_eq!(
2197 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
2198 0usize,
2199 concat!(
2200 "Offset of field: ",
2201 stringify!(virtio_gpu_set_scanout_blob),
2202 "::",
2203 stringify!(hdr)
2204 )
2205 );
2206 assert_eq!(
2207 unsafe { ::std::ptr::addr_of!((*ptr).r) as usize - ptr as usize },
2208 24usize,
2209 concat!(
2210 "Offset of field: ",
2211 stringify!(virtio_gpu_set_scanout_blob),
2212 "::",
2213 stringify!(r)
2214 )
2215 );
2216 assert_eq!(
2217 unsafe { ::std::ptr::addr_of!((*ptr).scanout_id) as usize - ptr as usize },
2218 40usize,
2219 concat!(
2220 "Offset of field: ",
2221 stringify!(virtio_gpu_set_scanout_blob),
2222 "::",
2223 stringify!(scanout_id)
2224 )
2225 );
2226 assert_eq!(
2227 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
2228 44usize,
2229 concat!(
2230 "Offset of field: ",
2231 stringify!(virtio_gpu_set_scanout_blob),
2232 "::",
2233 stringify!(resource_id)
2234 )
2235 );
2236 assert_eq!(
2237 unsafe { ::std::ptr::addr_of!((*ptr).width) as usize - ptr as usize },
2238 48usize,
2239 concat!(
2240 "Offset of field: ",
2241 stringify!(virtio_gpu_set_scanout_blob),
2242 "::",
2243 stringify!(width)
2244 )
2245 );
2246 assert_eq!(
2247 unsafe { ::std::ptr::addr_of!((*ptr).height) as usize - ptr as usize },
2248 52usize,
2249 concat!(
2250 "Offset of field: ",
2251 stringify!(virtio_gpu_set_scanout_blob),
2252 "::",
2253 stringify!(height)
2254 )
2255 );
2256 assert_eq!(
2257 unsafe { ::std::ptr::addr_of!((*ptr).format) as usize - ptr as usize },
2258 56usize,
2259 concat!(
2260 "Offset of field: ",
2261 stringify!(virtio_gpu_set_scanout_blob),
2262 "::",
2263 stringify!(format)
2264 )
2265 );
2266 assert_eq!(
2267 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
2268 60usize,
2269 concat!(
2270 "Offset of field: ",
2271 stringify!(virtio_gpu_set_scanout_blob),
2272 "::",
2273 stringify!(padding)
2274 )
2275 );
2276 assert_eq!(
2277 unsafe { ::std::ptr::addr_of!((*ptr).strides) as usize - ptr as usize },
2278 64usize,
2279 concat!(
2280 "Offset of field: ",
2281 stringify!(virtio_gpu_set_scanout_blob),
2282 "::",
2283 stringify!(strides)
2284 )
2285 );
2286 assert_eq!(
2287 unsafe { ::std::ptr::addr_of!((*ptr).offsets) as usize - ptr as usize },
2288 80usize,
2289 concat!(
2290 "Offset of field: ",
2291 stringify!(virtio_gpu_set_scanout_blob),
2292 "::",
2293 stringify!(offsets)
2294 )
2295 );
2296 }
2297 #[repr(C)]
2298 #[derive(Debug, Default, Copy, Clone, PartialEq)]
2299 pub struct virtio_gpu_resource_map_blob {
2300 pub hdr: virtio_gpu_ctrl_hdr,
2301 pub resource_id: __le32,
2302 pub padding: __le32,
2303 pub offset: __le64,
2304 }
2305 #[test]
bindgen_test_layout_virtio_gpu_resource_map_blob()2306 fn bindgen_test_layout_virtio_gpu_resource_map_blob() {
2307 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_map_blob> =
2308 ::std::mem::MaybeUninit::uninit();
2309 let ptr = UNINIT.as_ptr();
2310 assert_eq!(
2311 ::std::mem::size_of::<virtio_gpu_resource_map_blob>(),
2312 40usize,
2313 concat!("Size of: ", stringify!(virtio_gpu_resource_map_blob))
2314 );
2315 assert_eq!(
2316 ::std::mem::align_of::<virtio_gpu_resource_map_blob>(),
2317 8usize,
2318 concat!("Alignment of ", stringify!(virtio_gpu_resource_map_blob))
2319 );
2320 assert_eq!(
2321 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
2322 0usize,
2323 concat!(
2324 "Offset of field: ",
2325 stringify!(virtio_gpu_resource_map_blob),
2326 "::",
2327 stringify!(hdr)
2328 )
2329 );
2330 assert_eq!(
2331 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
2332 24usize,
2333 concat!(
2334 "Offset of field: ",
2335 stringify!(virtio_gpu_resource_map_blob),
2336 "::",
2337 stringify!(resource_id)
2338 )
2339 );
2340 assert_eq!(
2341 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
2342 28usize,
2343 concat!(
2344 "Offset of field: ",
2345 stringify!(virtio_gpu_resource_map_blob),
2346 "::",
2347 stringify!(padding)
2348 )
2349 );
2350 assert_eq!(
2351 unsafe { ::std::ptr::addr_of!((*ptr).offset) as usize - ptr as usize },
2352 32usize,
2353 concat!(
2354 "Offset of field: ",
2355 stringify!(virtio_gpu_resource_map_blob),
2356 "::",
2357 stringify!(offset)
2358 )
2359 );
2360 }
2361 #[repr(C)]
2362 #[derive(Debug, Default, Copy, Clone, PartialEq)]
2363 pub struct virtio_gpu_resp_map_info {
2364 pub hdr: virtio_gpu_ctrl_hdr,
2365 pub map_info: __u32,
2366 pub padding: __u32,
2367 }
2368 #[test]
bindgen_test_layout_virtio_gpu_resp_map_info()2369 fn bindgen_test_layout_virtio_gpu_resp_map_info() {
2370 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resp_map_info> =
2371 ::std::mem::MaybeUninit::uninit();
2372 let ptr = UNINIT.as_ptr();
2373 assert_eq!(
2374 ::std::mem::size_of::<virtio_gpu_resp_map_info>(),
2375 32usize,
2376 concat!("Size of: ", stringify!(virtio_gpu_resp_map_info))
2377 );
2378 assert_eq!(
2379 ::std::mem::align_of::<virtio_gpu_resp_map_info>(),
2380 8usize,
2381 concat!("Alignment of ", stringify!(virtio_gpu_resp_map_info))
2382 );
2383 assert_eq!(
2384 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
2385 0usize,
2386 concat!(
2387 "Offset of field: ",
2388 stringify!(virtio_gpu_resp_map_info),
2389 "::",
2390 stringify!(hdr)
2391 )
2392 );
2393 assert_eq!(
2394 unsafe { ::std::ptr::addr_of!((*ptr).map_info) as usize - ptr as usize },
2395 24usize,
2396 concat!(
2397 "Offset of field: ",
2398 stringify!(virtio_gpu_resp_map_info),
2399 "::",
2400 stringify!(map_info)
2401 )
2402 );
2403 assert_eq!(
2404 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
2405 28usize,
2406 concat!(
2407 "Offset of field: ",
2408 stringify!(virtio_gpu_resp_map_info),
2409 "::",
2410 stringify!(padding)
2411 )
2412 );
2413 }
2414 #[repr(C)]
2415 #[derive(Debug, Default, Copy, Clone, PartialEq)]
2416 pub struct virtio_gpu_resource_unmap_blob {
2417 pub hdr: virtio_gpu_ctrl_hdr,
2418 pub resource_id: __le32,
2419 pub padding: __le32,
2420 }
2421 #[test]
bindgen_test_layout_virtio_gpu_resource_unmap_blob()2422 fn bindgen_test_layout_virtio_gpu_resource_unmap_blob() {
2423 const UNINIT: ::std::mem::MaybeUninit<virtio_gpu_resource_unmap_blob> =
2424 ::std::mem::MaybeUninit::uninit();
2425 let ptr = UNINIT.as_ptr();
2426 assert_eq!(
2427 ::std::mem::size_of::<virtio_gpu_resource_unmap_blob>(),
2428 32usize,
2429 concat!("Size of: ", stringify!(virtio_gpu_resource_unmap_blob))
2430 );
2431 assert_eq!(
2432 ::std::mem::align_of::<virtio_gpu_resource_unmap_blob>(),
2433 8usize,
2434 concat!("Alignment of ", stringify!(virtio_gpu_resource_unmap_blob))
2435 );
2436 assert_eq!(
2437 unsafe { ::std::ptr::addr_of!((*ptr).hdr) as usize - ptr as usize },
2438 0usize,
2439 concat!(
2440 "Offset of field: ",
2441 stringify!(virtio_gpu_resource_unmap_blob),
2442 "::",
2443 stringify!(hdr)
2444 )
2445 );
2446 assert_eq!(
2447 unsafe { ::std::ptr::addr_of!((*ptr).resource_id) as usize - ptr as usize },
2448 24usize,
2449 concat!(
2450 "Offset of field: ",
2451 stringify!(virtio_gpu_resource_unmap_blob),
2452 "::",
2453 stringify!(resource_id)
2454 )
2455 );
2456 assert_eq!(
2457 unsafe { ::std::ptr::addr_of!((*ptr).padding) as usize - ptr as usize },
2458 28usize,
2459 concat!(
2460 "Offset of field: ",
2461 stringify!(virtio_gpu_resource_unmap_blob),
2462 "::",
2463 stringify!(padding)
2464 )
2465 );
2466 }
2467