VirtualBox

About
Screenshots
Downloads
Documentation
End-user docs
Technical docs
Contribute
Community

Browse Source

Context Navigation

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

Rev	Line
[44876]	1	/* $Id: DevVGA_VBVA.cpp 82088 2019-11-21 21:59:57Z vboxsync $ */
[23118]	2	/** @file
[22622]	3	* VirtualBox Video Acceleration (VBVA).
	4	*/
	5
	6	/*
[76553]	7	* Copyright (C) 2006-2019 Oracle Corporation
[22622]	8	*
[22652]	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.
[22622]	16	*/
	17
[57358]	18
	19	/*********************************************************************************************************************************
	20	* Header Files *
	21	*********************************************************************************************************************************/
[22622]	22	#define LOG_GROUP LOG_GROUP_DEV_VGA
[35346]	23	#include <VBox/vmm/pdmifs.h>
	24	#include <VBox/vmm/pdmdev.h>
	25	#include <VBox/vmm/pgm.h>
	26	#include <VBox/vmm/ssm.h>
[22622]	27	#include <VBox/VMMDev.h>
[71619]	28	#include <VBox/AssertGuest.h>
[65381]	29	#include <VBoxVideo.h>
[22622]	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
[44876]	45	#define LOGVBVABUFFER(a) do {} while (0)
[22622]	46	#endif
	47
[57358]	48
	49	/*********************************************************************************************************************************
	50	* Structures and Typedefs *
	51	*********************************************************************************************************************************/
[34490]	52	typedef struct VBVAPARTIALRECORD
[22622]	53	{
	54	uint8_t *pu8;
	55	uint32_t cb;
	56	} VBVAPARTIALRECORD;
	57
[56036]	58	typedef struct VBVADATA
	59	{
	60	struct
	61	{
[71619]	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). /
[56036]	64	} guest;
[71619]	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. /
[56036]	72	} VBVADATA;
	73
[34490]	74	typedef struct VBVAVIEW
[22622]	75	{
	76	VBVAINFOVIEW view;
	77	VBVAINFOSCREEN screen;
[56036]	78	VBVADATA vbva;
[22622]	79	} VBVAVIEW;
	80
[24714]	81	typedef 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
[44876]	95	/** @todo saved state: save and restore VBVACONTEXT */
[34490]	96	typedef struct VBVACONTEXT
[22622]	97	{
	98	uint32_t cViews;
[56036]	99	VBVAVIEW aViews[VBOX_VIDEO_MAX_SCREENS];
[24714]	100	VBVAMOUSESHAPEINFO mouseShapeInfo;
[50259]	101	bool fPaused;
[53528]	102	VBVAMODEHINT aModeHints[VBOX_VIDEO_MAX_SCREENS];
[22622]	103	} VBVACONTEXT;
	104
[44876]	105
[56036]	106	static void vbvaDataCleanup(VBVADATA *pVBVAData)
	107	{
	108	if (pVBVAData->guest.pVBVA)
	109	{
[71619]	110	pVBVAData->guest.pVBVA->hostFlags.u32HostEvents = 0;
	111	pVBVAData->guest.pVBVA->hostFlags.u32SupportedOrders = 0;
[56036]	112	}
[56316]	113
[56036]	114	RTMemFree(pVBVAData->partialRecord.pu8);
[44876]	115
[56036]	116	RT_ZERO(*pVBVAData);
	117	pVBVAData->u32VBVAOffset = HGSMIOFFSET_VOID;
	118	}
	119
[71619]	120	/** Copies @a cb bytes from the VBVA ring buffer to the @a pbDst.
[22622]	121	* Used for partial records or for records which cross the ring boundary.
	122	*/
[71619]	123	static bool vbvaFetchBytes(VBVADATA pVBVAData, uint8_t pbDst, uint32_t cb)
[22622]	124	{
[56036]	125	if (cb >= pVBVAData->cbData)
[22622]	126	{
[56036]	127	AssertMsgFailed(("cb = 0x%08X, ring buffer size 0x%08X", cb, pVBVAData->cbData));
	128	return false;
[22622]	129	}
	130
[71619]	131	const uint8_t RT_UNTRUSTED_VOLATILE_GUEST *pbSrc = &pVBVAData->guest.pu8Data[pVBVAData->off32Data];
[56036]	132	const uint32_t u32BytesTillBoundary = pVBVAData->cbData - pVBVAData->off32Data;
[71619]	133	const int32_t i32Diff = cb - u32BytesTillBoundary;
[22622]	134
	135	if (i32Diff <= 0)
	136	{
	137	/* Chunk will not cross buffer boundary. */
[71619]	138	RT_BCOPY_VOLATILE(pbDst, pbSrc, cb);
[22622]	139	}
	140	else
	141	{
	142	/* Chunk crosses buffer boundary. */
[71619]	143	RT_BCOPY_VOLATILE(pbDst, pbSrc, u32BytesTillBoundary);
	144	RT_BCOPY_VOLATILE(pbDst + u32BytesTillBoundary, &pVBVAData->guest.pu8Data[0], i32Diff);
[22622]	145	}
	146
[56036]	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;
[22622]	151	}
	152
	153
[56036]	154	static bool vbvaPartialRead(uint32_t cbRecord, VBVADATA *pVBVAData)
[22622]	155	{
[56036]	156	VBVAPARTIALRECORD *pPartialRecord = &pVBVAData->partialRecord;
[22622]	157	uint8_t *pu8New;
	158
	159	LOGVBVABUFFER(("vbvaPartialRead: p = %p, cb = %d, cbRecord 0x%08X\n",
	160	pPartialRecord->pu8, pPartialRecord->cb, cbRecord));
	161
[56036]	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
[22622]	170	if (pPartialRecord->pu8)
	171	{
[56036]	172	Assert(pPartialRecord->cb);
	173	pu8New = (uint8_t *)RTMemRealloc(pPartialRecord->pu8, cbRecord);
[22622]	174	}
	175	else
	176	{
[56036]	177	Assert(!pPartialRecord->cb);
	178	pu8New = (uint8_t *)RTMemAlloc(cbRecord);
[22622]	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. */
[56036]	191	if (!vbvaFetchBytes(pVBVAData, pu8New + pPartialRecord->cb, cbChunk))
	192	{
	193	return false;
	194	}
[22622]	195
	196	pPartialRecord->pu8 = pu8New;
	197	pPartialRecord->cb = cbRecord;
	198
	199	return true;
	200	}
	201
[71619]	202	/**
	203	* For contiguous chunks just return the address in the buffer. For crossing
	204	* boundary - allocate a buffer from heap.
[22622]	205	*/
[71619]	206	static bool vbvaFetchCmd(VBVADATA pVBVAData, VBVACMDHDR RT_UNTRUSTED_VOLATILE_GUEST ppHdr, uint32_t pcbCmd)
[22622]	207	{
[56036]	208	VBVAPARTIALRECORD *pPartialRecord = &pVBVAData->partialRecord;
	209	uint32_t indexRecordFirst = pVBVAData->indexRecordFirst;
	210	const uint32_t indexRecordFree = ASMAtomicReadU32(&pVBVAData->guest.pVBVA->indexRecordFree);
[22622]	211
	212	LOGVBVABUFFER(("first = %d, free = %d\n",
	213	indexRecordFirst, indexRecordFree));
	214
[56036]	215	if (indexRecordFree >= RT_ELEMENTS(pVBVAData->guest.pVBVA->aRecords))
	216	{
	217	return false;
	218	}
	219
[22622]	220	if (indexRecordFirst == indexRecordFree)
	221	{
	222	/* No records to process. Return without assigning output variables. */
	223	return true;
	224	}
	225
[56036]	226	uint32_t cbRecordCurrent = ASMAtomicReadU32(&pVBVAData->guest.pVBVA->aRecords[indexRecordFirst].cbRecord);
[22622]	227
[39887]	228	LOGVBVABUFFER(("cbRecord = 0x%08X, pPartialRecord->cb = 0x%08X\n", cbRecordCurrent, pPartialRecord->cb));
[22622]	229
[39887]	230	uint32_t cbRecord = cbRecordCurrent & ~VBVA_F_RECORD_PARTIAL;
[22622]	231
[56036]	232	if (cbRecord > VBVA_MAX_RECORD_SIZE)
	233	{
	234	return false;
	235	}
	236
[22622]	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",
[39887]	243	pPartialRecord->cb, cbRecordCurrent, indexRecordFirst, indexRecordFree));
[22622]	244
	245	if (cbRecord > pPartialRecord->cb)
	246	{
	247	/* New data has been added to the record. */
[56036]	248	if (!vbvaPartialRead(cbRecord, pVBVAData))
[22622]	249	{
	250	return false;
	251	}
	252	}
	253
[39887]	254	if (!(cbRecordCurrent & VBVA_F_RECORD_PARTIAL))
[22622]	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
[56036]	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;
[22622]	266
	267	LOGVBVABUFFER(("partial done ok, data = %d, free = %d\n",
[56036]	268	pVBVAData->off32Data, pVBVAData->guest.pVBVA->off32Free));
[22622]	269	}
	270
	271	return true;
	272	}
	273
	274	/* A new record need to be processed. */
[39887]	275	if (cbRecordCurrent & VBVA_F_RECORD_PARTIAL)
[22622]	276	{
	277	/* Current record is being written by guest. '=' is important here,
	278	* because the guest will do a FLUSH at this condition.
[33540]	279	* This partial record is too large for the ring buffer and must
[22622]	280	* be accumulated in an allocated buffer.
	281	*/
[56036]	282	if (cbRecord >= pVBVAData->cbData - pVBVAData->cbPartialWriteThreshold)
[22622]	283	{
	284	/* Partial read must be started. */
[56036]	285	if (!vbvaPartialRead(cbRecord, pVBVAData))
[22622]	286	{
	287	return false;
	288	}
	289
	290	LOGVBVABUFFER(("started partial record cb = 0x%08X cbRecord 0x%08X, first = %d, free = %d\n",
[39887]	291	pPartialRecord->cb, cbRecordCurrent, indexRecordFirst, indexRecordFree));
[22622]	292	}
	293
	294	return true;
	295	}
	296
	297	/* Current record is complete. If it is not empty, process it. */
[56036]	298	if (cbRecord >= pVBVAData->cbData)
	299	{
	300	return false;
	301	}
	302
[22622]	303	if (cbRecord)
	304	{
[56036]	305	/* The size of largest contiguous chunk in the ring buffer. */
	306	uint32_t u32BytesTillBoundary = pVBVAData->cbData - pVBVAData->off32Data;
[22622]	307
	308	/* The pointer to data in the ring buffer. */
[71619]	309	uint8_t RT_UNTRUSTED_VOLATILE_GUEST *pbSrc = &pVBVAData->guest.pu8Data[pVBVAData->off32Data];
[22622]	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. */
[71619]	315	ppHdr = (VBVACMDHDR RT_UNTRUSTED_VOLATILE_GUEST )pbSrc;
[22622]	316
[58539]	317	/* The data offset will be updated in vbvaReleaseCmd. */
[22622]	318	}
	319	else
	320	{
	321	/* The command crosses buffer boundary. Rare case, so not optimized. */
[71619]	322	uint8_t pbDst = (uint8_t )RTMemAlloc(cbRecord);
	323	if (!pbDst)
[22622]	324	{
	325	LogFlowFunc (("could not allocate %d bytes from heap!!!\n", cbRecord));
	326	return false;
	327	}
	328
[71619]	329	vbvaFetchBytes(pVBVAData, pbDst, cbRecord);
[22622]	330
[71619]	331	ppHdr = (VBVACMDHDR )pbDst;
[22622]	332
[71619]	333	LOGVBVABUFFER(("Allocated from heap %p\n", pbDst));
[22622]	334	}
	335	}
	336
	337	*pcbCmd = cbRecord;
	338
[56036]	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;
[22622]	342
	343	LOGVBVABUFFER(("done ok, data = %d, free = %d\n",
[56036]	344	pVBVAData->off32Data, pVBVAData->guest.pVBVA->off32Free));
[22622]	345
	346	return true;
	347	}
	348
[71619]	349	static void vbvaReleaseCmd(VBVADATA pVBVAData, VBVACMDHDR RT_UNTRUSTED_VOLATILE_GUEST pHdr, uint32_t cbCmd)
[22622]	350	{
[71619]	351	VBVAPARTIALRECORD *pPartialRecord = &pVBVAData->partialRecord;
	352	const uint8_t RT_UNTRUSTED_VOLATILE_GUEST *pbRingBuffer = pVBVAData->guest.pu8Data;
[22622]	353
[71619]	354	if ( (uintptr_t)pHdr >= (uintptr_t)pbRingBuffer
	355	&& (uintptr_t)pHdr < (uintptr_t)&pbRingBuffer[pVBVAData->cbData])
[22622]	356	{
	357	/* The pointer is inside ring buffer. Must be continuous chunk. */
[71619]	358	Assert(pVBVAData->cbData - (uint32_t)((uint8_t *)pHdr - pbRingBuffer) >= cbCmd);
[22622]	359
[58539]	360	/* Advance data offset and sync with guest. */
	361	pVBVAData->off32Data = (pVBVAData->off32Data + cbCmd) % pVBVAData->cbData;
	362	pVBVAData->guest.pVBVA->off32Data = pVBVAData->off32Data;
[22622]	363
[58539]	364	Assert(!pPartialRecord->pu8 && pPartialRecord->cb == 0);
[22622]	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	{
[56036]	378	Assert(!pPartialRecord->pu8 && pPartialRecord->cb == 0);
[22622]	379	}
	380
[71619]	381	RTMemFree((void *)pHdr);
[22622]	382	}
	383	}
	384
