From 486c502906586d797814c2dee050dc7195021c5e Mon Sep 17 00:00:00 2001 From: Drake Justice Date: Sat, 28 Jun 2014 14:20:08 -0400 Subject: [PATCH] libxcb -> 1.10 --- ...socket-and-no-other-threads-are-writ.patch | 121 ++++++++++++++++++ libxcb/PKGBUILD | 48 ++++--- libxcb/libxcb-1.1-no-pthread-stubs.patch | 12 +- 3 files changed, 158 insertions(+), 23 deletions(-) create mode 100644 libxcb/Ensure-xcb-owns-socket-and-no-other-threads-are-writ.patch diff --git a/libxcb/Ensure-xcb-owns-socket-and-no-other-threads-are-writ.patch b/libxcb/Ensure-xcb-owns-socket-and-no-other-threads-are-writ.patch new file mode 100644 index 000000000..90a236816 --- /dev/null +++ b/libxcb/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 +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 +Reviewed-by: Uli Schlachter +--- + 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/libxcb/PKGBUILD b/libxcb/PKGBUILD index 19677654b..8cca75d6d 100644 --- a/libxcb/PKGBUILD +++ b/libxcb/PKGBUILD @@ -2,34 +2,48 @@ # Maintainer: Neophytos Kolokotronis pkgname=libxcb -pkgver=1.9.3 -pkgrel=1 +pkgver=1.10 +pkgrel=2 pkgdesc="X11 client-side library" arch=(x86_64) url="http://xcb.freedesktop.org/" -depends=('xcb-proto' 'libxdmcp' 'libxau') +depends=('xcb-proto>=1.10' 'libxdmcp' 'libxau') makedepends=('pkgconfig' 'libxslt' 'python') options=('!libtool') license=('custom') -source=(${url}/dist/${pkgname}-${pkgver}.tar.bz2 - libxcb-1.1-no-pthread-stubs.patch) -sha1sums=('28076500e2ca05e5887c7ed231ba305a85e8bd0b' - '93330bdcf29a9386b4222e2f0c3cea3add93f5c0') +source=($url/dist/$pkgname-$pkgver.tar.bz2 + libxcb-1.1-no-pthread-stubs.patch + Ensure-xcb-owns-socket-and-no-other-threads-are-writ.patch) +sha256sums=('98d9ab05b636dd088603b64229dd1ab2d2cc02ab807892e107d674f9c3f2d5b5' + '748ed83af60468a0eb6785222e4a5ca589d28f20b9bfc60d5936ec93b8eef356' + '47de1025bb16446b9e69ff7b6b262a0a1af957d350afe897421b9105c89befeb') -prepare() { - cd "${srcdir}/${pkgname}-${pkgver}" - patch -Np1 -i "${srcdir}/libxcb-1.1-no-pthread-stubs.patch" +prepare() { + cd "$pkgname-$pkgver" + patch -Np1 -i ../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 } build() { - cd "${srcdir}/${pkgname}-${pkgver}" - PYTHON=/usr/bin/python2 ./autogen.sh --prefix=/usr --enable-xinput --enable-xkb + cd "$pkgname-$pkgver" + ./configure --prefix=/usr \ + --enable-xinput \ + --enable-xkb \ + --disable-static make } -package () { - cd "${srcdir}/${pkgname}-${pkgver}" - make DESTDIR="${pkgdir}" install - install -m755 -d "${pkgdir}/usr/share/licenses/${pkgname}" - install -m644 COPYING "${pkgdir}/usr/share/licenses/${pkgname}/" +check() { + cd $pkgname-$pkgver + make -k check +} + +package() { + cd "$pkgname-$pkgver" + make DESTDIR="$pkgdir" install + install -m755 -d "$pkgdir/usr/share/licenses/$pkgname" + install -m644 COPYING "$pkgdir/usr/share/licenses/$pkgname" } diff --git a/libxcb/libxcb-1.1-no-pthread-stubs.patch b/libxcb/libxcb-1.1-no-pthread-stubs.patch index ac896b8f3..52c22ab7e 100644 --- a/libxcb/libxcb-1.1-no-pthread-stubs.patch +++ b/libxcb/libxcb-1.1-no-pthread-stubs.patch @@ -1,11 +1,11 @@ ---- libxcb-1.9.3/configure.ac 2012-03-09 15:38:38.000000000 +0100 -+++ libxcb-1.9.3/configure.ac.new 2012-03-09 16:50:40.107109896 +0100 -@@ -35,7 +35,7 @@ - +--- 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 +@@ -43,7 +43,7 @@ + # Checks for pkg-config packages - PKG_CHECK_MODULES(XCBPROTO, xcb-proto >= 1.9) + 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) - + have_xdmcp="no"