#endif
struct event_list {
+ uint64_t sequence;
xcb_generic_event_t *event;
struct event_list *next;
};
} pending_reply;
typedef struct reader_list {
- unsigned int request;
+ uint64_t request;
pthread_cond_t *data;
struct reader_list *next;
} reader_list;
+static void remove_finished_readers(reader_list **prev_reader, uint64_t completed)
+{
+ while(*prev_reader && XCB_SEQUENCE_COMPARE((*prev_reader)->request, <=, completed))
+ {
+ /* If you don't have what you're looking for now, you never
+ * will. Wake up and leave me alone. */
+ pthread_cond_signal((*prev_reader)->data);
+ *prev_reader = (*prev_reader)->next;
+ }
+}
+
static int read_packet(xcb_connection_t *c)
{
xcb_generic_reply_t genrep;
c->in.current_reply = 0;
c->in.current_reply_tail = &c->in.current_reply;
}
- c->in.request_completed = c->in.request_read - 1;
+ c->in.request_completed = c->in.event_responses_completed = c->in.request_read - 1;
}
while(c->in.pending_replies &&
}
if(genrep.response_type == XCB_ERROR)
- c->in.request_completed = c->in.request_read;
+ c->in.request_completed = c->in.event_responses_completed = c->in.request_read;
+ else if(genrep.response_type == XCB_REPLY)
+ c->in.event_responses_completed = c->in.request_read;
+
+ remove_finished_readers(&c->in.readers, c->in.request_completed);
+ remove_finished_readers(&c->in.event_readers, c->in.event_responses_completed);
}
if(genrep.response_type == XCB_ERROR || genrep.response_type == XCB_REPLY)
if( genrep.response_type == XCB_REPLY ||
(genrep.response_type == XCB_ERROR && pend && (pend->flags & XCB_REQUEST_CHECKED)))
{
- reader_list *reader;
struct reply_list *cur = malloc(sizeof(struct reply_list));
if(!cur)
{
cur->next = 0;
*c->in.current_reply_tail = cur;
c->in.current_reply_tail = &cur->next;
- for(reader = c->in.readers;
- reader &&
- XCB_SEQUENCE_COMPARE_32(reader->request, <=, c->in.request_read);
- reader = reader->next)
- {
- if(XCB_SEQUENCE_COMPARE_32(reader->request, ==, c->in.request_read))
- {
- pthread_cond_signal(reader->data);
- break;
- }
- }
+ if(c->in.readers && c->in.readers->request == c->in.request_read)
+ pthread_cond_signal(c->in.readers->data);
return 1;
}
free(buf);
return 0;
}
+ event->sequence = c->in.request_read;
event->event = buf;
event->next = 0;
*c->in.events_tail = event;
c->in.events_tail = &event->next;
- pthread_cond_signal(&c->in.event_cond);
+ if(c->in.event_readers)
+ pthread_cond_signal(c->in.event_readers->data);
+ else
+ pthread_cond_signal(&c->in.event_cond);
return 1; /* I have something for you... */
}
return len;
}
-static int poll_for_reply(xcb_connection_t *c, unsigned int request, void **reply, xcb_generic_error_t **error)
+static int poll_for_reply(xcb_connection_t *c, uint64_t request, void **reply, xcb_generic_error_t **error)
{
struct reply_list *head;
head = 0;
/* We've read requests past the one we want, so if it has replies we have
* them all and they're in the replies map. */
- else if(XCB_SEQUENCE_COMPARE_32(request, <, c->in.request_read))
+ else if(XCB_SEQUENCE_COMPARE(request, <, c->in.request_read))
{
head = _xcb_map_remove(c->in.replies, request);
if(head && head->next)
}
/* We're currently processing the responses to the request we want, and we
* have a reply ready to return. So just return it without blocking. */
- else if(XCB_SEQUENCE_COMPARE_32(request, ==, c->in.request_read) && c->in.current_reply)
+ else if(request == c->in.request_read && c->in.current_reply)
{
head = c->in.current_reply;
c->in.current_reply = head->next;
}
/* We know this request can't have any more replies, and we've already
* established it doesn't have a reply now. Don't bother blocking. */
- else if(XCB_SEQUENCE_COMPARE_32(request, ==, c->in.request_completed))
+ else if(request == c->in.request_completed)
head = 0;
/* We may have more replies on the way for this request: block until we're
* sure. */
return 1;
}
-static void *wait_for_reply(xcb_connection_t *c, unsigned int request, xcb_generic_error_t **e)
+static void insert_reader(reader_list **prev_reader, reader_list *reader, uint64_t request, pthread_cond_t *cond)
+{
+ while(*prev_reader && XCB_SEQUENCE_COMPARE((*prev_reader)->request, <=, request))
+ prev_reader = &(*prev_reader)->next;
+ reader->request = request;
+ reader->data = cond;
+ reader->next = *prev_reader;
+ *prev_reader = reader;
+}
+
+static void remove_reader(reader_list **prev_reader, reader_list *reader)
+{
+ while(*prev_reader && XCB_SEQUENCE_COMPARE((*prev_reader)->request, <=, reader->request))
+ if(*prev_reader == reader)
+ {
+ *prev_reader = (*prev_reader)->next;
+ break;
+ }
+}
+
+static void *wait_for_reply(xcb_connection_t *c, uint64_t request, xcb_generic_error_t **e)
{
void *ret = 0;
- uint64_t widened_request = (c->out.request & UINT64_C(0xffffffff00000000)) | request;
- if(widened_request > c->out.request)
- widened_request -= UINT64_C(1) << 32;
/* If this request has not been written yet, write it. */
- if(c->out.return_socket || _xcb_out_flush_to(c, widened_request))
+ if(c->out.return_socket || _xcb_out_flush_to(c, request))
{
pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
reader_list reader;
- reader_list **prev_reader;
-
- for(prev_reader = &c->in.readers;
- *prev_reader &&
- XCB_SEQUENCE_COMPARE_32((*prev_reader)->request, <=, request);
- prev_reader = &(*prev_reader)->next)
- {
- /* empty */;
- }
- reader.request = request;
- reader.data = &cond;
- reader.next = *prev_reader;
- *prev_reader = &reader;
+
+ insert_reader(&c->in.readers, &reader, request, &cond);
while(!poll_for_reply(c, request, &ret, e))
if(!_xcb_conn_wait(c, &cond, 0, 0))
break;
- for(prev_reader = &c->in.readers;
- *prev_reader &&
- XCB_SEQUENCE_COMPARE_32((*prev_reader)->request, <=, request);
- prev_reader = &(*prev_reader)->next)
- {
- if(*prev_reader == &reader)
- {
- *prev_reader = (*prev_reader)->next;
- break;
- }
- }
+ remove_reader(&c->in.readers, &reader);
pthread_cond_destroy(&cond);
}
return ret;
}
+static uint64_t widen(xcb_connection_t *c, unsigned int request)
+{
+ uint64_t widened_request = (c->out.request & UINT64_C(0xffffffff00000000)) | request;
+ if(widened_request > c->out.request)
+ widened_request -= UINT64_C(1) << 32;
+ return widened_request;
+}
+
/* Public interface */
void *xcb_wait_for_reply(xcb_connection_t *c, unsigned int request, xcb_generic_error_t **e)
return 0;
pthread_mutex_lock(&c->iolock);
- ret = wait_for_reply(c, request, e);
+ ret = wait_for_reply(c, widen(c, request), e);
pthread_mutex_unlock(&c->iolock);
return ret;
}
c->in.pending_replies_tail = &pend->next;
}
-static void discard_reply(xcb_connection_t *c, unsigned int request)
+static void discard_reply(xcb_connection_t *c, uint64_t request)
{
- pending_reply *pend = 0;
+ void *reply;
pending_reply **prev_pend;
- uint64_t widened_request;
- /* We've read requests past the one we want, so if it has replies we have
- * them all and they're in the replies map. */
- if(XCB_SEQUENCE_COMPARE_32(request, <, c->in.request_read))
- {
- struct reply_list *head;
- head = _xcb_map_remove(c->in.replies, request);
- while (head)
- {
- struct reply_list *next = head->next;
- free(head->reply);
- free(head);
- head = next;
- }
- return;
- }
-
- /* We're currently processing the responses to the request we want, and we
- * have a reply ready to return. Free it, and mark the pend to free any further
- * replies. */
- if(XCB_SEQUENCE_COMPARE_32(request, ==, c->in.request_read) && c->in.current_reply)
- {
- struct reply_list *head;
- head = c->in.current_reply;
- c->in.current_reply = NULL;
- c->in.current_reply_tail = &c->in.current_reply;
- while (head)
- {
- struct reply_list *next = head->next;
- free(head->reply);
- free(head);
- head = next;
- }
-
- pend = c->in.pending_replies;
- if(pend &&
- !(XCB_SEQUENCE_COMPARE(pend->first_request, <=, c->in.request_read) &&
- (pend->workaround == WORKAROUND_EXTERNAL_SOCKET_OWNER ||
- XCB_SEQUENCE_COMPARE(c->in.request_read, <=, pend->last_request))))
- pend = 0;
- if(pend)
- pend->flags |= XCB_REQUEST_DISCARD_REPLY;
- else
- insert_pending_discard(c, &c->in.pending_replies, c->in.request_read);
+ /* Free any replies or errors that we've already read. Stop if
+ * xcb_wait_for_reply would block or we've run out of replies. */
+ while(poll_for_reply(c, request, &reply, 0) && reply)
+ free(reply);
+ /* If we've proven there are no more responses coming, we're done. */
+ if(XCB_SEQUENCE_COMPARE(request, <=, c->in.request_completed))
return;
- }
/* Walk the list of pending requests. Mark the first match for deletion. */
for(prev_pend = &c->in.pending_replies; *prev_pend; prev_pend = &(*prev_pend)->next)
{
- if(XCB_SEQUENCE_COMPARE_32((*prev_pend)->first_request, >, request))
+ if(XCB_SEQUENCE_COMPARE((*prev_pend)->first_request, >, request))
break;
- if(XCB_SEQUENCE_COMPARE_32((*prev_pend)->first_request, ==, request))
+ if((*prev_pend)->first_request == request)
{
/* Pending reply found. Mark for discard: */
(*prev_pend)->flags |= XCB_REQUEST_DISCARD_REPLY;
}
/* Pending reply not found (likely due to _unchecked request). Create one: */
- widened_request = (c->out.request & UINT64_C(0xffffffff00000000)) | request;
- if(widened_request > c->out.request)
- widened_request -= UINT64_C(1) << 32;
-
- insert_pending_discard(c, prev_pend, widened_request);
+ insert_pending_discard(c, prev_pend, request);
}
void xcb_discard_reply(xcb_connection_t *c, unsigned int sequence)
return;
pthread_mutex_lock(&c->iolock);
- discard_reply(c, sequence);
+ discard_reply(c, widen(c, sequence));
pthread_mutex_unlock(&c->iolock);
}
}
assert(reply != 0);
pthread_mutex_lock(&c->iolock);
- ret = poll_for_reply(c, request, reply, error);
+ ret = poll_for_reply(c, widen(c, request), reply, error);
pthread_mutex_unlock(&c->iolock);
return ret;
}
return ret;
}
+static xcb_generic_event_t *get_event_until(xcb_connection_t *c, uint64_t request)
+{
+ if(c->in.events && XCB_SEQUENCE_COMPARE(c->in.events->sequence, <=, request))
+ return get_event(c);
+ return 0;
+}
+
+xcb_generic_event_t *xcb_wait_for_event_until(xcb_connection_t *c, unsigned int request)
+{
+ pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
+ reader_list reader;
+ xcb_generic_event_t *ret;
+ if(c->has_error)
+ return 0;
+ pthread_mutex_lock(&c->iolock);
+
+ insert_reader(&c->in.event_readers, &reader, widen(c, request), &cond);
+
+ while(!(ret = get_event_until(c, reader.request)) && XCB_SEQUENCE_COMPARE(c->in.event_responses_completed, <, reader.request))
+ if(!_xcb_conn_wait(c, &cond, 0, 0))
+ break;
+
+ remove_reader(&c->in.event_readers, &reader);
+ pthread_cond_destroy(&cond);
+ _xcb_in_wake_up_next_reader(c);
+ pthread_mutex_unlock(&c->iolock);
+ return ret;
+}
+
xcb_generic_error_t *xcb_request_check(xcb_connection_t *c, xcb_void_cookie_t cookie)
{
+ uint64_t request;
xcb_generic_error_t *ret = 0;
void *reply;
if(c->has_error)
return 0;
pthread_mutex_lock(&c->iolock);
- if(XCB_SEQUENCE_COMPARE_32(cookie.sequence,>=,c->in.request_expected)
- && XCB_SEQUENCE_COMPARE_32(cookie.sequence,>,c->in.request_completed))
+ request = widen(c, cookie.sequence);
+ if(XCB_SEQUENCE_COMPARE(request, >=, c->in.request_expected)
+ && XCB_SEQUENCE_COMPARE(request, >, c->in.request_completed))
{
_xcb_out_send_sync(c);
_xcb_out_flush_to(c, c->out.request);
}
- reply = wait_for_reply(c, cookie.sequence, &ret);
+ reply = wait_for_reply(c, request, &ret);
assert(!reply);
pthread_mutex_unlock(&c->iolock);
return ret;
int pthreadret;
if(c->in.readers)
pthreadret = pthread_cond_signal(c->in.readers->data);
+ else if(c->in.event_readers)
+ pthreadret = pthread_cond_signal(c->in.event_readers->data);
else
pthreadret = pthread_cond_signal(&c->in.event_cond);
assert(pthreadret == 0);
projects / free-sw / xcb / libxcb / blobdiff