Merge remote-tracking branch 'origin/released'

Conflicts:
	pixman/pixman/pixman-mmx.c
	xorg-server/Xext/shm.c
	xorg-server/Xext/syncsrv.h
	xorg-server/Xext/xvmain.c
	xorg-server/Xi/exevents.c
	xorg-server/Xi/opendev.c
	xorg-server/composite/compalloc.c
	xorg-server/composite/compoverlay.c
	xorg-server/dix/colormap.c
	xorg-server/dix/devices.c
	xorg-server/dix/dispatch.c
	xorg-server/dix/dixfonts.c
	xorg-server/dix/eventconvert.c
	xorg-server/dix/events.c
	xorg-server/dix/gc.c
	xorg-server/dix/getevents.c
	xorg-server/dix/main.c
	xorg-server/dix/privates.c
	xorg-server/dix/registry.c
	xorg-server/dix/resource.c
	xorg-server/exa/exa_accel.c
	xorg-server/exa/exa_migration_classic.c
	xorg-server/exa/exa_unaccel.c
	xorg-server/fb/fb.h
	xorg-server/fb/fbcopy.c
	xorg-server/fb/fbpixmap.c
	xorg-server/glx/dispatch.h
	xorg-server/glx/glapi.h
	xorg-server/glx/glapi_gentable.c
	xorg-server/glx/glapitable.h
	xorg-server/glx/glprocs.h
	xorg-server/glx/glxcmds.c
	xorg-server/glx/glxcmdsswap.c
	xorg-server/glx/glxdricommon.c
	xorg-server/glx/glxdriswrast.c
	xorg-server/glx/glxext.c
	xorg-server/glx/indirect_dispatch.c
	xorg-server/glx/indirect_dispatch.h
	xorg-server/glx/indirect_dispatch_swap.c
	xorg-server/glx/indirect_size.h
	xorg-server/glx/indirect_size_get.h
	xorg-server/glx/indirect_table.c
	xorg-server/glx/indirect_util.c
	xorg-server/glx/rensize.c
	xorg-server/glx/single2swap.c
	xorg-server/glx/singlepix.c
	xorg-server/glx/singlepixswap.c
	xorg-server/glx/singlesize.c
	xorg-server/hw/dmx/dmxinit.c
	xorg-server/hw/kdrive/ephyr/ephyr.c
	xorg-server/hw/kdrive/ephyr/hostx.c
	xorg-server/hw/kdrive/ephyr/hostx.h
	xorg-server/hw/kdrive/src/kinput.c
	xorg-server/hw/xfree86/common/compiler.h
	xorg-server/hw/xwin/InitInput.c
	xorg-server/hw/xwin/InitOutput.c
	xorg-server/hw/xwin/ddraw.h
	xorg-server/hw/xwin/glx/glwrap.c
	xorg-server/hw/xwin/glx/indirect.c
	xorg-server/hw/xwin/glx/wgl_ext_api.h
	xorg-server/hw/xwin/glx/winpriv.c
	xorg-server/hw/xwin/win.h
	xorg-server/hw/xwin/winallpriv.c
	xorg-server/hw/xwin/winauth.c
	xorg-server/hw/xwin/winclipboard.h
	xorg-server/hw/xwin/winclipboardinit.c
	xorg-server/hw/xwin/winclipboardthread.c
	xorg-server/hw/xwin/winclipboardunicode.c
	xorg-server/hw/xwin/winclipboardwndproc.c
	xorg-server/hw/xwin/winclipboardwrappers.c
	xorg-server/hw/xwin/winclipboardxevents.c
	xorg-server/hw/xwin/wincmap.c
	xorg-server/hw/xwin/winconfig.c
	xorg-server/hw/xwin/wincreatewnd.c
	xorg-server/hw/xwin/wincursor.c
	xorg-server/hw/xwin/windialogs.c
	xorg-server/hw/xwin/winengine.c
	xorg-server/hw/xwin/winerror.c
	xorg-server/hw/xwin/wingc.c
	xorg-server/hw/xwin/wingetsp.c
	xorg-server/hw/xwin/winkeybd.c
	xorg-server/hw/xwin/winkeybd.h
	xorg-server/hw/xwin/winlayouts.h
	xorg-server/hw/xwin/winmisc.c
	xorg-server/hw/xwin/winmonitors.c
	xorg-server/hw/xwin/winmouse.c
	xorg-server/hw/xwin/winmsg.c
	xorg-server/hw/xwin/winmsg.h
	xorg-server/hw/xwin/winmultiwindowclass.c
	xorg-server/hw/xwin/winmultiwindowicons.c
	xorg-server/hw/xwin/winmultiwindowshape.c
	xorg-server/hw/xwin/winmultiwindowwindow.c
	xorg-server/hw/xwin/winmultiwindowwm.c
	xorg-server/hw/xwin/winmultiwindowwndproc.c
	xorg-server/hw/xwin/winnativegdi.c
	xorg-server/hw/xwin/winpfbdd.c
	xorg-server/hw/xwin/winpixmap.c
	xorg-server/hw/xwin/winpolyline.c
	xorg-server/hw/xwin/winprefs.c
	xorg-server/hw/xwin/winprocarg.c
	xorg-server/hw/xwin/winregistry.c
	xorg-server/hw/xwin/winscrinit.c
	xorg-server/hw/xwin/winsetsp.c
	xorg-server/hw/xwin/winshaddd.c
	xorg-server/hw/xwin/winshadddnl.c
	xorg-server/hw/xwin/winshadgdi.c
	xorg-server/hw/xwin/wintrayicon.c
	xorg-server/hw/xwin/winwin32rootless.c
	xorg-server/hw/xwin/winwin32rootlesswindow.c
	xorg-server/hw/xwin/winwin32rootlesswndproc.c
	xorg-server/hw/xwin/winwindow.c
	xorg-server/hw/xwin/winwindow.h
	xorg-server/hw/xwin/winwindowswm.c
	xorg-server/hw/xwin/winwndproc.c
	xorg-server/include/callback.h
	xorg-server/include/dixstruct.h
	xorg-server/include/misc.h
	xorg-server/include/os.h
	xorg-server/include/scrnintstr.h
	xorg-server/mi/micmap.c
	xorg-server/mi/miinitext.c
	xorg-server/mi/mioverlay.c
	xorg-server/mi/misprite.c
	xorg-server/mi/mivaltree.c
	xorg-server/mi/miwindow.c
	xorg-server/miext/damage/damage.c
	xorg-server/miext/rootless/rootlessGC.c
	xorg-server/miext/rootless/rootlessWindow.c
	xorg-server/os/WaitFor.c
	xorg-server/os/access.c
	xorg-server/os/connection.c
	xorg-server/os/io.c
	xorg-server/os/log.c
	xorg-server/os/osinit.c
	xorg-server/os/utils.c
	xorg-server/os/xdmcp.c
	xorg-server/os/xprintf.c
	xorg-server/os/xstrans.c
	xorg-server/render/mipict.c
	xorg-server/xkb/xkbActions.c
	xorg-server/xkb/xkbInit.c
	xorg-server/xkeyboard-config/compat/default.in

1 files changed, 1195 insertions, 1289 deletions

diff --git a/xorg-server/Xext/sync.c b/xorg-server/Xext/sync.c
index 830552381..44e2b12eb 100644
--- a/xorg-server/Xext/sync.c
+++ b/xorg-server/Xext/sync.c
@@ -24,7 +24,6 @@ not be used in advertising or otherwise to promote the sale, use or
 other dealings in this Software without prior written authorization
 from The Open Group.
 
-
 Copyright 1991, 1993 by Digital Equipment Corporation, Maynard, Massachusetts,
 and Olivetti Research Limited, Cambridge, England.
 
@@ -70,6 +69,7 @@ PERFORMANCE OF THIS SOFTWARE.
 #include "syncsrv.h"
 #include "syncsdk.h"
 #include "protocol-versions.h"
+#include "inputstr.h"
 
 #include <stdio.h>
 #if !defined(WIN32)
@@ -81,25 +81,25 @@ PERFORMANCE OF THIS SOFTWARE.
 /*
  * Local Global Variables
  */
-static int      SyncEventBase;
-static int      SyncErrorBase;
-static RESTYPE  RTCounter = 0;
-static RESTYPE  RTAwait;
-static RESTYPE  RTAlarm;
-static RESTYPE  RTAlarmClient;
-static RESTYPE  RTFence;
-static int SyncNumSystemCounters = 0;
-static SyncCounter **SysCounterList = NULL;
+static int SyncEventBase;
+static int SyncErrorBase;
+static RESTYPE RTCounter = 0;
+static RESTYPE RTAwait;
+static RESTYPE RTAlarm;
+static RESTYPE RTAlarmClient;
+static RESTYPE RTFence;
+static struct xorg_list SysCounterList;
 static int SyncNumInvalidCounterWarnings = 0;
+
 #define MAX_INVALID_COUNTER_WARNINGS	   5
 
 static const char *WARN_INVALID_COUNTER_COMPARE =
-"Warning: Non-counter XSync object using Counter-only\n"
-"         comparison.  Result will never be true.\n";
+    "Warning: Non-counter XSync object using Counter-only\n"
+    "         comparison.  Result will never be true.\n";
 
 static const char *WARN_INVALID_COUNTER_ALARM =
-"Warning: Non-counter XSync object used in alarm.  This is\n"
-"         the result of a programming error in the X server.\n";
+    "Warning: Non-counter XSync object used in alarm.  This is\n"
+    "         the result of a programming error in the X server.\n";
 
 #define IsSystemCounter(pCounter) \
     (pCounter && (pCounter->sync.client == NULL))
@@ -114,18 +114,24 @@ static void SyncInitServerTime(void);
 
 static void SyncInitIdleTime(void);
 
+static inline void*
+SysCounterGetPrivate(SyncCounter *counter)
+{
+    BUG_WARN(!IsSystemCounter(counter));
+
+    return counter->pSysCounterInfo ? counter->pSysCounterInfo->private : NULL;
+}
+
 static Bool
-SyncCheckWarnIsCounter(const SyncObject* pSync, const char *warning)
+SyncCheckWarnIsCounter(const SyncObject * pSync, const char *warning)
 {
-    if (pSync && (SYNC_COUNTER != pSync->type))
-    {
-	if (SyncNumInvalidCounterWarnings++ < MAX_INVALID_COUNTER_WARNINGS)
-	{
-	    ErrorF("%s", warning);
-	    ErrorF("         Counter type: %d\n", pSync->type);
-	}
+    if (pSync && (SYNC_COUNTER != pSync->type)) {
+        if (SyncNumInvalidCounterWarnings++ < MAX_INVALID_COUNTER_WARNINGS) {
+            ErrorF("%s", warning);
+            ErrorF("         Counter type: %d\n", pSync->type);
+        }
 
-	return FALSE;
+        return FALSE;
     }
 
     return TRUE;
@@ -136,7 +142,7 @@ SyncCheckWarnIsCounter(const SyncObject* pSync, const char *warning)
  *  delete and add triggers on this list.
  */
 static void
-SyncDeleteTriggerFromSyncObject(SyncTrigger *pTrigger)
+SyncDeleteTriggerFromSyncObject(SyncTrigger * pTrigger)
 {
     SyncTriggerList *pCur;
     SyncTriggerList *pPrev;
@@ -145,79 +151,76 @@ SyncDeleteTriggerFromSyncObject(SyncTrigger *pTrigger)
     /* pSync needs to be stored in pTrigger before calling here. */
 
     if (!pTrigger->pSync)
-	return;
+        return;
 
     pPrev = NULL;
     pCur = pTrigger->pSync->pTriglist;
 
-    while (pCur)
-    {
-	if (pCur->pTrigger == pTrigger)
-	{
-	    if (pPrev)
-		pPrev->next = pCur->next;
-	    else
-		pTrigger->pSync->pTriglist = pCur->next;
+    while (pCur) {
+        if (pCur->pTrigger == pTrigger) {
+            if (pPrev)
+                pPrev->next = pCur->next;
+            else
+                pTrigger->pSync->pTriglist = pCur->next;
+
+            free(pCur);
+            break;
+        }
 
-	    free(pCur);
-	    break;
-	}
-	
-	pPrev = pCur;
-	pCur = pCur->next;
+        pPrev = pCur;
+        pCur = pCur->next;
     }
 
-    if (SYNC_COUNTER == pTrigger->pSync->type)
-    {
-	pCounter = (SyncCounter *)pTrigger->pSync;
+    if (SYNC_COUNTER == pTrigger->pSync->type) {
+        pCounter = (SyncCounter *) pTrigger->pSync;
 
-	if (IsSystemCounter(pCounter))
-	    SyncComputeBracketValues(pCounter);
-    } else if (SYNC_FENCE == pTrigger->pSync->type) {
-	SyncFence* pFence = (SyncFence*) pTrigger->pSync;
-	pFence->funcs.DeleteTrigger(pTrigger);
+        if (IsSystemCounter(pCounter))
+            SyncComputeBracketValues(pCounter);
     }
-}
+    else if (SYNC_FENCE == pTrigger->pSync->type) {
+        SyncFence *pFence = (SyncFence *) pTrigger->pSync;
 
+        pFence->funcs.DeleteTrigger(pTrigger);
+    }
+}
 
 static int
-SyncAddTriggerToSyncObject(SyncTrigger *pTrigger)
+SyncAddTriggerToSyncObject(SyncTrigger * pTrigger)
 {
     SyncTriggerList *pCur;
     SyncCounter *pCounter;
 
     if (!pTrigger->pSync)
-	return Success;
+        return Success;
 
     /* don't do anything if it's already there */
-    for (pCur = pTrigger->pSync->pTriglist; pCur; pCur = pCur->next)
-    {
-	if (pCur->pTrigger == pTrigger)
-	    return Success;
+    for (pCur = pTrigger->pSync->pTriglist; pCur; pCur = pCur->next) {
+        if (pCur->pTrigger == pTrigger)
+            return Success;
     }
 
     if (!(pCur = malloc(sizeof(SyncTriggerList))))
-	return BadAlloc;
+        return BadAlloc;
 
     pCur->pTrigger = pTrigger;
     pCur->next = pTrigger->pSync->pTriglist;
     pTrigger->pSync->pTriglist = pCur;
 
-    if (SYNC_COUNTER == pTrigger->pSync->type)
-    {
-	pCounter = (SyncCounter *)pTrigger->pSync;
+    if (SYNC_COUNTER == pTrigger->pSync->type) {
+        pCounter = (SyncCounter *) pTrigger->pSync;
+
+        if (IsSystemCounter(pCounter))
+            SyncComputeBracketValues(pCounter);
+    }
+    else if (SYNC_FENCE == pTrigger->pSync->type) {
+        SyncFence *pFence = (SyncFence *) pTrigger->pSync;
 
-	if (IsSystemCounter(pCounter))
-	    SyncComputeBracketValues(pCounter);
-    } else if (SYNC_FENCE == pTrigger->pSync->type) {
-	SyncFence* pFence = (SyncFence*) pTrigger->pSync;
-	pFence->funcs.AddTrigger(pTrigger);
+        pFence->funcs.AddTrigger(pTrigger);
     }
 
     return Success;
 }
 
-
 /*  Below are five possible functions that can be plugged into
  *  pTrigger->CheckTrigger for counter sync objects, corresponding to
  *  the four possible test-types, and the one possible function that
@@ -234,194 +237,182 @@ SyncAddTriggerToSyncObject(SyncTrigger *pTrigger)
  */
 
 static Bool
-SyncCheckTriggerPositiveComparison(SyncTrigger *pTrigger, CARD64 oldval)
+SyncCheckTriggerPositiveComparison(SyncTrigger * pTrigger, CARD64 oldval)
 {
     SyncCounter *pCounter;
 
     /* Non-counter sync objects should never get here because they
      * never trigger this comparison. */
     if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))
-	return FALSE;
+        return FALSE;
 
-    pCounter = (SyncCounter *)pTrigger->pSync;
+    pCounter = (SyncCounter *) pTrigger->pSync;
 
     return (pCounter == NULL ||
-	    XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value));
+            XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value));
 }
 
 static Bool
-SyncCheckTriggerNegativeComparison(SyncTrigger *pTrigger,  CARD64 oldval)
+SyncCheckTriggerNegativeComparison(SyncTrigger * pTrigger, CARD64 oldval)
 {
     SyncCounter *pCounter;
 
     /* Non-counter sync objects should never get here because they
      * never trigger this comparison. */
     if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))
-	return FALSE;
+        return FALSE;
 
-    pCounter = (SyncCounter *)pTrigger->pSync;
+    pCounter = (SyncCounter *) pTrigger->pSync;
 
     return (pCounter == NULL ||
-	    XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value));
+            XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value));
 }
 
 static Bool
-SyncCheckTriggerPositiveTransition(SyncTrigger *pTrigger, CARD64 oldval)
+SyncCheckTriggerPositiveTransition(SyncTrigger * pTrigger, CARD64 oldval)
 {
     SyncCounter *pCounter;
 
     /* Non-counter sync objects should never get here because they
      * never trigger this comparison. */
     if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))
-	return FALSE;
+        return FALSE;
 
-    pCounter = (SyncCounter *)pTrigger->pSync;
+    pCounter = (SyncCounter *) pTrigger->pSync;
 
     return (pCounter == NULL ||
-	    (XSyncValueLessThan(oldval, pTrigger->test_value) &&
-	     XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value)));
+            (XSyncValueLessThan(oldval, pTrigger->test_value) &&
+             XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value)));
 }
 
 static Bool
-SyncCheckTriggerNegativeTransition(SyncTrigger *pTrigger, CARD64 oldval)
+SyncCheckTriggerNegativeTransition(SyncTrigger * pTrigger, CARD64 oldval)
 {
     SyncCounter *pCounter;
 
     /* Non-counter sync objects should never get here because they
      * never trigger this comparison. */
     if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_COMPARE))
