209670 2020-03-27 11:42:13 -0700 REGRESSION(r258857): Broke aarch64 JSCOnly CI 2020-11-17 07:32:31 -0800 1 1 1 Unclassified WebKit JavaScriptCore WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=209236 InRadar P2 Normal --- 209360 209236 1 clopez clopez benjamin cdumez cmarcelo ews-watchlist fpizlo ggaren jbedard keith_miller mark.lam mcatanzaro msaboff saam tpopela tzagallo webkit-bug-importer zan oldest_to_newest 1634917 0 clopez 2020-03-27 11:42:13 -0700 The JSCOnly ARM64 its crashing all of the time since r258857 https://build.webkit.org/builders/JSCOnly%20Linux%20AArch64%20Release/builds/5810 1634921 1 394739 clopez 2020-03-27 11:47:19 -0700 Created attachment 394739 Patch 1634922 2 mcatanzaro 2020-03-27 11:48:33 -0700 Try changing it to 4 KB (or 16 KB), see if that makes a difference? It really *shouldn't*, but if you're seeing crashes then clearly it does.... 1634925 3 394741 clopez 2020-03-27 11:50:01 -0700 Created attachment 394741 Patch 1634928 4 mcatanzaro 2020-03-27 11:54:07 -0700 Don't revert my ChangeLog entries. :P There is a 'webkit-patch rollout' command that will do the revert for you without messing up the ChangeLog. That said, this change is passing our aarch64 CI. Must be related to different page size. Try this patch: $ git diff diff --git a/Source/WTF/wtf/PageBlock.h b/Source/WTF/wtf/PageBlock.h index 425c9d9e662f..dd56f973cd09 100644 --- a/Source/WTF/wtf/PageBlock.h +++ b/Source/WTF/wtf/PageBlock.h @@ -49,9 +49,9 @@ namespace WTF { // Use 64 KiB for any unknown CPUs to be conservative. #if OS(DARWIN) || PLATFORM(PLAYSTATION) constexpr size_t CeilingOnPageSize = 16 * KB; -#elif OS(WINDOWS) || CPU(MIPS) || CPU(X86) || CPU(X86_64) || CPU(ARM) +#elif OS(WINDOWS) || CPU(MIPS) || CPU(X86) || CPU(X86_64) || CPU(ARM) || CPU(ARM64) constexpr size_t CeilingOnPageSize = 4 * KB; -#elif CPU(UNKNOWN) || CPU(PPC) || CPU(PPC64) || CPU(PPC64LE) || CPU(ARM64) +#elif CPU(UNKNOWN) || CPU(PPC) || CPU(PPC64) || CPU(PPC64LE) constexpr size_t CeilingOnPageSize = 64 * KB; #else #error Must set CeilingOnPageSize in PageBlock.h when adding a new CPU architecture! That will definitely break our CI, because we use 64 KB pages, but at least that's the first step to figuring out what went wrong. Something must be wrong somewhere, because it should be completely safe to use any value larger than the actual page size for CeilingOnPageSize, as long as it is a multiple of the real page size.... 1634929 5 clopez 2020-03-27 11:59:08 -0700 (In reply to Michael Catanzaro from comment #4) > Don't revert my ChangeLog entries. :P There is a 'webkit-patch rollout' > command that will do the revert for you without messing up the ChangeLog. > Yes, but it failed because of r259018 So I had to do the revert manually.. I fixed the changelog thing already. Let's wait for EWS green before landing. 1634930 6 mcatanzaro 2020-03-27 12:00:22 -0700 BTW, is it crashing in JSC Config::permanentlyFreeze? 1634931 7 mcatanzaro 2020-03-27 12:04:28 -0700 Plan is: * Try 4 KB page size first * If that doesn't immediately fix the problem, land clopez's revert and figure it out next week. 1634938 8 394743 mcatanzaro 2020-03-27 12:08:32 -0700 Created attachment 394743 Patch 1634959 9 ews-feeder 2020-03-27 12:48:08 -0700 Committed r259134: <https://trac.webkit.org/changeset/259134> All reviewed patches have been landed. Closing bug and clearing flags on attachment 394743. 1634961 10 webkit-bug-importer 2020-03-27 12:49:15 -0700 <rdar://problem/60980423> 1635182 11 mcatanzaro 2020-03-28 08:26:03 -0700 Looks like that fixed the upstream bot. Now if only it didn't also break our internal bot, I would be happy.... Can you find where it was crashing, please? (gdb backtrace, not strace.) This change should only have affected MarkedBlock.h and JSCConfig.h. And in both cases, using any multiple of the system page size should have been perfectly safe. 1635436 12 394895 zan 2020-03-30 03:40:39 -0700 Created attachment 394895 Crash backtrace 1635437 13 zan 2020-03-30 03:46:54 -0700 (In reply to Zan Dobersek from comment #12) > Created attachment 394895 [details] > Crash backtrace The change leading to the crashes is the MarkedBlock size increase. The backtrace shows the crash, but it's more of a side-effect of that size increase than anything else. FWIW the crash doesn't occur when bmalloc is disabled via `Malloc=1`. Regardless of the fix for this crash, I don't think the increase to 64kB as the page-size ceiling is welcome for ARM64 platforms that don't need it, since it leads to quadrupling the size of the MarkedBlock objects. 1635483 14 mcatanzaro 2020-03-30 07:03:08 -0700 (In reply to Zan Dobersek from comment #13) > FWIW the crash doesn't occur when bmalloc is disabled via `Malloc=1`. Ahhh, there we go, that explains it. Yes, bmalloc has to be disabled when using sizes > 16 KB. The default CeilingOnPageSize of 64 KB is OK because bmalloc is disabled by default except on whitelisted architectures. It fails only on aarch64 because we have aarch64 whitelisted in WebKitFeatures.cmake. But RHEL's build manually overrides this by passing -DUSE_SYSTEM_MALLOC=ON for aarch64. I created bug #209360 to ask if it would be possible to fix that, but no response yet. We could fix this by checking the page size at build time using sysconf(), but Carlos Lopez pointed out that will fail when cross-compiling, which is why I wound up just hardcoding page size guesses. So as long as bmalloc crashes in this configuration, the only solutions I can think of are (a) disable bmalloc for aarch64, even though it works on most systems, or (b) require that it be manually disabled downstream, and also patch the page size downstream in PageBlock.h. You can imagine I don't like either option very much. :) Have you ever done any performance testing of bmalloc on aarch64? I'm curious to know whether it's any better than the system allocator. I assume it's probably not, but it still contains important heap security features, so it would be a shame to turn it off if not absolutely required. Maybe somebody who understands bmalloc could help with bug #209360. > Regardless of the fix for this crash, I don't think the increase to 64kB as > the page-size ceiling is welcome for ARM64 platforms that don't need it, > since it leads to quadrupling the size of the MarkedBlock objects. FWIW, the 64 KB page size is apparently performance-critical for some reason. I don't know or understand why. Maybe something about cache locality? 1635509 15 clopez 2020-03-30 08:06:34 -0700 (In reply to Michael Catanzaro from comment #14) > (In reply to Zan Dobersek from comment #13) > > FWIW the crash doesn't occur when bmalloc is disabled via `Malloc=1`. > > Ahhh, there we go, that explains it. Yes, bmalloc has to be disabled when > using sizes > 16 KB. The default CeilingOnPageSize of 64 KB is OK because > bmalloc is disabled by default except on whitelisted architectures. It fails > only on aarch64 because we have aarch64 whitelisted in WebKitFeatures.cmake. > But RHEL's build manually overrides this by passing -DUSE_SYSTEM_MALLOC=ON > for aarch64. I created bug #209360 to ask if it would be possible to fix > that, but no response yet. > > We could fix this by checking the page size at build time using sysconf(), > but Carlos Lopez pointed out that will fail when cross-compiling, which is > why I wound up just hardcoding page size guesses. So as long as bmalloc > crashes in this configuration, the only solutions I can think of are (a) > disable bmalloc for aarch64, even though it works on most systems, or (b) > require that it be manually disabled downstream, and also patch the page > size downstream in PageBlock.h. You can imagine I don't like either option > very much. :) > I also don't like any of the options, but I strongly prefer b) over a). AFAIK, all Linux ARM64 distributions but RHEL use a default 4KB page size, so I don't think crippling the majority of our users its acceptable because of an exception. Therefore I prefer if RHEL carries a patch downstream for this problem unless we can find a better fix. If you want to avoid carrying a patch, we can maybe add a new CMake internal config option that if set will take preference over the previous options: something like -DJSC_PAGE_SIZE=value and then you can define that to the value desired on the RHEL spec file. > Have you ever done any performance testing of bmalloc on aarch64? I'm > curious to know whether it's any better than the system allocator. I assume > it's probably not, but it still contains important heap security features, > so it would be a shame to turn it off if not absolutely required. Maybe > somebody who understands bmalloc could help with bug #209360. > > > Regardless of the fix for this crash, I don't think the increase to 64kB as > > the page-size ceiling is welcome for ARM64 platforms that don't need it, > > since it leads to quadrupling the size of the MarkedBlock objects. > > FWIW, the 64 KB page size is apparently performance-critical for some > reason. I don't know or understand why. Maybe something about cache locality? A 64KB page size on ARM64 allows for faster TLB lookups. However, it can also cause performance penalties if you are dealing with small data structures that have to be page aligned. It would be interesting to see some benchmark results to see how changing this value affects the performance of JSC. https://www.kernel.org/doc/Documentation/arm64/memory.txt https://wiki.ubuntu.com/ARM64/performance#A4k_page_size_vs_64k_page_size 1635531 16 mcatanzaro 2020-03-30 08:54:17 -0700 (In reply to Carlos Alberto Lopez Perez from comment #15) > AFAIK, all Linux ARM64 distributions but RHEL use a default 4KB page size, > so I don't think crippling the majority of our users its acceptable because > of an exception. Therefore I prefer if RHEL carries a patch downstream for > this problem unless we can find a better fix. I agree. > If you want to avoid carrying a patch, we can maybe add a new CMake internal > config option that if set will take preference over the previous options: > something like -DJSC_PAGE_SIZE=value and then you can define that to the > value desired on the RHEL spec file. I think that's the best we can do if fixing bmalloc is not possible. But I also think that fixing bmalloc should be possible. :) 1635533 17 mcatanzaro 2020-03-30 08:55:45 -0700 CC: bmalloc devs, since this has turned into a bmalloc bug. 1635539 18 mcatanzaro 2020-03-30 09:10:13 -0700 (In reply to Michael Catanzaro from comment #14) > We could fix this by checking the page size at build time using sysconf(), > but Carlos Lopez pointed out that will fail when cross-compiling, which is > why I wound up just hardcoding page size guesses. Maybe a build-time check would not be such a bad solution. Linux distros do not care about cross building (unless you are Gentoo). All distros are going to be building aarch64 packages natively using powerful aarch64 servers. Embedded systems devs also are not going to care in this particular case, because the page size check on the host system will return 4 KB, because nobody is going to be cross-building from anything except an x86_64 host. And that will match the target system, because nobody is going to be using something different than 4 KB on embedded systems. So even though it's definitely incorrect to do this, it should work OK in practice... trying to get page size at build time is incorrect anyway, we're just guessing here and hoping it doesn't change.... 1635547 19 clopez 2020-03-30 09:44:29 -0700 (In reply to Michael Catanzaro from comment #18) > (In reply to Michael Catanzaro from comment #14) > > We could fix this by checking the page size at build time using sysconf(), > > but Carlos Lopez pointed out that will fail when cross-compiling, which is > > why I wound up just hardcoding page size guesses. > > Maybe a build-time check would not be such a bad solution. > > Linux distros do not care about cross building (unless you are Gentoo). All > distros are going to be building aarch64 packages natively using powerful > aarch64 servers. > > Embedded systems devs also are not going to care in this particular case, > because the page size check on the host system will return 4 KB, because > nobody is going to be cross-building from anything except an x86_64 host. > And that will match the target system, because nobody is going to be using > something different than 4 KB on embedded systems. So even though it's > definitely incorrect to do this, it should work OK in practice... trying to > get page size at build time is incorrect anyway, we're just guessing here > and hoping it doesn't change.... I prefer that we do not do this, mainly because its incorrect and can lead to subtle bugs that are hard to diagnose. For example: What will happen if you cross-build for PPC64LE on AMD64? Also I don't think we can't affirm without doubt that "nobody is going to be cross-building from anything except an x86_64 host". That it's something we don't know. There are powerful boxes out there running on other architectures like PPC64 (Raptor Talos) or even ARM64. 1635549 20 zan 2020-03-30 09:51:45 -0700 (In reply to Michael Catanzaro from comment #14) > Have you ever done any performance testing of bmalloc on aarch64? I'm > curious to know whether it's any better than the system allocator. I assume > it's probably not, but it still contains important heap security features, > so it would be a shame to turn it off if not absolutely required. Maybe > somebody who understands bmalloc could help with bug #209360. > bmalloc is better than the system allocator both in performance and efficiency. It's unreasonable to turn off bmalloc by default for platforms that can use it. 1635604 21 mcatanzaro 2020-03-30 11:12:00 -0700 OK, good to know. Hopefully we can fix bmalloc. Otherwise, we don't have a ton of options here. 1636373 22 saam 2020-03-31 21:24:10 -0700 My guess is the commit/decommit of IsoHeaps both in JS and bmalloc are an issue here. What happens when you commit something smaller than page size? You may need to change those to use 64k. I think for bmalloc IsoHeaps, that should be trivial. I haven’t thought if this is trivial to do in JS, but I suspect it could be. 1636374 23 saam 2020-03-31 21:31:18 -0700 (In reply to Saam Barati from comment #22) > My guess is the commit/decommit of IsoHeaps both in JS and bmalloc are an > issue here. What happens when you commit something smaller than page size? > You may need to change those to use 64k. I think for bmalloc IsoHeaps, that > should be trivial. I haven’t thought if this is trivial to do in JS, but I > suspect it could be. Actually, it seems like the code in the JS heap should just work with 64k blocks. However, y'all didn't implement this inside bmalloc. You'll want to switch bmalloc's IsoHeaps to use CeilingOnPageSize sized blocks, and the configSizeToProtect to be CeilingOnPageSize inside bmalloc too. 1636379 24 saam 2020-03-31 21:37:57 -0700 These seem problematic: ``` class IsoPageBase { public: static constexpr size_t pageSize = 16384; ``` ``` constexpr size_t configSizeToProtect = 16 * bmalloc::Sizes::kB; ``` You might want to tune `m_smallLineMetadata` for 64k pages 1639891 25 mcatanzaro 2020-04-09 14:52:37 -0700 BTW, upstream kernel build options: config ARM64_4K_PAGES bool "4KB" help This feature enables 4KB pages support. config ARM64_16K_PAGES bool "16KB" help The system will use 16KB pages support. AArch32 emulation requires applications compiled with 16K (or a multiple of 16K) aligned segments. config ARM64_64K_PAGES bool "64KB" help This feature enables 64KB pages support (4KB by default) allowing only two levels of page tables and faster TLB look-up. AArch32 emulation requires applications compiled with 64K aligned segments. 1639899 26 mcatanzaro 2020-04-09 15:01:37 -0700 Of the WTF CPU types that are not UNKNOWN, it looks like MIPS also supports page sizes up to 64 KB. 1639923 27 396020 mcatanzaro 2020-04-09 15:36:56 -0700 Created attachment 396020 Patch 1639924 28 mcatanzaro 2020-04-09 15:38:50 -0700 (In reply to Carlos Alberto Lopez Perez from comment #0) > The JSCOnly ARM64 its crashing all of the time since r258857 We don't have an EWS for it... do we? I will test with the MIPS EWS, I guess. 1639934 29 clopez 2020-04-09 15:50:34 -0700 (In reply to Michael Catanzaro from comment #28) > (In reply to Carlos Alberto Lopez Perez from comment #0) > > The JSCOnly ARM64 its crashing all of the time since r258857 > > We don't have an EWS for it... do we? > > I will test with the MIPS EWS, I guess. No... no EWS at this moment. Only tests with buildbot at build.webkit.org after the fact 1639974 30 mcatanzaro 2020-04-09 17:19:11 -0700 MIPS EWS seems hung (stalled for five hours). 1653172 31 mcatanzaro 2020-05-15 14:25:53 -0700 Regression is fixed, we can continue in another bug in the future. 1708223 32 mcatanzaro 2020-11-17 07:32:31 -0800 (In reply to Zan Dobersek from comment #13) > Regardless of the fix for this crash, I don't think the increase to 64kB as > the page-size ceiling is welcome for ARM64 platforms that don't need it, > since it leads to quadrupling the size of the MarkedBlock objects. This is finally addressed by r269396. We continue to default to assuming page size is 4 KB to avoid regressing embedded systems, but allow distributions to declare that they need 64 KB at build time if needed. If that option is used, the size of MarkedBlock and other objects that depend on system page size (notably JSCConfig/WTFConfig) increases, and bmalloc and JIT both get disabled. Otherwise, no change. 394739 2020-03-27 11:47:19 -0700 2020-03-27 11:49:22 -0700 Patch bug-209670-20200327194717.patch text/plain 7915 clopez U3VidmVyc2lvbiBSZXZpc2lvbjogMjU5MTMwCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCBi NWRmOTdjYzFmNDNiNzgzZmVhMDMwZGE1YTRiYTBjNjVkNGFiOTgxLi5lMDU2ZjQ0YzU2ZTgyYmU4 ZjU4OWNiNDM4MjNmY2ViMzE2ZDIyNWNiIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNyBAQAorMjAyMC0wMy0yNyAgQ2FybG9zIEFsYmVydG8gTG9wZXogUGVyZXogIDxjbG9w ZXpAaWdhbGlhLmNvbT4KKworICAgICAgICBSRUdSRVNTSU9OKHIyNTg4NTcpOiBSZXZlcnQgcjI1 ODg1NyBiZWNhdXNlIGl0IGNhdXNlZCBhbGwgY3Jhc2hlcyBvbiB0aGUgSlNDT25seSBBUk02NCBi b3QuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDk2 NzAKKworICAgICAgICBVbnJldmlld2VkIHJldmVydC4KKworICAgICAgICBUaGlzIHJldmVydHMg cjI1ODg1NyBhbmQgcjI1OTAxOCAobmVlZGVkIHRvIHJldmVydCByMjU4ODU3KQorCisgICAgICAg ICogaGVhcC9NYXJrZWRCbG9jay5oOgorICAgICAgICAqIHJ1bnRpbWUvSlNDQ29uZmlnLmNwcDoK KyAgICAgICAgKEpTQzo6Q29uZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSk6CisgICAgICAgICogcnVu dGltZS9KU0NDb25maWcuaDoKKwogMjAyMC0wMy0yNyAgS2VpdGggTWlsbGVyICA8a2VpdGhfbWls bGVyQGFwcGxlLmNvbT4KIAogICAgICAgICBBZGQgbWlzc2luZyBzY29wZSByZWxlYXNlIHRvIERh dGFWaWV3J3MgYnVmZmVyIGdldHRlcgpAQCAtNTM1LDE4ICs1NDksNiBAQAogICAgICAgICAoSlND OjpQYXJzZXI6OmRlY2xhcmVWYXJpYWJsZSk6CiAgICAgICAgIChKU0M6OlBhcnNlcjo6ZGVjbGFy ZUZ1bmN0aW9uKToKIAotMjAyMC0wMy0yMyAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJv QGdub21lLm9yZz4KLQotICAgICAgICBSRUdSRVNTSU9OKHIyNDk4MDgpOiBbR1RLXSBDcmFzaCBp biBKU0MgQ29uZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSgpIG9uIGFyY2hpdGVjdHVyZSBwcGM2NGVs Ci0gICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDkyMzYK LQotICAgICAgICBSZXZpZXdlZCBieSBNYXJrIExhbS4KLQotICAgICAgICAqIGhlYXAvTWFya2Vk QmxvY2suaDogVXNlIG5ldyBDZWlsaW5nT25QYWdlU2l6ZS4KLSAgICAgICAgKiBydW50aW1lL0pT Q0NvbmZpZy5jcHA6Ci0gICAgICAgIChKU0M6OkNvbmZpZzo6cGVybWFuZW50bHlGcmVlemUpOiBV c2UgcGFnZVNpemUgaW5zdGVhZCBvZiB2bVBhZ2VTaXplLgotICAgICAgICAqIHJ1bnRpbWUvSlND Q29uZmlnLmg6IFVzZSBuZXcgQ2VpbGluZ09uUGFnZVNpemUuCi0KIDIwMjAtMDMtMjIgIFl1c3Vr ZSBTdXp1a2kgIDx5c3V6dWtpQGFwcGxlLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCByZW5h bWUga2VlcEFsaXZlIHRvIGVuc3VyZVN0aWxsQWxpdmVIZXJlCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V1RGL0NoYW5nZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGRhNzdiNGQ2MDdlNjJm OGFhOWRkZDkxODM5ODg0ZGI2ZTNkYzkzY2YuLjc2MTgxNGUxZDY3NWNmMzljZmYwNGE0NzM4MjZl ODE5NDliN2U5NWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XVEYvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMjAtMDMtMjcgIENhcmxvcyBBbGJl cnRvIExvcGV6IFBlcmV6ICA8Y2xvcGV6QGlnYWxpYS5jb20+CisKKyAgICAgICAgUkVHUkVTU0lP TihyMjU4ODU3KTogUmV2ZXJ0IHIyNTg4NTcgYmVjYXVzZSBpdCBjYXVzZWQgYWxsIGNyYXNoZXMg b24gdGhlIEpTQ09ubHkgQVJNNjQgYm90LgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjA5NjcwCisKKyAgICAgICAgVW5yZXZpZXdlZCByZXZlcnQuCisK KyAgICAgICAgVGhpcyByZXZlcnRzIHIyNTg4NTcuCisKKyAgICAgICAgKiB3dGYvUGFnZUJsb2Nr LmNwcDoKKyAgICAgICAgKFdURjo6c3lzdGVtUGFnZVNpemUpOgorICAgICAgICAoV1RGOjpwYWdl U2l6ZSk6CisgICAgICAgICogd3RmL1BhZ2VCbG9jay5oOgorCiAyMDIwLTAzLTI2ICBNaWNoYWVs IENhdGFuemFybyAgPG1jYXRhbnphcm9AZ25vbWUub3JnPgogCiAgICAgICAgIEZpeCB2YXJpb3Vz IGNvbXBpbGVyIHdhcm5pbmdzCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaGVh cC9NYXJrZWRCbG9jay5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvTWFya2VkQmxvY2su aAppbmRleCBhZDE2YTRiZDZiZTdjNWU5YzZiZTE0ZjUyNDdmOGE0MzQ5YjcwNzc3Li5lODA0ZTFi ZDdiZWY5OTZiY2RjYWMzNjRjZDUxMjlhMTA2MWJkNWZmIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvaGVhcC9NYXJrZWRCbG9jay5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9oZWFwL01hcmtlZEJsb2NrLmgKQEAgLTI2LDEyICsyNiwxMCBAQAogI2luY2x1ZGUgIkhlYXBD ZWxsLmgiCiAjaW5jbHVkZSAiSXRlcmF0aW9uU3RhdHVzLmgiCiAjaW5jbHVkZSAiV2Vha1NldC5o IgotI2luY2x1ZGUgPGFsZ29yaXRobT4KICNpbmNsdWRlIDx3dGYvQXRvbWljcy5oPgogI2luY2x1 ZGUgPHd0Zi9CaXRtYXAuaD4KLSNpbmNsdWRlIDx3dGYvQ291bnRpbmdMb2NrLmg+CiAjaW5jbHVk ZSA8d3RmL0hhc2hGdW5jdGlvbnMuaD4KLSNpbmNsdWRlIDx3dGYvUGFnZUJsb2NrLmg+CisjaW5j bHVkZSA8d3RmL0NvdW50aW5nTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4K IAogbmFtZXNwYWNlIEpTQyB7CkBAIC03Miw3ICs3MCwxMSBAQCBwdWJsaWM6CiAgICAgc3RhdGlj IGNvbnN0ZXhwciBzaXplX3QgYXRvbVNpemUgPSAxNjsgLy8gYnl0ZXMKIAogICAgIC8vIEJsb2Nr IHNpemUgbXVzdCBiZSBhdCBsZWFzdCBhcyBsYXJnZSBhcyB0aGUgc3lzdGVtIHBhZ2Ugc2l6ZS4K LSAgICBzdGF0aWMgY29uc3RleHByIHNpemVfdCBibG9ja1NpemUgPSBzdGQ6Om1heCgxNiAqIEtC LCBDZWlsaW5nT25QYWdlU2l6ZSk7CisjaWYgQ1BVKFBQQzY0KSB8fCBDUFUoUFBDNjRMRSkgfHwg Q1BVKFBQQykgfHwgQ1BVKFVOS05PV04pCisgICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3QgYmxv Y2tTaXplID0gNjQgKiBLQjsKKyNlbHNlCisgICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3QgYmxv Y2tTaXplID0gMTYgKiBLQjsKKyNlbmRpZgogCiAgICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3Qg YmxvY2tNYXNrID0gfihibG9ja1NpemUgLSAxKTsgLy8gYmxvY2tTaXplIG11c3QgYmUgYSBwb3dl ciBvZiB0d28uCiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pT Q0NvbmZpZy5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0NDb25maWcuY3Bw CmluZGV4IDZmZGIzZWUwMGU1OWM1M2Y2ODdmZGY1OTJjYTkyZjQ2N2I5NGQwYTEuLjc5Y2MyYjY3 YmE5MDUwNDFiZTkzM2Q3YTI1M2IxMjc1NDViNzZiYjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL3J1bnRpbWUvSlNDQ29uZmlnLmNwcApAQCAtNTMsNyArNTMsOSBAQCB2b2lkIENvbmZpZzo6 ZW5hYmxlUmVzdHJpY3RlZE9wdGlvbnMoKQogICAgIAogdm9pZCBDb25maWc6OnBlcm1hbmVudGx5 RnJlZXplKCkKIHsKLSAgICBSRUxFQVNFX0FTU0VSVChyb3VuZFVwVG9NdWx0aXBsZU9mKHBhZ2VT aXplKCksIENvbmZpZ1NpemVUb1Byb3RlY3QpID09IENvbmZpZ1NpemVUb1Byb3RlY3QpOworI2lm IFBMQVRGT1JNKENPQ09BKQorICAgIFJFTEVBU0VfQVNTRVJUKHJvdW5kVXBUb011bHRpcGxlT2Yo dm1QYWdlU2l6ZSgpLCBDb25maWdTaXplVG9Qcm90ZWN0KSA9PSBDb25maWdTaXplVG9Qcm90ZWN0 KTsKKyNlbmRpZgogCiAgICAgaWYgKCFnX2pzY0NvbmZpZy5pc1Blcm1hbmVudGx5RnJvemVuKQog ICAgICAgICBnX2pzY0NvbmZpZy5pc1Blcm1hbmVudGx5RnJvemVuID0gdHJ1ZTsKZGlmZiAtLWdp dCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5oIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29uZmlnLmgKaW5kZXggYWE5YmZlNmM2MTg0NDIwZTYy YWY2NDdlODJiMzllMTZjMjU5NWJhZi4uMWFlNTNhNTY0MzFhNTk4NGY0OTk1YmUxODFjYjZkYmMx MmNhZTc2YiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29u ZmlnLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29uZmlnLmgKQEAg LTI2LDcgKzI2LDYgQEAKICNwcmFnbWEgb25jZQogCiAjaW5jbHVkZSAiT3B0aW9uc0xpc3QuaCIK LSNpbmNsdWRlIDx3dGYvUGFnZUJsb2NrLmg+CiAjaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5o PgogCiBuYW1lc3BhY2UgSlNDIHsKQEAgLTM1LDcgKzM0LDExIEBAIGNsYXNzIEV4ZWN1dGFibGVB bGxvY2F0b3I7CiBjbGFzcyBGaXhlZFZNUG9vbEV4ZWN1dGFibGVBbGxvY2F0b3I7CiBjbGFzcyBW TTsKIAotY29uc3RleHByIHNpemVfdCBDb25maWdTaXplVG9Qcm90ZWN0ID0gQ2VpbGluZ09uUGFn ZVNpemU7CisjaWYgIU9TKFdJTkRPV1MpCitjb25zdGV4cHIgc2l6ZV90IENvbmZpZ1NpemVUb1By b3RlY3QgPSAxNiAqIEtCOworI2Vsc2UKK2NvbnN0ZXhwciBzaXplX3QgQ29uZmlnU2l6ZVRvUHJv dGVjdCA9IDQgKiBLQjsKKyNlbmRpZgogCiAjaWYgRU5BQkxFKFNFUEFSQVRFRF9XWF9IRUFQKQog dXNpbmcgSklUV3JpdGVTZXBhcmF0ZUhlYXBzRnVuY3Rpb24gPSB2b2lkICgqKShvZmZfdCwgY29u c3Qgdm9pZCosIHNpemVfdCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2su Y3BwIGIvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmNwcAppbmRleCA1ZDBhY2FkZDRiMWYyZTA0 NDJkOWEzZjEzYmU2ZDQwN2I1ZDFjOTNmLi4zNzM4MWIyZTUyMjg3NTQ0ZGUyYjNkZDBlMzk4ZWFj ZjIxNTE4MzIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suY3BwCisrKyBi L1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5jcHAKQEAgLTQ0LDcgKzQ0LDcgQEAgc3RhdGljIHNp emVfdCBzX3BhZ2VNYXNrOwogCiBpbmxpbmUgc2l6ZV90IHN5c3RlbVBhZ2VTaXplKCkKIHsKLSAg ICByZXR1cm4gc3lzY29uZihfU0NfUEFHRVNJWkUpOworICAgIHJldHVybiBnZXRwYWdlc2l6ZSgp OwogfQogCiAjZWxpZiBPUyhXSU5ET1dTKQpAQCAtNjIsMTEgKzYyLDkgQEAgaW5saW5lIHNpemVf dCBzeXN0ZW1QYWdlU2l6ZSgpCiAKIHNpemVfdCBwYWdlU2l6ZSgpCiB7Ci0gICAgaWYgKCFzX3Bh Z2VTaXplKSB7CisgICAgaWYgKCFzX3BhZ2VTaXplKQogICAgICAgICBzX3BhZ2VTaXplID0gc3lz dGVtUGFnZVNpemUoKTsKLSAgICAgICAgUkVMRUFTRV9BU1NFUlQoaXNQb3dlck9mVHdvKHNfcGFn ZVNpemUpKTsKLSAgICAgICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKHNfcGFnZVNpemUg PD0gQ2VpbGluZ09uUGFnZVNpemUsICJDZWlsaW5nT25QYWdlU2l6ZSBpcyB0b28gbG93LCByYWlz ZSBpdCBpbiBQYWdlQmxvY2suaCEiKTsKLSAgICB9CisgICAgQVNTRVJUKGlzUG93ZXJPZlR3byhz X3BhZ2VTaXplKSk7CiAgICAgcmV0dXJuIHNfcGFnZVNpemU7CiB9CiAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5oIGIvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmgKaW5k ZXggNDI1YzlkOWU2NjJmMDc3OTY5MWZkNmUwNjFiNTNjMmExNGRlMTJlZC4uYjUyYzM5ZTBiMTAx ZDNlNDdlNTkzMDRmYTI4N2ZhM2I3YWE3ZTUxNiAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYv UGFnZUJsb2NrLmgKKysrIGIvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmgKQEAgLTI1LDM4ICsy NSw4IEBACiAKICNwcmFnbWEgb25jZQogCi0jaW5jbHVkZSA8d3RmL1N0ZExpYkV4dHJhcy5oPgot CiBuYW1lc3BhY2UgV1RGIHsKIAotLy8gV2UgYXR0ZW1wdCB0byBndWVzcyBhIHZhbHVlIHRoYXQg aXMgKkFUIExFQVNUKiBhcyBsYXJnZSBhcyB0aGUgc3lzdGVtJ3MgYWN0dWFsIHBhZ2Ugc2l6ZS4K LS8vIFRoaXMgaXMgaW1wb3NzaWJsZSB0byBkbyBjb3JyZWN0bHkgYXQgYnVpbGQgdGltZSwgYnV0 IEpTQyByZWFsbHkgbmVlZHMgaXQgYXQgYnVpbGQgdGltZSwgc28KLS8vIHdlIGhhdmUgYSBSRUxF QVNFX0FTU0VSVCgpIGluc2lkZSBXVEY6OnBhZ2VTaXplIHRvIG1ha2Ugc3VyZSBpdCBpcyBzZXQg cHJvcGVybHkgYXQgcnVudGltZS4KLS8vIEFsbCBvZiB0aGVzZSB2YWx1ZXMgYXJlIGdvaW5nIHRv IGJlIGluY29ycmVjdCBvbiBzeXN0ZW1zIGNvbmZpZ3VyZWQgdG8gdXNlIGxhcmdlciB0aGFuIG5v cm1hbAotLy8gcGFnZSBzaXplLCBzbyBvbiBzdWNoIHN5c3RlbXMgaXQgaXMgZXhwZWN0ZWQgdGhh dCBXZWJLaXQgd2lsbCBjcmFzaCB1bnRpbCB0aGlzIHZhbHVlIGlzIGNoYW5nZWQKLS8vIGFuZCBy ZWNvbXBpbGVkLiBTb3JyeS4KLS8vCi0vLyBtYWNPUyB4ODZfNjQgdXNlcyA0IEtpQiwgYnV0IEFw cGxlJ3MgYWFyY2g2NCBzeXN0ZW1zIHVzZSAxNiBLaUIuIFVzZSAxNiBLaUIgb24gYWxsIEFwcGxl IHN5c3RlbXMKLS8vIGZvciBjb25zaXN0ZW5jeS4KLS8vCi0vLyBNb3N0IExpbnV4IGFuZCBXaW5k b3dzIHN5c3RlbXMgdXNlIGEgcGFnZSBzaXplIG9mIDQgS2lCLgotLy8KLS8vIE9uIExpbnV4LCBQ b3dlciBzeXN0ZW1zIG5vcm1hbGx5IHVzZSA2NCBLaUIgcGFnZXMuCi0vLwotLy8gYWFyY2g2NCBz eXN0ZW1zIHNlZW0gdG8gYmUgYWxsIG92ZXIgdGhlIHBsYWNlLiBNb3N0IExpbnV4IGRpc3Ryb3Mg dXNlIDQgS2lCLCBidXQgUkhFTCB1c2VzCi0vLyA2NCBLaUIuIChBcHBsZSB1c2VzIDE2IEtpQi4p Ci0vLwotLy8gVXNlIDY0IEtpQiBmb3IgYW55IHVua25vd24gQ1BVcyB0byBiZSBjb25zZXJ2YXRp dmUuCi0jaWYgT1MoREFSV0lOKSB8fCBQTEFURk9STShQTEFZU1RBVElPTikKLWNvbnN0ZXhwciBz aXplX3QgQ2VpbGluZ09uUGFnZVNpemUgPSAxNiAqIEtCOwotI2VsaWYgT1MoV0lORE9XUykgfHwg Q1BVKE1JUFMpIHx8IENQVShYODYpIHx8IENQVShYODZfNjQpIHx8IENQVShBUk0pCi1jb25zdGV4 cHIgc2l6ZV90IENlaWxpbmdPblBhZ2VTaXplID0gNCAqIEtCOwotI2VsaWYgQ1BVKFVOS05PV04p IHx8IENQVShQUEMpIHx8IENQVShQUEM2NCkgfHwgQ1BVKFBQQzY0TEUpIHx8IENQVShBUk02NCkK LWNvbnN0ZXhwciBzaXplX3QgQ2VpbGluZ09uUGFnZVNpemUgPSA2NCAqIEtCOwotI2Vsc2UKLSNl cnJvciBNdXN0IHNldCBDZWlsaW5nT25QYWdlU2l6ZSBpbiBQYWdlQmxvY2suaCB3aGVuIGFkZGlu ZyBhIG5ldyBDUFUgYXJjaGl0ZWN0dXJlIQotI2VuZGlmCi0KIFdURl9FWFBPUlRfUFJJVkFURSBz aXplX3QgcGFnZVNpemUoKTsKIFdURl9FWFBPUlRfUFJJVkFURSBzaXplX3QgcGFnZU1hc2soKTsK IGlubGluZSBib29sIGlzUGFnZUFsaWduZWQodm9pZCogYWRkcmVzcykgeyByZXR1cm4gIShyZWlu dGVycHJldF9jYXN0PGludHB0cl90PihhZGRyZXNzKSAmIChwYWdlU2l6ZSgpIC0gMSkpOyB9CkBA IC0xMTAsNyArODAsNiBAQCBpbmxpbmUgUGFnZUJsb2NrOjpQYWdlQmxvY2sodm9pZCogYmFzZSwg c2l6ZV90IHNpemUsIGJvb2wgaGFzR3VhcmRQYWdlcykKIAogfSAvLyBuYW1lc3BhY2UgV1RGCiAK LXVzaW5nIFdURjo6Q2VpbGluZ09uUGFnZVNpemU7CiB1c2luZyBXVEY6OnBhZ2VTaXplOwogdXNp bmcgV1RGOjppc1BhZ2VBbGlnbmVkOwogdXNpbmcgV1RGOjppc1Bvd2VyT2ZUd287Cg== 394741 2020-03-27 11:50:01 -0700 2020-03-27 12:08:30 -0700 Patch bug-209670-20200327195000.patch text/plain 7217 clopez U3VidmVyc2lvbiBSZXZpc2lvbjogMjU5MTMwCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvQ2hhbmdlTG9nIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwppbmRleCBi NWRmOTdjYzFmNDNiNzgzZmVhMDMwZGE1YTRiYTBjNjVkNGFiOTgxLi4wMzU3N2E2ODM3OTU0ZmEw YzhhZGY4OGFhOGI2MDQyNWRiMWQ2M2UxIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwxNyBAQAorMjAyMC0wMy0yNyAgQ2FybG9zIEFsYmVydG8gTG9wZXogUGVyZXogIDxjbG9w ZXpAaWdhbGlhLmNvbT4KKworICAgICAgICBSRUdSRVNTSU9OKHIyNTg4NTcpOiBSZXZlcnQgcjI1 ODg1NyBiZWNhdXNlIGl0IGNhdXNlZCBhbGwgY3Jhc2hlcyBvbiB0aGUgSlNDT25seSBBUk02NCBi b3QuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDk2 NzAKKworICAgICAgICBVbnJldmlld2VkIHJldmVydC4KKworICAgICAgICBUaGlzIHJldmVydHMg cjI1ODg1NyBhbmQgcjI1OTAxOCAobmVlZGVkIHRvIHJldmVydCByMjU4ODU3KQorCisgICAgICAg ICogaGVhcC9NYXJrZWRCbG9jay5oOgorICAgICAgICAqIHJ1bnRpbWUvSlNDQ29uZmlnLmNwcDoK KyAgICAgICAgKEpTQzo6Q29uZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSk6CisgICAgICAgICogcnVu dGltZS9KU0NDb25maWcuaDoKKwogMjAyMC0wMy0yNyAgS2VpdGggTWlsbGVyICA8a2VpdGhfbWls bGVyQGFwcGxlLmNvbT4KIAogICAgICAgICBBZGQgbWlzc2luZyBzY29wZSByZWxlYXNlIHRvIERh dGFWaWV3J3MgYnVmZmVyIGdldHRlcgpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi9DaGFuZ2VMb2cg Yi9Tb3VyY2UvV1RGL0NoYW5nZUxvZwppbmRleCBkYTc3YjRkNjA3ZTYyZjhhYTlkZGQ5MTgzOTg4 NGRiNmUzZGM5M2NmLi43NjE4MTRlMWQ2NzVjZjM5Y2ZmMDRhNDczODI2ZTgxOTQ5YjdlOTViIDEw MDY0NAotLS0gYS9Tb3VyY2UvV1RGL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV1RGL0NoYW5nZUxv ZwpAQCAtMSwzICsxLDE3IEBACisyMDIwLTAzLTI3ICBDYXJsb3MgQWxiZXJ0byBMb3BleiBQZXJl eiAgPGNsb3BlekBpZ2FsaWEuY29tPgorCisgICAgICAgIFJFR1JFU1NJT04ocjI1ODg1Nyk6IFJl dmVydCByMjU4ODU3IGJlY2F1c2UgaXQgY2F1c2VkIGFsbCBjcmFzaGVzIG9uIHRoZSBKU0NPbmx5 IEFSTTY0IGJvdC4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTIwOTY3MAorCisgICAgICAgIFVucmV2aWV3ZWQgcmV2ZXJ0LgorCisgICAgICAgIFRoaXMg cmV2ZXJ0cyByMjU4ODU3LgorCisgICAgICAgICogd3RmL1BhZ2VCbG9jay5jcHA6CisgICAgICAg IChXVEY6OnN5c3RlbVBhZ2VTaXplKToKKyAgICAgICAgKFdURjo6cGFnZVNpemUpOgorICAgICAg ICAqIHd0Zi9QYWdlQmxvY2suaDoKKwogMjAyMC0wMy0yNiAgTWljaGFlbCBDYXRhbnphcm8gIDxt Y2F0YW56YXJvQGdub21lLm9yZz4KIAogICAgICAgICBGaXggdmFyaW91cyBjb21waWxlciB3YXJu aW5ncwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2hlYXAvTWFya2VkQmxvY2su aCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL01hcmtlZEJsb2NrLmgKaW5kZXggYWQxNmE0 YmQ2YmU3YzVlOWM2YmUxNGY1MjQ3ZjhhNDM0OWI3MDc3Ny4uZTgwNGUxYmQ3YmVmOTk2YmNkY2Fj MzY0Y2Q1MTI5YTEwNjFiZDVmZiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL2hl YXAvTWFya2VkQmxvY2suaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaGVhcC9NYXJrZWRC bG9jay5oCkBAIC0yNiwxMiArMjYsMTAgQEAKICNpbmNsdWRlICJIZWFwQ2VsbC5oIgogI2luY2x1 ZGUgIkl0ZXJhdGlvblN0YXR1cy5oIgogI2luY2x1ZGUgIldlYWtTZXQuaCIKLSNpbmNsdWRlIDxh bGdvcml0aG0+CiAjaW5jbHVkZSA8d3RmL0F0b21pY3MuaD4KICNpbmNsdWRlIDx3dGYvQml0bWFw Lmg+Ci0jaW5jbHVkZSA8d3RmL0NvdW50aW5nTG9jay5oPgogI2luY2x1ZGUgPHd0Zi9IYXNoRnVu Y3Rpb25zLmg+Ci0jaW5jbHVkZSA8d3RmL1BhZ2VCbG9jay5oPgorI2luY2x1ZGUgPHd0Zi9Db3Vu dGluZ0xvY2suaD4KICNpbmNsdWRlIDx3dGYvU3RkTGliRXh0cmFzLmg+CiAKIG5hbWVzcGFjZSBK U0MgewpAQCAtNzIsNyArNzAsMTEgQEAgcHVibGljOgogICAgIHN0YXRpYyBjb25zdGV4cHIgc2l6 ZV90IGF0b21TaXplID0gMTY7IC8vIGJ5dGVzCiAKICAgICAvLyBCbG9jayBzaXplIG11c3QgYmUg YXQgbGVhc3QgYXMgbGFyZ2UgYXMgdGhlIHN5c3RlbSBwYWdlIHNpemUuCi0gICAgc3RhdGljIGNv bnN0ZXhwciBzaXplX3QgYmxvY2tTaXplID0gc3RkOjptYXgoMTYgKiBLQiwgQ2VpbGluZ09uUGFn ZVNpemUpOworI2lmIENQVShQUEM2NCkgfHwgQ1BVKFBQQzY0TEUpIHx8IENQVShQUEMpIHx8IENQ VShVTktOT1dOKQorICAgIHN0YXRpYyBjb25zdGV4cHIgc2l6ZV90IGJsb2NrU2l6ZSA9IDY0ICog S0I7CisjZWxzZQorICAgIHN0YXRpYyBjb25zdGV4cHIgc2l6ZV90IGJsb2NrU2l6ZSA9IDE2ICog S0I7CisjZW5kaWYKIAogICAgIHN0YXRpYyBjb25zdGV4cHIgc2l6ZV90IGJsb2NrTWFzayA9IH4o YmxvY2tTaXplIC0gMSk7IC8vIGJsb2NrU2l6ZSBtdXN0IGJlIGEgcG93ZXIgb2YgdHdvLgogCmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9KU0NDb25maWcuY3BwIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNDQ29uZmlnLmNwcAppbmRleCA2ZmRiM2Vl MDBlNTljNTNmNjg3ZmRmNTkyY2E5MmY0NjdiOTRkMGExLi43OWNjMmI2N2JhOTA1MDQxYmU5MzNk N2EyNTNiMTI3NTQ1Yjc2YmI5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVu dGltZS9KU0NDb25maWcuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pT Q0NvbmZpZy5jcHAKQEAgLTUzLDcgKzUzLDkgQEAgdm9pZCBDb25maWc6OmVuYWJsZVJlc3RyaWN0 ZWRPcHRpb25zKCkKICAgICAKIHZvaWQgQ29uZmlnOjpwZXJtYW5lbnRseUZyZWV6ZSgpCiB7Ci0g ICAgUkVMRUFTRV9BU1NFUlQocm91bmRVcFRvTXVsdGlwbGVPZihwYWdlU2l6ZSgpLCBDb25maWdT aXplVG9Qcm90ZWN0KSA9PSBDb25maWdTaXplVG9Qcm90ZWN0KTsKKyNpZiBQTEFURk9STShDT0NP QSkKKyAgICBSRUxFQVNFX0FTU0VSVChyb3VuZFVwVG9NdWx0aXBsZU9mKHZtUGFnZVNpemUoKSwg Q29uZmlnU2l6ZVRvUHJvdGVjdCkgPT0gQ29uZmlnU2l6ZVRvUHJvdGVjdCk7CisjZW5kaWYKIAog ICAgIGlmICghZ19qc2NDb25maWcuaXNQZXJtYW5lbnRseUZyb3plbikKICAgICAgICAgZ19qc2ND b25maWcuaXNQZXJtYW5lbnRseUZyb3plbiA9IHRydWU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvcnVudGltZS9KU0NDb25maWcuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9y dW50aW1lL0pTQ0NvbmZpZy5oCmluZGV4IGFhOWJmZTZjNjE4NDQyMGU2MmFmNjQ3ZTgyYjM5ZTE2 YzI1OTViYWYuLjFhZTUzYTU2NDMxYTU5ODRmNDk5NWJlMTgxY2I2ZGJjMTJjYWU3NmIgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5oCisrKyBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ0NvbmZpZy5oCkBAIC0yNiw3ICsyNiw2IEBA CiAjcHJhZ21hIG9uY2UKIAogI2luY2x1ZGUgIk9wdGlvbnNMaXN0LmgiCi0jaW5jbHVkZSA8d3Rm L1BhZ2VCbG9jay5oPgogI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KIAogbmFtZXNwYWNl IEpTQyB7CkBAIC0zNSw3ICszNCwxMSBAQCBjbGFzcyBFeGVjdXRhYmxlQWxsb2NhdG9yOwogY2xh c3MgRml4ZWRWTVBvb2xFeGVjdXRhYmxlQWxsb2NhdG9yOwogY2xhc3MgVk07CiAKLWNvbnN0ZXhw ciBzaXplX3QgQ29uZmlnU2l6ZVRvUHJvdGVjdCA9IENlaWxpbmdPblBhZ2VTaXplOworI2lmICFP UyhXSU5ET1dTKQorY29uc3RleHByIHNpemVfdCBDb25maWdTaXplVG9Qcm90ZWN0ID0gMTYgKiBL QjsKKyNlbHNlCitjb25zdGV4cHIgc2l6ZV90IENvbmZpZ1NpemVUb1Byb3RlY3QgPSA0ICogS0I7 CisjZW5kaWYKIAogI2lmIEVOQUJMRShTRVBBUkFURURfV1hfSEVBUCkKIHVzaW5nIEpJVFdyaXRl U2VwYXJhdGVIZWFwc0Z1bmN0aW9uID0gdm9pZCAoKikob2ZmX3QsIGNvbnN0IHZvaWQqLCBzaXpl X3QpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmNwcCBiL1NvdXJjZS9X VEYvd3RmL1BhZ2VCbG9jay5jcHAKaW5kZXggNWQwYWNhZGQ0YjFmMmUwNDQyZDlhM2YxM2JlNmQ0 MDdiNWQxYzkzZi4uMzczODFiMmU1MjI4NzU0NGRlMmIzZGQwZTM5OGVhY2YyMTUxODMyMCAxMDA2 NDQKLS0tIGEvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmNwcAorKysgYi9Tb3VyY2UvV1RGL3d0 Zi9QYWdlQmxvY2suY3BwCkBAIC00NCw3ICs0NCw3IEBAIHN0YXRpYyBzaXplX3Qgc19wYWdlTWFz azsKIAogaW5saW5lIHNpemVfdCBzeXN0ZW1QYWdlU2l6ZSgpCiB7Ci0gICAgcmV0dXJuIHN5c2Nv bmYoX1NDX1BBR0VTSVpFKTsKKyAgICByZXR1cm4gZ2V0cGFnZXNpemUoKTsKIH0KIAogI2VsaWYg T1MoV0lORE9XUykKQEAgLTYyLDExICs2Miw5IEBAIGlubGluZSBzaXplX3Qgc3lzdGVtUGFnZVNp emUoKQogCiBzaXplX3QgcGFnZVNpemUoKQogewotICAgIGlmICghc19wYWdlU2l6ZSkgeworICAg IGlmICghc19wYWdlU2l6ZSkKICAgICAgICAgc19wYWdlU2l6ZSA9IHN5c3RlbVBhZ2VTaXplKCk7 Ci0gICAgICAgIFJFTEVBU0VfQVNTRVJUKGlzUG93ZXJPZlR3byhzX3BhZ2VTaXplKSk7Ci0gICAg ICAgIFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRShzX3BhZ2VTaXplIDw9IENlaWxpbmdPblBh Z2VTaXplLCAiQ2VpbGluZ09uUGFnZVNpemUgaXMgdG9vIGxvdywgcmFpc2UgaXQgaW4gUGFnZUJs b2NrLmghIik7Ci0gICAgfQorICAgIEFTU0VSVChpc1Bvd2VyT2ZUd28oc19wYWdlU2l6ZSkpOwog ICAgIHJldHVybiBzX3BhZ2VTaXplOwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9Q YWdlQmxvY2suaCBiL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5oCmluZGV4IDQyNWM5ZDllNjYy ZjA3Nzk2OTFmZDZlMDYxYjUzYzJhMTRkZTEyZWQuLmI1MmMzOWUwYjEwMWQzZTQ3ZTU5MzA0ZmEy ODdmYTNiN2FhN2U1MTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5oCisr KyBiL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5oCkBAIC0yNSwzOCArMjUsOCBAQAogCiAjcHJh Z21hIG9uY2UKIAotI2luY2x1ZGUgPHd0Zi9TdGRMaWJFeHRyYXMuaD4KLQogbmFtZXNwYWNlIFdU RiB7CiAKLS8vIFdlIGF0dGVtcHQgdG8gZ3Vlc3MgYSB2YWx1ZSB0aGF0IGlzICpBVCBMRUFTVCog YXMgbGFyZ2UgYXMgdGhlIHN5c3RlbSdzIGFjdHVhbCBwYWdlIHNpemUuCi0vLyBUaGlzIGlzIGlt cG9zc2libGUgdG8gZG8gY29ycmVjdGx5IGF0IGJ1aWxkIHRpbWUsIGJ1dCBKU0MgcmVhbGx5IG5l ZWRzIGl0IGF0IGJ1aWxkIHRpbWUsIHNvCi0vLyB3ZSBoYXZlIGEgUkVMRUFTRV9BU1NFUlQoKSBp bnNpZGUgV1RGOjpwYWdlU2l6ZSB0byBtYWtlIHN1cmUgaXQgaXMgc2V0IHByb3Blcmx5IGF0IHJ1 bnRpbWUuCi0vLyBBbGwgb2YgdGhlc2UgdmFsdWVzIGFyZSBnb2luZyB0byBiZSBpbmNvcnJlY3Qg b24gc3lzdGVtcyBjb25maWd1cmVkIHRvIHVzZSBsYXJnZXIgdGhhbiBub3JtYWwKLS8vIHBhZ2Ug c2l6ZSwgc28gb24gc3VjaCBzeXN0ZW1zIGl0IGlzIGV4cGVjdGVkIHRoYXQgV2ViS2l0IHdpbGwg Y3Jhc2ggdW50aWwgdGhpcyB2YWx1ZSBpcyBjaGFuZ2VkCi0vLyBhbmQgcmVjb21waWxlZC4gU29y cnkuCi0vLwotLy8gbWFjT1MgeDg2XzY0IHVzZXMgNCBLaUIsIGJ1dCBBcHBsZSdzIGFhcmNoNjQg c3lzdGVtcyB1c2UgMTYgS2lCLiBVc2UgMTYgS2lCIG9uIGFsbCBBcHBsZSBzeXN0ZW1zCi0vLyBm b3IgY29uc2lzdGVuY3kuCi0vLwotLy8gTW9zdCBMaW51eCBhbmQgV2luZG93cyBzeXN0ZW1zIHVz ZSBhIHBhZ2Ugc2l6ZSBvZiA0IEtpQi4KLS8vCi0vLyBPbiBMaW51eCwgUG93ZXIgc3lzdGVtcyBu b3JtYWxseSB1c2UgNjQgS2lCIHBhZ2VzLgotLy8KLS8vIGFhcmNoNjQgc3lzdGVtcyBzZWVtIHRv IGJlIGFsbCBvdmVyIHRoZSBwbGFjZS4gTW9zdCBMaW51eCBkaXN0cm9zIHVzZSA0IEtpQiwgYnV0 IFJIRUwgdXNlcwotLy8gNjQgS2lCLiAoQXBwbGUgdXNlcyAxNiBLaUIuKQotLy8KLS8vIFVzZSA2 NCBLaUIgZm9yIGFueSB1bmtub3duIENQVXMgdG8gYmUgY29uc2VydmF0aXZlLgotI2lmIE9TKERB UldJTikgfHwgUExBVEZPUk0oUExBWVNUQVRJT04pCi1jb25zdGV4cHIgc2l6ZV90IENlaWxpbmdP blBhZ2VTaXplID0gMTYgKiBLQjsKLSNlbGlmIE9TKFdJTkRPV1MpIHx8IENQVShNSVBTKSB8fCBD UFUoWDg2KSB8fCBDUFUoWDg2XzY0KSB8fCBDUFUoQVJNKQotY29uc3RleHByIHNpemVfdCBDZWls aW5nT25QYWdlU2l6ZSA9IDQgKiBLQjsKLSNlbGlmIENQVShVTktOT1dOKSB8fCBDUFUoUFBDKSB8 fCBDUFUoUFBDNjQpIHx8IENQVShQUEM2NExFKSB8fCBDUFUoQVJNNjQpCi1jb25zdGV4cHIgc2l6 ZV90IENlaWxpbmdPblBhZ2VTaXplID0gNjQgKiBLQjsKLSNlbHNlCi0jZXJyb3IgTXVzdCBzZXQg Q2VpbGluZ09uUGFnZVNpemUgaW4gUGFnZUJsb2NrLmggd2hlbiBhZGRpbmcgYSBuZXcgQ1BVIGFy Y2hpdGVjdHVyZSEKLSNlbmRpZgotCiBXVEZfRVhQT1JUX1BSSVZBVEUgc2l6ZV90IHBhZ2VTaXpl KCk7CiBXVEZfRVhQT1JUX1BSSVZBVEUgc2l6ZV90IHBhZ2VNYXNrKCk7CiBpbmxpbmUgYm9vbCBp c1BhZ2VBbGlnbmVkKHZvaWQqIGFkZHJlc3MpIHsgcmV0dXJuICEocmVpbnRlcnByZXRfY2FzdDxp bnRwdHJfdD4oYWRkcmVzcykgJiAocGFnZVNpemUoKSAtIDEpKTsgfQpAQCAtMTEwLDcgKzgwLDYg QEAgaW5saW5lIFBhZ2VCbG9jazo6UGFnZUJsb2NrKHZvaWQqIGJhc2UsIHNpemVfdCBzaXplLCBi b29sIGhhc0d1YXJkUGFnZXMpCiAKIH0gLy8gbmFtZXNwYWNlIFdURgogCi11c2luZyBXVEY6OkNl aWxpbmdPblBhZ2VTaXplOwogdXNpbmcgV1RGOjpwYWdlU2l6ZTsKIHVzaW5nIFdURjo6aXNQYWdl QWxpZ25lZDsKIHVzaW5nIFdURjo6aXNQb3dlck9mVHdvOwo= 394743 2020-03-27 12:08:32 -0700 2020-04-09 15:37:31 -0700 Patch bug-209670-20200327140832.patch text/plain 1948 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjU5MDgzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDljMmRmYWU4NmY1NTk1YzNhMTI3NDA4 NGYwNDM3Y2U3OGNjYWFjMzIuLmVjNTI0ZWJmNmY0MzhlMzM5YWQ2MDliMTFhNTNjMjA2OWFlNWIx YWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMjAtMDMtMjcgIE1pY2hhZWwgQ2F0YW56YXJvICA8 bWNhdGFuemFyb0Bnbm9tZS5vcmc+CisKKyAgICAgICAgUkVHUkVTU0lPTihyMjU4ODU3KTogQnJv a2UgYWFyY2g2NCBKU0NPbmx5IENJCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yMDk2NzAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICBDaGFuZ2UgYWFyY2g2NCB0byB1c2UgNCBLQiByYXRoZXIgdGhhbiA2NCBL QiBhcyB0aGUgY2VpbGluZyBvbiBwYWdlIHNpemUuCisKKyAgICAgICAgVGhpcyBjaGFuZ2UgaXMg ZGVmaW5pdGVseSBpbmNvcnJlY3QsIGJlY2F1c2UgaXQgd2lsbCBicmVhayBvdXIgaW50ZXJuYWwg YWFyY2g2NCBDSSB0aGF0IHVzZXMKKyAgICAgICAgNjQgS0IgcGFnZXMuIEJ1dCBtYXliZSBpdCB3 aWxsIGZpeCB0aGUgcHVibGljIGFhcmNoNjQgQ0kgYm90IHRoYXQgaXMgdXNpbmcgNCBLQiBwYWdl cz8KKyAgICAgICAgRnVydGhlciBpbnZlc3RpZ2F0aW9uIGlzIHJlcXVpcmVkLCBiZWNhdXNlIDY0 IEtCIHNob3VsZCBoYXZlIGJlZW4gYSBzYWZlIHZhbHVlIGZvciBhbGwKKyAgICAgICAgcGxhdGZv cm1zLCBidXQgZmlyc3Qgc3RlcCBpcyB0byBjb21taXQgdGhpcyBhbmQgc2VlIHdoYXQgaGFwcGVu cy4KKworICAgICAgICAqIHd0Zi9QYWdlQmxvY2suaDoKKwogMjAyMC0wMy0yNSAgQ2hyaXN0b3Bo ZXIgUmVpZCAgPGNocmlzLnJlaWRAc29ueS5jb20+CiAKICAgICAgICAgW1BsYXlTdGF0aW9uXSBT cGVjaWZ5IGEgMTYgS0IgbWluaW11bSBwYWdlIHNpemUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYv d3RmL1BhZ2VCbG9jay5oIGIvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmgKaW5kZXggNDI1Yzlk OWU2NjJmMDc3OTY5MWZkNmUwNjFiNTNjMmExNGRlMTJlZC4uZGQ1NmY5NzNjZDA5NGYyZDc4ODk5 ZDI3NjY2ODJkYjdmMTJhYjI1YSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvUGFnZUJsb2Nr LmgKKysrIGIvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmgKQEAgLTQ5LDkgKzQ5LDkgQEAgbmFt ZXNwYWNlIFdURiB7CiAvLyBVc2UgNjQgS2lCIGZvciBhbnkgdW5rbm93biBDUFVzIHRvIGJlIGNv bnNlcnZhdGl2ZS4KICNpZiBPUyhEQVJXSU4pIHx8IFBMQVRGT1JNKFBMQVlTVEFUSU9OKQogY29u c3RleHByIHNpemVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDE2ICogS0I7Ci0jZWxpZiBPUyhXSU5E T1dTKSB8fCBDUFUoTUlQUykgfHwgQ1BVKFg4NikgfHwgQ1BVKFg4Nl82NCkgfHwgQ1BVKEFSTSkK KyNlbGlmIE9TKFdJTkRPV1MpIHx8IENQVShNSVBTKSB8fCBDUFUoWDg2KSB8fCBDUFUoWDg2XzY0 KSB8fCBDUFUoQVJNKSB8fCBDUFUoQVJNNjQpCiBjb25zdGV4cHIgc2l6ZV90IENlaWxpbmdPblBh Z2VTaXplID0gNCAqIEtCOwotI2VsaWYgQ1BVKFVOS05PV04pIHx8IENQVShQUEMpIHx8IENQVShQ UEM2NCkgfHwgQ1BVKFBQQzY0TEUpIHx8IENQVShBUk02NCkKKyNlbGlmIENQVShVTktOT1dOKSB8 fCBDUFUoUFBDKSB8fCBDUFUoUFBDNjQpIHx8IENQVShQUEM2NExFKQogY29uc3RleHByIHNpemVf dCBDZWlsaW5nT25QYWdlU2l6ZSA9IDY0ICogS0I7CiAjZWxzZQogI2Vycm9yIE11c3Qgc2V0IENl aWxpbmdPblBhZ2VTaXplIGluIFBhZ2VCbG9jay5oIHdoZW4gYWRkaW5nIGEgbmV3IENQVSBhcmNo aXRlY3R1cmUhCg== 394895 2020-03-30 03:40:39 -0700 2020-03-30 03:40:39 -0700 Crash backtrace gdb.txt text/plain 3209 zan U3RhcnRpbmcgcHJvZ3JhbTogL3RtcC9qc2MgCltUaHJlYWQgZGVidWdnaW5nIHVzaW5nIGxpYnRo cmVhZF9kYiBlbmFibGVkXQpVc2luZyBob3N0IGxpYnRocmVhZF9kYiBsaWJyYXJ5ICIvbGliL2Fh cmNoNjQtbGludXgtZ251L2xpYnRocmVhZF9kYi5zby4xIi4KW05ldyBUaHJlYWQgMHg3ZmI1ZDU3 MWQwIChMV1AgMTQ5MDkpXQoKVGhyZWFkIDEgImpzYyIgcmVjZWl2ZWQgc2lnbmFsIFNJR1NFR1Ys IFNlZ21lbnRhdGlvbiBmYXVsdC4KIzAgIDB4MDAwMDAwNTU1NTYxNjYyNCBpbiBKU0M6OlN0cnVj dHVyZUlEVGFibGU6OmdldCh1bnNpZ25lZCBpbnQpICgpIGF0IC9ob21lL3phbi9Xb3JrL3dlYmtp dC9naXQvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvU3RydWN0dXJlSURUYWJsZS5oOjE3 NQojMSAgMHgwMDAwMDA1NTU1NjE3M2I0IGluIEpTQzo6Vk06OmdldFN0cnVjdHVyZSh1bnNpZ25l ZCBpbnQpICgpIGF0IC9ob21lL3phbi9Xb3JrL3dlYmtpdC9naXQvU291cmNlL0phdmFTY3JpcHRD b3JlL3J1bnRpbWUvVk0uaDo5MDMKIzIgIDB4MDAwMDAwNTU1NTYyMDgwMCBpbiBKU0M6OkpTQ2Vs bDo6c3RydWN0dXJlKEpTQzo6Vk0mKSBjb25zdCAoKSBhdCAvaG9tZS96YW4vV29yay93ZWJraXQv Z2l0L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTQ2VsbElubGluZXMuaDoxMjkKIzMg IDB4MDAwMDAwNTU1NTYyMDdkNCBpbiBKU0M6OkpTQ2VsbDo6c3RydWN0dXJlKCkgY29uc3QgKCkg YXQgL2hvbWUvemFuL1dvcmsvd2Via2l0L2dpdC9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGlt ZS9KU0NlbGxJbmxpbmVzLmg6MTI0CiM0ICAweDAwMDAwMDU1NTU2MWZmNDAgaW4gSlNDOjpIZWFw Ojp3cml0ZUJhcnJpZXIoSlNDOjpKU0NlbGwgY29uc3QqKSAoKSBhdCAvaG9tZS96YW4vV29yay93 ZWJraXQvZ2l0L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL0hlYXBJbmxpbmVzLmg6MTIwCiM1 ICAweDAwMDAwMDU1NTU2MmI4ZDggaW4gSlNDOjpBdXhpbGlhcnlCYXJyaWVyPEpTQzo6QnV0dGVy Zmx5Kj46OkF1eGlsaWFyeUJhcnJpZXI8SlNDOjpCdXR0ZXJmbHkqJj4oSlNDOjpWTSYsIEpTQzo6 SlNDZWxsKiwgSlNDOjpCdXR0ZXJmbHkqJikgKCkgYXQgL2hvbWUvemFuL1dvcmsvd2Via2l0L2dp dC9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9BdXhpbGlhcnlCYXJyaWVySW5saW5lcy5o OjM5CiM2ICAweDAwMDAwMDU1NTU2MWNlZmMgaW4gSlNDOjpKU09iamVjdDo6SlNPYmplY3QoSlND OjpWTSYsIEpTQzo6U3RydWN0dXJlKiwgSlNDOjpCdXR0ZXJmbHkqKSAoKSBhdCAvaG9tZS96YW4v V29yay93ZWJraXQvZ2l0L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0pTT2JqZWN0Lmg6 MTMwNQojNyAgMHgwMDAwMDA1NTU1NjFjODE0IGluIEpTQzo6SlNOb25GaW5hbE9iamVjdDo6SlNO b25GaW5hbE9iamVjdChKU0M6OlZNJiwgSlNDOjpTdHJ1Y3R1cmUqLCBKU0M6OkJ1dHRlcmZseSop ICgpIGF0IC9ob21lL3phbi9Xb3JrL3dlYmtpdC9naXQvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1 bnRpbWUvSlNPYmplY3QuaDoxMTE1CiM4ICAweDAwMDAwMDU1NTViNWM0YjggaW4gSlNDOjpKU1Nj b3BlOjpKU1Njb3BlKEpTQzo6Vk0mLCBKU0M6OlN0cnVjdHVyZSosIEpTQzo6SlNTY29wZSopICgp IGF0IC9ob21lL3phbi9Xb3JrL3dlYmtpdC9naXQvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRp bWUvSlNTY29wZS5oOjk3CiM5ICAweDAwMDAwMDU1NTY0NjE1YzQgaW4gSlNDOjpKU1N5bWJvbFRh YmxlT2JqZWN0OjpKU1N5bWJvbFRhYmxlT2JqZWN0KEpTQzo6Vk0mLCBKU0M6OlN0cnVjdHVyZSos IEpTQzo6SlNTY29wZSopICgpIGF0IC9ob21lL3phbi9Xb3JrL3dlYmtpdC9naXQvU291cmNlL0ph dmFTY3JpcHRDb3JlL3J1bnRpbWUvSlNTeW1ib2xUYWJsZU9iamVjdC5oOjU1CiMxMCAweDAwMDAw MDU1NTY0NWY3ODQgaW4gSlNDOjpKU1NlZ21lbnRlZFZhcmlhYmxlT2JqZWN0OjpKU1NlZ21lbnRl ZFZhcmlhYmxlT2JqZWN0KEpTQzo6Vk0mLCBKU0M6OlN0cnVjdHVyZSosIEpTQzo6SlNTY29wZSop ICgpIGF0IC9ob21lL3phbi9Xb3JrL3dlYmtpdC9naXQvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1 bnRpbWUvSlNTZWdtZW50ZWRWYXJpYWJsZU9iamVjdC5jcHA6OTkKIzExIDB4MDAwMDAwNTU1NjNi Y2RlYyBpbiBKU0M6OkpTR2xvYmFsT2JqZWN0OjpKU0dsb2JhbE9iamVjdChKU0M6OlZNJiwgSlND OjpTdHJ1Y3R1cmUqLCBKU0M6Okdsb2JhbE9iamVjdE1ldGhvZFRhYmxlIGNvbnN0KikgKCkgYXQg L2hvbWUvemFuL1dvcmsvd2Via2l0L2dpdC9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9K U0dsb2JhbE9iamVjdC5jcHA6NDQyCiMxMiAweDAwMDAwMDU1NTU1ZmFiM2MgaW4gR2xvYmFsT2Jq ZWN0OjpHbG9iYWxPYmplY3QoSlNDOjpWTSYsIEpTQzo6U3RydWN0dXJlKikgKCkgYXQgL2hvbWUv emFuL1dvcmsvd2Via2l0L2dpdC9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvanNjLmNwcDo3MDIKIzEz IDB4MDAwMDAwNTU1NTYyNTgzNCBpbiBHbG9iYWxPYmplY3Q6OmNyZWF0ZShKU0M6OlZNJiwgSlND OjpTdHJ1Y3R1cmUqLCBXVEY6OlZlY3RvcjxXVEY6OlN0cmluZywgMHVsLCBXVEY6OkNyYXNoT25P dmVyZmxvdywgMTZ1bCwgV1RGOjpGYXN0TWFsbG9jPiBjb25zdCYpICgpIGF0IC9ob21lL3phbi9X b3JrL3dlYmtpdC9naXQvU291cmNlL0phdmFTY3JpcHRDb3JlL2pzYy5jcHA6NTA0CiMxNCAweDAw MDAwMDU1NTU2MGNiOTQgaW4gaW50IHJ1bkpTQzxqc2NtYWluKGludCwgY2hhcioqKTo6e2xhbWJk YShKU0M6OlZNJiwgR2xvYmFsT2JqZWN0KiwgYm9vbCYpIzF9PihDb21tYW5kTGluZSBjb25zdCYs IGJvb2wsIGpzY21haW4oaW50LCBjaGFyKiopOjp7bGFtYmRhKEpTQzo6Vk0mLCBHbG9iYWxPYmpl Y3QqLCBib29sJikjMX0gY29uc3QmKSAoKSBhdCAvaG9tZS96YW4vV29yay93ZWJraXQvZ2l0L1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9qc2MuY3BwOjMwNTYKIzE1IDB4MDAwMDAwNTU1NTYwYjBkNCBp biBqc2NtYWluKGludCwgY2hhcioqKSAoKSBhdCAvaG9tZS96YW4vV29yay93ZWJraXQvZ2l0L1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9qc2MuY3BwOjMyMTYKIzE2IDB4MDAwMDAwNTU1NTYwODlmOCBp biBtYWluICgpIGF0IC9ob21lL3phbi9Xb3JrL3dlYmtpdC9naXQvU291cmNlL0phdmFTY3JpcHRD b3JlL2pzYy5jcHA6MjU0Nwo= 396020 2020-04-09 15:36:56 -0700 2020-04-09 15:36:56 -0700 Patch bug-209670-20200409173655.patch text/plain 2983 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjU5ODI5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDIzZTAwZGE0NzE1YzQxNDIzN2RmNDUz NjYzYzUzOGRmMjQzOTY4ZDMuLmQwYzEwNmE1MTZkNmM0NGQxYTdhM2MzZWJlN2IyMjNkZjg5ZWJh MGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTIgQEAKKzIwMjAtMDQtMDkgIE1pY2hhZWwgQ2F0YW56YXJvICA8 bWNhdGFuemFyb0Bnbm9tZS5vcmc+CisKKyAgICAgICAgUkVHUkVTU0lPTihyMjU4ODU3KTogQnJv a2UgYWFyY2g2NCBKU0NPbmx5IENJCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3No b3dfYnVnLmNnaT9pZD0yMDk2NzAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMh KS4KKworICAgICAgICAqIHd0Zi9QYWdlQmxvY2suaDoKKwogMjAyMC0wNC0wOSAgRGF2aWQgS2ls emVyICA8ZGRraWx6ZXJAYXBwbGUuY29tPgogCiAgICAgICAgIFdURjo6UGVyc2lzdGVuY2U6OkNv ZGVyIGFuZCBXVEY6OlBlcnNpc3RlbmNlOjpEZWNvZGVyIHNob3VsZCB1c2UgV0FSTl9VTlVTRURf UkVUVVJOCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaGVhcC9NYXJrZWRCbG9j ay5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaGVhcC9NYXJrZWRCbG9jay5jcHAKaW5kZXgg ZDc4MTEyNjJmOTRmMDc2YmIxZmNjZmU0Mjc2NjM0YjMwODQyM2I5OC4uZjEzZmFiMzFmNTg2ZDIz YWNjZjdjZmY3ZmIxYzhlNGRmOWJkN2UwMCAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRD b3JlL2hlYXAvTWFya2VkQmxvY2suY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFw L01hcmtlZEJsb2NrLmNwcApAQCAtNTUsNyArNTUsNyBAQCBNYXJrZWRCbG9jazo6SGFuZGxlKiBN YXJrZWRCbG9jazo6dHJ5Q3JlYXRlKEhlYXAmIGhlYXAsIEFsaWduZWRNZW1vcnlBbGxvY2F0b3Iq CiAgICAgICAgIGlmICghKGJhbGFuY2UgJSAxMCkpCiAgICAgICAgICAgICBkYXRhTG9nKCJNYXJr ZWRCbG9jayBCYWxhbmNlOiAiLCBiYWxhbmNlLCAiXG4iKTsKICAgICB9Ci0gICAgdm9pZCogYmxv Y2tTcGFjZSA9IGFsaWduZWRNZW1vcnlBbGxvY2F0b3ItPnRyeUFsbG9jYXRlQWxpZ25lZE1lbW9y eShibG9ja1NpemUsIGJsb2NrU2l6ZSk7CisgICAgdm9pZCogYmxvY2tTcGFjZSA9IGFsaWduZWRN ZW1vcnlBbGxvY2F0b3ItPnRyeUFsbG9jYXRlQWxpZ25lZE1lbW9yeShzdGQ6Om1heChibG9ja1Np emUsIHBhZ2VTaXplKCkpLCBibG9ja1NpemUpOwogICAgIGlmICghYmxvY2tTcGFjZSkKICAgICAg ICAgcmV0dXJuIG51bGxwdHI7CiAgICAgaWYgKHNjcmliYmxlRnJlZUNlbGxzKCkpCmRpZmYgLS1n aXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaGVhcC9NYXJrZWRCbG9jay5oIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL2hlYXAvTWFya2VkQmxvY2suaAppbmRleCBhZDE2YTRiZDZiZTdjNWU5YzZi ZTE0ZjUyNDdmOGE0MzQ5YjcwNzc3Li5mMGJmZTE4NmJiZTNhNjU0MzI2NWJlMjNkM2E2OWIxM2I2 M2EwYmUzIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvaGVhcC9NYXJrZWRCbG9j ay5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9oZWFwL01hcmtlZEJsb2NrLmgKQEAgLTcx LDggKzcxLDcgQEAgcHJpdmF0ZToKIHB1YmxpYzoKICAgICBzdGF0aWMgY29uc3RleHByIHNpemVf dCBhdG9tU2l6ZSA9IDE2OyAvLyBieXRlcwogCi0gICAgLy8gQmxvY2sgc2l6ZSBtdXN0IGJlIGF0 IGxlYXN0IGFzIGxhcmdlIGFzIHRoZSBzeXN0ZW0gcGFnZSBzaXplLgotICAgIHN0YXRpYyBjb25z dGV4cHIgc2l6ZV90IGJsb2NrU2l6ZSA9IHN0ZDo6bWF4KDE2ICogS0IsIENlaWxpbmdPblBhZ2VT aXplKTsKKyAgICBzdGF0aWMgY29uc3RleHByIHNpemVfdCBibG9ja1NpemUgPSAxNiAqIEtCOwog CiAgICAgc3RhdGljIGNvbnN0ZXhwciBzaXplX3QgYmxvY2tNYXNrID0gfihibG9ja1NpemUgLSAx KTsgLy8gYmxvY2tTaXplIG11c3QgYmUgYSBwb3dlciBvZiB0d28uCiAKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5oIGIvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmgKaW5k ZXggZGQ1NmY5NzNjZDA5NGYyZDc4ODk5ZDI3NjY2ODJkYjdmMTJhYjI1YS4uMzMxODQyZmM3MDZk OTkxYTZmNjBkODE0NGIyNGQyNGNmNWRiYzkyNiAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYv UGFnZUJsb2NrLmgKKysrIGIvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmgKQEAgLTQ5LDkgKzQ5 LDkgQEAgbmFtZXNwYWNlIFdURiB7CiAvLyBVc2UgNjQgS2lCIGZvciBhbnkgdW5rbm93biBDUFVz IHRvIGJlIGNvbnNlcnZhdGl2ZS4KICNpZiBPUyhEQVJXSU4pIHx8IFBMQVRGT1JNKFBMQVlTVEFU SU9OKQogY29uc3RleHByIHNpemVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDE2ICogS0I7Ci0jZWxp ZiBPUyhXSU5ET1dTKSB8fCBDUFUoTUlQUykgfHwgQ1BVKFg4NikgfHwgQ1BVKFg4Nl82NCkgfHwg Q1BVKEFSTSkgfHwgQ1BVKEFSTTY0KQorI2VsaWYgT1MoV0lORE9XUykgfHwgQ1BVKFg4NikgfHwg Q1BVKFg4Nl82NCkgfHwgQ1BVKEFSTSkKIGNvbnN0ZXhwciBzaXplX3QgQ2VpbGluZ09uUGFnZVNp emUgPSA0ICogS0I7Ci0jZWxpZiBDUFUoVU5LTk9XTikgfHwgQ1BVKFBQQykgfHwgQ1BVKFBQQzY0 KSB8fCBDUFUoUFBDNjRMRSkKKyNlbGlmIENQVShVTktOT1dOKSB8fCBDUFUoUFBDKSB8fCBDUFUo UFBDNjQpIHx8IENQVShQUEM2NExFKSB8fCBDUFUoQVJNNjQpIHx8IENQVShNSVBTKQogY29uc3Rl eHByIHNpemVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDY0ICogS0I7CiAjZWxzZQogI2Vycm9yIE11 c3Qgc2V0IENlaWxpbmdPblBhZ2VTaXplIGluIFBhZ2VCbG9jay5oIHdoZW4gYWRkaW5nIGEgbmV3 IENQVSBhcmNoaXRlY3R1cmUhCg==