X-Git-Url: http://git.demorecorder.com/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fxcb_in.c;h=6dd358cbdd4727c7ca738e0ed27111ccf4469c1e;hb=1c590d5a86ae854e53f388e40c952e92f11d59e6;hp=212dc9a6e43431330383feee16ca10f22ccad6dd;hpb=fa452cc9b2bb69fa0603dfd97e00e540b6b52840;p=free-sw%2Fxcb%2Flibxcb diff --git a/src/xcb_in.c b/src/xcb_in.c index 212dc9a..6dd358c 100644 --- a/src/xcb_in.c +++ b/src/xcb_in.c @@ -30,12 +30,16 @@ #include #include #include -#include #include #include "xcb.h" #include "xcbext.h" #include "xcbint.h" +#if USE_POLL +#include +#else +#include +#endif #define XCB_ERROR 0 #define XCB_REPLY 1 @@ -65,16 +69,6 @@ typedef struct reader_list { struct reader_list *next; } reader_list; -static void wake_up_next_reader(xcb_connection_t *c) -{ - int pthreadret; - if(c->in.readers) - pthreadret = pthread_cond_signal(c->in.readers->data); - else - pthreadret = pthread_cond_signal(&c->in.event_cond); - assert(pthreadret == 0); -} - static int read_packet(xcb_connection_t *c) { xcb_generic_reply_t genrep; @@ -150,9 +144,7 @@ static int read_packet(xcb_connection_t *c) /* XGE events may have sizes > 32 */ if (genrep.response_type == XCB_XGE_EVENT) - { - eventlength = ((xcb_ge_event_t*)&genrep)->length * 4; - } + eventlength = genrep.length * 4; buf = malloc(length + eventlength + (genrep.response_type == XCB_REPLY ? 0 : sizeof(uint32_t))); @@ -268,12 +260,22 @@ static int read_block(const int fd, void *buf, const ssize_t len) done += ret; if(ret < 0 && errno == EAGAIN) { +#if USE_POLL + struct pollfd pfd; + pfd.fd = fd; + pfd.events = POLLIN; + pfd.revents = 0; + do { + ret = poll(&pfd, 1, -1); + } while (ret == -1 && errno == EINTR); +#else fd_set fds; FD_ZERO(&fds); FD_SET(fd, &fds); do { ret = select(fd + 1, &fds, 0, 0, 0); } while (ret == -1 && errno == EINTR); +#endif } if(ret <= 0) return ret; @@ -390,11 +392,121 @@ void *xcb_wait_for_reply(xcb_connection_t *c, unsigned int request, xcb_generic_ pthread_cond_destroy(&cond); } - wake_up_next_reader(c); + _xcb_in_wake_up_next_reader(c); pthread_mutex_unlock(&c->iolock); return ret; } +static void insert_pending_discard(xcb_connection_t *c, pending_reply **prev_next, uint64_t seq) +{ + pending_reply *pend; + pend = malloc(sizeof(*pend)); + if(!pend) + { + _xcb_conn_shutdown(c); + return; + } + + pend->first_request = seq; + pend->last_request = seq; + pend->workaround = 0; + pend->flags = XCB_REQUEST_DISCARD_REPLY; + pend->next = *prev_next; + *prev_next = pend; + + if(!pend->next) + c->in.pending_replies_tail = &pend->next; +} + +static void discard_reply(xcb_connection_t *c, unsigned int request) +{ + pending_reply *pend = 0; + 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); + + 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)) + break; + + if(XCB_SEQUENCE_COMPARE_32((*prev_pend)->first_request, ==, request)) + { + /* Pending reply found. Mark for discard: */ + (*prev_pend)->flags |= XCB_REQUEST_DISCARD_REPLY; + return; + } + } + + /* 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); +} + +void xcb_discard_reply(xcb_connection_t *c, unsigned int sequence) +{ + if(c->has_error) + return; + + /* If an error occurred when issuing the request, fail immediately. */ + if(!sequence) + return; + + pthread_mutex_lock(&c->iolock); + discard_reply(c, sequence); + pthread_mutex_unlock(&c->iolock); +} + int xcb_poll_for_reply(xcb_connection_t *c, unsigned int request, void **reply, xcb_generic_error_t **error) { int ret; @@ -423,7 +535,7 @@ xcb_generic_event_t *xcb_wait_for_event(xcb_connection_t *c) if(!_xcb_conn_wait(c, &c->in.event_cond, 0, 0)) break; - wake_up_next_reader(c); + _xcb_in_wake_up_next_reader(c); pthread_mutex_unlock(&c->iolock); return ret; } @@ -507,6 +619,16 @@ void _xcb_in_destroy(_xcb_in *in) } } +void _xcb_in_wake_up_next_reader(xcb_connection_t *c) +{ + int pthreadret; + if(c->in.readers) + pthreadret = pthread_cond_signal(c->in.readers->data); + else + pthreadret = pthread_cond_signal(&c->in.event_cond); + assert(pthreadret == 0); +} + int _xcb_in_expect_reply(xcb_connection_t *c, uint64_t request, enum workarounds workaround, int flags) { pending_reply *pend = malloc(sizeof(pending_reply));