-	return FALSE;
+        return FALSE;
 
-    pCounter = (SyncCounter *)pTrigger->pSync;
+    pCounter = (SyncCounter *) pTrigger->pSync;
 
     return (pCounter == NULL ||
-	    (XSyncValueGreaterThan(oldval, pTrigger->test_value) &&
-	     XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value)));
+            (XSyncValueGreaterThan(oldval, pTrigger->test_value) &&
+             XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value)));
 }
 
 static Bool
-SyncCheckTriggerFence(SyncTrigger *pTrigger, CARD64 unused)
+SyncCheckTriggerFence(SyncTrigger * pTrigger, CARD64 unused)
 {
-    SyncFence* pFence = (SyncFence*) pTrigger->pSync;
-    (void)unused;
+    SyncFence *pFence = (SyncFence *) pTrigger->pSync;
+
+    (void) unused;
 
-    return (pFence == NULL ||
-	    pFence->funcs.CheckTriggered(pFence));
+    return (pFence == NULL || pFence->funcs.CheckTriggered(pFence));
 }
 
 static int
-SyncInitTrigger(ClientPtr client, SyncTrigger *pTrigger, XID syncObject,
-		RESTYPE resType, Mask changes)
+SyncInitTrigger(ClientPtr client, SyncTrigger * pTrigger, XID syncObject,
+                RESTYPE resType, Mask changes)
 {
     SyncObject *pSync = pTrigger->pSync;
     SyncCounter *pCounter = NULL;
-    int		rc;
-    Bool	newSyncObject = FALSE;
-
-    if (changes & XSyncCACounter)
-    {
-	if (syncObject == None)
-	    pSync = NULL;
-	else if (Success != (rc = dixLookupResourceByType ((pointer *)&pSync,
-				syncObject, resType, client, DixReadAccess)))
-	{
-	    client->errorValue = syncObject;
-	    return rc;
-	}
-	if (pSync != pTrigger->pSync)
-	{ /* new counter for trigger */
-	    SyncDeleteTriggerFromSyncObject(pTrigger);
-	    pTrigger->pSync = pSync;
-	    newSyncObject = TRUE;
-	}
+    int rc;
+    Bool newSyncObject = FALSE;
+
+    if (changes & XSyncCACounter) {
+        if (syncObject == None)
+            pSync = NULL;
+        else if (Success != (rc = dixLookupResourceByType((pointer *) &pSync,
+                                                          syncObject, resType,
+                                                          client,
+                                                          DixReadAccess))) {
+            client->errorValue = syncObject;
+            return rc;
+        }
+        if (pSync != pTrigger->pSync) { /* new counter for trigger */
+            SyncDeleteTriggerFromSyncObject(pTrigger);
+            pTrigger->pSync = pSync;
+            newSyncObject = TRUE;
+        }
     }
 
     /* if system counter, ask it what the current value is */
 
-    if (pSync && SYNC_COUNTER == pSync->type)
-    {
-	pCounter = (SyncCounter *)pSync;
-
-	if (IsSystemCounter(pCounter))
-	{
-	    (*pCounter->pSysCounterInfo->QueryValue) ((pointer) pCounter,
-						      &pCounter->value);
-	}
-    }
-
-    if (changes & XSyncCAValueType)
-    {
-	if (pTrigger->value_type != XSyncRelative &&
-	    pTrigger->value_type != XSyncAbsolute)
-	{
-	    client->errorValue = pTrigger->value_type;
-	    return BadValue;
-	}
-    }
-
-    if (changes & XSyncCATestType)
-    {
-
-	if (pSync && SYNC_FENCE == pSync->type)
-	{
-	    pTrigger->CheckTrigger = SyncCheckTriggerFence;
-	}
-	else
-	{
-	    /* select appropriate CheckTrigger function */
-
-	    switch (pTrigger->test_type)
-	    {
-	    case XSyncPositiveTransition:
-		pTrigger->CheckTrigger = SyncCheckTriggerPositiveTransition;
-		break;
-	    case XSyncNegativeTransition:
-		pTrigger->CheckTrigger = SyncCheckTriggerNegativeTransition;
-		break;
-	    case XSyncPositiveComparison:
-		pTrigger->CheckTrigger = SyncCheckTriggerPositiveComparison;
-		break;
-	    case XSyncNegativeComparison:
-		pTrigger->CheckTrigger = SyncCheckTriggerNegativeComparison;
-		break;
-	    default:
-		client->errorValue = pTrigger->test_type;
-		return BadValue;
-	    }
-	}
-    }
-
-    if (changes & (XSyncCAValueType | XSyncCAValue))
-    {
-	if (pTrigger->value_type == XSyncAbsolute)
-	    pTrigger->test_value = pTrigger->wait_value;
-	else /* relative */
-	{
-	    Bool overflow;
-	    if (pCounter == NULL)
-		return BadMatch;
-
-	    XSyncValueAdd(&pTrigger->test_value, pCounter->value,
-			  pTrigger->wait_value, &overflow);
-	    if (overflow)
-	    {
-		client->errorValue = XSyncValueHigh32(pTrigger->wait_value);
-		return BadValue;
-	    }
-	}
+    if (pSync && SYNC_COUNTER == pSync->type) {
+        pCounter = (SyncCounter *) pSync;
+
+        if (IsSystemCounter(pCounter)) {
+            (*pCounter->pSysCounterInfo->QueryValue) ((pointer) pCounter,
+                                                      &pCounter->value);
+        }
+    }
+
+    if (changes & XSyncCAValueType) {
+        if (pTrigger->value_type != XSyncRelative &&
+            pTrigger->value_type != XSyncAbsolute) {
+            client->errorValue = pTrigger->value_type;
+            return BadValue;
+        }
+    }
+
+    if (changes & XSyncCATestType) {
+
+        if (pSync && SYNC_FENCE == pSync->type) {
+            pTrigger->CheckTrigger = SyncCheckTriggerFence;
+        }
+        else {
+            /* select appropriate CheckTrigger function */
+
+            switch (pTrigger->test_type) {
+            case XSyncPositiveTransition:
+                pTrigger->CheckTrigger = SyncCheckTriggerPositiveTransition;
+                break;
+            case XSyncNegativeTransition:
+                pTrigger->CheckTrigger = SyncCheckTriggerNegativeTransition;
+                break;
+            case XSyncPositiveComparison:
+                pTrigger->CheckTrigger = SyncCheckTriggerPositiveComparison;
+                break;
+            case XSyncNegativeComparison:
+                pTrigger->CheckTrigger = SyncCheckTriggerNegativeComparison;
+                break;
+            default:
+                client->errorValue = pTrigger->test_type;
+                return BadValue;
+            }
+        }
+    }
+
+    if (changes & (XSyncCAValueType | XSyncCAValue)) {
+        if (pTrigger->value_type == XSyncAbsolute)
+            pTrigger->test_value = pTrigger->wait_value;
+        else {                  /* relative */
+
+            Bool overflow;
+
+            if (pCounter == NULL)
+                return BadMatch;
+
+            XSyncValueAdd(&pTrigger->test_value, pCounter->value,
+                          pTrigger->wait_value, &overflow);
+            if (overflow) {
+                client->errorValue = XSyncValueHigh32(pTrigger->wait_value);
+                return BadValue;
+            }
+        }
     }
 
     /*  we wait until we're sure there are no errors before registering
      *  a new counter on a trigger
      */
-    if (newSyncObject)
-    {
-	if ((rc = SyncAddTriggerToSyncObject(pTrigger)) != Success)
-	    return rc;
+    if (newSyncObject) {
+        if ((rc = SyncAddTriggerToSyncObject(pTrigger)) != Success)
+            return rc;
     }
-    else if (pCounter && IsSystemCounter(pCounter))
-    {
-	SyncComputeBracketValues(pCounter);
+    else if (pCounter && IsSystemCounter(pCounter)) {
+        SyncComputeBracketValues(pCounter);
     }
 
     return Success;
@@ -432,7 +423,7 @@ SyncInitTrigger(ClientPtr client, SyncTrigger *pTrigger, XID syncObject,
  *  clients.  The alarm maintains a list of clients interested in events.
  */
 static void
-SyncSendAlarmNotifyEvents(SyncAlarm *pAlarm)
+SyncSendAlarmNotifyEvents(SyncAlarm * pAlarm)
 {
     SyncAlarmClientList *pcl;
     xSyncAlarmNotifyEvent ane;
@@ -440,23 +431,21 @@ SyncSendAlarmNotifyEvents(SyncAlarm *pAlarm)
     SyncCounter *pCounter;
 
     if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_ALARM))
-	return;
+        return;
 
-    pCounter = (SyncCounter *)pTrigger->pSync;
+    pCounter = (SyncCounter *) pTrigger->pSync;
 
     UpdateCurrentTime();
 
     ane.type = SyncEventBase + XSyncAlarmNotify;
     ane.kind = XSyncAlarmNotify;
     ane.alarm = pAlarm->alarm_id;
-    if (pTrigger->pSync && SYNC_COUNTER == pTrigger->pSync->type)
-    {
-	ane.counter_value_hi = XSyncValueHigh32(pCounter->value);
-	ane.counter_value_lo = XSyncValueLow32(pCounter->value);
+    if (pTrigger->pSync && SYNC_COUNTER == pTrigger->pSync->type) {
+        ane.counter_value_hi = XSyncValueHigh32(pCounter->value);
+        ane.counter_value_lo = XSyncValueLow32(pCounter->value);
     }
-    else
-    { /* XXX what else can we do if there's no counter? */
-	ane.counter_value_hi = ane.counter_value_lo = 0;
+    else {                      /* XXX what else can we do if there's no counter? */
+        ane.counter_value_hi = ane.counter_value_lo = 0;
     }
 
     ane.alarm_value_hi = XSyncValueHigh32(pTrigger->test_value);
@@ -466,149 +455,141 @@ SyncSendAlarmNotifyEvents(SyncAlarm *pAlarm)
 
     /* send to owner */
     if (pAlarm->events)
-	WriteEventsToClient(pAlarm->client, 1, (xEvent *) &ane);
+        WriteEventsToClient(pAlarm->client, 1, (xEvent *) &ane);
 
     /* send to other interested clients */
     for (pcl = pAlarm->pEventClients; pcl; pcl = pcl->next)
-	WriteEventsToClient(pcl->client, 1, (xEvent *) &ane);
+        WriteEventsToClient(pcl->client, 1, (xEvent *) &ane);
 }
 
-
 /*  CounterNotify events only occur in response to an Await.  The events
  *  go only to the Awaiting client.
  */
 static void
-SyncSendCounterNotifyEvents(ClientPtr client, SyncAwait **ppAwait,
-			    int num_events)
+SyncSendCounterNotifyEvents(ClientPtr client, SyncAwait ** ppAwait,
+                            int num_events)
 {
     xSyncCounterNotifyEvent *pEvents, *pev;
     int i;
 
     if (client->clientGone)
-	return;
+        return;
     pev = pEvents = malloc(num_events * sizeof(xSyncCounterNotifyEvent));
     if (!pEvents)
-	return;
+        return;
     UpdateCurrentTime();
-    for (i = 0; i < num_events; i++, ppAwait++, pev++)
-    {
-	SyncTrigger *pTrigger = &(*ppAwait)->trigger;
-	pev->type = SyncEventBase + XSyncCounterNotify;
-	pev->kind = XSyncCounterNotify;
-	pev->counter = pTrigger->pSync->id;
-	pev->wait_value_lo = XSyncValueLow32(pTrigger->test_value);
-	pev->wait_value_hi = XSyncValueHigh32(pTrigger->test_value);
-	if (SYNC_COUNTER == pTrigger->pSync->type)
-	{
-	    SyncCounter *pCounter = (SyncCounter *)pTrigger->pSync;
-
-	    pev->counter_value_lo = XSyncValueLow32(pCounter->value);
-	    pev->counter_value_hi = XSyncValueHigh32(pCounter->value);
-	}
-	else
-	{
-	    pev->counter_value_lo = 0;
-	    pev->counter_value_hi = 0;
-	}
-
-	pev->time = currentTime.milliseconds;
-	pev->count = num_events - i - 1; /* events remaining */
-	pev->destroyed = pTrigger->pSync->beingDestroyed;
+    for (i = 0; i < num_events; i++, ppAwait++, pev++) {
+        SyncTrigger *pTrigger = &(*ppAwait)->trigger;
+
+        pev->type = SyncEventBase + XSyncCounterNotify;
+        pev->kind = XSyncCounterNotify;
+        pev->counter = pTrigger->pSync->id;
+        pev->wait_value_lo = XSyncValueLow32(pTrigger->test_value);
+        pev->wait_value_hi = XSyncValueHigh32(pTrigger->test_value);
+        if (SYNC_COUNTER == pTrigger->pSync->type) {
+            SyncCounter *pCounter = (SyncCounter *) pTrigger->pSync;
+
+            pev->counter_value_lo = XSyncValueLow32(pCounter->value);
+            pev->counter_value_hi = XSyncValueHigh32(pCounter->value);
+        }
+        else {
+            pev->counter_value_lo = 0;
+            pev->counter_value_hi = 0;
+        }
+
+        pev->time = currentTime.milliseconds;
+        pev->count = num_events - i - 1;        /* events remaining */
+        pev->destroyed = pTrigger->pSync->beingDestroyed;
     }
     /* swapping will be taken care of by this */
-    WriteEventsToClient(client, num_events, (xEvent *)pEvents);
+    WriteEventsToClient(client, num_events, (xEvent *) pEvents);
     free(pEvents);
 }
 
-
 /* This function is called when an alarm's counter is destroyed.
  * It is plugged into pTrigger->CounterDestroyed (for alarm triggers).
  */
 static void
-SyncAlarmCounterDestroyed(SyncTrigger *pTrigger)
+SyncAlarmCounterDestroyed(SyncTrigger * pTrigger)
 {
-    SyncAlarm *pAlarm = (SyncAlarm *)pTrigger;
+    SyncAlarm *pAlarm = (SyncAlarm *) pTrigger;
 
     pAlarm->state = XSyncAlarmInactive;
     SyncSendAlarmNotifyEvents(pAlarm);
     pTrigger->pSync = NULL;
 }
 
-
 /*  This function is called when an alarm "goes off."
  *  It is plugged into pTrigger->TriggerFired (for alarm triggers).
  */
 static void
-SyncAlarmTriggerFired(SyncTrigger *pTrigger)
+SyncAlarmTriggerFired(SyncTrigger * pTrigger)
 {
-    SyncAlarm *pAlarm = (SyncAlarm *)pTrigger;
+    SyncAlarm *pAlarm = (SyncAlarm *) pTrigger;
     SyncCounter *pCounter;
     CARD64 new_test_value;
 
     if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_ALARM))
-	return;
+        return;
 
-    pCounter = (SyncCounter *)pTrigger->pSync;
+    pCounter = (SyncCounter *) pTrigger->pSync;
 
     /* no need to check alarm unless it's active */
     if (pAlarm->state != XSyncAlarmActive)
-	return;
+        return;
 
     /*  " if the counter value is None, or if the delta is 0 and
      *    the test-type is PositiveComparison or NegativeComparison,
      *    no change is made to value (test-value) and the alarm
      *    state is changed to Inactive before the event is generated."
      */
-    if (pCounter == NULL
-	|| (XSyncValueIsZero(pAlarm->delta)
-	    && (pAlarm->trigger.test_type == XSyncPositiveComparison
-		|| pAlarm->trigger.test_type == XSyncNegativeComparison)))
-	pAlarm->state = XSyncAlarmInactive;
+    if (pCounter == NULL || (XSyncValueIsZero(pAlarm->delta)
+                             && (pAlarm->trigger.test_type ==
+                                 XSyncPositiveComparison ||
+                                 pAlarm->trigger.test_type ==
+                                 XSyncNegativeComparison)))
+        pAlarm->state = XSyncAlarmInactive;
 
     new_test_value = pAlarm->trigger.test_value;
 
-    if (pAlarm->state == XSyncAlarmActive)
-    {
-	Bool overflow;
-	CARD64 oldvalue;
-	SyncTrigger *paTrigger = &pAlarm->trigger;
-	SyncCounter *paCounter;
-
-	if (!SyncCheckWarnIsCounter(paTrigger->pSync,
-				    WARN_INVALID_COUNTER_ALARM))
-	    return;
-
-	paCounter = (SyncCounter *)pTrigger->pSync;
-
-	/* "The alarm is updated by repeatedly adding delta to the
-	 *  value of the trigger and re-initializing it until it
-	 *  becomes FALSE."
-	 */
-	oldvalue = paTrigger->test_value;
-
-	/* XXX really should do something smarter here */
-
-	do
-	{
-	    XSyncValueAdd(&paTrigger->test_value, paTrigger->test_value,
-			  pAlarm->delta, &overflow);
-	} while (!overflow &&
-	      (*paTrigger->CheckTrigger)(paTrigger,
-					paCounter->value));
-
-	new_test_value = paTrigger->test_value;
-	paTrigger->test_value = oldvalue;
-
-	/* "If this update would cause value to fall outside the range
-	 *  for an INT64...no change is made to value (test-value) and
-	 *  the alarm state is changed to Inactive before the event is
-	 *  generated."
-	 */
-	if (overflow)
-	{
-	    new_test_value = oldvalue;
-	    pAlarm->state = XSyncAlarmInactive;
-	}
+    if (pAlarm->state == XSyncAlarmActive) {
+        Bool overflow;
+        CARD64 oldvalue;
+        SyncTrigger *paTrigger = &pAlarm->trigger;
+        SyncCounter *paCounter;
+
+        if (!SyncCheckWarnIsCounter(paTrigger->pSync,
+                                    WARN_INVALID_COUNTER_ALARM))
+            return;
+
+        paCounter = (SyncCounter *) pTrigger->pSync;
+
+        /* "The alarm is updated by repeatedly adding delta to the
+         *  value of the trigger and re-initializing it until it
+         *  becomes FALSE."
+         */
+        oldvalue = paTrigger->test_value;
+
+        /* XXX really should do something smarter here */
+
+        do {
+            XSyncValueAdd(&paTrigger->test_value, paTrigger->test_value,
+                          pAlarm->delta, &overflow);
+        } while (!overflow &&
+                 (*paTrigger->CheckTrigger) (paTrigger, paCounter->value));
+
+        new_test_value = paTrigger->test_value;
+        paTrigger->test_value = oldvalue;
+
+        /* "If this update would cause value to fall outside the range
+         *  for an INT64...no change is made to value (test-value) and
+         *  the alarm state is changed to Inactive before the event is
+         *  generated."
+         */
+        if (overflow) {
+            new_test_value = oldvalue;
+            pAlarm->state = XSyncAlarmInactive;
+        }
     }
     /*  The AlarmNotify event has to have the "new state of the alarm"
      *  which we can't be sure of until this point.  However, it has
@@ -620,28 +601,27 @@ SyncAlarmTriggerFired(SyncTrigger *pTrigger)
     pTrigger->test_value = new_test_value;
 }
 
-
 /*  This function is called when an Await unblocks, either as a result
  *  of the trigger firing OR the counter being destroyed.
  *  It goes into pTrigger->TriggerFired AND pTrigger->CounterDestroyed
  *  (for Await triggers).
  */
 static void
-SyncAwaitTriggerFired(SyncTrigger *pTrigger)
+SyncAwaitTriggerFired(SyncTrigger * pTrigger)
 {
-    SyncAwait *pAwait = (SyncAwait *)pTrigger;
+    SyncAwait *pAwait = (SyncAwait *) pTrigger;
     int numwaits;
     SyncAwaitUnion *pAwaitUnion;
     SyncAwait **ppAwait;
     int num_events = 0;
 
-    pAwaitUnion = (SyncAwaitUnion *)pAwait->pHeader;
+    pAwaitUnion = (SyncAwaitUnion *) pAwait->pHeader;
     numwaits = pAwaitUnion->header.num_waitconditions;
     ppAwait = malloc(numwaits * sizeof(SyncAwait *));
     if (!ppAwait)
-	goto bail;
+        goto bail;
 
-    pAwait = &(pAwaitUnion+1)->await;
+    pAwait = &(pAwaitUnion + 1)->await;
 
     /* "When a client is unblocked, all the CounterNotify events for
      *  the Await request are generated contiguously. If count is 0
@@ -652,132 +632,119 @@ SyncAwaitTriggerFired(SyncTrigger *pTrigger)
      *  need to be sent first, so that an accurate count field can
      *  be stored in the events.
      */
-    for ( ; numwaits; numwaits--, pAwait++)
-    {
-	CARD64 diff;
-	Bool overflow, diffgreater, diffequal;
-
-	/* "A CounterNotify event with the destroyed flag set to TRUE is
-	 *  always generated if the counter for one of the triggers is
-	 *  destroyed."
-	 */
-	if (pAwait->trigger.pSync->beingDestroyed)
-	{
-	    ppAwait[num_events++] = pAwait;
-	    continue;
-	}
-	
-	if (SYNC_COUNTER == pAwait->trigger.pSync->type)
-	{
-	    SyncCounter *pCounter = (SyncCounter *) pAwait->trigger.pSync;
-
-	    /* "The difference between the counter and the test value is
-	     *  calculated by subtracting the test value from the value of
-	     *  the counter."
-	     */
-	    XSyncValueSubtract(&diff, pCounter->value,
-			       pAwait->trigger.test_value, &overflow);
-
-	    /* "If the difference lies outside the range for an INT64, an
-	     *  event is not generated."
-	     */
-	    if (overflow)
-		continue;
-	    diffgreater = XSyncValueGreaterThan(diff, pAwait->event_threshold);
-	    diffequal   = XSyncValueEqual(diff, pAwait->event_threshold);
-
-	    /* "If the test-type is PositiveTransition or
-	     *  PositiveComparison, a CounterNotify event is generated if
-	     *  the difference is at least event-threshold. If the test-type
-	     *  is NegativeTransition or NegativeComparison, a CounterNotify
-	     *  event is generated if the difference is at most
-	     *  event-threshold."
-	     */
-
-	    if ( ((pAwait->trigger.test_type == XSyncPositiveComparison ||
-		   pAwait->trigger.test_type == XSyncPositiveTransition)
-		  && (diffgreater || diffequal))
-		 ||
-		 ((pAwait->trigger.test_type == XSyncNegativeComparison ||
-		   pAwait->trigger.test_type == XSyncNegativeTransition)
-		  && (!diffgreater) /* less or equal */
-		 )
-	       )
-	    {
-		ppAwait[num_events++] = pAwait;
-	    }
-	}
+    for (; numwaits; numwaits--, pAwait++) {
+        CARD64 diff;
+        Bool overflow, diffgreater, diffequal;
+
+        /* "A CounterNotify event with the destroyed flag set to TRUE is
+         *  always generated if the counter for one of the triggers is
+         *  destroyed."
+         */
+        if (pAwait->trigger.pSync->beingDestroyed) {
+            ppAwait[num_events++] = pAwait;
+            continue;
+        }
+
+        if (SYNC_COUNTER == pAwait->trigger.pSync->type) {
+            SyncCounter *pCounter = (SyncCounter *) pAwait->trigger.pSync;
+
+            /* "The difference between the counter and the test value is
+             *  calculated by subtracting the test value from the value of
+             *  the counter."
+             */
+            XSyncValueSubtract(&diff, pCounter->value,
+                               pAwait->trigger.test_value, &overflow);
+
+            /* "If the difference lies outside the range for an INT64, an
+             *  event is not generated."
+             */
+            if (overflow)
+                continue;
+            diffgreater = XSyncValueGreaterThan(diff, pAwait->event_threshold);
+            diffequal = XSyncValueEqual(diff, pAwait->event_threshold);
+
+            /* "If the test-type is PositiveTransition or
+             *  PositiveComparison, a CounterNotify event is generated if
+             *  the difference is at least event-threshold. If the test-type
+             *  is NegativeTransition or NegativeComparison, a CounterNotify
+             *  event is generated if the difference is at most
+             *  event-threshold."
+             */
+
+            if (((pAwait->trigger.test_type == XSyncPositiveComparison ||
+                  pAwait->trigger.test_type == XSyncPositiveTransition)
+                 && (diffgreater || diffequal))
+                ||
+                ((pAwait->trigger.test_type == XSyncNegativeComparison ||
+                  pAwait->trigger.test_type == XSyncNegativeTransition)
+                 && (!diffgreater)      /* less or equal */
+                )
+                ) {
+                ppAwait[num_events++] = pAwait;
+            }
+        }
     }
     if (num_events)
-	SyncSendCounterNotifyEvents(pAwaitUnion->header.client, ppAwait,
-				    num_events);
+        SyncSendCounterNotifyEvents(pAwaitUnion->header.client, ppAwait,
+                                    num_events);
     free(ppAwait);
 
-bail:
+ bail:
     /* unblock the client */
     AttendClient(pAwaitUnion->header.client);
     /* delete the await */
     FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
 }
 
-
 /*  This function should always be used to change a counter's value so that
  *  any triggers depending on the counter will be checked.
  */
 void
-SyncChangeCounter(SyncCounter *pCounter, CARD64 newval)
+SyncChangeCounter(SyncCounter * pCounter, CARD64 newval)
 {
-    SyncTriggerList       *ptl, *pnext;
+    SyncTriggerList *ptl, *pnext;
     CARD64 oldval;
 
     oldval = pCounter->value;
     pCounter->value = newval;
 
     /* run through triggers to see if any become true */
-    for (ptl = pCounter->sync.pTriglist; ptl; ptl = pnext)
-    {
-	pnext = ptl->next;
-	if ((*ptl->pTrigger->CheckTrigger)(ptl->pTrigger, oldval))
-	    (*ptl->pTrigger->TriggerFired)(ptl->pTrigger);
+    for (ptl = pCounter->sync.pTriglist; ptl; ptl = pnext) {
+        pnext = ptl->next;
+        if ((*ptl->pTrigger->CheckTrigger) (ptl->pTrigger, oldval))
+            (*ptl->pTrigger->TriggerFired) (ptl->pTrigger);
     }
 
-    if (IsSystemCounter(pCounter))
-    {
-	SyncComputeBracketValues(pCounter);
+    if (IsSystemCounter(pCounter)) {
+        SyncComputeBracketValues(pCounter);
     }
 }
 
-
 /* loosely based on dix/events.c/EventSelectForWindow */
 static Bool
-SyncEventSelectForAlarm(SyncAlarm *pAlarm, ClientPtr client, Bool wantevents)
+SyncEventSelectForAlarm(SyncAlarm * pAlarm, ClientPtr client, Bool wantevents)
 {
     SyncAlarmClientList *pClients;
 
-    if (client == pAlarm->client) /* alarm owner */
-    {
-	pAlarm->events = wantevents;
-	return Success;
+    if (client == pAlarm->client) {     /* alarm owner */
+        pAlarm->events = wantevents;
+        return Success;
     }
 
     /* see if the client is already on the list (has events selected) */
 
-    for (pClients = pAlarm->pEventClients; pClients;
-	 pClients = pClients->next)
-    {
-	if (pClients->client == client)
-	{
-	    /* client's presence on the list indicates desire for
-	     * events.  If the client doesn't want events, remove it
-	     * from the list.  If the client does want events, do
-	     * nothing, since it's already got them.
-	     */
-	    if (!wantevents)
-	    {
-		FreeResource(pClients->delete_id, RT_NONE);
-	    }
-	    return Success;
-	}
+    for (pClients = pAlarm->pEventClients; pClients; pClients = pClients->next) {
+        if (pClients->client == client) {
+            /* client's presence on the list indicates desire for
+             * events.  If the client doesn't want events, remove it
+             * from the list.  If the client does want events, do
+             * nothing, since it's already got them.
+             */
+            if (!wantevents) {
+                FreeResource(pClients->delete_id, RT_NONE);
+            }
+            return Success;
+        }
     }
 
     /*  if we get here, this client does not currently have
@@ -785,16 +752,16 @@ SyncEventSelectForAlarm(SyncAlarm *pAlarm, ClientPtr client, Bool wantevents)
      */
 
     if (!wantevents)
-	/* client doesn't want events, and we just discovered that it
-	 * doesn't have them, so there's nothing to do.
-	 */
-	return Success;
+        /* client doesn't want events, and we just discovered that it
+         * doesn't have them, so there's nothing to do.
+         */
+        return Success;
 
     /* add new client to pAlarm->pEventClients */
 
     pClients = malloc(sizeof(SyncAlarmClientList));
     if (!pClients)
-	return BadAlloc;
+        return BadAlloc;
 
     /*  register it as a resource so it will be cleaned up
      *  if the client dies
@@ -808,7 +775,7 @@ SyncEventSelectForAlarm(SyncAlarm *pAlarm, ClientPtr client, Bool wantevents)
     pClients->client = client;
 
     if (!AddResource(pClients->delete_id, RTAlarmClient, pAlarm))
-	return BadAlloc;
+        return BadAlloc;
 
     return Success;
 }
@@ -817,69 +784,66 @@ SyncEventSelectForAlarm(SyncAlarm *pAlarm, ClientPtr client, Bool wantevents)
  * ** SyncChangeAlarmAttributes ** This is used by CreateAlarm and ChangeAlarm
  */
 static int
-SyncChangeAlarmAttributes(ClientPtr client, SyncAlarm *pAlarm, Mask mask,
-			  CARD32 *values)
-{
-    int		   status;
-    XSyncCounter   counter;
-    Mask	   origmask = mask;
-
-    counter =
-	pAlarm->trigger.pSync ? pAlarm->trigger.pSync->id : None;
-
-    while (mask)
-    {
-	int    index2 = lowbit(mask);
-	mask &= ~index2;
-	switch (index2)
-	{
-	  case XSyncCACounter:
-	    mask &= ~XSyncCACounter;
-	    /* sanity check in SyncInitTrigger */
-	    counter = *values++;
-	    break;
-
-	  case XSyncCAValueType:
-	    mask &= ~XSyncCAValueType;
-	    /* sanity check in SyncInitTrigger */
-	    pAlarm->trigger.value_type = *values++;
-	    break;
-
-	  case XSyncCAValue:
-	    mask &= ~XSyncCAValue;
-	    XSyncIntsToValue(&pAlarm->trigger.wait_value, values[1], values[0]);
-	    values += 2;
-	    break;
-
-	  case XSyncCATestType:
-	    mask &= ~XSyncCATestType;
-	    /* sanity check in SyncInitTrigger */
-	    pAlarm->trigger.test_type = *values++;
-	    break;
-
-	  case XSyncCADelta:
-	    mask &= ~XSyncCADelta;
-	    XSyncIntsToValue(&pAlarm->delta, values[1], values[0]);
-	    values += 2;
-	    break;
-
-	  case XSyncCAEvents:
-	    mask &= ~XSyncCAEvents;
-	    if ((*values != xTrue) && (*values != xFalse))
-	    {
-		client->errorValue = *values;
-		return BadValue;
-	    }
-	    status = SyncEventSelectForAlarm(pAlarm, client,
-					     (Bool)(*values++));
-	    if (status != Success)
-		return status;
-	    break;
-
-	  default:
-	    client->errorValue = mask;
-	    return BadValue;
-	}
+SyncChangeAlarmAttributes(ClientPtr client, SyncAlarm * pAlarm, Mask mask,
+                          CARD32 *values)
+{
+    int status;
+    XSyncCounter counter;
+    Mask origmask = mask;
+
+    counter = pAlarm->trigger.pSync ? pAlarm->trigger.pSync->id : None;
+
+    while (mask) {
+        int index2 = lowbit(mask);
+
+        mask &= ~index2;
+        switch (index2) {
+        case XSyncCACounter:
+            mask &= ~XSyncCACounter;
+            /* sanity check in SyncInitTrigger */
+            counter = *values++;
+            break;
+
+        case XSyncCAValueType:
+            mask &= ~XSyncCAValueType;
+            /* sanity check in SyncInitTrigger */
+            pAlarm->trigger.value_type = *values++;
+            break;
+
+        case XSyncCAValue:
+            mask &= ~XSyncCAValue;
+            XSyncIntsToValue(&pAlarm->trigger.wait_value, values[1], values[0]);
+            values += 2;
+            break;
+
+        case XSyncCATestType:
+            mask &= ~XSyncCATestType;
+            /* sanity check in SyncInitTrigger */
+            pAlarm->trigger.test_type = *values++;
+            break;
+
+        case XSyncCADelta:
+            mask &= ~XSyncCADelta;
+            XSyncIntsToValue(&pAlarm->delta, values[1], values[0]);
+            values += 2;
+            break;
+
+        case XSyncCAEvents:
+            mask &= ~XSyncCAEvents;
+            if ((*values != xTrue) && (*values != xFalse)) {
+                client->errorValue = *values;
+                return BadValue;
+            }
+            status = SyncEventSelectForAlarm(pAlarm, client,
+                                             (Bool) (*values++));
+            if (status != Success)
+                return status;
+            break;
+
+        default:
+            client->errorValue = mask;
+            return BadValue;
+        }
     }
 
     /* "If the test-type is PositiveComparison or PositiveTransition
@@ -887,27 +851,26 @@ SyncChangeAlarmAttributes(ClientPtr client, SyncAlarm *pAlarm, Mask mask,
      *  NegativeComparison or NegativeTransition and delta is
      *  greater than zero, a Match error is generated."
      */
-    if (origmask & (XSyncCADelta|XSyncCATestType))
-    {
-	CARD64 zero;
-	XSyncIntToValue(&zero, 0);
-	if ((((pAlarm->trigger.test_type == XSyncPositiveComparison) ||
-	      (pAlarm->trigger.test_type == XSyncPositiveTransition))
-	     && XSyncValueLessThan(pAlarm->delta, zero))
-	    ||
-	    (((pAlarm->trigger.test_type == XSyncNegativeComparison) ||
-	      (pAlarm->trigger.test_type == XSyncNegativeTransition))
-	     && XSyncValueGreaterThan(pAlarm->delta, zero))
-	   )
-	{
-	    return BadMatch;
-	}
+    if (origmask & (XSyncCADelta | XSyncCATestType)) {
+        CARD64 zero;
+
+        XSyncIntToValue(&zero, 0);
+        if ((((pAlarm->trigger.test_type == XSyncPositiveComparison) ||
+              (pAlarm->trigger.test_type == XSyncPositiveTransition))
+             && XSyncValueLessThan(pAlarm->delta, zero))
+            ||
+            (((pAlarm->trigger.test_type == XSyncNegativeComparison) ||
+              (pAlarm->trigger.test_type == XSyncNegativeTransition))
+             && XSyncValueGreaterThan(pAlarm->delta, zero))
+            ) {
+            return BadMatch;
+        }
     }
 
     /* postpone this until now, when we're sure nothing else can go wrong */
     if ((status = SyncInitTrigger(client, &pAlarm->trigger, counter, RTCounter,
-			     origmask & XSyncCAAllTrigger)) != Success)
-	return status;
+                                  origmask & XSyncCAAllTrigger)) != Success)
+        return status;
 
     /* XXX spec does not really say to do this - needs clarification */
     pAlarm->state = XSyncAlarmActive;
@@ -921,18 +884,18 @@ SyncCreate(ClientPtr client, XID id, unsigned char type)
 
     switch (type) {
     case SYNC_COUNTER:
-	pSync = malloc(sizeof(SyncCounter));
-	break;
+        pSync = malloc(sizeof(SyncCounter));
+        break;
     case SYNC_FENCE:
-	pSync = (SyncObject*)dixAllocateObjectWithPrivates(SyncFence,
-							   PRIVATE_SYNC_FENCE);
-	break;
+        pSync = (SyncObject *) dixAllocateObjectWithPrivates(SyncFence,
+                                                             PRIVATE_SYNC_FENCE);
+        break;
     default:
-	return NULL;
+        return NULL;
     }
 
     if (!pSync)
-	return NULL;
+        return NULL;
 
     pSync->client = client;
     pSync->id = id;
@@ -943,22 +906,19 @@ SyncCreate(ClientPtr client, XID id, unsigned char type)
     return pSync;
 }
 
-
 static SyncCounter *
 SyncCreateCounter(ClientPtr client, XSyncCounter id, CARD64 initialvalue)
 {
     SyncCounter *pCounter;
 
-    if (!(pCounter = (SyncCounter *)SyncCreate(client,
-					       id,
-					       SYNC_COUNTER)))
-	return NULL;
+    if (!(pCounter = (SyncCounter *) SyncCreate(client, id, SYNC_COUNTER)))
+        return NULL;
 
     pCounter->value = initialvalue;
     pCounter->pSysCounterInfo = NULL;
 
     if (!AddResource(id, RTCounter, (pointer) pCounter))
-	return NULL;
+        return NULL;
 
     return pCounter;
 }
@@ -969,59 +929,48 @@ static int FreeCounter(void *, XID);
  * ***** System Counter utilities
  */
 
-pointer
-SyncCreateSystemCounter(
-	const char *name,
-	CARD64 initial,
-	CARD64 resolution,
-	SyncCounterType counterType,
-	void (*QueryValue)(pointer /* pCounter */,
-	      	           CARD64 * /* pValue_return */),
-	void (*BracketValues)(pointer /* pCounter */,
-	       	              CARD64 * /* pbracket_less */,
-	                      CARD64 * /* pbracket_greater */)
-	)
-{
-    SyncCounter    *pCounter;
-
-    SysCounterList = realloc(SysCounterList,
-			    (SyncNumSystemCounters+1)*sizeof(SyncCounter *));
-    if (!SysCounterList)
-	return NULL;
+SyncCounter*
+SyncCreateSystemCounter(const char *name,
+                        CARD64 initial,
+                        CARD64 resolution,
+                        SyncCounterType counterType,
+                        SyncSystemCounterQueryValue QueryValue,
+                        SyncSystemCounterBracketValues BracketValues
+    )
+{
+    SyncCounter *pCounter;
 
     /* this function may be called before SYNC has been initialized, so we
      * have to make sure RTCounter is created.
      */
-    if (RTCounter == 0)
-    {
-	RTCounter = CreateNewResourceType(FreeCounter, "SyncCounter");
-	if (RTCounter == 0)
-	{
-	    return NULL;
-	}
+    if (RTCounter == 0) {
+        RTCounter = CreateNewResourceType(FreeCounter, "SyncCounter");
+        if (RTCounter == 0) {
+            return NULL;
+        }
     }
 
     pCounter = SyncCreateCounter(NULL, FakeClientID(0), initial);
 
-    if (pCounter)
-    {
-	SysCounterInfo *psci;
-
-	psci = malloc(sizeof(SysCounterInfo));
-	if (!psci)
-	{
-	    FreeResource(pCounter->sync.id, RT_NONE);
-	    return pCounter;
-	}
-	pCounter->pSysCounterInfo = psci;
-	psci->name = name;
-	psci->resolution = resolution;
-	psci->counterType = counterType;
-	psci->QueryValue = QueryValue;
-	psci->BracketValues = BracketValues;
-	XSyncMaxValue(&psci->bracket_greater);
-	XSyncMinValue(&psci->bracket_less);
-	SysCounterList[SyncNumSystemCounters++] = pCounter;
+    if (pCounter) {
+        SysCounterInfo *psci;
+
+        psci = malloc(sizeof(SysCounterInfo));
+        if (!psci) {
+            FreeResource(pCounter->sync.id, RT_NONE);
+            return pCounter;
+        }
+        pCounter->pSysCounterInfo = psci;
+        psci->pCounter = pCounter;
+        psci->name = strdup(name);
+        psci->resolution = resolution;
+        psci->counterType = counterType;
+        psci->QueryValue = QueryValue;
+        psci->BracketValues = BracketValues;
+        psci->private = NULL;
+        XSyncMaxValue(&psci->bracket_greater);
+        XSyncMinValue(&psci->bracket_less);
+        xorg_list_add(&psci->entry, &SysCounterList);
     }
     return pCounter;
 }
@@ -1029,12 +978,13 @@ SyncCreateSystemCounter(
 void
 SyncDestroySystemCounter(pointer pSysCounter)
 {
-    SyncCounter *pCounter = (SyncCounter *)pSysCounter;
+    SyncCounter *pCounter = (SyncCounter *) pSysCounter;
+
     FreeResource(pCounter->sync.id, RT_NONE);
 }
 
 static void
-SyncComputeBracketValues(SyncCounter *pCounter)
+SyncComputeBracketValues(SyncCounter * pCounter)
 {
     SyncTriggerList *pCur;
     SyncTrigger *pTrigger;
@@ -1044,89 +994,81 @@ SyncComputeBracketValues(SyncCounter *pCounter)
     SyncCounterType ct;
 
     if (!pCounter)
-	return;
+        return;
 
     psci = pCounter->pSysCounterInfo;
     ct = pCounter->pSysCounterInfo->counterType;
     if (ct == XSyncCounterNeverChanges)
-	return;
+        return;
 
     XSyncMaxValue(&psci->bracket_greater);
     XSyncMinValue(&psci->bracket_less);
 
-    for (pCur = pCounter->sync.pTriglist; pCur; pCur = pCur->next)
-    {
-	pTrigger = pCur->pTrigger;
-	
+    for (pCur = pCounter->sync.pTriglist; pCur; pCur = pCur->next) {
+        pTrigger = pCur->pTrigger;
+
         if (pTrigger->test_type == XSyncPositiveComparison &&
-	    ct != XSyncCounterNeverIncreases)
-	{
-	    if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) &&
-		XSyncValueLessThan(pTrigger->test_value,
-				   psci->bracket_greater))
-	    {
-		psci->bracket_greater = pTrigger->test_value;
-		pnewgtval = &psci->bracket_greater;
-	    }
-	}
-	else if (pTrigger->test_type == XSyncNegativeComparison &&
-		 ct != XSyncCounterNeverDecreases)
-	{
-	    if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) &&
-		XSyncValueGreaterThan(pTrigger->test_value,
-				      psci->bracket_less))
-	    {
-		psci->bracket_less = pTrigger->test_value;
-		pnewltval = &psci->bracket_less;
-	    }
-	}
-	else if (pTrigger->test_type == XSyncNegativeTransition &&
-		   ct != XSyncCounterNeverIncreases)
-	{
-	    if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) &&
-		XSyncValueGreaterThan(pTrigger->test_value, psci->bracket_less))
-	    {
-		psci->bracket_less = pTrigger->test_value;
-		pnewltval = &psci->bracket_less;
-	    } else if (XSyncValueEqual(pCounter->value, pTrigger->test_value) &&
-		       XSyncValueLessThan(pTrigger->test_value,
-					  psci->bracket_greater))
-	    {
-	        /*
-		 * The value is exactly equal to our threshold.  We want one
-		 * more event in the positive direction to ensure we pick up
-		 * when the value *exceeds* this threshold.
-		 */
-	        psci->bracket_greater = pTrigger->test_value;
-		pnewgtval = &psci->bracket_greater;
-	    }
-	}
+            ct != XSyncCounterNeverIncreases) {
+            if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) &&
+                XSyncValueLessThan(pTrigger->test_value,
+                                   psci->bracket_greater)) {
+                psci->bracket_greater = pTrigger->test_value;
+                pnewgtval = &psci->bracket_greater;
+            }
+        }
+        else if (pTrigger->test_type == XSyncNegativeComparison &&
+                 ct != XSyncCounterNeverDecreases) {
+            if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) &&
+                XSyncValueGreaterThan(pTrigger->test_value,
+                                      psci->bracket_less)) {
+                psci->bracket_less = pTrigger->test_value;
+                pnewltval = &psci->bracket_less;
+            }
+        }
+        else if (pTrigger->test_type == XSyncNegativeTransition &&
+                 ct != XSyncCounterNeverIncreases) {
+            if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) &&
+                XSyncValueGreaterThan(pTrigger->test_value, psci->bracket_less))
+            {
+                psci->bracket_less = pTrigger->test_value;
+                pnewltval = &psci->bracket_less;
+            }
+            else if (XSyncValueEqual(pCounter->value, pTrigger->test_value) &&
+                     XSyncValueLessThan(pTrigger->test_value,
+                                        psci->bracket_greater)) {
+                /*
+                 * The value is exactly equal to our threshold.  We want one
+                 * more event in the positive direction to ensure we pick up
+                 * when the value *exceeds* this threshold.
+                 */
+                psci->bracket_greater = pTrigger->test_value;
+                pnewgtval = &psci->bracket_greater;
+            }
+        }
         else if (pTrigger->test_type == XSyncPositiveTransition &&
-		  ct != XSyncCounterNeverDecreases)
-	{
-	    if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) &&
-		XSyncValueLessThan(pTrigger->test_value, psci->bracket_greater))
-	    {
-		psci->bracket_greater = pTrigger->test_value;
-		pnewgtval = &psci->bracket_greater;
-	    } else if (XSyncValueEqual(pCounter->value, pTrigger->test_value) &&
-		       XSyncValueGreaterThan(pTrigger->test_value,
-					     psci->bracket_less))
-	    {
-	        /*
-		 * The value is exactly equal to our threshold.  We want one
-		 * more event in the negative direction to ensure we pick up
-		 * when the value is less than this threshold.
-		 */
-	        psci->bracket_less = pTrigger->test_value;
-		pnewltval = &psci->bracket_less;
-	    }
-	}
-    } /* end for each trigger */
-
-    if (pnewgtval || pnewltval)
-    {
-	(*psci->BracketValues)((pointer)pCounter, pnewltval, pnewgtval);
+                 ct != XSyncCounterNeverDecreases) {
+            if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) &&
+                XSyncValueLessThan(pTrigger->test_value, psci->bracket_greater))
+            {
+                psci->bracket_greater = pTrigger->test_value;
+                pnewgtval = &psci->bracket_greater;
+            }
+            else if (XSyncValueEqual(pCounter->value, pTrigger->test_value) &&
+                     XSyncValueGreaterThan(pTrigger->test_value,
+                                           psci->bracket_less)) {
+                /*
+                 * The value is exactly equal to our threshold.  We want one
+                 * more event in the negative direction to ensure we pick up
+                 * when the value is less than this threshold.
+                 */
+                psci->bracket_less = pTrigger->test_value;
+                pnewltval = &psci->bracket_less;
+            }
+        }
+    }                           /* end for each trigger */
+
+    if (pnewgtval || pnewltval) {
+        (*psci->BracketValues) ((pointer) pCounter, pnewltval, pnewgtval);
     }
 }
 
