1 | /* $Id: DevQemuFwCfg.cpp 106061 2024-09-16 14:03:52Z vboxsync $ */
|
---|
2 | /** @file
|
---|
3 | * DevQemuFwCfg - QEMU firmware configuration compatible device.
|
---|
4 | */
|
---|
5 |
|
---|
6 | /*
|
---|
7 | * Copyright (C) 2020-2024 Oracle and/or its affiliates.
|
---|
8 | *
|
---|
9 | * This file is part of VirtualBox base platform packages, as
|
---|
10 | * available from https://www.virtualbox.org.
|
---|
11 | *
|
---|
12 | * This program is free software; you can redistribute it and/or
|
---|
13 | * modify it under the terms of the GNU General Public License
|
---|
14 | * as published by the Free Software Foundation, in version 3 of the
|
---|
15 | * License.
|
---|
16 | *
|
---|
17 | * This program is distributed in the hope that it will be useful, but
|
---|
18 | * WITHOUT ANY WARRANTY; without even the implied warranty of
|
---|
19 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
---|
20 | * General Public License for more details.
|
---|
21 | *
|
---|
22 | * You should have received a copy of the GNU General Public License
|
---|
23 | * along with this program; if not, see <https://www.gnu.org/licenses>.
|
---|
24 | *
|
---|
25 | * SPDX-License-Identifier: GPL-3.0-only
|
---|
26 | */
|
---|
27 |
|
---|
28 | /** @page pg_qemufwcfg The QEMU firmware configuration Device.
|
---|
29 | *
|
---|
30 | * The QEMU firmware configuration device is a custom device emulation
|
---|
31 | * to convey information about the VM to the guests firmware (UEFI for example).
|
---|
32 | * In the case of VirtualBox it is used to directly load a compatible kernel
|
---|
33 | * and initrd image like Linux from the host into the guest and boot it. This allows
|
---|
34 | * efficiently testing/debugging of multiple Linux kernels without having to install
|
---|
35 | * a guest OS. On VirtualBox the EFI firmware supports this interface, the BIOS is
|
---|
36 | * currently unsupported (and probably never will be).
|
---|
37 | *
|
---|
38 | * @section sec_qemufwcfg_config Configuration
|
---|
39 | *
|
---|
40 | * To use this interface for a particular VM the following extra data needs to be
|
---|
41 | * set besides enabling the EFI firmware:
|
---|
42 | *
|
---|
43 | * VBoxManage setextradata <VM name> "VBoxInternal/Devices/qemu-fw-cfg/0/Config/KernelImage" /path/to/kernel
|
---|
44 | * VBoxManage setextradata <VM name> "VBoxInternal/Devices/qemu-fw-cfg/0/Config/InitrdImage" /path/to/initrd
|
---|
45 | * VBoxManage setextradata <VM name> "VBoxInternal/Devices/qemu-fw-cfg/0/Config/CmdLine" "<cmd line string>"
|
---|
46 | *
|
---|
47 | * The only mandatory item is the KernelImage one, the others are optional if the
|
---|
48 | * kernel is configured to not require it. The InitrdImage item accepts a path to a directory as well.
|
---|
49 | * If a directory is encountered, the CPIO initrd image is created on the fly and passed to the guest.
|
---|
50 | * If the kernel is not an EFI compatible executable (CONFIG_EFI_STUB=y for Linux) a dedicated setup image might be required
|
---|
51 | * which can be set with:
|
---|
52 | *
|
---|
53 | * VBoxManage setextradata <VM name> "VBoxInternal/Devices/qemu-fw-cfg/0/Config/SetupImage" /path/to/setup_image
|
---|
54 | *
|
---|
55 | * @section sec_qemufwcfg_dma DMA
|
---|
56 | *
|
---|
57 | * The QEMU firmware configuration device supports an optional DMA interface to speed up transferring the data into the guest.
|
---|
58 | * It currently is not enabled by default but needs to be enabled with:
|
---|
59 | *
|
---|
60 | * VBoxManage setextradata <VM name> "VBoxInternal/Devices/qemu-fw-cfg/0/Config/DmaEnabled" 1
|
---|
61 | */
|
---|
62 |
|
---|
63 |
|
---|
64 | /*********************************************************************************************************************************
|
---|
65 | * Header Files *
|
---|
66 | *********************************************************************************************************************************/
|
---|
67 | #define LOG_GROUP LOG_GROUP_DEV_QEMUFWCFG
|
---|
68 | #include <VBox/vmm/pdmdev.h>
|
---|
69 | #include <VBox/vmm/mm.h>
|
---|
70 | #include <VBox/vmm/pgm.h>
|
---|
71 | #include <VBox/log.h>
|
---|
72 | #include <iprt/errcore.h>
|
---|
73 | #include <iprt/assert.h>
|
---|
74 | #include <iprt/dir.h>
|
---|
75 | #include <iprt/file.h>
|
---|
76 | #include <iprt/mem.h>
|
---|
77 | #include <iprt/path.h>
|
---|
78 | #include <iprt/string.h>
|
---|
79 | #include <iprt/vfs.h>
|
---|
80 | #include <iprt/zero.h>
|
---|
81 | #include <iprt/zip.h>
|
---|
82 | #include <iprt/uuid.h>
|
---|
83 |
|
---|
84 | #include "VBoxDD.h"
|
---|
85 |
|
---|
86 |
|
---|
87 | /*********************************************************************************************************************************
|
---|
88 | * Defined Constants And Macros *
|
---|
89 | *********************************************************************************************************************************/
|
---|
90 |
|
---|
91 | /** Start of the I/O port region. */
|
---|
92 | #define QEMU_FW_CFG_IO_PORT_START 0x510
|
---|
93 | /** Number of I/O ports reserved for this device. */
|
---|
94 | #define QEMU_FW_CFG_IO_PORT_SIZE 12
|
---|
95 | /** Offset of the config item selector register from the start. */
|
---|
96 | #define QEMU_FW_CFG_OFF_SELECTOR 0
|
---|
97 | /** Offset of the data port from the start. */
|
---|
98 | #define QEMU_FW_CFG_OFF_DATA 1
|
---|
99 | /** Offset of the high 32bit of the DMA address. */
|
---|
100 | #define QEMU_FW_CFG_OFF_DMA_HIGH 4
|
---|
101 | /** Offset of the low 32bit of the DMA address. */
|
---|
102 | #define QEMU_FW_CFG_OFF_DMA_LOW 8
|
---|
103 |
|
---|
104 |
|
---|
105 | /** @name MMIO register offsets.
|
---|
106 | * @{ */
|
---|
107 | /** Data register offset. */
|
---|
108 | #define QEU_FW_CFG_MMIO_OFF_DATA 0
|
---|
109 | /** Selector register offset. */
|
---|
110 | #define QEU_FW_CFG_MMIO_OFF_SELECTOR 8
|
---|
111 | /** DMA base address register offset. */
|
---|
112 | #define QEU_FW_CFG_MMIO_OFF_DMA 16
|
---|
113 | /** @} */
|
---|
114 |
|
---|
115 |
|
---|
116 | /** Set if legacy interface is supported (always set).*/
|
---|
117 | #define QEMU_FW_CFG_VERSION_LEGACY RT_BIT_32(0)
|
---|
118 | /** Set if DMA is supported.*/
|
---|
119 | #define QEMU_FW_CFG_VERSION_DMA RT_BIT_32(1)
|
---|
120 |
|
---|
121 |
|
---|
122 | /** Error happened during the DMA access. */
|
---|
123 | #define QEMU_FW_CFG_DMA_ERROR RT_BIT_32(0)
|
---|
124 | /** Read requested. */
|
---|
125 | #define QEMU_FW_CFG_DMA_READ RT_BIT_32(1)
|
---|
126 | /** Skipping bytes requested. */
|
---|
127 | #define QEMU_FW_CFG_DMA_SKIP RT_BIT_32(2)
|
---|
128 | /** The config item is selected. */
|
---|
129 | #define QEMU_FW_CFG_DMA_SELECT RT_BIT_32(3)
|
---|
130 | /** Write requested. */
|
---|
131 | #define QEMU_FW_CFG_DMA_WRITE RT_BIT_32(4)
|
---|
132 | /** Extracts the selected config item. */
|
---|
133 | #define QEMU_FW_CFG_DMA_GET_CFG_ITEM(a_Control) ((uint16_t)((a_Control) >> 16))
|
---|
134 |
|
---|
135 | /** The signature when reading the DMA address register and the DMA interace is enabled. */
|
---|
136 | #define QEMU_FW_CFG_DMA_ADDR_SIGNATURE UINT64_C(0x51454d5520434647) /* "QEMU CFG" */
|
---|
137 |
|
---|
138 | /** @name Known config items.
|
---|
139 | * @{ */
|
---|
140 | #define QEMU_FW_CFG_ITEM_SIGNATURE UINT16_C(0x0000)
|
---|
141 | #define QEMU_FW_CFG_ITEM_VERSION UINT16_C(0x0001)
|
---|
142 | #define QEMU_FW_CFG_ITEM_SYSTEM_UUID UINT16_C(0x0002)
|
---|
143 | #define QEMU_FW_CFG_ITEM_RAM_SIZE UINT16_C(0x0003)
|
---|
144 | #define QEMU_FW_CFG_ITEM_GRAPHICS_ENABLED UINT16_C(0x0004)
|
---|
145 | #define QEMU_FW_CFG_ITEM_SMP_CPU_COUNT UINT16_C(0x0005)
|
---|
146 | #define QEMU_FW_CFG_ITEM_MACHINE_ID UINT16_C(0x0006)
|
---|
147 | #define QEMU_FW_CFG_ITEM_KERNEL_ADDRESS UINT16_C(0x0007)
|
---|
148 | #define QEMU_FW_CFG_ITEM_KERNEL_SIZE UINT16_C(0x0008)
|
---|
149 | #define QEMU_FW_CFG_ITEM_KERNEL_CMD_LINE UINT16_C(0x0009)
|
---|
150 | #define QEMU_FW_CFG_ITEM_INITRD_ADDRESS UINT16_C(0x000a)
|
---|
151 | #define QEMU_FW_CFG_ITEM_INITRD_SIZE UINT16_C(0x000b)
|
---|
152 | #define QEMU_FW_CFG_ITEM_BOOT_DEVICE UINT16_C(0x000c)
|
---|
153 | #define QEMU_FW_CFG_ITEM_NUMA_DATA UINT16_C(0x000d)
|
---|
154 | #define QEMU_FW_CFG_ITEM_BOOT_MENU UINT16_C(0x000e)
|
---|
155 | #define QEMU_FW_CFG_ITEM_MAX_CPU_COUNT UINT16_C(0x000f)
|
---|
156 | #define QEMU_FW_CFG_ITEM_KERNEL_ENTRY UINT16_C(0x0010)
|
---|
157 | #define QEMU_FW_CFG_ITEM_KERNEL_DATA UINT16_C(0x0011)
|
---|
158 | #define QEMU_FW_CFG_ITEM_INITRD_DATA UINT16_C(0x0012)
|
---|
159 | #define QEMU_FW_CFG_ITEM_CMD_LINE_ADDRESS UINT16_C(0x0013)
|
---|
160 | #define QEMU_FW_CFG_ITEM_CMD_LINE_SIZE UINT16_C(0x0014)
|
---|
161 | #define QEMU_FW_CFG_ITEM_CMD_LINE_DATA UINT16_C(0x0015)
|
---|
162 | #define QEMU_FW_CFG_ITEM_KERNEL_SETUP_ADDRESS UINT16_C(0x0016)
|
---|
163 | #define QEMU_FW_CFG_ITEM_KERNEL_SETUP_SIZE UINT16_C(0x0017)
|
---|
164 | #define QEMU_FW_CFG_ITEM_KERNEL_SETUP_DATA UINT16_C(0x0018)
|
---|
165 | #define QEMU_FW_CFG_ITEM_FILE_DIR UINT16_C(0x0019)
|
---|
166 |
|
---|
167 | /** The first index for custom file based data. */
|
---|
168 | #define QEMU_FW_CFG_ITEM_FILE_USER_FIRST UINT16_C(0x0020)
|
---|
169 | /** @} */
|
---|
170 |
|
---|
171 | /** Maximum number of characters for a config item filename (without the zero terminator. */
|
---|
172 | #define QEMU_FW_CFG_ITEM_FILE_NAME_MAX 55
|
---|
173 |
|
---|
174 | /** The size of the directory entry buffer we're using. */
|
---|
175 | #define QEMUFWCFG_DIRENTRY_BUF_SIZE (sizeof(RTDIRENTRYEX) + RTPATH_MAX)
|
---|
176 |
|
---|
177 |
|
---|
178 | /*********************************************************************************************************************************
|
---|
179 | * Structures and Typedefs *
|
---|
180 | *********************************************************************************************************************************/
|
---|
181 |
|
---|
182 | /**
|
---|
183 | * RAM based framebuffer config.
|
---|
184 | */
|
---|
185 | #pragma pack(1)
|
---|
186 | typedef struct QEMURAMFBCONFIG
|
---|
187 | {
|
---|
188 | /** Base physical address of the framebuffer. */
|
---|
189 | uint64_t GCPhysRamfbBase;
|
---|
190 | /** The FourCC code for the image format. */
|
---|
191 | uint32_t u32FourCC;
|
---|
192 | /** Flags for the framebuffer. */
|
---|
193 | uint32_t u32Flags;
|
---|
194 | /** Width of the framebuffer in pixels. */
|
---|
195 | uint32_t cWidth;
|
---|
196 | /** Height of the framebuffer in pixels. */
|
---|
197 | uint32_t cHeight;
|
---|
198 | /** Stride of the framebuffer in bytes. */
|
---|
199 | uint32_t cbStride;
|
---|
200 | } QEMURAMFBCONFIG;
|
---|
201 | #pragma pack()
|
---|
202 | AssertCompileSize(QEMURAMFBCONFIG, 28);
|
---|
203 | /** Pointer to a RAM based framebuffer config. */
|
---|
204 | typedef QEMURAMFBCONFIG *PQEMURAMFBCONFIG;
|
---|
205 | /** Pointer to a const RAM based framebuffer config. */
|
---|
206 | typedef const QEMURAMFBCONFIG *PCQEMURAMFBCONFIG;
|
---|
207 |
|
---|
208 | /** The FourCC format code for RGB (+ ignored byte). */
|
---|
209 | #define QEMU_RAMFB_CFG_FORMAT 0x34325258 /* XRGB8888 */
|
---|
210 | /** Number of bytes per pixel. */
|
---|
211 | #define QEMU_RAMFB_CFG_BPP 4
|
---|
212 |
|
---|
213 |
|
---|
214 | /**
|
---|
215 | * QEMU firmware config DMA descriptor.
|
---|
216 | */
|
---|
217 | typedef struct QEMUFWDMADESC
|
---|
218 | {
|
---|
219 | /** Control field. */
|
---|
220 | uint32_t u32Ctrl;
|
---|
221 | /** Length of the transfer in bytes. */
|
---|
222 | uint32_t u32Length;
|
---|
223 | /** Address of the buffer to transfer from/to. */
|
---|
224 | uint64_t u64GCPhysBuf;
|
---|
225 | } QEMUFWDMADESC;
|
---|
226 | AssertCompileSize(QEMUFWDMADESC, 2 * 4 + 8);
|
---|
227 | /** Pointer to a QEMU firmware config DMA descriptor. */
|
---|
228 | typedef QEMUFWDMADESC *PQEMUFWDMADESC;
|
---|
229 | /** Pointer to a const QEMU firmware config DMA descriptor. */
|
---|
230 | typedef const QEMUFWDMADESC *PCQEMUFWDMADESC;
|
---|
231 |
|
---|
232 |
|
---|
233 | /**
|
---|
234 | * QEMU firmware config file.
|
---|
235 | */
|
---|
236 | typedef struct QEMUFWCFGFILE
|
---|
237 | {
|
---|
238 | /** Size of the file in bytes. */
|
---|
239 | uint32_t cbFile;
|
---|
240 | /** The config selector item. */
|
---|
241 | uint16_t uCfgItem;
|
---|
242 | /** Reserved. */
|
---|
243 | uint16_t u16Rsvd;
|
---|
244 | /** The filename as an zero terminated ASCII string. */
|
---|
245 | char szFilename[QEMU_FW_CFG_ITEM_FILE_NAME_MAX + 1];
|
---|
246 | } QEMUFWCFGFILE;
|
---|
247 | AssertCompileSize(QEMUFWCFGFILE, 64);
|
---|
248 | /** Pointer to a QEMU firmware config file. */
|
---|
249 | typedef QEMUFWCFGFILE *PQEMUFWCFGFILE;
|
---|
250 | /** Pointer to a const QEMU firmware config file. */
|
---|
251 | typedef const QEMUFWCFGFILE *PCQEMUFWCFGFILE;
|
---|
252 |
|
---|
253 |
|
---|
254 | /** Pointer to the QEMU firmware config device instance. */
|
---|
255 | typedef struct DEVQEMUFWCFG *PDEVQEMUFWCFG;
|
---|
256 | /** Pointer to a const configuration item descriptor. */
|
---|
257 | typedef const struct QEMUFWCFGITEM *PCQEMUFWCFGITEM;
|
---|
258 |
|
---|
259 |
|
---|
260 | /**
|
---|
261 | * Setup callback for when the guest writes the selector.
|
---|
262 | *
|
---|
263 | * @returns VBox status code.
|
---|
264 | * @param pThis The QEMU fw config device instance.
|
---|
265 | * @param pItem Pointer to the selected item.
|
---|
266 | * @param pcbItem Where to store the size of the item on success.
|
---|
267 | */
|
---|
268 | typedef DECLCALLBACKTYPE(int, FNQEMUFWCFGITEMSETUP,(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t *pcbItem));
|
---|
269 | /** Pointer to a FNQEMUFWCFGITEMSETUP() function. */
|
---|
270 | typedef FNQEMUFWCFGITEMSETUP *PFNQEMUFWCFGITEMSETUP;
|
---|
271 |
|
---|
272 |
|
---|
273 | /**
|
---|
274 | * Read callback to return the data.
|
---|
275 | *
|
---|
276 | * @returns VBox status code.
|
---|
277 | * @param pThis The QEMU fw config device instance.
|
---|
278 | * @param pItem Pointer to the selected item.
|
---|
279 | * @param off Where to start reading from.
|
---|
280 | * @param pvBuf Where to store the read data.
|
---|
281 | * @param cbToRead How much to read.
|
---|
282 | * @param pcbRead Where to store the amount of bytes read.
|
---|
283 | */
|
---|
284 | typedef DECLCALLBACKTYPE(int, FNQEMUFWCFGITEMREAD,(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t off, void *pvBuf,
|
---|
285 | uint32_t cbToRead, uint32_t *pcbRead));
|
---|
286 | /** Pointer to a FNQEMUFWCFGITEMREAD() function. */
|
---|
287 | typedef FNQEMUFWCFGITEMREAD *PFNQEMUFWCFGITEMREAD;
|
---|
288 |
|
---|
289 |
|
---|
290 | /**
|
---|
291 | * Write callback to receive data.
|
---|
292 | *
|
---|
293 | * @returns VBox status code.
|
---|
294 | * @param pThis The QEMU fw config device instance.
|
---|
295 | * @param pItem Pointer to the selected item.
|
---|
296 | * @param off Where to start writing to.
|
---|
297 | * @param pvBuf The data to write.
|
---|
298 | * @param cbToWrite How much to write.
|
---|
299 | * @param pcbWritten Where to store the amount of bytes written.
|
---|
300 | */
|
---|
301 | typedef DECLCALLBACKTYPE(int, FNQEMUFWCFGITEMWRITE,(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t off, const void *pvBuf,
|
---|
302 | uint32_t cbToWrite, uint32_t *pcbWritten));
|
---|
303 | /** Pointer to a FNQEMUFWCFGITEMWRITE() function. */
|
---|
304 | typedef FNQEMUFWCFGITEMWRITE *PFNQEMUFWCFGITEMWRITE;
|
---|
305 |
|
---|
306 |
|
---|
307 | /**
|
---|
308 | * Cleans up any allocated resources when the item is de-selected.
|
---|
309 | *
|
---|
310 | * @param pThis The QEMU fw config device instance.
|
---|
311 | * @param pItem Pointer to the selected item.
|
---|
312 | */
|
---|
313 | typedef DECLCALLBACKTYPE(void, FNQEMUFWCFGITEMCLEANUP,(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem));
|
---|
314 | /** Pointer to a FNQEMUFWCFGITEMCLEANUP() function. */
|
---|
315 | typedef FNQEMUFWCFGITEMCLEANUP *PFNQEMUFWCFGITEMCLEANUP;
|
---|
316 |
|
---|
317 |
|
---|
318 | /**
|
---|
319 | * A supported configuration item descriptor.
|
---|
320 | */
|
---|
321 | typedef struct QEMUFWCFGITEM
|
---|
322 | {
|
---|
323 | /** The config item value. */
|
---|
324 | uint16_t uCfgItem;
|
---|
325 | /** Name of the item. */
|
---|
326 | const char *pszItem;
|
---|
327 | /** Optional CFGM key to lookup the content. */
|
---|
328 | const char *pszCfgmKey;
|
---|
329 |
|
---|
330 | /** Setup callback. */
|
---|
331 | PFNQEMUFWCFGITEMSETUP pfnSetup;
|
---|
332 | /** Read callback. */
|
---|
333 | PFNQEMUFWCFGITEMREAD pfnRead;
|
---|
334 | /** Write callback. */
|
---|
335 | PFNQEMUFWCFGITEMWRITE pfnWrite;
|
---|
336 | /** Cleanup callback. */
|
---|
337 | PFNQEMUFWCFGITEMCLEANUP pfnCleanup;
|
---|
338 | } QEMUFWCFGITEM;
|
---|
339 | /** Pointer to a configuration item descriptor. */
|
---|
340 | typedef QEMUFWCFGITEM *PQEMUFWCFGITEM;
|
---|
341 |
|
---|
342 |
|
---|
343 | /**
|
---|
344 | * A config file entry.
|
---|
345 | */
|
---|
346 | typedef struct QEMUFWCFGFILEENTRY
|
---|
347 | {
|
---|
348 | /** The config item structure. */
|
---|
349 | QEMUFWCFGITEM Cfg;
|
---|
350 | /** Size of the file in bytes. */
|
---|
351 | uint32_t cbFile;
|
---|
352 | /** The stored filename as an zero terminated ASCII string. */
|
---|
353 | char szFilename[QEMU_FW_CFG_ITEM_FILE_NAME_MAX + 1];
|
---|
354 | } QEMUFWCFGFILEENTRY;
|
---|
355 | /** Pointer to a config file entry. */
|
---|
356 | typedef QEMUFWCFGFILEENTRY *PQEMUFWCFGFILEENTRY;
|
---|
357 | /** Pointer to a const config file entry. */
|
---|
358 | typedef const QEMUFWCFGFILEENTRY *PCQEMUFWCFGFILEENTRY;
|
---|
359 |
|
---|
360 |
|
---|
361 | /**
|
---|
362 | * QEMU firmware config instance data structure.
|
---|
363 | */
|
---|
364 | typedef struct DEVQEMUFWCFG
|
---|
365 | {
|
---|
366 | /** Pointer back to the device instance. */
|
---|
367 | PPDMDEVINS pDevIns;
|
---|
368 | /** The configuration handle. */
|
---|
369 | PCFGMNODE pCfg;
|
---|
370 |
|
---|
371 | /** LUN\#0: The display port base interface. */
|
---|
372 | PDMIBASE IBase;
|
---|
373 | /** LUN\#0: The display port interface for the RAM based framebuffer if enabled. */
|
---|
374 | PDMIDISPLAYPORT IPortRamfb;
|
---|
375 |
|
---|
376 | /** Pointer to base interface of the driver - LUN#0. */
|
---|
377 | R3PTRTYPE(PPDMIBASE) pDrvBaseL0;
|
---|
378 | /** Pointer to display connector interface of the driver - LUN#0. */
|
---|
379 | R3PTRTYPE(PPDMIDISPLAYCONNECTOR) pDrvL0;
|
---|
380 |
|
---|
381 | /** Pointer to the currently selected item. */
|
---|
382 | PCQEMUFWCFGITEM pCfgItem;
|
---|
383 | /** Offset of the next byte to read from the start of the data item. */
|
---|
384 | uint32_t offCfgItemNext;
|
---|
385 | /** How many bytes are left for transfer. */
|
---|
386 | uint32_t cbCfgItemLeft;
|
---|
387 | /** Version register. */
|
---|
388 | uint32_t u32Version;
|
---|
389 | /** Guest physical address of the DMA descriptor. */
|
---|
390 | RTGCPHYS GCPhysDma;
|
---|
391 | /** VFS file of the on-the-fly created initramfs. */
|
---|
392 | RTVFSFILE hVfsFileInitrd;
|
---|
393 |
|
---|
394 | /** Pointer to the array of config file items. */
|
---|
395 | PQEMUFWCFGFILEENTRY paCfgFiles;
|
---|
396 | /** Number of entries in the config file item array. */
|
---|
397 | uint32_t cCfgFiles;
|
---|
398 | /** Number if entries allocated in the config file items array. */
|
---|
399 | uint32_t cCfgFilesMax;
|
---|
400 |
|
---|
401 | /** Critical section for synchronizing the RAM framebuffer access. */
|
---|
402 | PDMCRITSECT CritSectRamfb;
|
---|
403 | /** The refresh interval for the Ramfb support. */
|
---|
404 | uint32_t cMilliesRefreshInterval;
|
---|
405 | /** Refresh timer handle for the Ramfb support. */
|
---|
406 | TMTIMERHANDLE hRamfbRefreshTimer;
|
---|
407 | /** The current rambuffer config if enabled. */
|
---|
408 | QEMURAMFBCONFIG RamfbCfg;
|
---|
409 | /** Flag whether rendering the VRAM is enabled currently. */
|
---|
410 | bool fRenderVRam;
|
---|
411 | /** Flag whether the RAM based framebuffer device is enabled. */
|
---|
412 | bool fRamfbSupported;
|
---|
413 | /** Flag whether the DMA interface is available. */
|
---|
414 | bool fDmaEnabled;
|
---|
415 |
|
---|
416 | /** Scratch buffer for config item specific data. */
|
---|
417 | union
|
---|
418 | {
|
---|
419 | uint8_t u8;
|
---|
420 | uint16_t u16;
|
---|
421 | uint32_t u32;
|
---|
422 | uint64_t u64;
|
---|
423 | /** VFS file handle. */
|
---|
424 | RTVFSFILE hVfsFile;
|
---|
425 | /** Firmware config file entry. */
|
---|
426 | QEMUFWCFGFILE CfgFile;
|
---|
427 | /** Byte view. */
|
---|
428 | uint8_t ab[8];
|
---|
429 | } u;
|
---|
430 | } DEVQEMUFWCFG;
|
---|
431 |
|
---|
432 |
|
---|
433 | /**
|
---|
434 | * @interface_method_impl{QEMUFWCFGITEM,pfnSetup, Sets up the data for the signature configuration item.}
|
---|
435 | */
|
---|
436 | static DECLCALLBACK(int) qemuFwCfgR3SetupSignature(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t *pcbItem)
|
---|
437 | {
|
---|
438 | RT_NOREF(pThis, pItem);
|
---|
439 | uint8_t abSig[] = { 'Q', 'E', 'M', 'U' };
|
---|
440 | memcpy(&pThis->u.ab[0], &abSig[0], sizeof(abSig));
|
---|
441 | *pcbItem = sizeof(abSig);
|
---|
442 | return VINF_SUCCESS;
|
---|
443 | }
|
---|
444 |
|
---|
445 |
|
---|
446 | /**
|
---|
447 | * @interface_method_impl{QEMUFWCFGITEM,pfnSetup, Sets up the data for the version configuration item.}
|
---|
448 | */
|
---|
449 | static DECLCALLBACK(int) qemuFwCfgR3SetupVersion(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t *pcbItem)
|
---|
450 | {
|
---|
451 | RT_NOREF(pThis, pItem);
|
---|
452 | memcpy(&pThis->u.ab[0], &pThis->u32Version, sizeof(pThis->u32Version));
|
---|
453 | *pcbItem = sizeof(pThis->u32Version);
|
---|
454 | return VINF_SUCCESS;
|
---|
455 | }
|
---|
456 |
|
---|
457 |
|
---|
458 | /**
|
---|
459 | * @interface_method_impl{QEMUFWCFGITEM,pfnSetup, Sets up the data for the file directory configuration item.}
|
---|
460 | */
|
---|
461 | static DECLCALLBACK(int) qemuFwCfgR3SetupFileDir(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t *pcbItem)
|
---|
462 | {
|
---|
463 | RT_NOREF(pItem);
|
---|
464 | uint32_t cCfgFiles = RT_H2BE_U32(pThis->cCfgFiles);
|
---|
465 | memcpy(&pThis->u.ab[0], &cCfgFiles, sizeof(cCfgFiles));
|
---|
466 | *pcbItem = sizeof(uint32_t) + pThis->cCfgFiles * sizeof(QEMUFWCFGFILE);
|
---|
467 | return VINF_SUCCESS;
|
---|
468 | }
|
---|
469 |
|
---|
470 |
|
---|
471 | /**
|
---|
472 | * @interface_method_impl{QEMUFWCFGITEM,pfnSetup, Sets up the data for the size config item belonging to a VFS file type configuration item.}
|
---|
473 | */
|
---|
474 | static DECLCALLBACK(int) qemuFwCfgR3SetupCfgmFileSz(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t *pcbItem)
|
---|
475 | {
|
---|
476 | PCPDMDEVHLPR3 pHlp = pThis->pDevIns->pHlpR3;
|
---|
477 |
|
---|
478 | int rc = VINF_SUCCESS;
|
---|
479 | RTVFSFILE hVfsFile = NIL_RTVFSFILE;
|
---|
480 | if ( pItem->uCfgItem == QEMU_FW_CFG_ITEM_INITRD_SIZE
|
---|
481 | && pThis->hVfsFileInitrd != NIL_RTVFSFILE)
|
---|
482 | {
|
---|
483 | RTVfsFileRetain(pThis->hVfsFileInitrd);
|
---|
484 | hVfsFile = pThis->hVfsFileInitrd;
|
---|
485 | }
|
---|
486 | else
|
---|
487 | {
|
---|
488 | /* Query the path from the CFGM key. */
|
---|
489 | char *pszFilePath = NULL;
|
---|
490 | rc = pHlp->pfnCFGMQueryStringAlloc(pThis->pCfg, pItem->pszCfgmKey, &pszFilePath);
|
---|
491 | if (RT_SUCCESS(rc))
|
---|
492 | {
|
---|
493 | rc = RTVfsFileOpenNormal(pszFilePath, RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &hVfsFile);
|
---|
494 | if (RT_FAILURE(rc))
|
---|
495 | LogRel(("QemuFwCfg: Failed to open file \"%s\" -> %Rrc\n", pszFilePath, rc));
|
---|
496 | PDMDevHlpMMHeapFree(pThis->pDevIns, pszFilePath);
|
---|
497 | }
|
---|
498 | else if (rc == VERR_CFGM_VALUE_NOT_FOUND)
|
---|
499 | {
|
---|
500 | pThis->u.u32 = 0;
|
---|
501 | *pcbItem = sizeof(uint32_t);
|
---|
502 | rc = VINF_SUCCESS;
|
---|
503 | }
|
---|
504 | else
|
---|
505 | LogRel(("QemuFwCfg: Failed to query \"%s\" -> %Rrc\n", pItem->pszCfgmKey, rc));
|
---|
506 | }
|
---|
507 |
|
---|
508 | if ( RT_SUCCESS(rc)
|
---|
509 | && hVfsFile != NIL_RTVFSFILE)
|
---|
510 | {
|
---|
511 | uint64_t cbFile = 0;
|
---|
512 | rc = RTVfsFileQuerySize(hVfsFile, &cbFile);
|
---|
513 | if (RT_SUCCESS(rc))
|
---|
514 | {
|
---|
515 | if (cbFile < _4G)
|
---|
516 | {
|
---|
517 | pThis->u.u32 = (uint32_t)cbFile;
|
---|
518 | *pcbItem = sizeof(uint32_t);
|
---|
519 | }
|
---|
520 | else
|
---|
521 | {
|
---|
522 | rc = VERR_BUFFER_OVERFLOW;
|
---|
523 | LogRel(("QemuFwCfg: File exceeds 4G limit (%llu)\n", cbFile));
|
---|
524 | }
|
---|
525 | }
|
---|
526 | else
|
---|
527 | LogRel(("QemuFwCfg: Failed to query file size from -> %Rrc\n", rc));
|
---|
528 | RTVfsFileRelease(hVfsFile);
|
---|
529 | }
|
---|
530 |
|
---|
531 | return rc;
|
---|
532 | }
|
---|
533 |
|
---|
534 |
|
---|
535 | /**
|
---|
536 | * @interface_method_impl{QEMUFWCFGITEM,pfnSetup, Sets up the data for the size config item belonging to a string type configuration item.}
|
---|
537 | */
|
---|
538 | static DECLCALLBACK(int) qemuFwCfgR3SetupCfgmStrSz(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t *pcbItem)
|
---|
539 | {
|
---|
540 | PCPDMDEVHLPR3 pHlp = pThis->pDevIns->pHlpR3;
|
---|
541 |
|
---|
542 | /* Query the string from the CFGM key. */
|
---|
543 | char sz[_4K];
|
---|
544 | int rc = pHlp->pfnCFGMQueryString(pThis->pCfg, pItem->pszCfgmKey, &sz[0], sizeof(sz));
|
---|
545 | if (RT_SUCCESS(rc))
|
---|
546 | {
|
---|
547 | pThis->u.u32 = (uint32_t)strlen(&sz[0]) + 1;
|
---|
548 | *pcbItem = sizeof(uint32_t);
|
---|
549 | }
|
---|
550 | else if (rc == VERR_CFGM_VALUE_NOT_FOUND)
|
---|
551 | {
|
---|
552 | pThis->u.u32 = 0;
|
---|
553 | *pcbItem = sizeof(uint32_t);
|
---|
554 | rc = VINF_SUCCESS;
|
---|
555 | }
|
---|
556 | else
|
---|
557 | LogRel(("QemuFwCfg: Failed to query \"%s\" -> %Rrc\n", pItem->pszCfgmKey, rc));
|
---|
558 |
|
---|
559 | return rc;
|
---|
560 | }
|
---|
561 |
|
---|
562 |
|
---|
563 | /**
|
---|
564 | * @interface_method_impl{QEMUFWCFGITEM,pfnSetup, Sets up the data for a string type configuration item gathered from CFGM.}
|
---|
565 | */
|
---|
566 | static DECLCALLBACK(int) qemuFwCfgR3SetupCfgmStr(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t *pcbItem)
|
---|
567 | {
|
---|
568 | PCPDMDEVHLPR3 pHlp = pThis->pDevIns->pHlpR3;
|
---|
569 |
|
---|
570 | /* Query the string from the CFGM key. */
|
---|
571 | char sz[_4K];
|
---|
572 | int rc = pHlp->pfnCFGMQueryString(pThis->pCfg, pItem->pszCfgmKey, &sz[0], sizeof(sz));
|
---|
573 | if (RT_SUCCESS(rc))
|
---|
574 | *pcbItem = (uint32_t)strlen(&sz[0]) + 1;
|
---|
575 | else
|
---|
576 | LogRel(("QemuFwCfg: Failed to query \"%s\" -> %Rrc\n", pItem->pszCfgmKey, rc));
|
---|
577 |
|
---|
578 | return rc;
|
---|
579 | }
|
---|
580 |
|
---|
581 |
|
---|
582 | /**
|
---|
583 | * @interface_method_impl{QEMUFWCFGITEM,pfnSetup, Sets up the data for a VFS file type configuration item.}
|
---|
584 | */
|
---|
585 | static DECLCALLBACK(int) qemuFwCfgR3SetupCfgmFile(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t *pcbItem)
|
---|
586 | {
|
---|
587 | PCPDMDEVHLPR3 pHlp = pThis->pDevIns->pHlpR3;
|
---|
588 |
|
---|
589 | int rc = VINF_SUCCESS;
|
---|
590 | if ( pItem->uCfgItem == QEMU_FW_CFG_ITEM_INITRD_DATA
|
---|
591 | && pThis->hVfsFileInitrd != NIL_RTVFSFILE)
|
---|
592 | {
|
---|
593 | RTVfsFileRetain(pThis->hVfsFileInitrd);
|
---|
594 | pThis->u.hVfsFile = pThis->hVfsFileInitrd;
|
---|
595 | }
|
---|
596 | else
|
---|
597 | {
|
---|
598 | /* Query the path from the CFGM key. */
|
---|
599 | char *pszFilePath = NULL;
|
---|
600 | rc = pHlp->pfnCFGMQueryStringAlloc(pThis->pCfg, pItem->pszCfgmKey, &pszFilePath);
|
---|
601 | if (RT_SUCCESS(rc))
|
---|
602 | {
|
---|
603 | rc = RTVfsFileOpenNormal(pszFilePath, RTFILE_O_READ | RTFILE_O_DENY_NONE | RTFILE_O_OPEN, &pThis->u.hVfsFile);
|
---|
604 | if (RT_FAILURE(rc))
|
---|
605 | LogRel(("QemuFwCfg: Failed to open file \"%s\" -> %Rrc\n", pszFilePath, rc));
|
---|
606 | PDMDevHlpMMHeapFree(pThis->pDevIns, pszFilePath);
|
---|
607 | }
|
---|
608 | else
|
---|
609 | LogRel(("QemuFwCfg: Failed to query \"%s\" -> %Rrc\n", pItem->pszCfgmKey, rc));
|
---|
610 | }
|
---|
611 |
|
---|
612 | if (RT_SUCCESS(rc))
|
---|
613 | {
|
---|
614 | uint64_t cbFile = 0;
|
---|
615 | rc = RTVfsFileQuerySize(pThis->u.hVfsFile, &cbFile);
|
---|
616 | if (RT_SUCCESS(rc))
|
---|
617 | {
|
---|
618 | if (cbFile < _4G)
|
---|
619 | *pcbItem = (uint32_t)cbFile;
|
---|
620 | else
|
---|
621 | {
|
---|
622 | rc = VERR_BUFFER_OVERFLOW;
|
---|
623 | LogRel(("QemuFwCfg: File exceeds 4G limit (%llu)\n", cbFile));
|
---|
624 | }
|
---|
625 | }
|
---|
626 | else
|
---|
627 | LogRel(("QemuFwCfg: Failed to query file size from -> %Rrc\n", rc));
|
---|
628 | }
|
---|
629 |
|
---|
630 | return rc;
|
---|
631 | }
|
---|
632 |
|
---|
633 |
|
---|
634 | /**
|
---|
635 | * @interface_method_impl{QEMUFWCFGITEM,pfnRead, Reads data from a configuration item having its data stored in the scratch buffer.}
|
---|
636 | */
|
---|
637 | static DECLCALLBACK(int) qemuFwCfgR3ReadSimple(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t off, void *pvBuf,
|
---|
638 | uint32_t cbToRead, uint32_t *pcbRead)
|
---|
639 | {
|
---|
640 | RT_NOREF(pThis, pItem);
|
---|
641 | memcpy(pvBuf, &pThis->u.ab[off], cbToRead);
|
---|
642 | *pcbRead = cbToRead;
|
---|
643 | return VINF_SUCCESS;
|
---|
644 | }
|
---|
645 |
|
---|
646 |
|
---|
647 | /**
|
---|
648 | * @interface_method_impl{QEMUFWCFGITEM,pfnRead, Reads data from a VFS file type configuration item.}
|
---|
649 | */
|
---|
650 | static DECLCALLBACK(int) qemuFwCfgR3ReadVfsFile(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t off, void *pvBuf,
|
---|
651 | uint32_t cbToRead, uint32_t *pcbRead)
|
---|
652 | {
|
---|
653 | RT_NOREF(pItem);
|
---|
654 | size_t cbRead = 0;
|
---|
655 | int rc = RTVfsFileReadAt(pThis->u.hVfsFile, off, pvBuf, cbToRead, &cbRead);
|
---|
656 | if (RT_SUCCESS(rc))
|
---|
657 | *pcbRead = (uint32_t)cbRead;
|
---|
658 |
|
---|
659 | return rc;
|
---|
660 | }
|
---|
661 |
|
---|
662 |
|
---|
663 | /**
|
---|
664 | * @interface_method_impl{QEMUFWCFGITEM,pfnRead, Reads a string item gathered from CFGM.}
|
---|
665 | */
|
---|
666 | static DECLCALLBACK(int) qemuFwCfgR3ReadStr(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t off, void *pvBuf,
|
---|
667 | uint32_t cbToRead, uint32_t *pcbRead)
|
---|
668 | {
|
---|
669 | PCPDMDEVHLPR3 pHlp = pThis->pDevIns->pHlpR3;
|
---|
670 |
|
---|
671 | /* Query the string from the CFGM key. */
|
---|
672 | char sz[_4K];
|
---|
673 | int rc = pHlp->pfnCFGMQueryString(pThis->pCfg, pItem->pszCfgmKey, &sz[0], sizeof(sz));
|
---|
674 | if (RT_SUCCESS(rc))
|
---|
675 | {
|
---|
676 | uint32_t cch = (uint32_t)strlen(sz) + 1;
|
---|
677 | if (off < cch)
|
---|
678 | {
|
---|
679 | uint32_t cbRead = RT_MIN(cbToRead, off - cch);
|
---|
680 | memcpy(pvBuf, &sz[off], cbRead);
|
---|
681 | *pcbRead = cbRead;
|
---|
682 | }
|
---|
683 | else
|
---|
684 | rc = VERR_BUFFER_OVERFLOW;
|
---|
685 | }
|
---|
686 | else
|
---|
687 | LogRel(("QemuFwCfg: Failed to query \"%s\" -> %Rrc\n", pItem->pszCfgmKey, rc));
|
---|
688 |
|
---|
689 | return rc;
|
---|
690 | }
|
---|
691 |
|
---|
692 |
|
---|
693 | /**
|
---|
694 | * @interface_method_impl{QEMUFWCFGITEM,pfnRead, Reads data from the file directory.}
|
---|
695 | */
|
---|
696 | static DECLCALLBACK(int) qemuFwCfgR3ReadFileDir(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t off, void *pvBuf,
|
---|
697 | uint32_t cbToRead, uint32_t *pcbRead)
|
---|
698 | {
|
---|
699 | RT_NOREF(pItem);
|
---|
700 |
|
---|
701 | /* The first 4 bytes are the number of entries following. */
|
---|
702 | if (off < sizeof(uint32_t))
|
---|
703 | {
|
---|
704 | cbToRead = RT_MIN(cbToRead, sizeof(uint32_t) - off);
|
---|
705 | memcpy(pvBuf, &pThis->u.ab[off], cbToRead);
|
---|
706 | *pcbRead = cbToRead;
|
---|
707 | }
|
---|
708 | else
|
---|
709 | {
|
---|
710 | off -= sizeof(uint32_t);
|
---|
711 |
|
---|
712 | /* The entries are static, so we can deduce the entry number from the offset. */
|
---|
713 | uint32_t idxEntry = off / sizeof(pThis->u.CfgFile);
|
---|
714 | AssertReturn(idxEntry < pThis->cCfgFiles, VERR_INTERNAL_ERROR);
|
---|
715 |
|
---|
716 | off %= sizeof(pThis->u.CfgFile);
|
---|
717 | cbToRead = RT_MIN(cbToRead, sizeof(pThis->u.CfgFile));
|
---|
718 |
|
---|
719 | /* Setup the config file item. */
|
---|
720 | PCQEMUFWCFGFILEENTRY pEntry = &pThis->paCfgFiles[idxEntry];
|
---|
721 | pThis->u.CfgFile.cbFile = RT_H2BE_U32(pEntry->cbFile);
|
---|
722 | pThis->u.CfgFile.uCfgItem = RT_H2BE_U16(pEntry->Cfg.uCfgItem);
|
---|
723 | pThis->u.CfgFile.u16Rsvd = 0;
|
---|
724 | strncpy(pThis->u.CfgFile.szFilename, pEntry->Cfg.pszItem, sizeof(pThis->u.CfgFile.szFilename) - 1);
|
---|
725 | pThis->u.CfgFile.szFilename[QEMU_FW_CFG_ITEM_FILE_NAME_MAX] = '\0';
|
---|
726 |
|
---|
727 | memcpy(pvBuf, &pThis->u.ab[off], cbToRead);
|
---|
728 | *pcbRead = cbToRead;
|
---|
729 | }
|
---|
730 | return VINF_SUCCESS;
|
---|
731 | }
|
---|
732 |
|
---|
733 |
|
---|
734 | /**
|
---|
735 | * @interface_method_impl{QEMUFWCFGITEM,pfnCleanup, Cleans up a VFS file type configuration item.}
|
---|
736 | */
|
---|
737 | static DECLCALLBACK(void) qemuFwCfgR3CleanupVfsFile(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem)
|
---|
738 | {
|
---|
739 | RT_NOREF(pItem);
|
---|
740 | RTVfsFileRelease(pThis->u.hVfsFile);
|
---|
741 | pThis->u.hVfsFile = NIL_RTVFSFILE;
|
---|
742 | }
|
---|
743 |
|
---|
744 |
|
---|
745 | /**
|
---|
746 | * @interface_method_impl{QEMUFWCFGITEM,pfnSetup, Generic setup routine for file entries which don't have a dedicated setup routine.}
|
---|
747 | */
|
---|
748 | static DECLCALLBACK(int) qemuFwCfgR3SetupFileGeneric(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t *pcbItem)
|
---|
749 | {
|
---|
750 | RT_NOREF(pItem);
|
---|
751 | *pcbItem = pThis->paCfgFiles[pItem->uCfgItem - QEMU_FW_CFG_ITEM_FILE_USER_FIRST].cbFile;
|
---|
752 | return VINF_SUCCESS;
|
---|
753 | }
|
---|
754 |
|
---|
755 |
|
---|
756 | /**
|
---|
757 | * Supported config items.
|
---|
758 | */
|
---|
759 | static const QEMUFWCFGITEM g_aQemuFwCfgItems[] =
|
---|
760 | {
|
---|
761 | /** u16Selector pszItem pszCfgmKey pfnSetup pfnRead pfnWrite pfnCleanup */
|
---|
762 | { QEMU_FW_CFG_ITEM_SIGNATURE, "Signature", NULL, qemuFwCfgR3SetupSignature, qemuFwCfgR3ReadSimple, NULL, NULL },
|
---|
763 | { QEMU_FW_CFG_ITEM_VERSION, "Version", NULL, qemuFwCfgR3SetupVersion, qemuFwCfgR3ReadSimple, NULL, NULL },
|
---|
764 | { QEMU_FW_CFG_ITEM_KERNEL_SIZE, "KrnlSz", "KernelImage", qemuFwCfgR3SetupCfgmFileSz, qemuFwCfgR3ReadSimple, NULL, NULL },
|
---|
765 | { QEMU_FW_CFG_ITEM_KERNEL_DATA, "KrnlDat", "KernelImage", qemuFwCfgR3SetupCfgmFile, qemuFwCfgR3ReadVfsFile, NULL, qemuFwCfgR3CleanupVfsFile },
|
---|
766 | { QEMU_FW_CFG_ITEM_INITRD_SIZE, "InitrdSz", "InitrdImage", qemuFwCfgR3SetupCfgmFileSz, qemuFwCfgR3ReadSimple, NULL, NULL },
|
---|
767 | { QEMU_FW_CFG_ITEM_INITRD_DATA, "InitrdDat", "InitrdImage", qemuFwCfgR3SetupCfgmFile, qemuFwCfgR3ReadVfsFile, NULL, qemuFwCfgR3CleanupVfsFile },
|
---|
768 | { QEMU_FW_CFG_ITEM_KERNEL_SETUP_SIZE, "SetupSz", "SetupImage", qemuFwCfgR3SetupCfgmFileSz, qemuFwCfgR3ReadSimple, NULL, NULL },
|
---|
769 | { QEMU_FW_CFG_ITEM_KERNEL_SETUP_DATA, "SetupDat", "SetupImage", qemuFwCfgR3SetupCfgmFile, qemuFwCfgR3ReadVfsFile, NULL, qemuFwCfgR3CleanupVfsFile },
|
---|
770 | { QEMU_FW_CFG_ITEM_CMD_LINE_SIZE, "CmdLineSz", "CmdLine", qemuFwCfgR3SetupCfgmStrSz, qemuFwCfgR3ReadSimple, NULL, NULL },
|
---|
771 | { QEMU_FW_CFG_ITEM_CMD_LINE_DATA, "CmdLineDat", "CmdLine", qemuFwCfgR3SetupCfgmStr, qemuFwCfgR3ReadStr, NULL, NULL },
|
---|
772 | { QEMU_FW_CFG_ITEM_FILE_DIR, "FileDir", NULL, qemuFwCfgR3SetupFileDir, qemuFwCfgR3ReadFileDir, NULL, NULL }
|
---|
773 | };
|
---|
774 |
|
---|
775 |
|
---|
776 | /**
|
---|
777 | * Resets the currently selected item.
|
---|
778 | *
|
---|
779 | * @param pThis The QEMU fw config device instance.
|
---|
780 | */
|
---|
781 | static void qemuFwCfgR3ItemReset(PDEVQEMUFWCFG pThis)
|
---|
782 | {
|
---|
783 | if ( pThis->pCfgItem
|
---|
784 | && pThis->pCfgItem->pfnCleanup)
|
---|
785 | pThis->pCfgItem->pfnCleanup(pThis, pThis->pCfgItem);
|
---|
786 |
|
---|
787 | pThis->pCfgItem = NULL;
|
---|
788 | pThis->offCfgItemNext = 0;
|
---|
789 | pThis->cbCfgItemLeft = 0;
|
---|
790 | }
|
---|
791 |
|
---|
792 |
|
---|
793 | /**
|
---|
794 | * Selects the given config item.
|
---|
795 | *
|
---|
796 | * @returns VBox status code.
|
---|
797 | * @param pThis The QEMU fw config device instance.
|
---|
798 | * @param uCfgItem The configuration item to select.
|
---|
799 | */
|
---|
800 | static int qemuFwCfgItemSelect(PDEVQEMUFWCFG pThis, uint16_t uCfgItem)
|
---|
801 | {
|
---|
802 | LogFlowFunc(("uCfgItem=%#x\n", uCfgItem));
|
---|
803 |
|
---|
804 | qemuFwCfgR3ItemReset(pThis);
|
---|
805 |
|
---|
806 | PCQEMUFWCFGITEM pCfgItem = NULL;;
|
---|
807 |
|
---|
808 | /* Check whether this is a file item. */
|
---|
809 | if (uCfgItem >= QEMU_FW_CFG_ITEM_FILE_USER_FIRST)
|
---|
810 | {
|
---|
811 | uCfgItem -= QEMU_FW_CFG_ITEM_FILE_USER_FIRST;
|
---|
812 | if (uCfgItem < pThis->cCfgFiles)
|
---|
813 | pCfgItem = &pThis->paCfgFiles[uCfgItem].Cfg;
|
---|
814 | }
|
---|
815 | else
|
---|
816 | {
|
---|
817 | for (uint32_t i = 0; i < RT_ELEMENTS(g_aQemuFwCfgItems); i++)
|
---|
818 | {
|
---|
819 | pCfgItem = &g_aQemuFwCfgItems[i];
|
---|
820 | if (pCfgItem->uCfgItem == uCfgItem)
|
---|
821 | break;
|
---|
822 | }
|
---|
823 | }
|
---|
824 |
|
---|
825 | if (pCfgItem)
|
---|
826 | {
|
---|
827 | uint32_t cbItem = 0;
|
---|
828 | AssertPtrReturn(pCfgItem->pfnSetup, VERR_INVALID_STATE);
|
---|
829 |
|
---|
830 | int rc = pCfgItem->pfnSetup(pThis, pCfgItem, &cbItem);
|
---|
831 | if (RT_SUCCESS(rc))
|
---|
832 | {
|
---|
833 | pThis->pCfgItem = pCfgItem;
|
---|
834 | pThis->cbCfgItemLeft = cbItem;
|
---|
835 | return VINF_SUCCESS;
|
---|
836 | }
|
---|
837 |
|
---|
838 | return rc;
|
---|
839 | }
|
---|
840 |
|
---|
841 | return VERR_NOT_FOUND;
|
---|
842 | }
|
---|
843 |
|
---|
844 |
|
---|
845 | /**
|
---|
846 | * Processes a DMA transfer.
|
---|
847 | *
|
---|
848 | * @param pThis The QEMU fw config device instance.
|
---|
849 | * @param GCPhysDma The guest physical address of the DMA descriptor.
|
---|
850 | */
|
---|
851 | static void qemuFwCfgDmaXfer(PDEVQEMUFWCFG pThis, RTGCPHYS GCPhysDma)
|
---|
852 | {
|
---|
853 | QEMUFWDMADESC DmaDesc; RT_ZERO(DmaDesc);
|
---|
854 |
|
---|
855 | LogFlowFunc(("pThis=%p GCPhysDma=%RGp\n", pThis, GCPhysDma));
|
---|
856 |
|
---|
857 | PDMDevHlpPhysReadMeta(pThis->pDevIns, GCPhysDma, &DmaDesc, sizeof(DmaDesc));
|
---|
858 |
|
---|
859 | /* Convert from big endianess to host endianess. */
|
---|
860 | DmaDesc.u32Ctrl = RT_BE2H_U32(DmaDesc.u32Ctrl);
|
---|
861 | DmaDesc.u32Length = RT_BE2H_U32(DmaDesc.u32Length);
|
---|
862 | DmaDesc.u64GCPhysBuf = RT_BE2H_U64(DmaDesc.u64GCPhysBuf);
|
---|
863 |
|
---|
864 | LogFlowFunc(("u32Ctrl=%#x u32Length=%u u64GCPhysBuf=%llx\n",
|
---|
865 | DmaDesc.u32Ctrl, DmaDesc.u32Length, DmaDesc.u64GCPhysBuf));
|
---|
866 |
|
---|
867 | /* If the select bit is set a select is performed. */
|
---|
868 | int rc = VINF_SUCCESS;
|
---|
869 | if (DmaDesc.u32Ctrl & QEMU_FW_CFG_DMA_SELECT)
|
---|
870 | rc = qemuFwCfgItemSelect(pThis, QEMU_FW_CFG_DMA_GET_CFG_ITEM(DmaDesc.u32Ctrl));
|
---|
871 | else if (!pThis->pCfgItem)
|
---|
872 | rc = VERR_NOT_FOUND;
|
---|
873 |
|
---|
874 | if (RT_SUCCESS(rc))
|
---|
875 | {
|
---|
876 | if ( ( DmaDesc.u32Ctrl & QEMU_FW_CFG_DMA_WRITE
|
---|
877 | && !pThis->pCfgItem->pfnWrite)
|
---|
878 | || ( DmaDesc.u32Ctrl & QEMU_FW_CFG_DMA_READ
|
---|
879 | && !pThis->pCfgItem->pfnRead))
|
---|
880 | rc = VERR_NOT_SUPPORTED;
|
---|
881 | else if ( !pThis->pCfgItem
|
---|
882 | || !pThis->cbCfgItemLeft)
|
---|
883 | {
|
---|
884 | if (DmaDesc.u32Ctrl & QEMU_FW_CFG_DMA_READ)
|
---|
885 | {
|
---|
886 | /* Item is not supported, just zero out the indicated area. */
|
---|
887 | RTGCPHYS GCPhysCur = DmaDesc.u64GCPhysBuf;
|
---|
888 | uint32_t cbLeft = DmaDesc.u32Length;
|
---|
889 |
|
---|
890 | while ( RT_SUCCESS(rc)
|
---|
891 | && cbLeft)
|
---|
892 | {
|
---|
893 | uint32_t cbZero = RT_MIN(_64K, cbLeft);
|
---|
894 |
|
---|
895 | PDMDevHlpPhysWriteMeta(pThis->pDevIns, GCPhysCur, &g_abRTZero64K[0], cbZero);
|
---|
896 |
|
---|
897 | cbLeft -= cbZero;
|
---|
898 | GCPhysCur += cbZero;
|
---|
899 | }
|
---|
900 | }
|
---|
901 | /* else: Assume Skip or Write and ignore. */
|
---|
902 | }
|
---|
903 | else
|
---|
904 | {
|
---|
905 | /* Normal path. */
|
---|
906 | RTGCPHYS GCPhysCur = DmaDesc.u64GCPhysBuf;
|
---|
907 | uint32_t cbLeft = RT_MIN(DmaDesc.u32Length, pThis->cbCfgItemLeft);
|
---|
908 |
|
---|
909 | if (DmaDesc.u32Ctrl & QEMU_FW_CFG_DMA_WRITE)
|
---|
910 | {
|
---|
911 | while ( RT_SUCCESS(rc)
|
---|
912 | && cbLeft)
|
---|
913 | {
|
---|
914 | uint8_t abTmp[_1K];
|
---|
915 | uint32_t cbThisWrite = RT_MIN(sizeof(abTmp), cbLeft);
|
---|
916 | uint32_t cbWritten;
|
---|
917 |
|
---|
918 | PDMDevHlpPhysReadMeta(pThis->pDevIns, GCPhysCur, &abTmp[0], cbThisWrite);
|
---|
919 | rc = pThis->pCfgItem->pfnWrite(pThis, pThis->pCfgItem, pThis->offCfgItemNext, &abTmp[0],
|
---|
920 | cbThisWrite, &cbWritten);
|
---|
921 | if (RT_SUCCESS(rc))
|
---|
922 | {
|
---|
923 | cbLeft -= cbWritten;
|
---|
924 | GCPhysCur += cbWritten;
|
---|
925 |
|
---|
926 | pThis->offCfgItemNext += cbWritten;
|
---|
927 | pThis->cbCfgItemLeft -= cbWritten;
|
---|
928 | }
|
---|
929 | }
|
---|
930 | }
|
---|
931 | else
|
---|
932 | {
|
---|
933 | while ( RT_SUCCESS(rc)
|
---|
934 | && cbLeft)
|
---|
935 | {
|
---|
936 | uint8_t abTmp[_1K];
|
---|
937 | uint32_t cbThisRead = RT_MIN(sizeof(abTmp), cbLeft);
|
---|
938 | uint32_t cbRead;
|
---|
939 |
|
---|
940 | rc = pThis->pCfgItem->pfnRead(pThis, pThis->pCfgItem, pThis->offCfgItemNext, &abTmp[0],
|
---|
941 | cbThisRead, &cbRead);
|
---|
942 | if (RT_SUCCESS(rc))
|
---|
943 | {
|
---|
944 | if (DmaDesc.u32Ctrl & QEMU_FW_CFG_DMA_READ)
|
---|
945 | PDMDevHlpPhysWriteMeta(pThis->pDevIns, GCPhysCur, &abTmp[0], cbRead);
|
---|
946 | /* else: Assume Skip */
|
---|
947 |
|
---|
948 | cbLeft -= cbRead;
|
---|
949 | GCPhysCur += cbRead;
|
---|
950 |
|
---|
951 | pThis->offCfgItemNext += cbRead;
|
---|
952 | pThis->cbCfgItemLeft -= cbRead;
|
---|
953 | }
|
---|
954 | }
|
---|
955 | }
|
---|
956 | }
|
---|
957 | }
|
---|
958 |
|
---|
959 | LogFlowFunc(("pThis=%p GCPhysDma=%RGp -> %Rrc\n", pThis, GCPhysDma, rc));
|
---|
960 |
|
---|
961 | /* Write back the control field. */
|
---|
962 | uint32_t u32Resp = RT_SUCCESS(rc) ? 0 : RT_H2BE_U32(QEMU_FW_CFG_DMA_ERROR);
|
---|
963 | PDMDevHlpPhysWriteMeta(pThis->pDevIns, GCPhysDma, &u32Resp, sizeof(u32Resp));
|
---|
964 | }
|
---|
965 |
|
---|
966 |
|
---|
967 | /**
|
---|
968 | * @callback_method_impl{FNIOMIOPORTNEWOUT, QEMU firmware configuration write.}
|
---|
969 | */
|
---|
970 | static DECLCALLBACK(VBOXSTRICTRC) qemuFwCfgIoPortWrite(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t u32, unsigned cb)
|
---|
971 | {
|
---|
972 | int rc = VINF_SUCCESS;
|
---|
973 | PDEVQEMUFWCFG pThis = PDMDEVINS_2_DATA(pDevIns, PDEVQEMUFWCFG);
|
---|
974 | NOREF(pvUser);
|
---|
975 |
|
---|
976 | LogFlowFunc(("offPort=%RTiop u32=%#x cb=%u\n", offPort, u32, cb));
|
---|
977 |
|
---|
978 | switch (offPort)
|
---|
979 | {
|
---|
980 | case QEMU_FW_CFG_OFF_SELECTOR:
|
---|
981 | {
|
---|
982 | if (cb == 2)
|
---|
983 | qemuFwCfgItemSelect(pThis, (uint16_t)u32);
|
---|
984 | break;
|
---|
985 | }
|
---|
986 | case QEMU_FW_CFG_OFF_DATA: /* Readonly, ignore */
|
---|
987 | break;
|
---|
988 | case QEMU_FW_CFG_OFF_DMA_HIGH:
|
---|
989 | {
|
---|
990 | if (cb == 4)
|
---|
991 | pThis->GCPhysDma = ((RTGCPHYS)RT_BE2H_U32(u32)) << 32;
|
---|
992 | break;
|
---|
993 | }
|
---|
994 | case QEMU_FW_CFG_OFF_DMA_LOW:
|
---|
995 | {
|
---|
996 | if (cb == 4)
|
---|
997 | {
|
---|
998 | pThis->GCPhysDma |= ((RTGCPHYS)RT_BE2H_U32(u32));
|
---|
999 | qemuFwCfgDmaXfer(pThis, pThis->GCPhysDma);
|
---|
1000 | pThis->GCPhysDma = 0;
|
---|
1001 | }
|
---|
1002 | break;
|
---|
1003 | }
|
---|
1004 | default:
|
---|
1005 | rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "Port=%#x cb=%d u32=%#x\n", offPort, cb, u32);
|
---|
1006 | break;
|
---|
1007 | }
|
---|
1008 |
|
---|
1009 | LogFlowFunc((" -> rc=%Rrc\n", rc));
|
---|
1010 | return rc;
|
---|
1011 | }
|
---|
1012 |
|
---|
1013 |
|
---|
1014 | /**
|
---|
1015 | * @callback_method_impl{FNIOMIOPORTNEWIN, QEMU firmware configuration read.}
|
---|
1016 | */
|
---|
1017 | static DECLCALLBACK(VBOXSTRICTRC) qemuFwCfgIoPortRead(PPDMDEVINS pDevIns, void *pvUser, RTIOPORT offPort, uint32_t *pu32, unsigned cb)
|
---|
1018 | {
|
---|
1019 | int rc = VINF_SUCCESS;
|
---|
1020 | PDEVQEMUFWCFG pThis = PDMDEVINS_2_DATA(pDevIns, PDEVQEMUFWCFG);
|
---|
1021 | NOREF(pvUser);
|
---|
1022 |
|
---|
1023 | *pu32 = 0;
|
---|
1024 |
|
---|
1025 | LogFlowFunc(("offPort=%RTiop cb=%u\n", offPort, cb));
|
---|
1026 |
|
---|
1027 | switch (offPort)
|
---|
1028 | {
|
---|
1029 | /* Selector (Writeonly, ignore). */
|
---|
1030 | case QEMU_FW_CFG_OFF_SELECTOR:
|
---|
1031 | break;
|
---|
1032 | case QEMU_FW_CFG_OFF_DATA:
|
---|
1033 | {
|
---|
1034 | if (cb == 1)
|
---|
1035 | {
|
---|
1036 | if ( pThis->cbCfgItemLeft
|
---|
1037 | && pThis->pCfgItem)
|
---|
1038 | {
|
---|
1039 | uint8_t bRead = 0;
|
---|
1040 | uint32_t cbRead = 0;
|
---|
1041 | int rc2 = pThis->pCfgItem->pfnRead(pThis, pThis->pCfgItem, pThis->offCfgItemNext, &bRead,
|
---|
1042 | sizeof(bRead), &cbRead);
|
---|
1043 | if ( RT_SUCCESS(rc2)
|
---|
1044 | && cbRead == sizeof(bRead))
|
---|
1045 | {
|
---|
1046 | pThis->offCfgItemNext += cbRead;
|
---|
1047 | pThis->cbCfgItemLeft -= cbRead;
|
---|
1048 | *pu32 = bRead;
|
---|
1049 | }
|
---|
1050 | }
|
---|
1051 | }
|
---|
1052 | else
|
---|
1053 | rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "Port=%#x cb=%d\n", offPort, cb);
|
---|
1054 | break;
|
---|
1055 | }
|
---|
1056 |
|
---|
1057 | default:
|
---|
1058 | rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "Port=%#x cb=%d\n", offPort, cb);
|
---|
1059 | break;
|
---|
1060 | }
|
---|
1061 |
|
---|
1062 | LogFlowFunc(("offPort=%RTiop cb=%u -> rc=%Rrc u32=%#x\n", offPort, cb, rc, *pu32));
|
---|
1063 |
|
---|
1064 | return rc;
|
---|
1065 | }
|
---|
1066 |
|
---|
1067 |
|
---|
1068 | /* -=-=-=-=-=- MMIO callbacks -=-=-=-=-=- */
|
---|
1069 |
|
---|
1070 |
|
---|
1071 | /**
|
---|
1072 | * @callback_method_impl{FNIOMMMIONEWREAD}
|
---|
1073 | */
|
---|
1074 | static DECLCALLBACK(VBOXSTRICTRC) qemuFwCfgMmioRead(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void *pv, unsigned cb)
|
---|
1075 | {
|
---|
1076 | PDEVQEMUFWCFG pThis = PDMDEVINS_2_DATA(pDevIns, PDEVQEMUFWCFG);
|
---|
1077 | RT_NOREF(pvUser);
|
---|
1078 |
|
---|
1079 | LogFlowFunc(("%RGp cb=%u\n", off, cb));
|
---|
1080 |
|
---|
1081 | AssertReturn(cb <= sizeof(uint64_t), VERR_INVALID_PARAMETER);
|
---|
1082 |
|
---|
1083 | VBOXSTRICTRC rc = VINF_SUCCESS;
|
---|
1084 | switch (off)
|
---|
1085 | {
|
---|
1086 | case QEU_FW_CFG_MMIO_OFF_DATA:
|
---|
1087 | {
|
---|
1088 | if ( pThis->cbCfgItemLeft
|
---|
1089 | && pThis->pCfgItem)
|
---|
1090 | {
|
---|
1091 | uint32_t cbRead = 0;
|
---|
1092 | int rc2 = pThis->pCfgItem->pfnRead(pThis, pThis->pCfgItem, pThis->offCfgItemNext, pv,
|
---|
1093 | cb, &cbRead);
|
---|
1094 | if (RT_SUCCESS(rc2))
|
---|
1095 | {
|
---|
1096 | pThis->offCfgItemNext += cbRead;
|
---|
1097 | pThis->cbCfgItemLeft -= cbRead;
|
---|
1098 | }
|
---|
1099 | }
|
---|
1100 | else
|
---|
1101 | rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "offMmio=%#x cb=%d\n", off, cb);
|
---|
1102 | break;
|
---|
1103 | }
|
---|
1104 | case QEU_FW_CFG_MMIO_OFF_DMA:
|
---|
1105 | if ( cb == sizeof(uint64_t)
|
---|
1106 | && pThis->fDmaEnabled)
|
---|
1107 | *(uint64_t *)pv = RT_H2BE_U64(QEMU_FW_CFG_DMA_ADDR_SIGNATURE);
|
---|
1108 | else
|
---|
1109 | rc = VINF_IOM_MMIO_UNUSED_00;
|
---|
1110 | break;
|
---|
1111 | case QEU_FW_CFG_MMIO_OFF_SELECTOR:
|
---|
1112 | /* Writeonly, ignore. */
|
---|
1113 | rc = VINF_IOM_MMIO_UNUSED_00;
|
---|
1114 | break;
|
---|
1115 | default:
|
---|
1116 | rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "offMmio=%#x cb=%d\n", off, cb);
|
---|
1117 | break;
|
---|
1118 | }
|
---|
1119 |
|
---|
1120 | return rc;
|
---|
1121 | }
|
---|
1122 |
|
---|
1123 |
|
---|
1124 | /**
|
---|
1125 | * @callback_method_impl{FNIOMMMIONEWWRITE}
|
---|
1126 | */
|
---|
1127 | static DECLCALLBACK(VBOXSTRICTRC) qemuFwCfgMmioWrite(PPDMDEVINS pDevIns, void *pvUser, RTGCPHYS off, void const *pv, unsigned cb)
|
---|
1128 | {
|
---|
1129 | int rc = VINF_SUCCESS;
|
---|
1130 | PDEVQEMUFWCFG pThis = PDMDEVINS_2_DATA(pDevIns, PDEVQEMUFWCFG);
|
---|
1131 | RT_NOREF(pvUser);
|
---|
1132 |
|
---|
1133 | LogFlowFunc(("off=%RGp cb=%u\n", off, cb));
|
---|
1134 |
|
---|
1135 | switch (off)
|
---|
1136 | {
|
---|
1137 | case QEU_FW_CFG_MMIO_OFF_DATA: /* Readonly, ignore */
|
---|
1138 | break;
|
---|
1139 | case QEU_FW_CFG_MMIO_OFF_SELECTOR:
|
---|
1140 | {
|
---|
1141 | if (cb == sizeof(uint16_t))
|
---|
1142 | qemuFwCfgItemSelect(pThis, RT_BE2H_U16(*(uint16_t *)pv));
|
---|
1143 | else
|
---|
1144 | rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "offMmio=%#x cb=%d\n", off, cb);
|
---|
1145 | break;
|
---|
1146 | }
|
---|
1147 | case QEU_FW_CFG_MMIO_OFF_DMA:
|
---|
1148 | {
|
---|
1149 | if (cb == sizeof(uint64_t))
|
---|
1150 | {
|
---|
1151 | pThis->GCPhysDma |= ((RTGCPHYS)RT_BE2H_U64(*(uint64_t *)pv));
|
---|
1152 | qemuFwCfgDmaXfer(pThis, pThis->GCPhysDma);
|
---|
1153 | pThis->GCPhysDma = 0;
|
---|
1154 | }
|
---|
1155 | else
|
---|
1156 | rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "offMmio=%#x cb=%d\n", off, cb);
|
---|
1157 | break;
|
---|
1158 | }
|
---|
1159 | default:
|
---|
1160 | rc = PDMDevHlpDBGFStop(pDevIns, RT_SRC_POS, "offMmio=%#x cb=%d\n", off, cb);
|
---|
1161 | break;
|
---|
1162 | }
|
---|
1163 |
|
---|
1164 | LogFlowFunc((" -> rc=%Rrc\n", rc));
|
---|
1165 | return rc;
|
---|
1166 | }
|
---|
1167 |
|
---|
1168 |
|
---|
1169 | /**
|
---|
1170 | * Sets up the initrd memory file and CPIO filesystem stream for writing.
|
---|
1171 | *
|
---|
1172 | * @returns VBox status code.
|
---|
1173 | * @param pThis The QEMU fw config device instance.
|
---|
1174 | * @param phVfsFss Where to return the filesystem stream handle.
|
---|
1175 | */
|
---|
1176 | static int qemuFwCfgCreateOutputArchive(PDEVQEMUFWCFG pThis, PRTVFSFSSTREAM phVfsFss)
|
---|
1177 | {
|
---|
1178 | int rc = RTVfsMemFileCreate(NIL_RTVFSIOSTREAM, 0 /*cbEstimate*/, &pThis->hVfsFileInitrd);
|
---|
1179 | if (RT_SUCCESS(rc))
|
---|
1180 | {
|
---|
1181 | RTVFSFSSTREAM hVfsFss;
|
---|
1182 | RTVFSIOSTREAM hVfsIosOut = RTVfsFileToIoStream(pThis->hVfsFileInitrd);
|
---|
1183 | rc = RTZipTarFsStreamToIoStream(hVfsIosOut, RTZIPTARFORMAT_CPIO_ASCII_NEW, 0 /*fFlags*/, &hVfsFss);
|
---|
1184 | if (RT_SUCCESS(rc))
|
---|
1185 | {
|
---|
1186 | rc = RTZipTarFsStreamSetOwner(hVfsFss, 0, "root");
|
---|
1187 | if (RT_SUCCESS(rc))
|
---|
1188 | rc = RTZipTarFsStreamSetGroup(hVfsFss, 0, "root");
|
---|
1189 |
|
---|
1190 | if (RT_SUCCESS(rc))
|
---|
1191 | *phVfsFss = hVfsFss;
|
---|
1192 | else
|
---|
1193 | {
|
---|
1194 | RTVfsFsStrmRelease(hVfsFss);
|
---|
1195 | *phVfsFss = NIL_RTVFSFSSTREAM;
|
---|
1196 | }
|
---|
1197 | }
|
---|
1198 | RTVfsIoStrmRelease(hVfsIosOut);
|
---|
1199 | }
|
---|
1200 |
|
---|
1201 | return rc;
|
---|
1202 | }
|
---|
1203 |
|
---|
1204 |
|
---|
1205 | /**
|
---|
1206 | * Archives a file.
|
---|
1207 | *
|
---|
1208 | * @returns VBox status code.
|
---|
1209 | * @param hVfsFss The TAR filesystem stream handle.
|
---|
1210 | * @param pszSrc The file path or VFS spec.
|
---|
1211 | * @param pszDst The name to archive the file under.
|
---|
1212 | * @param pErrInfo Error info buffer (saves stack space).
|
---|
1213 | */
|
---|
1214 | static int qemuFwCfgInitrdArchiveFile(RTVFSFSSTREAM hVfsFss, const char *pszSrc,
|
---|
1215 | const char *pszDst, PRTERRINFOSTATIC pErrInfo)
|
---|
1216 | {
|
---|
1217 | /* Open the file. */
|
---|
1218 | uint32_t offError;
|
---|
1219 | RTVFSIOSTREAM hVfsIosSrc;
|
---|
1220 | int rc = RTVfsChainOpenIoStream(pszSrc, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE,
|
---|
1221 | &hVfsIosSrc, &offError, RTErrInfoInitStatic(pErrInfo));
|
---|
1222 | if (RT_FAILURE(rc))
|
---|
1223 | return rc;
|
---|
1224 |
|
---|
1225 | /* I/O stream to base object. */
|
---|
1226 | RTVFSOBJ hVfsObjSrc = RTVfsObjFromIoStream(hVfsIosSrc);
|
---|
1227 | if (hVfsObjSrc != NIL_RTVFSOBJ)
|
---|
1228 | {
|
---|
1229 | /*
|
---|
1230 | * Add it to the stream.
|
---|
1231 | */
|
---|
1232 | rc = RTVfsFsStrmAdd(hVfsFss, pszDst, hVfsObjSrc, 0 /*fFlags*/);
|
---|
1233 | RTVfsIoStrmRelease(hVfsIosSrc);
|
---|
1234 | RTVfsObjRelease(hVfsObjSrc);
|
---|
1235 | return rc;
|
---|
1236 | }
|
---|
1237 | RTVfsIoStrmRelease(hVfsIosSrc);
|
---|
1238 | return VERR_INVALID_POINTER;
|
---|
1239 | }
|
---|
1240 |
|
---|
1241 |
|
---|
1242 | /**
|
---|
1243 | * Archives a symlink.
|
---|
1244 | *
|
---|
1245 | * @returns VBox status code.
|
---|
1246 | * @param hVfsFss The TAR filesystem stream handle.
|
---|
1247 | * @param pszSrc The file path or VFS spec.
|
---|
1248 | * @param pszDst The name to archive the file under.
|
---|
1249 | * @param pErrInfo Error info buffer (saves stack space).
|
---|
1250 | */
|
---|
1251 | static int qemuFwCfgInitrdArchiveSymlink(RTVFSFSSTREAM hVfsFss, const char *pszSrc,
|
---|
1252 | const char *pszDst, PRTERRINFOSTATIC pErrInfo)
|
---|
1253 | {
|
---|
1254 | /* Open the file. */
|
---|
1255 | uint32_t offError;
|
---|
1256 | RTVFSOBJ hVfsObjSrc;
|
---|
1257 | int rc = RTVfsChainOpenObj(pszSrc, RTFILE_O_READ | RTFILE_O_OPEN | RTFILE_O_DENY_NONE,
|
---|
1258 | RTVFSOBJ_F_OPEN_SYMLINK | RTVFSOBJ_F_CREATE_NOTHING | RTPATH_F_ON_LINK,
|
---|
1259 | &hVfsObjSrc, &offError, RTErrInfoInitStatic(pErrInfo));
|
---|
1260 | if (RT_FAILURE(rc))
|
---|
1261 | return rc;
|
---|
1262 |
|
---|
1263 | rc = RTVfsFsStrmAdd(hVfsFss, pszDst, hVfsObjSrc, 0 /*fFlags*/);
|
---|
1264 | RTVfsObjRelease(hVfsObjSrc);
|
---|
1265 | return rc;
|
---|
1266 | }
|
---|
1267 |
|
---|
1268 |
|
---|
1269 | /**
|
---|
1270 | * Sub-directory helper for creating archives.
|
---|
1271 | *
|
---|
1272 | * @returns VBox status code.
|
---|
1273 | * @param hVfsFss The TAR filesystem stream handle.
|
---|
1274 | * @param pszSrc The directory path or VFS spec. We append to the
|
---|
1275 | * buffer as we decend.
|
---|
1276 | * @param cchSrc The length of the input.
|
---|
1277 | * @param pszDst The name to archive it the under. We append to the
|
---|
1278 | * buffer as we decend.
|
---|
1279 | * @param cchDst The length of the input.
|
---|
1280 | * @param pDirEntry Directory entry to use for the directory to handle.
|
---|
1281 | * @param pErrInfo Error info buffer (saves stack space).
|
---|
1282 | */
|
---|
1283 | static int qemuFwCfgInitrdArchiveDirSub(RTVFSFSSTREAM hVfsFss,
|
---|
1284 | char *pszSrc, size_t cchSrc,
|
---|
1285 | char pszDst[RTPATH_MAX], size_t cchDst, PRTDIRENTRYEX pDirEntry,
|
---|
1286 | PRTERRINFOSTATIC pErrInfo)
|
---|
1287 | {
|
---|
1288 | uint32_t offError;
|
---|
1289 | RTVFSDIR hVfsIoDir;
|
---|
1290 | int rc = RTVfsChainOpenDir(pszSrc, 0 /*fFlags*/,
|
---|
1291 | &hVfsIoDir, &offError, RTErrInfoInitStatic(pErrInfo));
|
---|
1292 | if (RT_FAILURE(rc))
|
---|
1293 | return rc;
|
---|
1294 |
|
---|
1295 | /* Make sure we've got some room in the path, to save us extra work further down. */
|
---|
1296 | if (cchSrc + 3 >= RTPATH_MAX)
|
---|
1297 | return VERR_FILENAME_TOO_LONG;
|
---|
1298 |
|
---|
1299 | /* Ensure we've got a trailing slash (there is space for it see above). */
|
---|
1300 | if (!RTPATH_IS_SEP(pszSrc[cchSrc - 1]))
|
---|
1301 | {
|
---|
1302 | pszSrc[cchSrc++] = RTPATH_SLASH;
|
---|
1303 | pszSrc[cchSrc] = '\0';
|
---|
1304 | }
|
---|
1305 |
|
---|
1306 | /* Ditto for destination. */
|
---|
1307 | if (cchDst + 3 >= RTPATH_MAX)
|
---|
1308 | return VERR_FILENAME_TOO_LONG;
|
---|
1309 |
|
---|
1310 | /* Don't try adding the root directory. */
|
---|
1311 | if (*pszDst != '\0')
|
---|
1312 | {
|
---|
1313 | RTVFSOBJ hVfsObjSrc = RTVfsObjFromDir(hVfsIoDir);
|
---|
1314 | rc = RTVfsFsStrmAdd(hVfsFss, pszDst, hVfsObjSrc, 0 /*fFlags*/);
|
---|
1315 | RTVfsObjRelease(hVfsObjSrc);
|
---|
1316 | if (RT_FAILURE(rc))
|
---|
1317 | return rc;
|
---|
1318 |
|
---|
1319 | if (!RTPATH_IS_SEP(pszDst[cchDst - 1]))
|
---|
1320 | {
|
---|
1321 | pszDst[cchDst++] = RTPATH_SLASH;
|
---|
1322 | pszDst[cchDst] = '\0';
|
---|
1323 | }
|
---|
1324 | }
|
---|
1325 |
|
---|
1326 | /*
|
---|
1327 | * Process the files and subdirs.
|
---|
1328 | */
|
---|
1329 | for (;;)
|
---|
1330 | {
|
---|
1331 | size_t cbDirEntry = QEMUFWCFG_DIRENTRY_BUF_SIZE;
|
---|
1332 | rc = RTVfsDirReadEx(hVfsIoDir, pDirEntry, &cbDirEntry, RTFSOBJATTRADD_UNIX);
|
---|
1333 | if (RT_FAILURE(rc))
|
---|
1334 | break;
|
---|
1335 |
|
---|
1336 | /* Check length. */
|
---|
1337 | if (pDirEntry->cbName + cchSrc + 3 >= RTPATH_MAX)
|
---|
1338 | {
|
---|
1339 | rc = VERR_BUFFER_OVERFLOW;
|
---|
1340 | break;
|
---|
1341 | }
|
---|
1342 |
|
---|
1343 | switch (pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK)
|
---|
1344 | {
|
---|
1345 | case RTFS_TYPE_DIRECTORY:
|
---|
1346 | {
|
---|
1347 | if (RTDirEntryExIsStdDotLink(pDirEntry))
|
---|
1348 | continue;
|
---|
1349 |
|
---|
1350 | memcpy(&pszSrc[cchSrc], pDirEntry->szName, pDirEntry->cbName + 1);
|
---|
1351 | memcpy(&pszDst[cchDst], pDirEntry->szName, pDirEntry->cbName + 1);
|
---|
1352 | rc = qemuFwCfgInitrdArchiveDirSub(hVfsFss, pszSrc, cchSrc + pDirEntry->cbName,
|
---|
1353 | pszDst, cchDst + pDirEntry->cbName, pDirEntry, pErrInfo);
|
---|
1354 | break;
|
---|
1355 | }
|
---|
1356 |
|
---|
1357 | case RTFS_TYPE_FILE:
|
---|
1358 | {
|
---|
1359 | memcpy(&pszSrc[cchSrc], pDirEntry->szName, pDirEntry->cbName + 1);
|
---|
1360 | memcpy(&pszDst[cchDst], pDirEntry->szName, pDirEntry->cbName + 1);
|
---|
1361 | rc = qemuFwCfgInitrdArchiveFile(hVfsFss, pszSrc, pszDst, pErrInfo);
|
---|
1362 | break;
|
---|
1363 | }
|
---|
1364 |
|
---|
1365 | case RTFS_TYPE_SYMLINK:
|
---|
1366 | {
|
---|
1367 | memcpy(&pszSrc[cchSrc], pDirEntry->szName, pDirEntry->cbName + 1);
|
---|
1368 | memcpy(&pszDst[cchDst], pDirEntry->szName, pDirEntry->cbName + 1);
|
---|
1369 | rc = qemuFwCfgInitrdArchiveSymlink(hVfsFss, pszSrc, pszDst, pErrInfo);
|
---|
1370 | break;
|
---|
1371 | }
|
---|
1372 |
|
---|
1373 | default:
|
---|
1374 | {
|
---|
1375 | LogRel(("Warning: File system type %#x for '%s' not implemented yet, sorry! Skipping ...\n",
|
---|
1376 | pDirEntry->Info.Attr.fMode & RTFS_TYPE_MASK, pDirEntry->szName));
|
---|
1377 | break;
|
---|
1378 | }
|
---|
1379 | }
|
---|
1380 | }
|
---|
1381 |
|
---|
1382 | if (rc == VERR_NO_MORE_FILES)
|
---|
1383 | rc = VINF_SUCCESS;
|
---|
1384 |
|
---|
1385 | RTVfsDirRelease(hVfsIoDir);
|
---|
1386 | return rc;
|
---|
1387 | }
|
---|
1388 |
|
---|
1389 |
|
---|
1390 | /**
|
---|
1391 | * Archives a directory recursively.
|
---|
1392 | *
|
---|
1393 | * @returns VBox status code.
|
---|
1394 | * @param hVfsFss The CPIO filesystem stream handle.
|
---|
1395 | * @param pszSrc The directory path or VFS spec. We append to the
|
---|
1396 | * buffer as we decend.
|
---|
1397 | * @param cchSrc The length of the input.
|
---|
1398 | * @param pszDst The name to archive it the under. We append to the
|
---|
1399 | * buffer as we decend.
|
---|
1400 | * @param cchDst The length of the input.
|
---|
1401 | * @param pErrInfo Error info buffer (saves stack space).
|
---|
1402 | */
|
---|
1403 | static int qemuFwCfgInitrdArchiveDir(RTVFSFSSTREAM hVfsFss, char pszSrc[RTPATH_MAX], size_t cchSrc,
|
---|
1404 | char pszDst[RTPATH_MAX], size_t cchDst,
|
---|
1405 | PRTERRINFOSTATIC pErrInfo)
|
---|
1406 | {
|
---|
1407 | RT_NOREF(cchSrc);
|
---|
1408 |
|
---|
1409 | char szSrcAbs[RTPATH_MAX];
|
---|
1410 | int rc = RTPathAbs(pszSrc, szSrcAbs, sizeof(szSrcAbs));
|
---|
1411 | if (RT_FAILURE(rc))
|
---|
1412 | return rc;
|
---|
1413 |
|
---|
1414 | union
|
---|
1415 | {
|
---|
1416 | uint8_t abPadding[QEMUFWCFG_DIRENTRY_BUF_SIZE];
|
---|
1417 | RTDIRENTRYEX DirEntry;
|
---|
1418 | } uBuf;
|
---|
1419 |
|
---|
1420 | return qemuFwCfgInitrdArchiveDirSub(hVfsFss, szSrcAbs, strlen(szSrcAbs), pszDst, cchDst, &uBuf.DirEntry, pErrInfo);
|
---|
1421 | }
|
---|
1422 |
|
---|
1423 |
|
---|
1424 | /**
|
---|
1425 | * Creates an on the fly initramfs for a given root directory.
|
---|
1426 | *
|
---|
1427 | * @returns VBox status code.
|
---|
1428 | * @param pThis The QEMU fw config device instance.
|
---|
1429 | * @param pszPath The path to work on.
|
---|
1430 | */
|
---|
1431 | static int qemuFwCfgInitrdCreate(PDEVQEMUFWCFG pThis, const char *pszPath)
|
---|
1432 | {
|
---|
1433 | /*
|
---|
1434 | * First open the output file.
|
---|
1435 | */
|
---|
1436 | RTVFSFSSTREAM hVfsFss;
|
---|
1437 | int rc = qemuFwCfgCreateOutputArchive(pThis, &hVfsFss);
|
---|
1438 | if (RT_FAILURE(rc))
|
---|
1439 | return rc;
|
---|
1440 |
|
---|
1441 | /*
|
---|
1442 | * Construct/copy the source name.
|
---|
1443 | */
|
---|
1444 | char szSrc[RTPATH_MAX];
|
---|
1445 | rc = RTStrCopy(szSrc, sizeof(szSrc), pszPath);
|
---|
1446 | if (RT_SUCCESS(rc))
|
---|
1447 | {
|
---|
1448 | RTERRINFOSTATIC ErrInfo;
|
---|
1449 | char szDst[RTPATH_MAX]; RT_ZERO(szDst);
|
---|
1450 | rc = qemuFwCfgInitrdArchiveDir(hVfsFss, szSrc, strlen(szSrc),
|
---|
1451 | szDst, strlen(szDst), &ErrInfo);
|
---|
1452 | }
|
---|
1453 |
|
---|
1454 | /*
|
---|
1455 | * Finalize the archive.
|
---|
1456 | */
|
---|
1457 | int rc2 = RTVfsFsStrmEnd(hVfsFss); AssertRC(rc2);
|
---|
1458 | RTVfsFsStrmRelease(hVfsFss);
|
---|
1459 | return rc;
|
---|
1460 | }
|
---|
1461 |
|
---|
1462 |
|
---|
1463 | /**
|
---|
1464 | * Checks whether creation of the initrd should be done on the fly.
|
---|
1465 | *
|
---|
1466 | * @returns VBox status code.
|
---|
1467 | * @param pThis The QEMU fw config device instance.
|
---|
1468 | */
|
---|
1469 | static int qemuFwCfgInitrdMaybeCreate(PDEVQEMUFWCFG pThis)
|
---|
1470 | {
|
---|
1471 | PPDMDEVINS pDevIns = pThis->pDevIns;
|
---|
1472 | PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
|
---|
1473 |
|
---|
1474 | /* Query the path from the CFGM key. */
|
---|
1475 | char *pszFilePath = NULL;
|
---|
1476 | int rc = pHlp->pfnCFGMQueryStringAlloc(pThis->pCfg, "InitrdImage", &pszFilePath);
|
---|
1477 | if (RT_SUCCESS(rc))
|
---|
1478 | {
|
---|
1479 | if (RTDirExists(pszFilePath))
|
---|
1480 | {
|
---|
1481 | rc = qemuFwCfgInitrdCreate(pThis, pszFilePath);
|
---|
1482 | if (RT_FAILURE(rc))
|
---|
1483 | rc = PDMDEV_SET_ERROR(pDevIns, rc,
|
---|
1484 | N_("QemuFwCfg: failed to create the in memory initram filesystem"));
|
---|
1485 | }
|
---|
1486 | /*else: Probably a normal file. */
|
---|
1487 | PDMDevHlpMMHeapFree(pDevIns, pszFilePath);
|
---|
1488 | }
|
---|
1489 | else if (rc != VERR_CFGM_VALUE_NOT_FOUND)
|
---|
1490 | rc = PDMDEV_SET_ERROR(pDevIns, rc,
|
---|
1491 | N_("Configuration error: Querying \"InitrdImage\" as a string failed"));
|
---|
1492 | else
|
---|
1493 | rc = VINF_SUCCESS;
|
---|
1494 |
|
---|
1495 | return rc;
|
---|
1496 | }
|
---|
1497 |
|
---|
1498 |
|
---|
1499 | /**
|
---|
1500 | * Registers a file item with the given name for consumption by the firmware.
|
---|
1501 | *
|
---|
1502 | * @returns VBox status code.
|
---|
1503 | * @param pThis The QEMU fw config device instance.
|
---|
1504 | * @param pszFilename The filename to use.
|
---|
1505 | * @param cbData Size of the file in bytes.
|
---|
1506 | * @param pfnSetup Setup callback - optional.
|
---|
1507 | * @param pfnRead Read callback - optional.
|
---|
1508 | * @param pfnWrite Write callback - optional.
|
---|
1509 | * @param pfnCleanup Cleanup callback when the item gets de-selected - optional.
|
---|
1510 | */
|
---|
1511 | static int qemuFwCfgR3FileRegister(PDEVQEMUFWCFG pThis, const char *pszFilename, uint32_t cbData,
|
---|
1512 | PFNQEMUFWCFGITEMSETUP pfnSetup, PFNQEMUFWCFGITEMREAD pfnRead,
|
---|
1513 | PFNQEMUFWCFGITEMWRITE pfnWrite, PFNQEMUFWCFGITEMCLEANUP pfnCleanup)
|
---|
1514 | {
|
---|
1515 | AssertReturn(strlen(pszFilename) <= QEMU_FW_CFG_ITEM_FILE_NAME_MAX, VERR_FILENAME_TOO_LONG);
|
---|
1516 |
|
---|
1517 | PQEMUFWCFGFILEENTRY pEntry = NULL;
|
---|
1518 | if (pThis->cCfgFiles == pThis->cCfgFilesMax)
|
---|
1519 | {
|
---|
1520 | /* Grow the array. */
|
---|
1521 | PQEMUFWCFGFILEENTRY paCfgFilesNew = (PQEMUFWCFGFILEENTRY)RTMemRealloc(pThis->paCfgFiles,
|
---|
1522 | (pThis->cCfgFilesMax + 10) * sizeof(*pThis->paCfgFiles));
|
---|
1523 | if (!paCfgFilesNew)
|
---|
1524 | return VERR_NO_MEMORY;
|
---|
1525 |
|
---|
1526 | pThis->paCfgFiles = paCfgFilesNew;
|
---|
1527 | pThis->cCfgFilesMax += 10;
|
---|
1528 | }
|
---|
1529 |
|
---|
1530 | pEntry = &pThis->paCfgFiles[pThis->cCfgFiles];
|
---|
1531 | pThis->cCfgFiles++;
|
---|
1532 |
|
---|
1533 | pEntry->cbFile = cbData;
|
---|
1534 | strncpy(&pEntry->szFilename[0], pszFilename, sizeof(pEntry->szFilename));
|
---|
1535 | pEntry->Cfg.uCfgItem = QEMU_FW_CFG_ITEM_FILE_USER_FIRST + pThis->cCfgFiles - 1;
|
---|
1536 | pEntry->Cfg.pszItem = &pEntry->szFilename[0];
|
---|
1537 | pEntry->Cfg.pszCfgmKey = NULL;
|
---|
1538 | pEntry->Cfg.pfnSetup = pfnSetup ? pfnSetup : qemuFwCfgR3SetupFileGeneric;
|
---|
1539 | pEntry->Cfg.pfnRead = pfnRead;
|
---|
1540 | pEntry->Cfg.pfnWrite = pfnWrite;
|
---|
1541 | pEntry->Cfg.pfnCleanup = pfnCleanup;
|
---|
1542 | return VINF_SUCCESS;
|
---|
1543 | }
|
---|
1544 |
|
---|
1545 |
|
---|
1546 | /**
|
---|
1547 | * RAM framebuffer config write callback.
|
---|
1548 | *
|
---|
1549 | * @param pThis The QEMU fw config device instance.
|
---|
1550 | * @param pItem Pointer to the selected item.
|
---|
1551 | * @param off Where to start writing to.
|
---|
1552 | * @param pvBuf The data to write.
|
---|
1553 | * @param cbToWrite How much to write.
|
---|
1554 | * @param pcbWritten Where to store the amount of bytes written.
|
---|
1555 | */
|
---|
1556 | static DECLCALLBACK(int) qemuFwCfgR3RamfbCfgWrite(PDEVQEMUFWCFG pThis, PCQEMUFWCFGITEM pItem, uint32_t off, const void *pvBuf,
|
---|
1557 | uint32_t cbToWrite, uint32_t *pcbWritten)
|
---|
1558 | {
|
---|
1559 | RT_NOREF(pItem);
|
---|
1560 |
|
---|
1561 | AssertReturn(!off && cbToWrite == sizeof(QEMURAMFBCONFIG), VERR_NOT_SUPPORTED);
|
---|
1562 | *pcbWritten = cbToWrite;
|
---|
1563 |
|
---|
1564 | PCQEMURAMFBCONFIG pRamfbCfg = (PCQEMURAMFBCONFIG)pvBuf;
|
---|
1565 | if ( RT_BE2H_U32(pRamfbCfg->u32FourCC) != QEMU_RAMFB_CFG_FORMAT
|
---|
1566 | || RT_BE2H_U32(pRamfbCfg->u32Flags) != 0)
|
---|
1567 | return VERR_NOT_SUPPORTED;
|
---|
1568 |
|
---|
1569 | int const rcLock = PDMDevHlpCritSectEnter(pThis->pDevIns, &pThis->CritSectRamfb, VERR_SEM_BUSY);
|
---|
1570 | PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pThis->pDevIns, &pThis->CritSectRamfb, rcLock);
|
---|
1571 |
|
---|
1572 | pThis->RamfbCfg.GCPhysRamfbBase = RT_BE2H_U64(pRamfbCfg->GCPhysRamfbBase);
|
---|
1573 | pThis->RamfbCfg.cbStride = RT_BE2H_U32(pRamfbCfg->cbStride);
|
---|
1574 | pThis->RamfbCfg.cWidth = RT_BE2H_U32(pRamfbCfg->cWidth);
|
---|
1575 | pThis->RamfbCfg.cHeight = RT_BE2H_U32(pRamfbCfg->cHeight);
|
---|
1576 | pThis->RamfbCfg.u32FourCC = RT_BE2H_U32(pRamfbCfg->u32FourCC);
|
---|
1577 | pThis->RamfbCfg.u32Flags = RT_BE2H_U32(pRamfbCfg->u32Flags);
|
---|
1578 |
|
---|
1579 | if (pThis->pDrvL0)
|
---|
1580 | {
|
---|
1581 | int rc = pThis->pDrvL0->pfnResize(pThis->pDrvL0, QEMU_RAMFB_CFG_BPP * 8, NULL /*pvVRAM*/,
|
---|
1582 | pThis->RamfbCfg.cbStride,
|
---|
1583 | pThis->RamfbCfg.cWidth,
|
---|
1584 | pThis->RamfbCfg.cHeight);
|
---|
1585 | AssertRC(rc);
|
---|
1586 | }
|
---|
1587 |
|
---|
1588 | PDMDevHlpCritSectLeave(pThis->pDevIns, &pThis->CritSectRamfb);
|
---|
1589 |
|
---|
1590 | return VINF_SUCCESS;
|
---|
1591 | }
|
---|
1592 |
|
---|
1593 |
|
---|
1594 | /* -=-=-=-=-=- Ring 3: IDisplayPort -=-=-=-=-=- */
|
---|
1595 |
|
---|
1596 | /**
|
---|
1597 | * @interface_method_impl{PDMIDISPLAYPORT,pfnUpdateDisplay}
|
---|
1598 | */
|
---|
1599 | static DECLCALLBACK(int) qemuFwCfgR3RamfbPortUpdateDisplay(PPDMIDISPLAYPORT pInterface)
|
---|
1600 | {
|
---|
1601 | PDEVQEMUFWCFG pThis = RT_FROM_MEMBER(pInterface, DEVQEMUFWCFG, IPortRamfb);
|
---|
1602 |
|
---|
1603 | LogFlowFunc(("\n"));
|
---|
1604 |
|
---|
1605 | int const rcLock = PDMDevHlpCritSectEnter(pThis->pDevIns, &pThis->CritSectRamfb, VERR_SEM_BUSY);
|
---|
1606 | PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pThis->pDevIns, &pThis->CritSectRamfb, rcLock);
|
---|
1607 |
|
---|
1608 | if ( pThis->fRenderVRam
|
---|
1609 | && pThis->RamfbCfg.GCPhysRamfbBase)
|
---|
1610 | {
|
---|
1611 | if ( pThis->RamfbCfg.cWidth == pThis->pDrvL0->cx
|
---|
1612 | && pThis->RamfbCfg.cHeight == pThis->pDrvL0->cy
|
---|
1613 | && pThis->RamfbCfg.cbStride == pThis->pDrvL0->cbScanline
|
---|
1614 | && pThis->pDrvL0->pbData)
|
---|
1615 | {
|
---|
1616 | PDMDevHlpPhysReadUser(pThis->pDevIns, pThis->RamfbCfg.GCPhysRamfbBase, pThis->pDrvL0->pbData, pThis->RamfbCfg.cbStride * pThis->RamfbCfg.cHeight);
|
---|
1617 | AssertPtr(pThis->pDrvL0);
|
---|
1618 | pThis->pDrvL0->pfnUpdateRect(pThis->pDrvL0, 0, 0, pThis->RamfbCfg.cWidth, pThis->RamfbCfg.cHeight);
|
---|
1619 | }
|
---|
1620 | else
|
---|
1621 | LogFlowFunc(("Framebuffer dimension mismatch ({%u, %u, %u} vs {%u, %u, %u})\n",
|
---|
1622 | pThis->RamfbCfg.cWidth, pThis->RamfbCfg.cHeight, pThis->RamfbCfg.cbStride,
|
---|
1623 | pThis->pDrvL0->cx, pThis->pDrvL0->cy, pThis->pDrvL0->cbScanline));
|
---|
1624 | }
|
---|
1625 | else
|
---|
1626 | LogFlowFunc(("Rendering disabled or no RAM framebuffer set up\n"));
|
---|
1627 |
|
---|
1628 | PDMDevHlpCritSectLeave(pThis->pDevIns, &pThis->CritSectRamfb);
|
---|
1629 | return VINF_SUCCESS;
|
---|
1630 | }
|
---|
1631 |
|
---|
1632 |
|
---|
1633 | /**
|
---|
1634 | * @interface_method_impl{PDMIDISPLAYPORT,pfnUpdateDisplayAll}
|
---|
1635 | */
|
---|
1636 | static DECLCALLBACK(int) qemuFwCfgR3RamfbPortUpdateDisplayAll(PPDMIDISPLAYPORT pInterface, bool fFailOnResize)
|
---|
1637 | {
|
---|
1638 | RT_NOREF(fFailOnResize);
|
---|
1639 | return qemuFwCfgR3RamfbPortUpdateDisplay(pInterface);
|
---|
1640 | }
|
---|
1641 |
|
---|
1642 |
|
---|
1643 | /**
|
---|
1644 | * @interface_method_impl{PDMIDISPLAYPORT,pfnSetRefreshRate}
|
---|
1645 | */
|
---|
1646 | static DECLCALLBACK(int) qemuFwCfgR3RamfbPortSetRefreshRate(PPDMIDISPLAYPORT pInterface, uint32_t cMilliesInterval)
|
---|
1647 | {
|
---|
1648 | PDEVQEMUFWCFG pThis = RT_FROM_MEMBER(pInterface, DEVQEMUFWCFG, IPortRamfb);
|
---|
1649 |
|
---|
1650 | /*
|
---|
1651 | * Update the interval, then restart or stop the timer.
|
---|
1652 | */
|
---|
1653 | ASMAtomicWriteU32(&pThis->cMilliesRefreshInterval, cMilliesInterval);
|
---|
1654 |
|
---|
1655 | if (cMilliesInterval)
|
---|
1656 | return PDMDevHlpTimerSetMillies(pThis->pDevIns, pThis->hRamfbRefreshTimer, cMilliesInterval);
|
---|
1657 | return PDMDevHlpTimerStop(pThis->pDevIns, pThis->hRamfbRefreshTimer);
|
---|
1658 | }
|
---|
1659 |
|
---|
1660 |
|
---|
1661 | /**
|
---|
1662 | * @interface_method_impl{PDMIDISPLAYPORT,pfnQueryVideoMode}
|
---|
1663 | */
|
---|
1664 | static DECLCALLBACK(int) qemuFwCfgR3RamfbPortQueryVideoMode(PPDMIDISPLAYPORT pInterface, uint32_t *pcBits, uint32_t *pcx, uint32_t *pcy)
|
---|
1665 | {
|
---|
1666 | AssertReturn(pcBits, VERR_INVALID_PARAMETER);
|
---|
1667 |
|
---|
1668 | RT_NOREF(pInterface, pcx, pcy);
|
---|
1669 | AssertReleaseFailed();
|
---|
1670 | return VERR_NOT_IMPLEMENTED;
|
---|
1671 | }
|
---|
1672 |
|
---|
1673 |
|
---|
1674 | /**
|
---|
1675 | * @interface_method_impl{PDMIDISPLAYPORT,pfnTakeScreenshot}
|
---|
1676 | */
|
---|
1677 | static DECLCALLBACK(int) qemuFwCfgR3RamfbPortTakeScreenshot(PPDMIDISPLAYPORT pInterface, uint8_t **ppbData, size_t *pcbData,
|
---|
1678 | uint32_t *pcx, uint32_t *pcy)
|
---|
1679 | {
|
---|
1680 | PDEVQEMUFWCFG pThis = RT_FROM_MEMBER(pInterface, DEVQEMUFWCFG, IPortRamfb);
|
---|
1681 |
|
---|
1682 | LogFlowFunc(("\n"));
|
---|
1683 |
|
---|
1684 | int const rcLock = PDMDevHlpCritSectEnter(pThis->pDevIns, &pThis->CritSectRamfb, VERR_SEM_BUSY);
|
---|
1685 | PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pThis->pDevIns, &pThis->CritSectRamfb, rcLock);
|
---|
1686 |
|
---|
1687 | int rc;
|
---|
1688 | size_t cbData = pThis->RamfbCfg.cHeight * pThis->RamfbCfg.cbStride;
|
---|
1689 | if ( pThis->RamfbCfg.GCPhysRamfbBase
|
---|
1690 | && cbData)
|
---|
1691 | {
|
---|
1692 | uint8_t *pbData = (uint8_t *)RTMemAlloc(cbData);
|
---|
1693 | if (pbData)
|
---|
1694 | {
|
---|
1695 | rc = PDMDevHlpPhysReadUser(pThis->pDevIns, pThis->RamfbCfg.GCPhysRamfbBase, pbData, cbData);
|
---|
1696 | if (RT_SUCCESS(rc))
|
---|
1697 | {
|
---|
1698 | *ppbData = pbData;
|
---|
1699 | *pcbData = cbData;
|
---|
1700 | *pcx = pThis->RamfbCfg.cWidth;
|
---|
1701 | *pcy = pThis->RamfbCfg.cHeight;
|
---|
1702 | }
|
---|
1703 | }
|
---|
1704 | else
|
---|
1705 | rc = VERR_NO_MEMORY;
|
---|
1706 | }
|
---|
1707 | else
|
---|
1708 | rc = VERR_NOT_SUPPORTED;
|
---|
1709 |
|
---|
1710 | PDMDevHlpCritSectLeave(pThis->pDevIns, &pThis->CritSectRamfb);
|
---|
1711 | return rc;
|
---|
1712 | }
|
---|
1713 |
|
---|
1714 |
|
---|
1715 | /**
|
---|
1716 | * @interface_method_impl{PDMIDISPLAYPORT,pfnFreeScreenshot}
|
---|
1717 | */
|
---|
1718 | static DECLCALLBACK(void) qemuFwCfgR3RamfbPortFreeScreenshot(PPDMIDISPLAYPORT pInterface, uint8_t *pbData)
|
---|
1719 | {
|
---|
1720 | NOREF(pInterface);
|
---|
1721 | LogFlowFunc(("pbData=%p\n", pbData));
|
---|
1722 | RTMemFree(pbData);
|
---|
1723 | }
|
---|
1724 |
|
---|
1725 |
|
---|
1726 | /**
|
---|
1727 | * @interface_method_impl{PDMIDISPLAYPORT,pfnDisplayBlt}
|
---|
1728 | */
|
---|
1729 | static DECLCALLBACK(int) qemuFwCfgR3RamfbPortDisplayBlt(PPDMIDISPLAYPORT pInterface, const void *pvData,
|
---|
1730 | uint32_t x, uint32_t y, uint32_t cx, uint32_t cy)
|
---|
1731 | {
|
---|
1732 | RT_NOREF(pInterface, pvData, x, y, cx, cy);
|
---|
1733 | AssertReleaseFailed();
|
---|
1734 | return VERR_NOT_IMPLEMENTED;
|
---|
1735 | }
|
---|
1736 |
|
---|
1737 |
|
---|
1738 | /**
|
---|
1739 | * @interface_method_impl{PDMIDISPLAYPORT,pfnUpdateDisplayRect}
|
---|
1740 | */
|
---|
1741 | static DECLCALLBACK(void) qemuFwCfgR3RamfbPortUpdateDisplayRect(PPDMIDISPLAYPORT pInterface, int32_t x, int32_t y,
|
---|
1742 | uint32_t cx, uint32_t cy)
|
---|
1743 | {
|
---|
1744 | RT_NOREF(pInterface, x, y, cx, cy);
|
---|
1745 | AssertReleaseFailed();
|
---|
1746 | }
|
---|
1747 |
|
---|
1748 |
|
---|
1749 | /**
|
---|
1750 | * @interface_method_impl{PDMIDISPLAYPORT,pfnCopyRect}
|
---|
1751 | */
|
---|
1752 | static DECLCALLBACK(int)
|
---|
1753 | qemuFwCfgR3RamfbPortCopyRect(PPDMIDISPLAYPORT pInterface,
|
---|
1754 | uint32_t cx, uint32_t cy,
|
---|
1755 | const uint8_t *pbSrc, int32_t xSrc, int32_t ySrc, uint32_t cxSrc, uint32_t cySrc,
|
---|
1756 | uint32_t cbSrcLine, uint32_t cSrcBitsPerPixel,
|
---|
1757 | uint8_t *pbDst, int32_t xDst, int32_t yDst, uint32_t cxDst, uint32_t cyDst,
|
---|
1758 | uint32_t cbDstLine, uint32_t cDstBitsPerPixel)
|
---|
1759 | {
|
---|
1760 | RT_NOREF(pInterface, cx, cy, pbSrc, xSrc, ySrc, cxSrc, cySrc, cbSrcLine, cSrcBitsPerPixel, pbDst, xDst, yDst, cxDst, cyDst,
|
---|
1761 | cbDstLine, cDstBitsPerPixel);
|
---|
1762 | AssertReleaseFailed();
|
---|
1763 | return VINF_SUCCESS;
|
---|
1764 | }
|
---|
1765 |
|
---|
1766 |
|
---|
1767 | /**
|
---|
1768 | * @interface_method_impl{PDMIDISPLAYPORT,pfnSetRenderVRAM}
|
---|
1769 | */
|
---|
1770 | static DECLCALLBACK(void) qemuFwCfgR3RamfbPortSetRenderVRAM(PPDMIDISPLAYPORT pInterface, bool fRender)
|
---|
1771 | {
|
---|
1772 | PDEVQEMUFWCFG pThis = RT_FROM_MEMBER(pInterface, DEVQEMUFWCFG, IPortRamfb);
|
---|
1773 |
|
---|
1774 | LogFlowFunc(("fRender = %d\n", fRender));
|
---|
1775 |
|
---|
1776 | int const rcLock = PDMDevHlpCritSectEnter(pThis->pDevIns, &pThis->CritSectRamfb, VERR_SEM_BUSY);
|
---|
1777 | PDM_CRITSECT_RELEASE_ASSERT_RC_DEV(pThis->pDevIns, &pThis->CritSectRamfb, rcLock);
|
---|
1778 |
|
---|
1779 | pThis->fRenderVRam = fRender;
|
---|
1780 |
|
---|
1781 | PDMDevHlpCritSectLeave(pThis->pDevIns, &pThis->CritSectRamfb);
|
---|
1782 | }
|
---|
1783 |
|
---|
1784 |
|
---|
1785 | /**
|
---|
1786 | * @interface_method_impl{PDMIDISPLAYPORT,pfnSendModeHint}
|
---|
1787 | */
|
---|
1788 | static DECLCALLBACK(int) qemuFwCfgR3RamfbPortSendModeHint(PPDMIDISPLAYPORT pInterface, uint32_t cx, uint32_t cy, uint32_t cBPP,
|
---|
1789 | uint32_t iDisplay, uint32_t dx, uint32_t dy, uint32_t fEnabled, uint32_t fNotifyGuest)
|
---|
1790 | {
|
---|
1791 | RT_NOREF(pInterface, cx, cy, cBPP, iDisplay, dx, dy, fEnabled, fNotifyGuest);
|
---|
1792 | return VINF_SUCCESS;
|
---|
1793 | }
|
---|
1794 |
|
---|
1795 |
|
---|
1796 | /**
|
---|
1797 | * @interface_method_impl{PDMIDISPLAYPORT,pfnReportHostCursorCapabilities}
|
---|
1798 | */
|
---|
1799 | static DECLCALLBACK(void) qemuFwCfgR3RamfbPortReportHostCursorCapabilities(PPDMIDISPLAYPORT pInterface, bool fSupportsRenderCursor,
|
---|
1800 | bool fSupportsMoveCursor)
|
---|
1801 | {
|
---|
1802 | RT_NOREF(pInterface, fSupportsRenderCursor, fSupportsMoveCursor);
|
---|
1803 | }
|
---|
1804 |
|
---|
1805 |
|
---|
1806 | /**
|
---|
1807 | * @interface_method_impl{PDMIDISPLAYPORT,pfnReportHostCursorPosition}
|
---|
1808 | */
|
---|
1809 | static DECLCALLBACK(void) qemuFwCfgR3RamfbPortReportHostCursorPosition(PPDMIDISPLAYPORT pInterface, uint32_t x, uint32_t y, bool fOutOfRange)
|
---|
1810 | {
|
---|
1811 | RT_NOREF(pInterface, x, y, fOutOfRange);
|
---|
1812 | }
|
---|
1813 |
|
---|
1814 |
|
---|
1815 | /**
|
---|
1816 | * @callback_method_impl{FNTMTIMERDEV, VGA Refresh Timer}
|
---|
1817 | */
|
---|
1818 | static DECLCALLBACK(void) qemuFwCfgR3RamfbTimerRefresh(PPDMDEVINS pDevIns, TMTIMERHANDLE hTimer, void *pvUser)
|
---|
1819 | {
|
---|
1820 | PDEVQEMUFWCFG pThis = PDMDEVINS_2_DATA(pDevIns, PDEVQEMUFWCFG);
|
---|
1821 | RT_NOREF(pvUser);
|
---|
1822 |
|
---|
1823 | if (pThis->pDrvL0)
|
---|
1824 | pThis->pDrvL0->pfnRefresh(pThis->pDrvL0);
|
---|
1825 |
|
---|
1826 | if (pThis->cMilliesRefreshInterval)
|
---|
1827 | PDMDevHlpTimerSetMillies(pDevIns, hTimer, pThis->cMilliesRefreshInterval);
|
---|
1828 | }
|
---|
1829 |
|
---|
1830 |
|
---|
1831 | /* -=-=-=-=-=- Ring 3: IBase -=-=-=-=-=- */
|
---|
1832 |
|
---|
1833 | /**
|
---|
1834 | * @interface_method_impl{PDMIBASE,pfnQueryInterface}
|
---|
1835 | */
|
---|
1836 | static DECLCALLBACK(void *) qemuFwCfgR3PortQueryInterface(PPDMIBASE pInterface, const char *pszIID)
|
---|
1837 | {
|
---|
1838 | PDEVQEMUFWCFG pThis = RT_FROM_MEMBER(pInterface, DEVQEMUFWCFG, IBase);
|
---|
1839 | PDMIBASE_RETURN_INTERFACE(pszIID, PDMIBASE, &pThis->IBase);
|
---|
1840 | if (pThis->fRamfbSupported)
|
---|
1841 | PDMIBASE_RETURN_INTERFACE(pszIID, PDMIDISPLAYPORT, &pThis->IPortRamfb);
|
---|
1842 | return NULL;
|
---|
1843 | }
|
---|
1844 |
|
---|
1845 |
|
---|
1846 | /**
|
---|
1847 | * @interface_method_impl{PDMDEVREG,pfnReset}
|
---|
1848 | */
|
---|
1849 | static DECLCALLBACK(void) qemuFwCfgReset(PPDMDEVINS pDevIns)
|
---|
1850 | {
|
---|
1851 | PDEVQEMUFWCFG pThis = PDMDEVINS_2_DATA(pDevIns, PDEVQEMUFWCFG);
|
---|
1852 |
|
---|
1853 | qemuFwCfgR3ItemReset(pThis);
|
---|
1854 | pThis->GCPhysDma = 0;
|
---|
1855 |
|
---|
1856 | if (pThis->hVfsFileInitrd != NIL_RTVFSFILE)
|
---|
1857 | RTVfsFileRelease(pThis->hVfsFileInitrd);
|
---|
1858 | pThis->hVfsFileInitrd = NIL_RTVFSFILE;
|
---|
1859 |
|
---|
1860 | qemuFwCfgInitrdMaybeCreate(pThis); /* Ignores status code. */
|
---|
1861 | }
|
---|
1862 |
|
---|
1863 |
|
---|
1864 | /**
|
---|
1865 | * @interface_method_impl{PDMDEVREG,pfnAttach}
|
---|
1866 | *
|
---|
1867 | * This is like plugging in the monitor after turning on the PC.
|
---|
1868 | */
|
---|
1869 | static DECLCALLBACK(int) qemuFwCfgR3Attach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
|
---|
1870 | {
|
---|
1871 | PDEVQEMUFWCFG pThis = PDMDEVINS_2_DATA(pDevIns, PDEVQEMUFWCFG);
|
---|
1872 |
|
---|
1873 | AssertMsgReturn(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG,
|
---|
1874 | ("QEMU RAM framebuffer device does not support hotplugging\n"),
|
---|
1875 | VERR_INVALID_PARAMETER);
|
---|
1876 |
|
---|
1877 | switch (iLUN)
|
---|
1878 | {
|
---|
1879 | /* LUN #0: Display port. */
|
---|
1880 | case 0:
|
---|
1881 | {
|
---|
1882 | AssertLogRelMsgReturn(pThis->fRamfbSupported,
|
---|
1883 | ("QemuFwCfg: Trying to attach a display without the RAM framebuffer support being enabled!\n"),
|
---|
1884 | VERR_NOT_SUPPORTED);
|
---|
1885 |
|
---|
1886 | int rc = PDMDevHlpDriverAttach(pDevIns, iLUN, &pThis->IBase, &pThis->pDrvBaseL0, "Display Port");
|
---|
1887 | if (RT_SUCCESS(rc))
|
---|
1888 | {
|
---|
1889 | pThis->pDrvL0 = PDMIBASE_QUERY_INTERFACE(pThis->pDrvBaseL0, PDMIDISPLAYCONNECTOR);
|
---|
1890 | if (pThis->pDrvL0)
|
---|
1891 | {
|
---|
1892 | /* pThis->pDrvL0->pbData can be NULL when there is no framebuffer. */
|
---|
1893 | if ( pThis->pDrvL0->pfnRefresh
|
---|
1894 | && pThis->pDrvL0->pfnResize
|
---|
1895 | && pThis->pDrvL0->pfnUpdateRect)
|
---|
1896 | rc = VINF_SUCCESS;
|
---|
1897 | else
|
---|
1898 | {
|
---|
1899 | Assert(pThis->pDrvL0->pfnRefresh);
|
---|
1900 | Assert(pThis->pDrvL0->pfnResize);
|
---|
1901 | Assert(pThis->pDrvL0->pfnUpdateRect);
|
---|
1902 | pThis->pDrvL0 = NULL;
|
---|
1903 | pThis->pDrvBaseL0 = NULL;
|
---|
1904 | rc = VERR_INTERNAL_ERROR;
|
---|
1905 | }
|
---|
1906 | }
|
---|
1907 | else
|
---|
1908 | {
|
---|
1909 | AssertMsgFailed(("LUN #0 doesn't have a display connector interface! rc=%Rrc\n", rc));
|
---|
1910 | pThis->pDrvBaseL0 = NULL;
|
---|
1911 | rc = VERR_PDM_MISSING_INTERFACE;
|
---|
1912 | }
|
---|
1913 | }
|
---|
1914 | else if (rc == VERR_PDM_NO_ATTACHED_DRIVER)
|
---|
1915 | {
|
---|
1916 | Log(("%s/%d: warning: no driver attached to LUN #0!\n", pDevIns->pReg->szName, pDevIns->iInstance));
|
---|
1917 | rc = VINF_SUCCESS;
|
---|
1918 | }
|
---|
1919 | else
|
---|
1920 | AssertLogRelMsgFailed(("Failed to attach LUN #0! rc=%Rrc\n", rc));
|
---|
1921 | return rc;
|
---|
1922 | }
|
---|
1923 |
|
---|
1924 | default:
|
---|
1925 | AssertMsgFailed(("Invalid LUN #%d\n", iLUN));
|
---|
1926 | return VERR_PDM_NO_SUCH_LUN;
|
---|
1927 | }
|
---|
1928 | }
|
---|
1929 |
|
---|
1930 |
|
---|
1931 | /**
|
---|
1932 | * @interface_method_impl{PDMDEVREG,pfnDetach}
|
---|
1933 | *
|
---|
1934 | * This is like unplugging the monitor while the PC is still running.
|
---|
1935 | */
|
---|
1936 | static DECLCALLBACK(void) qemuFwCfgR3Detach(PPDMDEVINS pDevIns, unsigned iLUN, uint32_t fFlags)
|
---|
1937 | {
|
---|
1938 | PDEVQEMUFWCFG pThis = PDMDEVINS_2_DATA(pDevIns, PDEVQEMUFWCFG);
|
---|
1939 | AssertMsg(fFlags & PDM_TACH_FLAGS_NOT_HOT_PLUG, ("QEMU RAM framebuffer device does not support hotplugging\n"));
|
---|
1940 | RT_NOREF(fFlags);
|
---|
1941 |
|
---|
1942 | /*
|
---|
1943 | * Reset the interfaces and update the controller state.
|
---|
1944 | */
|
---|
1945 | switch (iLUN)
|
---|
1946 | {
|
---|
1947 | /* LUN #0: Display port. */
|
---|
1948 | case 0:
|
---|
1949 | AssertLogRelMsg(pThis->fRamfbSupported,
|
---|
1950 | ("QemuFwCfg: Trying to detach a display without the RAM framebuffer support being enabled!\n"));
|
---|
1951 |
|
---|
1952 | pThis->pDrvL0 = NULL;
|
---|
1953 | pThis->pDrvBaseL0 = NULL;
|
---|
1954 | break;
|
---|
1955 |
|
---|
1956 | default:
|
---|
1957 | AssertMsgFailed(("Invalid LUN #%d\n", iLUN));
|
---|
1958 | break;
|
---|
1959 | }
|
---|
1960 | }
|
---|
1961 |
|
---|
1962 |
|
---|
1963 | /**
|
---|
1964 | * @interface_method_impl{PDMDEVREG,pfnDestruct}
|
---|
1965 | */
|
---|
1966 | static DECLCALLBACK(int) qemuFwCfgDestruct(PPDMDEVINS pDevIns)
|
---|
1967 | {
|
---|
1968 | PDMDEV_CHECK_VERSIONS_RETURN_QUIET(pDevIns);
|
---|
1969 | PDEVQEMUFWCFG pThis = PDMDEVINS_2_DATA(pDevIns, PDEVQEMUFWCFG);
|
---|
1970 |
|
---|
1971 | qemuFwCfgR3ItemReset(pThis);
|
---|
1972 | pThis->GCPhysDma = 0;
|
---|
1973 |
|
---|
1974 | if (pThis->paCfgFiles)
|
---|
1975 | {
|
---|
1976 | Assert(pThis->cCfgFiles && pThis->cCfgFilesMax);
|
---|
1977 | RTMemFree(pThis->paCfgFiles);
|
---|
1978 | pThis->paCfgFiles = NULL;
|
---|
1979 | pThis->cCfgFiles = 0;
|
---|
1980 | pThis->cCfgFilesMax = 0;
|
---|
1981 | }
|
---|
1982 | else
|
---|
1983 | Assert(!pThis->cCfgFiles && !pThis->cCfgFilesMax);
|
---|
1984 |
|
---|
1985 | if (pThis->hVfsFileInitrd != NIL_RTVFSFILE)
|
---|
1986 | RTVfsFileRelease(pThis->hVfsFileInitrd);
|
---|
1987 | pThis->hVfsFileInitrd = NIL_RTVFSFILE;
|
---|
1988 |
|
---|
1989 | return VINF_SUCCESS;
|
---|
1990 | }
|
---|
1991 |
|
---|
1992 |
|
---|
1993 | /**
|
---|
1994 | * @interface_method_impl{PDMDEVREG,pfnConstruct}
|
---|
1995 | */
|
---|
1996 | static DECLCALLBACK(int) qemuFwCfgConstruct(PPDMDEVINS pDevIns, int iInstance, PCFGMNODE pCfg)
|
---|
1997 | {
|
---|
1998 | PDMDEV_CHECK_VERSIONS_RETURN(pDevIns);
|
---|
1999 | PDEVQEMUFWCFG pThis = PDMDEVINS_2_DATA(pDevIns, PDEVQEMUFWCFG);
|
---|
2000 | PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
|
---|
2001 | Assert(iInstance == 0); RT_NOREF(iInstance);
|
---|
2002 |
|
---|
2003 | /*
|
---|
2004 | * Validate configuration.
|
---|
2005 | */
|
---|
2006 | PDMDEV_VALIDATE_CONFIG_RETURN(pDevIns, "DmaEnabled"
|
---|
2007 | "|MmioBase"
|
---|
2008 | "|MmioSize"
|
---|
2009 | "|KernelImage"
|
---|
2010 | "|InitrdImage"
|
---|
2011 | "|SetupImage"
|
---|
2012 | "|CmdLine"
|
---|
2013 | "|QemuRamfbSupport",
|
---|
2014 | "");
|
---|
2015 |
|
---|
2016 | int rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "DmaEnabled", &pThis->fDmaEnabled, false);
|
---|
2017 | if (RT_FAILURE(rc))
|
---|
2018 | return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to read \"DmaEnabled\""));
|
---|
2019 |
|
---|
2020 | /*
|
---|
2021 | * Init the data.
|
---|
2022 | */
|
---|
2023 | pThis->pDevIns = pDevIns;
|
---|
2024 | pThis->pCfg = pCfg;
|
---|
2025 | pThis->u32Version = QEMU_FW_CFG_VERSION_LEGACY | (pThis->fDmaEnabled ? QEMU_FW_CFG_VERSION_DMA : 0);
|
---|
2026 | pThis->GCPhysDma = 0;
|
---|
2027 | pThis->hVfsFileInitrd = NIL_RTVFSFILE;
|
---|
2028 | pThis->paCfgFiles = NULL;
|
---|
2029 | pThis->cCfgFiles = 0;
|
---|
2030 | pThis->cCfgFilesMax = 0;
|
---|
2031 |
|
---|
2032 | pThis->IBase.pfnQueryInterface = qemuFwCfgR3PortQueryInterface;
|
---|
2033 |
|
---|
2034 | pThis->IPortRamfb.pfnUpdateDisplay = qemuFwCfgR3RamfbPortUpdateDisplay;
|
---|
2035 | pThis->IPortRamfb.pfnUpdateDisplayAll = qemuFwCfgR3RamfbPortUpdateDisplayAll;
|
---|
2036 | pThis->IPortRamfb.pfnQueryVideoMode = qemuFwCfgR3RamfbPortQueryVideoMode;
|
---|
2037 | pThis->IPortRamfb.pfnSetRefreshRate = qemuFwCfgR3RamfbPortSetRefreshRate;
|
---|
2038 | pThis->IPortRamfb.pfnTakeScreenshot = qemuFwCfgR3RamfbPortTakeScreenshot;
|
---|
2039 | pThis->IPortRamfb.pfnFreeScreenshot = qemuFwCfgR3RamfbPortFreeScreenshot;
|
---|
2040 | pThis->IPortRamfb.pfnDisplayBlt = qemuFwCfgR3RamfbPortDisplayBlt;
|
---|
2041 | pThis->IPortRamfb.pfnUpdateDisplayRect = qemuFwCfgR3RamfbPortUpdateDisplayRect;
|
---|
2042 | pThis->IPortRamfb.pfnCopyRect = qemuFwCfgR3RamfbPortCopyRect;
|
---|
2043 | pThis->IPortRamfb.pfnSetRenderVRAM = qemuFwCfgR3RamfbPortSetRenderVRAM;
|
---|
2044 | pThis->IPortRamfb.pfnSetViewport = NULL;
|
---|
2045 | pThis->IPortRamfb.pfnReportMonitorPositions = NULL;
|
---|
2046 | pThis->IPortRamfb.pfnSendModeHint = qemuFwCfgR3RamfbPortSendModeHint;
|
---|
2047 | pThis->IPortRamfb.pfnReportHostCursorCapabilities = qemuFwCfgR3RamfbPortReportHostCursorCapabilities;
|
---|
2048 | pThis->IPortRamfb.pfnReportHostCursorPosition = qemuFwCfgR3RamfbPortReportHostCursorPosition;
|
---|
2049 |
|
---|
2050 | RTGCPHYS GCPhysMmioBase = 0;
|
---|
2051 | rc = pHlp->pfnCFGMQueryU64(pCfg, "MmioBase", &GCPhysMmioBase);
|
---|
2052 | if (RT_FAILURE(rc) && rc != VERR_CFGM_VALUE_NOT_FOUND)
|
---|
2053 | return PDMDEV_SET_ERROR(pDevIns, rc,
|
---|
2054 | N_("Configuration error: Failed to get the \"MmioBase\" value"));
|
---|
2055 | if (rc == VERR_CFGM_VALUE_NOT_FOUND)
|
---|
2056 | {
|
---|
2057 | /*
|
---|
2058 | * Register standard I/O Ports
|
---|
2059 | */
|
---|
2060 | IOMIOPORTHANDLE hIoPorts;
|
---|
2061 | rc = PDMDevHlpIoPortCreateFlagsAndMap(pDevIns, QEMU_FW_CFG_IO_PORT_START, QEMU_FW_CFG_IO_PORT_SIZE, 0 /*fFlags*/,
|
---|
2062 | qemuFwCfgIoPortWrite, qemuFwCfgIoPortRead,
|
---|
2063 | "QEMU firmware configuration", NULL /*paExtDescs*/, &hIoPorts);
|
---|
2064 | AssertRCReturn(rc, rc);
|
---|
2065 | }
|
---|
2066 | else
|
---|
2067 | {
|
---|
2068 | uint32_t cbMmio = 0;
|
---|
2069 | rc = pHlp->pfnCFGMQueryU32(pCfg, "MmioSize", &cbMmio);
|
---|
2070 | if (RT_FAILURE(rc))
|
---|
2071 | return PDMDEV_SET_ERROR(pDevIns, rc,
|
---|
2072 | N_("Configuration error: Failed to get the \"MmioSize\" value"));
|
---|
2073 |
|
---|
2074 | /*
|
---|
2075 | * Register and map the MMIO region.
|
---|
2076 | */
|
---|
2077 | IOMMMIOHANDLE hMmio;
|
---|
2078 | rc = PDMDevHlpMmioCreateAndMap(pDevIns, GCPhysMmioBase, cbMmio, qemuFwCfgMmioWrite, qemuFwCfgMmioRead,
|
---|
2079 | IOMMMIO_FLAGS_READ_PASSTHRU | IOMMMIO_FLAGS_WRITE_PASSTHRU, "QemuFwCfg", &hMmio);
|
---|
2080 | AssertRCReturn(rc, rc);
|
---|
2081 | }
|
---|
2082 |
|
---|
2083 | qemuFwCfgR3ItemReset(pThis);
|
---|
2084 |
|
---|
2085 | /* Setup the RAM based framebuffer support if configured. */
|
---|
2086 | rc = pHlp->pfnCFGMQueryBoolDef(pCfg, "QemuRamfbSupport", &pThis->fRamfbSupported, false);
|
---|
2087 | if (RT_FAILURE(rc))
|
---|
2088 | return PDMDEV_SET_ERROR(pDevIns, rc, N_("Configuration error: Failed to read \"QemuRamfbSupport\""));
|
---|
2089 |
|
---|
2090 | if (pThis->fRamfbSupported)
|
---|
2091 | {
|
---|
2092 | LogRel(("QemuFwCfg: RAM based framebuffer support enabled\n"));
|
---|
2093 | if (!pThis->fDmaEnabled)
|
---|
2094 | return PDMDEV_SET_ERROR(pDevIns, VERR_INVALID_PARAMETER, N_("Configuration error: Enabling \"QemuRamfbSupport\" requires \"DmaEnabled\""));
|
---|
2095 |
|
---|
2096 | /* Critical section for synchronizing access. */
|
---|
2097 | rc = PDMDevHlpCritSectInit(pDevIns, &pThis->CritSectRamfb, RT_SRC_POS, "Ramfb#%u", iInstance);
|
---|
2098 | AssertRCReturn(rc, rc);
|
---|
2099 |
|
---|
2100 | /*
|
---|
2101 | * Create the refresh timer.
|
---|
2102 | */
|
---|
2103 | rc = PDMDevHlpTimerCreate(pDevIns, TMCLOCK_REAL, qemuFwCfgR3RamfbTimerRefresh, NULL,
|
---|
2104 | TMTIMER_FLAGS_NO_CRIT_SECT | TMTIMER_FLAGS_NO_RING0, "Ramfb Refresh", &pThis->hRamfbRefreshTimer);
|
---|
2105 | AssertRCReturn(rc, rc);
|
---|
2106 |
|
---|
2107 | /* Register a config file item and attach the driver below us. */
|
---|
2108 | rc = qemuFwCfgR3Attach(pDevIns, 0 /* display LUN # */, PDM_TACH_FLAGS_NOT_HOT_PLUG);
|
---|
2109 | AssertRCReturn(rc, rc);
|
---|
2110 |
|
---|
2111 | rc = qemuFwCfgR3FileRegister(pThis, "etc/ramfb", sizeof(pThis->RamfbCfg),
|
---|
2112 | NULL /* pfnSetup */, NULL /*pfnRead*/,
|
---|
2113 | qemuFwCfgR3RamfbCfgWrite, NULL /*pfnCleanup*/);
|
---|
2114 | AssertRCReturn(rc, rc);
|
---|
2115 | }
|
---|
2116 |
|
---|
2117 | rc = qemuFwCfgInitrdMaybeCreate(pThis);
|
---|
2118 | if (RT_FAILURE(rc))
|
---|
2119 | return rc; /* Error set. */
|
---|
2120 |
|
---|
2121 | return VINF_SUCCESS;
|
---|
2122 | }
|
---|
2123 |
|
---|
2124 |
|
---|
2125 | /**
|
---|
2126 | * The device registration structure.
|
---|
2127 | */
|
---|
2128 | const PDMDEVREG g_DeviceQemuFwCfg =
|
---|
2129 | {
|
---|
2130 | /* .u32Version = */ PDM_DEVREG_VERSION,
|
---|
2131 | /* .uReserved0 = */ 0,
|
---|
2132 | /* .szName = */ "qemu-fw-cfg",
|
---|
2133 | /* .fFlags = */ PDM_DEVREG_FLAGS_DEFAULT_BITS | PDM_DEVREG_FLAGS_NEW_STYLE,
|
---|
2134 | /* .fClass = */ PDM_DEVREG_CLASS_ARCH,
|
---|
2135 | /* .cMaxInstances = */ 1,
|
---|
2136 | /* .uSharedVersion = */ 42,
|
---|
2137 | /* .cbInstanceShared = */ sizeof(DEVQEMUFWCFG),
|
---|
2138 | /* .cbInstanceCC = */ 0,
|
---|
2139 | /* .cbInstanceRC = */ 0,
|
---|
2140 | /* .cMaxPciDevices = */ 0,
|
---|
2141 | /* .cMaxMsixVectors = */ 0,
|
---|
2142 | /* .pszDescription = */ "QEMU Firmware Config compatible device",
|
---|
2143 | #if defined(IN_RING3)
|
---|
2144 | /* .pszRCMod = */ "",
|
---|
2145 | /* .pszR0Mod = */ "",
|
---|
2146 | /* .pfnConstruct = */ qemuFwCfgConstruct,
|
---|
2147 | /* .pfnDestruct = */ qemuFwCfgDestruct,
|
---|
2148 | /* .pfnRelocate = */ NULL,
|
---|
2149 | /* .pfnMemSetup = */ NULL,
|
---|
2150 | /* .pfnPowerOn = */ NULL,
|
---|
2151 | /* .pfnReset = */ qemuFwCfgReset,
|
---|
2152 | /* .pfnSuspend = */ NULL,
|
---|
2153 | /* .pfnResume = */ NULL,
|
---|
2154 | /* .pfnAttach = */ qemuFwCfgR3Attach,
|
---|
2155 | /* .pfnDetach = */ qemuFwCfgR3Detach,
|
---|
2156 | /* .pfnQueryInterface = */ NULL,
|
---|
2157 | /* .pfnInitComplete = */ NULL,
|
---|
2158 | /* .pfnPowerOff = */ NULL,
|
---|
2159 | /* .pfnSoftReset = */ NULL,
|
---|
2160 | /* .pfnReserved0 = */ NULL,
|
---|
2161 | /* .pfnReserved1 = */ NULL,
|
---|
2162 | /* .pfnReserved2 = */ NULL,
|
---|
2163 | /* .pfnReserved3 = */ NULL,
|
---|
2164 | /* .pfnReserved4 = */ NULL,
|
---|
2165 | /* .pfnReserved5 = */ NULL,
|
---|
2166 | /* .pfnReserved6 = */ NULL,
|
---|
2167 | /* .pfnReserved7 = */ NULL,
|
---|
2168 | #elif defined(IN_RING0)
|
---|
2169 | /* .pfnEarlyConstruct = */ NULL,
|
---|
2170 | /* .pfnConstruct = */ NULL,
|
---|
2171 | /* .pfnDestruct = */ NULL,
|
---|
2172 | /* .pfnFinalDestruct = */ NULL,
|
---|
2173 | /* .pfnRequest = */ NULL,
|
---|
2174 | /* .pfnReserved0 = */ NULL,
|
---|
2175 | /* .pfnReserved1 = */ NULL,
|
---|
2176 | /* .pfnReserved2 = */ NULL,
|
---|
2177 | /* .pfnReserved3 = */ NULL,
|
---|
2178 | /* .pfnReserved4 = */ NULL,
|
---|
2179 | /* .pfnReserved5 = */ NULL,
|
---|
2180 | /* .pfnReserved6 = */ NULL,
|
---|
2181 | /* .pfnReserved7 = */ NULL,
|
---|
2182 | #elif defined(IN_RC)
|
---|
2183 | /* .pfnConstruct = */ NULL,
|
---|
2184 | /* .pfnReserved0 = */ NULL,
|
---|
2185 | /* .pfnReserved1 = */ NULL,
|
---|
2186 | /* .pfnReserved2 = */ NULL,
|
---|
2187 | /* .pfnReserved3 = */ NULL,
|
---|
2188 | /* .pfnReserved4 = */ NULL,
|
---|
2189 | /* .pfnReserved5 = */ NULL,
|
---|
2190 | /* .pfnReserved6 = */ NULL,
|
---|
2191 | /* .pfnReserved7 = */ NULL,
|
---|
2192 | #else
|
---|
2193 | # error "Not in IN_RING3, IN_RING0 or IN_RC!"
|
---|
2194 | #endif
|
---|
2195 | /* .u32VersionEnd = */ PDM_DEVREG_VERSION
|
---|
2196 | };
|
---|
2197 |
|
---|