157973 2016-05-21 09:59:16 -0700 PlatformDisplay crash when calling egl_terminate 2023-04-19 15:16:01 -0700 1 1 1 Unclassified WebKit WebKitGTK Other PC Linux RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=145832 https://bugs.webkit.org/show_bug.cgi?id=174789 https://bugs.webkit.org/show_bug.cgi?id=176490 https://bugs.webkit.org/show_bug.cgi?id=255678 P2 Normal --- 81456 1 mcatanzaro webkit-unassigned bugs-noreply cgarcia hur.ims mcatanzaro zan oldest_to_newest 1195357 0 mcatanzaro 2016-05-21 09:59:16 -0700 We crash very often in the destructor of PlatformDisplayWayland when it runs in an exit handler. The effect is that the web process corresponding to a closed Epiphany tab crashes quite regularly immediately after closing tab. Normally when issues like this happen I just switch to use of NeverDestroyed, but I'm not sure if that's correct in this case. Incredibly enough, this is also somehow causing test-ephy-bookmarks to crash when run under Wayland: $ jhbuild run valgrind ./test-ephy-bookmarks ==16259== Memcheck, a memory error detector ==16259== Copyright (C) 2002-2015, and GNU GPL'd, by Julian Seward et al. ==16259== Using Valgrind-3.11.0 and LibVEX; rerun with -h for copyright info ==16259== Command: ./test-ephy-bookmarks ==16259== --16259-- warning: DiCfSI 0xa13c1e0 .. 0xa617b6f is huge; length = 5093776 (libwebkit2gtk-4.0.so.37) ==16259== Warning: set address range perms: large range [0x395d9000, 0x795db000) (noaccess) /src/bookmarks/ephy-bookmarks/create: OK /src/bookmarks/ephy-bookmarks/add: OK /src/bookmarks/ephy-bookmarks/set_address: OK ==16259== Invalid write of size 4 ==16259== at 0x18E2586F: _eglError (eglcurrent.c:240) ==16259== by 0x18E1F110: eglTerminate (eglapi.c:531) ==16259== by 0xC2D8344: WebCore::PlatformDisplay::terminateEGLDisplay() (PlatformDisplay.cpp:168) ==16259== by 0xC2D81C7: WebCore::PlatformDisplay::~PlatformDisplay() (PlatformDisplay.cpp:118) ==16259== by 0xC1E2B4B: WebCore::PlatformDisplayWayland::~PlatformDisplayWayland() (PlatformDisplayWayland.cpp:108) ==16259== by 0xC1E2B67: WebCore::PlatformDisplayWayland::~PlatformDisplayWayland() (PlatformDisplayWayland.cpp:118) ==16259== by 0xC2D8E9B: std::default_delete<WebCore::PlatformDisplay>::operator()(WebCore::PlatformDisplay*) const (unique_ptr.h:76) ==16259== by 0xC2D8952: std::unique_ptr<WebCore::PlatformDisplay, std::default_delete<WebCore::PlatformDisplay> >::~unique_ptr() (unique_ptr.h:236) ==16259== by 0x17748947: __run_exit_handlers (exit.c:82) ==16259== by 0x17748994: exit (exit.c:104) ==16259== by 0x1772F737: (below main) (libc-start.c:323) ==16259== Address 0x2909bf00 is 0 bytes inside a block of size 40 free'd ==16259== at 0x4C2CD5A: free (vg_replace_malloc.c:530) ==16259== by 0x18E253C1: _eglFiniTSD (eglcurrent.c:80) ==16259== by 0x18E267CA: _eglAtExit (eglglobals.c:68) ==16259== by 0x17748947: __run_exit_handlers (exit.c:82) ==16259== by 0x17748994: exit (exit.c:104) ==16259== by 0x1772F737: (below main) (libc-start.c:323) ==16259== Block was alloc'd at ==16259== at 0x4C2DA60: calloc (vg_replace_malloc.c:711) ==16259== by 0x18E253F6: _eglCreateThreadInfo (eglcurrent.c:124) ==16259== by 0x18E253F6: _eglGetCurrentThread.part.1 (eglcurrent.c:171) ==16259== by 0x18E25915: _eglGetCurrentThread (eglcurrent.c:151) ==16259== by 0x18E25915: _eglError (eglcurrent.c:235) ==16259== by 0x18E2163F: eglInitialize (eglapi.c:521) ==16259== by 0xC2D828E: WebCore::PlatformDisplay::initializeEGLDisplay() (PlatformDisplay.cpp:146) ==16259== by 0xC1E2A0C: WebCore::PlatformDisplayWayland::PlatformDisplayWayland(wl_display*) (PlatformDisplayWayland.cpp:95) ==16259== by 0xC1E28AC: WebCore::PlatformDisplayWayland::create() (PlatformDisplayWayland.cpp:67) ==16259== by 0xC2D8067: WebCore::PlatformDisplay::createPlatformDisplay() (PlatformDisplay.cpp:79) ==16259== by 0xC2D80D1: WebCore::PlatformDisplay::sharedDisplay()::{lambda()#1}::operator()() const (PlatformDisplay.cpp:101) ==16259== by 0xC2D85D9: void std::_Bind_simple<WebCore::PlatformDisplay::sharedDisplay()::{lambda()#1} ()>::_M_invoke<>(std::_Index_tuple<>) (functional:1400) ==16259== by 0xC2D8576: std::_Bind_simple<WebCore::PlatformDisplay::sharedDisplay()::{lambda()#1} ()>::operator()() (functional:1389) ==16259== by 0xC2D84C0: void std::__once_call_impl<std::_Bind_simple<WebCore::PlatformDisplay::sharedDisplay()::{lambda()#1} ()> >() (mutex:587) ==16259== LEAK: 1 WebProcessPool ==16259== ==16259== HEAP SUMMARY: ==16259== in use at exit: 1,850,660 bytes in 12,382 blocks ==16259== total heap usage: 43,709 allocs, 31,327 frees, 7,469,918 bytes allocated ==16259== ==16259== LEAK SUMMARY: ==16259== definitely lost: 600 bytes in 3 blocks ==16259== indirectly lost: 1,089,886 bytes in 3,789 blocks ==16259== possibly lost: 6,096 bytes in 29 blocks ==16259== still reachable: 690,526 bytes in 8,026 blocks ==16259== of which reachable via heuristic: ==16259== length64 : 4,064 bytes in 71 blocks ==16259== newarray : 2,128 bytes in 53 blocks ==16259== suppressed: 0 bytes in 0 blocks ==16259== Rerun with --leak-check=full to see details of leaked memory ==16259== ==16259== For counts of detected and suppressed errors, rerun with: -v ==16259== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) 1195358 1 mcatanzaro 2016-05-21 10:04:24 -0700 Most likely we need to add some PlatformDisplay::Destroy function to be called explicitly from... somewhere... that's not an exit handler, and switch to using NeverDestroyed. 1196997 2 cgarcia 2016-05-27 00:50:57 -0700 (In reply to comment #1) > Most likely we need to add some PlatformDisplay::Destroy function to be > called explicitly from... somewhere... that's not an exit handler, and > switch to using NeverDestroyed. To properly fix this we need to figure out why it's crashing. Workarounds will just hide the actual issue. 1196998 3 cgarcia 2016-05-27 01:02:37 -0700 This is my guess looking at mesa egl code. _eglGlobal registers two at exist callbacks one to finish the display and another one to unload drivers, the one to finish the display happens first. When our destructor is called the _eglFiniDisplay callback has already been called, so we have a valid pointer for an already finished display. Then eglTerminate tries to find the display in the global display list, but fails and for some reason it crashes when trying to return an error. The error doesn't really depend on the display, it uses thread specific data I think. But _eglGetCurrentThread should never return null, so I don't understand why it's crashing. 1197824 4 zan 2016-05-31 10:31:56 -0700 If we're committed to destructing the PlatformDisplay object, then using atexit() manually might work better than a static std::unique_ptr<> object. The PlatformDisplayWayland constructor would do the EGL initialization, setting up exit-time callbacks in Mesa. We should register the destruction of this object with atexit() afterwards, since the callbacks passed to atexit() are called in reverse order. This showcases the problem: https://www.ibm.com/developerworks/community/blogs/5894415f-be62-4bc0-81c5-3956e82276f3/entry/be_careful_when_using_the_atexit_routine_with_static_objects?lang=en 1198119 5 280228 cgarcia 2016-06-01 04:02:45 -0700 Created attachment 280228 Patch Could someone try this to confirm it works? 1198124 6 280228 mcatanzaro 2016-06-01 05:27:35 -0700 Comment on attachment 280228 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=280228&action=review I confirm it fixes at least the crash running test-ephy-bookmarks. Awesome, thanks. > Source/WebCore/platform/graphics/PlatformDisplay.cpp:171 > + std::atexit([] { PlatformDisplay::sharedDisplay().terminateEGLDisplay(); }); This is harmless, but not really great, since it means terminateEGLDisplay will be redundantly called on the sharedDisplay once for each time initializeEGLDisplay is called on ANY PlatformDisplay object. Perhaps it would it make sense to check if this == PlatformDisplay::sharedDisplay before registering the atexit handler here. Alternatively, and probably better, move this to inside the lambda in PlatformDisplay::sharedDisplay, where it will be called at most once. Or, perhaps the best option is to call terminateEGLDisplay on the current PlatformDisplay (i.e. |this| rather than the sharedDisplay) and remove the call to terminateEGLDisplay from the destructor. 1198130 7 280228 zan 2016-06-01 06:30:07 -0700 Comment on attachment 280228 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=280228&action=review >> Source/WebCore/platform/graphics/PlatformDisplay.cpp:171 >> + std::atexit([] { PlatformDisplay::sharedDisplay().terminateEGLDisplay(); }); > > This is harmless, but not really great, since it means terminateEGLDisplay will be redundantly called on the sharedDisplay once for each time initializeEGLDisplay is called on ANY PlatformDisplay object. Perhaps it would it make sense to check if this == PlatformDisplay::sharedDisplay before registering the atexit handler here. Alternatively, and probably better, move this to inside the lambda in PlatformDisplay::sharedDisplay, where it will be called at most once. Or, perhaps the best option is to call terminateEGLDisplay on the current PlatformDisplay (i.e. |this| rather than the sharedDisplay) and remove the call to terminateEGLDisplay from the destructor. Only PlatformDisplay::sharedDisplay() should ever live during the program lifetime, so this method would only be called only once as well. Asserting !m_eglDisplayInitialized at the beginning here would be helpful in that regard. 1198145 8 mcatanzaro 2016-06-01 07:40:54 -0700 (In reply to comment #7) > Only PlatformDisplay::sharedDisplay() should ever live during the program > lifetime, so this method would only be called only once as well. Asserting > !m_eglDisplayInitialized at the beginning here would be helpful in that > regard. Are you saying that this class is intended to be a singleton? If so, then it should use our normal singleton naming convention (PlatformDisplay::singleton rather than PlatformDisplay::sharedDisplay), and should have nothing in its destructor (as it would never make sense to call egl_terminate there if it's always scheduled by atexit), and terminateEGLDisplay should be called on the this pointer rather than sharedDisplay for readability. If it's not supposed to be a singleton, then the assert you suggested would be inappropriate. 1198152 9 cgarcia 2016-06-01 08:45:30 -0700 The constructor is private (well, protected) so yes, it's indeed a singleton, but we really want to close displays, when needed, and that's why it's not NeverDestroyed. I agree that if we terminate in the atexit, it doesn't make sense to terminate again the destructor, since the atexit should always happen first. We can't capture this on a lambda for a pointer function. 1198156 10 280238 cgarcia 2016-06-01 08:56:11 -0700 Created attachment 280238 Updated patch 1198173 11 280238 mcatanzaro 2016-06-01 09:23:43 -0700 Comment on attachment 280238 Updated patch View in context: https://bugs.webkit.org/attachment.cgi?id=280238&action=review OK. > Source/WebCore/platform/graphics/PlatformDisplay.cpp:169 > + std::atexit([] { PlatformDisplay::sharedDisplay().terminateEGLDisplay(); }); Since this is not a static function, I think it make more sense to not use PlatformDisplay::sharedDisplay() here. You say you cannot capture |this| here, but I don't understand why not; did you try writing it this way: std::atexit([this] { this->terminateEGLDisplay(); }); 1198472 12 280238 zan 2016-06-02 00:04:42 -0700 Comment on attachment 280238 Updated patch View in context: https://bugs.webkit.org/attachment.cgi?id=280238&action=review >> Source/WebCore/platform/graphics/PlatformDisplay.cpp:169 >> + std::atexit([] { PlatformDisplay::sharedDisplay().terminateEGLDisplay(); }); > > Since this is not a static function, I think it make more sense to not use PlatformDisplay::sharedDisplay() here. You say you cannot capture |this| here, but I don't understand why not; did you try writing it this way: > > std::atexit([this] { this->terminateEGLDisplay(); }); std::atexit() has to be passed a function pointer to a static function, since it only stores the pointer, not the whole function object. Only capture-less lambdas can be passed as such arguments, since they have the conversion operator that converts to a function pointer. http://en.cppreference.com/w/cpp/language/lambda -- see ClosureType::operator ret(*)(params)() In such cases compiler simply generates a bare struct with the call operator and this conversion operator, since it has no state to manage because nothing is captured. You'd basically be able to call the struct's call operator as if it was any other static non-method function. If anything is captured, then lambda implies an actual object of that helper struct type, generating all the relevant constructors and destructors, plus you have to address the lifetime management (limited to scope or storable to std::function<> for delayed use). 1198479 13 cgarcia 2016-06-02 00:35:16 -0700 Committed r201595: <http://trac.webkit.org/changeset/201595> 1331654 14 mcatanzaro 2017-07-24 09:47:16 -0700 Looks like this has somehow returned in bug #174789. 280228 2016-06-01 04:02:45 -0700 2016-06-01 08:56:11 -0700 Patch wk2-wayland-display-crash.diff text/plain 2642 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAzNDBiOWNjLi5jMTFlNzFjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIg QEAKKzIwMTYtMDYtMDEgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgorCisgICAgICAgIFtXYXlsYW5kXSBQbGF0Zm9ybURpc3BsYXlXYXlsYW5kIGRlc3RydWN0b3Ig aXMgc3VwZXIgY3Jhc2h5CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xNTc5NzMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBFR0wgcmVnaXN0ZXJzIHR3byBhdCBleGlzdCBjYWxsYmFja3Mgb25lIHRvIGZpbmlz aCB0aGUgZGlzcGxheSBhbmQgYW5vdGhlciBvbmUgdG8gdW5sb2FkIGRyaXZlcnMsIHRoZSBvbmUg dG8KKyAgICAgICAgZmluaXNoIHRoZSBkaXNwbGF5IGhhcHBlbnMgZmlyc3QuIFdoZW4gb3VyIGRl c3RydWN0b3IgaXMgY2FsbGVkIHRoZSBfZWdsRmluaURpc3BsYXkgY2FsbGJhY2sgaGFzIGFscmVh ZHkgYmVlbgorICAgICAgICBjYWxsZWQsIHNvIHdlIGhhdmUgYSB2YWxpZCBwb2ludGVyIGZvciBh biBhbHJlYWR5IGZpbmlzaGVkIGRpc3BsYXkuIFRoZW4gZWdsVGVybWluYXRlIHRyaWVzIHRvIGZp bmQgdGhlIGRpc3BsYXkKKyAgICAgICAgaW4gdGhlIGdsb2JhbCBkaXNwbGF5IGxpc3QsIGJ1dCBm YWlscyBhbmQgZm9yIHNvbWUgcmVhc29uIGl0IGNyYXNoZXMgd2hlbiB0cnlpbmcgdG8gcmV0dXJu IGFuIGVycm9yLgorICAgICAgICBJZiBhdGV4aXQgaXMgY2FsbGVkIGFmdGVyIHRoZSBnbG9iYWwg UGxhdGZvcm1EaXNwbGF5IGNvbnN0cnVjdG9yLCB0aGUgYXRleGl0IGhhbmRsZXIgaXMgY2FsbGVk IGJlZm9yZSB0aGUKKyAgICAgICAgZGVzdHJ1Y3Rvci4gVGhlIGF0ZXhpdCBjYWxsYmFja3MgYXJl IGNhbGxlZCBpbiByZXZlcnNlIG9yZGVyLCBzbyBpZiB3ZSByZWdpc3RlciBhbiBhdGV4aXQgaGFu ZGxlciBhZnRlciB0aGUKKyAgICAgICAgZ2xvYmFsIGluc3RhY2UgaGFzIGJlZW4gY3JlYXRlZCBh bmQgYWZ0ZXIgRUdMIGhhcyBiZWVuIGluaXRpYWxpemVkLCB3ZSBjb3VsZCB0ZXJtaW5hdGUgdGhl IEVHTCBkaXNwbGF5IGJlZm9yZQorICAgICAgICB0aGUgRUdMIGF0ZXhpdCBoYW5kbGVycyBhbmQg dGhlIGdsb2JhbCBQbGF0Zm9ybURpc3BsYXkgZGVzdHJ1Y3Rvci4KKworICAgICAgICAqIHBsYXRm b3JtL2dyYXBoaWNzL1BsYXRmb3JtRGlzcGxheS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQbGF0 Zm9ybURpc3BsYXk6OmluaXRpYWxpemVFR0xEaXNwbGF5KToKKwogMjAxNi0wNi0wMSAgUGVyIEFy bmUgVm9sbGFuICA8cHZvbGxhbkBhcHBsZS5jb20+CiAKICAgICAgICAgW1dpbl1bSW5kZXhlZERC XSBDcmFzaCB3aGVuIHJ1bm5pbmcgYmxvYiB0ZXN0LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGxhdGZvcm1EaXNwbGF5LmNwcCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL1BsYXRmb3JtRGlzcGxheS5jcHAKaW5kZXggMTlhNmI5OS4uNzAx YzAxZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGxhdGZv cm1EaXNwbGF5LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QbGF0 Zm9ybURpc3BsYXkuY3BwCkBAIC0xNTksNiArMTU5LDE2IEBAIHZvaWQgUGxhdGZvcm1EaXNwbGF5 Ojppbml0aWFsaXplRUdMRGlzcGxheSgpCiAgICAgICAgIHRlcm1pbmF0ZUVHTERpc3BsYXkoKTsK ICAgICAgICAgcmV0dXJuOwogICAgIH0KKworICAgIC8vIEVHTCByZWdpc3RlcnMgYXRleGl0IGhh bmRsZXJzIHRvIGNsZWFudXAgaXRzIGdsb2JhbCBkaXNwbGF5IGxpc3QuCisgICAgLy8gU2luY2Ug dGhlIGdsb2JhbCBQbGF0Zm9ybURpc3BsYXkgaW5zdGFuY2UgaXMgY3JlYXRlZCBiZWZvcmUsCisg ICAgLy8gd2hlbiB0aGUgUGxhdGZvcm1EaXNwbGF5IGRlc3RydWN0b3IgaXMgY2FsbGVkLCBFR0wg aGFzIGFscmVhZHkgcmVtb3ZlZCB0aGUKKyAgICAvLyBkaXNwbGF5IGZyb20gdGhlIGxpc3QsIGNh dXNpbmcgZWdsVGVybWluYXRlKCkgdG8gY3Jhc2guIFNvLCBoZXJlIHdlIHJlZ2lzdGVyCisgICAg Ly8gb3VyIG93biBhdGV4aXQgaGFuZGxlciwgYWZ0ZXIgRUdMIGhhcyBiZWVuIGluaXRpYWxpemVk IGFuZCBhZnRlciB0aGUgZ2xvYmFsCisgICAgLy8gaW5zdGFuY2UgaGFzIGJlZW4gY3JlYXRlZCB0 byBlbnN1cmUgd2UgY2FsbCBlZ2xUZXJtaW5hdGUoKSBiZWZvcmUgdGhlIG90aGVyCisgICAgLy8g RUdMIGF0ZXhpdCBoYW5kbGVycyBhbmQgdGhlIFBsYXRmb3JtRGlzcGxheSBkZXN0cnVjdG9yLgor ICAgIC8vIFNlZSBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTU3OTcz LgorICAgIHN0ZDo6YXRleGl0KFtdIHsgUGxhdGZvcm1EaXNwbGF5OjpzaGFyZWREaXNwbGF5KCku dGVybWluYXRlRUdMRGlzcGxheSgpOyB9KTsKIH0KIAogdm9pZCBQbGF0Zm9ybURpc3BsYXk6OnRl cm1pbmF0ZUVHTERpc3BsYXkoKQo= 280238 2016-06-01 08:56:11 -0700 2016-06-01 09:23:43 -0700 Updated patch wk2-wayland-display-crash.diff text/plain 3092 cgarcia ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCA1ZWIwYjAwLi4xMTExOThiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjIg QEAKKzIwMTYtMDYtMDEgIENhcmxvcyBHYXJjaWEgQ2FtcG9zICA8Y2dhcmNpYUBpZ2FsaWEuY29t PgorCisgICAgICAgIFtXYXlsYW5kXSBQbGF0Zm9ybURpc3BsYXlXYXlsYW5kIGRlc3RydWN0b3Ig aXMgc3VwZXIgY3Jhc2h5CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0xNTc5NzMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBFR0wgcmVnaXN0ZXJzIHR3byBhdCBleGlzdCBjYWxsYmFja3Mgb25lIHRvIGZpbmlz aCB0aGUgZGlzcGxheSBhbmQgYW5vdGhlciBvbmUgdG8gdW5sb2FkIGRyaXZlcnMsIHRoZSBvbmUg dG8KKyAgICAgICAgZmluaXNoIHRoZSBkaXNwbGF5IGhhcHBlbnMgZmlyc3QuIFdoZW4gb3VyIGRl c3RydWN0b3IgaXMgY2FsbGVkIHRoZSBfZWdsRmluaURpc3BsYXkgY2FsbGJhY2sgaGFzIGFscmVh ZHkgYmVlbgorICAgICAgICBjYWxsZWQsIHNvIHdlIGhhdmUgYSB2YWxpZCBwb2ludGVyIGZvciBh biBhbHJlYWR5IGZpbmlzaGVkIGRpc3BsYXkuIFRoZW4gZWdsVGVybWluYXRlIHRyaWVzIHRvIGZp bmQgdGhlIGRpc3BsYXkKKyAgICAgICAgaW4gdGhlIGdsb2JhbCBkaXNwbGF5IGxpc3QsIGJ1dCBm YWlscyBhbmQgZm9yIHNvbWUgcmVhc29uIGl0IGNyYXNoZXMgd2hlbiB0cnlpbmcgdG8gcmV0dXJu IGFuIGVycm9yLgorICAgICAgICBJZiBhdGV4aXQgaXMgY2FsbGVkIGFmdGVyIHRoZSBnbG9iYWwg UGxhdGZvcm1EaXNwbGF5IGNvbnN0cnVjdG9yLCB0aGUgYXRleGl0IGhhbmRsZXIgaXMgY2FsbGVk IGJlZm9yZSB0aGUKKyAgICAgICAgZGVzdHJ1Y3Rvci4gVGhlIGF0ZXhpdCBjYWxsYmFja3MgYXJl IGNhbGxlZCBpbiByZXZlcnNlIG9yZGVyLCBzbyBpZiB3ZSByZWdpc3RlciBhbiBhdGV4aXQgaGFu ZGxlciBhZnRlciB0aGUKKyAgICAgICAgZ2xvYmFsIGluc3RhY2UgaGFzIGJlZW4gY3JlYXRlZCBh bmQgYWZ0ZXIgRUdMIGhhcyBiZWVuIGluaXRpYWxpemVkLCB3ZSBjb3VsZCB0ZXJtaW5hdGUgdGhl IEVHTCBkaXNwbGF5IGJlZm9yZQorICAgICAgICB0aGUgRUdMIGF0ZXhpdCBoYW5kbGVycyBhbmQg dGhlIGdsb2JhbCBQbGF0Zm9ybURpc3BsYXkgZGVzdHJ1Y3Rvci4KKworICAgICAgICAqIHBsYXRm b3JtL2dyYXBoaWNzL1BsYXRmb3JtRGlzcGxheS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQbGF0 Zm9ybURpc3BsYXk6OmluaXRpYWxpemVFR0xEaXNwbGF5KToKKwogMjAxNi0wNi0wMSAgQW50dGkg S29pdmlzdG8gIDxhbnR0aUBhcHBsZS5jb20+CiAKICAgICAgICAgUmVtb3ZlIGFjY2lkZW50YWwg ZnByaW50Zi4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1Bs YXRmb3JtRGlzcGxheS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9QbGF0 Zm9ybURpc3BsYXkuY3BwCmluZGV4IDE5YTZiOTkuLjhkNWM3ZDMgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL1BsYXRmb3JtRGlzcGxheS5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvUGxhdGZvcm1EaXNwbGF5LmNwcApAQCAtMTEy LDEwICsxMTIsOCBAQCBQbGF0Zm9ybURpc3BsYXk6OlBsYXRmb3JtRGlzcGxheSgpCiAKIFBsYXRm b3JtRGlzcGxheTo6flBsYXRmb3JtRGlzcGxheSgpCiB7Ci0gICAgLy8gV2luQ2Fpcm8gY3Jhc2hl cyB3aGVuIHRlcm1pbmF0aW5nIEVHTCBvbiBleGl0LgotICAgIC8vIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNDU4MzIKLSNpZiBVU0UoRUdMKSAmJiAhUExBVEZPUk0o V0lOKQotICAgIHRlcm1pbmF0ZUVHTERpc3BsYXkoKTsKKyNpZiBVU0UoRUdMKQorICAgIEFTU0VS VChtX2VnbERpc3BsYXkgPT0gRUdMX05PX0RJU1BMQVkpOwogI2VuZGlmCiB9CiAKQEAgLTE1OSwx MCArMTU3LDIxIEBAIHZvaWQgUGxhdGZvcm1EaXNwbGF5Ojppbml0aWFsaXplRUdMRGlzcGxheSgp CiAgICAgICAgIHRlcm1pbmF0ZUVHTERpc3BsYXkoKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0K KworICAgIC8vIEVHTCByZWdpc3RlcnMgYXRleGl0IGhhbmRsZXJzIHRvIGNsZWFudXAgaXRzIGds b2JhbCBkaXNwbGF5IGxpc3QuCisgICAgLy8gU2luY2UgdGhlIGdsb2JhbCBQbGF0Zm9ybURpc3Bs YXkgaW5zdGFuY2UgaXMgY3JlYXRlZCBiZWZvcmUsCisgICAgLy8gd2hlbiB0aGUgUGxhdGZvcm1E aXNwbGF5IGRlc3RydWN0b3IgaXMgY2FsbGVkLCBFR0wgaGFzIGFscmVhZHkgcmVtb3ZlZCB0aGUK KyAgICAvLyBkaXNwbGF5IGZyb20gdGhlIGxpc3QsIGNhdXNpbmcgZWdsVGVybWluYXRlKCkgdG8g Y3Jhc2guIFNvLCBoZXJlIHdlIHJlZ2lzdGVyCisgICAgLy8gb3VyIG93biBhdGV4aXQgaGFuZGxl ciwgYWZ0ZXIgRUdMIGhhcyBiZWVuIGluaXRpYWxpemVkIGFuZCBhZnRlciB0aGUgZ2xvYmFsCisg ICAgLy8gaW5zdGFuY2UgaGFzIGJlZW4gY3JlYXRlZCB0byBlbnN1cmUgd2UgY2FsbCBlZ2xUZXJt aW5hdGUoKSBiZWZvcmUgdGhlIG90aGVyCisgICAgLy8gRUdMIGF0ZXhpdCBoYW5kbGVycyBhbmQg dGhlIFBsYXRmb3JtRGlzcGxheSBkZXN0cnVjdG9yLgorICAgIC8vIFNlZSBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTU3OTczLgorICAgIHN0ZDo6YXRleGl0KFtdIHsg UGxhdGZvcm1EaXNwbGF5OjpzaGFyZWREaXNwbGF5KCkudGVybWluYXRlRUdMRGlzcGxheSgpOyB9 KTsKIH0KIAogdm9pZCBQbGF0Zm9ybURpc3BsYXk6OnRlcm1pbmF0ZUVHTERpc3BsYXkoKQogewor ICAgIEFTU0VSVChtX2VnbERpc3BsYXlJbml0aWFsaXplZCk7CiAgICAgaWYgKG1fZWdsRGlzcGxh eSA9PSBFR0xfTk9fRElTUExBWSkKICAgICAgICAgcmV0dXJuOwogICAgIGVnbFRlcm1pbmF0ZSht X2VnbERpc3BsYXkpOwo=