[56036]	385	static int vbvaFlushProcess(unsigned uScreenId, PVGASTATE pVGAState, VBVADATA *pVBVAData)
[22622]	386	{
	387	LOGVBVABUFFER(("uScreenId %d, indexRecordFirst = %d, indexRecordFree = %d, off32Data = %d, off32Free = %d\n",
[72060]	388	uScreenId, pVBVAData->indexRecordFirst, pVBVAData->guest.pVBVA->indexRecordFree,
	389	pVBVAData->off32Data, pVBVAData->guest.pVBVA->off32Free));
[22622]	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;
[32585]	397	RT_ZERO(dirtyRect);
[23118]	398
[22622]	399	bool fUpdate = false; /* Whether there were any updates. */
[32585]	400	bool fDirtyEmpty = true;
[22622]	401
	402	for (;;)
	403	{
	404	/* Fetch the command data. */
[71619]	405	VBVACMDHDR RT_UNTRUSTED_VOLATILE_GUEST *pHdr = NULL;
	406	uint32_t cbCmd = UINT32_MAX;
	407	if (!vbvaFetchCmd(pVBVAData, &pHdr, &cbCmd))
[22622]	408	{
	409	LogFunc(("unable to fetch command. off32Data = %d, off32Free = %d!!!\n",
[71619]	410	pVBVAData->off32Data, pVBVAData->guest.pVBVA->off32Free));
[22622]	411	return VERR_NOT_SUPPORTED;
	412	}
	413
[72060]	414	if (cbCmd == UINT32_MAX)
[22622]	415	{
	416	/* No more commands yet in the queue. */
	417	break;
	418	}
	419
[56036]	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
[22622]	428	if (cbCmd != 0)
	429	{
	430	if (!fUpdate)
	431	{
[56036]	432	pVGAState->pDrv->pfnVBVAUpdateBegin(pVGAState->pDrv, uScreenId);
[22622]	433	fUpdate = true;
	434	}
	435
	436	/* Updates the rectangle and sends the command to the VRDP server. */
[71619]	437	pVGAState->pDrv->pfnVBVAUpdateProcess(pVGAState->pDrv, uScreenId, pHdr, cbCmd);
[22622]	438
[71619]	439	int32_t xRight = pHdr->x + pHdr->w;
	440	int32_t yBottom = pHdr->y + pHdr->h;
[22622]	441
	442	/* These are global coords, relative to the primary screen. */
	443
[72060]	444	LOGVBVABUFFER(("cbCmd = %d, x=%d, y=%d, w=%d, h=%d\n", cbCmd, pHdr->x, pHdr->y, pHdr->w, pHdr->h));
[42409]	445	LogRel3(("%s: update command cbCmd = %d, x=%d, y=%d, w=%d, h=%d\n",
[71619]	446	__FUNCTION__, cbCmd, pHdr->x, pHdr->y, pHdr->w, pHdr->h));
[22622]	447
	448	/* Collect all rects into one. */
[32585]	449	if (fDirtyEmpty)
[22622]	450	{
	451	/* This is the first rectangle to be added. */
[71619]	452	dirtyRect.xLeft = pHdr->x;
	453	dirtyRect.yTop = pHdr->y;
[22622]	454	dirtyRect.xRight = xRight;
	455	dirtyRect.yBottom = yBottom;
[32585]	456	fDirtyEmpty = false;
[22622]	457	}
	458	else
	459	{
	460	/* Adjust region coordinates. */
[71619]	461	if (dirtyRect.xLeft > pHdr->x)
[22622]	462	{
[71619]	463	dirtyRect.xLeft = pHdr->x;
[22622]	464	}
	465
[71619]	466	if (dirtyRect.yTop > pHdr->y)
[22622]	467	{
[71619]	468	dirtyRect.yTop = pHdr->y;
[22622]	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
[71619]	483	vbvaReleaseCmd(pVBVAData, pHdr, cbCmd);
[22622]	484	}
	485
	486	if (fUpdate)
	487	{
[32585]	488	if (dirtyRect.xRight - dirtyRect.xLeft)
[22622]	489	{
[42409]	490	LogRel3(("%s: sending update screen=%d, x=%d, y=%d, w=%d, h=%d\n",
[56036]	491	__FUNCTION__, uScreenId, dirtyRect.xLeft,
[42409]	492	dirtyRect.yTop, dirtyRect.xRight - dirtyRect.xLeft,
	493	dirtyRect.yBottom - dirtyRect.yTop));
[56036]	494	pVGAState->pDrv->pfnVBVAUpdateEnd(pVGAState->pDrv, uScreenId, dirtyRect.xLeft, dirtyRect.yTop,
	495	dirtyRect.xRight - dirtyRect.xLeft, dirtyRect.yBottom - dirtyRect.yTop);
[22622]	496	}
	497	else
	498	{
[56036]	499	pVGAState->pDrv->pfnVBVAUpdateEnd(pVGAState->pDrv, uScreenId, 0, 0, 0, 0);
[22622]	500	}
	501	}
	502
	503	return VINF_SUCCESS;
	504	}
	505
[56036]	506	static int vbvaFlush(PVGASTATE pVGAState, VBVACONTEXT *pCtx)
[22622]	507	{
[56036]	508	int rc = VINF_SUCCESS;
	509
[22622]	510	unsigned uScreenId;
	511	for (uScreenId = 0; uScreenId < pCtx->cViews; uScreenId++)
	512	{
[56036]	513	VBVADATA *pVBVAData = &pCtx->aViews[uScreenId].vbva;
	514	if (pVBVAData->guest.pVBVA)
[22622]	515	{
[56036]	516	rc = vbvaFlushProcess(uScreenId, pVGAState, pVBVAData);
	517	if (RT_FAILURE(rc))
	518	break;
[22622]	519	}
	520	}
	521
[56036]	522	if (RT_FAILURE(rc))
	523	{
	524	/* Turn off VBVA processing. */
[56992]	525	LogRel(("VBVA: Disabling (%Rrc)\n", rc));
[56814]	526	pVGAState->fGuestCaps = 0;
	527	pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
[56036]	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;
[22622]	540	}
	541
[60905]	542	static int vbvaResize(PVGASTATE pVGAState, VBVAVIEW pView, const VBVAINFOSCREEN pNewScreen, bool fResetInputMapping)
[22622]	543	{
[56036]	544	/* Callers ensure that pNewScreen contains valid data. */
[22622]	545
	546	/* Apply these changes. */
	547	pView->screen = *pNewScreen;
	548
	549	uint8_t *pu8VRAM = pVGAState->vram_ptrR3 + pView->view.u32ViewOffset;
[60905]	550	return pVGAState->pDrv->pfnVBVAResize (pVGAState->pDrv, &pView->view, &pView->screen, pu8VRAM, fResetInputMapping);
[22622]	551	}
	552
[71619]	553	static int vbvaEnable(unsigned uScreenId, PVGASTATE pVGAState, VBVACONTEXT *pCtx,
	554	VBVABUFFER RT_UNTRUSTED_VOLATILE_GUEST *pVBVA, uint32_t u32Offset, bool fRestored)
[22622]	555	{
[71619]	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();
[22622]	562
[71619]	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
[71628]	566	&& u32Offset <= pVGAState->vram_size - cbVBVABuffer,
[71619]	567	VERR_INVALID_PARAMETER);
[56785]	568	if (!fRestored)
	569	{
[71619]	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);
[56785]	574	}
[71619]	575	ASSERT_GUEST_RETURN( VbgaSafe.cbPartialWriteThreshold < VbgaSafe.cbData
	576	&& VbgaSafe.cbPartialWriteThreshold != 0,
	577	VERR_INVALID_PARAMETER);
	578	RT_UNTRUSTED_VALIDATED_FENCE();
[56785]	579
[71619]	580	/*
	581	* Okay, try do the job.
	582	*/
	583	int rc;
[56036]	584	if (pVGAState->pDrv->pfnVBVAEnable)
	585	{
[71619]	586	pVBVA->hostFlags.u32HostEvents = 0;
	587	pVBVA->hostFlags.u32SupportedOrders = 0;
[80872]	588	rc = pVGAState->pDrv->pfnVBVAEnable(pVGAState->pDrv, uScreenId, &pVBVA->hostFlags);
[71619]	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));
[22622]	594
[71619]	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;
[22622]	603
[71619]	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	}
[56036]	615
[71619]	616	/* VBVA is working so disable the pause. */
	617	pCtx->fPaused = false;
[39887]	618	}
[22622]	619	}
[71619]	620	else
	621	rc = VERR_NOT_SUPPORTED;
[22622]	622	return rc;
	623	}
	624
	625	static 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
[56036]	630	VBVADATA *pVBVAData = &pCtx->aViews[uScreenId].vbva;
	631	vbvaDataCleanup(pVBVAData);
[22622]	632
[56814]	633	if (uScreenId == 0)
	634	{
	635	pVGAState->fGuestCaps = 0;
	636	pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
	637	}
[56036]	638	pVGAState->pDrv->pfnVBVADisable(pVGAState->pDrv, uScreenId);
[22622]	639	return VINF_SUCCESS;
	640	}
	641
[28379]	642	bool 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];
[56036]	653	if (pView->vbva.guest.pVBVA)
[28379]	654	return true;
	655	}
	656	}
	657	}
	658	return false;
	659	}
	660
[24714]	661	#ifdef DEBUG_sunlover
	662	void 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
[56036]	679	static int vbvaUpdateMousePointerShape(PVGASTATE pVGAState, VBVAMOUSESHAPEINFO *pMouseShapeInfo, bool fShape)
[24714]	680	{
[56036]	681	LogFlowFunc(("pVGAState %p, pMouseShapeInfo %p, fShape %d\n",
	682	pVGAState, pMouseShapeInfo, fShape));
[24714]	683	#ifdef DEBUG_sunlover
	684	dumpMouseShapeInfo(pMouseShapeInfo);
	685	#endif
	686
[56036]	687	if (pVGAState->pDrv->pfnVBVAMousePointerShape == NULL)
[24714]	688	{
[56036]	689	return VERR_NOT_SUPPORTED;
	690	}
	691
	692	int rc;
	693	if (fShape && pMouseShapeInfo->pu8Shape != NULL)
	694	{
[24714]	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,
[56036]	702	pMouseShapeInfo->pu8Shape);
[24714]	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
[71590]	717	static int vbvaMousePointerShape(PVGASTATE pVGAState, VBVACONTEXT *pCtx,
	718	const VBVAMOUSEPOINTERSHAPE RT_UNTRUSTED_VOLATILE_GUEST *pShape, HGSMISIZE cbShape)
[22622]	719	{
[71622]	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();
[22622]	726
[56036]	727	LogFlowFunc(("VBVA_MOUSE_POINTER_SHAPE: i32Result 0x%x, fu32Flags 0x%x, hot spot %d,%d, size %dx%d\n",
[71622]	728	SafeShape.i32Result, SafeShape.fu32Flags, SafeShape.u32HotX, SafeShape.u32HotY, SafeShape.u32Width, SafeShape.u32Height));
[56036]	729
[71622]	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);
[56036]	733
[22622]	734	HGSMISIZE cbPointerData = 0;
	735	if (fShape)
	736	{
[71622]	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);
[49427]	743
[71622]	744	cbPointerData = ((((SafeShape.u32Width + 7) / 8) * SafeShape.u32Height + 3) & ~3)
	745	+ SafeShape.u32Width * 4 * SafeShape.u32Height;
[23118]	746
[71622]	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);
[22622]	751	}
[71622]	752	RT_UNTRUSTED_VALIDATED_FENCE();
[22622]	753
[71622]	754	/*
	755	* Do the job.
	756	*/
[24714]	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)
[22622]	761	{
[24940]	762	/* Data related to shape. */
[71622]	763	pCtx->mouseShapeInfo.u32HotX = SafeShape.u32HotX;
	764	pCtx->mouseShapeInfo.u32HotY = SafeShape.u32HotY;
	765	pCtx->mouseShapeInfo.u32Width = SafeShape.u32Width;
	766	pCtx->mouseShapeInfo.u32Height = SafeShape.u32Height;
[59307]	767	pCtx->mouseShapeInfo.fAlpha = fAlpha;
[24940]	768
[24714]	769	/* Reallocate memory buffer if necessary. */
	770	if (cbPointerData > pCtx->mouseShapeInfo.cbAllocated)
	771	{
[71626]	772	RTMemFree(pCtx->mouseShapeInfo.pu8Shape);
[24714]	773	pCtx->mouseShapeInfo.pu8Shape = NULL;
	774	pCtx->mouseShapeInfo.cbShape = 0;
[22622]	775
[71626]	776	uint8_t pu8Shape = (uint8_t )RTMemAlloc(cbPointerData);
[24714]	777	if (pu8Shape)
	778	{
	779	pCtx->mouseShapeInfo.pu8Shape = pu8Shape;
	780	pCtx->mouseShapeInfo.cbAllocated = cbPointerData;
	781	}
	782	}
[22622]	783
[24714]	784	/* Copy shape bitmaps. */
	785	if (pCtx->mouseShapeInfo.pu8Shape)
	786	{
[71622]	787	RT_BCOPY_VOLATILE(pCtx->mouseShapeInfo.pu8Shape, &pShape->au8Data[0], cbPointerData);
[24714]	788	pCtx->mouseShapeInfo.cbShape = cbPointerData;
	789	}
[22622]	790	}
[24714]	791
[71622]	792	return vbvaUpdateMousePointerShape(pVGAState, &pCtx->mouseShapeInfo, fShape);
[22622]	793	}
	794
[71590]	795	static uint32_t vbvaViewFromBufferPtr(PHGSMIINSTANCE pIns, const VBVACONTEXT *pCtx,
	796	const void RT_UNTRUSTED_VOLATILE_GUEST *pvBuffer)
