209149 2020-03-16 14:11:50 -0700 Crash under WebCookieCache::clearForHost() 2020-03-16 17:04:04 -0700 1 1 1 Unclassified WebKit WebKit2 WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 cdumez cdumez achristensen beidson commit-queue darin ggaren koivisto webkit-bug-importer oldest_to_newest 1630455 0 cdumez 2020-03-16 14:11:50 -0700 Crash under WebCookieCache::clearForHost(): Thread[0] EXC_BAD_ACCESS (SIGSEGV) (KERN_INVALID_ADDRESS at 0xffffffffffffffff) [ 0] 0x00007fff45ec6c2a WebKit`WebKit::WebCookieCache::clearForHost(WTF::String const&) [inlined] WTF::StringImpl::ref() at StringImpl.h:1098:16 0x00007fff45ec6c1f: movq %rax, %r15 0x00007fff45ec6c22: movq (%r14), %rbx 0x00007fff45ec6c25: testq %rbx, %rbx 0x00007fff45ec6c28: je 0x525c2d ; <+143> [inlined] WTF::VectorBufferBase<WTF::String, WTF::FastMalloc>::VectorBufferBase() at Vector.h:383 -> 0x00007fff45ec6c2a: addl $0x2, (%rbx) 0x00007fff45ec6c2d: xorps %xmm0, %xmm0 0x00007fff45ec6c30: movaps %xmm0, -0x50(%rbp) 0x00007fff45ec6c34: movl $0x1, -0x48(%rbp) 0x00007fff45ec6c3b: movl $0x8, %edi [ 0] 0x00007fff45ec6c2a WebKit`WebKit::WebCookieCache::clearForHost(WTF::String const&) [inlined] void WTF::refIfNotNull<WTF::StringImpl>(WTF::StringImpl*) + 5 at RefPtr.h:38 [ 0] 0x00007fff45ec6c25 WebKit`WebKit::WebCookieCache::clearForHost(WTF::String const&) [inlined] WTF::RefPtr<WTF::StringImpl, WTF::DumbPtrTraits<WTF::StringImpl> >::RefPtr(WTF::RefPtr<WTF::StringImpl, WTF::DumbPtrTraits<WTF::StringImpl> > const&) + 3 at RefPtr.h:59 [ 0] 0x00007fff45ec6c22 WebKit`WebKit::WebCookieCache::clearForHost(WTF::String const&) [inlined] WTF::RefPtr<WTF::StringImpl, WTF::DumbPtrTraits<WTF::StringImpl> >::RefPtr(WTF::RefPtr<WTF::StringImpl, WTF::DumbPtrTraits<WTF::StringImpl> > const&) at RefPtr.h:59 [ 0] 0x00007fff45ec6c22 WebKit`WebKit::WebCookieCache::clearForHost(WTF::String const&) [inlined] WTF::String::String(WTF::String const&) at WTFString.h:132 [ 0] 0x00007fff45ec6c22 WebKit`WebKit::WebCookieCache::clearForHost(WTF::String const&) [inlined] WTF::String::String(WTF::String const&) at WTFString.h:132 [ 0] 0x00007fff45ec6c22 WebKit`WebKit::WebCookieCache::clearForHost(WTF::String const&) + 132 at WebCookieCache.cpp:101 [ 1] 0x00007fff45ec7614 WebKit`WebKit::WebCookieJar::cookies(WebCore::Document&, WTF::URL const&) const [inlined] WebKit::WebCookieCache::pruneCacheIfNecessary() + 63 at WebCookieCache.cpp:113:9 [ 1] 0x00007fff45ec75d5 WebKit`WebKit::WebCookieJar::cookies(WebCore::Document&, WTF::URL const&) const [inlined] WebKit::WebCookieCache::cookiesForDOM(WTF::URL const&, WebCore::SameSiteInfo const&, WTF::URL const&, WTF::ObjectIdentifier<WebCore::FrameIdentifierType>, WTF::ObjectIdentifier<WebCore::PageIdentifierType>, WebCore::IncludeSecureCookies) + 626 at WebCookieCache.cpp:55 [ 1] 0x00007fff45ec7363 WebKit`WebKit::WebCookieJar::cookies(WebCore::Document&, WTF::URL const&) const + 1133 at WebCookieJar.cpp:127 [ 2] 0x00007fff447799d6 WebCore`WebCore::Document::cookie() + 438 at Document.cpp:4997:49 1630456 1 cdumez 2020-03-16 14:12:06 -0700 <rdar://problem/60453086> 1630461 2 393681 cdumez 2020-03-16 14:16:01 -0700 Created attachment 393681 Patch 1630467 3 393681 achristensen 2020-03-16 14:41:30 -0700 Comment on attachment 393681 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=393681&action=review > Tools/TestWebKitAPI/Tests/WebKitCocoa/CookiePrivateBrowsing.mm:138 > + for (int i = 0; i < 100; i++) { unsigned 1630473 4 393684 cdumez 2020-03-16 14:45:16 -0700 Created attachment 393684 Patch 1630484 5 393684 commit-queue 2020-03-16 15:04:07 -0700 Comment on attachment 393684 Patch Clearing flags on attachment: 393684 Committed r258521: <https://trac.webkit.org/changeset/258521> 1630485 6 commit-queue 2020-03-16 15:04:09 -0700 All reviewed patches have been landed. Closing bug. 1630496 7 393684 darin 2020-03-16 15:29:18 -0700 Comment on attachment 393684 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=393684&action=review > Source/WebKit/WebProcess/WebPage/WebCookieCache.cpp:123 > + String hostToRemove = *m_hostsWithInMemoryStorage.random(); > + clearForHost(hostToRemove); To me this seems like a workaround. The fix would be in the clearForHost function. Generally speaking functions that take references or pointers or const references — including const String& — have no right to assume the reference is safe to re-use after they make state changes. One kind of fix is to change the function argument to String rather than const String&. I am interested in our programming discipline to avoid such things, going beyond any one bug fix. 1630506 8 393684 cdumez 2020-03-16 15:47:59 -0700 Comment on attachment 393684 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=393684&action=review >> Source/WebKit/WebProcess/WebPage/WebCookieCache.cpp:123 >> + clearForHost(hostToRemove); > > To me this seems like a workaround. The fix would be in the clearForHost function. Generally speaking functions that take references or pointers or const references — including const String& — have no right to assume the reference is safe to re-use after they make state changes. > > One kind of fix is to change the function argument to String rather than const String&. > > I am interested in our programming discipline to avoid such things, going beyond any one bug fix. I considered several fixes but this is the one I liked best in the end. You are right that I could have simply passed in a 'String' instead of a 'const String&' but this seems to go against our usual coding practices where we ask developers to pass by reference to const as much as possible to avoid refcounting churn. I chose not to make the fix in clearForHost() because clearForHost() has no way to know that the host it is being provided is part of the HashSet it is about to modify. As a matter of fact, in the common case (not the pruning case) the String does not come from the HashSet. I see your point though that it would be safer for clearForHost() to not expect its parameters to be safe to reuse after they make any state changes. Either way, you could imagine cases where it is not super obvious. For e.g.: 1. I get a string from set of Object A and call a method on Object B passing the string as parameter 2. Object B does some modification of the set of object A (via a method call for e.g.) -> The String is no longer valid, even though Object A did not modify its own state. Passing a String instead of a const String& makes it less error-prone for sure but then we do ref-counting churn that will not be necessary in a lot of cases. In the past, we have tried avoiding that. 1630507 9 393684 darin 2020-03-16 15:51:09 -0700 Comment on attachment 393684 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=393684&action=review >>> Source/WebKit/WebProcess/WebPage/WebCookieCache.cpp:123 >>> + clearForHost(hostToRemove); >> >> To me this seems like a workaround. The fix would be in the clearForHost function. Generally speaking functions that take references or pointers or const references — including const String& — have no right to assume the reference is safe to re-use after they make state changes. >> >> One kind of fix is to change the function argument to String rather than const String&. >> >> I am interested in our programming discipline to avoid such things, going beyond any one bug fix. > > I considered several fixes but this is the one I liked best in the end. You are right that I could have simply passed in a 'String' instead of a 'const String&' but this seems to go against our usual coding practices where we ask developers to pass by reference to const as much as possible to avoid refcounting churn. I chose not to make the fix in clearForHost() because clearForHost() has no way to know that the host it is being provided is part of the HashSet it is about to modify. As a matter of fact, in the common case (not the pruning case) the String does not come from the HashSet. > > I see your point though that it would be safer for clearForHost() to not expect its parameters to be safe to reuse after they make any state changes. Either way, you could imagine cases where it is not super obvious. For e.g.: > 1. I get a string from set of Object A and call a method on Object B passing the string as parameter > 2. Object B does some modification of the set of object A (via a method call for e.g.) > -> The String is no longer valid, even though Object A did not modify its own state. > > Passing a String instead of a const String& makes it less error-prone for sure but then we do ref-counting churn that will not be necessary in a lot of cases. In the past, we have tried avoiding that. Seems great for fixing this one bug. Not sure it’s scalable. To be clear, when I said "make state changes" I did not mean an object modifying its own state, I meant generally doing any nontrivial operation. 1630508 10 cdumez 2020-03-16 15:59:50 -0700 Reopening for alternative fix. 1630509 11 393698 cdumez 2020-03-16 16:00:13 -0700 Created attachment 393698 Alternative fix 1630511 12 393698 cdumez 2020-03-16 16:00:40 -0700 Comment on attachment 393698 Alternative fix Do you like this version of the fix better? 1630521 13 393698 darin 2020-03-16 16:09:33 -0700 Comment on attachment 393698 Alternative fix I do like that better 1630525 14 achristensen 2020-03-16 16:14:45 -0700 If we use link time optimization and use String everywhere we currently use const String&, would it remove all the unnecessary ref/deref pairs? 1630558 15 393698 commit-queue 2020-03-16 17:04:02 -0700 Comment on attachment 393698 Alternative fix Clearing flags on attachment: 393698 Committed r258530: <https://trac.webkit.org/changeset/258530> 1630560 16 commit-queue 2020-03-16 17:04:04 -0700 All reviewed patches have been landed. Closing bug. 393681 2020-03-16 14:16:01 -0700 2020-03-16 14:45:14 -0700 Patch bug-209149-20200316141601.patch text/plain 4299 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4NDk0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDY4ZjcwMjQ1MGQ1ODNmMzdh OTZlYTlhMmEwYjdkNTAxNDRmMTRlNjQuLjBkNWQxODM2ZWJlZTY4YzYyZDY0YjhkNjJmZGQzNzlm NjQ3MTFjZTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMjAtMDMtMTYgIENocmlzIER1 bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KKworICAgICAgICBDcmFzaCB1bmRlciBXZWJDb29raWVD YWNoZTo6Y2xlYXJGb3JIb3N0KCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTIwOTE0OQorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNjA0NTMwODY+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTWFrZSBzdXJl IFdlYkNvb2tpZUNhY2hlOjpwcnVuZUNhY2hlSWZOZWNlc3NhcnkoKSBrZWVwcyBhbGl2ZSB0aGUg aG9zdCBTdHJpbmcgaXQgaXMgcGFzc2luZworICAgICAgICB0byBXZWJDb29raWVDYWNoZTo6Y2xl YXJGb3JIb3N0KCkuIFByZXZpb3VzbHksIGl0IHdhcyBtZXJlbHkgZGVmZXJlbmNpbmcgYSBIYXNo U2V0IGl0ZXJhdG9yCisgICAgICAgIGFuZCBwYXNzaW5nIHRoYXQgdG8gY2xlYXJGb3JIb3N0KCku IEhvd2V2ZXIsIGNsZWFyRm9ySG9zdCgpIHdvdWxkIHRoZW4gZHJvcCB0aGUgU3RyaW5nIGZyb20K KyAgICAgICAgdGhlIEhhc2hTZXQgYW5kIHRoZSBob3N0IHdvdWxkIG5vIGxvbmdlciBiZSB2YWxp ZC4KKworICAgICAgICBDaGFuZ2UgY292ZXJlZCBieSBuZXcgQVBJIHRlc3QuCisKKyAgICAgICAg KiBXZWJQcm9jZXNzL1dlYlBhZ2UvV2ViQ29va2llQ2FjaGUuY3BwOgorICAgICAgICAoV2ViS2l0 OjpXZWJDb29raWVDYWNoZTo6cHJ1bmVDYWNoZUlmTmVjZXNzYXJ5KToKKwogMjAyMC0wMy0xNiAg eW91ZW5uIGZhYmxldCAgPHlvdWVubkBhcHBsZS5jb20+CiAKICAgICAgICAgVW5pcXVlIG9yaWdp bnMgc2hvdWxkIG5vdCBiZSBQb3RlbnRpYWxseSBUcnVzdHdvcnRoeQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViQ29va2llQ2FjaGUuY3BwIGIvU291cmNl L1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2ViQ29va2llQ2FjaGUuY3BwCmluZGV4IDdkNDI0 ODk5NTdjZDU4NWU0YTFkMmFjM2E3Njk1MTc5MWVlNzhiNzMuLjA1NDQ2ZGVlNDgxODgxZDljMzM2 YzBhNDljOTQzYzA2MjBjNDQwMTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vz cy9XZWJQYWdlL1dlYkNvb2tpZUNhY2hlLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nl c3MvV2ViUGFnZS9XZWJDb29raWVDYWNoZS5jcHAKQEAgLTExOCw4ICsxMTgsMTAgQEAgdm9pZCBX ZWJDb29raWVDYWNoZTo6cHJ1bmVDYWNoZUlmTmVjZXNzYXJ5KCkKICAgICAvLyBXZSBtYXkgd2Fu dCB0byByYWlzZSB0aGlzIGxpbWl0IGlmIHdlIHN0YXJ0IHVzaW5nIHRoZSBjYWNoZSBmb3IgdGhp cmQtcGFydHkgaWZyYW1lcy4KICAgICBzdGF0aWMgY29uc3QgdW5zaWduZWQgbWF4Q2FjaGVkSG9z dHMgPSA1OwogCi0gICAgd2hpbGUgKG1faG9zdHNXaXRoSW5NZW1vcnlTdG9yYWdlLnNpemUoKSA+ PSBtYXhDYWNoZWRIb3N0cykKLSAgICAgICAgY2xlYXJGb3JIb3N0KCptX2hvc3RzV2l0aEluTWVt b3J5U3RvcmFnZS5yYW5kb20oKSk7CisgICAgd2hpbGUgKG1faG9zdHNXaXRoSW5NZW1vcnlTdG9y YWdlLnNpemUoKSA+PSBtYXhDYWNoZWRIb3N0cykgeworICAgICAgICBTdHJpbmcgaG9zdFRvUmVt b3ZlID0gKm1faG9zdHNXaXRoSW5NZW1vcnlTdG9yYWdlLnJhbmRvbSgpOworICAgICAgICBjbGVh ckZvckhvc3QoaG9zdFRvUmVtb3ZlKTsKKyAgICB9CiB9CiAKICNpZiAhUExBVEZPUk0oQ09DT0Ep CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggNjBm NWE0NTEzNWI0OGM5NzQwZjZkMDRjZjVkYjAwNWY2ODFkZGQ4ZS4uYjdmNmQ5YjVhNzY4MzhmZmE0 NGRmZjE2YzE0OGNmMWJiMDUzMzE5ZiAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBi L1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDIwLTAzLTE2ICBDaHJpcyBEdW1l eiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgQ3Jhc2ggdW5kZXIgV2ViQ29va2llQ2Fj aGU6OmNsZWFyRm9ySG9zdCgpCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0yMDkxNDkKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzYwNDUzMDg2PgorCisg ICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBBUEkgdGVz dCBjb3ZlcmFnZS4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2Ev Q29va2llUHJpdmF0ZUJyb3dzaW5nLm1tOgorICAgICAgICAoVEVTVCk6CisKIDIwMjAtMDMtMTYg IHlvdWVubiBmYWJsZXQgIDx5b3Vlbm5AYXBwbGUuY29tPgogCiAgICAgICAgIFVuaXF1ZSBvcmln aW5zIHNob3VsZCBub3QgYmUgUG90ZW50aWFsbHkgVHJ1c3R3b3J0aHkKZGlmZiAtLWdpdCBhL1Rv b2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2EvQ29va2llUHJpdmF0ZUJyb3dzaW5n Lm1tIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9Db29raWVQcml2YXRl QnJvd3NpbmcubW0KaW5kZXggMTg4OWE5ZjE0ZDZhODIyY2VhZDA3N2NiYmY0MjMzZDkwNDQ1Nzk4 YS4uMzA4OTllZWY5ZWZiODU4MzlmYWViMWFjODdmODY1ZGZiY2YyMTRjNiAxMDA2NDQKLS0tIGEv VG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9Db29raWVQcml2YXRlQnJvd3Np bmcubW0KKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XZWJLaXRDb2NvYS9Db29raWVQ cml2YXRlQnJvd3NpbmcubW0KQEAgLTMzLDYgKzMzLDcgQEAKICNpbXBvcnQgPFdlYktpdC9XS1dl YlZpZXcuaD4KICNpbXBvcnQgPFdlYktpdC9XS1dlYlZpZXdDb25maWd1cmF0aW9uLmg+CiAjaW1w b3J0IDx3dGYvUmV0YWluUHRyLmg+CisjaW1wb3J0IDx3dGYvdGV4dC9TdHJpbmdDb25jYXRlbmF0 ZU51bWJlcnMuaD4KICNpbXBvcnQgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgogCiBzdGF0aWMgYm9v bCByZWNlaXZlZEFsZXJ0OwpAQCAtMTI4LDMgKzEyOSwyMiBAQCBURVNUKFdlYktpdCwgQ29va2ll Q2FjaGVTeW5jQWNyb3NzUHJvY2VzcykKICAgICB9IHdoaWxlIChjb29raWVTdHJpbmcgIT0gIiIg JiYgdGltZW91dCA8IDUwKTsKICAgICBFWFBFQ1RfV0tfU1RSRVEoImZvbz1iYXIiLCBjb29raWVT dHJpbmcpOwogfQorCitURVNUKFdlYktpdCwgQ29va2llQ2FjaGVQcnVuaW5nKQoreworICAgIGF1 dG8gY29uZmlndXJhdGlvbiA9IGFkb3B0TlMoW1tXS1dlYlZpZXdDb25maWd1cmF0aW9uIGFsbG9j XSBpbml0XSk7CisgICAgYXV0byB2aWV3ID0gYWRvcHROUyhbW1dLV2ViVmlldyBhbGxvY10gaW5p dFdpdGhGcmFtZTpOU01ha2VSZWN0KDAsIDAsIDgwMCwgNjAwKSBjb25maWd1cmF0aW9uOmNvbmZp Z3VyYXRpb24uZ2V0KCldKTsKKworICAgIGZvciAoaW50IGkgPSAwOyBpIDwgMTAwOyBpKyspIHsK KyAgICAgICAgW3ZpZXcgc3luY2hyb25vdXNseUxvYWRIVE1MU3RyaW5nOkAiZm9vIiBiYXNlVVJM OltOU1VSTCBVUkxXaXRoU3RyaW5nOm1ha2VTdHJpbmcoImh0dHA6Ly9mb28iLCBpLCAiLmV4YW1w bGUuY29tLyIpXV07CisKKyAgICAgICAgX19ibG9jayBib29sIGRvbmVFdmFsdWF0aW5nSmF2YVNj cmlwdCA9IGZhbHNlOworICAgICAgICBbdmlldyBldmFsdWF0ZUphdmFTY3JpcHQ6QCJkb2N1bWVu dC5jb29raWU7IiBjb21wbGV0aW9uSGFuZGxlcjpeKGlkIF9OdWxsYWJsZSBjb29raWUsIE5TRXJy b3IgKiBfTnVsbGFibGUgZXJyb3IpIHsKKyAgICAgICAgICAgIEVYUEVDVF9OVUxMKGVycm9yKTsK KyAgICAgICAgICAgIEVYUEVDVF9UUlVFKFtjb29raWUgaXNLaW5kT2ZDbGFzczpbTlNTdHJpbmcg Y2xhc3NdXSk7CisgICAgICAgICAgICBFWFBFQ1RfV0tfU1RSRVEoIiIsIChOU1N0cmluZyAqKWNv b2tpZSk7CisgICAgICAgICAgICBkb25lRXZhbHVhdGluZ0phdmFTY3JpcHQgPSB0cnVlOworICAg ICAgICB9XTsKKyAgICAgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6cnVuKCZkb25lRXZhbHVhdGlu Z0phdmFTY3JpcHQpOworICAgIH0KK30K 393684 2020-03-16 14:45:16 -0700 2020-03-16 16:00:23 -0700 Patch bug-209149-20200316144515.patch text/plain 4308 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4NDk0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDY4ZjcwMjQ1MGQ1ODNmMzdh OTZlYTlhMmEwYjdkNTAxNDRmMTRlNjQuLmE3NzUyMzc3YWRmNGJlNTc3Y2RkNjgzODAzMDZmNzIz ZDQxMjI0MDUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjEgQEAKKzIwMjAtMDMtMTYgIENocmlzIER1 bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KKworICAgICAgICBDcmFzaCB1bmRlciBXZWJDb29raWVD YWNoZTo6Y2xlYXJGb3JIb3N0KCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTIwOTE0OQorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNjA0NTMwODY+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgQWxleCBDaHJpc3RlbnNlbi4KKworICAgICAgICBNYWtlIHN1 cmUgV2ViQ29va2llQ2FjaGU6OnBydW5lQ2FjaGVJZk5lY2Vzc2FyeSgpIGtlZXBzIGFsaXZlIHRo ZSBob3N0IFN0cmluZyBpdCBpcyBwYXNzaW5nCisgICAgICAgIHRvIFdlYkNvb2tpZUNhY2hlOjpj bGVhckZvckhvc3QoKS4gUHJldmlvdXNseSwgaXQgd2FzIG1lcmVseSBkZWZlcmVuY2luZyBhIEhh c2hTZXQgaXRlcmF0b3IKKyAgICAgICAgYW5kIHBhc3NpbmcgdGhhdCB0byBjbGVhckZvckhvc3Qo KS4gSG93ZXZlciwgY2xlYXJGb3JIb3N0KCkgd291bGQgdGhlbiBkcm9wIHRoZSBTdHJpbmcgZnJv bQorICAgICAgICB0aGUgSGFzaFNldCBhbmQgdGhlIGhvc3Qgd291bGQgbm8gbG9uZ2VyIGJlIHZh bGlkLgorCisgICAgICAgIENoYW5nZSBjb3ZlcmVkIGJ5IG5ldyBBUEkgdGVzdC4KKworICAgICAg ICAqIFdlYlByb2Nlc3MvV2ViUGFnZS9XZWJDb29raWVDYWNoZS5jcHA6CisgICAgICAgIChXZWJL aXQ6OldlYkNvb2tpZUNhY2hlOjpwcnVuZUNhY2hlSWZOZWNlc3NhcnkpOgorCiAyMDIwLTAzLTE2 ICB5b3Vlbm4gZmFibGV0ICA8eW91ZW5uQGFwcGxlLmNvbT4KIAogICAgICAgICBVbmlxdWUgb3Jp Z2lucyBzaG91bGQgbm90IGJlIFBvdGVudGlhbGx5IFRydXN0d29ydGh5CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJDb29raWVDYWNoZS5jcHAgYi9Tb3Vy Y2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJDb29raWVDYWNoZS5jcHAKaW5kZXggN2Q0 MjQ4OTk1N2NkNTg1ZTRhMWQyYWMzYTc2OTUxNzkxZWU3OGI3My4uMDU0NDZkZWU0ODE4ODFkOWMz MzZjMGE0OWM5NDNjMDYyMGM0NDAxOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9XZWJQcm9j ZXNzL1dlYlBhZ2UvV2ViQ29va2llQ2FjaGUuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJv Y2Vzcy9XZWJQYWdlL1dlYkNvb2tpZUNhY2hlLmNwcApAQCAtMTE4LDggKzExOCwxMCBAQCB2b2lk IFdlYkNvb2tpZUNhY2hlOjpwcnVuZUNhY2hlSWZOZWNlc3NhcnkoKQogICAgIC8vIFdlIG1heSB3 YW50IHRvIHJhaXNlIHRoaXMgbGltaXQgaWYgd2Ugc3RhcnQgdXNpbmcgdGhlIGNhY2hlIGZvciB0 aGlyZC1wYXJ0eSBpZnJhbWVzLgogICAgIHN0YXRpYyBjb25zdCB1bnNpZ25lZCBtYXhDYWNoZWRI b3N0cyA9IDU7CiAKLSAgICB3aGlsZSAobV9ob3N0c1dpdGhJbk1lbW9yeVN0b3JhZ2Uuc2l6ZSgp ID49IG1heENhY2hlZEhvc3RzKQotICAgICAgICBjbGVhckZvckhvc3QoKm1faG9zdHNXaXRoSW5N ZW1vcnlTdG9yYWdlLnJhbmRvbSgpKTsKKyAgICB3aGlsZSAobV9ob3N0c1dpdGhJbk1lbW9yeVN0 b3JhZ2Uuc2l6ZSgpID49IG1heENhY2hlZEhvc3RzKSB7CisgICAgICAgIFN0cmluZyBob3N0VG9S ZW1vdmUgPSAqbV9ob3N0c1dpdGhJbk1lbW9yeVN0b3JhZ2UucmFuZG9tKCk7CisgICAgICAgIGNs ZWFyRm9ySG9zdChob3N0VG9SZW1vdmUpOworICAgIH0KIH0KIAogI2lmICFQTEFURk9STShDT0NP QSkKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxvZwppbmRleCA2 MGY1YTQ1MTM1YjQ4Yzk3NDBmNmQwNGNmNWRiMDA1ZjY4MWRkZDhlLi5hODZjNjMxOWJiMmMwNjEy NTg2MjFlNDgwNmZjNDA4ZmNmYjg1YTkwIDEwMDY0NAotLS0gYS9Ub29scy9DaGFuZ2VMb2cKKysr IGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMjAtMDMtMTYgIENocmlzIER1 bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KKworICAgICAgICBDcmFzaCB1bmRlciBXZWJDb29raWVD YWNoZTo6Y2xlYXJGb3JIb3N0KCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTIwOTE0OQorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNjA0NTMwODY+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgQWxleCBDaHJpc3RlbnNlbi4KKworICAgICAgICBBZGQgQVBJ IHRlc3QgY292ZXJhZ2UuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENv Y29hL0Nvb2tpZVByaXZhdGVCcm93c2luZy5tbToKKyAgICAgICAgKFRFU1QpOgorCiAyMDIwLTAz LTE2ICB5b3Vlbm4gZmFibGV0ICA8eW91ZW5uQGFwcGxlLmNvbT4KIAogICAgICAgICBVbmlxdWUg b3JpZ2lucyBzaG91bGQgbm90IGJlIFBvdGVudGlhbGx5IFRydXN0d29ydGh5CmRpZmYgLS1naXQg YS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dlYktpdENvY29hL0Nvb2tpZVByaXZhdGVCcm93 c2luZy5tbSBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2EvQ29va2llUHJp dmF0ZUJyb3dzaW5nLm1tCmluZGV4IDE4ODlhOWYxNGQ2YTgyMmNlYWQwNzdjYmJmNDIzM2Q5MDQ0 NTc5OGEuLjQ2NmMwZjVjMmE1NDJiODM1YTEyOThhODEwYzVmZTE1M2MzYzY1ZDUgMTAwNjQ0Ci0t LSBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2EvQ29va2llUHJpdmF0ZUJy b3dzaW5nLm1tCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV2ViS2l0Q29jb2EvQ29v a2llUHJpdmF0ZUJyb3dzaW5nLm1tCkBAIC0zMyw2ICszMyw3IEBACiAjaW1wb3J0IDxXZWJLaXQv V0tXZWJWaWV3Lmg+CiAjaW1wb3J0IDxXZWJLaXQvV0tXZWJWaWV3Q29uZmlndXJhdGlvbi5oPgog I2ltcG9ydCA8d3RmL1JldGFpblB0ci5oPgorI2ltcG9ydCA8d3RmL3RleHQvU3RyaW5nQ29uY2F0 ZW5hdGVOdW1iZXJzLmg+CiAjaW1wb3J0IDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KIAogc3RhdGlj IGJvb2wgcmVjZWl2ZWRBbGVydDsKQEAgLTEyOCwzICsxMjksMjIgQEAgVEVTVChXZWJLaXQsIENv b2tpZUNhY2hlU3luY0Fjcm9zc1Byb2Nlc3MpCiAgICAgfSB3aGlsZSAoY29va2llU3RyaW5nICE9 ICIiICYmIHRpbWVvdXQgPCA1MCk7CiAgICAgRVhQRUNUX1dLX1NUUkVRKCJmb289YmFyIiwgY29v a2llU3RyaW5nKTsKIH0KKworVEVTVChXZWJLaXQsIENvb2tpZUNhY2hlUHJ1bmluZykKK3sKKyAg ICBhdXRvIGNvbmZpZ3VyYXRpb24gPSBhZG9wdE5TKFtbV0tXZWJWaWV3Q29uZmlndXJhdGlvbiBh bGxvY10gaW5pdF0pOworICAgIGF1dG8gdmlldyA9IGFkb3B0TlMoW1tXS1dlYlZpZXcgYWxsb2Nd IGluaXRXaXRoRnJhbWU6TlNNYWtlUmVjdCgwLCAwLCA4MDAsIDYwMCkgY29uZmlndXJhdGlvbjpj b25maWd1cmF0aW9uLmdldCgpXSk7CisKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgMTAw OyArK2kpIHsKKyAgICAgICAgW3ZpZXcgc3luY2hyb25vdXNseUxvYWRIVE1MU3RyaW5nOkAiZm9v IiBiYXNlVVJMOltOU1VSTCBVUkxXaXRoU3RyaW5nOm1ha2VTdHJpbmcoImh0dHA6Ly9mb28iLCBp LCAiLmV4YW1wbGUuY29tLyIpXV07CisKKyAgICAgICAgX19ibG9jayBib29sIGRvbmVFdmFsdWF0 aW5nSmF2YVNjcmlwdCA9IGZhbHNlOworICAgICAgICBbdmlldyBldmFsdWF0ZUphdmFTY3JpcHQ6 QCJkb2N1bWVudC5jb29raWU7IiBjb21wbGV0aW9uSGFuZGxlcjpeKGlkIF9OdWxsYWJsZSBjb29r aWUsIE5TRXJyb3IgKiBfTnVsbGFibGUgZXJyb3IpIHsKKyAgICAgICAgICAgIEVYUEVDVF9OVUxM KGVycm9yKTsKKyAgICAgICAgICAgIEVYUEVDVF9UUlVFKFtjb29raWUgaXNLaW5kT2ZDbGFzczpb TlNTdHJpbmcgY2xhc3NdXSk7CisgICAgICAgICAgICBFWFBFQ1RfV0tfU1RSRVEoIiIsIChOU1N0 cmluZyAqKWNvb2tpZSk7CisgICAgICAgICAgICBkb25lRXZhbHVhdGluZ0phdmFTY3JpcHQgPSB0 cnVlOworICAgICAgICB9XTsKKyAgICAgICAgVGVzdFdlYktpdEFQSTo6VXRpbDo6cnVuKCZkb25l RXZhbHVhdGluZ0phdmFTY3JpcHQpOworICAgIH0KK30K 393698 2020-03-16 16:00:13 -0700 2020-03-16 17:04:02 -0700 Alternative fix bug-209149-20200316160013.patch text/plain 2685 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjU4NTIyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDA4NDM4YmMwNTFhZDcyMDRl ZmEwZDEzOTg4OTgyNTcxM2UwNGNjZTYuLjIzODY5ZTNlNDI0YzlmODAyY2JkZGMzNTdjZDQ1Zjdl NTNiOTljN2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMjAtMDMtMTYgIENocmlzIER1 bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KKworICAgICAgICBDcmFzaCB1bmRlciBXZWJDb29raWVD YWNoZTo6Y2xlYXJGb3JIb3N0KCkKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTIwOTE0OQorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNjA0NTMwODY+CisK KyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWx0ZXJuYXRp dmUgZml4IGZvciBCdWcgMjA5MTQ5IGJhc2VkIG9uIGNvbW1lbnRzIGZyb20gRGFyaW4uCisKKyAg ICAgICAgKiBXZWJQcm9jZXNzL1dlYlBhZ2UvV2ViQ29va2llQ2FjaGUuY3BwOgorICAgICAgICAo V2ViS2l0OjpXZWJDb29raWVDYWNoZTo6Y2xlYXJGb3JIb3N0KToKKyAgICAgICAgKFdlYktpdDo6 V2ViQ29va2llQ2FjaGU6OnBydW5lQ2FjaGVJZk5lY2Vzc2FyeSk6CisKIDIwMjAtMDMtMTYgIENo cmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KIAogICAgICAgICBDcmFzaCB1bmRlciBXZWJD b29raWVDYWNoZTo6Y2xlYXJGb3JIb3N0KCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvV2Vi UHJvY2Vzcy9XZWJQYWdlL1dlYkNvb2tpZUNhY2hlLmNwcCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJv Y2Vzcy9XZWJQYWdlL1dlYkNvb2tpZUNhY2hlLmNwcAppbmRleCAwNTQ0NmRlZTQ4MTg4MWQ5YzMz NmMwYTQ5Yzk0M2MwNjIwYzQ0MDE4Li43ZWU2NGQ3ZTY0ZDU5NTBkNzhlM2I0MGI5YzY5NTBhZmRm NjBhMjdmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUGFnZS9XZWJD b29raWVDYWNoZS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlBhZ2UvV2Vi Q29va2llQ2FjaGUuY3BwCkBAIC0xMDIsMTQgKzEwMiwxMyBAQCB2b2lkIFdlYkNvb2tpZUNhY2hl OjpjbGVhcigpCiAKIHZvaWQgV2ViQ29va2llQ2FjaGU6OmNsZWFyRm9ySG9zdChjb25zdCBTdHJp bmcmIGhvc3QpCiB7Ci0gICAgYXV0byBpdCA9IG1faG9zdHNXaXRoSW5NZW1vcnlTdG9yYWdlLmZp bmQoaG9zdCk7Ci0gICAgaWYgKGl0ID09IG1faG9zdHNXaXRoSW5NZW1vcnlTdG9yYWdlLmVuZCgp KQorICAgIFN0cmluZyByZW1vdmVkSG9zdCA9IG1faG9zdHNXaXRoSW5NZW1vcnlTdG9yYWdlLnRh a2UoaG9zdCk7CisgICAgaWYgKHJlbW92ZWRIb3N0LmlzTnVsbCgpKQogICAgICAgICByZXR1cm47 CiAKLSAgICBtX2hvc3RzV2l0aEluTWVtb3J5U3RvcmFnZS5yZW1vdmUoaXQpOwotICAgIGluTWVt b3J5U3RvcmFnZVNlc3Npb24oKS5kZWxldGVDb29raWVzRm9ySG9zdG5hbWVzKFZlY3RvcjxTdHJp bmc+IHsgaG9zdCB9KTsKKyAgICBpbk1lbW9yeVN0b3JhZ2VTZXNzaW9uKCkuZGVsZXRlQ29va2ll c0Zvckhvc3RuYW1lcyhWZWN0b3I8U3RyaW5nPiB7IHJlbW92ZWRIb3N0IH0pOwogI2lmIEhBVkUo Q09PS0lFX0NIQU5HRV9MSVNURU5FUl9BUEkpCi0gICAgV2ViUHJvY2Vzczo6c2luZ2xldG9uKCku ZW5zdXJlTmV0d29ya1Byb2Nlc3NDb25uZWN0aW9uKCkuY29ubmVjdGlvbigpLnNlbmQoTWVzc2Fn ZXM6Ok5ldHdvcmtDb25uZWN0aW9uVG9XZWJQcm9jZXNzOjpVbnN1YnNjcmliZUZyb21Db29raWVD aGFuZ2VOb3RpZmljYXRpb25zKEhhc2hTZXQ8U3RyaW5nPiB7IGhvc3QgfSksIDApOworICAgIFdl YlByb2Nlc3M6OnNpbmdsZXRvbigpLmVuc3VyZU5ldHdvcmtQcm9jZXNzQ29ubmVjdGlvbigpLmNv bm5lY3Rpb24oKS5zZW5kKE1lc3NhZ2VzOjpOZXR3b3JrQ29ubmVjdGlvblRvV2ViUHJvY2Vzczo6 VW5zdWJzY3JpYmVGcm9tQ29va2llQ2hhbmdlTm90aWZpY2F0aW9ucyhIYXNoU2V0PFN0cmluZz4g eyByZW1vdmVkSG9zdCB9KSwgMCk7CiAjZW5kaWYKIH0KIApAQCAtMTE4LDEwICsxMTcsOCBAQCB2 b2lkIFdlYkNvb2tpZUNhY2hlOjpwcnVuZUNhY2hlSWZOZWNlc3NhcnkoKQogICAgIC8vIFdlIG1h eSB3YW50IHRvIHJhaXNlIHRoaXMgbGltaXQgaWYgd2Ugc3RhcnQgdXNpbmcgdGhlIGNhY2hlIGZv ciB0aGlyZC1wYXJ0eSBpZnJhbWVzLgogICAgIHN0YXRpYyBjb25zdCB1bnNpZ25lZCBtYXhDYWNo ZWRIb3N0cyA9IDU7CiAKLSAgICB3aGlsZSAobV9ob3N0c1dpdGhJbk1lbW9yeVN0b3JhZ2Uuc2l6 ZSgpID49IG1heENhY2hlZEhvc3RzKSB7Ci0gICAgICAgIFN0cmluZyBob3N0VG9SZW1vdmUgPSAq bV9ob3N0c1dpdGhJbk1lbW9yeVN0b3JhZ2UucmFuZG9tKCk7Ci0gICAgICAgIGNsZWFyRm9ySG9z dChob3N0VG9SZW1vdmUpOwotICAgIH0KKyAgICB3aGlsZSAobV9ob3N0c1dpdGhJbk1lbW9yeVN0 b3JhZ2Uuc2l6ZSgpID49IG1heENhY2hlZEhvc3RzKQorICAgICAgICBjbGVhckZvckhvc3QoKm1f aG9zdHNXaXRoSW5NZW1vcnlTdG9yYWdlLnJhbmRvbSgpKTsKIH0KIAogI2lmICFQTEFURk9STShD T0NPQSkK