VirtualBox

Ignore:
Timestamp:
Sep 25, 2008 2:26:02 PM (16 years ago)
Author:
vboxsync
Message:

VBoxVideo: Logging.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/src/VBox/Additions/WINNT/Graphics/Miniport/VBoxVideo.cpp

    r12215 r12741  
    3333#define _INC_SWPRINTF_INL_
    3434extern "C" int __cdecl swprintf(wchar_t *, const wchar_t *, ...);
    35 #endif 
     35#endif
    3636#include <wchar.h>
    3737
     
    737737
    738738    /* Size of a framebuffer. */
    739    
     739
    740740    ULONG ulSize = ulAvailable / PrimaryExtension->u.primary.cDisplays;
    741    
     741
    742742    /* Align down to 4096 bytes. */
    743743    ulSize &= ~0xFFF;
    744    
     744
    745745    dprintf(("VBoxVideo::vboxComputeFrameBufferSizes: cbVRAM = 0x%08X, cDisplays = %d, ulSize = 0x%08X, ulSize * cDisplays = 0x%08X, slack = 0x%08X\n",
    746746             PrimaryExtension->u.primary.cbVRAM, PrimaryExtension->u.primary.cDisplays,
    747747             ulSize, ulSize * PrimaryExtension->u.primary.cDisplays,
    748748             ulAvailable - ulSize * PrimaryExtension->u.primary.cDisplays));
    749    
     749
    750750    if (ulSize > VBOX_VIDEO_DISPLAY_INFORMATION_SIZE)
    751751    {
     
    758758        ulSize = 0;
    759759    }
    760    
     760
    761761    /* Update the primary info. */
    762762    PrimaryExtension->u.primary.ulMaxFrameBufferSize     = ulSize;
    763763    PrimaryExtension->u.primary.ulDisplayInformationSize = VBOX_VIDEO_DISPLAY_INFORMATION_SIZE;
    764    
     764
    765765    /* Update the per extension info. */
    766766    PDEVICE_EXTENSION Extension = PrimaryExtension;
     
    771771        /* That is assigned when a video mode is set. */
    772772        Extension->ulFrameBufferSize = 0;
    773        
     773
    774774        dprintf(("VBoxVideo::vboxComputeFrameBufferSizes: [%d] ulFrameBufferOffset 0x%08X\n",
    775775                 Extension->iDevice, ulFrameBufferOffset));
    776        
     776
    777777        ulFrameBufferOffset += PrimaryExtension->u.primary.ulMaxFrameBufferSize
    778778                               + PrimaryExtension->u.primary.ulDisplayInformationSize;
    779                                
     779
    780780        Extension = Extension->pNext;
    781781    }
     
    807807        *ppv = VideoRamBase;
    808808    }
    809    
     809
    810810    dprintf(("VBoxVideo::vboxMapAdapterMemory rc = %d\n", Status));
    811    
     811
    812812    return Status;
    813813}
     
    816816{
    817817    dprintf(("VBoxVideo::vboxMapAdapterMemory\n"));
    818    
     818
    819819    if (*ppv)
    820820    {
    821821        VideoPortUnmapMemory(PrimaryExtension, *ppv, NULL);
    822822    }
    823    
     823
    824824    *ppv = NULL;
    825825}
     
    828828{
    829829    dprintf(("VBoxVideo::vboxQueryConf: u32Index = %d\n", u32Index));
    830    
     830
    831831    typedef struct _VBOXVIDEOQCONF32
    832832    {
     
    841841    p->hdrQuery.u8Reserved = 0;
    842842    p->hdrQuery.u16Length  = sizeof (VBOXVIDEOINFOQUERYCONF32);
    843    
     843
    844844    p->query.u32Index = u32Index;
    845845    p->query.u32Value = 0;
    846    
     846
    847847    p->hdrEnd.u8Type     = VBOX_VIDEO_INFO_TYPE_END;
    848848    p->hdrEnd.u8Reserved = 0;
    849849    p->hdrEnd.u16Length  = 0;
    850    
     850
    851851    /* Let the host to process the commands. */
    852852    VideoPortWritePortUshort((PUSHORT)VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_VBOX_VIDEO);
    853853    VideoPortWritePortUlong((PULONG)VBE_DISPI_IOPORT_DATA, VBOX_VIDEO_INTERPRET_ADAPTER_MEMORY);
    854    
     854
    855855    *pulValue = (ULONG)p->query.u32Value;
    856    
     856
    857857    dprintf(("VBoxVideo::vboxQueryConf: u32Value = %d\n", p->query.u32Value));
    858858}
     
    861861{
    862862    dprintf(("VBoxVideo::vboxSetupAdapterInfo\n"));
    863    
     863
    864864    VBOXVIDEOINFOHDR *pHdr;
    865865
     
    887887    }
    888888
    889    
     889
    890890    /* The heap description. */
    891891    pHdr = (VBOXVIDEOINFOHDR *)pu8;
     
    899899    pu8 += sizeof (VBOXVIDEOINFONVHEAP);
    900900
    901     pHeap->u32HeapOffset = PrimaryExtension->u.primary.cbVRAM 
     901    pHeap->u32HeapOffset = PrimaryExtension->u.primary.cbVRAM
    902902                           - PrimaryExtension->u.primary.cbMiniportHeap
    903903                           - VBOX_VIDEO_ADAPTER_INFORMATION_SIZE;
    904904    pHeap->u32HeapSize = PrimaryExtension->u.primary.cbMiniportHeap;
    905        
    906    
     905
     906
    907907    /* The END marker. */
    908908    pHdr = (VBOXVIDEOINFOHDR *)pu8;
     
    916916    VideoPortWritePortUshort((PUSHORT)VBE_DISPI_IOPORT_INDEX, VBE_DISPI_INDEX_VBOX_VIDEO);
    917917    VideoPortWritePortUlong((PULONG)VBE_DISPI_IOPORT_DATA, VBOX_VIDEO_INTERPRET_ADAPTER_MEMORY);
    918    
     918
    919919    dprintf(("VBoxVideo::vboxSetupAdapterInfo finished\n"));
    920920}
     
    956956        PrimaryExtension->u.primary.bVBoxVideoSupported = TRUE;
    957957    }
    958    
     958
    959959    dprintf(("VBoxVideo::VBoxSetupDisplays: bVBoxVideoSupported = %d\n",
    960960             PrimaryExtension->u.primary.bVBoxVideoSupported));
    961    
     961
    962962    if (PrimaryExtension->u.primary.bVBoxVideoSupported)
    963963    {
     
    972972            dprintf(("VBoxVideo::VBoxSetupDisplays: vboxMapAdapterMemory pvAdapterInfoirrmation failed rc = %d\n",
    973973                     rc));
    974    
     974
    975975            PrimaryExtension->u.primary.bVBoxVideoSupported = FALSE;
    976976        }
    977977    }
    978    
     978
    979979    /* Setup the non-volatile heap and the adapter memory. */
    980980    if (PrimaryExtension->u.primary.bVBoxVideoSupported)
     
    983983        ULONG cbMiniportHeap = 0;
    984984        vboxQueryConf (PrimaryExtension, VBOX_VIDEO_QCI32_OFFSCREEN_HEAP_SIZE, &cbMiniportHeap);
    985        
     985
    986986        /* Do not allow too big heap. 50% of VRAM should be enough. */
    987987        ULONG cbMiniportHeapMaxSize = AdapterMemorySize / 2 - VBOX_VIDEO_ADAPTER_INFORMATION_SIZE;
    988        
     988
    989989        if (cbMiniportHeap > cbMiniportHeapMaxSize)
    990990        {
    991991            cbMiniportHeap = cbMiniportHeapMaxSize;
    992992        }
    993        
     993
    994994        /* Round up to 4096. */
    995995        PrimaryExtension->u.primary.cbMiniportHeap = (cbMiniportHeap + 0xFFF) & ~0xFFF;
    996        
     996
    997997        dprintf(("VBoxVideo::VBoxSetupDisplays: cbMiniportHeap = 0x%08X, PrimaryExtension->u.primary.cbMiniportHeap = 0x%08X, cbMiniportHeapMaxSize = 0x%08X\n",
    998998                 cbMiniportHeap, PrimaryExtension->u.primary.cbMiniportHeap, cbMiniportHeapMaxSize));
    999        
     999
    10001000        /* Map the heap region and the adapter information area.
    10011001         *
     
    10041004         *       It is assumed that all display drivers and the miniport has the SAME
    10051005         *       virtual address space.
    1006          * 
     1006         *
    10071007         */
    10081008        rc = vboxMapAdapterMemory (PrimaryExtension,
     
    10131013                                   PrimaryExtension->u.primary.cbMiniportHeap
    10141014                                  );
    1015        
     1015
    10161016        if (rc != NO_ERROR)
    10171017        {
     
    10261026        typedef VP_STATUS (*PFNCREATESECONDARYDISPLAY)(PVOID, PVOID *, ULONG);
    10271027        PFNCREATESECONDARYDISPLAY pfnCreateSecondaryDisplay = NULL;
    1028        
     1028
    10291029        /* Dynamically query the VideoPort import to be binary compatible across Windows versions */
    1030         if (vboxQueryWinVersion() > WINNT4) 
     1030        if (vboxQueryWinVersion() > WINNT4)
    10311031        {
    10321032            /* This bluescreens on NT4, hence the above version check */
     
    10411041            ULONG cDisplays = 0;
    10421042            vboxQueryConf (PrimaryExtension, VBOX_VIDEO_QCI32_MONITOR_COUNT, &cDisplays);
    1043        
     1043
    10441044            dprintf(("VBoxVideo::VBoxSetupDisplays: cDisplays = %d\n",
    10451045                     cDisplays));
    1046                      
     1046
    10471047            if (cDisplays == 0 || cDisplays > VBOX_VIDEO_MAX_SCREENS)
    10481048            {
     
    10521052
    10531053            PDEVICE_EXTENSION pPrev = PrimaryExtension;
    1054            
     1054
    10551055            ULONG iDisplay;
    10561056            for (iDisplay = 1; iDisplay < cDisplays; iDisplay++)
     
    10581058               PDEVICE_EXTENSION SecondaryExtension = NULL;
    10591059               rc = pfnCreateSecondaryDisplay (PrimaryExtension, (PVOID*)&SecondaryExtension, VIDEO_DUALVIEW_REMOVABLE);
    1060                
     1060
    10611061               dprintf(("VBoxVideo::VBoxSetupDisplays: VideoPortCreateSecondaryDisplay returned %#x, SecondaryExtension = %p\n",
    10621062                        rc, SecondaryExtension));
    1063                
     1063
    10641064               if (rc != NO_ERROR)
    10651065               {
     
    10731073               SecondaryExtension->ulFrameBufferSize    = 0;
    10741074               SecondaryExtension->u.secondary.bEnabled = FALSE;
    1075                
     1075
    10761076               /* Update the list pointers. */
    10771077               pPrev->pNext = SecondaryExtension;
    10781078               pPrev = SecondaryExtension;
    1079                
     1079
    10801080               /* Take the successfully created display into account. */
    10811081               PrimaryExtension->u.primary.cDisplays++;
    10821082            }
    1083            
     1083
    10841084            /* Failure to create secondary displays is not fatal */
    10851085            rc = NO_ERROR;
    10861086        }
    10871087    }
    1088        
     1088
    10891089    /* Now when the number of monitors is known and extensions are created,
    10901090     * calculate the layout of framebuffers.
     
    11031103        vboxUnmapAdapterMemory (PrimaryExtension, &PrimaryExtension->u.primary.pvAdapterInformation);
    11041104    }
    1105    
     1105
    11061106    dprintf(("VBoxVideo::VBoxSetupDisplays: finished\n"));
    11071107}
     
    12601260    BOOLEAN Result;
    12611261
    1262 //    dprintf(("VBoxVideo::VBoxVideoStartIO: code %08X\n", RequestPacket->IoControlCode));
     1262//    dprintf(("VBoxVideo::VBoxVideoStartIO: Code %08X\n", RequestPacket->IoControlCode));
    12631263
    12641264    RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
     
    13241324            VP_STATUS status;
    13251325
    1326             dprintf(("IOCTL_VIDEO_SHARE_VIDEO_MEMORY\n"));
    1327 
    1328             if (    (RequestPacket->OutputBufferLength < sizeof(VIDEO_SHARE_MEMORY_INFORMATION)) 
     1326            dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_SHARE_VIDEO_MEMORY\n"));
     1327
     1328            if (    (RequestPacket->OutputBufferLength < sizeof(VIDEO_SHARE_MEMORY_INFORMATION))
    13291329                ||  (RequestPacket->InputBufferLength < sizeof(VIDEO_MEMORY)) ) {
    13301330
    1331                 dprintf(("IOCTL_VIDEO_SHARE_VIDEO_MEMORY: ERROR_INSUFFICIENT_BUFFER\n"));
     1331                dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_SHARE_VIDEO_MEMORY: ERROR_INSUFFICIENT_BUFFER\n"));
    13321332                RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
    13331333                Result = FALSE;
     
    13371337            pShareMemory = (PVIDEO_SHARE_MEMORY)RequestPacket->InputBuffer;
    13381338
    1339             if (    (pShareMemory->ViewOffset > pDevExt->pPrimary->u.primary.ulMaxFrameBufferSize) 
     1339            if (    (pShareMemory->ViewOffset > pDevExt->pPrimary->u.primary.ulMaxFrameBufferSize)
    13401340                ||  ((pShareMemory->ViewOffset + pShareMemory->ViewSize) > pDevExt->pPrimary->u.primary.ulMaxFrameBufferSize) ) {
    13411341
    1342                 dprintf(("IOCTL_VIDEO_SHARE_VIDEO_MEMORY - ERROR_INVALID_PARAMETER %x:%x size %x\n", pShareMemory->ViewOffset, pShareMemory->ViewSize, pDevExt->pPrimary->u.primary.ulMaxFrameBufferSize));
     1342                dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_SHARE_VIDEO_MEMORY - ERROR_INVALID_PARAMETER %x:%x size %x\n", pShareMemory->ViewOffset, pShareMemory->ViewSize, pDevExt->pPrimary->u.primary.ulMaxFrameBufferSize));
    13431343                RequestPacket->StatusBlock->Status = ERROR_INVALID_PARAMETER;
    13441344                Result = FALSE;
     
    13551355            status = VideoPortMapMemory(HwDeviceExtension, shareAddress, &sharedViewSize, &inIoSpace, &virtualAddress);
    13561356            if (status != NO_ERROR)
    1357                 dprintf(("VideoPortMapMemory failed with %x\n", status));
     1357                dprintf(("VBoxVideo::VBoxVideoStartIO: VideoPortMapMemory failed with %x\n", status));
    13581358            Result = (status == NO_ERROR);
    13591359
     
    13701370            VP_STATUS status;
    13711371
    1372             dprintf(("IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY\n"));
    1373 
    1374             if (RequestPacket->InputBufferLength < sizeof(VIDEO_SHARE_MEMORY)) 
    1375             {
    1376                 dprintf(("IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY: ERROR_INSUFFICIENT_BUFFER\n"));
     1372            dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY\n"));
     1373
     1374            if (RequestPacket->InputBufferLength < sizeof(VIDEO_SHARE_MEMORY))
     1375            {
     1376                dprintf(("VBoxVideo::VBoxVideoStartIO: IOCTL_VIDEO_UNSHARE_VIDEO_MEMORY: ERROR_INSUFFICIENT_BUFFER\n"));
    13771377                RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
    13781378                Result = FALSE;
     
    13841384            status = VideoPortUnmapMemory(HwDeviceExtension, pShareMemory->RequestedVirtualAddress, pShareMemory->ProcessHandle);
    13851385            if (status != NO_ERROR)
    1386                 dprintf(("VideoPortUnmapMemory failed with %x\n", status));
     1386                dprintf(("VBoxVideo::VBoxVideoStartIO: VideoPortUnmapMemory failed with %x\n", status));
    13871387            Result = (status == NO_ERROR);
    13881388            break;
     
    14711471
    14721472                if (!Result)
    1473                     dprintf(("VBoxVideo::VBoxVideoStartIO: could not hide hardware pointer -> fallback\n"));
     1473                    dprintf(("VBoxVideo::VBoxVideoStartIO: Could not hide hardware pointer -> fallback\n"));
    14741474            } else
    14751475            {
     
    14991499
    15001500                if (!Result)
    1501                     dprintf(("VBoxVideo::VBoxVideoStartIO: could not hide hardware pointer -> fallback\n"));
     1501                    dprintf(("VBoxVideo::VBoxVideoStartIO: Could not hide hardware pointer -> fallback\n"));
    15021502            } else
    15031503            {
     
    15411541                Result = vboxUpdatePointerShape(pPointerAttributes, RequestPacket->InputBufferLength);
    15421542                if (!Result)
    1543                     dprintf(("VBoxVideo::VBoxVideoStartIO: could not set hardware pointer -> fallback\n"));
     1543                    dprintf(("VBoxVideo::VBoxVideoStartIO: Could not set hardware pointer -> fallback\n"));
    15441544            } else
    15451545            {
    1546                 dprintf(("VBoxVideo::VBoxVideoStartIO: fallback to software pointer\n"));
     1546                dprintf(("VBoxVideo::VBoxVideoStartIO: Fallback to software pointer\n"));
    15471547                // fallback to software pointer
    15481548                RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
     
    15901590            if (RequestPacket->OutputBufferLength < sizeof(VIDEO_POINTER_POSITION))
    15911591            {
    1592                 dprintf(("VBoxVideo::VBoxVideoStartIO: output buffer too small!\n"));
     1592                dprintf(("VBoxVideo::VBoxVideoStartIO: Output buffer too small!\n"));
    15931593                RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
    15941594                return TRUE;
     
    16251625            if (RequestPacket->OutputBufferLength < sizeof(VIDEO_POINTER_CAPABILITIES))
    16261626            {
    1627                 dprintf(("VBoxVideo::VBoxVideoStartIO: output buffer too small!\n"));
     1627                dprintf(("VBoxVideo::VBoxVideoStartIO: Output buffer too small!\n"));
    16281628                RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
    16291629                return TRUE;
     
    16841684            if (RequestPacket->OutputBufferLength < sizeof(QUERYDISPLAYINFORESULT))
    16851685            {
    1686                 dprintf(("VBoxVideo::VBoxVideoStartIO: output buffer too small: %d needed: %d!!!\n",
     1686                dprintf(("VBoxVideo::VBoxVideoStartIO: Output buffer too small: %d needed: %d!!!\n",
    16871687                         RequestPacket->OutputBufferLength, sizeof(QUERYDISPLAYINFORESULT)));
    16881688                RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
     
    16911691
    16921692            QUERYDISPLAYINFORESULT *pDispInfo = (QUERYDISPLAYINFORESULT *)RequestPacket->OutputBuffer;
    1693            
     1693
    16941694            pDispInfo->iDevice = pDevExt->iDevice;
    16951695            pDispInfo->u32DisplayInfoSize = pDevExt->pPrimary->u.primary.ulDisplayInformationSize;
     
    17101710            if (RequestPacket->InputBufferLength < sizeof(ULONG))
    17111711            {
    1712                 dprintf(("VBoxVideo::VBoxVideoStartIO: input buffer too small: %d needed: %d!!!\n",
     1712                dprintf(("VBoxVideo::VBoxVideoStartIO: Input buffer too small: %d needed: %d!!!\n",
    17131713                         RequestPacket->InputBufferLength, sizeof(ULONG)));
    17141714                RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
     
    17181718            if (RequestPacket->OutputBufferLength < sizeof(VBVAENABLERESULT))
    17191719            {
    1720                 dprintf(("VBoxVideo::VBoxVideoStartIO: output buffer too small: %d needed: %d!!!\n",
     1720                dprintf(("VBoxVideo::VBoxVideoStartIO: Output buffer too small: %d needed: %d!!!\n",
    17211721                         RequestPacket->OutputBufferLength, sizeof(VBVAENABLERESULT)));
    17221722                RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
     
    17531753                ||  RequestPacket->InputBufferLength != cRect*sizeof(RTRECT))
    17541754            {
    1755                 dprintf(("VBoxVideo::IOCTL_VIDEO_VBOX_SETVISIBLEREGION: output buffer too small: %d needed: %d!!!\n",
     1755                dprintf(("VBoxVideo::IOCTL_VIDEO_VBOX_SETVISIBLEREGION: Output buffer too small: %d needed: %d!!!\n",
    17561756                         RequestPacket->OutputBufferLength, sizeof(RTRECT)));
    17571757                RequestPacket->StatusBlock->Status = ERROR_INSUFFICIENT_BUFFER;
     
    17801780                }
    17811781            }
    1782             dprintf(("VBoxVideo: failed with rc=%x (hdr.rc=%x)\n", rc, (req) ? req->header.rc : -1));
     1782            dprintf(("VBoxVideo::VBoxVideoStartIO: Failed with rc=%x (hdr.rc=%x)\n", rc, (req) ? req->header.rc : -1));
    17831783            RequestPacket->StatusBlock->Status = ERROR_INVALID_FUNCTION;
    17841784            return FALSE;
     
    17861786
    17871787        default:
    1788             dprintf(("VBoxVideo::VBoxVideoStartIO: unsupported %p, fn %d(0x%x)\n",
     1788            dprintf(("VBoxVideo::VBoxVideoStartIO: Unsupported %p, fn %d(0x%x)\n",
    17891789                      RequestPacket->IoControlCode,
    17901790                      (RequestPacket->IoControlCode >> 2) & 0xFFF,
     
    17991799        RequestPacket->StatusBlock->Information = 0;
    18001800
    1801 //    dprintf(("VBoxVideo::VBoxVideoStartIO: completed\n"));
     1801//    dprintf(("VBoxVideo::VBoxVideoStartIO: Completed\n"));
    18021802
    18031803    return TRUE;
     
    18321832
    18331833    VbglTerminate ();
    1834    
     1834
    18351835    vboxUnmapAdapterMemory (pDevExt, &pDevExt->u.primary.pvMiniportHeap);
    18361836    vboxUnmapAdapterMemory (pDevExt, &pDevExt->u.primary.pvAdapterInformation);
     
    18651865/**
    18661866 * VBoxVideoSetGraphicsCap
    1867  * 
     1867 *
    18681868 * Tells the host whether or not we currently support graphics in the
    18691869 * additions
     
    18841884        req->u32OrMask = isEnabled ? VMMDEV_GUEST_SUPPORTS_GRAPHICS : 0;
    18851885        req->u32NotMask = isEnabled ? 0 : VMMDEV_GUEST_SUPPORTS_GRAPHICS;
    1886  
     1886
    18871887        rc = VbglGRPerform (&req->header);
    18881888        if (!RT_SUCCESS(rc) || !RT_SUCCESS(req->header.rc))
     
    21942194
    21952195    dprintf(("VBoxVideo::vboxVbvaEnable: VbglQueryVMMDevMemory rc = %d, pVMMDevMemory = %p\n", rc, pVMMDevMemory));
    2196    
     2196
    21972197    if (pDevExt->iDevice > 0)
    21982198    {
     
    22012201        dprintf(("VBoxVideo::vboxVbvaEnable: Skipping for non-primary display %d\n",
    22022202                 pDevExt->iDevice));
    2203        
     2203
    22042204        if (   ulEnable
    22052205            && pPrimaryDevExt->u.primary.ulVbvaEnabled)
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