andreacavalli
/
xserver-multidpi
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

sync: Convert from "CARD64" to int64_t. 

The extension was using the name CARD64 to represent 64-bit values,
with a #define from CARD64 to XSyncValue, a struct with a pair of
32-bit values representing a signed 64-bit value.  This interfered
with protocol headers using CARD64 to try to actually store a
uint64_t.  Now that stdint.h exists, let's just use that here,
instead.

v2: Fix alarm delta changes.
v3: Do the potentially overflowing math as uint and convert to int
    afterward, out of C spec paranoia.

Signed-off-by: Eric Anholt <eric@anholt.net>
Reviewed-by: Keith Packard <keithp@keithp.com>
This commit is contained in:
Eric Anholt 2017-09-18 17:34:32 -07:00 committed by Adam Jackson
parent 5cbfa27654
commit e0f872207a
6 changed files with 216 additions and 208 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

354
Xext/sync.c
View File

@ -237,7 +237,37 @@ SyncAddTriggerToSyncObject(SyncTrigger * pTrigger)
*/ */
static Bool static Bool
SyncCheckTriggerPositiveComparison(SyncTrigger * pTrigger, CARD64 oldval) SyncCheckTriggerPositiveComparison(SyncTrigger * pTrigger, int64_t 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;
pCounter = (SyncCounter *) pTrigger->pSync;
return pCounter == NULL || pCounter->value >= pTrigger->test_value;
}
static Bool
SyncCheckTriggerNegativeComparison(SyncTrigger * pTrigger, int64_t 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;
pCounter = (SyncCounter *) pTrigger->pSync;
return pCounter == NULL || pCounter->value <= pTrigger->test_value;
}
static Bool
SyncCheckTriggerPositiveTransition(SyncTrigger * pTrigger, int64_t oldval)
{ {
SyncCounter *pCounter; SyncCounter *pCounter;
@ -249,11 +279,12 @@ SyncCheckTriggerPositiveComparison(SyncTrigger * pTrigger, CARD64 oldval)
pCounter = (SyncCounter *) pTrigger->pSync; pCounter = (SyncCounter *) pTrigger->pSync;
return (pCounter == NULL || return (pCounter == NULL ||
XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value)); (oldval < pTrigger->test_value &&
pCounter->value >= pTrigger->test_value));
} }
static Bool static Bool
SyncCheckTriggerNegativeComparison(SyncTrigger * pTrigger, CARD64 oldval) SyncCheckTriggerNegativeTransition(SyncTrigger * pTrigger, int64_t oldval)
{ {
SyncCounter *pCounter; SyncCounter *pCounter;
@ -265,45 +296,12 @@ SyncCheckTriggerNegativeComparison(SyncTrigger * pTrigger, CARD64 oldval)
pCounter = (SyncCounter *) pTrigger->pSync; pCounter = (SyncCounter *) pTrigger->pSync;
return (pCounter == NULL || return (pCounter == NULL ||
XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value)); (oldval > pTrigger->test_value &&
pCounter->value <= pTrigger->test_value));
} }
static Bool static Bool
SyncCheckTriggerPositiveTransition(SyncTrigger * pTrigger, CARD64 oldval) SyncCheckTriggerFence(SyncTrigger * pTrigger, int64_t unused)
{
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;
pCounter = (SyncCounter *) pTrigger->pSync;
return (pCounter == NULL ||
(XSyncValueLessThan(oldval, pTrigger->test_value) &&
XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value)));
}
static Bool
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;
pCounter = (SyncCounter *) pTrigger->pSync;
return (pCounter == NULL ||
(XSyncValueGreaterThan(oldval, pTrigger->test_value) &&
XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value)));
}
static Bool
SyncCheckTriggerFence(SyncTrigger * pTrigger, CARD64 unused)
{ {
SyncFence *pFence = (SyncFence *) pTrigger->pSync; SyncFence *pFence = (SyncFence *) pTrigger->pSync;
@ -389,16 +387,15 @@ SyncInitTrigger(ClientPtr client, SyncTrigger * pTrigger, XID syncObject,
if (pTrigger->value_type == XSyncAbsolute) if (pTrigger->value_type == XSyncAbsolute)
pTrigger->test_value = pTrigger->wait_value; pTrigger->test_value = pTrigger->wait_value;
else { /* relative */ else { /* relative */
Bool overflow; Bool overflow;
if (pCounter == NULL) if (pCounter == NULL)
return BadMatch; return BadMatch;
XSyncValueAdd(&pTrigger->test_value, pCounter->value, overflow = checked_int64_add(&pTrigger->test_value,
pTrigger->wait_value, &overflow); pCounter->value, pTrigger->wait_value);
if (overflow) { if (overflow) {
client->errorValue = XSyncValueHigh32(pTrigger->wait_value); client->errorValue = pTrigger->wait_value >> 32;
return BadValue; return BadValue;
} }
} }
@ -441,15 +438,15 @@ SyncSendAlarmNotifyEvents(SyncAlarm * pAlarm)
.type = SyncEventBase + XSyncAlarmNotify, .type = SyncEventBase + XSyncAlarmNotify,
.kind = XSyncAlarmNotify, .kind = XSyncAlarmNotify,
.alarm = pAlarm->alarm_id, .alarm = pAlarm->alarm_id,
.alarm_value_hi = XSyncValueHigh32(pTrigger->test_value), .alarm_value_hi = pTrigger->test_value >> 32,
.alarm_value_lo = XSyncValueLow32(pTrigger->test_value), .alarm_value_lo = pTrigger->test_value,
.time = currentTime.milliseconds, .time = currentTime.milliseconds,
.state = pAlarm->state .state = pAlarm->state
}; };
if (pTrigger->pSync && SYNC_COUNTER == pTrigger->pSync->type) { if (pTrigger->pSync && SYNC_COUNTER == pTrigger->pSync->type) {
ane.counter_value_hi = XSyncValueHigh32(pCounter->value); ane.counter_value_hi = pCounter->value >> 32;
ane.counter_value_lo = XSyncValueLow32(pCounter->value); ane.counter_value_lo = pCounter->value;
} }
else { else {
/* XXX what else can we do if there's no counter? */ /* XXX what else can we do if there's no counter? */
@ -487,13 +484,13 @@ SyncSendCounterNotifyEvents(ClientPtr client, SyncAwait ** ppAwait,
pev->type = SyncEventBase + XSyncCounterNotify; pev->type = SyncEventBase + XSyncCounterNotify;
pev->kind = XSyncCounterNotify; pev->kind = XSyncCounterNotify;
pev->counter = pTrigger->pSync->id; pev->counter = pTrigger->pSync->id;
pev->wait_value_lo = XSyncValueLow32(pTrigger->test_value); pev->wait_value_lo = pTrigger->test_value;
pev->wait_value_hi = XSyncValueHigh32(pTrigger->test_value); pev->wait_value_hi = pTrigger->test_value >> 32;
if (SYNC_COUNTER == pTrigger->pSync->type) { if (SYNC_COUNTER == pTrigger->pSync->type) {
SyncCounter *pCounter = (SyncCounter *) pTrigger->pSync; SyncCounter *pCounter = (SyncCounter *) pTrigger->pSync;
pev->counter_value_lo = XSyncValueLow32(pCounter->value); pev->counter_value_lo = pCounter->value;
pev->counter_value_hi = XSyncValueHigh32(pCounter->value); pev->counter_value_hi = pCounter->value >> 32;
} }
else { else {
pev->counter_value_lo = 0; pev->counter_value_lo = 0;
@ -530,7 +527,7 @@ SyncAlarmTriggerFired(SyncTrigger * pTrigger)
{ {
SyncAlarm *pAlarm = (SyncAlarm *) pTrigger; SyncAlarm *pAlarm = (SyncAlarm *) pTrigger;
SyncCounter *pCounter; SyncCounter *pCounter;
CARD64 new_test_value; int64_t new_test_value;
if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_ALARM)) if (!SyncCheckWarnIsCounter(pTrigger->pSync, WARN_INVALID_COUNTER_ALARM))
return; return;
@ -546,7 +543,7 @@ SyncAlarmTriggerFired(SyncTrigger * pTrigger)
* no change is made to value (test-value) and the alarm * no change is made to value (test-value) and the alarm
* state is changed to Inactive before the event is generated." * state is changed to Inactive before the event is generated."
*/ */
if (pCounter == NULL || (XSyncValueIsZero(pAlarm->delta) if (pCounter == NULL || (pAlarm->delta == 0
&& (pAlarm->trigger.test_type == && (pAlarm->trigger.test_type ==
XSyncPositiveComparison || XSyncPositiveComparison ||
pAlarm->trigger.test_type == pAlarm->trigger.test_type ==
@ -557,7 +554,7 @@ SyncAlarmTriggerFired(SyncTrigger * pTrigger)
if (pAlarm->state == XSyncAlarmActive) { if (pAlarm->state == XSyncAlarmActive) {
Bool overflow; Bool overflow;
CARD64 oldvalue; int64_t oldvalue;
SyncTrigger *paTrigger = &pAlarm->trigger; SyncTrigger *paTrigger = &pAlarm->trigger;
SyncCounter *paCounter; SyncCounter *paCounter;
@ -576,8 +573,8 @@ SyncAlarmTriggerFired(SyncTrigger * pTrigger)
/* XXX really should do something smarter here */ /* XXX really should do something smarter here */
do { do {
XSyncValueAdd(&paTrigger->test_value, paTrigger->test_value, overflow = checked_int64_add(&paTrigger->test_value,
pAlarm->delta, &overflow); paTrigger->test_value, pAlarm->delta);
} while (!overflow && } while (!overflow &&
(*paTrigger->CheckTrigger) (paTrigger, paCounter->value)); (*paTrigger->CheckTrigger) (paTrigger, paCounter->value));
@ -636,7 +633,7 @@ SyncAwaitTriggerFired(SyncTrigger * pTrigger)
* be stored in the events. * be stored in the events.
*/ */
for (; numwaits; numwaits--, pAwait++) { for (; numwaits; numwaits--, pAwait++) {
CARD64 diff; int64_t diff;
Bool overflow, diffgreater, diffequal; Bool overflow, diffgreater, diffequal;
/* "A CounterNotify event with the destroyed flag set to TRUE is /* "A CounterNotify event with the destroyed flag set to TRUE is
@ -655,16 +652,16 @@ SyncAwaitTriggerFired(SyncTrigger * pTrigger)
* calculated by subtracting the test value from the value of * calculated by subtracting the test value from the value of
* the counter." * the counter."
*/ */
XSyncValueSubtract(&diff, pCounter->value, overflow = checked_int64_subtract(&diff, pCounter->value,
pAwait->trigger.test_value, &overflow); pAwait->trigger.test_value);
/* "If the difference lies outside the range for an INT64, an /* "If the difference lies outside the range for an INT64, an
* event is not generated." * event is not generated."
*/ */
if (overflow) if (overflow)
continue; continue;
diffgreater = XSyncValueGreaterThan(diff, pAwait->event_threshold); diffgreater = diff >= pAwait->event_threshold;
diffequal = XSyncValueEqual(diff, pAwait->event_threshold); diffequal = diff == pAwait->event_threshold;
/* "If the test-type is PositiveTransition or /* "If the test-type is PositiveTransition or
* PositiveComparison, a CounterNotify event is generated if * PositiveComparison, a CounterNotify event is generated if
@ -699,10 +696,10 @@ SyncAwaitTriggerFired(SyncTrigger * pTrigger)
FreeResource(pAwaitUnion->header.delete_id, RT_NONE); FreeResource(pAwaitUnion->header.delete_id, RT_NONE);
} }
static CARD64 static int64_t
SyncUpdateCounter(SyncCounter *pCounter, CARD64 newval) SyncUpdateCounter(SyncCounter *pCounter, int64_t newval)
{ {
CARD64 oldval = pCounter->value; int64_t oldval = pCounter->value;
pCounter->value = newval; pCounter->value = newval;
return oldval; return oldval;
} }
@ -711,10 +708,10 @@ SyncUpdateCounter(SyncCounter *pCounter, CARD64 newval)
* any triggers depending on the counter will be checked. * any triggers depending on the counter will be checked.
*/ */
void void
SyncChangeCounter(SyncCounter * pCounter, CARD64 newval) SyncChangeCounter(SyncCounter * pCounter, int64_t newval)
{ {
SyncTriggerList *ptl, *pnext; SyncTriggerList *ptl, *pnext;
CARD64 oldval; int64_t oldval;
oldval = SyncUpdateCounter(pCounter, newval); oldval = SyncUpdateCounter(pCounter, newval);
@ -822,7 +819,7 @@ SyncChangeAlarmAttributes(ClientPtr client, SyncAlarm * pAlarm, Mask mask,
case XSyncCAValue: case XSyncCAValue:
mask &= ~XSyncCAValue; mask &= ~XSyncCAValue;
XSyncIntsToValue(&pAlarm->trigger.wait_value, values[1], values[0]); pAlarm->trigger.wait_value = ((int64_t)values[0] << 32) | values[1];
values += 2; values += 2;
break; break;
@ -834,7 +831,7 @@ SyncChangeAlarmAttributes(ClientPtr client, SyncAlarm * pAlarm, Mask mask,
case XSyncCADelta: case XSyncCADelta:
mask &= ~XSyncCADelta; mask &= ~XSyncCADelta;
XSyncIntsToValue(&pAlarm->delta, values[1], values[0]); pAlarm->delta = ((int64_t)values[0] << 32) | values[1];
values += 2; values += 2;
break; break;
@ -862,16 +859,13 @@ SyncChangeAlarmAttributes(ClientPtr client, SyncAlarm * pAlarm, Mask mask,
* greater than zero, a Match error is generated." * greater than zero, a Match error is generated."
*/ */
if (origmask & (XSyncCADelta | XSyncCATestType)) { if (origmask & (XSyncCADelta | XSyncCATestType)) {
CARD64 zero;
XSyncIntToValue(&zero, 0);
if ((((pAlarm->trigger.test_type == XSyncPositiveComparison) || if ((((pAlarm->trigger.test_type == XSyncPositiveComparison) ||
(pAlarm->trigger.test_type == XSyncPositiveTransition)) (pAlarm->trigger.test_type == XSyncPositiveTransition))
&& XSyncValueLessThan(pAlarm->delta, zero)) && pAlarm->delta < 0)
|| ||
(((pAlarm->trigger.test_type == XSyncNegativeComparison) || (((pAlarm->trigger.test_type == XSyncNegativeComparison) ||
(pAlarm->trigger.test_type == XSyncNegativeTransition)) (pAlarm->trigger.test_type == XSyncNegativeTransition))
&& XSyncValueGreaterThan(pAlarm->delta, zero)) && pAlarm->delta >= 0)
) { ) {
return BadMatch; return BadMatch;
} }
@ -953,7 +947,7 @@ SyncFDFromFence(ClientPtr client, DrawablePtr pDraw, SyncFence *pFence)
} }
static SyncCounter * static SyncCounter *
SyncCreateCounter(ClientPtr client, XSyncCounter id, CARD64 initialvalue) SyncCreateCounter(ClientPtr client, XSyncCounter id, int64_t initialvalue)
{ {
SyncCounter *pCounter; SyncCounter *pCounter;
@ -977,8 +971,8 @@ static int FreeCounter(void *, XID);
SyncCounter* SyncCounter*
SyncCreateSystemCounter(const char *name, SyncCreateSystemCounter(const char *name,
CARD64 initial, int64_t initial,
CARD64 resolution, int64_t resolution,
SyncCounterType counterType, SyncCounterType counterType,
SyncSystemCounterQueryValue QueryValue, SyncSystemCounterQueryValue QueryValue,
SyncSystemCounterBracketValues BracketValues SyncSystemCounterBracketValues BracketValues
@ -1002,8 +996,8 @@ SyncCreateSystemCounter(const char *name,
psci->QueryValue = QueryValue; psci->QueryValue = QueryValue;
psci->BracketValues = BracketValues; psci->BracketValues = BracketValues;
psci->private = NULL; psci->private = NULL;
XSyncMaxValue(&psci->bracket_greater); psci->bracket_greater = LLONG_MAX;
XSyncMinValue(&psci->bracket_less); psci->bracket_less = LLONG_MIN;
xorg_list_add(&psci->entry, &SysCounterList); xorg_list_add(&psci->entry, &SysCounterList);
} }
return pCounter; return pCounter;
@ -1023,8 +1017,8 @@ SyncComputeBracketValues(SyncCounter * pCounter)
SyncTriggerList *pCur; SyncTriggerList *pCur;
SyncTrigger *pTrigger; SyncTrigger *pTrigger;
SysCounterInfo *psci; SysCounterInfo *psci;
CARD64 *pnewgtval = NULL; int64_t *pnewgtval = NULL;
CARD64 *pnewltval = NULL; int64_t *pnewltval = NULL;
SyncCounterType ct; SyncCounterType ct;
if (!pCounter) if (!pCounter)
@ -1035,44 +1029,42 @@ SyncComputeBracketValues(SyncCounter * pCounter)
if (ct == XSyncCounterNeverChanges) if (ct == XSyncCounterNeverChanges)
return; return;
XSyncMaxValue(&psci->bracket_greater); psci->bracket_greater = LLONG_MAX;
XSyncMinValue(&psci->bracket_less); psci->bracket_less = LLONG_MIN;
for (pCur = pCounter->sync.pTriglist; pCur; pCur = pCur->next) { for (pCur = pCounter->sync.pTriglist; pCur; pCur = pCur->next) {
pTrigger = pCur->pTrigger; pTrigger = pCur->pTrigger;
if (pTrigger->test_type == XSyncPositiveComparison && if (pTrigger->test_type == XSyncPositiveComparison &&
ct != XSyncCounterNeverIncreases) { ct != XSyncCounterNeverIncreases) {
if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) && if (pCounter->value < pTrigger->test_value &&
XSyncValueLessThan(pTrigger->test_value, pTrigger->test_value < psci->bracket_greater) {
psci->bracket_greater)) {
psci->bracket_greater = pTrigger->test_value; psci->bracket_greater = pTrigger->test_value;
pnewgtval = &psci->bracket_greater; pnewgtval = &psci->bracket_greater;
} }
else if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) && else if (pCounter->value > pTrigger->test_value &&
XSyncValueGreaterThan(pTrigger->test_value, psci->bracket_less)) { pTrigger->test_value > psci->bracket_less) {
psci->bracket_less = pTrigger->test_value; psci->bracket_less = pTrigger->test_value;
pnewltval = &psci->bracket_less; pnewltval = &psci->bracket_less;
} }
} }
else if (pTrigger->test_type == XSyncNegativeComparison && else if (pTrigger->test_type == XSyncNegativeComparison &&
ct != XSyncCounterNeverDecreases) { ct != XSyncCounterNeverDecreases) {
if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) && if (pCounter->value > pTrigger->test_value &&
XSyncValueGreaterThan(pTrigger->test_value, pTrigger->test_value > psci->bracket_less) {
psci->bracket_less)) {
psci->bracket_less = pTrigger->test_value; psci->bracket_less = pTrigger->test_value;
pnewltval = &psci->bracket_less; pnewltval = &psci->bracket_less;
} }
else if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) && else if (pCounter->value < pTrigger->test_value &&
XSyncValueLessThan(pTrigger->test_value, psci->bracket_greater)) { pTrigger->test_value < psci->bracket_greater) {
psci->bracket_greater = pTrigger->test_value; psci->bracket_greater = pTrigger->test_value;
pnewgtval = &psci->bracket_greater; pnewgtval = &psci->bracket_greater;
} }
} }
else if (pTrigger->test_type == XSyncNegativeTransition && else if (pTrigger->test_type == XSyncNegativeTransition &&
ct != XSyncCounterNeverIncreases) { ct != XSyncCounterNeverIncreases) {
if (XSyncValueGreaterOrEqual(pCounter->value, pTrigger->test_value) && if (pCounter->value >= pTrigger->test_value &&
XSyncValueGreaterThan(pTrigger->test_value, psci->bracket_less)) { pTrigger->test_value > psci->bracket_less) {
/* /*
* If the value is exactly equal to our threshold, we want one * If the value is exactly equal to our threshold, we want one
* more event in the negative direction to ensure we pick up * more event in the negative direction to ensure we pick up
@ -1081,16 +1073,16 @@ SyncComputeBracketValues(SyncCounter * pCounter)
psci->bracket_less = pTrigger->test_value; psci->bracket_less = pTrigger->test_value;
pnewltval = &psci->bracket_less; pnewltval = &psci->bracket_less;
} }
else if (XSyncValueLessThan(pCounter->value, pTrigger->test_value) && else if (pCounter->value < pTrigger->test_value &&
XSyncValueLessThan(pTrigger->test_value, psci->bracket_greater)) { pTrigger->test_value < psci->bracket_greater) {
psci->bracket_greater = pTrigger->test_value; psci->bracket_greater = pTrigger->test_value;
pnewgtval = &psci->bracket_greater; pnewgtval = &psci->bracket_greater;
} }
} }
else if (pTrigger->test_type == XSyncPositiveTransition && else if (pTrigger->test_type == XSyncPositiveTransition &&
ct != XSyncCounterNeverDecreases) { ct != XSyncCounterNeverDecreases) {
if (XSyncValueLessOrEqual(pCounter->value, pTrigger->test_value) && if (pCounter->value <= pTrigger->test_value &&
XSyncValueLessThan(pTrigger->test_value, psci->bracket_greater)) { pTrigger->test_value < psci->bracket_greater) {
/* /*
* If the value is exactly equal to our threshold, we * If the value is exactly equal to our threshold, we
* want one more event in the positive direction to * want one more event in the positive direction to
@ -1100,8 +1092,8 @@ SyncComputeBracketValues(SyncCounter * pCounter)
psci->bracket_greater = pTrigger->test_value; psci->bracket_greater = pTrigger->test_value;
pnewgtval = &psci->bracket_greater; pnewgtval = &psci->bracket_greater;
} }
else if (XSyncValueGreaterThan(pCounter->value, pTrigger->test_value) && else if (pCounter->value > pTrigger->test_value &&
XSyncValueGreaterThan(pTrigger->test_value, psci->bracket_less)) { pTrigger->test_value > psci->bracket_less) {
psci->bracket_less = pTrigger->test_value; psci->bracket_less = pTrigger->test_value;
pnewltval = &psci->bracket_less; pnewltval = &psci->bracket_less;
} }
@ -1283,8 +1275,8 @@ ProcSyncListSystemCounters(ClientPtr client)
char *pname_in_reply; char *pname_in_reply;
walklist->counter = psci->pCounter->sync.id; walklist->counter = psci->pCounter->sync.id;
walklist->resolution_hi = XSyncValueHigh32(psci->resolution); walklist->resolution_hi = psci->resolution >> 32;
walklist->resolution_lo = XSyncValueLow32(psci->resolution); walklist->resolution_lo = psci->resolution;
namelen = strlen(psci->name); namelen = strlen(psci->name);
walklist->name_length = namelen; walklist->name_length = namelen;
@ -1391,14 +1383,14 @@ static int
ProcSyncCreateCounter(ClientPtr client) ProcSyncCreateCounter(ClientPtr client)
{ {
REQUEST(xSyncCreateCounterReq); REQUEST(xSyncCreateCounterReq);
CARD64 initial; int64_t initial;
REQUEST_SIZE_MATCH(xSyncCreateCounterReq); REQUEST_SIZE_MATCH(xSyncCreateCounterReq);
LEGAL_NEW_RESOURCE(stuff->cid, client); LEGAL_NEW_RESOURCE(stuff->cid, client);
XSyncIntsToValue(&initial, stuff->initial_value_lo, initial = ((int64_t)stuff->initial_value_hi << 32) | stuff->initial_value_lo;
stuff->initial_value_hi);
if (!SyncCreateCounter(client, stuff->cid, initial)) if (!SyncCreateCounter(client, stuff->cid, initial))
return BadAlloc; return BadAlloc;
@ -1413,7 +1405,7 @@ ProcSyncSetCounter(ClientPtr client)
{ {
REQUEST(xSyncSetCounterReq); REQUEST(xSyncSetCounterReq);
SyncCounter *pCounter; SyncCounter *pCounter;
CARD64 newvalue; int64_t newvalue;
int rc; int rc;
REQUEST_SIZE_MATCH(xSyncSetCounterReq); REQUEST_SIZE_MATCH(xSyncSetCounterReq);
@ -1428,7 +1420,7 @@ ProcSyncSetCounter(ClientPtr client)
return BadAccess; return BadAccess;
} }
XSyncIntsToValue(&newvalue, stuff->value_lo, stuff->value_hi); newvalue = ((int64_t)stuff->value_hi << 32) | stuff->value_lo;
SyncChangeCounter(pCounter, newvalue); SyncChangeCounter(pCounter, newvalue);
return Success; return Success;
} }
@ -1441,7 +1433,7 @@ ProcSyncChangeCounter(ClientPtr client)
{ {
REQUEST(xSyncChangeCounterReq); REQUEST(xSyncChangeCounterReq);
SyncCounter *pCounter; SyncCounter *pCounter;
CARD64 newvalue; int64_t newvalue;
Bool overflow; Bool overflow;
int rc; int rc;
@ -1457,8 +1449,8 @@ ProcSyncChangeCounter(ClientPtr client)
return BadAccess; return BadAccess;
} }
XSyncIntsToValue(&newvalue, stuff->value_lo, stuff->value_hi); newvalue = (int64_t)stuff->value_hi << 32 | stuff->value_lo;
XSyncValueAdd(&newvalue, pCounter->value, newvalue, &overflow); overflow = checked_int64_add(&newvalue, newvalue, pCounter->value);
if (overflow) { if (overflow) {
/* XXX 64 bit value can't fit in 32 bits; do the best we can */ /* XXX 64 bit value can't fit in 32 bits; do the best we can */
client->errorValue = stuff->value_hi; client->errorValue = stuff->value_hi;
@ -1529,7 +1521,7 @@ SyncAwaitEpilogue(ClientPtr client, int items, SyncAwaitUnion * pAwaitUnion)
pAwait = &(pAwaitUnion + 1)->await; /* skip over header */ pAwait = &(pAwaitUnion + 1)->await; /* skip over header */
for (i = 0; i < items; i++, pAwait++) { for (i = 0; i < items; i++, pAwait++) {
CARD64 value; int64_t value;
/* don't have to worry about NULL counters because the request /* don't have to worry about NULL counters because the request
* errors before we get here out if they occur * errors before we get here out if they occur
@ -1539,7 +1531,7 @@ SyncAwaitEpilogue(ClientPtr client, int items, SyncAwaitUnion * pAwaitUnion)
value = ((SyncCounter *) pAwait->trigger.pSync)->value; value = ((SyncCounter *) pAwait->trigger.pSync)->value;
break; break;
default: default:
XSyncIntToValue(&value, 0); value = 0;
} }
if ((*pAwait->trigger.CheckTrigger) (&pAwait->trigger, value)) { if ((*pAwait->trigger.CheckTrigger) (&pAwait->trigger, value)) {
@ -1598,9 +1590,9 @@ ProcSyncAwait(ClientPtr client)
/* sanity checks are in SyncInitTrigger */ /* sanity checks are in SyncInitTrigger */
pAwait->trigger.pSync = NULL; pAwait->trigger.pSync = NULL;
pAwait->trigger.value_type = pProtocolWaitConds->value_type; pAwait->trigger.value_type = pProtocolWaitConds->value_type;
XSyncIntsToValue(&pAwait->trigger.wait_value, pAwait->trigger.wait_value =
pProtocolWaitConds->wait_value_lo, ((int64_t)pProtocolWaitConds->wait_value_hi << 32) |
pProtocolWaitConds->wait_value_hi); pProtocolWaitConds->wait_value_lo;
pAwait->trigger.test_type = pProtocolWaitConds->test_type; pAwait->trigger.test_type = pProtocolWaitConds->test_type;
status = SyncInitTrigger(client, &pAwait->trigger, status = SyncInitTrigger(client, &pAwait->trigger,
@ -1616,9 +1608,10 @@ ProcSyncAwait(ClientPtr client)
/* this is not a mistake -- same function works for both cases */ /* this is not a mistake -- same function works for both cases */
pAwait->trigger.TriggerFired = SyncAwaitTriggerFired; pAwait->trigger.TriggerFired = SyncAwaitTriggerFired;
pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired; pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired;
XSyncIntsToValue(&pAwait->event_threshold, pAwait->event_threshold =
pProtocolWaitConds->event_threshold_lo, ((int64_t) pProtocolWaitConds->event_threshold_hi << 32) |
pProtocolWaitConds->event_threshold_hi); pProtocolWaitConds->event_threshold_lo;
pAwait->pHeader = &pAwaitUnion->header; pAwait->pHeader = &pAwaitUnion->header;
pAwaitUnion->header.num_waitconditions++; pAwaitUnion->header.num_waitconditions++;
} }
@ -1656,8 +1649,8 @@ ProcSyncQueryCounter(ClientPtr client)
.type = X_Reply, .type = X_Reply,
.sequenceNumber = client->sequence, .sequenceNumber = client->sequence,
.length = 0, .length = 0,
.value_hi = XSyncValueHigh32(pCounter->value), .value_hi = pCounter->value >> 32,
.value_lo = XSyncValueLow32(pCounter->value) .value_lo = pCounter->value
}; };
if (client->swapped) { if (client->swapped) {
@ -1701,7 +1694,7 @@ ProcSyncCreateAlarm(ClientPtr client)
pTrigger = &pAlarm->trigger; pTrigger = &pAlarm->trigger;
pTrigger->pSync = NULL; pTrigger->pSync = NULL;
pTrigger->value_type = XSyncAbsolute; pTrigger->value_type = XSyncAbsolute;
XSyncIntToValue(&pTrigger->wait_value, 0L); pTrigger->wait_value = 0;
pTrigger->test_type = XSyncPositiveComparison; pTrigger->test_type = XSyncPositiveComparison;
pTrigger->TriggerFired = SyncAlarmTriggerFired; pTrigger->TriggerFired = SyncAlarmTriggerFired;
pTrigger->CounterDestroyed = SyncAlarmCounterDestroyed; pTrigger->CounterDestroyed = SyncAlarmCounterDestroyed;
@ -1714,7 +1707,7 @@ ProcSyncCreateAlarm(ClientPtr client)
pAlarm->client = client; pAlarm->client = client;
pAlarm->alarm_id = stuff->id; pAlarm->alarm_id = stuff->id;
XSyncIntToValue(&pAlarm->delta, 1L); pAlarm->delta = 1;
pAlarm->events = TRUE; pAlarm->events = TRUE;
pAlarm->state = XSyncAlarmInactive; pAlarm->state = XSyncAlarmInactive;
pAlarm->pEventClients = NULL; pAlarm->pEventClients = NULL;
@ -1826,17 +1819,17 @@ ProcSyncQueryAlarm(ClientPtr client)
* on. * on.
*/ */
.value_type = pTrigger->value_type, .value_type = pTrigger->value_type,
.wait_value_hi = XSyncValueHigh32(pTrigger->wait_value), .wait_value_hi = pTrigger->wait_value >> 32,
.wait_value_lo = XSyncValueLow32(pTrigger->wait_value), .wait_value_lo = pTrigger->wait_value,
#else #else
.value_type = XSyncAbsolute, .value_type = XSyncAbsolute,
.wait_value_hi = XSyncValueHigh32(pTrigger->test_value), .wait_value_hi = pTrigger->test_value >> 32,
.wait_value_lo = XSyncValueLow32(pTrigger->test_value), .wait_value_lo = pTrigger->test_value,
#endif #endif
.test_type = pTrigger->test_type, .test_type = pTrigger->test_type,
.delta_hi = XSyncValueHigh32(pAlarm->delta), .delta_hi = pAlarm->delta >> 32,
.delta_lo = XSyncValueLow32(pAlarm->delta), .delta_lo = pAlarm->delta,
.events = pAlarm->events, .events = pAlarm->events,
.state = pAlarm->state .state = pAlarm->state
}; };
@ -2067,7 +2060,7 @@ ProcSyncAwaitFence(ClientPtr client)
* satisfy SyncInitTrigger's validation logic * satisfy SyncInitTrigger's validation logic
*/ */
pAwait->trigger.value_type = XSyncAbsolute; pAwait->trigger.value_type = XSyncAbsolute;
XSyncIntToValue(&pAwait->trigger.wait_value, 0); pAwait->trigger.wait_value = 0;
pAwait->trigger.test_type = 0; pAwait->trigger.test_type = 0;
status = SyncInitTrigger(client, &pAwait->trigger, status = SyncInitTrigger(client, &pAwait->trigger,
@ -2083,7 +2076,7 @@ ProcSyncAwaitFence(ClientPtr client)
pAwait->trigger.TriggerFired = SyncAwaitTriggerFired; pAwait->trigger.TriggerFired = SyncAwaitTriggerFired;
pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired; pAwait->trigger.CounterDestroyed = SyncAwaitTriggerFired;
/* event_threshold is unused for fence syncs */ /* event_threshold is unused for fence syncs */
XSyncIntToValue(&pAwait->event_threshold, 0); pAwait->event_threshold = 0;
pAwait->pHeader = &pAwaitUnion->header; pAwait->pHeader = &pAwaitUnion->header;
pAwaitUnion->header.num_waitconditions++; pAwaitUnion->header.num_waitconditions++;
} }
@ -2541,15 +2534,18 @@ SyncExtensionInit(void)
*/ */
static void *ServertimeCounter; static void *ServertimeCounter;
static XSyncValue Now; static int64_t Now;
static XSyncValue *pnext_time; static int64_t *pnext_time;
#define GetTime()\ static void GetTime(void)
{\ {
unsigned long millis = GetTimeInMillis();\ unsigned long millis = GetTimeInMillis();
unsigned long maxis = XSyncValueHigh32(Now);\ unsigned long maxis = Now >> 32;
if (millis < XSyncValueLow32(Now)) maxis++;\
XSyncIntsToValue(&Now, millis, maxis);\ if (millis < (Now & 0xffffffff))
maxis++;
Now = ((int64_t)maxis << 32) | millis;
} }
/* /*
@ -2559,21 +2555,16 @@ static XSyncValue *pnext_time;
/*ARGSUSED*/ static void /*ARGSUSED*/ static void
ServertimeBlockHandler(void *env, void *wt) ServertimeBlockHandler(void *env, void *wt)
{ {
XSyncValue delay;
unsigned long timeout; unsigned long timeout;
if (pnext_time) { if (pnext_time) {
GetTime(); GetTime();
if (XSyncValueGreaterOrEqual(Now, *pnext_time)) { if (Now >= *pnext_time) {
timeout = 0; timeout = 0;
} }
else { else {
Bool overflow; timeout = *pnext_time - Now;
XSyncValueSubtract(&delay, *pnext_time, Now, &overflow);
(void) overflow;
timeout = XSyncValueLow32(delay);
} }
AdjustWaitForDelay(wt, timeout); /* os/utils.c */ AdjustWaitForDelay(wt, timeout); /* os/utils.c */
} }
@ -2588,22 +2579,22 @@ ServertimeWakeupHandler(void *env, int rc)
if (pnext_time) { if (pnext_time) {
GetTime(); GetTime();
if (XSyncValueGreaterOrEqual(Now, *pnext_time)) { if (Now >= *pnext_time) {
SyncChangeCounter(ServertimeCounter, Now); SyncChangeCounter(ServertimeCounter, Now);
} }
} }
} }
static void static void
ServertimeQueryValue(void *pCounter, CARD64 * pValue_return) ServertimeQueryValue(void *pCounter, int64_t *pValue_return)
{ {
GetTime(); GetTime();
*pValue_return = Now; *pValue_return = Now;
} }
static void static void
ServertimeBracketValues(void *pCounter, CARD64 * pbracket_less, ServertimeBracketValues(void *pCounter, int64_t *pbracket_less,
CARD64 * pbracket_greater) int64_t *pbracket_greater)
{ {
if (!pnext_time && pbracket_greater) { if (!pnext_time && pbracket_greater) {
RegisterBlockAndWakeupHandlers(ServertimeBlockHandler, RegisterBlockAndWakeupHandlers(ServertimeBlockHandler,
@ -2619,10 +2610,9 @@ ServertimeBracketValues(void *pCounter, CARD64 * pbracket_less,
static void static void
SyncInitServerTime(void) SyncInitServerTime(void)
{ {
CARD64 resolution; int64_t resolution = 4;
XSyncIntsToValue(&Now, GetTimeInMillis(), 0); Now = GetTimeInMillis();
XSyncIntToValue(&resolution, 4);
ServertimeCounter = SyncCreateSystemCounter("SERVERTIME", Now, resolution, ServertimeCounter = SyncCreateSystemCounter("SERVERTIME", Now, resolution,
XSyncCounterNeverDecreases, XSyncCounterNeverDecreases,
ServertimeQueryValue, ServertimeQueryValue,
@ -2635,13 +2625,13 @@ SyncInitServerTime(void)
*/ */
typedef struct { typedef struct {
XSyncValue *value_less; int64_t *value_less;
XSyncValue *value_greater; int64_t *value_greater;
int deviceid; int deviceid;
} IdleCounterPriv; } IdleCounterPriv;
static void static void
IdleTimeQueryValue(void *pCounter, CARD64 * pValue_return) IdleTimeQueryValue(void *pCounter, int64_t *pValue_return)
{ {
int deviceid; int deviceid;
CARD32 idle; CARD32 idle;
@ -2654,7 +2644,7 @@ IdleTimeQueryValue(void *pCounter, CARD64 * pValue_return)
else else
deviceid = XIAllDevices; deviceid = XIAllDevices;
idle = GetTimeInMillis() - LastEventTime(deviceid).milliseconds; idle = GetTimeInMillis() - LastEventTime(deviceid).milliseconds;
XSyncIntsToValue(pValue_return, idle, 0); *pValue_return = idle;
} }
static void static void
@ -2662,9 +2652,9 @@ IdleTimeBlockHandler(void *pCounter, void *wt)
{ {
SyncCounter *counter = pCounter; SyncCounter *counter = pCounter;
IdleCounterPriv *priv = SysCounterGetPrivate(counter); IdleCounterPriv *priv = SysCounterGetPrivate(counter);
XSyncValue *less = priv->value_less, int64_t *less = priv->value_less;
*greater = priv->value_greater; int64_t *greater = priv->value_greater;
XSyncValue idle, old_idle; int64_t idle, old_idle;
SyncTriggerList *list = counter->sync.pTriglist; SyncTriggerList *list = counter->sync.pTriglist;
SyncTrigger *trig; SyncTrigger *trig;
@ -2681,10 +2671,10 @@ IdleTimeBlockHandler(void *pCounter, void *wt)
* may be past the lower bracket if we dawdled with the events, so * may be past the lower bracket if we dawdled with the events, so
* check for whether we did reset and bomb out of select immediately. * check for whether we did reset and bomb out of select immediately.
*/ */
if (less && XSyncValueGreaterThan(idle, *less) && if (less && idle > *less &&
LastEventTimeWasReset(priv->deviceid)) { LastEventTimeWasReset(priv->deviceid)) {
AdjustWaitForDelay(wt, 0); AdjustWaitForDelay(wt, 0);
} else if (less && XSyncValueLessOrEqual(idle, *less)) { } else if (less && idle <= *less) {
/* /*
* We've been idle for less than the threshold value, and someone * 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 * wants to know about that, but now we need to know whether they
@ -2706,7 +2696,7 @@ IdleTimeBlockHandler(void *pCounter, void *wt)
* idle time greater than this. Schedule a wakeup for the next * idle time greater than this. Schedule a wakeup for the next
* millisecond so we won't miss a transition. * millisecond so we won't miss a transition.
*/ */
if (XSyncValueEqual(idle, *less)) if (idle == *less)
AdjustWaitForDelay(wt, 1); AdjustWaitForDelay(wt, 1);
} }
else if (greater) { else if (greater) {
@ -2717,12 +2707,8 @@ IdleTimeBlockHandler(void *pCounter, void *wt)
* that level-triggered, schedule an immediate wakeup. * that level-triggered, schedule an immediate wakeup.
*/ */
if (XSyncValueLessThan(idle, *greater)) { if (idle < *greater) {
XSyncValue value; AdjustWaitForDelay(wt, *greater - idle);
Bool overflow;
XSyncValueSubtract(&value, *greater, idle, &overflow);
AdjustWaitForDelay(wt, XSyncValueLow32(value));
} }
else { else {
for (list = counter->sync.pTriglist; list; for (list = counter->sync.pTriglist; list;
@ -2740,10 +2726,11 @@ IdleTimeBlockHandler(void *pCounter, void *wt)
} }
static void static void
IdleTimeCheckBrackets(SyncCounter *counter, XSyncValue idle, XSyncValue *less, XSyncValue *greater) IdleTimeCheckBrackets(SyncCounter *counter, int64_t idle,
int64_t *less, int64_t *greater)
{ {
if ((greater && XSyncValueGreaterOrEqual(idle, *greater)) || if ((greater && idle >= *greater) ||
(less && XSyncValueLessOrEqual(idle, *less))) { (less && idle <= *less)) {
SyncChangeCounter(counter, idle); SyncChangeCounter(counter, idle);
} }
else else
@ -2755,9 +2742,9 @@ IdleTimeWakeupHandler(void *pCounter, int rc)
{ {
SyncCounter *counter = pCounter; SyncCounter *counter = pCounter;
IdleCounterPriv *priv = SysCounterGetPrivate(counter); IdleCounterPriv *priv = SysCounterGetPrivate(counter);
XSyncValue *less = priv->value_less, int64_t *less = priv->value_less;
*greater = priv->value_greater; int64_t *greater = priv->value_greater;
XSyncValue idle; int64_t idle;
if (!less && !greater) if (!less && !greater)
return; return;
@ -2772,10 +2759,8 @@ IdleTimeWakeupHandler(void *pCounter, int rc)
*/ */
if (LastEventTimeWasReset(priv->deviceid)) { if (LastEventTimeWasReset(priv->deviceid)) {
LastEventTimeToggleResetFlag(priv->deviceid, FALSE); LastEventTimeToggleResetFlag(priv->deviceid, FALSE);
if (!XSyncValueIsZero(idle)) { if (idle != 0) {
XSyncValue zero; IdleTimeCheckBrackets(counter, 0, less, greater);
XSyncIntsToValue(&zero, 0, 0);
IdleTimeCheckBrackets(counter, zero, less, greater);
less = priv->value_less; less = priv->value_less;
greater = priv->value_greater; greater = priv->value_greater;
} }
@ -2785,13 +2770,13 @@ IdleTimeWakeupHandler(void *pCounter, int rc)
} }
static void static void
IdleTimeBracketValues(void *pCounter, CARD64 * pbracket_less, IdleTimeBracketValues(void *pCounter, int64_t *pbracket_less,
CARD64 * pbracket_greater) int64_t *pbracket_greater)
{ {
SyncCounter *counter = pCounter; SyncCounter *counter = pCounter;
IdleCounterPriv *priv = SysCounterGetPrivate(counter); IdleCounterPriv *priv = SysCounterGetPrivate(counter);
XSyncValue *less = priv->value_less, int64_t *less = priv->value_less;
*greater = priv->value_greater; int64_t *greater = priv->value_greater;
Bool registered = (less || greater); Bool registered = (less || greater);
if (registered && !pbracket_less && !pbracket_greater) { if (registered && !pbracket_less && !pbracket_greater) {
@ -2813,12 +2798,11 @@ IdleTimeBracketValues(void *pCounter, CARD64 * pbracket_less,
static SyncCounter* static SyncCounter*
init_system_idle_counter(const char *name, int deviceid) init_system_idle_counter(const char *name, int deviceid)
{ {
CARD64 resolution; int64_t resolution = 4;
XSyncValue idle; int64_t idle;
SyncCounter *idle_time_counter; SyncCounter *idle_time_counter;
IdleTimeQueryValue(NULL, &idle); IdleTimeQueryValue(NULL, &idle);
XSyncIntToValue(&resolution, 4);
idle_time_counter = SyncCreateSystemCounter(name, idle, resolution, idle_time_counter = SyncCreateSystemCounter(name, idle, resolution,
XSyncCounterUnrestricted, XSyncCounterUnrestricted,

23
Xext/syncsrv.h
View File

@ -67,19 +67,19 @@ typedef enum {
} SyncCounterType; } SyncCounterType;
typedef void (*SyncSystemCounterQueryValue)(void *counter, typedef void (*SyncSystemCounterQueryValue)(void *counter,
CARD64 *value_return int64_t *value_return
); );
typedef void (*SyncSystemCounterBracketValues)(void *counter, typedef void (*SyncSystemCounterBracketValues)(void *counter,
CARD64 *pbracket_less, int64_t *pbracket_less,
CARD64 *pbracket_greater int64_t *pbracket_greater
); );
typedef struct _SysCounterInfo { typedef struct _SysCounterInfo {
SyncCounter *pCounter; SyncCounter *pCounter;
char *name; char *name;
CARD64 resolution; int64_t resolution;
CARD64 bracket_greater; int64_t bracket_greater;
CARD64 bracket_less; int64_t bracket_less;
SyncCounterType counterType; /* how can this counter change */ SyncCounterType counterType; /* how can this counter change */
SyncSystemCounterQueryValue QueryValue; SyncSystemCounterQueryValue QueryValue;
SyncSystemCounterBracketValues BracketValues; SyncSystemCounterBracketValues BracketValues;
@ -97,7 +97,7 @@ typedef struct _SyncAlarm {
SyncTrigger trigger; SyncTrigger trigger;
ClientPtr client; ClientPtr client;
XSyncAlarm alarm_id; XSyncAlarm alarm_id;
CARD64 delta; int64_t delta;
int events; int events;
int state; int state;
SyncAlarmClientList *pEventClients; SyncAlarmClientList *pEventClients;
@ -111,7 +111,7 @@ typedef struct {
typedef struct { typedef struct {
SyncTrigger trigger; SyncTrigger trigger;
CARD64 event_threshold; int64_t event_threshold;
SyncAwaitHeader *pHeader; SyncAwaitHeader *pHeader;
} SyncAwait; } SyncAwait;
@ -121,16 +121,15 @@ typedef union {
} SyncAwaitUnion; } SyncAwaitUnion;
extern SyncCounter* SyncCreateSystemCounter(const char *name, extern SyncCounter* SyncCreateSystemCounter(const char *name,
CARD64 initial_value, int64_t initial_value,
CARD64 resolution, int64_t resolution,
SyncCounterType counterType, SyncCounterType counterType,
SyncSystemCounterQueryValue QueryValue, SyncSystemCounterQueryValue QueryValue,
SyncSystemCounterBracketValues BracketValues SyncSystemCounterBracketValues BracketValues
); );
extern void SyncChangeCounter(SyncCounter *pCounter, extern void SyncChangeCounter(SyncCounter *pCounter,
CARD64 new_value int64_t new_value);
);
extern void SyncDestroySystemCounter(void *pCounter); extern void SyncDestroySystemCounter(void *pCounter);

29
include/misc.h
View File

@ -324,6 +324,35 @@ bswap_32(uint32_t x)
((x & 0x000000FF) << 24)); ((x & 0x000000FF) << 24));
} }
static inline Bool
checked_int64_add(int64_t *out, int64_t a, int64_t b)
{
/* Do the potentially overflowing math as uint64_t, as signed
* integers in C are undefined on overflow (and the compiler may
* optimize out our overflow check below, otherwise)
*/
int64_t result = (uint64_t)a + (uint64_t)b;
/* signed addition overflows if operands have the same sign, and
* the sign of the result doesn't match the sign of the inputs.
*/
Bool overflow = (a < 0) == (b < 0) && (a < 0) != (result < 0);
*out = result;
return overflow;
}
static inline Bool
checked_int64_subtract(int64_t *out, int64_t a, int64_t b)
{
int64_t result = (uint64_t)a - (uint64_t)b;
Bool overflow = (a < 0) != (b < 0) && (a < 0) != (result < 0);
*out = result;
return overflow;
}
#define swapl(x) do { \ #define swapl(x) do { \
if (sizeof(*(x)) != 4) \ if (sizeof(*(x)) != 4) \
wrong_size(); \ wrong_size(); \

5
miext/sync/misync.c
View File

@ -127,16 +127,13 @@ void
miSyncTriggerFence(SyncFence * pFence) miSyncTriggerFence(SyncFence * pFence)
{ {
SyncTriggerList *ptl, *pNext; SyncTriggerList *ptl, *pNext;
CARD64 unused;
pFence->funcs.SetTriggered(pFence); pFence->funcs.SetTriggered(pFence);
XSyncIntToValue(&unused, 0L);
/* run through triggers to see if any fired */ /* run through triggers to see if any fired */
for (ptl = pFence->sync.pTriglist; ptl; ptl = pNext) { for (ptl = pFence->sync.pTriglist; ptl; ptl = pNext) {
pNext = ptl->next; pNext = ptl->next;
if ((*ptl->pTrigger->CheckTrigger) (ptl->pTrigger, unused)) if ((*ptl->pTrigger->CheckTrigger) (ptl->pTrigger, 0))
(*ptl->pTrigger->TriggerFired) (ptl->pTrigger); (*ptl->pTrigger->TriggerFired) (ptl->pTrigger);
} }
} }

11
miext/sync/misyncstr.h
View File

@ -28,13 +28,12 @@
#ifndef _MISYNCSTR_H_ #ifndef _MISYNCSTR_H_
#define _MISYNCSTR_H_ #define _MISYNCSTR_H_
#include <stdint.h>
#include "dix.h" #include "dix.h"
#include "misync.h" #include "misync.h"
#include "scrnintstr.h" #include "scrnintstr.h"
#include <X11/extensions/syncconst.h> #include <X11/extensions/syncconst.h>
#define CARD64 XSyncValue /* XXX temporary! need real 64 bit values for Alpha */
/* Sync object types */ /* Sync object types */
#define SYNC_COUNTER 0 #define SYNC_COUNTER 0
#define SYNC_FENCE 1 #define SYNC_FENCE 1
@ -49,7 +48,7 @@ typedef struct _SyncObject {
typedef struct _SyncCounter { typedef struct _SyncCounter {
SyncObject sync; /* Common sync object data */ SyncObject sync; /* Common sync object data */
CARD64 value; /* counter value */ int64_t value; /* counter value */
struct _SysCounterInfo *pSysCounterInfo; /* NULL if not a system counter */ struct _SysCounterInfo *pSysCounterInfo; /* NULL if not a system counter */
} SyncCounter; } SyncCounter;
@ -63,12 +62,12 @@ struct _SyncFence {
struct _SyncTrigger { struct _SyncTrigger {
SyncObject *pSync; SyncObject *pSync;
CARD64 wait_value; /* wait value */ int64_t wait_value; /* wait value */
unsigned int value_type; /* Absolute or Relative */ unsigned int value_type; /* Absolute or Relative */
unsigned int test_type; /* transition or Comparision type */ unsigned int test_type; /* transition or Comparision type */
CARD64 test_value; /* trigger event threshold value */ int64_t test_value; /* trigger event threshold value */
Bool (*CheckTrigger) (struct _SyncTrigger * /*pTrigger */ , Bool (*CheckTrigger) (struct _SyncTrigger * /*pTrigger */ ,
CARD64 /*newval */ int64_t /*newval */
); );
void (*TriggerFired) (struct _SyncTrigger * /*pTrigger */ void (*TriggerFired) (struct _SyncTrigger * /*pTrigger */
); );

2
present/present_fence.c
View File

@ -45,7 +45,7 @@ struct present_fence {
* SyncTrigger callbacks * SyncTrigger callbacks
*/ */
static Bool static Bool
present_fence_sync_check_trigger(SyncTrigger *trigger, XSyncValue oldval) present_fence_sync_check_trigger(SyncTrigger *trigger, int64_t oldval)
{ {
struct present_fence *present_fence = container_of(trigger, struct present_fence, trigger); struct present_fence *present_fence = container_of(trigger, struct present_fence, trigger);