519 2011-10-03 13:30:43 +0200 GLPBuffer takes awtlock during painting 2011-12-02 07:59:44 +0100 1 1 3 JogAmp Jogl awt 2 All all VERIFIED FIXED --- normal --- 1 danielbalog86 sgothel danielbalog86 --- 0bcf2c35e96cbf7a1e2537448f9603d7d487cf86 e341ad8db546530b3a49c56c32cc26980e296201 c84e235b3284d0e18481748b44594116e25821a9 a94c1a2945a31aa5d93e354da3bc80f59f253ec4 7ae0f2df39692e82d7955dbcd09c35c36382726c 6b8f6e8d7c548cb6bfed14d8a04c9cf252ca7c4d 9ef0a0c185ace5217efc014809e97c5eead842cc 0314be79a7a93931a74fe4322bc78e699d7741e9 --- oldest_to_newest 1106 0 276 danielbalog86 2011-10-03 13:30:43 +0200 Created attachment 276 Test that demonstrates deadlock. As described in this thread: http://forum.jogamp.org/2-0-RC3-PBuffer-uses-awtlock-during-display-td3355580.html A GLPBuffer takes an AWTLock, even though it is generally used for offscreen rendering. This can cause deadlocks and hangs when offscreen images are being rendered asynchronously, together with AWT/Swing components. One workaround is to call GLProfile.initSingleton(true) as first line of your application, but this is not always feasible. One suggestion is to remove AWT locking for offscreen PBuffers altogether. The relevant stack trace is as follows: java.lang.Thread.State: WAITING at sun.misc.Unsafe.park(Unsafe.java:-1) at java.util.concurrent.locks.LockSupport.park(LockSupport.java:158) at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:811) at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:842) at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1178) at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:186) at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:262) at sun.awt.SunToolkit.awtLock(SunToolkit.java:236) at sun.reflect.GeneratedMethodAccessor4.invoke(Unknown Source:-1) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) at java.lang.reflect.Method.invoke(Method.java:597) at jogamp.nativewindow.jawt.JAWTUtil.awtLock(JAWTUtil.java:195) at jogamp.nativewindow.jawt.JAWTUtil.lockToolkit(JAWTUtil.java:224) at jogamp.nativewindow.jawt.x11.X11JAWTToolkitLock.lock(X11JAWTToolkitLock.java:51) at javax.media.nativewindow.DefaultGraphicsDevice.lock(DefaultGraphicsDevice.java:128) at javax.media.nativewindow.ProxySurface.lockSurface(ProxySurface.java:94) at jogamp.opengl.GLDrawableImpl.lockSurface(GLDrawableImpl.java:186) at jogamp.opengl.GLContextImpl.makeCurrentLocking(GLContextImpl.java:435) at jogamp.opengl.GLContextImpl.makeCurrent(GLContextImpl.java:388) at jogamp.opengl.GLDrawableHelper.invokeGL(GLDrawableHelper.java:328) at jogamp.opengl.GLPbufferImpl.invokeGL(GLPbufferImpl.java:289) at jogamp.opengl.GLPbufferImpl.display(GLPbufferImpl.java:148) To reproduce the issue, run the code in the attachment. 1139 1 danielbalog86 2011-10-17 09:08:37 +0200 So to get this ball rolling, I tried to create a flag in GLContextImpl that basically prevents a surfacelock from being taken when set to false. This would make the makeCurrentLocking() method look like this: // Note: the surface is locked within [makeCurrent .. swap .. release] protected final int makeCurrentLocking() throws GLException { boolean exceptionOccurred = false; int lockRes = 0; if ( surfaceLocking ) { lockRes = drawable.lockSurface(); }else{ lockRes = NativeSurface.LOCK_SUCCESS; } try { if (NativeSurface.LOCK_SURFACE_NOT_READY == lockRes) { return CONTEXT_NOT_CURRENT; } try { if (NativeSurface.LOCK_SURFACE_CHANGED == lockRes) { drawable.updateHandle(); } if (0 == drawable.getHandle()) { throw new GLException("drawable has invalid handle: "+drawable); } boolean newCreated = false; if (!isCreated()) { GLProfile.initProfiles( getGLDrawable().getNativeSurface().getGraphicsConfiguration().getNativeGraphicsConfiguration().getScreen().getDevice()); newCreated = createImpl(); // may throws exception if fails! if (DEBUG) { if(newCreated) { System.err.println(getThreadName() + ": !!! Create GL context OK: " + toHexString(contextHandle) + " for " + getClass().getName()); } else { System.err.println(getThreadName() + ": !!! Create GL context FAILED for " + getClass().getName()); } } if(!newCreated) { return CONTEXT_NOT_CURRENT; } GLContextShareSet.contextCreated(this); } makeCurrentImpl(newCreated); return newCreated ? CONTEXT_CURRENT_NEW : CONTEXT_CURRENT ; } catch (RuntimeException e) { exceptionOccurred = true; throw e; } } finally { if (exceptionOccurred) { if ( surfaceLocking ) { drawable.unlockSurface(); } } } } The problem is that this method still takes an awtlock regardless, through the following stack trace: "pool-1-thread-1" prio=10 tid=0x00000000411d4800 nid=0x1844 waiting on condition [0x00007f6511210000] java.lang.Thread.State: WAITING (parking) at sun.misc.Unsafe.park(Native Method) - parking to wait for <0x00000000bc0b4128> (a java.util.concurrent.locks.ReentrantLock$NonfairSync) at java.util.concurrent.locks.LockSupport.park(LockSupport.java:158) at java.util.concurrent.locks.AbstractQueuedSynchronizer.parkAndCheckInterrupt(AbstractQueuedSynchronizer.java:811) at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquireQueued(AbstractQueuedSynchronizer.java:842) at java.util.concurrent.locks.AbstractQueuedSynchronizer.acquire(AbstractQueuedSynchronizer.java:1178) at java.util.concurrent.locks.ReentrantLock$NonfairSync.lock(ReentrantLock.java:186) at java.util.concurrent.locks.ReentrantLock.lock(ReentrantLock.java:262) at sun.awt.SunToolkit.awtLock(SunToolkit.java:236) at sun.reflect.GeneratedMethodAccessor4.invoke(Unknown Source) at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:25) at java.lang.reflect.Method.invoke(Method.java:597) at jogamp.nativewindow.jawt.JAWTUtil.awtLock(JAWTUtil.java:195) at jogamp.nativewindow.jawt.JAWTUtil.lockToolkit(JAWTUtil.java:224) at jogamp.nativewindow.jawt.JAWTToolkitLock.lock(JAWTToolkitLock.java:47) at jogamp.nativewindow.x11.X11Util.lockDefaultToolkit(X11Util.java:131) at jogamp.nativewindow.x11.X11Util.XSync(X11Util.java:502) at jogamp.opengl.x11.glx.X11GLXContext.createContextARBImpl(X11GLXContext.java:249) at jogamp.opengl.GLContextImpl.createContextARB(GLContextImpl.java:593) at jogamp.opengl.x11.glx.X11GLXContext.createImplRaw(X11GLXContext.java:340) at jogamp.opengl.x11.glx.X11GLXContext.createImpl(X11GLXContext.java:285) at jogamp.opengl.GLContextImpl.makeCurrentLocking(GLContextImpl.java:466) at jogamp.opengl.GLContextImpl.makeCurrent(GLContextImpl.java:398) at jogamp.opengl.GLDrawableHelper.invokeGL(GLDrawableHelper.java:328) at jogamp.opengl.GLPbufferImpl.invokeGL(GLPbufferImpl.java:290) at jogamp.opengl.GLPbufferImpl.display(GLPbufferImpl.java:149) at com.jogamp.opengl.test.junit.jogl.demos.gl2.awt.TestPBufferDeadLock$1.run(TestPBufferDeadLock.java:75) at java.util.concurrent.ThreadPoolExecutor$Worker.runTask(ThreadPoolExecutor.java:886) at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:908) at java.lang.Thread.run(Thread.java:662) Basically, the X11Util.XSync method also locks awt, which fails this test. 1140 2 danielbalog86 2011-10-17 09:19:55 +0200 Ok, so I can get around the XSync lock by adding a lock parameter to the method that, when set to false, prevents locking. So basically: public static int XSync( long display, boolean discard, boolean lock ) { if ( lock ) { lockDefaultToolkit(display); } try { return X11Lib.XSync(display, discard); } finally { if ( lock ) { unlockDefaultToolkit(display); } } } And then in X11GLXContext.createContextARBIMpl(), you call: try { // critical path, a remote display might not support this command, // hence we need to catch the X11 Error within this block. X11Util.XSync(display, false, isSurfaceLocking() ); ctx = _glXExt.glXCreateContextAttribsARB(display, config.getFBConfig(), share, direct, attribs); X11Util.XSync(display, false, isSurfaceLocking() ); } catch (RuntimeException re) { if(DEBUG) { Throwable t = new Throwable("Info: X11GLXContext.createContextARBImpl glXCreateContextAttribsARB failed with "+getGLVersion(major, minor, ctp, "@creation"), re); t.printStackTrace(); } } where isSurfaceLocking() is defined in GLContextImpl as public boolean isSurfaceLocking() { return surfaceLocking; } public void setSurfaceLocking( boolean aSurfaceLocking ) { surfaceLocking = aSurfaceLocking; } , and surfaceLocking is a flag that is set to false when creating a PBufferDrawable. So the constructor of GLPBufferImpl would be: public GLPbufferImpl(GLDrawableImpl pbufferDrawable, GLContext parentContext) { GLCapabilitiesImmutable caps = (GLCapabilitiesImmutable) pbufferDrawable.getNativeSurface().getGraphicsConfiguration().getNativeGraphicsConfiguration().getChosenCapabilities(); if(caps.isOnscreen()) { if(caps.isPBuffer()) { throw new IllegalArgumentException("Error: Given drawable is Onscreen and Pbuffer: "+pbufferDrawable); } throw new IllegalArgumentException("Error: Given drawable is Onscreen: "+pbufferDrawable); } else { if(!caps.isPBuffer()) { throw new IllegalArgumentException("Error: Given drawable is not Pbuffer: "+pbufferDrawable); } } this.pbufferDrawable = pbufferDrawable; context = (GLContextImpl) pbufferDrawable.createContext(parentContext); context.setSynchronized(true); context.setSurfaceLocking( false ); } I'll upload the diff-patch for you to evaluate. 1141 3 283 danielbalog86 2011-10-17 09:27:06 +0200 Created attachment 283 A patch that prevents a PBuffer from taking awtlocks during display I uploaded a patch that modifies 4 files to make the given test succeed: GLPBufferImpl X11Util GLContextImpl X11GLXContext 1142 4 sgothel 2011-10-17 10:00:35 +0200 Thank you very much for your triage and proposal Daniel! I definitely will look into this one before RC4, of course. I like to check weather it's possible to apply your 'don't lock AWT in offscreen surface' logic further below where we actually attach the lock object to the nativewindow graphics devices. In general you are right, but applying it in the nativewindow layer would allow to make a more generic approach. 1143 5 danielbalog86 2011-10-17 17:52:50 +0200 Yeah, I figured it wasn't general enough. The problem is that I get lost in the code real easily :) Thanks for the update though, let me know if you need more help. 1202 6 sgothel 2011-11-23 04:27:51 +0100 Ok .. I actually started to work on this issue today. Will update soon .. ie. revalidating the AWT lock and controlling it's use more fine grained. This has to be done pretty carefully to not have regressions etc .. 1204 7 sgothel 2011-11-25 03:20:37 +0100 Completed review of the underlying locking mechanism, commits: 0bcf2c35e96cbf7a1e2537448f9603d7d487cf86 e341ad8db546530b3a49c56c32cc26980e296201 c84e235b3284d0e18481748b44594116e25821a9 a94c1a2945a31aa5d93e354da3bc80f59f253ec4 7ae0f2df39692e82d7955dbcd09c35c36382726c 6b8f6e8d7c548cb6bfed14d8a04c9cf252ca7c4d 9ef0a0c185ace5217efc014809e97c5eead842cc 0314be79a7a93931a74fe4322bc78e699d7741e9 It was a good review, thanks to the bug report. It resulted in a good cleanup of JAWTWindow usage and more, especially for X11. The fixes didn't introduce any more states or complication and actually removed a lot of them. Offscreen surfaces (besides others) are now lock free, even on X11. 276 2011-10-03 13:30:43 +0200 2011-10-03 13:30:43 +0200 Test that demonstrates deadlock. TestPBufferDeadlock.java text/x-java 2165 danielbalog86 CmltcG9ydCBjb20uam9nYW1wLm9wZW5nbC50ZXN0Lmp1bml0LnV0aWwuVUlUZXN0Q2FzZTsKaW1w b3J0IG9yZy5qdW5pdC4qOwppbXBvcnQgc3VuLmF3dC5TdW5Ub29sa2l0OwoKaW1wb3J0IGphdmF4 Lm1lZGlhLm9wZW5nbC4qOwppbXBvcnQgamF2YS51dGlsLmNvbmN1cnJlbnQuRXhlY3V0b3JTZXJ2 aWNlOwppbXBvcnQgamF2YS51dGlsLmNvbmN1cnJlbnQuRXhlY3V0b3JzOwoKcHVibGljIGNsYXNz IFRlc3RQQnVmZmVyRGVhZExvY2sgZXh0ZW5kcyBVSVRlc3RDYXNlIHsKICBzdGF0aWMgR0xQcm9m aWxlIGdscDsKICBzdGF0aWMgaW50IHdpZHRoLCBoZWlnaHQ7CiAgcHJpdmF0ZSBFeGVjdXRvclNl cnZpY2UgZlNpbmdsZVRocmVhZEV4ZWN1dG9yU2VydmljZTsKCiAgQEJlZm9yZUNsYXNzCiAgcHVi bGljIHN0YXRpYyB2b2lkIGluaXRDbGFzcygpIHsKICAgIGdscCA9IEdMUHJvZmlsZS5nZXREZWZh dWx0KCk7CiAgICBBc3NlcnQuYXNzZXJ0Tm90TnVsbCggZ2xwICk7CiAgICB3aWR0aCA9IDUxMjsK ICAgIGhlaWdodCA9IDUxMjsKICB9CgogIEBBZnRlckNsYXNzCiAgcHVibGljIHN0YXRpYyB2b2lk IHJlbGVhc2VDbGFzcygpIHsKICB9CgogIEBPdmVycmlkZSBAQmVmb3JlCiAgcHVibGljIHZvaWQg c2V0VXAoKSB7CiAgICBzdXBlci5zZXRVcCgpOwogICAgZlNpbmdsZVRocmVhZEV4ZWN1dG9yU2Vy dmljZSA9IEV4ZWN1dG9ycy5uZXdGaXhlZFRocmVhZFBvb2woIDEgKTsKICB9CgogIHByb3RlY3Rl ZCB2b2lkIHJ1blRlc3RHTCggR0xDYXBhYmlsaXRpZXMgY2FwcyApIHRocm93cyBJbnRlcnJ1cHRl ZEV4Y2VwdGlvbiB7CiAgICBmaW5hbCBHTFBidWZmZXIgcGJ1ZmZlciA9IEdMRHJhd2FibGVGYWN0 b3J5LmdldEZhY3RvcnkoIEdMUHJvZmlsZS5nZXQoICJHTDIiICkgKS5jcmVhdGVHTFBidWZmZXIo CiAgICAgICAgbnVsbCwKICAgICAgICBjYXBzLAogICAgICAgIG5ldyBEZWZhdWx0R0xDYXBhYmls aXRpZXNDaG9vc2VyKCksCiAgICAgICAgNTEyLAogICAgICAgIDUxMiwKICAgICAgICBudWxsCiAg ICApOwoKICAgIGZpbmFsIGJvb2xlYW5bXSBkb25lID0ge2ZhbHNlfTsKICAgIFJ1bm5hYmxlIHJ1 bm5hYmxlID0gbmV3IFJ1bm5hYmxlKCkgewogICAgICBwdWJsaWMgdm9pZCBydW4oKSB7CiAgICAg ICAgcGJ1ZmZlci5kaXNwbGF5KCk7CiAgICAgICAgZG9uZVsgMCBdID0gdHJ1ZTsKICAgICAgfQog ICAgfTsKICAgIHRyeSB7CiAgICAgIFN1blRvb2xraXQuYXd0TG9jaygpOwogICAgICBmU2luZ2xl VGhyZWFkRXhlY3V0b3JTZXJ2aWNlLmV4ZWN1dGUoIHJ1bm5hYmxlICk7CiAgICAgIHdoaWxlICgg IWRvbmVbIDAgXSApIHsKICAgICAgICB0cnkgewogICAgICAgICAgVGhyZWFkLnNsZWVwKCAxMDAg KTsKICAgICAgICB9CiAgICAgICAgY2F0Y2ggKCBJbnRlcnJ1cHRlZEV4Y2VwdGlvbiBlICkgewog ICAgICAgICAgQXNzZXJ0LmZhaWwoICJGYWlsZWQgdG8gc2xlZXAiICk7CiAgICAgICAgfQogICAg ICB9CgogICAgfQogICAgZmluYWxseSB7CiAgICAgIFN1blRvb2xraXQuYXd0VW5sb2NrKCk7CiAg ICB9CiAgfQoKICBAVGVzdCh0aW1lb3V0ID0gMTAwMDApIC8vMTAgc2Vjb25kIHRpbWVvdXQKICBw dWJsaWMgdm9pZCB0ZXN0RGVhZGxvY2soKSB0aHJvd3MgSW50ZXJydXB0ZWRFeGNlcHRpb24gewog ICAgR0xDYXBhYmlsaXRpZXMgY2FwcyA9IG5ldyBHTENhcGFiaWxpdGllcyggZ2xwICk7CiAgICBy dW5UZXN0R0woIGNhcHMgKTsKICB9CgogIHN0YXRpYyBsb25nIGR1cmF0aW9uID0gNTAwOyAvLyBt cwoKICBwdWJsaWMgc3RhdGljIHZvaWQgbWFpbiggU3RyaW5nIGFyZ3NbXSApIHsKICAgIGZvciAo IGludCBpID0gMDsgaSA8IGFyZ3MubGVuZ3RoOyBpKysgKSB7CiAgICAgIGlmICggYXJnc1sgaSBd LmVxdWFscyggIi10aW1lIiApICkgewogICAgICAgIGkrKzsKICAgICAgICB0cnkgewogICAgICAg ICAgZHVyYXRpb24gPSBJbnRlZ2VyLnBhcnNlSW50KCBhcmdzWyBpIF0gKTsKICAgICAgICB9CiAg ICAgICAgY2F0Y2ggKCBFeGNlcHRpb24gZXggKSB7CiAgICAgICAgICBleC5wcmludFN0YWNrVHJh Y2UoKTsKICAgICAgICB9CiAgICAgIH0KICAgIH0KICAgIG9yZy5qdW5pdC5ydW5uZXIuSlVuaXRD b3JlLm1haW4oIFRlc3RQQnVmZmVyRGVhZExvY2suY2xhc3MuZ2V0TmFtZSgpICk7CiAgfQp9IAo= 283 2011-10-17 09:27:06 +0200 2011-10-17 09:27:06 +0200 A patch that prevents a PBuffer from taking awtlocks during display Patch_to_prevent_PBuffer_from_taking_awtlock_during_display_calls.patch text/plain 6882 danielbalog86 SW5kZXg6IC4uLy4uL0FwcGxpY2F0aW9ucy9KT0dMR0lUL2pvZ2wvc3JjL2pvZ2wvY2xhc3Nlcy9q b2dhbXAvb3BlbmdsL0dMQ29udGV4dEltcGwuamF2YQo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSAuLi8uLi9BcHBs aWNhdGlvbnMvSk9HTEdJVC9qb2dsL3NyYy9qb2dsL2NsYXNzZXMvam9nYW1wL29wZW5nbC9HTENv bnRleHRJbXBsLmphdmEJKHJldmlzaW9uIDkxM2M2ZTI1YTZjNmJlYTI1NmY2YzIzOTQzOTU2NTYz NDI3Y2MxYjQpCisrKyAuLi8uLi9BcHBsaWNhdGlvbnMvSk9HTEdJVC9qb2dsL3NyYy9qb2dsL2Ns YXNzZXMvam9nYW1wL29wZW5nbC9HTENvbnRleHRJbXBsLmphdmEJKHJldmlzaW9uICkKQEAgLTEw NSw2ICsxMDUsOCBAQAogICBwcm90ZWN0ZWQgc3RhdGljIGZpbmFsIEhhc2hNYXA8U3RyaW5nLCBQ cm9jQWRkcmVzc1RhYmxlPiBtYXBwZWRHTFByb2NBZGRyZXNzOwogICBwcm90ZWN0ZWQgc3RhdGlj IGZpbmFsIEhhc2hNYXA8U3RyaW5nLCBQcm9jQWRkcmVzc1RhYmxlPiBtYXBwZWRHTFhQcm9jQWRk cmVzczsKIAorICBwcml2YXRlIGJvb2xlYW4gc3VyZmFjZUxvY2tpbmcgPSB0cnVlOworCiAgIHN0 YXRpYyB7CiAgICAgICBtYXBwZWRDb250ZXh0VHlwZU9iamVjdExvY2sgPSBuZXcgT2JqZWN0KCk7 CiAgICAgICBtYXBwZWRFeHRlbnNpb25BdmFpbGFiaWxpdHlDYWNoZSA9IG5ldyBIYXNoTWFwPFN0 cmluZywgRXh0ZW5zaW9uQXZhaWxhYmlsaXR5Q2FjaGU+KCk7CkBAIC0yMjIsNyArMjI0LDE1IEBA CiAgICAgICB9CiAgICAgICBsb2NrLmxvY2soKTsKICAgfQotICAgIAorCisgIHB1YmxpYyBib29s ZWFuIGlzU3VyZmFjZUxvY2tpbmcoKSB7CisgICAgcmV0dXJuIHN1cmZhY2VMb2NraW5nOworICB9 CisKKyAgcHVibGljIHZvaWQgc2V0U3VyZmFjZUxvY2tpbmcoIGJvb2xlYW4gYVN1cmZhY2VMb2Nr aW5nICkgeworICAgIHN1cmZhY2VMb2NraW5nID0gYVN1cmZhY2VMb2NraW5nOworICB9CisKICAg cHVibGljIGFic3RyYWN0IE9iamVjdCBnZXRQbGF0Zm9ybUdMRXh0ZW5zaW9ucygpOwogCiAgIC8v IE5vdGU6IHRoZSBzdXJmYWNlIGlzIGxvY2tlZCB3aXRoaW4gW21ha2VDdXJyZW50IC4uIHN3YXAg Li4gcmVsZWFzZV0KQEAgLTQzMiw3ICs0NDIsMTIgQEAKICAgLy8gTm90ZTogdGhlIHN1cmZhY2Ug aXMgbG9ja2VkIHdpdGhpbiBbbWFrZUN1cnJlbnQgLi4gc3dhcCAuLiByZWxlYXNlXQogICBwcm90 ZWN0ZWQgZmluYWwgaW50IG1ha2VDdXJyZW50TG9ja2luZygpIHRocm93cyBHTEV4Y2VwdGlvbiB7 CiAgICAgYm9vbGVhbiBleGNlcHRpb25PY2N1cnJlZCA9IGZhbHNlOwotICAgIGludCBsb2NrUmVz ID0gZHJhd2FibGUubG9ja1N1cmZhY2UoKTsKKyAgICBpbnQgbG9ja1JlcyA9IDA7CisgICAgaWYg KCBzdXJmYWNlTG9ja2luZyApIHsKKyAgICAgIGxvY2tSZXMgPSBkcmF3YWJsZS5sb2NrU3VyZmFj ZSgpOworICAgIH1lbHNleworICAgICAgbG9ja1JlcyA9IE5hdGl2ZVN1cmZhY2UuTE9DS19TVUND RVNTOworICAgIH0KICAgICB0cnkgewogICAgICAgaWYgKE5hdGl2ZVN1cmZhY2UuTE9DS19TVVJG QUNFX05PVF9SRUFEWSA9PSBsb2NrUmVzKSB7CiAgICAgICAgIHJldHVybiBDT05URVhUX05PVF9D VVJSRU5UOwpAQCAtNDY5LDEwICs0ODQsMTIgQEAKICAgICAgIH0KICAgICB9IGZpbmFsbHkgewog ICAgICAgaWYgKGV4Y2VwdGlvbk9jY3VycmVkKSB7CisgICAgICAgIGlmICggc3VyZmFjZUxvY2tp bmcgKSB7Ci0gICAgICAgIGRyYXdhYmxlLnVubG9ja1N1cmZhY2UoKTsKLSAgICAgIH0KLSAgICB9 Ci0gIH0KKyAgICAgICAgICBkcmF3YWJsZS51bmxvY2tTdXJmYWNlKCk7CisgICAgICAgIH0KKyAg ICAgIH0KKyAgICB9CisgIH0KICAgcHJvdGVjdGVkIGFic3RyYWN0IHZvaWQgbWFrZUN1cnJlbnRJ bXBsKGJvb2xlYW4gbmV3Q3JlYXRlZENvbnRleHQpIHRocm93cyBHTEV4Y2VwdGlvbjsKICAgcHJv dGVjdGVkIGFic3RyYWN0IGJvb2xlYW4gY3JlYXRlSW1wbCgpIHRocm93cyBHTEV4Y2VwdGlvbiA7 CiAKSW5kZXg6IC4uLy4uL0FwcGxpY2F0aW9ucy9KT0dMR0lUL2pvZ2wvc3JjL2pvZ2wvY2xhc3Nl cy9qb2dhbXAvb3BlbmdsL0dMUGJ1ZmZlckltcGwuamF2YQo9PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSAuLi8uLi9B cHBsaWNhdGlvbnMvSk9HTEdJVC9qb2dsL3NyYy9qb2dsL2NsYXNzZXMvam9nYW1wL29wZW5nbC9H TFBidWZmZXJJbXBsLmphdmEJKHJldmlzaW9uIDkxM2M2ZTI1YTZjNmJlYTI1NmY2YzIzOTQzOTU2 NTYzNDI3Y2MxYjQpCisrKyAuLi8uLi9BcHBsaWNhdGlvbnMvSk9HTEdJVC9qb2dsL3NyYy9qb2ds L2NsYXNzZXMvam9nYW1wL29wZW5nbC9HTFBidWZmZXJJbXBsLmphdmEJKHJldmlzaW9uICkKQEAg LTgzLDYgKzgzLDcgQEAKICAgICB0aGlzLnBidWZmZXJEcmF3YWJsZSA9IHBidWZmZXJEcmF3YWJs ZTsKICAgICBjb250ZXh0ID0gKEdMQ29udGV4dEltcGwpIHBidWZmZXJEcmF3YWJsZS5jcmVhdGVD b250ZXh0KHBhcmVudENvbnRleHQpOwogICAgIGNvbnRleHQuc2V0U3luY2hyb25pemVkKHRydWUp OworICAgIGNvbnRleHQuc2V0U3VyZmFjZUxvY2tpbmcoIGZhbHNlICk7CiAgIH0KIAogICBwdWJs aWMgR0xDb250ZXh0IGNyZWF0ZUNvbnRleHQoR0xDb250ZXh0IHNoYXJlV2l0aCkgewpJbmRleDog Li4vLi4vQXBwbGljYXRpb25zL0pPR0xHSVQvam9nbC9zcmMvbmF0aXZld2luZG93L2NsYXNzZXMv am9nYW1wL25hdGl2ZXdpbmRvdy94MTEvWDExVXRpbC5qYXZhCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIC4uLy4u L0FwcGxpY2F0aW9ucy9KT0dMR0lUL2pvZ2wvc3JjL25hdGl2ZXdpbmRvdy9jbGFzc2VzL2pvZ2Ft cC9uYXRpdmV3aW5kb3cveDExL1gxMVV0aWwuamF2YQkocmV2aXNpb24gOTEzYzZlMjVhNmM2YmVh MjU2ZjZjMjM5NDM5NTY1NjM0MjdjYzFiNCkKKysrIC4uLy4uL0FwcGxpY2F0aW9ucy9KT0dMR0lU L2pvZ2wvc3JjL25hdGl2ZXdpbmRvdy9jbGFzc2VzL2pvZ2FtcC9uYXRpdmV3aW5kb3cveDExL1gx MVV0aWwuamF2YQkocmV2aXNpb24gKQpAQCAtMzcsMTUgKzM3LDE3IEBACiBpbXBvcnQgam9nYW1w Lm5hdGl2ZXdpbmRvdy5EZWJ1ZzsKIGltcG9ydCBqb2dhbXAubmF0aXZld2luZG93Lk5XSk5JTGli TG9hZGVyOwogCi1pbXBvcnQgamF2YXgubWVkaWEubmF0aXZld2luZG93Lio7Ci0KK2ltcG9ydCBq YXZheC5tZWRpYS5uYXRpdmV3aW5kb3cuQWJzdHJhY3RHcmFwaGljc0RldmljZTsKK2ltcG9ydCBq YXZheC5tZWRpYS5uYXRpdmV3aW5kb3cuTmF0aXZlV2luZG93RXhjZXB0aW9uOworaW1wb3J0IGph dmF4Lm1lZGlhLm5hdGl2ZXdpbmRvdy5OYXRpdmVXaW5kb3dGYWN0b3J5OworaW1wb3J0IGphdmF4 Lm1lZGlhLm5hdGl2ZXdpbmRvdy5Ub29sa2l0TG9jazsKK2ltcG9ydCBqYXZheC5tZWRpYS5uYXRp dmV3aW5kb3cudXRpbC5Qb2ludDsKIGltcG9ydCBqYXZhLm5pby5CdWZmZXI7CiBpbXBvcnQgamF2 YS5uaW8uSW50QnVmZmVyOwogaW1wb3J0IGphdmEubmlvLlNob3J0QnVmZmVyOwogaW1wb3J0IGph dmEuc2VjdXJpdHkuQWNjZXNzQ29udHJvbGxlcjsKIGltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0 OwogaW1wb3J0IGphdmEudXRpbC5MaXN0OwotaW1wb3J0IGphdmF4Lm1lZGlhLm5hdGl2ZXdpbmRv dy51dGlsLlBvaW50OwogCiAvKioKICAqIENvbnRhaW5zIGEgdGhyZWFkIHNhZmUgWDExIHV0aWxp dHkgdG8gcmV0cmlldmUgZGlzcGxheSBjb25uZWN0aW9ucy4KQEAgLTQ5NiwxNCArNDk4LDE4IEBA CiAgICAgICAgIH0KICAgICB9CiAKLSAgICBwdWJsaWMgc3RhdGljIGludCBYU3luYyhsb25nIGRp c3BsYXksIGJvb2xlYW4gZGlzY2FyZCkgeworICAgIHB1YmxpYyBzdGF0aWMgaW50IFhTeW5jKCBs b25nIGRpc3BsYXksIGJvb2xlYW4gZGlzY2FyZCwgYm9vbGVhbiBsb2NrICkgeworICAgICAgaWYg KCBsb2NrICkgewogICAgICAgICBsb2NrRGVmYXVsdFRvb2xraXQoZGlzcGxheSk7CisgICAgICB9 Ci0gICAgICAgIHRyeSB7CisgICAgICB0cnkgewogICAgICAgICAgICAgcmV0dXJuIFgxMUxpYi5Y U3luYyhkaXNwbGF5LCBkaXNjYXJkKTsKICAgICAgICAgfSBmaW5hbGx5IHsKKyAgICAgICAgaWYg KCBsb2NrICkgewotICAgICAgICAgICAgdW5sb2NrRGVmYXVsdFRvb2xraXQoZGlzcGxheSk7Cisg ICAgICAgICAgdW5sb2NrRGVmYXVsdFRvb2xraXQoZGlzcGxheSk7CiAgICAgICAgIH0KLSAgICB9 CisgICAgICB9CisgICAgfQogCiAgICAgcHVibGljIHN0YXRpYyB2b2lkIFhTeW5jaHJvbml6ZShs b25nIGRpc3BsYXksIGJvb2xlYW4gb25vZmYpIHsKICAgICAgICAgbG9ja0RlZmF1bHRUb29sa2l0 KGRpc3BsYXkpOwpJbmRleDogLi4vLi4vQXBwbGljYXRpb25zL0pPR0xHSVQvam9nbC9zcmMvam9n bC9jbGFzc2VzL2pvZ2FtcC9vcGVuZ2wveDExL2dseC9YMTFHTFhDb250ZXh0LmphdmEKPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQotLS0gLi4vLi4vQXBwbGljYXRpb25zL0pPR0xHSVQvam9nbC9zcmMvam9nbC9jbGFzc2Vz L2pvZ2FtcC9vcGVuZ2wveDExL2dseC9YMTFHTFhDb250ZXh0LmphdmEJKHJldmlzaW9uIDkxM2M2 ZTI1YTZjNmJlYTI1NmY2YzIzOTQzOTU2NTYzNDI3Y2MxYjQpCisrKyAuLi8uLi9BcHBsaWNhdGlv bnMvSk9HTEdJVC9qb2dsL3NyYy9qb2dsL2NsYXNzZXMvam9nYW1wL29wZW5nbC94MTEvZ2x4L1gx MUdMWENvbnRleHQuamF2YQkocmV2aXNpb24gKQpAQCAtNDAsMjAgKzQwLDI5IEBACiAKIHBhY2th Z2Ugam9nYW1wLm9wZW5nbC54MTEuZ2x4OwogCi1pbXBvcnQgamF2YS5uaW8uKjsKLWltcG9ydCBq YXZhLnV0aWwuKjsKLQotaW1wb3J0IGphdmF4Lm1lZGlhLm9wZW5nbC4qOwotaW1wb3J0IGphdmF4 Lm1lZGlhLm5hdGl2ZXdpbmRvdy4qOwotaW1wb3J0IGphdmF4Lm1lZGlhLm5hdGl2ZXdpbmRvdy54 MTEuWDExR3JhcGhpY3NEZXZpY2U7Ci0KIGltcG9ydCBjb20uam9nYW1wLmNvbW1vbi5uaW8uQnVm ZmVyczsKIGltcG9ydCBjb20uam9nYW1wLmNvbW1vbi51dGlsLlZlcnNpb25OdW1iZXI7Ci1pbXBv cnQgam9nYW1wLm9wZW5nbC4qOwogaW1wb3J0IGNvbS5qb2dhbXAuZ2x1ZWdlbi5ydW50aW1lLlBy b2NBZGRyZXNzVGFibGU7CiBpbXBvcnQgY29tLmpvZ2FtcC5nbHVlZ2VuLnJ1bnRpbWUub3Blbmds LkdMUHJvY0FkZHJlc3NSZXNvbHZlcjsKIGltcG9ydCBqb2dhbXAubmF0aXZld2luZG93LngxMS5Y MTFVdGlsOworaW1wb3J0IGpvZ2FtcC5vcGVuZ2wuR0xDb250ZXh0SW1wbDsKK2ltcG9ydCBqb2dh bXAub3BlbmdsLkdMQ29udGV4dFNoYXJlU2V0OworaW1wb3J0IGpvZ2FtcC5vcGVuZ2wuR0xEcmF3 YWJsZUZhY3RvcnlJbXBsOworaW1wb3J0IGpvZ2FtcC5vcGVuZ2wuR0xEcmF3YWJsZUltcGw7CiAK K2ltcG9ydCBqYXZheC5tZWRpYS5uYXRpdmV3aW5kb3cuQWJzdHJhY3RHcmFwaGljc0NvbmZpZ3Vy YXRpb247CitpbXBvcnQgamF2YXgubWVkaWEubmF0aXZld2luZG93LkFic3RyYWN0R3JhcGhpY3NE ZXZpY2U7CitpbXBvcnQgamF2YXgubWVkaWEubmF0aXZld2luZG93Lk5hdGl2ZVN1cmZhY2U7Citp bXBvcnQgamF2YXgubWVkaWEubmF0aXZld2luZG93LngxMS5YMTFHcmFwaGljc0RldmljZTsKK2lt cG9ydCBqYXZheC5tZWRpYS5vcGVuZ2wuR0xDYXBhYmlsaXRpZXNJbW11dGFibGU7CitpbXBvcnQg amF2YXgubWVkaWEub3BlbmdsLkdMQ29udGV4dDsKK2ltcG9ydCBqYXZheC5tZWRpYS5vcGVuZ2wu R0xFeGNlcHRpb247CitpbXBvcnQgamF2YXgubWVkaWEub3BlbmdsLkdMUHJvZmlsZTsKK2ltcG9y dCBqYXZhLm5pby5CeXRlQnVmZmVyOworaW1wb3J0IGphdmEubmlvLkludEJ1ZmZlcjsKK2ltcG9y dCBqYXZhLnV0aWwuSGFzaE1hcDsKK2ltcG9ydCBqYXZhLnV0aWwuTWFwOworCiBwdWJsaWMgYWJz dHJhY3QgY2xhc3MgWDExR0xYQ29udGV4dCBleHRlbmRzIEdMQ29udGV4dEltcGwgewogICBwcm90 ZWN0ZWQgc3RhdGljIGZpbmFsIGJvb2xlYW4gVFJBQ0VfQ09OVEVYVF9DVVJSRU5UID0gZmFsc2U7 IC8vIHRydWU7CiAKQEAgLTI0Niw5ICsyNTUsOSBAQAogICAgIHRyeSB7CiAgICAgICAgIC8vIGNy aXRpY2FsIHBhdGgsIGEgcmVtb3RlIGRpc3BsYXkgbWlnaHQgbm90IHN1cHBvcnQgdGhpcyBjb21t YW5kLAogICAgICAgICAvLyBoZW5jZSB3ZSBuZWVkIHRvIGNhdGNoIHRoZSBYMTEgRXJyb3Igd2l0 aGluIHRoaXMgYmxvY2suCi0gICAgICAgIFgxMVV0aWwuWFN5bmMoZGlzcGxheSwgZmFsc2UpOwor ICAgICAgICBYMTFVdGlsLlhTeW5jKGRpc3BsYXksIGZhbHNlLCBpc1N1cmZhY2VMb2NraW5nKCkg KTsKICAgICAgICAgY3R4ID0gX2dsWEV4dC5nbFhDcmVhdGVDb250ZXh0QXR0cmlic0FSQihkaXNw bGF5LCBjb25maWcuZ2V0RkJDb25maWcoKSwgc2hhcmUsIGRpcmVjdCwgYXR0cmlicyk7Ci0gICAg ICAgIFgxMVV0aWwuWFN5bmMoZGlzcGxheSwgZmFsc2UpOworICAgICAgICBYMTFVdGlsLlhTeW5j KGRpc3BsYXksIGZhbHNlLCBpc1N1cmZhY2VMb2NraW5nKCkgKTsKICAgICB9IGNhdGNoIChSdW50 aW1lRXhjZXB0aW9uIHJlKSB7CiAgICAgICAgIGlmKERFQlVHKSB7CiAgICAgICAgICAgVGhyb3dh YmxlIHQgPSBuZXcgVGhyb3dhYmxlKCJJbmZvOiBYMTFHTFhDb250ZXh0LmNyZWF0ZUNvbnRleHRB UkJJbXBsIGdsWENyZWF0ZUNvbnRleHRBdHRyaWJzQVJCIGZhaWxlZCB3aXRoICIrZ2V0R0xWZXJz aW9uKG1ham9yLCBtaW5vciwgY3RwLCAiQGNyZWF0aW9uIiksIHJlKTsK