1.10-3

5 files changed, 262 insertions, 22 deletions

diff --git a/.SRCINFO b/.SRCINFO
index f778a4c6bbe0..12496fe226c1 100644
--- a/.SRCINFO
+++ b/.SRCINFO
@@ -1,23 +1,26 @@
 pkgbase = libx32-libxcb
 	pkgdesc = X11 client-side library (x32 ABI)
-	pkgver = 1.9
-	pkgrel = 1.1
+	pkgver = 1.10
+	pkgrel = 3
 	url = http://xcb.freedesktop.org/
 	arch = x86_64
 	license = custom
 	makedepends = pkgconfig
 	makedepends = libx32-libxslt
-	makedepends = binx32-python2
+	makedepends = python
 	makedepends = gcc-multilib-x32
 	makedepends = autoconf
 	depends = libx32-libxdmcp
 	depends = libx32-libxau
 	depends = libxcb
-	options = !libtool
-	source = http://xcb.freedesktop.org//dist/libxcb-1.9.tar.bz2
+	source = http://xcb.freedesktop.org//dist/libxcb-1.10.tar.bz2
 	source = libxcb-1.1-no-pthread-stubs.patch
-	sha1sums = ad2fb95eeec41ba3d39502a4f7460c3b64fdf061
-	sha1sums = d2df03ddf3e949c10c2c185256b0eb7fa02837ab
+	source = Ensure-xcb-owns-socket-and-no-other-threads-are-writ.patch
+	source = Force-XCB-event-structures-with-64-bit-extended-fiel.patch
+	sha256sums = 98d9ab05b636dd088603b64229dd1ab2d2cc02ab807892e107d674f9c3f2d5b5
+	sha256sums = 748ed83af60468a0eb6785222e4a5ca589d28f20b9bfc60d5936ec93b8eef356
+	sha256sums = 47de1025bb16446b9e69ff7b6b262a0a1af957d350afe897421b9105c89befeb
+	sha256sums = 7dd84c631da541e2dc708323071c3306ceaf79ee807aa457c1cdc7e069b7ccb9
 
 pkgname = libx32-libxcb
 
