VirtualBox

Ignore:
Timestamp:
Oct 4, 2010 11:14:12 PM (14 years ago)
Author:
vboxsync
Message:

wddm/3d: chromium over hgsmi transport fixing & perf measurement

Location:
trunk/src/VBox/Additions/WINNT/Graphics/Miniport
Files:
7 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/Makefile.kmk

    r32877 r32889  
    9090  endif
    9191 endif
    92  ifdef VBOXVDMA_WITH_VDMA
    93   VBoxVideoWddm_DEFS     += VBOXVDMA_WITH_VDMA
     92 ifdef VBOX_WITH_VDMA
     93  VBoxVideoWddm_DEFS     += VBOX_WITH_VDMA
    9494 endif
    9595 ifdef DEBUG_misha

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.h

    r32876 r32889  
    336336   VBOXSHGSMILIST VhwaCmdList;
    337337#endif
    338    BOOL bSetNotifyDxDpc;
     338//   BOOL bSetNotifyDxDpc;
    339339   BOOL bNotifyDxDpc;
    340340

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxUhgsmi.h

    r32877 r32889  
    3434        struct
    3535        {
    36             uint32_t bReadOnly  : 1;
    37             uint32_t bWriteOnly : 1;
    38             uint32_t bDonotWait : 1;
    39             uint32_t bDiscard   : 1;
    40             uint32_t Reserved   : 28;
     36            uint32_t bReadOnly   : 1;
     37            uint32_t bWriteOnly  : 1;
     38            uint32_t bDonotWait  : 1;
     39            uint32_t bDiscard    : 1;
     40            uint32_t bLockEntire : 1;
     41            uint32_t Reserved    : 27;
    4142        };
    4243        uint32_t Value;
    … …  
    5455            uint32_t bDoNotRetire           : 1; /* <- the buffer will be used in a subsequent command */
    5556            uint32_t bDoNotSignalCompletion : 1; /* <- do not signal notification object on completion for this alloc */
    56             uint32_t Reserved               : 28;
     57            uint32_t bEntireBuffer          : 1; /* <- do not signal notification object on completion for this alloc */
     58            uint32_t Reserved               : 27;
    5759        };
    5860        uint32_t Value;

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoMisc.cpp

    r32766 r32889  
    693693NTSTATUS vboxWddmDisplaySettingsQueryPos(IN PDEVICE_EXTENSION pDeviceExtension, D3DDDI_VIDEO_PRESENT_SOURCE_ID VidPnSourceId, POINT * pPos)
    694694{
     695    Assert(KeGetCurrentIrql() == PASSIVE_LEVEL);
    695696    HANDLE hKey;
    696697    NTSTATUS Status = vboxWddmRegOpenDisplaySettingsKey(pDeviceExtension, VidPnSourceId, &hKey);

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVdma.cpp

    r32877 r32889  
    10021002static int vboxWddmVdmaSubmitHgsmi(struct _DEVICE_EXTENSION* pDevExt, PVBOXVDMAINFO pInfo, HGSMIOFFSET offDr)
    10031003{
    1004     VBoxHGSMIGuestWrite(pDevExt, offDr);
     1004    VBoxHGSMIGuestWrite(hgsmiFromDeviceExt(pDevExt), offDr);
    10051005    return VINF_SUCCESS;
    10061006}
    … …  
    10121012    int rc = VINF_SUCCESS;
    10131013
    1014     PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&pDevExt->u.primary.hgsmiAdapterHeap, sizeof (VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
     1014    PVBOXVDMA_CTL pCmd = (PVBOXVDMA_CTL)VBoxSHGSMICommandAlloc(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, sizeof (VBOXVDMA_CTL), HGSMI_CH_VBVA, VBVA_VDMA_CTL);
    10151015    if (pCmd)
    10161016    {
    … …  
    10191019        pCmd->i32Result = VERR_NOT_SUPPORTED;
    10201020
    1021         const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&pDevExt->u.primary.hgsmiAdapterHeap, pCmd);
     1021        const VBOXSHGSMIHEADER* pHdr = VBoxSHGSMICommandPrepSynch(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pCmd);
    10221022        Assert(pHdr);
    10231023        if (pHdr)
    … …  
    10251025            do
    10261026            {
    1027                 HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&pDevExt->u.primary.hgsmiAdapterHeap, pHdr);
     1027                HGSMIOFFSET offCmd = VBoxSHGSMICommandOffset(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
    10281028                Assert(offCmd != HGSMIOFFSET_VOID);
    10291029                if (offCmd != HGSMIOFFSET_VOID)
    … …  
    10331033                    if (RT_SUCCESS(rc))
    10341034                    {
    1035                         rc = VBoxSHGSMICommandDoneSynch(&pDevExt->u.primary.hgsmiAdapterHeap, pHdr);
     1035                        rc = VBoxSHGSMICommandDoneSynch(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
    10361036                        AssertRC(rc);
    10371037                        if (RT_SUCCESS(rc))
    … …  
    10461046                    rc = VERR_INVALID_PARAMETER;
    10471047                /* fail to submit, cancel it */
    1048                 VBoxSHGSMICommandCancelSynch(&pDevExt->u.primary.hgsmiAdapterHeap, pHdr);
     1048                VBoxSHGSMICommandCancelSynch(&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pHdr);
    10491049            } while (0);
    10501050        }
    10511051
    1052         VBoxSHGSMICommandFree (&pDevExt->u.primary.hgsmiAdapterHeap, pCmd);
     1052        VBoxSHGSMICommandFree (&hgsmiFromDeviceExt(pDevExt)->hgsmiAdapterHeap, pCmd);
    10531053    }
    10541054    else
    … …  
    12471247    }
    12481248
    1249     vboxVdmaDdiCmdCompletedIrq(pDevExt, &pDevExt->DdiCmdQueue, VBOXVDMADDI_CMD_FROM_BUF_DR(pDr), enmComplType);
     1249    if (vboxVdmaDdiCmdCompletedIrq(pDevExt, &pDevExt->DdiCmdQueue, VBOXVDMADDI_CMD_FROM_BUF_DR(pDr), enmComplType))
     1250    {
     1251        pDevExt->bNotifyDxDpc = TRUE;
     1252    }
    12501253
    12511254    /* inform SHGSMI we DO NOT want to be called at DPC later */

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoVdma.h

    r32877 r32889  
    7979}
    8080
     81DECLINLINE(BOOLEAN) vboxVdmaDdiCmdIsCompletedListEmptyIsr(PVBOXVDMADDI_CMD_QUEUE pQueue)
     82{
     83    return IsListEmpty(&pQueue->DpcCmdQueue);
     84}
     85
    8186#define VBOXVDMADDI_CMD_FROM_ENTRY(_pEntry) ((PVBOXVDMADDI_CMD)(((uint8_t*)(_pEntry)) - RT_OFFSETOF(VBOXVDMADDI_CMD, QueueEntry)))
    8287

  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/wddm/VBoxVideoWddm.cpp

    r32877 r32889  
    214214     * Set the current mode into the hardware.
    215215     */
    216     NTSTATUS Status= vboxWddmDisplaySettingsQueryPos(pDevExt, VidPnSourceId, &pSource->VScreenPos);
    217     Assert(Status == STATUS_SUCCESS);
    218     Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocation);
     216//    NTSTATUS Status= vboxWddmDisplaySettingsQueryPos(pDevExt, VidPnSourceId, &pSource->VScreenPos);
     217//    Assert(Status == STATUS_SUCCESS);
     218    NTSTATUS Status = vboxWddmGhDisplaySetMode(pDevExt, pAllocation);
    219219    Assert(Status == STATUS_SUCCESS);
    220220    if (Status == STATUS_SUCCESS)
    … …  
    886886        }
    887887
    888         if (pDevExt->bSetNotifyDxDpc)
    889         {
    890             Assert(bNeedDpc == TRUE);
    891             pDevExt->bNotifyDxDpc = TRUE;
    892             pDevExt->bSetNotifyDxDpc = FALSE;
     888        if (pDevExt->bNotifyDxDpc)
     889        {
     890//            Assert(bNeedDpc == TRUE);
     891//            pDevExt->bNotifyDxDpc = TRUE;
     892//            pDevExt->bSetNotifyDxDpc = FALSE;
    893893            bNeedDpc = TRUE;
    894894        }
    … …  
    14421442//        }
    14431443//#endif
     1444        case VBOXWDDM_ALLOC_TYPE_UMD_HGSMI_BUFFER:
     1445        {
     1446            ObDereferenceObject(pAllocation->pSynchEvent);
     1447            break;
     1448        }
    14441449        default:
    14451450            break;
    … …  
    14721477        if (pAllocation)
    14731478        {
    1474             pAllocation->enmType = pAllocInfo->enmType;
    1475             pAllocation->fRcFlags = pAllocInfo->fFlags;
    1476             pAllocation->offVram = VBOXVIDEOOFFSET_VOID;
    1477             pAllocation->SurfDesc = pAllocInfo->SurfDesc;
    1478             pAllocation->bVisible = FALSE;
    1479             pAllocation->bAssigned = FALSE;
    1480 
    14811479            pAllocationInfo->pPrivateDriverData = NULL;
    14821480            pAllocationInfo->PrivateDriverDataSize = 0;
    14831481            pAllocationInfo->Alignment = 0;
    1484             pAllocationInfo->Size = pAllocInfo->SurfDesc.cbSize;
    14851482            pAllocationInfo->PitchAlignedSize = 0;
    14861483            pAllocationInfo->HintedBank.Value = 0;
    … …  
    14951492            pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_NORMAL;
    14961493
     1494            pAllocation->enmType = pAllocInfo->enmType;
     1495            pAllocation->offVram = VBOXVIDEOOFFSET_VOID;
     1496            pAllocation->bVisible = FALSE;
     1497            pAllocation->bAssigned = FALSE;
     1498
    14971499            switch (pAllocInfo->enmType)
    14981500            {
    14991501                case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE:
     1502                case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
     1503                case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
     1504                case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE:
     1505                {
     1506                    pAllocation->fRcFlags = pAllocInfo->fFlags;
     1507                    pAllocation->SurfDesc = pAllocInfo->SurfDesc;
     1508
     1509                    pAllocationInfo->Size = pAllocInfo->SurfDesc.cbSize;
     1510
     1511                    switch (pAllocInfo->enmType)
     1512                    {
     1513                        case VBOXWDDM_ALLOC_TYPE_STD_SHAREDPRIMARYSURFACE:
    15001514#if 0 //defined(VBOXWDDM_RENDER_FROM_SHADOW)
    1501                     pAllocationInfo->SupportedReadSegmentSet = 2;
    1502                     pAllocationInfo->SupportedWriteSegmentSet = 2;
     1515                            pAllocationInfo->SupportedReadSegmentSet = 2;
     1516                            pAllocationInfo->SupportedWriteSegmentSet = 2;
    15031517#endif
    15041518#ifndef VBOXWDDM_RENDER_FROM_SHADOW
    1505                     pAllocationInfo->Flags.CpuVisible = 1;
     1519                            pAllocationInfo->Flags.CpuVisible = 1;
    15061520#endif
    1507                     break;
    1508                 case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
    1509 //                    Assert(pResource);
    1510 //                    if (pResource)
    1511                     {
    1512 //                        Assert(pResource->cAllocations);
    1513 //                        if (pResource->cAllocations)
    1514                         {
     1521                            break;
     1522                        case VBOXWDDM_ALLOC_TYPE_UMD_RC_GENERIC:
    15151523#ifdef VBOX_WITH_VIDEOHWACCEL
    15161524                            if (pAllocInfo->fFlags.Overlay)
    … …  
    15441552                                }
    15451553                            }
    1546                         }
    1547 //                        else
    1548 //                            Status = STATUS_INVALID_PARAMETER;
     1554                            break;
     1555                        case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
     1556                        case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE:
     1557                            pAllocationInfo->Flags.CpuVisible = 1;
     1558                            break;
     1559                    }
     1560
     1561                    if (Status == STATUS_SUCCESS)
     1562                    {
     1563                        pAllocation->UsageHint.Version = 0;
     1564                        pAllocation->UsageHint.v1.Flags.Value = 0;
     1565                        pAllocation->UsageHint.v1.Format = pAllocInfo->SurfDesc.format;
     1566                        pAllocation->UsageHint.v1.SwizzledFormat = 0;
     1567                        pAllocation->UsageHint.v1.ByteOffset = 0;
     1568                        pAllocation->UsageHint.v1.Width = pAllocation->SurfDesc.width;
     1569                        pAllocation->UsageHint.v1.Height = pAllocation->SurfDesc.height;
     1570                        pAllocation->UsageHint.v1.Pitch = pAllocation->SurfDesc.pitch;
     1571                        pAllocation->UsageHint.v1.Depth = 0;
     1572                        pAllocation->UsageHint.v1.SlicePitch = 0;
     1573
     1574                        Assert(!pAllocationInfo->pAllocationUsageHint);
     1575                        pAllocationInfo->pAllocationUsageHint = &pAllocation->UsageHint;
     1576                    }
     1577
     1578                    break;
     1579                }
     1580                case VBOXWDDM_ALLOC_TYPE_UMD_HGSMI_BUFFER:
     1581                {
     1582                    pAllocationInfo->Size = pAllocInfo->cbBuffer;
     1583                    pAllocation->enmSynchType = pAllocInfo->enmSynchType;
     1584                    pAllocation->SurfDesc.cbSize = pAllocInfo->cbBuffer;
     1585                    pAllocationInfo->Flags.CpuVisible = 1;
     1586                    pAllocationInfo->Flags.SynchronousPaging = 1;
     1587                    pAllocationInfo->AllocationPriority = D3DDDI_ALLOCATIONPRIORITY_MAXIMUM;
     1588                    switch (pAllocInfo->enmSynchType)
     1589                    {
     1590                        case VBOXUHGSMI_SYNCHOBJECT_TYPE_EVENT:
     1591                            Status = ObReferenceObjectByHandle(pAllocInfo->hSynch, EVENT_MODIFY_STATE, *ExEventObjectType, UserMode,
     1592                                    (PVOID*)&pAllocation->pSynchEvent,
     1593                                    NULL);
     1594                            Assert(Status == STATUS_SUCCESS);
     1595                            break;
     1596                        case VBOXUHGSMI_SYNCHOBJECT_TYPE_SEMAPHORE:
     1597                            Status = ObReferenceObjectByHandle(pAllocInfo->hSynch, EVENT_MODIFY_STATE, *ExSemaphoreObjectType, UserMode,
     1598                                    (PVOID*)&pAllocation->pSynchSemaphore,
     1599                                    NULL);
     1600                            Assert(Status == STATUS_SUCCESS);
     1601                            break;
     1602                        default:
     1603                            drprintf((__FUNCTION__ ": ERROR: invalid synch info type(%d)\n", pAllocInfo->enmSynchType));
     1604                            AssertBreakpoint();
     1605                            Status = STATUS_INVALID_PARAMETER;
     1606                            break;
    15491607                    }
    15501608                    break;
    1551                 case VBOXWDDM_ALLOC_TYPE_STD_SHADOWSURFACE:
    1552                 case VBOXWDDM_ALLOC_TYPE_STD_STAGINGSURFACE:
    1553                     pAllocationInfo->Flags.CpuVisible = 1;
    1554                     break;
     1609                }
     1610
    15551611                default:
    15561612                    drprintf((__FUNCTION__ ": ERROR: invalid alloc info type(%d)\n", pAllocInfo->enmType));
    … …  
    15581614                    Status = STATUS_INVALID_PARAMETER;
    15591615                    break;
    1560             }
    1561 
    1562             if (Status == STATUS_SUCCESS)
    1563             {
    1564                 pAllocation->UsageHint.Version = 0;
    1565                 pAllocation->UsageHint.v1.Flags.Value = 0;
    1566                 pAllocation->UsageHint.v1.Format = pAllocInfo->SurfDesc.format;
    1567                 pAllocation->UsageHint.v1.SwizzledFormat = 0;
    1568                 pAllocation->UsageHint.v1.ByteOffset = 0;
    1569                 pAllocation->UsageHint.v1.Width = pAllocation->SurfDesc.width;
    1570                 pAllocation->UsageHint.v1.Height = pAllocation->SurfDesc.height;
    1571                 pAllocation->UsageHint.v1.Pitch = pAllocation->SurfDesc.pitch;
    1572                 pAllocation->UsageHint.v1.Depth = 0;
    1573                 pAllocation->UsageHint.v1.SlicePitch = 0;
    1574 
    1575                 Assert(!pAllocationInfo->pAllocationUsageHint);
    1576                 pAllocationInfo->pAllocationUsageHint = &pAllocation->UsageHint;
    1577             }
    1578             else
     1616
     1617            }
     1618
     1619            if (Status != STATUS_SUCCESS)
    15791620                vboxWddmAllocationDeleteFromResource(pResource, pAllocation);
    15801621        }
    … …  
    19932034                    if (pAllocationList->SegmentId)
    19942035                    {
    1995                         DXGK_ALLOCATIONLIST *pAllocation2Patch = (DXGK_ALLOCATIONLIST*)pPrivateBuf + pPatchList->PatchOffset;
     2036                        DXGK_ALLOCATIONLIST *pAllocation2Patch = (DXGK_ALLOCATIONLIST*)(pPrivateBuf + pPatchList->PatchOffset);
    19962037                        pAllocation2Patch->SegmentId = pAllocationList->SegmentId;
    19972038                        pAllocation2Patch->PhysicalAddress = pAllocationList->PhysicalAddress;
    … …  
    21242165DECLCALLBACK(VOID) vboxWddmDmaCompleteChromiumCmd(PDEVICE_EXTENSION pDevExt, PVBOXVDMADDI_CMD pCmd, PVOID pvContext)
    21252166{
    2126     PVBOXVDMACBUF_DR pDr = (pDr)pvContext;
     2167    PVBOXVDMACBUF_DR pDr = (PVBOXVDMACBUF_DR)pvContext;
    21272168    PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
    21282169    UINT cBufs = pHdr->u32CmdSpecific;
    … …  
    23422383            pDr->fFlags = VBOXVDMACBUF_FLAG_BUF_FOLLOWS_DR;
    23432384            pDr->cbBuf = cbCmd;
    2344             pDr->u32FenceId = pSubmitCommand->SubmissionFenceId;
    23452385            pDr->rc = VERR_NOT_IMPLEMENTED;
    2346             pDr->u64GuestContext = (uint64_t)pContext;
    23472386
    23482387            PVBOXVDMACMD pHdr = VBOXVDMACBUF_DR_TAIL(pDr, VBOXVDMACMD);
    … …  
    23632402            PVBOXVDMADDI_CMD pDdiCmd = VBOXVDMADDI_CMD_FROM_BUF_DR(pDr);
    23642403            vboxVdmaDdiCmdInit(pDdiCmd, pSubmitCommand->SubmissionFenceId, pContext, vboxWddmDmaCompleteChromiumCmd, pDr);
    2365             NTSTATUS Status = vboxVdmaDdiCmdSubmitted(pDevExt, &pDevExt->DdiCmdQueue, &pCmd->DdiCmd);
     2404            NTSTATUS Status = vboxVdmaDdiCmdSubmitted(pDevExt, &pDevExt->DdiCmdQueue, pDdiCmd);
    23662405            Assert(Status == STATUS_SUCCESS);
    23672406            if (Status == STATUS_SUCCESS)
    … …  
    23782417            Assert(Status == STATUS_SUCCESS);
    23792418#endif
     2419            break;
    23802420        }
    23812421        case VBOXVDMACMD_TYPE_DMA_PRESENT_FLIP:
    … …  
    24422482        {
    24432483            AssertBreakpoint();
    2444 #ifdef VBOX_WITH_VDMA
     2484#if 0 //def VBOX_WITH_VDMA
    24452485            VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR *pPrivateData = (VBOXWDDM_DMA_PRIVATEDATA_PRESENTHDR*)pPrivateDataBase;
    24462486            PVBOXVDMACBUF_DR pDr = vboxVdmaCBufDrCreate (&pDevExt->u.primary.Vdma, 0);
    … …  
    34343474                pSource->offVram = VBOXVIDEOOFFSET_VOID;
    34353475#endif
     3476                Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceAddress->VidPnSourceId, &pSource->VScreenPos);
     3477                Assert(Status == STATUS_SUCCESS);
    34363478                /* should not generally happen, but still inform host*/
    34373479                Status = vboxWddmGhDisplaySetInfo(pDevExt, pSource, pSetVidPnSourceAddress->VidPnSourceId);
    … …  
    35003542                        pSource->offVram = VBOXVIDEOOFFSET_VOID;
    35013543#endif
    3502 #if 0 /* tmp */
     3544                        Status= vboxWddmDisplaySettingsQueryPos(pDevExt, pSetVidPnSourceVisibility->VidPnSourceId, &pSource->VScreenPos);
     3545                        Assert(Status == STATUS_SUCCESS);
    35033546                        Status = vboxWddmGhDisplaySetInfo(pDevExt, pSource, pSetVidPnSourceVisibility->VidPnSourceId);
    35043547                        Assert(Status == STATUS_SUCCESS);
    35053548                        if (Status != STATUS_SUCCESS)
    35063549                            drprintf((__FUNCTION__": vboxWddmGhDisplaySetInfo failed, Status (0x%x)\n", Status));
    3507 #endif
    35083550                    }
    35093551                }
    … …  
    45794621    int rc = vboxVhwaHlpOverlayUpdate(pOverlay, &pUpdateOverlay->OverlayInfo);
    45804622    AssertRC(rc);
    4581     if (RT_FAILURE(rc))
     4623    if (RT_SUCCESS(rc))
     4624    {
     4625        RECT DstRect;
     4626        vboxVhwaHlpOverlayDstRectGet(pOverlay->pDevExt, pOverlay, &DstRect);
     4627        Status = vboxVdmaHlpUpdatePrimary(pOverlay->pDevExt, pOverlay->VidPnSourceId, &DstRect);
     4628        Assert(Status == STATUS_SUCCESS);
     4629    }
     4630    else
    45824631        Status = STATUS_UNSUCCESSFUL;
    45834632
    … …  
    46684717            {
    46694718                pDevExt->aSources[i].offVram = VBOXVIDEOOFFSET_VOID;
     4719                Status= vboxWddmDisplaySettingsQueryPos(pDevExt, i, &pDevExt->aSources[i].VScreenPos);
     4720                Assert(Status == STATUS_SUCCESS);
    46704721            }
    46714722        }
Note: See TracChangeset for help on using the changeset viewer.

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