@@ -1138,7 +1080,7 @@ SyncComputeBracketValues(SyncCounter *pCounter)
 static int
 FreeAlarm(void *addr, XID id)
 {
-    SyncAlarm      *pAlarm = (SyncAlarm *) addr;
+    SyncAlarm *pAlarm = (SyncAlarm *) addr;
 
     pAlarm->state = XSyncAlarmDestroyed;
 
@@ -1147,7 +1089,7 @@ FreeAlarm(void *addr, XID id)
     /* delete event selections */
 
     while (pAlarm->pEventClients)
-	FreeResource(pAlarm->pEventClients->delete_id, RT_NONE);
+        FreeResource(pAlarm->pEventClients->delete_id, RT_NONE);
 
     SyncDeleteTriggerFromSyncObject(&pAlarm->trigger);
 
@@ -1155,7 +1097,6 @@ FreeAlarm(void *addr, XID id)
     return Success;
 }
 
-
 /*
  * ** Cleanup after the destruction of a Counter
  */
@@ -1163,44 +1104,21 @@ FreeAlarm(void *addr, XID id)
 static int
 FreeCounter(void *env, XID id)
 {
-    SyncCounter     *pCounter = (SyncCounter *) env;
+    SyncCounter *pCounter = (SyncCounter *) env;
     SyncTriggerList *ptl, *pnext;
 
     pCounter->sync.beingDestroyed = TRUE;
     /* tell all the counter's triggers that the counter has been destroyed */
-    for (ptl = pCounter->sync.pTriglist; ptl; ptl = pnext)
-    {
-	(*ptl->pTrigger->CounterDestroyed)(ptl->pTrigger);
-	pnext = ptl->next;
-	free(ptl); /* destroy the trigger list as we go */
-    }
-    if (IsSystemCounter(pCounter))
-    {
-	int i, found = 0;
-
-	free(pCounter->pSysCounterInfo);
-
-	/* find the counter in the list of system counters and remove it */
-
-	if (SysCounterList)
-	{
-	    for (i = 0; i < SyncNumSystemCounters; i++)
-	    {
-		if (SysCounterList[i] == pCounter)
-		{
-		    found = i;
-		    break;
-		}
-	    }
-	    if (found < (SyncNumSystemCounters-1))
-	    {
-		for (i = found; i < SyncNumSystemCounters-1; i++)
-		{
-		    SysCounterList[i] = SysCounterList[i+1];
-		}
-	    }
-	}
-	SyncNumSystemCounters--;
+    for (ptl = pCounter->sync.pTriglist; ptl; ptl = pnext) {
+        (*ptl->pTrigger->CounterDestroyed) (ptl->pTrigger);
+        pnext = ptl->next;
+        free(ptl);              /* destroy the trigger list as we go */
+    }
+    if (IsSystemCounter(pCounter)) {
+        xorg_list_del(&pCounter->pSysCounterInfo->entry);
+        free(pCounter->pSysCounterInfo->name);
+        free(pCounter->pSysCounterInfo->private);
+        free(pCounter->pSysCounterInfo);
     }
     free(pCounter);
     return Success;
@@ -1217,19 +1135,19 @@ FreeAwait(void *addr, XID id)
     SyncAwait *pAwait;
     int numwaits;
 
-    pAwait = &(pAwaitUnion+1)->await; /* first await on list */
+    pAwait = &(pAwaitUnion + 1)->await; /* first await on list */
 
     /* remove triggers from counters */
 
     for (numwaits = pAwaitUnion->header.num_waitconditions; numwaits;
-	 numwaits--, pAwait++)
-    {
-	/* If the counter is being destroyed, FreeCounter will delete
-	 * the trigger list itself, so don't do it here.
-	 */
-	SyncObject *pSync = pAwait->trigger.pSync;
-	if (pSync && !pSync->beingDestroyed)
-	    SyncDeleteTriggerFromSyncObject(&pAwait->trigger);
+         numwaits--, pAwait++) {
+        /* If the counter is being destroyed, FreeCounter will delete
+         * the trigger list itself, so don't do it here.
+         */
+        SyncObject *pSync = pAwait->trigger.pSync;
+
+        if (pSync && !pSync->beingDestroyed)
+            SyncDeleteTriggerFromSyncObject(&pAwait->trigger);
     }
     free(pAwaitUnion);
     return Success;
@@ -1243,40 +1161,35 @@ FreeAwait(void *addr, XID id)
 static int
 FreeAlarmClient(void *value, XID id)
 {
-    SyncAlarm *pAlarm = (SyncAlarm *)value;
+    SyncAlarm *pAlarm = (SyncAlarm *) value;
     SyncAlarmClientList *pCur, *pPrev;
 
     for (pPrev = NULL, pCur = pAlarm->pEventClients;
-	 pCur;
-	 pPrev = pCur, pCur = pCur->next)
-    {
-	if (pCur->delete_id == id)
-	{
-	    if (pPrev)
-		pPrev->next = pCur->next;
-	    else
-		pAlarm->pEventClients = pCur->next;
-	    free(pCur);
-	    return Success;
-	}
+         pCur; pPrev = pCur, pCur = pCur->next) {
+        if (pCur->delete_id == id) {
+            if (pPrev)
+                pPrev->next = pCur->next;
+            else
+                pAlarm->pEventClients = pCur->next;
+            free(pCur);
+            return Success;
+        }
     }
     FatalError("alarm client not on event list");
-    /*NOTREACHED*/
-}
-
+ /*NOTREACHED*/}
 
 /*
  * *****  Proc functions
  */
 
-
 /*
  * ** Initialize the extension
  */
 static int
 ProcSyncInitialize(ClientPtr client)
 {
-    xSyncInitializeReply  rep;
+    xSyncInitializeReply rep;
+
     REQUEST_SIZE_MATCH(xSyncInitializeReq);
 
     memset(&rep, 0, sizeof(xSyncInitializeReply));
@@ -1286,9 +1199,8 @@ ProcSyncInitialize(ClientPtr client)
     rep.minorVersion = SERVER_SYNC_MINOR_VERSION;
     rep.length = 0;
 
-    if (client->swapped)
-    {
-	swaps(&rep.sequenceNumber);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
     }
     WriteToClient(client, sizeof(rep), (char *) &rep);
     return Success;
@@ -1300,70 +1212,65 @@ ProcSyncInitialize(ClientPtr client)
 static int
 ProcSyncListSystemCounters(ClientPtr client)
 {
-    xSyncListSystemCountersReply  rep;
-    int i, len;
+    xSyncListSystemCountersReply rep;
+    SysCounterInfo *psci=NULL;
+    int len = 0;
     xSyncSystemCounter *list = NULL, *walklist = NULL;
 
     REQUEST_SIZE_MATCH(xSyncListSystemCountersReq);
 
     rep.type = X_Reply;
     rep.sequenceNumber = client->sequence;
-    rep.nCounters = SyncNumSystemCounters;
+    rep.nCounters = 0;
 
-    for (i = len = 0; i < SyncNumSystemCounters; i++)
-    {
-	const char *name = SysCounterList[i]->pSysCounterInfo->name;
-	/* pad to 4 byte boundary */
-	len += pad_to_int32(sz_xSyncSystemCounter + strlen(name));
+    xorg_list_for_each_entry(psci, &SysCounterList, entry) {
+        /* pad to 4 byte boundary */
+        len += pad_to_int32(sz_xSyncSystemCounter + strlen(psci->name));
+        ++rep.nCounters;
     }
 
-    if (len)
-    {
-	walklist = list = malloc(len);
-	if (!list)
-	    return BadAlloc;
+    if (len) {
+        walklist = list = malloc(len);
+        if (!list)
+            return BadAlloc;
     }
 
     rep.length = bytes_to_int32(len);
 
-    if (client->swapped)
-    {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
-	swapl(&rep.nCounters);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.nCounters);
     }
 
-    for (i = 0; i < SyncNumSystemCounters; i++)
-    {
-	int namelen;
-	char *pname_in_reply;
-	SysCounterInfo *psci = SysCounterList[i]->pSysCounterInfo;
+    xorg_list_for_each_entry(psci, &SysCounterList, entry) {
+        int namelen;
+        char *pname_in_reply;
 
-	walklist->counter = SysCounterList[i]->sync.id;
-	walklist->resolution_hi = XSyncValueHigh32(psci->resolution);
-	walklist->resolution_lo = XSyncValueLow32(psci->resolution);
-	namelen = strlen(psci->name);
-	walklist->name_length = namelen;
+        walklist->counter = psci->pCounter->sync.id;
+        walklist->resolution_hi = XSyncValueHigh32(psci->resolution);
+        walklist->resolution_lo = XSyncValueLow32(psci->resolution);
+        namelen = strlen(psci->name);
+        walklist->name_length = namelen;
 
-	if (client->swapped)
-	{
-	    swapl(&walklist->counter);
-	    swapl(&walklist->resolution_hi);
-	    swapl(&walklist->resolution_lo);
-	    swaps(&walklist->name_length);
-	}
+        if (client->swapped) {
+            swapl(&walklist->counter);
+            swapl(&walklist->resolution_hi);
+            swapl(&walklist->resolution_lo);
+            swaps(&walklist->name_length);
+        }
 
-	pname_in_reply = ((char *)walklist) + sz_xSyncSystemCounter;
-	strncpy(pname_in_reply, psci->name, namelen);
-	walklist = (xSyncSystemCounter *) (((char *)walklist) +
-				pad_to_int32(sz_xSyncSystemCounter + namelen));
+        pname_in_reply = ((char *) walklist) + sz_xSyncSystemCounter;
+        strncpy(pname_in_reply, psci->name, namelen);
+        walklist = (xSyncSystemCounter *) (((char *) walklist) +
+                                           pad_to_int32(sz_xSyncSystemCounter +
+                                                        namelen));
     }
 
     WriteToClient(client, sizeof(rep), (char *) &rep);
-    if (len)
-    {
-	WriteToClient(client, len, (char *) list);
-	free(list);
+    if (len) {
+        WriteToClient(client, len, (char *) list);
+        free(list);
     }
 
     return Success;
@@ -1382,24 +1289,23 @@ ProcSyncSetPriority(ClientPtr client)
     REQUEST_SIZE_MATCH(xSyncSetPriorityReq);
 
     if (stuff->id == None)
-	priorityclient = client;
+        priorityclient = client;
     else {
-	rc = dixLookupClient(&priorityclient, stuff->id, client,
-			     DixSetAttrAccess);
-	if (rc != Success)
-	    return rc;
+        rc = dixLookupClient(&priorityclient, stuff->id, client,
+                             DixSetAttrAccess);
+        if (rc != Success)
+            return rc;
     }
 
-    if (priorityclient->priority != stuff->priority)
-    {
-	priorityclient->priority = stuff->priority;
+    if (priorityclient->priority != stuff->priority) {
+        priorityclient->priority = stuff->priority;
 
-	/*  The following will force the server back into WaitForSomething
-	 *  so that the change in this client's priority is immediately
-	 *  reflected.
-	 */
-	isItTimeToYield = TRUE;
-	dispatchException |= DE_PRIORITYCHANGE;
+        /*  The following will force the server back into WaitForSomething
+         *  so that the change in this client's priority is immediately
+         *  reflected.
+         */
+        isItTimeToYield = TRUE;
+        dispatchException |= DE_PRIORITYCHANGE;
     }
     return Success;
 }
@@ -1418,12 +1324,12 @@ ProcSyncGetPriority(ClientPtr client)
     REQUEST_SIZE_MATCH(xSyncGetPriorityReq);
 
     if (stuff->id == None)
-	priorityclient = client;
+        priorityclient = client;
     else {
-	rc = dixLookupClient(&priorityclient, stuff->id, client,
-			     DixGetAttrAccess);
-	if (rc != Success)
-	    return rc;
+        rc = dixLookupClient(&priorityclient, stuff->id, client,
+                             DixGetAttrAccess);
+        if (rc != Success)
+            return rc;
     }
 
     rep.type = X_Reply;
@@ -1431,10 +1337,9 @@ ProcSyncGetPriority(ClientPtr client)
     rep.sequenceNumber = client->sequence;
     rep.priority = priorityclient->priority;
 
-    if (client->swapped)
-    {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.priority);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.priority);
     }
 
     WriteToClient(client, sizeof(xSyncGetPriorityReply), (char *) &rep);
@@ -1449,15 +1354,16 @@ static int
 ProcSyncCreateCounter(ClientPtr client)
 {
     REQUEST(xSyncCreateCounterReq);
-    CARD64          initial;
+    CARD64 initial;
 
     REQUEST_SIZE_MATCH(xSyncCreateCounterReq);
 
     LEGAL_NEW_RESOURCE(stuff->cid, client);
 
-    XSyncIntsToValue(&initial, stuff->initial_value_lo, stuff->initial_value_hi);
+    XSyncIntsToValue(&initial, stuff->initial_value_lo,
+                     stuff->initial_value_hi);
     if (!SyncCreateCounter(client, stuff->cid, initial))
-	return BadAlloc;
+        return BadAlloc;
 
     return Success;
 }
@@ -1469,21 +1375,20 @@ static int
 ProcSyncSetCounter(ClientPtr client)
 {
     REQUEST(xSyncSetCounterReq);
-    SyncCounter    *pCounter;
-    CARD64	   newvalue;
-    int	rc;
+    SyncCounter *pCounter;
+    CARD64 newvalue;
+    int rc;
 
     REQUEST_SIZE_MATCH(xSyncSetCounterReq);
 
-    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->cid, RTCounter,
-				 client, DixWriteAccess);
+    rc = dixLookupResourceByType((pointer *) &pCounter, stuff->cid, RTCounter,
+                                 client, DixWriteAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
-    if (IsSystemCounter(pCounter))
-    {
-	client->errorValue = stuff->cid;
-	return BadAccess;
+    if (IsSystemCounter(pCounter)) {
+        client->errorValue = stuff->cid;
+        return BadAccess;
     }
 
     XSyncIntsToValue(&newvalue, stuff->value_lo, stuff->value_hi);
@@ -1498,31 +1403,29 @@ static int
 ProcSyncChangeCounter(ClientPtr client)
 {
     REQUEST(xSyncChangeCounterReq);
-    SyncCounter    *pCounter;
-    CARD64          newvalue;
-    Bool	    overflow;
-    int	rc;
+    SyncCounter *pCounter;
+    CARD64 newvalue;
+    Bool overflow;
+    int rc;
 
     REQUEST_SIZE_MATCH(xSyncChangeCounterReq);
 
-    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->cid, RTCounter,
-				 client, DixWriteAccess);
+    rc = dixLookupResourceByType((pointer *) &pCounter, stuff->cid, RTCounter,
+                                 client, DixWriteAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
-    if (IsSystemCounter(pCounter))
-    {
-	client->errorValue = stuff->cid;
-	return BadAccess;
+    if (IsSystemCounter(pCounter)) {
+        client->errorValue = stuff->cid;
+        return BadAccess;
     }
 
     XSyncIntsToValue(&newvalue, stuff->value_lo, stuff->value_hi);
     XSyncValueAdd(&newvalue, pCounter->value, newvalue, &overflow);
-    if (overflow)
-    {
-	/* XXX 64 bit value can't fit in 32 bits; do the best we can */
-	client->errorValue = stuff->value_hi;
-	return BadValue;
+    if (overflow) {
+        /* XXX 64 bit value can't fit in 32 bits; do the best we can */
+        client->errorValue = stuff->value_hi;
+        return BadValue;
     }
     SyncChangeCounter(pCounter, newvalue);
     return Success;
@@ -1535,26 +1438,25 @@ static int
 ProcSyncDestroyCounter(ClientPtr client)
 {
     REQUEST(xSyncDestroyCounterReq);
-    SyncCounter    *pCounter;
+    SyncCounter *pCounter;
     int rc;
 
     REQUEST_SIZE_MATCH(xSyncDestroyCounterReq);
 
-    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->counter, RTCounter,
-				 client, DixDestroyAccess);
+    rc = dixLookupResourceByType((pointer *) &pCounter, stuff->counter,
+                                 RTCounter, client, DixDestroyAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
-    if (IsSystemCounter(pCounter))
-    {
-	client->errorValue = stuff->counter;
-	return BadAccess;
+    if (IsSystemCounter(pCounter)) {
+        client->errorValue = stuff->counter;
+        return BadAccess;
     }
     FreeResource(pCounter->sync.id, RT_NONE);
     return Success;
 }
 
-static SyncAwaitUnion*
+static SyncAwaitUnion *
 SyncAwaitPrologue(ClientPtr client, int items)
 {
     SyncAwaitUnion *pAwaitUnion;
@@ -1562,9 +1464,9 @@ SyncAwaitPrologue(ClientPtr client, int items)
     /*  all the memory for the entire await list is allocated
      *  here in one chunk
      */
-    pAwaitUnion = malloc((items+1) * sizeof(SyncAwaitUnion));
+    pAwaitUnion = malloc((items + 1) * sizeof(SyncAwaitUnion));
     if (!pAwaitUnion)
-	return NULL;
+        return NULL;
 
     /* first item is the header, remainder are real wait conditions */
 
@@ -1573,13 +1475,13 @@ SyncAwaitPrologue(ClientPtr client, int items)
     pAwaitUnion->header.num_waitconditions = 0;
 
     if (!AddResource(pAwaitUnion->header.delete_id, RTAwait, pAwaitUnion))
-	return NULL;
+        return NULL;
 
     return pAwaitUnion;
 }
 
 static void
-SyncAwaitEpilogue(ClientPtr client, int items, SyncAwaitUnion *pAwaitUnion)
+SyncAwaitEpilogue(ClientPtr client, int items, SyncAwaitUnion * pAwaitUnion)
 {
     SyncAwait *pAwait;
     int i;
@@ -1588,27 +1490,25 @@ SyncAwaitEpilogue(ClientPtr client, int items, SyncAwaitUnion *pAwaitUnion)
 
     /* see if any of the triggers are already true */
 
-    pAwait = &(pAwaitUnion+1)->await; /* skip over header */
-    for (i = 0; i < items; i++, pAwait++)
-    {
-	CARD64 value;
-
-	/*  don't have to worry about NULL counters because the request
-	 *  errors before we get here out if they occur
-	 */
-	switch (pAwait->trigger.pSync->type) {
-	case SYNC_COUNTER:
-	    value = ((SyncCounter *)pAwait->trigger.pSync)->value;
-	    break;
-	default:
-	    XSyncIntToValue(&value, 0);
-	}
+    pAwait = &(pAwaitUnion + 1)->await; /* skip over header */
+    for (i = 0; i < items; i++, pAwait++) {
+        CARD64 value;
+
+        /*  don't have to worry about NULL counters because the request
+         *  errors before we get here out if they occur
+         */
+        switch (pAwait->trigger.pSync->type) {
+        case SYNC_COUNTER:
+            value = ((SyncCounter *) pAwait->trigger.pSync)->value;
+            break;
+        default:
+            XSyncIntToValue(&value, 0);
+        }
 
-	if ((*pAwait->trigger.CheckTrigger)(&pAwait->trigger, value))
-	{
-	    (*pAwait->trigger.TriggerFired)(&pAwait->trigger);
-	    break; /* once is enough */
-	}
+        if ((*pAwait->trigger.CheckTrigger) (&pAwait->trigger, value)) {
+            (*pAwait->trigger.TriggerFired) (&pAwait->trigger);
+            break;              /* once is enough */
+        }
     }
 }
 
@@ -1619,12 +1519,12 @@ static int
 ProcSyncAwait(ClientPtr client)
 {
     REQUEST(xSyncAwaitReq);
-    int             len, items;
-    int             i;
+    int len, items;
+    int i;
     xSyncWaitCondition *pProtocolWaitConds;
     SyncAwaitUnion *pAwaitUnion;
-    SyncAwait	   *pAwait;
-    int		   status;
+    SyncAwait *pAwait;
+    int status;
 
     REQUEST_AT_LEAST_SIZE(xSyncAwaitReq);
 
@@ -1632,63 +1532,58 @@ ProcSyncAwait(ClientPtr client)
     len -= sz_xSyncAwaitReq;
     items = len / sz_xSyncWaitCondition;
 
-    if (items * sz_xSyncWaitCondition != len)
-    {
-	return BadLength;
+    if (items * sz_xSyncWaitCondition != len) {
+        return BadLength;
     }
-    if (items == 0)
-    {
-	client->errorValue = items; /* XXX protocol change */
-	return BadValue;
+    if (items == 0) {
+        client->errorValue = items;     /* XXX protocol change */
+        return BadValue;
     }
 
     if (!(pAwaitUnion = SyncAwaitPrologue(client, items)))
-	return BadAlloc;
+        return BadAlloc;
 
     /* don't need to do any more memory allocation for this request! */
 
-    pProtocolWaitConds = (xSyncWaitCondition *) & stuff[1];
-
-    pAwait = &(pAwaitUnion+1)->await; /* skip over header */
-    for (i = 0; i < items; i++, pProtocolWaitConds++, pAwait++)
-    {
-	if (pProtocolWaitConds->counter == None) /* XXX protocol change */
-	{
-	    /*  this should take care of removing any triggers created by
-	     *  this request that have already been registered on sync objects
-	     */
-	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
-	    client->errorValue = pProtocolWaitConds->counter;
-	    return SyncErrorBase + XSyncBadCounter;
-	}
-
-	/* sanity checks are in SyncInitTrigger */
-	pAwait->trigger.pSync = NULL;
-	pAwait->trigger.value_type = pProtocolWaitConds->value_type;
-	XSyncIntsToValue(&pAwait->trigger.wait_value,
-			 pProtocolWaitConds->wait_value_lo,
-			 pProtocolWaitConds->wait_value_hi);
-	pAwait->trigger.test_type = pProtocolWaitConds->test_type;
-
-	status = SyncInitTrigger(client, &pAwait->trigger,
-				 pProtocolWaitConds->counter, RTCounter,
-				 XSyncCAAllTrigger);
-	if (status != Success)
-	{
-	    /*  this should take care of removing any triggers created by
-	     *  this request that have already been registered on sync objects
-	     */
-	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
-	    return status;
-	}
-	/* this is not a mistake -- same function works for both cases */
-	pAwait->trigger.TriggerFired = SyncAwaitTriggerFired;
-	pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired;
-	XSyncIntsToValue(&pAwait->event_threshold,
-			 pProtocolWaitConds->event_threshold_lo,
-			 pProtocolWaitConds->event_threshold_hi);
-	pAwait->pHeader = &pAwaitUnion->header;
-	pAwaitUnion->header.num_waitconditions++;
+    pProtocolWaitConds = (xSyncWaitCondition *) &stuff[1];
+
+    pAwait = &(pAwaitUnion + 1)->await; /* skip over header */
+    for (i = 0; i < items; i++, pProtocolWaitConds++, pAwait++) {
+        if (pProtocolWaitConds->counter == None) {      /* XXX protocol change */
+            /*  this should take care of removing any triggers created by
+             *  this request that have already been registered on sync objects
+             */
+            FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
+            client->errorValue = pProtocolWaitConds->counter;
+            return SyncErrorBase + XSyncBadCounter;
+        }
+
+        /* sanity checks are in SyncInitTrigger */
+        pAwait->trigger.pSync = NULL;
+        pAwait->trigger.value_type = pProtocolWaitConds->value_type;
+        XSyncIntsToValue(&pAwait->trigger.wait_value,
+                         pProtocolWaitConds->wait_value_lo,
+                         pProtocolWaitConds->wait_value_hi);
+        pAwait->trigger.test_type = pProtocolWaitConds->test_type;
+
+        status = SyncInitTrigger(client, &pAwait->trigger,
+                                 pProtocolWaitConds->counter, RTCounter,
+                                 XSyncCAAllTrigger);
+        if (status != Success) {
+            /*  this should take care of removing any triggers created by
+             *  this request that have already been registered on sync objects
+             */
+            FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
+            return status;
+        }
+        /* this is not a mistake -- same function works for both cases */
+        pAwait->trigger.TriggerFired = SyncAwaitTriggerFired;
+        pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired;
+        XSyncIntsToValue(&pAwait->event_threshold,
+                         pProtocolWaitConds->event_threshold_lo,
+                         pProtocolWaitConds->event_threshold_hi);
+        pAwait->pHeader = &pAwaitUnion->header;
+        pAwaitUnion->header.num_waitconditions++;
     }
 
     SyncAwaitEpilogue(client, items, pAwaitUnion);
@@ -1696,7 +1591,6 @@ ProcSyncAwait(ClientPtr client)
     return Success;
 }
 
-
 /*
  * ** Query a counter
  */
@@ -1705,15 +1599,15 @@ ProcSyncQueryCounter(ClientPtr client)
 {
     REQUEST(xSyncQueryCounterReq);
     xSyncQueryCounterReply rep;
-    SyncCounter    *pCounter;
+    SyncCounter *pCounter;
     int rc;
 
     REQUEST_SIZE_MATCH(xSyncQueryCounterReq);
 
-    rc = dixLookupResourceByType((pointer *)&pCounter, stuff->counter,
-				 RTCounter, client, DixReadAccess);
+    rc = dixLookupResourceByType((pointer *) &pCounter, stuff->counter,
+                                 RTCounter, client, DixReadAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     rep.type = X_Reply;
     rep.length = 0;
@@ -1721,26 +1615,23 @@ ProcSyncQueryCounter(ClientPtr client)
 
     /* if system counter, ask it what the current value is */
 
-    if (IsSystemCounter(pCounter))
-    {
-	(*pCounter->pSysCounterInfo->QueryValue) ((pointer) pCounter,
-						  &pCounter->value);
+    if (IsSystemCounter(pCounter)) {
+        (*pCounter->pSysCounterInfo->QueryValue) ((pointer) pCounter,
+                                                  &pCounter->value);
     }
 
     rep.value_hi = XSyncValueHigh32(pCounter->value);
     rep.value_lo = XSyncValueLow32(pCounter->value);
-    if (client->swapped)
-    {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
-	swapl(&rep.value_hi);
-	swapl(&rep.value_lo);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.value_hi);
+        swapl(&rep.value_lo);
     }
     WriteToClient(client, sizeof(xSyncQueryCounterReply), (char *) &rep);
     return Success;
 }
 
-
 /*
  * ** Create Alarm
  */
@@ -1748,10 +1639,10 @@ static int
 ProcSyncCreateAlarm(ClientPtr client)
 {
     REQUEST(xSyncCreateAlarmReq);
-    SyncAlarm      *pAlarm;
-    int             status;
-    unsigned long   len, vmask;
-    SyncTrigger	    *pTrigger;
+    SyncAlarm *pAlarm;
+    int status;
+    unsigned long len, vmask;
+    SyncTrigger *pTrigger;
 
     REQUEST_AT_LEAST_SIZE(xSyncCreateAlarmReq);
 
@@ -1760,12 +1651,11 @@ ProcSyncCreateAlarm(ClientPtr client)
     vmask = stuff->valueMask;
     len = client->req_len - bytes_to_int32(sizeof(xSyncCreateAlarmReq));
     /* the "extra" call to Ones accounts for the presence of 64 bit values */
-    if (len != (Ones(vmask) + Ones(vmask & (XSyncCAValue|XSyncCADelta))))
-	return BadLength;
+    if (len != (Ones(vmask) + Ones(vmask & (XSyncCAValue | XSyncCADelta))))
+        return BadLength;
 
-    if (!(pAlarm = malloc(sizeof(SyncAlarm))))
-    {
-	return BadAlloc;
+    if (!(pAlarm = malloc(sizeof(SyncAlarm)))) {
+        return BadAlloc;
     }
 
     /* set up defaults */
@@ -1778,11 +1668,10 @@ ProcSyncCreateAlarm(ClientPtr client)
     pTrigger->TriggerFired = SyncAlarmTriggerFired;
     pTrigger->CounterDestroyed = SyncAlarmCounterDestroyed;
     status = SyncInitTrigger(client, pTrigger, None, RTCounter,
-			     XSyncCAAllTrigger);
-    if (status != Success)
-    {
-	free(pAlarm);
-	return status;
+                             XSyncCAAllTrigger);
+    if (status != Success) {
+        free(pAlarm);
+        return status;
     }
 
     pAlarm->client = client;
@@ -1792,39 +1681,35 @@ ProcSyncCreateAlarm(ClientPtr client)
     pAlarm->state = XSyncAlarmInactive;
     pAlarm->pEventClients = NULL;
     status = SyncChangeAlarmAttributes(client, pAlarm, vmask,
-				       (CARD32 *)&stuff[1]);
-    if (status != Success)
-    {
-	free(pAlarm);
-	return status;
+                                       (CARD32 *) &stuff[1]);
+    if (status != Success) {
+        free(pAlarm);
+        return status;
     }
 
     if (!AddResource(stuff->id, RTAlarm, pAlarm))
-	return BadAlloc;
+        return BadAlloc;
 
     /*  see if alarm already triggered.  NULL counter will not trigger
      *  in CreateAlarm and sets alarm state to Inactive.
      */
 
-    if (!pTrigger->pSync)
-    {
-	pAlarm->state = XSyncAlarmInactive; /* XXX protocol change */
+    if (!pTrigger->pSync) {
+        pAlarm->state = XSyncAlarmInactive;     /* XXX protocol change */
     }
-    else
-    {
-	SyncCounter *pCounter;
+    else {
+        SyncCounter *pCounter;
 
-	if (!SyncCheckWarnIsCounter(pTrigger->pSync,
-				    WARN_INVALID_COUNTER_ALARM))
-	{
-	    FreeResource(stuff->id, RT_NONE);
-	    return BadAlloc;
-	}
+        if (!SyncCheckWarnIsCounter(pTrigger->pSync,
+                                    WARN_INVALID_COUNTER_ALARM)) {
+            FreeResource(stuff->id, RT_NONE);
+            return BadAlloc;
+        }
 
-	pCounter = (SyncCounter *)pTrigger->pSync;
+        pCounter = (SyncCounter *) pTrigger->pSync;
 
-	if ((*pTrigger->CheckTrigger)(pTrigger, pCounter->value))
-	    (*pTrigger->TriggerFired)(pTrigger);
+        if ((*pTrigger->CheckTrigger) (pTrigger, pCounter->value))
+            (*pTrigger->TriggerFired) (pTrigger);
     }
 
     return Success;
@@ -1837,40 +1722,39 @@ static int
 ProcSyncChangeAlarm(ClientPtr client)
 {
     REQUEST(xSyncChangeAlarmReq);
-    SyncAlarm   *pAlarm;
+    SyncAlarm *pAlarm;
     SyncCounter *pCounter = NULL;
-    long        vmask;
-    int         len, status;
+    long vmask;
+    int len, status;
 
     REQUEST_AT_LEAST_SIZE(xSyncChangeAlarmReq);
 
-    status = dixLookupResourceByType((pointer *)&pAlarm, stuff->alarm, RTAlarm,
-				     client, DixWriteAccess);
+    status = dixLookupResourceByType((pointer *) &pAlarm, stuff->alarm, RTAlarm,
+                                     client, DixWriteAccess);
     if (status != Success)
-	return status;
+        return status;
 
     vmask = stuff->valueMask;
     len = client->req_len - bytes_to_int32(sizeof(xSyncChangeAlarmReq));
     /* the "extra" call to Ones accounts for the presence of 64 bit values */
-    if (len != (Ones(vmask) + Ones(vmask & (XSyncCAValue|XSyncCADelta))))
-	return BadLength;
+    if (len != (Ones(vmask) + Ones(vmask & (XSyncCAValue | XSyncCADelta))))
+        return BadLength;
 
     if ((status = SyncChangeAlarmAttributes(client, pAlarm, vmask,
-					    (CARD32 *)&stuff[1])) != Success)
-	return status;
+                                            (CARD32 *) &stuff[1])) != Success)
+        return status;
 
     if (SyncCheckWarnIsCounter(pAlarm->trigger.pSync,
-			       WARN_INVALID_COUNTER_ALARM))
-	pCounter = (SyncCounter *)pAlarm->trigger.pSync;
+                               WARN_INVALID_COUNTER_ALARM))
+        pCounter = (SyncCounter *) pAlarm->trigger.pSync;
 
     /*  see if alarm already triggered.  NULL counter WILL trigger
      *  in ChangeAlarm.
      */
 
     if (!pCounter ||
-	(*pAlarm->trigger.CheckTrigger)(&pAlarm->trigger, pCounter->value))
-    {
-	(*pAlarm->trigger.TriggerFired)(&pAlarm->trigger);
+        (*pAlarm->trigger.CheckTrigger) (&pAlarm->trigger, pCounter->value)) {
+        (*pAlarm->trigger.TriggerFired) (&pAlarm->trigger);
     }
     return Success;
 }
@@ -1879,29 +1763,30 @@ static int
 ProcSyncQueryAlarm(ClientPtr client)
 {
     REQUEST(xSyncQueryAlarmReq);
-    SyncAlarm      *pAlarm;
+    SyncAlarm *pAlarm;
     xSyncQueryAlarmReply rep;
-    SyncTrigger    *pTrigger;
+    SyncTrigger *pTrigger;
     int rc;
 
     REQUEST_SIZE_MATCH(xSyncQueryAlarmReq);
 
-    rc = dixLookupResourceByType((pointer *)&pAlarm, stuff->alarm, RTAlarm,
-				 client, DixReadAccess);
+    rc = dixLookupResourceByType((pointer *) &pAlarm, stuff->alarm, RTAlarm,
+                                 client, DixReadAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     rep.type = X_Reply;
-    rep.length = bytes_to_int32(sizeof(xSyncQueryAlarmReply) - sizeof(xGenericReply));
+    rep.length =
+        bytes_to_int32(sizeof(xSyncQueryAlarmReply) - sizeof(xGenericReply));
     rep.sequenceNumber = client->sequence;
 
     pTrigger = &pAlarm->trigger;
     rep.counter = (pTrigger->pSync) ? pTrigger->pSync->id : None;
 
-#if 0 /* XXX unclear what to do, depends on whether relative value-types
-       * are "consumed" immediately and are considered absolute from then
-       * on.
-       */
+#if 0                           /* XXX unclear what to do, depends on whether relative value-types
+                                 * are "consumed" immediately and are considered absolute from then
+                                 * on.
+                                 */
     rep.value_type = pTrigger->value_type;
     rep.wait_value_hi = XSyncValueHigh32(pTrigger->wait_value);
     rep.wait_value_lo = XSyncValueLow32(pTrigger->wait_value);
@@ -1917,16 +1802,15 @@ ProcSyncQueryAlarm(ClientPtr client)
     rep.events = pAlarm->events;
     rep.state = pAlarm->state;
 
-    if (client->swapped)
-    {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
-	swapl(&rep.counter);
-	swapl(&rep.wait_value_hi);
-	swapl(&rep.wait_value_lo);
-	swapl(&rep.test_type);
-	swapl(&rep.delta_hi);
-	swapl(&rep.delta_lo);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
+        swapl(&rep.counter);
+        swapl(&rep.wait_value_hi);
+        swapl(&rep.wait_value_lo);
+        swapl(&rep.test_type);
+        swapl(&rep.delta_hi);
+        swapl(&rep.delta_lo);
     }
 
     WriteToClient(client, sizeof(xSyncQueryAlarmReply), (char *) &rep);
@@ -1938,14 +1822,15 @@ ProcSyncDestroyAlarm(ClientPtr client)
 {
     SyncAlarm *pAlarm;
     int rc;
+
     REQUEST(xSyncDestroyAlarmReq);
 
     REQUEST_SIZE_MATCH(xSyncDestroyAlarmReq);
 
-    rc = dixLookupResourceByType((pointer *)&pAlarm, stuff->alarm, RTAlarm,
-				 client, DixDestroyAccess);
+    rc = dixLookupResourceByType((pointer *) &pAlarm, stuff->alarm, RTAlarm,
+                                 client, DixDestroyAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     FreeResource(stuff->alarm, RT_NONE);
     return Success;
@@ -1963,19 +1848,17 @@ ProcSyncCreateFence(ClientPtr client)
 
     rc = dixLookupDrawable(&pDraw, stuff->d, client, M_ANY, DixGetAttrAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     LEGAL_NEW_RESOURCE(stuff->fid, client);
 
-    if (!(pFence = (SyncFence *)SyncCreate(client,
-					   stuff->fid,
-					   SYNC_FENCE)))
-	return BadAlloc;
+    if (!(pFence = (SyncFence *) SyncCreate(client, stuff->fid, SYNC_FENCE)))
+        return BadAlloc;
 
     miSyncInitFence(pDraw->pScreen, pFence, stuff->initially_triggered);
 
     if (!AddResource(stuff->fid, RTFence, (pointer) pFence))
-	return BadAlloc;
+        return BadAlloc;
 
     return client->noClientException;
 }
@@ -1990,14 +1873,14 @@ FreeFence(void *obj, XID id)
     return Success;
 }
 
-int SyncVerifyFence(SyncFence **ppSyncFence, XID fid,
-		    ClientPtr client, Mask mode)
+int
+SyncVerifyFence(SyncFence ** ppSyncFence, XID fid, ClientPtr client, Mask mode)
 {
-    int rc = dixLookupResourceByType((pointer *)ppSyncFence, fid, RTFence,
-				     client, mode);
+    int rc = dixLookupResourceByType((pointer *) ppSyncFence, fid, RTFence,
+                                     client, mode);
 
     if (rc != Success)
-	client->errorValue = fid;
+        client->errorValue = fid;
 
     return rc;
 }
@@ -2011,10 +1894,10 @@ ProcSyncTriggerFence(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xSyncTriggerFenceReq);
 
-    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid, RTFence,
-				 client, DixWriteAccess);
+    rc = dixLookupResourceByType((pointer *) &pFence, stuff->fid, RTFence,
+                                 client, DixWriteAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     miSyncTriggerFence(pFence);
 
@@ -2030,13 +1913,13 @@ ProcSyncResetFence(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xSyncResetFenceReq);
 
-    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid, RTFence,
-				 client, DixWriteAccess);
+    rc = dixLookupResourceByType((pointer *) &pFence, stuff->fid, RTFence,
+                                 client, DixWriteAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     if (pFence->funcs.CheckTriggered(pFence) != TRUE)
-	return BadMatch;
+        return BadMatch;
 
     pFence->funcs.Reset(pFence);
 
@@ -2052,10 +1935,10 @@ ProcSyncDestroyFence(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xSyncDestroyFenceReq);
 
-    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid, RTFence,
-				 client, DixDestroyAccess);
+    rc = dixLookupResourceByType((pointer *) &pFence, stuff->fid, RTFence,
+                                 client, DixDestroyAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     FreeResource(stuff->fid, RT_NONE);
     return client->noClientException;
@@ -2071,10 +1954,10 @@ ProcSyncQueryFence(ClientPtr client)
 
     REQUEST_SIZE_MATCH(xSyncQueryFenceReq);
 
-    rc = dixLookupResourceByType((pointer *)&pFence, stuff->fid,
-				 RTFence, client, DixReadAccess);
+    rc = dixLookupResourceByType((pointer *) &pFence, stuff->fid,
+                                 RTFence, client, DixReadAccess);
     if (rc != Success)
-	return rc;
+        return rc;
 
     rep.type = X_Reply;
     rep.length = 0;
@@ -2082,10 +1965,9 @@ ProcSyncQueryFence(ClientPtr client)
 
     rep.triggered = pFence->funcs.CheckTriggered(pFence);
 
-    if (client->swapped)
-    {
-	swaps(&rep.sequenceNumber);
-	swapl(&rep.length);
+    if (client->swapped) {
+        swaps(&rep.sequenceNumber);
+        swapl(&rep.length);
     }
 
     WriteToClient(client, sizeof(xSyncQueryFenceReply), (char *) &rep);
@@ -2098,6 +1980,7 @@ ProcSyncAwaitFence(ClientPtr client)
     REQUEST(xSyncAwaitFenceReq);
     SyncAwaitUnion *pAwaitUnion;
     SyncAwait *pAwait;
+
     /* Use CARD32 rather than XSyncFence because XIDs are hard-coded to
      * CARD32 in protocol definitions */
     CARD32 *pProtocolFences;
@@ -2112,62 +1995,56 @@ ProcSyncAwaitFence(ClientPtr client)
     len -= sz_xSyncAwaitFenceReq;
     items = len / sizeof(CARD32);
 
-    if (items * sizeof(CARD32) != len)
-    {
-	return BadLength;
+    if (items * sizeof(CARD32) != len) {
+        return BadLength;
     }
-    if (items == 0)
-    {
-	client->errorValue = items;
-	return BadValue;
+    if (items == 0) {
+        client->errorValue = items;
+        return BadValue;
     }
 
     if (!(pAwaitUnion = SyncAwaitPrologue(client, items)))
-	return BadAlloc;
+        return BadAlloc;
 
     /* don't need to do any more memory allocation for this request! */
 
-    pProtocolFences = (CARD32 *) & stuff[1];
-
-    pAwait = &(pAwaitUnion+1)->await; /* skip over header */
-    for (i = 0; i < items; i++, pProtocolFences++, pAwait++)
-    {
-	if (*pProtocolFences == None)
-	{
-	    /*  this should take care of removing any triggers created by
-	     *  this request that have already been registered on sync objects
-	     */
-	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
-	    client->errorValue = *pProtocolFences;
-	    return SyncErrorBase + XSyncBadFence;
-	}
-
-	pAwait->trigger.pSync = NULL;
-	/* Provide acceptable values for these unused fields to
-	 * satisfy SyncInitTrigger's validation logic
-	 */
-	pAwait->trigger.value_type = XSyncAbsolute;
-	XSyncIntToValue(&pAwait->trigger.wait_value, 0);
-	pAwait->trigger.test_type = 0;
-
-	status = SyncInitTrigger(client, &pAwait->trigger,
-				 *pProtocolFences, RTFence,
-				 XSyncCAAllTrigger);
-	if (status != Success)
-	{
-	    /*  this should take care of removing any triggers created by
-	     *  this request that have already been registered on sync objects
-	     */
-	    FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
-	    return status;
-	}
-	/* this is not a mistake -- same function works for both cases */
-	pAwait->trigger.TriggerFired = SyncAwaitTriggerFired;
-	pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired;
-	/* event_threshold is unused for fence syncs */
-	XSyncIntToValue(&pAwait->event_threshold, 0);
-	pAwait->pHeader = &pAwaitUnion->header;
-	pAwaitUnion->header.num_waitconditions++;
+    pProtocolFences = (CARD32 *) &stuff[1];
+
+    pAwait = &(pAwaitUnion + 1)->await; /* skip over header */
+    for (i = 0; i < items; i++, pProtocolFences++, pAwait++) {
+        if (*pProtocolFences == None) {
+            /*  this should take care of removing any triggers created by
+             *  this request that have already been registered on sync objects
+             */
+            FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
+            client->errorValue = *pProtocolFences;
+            return SyncErrorBase + XSyncBadFence;
+        }
+
+        pAwait->trigger.pSync = NULL;
+        /* Provide acceptable values for these unused fields to
+         * satisfy SyncInitTrigger's validation logic
+         */
+        pAwait->trigger.value_type = XSyncAbsolute;
+        XSyncIntToValue(&pAwait->trigger.wait_value, 0);
+        pAwait->trigger.test_type = 0;
+
+        status = SyncInitTrigger(client, &pAwait->trigger,
+                                 *pProtocolFences, RTFence, XSyncCAAllTrigger);
+        if (status != Success) {
+            /*  this should take care of removing any triggers created by
+             *  this request that have already been registered on sync objects
+             */
+            FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
+            return status;
+        }
+        /* this is not a mistake -- same function works for both cases */
+        pAwait->trigger.TriggerFired = SyncAwaitTriggerFired;
+        pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired;
+        /* event_threshold is unused for fence syncs */
+        XSyncIntToValue(&pAwait->event_threshold, 0);
+        pAwait->pHeader = &pAwaitUnion->header;
+        pAwaitUnion->header.num_waitconditions++;
     }
 
     SyncAwaitEpilogue(client, items, pAwaitUnion);
@@ -2183,50 +2060,49 @@ ProcSyncDispatch(ClientPtr client)
 {
     REQUEST(xReq);
 
-    switch (stuff->data)
-    {
-      case X_SyncInitialize:
-	return ProcSyncInitialize(client);
-      case X_SyncListSystemCounters:
-	return ProcSyncListSystemCounters(client);
-      case X_SyncCreateCounter:
-	return ProcSyncCreateCounter(client);
-      case X_SyncSetCounter:
-	return ProcSyncSetCounter(client);
-      case X_SyncChangeCounter:
-	return ProcSyncChangeCounter(client);
-      case X_SyncQueryCounter:
-	return ProcSyncQueryCounter(client);
-      case X_SyncDestroyCounter:
-	return ProcSyncDestroyCounter(client);
-      case X_SyncAwait:
-	return ProcSyncAwait(client);
-      case X_SyncCreateAlarm:
-	return ProcSyncCreateAlarm(client);
-      case X_SyncChangeAlarm:
-	return ProcSyncChangeAlarm(client);
-      case X_SyncQueryAlarm:
-	return ProcSyncQueryAlarm(client);
-      case X_SyncDestroyAlarm:
-	return ProcSyncDestroyAlarm(client);
-      case X_SyncSetPriority:
-	return ProcSyncSetPriority(client);
-      case X_SyncGetPriority:
-	return ProcSyncGetPriority(client);
-      case X_SyncCreateFence:
-	return ProcSyncCreateFence(client);
-      case X_SyncTriggerFence:
-	return ProcSyncTriggerFence(client);
-      case X_SyncResetFence:
-	return ProcSyncResetFence(client);
-      case X_SyncDestroyFence:
-	return ProcSyncDestroyFence(client);
-      case X_SyncQueryFence:
-	return ProcSyncQueryFence(client);
-      case X_SyncAwaitFence:
-	return ProcSyncAwaitFence(client);
-      default:
-	return BadRequest;
+    switch (stuff->data) {
+    case X_SyncInitialize:
+        return ProcSyncInitialize(client);
+    case X_SyncListSystemCounters:
+        return ProcSyncListSystemCounters(client);
+    case X_SyncCreateCounter:
+        return ProcSyncCreateCounter(client);
+    case X_SyncSetCounter:
+        return ProcSyncSetCounter(client);
+    case X_SyncChangeCounter:
+        return ProcSyncChangeCounter(client);
+    case X_SyncQueryCounter:
+        return ProcSyncQueryCounter(client);
+    case X_SyncDestroyCounter:
+        return ProcSyncDestroyCounter(client);
+    case X_SyncAwait:
+        return ProcSyncAwait(client);
+    case X_SyncCreateAlarm:
+        return ProcSyncCreateAlarm(client);
+    case X_SyncChangeAlarm:
+        return ProcSyncChangeAlarm(client);
+    case X_SyncQueryAlarm:
+        return ProcSyncQueryAlarm(client);
+    case X_SyncDestroyAlarm:
+        return ProcSyncDestroyAlarm(client);
+    case X_SyncSetPriority:
+        return ProcSyncSetPriority(client);
+    case X_SyncGetPriority:
+        return ProcSyncGetPriority(client);
+    case X_SyncCreateFence:
+        return ProcSyncCreateFence(client);
+    case X_SyncTriggerFence:
+        return ProcSyncTriggerFence(client);
+    case X_SyncResetFence:
+        return ProcSyncResetFence(client);
+    case X_SyncDestroyFence:
+        return ProcSyncDestroyFence(client);
+    case X_SyncQueryFence:
+        return ProcSyncQueryFence(client);
+    case X_SyncAwaitFence:
+        return ProcSyncAwaitFence(client);
+    default:
+        return BadRequest;
     }
 }
 
@@ -2239,7 +2115,7 @@ SProcSyncInitialize(ClientPtr client)
 {
     REQUEST(xSyncInitializeReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncInitializeReq);
+    REQUEST_SIZE_MATCH(xSyncInitializeReq);
 
     return ProcSyncInitialize(client);
 }
@@ -2249,7 +2125,7 @@ SProcSyncListSystemCounters(ClientPtr client)
 {
     REQUEST(xSyncListSystemCountersReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncListSystemCountersReq);
+    REQUEST_SIZE_MATCH(xSyncListSystemCountersReq);
 
     return ProcSyncListSystemCounters(client);
 }
@@ -2259,7 +2135,7 @@ SProcSyncCreateCounter(ClientPtr client)
 {
     REQUEST(xSyncCreateCounterReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncCreateCounterReq);
+    REQUEST_SIZE_MATCH(xSyncCreateCounterReq);
     swapl(&stuff->cid);
     swapl(&stuff->initial_value_lo);
     swapl(&stuff->initial_value_hi);
@@ -2272,7 +2148,7 @@ SProcSyncSetCounter(ClientPtr client)
 {
     REQUEST(xSyncSetCounterReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncSetCounterReq);
+    REQUEST_SIZE_MATCH(xSyncSetCounterReq);
     swapl(&stuff->cid);
     swapl(&stuff->value_lo);
     swapl(&stuff->value_hi);
@@ -2285,7 +2161,7 @@ SProcSyncChangeCounter(ClientPtr client)
 {
     REQUEST(xSyncChangeCounterReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncChangeCounterReq);
+    REQUEST_SIZE_MATCH(xSyncChangeCounterReq);
     swapl(&stuff->cid);
     swapl(&stuff->value_lo);
     swapl(&stuff->value_hi);
@@ -2298,7 +2174,7 @@ SProcSyncQueryCounter(ClientPtr client)
 {
     REQUEST(xSyncQueryCounterReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncQueryCounterReq);
+    REQUEST_SIZE_MATCH(xSyncQueryCounterReq);
     swapl(&stuff->counter);
 
     return ProcSyncQueryCounter(client);
@@ -2309,7 +2185,7 @@ SProcSyncDestroyCounter(ClientPtr client)
 {
     REQUEST(xSyncDestroyCounterReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncDestroyCounterReq);
+    REQUEST_SIZE_MATCH(xSyncDestroyCounterReq);
     swapl(&stuff->counter);
 
     return ProcSyncDestroyCounter(client);
@@ -2356,7 +2232,7 @@ SProcSyncQueryAlarm(ClientPtr client)
 {
     REQUEST(xSyncQueryAlarmReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncQueryAlarmReq);
+    REQUEST_SIZE_MATCH(xSyncQueryAlarmReq);
     swapl(&stuff->alarm);
 
     return ProcSyncQueryAlarm(client);
@@ -2367,7 +2243,7 @@ SProcSyncDestroyAlarm(ClientPtr client)
 {
     REQUEST(xSyncDestroyAlarmReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncDestroyAlarmReq);
+    REQUEST_SIZE_MATCH(xSyncDestroyAlarmReq);
     swapl(&stuff->alarm);
 
     return ProcSyncDestroyAlarm(client);
@@ -2378,7 +2254,7 @@ SProcSyncSetPriority(ClientPtr client)
 {
     REQUEST(xSyncSetPriorityReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncSetPriorityReq);
+    REQUEST_SIZE_MATCH(xSyncSetPriorityReq);
     swapl(&stuff->id);
     swapl(&stuff->priority);
 
@@ -2390,7 +2266,7 @@ SProcSyncGetPriority(ClientPtr client)
 {
     REQUEST(xSyncGetPriorityReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncGetPriorityReq);
+    REQUEST_SIZE_MATCH(xSyncGetPriorityReq);
     swapl(&stuff->id);
 
     return ProcSyncGetPriority(client);
@@ -2401,7 +2277,7 @@ SProcSyncCreateFence(ClientPtr client)
 {
     REQUEST(xSyncCreateFenceReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncCreateFenceReq);
+    REQUEST_SIZE_MATCH(xSyncCreateFenceReq);
     swapl(&stuff->fid);
 
     return ProcSyncCreateFence(client);
@@ -2412,7 +2288,7 @@ SProcSyncTriggerFence(ClientPtr client)
 {
     REQUEST(xSyncTriggerFenceReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncTriggerFenceReq);
+    REQUEST_SIZE_MATCH(xSyncTriggerFenceReq);
     swapl(&stuff->fid);
 
     return ProcSyncTriggerFence(client);
@@ -2423,7 +2299,7 @@ SProcSyncResetFence(ClientPtr client)
 {
     REQUEST(xSyncResetFenceReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncResetFenceReq);
+    REQUEST_SIZE_MATCH(xSyncResetFenceReq);
     swapl(&stuff->fid);
 
     return ProcSyncResetFence(client);
@@ -2434,7 +2310,7 @@ SProcSyncDestroyFence(ClientPtr client)
 {
     REQUEST(xSyncDestroyFenceReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncDestroyFenceReq);
+    REQUEST_SIZE_MATCH(xSyncDestroyFenceReq);
     swapl(&stuff->fid);
 
     return ProcSyncDestroyFence(client);
@@ -2445,7 +2321,7 @@ SProcSyncQueryFence(ClientPtr client)
 {
     REQUEST(xSyncQueryFenceReq);
     swaps(&stuff->length);
-    REQUEST_SIZE_MATCH (xSyncQueryFenceReq);
+    REQUEST_SIZE_MATCH(xSyncQueryFenceReq);
     swapl(&stuff->fid);
 
     return ProcSyncQueryFence(client);
@@ -2467,50 +2343,49 @@ SProcSyncDispatch(ClientPtr client)
 {
     REQUEST(xReq);
 
-    switch (stuff->data)
-    {
-      case X_SyncInitialize:
-	return SProcSyncInitialize(client);
-      case X_SyncListSystemCounters:
-	return SProcSyncListSystemCounters(client);
-      case X_SyncCreateCounter:
-	return SProcSyncCreateCounter(client);
-      case X_SyncSetCounter:
-	return SProcSyncSetCounter(client);
-      case X_SyncChangeCounter:
-	return SProcSyncChangeCounter(client);
-      case X_SyncQueryCounter:
-	return SProcSyncQueryCounter(client);
-      case X_SyncDestroyCounter:
-	return SProcSyncDestroyCounter(client);
-      case X_SyncAwait:
-	return SProcSyncAwait(client);
-      case X_SyncCreateAlarm:
-	return SProcSyncCreateAlarm(client);
-      case X_SyncChangeAlarm:
-	return SProcSyncChangeAlarm(client);
-      case X_SyncQueryAlarm:
-	return SProcSyncQueryAlarm(client);
-      case X_SyncDestroyAlarm:
-	return SProcSyncDestroyAlarm(client);
-      case X_SyncSetPriority:
-	return SProcSyncSetPriority(client);
-      case X_SyncGetPriority:
-	return SProcSyncGetPriority(client);
-      case X_SyncCreateFence:
-	return SProcSyncCreateFence(client);
-      case X_SyncTriggerFence:
-	return SProcSyncTriggerFence(client);
-      case X_SyncResetFence:
-	return SProcSyncResetFence(client);
-      case X_SyncDestroyFence:
-	return SProcSyncDestroyFence(client);
-      case X_SyncQueryFence:
-	return SProcSyncQueryFence(client);
-      case X_SyncAwaitFence:
-	return SProcSyncAwaitFence(client);
-      default:
-	return BadRequest;
+    switch (stuff->data) {
+    case X_SyncInitialize:
+        return SProcSyncInitialize(client);
+    case X_SyncListSystemCounters:
+        return SProcSyncListSystemCounters(client);
+    case X_SyncCreateCounter:
+        return SProcSyncCreateCounter(client);
+    case X_SyncSetCounter:
+        return SProcSyncSetCounter(client);
+    case X_SyncChangeCounter:
+        return SProcSyncChangeCounter(client);
+    case X_SyncQueryCounter:
+        return SProcSyncQueryCounter(client);
+    case X_SyncDestroyCounter:
+        return SProcSyncDestroyCounter(client);
+    case X_SyncAwait:
+        return SProcSyncAwait(client);
+    case X_SyncCreateAlarm:
+        return SProcSyncCreateAlarm(client);
+    case X_SyncChangeAlarm:
+        return SProcSyncChangeAlarm(client);
+    case X_SyncQueryAlarm:
+        return SProcSyncQueryAlarm(client);
+    case X_SyncDestroyAlarm:
+        return SProcSyncDestroyAlarm(client);
+    case X_SyncSetPriority:
+        return SProcSyncSetPriority(client);
+    case X_SyncGetPriority:
+        return SProcSyncGetPriority(client);
+    case X_SyncCreateFence:
+        return SProcSyncCreateFence(client);
+    case X_SyncTriggerFence:
+        return SProcSyncTriggerFence(client);
+    case X_SyncResetFence:
+        return SProcSyncResetFence(client);
+    case X_SyncDestroyFence:
+        return SProcSyncDestroyFence(client);
+    case X_SyncQueryFence:
+        return SProcSyncQueryFence(client);
+    case X_SyncAwaitFence:
+        return SProcSyncAwaitFence(client);
+    default:
+        return BadRequest;
     }
 }
 
@@ -2519,7 +2394,8 @@ SProcSyncDispatch(ClientPtr client)
  */
 
 static void
-SCounterNotifyEvent(xSyncCounterNotifyEvent *from, xSyncCounterNotifyEvent *to)
+SCounterNotifyEvent(xSyncCounterNotifyEvent * from,
+                    xSyncCounterNotifyEvent * to)
 {
     to->type = from->type;
     to->kind = from->kind;
@@ -2534,9 +2410,8 @@ SCounterNotifyEvent(xSyncCounterNotifyEvent *from, xSyncCounterNotifyEvent *to)
     to->destroyed = from->destroyed;
 }
 
-
 static void
-SAlarmNotifyEvent(xSyncAlarmNotifyEvent *from, xSyncAlarmNotifyEvent *to)
+SAlarmNotifyEvent(xSyncAlarmNotifyEvent * from, xSyncAlarmNotifyEvent * to)
 {
     to->type = from->type;
     to->kind = from->kind;
@@ -2555,10 +2430,8 @@ SAlarmNotifyEvent(xSyncAlarmNotifyEvent *from, xSyncAlarmNotifyEvent *to)
  */
 /* ARGSUSED */
 static void
-SyncResetProc(ExtensionEntry *extEntry)
+SyncResetProc(ExtensionEntry * extEntry)
 {
-    free(SysCounterList);
-    SysCounterList = NULL;
     RTCounter = 0;
 }
 
@@ -2569,41 +2442,42 @@ void
 SyncExtensionInit(void)
 {
     ExtensionEntry *extEntry;
-    int 	    s;
+    int s;
+
+    xorg_list_init(&SysCounterList);
 
     for (s = 0; s < screenInfo.numScreens; s++)
-	miSyncSetup(screenInfo.screens[s]);
+        miSyncSetup(screenInfo.screens[s]);
 
-    if (RTCounter == 0)
-    {
-	RTCounter = CreateNewResourceType(FreeCounter, "SyncCounter");
+    if (RTCounter == 0) {
+        RTCounter = CreateNewResourceType(FreeCounter, "SyncCounter");
     }
     RTAlarm = CreateNewResourceType(FreeAlarm, "SyncAlarm");
     RTAwait = CreateNewResourceType(FreeAwait, "SyncAwait");
     RTFence = CreateNewResourceType(FreeFence, "SyncFence");
     if (RTAwait)
-	RTAwait |= RC_NEVERRETAIN;
+        RTAwait |= RC_NEVERRETAIN;
     RTAlarmClient = CreateNewResourceType(FreeAlarmClient, "SyncAlarmClient");
     if (RTAlarmClient)
-	RTAlarmClient |= RC_NEVERRETAIN;
+        RTAlarmClient |= RC_NEVERRETAIN;
 
     if (RTCounter == 0 || RTAwait == 0 || RTAlarm == 0 ||
-	RTAlarmClient == 0 ||
-	(extEntry = AddExtension(SYNC_NAME,
-				 XSyncNumberEvents, XSyncNumberErrors,
-				 ProcSyncDispatch, SProcSyncDispatch,
-				 SyncResetProc,
-				 StandardMinorOpcode)) == NULL)
-    {
-	ErrorF("Sync Extension %d.%d failed to Initialise\n",
-		SYNC_MAJOR_VERSION, SYNC_MINOR_VERSION);
-	return;
+        RTAlarmClient == 0 ||
+        (extEntry = AddExtension(SYNC_NAME,
+                                 XSyncNumberEvents, XSyncNumberErrors,
+                                 ProcSyncDispatch, SProcSyncDispatch,
+                                 SyncResetProc, StandardMinorOpcode)) == NULL) {
+        ErrorF("Sync Extension %d.%d failed to Initialise\n",
+               SYNC_MAJOR_VERSION, SYNC_MINOR_VERSION);
+        return;
     }
 
     SyncEventBase = extEntry->eventBase;
     SyncErrorBase = extEntry->errorBase;
-    EventSwapVector[SyncEventBase + XSyncCounterNotify] = (EventSwapPtr) SCounterNotifyEvent;
-    EventSwapVector[SyncEventBase + XSyncAlarmNotify] = (EventSwapPtr) SAlarmNotifyEvent;
+    EventSwapVector[SyncEventBase + XSyncCounterNotify] =
+        (EventSwapPtr) SCounterNotifyEvent;
+    EventSwapVector[SyncEventBase + XSyncAlarmNotify] =
+        (EventSwapPtr) SAlarmNotifyEvent;
 
     SetResourceTypeErrorValue(RTCounter, SyncErrorBase + XSyncBadCounter);
     SetResourceTypeErrorValue(RTAlarm, SyncErrorBase + XSyncBadAlarm);
@@ -2620,17 +2494,14 @@ SyncExtensionInit(void)
 
 #ifdef DEBUG
     fprintf(stderr, "Sync Extension %d.%d\n",
-	    SYNC_MAJOR_VERSION, SYNC_MINOR_VERSION);
+            SYNC_MAJOR_VERSION, SYNC_MINOR_VERSION);
 #endif
 }
 
-
 /*
  * ***** SERVERTIME implementation - should go in its own file in OS directory?
  */
 
-
-
 static pointer ServertimeCounter;
 static XSyncValue Now;
 static XSyncValue *pnext_time;
@@ -2647,72 +2518,62 @@ static XSyncValue *pnext_time;
 *** Server Block Handler
 *** code inspired by multibuffer extension (now deprecated)
  */
-/*ARGSUSED*/
-static void
+ /*ARGSUSED*/ static void
 ServertimeBlockHandler(void *env, struct timeval **wt, void *LastSelectMask)
 {
     XSyncValue delay;
     unsigned long timeout;
 
-    if (pnext_time)
-    {
+    if (pnext_time) {
         GetTime();
 
-        if (XSyncValueGreaterOrEqual(Now, *pnext_time))
-	{
+        if (XSyncValueGreaterOrEqual(Now, *pnext_time)) {
             timeout = 0;
         }
-	else
-	{
-	    Bool overflow;
+        else {
+            Bool overflow;
+
             XSyncValueSubtract(&delay, *pnext_time, Now, &overflow);
-	    (void)overflow;
+            (void) overflow;
             timeout = XSyncValueLow32(delay);
         }
-        AdjustWaitForDelay(wt, timeout); /* os/utils.c */
+        AdjustWaitForDelay(wt, timeout);        /* os/utils.c */
     }
 }
 
 /*
 *** Wakeup Handler
  */
-/*ARGSUSED*/
-static void
+ /*ARGSUSED*/ static void
 ServertimeWakeupHandler(void *env, int rc, void *LastSelectMask)
 {
-    if (pnext_time)
-    {
+    if (pnext_time) {
         GetTime();
 
-        if (XSyncValueGreaterOrEqual(Now, *pnext_time))
-	{
+        if (XSyncValueGreaterOrEqual(Now, *pnext_time)) {
             SyncChangeCounter(ServertimeCounter, Now);
         }
     }
 }
 
 static void
-ServertimeQueryValue(void *pCounter, CARD64 *pValue_return)
+ServertimeQueryValue(void *pCounter, CARD64 * pValue_return)
 {
     GetTime();
     *pValue_return = Now;
 }
 
 static void
-ServertimeBracketValues(void *pCounter, CARD64 *pbracket_less,
-			CARD64 *pbracket_greater)
+ServertimeBracketValues(void *pCounter, CARD64 * pbracket_less,
+                        CARD64 * pbracket_greater)
 {
-    if (!pnext_time && pbracket_greater)
-    {
-	RegisterBlockAndWakeupHandlers(ServertimeBlockHandler,
-				       ServertimeWakeupHandler,
-				       NULL);
+    if (!pnext_time && pbracket_greater) {
+        RegisterBlockAndWakeupHandlers(ServertimeBlockHandler,
+                                       ServertimeWakeupHandler, NULL);
     }
-    else if (pnext_time && !pbracket_greater)
-    {
-	RemoveBlockAndWakeupHandlers(ServertimeBlockHandler,
-				     ServertimeWakeupHandler,
-				     NULL);
+    else if (pnext_time && !pbracket_greater) {
+        RemoveBlockAndWakeupHandlers(ServertimeBlockHandler,
+                                     ServertimeWakeupHandler, NULL);
     }
     pnext_time = pbracket_greater;
 }
@@ -2725,157 +2586,202 @@ SyncInitServerTime(void)
     XSyncIntsToValue(&Now, GetTimeInMillis(), 0);
     XSyncIntToValue(&resolution, 4);
     ServertimeCounter = SyncCreateSystemCounter("SERVERTIME", Now, resolution,
-			    XSyncCounterNeverDecreases,
-			    ServertimeQueryValue, ServertimeBracketValues);
+                                                XSyncCounterNeverDecreases,
+                                                ServertimeQueryValue,
+                                                ServertimeBracketValues);
     pnext_time = NULL;
 }
 
-
-
 /*
  * IDLETIME implementation
  */
 
-static SyncCounter *IdleTimeCounter;
-static XSyncValue *pIdleTimeValueLess;
-static XSyncValue *pIdleTimeValueGreater;
+typedef struct {
+    XSyncValue *value_less;
+    XSyncValue *value_greater;
+    int deviceid;
+} IdleCounterPriv;
 
 static void
-IdleTimeQueryValue (pointer pCounter, CARD64 *pValue_return)
+IdleTimeQueryValue(pointer pCounter, CARD64 * pValue_return)
 {
-    CARD32 idle = GetTimeInMillis() - lastDeviceEventTime.milliseconds;
-    XSyncIntsToValue (pValue_return, idle, 0);
+    int deviceid;
+    CARD32 idle;
+
+    if (pCounter) {
+        SyncCounter *counter = pCounter;
+        IdleCounterPriv *priv = SysCounterGetPrivate(counter);
+        deviceid = priv->deviceid;
+    }
+    else
+        deviceid = XIAllDevices;
+    idle = GetTimeInMillis() - lastDeviceEventTime[deviceid].milliseconds;
+    XSyncIntsToValue(pValue_return, idle, 0);
 }
 
 static void
-IdleTimeBlockHandler(pointer env, struct timeval **wt, pointer LastSelectMask)
+IdleTimeBlockHandler(pointer pCounter, struct timeval **wt, pointer LastSelectMask)
 {
+    SyncCounter *counter = pCounter;
+    IdleCounterPriv *priv = SysCounterGetPrivate(counter);
+    XSyncValue *less = priv->value_less,
+               *greater = priv->value_greater;
     XSyncValue idle, old_idle;
-    SyncTriggerList *list = IdleTimeCounter->sync.pTriglist;
+    SyncTriggerList *list = counter->sync.pTriglist;
     SyncTrigger *trig;
 
-    if (!pIdleTimeValueLess && !pIdleTimeValueGreater)
-	return;
-
-    old_idle = IdleTimeCounter->value;
-    IdleTimeQueryValue (NULL, &idle);
-    IdleTimeCounter->value = idle; /* push, so CheckTrigger works */
-
-    if (pIdleTimeValueLess &&
-        XSyncValueLessOrEqual (idle, *pIdleTimeValueLess))
-    {
-	/*
-	 * We've been idle for less than the threshold value, and someone
-	 * wants to know about that, but now we need to know whether they
-	 * want level or edge trigger.  Check the trigger list against the
-	 * current idle time, and if any succeed, bomb out of select()
-	 * immediately so we can reschedule.
-	 */
-
-	for (list = IdleTimeCounter->sync.pTriglist; list; list = list->next) {
-	    trig = list->pTrigger;
-	    if (trig->CheckTrigger(trig, old_idle)) {
-		AdjustWaitForDelay(wt, 0);
-		break;
-	    }
-	}
-	/* 
-	 * We've been called exactly on the idle time, but we have a
-	 * NegativeTransition trigger which requires a transition from an
-	 * idle time greater than this.  Schedule a wakeup for the next
-	 * millisecond so we won't miss a transition.
-	 */
-	if (XSyncValueEqual (idle, *pIdleTimeValueLess))
-	    AdjustWaitForDelay(wt, 1);
-    }
-    else if (pIdleTimeValueGreater)
-    {
-	/*
-	 * There's a threshold in the positive direction.  If we've been
-	 * idle less than it, schedule a wakeup for sometime in the future.
-	 * If we've been idle more than it, and someone wants to know about
-	 * that level-triggered, schedule an immediate wakeup.
-	 */
-	unsigned long timeout = -1;
-
-	if (XSyncValueLessThan (idle, *pIdleTimeValueGreater)) {
-	    XSyncValue value;
-	    Bool overflow;
-
-	    XSyncValueSubtract (&value, *pIdleTimeValueGreater,
-	                        idle, &overflow);
-	    timeout = min(timeout, XSyncValueLow32 (value));
-	} else {
-	    for (list = IdleTimeCounter->sync.pTriglist; list; list = list->next) {
-		trig = list->pTrigger;
-		if (trig->CheckTrigger(trig, old_idle)) {
-		    timeout = min(timeout, 0);
-		    break;
-		}
-	    }
-	}
-
-	AdjustWaitForDelay (wt, timeout);
-    }
-
-    IdleTimeCounter->value = old_idle; /* pop */
+    if (!less && !greater)
+        return;
+
+    old_idle = counter->value;
+    IdleTimeQueryValue(NULL, &idle);
+    counter->value = idle;      /* push, so CheckTrigger works */
+
+    if (less && XSyncValueLessOrEqual(idle, *less)) {
+        /*
+         * We've been idle for less than the threshold value, and someone
+         * wants to know about that, but now we need to know whether they
+         * want level or edge trigger.  Check the trigger list against the
+         * current idle time, and if any succeed, bomb out of select()
+         * immediately so we can reschedule.
+         */
+
+        for (list = counter->sync.pTriglist; list; list = list->next) {
+            trig = list->pTrigger;
+            if (trig->CheckTrigger(trig, old_idle)) {
+                AdjustWaitForDelay(wt, 0);
+                break;
+            }
+        }
+        /* 
+         * We've been called exactly on the idle time, but we have a
+         * NegativeTransition trigger which requires a transition from an
+         * idle time greater than this.  Schedule a wakeup for the next
+         * millisecond so we won't miss a transition.
+         */
+        if (XSyncValueEqual(idle, *less))
+            AdjustWaitForDelay(wt, 1);
+    }
+    else if (greater) {
+        /*
+         * There's a threshold in the positive direction.  If we've been
+         * idle less than it, schedule a wakeup for sometime in the future.
+         * If we've been idle more than it, and someone wants to know about
+         * that level-triggered, schedule an immediate wakeup.
+         */
+        unsigned long timeout = -1;
+
+        if (XSyncValueLessThan(idle, *greater)) {
+            XSyncValue value;
+            Bool overflow;
+
+            XSyncValueSubtract(&value, *greater, idle, &overflow);
+            timeout = min(timeout, XSyncValueLow32(value));
+        }
+        else {
+            for (list = counter->sync.pTriglist; list;
+                 list = list->next) {
+                trig = list->pTrigger;
+                if (trig->CheckTrigger(trig, old_idle)) {
+                    timeout = min(timeout, 0);
+                    break;
+                }
+            }
+        }
+
+        AdjustWaitForDelay(wt, timeout);
+    }
+
+    counter->value = old_idle;  /* pop */
 }
 
 static void
-IdleTimeWakeupHandler (pointer env, int rc, pointer LastSelectMask)
+IdleTimeWakeupHandler(pointer pCounter, int rc, pointer LastSelectMask)
 {
+    SyncCounter *counter = pCounter;
+    IdleCounterPriv *priv = SysCounterGetPrivate(counter);
+    XSyncValue *less = priv->value_less,
+               *greater = priv->value_greater;
     XSyncValue idle;
 
-    if (!pIdleTimeValueLess && !pIdleTimeValueGreater)
-	return;
+    if (!less && !greater)
+        return;
 
-    IdleTimeQueryValue (NULL, &idle);
+    IdleTimeQueryValue(pCounter, &idle);
 
-    if ((pIdleTimeValueGreater &&
-         XSyncValueGreaterOrEqual (idle, *pIdleTimeValueGreater)) ||
-        (pIdleTimeValueLess &&
-	 XSyncValueLessOrEqual (idle, *pIdleTimeValueLess)))
-    {
-	SyncChangeCounter (IdleTimeCounter, idle);
+    if ((greater && XSyncValueGreaterOrEqual(idle, *greater)) ||
+        (less && XSyncValueLessOrEqual(idle, *less))) {
+        SyncChangeCounter(counter, idle);
     }
 }
 
 static void
-IdleTimeBracketValues (pointer pCounter, CARD64 *pbracket_less,
-                       CARD64 *pbracket_greater)
+IdleTimeBracketValues(pointer pCounter, CARD64 * pbracket_less,
+                      CARD64 * pbracket_greater)
 {
-    Bool registered = (pIdleTimeValueLess || pIdleTimeValueGreater);
+    SyncCounter *counter = pCounter;
+    IdleCounterPriv *priv = SysCounterGetPrivate(counter);
+    XSyncValue *less = priv->value_less,
+               *greater = priv->value_greater;
+    Bool registered = (less || greater);
 
-    if (registered && !pbracket_less && !pbracket_greater)
-    {
-	RemoveBlockAndWakeupHandlers(IdleTimeBlockHandler,
-	                             IdleTimeWakeupHandler,
-	                             NULL);
+    if (registered && !pbracket_less && !pbracket_greater) {
+        RemoveBlockAndWakeupHandlers(IdleTimeBlockHandler,
+                                     IdleTimeWakeupHandler, pCounter);
     }
-    else if (!registered && (pbracket_less || pbracket_greater))
-    {
-	RegisterBlockAndWakeupHandlers(IdleTimeBlockHandler,
-	                               IdleTimeWakeupHandler,
-	                               NULL);
+    else if (!registered && (pbracket_less || pbracket_greater)) {
+        RegisterBlockAndWakeupHandlers(IdleTimeBlockHandler,
+                                       IdleTimeWakeupHandler, pCounter);
     }
 
-    pIdleTimeValueGreater = pbracket_greater;
-    pIdleTimeValueLess    = pbracket_less;
+    priv->value_greater = pbracket_greater;
+    priv->value_less = pbracket_less;
 }
 
-static void
-SyncInitIdleTime (void)
+static SyncCounter*
+init_system_idle_counter(const char *name, int deviceid)
 {
     CARD64 resolution;
     XSyncValue idle;
+    IdleCounterPriv *priv = malloc(sizeof(IdleCounterPriv));
+    SyncCounter *idle_time_counter;
+
+    IdleTimeQueryValue(NULL, &idle);
+    XSyncIntToValue(&resolution, 4);
+
+    idle_time_counter = SyncCreateSystemCounter(name, idle, resolution,
+                                                XSyncCounterUnrestricted,
+                                                IdleTimeQueryValue,
+                                                IdleTimeBracketValues);
+
+    priv->deviceid = deviceid;
+    priv->value_less = priv->value_greater = NULL;
 
-    IdleTimeQueryValue (NULL, &idle);
-    XSyncIntToValue (&resolution, 4);
+    idle_time_counter->pSysCounterInfo->private = priv;
 
-    IdleTimeCounter = SyncCreateSystemCounter ("IDLETIME", idle, resolution,
-                                               XSyncCounterUnrestricted,
-                                               IdleTimeQueryValue,
-                                               IdleTimeBracketValues);
+    return idle_time_counter;
+}
+
+static void
+SyncInitIdleTime(void)
+{
+    init_system_idle_counter("IDLETIME", XIAllDevices);
+}
 
-    pIdleTimeValueLess = pIdleTimeValueGreater = NULL;
+SyncCounter*
+SyncInitDeviceIdleTime(DeviceIntPtr dev)
+{
+    char timer_name[64];
+    sprintf(timer_name, "DEVICEIDLETIME %d", dev->id);
+
+    return init_system_idle_counter(timer_name, dev->id);
+}
+
+void SyncRemoveDeviceIdleTime(SyncCounter *counter)
+{
+    /* FreeAllResources() frees all system counters before the devices are
+       shut down, check if there are any left before freeing the device's
+       counter */
+    if (!xorg_list_is_empty(&SysCounterList))
+        xorg_list_del(&counter->pSysCounterInfo->entry);
 }