234293 2021-12-14 04:45:23 -0800 [GTK] Use libgbm and the ANGLE gbm backend to fix initialisation 2021-12-15 08:36:17 -0800 1 1 1 Unclassified WebKit WebGL WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=234239 InRadar P2 Normal --- 1 clord clord alex annulen dino don.olmstead ews-watchlist fujii gyuyoung.kim kbr kkinnunen koivisto kondapallykalyan mmaxfield ryuan.choi sergio webkit-bug-importer oldest_to_newest 1823961 0 clord 2021-12-14 04:45:23 -0800 Once you build with ANGLE-WebGL enabled with GTK, the web process crashes upon initialising an ANGLE context. A couple of small fixes are need to enable its basic functionality. 1823962 1 447122 clord 2021-12-14 04:49:40 -0800 Created attachment 447122 Patch 1823969 2 447122 kkinnunen 2021-12-14 05:26:21 -0800 Comment on attachment 447122 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=447122&action=review I suppose it's ok to prevent crashes. I think the commit message could be better and optimally there should be no additional ifdefs > Source/WebCore/ChangeLog:8 > + Fix ANGLE initialisation and drawing buffer binding on GTK. If it's intended to initialize using EGL specifically, then the commit message could be more verbose as to explain what's happening. So below I'll recommend using shared default initialisation, but I don't exactly know why it doesn't work for GTK .. > Source/WebCore/platform/graphics/nicosia/texmap/NicosiaGCGLANGLELayer.cpp:77 > + EGL_PLATFORM_ANGLE_TYPE_ANGLE, EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE, Without any further knowledge, it's hard to understand why GLES is forced. I'd imagine would be better to use the default one.. Would EGL_PLATFORM_ANGLE_TYPE_ANGLE == EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE work? if so, you can call GetPlatformDisplayExt and provide nullptr displayAttributes. > Source/WebCore/platform/graphics/nicosia/texmap/NicosiaGCGLANGLELayer.cpp:81 > + EGLDisplay display = EGL_GetPlatformDisplay(EGL_PLATFORM_ANGLE_ANGLE, EGL_DEFAULT_DISPLAY, displayAttributes); Could you call GetPlatformDisplayExt? > Source/WebCore/platform/graphics/nicosia/texmap/NicosiaGCGLANGLELayer.cpp:84 > +#endif If the above would work, you could try if all ports using this file could share the initialisation. EGL_GetDisplay is implemented with same code as GetPlatformDisplayExt 1824001 3 clord 2021-12-14 07:56:52 -0800 (In reply to Kimmo Kinnunen from comment #2) > Comment on attachment 447122 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=447122&action=review > > I suppose it's ok to prevent crashes. I think the commit message could be > better and optimally there should be no additional ifdefs > > > Source/WebCore/ChangeLog:8 > > + Fix ANGLE initialisation and drawing buffer binding on GTK. > > If it's intended to initialize using EGL specifically, then the commit > message could be more verbose as to explain what's happening. > > So below I'll recommend using shared default initialisation, but I don't > exactly know why it doesn't work for GTK .. > > > Source/WebCore/platform/graphics/nicosia/texmap/NicosiaGCGLANGLELayer.cpp:77 > > + EGL_PLATFORM_ANGLE_TYPE_ANGLE, EGL_PLATFORM_ANGLE_TYPE_OPENGLES_ANGLE, > > Without any further knowledge, it's hard to understand why GLES is forced. > I'd imagine would be better to use the default one.. > > Would EGL_PLATFORM_ANGLE_TYPE_ANGLE == EGL_PLATFORM_ANGLE_TYPE_DEFAULT_ANGLE > work? > if so, you can call GetPlatformDisplayExt and provide nullptr > displayAttributes. > > > Source/WebCore/platform/graphics/nicosia/texmap/NicosiaGCGLANGLELayer.cpp:81 > > + EGLDisplay display = EGL_GetPlatformDisplay(EGL_PLATFORM_ANGLE_ANGLE, EGL_DEFAULT_DISPLAY, displayAttributes); > > Could you call GetPlatformDisplayExt? > > > Source/WebCore/platform/graphics/nicosia/texmap/NicosiaGCGLANGLELayer.cpp:84 > > +#endif > > If the above would work, you could try if all ports using this file could > share the initialisation. > > EGL_GetDisplay is implemented with same code as GetPlatformDisplayExt I couldn't get any combination of parameters using EGL_GetPlatformDisplayEXT working - there's no need to specify ANGLE_TYPE_OPENGLES_ANGLE when using GetPlatformDisplay, so that's redundant, but as you pointed out on Slack, specifying DEVICE_TYPE_EGL_ANGLE is probably forcing that choice anyway. Without this, the X11 backend is used and that segfaults due to a prior GL error in rx::nativegl_gl::GenerateTextureFormatCaps during EGL_Initialize. I don't know that we'd want to be using the X11 backend at all, but I haven't found out yet how to alter the build to force ANGLE not to build the X11 backend. 1824061 4 447122 don.olmstead 2021-12-14 11:47:51 -0800 Comment on attachment 447122 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=447122&action=review Just a nit and an open question > Source/WebCore/platform/graphics/angle/GraphicsContextGLANGLE.cpp:76 > -#if PLATFORM(WIN) > +#if PLATFORM(WIN) || PLATFORM(GTK) Wouldn't !PLATFORM(COCOA) be more appropriate here? I'm assuming WPE will eventually end up with ANGLE support. >> Source/WebCore/platform/graphics/nicosia/texmap/NicosiaGCGLANGLELayer.cpp:84 >> +#endif > > If the above would work, you could try if all ports using this file could share the initialisation. > > EGL_GetDisplay is implemented with same code as GetPlatformDisplayExt Not specific to this patch but considering all the ANGLE specific classes and then needing even additional platform specific code hanging out I'm really wondering if we're abstracting at the right point. Right after the Blink split Brandon Jones did an article on how all the GraphicsContext classes were able to be collapsed and now we're adding ANGLE and expanding the class hierarchy. At one point I swore we had a gl:: namespace being generated from ANGLE and it really felt to me like we should have all GL calls going through that namespace and abstract at that point where its either a OpenGL ES 2/3 provided by system or provided by ANGLE. Just mentioning here in case anyone working on this would be interested in trying that route. 1824129 5 447122 kbr 2021-12-14 14:24:48 -0800 Comment on attachment 447122 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=447122&action=review >>> Source/WebCore/platform/graphics/nicosia/texmap/NicosiaGCGLANGLELayer.cpp:84 >>> +#endif >> >> If the above would work, you could try if all ports using this file could share the initialisation. >> >> EGL_GetDisplay is implemented with same code as GetPlatformDisplayExt > > Not specific to this patch but considering all the ANGLE specific classes and then needing even additional platform specific code hanging out I'm really wondering if we're abstracting at the right point. Right after the Blink split Brandon Jones did an article on how all the GraphicsContext classes were able to be collapsed and now we're adding ANGLE and expanding the class hierarchy. At one point I swore we had a gl:: namespace being generated from ANGLE and it really felt to me like we should have all GL calls going through that namespace and abstract at that point where its either a OpenGL ES 2/3 provided by system or provided by ANGLE. Just mentioning here in case anyone working on this would be interested in trying that route. I'd like to suggest that doing this shimming to make the system OpenGL look like ANGLE's OpenGL would obfuscate what the code is doing. During the initial development of WebKit's ANGLE port we ran into multiple situations where legacy code was accidentally punching through ANGLE's layer and talking directly with the system OpenGL - which breaks ANGLE's state tracking and can lead to crashes. Making the system OpenGL look like ANGLE will cause accidents, in my experience. Instead, I would suggest pushing forward with this port, and once it's done, just delete the non-ANGLE code paths. ANGLE is a robust dependency; it provides a well-tested OpenGL ES implementation, and offers the chance to evolve off of underlying OpenGL implementations in favor of Direct3D, Metal and Vulkan. 1824202 6 447122 mmaxfield 2021-12-14 18:11:16 -0800 Comment on attachment 447122 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=447122&action=review >>>> Source/WebCore/platform/graphics/nicosia/texmap/NicosiaGCGLANGLELayer.cpp:84 >>>> +#endif >>> >>> If the above would work, you could try if all ports using this file could share the initialisation. >>> >>> EGL_GetDisplay is implemented with same code as GetPlatformDisplayExt >> >> Not specific to this patch but considering all the ANGLE specific classes and then needing even additional platform specific code hanging out I'm really wondering if we're abstracting at the right point. Right after the Blink split Brandon Jones did an article on how all the GraphicsContext classes were able to be collapsed and now we're adding ANGLE and expanding the class hierarchy. At one point I swore we had a gl:: namespace being generated from ANGLE and it really felt to me like we should have all GL calls going through that namespace and abstract at that point where its either a OpenGL ES 2/3 provided by system or provided by ANGLE. Just mentioning here in case anyone working on this would be interested in trying that route. > > I'd like to suggest that doing this shimming to make the system OpenGL look like ANGLE's OpenGL would obfuscate what the code is doing. During the initial development of WebKit's ANGLE port we ran into multiple situations where legacy code was accidentally punching through ANGLE's layer and talking directly with the system OpenGL - which breaks ANGLE's state tracking and can lead to crashes. Making the system OpenGL look like ANGLE will cause accidents, in my experience. > > Instead, I would suggest pushing forward with this port, and once it's done, just delete the non-ANGLE code paths. ANGLE is a robust dependency; it provides a well-tested OpenGL ES implementation, and offers the chance to evolve off of underlying OpenGL implementations in favor of Direct3D, Metal and Vulkan. > During the initial development of WebKit's ANGLE port we ran into multiple situations where legacy code was accidentally punching through ANGLE's layer I'm not sure if having two subtly different copies of the WebGL API is the right solution to this problem. It seems like a build-time step to statically validate correct usage would work better. 1824204 7 mmaxfield 2021-12-14 18:12:43 -0800 > I'm not sure if having two subtly different copies of the WebGL API is the > right solution to this problem. It seems like a build-time step to > statically validate correct usage would work better. *** OpenGL (ES) API 1824211 8 don.olmstead 2021-12-14 19:01:03 -0800 (In reply to Kenneth Russell from comment #5) > Comment on attachment 447122 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=447122&action=review > > >>> Source/WebCore/platform/graphics/nicosia/texmap/NicosiaGCGLANGLELayer.cpp:84 > >>> +#endif > >> > >> If the above would work, you could try if all ports using this file could share the initialisation. > >> > >> EGL_GetDisplay is implemented with same code as GetPlatformDisplayExt > > > > Not specific to this patch but considering all the ANGLE specific classes and then needing even additional platform specific code hanging out I'm really wondering if we're abstracting at the right point. Right after the Blink split Brandon Jones did an article on how all the GraphicsContext classes were able to be collapsed and now we're adding ANGLE and expanding the class hierarchy. At one point I swore we had a gl:: namespace being generated from ANGLE and it really felt to me like we should have all GL calls going through that namespace and abstract at that point where its either a OpenGL ES 2/3 provided by system or provided by ANGLE. Just mentioning here in case anyone working on this would be interested in trying that route. > > I'd like to suggest that doing this shimming to make the system OpenGL look > like ANGLE's OpenGL would obfuscate what the code is doing. During the > initial development of WebKit's ANGLE port we ran into multiple situations > where legacy code was accidentally punching through ANGLE's layer and > talking directly with the system OpenGL - which breaks ANGLE's state > tracking and can lead to crashes. Making the system OpenGL look like ANGLE > will cause accidents, in my experience. > > Instead, I would suggest pushing forward with this port, and once it's done, > just delete the non-ANGLE code paths. ANGLE is a robust dependency; it > provides a well-tested OpenGL ES implementation, and offers the chance to > evolve off of underlying OpenGL implementations in favor of Direct3D, Metal > and Vulkan. I completely understand that punching through ANGLE's layer and talking to the system OpenGL is bad news. Wouldn't making a <pal/OpenGL.h> that declared OpenGL functions in a namespace, e.g. glFoo -> gl::foo, replacing all uses of glFoo with gl::foo, and having gl::foo go through ANGLE or system GL dependent on the value of USE_ANGLE, solve this concern? Why not just make a hard requirement to have an OpenGL ES implementation, that is either ANGLE or system provided, and make sure that all calls go through that implementation? As an aside I do understand that all WebGL spec conformance is pushed into the ANGLE layer so if you want WebGL then you need to use ANGLE, but if you just need an OpenGL ES implementation and have a system one then there's no reason to have anything go through ANGLE. 1824219 9 fujii 2021-12-14 19:42:57 -0800 (In reply to Don Olmstead from comment #8) > I completely understand that punching through ANGLE's layer and talking to > the system OpenGL is bad news. Wouldn't making a <pal/OpenGL.h> that > declared OpenGL functions in a namespace, e.g. glFoo -> gl::foo, replacing > all uses of glFoo with gl::foo, and having gl::foo go through ANGLE or > system GL dependent on the value of USE_ANGLE, solve this concern? The new ANGLE no longer use 'gl::' namespace, but 'GL_' prefix. With USE_ANGLE_WEBGL CMake option, GTK port is using ANGLE for WebGL, and system OpenGL for the compositor simultaneously. Statically switching by USE_ANGLE macro approach can't solve it. > Why not just make a hard requirement to have an OpenGL ES implementation, > that is either ANGLE or system provided, and make sure that all calls go > through that implementation? ANGLE OpenGL backend isn't thread-safe. So, GTK and WPE ports want to use OpenGL/ES both in the main thread and the compositor thread of web process. Eleni's video is the best summary what is the problem for adopting ANGLE for GTK/WPE WebGL, and how to solve the problem. (Bug 225563 comment 6) 1824278 10 mmaxfield 2021-12-15 01:18:44 -0800 Are you willing to make every GL function virtual? This sounds like a job for inheritance. 1824288 11 kkinnunen 2021-12-15 02:01:59 -0800 (In reply to Don Olmstead from comment #4) > Not specific to this patch but considering all the ANGLE specific classes > and then needing even additional platform specific code hanging out I'm > really wondering if we're abstracting at the right point. Right after the > Blink split Brandon Jones did an article on how all the GraphicsContext > classes were able to be collapsed and now we're adding ANGLE and expanding > the class hierarchy. There is no "expanding the class hierarchy" being done. There is (most likely) ever only two working implementations of GraphicsContextGL: - Remote - In-process via ANGLE (until this can be removed, when it can) There are platform-specific details in these, but this is business as usual and shouldn't be seen as needless proliferation of class hierarchy. This bug is about fixing ANGLE initialisation for WebGL implementation purposes. Whatever the various port-specific compositors are using are design decisions of the port specific compositor implementations. I propose these should be designed in the design bugs of the port specific compositors. 1824310 12 clord 2021-12-15 03:53:50 -0800 Ok, so taking a slightly different tac that I hope is more amenable to everyone - if we use the ANGLE libgbm backend, that makes it X11/Wayland agnostic and also fixes the default display initialisation. Rather than add #ifdefs in the code, we can change the build and remove the X11-specific bits in favour of gbm/libdrm. 1824311 13 447219 clord 2021-12-15 04:00:07 -0800 Created attachment 447219 Patch 1824314 14 447220 clord 2021-12-15 04:25:45 -0800 Created attachment 447220 Patch 1824316 15 ews-watchlist 2021-12-15 04:26:48 -0800 Note that there are important steps to take when updating ANGLE. See https://trac.webkit.org/wiki/UpdatingANGLE 1824366 16 ews-feeder 2021-12-15 08:35:00 -0800 Committed r287075 (245270@main): <https://commits.webkit.org/245270@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 447220. 1824367 17 webkit-bug-importer 2021-12-15 08:36:17 -0800 <rdar://problem/86524504> 447122 2021-12-14 04:49:40 -0800 2021-12-15 04:00:02 -0800 Patch bug-234293-20211214124938.patch text/plain 2728 clord U3VidmVyc2lvbiBSZXZpc2lvbjogMjg3MDIxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMmVkMjVkMmM1MTczMTQ4 ZGI0ZWExZThhMjc3YThjZDBiZGNkNzAyOC4uNTA2OTBkYWRiMWViOGM1NTllMTYzNjQ1NjBjMzJi NzgyZjRlMTRiMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE3IEBACisyMDIxLTEyLTE0ICBDaHJp cyBMb3JkICA8Y2xvcmRAaWdhbGlhLmNvbT4KKworICAgICAgICBbR1RLXSBGaXggQU5HTEUgaW5p dGlhbGlzYXRpb24gYW5kIGRyYXdpbmcKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTIzNDI5MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEZpeCBBTkdMRSBpbml0aWFsaXNhdGlvbiBhbmQgZHJhd2luZyBidWZm ZXIgYmluZGluZyBvbiBHVEsuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9hbmdsZS9H cmFwaGljc0NvbnRleHRHTEFOR0xFLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29u dGV4dEdMQU5HTEU6OmRyYXdpbmdCdWZmZXJUZXh0dXJlVGFyZ2V0KToKKyAgICAgICAgKiBwbGF0 Zm9ybS9ncmFwaGljcy9uaWNvc2lhL3RleG1hcC9OaWNvc2lhR0NHTEFOR0xFTGF5ZXIuY3BwOgor ICAgICAgICAoTmljb3NpYTo6R0NHTEFOR0xFTGF5ZXI6OkFOR0xFQ29udGV4dDo6Y3JlYXRlQ29u dGV4dCk6CisKIDIwMjEtMTItMTQgIEplYW4tWXZlcyBBdmVuYXJkICA8anlhQGFwcGxlLmNvbT4K IAogICAgICAgICBSZW5hbWUgU2hhcmVkQnVmZmVyIGNsYXNzZXMuCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9hbmdsZS9HcmFwaGljc0NvbnRleHRHTEFOR0xF LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2FuZ2xlL0dyYXBoaWNzQ29u dGV4dEdMQU5HTEUuY3BwCmluZGV4IDRlMzA2ZjQ1MDAyMDY4MzIwZGUwYTZhNjEwNjlkMDE0MzVi NzAyYzEuLjZhYmI1Y2NkMjE4MDY2ZGFiYzg2NDdmODU1ZTE3NTAzOWUwNWIwNTQgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2FuZ2xlL0dyYXBoaWNzQ29udGV4 dEdMQU5HTEUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2FuZ2xl L0dyYXBoaWNzQ29udGV4dEdMQU5HTEUuY3BwCkBAIC03Myw3ICs3Myw3IEBAIHN0YXRpYyB2b2lk IHdpcGVBbHBoYUNoYW5uZWxGcm9tUGl4ZWxzKGludCB3aWR0aCwgaW50IGhlaWdodCwgdW5zaWdu ZWQgY2hhciogcGl4CiAKIEdDR0xlbnVtIEdyYXBoaWNzQ29udGV4dEdMQU5HTEU6OmRyYXdpbmdC dWZmZXJUZXh0dXJlVGFyZ2V0KCkKIHsKLSNpZiBQTEFURk9STShXSU4pCisjaWYgUExBVEZPUk0o V0lOKSB8fCBQTEFURk9STShHVEspCiAgICAgbV9kcmF3aW5nQnVmZmVyVGV4dHVyZVRhcmdldCA9 IEVHTF9URVhUVVJFXzJEOwogI2Vsc2UKICAgICBpZiAobV9kcmF3aW5nQnVmZmVyVGV4dHVyZVRh cmdldCA9PSAtMSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L25pY29zaWEvdGV4bWFwL05pY29zaWFHQ0dMQU5HTEVMYXllci5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9uaWNvc2lhL3RleG1hcC9OaWNvc2lhR0NHTEFOR0xFTGF5ZXIu Y3BwCmluZGV4IDJiZmY2ZTRmMGJjZjVhZTkzNjU2ODk2OGRjMzNhNDAwOGYxN2ViZDMuLjQ3OGY2 MDVjMmEyZWJhNWEzZjdmZDlhNWE5ZWUxNmQ3MDkzNDQzZmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL25pY29zaWEvdGV4bWFwL05pY29zaWFHQ0dMQU5HTEVM YXllci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvbmljb3NpYS90 ZXhtYXAvTmljb3NpYUdDR0xBTkdMRUxheWVyLmNwcApAQCAtNzEsNyArNzEsMTggQEAgY29uc3Qg Y2hhciogR0NHTEFOR0xFTGF5ZXI6OkFOR0xFQ29udGV4dDo6bGFzdEVycm9yU3RyaW5nKCkKIAog c3RkOjp1bmlxdWVfcHRyPEdDR0xBTkdMRUxheWVyOjpBTkdMRUNvbnRleHQ+IEdDR0xBTkdMRUxh eWVyOjpBTkdMRUNvbnRleHQ6OmNyZWF0ZUNvbnRleHQoKQogeworI2lmIFBMQVRGT1JNKEdUSykK KyAgICBjb25zdGV4cHIgRUdMQXR0cmliIGRpc3BsYXlBdHRyaWJ1dGVzW10gPSB7CisgICAgICAg IEVHTF9QTEFURk9STV9BTkdMRV9ERVZJQ0VfVFlQRV9BTkdMRSwgRUdMX1BMQVRGT1JNX0FOR0xF X0RFVklDRV9UWVBFX0VHTF9BTkdMRSwKKyAgICAgICAgRUdMX1BMQVRGT1JNX0FOR0xFX1RZUEVf QU5HTEUsIEVHTF9QTEFURk9STV9BTkdMRV9UWVBFX09QRU5HTEVTX0FOR0xFLAorICAgICAgICBF R0xfTk9ORQorICAgIH07CisKKyAgICBFR0xEaXNwbGF5IGRpc3BsYXkgPSBFR0xfR2V0UGxhdGZv cm1EaXNwbGF5KEVHTF9QTEFURk9STV9BTkdMRV9BTkdMRSwgRUdMX0RFRkFVTFRfRElTUExBWSwg ZGlzcGxheUF0dHJpYnV0ZXMpOworI2Vsc2UKICAgICBFR0xEaXNwbGF5IGRpc3BsYXkgPSBFR0xf R2V0RGlzcGxheShFR0xfREVGQVVMVF9ESVNQTEFZKTsKKyNlbmRpZgorCiAgICAgaWYgKGRpc3Bs YXkgPT0gRUdMX05PX0RJU1BMQVkpCiAgICAgICAgIHJldHVybiBudWxscHRyOwogCg== 447219 2021-12-15 04:00:07 -0800 2021-12-15 04:25:40 -0800 Patch bug-234293-20211215120005.patch text/plain 7730 clord U3VidmVyc2lvbiBSZXZpc2lvbjogMjg3MDIxCmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0 eS9BTkdMRS9DaGFuZ2VMb2cgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9DaGFuZ2VMb2cKaW5k ZXggYmY4MDkwZWNjYTcxN2YzMTA5OTRhYTJiN2E5OTk1MmY5OTU5MWU1Yy4uYjdmY2YyYzhmNjU5 ODZiYzU2N2ZjMGY1N2Y2YmViNWQyMjE2YjJiMSAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDE2IEBACisyMDIxLTEyLTE1ICBDaHJpcyBMb3JkICA8Y2xvcmRAaWdhbGlh LmNvbT4KKworICAgICAgICBbR1RLXSBVc2UgbGliZ2JtIGFuZCB0aGUgQU5HTEUgZ2JtIGJhY2tl bmQgdG8gZml4IGluaXRpYWxpc2F0aW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yMzQyOTMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBVc2UgR0JNIGJhY2tlbmQgZm9yIEdUSyBwbGF0Zm9ybS4KKworICAg ICAgICAqIENNYWtlTGlzdHMudHh0OgorICAgICAgICAqIEdMLmNtYWtlOgorICAgICAgICAqIFBs YXRmb3JtR1RLLmNtYWtlOgorCiAyMDIxLTEyLTE0ICBBcmNhZHkgR29sZG1pbnRzLU9ybG92ICA8 YWdvbGRtaW50c0BpZ2FsaWEuY29tPgogCiAgICAgICAgIFtHVEtdIGJ1aWxkIGZhaWxzIHdpdGgg dW5kZWZpbmVkIHN5bWJvbCBpbiBBTkdMRSBpZiBVU0VfQU5HTEVfV0VCR0wgaXMgZW5hYmxlZC4K ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCAyZWQyNWQyYzUxNzMxNDhkYjRlYTFlOGEyNzdhOGNkMGJkY2Q3MDI4Li4x ZDllOWJhZDI0OWZlNzY0OGQyZmI2NmIzZjhjMTkyMTdiZGY5NGQ0IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0x LDMgKzEsMTUgQEAKKzIwMjEtMTItMTUgIENocmlzIExvcmQgIDxjbG9yZEBpZ2FsaWEuY29tPgor CisgICAgICAgIFtHVEtdIFVzZSBsaWJnYm0gYW5kIHRoZSBBTkdMRSBnYm0gYmFja2VuZCB0byBm aXggaW5pdGlhbGlzYXRpb24KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIzNDI5MworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIE1ha2UgQU5HTEUgY29udGV4dCBub24tVEVYVFVSRV8yRCBkcmF3aW5nQnVmZmVy VGV4dHVyZVRhcmdldCBDb2NvYS1zcGVjaWZpYy4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBo aWNzL2FuZ2xlL0dyYXBoaWNzQ29udGV4dEdMQU5HTEUuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 R3JhcGhpY3NDb250ZXh0R0xBTkdMRTo6ZHJhd2luZ0J1ZmZlclRleHR1cmVUYXJnZXQpOgorCiAy MDIxLTEyLTE0ICBKZWFuLVl2ZXMgQXZlbmFyZCAgPGp5YUBhcHBsZS5jb20+CiAKICAgICAgICAg UmVuYW1lIFNoYXJlZEJ1ZmZlciBjbGFzc2VzLgpkaWZmIC0tZ2l0IGEvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvQ01ha2VMaXN0cy50eHQgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9DTWFrZUxp c3RzLnR4dAppbmRleCAyY2E4Mjc4MmQ5YmUxMDg5NTNkODgwNGM2NWFhOTY2MGY2OWY1MzdkLi5k NmI3NDZlNGM4OTM5OGQwN2RjN2M5ODU1ZTgwZWY1NjhiODc1ZGNiIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvVGhpcmRQYXJ0eS9BTkdMRS9DTWFrZUxpc3RzLnR4dAorKysgYi9Tb3VyY2UvVGhpcmRQYXJ0 eS9BTkdMRS9DTWFrZUxpc3RzLnR4dApAQCAtOSw5ICs5LDcgQEAgZWxzZWlmIChXSU4zMikKICAg ICBzZXQoYW5nbGVfaXNfd2ludXdwIEZBTFNFKQogZWxzZWlmIChVTklYKQogICAgIHNldChpc19s aW51eCBUUlVFKQotICAgIGlmIChFTkFCTEVfWDExX1RBUkdFVCkKLSAgICAgICAgc2V0KGFuZ2xl X3VzZV94MTEgVFJVRSkKLSAgICBlbmRpZiAoKQorICAgIHNldChvem9uZV9wbGF0Zm9ybV9nYm0g VFJVRSkKIGVuZGlmICgpCiAKIGluY2x1ZGUoQ29tcGlsZXIuY21ha2UpCmRpZmYgLS1naXQgYS9T b3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9HTC5jbWFrZSBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xF L0dMLmNtYWtlCmluZGV4IDFlZTljYmY5ZDc0YzgzMjg3YzkwZjg3ZDQ1MzVhMjJmNDVhYmY2MDAu LjdlYTY0M2VhMzlhYWQ0YjI2YjJmMmUyNGM2ODFhYzJiMmE2ZDAyNTYgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9UaGlyZFBhcnR5L0FOR0xFL0dMLmNtYWtlCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FO R0xFL0dMLmNtYWtlCkBAIC0xNjUsMTAgKzE2NSw2IEBAIGlmKG96b25lX3BsYXRmb3JtX2dibSkK ICAgICAgICAgInNyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9lZ2wvZ2JtL1N1cmZhY2VHYm0uY3Bw IgogICAgICAgICAic3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL2VnbC9nYm0vU3VyZmFjZUdibS5o IgogICAgICkKLQotICAgICBwa2dfY29uZmlnKCJzcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvbGli ZHJtIikgCi0gICAgIHNldChwYWNrYWdlcyAic3JjL2xpYkFOR0xFL3JlbmRlcmVyL2dsL2xpYmRy bSIgKQotICAgCiBlbmRpZigpCiAKIApkaWZmIC0tZ2l0IGEvU291cmNlL1RoaXJkUGFydHkvQU5H TEUvUGxhdGZvcm1HVEsuY21ha2UgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9QbGF0Zm9ybUdU Sy5jbWFrZQppbmRleCBlZjk3NmI1MzdiZGM0MDU2ZDNmNTQ1NjQ3ZGY5NTM3ZjI5ZmY2YjY4Li42 YjIyNWVmZGQxZDA4ZTYxMWM2MjU1MjE0N2JhYTU3NzkxMzI1YjA1IDEwMDY0NAotLS0gYS9Tb3Vy Y2UvVGhpcmRQYXJ0eS9BTkdMRS9QbGF0Zm9ybUdUSy5jbWFrZQorKysgYi9Tb3VyY2UvVGhpcmRQ YXJ0eS9BTkdMRS9QbGF0Zm9ybUdUSy5jbWFrZQpAQCAtMjIsMTAgKzIyLDIyIEBAIGlmIChVU0Vf QU5HTEVfRUdMIE9SIFVTRV9BTkdMRV9XRUJHTCkKIAogICAgIGxpc3QoQVBQRU5EIEFOR0xFX0RF RklOSVRJT05TCiAgICAgICAgIEFOR0xFX0VOQUJMRV9PUEVOR0wKKyAgICAgICAgQU5HTEVfVVNF X0dCTQorICAgICAgICBVU0VfU1lTVEVNX0VHTAorICAgICkKKworICAgIGZpbmRfcGFja2FnZShM aWJEUk0gUkVRVUlSRUQpCisgICAgZmluZF9wYWNrYWdlKEdCTSBSRVFVSVJFRCkKKworICAgIGxp c3QoQVBQRU5EIEFOR0xFX1BSSVZBVEVfSU5DTFVERV9ESVJFQ1RPUklFUworICAgICAgICAke0xJ QkRSTV9JTkNMVURFX0RJUn0KKyAgICAgICAge0dCTV9JTkNMVURFX0RJUn0KICAgICApCiAKICAg ICBsaXN0KEFQUEVORCBBTkdMRUdMRVN2Ml9MSUJSQVJJRVMKICAgICAgICAgJHtDTUFLRV9ETF9M SUJTfQorICAgICAgICAke0xJQkRSTV9MSUJSQVJJRVN9CisgICAgICAgICR7R0JNX0xJQlJBUklF U30KICAgICAgICAgVGhyZWFkczo6VGhyZWFkcwogICAgICkKIApAQCAtMzQsMjQgKzQ2LDQgQEAg aWYgKFVTRV9BTkdMRV9FR0wgT1IgVVNFX0FOR0xFX1dFQkdMKQogICAgIGVsc2UgKCkKICAgICAg ICAgbGlzdChBUFBFTkQgQU5HTEVHTEVTdjJfTElCUkFSSUVTIE9wZW5HTDo6R0xFUykKICAgICBl bmRpZiAoKQotCi0gICAgIyBOT1RFOiBXaGVuIGJvdGggV2F5bGFuZCBhbmQgWDExIGFyZSBlbmFi bGVkLCBBTkdMRV9VU0VfWDExIHdpbGwgYmUKLSAgICAjIGRlZmluZWQgYW5kIHRoZSBYMTEgdHlw ZSBkZWZpbml0aW9ucyB3aWxsIGJlIHVzZWQgZm9yIGNvZGUgaW52b2x2aW5nCi0gICAgIyBib3Ro LiBUaGF0IHdvcmtzIGJlY2F1c2UgdHlwZXMgZm9yIGJvdGggV2F5bGFuZCBhbmQgWDExIGhhdmUg dGhlIHNhbWUKLSAgICAjIHNpemVzIGFuZCB0aGUgY29kZSBpbiBXZWJLaXQgY2FzdHMgdGhlIHZh bHVlcyB0byB0aGUgcHJvcGVyIHR5cGVzIGFzCi0gICAgIyBuZWVkZWQuCi0gICAgc2V0KEdUS19B TkdMRV9ERUZJTklUSU9OUykKLQotICAgIGlmIChFTkFCTEVfWDExX1RBUkdFVCkKLSAgICAgICAg bGlzdChBUFBFTkQgQU5HTEVfU09VUkNFUyAke2xpYmFuZ2xlX2dsX2dseF9zb3VyY2VzfSkKLSAg ICAgICAgbGlzdChBUFBFTkQgQU5HTEVHTEVTdjJfTElCUkFSSUVTIFgxMSkKLSAgICAgICAgbGlz dChBUFBFTkQgR1RLX0FOR0xFX0RFRklOSVRJT05TIEFOR0xFX1VTRV9YMTEpCi0gICAgZW5kaWYg KCkKLQotICAgICMgQWxsb3cgYnVpbGRpbmcgQU5HTEUgb24gcGxhdGZvcm1zIHdoaWNoIG1heSBu b3QgcHJvdmlkZSBYMTEgaGVhZGVycy4KLSAgICBpZiAoTk9UIEdUS19BTkdMRV9ERUZJTklUSU9O UykKLSAgICAgICAgbGlzdChBUFBFTkQgR1RLX0FOR0xFX0RFRklOSVRJT05TIFVTRV9TWVNURU1f RUdMKQotICAgIGVuZGlmICgpCi0KLSAgICBsaXN0KEFQUEVORCBBTkdMRV9ERUZJTklUSU9OUyAk e0dUS19BTkdMRV9ERUZJTklUSU9OU30pCiBlbmRpZiAoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvYW5nbGUvR3JhcGhpY3NDb250ZXh0R0xBTkdMRS5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9hbmdsZS9HcmFwaGljc0NvbnRleHRH TEFOR0xFLmNwcAppbmRleCA0ZTMwNmY0NTAwMjA2ODMyMGRlMGE2YTYxMDY5ZDAxNDM1YjcwMmMx Li42ZDEwNjZhNWI5NWE0MDFlNjg5NDUwZGVlYzU0NWQ3YWQxZTc0MmMzIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9hbmdsZS9HcmFwaGljc0NvbnRleHRHTEFO R0xFLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9hbmdsZS9HcmFw aGljc0NvbnRleHRHTEFOR0xFLmNwcApAQCAtNzMsNyArNzMsNyBAQCBzdGF0aWMgdm9pZCB3aXBl QWxwaGFDaGFubmVsRnJvbVBpeGVscyhpbnQgd2lkdGgsIGludCBoZWlnaHQsIHVuc2lnbmVkIGNo YXIqIHBpeAogCiBHQ0dMZW51bSBHcmFwaGljc0NvbnRleHRHTEFOR0xFOjpkcmF3aW5nQnVmZmVy VGV4dHVyZVRhcmdldCgpCiB7Ci0jaWYgUExBVEZPUk0oV0lOKQorI2lmICFQTEFURk9STShDT0NP QSkKICAgICBtX2RyYXdpbmdCdWZmZXJUZXh0dXJlVGFyZ2V0ID0gRUdMX1RFWFRVUkVfMkQ7CiAj ZWxzZQogICAgIGlmIChtX2RyYXdpbmdCdWZmZXJUZXh0dXJlVGFyZ2V0ID09IC0xKQpkaWZmIC0t Z2l0IGEvU291cmNlL2NtYWtlL0ZpbmRHQk0uY21ha2UgYi9Tb3VyY2UvY21ha2UvRmluZEdCTS5j bWFrZQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwLi4xNDk5M2MzOGI4NGQ4Y2NmN2UyZTM4M2I5ZjkzYmQwNWE4YWU3ZGY0 Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL2NtYWtlL0ZpbmRHQk0uY21ha2UKQEAgLTAsMCAr MSwyOSBAQAorIyAtIEZpbmQgR0JNCisjIFRoaXMgbW9kdWxlIGxvb2tzIGZvciBHQk0uIFRoaXMg bW9kdWxlIGRlZmluZXMgdGhlCisjIGZvbGxvd2luZyB2YXJpYWJsZXM6CisjICBHQk1fRk9VTkQg LSBzeXN0ZW0gaGFzIGdibQorIyAgR0JNX0lOQ0xVREVfRElSUyAtIHRoZSBnYm0gaW5jbHVkZSBk aXJlY3RvcmllcworIyAgR0JNX0xJQlJBUklFUyAtIGxpbmsgdGhlc2UgdG8gdXNlIGdibQorCitm aW5kX3BhY2thZ2UoUGtnQ29uZmlnIFFVSUVUKQorcGtnX2NoZWNrX21vZHVsZXMoUENfR0JNIFFV SUVUIGdibSkKKworZmluZF9saWJyYXJ5KEdCTV9MSUJSQVJJRVMKKyAgICBOQU1FUyBnYm0KKyAg ICBISU5UUyAke1BDX0dCTV9MSUJESVJ9CisgICAgICAgICAgJHtQQ19HQk1fTElCUkFSWV9ESVJT fQorKQorCitmaW5kX3BhdGgoR0JNX0lOQ0xVREVfRElSCisgICAgTkFNRVMgZ2JtLmgKKyAgICBI SU5UUyAke1BDX0dCTV9JTkNMVURFRElSfQorICAgICAgICAgICR7UENfR0JNX0lOQ0xVREVfRElS U30KKykKKworaW5jbHVkZShGaW5kUGFja2FnZUhhbmRsZVN0YW5kYXJkQXJncykKK0ZJTkRfUEFD S0FHRV9IQU5ETEVfU1RBTkRBUkRfQVJHUyhHQk0gREVGQVVMVF9NU0cgR0JNX0xJQlJBUklFUyBH Qk1fSU5DTFVERV9ESVIpCisKK21hcmtfYXNfYWR2YW5jZWQoCisgIEdCTV9JTkNMVURFX0RJUgor ICBHQk1fTElCUkFSSUVTCispCmRpZmYgLS1naXQgYS9Tb3VyY2UvY21ha2UvRmluZExpYkRSTS5j bWFrZSBiL1NvdXJjZS9jbWFrZS9GaW5kTGliRFJNLmNtYWtlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmRiNDgwODM5 ZjZmODU5OWIyMGIxZjRhNTA2OTNhMmQxYTJlNWZmODYKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3Vy Y2UvY21ha2UvRmluZExpYkRSTS5jbWFrZQpAQCAtMCwwICsxLDMwIEBACisjIC0gRmluZCBsaWJk cm0KKyMgVGhpcyBtb2R1bGUgbG9va3MgZm9yIGxpYmRybS4gVGhpcyBtb2R1bGUgZGVmaW5lcyB0 aGUKKyMgZm9sbG93aW5nIHZhcmlhYmxlczoKKyMgIExJQkRSTV9GT1VORCAtIHN5c3RlbSBoYXMg bGliZHJtCisjICBMSUJEUk1fSU5DTFVERV9ESVJTIC0gdGhlIGxpYmRybSBpbmNsdWRlIGRpcmVj dG9yaWVzCisjICBMSUJEUk1fTElCUkFSSUVTIC0gbGluayB0aGVzZSB0byB1c2UgbGliZHJtCisK K2ZpbmRfcGFja2FnZShQa2dDb25maWcgUVVJRVQpCitwa2dfY2hlY2tfbW9kdWxlcyhQQ19MSUJE Uk0gUVVJRVQgbGliZHJtKQorCitmaW5kX2xpYnJhcnkoTElCRFJNX0xJQlJBUklFUworICAgIE5B TUVTIGRybQorICAgIEhJTlRTICR7UENfTElCRFJNX0xJQkRJUn0KKyAgICAgICAgICAke1BDX0xJ QkRSTV9MSUJSQVJZX0RJUlN9CispCisKK2ZpbmRfcGF0aChMSUJEUk1fSU5DTFVERV9ESVIKKyAg ICBOQU1FUyBkcm0uaAorICAgIEhJTlRTICR7UENfTElCRFJNX0lOQ0xVREVESVJ9CisgICAgICAg ICAgJHtQQ19MSUJEUk1fSU5DTFVERV9ESVJTfQorICAgIFBBVEhfU1VGRklYRVMgbGliZHJtCisp CisKK2luY2x1ZGUoRmluZFBhY2thZ2VIYW5kbGVTdGFuZGFyZEFyZ3MpCitGSU5EX1BBQ0tBR0Vf SEFORExFX1NUQU5EQVJEX0FSR1MoTGliRFJNIERFRkFVTFRfTVNHIExJQkRSTV9MSUJSQVJJRVMg TElCRFJNX0lOQ0xVREVfRElSKQorCittYXJrX2FzX2FkdmFuY2VkKAorICBMSUJEUk1fSU5DTFVE RV9ESVIKKyAgTElCRFJNX0xJQlJBUklFUworKQpkaWZmIC0tZ2l0IGEvQ2hhbmdlTG9nIGIvQ2hh bmdlTG9nCmluZGV4IDA3YWE1NmFkM2MzOTM2ZDEzMjRiNGJmMzU5ZDRlNjM3ODUzZDIzOTguLjQ4 NWM1NTYwOGJkMTZhNTg5OWVjOThiYmU5MTQ0OGNlOTg2NDdmMWQgMTAwNjQ0Ci0tLSBhL0NoYW5n ZUxvZworKysgYi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAyMS0xMi0xNSAgQ2hyaXMg TG9yZCAgPGNsb3JkQGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10gVXNlIGxpYmdibSBhbmQg dGhlIEFOR0xFIGdibSBiYWNrZW5kIHRvIGZpeCBpbml0aWFsaXNhdGlvbgorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjM0MjkzCisKKyAgICAgICAgUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGNtYWtlIGZpbGVzIHRvIGZp bmQgZ2JtIGFuZCBsaWJkcm0uCisKKyAgICAgICAgKiBTb3VyY2UvY21ha2UvRmluZEdCTS5jbWFr ZTogQWRkZWQuCisgICAgICAgICogU291cmNlL2NtYWtlL0ZpbmRMaWJEUk0uY21ha2U6IEFkZGVk LgorCiAyMDIxLTEyLTExICBBYWthc2ggSmFpbiAgPGFha2FzaF9qYWluQGFwcGxlLmNvbT4KIAog ICAgICAgICBVcGRhdGUgbXkgZ2l0aHViIHVzZXJuYW1lLgo= 447220 2021-12-15 04:25:45 -0800 2021-12-15 08:35:03 -0800 Patch bug-234293-20211215122544.patch text/plain 7736 clord U3VidmVyc2lvbiBSZXZpc2lvbjogMjg3MDY5CmRpZmYgLS1naXQgYS9Tb3VyY2UvVGhpcmRQYXJ0 eS9BTkdMRS9DaGFuZ2VMb2cgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9DaGFuZ2VMb2cKaW5k ZXggMzYzM2M3NTllMTM3YzUwYzI1YjcxZWIyYTlmYTIxOWVkYWE0YTIyNC4uOTI1NmU0MDU5ZGI5 ODVhMTViOWM3NWU1OTAxZjQ5NWEyNjJjMGQzMCAxMDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDE2IEBACisyMDIxLTEyLTE1ICBDaHJpcyBMb3JkICA8Y2xvcmRAaWdhbGlh LmNvbT4KKworICAgICAgICBbR1RLXSBVc2UgbGliZ2JtIGFuZCB0aGUgQU5HTEUgZ2JtIGJhY2tl bmQgdG8gZml4IGluaXRpYWxpc2F0aW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3Jn L3Nob3dfYnVnLmNnaT9pZD0yMzQyOTMKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBVc2UgR0JNIGJhY2tlbmQgZm9yIEdUSyBwbGF0Zm9ybS4KKworICAg ICAgICAqIENNYWtlTGlzdHMudHh0OgorICAgICAgICAqIEdMLmNtYWtlOgorICAgICAgICAqIFBs YXRmb3JtR1RLLmNtYWtlOgorCiAyMDIxLTEyLTE1ICBLeWxlIFBpZGRpbmd0b24gIDxrcGlkZGlu Z3RvbkBhcHBsZS5jb20+CiAKICAgICAgICAgW0FOR0xFXSBSb2xsIEFOR0xFIHRvIDEyLTE0LTIw MjEgKDVlZTdkZmJkNWEzKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nIGIv U291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCmluZGV4IDcyNzlhM2JkZGEyZTJjNWFhYmFkYzQ0Njg2 OWY2NTllMDUwODliZGYuLjJhZTVhYmEwNWFjMzU4YjdkNjg1ZWRlZDFiYWNlMzRiNGFiMDM3YmYg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAyMS0xMi0xNSAgQ2hyaXMgTG9yZCAgPGNs b3JkQGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10gVXNlIGxpYmdibSBhbmQgdGhlIEFOR0xF IGdibSBiYWNrZW5kIHRvIGZpeCBpbml0aWFsaXNhdGlvbgorICAgICAgICBodHRwczovL2J1Z3Mu d2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjM0MjkzCisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFrZSBBTkdMRSBjb250ZXh0IG5vbi1URVhUVVJF XzJEIGRyYXdpbmdCdWZmZXJUZXh0dXJlVGFyZ2V0IENvY29hLXNwZWNpZmljLgorCisgICAgICAg ICogcGxhdGZvcm0vZ3JhcGhpY3MvYW5nbGUvR3JhcGhpY3NDb250ZXh0R0xBTkdMRS5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRHTEFOR0xFOjpkcmF3aW5nQnVmZmVyVGV4 dHVyZVRhcmdldCk6CisKIDIwMjEtMTItMTUgIFlvdWVubiBGYWJsZXQgIDx5b3Vlbm5AYXBwbGUu Y29tPgogCiAgICAgICAgIE1ha2Ugc3VyZSB0byBzdGFydCBhIHJlYWx0aW1lIG91dGdvaW5nIHNv dXJjZSBpbiBjYXNlIGl0IGlzIHRha2VuIHRvIGFub3RoZXIgc2VuZGVyCmRpZmYgLS1naXQgYS9T b3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9DTWFrZUxpc3RzLnR4dCBiL1NvdXJjZS9UaGlyZFBhcnR5 L0FOR0xFL0NNYWtlTGlzdHMudHh0CmluZGV4IDJjYTgyNzgyZDliZTEwODk1M2Q4ODA0YzY1YWE5 NjYwZjY5ZjUzN2QuLmQ2Yjc0NmU0Yzg5Mzk4ZDA3ZGM3Yzk4NTVlODBlZjU2OGI4NzVkY2IgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL0NNYWtlTGlzdHMudHh0CisrKyBiL1Nv dXJjZS9UaGlyZFBhcnR5L0FOR0xFL0NNYWtlTGlzdHMudHh0CkBAIC05LDkgKzksNyBAQCBlbHNl aWYgKFdJTjMyKQogICAgIHNldChhbmdsZV9pc193aW51d3AgRkFMU0UpCiBlbHNlaWYgKFVOSVgp CiAgICAgc2V0KGlzX2xpbnV4IFRSVUUpCi0gICAgaWYgKEVOQUJMRV9YMTFfVEFSR0VUKQotICAg ICAgICBzZXQoYW5nbGVfdXNlX3gxMSBUUlVFKQotICAgIGVuZGlmICgpCisgICAgc2V0KG96b25l X3BsYXRmb3JtX2dibSBUUlVFKQogZW5kaWYgKCkKIAogaW5jbHVkZShDb21waWxlci5jbWFrZSkK ZGlmZiAtLWdpdCBhL1NvdXJjZS9UaGlyZFBhcnR5L0FOR0xFL0dMLmNtYWtlIGIvU291cmNlL1Ro aXJkUGFydHkvQU5HTEUvR0wuY21ha2UKaW5kZXggMTFmYzVhNDEyZGI2M2ZmZWQ3OTMxYjNjMGY1 YTY2MmEzMDg1MDVhYS4uZTBjMzljNTg4MmQyMzVmYzVhMmMyZDFlMzI0ZjQ3OTNkZjIwNDAyNCAx MDA2NDQKLS0tIGEvU291cmNlL1RoaXJkUGFydHkvQU5HTEUvR0wuY21ha2UKKysrIGIvU291cmNl L1RoaXJkUGFydHkvQU5HTEUvR0wuY21ha2UKQEAgLTE2Myw5ICsxNjMsNiBAQCBpZihvem9uZV9w bGF0Zm9ybV9nYm0pCiAgICAgICAgICJzcmMvbGliQU5HTEUvcmVuZGVyZXIvZ2wvZWdsL2dibS9T dXJmYWNlR2JtLmNwcCIKICAgICAgICAgInNyYy9saWJBTkdMRS9yZW5kZXJlci9nbC9lZ2wvZ2Jt L1N1cmZhY2VHYm0uaCIKICAgICApCi0KLSAgICBwa2dfY29uZmlnKCJzcmMvbGliQU5HTEUvcmVu ZGVyZXIvZ2wvbGliZHJtIikgCi0gICAgc2V0KHBhY2thZ2VzICJzcmMvbGliQU5HTEUvcmVuZGVy ZXIvZ2wvbGliZHJtIiApCiBlbmRpZigpCiAKIApkaWZmIC0tZ2l0IGEvU291cmNlL1RoaXJkUGFy dHkvQU5HTEUvUGxhdGZvcm1HVEsuY21ha2UgYi9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9QbGF0 Zm9ybUdUSy5jbWFrZQppbmRleCBlZjk3NmI1MzdiZGM0MDU2ZDNmNTQ1NjQ3ZGY5NTM3ZjI5ZmY2 YjY4Li42YjIyNWVmZGQxZDA4ZTYxMWM2MjU1MjE0N2JhYTU3NzkxMzI1YjA1IDEwMDY0NAotLS0g YS9Tb3VyY2UvVGhpcmRQYXJ0eS9BTkdMRS9QbGF0Zm9ybUdUSy5jbWFrZQorKysgYi9Tb3VyY2Uv VGhpcmRQYXJ0eS9BTkdMRS9QbGF0Zm9ybUdUSy5jbWFrZQpAQCAtMjIsMTAgKzIyLDIyIEBAIGlm IChVU0VfQU5HTEVfRUdMIE9SIFVTRV9BTkdMRV9XRUJHTCkKIAogICAgIGxpc3QoQVBQRU5EIEFO R0xFX0RFRklOSVRJT05TCiAgICAgICAgIEFOR0xFX0VOQUJMRV9PUEVOR0wKKyAgICAgICAgQU5H TEVfVVNFX0dCTQorICAgICAgICBVU0VfU1lTVEVNX0VHTAorICAgICkKKworICAgIGZpbmRfcGFj a2FnZShMaWJEUk0gUkVRVUlSRUQpCisgICAgZmluZF9wYWNrYWdlKEdCTSBSRVFVSVJFRCkKKwor ICAgIGxpc3QoQVBQRU5EIEFOR0xFX1BSSVZBVEVfSU5DTFVERV9ESVJFQ1RPUklFUworICAgICAg ICAke0xJQkRSTV9JTkNMVURFX0RJUn0KKyAgICAgICAge0dCTV9JTkNMVURFX0RJUn0KICAgICAp CiAKICAgICBsaXN0KEFQUEVORCBBTkdMRUdMRVN2Ml9MSUJSQVJJRVMKICAgICAgICAgJHtDTUFL RV9ETF9MSUJTfQorICAgICAgICAke0xJQkRSTV9MSUJSQVJJRVN9CisgICAgICAgICR7R0JNX0xJ QlJBUklFU30KICAgICAgICAgVGhyZWFkczo6VGhyZWFkcwogICAgICkKIApAQCAtMzQsMjQgKzQ2 LDQgQEAgaWYgKFVTRV9BTkdMRV9FR0wgT1IgVVNFX0FOR0xFX1dFQkdMKQogICAgIGVsc2UgKCkK ICAgICAgICAgbGlzdChBUFBFTkQgQU5HTEVHTEVTdjJfTElCUkFSSUVTIE9wZW5HTDo6R0xFUykK ICAgICBlbmRpZiAoKQotCi0gICAgIyBOT1RFOiBXaGVuIGJvdGggV2F5bGFuZCBhbmQgWDExIGFy ZSBlbmFibGVkLCBBTkdMRV9VU0VfWDExIHdpbGwgYmUKLSAgICAjIGRlZmluZWQgYW5kIHRoZSBY MTEgdHlwZSBkZWZpbml0aW9ucyB3aWxsIGJlIHVzZWQgZm9yIGNvZGUgaW52b2x2aW5nCi0gICAg IyBib3RoLiBUaGF0IHdvcmtzIGJlY2F1c2UgdHlwZXMgZm9yIGJvdGggV2F5bGFuZCBhbmQgWDEx IGhhdmUgdGhlIHNhbWUKLSAgICAjIHNpemVzIGFuZCB0aGUgY29kZSBpbiBXZWJLaXQgY2FzdHMg dGhlIHZhbHVlcyB0byB0aGUgcHJvcGVyIHR5cGVzIGFzCi0gICAgIyBuZWVkZWQuCi0gICAgc2V0 KEdUS19BTkdMRV9ERUZJTklUSU9OUykKLQotICAgIGlmIChFTkFCTEVfWDExX1RBUkdFVCkKLSAg ICAgICAgbGlzdChBUFBFTkQgQU5HTEVfU09VUkNFUyAke2xpYmFuZ2xlX2dsX2dseF9zb3VyY2Vz fSkKLSAgICAgICAgbGlzdChBUFBFTkQgQU5HTEVHTEVTdjJfTElCUkFSSUVTIFgxMSkKLSAgICAg ICAgbGlzdChBUFBFTkQgR1RLX0FOR0xFX0RFRklOSVRJT05TIEFOR0xFX1VTRV9YMTEpCi0gICAg ZW5kaWYgKCkKLQotICAgICMgQWxsb3cgYnVpbGRpbmcgQU5HTEUgb24gcGxhdGZvcm1zIHdoaWNo IG1heSBub3QgcHJvdmlkZSBYMTEgaGVhZGVycy4KLSAgICBpZiAoTk9UIEdUS19BTkdMRV9ERUZJ TklUSU9OUykKLSAgICAgICAgbGlzdChBUFBFTkQgR1RLX0FOR0xFX0RFRklOSVRJT05TIFVTRV9T WVNURU1fRUdMKQotICAgIGVuZGlmICgpCi0KLSAgICBsaXN0KEFQUEVORCBBTkdMRV9ERUZJTklU SU9OUyAke0dUS19BTkdMRV9ERUZJTklUSU9OU30pCiBlbmRpZiAoKQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvYW5nbGUvR3JhcGhpY3NDb250ZXh0R0xBTkdM RS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9hbmdsZS9HcmFwaGljc0Nv bnRleHRHTEFOR0xFLmNwcAppbmRleCA0ZTMwNmY0NTAwMjA2ODMyMGRlMGE2YTYxMDY5ZDAxNDM1 YjcwMmMxLi42ZDEwNjZhNWI5NWE0MDFlNjg5NDUwZGVlYzU0NWQ3YWQxZTc0MmMzIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9hbmdsZS9HcmFwaGljc0NvbnRl eHRHTEFOR0xFLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9hbmds ZS9HcmFwaGljc0NvbnRleHRHTEFOR0xFLmNwcApAQCAtNzMsNyArNzMsNyBAQCBzdGF0aWMgdm9p ZCB3aXBlQWxwaGFDaGFubmVsRnJvbVBpeGVscyhpbnQgd2lkdGgsIGludCBoZWlnaHQsIHVuc2ln bmVkIGNoYXIqIHBpeAogCiBHQ0dMZW51bSBHcmFwaGljc0NvbnRleHRHTEFOR0xFOjpkcmF3aW5n QnVmZmVyVGV4dHVyZVRhcmdldCgpCiB7Ci0jaWYgUExBVEZPUk0oV0lOKQorI2lmICFQTEFURk9S TShDT0NPQSkKICAgICBtX2RyYXdpbmdCdWZmZXJUZXh0dXJlVGFyZ2V0ID0gRUdMX1RFWFRVUkVf MkQ7CiAjZWxzZQogICAgIGlmIChtX2RyYXdpbmdCdWZmZXJUZXh0dXJlVGFyZ2V0ID09IC0xKQpk aWZmIC0tZ2l0IGEvU291cmNlL2NtYWtlL0ZpbmRHQk0uY21ha2UgYi9Tb3VyY2UvY21ha2UvRmlu ZEdCTS5jbWFrZQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4xNDk5M2MzOGI4NGQ4Y2NmN2UyZTM4M2I5ZjkzYmQwNWE4 YWU3ZGY0Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL2NtYWtlL0ZpbmRHQk0uY21ha2UKQEAg LTAsMCArMSwyOSBAQAorIyAtIEZpbmQgR0JNCisjIFRoaXMgbW9kdWxlIGxvb2tzIGZvciBHQk0u IFRoaXMgbW9kdWxlIGRlZmluZXMgdGhlCisjIGZvbGxvd2luZyB2YXJpYWJsZXM6CisjICBHQk1f Rk9VTkQgLSBzeXN0ZW0gaGFzIGdibQorIyAgR0JNX0lOQ0xVREVfRElSUyAtIHRoZSBnYm0gaW5j bHVkZSBkaXJlY3RvcmllcworIyAgR0JNX0xJQlJBUklFUyAtIGxpbmsgdGhlc2UgdG8gdXNlIGdi bQorCitmaW5kX3BhY2thZ2UoUGtnQ29uZmlnIFFVSUVUKQorcGtnX2NoZWNrX21vZHVsZXMoUENf R0JNIFFVSUVUIGdibSkKKworZmluZF9saWJyYXJ5KEdCTV9MSUJSQVJJRVMKKyAgICBOQU1FUyBn Ym0KKyAgICBISU5UUyAke1BDX0dCTV9MSUJESVJ9CisgICAgICAgICAgJHtQQ19HQk1fTElCUkFS WV9ESVJTfQorKQorCitmaW5kX3BhdGgoR0JNX0lOQ0xVREVfRElSCisgICAgTkFNRVMgZ2JtLmgK KyAgICBISU5UUyAke1BDX0dCTV9JTkNMVURFRElSfQorICAgICAgICAgICR7UENfR0JNX0lOQ0xV REVfRElSU30KKykKKworaW5jbHVkZShGaW5kUGFja2FnZUhhbmRsZVN0YW5kYXJkQXJncykKK0ZJ TkRfUEFDS0FHRV9IQU5ETEVfU1RBTkRBUkRfQVJHUyhHQk0gREVGQVVMVF9NU0cgR0JNX0xJQlJB UklFUyBHQk1fSU5DTFVERV9ESVIpCisKK21hcmtfYXNfYWR2YW5jZWQoCisgIEdCTV9JTkNMVURF X0RJUgorICBHQk1fTElCUkFSSUVTCispCmRpZmYgLS1naXQgYS9Tb3VyY2UvY21ha2UvRmluZExp YkRSTS5jbWFrZSBiL1NvdXJjZS9jbWFrZS9GaW5kTGliRFJNLmNtYWtlCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmRi NDgwODM5ZjZmODU5OWIyMGIxZjRhNTA2OTNhMmQxYTJlNWZmODYKLS0tIC9kZXYvbnVsbAorKysg Yi9Tb3VyY2UvY21ha2UvRmluZExpYkRSTS5jbWFrZQpAQCAtMCwwICsxLDMwIEBACisjIC0gRmlu ZCBsaWJkcm0KKyMgVGhpcyBtb2R1bGUgbG9va3MgZm9yIGxpYmRybS4gVGhpcyBtb2R1bGUgZGVm aW5lcyB0aGUKKyMgZm9sbG93aW5nIHZhcmlhYmxlczoKKyMgIExJQkRSTV9GT1VORCAtIHN5c3Rl bSBoYXMgbGliZHJtCisjICBMSUJEUk1fSU5DTFVERV9ESVJTIC0gdGhlIGxpYmRybSBpbmNsdWRl IGRpcmVjdG9yaWVzCisjICBMSUJEUk1fTElCUkFSSUVTIC0gbGluayB0aGVzZSB0byB1c2UgbGli ZHJtCisKK2ZpbmRfcGFja2FnZShQa2dDb25maWcgUVVJRVQpCitwa2dfY2hlY2tfbW9kdWxlcyhQ Q19MSUJEUk0gUVVJRVQgbGliZHJtKQorCitmaW5kX2xpYnJhcnkoTElCRFJNX0xJQlJBUklFUwor ICAgIE5BTUVTIGRybQorICAgIEhJTlRTICR7UENfTElCRFJNX0xJQkRJUn0KKyAgICAgICAgICAk e1BDX0xJQkRSTV9MSUJSQVJZX0RJUlN9CispCisKK2ZpbmRfcGF0aChMSUJEUk1fSU5DTFVERV9E SVIKKyAgICBOQU1FUyBkcm0uaAorICAgIEhJTlRTICR7UENfTElCRFJNX0lOQ0xVREVESVJ9Cisg ICAgICAgICAgJHtQQ19MSUJEUk1fSU5DTFVERV9ESVJTfQorICAgIFBBVEhfU1VGRklYRVMgbGli ZHJtCispCisKK2luY2x1ZGUoRmluZFBhY2thZ2VIYW5kbGVTdGFuZGFyZEFyZ3MpCitGSU5EX1BB Q0tBR0VfSEFORExFX1NUQU5EQVJEX0FSR1MoTGliRFJNIERFRkFVTFRfTVNHIExJQkRSTV9MSUJS QVJJRVMgTElCRFJNX0lOQ0xVREVfRElSKQorCittYXJrX2FzX2FkdmFuY2VkKAorICBMSUJEUk1f SU5DTFVERV9ESVIKKyAgTElCRFJNX0xJQlJBUklFUworKQpkaWZmIC0tZ2l0IGEvQ2hhbmdlTG9n IGIvQ2hhbmdlTG9nCmluZGV4IDA3YWE1NmFkM2MzOTM2ZDEzMjRiNGJmMzU5ZDRlNjM3ODUzZDIz OTguLjQ4NWM1NTYwOGJkMTZhNTg5OWVjOThiYmU5MTQ0OGNlOTg2NDdmMWQgMTAwNjQ0Ci0tLSBh L0NoYW5nZUxvZworKysgYi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNSBAQAorMjAyMS0xMi0xNSAg Q2hyaXMgTG9yZCAgPGNsb3JkQGlnYWxpYS5jb20+CisKKyAgICAgICAgW0dUS10gVXNlIGxpYmdi bSBhbmQgdGhlIEFOR0xFIGdibSBiYWNrZW5kIHRvIGZpeCBpbml0aWFsaXNhdGlvbgorICAgICAg ICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjM0MjkzCisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGNtYWtlIGZpbGVz IHRvIGZpbmQgZ2JtIGFuZCBsaWJkcm0uCisKKyAgICAgICAgKiBTb3VyY2UvY21ha2UvRmluZEdC TS5jbWFrZTogQWRkZWQuCisgICAgICAgICogU291cmNlL2NtYWtlL0ZpbmRMaWJEUk0uY21ha2U6 IEFkZGVkLgorCiAyMDIxLTEyLTExICBBYWthc2ggSmFpbiAgPGFha2FzaF9qYWluQGFwcGxlLmNv bT4KIAogICAgICAgICBVcGRhdGUgbXkgZ2l0aHViIHVzZXJuYW1lLgo=