[22622]	797	{
	798	/* Check which view contains the buffer. */
[56036]	799	HGSMIOFFSET offBuffer = HGSMIPointerToOffsetHost(pIns, pvBuffer);
[22622]	800	if (offBuffer != HGSMIOFFSET_VOID)
	801	{
	802	unsigned uScreenId;
	803	for (uScreenId = 0; uScreenId < pCtx->cViews; uScreenId++)
	804	{
[56036]	805	const VBVAINFOVIEW *pView = &pCtx->aViews[uScreenId].view;
[71619]	806	if ((uint32_t)(offBuffer - pView->u32ViewOffset) < pView->u32ViewSize)
[22622]	807	return pView->u32ViewIndex;
	808	}
	809	}
[62928]	810	return UINT32_MAX;
[22622]	811	}
	812
	813	#ifdef DEBUG_sunlover
	814	static 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,
[23118]	837	pView->screen.u16BitsPerPixel,
[22622]	838	pView->screen.u16Flags));
	839
	840	Log((" VBVA o 0x%x p %p\n",
[56431]	841	pView->vbva.u32VBVAOffset,
[56036]	842	pView->vbva.guest.pVBVA));
[22622]	843
	844	Log((" PR cb 0x%x p %p\n",
[56431]	845	pView->vbva.partialRecord.cb,
	846	pView->vbva.partialRecord.pu8));
[22622]	847	}
[24714]	848
	849	dumpMouseShapeInfo(&pCtx->mouseShapeInfo);
[22622]	850	}
	851	#endif /* DEBUG_sunlover */
	852
[34140]	853	#define VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC 0x12345678
	854	#define VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC 0x9abcdef0
[22622]	855
	856	#ifdef VBOX_WITH_VIDEOHWACCEL
[27839]	857	static void vbvaVHWAHHCommandReinit(VBOXVHWACMD* pHdr, VBOXVHWACMD_TYPE enmCmd, int32_t iDisplay)
[22622]	858	{
[27839]	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
[62928]	867	static VBOXVHWACMD *vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE enmCmd, int32_t iDisplay, VBOXVHWACMD_LENGTH cbCmd)
[27839]	868	{
[62928]	869	VBOXVHWACMD pHdr = (VBOXVHWACMD )RTMemAllocZ(cbCmd + VBOXVHWACMD_HEADSIZE());
[22622]	870	Assert(pHdr);
	871	if (pHdr)
[27839]	872	vbvaVHWAHHCommandReinit(pHdr, enmCmd, iDisplay);
[22622]	873
	874	return pHdr;
	875	}
	876
[62928]	877	DECLINLINE(void) vbvaVHWAHHCommandRelease(VBOXVHWACMD *pCmd)
[22622]	878	{
	879	uint32_t cRefs = ASMAtomicDecU32(&pCmd->cRefs);
[62928]	880	if (!cRefs)
[22622]	881	RTMemFree(pCmd);
	882	}
	883
[62928]	884	DECLINLINE(void) vbvaVHWAHHCommandRetain(VBOXVHWACMD *pCmd)
[22622]	885	{
	886	ASMAtomicIncU32(&pCmd->cRefs);
	887	}
	888
[71590]	889	static void vbvaVHWACommandComplete(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand, bool fAsyncCommand)
[22622]	890	{
[49420]	891	if (fAsyncCommand)
	892	{
	893	Assert(pCommand->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH);
[82088]	894	vbvaR3VHWACommandCompleteAsync(&pVGAState->IVBVACallbacks, pCommand);
[49420]	895	}
	896	else
	897	{
	898	Log(("VGA Command <<< Sync rc %d %#p, %d\n", pCommand->rc, pCommand, pCommand->enmCmd));
[62928]	899	pCommand->Flags &= ~VBOXVHWACMD_FLAG_HG_ASYNCH;
[49420]	900	}
	901
	902	}
	903
	904	static void vbvaVHWACommandCompleteAllPending(PVGASTATE pVGAState, int rc)
	905	{
[49434]	906	if (!ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending))
[49420]	907	return;
	908
[82050]	909	PDMDevHlpCritSectEnter(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect, VERR_SEM_BUSY);
[49434]	910
[62928]	911	VBOX_VHWA_PENDINGCMD pIter, pNext;
[49420]	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);
[49434]	919	ASMAtomicDecU32(&pVGAState->pendingVhwaCommands.cPending);
[49420]	920	RTMemFree(pIter);
	921	}
[49434]	922
[82050]	923	PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
[49420]	924	}
	925
[49434]	926	static void vbvaVHWACommandClearAllPending(PVGASTATE pVGAState)
[49420]	927	{
[49434]	928	if (!ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending))
[49420]	929	return;
	930
[82050]	931	PDMDevHlpCritSectEnter(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect, VERR_SEM_BUSY);
[49434]	932
[62928]	933	VBOX_VHWA_PENDINGCMD pIter, pNext;
[49420]	934	RTListForEachSafe(&pVGAState->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
	935	{
	936	RTListNodeRemove(&pIter->Node);
[49434]	937	ASMAtomicDecU32(&pVGAState->pendingVhwaCommands.cPending);
[49420]	938	RTMemFree(pIter);
	939	}
[49434]	940
[82050]	941	PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
[49420]	942	}
	943
[71590]	944	static void vbvaVHWACommandPend(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand)
[49420]	945	{
	946	int rc = VERR_BUFFER_OVERFLOW;
	947
[49434]	948	if (ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending) < VBOX_VHWA_MAX_PENDING_COMMANDS)
[49420]	949	{
[62928]	950	VBOX_VHWA_PENDINGCMD pPend = (VBOX_VHWA_PENDINGCMD )RTMemAlloc(sizeof(*pPend));
[49420]	951	if (pPend)
	952	{
	953	pCommand->Flags \|= VBOXVHWACMD_FLAG_HG_ASYNCH;
	954	pPend->pCommand = pCommand;
[82050]	955	PDMDevHlpCritSectEnter(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect, VERR_SEM_BUSY);
[49434]	956	if (ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending) < VBOX_VHWA_MAX_PENDING_COMMANDS)
	957	{
	958	RTListAppend(&pVGAState->pendingVhwaCommands.PendingList, &pPend->Node);
	959	ASMAtomicIncU32(&pVGAState->pendingVhwaCommands.cPending);
[82050]	960	PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
[49434]	961	return;
	962	}
[82050]	963	PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
[56097]	964	LogRel(("VBVA: Pending command count has reached its threshold.. completing them all.."));
[49434]	965	RTMemFree(pPend);
[49420]	966	}
	967	else
	968	rc = VERR_NO_MEMORY;
	969	}
	970	else
[56097]	971	LogRel(("VBVA: Pending command count has reached its threshold, completing them all.."));
[49420]	972
	973	vbvaVHWACommandCompleteAllPending(pVGAState, rc);
	974
	975	pCommand->rc = rc;
	976
	977	vbvaVHWACommandComplete(pVGAState, pCommand, false);
	978	}
	979
[71590]	980	static bool vbvaVHWACommandCanPend(VBOXVHWACMD_TYPE enmCmd)
[49420]	981	{
[71590]	982	switch (enmCmd)
[49420]	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
[82048]	995	static int vbvaVHWACommandSavePending(PCPDMDEVHLPR3 pHlp, PVGASTATE pVGAState, PSSMHANDLE pSSM)
[49420]	996	{
[82048]	997	int rc = pHlp->pfnSSMPutU32(pSSM, pVGAState->pendingVhwaCommands.cPending);
[49420]	998	AssertRCReturn(rc, rc);
[62928]	999
[49420]	1000	VBOX_VHWA_PENDINGCMD *pIter;
	1001	RTListForEach(&pVGAState->pendingVhwaCommands.PendingList, pIter, VBOX_VHWA_PENDINGCMD, Node)
	1002	{
[71626]	1003	AssertContinue((uintptr_t)pIter->pCommand - (uintptr_t)pVGAState->vram_ptrR3 < pVGAState->vram_size);
[82048]	1004	rc = pHlp->pfnSSMPutU32(pSSM, (uint32_t)(((uint8_t )pIter->pCommand) - ((uint8_t )pVGAState->vram_ptrR3)));
[49420]	1005	AssertRCReturn(rc, rc);
	1006	}
	1007	return rc;
	1008	}
	1009
[82048]	1010	static int vbvaVHWACommandLoadPending(PCPDMDEVHLPR3 pHlp, PVGASTATE pVGAState, PSSMHANDLE pSSM, uint32_t u32Version)
[49420]	1011	{
	1012	if (u32Version < VGA_SAVEDSTATE_VERSION_WITH_PENDVHWA)
	1013	return VINF_SUCCESS;
	1014
	1015	uint32_t u32;
[82048]	1016	int rc = pHlp->pfnSSMGetU32(pSSM, &u32);
[49420]	1017	AssertRCReturn(rc, rc);
	1018	for (uint32_t i = 0; i < u32; ++i)
	1019	{
	1020	uint32_t off32;
[82048]	1021	rc = pHlp->pfnSSMGetU32(pSSM, &off32);
[49420]	1022	AssertRCReturn(rc, rc);
[71590]	1023	VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCommand
	1024	= (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST )((uint8_t volatile )pVGAState->vram_ptrR3 + off32);
[49420]	1025	vbvaVHWACommandPend(pVGAState, pCommand);
	1026	}
	1027	return rc;
	1028	}
	1029
	1030
[71626]	1031	/** Worker for vbvaVHWACommandSubmit. */
	1032	static bool vbvaVHWACommandSubmitInner(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST pCommand, bool pfPending)
[49420]	1033	{
[71626]	1034	*pfPending = false;
	1035
	1036	/*
	1037	* Read the command type and validate it and our driver state.
	1038	*/
[71590]	1039	VBOXVHWACMD_TYPE enmCmd = pCommand->enmCmd;
[71626]	1040	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
[71590]	1041
[71626]	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)
[49420]	1064	{
[71626]	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))
[49420]	1074	{
[71626]	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?? */
[49420]	1078	}
	1079
[71626]	1080	Log(("VGA Command --- Can NOT Pend %#p, %d\n", pCommand, enmCmd));
[49420]	1081	}
[24779]	1082	else
[71626]	1083	Log(("VGA Command --- Going Complete Sync rc %d %#p, %d\n", rc, pCommand, enmCmd));
[49420]	1084
[71626]	1085	/* the command was completed, take a special care about it (see caller) */
	1086	pCommand->rc = rc;
	1087	return true;
	1088	}
[49420]	1089
	1090
[71626]	1091	static 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;
[22622]	1098	}
	1099
[71626]	1100
	1101	/**
	1102	* @returns false if commands are pending, otherwise true.
	1103	*/
[49420]	1104	static bool vbvaVHWACheckPendingCommands(PVGASTATE pVGAState)
	1105	{
[49434]	1106	if (!ASMAtomicUoReadU32(&pVGAState->pendingVhwaCommands.cPending))
[49420]	1107	return true;
	1108
[82050]	1109	PDMDevHlpCritSectEnter(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect, VERR_SEM_BUSY);
[49434]	1110
[64766]	1111	VBOX_VHWA_PENDINGCMD pIter, pNext;
[49420]	1112	RTListForEachSafe(&pVGAState->pendingVhwaCommands.PendingList, pIter, pNext, VBOX_VHWA_PENDINGCMD, Node)
	1113	{
	1114	if (!vbvaVHWACommandSubmit(pVGAState, pIter->pCommand, true))
[49434]	1115	{
[82050]	1116	PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
[71626]	1117	return false; /* the command should be still pending */
[49434]	1118	}
[49420]	1119
	1120	/* the command is submitted/processed, remove from the pend list */
	1121	RTListNodeRemove(&pIter->Node);
[49434]	1122	ASMAtomicDecU32(&pVGAState->pendingVhwaCommands.cPending);
[49420]	1123	RTMemFree(pIter);
	1124	}
	1125
[82050]	1126	PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSect);
[49434]	1127
[49420]	1128	return true;
	1129	}
	1130
	1131	void vbvaTimerCb(PVGASTATE pVGAState)
	1132	{
	1133	vbvaVHWACheckPendingCommands(pVGAState);
	1134	}
