173789 2017-06-23 13:52:26 -0700 Add assertions to RefCounted and DeferrableRefCounted to catch thread-safety issues 2017-06-25 16:15:17 -0700 1 1 1 Unclassified WebKit Web Template Framework WebKit Nightly Build Unspecified Unspecified RESOLVED WONTFIX https://bugs.webkit.org/show_bug.cgi?id=31639 https://bugs.webkit.org/show_bug.cgi?id=127004 P2 Normal --- 1 ddkilzer ddkilzer bfulgham cdumez darin oldest_to_newest 1322426 0 ddkilzer 2017-06-23 13:52:26 -0700 While reading the committed fix for Bug 173753 (<https://trac.webkit.org/r218734>), I wondered if there was a way to catch thread-unsafe use of RefCounted objects in Debug builds. After talking to Chris Dumez, he pointed me to the fix for Bug 173693 (<https://trac.webkit.org/r218705>), where a thread ID debug assertion was added to WebKit::GenericCallback. So this bug represents adding a similar debug assertion to RefCounted and DeferrableRefCounted to check for places where RefCountedBase::m_refCount and DeferrableRefCountedBase::m_refCount are being accessed on a different thread than the thread where the object was created. This also catches situations where ref() and deref() are called on different threads. 1322557 1 ap 2017-06-23 21:13:10 -0700 > check for places where RefCountedBase::m_refCount and DeferrableRefCountedBase::m_refCount are being accessed on a This is legal with locking. 1322601 2 ddkilzer 2017-06-24 03:27:01 -0700 (In reply to Alexey Proskuryakov from comment #1) > > check for places where RefCountedBase::m_refCount and DeferrableRefCountedBase::m_refCount are being accessed on a > > This is legal with locking. Do you know of any place where we actually lock like this? Seems like locking would be a fairly heavy(?) compared to using atomic operations for m_refCount in ThreadSafeRefCounted. The other place this is legal is when doing a WTFMove() of an object from one thread to another, such as in a lambda. I guess if I can't get this to work I should focus on making it easy to build and run tests with ThreadSanitizer instead, which would catch the same issues, but work in the locking case and maybe(?) the WTFMove() case. 1322653 3 313792 ddkilzer 2017-06-24 18:26:07 -0700 Created attachment 313792 Attempt #1 (doesn't work) 1322654 4 313792 ddkilzer 2017-06-24 18:31:42 -0700 Comment on attachment 313792 Attempt #1 (doesn't work) View in context: https://bugs.webkit.org/attachment.cgi?id=313792&action=review > Source/WTF/wtf/RefPtr.h:113 > RefPtr copyRef() const & WARN_UNUSED_RETURN { return RefPtr(m_ptr); } > + template<typename V> RefPtr<RefCounted<V>> copyRef() const & WARN_UNUSED_RETURN { > + m_ptr->resetOriginThreadID(); > + return RefPtr<RefCounted<V>>(m_ptr); > + } This specialization doesn't work, but I'm not sure why yet. The patch compiles, but I still get some spurious assertions in Debug builds when running tests like this: ./Tools/Scripts/run-webkit-tests --debug --no-build -1 --no-retry --no-show-results --no-timeout --no-sample compositing/backface-visibility/backface-visibility-image.html I think it's calling the copyRef() on the line above instead of the new method since m_originThreadID doesn't get reset. The assert happens in Source/WebCore/loader/SubresourceLoader.cpp on this line in buffer.copyRef(): ResourceLoader::didReceiveDataOrBuffer(data, length, buffer.copyRef(), encodedDataLength, dataPayloadType); The reason that m_originThreadID is reset is that we have cases where we pass an object from one thread to another, then issues copyRef() (or similar), which then destroys the old object and creates a new one on the current thread. If we don't do this, then we hit false-positive asserts. (Or at least that's the current thinking.) Anyway, I'll look into it more on Monday. 1322698 5 darin 2017-06-25 10:16:46 -0700 (In reply to David Kilzer (:ddkilzer) from comment #0) > So this bug represents adding a similar debug assertion to RefCounted and > DeferrableRefCounted to check for places where RefCountedBase::m_refCount > and DeferrableRefCountedBase::m_refCount are being accessed on a different > thread than the thread where the object was created. This also catches > situations where ref() and deref() are called on different threads. An example of how we do this intentionally is with isolatedCopy. We make a copy on one thread and then transfer it to another, using the appropriate correct locking and using isolatedCopy to guarantee other clients aren’t manipulating the reference count on the same object. To add some kind of assertion like this we will have to come up with a scheme to distinguish intentional correct use from incorrect. The object goes into a “ready to go to another thread” state as far as the programmer is concerned, but RefCounted, Ref, and RefPtr have no idea this is going on. 1322699 6 darin 2017-06-25 10:22:33 -0700 The last attempt at this was in 2011, and the details of how we started on it are in bug 31639, but then there was lots of follow-on to try to make it work. We eventually decided not to pursue it and removed it with bug 127004. 1322735 7 ddkilzer 2017-06-25 14:49:21 -0700 (In reply to Darin Adler from comment #6) > The last attempt at this was in 2011, and the details of how we started on > it are in bug 31639, but then there was lots of follow-on to try to make it > work. We eventually decided not to pursue it and removed it with bug 127004. Okay, thanks for the info. Sounds like investigating ThreadSanitizer would probably be more useful here. 1322741 8 darin 2017-06-25 16:15:17 -0700 Given we had a hard time getting this to work globally last time, one idea would be to add something that is activated only for certain classes, certain code paths, or certain objects and slowly turn it on for more and more use cases. Some day it could be on by default. 313792 2017-06-24 18:26:07 -0700 2017-06-24 18:26:19 -0700 Attempt #1 (doesn't work) bug-173789-20170624182612.patch text/plain 12295 ddkilzer U3VidmVyc2lvbiBSZXZpc2lvbjogMjE4NzUzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGEzZjc1MzE0OWRiZTZlMWRlNGVmMmZh MWQ5Yzc3OGYxNWZmYjYzYzQuLjJlZmI5YTc5OWJjMzBhZGQxNDA2NDc4Y2MxMjkwZDVlMzIxNzkx NGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsNDcgQEAKKzIwMTctMDYtMjQgIERhdmlkIEtpbHplciAgPGRka2ls emVyQGFwcGxlLmNvbT4KKworICAgICAgICBBZGQgYXNzZXJ0aW9ucyB0byBSZWZDb3VudGVkIGFu ZCBEZWZlcnJhYmxlUmVmQ291bnRlZCB0byBjYXRjaCB0aHJlYWQtc2FmZXR5IGlzc3VlcworICAg ICAgICA8aHR0cHM6Ly93ZWJraXQub3JnL2IvMTczNzg5PgorCisgICAgICAgIFJldmlld2VkIGJ5 IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogd3RmL1JlZi5oOgorICAgICAgICAoV1RGOjpS ZWY6OlJlZik6CisgICAgICAgIChXVEY6OlJlZjo6YXNzaWduVG9IYXNoVGFibGVFbXB0eVZhbHVl KToKKyAgICAgICAgKFdURjo6UmVmPFQ+Ojpzd2FwKToKKyAgICAgICAgKFdURjo6UmVmPFQ+Ojpy ZXBsYWNlKToKKyAgICAgICAgKFdURjo6c3RhdGljX3JlZmVyZW5jZV9jYXN0KToKKyAgICAgICAg LSBBZGQgdGVtcGxhdGUgc3BlY2lhbGl6YXRpb25zIGZvciBSZWZDb3VudGVkIGNsYXNzIHRvCisg ICAgICAgICAgcmVzZXQgUmVmQ291bnRlZDo6bV9vcmlnaW5UaHJlYWRJRCBkdXJpbmcgYSBtb3Zl LgorCisgICAgICAgICogd3RmL1JlZkNvdW50ZWQuaDoKKyAgICAgICAgKFdURjo6UmVmQ291bnRl ZEJhc2U6OnJlZik6CisgICAgICAgIChXVEY6OlJlZkNvdW50ZWRCYXNlOjpoYXNPbmVSZWYpOgor ICAgICAgICAoV1RGOjpSZWZDb3VudGVkQmFzZTo6cmVmQ291bnQpOgorICAgICAgICAoV1RGOjpS ZWZDb3VudGVkQmFzZTo6cmVzZXRPcmlnaW5UaHJlYWRJRCk6CisgICAgICAgIChXVEY6OlJlZkNv dW50ZWRCYXNlOjpSZWZDb3VudGVkQmFzZSk6CisgICAgICAgIChXVEY6OlJlZkNvdW50ZWRCYXNl OjpkZXJlZkJhc2UpOgorICAgICAgICAtIEFkZCBtX29yaWdpblRocmVhZElEIGFuZCB2ZXJpZnkg aXQgaW4gRGVidWcgYnVpbGRzLgorCisgICAgICAgICogd3RmL1JlZlB0ci5oOgorICAgICAgICAo V1RGOjpSZWZQdHI6OlJlZlB0cik6CisgICAgICAgIChXVEY6OlJlZlB0cjxUPjo6UmVmUHRyKToK KyAgICAgICAgKFdURjo6UmVmUHRyPFQ+Ojpzd2FwKToKKyAgICAgICAgLSBBZGQgdGVtcGxhdGUg c3BlY2lhbGl6YXRpb25zIGZvciBSZWZDb3VudGVkIGNsYXNzIHRvCisgICAgICAgICAgcmVzZXQg UmVmQ291bnRlZDo6bV9vcmlnaW5UaHJlYWRJRCBkdXJpbmcgYSBtb3ZlLgorCisgICAgICAgICog d3RmL1NpemVMaW1pdHMuY3BwOgorICAgICAgICAoc3RydWN0IFNhbWVTaXplQXNSZWZDb3VudGVk KTogVXBkYXRlIGZvciBEZWJ1ZyBzaXplCisgICAgICAgIG9mIFJlZkNvdW50ZWQgY2xhc3MuCisK KyAgICAgICAgKiB3dGYvVGhyZWFkaW5nLmg6CisgICAgICAgIChUaHJlYWQ6OnVuc2V0VGhyZWFk SUQpOiBBZGQgY29uc3RhbnQgZm9yIG1hZ2ljIHZhbHVlLgorICAgICAgICAoVGhyZWFkOjptX2lk KTogSW5pdGlhbGl6ZSB2YWx1ZSB0byB1bnNldFRocmVhZElELgorCisgICAgICAgICogd3RmL1Ro cmVhZGluZ1B0aHJlYWRzLmNwcDoKKyAgICAgICAgKFdURjo6VGhyZWFkOjplc3RhYmxpc2gpOiBV c2UgdW5zZXRUaHJlYWRJRCBpbnN0ZWFkIG9mCisgICAgICAgIGltcGxpY2l0IG1hZ2ljIG51bWJl ci4KKwogMjAxNy0wNi0yMyAgS29uc3RhbnRpbiBUb2thcmV2ICA8YW5udWxlbkB5YW5kZXgucnU+ CiAKICAgICAgICAgUmVtb3ZlIG1vcmUgdW51c2VkIGhlYWRlcnMgZnJvbSBXVEYKZGlmZiAtLWdp dCBhL1NvdXJjZS9XVEYvd3RmL1JlZi5oIGIvU291cmNlL1dURi93dGYvUmVmLmgKaW5kZXggMzMw YmQ1Y2M2YTExOTM0OTJmZWYwYjc0OWM1MDljZjllNDk1NDI4MS4uZmI0MzdkOGE0NzIxZGYzMWQ3 MzdmNGIzYWU4MDVjM2NkOGMzM2RhZSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvUmVmLmgK KysrIGIvU291cmNlL1dURi93dGYvUmVmLmgKQEAgLTQyLDYgKzQyLDcgQEAgbmFtZXNwYWNlIFdU RiB7CiBpbmxpbmUgdm9pZCBhZG9wdGVkKGNvbnN0IHZvaWQqKSB7IH0KIAogdGVtcGxhdGU8dHlw ZW5hbWUgVD4gY2xhc3MgUmVmOwordGVtcGxhdGU8dHlwZW5hbWUgVD4gY2xhc3MgUmVmQ291bnRl ZDsKIHRlbXBsYXRlPHR5cGVuYW1lIFQ+IFJlZjxUPiBhZG9wdFJlZihUJik7CiAKIHRlbXBsYXRl PHR5cGVuYW1lIFQ+IGNsYXNzIFJlZiB7CkBAIC04MSw2ICs4MiwxNCBAQCBwdWJsaWM6CiAgICAg ICAgIEFTU0VSVChtX3B0cik7CiAgICAgfQogCisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVj4KKyAg ICBSZWYoUmVmPFJlZkNvdW50ZWQ8Vj4+JiYgb3RoZXIpCisgICAgICAgIDogbV9wdHIoJm90aGVy LmxlYWtSZWYoKSkKKyAgICB7CisgICAgICAgIEFTU0VSVChtX3B0cik7CisgICAgICAgIG1fcHRy LT5yZXNldE9yaWdpblRocmVhZElEKCk7CisgICAgfQorCiAgICAgUmVmJiBvcGVyYXRvcj0oVCYp OwogICAgIFJlZiYgb3BlcmF0b3I9KFJlZiYmKTsKICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBVPiBS ZWYmIG9wZXJhdG9yPShSZWY8VT4mJik7CkBAIC05MCw2ICs5OSw3IEBAIHB1YmxpYzoKICAgICB0 ZW1wbGF0ZTx0eXBlbmFtZSBVPiBSZWYmIG9wZXJhdG9yPShjb25zdCBSZWY8VT4mKSA9IGRlbGV0 ZTsKIAogICAgIHZvaWQgc3dhcChSZWYmKTsKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBWPiB2b2lk IHN3YXAoUmVmPFJlZkNvdW50ZWQ8Vj4+Jik7CiAKICAgICAvLyBIYXNoIHRhYmxlIGRlbGV0ZWQg dmFsdWVzLCB3aGljaCBhcmUgb25seSBjb25zdHJ1Y3RlZCBhbmQgbmV2ZXIgY29waWVkIG9yIGRl c3Ryb3llZC4KICAgICBSZWYoSGFzaFRhYmxlRGVsZXRlZFZhbHVlVHlwZSkgOiBtX3B0cihoYXNo VGFibGVEZWxldGVkVmFsdWUoKSkgeyB9CkBAIC0xMTAsNiArMTIwLDE0IEBAIHB1YmxpYzoKICAg ICAgICAgQVNTRVJUKG1fcHRyKTsKICAgICB9CiAKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBWPiB2 b2lkIGFzc2lnblRvSGFzaFRhYmxlRW1wdHlWYWx1ZShSZWY8UmVmQ291bnRlZDxWPj4mJiByZWZl cmVuY2UpCisgICAgeworICAgICAgICBBU1NFUlQobV9wdHIgPT0gaGFzaFRhYmxlRW1wdHlWYWx1 ZSgpKTsKKyAgICAgICAgbV9wdHIgPSAmcmVmZXJlbmNlLmxlYWtSZWYoKTsKKyAgICAgICAgQVNT RVJUKG1fcHRyKTsKKyAgICAgICAgbV9wdHItPnJlc2V0T3JpZ2luVGhyZWFkSUQoKTsKKyAgICB9 CisKICAgICBUKiBvcGVyYXRvci0+KCkgY29uc3QgeyBBU1NFUlQobV9wdHIpOyByZXR1cm4gbV9w dHI7IH0KICAgICBUKiBwdHIoKSBjb25zdCBSRVRVUk5TX05PTk5VTEwgeyBBU1NFUlQobV9wdHIp OyByZXR1cm4gbV9wdHI7IH0KICAgICBUJiBnZXQoKSBjb25zdCB7IEFTU0VSVChtX3B0cik7IHJl dHVybiAqbV9wdHI7IH0KQEAgLTExNywxMCArMTM1LDE1IEBAIHB1YmxpYzoKICAgICBib29sIG9w ZXJhdG9yISgpIGNvbnN0IHsgQVNTRVJUKG1fcHRyKTsgcmV0dXJuICEqbV9wdHI7IH0KIAogICAg IHRlbXBsYXRlPHR5cGVuYW1lIFU+IFJlZjxUPiByZXBsYWNlKFJlZjxVPiYmKSBXQVJOX1VOVVNF RF9SRVRVUk47CisgICAgdGVtcGxhdGU8dHlwZW5hbWUgVj4gUmVmPFQ+IHJlcGxhY2UoUmVmPFJl ZkNvdW50ZWQ8Vj4+JiYpIFdBUk5fVU5VU0VEX1JFVFVSTjsKIAogI2lmIENPTVBJTEVSX1NVUFBP UlRTKENYWF9SRUZFUkVOQ0VfUVVBTElGSUVEX0ZVTkNUSU9OUykKICAgICBSZWYgY29weVJlZigp ICYmID0gZGVsZXRlOwogICAgIFJlZiBjb3B5UmVmKCkgY29uc3QgJiBXQVJOX1VOVVNFRF9SRVRV Uk4geyByZXR1cm4gUmVmKCptX3B0cik7IH0KKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBWPiBSZWY8 UmVmQ291bnRlZDxWPj4gY29weVJlZigpIGNvbnN0ICYgV0FSTl9VTlVTRURfUkVUVVJOIHsKKyAg ICAgICAgbV9wdHItPnJlc2V0T3JpZ2luVGhyZWFkSUQoKTsKKyAgICAgICAgcmV0dXJuIFJlZjxS ZWZDb3VudGVkPFY+PigqbV9wdHIpOworICAgIH0KICNlbHNlCiAgICAgUmVmIGNvcHlSZWYoKSBj b25zdCBXQVJOX1VOVVNFRF9SRVRVUk4geyByZXR1cm4gUmVmKCptX3B0cik7IH0KICNlbmRpZgpA QCAtMTc4LDYgKzIwMSwxNCBAQCB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBpbmxpbmUgdm9pZCBSZWY8 VD46OnN3YXAoUmVmJiBvdGhlcikKICAgICBzdGQ6OnN3YXAobV9wdHIsIG90aGVyLm1fcHRyKTsK IH0KIAordGVtcGxhdGU8dHlwZW5hbWUgVD4KK3RlbXBsYXRlPHR5cGVuYW1lIFY+IGlubGluZSB2 b2lkIFJlZjxUPjo6c3dhcChSZWY8UmVmQ291bnRlZDxWPj4mIG90aGVyKQoreworICAgIHN0ZDo6 c3dhcChtX3B0ciwgb3RoZXIubV9wdHIpOworICAgIG1fcHRyLT5yZXNldE9yaWdpblRocmVhZElE KCk7CisgICAgb3RoZXIubV9wdHItPnJlc2V0T3JpZ2luVGhyZWFkSUQoKTsKK30KKwogdGVtcGxh dGU8dHlwZW5hbWUgVD4gaW5saW5lIHZvaWQgc3dhcChSZWY8VD4mIGEsIFJlZjxUPiYgYikKIHsK ICAgICBhLnN3YXAoYik7CkBAIC0xOTAsNiArMjIxLDE0IEBAIHRlbXBsYXRlPHR5cGVuYW1lIFQ+ IHRlbXBsYXRlPHR5cGVuYW1lIFU+IGlubGluZSBSZWY8VD4gUmVmPFQ+OjpyZXBsYWNlKFJlZjxV PiYmCiAgICAgcmV0dXJuIG9sZFJlZmVyZW5jZTsKIH0KIAordGVtcGxhdGU8dHlwZW5hbWUgVD4g dGVtcGxhdGU8dHlwZW5hbWUgVj4gaW5saW5lIFJlZjxUPiBSZWY8VD46OnJlcGxhY2UoUmVmPFJl ZkNvdW50ZWQ8Vj4+JiYgcmVmZXJlbmNlKQoreworICAgIGF1dG8gb2xkUmVmZXJlbmNlID0gYWRv cHRSZWYoKm1fcHRyKTsKKyAgICBtX3B0ciA9ICZyZWZlcmVuY2UubGVha1JlZigpOworICAgIG1f cHRyLT5yZXNldE9yaWdpblRocmVhZElEKCk7CisgICAgcmV0dXJuIG9sZFJlZmVyZW5jZTsKK30K KwogdGVtcGxhdGU8dHlwZW5hbWUgVCwgdHlwZW5hbWUgVT4gaW5saW5lIFJlZjxUPiBzdGF0aWNf cmVmZXJlbmNlX2Nhc3QoUmVmPFU+JiByZWZlcmVuY2UpCiB7CiAgICAgcmV0dXJuIFJlZjxUPihz dGF0aWNfY2FzdDxUJj4ocmVmZXJlbmNlLmdldCgpKSk7CkBAIC0yMDAsNiArMjM5LDEzIEBAIHRl bXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVuYW1lIFU+IGlubGluZSBSZWY8VD4gc3RhdGljX3JlZmVy ZW5jZV9jYXN0KFJlZjxVPiYmIHJlCiAgICAgcmV0dXJuIGFkb3B0UmVmKHN0YXRpY19jYXN0PFQm PihyZWZlcmVuY2UubGVha1JlZigpKSk7CiB9CiAKK3RlbXBsYXRlPHR5cGVuYW1lIFQsIHR5cGVu YW1lIFY+IGlubGluZSBSZWY8VD4gc3RhdGljX3JlZmVyZW5jZV9jYXN0KFJlZjxSZWZDb3VudGVk PFY+PiYmIHJlZmVyZW5jZSkKK3sKKyAgICBhdXRvIGFkb3B0ZWQgPSBhZG9wdFJlZihzdGF0aWNf Y2FzdDxUJj4ocmVmZXJlbmNlLmxlYWtSZWYoKSkpOworICAgIGFkb3B0ZWQucmVzZXRPcmlnaW5U aHJlYWRJRCgpOworICAgIHJldHVybiBhZG9wdGVkOworfQorCiB0ZW1wbGF0ZTx0eXBlbmFtZSBU LCB0eXBlbmFtZSBVPiBpbmxpbmUgUmVmPFQ+IHN0YXRpY19yZWZlcmVuY2VfY2FzdChjb25zdCBS ZWY8VT4mIHJlZmVyZW5jZSkKIHsKICAgICByZXR1cm4gUmVmPFQ+KHN0YXRpY19jYXN0PFQmPihy ZWZlcmVuY2UuY29weVJlZigpLmdldCgpKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9S ZWZDb3VudGVkLmggYi9Tb3VyY2UvV1RGL3d0Zi9SZWZDb3VudGVkLmgKaW5kZXggMTM3NjJlMDdh ZWY0Mzg4NTY5NTAyYmUyMzY0OTA4NzA4NWJmNmFjNi4uNTE3YzE5ZmFiYTcxZWVmMGRmMTU4MjMx ZGIyM2MyZjYwZGM0NThhYSAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvUmVmQ291bnRlZC5o CisrKyBiL1NvdXJjZS9XVEYvd3RmL1JlZkNvdW50ZWQuaApAQCAtMjMsNiArMjMsNyBAQAogI2lu Y2x1ZGUgPHd0Zi9Bc3NlcnRpb25zLmg+CiAjaW5jbHVkZSA8d3RmL0Zhc3RNYWxsb2MuaD4KICNp bmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KKyNpbmNsdWRlIDx3dGYvVGhyZWFkaW5nLmg+CiAK IG5hbWVzcGFjZSBXVEYgewogCkBAIC0zOSw2ICs0MCw3IEBAIGNsYXNzIFJlZkNvdW50ZWRCYXNl IHsKIHB1YmxpYzoKICAgICB2b2lkIHJlZigpIGNvbnN0CiAgICAgeworICAgICAgICBBU1NFUlQo Y3VycmVudFRocmVhZCgpID09IG1fb3JpZ2luVGhyZWFkSUQpOwogI2lmIENIRUNLX1JFRl9DT1VO VEVEX0xJRkVDWUNMRQogICAgICAgICBBU1NFUlRfV0lUSF9TRUNVUklUWV9JTVBMSUNBVElPTigh bV9kZWxldGlvbkhhc0JlZ3VuKTsKICAgICAgICAgQVNTRVJUKCFtX2Fkb3B0aW9uSXNSZXF1aXJl ZCk7CkBAIC00OCw2ICs1MCw3IEBAIHB1YmxpYzoKIAogICAgIGJvb2wgaGFzT25lUmVmKCkgY29u c3QKICAgICB7CisgICAgICAgIEFTU0VSVChjdXJyZW50VGhyZWFkKCkgPT0gbV9vcmlnaW5UaHJl YWRJRCk7CiAjaWYgQ0hFQ0tfUkVGX0NPVU5URURfTElGRUNZQ0xFCiAgICAgICAgIEFTU0VSVCgh bV9kZWxldGlvbkhhc0JlZ3VuKTsKICNlbmRpZgpAQCAtNTYsNiArNTksNyBAQCBwdWJsaWM6CiAK ICAgICB1bnNpZ25lZCByZWZDb3VudCgpIGNvbnN0CiAgICAgeworICAgICAgICBBU1NFUlQoY3Vy cmVudFRocmVhZCgpID09IG1fb3JpZ2luVGhyZWFkSUQpOwogICAgICAgICByZXR1cm4gbV9yZWZD b3VudDsKICAgICB9CiAKQEAgLTY4LDE0ICs3MiwxOSBAQCBwdWJsaWM6CiAjZW5kaWYKICAgICB9 CiAKKyNpZm5kZWYgTkRFQlVHCisgICAgdm9pZCByZXNldE9yaWdpblRocmVhZElEKCkKKyAgICB7 CisgICAgICAgIEFTU0VSVChtX29yaWdpblRocmVhZElEICE9IFRocmVhZDo6dW5zZXRUaHJlYWRJ RCk7CisgICAgICAgIG1fb3JpZ2luVGhyZWFkSUQgPSBjdXJyZW50VGhyZWFkKCk7CisgICAgICAg IEFTU0VSVChtX29yaWdpblRocmVhZElEICE9IFRocmVhZDo6dW5zZXRUaHJlYWRJRCk7CisgICAg fQorI2VuZGlmCisKIHByb3RlY3RlZDoKICAgICBSZWZDb3VudGVkQmFzZSgpCi0gICAgICAgIDog bV9yZWZDb3VudCgxKQotI2lmIENIRUNLX1JFRl9DT1VOVEVEX0xJRkVDWUNMRQotICAgICAgICAs IG1fZGVsZXRpb25IYXNCZWd1bihmYWxzZSkKLSAgICAgICAgLCBtX2Fkb3B0aW9uSXNSZXF1aXJl ZCh0cnVlKQotI2VuZGlmCiAgICAgeworICAgICAgICBBU1NFUlQobV9vcmlnaW5UaHJlYWRJRCAh PSBUaHJlYWQ6OnVuc2V0VGhyZWFkSUQpOwogICAgIH0KIAogICAgIH5SZWZDb3VudGVkQmFzZSgp CkBAIC04OSw2ICs5OCw3IEBAIHByb3RlY3RlZDoKICAgICAvLyBSZXR1cm5zIHdoZXRoZXIgdGhl IHBvaW50ZXIgc2hvdWxkIGJlIGZyZWVkIG9yIG5vdC4KICAgICBib29sIGRlcmVmQmFzZSgpIGNv bnN0CiAgICAgeworICAgICAgICBBU1NFUlQoY3VycmVudFRocmVhZCgpID09IG1fb3JpZ2luVGhy ZWFkSUQpOwogI2lmIENIRUNLX1JFRl9DT1VOVEVEX0xJRkVDWUNMRQogICAgICAgICBBU1NFUlRf V0lUSF9TRUNVUklUWV9JTVBMSUNBVElPTighbV9kZWxldGlvbkhhc0JlZ3VuKTsKICAgICAgICAg QVNTRVJUKCFtX2Fkb3B0aW9uSXNSZXF1aXJlZCk7CkBAIC0xMTksMTAgKzEyOSwxMyBAQCBwcml2 YXRlOgogICAgIGZyaWVuZCB2b2lkIGFkb3B0ZWQoUmVmQ291bnRlZEJhc2UqKTsKICNlbmRpZgog Ci0gICAgbXV0YWJsZSB1bnNpZ25lZCBtX3JlZkNvdW50OworICAgIG11dGFibGUgdW5zaWduZWQg bV9yZWZDb3VudCB7IDEgfTsKKyNpZm5kZWYgTkRFQlVHCisgICAgbXV0YWJsZSBUaHJlYWRJZGVu dGlmaWVyIG1fb3JpZ2luVGhyZWFkSUQgeyBjdXJyZW50VGhyZWFkKCkgfTsKKyNlbmRpZgogI2lm IENIRUNLX1JFRl9DT1VOVEVEX0xJRkVDWUNMRQotICAgIG11dGFibGUgYm9vbCBtX2RlbGV0aW9u SGFzQmVndW47Ci0gICAgbXV0YWJsZSBib29sIG1fYWRvcHRpb25Jc1JlcXVpcmVkOworICAgIG11 dGFibGUgYm9vbCBtX2RlbGV0aW9uSGFzQmVndW4geyBmYWxzZSB9OworICAgIG11dGFibGUgYm9v bCBtX2Fkb3B0aW9uSXNSZXF1aXJlZCB7IHRydWUgfTsKICNlbmRpZgogfTsKIApkaWZmIC0tZ2l0 IGEvU291cmNlL1dURi93dGYvUmVmUHRyLmggYi9Tb3VyY2UvV1RGL3d0Zi9SZWZQdHIuaAppbmRl eCAwN2FmMzVmNDg0ZjFmZDQwMmZkYmY5ZDY1MjQ1Y2FiZmZjNTZlMmQ5Li42Mjc1MmEwODJmMDdk MGNhZTBmYzViMmM3ZDMwMmYwOTgxZGQ2OGVmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9S ZWZQdHIuaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9SZWZQdHIuaApAQCAtMzAsNiArMzAsNyBAQAog CiBuYW1lc3BhY2UgV1RGIHsKIAordGVtcGxhdGU8dHlwZW5hbWUgVD4gY2xhc3MgUmVmQ291bnRl ZDsKIHRlbXBsYXRlPHR5cGVuYW1lIFQ+IGNsYXNzIFJlZlB0cjsKIHRlbXBsYXRlPHR5cGVuYW1l IFQ+IFJlZlB0cjxUPiBhZG9wdFJlZihUKik7CiAKQEAgLTYwLDcgKzYxLDEzIEBAIHB1YmxpYzoK IAogICAgIEFMV0FZU19JTkxJTkUgUmVmUHRyKFJlZlB0ciYmIG8pIDogbV9wdHIoby5sZWFrUmVm KCkpIHsgfQogICAgIHRlbXBsYXRlPHR5cGVuYW1lIFU+IFJlZlB0cihSZWZQdHI8VT4mJiBvKSA6 IG1fcHRyKG8ubGVha1JlZigpKSB7IH0KKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBWPiBSZWZQdHIo UmVmUHRyPFJlZkNvdW50ZWQ8Vj4+JiYgbykKKyAgICAgICAgOiBtX3B0cihvLmxlYWtSZWYoKSkK KyAgICB7CisgICAgICAgIG1fcHRyLT5yZXNldE9yaWdpblRocmVhZElEKCk7CisgICAgfQogICAg IHRlbXBsYXRlPHR5cGVuYW1lIFU+IFJlZlB0cihSZWY8VT4mJik7CisgICAgdGVtcGxhdGU8dHlw ZW5hbWUgVj4gUmVmUHRyKFJlZjxSZWZDb3VudGVkPFY+PiYmKTsKIAogICAgIC8vIEhhc2ggdGFi bGUgZGVsZXRlZCB2YWx1ZXMsIHdoaWNoIGFyZSBvbmx5IGNvbnN0cnVjdGVkIGFuZCBuZXZlciBj b3BpZWQgb3IgZGVzdHJveWVkLgogICAgIFJlZlB0cihIYXNoVGFibGVEZWxldGVkVmFsdWVUeXBl KSA6IG1fcHRyKGhhc2hUYWJsZURlbGV0ZWRWYWx1ZSgpKSB7IH0KQEAgLTkzLDEyICsxMDAsMTcg QEAgcHVibGljOgogICAgIHRlbXBsYXRlPHR5cGVuYW1lIFU+IFJlZlB0ciYgb3BlcmF0b3I9KFJl ZjxVPiYmKTsKIAogICAgIHZvaWQgc3dhcChSZWZQdHImKTsKKyAgICB0ZW1wbGF0ZTx0eXBlbmFt ZSBWPiB2b2lkIHN3YXAoUmVmUHRyPFJlZkNvdW50ZWQ8Vj4+Jik7CiAKICAgICBzdGF0aWMgVCog aGFzaFRhYmxlRGVsZXRlZFZhbHVlKCkgeyByZXR1cm4gcmVpbnRlcnByZXRfY2FzdDxUKj4oLTEp OyB9CiAKICNpZiBDT01QSUxFUl9TVVBQT1JUUyhDWFhfUkVGRVJFTkNFX1FVQUxJRklFRF9GVU5D VElPTlMpCiAgICAgUmVmUHRyIGNvcHlSZWYoKSAmJiA9IGRlbGV0ZTsKICAgICBSZWZQdHIgY29w eVJlZigpIGNvbnN0ICYgV0FSTl9VTlVTRURfUkVUVVJOIHsgcmV0dXJuIFJlZlB0cihtX3B0cik7 IH0KKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBWPiBSZWZQdHI8UmVmQ291bnRlZDxWPj4gY29weVJl ZigpIGNvbnN0ICYgV0FSTl9VTlVTRURfUkVUVVJOIHsKKyAgICAgICAgbV9wdHItPnJlc2V0T3Jp Z2luVGhyZWFkSUQoKTsKKyAgICAgICAgcmV0dXJuIFJlZlB0cjxSZWZDb3VudGVkPFY+PihtX3B0 cik7CisgICAgfQogI2Vsc2UKICAgICBSZWZQdHIgY29weVJlZigpIGNvbnN0IFdBUk5fVU5VU0VE X1JFVFVSTiB7IHJldHVybiBSZWZQdHIobV9wdHIpOyB9CiAjZW5kaWYKQEAgLTExNyw2ICsxMjks MTIgQEAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gdGVtcGxhdGU8dHlwZW5hbWUgVT4gaW5saW5lIFJl ZlB0cjxUPjo6UmVmUHRyKFJlZjxVPiYmIHJlZmUKIHsKIH0KIAordGVtcGxhdGU8dHlwZW5hbWUg VD4gdGVtcGxhdGU8dHlwZW5hbWUgVj4gaW5saW5lIFJlZlB0cjxUPjo6UmVmUHRyKFJlZjxSZWZD b3VudGVkPFY+PiYmIHJlZmVyZW5jZSkKKyAgICA6IG1fcHRyKCZyZWZlcmVuY2UubGVha1JlZigp KQoreworICAgIG1fcHRyLT5yZXNldE9yaWdpblRocmVhZElEKCk7Cit9CisKIHRlbXBsYXRlPHR5 cGVuYW1lIFQ+CiBpbmxpbmUgVCogUmVmUHRyPFQ+OjpsZWFrUmVmKCkKIHsKQEAgLTE3Niw2ICsx OTQsMTQgQEAgdGVtcGxhdGU8Y2xhc3MgVD4gaW5saW5lIHZvaWQgUmVmUHRyPFQ+Ojpzd2FwKFJl ZlB0ciYgbykKICAgICBzdGQ6OnN3YXAobV9wdHIsIG8ubV9wdHIpOwogfQogCit0ZW1wbGF0ZTxj bGFzcyBUPgordGVtcGxhdGU8Y2xhc3MgVj4gaW5saW5lIHZvaWQgUmVmUHRyPFQ+Ojpzd2FwKFJl ZlB0cjxSZWZDb3VudGVkPFY+PiYgbykKK3sKKyAgICBzdGQ6OnN3YXAobV9wdHIsIG8ubV9wdHIp OworICAgIG1fcHRyLT5yZXNldE9yaWdpblRocmVhZElEKCk7CisgICAgby5tX3B0ci0+cmVzZXRP cmlnaW5UaHJlYWRJRCgpOworfQorCiB0ZW1wbGF0ZTxjbGFzcyBUPiBpbmxpbmUgdm9pZCBzd2Fw KFJlZlB0cjxUPiYgYSwgUmVmUHRyPFQ+JiBiKQogewogICAgIGEuc3dhcChiKTsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XVEYvd3RmL1NpemVMaW1pdHMuY3BwIGIvU291cmNlL1dURi93dGYvU2l6ZUxp bWl0cy5jcHAKaW5kZXggM2NjNmZkN2M2YTdiOGEzZTUwNjVmMGJjNzhhMTNmZjIzNDBkMjQ3OC4u YjdjOGQxNjk5ZTk4YTJlYjMwMmE2OWMzYWM2YjlkYTcyN2I1ODZlZiAxMDA2NDQKLS0tIGEvU291 cmNlL1dURi93dGYvU2l6ZUxpbWl0cy5jcHAKKysrIGIvU291cmNlL1dURi93dGYvU2l6ZUxpbWl0 cy5jcHAKQEAgLTQ0LDYgKzQ0LDcgQEAgc3RydWN0IFNhbWVTaXplQXNSZWZDb3VudGVkIHsKICAg ICBpbnQgYTsKICAgICBib29sIGI7CiAgICAgYm9vbCBjOworICAgIHVpbnQzMl90IGQ7CiAgICAg Ly8gVGhlIGRlYnVnIHZlcnNpb24gbWF5IGdldCBiaWdnZXIuCiB9OwogI2Vsc2UKZGlmZiAtLWdp dCBhL1NvdXJjZS9XVEYvd3RmL1RocmVhZGluZy5oIGIvU291cmNlL1dURi93dGYvVGhyZWFkaW5n LmgKaW5kZXggMzM3MmFjMTJlZDhmZTBiM2EwMWFmMGYxZmUzNjY1ZWIzNDk2YmRhMi4uMjM1Y2M5 YjkzN2E4Y2M0ZWNmNGU4ODEwMzhjY2NjMGI1N2I5OTEyOCAxMDA2NDQKLS0tIGEvU291cmNlL1dU Ri93dGYvVGhyZWFkaW5nLmgKKysrIGIvU291cmNlL1dURi93dGYvVGhyZWFkaW5nLmgKQEAgLTEx Miw2ICsxMTIsNyBAQCBwdWJsaWM6CiAKICAgICBXVEZfRVhQT1JUX1BSSVZBVEUgdm9pZCBkdW1w KFByaW50U3RyZWFtJiBvdXQpIGNvbnN0OwogCisgICAgc3RhdGljIGNvbnN0IFRocmVhZElkZW50 aWZpZXIgdW5zZXRUaHJlYWRJRCB7IDAgfTsKICAgICBUaHJlYWRJZGVudGlmaWVyIGlkKCkgY29u c3QgeyByZXR1cm4gbV9pZDsgfQogCiAgICAgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFRocmVhZCYg dGhyZWFkKQpAQCAtMTcwLDcgKzE3MSw3IEBAIHByb3RlY3RlZDoKIAogICAgIC8vIFdvcmRMb2Nr ICYgTG9jayByZWx5IG9uIFRocmVhZFNwZWNpZmljLiBCdXQgVGhyZWFkIG9iamVjdCBjYW4gYmUg ZGVzdHJveWVkIGV2ZW4gYWZ0ZXIgVGhyZWFkU3BlY2lmaWMgdGhpbmdzIGFyZSBkZXN0cm95ZWQu CiAgICAgc3RkOjptdXRleCBtX211dGV4OwotICAgIFRocmVhZElkZW50aWZpZXIgbV9pZCB7IDAg fTsKKyAgICBUaHJlYWRJZGVudGlmaWVyIG1faWQgeyB1bnNldFRocmVhZElEIH07CiAgICAgSm9p bmFibGVTdGF0ZSBtX2pvaW5hYmxlU3RhdGUgeyBKb2luYWJsZSB9OwogICAgIGJvb2wgbV9kaWRF eGl0IHsgZmFsc2UgfTsKICNpZiBVU0UoUFRIUkVBRFMpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RG L3d0Zi9UaHJlYWRpbmdQdGhyZWFkcy5jcHAgYi9Tb3VyY2UvV1RGL3d0Zi9UaHJlYWRpbmdQdGhy ZWFkcy5jcHAKaW5kZXggZDZjMGExNzdhNjkwOGUxZGMwMTM4YTA2OGMyYTExMGE5NDMyNWEyZi4u NTI4ZDU0MzgwOTkwODljMDY2ZWU0OTAwZDRhOTAwMDAxYmMzMTlmZSAxMDA2NDQKLS0tIGEvU291 cmNlL1dURi93dGYvVGhyZWFkaW5nUHRocmVhZHMuY3BwCisrKyBiL1NvdXJjZS9XVEYvd3RmL1Ro cmVhZGluZ1B0aHJlYWRzLmNwcApAQCAtNDU0LDcgKzQ1NCw3IEBAIHZvaWQgVGhyZWFkOjplc3Rh Ymxpc2gocHRocmVhZF90IGhhbmRsZSkKIHsKICAgICBzdGQ6OnVuaXF1ZV9sb2NrPHN0ZDo6bXV0 ZXg+IGxvY2tlcihtX211dGV4KTsKICAgICBtX2hhbmRsZSA9IGhhbmRsZTsKLSAgICBpZiAoIW1f aWQpIHsKKyAgICBpZiAobV9pZCA9PSBUaHJlYWQ6OnVuc2V0VGhyZWFkSUQpIHsKICAgICAgICAg c3RhdGljIHN0ZDo6YXRvbWljPFRocmVhZElkZW50aWZpZXI+IHByb3ZpZGVyIHsgMCB9OwogICAg ICAgICBtX2lkID0gKytwcm92aWRlcjsKICNpZiBPUyhEQVJXSU4pCg==