VirtualBox

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

Last change on this file since 66058 was 65381, checked in by vboxsync, 8 years ago

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