[71626]	1135
[71590]	1136	static void vbvaVHWAHandleCommand(PVGASTATE pVGAState, VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
[49420]	1137	{
	1138	if (vbvaVHWACheckPendingCommands(pVGAState))
	1139	{
	1140	if (vbvaVHWACommandSubmit(pVGAState, pCmd, false))
	1141	return;
	1142	}
	1143
	1144	vbvaVHWACommandPend(pVGAState, pCmd);
	1145	}
	1146
[24925]	1147	static DECLCALLBACK(void) vbvaVHWAHHCommandSetEventCallback(void * pContext)
	1148	{
	1149	RTSemEventSignal((RTSEMEVENT)pContext);
	1150	}
	1151
[71626]	1152	static int vbvaVHWAHHCommandPost(PVGASTATE pVGAState, VBOXVHWACMD *pCmd)
[22622]	1153	{
	1154	RTSEMEVENT hComplEvent;
	1155	int rc = RTSemEventCreate(&hComplEvent);
[24095]	1156	AssertRC(rc);
[71626]	1157	if (RT_SUCCESS(rc))
[22622]	1158	{
	1159	/* ensure the cmd is not deleted until we process it */
[71626]	1160	vbvaVHWAHHCommandRetain(pCmd);
	1161
	1162	VBOXVHWA_HH_CALLBACK_SET(pCmd, vbvaVHWAHHCommandSetEventCallback, (void *)hComplEvent);
[49420]	1163	vbvaVHWAHandleCommand(pVGAState, pCmd);
[22622]	1164
[71626]	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
[24095]	1169	AssertRC(rc);
[71626]	1170	if (RT_SUCCESS(rc))
[22622]	1171	RTSemEventDestroy(hComplEvent);
[71626]	1172
[22622]	1173	vbvaVHWAHHCommandRelease(pCmd);
	1174	}
	1175	return rc;
	1176	}
	1177
[71592]	1178	int vbvaVHWAConstruct(PVGASTATE pVGAState)
[22622]	1179	{
[49420]	1180	pVGAState->pendingVhwaCommands.cPending = 0;
	1181	RTListInit(&pVGAState->pendingVhwaCommands.PendingList);
[49434]	1182
[62928]	1183	VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_CONSTRUCT, 0, sizeof(VBOXVHWACMD_HH_CONSTRUCT));
[22622]	1184	Assert(pCmd);
	1185	if(pCmd)
	1186	{
[27839]	1187	uint32_t iDisplay = 0;
	1188	int rc = VINF_SUCCESS;
[71592]	1189	VBOXVHWACMD_HH_CONSTRUCT *pBody = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_CONSTRUCT);
[22622]	1190
[27839]	1191	do
	1192	{
	1193	memset(pBody, 0, sizeof(VBOXVHWACMD_HH_CONSTRUCT));
[22622]	1194
[27839]	1195	PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
	1196	PVM pVM = PDMDevHlpGetVM(pDevIns);
[22622]	1197
[27839]	1198	pBody->pVM = pVM;
	1199	pBody->pvVRAM = pVGAState->vram_ptrR3;
	1200	pBody->cbVRAM = pVGAState->vram_size;
	1201
	1202	rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
[71592]	1203	ASMCompilerBarrier();
	1204
[27839]	1205	AssertRC(rc);
[71592]	1206	if (RT_SUCCESS(rc))
[22622]	1207	{
[27839]	1208	rc = pCmd->rc;
	1209	AssertMsg(RT_SUCCESS(rc) \|\| rc == VERR_NOT_IMPLEMENTED, ("%Rrc\n", rc));
	1210	if(rc == VERR_NOT_IMPLEMENTED)
	1211	{
[63562]	1212	/** @todo set some flag in pVGAState indicating VHWA is not supported */
[27839]	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;
[22622]	1219	}
[27839]	1220	else
	1221	break;
[24163]	1222
[27839]	1223	++iDisplay;
	1224	if (iDisplay >= pVGAState->cMonitors)
	1225	break;
	1226	vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_CONSTRUCT, (int32_t)iDisplay);
	1227	} while (true);
	1228
[24163]	1229	vbvaVHWAHHCommandRelease(pCmd);
	1230
[22622]	1231	return rc;
	1232	}
	1233	return VERR_OUT_OF_RESOURCES;
	1234	}
	1235
[71592]	1236	int vbvaVHWAReset(PVGASTATE pVGAState)
[24053]	1237	{
[49434]	1238	vbvaVHWACommandClearAllPending(pVGAState);
[49420]	1239
[24053]	1240	/* ensure we have all pending cmds processed and h->g cmds disabled */
[62928]	1241	VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_RESET, 0, 0);
[24053]	1242	Assert(pCmd);
[71626]	1243	if (pCmd)
[24053]	1244	{
[27839]	1245	int rc = VINF_SUCCESS;
	1246	uint32_t iDisplay = 0;
	1247
	1248	do
[24053]	1249	{
[71626]	1250	rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
[27839]	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	}
[24163]	1259
[27839]	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
[24163]	1270	vbvaVHWAHHCommandRelease(pCmd);
	1271
[24053]	1272	return rc;
	1273	}
	1274	return VERR_OUT_OF_RESOURCES;
	1275	}
	1276
[34140]	1277	typedef DECLCALLBACK(bool) FNVBOXVHWAHHCMDPRECB(PVGASTATE pVGAState, VBOXVHWACMD pCmd, uint32_t iDisplay, void pvContext);
	1278	typedef FNVBOXVHWAHHCMDPRECB *PFNVBOXVHWAHHCMDPRECB;
	1279
	1280	typedef DECLCALLBACK(bool) FNVBOXVHWAHHCMDPOSTCB(PVGASTATE pVGAState, VBOXVHWACMD pCmd, uint32_t iDisplay, int rc, void pvContext);
	1281	typedef FNVBOXVHWAHHCMDPOSTCB *PFNVBOXVHWAHHCMDPOSTCB;
	1282
	1283	int vbvaVHWAHHPost(PVGASTATE pVGAState, VBOXVHWACMD pCmd, PFNVBOXVHWAHHCMDPRECB pfnPre, PFNVBOXVHWAHHCMDPOSTCB pfnPost, void pvContext)
[22622]	1284	{
[34140]	1285	const VBOXVHWACMD_TYPE enmType = pCmd->enmCmd;
	1286	int rc = VINF_SUCCESS;
	1287	uint32_t iDisplay = 0;
	1288
	1289	do
[22622]	1290	{
[34140]	1291	if (!pfnPre \|\| pfnPre(pVGAState, pCmd, iDisplay, pvContext))
[22622]	1292	{
[27839]	1293	rc = vbvaVHWAHHCommandPost(pVGAState, pCmd);
	1294	AssertRC(rc);
[34140]	1295	if (pfnPost)
[22622]	1296	{
[34140]	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	{
[27839]	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	}
[22622]	1312	}
[24163]	1313
[27839]	1314	if (!RT_SUCCESS(rc))
	1315	break;
[34140]	1316	}
[27839]	1317
[34140]	1318	++iDisplay;
	1319	if (iDisplay >= pVGAState->cMonitors)
	1320	break;
	1321	vbvaVHWAHHCommandReinit(pCmd, enmType, (int32_t)iDisplay);
	1322	} while (true);
[27839]	1323
[34140]	1324	return rc;
	1325	}
[27839]	1326
[63562]	1327	/** @todo call this also on reset? */
[34140]	1328	int vbvaVHWAEnable (PVGASTATE pVGAState, bool bEnable)
	1329	{
	1330	const VBOXVHWACMD_TYPE enmType = bEnable ? VBOXVHWACMD_TYPE_HH_ENABLE : VBOXVHWACMD_TYPE_HH_DISABLE;
[62928]	1331	VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(enmType, 0, 0);
[34140]	1332	Assert(pCmd);
	1333	if(pCmd)
	1334	{
	1335	int rc = vbvaVHWAHHPost (pVGAState, pCmd, NULL, NULL, NULL);
[24163]	1336	vbvaVHWAHHCommandRelease(pCmd);
[22622]	1337	return rc;
	1338	}
	1339	return VERR_OUT_OF_RESOURCES;
	1340	}
	1341
[62928]	1342	int vboxVBVASaveStatePrep(PPDMDEVINS pDevIns)
[22622]	1343	{
	1344	/* ensure we have no pending commands */
[34129]	1345	return vbvaVHWAEnable(PDMINS_2_DATA(pDevIns, PVGASTATE), false);
[22622]	1346	}
	1347
[62928]	1348	int vboxVBVASaveStateDone(PPDMDEVINS pDevIns)
[34129]	1349	{
	1350	/* ensure we have no pending commands */
	1351	return vbvaVHWAEnable(PDMINS_2_DATA(pDevIns, PVGASTATE), true);
	1352	}
	1353
[71626]	1354	/**
	1355	* @interface_method_impl{PDMIDISPLAYVBVACALLBACKS,pfnVHWACommandCompleteAsync}
	1356	*/
[82088]	1357	DECLCALLBACK(int) vbvaR3VHWACommandCompleteAsync(PPDMIDISPLAYVBVACALLBACKS pInterface,
	1358	VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *pCmd)
[22622]	1359	{
[71626]	1360	PVGASTATE pVGAState = PPDMIDISPLAYVBVACALLBACKS_2_PVGASTATE(pInterface);
[22622]	1361	int rc;
[49420]	1362	Log(("VGA Command <<< Async rc %d %#p, %d\n", pCmd->rc, pCmd, pCmd->enmCmd));
	1363
[71626]	1364	if ((uintptr_t)pCmd - (uintptr_t)pVGAState->vram_ptrR3 < pVGAState->vram_size)
[22622]	1365	{
	1366	PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
[71626]	1367	Assert(!(pCmd->Flags & VBOXVHWACMD_FLAG_HH_CMD));
[22622]	1368	Assert(pCmd->Flags & VBOXVHWACMD_FLAG_HG_ASYNCH);
[32622]	1369	#ifdef VBOX_WITH_WDDM
[29742]	1370	if (pVGAState->fGuestCaps & VBVACAPS_COMPLETEGCMD_BY_IOREAD)
[22622]	1371	{
[29742]	1372	rc = HGSMICompleteGuestCommand(pIns, pCmd, !!(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ));
[24095]	1373	AssertRC(rc);
[22622]	1374	}
	1375	else
[29742]	1376	#endif
[22622]	1377	{
[71590]	1378	VBVAHOSTCMD RT_UNTRUSTED_VOLATILE_GUEST pHostCmd = NULL; / Shut up MSC. */
[62928]	1379	if (pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_EVENT)
[22622]	1380	{
[62928]	1381	rc = HGSMIHostCommandAlloc(pIns,
[71590]	1382	(void RT_UNTRUSTED_VOLATILE_GUEST **)&pHostCmd,
[62928]	1383	VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)),
	1384	HGSMI_CH_VBVA,
	1385	VBVAHG_EVENT);
[24095]	1386	AssertRC(rc);
[62928]	1387	if (RT_SUCCESS(rc))
[22622]	1388	{
[71590]	1389	memset((void *)pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDEVENT)));
[22622]	1390	pHostCmd->iDstID = pCmd->iDisplay;
[29742]	1391	pHostCmd->customOpCode = 0;
[71592]	1392	VBVAHOSTCMDEVENT RT_UNTRUSTED_VOLATILE_GUEST *pBody = VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDEVENT);
[29742]	1393	pBody->pEvent = pCmd->GuestVBVAReserved1;
[22622]	1394	}
	1395	}
	1396	else
	1397	{
[62928]	1398	HGSMIOFFSET offCmd = HGSMIPointerToOffsetHost(pIns, pCmd);
[29742]	1399	Assert(offCmd != HGSMIOFFSET_VOID);
[62928]	1400	if (offCmd != HGSMIOFFSET_VOID)
[29742]	1401	{
[62928]	1402	rc = HGSMIHostCommandAlloc(pIns,
[71590]	1403	(void RT_UNTRUSTED_VOLATILE_GUEST **)&pHostCmd,
[62928]	1404	VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)),
	1405	HGSMI_CH_VBVA,
	1406	VBVAHG_DISPLAY_CUSTOM);
[29742]	1407	AssertRC(rc);
[62928]	1408	if (RT_SUCCESS(rc))
[29742]	1409	{
[71590]	1410	memset((void *)pHostCmd, 0 , VBVAHOSTCMD_SIZE(sizeof(VBVAHOSTCMDVHWACMDCOMPLETE)));
[29742]	1411	pHostCmd->iDstID = pCmd->iDisplay;
	1412	pHostCmd->customOpCode = VBVAHG_DCUSTOM_VHWA_CMDCOMPLETE;
[71592]	1413	VBVAHOSTCMDVHWACMDCOMPLETE RT_UNTRUSTED_VOLATILE_GUEST *pBody
	1414	= VBVAHOSTCMD_BODY(pHostCmd, VBVAHOSTCMDVHWACMDCOMPLETE);
[29742]	1415	pBody->offCmd = offCmd;
	1416	}
	1417	}
	1418	else
	1419	rc = VERR_INVALID_PARAMETER;
[22622]	1420	}
	1421
[62928]	1422	if (RT_SUCCESS(rc))
[22622]	1423	{
[55560]	1424	rc = HGSMIHostCommandSubmitAndFreeAsynch(pIns, pHostCmd, RT_BOOL(pCmd->Flags & VBOXVHWACMD_FLAG_GH_ASYNCH_IRQ));
[29742]	1425	AssertRC(rc);
[62928]	1426	if (RT_SUCCESS(rc))
[29742]	1427	return rc;
[62928]	1428
[29742]	1429	HGSMIHostCommandFree (pIns, pHostCmd);
[22622]	1430	}
	1431	}
	1432	}
	1433	else
	1434	{
[71626]	1435	Assert(pCmd->Flags & VBOXVHWACMD_FLAG_HH_CMD);
[24925]	1436	PFNVBOXVHWA_HH_CALLBACK pfn = VBOXVHWA_HH_CALLBACK_GET(pCmd);
[62928]	1437	if (pfn)
[24925]	1438	pfn(VBOXVHWA_HH_CALLBACK_GET_ARG(pCmd));
[22622]	1439	rc = VINF_SUCCESS;
	1440	}
	1441	return rc;
	1442	}
[34140]	1443
	1444	typedef struct VBOXVBVASAVEDSTATECBDATA
	1445	{
	1446	PSSMHANDLE pSSM;
	1447	int rc;
	1448	bool ab2DOn[VBOX_VIDEO_MAX_SCREENS];
	1449	} VBOXVBVASAVEDSTATECBDATA, *PVBOXVBVASAVEDSTATECBDATA;
	1450
[62928]	1451	static DECLCALLBACK(bool) vboxVBVASaveStateBeginPostCb(PVGASTATE pVGAState, VBOXVHWACMD *pCmd, uint32_t iDisplay,
	1452	int rc, void *pvContext)
