232580 2021-11-01 14:13:42 -0700 [GPU Process] Rendering backend may stop processing IPC stream messages after a sync message timeout 2021-11-04 09:24:02 -0700 1 1 1 Unclassified WebKit WebKit2 WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 wenson_hsieh wenson_hsieh cdumez kkinnunen thorton webkit-bug-importer oldest_to_newest 1810867 0 wenson_hsieh 2021-11-01 14:13:42 -0700 It's possible for RemoteRenderingBackend's IPC stream to stop processing altogether after the web process times out when sending a synchronous stream message to the GPU Process. To reproduce, (1) modify a sync message to RRB such that it intentionally times out (here, I made it so that we only time out every other call). diff --git a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp index b664d8e37640..c4980ea4df71 100644 --- a/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp +++ b/Source/WebKit/GPUProcess/graphics/RemoteRenderingBackend.cpp @@ -284,6 +284,9 @@ void RemoteRenderingBackend::getDataForImageBufferWithQualifiedIdentifier(const Vector<uint8_t> data; if (auto imageBuffer = m_remoteResourceCache.cachedImageBuffer(renderingResourceIdentifier)) data = imageBuffer->toData(mimeType, quality); + static bool shouldSleep = false; + if (shouldSleep) sleep(1.5_s); + shouldSleep = !shouldSleep; completionHandler(WTFMove(data)); } (2) Then go to https://whsieh.github.io/examples/canvas-to-blob and click the "Change color" button twice. The GPU Process should hang the first time, but then recover and (correctly) change color the second time. Instead, it currently hangs after the first click, and then stops processing incoming stream messages entirely. 1810900 1 wenson_hsieh 2021-11-01 15:07:18 -0700 (In debug builds, we actually hit this assertion:) ``` if (!currentReceiver) { // Valid scenario is when receiver has been removed, but there are messages for it in the buffer. // FIXME: Since we do not have a receiver, we don't know how to decode the message. // This means we must timeout every receiver in the stream connection. // Currently we assert that the receivers are empty, as we only have up to one receiver in // a stream connection until possibility of skipping is implemented properly. Locker locker { m_receiversLock }; ASSERT(m_receivers.isEmpty()); return DispatchResult::HasNoMessages; } ``` …because the currentReceiverName is `IPC`, but the destination is equal that of the `RemoteRenderingBackend`, and the message name itself is `SyncMessageReply`. What's happening is: 1. Client sends the sync message (RemoteRenderingBackend::GetDataForImageBuffer, in this case). Client then begins waiting for a response under `tryAcquireAll()`. 2. Server receives this message but does not reply in time. 3. About a second later, the client times out while waiting in `tryAcquireAll()`, failing the `sendSync()`. Soon afterwards, it sends the next stream message and blocks on `clientWaitSemaphore()` inside `tryAcquire`. 4. Server finally finishes processing `GetDataForImageBuffer` and goes to write SyncMessageReply at offset 0. Note that WP has already given up on waiting this reply in (3). Server then signals the client waiting semaphore. 5. Client writes the new stream message after the SyncMessageReply. 6. Server runs its processing loop from 0, decodes the SyncMessageReply that it just wrote. It then fails to find a suitable message receiver for this message and exits the processing loop early. 1811055 2 kkinnunen 2021-11-02 01:22:33 -0700 Yeah. The design is so that timeouts do not make sense. If WP asks to draw a 4k x 4k image, and that never completes, there's nothing sensible you can do except restart the GPU process. The rationale: We define timeout as X seconds, e.g. if message is not replied within X seconds, we declare the GPU process has hung. You send message. The message times out. What do you do now? A) Maybe GPUP has not hung, we should be able to retry something like 3 times - If the GPUP has not hung, why did you define "GPUP is hung if timeout X seconds"? - I still want to retry 3 times - Why did you not define "GPUP is hung if timeout is 3*X seconds"? What does the retry contribute here? - ... B) We did define X sec timeout means GPU process has hung, so GPU process has hung. Restart it. "Retry" or "carry on like nothing happened and hope for the best" is ok if the medium is such that it's expected that messages get lost, like a network. IPC isn't like that, nothing should be lost by design. 1811120 3 wenson_hsieh 2021-11-02 08:28:20 -0700 (In reply to Kimmo Kinnunen from comment #2) > Yeah. > The design is so that timeouts do not make sense. > > If WP asks to draw a 4k x 4k image, and that never completes, there's > nothing sensible you can do except restart the GPU process. > > The rationale: > We define timeout as X seconds, e.g. if message is not replied within X > seconds, we declare the GPU process has hung. > > You send message. > The message times out. > What do you do now? > > A) Maybe GPUP has not hung, we should be able to retry something like 3 times > - If the GPUP has not hung, why did you define "GPUP is hung if timeout X > seconds"? > - I still want to retry 3 times > - Why did you not define "GPUP is hung if timeout is 3*X seconds"? What > does the > retry contribute here? > - ... Agreed! Implementing some kind of retry policy is redundant with timeouts in the first place, since the timeout is arbitrary anyways. > > B) We did define X sec timeout means GPU process has hung, so GPU process > has hung. Restart it. That said, it's critical that a web process does not have the capability to cause the GPU Process to "restart" arbitrarily, as the client is untrusted. We wouldn't want a compromised web process to be able to effectively kill and relaunch the GPU Process in a loop. Now that I think about it more, I believe there's a third option (C) here, which is to simply remove the timeout and just use Seconds::infinity() for these sync messages. The client (web process) trusts the server (GPU process) to be able to handle incoming drawing commands, and knows that it's only a matter of time until the GPU Process either: [1] ..finishes executing the command and sends the reply, in which case the `sendSync()` succeeds or [2] ..jetsams or crashes in the process, in which case the `sendSync()` fails and we just carry on in the web process > > > "Retry" or "carry on like nothing happened and hope for the best" is ok if > the medium is such that it's expected that messages get lost, like a > network. IPC isn't like that, nothing should be lost by design. 1811125 4 wenson_hsieh 2021-11-02 08:36:07 -0700 (In reply to Wenson Hsieh from comment #3) > (In reply to Kimmo Kinnunen from comment #2) > > Yeah. > > The design is so that timeouts do not make sense. > > > > If WP asks to draw a 4k x 4k image, and that never completes, there's > > nothing sensible you can do except restart the GPU process. > > > > The rationale: > > We define timeout as X seconds, e.g. if message is not replied within X > > seconds, we declare the GPU process has hung. > > > > You send message. > > The message times out. > > What do you do now? > > > > A) Maybe GPUP has not hung, we should be able to retry something like 3 times > > - If the GPUP has not hung, why did you define "GPUP is hung if timeout X > > seconds"? > > - I still want to retry 3 times > > - Why did you not define "GPUP is hung if timeout is 3*X seconds"? What > > does the > > retry contribute here? > > - ... > > Agreed! Implementing some kind of retry policy is redundant with timeouts in > the first place, since the timeout is arbitrary anyways. > > > > > B) We did define X sec timeout means GPU process has hung, so GPU process > > has hung. Restart it. > > That said, it's critical that a web process does not have the capability to > cause the GPU Process to "restart" arbitrarily, as the client is untrusted. > We wouldn't want a compromised web process to be able to effectively kill > and relaunch the GPU Process in a loop. > > Now that I think about it more, I believe there's a third option (C) here, > which is to simply remove the timeout and just use Seconds::infinity() for > these sync messages. The client (web process) trusts the server (GPU > process) to be able to handle incoming drawing commands, and knows that it's > only a matter of time until the GPU Process either: > [1] ..finishes executing the command and sends the reply, in which case > the `sendSync()` succeeds or > [2] ..jetsams or crashes in the process, in which case the `sendSync()` > fails and we just carry on in the web process I should also note — using an ∞ timeout is also how most of the regular `IPC::Connection::sendSync()` calls from the web process to the UI process work, and the trust model between the web and UI process is pretty much the same as the trust model between the web and GPU process. The notion of a sync IPC timeout is really only useful in the other direction (UI -> web, or more generally "trusted" -> "untrusted"), since any sync IPC in this direction (1) will prevent the trusted process from doing anything else in the meantime, and (2) is not guaranteed to complete in a timely manner. > > > > > > > "Retry" or "carry on like nothing happened and hope for the best" is ok if > > the medium is such that it's expected that messages get lost, like a > > network. IPC isn't like that, nothing should be lost by design. 1811195 5 443113 wenson_hsieh 2021-11-02 11:16:48 -0700 Created attachment 443113 For EWS 1811557 6 wenson_hsieh 2021-11-03 11:38:05 -0700 I think we should consider adjusting our web -> GPUP IPC timeout policy in a followup — there might be some reasons to remove the timeout (which would match the behavior of most sync messages from web -> UI process), but there might also be advantages to preserving the timeout since (in theory) it may be better for some synchronous canvas APIs like `toDataURL()` to fail gracefully instead of hanging the web process forever. In any case, I think this adjustment is a fairly safe and straightforward way to mitigate this source of instability. 1811583 7 443113 kkinnunen 2021-11-03 12:23:53 -0700 Comment on attachment 443113 For EWS View in context: https://bugs.webkit.org/attachment.cgi?id=443113&action=review > In summary, the sync IPC timeout causes us to enter a state where the web process continues to encode messages .. > To fix this, we simply keep the client offset in sync with the server offset in the case of a sync message I'm a bit torn about this change. It's not really consistent to say: A) It is programming error to send messages after a timeout B) I'm fixing an issue that happens when I send messages after a timeout The connection state is not well-defined after timeout. Primarily the timeout means the GPU process receiver is broken. If it was not broken, it'd make sense to wait longer. > Source/WebKit/Platform/IPC/StreamClientConnection.h:291 > // If the transaction commits, server is guaranteed to signal. The comment above says: // This would mean we try to send messages after a timeout. It is a programming error. 1811584 8 kkinnunen 2021-11-03 12:26:41 -0700 > synchronous canvas APIs like `toDataURL()` to fail gracefully instead of hanging the web process forever. But what's the graceful method to do that? I think UI should stop the web page that hangs and show "web page crashed" dialog. 1811585 9 wenson_hsieh 2021-11-03 12:30:24 -0700 (In reply to Kimmo Kinnunen from comment #7) > Comment on attachment 443113 [details] > For EWS > > View in context: > https://bugs.webkit.org/attachment.cgi?id=443113&action=review > > > In summary, the sync IPC timeout causes us to enter a state where the web process continues to encode messages > .. > > To fix this, we simply keep the client offset in sync with the server offset in the case of a sync message > > I'm a bit torn about this change. > It's not really consistent to say: > A) It is programming error to send messages after a timeout > B) I'm fixing an issue that happens when I send messages after a timeout Perhaps this is true of timeouts when waiting in tryAcquire(), but it seems that timing out doesn't leave us in a bad state in tryAcquireAll() (i.e. in the case of sync IPC), with the exception of the client offset not being reset. Can we just adjust this comment to be more precise? > > The connection state is not well-defined after timeout. > Primarily the timeout means the GPU process receiver is broken. > If it was not broken, it'd make sense to wait longer. > > > Source/WebKit/Platform/IPC/StreamClientConnection.h:291 > > // If the transaction commits, server is guaranteed to signal. > > The comment above says: > // This would mean we try to send messages after a timeout. It is a > programming error. 1811593 10 wenson_hsieh 2021-11-03 12:42:47 -0700 (In reply to Kimmo Kinnunen from comment #8) > > synchronous canvas APIs like `toDataURL()` to fail gracefully instead of hanging the web process forever. > > But what's the graceful method to do that? I think UI should stop the web > page that hangs and show "web page crashed" dialog. I think some APIs (like getImageData) will simply return null, in the case of timeouts. After chatting with thorton, I now think that my original approach might be better (i.e. just remove the timeout in these circumstances), since we don't know if the results of this API are going to be (for instance) uploaded and stored on a server, or something. That said, I don't think there's any tangible downside to the tweak in https://bugs.webkit.org/attachment.cgi?id=443113&action=review. Perhaps we could still consider that change, but in a separate bug? 1811607 11 443228 wenson_hsieh 2021-11-03 12:59:57 -0700 Created attachment 443228 For EWS 1811637 12 443228 thorton 2021-11-03 13:36:37 -0700 Comment on attachment 443228 For EWS Kimmo's comments (mostly #c2) suggest he's OK with this approach too, if I'm reading them right. It certainly makes sense to me. 1811664 13 443228 wenson_hsieh 2021-11-03 14:51:27 -0700 Comment on attachment 443228 For EWS Thanks for the review! 1811678 14 ews-feeder 2021-11-03 15:03:13 -0700 Committed r285233 (243854@main): <https://commits.webkit.org/243854@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 443228. 1811679 15 webkit-bug-importer 2021-11-03 15:04:18 -0700 <rdar://problem/84993628> 1811796 16 kkinnunen 2021-11-04 02:11:24 -0700 (In reply to Wenson Hsieh from comment #10) > That said, I don't think there's any tangible downside to the tweak in > https://bugs.webkit.org/attachment.cgi?id=443113&action=review. Perhaps we > could still consider that change, but in a separate bug? When sync message is put to the buffer, it is as if sender says to the receiver: "You now own the whole buffer. My message starts at the offset you expect it to start." When sync message is confirmed to be completed, it is as if receiver says to the sender: "I just processed your message. You now own the whole buffer. My reply starts at offset 0." So if you don't get the completion confirmation, the receiver still owns the buffer. Sender cannot just start overwriting data and expect correct operation. If we were able to do this, what would be the point in waiting for sync completion in the first place? Also, correcting the senders local offset variable is not the full solution. The shared state is still left in undefined state. The local offset variable can be only modified based on the state of the shared variables, interpreted with the communication protocol rules. Also, correcting any state is pointless, as timeout means the receiver has gone broken. 1811797 17 kkinnunen 2021-11-04 02:21:40 -0700 > So if you don't get the completion confirmation, the receiver still owns the buffer. Sender cannot just start overwriting data and expect correct operation. Concrete example of receiver speed, workload and timeout duration mismatch: 1) Sender sends sync message asking for image data. 2) This times out. 3) Sender reset the local client offset to 0. 4a) Sender then send normal drawImage by writing 50 bytes that to index 0. 4b) At the same time, the receiver replies to the message in 1) by writing the 100kb image data to index 0. It doesn't work. > Also, correcting any state is pointless, as timeout means the receiver has gone broken. Concrete example of a receiver bug: 1) Sender sends sync message asking for image data. 2) This times out. 3) Sender reset the local client offset to 0. 4a) Sender then send normal drawImage by writing 50 bytes that to index 0. 5) Receiver does not receive the drawImage, because it has hung somewhere earlier, as indicated first by 2). So calls either complete or the receiver is invalid. 1811875 18 wenson_hsieh 2021-11-04 09:24:02 -0700 (In reply to Kimmo Kinnunen from comment #17) > > So if you don't get the completion confirmation, the receiver still owns the buffer. Sender cannot just start overwriting data and expect correct operation. > > Concrete example of receiver speed, workload and timeout duration mismatch: > 1) Sender sends sync message asking for image data. > 2) This times out. > 3) Sender reset the local client offset to 0. > 4a) Sender then send normal drawImage by writing 50 bytes that to index 0. > 4b) At the same time, the receiver replies to the message in 1) by writing > the 100kb image data to index 0. > > It doesn't work. In practice (at least, when I tested locally yesterday), this is not what happens because in step (4a) the sender will wait for the receiver to `releaseAll()` under `tryAcquire()`. So the receiver will first write the 100KB data to 0, and *then* the sender will write its data on top of that at offset 0. > > > > Also, correcting any state is pointless, as timeout means the receiver has gone broken. > > Concrete example of a receiver bug: > 1) Sender sends sync message asking for image data. > 2) This times out. > 3) Sender reset the local client offset to 0. > 4a) Sender then send normal drawImage by writing 50 bytes that to index 0. > 5) Receiver does not receive the drawImage, because it has hung somewhere > earlier, as indicated first by 2). > > So calls either complete or the receiver is invalid. In the case where the receiver is "invalid" (presumably, hanging?), I don't think anything we can do on the sender really matters. It should probably be up to the UI process to detect this and restart the GPU Process, in this circumstance. 443113 2021-11-02 11:16:48 -0700 2021-11-03 12:59:55 -0700 For EWS bug-232580-20211102111647.patch text/plain 6216 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjg1MDgzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IGJiOGZkZDAxY2MyM2MwNzZl M2NiOGQzYjU0MjEyYWJkNTI5ZDBhY2IuLjY4Nzc0NTM3Y2ViNzFkYmIzMGIyNTA2NDhhNjVkMDlm MTdkMmQ5OTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNTQgQEAKKzIwMjEtMTEtMDIgIFdlbnNvbiBI c2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgW0dQVSBQcm9jZXNzXSBS ZW5kZXJpbmcgYmFja2VuZCBtYXkgc3RvcCBwcm9jZXNzaW5nIElQQyBzdHJlYW0gbWVzc2FnZXMg YWZ0ZXIgYSBzeW5jIG1lc3NhZ2UgdGltZW91dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjMyNTgwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgQ3VycmVudGx5LCBpdCdzIHBvc3NpYmxlIGZvciBzeW5jIElQ QyBtZXNzYWdlcyB0aGF0IGFyZSBzZW50IHRocm91Z2ggSVBDIHN0cmVhbXMgdG8gdGltZSBvdXQg YW5kIHN1YnNlcXVlbnRseQorICAgICAgICBjYXVzZSB0aGUgSVBDIHN0cmVhbSBzZXJ2ZXIgKGUu Zy4gUmVtb3RlUmVuZGVyaW5nQmFja2VuZCkgdG8gc3RvcCBwcm9jZXNzaW5nIElQQyBzdHJlYW0g bWVzc2FnZXMgYWx0b2dldGhlci4gVGhlCisgICAgICAgIGZvbGxvd2luZyBleGFtcGxlIGlsbHVz dHJhdGVzIGhvdyB0aGlzIG1pZ2h0IGhhcHBlbjoKKworICAgICAgICAxLiAgICAgIFdlYiBwcm9j ZXNzIHNlbmRzIHRoZSBzeW5jIG1lc3NhZ2UgYXQgb2Zmc2V0IGBuYCAocmVsYXRpdmUgdG8gdGhl IHN0YXJ0IG9mIHRoZSByaW5nIGJ1ZmZlcikuCisgICAgICAgICAgICAgICAgV2ViIHByb2Nlc3Mg dGhlbiBiZWdpbnMgdG8gd2FpdCBmb3IgdGhlIHN5bmMgc3RyZWFtIHJlc3BvbnNlIHVuZGVyIGB0 cnlBY3F1aXJlQWxsKClgLgorCisgICAgICAgIDIuICAgICAgR1BVIHByb2Nlc3MgcmVjZWl2ZXMg dGhlIHN5bmMgbWVzc2FnZSwgYW5kIHRha2VzIGEgd2hpbGUgKD4gMSBzZWMuKSBhdHRlbXB0aW5n IHRvIGRpc3BhdGNoIGl0LgorCisgICAgICAgIDMuICAgICAgTWVhbndoaWxlIGluIHRoZSB3ZWIg cHJvY2Vzcywgd2UgaGl0IHRoZSBJUEMgdGltZW91dCBhbmQgYmFpbCBmcm9tIGB0cnlBY3F1aXJl QWxsKClgLiBUaGUgY2xpZW50IG9mZnNldAorICAgICAgICAgICAgICAgIGlzIHN0aWxsIGF0IGBu YC4gU2hvcnRseSBhZnRlcndhcmRzLCB0aGUgd2ViIHByb2Nlc3MgdHJpZXMgdG8gc2VuZCBhIHJl Z3VsYXIgc3RyZWFtIG1lc3NhZ2UsIGNhbGxpbmcKKyAgICAgICAgICAgICAgICBgdHJ5QWNxdWly ZSgpYCBhbmQgd2FpdGluZyBmb3IgdGhlIGNsaWVudCBzZW1hcGhvcmUgdG8gYmUgc2lnbmFsZWQu CisKKyAgICAgICAgNC4gICAgICBUaGUgR1BVIHByb2Nlc3MgZmluYWxseSBmaW5pc2hlcyBkaXNw YXRjaGluZyB0aGUgc3luYyBtZXNzYWdlIGZyb20gKDIpLCBzZW5kcyBhIHN5bmMgcmVwbHkgKHVu YXdhcmUgdGhhdAorICAgICAgICAgICAgICAgIHRoZSB3ZWIgcHJvY2VzcyBoYXMgYWxyZWFkeSBn aXZlbiB1cCB3YWl0aW5nKSwgYW5kIGZpbmFsbHkgY2FsbHMgYHJlbGVhc2VBbGwoKWAsIHNpZ25h bGluZyB0aGUgY2xpZW50CisgICAgICAgICAgICAgICAgc2VtYXBob3JlLiBUaGUgc2VydmVyIG9m ZnNldCBpcyB0aGVuIHJlc2V0IGJhY2sgdG8gMC4KKworICAgICAgICA1LiAgICAgIFRoZSB3ZWIg cHJvY2VzcyBmaW5pc2hlcyB3YWl0aW5nLCByZXR1cm5zIGZyb20gYHRyeUFjcXVpcmUoKWAsIHBy b2NlZWRzIHRvIHdyaXRlIHRoZSBuZXcgc3RyZWFtCisgICAgICAgICAgICAgICAgbWVzc2FnZSBh ZnRlciBvZmZzZXQgYG5gLCBhbmQgd2FrZXMgdXAgdGhlIEdQVSBwcm9jZXNzIHdpdGggdGhlIGlu dGVudGlvbiBvZiBoYW5kbGluZyB0aGlzIG1lc3NhZ2UuCisKKyAgICAgICAgNi4gICAgICBUaGUg R1BVIHByb2Nlc3Mgd2FrZXMgdXAgYW5kIGJlZ2lucyByZWFkaW5nIGZyb20gb2Zmc2V0IDAuIFRo ZSBmaXJzdCBtZXNzYWdlIGl0IGVuY291bnRlcnMgaXMgdGhlCisgICAgICAgICAgICAgICAgYFN5 bmNNZXNzYWdlUmVwbHlgIGl0IGp1c3Qgd3JvdGUgaW4gc3RlcCAoNCksIGFuZCBzdWJzZXF1ZW50 bHkgYmFpbHMgZnJvbSB0aGUgcHJvY2Vzc2luZyBsb29wIGJlY2F1c2UgaXQKKyAgICAgICAgICAg ICAgICBpc24ndCBjYXBhYmxlIG9mIGRpc3BhdGNoaW5nIHRoaXMgbWVzc2FnZSAod2hpY2ggd2Fz IG1lYW50IHRvIGJlIGNvbnN1bWVkIGluIHRoZSB3ZWIgcHJvY2VzcyBpbiB0aGUKKyAgICAgICAg ICAgICAgICBmaXJzdCBwbGFjZSkuCisKKyAgICAgICAgSW4gc3VtbWFyeSwgdGhlIHN5bmMgSVBD IHRpbWVvdXQgY2F1c2VzIHVzIHRvIGVudGVyIGEgc3RhdGUgd2hlcmUgdGhlIHdlYiBwcm9jZXNz IGNvbnRpbnVlcyB0byBlbmNvZGUgbWVzc2FnZXMKKyAgICAgICAgYXQgdGhlIGJ1ZmZlciBvZmZz ZXQgcHJpb3IgdG8gdGltZW91dCAoaS5lLiBvZmZzZXQgYG5gKSwgd2hpbGUgdGhlIEdQVSBwcm9j ZXNzIGlzIHJlYWRpbmcgZnJvbSB0aGUgc3RhcnQgb2YgdGhlCisgICAgICAgIGJ1ZmZlciAob2Zm c2V0IGAwYCkuCisKKyAgICAgICAgVG8gZml4IHRoaXMsIHdlIHNpbXBseSBrZWVwIHRoZSBjbGll bnQgb2Zmc2V0IGluIHN5bmMgd2l0aCB0aGUgc2VydmVyIG9mZnNldCBpbiB0aGUgY2FzZSBvZiBh IHN5bmMgbWVzc2FnZQorICAgICAgICB0aW1lb3V0LCBieSBoYXZpbmcgdGhlIHdlYiBwcm9jZXNz IG1vdmUgdGhlIG9mZnNldCBiYWNrIHRvIDAuIFdlIGtub3cgdGhhdCB0aGUgR1BVIHByb2Nlc3Mg d2lsbCBldmVudHVhbGx5CisgICAgICAgIGVpdGhlciBjcmFzaCBvciBmaW5pc2ggcHJvY2Vzc2lu ZyB0aGUgc3luYyBtZXNzYWdlOyBpbiB0aGUgZm9ybWVyIGNhc2UsIHRoZSBlbnRpcmUgY29ubmVj dGlvbiB3aWxsIGJlIHRvcm4gZG93bgorICAgICAgICBhbmQgcmVlc3RhYmxpc2hlZCBhbnl3YXlz LCBhbmQgaW4gdGhlIGxhdHRlciBjYXNlIHdlIGtub3cgdGhhdCB0aGUgR1BVIHByb2Nlc3MgaXMg Z29pbmcgdG8gZXhwZWN0IHRvIGRlY29kZQorICAgICAgICBtZXNzYWdlcyBzdGFydGluZyBmcm9t IG9mZnNldCAwIGluIHRoZSByaW5nIGJ1ZmZlciwgc28gdGhlcmUncyBubyByZWFzb24gdG8gYXZv aWQgbW92aW5nIHRoZSBvZmZzZXQgdG8gdGhlIHN0YXJ0CisgICAgICAgIGluIHRoZSBjYXNlIG9m IGEgc3luYyBJUEMgdGltZW91dC4KKworICAgICAgICAqIFBsYXRmb3JtL0lQQy9TdHJlYW1DbGll bnRDb25uZWN0aW9uLmg6CisgICAgICAgIChJUEM6OlN0cmVhbUNsaWVudENvbm5lY3Rpb246OnRy eUFjcXVpcmVBbGwpOgorICAgICAgICAqIFBsYXRmb3JtL0lQQy9TdHJlYW1TZXJ2ZXJDb25uZWN0 aW9uLmNwcDoKKyAgICAgICAgKElQQzo6U3RyZWFtU2VydmVyQ29ubmVjdGlvbjo6ZGlzcGF0Y2hT dHJlYW1NZXNzYWdlcyk6CisKKyAgICAgICAgRHJpdmUtYnkgZml4OiB3ZSBvbmx5IG5lZWQgdG8g Z3JhYiB0aGUgYG1fcmVjZWl2ZXJzTG9ja2AgaGVyZSBpZiB3ZSdyZSB0cnlpbmcgdG8gYXNzZXJ0 IHRoYXQgdGhlcmUgYXJlIG5vCisgICAgICAgIHJlY2VpdmVycywgc28gdGhlIGxvY2sgc2hvdWxk IG9ubHkgYmUgbmVjZXNzYXJ5IGlmIGBBU1NFUlRfRU5BQkxFRGAuCisKIDIwMjEtMTAtMzAgIFdl bnNvbiBIc2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CiAKICAgICAgICAgTGF5ZXIgdHJl ZSBzaG91bGQgbm90IGJlIHN0dWNrIGluIGZyb3plbiBzdGF0ZSBhZnRlciBleHBsaWNpdGx5IHN0 b3BwaW5nIGEgcGFnZSBsb2FkCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQ Qy9TdHJlYW1DbGllbnRDb25uZWN0aW9uLmggYi9Tb3VyY2UvV2ViS2l0L1BsYXRmb3JtL0lQQy9T dHJlYW1DbGllbnRDb25uZWN0aW9uLmgKaW5kZXggNWVlNjFmN2MxODFjYmFlODU3ZTNhNzgxODEy Njk1MWI5ODViNDk5Mi4uOGFmODZiODc0ODRkYzM1OGNmNTFkNmRjMzc4MjU3NTFlNjQzM2I1NCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvU3RyZWFtQ2xpZW50Q29ubmVj dGlvbi5oCisrKyBiL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL1N0cmVhbUNsaWVudENvbm5l Y3Rpb24uaApAQCAtMjg5LDcgKzI4OSw3IEBAIGlubGluZSBzdGQ6Om9wdGlvbmFsPFN0cmVhbUNs aWVudENvbm5lY3Rpb246OlNwYW4+IFN0cmVhbUNsaWVudENvbm5lY3Rpb246OnRyeUFjCiAgICAg Ly8gVGhlIHdhaXQgc2VxdWVuY2UgaW52b2x2ZXMgdHdvIHZhcmlhYmxlcywgc28gZm9ybSBhIHRy YW5zYWN0aW9uIGJ5IHNldHRpbmcgY2xpZW50TGltaXQgPT0gY2xpZW50SXNXYWl0aW5nVGFnLgog ICAgIC8vIFRoZSB0cmFuc2FjdGlvbiBpcyBjYW5jZWxsZWQgaWYgdGhlIHNlcnZlciBoYXMgYWxy ZWFkeSBzZXQgY2xpZW50T2Zmc2V0ID09IGNsaWVudExpbWl0ID09IDAsIG90aGVyd2lzZSBpdCBj b21taXRzLgogICAgIC8vIElmIHRoZSB0cmFuc2FjdGlvbiBjb21taXRzLCBzZXJ2ZXIgaXMgZ3Vh cmFudGVlZCB0byBzaWduYWwuCi0KKyAgICBtX2NsaWVudE9mZnNldCA9IDA7CiAgICAgZm9yICg7 OykgewogICAgICAgICBDbGllbnRMaW1pdCBjbGllbnRMaW1pdCA9IHNoYXJlZENsaWVudExpbWl0 KCkuZXhjaGFuZ2UoQ2xpZW50TGltaXQ6OmNsaWVudElzV2FpdGluZ1RhZywgc3RkOjptZW1vcnlf b3JkZXJfYWNxX3JlbCk7CiAgICAgICAgIENsaWVudE9mZnNldCBjbGllbnRPZmZzZXQgPSBzaGFy ZWRDbGllbnRPZmZzZXQoKS5sb2FkKHN0ZDo6bWVtb3J5X29yZGVyX2FjcXVpcmUpOwpAQCAtMzAy LDcgKzMwMiw2IEBAIGlubGluZSBzdGQ6Om9wdGlvbmFsPFN0cmVhbUNsaWVudENvbm5lY3Rpb246 OlNwYW4+IFN0cmVhbUNsaWVudENvbm5lY3Rpb246OnRyeUFjCiAgICAgfQogICAgIC8vIEluIGNh c2UgdGhlIHRyYW5zYWN0aW9uIHdhcyBjYW5jZWxsZWQsIHVuZG8gdGhlIHRyYW5zYWN0aW9uIG1h cmtlci4KICAgICBzaGFyZWRDbGllbnRMaW1pdCgpLnN0b3JlKHN0YXRpY19jYXN0PENsaWVudExp bWl0PigwKSwgc3RkOjptZW1vcnlfb3JkZXJfcmVsZWFzZSk7Ci0gICAgbV9jbGllbnRPZmZzZXQg PSAwOwogICAgIHJldHVybiBhbGlnbmVkU3BhbihtX2NsaWVudE9mZnNldCwgMCk7CiB9CiAKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvUGxhdGZvcm0vSVBDL1N0cmVhbVNlcnZlckNvbm5lY3Rp b24uY3BwIGIvU291cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvU3RyZWFtU2VydmVyQ29ubmVjdGlv bi5jcHAKaW5kZXggOTZhM2VhZjZhN2Q4ZjFmZDVkZThlYWJmOTA1MDEzZmU0OTFkYTFjNC4uNTJl ZmUzYjVhMjcxNjQ2MzlkNTExYWI1NjUyNWNjNDg2OWQ2NjNjOSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdC9QbGF0Zm9ybS9JUEMvU3RyZWFtU2VydmVyQ29ubmVjdGlvbi5jcHAKKysrIGIvU291 cmNlL1dlYktpdC9QbGF0Zm9ybS9JUEMvU3RyZWFtU2VydmVyQ29ubmVjdGlvbi5jcHAKQEAgLTIy Miw4ICsyMjIsMTAgQEAgU3RyZWFtU2VydmVyQ29ubmVjdGlvbkJhc2U6OkRpc3BhdGNoUmVzdWx0 IFN0cmVhbVNlcnZlckNvbm5lY3Rpb246OmRpc3BhdGNoU3RyZWEKICAgICAgICAgICAgIC8vIFRo aXMgbWVhbnMgd2UgbXVzdCB0aW1lb3V0IGV2ZXJ5IHJlY2VpdmVyIGluIHRoZSBzdHJlYW0gY29u bmVjdGlvbi4KICAgICAgICAgICAgIC8vIEN1cnJlbnRseSB3ZSBhc3NlcnQgdGhhdCB0aGUgcmVj ZWl2ZXJzIGFyZSBlbXB0eSwgYXMgd2Ugb25seSBoYXZlIHVwIHRvIG9uZSByZWNlaXZlciBpbgog ICAgICAgICAgICAgLy8gYSBzdHJlYW0gY29ubmVjdGlvbiB1bnRpbCBwb3NzaWJpbGl0eSBvZiBz a2lwcGluZyBpcyBpbXBsZW1lbnRlZCBwcm9wZXJseS4KKyNpZiBBU1NFUlRfRU5BQkxFRAogICAg ICAgICAgICAgTG9ja2VyIGxvY2tlciB7IG1fcmVjZWl2ZXJzTG9jayB9OwogICAgICAgICAgICAg QVNTRVJUKG1fcmVjZWl2ZXJzLmlzRW1wdHkoKSk7CisjZW5kaWYKICAgICAgICAgICAgIHJldHVy biBEaXNwYXRjaFJlc3VsdDo6SGFzTm9NZXNzYWdlczsKICAgICAgICAgfQogICAgICAgICBpZiAo IWRpc3BhdGNoU3RyZWFtTWVzc2FnZShXVEZNb3ZlKGRlY29kZXIpLCAqY3VycmVudFJlY2VpdmVy KSkK 443228 2021-11-03 12:59:57 -0700 2021-11-03 15:03:14 -0700 For EWS bug-232580-20211103125956.patch text/plain 11450 wenson_hsieh U3VidmVyc2lvbiBSZXZpc2lvbjogMjg1MTcwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0No YW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDRlZDk4MzlkOTM5MDA0Nzk4 NjI2MjM2MTgyMTUxZjc4YzZmMTYwNDIuLjY2ZGY5YzNjOTgxNzJiYTAxN2I4Zjg3Y2EyNDA3N2Nl ZjIzNzYwODMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJj ZS9XZWJLaXQvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNDggQEAKKzIwMjEtMTEtMDMgIFdlbnNvbiBI c2llaCAgPHdlbnNvbl9oc2llaEBhcHBsZS5jb20+CisKKyAgICAgICAgW0dQVSBQcm9jZXNzXSBS ZW5kZXJpbmcgYmFja2VuZCBtYXkgc3RvcCBwcm9jZXNzaW5nIElQQyBzdHJlYW0gbWVzc2FnZXMg YWZ0ZXIgYSBzeW5jIG1lc3NhZ2UgdGltZW91dAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjMyNTgwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZ IChPT1BTISkuCisKKyAgICAgICAgQ3VycmVudGx5LCBpdCdzIHBvc3NpYmxlIGZvciBzeW5jIElQ QyBtZXNzYWdlcyB0aGF0IGFyZSBzZW50IHRocm91Z2ggSVBDIHN0cmVhbXMgdG8gdGltZSBvdXQg YW5kIHN1YnNlcXVlbnRseQorICAgICAgICBjYXVzZSB0aGUgSVBDIHN0cmVhbSBzZXJ2ZXIgKGUu Zy4gUmVtb3RlUmVuZGVyaW5nQmFja2VuZCkgdG8gc3RvcCBwcm9jZXNzaW5nIElQQyBzdHJlYW0g bWVzc2FnZXMgYWx0b2dldGhlci4gVGhlCisgICAgICAgIGZvbGxvd2luZyBleGFtcGxlIGlsbHVz dHJhdGVzIGhvdyB0aGlzIG1pZ2h0IGhhcHBlbjoKKworICAgICAgICAxLiAgICAgIFdlYiBwcm9j ZXNzIHNlbmRzIHRoZSBzeW5jIG1lc3NhZ2UgYXQgb2Zmc2V0IGBuYCAocmVsYXRpdmUgdG8gdGhl IHN0YXJ0IG9mIHRoZSByaW5nIGJ1ZmZlcikuCisgICAgICAgICAgICAgICAgV2ViIHByb2Nlc3Mg dGhlbiBiZWdpbnMgdG8gd2FpdCBmb3IgdGhlIHN5bmMgc3RyZWFtIHJlc3BvbnNlIHVuZGVyIGB0 cnlBY3F1aXJlQWxsKClgLgorCisgICAgICAgIDIuICAgICAgR1BVIHByb2Nlc3MgcmVjZWl2ZXMg dGhlIHN5bmMgbWVzc2FnZSwgYW5kIHRha2VzIGEgd2hpbGUgKD4gMSBzZWMuKSBhdHRlbXB0aW5n IHRvIGRpc3BhdGNoIGl0LgorCisgICAgICAgIDMuICAgICAgTWVhbndoaWxlIGluIHRoZSB3ZWIg cHJvY2Vzcywgd2UgaGl0IHRoZSBJUEMgdGltZW91dCBhbmQgYmFpbCBmcm9tIGB0cnlBY3F1aXJl QWxsKClgLiBUaGUgY2xpZW50IG9mZnNldAorICAgICAgICAgICAgICAgIGlzIHN0aWxsIGF0IGBu YC4gU2hvcnRseSBhZnRlcndhcmRzLCB0aGUgd2ViIHByb2Nlc3MgdHJpZXMgdG8gc2VuZCBhIHJl Z3VsYXIgc3RyZWFtIG1lc3NhZ2UsIGNhbGxpbmcKKyAgICAgICAgICAgICAgICBgdHJ5QWNxdWly ZSgpYCBhbmQgd2FpdGluZyBmb3IgdGhlIGNsaWVudCBzZW1hcGhvcmUgdG8gYmUgc2lnbmFsZWQu CisKKyAgICAgICAgNC4gICAgICBUaGUgR1BVIHByb2Nlc3MgZmluYWxseSBmaW5pc2hlcyBkaXNw YXRjaGluZyB0aGUgc3luYyBtZXNzYWdlIGZyb20gKDIpLCBzZW5kcyBhIHN5bmMgcmVwbHkgKHVu YXdhcmUgdGhhdAorICAgICAgICAgICAgICAgIHRoZSB3ZWIgcHJvY2VzcyBoYXMgYWxyZWFkeSBn aXZlbiB1cCB3YWl0aW5nKSwgYW5kIGZpbmFsbHkgY2FsbHMgYHJlbGVhc2VBbGwoKWAsIHNpZ25h bGluZyB0aGUgY2xpZW50CisgICAgICAgICAgICAgICAgc2VtYXBob3JlLiBUaGUgc2VydmVyIG9m ZnNldCBpcyB0aGVuIHJlc2V0IGJhY2sgdG8gMC4KKworICAgICAgICA1LiAgICAgIFRoZSB3ZWIg cHJvY2VzcyBmaW5pc2hlcyB3YWl0aW5nLCByZXR1cm5zIGZyb20gYHRyeUFjcXVpcmUoKWAsIHBy b2NlZWRzIHRvIHdyaXRlIHRoZSBuZXcgc3RyZWFtCisgICAgICAgICAgICAgICAgbWVzc2FnZSBh ZnRlciBvZmZzZXQgYG5gLCBhbmQgd2FrZXMgdXAgdGhlIEdQVSBwcm9jZXNzIHdpdGggdGhlIGlu dGVudGlvbiBvZiBoYW5kbGluZyB0aGlzIG1lc3NhZ2UuCisKKyAgICAgICAgNi4gICAgICBUaGUg R1BVIHByb2Nlc3Mgd2FrZXMgdXAgYW5kIGJlZ2lucyByZWFkaW5nIGZyb20gb2Zmc2V0IDAuIFRo ZSBmaXJzdCBtZXNzYWdlIGl0IGVuY291bnRlcnMgaXMgdGhlCisgICAgICAgICAgICAgICAgYFN5 bmNNZXNzYWdlUmVwbHlgIGl0IGp1c3Qgd3JvdGUgaW4gc3RlcCAoNCksIGFuZCBzdWJzZXF1ZW50 bHkgYmFpbHMgZnJvbSB0aGUgcHJvY2Vzc2luZyBsb29wIGJlY2F1c2UgaXQKKyAgICAgICAgICAg ICAgICBpc24ndCBjYXBhYmxlIG9mIGRpc3BhdGNoaW5nIHRoaXMgbWVzc2FnZSAod2hpY2ggd2Fz IG1lYW50IHRvIGJlIGNvbnN1bWVkIGluIHRoZSB3ZWIgcHJvY2VzcyBpbiB0aGUKKyAgICAgICAg ICAgICAgICBmaXJzdCBwbGFjZSkuCisKKyAgICAgICAgSW4gc3VtbWFyeSwgdGhlIHN5bmMgSVBD IHRpbWVvdXQgY2F1c2VzIHVzIHRvIGVudGVyIGEgc3RhdGUgd2hlcmUgdGhlIHdlYiBwcm9jZXNz IGNvbnRpbnVlcyB0byBlbmNvZGUgbWVzc2FnZXMKKyAgICAgICAgYXQgdGhlIGJ1ZmZlciBvZmZz ZXQgcHJpb3IgdG8gdGltZW91dCAoaS5lLiBvZmZzZXQgYG5gKSwgd2hpbGUgdGhlIEdQVSBwcm9j ZXNzIGlzIHJlYWRpbmcgZnJvbSB0aGUgc3RhcnQgb2YgdGhlCisgICAgICAgIGJ1ZmZlciAob2Zm c2V0IGAwYCkuIFRvIGF2b2lkIHRoaXMsIHNpbXBseSByZXBsYWNlIHRoZSB0aW1lb3V0cyB3aGVu IHN5bmNocm9ub3VzbHkgZ3JhYmJpbmcgaW1hZ2UgZGF0YSBmcm9tIHRoZQorICAgICAgICBHUFUg cHJvY2Vzcy4gVGhpcyBlbnN1cmVzIHRoYXQgd2UncmUgbmV2ZXIgaW4gYSBzdGF0ZSB3aGVyZSB3 ZSdyZSBjb250aW51aW5nIHRvIHNlbmQgc3RyZWFtIG1lc3NhZ2VzIHRvIGEKKyAgICAgICAgcmVu ZGVyaW5nIGJhY2tlbmQgY29ubmVjdGlvbiBzdHJlYW0gYWZ0ZXIgdGltaW5nIG91dCB3aGVuIHdh aXRpbmcgZm9yIGEgcHJldmlvdXMgc3luYyBtZXNzYWdlIHRvIHRoYXQgc3RyZWFtIHRvCisgICAg ICAgIGZpbmlzaC4KKworICAgICAgICAqIFdlYlByb2Nlc3MvR1BVL2dyYXBoaWNzL1JlbW90ZUlt YWdlQnVmZmVyUHJveHkuaDoKKyAgICAgICAgKiBXZWJQcm9jZXNzL0dQVS9ncmFwaGljcy9SZW1v dGVSZW5kZXJpbmdCYWNrZW5kUHJveHkuY3BwOgorICAgICAgICAoV2ViS2l0OjpSZW1vdGVSZW5k ZXJpbmdCYWNrZW5kUHJveHk6OnNoYXJlZE1lbW9yeUZvckdldFBpeGVsQnVmZmVyKToKKyAgICAg ICAgKFdlYktpdDo6UmVtb3RlUmVuZGVyaW5nQmFja2VuZFByb3h5Ojp3YWl0Rm9yR2V0UGl4ZWxC dWZmZXJUb0NvbXBsZXRlKToKKyAgICAgICAgKiBXZWJQcm9jZXNzL0dQVS9ncmFwaGljcy9SZW1v dGVSZW5kZXJpbmdCYWNrZW5kUHJveHkuaDoKKwogMjAyMS0xMS0wMiAgS2F0ZSBDaGVuZXkgIDxr YXRoZXJpbmVfY2hlbmV5QGFwcGxlLmNvbT4KIAogICAgICAgICBQQ006IFNhZmFyaSBvbiBpT1Mg YW5kIG1hY09TIGFyZSBub3Qgc2VuZGluZyBhZCBjbGljayBhdHRyaWJ1dGlvbiByZXBvcnRzIGZv ciBQcml2YXRlIENsaWNrIE1lYXN1cmVtZW50CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dl YlByb2Nlc3MvR1BVL2dyYXBoaWNzL1JlbW90ZUltYWdlQnVmZmVyUHJveHkuaCBiL1NvdXJjZS9X ZWJLaXQvV2ViUHJvY2Vzcy9HUFUvZ3JhcGhpY3MvUmVtb3RlSW1hZ2VCdWZmZXJQcm94eS5oCmlu ZGV4IGE3OGQzMjY1MDVjNGMzYTliNDlkMDMwOGJiNWNjMjc3ZjJlOTgzZDkuLjA5NTU3YTc1YjBl ZDRlMTBmNTZiYjQ4OWVmMDNkNzhiZWMzZmJhZTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv V2ViUHJvY2Vzcy9HUFUvZ3JhcGhpY3MvUmVtb3RlSW1hZ2VCdWZmZXJQcm94eS5oCisrKyBiL1Nv dXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9HUFUvZ3JhcGhpY3MvUmVtb3RlSW1hZ2VCdWZmZXJQcm94 eS5oCkBAIC0yMDgsOCArMjA4LDcgQEAgcHJvdGVjdGVkOgogICAgICAgICAgICAgcmV0dXJuIHN0 ZDo6bnVsbG9wdDsKICAgICAgICAgc2l6ZV90IGRhdGFTaXplID0gcGl4ZWxCdWZmZXItPmRhdGEo KS5ieXRlTGVuZ3RoKCk7CiAKLSAgICAgICAgSVBDOjpUaW1lb3V0IHRpbWVvdXQgPSA1X3M7Ci0g ICAgICAgIFNoYXJlZE1lbW9yeSogc2hhcmVkTWVtb3J5ID0gbV9yZW1vdGVSZW5kZXJpbmdCYWNr ZW5kUHJveHktPnNoYXJlZE1lbW9yeUZvckdldFBpeGVsQnVmZmVyKGRhdGFTaXplLCB0aW1lb3V0 KTsKKyAgICAgICAgU2hhcmVkTWVtb3J5KiBzaGFyZWRNZW1vcnkgPSBtX3JlbW90ZVJlbmRlcmlu Z0JhY2tlbmRQcm94eS0+c2hhcmVkTWVtb3J5Rm9yR2V0UGl4ZWxCdWZmZXIoZGF0YVNpemUpOwog ICAgICAgICBpZiAoIXNoYXJlZE1lbW9yeSkKICAgICAgICAgICAgIHJldHVybiBzdGQ6Om51bGxv cHQ7CiAKQEAgLTIxNyw3ICsyMTYsNyBAQCBwcm90ZWN0ZWQ6CiAgICAgICAgIG11dGFibGVUaGlz Lm1fcmVtb3RlRGlzcGxheUxpc3QuZ2V0UGl4ZWxCdWZmZXIoZGVzdGluYXRpb25Gb3JtYXQsIHNy Y1JlY3QpOwogICAgICAgICBtdXRhYmxlVGhpcy5mbHVzaERyYXdpbmdDb250ZXh0QXN5bmMoKTsK IAotICAgICAgICBpZiAobV9yZW1vdGVSZW5kZXJpbmdCYWNrZW5kUHJveHktPndhaXRGb3JHZXRQ aXhlbEJ1ZmZlclRvQ29tcGxldGUodGltZW91dCkpCisgICAgICAgIGlmIChtX3JlbW90ZVJlbmRl cmluZ0JhY2tlbmRQcm94eS0+d2FpdEZvckdldFBpeGVsQnVmZmVyVG9Db21wbGV0ZSgpKQogICAg ICAgICAgICAgbWVtY3B5KHBpeGVsQnVmZmVyLT5kYXRhKCkuZGF0YSgpLCBzaGFyZWRNZW1vcnkt PmRhdGEoKSwgZGF0YVNpemUpOwogICAgICAgICBlbHNlCiAgICAgICAgICAgICBtZW1zZXQocGl4 ZWxCdWZmZXItPmRhdGEoKS5kYXRhKCksIDAsIGRhdGFTaXplKTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQvV2ViUHJvY2Vzcy9HUFUvZ3JhcGhpY3MvUmVtb3RlUmVuZGVyaW5nQmFja2VuZFBy b3h5LmNwcCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9HUFUvZ3JhcGhpY3MvUmVtb3RlUmVu ZGVyaW5nQmFja2VuZFByb3h5LmNwcAppbmRleCAyOGJiMjQ0ODE2ODE5M2VlZTdkY2FjZWIzODFh OGYzZGUwOGRhMWFmLi4yY2Q1MzFjMTk2MTcyMmE3ZTE3ZGZkNzEzMDAzZWRhYTQ3M2M3YmYwIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvR1BVL2dyYXBoaWNzL1JlbW90ZVJl bmRlcmluZ0JhY2tlbmRQcm94eS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL0dQ VS9ncmFwaGljcy9SZW1vdGVSZW5kZXJpbmdCYWNrZW5kUHJveHkuY3BwCkBAIC0xNTUsNyArMTU1 LDcgQEAgUmVmUHRyPEltYWdlQnVmZmVyPiBSZW1vdGVSZW5kZXJpbmdCYWNrZW5kUHJveHk6OmNy ZWF0ZUltYWdlQnVmZmVyKGNvbnN0IEZsb2F0U2kKICAgICByZXR1cm4gbnVsbHB0cjsKIH0KIAot U2hhcmVkTWVtb3J5KiBSZW1vdGVSZW5kZXJpbmdCYWNrZW5kUHJveHk6OnNoYXJlZE1lbW9yeUZv ckdldFBpeGVsQnVmZmVyKHNpemVfdCBkYXRhU2l6ZSwgSVBDOjpUaW1lb3V0IHRpbWVvdXQpCitT aGFyZWRNZW1vcnkqIFJlbW90ZVJlbmRlcmluZ0JhY2tlbmRQcm94eTo6c2hhcmVkTWVtb3J5Rm9y R2V0UGl4ZWxCdWZmZXIoc2l6ZV90IGRhdGFTaXplKQogewogICAgIGJvb2wgbmVlZHNTaGFyZWRN ZW1vcnkgPSAhbV9nZXRQaXhlbEJ1ZmZlclNoYXJlZE1lbW9yeSB8fCBkYXRhU2l6ZSA+IG1fZ2V0 UGl4ZWxCdWZmZXJTaGFyZWRNZW1vcnlMZW5ndGg7CiAgICAgYm9vbCBuZWVkc1NlbWFwaG9yZSA9 ICFtX2dldFBpeGVsQnVmZmVyU2VtYXBob3JlOwpAQCAtMTY3LDExICsxNjcsMTEgQEAgU2hhcmVk TWVtb3J5KiBSZW1vdGVSZW5kZXJpbmdCYWNrZW5kUHJveHk6OnNoYXJlZE1lbW9yeUZvckdldFBp eGVsQnVmZmVyKHNpemVfdAogICAgIElQQzo6U2VtYXBob3JlIHNlbWFwaG9yZTsKIAogICAgIGlm IChuZWVkc1NoYXJlZE1lbW9yeSAmJiBuZWVkc1NlbWFwaG9yZSkKLSAgICAgICAgc2VuZFN5bmNU b1N0cmVhbShNZXNzYWdlczo6UmVtb3RlUmVuZGVyaW5nQmFja2VuZDo6VXBkYXRlU2hhcmVkTWVt b3J5QW5kU2VtYXBob3JlRm9yR2V0UGl4ZWxCdWZmZXIoZGF0YVNpemUpLCBNZXNzYWdlczo6UmVt b3RlUmVuZGVyaW5nQmFja2VuZDo6VXBkYXRlU2hhcmVkTWVtb3J5QW5kU2VtYXBob3JlRm9yR2V0 UGl4ZWxCdWZmZXI6OlJlcGx5KGhhbmRsZSwgc2VtYXBob3JlKSwgdGltZW91dCk7CisgICAgICAg IHNlbmRTeW5jVG9TdHJlYW0oTWVzc2FnZXM6OlJlbW90ZVJlbmRlcmluZ0JhY2tlbmQ6OlVwZGF0 ZVNoYXJlZE1lbW9yeUFuZFNlbWFwaG9yZUZvckdldFBpeGVsQnVmZmVyKGRhdGFTaXplKSwgTWVz c2FnZXM6OlJlbW90ZVJlbmRlcmluZ0JhY2tlbmQ6OlVwZGF0ZVNoYXJlZE1lbW9yeUFuZFNlbWFw aG9yZUZvckdldFBpeGVsQnVmZmVyOjpSZXBseShoYW5kbGUsIHNlbWFwaG9yZSkpOwogICAgIGVs c2UgaWYgKG5lZWRzU2hhcmVkTWVtb3J5KQotICAgICAgICBzZW5kU3luY1RvU3RyZWFtKE1lc3Nh Z2VzOjpSZW1vdGVSZW5kZXJpbmdCYWNrZW5kOjpVcGRhdGVTaGFyZWRNZW1vcnlGb3JHZXRQaXhl bEJ1ZmZlcihkYXRhU2l6ZSksIE1lc3NhZ2VzOjpSZW1vdGVSZW5kZXJpbmdCYWNrZW5kOjpVcGRh dGVTaGFyZWRNZW1vcnlGb3JHZXRQaXhlbEJ1ZmZlcjo6UmVwbHkoaGFuZGxlKSwgdGltZW91dCk7 CisgICAgICAgIHNlbmRTeW5jVG9TdHJlYW0oTWVzc2FnZXM6OlJlbW90ZVJlbmRlcmluZ0JhY2tl bmQ6OlVwZGF0ZVNoYXJlZE1lbW9yeUZvckdldFBpeGVsQnVmZmVyKGRhdGFTaXplKSwgTWVzc2Fn ZXM6OlJlbW90ZVJlbmRlcmluZ0JhY2tlbmQ6OlVwZGF0ZVNoYXJlZE1lbW9yeUZvckdldFBpeGVs QnVmZmVyOjpSZXBseShoYW5kbGUpKTsKICAgICBlbHNlIGlmIChuZWVkc1NlbWFwaG9yZSkKLSAg ICAgICAgc2VuZFN5bmNUb1N0cmVhbShNZXNzYWdlczo6UmVtb3RlUmVuZGVyaW5nQmFja2VuZDo6 U2VtYXBob3JlRm9yR2V0UGl4ZWxCdWZmZXIoKSwgTWVzc2FnZXM6OlJlbW90ZVJlbmRlcmluZ0Jh Y2tlbmQ6OlNlbWFwaG9yZUZvckdldFBpeGVsQnVmZmVyOjpSZXBseShzZW1hcGhvcmUpLCB0aW1l b3V0KTsKKyAgICAgICAgc2VuZFN5bmNUb1N0cmVhbShNZXNzYWdlczo6UmVtb3RlUmVuZGVyaW5n QmFja2VuZDo6U2VtYXBob3JlRm9yR2V0UGl4ZWxCdWZmZXIoKSwgTWVzc2FnZXM6OlJlbW90ZVJl bmRlcmluZ0JhY2tlbmQ6OlNlbWFwaG9yZUZvckdldFBpeGVsQnVmZmVyOjpSZXBseShzZW1hcGhv cmUpKTsKIAogICAgIGlmICghaGFuZGxlLmhhbmRsZS5pc051bGwoKSkgewogICAgICAgICBtX2dl dFBpeGVsQnVmZmVyU2hhcmVkTWVtb3J5ID0gU2hhcmVkTWVtb3J5OjptYXAoaGFuZGxlLmhhbmRs ZSwgU2hhcmVkTWVtb3J5OjpQcm90ZWN0aW9uOjpSZWFkT25seSk7CkBAIC0xODcsMTAgKzE4Nywx MCBAQCBTaGFyZWRNZW1vcnkqIFJlbW90ZVJlbmRlcmluZ0JhY2tlbmRQcm94eTo6c2hhcmVkTWVt b3J5Rm9yR2V0UGl4ZWxCdWZmZXIoc2l6ZV90CiAgICAgcmV0dXJuIG1fZ2V0UGl4ZWxCdWZmZXJT aGFyZWRNZW1vcnkuZ2V0KCk7CiB9CiAKLWJvb2wgUmVtb3RlUmVuZGVyaW5nQmFja2VuZFByb3h5 Ojp3YWl0Rm9yR2V0UGl4ZWxCdWZmZXJUb0NvbXBsZXRlKElQQzo6VGltZW91dCB0aW1lb3V0KQor Ym9vbCBSZW1vdGVSZW5kZXJpbmdCYWNrZW5kUHJveHk6OndhaXRGb3JHZXRQaXhlbEJ1ZmZlclRv Q29tcGxldGUoKQogewogICAgIEFTU0VSVChtX2dldFBpeGVsQnVmZmVyU2VtYXBob3JlKTsKLSAg ICByZXR1cm4gbV9nZXRQaXhlbEJ1ZmZlclNlbWFwaG9yZS0+d2FpdEZvcih0aW1lb3V0KTsKKyAg ICByZXR1cm4gbV9nZXRQaXhlbEJ1ZmZlclNlbWFwaG9yZS0+d2FpdCgpOwogfQogCiB2b2lkIFJl bW90ZVJlbmRlcmluZ0JhY2tlbmRQcm94eTo6ZGVzdHJveUdldFBpeGVsQnVmZmVyU2hhcmVkTWVt b3J5KCkKQEAgLTIwMiwyMSArMjAyLDIxIEBAIHZvaWQgUmVtb3RlUmVuZGVyaW5nQmFja2VuZFBy b3h5OjpkZXN0cm95R2V0UGl4ZWxCdWZmZXJTaGFyZWRNZW1vcnkoKQogU3RyaW5nIFJlbW90ZVJl bmRlcmluZ0JhY2tlbmRQcm94eTo6Z2V0RGF0YVVSTEZvckltYWdlQnVmZmVyKGNvbnN0IFN0cmlu ZyYgbWltZVR5cGUsIHN0ZDo6b3B0aW9uYWw8ZG91YmxlPiBxdWFsaXR5LCBQcmVzZXJ2ZVJlc29s dXRpb24gcHJlc2VydmVSZXNvbHV0aW9uLCBSZW5kZXJpbmdSZXNvdXJjZUlkZW50aWZpZXIgcmVu ZGVyaW5nUmVzb3VyY2VJZGVudGlmaWVyKQogewogICAgIFN0cmluZyB1cmxTdHJpbmc7Ci0gICAg c2VuZFN5bmNUb1N0cmVhbShNZXNzYWdlczo6UmVtb3RlUmVuZGVyaW5nQmFja2VuZDo6R2V0RGF0 YVVSTEZvckltYWdlQnVmZmVyKG1pbWVUeXBlLCBxdWFsaXR5LCBwcmVzZXJ2ZVJlc29sdXRpb24s IHJlbmRlcmluZ1Jlc291cmNlSWRlbnRpZmllciksIE1lc3NhZ2VzOjpSZW1vdGVSZW5kZXJpbmdC YWNrZW5kOjpHZXREYXRhVVJMRm9ySW1hZ2VCdWZmZXI6OlJlcGx5KHVybFN0cmluZyksIDFfcyk7 CisgICAgc2VuZFN5bmNUb1N0cmVhbShNZXNzYWdlczo6UmVtb3RlUmVuZGVyaW5nQmFja2VuZDo6 R2V0RGF0YVVSTEZvckltYWdlQnVmZmVyKG1pbWVUeXBlLCBxdWFsaXR5LCBwcmVzZXJ2ZVJlc29s dXRpb24sIHJlbmRlcmluZ1Jlc291cmNlSWRlbnRpZmllciksIE1lc3NhZ2VzOjpSZW1vdGVSZW5k ZXJpbmdCYWNrZW5kOjpHZXREYXRhVVJMRm9ySW1hZ2VCdWZmZXI6OlJlcGx5KHVybFN0cmluZykp OwogICAgIHJldHVybiB1cmxTdHJpbmc7CiB9CiAKIFZlY3Rvcjx1aW50OF90PiBSZW1vdGVSZW5k ZXJpbmdCYWNrZW5kUHJveHk6OmdldERhdGFGb3JJbWFnZUJ1ZmZlcihjb25zdCBTdHJpbmcmIG1p bWVUeXBlLCBzdGQ6Om9wdGlvbmFsPGRvdWJsZT4gcXVhbGl0eSwgUmVuZGVyaW5nUmVzb3VyY2VJ ZGVudGlmaWVyIHJlbmRlcmluZ1Jlc291cmNlSWRlbnRpZmllcikKIHsKICAgICBWZWN0b3I8dWlu dDhfdD4gZGF0YTsKLSAgICBzZW5kU3luY1RvU3RyZWFtKE1lc3NhZ2VzOjpSZW1vdGVSZW5kZXJp bmdCYWNrZW5kOjpHZXREYXRhRm9ySW1hZ2VCdWZmZXIobWltZVR5cGUsIHF1YWxpdHksIHJlbmRl cmluZ1Jlc291cmNlSWRlbnRpZmllciksIE1lc3NhZ2VzOjpSZW1vdGVSZW5kZXJpbmdCYWNrZW5k OjpHZXREYXRhRm9ySW1hZ2VCdWZmZXI6OlJlcGx5KGRhdGEpLCAxX3MpOworICAgIHNlbmRTeW5j VG9TdHJlYW0oTWVzc2FnZXM6OlJlbW90ZVJlbmRlcmluZ0JhY2tlbmQ6OkdldERhdGFGb3JJbWFn ZUJ1ZmZlcihtaW1lVHlwZSwgcXVhbGl0eSwgcmVuZGVyaW5nUmVzb3VyY2VJZGVudGlmaWVyKSwg TWVzc2FnZXM6OlJlbW90ZVJlbmRlcmluZ0JhY2tlbmQ6OkdldERhdGFGb3JJbWFnZUJ1ZmZlcjo6 UmVwbHkoZGF0YSkpOwogICAgIHJldHVybiBkYXRhOwogfQogCiBSZWZQdHI8U2hhcmVhYmxlQml0 bWFwPiBSZW1vdGVSZW5kZXJpbmdCYWNrZW5kUHJveHk6OmdldFNoYXJlYWJsZUJpdG1hcChSZW5k ZXJpbmdSZXNvdXJjZUlkZW50aWZpZXIgaW1hZ2VCdWZmZXIsIFByZXNlcnZlUmVzb2x1dGlvbiBw cmVzZXJ2ZVJlc29sdXRpb24pCiB7CiAgICAgU2hhcmVhYmxlQml0bWFwOjpIYW5kbGUgaGFuZGxl OwotICAgIGF1dG8gc2VuZFJlc3VsdCA9IHNlbmRTeW5jVG9TdHJlYW0oTWVzc2FnZXM6OlJlbW90 ZVJlbmRlcmluZ0JhY2tlbmQ6OkdldFNoYXJlYWJsZUJpdG1hcEZvckltYWdlQnVmZmVyKGltYWdl QnVmZmVyLCBwcmVzZXJ2ZVJlc29sdXRpb24pLCBNZXNzYWdlczo6UmVtb3RlUmVuZGVyaW5nQmFj a2VuZDo6R2V0U2hhcmVhYmxlQml0bWFwRm9ySW1hZ2VCdWZmZXI6OlJlcGx5KGhhbmRsZSksIDFf cyk7CisgICAgYXV0byBzZW5kUmVzdWx0ID0gc2VuZFN5bmNUb1N0cmVhbShNZXNzYWdlczo6UmVt b3RlUmVuZGVyaW5nQmFja2VuZDo6R2V0U2hhcmVhYmxlQml0bWFwRm9ySW1hZ2VCdWZmZXIoaW1h Z2VCdWZmZXIsIHByZXNlcnZlUmVzb2x1dGlvbiksIE1lc3NhZ2VzOjpSZW1vdGVSZW5kZXJpbmdC YWNrZW5kOjpHZXRTaGFyZWFibGVCaXRtYXBGb3JJbWFnZUJ1ZmZlcjo6UmVwbHkoaGFuZGxlKSk7 CiAgICAgaWYgKGhhbmRsZS5pc051bGwoKSkKICAgICAgICAgcmV0dXJuIHsgfTsKICAgICBBU1NF UlRfVU5VU0VEKHNlbmRSZXN1bHQsIHNlbmRSZXN1bHQpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9XZWJQcm9jZXNzL0dQVS9ncmFwaGljcy9SZW1vdGVSZW5kZXJpbmdCYWNrZW5kUHJveHku aCBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9HUFUvZ3JhcGhpY3MvUmVtb3RlUmVuZGVyaW5n QmFja2VuZFByb3h5LmgKaW5kZXggNjRiYjkyNjdmZTZiMzM0OTZiMzNmZTU3MGQ5YTcxZWFjYTU1 NGNjZi4uZmE4MzI5OTExOWJmZTFkMWEzMjhkMWU2ODJhMDMwNzk1YzhkN2M5NyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL0dQVS9ncmFwaGljcy9SZW1vdGVSZW5kZXJpbmdC YWNrZW5kUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvR1BVL2dyYXBoaWNz L1JlbW90ZVJlbmRlcmluZ0JhY2tlbmRQcm94eS5oCkBAIC03NCw4ICs3NCw4IEBAIHB1YmxpYzoK IAogICAgIFJlbW90ZVJlc291cmNlQ2FjaGVQcm94eSYgcmVtb3RlUmVzb3VyY2VDYWNoZVByb3h5 KCkgeyByZXR1cm4gbV9yZW1vdGVSZXNvdXJjZUNhY2hlUHJveHk7IH0KIAotICAgIFNoYXJlZE1l bW9yeSogc2hhcmVkTWVtb3J5Rm9yR2V0UGl4ZWxCdWZmZXIoc2l6ZV90IGRhdGFTaXplLCBJUEM6 OlRpbWVvdXQpOwotICAgIGJvb2wgd2FpdEZvckdldFBpeGVsQnVmZmVyVG9Db21wbGV0ZShJUEM6 OlRpbWVvdXQpOworICAgIFNoYXJlZE1lbW9yeSogc2hhcmVkTWVtb3J5Rm9yR2V0UGl4ZWxCdWZm ZXIoc2l6ZV90IGRhdGFTaXplKTsKKyAgICBib29sIHdhaXRGb3JHZXRQaXhlbEJ1ZmZlclRvQ29t cGxldGUoKTsKICAgICB2b2lkIGRlc3Ryb3lHZXRQaXhlbEJ1ZmZlclNoYXJlZE1lbW9yeSgpOwog CiAgICAgdm9pZCBjcmVhdGVSZW1vdGVJbWFnZUJ1ZmZlcihXZWJDb3JlOjpJbWFnZUJ1ZmZlciYp OwpAQCAtMTQwLDcgKzE0MCw3IEBAIHByaXZhdGU6CiAgICAgSVBDOjpTdHJlYW1DbGllbnRDb25u ZWN0aW9uJiBzdHJlYW1Db25uZWN0aW9uKCk7CiAKICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPgot ICAgIGF1dG8gc2VuZFN5bmNUb1N0cmVhbShUJiYgbWVzc2FnZSwgdHlwZW5hbWUgVDo6UmVwbHkm JiByZXBseSwgSVBDOjpUaW1lb3V0IHRpbWVvdXQpCisgICAgYXV0byBzZW5kU3luY1RvU3RyZWFt KFQmJiBtZXNzYWdlLCB0eXBlbmFtZSBUOjpSZXBseSYmIHJlcGx5LCBJUEM6OlRpbWVvdXQgdGlt ZW91dCA9IHsgU2Vjb25kczo6aW5maW5pdHkoKSB9KQogICAgIHsKICAgICAgICAgcmV0dXJuIHN0 cmVhbUNvbm5lY3Rpb24oKS5zZW5kU3luYyhXVEZNb3ZlKG1lc3NhZ2UpLCBXVEZNb3ZlKHJlcGx5 KSwgcmVuZGVyaW5nQmFja2VuZElkZW50aWZpZXIoKSwgdGltZW91dCk7CiAgICAgfQo=