aboutsummaryrefslogtreecommitdiff
path: root/xorg-server/Xext/sync.c
diff options
context:
space:
mode:
Diffstat (limited to 'xorg-server/Xext/sync.c')
-rw-r--r--xorg-server/Xext/sync.c2484
1 files changed, 1195 insertions, 1289 deletions
diff --git a/xorg-server/Xext/sync.c b/xorg-server/Xext/sync.c
index 23360f002..91968e498 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;
@@ -1239,40 +1157,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));
@@ -1282,9 +1195,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;
@@ -1296,70 +1208,65 @@ ProcSyncInitialize(ClientPtr client)
static int
ProcSyncListSystemCounters(ClientPtr client)
{
- xSyncListSystemCountersReply rep;
- int i, len;
+ xSyncListSystemCountersReply rep;
+ SysCounterInfo *psci;
+ 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;
@@ -1378,24 +1285,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;
}
@@ -1414,12 +1320,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;
@@ -1427,10 +1333,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);
@@ -1445,15 +1350,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;
}
@@ -1465,21 +1371,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);
@@ -1494,31 +1399,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;
@@ -1531,26 +1434,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;
@@ -1558,9 +1460,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 */
@@ -1569,13 +1471,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;
@@ -1584,27 +1486,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 */
+ }
}
}
@@ -1615,12 +1515,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);
@@ -1628,63 +1528,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);
@@ -1692,7 +1587,6 @@ ProcSyncAwait(ClientPtr client)
return Success;
}
-
/*
* ** Query a counter
*/
@@ -1701,15 +1595,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;
@@ -1717,26 +1611,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
*/
@@ -1744,10 +1635,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);
@@ -1756,12 +1647,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 */
@@ -1774,11 +1664,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;
@@ -1788,39 +1677,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;
@@ -1833,40 +1718,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;
}
@@ -1875,29 +1759,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);
@@ -1913,16 +1798,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);
@@ -1934,14 +1818,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;
@@ -1959,19 +1844,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;
}
@@ -1986,14 +1869,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;
}
@@ -2007,10 +1890,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);
@@ -2026,13 +1909,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);
@@ -2048,10 +1931,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;
@@ -2067,10 +1950,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;
@@ -2078,10 +1961,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);
@@ -2094,6 +1976,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;
@@ -2108,62 +1991,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);
@@ -2179,50 +2056,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;
}
}
@@ -2235,7 +2111,7 @@ SProcSyncInitialize(ClientPtr client)
{
REQUEST(xSyncInitializeReq);
swaps(&stuff->length);
- REQUEST_SIZE_MATCH (xSyncInitializeReq);
+ REQUEST_SIZE_MATCH(xSyncInitializeReq);
return ProcSyncInitialize(client);
}
@@ -2245,7 +2121,7 @@ SProcSyncListSystemCounters(ClientPtr client)
{
REQUEST(xSyncListSystemCountersReq);
swaps(&stuff->length);
- REQUEST_SIZE_MATCH (xSyncListSystemCountersReq);
+ REQUEST_SIZE_MATCH(xSyncListSystemCountersReq);
return ProcSyncListSystemCounters(client);
}
@@ -2255,7 +2131,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);
@@ -2268,7 +2144,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);
@@ -2281,7 +2157,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);
@@ -2294,7 +2170,7 @@ SProcSyncQueryCounter(ClientPtr client)
{
REQUEST(xSyncQueryCounterReq);
swaps(&stuff->length);
- REQUEST_SIZE_MATCH (xSyncQueryCounterReq);
+ REQUEST_SIZE_MATCH(xSyncQueryCounterReq);
swapl(&stuff->counter);
return ProcSyncQueryCounter(client);
@@ -2305,7 +2181,7 @@ SProcSyncDestroyCounter(ClientPtr client)
{
REQUEST(xSyncDestroyCounterReq);
swaps(&stuff->length);
- REQUEST_SIZE_MATCH (xSyncDestroyCounterReq);
+ REQUEST_SIZE_MATCH(xSyncDestroyCounterReq);
swapl(&stuff->counter);
return ProcSyncDestroyCounter(client);
@@ -2352,7 +2228,7 @@ SProcSyncQueryAlarm(ClientPtr client)
{
REQUEST(xSyncQueryAlarmReq);
swaps(&stuff->length);
- REQUEST_SIZE_MATCH (xSyncQueryAlarmReq);
+ REQUEST_SIZE_MATCH(xSyncQueryAlarmReq);
swapl(&stuff->alarm);
return ProcSyncQueryAlarm(client);
@@ -2363,7 +2239,7 @@ SProcSyncDestroyAlarm(ClientPtr client)
{
REQUEST(xSyncDestroyAlarmReq);
swaps(&stuff->length);
- REQUEST_SIZE_MATCH (xSyncDestroyAlarmReq);
+ REQUEST_SIZE_MATCH(xSyncDestroyAlarmReq);
swapl(&stuff->alarm);
return ProcSyncDestroyAlarm(client);
@@ -2374,7 +2250,7 @@ SProcSyncSetPriority(ClientPtr client)
{
REQUEST(xSyncSetPriorityReq);
swaps(&stuff->length);
- REQUEST_SIZE_MATCH (xSyncSetPriorityReq);
+ REQUEST_SIZE_MATCH(xSyncSetPriorityReq);
swapl(&stuff->id);
swapl(&stuff->priority);
@@ -2386,7 +2262,7 @@ SProcSyncGetPriority(ClientPtr client)
{
REQUEST(xSyncGetPriorityReq);
swaps(&stuff->length);
- REQUEST_SIZE_MATCH (xSyncGetPriorityReq);
+ REQUEST_SIZE_MATCH(xSyncGetPriorityReq);
swapl(&stuff->id);
return ProcSyncGetPriority(client);
@@ -2397,7 +2273,7 @@ SProcSyncCreateFence(ClientPtr client)
{
REQUEST(xSyncCreateFenceReq);
swaps(&stuff->length);
- REQUEST_SIZE_MATCH (xSyncCreateFenceReq);
+ REQUEST_SIZE_MATCH(xSyncCreateFenceReq);
swapl(&stuff->fid);
return ProcSyncCreateFence(client);
@@ -2408,7 +2284,7 @@ SProcSyncTriggerFence(ClientPtr client)
{
REQUEST(xSyncTriggerFenceReq);
swaps(&stuff->length);
- REQUEST_SIZE_MATCH (xSyncTriggerFenceReq);
+ REQUEST_SIZE_MATCH(xSyncTriggerFenceReq);
swapl(&stuff->fid);
return ProcSyncTriggerFence(client);
@@ -2419,7 +2295,7 @@ SProcSyncResetFence(ClientPtr client)
{
REQUEST(xSyncResetFenceReq);
swaps(&stuff->length);
- REQUEST_SIZE_MATCH (xSyncResetFenceReq);
+ REQUEST_SIZE_MATCH(xSyncResetFenceReq);
swapl(&stuff->fid);
return ProcSyncResetFence(client);
@@ -2430,7 +2306,7 @@ SProcSyncDestroyFence(ClientPtr client)
{
REQUEST(xSyncDestroyFenceReq);
swaps(&stuff->length);
- REQUEST_SIZE_MATCH (xSyncDestroyFenceReq);
+ REQUEST_SIZE_MATCH(xSyncDestroyFenceReq);
swapl(&stuff->fid);
return ProcSyncDestroyFence(client);
@@ -2441,7 +2317,7 @@ SProcSyncQueryFence(ClientPtr client)
{
REQUEST(xSyncQueryFenceReq);
swaps(&stuff->length);
- REQUEST_SIZE_MATCH (xSyncQueryFenceReq);
+ REQUEST_SIZE_MATCH(xSyncQueryFenceReq);
swapl(&stuff->fid);
return ProcSyncQueryFence(client);
@@ -2463,50 +2339,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;
}
}
@@ -2515,7 +2390,8 @@ SProcSyncDispatch(ClientPtr client)
*/
static void
-SCounterNotifyEvent(xSyncCounterNotifyEvent *from, xSyncCounterNotifyEvent *to)
+SCounterNotifyEvent(xSyncCounterNotifyEvent * from,
+ xSyncCounterNotifyEvent * to)
{
to->type = from->type;
to->kind = from->kind;
@@ -2530,9 +2406,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;
@@ -2551,10 +2426,8 @@ SAlarmNotifyEvent(xSyncAlarmNotifyEvent *from, xSyncAlarmNotifyEvent *to)
*/
/* ARGSUSED */
static void
-SyncResetProc(ExtensionEntry *extEntry)
+SyncResetProc(ExtensionEntry * extEntry)
{
- free(SysCounterList);
- SysCounterList = NULL;
RTCounter = 0;
}
@@ -2565,41 +2438,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);
@@ -2616,17 +2490,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;
@@ -2643,72 +2514,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;
}
@@ -2721,157 +2582,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);
}