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

Merge remote-tracking branch 'jeremyhu/master'

Browse Source
This commit is contained in:
Keith Packard 2011-10-24 18:12:23 -07:00
commit d9d3a01ffc
8 changed files with 545 additions and 201 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
configure.ac
View File

@ -87,6 +87,12 @@ XORG_PROG_RAWCPP
# easier overrides at build time.
XSERVER_CFLAGS='$(CWARNFLAGS)'
dnl Explicitly add -fno-strict-aliasing since this option should disappear
dnl from util-macros CWARNFLAGS
if test "x$GCC" = xyes ; then
XSERVER_CFLAGS="$XSERVER_CFLAGS -fno-strict-aliasing"
fi
dnl Check for dtrace program (needed to build Xserver dtrace probes)
dnl Also checks for <sys/sdt.h>, since some Linux distros have an
dnl ISDN trace program named dtrace

2
hw/xnest/Events.c
View File

@ -198,8 +198,6 @@ xnestCollectEvents(void)
case DestroyNotify:
if (xnestParentWindow != (Window) 0 &&
X.xdestroywindow.window == xnestParentWindow)
CloseWellKnownConnections();
OsCleanup(1);
exit (0);
break;

21
hw/xnest/Keyboard.c
View File

@ -114,11 +114,13 @@ xnestChangeKeyboardControl(DeviceIntPtr pDev, KeybdCtrl *ctrl)
int
xnestKeyboardProc(DeviceIntPtr pDev, int onoff)
{
XModifierKeymap *modifier_keymap;
KeySym *keymap;
int mapWidth;
int min_keycode, max_keycode;
KeySymsRec keySyms;
int i;
CARD8 modmap[MAP_LENGTH];
int i, j;
XKeyboardState values;
XkbDescPtr xkb;
int op, event, error, major, minor;
@ -130,7 +132,7 @@ xnestKeyboardProc(DeviceIntPtr pDev, int onoff)
#ifdef _XSERVER64
{
KeySym64 *keymap64;
int i, len;
int len;
keymap64 = XGetKeyboardMapping(xnestDisplay,
min_keycode,
max_keycode - min_keycode + 1,
@ -148,6 +150,16 @@ xnestKeyboardProc(DeviceIntPtr pDev, int onoff)
&mapWidth);
#endif
memset(modmap, 0, sizeof(modmap));
modifier_keymap = XGetModifierMapping(xnestDisplay);
for (j = 0; j < 8; j++)
for(i = 0; i < modifier_keymap->max_keypermod; i++) {
CARD8 keycode;
if ((keycode = modifier_keymap->modifiermap[j * modifier_keymap->max_keypermod + i]))
modmap[keycode] |= 1<<j;
}
XFreeModifiermap(modifier_keymap);
keySyms.minKeyCode = min_keycode;
keySyms.maxKeyCode = max_keycode;
keySyms.mapWidth = mapWidth;
@ -166,6 +178,11 @@ xnestKeyboardProc(DeviceIntPtr pDev, int onoff)
InitKeyboardDeviceStruct(pDev, NULL,
xnestBell, xnestChangeKeyboardControl);
XkbApplyMappingChange(pDev, &keySyms, keySyms.minKeyCode,
keySyms.maxKeyCode - keySyms.minKeyCode + 1,
modmap, serverClient);
XkbDDXChangeControls(pDev, xkb->ctrls, xkb->ctrls);
XkbFreeKeyboard(xkb, 0, False);
free(keymap);

2
hw/xquartz/darwin.c
View File

@ -621,7 +621,7 @@ void OsVendorInit(void)
char *lf;
char *home = getenv("HOME");
assert(home);
assert(0 < asprintf(&lf, "%s/Library/Logs/X11.%s.log", home, bundle_id_prefix));
assert(0 < asprintf(&lf, "%s/Library/Logs/%s.X11.log", home, bundle_id_prefix));
LogInit(lf, ".old");
free(lf);

139
hw/xquartz/xpr/appledri.c
View File

@ -2,7 +2,7 @@
Copyright 1998-1999 Precision Insight, Inc., Cedar Park, Texas.
Copyright 2000 VA Linux Systems, Inc.
Copyright (c) 2002, 2009 Apple Computer, Inc.
Copyright (c) 2002, 2009-2011 Apple Inc.
All Rights Reserved.
Permission is hereby granted, free of charge, to any person obtaining a
@ -102,6 +102,9 @@ ProcAppleDRIQueryVersion(
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swaps(&rep.majorVersion);
swaps(&rep.minorVersion);
swapl(&rep.patchVersion);
}
WriteToClient(client, sizeof(xAppleDRIQueryVersionReply), (char *)&rep);
return Success;
@ -133,6 +136,11 @@ ProcAppleDRIQueryDirectRenderingCapable(
if (!LocalClient(client))
rep.isCapable = 0;
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
}
WriteToClient(client,
sizeof(xAppleDRIQueryDirectRenderingCapableReply), (char *)&rep);
return Success;
@ -157,6 +165,13 @@ ProcAppleDRIAuthConnection(
ErrorF("Failed to authenticate %u\n", (unsigned int)stuff->magic);
rep.authenticated = 0;
}
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.authenticated); /* Yes, this is a CARD32 ... sigh */
}
WriteToClient(client, sizeof(xAppleDRIAuthConnectionReply), (char *)&rep);
return Success;
}
@ -216,6 +231,14 @@ ProcAppleDRICreateSurface(
rep.key_1 = key[1];
rep.uid = sid;
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.key_0);
swapl(&rep.key_1);
swapl(&rep.uid);
}
WriteToClient(client, sizeof(xAppleDRICreateSurfaceReply), (char *)&rep);
return Success;
}
@ -277,9 +300,8 @@ ProcAppleDRICreatePixmap(ClientPtr client)
rep.stringLength = strlen(path) + 1;
/* No need for swapping, because this only runs if LocalClient is true. */
rep.type = X_Reply;
rep.length = sizeof(rep) + rep.stringLength;
rep.length = bytes_to_int32(rep.stringLength);
rep.sequenceNumber = client->sequence;
rep.width = width;
rep.height = height;
@ -290,8 +312,19 @@ ProcAppleDRICreatePixmap(ClientPtr client)
if(sizeof(rep) != sz_xAppleDRICreatePixmapReply)
ErrorF("error sizeof(rep) is %zu\n", sizeof(rep));
WriteReplyToClient(client, sizeof(rep), &rep);
(void)WriteToClient(client, rep.stringLength, path);
if (client->swapped) {
swaps(&rep.sequenceNumber);
swapl(&rep.length);
swapl(&rep.stringLength);
swapl(&rep.width);
swapl(&rep.height);
swapl(&rep.pitch);
swapl(&rep.bpp);
swapl(&rep.size);
}
WriteToClient(client, sizeof(rep), &rep);
WriteToClient(client, rep.stringLength, path);
return Success;
}
@ -376,6 +409,77 @@ SProcAppleDRIQueryVersion(
return ProcAppleDRIQueryVersion(client);
}
static int
SProcAppleDRIQueryDirectRenderingCapable(
register ClientPtr client
)
{
REQUEST(xAppleDRIQueryDirectRenderingCapableReq);
swaps(&stuff->length);
swapl(&stuff->screen);
return ProcAppleDRIQueryDirectRenderingCapable(client);
}
static int
SProcAppleDRIAuthConnection(
register ClientPtr client
)
{
REQUEST(xAppleDRIAuthConnectionReq);
swaps(&stuff->length);
swapl(&stuff->screen);
swapl(&stuff->magic);
return ProcAppleDRIAuthConnection(client);
}
static int
SProcAppleDRICreateSurface(
register ClientPtr client
)
{
REQUEST(xAppleDRICreateSurfaceReq);
swaps(&stuff->length);
swapl(&stuff->screen);
swapl(&stuff->drawable);
swapl(&stuff->client_id);
return ProcAppleDRICreateSurface(client);
}
static int
SProcAppleDRIDestroySurface(
register ClientPtr client
)
{
REQUEST(xAppleDRIDestroySurfaceReq);
swaps(&stuff->length);
swapl(&stuff->screen);
swapl(&stuff->drawable);
return ProcAppleDRIDestroySurface(client);
}
static int
SProcAppleDRICreatePixmap(
register ClientPtr client
)
{
REQUEST(xAppleDRICreatePixmapReq);
swaps(&stuff->length);
swapl(&stuff->screen);
swapl(&stuff->drawable);
return ProcAppleDRICreatePixmap(client);
}
static int
SProcAppleDRIDestroyPixmap(
register ClientPtr client
)
{
REQUEST(xAppleDRIDestroyPixmapReq);
swaps(&stuff->length);
swapl(&stuff->drawable);
return ProcAppleDRIDestroyPixmap(client);
}
static int
SProcAppleDRIDispatch (
register ClientPtr client
@ -383,15 +487,30 @@ SProcAppleDRIDispatch (
{
REQUEST(xReq);
/* It is bound to be non-local when there is byte swapping */
if (!LocalClient(client))
return DRIErrorBase + AppleDRIClientNotLocal;
/* only local clients are allowed DRI access */
switch (stuff->data)
{
case X_AppleDRIQueryVersion:
return SProcAppleDRIQueryVersion(client);
case X_AppleDRIQueryDirectRenderingCapable:
return SProcAppleDRIQueryDirectRenderingCapable(client);
}
if (!LocalClient(client))
return DRIErrorBase + AppleDRIClientNotLocal;
switch (stuff->data)
{
case X_AppleDRIAuthConnection:
return SProcAppleDRIAuthConnection(client);
case X_AppleDRICreateSurface:
return SProcAppleDRICreateSurface(client);
case X_AppleDRIDestroySurface:
return SProcAppleDRIDestroySurface(client);
case X_AppleDRICreatePixmap:
return SProcAppleDRICreatePixmap(client);
case X_AppleDRIDestroyPixmap:
return SProcAppleDRIDestroyPixmap(client);
default:
return BadRequest;
}

48
hw/xquartz/xpr/appledristr.h
View File

@ -46,14 +46,16 @@ SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
#define APPLE_DRI_MINOR_VERSION 0
#define APPLE_DRI_PATCH_VERSION 0
typedef struct _AppleDRIQueryVersion {
typedef struct _AppleDRIQueryVersion
{
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRIQueryVersion */
CARD16 length B16;
} xAppleDRIQueryVersionReq;
#define sz_xAppleDRIQueryVersionReq 4
typedef struct {
typedef struct
{
BYTE type; /* X_Reply */
BOOL pad1;
CARD16 sequenceNumber B16;
@ -68,7 +70,8 @@ typedef struct {
} xAppleDRIQueryVersionReply;
#define sz_xAppleDRIQueryVersionReply 32
typedef struct _AppleDRIQueryDirectRenderingCapable {
typedef struct _AppleDRIQueryDirectRenderingCapable
{
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* X_DRIQueryDirectRenderingCapable */
CARD16 length B16;
@ -76,7 +79,8 @@ typedef struct _AppleDRIQueryDirectRenderingCapable {
} xAppleDRIQueryDirectRenderingCapableReq;
#define sz_xAppleDRIQueryDirectRenderingCapableReq 8
typedef struct {
typedef struct
{
BYTE type; /* X_Reply */
BOOL pad1;
CARD16 sequenceNumber B16;
@ -93,7 +97,8 @@ typedef struct {
} xAppleDRIQueryDirectRenderingCapableReply;
#define sz_xAppleDRIQueryDirectRenderingCapableReply 32
typedef struct _AppleDRIAuthConnection {
typedef struct _AppleDRIAuthConnection
{
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRICloseConnection */
CARD16 length B16;
@ -102,7 +107,8 @@ typedef struct _AppleDRIAuthConnection {
} xAppleDRIAuthConnectionReq;
#define sz_xAppleDRIAuthConnectionReq 12
typedef struct {
typedef struct
{
BYTE type;
BOOL pad1;
CARD16 sequenceNumber B16;
@ -116,7 +122,8 @@ typedef struct {
} xAppleDRIAuthConnectionReply;
#define zx_xAppleDRIAuthConnectionReply 32
typedef struct _AppleDRICreateSurface {
typedef struct _AppleDRICreateSurface
{
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRICreateSurface */
CARD16 length B16;
@ -126,7 +133,8 @@ typedef struct _AppleDRICreateSurface {
} xAppleDRICreateSurfaceReq;
#define sz_xAppleDRICreateSurfaceReq 16
typedef struct {
typedef struct
{
BYTE type; /* X_Reply */
BOOL pad1;
CARD16 sequenceNumber B16;
@ -140,7 +148,8 @@ typedef struct {
} xAppleDRICreateSurfaceReply;
#define sz_xAppleDRICreateSurfaceReply 32
typedef struct _AppleDRIDestroySurface {
typedef struct _AppleDRIDestroySurface
{
CARD8 reqType; /* always DRIReqCode */
CARD8 driReqType; /* always X_DRIDestroySurface */
CARD16 length B16;
@ -149,7 +158,8 @@ typedef struct _AppleDRIDestroySurface {
} xAppleDRIDestroySurfaceReq;
#define sz_xAppleDRIDestroySurfaceReq 12
typedef struct _AppleDRINotify {
typedef struct _AppleDRINotify
{
BYTE type; /* always eventBase + event type */
BYTE kind;
CARD16 sequenceNumber B16;
@ -164,7 +174,8 @@ typedef struct _AppleDRINotify {
#define sz_xAppleDRINotifyEvent 32
typedef struct {
typedef struct
{
CARD8 reqType;
CARD8 driReqType;
CARD16 length B16;
@ -176,7 +187,8 @@ typedef struct {
#define sz_xAppleDRICreateSharedBufferReq 16
typedef struct {
typedef struct
{
BYTE type;
BYTE data1;
CARD16 sequenceNumber B16;
@ -191,7 +203,8 @@ typedef struct {
#define sz_xAppleDRICreateSharedBufferReply 32
typedef struct {
typedef struct
{
CARD8 reqType;
CARD8 driReqType;
CARD16 length B16;
@ -201,7 +214,8 @@ typedef struct {
#define sz_xAppleDRISwapBuffersReq 12
typedef struct {
typedef struct
{
CARD8 reqType; /*1 */
CARD8 driReqType; /*2 */
CARD16 length B16; /*4 */
@ -211,7 +225,8 @@ typedef struct {
#define sz_xAppleDRICreatePixmapReq 12
typedef struct {
typedef struct
{
BYTE type; /*1 */
BOOL pad1; /*2 */
CARD16 sequenceNumber B16; /*4 */
@ -226,7 +241,8 @@ typedef struct {
#define sz_xAppleDRICreatePixmapReply 32
typedef struct {
typedef struct
{
CARD8 reqType; /*1 */
CARD8 driReqType; /*2 */
CARD16 length B16; /*4 */

178
mi/mieq.c
View File

@ -59,7 +59,12 @@ in this Software without prior written authorization from The Open Group.
# include <X11/extensions/dpmsconst.h>
#endif
#define QUEUE_SIZE 512
/* Maximum size should be initial size multiplied by a power of 2 */
#define QUEUE_INITIAL_SIZE 256
#define QUEUE_RESERVED_SIZE 64
#define QUEUE_MAXIMUM_SIZE 4096
#define QUEUE_DROP_BACKTRACE_FREQUENCY 100
#define QUEUE_DROP_BACKTRACE_MAX 10
#define EnqueueScreen(dev) dev->spriteInfo->sprite->pEnqueueScreen
#define DequeueScreen(dev) dev->spriteInfo->sprite->pDequeueScreen
@ -74,7 +79,9 @@ typedef struct _EventQueue {
HWEventQueueType head, tail; /* long for SetInputCheck */
CARD32 lastEventTime; /* to avoid time running backwards */
int lastMotion; /* device ID if last event motion? */
EventRec events[QUEUE_SIZE]; /* static allocation for signals */
EventRec *events; /* our queue as an array */
size_t nevents; /* the number of buckets in our queue */
size_t dropped; /* counter for number of consecutive dropped events */
mieqHandler handlers[128]; /* custom event handler */
} EventQueueRec, *EventQueuePtr;
@ -99,25 +106,87 @@ static inline void wait_for_server_init(void) {
}
#endif
static size_t
mieqNumEnqueued(EventQueuePtr eventQueue) {
size_t n_enqueued = 0;
if (eventQueue->nevents) {
/* % is not well-defined with negative numbers... sigh */
n_enqueued = eventQueue->tail - eventQueue->head + eventQueue->nevents;
if (n_enqueued >= eventQueue->nevents)
n_enqueued -= eventQueue->nevents;
}
return n_enqueued;
}
/* Pre-condition: Called with miEventQueueMutex held */
static Bool
mieqGrowQueue(EventQueuePtr eventQueue, size_t new_nevents) {
size_t i, n_enqueued, first_hunk;
EventRec *new_events;
if (!eventQueue) {
ErrorF("[mi] mieqGrowQueue called with a NULL eventQueue\n");
return FALSE;
}
if (new_nevents <= eventQueue->nevents)
return FALSE;
new_events = calloc(new_nevents, sizeof(EventRec));
if (new_events == NULL) {
ErrorF("[mi] mieqGrowQueue memory allocation error.\n");
return FALSE;
}
n_enqueued = mieqNumEnqueued(eventQueue);
/* We block signals, so an mieqEnqueue triggered by SIGIO does not
* write to our queue as we are modifying it.
*/
OsBlockSignals();
/* First copy the existing events */
first_hunk = eventQueue->nevents - eventQueue->head;
memcpy(new_events,
&eventQueue->events[eventQueue->head],
first_hunk * sizeof(EventRec));
memcpy(&new_events[first_hunk],
eventQueue->events,
eventQueue->head * sizeof(EventRec));
/* Initialize the new portion */
for (i = eventQueue->nevents; i < new_nevents; i++) {
InternalEvent* evlist = InitEventList(1);
if (!evlist) {
size_t j;
for (j = 0; j < i; j++)
FreeEventList(new_events[j].events, 1);
free(new_events);
OsReleaseSignals();
return FALSE;
}
new_events[i].events = evlist;
}
/* And update our record */
eventQueue->tail = n_enqueued;
eventQueue->head = 0;
eventQueue->nevents = new_nevents;
free(eventQueue->events);
eventQueue->events = new_events;
OsReleaseSignals();
return TRUE;
}
Bool
mieqInit(void)
{
int i;
miEventQueue.head = miEventQueue.tail = 0;
memset(&miEventQueue, 0, sizeof(miEventQueue));
miEventQueue.lastEventTime = GetTimeInMillis ();
miEventQueue.lastMotion = FALSE;
for (i = 0; i < 128; i++)
miEventQueue.handlers[i] = NULL;
for (i = 0; i < QUEUE_SIZE; i++)
{
if (miEventQueue.events[i].events == NULL) {
InternalEvent* evlist = InitEventList(1);
if (!evlist)
if(!mieqGrowQueue(&miEventQueue, QUEUE_INITIAL_SIZE))
FatalError("Could not allocate event queue.\n");
miEventQueue.events[i].events = evlist;
}
}
SetInputCheck(&miEventQueue.head, &miEventQueue.tail);
return TRUE;
@ -127,13 +196,34 @@ void
mieqFini(void)
{
int i;
for (i = 0; i < QUEUE_SIZE; i++)
for (i = 0; i < miEventQueue.nevents; i++)
{
if (miEventQueue.events[i].events != NULL) {
FreeEventList(miEventQueue.events[i].events, 1);
miEventQueue.events[i].events = NULL;
}
}
free(miEventQueue.events);
}
/* This function will determine if the given event is allowed to used the reserved
* queue space.
*/
static Bool
mieqReservedCandidate(InternalEvent *e) {
switch(e->any.type) {
case ET_KeyRelease:
case ET_ButtonRelease:
#if XFreeXDGA
case ET_DGAEvent:
#endif
case ET_RawKeyRelease:
case ET_RawButtonRelease:
case ET_XQuartz:
return TRUE;
default:
return FALSE;
}
}
/*
@ -151,6 +241,7 @@ mieqEnqueue(DeviceIntPtr pDev, InternalEvent *e)
int isMotion = 0;
int evlen;
Time time;
size_t n_enqueued;
#ifdef XQUARTZ
wait_for_server_init();
@ -159,33 +250,41 @@ mieqEnqueue(DeviceIntPtr pDev, InternalEvent *e)
verify_internal_event(e);
n_enqueued = mieqNumEnqueued(&miEventQueue);
/* avoid merging events from different devices */
if (e->any.type == ET_Motion)
isMotion = pDev->id;
if (isMotion && isMotion == miEventQueue.lastMotion &&
oldtail != miEventQueue.head) {
oldtail = (oldtail - 1) % QUEUE_SIZE;
}
else {
static int stuck = 0;
oldtail = (oldtail - 1) % miEventQueue.nevents;
} else if ((n_enqueued + 1 == miEventQueue.nevents) ||
((n_enqueued + 1 >= miEventQueue.nevents - QUEUE_RESERVED_SIZE) && !mieqReservedCandidate(e))) {
/* Toss events which come in late. Usually this means your server's
* stuck in an infinite loop somewhere, but SIGIO is still getting
* handled. */
if (((oldtail + 1) % QUEUE_SIZE) == miEventQueue.head) {
if (!stuck) {
ErrorF("[mi] EQ overflowing. The server is probably stuck "
"in an infinite loop.\n");
* handled.
*/
miEventQueue.dropped++;
if (miEventQueue.dropped == 1) {
ErrorF("[mi] EQ overflowing. Additional events will be discarded until existing events are processed.\n");
xorg_backtrace();
stuck = 1;
ErrorF("[mi] These backtraces from mieqEnqueue may point to a culprit higher up the stack.\n");
ErrorF("[mi] mieq is *NOT* the cause. It is a victim.\n");
} else if (miEventQueue.dropped % QUEUE_DROP_BACKTRACE_FREQUENCY == 0 &&
miEventQueue.dropped / QUEUE_DROP_BACKTRACE_FREQUENCY <= QUEUE_DROP_BACKTRACE_MAX) {
ErrorF("[mi] EQ overflow continuing. %lu events have been dropped.\n", miEventQueue.dropped);
if (miEventQueue.dropped / QUEUE_DROP_BACKTRACE_FREQUENCY == QUEUE_DROP_BACKTRACE_MAX) {
ErrorF("[mi] No further overflow reports will be reported until the clog is cleared.\n");
}
xorg_backtrace();
}
#ifdef XQUARTZ
pthread_mutex_unlock(&miEventQueueMutex);
#endif
return;
}
stuck = 0;
}
evlen = e->any.length;
evt = miEventQueue.events[oldtail].events;
@ -203,7 +302,7 @@ mieqEnqueue(DeviceIntPtr pDev, InternalEvent *e)
miEventQueue.events[oldtail].pDev = pDev;
miEventQueue.lastMotion = isMotion;
miEventQueue.tail = (oldtail + 1) % QUEUE_SIZE;
miEventQueue.tail = (oldtail + 1) % miEventQueue.nevents;
#ifdef XQUARTZ
pthread_mutex_unlock(&miEventQueueMutex);
#endif
@ -437,11 +536,28 @@ mieqProcessInputEvents(void)
static InternalEvent event;
DeviceIntPtr dev = NULL,
master = NULL;
size_t n_enqueued;
#ifdef XQUARTZ
pthread_mutex_lock(&miEventQueueMutex);
#endif
/* Grow our queue if we are reaching capacity: < 2 * QUEUE_RESERVED_SIZE remaining */
n_enqueued = mieqNumEnqueued(&miEventQueue);
if (n_enqueued >= (miEventQueue.nevents - (2 * QUEUE_RESERVED_SIZE)) &&
miEventQueue.nevents < QUEUE_MAXIMUM_SIZE) {
ErrorF("[mi] Increasing EQ size to %lu to prevent dropped events.\n", miEventQueue.nevents << 1);
if (!mieqGrowQueue(&miEventQueue, miEventQueue.nevents << 1)) {
ErrorF("[mi] Increasing the size of EQ failed.\n");
}
}
if (miEventQueue.dropped) {
ErrorF("[mi] EQ processing has resumed after %lu dropped events.\n", miEventQueue.dropped);
ErrorF("[mi] This may be caused my a misbehaving driver monopolizing the server's resources.\n");
miEventQueue.dropped = 0;
}
while (miEventQueue.head != miEventQueue.tail) {
e = &miEventQueue.events[miEventQueue.head];
@ -449,7 +565,7 @@ mieqProcessInputEvents(void)
dev = e->pDev;
screen = e->pScreen;
miEventQueue.head = (miEventQueue.head + 1) % QUEUE_SIZE;
miEventQueue.head = (miEventQueue.head + 1) % miEventQueue.nevents;
#ifdef XQUARTZ
pthread_mutex_unlock(&miEventQueueMutex);

84
test/input.c
View File

@ -40,6 +40,7 @@
#include "dixgrabs.h"
#include "eventstr.h"
#include "inpututils.h"
#include "mi.h"
#include "assert.h"
/**
@ -1480,8 +1481,6 @@ _test_double_fp16_values(double orig_d)
{
FP1616 first_fp16, final_fp16;
double final_d;
char first_fp16_s[64];
char final_fp16_s[64];
if (orig_d > 0x7FFF) {
printf("Test out of range\n");
@ -1492,10 +1491,15 @@ _test_double_fp16_values(double orig_d)
final_d = fp1616_to_double(first_fp16);
final_fp16 = double_to_fp1616(final_d);
snprintf(first_fp16_s, sizeof(first_fp16_s), "%d + %u * 2^-16", (first_fp16 & 0xffff0000) >> 16, first_fp16 & 0xffff);
snprintf(final_fp16_s, sizeof(final_fp16_s), "%d + %u * 2^-16", (final_fp16 & 0xffff0000) >> 16, final_fp16 & 0xffff);
printf("FP16: original double: %f first fp16: %s, re-encoded double: %f, final fp16: %s\n", orig_d, first_fp16_s, final_d, final_fp16_s);
/* {
* char first_fp16_s[64];
* char final_fp16_s[64];
* snprintf(first_fp16_s, sizeof(first_fp16_s), "%d + %u * 2^-16", (first_fp16 & 0xffff0000) >> 16, first_fp16 & 0xffff);
* snprintf(final_fp16_s, sizeof(final_fp16_s), "%d + %u * 2^-16", (final_fp16 & 0xffff0000) >> 16, final_fp16 & 0xffff);
*
* printf("FP16: original double: %f first fp16: %s, re-encoded double: %f, final fp16: %s\n", orig_d, first_fp16_s, final_d, final_fp16_s);
* }
*/
/* since we lose precision, we only do rough range testing */
assert(final_d > orig_d - 0.1);
@ -1603,6 +1607,73 @@ dix_double_fp_conversion(void)
}
}
/* The mieq test verifies that events added to the queue come out in the same
* order that they went in.
*/
static uint32_t mieq_test_event_last_processed;
static void
mieq_test_event_handler(int screenNum, InternalEvent *ie, DeviceIntPtr dev) {
RawDeviceEvent *e = (RawDeviceEvent *)ie;
assert(e->type == ET_RawMotion);
assert(e->flags > mieq_test_event_last_processed);
mieq_test_event_last_processed = e->flags;
}
static void _mieq_test_generate_events(uint32_t start, uint32_t count) {
count += start;
while (start < count) {
RawDeviceEvent e = {0};
e.header = ET_Internal;
e.type = ET_RawMotion;
e.length = sizeof(e);
e.time = GetTimeInMillis();
e.flags = start;
mieqEnqueue(NULL, (InternalEvent*)&e);
start++;
}
}
#define mieq_test_generate_events(c) { _mieq_test_generate_events(next, c); next += c; }
static void
mieq_test(void) {
uint32_t next = 1;
mieq_test_event_last_processed = 0;
mieqInit();
mieqSetHandler(ET_RawMotion, mieq_test_event_handler);
/* Enough to fit the buffer but trigger a grow */
mieq_test_generate_events(180);
/* We should resize to 512 now */
mieqProcessInputEvents();
/* Some should now get dropped */
mieq_test_generate_events(500);
/* Tell us how many got dropped, 1024 now */
mieqProcessInputEvents();
/* Now make it 2048 */
mieq_test_generate_events(900);
mieqProcessInputEvents();
/* Now make it 4096 (max) */
mieq_test_generate_events(1950);
mieqProcessInputEvents();
/* Now overflow one last time with the maximal queue and reach the verbosity limit */
mieq_test_generate_events(10000);
mieqProcessInputEvents();
mieqFini();
}
int main(int argc, char** argv)
{
dix_double_fp_conversion();
@ -1621,6 +1692,7 @@ int main(int argc, char** argv)
dix_valuator_alloc();
dix_get_master();
input_option_test();
mieq_test();
return 0;
}