217989 2020-10-20 14:41:41 -0700 Add new build option USE(64KB_PAGE_BLOCK) 2022-08-17 08:59:37 -0700 1 1 1 Unclassified WebKit WebKitGTK WebKit Nightly Build PC Linux RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=209360 https://bugs.webkit.org/show_bug.cgi?id=218613 https://bugs.webkit.org/show_bug.cgi?id=225393 https://bugs.webkit.org/show_bug.cgi?id=227905 https://bugs.webkit.org/show_bug.cgi?id=244036 P2 Normal --- 1 mcatanzaro mcatanzaro annulen benjamin bugs-noreply cdumez clopez cmarcelo ddkilzer ews-watchlist guijemont gyuyoung.kim mcatanzaro mgorse ryuan.choi sergio webkit-bug-importer xan.lopez ysuzuki oldest_to_newest 1699931 0 mcatanzaro 2020-10-20 14:41:41 -0700 Add new build option USE(64KB_PAGE_BLOCK) Why do we need this option? Because JSC and bmalloc both want to know the userspace page size at compile time, which is impossible on Linux because it's a runtime setting. We cannot test the system page size at build time in hopes that it will be the same on the target system, because (a) cross compiling wouldn't work, and (b) the build system could use a different page size than the target system (which will be true for Fedora aarch64, because Fedora is built using RHEL), so the best we can do is guess based on based on the target CPU architecture. In practice, guessing works for all architectures except aarch64 (unless unusual page sizes are used), but it fails for aarch64 because distros are split between using 4 KB and 64 KB pages there. Most distros (including Fedora) use 4 KB, but RHEL uses 16 KB. SUSE actually supports both. Since there is no way to guess correctly, the best we can do is provide an option for it. You should probably only to use this if building for aarch64. Otherwise, known CPUs except PowerPC will use 4 KB, while PowerPC and unknown CPUs will use 64 KB (see wtf/PageBlock.h). aarch64 will continue to default to 4 KB because this is a better default on systems where it doesn't crash. Having one flag will help avoid mistakes. E.g. both RHEL and SUSE were manually passing -DENABLE_JIT=OFF and -DUSE_SYSTEM_MALLOC=ON, but we missed -DENABLE_C_LOOP=ON and -DENABLE_SAMPLING_PROFILER=OFF, so wound up running with both JIT and cloop disabled, a configuration not otherwise used on Linux (and not supported by GTK or WPE ports). It will be easier to not mess up if we only have to pass one special build option. 1699933 1 411919 mcatanzaro 2020-10-20 14:46:45 -0700 Created attachment 411919 Patch 1699934 2 mcatanzaro 2020-10-20 14:47:11 -0700 (This will also allow us to stop patching PageBlock.h downstream, because I don't like downstream patches that we have to keep forever.) 1699937 3 411920 mcatanzaro 2020-10-20 14:54:20 -0700 Created attachment 411920 Patch 1699989 4 clopez 2020-10-20 16:13:03 -0700 (In reply to Michael Catanzaro from comment #0) > Having one flag will help avoid mistakes. E.g. both RHEL and SUSE were > manually passing -DENABLE_JIT=OFF and -DUSE_SYSTEM_MALLOC=ON, but we missed > -DENABLE_C_LOOP=ON and -DENABLE_SAMPLING_PROFILER=OFF, so wound up running > with both JIT and cloop disabled, a configuration not otherwise used on > Linux (and not supported by GTK or WPE ports). It will be easier to not mess > up if we only have to pass one special build option. Any idea why the JSC JIT or bmalloc don't work on Aarch64 with a 64kb pagesize? 1699992 5 411920 clopez 2020-10-20 16:15:31 -0700 Comment on attachment 411920 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=411920&action=review > Source/WTF/wtf/PageBlock.h:53 > +#elif USE(64KB_PAGE_BLOCK) || CPU(PPC) || CPU(PPC64) || CPU(PPC64LE) || CPU(UNKNOWN) > +constexpr size_t CeilingOnPageSize = 64 * KB; On Source/bmalloc/bmalloc/mbmalloc.cpp I see the variables ConfigAlignment and ConfigSizeToProtect that likely should match this. There is a FIXME for that in such file. > Source/cmake/WebKitFeatures.cmake:71 > +# there. Most distros (including Fedora) use 4 KB, but RHEL uses 16 KB. SUSE actually supports both. I guess you mean here 64KB and not 16KB 1700000 6 mcatanzaro 2020-10-20 16:28:09 -0700 (In reply to Carlos Alberto Lopez Perez from comment #5) > > Source/WTF/wtf/PageBlock.h:53 > > +#elif USE(64KB_PAGE_BLOCK) || CPU(PPC) || CPU(PPC64) || CPU(PPC64LE) || CPU(UNKNOWN) > > +constexpr size_t CeilingOnPageSize = 64 * KB; > > On Source/bmalloc/bmalloc/mbmalloc.cpp I see the variables ConfigAlignment > and ConfigSizeToProtect that likely should match this. There is a FIXME for > that in such file. Well there are more places that need tweaked too (see bug #209360), and I don't know how to do it. Even if I did know what was needed, I'd have to figure out how to access a machine to test my changes on (that would be an... adventure). > > Source/cmake/WebKitFeatures.cmake:71 > > +# there. Most distros (including Fedora) use 4 KB, but RHEL uses 16 KB. SUSE actually supports both. > > I guess you mean here 64KB and not 16KB Yup, I'll fix that. 1700002 7 mcatanzaro 2020-10-20 16:29:18 -0700 (In reply to Michael Catanzaro from comment #6) > Well there are more places that need tweaked too (see bug #209360), and I > don't know how to do it. Even if I did know what was needed, I'd have to > figure out how to access a machine to test my changes on (that would be > an... adventure). Oh that's just for bmalloc. For JSC JIT, I don't know what all would need to be changed. (Fixing ConfigSizeToProtect was needed for cloop to work. I really don't know about JIT.) 1700003 8 411938 mcatanzaro 2020-10-20 16:30:03 -0700 Created attachment 411938 Patch 1700020 9 clopez 2020-10-20 17:03:33 -0700 (In reply to Michael Catanzaro from comment #6) > (In reply to Carlos Alberto Lopez Perez from comment #5) > > > Source/WTF/wtf/PageBlock.h:53 > > > +#elif USE(64KB_PAGE_BLOCK) || CPU(PPC) || CPU(PPC64) || CPU(PPC64LE) || CPU(UNKNOWN) > > > +constexpr size_t CeilingOnPageSize = 64 * KB; > > > > On Source/bmalloc/bmalloc/mbmalloc.cpp I see the variables ConfigAlignment > > and ConfigSizeToProtect that likely should match this. There is a FIXME for > > that in such file. > > Well there are more places that need tweaked too (see bug #209360), and I > don't know how to do it. Even if I did know what was needed, I'd have to > figure out how to access a machine to test my changes on (that would be > an... adventure). > I see.. having access to a test machine with this non-standard configurations is usually the biggest problem I wonder if you tested to define the pre-processor defines ENABLE_UNIFIED_AND_FREEZABLE_CONFIG_RECORD BENABLE_UNIFIED_AND_FREEZABLE_CONFIG_RECORD? they seem to be guarding this code and seem to be disabled for OS(WINDOWS) Maybe is a better idea to disable this feature of UNIFIED_AND_FREEZABLE_CONFIG_RECORD than to disable bmalloc or the JSC JIT =? 1700187 10 mcatanzaro 2020-10-21 08:20:14 -0700 (In reply to Carlos Alberto Lopez Perez from comment #9) > Maybe is a better idea to disable this feature of > UNIFIED_AND_FREEZABLE_CONFIG_RECORD than to disable bmalloc or the JSC JIT =? Well... if we can make it work without crashing, then yes, of course it's better to not disable bmalloc. But again, there will be more work needed in at least Sizes.h and Gigacage.h that is not guarded by BENABLE_UNIFIED_AND_FREEZABLE_CONFIG_RECORD. If we do make it work, we would still need USE(64KB_PAGE_BLOCK), it just wouldn't need to disable bmalloc or JIT anymore. And we could probably then enable bmalloc for CPU(UNKNOWN). (But JIT would still need to stay disabled for CPU(UNKNOWN).) 1701482 11 mcatanzaro 2020-10-26 09:45:33 -0700 (In reply to Michael Catanzaro from comment #10) > If we do make it work, we would still need USE(64KB_PAGE_BLOCK), it just > wouldn't need to disable bmalloc or JIT anymore. And we could probably then > enable bmalloc for CPU(UNKNOWN). (But JIT would still need to stay disabled > for CPU(UNKNOWN).) So... I think we should add USE(64KB_PAGE_BLOCK) regardless. OK? :) 1701559 12 411938 clopez 2020-10-26 12:05:40 -0700 Comment on attachment 411938 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=411938&action=review > ChangeLog:26 > + Having one flag will help avoid mistakes. E.g. both RHEL and SUSE were manually passing > + -DENABLE_JIT=OFF and -DUSE_SYSTEM_MALLOC=ON, but we missed -DENABLE_C_LOOP=ON and > + -DENABLE_SAMPLING_PROFILER=OFF, so wound up running with both JIT and cloop disabled, a > + configuration not otherwise used on Linux (and not supported by GTK or WPE ports). It will I think we should add a check in cmake to ensure that one (and only one) of JIT or C_LOOP is enabled, so that we don't allow building with both options disabled (or with both enabled) 1701583 13 mcatanzaro 2020-10-26 13:14:26 -0700 OK, bug #218201. 1701863 14 411938 mcatanzaro 2020-10-27 07:34:31 -0700 Comment on attachment 411938 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=411938&action=review > Source/cmake/WebKitFeatures.cmake:73 > +# Since there is no way to guess correctly, the best we can do is provide an option for it. You > +# should probably only to use this if building for aarch64. Otherwise, known CPUs except PowerPC Typo to fix before landing: "You should probably only to use this" > ChangeLog:18 > + can do is provide an option for it. You should probably only to use this if building for Typo to fix before landing: "You should probably only to use this" >> ChangeLog:26 >> + configuration not otherwise used on Linux (and not supported by GTK or WPE ports). It will > > I think we should add a check in cmake to ensure that one (and only one) of JIT or C_LOOP is enabled, so that we don't allow building with both options disabled (or with both enabled) Proposed in bug #218201, but we decided not to do this. 1704423 15 mcatanzaro 2020-11-04 08:05:57 -0800 Ping reviewers 1704554 16 411938 ysuzuki 2020-11-04 12:10:48 -0800 Comment on attachment 411938 Patch r=me 1704555 17 mcatanzaro 2020-11-04 12:14:34 -0800 Thanks. 1704570 18 413198 mcatanzaro 2020-11-04 12:59:24 -0800 Created attachment 413198 Patch 1704624 19 ews-feeder 2020-11-04 15:07:39 -0800 Committed r269396: <https://trac.webkit.org/changeset/269396> All reviewed patches have been landed. Closing bug and clearing flags on attachment 413198. 1704640 20 413198 clopez 2020-11-04 15:48:17 -0800 Comment on attachment 413198 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=413198&action=review > Source/cmake/WebKitFeatures.cmake:86 > - if (WTF_CPU_ARM64 OR WTF_CPU_X86_64) > + if (USE_64KB_PAGE_BLOCK) > + set(ENABLE_JIT_DEFAULT OFF) > + set(ENABLE_FTL_DEFAULT OFF) > + set(USE_SYSTEM_MALLOC_DEFAULT ON) > + set(ENABLE_C_LOOP_DEFAULT ON) I wonder if it would be better to disable C_LOOP for the case of "USE_64KB_PAGE_BLOCK && WTF_CPU_ARM64" ? According to https://bugs.webkit.org/show_bug.cgi?id=218201#c6 asm LLInt+no JIT is faster than C_LOOP and it seems well supported on ARM64 1704652 21 mcatanzaro 2020-11-04 16:12:35 -0800 (In reply to Carlos Alberto Lopez Perez from comment #20) > I wonder if it would be better to disable C_LOOP for the case of > "USE_64KB_PAGE_BLOCK && WTF_CPU_ARM64" ? > According to https://bugs.webkit.org/show_bug.cgi?id=218201#c6 asm LLInt+no > JIT is faster than C_LOOP and it seems well supported on ARM64 I'm OK with changing this to whatever Igalia prefers. My inclination would be to lean towards using cloop, since I know you're not testing 64 KB aarch64, and I think you're not testing llint without JIT on any architecture (right?), and cloop ought to work well on every architecture. So I figure the chances of RHEL/SUSE-specific bugs should be lower using cloop than with llint without JIT, right? But if Guij and Xan think it's safe, then OK. Whatever you prefer. I really do not care one at all about performance. I'd just rather not wind up with crashes or correctness problems that nobody else can reproduce. 1704783 22 xan.lopez 2020-11-05 01:45:16 -0800 (In reply to Michael Catanzaro from comment #21) > (In reply to Carlos Alberto Lopez Perez from comment #20) > > I wonder if it would be better to disable C_LOOP for the case of > > "USE_64KB_PAGE_BLOCK && WTF_CPU_ARM64" ? > > According to https://bugs.webkit.org/show_bug.cgi?id=218201#c6 asm LLInt+no > > JIT is faster than C_LOOP and it seems well supported on ARM64 > > I'm OK with changing this to whatever Igalia prefers. My inclination would > be to lean towards using cloop, since I know you're not testing 64 KB > aarch64, and I think you're not testing llint without JIT on any > architecture (right?), and cloop ought to work well on every architecture. > So I figure the chances of RHEL/SUSE-specific bugs should be lower using > cloop than with llint without JIT, right? But if Guij and Xan think it's > safe, then OK. Whatever you prefer. > > I really do not care one at all about performance. I'd just rather not wind > up with crashes or correctness problems that nobody else can reproduce. LLInt on aarch64 is really well tested, I think having or not having JIT should not change things much in that regard (sure, it's a moving part and weird things could happen). In the long term it's also probably better if we test that instead of CLOOP. It is true, though, that going for CLOOP might be slightly safer. That being said the difference in the end is going to be pretty small, for users in that architecture the deal breaker is not having any working tier above LLInt tbh. So if you are planning to figure that out at some point it might be worth just going for asm LLInt to laid the ground for future improvements. 1704832 23 mcatanzaro 2020-11-05 06:15:04 -0800 OK, bug #218613. 411919 2020-10-20 14:46:45 -0700 2020-10-20 14:54:17 -0700 Patch bug-217989-20201020164645.patch text/plain 6495 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjY4NzI3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDYwZTEyMGFiOWRiNGQwNDUwMWIxMTlj YmVkOGUyNzBlZTUyNmFlMmEuLjMxYTY0YmZmNjQxODI3YzdjNTRlZGIwMTRkOTNjYjU0MjFlNzAx OTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTIgQEAKKzIwMjAtMTAtMjAgIE1pY2hhZWwgQ2F0YW56YXJvICA8 bWNhdGFuemFyb0Bnbm9tZS5vcmc+CisKKyAgICAgICAgQWRkIG5ldyBidWlsZCBvcHRpb24gVVNF KDY0S0JfUEFHRV9CTE9DSykKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIxNzk4OQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgICogd3RmL1BhZ2VCbG9jay5oOgorCiAyMDIwLTEwLTIwICBTYW0gV2VpbmlnICA8 d2VpbmlnQGFwcGxlLmNvbT4KIAogICAgICAgICBUd2VhayBXZWJQcmVmZXJlbmNlcyoueWFtbCAi ZXhwb3NlZCIga2V5IHRvIG9ubHkgaW5kaWNhdGUgdGhhdCB0aGUga2V5IHNob3VsZCBub3QgYmUg Y2hhbmdlYWJsZSBieSB0aGUgZnJvbnRlbmQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1Bh Z2VCbG9jay5oIGIvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmgKaW5kZXggY2Y1Y2YzMWIyYzkz ZTAyMTlkMzcyMzE0NmI3ZmI5NWJlODQwYjNhNS4uYzY1NWE1MGMyYzg5ZDNmN2FiYzBiNmIzZWE0 ZDAwMWE0YWU4ZTEzYiAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmgKKysr IGIvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmgKQEAgLTQ5LDEwICs0OSwxMCBAQCBuYW1lc3Bh Y2UgV1RGIHsKIC8vIFVzZSA2NCBLaUIgZm9yIGFueSB1bmtub3duIENQVXMgdG8gYmUgY29uc2Vy dmF0aXZlLgogI2lmIE9TKERBUldJTikgfHwgUExBVEZPUk0oUExBWVNUQVRJT04pCiBjb25zdGV4 cHIgc2l6ZV90IENlaWxpbmdPblBhZ2VTaXplID0gMTYgKiBLQjsKKyNlbGlmIFVTRSg2NEtCX1BB R0VfQkxPQ0spIHx8IENQVShQUEMpIHx8IENQVShQUEM2NCkgfHwgQ1BVKFBQQzY0TEUpIHx8IENQ VShVTktOT1dOKQorY29uc3RleHByIHNpemVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDY0ICogS0I7 CiAjZWxpZiBPUyhXSU5ET1dTKSB8fCBDUFUoTUlQUykgfHwgQ1BVKE1JUFM2NCkgfHwgQ1BVKFg4 NikgfHwgQ1BVKFg4Nl82NCkgfHwgQ1BVKEFSTSkgfHwgQ1BVKEFSTTY0KQogY29uc3RleHByIHNp emVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDQgKiBLQjsKLSNlbGlmIENQVShVTktOT1dOKSB8fCBD UFUoUFBDKSB8fCBDUFUoUFBDNjQpIHx8IENQVShQUEM2NExFKQotY29uc3RleHByIHNpemVfdCBD ZWlsaW5nT25QYWdlU2l6ZSA9IDY0ICogS0I7CiAjZWxzZQogI2Vycm9yIE11c3Qgc2V0IENlaWxp bmdPblBhZ2VTaXplIGluIFBhZ2VCbG9jay5oIHdoZW4gYWRkaW5nIGEgbmV3IENQVSBhcmNoaXRl Y3R1cmUhCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9jbWFrZS9XZWJLaXRGZWF0dXJlcy5j bWFrZSBiL1NvdXJjZS9jbWFrZS9XZWJLaXRGZWF0dXJlcy5jbWFrZQppbmRleCA2ZGYxOTcxNGNj MWJiMGJjYzJkMjAxNTA0OWE5M2E4YzE3OWZiZDRhLi41MzU5YTM1MDZkYTU3MGYxZTM0NzUxYTAx NjYwNGQ2ZTA3NWI2MjUzIDEwMDY0NAotLS0gYS9Tb3VyY2UvY21ha2UvV2ViS2l0RmVhdHVyZXMu Y21ha2UKKysrIGIvU291cmNlL2NtYWtlL1dlYktpdEZlYXR1cmVzLmNtYWtlCkBAIC01OSwxMCAr NTksMzIgQEAgbWFjcm8oV0VCS0lUX09QVElPTl9ERVBFTkQgX25hbWUgX2RlcGVuZCkKICAgICBs aXN0KEFQUEVORCBfV0VCS0lUX0FWQUlMQUJMRV9PUFRJT05TXyR7X25hbWV9X0RFUEVOREVOQ0lF UyAke19kZXBlbmR9KQogZW5kbWFjcm8oKQogCisjIFdlIGNhbid0IHVzZSBXRUJLSVRfT1BUSU9O X0RFRklORSBmb3IgVVNFXzY0S0JfUEFHRV9CTE9DSyBiZWNhdXNlIGl0J3MgbmVlZGVkIHRvIHNl dCB0aGUgZGVmYXVsdAorIyB2YWx1ZSBvZiBvdGhlciBvcHRpb25zLiBXaHkgZG8gd2UgbmVlZCB0 aGlzIG9wdGlvbj8gQmVjYXVzZSBKU0MgYW5kIGJtYWxsb2MgYm90aCB3YW50IHRvIGtub3cgdGhl CisjIHVzZXJzcGFjZSBwYWdlIHNpemUgYXQgY29tcGlsZSB0aW1lLCB3aGljaCBpcyBpbXBvc3Np YmxlIG9uIExpbnV4IGJlY2F1c2UgaXQncyBhIHJ1bnRpbWUgc2V0dGluZy4KKyMgV2UgY2Fubm90 IHRlc3QgdGhlIHN5c3RlbSBwYWdlIHNpemUgYXQgYnVpbGQgdGltZSBpbiBob3BlcyB0aGF0IGl0 IHdpbGwgYmUgdGhlIHNhbWUgb24gdGhlIHRhcmdldAorIyBzeXN0ZW0sIGJlY2F1c2UgKGEpIGNy b3NzIGNvbXBpbGluZyB3b3VsZG4ndCB3b3JrLCBhbmQgKGIpIHRoZSBidWlsZCBzeXN0ZW0gY291 bGQgdXNlIGEgZGlmZmVyZW50CisjIHBhZ2Ugc2l6ZSB0aGFuIHRoZSB0YXJnZXQgc3lzdGVtICh3 aGljaCB3aWxsIGJlIHRydWUgZm9yIEZlZG9yYSBhYXJjaDY0LCBiZWNhdXNlIEZlZG9yYSBpcyBi dWlsdAorIyB1c2luZyBSSEVMKSwgc28gdGhlIGJlc3Qgd2UgY2FuIGRvIGlzIGd1ZXNzIGJhc2Vk IG9uIGJhc2VkIG9uIHRoZSB0YXJnZXQgQ1BVIGFyY2hpdGVjdHVyZS4gSW4KKyMgcHJhY3RpY2Us IGd1ZXNzaW5nIHdvcmtzIGZvciBhbGwgYXJjaGl0ZWN0dXJlcyBleGNlcHQgYWFyY2g2NCAodW5s ZXNzIHVudXN1YWwgcGFnZSBzaXplcyBhcmUKKyMgdXNlZCksIGJ1dCBpdCBmYWlscyBmb3IgYWFy Y2g2NCBiZWNhdXNlIGRpc3Ryb3MgYXJlIHNwbGl0IGJldHdlZW4gdXNpbmcgNCBLQiBhbmQgNjQg S0IgcGFnZXMKKyMgdGhlcmUuIE1vc3QgZGlzdHJvcyAoaW5jbHVkaW5nIEZlZG9yYSkgdXNlIDQg S0IsIGJ1dCBSSEVMIHVzZXMgMTYgS0IuIFNVU0UgYWN0dWFsbHkgc3VwcG9ydHMgYm90aC4KKyMg U2luY2UgdGhlcmUgaXMgbm8gd2F5IHRvIGd1ZXNzIGNvcnJlY3RseSwgdGhlIGJlc3Qgd2UgY2Fu IGRvIGlzIHByb3ZpZGUgYW4gb3B0aW9uIGZvciBpdC4gWW91CisjIHNob3VsZCBwcm9iYWJseSBv bmx5IHRvIHVzZSB0aGlzIGlmIGJ1aWxkaW5nIGZvciBhYXJjaDY0LiBPdGhlcndpc2UsIGtub3du IENQVXMgZXhjZXB0IFBvd2VyUEMKKyMgd2lsbCB1c2UgNCBLQiwgd2hpbGUgUG93ZXJQQyBhbmQg dW5rbm93biBDUFVzIHdpbGwgdXNlIDY0IEtCIChzZWUgd3RmL1BhZ2VCbG9jay5oKS4gYWFyY2g2 NCB3aWxsCisjIGNvbnRpbnVlIHRvIGRlZmF1bHQgdG8gNCBLQiBiZWNhdXNlIHRoaXMgaXMgYSBi ZXR0ZXIgZGVmYXVsdCBvbiBzeXN0ZW1zIHdoZXJlIGl0IGRvZXNuJ3QgY3Jhc2guCitvcHRpb24o VVNFXzY0S0JfUEFHRV9CTE9DSyAiRm9yY2Ugc3VwcG9ydCA2NCBLQiB1c2Vyc3BhY2UgcGFnZSBz aXplIChyZWR1Y2VzIHNlY3VyaXR5IGFuZCBwZXJmb3JtYW5jZSkiIE9GRikKKwogbWFjcm8oV0VC S0lUX09QVElPTl9CRUdJTikKICAgICBzZXQoX1NFVFRJTkdfV0VCS0lUX09QVElPTlMgVFJVRSkK IAotICAgIGlmIChXVEZfQ1BVX0FSTTY0IE9SIFdURl9DUFVfWDg2XzY0KQorICAgIGlmIChVU0Vf NjRLQl9QQUdFX0JMT0NLKQorICAgICAgICBzZXQoRU5BQkxFX0pJVF9ERUZBVUxUIE9GRikKKyAg ICAgICAgc2V0KEVOQUJMRV9GVExfREVGQVVMVCBPRkYpCisgICAgICAgIHNldChVU0VfU1lTVEVN X01BTExPQ19ERUZBVUxUIE9OKQorICAgICAgICBzZXQoRU5BQkxFX0NfTE9PUF9ERUZBVUxUIE9O KQorICAgICAgICBzZXQoRU5BQkxFX1NBTVBMSU5HX1BST0ZJTEVSX0RFRkFVTFQgT0ZGKQorICAg IGVsc2VpZiAoV1RGX0NQVV9BUk02NCBPUiBXVEZfQ1BVX1g4Nl82NCkKICAgICAgICAgc2V0KEVO QUJMRV9KSVRfREVGQVVMVCBPTikKICAgICAgICAgc2V0KEVOQUJMRV9GVExfREVGQVVMVCBPTikK ICAgICAgICAgc2V0KFVTRV9TWVNURU1fTUFMTE9DX0RFRkFVTFQgT0ZGKQpkaWZmIC0tZ2l0IGEv Q2hhbmdlTG9nIGIvQ2hhbmdlTG9nCmluZGV4IDcxNmZkOTMwMWU1NDlhMjcyY2U5MGM4ODdkZTVh ODg3ZTEzNDA3YjIuLjE5NDdkNDM4MzNmOGNhNmUyMDVmZTI5ODZhMzM2OWQ0NmQ0MDE4MjUgMTAw NjQ0Ci0tLSBhL0NoYW5nZUxvZworKysgYi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNSBAQAorMjAy MC0xMC0yMCAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGdub21lLm9yZz4KKworICAg ICAgICBBZGQgbmV3IGJ1aWxkIG9wdGlvbiBVU0UoNjRLQl9QQUdFX0JMT0NLKQorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjE3OTg5CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgV2h5IGRvIHdlIG5lZWQgdGhp cyBvcHRpb24/IEJlY2F1c2UgSlNDIGFuZCBibWFsbG9jIGJvdGggd2FudCB0byBrbm93IHRoZSB1 c2Vyc3BhY2UgcGFnZQorICAgICAgICBzaXplIGF0IGNvbXBpbGUgdGltZSwgd2hpY2ggaXMgaW1w b3NzaWJsZSBvbiBMaW51eCBiZWNhdXNlIGl0J3MgYSBydW50aW1lIHNldHRpbmcuIFdlCisgICAg ICAgIGNhbm5vdCB0ZXN0IHRoZSBzeXN0ZW0gcGFnZSBzaXplIGF0IGJ1aWxkIHRpbWUgaW4gaG9w ZXMgdGhhdCBpdCB3aWxsIGJlIHRoZSBzYW1lIG9uIHRoZQorICAgICAgICB0YXJnZXQgc3lzdGVt LCBiZWNhdXNlIChhKSBjcm9zcyBjb21waWxpbmcgd291bGRuJ3Qgd29yaywgYW5kIChiKSB0aGUg YnVpbGQgc3lzdGVtIGNvdWxkCisgICAgICAgIHVzZSBhIGRpZmZlcmVudCBwYWdlIHNpemUgdGhh biB0aGUgdGFyZ2V0IHN5c3RlbSAod2hpY2ggd2lsbCBiZSB0cnVlIGZvciBGZWRvcmEgYWFyY2g2 NCwKKyAgICAgICAgYmVjYXVzZSBGZWRvcmEgaXMgYnVpbHQgdXNpbmcgUkhFTCksIHNvIHRoZSBi ZXN0IHdlIGNhbiBkbyBpcyBndWVzcyBiYXNlZCBvbiBiYXNlZCBvbiB0aGUKKyAgICAgICAgdGFy Z2V0IENQVSBhcmNoaXRlY3R1cmUuIEluIHByYWN0aWNlLCBndWVzc2luZyB3b3JrcyBmb3IgYWxs IGFyY2hpdGVjdHVyZXMgZXhjZXB0IGFhcmNoNjQKKyAgICAgICAgKHVubGVzcyB1bnVzdWFsIHBh Z2Ugc2l6ZXMgYXJlIHVzZWQpLCBidXQgaXQgZmFpbHMgZm9yIGFhcmNoNjQgYmVjYXVzZSBkaXN0 cm9zIGFyZSBzcGxpdAorICAgICAgICBiZXR3ZWVuIHVzaW5nIDQgS0IgYW5kIDY0IEtCIHBhZ2Vz IHRoZXJlLiBNb3N0IGRpc3Ryb3MgKGluY2x1ZGluZyBGZWRvcmEpIHVzZSA0IEtCLCBidXQgUkhF TAorICAgICAgICB1c2VzIDE2IEtCLiBTVVNFIGFjdHVhbGx5IHN1cHBvcnRzIGJvdGguIFNpbmNl IHRoZXJlIGlzIG5vIHdheSB0byBndWVzcyBjb3JyZWN0bHksIHRoZSBiZXN0CisgICAgICAgIHdl IGNhbiBkbyBpcyBwcm92aWRlIGFuIG9wdGlvbiBmb3IgaXQuIFlvdSBzaG91bGQgcHJvYmFibHkg b25seSB0byB1c2UgdGhpcyBpZiBidWlsZGluZyBmb3IKKyAgICAgICAgYWFyY2g2NC4gT3RoZXJ3 aXNlLCBrbm93biBDUFVzIGV4Y2VwdCBQb3dlclBDIHdpbGwgdXNlIDQgS0IsIHdoaWxlIFBvd2Vy UEMgYW5kIHVua25vd24gQ1BVcworICAgICAgICB3aWxsIHVzZSA2NCBLQiAoc2VlIHd0Zi9QYWdl QmxvY2suaCkuIGFhcmNoNjQgd2lsbCBjb250aW51ZSB0byBkZWZhdWx0IHRvIDQgS0IgYmVjYXVz ZSB0aGlzCisgICAgICAgIGlzIGEgbXVjaCBiZXR0ZXIgZGVmYXVsdCBvbiBzeXN0ZW1zIHdoZXJl IGl0IGRvZXNuJ3QgY3Jhc2guCisKKyAgICAgICAgSGF2aW5nIG9uZSBmbGFnIHdpbGwgaGVscCBh dm9pZCBtaXN0YWtlcy4gRS5nLiBib3RoIFJIRUwgYW5kIFNVU0Ugd2VyZSBtYW51YWxseSBwYXNz aW5nCisgICAgICAgIC1ERU5BQkxFX0pJVD1PRkYgYW5kIC1EVVNFX1NZU1RFTV9NQUxMT0M9T04s IGJ1dCB3ZSBtaXNzZWQgLURFTkFCTEVfQ19MT09QPU9OIGFuZAorICAgICAgICAtREVOQUJMRV9T QU1QTElOR19QUk9GSUxFUj1PRkYsIHNvIHdvdW5kIHVwIHJ1bm5pbmcgd2l0aCBib3RoIEpJVCBh bmQgY2xvb3AgZGlzYWJsZWQsIGEKKyAgICAgICAgY29uZmlndXJhdGlvbiBub3Qgb3RoZXJ3aXNl IHVzZWQgb24gTGludXggKGFuZCBub3Qgc3VwcG9ydGVkIGJ5IEdUSyBvciBXUEUgcG9ydHMpLiBJ dCB3aWxsCisgICAgICAgIGJlIGVhc2llciB0byBub3QgbWVzcyB1cCBpZiB3ZSBvbmx5IGhhdmUg dG8gcGFzcyBvbmUgc3BlY2lhbCBidWlsZCBvcHRpb24uIFRoaXMgd2lsbCBhbHNvCisgICAgICAg IGFsbG93IHVzIHRvIHN0b3AgcGF0Y2hpbmcgUGFnZUJsb2NrLmggZG93bnN0cmVhbSwgYmVjYXVz ZSBJIGRvbid0IGxpa2UgZG93bnN0cmVhbSBwYXRjaGVzCisgICAgICAgIHRoYXQgd2UgaGF2ZSB0 byBrZWVwIGZvcmV2ZXIuCisKKyAgICAgICAgKiBTb3VyY2UvY21ha2UvV2ViS2l0RmVhdHVyZXMu Y21ha2U6CisKIDIwMjAtMTAtMjAgIEFkcmlhbiBQZXJleiBkZSBDYXN0cm8gIDxhcGVyZXpAaWdh bGlhLmNvbT4KIAogICAgICAgICBbR1RLXSBJbXBsZW1lbnQgSFRNTDUgR2FtZXBhZCBBUEkK 411920 2020-10-20 14:54:20 -0700 2020-10-20 16:30:00 -0700 Patch bug-217989-20201020165420.patch text/plain 6471 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjY4NzYxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDU4ODdmMmI3MTZkNTA2Mjg1ZWIzYjBj ZjNhYjFjZDQwNzQ3YjBlYjguLjY2MDZlNDNjN2ZhYmVmN2M2ZmJiNGU4YmE5YmZkYzM5NmJlY2Ex OGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTIgQEAKKzIwMjAtMTAtMjAgIE1pY2hhZWwgQ2F0YW56YXJvICA8 bWNhdGFuemFyb0Bnbm9tZS5vcmc+CisKKyAgICAgICAgQWRkIG5ldyBidWlsZCBvcHRpb24gVVNF KDY0S0JfUEFHRV9CTE9DSykKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIxNzk4OQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgICogd3RmL1BhZ2VCbG9jay5oOgorCiAyMDIwLTEwLTE1ICBKZXIgTm9ibGUgIDxq ZXIubm9ibGVAYXBwbGUuY29tPgogCiAgICAgICAgIEFkZCBza2VsZXRvbiBpbXBsZW1lbnRhdGlv biBvZiBNZWRpYSBTZXNzaW9uIEFQSQpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvUGFnZUJs b2NrLmggYi9Tb3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suaAppbmRleCBjZjVjZjMxYjJjOTNlMDIx OWQzNzIzMTQ2YjdmYjk1YmU4NDBiM2E1Li5jNjU1YTUwYzJjODlkM2Y3YWJjMGI2YjNlYTRkMDAx YTRhZThlMTNiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suaAorKysgYi9T b3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suaApAQCAtNDksMTAgKzQ5LDEwIEBAIG5hbWVzcGFjZSBX VEYgewogLy8gVXNlIDY0IEtpQiBmb3IgYW55IHVua25vd24gQ1BVcyB0byBiZSBjb25zZXJ2YXRp dmUuCiAjaWYgT1MoREFSV0lOKSB8fCBQTEFURk9STShQTEFZU1RBVElPTikKIGNvbnN0ZXhwciBz aXplX3QgQ2VpbGluZ09uUGFnZVNpemUgPSAxNiAqIEtCOworI2VsaWYgVVNFKDY0S0JfUEFHRV9C TE9DSykgfHwgQ1BVKFBQQykgfHwgQ1BVKFBQQzY0KSB8fCBDUFUoUFBDNjRMRSkgfHwgQ1BVKFVO S05PV04pCitjb25zdGV4cHIgc2l6ZV90IENlaWxpbmdPblBhZ2VTaXplID0gNjQgKiBLQjsKICNl bGlmIE9TKFdJTkRPV1MpIHx8IENQVShNSVBTKSB8fCBDUFUoTUlQUzY0KSB8fCBDUFUoWDg2KSB8 fCBDUFUoWDg2XzY0KSB8fCBDUFUoQVJNKSB8fCBDUFUoQVJNNjQpCiBjb25zdGV4cHIgc2l6ZV90 IENlaWxpbmdPblBhZ2VTaXplID0gNCAqIEtCOwotI2VsaWYgQ1BVKFVOS05PV04pIHx8IENQVShQ UEMpIHx8IENQVShQUEM2NCkgfHwgQ1BVKFBQQzY0TEUpCi1jb25zdGV4cHIgc2l6ZV90IENlaWxp bmdPblBhZ2VTaXplID0gNjQgKiBLQjsKICNlbHNlCiAjZXJyb3IgTXVzdCBzZXQgQ2VpbGluZ09u UGFnZVNpemUgaW4gUGFnZUJsb2NrLmggd2hlbiBhZGRpbmcgYSBuZXcgQ1BVIGFyY2hpdGVjdHVy ZSEKICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL2NtYWtlL1dlYktpdEZlYXR1cmVzLmNtYWtl IGIvU291cmNlL2NtYWtlL1dlYktpdEZlYXR1cmVzLmNtYWtlCmluZGV4IDZkZjE5NzE0Y2MxYmIw YmNjMmQyMDE1MDQ5YTkzYThjMTc5ZmJkNGEuLjUzNTlhMzUwNmRhNTcwZjFlMzQ3NTFhMDE2NjA0 ZDZlMDc1YjYyNTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9jbWFrZS9XZWJLaXRGZWF0dXJlcy5jbWFr ZQorKysgYi9Tb3VyY2UvY21ha2UvV2ViS2l0RmVhdHVyZXMuY21ha2UKQEAgLTU5LDEwICs1OSwz MiBAQCBtYWNybyhXRUJLSVRfT1BUSU9OX0RFUEVORCBfbmFtZSBfZGVwZW5kKQogICAgIGxpc3Qo QVBQRU5EIF9XRUJLSVRfQVZBSUxBQkxFX09QVElPTlNfJHtfbmFtZX1fREVQRU5ERU5DSUVTICR7 X2RlcGVuZH0pCiBlbmRtYWNybygpCiAKKyMgV2UgY2FuJ3QgdXNlIFdFQktJVF9PUFRJT05fREVG SU5FIGZvciBVU0VfNjRLQl9QQUdFX0JMT0NLIGJlY2F1c2UgaXQncyBuZWVkZWQgdG8gc2V0IHRo ZSBkZWZhdWx0CisjIHZhbHVlIG9mIG90aGVyIG9wdGlvbnMuIFdoeSBkbyB3ZSBuZWVkIHRoaXMg b3B0aW9uPyBCZWNhdXNlIEpTQyBhbmQgYm1hbGxvYyBib3RoIHdhbnQgdG8ga25vdyB0aGUKKyMg dXNlcnNwYWNlIHBhZ2Ugc2l6ZSBhdCBjb21waWxlIHRpbWUsIHdoaWNoIGlzIGltcG9zc2libGUg b24gTGludXggYmVjYXVzZSBpdCdzIGEgcnVudGltZSBzZXR0aW5nLgorIyBXZSBjYW5ub3QgdGVz dCB0aGUgc3lzdGVtIHBhZ2Ugc2l6ZSBhdCBidWlsZCB0aW1lIGluIGhvcGVzIHRoYXQgaXQgd2ls bCBiZSB0aGUgc2FtZSBvbiB0aGUgdGFyZ2V0CisjIHN5c3RlbSwgYmVjYXVzZSAoYSkgY3Jvc3Mg Y29tcGlsaW5nIHdvdWxkbid0IHdvcmssIGFuZCAoYikgdGhlIGJ1aWxkIHN5c3RlbSBjb3VsZCB1 c2UgYSBkaWZmZXJlbnQKKyMgcGFnZSBzaXplIHRoYW4gdGhlIHRhcmdldCBzeXN0ZW0gKHdoaWNo IHdpbGwgYmUgdHJ1ZSBmb3IgRmVkb3JhIGFhcmNoNjQsIGJlY2F1c2UgRmVkb3JhIGlzIGJ1aWx0 CisjIHVzaW5nIFJIRUwpLCBzbyB0aGUgYmVzdCB3ZSBjYW4gZG8gaXMgZ3Vlc3MgYmFzZWQgb24g YmFzZWQgb24gdGhlIHRhcmdldCBDUFUgYXJjaGl0ZWN0dXJlLiBJbgorIyBwcmFjdGljZSwgZ3Vl c3Npbmcgd29ya3MgZm9yIGFsbCBhcmNoaXRlY3R1cmVzIGV4Y2VwdCBhYXJjaDY0ICh1bmxlc3Mg dW51c3VhbCBwYWdlIHNpemVzIGFyZQorIyB1c2VkKSwgYnV0IGl0IGZhaWxzIGZvciBhYXJjaDY0 IGJlY2F1c2UgZGlzdHJvcyBhcmUgc3BsaXQgYmV0d2VlbiB1c2luZyA0IEtCIGFuZCA2NCBLQiBw YWdlcworIyB0aGVyZS4gTW9zdCBkaXN0cm9zIChpbmNsdWRpbmcgRmVkb3JhKSB1c2UgNCBLQiwg YnV0IFJIRUwgdXNlcyAxNiBLQi4gU1VTRSBhY3R1YWxseSBzdXBwb3J0cyBib3RoLgorIyBTaW5j ZSB0aGVyZSBpcyBubyB3YXkgdG8gZ3Vlc3MgY29ycmVjdGx5LCB0aGUgYmVzdCB3ZSBjYW4gZG8g aXMgcHJvdmlkZSBhbiBvcHRpb24gZm9yIGl0LiBZb3UKKyMgc2hvdWxkIHByb2JhYmx5IG9ubHkg dG8gdXNlIHRoaXMgaWYgYnVpbGRpbmcgZm9yIGFhcmNoNjQuIE90aGVyd2lzZSwga25vd24gQ1BV cyBleGNlcHQgUG93ZXJQQworIyB3aWxsIHVzZSA0IEtCLCB3aGlsZSBQb3dlclBDIGFuZCB1bmtu b3duIENQVXMgd2lsbCB1c2UgNjQgS0IgKHNlZSB3dGYvUGFnZUJsb2NrLmgpLiBhYXJjaDY0IHdp bGwKKyMgY29udGludWUgdG8gZGVmYXVsdCB0byA0IEtCIGJlY2F1c2UgdGhpcyBpcyBhIGJldHRl ciBkZWZhdWx0IG9uIHN5c3RlbXMgd2hlcmUgaXQgZG9lc24ndCBjcmFzaC4KK29wdGlvbihVU0Vf NjRLQl9QQUdFX0JMT0NLICJGb3JjZSBzdXBwb3J0IDY0IEtCIHVzZXJzcGFjZSBwYWdlIHNpemUg KHJlZHVjZXMgc2VjdXJpdHkgYW5kIHBlcmZvcm1hbmNlKSIgT0ZGKQorCiBtYWNybyhXRUJLSVRf T1BUSU9OX0JFR0lOKQogICAgIHNldChfU0VUVElOR19XRUJLSVRfT1BUSU9OUyBUUlVFKQogCi0g ICAgaWYgKFdURl9DUFVfQVJNNjQgT1IgV1RGX0NQVV9YODZfNjQpCisgICAgaWYgKFVTRV82NEtC X1BBR0VfQkxPQ0spCisgICAgICAgIHNldChFTkFCTEVfSklUX0RFRkFVTFQgT0ZGKQorICAgICAg ICBzZXQoRU5BQkxFX0ZUTF9ERUZBVUxUIE9GRikKKyAgICAgICAgc2V0KFVTRV9TWVNURU1fTUFM TE9DX0RFRkFVTFQgT04pCisgICAgICAgIHNldChFTkFCTEVfQ19MT09QX0RFRkFVTFQgT04pCisg ICAgICAgIHNldChFTkFCTEVfU0FNUExJTkdfUFJPRklMRVJfREVGQVVMVCBPRkYpCisgICAgZWxz ZWlmIChXVEZfQ1BVX0FSTTY0IE9SIFdURl9DUFVfWDg2XzY0KQogICAgICAgICBzZXQoRU5BQkxF X0pJVF9ERUZBVUxUIE9OKQogICAgICAgICBzZXQoRU5BQkxFX0ZUTF9ERUZBVUxUIE9OKQogICAg ICAgICBzZXQoVVNFX1NZU1RFTV9NQUxMT0NfREVGQVVMVCBPRkYpCmRpZmYgLS1naXQgYS9DaGFu Z2VMb2cgYi9DaGFuZ2VMb2cKaW5kZXggOTBjNmQxNWMxNTY1MWI1MTQyNzM4MmY5NzU1YTNjYzg2 N2UzZjFjNy4uNzkyMGMxMGUwYWM1YTM2YWM4NDg1ZDAyN2EyN2ZmZDBjNDkwMWM4NSAxMDA2NDQK LS0tIGEvQ2hhbmdlTG9nCisrKyBiL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDIwLTEw LTIwICBNaWNoYWVsIENhdGFuemFybyAgPG1jYXRhbnphcm9AZ25vbWUub3JnPgorCisgICAgICAg IEFkZCBuZXcgYnVpbGQgb3B0aW9uIFVTRSg2NEtCX1BBR0VfQkxPQ0spCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTc5ODkKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBXaHkgZG8gd2UgbmVlZCB0aGlzIG9w dGlvbj8gQmVjYXVzZSBKU0MgYW5kIGJtYWxsb2MgYm90aCB3YW50IHRvIGtub3cgdGhlIHVzZXJz cGFjZSBwYWdlCisgICAgICAgIHNpemUgYXQgY29tcGlsZSB0aW1lLCB3aGljaCBpcyBpbXBvc3Np YmxlIG9uIExpbnV4IGJlY2F1c2UgaXQncyBhIHJ1bnRpbWUgc2V0dGluZy4gV2UKKyAgICAgICAg Y2Fubm90IHRlc3QgdGhlIHN5c3RlbSBwYWdlIHNpemUgYXQgYnVpbGQgdGltZSBpbiBob3BlcyB0 aGF0IGl0IHdpbGwgYmUgdGhlIHNhbWUgb24gdGhlCisgICAgICAgIHRhcmdldCBzeXN0ZW0sIGJl Y2F1c2UgKGEpIGNyb3NzIGNvbXBpbGluZyB3b3VsZG4ndCB3b3JrLCBhbmQgKGIpIHRoZSBidWls ZCBzeXN0ZW0gY291bGQKKyAgICAgICAgdXNlIGEgZGlmZmVyZW50IHBhZ2Ugc2l6ZSB0aGFuIHRo ZSB0YXJnZXQgc3lzdGVtICh3aGljaCB3aWxsIGJlIHRydWUgZm9yIEZlZG9yYSBhYXJjaDY0LAor ICAgICAgICBiZWNhdXNlIEZlZG9yYSBpcyBidWlsdCB1c2luZyBSSEVMKSwgc28gdGhlIGJlc3Qg d2UgY2FuIGRvIGlzIGd1ZXNzIGJhc2VkIG9uIHRoZSB0YXJnZXQgQ1BVCisgICAgICAgIGFyY2hp dGVjdHVyZS4gSW4gcHJhY3RpY2UsIGd1ZXNzaW5nIHdvcmtzIGZvciBhbGwgYXJjaGl0ZWN0dXJl cyBleGNlcHQgYWFyY2g2NCAodW5sZXNzCisgICAgICAgIHVudXN1YWwgcGFnZSBzaXplcyBhcmUg dXNlZCksIGJ1dCBpdCBmYWlscyBmb3IgYWFyY2g2NCBiZWNhdXNlIGRpc3Ryb3MgYXJlIHNwbGl0 IGJldHdlZW4KKyAgICAgICAgdXNpbmcgNCBLQiBhbmQgNjQgS0IgcGFnZXMgdGhlcmUuIE1vc3Qg ZGlzdHJvcyAoaW5jbHVkaW5nIEZlZG9yYSkgdXNlIDQgS0IsIGJ1dCBSSEVMIHVzZXMKKyAgICAg ICAgMTYgS0IuIFNVU0UgYWN0dWFsbHkgc3VwcG9ydHMgYm90aC4gU2luY2UgdGhlcmUgaXMgbm8g d2F5IHRvIGd1ZXNzIGNvcnJlY3RseSwgdGhlIGJlc3Qgd2UKKyAgICAgICAgY2FuIGRvIGlzIHBy b3ZpZGUgYW4gb3B0aW9uIGZvciBpdC4gWW91IHNob3VsZCBwcm9iYWJseSBvbmx5IHRvIHVzZSB0 aGlzIGlmIGJ1aWxkaW5nIGZvcgorICAgICAgICBhYXJjaDY0LiBPdGhlcndpc2UsIGtub3duIENQ VXMgZXhjZXB0IFBvd2VyUEMgd2lsbCB1c2UgNCBLQiwgd2hpbGUgUG93ZXJQQyBhbmQgdW5rbm93 biBDUFVzCisgICAgICAgIHdpbGwgdXNlIDY0IEtCIChzZWUgd3RmL1BhZ2VCbG9jay5oKS4gYWFy Y2g2NCB3aWxsIGNvbnRpbnVlIHRvIGRlZmF1bHQgdG8gNCBLQiBiZWNhdXNlIHRoaXMKKyAgICAg ICAgaXMgYSBtdWNoIGJldHRlciBkZWZhdWx0IG9uIHN5c3RlbXMgd2hlcmUgaXQgZG9lc24ndCBj cmFzaC4KKworICAgICAgICBIYXZpbmcgb25lIGZsYWcgd2lsbCBoZWxwIGF2b2lkIG1pc3Rha2Vz LiBFLmcuIGJvdGggUkhFTCBhbmQgU1VTRSB3ZXJlIG1hbnVhbGx5IHBhc3NpbmcKKyAgICAgICAg LURFTkFCTEVfSklUPU9GRiBhbmQgLURVU0VfU1lTVEVNX01BTExPQz1PTiwgYnV0IHdlIG1pc3Nl ZCAtREVOQUJMRV9DX0xPT1A9T04gYW5kCisgICAgICAgIC1ERU5BQkxFX1NBTVBMSU5HX1BST0ZJ TEVSPU9GRiwgc28gd291bmQgdXAgcnVubmluZyB3aXRoIGJvdGggSklUIGFuZCBjbG9vcCBkaXNh YmxlZCwgYQorICAgICAgICBjb25maWd1cmF0aW9uIG5vdCBvdGhlcndpc2UgdXNlZCBvbiBMaW51 eCAoYW5kIG5vdCBzdXBwb3J0ZWQgYnkgR1RLIG9yIFdQRSBwb3J0cykuIEl0IHdpbGwKKyAgICAg ICAgYmUgZWFzaWVyIHRvIG5vdCBtZXNzIHVwIGlmIHdlIG9ubHkgaGF2ZSB0byBwYXNzIG9uZSBz cGVjaWFsIGJ1aWxkIG9wdGlvbi4gVGhpcyB3aWxsIGFsc28KKyAgICAgICAgYWxsb3cgdXMgdG8g c3RvcCBwYXRjaGluZyBQYWdlQmxvY2suaCBkb3duc3RyZWFtLCBiZWNhdXNlIEkgZG9uJ3QgbGlr ZSBkb3duc3RyZWFtIHBhdGNoZXMKKyAgICAgICAgdGhhdCB3ZSBoYXZlIHRvIGtlZXAgZm9yZXZl ci4KKworICAgICAgICAqIFNvdXJjZS9jbWFrZS9XZWJLaXRGZWF0dXJlcy5jbWFrZToKKwogMjAy MC0xMC0yMCAgTWljaGFlbCBDYXRhbnphcm8gIDxtY2F0YW56YXJvQGdub21lLm9yZz4KIAogICAg ICAgICBbR1RLXSBNb3ZlIEVOQUJMRV9BU1lOQ19TQ1JPTExJTkcgYnVpbGQgb3B0aW9uIHRvIHJp Z2h0IHBsYWNlIGluIE9wdGlvbnNHVEsuY21ha2UK 411938 2020-10-20 16:30:03 -0700 2020-11-04 12:59:21 -0800 Patch bug-217989-20201020183003.patch text/plain 6454 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjY4NzcyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDNhNDU2ZDdjNjMyNzJjNDg1OGVlZGM0 YzEyNzNlNjFkYjk5ZDdjYjguLjlkZmMxZWQ3MTc3MDUzOTE4ZGYyNGU4NGViNTgwM2Y0NGU2OTYx YzAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTIgQEAKKzIwMjAtMTAtMjAgIE1pY2hhZWwgQ2F0YW56YXJvICA8 bWNhdGFuemFyb0Bnbm9tZS5vcmc+CisKKyAgICAgICAgQWRkIG5ldyBidWlsZCBvcHRpb24gVVNF KDY0S0JfUEFHRV9CTE9DSykKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIxNzk4OQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgICogd3RmL1BhZ2VCbG9jay5oOgorCiAyMDIwLTEwLTIwICBTaWh1aSBMaXUgIDxz aWh1aV9saXVAYXBwbGUuY29tPgogCiAgICAgICAgIEFkZCBzdHVicyBmb3IgU3BlZWNoUmVjb2du aXRpb24KZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5oIGIvU291cmNlL1dU Ri93dGYvUGFnZUJsb2NrLmgKaW5kZXggY2Y1Y2YzMWIyYzkzZTAyMTlkMzcyMzE0NmI3ZmI5NWJl ODQwYjNhNS4uYzY1NWE1MGMyYzg5ZDNmN2FiYzBiNmIzZWE0ZDAwMWE0YWU4ZTEzYiAxMDA2NDQK LS0tIGEvU291cmNlL1dURi93dGYvUGFnZUJsb2NrLmgKKysrIGIvU291cmNlL1dURi93dGYvUGFn ZUJsb2NrLmgKQEAgLTQ5LDEwICs0OSwxMCBAQCBuYW1lc3BhY2UgV1RGIHsKIC8vIFVzZSA2NCBL aUIgZm9yIGFueSB1bmtub3duIENQVXMgdG8gYmUgY29uc2VydmF0aXZlLgogI2lmIE9TKERBUldJ TikgfHwgUExBVEZPUk0oUExBWVNUQVRJT04pCiBjb25zdGV4cHIgc2l6ZV90IENlaWxpbmdPblBh Z2VTaXplID0gMTYgKiBLQjsKKyNlbGlmIFVTRSg2NEtCX1BBR0VfQkxPQ0spIHx8IENQVShQUEMp IHx8IENQVShQUEM2NCkgfHwgQ1BVKFBQQzY0TEUpIHx8IENQVShVTktOT1dOKQorY29uc3RleHBy IHNpemVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDY0ICogS0I7CiAjZWxpZiBPUyhXSU5ET1dTKSB8 fCBDUFUoTUlQUykgfHwgQ1BVKE1JUFM2NCkgfHwgQ1BVKFg4NikgfHwgQ1BVKFg4Nl82NCkgfHwg Q1BVKEFSTSkgfHwgQ1BVKEFSTTY0KQogY29uc3RleHByIHNpemVfdCBDZWlsaW5nT25QYWdlU2l6 ZSA9IDQgKiBLQjsKLSNlbGlmIENQVShVTktOT1dOKSB8fCBDUFUoUFBDKSB8fCBDUFUoUFBDNjQp IHx8IENQVShQUEM2NExFKQotY29uc3RleHByIHNpemVfdCBDZWlsaW5nT25QYWdlU2l6ZSA9IDY0 ICogS0I7CiAjZWxzZQogI2Vycm9yIE11c3Qgc2V0IENlaWxpbmdPblBhZ2VTaXplIGluIFBhZ2VC bG9jay5oIHdoZW4gYWRkaW5nIGEgbmV3IENQVSBhcmNoaXRlY3R1cmUhCiAjZW5kaWYKZGlmZiAt LWdpdCBhL1NvdXJjZS9jbWFrZS9XZWJLaXRGZWF0dXJlcy5jbWFrZSBiL1NvdXJjZS9jbWFrZS9X ZWJLaXRGZWF0dXJlcy5jbWFrZQppbmRleCA2ZGYxOTcxNGNjMWJiMGJjYzJkMjAxNTA0OWE5M2E4 YzE3OWZiZDRhLi41MzU5YTM1MDZkYTU3MGYxZTM0NzUxYTAxNjYwNGQ2ZTA3NWI2MjUzIDEwMDY0 NAotLS0gYS9Tb3VyY2UvY21ha2UvV2ViS2l0RmVhdHVyZXMuY21ha2UKKysrIGIvU291cmNlL2Nt YWtlL1dlYktpdEZlYXR1cmVzLmNtYWtlCkBAIC01OSwxMCArNTksMzIgQEAgbWFjcm8oV0VCS0lU X09QVElPTl9ERVBFTkQgX25hbWUgX2RlcGVuZCkKICAgICBsaXN0KEFQUEVORCBfV0VCS0lUX0FW QUlMQUJMRV9PUFRJT05TXyR7X25hbWV9X0RFUEVOREVOQ0lFUyAke19kZXBlbmR9KQogZW5kbWFj cm8oKQogCisjIFdlIGNhbid0IHVzZSBXRUJLSVRfT1BUSU9OX0RFRklORSBmb3IgVVNFXzY0S0Jf UEFHRV9CTE9DSyBiZWNhdXNlIGl0J3MgbmVlZGVkIHRvIHNldCB0aGUgZGVmYXVsdAorIyB2YWx1 ZSBvZiBvdGhlciBvcHRpb25zLiBXaHkgZG8gd2UgbmVlZCB0aGlzIG9wdGlvbj8gQmVjYXVzZSBK U0MgYW5kIGJtYWxsb2MgYm90aCB3YW50IHRvIGtub3cgdGhlCisjIHVzZXJzcGFjZSBwYWdlIHNp emUgYXQgY29tcGlsZSB0aW1lLCB3aGljaCBpcyBpbXBvc3NpYmxlIG9uIExpbnV4IGJlY2F1c2Ug aXQncyBhIHJ1bnRpbWUgc2V0dGluZy4KKyMgV2UgY2Fubm90IHRlc3QgdGhlIHN5c3RlbSBwYWdl IHNpemUgYXQgYnVpbGQgdGltZSBpbiBob3BlcyB0aGF0IGl0IHdpbGwgYmUgdGhlIHNhbWUgb24g dGhlIHRhcmdldAorIyBzeXN0ZW0sIGJlY2F1c2UgKGEpIGNyb3NzIGNvbXBpbGluZyB3b3VsZG4n dCB3b3JrLCBhbmQgKGIpIHRoZSBidWlsZCBzeXN0ZW0gY291bGQgdXNlIGEgZGlmZmVyZW50Cisj IHBhZ2Ugc2l6ZSB0aGFuIHRoZSB0YXJnZXQgc3lzdGVtICh3aGljaCB3aWxsIGJlIHRydWUgZm9y IEZlZG9yYSBhYXJjaDY0LCBiZWNhdXNlIEZlZG9yYSBpcyBidWlsdAorIyB1c2luZyBSSEVMKSwg c28gdGhlIGJlc3Qgd2UgY2FuIGRvIGlzIGd1ZXNzIGJhc2VkIG9uIGJhc2VkIG9uIHRoZSB0YXJn ZXQgQ1BVIGFyY2hpdGVjdHVyZS4gSW4KKyMgcHJhY3RpY2UsIGd1ZXNzaW5nIHdvcmtzIGZvciBh bGwgYXJjaGl0ZWN0dXJlcyBleGNlcHQgYWFyY2g2NCAodW5sZXNzIHVudXN1YWwgcGFnZSBzaXpl cyBhcmUKKyMgdXNlZCksIGJ1dCBpdCBmYWlscyBmb3IgYWFyY2g2NCBiZWNhdXNlIGRpc3Ryb3Mg YXJlIHNwbGl0IGJldHdlZW4gdXNpbmcgNCBLQiBhbmQgNjQgS0IgcGFnZXMKKyMgdGhlcmUuIE1v c3QgZGlzdHJvcyAoaW5jbHVkaW5nIEZlZG9yYSkgdXNlIDQgS0IsIGJ1dCBSSEVMIHVzZXMgMTYg S0IuIFNVU0UgYWN0dWFsbHkgc3VwcG9ydHMgYm90aC4KKyMgU2luY2UgdGhlcmUgaXMgbm8gd2F5 IHRvIGd1ZXNzIGNvcnJlY3RseSwgdGhlIGJlc3Qgd2UgY2FuIGRvIGlzIHByb3ZpZGUgYW4gb3B0 aW9uIGZvciBpdC4gWW91CisjIHNob3VsZCBwcm9iYWJseSBvbmx5IHRvIHVzZSB0aGlzIGlmIGJ1 aWxkaW5nIGZvciBhYXJjaDY0LiBPdGhlcndpc2UsIGtub3duIENQVXMgZXhjZXB0IFBvd2VyUEMK KyMgd2lsbCB1c2UgNCBLQiwgd2hpbGUgUG93ZXJQQyBhbmQgdW5rbm93biBDUFVzIHdpbGwgdXNl IDY0IEtCIChzZWUgd3RmL1BhZ2VCbG9jay5oKS4gYWFyY2g2NCB3aWxsCisjIGNvbnRpbnVlIHRv IGRlZmF1bHQgdG8gNCBLQiBiZWNhdXNlIHRoaXMgaXMgYSBiZXR0ZXIgZGVmYXVsdCBvbiBzeXN0 ZW1zIHdoZXJlIGl0IGRvZXNuJ3QgY3Jhc2guCitvcHRpb24oVVNFXzY0S0JfUEFHRV9CTE9DSyAi Rm9yY2Ugc3VwcG9ydCA2NCBLQiB1c2Vyc3BhY2UgcGFnZSBzaXplIChyZWR1Y2VzIHNlY3VyaXR5 IGFuZCBwZXJmb3JtYW5jZSkiIE9GRikKKwogbWFjcm8oV0VCS0lUX09QVElPTl9CRUdJTikKICAg ICBzZXQoX1NFVFRJTkdfV0VCS0lUX09QVElPTlMgVFJVRSkKIAotICAgIGlmIChXVEZfQ1BVX0FS TTY0IE9SIFdURl9DUFVfWDg2XzY0KQorICAgIGlmIChVU0VfNjRLQl9QQUdFX0JMT0NLKQorICAg ICAgICBzZXQoRU5BQkxFX0pJVF9ERUZBVUxUIE9GRikKKyAgICAgICAgc2V0KEVOQUJMRV9GVExf REVGQVVMVCBPRkYpCisgICAgICAgIHNldChVU0VfU1lTVEVNX01BTExPQ19ERUZBVUxUIE9OKQor ICAgICAgICBzZXQoRU5BQkxFX0NfTE9PUF9ERUZBVUxUIE9OKQorICAgICAgICBzZXQoRU5BQkxF X1NBTVBMSU5HX1BST0ZJTEVSX0RFRkFVTFQgT0ZGKQorICAgIGVsc2VpZiAoV1RGX0NQVV9BUk02 NCBPUiBXVEZfQ1BVX1g4Nl82NCkKICAgICAgICAgc2V0KEVOQUJMRV9KSVRfREVGQVVMVCBPTikK ICAgICAgICAgc2V0KEVOQUJMRV9GVExfREVGQVVMVCBPTikKICAgICAgICAgc2V0KFVTRV9TWVNU RU1fTUFMTE9DX0RFRkFVTFQgT0ZGKQpkaWZmIC0tZ2l0IGEvQ2hhbmdlTG9nIGIvQ2hhbmdlTG9n CmluZGV4IDkwYzZkMTVjMTU2NTFiNTE0MjczODJmOTc1NWEzY2M4NjdlM2YxYzcuLjlhMzU5MjI5 NzJhZmViZTVjYjczN2I5ZDQyMTE5OTJkOWFlYTg1MGQgMTAwNjQ0Ci0tLSBhL0NoYW5nZUxvZwor KysgYi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNSBAQAorMjAyMC0xMC0yMCAgTWljaGFlbCBDYXRh bnphcm8gIDxtY2F0YW56YXJvQGdub21lLm9yZz4KKworICAgICAgICBBZGQgbmV3IGJ1aWxkIG9w dGlvbiBVU0UoNjRLQl9QQUdFX0JMT0NLKQorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjE3OTg5CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgV2h5IGRvIHdlIG5lZWQgdGhpcyBvcHRpb24/IEJlY2F1c2UgSlND IGFuZCBibWFsbG9jIGJvdGggd2FudCB0byBrbm93IHRoZSB1c2Vyc3BhY2UgcGFnZQorICAgICAg ICBzaXplIGF0IGNvbXBpbGUgdGltZSwgd2hpY2ggaXMgaW1wb3NzaWJsZSBvbiBMaW51eCBiZWNh dXNlIGl0J3MgYSBydW50aW1lIHNldHRpbmcuIFdlCisgICAgICAgIGNhbm5vdCB0ZXN0IHRoZSBz eXN0ZW0gcGFnZSBzaXplIGF0IGJ1aWxkIHRpbWUgaW4gaG9wZXMgdGhhdCBpdCB3aWxsIGJlIHRo ZSBzYW1lIG9uIHRoZQorICAgICAgICB0YXJnZXQgc3lzdGVtLCBiZWNhdXNlIChhKSBjcm9zcyBj b21waWxpbmcgd291bGRuJ3Qgd29yaywgYW5kIChiKSB0aGUgYnVpbGQgc3lzdGVtIGNvdWxkCisg ICAgICAgIHVzZSBhIGRpZmZlcmVudCBwYWdlIHNpemUgdGhhbiB0aGUgdGFyZ2V0IHN5c3RlbSAo d2hpY2ggd2lsbCBiZSB0cnVlIGZvciBGZWRvcmEgYWFyY2g2NCwKKyAgICAgICAgYmVjYXVzZSBG ZWRvcmEgaXMgYnVpbHQgdXNpbmcgUkhFTCksIHNvIHRoZSBiZXN0IHdlIGNhbiBkbyBpcyBndWVz cyBiYXNlZCBvbiB0aGUgdGFyZ2V0IENQVQorICAgICAgICBhcmNoaXRlY3R1cmUuIEluIHByYWN0 aWNlLCBndWVzc2luZyB3b3JrcyBmb3IgYWxsIGFyY2hpdGVjdHVyZXMgZXhjZXB0IGFhcmNoNjQg KHVubGVzcworICAgICAgICB1bnVzdWFsIHBhZ2Ugc2l6ZXMgYXJlIHVzZWQpLCBidXQgaXQgZmFp bHMgZm9yIGFhcmNoNjQgYmVjYXVzZSBkaXN0cm9zIGFyZSBzcGxpdCBiZXR3ZWVuCisgICAgICAg IHVzaW5nIDQgS0IgYW5kIDY0IEtCIHBhZ2VzIHRoZXJlLiBNb3N0IGRpc3Ryb3MgKGluY2x1ZGlu ZyBGZWRvcmEpIHVzZSA0IEtCLCBidXQgUkhFTCB1c2VzCisgICAgICAgIDY0IEtCLiBTVVNFIGFj dHVhbGx5IHN1cHBvcnRzIGJvdGguIFNpbmNlIHRoZXJlIGlzIG5vIHdheSB0byBndWVzcyBjb3Jy ZWN0bHksIHRoZSBiZXN0IHdlCisgICAgICAgIGNhbiBkbyBpcyBwcm92aWRlIGFuIG9wdGlvbiBm b3IgaXQuIFlvdSBzaG91bGQgcHJvYmFibHkgb25seSB0byB1c2UgdGhpcyBpZiBidWlsZGluZyBm b3IKKyAgICAgICAgYWFyY2g2NC4gT3RoZXJ3aXNlLCBrbm93biBDUFVzIGV4Y2VwdCBQb3dlclBD IHdpbGwgdXNlIDQgS0IsIHdoaWxlIFBvd2VyUEMgYW5kIHVua25vd24gQ1BVcworICAgICAgICB3 aWxsIHVzZSA2NCBLQiAoc2VlIHd0Zi9QYWdlQmxvY2suaCkuIGFhcmNoNjQgd2lsbCBjb250aW51 ZSB0byBkZWZhdWx0IHRvIDQgS0IgYmVjYXVzZSB0aGlzCisgICAgICAgIGlzIGEgbXVjaCBiZXR0 ZXIgZGVmYXVsdCBvbiBzeXN0ZW1zIHdoZXJlIGl0IGRvZXNuJ3QgY3Jhc2guCisKKyAgICAgICAg SGF2aW5nIG9uZSBmbGFnIHdpbGwgaGVscCBhdm9pZCBtaXN0YWtlcy4gRS5nLiBib3RoIFJIRUwg YW5kIFNVU0Ugd2VyZSBtYW51YWxseSBwYXNzaW5nCisgICAgICAgIC1ERU5BQkxFX0pJVD1PRkYg YW5kIC1EVVNFX1NZU1RFTV9NQUxMT0M9T04sIGJ1dCB3ZSBtaXNzZWQgLURFTkFCTEVfQ19MT09Q PU9OIGFuZAorICAgICAgICAtREVOQUJMRV9TQU1QTElOR19QUk9GSUxFUj1PRkYsIHNvIHdvdW5k IHVwIHJ1bm5pbmcgd2l0aCBib3RoIEpJVCBhbmQgY2xvb3AgZGlzYWJsZWQsIGEKKyAgICAgICAg Y29uZmlndXJhdGlvbiBub3Qgb3RoZXJ3aXNlIHVzZWQgb24gTGludXggKGFuZCBub3Qgc3VwcG9y dGVkIGJ5IEdUSyBvciBXUEUgcG9ydHMpLiBJdCB3aWxsCisgICAgICAgIGJlIGVhc2llciB0byBu b3QgbWVzcyB1cCBpZiB3ZSBvbmx5IGhhdmUgdG8gcGFzcyBvbmUgc3BlY2lhbCBidWlsZCBvcHRp b24uIFRoaXMgd2lsbCBhbHNvCisgICAgICAgIGFsbG93IHVzIHRvIHN0b3AgcGF0Y2hpbmcgUGFn ZUJsb2NrLmggZG93bnN0cmVhbSwgYmVjYXVzZSBJIGRvbid0IGxpa2UgZG93bnN0cmVhbSBwYXRj aGVzCisgICAgICAgIHRoYXQgd2UgaGF2ZSB0byBrZWVwIGZvcmV2ZXIuCisKKyAgICAgICAgKiBT b3VyY2UvY21ha2UvV2ViS2l0RmVhdHVyZXMuY21ha2U6CisKIDIwMjAtMTAtMjAgIE1pY2hhZWwg Q2F0YW56YXJvICA8bWNhdGFuemFyb0Bnbm9tZS5vcmc+CiAKICAgICAgICAgW0dUS10gTW92ZSBF TkFCTEVfQVNZTkNfU0NST0xMSU5HIGJ1aWxkIG9wdGlvbiB0byByaWdodCBwbGFjZSBpbiBPcHRp b25zR1RLLmNtYWtlCg== 413198 2020-11-04 12:59:24 -0800 2020-11-04 15:07:40 -0800 Patch bug-217989-20201104145930.patch text/plain 6448 mcatanzaro U3VidmVyc2lvbiBSZXZpc2lvbjogMjY5Mzc3CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGQyZmM2NjY5OTY1Y2I5YzA1MGIzNjQ0 NDY0MTFiNjQ1N2NmMDg0MWIuLjdjMzU4ZTgyZjQzZDAyYjc2MGNiOTUwYjZiY2RmNGI3MzY2MDc3 NGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTIgQEAKKzIwMjAtMTEtMDQgIE1pY2hhZWwgQ2F0YW56YXJvICA8 bWNhdGFuemFyb0Bnbm9tZS5vcmc+CisKKyAgICAgICAgQWRkIG5ldyBidWlsZCBvcHRpb24gVVNF KDY0S0JfUEFHRV9CTE9DSykKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIxNzk4OQorCisgICAgICAgIFJldmlld2VkIGJ5IFl1c3VrZSBTdXp1a2kuCisK KyAgICAgICAgKiB3dGYvUGFnZUJsb2NrLmg6CisKIDIwMjAtMTEtMDMgIFl1c3VrZSBTdXp1a2kg IDx5c3V6dWtpQGFwcGxlLmNvbT4KIAogICAgICAgICBbSlNDXSBBZGQgSklUQ2FnZSBzdXBwb3J0 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9QYWdlQmxvY2suaCBiL1NvdXJjZS9XVEYvd3Rm L1BhZ2VCbG9jay5oCmluZGV4IGNmNWNmMzFiMmM5M2UwMjE5ZDM3MjMxNDZiN2ZiOTViZTg0MGIz YTUuLmM2NTVhNTBjMmM4OWQzZjdhYmMwYjZiM2VhNGQwMDFhNGFlOGUxM2IgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9jay5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1BhZ2VCbG9j ay5oCkBAIC00OSwxMCArNDksMTAgQEAgbmFtZXNwYWNlIFdURiB7CiAvLyBVc2UgNjQgS2lCIGZv ciBhbnkgdW5rbm93biBDUFVzIHRvIGJlIGNvbnNlcnZhdGl2ZS4KICNpZiBPUyhEQVJXSU4pIHx8 IFBMQVRGT1JNKFBMQVlTVEFUSU9OKQogY29uc3RleHByIHNpemVfdCBDZWlsaW5nT25QYWdlU2l6 ZSA9IDE2ICogS0I7CisjZWxpZiBVU0UoNjRLQl9QQUdFX0JMT0NLKSB8fCBDUFUoUFBDKSB8fCBD UFUoUFBDNjQpIHx8IENQVShQUEM2NExFKSB8fCBDUFUoVU5LTk9XTikKK2NvbnN0ZXhwciBzaXpl X3QgQ2VpbGluZ09uUGFnZVNpemUgPSA2NCAqIEtCOwogI2VsaWYgT1MoV0lORE9XUykgfHwgQ1BV KE1JUFMpIHx8IENQVShNSVBTNjQpIHx8IENQVShYODYpIHx8IENQVShYODZfNjQpIHx8IENQVShB Uk0pIHx8IENQVShBUk02NCkKIGNvbnN0ZXhwciBzaXplX3QgQ2VpbGluZ09uUGFnZVNpemUgPSA0 ICogS0I7Ci0jZWxpZiBDUFUoVU5LTk9XTikgfHwgQ1BVKFBQQykgfHwgQ1BVKFBQQzY0KSB8fCBD UFUoUFBDNjRMRSkKLWNvbnN0ZXhwciBzaXplX3QgQ2VpbGluZ09uUGFnZVNpemUgPSA2NCAqIEtC OwogI2Vsc2UKICNlcnJvciBNdXN0IHNldCBDZWlsaW5nT25QYWdlU2l6ZSBpbiBQYWdlQmxvY2su aCB3aGVuIGFkZGluZyBhIG5ldyBDUFUgYXJjaGl0ZWN0dXJlIQogI2VuZGlmCmRpZmYgLS1naXQg YS9Tb3VyY2UvY21ha2UvV2ViS2l0RmVhdHVyZXMuY21ha2UgYi9Tb3VyY2UvY21ha2UvV2ViS2l0 RmVhdHVyZXMuY21ha2UKaW5kZXggYjhmNjg1NjE1NDI5OGJmNWQwNWM3NzE2YWJlZTYyMjYxMDg1 ODUzOC4uZWNiZGQ4NTM0Y2IwMzFjNmFmNDc3NTI2ZjhjNzcwZDYzZmYyOGQ3YiAxMDA2NDQKLS0t IGEvU291cmNlL2NtYWtlL1dlYktpdEZlYXR1cmVzLmNtYWtlCisrKyBiL1NvdXJjZS9jbWFrZS9X ZWJLaXRGZWF0dXJlcy5jbWFrZQpAQCAtNTksMTAgKzU5LDMzIEBAIG1hY3JvKFdFQktJVF9PUFRJ T05fREVQRU5EIF9uYW1lIF9kZXBlbmQpCiAgICAgbGlzdChBUFBFTkQgX1dFQktJVF9BVkFJTEFC TEVfT1BUSU9OU18ke19uYW1lfV9ERVBFTkRFTkNJRVMgJHtfZGVwZW5kfSkKIGVuZG1hY3JvKCkK IAorIyBXZSBjYW4ndCB1c2UgV0VCS0lUX09QVElPTl9ERUZJTkUgZm9yIFVTRV82NEtCX1BBR0Vf QkxPQ0sgYmVjYXVzZSBpdCdzIG5lZWRlZCB0byBzZXQgdGhlIGRlZmF1bHQKKyMgdmFsdWUgb2Yg b3RoZXIgb3B0aW9ucy4gV2h5IGRvIHdlIG5lZWQgdGhpcyBvcHRpb24/IEJlY2F1c2UgSlNDIGFu ZCBibWFsbG9jIGJvdGggd2FudCB0byBrbm93IHRoZQorIyB1c2Vyc3BhY2UgcGFnZSBzaXplIGF0 IGNvbXBpbGUgdGltZSwgd2hpY2ggaXMgaW1wb3NzaWJsZSBvbiBMaW51eCBiZWNhdXNlIGl0J3Mg YSBydW50aW1lIHNldHRpbmcuCisjIFdlIGNhbm5vdCB0ZXN0IHRoZSBzeXN0ZW0gcGFnZSBzaXpl IGF0IGJ1aWxkIHRpbWUgaW4gaG9wZXMgdGhhdCBpdCB3aWxsIGJlIHRoZSBzYW1lIG9uIHRoZSB0 YXJnZXQKKyMgc3lzdGVtLCBiZWNhdXNlIChhKSBjcm9zcyBjb21waWxpbmcgd291bGRuJ3Qgd29y aywgYW5kIChiKSB0aGUgYnVpbGQgc3lzdGVtIGNvdWxkIHVzZSBhIGRpZmZlcmVudAorIyBwYWdl IHNpemUgdGhhbiB0aGUgdGFyZ2V0IHN5c3RlbSAod2hpY2ggd2lsbCBiZSB0cnVlIGZvciBGZWRv cmEgYWFyY2g2NCwgYmVjYXVzZSBGZWRvcmEgaXMgYnVpbHQKKyMgdXNpbmcgUkhFTCksIHNvIHRo ZSBiZXN0IHdlIGNhbiBkbyBpcyBndWVzcyBiYXNlZCBvbiBiYXNlZCBvbiB0aGUgdGFyZ2V0IENQ VSBhcmNoaXRlY3R1cmUuIEluCisjIHByYWN0aWNlLCBndWVzc2luZyB3b3JrcyBmb3IgYWxsIGFy Y2hpdGVjdHVyZXMgZXhjZXB0IGFhcmNoNjQgKHVubGVzcyB1bnVzdWFsIHBhZ2Ugc2l6ZXMgYXJl CisjIHVzZWQpLCBidXQgaXQgZmFpbHMgZm9yIGFhcmNoNjQgYmVjYXVzZSBkaXN0cm9zIGFyZSBz cGxpdCBiZXR3ZWVuIHVzaW5nIDQgS0IgYW5kIDY0IEtCIHBhZ2VzCisjIHRoZXJlLiBNb3N0IGRp c3Ryb3MgKGluY2x1ZGluZyBGZWRvcmEpIHVzZSA0IEtCLCBidXQgUkhFTCB1c2VzIDE2IEtCLiBT VVNFIGFjdHVhbGx5IHN1cHBvcnRzIGJvdGguCisjIFNpbmNlIHRoZXJlIGlzIG5vIHdheSB0byBn dWVzcyBjb3JyZWN0bHksIHRoZSBiZXN0IHdlIGNhbiBkbyBpcyBwcm92aWRlIGFuIG9wdGlvbiBm b3IgaXQuIFlvdQorIyBzaG91bGQgcHJvYmFibHkgb25seSB1c2UgdGhpcyBpZiBidWlsZGluZyBm b3IgYWFyY2g2NC4gT3RoZXJ3aXNlLCBrbm93biBDUFVzIGV4Y2VwdCBQb3dlclBDCisjIHdpbGwg dXNlIDQgS0IsIHdoaWxlIFBvd2VyUEMgYW5kIHVua25vd24gQ1BVcyB3aWxsIHVzZSA2NCBLQiAo c2VlIHd0Zi9QYWdlQmxvY2suaCkuIGFhcmNoNjQgd2lsbAorIyBjb250aW51ZSB0byBkZWZhdWx0 IHRvIDQgS0IgYmVjYXVzZSB0aGlzIGlzIGEgYmV0dGVyIGRlZmF1bHQgb24gc3lzdGVtcyB3aGVy ZSBpdCBkb2Vzbid0IGNyYXNoLgorIyAoTGludXggYWFyY2g2NCBpcyBkaWZmZXJlbnQgZnJvbSBB cHBsZSdzIEFSTTY0LCB3aGljaCB1c2VzIDE2IEtCLikKK29wdGlvbihVU0VfNjRLQl9QQUdFX0JM T0NLICJGb3JjZSBzdXBwb3J0IDY0IEtCIHVzZXJzcGFjZSBwYWdlIHNpemUgKHJlZHVjZXMgc2Vj dXJpdHkgYW5kIHBlcmZvcm1hbmNlKSIgT0ZGKQorCiBtYWNybyhXRUJLSVRfT1BUSU9OX0JFR0lO KQogICAgIHNldChfU0VUVElOR19XRUJLSVRfT1BUSU9OUyBUUlVFKQogCi0gICAgaWYgKFdURl9D UFVfQVJNNjQgT1IgV1RGX0NQVV9YODZfNjQpCisgICAgaWYgKFVTRV82NEtCX1BBR0VfQkxPQ0sp CisgICAgICAgIHNldChFTkFCTEVfSklUX0RFRkFVTFQgT0ZGKQorICAgICAgICBzZXQoRU5BQkxF X0ZUTF9ERUZBVUxUIE9GRikKKyAgICAgICAgc2V0KFVTRV9TWVNURU1fTUFMTE9DX0RFRkFVTFQg T04pCisgICAgICAgIHNldChFTkFCTEVfQ19MT09QX0RFRkFVTFQgT04pCisgICAgICAgIHNldChF TkFCTEVfU0FNUExJTkdfUFJPRklMRVJfREVGQVVMVCBPRkYpCisgICAgZWxzZWlmIChXVEZfQ1BV X0FSTTY0IE9SIFdURl9DUFVfWDg2XzY0KQogICAgICAgICBzZXQoRU5BQkxFX0pJVF9ERUZBVUxU IE9OKQogICAgICAgICBzZXQoRU5BQkxFX0ZUTF9ERUZBVUxUIE9OKQogICAgICAgICBzZXQoVVNF X1NZU1RFTV9NQUxMT0NfREVGQVVMVCBPRkYpCmRpZmYgLS1naXQgYS9DaGFuZ2VMb2cgYi9DaGFu Z2VMb2cKaW5kZXggNTQzODlhZDAyOGE4NDdhNzE1YmJhNmE1OGZkNTRlMzI0YTBlYjhkNS4uZmZh ODc3NzhmZTZkOTZhMTIxMDY2NWIwOGE3MGVkMzU4ZWYxMDE5NyAxMDA2NDQKLS0tIGEvQ2hhbmdl TG9nCisrKyBiL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDIwLTExLTA0ICBNaWNoYWVs IENhdGFuemFybyAgPG1jYXRhbnphcm9AZ25vbWUub3JnPgorCisgICAgICAgIEFkZCBuZXcgYnVp bGQgb3B0aW9uIFVTRSg2NEtCX1BBR0VfQkxPQ0spCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMTc5ODkKKworICAgICAgICBSZXZpZXdlZCBieSBZdXN1 a2UgU3V6dWtpLgorCisgICAgICAgIFdoeSBkbyB3ZSBuZWVkIHRoaXMgb3B0aW9uPyBCZWNhdXNl IEpTQyBhbmQgYm1hbGxvYyBib3RoIHdhbnQgdG8ga25vdyB0aGUgdXNlcnNwYWNlIHBhZ2UKKyAg ICAgICAgc2l6ZSBhdCBjb21waWxlIHRpbWUsIHdoaWNoIGlzIGltcG9zc2libGUgb24gTGludXgg YmVjYXVzZSBpdCdzIGEgcnVudGltZSBzZXR0aW5nLiBXZQorICAgICAgICBjYW5ub3QgdGVzdCB0 aGUgc3lzdGVtIHBhZ2Ugc2l6ZSBhdCBidWlsZCB0aW1lIGluIGhvcGVzIHRoYXQgaXQgd2lsbCBi ZSB0aGUgc2FtZSBvbiB0aGUKKyAgICAgICAgdGFyZ2V0IHN5c3RlbSwgYmVjYXVzZSAoYSkgY3Jv c3MgY29tcGlsaW5nIHdvdWxkbid0IHdvcmssIGFuZCAoYikgdGhlIGJ1aWxkIHN5c3RlbSBjb3Vs ZAorICAgICAgICB1c2UgYSBkaWZmZXJlbnQgcGFnZSBzaXplIHRoYW4gdGhlIHRhcmdldCBzeXN0 ZW0gKHdoaWNoIHdpbGwgYmUgdHJ1ZSBmb3IgRmVkb3JhIGFhcmNoNjQsCisgICAgICAgIGJlY2F1 c2UgRmVkb3JhIGlzIGJ1aWx0IHVzaW5nIFJIRUwpLCBzbyB0aGUgYmVzdCB3ZSBjYW4gZG8gaXMg Z3Vlc3MgYmFzZWQgb24gdGhlIHRhcmdldCBDUFUKKyAgICAgICAgYXJjaGl0ZWN0dXJlLiBJbiBw cmFjdGljZSwgZ3Vlc3Npbmcgd29ya3MgZm9yIGFsbCBhcmNoaXRlY3R1cmVzIGV4Y2VwdCBhYXJj aDY0ICh1bmxlc3MKKyAgICAgICAgdW51c3VhbCBwYWdlIHNpemVzIGFyZSB1c2VkKSwgYnV0IGl0 IGZhaWxzIGZvciBhYXJjaDY0IGJlY2F1c2UgZGlzdHJvcyBhcmUgc3BsaXQgYmV0d2VlbgorICAg ICAgICB1c2luZyA0IEtCIGFuZCA2NCBLQiBwYWdlcyB0aGVyZS4gTW9zdCBkaXN0cm9zIChpbmNs dWRpbmcgRmVkb3JhKSB1c2UgNCBLQiwgYnV0IFJIRUwgdXNlcworICAgICAgICA2NCBLQi4gU1VT RSBhY3R1YWxseSBzdXBwb3J0cyBib3RoLiBTaW5jZSB0aGVyZSBpcyBubyB3YXkgdG8gZ3Vlc3Mg Y29ycmVjdGx5LCB0aGUgYmVzdCB3ZQorICAgICAgICBjYW4gZG8gaXMgcHJvdmlkZSBhbiBvcHRp b24gZm9yIGl0LiBZb3Ugc2hvdWxkIHByb2JhYmx5IG9ubHkgdXNlIHRoaXMgaWYgYnVpbGRpbmcg Zm9yCisgICAgICAgIGFhcmNoNjQuIE90aGVyd2lzZSwga25vd24gQ1BVcyBleGNlcHQgUG93ZXJQ QyB3aWxsIHVzZSA0IEtCLCB3aGlsZSBQb3dlclBDIGFuZCB1bmtub3duIENQVXMKKyAgICAgICAg d2lsbCB1c2UgNjQgS0IgKHNlZSB3dGYvUGFnZUJsb2NrLmgpLiBhYXJjaDY0IHdpbGwgY29udGlu dWUgdG8gZGVmYXVsdCB0byA0IEtCIGJlY2F1c2UgdGhpcworICAgICAgICBpcyBhIG11Y2ggYmV0 dGVyIGRlZmF1bHQgb24gc3lzdGVtcyB3aGVyZSBpdCBkb2Vzbid0IGNyYXNoLgorCisgICAgICAg IEhhdmluZyBvbmUgZmxhZyB3aWxsIGhlbHAgYXZvaWQgbWlzdGFrZXMuIEUuZy4gYm90aCBSSEVM IGFuZCBTVVNFIHdlcmUgbWFudWFsbHkgcGFzc2luZworICAgICAgICAtREVOQUJMRV9KSVQ9T0ZG IGFuZCAtRFVTRV9TWVNURU1fTUFMTE9DPU9OLCBidXQgd2UgbWlzc2VkIC1ERU5BQkxFX0NfTE9P UD1PTiBhbmQKKyAgICAgICAgLURFTkFCTEVfU0FNUExJTkdfUFJPRklMRVI9T0ZGLCBzbyB3b3Vu ZCB1cCBydW5uaW5nIHdpdGggYm90aCBKSVQgYW5kIGNsb29wIGRpc2FibGVkLCBhCisgICAgICAg IGNvbmZpZ3VyYXRpb24gbm90IG90aGVyd2lzZSB1c2VkIG9uIExpbnV4IChhbmQgbm90IHN1cHBv cnRlZCBieSBHVEsgb3IgV1BFIHBvcnRzKS4gSXQgd2lsbAorICAgICAgICBiZSBlYXNpZXIgdG8g bm90IG1lc3MgdXAgaWYgd2Ugb25seSBoYXZlIHRvIHBhc3Mgb25lIHNwZWNpYWwgYnVpbGQgb3B0 aW9uLiBUaGlzIHdpbGwgYWxzbworICAgICAgICBhbGxvdyB1cyB0byBzdG9wIHBhdGNoaW5nIFBh Z2VCbG9jay5oIGRvd25zdHJlYW0sIGJlY2F1c2UgSSBkb24ndCBsaWtlIGRvd25zdHJlYW0gcGF0 Y2hlcworICAgICAgICB0aGF0IHdlIGhhdmUgdG8ga2VlcCBmb3JldmVyLgorCisgICAgICAgICog U291cmNlL2NtYWtlL1dlYktpdEZlYXR1cmVzLmNtYWtlOgorCiAyMDIwLTEwLTMwICBSeW9zdWtl IE5pd2EgIDxybml3YUB3ZWJraXQub3JnPgogCiAgICAgICAgIEFkZCBJbnRyb2R1Y3Rpb24gdG8g V2ViS2l0Cg==