VirtualBox

source: vbox/trunk/src/VBox/Additions/WINNT/Graphics/Display/driver.h@ 30541

Last change on this file since 30541 was 28800, checked in by vboxsync, 15 years ago

Automated rebranding to Oracle copyright/license strings via filemuncher
  • Property svn:eol-style set to native
  • Property svn:keywords set to Author Date Id Revision
File size: 17.1 KB
Line 
1/******************************Module*Header*******************************\
2*
3 * Copyright (C) 2006-2007 Oracle Corporation
4 *
5 * This file is part of VirtualBox Open Source Edition (OSE), as
6 * available from http://www.virtualbox.org. This file is free software;
7 * you can redistribute it and/or modify it under the terms of the GNU
8 * General Public License (GPL) as published by the Free Software
9 * Foundation, in version 2 as it comes in the "COPYING" file of the
10 * VirtualBox OSE distribution. VirtualBox OSE is distributed in the
11 * hope that it will be useful, but WITHOUT ANY WARRANTY of any kind.
12*/
13/*
14* Based in part on Microsoft DDK sample code
15*
16* *******************
17* * GDI SAMPLE CODE *
18* *******************
19*
20* Module Name: driver.h
21*
22* contains prototypes for the frame buffer driver.
23*
24* Copyright (c) 1992-1998 Microsoft Corporation
25\**************************************************************************/
26
27#include "stddef.h"
28#include <stdarg.h>
29#include "windef.h"
30#include "wingdi.h"
31#include "winddi.h"
32#include "devioctl.h"
33#include "ntddvdeo.h"
34#include "debug.h"
35
36#include "../Miniport/vboxioctl.h"
37
38#include <VBox/VBoxVideo.h>
39#ifdef VBOX_WITH_VIDEOHWACCEL
40#include <iprt/asm.h>
41#endif
42
43/* Forward declaration. */
44struct _PDEV;
45typedef struct _PDEV PDEV;
46typedef PDEV *PPDEV;
47
48typedef struct _VBOXDISPLAYINFO
49{
50 VBOXVIDEOINFOHDR hdrLink;
51 VBOXVIDEOINFOLINK link;
52 VBOXVIDEOINFOHDR hdrScreen;
53 VBOXVIDEOINFOSCREEN screen;
54 VBOXVIDEOINFOHDR hdrHostEvents;
55 VBOXVIDEOINFOHOSTEVENTS hostEvents;
56 VBOXVIDEOINFOHDR hdrEnd;
57} VBOXDISPLAYINFO;
58
59#include "vbvavrdp.h"
60#include "vrdpbmp.h"
61
62/* Saved screen bits information. */
63typedef struct _SSB
64{
65 ULONG ident; /* 1 based index in the stack = the handle returned by DrvSaveScreenBits (SS_SAVE) */
66 BYTE *pBuffer; /* Buffer where screen bits are saved. */
67} SSB;
68
69/* VRAM
70 * | | | | |
71 * 0+framebuffer+ddraw heap+VBVA buffer+displayinfo=cScreenSize
72 */
73typedef struct _VRAMLAYOUT
74{
75 ULONG cbVRAM;
76
77 ULONG offFrameBuffer;
78 ULONG cbFrameBuffer;
79
80 ULONG offDDRAWHeap; //@todo
81 ULONG cbDDRAWHeap;
82
83 ULONG offVBVABuffer;
84 ULONG cbVBVABuffer;
85
86 ULONG offDisplayInformation;
87 ULONG cbDisplayInformation;
88} VRAMLAYOUT;
89
90typedef struct
91{
92 PPDEV ppdev;
93} VBOXSURF, *PVBOXSURF;
94
95#ifdef VBOX_WITH_VIDEOHWACCEL
96typedef struct _VBOXVHWAREGION
97{
98 RECTL Rect;
99 bool bValid;
100}VBOXVHWAREGION, *PVBOXVHWAREGION;
101
102typedef struct _VBOXVHWASURFDESC
103{
104 VBOXVHWA_SURFHANDLE hHostHandle;
105 volatile uint32_t cPendingBltsSrc;
106 volatile uint32_t cPendingBltsDst;
107 volatile uint32_t cPendingFlipsCurr;
108 volatile uint32_t cPendingFlipsTarg;
109#ifdef DEBUG
110 volatile uint32_t cFlipsCurr;
111 volatile uint32_t cFlipsTarg;
112#endif
113// uint32_t cBitsPerPixel;
114 bool bVisible;
115 VBOXVHWAREGION UpdatedMemRegion;
116 VBOXVHWAREGION NonupdatedMemRegion;
117}VBOXVHWASURFDESC, *PVBOXVHWASURFDESC;
118
119typedef struct _VBOXVHWAINFO
120{
121 uint32_t caps;
122 uint32_t caps2;
123 uint32_t colorKeyCaps;
124 uint32_t stretchCaps;
125 uint32_t surfaceCaps;
126 uint32_t numOverlays;
127 uint32_t numFourCC;
128 HGSMIOFFSET FourCC;
129 ULONG_PTR offVramBase;
130 BOOLEAN bVHWAEnabled;
131 BOOLEAN bVHWAInited;
132} VBOXVHWAINFO;
133#endif
134
135struct _PDEV
136{
137 HANDLE hDriver; // Handle to \Device\Screen
138 HDEV hdevEng; // Engine's handle to PDEV
139 HSURF hsurfScreenBitmap; // Engine's handle to VRAM screen bitmap surface
140 SURFOBJ *psoScreenBitmap; // VRAM screen bitmap surface
141 HSURF hsurfScreen; // Engine's handle to VRAM screen device surface
142 ULONG ulBitmapType;
143 HPALETTE hpalDefault; // Handle to the default palette for device.
144 PBYTE pjScreen; // This is pointer to base screen address
145 ULONG cxScreen; // Visible screen width
146 ULONG cyScreen; // Visible screen height
147 POINTL ptlOrg; // Where this display is anchored in
148 // the virtual desktop.
149 POINTL ptlDevOrg; // Device origin for DualView (0,0 for primary view).
150 ULONG ulMode; // Mode the mini-port driver is in.
151 LONG lDeltaScreen; // Distance from one scan to the next.
152
153 PVOID pOffscreenList; // linked list of DCI offscreen surfaces.
154 FLONG flRed; // For bitfields device, Red Mask
155 FLONG flGreen; // For bitfields device, Green Mask
156 FLONG flBlue; // For bitfields device, Blue Mask
157 ULONG cPaletteShift; // number of bits the 8-8-8 palette must
158 // be shifted by to fit in the hardware
159 // palette.
160 ULONG ulBitCount; // # of bits per pel 8,16,24,32 are only supported.
161 POINTL ptlHotSpot; // adjustment for pointer hot spot
162 VIDEO_POINTER_CAPABILITIES PointerCapabilities; // HW pointer abilities
163 PVIDEO_POINTER_ATTRIBUTES pPointerAttributes; // hardware pointer attributes
164 DWORD cjPointerAttributes; // Size of buffer allocated
165 BOOL fHwCursorActive; // Are we currently using the hw cursor
166 PALETTEENTRY *pPal; // If this is pal managed, this is the pal
167 BOOL bSupportDCI; // Does the miniport support DCI?
168 FLONG flHooks;
169
170#ifndef VBOX_WITH_HGSMI
171 VBVAENABLERESULT vbva;
172 uint32_t u32VRDPResetFlag;
173#endif /* !VBOX_WITH_HGSMI */
174 BOOL fHwBufferOverflow;
175 VBVARECORD *pRecord;
176 VRDPBC cache;
177
178 ULONG cSSB; // Number of active saved screen bits records in the following array.
179 SSB aSSB[4]; // LIFO type stack for saved screen areas.
180
181#ifndef VBOX_WITH_HGSMI
182 VBOXDISPLAYINFO *pInfo;
183 BOOLEAN bVBoxVideoSupported;
184#endif /* !VBOX_WITH_HGSMI */
185 ULONG iDevice;
186 VRAMLAYOUT layout;
187
188 PVBOXSURF pdsurfScreen;
189
190#ifdef VBOX_WITH_DDRAW
191 BOOL bDdExclusiveMode;
192 DWORD dwNewDDSurfaceOffset;
193 DWORD cHeaps;
194 VIDEOMEMORY* pvmList;
195 struct {
196 DWORD bLocked;
197 RECTL rArea;
198 } ddLock;
199#endif /* VBOX_WITH_DDRAW */
200
201#ifdef VBOX_WITH_HGSMI
202 BOOLEAN bHGSMISupported;
203 HGSMIHEAP hgsmiDisplayHeap;
204 VBVABUFFER *pVBVA; /* Pointer to the pjScreen + layout->offVBVABuffer. NULL if VBVA is not enabled. */
205
206 HVBOXVIDEOHGSMI hMpHGSMI; /* context handler passed to miniport HGSMI callbacks */
207 PFNVBOXVIDEOHGSMICOMPLETION pfnHGSMICommandComplete; /* called to complete the command we receive from the miniport */
208 PFNVBOXVIDEOHGSMICOMMANDS pfnHGSMIRequestCommands; /* called to requests the commands posted to us from the host */
209
210 RTIOPORT IOPortGuestCommand;
211
212 PVOID pVideoPortContext;
213 VBOXVIDEOPORTPROCS VideoPortProcs;
214#endif /* VBOX_WITH_HGSMI */
215
216#ifdef VBOX_WITH_VIDEOHWACCEL
217 VBOXVHWAINFO vhwaInfo;
218#endif
219};
220
221#ifdef VBOX_WITH_OPENGL
222typedef struct
223{
224 DWORD dwVersion;
225 DWORD dwDriverVersion;
226 WCHAR szDriverName[256];
227} OPENGL_INFO, *POPENGL_INFO;
228#endif
229
230#ifndef VBOX_WITH_HGSMI
231/* The global semaphore handle for all driver instances. */
232extern HSEMAPHORE ghsemHwBuffer;
233#endif /* !VBOX_WITH_HGSMI */
234
235
236extern BOOL g_bOnNT40;
237
238DWORD getAvailableModes(HANDLE, PVIDEO_MODE_INFORMATION *, DWORD *);
239BOOL bInitPDEV(PPDEV, PDEVMODEW, GDIINFO *, DEVINFO *);
240BOOL bInitSURF(PPDEV, BOOL);
241BOOL bInitPaletteInfo(PPDEV, DEVINFO *);
242BOOL bInitPointer(PPDEV, DEVINFO *);
243BOOL bInit256ColorPalette(PPDEV);
244BOOL bInitNotificationThread(PPDEV);
245VOID vStopNotificationThread (PPDEV);
246VOID vDisablePalette(PPDEV);
247VOID vDisableSURF(PPDEV);
248
249#define MAX_CLUT_SIZE (sizeof(VIDEO_CLUT) + (sizeof(ULONG) * 256))
250
251//
252// Determines the size of the DriverExtra information in the DEVMODE
253// structure passed to and from the display driver.
254//
255
256#define DRIVER_EXTRA_SIZE 0
257
258#define DLL_NAME L"VBoxDisp" // Name of the DLL in UNICODE
259#define STANDARD_DEBUG_PREFIX "VBOXDISP: " // All debug output is prefixed
260#define ALLOC_TAG 'bvDD' // Four byte tag (characters in
261 // reverse order) used for memory
262 // allocations
263
264// VBOX
265typedef struct _CLIPRECTS {
266 ULONG c;
267 RECTL arcl[64];
268} CLIPRECTS;
269
270typedef struct _VRDPCLIPRECTS
271{
272 RECTL rclDstOrig; /* Original bounding rectancle. */
273 RECTL rclDst; /* Bounding rectangle of all rects. */
274 CLIPRECTS rects; /* Rectangles to update. */
275} VRDPCLIPRECTS;
276
277
278BOOL vboxVbvaEnable (PPDEV ppdev);
279void vboxVbvaDisable (PPDEV ppdev);
280
281BOOL vboxHwBufferBeginUpdate (PPDEV ppdev);
282void vboxHwBufferEndUpdate (PPDEV ppdev);
283
284BOOL vboxWrite (PPDEV ppdev, const void *pv, uint32_t cb);
285
286BOOL vboxOrderSupported (PPDEV ppdev, unsigned code);
287
288void VBoxProcessDisplayInfo(PPDEV ppdev);
289void VBoxUpdateDisplayInfo (PPDEV ppdev);
290
291void drvLoadEng (void);
292
293#ifdef VBOX_WITH_HGSMI
294void vboxVBVAHostCommandComplete(PPDEV ppdev, VBVAHOSTCMD * pCmd);
295
296 #ifdef VBOX_WITH_VIDEOHWACCEL
297
298DECLINLINE(uint64_t) vboxVHWAVramOffsetFromPDEV(PPDEV pDev, ULONG_PTR offPdev)
299{
300 return (uint64_t)(pDev->vhwaInfo.offVramBase + offPdev);
301}
302
303#define VBOXDD_CHECKFLAG(_v, _f) ((_v) & (_f)) == (_f)
304
305typedef DECLCALLBACK(void) FNVBOXVHWACMDCOMPLETION(PPDEV ppdev, VBOXVHWACMD * pCmd, void * pContext);
306typedef FNVBOXVHWACMDCOMPLETION *PFNVBOXVHWACMDCOMPLETION;
307
308void vboxVHWARectUnited(RECTL * pDst, RECTL * pRect1, RECTL * pRect2);
309bool vboxVHWARectIsEmpty(RECTL * pRect);
310bool vboxVHWARectIntersect(RECTL * pRect1, RECTL * pRect2);
311bool vboxVHWARectInclude(RECTL * pRect1, RECTL * pRect2);
312bool vboxVHWARegionIntersects(PVBOXVHWAREGION pReg, RECTL * pRect);
313bool vboxVHWARegionIncludes(PVBOXVHWAREGION pReg, RECTL * pRect);
314bool vboxVHWARegionIncluded(PVBOXVHWAREGION pReg, RECTL * pRect);
315void vboxVHWARegionSet(PVBOXVHWAREGION pReg, RECTL * pRect);
316void vboxVHWARegionAdd(PVBOXVHWAREGION pReg, RECTL * pRect);
317void vboxVHWARegionInit(PVBOXVHWAREGION pReg);
318void vboxVHWARegionClear(PVBOXVHWAREGION pReg);
319bool vboxVHWARegionValid(PVBOXVHWAREGION pReg);
320void vboxVHWARegionTrySubstitute(PVBOXVHWAREGION pReg, const RECTL *pRect);
321
322VBOXVHWACMD* vboxVHWACommandCreate (PPDEV ppdev, VBOXVHWACMD_TYPE enmCmd, VBOXVHWACMD_LENGTH cbCmd);
323void vboxVHWACommandFree (PPDEV ppdev, VBOXVHWACMD* pCmd);
324DECLINLINE(void) vbvaVHWACommandRelease (PPDEV ppdev, VBOXVHWACMD* pCmd)
325{
326 uint32_t cRefs = ASMAtomicDecU32(&pCmd->cRefs);
327 Assert(cRefs < UINT32_MAX / 2);
328 if(!cRefs)
329 {
330 vboxVHWACommandFree(ppdev, pCmd);
331 }
332}
333
334DECLINLINE(void) vbvaVHWACommandRetain (PPDEV ppdev, VBOXVHWACMD* pCmd)
335{
336 ASMAtomicIncU32(&pCmd->cRefs);
337}
338
339BOOL vboxVHWACommandSubmit (PPDEV ppdev, VBOXVHWACMD* pCmd);
340void vboxVHWACommandSubmitAsynch (PPDEV ppdev, VBOXVHWACMD* pCmd, PFNVBOXVHWACMDCOMPLETION pfnCompletion, void * pContext);
341void vboxVHWACommandSubmitAsynchByEvent (PPDEV ppdev, VBOXVHWACMD* pCmd, VBOXPEVENT pEvent);
342void vboxVHWACommandCheckHostCmds(PPDEV ppdev);
343void vboxVHWACommandSubmitAsynchAndComplete (PPDEV ppdev, VBOXVHWACMD* pCmd);
344
345int vboxVHWAInitHostInfo1(PPDEV ppdev);
346int vboxVHWAInitHostInfo2(PPDEV ppdev, DWORD *pFourCC);
347
348VBOXVHWACMD_QUERYINFO1* vboxVHWAQueryHostInfo1(PPDEV ppdev);
349void vboxVHWAFreeHostInfo1(PPDEV ppdev, VBOXVHWACMD_QUERYINFO1* pInfo);
350VBOXVHWACMD_QUERYINFO2* vboxVHWAQueryHostInfo2(PPDEV ppdev, uint32_t numFourCC);
351void vboxVHWAFreeHostInfo2(PPDEV ppdev, VBOXVHWACMD_QUERYINFO2* pInfo);
352
353void vboxVHWAInit();
354void vboxVHWATerm();
355uint32_t vboxVHWAUnsupportedDDCAPS(uint32_t caps);
356uint32_t vboxVHWAUnsupportedDDSCAPS(uint32_t caps);
357uint32_t vboxVHWAUnsupportedDDPFS(uint32_t caps);
358uint32_t vboxVHWASupportedDDCAPS(uint32_t caps);
359uint32_t vboxVHWASupportedDDSCAPS(uint32_t caps);
360uint32_t vboxVHWASupportedDDPFS(uint32_t caps);
361
362uint32_t vboxVHWAUnsupportedDDCEYCAPS(uint32_t caps);
363uint32_t vboxVHWASupportedDDCEYCAPS(uint32_t caps);
364
365uint32_t vboxVHWAToDDBLTs(uint32_t caps);
366uint32_t vboxVHWAFromDDBLTs(uint32_t caps);
367
368uint32_t vboxVHWAFromDDCAPS2(uint32_t caps);
369uint32_t vboxVHWAToDDCAPS2(uint32_t caps);
370
371void vboxVHWAFromDDBLTFX(VBOXVHWA_BLTFX *pVHWABlt, DDBLTFX *pDdBlt);
372
373void vboxVHWAFromDDCOLORKEY(VBOXVHWA_COLORKEY *pVHWACKey, DDCOLORKEY *pDdCKey);
374
375uint32_t vboxVHWAFromDDOVERs(uint32_t caps);
376uint32_t vboxVHWAToDDOVERs(uint32_t caps);
377uint32_t vboxVHWAFromDDCKEYs(uint32_t caps);
378uint32_t vboxVHWAToDDCKEYs(uint32_t caps);
379
380void vboxVHWAFromDDOVERLAYFX(VBOXVHWA_OVERLAYFX *pVHWAOverlay, DDOVERLAYFX *pDdOverlay);
381
382uint32_t vboxVHWAFromDDCAPS(uint32_t caps);
383uint32_t vboxVHWAToDDCAPS(uint32_t caps);
384uint32_t vboxVHWAFromDDSCAPS(uint32_t caps);
385uint32_t vboxVHWAToDDSCAPS(uint32_t caps);
386uint32_t vboxVHWAFromDDPFS(uint32_t caps);
387uint32_t vboxVHWAToDDPFS(uint32_t caps);
388uint32_t vboxVHWAFromDDCKEYCAPS(uint32_t caps);
389uint32_t vboxVHWAToDDCKEYCAPS(uint32_t caps);
390int vboxVHWAFromDDPIXELFORMAT(VBOXVHWA_PIXELFORMAT *pVHWAFormat, DDPIXELFORMAT *pDdFormat);
391int vboxVHWAFromDDSURFACEDESC(VBOXVHWA_SURFACEDESC *pVHWADesc, DDSURFACEDESC *pDdDesc);
392void vboxVHWAFromRECTL(VBOXVHWA_RECTL *pDst, RECTL *pSrc);
393PVBOXVHWASURFDESC vboxVHWASurfDescAlloc();
394void vboxVHWASurfDescFree(PVBOXVHWASURFDESC pDesc);
395
396int vboxVHWAEnable(PPDEV ppdev);
397int vboxVHWADisable(PPDEV ppdev);
398
399 #endif
400#endif
401
402BOOL bIsScreenSurface (SURFOBJ *pso);
403
404__inline SURFOBJ *getSurfObj (SURFOBJ *pso)
405{
406 if (pso)
407 {
408 PPDEV ppdev = (PPDEV)pso->dhpdev;
409
410 if (ppdev)
411 {
412 if (ppdev->psoScreenBitmap && pso->hsurf == ppdev->hsurfScreen)
413 {
414 /* Convert the device PSO to the bitmap PSO which can be passed to Eng*. */
415 pso = ppdev->psoScreenBitmap;
416 }
417 }
418 }
419
420 return pso;
421}
422
423#define CONV_SURF(_pso) getSurfObj (_pso)
424
425__inline int format2BytesPerPixel(const SURFOBJ *pso)
426{
427 switch (pso->iBitmapFormat)
428 {
429 case BMF_16BPP: return 2;
430 case BMF_24BPP: return 3;
431 case BMF_32BPP: return 4;
432 }
433
434 return 0;
435}
436
437#ifdef VBOX_VBVA_ADJUST_RECT
438void vrdpAdjustRect (SURFOBJ *pso, RECTL *prcl);
439BOOL vbvaFindChangedRect (SURFOBJ *psoDest, SURFOBJ *psoSrc, RECTL *prclDest, POINTL *pptlSrc);
440#endif /* VBOX_VBVA_ADJUST_RECT */
441
442void vrdpReportDirtyRect (PPDEV ppdev, RECTL *prcl);
443void vbvaReportDirtyRect (PPDEV ppdev, RECTL *prcl);
444
445#define VRDP_TEXT_MAX_GLYPH_SIZE 0x100
446#define VRDP_TEXT_MAX_GLYPHS 0xfe
447
448BOOL vboxReportText (PPDEV ppdev,
449 VRDPCLIPRECTS *pClipRects,
450 STROBJ *pstro,
451 FONTOBJ *pfo,
452 RECTL *prclOpaque,
453 ULONG ulForeRGB,
454 ULONG ulBackRGB
455 );
456
457BOOL vrdpReportOrderGeneric (PPDEV ppdev,
458 const VRDPCLIPRECTS *pClipRects,
459 const void *pvOrder,
460 unsigned cbOrder,
461 unsigned code);
462
463
464#include <iprt/assert.h>
465
466#ifdef DEBUG
467#define VBVA_ASSERT(expr) \
468 do { \
469 if (!(expr)) \
470 { \
471 RTAssertMsg1Weak(#expr, __LINE__, __FILE__, __PRETTY_FUNCTION__); \
472 RTAssertMsg2Weak("!!!\n"); \
473 } \
474 } while (0)
475#else
476#define VBVA_ASSERT(expr) do {} while (0)
477#endif
478
479#ifdef STAT_sunlover
480extern ULONG gStatCopyBitsOffscreenToScreen;
481extern ULONG gStatCopyBitsScreenToScreen;
482extern ULONG gStatBitBltOffscreenToScreen;
483extern ULONG gStatBitBltScreenToScreen;
484extern ULONG gStatUnchangedOffscreenToScreen;
485extern ULONG gStatUnchangedOffscreenToScreenCRC;
486extern ULONG gStatNonTransientEngineBitmaps;
487extern ULONG gStatTransientEngineBitmaps;
488extern ULONG gStatUnchangedBitmapsCRC;
489extern ULONG gStatUnchangedBitmapsDeviceCRC;
490extern ULONG gStatBitmapsCRC;
491extern ULONG gStatBitBltScreenPattern;
492extern ULONG gStatBitBltScreenSquare;
493extern ULONG gStatBitBltScreenPatternReported;
494extern ULONG gStatBitBltScreenSquareReported;
495extern ULONG gStatCopyBitsScreenSquare;
496
497extern ULONG gStatEnablePDEV;
498extern ULONG gStatCompletePDEV;
499extern ULONG gStatDisablePDEV;
500extern ULONG gStatEnableSurface;
501extern ULONG gStatDisableSurface;
502extern ULONG gStatAssertMode;
503extern ULONG gStatDisableDriver;
504extern ULONG gStatCreateDeviceBitmap;
505extern ULONG gStatDeleteDeviceBitmap;
506extern ULONG gStatDitherColor;
507extern ULONG gStatStrokePath;
508extern ULONG gStatFillPath;
509extern ULONG gStatStrokeAndFillPath;
510extern ULONG gStatPaint;
511extern ULONG gStatBitBlt;
512extern ULONG gStatCopyBits;
513extern ULONG gStatStretchBlt;
514extern ULONG gStatSetPalette;
515extern ULONG gStatTextOut;
516extern ULONG gStatSetPointerShape;
517extern ULONG gStatMovePointer;
518extern ULONG gStatLineTo;
519extern ULONG gStatSynchronize;
520extern ULONG gStatGetModes;
521extern ULONG gStatGradientFill;
522extern ULONG gStatStretchBltROP;
523extern ULONG gStatPlgBlt;
524extern ULONG gStatAlphaBlend;
525extern ULONG gStatTransparentBlt;
526
527void statPrint (void);
528
529#define STATDRVENTRY(a, b) do { if (bIsScreenSurface (b)) gStat##a++; } while (0)
530#define STATPRINT do { statPrint (); } while (0)
531#else
532#define STATDRVENTRY(a, b)
533#define STATPRINT
534#endif /* STAT_sunlover */
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