diff --git a/Ensure-xcb-owns-socket-and-no-other-threads-are-writ.patch b/Ensure-xcb-owns-socket-and-no-other-threads-are-writ.patch
new file mode 100644
index 000000000000..90a236816174
--- /dev/null
+++ b/Ensure-xcb-owns-socket-and-no-other-threads-are-writ.patch
@@ -0,0 +1,121 @@
+From be0fe56c3bcad5124dcc6c47a2fad01acd16f71a Mon Sep 17 00:00:00 2001
+From: Keith Packard <keithp@keithp.com>
+Date: Mon, 23 Dec 2013 21:15:20 -0800
+Subject: [PATCH] Ensure xcb owns socket and no other threads are writing
+ before send_request
+
+send_request may only write to out.queue if no other thread is busy
+writing to the network (as that thread may be writing from out.queue).
+
+send_request may only allocate request sequence numbers if XCB owns
+the socket.
+
+Therefore, send_request must make sure that both conditions are true
+when it holds iolock, which can only be done by looping until both
+conditions are true without having dropped the lock waiting for the
+second condition.
+
+We choose to get the socket back from Xlib first as get_socket_back
+has a complicated test and checking for other threads writing is a
+simple in-lined check.
+
+This also changes the sequence number checks (64k requests with no
+reply, 4M request wrapping) to ensure that both conditions are true
+before queueing the request.
+
+Signed-off-by: Keith Packard <keithp@keithp.com>
+Reviewed-by: Uli Schlachter <psychon@znc.in>
+---
+ src/xcb_out.c | 57 ++++++++++++++++++++++++++++++++++++++++-----------------
+ 1 file changed, 40 insertions(+), 17 deletions(-)
+
+diff --git a/src/xcb_out.c b/src/xcb_out.c
+index 18bb5f9..dc42954 100644
+--- a/src/xcb_out.c
++++ b/src/xcb_out.c
+@@ -103,6 +103,33 @@ static void get_socket_back(xcb_connection_t *c)
+     _xcb_in_replies_done(c);
+ }
+ 
++static void prepare_socket_request(xcb_connection_t *c)
++{
++    /* We're about to append data to out.queue, so we need to
++     * atomically test for an external socket owner *and* some other
++     * thread currently writing.
++     *
++     * If we have an external socket owner, we have to get the socket back
++     * before we can use it again.
++     *
++     * If some other thread is writing to the socket, we assume it's
++     * writing from out.queue, and so we can't stick data there.
++     *
++     * We satisfy this condition by first calling get_socket_back
++     * (which may drop the lock, but will return when XCB owns the
++     * socket again) and then checking for another writing thread and
++     * escaping the loop if we're ready to go.
++     */
++    for (;;) {
++        if(c->has_error)
++            return;
++        get_socket_back(c);
++        if (!c->out.writing)
++            break;
++        pthread_cond_wait(&c->out.cond, &c->iolock);
++    }
++}
++
+ /* Public interface */
+ 
+ void xcb_prefetch_maximum_request_length(xcb_connection_t *c)
+@@ -236,24 +263,23 @@ unsigned int xcb_send_request(xcb_connection_t *c, int flags, struct iovec *vect
+ 
+     /* get a sequence number and arrange for delivery. */
+     pthread_mutex_lock(&c->iolock);
+-    /* wait for other writing threads to get out of my way. */
+-    while(c->out.writing)
+-        pthread_cond_wait(&c->out.cond, &c->iolock);
+-    get_socket_back(c);
++
++    prepare_socket_request(c);
+ 
+     /* send GetInputFocus (sync_req) when 64k-2 requests have been sent without
+-     * a reply. */
+-    if(req->isvoid && c->out.request == c->in.request_expected + (1 << 16) - 2)
+-        send_sync(c);
+-    /* Also send sync_req (could use NoOp) at 32-bit wrap to avoid having
++     * a reply.
++     * Also send sync_req (could use NoOp) at 32-bit wrap to avoid having
+      * applications see sequence 0 as that is used to indicate
+-     * an error in sending the request */
+-    if((unsigned int) (c->out.request + 1) == 0)
++     * an error in sending the request
++     */
++     
++    while ((req->isvoid && c->out.request == c->in.request_expected + (1 << 16) - 2) ||
++           (unsigned int) (c->out.request + 1) == 0)
++    {
+         send_sync(c);
++        prepare_socket_request(c);
++    }
+ 
+-    /* The above send_sync calls could drop the I/O lock, but this
+-     * thread will still exclude any other thread that tries to write,
+-     * so the sequence number postconditions still hold. */
+     send_request(c, req->isvoid, workaround, flags, vector, veclen);
+     request = c->has_error ? 0 : c->out.request;
+     pthread_mutex_unlock(&c->iolock);
+@@ -373,10 +399,7 @@ int _xcb_out_send(xcb_connection_t *c, struct iovec *vector, int count)
+ 
+ void _xcb_out_send_sync(xcb_connection_t *c)
+ {
+-    /* wait for other writing threads to get out of my way. */
+-    while(c->out.writing)
+-        pthread_cond_wait(&c->out.cond, &c->iolock);
+-    get_socket_back(c);
++    prepare_socket_request(c);
+     send_sync(c);
+ }
+ 
+-- 
+1.9.2
+
diff --git a/Force-XCB-event-structures-with-64-bit-extended-fiel.patch b/Force-XCB-event-structures-with-64-bit-extended-fiel.patch
new file mode 100644
index 000000000000..90575c70dd78
--- /dev/null
+++ b/Force-XCB-event-structures-with-64-bit-extended-fiel.patch
@@ -0,0 +1,102 @@
+From 3b72a2c9d1d656c74c691a45689e1d637f669e3a Mon Sep 17 00:00:00 2001
+From: Kenneth Graunke <kenneth@whitecape.org>
+Date: Fri, 03 Jan 2014 23:08:33 +0000
+Subject: Force XCB event structures with 64-bit extended fields to be packed.
+
+With the advent of the Present extension, some events (such as
+PresentCompleteNotify) now use native 64-bit types on the wire.
+
+For XGE events, we insert an extra "uint32_t full_sequence" field
+immediately after the first 32 bytes of data.  Normally, this causes
+the subsequent fields to be shifted over by 4 bytes, and the structure
+to grow in size by 4 bytes.  Everything works fine.
+
+However, if event contains 64-bit extended fields, this may result in
+the compiler adding an extra 4 bytes of padding so that those fields
+remain aligned on 64-bit boundaries.  This causes the structure to grow
+by 8 bytes, not 4.  Unfortunately, XCB doesn't realize this, and
+always believes that the length only increased by 4.  read_packet()
+then fails to malloc enough memory to hold the event, and the event
+processing code uses the wrong offsets.
+
+To fix this, mark any event structures containing 64-bit extended
+fields with __attribute__((__packed__)).
+
+v2: Use any(...) instead of True in (...), as suggested by
+    Daniel Martin.
+
+v3 (Alan Coopersmith): Fix build with Solaris Studio 12.3 by moving the
+attribute to after the structure definition.
+
+Signed-off-by: Kenneth Graunke <kenneth@whitecape.org>
+Reviewed-by: Keith Packard <keithp@keithp.com> [v1]
+Reviewed-by: Josh Triplett <josh@joshtriplett.org> [v1]
+Reviewed-by: Daniel Martin <consume.noise@gmail.com>
+Signed-off-by: Alan Coopersmith <alan.coopersmith@oracle.com>
+---
+diff --git a/src/c_client.py b/src/c_client.py
+index 99fd307..45de544 100644
+--- a/src/c_client.py
++++ b/src/c_client.py
+@@ -1762,7 +1762,7 @@ def c_simple(self, name):
+         # Iterator
+         _c_iterator(self, name)
+ 
+-def _c_complex(self):
++def _c_complex(self, force_packed = False):
+     '''
+     Helper function for handling all structure types.
+     Called for all structs, requests, replies, events, errors.
+@@ -1817,7 +1817,7 @@ def _c_complex(self):
+             if b.type.has_name:
+                 _h('    } %s;', b.c_field_name)
+ 
+-    _h('} %s;', self.c_type)
++    _h('} %s%s;', 'XCB_PACKED ' if force_packed else '', self.c_type)
+ 
+ def c_struct(self, name):
+     '''
+@@ -2902,6 +2902,7 @@ def c_event(self, name):
+     # events while generating the structure for them. Otherwise we would read
+     # garbage (the internal full_sequence) when accessing normal event fields
+     # there.
++    force_packed = False
+     if hasattr(self, 'is_ge_event') and self.is_ge_event and self.name == name:
+         event_size = 0
+         for field in self.fields:
+@@ -2911,6 +2912,11 @@ def c_event(self, name):
+                 full_sequence = Field(tcard32, tcard32.name, 'full_sequence', False, True, True)
+                 idx = self.fields.index(field)
+                 self.fields.insert(idx + 1, full_sequence)
++
++                # If the event contains any 64-bit extended fields, they need
++                # to remain aligned on a 64-bit boundary.  Adding full_sequence
++                # would normally break that; force the struct to be packed.
++                force_packed = any(f.type.size == 8 and f.type.is_simple for f in self.fields[(idx+1):])
+                 break
+ 
+     _c_type_setup(self, name, ('event',))
+@@ -2920,7 +2926,7 @@ def c_event(self, name):
+ 
+     if self.name == name:
+         # Structure definition
+-        _c_complex(self)
++        _c_complex(self, force_packed)
+     else:
+         # Typedef
+         _h('')
+diff --git a/src/xcb.h b/src/xcb.h
+index e62c985..73c77a3 100644
+--- a/src/xcb.h
++++ b/src/xcb.h
+@@ -51,6 +51,8 @@ extern "C" {
+  * @file xcb.h
+  */
+ 
++#define XCB_PACKED __attribute__((__packed__))
++
+ /**
+  * @defgroup XCB_Core_API XCB Core API
+  * @brief Core API of the XCB library.
+--
+cgit v0.9.0.2-2-gbebe
diff --git a/PKGBUILD b/PKGBUILD
index 63eea01bd79d..bb337f94a32d 100644
--- a/PKGBUILD
+++ b/PKGBUILD
@@ -1,36 +1,50 @@
-# $Id: PKGBUILD 78820 2012-10-25 06:47:28Z foutrelis $
-# Upstream Maintainer: Alexander Baldeck <alexander@archlinux.org>
+# $Id: PKGBUILD 115638 2014-07-13 07:05:40Z lcarlier $
+# Maintainer: Alexander Baldeck <alexander@archlinux.org>
 # Contributor: Jan de Groot <jgc@archlinux.org>
-# Maintainer: Fantix King <fantix.king at gmail.com>
+# x32 Maintainer: Fantix King <fantix.king at gmail.com>
 
 _pkgbasename=libxcb
 pkgname=libx32-$_pkgbasename
-pkgver=1.9
-pkgrel=1.1
+pkgver=1.10
+pkgrel=3
 pkgdesc="X11 client-side library (x32 ABI)"
 arch=(x86_64)
 url="http://xcb.freedesktop.org/"
 depends=('libx32-libxdmcp' 'libx32-libxau' $_pkgbasename)
-makedepends=('pkgconfig' 'libx32-libxslt' 'binx32-python2' 'gcc-multilib-x32'
+makedepends=('pkgconfig' 'libx32-libxslt' 'python' 'gcc-multilib-x32'
              'autoconf')
-options=('!libtool')
 license=('custom')
 source=(${url}/dist/${_pkgbasename}-${pkgver}.tar.bz2
-        libxcb-1.1-no-pthread-stubs.patch)
-sha1sums=('ad2fb95eeec41ba3d39502a4f7460c3b64fdf061'
-          'd2df03ddf3e949c10c2c185256b0eb7fa02837ab')
-
-build() {
+        libxcb-1.1-no-pthread-stubs.patch
+	Ensure-xcb-owns-socket-and-no-other-threads-are-writ.patch
+        Force-XCB-event-structures-with-64-bit-extended-fiel.patch)
+sha256sums=('98d9ab05b636dd088603b64229dd1ab2d2cc02ab807892e107d674f9c3f2d5b5'
+            '748ed83af60468a0eb6785222e4a5ca589d28f20b9bfc60d5936ec93b8eef356'
+	    '47de1025bb16446b9e69ff7b6b262a0a1af957d350afe897421b9105c89befeb'
+            '7dd84c631da541e2dc708323071c3306ceaf79ee807aa457c1cdc7e069b7ccb9')
+
+prepare() {
   cd "${srcdir}/${_pkgbasename}-${pkgver}"
 
   patch -Np1 -i "${srcdir}/libxcb-1.1-no-pthread-stubs.patch"
+  autoreconf -vfi
+
+  # fix FS#40289 merged upstream 
+  patch -Np1 -i ../Ensure-xcb-owns-socket-and-no-other-threads-are-writ.patch 
+  # fix FS#41172 merged upstream
+  patch -Np1 -i ../Force-XCB-event-structures-with-64-bit-extended-fiel.patch
+}
+
+build() {
+  cd "${srcdir}/${_pkgbasename}-${pkgver}"
 
   export CC="gcc -mx32"
   export PKG_CONFIG_PATH="/usr/libx32/pkgconfig"
 
-  PYTHON=/usr/bin/python2-x32 ./autogen.sh \
+  ./autogen.sh \
 	  --prefix=/usr \
 	  --enable-xinput \
+          --enable-xkb \
 	  --libdir=/usr/libx32 \
 	  --disable-static
   make
diff --git a/libxcb-1.1-no-pthread-stubs.patch b/libxcb-1.1-no-pthread-stubs.patch
index 8e8162f0af7c..52c22ab7ecda 100644
--- a/libxcb-1.1-no-pthread-stubs.patch
+++ b/libxcb-1.1-no-pthread-stubs.patch
@@ -1,9 +1,9 @@
 --- libxcb-1.8.1/configure.ac	2012-03-09 15:38:38.000000000 +0100
 +++ libxcb-1.8.1/configure.ac.new	2012-03-09 16:50:40.107109896 +0100
-@@ -35,7 +35,7 @@
+@@ -43,7 +43,7 @@
  
  # Checks for pkg-config packages
- PKG_CHECK_MODULES(XCBPROTO, xcb-proto >= 1.7)
+ PKG_CHECK_MODULES(XCBPROTO, xcb-proto >= 1.10)
 -NEEDED="pthread-stubs xau >= 0.99.2"
 +NEEDED="xau >= 0.99.2"
  PKG_CHECK_MODULES(NEEDED, $NEEDED)