File xorg-x11-server-bnc472046-xsync-original-upstre... of Package xorg-x11-server

Overview Repositories Revisions Requests Users Attributes Meta

File xorg-x11-server-bnc472046-xsync-original-upstream-patch.diff of Package xorg-x11-server

From 4f160e68020b395faba014addbd08348acb08c2d Mon Sep 17 00:00:00 2001
From: Federico Mena Quintero <federico@novell.com>
Date: Thu, 9 Apr 2009 15:29:03 -0500
Subject: [PATCH 1/7] Cherry-pick 1208a1dbcaecbc218a77bf51068f9c0c768e16c5

---
 Xext/sync.c |   81 +++++++++++++++++++++++++++++------------------------------
 1 files changed, 40 insertions(+), 41 deletions(-)

diff --git a/Xext/sync.c b/Xext/sync.c
index 10d4481..297820c 100644
--- a/Xext/sync.c
+++ b/Xext/sync.c
@@ -353,7 +353,7 @@ SyncAddTriggerToCounter(pTrigger)
 	    return Success;
     }
 
-    if (!(pCur = (SyncTriggerList *)xalloc(sizeof(SyncTriggerList))))
+    if (!(pCur = xalloc(sizeof(SyncTriggerList))))
 	return BadAlloc;
 
     pCur->pTrigger = pTrigger;
@@ -600,8 +600,7 @@ SyncSendCounterNotifyEvents(client, ppAwait, num_events)
 
     if (client->clientGone)
 	return;
-    pev = pEvents = (xSyncCounterNotifyEvent *)
-		 xalloc(num_events * sizeof(xSyncCounterNotifyEvent));
+    pev = pEvents = xalloc(num_events * sizeof(xSyncCounterNotifyEvent));
     if (!pEvents) 
 	return;
     UpdateCurrentTime();
@@ -732,7 +731,7 @@ SyncAwaitTriggerFired(pTrigger)
 
     pAwaitUnion = (SyncAwaitUnion *)pAwait->pHeader;
     numwaits = pAwaitUnion->header.num_waitconditions;
-    ppAwait = (SyncAwait **)xalloc(numwaits * sizeof(SyncAwait *));
+    ppAwait = xalloc(numwaits * sizeof(SyncAwait *));
     if (!ppAwait)
 	goto bail;
 
@@ -887,7 +886,7 @@ SyncEventSelectForAlarm(pAlarm, client, wantevents)
 
     /* add new client to pAlarm->pEventClients */
 
-    pClients = (SyncAlarmClientList *) xalloc(sizeof(SyncAlarmClientList));
+    pClients = xalloc(sizeof(SyncAlarmClientList));
     if (!pClients)
 	return BadAlloc;
 
