1#[repr(C)]
4#[derive(Default)]
5pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; 0]);
6impl<T> __IncompleteArrayField<T> {
7 #[inline]
8 pub const fn new() -> Self {
9 __IncompleteArrayField(::std::marker::PhantomData, [])
10 }
11 #[inline]
12 pub fn as_ptr(&self) -> *const T {
13 self as *const _ as *const T
14 }
15 #[inline]
16 pub fn as_mut_ptr(&mut self) -> *mut T {
17 self as *mut _ as *mut T
18 }
19 #[inline]
20 pub unsafe fn as_slice(&self, len: usize) -> &[T] {
21 ::std::slice::from_raw_parts(self.as_ptr(), len)
22 }
23 #[inline]
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}
28impl<T> ::std::fmt::Debug for __IncompleteArrayField<T> {
29 fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
30 fmt.write_str("__IncompleteArrayField")
31 }
32}
33pub const VIRTIO_GPU_F_VIRGL: u32 = 0;
34pub const VIRTIO_GPU_F_EDID: u32 = 1;
35pub const VIRTIO_GPU_F_RESOURCE_UUID: u32 = 2;
36pub const VIRTIO_GPU_F_RESOURCE_BLOB: u32 = 3;
37pub const VIRTIO_GPU_F_CONTEXT_INIT: u32 = 4;
38pub const VIRTIO_GPU_FLAG_FENCE: u32 = 1;
39pub const VIRTIO_GPU_FLAG_INFO_RING_IDX: u32 = 2;
40pub const VIRTIO_GPU_MAX_SCANOUTS: u32 = 16;
41pub const VIRTIO_GPU_RESOURCE_FLAG_Y_0_TOP: u32 = 1;
42pub const VIRTIO_GPU_CONTEXT_INIT_CAPSET_ID_MASK: u32 = 255;
43pub const VIRTIO_GPU_CAPSET_VIRGL: u32 = 1;
44pub const VIRTIO_GPU_CAPSET_VIRGL2: u32 = 2;
45pub const VIRTIO_GPU_CAPSET_GFXSTREAM_VULKAN: u32 = 3;
46pub const VIRTIO_GPU_CAPSET_VENUS: u32 = 4;
47pub const VIRTIO_GPU_CAPSET_CROSS_DOMAIN: u32 = 5;
48pub const VIRTIO_GPU_CAPSET_DRM: u32 = 6;
49pub const VIRTIO_GPU_EVENT_DISPLAY: u32 = 1;
50pub const VIRTIO_GPU_BLOB_MEM_GUEST: u32 = 1;
51pub const VIRTIO_GPU_BLOB_MEM_HOST3D: u32 = 2;
52pub const VIRTIO_GPU_BLOB_MEM_HOST3D_GUEST: u32 = 3;
53pub const VIRTIO_GPU_BLOB_FLAG_USE_MAPPABLE: u32 = 1;
54pub const VIRTIO_GPU_BLOB_FLAG_USE_SHAREABLE: u32 = 2;
55pub const VIRTIO_GPU_BLOB_FLAG_USE_CROSS_DEVICE: u32 = 4;
56pub const VIRTIO_GPU_MAP_CACHE_MASK: u32 = 15;
57pub const VIRTIO_GPU_MAP_CACHE_NONE: u32 = 0;
58pub const VIRTIO_GPU_MAP_CACHE_CACHED: u32 = 1;
59pub const VIRTIO_GPU_MAP_CACHE_UNCACHED: u32 = 2;
60pub const VIRTIO_GPU_MAP_CACHE_WC: u32 = 3;
61pub type __u8 = ::std::os::raw::c_uchar;
62pub type __u32 = ::std::os::raw::c_uint;
63pub type __u64 = ::std::os::raw::c_ulonglong;
64pub type __le32 = __u32;
65pub type __le64 = __u64;
66pub const virtio_gpu_ctrl_type_VIRTIO_GPU_UNDEFINED: virtio_gpu_ctrl_type = 0;
67pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_GET_DISPLAY_INFO: virtio_gpu_ctrl_type = 256;
68pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_CREATE_2D: virtio_gpu_ctrl_type = 257;
69pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_UNREF: virtio_gpu_ctrl_type = 258;
70pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_SET_SCANOUT: virtio_gpu_ctrl_type = 259;
71pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_FLUSH: virtio_gpu_ctrl_type = 260;
72pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_TRANSFER_TO_HOST_2D: virtio_gpu_ctrl_type = 261;
73pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_ATTACH_BACKING: virtio_gpu_ctrl_type = 262;
74pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_DETACH_BACKING: virtio_gpu_ctrl_type = 263;
75pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_GET_CAPSET_INFO: virtio_gpu_ctrl_type = 264;
76pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_GET_CAPSET: virtio_gpu_ctrl_type = 265;
77pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_GET_EDID: virtio_gpu_ctrl_type = 266;
78pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_ASSIGN_UUID: virtio_gpu_ctrl_type = 267;
79pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_CREATE_BLOB: virtio_gpu_ctrl_type = 268;
80pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_SET_SCANOUT_BLOB: virtio_gpu_ctrl_type = 269;
81pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_CTX_CREATE: virtio_gpu_ctrl_type = 512;
82pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_CTX_DESTROY: virtio_gpu_ctrl_type = 513;
83pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_CTX_ATTACH_RESOURCE: virtio_gpu_ctrl_type = 514;
84pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_CTX_DETACH_RESOURCE: virtio_gpu_ctrl_type = 515;
85pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_CREATE_3D: virtio_gpu_ctrl_type = 516;
86pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_TRANSFER_TO_HOST_3D: virtio_gpu_ctrl_type = 517;
87pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_TRANSFER_FROM_HOST_3D: virtio_gpu_ctrl_type = 518;
88pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_SUBMIT_3D: virtio_gpu_ctrl_type = 519;
89pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_MAP_BLOB: virtio_gpu_ctrl_type = 520;
90pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_RESOURCE_UNMAP_BLOB: virtio_gpu_ctrl_type = 521;
91pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_UPDATE_CURSOR: virtio_gpu_ctrl_type = 768;
92pub const virtio_gpu_ctrl_type_VIRTIO_GPU_CMD_MOVE_CURSOR: virtio_gpu_ctrl_type = 769;
93pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_NODATA: virtio_gpu_ctrl_type = 4352;
94pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_DISPLAY_INFO: virtio_gpu_ctrl_type = 4353;
95pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_CAPSET_INFO: virtio_gpu_ctrl_type = 4354;
96pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_CAPSET: virtio_gpu_ctrl_type = 4355;
97pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_EDID: virtio_gpu_ctrl_type = 4356;
98pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_RESOURCE_UUID: virtio_gpu_ctrl_type = 4357;
99pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_OK_MAP_INFO: virtio_gpu_ctrl_type = 4358;
100pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_UNSPEC: virtio_gpu_ctrl_type = 4608;
101pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_OUT_OF_MEMORY: virtio_gpu_ctrl_type = 4609;
102pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_INVALID_SCANOUT_ID: virtio_gpu_ctrl_type = 4610;
103pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_INVALID_RESOURCE_ID: virtio_gpu_ctrl_type = 4611;
104pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_INVALID_CONTEXT_ID: virtio_gpu_ctrl_type = 4612;
105pub const virtio_gpu_ctrl_type_VIRTIO_GPU_RESP_ERR_INVALID_PARAMETER: virtio_gpu_ctrl_type = 4613;
106pub type virtio_gpu_ctrl_type = ::std::os::raw::c_uint;
107pub const virtio_gpu_shm_id_VIRTIO_GPU_SHM_ID_UNDEFINED: virtio_gpu_shm_id = 0;
108pub const virtio_gpu_shm_id_VIRTIO_GPU_SHM_ID_HOST_VISIBLE: virtio_gpu_shm_id = 1;
109pub type virtio_gpu_shm_id = ::std::os::raw::c_uint;
110#[repr(C)]
111#[derive(Debug, Default, Copy, Clone, PartialEq)]
112pub struct virtio_gpu_ctrl_hdr {
113 pub type_: __le32,
114 pub flags: __le32,
115 pub fence_id: __le64,
116 pub ctx_id: __le32,
117 pub ring_idx: __u8,
118 pub padding: [__u8; 3usize],
119}
120#[allow(clippy::unnecessary_operation, clippy::identity_op)]
121const _: () = {
122 ["Size of virtio_gpu_ctrl_hdr"][::std::mem::size_of::<virtio_gpu_ctrl_hdr>() - 24usize];
123 ["Alignment of virtio_gpu_ctrl_hdr"][::std::mem::align_of::<virtio_gpu_ctrl_hdr>() - 8usize];
124 ["Offset of field: virtio_gpu_ctrl_hdr::type_"]
125 [::std::mem::offset_of!(virtio_gpu_ctrl_hdr, type_) - 0usize];
126 ["Offset of field: virtio_gpu_ctrl_hdr::flags"]
127 [::std::mem::offset_of!(virtio_gpu_ctrl_hdr, flags) - 4usize];
128 ["Offset of field: virtio_gpu_ctrl_hdr::fence_id"]
129 [::std::mem::offset_of!(virtio_gpu_ctrl_hdr, fence_id) - 8usize];
130 ["Offset of field: virtio_gpu_ctrl_hdr::ctx_id"]
131 [::std::mem::offset_of!(virtio_gpu_ctrl_hdr, ctx_id) - 16usize];
132 ["Offset of field: virtio_gpu_ctrl_hdr::ring_idx"]
133 [::std::mem::offset_of!(virtio_gpu_ctrl_hdr, ring_idx) - 20usize];
134 ["Offset of field: virtio_gpu_ctrl_hdr::padding"]
135 [::std::mem::offset_of!(virtio_gpu_ctrl_hdr, padding) - 21usize];
136};
137#[repr(C)]
138#[derive(Debug, Default, Copy, Clone, PartialEq)]
139pub struct virtio_gpu_cursor_pos {
140 pub scanout_id: __le32,
141 pub x: __le32,
142 pub y: __le32,
143 pub padding: __le32,
144}
145#[allow(clippy::unnecessary_operation, clippy::identity_op)]
146const _: () = {
147 ["Size of virtio_gpu_cursor_pos"][::std::mem::size_of::<virtio_gpu_cursor_pos>() - 16usize];
148 ["Alignment of virtio_gpu_cursor_pos"]
149 [::std::mem::align_of::<virtio_gpu_cursor_pos>() - 4usize];
150 ["Offset of field: virtio_gpu_cursor_pos::scanout_id"]
151 [::std::mem::offset_of!(virtio_gpu_cursor_pos, scanout_id) - 0usize];
152 ["Offset of field: virtio_gpu_cursor_pos::x"]
153 [::std::mem::offset_of!(virtio_gpu_cursor_pos, x) - 4usize];
154 ["Offset of field: virtio_gpu_cursor_pos::y"]
155 [::std::mem::offset_of!(virtio_gpu_cursor_pos, y) - 8usize];
156 ["Offset of field: virtio_gpu_cursor_pos::padding"]
157 [::std::mem::offset_of!(virtio_gpu_cursor_pos, padding) - 12usize];
158};
159#[repr(C)]
160#[derive(Debug, Default, Copy, Clone, PartialEq)]
161pub struct virtio_gpu_update_cursor {
162 pub hdr: virtio_gpu_ctrl_hdr,
163 pub pos: virtio_gpu_cursor_pos,
164 pub resource_id: __le32,
165 pub hot_x: __le32,
166 pub hot_y: __le32,
167 pub padding: __le32,
168}
169#[allow(clippy::unnecessary_operation, clippy::identity_op)]
170const _: () = {
171 ["Size of virtio_gpu_update_cursor"]
172 [::std::mem::size_of::<virtio_gpu_update_cursor>() - 56usize];
173 ["Alignment of virtio_gpu_update_cursor"]
174 [::std::mem::align_of::<virtio_gpu_update_cursor>() - 8usize];
175 ["Offset of field: virtio_gpu_update_cursor::hdr"]
176 [::std::mem::offset_of!(virtio_gpu_update_cursor, hdr) - 0usize];
177 ["Offset of field: virtio_gpu_update_cursor::pos"]
178 [::std::mem::offset_of!(virtio_gpu_update_cursor, pos) - 24usize];
179 ["Offset of field: virtio_gpu_update_cursor::resource_id"]
180 [::std::mem::offset_of!(virtio_gpu_update_cursor, resource_id) - 40usize];
181 ["Offset of field: virtio_gpu_update_cursor::hot_x"]
182 [::std::mem::offset_of!(virtio_gpu_update_cursor, hot_x) - 44usize];
183 ["Offset of field: virtio_gpu_update_cursor::hot_y"]
184 [::std::mem::offset_of!(virtio_gpu_update_cursor, hot_y) - 48usize];
185 ["Offset of field: virtio_gpu_update_cursor::padding"]
186 [::std::mem::offset_of!(virtio_gpu_update_cursor, padding) - 52usize];
187};
188#[repr(C)]
189#[derive(Debug, Default, Copy, Clone, PartialEq)]
190pub struct virtio_gpu_rect {
191 pub x: __le32,
192 pub y: __le32,
193 pub width: __le32,
194 pub height: __le32,
195}
196#[allow(clippy::unnecessary_operation, clippy::identity_op)]
197const _: () = {
198 ["Size of virtio_gpu_rect"][::std::mem::size_of::<virtio_gpu_rect>() - 16usize];
199 ["Alignment of virtio_gpu_rect"][::std::mem::align_of::<virtio_gpu_rect>() - 4usize];
200 ["Offset of field: virtio_gpu_rect::x"][::std::mem::offset_of!(virtio_gpu_rect, x) - 0usize];
201 ["Offset of field: virtio_gpu_rect::y"][::std::mem::offset_of!(virtio_gpu_rect, y) - 4usize];
202 ["Offset of field: virtio_gpu_rect::width"]
203 [::std::mem::offset_of!(virtio_gpu_rect, width) - 8usize];
204 ["Offset of field: virtio_gpu_rect::height"]
205 [::std::mem::offset_of!(virtio_gpu_rect, height) - 12usize];
206};
207#[repr(C)]
208#[derive(Debug, Default, Copy, Clone, PartialEq)]
209pub struct virtio_gpu_resource_unref {
210 pub hdr: virtio_gpu_ctrl_hdr,
211 pub resource_id: __le32,
212 pub padding: __le32,
213}
214#[allow(clippy::unnecessary_operation, clippy::identity_op)]
215const _: () = {
216 ["Size of virtio_gpu_resource_unref"]
217 [::std::mem::size_of::<virtio_gpu_resource_unref>() - 32usize];
218 ["Alignment of virtio_gpu_resource_unref"]
219 [::std::mem::align_of::<virtio_gpu_resource_unref>() - 8usize];
220 ["Offset of field: virtio_gpu_resource_unref::hdr"]
221 [::std::mem::offset_of!(virtio_gpu_resource_unref, hdr) - 0usize];
222 ["Offset of field: virtio_gpu_resource_unref::resource_id"]
223 [::std::mem::offset_of!(virtio_gpu_resource_unref, resource_id) - 24usize];
224 ["Offset of field: virtio_gpu_resource_unref::padding"]
225 [::std::mem::offset_of!(virtio_gpu_resource_unref, padding) - 28usize];
226};
227#[repr(C)]
228#[derive(Debug, Default, Copy, Clone, PartialEq)]
229pub struct virtio_gpu_resource_create_2d {
230 pub hdr: virtio_gpu_ctrl_hdr,
231 pub resource_id: __le32,
232 pub format: __le32,
233 pub width: __le32,
234 pub height: __le32,
235}
236#[allow(clippy::unnecessary_operation, clippy::identity_op)]
237const _: () = {
238 ["Size of virtio_gpu_resource_create_2d"]
239 [::std::mem::size_of::<virtio_gpu_resource_create_2d>() - 40usize];
240 ["Alignment of virtio_gpu_resource_create_2d"]
241 [::std::mem::align_of::<virtio_gpu_resource_create_2d>() - 8usize];
242 ["Offset of field: virtio_gpu_resource_create_2d::hdr"]
243 [::std::mem::offset_of!(virtio_gpu_resource_create_2d, hdr) - 0usize];
244 ["Offset of field: virtio_gpu_resource_create_2d::resource_id"]
245 [::std::mem::offset_of!(virtio_gpu_resource_create_2d, resource_id) - 24usize];
246 ["Offset of field: virtio_gpu_resource_create_2d::format"]
247 [::std::mem::offset_of!(virtio_gpu_resource_create_2d, format) - 28usize];
248 ["Offset of field: virtio_gpu_resource_create_2d::width"]
249 [::std::mem::offset_of!(virtio_gpu_resource_create_2d, width) - 32usize];
250 ["Offset of field: virtio_gpu_resource_create_2d::height"]
251 [::std::mem::offset_of!(virtio_gpu_resource_create_2d, height) - 36usize];
252};
253#[repr(C)]
254#[derive(Debug, Default, Copy, Clone, PartialEq)]
255pub struct virtio_gpu_set_scanout {
256 pub hdr: virtio_gpu_ctrl_hdr,
257 pub r: virtio_gpu_rect,
258 pub scanout_id: __le32,
259 pub resource_id: __le32,
260}
261#[allow(clippy::unnecessary_operation, clippy::identity_op)]
262const _: () = {
263 ["Size of virtio_gpu_set_scanout"][::std::mem::size_of::<virtio_gpu_set_scanout>() - 48usize];
264 ["Alignment of virtio_gpu_set_scanout"]
265 [::std::mem::align_of::<virtio_gpu_set_scanout>() - 8usize];
266 ["Offset of field: virtio_gpu_set_scanout::hdr"]
267 [::std::mem::offset_of!(virtio_gpu_set_scanout, hdr) - 0usize];
268 ["Offset of field: virtio_gpu_set_scanout::r"]
269 [::std::mem::offset_of!(virtio_gpu_set_scanout, r) - 24usize];
270 ["Offset of field: virtio_gpu_set_scanout::scanout_id"]
271 [::std::mem::offset_of!(virtio_gpu_set_scanout, scanout_id) - 40usize];
272 ["Offset of field: virtio_gpu_set_scanout::resource_id"]
273 [::std::mem::offset_of!(virtio_gpu_set_scanout, resource_id) - 44usize];
274};
275#[repr(C)]
276#[derive(Debug, Default, Copy, Clone, PartialEq)]
277pub struct virtio_gpu_resource_flush {
278 pub hdr: virtio_gpu_ctrl_hdr,
279 pub r: virtio_gpu_rect,
280 pub resource_id: __le32,
281 pub padding: __le32,
282}
283#[allow(clippy::unnecessary_operation, clippy::identity_op)]
284const _: () = {
285 ["Size of virtio_gpu_resource_flush"]
286 [::std::mem::size_of::<virtio_gpu_resource_flush>() - 48usize];
287 ["Alignment of virtio_gpu_resource_flush"]
288 [::std::mem::align_of::<virtio_gpu_resource_flush>() - 8usize];
289 ["Offset of field: virtio_gpu_resource_flush::hdr"]
290 [::std::mem::offset_of!(virtio_gpu_resource_flush, hdr) - 0usize];
291 ["Offset of field: virtio_gpu_resource_flush::r"]
292 [::std::mem::offset_of!(virtio_gpu_resource_flush, r) - 24usize];
293 ["Offset of field: virtio_gpu_resource_flush::resource_id"]
294 [::std::mem::offset_of!(virtio_gpu_resource_flush, resource_id) - 40usize];
295 ["Offset of field: virtio_gpu_resource_flush::padding"]
296 [::std::mem::offset_of!(virtio_gpu_resource_flush, padding) - 44usize];
297};
298#[repr(C)]
299#[derive(Debug, Default, Copy, Clone, PartialEq)]
300pub struct virtio_gpu_transfer_to_host_2d {
301 pub hdr: virtio_gpu_ctrl_hdr,
302 pub r: virtio_gpu_rect,
303 pub offset: __le64,
304 pub resource_id: __le32,
305 pub padding: __le32,
306}
307#[allow(clippy::unnecessary_operation, clippy::identity_op)]
308const _: () = {
309 ["Size of virtio_gpu_transfer_to_host_2d"]
310 [::std::mem::size_of::<virtio_gpu_transfer_to_host_2d>() - 56usize];
311 ["Alignment of virtio_gpu_transfer_to_host_2d"]
312 [::std::mem::align_of::<virtio_gpu_transfer_to_host_2d>() - 8usize];
313 ["Offset of field: virtio_gpu_transfer_to_host_2d::hdr"]
314 [::std::mem::offset_of!(virtio_gpu_transfer_to_host_2d, hdr) - 0usize];
315 ["Offset of field: virtio_gpu_transfer_to_host_2d::r"]
316 [::std::mem::offset_of!(virtio_gpu_transfer_to_host_2d, r) - 24usize];
317 ["Offset of field: virtio_gpu_transfer_to_host_2d::offset"]
318 [::std::mem::offset_of!(virtio_gpu_transfer_to_host_2d, offset) - 40usize];
319 ["Offset of field: virtio_gpu_transfer_to_host_2d::resource_id"]
320 [::std::mem::offset_of!(virtio_gpu_transfer_to_host_2d, resource_id) - 48usize];
321 ["Offset of field: virtio_gpu_transfer_to_host_2d::padding"]
322 [::std::mem::offset_of!(virtio_gpu_transfer_to_host_2d, padding) - 52usize];
323};
324#[repr(C)]
325#[derive(Debug, Default, Copy, Clone, PartialEq)]
326pub struct virtio_gpu_mem_entry {
327 pub addr: __le64,
328 pub length: __le32,
329 pub padding: __le32,
330}
331#[allow(clippy::unnecessary_operation, clippy::identity_op)]
332const _: () = {
333 ["Size of virtio_gpu_mem_entry"][::std::mem::size_of::<virtio_gpu_mem_entry>() - 16usize];
334 ["Alignment of virtio_gpu_mem_entry"][::std::mem::align_of::<virtio_gpu_mem_entry>() - 8usize];
335 ["Offset of field: virtio_gpu_mem_entry::addr"]
336 [::std::mem::offset_of!(virtio_gpu_mem_entry, addr) - 0usize];
337 ["Offset of field: virtio_gpu_mem_entry::length"]
338 [::std::mem::offset_of!(virtio_gpu_mem_entry, length) - 8usize];
339 ["Offset of field: virtio_gpu_mem_entry::padding"]
340 [::std::mem::offset_of!(virtio_gpu_mem_entry, padding) - 12usize];
341};
342#[repr(C)]
343#[derive(Debug, Default, Copy, Clone, PartialEq)]
344pub struct virtio_gpu_resource_attach_backing {
345 pub hdr: virtio_gpu_ctrl_hdr,
346 pub resource_id: __le32,
347 pub nr_entries: __le32,
348}
349#[allow(clippy::unnecessary_operation, clippy::identity_op)]
350const _: () = {
351 ["Size of virtio_gpu_resource_attach_backing"]
352 [::std::mem::size_of::<virtio_gpu_resource_attach_backing>() - 32usize];
353 ["Alignment of virtio_gpu_resource_attach_backing"]
354 [::std::mem::align_of::<virtio_gpu_resource_attach_backing>() - 8usize];
355 ["Offset of field: virtio_gpu_resource_attach_backing::hdr"]
356 [::std::mem::offset_of!(virtio_gpu_resource_attach_backing, hdr) - 0usize];
357 ["Offset of field: virtio_gpu_resource_attach_backing::resource_id"]
358 [::std::mem::offset_of!(virtio_gpu_resource_attach_backing, resource_id) - 24usize];
359 ["Offset of field: virtio_gpu_resource_attach_backing::nr_entries"]
360 [::std::mem::offset_of!(virtio_gpu_resource_attach_backing, nr_entries) - 28usize];
361};
362#[repr(C)]
363#[derive(Debug, Default, Copy, Clone, PartialEq)]
364pub struct virtio_gpu_resource_detach_backing {
365 pub hdr: virtio_gpu_ctrl_hdr,
366 pub resource_id: __le32,
367 pub padding: __le32,
368}
369#[allow(clippy::unnecessary_operation, clippy::identity_op)]
370const _: () = {
371 ["Size of virtio_gpu_resource_detach_backing"]
372 [::std::mem::size_of::<virtio_gpu_resource_detach_backing>() - 32usize];
373 ["Alignment of virtio_gpu_resource_detach_backing"]
374 [::std::mem::align_of::<virtio_gpu_resource_detach_backing>() - 8usize];
375 ["Offset of field: virtio_gpu_resource_detach_backing::hdr"]
376 [::std::mem::offset_of!(virtio_gpu_resource_detach_backing, hdr) - 0usize];
377 ["Offset of field: virtio_gpu_resource_detach_backing::resource_id"]
378 [::std::mem::offset_of!(virtio_gpu_resource_detach_backing, resource_id) - 24usize];
379 ["Offset of field: virtio_gpu_resource_detach_backing::padding"]
380 [::std::mem::offset_of!(virtio_gpu_resource_detach_backing, padding) - 28usize];
381};
382#[repr(C)]
383#[derive(Debug, Default, Copy, Clone, PartialEq)]
384pub struct virtio_gpu_resp_display_info {
385 pub hdr: virtio_gpu_ctrl_hdr,
386 pub pmodes: [virtio_gpu_resp_display_info_virtio_gpu_display_one; 16usize],
387}
388#[repr(C)]
389#[derive(Debug, Default, Copy, Clone, PartialEq)]
390pub struct virtio_gpu_resp_display_info_virtio_gpu_display_one {
391 pub r: virtio_gpu_rect,
392 pub enabled: __le32,
393 pub flags: __le32,
394}
395#[allow(clippy::unnecessary_operation, clippy::identity_op)]
396const _: () = {
397 ["Size of virtio_gpu_resp_display_info_virtio_gpu_display_one"]
398 [::std::mem::size_of::<virtio_gpu_resp_display_info_virtio_gpu_display_one>() - 24usize];
399 ["Alignment of virtio_gpu_resp_display_info_virtio_gpu_display_one"]
400 [::std::mem::align_of::<virtio_gpu_resp_display_info_virtio_gpu_display_one>() - 4usize];
401 ["Offset of field: virtio_gpu_resp_display_info_virtio_gpu_display_one::r"]
402 [::std::mem::offset_of!(virtio_gpu_resp_display_info_virtio_gpu_display_one, r) - 0usize];
403 ["Offset of field: virtio_gpu_resp_display_info_virtio_gpu_display_one::enabled"][::std::mem::offset_of!(
404 virtio_gpu_resp_display_info_virtio_gpu_display_one,
405 enabled
406 ) - 16usize];
407 ["Offset of field: virtio_gpu_resp_display_info_virtio_gpu_display_one::flags"][::std::mem::offset_of!(
408 virtio_gpu_resp_display_info_virtio_gpu_display_one,
409 flags
410 ) - 20usize];
411};
412#[allow(clippy::unnecessary_operation, clippy::identity_op)]
413const _: () = {
414 ["Size of virtio_gpu_resp_display_info"]
415 [::std::mem::size_of::<virtio_gpu_resp_display_info>() - 408usize];
416 ["Alignment of virtio_gpu_resp_display_info"]
417 [::std::mem::align_of::<virtio_gpu_resp_display_info>() - 8usize];
418 ["Offset of field: virtio_gpu_resp_display_info::hdr"]
419 [::std::mem::offset_of!(virtio_gpu_resp_display_info, hdr) - 0usize];
420 ["Offset of field: virtio_gpu_resp_display_info::pmodes"]
421 [::std::mem::offset_of!(virtio_gpu_resp_display_info, pmodes) - 24usize];
422};
423#[repr(C)]
424#[derive(Debug, Default, Copy, Clone, PartialEq)]
425pub struct virtio_gpu_box {
426 pub x: __le32,
427 pub y: __le32,
428 pub z: __le32,
429 pub w: __le32,
430 pub h: __le32,
431 pub d: __le32,
432}
433#[allow(clippy::unnecessary_operation, clippy::identity_op)]
434const _: () = {
435 ["Size of virtio_gpu_box"][::std::mem::size_of::<virtio_gpu_box>() - 24usize];
436 ["Alignment of virtio_gpu_box"][::std::mem::align_of::<virtio_gpu_box>() - 4usize];
437 ["Offset of field: virtio_gpu_box::x"][::std::mem::offset_of!(virtio_gpu_box, x) - 0usize];
438 ["Offset of field: virtio_gpu_box::y"][::std::mem::offset_of!(virtio_gpu_box, y) - 4usize];
439 ["Offset of field: virtio_gpu_box::z"][::std::mem::offset_of!(virtio_gpu_box, z) - 8usize];
440 ["Offset of field: virtio_gpu_box::w"][::std::mem::offset_of!(virtio_gpu_box, w) - 12usize];
441 ["Offset of field: virtio_gpu_box::h"][::std::mem::offset_of!(virtio_gpu_box, h) - 16usize];
442 ["Offset of field: virtio_gpu_box::d"][::std::mem::offset_of!(virtio_gpu_box, d) - 20usize];
443};
444#[repr(C)]
445#[derive(Debug, Default, Copy, Clone, PartialEq)]
446pub struct virtio_gpu_transfer_host_3d {
447 pub hdr: virtio_gpu_ctrl_hdr,
448 pub box_: virtio_gpu_box,
449 pub offset: __le64,
450 pub resource_id: __le32,
451 pub level: __le32,
452 pub stride: __le32,
453 pub layer_stride: __le32,
454}
455#[allow(clippy::unnecessary_operation, clippy::identity_op)]
456const _: () = {
457 ["Size of virtio_gpu_transfer_host_3d"]
458 [::std::mem::size_of::<virtio_gpu_transfer_host_3d>() - 72usize];
459 ["Alignment of virtio_gpu_transfer_host_3d"]
460 [::std::mem::align_of::<virtio_gpu_transfer_host_3d>() - 8usize];
461 ["Offset of field: virtio_gpu_transfer_host_3d::hdr"]
462 [::std::mem::offset_of!(virtio_gpu_transfer_host_3d, hdr) - 0usize];
463 ["Offset of field: virtio_gpu_transfer_host_3d::box_"]
464 [::std::mem::offset_of!(virtio_gpu_transfer_host_3d, box_) - 24usize];
465 ["Offset of field: virtio_gpu_transfer_host_3d::offset"]
466 [::std::mem::offset_of!(virtio_gpu_transfer_host_3d, offset) - 48usize];
467 ["Offset of field: virtio_gpu_transfer_host_3d::resource_id"]
468 [::std::mem::offset_of!(virtio_gpu_transfer_host_3d, resource_id) - 56usize];
469 ["Offset of field: virtio_gpu_transfer_host_3d::level"]
470 [::std::mem::offset_of!(virtio_gpu_transfer_host_3d, level) - 60usize];
471 ["Offset of field: virtio_gpu_transfer_host_3d::stride"]
472 [::std::mem::offset_of!(virtio_gpu_transfer_host_3d, stride) - 64usize];
473 ["Offset of field: virtio_gpu_transfer_host_3d::layer_stride"]
474 [::std::mem::offset_of!(virtio_gpu_transfer_host_3d, layer_stride) - 68usize];
475};
476#[repr(C)]
477#[derive(Debug, Default, Copy, Clone, PartialEq)]
478pub struct virtio_gpu_resource_create_3d {
479 pub hdr: virtio_gpu_ctrl_hdr,
480 pub resource_id: __le32,
481 pub target: __le32,
482 pub format: __le32,
483 pub bind: __le32,
484 pub width: __le32,
485 pub height: __le32,
486 pub depth: __le32,
487 pub array_size: __le32,
488 pub last_level: __le32,
489 pub nr_samples: __le32,
490 pub flags: __le32,
491 pub padding: __le32,
492}
493#[allow(clippy::unnecessary_operation, clippy::identity_op)]
494const _: () = {
495 ["Size of virtio_gpu_resource_create_3d"]
496 [::std::mem::size_of::<virtio_gpu_resource_create_3d>() - 72usize];
497 ["Alignment of virtio_gpu_resource_create_3d"]
498 [::std::mem::align_of::<virtio_gpu_resource_create_3d>() - 8usize];
499 ["Offset of field: virtio_gpu_resource_create_3d::hdr"]
500 [::std::mem::offset_of!(virtio_gpu_resource_create_3d, hdr) - 0usize];
501 ["Offset of field: virtio_gpu_resource_create_3d::resource_id"]
502 [::std::mem::offset_of!(virtio_gpu_resource_create_3d, resource_id) - 24usize];
503 ["Offset of field: virtio_gpu_resource_create_3d::target"]
504 [::std::mem::offset_of!(virtio_gpu_resource_create_3d, target) - 28usize];
505 ["Offset of field: virtio_gpu_resource_create_3d::format"]
506 [::std::mem::offset_of!(virtio_gpu_resource_create_3d, format) - 32usize];
507 ["Offset of field: virtio_gpu_resource_create_3d::bind"]
508 [::std::mem::offset_of!(virtio_gpu_resource_create_3d, bind) - 36usize];
509 ["Offset of field: virtio_gpu_resource_create_3d::width"]
510 [::std::mem::offset_of!(virtio_gpu_resource_create_3d, width) - 40usize];
511 ["Offset of field: virtio_gpu_resource_create_3d::height"]
512 [::std::mem::offset_of!(virtio_gpu_resource_create_3d, height) - 44usize];
513 ["Offset of field: virtio_gpu_resource_create_3d::depth"]
514 [::std::mem::offset_of!(virtio_gpu_resource_create_3d, depth) - 48usize];
515 ["Offset of field: virtio_gpu_resource_create_3d::array_size"]
516 [::std::mem::offset_of!(virtio_gpu_resource_create_3d, array_size) - 52usize];
517 ["Offset of field: virtio_gpu_resource_create_3d::last_level"]
518 [::std::mem::offset_of!(virtio_gpu_resource_create_3d, last_level) - 56usize];
519 ["Offset of field: virtio_gpu_resource_create_3d::nr_samples"]
520 [::std::mem::offset_of!(virtio_gpu_resource_create_3d, nr_samples) - 60usize];
521 ["Offset of field: virtio_gpu_resource_create_3d::flags"]
522 [::std::mem::offset_of!(virtio_gpu_resource_create_3d, flags) - 64usize];
523 ["Offset of field: virtio_gpu_resource_create_3d::padding"]
524 [::std::mem::offset_of!(virtio_gpu_resource_create_3d, padding) - 68usize];
525};
526#[repr(C)]
527#[derive(Debug, Copy, Clone, PartialEq)]
528pub struct virtio_gpu_ctx_create {
529 pub hdr: virtio_gpu_ctrl_hdr,
530 pub nlen: __le32,
531 pub context_init: __le32,
532 pub debug_name: [::std::os::raw::c_char; 64usize],
533}
534#[allow(clippy::unnecessary_operation, clippy::identity_op)]
535const _: () = {
536 ["Size of virtio_gpu_ctx_create"][::std::mem::size_of::<virtio_gpu_ctx_create>() - 96usize];
537 ["Alignment of virtio_gpu_ctx_create"]
538 [::std::mem::align_of::<virtio_gpu_ctx_create>() - 8usize];
539 ["Offset of field: virtio_gpu_ctx_create::hdr"]
540 [::std::mem::offset_of!(virtio_gpu_ctx_create, hdr) - 0usize];
541 ["Offset of field: virtio_gpu_ctx_create::nlen"]
542 [::std::mem::offset_of!(virtio_gpu_ctx_create, nlen) - 24usize];
543 ["Offset of field: virtio_gpu_ctx_create::context_init"]
544 [::std::mem::offset_of!(virtio_gpu_ctx_create, context_init) - 28usize];
545 ["Offset of field: virtio_gpu_ctx_create::debug_name"]
546 [::std::mem::offset_of!(virtio_gpu_ctx_create, debug_name) - 32usize];
547};
548impl Default for virtio_gpu_ctx_create {
549 fn default() -> Self {
550 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
551 unsafe {
552 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
553 s.assume_init()
554 }
555 }
556}
557#[repr(C)]
558#[derive(Debug, Default, Copy, Clone, PartialEq)]
559pub struct virtio_gpu_ctx_destroy {
560 pub hdr: virtio_gpu_ctrl_hdr,
561}
562#[allow(clippy::unnecessary_operation, clippy::identity_op)]
563const _: () = {
564 ["Size of virtio_gpu_ctx_destroy"][::std::mem::size_of::<virtio_gpu_ctx_destroy>() - 24usize];
565 ["Alignment of virtio_gpu_ctx_destroy"]
566 [::std::mem::align_of::<virtio_gpu_ctx_destroy>() - 8usize];
567 ["Offset of field: virtio_gpu_ctx_destroy::hdr"]
568 [::std::mem::offset_of!(virtio_gpu_ctx_destroy, hdr) - 0usize];
569};
570#[repr(C)]
571#[derive(Debug, Default, Copy, Clone, PartialEq)]
572pub struct virtio_gpu_ctx_resource {
573 pub hdr: virtio_gpu_ctrl_hdr,
574 pub resource_id: __le32,
575 pub padding: __le32,
576}
577#[allow(clippy::unnecessary_operation, clippy::identity_op)]
578const _: () = {
579 ["Size of virtio_gpu_ctx_resource"][::std::mem::size_of::<virtio_gpu_ctx_resource>() - 32usize];
580 ["Alignment of virtio_gpu_ctx_resource"]
581 [::std::mem::align_of::<virtio_gpu_ctx_resource>() - 8usize];
582 ["Offset of field: virtio_gpu_ctx_resource::hdr"]
583 [::std::mem::offset_of!(virtio_gpu_ctx_resource, hdr) - 0usize];
584 ["Offset of field: virtio_gpu_ctx_resource::resource_id"]
585 [::std::mem::offset_of!(virtio_gpu_ctx_resource, resource_id) - 24usize];
586 ["Offset of field: virtio_gpu_ctx_resource::padding"]
587 [::std::mem::offset_of!(virtio_gpu_ctx_resource, padding) - 28usize];
588};
589#[repr(C)]
590#[derive(Debug, Default, Copy, Clone, PartialEq)]
591pub struct virtio_gpu_cmd_submit {
592 pub hdr: virtio_gpu_ctrl_hdr,
593 pub size: __le32,
594 pub padding: __le32,
595}
596#[allow(clippy::unnecessary_operation, clippy::identity_op)]
597const _: () = {
598 ["Size of virtio_gpu_cmd_submit"][::std::mem::size_of::<virtio_gpu_cmd_submit>() - 32usize];
599 ["Alignment of virtio_gpu_cmd_submit"]
600 [::std::mem::align_of::<virtio_gpu_cmd_submit>() - 8usize];
601 ["Offset of field: virtio_gpu_cmd_submit::hdr"]
602 [::std::mem::offset_of!(virtio_gpu_cmd_submit, hdr) - 0usize];
603 ["Offset of field: virtio_gpu_cmd_submit::size"]
604 [::std::mem::offset_of!(virtio_gpu_cmd_submit, size) - 24usize];
605 ["Offset of field: virtio_gpu_cmd_submit::padding"]
606 [::std::mem::offset_of!(virtio_gpu_cmd_submit, padding) - 28usize];
607};
608#[repr(C)]
609#[derive(Debug, Default, Copy, Clone, PartialEq)]
610pub struct virtio_gpu_get_capset_info {
611 pub hdr: virtio_gpu_ctrl_hdr,
612 pub capset_index: __le32,
613 pub padding: __le32,
614}
615#[allow(clippy::unnecessary_operation, clippy::identity_op)]
616const _: () = {
617 ["Size of virtio_gpu_get_capset_info"]
618 [::std::mem::size_of::<virtio_gpu_get_capset_info>() - 32usize];
619 ["Alignment of virtio_gpu_get_capset_info"]
620 [::std::mem::align_of::<virtio_gpu_get_capset_info>() - 8usize];
621 ["Offset of field: virtio_gpu_get_capset_info::hdr"]
622 [::std::mem::offset_of!(virtio_gpu_get_capset_info, hdr) - 0usize];
623 ["Offset of field: virtio_gpu_get_capset_info::capset_index"]
624 [::std::mem::offset_of!(virtio_gpu_get_capset_info, capset_index) - 24usize];
625 ["Offset of field: virtio_gpu_get_capset_info::padding"]
626 [::std::mem::offset_of!(virtio_gpu_get_capset_info, padding) - 28usize];
627};
628#[repr(C)]
629#[derive(Debug, Default, Copy, Clone, PartialEq)]
630pub struct virtio_gpu_resp_capset_info {
631 pub hdr: virtio_gpu_ctrl_hdr,
632 pub capset_id: __le32,
633 pub capset_max_version: __le32,
634 pub capset_max_size: __le32,
635 pub padding: __le32,
636}
637#[allow(clippy::unnecessary_operation, clippy::identity_op)]
638const _: () = {
639 ["Size of virtio_gpu_resp_capset_info"]
640 [::std::mem::size_of::<virtio_gpu_resp_capset_info>() - 40usize];
641 ["Alignment of virtio_gpu_resp_capset_info"]
642 [::std::mem::align_of::<virtio_gpu_resp_capset_info>() - 8usize];
643 ["Offset of field: virtio_gpu_resp_capset_info::hdr"]
644 [::std::mem::offset_of!(virtio_gpu_resp_capset_info, hdr) - 0usize];
645 ["Offset of field: virtio_gpu_resp_capset_info::capset_id"]
646 [::std::mem::offset_of!(virtio_gpu_resp_capset_info, capset_id) - 24usize];
647 ["Offset of field: virtio_gpu_resp_capset_info::capset_max_version"]
648 [::std::mem::offset_of!(virtio_gpu_resp_capset_info, capset_max_version) - 28usize];
649 ["Offset of field: virtio_gpu_resp_capset_info::capset_max_size"]
650 [::std::mem::offset_of!(virtio_gpu_resp_capset_info, capset_max_size) - 32usize];
651 ["Offset of field: virtio_gpu_resp_capset_info::padding"]
652 [::std::mem::offset_of!(virtio_gpu_resp_capset_info, padding) - 36usize];
653};
654#[repr(C)]
655#[derive(Debug, Default, Copy, Clone, PartialEq)]
656pub struct virtio_gpu_get_capset {
657 pub hdr: virtio_gpu_ctrl_hdr,
658 pub capset_id: __le32,
659 pub capset_version: __le32,
660}
661#[allow(clippy::unnecessary_operation, clippy::identity_op)]
662const _: () = {
663 ["Size of virtio_gpu_get_capset"][::std::mem::size_of::<virtio_gpu_get_capset>() - 32usize];
664 ["Alignment of virtio_gpu_get_capset"]
665 [::std::mem::align_of::<virtio_gpu_get_capset>() - 8usize];
666 ["Offset of field: virtio_gpu_get_capset::hdr"]
667 [::std::mem::offset_of!(virtio_gpu_get_capset, hdr) - 0usize];
668 ["Offset of field: virtio_gpu_get_capset::capset_id"]
669 [::std::mem::offset_of!(virtio_gpu_get_capset, capset_id) - 24usize];
670 ["Offset of field: virtio_gpu_get_capset::capset_version"]
671 [::std::mem::offset_of!(virtio_gpu_get_capset, capset_version) - 28usize];
672};
673#[repr(C)]
674#[derive(Debug, Default)]
675pub struct virtio_gpu_resp_capset {
676 pub hdr: virtio_gpu_ctrl_hdr,
677 pub capset_data: __IncompleteArrayField<__u8>,
678}
679#[allow(clippy::unnecessary_operation, clippy::identity_op)]
680const _: () = {
681 ["Size of virtio_gpu_resp_capset"][::std::mem::size_of::<virtio_gpu_resp_capset>() - 24usize];
682 ["Alignment of virtio_gpu_resp_capset"]
683 [::std::mem::align_of::<virtio_gpu_resp_capset>() - 8usize];
684 ["Offset of field: virtio_gpu_resp_capset::hdr"]
685 [::std::mem::offset_of!(virtio_gpu_resp_capset, hdr) - 0usize];
686 ["Offset of field: virtio_gpu_resp_capset::capset_data"]
687 [::std::mem::offset_of!(virtio_gpu_resp_capset, capset_data) - 24usize];
688};
689#[repr(C)]
690#[derive(Debug, Default, Copy, Clone, PartialEq)]
691pub struct virtio_gpu_cmd_get_edid {
692 pub hdr: virtio_gpu_ctrl_hdr,
693 pub scanout: __le32,
694 pub padding: __le32,
695}
696#[allow(clippy::unnecessary_operation, clippy::identity_op)]
697const _: () = {
698 ["Size of virtio_gpu_cmd_get_edid"][::std::mem::size_of::<virtio_gpu_cmd_get_edid>() - 32usize];
699 ["Alignment of virtio_gpu_cmd_get_edid"]
700 [::std::mem::align_of::<virtio_gpu_cmd_get_edid>() - 8usize];
701 ["Offset of field: virtio_gpu_cmd_get_edid::hdr"]
702 [::std::mem::offset_of!(virtio_gpu_cmd_get_edid, hdr) - 0usize];
703 ["Offset of field: virtio_gpu_cmd_get_edid::scanout"]
704 [::std::mem::offset_of!(virtio_gpu_cmd_get_edid, scanout) - 24usize];
705 ["Offset of field: virtio_gpu_cmd_get_edid::padding"]
706 [::std::mem::offset_of!(virtio_gpu_cmd_get_edid, padding) - 28usize];
707};
708#[repr(C)]
709#[derive(Debug, Copy, Clone, PartialEq)]
710pub struct virtio_gpu_resp_edid {
711 pub hdr: virtio_gpu_ctrl_hdr,
712 pub size: __le32,
713 pub padding: __le32,
714 pub edid: [__u8; 1024usize],
715}
716#[allow(clippy::unnecessary_operation, clippy::identity_op)]
717const _: () = {
718 ["Size of virtio_gpu_resp_edid"][::std::mem::size_of::<virtio_gpu_resp_edid>() - 1056usize];
719 ["Alignment of virtio_gpu_resp_edid"][::std::mem::align_of::<virtio_gpu_resp_edid>() - 8usize];
720 ["Offset of field: virtio_gpu_resp_edid::hdr"]
721 [::std::mem::offset_of!(virtio_gpu_resp_edid, hdr) - 0usize];
722 ["Offset of field: virtio_gpu_resp_edid::size"]
723 [::std::mem::offset_of!(virtio_gpu_resp_edid, size) - 24usize];
724 ["Offset of field: virtio_gpu_resp_edid::padding"]
725 [::std::mem::offset_of!(virtio_gpu_resp_edid, padding) - 28usize];
726 ["Offset of field: virtio_gpu_resp_edid::edid"]
727 [::std::mem::offset_of!(virtio_gpu_resp_edid, edid) - 32usize];
728};
729impl Default for virtio_gpu_resp_edid {
730 fn default() -> Self {
731 let mut s = ::std::mem::MaybeUninit::<Self>::uninit();
732 unsafe {
733 ::std::ptr::write_bytes(s.as_mut_ptr(), 0, 1);
734 s.assume_init()
735 }
736 }
737}
738#[repr(C)]
739#[derive(Debug, Default, Copy, Clone, PartialEq)]
740pub struct virtio_gpu_config {
741 pub events_read: __le32,
742 pub events_clear: __le32,
743 pub num_scanouts: __le32,
744 pub num_capsets: __le32,
745}
746#[allow(clippy::unnecessary_operation, clippy::identity_op)]
747const _: () = {
748 ["Size of virtio_gpu_config"][::std::mem::size_of::<virtio_gpu_config>() - 16usize];
749 ["Alignment of virtio_gpu_config"][::std::mem::align_of::<virtio_gpu_config>() - 4usize];
750 ["Offset of field: virtio_gpu_config::events_read"]
751 [::std::mem::offset_of!(virtio_gpu_config, events_read) - 0usize];
752 ["Offset of field: virtio_gpu_config::events_clear"]
753 [::std::mem::offset_of!(virtio_gpu_config, events_clear) - 4usize];
754 ["Offset of field: virtio_gpu_config::num_scanouts"]
755 [::std::mem::offset_of!(virtio_gpu_config, num_scanouts) - 8usize];
756 ["Offset of field: virtio_gpu_config::num_capsets"]
757 [::std::mem::offset_of!(virtio_gpu_config, num_capsets) - 12usize];
758};
759pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_B8G8R8A8_UNORM: virtio_gpu_formats = 1;
760pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_B8G8R8X8_UNORM: virtio_gpu_formats = 2;
761pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_A8R8G8B8_UNORM: virtio_gpu_formats = 3;
762pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_X8R8G8B8_UNORM: virtio_gpu_formats = 4;
763pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_R8G8B8A8_UNORM: virtio_gpu_formats = 67;
764pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_X8B8G8R8_UNORM: virtio_gpu_formats = 68;
765pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_A8B8G8R8_UNORM: virtio_gpu_formats = 121;
766pub const virtio_gpu_formats_VIRTIO_GPU_FORMAT_R8G8B8X8_UNORM: virtio_gpu_formats = 134;
767pub type virtio_gpu_formats = ::std::os::raw::c_uint;
768#[repr(C)]
769#[derive(Debug, Default, Copy, Clone, PartialEq)]
770pub struct virtio_gpu_resource_assign_uuid {
771 pub hdr: virtio_gpu_ctrl_hdr,
772 pub resource_id: __le32,
773 pub padding: __le32,
774}
775#[allow(clippy::unnecessary_operation, clippy::identity_op)]
776const _: () = {
777 ["Size of virtio_gpu_resource_assign_uuid"]
778 [::std::mem::size_of::<virtio_gpu_resource_assign_uuid>() - 32usize];
779 ["Alignment of virtio_gpu_resource_assign_uuid"]
780 [::std::mem::align_of::<virtio_gpu_resource_assign_uuid>() - 8usize];
781 ["Offset of field: virtio_gpu_resource_assign_uuid::hdr"]
782 [::std::mem::offset_of!(virtio_gpu_resource_assign_uuid, hdr) - 0usize];
783 ["Offset of field: virtio_gpu_resource_assign_uuid::resource_id"]
784 [::std::mem::offset_of!(virtio_gpu_resource_assign_uuid, resource_id) - 24usize];
785 ["Offset of field: virtio_gpu_resource_assign_uuid::padding"]
786 [::std::mem::offset_of!(virtio_gpu_resource_assign_uuid, padding) - 28usize];
787};
788#[repr(C)]
789#[derive(Debug, Default, Copy, Clone, PartialEq)]
790pub struct virtio_gpu_resp_resource_uuid {
791 pub hdr: virtio_gpu_ctrl_hdr,
792 pub uuid: [__u8; 16usize],
793}
794#[allow(clippy::unnecessary_operation, clippy::identity_op)]
795const _: () = {
796 ["Size of virtio_gpu_resp_resource_uuid"]
797 [::std::mem::size_of::<virtio_gpu_resp_resource_uuid>() - 40usize];
798 ["Alignment of virtio_gpu_resp_resource_uuid"]
799 [::std::mem::align_of::<virtio_gpu_resp_resource_uuid>() - 8usize];
800 ["Offset of field: virtio_gpu_resp_resource_uuid::hdr"]
801 [::std::mem::offset_of!(virtio_gpu_resp_resource_uuid, hdr) - 0usize];
802 ["Offset of field: virtio_gpu_resp_resource_uuid::uuid"]
803 [::std::mem::offset_of!(virtio_gpu_resp_resource_uuid, uuid) - 24usize];
804};
805#[repr(C)]
806#[derive(Debug, Default, Copy, Clone, PartialEq)]
807pub struct virtio_gpu_resource_create_blob {
808 pub hdr: virtio_gpu_ctrl_hdr,
809 pub resource_id: __le32,
810 pub blob_mem: __le32,
811 pub blob_flags: __le32,
812 pub nr_entries: __le32,
813 pub blob_id: __le64,
814 pub size: __le64,
815}
816#[allow(clippy::unnecessary_operation, clippy::identity_op)]
817const _: () = {
818 ["Size of virtio_gpu_resource_create_blob"]
819 [::std::mem::size_of::<virtio_gpu_resource_create_blob>() - 56usize];
820 ["Alignment of virtio_gpu_resource_create_blob"]
821 [::std::mem::align_of::<virtio_gpu_resource_create_blob>() - 8usize];
822 ["Offset of field: virtio_gpu_resource_create_blob::hdr"]
823 [::std::mem::offset_of!(virtio_gpu_resource_create_blob, hdr) - 0usize];
824 ["Offset of field: virtio_gpu_resource_create_blob::resource_id"]
825 [::std::mem::offset_of!(virtio_gpu_resource_create_blob, resource_id) - 24usize];
826 ["Offset of field: virtio_gpu_resource_create_blob::blob_mem"]
827 [::std::mem::offset_of!(virtio_gpu_resource_create_blob, blob_mem) - 28usize];
828 ["Offset of field: virtio_gpu_resource_create_blob::blob_flags"]
829 [::std::mem::offset_of!(virtio_gpu_resource_create_blob, blob_flags) - 32usize];
830 ["Offset of field: virtio_gpu_resource_create_blob::nr_entries"]
831 [::std::mem::offset_of!(virtio_gpu_resource_create_blob, nr_entries) - 36usize];
832 ["Offset of field: virtio_gpu_resource_create_blob::blob_id"]
833 [::std::mem::offset_of!(virtio_gpu_resource_create_blob, blob_id) - 40usize];
834 ["Offset of field: virtio_gpu_resource_create_blob::size"]
835 [::std::mem::offset_of!(virtio_gpu_resource_create_blob, size) - 48usize];
836};
837#[repr(C)]
838#[derive(Debug, Default, Copy, Clone, PartialEq)]
839pub struct virtio_gpu_set_scanout_blob {
840 pub hdr: virtio_gpu_ctrl_hdr,
841 pub r: virtio_gpu_rect,
842 pub scanout_id: __le32,
843 pub resource_id: __le32,
844 pub width: __le32,
845 pub height: __le32,
846 pub format: __le32,
847 pub padding: __le32,
848 pub strides: [__le32; 4usize],
849 pub offsets: [__le32; 4usize],
850}
851#[allow(clippy::unnecessary_operation, clippy::identity_op)]
852const _: () = {
853 ["Size of virtio_gpu_set_scanout_blob"]
854 [::std::mem::size_of::<virtio_gpu_set_scanout_blob>() - 96usize];
855 ["Alignment of virtio_gpu_set_scanout_blob"]
856 [::std::mem::align_of::<virtio_gpu_set_scanout_blob>() - 8usize];
857 ["Offset of field: virtio_gpu_set_scanout_blob::hdr"]
858 [::std::mem::offset_of!(virtio_gpu_set_scanout_blob, hdr) - 0usize];
859 ["Offset of field: virtio_gpu_set_scanout_blob::r"]
860 [::std::mem::offset_of!(virtio_gpu_set_scanout_blob, r) - 24usize];
861 ["Offset of field: virtio_gpu_set_scanout_blob::scanout_id"]
862 [::std::mem::offset_of!(virtio_gpu_set_scanout_blob, scanout_id) - 40usize];
863 ["Offset of field: virtio_gpu_set_scanout_blob::resource_id"]
864 [::std::mem::offset_of!(virtio_gpu_set_scanout_blob, resource_id) - 44usize];
865 ["Offset of field: virtio_gpu_set_scanout_blob::width"]
866 [::std::mem::offset_of!(virtio_gpu_set_scanout_blob, width) - 48usize];
867 ["Offset of field: virtio_gpu_set_scanout_blob::height"]
868 [::std::mem::offset_of!(virtio_gpu_set_scanout_blob, height) - 52usize];
869 ["Offset of field: virtio_gpu_set_scanout_blob::format"]
870 [::std::mem::offset_of!(virtio_gpu_set_scanout_blob, format) - 56usize];
871 ["Offset of field: virtio_gpu_set_scanout_blob::padding"]
872 [::std::mem::offset_of!(virtio_gpu_set_scanout_blob, padding) - 60usize];
873 ["Offset of field: virtio_gpu_set_scanout_blob::strides"]
874 [::std::mem::offset_of!(virtio_gpu_set_scanout_blob, strides) - 64usize];
875 ["Offset of field: virtio_gpu_set_scanout_blob::offsets"]
876 [::std::mem::offset_of!(virtio_gpu_set_scanout_blob, offsets) - 80usize];
877};
878#[repr(C)]
879#[derive(Debug, Default, Copy, Clone, PartialEq)]
880pub struct virtio_gpu_resource_map_blob {
881 pub hdr: virtio_gpu_ctrl_hdr,
882 pub resource_id: __le32,
883 pub padding: __le32,
884 pub offset: __le64,
885}
886#[allow(clippy::unnecessary_operation, clippy::identity_op)]
887const _: () = {
888 ["Size of virtio_gpu_resource_map_blob"]
889 [::std::mem::size_of::<virtio_gpu_resource_map_blob>() - 40usize];
890 ["Alignment of virtio_gpu_resource_map_blob"]
891 [::std::mem::align_of::<virtio_gpu_resource_map_blob>() - 8usize];
892 ["Offset of field: virtio_gpu_resource_map_blob::hdr"]
893 [::std::mem::offset_of!(virtio_gpu_resource_map_blob, hdr) - 0usize];
894 ["Offset of field: virtio_gpu_resource_map_blob::resource_id"]
895 [::std::mem::offset_of!(virtio_gpu_resource_map_blob, resource_id) - 24usize];
896 ["Offset of field: virtio_gpu_resource_map_blob::padding"]
897 [::std::mem::offset_of!(virtio_gpu_resource_map_blob, padding) - 28usize];
898 ["Offset of field: virtio_gpu_resource_map_blob::offset"]
899 [::std::mem::offset_of!(virtio_gpu_resource_map_blob, offset) - 32usize];
900};
901#[repr(C)]
902#[derive(Debug, Default, Copy, Clone, PartialEq)]
903pub struct virtio_gpu_resp_map_info {
904 pub hdr: virtio_gpu_ctrl_hdr,
905 pub map_info: __u32,
906 pub padding: __u32,
907}
908#[allow(clippy::unnecessary_operation, clippy::identity_op)]
909const _: () = {
910 ["Size of virtio_gpu_resp_map_info"]
911 [::std::mem::size_of::<virtio_gpu_resp_map_info>() - 32usize];
912 ["Alignment of virtio_gpu_resp_map_info"]
913 [::std::mem::align_of::<virtio_gpu_resp_map_info>() - 8usize];
914 ["Offset of field: virtio_gpu_resp_map_info::hdr"]
915 [::std::mem::offset_of!(virtio_gpu_resp_map_info, hdr) - 0usize];
916 ["Offset of field: virtio_gpu_resp_map_info::map_info"]
917 [::std::mem::offset_of!(virtio_gpu_resp_map_info, map_info) - 24usize];
918 ["Offset of field: virtio_gpu_resp_map_info::padding"]
919 [::std::mem::offset_of!(virtio_gpu_resp_map_info, padding) - 28usize];
920};
921#[repr(C)]
922#[derive(Debug, Default, Copy, Clone, PartialEq)]
923pub struct virtio_gpu_resource_unmap_blob {
924 pub hdr: virtio_gpu_ctrl_hdr,
925 pub resource_id: __le32,
926 pub padding: __le32,
927}
928#[allow(clippy::unnecessary_operation, clippy::identity_op)]
929const _: () = {
930 ["Size of virtio_gpu_resource_unmap_blob"]
931 [::std::mem::size_of::<virtio_gpu_resource_unmap_blob>() - 32usize];
932 ["Alignment of virtio_gpu_resource_unmap_blob"]
933 [::std::mem::align_of::<virtio_gpu_resource_unmap_blob>() - 8usize];
934 ["Offset of field: virtio_gpu_resource_unmap_blob::hdr"]
935 [::std::mem::offset_of!(virtio_gpu_resource_unmap_blob, hdr) - 0usize];
936 ["Offset of field: virtio_gpu_resource_unmap_blob::resource_id"]
937 [::std::mem::offset_of!(virtio_gpu_resource_unmap_blob, resource_id) - 24usize];
938 ["Offset of field: virtio_gpu_resource_unmap_blob::padding"]
939 [::std::mem::offset_of!(virtio_gpu_resource_unmap_blob, padding) - 28usize];
940};