227966 2021-07-14 13:25:40 -0700 [curl] Use curl_multi_poll and curl_multi_wakeup instead of select 2021-07-16 14:15:58 -0700 1 1 1 Unclassified WebKit Platform WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 fujii fujii basuke don.olmstead ews-watchlist galpeter takashi.komori webkit-bug-importer oldest_to_newest 1777015 0 fujii 2021-07-14 13:25:40 -0700 [curl] Use curl_multi_poll and curl_multi_wakeup instead of select 'select' system call can be replaced by those curl API. curl_multi_poll https://curl.se/libcurl/c/curl_multi_poll.html curl_multi_wakeup https://curl.se/libcurl/c/curl_multi_wakeup.html This is your wake up curl | daniel.haxx.se https://daniel.haxx.se/blog/2019/12/09/this-is-your-wake-up-curl/ 1777017 1 433524 fujii 2021-07-14 13:39:34 -0700 Created attachment 433524 Patch 1777235 2 433524 don.olmstead 2021-07-15 10:05:02 -0700 Comment on attachment 433524 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=433524&action=review Going to ask Basuke to do an informal on this. > Source/WebCore/ChangeLog:8 > + libcurl 7.68.0 added curl_multi_poll and curl_multi_wakeup. I checked the OptionsWinCairo.cmake and 7.71.0 is the requirement so nothing needs to change. 1777245 3 433524 basuke 2021-07-15 10:40:29 -0700 Comment on attachment 433524 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=433524&action=review This is informal review. Thanks for the patch. I love to see curl port is modernizing in a good way. But I don't agree with the direction of the change of therad life cycle. > Source/WebCore/platform/network/curl/CurlRequestScheduler.cpp:145 > + Locker locker { m_multiHandleMutex }; m_multiHandleMutex is used only in this workerThread by design. There's no need to lock. I bed you've added the lock because you need to check the validity of multi handle before calling curl_multi_wakeup. If that's the reason, how about moving the instantiation of the multi handle to the thread creation timing in main thread. That's ensure multi handle existance while thread is running. Any way this also related to the design of the thread life cycle I mentioned at the latter part (*1). > Source/WebCore/platform/network/curl/CurlRequestScheduler.cpp:-199 > - stopThreadIfNoMoreJobRunning(); The original design is stopping the thread if there's network is running to minimize the resource usage in entire system. I don't agree to change that with any good reason. [*1] > Source/WebCore/platform/network/curl/CurlRequestScheduler.cpp:182 > + Locker locker { m_multiHandleMutex }; Ditto. > Source/WebCore/platform/network/curl/CurlRequestScheduler.h:75 > + Lock m_multiHandleMutex; No need. > Source/WebCore/platform/network/curl/CurlRequestScheduler.h:76 > + std::optional<CurlMultiHandle> m_curlMultiHandle; What is the reason to change it from unique_ptr to optional? If there's good reason, then use WTF::Optional instead. 1777311 4 433524 fujii 2021-07-15 13:17:45 -0700 Comment on attachment 433524 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=433524&action=review >> Source/WebCore/platform/network/curl/CurlRequestScheduler.cpp:145 >> + Locker locker { m_multiHandleMutex }; > > m_multiHandleMutex is used only in this workerThread by design. There's no need to lock. I bed you've added the lock because you need to check the validity of multi handle before calling curl_multi_wakeup. If that's the reason, how about moving the instantiation of the multi handle to the thread creation timing in main thread. That's ensure multi handle existance while thread is running. Any way this also related to the design of the thread life cycle I mentioned at the latter part (*1). I also has a same idea, and tried the idea, but it doesn't work at all. I didn't look into it, but I guess that's because a multi handle might be fixed to the thread of creation time. >> Source/WebCore/platform/network/curl/CurlRequestScheduler.cpp:-199 >> - stopThreadIfNoMoreJobRunning(); > > The original design is stopping the thread if there's network is running to minimize the resource usage in entire system. I don't agree to change that with any good reason. [*1] I think the original design stops the thread because it didn't implement the wake up by using self-piping technique. It runs busily while no active handles (Bug 227942). The network thread is almost always necessary for a browser. I don't agree it can minimize the resource usage. >> Source/WebCore/platform/network/curl/CurlRequestScheduler.h:76 >> + std::optional<CurlMultiHandle> m_curlMultiHandle; > > What is the reason to change it from unique_ptr to optional? If there's good reason, then use WTF::Optional instead. Heap allocation have a cost of allocation and fragmentation, but useful for memory saving by freeing unused objects. However, CurlMultiHandle isn't big and CurlRequestScheduler almost always has a CurlMultiHandle. It doesn't make sense to separately allocate a CurlMultiHandle . WTF::Optional was removed in favor of std::optional (Bug 226705). 1777428 5 433524 basuke 2021-07-15 21:31:15 -0700 Comment on attachment 433524 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=433524&action=review >>> Source/WebCore/platform/network/curl/CurlRequestScheduler.cpp:145 >>> + Locker locker { m_multiHandleMutex }; >> >> m_multiHandleMutex is used only in this workerThread by design. There's no need to lock. I bed you've added the lock because you need to check the validity of multi handle before calling curl_multi_wakeup. If that's the reason, how about moving the instantiation of the multi handle to the thread creation timing in main thread. That's ensure multi handle existance while thread is running. Any way this also related to the design of the thread life cycle I mentioned at the latter part (*1). > > I also has a same idea, and tried the idea, but it doesn't work at all. > I didn't look into it, but I guess that's because a multi handle might be fixed to the thread of creation time. Okay. If I have time to investigate more, I can dig into this, but for now, safer is better. Let's add this mutex and lock area. >>> Source/WebCore/platform/network/curl/CurlRequestScheduler.cpp:-199 >>> - stopThreadIfNoMoreJobRunning(); >> >> The original design is stopping the thread if there's network is running to minimize the resource usage in entire system. I don't agree to change that with any good reason. [*1] > > I think the original design stops the thread because it didn't implement the wake up by using self-piping technique. It runs busily while no active handles (Bug 227942). > The network thread is almost always necessary for a browser. I don't agree it can minimize the resource usage. > It runs busily while no active handles (Bug 227942). That's be solved by this patch :) and not related to the life cycle issue we are discussing. You know WebView is not only for browser. Our use case requires that design. On the other hand I understand the your design. It is okay to add a compiler flag to choose which implementation. On WinCairo, no objection to enable your design. On PlayStation, we need current one. >>> Source/WebCore/platform/network/curl/CurlRequestScheduler.h:76 >>> + std::optional<CurlMultiHandle> m_curlMultiHandle; >> >> What is the reason to change it from unique_ptr to optional? If there's good reason, then use WTF::Optional instead. > > Heap allocation have a cost of allocation and fragmentation, but useful for memory saving by freeing unused objects. > However, CurlMultiHandle isn't big and CurlRequestScheduler almost always has a CurlMultiHandle. > It doesn't make sense to separately allocate a CurlMultiHandle . > WTF::Optional was removed in favor of std::optional (Bug 226705). Shame on me, I didn't follow that change. And the reason is very clear. Great. 1777435 6 fujii 2021-07-15 22:16:08 -0700 (In reply to Basuke Suzuki from comment #5) > That's be solved by this patch :) and not related to the life cycle issue we > are discussing. You know WebView is not only for browser. Our use case > requires that design. I got it. Will fix. 1777436 7 433656 fujii 2021-07-15 22:22:45 -0700 Created attachment 433656 Patch 1777439 8 433524 fujii 2021-07-15 22:35:38 -0700 Comment on attachment 433524 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=433524&action=review >>>> Source/WebCore/platform/network/curl/CurlRequestScheduler.cpp:145 >>>> + Locker locker { m_multiHandleMutex }; >>> >>> m_multiHandleMutex is used only in this workerThread by design. There's no need to lock. I bed you've added the lock because you need to check the validity of multi handle before calling curl_multi_wakeup. If that's the reason, how about moving the instantiation of the multi handle to the thread creation timing in main thread. That's ensure multi handle existance while thread is running. Any way this also related to the design of the thread life cycle I mentioned at the latter part (*1). >> >> I also has a same idea, and tried the idea, but it doesn't work at all. >> I didn't look into it, but I guess that's because a multi handle might be fixed to the thread of creation time. > > Okay. If I have time to investigate more, I can dig into this, but for now, safer is better. Let's add this mutex and lock area. Oops. My bad. It was just a deadlock. CurlContext::singleton() was called as re-entrant. CurlMultiHandle ctor calls CurlContext::singleton(). I hope you wil fix the problem as a follow-up. 1777440 9 433656 basuke 2021-07-15 22:47:00 -0700 Comment on attachment 433656 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=433656&action=review Thanks for understanding. And I'll try reducing the mutex after this bug. > Source/WebCore/platform/network/curl/CurlRequestScheduler.cpp:-99 > - m_runThread = false; This is still required for the case when there's no running handle. 1777443 10 433656 fujii 2021-07-15 22:51:59 -0700 Comment on attachment 433656 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=433656&action=review >> Source/WebCore/platform/network/curl/CurlRequestScheduler.cpp:-99 >> - m_runThread = false; > > This is still required for the case when there's no running handle. Why? CurlRequestScheduler::stopThreadIfNoMoreJobRunning set m_runThread = false. 1777454 11 433656 basuke 2021-07-16 00:33:31 -0700 Comment on attachment 433656 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=433656&action=review >>> Source/WebCore/platform/network/curl/CurlRequestScheduler.cpp:-99 >>> - m_runThread = false; >> >> This is still required for the case when there's no running handle. > > Why? CurlRequestScheduler::stopThreadIfNoMoreJobRunning set m_runThread = false. Oh, that's right. Sorry, my bad. You are right. This isn't needed here. 1777574 12 fujii 2021-07-16 13:19:56 -0700 Committed r279993 (239736@main): <https://commits.webkit.org/239736@main> 1777576 13 webkit-bug-importer 2021-07-16 13:20:18 -0700 <rdar://problem/80700058> 1777597 14 fujii 2021-07-16 14:15:58 -0700 *** Bug 227942 has been marked as a duplicate of this bug. *** 433524 2021-07-14 13:39:34 -0700 2021-07-15 22:22:35 -0700 Patch bug-227966-20210715053933.patch text/plain 8434 fujii U3VidmVyc2lvbiBSZXZpc2lvbjogMjc5OTAxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzljMmIyNWVlNmE3YzNh ZmE2NTZlNzc2MDNmY2YxZjIyNjQ5OWFhNC4uNmIzYzU1MDgwZjU3ZjE3MzMxMmI2ZTdmODFhYzY3 ZjIzODQ2YjUzNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDIxLTA3LTE0ICBGdWpp aSBIaXJvbm9yaSAgPEhpcm9ub3JpLkZ1amlpQHNvbnkuY29tPgorCisgICAgICAgIFtjdXJsXSBV c2UgY3VybF9tdWx0aV9wb2xsIGFuZCBjdXJsX211bHRpX3dha2V1cCBpbnN0ZWFkIG9mIHNlbGVj dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI3OTY2 CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgbGliY3Vy bCA3LjY4LjAgYWRkZWQgY3VybF9tdWx0aV9wb2xsIGFuZCBjdXJsX211bHRpX3dha2V1cC4KKwor ICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvY3VybC9DdXJsQ29udGV4dC5jcHA6CisgICAgICAg IChXZWJDb3JlOjpDdXJsTXVsdGlIYW5kbGU6OnBvbGwpOiBBZGRlZC4KKyAgICAgICAgKFdlYkNv cmU6OkN1cmxNdWx0aUhhbmRsZTo6d2FrZVVwKTogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0v bmV0d29yay9jdXJsL0N1cmxDb250ZXh0Lmg6CisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9j dXJsL0N1cmxSZXF1ZXN0U2NoZWR1bGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkN1cmxSZXF1 ZXN0U2NoZWR1bGVyOjphZGQpOgorICAgICAgICAoV2ViQ29yZTo6Q3VybFJlcXVlc3RTY2hlZHVs ZXI6OmNhbGxPbldvcmtlclRocmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpDdXJsUmVxdWVzdFNj aGVkdWxlcjo6c3RhcnRPcldha2VVcFRocmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpDdXJsUmVx dWVzdFNjaGVkdWxlcjo6d2FrZVVwVGhyZWFkSWZQb3NzaWJsZSk6CisgICAgICAgIChXZWJDb3Jl OjpDdXJsUmVxdWVzdFNjaGVkdWxlcjo6c3RvcFRocmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpD dXJsUmVxdWVzdFNjaGVkdWxlcjo6d29ya2VyVGhyZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OkN1 cmxSZXF1ZXN0U2NoZWR1bGVyOjpzdGFydFRocmVhZElmTmVlZGVkKTogRGVsZXRlZC4KKyAgICAg ICAgKFdlYkNvcmU6OkN1cmxSZXF1ZXN0U2NoZWR1bGVyOjpzdG9wVGhyZWFkSWZOb01vcmVKb2JS dW5uaW5nKTogRGVsZXRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL2N1cmwvQ3VybFJl cXVlc3RTY2hlZHVsZXIuaDoKKwogMjAyMS0wNy0xMyAgQWxleCBDaHJpc3RlbnNlbiAgPGFjaHJp c3RlbnNlbkB3ZWJraXQub3JnPgogCiAgICAgICAgID40SyBSZWZlcmVyIHNob3VsZCBoYXZlIHRh aWxpbmcgLwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJs L0N1cmxDb250ZXh0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvY3VybC9D dXJsQ29udGV4dC5jcHAKaW5kZXggYTNjYTAwZDBkMmIzNjcyMjFjNjU0YTRmMTAwZjEzODk2OWNi MDZjOC4uNjA4NDA2YjgzZTUzOTJmMjNhZTk5Y2M5Y2YyMDYzMmQyNTM2Y2Q2YSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0N1cmxDb250ZXh0LmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvQ3VybENvbnRleHQuY3Bw CkBAIC0yNjYsNiArMjY2LDE3IEBAIENVUkxNY29kZSBDdXJsTXVsdGlIYW5kbGU6OmdldEZkU2V0 KGZkX3NldCYgcmVhZEZkU2V0LCBmZF9zZXQmIHdyaXRlRmRTZXQsIGZkX3NlCiAgICAgcmV0dXJu IGN1cmxfbXVsdGlfZmRzZXQobV9tdWx0aUhhbmRsZSwgJnJlYWRGZFNldCwgJndyaXRlRmRTZXQs ICZleGNGZFNldCwgJm1heEZkKTsKIH0KIAorQ1VSTE1jb2RlIEN1cmxNdWx0aUhhbmRsZTo6cG9s bChjb25zdCBWZWN0b3I8Y3VybF93YWl0ZmQ+JiBleHRyYUZkcywgaW50IHRpbWVvdXRNUykKK3sK KyAgICBpbnQgbnVtRmRzID0gMDsKKyAgICByZXR1cm4gY3VybF9tdWx0aV9wb2xsKG1fbXVsdGlI YW5kbGUsIGNvbnN0X2Nhc3Q8Y3VybF93YWl0ZmQqPihleHRyYUZkcy5kYXRhKCkpLCBleHRyYUZk cy5zaXplKCksIHRpbWVvdXRNUywgJm51bUZkcyk7Cit9CisKK0NVUkxNY29kZSBDdXJsTXVsdGlI YW5kbGU6Ondha2VVcCgpCit7CisgICAgcmV0dXJuIGN1cmxfbXVsdGlfd2FrZXVwKG1fbXVsdGlI YW5kbGUpOworfQorCiBDVVJMTWNvZGUgQ3VybE11bHRpSGFuZGxlOjpwZXJmb3JtKGludCYgcnVu bmluZ0hhbmRsZXMpCiB7CiAgICAgcmV0dXJuIGN1cmxfbXVsdGlfcGVyZm9ybShtX211bHRpSGFu ZGxlLCAmcnVubmluZ0hhbmRsZXMpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vbmV0d29yay9jdXJsL0N1cmxDb250ZXh0LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9u ZXR3b3JrL2N1cmwvQ3VybENvbnRleHQuaAppbmRleCBlYTAwZTlkMmM5YWJkYzA0MjZmOTc3MmZl ODA2MDg3MGJjZWQ3ZmU5Li5jNWEyZjZhZDU2YjJmOWQ5NDI0ZDMzZDJjYWYyZjA5MzJmYmU3ZGJl IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvQ3VybENv bnRleHQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvQ3VybENv bnRleHQuaApAQCAtMTc0LDYgKzE3NCw4IEBAIHB1YmxpYzoKICAgICBDVVJMTWNvZGUgcmVtb3Zl SGFuZGxlKENVUkwqKTsKIAogICAgIENVUkxNY29kZSBnZXRGZFNldChmZF9zZXQmLCBmZF9zZXQm LCBmZF9zZXQmLCBpbnQmKTsKKyAgICBDVVJMTWNvZGUgcG9sbChjb25zdCBWZWN0b3I8Y3VybF93 YWl0ZmQ+JiwgaW50KTsKKyAgICBDVVJMTWNvZGUgd2FrZVVwKCk7CiAgICAgQ1VSTE1jb2RlIHBl cmZvcm0oaW50Jik7CiAgICAgQ1VSTE1zZyogcmVhZEluZm8oaW50Jik7CiAKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvY3VybC9DdXJsUmVxdWVzdFNjaGVkdWxl ci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvQ3VybFJlcXVlc3RT Y2hlZHVsZXIuY3BwCmluZGV4IDRhMjA1ZjhiMGUwZGFhNmYwODNlODg5MDk4YTczMzJlNzJmZmYy ZDEuLjE2NTY4MGJmY2IwMzFlYTE2NzU0NDhkYzA3ZmRmNTY5M2U5YTIwNjYgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvY3VybC9DdXJsUmVxdWVzdFNjaGVkdWxl ci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0N1cmxSZXF1 ZXN0U2NoZWR1bGVyLmNwcApAQCAtNDksNyArNDksNyBAQCBib29sIEN1cmxSZXF1ZXN0U2NoZWR1 bGVyOjphZGQoQ3VybFJlcXVlc3RTY2hlZHVsZXJDbGllbnQqIGNsaWVudCkKICAgICAgICAgcmV0 dXJuIGZhbHNlOwogCiAgICAgc3RhcnRUcmFuc2ZlcihjbGllbnQpOwotICAgIHN0YXJ0VGhyZWFk SWZOZWVkZWQoKTsKKyAgICBzdGFydE9yV2FrZVVwVGhyZWFkKCk7CiAKICAgICByZXR1cm4gdHJ1 ZTsKIH0KQEAgLTcxLDE3ICs3MSwxOSBAQCB2b2lkIEN1cmxSZXF1ZXN0U2NoZWR1bGVyOjpjYWxs T25Xb3JrZXJUaHJlYWQoV1RGOjpGdW5jdGlvbjx2b2lkKCk+JiYgdGFzaykKICAgICAgICAgbV90 YXNrUXVldWUuYXBwZW5kKFdURk1vdmUodGFzaykpOwogICAgIH0KIAotICAgIHN0YXJ0VGhyZWFk SWZOZWVkZWQoKTsKKyAgICBzdGFydE9yV2FrZVVwVGhyZWFkKCk7CiB9CiAKLXZvaWQgQ3VybFJl cXVlc3RTY2hlZHVsZXI6OnN0YXJ0VGhyZWFkSWZOZWVkZWQoKQordm9pZCBDdXJsUmVxdWVzdFNj aGVkdWxlcjo6c3RhcnRPcldha2VVcFRocmVhZCgpCiB7CiAgICAgQVNTRVJUKGlzTWFpblRocmVh ZCgpKTsKIAogICAgIHsKICAgICAgICAgTG9ja2VyIGxvY2tlciB7IG1fbXV0ZXggfTsKLSAgICAg ICAgaWYgKG1fcnVuVGhyZWFkKQorICAgICAgICBpZiAobV9ydW5UaHJlYWQpIHsKKyAgICAgICAg ICAgIHdha2VVcFRocmVhZElmUG9zc2libGUoKTsKICAgICAgICAgICAgIHJldHVybjsKKyAgICAg ICAgfQogICAgIH0KIAogICAgIGlmIChtX3RocmVhZCkKQEAgLTk0LDIxICs5NiwxNiBAQCB2b2lk IEN1cmxSZXF1ZXN0U2NoZWR1bGVyOjpzdGFydFRocmVhZElmTmVlZGVkKCkKIAogICAgIG1fdGhy ZWFkID0gVGhyZWFkOjpjcmVhdGUoImN1cmxUaHJlYWQiLCBbdGhpc10gewogICAgICAgICB3b3Jr ZXJUaHJlYWQoKTsKLQotICAgICAgICBMb2NrZXIgbG9ja2VyIHsgbV9tdXRleCB9OwotICAgICAg ICBtX3J1blRocmVhZCA9IGZhbHNlOwogICAgIH0sIFRocmVhZFR5cGU6Ok5ldHdvcmspOwogfQog Ci12b2lkIEN1cmxSZXF1ZXN0U2NoZWR1bGVyOjpzdG9wVGhyZWFkSWZOb01vcmVKb2JSdW5uaW5n KCkKK3ZvaWQgQ3VybFJlcXVlc3RTY2hlZHVsZXI6Ondha2VVcFRocmVhZElmUG9zc2libGUoKQog ewotICAgIEFTU0VSVCghaXNNYWluVGhyZWFkKCkpOwotCi0gICAgTG9ja2VyIGxvY2tlciB7IG1f bXV0ZXggfTsKLSAgICBpZiAobV9hY3RpdmVKb2JzLnNpemUoKSB8fCBtX3Rhc2tRdWV1ZS5zaXpl KCkpCisgICAgTG9ja2VyIGxvY2tlciB7IG1fbXVsdGlIYW5kbGVNdXRleCB9OworICAgIGlmICgh bV9jdXJsTXVsdGlIYW5kbGUpCiAgICAgICAgIHJldHVybjsKIAotICAgIG1fcnVuVGhyZWFkID0g ZmFsc2U7CisgICAgbV9jdXJsTXVsdGlIYW5kbGUtPndha2VVcCgpOwogfQogCiB2b2lkIEN1cmxS ZXF1ZXN0U2NoZWR1bGVyOjpzdG9wVGhyZWFkKCkKQEAgLTExOSw2ICsxMTYsNyBAQCB2b2lkIEN1 cmxSZXF1ZXN0U2NoZWR1bGVyOjpzdG9wVGhyZWFkKCkKICAgICB9CiAKICAgICBpZiAobV90aHJl YWQpIHsKKyAgICAgICAgd2FrZVVwVGhyZWFkSWZQb3NzaWJsZSgpOwogICAgICAgICBtX3RocmVh ZC0+d2FpdEZvckNvbXBsZXRpb24oKTsKICAgICAgICAgbV90aHJlYWQgPSBudWxscHRyOwogICAg IH0KQEAgLTE0MywxMCArMTQxLDEzIEBAIHZvaWQgQ3VybFJlcXVlc3RTY2hlZHVsZXI6Ondvcmtl clRocmVhZCgpCiB7CiAgICAgQVNTRVJUKCFpc01haW5UaHJlYWQoKSk7CiAKLSAgICBtX2N1cmxN dWx0aUhhbmRsZSA9IG1ha2VVbmlxdWU8Q3VybE11bHRpSGFuZGxlPigpOwotICAgIG1fY3VybE11 bHRpSGFuZGxlLT5zZXRNYXhDb25uZWN0cyhtX21heENvbm5lY3RzKTsKLSAgICBtX2N1cmxNdWx0 aUhhbmRsZS0+c2V0TWF4VG90YWxDb25uZWN0aW9ucyhtX21heFRvdGFsQ29ubmVjdGlvbnMpOwot ICAgIG1fY3VybE11bHRpSGFuZGxlLT5zZXRNYXhIb3N0Q29ubmVjdGlvbnMobV9tYXhIb3N0Q29u bmVjdGlvbnMpOworICAgIHsKKyAgICAgICAgTG9ja2VyIGxvY2tlciB7IG1fbXVsdGlIYW5kbGVN dXRleCB9OworICAgICAgICBtX2N1cmxNdWx0aUhhbmRsZS5lbXBsYWNlKCk7CisgICAgICAgIG1f Y3VybE11bHRpSGFuZGxlLT5zZXRNYXhDb25uZWN0cyhtX21heENvbm5lY3RzKTsKKyAgICAgICAg bV9jdXJsTXVsdGlIYW5kbGUtPnNldE1heFRvdGFsQ29ubmVjdGlvbnMobV9tYXhUb3RhbENvbm5l Y3Rpb25zKTsKKyAgICAgICAgbV9jdXJsTXVsdGlIYW5kbGUtPnNldE1heEhvc3RDb25uZWN0aW9u cyhtX21heEhvc3RDb25uZWN0aW9ucyk7CisgICAgfQogCiAgICAgd2hpbGUgKHRydWUpIHsKICAg ICAgICAgewpAQCAtMTU3LDI4ICsxNTgsOCBAQCB2b2lkIEN1cmxSZXF1ZXN0U2NoZWR1bGVyOjp3 b3JrZXJUaHJlYWQoKQogCiAgICAgICAgIGV4ZWN1dGVUYXNrcygpOwogCi0gICAgICAgIC8vIFJl dHJ5ICdzZWxlY3QnIGlmIGl0IHdhcyBpbnRlcnJ1cHRlZCBieSBhIHByb2Nlc3Mgc2lnbmFsLgot ICAgICAgICBpbnQgcmMgPSAwOwotICAgICAgICBkbyB7Ci0gICAgICAgICAgICBmZF9zZXQgZmRy ZWFkOwotICAgICAgICAgICAgZmRfc2V0IGZkd3JpdGU7Ci0gICAgICAgICAgICBmZF9zZXQgZmRl eGNlcDsKLSAgICAgICAgICAgIGludCBtYXhmZCA9IDA7Ci0KLSAgICAgICAgICAgIGNvbnN0IGlu dCBzZWxlY3RUaW1lb3V0TVMgPSA1OwotCi0gICAgICAgICAgICBzdHJ1Y3QgdGltZXZhbCB0aW1l b3V0OwotICAgICAgICAgICAgdGltZW91dC50dl9zZWMgPSAwOwotICAgICAgICAgICAgdGltZW91 dC50dl91c2VjID0gc2VsZWN0VGltZW91dE1TICogMTAwMDsgLy8gc2VsZWN0IHdhaXRzIG1pY3Jv c2Vjb25kcwotCi0gICAgICAgICAgICBtX2N1cmxNdWx0aUhhbmRsZS0+Z2V0RmRTZXQoZmRyZWFk LCBmZHdyaXRlLCBmZGV4Y2VwLCBtYXhmZCk7Ci0KLSAgICAgICAgICAgIC8vIFdoZW4gdGhlIDMg ZmlsZSBkZXNjcmlwdG9ycyBhcmUgZW1wdHksIHdpbnNvY2sgd2lsbCByZXR1cm4gLTEKLSAgICAg ICAgICAgIC8vIGFuZCBiYWlsIG91dCwgc3RvcHBpbmcgdGhlIGZpbGUgZG93bmxvYWQuIFNvIG1h a2Ugc3VyZSB3ZQotICAgICAgICAgICAgLy8gaGF2ZSB2YWxpZCBmaWxlIGRlc2NyaXB0b3JzIGJl Zm9yZSBjYWxsaW5nIHNlbGVjdC4KLSAgICAgICAgICAgIGlmIChtYXhmZCA+PSAwKQotICAgICAg ICAgICAgICAgIHJjID0gOjpzZWxlY3QobWF4ZmQgKyAxLCAmZmRyZWFkLCAmZmR3cml0ZSwgJmZk ZXhjZXAsICZ0aW1lb3V0KTsKLSAgICAgICAgfSB3aGlsZSAocmMgPT0gLTEgJiYgZXJybm8gPT0g RUlOVFIpOworICAgICAgICBjb25zdCBpbnQgc2VsZWN0VGltZW91dE1TID0gSU5UX01BWDsKKyAg ICAgICAgbV9jdXJsTXVsdGlIYW5kbGUtPnBvbGwoeyB9LCBzZWxlY3RUaW1lb3V0TVMpOwogCiAg ICAgICAgIGludCBhY3RpdmVDb3VudCA9IDA7CiAgICAgICAgIHdoaWxlIChtX2N1cmxNdWx0aUhh bmRsZS0+cGVyZm9ybShhY3RpdmVDb3VudCkgPT0gQ1VSTE1fQ0FMTF9NVUxUSV9QRVJGT1JNKSB7 IH0KQEAgLTE5NSwxMSArMTc2LDEyIEBAIHZvaWQgQ3VybFJlcXVlc3RTY2hlZHVsZXI6Ondvcmtl clRocmVhZCgpCiAgICAgICAgICAgICBpZiAoYXV0byBjbGllbnQgPSBtX2NsaWVudE1hcHMuaW5s aW5lR2V0KG1zZy0+ZWFzeV9oYW5kbGUpKQogICAgICAgICAgICAgICAgIGNvbXBsZXRlVHJhbnNm ZXIoY2xpZW50LCBtc2ctPmRhdGEucmVzdWx0KTsKICAgICAgICAgfQotCi0gICAgICAgIHN0b3BU aHJlYWRJZk5vTW9yZUpvYlJ1bm5pbmcoKTsKICAgICB9CiAKLSAgICBtX2N1cmxNdWx0aUhhbmRs ZSA9IG51bGxwdHI7CisgICAgeworICAgICAgICBMb2NrZXIgbG9ja2VyIHsgbV9tdWx0aUhhbmRs ZU11dGV4IH07CisgICAgICAgIG1fY3VybE11bHRpSGFuZGxlLnJlc2V0KCk7CisgICAgfQogfQog CiB2b2lkIEN1cmxSZXF1ZXN0U2NoZWR1bGVyOjpzdGFydFRyYW5zZmVyKEN1cmxSZXF1ZXN0U2No ZWR1bGVyQ2xpZW50KiBjbGllbnQpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9uZXR3b3JrL2N1cmwvQ3VybFJlcXVlc3RTY2hlZHVsZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvY3VybC9DdXJsUmVxdWVzdFNjaGVkdWxlci5oCmluZGV4IDRiOTVjMGQx OWFkOTA0MmQyYWM3MGVkNGIxMzNmOGQxZDBjNjMyYmYuLjk3NzUyOTUwMGE3ODY0ZDcwNGQ2MDRk YTY4NDZmOTU5OTllNGQ4NWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25l dHdvcmsvY3VybC9DdXJsUmVxdWVzdFNjaGVkdWxlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL25ldHdvcmsvY3VybC9DdXJsUmVxdWVzdFNjaGVkdWxlci5oCkBAIC01MSw4ICs1MSw4 IEBAIHB1YmxpYzoKICAgICB2b2lkIGNhbGxPbldvcmtlclRocmVhZChXVEY6OkZ1bmN0aW9uPHZv aWQoKT4mJik7CiAKIHByaXZhdGU6Ci0gICAgdm9pZCBzdGFydFRocmVhZElmTmVlZGVkKCk7Ci0g ICAgdm9pZCBzdG9wVGhyZWFkSWZOb01vcmVKb2JSdW5uaW5nKCk7CisgICAgdm9pZCBzdGFydE9y V2FrZVVwVGhyZWFkKCk7CisgICAgdm9pZCB3YWtlVXBUaHJlYWRJZlBvc3NpYmxlKCk7CiAgICAg dm9pZCBzdG9wVGhyZWFkKCk7CiAKICAgICB2b2lkIGV4ZWN1dGVUYXNrcygpOwpAQCAtNzIsNyAr NzIsOCBAQCBwcml2YXRlOgogICAgIEhhc2hTZXQ8Q3VybFJlcXVlc3RTY2hlZHVsZXJDbGllbnQq PiBtX2FjdGl2ZUpvYnM7CiAgICAgSGFzaE1hcDxDVVJMKiwgQ3VybFJlcXVlc3RTY2hlZHVsZXJD bGllbnQqPiBtX2NsaWVudE1hcHM7CiAKLSAgICBzdGQ6OnVuaXF1ZV9wdHI8Q3VybE11bHRpSGFu ZGxlPiBtX2N1cmxNdWx0aUhhbmRsZTsKKyAgICBMb2NrIG1fbXVsdGlIYW5kbGVNdXRleDsKKyAg ICBzdGQ6Om9wdGlvbmFsPEN1cmxNdWx0aUhhbmRsZT4gbV9jdXJsTXVsdGlIYW5kbGU7CiAKICAg ICBsb25nIG1fbWF4Q29ubmVjdHM7CiAgICAgbG9uZyBtX21heFRvdGFsQ29ubmVjdGlvbnM7Cg== 433656 2021-07-15 22:22:45 -0700 2021-07-16 08:22:56 -0700 Patch bug-227966-20210716142244.patch text/plain 8190 fujii U3VidmVyc2lvbiBSZXZpc2lvbjogMjc5OTc2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMWUxYTIyNThkZTY1ZmIz MDdiODUwN2IyYWFkYzFiODEwN2QwN2E2MC4uMjc4MWJmN2MzNTRlNWNiZmM0MTM4YTVmNjVmODhl N2ZiODQxNjdkNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDIxLTA3LTE1ICBGdWpp aSBIaXJvbm9yaSAgPEhpcm9ub3JpLkZ1amlpQHNvbnkuY29tPgorCisgICAgICAgIFtjdXJsXSBV c2UgY3VybF9tdWx0aV9wb2xsIGFuZCBjdXJsX211bHRpX3dha2V1cCBpbnN0ZWFkIG9mIHNlbGVj dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI3OTY2 CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgbGliY3Vy bCA3LjY4LjAgYWRkZWQgY3VybF9tdWx0aV9wb2xsIGFuZCBjdXJsX211bHRpX3dha2V1cC4KKwor ICAgICAgICAqIHBsYXRmb3JtL25ldHdvcmsvY3VybC9DdXJsQ29udGV4dC5jcHA6CisgICAgICAg IChXZWJDb3JlOjpDdXJsTXVsdGlIYW5kbGU6OnBvbGwpOiBBZGRlZC4KKyAgICAgICAgKFdlYkNv cmU6OkN1cmxNdWx0aUhhbmRsZTo6d2FrZVVwKTogQWRkZWQuCisgICAgICAgICogcGxhdGZvcm0v bmV0d29yay9jdXJsL0N1cmxDb250ZXh0Lmg6CisgICAgICAgICogcGxhdGZvcm0vbmV0d29yay9j dXJsL0N1cmxSZXF1ZXN0U2NoZWR1bGVyLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkN1cmxSZXF1 ZXN0U2NoZWR1bGVyOjphZGQpOgorICAgICAgICAoV2ViQ29yZTo6Q3VybFJlcXVlc3RTY2hlZHVs ZXI6OmNhbGxPbldvcmtlclRocmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpDdXJsUmVxdWVzdFNj aGVkdWxlcjo6c3RhcnRPcldha2VVcFRocmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpDdXJsUmVx dWVzdFNjaGVkdWxlcjo6d2FrZVVwVGhyZWFkSWZQb3NzaWJsZSk6CisgICAgICAgIChXZWJDb3Jl OjpDdXJsUmVxdWVzdFNjaGVkdWxlcjo6c3RvcFRocmVhZCk6CisgICAgICAgIChXZWJDb3JlOjpD dXJsUmVxdWVzdFNjaGVkdWxlcjo6d29ya2VyVGhyZWFkKToKKyAgICAgICAgKFdlYkNvcmU6OkN1 cmxSZXF1ZXN0U2NoZWR1bGVyOjpzdGFydFRocmVhZElmTmVlZGVkKTogRGVsZXRlZC4KKyAgICAg ICAgKFdlYkNvcmU6OkN1cmxSZXF1ZXN0U2NoZWR1bGVyOjpzdG9wVGhyZWFkSWZOb01vcmVKb2JS dW5uaW5nKTogRGVsZXRlZC4KKyAgICAgICAgKiBwbGF0Zm9ybS9uZXR3b3JrL2N1cmwvQ3VybFJl cXVlc3RTY2hlZHVsZXIuaDoKKwogMjAyMS0wNy0xNSAgSmVhbi1ZdmVzIEF2ZW5hcmQgIDxqeWFA YXBwbGUuY29tPgogCiAgICAgICAgIFtXazFdIG1lZGlhL21lZGlhLXNvdXJjZS9tZWRpYS13ZWJt LW9wdXMtcGFydGlhbC5odG1sIGlzIGEgY29uc2lzdGVudCBmYWlsdXJlIChFbmFibGUgVlA4L1ZQ OS9Wb3JiaXMvT3B1cyBpbiBXZWJLaXRMZWdhY3kpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvQ3VybENvbnRleHQuY3BwIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vbmV0d29yay9jdXJsL0N1cmxDb250ZXh0LmNwcAppbmRleCBhM2NhMDBkMGQyYjM2 NzIyMWM2NTRhNGYxMDBmMTM4OTY5Y2IwNmM4Li42MDg0MDZiODNlNTM5MmYyM2FlOTljYzljZjIw NjMyZDI1MzZjZDZhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3Jr L2N1cmwvQ3VybENvbnRleHQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdv cmsvY3VybC9DdXJsQ29udGV4dC5jcHAKQEAgLTI2Niw2ICsyNjYsMTcgQEAgQ1VSTE1jb2RlIEN1 cmxNdWx0aUhhbmRsZTo6Z2V0RmRTZXQoZmRfc2V0JiByZWFkRmRTZXQsIGZkX3NldCYgd3JpdGVG ZFNldCwgZmRfc2UKICAgICByZXR1cm4gY3VybF9tdWx0aV9mZHNldChtX211bHRpSGFuZGxlLCAm cmVhZEZkU2V0LCAmd3JpdGVGZFNldCwgJmV4Y0ZkU2V0LCAmbWF4RmQpOwogfQogCitDVVJMTWNv ZGUgQ3VybE11bHRpSGFuZGxlOjpwb2xsKGNvbnN0IFZlY3RvcjxjdXJsX3dhaXRmZD4mIGV4dHJh RmRzLCBpbnQgdGltZW91dE1TKQoreworICAgIGludCBudW1GZHMgPSAwOworICAgIHJldHVybiBj dXJsX211bHRpX3BvbGwobV9tdWx0aUhhbmRsZSwgY29uc3RfY2FzdDxjdXJsX3dhaXRmZCo+KGV4 dHJhRmRzLmRhdGEoKSksIGV4dHJhRmRzLnNpemUoKSwgdGltZW91dE1TLCAmbnVtRmRzKTsKK30K KworQ1VSTE1jb2RlIEN1cmxNdWx0aUhhbmRsZTo6d2FrZVVwKCkKK3sKKyAgICByZXR1cm4gY3Vy bF9tdWx0aV93YWtldXAobV9tdWx0aUhhbmRsZSk7Cit9CisKIENVUkxNY29kZSBDdXJsTXVsdGlI YW5kbGU6OnBlcmZvcm0oaW50JiBydW5uaW5nSGFuZGxlcykKIHsKICAgICByZXR1cm4gY3VybF9t dWx0aV9wZXJmb3JtKG1fbXVsdGlIYW5kbGUsICZydW5uaW5nSGFuZGxlcyk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvQ3VybENvbnRleHQuaCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL25ldHdvcmsvY3VybC9DdXJsQ29udGV4dC5oCmluZGV4IGVh MDBlOWQyYzlhYmRjMDQyNmY5NzcyZmU4MDYwODcwYmNlZDdmZTkuLmM1YTJmNmFkNTZiMmY5ZDk0 MjRkMzNkMmNhZjJmMDkzMmZiZTdkYmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvY3VybC9DdXJsQ29udGV4dC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL25ldHdvcmsvY3VybC9DdXJsQ29udGV4dC5oCkBAIC0xNzQsNiArMTc0LDggQEAgcHVibGlj OgogICAgIENVUkxNY29kZSByZW1vdmVIYW5kbGUoQ1VSTCopOwogCiAgICAgQ1VSTE1jb2RlIGdl dEZkU2V0KGZkX3NldCYsIGZkX3NldCYsIGZkX3NldCYsIGludCYpOworICAgIENVUkxNY29kZSBw b2xsKGNvbnN0IFZlY3RvcjxjdXJsX3dhaXRmZD4mLCBpbnQpOworICAgIENVUkxNY29kZSB3YWtl VXAoKTsKICAgICBDVVJMTWNvZGUgcGVyZm9ybShpbnQmKTsKICAgICBDVVJMTXNnKiByZWFkSW5m byhpbnQmKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9j dXJsL0N1cmxSZXF1ZXN0U2NoZWR1bGVyLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL25l dHdvcmsvY3VybC9DdXJsUmVxdWVzdFNjaGVkdWxlci5jcHAKaW5kZXggNGEyMDVmOGIwZTBkYWE2 ZjA4M2U4ODkwOThhNzMzMmU3MmZmZjJkMS4uMGQ0ODYwOTk5YTAzMDY3NTE3MDc3NzRmNjg2Nzcy YzBmMzU1NzY1MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vbmV0d29yay9j dXJsL0N1cmxSZXF1ZXN0U2NoZWR1bGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9uZXR3b3JrL2N1cmwvQ3VybFJlcXVlc3RTY2hlZHVsZXIuY3BwCkBAIC00OSw3ICs0OSw3IEBA IGJvb2wgQ3VybFJlcXVlc3RTY2hlZHVsZXI6OmFkZChDdXJsUmVxdWVzdFNjaGVkdWxlckNsaWVu dCogY2xpZW50KQogICAgICAgICByZXR1cm4gZmFsc2U7CiAKICAgICBzdGFydFRyYW5zZmVyKGNs aWVudCk7Ci0gICAgc3RhcnRUaHJlYWRJZk5lZWRlZCgpOworICAgIHN0YXJ0T3JXYWtlVXBUaHJl YWQoKTsKIAogICAgIHJldHVybiB0cnVlOwogfQpAQCAtNzEsMTcgKzcxLDE5IEBAIHZvaWQgQ3Vy bFJlcXVlc3RTY2hlZHVsZXI6OmNhbGxPbldvcmtlclRocmVhZChXVEY6OkZ1bmN0aW9uPHZvaWQo KT4mJiB0YXNrKQogICAgICAgICBtX3Rhc2tRdWV1ZS5hcHBlbmQoV1RGTW92ZSh0YXNrKSk7CiAg ICAgfQogCi0gICAgc3RhcnRUaHJlYWRJZk5lZWRlZCgpOworICAgIHN0YXJ0T3JXYWtlVXBUaHJl YWQoKTsKIH0KIAotdm9pZCBDdXJsUmVxdWVzdFNjaGVkdWxlcjo6c3RhcnRUaHJlYWRJZk5lZWRl ZCgpCit2b2lkIEN1cmxSZXF1ZXN0U2NoZWR1bGVyOjpzdGFydE9yV2FrZVVwVGhyZWFkKCkKIHsK ICAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOwogCiAgICAgewogICAgICAgICBMb2NrZXIgbG9j a2VyIHsgbV9tdXRleCB9OwotICAgICAgICBpZiAobV9ydW5UaHJlYWQpCisgICAgICAgIGlmICht X3J1blRocmVhZCkgeworICAgICAgICAgICAgd2FrZVVwVGhyZWFkSWZQb3NzaWJsZSgpOwogICAg ICAgICAgICAgcmV0dXJuOworICAgICAgICB9CiAgICAgfQogCiAgICAgaWYgKG1fdGhyZWFkKQpA QCAtOTQsMTIgKzk2LDE4IEBAIHZvaWQgQ3VybFJlcXVlc3RTY2hlZHVsZXI6OnN0YXJ0VGhyZWFk SWZOZWVkZWQoKQogCiAgICAgbV90aHJlYWQgPSBUaHJlYWQ6OmNyZWF0ZSgiY3VybFRocmVhZCIs IFt0aGlzXSB7CiAgICAgICAgIHdvcmtlclRocmVhZCgpOwotCi0gICAgICAgIExvY2tlciBsb2Nr ZXIgeyBtX211dGV4IH07Ci0gICAgICAgIG1fcnVuVGhyZWFkID0gZmFsc2U7CiAgICAgfSwgVGhy ZWFkVHlwZTo6TmV0d29yayk7CiB9CiAKK3ZvaWQgQ3VybFJlcXVlc3RTY2hlZHVsZXI6Ondha2VV cFRocmVhZElmUG9zc2libGUoKQoreworICAgIExvY2tlciBsb2NrZXIgeyBtX211bHRpSGFuZGxl TXV0ZXggfTsKKyAgICBpZiAoIW1fY3VybE11bHRpSGFuZGxlKQorICAgICAgICByZXR1cm47CisK KyAgICBtX2N1cmxNdWx0aUhhbmRsZS0+d2FrZVVwKCk7Cit9CisKIHZvaWQgQ3VybFJlcXVlc3RT Y2hlZHVsZXI6OnN0b3BUaHJlYWRJZk5vTW9yZUpvYlJ1bm5pbmcoKQogewogICAgIEFTU0VSVCgh aXNNYWluVGhyZWFkKCkpOwpAQCAtMTE5LDYgKzEyNyw3IEBAIHZvaWQgQ3VybFJlcXVlc3RTY2hl ZHVsZXI6OnN0b3BUaHJlYWQoKQogICAgIH0KIAogICAgIGlmIChtX3RocmVhZCkgeworICAgICAg ICB3YWtlVXBUaHJlYWRJZlBvc3NpYmxlKCk7CiAgICAgICAgIG1fdGhyZWFkLT53YWl0Rm9yQ29t cGxldGlvbigpOwogICAgICAgICBtX3RocmVhZCA9IG51bGxwdHI7CiAgICAgfQpAQCAtMTQzLDEw ICsxNTIsMTMgQEAgdm9pZCBDdXJsUmVxdWVzdFNjaGVkdWxlcjo6d29ya2VyVGhyZWFkKCkKIHsK ICAgICBBU1NFUlQoIWlzTWFpblRocmVhZCgpKTsKIAotICAgIG1fY3VybE11bHRpSGFuZGxlID0g bWFrZVVuaXF1ZTxDdXJsTXVsdGlIYW5kbGU+KCk7Ci0gICAgbV9jdXJsTXVsdGlIYW5kbGUtPnNl dE1heENvbm5lY3RzKG1fbWF4Q29ubmVjdHMpOwotICAgIG1fY3VybE11bHRpSGFuZGxlLT5zZXRN YXhUb3RhbENvbm5lY3Rpb25zKG1fbWF4VG90YWxDb25uZWN0aW9ucyk7Ci0gICAgbV9jdXJsTXVs dGlIYW5kbGUtPnNldE1heEhvc3RDb25uZWN0aW9ucyhtX21heEhvc3RDb25uZWN0aW9ucyk7Cisg ICAgeworICAgICAgICBMb2NrZXIgbG9ja2VyIHsgbV9tdWx0aUhhbmRsZU11dGV4IH07CisgICAg ICAgIG1fY3VybE11bHRpSGFuZGxlLmVtcGxhY2UoKTsKKyAgICAgICAgbV9jdXJsTXVsdGlIYW5k bGUtPnNldE1heENvbm5lY3RzKG1fbWF4Q29ubmVjdHMpOworICAgICAgICBtX2N1cmxNdWx0aUhh bmRsZS0+c2V0TWF4VG90YWxDb25uZWN0aW9ucyhtX21heFRvdGFsQ29ubmVjdGlvbnMpOworICAg ICAgICBtX2N1cmxNdWx0aUhhbmRsZS0+c2V0TWF4SG9zdENvbm5lY3Rpb25zKG1fbWF4SG9zdENv bm5lY3Rpb25zKTsKKyAgICB9CiAKICAgICB3aGlsZSAodHJ1ZSkgewogICAgICAgICB7CkBAIC0x NTcsMjggKzE2OSw4IEBAIHZvaWQgQ3VybFJlcXVlc3RTY2hlZHVsZXI6OndvcmtlclRocmVhZCgp CiAKICAgICAgICAgZXhlY3V0ZVRhc2tzKCk7CiAKLSAgICAgICAgLy8gUmV0cnkgJ3NlbGVjdCcg aWYgaXQgd2FzIGludGVycnVwdGVkIGJ5IGEgcHJvY2VzcyBzaWduYWwuCi0gICAgICAgIGludCBy YyA9IDA7Ci0gICAgICAgIGRvIHsKLSAgICAgICAgICAgIGZkX3NldCBmZHJlYWQ7Ci0gICAgICAg ICAgICBmZF9zZXQgZmR3cml0ZTsKLSAgICAgICAgICAgIGZkX3NldCBmZGV4Y2VwOwotICAgICAg ICAgICAgaW50IG1heGZkID0gMDsKLQotICAgICAgICAgICAgY29uc3QgaW50IHNlbGVjdFRpbWVv dXRNUyA9IDU7Ci0KLSAgICAgICAgICAgIHN0cnVjdCB0aW1ldmFsIHRpbWVvdXQ7Ci0gICAgICAg ICAgICB0aW1lb3V0LnR2X3NlYyA9IDA7Ci0gICAgICAgICAgICB0aW1lb3V0LnR2X3VzZWMgPSBz ZWxlY3RUaW1lb3V0TVMgKiAxMDAwOyAvLyBzZWxlY3Qgd2FpdHMgbWljcm9zZWNvbmRzCi0KLSAg ICAgICAgICAgIG1fY3VybE11bHRpSGFuZGxlLT5nZXRGZFNldChmZHJlYWQsIGZkd3JpdGUsIGZk ZXhjZXAsIG1heGZkKTsKLQotICAgICAgICAgICAgLy8gV2hlbiB0aGUgMyBmaWxlIGRlc2NyaXB0 b3JzIGFyZSBlbXB0eSwgd2luc29jayB3aWxsIHJldHVybiAtMQotICAgICAgICAgICAgLy8gYW5k IGJhaWwgb3V0LCBzdG9wcGluZyB0aGUgZmlsZSBkb3dubG9hZC4gU28gbWFrZSBzdXJlIHdlCi0g ICAgICAgICAgICAvLyBoYXZlIHZhbGlkIGZpbGUgZGVzY3JpcHRvcnMgYmVmb3JlIGNhbGxpbmcg c2VsZWN0LgotICAgICAgICAgICAgaWYgKG1heGZkID49IDApCi0gICAgICAgICAgICAgICAgcmMg PSA6OnNlbGVjdChtYXhmZCArIDEsICZmZHJlYWQsICZmZHdyaXRlLCAmZmRleGNlcCwgJnRpbWVv dXQpOwotICAgICAgICB9IHdoaWxlIChyYyA9PSAtMSAmJiBlcnJubyA9PSBFSU5UUik7CisgICAg ICAgIGNvbnN0IGludCBzZWxlY3RUaW1lb3V0TVMgPSBJTlRfTUFYOworICAgICAgICBtX2N1cmxN dWx0aUhhbmRsZS0+cG9sbCh7IH0sIHNlbGVjdFRpbWVvdXRNUyk7CiAKICAgICAgICAgaW50IGFj dGl2ZUNvdW50ID0gMDsKICAgICAgICAgd2hpbGUgKG1fY3VybE11bHRpSGFuZGxlLT5wZXJmb3Jt KGFjdGl2ZUNvdW50KSA9PSBDVVJMTV9DQUxMX01VTFRJX1BFUkZPUk0pIHsgfQpAQCAtMTk5LDcg KzE5MSwxMCBAQCB2b2lkIEN1cmxSZXF1ZXN0U2NoZWR1bGVyOjp3b3JrZXJUaHJlYWQoKQogICAg ICAgICBzdG9wVGhyZWFkSWZOb01vcmVKb2JSdW5uaW5nKCk7CiAgICAgfQogCi0gICAgbV9jdXJs TXVsdGlIYW5kbGUgPSBudWxscHRyOworICAgIHsKKyAgICAgICAgTG9ja2VyIGxvY2tlciB7IG1f bXVsdGlIYW5kbGVNdXRleCB9OworICAgICAgICBtX2N1cmxNdWx0aUhhbmRsZS5yZXNldCgpOwor ICAgIH0KIH0KIAogdm9pZCBDdXJsUmVxdWVzdFNjaGVkdWxlcjo6c3RhcnRUcmFuc2ZlcihDdXJs UmVxdWVzdFNjaGVkdWxlckNsaWVudCogY2xpZW50KQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vbmV0d29yay9jdXJsL0N1cmxSZXF1ZXN0U2NoZWR1bGVyLmggYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvQ3VybFJlcXVlc3RTY2hlZHVsZXIuaAppbmRl eCA0Yjk1YzBkMTlhZDkwNDJkMmFjNzBlZDRiMTMzZjhkMWQwYzYzMmJmLi4yMzg5OWQ0ZGRkNjEx NjhjNjk4YmU0ZDQzMzQ1NTE1NWM0M2M1OGIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9uZXR3b3JrL2N1cmwvQ3VybFJlcXVlc3RTY2hlZHVsZXIuaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9uZXR3b3JrL2N1cmwvQ3VybFJlcXVlc3RTY2hlZHVsZXIuaApAQCAt NTEsNyArNTEsOCBAQCBwdWJsaWM6CiAgICAgdm9pZCBjYWxsT25Xb3JrZXJUaHJlYWQoV1RGOjpG dW5jdGlvbjx2b2lkKCk+JiYpOwogCiBwcml2YXRlOgotICAgIHZvaWQgc3RhcnRUaHJlYWRJZk5l ZWRlZCgpOworICAgIHZvaWQgc3RhcnRPcldha2VVcFRocmVhZCgpOworICAgIHZvaWQgd2FrZVVw VGhyZWFkSWZQb3NzaWJsZSgpOwogICAgIHZvaWQgc3RvcFRocmVhZElmTm9Nb3JlSm9iUnVubmlu ZygpOwogICAgIHZvaWQgc3RvcFRocmVhZCgpOwogCkBAIC03Miw3ICs3Myw4IEBAIHByaXZhdGU6 CiAgICAgSGFzaFNldDxDdXJsUmVxdWVzdFNjaGVkdWxlckNsaWVudCo+IG1fYWN0aXZlSm9iczsK ICAgICBIYXNoTWFwPENVUkwqLCBDdXJsUmVxdWVzdFNjaGVkdWxlckNsaWVudCo+IG1fY2xpZW50 TWFwczsKIAotICAgIHN0ZDo6dW5pcXVlX3B0cjxDdXJsTXVsdGlIYW5kbGU+IG1fY3VybE11bHRp SGFuZGxlOworICAgIExvY2sgbV9tdWx0aUhhbmRsZU11dGV4OworICAgIHN0ZDo6b3B0aW9uYWw8 Q3VybE11bHRpSGFuZGxlPiBtX2N1cmxNdWx0aUhhbmRsZTsKIAogICAgIGxvbmcgbV9tYXhDb25u ZWN0czsKICAgICBsb25nIG1fbWF4VG90YWxDb25uZWN0aW9uczsK