diff --git a/composite/compinit.c b/composite/compinit.c
index cb0de0ecd..ad7a6f63d 100644
--- a/composite/compinit.c
+++ b/composite/compinit.c
@@ -370,6 +370,7 @@ compScreenInit(ScreenPtr pScreen)
         pScreen->backingStoreSupport = WhenMapped;
 
     dixScreenHookWindowDestroy(pScreen, compWindowDestroy);
+    fprintf(stderr, "compext: hooking WindowPosition\n");
     dixScreenHookWindowPosition(pScreen, compWindowPosition);
 
     cs->CopyWindow = pScreen->CopyWindow;
diff --git a/composite/compwindow.c b/composite/compwindow.c
index 42959bc21..91a114192 100644
--- a/composite/compwindow.c
+++ b/composite/compwindow.c
@@ -226,7 +226,10 @@ updateOverlayWindow(ScreenPtr pScreen)
 
 void compWindowPosition(CallbackListPtr *pcbl, ScreenPtr pScreen, XorgScreenWindowPositionParamRec *param)
 {
+    fprintf(stderr, "compWindowPosition: pScreen=%p param=%p\n", pScreen, param);
+
     WindowPtr pWin = param->window;
+    fprintf(stderr, "  --> window=%p\n", pWin);
     /*
      * "Shouldn't need this as all possible places should be wrapped
      *
@@ -252,6 +255,7 @@ void compWindowPosition(CallbackListPtr *pcbl, ScreenPtr pScreen, XorgScreenWind
 
     compCheckTree(pWin->drawable.pScreen);
     updateOverlayWindow(pScreen);
+    fprintf(stderr, "compWindowPosition() LEAVE\n");
 }
 
 Bool
diff --git a/dbe/midbe.c b/dbe/midbe.c
index ccf5aa167..1d5e60efb 100644
--- a/dbe/midbe.c
+++ b/dbe/midbe.c
@@ -458,9 +458,11 @@ void miDbeWindowPosition(CallbackListPtr *pcbl, ScreenPtr pScreen, XorgScreenWin
     GCPtr pGC;
     xRectangle clearRect;
 
+    fprintf(stderr, "miDbeWindowPosition 001 param=%p\n", param);
     WindowPtr pWin = param->window;
     pDbeScreenPriv = DBE_SCREEN_PRIV(pScreen);
 
+    fprintf(stderr, "miDbeWindowPosition 002 pWin=%p\n", pWin);
     /*
      **************************************************************************
      ** 5. Do any work necessary after the member routine has been called.
@@ -470,10 +472,13 @@ void miDbeWindowPosition(CallbackListPtr *pcbl, ScreenPtr pScreen, XorgScreenWin
     if (!(pDbeWindowPriv = DBE_WINDOW_PRIV(pWin)))
         return;
 
+    fprintf(stderr, "miDbeWindowPosition 002b pWin=%p\n", pWin);
+
     if (pDbeWindowPriv->width == pWin->drawable.width &&
         pDbeWindowPriv->height == pWin->drawable.height)
         return;
 
+    fprintf(stderr, "miDbeWindowPosition 003\n");
     width = pWin->drawable.width;
     height = pWin->drawable.height;
 
@@ -484,6 +489,7 @@ void miDbeWindowPosition(CallbackListPtr *pcbl, ScreenPtr pScreen, XorgScreenWin
 
     GravityTranslate(0, 0, -dx, -dy, dw, dh, pWin->bitGravity, &destx, &desty);
 
+    fprintf(stderr, "miDbeWindowPosition 004\n");
     clear = ((pDbeWindowPriv->width < (unsigned short) width) ||
              (pDbeWindowPriv->height < (unsigned short) height) ||
              (pWin->bitGravity == ForgetGravity));
@@ -500,6 +506,7 @@ void miDbeWindowPosition(CallbackListPtr *pcbl, ScreenPtr pScreen, XorgScreenWin
         destx = 0;
     }
 
+    fprintf(stderr, "miDbeWindowPosition 005\n");
     if (destx + savewidth > width) {
         savewidth = width - destx;
     }
@@ -514,6 +521,7 @@ void miDbeWindowPosition(CallbackListPtr *pcbl, ScreenPtr pScreen, XorgScreenWin
         saveheight = height - desty;
     }
 
+    fprintf(stderr, "miDbeWindowPosition 006\n");
     pDbeWindowPriv->width = width;
     pDbeWindowPriv->height = height;
     pDbeWindowPriv->x = pWin->drawable.x;
@@ -521,6 +529,8 @@ void miDbeWindowPosition(CallbackListPtr *pcbl, ScreenPtr pScreen, XorgScreenWin
 
     pGC = GetScratchGC(pWin->drawable.depth, pScreen);
 
+    fprintf(stderr, "miDbeWindowPosition 007\n");
+
     if (clear) {
         if ((*pDbeScreenPriv->SetupBackgroundPainter) (pWin, pGC)) {
             clearRect.x = 0;
@@ -533,6 +543,8 @@ void miDbeWindowPosition(CallbackListPtr *pcbl, ScreenPtr pScreen, XorgScreenWin
         }
     }
 
+    fprintf(stderr, "miDbeWindowPosition 008\n");
+
     /* Create DBE buffer pixmaps equal to size of resized window. */
     pFrontBuffer = (*pScreen->CreatePixmap) (pScreen, width, height,
                                              pWin->drawable.depth, 0);
@@ -540,6 +552,7 @@ void miDbeWindowPosition(CallbackListPtr *pcbl, ScreenPtr pScreen, XorgScreenWin
     pBackBuffer = (*pScreen->CreatePixmap) (pScreen, width, height,
                                             pWin->drawable.depth, 0);
 
+    fprintf(stderr, "miDbeWindowPosition 009\n");
     if (!pFrontBuffer || !pBackBuffer) {
         /* We failed at creating 1 or 2 of the pixmaps. */
 
@@ -606,6 +619,8 @@ void miDbeWindowPosition(CallbackListPtr *pcbl, ScreenPtr pScreen, XorgScreenWin
 
         FreeScratchGC(pGC);
     }
+
+    fprintf(stderr, "miDbeWindowPosition LEAVE\n");
 }
 
 /******************************************************************************
@@ -621,6 +636,7 @@ void miDbeWindowPosition(CallbackListPtr *pcbl, ScreenPtr pScreen, XorgScreenWin
 Bool
 miDbeInit(ScreenPtr pScreen, DbeScreenPrivPtr pDbeScreenPriv)
 {
+    fprintf(stderr, "midbe: hooking WindowPosition\n");
     dixScreenHookWindowPosition(pScreen, miDbeWindowPosition);
 
     /* Initialize the per-screen DBE function pointers. */
diff --git a/dix/dispatch.c b/dix/dispatch.c
index a390b8232..a21006838 100644
--- a/dix/dispatch.c
+++ b/dix/dispatch.c
@@ -4011,11 +4011,14 @@ AddScreen(Bool (*pfnInit) (ScreenPtr /*pScreen */ ,
        any of the strings pointed to by argv.  They may be passed to
        multiple screens.
      */
+    fprintf(stderr, "AddScreen() index=%d hook=%p\n", i, pScreen->hookWindowPosition);
+
     screenInfo.screens[i] = pScreen;
     screenInfo.numScreens++;
     if (!(*pfnInit) (pScreen, argc, argv)) {
         dixFreeScreenSpecificPrivates(pScreen);
         dixFreePrivates(pScreen->devPrivates, PRIVATE_SCREEN);
+        fprintf(stderr, "AddScreen() abort index=%d hook=%p\n", i, pScreen->hookWindowPosition);
         free(pScreen);
         screenInfo.numScreens--;
         return -1;
@@ -4023,6 +4026,7 @@ AddScreen(Bool (*pfnInit) (ScreenPtr /*pScreen */ ,
 
     update_desktop_dimensions();
 
+    fprintf(stderr, "AddScreen() OK index=%d hook=%p\n", i, pScreen->hookWindowPosition);
     return i;
 }
 
@@ -4041,6 +4045,8 @@ AddGPUScreen(Bool (*pfnInit) (ScreenPtr /*pScreen */ ,
     if (i == MAXGPUSCREENS)
         return -1;
 
+    fprintf(stderr, "AddGPUScreen() %d\n", i);
+
     pScreen = (ScreenPtr) calloc(1, sizeof(ScreenRec));
     if (!pScreen)
         return -1;
diff --git a/dix/dixutils.c b/dix/dixutils.c
index 892207532..4dc8bda3f 100644
--- a/dix/dixutils.c
+++ b/dix/dixutils.c
@@ -703,6 +703,7 @@ _CallCallbacks(CallbackListPtr *pcbl, void *call_data)
 
     ++(cbl->inCallback);
     for (cbr = cbl->list; cbr != NULL; cbr = cbr->next) {
+        fprintf(stderr, "CallCallbacks: cbr_data=%p call_data=%p\n", cbr->data, call_data);
         (*(cbr->proc)) (pcbl, cbr->data, call_data);
     }
     --(cbl->inCallback);
@@ -831,6 +832,8 @@ DeleteCallback(CallbackListPtr *pcbl, CallbackProcPtr callback, void *data)
 void
 DeleteCallbackManager(void)
 {
+    fprintf(stderr, "DeleteCallbackManager ENTER\n");
+
     int i;
 
     for (i = 0; i < numCallbackListsToCleanup; i++) {
@@ -840,6 +843,7 @@ DeleteCallbackManager(void)
 
     numCallbackListsToCleanup = 0;
     listsToCleanup = NULL;
+    fprintf(stderr, "DeleteCallbackManager FIN\n");
 }
 
 void
diff --git a/dix/main.c b/dix/main.c
index 1347ea5d4..3f231d160 100644
--- a/dix/main.c
+++ b/dix/main.c
@@ -151,11 +151,13 @@ dix_main(int argc, char *argv[], char *envp[])
     alwaysCheckForInput[1] = 1;
     while (1) {
         serverGeneration++;
+	fprintf(stderr, "startup: 001 %ld\n", serverGeneration);
         ScreenSaverTime = defaultScreenSaverTime;
         ScreenSaverInterval = defaultScreenSaverInterval;
         ScreenSaverBlanking = defaultScreenSaverBlanking;
         ScreenSaverAllowExposures = defaultScreenSaverAllowExposures;
 
+	fprintf(stderr, "startup: 002 %ld\n", serverGeneration);
         InitBlockAndWakeupHandlers();
         /* Perform any operating system dependent initializations you'd like */
         OsInit();
@@ -173,21 +175,26 @@ dix_main(int argc, char *argv[], char *envp[])
         clients[0] = serverClient;
         currentMaxClients = 1;
 
+	fprintf(stderr, "startup: 003 %ld\n", serverGeneration);
         /* clear any existing selections */
         InitSelections();
 
+	fprintf(stderr, "startup: 004 %ld\n", serverGeneration);
         /* Initialize privates before first allocation */
         dixResetPrivates();
 
         /* Initialize server client devPrivates, to be reallocated as
          * more client privates are registered
          */
+	fprintf(stderr, "startup: 005 %ld\n", serverGeneration);
         if (!dixAllocatePrivates(&serverClient->devPrivates, PRIVATE_CLIENT))
             FatalError("failed to create server client privates");
 
+	fprintf(stderr, "startup: 006 %ld\n", serverGeneration);
         if (!InitClientResources(serverClient)) /* for root resources */
             FatalError("couldn't init server resources");
 
+	fprintf(stderr, "startup: 007 %ld\n", serverGeneration);
         SetInputCheck(&alwaysCheckForInput[0], &alwaysCheckForInput[1]);
         screenInfo.numScreens = 0;
 
@@ -196,12 +203,16 @@ dix_main(int argc, char *argv[], char *envp[])
         xfont2_init_glyph_caching();
         dixResetRegistry();
         InitFonts();
+	fprintf(stderr, "startup: 008 %ld calling InitCallbackManager\n", serverGeneration);
         InitCallbackManager();
+	fprintf(stderr, "startup: 009 %ld returned from InitCallbackManager\n", serverGeneration);
         InitOutput(&screenInfo, argc, argv);
 
+	fprintf(stderr, "startup: 010 %ld returned from InitOutput\n", serverGeneration);
         if (screenInfo.numScreens < 1)
             FatalError("no screens found");
         InitExtensions(argc, argv);
+	fprintf(stderr, "startup: 011 %ld returned from InitExtensions\n", serverGeneration);
 
         for (i = 0; i < screenInfo.numGPUScreens; i++) {
             ScreenPtr pScreen = screenInfo.gpuscreens[i];
@@ -212,6 +223,8 @@ dix_main(int argc, char *argv[], char *envp[])
                 FatalError("failed to create screen resources");
         }
 
+	fprintf(stderr, "startup: 012 %ld processed gpuscreens\n", serverGeneration);
+
         for (i = 0; i < screenInfo.numScreens; i++) {
             ScreenPtr pScreen = screenInfo.screens[i];
 
@@ -229,6 +242,7 @@ dix_main(int argc, char *argv[], char *envp[])
             CallCallbacks(&RootWindowFinalizeCallback, pScreen);
         }
 
+	fprintf(stderr, "startup: 013 %ld processed screens\n", serverGeneration);
         if (SetDefaultFontPath(defaultFontPath) != Success) {
             ErrorF("[dix] failed to set default font path '%s'",
                    defaultFontPath);
@@ -242,27 +256,42 @@ dix_main(int argc, char *argv[], char *envp[])
         }
 
         rootCursor = RefCursor(rootCursor);
+	fprintf(stderr, "startup: 014 %ld created root cursor\n", serverGeneration);
 
 #ifdef XINERAMA
         /*
          * Consolidate window and colourmap information for each screen
          */
-        if (!noPanoramiXExtension)
+        if (!noPanoramiXExtension) {
+		fprintf(stderr, "startup: 014B %ld consolidate panoramix\n", serverGeneration);
             PanoramiXConsolidate();
+	}
 #endif /* XINERAMA */
 
-        for (i = 0; i < screenInfo.numScreens; i++)
+        fflush(stderr);
+
+        for (i = 0; i < screenInfo.numScreens; i++) {
+            fprintf(stderr, "init root window on screen %d\n", i);
             InitRootWindow(screenInfo.screens[i]->root);
+            fprintf(stderr, "finished root window on screen %d\n", i);
+        }
+
+	fflush(stderr);
+	fprintf(stderr, "startup: 015 %ld initialized root windows\n", serverGeneration);
+	fflush(stderr);
 
         InitCoreDevices();
         InitInput(argc, argv);
         InitAndStartDevices();
         ReserveClientIds(serverClient);
+	fprintf(stderr, "startup: 016 %ld\n", serverGeneration);
 
         dixSaveScreens(serverClient, SCREEN_SAVER_FORCER, ScreenSaverReset);
 
         dixCloseRegistry();
 
+	fprintf(stderr, "startup: 017 %ld\n", serverGeneration);
+
 #ifdef XINERAMA
         if (!noPanoramiXExtension) {
             if (!PanoramiXCreateConnectionBlock()) {
@@ -277,22 +306,33 @@ dix_main(int argc, char *argv[], char *envp[])
             }
         }
 
+	fprintf(stderr, "startup: 018 %ld\n", serverGeneration);
+
         NotifyParentProcess();
+	fprintf(stderr, "startup: 019 %ld\n", serverGeneration);
 
         InputThreadInit();
+	fprintf(stderr, "startup: 020 %ld\n", serverGeneration);
 
         Dispatch();
 
+	fprintf(stderr, "shutdown: 001 %ld\n", serverGeneration);
         UnrefCursor(rootCursor);
 
+	fprintf(stderr, "shutdown: 002 %ld\n", serverGeneration);
         UndisplayDevices();
+	fprintf(stderr, "shutdown: 003 %ld\n", serverGeneration);
         DisableAllDevices();
+	fprintf(stderr, "shutdown: 004 %ld\n", serverGeneration);
 
         /* Now free up whatever must be freed */
         if (screenIsSaved == SCREEN_SAVER_ON)
             dixSaveScreens(serverClient, SCREEN_SAVER_OFF, ScreenSaverReset);
         FreeScreenSaverTimer();
+	fprintf(stderr, "shutdown: 005 %ld\n", serverGeneration);
+
         CloseDownExtensions();
+	fprintf(stderr, "shutdown: 006 %ld\n", serverGeneration);
 
 #ifdef XINERAMA
         {
@@ -305,43 +345,56 @@ dix_main(int argc, char *argv[], char *envp[])
 #else
         FreeAllResources();
 #endif /* XINERAMA */
+	fprintf(stderr, "shutdown: 007 %ld\n", serverGeneration);
 
         CloseInput();
+	fprintf(stderr, "shutdown: 008 %ld\n", serverGeneration);
 
         InputThreadFini();
 
+	fprintf(stderr, "shutdown: 009 %ld\n", serverGeneration);
+
         for (i = 0; i < screenInfo.numScreens; i++)
             screenInfo.screens[i]->root = NullWindow;
 
+	fprintf(stderr, "shutdown: 010 %ld\n", serverGeneration);
+
         CloseDownDevices();
 
         CloseDownEvents();
+	fprintf(stderr, "shutdown: 011 %ld\n", serverGeneration);
 
         for (i = screenInfo.numGPUScreens - 1; i >= 0; i--) {
             dixFreeScreen(screenInfo.gpuscreens[i]);
             screenInfo.numGPUScreens = i;
         }
         memset(&screenInfo.numGPUScreens, 0, sizeof(screenInfo.numGPUScreens));
+	fprintf(stderr, "shutdown: 012 %ld\n", serverGeneration);
 
         for (i = screenInfo.numScreens - 1; i >= 0; i--) {
             dixFreeScreen(screenInfo.screens[i]);
             screenInfo.numScreens = i;
         }
         memset(&screenInfo.screens, 0, sizeof(screenInfo.numGPUScreens));
+	fprintf(stderr, "shutdown: 013 %ld\n", serverGeneration);
 
         ReleaseClientIds(serverClient);
         dixFreePrivates(serverClient->devPrivates, PRIVATE_CLIENT);
         serverClient->devPrivates = NULL;
+	fprintf(stderr, "shutdown: 014 %ld\n", serverGeneration);
 
 	dixFreeRegistry();
 
         FreeFonts();
+	fprintf(stderr, "shutdown: 015 %ld\n", serverGeneration);
 
         FreeAllAtoms();
 
         FreeAuditTimer();
 
+	fprintf(stderr, "shutdown: calling DeleteCallbackManager\n");
         DeleteCallbackManager();
+	fprintf(stderr, "shutdown: returned from DeleteCallbackManager\n");
 
         ClearWorkQueue();
 
@@ -349,15 +402,19 @@ dix_main(int argc, char *argv[], char *envp[])
             CloseWellKnownConnections();
         }
 
+	fprintf(stderr, "shutdown: 001\n");
         OsCleanup((dispatchException & DE_TERMINATE) != 0);
 
+	fprintf(stderr, "shutdown: 002\n");
         if (dispatchException & DE_TERMINATE) {
             ddxGiveUp(EXIT_NO_ERROR);
             break;
         }
 
+	fprintf(stderr, "shutdown: 003\n");
         free(ConnectionInfo);
         ConnectionInfo = NULL;
+	fprintf(stderr, "shutdown: 004\n");
     }
     return 0;
 }
diff --git a/dix/screen_hooks.c b/dix/screen_hooks.c
index 0dae18123..3be950ad5 100644
--- a/dix/screen_hooks.c
+++ b/dix/screen_hooks.c
@@ -34,7 +34,9 @@ int dixScreenRaiseWindowDestroy(WindowPtr pWin)
 
     ScreenPtr pScreen = pWin->drawable.pScreen;
 
+    fprintf(stderr, "calling hookWindowDestroy\n");
     CallCallbacks(&pScreen->hookWindowDestroy, pWin);
+    fprintf(stderr, "returned from hookWindowDestroy\n");
 
     return (pScreen->DestroyWindow ? pScreen->DestroyWindow(pWin) : Success);
 }
@@ -44,18 +46,30 @@ void dixScreenRaiseWindowPosition(WindowPtr pWin, uint32_t x, uint32_t y)
     if (!pWin)
         return;
 
+    fprintf(stderr, "dixScreenRaiseWindowPosition: pWin=%p\n", pWin);
+
     ScreenPtr pScreen = pWin->drawable.pScreen;
 
+    if (!pScreen) {
+        fprintf(stderr, "dixScreenRaiseWindowPosition: window has no screen ?!\n");
+    } else {
+        fprintf(stderr, "dixScreenRaiseWindowPosition: screen %p\n", pScreen);
+    }
+
     XorgScreenWindowPositionParamRec param = {
         .window = pWin,
         .x = x,
         .y = y,
     };
 
+    fprintf(stderr, "dixScreenRaiseWindowPosition: param=%p .. window=%p calling it\n", &param, param.window);
+    fprintf(stderr, "dixScreenRaiseWindowPosition: hookWindowPosition=%p .. calling it\n", pScreen->hookWindowPosition);
     CallCallbacks(&pScreen->hookWindowPosition, &param);
 
+    fprintf(stderr, "dixScreenRaiseWindowPosition: calling PositionWindow screen proc\n");
     if (pScreen->PositionWindow)
         pScreen->PositionWindow(pWin, x, y);
+    fprintf(stderr, "dixScreenRaiseWindowPosition: FIN\n");
 }
 
 void dixScreenRaiseClose(ScreenPtr pScreen) {
diff --git a/dix/window.c b/dix/window.c
index db413b8ab..3b7b9b826 100644
--- a/dix/window.c
+++ b/dix/window.c
@@ -665,27 +665,38 @@ CreateRootWindow(ScreenPtr pScreen)
 void
 InitRootWindow(WindowPtr pWin)
 {
+    fprintf(stderr, "InitRootWindow() 001 ENTER\n");
     ScreenPtr pScreen = pWin->drawable.pScreen;
     int backFlag = CWBorderPixel | CWCursor | CWBackingStore;
 
+    fprintf(stderr, "InitRootWindow() 002\n");
     if (!(*pScreen->CreateWindow) (pWin))
         return;                 /* XXX */
 
+    fprintf(stderr, "InitRootWindow() 003\n");
+
     dixScreenRaiseWindowPosition(pWin, 0, 0);
 
+    fprintf(stderr, "InitRootWindow() 004\n");
+
     pWin->cursorIsNone = FALSE;
     pWin->optional->cursor = RefCursor(rootCursor);
 
+    fprintf(stderr, "InitRootWindow() 005\n");
+
     if (party_like_its_1989) {
+        fprintf(stderr, "InitRootWindow() 006a\n");
         MakeRootTile(pWin);
         backFlag |= CWBackPixmap;
     }
     else if (pScreen->canDoBGNoneRoot && bgNoneRoot) {
+        fprintf(stderr, "InitRootWindow() 006b\n");
         pWin->backgroundState = XaceBackgroundNoneState(pWin);
         pWin->background.pixel = pScreen->whitePixel;
         backFlag |= CWBackPixmap;
     }
     else {
+        fprintf(stderr, "InitRootWindow() 006c\n");
         pWin->backgroundState = BackgroundPixel;
         if (whiteRoot)
             pWin->background.pixel = pScreen->whitePixel;
@@ -694,11 +705,17 @@ InitRootWindow(WindowPtr pWin)
         backFlag |= CWBackPixel;
     }
 
+    fprintf(stderr, "InitRootWindow() 007\n");
+
     pWin->backingStore = NotUseful;
     /* We SHOULD check for an error value here XXX */
+    fprintf(stderr, "InitRootWindow() 008\n");
     (*pScreen->ChangeWindowAttributes) (pWin, backFlag);
 
+    fprintf(stderr, "InitRootWindow() 009\n");
+
     MapWindow(pWin, serverClient);
+    fprintf(stderr, "InitRootWindow() 010 FIN\n");
 }
 
 /* Set the region to the intersection of the rectangle and the