diff options
Diffstat (limited to 'xorg-server/Xext/sync.c')
| -rw-r--r-- | xorg-server/Xext/sync.c | 2484 |
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); } |