[34140]	1453	{
[62928]	1454	RT_NOREF(pVGAState, pCmd);
[34140]	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
[62928]	1485	static DECLCALLBACK(bool)
	1486	vboxVBVASaveStatePerformPreCb(PVGASTATE pVGAState, VBOXVHWACMD pCmd, uint32_t iDisplay, void pvContext)
[34140]	1487	{
[62928]	1488	RT_NOREF(pVGAState, pCmd);
[34140]	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;
[82048]	1501	PCPDMDEVHLPR3 pHlp = pVGAState->pDevInsR3->pHlpR3;
[34140]	1502
	1503	if (pData->ab2DOn[iDisplay])
	1504	{
[82048]	1505	rc = pHlp->pfnSSMPutU32(pData->pSSM, VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC); AssertRC(rc);
[34140]	1506	if (RT_FAILURE(rc))
	1507	{
	1508	pData->rc = rc;
	1509	return false;
	1510	}
	1511	return true;
	1512	}
	1513
[82048]	1514	rc = pHlp->pfnSSMPutU32(pData->pSSM, VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC); AssertRC(rc);
[34140]	1515	if (RT_FAILURE(rc))
	1516	{
	1517	pData->rc = rc;
	1518	return false;
	1519	}
	1520
	1521	return false;
	1522	}
	1523
	1524	static DECLCALLBACK(bool) vboxVBVASaveStateEndPreCb(PVGASTATE pVGAState, VBOXVHWACMD pCmd, uint32_t iDisplay, void pvContext)
	1525	{
[62928]	1526	RT_NOREF(pVGAState, pCmd);
[34140]	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
[62928]	1537	static DECLCALLBACK(bool)
	1538	vboxVBVALoadStatePerformPostCb(PVGASTATE pVGAState, VBOXVHWACMD pCmd, uint32_t iDisplay, int rc, void pvContext)
[34140]	1539	{
[62928]	1540	RT_NOREF(pVGAState, pCmd);
[34140]	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
[82048]	1557	PCPDMDEVHLPR3 pHlp = pVGAState->pDevInsR3->pHlpR3;
[34140]	1558	Assert(RT_SUCCESS(pCmd->rc) \|\| pCmd->rc == VERR_NOT_IMPLEMENTED);
	1559	if (pCmd->rc == VERR_NOT_IMPLEMENTED)
	1560	{
[82048]	1561	pData->rc = pHlp->pfnSSMSkipToEndOfUnit(pData->pSSM);
[34140]	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
[62928]	1574	static DECLCALLBACK(bool)
	1575	vboxVBVALoadStatePerformPreCb(PVGASTATE pVGAState, VBOXVHWACMD pCmd, uint32_t iDisplay, void pvContext)
[34140]	1576	{
[62928]	1577	RT_NOREF(pVGAState, pCmd);
[34140]	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
[82048]	1589	PCPDMDEVHLPR3 pHlp = pVGAState->pDevInsR3->pHlpR3;
[34140]	1590	int rc;
	1591	uint32_t u32;
[82048]	1592	rc = pHlp->pfnSSMGetU32(pData->pSSM, &u32); AssertRC(rc);
[34140]	1593	if (RT_FAILURE(rc))
	1594	{
	1595	pData->rc = rc;
	1596	return false;
	1597	}
	1598
	1599	switch (u32)
	1600	{
	1601	case VBOXVBVASAVEDSTATE_VHWAAVAILABLE_MAGIC:
[51631]	1602	pData->ab2DOn[iDisplay] = true;
[34140]	1603	return true;
	1604	case VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC:
[51631]	1605	pData->ab2DOn[iDisplay] = false;
[34140]	1606	return false;
	1607	default:
	1608	pData->rc = VERR_INVALID_STATE;
	1609	return false;
	1610	}
	1611	}
	1612	#endif /* #ifdef VBOX_WITH_VIDEOHWACCEL */
	1613
[82048]	1614	int vboxVBVASaveDevStateExec(PCPDMDEVHLPR3 pHlp, PVGASTATE pVGAState, PSSMHANDLE pSSM)
[34140]	1615	{
	1616	PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
[82048]	1617	int rc = HGSMIHostSaveStateExec(pHlp, pIns, pSSM);
[34140]	1618	if (RT_SUCCESS(rc))
	1619	{
[56969]	1620	VGA_SAVED_STATE_PUT_MARKER(pSSM, 2);
	1621
[34140]	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. */
[82048]	1630	rc = pHlp->pfnSSMPutU32 (pSSM, 0);
[34140]	1631	AssertRCReturn(rc, rc);
	1632	}
	1633	else
	1634	{
	1635	#ifdef DEBUG_sunlover
	1636	dumpctx(pCtx);
[22622]	1637	#endif
	1638
[82048]	1639	rc = pHlp->pfnSSMPutU32 (pSSM, pCtx->cViews);
[34140]	1640	AssertRCReturn(rc, rc);
[22622]	1641
[34140]	1642	uint32_t iView;
	1643	for (iView = 0; iView < pCtx->cViews; iView++)
	1644	{
	1645	VBVAVIEW *pView = &pCtx->aViews[iView];
	1646
[82048]	1647	rc = pHlp->pfnSSMPutU32(pSSM, pView->view.u32ViewIndex);
[34140]	1648	AssertRCReturn(rc, rc);
[82048]	1649	rc = pHlp->pfnSSMPutU32(pSSM, pView->view.u32ViewOffset);
[34140]	1650	AssertRCReturn(rc, rc);
[82048]	1651	rc = pHlp->pfnSSMPutU32(pSSM, pView->view.u32ViewSize);
[34140]	1652	AssertRCReturn(rc, rc);
[82048]	1653	rc = pHlp->pfnSSMPutU32(pSSM, pView->view.u32MaxScreenSize);
[34140]	1654	AssertRCReturn(rc, rc);
	1655
[82048]	1656	rc = pHlp->pfnSSMPutU32(pSSM, pView->screen.u32ViewIndex);
[34140]	1657	AssertRCReturn(rc, rc);
[82048]	1658	rc = pHlp->pfnSSMPutS32(pSSM, pView->screen.i32OriginX);
[34140]	1659	AssertRCReturn(rc, rc);
[82048]	1660	rc = pHlp->pfnSSMPutS32(pSSM, pView->screen.i32OriginY);
[34140]	1661	AssertRCReturn(rc, rc);
[82048]	1662	rc = pHlp->pfnSSMPutU32(pSSM, pView->screen.u32StartOffset);
[34140]	1663	AssertRCReturn(rc, rc);
[82048]	1664	rc = pHlp->pfnSSMPutU32(pSSM, pView->screen.u32LineSize);
[34140]	1665	AssertRCReturn(rc, rc);
[82048]	1666	rc = pHlp->pfnSSMPutU32(pSSM, pView->screen.u32Width);
[34140]	1667	AssertRCReturn(rc, rc);
[82048]	1668	rc = pHlp->pfnSSMPutU32(pSSM, pView->screen.u32Height);
[34140]	1669	AssertRCReturn(rc, rc);
[82048]	1670	rc = pHlp->pfnSSMPutU16(pSSM, pView->screen.u16BitsPerPixel);
[34140]	1671	AssertRCReturn(rc, rc);
[82048]	1672	rc = pHlp->pfnSSMPutU16(pSSM, pView->screen.u16Flags);
[34140]	1673	AssertRCReturn(rc, rc);
	1674
[82048]	1675	rc = pHlp->pfnSSMPutU32(pSSM, pView->vbva.guest.pVBVA? pView->vbva.u32VBVAOffset: HGSMIOFFSET_VOID);
[34140]	1676	AssertRCReturn(rc, rc);
	1677
[82048]	1678	rc = pHlp->pfnSSMPutU32(pSSM, pView->vbva.partialRecord.cb);
[34140]	1679	AssertRCReturn(rc, rc);
	1680
[56036]	1681	if (pView->vbva.partialRecord.cb > 0)
[34140]	1682	{
[82048]	1683	rc = pHlp->pfnSSMPutMem(pSSM, pView->vbva.partialRecord.pu8, pView->vbva.partialRecord.cb);
[34140]	1684	AssertRCReturn(rc, rc);
	1685	}
	1686	}
	1687
	1688	/* Save mouse pointer shape information. */
[82048]	1689	rc = pHlp->pfnSSMPutBool(pSSM, pCtx->mouseShapeInfo.fSet);
[34140]	1690	AssertRCReturn(rc, rc);
[82048]	1691	rc = pHlp->pfnSSMPutBool(pSSM, pCtx->mouseShapeInfo.fVisible);
[34140]	1692	AssertRCReturn(rc, rc);
[82048]	1693	rc = pHlp->pfnSSMPutBool(pSSM, pCtx->mouseShapeInfo.fAlpha);
[34140]	1694	AssertRCReturn(rc, rc);
[82048]	1695	rc = pHlp->pfnSSMPutU32(pSSM, pCtx->mouseShapeInfo.u32HotX);
[34140]	1696	AssertRCReturn(rc, rc);
[82048]	1697	rc = pHlp->pfnSSMPutU32(pSSM, pCtx->mouseShapeInfo.u32HotY);
[34140]	1698	AssertRCReturn(rc, rc);
[82048]	1699	rc = pHlp->pfnSSMPutU32(pSSM, pCtx->mouseShapeInfo.u32Width);
[34140]	1700	AssertRCReturn(rc, rc);
[82048]	1701	rc = pHlp->pfnSSMPutU32(pSSM, pCtx->mouseShapeInfo.u32Height);
[34140]	1702	AssertRCReturn(rc, rc);
[82048]	1703	rc = pHlp->pfnSSMPutU32(pSSM, pCtx->mouseShapeInfo.cbShape);
[34140]	1704	AssertRCReturn(rc, rc);
	1705	if (pCtx->mouseShapeInfo.cbShape)
	1706	{
[82048]	1707	rc = pHlp->pfnSSMPutMem(pSSM, pCtx->mouseShapeInfo.pu8Shape, pCtx->mouseShapeInfo.cbShape);
[34140]	1708	AssertRCReturn(rc, rc);
	1709	}
	1710
[34188]	1711	#ifdef VBOX_WITH_WDDM
[34140]	1712	/* Size of some additional data. For future extensions. */
[82048]	1713	rc = pHlp->pfnSSMPutU32(pSSM, 4);
[34188]	1714	AssertRCReturn(rc, rc);
[82048]	1715	rc = pHlp->pfnSSMPutU32(pSSM, pVGAState->fGuestCaps);
[34188]	1716	AssertRCReturn(rc, rc);
	1717	#else
	1718	/* Size of some additional data. For future extensions. */
[82048]	1719	rc = pHlp->pfnSSMPutU32(pSSM, 0);
[34140]	1720	AssertRCReturn(rc, rc);
[34188]	1721	#endif
[82048]	1722	rc = pHlp->pfnSSMPutU32(pSSM, RT_ELEMENTS(pCtx->aModeHints));
[53528]	1723	AssertRCReturn(rc, rc);
[82048]	1724	rc = pHlp->pfnSSMPutU32(pSSM, sizeof(VBVAMODEHINT));
[53528]	1725	AssertRCReturn(rc, rc);
	1726	for (unsigned i = 0; i < RT_ELEMENTS(pCtx->aModeHints); ++i)
	1727	{
[82048]	1728	rc = pHlp->pfnSSMPutMem(pSSM, &pCtx->aModeHints[i], sizeof(VBVAMODEHINT));
[53528]	1729	AssertRCReturn(rc, rc);
	1730	}
[34140]	1731	}
	1732	}
	1733
	1734	return rc;
	1735	}
	1736
[82048]	1737	int vboxVBVASaveStateExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM)
[34140]	1738	{
[82048]	1739	PVGASTATE pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
	1740	PCPDMDEVHLPR3 pHlp = pDevIns->pHlpR3;
[34140]	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 */
[62928]	1746	VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEBEGIN, 0, cbCmd);
[34140]	1747	Assert(pCmd);
	1748	if(pCmd)
	1749	{
[82048]	1750	vbvaVHWAHHPost(pVGAState, pCmd, NULL, vboxVBVASaveStateBeginPostCb, &VhwaData);
[34140]	1751	rc = VhwaData.rc;
	1752	AssertRC(rc);
	1753	if (RT_SUCCESS(rc))
	1754	{
	1755	#endif
[82048]	1756	rc = vboxVBVASaveDevStateExec(pHlp, pVGAState, pSSM);
[34140]	1757	AssertRC(rc);
	1758	#ifdef VBOX_WITH_VIDEOHWACCEL
	1759	if (RT_SUCCESS(rc))
	1760	{
	1761	vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEPERFORM, 0);
[71592]	1762	VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM *pSave = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_SAVESTATE_SAVEPERFORM);
[34140]	1763	pSave->pSSM = pSSM;
[82048]	1764	vbvaVHWAHHPost(pVGAState, pCmd, vboxVBVASaveStatePerformPreCb, NULL, &VhwaData);
[34140]	1765	rc = VhwaData.rc;
	1766	AssertRC(rc);
	1767	if (RT_SUCCESS(rc))
	1768	{
[82048]	1769	rc = vbvaVHWACommandSavePending(pHlp, pVGAState, pSSM);
[49420]	1770	AssertRCReturn(rc, rc);
	1771
[34140]	1772	vbvaVHWAHHCommandReinit(pCmd, VBOXVHWACMD_TYPE_HH_SAVESTATE_SAVEEND, 0);
[82048]	1773	vbvaVHWAHHPost(pVGAState, pCmd, vboxVBVASaveStateEndPreCb, NULL, &VhwaData);
[34140]	1774	rc = VhwaData.rc;
	1775	AssertRC(rc);
	1776	}
	1777	}
	1778	}
	1779
	1780	vbvaVHWAHHCommandRelease(pCmd);
	1781	}
[34203]	1782	else
	1783	rc = VERR_OUT_OF_RESOURCES;
[34140]	1784	#else
[34203]	1785	if (RT_SUCCESS(rc))
[34140]	1786	{
[34203]	1787	for (uint32_t i = 0; i < pVGAState->cMonitors; ++i)
	1788	{
[82048]	1789	rc = pHlp->pfnSSMPutU32(pSSM, VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC);
[34203]	1790	AssertRCReturn(rc, rc);
	1791	}
[34140]	1792	}
[51631]	1793
	1794	/* no pending commands */
[82048]	1795	pHlp->pfnSSMPutU32(pSSM, 0);
[34140]	1796	#endif
[34203]	1797	return rc;
[34140]	1798	}
	1799