@@ -1022,13 +1021,13 @@ SyncCreateCounter(client, id, initialvalue)
 {
     SyncCounter *pCounter;
 
-    if (!(pCounter = (SyncCounter *) xalloc(sizeof(SyncCounter))))
-	return (SyncCounter *)NULL;
+    if (!(pCounter = xalloc(sizeof(SyncCounter))))
+	return NULL;
 
     if (!AddResource(id, RTCounter, (pointer) pCounter))
     {
-	xfree((pointer) pCounter);
-	return (SyncCounter *)NULL;
+	xfree(pCounter);
+	return NULL;
     }
 
     pCounter->client = client;
@@ -1066,10 +1065,10 @@ SyncCreateSystemCounter(name, initial, resolution, counterType,
 {
     SyncCounter    *pCounter;
 
-    SysCounterList = (SyncCounter **)xrealloc(SysCounterList,
+    SysCounterList = xrealloc(SysCounterList,
 			    (SyncNumSystemCounters+1)*sizeof(SyncCounter *));
     if (!SysCounterList)
-	return (pointer)NULL;
+	return NULL;
 
     /* this function may be called before SYNC has been initialized, so we
      * have to make sure RTCounter is created.
@@ -1079,7 +1078,7 @@ SyncCreateSystemCounter(name, initial, resolution, counterType,
 	RTCounter = CreateNewResourceType(FreeCounter);
 	if (RTCounter == 0)
 	{
-	    return (pointer)NULL;
+	    return NULL;
 	}
     }
 
@@ -1089,11 +1088,11 @@ SyncCreateSystemCounter(name, initial, resolution, counterType,
     {
 	SysCounterInfo *psci;
 
-	psci = (SysCounterInfo *)xalloc(sizeof(SysCounterInfo));
+	psci = xalloc(sizeof(SysCounterInfo));
 	if (!psci)
 	{
 	    FreeResource(pCounter->id, RT_NONE);
-	    return (pointer) pCounter;
+	    return pCounter;
 	}
 	pCounter->pSysCounterInfo = psci;
 	psci->name = name;
@@ -1105,7 +1104,7 @@ SyncCreateSystemCounter(name, initial, resolution, counterType,
 	XSyncMinValue(&psci->bracket_less);
 	SysCounterList[SyncNumSystemCounters++] = pCounter;
     }
-    return (pointer) pCounter;
+    return pCounter;
 }
 
 void
@@ -1331,7 +1330,7 @@ FreeAlarmClient(value, id)
 	    else
 		pAlarm->pEventClients = pCur->next;
 	    xfree(pCur);
-	    return(Success);
+	    return Success;
 	}
     }
     FatalError("alarm client not on event list");
@@ -1367,7 +1366,7 @@ ProcSyncInitialize(client)
 	swaps(&rep.sequenceNumber, n);
     }
     WriteToClient(client, sizeof(rep), (char *) &rep);
-    return (client->noClientException);
+    return client->noClientException;
 }
 
 /*
@@ -1396,7 +1395,7 @@ ProcSyncListSystemCounters(client)
 
     if (len)
     {
-	walklist = list = (xSyncSystemCounter *) xalloc(len);
+	walklist = list = xalloc(len);
 	if (!list)
 	    return BadAlloc;
     }
@@ -1445,7 +1444,7 @@ ProcSyncListSystemCounters(client)
 	xfree(list);
     }
 
-    return (client->noClientException);
+    return client->noClientException;
 }
 
 /*
@@ -1521,7 +1520,7 @@ ProcSyncGetPriority(client)
 
     WriteToClient(client, sizeof(xSyncGetPriorityReply), (char *) &rep);
 
-    return (client->noClientException);
+    return client->noClientException;
 }
 
 /*
@@ -1542,7 +1541,7 @@ ProcSyncCreateCounter(client)
     if (!SyncCreateCounter(client, stuff->cid, initial))
 	return BadAlloc;
 
-    return (client->noClientException);
+    return client->noClientException;
 }
 
 /*
@@ -1558,8 +1557,8 @@ ProcSyncSetCounter(client)
 
     REQUEST_SIZE_MATCH(xSyncSetCounterReq);
 
-    pCounter = (SyncCounter *)SecurityLookupIDByType(client, stuff->cid,
-					   RTCounter, DixWriteAccess);
+    pCounter = SecurityLookupIDByType(client, stuff->cid, RTCounter,
+				      DixWriteAccess);
     if (pCounter == NULL)
     {
 	client->errorValue = stuff->cid;
@@ -1591,8 +1590,8 @@ ProcSyncChangeCounter(client)
 
     REQUEST_SIZE_MATCH(xSyncChangeCounterReq);
 
-    pCounter = (SyncCounter *) SecurityLookupIDByType(client, stuff->cid,
-					    RTCounter, DixWriteAccess);
+    pCounter = SecurityLookupIDByType(client, stuff->cid, RTCounter,
+				      DixWriteAccess);
     if (pCounter == NULL)
     {
 	client->errorValue = stuff->cid;
@@ -1629,8 +1628,8 @@ ProcSyncDestroyCounter(client)
 
     REQUEST_SIZE_MATCH(xSyncDestroyCounterReq);
 
-    pCounter = (SyncCounter *)SecurityLookupIDByType(client, stuff->counter,
-					   RTCounter, DixDestroyAccess);
+    pCounter = SecurityLookupIDByType(client, stuff->counter, RTCounter,
+				      DixDestroyAccess);
     if (pCounter == NULL)
     {
 	client->errorValue = stuff->counter;
@@ -1682,7 +1681,7 @@ ProcSyncAwait(client)
     /*  all the memory for the entire await list is allocated 
      *  here in one chunk
      */
-    pAwaitUnion = (SyncAwaitUnion *)xalloc((items+1) * sizeof(SyncAwaitUnion));
+    pAwaitUnion = xalloc((items+1) * sizeof(SyncAwaitUnion));
     if (!pAwaitUnion)
 	return BadAlloc;
 
@@ -1775,8 +1774,8 @@ ProcSyncQueryCounter(client)
 
     REQUEST_SIZE_MATCH(xSyncQueryCounterReq);
 
-    pCounter = (SyncCounter *)SecurityLookupIDByType(client, stuff->counter,
-					    RTCounter, DixReadAccess);
+    pCounter = SecurityLookupIDByType(client, stuff->counter, RTCounter,
+				      DixReadAccess);
     if (pCounter == NULL)
     {
 	client->errorValue = stuff->counter;
@@ -1806,7 +1805,7 @@ ProcSyncQueryCounter(client)
 	swapl(&rep.value_lo, n);
     }
     WriteToClient(client, sizeof(xSyncQueryCounterReply), (char *) &rep);
-    return (client->noClientException);
+    return client->noClientException;
 }
 
 
@@ -1833,7 +1832,7 @@ ProcSyncCreateAlarm(client)
     if (len != (Ones(vmask) + Ones(vmask & (XSyncCAValue|XSyncCADelta))))
 	return BadLength;
 
-    if (!(pAlarm = (SyncAlarm *) xalloc(sizeof(SyncAlarm))))
+    if (!(pAlarm = xalloc(sizeof(SyncAlarm))))
     {
 	return BadAlloc;
     }
@@ -1904,8 +1903,8 @@ ProcSyncChangeAlarm(client)
 
     REQUEST_AT_LEAST_SIZE(xSyncChangeAlarmReq);
 
-    if (!(pAlarm = (SyncAlarm *)SecurityLookupIDByType(client, stuff->alarm,
-					      RTAlarm, DixWriteAccess)))
+    if (!(pAlarm = SecurityLookupIDByType(client, stuff->alarm, RTAlarm,
+					  DixWriteAccess)))
     {
 	client->errorValue = stuff->alarm;
 	return SyncErrorBase + XSyncBadAlarm;
@@ -1945,12 +1944,12 @@ ProcSyncQueryAlarm(client)
 
     REQUEST_SIZE_MATCH(xSyncQueryAlarmReq);
 
-    pAlarm = (SyncAlarm *)SecurityLookupIDByType(client, stuff->alarm,
-						RTAlarm, DixReadAccess);
+    pAlarm = SecurityLookupIDByType(client, stuff->alarm, RTAlarm,
+				    DixReadAccess);
     if (!pAlarm)
     {
 	client->errorValue = stuff->alarm;
-	return (SyncErrorBase + XSyncBadAlarm);
+	return SyncErrorBase + XSyncBadAlarm;
     }
 
     rep.type = X_Reply;
@@ -1993,7 +1992,7 @@ ProcSyncQueryAlarm(client)
     }
 
     WriteToClient(client, sizeof(xSyncQueryAlarmReply), (char *) &rep);
-    return (client->noClientException);
+    return client->noClientException;
 }
 
 
@@ -2005,15 +2004,15 @@ ProcSyncDestroyAlarm(client)
 
     REQUEST_SIZE_MATCH(xSyncDestroyAlarmReq);
 
-    if (!((SyncAlarm *)SecurityLookupIDByType(client, stuff->alarm,
-					      RTAlarm, DixDestroyAccess)))
+    if (!(SecurityLookupIDByType(client, stuff->alarm, RTAlarm,
+				 DixDestroyAccess)))
     {
 	client->errorValue = stuff->alarm;
 	return SyncErrorBase + XSyncBadAlarm;
     }
 
     FreeResource(stuff->alarm, RT_NONE);
-    return (client->noClientException);
+    return client->noClientException;
 }
 
 /*
-- 
1.6.0.2

From 2cfd96f9f3caf13017c9d686359a59d6fa88d8e9 Mon Sep 17 00:00:00 2001
From: Federico Mena Quintero <federico@novell.com>
Date: Thu, 9 Apr 2009 15:30:57 -0500
Subject: [PATCH 2/7] Cherry-pick e0d8f6a8084a3fe6c549c1dee11e4502e316c382 and adjust Xext/Makefile.am

---
 Xext/Makefile.am |    1 +
 Xext/sync.c      |    2 +-
 Xext/syncsrv.h   |  176 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 178 insertions(+), 1 deletions(-)
 create mode 100644 Xext/syncsrv.h

diff --git a/Xext/Makefile.am b/Xext/Makefile.am
index 648736d..8aa8ddb 100644
--- a/Xext/Makefile.am
+++ b/Xext/Makefile.am
@@ -31,6 +31,7 @@ MODULE_SRCS =			\
 	mitmisc.c		\
 	shape.c			\
 	sync.c			\
+	syncsrv.h		\
 	xcmisc.c
 
 # Optional sources included if extension enabled by configure.ac rules
diff --git a/Xext/sync.c b/Xext/sync.c
index 297820c..5ac281c 100644
--- a/Xext/sync.c
+++ b/Xext/sync.c
@@ -67,9 +67,9 @@ PERFORMANCE OF THIS SOFTWARE.
 #include "dixstruct.h"
 #include "resource.h"
 #include "opaque.h"
-#define _SYNC_SERVER
 #include <X11/extensions/sync.h>
 #include <X11/extensions/syncstr.h>
+#include "syncsrv.h"
 
 #include <stdio.h>
 #if !defined(WIN32) && !defined(Lynx)
diff --git a/Xext/syncsrv.h b/Xext/syncsrv.h
new file mode 100644
index 0000000..93f6b9d
--- /dev/null
+++ b/Xext/syncsrv.h
@@ -0,0 +1,176 @@
+/*
+
+Copyright 1991, 1993, 1994, 1998  The Open Group
+
+Permission to use, copy, modify, distribute, and sell this software and its
+documentation for any purpose is hereby granted without fee, provided that
+the above copyright notice appear in all copies and that both that
+copyright notice and this permission notice appear in supporting
+documentation.
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
+OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
+AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+Except as contained in this notice, the name of The Open Group shall 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.
+
+                        All Rights Reserved
+
+Permission to use, copy, modify, and distribute this software and its 
+documentation for any purpose and without fee is hereby granted, 
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in 
+supporting documentation, and that the names of Digital or Olivetti
+not be used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.  
+
+DIGITAL AND OLIVETTI DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL THEY BE LIABLE FOR ANY SPECIAL, INDIRECT OR
+CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF
+USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+
+******************************************************************/
+
+#ifndef _SYNCSTR_H_
+#define _SYNCSTR_H_
+
+#define CARD64 XSyncValue /* XXX temporary! need real 64 bit values for Alpha */
+
+typedef struct _SyncCounter {
+    ClientPtr		client;	/* Owning client. 0 for system counters */
+    XSyncCounter	id;		/* resource ID */
+    CARD64		value;		/* counter value */
+    struct _SyncTriggerList *pTriglist;	/* list of triggers */
+    Bool		beingDestroyed; /* in process of going away */
+    struct _SysCounterInfo *pSysCounterInfo; /* NULL if not a system counter */
+} SyncCounter;
+
+/*
+ * The System Counter interface
+ */
+
+typedef enum {
+    XSyncCounterNeverChanges,
+    XSyncCounterNeverIncreases,
+    XSyncCounterNeverDecreases,
+    XSyncCounterUnrestricted
+} SyncCounterType;
+
+typedef struct _SysCounterInfo {
+    char	*name;
+    CARD64	resolution;
+    CARD64	bracket_greater;
+    CARD64	bracket_less;
+    SyncCounterType counterType;  /* how can this counter change */
+    void        (*QueryValue)(
+			      pointer /*pCounter*/,
+			      CARD64 * /*freshvalue*/
+);
+    void	(*BracketValues)(
+				 pointer /*pCounter*/,
+				 CARD64 * /*lessthan*/,
+				 CARD64 * /*greaterthan*/
+);
+} SysCounterInfo;
+
+
+
+typedef struct _SyncTrigger {
+    SyncCounter *pCounter;
+    CARD64	wait_value;	/* wait value */
+    unsigned int value_type;     /* Absolute or Relative */
+    unsigned int test_type;	/* transition or Comparision type */
+    CARD64	test_value;	/* trigger event threshold value */
+    Bool	(*CheckTrigger)(
+				struct _SyncTrigger * /*pTrigger*/,
+				CARD64 /*newval*/
+				);
+    void	(*TriggerFired)(
+				struct _SyncTrigger * /*pTrigger*/
+				);
+    void	(*CounterDestroyed)(
+				struct _SyncTrigger * /*pTrigger*/
+				    );
+} SyncTrigger;
+
+typedef struct _SyncTriggerList {
+    SyncTrigger *pTrigger;
+    struct _SyncTriggerList *next;
+} SyncTriggerList;
+
+typedef struct _SyncAlarmClientList {
+    ClientPtr	client;
+    XID		delete_id;
+    struct _SyncAlarmClientList *next;
+} SyncAlarmClientList;
+
+typedef struct _SyncAlarm {
+    SyncTrigger trigger;
+    ClientPtr	client;
+    XSyncAlarm 	alarm_id;
+    CARD64	delta;
+    int		events;
+    int		state;
+    SyncAlarmClientList *pEventClients;
+} SyncAlarm;
+
+typedef struct {
+    ClientPtr	client;
+    CARD32 	delete_id;
+    int		num_waitconditions;
+} SyncAwaitHeader;
+
+typedef struct {
+    SyncTrigger trigger;
+    CARD64	event_threshold;
+    SyncAwaitHeader *pHeader;
+} SyncAwait;
+
+typedef union {
+    SyncAwaitHeader header;
+    SyncAwait	    await;
+} SyncAwaitUnion;
+
+
+extern pointer SyncCreateSystemCounter(
+    char *	/* name */,
+    CARD64  	/* inital_value */,
+    CARD64  	/* resolution */,
+    SyncCounterType /* change characterization */,
+    void        (* /*QueryValue*/ ) (
+        pointer /* pCounter */,
+        CARD64 * /* pValue_return */), /* XXX prototype */
+    void        (* /*BracketValues*/) (
+        pointer /* pCounter */, 
+        CARD64 * /* pbracket_less */,
+        CARD64 * /* pbracket_greater */)
+);
+
+extern void SyncChangeCounter(
+    SyncCounter *	/* pCounter*/,
+    CARD64  		/* new_value */
+);
+
+extern void SyncDestroySystemCounter(
+    pointer pCounter
+);
+extern void InitServertime(void);
+
+#endif /* _SYNCSTR_H_ */
-- 
1.6.0.2

From ddcb39894a6fa2e701e3678a418bc09e1544413d Mon Sep 17 00:00:00 2001
From: Federico Mena Quintero <federico@novell.com>
Date: Thu, 9 Apr 2009 15:31:25 -0500
Subject: [PATCH 3/7] Cherry-pick 1a99110f0c221b79045ea26d61c4a1ec1e0d7341

---
 Xext/sync.c |  530 ++++++++++++++++-------------------------------------------
 1 files changed, 138 insertions(+), 392 deletions(-)

diff --git a/Xext/sync.c b/Xext/sync.c
index 5ac281c..1131f25 100644
--- a/Xext/sync.c
+++ b/Xext/sync.c
@@ -34,7 +34,7 @@ Permission to use, copy, modify, and distribute this software and its
 documentation for any purpose and without fee is hereby granted,
 provided that the above copyright notice appear in all copies and that
 both that copyright notice and this permission notice appear in
-supporting documentation, and that the names of Digital or Olivetti 
+supporting documentation, and that the names of Digital or Olivetti
 not be used in advertising or publicity pertaining to distribution of the
 software without specific, written prior permission.  Digital and Olivetti
 make no representations about the suitability of this software
@@ -97,173 +97,11 @@ static SyncCounter **SysCounterList = NULL;
 #define XSyncCAAllTrigger \
     (XSyncCACounter | XSyncCAValueType | XSyncCAValue | XSyncCATestType)
 
-static int
-FreeAlarm(
-    pointer /* addr */,
-    XID /* id */
-);
-
-static int
-FreeAlarmClient(
-    pointer /* value */,
-    XID /* id */
-);
-
-static int
-FreeAwait(
-    pointer /* addr */,
-    XID /* id */
-);
-
-static void
-ServertimeBracketValues(
-    pointer /* pCounter */,
-    CARD64 * /* pbracket_less */,
-    CARD64 * /* pbracket_greater */
-);
-
-static void
-ServertimeQueryValue(
-    pointer /* pCounter */,
-    CARD64 * /* pValue_return */
-);
-
-static void
-ServertimeWakeupHandler(
-    pointer /* env */,
-    int /* rc */,
-    pointer /* LastSelectMask */
-);
-
-static int 
-SyncInitTrigger(
-    ClientPtr /* client */,
-    SyncTrigger * /* pTrigger */,
-    XSyncCounter /* counter */,
-    Mask /* changes */
-);
-
-static void
-SAlarmNotifyEvent(
-    xSyncAlarmNotifyEvent * /* from */,
-    xSyncAlarmNotifyEvent * /* to */
-);
-
-static void
-SCounterNotifyEvent(
-    xSyncCounterNotifyEvent * /* from */,
-    xSyncCounterNotifyEvent * /* to */
-);
-
-static void
-ServertimeBlockHandler(
-    pointer  /* env */,
-    struct timeval ** /* wt */,
-    pointer  /* LastSelectMask */
-);
-
-static int
-SyncAddTriggerToCounter(
-    SyncTrigger * /* pTrigger */
-);
-
-extern void
-SyncAlarmCounterDestroyed(
-    SyncTrigger * /* pTrigger */
-);
-
-static void
-SyncAlarmTriggerFired(
-    SyncTrigger * /* pTrigger */
-);
-
-static void
-SyncAwaitTriggerFired(
-    SyncTrigger * /* pTrigger */
-);
-
-static int
-SyncChangeAlarmAttributes(
-    ClientPtr /* client */,
-    SyncAlarm * /* pAlarm */,
-    Mask /* mask */,
-    CARD32 * /* values */
-);
-
-static Bool
-SyncCheckTriggerNegativeComparison(
-    SyncTrigger * /* pTrigger */,
-    CARD64 /* oldval */
-);
+static void SyncComputeBracketValues(SyncCounter *, Bool);
 
-static Bool
-SyncCheckTriggerNegativeTransition(
-    SyncTrigger * /* pTrigger */,
-    CARD64 /* oldval */
-);
-
-static Bool
-SyncCheckTriggerPositiveComparison(
-    SyncTrigger * /* pTrigger */,
-    CARD64 /* oldval */
-);
-
-static Bool
-SyncCheckTriggerPositiveTransition(
-    SyncTrigger * /* pTrigger */,
-    CARD64 /* oldval */
-);
-
-static SyncCounter *
-SyncCreateCounter(
-    ClientPtr /* client */,
-    XSyncCounter /* id */,
-    CARD64 /* initialvalue */
-);
-
-static void SyncComputeBracketValues(
-    SyncCounter * /* pCounter */,
-    Bool /* startOver */
-);
-
-static void
-SyncDeleteTriggerFromCounter(
-    SyncTrigger * /* pTrigger */
-);
-
-static Bool
-SyncEventSelectForAlarm(
-    SyncAlarm * /* pAlarm */,
-    ClientPtr /* client */,
-    Bool /* wantevents */
-);
-
-static void
-SyncInitServerTime(
-    void
-);
+static void SyncInitServerTime(void);
 
-static void
-SyncInitIdleTime(
-    void
-);
-
-static void 
-SyncResetProc(
-    ExtensionEntry * /* extEntry */
-);
-
-static void
-SyncSendAlarmNotifyEvents(
-    SyncAlarm * /* pAlarm */
-);
-
-static void
-SyncSendCounterNotifyEvents(
-    ClientPtr /* client */,
-    SyncAwait ** /* ppAwait */,
-    int /* num_events */
-);
+static void SyncInitIdleTime(void);
 
 static DISPATCH_PROC(ProcSyncAwait);
 static DISPATCH_PROC(ProcSyncChangeAlarm);
@@ -301,8 +139,7 @@ static DISPATCH_PROC(SProcSyncSetPriority);
  *  delete and add triggers on this list.
  */
 static void
-SyncDeleteTriggerFromCounter(pTrigger)
-    SyncTrigger *pTrigger;
+SyncDeleteTriggerFromCounter(SyncTrigger *pTrigger)
 {
     SyncTriggerList *pCur;
     SyncTriggerList *pPrev;
@@ -323,7 +160,7 @@ SyncDeleteTriggerFromCounter(pTrigger)
 		pPrev->next = pCur->next;
 	    else
 		pTrigger->pCounter->pTriglist = pCur->next;
-	    
+
 	    xfree(pCur);
 	    break;
 	}
@@ -331,15 +168,14 @@ SyncDeleteTriggerFromCounter(pTrigger)
 	pPrev = pCur;
 	pCur = pCur->next;
     }
