VirtualBox

source: vbox/trunk/src/VBox/Devices/Graphics/DevVGA_VBVA.cpp@ 82088

Last change on this file since 82088 was 82088, checked in by vboxsync, 4 years ago

DevVGA: Mark functions with R3 where appropriate, adding docs and doing other minor cleaning up. bugref:9218
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 103.1 KB
Line 
1/* $Id: DevVGA_VBVA.cpp 82088 2019-11-21 21:59:57Z vboxsync $ */
2/** @file
3 * VirtualBox Video Acceleration (VBVA).
4 */
5
6/*
7 * Copyright (C) 2006-2019 Oracle Corporation
8 *
9 * This file is part of VirtualBox Open Source Edition (OSE), as
10 * available from http://www.virtualbox.org. This file is free software;
11 * you can redistribute it and/or modify it under the terms of the GNU
12 * General Public License (GPL) as published by the Free Software
13 * Foundation, in version 2 as it comes in the "COPYING" file of the
14 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
15 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
16 */
17
18
19/*********************************************************************************************************************************
20* Header Files *
21*********************************************************************************************************************************/
22#define LOG_GROUP LOG_GROUP_DEV_VGA
23#include <VBox/vmm/pdmifs.h>
24#include <VBox/vmm/pdmdev.h>
25#include <VBox/vmm/pgm.h>
26#include <VBox/vmm/ssm.h>
27#include <VBox/VMMDev.h>
28#include <VBox/AssertGuest.h>
29#include <VBoxVideo.h>
30#include <iprt/alloc.h>
31#include <iprt/assert.h>
32#include <iprt/asm.h>
33#include <iprt/string.h>
34#include <iprt/param.h>
35#ifdef VBOX_WITH_VIDEOHWACCEL
36#include <iprt/semaphore.h>
37#endif
38
39#include "DevVGA.h"
40
41/* A very detailed logging. */
42#if 0 // def DEBUG_sunlover
43#define LOGVBVABUFFER(a) LogFlow(a)
44#else
45#define LOGVBVABUFFER(a) do {} while (0)
46#endif
47
48
49/*********************************************************************************************************************************
50* Structures and Typedefs *
51*********************************************************************************************************************************/
52typedef struct VBVAPARTIALRECORD
53{
54 uint8_t *pu8;
55 uint32_t cb;
56} VBVAPARTIALRECORD;
57
58typedef struct VBVADATA
59{
60 struct
61 {
62 VBVABUFFER RT_UNTRUSTED_VOLATILE_GUEST *pVBVA; /**< Pointer to the guest memory with the VBVABUFFER. */
63 uint8_t RT_UNTRUSTED_VOLATILE_GUEST *pu8Data; /**< For convenience, pointer to the guest ring buffer (VBVABUFFER::au8Data). */
64 } guest;
65 uint32_t u32VBVAOffset; /**< VBVABUFFER offset in the guest VRAM. */
66 VBVAPARTIALRECORD partialRecord; /**< Partial record temporary storage. */
67 uint32_t off32Data; /**< The offset where the data starts in the VBVABUFFER.
68 * The host code uses it instead of VBVABUFFER::off32Data. */
69 uint32_t indexRecordFirst; /**< Index of the first filled record in VBVABUFFER::aRecords. */
70 uint32_t cbPartialWriteThreshold; /**< Copy of VBVABUFFER::cbPartialWriteThreshold used by host code. */
71 uint32_t cbData; /**< Copy of VBVABUFFER::cbData used by host code. */
72} VBVADATA;
73
74typedef struct VBVAVIEW
75{
76 VBVAINFOVIEW view;
77 VBVAINFOSCREEN screen;
78 VBVADATA vbva;
79} VBVAVIEW;
80
81typedef struct VBVAMOUSESHAPEINFO
82{
83 bool fSet;
84 bool fVisible;
85 bool fAlpha;
86 uint32_t u32HotX;
87 uint32_t u32HotY;
88 uint32_t u32Width;
89 uint32_t u32Height;
90 uint32_t cbShape;
91 uint32_t cbAllocated;
92 uint8_t *pu8Shape;
93} VBVAMOUSESHAPEINFO;
94
95/** @todo saved state: save and restore VBVACONTEXT */
96typedef struct VBVACONTEXT
97{
98 uint32_t cViews;
99 VBVAVIEW aViews[VBOX_VIDEO_MAX_SCREENS];
100 VBVAMOUSESHAPEINFO mouseShapeInfo;
101 bool fPaused;
102 VBVAMODEHINT aModeHints[VBOX_VIDEO_MAX_SCREENS];
103} VBVACONTEXT;
104
105
106static void vbvaDataCleanup(VBVADATA *pVBVAData)
107{
108 if (pVBVAData->guest.pVBVA)
109 {
110 pVBVAData->guest.pVBVA->hostFlags.u32HostEvents = 0;
111 pVBVAData->guest.pVBVA->hostFlags.u32SupportedOrders = 0;
112 }
113
114 RTMemFree(pVBVAData->partialRecord.pu8);
115
116 RT_ZERO(*pVBVAData);
117 pVBVAData->u32VBVAOffset = HGSMIOFFSET_VOID;
118}
119
120/** Copies @a cb bytes from the VBVA ring buffer to the @a pbDst.
121 * Used for partial records or for records which cross the ring boundary.
122 */
123static bool vbvaFetchBytes(VBVADATA *pVBVAData, uint8_t *pbDst, uint32_t cb)
124{
125 if (cb >= pVBVAData->cbData)
126 {
127 AssertMsgFailed(("cb = 0x%08X, ring buffer size 0x%08X", cb, pVBVAData->cbData));
128 return false;
129 }
130
131 const uint8_t RT_UNTRUSTED_VOLATILE_GUEST *pbSrc = &pVBVAData->guest.pu8Data[pVBVAData->off32Data];
132 const uint32_t u32BytesTillBoundary = pVBVAData->cbData - pVBVAData->off32Data;
133 const int32_t i32Diff = cb - u32BytesTillBoundary;
134
135 if (i32Diff <= 0)
136 {
137 /* Chunk will not cross buffer boundary. */
138 RT_BCOPY_VOLATILE(pbDst, pbSrc, cb);
139 }
140 else
141 {
142 /* Chunk crosses buffer boundary. */
143 RT_BCOPY_VOLATILE(pbDst, pbSrc, u32BytesTillBoundary);
144 RT_BCOPY_VOLATILE(pbDst + u32BytesTillBoundary, &pVBVAData->guest.pu8Data[0], i32Diff);
145 }
146
147 /* Advance data offset and sync with guest. */
148 pVBVAData->off32Data = (pVBVAData->off32Data + cb) % pVBVAData->cbData;
149 pVBVAData->guest.pVBVA->off32Data = pVBVAData->off32Data;
150 return true;
151}
152
153
154static bool vbvaPartialRead(uint32_t cbRecord, VBVADATA *pVBVAData)
155{
156 VBVAPARTIALRECORD *pPartialRecord = &pVBVAData->partialRecord;
157 uint8_t *pu8New;
158
159 LOGVBVABUFFER(("vbvaPartialRead: p = %p, cb = %d, cbRecord 0x%08X\n",
160 pPartialRecord->pu8, pPartialRecord->cb, cbRecord));
161
162 Assert(cbRecord > pPartialRecord->cb); /* Caller ensures this. */
163
164 const uint32_t cbChunk = cbRecord - pPartialRecord->cb;
165 if (cbChunk >= pVBVAData->cbData)
166 {
167 return false;
168 }
169
170 if (pPartialRecord->pu8)
171 {
172 Assert(pPartialRecord->cb);
173 pu8New = (uint8_t *)RTMemRealloc(pPartialRecord->pu8, cbRecord);
174 }
175 else
176 {
177 Assert(!pPartialRecord->cb);
178 pu8New = (uint8_t *)RTMemAlloc(cbRecord);
179 }
180
181 if (!pu8New)
182 {
183 /* Memory allocation failed, fail the function. */
184 Log(("vbvaPartialRead: failed to (re)alocate memory for partial record!!! cbRecord 0x%08X\n",
185 cbRecord));
186
187 return false;
188 }
189
190 /* Fetch data from the ring buffer. */
191 if (!vbvaFetchBytes(pVBVAData, pu8New + pPartialRecord->cb, cbChunk))
192 {
193 return false;
194 }
195
196 pPartialRecord->pu8 = pu8New;
197 pPartialRecord->cb = cbRecord;
198
199 return true;
200}
201
202/**
203 * For contiguous chunks just return the address in the buffer. For crossing
204 * boundary - allocate a buffer from heap.
205 */
206static bool vbvaFetchCmd(VBVADATA *pVBVAData, VBVACMDHDR RT_UNTRUSTED_VOLATILE_GUEST **ppHdr, uint32_t *pcbCmd)
207{
208 VBVAPARTIALRECORD *pPartialRecord = &pVBVAData->partialRecord;
209 uint32_t indexRecordFirst = pVBVAData->indexRecordFirst;
210 const uint32_t indexRecordFree = ASMAtomicReadU32(&pVBVAData->guest.pVBVA->indexRecordFree);
211
212 LOGVBVABUFFER(("first = %d, free = %d\n",
213 indexRecordFirst, indexRecordFree));
214
215 if (indexRecordFree >= RT_ELEMENTS(pVBVAData->guest.pVBVA->aRecords))
216 {
217 return false;
218 }
219
220 if (indexRecordFirst == indexRecordFree)
221 {
222 /* No records to process. Return without assigning output variables. */
223 return true;
224 }
225
226 uint32_t cbRecordCurrent = ASMAtomicReadU32(&pVBVAData->guest.pVBVA->aRecords[indexRecordFirst].cbRecord);
227
228 LOGVBVABUFFER(("cbRecord = 0x%08X, pPartialRecord->cb = 0x%08X\n", cbRecordCurrent, pPartialRecord->cb));
229
230 uint32_t cbRecord = cbRecordCurrent & ~VBVA_F_RECORD_PARTIAL;
231
232 if (cbRecord > VBVA_MAX_RECORD_SIZE)
233 {
234 return false;
235 }
236
237 if (pPartialRecord->cb)
238 {
239 /* There is a partial read in process. Continue with it. */
240 Assert (pPartialRecord->pu8);
241
242 LOGVBVABUFFER(("continue partial record cb = %d cbRecord 0x%08X, first = %d, free = %d\n",
243 pPartialRecord->cb, cbRecordCurrent, indexRecordFirst, indexRecordFree));
244
245 if (cbRecord > pPartialRecord->cb)
246 {
247 /* New data has been added to the record. */
248 if (!vbvaPartialRead(cbRecord, pVBVAData))
249 {
250 return false;
251 }
252 }
253
254 if (!(cbRecordCurrent & VBVA_F_RECORD_PARTIAL))
255 {
256 /* The record is completed by guest. Return it to the caller. */
257 *ppHdr = (VBVACMDHDR *)pPartialRecord->pu8;
258 *pcbCmd = pPartialRecord->cb;
259
260 pPartialRecord->pu8 = NULL;
261 pPartialRecord->cb = 0;
262
263 /* Advance the record index and sync with guest. */
264 pVBVAData->indexRecordFirst = (indexRecordFirst + 1) % RT_ELEMENTS(pVBVAData->guest.pVBVA->aRecords);
265 pVBVAData->guest.pVBVA->indexRecordFirst = pVBVAData->indexRecordFirst;
266
267 LOGVBVABUFFER(("partial done ok, data = %d, free = %d\n",
268 pVBVAData->off32Data, pVBVAData->guest.pVBVA->off32Free));
269 }
270
271 return true;
272 }
273
274 /* A new record need to be processed. */
275 if (cbRecordCurrent & VBVA_F_RECORD_PARTIAL)
276 {
277 /* Current record is being written by guest. '=' is important here,
278 * because the guest will do a FLUSH at this condition.
279 * This partial record is too large for the ring buffer and must
280 * be accumulated in an allocated buffer.
281 */
282 if (cbRecord >= pVBVAData->cbData - pVBVAData->cbPartialWriteThreshold)
283 {
284 /* Partial read must be started. */
285 if (!vbvaPartialRead(cbRecord, pVBVAData))
286 {
287 return false;
288 }
289
290 LOGVBVABUFFER(("started partial record cb = 0x%08X cbRecord 0x%08X, first = %d, free = %d\n",
291 pPartialRecord->cb, cbRecordCurrent, indexRecordFirst, indexRecordFree));
292 }
293
294 return true;
295 }
296
297 /* Current record is complete. If it is not empty, process it. */
298 if (cbRecord >= pVBVAData->cbData)
299 {
300 return false;
301 }
302
303 if (cbRecord)
304 {
305 /* The size of largest contiguous chunk in the ring buffer. */
306 uint32_t u32BytesTillBoundary = pVBVAData->cbData - pVBVAData->off32Data;
307
308 /* The pointer to data in the ring buffer. */
309 uint8_t RT_UNTRUSTED_VOLATILE_GUEST *pbSrc = &pVBVAData->guest.pu8Data[pVBVAData->off32Data];
310
311 /* Fetch or point the data. */
312 if (u32BytesTillBoundary >= cbRecord)
313 {
314 /* The command does not cross buffer boundary. Return address in the buffer. */
315 *ppHdr = (VBVACMDHDR RT_UNTRUSTED_VOLATILE_GUEST *)pbSrc;
316
317 /* The data offset will be updated in vbvaReleaseCmd. */
318 }
319 else
320 {
321 /* The command crosses buffer boundary. Rare case, so not optimized. */
322 uint8_t *pbDst = (uint8_t *)RTMemAlloc(cbRecord);
323 if (!pbDst)
324 {
325 LogFlowFunc (("could not allocate %d bytes from heap!!!\n", cbRecord));
326 return false;
327 }
328
329 vbvaFetchBytes(pVBVAData, pbDst, cbRecord);
330
331 *ppHdr = (VBVACMDHDR *)pbDst;
332
333 LOGVBVABUFFER(("Allocated from heap %p\n", pbDst));
334 }
335 }
336
337 *pcbCmd = cbRecord;
338
339 /* Advance the record index and sync with guest. */
340 pVBVAData->indexRecordFirst = (indexRecordFirst + 1) % RT_ELEMENTS(pVBVAData->guest.pVBVA->aRecords);
341 pVBVAData->guest.pVBVA->indexRecordFirst = pVBVAData->indexRecordFirst;
342
343 LOGVBVABUFFER(("done ok, data = %d, free = %d\n",
344 pVBVAData->off32Data, pVBVAData->guest.pVBVA->off32Free));
345
346 return true;
347}
348
349static void vbvaReleaseCmd(VBVADATA *pVBVAData, VBVACMDHDR RT_UNTRUSTED_VOLATILE_GUEST *pHdr, uint32_t cbCmd)
350{
351 VBVAPARTIALRECORD *pPartialRecord = &pVBVAData->partialRecord;
352 const uint8_t RT_UNTRUSTED_VOLATILE_GUEST *pbRingBuffer = pVBVAData->guest.pu8Data;
353
354 if ( (uintptr_t)pHdr >= (uintptr_t)pbRingBuffer
355 && (uintptr_t)pHdr < (uintptr_t)&pbRingBuffer[pVBVAData->cbData])
356 {
357 /* The pointer is inside ring buffer. Must be continuous chunk. */
358 Assert(pVBVAData->cbData - (uint32_t)((uint8_t *)pHdr - pbRingBuffer) >= cbCmd);
359
360 /* Advance data offset and sync with guest. */
361 pVBVAData->off32Data = (pVBVAData->off32Data + cbCmd) % pVBVAData->cbData;
362 pVBVAData->guest.pVBVA->off32Data = pVBVAData->off32Data;
363
364 Assert(!pPartialRecord->pu8 && pPartialRecord->cb == 0);
365 }
366 else
367 {
368 /* The pointer is outside. It is then an allocated copy. */
369 LOGVBVABUFFER(("Free heap %p\n", pHdr));
370
371 if ((uint8_t *)pHdr == pPartialRecord->pu8)
372 {
373 pPartialRecord->pu8 = NULL;
374 pPartialRecord->cb = 0;
375 }
376 else
377 {
378 Assert(!pPartialRecord->pu8 && pPartialRecord->cb == 0);
379 }
380
381 RTMemFree((void *)pHdr);
382 }
383}
384
385static int vbvaFlushProcess(unsigned uScreenId, PVGASTATE pVGAState, VBVADATA *pVBVAData)
386{
387 LOGVBVABUFFER(("uScreenId %d, indexRecordFirst = %d, indexRecordFree = %d, off32Data = %d, off32Free = %d\n",
388 uScreenId, pVBVAData->indexRecordFirst, pVBVAData->guest.pVBVA->indexRecordFree,
389 pVBVAData->off32Data, pVBVAData->guest.pVBVA->off32Free));
390 struct {
391 /* The rectangle that includes all dirty rectangles. */
392 int32_t xLeft;
393 int32_t xRight;
394 int32_t yTop;
395 int32_t yBottom;
396 } dirtyRect;
397 RT_ZERO(dirtyRect);
398
399 bool fUpdate = false; /* Whether there were any updates. */
400 bool fDirtyEmpty = true;
401
402 for (;;)
403 {
404 /* Fetch the command data. */
405 VBVACMDHDR RT_UNTRUSTED_VOLATILE_GUEST *pHdr = NULL;
406 uint32_t cbCmd = UINT32_MAX;
407 if (!vbvaFetchCmd(pVBVAData, &pHdr, &cbCmd))
408 {
409 LogFunc(("unable to fetch command. off32Data = %d, off32Free = %d!!!\n",
410 pVBVAData->off32Data, pVBVAData->guest.pVBVA->off32Free));
411 return VERR_NOT_SUPPORTED;
412 }
413
414 if (cbCmd == UINT32_MAX)
415 {
416 /* No more commands yet in the queue. */
417 break;
418 }
419
420 if (cbCmd < sizeof(VBVACMDHDR))
421 {
422 LogFunc(("short command. off32Data = %d, off32Free = %d, cbCmd %d!!!\n",
423 pVBVAData->off32Data, pVBVAData->guest.pVBVA->off32Free, cbCmd));
424
425 return VERR_NOT_SUPPORTED;
426 }
427
428 if (cbCmd != 0)
429 {
430 if (!fUpdate)
431 {
432 pVGAState->pDrv->pfnVBVAUpdateBegin(pVGAState->pDrv, uScreenId);
433 fUpdate = true;
434 }
435
436 /* Updates the rectangle and sends the command to the VRDP server. */
437 pVGAState->pDrv->pfnVBVAUpdateProcess(pVGAState->pDrv, uScreenId, pHdr, cbCmd);
438
439 int32_t xRight = pHdr->x + pHdr->w;
440 int32_t yBottom = pHdr->y + pHdr->h;
441
442 /* These are global coords, relative to the primary screen. */
443
444 LOGVBVABUFFER(("cbCmd = %d, x=%d, y=%d, w=%d, h=%d\n", cbCmd, pHdr->x, pHdr->y, pHdr->w, pHdr->h));
445 LogRel3(("%s: update command cbCmd = %d, x=%d, y=%d, w=%d, h=%d\n",
446 __FUNCTION__, cbCmd, pHdr->x, pHdr->y, pHdr->w, pHdr->h));
447
448 /* Collect all rects into one. */
449 if (fDirtyEmpty)
450 {
451 /* This is the first rectangle to be added. */
452 dirtyRect.xLeft = pHdr->x;
453 dirtyRect.yTop = pHdr->y;
454 dirtyRect.xRight = xRight;
455 dirtyRect.yBottom = yBottom;
456 fDirtyEmpty = false;
457 }
458 else
459 {
460 /* Adjust region coordinates. */
461 if (dirtyRect.xLeft > pHdr->x)
462 {
463 dirtyRect.xLeft = pHdr->x;
464 }
465
466 if (dirtyRect.yTop > pHdr->y)
467 {
468 dirtyRect.yTop = pHdr->y;
469 }
470
471 if (dirtyRect.xRight < xRight)
472 {
473 dirtyRect.xRight = xRight;
474 }
475
476 if (dirtyRect.yBottom < yBottom)
477 {
478 dirtyRect.yBottom = yBottom;
479 }
480 }
481 }
482
483 vbvaReleaseCmd(pVBVAData, pHdr, cbCmd);
484 }
485
486 if (fUpdate)
487 {
488 if (dirtyRect.xRight - dirtyRect.xLeft)
489 {
490 LogRel3(("%s: sending update screen=%d, x=%d, y=%d, w=%d, h=%d\n",
491 __FUNCTION__, uScreenId, dirtyRect.xLeft,
492 dirtyRect.yTop, dirtyRect.xRight - dirtyRect.xLeft,
493 dirtyRect.yBottom - dirtyRect.yTop));
494 pVGAState->pDrv->pfnVBVAUpdateEnd(pVGAState->pDrv, uScreenId, dirtyRect.xLeft, dirtyRect.yTop,
495 dirtyRect.xRight - dirtyRect.xLeft, dirtyRect.yBottom - dirtyRect.yTop);
496 }
497 else
498 {
499 pVGAState->pDrv->pfnVBVAUpdateEnd(pVGAState->pDrv, uScreenId, 0, 0, 0, 0);
500 }
501 }
502
503 return VINF_SUCCESS;
504}
505
506static int vbvaFlush(PVGASTATE pVGAState, VBVACONTEXT *pCtx)
507{
508 int rc = VINF_SUCCESS;
509
510 unsigned uScreenId;
511 for (uScreenId = 0; uScreenId < pCtx->cViews; uScreenId++)
512 {
513 VBVADATA *pVBVAData = &pCtx->aViews[uScreenId].vbva;
514 if (pVBVAData->guest.pVBVA)
515 {
516 rc = vbvaFlushProcess(uScreenId, pVGAState, pVBVAData);
517 if (RT_FAILURE(rc))
518 break;
519 }
520 }
521
522 if (RT_FAILURE(rc))
523 {
524 /* Turn off VBVA processing. */
525 LogRel(("VBVA: Disabling (%Rrc)\n", rc));
526 pVGAState->fGuestCaps = 0;
527 pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
528 for (uScreenId = 0; uScreenId < pCtx->cViews; uScreenId++)
529 {
530 VBVADATA *pVBVAData = &pCtx->aViews[uScreenId].vbva;
531 if (pVBVAData->guest.pVBVA)
532 {
533 vbvaDataCleanup(pVBVAData);
534 pVGAState->pDrv->pfnVBVADisable(pVGAState->pDrv, uScreenId);
535 }
536 }
537 }
538
539 return rc;
540}
541
542static int vbvaResize(PVGASTATE pVGAState, VBVAVIEW *pView, const VBVAINFOSCREEN *pNewScreen, bool fResetInputMapping)
543{
544 /* Callers ensure that pNewScreen contains valid data. */
545
546 /* Apply these changes. */
547 pView->screen = *pNewScreen;
548
549 uint8_t *pu8VRAM = pVGAState->vram_ptrR3 + pView->view.u32ViewOffset;
550 return pVGAState->pDrv->pfnVBVAResize (pVGAState->pDrv, &pView->view, &pView->screen, pu8VRAM, fResetInputMapping);
551}
552
553static int vbvaEnable(unsigned uScreenId, PVGASTATE pVGAState, VBVACONTEXT *pCtx,
554 VBVABUFFER RT_UNTRUSTED_VOLATILE_GUEST *pVBVA, uint32_t u32Offset, bool fRestored)
555{
556 /*
557 * Copy into non-volatile memory and validate its content.
558 */
559 VBVABUFFER VbgaSafe;
560 RT_COPY_VOLATILE(VbgaSafe, *pVBVA);
561 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
562
563 uint32_t const cbVBVABuffer = RT_UOFFSETOF(VBVABUFFER, au8Data) + VbgaSafe.cbData;
564 ASSERT_GUEST_RETURN( VbgaSafe.cbData <= UINT32_MAX - RT_UOFFSETOF(VBVABUFFER, au8Data)
565 && cbVBVABuffer <= pVGAState->vram_size
566 && u32Offset <= pVGAState->vram_size - cbVBVABuffer,
567 VERR_INVALID_PARAMETER);
568 if (!fRestored)
569 {
570 ASSERT_GUEST_RETURN(VbgaSafe.off32Data == 0, VERR_INVALID_PARAMETER);
571 ASSERT_GUEST_RETURN(VbgaSafe.off32Free == 0, VERR_INVALID_PARAMETER);
572 ASSERT_GUEST_RETURN(VbgaSafe.indexRecordFirst == 0, VERR_INVALID_PARAMETER);
573 ASSERT_GUEST_RETURN(VbgaSafe.indexRecordFree == 0, VERR_INVALID_PARAMETER);
574 }
575 ASSERT_GUEST_RETURN( VbgaSafe.cbPartialWriteThreshold < VbgaSafe.cbData
576 && VbgaSafe.cbPartialWriteThreshold != 0,
577 VERR_INVALID_PARAMETER);
578 RT_UNTRUSTED_VALIDATED_FENCE();
579
580 /*
581 * Okay, try do the job.
582 */
583 int rc;
584 if (pVGAState->pDrv->pfnVBVAEnable)
585 {
586 pVBVA->hostFlags.u32HostEvents = 0;
587 pVBVA->hostFlags.u32SupportedOrders = 0;
588 rc = pVGAState->pDrv->pfnVBVAEnable(pVGAState->pDrv, uScreenId, &pVBVA->hostFlags);
589 if (RT_SUCCESS(rc))
590 {
591 /* pVBVA->hostFlags has been set up by pfnVBVAEnable. */
592 LogFlowFunc(("u32HostEvents=0x%08x u32SupportedOrders=0x%08x\n",
593 pVBVA->hostFlags.u32HostEvents, pVBVA->hostFlags.u32SupportedOrders));
594
595 VBVADATA *pVBVAData = &pCtx->aViews[uScreenId].vbva;
596 pVBVAData->guest.pVBVA = pVBVA;
597 pVBVAData->guest.pu8Data = &pVBVA->au8Data[0];
598 pVBVAData->u32VBVAOffset = u32Offset;
599 pVBVAData->off32Data = VbgaSafe.off32Data;
600 pVBVAData->indexRecordFirst = VbgaSafe.indexRecordFirst;
601 pVBVAData->cbPartialWriteThreshold = VbgaSafe.cbPartialWriteThreshold;
602 pVBVAData->cbData = VbgaSafe.cbData;
603
604 if (!fRestored)
605 {
606 /** @todo Actually this function must not touch the partialRecord structure at all,
607 * because initially it is a zero and when VBVA is disabled this should be set to zero.
608 * But I'm not sure that no code depends on zeroing partialRecord here.
609 * So for now (a quick fix for 4.1) just do not do this if the VM was restored,
610 * when partialRecord might be loaded already from the saved state.
611 */
612 pVBVAData->partialRecord.pu8 = NULL;
613 pVBVAData->partialRecord.cb = 0;
614 }
615
616 /* VBVA is working so disable the pause. */
617 pCtx->fPaused = false;
618 }
619 }
620 else
621 rc = VERR_NOT_SUPPORTED;
622 return rc;
623}
624
625static int vbvaDisable (unsigned uScreenId, PVGASTATE pVGAState, VBVACONTEXT *pCtx)
626{
627 /* Process any pending orders and empty the VBVA ring buffer. */
628 vbvaFlush (pVGAState, pCtx);
629
630 VBVADATA *pVBVAData = &pCtx->aViews[uScreenId].vbva;
631 vbvaDataCleanup(pVBVAData);
632
633 if (uScreenId == 0)
634 {
635 pVGAState->fGuestCaps = 0;
636 pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
637 }
638 pVGAState->pDrv->pfnVBVADisable(pVGAState->pDrv, uScreenId);
639 return VINF_SUCCESS;
640}
641
642bool VBVAIsEnabled(PVGASTATE pVGAState)
643{
644 PHGSMIINSTANCE pHGSMI = pVGAState->pHGSMI;
645 if (pHGSMI)
646 {
647 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pHGSMI);
648 if (pCtx)
649 {
650 if (pCtx->cViews)
651 {
652 VBVAVIEW * pView = &pCtx->aViews[0];
653 if (pView->vbva.guest.pVBVA)
654 return true;
655 }
656 }
657 }
658 return false;
659}
660
661#ifdef DEBUG_sunlover
662void dumpMouseShapeInfo(const VBVAMOUSESHAPEINFO *pMouseShapeInfo)
663{
664 LogFlow(("fSet = %d, fVisible %d, fAlpha %d, @%d,%d %dx%d (%p, %d/%d)\n",
665 pMouseShapeInfo->fSet,
666 pMouseShapeInfo->fVisible,
667 pMouseShapeInfo->fAlpha,
668 pMouseShapeInfo->u32HotX,
669 pMouseShapeInfo->u32HotY,
670 pMouseShapeInfo->u32Width,
671 pMouseShapeInfo->u32Height,
672 pMouseShapeInfo->pu8Shape,
673 pMouseShapeInfo->cbShape,
674 pMouseShapeInfo->cbAllocated
675 ));
676}
677#endif
678
679static int vbvaUpdateMousePointerShape(PVGASTATE pVGAState, VBVAMOUSESHAPEINFO *pMouseShapeInfo, bool fShape)
680{
681 LogFlowFunc(("pVGAState %p, pMouseShapeInfo %p, fShape %d\n",
682 pVGAState, pMouseShapeInfo, fShape));
683#ifdef DEBUG_sunlover
684 dumpMouseShapeInfo(pMouseShapeInfo);
685#endif
686
687 if (pVGAState->pDrv->pfnVBVAMousePointerShape == NULL)
688 {
689 return VERR_NOT_SUPPORTED;
690 }
691
692 int rc;
693 if (fShape && pMouseShapeInfo->pu8Shape != NULL)
694 {
695 rc = pVGAState->pDrv->pfnVBVAMousePointerShape (pVGAState->pDrv,
696 pMouseShapeInfo->fVisible,
697 pMouseShapeInfo->fAlpha,
698 pMouseShapeInfo->u32HotX,
699 pMouseShapeInfo->u32HotY,
700 pMouseShapeInfo->u32Width,
701 pMouseShapeInfo->u32Height,
702 pMouseShapeInfo->pu8Shape);
703 }
704 else
705 {
706 rc = pVGAState->pDrv->pfnVBVAMousePointerShape (pVGAState->pDrv,
707 pMouseShapeInfo->fVisible,
708 false,
709 0, 0,
710 0, 0,
711 NULL);
712 }
713
714 return rc;
715}
716
717static int vbvaMousePointerShape(PVGASTATE pVGAState, VBVACONTEXT *pCtx,
718 const VBVAMOUSEPOINTERSHAPE RT_UNTRUSTED_VOLATILE_GUEST *pShape, HGSMISIZE cbShape)
719{
720 /*
721 * Make non-volatile copy of the shape header and validate it.
722 */
723 VBVAMOUSEPOINTERSHAPE SafeShape;
724 RT_COPY_VOLATILE(SafeShape, *pShape);
725 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
726
727 LogFlowFunc(("VBVA_MOUSE_POINTER_SHAPE: i32Result 0x%x, fu32Flags 0x%x, hot spot %d,%d, size %dx%d\n",
728 SafeShape.i32Result, SafeShape.fu32Flags, SafeShape.u32HotX, SafeShape.u32HotY, SafeShape.u32Width, SafeShape.u32Height));
729
730 const bool fVisible = RT_BOOL(SafeShape.fu32Flags & VBOX_MOUSE_POINTER_VISIBLE);
731 const bool fAlpha = RT_BOOL(SafeShape.fu32Flags & VBOX_MOUSE_POINTER_ALPHA);
732 const bool fShape = RT_BOOL(SafeShape.fu32Flags & VBOX_MOUSE_POINTER_SHAPE);
733
734 HGSMISIZE cbPointerData = 0;
735 if (fShape)
736 {
737 static const uint32_t s_cxMax = 2048; //used to be: 8192;
738 static const uint32_t s_cyMax = 2048; //used to be: 8192;
739 ASSERT_GUEST_MSG_RETURN( SafeShape.u32Width <= s_cxMax
740 || SafeShape.u32Height <= s_cyMax,
741 ("Too large: %ux%u, max %ux%x\n", SafeShape.u32Width, SafeShape.u32Height, s_cxMax, s_cyMax),
742 VERR_INVALID_PARAMETER);
743
744 cbPointerData = ((((SafeShape.u32Width + 7) / 8) * SafeShape.u32Height + 3) & ~3)
745 + SafeShape.u32Width * 4 * SafeShape.u32Height;
746
747 ASSERT_GUEST_MSG_RETURN(cbPointerData <= cbShape - RT_UOFFSETOF(VBVAMOUSEPOINTERSHAPE, au8Data),
748 ("Insufficent pointer data: Expected %#x, got %#x\n",
749 cbPointerData, cbShape - RT_UOFFSETOF(VBVAMOUSEPOINTERSHAPE, au8Data) ),
750 VERR_INVALID_PARAMETER);
751 }
752 RT_UNTRUSTED_VALIDATED_FENCE();
753
754 /*
755 * Do the job.
756 */
757 /* Save mouse info it will be used to restore mouse pointer after restoring saved state. */
758 pCtx->mouseShapeInfo.fSet = true;
759 pCtx->mouseShapeInfo.fVisible = fVisible;
760 if (fShape)
761 {
762 /* Data related to shape. */
763 pCtx->mouseShapeInfo.u32HotX = SafeShape.u32HotX;
764 pCtx->mouseShapeInfo.u32HotY = SafeShape.u32HotY;
765 pCtx->mouseShapeInfo.u32Width = SafeShape.u32Width;
766 pCtx->mouseShapeInfo.u32Height = SafeShape.u32Height;
767 pCtx->mouseShapeInfo.fAlpha = fAlpha;
768
769 /* Reallocate memory buffer if necessary. */
770 if (cbPointerData > pCtx->mouseShapeInfo.cbAllocated)
771 {
772 RTMemFree(pCtx->mouseShapeInfo.pu8Shape);
773 pCtx->mouseShapeInfo.pu8Shape = NULL;
774 pCtx->mouseShapeInfo.cbShape = 0;
775
776 uint8_t *pu8Shape = (uint8_t *)RTMemAlloc(cbPointerData);
777 if (pu8Shape)
778 {
779 pCtx->mouseShapeInfo.pu8Shape = pu8Shape;
780 pCtx->mouseShapeInfo.cbAllocated = cbPointerData;
781 }
782 }
783
784 /* Copy shape bitmaps. */
785 if (pCtx->mouseShapeInfo.pu8Shape)
786 {
787 RT_BCOPY_VOLATILE(pCtx->mouseShapeInfo.pu8Shape, &pShape->au8Data[0], cbPointerData);
788 pCtx->mouseShapeInfo.cbShape = cbPointerData;
789 }
790 }
791
792 return vbvaUpdateMousePointerShape(pVGAState, &pCtx->mouseShapeInfo, fShape);
793}
794
795static uint32_t vbvaViewFromBufferPtr(PHGSMIINSTANCE pIns, const VBVACONTEXT *pCtx,
796 const void RT_UNTRUSTED_VOLATILE_GUEST *pvBuffer)
797{
798 /* Check which view contains the buffer. */
799 HGSMIOFFSET offBuffer = HGSMIPointerToOffsetHost(pIns, pvBuffer);
800 if (offBuffer != HGSMIOFFSET_VOID)
801 {
802 unsigned uScreenId;
803 for (uScreenId = 0; uScreenId < pCtx->cViews; uScreenId++)
804 {
805 const VBVAINFOVIEW *pView = &pCtx->aViews[uScreenId].view;
806 if ((uint32_t)(offBuffer - pView->u32ViewOffset) < pView->u32ViewSize)
807 return pView->u32ViewIndex;
808 }
809 }
810 return UINT32_MAX;
811}
812
813#ifdef DEBUG_sunlover
814static void dumpctx(const VBVACONTEXT *pCtx)
815{
816 Log(("VBVACONTEXT dump: cViews %d\n", pCtx->cViews));
817
818 uint32_t iView;
819 for (iView = 0; iView < pCtx->cViews; iView++)
820 {
821 const VBVAVIEW *pView = &pCtx->aViews[iView];
822
823 Log((" view %d o 0x%x s 0x%x m 0x%x\n",
824 pView->view.u32ViewIndex,
825 pView->view.u32ViewOffset,
826 pView->view.u32ViewSize,
827 pView->view.u32MaxScreenSize));
828
829 Log((" screen %d @%d,%d s 0x%x l 0x%x %dx%d bpp %d f 0x%x\n",
830 pView->screen.u32ViewIndex,
831 pView->screen.i32OriginX,
832 pView->screen.i32OriginY,
833 pView->screen.u32StartOffset,
834 pView->screen.u32LineSize,
835 pView->screen.u32Width,
836 pView->screen.u32Height,
837 pView->screen.u16BitsPerPixel,
838 pView->screen.u16Flags));
839
840 Log((" VBVA o 0x%x p %p\n",
841 pView->vbva.u32VBVAOffset,
842 pView->vbva.guest.pVBVA));
843
844 Log((" PR cb 0x%x p %p\n",
845 pView->vbva.partialRecord.cb,
846 pView->vbva.partialRecord.pu8));
847 }
848
849 dumpMouseShapeInfo(&pCtx->mouseShapeInfo);
850}
851#endif /* DEBUG_sunlover */
852
853#define VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC 0x12345678
854#define VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC 0x9abcdef0
855
856#ifdef VBOX_WITH_VIDEOHWACCEL
857static void vbvaVHWAHHCommandReinit(VBOXVHWACMD* pHdr, VBOXVHWACMD_TYPE enmCmd, int32_t iDisplay)
858{
859 memset(pHdr, 0, VBOXVHWACMD_HEADSIZE());
860 pHdr->cRefs = 1;
861 pHdr->iDisplay = iDisplay;
862 pHdr->rc = VERR_NOT_IMPLEMENTED;
863 pHdr->enmCmd = enmCmd;
864 pHdr->Flags = VBOXVHWACMD_FLAG_HH_CMD;
865}
866
867static VBOXVHWACMD *vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE enmCmd, int32_t iDisplay, VBOXVHWACMD_LENGTH cbCmd)
868{
869 VBOXVHWACMD *pHdr = (VBOXVHWACMD *)RTMemAllocZ(cbCmd + VBOXVHWACMD_HEADSIZE());
870 Assert(pHdr);
871 if (pHdr)
872 vbvaVHWAHHCommandReinit(pHdr, enmCmd, iDisplay);
873
874 return pHdr;
875}
876
877DECLINLINE(void) vbvaVHWAHHCommandRelease(VBOXVHWACMD *pCmd)
878{
879 uint32_t cRefs = ASMAtomicDecU32(&pCmd->cRefs);
880 if (!cRefs)
881 RTMemFree(pCmd);
882}
883
884DECLINLINE(void) vbvaVHWAHHCommandRetain(VBOXVHWACMD *pCmd)
885{
886 ASMAtomicIncU32(&pCmd->cRefs);
887}
888
889static void vbvaVHWACommandComplete(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand, bool fAsyncCommand)
890{
891 if (fAsyncCommand)
892 {
893 Assert(pCommand->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH);
894 vbvaR3VHWACommandCompleteAsync(&pVGAState->IVBVACallbacks, pCommand);
895 }
896 else
897 {
898 Log(("VGA Command <<< Sync rc %d %#p, %d\n", pCommand->rc, pCommand, pCommand->enmCmd));
899 pCommand->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
900 }
901
902}
903
904static void vbvaVHWACommandCompleteAllPending(PVGASTATE pVGAState, int rc)
905{
906 if (!ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending))
907 return;
908
909 PDMDevHlpCritSectEnter(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect, VERR_SEM_BUSY);
910
911 VBOX_VHWA_PENDINGCMD *pIter, *pNext;
912 RTListForEachSafe(&pVGAState->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
913 {
914 pIter->pCommand->rc = rc;
915 vbvaVHWACommandComplete(pVGAState, pIter->pCommand, true);
916
917 /* the command is submitted/processed, remove from the pend list */
918 RTListNodeRemove(&pIter->Node);
919 ASMAtomicDecU32(&pVGAState->pendingVhwaCommands.cPending);
920 RTMemFree(pIter);
921 }
922
923 PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
924}
925
926static void vbvaVHWACommandClearAllPending(PVGASTATE pVGAState)
927{
928 if (!ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending))
929 return;
930
931 PDMDevHlpCritSectEnter(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect, VERR_SEM_BUSY);
932
933 VBOX_VHWA_PENDINGCMD *pIter, *pNext;
934 RTListForEachSafe(&pVGAState->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
935 {
936 RTListNodeRemove(&pIter->Node);
937 ASMAtomicDecU32(&pVGAState->pendingVhwaCommands.cPending);
938 RTMemFree(pIter);
939 }
940
941 PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
942}
943
944static void vbvaVHWACommandPend(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand)
945{
946 int rc = VERR_BUFFER_OVERFLOW;
947
948 if (ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending) < VBOX_VHWA_MAX_PENDING_COMMANDS)
949 {
950 VBOX_VHWA_PENDINGCMD *pPend = (VBOX_VHWA_PENDINGCMD *)RTMemAlloc(sizeof(*pPend));
951 if (pPend)
952 {
953 pCommand->Flags |= VBOXVHWACMD_FLAG_HG_ASYNCH;
954 pPend->pCommand = pCommand;
955 PDMDevHlpCritSectEnter(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect, VERR_SEM_BUSY);
956 if (ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending) < VBOX_VHWA_MAX_PENDING_COMMANDS)
957 {
958 RTListAppend(&pVGAState->pendingVhwaCommands.PendingList, &pPend->Node);
959 ASMAtomicIncU32(&pVGAState->pendingVhwaCommands.cPending);
960 PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
961 return;
962 }
963 PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
964 LogRel(("VBVA: Pending command count has reached its threshold.. completing them all.."));
965 RTMemFree(pPend);
966 }
967 else
968 rc = VERR_NO_MEMORY;
969 }
970 else
971 LogRel(("VBVA: Pending command count has reached its threshold, completing them all.."));
972
973 vbvaVHWACommandCompleteAllPending(pVGAState, rc);
974
975 pCommand->rc = rc;
976
977 vbvaVHWACommandComplete(pVGAState, pCommand, false);
978}
979
980static bool vbvaVHWACommandCanPend(VBOXVHWACMD_TYPE enmCmd)
981{
982 switch (enmCmd)
983 {
984 case VBOXVHWACMD_TYPE_HH_CONSTRUCT:
985 case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN:
986 case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND:
987 case VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM:
988 case VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM:
989 return false;
990 default:
991 return true;
992 }
993}
994
995static int vbvaVHWACommandSavePending(PCPDMDEVHLPR3 pHlp, PVGASTATE pVGAState, PSSMHANDLE pSSM)
996{
997 int rc = pHlp->pfnSSMPutU32(pSSM, pVGAState->pendingVhwaCommands.cPending);
998 AssertRCReturn(rc, rc);
999
1000 VBOX_VHWA_PENDINGCMD *pIter;
1001 RTListForEach(&pVGAState->pendingVhwaCommands.PendingList, pIter, VBOX_VHWA_PENDINGCMD, Node)
1002 {
1003 AssertContinue((uintptr_t)pIter->pCommand - (uintptr_t)pVGAState->vram_ptrR3 < pVGAState->vram_size);
1004 rc = pHlp->pfnSSMPutU32(pSSM, (uint32_t)(((uint8_t *)pIter->pCommand) - ((uint8_t *)pVGAState->vram_ptrR3)));
1005 AssertRCReturn(rc, rc);
1006 }
1007 return rc;
1008}
1009
1010static int vbvaVHWACommandLoadPending(PCPDMDEVHLPR3 pHlp, PVGASTATE pVGAState, PSSMHANDLE pSSM, uint32_t u32Version)
1011{
1012 if (u32Version < VGA_SAVEDSTATE_VERSION_WITH_PENDVHWA)
1013 return VINF_SUCCESS;
1014
1015 uint32_t u32;
1016 int rc = pHlp->pfnSSMGetU32(pSSM, &u32);
1017 AssertRCReturn(rc, rc);
1018 for (uint32_t i = 0; i < u32; ++i)
1019 {
1020 uint32_t off32;
1021 rc = pHlp->pfnSSMGetU32(pSSM, &off32);
1022 AssertRCReturn(rc, rc);
1023 VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand
1024 = (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *)((uint8_t volatile *)pVGAState->vram_ptrR3 + off32);
1025 vbvaVHWACommandPend(pVGAState, pCommand);
1026 }
1027 return rc;
1028}
1029
1030
1031/** Worker for vbvaVHWACommandSubmit. */
1032static bool vbvaVHWACommandSubmitInner(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand, bool *pfPending)
1033{
1034 *pfPending = false;
1035
1036 /*
1037 * Read the command type and validate it and our driver state.
1038 */
1039 VBOXVHWACMD_TYPE enmCmd = pCommand->enmCmd;
1040 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
1041
1042 bool fGuestCmd = (uintptr_t)pCommand - (uintptr_t)pVGAState->vram_ptrR3 < pVGAState->vram_size;
1043 ASSERT_GUEST_LOGREL_MSG_STMT_RETURN( !fGuestCmd
1044 || ( enmCmd != VBOXVHWACMD_TYPE_HH_CONSTRUCT
1045 && enmCmd != VBOXVHWACMD_TYPE_HH_RESET
1046 && enmCmd != VBOXVHWACMD_TYPE_HH_DISABLE
1047 && enmCmd != VBOXVHWACMD_TYPE_HH_ENABLE
1048 && enmCmd != VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN
1049 && enmCmd != VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND
1050 && enmCmd != VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM
1051 && enmCmd != VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM),
1052 ("enmCmd=%d\n", enmCmd),
1053 pCommand->rc = VERR_INVALID_PARAMETER,
1054 true);
1055 ASSERT_GUEST_STMT_RETURN(pVGAState->pDrv->pfnVHWACommandProcess, pCommand->rc = VERR_INVALID_STATE, true);
1056 RT_UNTRUSTED_VALIDATED_FENCE();
1057
1058 /*
1059 * Call the driver to process the command.
1060 */
1061 Log(("VGA Command >>> %#p, %d\n", pCommand, enmCmd));
1062 int rc = pVGAState->pDrv->pfnVHWACommandProcess(pVGAState->pDrv, enmCmd, fGuestCmd, pCommand);
1063 if (rc == VINF_CALLBACK_RETURN)
1064 {
1065 Log(("VGA Command --- Going Async %#p, %d\n", pCommand, enmCmd));
1066 *pfPending = true;
1067 return true; /* Command will be completed asynchronously by the driver and need not be put in the pending list. */
1068 }
1069
1070 if (rc == VERR_INVALID_STATE)
1071 {
1072 Log(("VGA Command --- Trying Pend %#p, %d\n", pCommand, enmCmd));
1073 if (vbvaVHWACommandCanPend(enmCmd))
1074 {
1075 Log(("VGA Command --- Can Pend %#p, %d\n", pCommand, enmCmd));
1076 *pfPending = true;
1077 return false; /* put on pending list so it can be retried?? */
1078 }
1079
1080 Log(("VGA Command --- Can NOT Pend %#p, %d\n", pCommand, enmCmd));
1081 }
1082 else
1083 Log(("VGA Command --- Going Complete Sync rc %d %#p, %d\n", rc, pCommand, enmCmd));
1084
1085 /* the command was completed, take a special care about it (see caller) */
1086 pCommand->rc = rc;
1087 return true;
1088}
1089
1090
1091static bool vbvaVHWACommandSubmit(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand, bool fAsyncCommand)
1092{
1093 bool fPending = false;
1094 bool fRet = vbvaVHWACommandSubmitInner(pVGAState, pCommand, &fPending);
1095 if (!fPending)
1096 vbvaVHWACommandComplete(pVGAState, pCommand, fAsyncCommand);
1097 return fRet;
1098}
1099
1100
1101/**
1102 * @returns false if commands are pending, otherwise true.
1103 */
1104static bool vbvaVHWACheckPendingCommands(PVGASTATE pVGAState)
1105{
1106 if (!ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending))
1107 return true;
1108
1109 PDMDevHlpCritSectEnter(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect, VERR_SEM_BUSY);
1110
1111 VBOX_VHWA_PENDINGCMD *pIter, *pNext;
1112 RTListForEachSafe(&pVGAState->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
1113 {
1114 if (!vbvaVHWACommandSubmit(pVGAState, pIter->pCommand, true))
1115 {
1116 PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
1117 return false; /* the command should be still pending */
1118 }
1119
1120 /* the command is submitted/processed, remove from the pend list */
1121 RTListNodeRemove(&pIter->Node);
1122 ASMAtomicDecU32(&pVGAState->pendingVhwaCommands.cPending);
1123 RTMemFree(pIter);
1124 }
1125
1126 PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
1127
1128 return true;
1129}
1130
1131void vbvaTimerCb(PVGASTATE pVGAState)
1132{
1133 vbvaVHWACheckPendingCommands(pVGAState);
1134}
1135
1136static void vbvaVHWAHandleCommand(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
1137{
1138 if (vbvaVHWACheckPendingCommands(pVGAState))
1139 {
1140 if (vbvaVHWACommandSubmit(pVGAState, pCmd, false))
1141 return;
1142 }
1143
1144 vbvaVHWACommandPend(pVGAState, pCmd);
1145}
1146
1147static DECLCALLBACK(void) vbvaVHWAHHCommandSetEventCallback(void * pContext)
1148{
1149 RTSemEventSignal((RTSEMEVENT)pContext);
1150}
1151
1152static int vbvaVHWAHHCommandPost(PVGASTATE pVGAState, VBOXVHWACMD *pCmd)
1153{
1154 RTSEMEVENT hComplEvent;
1155 int rc = RTSemEventCreate(&hComplEvent);
1156 AssertRC(rc);
1157 if (RT_SUCCESS(rc))
1158 {
1159 /* ensure the cmd is not deleted until we process it */
1160 vbvaVHWAHHCommandRetain(pCmd);
1161
1162 VBOXVHWA_HH_CALLBACK_SET(pCmd, vbvaVHWAHHCommandSetEventCallback, (void *)hComplEvent);
1163 vbvaVHWAHandleCommand(pVGAState, pCmd);
1164
1165 if ((ASMAtomicReadU32((volatile uint32_t *)&pCmd->Flags) & VBOXVHWACMD_FLAG_HG_ASYNCH) != 0)
1166 rc = RTSemEventWaitNoResume(hComplEvent, RT_INDEFINITE_WAIT); /** @todo Why the NoResume and event leaking here? */
1167 /* else: the command is completed */
1168
1169 AssertRC(rc);
1170 if (RT_SUCCESS(rc))
1171 RTSemEventDestroy(hComplEvent);
1172
1173 vbvaVHWAHHCommandRelease(pCmd);
1174 }
1175 return rc;
1176}
1177
1178int vbvaVHWAConstruct(PVGASTATE pVGAState)
1179{
1180 pVGAState->pendingVhwaCommands.cPending = 0;
1181 RTListInit(&pVGAState->pendingVhwaCommands.PendingList);
1182
1183 VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_CONSTRUCT, 0, sizeof(VBOXVHWACMD_HH_CONSTRUCT));
1184 Assert(pCmd);
1185 if(pCmd)
1186 {
1187 uint32_t iDisplay = 0;
1188 int rc = VINF_SUCCESS;
1189 VBOXVHWACMD_HH_CONSTRUCT *pBody = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_CONSTRUCT);
1190
1191 do
1192 {
1193 memset(pBody, 0, sizeof(VBOXVHWACMD_HH_CONSTRUCT));
1194
1195 PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
1196 PVM pVM = PDMDevHlpGetVM(pDevIns);
1197
1198 pBody->pVM = pVM;
1199 pBody->pvVRAM = pVGAState->vram_ptrR3;
1200 pBody->cbVRAM = pVGAState->vram_size;
1201
1202 rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
1203 ASMCompilerBarrier();
1204
1205 AssertRC(rc);
1206 if (RT_SUCCESS(rc))
1207 {
1208 rc = pCmd->rc;
1209 AssertMsg(RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
1210 if(rc == VERR_NOT_IMPLEMENTED)
1211 {
1212 /** @todo set some flag in pVGAState indicating VHWA is not supported */
1213 /* VERR_NOT_IMPLEMENTED is not a failure, we just do not support it */
1214 rc = VINF_SUCCESS;
1215 }
1216
1217 if (!RT_SUCCESS(rc))
1218 break;
1219 }
1220 else
1221 break;
1222
1223 ++iDisplay;
1224 if (iDisplay >= pVGAState->cMonitors)
1225 break;
1226 vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_CONSTRUCT, (int32_t)iDisplay);
1227 } while (true);
1228
1229 vbvaVHWAHHCommandRelease(pCmd);
1230
1231 return rc;
1232 }
1233 return VERR_OUT_OF_RESOURCES;
1234}
1235
1236int vbvaVHWAReset(PVGASTATE pVGAState)
1237{
1238 vbvaVHWACommandClearAllPending(pVGAState);
1239
1240 /* ensure we have all pending cmds processed and h->g cmds disabled */
1241 VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_RESET, 0, 0);
1242 Assert(pCmd);
1243 if (pCmd)
1244 {
1245 int rc = VINF_SUCCESS;
1246 uint32_t iDisplay = 0;
1247
1248 do
1249 {
1250 rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
1251 AssertRC(rc);
1252 if(RT_SUCCESS(rc))
1253 {
1254 rc = pCmd->rc;
1255 AssertMsg(RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
1256 if (rc == VERR_NOT_IMPLEMENTED)
1257 rc = VINF_SUCCESS;
1258 }
1259
1260 if (!RT_SUCCESS(rc))
1261 break;
1262
1263 ++iDisplay;
1264 if (iDisplay >= pVGAState->cMonitors)
1265 break;
1266 vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_RESET, (int32_t)iDisplay);
1267
1268 } while (true);
1269
1270 vbvaVHWAHHCommandRelease(pCmd);
1271
1272 return rc;
1273 }
1274 return VERR_OUT_OF_RESOURCES;
1275}
1276
1277typedef DECLCALLBACK(bool) FNVBOXVHWAHHCMDPRECB(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext);
1278typedef FNVBOXVHWAHHCMDPRECB *PFNVBOXVHWAHHCMDPRECB;
1279
1280typedef DECLCALLBACK(bool) FNVBOXVHWAHHCMDPOSTCB(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, int rc, void *pvContext);
1281typedef FNVBOXVHWAHHCMDPOSTCB *PFNVBOXVHWAHHCMDPOSTCB;
1282
1283int vbvaVHWAHHPost(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, PFNVBOXVHWAHHCMDPRECB pfnPre, PFNVBOXVHWAHHCMDPOSTCB pfnPost, void *pvContext)
1284{
1285 const VBOXVHWACMD_TYPE enmType = pCmd->enmCmd;
1286 int rc = VINF_SUCCESS;
1287 uint32_t iDisplay = 0;
1288
1289 do
1290 {
1291 if (!pfnPre || pfnPre(pVGAState, pCmd, iDisplay, pvContext))
1292 {
1293 rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
1294 AssertRC(rc);
1295 if (pfnPost)
1296 {
1297 if (!pfnPost(pVGAState, pCmd, iDisplay, rc, pvContext))
1298 {
1299 rc = VINF_SUCCESS;
1300 break;
1301 }
1302 rc = VINF_SUCCESS;
1303 }
1304 else if(RT_SUCCESS(rc))
1305 {
1306 rc = pCmd->rc;
1307 AssertMsg(RT_SUCCESS(rc) || rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
1308 if(rc == VERR_NOT_IMPLEMENTED)
1309 {
1310 rc = VINF_SUCCESS;
1311 }
1312 }
1313
1314 if (!RT_SUCCESS(rc))
1315 break;
1316 }
1317
1318 ++iDisplay;
1319 if (iDisplay >= pVGAState->cMonitors)
1320 break;
1321 vbvaVHWAHHCommandReinit(pCmd, enmType, (int32_t)iDisplay);
1322 } while (true);
1323
1324 return rc;
1325}
1326
1327/** @todo call this also on reset? */
1328int vbvaVHWAEnable (PVGASTATE pVGAState, bool bEnable)
1329{
1330 const VBOXVHWACMD_TYPE enmType = bEnable ? VBOXVHWACMD_TYPE_HH_ENABLE : VBOXVHWACMD_TYPE_HH_DISABLE;
1331 VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(enmType, 0, 0);
1332 Assert(pCmd);
1333 if(pCmd)
1334 {
1335 int rc = vbvaVHWAHHPost (pVGAState, pCmd, NULL, NULL, NULL);
1336 vbvaVHWAHHCommandRelease(pCmd);
1337 return rc;
1338 }
1339 return VERR_OUT_OF_RESOURCES;
1340}
1341
1342int vboxVBVASaveStatePrep(PPDMDEVINS pDevIns)
1343{
1344 /* ensure we have no pending commands */
1345 return vbvaVHWAEnable(PDMINS_2_DATA(pDevIns, PVGASTATE), false);
1346}
1347
1348int vboxVBVASaveStateDone(PPDMDEVINS pDevIns)
1349{
1350 /* ensure we have no pending commands */
1351 return vbvaVHWAEnable(PDMINS_2_DATA(pDevIns, PVGASTATE), true);
1352}
1353
1354/**
1355 * @interface_method_impl{PDMIDISPLAYVBVACALLBACKS,pfnVHWACommandCompleteAsync}
1356 */
1357DECLCALLBACK(int) vbvaR3VHWACommandCompleteAsync(PPDMIDISPLAYVBVACALLBACKS pInterface,
1358 VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
1359{
1360 PVGASTATE pVGAState = PPDMIDISPLAYVBVACALLBACKS_2_PVGASTATE(pInterface);
1361 int rc;
1362 Log(("VGA Command <<< Async rc %d %#p, %d\n", pCmd->rc, pCmd, pCmd->enmCmd));
1363
1364 if ((uintptr_t)pCmd - (uintptr_t)pVGAState->vram_ptrR3 < pVGAState->vram_size)
1365 {
1366 PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
1367 Assert(!(pCmd->Flags & VBOXVHWACMD_FLAG_HH_CMD));
1368 Assert(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH);
1369#ifdef VBOX_WITH_WDDM
1370 if (pVGAState->fGuestCaps & VBVACAPS_COMPLETEGCMD_BY_IOREAD)
1371 {
1372 rc = HGSMICompleteGuestCommand(pIns, pCmd, !!(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ));
1373 AssertRC(rc);
1374 }
1375 else
1376#endif
1377 {
1378 VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_GUEST *pHostCmd = NULL; /* Shut up MSC. */
1379 if (pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT)
1380 {
1381 rc = HGSMIHostCommandAlloc(pIns,
1382 (void RT_UNTRUSTED_VOLATILE_GUEST **)&pHostCmd,
1383 VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)),
1384 HGSMI_CH_VBVA,
1385 VBVAHG_EVENT);
1386 AssertRC(rc);
1387 if (RT_SUCCESS(rc))
1388 {
1389 memset((void *)pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)));
1390 pHostCmd->iDstID = pCmd->iDisplay;
1391 pHostCmd->customOpCode = 0;
1392 VBVAHOSTCMDEVENT RT_UNTRUSTED_VOLATILE_GUEST *pBody = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDEVENT);
1393 pBody->pEvent = pCmd->GuestVBVAReserved1;
1394 }
1395 }
1396 else
1397 {
1398 HGSMIOFFSET offCmd = HGSMIPointerToOffsetHost(pIns, pCmd);
1399 Assert(offCmd != HGSMIOFFSET_VOID);
1400 if (offCmd != HGSMIOFFSET_VOID)
1401 {
1402 rc = HGSMIHostCommandAlloc(pIns,
1403 (void RT_UNTRUSTED_VOLATILE_GUEST **)&pHostCmd,
1404 VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)),
1405 HGSMI_CH_VBVA,
1406 VBVAHG_DISPLAY_CUSTOM);
1407 AssertRC(rc);
1408 if (RT_SUCCESS(rc))
1409 {
1410 memset((void *)pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)));
1411 pHostCmd->iDstID = pCmd->iDisplay;
1412 pHostCmd->customOpCode = VBVAHG_DCUSTOM_VHWA_CMDCOMPLETE;
1413 VBVAHOSTCMDVHWACMDCOMPLETE RT_UNTRUSTED_VOLATILE_GUEST *pBody
1414 = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDVHWACMDCOMPLETE);
1415 pBody->offCmd = offCmd;
1416 }
1417 }
1418 else
1419 rc = VERR_INVALID_PARAMETER;
1420 }
1421
1422 if (RT_SUCCESS(rc))
1423 {
1424 rc = HGSMIHostCommandSubmitAndFreeAsynch(pIns, pHostCmd, RT_BOOL(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ));
1425 AssertRC(rc);
1426 if (RT_SUCCESS(rc))
1427 return rc;
1428
1429 HGSMIHostCommandFree (pIns, pHostCmd);
1430 }
1431 }
1432 }
1433 else
1434 {
1435 Assert(pCmd->Flags & VBOXVHWACMD_FLAG_HH_CMD);
1436 PFNVBOXVHWA_HH_CALLBACK pfn = VBOXVHWA_HH_CALLBACK_GET(pCmd);
1437 if (pfn)
1438 pfn(VBOXVHWA_HH_CALLBACK_GET_ARG(pCmd));
1439 rc = VINF_SUCCESS;
1440 }
1441 return rc;
1442}
1443
1444typedef struct VBOXVBVASAVEDSTATECBDATA
1445{
1446 PSSMHANDLE pSSM;
1447 int rc;
1448 bool ab2DOn[VBOX_VIDEO_MAX_SCREENS];
1449} VBOXVBVASAVEDSTATECBDATA, *PVBOXVBVASAVEDSTATECBDATA;
1450
1451static DECLCALLBACK(bool) vboxVBVASaveStateBeginPostCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay,
1452 int rc, void *pvContext)
1453{
1454 RT_NOREF(pVGAState, pCmd);
1455 PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
1456 if (RT_FAILURE(pData->rc))
1457 return false;
1458 if (RT_FAILURE(rc))
1459 {
1460 pData->rc = rc;
1461 return false;
1462 }
1463
1464 Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
1465 if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
1466 {
1467 pData->rc = VERR_INVALID_PARAMETER;
1468 return false;
1469 }
1470
1471 Assert(RT_SUCCESS(pCmd->rc) || pCmd->rc == VERR_NOT_IMPLEMENTED);
1472 if (RT_SUCCESS(pCmd->rc))
1473 {
1474 pData->ab2DOn[iDisplay] = true;
1475 }
1476 else if (pCmd->rc != VERR_NOT_IMPLEMENTED)
1477 {
1478 pData->rc = pCmd->rc;
1479 return false;
1480 }
1481
1482 return true;
1483}
1484
1485static DECLCALLBACK(bool)
1486vboxVBVASaveStatePerformPreCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext)
1487{
1488 RT_NOREF(pVGAState, pCmd);
1489 PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
1490 if (RT_FAILURE(pData->rc))
1491 return false;
1492
1493 Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
1494 if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
1495 {
1496 pData->rc = VERR_INVALID_PARAMETER;
1497 return false;
1498 }
1499
1500 int rc;
1501 PCPDMDEVHLPR3 pHlp = pVGAState->pDevInsR3->pHlpR3;
1502
1503 if (pData->ab2DOn[iDisplay])
1504 {
1505 rc = pHlp->pfnSSMPutU32(pData->pSSM, VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC); AssertRC(rc);
1506 if (RT_FAILURE(rc))
1507 {
1508 pData->rc = rc;
1509 return false;
1510 }
1511 return true;
1512 }
1513
1514 rc = pHlp->pfnSSMPutU32(pData->pSSM, VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC); AssertRC(rc);
1515 if (RT_FAILURE(rc))
1516 {
1517 pData->rc = rc;
1518 return false;
1519 }
1520
1521 return false;
1522}
1523
1524static DECLCALLBACK(bool) vboxVBVASaveStateEndPreCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext)
1525{
1526 RT_NOREF(pVGAState, pCmd);
1527 PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
1528 Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
1529 if (pData->ab2DOn[iDisplay])
1530 {
1531 return true;
1532 }
1533
1534 return false;
1535}
1536
1537static DECLCALLBACK(bool)
1538vboxVBVALoadStatePerformPostCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, int rc, void *pvContext)
1539{
1540 RT_NOREF(pVGAState, pCmd);
1541 PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
1542 if (RT_FAILURE(pData->rc))
1543 return false;
1544 if (RT_FAILURE(rc))
1545 {
1546 pData->rc = rc;
1547 return false;
1548 }
1549
1550 Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
1551 if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
1552 {
1553 pData->rc = VERR_INVALID_PARAMETER;
1554 return false;
1555 }
1556
1557 PCPDMDEVHLPR3 pHlp = pVGAState->pDevInsR3->pHlpR3;
1558 Assert(RT_SUCCESS(pCmd->rc) || pCmd->rc == VERR_NOT_IMPLEMENTED);
1559 if (pCmd->rc == VERR_NOT_IMPLEMENTED)
1560 {
1561 pData->rc = pHlp->pfnSSMSkipToEndOfUnit(pData->pSSM);
1562 AssertRC(pData->rc);
1563 return false;
1564 }
1565 if (RT_FAILURE(pCmd->rc))
1566 {
1567 pData->rc = pCmd->rc;
1568 return false;
1569 }
1570
1571 return true;
1572}
1573
1574static DECLCALLBACK(bool)
1575vboxVBVALoadStatePerformPreCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay, void *pvContext)
1576{
1577 RT_NOREF(pVGAState, pCmd);
1578 PVBOXVBVASAVEDSTATECBDATA pData = (PVBOXVBVASAVEDSTATECBDATA)pvContext;
1579 if (RT_FAILURE(pData->rc))
1580 return false;
1581
1582 Assert(iDisplay < RT_ELEMENTS(pData->ab2DOn));
1583 if (iDisplay >= RT_ELEMENTS(pData->ab2DOn))
1584 {
1585 pData->rc = VERR_INVALID_PARAMETER;
1586 return false;
1587 }
1588
1589 PCPDMDEVHLPR3 pHlp = pVGAState->pDevInsR3->pHlpR3;
1590 int rc;
1591 uint32_t u32;
1592 rc = pHlp->pfnSSMGetU32(pData->pSSM, &u32); AssertRC(rc);
1593 if (RT_FAILURE(rc))
1594 {
1595 pData->rc = rc;
1596 return false;
1597 }
1598
1599 switch (u32)
1600 {
1601 case VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC:
1602 pData->ab2DOn[iDisplay] = true;
1603 return true;
1604 case VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC:
1605 pData->ab2DOn[iDisplay] = false;
1606 return false;
1607 default:
1608 pData->rc = VERR_INVALID_STATE;
1609 return false;
1610 }
1611}
1612#endif /* #ifdef VBOX_WITH_VIDEOHWACCEL */
1613
1614int vboxVBVASaveDevStateExec(PCPDMDEVHLPR3 pHlp, PVGASTATE pVGAState, PSSMHANDLE pSSM)
1615{
1616 PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
1617 int rc = HGSMIHostSaveStateExec(pHlp, pIns, pSSM);
1618 if (RT_SUCCESS(rc))
1619 {
1620 VGA_SAVED_STATE_PUT_MARKER(pSSM, 2);
1621
1622 /* Save VBVACONTEXT. */
1623 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext (pIns);
1624
1625 if (!pCtx)
1626 {
1627 AssertFailed();
1628
1629 /* Still write a valid value to the SSM. */
1630 rc = pHlp->pfnSSMPutU32 (pSSM, 0);
1631 AssertRCReturn(rc, rc);
1632 }
1633 else
1634 {
1635#ifdef DEBUG_sunlover
1636 dumpctx(pCtx);
1637#endif
1638
1639 rc = pHlp->pfnSSMPutU32 (pSSM, pCtx->cViews);
1640 AssertRCReturn(rc, rc);
1641
1642 uint32_t iView;
1643 for (iView = 0; iView < pCtx->cViews; iView++)
1644 {
1645 VBVAVIEW *pView = &pCtx->aViews[iView];
1646
1647 rc = pHlp->pfnSSMPutU32(pSSM, pView->view.u32ViewIndex);
1648 AssertRCReturn(rc, rc);
1649 rc = pHlp->pfnSSMPutU32(pSSM, pView->view.u32ViewOffset);
1650 AssertRCReturn(rc, rc);
1651 rc = pHlp->pfnSSMPutU32(pSSM, pView->view.u32ViewSize);
1652 AssertRCReturn(rc, rc);
1653 rc = pHlp->pfnSSMPutU32(pSSM, pView->view.u32MaxScreenSize);
1654 AssertRCReturn(rc, rc);
1655
1656 rc = pHlp->pfnSSMPutU32(pSSM, pView->screen.u32ViewIndex);
1657 AssertRCReturn(rc, rc);
1658 rc = pHlp->pfnSSMPutS32(pSSM, pView->screen.i32OriginX);
1659 AssertRCReturn(rc, rc);
1660 rc = pHlp->pfnSSMPutS32(pSSM, pView->screen.i32OriginY);
1661 AssertRCReturn(rc, rc);
1662 rc = pHlp->pfnSSMPutU32(pSSM, pView->screen.u32StartOffset);
1663 AssertRCReturn(rc, rc);
1664 rc = pHlp->pfnSSMPutU32(pSSM, pView->screen.u32LineSize);
1665 AssertRCReturn(rc, rc);
1666 rc = pHlp->pfnSSMPutU32(pSSM, pView->screen.u32Width);
1667 AssertRCReturn(rc, rc);
1668 rc = pHlp->pfnSSMPutU32(pSSM, pView->screen.u32Height);
1669 AssertRCReturn(rc, rc);
1670 rc = pHlp->pfnSSMPutU16(pSSM, pView->screen.u16BitsPerPixel);
1671 AssertRCReturn(rc, rc);
1672 rc = pHlp->pfnSSMPutU16(pSSM, pView->screen.u16Flags);
1673 AssertRCReturn(rc, rc);
1674
1675 rc = pHlp->pfnSSMPutU32(pSSM, pView->vbva.guest.pVBVA? pView->vbva.u32VBVAOffset: HGSMIOFFSET_VOID);
1676 AssertRCReturn(rc, rc);
1677
1678 rc = pHlp->pfnSSMPutU32(pSSM, pView->vbva.partialRecord.cb);
1679 AssertRCReturn(rc, rc);
1680
1681 if (pView->vbva.partialRecord.cb > 0)
1682 {
1683 rc = pHlp->pfnSSMPutMem(pSSM, pView->vbva.partialRecord.pu8, pView->vbva.partialRecord.cb);
1684 AssertRCReturn(rc, rc);
1685 }
1686 }
1687
1688 /* Save mouse pointer shape information. */
1689 rc = pHlp->pfnSSMPutBool(pSSM, pCtx->mouseShapeInfo.fSet);
1690 AssertRCReturn(rc, rc);
1691 rc = pHlp->pfnSSMPutBool(pSSM, pCtx->mouseShapeInfo.fVisible);
1692 AssertRCReturn(rc, rc);
1693 rc = pHlp->pfnSSMPutBool(pSSM, pCtx->mouseShapeInfo.fAlpha);
1694 AssertRCReturn(rc, rc);
1695 rc = pHlp->pfnSSMPutU32(pSSM, pCtx->mouseShapeInfo.u32HotX);
1696 AssertRCReturn(rc, rc);
1697 rc = pHlp->pfnSSMPutU32(pSSM, pCtx->mouseShapeInfo.u32HotY);
1698 AssertRCReturn(rc, rc);
1699 rc = pHlp->pfnSSMPutU32(pSSM, pCtx->mouseShapeInfo.u32Width);
1700 AssertRCReturn(rc, rc);
1701 rc = pHlp->pfnSSMPutU32(pSSM, pCtx->mouseShapeInfo.u32Height);
1702 AssertRCReturn(rc, rc);
1703 rc = pHlp->pfnSSMPutU32(pSSM, pCtx->mouseShapeInfo.cbShape);
1704 AssertRCReturn(rc, rc);
1705 if (pCtx->mouseShapeInfo.cbShape)
1706 {
1707 rc = pHlp->pfnSSMPutMem(pSSM, pCtx->mouseShapeInfo.pu8Shape, pCtx->mouseShapeInfo.cbShape);
1708 AssertRCReturn(rc, rc);
1709 }
1710
1711#ifdef VBOX_WITH_WDDM
1712 /* Size of some additional data. For future extensions. */
1713 rc = pHlp->pfnSSMPutU32(pSSM, 4);
1714 AssertRCReturn(rc, rc);
1715 rc = pHlp->pfnSSMPutU32(pSSM, pVGAState->fGuestCaps);
1716 AssertRCReturn(rc, rc);
1717#else
1718 /* Size of some additional data. For future extensions. */
1719 rc = pHlp->pfnSSMPutU32(pSSM, 0);
1720 AssertRCReturn(rc, rc);
1721#endif
1722 rc = pHlp->pfnSSMPutU32(pSSM, RT_ELEMENTS(pCtx->aModeHints));
1723 AssertRCReturn(rc, rc);
1724 rc = pHlp->pfnSSMPutU32(pSSM, sizeof(VBVAMODEHINT));
1725 AssertRCReturn(rc, rc);
1726 for (unsigned i = 0; i < RT_ELEMENTS(pCtx->aModeHints); ++i)
1727 {
1728 rc = pHlp->pfnSSMPutMem(pSSM, &pCtx->aModeHints[i], sizeof(VBVAMODEHINT));
1729 AssertRCReturn(rc, rc);
1730 }
1731 }
1732 }
1733
1734 return rc;
1735}
1736
1737int vboxVBVASaveStateExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
1738{
1739 PVGASTATE pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
1740 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
1741 int rc;
1742#ifdef VBOX_WITH_VIDEOHWACCEL
1743 VBOXVBVASAVEDSTATECBDATA VhwaData = {0};
1744 VhwaData.pSSM = pSSM;
1745 uint32_t cbCmd = sizeof (VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM); /* maximum cmd size */
1746 VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN, 0, cbCmd);
1747 Assert(pCmd);
1748 if(pCmd)
1749 {
1750 vbvaVHWAHHPost(pVGAState, pCmd, NULL, vboxVBVASaveStateBeginPostCb, &VhwaData);
1751 rc = VhwaData.rc;
1752 AssertRC(rc);
1753 if (RT_SUCCESS(rc))
1754 {
1755#endif
1756 rc = vboxVBVASaveDevStateExec(pHlp, pVGAState, pSSM);
1757 AssertRC(rc);
1758#ifdef VBOX_WITH_VIDEOHWACCEL
1759 if (RT_SUCCESS(rc))
1760 {
1761 vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM, 0);
1762 VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM *pSave = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM);
1763 pSave->pSSM = pSSM;
1764 vbvaVHWAHHPost(pVGAState, pCmd, vboxVBVASaveStatePerformPreCb, NULL, &VhwaData);
1765 rc = VhwaData.rc;
1766 AssertRC(rc);
1767 if (RT_SUCCESS(rc))
1768 {
1769 rc = vbvaVHWACommandSavePending(pHlp, pVGAState, pSSM);
1770 AssertRCReturn(rc, rc);
1771
1772 vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND, 0);
1773 vbvaVHWAHHPost(pVGAState, pCmd, vboxVBVASaveStateEndPreCb, NULL, &VhwaData);
1774 rc = VhwaData.rc;
1775 AssertRC(rc);
1776 }
1777 }
1778 }
1779
1780 vbvaVHWAHHCommandRelease(pCmd);
1781 }
1782 else
1783 rc = VERR_OUT_OF_RESOURCES;
1784#else
1785 if (RT_SUCCESS(rc))
1786 {
1787 for (uint32_t i = 0; i < pVGAState->cMonitors; ++i)
1788 {
1789 rc = pHlp->pfnSSMPutU32(pSSM, VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC);
1790 AssertRCReturn(rc, rc);
1791 }
1792 }
1793
1794 /* no pending commands */
1795 pHlp->pfnSSMPutU32(pSSM, 0);
1796#endif
1797 return rc;
1798}
1799
1800int vboxVBVALoadStateExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion)
1801{
1802 if (uVersion < VGA_SAVEDSTATE_VERSION_HGSMI)
1803 {
1804 /* Nothing was saved. */
1805 return VINF_SUCCESS;
1806 }
1807
1808 PVGASTATE pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
1809 PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
1810 PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
1811 int rc = HGSMIHostLoadStateExec(pHlp, pIns, pSSM, uVersion);
1812 if (RT_SUCCESS(rc))
1813 {
1814 VGA_SAVED_STATE_GET_MARKER_RETURN_ON_MISMATCH(pSSM, uVersion, 2);
1815
1816 /* Load VBVACONTEXT. */
1817 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext (pIns);
1818
1819 if (!pCtx)
1820 {
1821 /* This should not happen. */
1822 AssertFailed();
1823 rc = VERR_INVALID_PARAMETER;
1824 }
1825 else
1826 {
1827 uint32_t cViews = 0;
1828 rc = pHlp->pfnSSMGetU32 (pSSM, &cViews);
1829 AssertRCReturn(rc, rc);
1830
1831 uint32_t iView;
1832 for (iView = 0; iView < cViews; iView++)
1833 {
1834 VBVAVIEW *pView = &pCtx->aViews[iView];
1835
1836 rc = pHlp->pfnSSMGetU32 (pSSM, &pView->view.u32ViewIndex);
1837 AssertRCReturn(rc, rc);
1838 rc = pHlp->pfnSSMGetU32 (pSSM, &pView->view.u32ViewOffset);
1839 AssertRCReturn(rc, rc);
1840 rc = pHlp->pfnSSMGetU32 (pSSM, &pView->view.u32ViewSize);
1841 AssertRCReturn(rc, rc);
1842 rc = pHlp->pfnSSMGetU32 (pSSM, &pView->view.u32MaxScreenSize);
1843 AssertRCReturn(rc, rc);
1844
1845 rc = pHlp->pfnSSMGetU32 (pSSM, &pView->screen.u32ViewIndex);
1846 AssertRCReturn(rc, rc);
1847 rc = pHlp->pfnSSMGetS32 (pSSM, &pView->screen.i32OriginX);
1848 AssertRCReturn(rc, rc);
1849 rc = pHlp->pfnSSMGetS32 (pSSM, &pView->screen.i32OriginY);
1850 AssertRCReturn(rc, rc);
1851 rc = pHlp->pfnSSMGetU32 (pSSM, &pView->screen.u32StartOffset);
1852 AssertRCReturn(rc, rc);
1853 rc = pHlp->pfnSSMGetU32 (pSSM, &pView->screen.u32LineSize);
1854 AssertRCReturn(rc, rc);
1855 rc = pHlp->pfnSSMGetU32 (pSSM, &pView->screen.u32Width);
1856 AssertRCReturn(rc, rc);
1857 rc = pHlp->pfnSSMGetU32 (pSSM, &pView->screen.u32Height);
1858 AssertRCReturn(rc, rc);
1859 rc = pHlp->pfnSSMGetU16 (pSSM, &pView->screen.u16BitsPerPixel);
1860 AssertRCReturn(rc, rc);
1861 rc = pHlp->pfnSSMGetU16 (pSSM, &pView->screen.u16Flags);
1862 AssertRCReturn(rc, rc);
1863
1864 rc = pHlp->pfnSSMGetU32 (pSSM, &pView->vbva.u32VBVAOffset);
1865 AssertRCReturn(rc, rc);
1866
1867 rc = pHlp->pfnSSMGetU32 (pSSM, &pView->vbva.partialRecord.cb);
1868 AssertRCReturn(rc, rc);
1869
1870 if (pView->vbva.partialRecord.cb == 0)
1871 {
1872 pView->vbva.partialRecord.pu8 = NULL;
1873 }
1874 else
1875 {
1876 Assert(pView->vbva.partialRecord.pu8 == NULL); /* Should be it. */
1877
1878 uint8_t *pu8 = (uint8_t *)RTMemAlloc(pView->vbva.partialRecord.cb);
1879
1880 if (!pu8)
1881 {
1882 return VERR_NO_MEMORY;
1883 }
1884
1885 pView->vbva.partialRecord.pu8 = pu8;
1886
1887 rc = pHlp->pfnSSMGetMem (pSSM, pView->vbva.partialRecord.pu8, pView->vbva.partialRecord.cb);
1888 AssertRCReturn(rc, rc);
1889 }
1890
1891 if (pView->vbva.u32VBVAOffset == HGSMIOFFSET_VOID)
1892 {
1893 pView->vbva.guest.pVBVA = NULL;
1894 }
1895 else
1896 {
1897 pView->vbva.guest.pVBVA = (VBVABUFFER *)HGSMIOffsetToPointerHost(pIns, pView->vbva.u32VBVAOffset);
1898 }
1899 }
1900
1901 if (uVersion > VGA_SAVEDSTATE_VERSION_WITH_CONFIG)
1902 {
1903 /* Read mouse pointer shape information. */
1904 rc = pHlp->pfnSSMGetBool (pSSM, &pCtx->mouseShapeInfo.fSet);
1905 AssertRCReturn(rc, rc);
1906 rc = pHlp->pfnSSMGetBool (pSSM, &pCtx->mouseShapeInfo.fVisible);
1907 AssertRCReturn(rc, rc);
1908 rc = pHlp->pfnSSMGetBool (pSSM, &pCtx->mouseShapeInfo.fAlpha);
1909 AssertRCReturn(rc, rc);
1910 rc = pHlp->pfnSSMGetU32 (pSSM, &pCtx->mouseShapeInfo.u32HotX);
1911 AssertRCReturn(rc, rc);
1912 rc = pHlp->pfnSSMGetU32 (pSSM, &pCtx->mouseShapeInfo.u32HotY);
1913 AssertRCReturn(rc, rc);
1914 rc = pHlp->pfnSSMGetU32 (pSSM, &pCtx->mouseShapeInfo.u32Width);
1915 AssertRCReturn(rc, rc);
1916 rc = pHlp->pfnSSMGetU32 (pSSM, &pCtx->mouseShapeInfo.u32Height);
1917 AssertRCReturn(rc, rc);
1918 rc = pHlp->pfnSSMGetU32 (pSSM, &pCtx->mouseShapeInfo.cbShape);
1919 AssertRCReturn(rc, rc);
1920 if (pCtx->mouseShapeInfo.cbShape)
1921 {
1922 pCtx->mouseShapeInfo.pu8Shape = (uint8_t *)RTMemAlloc(pCtx->mouseShapeInfo.cbShape);
1923 if (pCtx->mouseShapeInfo.pu8Shape == NULL)
1924 {
1925 return VERR_NO_MEMORY;
1926 }
1927 pCtx->mouseShapeInfo.cbAllocated = pCtx->mouseShapeInfo.cbShape;
1928 rc = pHlp->pfnSSMGetMem (pSSM, pCtx->mouseShapeInfo.pu8Shape, pCtx->mouseShapeInfo.cbShape);
1929 AssertRCReturn(rc, rc);
1930 }
1931 else
1932 {
1933 pCtx->mouseShapeInfo.pu8Shape = NULL;
1934 }
1935
1936 /* Size of some additional data. For future extensions. */
1937 uint32_t cbExtra = 0;
1938 rc = pHlp->pfnSSMGetU32 (pSSM, &cbExtra);
1939 AssertRCReturn(rc, rc);
1940#ifdef VBOX_WITH_WDDM
1941 if (cbExtra >= 4)
1942 {
1943 rc = pHlp->pfnSSMGetU32 (pSSM, &pVGAState->fGuestCaps);
1944 AssertRCReturn(rc, rc);
1945 pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
1946 cbExtra -= 4;
1947 }
1948#endif
1949 if (cbExtra > 0)
1950 {
1951 rc = pHlp->pfnSSMSkip(pSSM, cbExtra);
1952 AssertRCReturn(rc, rc);
1953 }
1954
1955 if (uVersion >= VGA_SAVEDSTATE_VERSION_MODE_HINTS)
1956 {
1957 uint32_t cModeHints, cbModeHints;
1958 rc = pHlp->pfnSSMGetU32 (pSSM, &cModeHints);
1959 AssertRCReturn(rc, rc);
1960 rc = pHlp->pfnSSMGetU32 (pSSM, &cbModeHints);
1961 AssertRCReturn(rc, rc);
1962 memset(&pCtx->aModeHints, ~0, sizeof(pCtx->aModeHints));
1963 unsigned iHint;
1964 for (iHint = 0; iHint < cModeHints; ++iHint)
1965 {
1966 if ( cbModeHints <= sizeof(VBVAMODEHINT)
1967 && iHint < RT_ELEMENTS(pCtx->aModeHints))
1968 rc = pHlp->pfnSSMGetMem(pSSM, &pCtx->aModeHints[iHint],
1969 cbModeHints);
1970 else
1971 rc = pHlp->pfnSSMSkip(pSSM, cbModeHints);
1972 AssertRCReturn(rc, rc);
1973 }
1974 }
1975 }
1976
1977 pCtx->cViews = iView;
1978 LogFlowFunc(("%d views loaded\n", pCtx->cViews));
1979
1980 if (uVersion > VGA_SAVEDSTATE_VERSION_WDDM)
1981 {
1982 bool fLoadCommands;
1983
1984 if (uVersion < VGA_SAVEDSTATE_VERSION_FIXED_PENDVHWA)
1985 {
1986 const char *pcszOsArch = pHlp->pfnSSMHandleHostOSAndArch(pSSM);
1987 Assert(pcszOsArch);
1988 fLoadCommands = !pcszOsArch || RTStrNCmp(pcszOsArch, RT_STR_TUPLE("solaris"));
1989 }
1990 else
1991 fLoadCommands = true;
1992
1993#ifdef VBOX_WITH_VIDEOHWACCEL
1994 uint32_t cbCmd = sizeof (VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM); /* maximum cmd size */
1995 VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM, 0, cbCmd);
1996 Assert(pCmd);
1997 if(pCmd)
1998 {
1999 VBOXVBVASAVEDSTATECBDATA VhwaData = {0};
2000 VhwaData.pSSM = pSSM;
2001 VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM *pLoad = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM);
2002 pLoad->pSSM = pSSM;
2003 vbvaVHWAHHPost (pVGAState, pCmd, vboxVBVALoadStatePerformPreCb, vboxVBVALoadStatePerformPostCb, &VhwaData);
2004 rc = VhwaData.rc;
2005 vbvaVHWAHHCommandRelease(pCmd);
2006 AssertRCReturn(rc, rc);
2007
2008 if (fLoadCommands)
2009 {
2010 rc = vbvaVHWACommandLoadPending(pHlp, pVGAState, pSSM, uVersion);
2011 AssertRCReturn(rc, rc);
2012 }
2013 }
2014 else
2015 {
2016 rc = VERR_OUT_OF_RESOURCES;
2017 }
2018#else
2019 uint32_t u32;
2020
2021 for (uint32_t i = 0; i < pVGAState->cMonitors; ++i)
2022 {
2023 rc = pHlp->pfnSSMGetU32(pSSM, &u32);
2024 AssertRCReturn(rc, rc);
2025
2026 if (u32 != VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC)
2027 {
2028 LogRel(("VBVA: 2D data while 2D is not supported\n"));
2029 return VERR_NOT_SUPPORTED;
2030 }
2031 }
2032
2033 if (fLoadCommands)
2034 {
2035 rc = pHlp->pfnSSMGetU32(pSSM, &u32);
2036 AssertRCReturn(rc, rc);
2037
2038 if (u32)
2039 {
2040 LogRel(("VBVA: 2D pending command while 2D is not supported\n"));
2041 return VERR_NOT_SUPPORTED;
2042 }
2043 }
2044#endif
2045 }
2046
2047#ifdef DEBUG_sunlover
2048 dumpctx(pCtx);
2049#endif
2050 }
2051 }
2052
2053 return rc;
2054}
2055
2056int vboxVBVALoadStateDone(PPDMDEVINS pDevIns)
2057{
2058 PVGASTATE pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
2059 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pVGAState->pHGSMI);
2060 if (pCtx)
2061 {
2062 uint32_t iView;
2063 for (iView = 0; iView < pCtx->cViews; iView++)
2064 {
2065 VBVAVIEW *pView = &pCtx->aViews[iView];
2066 if (pView->vbva.guest.pVBVA)
2067 {
2068 int rc = vbvaEnable(iView, pVGAState, pCtx, pView->vbva.guest.pVBVA, pView->vbva.u32VBVAOffset, true /* fRestored */);
2069 if (RT_SUCCESS(rc))
2070 vbvaResize(pVGAState, pView, &pView->screen, false);
2071 else
2072 LogRel(("VBVA: can not restore: %Rrc\n", rc));
2073 }
2074 }
2075
2076 if (pCtx->mouseShapeInfo.fSet)
2077 vbvaUpdateMousePointerShape(pVGAState, &pCtx->mouseShapeInfo, true);
2078 }
2079
2080 return VINF_SUCCESS;
2081}
2082
2083void VBVARaiseIrq(PVGASTATE pVGAState, uint32_t fFlags)
2084{
2085 PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
2086
2087 PDMDevHlpCritSectEnter(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSectIRQ, VERR_SEM_BUSY);
2088
2089 const uint32_t fu32CurrentGuestFlags = HGSMIGetHostGuestFlags(pVGAState->pHGSMI);
2090 if ((fu32CurrentGuestFlags & HGSMIHOSTFLAGS_IRQ) == 0)
2091 {
2092 /* No IRQ set yet. */
2093 Assert(pVGAState->fu32PendingGuestFlags == 0);
2094
2095 HGSMISetHostGuestFlags(pVGAState->pHGSMI, HGSMIHOSTFLAGS_IRQ | fFlags);
2096
2097 /* If VM is not running, the IRQ will be set in VBVAOnResume. */
2098 const VMSTATE enmVMState = PDMDevHlpVMState(pDevIns);
2099 if ( enmVMState == VMSTATE_RUNNING
2100 || enmVMState == VMSTATE_RUNNING_LS)
2101 PDMDevHlpPCISetIrqNoWait(pDevIns, 0, PDM_IRQ_LEVEL_HIGH);
2102 }
2103 else
2104 {
2105 /* IRQ already set, remember the new flags. */
2106 pVGAState->fu32PendingGuestFlags |= HGSMIHOSTFLAGS_IRQ | fFlags;
2107 }
2108
2109 PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSectIRQ);
2110}
2111
2112void VBVAOnResume(PVGASTATE pThis)
2113{
2114 PPDMDEVINS pDevIns = pThis->pDevInsR3;
2115
2116 PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSectIRQ, VERR_SEM_BUSY);
2117
2118 if (HGSMIGetHostGuestFlags(pThis->pHGSMI) & HGSMIHOSTFLAGS_IRQ)
2119 PDMDevHlpPCISetIrqNoWait(pDevIns, 0, PDM_IRQ_LEVEL_HIGH);
2120
2121 PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSectIRQ);
2122}
2123
2124static int vbvaHandleQueryConf32(PVGASTATE pVGAState, VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *pConf32)
2125{
2126 uint32_t const idxQuery = pConf32->u32Index;
2127 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2128 LogFlowFunc(("VBVA_QUERY_CONF32: u32Index %d, u32Value 0x%x\n", idxQuery, pConf32->u32Value));
2129
2130 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pVGAState->pHGSMI);
2131 uint32_t uValue;
2132 if (idxQuery == VBOX_VBVA_CONF32_MONITOR_COUNT)
2133 uValue = pCtx->cViews;
2134 else if (idxQuery == VBOX_VBVA_CONF32_HOST_HEAP_SIZE)
2135 uValue = _64K; /** @todo a value calculated from the vram size */
2136 else if ( idxQuery == VBOX_VBVA_CONF32_MODE_HINT_REPORTING
2137 || idxQuery == VBOX_VBVA_CONF32_GUEST_CURSOR_REPORTING)
2138 uValue = VINF_SUCCESS;
2139 else if (idxQuery == VBOX_VBVA_CONF32_CURSOR_CAPABILITIES)
2140 uValue = VBOX_VBVA_CURSOR_CAPABILITY_HARDWARE;
2141 else if (idxQuery == VBOX_VBVA_CONF32_SCREEN_FLAGS)
2142 uValue = VBVA_SCREEN_F_ACTIVE
2143 | VBVA_SCREEN_F_DISABLED
2144 | VBVA_SCREEN_F_BLANK
2145 | VBVA_SCREEN_F_BLANK2;
2146 else if (idxQuery == VBOX_VBVA_CONF32_MAX_RECORD_SIZE)
2147 uValue = VBVA_MAX_RECORD_SIZE;
2148 else if (idxQuery == UINT32_MAX)
2149 uValue = UINT32_MAX; /* Older GA uses this for sanity checking. See testQueryConf in HGSMIBase.cpp on branches. */
2150 else
2151 ASSERT_GUEST_MSG_FAILED_RETURN(("Invalid index %#x\n", idxQuery), VERR_INVALID_PARAMETER);
2152
2153 pConf32->u32Value = uValue;
2154 return VINF_SUCCESS;
2155}
2156
2157static int vbvaHandleSetConf32(VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *pConf32)
2158{
2159 uint32_t const idxQuery = pConf32->u32Index;
2160 uint32_t const uValue = pConf32->u32Value;
2161 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2162 LogFlowFunc(("VBVA_SET_CONF32: u32Index %d, u32Value 0x%x\n", idxQuery, uValue));
2163
2164 if (idxQuery == VBOX_VBVA_CONF32_MONITOR_COUNT)
2165 { /* do nothing. this is a const. */ }
2166 else if (idxQuery == VBOX_VBVA_CONF32_HOST_HEAP_SIZE)
2167 { /* do nothing. this is a const. */ }
2168 else
2169 ASSERT_GUEST_MSG_FAILED_RETURN(("Invalid index %#x (value=%u)\n", idxQuery, uValue), VERR_INVALID_PARAMETER);
2170
2171 RT_NOREF_PV(uValue);
2172 return VINF_SUCCESS;
2173}
2174
2175static int vbvaHandleInfoHeap(PVGASTATE pVGAState, const VBVAINFOHEAP RT_UNTRUSTED_VOLATILE_GUEST *pInfoHeap)
2176{
2177 uint32_t const offHeap = pInfoHeap->u32HeapOffset;
2178 uint32_t const cbHeap = pInfoHeap->u32HeapSize;
2179 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2180 LogFlowFunc(("VBVA_INFO_HEAP: offset 0x%x, size 0x%x\n", offHeap, cbHeap));
2181
2182 return HGSMIHostHeapSetup(pVGAState->pHGSMI, offHeap, cbHeap);
2183}
2184
2185int VBVAInfoView(PVGASTATE pVGAState, const VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_GUEST *pView)
2186{
2187 VBVAINFOVIEW view;
2188 RT_COPY_VOLATILE(view, *pView);
2189 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2190
2191 LogFlowFunc(("VBVA_INFO_VIEW: u32ViewIndex %d, u32ViewOffset 0x%x, u32ViewSize 0x%x, u32MaxScreenSize 0x%x\n",
2192 view.u32ViewIndex, view.u32ViewOffset, view.u32ViewSize, view.u32MaxScreenSize));
2193
2194 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pVGAState->pHGSMI);
2195 ASSERT_GUEST_LOGREL_MSG_RETURN( view.u32ViewIndex < pCtx->cViews
2196 && view.u32ViewOffset <= pVGAState->vram_size
2197 && view.u32ViewSize <= pVGAState->vram_size
2198 && view.u32ViewOffset <= pVGAState->vram_size - view.u32ViewSize
2199 && view.u32MaxScreenSize <= view.u32ViewSize,
2200 ("index %d(%d), offset 0x%x, size 0x%x, max 0x%x, vram size 0x%x\n",
2201 view.u32ViewIndex, pCtx->cViews, view.u32ViewOffset, view.u32ViewSize,
2202 view.u32MaxScreenSize, pVGAState->vram_size),
2203 VERR_INVALID_PARAMETER);
2204 RT_UNTRUSTED_VALIDATED_FENCE();
2205
2206 pCtx->aViews[view.u32ViewIndex].view = view;
2207 return VINF_SUCCESS;
2208}
2209
2210int VBVAInfoScreen(PVGASTATE pVGAState, const VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_GUEST *pScreen)
2211{
2212 /*
2213 * Copy input into non-volatile buffer.
2214 */
2215 VBVAINFOSCREEN screen;
2216 RT_COPY_VOLATILE(screen, *pScreen);
2217 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2218 LogRel2(("VBVA: InfoScreen: [%d] @%d,%d %dx%d, line 0x%x, BPP %d, flags 0x%x\n",
2219 screen.u32ViewIndex, screen.i32OriginX, screen.i32OriginY,
2220 screen.u32Width, screen.u32Height,
2221 screen.u32LineSize, screen.u16BitsPerPixel, screen.u16Flags));
2222
2223 /*
2224 * Validate input.
2225 */
2226 /* Allow screen.u16BitsPerPixel == 0 because legacy guest code used it for screen blanking. */
2227 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pVGAState->pHGSMI);
2228 ASSERT_GUEST_LOGREL_MSG_RETURN(screen.u32ViewIndex < pCtx->cViews,
2229 ("Screen index %#x is out of bound (cViews=%#x)\n", screen.u32ViewIndex, pCtx->cViews),
2230 VERR_INVALID_PARAMETER);
2231 ASSERT_GUEST_LOGREL_MSG_RETURN( screen.u16BitsPerPixel <= 32
2232 && screen.u32Width <= UINT16_MAX
2233 && screen.u32Height <= UINT16_MAX
2234 && screen.u32LineSize <= UINT16_MAX * UINT32_C(4),
2235 ("One or more values out of range: u16BitsPerPixel=%#x u32Width=%#x u32Height=%#x u32LineSize=%#x\n",
2236 screen.u16BitsPerPixel, screen.u32Width, screen.u32Height, screen.u32LineSize),
2237 VERR_INVALID_PARAMETER);
2238 RT_UNTRUSTED_VALIDATED_FENCE();
2239
2240 const VBVAINFOVIEW *pView = &pCtx->aViews[screen.u32ViewIndex].view;
2241 const uint32_t cbPerPixel = (screen.u16BitsPerPixel + 7) / 8;
2242 ASSERT_GUEST_LOGREL_MSG_RETURN(screen.u32Width <= screen.u32LineSize / (cbPerPixel ? cbPerPixel : 1),
2243 ("u32Width=%#x u32LineSize=%3x cbPerPixel=%#x\n",
2244 screen.u32Width, screen.u32LineSize, cbPerPixel),
2245 VERR_INVALID_PARAMETER);
2246
2247 const uint64_t u64ScreenSize = (uint64_t)screen.u32LineSize * screen.u32Height;
2248
2249 ASSERT_GUEST_LOGREL_MSG_RETURN( screen.u32StartOffset <= pView->u32ViewSize
2250 && u64ScreenSize <= pView->u32MaxScreenSize
2251 && screen.u32StartOffset <= pView->u32ViewSize - (uint32_t)u64ScreenSize,
2252 ("u32StartOffset=%#x u32ViewSize=%#x u64ScreenSize=%#RX64 u32MaxScreenSize=%#x\n",
2253 screen.u32StartOffset, pView->u32ViewSize, u64ScreenSize, pView->u32MaxScreenSize),
2254 VERR_INVALID_PARAMETER);
2255 RT_UNTRUSTED_VALIDATED_FENCE();
2256
2257 /*
2258 * Do the job.
2259 */
2260 vbvaResize(pVGAState, &pCtx->aViews[screen.u32ViewIndex], &screen, true);
2261 return VINF_SUCCESS;
2262}
2263
2264int VBVAGetInfoViewAndScreen(PVGASTATE pVGAState, uint32_t u32ViewIndex, VBVAINFOVIEW *pView, VBVAINFOSCREEN *pScreen)
2265{
2266 if (u32ViewIndex >= pVGAState->cMonitors)
2267 return VERR_INVALID_PARAMETER;
2268
2269 PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
2270 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext (pIns);
2271
2272 if (pView)
2273 *pView = pCtx->aViews[u32ViewIndex].view;
2274
2275 if (pScreen)
2276 *pScreen = pCtx->aViews[u32ViewIndex].screen;
2277
2278 return VINF_SUCCESS;
2279}
2280
2281static int vbvaHandleEnable(PVGASTATE pVGAState, uint32_t fEnableFlags, uint32_t offEnable, uint32_t idScreen)
2282{
2283 LogFlowFunc(("VBVA_ENABLE[%u]: fEnableFlags=0x%x offEnable=%#x\n", idScreen, fEnableFlags, offEnable));
2284 PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
2285 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pIns);
2286
2287 /*
2288 * Validate input.
2289 */
2290 ASSERT_GUEST_LOGREL_MSG_RETURN(idScreen < pCtx->cViews, ("idScreen=%#x cViews=%#x\n", idScreen, pCtx->cViews), VERR_INVALID_PARAMETER);
2291 ASSERT_GUEST_LOGREL_MSG_RETURN( (fEnableFlags & (VBVA_F_ENABLE | VBVA_F_DISABLE)) == VBVA_F_ENABLE
2292 || (fEnableFlags & (VBVA_F_ENABLE | VBVA_F_DISABLE)) == VBVA_F_DISABLE,
2293 ("fEnableFlags=%#x\n", fEnableFlags),
2294 VERR_INVALID_PARAMETER);
2295 if (fEnableFlags & VBVA_F_ENABLE)
2296 {
2297 ASSERT_GUEST_LOGREL_MSG_RETURN(offEnable < pVGAState->vram_size,
2298 ("offEnable=%#x vram_size=%#x\n", offEnable, pVGAState->vram_size),
2299 VERR_INVALID_PARAMETER);
2300 if (fEnableFlags & VBVA_F_ABSOFFSET)
2301 /* Offset from VRAM start. */
2302 ASSERT_GUEST_LOGREL_MSG_RETURN( pVGAState->vram_size >= RT_UOFFSETOF(VBVABUFFER, au8Data)
2303 && offEnable <= pVGAState->vram_size - RT_UOFFSETOF(VBVABUFFER, au8Data),
2304 ("offEnable=%#x vram_size=%#x\n", offEnable, pVGAState->vram_size),
2305 VERR_INVALID_PARAMETER);
2306 else
2307 {
2308 /* Offset from the view start. We'd be using idScreen here to fence required. */
2309 RT_UNTRUSTED_VALIDATED_FENCE();
2310 const VBVAINFOVIEW *pView = &pCtx->aViews[idScreen].view;
2311 ASSERT_GUEST_LOGREL_MSG_RETURN( pVGAState->vram_size - offEnable >= pView->u32ViewOffset
2312 && pView->u32ViewSize >= RT_UOFFSETOF(VBVABUFFER, au8Data)
2313 && offEnable <= pView->u32ViewSize - RT_UOFFSETOF(VBVABUFFER, au8Data),
2314 ("offEnable=%#x vram_size=%#x view: %#x LB %#x\n",
2315 offEnable, pVGAState->vram_size, pView->u32ViewOffset, pView->u32ViewSize),
2316 VERR_INVALID_PARAMETER);
2317 offEnable += pView->u32ViewOffset;
2318 }
2319 ASSERT_GUEST_LOGREL_MSG_RETURN(HGSMIIsOffsetValid(pIns, offEnable),
2320 ("offEnable=%#x area %#x LB %#x\n",
2321 offEnable, HGSMIGetAreaOffset(pIns), HGSMIGetAreaSize(pIns)),
2322 VERR_INVALID_PARAMETER);
2323 }
2324 RT_UNTRUSTED_VALIDATED_FENCE();
2325
2326 /*
2327 * Execute.
2328 */
2329 int rc = VINF_SUCCESS;
2330 if (fEnableFlags & VBVA_F_ENABLE)
2331 {
2332 VBVABUFFER RT_UNTRUSTED_VOLATILE_GUEST *pVBVA
2333 = (VBVABUFFER RT_UNTRUSTED_VOLATILE_GUEST *)HGSMIOffsetToPointerHost(pIns, offEnable);
2334 ASSERT_GUEST_LOGREL_RETURN(pVBVA, VERR_INVALID_PARAMETER); /* already check above, but let's be careful. */
2335
2336 /* Process any pending orders and empty the VBVA ring buffer. */
2337 vbvaFlush(pVGAState, pCtx);
2338
2339 rc = vbvaEnable(idScreen, pVGAState, pCtx, pVBVA, offEnable, false /* fRestored */);
2340 if (RT_FAILURE(rc))
2341 LogRelMax(8, ("VBVA: can not enable: %Rrc\n", rc));
2342 }
2343 else
2344 rc = vbvaDisable(idScreen, pVGAState, pCtx);
2345 return rc;
2346}
2347
2348static int vbvaHandleQueryModeHints(PVGASTATE pVGAState, VBVAQUERYMODEHINTS volatile *pQueryModeHints, HGSMISIZE cbBuffer)
2349{
2350 PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
2351 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pIns);
2352
2353 /*
2354 * Copy and validate the request.
2355 */
2356 uint16_t const cHintsQueried = pQueryModeHints->cHintsQueried;
2357 uint16_t const cbHintStructureGuest = pQueryModeHints->cbHintStructureGuest;
2358 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2359
2360 LogRelFlowFunc(("VBVA: HandleQueryModeHints: cHintsQueried=%RU16, cbHintStructureGuest=%RU16\n",
2361 cHintsQueried, cbHintStructureGuest));
2362 ASSERT_GUEST_RETURN(cbBuffer >= sizeof(VBVAQUERYMODEHINTS) + (uint32_t)cHintsQueried * cbHintStructureGuest,
2363 VERR_INVALID_PARAMETER);
2364 RT_UNTRUSTED_VALIDATED_FENCE();
2365
2366 /*
2367 * Produce the requested data.
2368 */
2369 uint8_t *pbHint = (uint8_t *)(pQueryModeHints + 1);
2370 memset(pbHint, ~0, cbBuffer - sizeof(VBVAQUERYMODEHINTS));
2371
2372 for (unsigned iHint = 0; iHint < cHintsQueried && iHint < VBOX_VIDEO_MAX_SCREENS; ++iHint)
2373 {
2374 memcpy(pbHint, &pCtx->aModeHints[iHint], RT_MIN(cbHintStructureGuest, sizeof(VBVAMODEHINT)));
2375 pbHint += cbHintStructureGuest;
2376 Assert((uintptr_t)(pbHint - (uint8_t *)pQueryModeHints) <= cbBuffer);
2377 }
2378
2379 return VINF_SUCCESS;
2380}
2381
2382/*
2383 *
2384 * New VBVA uses a new interface id: #define VBE_DISPI_ID_VBOX_VIDEO 0xBE01
2385 *
2386 * VBVA uses two 32 bits IO ports to write VRAM offsets of shared memory blocks for commands.
2387 * Read Write
2388 * Host port 0x3b0 to process completed
2389 * Guest port 0x3d0 control value? to process
2390 *
2391 */
2392
2393static DECLCALLBACK(void) vbvaNotifyGuest (void *pvCallback)
2394{
2395#if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VIDEOHWACCEL) || defined(VBOX_WITH_VDMA) || defined(VBOX_WITH_WDDM))
2396 PVGASTATE pVGAState = (PVGASTATE)pvCallback;
2397 VBVARaiseIrq (pVGAState, 0);
2398#else
2399 NOREF(pvCallback);
2400 /* Do nothing. Later the VMMDev/VGA IRQ can be used for the notification. */
2401#endif
2402}
2403
2404/**
2405 * The guest submitted a command buffer (hit VGA_PORT_HGSMI_GUEST).
2406 *
2407 * Verify the buffer size and invoke corresponding handler.
2408 *
2409 * @return VBox status code.
2410 * @param pvHandler The VBVA channel context.
2411 * @param u16ChannelInfo Command code.
2412 * @param pvBuffer HGSMI buffer with command data. Considered volatile!
2413 * @param cbBuffer Size of command data.
2414 *
2415 * @thread EMT
2416 */
2417static DECLCALLBACK(int) vbvaChannelHandler(void *pvHandler, uint16_t u16ChannelInfo,
2418 void RT_UNTRUSTED_VOLATILE_GUEST *pvBuffer, HGSMISIZE cbBuffer)
2419{
2420 int rc = VINF_SUCCESS;
2421
2422 LogFlowFunc(("pvHandler %p, u16ChannelInfo %d, pvBuffer %p, cbBuffer %u\n", pvHandler, u16ChannelInfo, pvBuffer, cbBuffer));
2423
2424 PVGASTATE pVGAState = (PVGASTATE)pvHandler;
2425 PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
2426 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pIns);
2427
2428 switch (u16ChannelInfo)
2429 {
2430#ifdef VBOX_WITH_VDMA
2431 case VBVA_VDMA_CMD:
2432 if (cbBuffer >= VBoxSHGSMIBufferHeaderSize() + sizeof(VBOXVDMACBUF_DR))
2433 {
2434 VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_GUEST *pCmd
2435 = (VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_GUEST *)VBoxSHGSMIBufferData((VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
2436 vboxVDMACommand(pVGAState->pVdma, pCmd, cbBuffer - VBoxSHGSMIBufferHeaderSize());
2437 rc = VINF_SUCCESS;
2438 }
2439 else
2440 rc = VERR_INVALID_PARAMETER;
2441 break;
2442
2443 case VBVA_VDMA_CTL:
2444 if (cbBuffer >= VBoxSHGSMIBufferHeaderSize() + sizeof(VBOXVDMA_CTL))
2445 {
2446 VBOXVDMA_CTL RT_UNTRUSTED_VOLATILE_GUEST *pCmd
2447 = (VBOXVDMA_CTL RT_UNTRUSTED_VOLATILE_GUEST *)VBoxSHGSMIBufferData((VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
2448 vboxVDMAControl(pVGAState->pVdma, pCmd, cbBuffer - VBoxSHGSMIBufferHeaderSize());
2449 }
2450 else
2451 rc = VERR_INVALID_PARAMETER;
2452 break;
2453#endif /* VBOX_WITH_VDMA */
2454
2455 case VBVA_QUERY_CONF32:
2456 if (cbBuffer >= sizeof(VBVACONF32))
2457 rc = vbvaHandleQueryConf32(pVGAState, (VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
2458 else
2459 rc = VERR_INVALID_PARAMETER;
2460 break;
2461
2462 case VBVA_SET_CONF32:
2463 if (cbBuffer >= sizeof(VBVACONF32))
2464 rc = vbvaHandleSetConf32((VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
2465 else
2466 rc = VERR_INVALID_PARAMETER;
2467 break;
2468
2469 case VBVA_INFO_VIEW:
2470 /* Expect at least one VBVAINFOVIEW structure. */
2471 rc = VERR_INVALID_PARAMETER;
2472 if (cbBuffer >= sizeof(VBVAINFOVIEW))
2473 {
2474 /* Guest submits an array of VBVAINFOVIEW structures. */
2475 const VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_GUEST *pView = (VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
2476 for (;
2477 cbBuffer >= sizeof(VBVAINFOVIEW);
2478 ++pView, cbBuffer -= sizeof(VBVAINFOVIEW))
2479 {
2480 rc = VBVAInfoView(pVGAState, pView);
2481 if (RT_FAILURE(rc))
2482 break;
2483 }
2484 }
2485 break;
2486
2487 case VBVA_INFO_HEAP:
2488 if (cbBuffer >= sizeof(VBVAINFOHEAP))
2489 rc = vbvaHandleInfoHeap(pVGAState, (VBVAINFOHEAP RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
2490 else
2491 rc = VERR_INVALID_PARAMETER;
2492 break;
2493
2494 case VBVA_FLUSH:
2495 if (cbBuffer >= sizeof(VBVAFLUSH))
2496 rc = vbvaFlush(pVGAState, pCtx);
2497 else
2498 rc = VERR_INVALID_PARAMETER;
2499 break;
2500
2501 case VBVA_INFO_SCREEN:
2502 rc = VERR_INVALID_PARAMETER;
2503 if (cbBuffer >= sizeof(VBVAINFOSCREEN))
2504 rc = VBVAInfoScreen(pVGAState, (VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
2505 break;
2506
2507 case VBVA_ENABLE:
2508 rc = VERR_INVALID_PARAMETER;
2509 if (cbBuffer >= sizeof(VBVAENABLE))
2510 {
2511 VBVAENABLE RT_UNTRUSTED_VOLATILE_GUEST *pVbvaEnable = (VBVAENABLE RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
2512 uint32_t const fEnableFlags = pVbvaEnable->u32Flags;
2513 uint32_t const offEnable = pVbvaEnable->u32Offset;
2514 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2515
2516 uint32_t idScreen;
2517 if (fEnableFlags & VBVA_F_EXTENDED)
2518 {
2519 ASSERT_GUEST_STMT_BREAK(cbBuffer >= sizeof(VBVAENABLE_EX), rc = VERR_INVALID_PARAMETER);
2520 idScreen = ((VBVAENABLE_EX RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer)->u32ScreenId;
2521 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2522 }
2523 else
2524 idScreen = vbvaViewFromBufferPtr(pIns, pCtx, pvBuffer);
2525
2526 rc = vbvaHandleEnable(pVGAState, fEnableFlags, offEnable, idScreen);
2527 pVbvaEnable->i32Result = rc;
2528 }
2529 break;
2530
2531 case VBVA_MOUSE_POINTER_SHAPE:
2532 if (cbBuffer >= sizeof(VBVAMOUSEPOINTERSHAPE))
2533 {
2534 VBVAMOUSEPOINTERSHAPE RT_UNTRUSTED_VOLATILE_GUEST *pShape
2535 = (VBVAMOUSEPOINTERSHAPE RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
2536 rc = vbvaMousePointerShape(pVGAState, pCtx, pShape, cbBuffer);
2537 pShape->i32Result = rc;
2538 }
2539 else
2540 rc = VERR_INVALID_PARAMETER;
2541 break;
2542
2543
2544#ifdef VBOX_WITH_VIDEOHWACCEL
2545 case VBVA_VHWA_CMD:
2546 if (cbBuffer >= VBOXVHWACMD_HEADSIZE())
2547 {
2548 vbvaVHWAHandleCommand(pVGAState, (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
2549 rc = VINF_SUCCESS;
2550 }
2551 else
2552 rc = VERR_INVALID_PARAMETER;
2553 break;
2554#endif
2555
2556#ifdef VBOX_WITH_WDDM
2557 case VBVA_INFO_CAPS:
2558 if (cbBuffer >= sizeof(VBVACAPS))
2559 {
2560 VBVACAPS RT_UNTRUSTED_VOLATILE_GUEST *pCaps = (VBVACAPS RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
2561 pVGAState->fGuestCaps = pCaps->fCaps;
2562 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2563
2564 pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
2565 pCaps->rc = rc = VINF_SUCCESS;
2566 }
2567 else
2568 rc = VERR_INVALID_PARAMETER;
2569 break;
2570#endif
2571
2572 case VBVA_SCANLINE_CFG:
2573 if (cbBuffer >= sizeof(VBVASCANLINECFG))
2574 {
2575 VBVASCANLINECFG RT_UNTRUSTED_VOLATILE_GUEST *pCfg = (VBVASCANLINECFG RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
2576 pVGAState->fScanLineCfg = pCfg->fFlags;
2577 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2578
2579 pCfg->rc = rc = VINF_SUCCESS;
2580 }
2581 else
2582 rc = VERR_INVALID_PARAMETER;
2583 break;
2584
2585 case VBVA_QUERY_MODE_HINTS:
2586 if (cbBuffer >= sizeof(VBVAQUERYMODEHINTS))
2587 {
2588 VBVAQUERYMODEHINTS RT_UNTRUSTED_VOLATILE_GUEST *pQueryModeHints
2589 = (VBVAQUERYMODEHINTS RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
2590 rc = vbvaHandleQueryModeHints(pVGAState, pQueryModeHints, cbBuffer);
2591 pQueryModeHints->rc = rc;
2592 }
2593 else
2594 rc = VERR_INVALID_PARAMETER;
2595 break;
2596
2597 case VBVA_REPORT_INPUT_MAPPING:
2598 if (cbBuffer >= sizeof(VBVAREPORTINPUTMAPPING))
2599 {
2600 VBVAREPORTINPUTMAPPING inputMapping;
2601 {
2602 VBVAREPORTINPUTMAPPING RT_UNTRUSTED_VOLATILE_GUEST *pInputMapping
2603 = (VBVAREPORTINPUTMAPPING RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
2604 inputMapping.x = pInputMapping->x;
2605 inputMapping.y = pInputMapping->y;
2606 inputMapping.cx = pInputMapping->cx;
2607 inputMapping.cy = pInputMapping->cy;
2608 }
2609 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2610
2611 LogRelFlowFunc(("VBVA: ChannelHandler: VBVA_REPORT_INPUT_MAPPING: x=%RI32, y=%RI32, cx=%RU32, cy=%RU32\n",
2612 inputMapping.x, inputMapping.y, inputMapping.cx, inputMapping.cy));
2613 pVGAState->pDrv->pfnVBVAInputMappingUpdate(pVGAState->pDrv,
2614 inputMapping.x, inputMapping.y,
2615 inputMapping.cx, inputMapping.cy);
2616 rc = VINF_SUCCESS;
2617 }
2618 else
2619 rc = VERR_INVALID_PARAMETER;
2620 break;
2621
2622 case VBVA_CURSOR_POSITION:
2623 if (cbBuffer >= sizeof(VBVACURSORPOSITION))
2624 {
2625 VBVACURSORPOSITION RT_UNTRUSTED_VOLATILE_GUEST *pReport = (VBVACURSORPOSITION RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
2626 VBVACURSORPOSITION Report;
2627 Report.fReportPosition = pReport->fReportPosition;
2628 Report.x = pReport->x;
2629 Report.y = pReport->y;
2630 RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
2631
2632 LogRelFlowFunc(("VBVA: ChannelHandler: VBVA_CURSOR_POSITION: fReportPosition=%RTbool, Id=%RU32, x=%RU32, y=%RU32\n",
2633 RT_BOOL(Report.fReportPosition), vbvaViewFromBufferPtr(pIns, pCtx, pvBuffer), Report.x, Report.y));
2634
2635 pVGAState->pDrv->pfnVBVAReportCursorPosition(pVGAState->pDrv, RT_BOOL(Report.fReportPosition), vbvaViewFromBufferPtr(pIns, pCtx, pvBuffer), Report.x, Report.y);
2636 /* This was only ever briefly used by the guest, and a value
2637 * of zero in both was taken to mean "ignore". */
2638 pReport->x = 0;
2639 pReport->y = 0;
2640 rc = VINF_SUCCESS;
2641 }
2642 else
2643 rc = VERR_INVALID_PARAMETER;
2644 break;
2645
2646 default:
2647 Log(("Unsupported VBVA guest command %d (%#x)!!!\n", u16ChannelInfo, u16ChannelInfo));
2648 break;
2649 }
2650
2651 return rc;
2652}
2653
2654/* When VBVA is paused, then VGA device is allowed to work but
2655 * no HGSMI etc state is changed.
2656 */
2657void VBVAPause(PVGASTATE pVGAState, bool fPause)
2658{
2659 if (!pVGAState || !pVGAState->pHGSMI)
2660 {
2661 return;
2662 }
2663
2664 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pVGAState->pHGSMI);
2665
2666 if (pCtx)
2667 {
2668 pCtx->fPaused = fPause;
2669 }
2670}
2671
2672bool VBVAIsPaused(PVGASTATE pVGAState)
2673{
2674 if (pVGAState && pVGAState->pHGSMI)
2675 {
2676 const VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pVGAState->pHGSMI);
2677 if (pCtx && pCtx->cViews)
2678 {
2679 /* If VBVA is enabled at all. */
2680 const VBVAVIEW *pView = &pCtx->aViews[0];
2681 if (pView->vbva.guest.pVBVA)
2682 return pCtx->fPaused;
2683 }
2684 }
2685 /* VBVA is disabled. */
2686 return true;
2687}
2688
2689void VBVAOnVBEChanged(PVGASTATE pVGAState)
2690{
2691 /* The guest does not depend on host handling the VBE registers. */
2692 if (pVGAState->fGuestCaps & VBVACAPS_USE_VBVA_ONLY)
2693 {
2694 return;
2695 }
2696
2697 VBVAPause(pVGAState, (pVGAState->vbe_regs[VBE_DISPI_INDEX_ENABLE] & VBE_DISPI_ENABLED) == 0);
2698}
2699
2700void VBVAReset (PVGASTATE pVGAState)
2701{
2702 if (!pVGAState || !pVGAState->pHGSMI)
2703 {
2704 return;
2705 }
2706
2707 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext (pVGAState->pHGSMI);
2708
2709#ifdef VBOX_WITH_VIDEOHWACCEL
2710 vbvaVHWAReset (pVGAState);
2711#endif
2712
2713 HGSMIReset(pVGAState->pHGSMI);
2714 /* Make sure the IRQ is reset. */
2715 PDMDevHlpPCISetIrq(pVGAState->pDevInsR3, 0, PDM_IRQ_LEVEL_LOW);
2716 pVGAState->fu32PendingGuestFlags = 0;
2717
2718 if (pCtx)
2719 {
2720 vbvaFlush (pVGAState, pCtx);
2721
2722 unsigned uScreenId;
2723
2724 for (uScreenId = 0; uScreenId < pCtx->cViews; uScreenId++)
2725 {
2726 vbvaDisable (uScreenId, pVGAState, pCtx);
2727 }
2728
2729 pCtx->mouseShapeInfo.fSet = false;
2730 RTMemFree(pCtx->mouseShapeInfo.pu8Shape);
2731 pCtx->mouseShapeInfo.pu8Shape = NULL;
2732 pCtx->mouseShapeInfo.cbAllocated = 0;
2733 pCtx->mouseShapeInfo.cbShape = 0;
2734 }
2735
2736}
2737
2738int VBVAUpdateDisplay (PVGASTATE pVGAState)
2739{
2740 int rc = VERR_NOT_SUPPORTED; /* Assuming that the VGA device will have to do updates. */
2741
2742 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext (pVGAState->pHGSMI);
2743
2744 if (pCtx)
2745 {
2746 if (!pCtx->fPaused)
2747 {
2748 rc = vbvaFlush (pVGAState, pCtx);
2749
2750 if (RT_SUCCESS (rc))
2751 {
2752 if (!pCtx->aViews[0].vbva.guest.pVBVA)
2753 {
2754 /* VBVA is not enabled for the first view, so VGA device must do updates. */
2755 rc = VERR_NOT_SUPPORTED;
2756 }
2757 }
2758 }
2759 }
2760
2761 return rc;
2762}
2763
2764static int vbvaSendModeHintWorker(PVGASTATE pThis, uint32_t cx, uint32_t cy,
2765 uint32_t cBPP, uint32_t iDisplay, uint32_t dx,
2766 uint32_t dy, uint32_t fEnabled,
2767 uint32_t fNotifyGuest)
2768{
2769 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pThis->pHGSMI);
2770 /** @note See Display::setVideoModeHint: "It is up to the guest to decide
2771 * whether the hint is valid. Therefore don't do any VRAM sanity checks
2772 * here! */
2773 if (iDisplay >= RT_MIN(pThis->cMonitors, RT_ELEMENTS(pCtx->aModeHints)))
2774 return VERR_OUT_OF_RANGE;
2775 pCtx->aModeHints[iDisplay].magic = VBVAMODEHINT_MAGIC;
2776 pCtx->aModeHints[iDisplay].cx = cx;
2777 pCtx->aModeHints[iDisplay].cy = cy;
2778 pCtx->aModeHints[iDisplay].cBPP = cBPP;
2779 pCtx->aModeHints[iDisplay].dx = dx;
2780 pCtx->aModeHints[iDisplay].dy = dy;
2781 pCtx->aModeHints[iDisplay].fEnabled = fEnabled;
2782 if (fNotifyGuest && pThis->fGuestCaps & VBVACAPS_IRQ && pThis->fGuestCaps & VBVACAPS_VIDEO_MODE_HINTS)
2783 VBVARaiseIrq(pThis, HGSMIHOSTFLAGS_HOTPLUG);
2784 return VINF_SUCCESS;
2785}
2786
2787/** Converts a display port interface pointer to a vga state pointer. */
2788#define IDISPLAYPORT_2_VGASTATE(pInterface) ( (PVGASTATE)((uintptr_t)pInterface - RT_OFFSETOF(VGASTATE, IPort)) )
2789
2790/**
2791 * @interface_method_impl{PDMIDISPLAYPORT,pfnSendModeHint}
2792 */
2793DECLCALLBACK(int) vbvaR3PortSendModeHint(PPDMIDISPLAYPORT pInterface, uint32_t cx, uint32_t cy, uint32_t cBPP,
2794 uint32_t iDisplay, uint32_t dx, uint32_t dy, uint32_t fEnabled, uint32_t fNotifyGuest)
2795{
2796 PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
2797 int rc = PDMDevHlpCritSectEnter(pThis->pDevInsR3, &pThis->CritSect, VERR_SEM_BUSY);
2798 AssertRC(rc);
2799
2800 rc = vbvaSendModeHintWorker(pThis, cx, cy, cBPP, iDisplay, dx, dy, fEnabled, fNotifyGuest);
2801
2802 PDMDevHlpCritSectLeave(pThis->pDevInsR3, &pThis->CritSect);
2803 return rc;
2804}
2805
2806int VBVAInit(PVGASTATE pVGAState)
2807{
2808 PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
2809
2810 PVM pVM = PDMDevHlpGetVM(pDevIns);
2811
2812 int rc = HGSMICreate(&pVGAState->pHGSMI,
2813 pVM,
2814 "VBVA",
2815 0,
2816 pVGAState->vram_ptrR3,
2817 pVGAState->vram_size,
2818 vbvaNotifyGuest,
2819 pVGAState,
2820 sizeof(VBVACONTEXT));
2821 if (RT_SUCCESS(rc))
2822 {
2823 rc = HGSMIHostChannelRegister(pVGAState->pHGSMI,
2824 HGSMI_CH_VBVA,
2825 vbvaChannelHandler,
2826 pVGAState);
2827 if (RT_SUCCESS(rc))
2828 {
2829 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pVGAState->pHGSMI);
2830 pCtx->cViews = pVGAState->cMonitors;
2831 pCtx->fPaused = true;
2832 memset(pCtx->aModeHints, ~0, sizeof(pCtx->aModeHints));
2833 }
2834 }
2835
2836 return rc;
2837
2838}
2839
2840void VBVADestroy(PVGASTATE pVGAState)
2841{
2842 PHGSMIINSTANCE pHgsmi = pVGAState->pHGSMI;
2843 if (pHgsmi)
2844 {
2845 VBVACONTEXT *pCtx = (VBVACONTEXT *)HGSMIContext(pHgsmi);
2846 pCtx->mouseShapeInfo.fSet = false;
2847 RTMemFree(pCtx->mouseShapeInfo.pu8Shape);
2848 pCtx->mouseShapeInfo.pu8Shape = NULL;
2849 pCtx->mouseShapeInfo.cbAllocated = 0;
2850 pCtx->mouseShapeInfo.cbShape = 0;
2851
2852 HGSMIDestroy(pHgsmi);
2853 pVGAState->pHGSMI = NULL;
2854 }
2855}
2856
Note: See TracBrowser for help on using the repository browser.

© 2023 Oracle
Contact – Privacy policy – Terms of Use