[82048]	1800	int vboxVBVALoadStateExec(PPDMDEVINS pDevIns, PSSMHANDLE pSSM, uint32_t uVersion)
[34140]	1801	{
[56969]	1802	if (uVersion < VGA_SAVEDSTATE_VERSION_HGSMI)
[34140]	1803	{
	1804	/* Nothing was saved. */
	1805	return VINF_SUCCESS;
	1806	}
	1807
[82048]	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);
[34140]	1812	if (RT_SUCCESS(rc))
	1813	{
[56969]	1814	VGA_SAVED_STATE_GET_MARKER_RETURN_ON_MISMATCH(pSSM, uVersion, 2);
	1815
[34140]	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;
[82048]	1828	rc = pHlp->pfnSSMGetU32 (pSSM, &cViews);
[34140]	1829	AssertRCReturn(rc, rc);
	1830
	1831	uint32_t iView;
	1832	for (iView = 0; iView < cViews; iView++)
	1833	{
	1834	VBVAVIEW *pView = &pCtx->aViews[iView];
	1835
[82048]	1836	rc = pHlp->pfnSSMGetU32 (pSSM, &pView->view.u32ViewIndex);
[34140]	1837	AssertRCReturn(rc, rc);
[82048]	1838	rc = pHlp->pfnSSMGetU32 (pSSM, &pView->view.u32ViewOffset);
[34140]	1839	AssertRCReturn(rc, rc);
[82048]	1840	rc = pHlp->pfnSSMGetU32 (pSSM, &pView->view.u32ViewSize);
[34140]	1841	AssertRCReturn(rc, rc);
[82048]	1842	rc = pHlp->pfnSSMGetU32 (pSSM, &pView->view.u32MaxScreenSize);
[34140]	1843	AssertRCReturn(rc, rc);
	1844
[82048]	1845	rc = pHlp->pfnSSMGetU32 (pSSM, &pView->screen.u32ViewIndex);
[34140]	1846	AssertRCReturn(rc, rc);
[82048]	1847	rc = pHlp->pfnSSMGetS32 (pSSM, &pView->screen.i32OriginX);
[34140]	1848	AssertRCReturn(rc, rc);
[82048]	1849	rc = pHlp->pfnSSMGetS32 (pSSM, &pView->screen.i32OriginY);
[34140]	1850	AssertRCReturn(rc, rc);
[82048]	1851	rc = pHlp->pfnSSMGetU32 (pSSM, &pView->screen.u32StartOffset);
[34140]	1852	AssertRCReturn(rc, rc);
[82048]	1853	rc = pHlp->pfnSSMGetU32 (pSSM, &pView->screen.u32LineSize);
[34140]	1854	AssertRCReturn(rc, rc);
[82048]	1855	rc = pHlp->pfnSSMGetU32 (pSSM, &pView->screen.u32Width);
[34140]	1856	AssertRCReturn(rc, rc);
[82048]	1857	rc = pHlp->pfnSSMGetU32 (pSSM, &pView->screen.u32Height);
[34140]	1858	AssertRCReturn(rc, rc);
[82048]	1859	rc = pHlp->pfnSSMGetU16 (pSSM, &pView->screen.u16BitsPerPixel);
[34140]	1860	AssertRCReturn(rc, rc);
[82048]	1861	rc = pHlp->pfnSSMGetU16 (pSSM, &pView->screen.u16Flags);
[34140]	1862	AssertRCReturn(rc, rc);
	1863
[82048]	1864	rc = pHlp->pfnSSMGetU32 (pSSM, &pView->vbva.u32VBVAOffset);
[34140]	1865	AssertRCReturn(rc, rc);
	1866
[82048]	1867	rc = pHlp->pfnSSMGetU32 (pSSM, &pView->vbva.partialRecord.cb);
[34140]	1868	AssertRCReturn(rc, rc);
	1869
[56036]	1870	if (pView->vbva.partialRecord.cb == 0)
[34140]	1871	{
[56036]	1872	pView->vbva.partialRecord.pu8 = NULL;
[34140]	1873	}
	1874	else
	1875	{
[56036]	1876	Assert(pView->vbva.partialRecord.pu8 == NULL); /* Should be it. */
[34140]	1877
[56036]	1878	uint8_t pu8 = (uint8_t )RTMemAlloc(pView->vbva.partialRecord.cb);
[34140]	1879
	1880	if (!pu8)
	1881	{
	1882	return VERR_NO_MEMORY;
	1883	}
	1884
[56036]	1885	pView->vbva.partialRecord.pu8 = pu8;
[34140]	1886
[82048]	1887	rc = pHlp->pfnSSMGetMem (pSSM, pView->vbva.partialRecord.pu8, pView->vbva.partialRecord.cb);
[34140]	1888	AssertRCReturn(rc, rc);
	1889	}
	1890
[56036]	1891	if (pView->vbva.u32VBVAOffset == HGSMIOFFSET_VOID)
[34140]	1892	{
[56036]	1893	pView->vbva.guest.pVBVA = NULL;
[34140]	1894	}
	1895	else
	1896	{
[56036]	1897	pView->vbva.guest.pVBVA = (VBVABUFFER *)HGSMIOffsetToPointerHost(pIns, pView->vbva.u32VBVAOffset);
[34140]	1898	}
	1899	}
	1900
[56969]	1901	if (uVersion > VGA_SAVEDSTATE_VERSION_WITH_CONFIG)
[34140]	1902	{
	1903	/* Read mouse pointer shape information. */
[82048]	1904	rc = pHlp->pfnSSMGetBool (pSSM, &pCtx->mouseShapeInfo.fSet);
[34140]	1905	AssertRCReturn(rc, rc);
[82048]	1906	rc = pHlp->pfnSSMGetBool (pSSM, &pCtx->mouseShapeInfo.fVisible);
[34140]	1907	AssertRCReturn(rc, rc);
[82048]	1908	rc = pHlp->pfnSSMGetBool (pSSM, &pCtx->mouseShapeInfo.fAlpha);
[34140]	1909	AssertRCReturn(rc, rc);
[82048]	1910	rc = pHlp->pfnSSMGetU32 (pSSM, &pCtx->mouseShapeInfo.u32HotX);
[34140]	1911	AssertRCReturn(rc, rc);
[82048]	1912	rc = pHlp->pfnSSMGetU32 (pSSM, &pCtx->mouseShapeInfo.u32HotY);
[34140]	1913	AssertRCReturn(rc, rc);
[82048]	1914	rc = pHlp->pfnSSMGetU32 (pSSM, &pCtx->mouseShapeInfo.u32Width);
[34140]	1915	AssertRCReturn(rc, rc);
[82048]	1916	rc = pHlp->pfnSSMGetU32 (pSSM, &pCtx->mouseShapeInfo.u32Height);
[34140]	1917	AssertRCReturn(rc, rc);
[82048]	1918	rc = pHlp->pfnSSMGetU32 (pSSM, &pCtx->mouseShapeInfo.cbShape);
[34140]	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;
[82048]	1928	rc = pHlp->pfnSSMGetMem (pSSM, pCtx->mouseShapeInfo.pu8Shape, pCtx->mouseShapeInfo.cbShape);
[34140]	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;
[82048]	1938	rc = pHlp->pfnSSMGetU32 (pSSM, &cbExtra);
[34140]	1939	AssertRCReturn(rc, rc);
[34188]	1940	#ifdef VBOX_WITH_WDDM
	1941	if (cbExtra >= 4)
	1942	{
[82048]	1943	rc = pHlp->pfnSSMGetU32 (pSSM, &pVGAState->fGuestCaps);
[34188]	1944	AssertRCReturn(rc, rc);
[53809]	1945	pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
[34188]	1946	cbExtra -= 4;
	1947	}
	1948	#endif
[34140]	1949	if (cbExtra > 0)
	1950	{
[82048]	1951	rc = pHlp->pfnSSMSkip(pSSM, cbExtra);
[34140]	1952	AssertRCReturn(rc, rc);
	1953	}
[53535]	1954
[56969]	1955	if (uVersion >= VGA_SAVEDSTATE_VERSION_MODE_HINTS)
[53529]	1956	{
[53535]	1957	uint32_t cModeHints, cbModeHints;
[82048]	1958	rc = pHlp->pfnSSMGetU32 (pSSM, &cModeHints);
[53529]	1959	AssertRCReturn(rc, rc);
[82048]	1960	rc = pHlp->pfnSSMGetU32 (pSSM, &cbModeHints);
[53535]	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))
[82048]	1968	rc = pHlp->pfnSSMGetMem(pSSM, &pCtx->aModeHints[iHint],
[53535]	1969	cbModeHints);
	1970	else
[82048]	1971	rc = pHlp->pfnSSMSkip(pSSM, cbModeHints);
[53535]	1972	AssertRCReturn(rc, rc);
	1973	}
[53529]	1974	}
[34140]	1975	}
	1976
	1977	pCtx->cViews = iView;
	1978	LogFlowFunc(("%d views loaded\n", pCtx->cViews));
	1979
[56969]	1980	if (uVersion > VGA_SAVEDSTATE_VERSION_WDDM)
[34140]	1981	{
[51648]	1982	bool fLoadCommands;
	1983
[56969]	1984	if (uVersion < VGA_SAVEDSTATE_VERSION_FIXED_PENDVHWA)
[51648]	1985	{
[82048]	1986	const char *pcszOsArch = pHlp->pfnSSMHandleHostOSAndArch(pSSM);
[51648]	1987	Assert(pcszOsArch);
[51730]	1988	fLoadCommands = !pcszOsArch \|\| RTStrNCmp(pcszOsArch, RT_STR_TUPLE("solaris"));
[51648]	1989	}
	1990	else
	1991	fLoadCommands = true;
	1992
[34140]	1993	#ifdef VBOX_WITH_VIDEOHWACCEL
	1994	uint32_t cbCmd = sizeof (VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM); /* maximum cmd size */
[62928]	1995	VBOXVHWACMD *pCmd = vbvaVHWAHHCommandCreate(VBOXVHWACMD_TYPE_HH_SAVESTATE_LOADPERFORM, 0, cbCmd);
[34140]	1996	Assert(pCmd);
	1997	if(pCmd)
	1998	{
	1999	VBOXVBVASAVEDSTATECBDATA VhwaData = {0};
	2000	VhwaData.pSSM = pSSM;
[71592]	2001	VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM *pLoad = VBOXVHWACMD_BODY_HOST_HEAP(pCmd, VBOXVHWACMD_HH_SAVESTATE_LOADPERFORM);
[34140]	2002	pLoad->pSSM = pSSM;
	2003	vbvaVHWAHHPost (pVGAState, pCmd, vboxVBVALoadStatePerformPreCb, vboxVBVALoadStatePerformPostCb, &VhwaData);
	2004	rc = VhwaData.rc;
	2005	vbvaVHWAHHCommandRelease(pCmd);
[49420]	2006	AssertRCReturn(rc, rc);
	2007
[51631]	2008	if (fLoadCommands)
	2009	{
[82048]	2010	rc = vbvaVHWACommandLoadPending(pHlp, pVGAState, pSSM, uVersion);
[51631]	2011	AssertRCReturn(rc, rc);
	2012	}
[34140]	2013	}
	2014	else
	2015	{
	2016	rc = VERR_OUT_OF_RESOURCES;
	2017	}
	2018	#else
[51631]	2019	uint32_t u32;
	2020
	2021	for (uint32_t i = 0; i < pVGAState->cMonitors; ++i)
	2022	{
[82048]	2023	rc = pHlp->pfnSSMGetU32(pSSM, &u32);
[51631]	2024	AssertRCReturn(rc, rc);
	2025
	2026	if (u32 != VBOXVBVASAVEDSTATE_VHWAUNAVAILABLE_MAGIC)
	2027	{
[56097]	2028	LogRel(("VBVA: 2D data while 2D is not supported\n"));
[51631]	2029	return VERR_NOT_SUPPORTED;
	2030	}
	2031	}
	2032
[51648]	2033	if (fLoadCommands)
[51631]	2034	{
[82048]	2035	rc = pHlp->pfnSSMGetU32(pSSM, &u32);
[51631]	2036	AssertRCReturn(rc, rc);
	2037
[51633]	2038	if (u32)
	2039	{
[56097]	2040	LogRel(("VBVA: 2D pending command while 2D is not supported\n"));
[51633]	2041	return VERR_NOT_SUPPORTED;
	2042	}
[51631]	2043	}
[34140]	2044	#endif
	2045	}
	2046
	2047	#ifdef DEBUG_sunlover
	2048	dumpctx(pCtx);
	2049	#endif
	2050	}
	2051	}
	2052
	2053	return rc;
	2054	}
	2055
[62928]	2056	int vboxVBVALoadStateDone(PPDMDEVINS pDevIns)
[34140]	2057	{
	2058	PVGASTATE pVGAState = PDMINS_2_DATA(pDevIns, PVGASTATE);
[62928]	2059	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pVGAState->pHGSMI);
[34140]	2060	if (pCtx)
	2061	{
	2062	uint32_t iView;
	2063	for (iView = 0; iView < pCtx->cViews; iView++)
	2064	{
	2065	VBVAVIEW *pView = &pCtx->aViews[iView];
[56036]	2066	if (pView->vbva.guest.pVBVA)
[34140]	2067	{
[56797]	2068	int rc = vbvaEnable(iView, pVGAState, pCtx, pView->vbva.guest.pVBVA, pView->vbva.u32VBVAOffset, true /* fRestored */);
	2069	if (RT_SUCCESS(rc))
[60905]	2070	vbvaResize(pVGAState, pView, &pView->screen, false);
[56797]	2071	else
	2072	LogRel(("VBVA: can not restore: %Rrc\n", rc));
[34140]	2073	}
	2074	}
	2075
	2076	if (pCtx->mouseShapeInfo.fSet)
[56036]	2077	vbvaUpdateMousePointerShape(pVGAState, &pCtx->mouseShapeInfo, true);
[34140]	2078	}
	2079
	2080	return VINF_SUCCESS;
	2081	}
	2082
