frederik
/
libxcb
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Track 64-bit sequence numbers internally. 

External APIs that used 32-bit sequence numbers continue to do so.

Commit by Josh Triplett and Jamey Sharp.
This commit is contained in:
Jamey Sharp 2008-05-21 14:44:16 -07:00
parent 3012334957
commit 0a403b5613
3 changed files with 31 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
src/xcb_in.c
View File

@ -52,8 +52,8 @@ struct reply_list {
}; };
typedef struct pending_reply { typedef struct pending_reply {
unsigned int first_request; uint64_t first_request;
unsigned int last_request; uint64_t last_request;
enum workarounds workaround; enum workarounds workaround;
int flags; int flags;
struct pending_reply *next; struct pending_reply *next;
@ -94,8 +94,8 @@ static int read_packet(xcb_connection_t *c)
/* Compute 32-bit sequence number of this packet. */ /* Compute 32-bit sequence number of this packet. */
if((genrep.response_type & 0x7f) != XCB_KEYMAP_NOTIFY) if((genrep.response_type & 0x7f) != XCB_KEYMAP_NOTIFY)
{ {
unsigned int lastread = c->in.request_read; uint64_t lastread = c->in.request_read;
c->in.request_read = (lastread & 0xffff0000) | genrep.sequence; c->in.request_read = (lastread & UINT64_C(0xffffffffffff0000)) | genrep.sequence;
if(XCB_SEQUENCE_COMPARE(c->in.request_read, <, lastread)) if(XCB_SEQUENCE_COMPARE(c->in.request_read, <, lastread))
c->in.request_read += 0x10000; c->in.request_read += 0x10000;
if(XCB_SEQUENCE_COMPARE(c->in.request_read, >, c->in.request_expected)) if(XCB_SEQUENCE_COMPARE(c->in.request_read, >, c->in.request_expected))
@ -203,10 +203,10 @@ static int read_packet(xcb_connection_t *c)
c->in.current_reply_tail = &cur->next; c->in.current_reply_tail = &cur->next;
for(reader = c->in.readers; for(reader = c->in.readers;
reader && reader &&
XCB_SEQUENCE_COMPARE(reader->request, <=, c->in.request_read); XCB_SEQUENCE_COMPARE_32(reader->request, <=, c->in.request_read);
reader = reader->next) reader = reader->next)
{ {
if(reader->request == c->in.request_read) if(XCB_SEQUENCE_COMPARE_32(reader->request, ==, c->in.request_read))
{ {
pthread_cond_signal(reader->data); pthread_cond_signal(reader->data);
break; break;
@ -288,7 +288,7 @@ static int poll_for_reply(xcb_connection_t *c, unsigned int request, void **repl
head = 0; head = 0;
/* We've read requests past the one we want, so if it has replies we have /* 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. */ * them all and they're in the replies map. */
else if(XCB_SEQUENCE_COMPARE(request, <, c->in.request_read)) else if(XCB_SEQUENCE_COMPARE_32(request, <, c->in.request_read))
{ {
head = _xcb_map_remove(c->in.replies, request); head = _xcb_map_remove(c->in.replies, request);
if(head && head->next) if(head && head->next)
@ -296,7 +296,7 @@ static int poll_for_reply(xcb_connection_t *c, unsigned int request, void **repl
} }
/* We're currently processing the responses to the request we want, and we /* 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. */ * have a reply ready to return. So just return it without blocking. */
else if(request == c->in.request_read && c->in.current_reply) else if(XCB_SEQUENCE_COMPARE_32(request, ==, c->in.request_read) && c->in.current_reply)
{ {
head = c->in.current_reply; head = c->in.current_reply;
c->in.current_reply = head->next; c->in.current_reply = head->next;
@ -305,7 +305,7 @@ static int poll_for_reply(xcb_connection_t *c, unsigned int request, void **repl
} }
/* We know this request can't have any more replies, and we've already /* 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. */ * established it doesn't have a reply now. Don't bother blocking. */
else if(request == c->in.request_completed) else if(XCB_SEQUENCE_COMPARE_32(request, ==, c->in.request_completed))
head = 0; head = 0;
/* We may have more replies on the way for this request: block until we're /* We may have more replies on the way for this request: block until we're
* sure. */ * sure. */
@ -338,6 +338,7 @@ static int poll_for_reply(xcb_connection_t *c, unsigned int request, void **repl
void *xcb_wait_for_reply(xcb_connection_t *c, unsigned int request, xcb_generic_error_t **e) void *xcb_wait_for_reply(xcb_connection_t *c, unsigned int request, xcb_generic_error_t **e)
{ {
uint64_t widened_request;
void *ret = 0; void *ret = 0;
if(e) if(e)
*e = 0; *e = 0;
@ -346,8 +347,12 @@ void *xcb_wait_for_reply(xcb_connection_t *c, unsigned int request, xcb_generic_
pthread_mutex_lock(&c->iolock); pthread_mutex_lock(&c->iolock);
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 this request has not been written yet, write it. */
if(_xcb_out_flush_to(c, request)) if(_xcb_out_flush_to(c, widened_request))
{ {
pthread_cond_t cond = PTHREAD_COND_INITIALIZER; pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
reader_list reader; reader_list reader;
@ -355,7 +360,7 @@ void *xcb_wait_for_reply(xcb_connection_t *c, unsigned int request, xcb_generic_
for(prev_reader = &c->in.readers; for(prev_reader = &c->in.readers;
*prev_reader && *prev_reader &&
XCB_SEQUENCE_COMPARE ((*prev_reader)->request, <=, request); XCB_SEQUENCE_COMPARE_32((*prev_reader)->request, <=, request);
prev_reader = &(*prev_reader)->next) prev_reader = &(*prev_reader)->next)
{ {
/* empty */; /* empty */;
@ -371,7 +376,7 @@ void *xcb_wait_for_reply(xcb_connection_t *c, unsigned int request, xcb_generic_
for(prev_reader = &c->in.readers; for(prev_reader = &c->in.readers;
*prev_reader && *prev_reader &&
XCB_SEQUENCE_COMPARE((*prev_reader)->request, <=, request); XCB_SEQUENCE_COMPARE_32((*prev_reader)->request, <=, request);
prev_reader = &(*prev_reader)->next) prev_reader = &(*prev_reader)->next)
{ {
if(*prev_reader == &reader) if(*prev_reader == &reader)
@ -445,8 +450,8 @@ xcb_generic_error_t *xcb_request_check(xcb_connection_t *c, xcb_void_cookie_t co
void *reply; void *reply;
if(c->has_error) if(c->has_error)
return 0; return 0;
if(XCB_SEQUENCE_COMPARE(cookie.sequence,>,c->in.request_expected) if(XCB_SEQUENCE_COMPARE_32(cookie.sequence,>,c->in.request_expected)
&& XCB_SEQUENCE_COMPARE(cookie.sequence,>,c->in.request_completed)) && XCB_SEQUENCE_COMPARE_32(cookie.sequence,>,c->in.request_completed))
{ {
free(xcb_get_input_focus_reply(c, xcb_get_input_focus(c), &ret)); free(xcb_get_input_focus_reply(c, xcb_get_input_focus(c), &ret));
assert(!ret); assert(!ret);
@ -500,7 +505,7 @@ void _xcb_in_destroy(_xcb_in *in)
} }
} }
int _xcb_in_expect_reply(xcb_connection_t *c, unsigned int request, enum workarounds workaround, int flags) int _xcb_in_expect_reply(xcb_connection_t *c, uint64_t request, enum workarounds workaround, int flags)
{ {
pending_reply *pend = malloc(sizeof(pending_reply)); pending_reply *pend = malloc(sizeof(pending_reply));
assert(workaround != WORKAROUND_NONE || flags != 0); assert(workaround != WORKAROUND_NONE || flags != 0);

4
src/xcb_out.c
View File

@ -112,7 +112,7 @@ unsigned int xcb_send_request(xcb_connection_t *c, int flags, struct iovec *vect
} fields; } fields;
uint32_t packet; uint32_t packet;
} sync_req = { { /* GetInputFocus */ 43, 0, 1 } }; } sync_req = { { /* GetInputFocus */ 43, 0, 1 } };
unsigned int request; uint64_t request;
uint32_t prefix[3] = { 0 }; uint32_t prefix[3] = { 0 };
int veclen = req->count; int veclen = req->count;
enum workarounds workaround = WORKAROUND_NONE; enum workarounds workaround = WORKAROUND_NONE;
@ -282,7 +282,7 @@ int _xcb_out_send(xcb_connection_t *c, struct iovec **vector, int *count)
return ret; return ret;
} }
int _xcb_out_flush_to(xcb_connection_t *c, unsigned int request) int _xcb_out_flush_to(xcb_connection_t *c, uint64_t request)
{ {
assert(XCB_SEQUENCE_COMPARE(request, <=, c->out.request)); assert(XCB_SEQUENCE_COMPARE(request, <=, c->out.request));
if(XCB_SEQUENCE_COMPARE(c->out.request_written, >=, request)) if(XCB_SEQUENCE_COMPARE(c->out.request_written, >=, request))

17
src/xcbint.h
View File

@ -52,7 +52,8 @@ enum lazy_reply_tag
#define XCB_PAD(i) (-(i) & 3) #define XCB_PAD(i) (-(i) & 3)
#define XCB_SEQUENCE_COMPARE(a,op,b) ((int) ((a) - (b)) op 0) #define XCB_SEQUENCE_COMPARE(a,op,b) ((int64_t) ((a) - (b)) op 0)
#define XCB_SEQUENCE_COMPARE_32(a,op,b) (((int) (a) - (int) (b)) op 0)
/* xcb_list.c */ /* xcb_list.c */
@ -75,8 +76,8 @@ typedef struct _xcb_out {
char queue[4096]; char queue[4096];
int queue_len; int queue_len;
unsigned int request; uint64_t request;
unsigned int request_written; uint64_t request_written;
pthread_mutex_t reqlenlock; pthread_mutex_t reqlenlock;
enum lazy_reply_tag maximum_request_length_tag; enum lazy_reply_tag maximum_request_length_tag;
@ -90,7 +91,7 @@ int _xcb_out_init(_xcb_out *out);
void _xcb_out_destroy(_xcb_out *out); void _xcb_out_destroy(_xcb_out *out);
int _xcb_out_send(xcb_connection_t *c, struct iovec **vector, int *count); int _xcb_out_send(xcb_connection_t *c, struct iovec **vector, int *count);
int _xcb_out_flush_to(xcb_connection_t *c, unsigned int request); int _xcb_out_flush_to(xcb_connection_t *c, uint64_t request);
/* xcb_in.c */ /* xcb_in.c */
@ -102,9 +103,9 @@ typedef struct _xcb_in {
char queue[4096]; char queue[4096];
int queue_len; int queue_len;
unsigned int request_expected; uint64_t request_expected;
unsigned int request_read; uint64_t request_read;
unsigned int request_completed; uint64_t request_completed;
struct reply_list *current_reply; struct reply_list *current_reply;
struct reply_list **current_reply_tail; struct reply_list **current_reply_tail;
@ -120,7 +121,7 @@ typedef struct _xcb_in {
int _xcb_in_init(_xcb_in *in); int _xcb_in_init(_xcb_in *in);
void _xcb_in_destroy(_xcb_in *in); void _xcb_in_destroy(_xcb_in *in);
int _xcb_in_expect_reply(xcb_connection_t *c, unsigned int request, enum workarounds workaround, int flags); int _xcb_in_expect_reply(xcb_connection_t *c, uint64_t request, enum workarounds workaround, int flags);
int _xcb_in_read(xcb_connection_t *c); int _xcb_in_read(xcb_connection_t *c);
int _xcb_in_read_block(xcb_connection_t *c, void *buf, int nread); int _xcb_in_read_block(xcb_connection_t *c, void *buf, int nread);