VirtualBox

source: vbox/trunk/src/VBox/Devices/Graphics/HGSMI/HGSMIHost.cpp@ 55384

Last change on this file since 55384 was 55342, checked in by vboxsync, 10 years ago

HGSMI: cleanup, comments.
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 47.4 KB
Line 
1/** @file
2 *
3 * VBox Host Guest Shared Memory Interface (HGSMI).
4 * Host part:
5 * - virtual hardware IO handlers;
6 * - channel management;
7 * - low level interface for buffer transfer.
8 */
9
10/*
11 * Copyright (C) 2006-2015 Oracle Corporation
12 *
13 * This file is part of VirtualBox Open Source Edition (OSE), as
14 * available from http://www.virtualbox.org. This file is free software;
15 * you can redistribute it and/or modify it under the terms of the GNU
16 * General Public License (GPL) as published by the Free Software
17 * Foundation, in version 2 as it comes in the "COPYING" file of the
18 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
19 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
20 */
21
22
23/*
24 * Async host->guest calls. Completion by an IO write from the guest or a timer timeout.
25 *
26 * Sync guest->host calls. Initiated by an IO write from the guest.
27 *
28 * Guest->Host
29 * ___________
30 *
31 * Synchronous for the guest, an async result can be also reported later by a host->guest call:
32 *
33 * G: Alloc shared memory, fill the structure, issue an IO write (HGSMI_IO_GUEST) with the memory offset.
34 * H: Verify the shared memory and call the handler.
35 * G: Continue after the IO completion.
36 *
37 *
38 * Host->Guest
39 * __________
40 *
41 * H: Alloc shared memory, fill in the info.
42 * Register in the FIFO with a callback, issue IRQ (on EMT).
43 * Wait on a sem with timeout if necessary.
44 * G: Read FIFO from HGSMI_IO_HOST_COMMAND.
45 * H(EMT): Get the shared memory offset from FIFO to return to the guest.
46 * G: Get offset, process command, issue IO write to HGSMI_IO_HOST_COMMAND.
47 * H(EMT): Find registered shared mem, run callback, which could post the sem.
48 * H: Get results and free shared mem (could be freed automatically on EMT too).
49 *
50 *
51 * Implementation notes:
52 *
53 * Host->Guest
54 *
55 * * Shared memory allocation using a critsect.
56 * * FIFO manipulation with a critsect.
57 *
58 */
59
60#include <iprt/alloc.h>
61#include <iprt/critsect.h>
62#include <iprt/heap.h>
63#include <iprt/list.h>
64#include <iprt/semaphore.h>
65#include <iprt/string.h>
66
67#include <VBox/err.h>
68#define LOG_GROUP LOG_GROUP_DEV_VGA
69#include <VBox/log.h>
70#include <VBox/vmm/ssm.h>
71
72#include "HGSMIHost.h"
73#include <VBox/HGSMI/HGSMIChannels.h>
74#include <VBox/HGSMI/HGSMIChSetup.h>
75
76#include "../DevVGASavedState.h"
77
78#ifdef DEBUG_sunlover
79#define HGSMI_STRICT 1
80#endif /* !DEBUG_sunlover */
81
82#ifdef DEBUG_misha
83//# define VBOXHGSMI_STATE_DEBUG
84#endif
85
86#ifdef VBOXHGSMI_STATE_DEBUG
87#define VBOXHGSMI_STATE_START_MAGIC 0x12345678
88#define VBOXHGSMI_STATE_STOP_MAGIC 0x87654321
89#define VBOXHGSMI_STATE_FIFOSTART_MAGIC 0x9abcdef1
90#define VBOXHGSMI_STATE_FIFOSTOP_MAGIC 0x1fedcba9
91
92#define VBOXHGSMI_SAVE_START(_pSSM) do{ int rc2 = SSMR3PutU32(_pSSM, VBOXHGSMI_STATE_START_MAGIC); AssertRC(rc2);}while(0)
93#define VBOXHGSMI_SAVE_STOP(_pSSM) do{ int rc2 = SSMR3PutU32(_pSSM, VBOXHGSMI_STATE_STOP_MAGIC); AssertRC(rc2);}while(0)
94#define VBOXHGSMI_SAVE_FIFOSTART(_pSSM) do{ int rc2 = SSMR3PutU32(_pSSM, VBOXHGSMI_STATE_FIFOSTART_MAGIC); AssertRC(rc2);}while(0)
95#define VBOXHGSMI_SAVE_FIFOSTOP(_pSSM) do{ int rc2 = SSMR3PutU32(_pSSM, VBOXHGSMI_STATE_FIFOSTOP_MAGIC); AssertRC(rc2);}while(0)
96
97#define VBOXHGSMI_LOAD_CHECK(_pSSM, _v) \
98 do{ \
99 uint32_t u32; \
100 int rc2 = SSMR3GetU32(_pSSM, &u32); AssertRC(rc2); \
101 Assert(u32 == (_v)); \
102 }while(0)
103
104#define VBOXHGSMI_LOAD_START(_pSSM) VBOXHGSMI_LOAD_CHECK(_pSSM, VBOXHGSMI_STATE_START_MAGIC)
105#define VBOXHGSMI_LOAD_FIFOSTART(_pSSM) VBOXHGSMI_LOAD_CHECK(_pSSM, VBOXHGSMI_STATE_FIFOSTART_MAGIC)
106#define VBOXHGSMI_LOAD_FIFOSTOP(_pSSM) VBOXHGSMI_LOAD_CHECK(_pSSM, VBOXHGSMI_STATE_FIFOSTOP_MAGIC)
107#define VBOXHGSMI_LOAD_STOP(_pSSM) VBOXHGSMI_LOAD_CHECK(_pSSM, VBOXHGSMI_STATE_STOP_MAGIC)
108#else
109#define VBOXHGSMI_SAVE_START(_pSSM) do{ }while(0)
110#define VBOXHGSMI_SAVE_STOP(_pSSM) do{ }while(0)
111#define VBOXHGSMI_SAVE_FIFOSTART(_pSSM) do{ }while(0)
112#define VBOXHGSMI_SAVE_FIFOSTOP(_pSSM) do{ }while(0)
113
114
115#define VBOXHGSMI_LOAD_START(_pSSM) do{ }while(0)
116#define VBOXHGSMI_LOAD_FIFOSTART(_pSSM) do{ }while(0)
117#define VBOXHGSMI_LOAD_FIFOSTOP(_pSSM) do{ }while(0)
118#define VBOXHGSMI_LOAD_STOP(_pSSM) do{ }while(0)
119
120#endif
121
122/* Assertions for situations which could happen and normally must be processed properly
123 * but must be investigated during development: guest misbehaving, etc.
124 */
125#ifdef HGSMI_STRICT
126#define HGSMI_STRICT_ASSERT_FAILED() AssertFailed()
127#define HGSMI_STRICT_ASSERT(expr) Assert(expr)
128#else
129#define HGSMI_STRICT_ASSERT_FAILED() do {} while (0)
130#define HGSMI_STRICT_ASSERT(expr) do {} while (0)
131#endif /* !HGSMI_STRICT */
132
133
134typedef struct HGSMIINSTANCE
135{
136 PVM pVM; /* The VM. */
137
138 const char *pszName; /* A name for the instance. Mostyl used in the log. */
139
140 RTCRITSECT instanceCritSect; /* For updating the instance data: FIFO's, channels. */
141
142 HGSMIAREA area; /* The shared memory description. */
143 HGSMIHEAP hostHeap; /* Host heap instance. */
144 RTCRITSECT hostHeapCritSect; /* Heap serialization lock. */
145
146 RTLISTANCHOR hostFIFO; /* Pending host buffers. */
147 RTLISTANCHOR hostFIFORead; /* Host buffers read by the guest. */
148 RTLISTANCHOR hostFIFOProcessed; /* Processed by the guest. */
149 RTLISTANCHOR hostFIFOFree; /* Buffers for reuse. */
150#ifdef VBOX_WITH_WDDM
151 RTLISTANCHOR guestCmdCompleted; /* list of completed guest commands to be returned to the guest*/
152#endif
153 RTCRITSECT hostFIFOCritSect; /* FIFO serialization lock. */
154
155 PFNHGSMINOTIFYGUEST pfnNotifyGuest; /* Guest notification callback. */
156 void *pvNotifyGuest; /* Guest notification callback context. */
157
158 volatile HGSMIHOSTFLAGS *pHGFlags;
159
160 HGSMICHANNELINFO channelInfo; /* Channel handlers indexed by the channel id.
161 * The array is accessed under the instance lock.
162 */
163} HGSMIINSTANCE;
164
165
166typedef DECLCALLBACK(void) FNHGSMIHOSTFIFOCALLBACK(void *pvCallback);
167typedef FNHGSMIHOSTFIFOCALLBACK *PFNHGSMIHOSTFIFOCALLBACK;
168
169typedef struct HGSMIHOSTFIFOENTRY
170{
171 RTLISTNODE nodeEntry;
172
173 HGSMIINSTANCE *pIns; /* Backlink to the HGSMI instance. */
174
175#if 0
176 /* removed to allow saved state handling */
177 /* The event which is signalled when the command has been processed by the host. */
178 RTSEMEVENTMULTI hEvent;
179#endif
180
181 volatile uint32_t fl; /* Status flags of the entry. */
182
183 HGSMIOFFSET offBuffer; /* Offset in the memory region of the entry data. */
184
185#if 0
186 /* removed to allow saved state handling */
187 /* The command completion callback. */
188 PFNHGSMIHOSTFIFOCALLBACK pfnCallback;
189 void *pvCallback;
190#endif
191
192} HGSMIHOSTFIFOENTRY;
193
194
195#define HGSMI_F_HOST_FIFO_ALLOCATED 0x0001
196#define HGSMI_F_HOST_FIFO_QUEUED 0x0002
197#define HGSMI_F_HOST_FIFO_READ 0x0004
198#define HGSMI_F_HOST_FIFO_PROCESSED 0x0008
199#define HGSMI_F_HOST_FIFO_FREE 0x0010
200#define HGSMI_F_HOST_FIFO_CANCELED 0x0020
201
202static DECLCALLBACK(void) hgsmiHostCommandFreeCallback (void *pvCallback);
203
204#ifdef VBOX_WITH_WDDM
205
206typedef struct HGSMIGUESTCOMPLENTRY
207{
208 RTLISTNODE nodeEntry;
209 HGSMIOFFSET offBuffer; /* Offset of the guest command buffer. */
210} HGSMIGUESTCOMPLENTRY;
211
212
213static void hgsmiGuestCompletionFIFOFree (HGSMIINSTANCE *pIns, HGSMIGUESTCOMPLENTRY *pEntry)
214{
215 NOREF (pIns);
216 RTMemFree (pEntry);
217}
218
219static int hgsmiGuestCompletionFIFOAlloc (HGSMIINSTANCE *pIns, HGSMIGUESTCOMPLENTRY **ppEntry)
220{
221 int rc = VINF_SUCCESS;
222
223 NOREF (pIns);
224
225 HGSMIGUESTCOMPLENTRY *pEntry = (HGSMIGUESTCOMPLENTRY *)RTMemAllocZ (sizeof (HGSMIGUESTCOMPLENTRY));
226
227 if (pEntry)
228 *ppEntry = pEntry;
229 else
230 rc = VERR_NO_MEMORY;
231
232 return rc;
233}
234
235#endif
236
237static int hgsmiLock (HGSMIINSTANCE *pIns)
238{
239 int rc = RTCritSectEnter (&pIns->instanceCritSect);
240 AssertRC (rc);
241 return rc;
242}
243
244static void hgsmiUnlock (HGSMIINSTANCE *pIns)
245{
246 int rc = RTCritSectLeave (&pIns->instanceCritSect);
247 AssertRC (rc);
248}
249
250static int hgsmiFIFOLock (HGSMIINSTANCE *pIns)
251{
252 int rc = RTCritSectEnter (&pIns->hostFIFOCritSect);
253 AssertRC (rc);
254 return rc;
255}
256
257static void hgsmiFIFOUnlock (HGSMIINSTANCE *pIns)
258{
259 int rc = RTCritSectLeave (&pIns->hostFIFOCritSect);
260 AssertRC (rc);
261}
262
263/*
264 * Virtual hardware IO handlers.
265 */
266
267/* The guest submits a new buffer to the host.
268 * Called from the HGSMI_IO_GUEST write handler.
269 * @thread EMT
270 */
271void HGSMIGuestWrite (PHGSMIINSTANCE pIns,
272 HGSMIOFFSET offBuffer)
273{
274 HGSMIBufferProcess (&pIns->area, &pIns->channelInfo, offBuffer);
275}
276
277#ifdef VBOX_WITH_WDDM
278static HGSMIOFFSET hgsmiProcessGuestCmdCompletion(HGSMIINSTANCE *pIns)
279{
280 HGSMIOFFSET offCmd = HGSMIOFFSET_VOID;
281 int rc = hgsmiFIFOLock(pIns);
282 AssertRC(rc);
283 if (RT_SUCCESS(rc))
284 {
285 HGSMIGUESTCOMPLENTRY *pEntry = RTListGetFirst(&pIns->guestCmdCompleted, HGSMIGUESTCOMPLENTRY, nodeEntry);
286 if (pEntry)
287 {
288 RTListNodeRemove(&pEntry->nodeEntry);
289 }
290
291 if (RTListIsEmpty(&pIns->guestCmdCompleted))
292 {
293 if(pIns->pHGFlags)
294 {
295 ASMAtomicAndU32(&pIns->pHGFlags->u32HostFlags, ~HGSMIHOSTFLAGS_GCOMMAND_COMPLETED);
296 }
297 }
298
299 hgsmiFIFOUnlock(pIns);
300
301 if (pEntry)
302 {
303 offCmd = pEntry->offBuffer;
304
305 LogFlowFunc(("host FIFO head %p.\n", pEntry));
306
307 hgsmiGuestCompletionFIFOFree(pIns, pEntry);
308 }
309 }
310 return offCmd;
311}
312#endif
313
314
315/* Called from HGSMI_IO_GUEST read handler. */
316HGSMIOFFSET HGSMIGuestRead (PHGSMIINSTANCE pIns)
317{
318 LogFlowFunc(("pIns %p\n", pIns));
319
320 AssertPtr(pIns);
321
322 VM_ASSERT_EMT(pIns->pVM);
323
324#ifndef VBOX_WITH_WDDM
325 /* Currently there is no functionality here. */
326 NOREF(pIns);
327
328 return HGSMIOFFSET_VOID;
329#else
330 /* use this to speedup guest cmd completion
331 * this mechanism is alternative to submitting H->G command for notification */
332 HGSMIOFFSET offCmd = hgsmiProcessGuestCmdCompletion(pIns);
333 return offCmd;
334#endif
335}
336
337static bool hgsmiProcessHostCmdCompletion(HGSMIINSTANCE *pIns,
338 HGSMIOFFSET offBuffer,
339 bool bCompleteFirst)
340{
341 VM_ASSERT_EMT(pIns->pVM);
342
343 int rc = hgsmiFIFOLock(pIns);
344 if(RT_SUCCESS(rc))
345 {
346 /* Search the Read list for the given buffer offset. */
347 HGSMIHOSTFIFOENTRY *pEntry = NULL;
348
349 HGSMIHOSTFIFOENTRY *pIter;
350 RTListForEach(&pIns->hostFIFORead, pIter, HGSMIHOSTFIFOENTRY, nodeEntry)
351 {
352 Assert(pIter->fl == (HGSMI_F_HOST_FIFO_ALLOCATED | HGSMI_F_HOST_FIFO_READ));
353 if (bCompleteFirst || pIter->offBuffer == offBuffer)
354 {
355 pEntry = pIter;
356 break;
357 }
358 }
359
360 LogFlowFunc(("read list entry: %p.\n", pEntry));
361
362 Assert(pEntry || bCompleteFirst);
363
364 if (pEntry)
365 {
366 RTListNodeRemove(&pEntry->nodeEntry);
367
368 pEntry->fl &= ~HGSMI_F_HOST_FIFO_READ;
369 pEntry->fl |= HGSMI_F_HOST_FIFO_PROCESSED;
370
371 RTListAppend(&pIns->hostFIFOProcessed, &pEntry->nodeEntry);
372
373 hgsmiFIFOUnlock(pIns);
374#if 0
375 /* Inform the submitter. */
376 if (pEntry->pfnCallback)
377 {
378 pEntry->pfnCallback (pEntry->pvCallback);
379 }
380#else
381 hgsmiHostCommandFreeCallback(pEntry);
382#endif
383 return true;
384 }
385
386 hgsmiFIFOUnlock(pIns);
387 if(!bCompleteFirst)
388 LogRel(("HGSMI[%s]: ignored invalid write to the host FIFO: 0x%08X!!!\n", pIns->pszName, offBuffer));
389 }
390 return false;
391}
392
393/* The guest has finished processing of a buffer previously submitted by the host.
394 * Called from HGSMI_IO_HOST write handler.
395 * @thread EMT
396 */
397void HGSMIHostWrite (HGSMIINSTANCE *pIns,
398 HGSMIOFFSET offBuffer)
399{
400 LogFlowFunc(("pIns %p offBuffer 0x%x\n", pIns, offBuffer));
401
402 hgsmiProcessHostCmdCompletion (pIns, offBuffer, false);
403}
404
405/* The guest reads a new host buffer to be processed.
406 * Called from the HGSMI_IO_HOST read handler.
407 * @thread EMT
408 */
409HGSMIOFFSET HGSMIHostRead (HGSMIINSTANCE *pIns)
410{
411 LogFlowFunc(("pIns %p\n", pIns));
412
413 VM_ASSERT_EMT(pIns->pVM);
414
415 AssertPtrReturn(pIns->pHGFlags, VERR_WRONG_ORDER);
416 int rc = hgsmiFIFOLock(pIns);
417 AssertRC(rc);
418 if(RT_SUCCESS(rc))
419 {
420 /* Get the host FIFO head entry. */
421 HGSMIHOSTFIFOENTRY *pEntry = RTListGetFirst(&pIns->hostFIFO, HGSMIHOSTFIFOENTRY, nodeEntry);
422
423 LogFlowFunc(("host FIFO head %p.\n", pEntry));
424
425 if (pEntry != NULL)
426 {
427 Assert(pEntry->fl == (HGSMI_F_HOST_FIFO_ALLOCATED | HGSMI_F_HOST_FIFO_QUEUED));
428
429 /*
430 * Move the entry to the Read list.
431 */
432 RTListNodeRemove(&pEntry->nodeEntry);
433
434 if (RTListIsEmpty(&pIns->hostFIFO))
435 {
436 ASMAtomicAndU32(&pIns->pHGFlags->u32HostFlags, (~HGSMIHOSTFLAGS_COMMANDS_PENDING));
437 }
438
439 pEntry->fl &= ~HGSMI_F_HOST_FIFO_QUEUED;
440 pEntry->fl |= HGSMI_F_HOST_FIFO_READ;
441
442 RTListAppend(&pIns->hostFIFORead, &pEntry->nodeEntry);
443
444 hgsmiFIFOUnlock(pIns);
445
446 /* Return the buffer offset of the host FIFO head. */
447 return pEntry->offBuffer;
448 }
449 hgsmiFIFOUnlock(pIns);
450 }
451 /* Special value that means there is no host buffers to be processed. */
452 return HGSMIOFFSET_VOID;
453}
454
455
456/* Tells the guest that a new buffer to be processed is available from the host. */
457static void hgsmiNotifyGuest (HGSMIINSTANCE *pIns)
458{
459 if (pIns->pfnNotifyGuest)
460 {
461 pIns->pfnNotifyGuest (pIns->pvNotifyGuest);
462 }
463}
464
465void HGSMISetHostGuestFlags(HGSMIINSTANCE *pIns, uint32_t flags)
466{
467 AssertPtrReturnVoid(pIns->pHGFlags);
468 ASMAtomicOrU32(&pIns->pHGFlags->u32HostFlags, flags);
469}
470
471void HGSMIClearHostGuestFlags(HGSMIINSTANCE *pIns, uint32_t flags)
472{
473 AssertPtrReturnVoid(pIns->pHGFlags);
474 ASMAtomicAndU32(&pIns->pHGFlags->u32HostFlags, (~flags));
475}
476
477#if 0
478static void hgsmiRaiseEvent (const HGSMIHOSTFIFOENTRY *pEntry)
479{
480 int rc = RTSemEventMultiSignal (pEntry->hEvent);
481 AssertRC(rc);
482}
483
484static int hgsmiWaitEvent (const HGSMIHOSTFIFOENTRY *pEntry)
485{
486 int rc = RTSemEventMultiWait (pEntry->hEvent, RT_INDEFINITE_WAIT);
487 AssertRC(rc);
488 return rc;
489}
490#endif
491
492/*
493 * The host heap.
494 *
495 * Uses the RTHeap implementation.
496 *
497 */
498static int hgsmiHostHeapLock (HGSMIINSTANCE *pIns)
499{
500 int rc = RTCritSectEnter (&pIns->hostHeapCritSect);
501 AssertRC (rc);
502 return rc;
503}
504
505static void hgsmiHostHeapUnlock (HGSMIINSTANCE *pIns)
506{
507 int rc = RTCritSectLeave (&pIns->hostHeapCritSect);
508 AssertRC (rc);
509}
510
511static int hgsmiHostFIFOAlloc (HGSMIINSTANCE *pIns, HGSMIHOSTFIFOENTRY **ppEntry)
512{
513 int rc = VINF_SUCCESS;
514
515 NOREF (pIns);
516
517 HGSMIHOSTFIFOENTRY *pEntry = (HGSMIHOSTFIFOENTRY *)RTMemAllocZ (sizeof (HGSMIHOSTFIFOENTRY));
518
519 if (pEntry)
520 {
521 pEntry->fl = HGSMI_F_HOST_FIFO_ALLOCATED;
522#if 0
523 rc = RTSemEventMultiCreate (&pEntry->hEvent);
524
525 if (RT_FAILURE (rc))
526 {
527 RTMemFree (pEntry);
528 }
529#endif
530 }
531 else
532 {
533 rc = VERR_NO_MEMORY;
534 }
535
536 if (RT_SUCCESS (rc))
537 {
538 *ppEntry = pEntry;
539 }
540
541 return rc;
542}
543
544static void hgsmiHostFIFOFree (HGSMIINSTANCE *pIns, HGSMIHOSTFIFOENTRY *pEntry)
545{
546 NOREF (pIns);
547#if 0
548 if (pEntry->hEvent)
549 {
550 RTSemEventMultiDestroy (pEntry->hEvent);
551 }
552#endif
553 RTMemFree (pEntry);
554}
555
556static int hgsmiHostCommandFreeByEntry (HGSMIHOSTFIFOENTRY *pEntry)
557{
558 HGSMIINSTANCE *pIns = pEntry->pIns;
559 int rc = hgsmiFIFOLock (pIns);
560 if(RT_SUCCESS(rc))
561 {
562 RTListNodeRemove(&pEntry->nodeEntry);
563 hgsmiFIFOUnlock (pIns);
564
565 void *pvMem = HGSMIBufferDataFromOffset(&pIns->area, pEntry->offBuffer);
566
567 rc = hgsmiHostHeapLock (pIns);
568 if(RT_SUCCESS(rc))
569 {
570 /* Deallocate the host heap memory. */
571 HGSMIHeapFree (&pIns->hostHeap, pvMem);
572
573 hgsmiHostHeapUnlock(pIns);
574 }
575
576 hgsmiHostFIFOFree (pIns, pEntry);
577 }
578 return rc;
579}
580
581static int hgsmiHostCommandFree (HGSMIINSTANCE *pIns,
582 void *pvMem)
583{
584 HGSMIOFFSET offMem = HGSMIHeapBufferOffset (&pIns->hostHeap, pvMem);
585 int rc = VINF_SUCCESS;
586 if (offMem != HGSMIOFFSET_VOID)
587 {
588 rc = hgsmiFIFOLock (pIns);
589 if(RT_SUCCESS(rc))
590 {
591 /* Search the Processed list for the given offMem. */
592 HGSMIHOSTFIFOENTRY *pEntry = NULL;
593
594 HGSMIHOSTFIFOENTRY *pIter;
595 RTListForEach(&pIns->hostFIFOProcessed, pIter, HGSMIHOSTFIFOENTRY, nodeEntry)
596 {
597 Assert(pIter->fl == (HGSMI_F_HOST_FIFO_ALLOCATED | HGSMI_F_HOST_FIFO_PROCESSED));
598
599 if (pIter->offBuffer == offMem)
600 {
601 pEntry = pIter;
602 break;
603 }
604 }
605
606 if (pEntry)
607 {
608 RTListNodeRemove(&pEntry->nodeEntry);
609 }
610 else
611 {
612 LogRel(("HGSMI[%s]: the host frees unprocessed FIFO entry: 0x%08X\n", pIns->pszName, offMem));
613 AssertFailed ();
614 }
615
616 hgsmiFIFOUnlock (pIns);
617
618 rc = hgsmiHostHeapLock (pIns);
619 if(RT_SUCCESS(rc))
620 {
621 /* Deallocate the host heap memory. */
622 HGSMIHeapFree (&pIns->hostHeap, pvMem);
623
624 hgsmiHostHeapUnlock(pIns);
625 }
626
627 if(pEntry)
628 {
629 /* Deallocate the entry. */
630 hgsmiHostFIFOFree (pIns, pEntry);
631 }
632 }
633
634 }
635 else
636 {
637 rc = VERR_INVALID_POINTER;
638 LogRel(("HGSMI[%s]: the host frees invalid FIFO entry: %p\n", pIns->pszName, pvMem));
639 AssertFailed ();
640 }
641 return rc;
642}
643
644#if 0
645static DECLCALLBACK(void) hgsmiHostCommandRaiseEventCallback (void *pvCallback)
646{
647 /* Guest has processed the command. */
648 HGSMIHOSTFIFOENTRY *pEntry = (HGSMIHOSTFIFOENTRY *)pvCallback;
649
650 Assert(pEntry->fl == (HGSMI_F_HOST_FIFO_ALLOCATED | HGSMI_F_HOST_FIFO_PROCESSED));
651
652 /* This is a simple callback, just signal the event. */
653 hgsmiRaiseEvent (pEntry);
654}
655#endif
656
657static DECLCALLBACK(void) hgsmiHostCommandFreeCallback (void *pvCallback)
658{
659 /* Guest has processed the command. */
660 HGSMIHOSTFIFOENTRY *pEntry = (HGSMIHOSTFIFOENTRY *)pvCallback;
661
662 Assert(pEntry->fl == (HGSMI_F_HOST_FIFO_ALLOCATED | HGSMI_F_HOST_FIFO_PROCESSED));
663
664 /* This is a simple callback, just signal the event. */
665 hgsmiHostCommandFreeByEntry (pEntry);
666}
667
668static int hgsmiHostCommandWrite (HGSMIINSTANCE *pIns, HGSMIOFFSET offMem
669#if 0
670 , PFNHGSMIHOSTFIFOCALLBACK pfnCallback, void **ppvContext
671#endif
672 )
673{
674 HGSMIHOSTFIFOENTRY *pEntry;
675
676 AssertPtrReturn(pIns->pHGFlags, VERR_WRONG_ORDER);
677 int rc = hgsmiHostFIFOAlloc (pIns, &pEntry);
678
679 if (RT_SUCCESS (rc))
680 {
681 /* Initialize the new entry and add it to the FIFO. */
682 pEntry->fl |= HGSMI_F_HOST_FIFO_QUEUED;
683
684 pEntry->pIns = pIns;
685 pEntry->offBuffer = offMem;
686#if 0
687 pEntry->pfnCallback = pfnCallback;
688 pEntry->pvCallback = pEntry;
689#endif
690
691 rc = hgsmiFIFOLock(pIns);
692 if (RT_SUCCESS (rc))
693 {
694 RTListAppend(&pIns->hostFIFO, &pEntry->nodeEntry);
695 ASMAtomicOrU32(&pIns->pHGFlags->u32HostFlags, HGSMIHOSTFLAGS_COMMANDS_PENDING);
696
697 hgsmiFIFOUnlock(pIns);
698#if 0
699 *ppvContext = pEntry;
700#endif
701 }
702 else
703 {
704 hgsmiHostFIFOFree(pIns, pEntry);
705 }
706 }
707
708 return rc;
709}
710
711
712/**
713 * Append the shared memory block to the FIFO, inform the guest.
714 *
715 * @param pIns Pointer to HGSMI instance,
716 * @param pv The HC memory pointer to the information.
717 * @param ppvContext Where to store a pointer, which will allow the caller
718 * to wait for the command completion.
719 * @param bDoIrq specifies whether the guest interrupt should be generated,
720 * i.e. in case the command is not urgent(e.g. some guest command completion notification that does not require post-processing)
721 * the command could be posted without raising an irq.
722 *
723 * @thread EMT
724 */
725static int hgsmiHostCommandProcess (HGSMIINSTANCE *pIns, HGSMIOFFSET offBuffer,
726#if 0
727 PFNHGSMIHOSTFIFOCALLBACK pfnCallback, void **ppvContext,
728#endif
729 bool bDoIrq)
730{
731// HGSMIOFFSET offMem;
732//
733// int rc = hgsmiCheckMemPtr (pIns, pvMem, &offMem);
734//
735// if (RT_SUCCESS (rc))
736// {
737 /* Append the command to FIFO. */
738 int rc = hgsmiHostCommandWrite (pIns, offBuffer
739#if 0
740 , pfnCallback, ppvContext
741#endif
742 );
743
744 if (RT_SUCCESS (rc))
745 {
746 if(bDoIrq)
747 {
748 /* Now guest can read the FIFO, the notification is informational. */
749 hgsmiNotifyGuest (pIns);
750 }
751 }
752// }
753// else
754// {
755// AssertFailed ();
756// }
757
758 return rc;
759}
760#if 0
761static void hgsmiWait (void *pvContext)
762{
763 HGSMIHOSTFIFOENTRY *pEntry = (HGSMIHOSTFIFOENTRY *)pvContext;
764
765 for (;;)
766 {
767 hgsmiWaitEvent (pEntry);
768
769 if (pEntry->fl & (HGSMI_F_HOST_FIFO_PROCESSED | HGSMI_F_HOST_FIFO_CANCELED))
770 {
771 return;
772 }
773 }
774}
775#endif
776/**
777 * Allocate a shared memory block. The host can write command/data to the memory.
778 *
779 * @param pIns Pointer to HGSMI instance,
780 * @param ppvMem Where to store the allocated memory pointer to data.
781 * @param cbMem How many bytes of data to allocate.
782 */
783int HGSMIHostCommandAlloc (HGSMIINSTANCE *pIns,
784 void **ppvMem,
785 HGSMISIZE cbMem,
786 uint8_t u8Channel,
787 uint16_t u16ChannelInfo)
788{
789 LogFlowFunc (("pIns = %p, cbMem = 0x%08X(%d)\n", pIns, cbMem, cbMem));
790
791 int rc = hgsmiHostHeapLock (pIns);
792 if(RT_SUCCESS(rc))
793 {
794 void *pvMem = HGSMIHeapAlloc (&pIns->hostHeap,
795 cbMem,
796 u8Channel,
797 u16ChannelInfo);
798 hgsmiHostHeapUnlock(pIns);
799
800 if (pvMem)
801 {
802 *ppvMem = pvMem;
803 }
804 else
805 {
806 LogRel((0, "HGSMIHeapAlloc: HGSMIHeapAlloc failed\n"));
807 rc = VERR_GENERAL_FAILURE;
808 }
809 }
810
811 LogFlowFunc (("rc = %Rrc, pvMem = %p\n", rc, *ppvMem));
812
813 return rc;
814}
815
816/**
817 * Convenience function that allows posting the host command asynchronously
818 * and make it freed on completion.
819 * The caller does not get notified in any way on command completion,
820 * on success return the pvMem buffer can not be used after being passed to this function
821 *
822 * @param pIns Pointer to HGSMI instance,
823 * @param pvMem The pointer returned by 'HGSMIHostCommandAlloc'.
824 * @param bDoIrq specifies whether the guest interrupt should be generated,
825 * i.e. in case the command is not urgent(e.g. some guest command completion notification that does not require post-processing)
826 * the command could be posted without raising an irq.
827 */
828int HGSMIHostCommandProcessAndFreeAsynch (PHGSMIINSTANCE pIns,
829 void *pvMem,
830 bool bDoIrq)
831{
832 LogFlowFunc(("pIns = %p, pvMem = %p\n", pIns, pvMem));
833
834#if 0
835 void *pvContext = NULL;
836#endif
837
838 HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (&pIns->hostHeap, pvMem);
839
840 int rc = hgsmiHostCommandProcess (pIns, offBuffer,
841#if 0
842 hgsmiHostCommandFreeCallback, &pvContext,
843#endif
844 bDoIrq);
845 AssertRC (rc);
846
847 LogFlowFunc(("rc = %Rrc\n", rc));
848
849 return rc;
850}
851#if 0
852/**
853 * Submit the shared memory block to the guest.
854 *
855 * @param pIns Pointer to HGSMI instance,
856 * @param pvMem The pointer returned by 'HGSMIHostCommandAlloc'.
857 */
858int HGSMIHostCommandProcess (HGSMIINSTANCE *pIns,
859 void *pvMem)
860{
861 LogFlowFunc(("pIns = %p, pvMem = %p\n", pIns, pvMem));
862
863 VM_ASSERT_OTHER_THREAD(pIns->pVM);
864
865 void *pvContext = NULL;
866
867 HGSMIOFFSET offBuffer = HGSMIHeapBufferOffset (&pIns->hostHeap, pvMem);
868
869// /* Have to forward to EMT because FIFO processing is there. */
870// int rc = VMR3ReqCallVoid (pIns->pVM, &pReq, RT_INDEFINITE_WAIT,
871// (PFNRT) hgsmiHostCommandProcess,
872// 3, pIns, offBuffer, &pvContext);
873
874 int rc = hgsmiHostCommandProcess (pIns, offBuffer,
875#if 0
876 hgsmiHostCommandRaiseEventCallback, &pvContext,
877#endif
878 true);
879 AssertReleaseRC (rc);
880
881 if (RT_SUCCESS (rc))
882 {
883 /* Wait for completion. */
884 hgsmiWait (pvContext);
885 }
886
887 LogFlowFunc(("rc = %Rrc\n", rc));
888
889 return rc;
890}
891#endif
892
893/**
894 * Free the shared memory block.
895 *
896 * @param pIns Pointer to HGSMI instance,
897 * @param pvMem The pointer returned by 'HGSMIHostCommandAlloc'.
898 */
899int HGSMIHostCommandFree (HGSMIINSTANCE *pIns,
900 void *pvMem)
901{
902 LogFlowFunc(("pIns = %p, pvMem = %p\n", pIns, pvMem));
903
904 return hgsmiHostCommandFree (pIns, pvMem);
905}
906
907static DECLCALLBACK(void *) hgsmiEnvAlloc(void *pvEnv, HGSMISIZE cb)
908{
909 NOREF(pvEnv);
910 return RTMemAlloc(cb);
911}
912
913static DECLCALLBACK(void) hgsmiEnvFree(void *pvEnv, void *pv)
914{
915 NOREF(pvEnv);
916 RTMemFree(pv);
917}
918
919static HGSMIENV g_hgsmiEnv =
920{
921 NULL,
922 hgsmiEnvAlloc,
923 hgsmiEnvFree
924};
925
926int HGSMISetupHostHeap (PHGSMIINSTANCE pIns,
927 HGSMIOFFSET offHeap,
928 HGSMISIZE cbHeap)
929{
930 LogFlowFunc(("pIns %p, offHeap 0x%08X, cbHeap = 0x%08X\n", pIns, offHeap, cbHeap));
931
932 int rc = VINF_SUCCESS;
933
934 Assert (pIns);
935
936// if ( offHeap >= pIns->cbMem
937// || cbHeap > pIns->cbMem
938// || offHeap + cbHeap > pIns->cbMem)
939// {
940// rc = VERR_INVALID_PARAMETER;
941// }
942// else
943 {
944 rc = hgsmiHostHeapLock (pIns);
945
946 if (RT_SUCCESS (rc))
947 {
948 if (pIns->hostHeap.cRefs)
949 {
950 AssertFailed();
951 /* It is possible to change the heap only if there is no pending allocations. */
952 rc = VERR_ACCESS_DENIED;
953 }
954 else
955 {
956 rc = HGSMIHeapSetup (&pIns->hostHeap,
957 HGSMI_HEAP_TYPE_MA,
958 pIns->area.pu8Base+offHeap,
959 cbHeap,
960 offHeap,
961 &g_hgsmiEnv);
962 }
963
964 hgsmiHostHeapUnlock (pIns);
965 }
966 }
967
968 LogFlowFunc(("rc = %Rrc\n", rc));
969
970 return rc;
971}
972
973static int hgsmiHostSaveFifoLocked(RTLISTANCHOR *pList, PSSMHANDLE pSSM)
974{
975 VBOXHGSMI_SAVE_FIFOSTART(pSSM);
976
977 HGSMIHOSTFIFOENTRY *pIter;
978
979 uint32_t cEntries = 0;
980 RTListForEach(pList, pIter, HGSMIHOSTFIFOENTRY, nodeEntry)
981 {
982 ++cEntries;
983 }
984
985 int rc = SSMR3PutU32(pSSM, cEntries);
986 if (RT_SUCCESS(rc))
987 {
988 RTListForEach(pList, pIter, HGSMIHOSTFIFOENTRY, nodeEntry)
989 {
990 SSMR3PutU32(pSSM, pIter->fl);
991 rc = SSMR3PutU32(pSSM, pIter->offBuffer);
992 if (RT_FAILURE(rc))
993 {
994 break;
995 }
996 }
997 }
998
999 VBOXHGSMI_SAVE_FIFOSTOP(pSSM);
1000
1001 return rc;
1002}
1003
1004static int hgsmiHostSaveGuestCmdCompletedFifoLocked(RTLISTANCHOR *pList, PSSMHANDLE pSSM)
1005{
1006 VBOXHGSMI_SAVE_FIFOSTART(pSSM);
1007
1008 HGSMIGUESTCOMPLENTRY *pIter;
1009
1010 uint32_t cEntries = 0;
1011 RTListForEach(pList, pIter, HGSMIGUESTCOMPLENTRY, nodeEntry)
1012 {
1013 ++cEntries;
1014 }
1015 int rc = SSMR3PutU32(pSSM, cEntries);
1016 if (RT_SUCCESS(rc))
1017 {
1018 RTListForEach(pList, pIter, HGSMIGUESTCOMPLENTRY, nodeEntry)
1019 {
1020 rc = SSMR3PutU32(pSSM, pIter->offBuffer);
1021 if (RT_FAILURE(rc))
1022 {
1023 break;
1024 }
1025 }
1026 }
1027
1028 VBOXHGSMI_SAVE_FIFOSTOP(pSSM);
1029
1030 return rc;
1031}
1032
1033static int hgsmiHostLoadFifoEntryLocked (PHGSMIINSTANCE pIns, HGSMIHOSTFIFOENTRY **ppEntry, PSSMHANDLE pSSM)
1034{
1035 HGSMIHOSTFIFOENTRY *pEntry;
1036 int rc = hgsmiHostFIFOAlloc (pIns, &pEntry); AssertRC(rc);
1037 if (RT_SUCCESS (rc))
1038 {
1039 uint32_t u32;
1040 pEntry->pIns = pIns;
1041 rc = SSMR3GetU32 (pSSM, &u32); AssertRC(rc);
1042 pEntry->fl = u32;
1043 rc = SSMR3GetU32 (pSSM, &pEntry->offBuffer); AssertRC(rc);
1044 if (RT_SUCCESS (rc))
1045 *ppEntry = pEntry;
1046 else
1047 hgsmiHostFIFOFree (pIns, pEntry);
1048 }
1049
1050 return rc;
1051}
1052
1053static int hgsmiHostLoadFifoLocked(PHGSMIINSTANCE pIns, RTLISTANCHOR *pList, PSSMHANDLE pSSM)
1054{
1055 VBOXHGSMI_LOAD_FIFOSTART(pSSM);
1056
1057 uint32_t cEntries = 0;
1058 int rc = SSMR3GetU32(pSSM, &cEntries);
1059 if (RT_SUCCESS(rc) && cEntries)
1060 {
1061 uint32_t i;
1062 for (i = 0; i < cEntries; ++i)
1063 {
1064 HGSMIHOSTFIFOENTRY *pEntry = NULL;
1065 rc = hgsmiHostLoadFifoEntryLocked(pIns, &pEntry, pSSM);
1066 AssertRCBreak(rc);
1067
1068 RTListAppend(pList, &pEntry->nodeEntry);
1069 }
1070 }
1071
1072 VBOXHGSMI_LOAD_FIFOSTOP(pSSM);
1073
1074 return rc;
1075}
1076
1077static int hgsmiHostLoadGuestCmdCompletedFifoEntryLocked (PHGSMIINSTANCE pIns, HGSMIGUESTCOMPLENTRY **ppEntry, PSSMHANDLE pSSM)
1078{
1079 HGSMIGUESTCOMPLENTRY *pEntry;
1080 int rc = hgsmiGuestCompletionFIFOAlloc (pIns, &pEntry); AssertRC(rc);
1081 if (RT_SUCCESS (rc))
1082 {
1083 rc = SSMR3GetU32 (pSSM, &pEntry->offBuffer); AssertRC(rc);
1084 if (RT_SUCCESS (rc))
1085 *ppEntry = pEntry;
1086 else
1087 hgsmiGuestCompletionFIFOFree (pIns, pEntry);
1088 }
1089 return rc;
1090}
1091
1092static int hgsmiHostLoadGuestCmdCompletedFifoLocked(PHGSMIINSTANCE pIns, RTLISTANCHOR *pList, PSSMHANDLE pSSM, uint32_t u32Version)
1093{
1094 VBOXHGSMI_LOAD_FIFOSTART(pSSM);
1095
1096 uint32_t i;
1097
1098 uint32_t cEntries = 0;
1099 int rc = SSMR3GetU32(pSSM, &cEntries);
1100 if (RT_SUCCESS(rc) && cEntries)
1101 {
1102 if (u32Version > VGA_SAVEDSTATE_VERSION_INV_GCMDFIFO)
1103 {
1104 for (i = 0; i < cEntries; ++i)
1105 {
1106 HGSMIGUESTCOMPLENTRY *pEntry = NULL;
1107 rc = hgsmiHostLoadGuestCmdCompletedFifoEntryLocked(pIns, &pEntry, pSSM);
1108 AssertRCBreak(rc);
1109
1110 RTListAppend(pList, &pEntry->nodeEntry);
1111 }
1112 }
1113 else
1114 {
1115 LogRel(("WARNING: the current saved state version has some 3D support data missing, "
1116 "which may lead to some guest applications function improperly"));
1117
1118 /* Just read out all invalid data and discard it. */
1119 for (i = 0; i < cEntries; ++i)
1120 {
1121 HGSMIHOSTFIFOENTRY *pEntry = NULL;
1122 rc = hgsmiHostLoadFifoEntryLocked(pIns, &pEntry, pSSM);
1123 AssertRCBreak(rc);
1124
1125 hgsmiHostFIFOFree(pIns, pEntry);
1126 }
1127 }
1128 }
1129
1130 VBOXHGSMI_LOAD_FIFOSTOP(pSSM);
1131
1132 return rc;
1133}
1134
1135static int hgsmiHostSaveMA(PSSMHANDLE pSSM, HGSMIMADATA *pMA)
1136{
1137 int rc = SSMR3PutU32(pSSM, pMA->cBlocks);
1138 if (RT_SUCCESS(rc))
1139 {
1140 HGSMIMABLOCK *pIter;
1141 RTListForEach(&pMA->listBlocks, pIter, HGSMIMABLOCK, nodeBlock)
1142 {
1143 SSMR3PutU32(pSSM, pIter->descriptor);
1144 }
1145
1146 rc = SSMR3PutU32(pSSM, pMA->cbMaxBlock);
1147 }
1148
1149 return rc;
1150}
1151
1152static int hgsmiHostLoadMA(PSSMHANDLE pSSM, uint32_t *pcBlocks, HGSMIOFFSET **ppaDescriptors, HGSMISIZE *pcbMaxBlock)
1153{
1154 int rc = SSMR3GetU32(pSSM, pcBlocks);
1155 if (RT_SUCCESS(rc))
1156 {
1157 HGSMIOFFSET *paDescriptors = NULL;
1158 if (*pcBlocks > 0)
1159 {
1160 paDescriptors = (HGSMIOFFSET *)RTMemAlloc(*pcBlocks * sizeof(HGSMIOFFSET));
1161 if (paDescriptors)
1162 {
1163 uint32_t i;
1164 for (i = 0; i < *pcBlocks; ++i)
1165 {
1166 SSMR3GetU32(pSSM, &paDescriptors[i]);
1167 }
1168 }
1169 else
1170 {
1171 rc = VERR_NO_MEMORY;
1172 }
1173 }
1174
1175 if (RT_SUCCESS(rc))
1176 {
1177 rc = SSMR3GetU32(pSSM, pcbMaxBlock);
1178 }
1179
1180 if (RT_SUCCESS(rc))
1181 {
1182 *ppaDescriptors = paDescriptors;
1183 }
1184 else
1185 {
1186 RTMemFree(paDescriptors);
1187 }
1188 }
1189
1190 return rc;
1191}
1192
1193int HGSMIHostSaveStateExec (PHGSMIINSTANCE pIns, PSSMHANDLE pSSM)
1194{
1195 VBOXHGSMI_SAVE_START(pSSM);
1196
1197 int rc;
1198
1199 SSMR3PutU32(pSSM, pIns->hostHeap.u32HeapType);
1200
1201 HGSMIOFFSET off = pIns->pHGFlags ? HGSMIPointerToOffset(&pIns->area, (const HGSMIBUFFERHEADER *)pIns->pHGFlags) : HGSMIOFFSET_VOID;
1202 SSMR3PutU32 (pSSM, off);
1203
1204 off = pIns->hostHeap.u32HeapType == HGSMI_HEAP_TYPE_MA?
1205 0:
1206 HGSMIHeapHandleLocationOffset(&pIns->hostHeap);
1207 rc = SSMR3PutU32 (pSSM, off);
1208 if(off != HGSMIOFFSET_VOID)
1209 {
1210 SSMR3PutU32 (pSSM, HGSMIHeapOffset(&pIns->hostHeap));
1211 SSMR3PutU32 (pSSM, HGSMIHeapSize(&pIns->hostHeap));
1212 /* need save mem pointer to calculate offset on restore */
1213 SSMR3PutU64 (pSSM, (uint64_t)(uintptr_t)pIns->area.pu8Base);
1214 rc = hgsmiFIFOLock (pIns);
1215 if(RT_SUCCESS(rc))
1216 {
1217 rc = hgsmiHostSaveFifoLocked (&pIns->hostFIFO, pSSM); AssertRC(rc);
1218 rc = hgsmiHostSaveFifoLocked (&pIns->hostFIFORead, pSSM); AssertRC(rc);
1219 rc = hgsmiHostSaveFifoLocked (&pIns->hostFIFOProcessed, pSSM); AssertRC(rc);
1220#ifdef VBOX_WITH_WDDM
1221 rc = hgsmiHostSaveGuestCmdCompletedFifoLocked (&pIns->guestCmdCompleted, pSSM); AssertRC(rc);
1222#endif
1223
1224 hgsmiFIFOUnlock (pIns);
1225 }
1226
1227 if (RT_SUCCESS(rc))
1228 {
1229 if (pIns->hostHeap.u32HeapType == HGSMI_HEAP_TYPE_MA)
1230 {
1231 rc = hgsmiHostSaveMA(pSSM, &pIns->hostHeap.u.ma);
1232 }
1233 }
1234 }
1235
1236 VBOXHGSMI_SAVE_STOP(pSSM);
1237
1238 return rc;
1239}
1240
1241int HGSMIHostLoadStateExec (PHGSMIINSTANCE pIns, PSSMHANDLE pSSM, uint32_t u32Version)
1242{
1243 if(u32Version < VGA_SAVEDSTATE_VERSION_HGSMI)
1244 return VINF_SUCCESS;
1245
1246 VBOXHGSMI_LOAD_START(pSSM);
1247
1248 int rc;
1249 HGSMIOFFSET off;
1250 uint32_t u32HeapType = HGSMI_HEAP_TYPE_NULL;
1251
1252 if (u32Version >= VGA_SAVEDSTATE_VERSION_HGSMIMA)
1253 {
1254 rc = SSMR3GetU32(pSSM, &u32HeapType);
1255 AssertRCReturn(rc, rc);
1256 }
1257
1258 rc = SSMR3GetU32(pSSM, &off);
1259 AssertRCReturn(rc, rc);
1260 pIns->pHGFlags = (off != HGSMIOFFSET_VOID) ? (HGSMIHOSTFLAGS*)HGSMIOffsetToPointer (&pIns->area, off) : NULL;
1261
1262 HGSMIHEAP hHeap = pIns->hostHeap;
1263 rc = SSMR3GetU32(pSSM, &off);
1264 AssertRCReturn(rc, rc);
1265 if(off != HGSMIOFFSET_VOID)
1266 {
1267 /* There is a saved heap. */
1268 if (u32HeapType == HGSMI_HEAP_TYPE_NULL)
1269 {
1270 u32HeapType = u32Version > VGA_SAVEDSTATE_VERSION_HOST_HEAP?
1271 HGSMI_HEAP_TYPE_OFFSET:
1272 HGSMI_HEAP_TYPE_POINTER;
1273 }
1274
1275 HGSMIOFFSET offHeap;
1276 SSMR3GetU32(pSSM, &offHeap);
1277 uint32_t cbHeap;
1278 SSMR3GetU32(pSSM, &cbHeap);
1279 uint64_t oldMem;
1280 rc = SSMR3GetU64(pSSM, &oldMem);
1281 AssertRCReturn(rc, rc);
1282
1283 if (RT_SUCCESS(rc))
1284 {
1285 rc = hgsmiFIFOLock (pIns);
1286 if(RT_SUCCESS(rc))
1287 {
1288 rc = hgsmiHostLoadFifoLocked (pIns, &pIns->hostFIFO, pSSM);
1289 if (RT_SUCCESS(rc))
1290 rc = hgsmiHostLoadFifoLocked (pIns, &pIns->hostFIFORead, pSSM);
1291 if (RT_SUCCESS(rc))
1292 rc = hgsmiHostLoadFifoLocked (pIns, &pIns->hostFIFOProcessed, pSSM);
1293#ifdef VBOX_WITH_WDDM
1294 if (RT_SUCCESS(rc) && u32Version > VGA_SAVEDSTATE_VERSION_PRE_WDDM)
1295 rc = hgsmiHostLoadGuestCmdCompletedFifoLocked (pIns, &pIns->guestCmdCompleted, pSSM, u32Version);
1296#endif
1297
1298 hgsmiFIFOUnlock (pIns);
1299 }
1300 }
1301
1302 if (RT_SUCCESS(rc))
1303 {
1304 if (u32HeapType == HGSMI_HEAP_TYPE_MA)
1305 {
1306 uint32_t cBlocks = 0;
1307 HGSMISIZE cbMaxBlock = 0;
1308 HGSMIOFFSET *paDescriptors = NULL;
1309 rc = hgsmiHostLoadMA(pSSM, &cBlocks, &paDescriptors, &cbMaxBlock);
1310 if (RT_SUCCESS(rc))
1311 {
1312 rc = HGSMIHeapRestoreMA(&pIns->hostHeap,
1313 pIns->area.pu8Base+offHeap,
1314 cbHeap,
1315 offHeap,
1316 cBlocks,
1317 paDescriptors,
1318 cbMaxBlock,
1319 &g_hgsmiEnv);
1320
1321 RTMemFree(paDescriptors);
1322 }
1323 }
1324 else if ( u32HeapType == HGSMI_HEAP_TYPE_OFFSET
1325 || u32HeapType == HGSMI_HEAP_TYPE_POINTER)
1326 {
1327 rc = hgsmiHostHeapLock (pIns);
1328 if (RT_SUCCESS (rc))
1329 {
1330 Assert(!pIns->hostHeap.cRefs);
1331 pIns->hostHeap.cRefs = 0;
1332
1333 rc = HGSMIHeapRelocate(&pIns->hostHeap,
1334 u32HeapType,
1335 pIns->area.pu8Base+offHeap,
1336 off,
1337 uintptr_t(pIns->area.pu8Base) - uintptr_t(oldMem),
1338 cbHeap,
1339 offHeap);
1340
1341 hgsmiHostHeapUnlock (pIns);
1342 }
1343 }
1344 }
1345 }
1346
1347 VBOXHGSMI_LOAD_STOP(pSSM);
1348
1349 return rc;
1350}
1351
1352/*
1353 * Channels management.
1354 */
1355
1356static int hgsmiChannelMapCreate (PHGSMIINSTANCE pIns,
1357 const char *pszChannel,
1358 uint8_t *pu8Channel)
1359{
1360 /* @todo later */
1361 return VERR_NOT_SUPPORTED;
1362}
1363
1364/* Register a new HGSMI channel by a predefined index.
1365 */
1366int HGSMIHostChannelRegister(PHGSMIINSTANCE pIns,
1367 uint8_t u8Channel,
1368 PFNHGSMICHANNELHANDLER pfnChannelHandler,
1369 void *pvChannelHandler)
1370{
1371 LogFlowFunc(("pIns %p, u8Channel %x, pfnChannelHandler %p, pvChannelHandler %p\n",
1372 pIns, u8Channel, pfnChannelHandler, pvChannelHandler));
1373
1374 AssertReturn(!HGSMI_IS_DYNAMIC_CHANNEL(u8Channel), VERR_INVALID_PARAMETER);
1375 AssertPtrReturn(pIns, VERR_INVALID_PARAMETER);
1376 AssertPtrReturn(pfnChannelHandler, VERR_INVALID_PARAMETER);
1377
1378 int rc = hgsmiLock (pIns);
1379
1380 if (RT_SUCCESS (rc))
1381 {
1382 rc = HGSMIChannelRegister (&pIns->channelInfo, u8Channel, NULL, pfnChannelHandler, pvChannelHandler);
1383
1384 hgsmiUnlock (pIns);
1385 }
1386
1387 LogFlowFunc(("leave rc = %Rrc\n", rc));
1388
1389 return rc;
1390}
1391
1392/* Register a new HGSMI channel by name.
1393 */
1394int HGSMIChannelRegisterName (PHGSMIINSTANCE pIns,
1395 const char *pszChannel,
1396 PFNHGSMICHANNELHANDLER pfnChannelHandler,
1397 void *pvChannelHandler,
1398 uint8_t *pu8Channel)
1399{
1400 LogFlowFunc(("pIns %p, pszChannel %s, pfnChannelHandler %p, pvChannelHandler %p, pu8Channel %p\n",
1401 pIns, pszChannel, pfnChannelHandler, pvChannelHandler, pu8Channel));
1402
1403 AssertPtrReturn(pIns, VERR_INVALID_PARAMETER);
1404 AssertPtrReturn(pszChannel, VERR_INVALID_PARAMETER);
1405 AssertPtrReturn(pu8Channel, VERR_INVALID_PARAMETER);
1406 AssertPtrReturn(pfnChannelHandler, VERR_INVALID_PARAMETER);
1407
1408 int rc;
1409
1410 /* The pointer to the copy will be saved in the channel description. */
1411 char *pszName = RTStrDup (pszChannel);
1412
1413 if (pszName)
1414 {
1415 rc = hgsmiLock (pIns);
1416
1417 if (RT_SUCCESS (rc))
1418 {
1419 rc = hgsmiChannelMapCreate (pIns, pszName, pu8Channel);
1420
1421 if (RT_SUCCESS (rc))
1422 {
1423 rc = HGSMIChannelRegister (&pIns->channelInfo, *pu8Channel, pszName, pfnChannelHandler, pvChannelHandler);
1424 }
1425
1426 hgsmiUnlock (pIns);
1427 }
1428
1429 if (RT_FAILURE (rc))
1430 {
1431 RTStrFree (pszName);
1432 }
1433 }
1434 else
1435 {
1436 rc = VERR_NO_MEMORY;
1437 }
1438
1439 LogFlowFunc(("leave rc = %Rrc\n", rc));
1440
1441 return rc;
1442}
1443
1444void *HGSMIOffsetToPointerHost (PHGSMIINSTANCE pIns,
1445 HGSMIOFFSET offBuffer)
1446{
1447 const HGSMIAREA *pArea = &pIns->area;
1448
1449 if ( offBuffer < pArea->offBase
1450 || offBuffer > pArea->offLast)
1451 {
1452 LogFunc(("offset 0x%x is outside the area [0x%x;0x%x]!!!\n", offBuffer, pArea->offBase, pArea->offLast));
1453 return NULL;
1454 }
1455
1456 return HGSMIOffsetToPointer (pArea, offBuffer);
1457}
1458
1459
1460HGSMIOFFSET HGSMIPointerToOffsetHost (PHGSMIINSTANCE pIns,
1461 const void *pv)
1462{
1463 const HGSMIAREA *pArea = &pIns->area;
1464
1465 uintptr_t pBegin = (uintptr_t)pArea->pu8Base;
1466 uintptr_t pEnd = (uintptr_t)pArea->pu8Base + (pArea->cbArea - 1);
1467 uintptr_t p = (uintptr_t)pv;
1468
1469 if ( p < pBegin
1470 || p > pEnd)
1471 {
1472 LogFunc(("pointer %p is outside the area [%p;%p]!!!\n", pv, pBegin, pEnd));
1473 return HGSMIOFFSET_VOID;
1474 }
1475
1476 return HGSMIPointerToOffset (pArea, (HGSMIBUFFERHEADER *)pv);
1477}
1478
1479
1480void *HGSMIContext (PHGSMIINSTANCE pIns)
1481{
1482 uint8_t *p = (uint8_t *)pIns;
1483 return p + sizeof (HGSMIINSTANCE);
1484}
1485
1486/* The guest submitted a buffer. */
1487static DECLCALLBACK(int) hgsmiChannelHandler (void *pvHandler, uint16_t u16ChannelInfo, void *pvBuffer, HGSMISIZE cbBuffer)
1488{
1489 int rc = VINF_SUCCESS;
1490
1491 LogFlowFunc(("pvHandler %p, u16ChannelInfo %d, pvBuffer %p, cbBuffer %u\n",
1492 pvHandler, u16ChannelInfo, pvBuffer, cbBuffer));
1493
1494 PHGSMIINSTANCE pIns = (PHGSMIINSTANCE)pvHandler;
1495
1496 switch (u16ChannelInfo)
1497 {
1498 case HGSMI_CC_HOST_FLAGS_LOCATION:
1499 {
1500 if (cbBuffer < sizeof (HGSMIBUFFERLOCATION))
1501 {
1502 rc = VERR_INVALID_PARAMETER;
1503 break;
1504 }
1505
1506 HGSMIBUFFERLOCATION *pLoc = (HGSMIBUFFERLOCATION *)pvBuffer;
1507 if(pLoc->cbLocation != sizeof(HGSMIHOSTFLAGS))
1508 {
1509 rc = VERR_INVALID_PARAMETER;
1510 break;
1511 }
1512
1513 pIns->pHGFlags = (HGSMIHOSTFLAGS*)HGSMIOffsetToPointer (&pIns->area, pLoc->offLocation);
1514 } break;
1515
1516 default:
1517 Log(("Unsupported HGSMI guest command %d!!!\n",
1518 u16ChannelInfo));
1519 break;
1520 }
1521
1522 return rc;
1523}
1524
1525int HGSMICreate (PHGSMIINSTANCE *ppIns,
1526 PVM pVM,
1527 const char *pszName,
1528 HGSMIOFFSET offBase,
1529 uint8_t *pu8MemBase,
1530 HGSMISIZE cbMem,
1531 PFNHGSMINOTIFYGUEST pfnNotifyGuest,
1532 void *pvNotifyGuest,
1533 size_t cbContext)
1534{
1535 LogFlowFunc(("ppIns = %p, pVM = %p, pszName = [%s], pu8MemBase = %p, cbMem = 0x%08X, offMemBase = 0x%08X, "
1536 "pfnNotifyGuest = %p, pvNotifyGuest = %p, cbContext = %d\n",
1537 ppIns,
1538 pVM,
1539 pszName,
1540 pu8MemBase,
1541 cbMem,
1542 pfnNotifyGuest,
1543 pvNotifyGuest,
1544 cbContext
1545 ));
1546
1547 AssertPtrReturn(ppIns, VERR_INVALID_PARAMETER);
1548 AssertPtrReturn(pVM, VERR_INVALID_PARAMETER);
1549 AssertPtrReturn(pu8MemBase, VERR_INVALID_PARAMETER);
1550
1551 int rc = VINF_SUCCESS;
1552
1553 PHGSMIINSTANCE pIns = (PHGSMIINSTANCE)RTMemAllocZ (sizeof (HGSMIINSTANCE) + cbContext);
1554
1555 if (!pIns)
1556 {
1557 rc = VERR_NO_MEMORY;
1558 }
1559
1560 if (RT_SUCCESS (rc))
1561 {
1562 rc = HGSMIAreaInitialize (&pIns->area, pu8MemBase, cbMem, offBase);
1563 }
1564
1565 if (RT_SUCCESS (rc))
1566 {
1567 rc = RTCritSectInit (&pIns->instanceCritSect);
1568 }
1569
1570 if (RT_SUCCESS (rc))
1571 {
1572 rc = RTCritSectInit (&pIns->hostHeapCritSect);
1573 }
1574
1575 if (RT_SUCCESS (rc))
1576 {
1577 rc = RTCritSectInit (&pIns->hostFIFOCritSect);
1578 }
1579
1580 if (RT_SUCCESS (rc))
1581 {
1582 pIns->pVM = pVM;
1583
1584 pIns->pszName = VALID_PTR(pszName)? pszName: "";
1585
1586 HGSMIHeapSetupUninitialized(&pIns->hostHeap);
1587
1588 pIns->pfnNotifyGuest = pfnNotifyGuest;
1589 pIns->pvNotifyGuest = pvNotifyGuest;
1590
1591 RTListInit(&pIns->hostFIFO);
1592 RTListInit(&pIns->hostFIFORead);
1593 RTListInit(&pIns->hostFIFOProcessed);
1594 RTListInit(&pIns->hostFIFOFree);
1595 RTListInit(&pIns->guestCmdCompleted);
1596 }
1597
1598 rc = HGSMIHostChannelRegister (pIns,
1599 HGSMI_CH_HGSMI,
1600 hgsmiChannelHandler,
1601 pIns);
1602
1603 if (RT_SUCCESS (rc))
1604 {
1605 *ppIns = pIns;
1606 }
1607 else
1608 {
1609 HGSMIDestroy (pIns);
1610 }
1611
1612 LogFlowFunc(("leave rc = %Rrc, pIns = %p\n", rc, pIns));
1613
1614 return rc;
1615}
1616
1617uint32_t HGSMIReset (PHGSMIINSTANCE pIns)
1618{
1619 uint32_t flags = 0;
1620 if(pIns->pHGFlags)
1621 {
1622 /* treat the abandoned commands as read.. */
1623 while(HGSMIHostRead (pIns) != HGSMIOFFSET_VOID) {}
1624 flags = pIns->pHGFlags->u32HostFlags;
1625 pIns->pHGFlags->u32HostFlags = 0;
1626 }
1627
1628 /* .. and complete them */
1629 while(hgsmiProcessHostCmdCompletion (pIns, 0, true)) {}
1630
1631#ifdef VBOX_WITH_WDDM
1632 while(hgsmiProcessGuestCmdCompletion(pIns) != HGSMIOFFSET_VOID) {}
1633#endif
1634
1635 HGSMIHeapDestroy(&pIns->hostHeap);
1636
1637 HGSMIHeapSetupUninitialized(&pIns->hostHeap);
1638
1639 return flags;
1640}
1641
1642void HGSMIDestroy (PHGSMIINSTANCE pIns)
1643{
1644 LogFlowFunc(("pIns = %p\n", pIns));
1645
1646 if (pIns)
1647 {
1648 HGSMIHeapDestroy(&pIns->hostHeap);
1649
1650 if (RTCritSectIsInitialized (&pIns->hostHeapCritSect))
1651 {
1652 RTCritSectDelete (&pIns->hostHeapCritSect);
1653 }
1654
1655 if (RTCritSectIsInitialized (&pIns->instanceCritSect))
1656 {
1657 RTCritSectDelete (&pIns->instanceCritSect);
1658 }
1659
1660 if (RTCritSectIsInitialized (&pIns->hostFIFOCritSect))
1661 {
1662 RTCritSectDelete (&pIns->hostFIFOCritSect);
1663 }
1664
1665 memset (pIns, 0, sizeof (HGSMIINSTANCE));
1666
1667 RTMemFree (pIns);
1668 }
1669
1670 LogFlowFunc(("leave\n"));
1671}
1672
1673#ifdef VBOX_WITH_WDDM
1674
1675static int hgsmiGuestCommandComplete (HGSMIINSTANCE *pIns, HGSMIOFFSET offMem)
1676{
1677 HGSMIGUESTCOMPLENTRY *pEntry = NULL;
1678
1679 AssertPtrReturn(pIns->pHGFlags, VERR_WRONG_ORDER);
1680 int rc = hgsmiGuestCompletionFIFOAlloc (pIns, &pEntry);
1681 AssertRC(rc);
1682 if (RT_SUCCESS (rc))
1683 {
1684 pEntry->offBuffer = offMem;
1685
1686 rc = hgsmiFIFOLock(pIns);
1687 AssertRC(rc);
1688 if (RT_SUCCESS (rc))
1689 {
1690 RTListAppend(&pIns->guestCmdCompleted, &pEntry->nodeEntry);
1691 ASMAtomicOrU32(&pIns->pHGFlags->u32HostFlags, HGSMIHOSTFLAGS_GCOMMAND_COMPLETED);
1692
1693 hgsmiFIFOUnlock(pIns);
1694 }
1695 else
1696 {
1697 hgsmiGuestCompletionFIFOFree(pIns, pEntry);
1698 }
1699 }
1700
1701 return rc;
1702}
1703
1704int hgsmiCompleteGuestCommand(PHGSMIINSTANCE pIns,
1705 HGSMIOFFSET offBuffer,
1706 bool bDoIrq)
1707{
1708 int rc = hgsmiGuestCommandComplete (pIns, offBuffer);
1709 if (RT_SUCCESS (rc))
1710 {
1711 if(bDoIrq)
1712 {
1713 /* Now guest can read the FIFO, the notification is informational. */
1714 hgsmiNotifyGuest (pIns);
1715 }
1716#ifdef DEBUG_misha
1717 else
1718 {
1719 Assert(0);
1720 }
1721#endif
1722 }
1723 return rc;
1724}
1725
1726int HGSMICompleteGuestCommand(PHGSMIINSTANCE pIns,
1727 void *pvMem,
1728 bool bDoIrq)
1729{
1730 LogFlowFunc(("pIns = %p, pvMem = %p\n", pIns, pvMem));
1731
1732 int rc = VINF_SUCCESS;
1733
1734 HGSMIBUFFERHEADER *pHeader = HGSMIBufferHeaderFromData(pvMem);
1735 HGSMIOFFSET offBuffer = HGSMIPointerToOffset(&pIns->area, pHeader);
1736
1737 Assert(offBuffer != HGSMIOFFSET_VOID);
1738 if (offBuffer != HGSMIOFFSET_VOID)
1739 {
1740 rc = hgsmiCompleteGuestCommand (pIns, offBuffer, bDoIrq);
1741 AssertRC (rc);
1742 }
1743 else
1744 {
1745 LogRel(("invalid cmd offset \n"));
1746 rc = VERR_INVALID_PARAMETER;
1747 }
1748
1749 LogFlowFunc(("rc = %Rrc\n", rc));
1750
1751 return rc;
1752}
1753#endif
Note: See TracBrowser for help on using the repository browser.

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