Remove readmask from screen block/wakeup handler

With no users of the interface needing the readmask anymore, we can
remove it from the argument passed to these functions.

Signed-off-by: Keith Packard <keithp@keithp.com>
Reviewed-by: Adam Jackson <ajax@redhat.com>

22 files changed, 77 insertions, 131 deletions

diff --git a/composite/compalloc.c b/composite/compalloc.c
index 8daded0a5..e6a203f6b 100644
--- a/composite/compalloc.c
+++ b/composite/compalloc.c
@@ -55,13 +55,13 @@ compScreenUpdate(ScreenPtr pScreen)
 }
 
 static void
-compBlockHandler(ScreenPtr pScreen, void *pTimeout, void *pReadmask)
+compBlockHandler(ScreenPtr pScreen, void *pTimeout)
 {
     CompScreenPtr cs = GetCompScreen(pScreen);
 
     pScreen->BlockHandler = cs->BlockHandler;
     compScreenUpdate(pScreen);
-    (*pScreen->BlockHandler) (pScreen, pTimeout, pReadmask);
+    (*pScreen->BlockHandler) (pScreen, pTimeout);
 
     /* Next damage will restore the block handler */
     cs->BlockHandler = NULL;
diff --git a/dix/dixutils.c b/dix/dixutils.c
index 3d2e7a3c5..d72892943 100644
--- a/dix/dixutils.c
+++ b/dix/dixutils.c
@@ -385,16 +385,13 @@ BlockHandler(void *pTimeout, void *pReadmask)
     ++inHandler;
     for (i = 0; i < numHandlers; i++)
         if (!handlers[i].deleted)
-            (*handlers[i].BlockHandler) (handlers[i].blockData,
-                                         pTimeout, pReadmask);
+            (*handlers[i].BlockHandler) (handlers[i].blockData, pTimeout, pReadmask);
 
     for (i = 0; i < screenInfo.numGPUScreens; i++)
-        (*screenInfo.gpuscreens[i]->BlockHandler) (screenInfo.gpuscreens[i],
-                                                   pTimeout, pReadmask);
+        (*screenInfo.gpuscreens[i]->BlockHandler) (screenInfo.gpuscreens[i], pTimeout);
 
     for (i = 0; i < screenInfo.numScreens; i++)
-        (*screenInfo.screens[i]->BlockHandler) (screenInfo.screens[i],
-                                                pTimeout, pReadmask);
+        (*screenInfo.screens[i]->BlockHandler) (screenInfo.screens[i], pTimeout);
 
     if (handlerDeleted) {
         for (i = 0; i < numHandlers;)
@@ -422,15 +419,12 @@ WakeupHandler(int result, void *pReadmask)
 
     ++inHandler;
     for (i = 0; i < screenInfo.numScreens; i++)
-        (*screenInfo.screens[i]->WakeupHandler) (screenInfo.screens[i],
-                                                 result, pReadmask);
+        (*screenInfo.screens[i]->WakeupHandler) (screenInfo.screens[i], result);
     for (i = 0; i < screenInfo.numGPUScreens; i++)
-        (*screenInfo.gpuscreens[i]->WakeupHandler) (screenInfo.gpuscreens[i],
-                                                    result, pReadmask);
+        (*screenInfo.gpuscreens[i]->WakeupHandler) (screenInfo.gpuscreens[i], result);
     for (i = numHandlers - 1; i >= 0; i--)
         if (!handlers[i].deleted)
-            (*handlers[i].WakeupHandler) (handlers[i].blockData,
-                                          result, pReadmask);
+            (*handlers[i].WakeupHandler) (handlers[i].blockData, result, pReadmask);
     if (handlerDeleted) {
         for (i = 0; i < numHandlers;)
             if (handlers[i].deleted) {
diff --git a/doc/Xinput.xml b/doc/Xinput.xml
index 083b10908..0e7fbda72 100644
--- a/doc/Xinput.xml
+++ b/doc/Xinput.xml
@@ -210,7 +210,7 @@ A sample InitInput implementation is shown below.
 <literallayout class="monospaced">
 InitInput(argc,argv)
     {
-    int i, numdevs, ReadInput();
+    int i, numdevs;
     DeviceIntPtr dev;
     LocalDevice localdevs[LOCAL_MAX_DEVS];
     DeviceProc kbdproc, ptrproc, extproc;
@@ -224,12 +224,6 @@ InitInput(argc,argv)
     open_input_devices (&amp;numdevs, localdevs);
 
     /**************************************************************
-     * Register a WakeupHandler to handle input when it is generated.
-     ***************************************************************/
-
-    RegisterBlockAndWakeupHandlers (NoopDDA, ReadInput, NULL);
-
-    /**************************************************************
      * Register the input devices with DIX.
      ***************************************************************/
 
diff --git a/doc/Xserver-spec.xml b/doc/Xserver-spec.xml
index 72a544b55..7867544e4 100644
--- a/doc/Xserver-spec.xml
+++ b/doc/Xserver-spec.xml
@@ -674,30 +674,22 @@ If WaitForSomething() decides it is about to do something that might block
 routine called BlockHandler().
 <blockquote>
 <programlisting>
-	void BlockHandler(pTimeout, pReadmask)
-		pointer pTimeout;
-		pointer pReadmask;
+	void BlockHandler(void *pTimeout)
 </programlisting>
 </blockquote>
 The types of the arguments are for agreement between the OS and DDX
 implementations,  but the pTimeout is a pointer to the information
-determining how long the block is allowed to last,  and the
-pReadmask is a pointer to the information describing the descriptors
-that will be waited on.
+determining how long the block is allowed to last.
 </para>
 <para>
-In the sample server,  pTimeout is a pointer,  and pReadmask is
-the address of the select() mask for reading.
+In the sample server,  pTimeout is a pointer.
 </para>
 <para>
 The DIX BlockHandler() iterates through the Screens,  for each one calling
 its BlockHandler.  A BlockHandler is declared thus:
 <blockquote>
 <programlisting>
-	void xxxBlockHandler(pScreen, pTimeout, pReadmask)
-		ScreenPtr pScreen;
-		pointer pTimeout;
-		pointer pReadmask;
+	void xxxBlockHandler(ScreenPtr pScreen, void *pTimeout)
 </programlisting>
 </blockquote>
 The arguments are a pointer to the Screen, and the arguments to the
@@ -709,27 +701,20 @@ block,  even if it didn't actually block,  it must call the DIX routine
 WakeupHandler().
 <blockquote>
 <programlisting>
-	void WakeupHandler(result, pReadmask)
-		int result;
-		pointer pReadmask;
+	void WakeupHandler(int result)
 </programlisting>
 </blockquote>
 Once again,  the types are not specified by DIX.  The result is the
-success indicator for the thing that (may have) blocked,
-and the pReadmask is a mask of the descriptors that came active.
-In the sample server,  result is the result from select() (or equivalent
-operating system function),  and pReadmask is
-the address of the select() mask for reading.
+success indicator for the thing that (may have) blocked.
+In the sample server, result is the result from select() (or equivalent
+operating system function).
 </para>
 <para>
 The DIX WakeupHandler() calls each Screen's
 WakeupHandler.  A WakeupHandler is declared thus:
 <blockquote>
 <programlisting>
-	void xxxWakeupHandler(pScreen, result, pReadmask)
-		ScreenPtr pScreen;
-		unsigned long result;
-		pointer pReadmask;
+	void xxxWakeupHandler(ScreenPtr pScreen, int result)
 </programlisting>
 </blockquote>
 The arguments are the Screen, of the Screen, and the arguments to
@@ -741,8 +726,8 @@ block and wakeup handlers (only together) using:
 <blockquote>
 <programlisting>
 	Bool RegisterBlockAndWakeupHandlers (blockHandler, wakeupHandler, blockData)
-		BlockHandlerProcPtr    blockHandler;
-		WakeupHandlerProcPtr   wakeupHandler;
+		ServerBlockHandlerProcPtr    blockHandler;
+		ServerWakeupHandlerProcPtr   wakeupHandler;
 		pointer blockData;
 </programlisting>
 </blockquote>
@@ -752,8 +737,8 @@ memory.  To remove a registered Block handler at other than server reset time
 <blockquote>
 <programlisting>
 	RemoveBlockAndWakeupHandlers (blockHandler, wakeupHandler, blockData)
-		BlockHandlerProcPtr   blockHandler;
-		WakeupHandlerProcPtr  wakeupHandler;
+		ServerBlockHandlerProcPtr   blockHandler;
+		ServerWakeupHandlerProcPtr  wakeupHandler;
 		pointer blockData;
 </programlisting>
 </blockquote>
@@ -761,18 +746,15 @@ All three arguments must match the values passed to
 RegisterBlockAndWakeupHandlers.
 </para>
 <para>
-These registered block handlers are called after the per-screen handlers:
+These registered block handlers are called before the per-screen handlers:
 <blockquote>
 <programlisting>
-	void (*BlockHandler) (blockData, pptv, pReadmask)
-		pointer	blockData;
-		OsTimerPtr pptv;
-		pointer	pReadmask;
+	void (*ServerBlockHandler) (void *blockData, void *pTimeout)
 </programlisting>
 </blockquote>
 </para>
 <para>
-Sometimes block handlers need to adjust the time in a OSTimePtr structure,
+Sometimes block handlers need to adjust the time referenced by pTimeout,
 which on UNIX family systems is generally represented by a struct timeval
 consisting of seconds and microseconds in 32 bit values.
 As a convenience to reduce error prone struct timeval computations which
@@ -780,20 +762,17 @@ require modulus arithmetic and correct overflow behavior in the face of
 millisecond wrapping through 32 bits,
 <blockquote><programlisting>
 
-	void AdjustWaitForDelay(pointer /*waitTime*, unsigned long /* newdelay */)
+	void AdjustWaitForDelay(void *pTimeout, unsigned long newdelay)
 
 </programlisting></blockquote>
 has been provided.
 </para>
 <para>
 Any wakeup handlers registered with RegisterBlockAndWakeupHandlers will
-be called before the Screen handlers:
+be called after the Screen handlers:
 <blockquote><programlisting>
 
-	void (*WakeupHandler) (blockData, err, pReadmask)
-		pointer	blockData;
-		int err;
-		pointer pReadmask;
+	void (*ServerWakeupHandler) (void *blockData, int result)
 </programlisting></blockquote>
 </para>
 <para>
diff --git a/exa/exa.c b/exa/exa.c
index 51d36f3f3..7266b71f9 100644
--- a/exa/exa.c
+++ b/exa/exa.c
@@ -702,8 +702,7 @@ exaCreateScreenResources(ScreenPtr pScreen)
 }
 
 static void
-ExaBlockHandler(ScreenPtr pScreen, void *pTimeout,
-                void *pReadmask)
+ExaBlockHandler(ScreenPtr pScreen, void *pTimeout)
 {
     ExaScreenPriv(pScreen);
 
@@ -712,7 +711,7 @@ ExaBlockHandler(ScreenPtr pScreen, void *pTimeout,
         exaMoveInPixmap_mixed(pExaScr->deferred_mixed_pixmap);
 
     unwrap(pExaScr, pScreen, BlockHandler);
-    (*pScreen->BlockHandler) (pScreen, pTimeout, pReadmask);
+    (*pScreen->BlockHandler) (pScreen, pTimeout);
     wrap(pExaScr, pScreen, BlockHandler, ExaBlockHandler);
 
     /* The rest only applies to classic EXA */
@@ -732,13 +731,12 @@ ExaBlockHandler(ScreenPtr pScreen, void *pTimeout,
 }
 
 static void
-ExaWakeupHandler(ScreenPtr pScreen, unsigned long result,
-                 void *pReadmask)
+ExaWakeupHandler(ScreenPtr pScreen, int result)
 {
     ExaScreenPriv(pScreen);
 
     unwrap(pExaScr, pScreen, WakeupHandler);
-    (*pScreen->WakeupHandler) (pScreen, result, pReadmask);
+    (*pScreen->WakeupHandler) (pScreen, result);
     wrap(pExaScr, pScreen, WakeupHandler, ExaWakeupHandler);
 
     if (result == 0 && pExaScr->numOffscreenAvailable > 1) {
diff --git a/glamor/glamor.c b/glamor/glamor.c
index 867c53dd6..5ba440c83 100644
--- a/glamor/glamor.c
+++ b/glamor/glamor.c
@@ -257,7 +257,7 @@ glamor_block_handler(ScreenPtr screen)
 }
 
 static void
-_glamor_block_handler(ScreenPtr screen, void *timeout, void *readmask)
+_glamor_block_handler(ScreenPtr screen, void *timeout)
 {
     glamor_screen_private *glamor_priv = glamor_get_screen_private(screen);
 
@@ -265,7 +265,7 @@ _glamor_block_handler(ScreenPtr screen, void *timeout, void *readmask)
     glFlush();
 
     screen->BlockHandler = glamor_priv->saved_procs.block_handler;
-    screen->BlockHandler(screen, timeout, readmask);
+    screen->BlockHandler(screen, timeout);
     glamor_priv->saved_procs.block_handler = screen->BlockHandler;
     screen->BlockHandler = _glamor_block_handler;
 }
diff --git a/hw/kdrive/ephyr/ephyr.c b/hw/kdrive/ephyr/ephyr.c
index d7948e8de..4eec72af9 100644
--- a/hw/kdrive/ephyr/ephyr.c
+++ b/hw/kdrive/ephyr/ephyr.c
@@ -347,14 +347,14 @@ ephyrEventWorkProc(ClientPtr client, void *closure)
 }
 
 static void
-ephyrScreenBlockHandler(ScreenPtr pScreen, void *timeout, void *pRead)
+ephyrScreenBlockHandler(ScreenPtr pScreen, void *timeout)
 {
     KdScreenPriv(pScreen);
     KdScreenInfo *screen = pScreenPriv->screen;
     EphyrScrPriv *scrpriv = screen->driver;
 
     pScreen->BlockHandler = scrpriv->BlockHandler;
-    (*pScreen->BlockHandler)(pScreen, timeout, pRead);
+    (*pScreen->BlockHandler)(pScreen, timeout);
     scrpriv->BlockHandler = pScreen->BlockHandler;
     pScreen->BlockHandler = ephyrScreenBlockHandler;
 
diff --git a/hw/kdrive/src/kdrive.h b/hw/kdrive/src/kdrive.h
index e1d2b5927..3c7f2cdf2 100644
--- a/hw/kdrive/src/kdrive.h
+++ b/hw/kdrive/src/kdrive.h
@@ -527,12 +527,10 @@ void
  KdScreenToPointerCoords(int *x, int *y);
 
 void
-
-KdBlockHandler(ScreenPtr pScreen, void *timeout, void *readmask);
+KdBlockHandler(ScreenPtr pScreen, void *timeout);
 
 void
-
-KdWakeupHandler(ScreenPtr pScreen, unsigned long result, void *readmask);
+KdWakeupHandler(ScreenPtr pScreen, int result);
 
 void
  KdDisableInput(void);
diff --git a/hw/kdrive/src/kinput.c b/hw/kdrive/src/kinput.c
index 6ee575cf7..2c396246c 100644
--- a/hw/kdrive/src/kinput.c
+++ b/hw/kdrive/src/kinput.c
@@ -1961,7 +1961,7 @@ _KdEnqueuePointerEvent(KdPointerInfo * pi, int type, int x, int y, int z,
 }
 
 void
-KdBlockHandler(ScreenPtr pScreen, void *timeo, void *readmask)
+KdBlockHandler(ScreenPtr pScreen, void *timeo)
 {
     KdPointerInfo *pi;
     int myTimeout = 0;
@@ -1987,7 +1987,7 @@ KdBlockHandler(ScreenPtr pScreen, void *timeo, void *readmask)
 }
 
 void
-KdWakeupHandler(ScreenPtr pScreen, unsigned long lresult, void *readmask)
+KdWakeupHandler(ScreenPtr pScreen, int result)
 {
     KdPointerInfo *pi;
 
diff --git a/hw/xfree86/common/xf86VGAarbiter.c b/hw/xfree86/common/xf86VGAarbiter.c
index 5cc24298b..29a5f8512 100644
--- a/hw/xfree86/common/xf86VGAarbiter.c
+++ b/hw/xfree86/common/xf86VGAarbiter.c
@@ -265,23 +265,21 @@ VGAarbiterCloseScreen(ScreenPtr pScreen)
 }
 
 static void
-VGAarbiterBlockHandler(ScreenPtr pScreen,
-                       void *pTimeout, void *pReadmask)
+VGAarbiterBlockHandler(ScreenPtr pScreen, void *pTimeout)
 {
     SCREEN_PROLOG(BlockHandler);
     VGAGet(pScreen);
-    pScreen->BlockHandler(pScreen, pTimeout, pReadmask);
+    pScreen->BlockHandler(pScreen, pTimeout);
     VGAPut();
     SCREEN_EPILOG(BlockHandler, VGAarbiterBlockHandler);
 }
 
 static void
-VGAarbiterWakeupHandler(ScreenPtr pScreen, unsigned long result,
-                        void *pReadmask)
+VGAarbiterWakeupHandler(ScreenPtr pScreen, int result)
 {
     SCREEN_PROLOG(WakeupHandler);
     VGAGet(pScreen);
-    pScreen->WakeupHandler(pScreen, result, pReadmask);
+    pScreen->WakeupHandler(pScreen, result);
     VGAPut();
     SCREEN_EPILOG(WakeupHandler, VGAarbiterWakeupHandler);
 }
diff --git a/hw/xfree86/common/xf86VGAarbiterPriv.h b/hw/xfree86/common/xf86VGAarbiterPriv.h
index b832c9a5f..09be10aa3 100644
--- a/hw/xfree86/common/xf86VGAarbiterPriv.h
+++ b/hw/xfree86/common/xf86VGAarbiterPriv.h
@@ -146,10 +146,8 @@ typedef struct _VGAarbiterGC {
 } VGAarbiterGCRec, *VGAarbiterGCPtr;
 
 /* Screen funcs */
-static void VGAarbiterBlockHandler(ScreenPtr pScreen, void *pTimeout,
-                                   void *pReadmask);
-static void VGAarbiterWakeupHandler(ScreenPtr pScreen,
-                                    unsigned long result, void *pReadmask);
+static void VGAarbiterBlockHandler(ScreenPtr pScreen, void *pTimeout);
+static void VGAarbiterWakeupHandler(ScreenPtr pScreen, int result);
 static Bool VGAarbiterCloseScreen(ScreenPtr pScreen);
 static void VGAarbiterGetImage(DrawablePtr pDrawable, int sx, int sy, int w,
                                int h, unsigned int format,
diff --git a/hw/xfree86/dri/dri.c b/hw/xfree86/dri/dri.c
index dbad12fee..d39924646 100644
--- a/hw/xfree86/dri/dri.c
+++ b/hw/xfree86/dri/dri.c
@@ -1676,8 +1676,7 @@ DRIWakeupHandler(void *wakeupData, int result, void *pReadmask)
         DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
 
         if (pDRIPriv && pDRIPriv->pDriverInfo->wrap.WakeupHandler)
-            (*pDRIPriv->pDriverInfo->wrap.WakeupHandler) (pScreen,
-                                                          result, pReadmask);
+            (*pDRIPriv->pDriverInfo->wrap.WakeupHandler) (pScreen, result);
     }
 }
 
@@ -1691,14 +1690,12 @@ DRIBlockHandler(void *blockData, OSTimePtr pTimeout, void *pReadmask)
         DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
 
         if (pDRIPriv && pDRIPriv->pDriverInfo->wrap.BlockHandler)
-            (*pDRIPriv->pDriverInfo->wrap.BlockHandler) (pScreen,
-                                                         pTimeout, pReadmask);
+            (*pDRIPriv->pDriverInfo->wrap.BlockHandler) (pScreen, pTimeout);
     }
 }
 
 void
-DRIDoWakeupHandler(ScreenPtr pScreen,
-                   unsigned long result, void *pReadmask)
+DRIDoWakeupHandler(ScreenPtr pScreen, int result)
 {
     DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
 
@@ -1715,8 +1712,7 @@ DRIDoWakeupHandler(ScreenPtr pScreen,
 }
 
 void
-DRIDoBlockHandler(ScreenPtr pScreen,
-                  void *pTimeout, void *pReadmask)
+DRIDoBlockHandler(ScreenPtr pScreen, void *timeout)
 {
     DRIScreenPrivPtr pDRIPriv = DRI_SCREEN_PRIV(pScreen);
 
diff --git a/hw/xfree86/dri/dri.h b/hw/xfree86/dri/dri.h
index 7e0337fce..c659a207f 100644
--- a/hw/xfree86/dri/dri.h
+++ b/hw/xfree86/dri/dri.h
@@ -269,12 +269,9 @@ extern _X_EXPORT void DRIWakeupHandler(void *wakeupData,
 extern _X_EXPORT void DRIBlockHandler(void *blockData,
                                       OSTimePtr pTimeout, void *pReadmask);
 
-extern _X_EXPORT void DRIDoWakeupHandler(ScreenPtr pScreen,
-                                         unsigned long result,
-                                         void *pReadmask);
+extern _X_EXPORT void DRIDoWakeupHandler(ScreenPtr pScreen, int result);
 
-extern _X_EXPORT void DRIDoBlockHandler(ScreenPtr pScreen,
-                                        void *pTimeout, void *pReadmask);
+extern _X_EXPORT void DRIDoBlockHandler(ScreenPtr pScreen, void *timeout);
 
 extern _X_EXPORT void DRISwapContext(int drmFD, void *oldctx, void *newctx);
 
diff --git a/hw/xfree86/drivers/modesetting/driver.c b/hw/xfree86/drivers/modesetting/driver.c
index 262a8992c..f2620821b 100644
--- a/hw/xfree86/drivers/modesetting/driver.c
+++ b/hw/xfree86/drivers/modesetting/driver.c
@@ -639,12 +639,12 @@ ms_dirty_get_ent(ScreenPtr screen, PixmapPtr slave_dst)
 }
 
 static void
-msBlockHandler(ScreenPtr pScreen, void *pTimeout, void *pReadmask)
+msBlockHandler(ScreenPtr pScreen, void *timeout)
 {
     modesettingPtr ms = modesettingPTR(xf86ScreenToScrn(pScreen));
 
     pScreen->BlockHandler = ms->BlockHandler;
-    pScreen->BlockHandler(pScreen, pTimeout, pReadmask);
+    pScreen->BlockHandler(pScreen, timeout);
     ms->BlockHandler = pScreen->BlockHandler;
     pScreen->BlockHandler = msBlockHandler;
     if (pScreen->isGPU && !ms->drmmode.reverse_prime_offload_mode)
@@ -656,12 +656,12 @@ msBlockHandler(ScreenPtr pScreen, void *pTimeout, void *pReadmask)
 }
 
 static void
-msBlockHandler_oneshot(ScreenPtr pScreen, void *pTimeout, void *pReadmask)
+msBlockHandler_oneshot(ScreenPtr pScreen, void *pTimeout)
 {
     ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
     modesettingPtr ms = modesettingPTR(pScrn);
 
-    msBlockHandler(pScreen, pTimeout, pReadmask);
+    msBlockHandler(pScreen, pTimeout);
 
     drmmode_set_desired_modes(pScrn, &ms->drmmode, TRUE);
 }
diff --git a/hw/xfree86/modes/xf86Rotate.c b/hw/xfree86/modes/xf86Rotate.c
index fbd3c3204..13e5a5059 100644
--- a/hw/xfree86/modes/xf86Rotate.c
+++ b/hw/xfree86/modes/xf86Rotate.c
@@ -221,8 +221,7 @@ xf86RotateRedisplay(ScreenPtr pScreen)
 }
 
 static void
-xf86RotateBlockHandler(ScreenPtr pScreen,
-                       void *pTimeout, void *pReadmask)
+xf86RotateBlockHandler(ScreenPtr pScreen, void *pTimeout)
 {
     ScrnInfoPtr pScrn = xf86ScreenToScrn(pScreen);
     xf86CrtcConfigPtr xf86_config = XF86_CRTC_CONFIG_PTR(pScrn);
@@ -235,7 +234,7 @@ xf86RotateBlockHandler(ScreenPtr pScreen,
 
     xf86RotateRedisplay(pScreen);
 
-    (*pScreen->BlockHandler) (pScreen, pTimeout, pReadmask);
+    (*pScreen->BlockHandler) (pScreen, pTimeout);
 
     /* Re-wrap if we still need this hook */
     if (xf86_config->rotation_damage != NULL) {
diff --git a/hw/xquartz/quartzCocoa.m b/hw/xquartz/quartzCocoa.m
index d21fb7d91..ac6f67e2b 100644
--- a/hw/xquartz/quartzCocoa.m
+++ b/hw/xquartz/quartzCocoa.m
@@ -48,9 +48,7 @@
  *  Clean out any autoreleased objects.
  */
 void
-QuartzBlockHandler(void *blockData,
-                   OSTimePtr pTimeout,
-                   void *pReadmask)
+QuartzBlockHandler(void *blockData, void *pTimeout)
 {
     static NSAutoreleasePool *aPool = nil;
 
@@ -62,9 +60,7 @@ QuartzBlockHandler(void *blockData,
  * QuartzWakeupHandler
  */
 void
-QuartzWakeupHandler(void *blockData,
-                    int result,
-                    void *pReadmask)
+QuartzWakeupHandler(void *blockData, int result)
 {
     // nothing here
 }
diff --git a/hw/xquartz/quartzCommon.h b/hw/xquartz/quartzCommon.h
index 308a3f173..721886b87 100644
--- a/hw/xquartz/quartzCommon.h
+++ b/hw/xquartz/quartzCommon.h
@@ -47,8 +47,9 @@ extern int aquaMenuBarHeight;
 extern const char      *quartzOpenGLBundle;
 
 void
-QuartzBlockHandler(void *blockData, OSTimePtr pTimeout, void *pReadmask);
+QuartzBlockHandler(void *blockData, void *pTimeout);
+
 void
-QuartzWakeupHandler(void *blockData, int result, void *pReadmask);
+QuartzWakeupHandler(void *blockData, int result);
 
 #endif  /* _QUARTZCOMMON_H */
diff --git a/hw/xwin/win.h b/hw/xwin/win.h
index 787c42a96..9fa697dcc 100644
--- a/hw/xwin/win.h
+++ b/hw/xwin/win.h
@@ -902,9 +902,7 @@ Bool
  */
 
 void
-
-winWakeupHandler(ScreenPtr pScreen,
-                 unsigned long ulResult, void *pReadmask);
+winWakeupHandler(ScreenPtr pScreen, int iResult);
 
 /*
  * winwindow.c
diff --git a/hw/xwin/winwakeup.c b/hw/xwin/winwakeup.c
index ebcb0fad9..f593886ff 100644
--- a/hw/xwin/winwakeup.c
+++ b/hw/xwin/winwakeup.c
@@ -38,8 +38,7 @@
 
 /* See Porting Layer Definition - p. 7 */
 void
-winWakeupHandler(ScreenPtr pScreen,
-                 unsigned long ulResult, void *pReadmask)
+winWakeupHandler(ScreenPtr pScreen, int iResult)
 {
     MSG msg;
 
diff --git a/include/scrnintstr.h b/include/scrnintstr.h
index c5dadc7a6..5330714cb 100644
--- a/include/scrnintstr.h
+++ b/include/scrnintstr.h
@@ -258,12 +258,15 @@ typedef void (*ResolveColorProcPtr) (unsigned short * /*pred */ ,
 typedef RegionPtr (*BitmapToRegionProcPtr) (PixmapPtr /*pPix */ );
 
 typedef void (*ScreenBlockHandlerProcPtr) (ScreenPtr pScreen,
-                                           void *pTimeout,
-                                           void *pReadmask);
+                                           void *timeout);
 
+/* result has three possible values:
+ * < 0 - error
+ * = 0 - timeout
+ * > 0 - activity
+ */
 typedef void (*ScreenWakeupHandlerProcPtr) (ScreenPtr pScreen,
-                                            unsigned long result,
-                                            void *pReadMask);
+                                            int result);
 
 typedef Bool (*CreateScreenResourcesProcPtr) (ScreenPtr /*pScreen */ );
 
diff --git a/mi/misprite.c b/mi/misprite.c
index 68a49be1e..e682b243a 100644
--- a/mi/misprite.c
+++ b/mi/misprite.c
@@ -198,8 +198,7 @@ static void miSpriteSourceValidate(DrawablePtr pDrawable, int x, int y,
                                    unsigned int subWindowMode);
 static void miSpriteCopyWindow(WindowPtr pWindow,
                                DDXPointRec ptOldOrg, RegionPtr prgnSrc);
-static void miSpriteBlockHandler(ScreenPtr pScreen,
-                                 void *pTimeout, void *pReadMask);
+static void miSpriteBlockHandler(ScreenPtr pScreen, void *timeout);
 static void miSpriteInstallColormap(ColormapPtr pMap);
 static void miSpriteStoreColors(ColormapPtr pMap, int ndef, xColorItem * pdef);
 
@@ -512,8 +511,7 @@ miSpriteCopyWindow(WindowPtr pWindow, DDXPointRec ptOldOrg, RegionPtr prgnSrc)
 }
 
 static void
-miSpriteBlockHandler(ScreenPtr pScreen, void *pTimeout,
-                     void *pReadmask)
+miSpriteBlockHandler(ScreenPtr pScreen, void *timeout)
 {
     miSpriteScreenPtr pPriv = GetSpriteScreen(pScreen);
     DeviceIntPtr pDev;
@@ -545,7 +543,7 @@ miSpriteBlockHandler(ScreenPtr pScreen, void *pTimeout,
         }
     }
 
-    (*pScreen->BlockHandler) (pScreen, pTimeout, pReadmask);
+    (*pScreen->BlockHandler) (pScreen, timeout);
 
     if (WorkToDo)
         SCREEN_EPILOGUE(pPriv, pScreen, BlockHandler);
diff --git a/miext/shadow/shadow.c b/miext/shadow/shadow.c
index 405c4dddb..b8e23dae6 100644
--- a/miext/shadow/shadow.c
+++ b/miext/shadow/shadow.c
@@ -65,14 +65,14 @@ shadowRedisplay(ScreenPtr pScreen)
 }
 
 static void
-shadowBlockHandler(ScreenPtr pScreen, void *timeout, void *pRead)
+shadowBlockHandler(ScreenPtr pScreen, void *timeout)
 {
     shadowBuf(pScreen);
 
     shadowRedisplay(pScreen);
 
     unwrap(pBuf, pScreen, BlockHandler);
-    pScreen->BlockHandler(pScreen, timeout, pRead);
+    pScreen->BlockHandler(pScreen, timeout);
     wrap(pBuf, pScreen, BlockHandler);
 }