[82088]	2083	void VBVARaiseIrq(PVGASTATE pVGAState, uint32_t fFlags)
[41636]	2084	{
	2085	PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
[56041]	2086
[82050]	2087	PDMDevHlpCritSectEnter(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSectIRQ, VERR_SEM_BUSY);
[44876]	2088
[61973]	2089	const uint32_t fu32CurrentGuestFlags = HGSMIGetHostGuestFlags(pVGAState->pHGSMI);
	2090	if ((fu32CurrentGuestFlags & HGSMIHOSTFLAGS_IRQ) == 0)
[60465]	2091	{
[61973]	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);
[60465]	2102	}
[61973]	2103	else
	2104	{
	2105	/* IRQ already set, remember the new flags. */
	2106	pVGAState->fu32PendingGuestFlags \|= HGSMIHOSTFLAGS_IRQ \| fFlags;
	2107	}
[41636]	2108
[82050]	2109	PDMDevHlpCritSectLeave(pVGAState->CTX_SUFF(pDevIns), &pVGAState->CritSectIRQ);
[51324]	2110	}
	2111
[60465]	2112	void VBVAOnResume(PVGASTATE pThis)
	2113	{
	2114	PPDMDEVINS pDevIns = pThis->pDevInsR3;
	2115
[82050]	2116	PDMDevHlpCritSectEnter(pDevIns, &pThis->CritSectIRQ, VERR_SEM_BUSY);
[60465]	2117
[61973]	2118	if (HGSMIGetHostGuestFlags(pThis->pHGSMI) & HGSMIHOSTFLAGS_IRQ)
	2119	PDMDevHlpPCISetIrqNoWait(pDevIns, 0, PDM_IRQ_LEVEL_HIGH);
	2120
[82050]	2121	PDMDevHlpCritSectLeave(pDevIns, &pThis->CritSectIRQ);
[60465]	2122	}
	2123
[71590]	2124	static int vbvaHandleQueryConf32(PVGASTATE pVGAState, VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *pConf32)
[56036]	2125	{
[71619]	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));
[56036]	2129
[71619]	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)
[77965]	2140	uValue = VBOX_VBVA_CURSOR_CAPABILITY_HARDWARE;
[71619]	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;
[71656]	2148	else if (idxQuery == UINT32_MAX)
	2149	uValue = UINT32_MAX; /* Older GA uses this for sanity checking. See testQueryConf in HGSMIBase.cpp on branches. */
[56036]	2150	else
[71619]	2151	ASSERT_GUEST_MSG_FAILED_RETURN(("Invalid index %#x\n", idxQuery), VERR_INVALID_PARAMETER);
[56036]	2152
[71619]	2153	pConf32->u32Value = uValue;
	2154	return VINF_SUCCESS;
[56036]	2155	}
	2156
[71619]	2157	static int vbvaHandleSetConf32(VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *pConf32)
[56036]	2158	{
[71619]	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));
[56036]	2163
[71619]	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. */ }
[56036]	2168	else
[71619]	2169	ASSERT_GUEST_MSG_FAILED_RETURN(("Invalid index %#x (value=%u)\n", idxQuery, uValue), VERR_INVALID_PARAMETER);
[56036]	2170
[71620]	2171	RT_NOREF_PV(uValue);
[71619]	2172	return VINF_SUCCESS;
[56036]	2173	}
	2174
[71590]	2175	static int vbvaHandleInfoHeap(PVGASTATE pVGAState, const VBVAINFOHEAP RT_UNTRUSTED_VOLATILE_GUEST *pInfoHeap)
[56036]	2176	{
[71619]	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));
[56036]	2181
[71619]	2182	return HGSMIHostHeapSetup(pVGAState->pHGSMI, offHeap, cbHeap);
[56036]	2183	}
	2184
[71590]	2185	int VBVAInfoView(PVGASTATE pVGAState, const VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_GUEST *pView)
[51121]	2186	{
[71590]	2187	VBVAINFOVIEW view;
[71619]	2188	RT_COPY_VOLATILE(view, *pView);
	2189	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
[56036]	2190
[55844]	2191	LogFlowFunc(("VBVA_INFO_VIEW: u32ViewIndex %d, u32ViewOffset 0x%x, u32ViewSize 0x%x, u32MaxScreenSize 0x%x\n",
[56036]	2192	view.u32ViewIndex, view.u32ViewOffset, view.u32ViewSize, view.u32MaxScreenSize));
[49507]	2193
[71619]	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();
[51121]	2205
[71619]	2206	pCtx->aViews[view.u32ViewIndex].view = view;
	2207	return VINF_SUCCESS;
[51121]	2208	}
	2209
[71590]	2210	int VBVAInfoScreen(PVGASTATE pVGAState, const VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_GUEST *pScreen)
[51121]	2211	{
[71619]	2212	/*
	2213	* Copy input into non-volatile buffer.
	2214	*/
[71590]	2215	VBVAINFOSCREEN screen;
[71619]	2216	RT_COPY_VOLATILE(screen, *pScreen);
	2217	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
[77703]	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));
[51121]	2222
[71619]	2223	/*
	2224	* Validate input.
	2225	*/
[56036]	2226	/* Allow screen.u16BitsPerPixel == 0 because legacy guest code used it for screen blanking. */
[71619]	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();
[55844]	2239
[71619]	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);
[51121]	2246
[71619]	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",
[71620]	2253	screen.u32StartOffset, pView->u32ViewSize, u64ScreenSize, pView->u32MaxScreenSize),
[71619]	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;
[51121]	2262	}
	2263
[51260]	2264	int VBVAGetInfoViewAndScreen(PVGASTATE pVGAState, uint32_t u32ViewIndex, VBVAINFOVIEW pView, VBVAINFOSCREEN pScreen)
	2265	{
	2266	if (u32ViewIndex >= pVGAState->cMonitors)
	2267	return VERR_INVALID_PARAMETER;
[51121]	2268
[51260]	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
[71619]	2281	static int vbvaHandleEnable(PVGASTATE pVGAState, uint32_t fEnableFlags, uint32_t offEnable, uint32_t idScreen)
[56036]	2282	{
[71619]	2283	LogFlowFunc(("VBVA_ENABLE[%u]: fEnableFlags=0x%x offEnable=%#x\n", idScreen, fEnableFlags, offEnable));
[56036]	2284	PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
[71619]	2285	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pIns);
[51260]	2286
[71619]	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)
[56036]	2296	{
[71619]	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);
[56036]	2306	else
	2307	{
[71619]	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;
[56036]	2318	}
[71619]	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();
[56036]	2325
[71619]	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. */
[56036]	2335
[71619]	2336	/* Process any pending orders and empty the VBVA ring buffer. */
	2337	vbvaFlush(pVGAState, pCtx);
[56797]	2338
[71619]	2339	rc = vbvaEnable(idScreen, pVGAState, pCtx, pVBVA, offEnable, false /* fRestored */);
[56797]	2340	if (RT_FAILURE(rc))
[56799]	2341	LogRelMax(8, ("VBVA: can not enable: %Rrc\n", rc));
[56036]	2342	}
	2343	else
[71619]	2344	rc = vbvaDisable(idScreen, pVGAState, pCtx);
[56036]	2345	return rc;
	2346	}
	2347
[70604]	2348	static int vbvaHandleQueryModeHints(PVGASTATE pVGAState, VBVAQUERYMODEHINTS volatile *pQueryModeHints, HGSMISIZE cbBuffer)
[56036]	2349	{
	2350	PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
[70604]	2351	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pIns);
[56036]	2352
[71626]	2353	/*
	2354	* Copy and validate the request.
	2355	*/
[70604]	2356	uint16_t const cHintsQueried = pQueryModeHints->cHintsQueried;
	2357	uint16_t const cbHintStructureGuest = pQueryModeHints->cbHintStructureGuest;
[71626]	2358	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
[56036]	2359
[56097]	2360	LogRelFlowFunc(("VBVA: HandleQueryModeHints: cHintsQueried=%RU16, cbHintStructureGuest=%RU16\n",
[70604]	2361	cHintsQueried, cbHintStructureGuest));
[71626]	2362	ASSERT_GUEST_RETURN(cbBuffer >= sizeof(VBVAQUERYMODEHINTS) + (uint32_t)cHintsQueried * cbHintStructureGuest,
	2363	VERR_INVALID_PARAMETER);
	2364	RT_UNTRUSTED_VALIDATED_FENCE();
[56036]	2365
[71626]	2366	/*
	2367	* Produce the requested data.
	2368	*/
[70604]	2369	uint8_t pbHint = (uint8_t )(pQueryModeHints + 1);
[56036]	2370	memset(pbHint, ~0, cbBuffer - sizeof(VBVAQUERYMODEHINTS));
	2371
[70604]	2372	for (unsigned iHint = 0; iHint < cHintsQueried && iHint < VBOX_VIDEO_MAX_SCREENS; ++iHint)
[56036]	2373	{
[70604]	2374	memcpy(pbHint, &pCtx->aModeHints[iHint], RT_MIN(cbHintStructureGuest, sizeof(VBVAMODEHINT)));
	2375	pbHint += cbHintStructureGuest;
[59169]	2376	Assert((uintptr_t)(pbHint - (uint8_t *)pQueryModeHints) <= cbBuffer);
[56036]	2377	}
	2378
	2379	return VINF_SUCCESS;
	2380	}
	2381
[22622]	2382	/*
	2383	*
	2384	* New VBVA uses a new interface id: #define VBE_DISPI_ID_VBOX_VIDEO 0xBE01
	2385	*
[23793]	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
[22622]	2390	*
	2391	*/
	2392
	2393	static DECLCALLBACK(void) vbvaNotifyGuest (void *pvCallback)
	2394	{
[32877]	2395	#if defined(VBOX_WITH_HGSMI) && (defined(VBOX_WITH_VIDEOHWACCEL) \|\| defined(VBOX_WITH_VDMA) \|\| defined(VBOX_WITH_WDDM))
[22622]	2396	PVGASTATE pVGAState = (PVGASTATE)pvCallback;
[61973]	2397	VBVARaiseIrq (pVGAState, 0);
[22622]	2398	#else
	2399	NOREF(pvCallback);
	2400	/* Do nothing. Later the VMMDev/VGA IRQ can be used for the notification. */
	2401	#endif
	2402	}
	2403
[70604]	2404	/**
	2405	* The guest submitted a command buffer (hit VGA_PORT_HGSMI_GUEST).
[56036]	2406	*
[70604]	2407	* Verify the buffer size and invoke corresponding handler.
	2408	*
[58170]	2409	* @return VBox status code.
[56036]	2410	* @param pvHandler The VBVA channel context.
	2411	* @param u16ChannelInfo Command code.
[70604]	2412	* @param pvBuffer HGSMI buffer with command data. Considered volatile!
[56036]	2413	* @param cbBuffer Size of command data.
[70604]	2414	*
	2415	* @thread EMT
[56036]	2416	*/
[71590]	2417	static DECLCALLBACK(int) vbvaChannelHandler(void *pvHandler, uint16_t u16ChannelInfo,
	2418	void RT_UNTRUSTED_VOLATILE_GUEST *pvBuffer, HGSMISIZE cbBuffer)
[22622]	2419	{
	2420	int rc = VINF_SUCCESS;
	2421
[70604]	2422	LogFlowFunc(("pvHandler %p, u16ChannelInfo %d, pvBuffer %p, cbBuffer %u\n", pvHandler, u16ChannelInfo, pvBuffer, cbBuffer));
[22622]	2423
[70604]	2424	PVGASTATE pVGAState = (PVGASTATE)pvHandler;
	2425	PHGSMIINSTANCE pIns = pVGAState->pHGSMI;
	2426	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pIns);
