aboutsummaryrefslogtreecommitdiff
path: root/libX11/src/xcb_io.c
diff options
context:
space:
mode:
authormarha <marha@users.sourceforge.net>2009-07-25 12:47:39 +0000
committermarha <marha@users.sourceforge.net>2009-07-25 12:47:39 +0000
commitcb897b8ffca0a68c017c2edfa523cb5ff0491962 (patch)
tree8b4e9e320258d5280ce454163c49363030626c1a /libX11/src/xcb_io.c
parent213d71f78d6f9e35b23c00e35f9919efc9670b1e (diff)
parentc87efef42f76c2ff0dcfad2842ab369beffd21de (diff)
downloadvcxsrv-cb897b8ffca0a68c017c2edfa523cb5ff0491962.tar.gz
vcxsrv-cb897b8ffca0a68c017c2edfa523cb5ff0491962.tar.bz2
vcxsrv-cb897b8ffca0a68c017c2edfa523cb5ff0491962.zip
svn merge file:///D:/svnrepos/vcxsrv/branches/released .
Diffstat (limited to 'libX11/src/xcb_io.c')
-rw-r--r--libX11/src/xcb_io.c300
1 files changed, 194 insertions, 106 deletions
diff --git a/libX11/src/xcb_io.c b/libX11/src/xcb_io.c
index c6a83a293..c702a2835 100644
--- a/libX11/src/xcb_io.c
+++ b/libX11/src/xcb_io.c
@@ -3,15 +3,54 @@
#include "Xlibint.h"
#include "locking.h"
+#include "Xprivate.h"
#include "Xxcbint.h"
#include <xcb/xcbext.h>
-#include <xcb/xcbxlib.h>
#include <assert.h>
+#include <inttypes.h>
+#include <stdint.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
+static void return_socket(void *closure)
+{
+ Display *dpy = closure;
+ LockDisplay(dpy);
+ _XSend(dpy, NULL, 0);
+ dpy->bufmax = dpy->buffer;
+ UnlockDisplay(dpy);
+}
+
+static void require_socket(Display *dpy)
+{
+ if(dpy->bufmax == dpy->buffer)
+ {
+ uint64_t sent;
+ int flags = 0;
+ /* if we don't own the event queue, we have to ask XCB
+ * to set our errors aside for us. */
+ if(dpy->xcb->event_owner != XlibOwnsEventQueue)
+ flags = XCB_REQUEST_CHECKED;
+ if(!xcb_take_socket(dpy->xcb->connection, return_socket, dpy,
+ flags, &sent))
+ _XIOError(dpy);
+ /* Xlib uses unsigned long for sequence numbers. XCB
+ * uses 64-bit internally, but currently exposes an
+ * unsigned int API. If these differ, Xlib cannot track
+ * the full 64-bit sequence number if 32-bit wrap
+ * happens while Xlib does not own the socket. A
+ * complete fix would be to make XCB's public API use
+ * 64-bit sequence numbers. */
+ assert(!(sizeof(unsigned long) > sizeof(unsigned int)
+ && dpy->xcb->event_owner == XlibOwnsEventQueue
+ && (sent - dpy->last_request_read >= (UINT64_C(1) << 32))));
+ dpy->xcb->last_flushed = dpy->request = sent;
+ dpy->bufmax = dpy->xcb->real_bufmax;
+ }
+}
+
/* Call internal connection callbacks for any fds that are currently
* ready to read. This function will not block unless one of the
* callbacks blocks.
@@ -31,7 +70,7 @@
*/
static void check_internal_connections(Display *dpy)
{
- struct _XConnectionInfo *ilist;
+ struct _XConnectionInfo *ilist;
fd_set r_mask;
struct timeval tv;
int result;
@@ -69,15 +108,6 @@ static void check_internal_connections(Display *dpy)
}
}
-static void condition_wait(Display *dpy, xcondition_t cv)
-{
- _XPutXCBBuffer(dpy);
- xcb_xlib_unlock(dpy->xcb->connection);
- ConditionWait(dpy, cv);
- xcb_xlib_lock(dpy->xcb->connection);
- _XGetXCBBuffer(dpy);
-}
-
static void call_handlers(Display *dpy, xcb_generic_reply_t *buf)
{
_XAsyncHandler *async, *next;
@@ -97,16 +127,37 @@ static xcb_generic_event_t * wait_or_poll_for_event(Display *dpy, int wait)
xcb_generic_event_t *event;
if(wait)
{
- UnlockDisplay(dpy);
- event = xcb_wait_for_event(c);
- LockDisplay(dpy);
+ if(dpy->xcb->event_waiter)
+ {
+ ConditionWait(dpy, dpy->xcb->event_notify);
+ event = xcb_poll_for_event(c);
+ }
+ else
+ {
+ dpy->xcb->event_waiter = 1;
+ UnlockDisplay(dpy);
+ event = xcb_wait_for_event(c);
+ LockDisplay(dpy);
+ dpy->xcb->event_waiter = 0;
+ ConditionBroadcast(dpy, dpy->xcb->event_notify);
+ }
}
else
event = xcb_poll_for_event(c);
return event;
}
-static void process_responses(Display *dpy, int wait_for_first_event, xcb_generic_error_t **current_error, unsigned int current_request)
+/* Widen a 32-bit sequence number into a native-word-size (unsigned long)
+ * sequence number. Treating the comparison as a 1 and shifting it avoids a
+ * conditional branch, and shifting by 16 twice avoids a compiler warning when
+ * sizeof(unsigned long) == 4. */
+static void widen(unsigned long *wide, unsigned int narrow)
+{
+ unsigned long new = (*wide & ~0xFFFFFFFFUL) | narrow;
+ *wide = new + ((unsigned long) (new < *wide) << 16 << 16);
+}
+
+static void process_responses(Display *dpy, int wait_for_first_event, xcb_generic_error_t **current_error, unsigned long current_request)
{
void *reply;
xcb_generic_event_t *event = dpy->xcb->next_event;
@@ -115,24 +166,42 @@ static void process_responses(Display *dpy, int wait_for_first_event, xcb_generi
if(!event && dpy->xcb->event_owner == XlibOwnsEventQueue)
event = wait_or_poll_for_event(dpy, wait_for_first_event);
+ require_socket(dpy);
+
while(1)
{
PendingRequest *req = dpy->xcb->pending_requests;
- assert(!(req && current_request && !XCB_SEQUENCE_COMPARE(req->sequence, <=, current_request)));
- if(event && (!req || XCB_SEQUENCE_COMPARE(event->full_sequence, <=, req->sequence)))
+ unsigned long event_sequence = dpy->last_request_read;
+ if(event)
+ widen(&event_sequence, event->full_sequence);
+ assert(!(req && current_request && !XLIB_SEQUENCE_COMPARE(req->sequence, <=, current_request)));
+ if(event && (!req || XLIB_SEQUENCE_COMPARE(event_sequence, <=, req->sequence)))
{
- dpy->last_request_read = event->full_sequence;
+ dpy->last_request_read = event_sequence;
if(event->response_type != X_Error)
{
+ /* GenericEvents may be > 32 bytes. In this
+ * case, the event struct is trailed by the
+ * additional bytes. the xcb_generic_event_t
+ * struct uses 4 bytes for internal numbering,
+ * so we need to shift the trailing data to be
+ * after the first 32 bytes. */
+ if (event->response_type == GenericEvent &&
+ ((xcb_ge_event_t*)event)->length)
+ {
+ memmove(&event->full_sequence,
+ &event[1],
+ ((xcb_ge_event_t*)event)->length * 4);
+ }
_XEnq(dpy, (xEvent *) event);
wait_for_first_event = 0;
}
- else if(current_error && event->full_sequence == current_request)
+ else if(current_error && event_sequence == current_request)
{
/* This can only occur when called from
* _XReply, which doesn't need a new event. */
*current_error = (xcb_generic_error_t *) event;
- event = 0;
+ event = NULL;
break;
}
else
@@ -140,22 +209,13 @@ static void process_responses(Display *dpy, int wait_for_first_event, xcb_generi
free(event);
event = wait_or_poll_for_event(dpy, wait_for_first_event);
}
- else if(req && req->waiters != -1)
+ else if(req && req->sequence == current_request)
{
- if(req->sequence == current_request)
- break;
- if(!current_request && !wait_for_first_event)
- break;
- dpy->xcb->next_event = event;
- req->waiters++;
- assert(req->waiters > 0);
- condition_wait(dpy, &req->condition);
- --req->waiters;
- event = dpy->xcb->next_event;
+ break;
}
else if(req && xcb_poll_for_reply(dpy->xcb->connection, req->sequence, &reply, &error))
{
- unsigned int sequence = req->sequence;
+ uint64_t sequence = req->sequence;
if(!reply)
{
dpy->xcb->pending_requests = req->next;
@@ -181,8 +241,7 @@ static void process_responses(Display *dpy, int wait_for_first_event, xcb_generi
if(xcb_connection_has_error(c))
_XIOError(dpy);
- assert_sequence_less(dpy->last_request_read, dpy->request);
- assert(!wait_for_first_event);
+ assert(XLIB_SEQUENCE_COMPARE(dpy->last_request_read, <=, dpy->request));
}
int _XEventsQueued(Display *dpy, int mode)
@@ -193,10 +252,10 @@ int _XEventsQueued(Display *dpy, int mode)
return 0;
if(mode == QueuedAfterFlush)
- _XSend(dpy, 0, 0);
+ _XSend(dpy, NULL, 0);
else
check_internal_connections(dpy);
- process_responses(dpy, 0, 0, 0);
+ process_responses(dpy, 0, NULL, 0);
return dpy->qlen;
}
@@ -207,11 +266,13 @@ void _XReadEvents(Display *dpy)
{
if(dpy->flags & XlibDisplayIOError)
return;
- _XSend(dpy, 0, 0);
+ _XSend(dpy, NULL, 0);
if(dpy->xcb->event_owner != XlibOwnsEventQueue)
return;
check_internal_connections(dpy);
- process_responses(dpy, 1, 0, 0);
+ do {
+ process_responses(dpy, 1, NULL, 0);
+ } while (dpy->qlen == 0);
}
/*
@@ -223,32 +284,61 @@ void _XReadEvents(Display *dpy)
*/
void _XSend(Display *dpy, const char *data, long size)
{
+ static const xReq dummy_request;
+ static char const pad[3];
+ struct iovec vec[3];
+ uint64_t requests;
+ _XExtension *ext;
xcb_connection_t *c = dpy->xcb->connection;
if(dpy->flags & XlibDisplayIOError)
return;
- assert(!dpy->xcb->request_extra);
- dpy->xcb->request_extra = data;
- dpy->xcb->request_extra_size = size;
+ if(dpy->bufptr == dpy->buffer && !size)
+ return;
- /* give dpy->buffer to XCB */
- _XPutXCBBuffer(dpy);
+ /* iff we asked XCB to set aside errors, we must pick those up
+ * eventually. iff there are async handlers, we may have just
+ * issued requests that will generate replies. in either case,
+ * we need to remember to check later. */
+ if(dpy->xcb->event_owner != XlibOwnsEventQueue || dpy->async_handlers)
+ {
+ uint64_t sequence;
+ for(sequence = dpy->xcb->last_flushed; sequence < dpy->request; ++sequence)
+ {
+ PendingRequest *req = malloc(sizeof(PendingRequest));
+ assert(req);
+ req->next = NULL;
+ req->sequence = sequence;
+ *dpy->xcb->pending_requests_tail = req;
+ dpy->xcb->pending_requests_tail = &req->next;
+ }
+ }
+ requests = dpy->request - dpy->xcb->last_flushed;
+ dpy->xcb->last_flushed = dpy->request;
- if(xcb_flush(c) <= 0)
- _XIOError(dpy);
+ vec[0].iov_base = dpy->buffer;
+ vec[0].iov_len = dpy->bufptr - dpy->buffer;
+ vec[1].iov_base = (caddr_t) data;
+ vec[1].iov_len = size;
+ vec[2].iov_base = (caddr_t) pad;
+ vec[2].iov_len = -size & 3;
+
+ for(ext = dpy->flushes; ext; ext = ext->next_flush)
+ {
+ int i;
+ for(i = 0; i < 3; ++i)
+ if(vec[i].iov_len)
+ ext->before_flush(dpy, &ext->codes, vec[i].iov_base, vec[i].iov_len);
+ }
- /* get a new dpy->buffer */
- _XGetXCBBuffer(dpy);
+ if(xcb_writev(c, vec, 3, requests) < 0)
+ _XIOError(dpy);
+ dpy->bufptr = dpy->buffer;
+ dpy->last_req = (char *) &dummy_request;
check_internal_connections(dpy);
- /* A straight port of XlibInt.c would call _XSetSeqSyncFunction
- * here. However that does no good: unlike traditional Xlib,
- * Xlib/XCB almost never calls _XFlush because _XPutXCBBuffer
- * automatically pushes requests down into XCB, so Xlib's buffer
- * is empty most of the time. Since setting a synchandler has no
- * effect until after UnlockDisplay returns, we may as well do
- * the check in _XUnlockDisplay. */
+ _XSetSeqSyncFunction(dpy);
}
/*
@@ -257,24 +347,29 @@ void _XSend(Display *dpy, const char *data, long size)
*/
void _XFlush(Display *dpy)
{
- _XSend(dpy, 0, 0);
+ require_socket(dpy);
+ _XSend(dpy, NULL, 0);
_XEventsQueued(dpy, QueuedAfterReading);
}
-static int
-_XIDHandler(Display *dpy)
+static const XID inval_id = ~0UL;
+
+int _XIDHandler(Display *dpy)
{
- XID next = xcb_generate_id(dpy->xcb->connection);
+ XID next;
+
+ if (dpy->xcb->next_xid != inval_id)
+ return 0;
+
+ next = xcb_generate_id(dpy->xcb->connection);
LockDisplay(dpy);
dpy->xcb->next_xid = next;
- if(dpy->flags & XlibDisplayPrivSync)
- {
- dpy->synchandler = dpy->savedsynchandler;
- dpy->flags &= ~XlibDisplayPrivSync;
- }
+#ifdef XTHREADS
+ if (dpy->lock)
+ (*dpy->lock->user_unlock_display)(dpy);
+#endif
UnlockDisplay(dpy);
- SyncHandle();
return 0;
}
@@ -282,14 +377,13 @@ _XIDHandler(Display *dpy)
XID _XAllocID(Display *dpy)
{
XID ret = dpy->xcb->next_xid;
- dpy->xcb->next_xid = 0;
-
- if(!(dpy->flags & XlibDisplayPrivSync))
- {
- dpy->savedsynchandler = dpy->synchandler;
- dpy->flags |= XlibDisplayPrivSync;
- }
- dpy->synchandler = _XIDHandler;
+ assert (ret != inval_id);
+#ifdef XTHREADS
+ if (dpy->lock)
+ (*dpy->lock->user_lock_display)(dpy);
+#endif
+ dpy->xcb->next_xid = inval_id;
+ _XSetPrivSyncFunction(dpy);
return ret;
}
@@ -297,10 +391,18 @@ XID _XAllocID(Display *dpy)
void _XAllocIDs(Display *dpy, XID *ids, int count)
{
int i;
- _XPutXCBBuffer(dpy);
+#ifdef XTHREADS
+ if (dpy->lock)
+ (*dpy->lock->user_lock_display)(dpy);
+ UnlockDisplay(dpy);
+#endif
for (i = 0; i < count; i++)
ids[i] = xcb_generate_id(dpy->xcb->connection);
- _XGetXCBBuffer(dpy);
+#ifdef XTHREADS
+ LockDisplay(dpy);
+ if (dpy->lock)
+ (*dpy->lock->user_unlock_display)(dpy);
+#endif
}
static void _XFreeReplyData(Display *dpy, Bool force)
@@ -308,22 +410,15 @@ static void _XFreeReplyData(Display *dpy, Bool force)
if(!force && dpy->xcb->reply_consumed < dpy->xcb->reply_length)
return;
free(dpy->xcb->reply_data);
- dpy->xcb->reply_data = 0;
+ dpy->xcb->reply_data = NULL;
}
static PendingRequest * insert_pending_request(Display *dpy)
{
PendingRequest **cur = &dpy->xcb->pending_requests;
- while(*cur && XCB_SEQUENCE_COMPARE((*cur)->sequence, <, dpy->request))
+ while(*cur && XLIB_SEQUENCE_COMPARE((*cur)->sequence, <, dpy->request))
cur = &((*cur)->next);
- if(*cur && (*cur)->sequence == dpy->request)
- {
- /* Replacing an existing PendingRequest should only happen once,
- when calling _XReply, and the replaced PendingRequest must
- not have a condition set. */
- assert((*cur)->waiters == -1);
- }
- else
+ if(!*cur || (*cur)->sequence != dpy->request)
{
PendingRequest *node = malloc(sizeof(PendingRequest));
assert(node);
@@ -333,8 +428,6 @@ static PendingRequest * insert_pending_request(Display *dpy)
dpy->xcb->pending_requests_tail = &(node->next);
*cur = node;
}
- (*cur)->waiters = 0;
- xcondition_init(&((*cur)->condition));
return *cur;
}
@@ -356,27 +449,15 @@ Status _XReply(Display *dpy, xReply *rep, int extra, Bool discard)
if(dpy->flags & XlibDisplayIOError)
return 0;
- /* Internals of UnlockDisplay done by hand here, so that we can
- insert_pending_request *after* we _XPutXCBBuffer, but before we
- unlock the display. */
- _XPutXCBBuffer(dpy);
+ _XSend(dpy, NULL, 0);
current = insert_pending_request(dpy);
- if(!dpy->lock || dpy->lock->locking_level == 0)
- xcb_xlib_unlock(dpy->xcb->connection);
- if(dpy->xcb->lock_fns.unlock_display)
- dpy->xcb->lock_fns.unlock_display(dpy);
+ /* FIXME: drop the Display lock while waiting?
+ * Complicates process_responses. */
reply = xcb_wait_for_reply(c, current->sequence, &error);
- LockDisplay(dpy);
check_internal_connections(dpy);
process_responses(dpy, 0, &error, current->sequence);
- if(current->waiters)
- { /* The ConditionBroadcast macro contains an if; braces needed here. */
- ConditionBroadcast(dpy, &current->condition);
- }
- --current->waiters;
-
if(error)
{
_XExtension *ext;
@@ -398,27 +479,34 @@ Status _XReply(Display *dpy, xReply *rep, int extra, Bool discard)
{
case X_LookupColor:
case X_AllocNamedColor:
+ free(error);
return 0;
}
break;
case BadFont:
- if(err->majorCode == X_QueryFont)
+ if(err->majorCode == X_QueryFont) {
+ free(error);
return 0;
+ }
break;
case BadAlloc:
case BadAccess:
+ free(error);
return 0;
}
- /*
+ /*
* we better see if there is an extension who may
* want to suppress the error.
*/
for(ext = dpy->ext_procs; ext; ext = ext->next)
- if(ext->error && ext->error(dpy, err, &ext->codes, &ret_code))
+ if(ext->error && ext->error(dpy, err, &ext->codes, &ret_code)) {
+ free(error);
return ret_code;
+ }
- _XError(dpy, (xError *) error);
+ _XError(dpy, err);
+ free(error);
return 0;
}
@@ -453,7 +541,7 @@ int _XRead(Display *dpy, char *data, long size)
assert(size >= 0);
if(size == 0)
return 0;
- assert(dpy->xcb->reply_data != 0);
+ assert(dpy->xcb->reply_data != NULL);
assert(dpy->xcb->reply_consumed + size <= dpy->xcb->reply_length);
memcpy(data, dpy->xcb->reply_data + dpy->xcb->reply_consumed, size);
dpy->xcb->reply_consumed += size;