-    
+
     if (IsSystemCounter(pTrigger->pCounter))
 	SyncComputeBracketValues(pTrigger->pCounter, /*startOver*/ TRUE);
 }
 
 
 static int
-SyncAddTriggerToCounter(pTrigger)
-    SyncTrigger *pTrigger;
+SyncAddTriggerToCounter(SyncTrigger *pTrigger)
 {
     SyncTriggerList *pCur;
 
@@ -367,7 +203,7 @@ SyncAddTriggerToCounter(pTrigger)
 }
 
 
-/*  Below are four possible functions that can be plugged into 
+/*  Below are four possible functions that can be plugged into
  *  pTrigger->CheckTrigger, corresponding to the four possible
  *  test-types.  These functions are called after the counter's
  *  value changes but are also passed the old counter value
@@ -377,14 +213,12 @@ SyncAddTriggerToCounter(pTrigger)
  *  of the trigger.
  *
  *  All of them include the condition pTrigger->pCounter == NULL.
- *  This is because the spec says that a trigger with a counter value 
+ *  This is because the spec says that a trigger with a counter value
  *  of None is always TRUE.
  */
 
 static Bool
-SyncCheckTriggerPositiveComparison(pTrigger, oldval)
-    SyncTrigger *pTrigger;
-    CARD64	oldval;
+SyncCheckTriggerPositiveComparison(SyncTrigger *pTrigger, CARD64 oldval)
 {
     return (pTrigger->pCounter == NULL ||
 	    XSyncValueGreaterOrEqual(pTrigger->pCounter->value,
@@ -392,9 +226,7 @@ SyncCheckTriggerPositiveComparison(pTrigger, oldval)
 }
 
 static Bool
-SyncCheckTriggerNegativeComparison(pTrigger, oldval)
-    SyncTrigger *pTrigger;
-    CARD64	oldval;
+SyncCheckTriggerNegativeComparison(SyncTrigger *pTrigger,  CARD64 oldval)
 {
     return (pTrigger->pCounter == NULL ||
 	    XSyncValueLessOrEqual(pTrigger->pCounter->value,
@@ -402,9 +234,7 @@ SyncCheckTriggerNegativeComparison(pTrigger, oldval)
 }
 
 static Bool
-SyncCheckTriggerPositiveTransition(pTrigger, oldval)
-    SyncTrigger *pTrigger;
-    CARD64	oldval;
+SyncCheckTriggerPositiveTransition(SyncTrigger *pTrigger, CARD64 oldval)
 {
     return (pTrigger->pCounter == NULL ||
 	    (XSyncValueLessThan(oldval, pTrigger->test_value) &&
@@ -413,9 +243,7 @@ SyncCheckTriggerPositiveTransition(pTrigger, oldval)
 }
 
 static Bool
-SyncCheckTriggerNegativeTransition(pTrigger, oldval)
-    SyncTrigger *pTrigger;
-    CARD64	oldval;
+SyncCheckTriggerNegativeTransition(SyncTrigger *pTrigger, CARD64 oldval)
 {
     return (pTrigger->pCounter == NULL ||
 	    (XSyncValueGreaterThan(oldval, pTrigger->test_value) &&
@@ -423,14 +251,9 @@ SyncCheckTriggerNegativeTransition(pTrigger, oldval)
 				   pTrigger->test_value)));
 }
 
-
-
-static int 
-SyncInitTrigger(client, pTrigger, counter, changes) 
-    ClientPtr	     client;    /* so we can set errorValue */
-    SyncTrigger      *pTrigger;
-    XSyncCounter     counter; 
-    Mask	     changes;
+static int
+SyncInitTrigger(ClientPtr client, SyncTrigger pTrigger, XSyncCounter counter,
+		Mask changes)
 {
     SyncCounter *pCounter = pTrigger->pCounter;
     int		rc;
@@ -486,16 +309,16 @@ SyncInitTrigger(client, pTrigger, counter, changes)
 
 	switch (pTrigger->test_type)
 	{
-        case XSyncPositiveTransition: 
+        case XSyncPositiveTransition:
 	    pTrigger->CheckTrigger = SyncCheckTriggerPositiveTransition;
 	    break;
-        case XSyncNegativeTransition: 
+        case XSyncNegativeTransition:
 	    pTrigger->CheckTrigger = SyncCheckTriggerNegativeTransition;
 	    break;
-        case XSyncPositiveComparison: 
+        case XSyncPositiveComparison:
 	    pTrigger->CheckTrigger = SyncCheckTriggerPositiveComparison;
 	    break;
-        case XSyncNegativeComparison: 
+        case XSyncNegativeComparison:
 	    pTrigger->CheckTrigger = SyncCheckTriggerNegativeComparison;
 	    break;
 	}
@@ -511,7 +334,7 @@ SyncInitTrigger(client, pTrigger, counter, changes)
 	    if (pCounter == NULL)
 		return BadMatch;
 
-	    XSyncValueAdd(&pTrigger->test_value, pCounter->value, 
+	    XSyncValueAdd(&pTrigger->test_value, pCounter->value,
 			  pTrigger->wait_value, &overflow);
 	    if (overflow)
 	    {
@@ -533,17 +356,16 @@ SyncInitTrigger(client, pTrigger, counter, changes)
     {
 	SyncComputeBracketValues(pCounter, /*startOver*/ TRUE);
     }
-    
+
     return Success;
 }
 
 /*  AlarmNotify events happen in response to actions taken on an Alarm or
- *  the counter used by the alarm.  AlarmNotify may be sent to multiple 
+ *  the counter used by the alarm.  AlarmNotify may be sent to multiple
  *  clients.  The alarm maintains a list of clients interested in events.
  */
 static void
-SyncSendAlarmNotifyEvents(pAlarm)
-    SyncAlarm *pAlarm;
+SyncSendAlarmNotifyEvents(SyncAlarm *pAlarm)
 {
     SyncAlarmClientList *pcl;
     xSyncAlarmNotifyEvent ane;
@@ -571,7 +393,7 @@ SyncSendAlarmNotifyEvents(pAlarm)
     ane.state = pAlarm->state;
 
     /* send to owner */
-    if (pAlarm->events && !pAlarm->client->clientGone) 
+    if (pAlarm->events && !pAlarm->client->clientGone)
 	WriteEventsToClient(pAlarm->client, 1, (xEvent *) &ane);
 
     /* send to other interested clients */
@@ -586,14 +408,12 @@ SyncSendAlarmNotifyEvents(pAlarm)
 }
 
 
-/*  CounterNotify events only occur in response to an Await.  The events 
+/*  CounterNotify events only occur in response to an Await.  The events
  *  go only to the Awaiting client.
  */
 static void
-SyncSendCounterNotifyEvents(client, ppAwait, num_events)
-    ClientPtr client;
-    SyncAwait **ppAwait;
-    int num_events;
+SyncSendCounterNotifyEvents(ClientPtr client, SyncAwait **ppAwait,
+			    int num_events)
 {
     xSyncCounterNotifyEvent *pEvents, *pev;
     int i;
@@ -601,7 +421,7 @@ SyncSendCounterNotifyEvents(client, ppAwait, num_events)
     if (client->clientGone)
 	return;
     pev = pEvents = xalloc(num_events * sizeof(xSyncCounterNotifyEvent));
-    if (!pEvents) 
+    if (!pEvents)
 	return;
     UpdateCurrentTime();
     for (i = 0; i < num_events; i++, ppAwait++, pev++)
@@ -629,8 +449,7 @@ SyncSendCounterNotifyEvents(client, ppAwait, num_events)
  * It is plugged into pTrigger->CounterDestroyed (for alarm triggers).
  */
 void
-SyncAlarmCounterDestroyed(pTrigger)
-    SyncTrigger *pTrigger;
+SyncAlarmCounterDestroyed(SyncTrigger *pTrigger)
 {
     SyncAlarm *pAlarm = (SyncAlarm *)pTrigger;
 
@@ -640,12 +459,11 @@ SyncAlarmCounterDestroyed(pTrigger)
 }
 
 
-/*  This function is called when an alarm "goes off."  
+/*  This function is called when an alarm "goes off."
  *  It is plugged into pTrigger->TriggerFired (for alarm triggers).
  */
 static void
-SyncAlarmTriggerFired(pTrigger)
-    SyncTrigger *pTrigger;
+SyncAlarmTriggerFired(SyncTrigger *pTrigger)
 {
     SyncAlarm *pAlarm = (SyncAlarm *)pTrigger;
     CARD64 new_test_value;
@@ -685,7 +503,7 @@ SyncAlarmTriggerFired(pTrigger)
 	{
 	    XSyncValueAdd(&paTrigger->test_value, paTrigger->test_value,
 			  pAlarm->delta, &overflow);
-	} while (!overflow && 
+	} while (!overflow &&
 	      (*paTrigger->CheckTrigger)(paTrigger,
 					paTrigger->pCounter->value));
 
@@ -720,8 +538,7 @@ SyncAlarmTriggerFired(pTrigger)
  *  (for Await triggers).
  */
 static void
-SyncAwaitTriggerFired(pTrigger)
-    SyncTrigger *pTrigger;
+SyncAwaitTriggerFired(SyncTrigger *pTrigger)
 {
     SyncAwait *pAwait = (SyncAwait *)pTrigger;
     int numwaits;
@@ -814,9 +631,7 @@ bail:
  *  any triggers depending on the counter will be checked.
  */
 void
-SyncChangeCounter(pCounter, newval)
-    SyncCounter    *pCounter;
-    CARD64         newval;
+SyncChangeCounter(SyncCounter *pCounter, CARD64 newval)
 {
     SyncTriggerList       *ptl, *pnext;
     CARD64 oldval;
@@ -841,10 +656,7 @@ SyncChangeCounter(pCounter, newval)
 
 /* loosely based on dix/events.c/EventSelectForWindow */
 static Bool
-SyncEventSelectForAlarm(pAlarm, client, wantevents)
-    SyncAlarm *pAlarm;
-    ClientPtr client;
-    Bool      wantevents;
+SyncEventSelectForAlarm(SyncAlarm *pAlarm, ClientPtr client, Bool wantevents)
 {
     SyncAlarmClientList *pClients;
 
@@ -861,8 +673,8 @@ SyncEventSelectForAlarm(pAlarm, client, wantevents)
     {
 	if (pClients->client == client)
 	{
-	    /* client's presence on the list indicates desire for 
-	     * events.  If the client doesn't want events, remove it 
+	    /* 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.
 	     */
@@ -879,7 +691,7 @@ SyncEventSelectForAlarm(pAlarm, client, wantevents)
      */
 
     if (!wantevents)
-	/* client doesn't want events, and we just discovered that it 
+	/* client doesn't want events, and we just discovered that it
 	 * doesn't have them, so there's nothing to do.
 	 */
 	return Success;
@@ -890,7 +702,7 @@ SyncEventSelectForAlarm(pAlarm, client, wantevents)
     if (!pClients)
 	return BadAlloc;
 
-    /*  register it as a resource so it will be cleaned up 
+    /*  register it as a resource so it will be cleaned up
      *  if the client dies
      */
 
@@ -912,12 +724,9 @@ SyncEventSelectForAlarm(pAlarm, client, wantevents)
 /*
  * ** SyncChangeAlarmAttributes ** This is used by CreateAlarm and ChangeAlarm
  */
-static int 
-SyncChangeAlarmAttributes(client, pAlarm, mask, values)
-    ClientPtr       client;
-    SyncAlarm      *pAlarm;
-    Mask	    mask;
-    CARD32	    *values;
+static int
+SyncChangeAlarmAttributes(ClientPtr client, SyncAlarm *pAlarm, Mask mask,
+			  CARD32 *values)
 {
     int		   status;
     XSyncCounter   counter;
@@ -1014,10 +823,7 @@ SyncChangeAlarmAttributes(client, pAlarm, mask, values)
 
 
 static SyncCounter *
-SyncCreateCounter(client, id, initialvalue)
-    ClientPtr	client;
-    XSyncCounter id;
-    CARD64      initialvalue;
+SyncCreateCounter(ClientPtr client, XSyncCounter id, CARD64 initialvalue)
 {
     SyncCounter *pCounter;
 
@@ -1039,16 +845,13 @@ SyncCreateCounter(client, id, initialvalue)
     return pCounter;
 }
 
-static int FreeCounter(
-    pointer /*env*/,
-    XID     /*id*/
-);
+static int FreeCounter(void *, XID);
 
 /*
  * ***** System Counter utilities
  */
 
-pointer 
+pointer
 SyncCreateSystemCounter(name, initial, resolution, counterType,
 			QueryValue, BracketValues)
     char           *name;
@@ -1056,7 +859,7 @@ SyncCreateSystemCounter(name, initial, resolution, counterType,
     CARD64          resolution;
     SyncCounterType counterType;
     void            (*QueryValue) (
-        pointer /* pCounter */, 
+        pointer /* pCounter */,
         CARD64 * /* pValue_return */);
     void            (*BracketValues) (
         pointer /* pCounter */,
@@ -1116,9 +919,7 @@ SyncDestroySystemCounter(pSysCounter)
 }
 
 static void
-SyncComputeBracketValues(pCounter, startOver)
-    SyncCounter *pCounter;
-    Bool startOver;
+SyncComputeBracketValues(SyncCounter *pCounter, Bool startOver)
 {
     SyncTriggerList *pCur;
     SyncTrigger *pTrigger;
@@ -1205,9 +1006,7 @@ SyncComputeBracketValues(pCounter, startOver)
 
 /* ARGSUSED */
 static int
-FreeAlarm(addr, id)
-    pointer         addr;
-    XID             id;
+FreeAlarm(void *addr, XID id)
 {
     SyncAlarm      *pAlarm = (SyncAlarm *) addr;
 
@@ -1232,9 +1031,7 @@ FreeAlarm(addr, id)
  */
 /* ARGSUSED */
 static int
-FreeCounter(env, id)
-    pointer         env;
-    XID             id;
+FreeCounter(void *env, XID id)
 {
     SyncCounter     *pCounter = (SyncCounter *) env;
     SyncTriggerList *ptl, *pnext;
@@ -1284,9 +1081,7 @@ FreeCounter(env, id)
  */
 /* ARGSUSED */
 static int
-FreeAwait(addr, id)
-    pointer         addr;
-    XID             id;
+FreeAwait(void *addr, XID id)
 {
     SyncAwaitUnion *pAwaitUnion = (SyncAwaitUnion *) addr;
     SyncAwait *pAwait;
@@ -1299,7 +1094,7 @@ FreeAwait(addr, id)
     for (numwaits = pAwaitUnion->header.num_waitconditions; numwaits;
 	 numwaits--, pAwait++)
     {
-	/* If the counter is being destroyed, FreeCounter will delete 
+	/* If the counter is being destroyed, FreeCounter will delete
 	 * the trigger list itself, so don't do it here.
 	 */
 	SyncCounter *pCounter = pAwait->trigger.pCounter;
@@ -1312,9 +1107,7 @@ FreeAwait(addr, id)
 
 /* loosely based on dix/events.c/OtherClientGone */
 static int
-FreeAlarmClient(value, id)
-    pointer value; /* must conform to DeleteType */
-    XID   id;
+FreeAlarmClient(void *value, XID id)
 {
     SyncAlarm *pAlarm = (SyncAlarm *)value;
     SyncAlarmClientList *pCur, *pPrev;
@@ -1346,9 +1139,8 @@ FreeAlarmClient(value, id)
 /*
  * ** Initialize the extension
  */
-static int 
-ProcSyncInitialize(client)
-    ClientPtr       client;
+static int
+ProcSyncInitialize(ClientPtr client)
 {
     xSyncInitializeReply  rep;
     int   n;
@@ -1372,14 +1164,13 @@ ProcSyncInitialize(client)
 /*
  * ** Get list of system counters available through the extension
  */
-static int 
-ProcSyncListSystemCounters(client)
-    ClientPtr       client;
+static int
+ProcSyncListSystemCounters(ClientPtr client)
 {
     xSyncListSystemCountersReply  rep;
     int i, len;
     xSyncSystemCounter *list = NULL, *walklist = NULL;
-    
+
     REQUEST_SIZE_MATCH(xSyncListSystemCountersReq);
 
     rep.type = X_Reply;
@@ -1433,12 +1224,12 @@ ProcSyncListSystemCounters(client)
 
 	pname_in_reply = ((char *)walklist) + sz_xSyncSystemCounter;
 	strncpy(pname_in_reply, psci->name, namelen);
-	walklist = (xSyncSystemCounter *) (((char *)walklist) + 
+	walklist = (xSyncSystemCounter *) (((char *)walklist) +
 				((sz_xSyncSystemCounter + namelen + 3) & ~3));
     }
 
     WriteToClient(client, sizeof(rep), (char *) &rep);
-    if (len) 
+    if (len)
     {
 	WriteToClient(client, len, (char *) list);
 	xfree(list);
@@ -1450,9 +1241,8 @@ ProcSyncListSystemCounters(client)
 /*
  * ** Set client Priority
  */
-static int 
-ProcSyncSetPriority(client)
-    ClientPtr       client;
+static int
+ProcSyncSetPriority(ClientPtr client)
 {
     REQUEST(xSyncSetPriorityReq);
     ClientPtr priorityclient;
@@ -1486,9 +1276,8 @@ ProcSyncSetPriority(client)
 /*
  * ** Get client Priority
  */
-static int 
-ProcSyncGetPriority(client)
-    ClientPtr       client;
+static int
+ProcSyncGetPriority(ClientPtr client)
 {
     REQUEST(xSyncGetPriorityReq);
     xSyncGetPriorityReply rep;
@@ -1526,9 +1315,8 @@ ProcSyncGetPriority(client)
 /*
  * ** Create a new counter
  */
-static int 
-ProcSyncCreateCounter(client)
-    ClientPtr       client;
+static int
+ProcSyncCreateCounter(ClientPtr client)
 {
     REQUEST(xSyncCreateCounterReq);
     CARD64          initial;
@@ -1547,9 +1335,8 @@ ProcSyncCreateCounter(client)
 /*
  * ** Set Counter value
  */
-static int 
-ProcSyncSetCounter(client)
-    ClientPtr       client;
+static int
+ProcSyncSetCounter(ClientPtr client)
 {
     REQUEST(xSyncSetCounterReq);
     SyncCounter    *pCounter;
@@ -1579,9 +1366,8 @@ ProcSyncSetCounter(client)
 /*
  * ** Change Counter value
  */
-static int 
-ProcSyncChangeCounter(client)
-    ClientPtr       client;
+static int
+ProcSyncChangeCounter(ClientPtr client)
 {
     REQUEST(xSyncChangeCounterReq);
     SyncCounter    *pCounter;
@@ -1609,7 +1395,7 @@ ProcSyncChangeCounter(client)
     if (overflow)
     {
 	/* XXX 64 bit value can't fit in 32 bits; do the best we can */
-	client->errorValue = stuff->value_hi; 
+	client->errorValue = stuff->value_hi;
 	return BadValue;
     }
     SyncChangeCounter(pCounter, newvalue);
@@ -1619,9 +1405,8 @@ ProcSyncChangeCounter(client)
 /*
  * ** Destroy a counter
  */
-static int 
-ProcSyncDestroyCounter(client)
-    ClientPtr       client;
+static int
+ProcSyncDestroyCounter(ClientPtr client)
 {
     REQUEST(xSyncDestroyCounterReq);
     SyncCounter    *pCounter;
@@ -1648,9 +1433,8 @@ ProcSyncDestroyCounter(client)
 /*
  * ** Await
  */
-static int 
-ProcSyncAwait(client)
-    ClientPtr       client;
+static int
+ProcSyncAwait(ClientPtr client)
 {
     REQUEST(xSyncAwaitReq);
     int             len, items;
@@ -1678,7 +1462,7 @@ ProcSyncAwait(client)
 
     pProtocolWaitConds = (xSyncWaitCondition *) & stuff[1];
 
-    /*  all the memory for the entire await list is allocated 
+    /*  all the memory for the entire await list is allocated
      *  here in one chunk
      */
     pAwaitUnion = xalloc((items+1) * sizeof(SyncAwaitUnion));
@@ -1764,9 +1548,8 @@ ProcSyncAwait(client)
 /*
  * ** Query a counter
  */
-static int 
-ProcSyncQueryCounter(client)
-    ClientPtr       client;
+static int
+ProcSyncQueryCounter(ClientPtr client)
 {
     REQUEST(xSyncQueryCounterReq);
     xSyncQueryCounterReply rep;
@@ -1812,9 +1595,8 @@ ProcSyncQueryCounter(client)
 /*
  * ** Create Alarm
  */
-static int 
-ProcSyncCreateAlarm(client)
-    ClientPtr       client;
+static int
+ProcSyncCreateAlarm(ClientPtr client)
 {
     REQUEST(xSyncCreateAlarmReq);
     SyncAlarm      *pAlarm;
@@ -1892,9 +1674,8 @@ ProcSyncCreateAlarm(client)
 /*
  * ** Change Alarm
  */
-static int 
-ProcSyncChangeAlarm(client)
-    ClientPtr       client;
+static int
+ProcSyncChangeAlarm(ClientPtr client)
 {
     REQUEST(xSyncChangeAlarmReq);
     SyncAlarm   *pAlarm;
@@ -1916,7 +1697,7 @@ ProcSyncChangeAlarm(client)
     if (len != (Ones(vmask) + Ones(vmask & (XSyncCAValue|XSyncCADelta))))
 	return BadLength;
 
-    if ((status = SyncChangeAlarmAttributes(client, pAlarm, vmask, 
+    if ((status = SyncChangeAlarmAttributes(client, pAlarm, vmask,
 					    (CARD32 *)&stuff[1])) != Success)
 	return status;
 
@@ -1933,9 +1714,8 @@ ProcSyncChangeAlarm(client)
     return Success;
 }
 
-static int 
-ProcSyncQueryAlarm(client)
-    ClientPtr       client;
+static int
+ProcSyncQueryAlarm(ClientPtr client)
 {
     REQUEST(xSyncQueryAlarmReq);
     SyncAlarm      *pAlarm;
@@ -1995,10 +1775,8 @@ ProcSyncQueryAlarm(client)
     return client->noClientException;
 }
 
-
-static int 
-ProcSyncDestroyAlarm(client)
-    ClientPtr       client;
+static int
+ProcSyncDestroyAlarm(ClientPtr client)
 {
     REQUEST(xSyncDestroyAlarmReq);
 
@@ -2018,15 +1796,13 @@ ProcSyncDestroyAlarm(client)
 /*
  * ** Given an extension request, call the appropriate request procedure
  */
-static int 
-ProcSyncDispatch(client)
-    ClientPtr       client;
+static int
+ProcSyncDispatch(ClientPtr client)
 {
     REQUEST(xReq);
 
     switch (stuff->data)
     {
-
       case X_SyncInitialize:
 	return ProcSyncInitialize(client);
       case X_SyncListSystemCounters:
@@ -2064,9 +1840,8 @@ ProcSyncDispatch(client)
  * Boring Swapping stuff ...
  */
 
-static int 
-SProcSyncInitialize(client)
-    ClientPtr       client;
+static int
+SProcSyncInitialize(ClientPtr client)
 {
     REQUEST(xSyncInitializeReq);
     register char   n;
@@ -2077,9 +1852,8 @@ SProcSyncInitialize(client)
     return ProcSyncInitialize(client);
 }
 
-static int 
-SProcSyncListSystemCounters(client)
-    ClientPtr       client;
+static int
+SProcSyncListSystemCounters(ClientPtr client)
 {
     REQUEST(xSyncListSystemCountersReq);
     register char   n;
@@ -2090,9 +1864,8 @@ SProcSyncListSystemCounters(client)
     return ProcSyncListSystemCounters(client);
 }
 
-static int 
-SProcSyncCreateCounter(client)
-    ClientPtr       client;
+static int
+SProcSyncCreateCounter(ClientPtr client)
 {
     REQUEST(xSyncCreateCounterReq);
     register char   n;
@@ -2106,9 +1879,8 @@ SProcSyncCreateCounter(client)
     return ProcSyncCreateCounter(client);
 }
 
-static int 
-SProcSyncSetCounter(client)
-    ClientPtr       client;
+static int
+SProcSyncSetCounter(ClientPtr client)
 {
     REQUEST(xSyncSetCounterReq);
     register char   n;
@@ -2122,9 +1894,8 @@ SProcSyncSetCounter(client)
     return ProcSyncSetCounter(client);
 }
 
-static int 
-SProcSyncChangeCounter(client)
-    ClientPtr       client;
+static int
+SProcSyncChangeCounter(ClientPtr client)
 {
     REQUEST(xSyncChangeCounterReq);
     register char   n;
@@ -2138,9 +1909,8 @@ SProcSyncChangeCounter(client)
     return ProcSyncChangeCounter(client);
 }
 
-static int 
-SProcSyncQueryCounter(client)
-    ClientPtr       client;
+static int
+SProcSyncQueryCounter(ClientPtr client)
 {
     REQUEST(xSyncQueryCounterReq);
     register char   n;
@@ -2152,9 +1922,8 @@ SProcSyncQueryCounter(client)
     return ProcSyncQueryCounter(client);
 }
 
-static int 
-SProcSyncDestroyCounter(client)
-    ClientPtr       client;
+static int
+SProcSyncDestroyCounter(ClientPtr client)
 {
     REQUEST(xSyncDestroyCounterReq);
     register char   n;
@@ -2166,9 +1935,8 @@ SProcSyncDestroyCounter(client)
     return ProcSyncDestroyCounter(client);
 }
 
-static int 
-SProcSyncAwait(client)
-    ClientPtr       client;
+static int
+SProcSyncAwait(ClientPtr client)
 {
     REQUEST(xSyncAwaitReq);
     register char   n;
@@ -2180,10 +1948,8 @@ SProcSyncAwait(client)
     return ProcSyncAwait(client);
 }
 
-
-static int 
-SProcSyncCreateAlarm(client)
-    ClientPtr       client;
+static int
+SProcSyncCreateAlarm(ClientPtr client)
 {
     REQUEST(xSyncCreateAlarmReq);
     register char   n;
@@ -2197,9 +1963,8 @@ SProcSyncCreateAlarm(client)
     return ProcSyncCreateAlarm(client);
 }
 
-static int 
-SProcSyncChangeAlarm(client)
-    ClientPtr       client;
+static int
+SProcSyncChangeAlarm(ClientPtr client)
 {
     REQUEST(xSyncChangeAlarmReq);
     register char   n;
@@ -2212,9 +1977,8 @@ SProcSyncChangeAlarm(client)
     return ProcSyncChangeAlarm(client);
 }
 
-static int 
-SProcSyncQueryAlarm(client)
-    ClientPtr       client;
+static int
+SProcSyncQueryAlarm(ClientPtr client)
 {
     REQUEST(xSyncQueryAlarmReq);
     register char   n;
@@ -2226,9 +1990,8 @@ SProcSyncQueryAlarm(client)
     return ProcSyncQueryAlarm(client);
 }
 
-static int 
-SProcSyncDestroyAlarm(client)
-    ClientPtr       client;
+static int
+SProcSyncDestroyAlarm(ClientPtr client)
 {
     REQUEST(xSyncDestroyAlarmReq);
     register char   n;
@@ -2240,9 +2003,8 @@ SProcSyncDestroyAlarm(client)
     return ProcSyncDestroyAlarm(client);
 }
 
-static int 
-SProcSyncSetPriority(client)
-    ClientPtr       client;
+static int
+SProcSyncSetPriority(ClientPtr client)
 {
     REQUEST(xSyncSetPriorityReq);
     register char   n;
@@ -2255,9 +2017,8 @@ SProcSyncSetPriority(client)
     return ProcSyncSetPriority(client);
 }
 
-static int 
-SProcSyncGetPriority(client)
-    ClientPtr       client;
+static int
+SProcSyncGetPriority(ClientPtr client)
 {
     REQUEST(xSyncGetPriorityReq);
     register char   n;
@@ -2270,9 +2031,8 @@ SProcSyncGetPriority(client)
 }
 
 
-static int 
-SProcSyncDispatch(client)
-    ClientPtr       client;
+static int
+SProcSyncDispatch(ClientPtr client)
 {
     REQUEST(xReq);
 
@@ -2315,9 +2075,8 @@ SProcSyncDispatch(client)
  * Event Swapping
  */
 
-static void 
-SCounterNotifyEvent(from, to)
-    xSyncCounterNotifyEvent *from, *to;
+static void
+SCounterNotifyEvent(xSyncCounterNotifyEvent *from, xSyncCounterNotifyEvent *to)
 {
     to->type = from->type;
     to->kind = from->kind;
@@ -2333,9 +2092,8 @@ SCounterNotifyEvent(from, to)
 }
 
 
-static void 
-SAlarmNotifyEvent(from, to)
-    xSyncAlarmNotifyEvent *from, *to;
+static void
+SAlarmNotifyEvent(xSyncAlarmNotifyEvent *from, xSyncAlarmNotifyEvent *to)
 {
     to->type = from->type;
     to->kind = from->kind;
@@ -2353,9 +2111,8 @@ SAlarmNotifyEvent(from, to)
  * ** Close everything down. ** This is fairly simple for now.
  */
 /* ARGSUSED */
-static void 
-SyncResetProc(extEntry)
-    ExtensionEntry *extEntry;
+static void
+SyncResetProc(ExtensionEntry *extEntry)
 {
     xfree(SysCounterList);
     SysCounterList = NULL;
@@ -2366,8 +2123,8 @@ SyncResetProc(extEntry)
 /*
  * ** Initialise the extension.
  */
-void 
-SyncExtensionInit(INITARGS)
+void
+SyncExtensionInit(void)
 {
     ExtensionEntry *extEntry;
 
@@ -2436,10 +2193,8 @@ static XSyncValue *pnext_time;
 *** code inspired by multibuffer extension
  */
 /*ARGSUSED*/
-static void ServertimeBlockHandler(env, wt, LastSelectMask)
-pointer env;
-struct timeval **wt;
-pointer LastSelectMask;
+static void
+ServertimeBlockHandler(void *env, struct timeval **wt, void *LastSelectMask)
 {
     XSyncValue delay;
     unsigned long timeout;
@@ -2451,7 +2206,7 @@ pointer LastSelectMask;
         if (XSyncValueGreaterOrEqual(Now, *pnext_time))
 	{
             timeout = 0;
-        } 
+        }
 	else
 	{
 	    Bool overflow;
@@ -2467,10 +2222,8 @@ pointer LastSelectMask;
 *** Wakeup Handler
  */
 /*ARGSUSED*/
-static void ServertimeWakeupHandler(env, rc, LastSelectMask)
-pointer env;
-int rc;
-pointer LastSelectMask;
+static void
+ServertimeWakeupHandler(void *env, int rc, void *LastSelectMask)
 {
     if (pnext_time)
     {
@@ -2484,19 +2237,15 @@ pointer LastSelectMask;
 }
 
 static void
-ServertimeQueryValue(pCounter, pValue_return)
-    pointer pCounter;
-    CARD64 *pValue_return;
+ServertimeQueryValue(void *pCounter, CARD64 *pValue_return)
 {
     GetTime();
     *pValue_return = Now;
 }
 
 static void
-ServertimeBracketValues(pCounter, pbracket_less, pbracket_greater)
-    pointer pCounter;
-    CARD64 *pbracket_less;
-    CARD64 *pbracket_greater;
+ServertimeBracketValues(void *pCounter, CARD64 *pbracket_less,
+			CARD64 *pbracket_greater)
 {
     if (!pnext_time && pbracket_greater)
     {
@@ -2579,9 +2328,7 @@ IdleTimeBlockHandler (pointer env,
 }
 
 static void
-IdleTimeWakeupHandler (pointer env,
-                       int rc,
-                       pointer LastSelectMask)
+IdleTimeWakeupHandler (pointer env, int rc, pointer LastSelectMask)
 {
     XSyncValue idle;
 
@@ -2600,8 +2347,7 @@ IdleTimeWakeupHandler (pointer env,
 }
 
 static void
-IdleTimeBracketValues (pointer pCounter,
-                       CARD64 *pbracket_less,
+IdleTimeBracketValues (pointer pCounter, CARD64 *pbracket_less,
                        CARD64 *pbracket_greater)
 {
     Bool registered = (pIdleTimeValueLess || pIdleTimeValueGreater);
-- 
1.6.0.2

From d538f70139aa259ed3c1cc915a4746bd248df108 Mon Sep 17 00:00:00 2001
From: Federico Mena Quintero <federico@novell.com>
Date: Thu, 9 Apr 2009 15:31:45 -0500
Subject: [PATCH 4/7] Cherry-pick 1f4fb0225b278d1cf4145aebeb0bdd23dc8f62d5

---
 Xext/sync.c |   51 +++++++++++++++++++++++++++++++++++++++++----------
 1 files changed, 41 insertions(+), 10 deletions(-)

diff --git a/Xext/sync.c b/Xext/sync.c
index 1131f25..07dd7db 100644
--- a/Xext/sync.c
+++ b/Xext/sync.c
@@ -2281,7 +2281,7 @@ SyncInitServerTime(void)
  * IDLETIME implementation
  */
 
-static pointer IdleTimeCounter;
+static SyncCounter *IdleTimeCounter;
 static XSyncValue *pIdleTimeValueLess;
 static XSyncValue *pIdleTimeValueGreater;
 
@@ -2293,38 +2293,69 @@ IdleTimeQueryValue (pointer pCounter, CARD64 *pValue_return)
 }
 
 static void
-IdleTimeBlockHandler (pointer env,
-                      struct timeval **wt,
-                      pointer LastSelectMask)
+IdleTimeBlockHandler(pointer env, struct timeval **wt, pointer LastSelectMask)
 {
-    XSyncValue idle;
+    XSyncValue idle, old_idle;
+    SyncTriggerList *list = IdleTimeCounter->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))
     {
-	AdjustWaitForDelay (wt, 0);
+	/*
+	 * 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->pTriglist; list; list = list->next) {
+	    trig = list->pTrigger;
+	    if (trig->CheckTrigger(trig, old_idle)) {
+		AdjustWaitForDelay(wt, 0);
+		break;
+	    }
+	}
     }
     else if (pIdleTimeValueGreater)
     {
-	unsigned long timeout = 0;
+	/*
+	 * 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))
-	{
+	if (XSyncValueLessThan (idle, *pIdleTimeValueGreater)) {
 	    XSyncValue value;
 	    Bool overflow;
 
 	    XSyncValueSubtract (&value, *pIdleTimeValueGreater,
 	                        idle, &overflow);
-	    timeout = XSyncValueLow32 (value);
+	    timeout = min(timeout, XSyncValueLow32 (value));
+	} else {
+	    for (list = IdleTimeCounter->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 */
 }
 
 static void
-- 
1.6.0.2

From b987e23dd7fb161d4b5cc1d87b25ea80b9624a3e Mon Sep 17 00:00:00 2001
From: Adam Jackson <ajax@redhat.com>
Date: Thu, 11 Dec 2008 13:16:02 -0500
Subject: [PATCH 5/7] xsync: build fix

argh protocol header disaster
---
 Xext/sync.c |    2 ++
 1 files changed, 2 insertions(+), 0 deletions(-)

diff --git a/Xext/sync.c b/Xext/sync.c
index 07dd7db..7a25250 100644
--- a/Xext/sync.c
+++ b/Xext/sync.c
@@ -67,7 +67,9 @@ PERFORMANCE OF THIS SOFTWARE.
 #include "dixstruct.h"
 #include "resource.h"
 #include "opaque.h"
+#define _SYNC_SERVER
 #include <X11/extensions/sync.h>
+#undef _SYNC_SERVER
 #include <X11/extensions/syncstr.h>
 #include "syncsrv.h"
 
-- 
1.6.0.2

From ee9b69705015319e52a1d90fc539510480cac4f7 Mon Sep 17 00:00:00 2001
From: Colin Harrison <colin.harrison@virgin.net>
Date: Thu, 11 Dec 2008 13:22:53 -0500
Subject: [PATCH 6/7] xsync: Prototype fix.

---
 Xext/sync.c |    2 +-
 1 files changed, 1 insertions(+), 1 deletions(-)

diff --git a/Xext/sync.c b/Xext/sync.c
index 7a25250..f9bb5f9 100644
--- a/Xext/sync.c
+++ b/Xext/sync.c
@@ -254,7 +254,7 @@ SyncCheckTriggerNegativeTransition(SyncTrigger *pTrigger, CARD64 oldval)
 }
 
 static int
-SyncInitTrigger(ClientPtr client, SyncTrigger pTrigger, XSyncCounter counter,
+SyncInitTrigger(ClientPtr client, SyncTrigger *pTrigger, XSyncCounter counter,
 		Mask changes)
 {
     SyncCounter *pCounter = pTrigger->pCounter;
-- 
1.6.0.2

From 4198ec69f3337ab147eb0f0c21d6d65f9c31c89a Mon Sep 17 00:00:00 2001
From: Adam Jackson <ajax@redhat.com>
Date: Thu, 11 Dec 2008 17:04:37 -0500
Subject: [PATCH 7/7] Fix syncsrv.h guard define

---
 Xext/syncsrv.h |    6 +++---
 1 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Xext/syncsrv.h b/Xext/syncsrv.h
index 93f6b9d..00e0bda 100644
--- a/Xext/syncsrv.h
+++ b/Xext/syncsrv.h
@@ -48,8 +48,8 @@ PERFORMANCE OF THIS SOFTWARE.
 
 ******************************************************************/
 
-#ifndef _SYNCSTR_H_
-#define _SYNCSTR_H_
+#ifndef _SYNCSRV_H_
+#define _SYNCSRV_H_
 
 #define CARD64 XSyncValue /* XXX temporary! need real 64 bit values for Alpha */
 
@@ -173,4 +173,4 @@ extern void SyncDestroySystemCounter(
 );
 extern void InitServertime(void);
 
-#endif /* _SYNCSTR_H_ */
+#endif /* _SYNCSRV_H_ */
-- 
1.6.0.2

Places

File xorg-x11-server-bnc472046-xsync-original-upstream-patch.diff of Package xorg-x11-server

Places