[22622]	2427
	2428	switch (u16ChannelInfo)
	2429	{
[32877]	2430	#ifdef VBOX_WITH_VDMA
[26833]	2431	case VBVA_VDMA_CMD:
[70596]	2432	if (cbBuffer >= VBoxSHGSMIBufferHeaderSize() + sizeof(VBOXVDMACBUF_DR))
[39603]	2433	{
[71612]	2434	VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_GUEST *pCmd
	2435	= (VBOXVDMACBUF_DR RT_UNTRUSTED_VOLATILE_GUEST )VBoxSHGSMIBufferData((VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_GUEST )pvBuffer);
[70596]	2436	vboxVDMACommand(pVGAState->pVdma, pCmd, cbBuffer - VBoxSHGSMIBufferHeaderSize());
	2437	rc = VINF_SUCCESS;
	2438	}
	2439	else
[39603]	2440	rc = VERR_INVALID_PARAMETER;
[70596]	2441	break;
[56036]	2442
[26833]	2443	case VBVA_VDMA_CTL:
[70596]	2444	if (cbBuffer >= VBoxSHGSMIBufferHeaderSize() + sizeof(VBOXVDMA_CTL))
[39603]	2445	{
[71612]	2446	VBOXVDMA_CTL RT_UNTRUSTED_VOLATILE_GUEST *pCmd
	2447	= (VBOXVDMA_CTL RT_UNTRUSTED_VOLATILE_GUEST )VBoxSHGSMIBufferData((VBOXSHGSMIHEADER RT_UNTRUSTED_VOLATILE_GUEST )pvBuffer);
[70596]	2448	vboxVDMAControl(pVGAState->pVdma, pCmd, cbBuffer - VBoxSHGSMIBufferHeaderSize());
	2449	}
	2450	else
[39603]	2451	rc = VERR_INVALID_PARAMETER;
[70596]	2452	break;
[56036]	2453	#endif /* VBOX_WITH_VDMA */
	2454
[22622]	2455	case VBVA_QUERY_CONF32:
[70604]	2456	if (cbBuffer >= sizeof(VBVACONF32))
[71590]	2457	rc = vbvaHandleQueryConf32(pVGAState, (VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
[70604]	2458	else
[22622]	2459	rc = VERR_INVALID_PARAMETER;
[70604]	2460	break;
[22622]	2461
	2462	case VBVA_SET_CONF32:
[70604]	2463	if (cbBuffer >= sizeof(VBVACONF32))
[71619]	2464	rc = vbvaHandleSetConf32((VBVACONF32 RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
[70604]	2465	else
[22622]	2466	rc = VERR_INVALID_PARAMETER;
[70604]	2467	break;
[22622]	2468
	2469	case VBVA_INFO_VIEW:
[55844]	2470	/* Expect at least one VBVAINFOVIEW structure. */
[70604]	2471	rc = VERR_INVALID_PARAMETER;
	2472	if (cbBuffer >= sizeof(VBVAINFOVIEW))
[22622]	2473	{
[70604]	2474	/* Guest submits an array of VBVAINFOVIEW structures. */
[71590]	2475	const VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_GUEST pView = (VBVAINFOVIEW RT_UNTRUSTED_VOLATILE_GUEST )pvBuffer;
[70604]	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	}
[22622]	2484	}
[70604]	2485	break;
[22622]	2486
	2487	case VBVA_INFO_HEAP:
[70604]	2488	if (cbBuffer >= sizeof(VBVAINFOHEAP))
[71590]	2489	rc = vbvaHandleInfoHeap(pVGAState, (VBVAINFOHEAP RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
[70604]	2490	else
[22622]	2491	rc = VERR_INVALID_PARAMETER;
[70604]	2492	break;
[22622]	2493
	2494	case VBVA_FLUSH:
[70604]	2495	if (cbBuffer >= sizeof(VBVAFLUSH))
	2496	rc = vbvaFlush(pVGAState, pCtx);
	2497	else
[22622]	2498	rc = VERR_INVALID_PARAMETER;
[70604]	2499	break;
[22622]	2500
	2501	case VBVA_INFO_SCREEN:
[70604]	2502	rc = VERR_INVALID_PARAMETER;
	2503	if (cbBuffer >= sizeof(VBVAINFOSCREEN))
[71590]	2504	rc = VBVAInfoScreen(pVGAState, (VBVAINFOSCREEN RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
[70604]	2505	break;
[22622]	2506
	2507	case VBVA_ENABLE:
[70604]	2508	rc = VERR_INVALID_PARAMETER;
	2509	if (cbBuffer >= sizeof(VBVAENABLE))
[22622]	2510	{
[71590]	2511	VBVAENABLE RT_UNTRUSTED_VOLATILE_GUEST pVbvaEnable = (VBVAENABLE RT_UNTRUSTED_VOLATILE_GUEST )pvBuffer;
[71619]	2512	uint32_t const fEnableFlags = pVbvaEnable->u32Flags;
	2513	uint32_t const offEnable = pVbvaEnable->u32Offset;
[71607]	2514	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
[22622]	2515
[71619]	2516	uint32_t idScreen;
	2517	if (fEnableFlags & VBVA_F_EXTENDED)
[28228]	2518	{
[71619]	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();
[28228]	2522	}
[70604]	2523	else
[71619]	2524	idScreen = vbvaViewFromBufferPtr(pIns, pCtx, pvBuffer);
[22622]	2525
[71619]	2526	rc = vbvaHandleEnable(pVGAState, fEnableFlags, offEnable, idScreen);
[70604]	2527	pVbvaEnable->i32Result = rc;
[28228]	2528	}
[70604]	2529	break;
[28228]	2530
[22622]	2531	case VBVA_MOUSE_POINTER_SHAPE:
[70604]	2532	if (cbBuffer >= sizeof(VBVAMOUSEPOINTERSHAPE))
[22622]	2533	{
[71619]	2534	VBVAMOUSEPOINTERSHAPE RT_UNTRUSTED_VOLATILE_GUEST *pShape
	2535	= (VBVAMOUSEPOINTERSHAPE RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
[70604]	2536	rc = vbvaMousePointerShape(pVGAState, pCtx, pShape, cbBuffer);
	2537	pShape->i32Result = rc;
	2538	}
	2539	else
[22622]	2540	rc = VERR_INVALID_PARAMETER;
[70604]	2541	break;
[22622]	2542
	2543
	2544	#ifdef VBOX_WITH_VIDEOHWACCEL
	2545	case VBVA_VHWA_CMD:
[70604]	2546	if (cbBuffer >= VBOXVHWACMD_HEADSIZE())
[49420]	2547	{
[71590]	2548	vbvaVHWAHandleCommand(pVGAState, (VBOXVHWACMD RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer);
[70604]	2549	rc = VINF_SUCCESS;
	2550	}
	2551	else
[49420]	2552	rc = VERR_INVALID_PARAMETER;
[70604]	2553	break;
	2554	#endif
[22622]	2555
[32622]	2556	#ifdef VBOX_WITH_WDDM
[29742]	2557	case VBVA_INFO_CAPS:
[70604]	2558	if (cbBuffer >= sizeof(VBVACAPS))
[29742]	2559	{
[71590]	2560	VBVACAPS RT_UNTRUSTED_VOLATILE_GUEST pCaps = (VBVACAPS RT_UNTRUSTED_VOLATILE_GUEST )pvBuffer;
[70604]	2561	pVGAState->fGuestCaps = pCaps->fCaps;
[71607]	2562	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
	2563
[70604]	2564	pVGAState->pDrv->pfnVBVAGuestCapabilityUpdate(pVGAState->pDrv, pVGAState->fGuestCaps);
	2565	pCaps->rc = rc = VINF_SUCCESS;
	2566	}
	2567	else
[29742]	2568	rc = VERR_INVALID_PARAMETER;
[70604]	2569	break;
	2570	#endif
[29742]	2571
[41636]	2572	case VBVA_SCANLINE_CFG:
[70604]	2573	if (cbBuffer >= sizeof(VBVASCANLINECFG))
[41636]	2574	{
[71590]	2575	VBVASCANLINECFG RT_UNTRUSTED_VOLATILE_GUEST pCfg = (VBVASCANLINECFG RT_UNTRUSTED_VOLATILE_GUEST )pvBuffer;
[70604]	2576	pVGAState->fScanLineCfg = pCfg->fFlags;
[71607]	2577	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
	2578
[70604]	2579	pCfg->rc = rc = VINF_SUCCESS;
	2580	}
	2581	else
[41636]	2582	rc = VERR_INVALID_PARAMETER;
[70604]	2583	break;
[41636]	2584
[53528]	2585	case VBVA_QUERY_MODE_HINTS:
[70604]	2586	if (cbBuffer >= sizeof(VBVAQUERYMODEHINTS))
[53528]	2587	{
[71626]	2588	VBVAQUERYMODEHINTS RT_UNTRUSTED_VOLATILE_GUEST *pQueryModeHints
	2589	= (VBVAQUERYMODEHINTS RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
[70604]	2590	rc = vbvaHandleQueryModeHints(pVGAState, pQueryModeHints, cbBuffer);
	2591	pQueryModeHints->rc = rc;
	2592	}
	2593	else
[53528]	2594	rc = VERR_INVALID_PARAMETER;
[70604]	2595	break;
[56036]	2596
[53965]	2597	case VBVA_REPORT_INPUT_MAPPING:
[70604]	2598	if (cbBuffer >= sizeof(VBVAREPORTINPUTMAPPING))
[53965]	2599	{
[71590]	2600	VBVAREPORTINPUTMAPPING inputMapping;
	2601	{
	2602	VBVAREPORTINPUTMAPPING RT_UNTRUSTED_VOLATILE_GUEST *pInputMapping
	2603	= (VBVAREPORTINPUTMAPPING RT_UNTRUSTED_VOLATILE_GUEST *)pvBuffer;
[71626]	2604	inputMapping.x = pInputMapping->x;
	2605	inputMapping.y = pInputMapping->y;
[71590]	2606	inputMapping.cx = pInputMapping->cx;
	2607	inputMapping.cy = pInputMapping->cy;
	2608	}
[71607]	2609	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
[71590]	2610
[70604]	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
[53965]	2619	rc = VERR_INVALID_PARAMETER;
[70604]	2620	break;
[56036]	2621
[53965]	2622	case VBVA_CURSOR_POSITION:
[70604]	2623	if (cbBuffer >= sizeof(VBVACURSORPOSITION))
[53965]	2624	{
[71590]	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;
[71607]	2630	RT_UNTRUSTED_NONVOLATILE_COPY_FENCE();
[56036]	2631
[77130]	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));
[56036]	2634
[77130]	2635	pVGAState->pDrv->pfnVBVAReportCursorPosition(pVGAState->pDrv, RT_BOOL(Report.fReportPosition), vbvaViewFromBufferPtr(pIns, pCtx, pvBuffer), Report.x, Report.y);
[77965]	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;
[70604]	2640	rc = VINF_SUCCESS;
	2641	}
	2642	else
	2643	rc = VERR_INVALID_PARAMETER;
	2644	break;
[56036]	2645
[22622]	2646	default:
[70604]	2647	Log(("Unsupported VBVA guest command %d (%#x)!!!\n", u16ChannelInfo, u16ChannelInfo));
[22622]	2648	break;
	2649	}
	2650
	2651	return rc;
	2652	}
	2653
[50259]	2654	/* When VBVA is paused, then VGA device is allowed to work but
	2655	* no HGSMI etc state is changed.
	2656	*/
	2657	void 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
[60369]	2672	bool 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
	2689	void 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
[22622]	2700	void VBVAReset (PVGASTATE pVGAState)
	2701	{
	2702	if (!pVGAState \|\| !pVGAState->pHGSMI)
	2703	{
	2704	return;
	2705	}
	2706
	2707	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext (pVGAState->pHGSMI);
	2708
[24053]	2709	#ifdef VBOX_WITH_VIDEOHWACCEL
	2710	vbvaVHWAReset (pVGAState);
	2711	#endif
	2712
[61976]	2713	HGSMIReset(pVGAState->pHGSMI);
	2714	/* Make sure the IRQ is reset. */
	2715	PDMDevHlpPCISetIrq(pVGAState->pDevInsR3, 0, PDM_IRQ_LEVEL_LOW);
	2716	pVGAState->fu32PendingGuestFlags = 0;
[24053]	2717
[22622]	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	}
[24714]	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;
[22622]	2734	}
[24053]	2735
[22622]	2736	}
	2737
	2738	int 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	{
[50259]	2746	if (!pCtx->fPaused)
	2747	{
	2748	rc = vbvaFlush (pVGAState, pCtx);
[22622]	2749
[50259]	2750	if (RT_SUCCESS (rc))
[22622]	2751	{
[56036]	2752	if (!pCtx->aViews[0].vbva.guest.pVBVA)
[50259]	2753	{
	2754	/* VBVA is not enabled for the first view, so VGA device must do updates. */
	2755	rc = VERR_NOT_SUPPORTED;
	2756	}
[22622]	2757	}
	2758	}
	2759	}
	2760
	2761	return rc;
	2762	}
	2763
[53528]	2764	static 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! */
[54168]	2773	if (iDisplay >= RT_MIN(pThis->cMonitors, RT_ELEMENTS(pCtx->aModeHints)))
[53528]	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;
[54162]	2782	if (fNotifyGuest && pThis->fGuestCaps & VBVACAPS_IRQ && pThis->fGuestCaps & VBVACAPS_VIDEO_MODE_HINTS)
[53528]	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
[82088]	2790	/**
	2791	* @interface_method_impl{PDMIDISPLAYPORT,pfnSendModeHint}
	2792	*/
	2793	DECLCALLBACK(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)
[53528]	2795	{
[82088]	2796	PVGASTATE pThis = IDISPLAYPORT_2_VGASTATE(pInterface);
	2797	int rc = PDMDevHlpCritSectEnter(pThis->pDevInsR3, &pThis->CritSect, VERR_SEM_BUSY);
	2798	AssertRC(rc);
[53528]	2799
[82088]	2800	rc = vbvaSendModeHintWorker(pThis, cx, cy, cBPP, iDisplay, dx, dy, fEnabled, fNotifyGuest);
	2801
[82050]	2802	PDMDevHlpCritSectLeave(pThis->pDevInsR3, &pThis->CritSect);
[53528]	2803	return rc;
	2804	}
	2805
[70596]	2806	int VBVAInit(PVGASTATE pVGAState)
[22622]	2807	{
	2808	PPDMDEVINS pDevIns = pVGAState->pDevInsR3;
	2809
	2810	PVM pVM = PDMDevHlpGetVM(pDevIns);
	2811
[70596]	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))
[22622]	2822	{
[70596]	2823	rc = HGSMIHostChannelRegister(pVGAState->pHGSMI,
	2824	HGSMI_CH_VBVA,
	2825	vbvaChannelHandler,
	2826	pVGAState);
	2827	if (RT_SUCCESS(rc))
[22622]	2828	{
[70596]	2829	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pVGAState->pHGSMI);
[22622]	2830	pCtx->cViews = pVGAState->cMonitors;
[50259]	2831	pCtx->fPaused = true;
[54594]	2832	memset(pCtx->aModeHints, ~0, sizeof(pCtx->aModeHints));
[22622]	2833	}
	2834	}
	2835
	2836	return rc;
	2837
	2838	}
	2839
[70370]	2840	void VBVADestroy(PVGASTATE pVGAState)
[22622]	2841	{
[70370]	2842	PHGSMIINSTANCE pHgsmi = pVGAState->pHGSMI;
	2843	if (pHgsmi)
[24714]	2844	{
[70370]	2845	VBVACONTEXT pCtx = (VBVACONTEXT )HGSMIContext(pHgsmi);
[24714]	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;
[70370]	2851
	2852	HGSMIDestroy(pHgsmi);
	2853	pVGAState->pHGSMI = NULL;
[24714]	2854	}
[70370]	2855	}
[24714]	2856

Note: See TracBrowser for help on using the repository browser.

Download in other formats:

© 2023 Oracle
Contact – Privacy policy – Terms of Use