VirtualBox

source: vbox/trunk/src/VBox/Additions/common/VBoxVideo/HGSMIBase.cpp@ 40387

Last change on this file since 40387 was 40387, checked in by vboxsync, 13 years ago

wddm: concurrency fixes
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 20.9 KB
Line 
1/* $Id: HGSMIBase.cpp 40387 2012-03-06 20:38:49Z vboxsync $ */
2/** @file
3 * VirtualBox Video driver, common code - HGSMI initialisation and helper
4 * functions.
5 */
6
7/*
8 * Copyright (C) 2006-2010 Oracle Corporation
9 *
10 * This file is part of VirtualBox Open Source Edition (OSE), as
11 * available from http://www.virtualbox.org. This file is free software;
12 * you can redistribute it and/or modify it under the terms of the GNU
13 * General Public License (GPL) as published by the Free Software
14 * Foundation, in version 2 as it comes in the "COPYING" file of the
15 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
16 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
17 */
18
19#include <VBox/VBoxVideoGuest.h>
20#include <VBox/VBoxVideo.h>
21#include <VBox/VBoxGuest.h>
22#include <VBox/Hardware/VBoxVideoVBE.h>
23#include <VBox/VMMDev.h>
24
25#include <iprt/asm.h>
26#include <iprt/log.h>
27#include <iprt/string.h>
28
29/** Send completion notification to the host for the command located at offset
30 * @a offt into the host command buffer. */
31static void HGSMINotifyHostCmdComplete(PHGSMIHOSTCOMMANDCONTEXT pCtx, HGSMIOFFSET offt)
32{
33 VBoxVideoCmnPortWriteUlong(pCtx->port, offt);
34}
35
36
37/**
38 * Inform the host that a command has been handled.
39 *
40 * @param pCtx the context containing the heap to be used
41 * @param pvMem pointer into the heap as mapped in @a pCtx to the command to
42 * be completed
43 */
44RTDECL(void) VBoxHGSMIHostCmdComplete(PHGSMIHOSTCOMMANDCONTEXT pCtx,
45 void *pvMem)
46{
47 HGSMIBUFFERHEADER *pHdr = HGSMIBufferHeaderFromData(pvMem);
48 HGSMIOFFSET offMem = HGSMIPointerToOffset(&pCtx->areaCtx, pHdr);
49 Assert(offMem != HGSMIOFFSET_VOID);
50 if(offMem != HGSMIOFFSET_VOID)
51 {
52 HGSMINotifyHostCmdComplete(pCtx, offMem);
53 }
54}
55
56
57/** Submit an incoming host command to the appropriate handler. */
58static void hgsmiHostCmdProcess(PHGSMIHOSTCOMMANDCONTEXT pCtx,
59 HGSMIOFFSET offBuffer)
60{
61 int rc = HGSMIBufferProcess(&pCtx->areaCtx, &pCtx->channels, offBuffer);
62 Assert(!RT_FAILURE(rc));
63 if(RT_FAILURE(rc))
64 {
65 /* failure means the command was not submitted to the handler for some reason
66 * it's our responsibility to notify its completion in this case */
67 HGSMINotifyHostCmdComplete(pCtx, offBuffer);
68 }
69 /* if the cmd succeeded it's responsibility of the callback to complete it */
70}
71
72/** Get the next command from the host. */
73static HGSMIOFFSET hgsmiGetHostBuffer(PHGSMIHOSTCOMMANDCONTEXT pCtx)
74{
75 return VBoxVideoCmnPortReadUlong(pCtx->port);
76}
77
78
79/** Get and handle the next command from the host. */
80static void hgsmiHostCommandQueryProcess(PHGSMIHOSTCOMMANDCONTEXT pCtx)
81{
82 HGSMIOFFSET offset = hgsmiGetHostBuffer(pCtx);
83 AssertReturnVoid(offset != HGSMIOFFSET_VOID);
84 hgsmiHostCmdProcess(pCtx, offset);
85}
86
87
88/** Drain the host command queue. */
89RTDECL(void) VBoxHGSMIProcessHostQueue(PHGSMIHOSTCOMMANDCONTEXT pCtx)
90{
91 while (pCtx->pfHostFlags->u32HostFlags & HGSMIHOSTFLAGS_COMMANDS_PENDING)
92 {
93 if (!ASMAtomicCmpXchgBool(&pCtx->fHostCmdProcessing, true, false))
94 return;
95 hgsmiHostCommandQueryProcess(pCtx);
96 ASMAtomicWriteBool(&pCtx->fHostCmdProcessing, false);
97 }
98}
99
100
101/** Detect whether HGSMI is supported by the host. */
102RTDECL(bool) VBoxHGSMIIsSupported(void)
103{
104 uint16_t DispiId;
105
106 VBoxVideoCmnPortWriteUshort(VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_ID);
107 VBoxVideoCmnPortWriteUshort(VBE_DISPI_IOPORT_DATA, VBE_DISPI_ID_HGSMI);
108
109 DispiId = VBoxVideoCmnPortReadUshort(VBE_DISPI_IOPORT_DATA);
110
111 return (DispiId == VBE_DISPI_ID_HGSMI);
112}
113
114
115/**
116 * Allocate and initialise a command descriptor in the guest heap for a
117 * guest-to-host command.
118 *
119 * @returns pointer to the descriptor's command data buffer
120 * @param pCtx the context containing the heap to be used
121 * @param cbData the size of the command data to go into the descriptor
122 * @param u8Ch the HGSMI channel to be used, set to the descriptor
123 * @param u16Op the HGSMI command to be sent, set to the descriptor
124 */
125RTDECL(void *) VBoxHGSMIBufferAlloc(PHGSMIGUESTCOMMANDCONTEXT pCtx,
126 HGSMISIZE cbData,
127 uint8_t u8Ch,
128 uint16_t u16Op)
129{
130#ifdef VBOX_WDDM_MINIPORT
131 return VBoxSHGSMIHeapAlloc (&pCtx->heapCtx, cbData, u8Ch, u16Op);
132#else
133 return HGSMIHeapAlloc (&pCtx->heapCtx, cbData, u8Ch, u16Op);
134#endif
135}
136
137
138/**
139 * Free a descriptor allocated by @a VBoxHGSMIBufferAlloc.
140 *
141 * @param pCtx the context containing the heap used
142 * @param pvBuffer the pointer returned by @a VBoxHGSMIBufferAlloc
143 */
144RTDECL(void) VBoxHGSMIBufferFree(PHGSMIGUESTCOMMANDCONTEXT pCtx,
145 void *pvBuffer)
146{
147#ifdef VBOX_WDDM_MINIPORT
148 VBoxSHGSMIHeapFree (&pCtx->heapCtx, pvBuffer);
149#else
150 HGSMIHeapFree (&pCtx->heapCtx, pvBuffer);
151#endif
152}
153
154
155/**
156 * Submit a command descriptor allocated by @a VBoxHGSMIBufferAlloc.
157 *
158 * @param pCtx the context containing the heap used
159 * @param pvBuffer the pointer returned by @a VBoxHGSMIBufferAlloc
160 */
161RTDECL(int) VBoxHGSMIBufferSubmit(PHGSMIGUESTCOMMANDCONTEXT pCtx,
162 void *pvBuffer)
163{
164 /* Initialize the buffer and get the offset for port IO. */
165 HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (HGSMIGUESTCMDHEAP_GET(&pCtx->heapCtx), pvBuffer);
166
167 Assert(offBuffer != HGSMIOFFSET_VOID);
168 if (offBuffer != HGSMIOFFSET_VOID)
169 {
170 /* Submit the buffer to the host. */
171 VBoxVideoCmnPortWriteUlong(pCtx->port, offBuffer);
172 return VINF_SUCCESS;
173 }
174
175 return VERR_INVALID_PARAMETER;
176}
177
178
179/** Inform the host of the location of the host flags in VRAM via an HGSMI
180 * command. */
181static int vboxHGSMIReportFlagsLocation(PHGSMIGUESTCOMMANDCONTEXT pCtx,
182 HGSMIOFFSET offLocation)
183{
184 HGSMIBUFFERLOCATION *p;
185 int rc = VINF_SUCCESS;
186
187 /* Allocate the IO buffer. */
188 p = (HGSMIBUFFERLOCATION *)VBoxHGSMIBufferAlloc(pCtx,
189 sizeof(HGSMIBUFFERLOCATION),
190 HGSMI_CH_HGSMI,
191 HGSMI_CC_HOST_FLAGS_LOCATION);
192 if (p)
193 {
194 /* Prepare data to be sent to the host. */
195 p->offLocation = offLocation;
196 p->cbLocation = sizeof(HGSMIHOSTFLAGS);
197 rc = VBoxHGSMIBufferSubmit(pCtx, p);
198 /* Free the IO buffer. */
199 VBoxHGSMIBufferFree(pCtx, p);
200 }
201 else
202 rc = VERR_NO_MEMORY;
203 return rc;
204}
205
206
207/** Notify the host of HGSMI-related guest capabilities via an HGSMI command.
208 */
209static int vboxHGSMISendCapsInfo(PHGSMIGUESTCOMMANDCONTEXT pCtx,
210 uint32_t fCaps)
211{
212 VBVACAPS *pCaps;
213 int rc = VINF_SUCCESS;
214
215 /* Allocate the IO buffer. */
216 pCaps = (VBVACAPS *)VBoxHGSMIBufferAlloc(pCtx,
217 sizeof(VBVACAPS), HGSMI_CH_VBVA,
218 VBVA_INFO_CAPS);
219
220 if (pCaps)
221 {
222 /* Prepare data to be sent to the host. */
223 pCaps->rc = VERR_NOT_IMPLEMENTED;
224 pCaps->fCaps = fCaps;
225 rc = VBoxHGSMIBufferSubmit(pCtx, pCaps);
226 if (RT_SUCCESS(rc))
227 {
228 AssertRC(pCaps->rc);
229 rc = pCaps->rc;
230 }
231 /* Free the IO buffer. */
232 VBoxHGSMIBufferFree(pCtx, pCaps);
233 }
234 else
235 rc = VERR_NO_MEMORY;
236 return rc;
237}
238
239
240/** Tell the host about the location of the area of VRAM set aside for the host
241 * heap. */
242static int vboxHGSMIReportHostArea(PHGSMIGUESTCOMMANDCONTEXT pCtx,
243 uint32_t u32AreaOffset, uint32_t u32AreaSize)
244{
245 VBVAINFOHEAP *p;
246 int rc = VINF_SUCCESS;
247
248 /* Allocate the IO buffer. */
249 p = (VBVAINFOHEAP *)VBoxHGSMIBufferAlloc(pCtx,
250 sizeof (VBVAINFOHEAP), HGSMI_CH_VBVA,
251 VBVA_INFO_HEAP);
252 if (p)
253 {
254 /* Prepare data to be sent to the host. */
255 p->u32HeapOffset = u32AreaOffset;
256 p->u32HeapSize = u32AreaSize;
257 rc = VBoxHGSMIBufferSubmit(pCtx, p);
258 /* Free the IO buffer. */
259 VBoxHGSMIBufferFree(pCtx, p);
260 }
261 else
262 rc = VERR_NO_MEMORY;
263 return rc;
264}
265
266
267/**
268 * Get the information needed to map the basic communication structures in
269 * device memory into our address space. All pointer parameters are optional.
270 *
271 * @param cbVRAM how much video RAM is allocated to the device
272 * @param poffVRAMBaseMapping where to save the offset from the start of the
273 * device VRAM of the whole area to map
274 * @param pcbMapping where to save the mapping size
275 * @param poffGuestHeapMemory where to save the offset into the mapped area
276 * of the guest heap backing memory
277 * @param pcbGuestHeapMemory where to save the size of the guest heap
278 * backing memory
279 * @param poffHostFlags where to save the offset into the mapped area
280 * of the host flags
281 */
282RTDECL(void) VBoxHGSMIGetBaseMappingInfo(uint32_t cbVRAM,
283 uint32_t *poffVRAMBaseMapping,
284 uint32_t *pcbMapping,
285 uint32_t *poffGuestHeapMemory,
286 uint32_t *pcbGuestHeapMemory,
287 uint32_t *poffHostFlags)
288{
289 AssertPtrNullReturnVoid(poffVRAMBaseMapping);
290 AssertPtrNullReturnVoid(pcbMapping);
291 AssertPtrNullReturnVoid(poffGuestHeapMemory);
292 AssertPtrNullReturnVoid(pcbGuestHeapMemory);
293 AssertPtrNullReturnVoid(poffHostFlags);
294 if (poffVRAMBaseMapping)
295 *poffVRAMBaseMapping = cbVRAM - VBVA_ADAPTER_INFORMATION_SIZE;
296 if (pcbMapping)
297 *pcbMapping = VBVA_ADAPTER_INFORMATION_SIZE;
298 if (poffGuestHeapMemory)
299 *poffGuestHeapMemory = 0;
300 if (pcbGuestHeapMemory)
301 *pcbGuestHeapMemory = VBVA_ADAPTER_INFORMATION_SIZE
302 - sizeof(HGSMIHOSTFLAGS);
303 if (poffHostFlags)
304 *poffHostFlags = VBVA_ADAPTER_INFORMATION_SIZE
305 - sizeof(HGSMIHOSTFLAGS);
306}
307
308
309/**
310 * Set up the HGSMI guest-to-host command context.
311 * @returns iprt status value
312 * @param pCtx the context to set up
313 * @param pvGuestHeapMemory a pointer to the mapped backing memory for
314 * the guest heap
315 * @param cbGuestHeapMemory the size of the backing memory area
316 * @param offVRAMGuestHeapMemory the offset of the memory pointed to by
317 * @a pvGuestHeapMemory within the video RAM
318 */
319RTDECL(int) VBoxHGSMISetupGuestContext(PHGSMIGUESTCOMMANDCONTEXT pCtx,
320 void *pvGuestHeapMemory,
321 uint32_t cbGuestHeapMemory,
322 uint32_t offVRAMGuestHeapMemory)
323{
324 /** @todo should we be using a fixed ISA port value here? */
325 pCtx->port = (RTIOPORT)VGA_PORT_HGSMI_GUEST;
326#ifdef VBOX_WDDM_MINIPORT
327 return VBoxSHGSMIInit(&pCtx->heapCtx, pvGuestHeapMemory,
328 cbGuestHeapMemory, offVRAMGuestHeapMemory,
329 false /*fOffsetBased*/);
330#else
331 return HGSMIHeapSetup(&pCtx->heapCtx, pvGuestHeapMemory,
332 cbGuestHeapMemory, offVRAMGuestHeapMemory,
333 false /*fOffsetBased*/);
334#endif
335}
336
337
338/**
339 * Get the information needed to map the area used by the host to send back
340 * requests.
341 *
342 * @param pCtx the context containing the heap to use
343 * @param cbVRAM how much video RAM is allocated to the device
344 * @param offVRAMBaseMapping the offset of the basic communication structures
345 * into the guest's VRAM
346 * @param poffVRAMHostArea where to store the offset into VRAM of the host
347 * heap area
348 * @param pcbHostArea where to store the size of the host heap area
349 */
350RTDECL(void) VBoxHGSMIGetHostAreaMapping(PHGSMIGUESTCOMMANDCONTEXT pCtx,
351 uint32_t cbVRAM,
352 uint32_t offVRAMBaseMapping,
353 uint32_t *poffVRAMHostArea,
354 uint32_t *pcbHostArea)
355{
356 uint32_t offVRAMHostArea = offVRAMBaseMapping, cbHostArea = 0;
357
358 AssertPtrReturnVoid(poffVRAMHostArea);
359 AssertPtrReturnVoid(pcbHostArea);
360 VBoxQueryConfHGSMI(pCtx, VBOX_VBVA_CONF32_HOST_HEAP_SIZE, &cbHostArea);
361 if (cbHostArea != 0)
362 {
363 uint32_t cbHostAreaMaxSize = cbVRAM / 4;
364 /** @todo what is the idea of this? */
365 if (cbHostAreaMaxSize >= VBVA_ADAPTER_INFORMATION_SIZE)
366 {
367 cbHostAreaMaxSize -= VBVA_ADAPTER_INFORMATION_SIZE;
368 }
369 if (cbHostArea > cbHostAreaMaxSize)
370 {
371 cbHostArea = cbHostAreaMaxSize;
372 }
373 /* Round up to 4096 bytes. */
374 cbHostArea = (cbHostArea + 0xFFF) & ~0xFFF;
375 offVRAMHostArea = offVRAMBaseMapping - cbHostArea;
376 }
377
378 *pcbHostArea = cbHostArea;
379 *poffVRAMHostArea = offVRAMHostArea;
380 LogFunc(("offVRAMHostArea = 0x%08X, cbHostArea = 0x%08X\n",
381 offVRAMHostArea, cbHostArea));
382}
383
384
385/**
386 * Initialise the host context structure.
387 *
388 * @param pCtx the context structure to initialise
389 * @param pvBaseMapping where the basic HGSMI structures are mapped at
390 * @param offHostFlags the offset of the host flags into the basic HGSMI
391 * structures
392 * @param pvHostAreaMapping where the area for the host heap is mapped at
393 * @param offVRAMHostArea offset of the host heap area into VRAM
394 * @param cbHostArea size in bytes of the host heap area
395 */
396RTDECL(void) VBoxHGSMISetupHostContext(PHGSMIHOSTCOMMANDCONTEXT pCtx,
397 void *pvBaseMapping,
398 uint32_t offHostFlags,
399 void *pvHostAreaMapping,
400 uint32_t offVRAMHostArea,
401 uint32_t cbHostArea)
402{
403 uint8_t *pu8HostFlags = ((uint8_t *)pvBaseMapping) + offHostFlags;
404 pCtx->pfHostFlags = (HGSMIHOSTFLAGS *)pu8HostFlags;
405 /** @todo should we really be using a fixed ISA port value here? */
406 pCtx->port = (RTIOPORT)VGA_PORT_HGSMI_HOST;
407 HGSMIAreaInitialize(&pCtx->areaCtx, pvHostAreaMapping, cbHostArea,
408 offVRAMHostArea);
409}
410
411
412/**
413 * Tell the host about the ways it can use to communicate back to us via an
414 * HGSMI command
415 *
416 * @returns iprt status value
417 * @param pCtx the context containing the heap to use
418 * @param offVRAMFlagsLocation where we wish the host to place its flags
419 * relative to the start of the VRAM
420 * @param fCaps additions HGSMI capabilities the guest
421 * supports
422 * @param offVRAMHostArea offset into VRAM of the host heap area
423 * @param cbHostArea size in bytes of the host heap area
424 */
425RTDECL(int) VBoxHGSMISendHostCtxInfo(PHGSMIGUESTCOMMANDCONTEXT pCtx,
426 HGSMIOFFSET offVRAMFlagsLocation,
427 uint32_t fCaps,
428 uint32_t offVRAMHostArea,
429 uint32_t cbHostArea)
430{
431 Log(("VBoxVideo::vboxSetupAdapterInfo\n"));
432
433 /* setup the flags first to ensure they are initialized by the time the
434 * host heap is ready */
435 int rc = vboxHGSMIReportFlagsLocation(pCtx, offVRAMFlagsLocation);
436 AssertRC(rc);
437 if (RT_SUCCESS(rc) && fCaps)
438 {
439 /* Inform about caps */
440 rc = vboxHGSMISendCapsInfo(pCtx, fCaps);
441 AssertRC(rc);
442 }
443 if (RT_SUCCESS (rc))
444 {
445 /* Report the host heap location. */
446 rc = vboxHGSMIReportHostArea(pCtx, offVRAMHostArea, cbHostArea);
447 AssertRC(rc);
448 }
449 Log(("VBoxVideo::vboxSetupAdapterInfo finished rc = %d\n", rc));
450 return rc;
451}
452
453
454/**
455 * Query the host for an HGSMI configuration parameter via an HGSMI command.
456 * @returns iprt status value
457 * @param pCtx the context containing the heap used
458 * @param u32Index the index of the parameter to query,
459 * @see VBVACONF32::u32Index
460 * @param pulValue where to store the value of the parameter on success
461 */
462RTDECL(int) VBoxQueryConfHGSMI(PHGSMIGUESTCOMMANDCONTEXT pCtx,
463 uint32_t u32Index, uint32_t *pulValue)
464{
465 int rc = VINF_SUCCESS;
466 VBVACONF32 *p;
467 LogFunc(("u32Index = %d\n", u32Index));
468
469 /* Allocate the IO buffer. */
470 p = (VBVACONF32 *)VBoxHGSMIBufferAlloc(pCtx,
471 sizeof(VBVACONF32), HGSMI_CH_VBVA,
472 VBVA_QUERY_CONF32);
473 if (p)
474 {
475 /* Prepare data to be sent to the host. */
476 p->u32Index = u32Index;
477 p->u32Value = 0;
478 rc = VBoxHGSMIBufferSubmit(pCtx, p);
479 if (RT_SUCCESS(rc))
480 {
481 *pulValue = p->u32Value;
482 LogFunc(("u32Value = %d\n", p->u32Value));
483 }
484 /* Free the IO buffer. */
485 VBoxHGSMIBufferFree(pCtx, p);
486 }
487 else
488 rc = VERR_NO_MEMORY;
489 LogFunc(("rc = %d\n", rc));
490 return rc;
491}
492
493
494/**
495 * Pass the host a new mouse pointer shape via an HGSMI command.
496 *
497 * @returns success or failure
498 * @todo why not return an iprt status code?
499 * @param fFlags cursor flags, @see VMMDevReqMousePointer::fFlags
500 * @param cHotX horizontal position of the hot spot
501 * @param cHotY vertical position of the hot spot
502 * @param cWidth width in pixels of the cursor
503 * @param cHeight height in pixels of the cursor
504 * @param pPixels pixel data, @see VMMDevReqMousePointer for the format
505 * @param cbLength size in bytes of the pixel data
506 */
507RTDECL(bool) VBoxHGSMIUpdatePointerShape(PHGSMIGUESTCOMMANDCONTEXT pCtx,
508 uint32_t fFlags,
509 uint32_t cHotX,
510 uint32_t cHotY,
511 uint32_t cWidth,
512 uint32_t cHeight,
513 uint8_t *pPixels,
514 uint32_t cbLength)
515{
516 VBVAMOUSEPOINTERSHAPE *p;
517 uint32_t cbData = 0;
518 int rc = VINF_SUCCESS;
519
520 if (fFlags & VBOX_MOUSE_POINTER_SHAPE)
521 {
522 /* Size of the pointer data: sizeof (AND mask) + sizeof (XOR_MASK) */
523 cbData = ((((cWidth + 7) / 8) * cHeight + 3) & ~3)
524 + cWidth * 4 * cHeight;
525 /* If shape is supplied, then always create the pointer visible.
526 * See comments in 'vboxUpdatePointerShape'
527 */
528 fFlags |= VBOX_MOUSE_POINTER_VISIBLE;
529 }
530 LogFlowFunc(("cbData %d, %dx%d\n", cbData, cWidth, cHeight));
531 if (cbData > cbLength)
532 {
533 LogFunc(("calculated pointer data size is too big (%d bytes, limit %d)\n",
534 cbData, cbLength));
535 return false;
536 }
537 /* Allocate the IO buffer. */
538 p = (VBVAMOUSEPOINTERSHAPE *)VBoxHGSMIBufferAlloc(pCtx,
539 sizeof(VBVAMOUSEPOINTERSHAPE)
540 + cbData,
541 HGSMI_CH_VBVA,
542 VBVA_MOUSE_POINTER_SHAPE);
543 if (p)
544 {
545 /* Prepare data to be sent to the host. */
546 /* Will be updated by the host. */
547 p->i32Result = VINF_SUCCESS;
548 /* We have our custom flags in the field */
549 p->fu32Flags = fFlags;
550 p->u32HotX = cHotX;
551 p->u32HotY = cHotY;
552 p->u32Width = cWidth;
553 p->u32Height = cHeight;
554 if (p->fu32Flags & VBOX_MOUSE_POINTER_SHAPE)
555 /* Copy the actual pointer data. */
556 memcpy (p->au8Data, pPixels, cbData);
557 rc = VBoxHGSMIBufferSubmit(pCtx, p);
558 if (RT_SUCCESS(rc))
559 rc = p->i32Result;
560 /* Free the IO buffer. */
561 VBoxHGSMIBufferFree(pCtx, p);
562 }
563 else
564 rc = VERR_NO_MEMORY;
565 LogFlowFunc(("rc %d\n", rc));
566 return RT_SUCCESS(rc);
567}
568
569
570/** @todo Mouse pointer position to be read from VMMDev memory, address of the memory region
571 * can be queried from VMMDev via an IOCTL. This VMMDev memory region will contain
572 * host information which is needed by the guest.
573 *
574 * Reading will not cause a switch to the host.
575 *
576 * Have to take into account:
577 * * synchronization: host must write to the memory only from EMT,
578 * large structures must be read under flag, which tells the host
579 * that the guest is currently reading the memory (OWNER flag?).
580 * * guest writes: may be allocate a page for the host info and make
581 * the page readonly for the guest.
582 * * the information should be available only for additions drivers.
583 * * VMMDev additions driver will inform the host which version of the info it expects,
584 * host must support all versions.
585 *
586 */
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette