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.

3 files changed, 31 insertions, 25 deletions

diff --git a/src/xcb_in.c b/src/xcb_in.c
index 0c68208..6bf6648 100644
--- a/src/xcb_in.c
+++ b/src/xcb_in.c
@@ -52,8 +52,8 @@ struct reply_list {
 };
 
 typedef struct pending_reply {
-    unsigned int first_request;
-    unsigned int last_request;
+    uint64_t first_request;
+    uint64_t last_request;
     enum workarounds workaround;
     int flags;
     struct pending_reply *next;
@@ -94,8 +94,8 @@ static int read_packet(xcb_connection_t *c)
     /* Compute 32-bit sequence number of this packet. */
     if((genrep.response_type & 0x7f) != XCB_KEYMAP_NOTIFY)
     {
-        unsigned int lastread = c->in.request_read;
-        c->in.request_read = (lastread & 0xffff0000) | genrep.sequence;
+        uint64_t lastread = c->in.request_read;
+        c->in.request_read = (lastread & UINT64_C(0xffffffffffff0000)) | genrep.sequence;
         if(XCB_SEQUENCE_COMPARE(c->in.request_read, <, lastread))
             c->in.request_read += 0x10000;
         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;
         for(reader = c->in.readers; 
 	    reader && 
-	    XCB_SEQUENCE_COMPARE(reader->request, <=, c->in.request_read);
+	    XCB_SEQUENCE_COMPARE_32(reader->request, <=, c->in.request_read);
 	    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);
                 break;
@@ -288,7 +288,7 @@ static int poll_for_reply(xcb_connection_t *c, unsigned int request, void **repl
         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(request, <, c->in.request_read))
+    else if(XCB_SEQUENCE_COMPARE_32(request, <, c->in.request_read))
     {
         head = _xcb_map_remove(c->in.replies, request);
         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
      * 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;
         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
      * 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;
     /* We may have more replies on the way for this request: block until we're
      * 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)
 {
+    uint64_t widened_request;
     void *ret = 0;
     if(e)
         *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);
 
+    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(_xcb_out_flush_to(c, request))
+    if(_xcb_out_flush_to(c, widened_request))
     {
         pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
         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; 
 	    *prev_reader && 
-	    XCB_SEQUENCE_COMPARE ((*prev_reader)->request, <=, request);
+	    XCB_SEQUENCE_COMPARE_32((*prev_reader)->request, <=, request);
 	    prev_reader = &(*prev_reader)->next)
 	{
             /* 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;
 	    *prev_reader && 
-	    XCB_SEQUENCE_COMPARE((*prev_reader)->request, <=, request);
+	    XCB_SEQUENCE_COMPARE_32((*prev_reader)->request, <=, request);
 	    prev_reader = &(*prev_reader)->next)
 	{
             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;
     if(c->has_error)
         return 0;
-    if(XCB_SEQUENCE_COMPARE(cookie.sequence,>,c->in.request_expected)
-       && XCB_SEQUENCE_COMPARE(cookie.sequence,>,c->in.request_completed))
+    if(XCB_SEQUENCE_COMPARE_32(cookie.sequence,>,c->in.request_expected)
+       && XCB_SEQUENCE_COMPARE_32(cookie.sequence,>,c->in.request_completed))
     {
         free(xcb_get_input_focus_reply(c, xcb_get_input_focus(c), &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));
     assert(workaround != WORKAROUND_NONE || flags != 0);
diff --git a/src/xcb_out.c b/src/xcb_out.c
index ad4240a..1094ceb 100644
--- a/src/xcb_out.c
+++ b/src/xcb_out.c
@@ -112,7 +112,7 @@ unsigned int xcb_send_request(xcb_connection_t *c, int flags, struct iovec *vect
         } fields;
         uint32_t packet;
     } sync_req = { { /* GetInputFocus */ 43, 0, 1 } };
-    unsigned int request;
+    uint64_t request;
     uint32_t prefix[3] = { 0 };
     int veclen = req->count;
     enum workarounds workaround = WORKAROUND_NONE;
@@ -282,7 +282,7 @@ int _xcb_out_send(xcb_connection_t *c, struct iovec **vector, int *count)
     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));
     if(XCB_SEQUENCE_COMPARE(c->out.request_written, >=, request))
diff --git a/src/xcbint.h b/src/xcbint.h
index a85b04e..8c6bcaa 100644
--- a/src/xcbint.h
+++ b/src/xcbint.h
@@ -52,7 +52,8 @@ enum lazy_reply_tag
 
 #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 */
 
@@ -75,8 +76,8 @@ typedef struct _xcb_out {
     char queue[XCB_QUEUE_BUFFER_SIZE];
     int queue_len;
 
-    unsigned int request;
-    unsigned int request_written;
+    uint64_t request;
+    uint64_t request_written;
 
     pthread_mutex_t reqlenlock;
     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);
 
 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 */
@@ -102,9 +103,9 @@ typedef struct _xcb_in {
     char queue[4096];
     int queue_len;
 
-    unsigned int request_expected;
-    unsigned int request_read;
-    unsigned int request_completed;
+    uint64_t request_expected;
+    uint64_t request_read;
+    uint64_t request_completed;
     struct reply_list *current_reply;
     struct reply_list **current_reply_tail;
 
@@ -120,7 +121,7 @@ typedef struct _xcb_in {
 int _xcb_in_init(_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_block(xcb_connection_t *c, void *buf, int nread);