205546 2019-12-21 19:10:54 -0800 WKTR/DRT always trigger the Discrete GPU on dual GPU systems 2020-01-10 10:02:18 -0800 1 1 1 Unclassified WebKit Tools / Tests WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 dino dino ap ews-watchlist glenn jbedard jdarpinian kbr webkit-bug-importer oldest_to_newest 1601130 0 dino 2019-12-21 19:10:54 -0800 Launching either DumpRenderTree or WebKitTestRunner trigger a swap to the discrete GPU, on any test. This means we're not testing the most common situation our users run in (for all CA rendering and WebGL). 1601131 1 webkit-bug-importer 2019-12-21 19:11:10 -0800 <rdar://problem/58139610> 1601138 2 dbates 2019-12-21 20:07:17 -0800 This was intentional. LayoutTestHelper does it. 1601147 3 ap 2019-12-21 20:55:04 -0800 We are testing IG on Mac minis, because there is no discrete GPU there, so most of infrastructure. The special WebGL is IG only too. And yes, we intentionally force discrete where it’s available. Originally, the reason was that switching it on and off frequently would cause panics. But it’s still a good idea for predictability, as there are unsuspecting tests running in parallel. 1601181 4 dino 2019-12-22 13:10:04 -0800 We should default to it being integrated always. That is the default for WebGL. And it is our most common configuration. Having said that: - Alexey is right that the testing infrastructure might not have dual GPUs, but the issue here is that I'm trying to replicate a crash on Intel in DRT, and I can't if that app forces the discrete GPU - We should also be testing on the discrete GPU since our users will have that enabled if they are doing something else that would trigger it (e.g. Photoshop, Pixelmator, Chess,... a game) 1601182 5 dino 2019-12-22 13:12:18 -0800 I will revert the change in LayoutTestHelper, but add a command line argument to turn it on. Note that we had a important update in a .2 release to force integrated in nearly all circumstances, so I think it is important that that remains the default configuration. 1601187 6 ap 2019-12-22 14:59:27 -0800 > I will revert the change in LayoutTestHelper I disagree. It would be unacceptable to run the tests with IG or DG randomly, depending on which tests happen to run in parallel. What we are doing in this regard is intentional, all the way from software configuration to which hardware we choose to run on. If the issue is that you need to reproduce an issue with IG, feel free to edit LayoutTestHelper code locally, or add a non-default switch that bypasses the normal behavior. But we can't have that when running the whole test suite. 1601269 7 dino 2019-12-23 10:40:23 -0800 (In reply to Alexey Proskuryakov from comment #6) > > I will revert the change in LayoutTestHelper > > I disagree. It would be unacceptable to run the tests with IG or DG > randomly, depending on which tests happen to run in parallel. I think it should be the other way around. The vast majority of the tests do not require the DG. We'd be better off running everything but them on the IG, and then ensure the DG ones are run isolated. What tests actually use the DG? None of the WebGL ones should trigger it. 1601274 8 ap 2019-12-23 11:52:45 -0800 That's a good question. Let's find out before attempting to change things. This strikes me as very non-urgent though, because everything is already the way it should be. 1601287 9 386349 dino 2019-12-23 12:52:38 -0800 Created attachment 386349 Patch 1601288 10 dino 2019-12-23 12:55:10 -0800 (In reply to Alexey Proskuryakov from comment #8) > That's a good question. Let's find out before attempting to change things. I've made a patch so I can optionally turn off the GPU locking. > This strikes me as very non-urgent though, because everything is already the > way it should be. I disagree that things are the way they should be :) We're not testing the configuration that the vast majority of our customers use. This current situation is a hack to help the testing infrastructure work. Anyway, I need the option now, so here's a patch. It won't change anything by default. 1601291 11 386349 ap 2019-12-23 13:16:27 -0800 Comment on attachment 386349 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=386349&action=review > Tools/DumpRenderTree/mac/LayoutTestHelper.m:265 > + { "use-integrated-gpu", no_argument, &useIntegratedGPU, true }, The name is misleading. I'm not sure if I fully understand WebKit behavior at this point, but the flag doesn't make tests use integrated GPU, it just makes them use whatever happens to be enabled, and if WebKit chooses to enable discrete GPU for any tests, that will also be allowed. I think that the intention is to add "--enable-discrete-gpu-if-available" with default of true. > Tools/Scripts/webkitpy/layout_tests/run_webkit_tests.py:332 > + "--use-integrated-gpu", action="store_true", default=False, > + help=("Attempt to use only the integrated GPU on a dual-GPU system.")), This also seems misleading. > Tools/Scripts/webkitpy/port/base.py:952 > + def start_helper(self, pixel_tests=False, use_integrated_gpu=False): Interesting that this doesn't affect any tests. Tools/Scripts/webkitpy/port/mock_drt.py has a version of this. 1601410 12 386349 dino 2019-12-24 10:43:38 -0800 Comment on attachment 386349 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=386349&action=review >> Tools/DumpRenderTree/mac/LayoutTestHelper.m:265 >> + { "use-integrated-gpu", no_argument, &useIntegratedGPU, true }, > > The name is misleading. I'm not sure if I fully understand WebKit behavior at this point, but the flag doesn't make tests use integrated GPU, it just makes them use whatever happens to be enabled, and if WebKit chooses to enable discrete GPU for any tests, that will also be allowed. > > I think that the intention is to add "--enable-discrete-gpu-if-available" with default of true. You're right that no app can stop the discrete GPU from being used, and any test might trigger it (or any other app on the system). If I did it with "--enable-discrete-gpu-if-available" then to turn it off I'd need to use "--no-enable-discrete-gpu-if-available" which is cumbersome, but I don't really care. (I'm putting aside my suggestion that we default to the IG everywhere, and just trying to give myself the ability to not trigger the DG all the time) >> Tools/Scripts/webkitpy/layout_tests/run_webkit_tests.py:332 >> + help=("Attempt to use only the integrated GPU on a dual-GPU system.")), > > This also seems misleading. I'll rename it to your suggestion. Note that I'm still going to request we swap the default, so that our developers running tests on their laptops are exercising what most customers have. If the bots work better with the DG enabled, then they should be configured to turn it on locally. >> Tools/Scripts/webkitpy/port/base.py:952 >> + def start_helper(self, pixel_tests=False, use_integrated_gpu=False): > > Interesting that this doesn't affect any tests. Tools/Scripts/webkitpy/port/mock_drt.py has a version of this. I'll check. 1601417 13 386392 dino 2019-12-24 11:28:12 -0800 Created attachment 386392 Patch 1601418 14 dino 2019-12-24 11:28:59 -0800 I'm using "--prefer-integrated-gpu" which more accurately represents what will happen (and what the tester is asking for). 1601419 15 386392 ap 2019-12-24 12:40:54 -0800 Comment on attachment 386392 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=386392&action=review > Tools/ChangeLog:9 > + Add an option "--prefer-integrated-gpu" to run-webkit-test I'm not a fan of this name either, because the preference is not about impacting what WebKit prefers to use. WebKit will do its thing, which is now something different from it was before, and the policy can certainly change in the future. I want this to more closely match what run-webkit-tests code does, not what WebKit does. Maybe allow-integrated-gpu? 1601485 16 386392 dino 2019-12-25 09:43:12 -0800 Comment on attachment 386392 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=386392&action=review >> Tools/ChangeLog:9 >> + Add an option "--prefer-integrated-gpu" to run-webkit-test > > I'm not a fan of this name either, because the preference is not about impacting what WebKit prefers to use. WebKit will do its thing, which is now something different from it was before, and the policy can certainly change in the future. I want this to more closely match what run-webkit-tests code does, not what WebKit does. > > Maybe allow-integrated-gpu? What WebKit does is not optional as far as WebKit is concerned: it will always prefer the integrated GPU. Content may request the discrete GPU, but it isn't guaranteed to get it. This parameter is a message to the testing system, telling it to not dictate WebKit's ability to use the integrated GPU. This is the problem. LayoutTestHelper is removing WebKit's ability to use the integrated GPU. In order to get more realistic testing, I think that LayoutTestHelper should stop doing this by default. Instead, there should be a parameter, something like --activate-discrete-gpu, that will turn the discrete GPU on, and thus force all WebKit content to be on that GPU, even if it didn't want to be. If doing this makes our bots more stable then we can enable the flag there, but our developers should not get it by default. 1601488 17 dino 2019-12-25 09:51:26 -0800 Committed r253910: <https://trac.webkit.org/changeset/253910> 1601491 18 ap 2019-12-25 10:33:58 -0800 > > Maybe allow-integrated-gpu? > > What WebKit does is not optional as far as WebKit is concerned: it will > always prefer the integrated GPU. Content may request the discrete GPU, but > it isn't guaranteed to get it. > > This parameter is a message to the testing system, telling it to not dictate > WebKit's ability to use the integrated GPU. This is the problem. > LayoutTestHelper is removing WebKit's ability to use the integrated GPU. It almost sounds like you are agreeing that "allow-integrated-gpu" would be more accurate :-) > In order to get more realistic testing <...> > If doing this makes our bots more stable then we can enable the flag there, > but our developers should not get it by default. Can you define "realistic" in this context, and explain the value of this realism in local testing? I'm not sure if you are talking about the ease of reproducing issues found by bots, or something else. We have bugs that are specific to versions of integrated GPU, not to mention AMD and Nvidia. If there is a plan to work through these in foreseeable future, we should discuss how to best support such effort in automation. I'm pretty sure that it will be more complex than switching a default for local testing. 1601530 19 dino 2019-12-26 11:58:05 -0800 (In reply to Alexey Proskuryakov from comment #18) > > > Maybe allow-integrated-gpu? > > > > What WebKit does is not optional as far as WebKit is concerned: it will > > always prefer the integrated GPU. Content may request the discrete GPU, but > > it isn't guaranteed to get it. > > > > This parameter is a message to the testing system, telling it to not dictate > > WebKit's ability to use the integrated GPU. This is the problem. > > LayoutTestHelper is removing WebKit's ability to use the integrated GPU. > > It almost sounds like you are agreeing that "allow-integrated-gpu" would be > more accurate :-) Maybe! I don't really mind what it is at the moment, because I strongly think the command line option should be flipped so that you have to explicitly lock to the discrete GPU if you want all WebGL tests to run on that GPU (assuming the user hasn't already done that in System Preferences). > > > In order to get more realistic testing <...> > > If doing this makes our bots more stable then we can enable the flag there, > > but our developers should not get it by default. > > Can you define "realistic" in this context, and explain the value of this > realism in local testing? I'm not sure if you are talking about the ease of > reproducing issues found by bots, or something else. Reality is: - most users have a single GPU that is integrated - most users with an extra GPU have automated graphics switching enabled (the default) - all of the above get the integrated GPU when running WebGL (*) (*) Exceptions: - The WebGL content explicitly requests "high-performance", in which case we *might* give them the discrete GPU - The discrete GPU is already active, or becomes active I think that our default testing environment, both for developers and the bots should reflect this reality. i.e. LayoutTestHelper should not enable the discrete GPU unless asked. If a developer, testing locally, wants to exercise the discrete GPU, they can do so either by passing the flag to run-webkit-tests, changing System Preferences, or launching another application that will turn it on. Same thing for a bot. If, as you say, some bots kernel panic when switching GPUs, then they have the choice of using the command line flag, setting System Preferences, skipping all tests that would trigger the discrete GPU, or even adding a WebKit preference that disallows the discrete GPU in WebGL. However, I'm slightly confused about this, because there are no current tests that trigger the discrete GPU. Was this happening before we switched the default to be the integrated GPU? > We have bugs that are specific to versions of integrated GPU, not to mention > AMD and Nvidia. If there is a plan to work through these in foreseeable > future, we should discuss how to best support such effort in automation. I'm > pretty sure that it will be more complex than switching a default for local > testing. I'm not sure what you mean. If there is a bug on specific hardware, and you don't have that hardware, then no default will help. My quest started when I saw EWS was crashing on a test, and I realised that I had not tested locally on any Intel GPU because LayoutTestHelper was doing something unusual (from a user's point of view). It turns out the crash did not reproduce on my Intel GPU, but it might have. But yes, we should have bots that run on all supported hardware, and in all GPU environments. I think the best thing to do there would be to work with our GPU team. 1601532 20 ap 2019-12-26 12:22:13 -0800 > I saw EWS was crashing on a test Quick note about this: EWS is 2013 Mac Pro, thus using discrete GPU. Good thing that we caught the issue early! 1601540 21 ap 2019-12-26 13:54:57 -0800 > However, I'm slightly confused about this, because there are no current tests that trigger the discrete GPU. How did this happen? This is like a pretty serious omission if we don't test high-performance at all. It's one thing to avoid wasting battery on fingerprinting or trivial uses of graphics, and another thing to not test the code path needed for games. > Was this happening before we switched the default to be the integrated GPU? Panics and freezes were happening before that. But it's not just about panicking. If there is any test that triggers a different mode globally, that means that other tests randomly run with this mode enabled. That's a nightmare scenario for diagnosing flaky tests. > I think that our default testing environment, both for developers and the bots should reflect this reality. i.e. LayoutTestHelper should not enable the discrete GPU unless asked. I think that this concept of IG vs. DG is fundamentally confused, because different IG chipsets have different behaviors too. We have a zero regression policy that applies to hardware models, one doesn't get to say things like "this regression only affects laptops" or "this regression only affects iMacs". There are two purposes for local testing: 1. Minimize the risk of landing something that has to be rolled back. For this, you want to have a configuration that's similar to the bots. Since EWS has DG and post-commit has IG, neither default is preferable from this standpoint. 2. Perform testing that bots cannot do because of their limited set of configurations. Since there is a wider variety of DG behaviors, it is beneficial to test that locally, so that they get at least some testing, and we don't ship completely untested software to customers. This can be revisited once we have a better solution, but we don't have it now. 1604933 22 jdarpinian 2020-01-09 17:12:30 -0800 Is this fully fixed? When I run WebGL layout tests, DumpRenderTree is still triggering a switch to the discrete GPU, though LayoutTestHelper doesn't anymore. 1605125 23 ap 2020-01-10 08:53:14 -0800 There were no changes to DumpRenderTree or WebKit here (which is why I didn't like the --prefer-integrated-gpu name). Still, it's strange because no tests were triggering discrete GPU according to Dean. > though LayoutTestHelper doesn't anymore Presumably when you run it with the new flag, correct? The default behavior shouldn't have changed here. 1605172 24 jdarpinian 2020-01-10 10:02:18 -0800 Yes. 386349 2019-12-23 12:52:38 -0800 2019-12-24 11:28:08 -0800 Patch bug-205546-20191224075237.patch text/plain 6101 dino U3VidmVyc2lvbiBSZXZpc2lvbjogMjUzODI2CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZmJhNGNhNDQxYWFmZmJiZDlhMTJhYWNiZjA5M2EyZDFk ODI4M2NiYi4uNDA4YjBiNjE2YTViOTEwNmQwZTY3ZDY5NTMwMzVkNDJhOTM5NjQ0MCAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3 IEBACisyMDE5LTEyLTIzICBEZWFuIEphY2tzb24gIDxkaW5vQGFwcGxlLmNvbT4KKworICAgICAg ICBXS1RSL0RSVCBhbHdheXMgdHJpZ2dlciB0aGUgRGlzY3JldGUgR1BVIG9uIGR1YWwgR1BVIHN5 c3RlbXMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIw NTU0NgorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNTgxMzk2MTA+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGFuIG9wdGlvbiAiLS11c2UtaW50 ZWdyYXRlZC1ncHUiIHRvIHJ1bi13ZWJraXQtdGVzdAorICAgICAgICB0aGF0IGNhdXNlcyB0aGUg TGF5b3V0VGVzdEhlbHBlciB0byBOT1QgbG9jayB0aGUKKyAgICAgICAgbWFjaGluZSB0byBhIGRp c2NyZXRlIEdQVSBvbiBhIGR1YWwtR1BVIHN5c3RlbS4KKyAgICAgICAgVGhlIGRlZmF1bHQgaXMg ZmFsc2UuCisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdEhlbHBlci5t OgorICAgICAgICAobWFpbik6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVz dHMvY29udHJvbGxlcnMvbWFuYWdlci5weToKKyAgICAgICAgKE1hbmFnZXIuX3NldF91cF9ydW4p OgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVz dHMucHk6CisgICAgICAgIChwYXJzZV9hcmdzKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtpdHB5 L3BvcnQvYmFzZS5weToKKyAgICAgICAgKFBvcnQuc3RhcnRfaGVscGVyKToKKyAgICAgICAgKiBT Y3JpcHRzL3dlYmtpdHB5L3BvcnQvbWFjLnB5OgorICAgICAgICAoTWFjUG9ydC5zdGFydF9oZWxw ZXIpOgorCiAyMDE5LTEyLTIwICBKaWV3ZW4gVGFuICA8amlld2VuX3RhbkBhcHBsZS5jb20+CiAK ICAgICAgICAgW1dlYkF1dGhuXSBJbXBsZW1lbnQgY29kZXJzIGZvciBDVEFQIENsaWVudFBJTiBy ZXF1ZXN0cyBhbmQgcmVzcG9uc2VzCmRpZmYgLS1naXQgYS9Ub29scy9EdW1wUmVuZGVyVHJlZS9t YWMvTGF5b3V0VGVzdEhlbHBlci5tIGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRl c3RIZWxwZXIubQppbmRleCA4NDc2MzIyMWQxMTNmNTA0NTY2MDdjMjA0MTkyMTBiZjZhM2M5ZWVj Li45MThiOTZlMTI3NWFmZGM2MWUwZTQ2NmE3YmY4Njg0ODljNTcwMDYwIDEwMDY0NAotLS0gYS9U b29scy9EdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdEhlbHBlci5tCisrKyBiL1Rvb2xzL0R1 bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0SGVscGVyLm0KQEAgLTU3LDYgKzU3LDcgQEAKIC8v IHJ1bm5pbmcgbGF5b3V0IHRlc3RzLgogCiBzdGF0aWMgaW50IGluc3RhbGxDb2xvclByb2ZpbGUg PSBmYWxzZTsKK3N0YXRpYyBpbnQgdXNlSW50ZWdyYXRlZEdQVSA9IGZhbHNlOwogc3RhdGljIHVp bnQzMl90IGFzc2VydGlvbklERm9yRGlzcGxheVNsZWVwID0gMDsKIHN0YXRpYyB1aW50MzJfdCBh c3NlcnRpb25JREZvclN5c3RlbVNsZWVwID0gMDsKIApAQCAtMjYxLDYgKzI2Miw3IEBAIGludCBt YWluKGludCBhcmdjLCBjaGFyKiBhcmd2W10pCiB7CiAgICAgc3RydWN0IG9wdGlvbiBvcHRpb25z W10gPSB7CiAgICAgICAgIHsgImluc3RhbGwtY29sb3ItcHJvZmlsZSIsIG5vX2FyZ3VtZW50LCAm aW5zdGFsbENvbG9yUHJvZmlsZSwgdHJ1ZSB9LAorICAgICAgICB7ICJ1c2UtaW50ZWdyYXRlZC1n cHUiLCBub19hcmd1bWVudCwgJnVzZUludGVncmF0ZWRHUFUsIHRydWUgfSwKICAgICB9OwogCiAg ICAgaW50IG9wdGlvbjsKQEAgLTI3OSw3ICsyODEsOCBAQCBpbnQgbWFpbihpbnQgYXJnYywgY2hh ciogYXJndltdKQogICAgIHNpZ25hbChTSUdURVJNLCBzaW1wbGVTaWduYWxIYW5kbGVyKTsKIAog ICAgIGFkZFNsZWVwQXNzZXJ0aW9ucygpOwotICAgIGxvY2tEb3duRGlzY3JldGVHcmFwaGljcygp OworICAgIGlmICghdXNlSW50ZWdyYXRlZEdQVSkKKyAgICAgICAgbG9ja0Rvd25EaXNjcmV0ZUdy YXBoaWNzKCk7CiAKICAgICAvLyBTYXZlIG9mZiB0aGUgY3VycmVudCBwcm9maWxlLCBhbmQgdGhl biBpbnN0YWxsIHRoZSBsYXlvdXQgdGVzdCBwcm9maWxlLgogICAgIGluc3RhbGxMYXlvdXRUZXN0 Q29sb3JQcm9maWxlKCk7CmRpZmYgLS1naXQgYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91 dF90ZXN0cy9jb250cm9sbGVycy9tYW5hZ2VyLnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9s YXlvdXRfdGVzdHMvY29udHJvbGxlcnMvbWFuYWdlci5weQppbmRleCAzYzE1MmE2M2Q3ZjQ3MThm MmM2ZTg4YTBkZTY3MDdiNDExMjA4NmUxLi41NDM2Y2Q0YzdkMzgwZDQwMzkxZjkwZWEzMGQyOTU0 NjY0NzhjZGUxIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0 cy9jb250cm9sbGVycy9tYW5hZ2VyLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5 b3V0X3Rlc3RzL2NvbnRyb2xsZXJzL21hbmFnZXIucHkKQEAgLTE2MCw3ICsxNjAsNyBAQCBjbGFz cyBNYW5hZ2VyKG9iamVjdCk6CiAgICAgICAgICMgVGhpcyBtdXN0IGJlIHN0YXJ0ZWQgYmVmb3Jl IHdlIGNoZWNrIHRoZSBzeXN0ZW0gZGVwZW5kZW5jaWVzLAogICAgICAgICAjIHNpbmNlIHRoZSBo ZWxwZXIgbWF5IGRvIHRoaW5ncyB0byBtYWtlIHRoZSBzZXR1cCBjb3JyZWN0LgogICAgICAgICBz ZWxmLl9wcmludGVyLndyaXRlX3VwZGF0ZSgiU3RhcnRpbmcgaGVscGVyIC4uLiIpCi0gICAgICAg IGlmIG5vdCBzZWxmLl9wb3J0LnN0YXJ0X2hlbHBlcihzZWxmLl9vcHRpb25zLnBpeGVsX3Rlc3Rz KToKKyAgICAgICAgaWYgbm90IHNlbGYuX3BvcnQuc3RhcnRfaGVscGVyKHBpeGVsX3Rlc3RzPXNl bGYuX29wdGlvbnMucGl4ZWxfdGVzdHMsIHVzZV9pbnRlZ3JhdGVkX2dwdT1zZWxmLl9vcHRpb25z LnVzZV9pbnRlZ3JhdGVkX2dwdSk6CiAgICAgICAgICAgICByZXR1cm4gRmFsc2UKIAogICAgICAg ICBzZWxmLl91cGRhdGVfd29ya2VyX2NvdW50KHRlc3RfbmFtZXMsIGRldmljZV90eXBlPWRldmlj ZV90eXBlKQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMv cnVuX3dlYmtpdF90ZXN0cy5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3Rz L3J1bl93ZWJraXRfdGVzdHMucHkKaW5kZXggMjAxMzEzYTBhNDIzNjMyZWQwYTgwZTQ2MWI1N2Ix ZWQ4MGZjMTZiNy4uN2EwMjUyNjljZWY5MzUxYzcxMjA1Y2Y3MDQ1YmE2YzIwNGVjMDhkZiAxMDA3 NTUKLS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90 ZXN0cy5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Vi a2l0X3Rlc3RzLnB5CkBAIC0zMjcsNiArMzI3LDkgQEAgZGVmIHBhcnNlX2FyZ3MoYXJncyk6CiAg ICAgICAgIG9wdHBhcnNlLm1ha2Vfb3B0aW9uKAogICAgICAgICAgICAgIi0tdXNlLWdwdS1wcm9j ZXNzIiwgYWN0aW9uPSJzdG9yZV90cnVlIiwgZGVmYXVsdD1GYWxzZSwKICAgICAgICAgICAgIGhl bHA9KCJFbmFibGUgYWxsIEdQVSBwcm9jZXNzIHJlbGF0ZWQgZmVhdHVyZXMsIGFsc28gc2V0IGFk ZGl0aW9uYWwgZXhwZWN0YXRpb25zIGFuZCB0aGUgcmVzdWx0IHJlcG9ydCBmbGF2b3IuIikpLAor ICAgICAgICBvcHRwYXJzZS5tYWtlX29wdGlvbigKKyAgICAgICAgICAgICItLXVzZS1pbnRlZ3Jh dGVkLWdwdSIsIGFjdGlvbj0ic3RvcmVfdHJ1ZSIsIGRlZmF1bHQ9RmFsc2UsCisgICAgICAgICAg ICBoZWxwPSgiQXR0ZW1wdCB0byB1c2Ugb25seSB0aGUgaW50ZWdyYXRlZCBHUFUgb24gYSBkdWFs LUdQVSBzeXN0ZW0uIikpLAogICAgIF0pKQogCiAgICAgb3B0aW9uX2dyb3VwX2RlZmluaXRpb25z LmFwcGVuZCgoIldlYiBQbGF0Zm9ybSBUZXN0IFNlcnZlciBPcHRpb25zIiwgWwpkaWZmIC0tZ2l0 IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2Jhc2UucHkgYi9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L3BvcnQvYmFzZS5weQppbmRleCBjNzRmYTM1OWI2MmE3N2RkNmZlMGE1ZmNkZWIxNmNk MDhjZmNjMTE1Li5jMTNkMmMyMGNkZjNkZTYxMWQ5MDUyZWU0YTY5MmY3ZDY3ZGE3YjgyIDEwMDY0 NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvYmFzZS5weQorKysgYi9Ub29scy9T Y3JpcHRzL3dlYmtpdHB5L3BvcnQvYmFzZS5weQpAQCAtOTQ5LDcgKzk0OSw3IEBAIGNsYXNzIFBv cnQob2JqZWN0KToKICAgICAgICAgIiIiUmV0dXJuIGEgbmV3bHkgY3JlYXRlZCBEcml2ZXIgc3Vi Y2xhc3MgZm9yIHN0YXJ0aW5nL3N0b3BwaW5nIHRoZSB0ZXN0IGRyaXZlci4iIiIKICAgICAgICAg cmV0dXJuIGRyaXZlci5Ecml2ZXJQcm94eShzZWxmLCB3b3JrZXJfbnVtYmVyLCBzZWxmLl9kcml2 ZXJfY2xhc3MoKSwgcGl4ZWxfdGVzdHM9c2VsZi5nZXRfb3B0aW9uKCdwaXhlbF90ZXN0cycpLCBu b190aW1lb3V0PW5vX3RpbWVvdXQpCiAKLSAgICBkZWYgc3RhcnRfaGVscGVyKHNlbGYsIHBpeGVs X3Rlc3RzPUZhbHNlKToKKyAgICBkZWYgc3RhcnRfaGVscGVyKHNlbGYsIHBpeGVsX3Rlc3RzPUZh bHNlLCB1c2VfaW50ZWdyYXRlZF9ncHU9RmFsc2UpOgogICAgICAgICAiIiJJZiBhIHBvcnQgbmVl ZHMgdG8gcmVjb25maWd1cmUgZ3JhcGhpY3Mgc2V0dGluZ3Mgb3IgZG8gb3RoZXIKICAgICAgICAg dGhpbmdzIHRvIGVuc3VyZSBhIGtub3duIHRlc3QgY29uZmlndXJhdGlvbiwgaXQgc2hvdWxkIG92 ZXJyaWRlIHRoaXMKICAgICAgICAgbWV0aG9kLiIiIgpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0 cy93ZWJraXRweS9wb3J0L21hYy5weSBiL1Rvb2xzL1NjcmlwdHMvd2Via2l0cHkvcG9ydC9tYWMu cHkKaW5kZXggYjVmNjJhOTg3MGZmMDIwNmRlMDc5NDExMDY5Y2FlNTllMWJiNWQ1My4uODc3Njg5 ZmM2Y2QwZDI3YzZlMWQwYWM4ODg5YjE0NmVlOTBhYjJiOSAxMDA2NDQKLS0tIGEvVG9vbHMvU2Ny aXB0cy93ZWJraXRweS9wb3J0L21hYy5weQorKysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3Bv cnQvbWFjLnB5CkBAIC0yMTIsMTMgKzIxMiwxNSBAQCBjbGFzcyBNYWNQb3J0KERhcndpblBvcnQp OgogICAgICAgICAgICAgc3VwcG9ydGFibGVfaW5zdGFuY2VzID0gZGVmYXVsdF9jb3VudAogICAg ICAgICByZXR1cm4gbWluKHN1cHBvcnRhYmxlX2luc3RhbmNlcywgZGVmYXVsdF9jb3VudCkKIAot ICAgIGRlZiBzdGFydF9oZWxwZXIoc2VsZiwgcGl4ZWxfdGVzdHM9RmFsc2UpOgorICAgIGRlZiBz dGFydF9oZWxwZXIoc2VsZiwgcGl4ZWxfdGVzdHM9RmFsc2UsIHVzZV9pbnRlZ3JhdGVkX2dwdT1G YWxzZSk6CiAgICAgICAgIGhlbHBlcl9wYXRoID0gc2VsZi5fcGF0aF90b19oZWxwZXIoKQogICAg ICAgICBpZiBub3QgaGVscGVyX3BhdGg6CiAgICAgICAgICAgICBfbG9nLmVycm9yKCJObyBwYXRo IHRvIExheW91dFRlc3RIZWxwZXIgYmluYXJ5IikKICAgICAgICAgICAgIHJldHVybiBGYWxzZQog ICAgICAgICBfbG9nLmRlYnVnKCJTdGFydGluZyBsYXlvdXQgaGVscGVyICVzIiAlIGhlbHBlcl9w YXRoKQogICAgICAgICBhcmd1bWVudHMgPSBbaGVscGVyX3BhdGgsICctLWluc3RhbGwtY29sb3It cHJvZmlsZSddCisgICAgICAgIGlmIHVzZV9pbnRlZ3JhdGVkX2dwdToKKyAgICAgICAgICAgIGFy Z3VtZW50cy5hcHBlbmQoJy0tdXNlLWludGVncmF0ZWQtZ3B1JykKICAgICAgICAgc2VsZi5faGVs cGVyID0gc2VsZi5fZXhlY3V0aXZlLnBvcGVuKGFyZ3VtZW50cywKICAgICAgICAgICAgIHN0ZGlu PXNlbGYuX2V4ZWN1dGl2ZS5QSVBFLCBzdGRvdXQ9c2VsZi5fZXhlY3V0aXZlLlBJUEUsIHN0ZGVy cj1Ob25lKQogICAgICAgICBpc19yZWFkeSA9IHNlbGYuX2hlbHBlci5zdGRvdXQucmVhZGxpbmUo KQo= 386392 2019-12-24 11:28:12 -0800 2019-12-24 12:40:54 -0800 Patch bug-205546-20191225062810.patch text/plain 6853 dino U3VidmVyc2lvbiBSZXZpc2lvbjogMjUzODk5CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cg Yi9Ub29scy9DaGFuZ2VMb2cKaW5kZXggZDM3NmJmMjA1N2YyNjZiNjdiNTZhMDFkNjE3NzllMThh ODI2ZmM1OC4uMjU0YjZmMDEzNmQxM2YzODE2ZDc0OWE1ZDFmYjI0MjZkMjliNGJiYyAxMDA2NDQK LS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI5 IEBACisyMDE5LTEyLTI0ICBEZWFuIEphY2tzb24gIDxkaW5vQGFwcGxlLmNvbT4KKworICAgICAg ICBXS1RSL0RSVCBhbHdheXMgdHJpZ2dlciB0aGUgRGlzY3JldGUgR1BVIG9uIGR1YWwgR1BVIHN5 c3RlbXMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIw NTU0NgorICAgICAgICA8cmRhcjovL3Byb2JsZW0vNTgxMzk2MTA+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIGFuIG9wdGlvbiAiLS1wcmVmZXIt aW50ZWdyYXRlZC1ncHUiIHRvIHJ1bi13ZWJraXQtdGVzdAorICAgICAgICB0aGF0IGNhdXNlcyB0 aGUgTGF5b3V0VGVzdEhlbHBlciB0byBOT1QgbG9jayB0aGUKKyAgICAgICAgbWFjaGluZSB0byBh IGRpc2NyZXRlIEdQVSBvbiBhIGR1YWwtR1BVIHN5c3RlbS4KKyAgICAgICAgVGhlIGRlZmF1bHQg aXMgZmFsc2UuCisKKyAgICAgICAgKiBEdW1wUmVuZGVyVHJlZS9tYWMvTGF5b3V0VGVzdEhlbHBl ci5tOgorICAgICAgICAobWFpbik6CisgICAgICAgICogU2NyaXB0cy93ZWJraXRweS9sYXlvdXRf dGVzdHMvY29udHJvbGxlcnMvbWFuYWdlci5weToKKyAgICAgICAgKE1hbmFnZXIuX3NldF91cF9y dW4pOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRf dGVzdHMucHk6CisgICAgICAgIChwYXJzZV9hcmdzKToKKyAgICAgICAgKiBTY3JpcHRzL3dlYmtp dHB5L3BvcnQvYmFzZS5weToKKyAgICAgICAgKFBvcnQuc3RhcnRfaGVscGVyKToKKyAgICAgICAg KiBTY3JpcHRzL3dlYmtpdHB5L3BvcnQvbWFjLnB5OgorICAgICAgICAoTWFjUG9ydC5zdGFydF9o ZWxwZXIpOgorICAgICAgICAqIFNjcmlwdHMvd2Via2l0cHkvcG9ydC9tb2NrX2RydC5weToKKyAg ICAgICAgKE1vY2tEUlRQb3J0LnN0YXJ0X2hlbHBlcik6CisKIDIwMTktMTItMjQgIFlvdWVubiBG YWJsZXQgIDx5b3Vlbm5AYXBwbGUuY29tPgogCiAgICAgICAgIERlbnkgTm90aWZpY2F0aW9uIEFQ SSBhY2Nlc3MgZm9yIG5vbiBzZWN1cmUgY29udGV4dHMKZGlmZiAtLWdpdCBhL1Rvb2xzL0R1bXBS ZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0SGVscGVyLm0gYi9Ub29scy9EdW1wUmVuZGVyVHJlZS9t YWMvTGF5b3V0VGVzdEhlbHBlci5tCmluZGV4IDg0NzYzMjIxZDExM2Y1MDQ1NjYwN2MyMDQxOTIx MGJmNmEzYzllZWMuLjhmZmQyMmQ2OTdhYjU3YTY5ZmZiMGU0YTc5MmI5NzJmZmY3ZmYwZWMgMTAw NjQ0Ci0tLSBhL1Rvb2xzL0R1bXBSZW5kZXJUcmVlL21hYy9MYXlvdXRUZXN0SGVscGVyLm0KKysr IGIvVG9vbHMvRHVtcFJlbmRlclRyZWUvbWFjL0xheW91dFRlc3RIZWxwZXIubQpAQCAtNTcsNiAr NTcsNyBAQAogLy8gcnVubmluZyBsYXlvdXQgdGVzdHMuCiAKIHN0YXRpYyBpbnQgaW5zdGFsbENv bG9yUHJvZmlsZSA9IGZhbHNlOworc3RhdGljIGludCBwcmVmZXJJbnRlZ3JhdGVkR1BVID0gZmFs c2U7CiBzdGF0aWMgdWludDMyX3QgYXNzZXJ0aW9uSURGb3JEaXNwbGF5U2xlZXAgPSAwOwogc3Rh dGljIHVpbnQzMl90IGFzc2VydGlvbklERm9yU3lzdGVtU2xlZXAgPSAwOwogCkBAIC0yNjEsNiAr MjYyLDcgQEAgaW50IG1haW4oaW50IGFyZ2MsIGNoYXIqIGFyZ3ZbXSkKIHsKICAgICBzdHJ1Y3Qg b3B0aW9uIG9wdGlvbnNbXSA9IHsKICAgICAgICAgeyAiaW5zdGFsbC1jb2xvci1wcm9maWxlIiwg bm9fYXJndW1lbnQsICZpbnN0YWxsQ29sb3JQcm9maWxlLCB0cnVlIH0sCisgICAgICAgIHsgInBy ZWZlci1pbnRlZ3JhdGVkLWdwdSIsIG5vX2FyZ3VtZW50LCAmcHJlZmVySW50ZWdyYXRlZEdQVSwg dHJ1ZSB9LAogICAgIH07CiAKICAgICBpbnQgb3B0aW9uOwpAQCAtMjc5LDcgKzI4MSw4IEBAIGlu dCBtYWluKGludCBhcmdjLCBjaGFyKiBhcmd2W10pCiAgICAgc2lnbmFsKFNJR1RFUk0sIHNpbXBs ZVNpZ25hbEhhbmRsZXIpOwogCiAgICAgYWRkU2xlZXBBc3NlcnRpb25zKCk7Ci0gICAgbG9ja0Rv d25EaXNjcmV0ZUdyYXBoaWNzKCk7CisgICAgaWYgKCFwcmVmZXJJbnRlZ3JhdGVkR1BVKQorICAg ICAgICBsb2NrRG93bkRpc2NyZXRlR3JhcGhpY3MoKTsKIAogICAgIC8vIFNhdmUgb2ZmIHRoZSBj dXJyZW50IHByb2ZpbGUsIGFuZCB0aGVuIGluc3RhbGwgdGhlIGxheW91dCB0ZXN0IHByb2ZpbGUu CiAgICAgaW5zdGFsbExheW91dFRlc3RDb2xvclByb2ZpbGUoKTsKZGlmZiAtLWdpdCBhL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2NvbnRyb2xsZXJzL21hbmFnZXIucHkgYi9U b29scy9TY3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9jb250cm9sbGVycy9tYW5hZ2VyLnB5 CmluZGV4IDNjMTUyYTYzZDdmNDcxOGYyYzZlODhhMGRlNjcwN2I0MTEyMDg2ZTEuLmQ4ZmFhYjI5 YWEyODkxY2RjNDg0ZmQ2ODllMDM2ZDgwZGRjOTQ0MGMgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Njcmlw dHMvd2Via2l0cHkvbGF5b3V0X3Rlc3RzL2NvbnRyb2xsZXJzL21hbmFnZXIucHkKKysrIGIvVG9v bHMvU2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvY29udHJvbGxlcnMvbWFuYWdlci5weQpA QCAtMTYwLDcgKzE2MCw3IEBAIGNsYXNzIE1hbmFnZXIob2JqZWN0KToKICAgICAgICAgIyBUaGlz IG11c3QgYmUgc3RhcnRlZCBiZWZvcmUgd2UgY2hlY2sgdGhlIHN5c3RlbSBkZXBlbmRlbmNpZXMs CiAgICAgICAgICMgc2luY2UgdGhlIGhlbHBlciBtYXkgZG8gdGhpbmdzIHRvIG1ha2UgdGhlIHNl dHVwIGNvcnJlY3QuCiAgICAgICAgIHNlbGYuX3ByaW50ZXIud3JpdGVfdXBkYXRlKCJTdGFydGlu ZyBoZWxwZXIgLi4uIikKLSAgICAgICAgaWYgbm90IHNlbGYuX3BvcnQuc3RhcnRfaGVscGVyKHNl bGYuX29wdGlvbnMucGl4ZWxfdGVzdHMpOgorICAgICAgICBpZiBub3Qgc2VsZi5fcG9ydC5zdGFy dF9oZWxwZXIocGl4ZWxfdGVzdHM9c2VsZi5fb3B0aW9ucy5waXhlbF90ZXN0cywgcHJlZmVyX2lu dGVncmF0ZWRfZ3B1PXNlbGYuX29wdGlvbnMucHJlZmVyX2ludGVncmF0ZWRfZ3B1KToKICAgICAg ICAgICAgIHJldHVybiBGYWxzZQogCiAgICAgICAgIHNlbGYuX3VwZGF0ZV93b3JrZXJfY291bnQo dGVzdF9uYW1lcywgZGV2aWNlX3R5cGU9ZGV2aWNlX3R5cGUpCmRpZmYgLS1naXQgYS9Ub29scy9T Y3JpcHRzL3dlYmtpdHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5IGIvVG9vbHMv U2NyaXB0cy93ZWJraXRweS9sYXlvdXRfdGVzdHMvcnVuX3dlYmtpdF90ZXN0cy5weQppbmRleCAy MDEzMTNhMGE0MjM2MzJlZDBhODBlNDYxYjU3YjFlZDgwZmMxNmI3Li45OGY4NTE1ZGVmMWI3OGM3 OWE4YjYyN2JhZTU2NjhjYWUyNDQzNGMyIDEwMDc1NQotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtp dHB5L2xheW91dF90ZXN0cy9ydW5fd2Via2l0X3Rlc3RzLnB5CisrKyBiL1Rvb2xzL1NjcmlwdHMv d2Via2l0cHkvbGF5b3V0X3Rlc3RzL3J1bl93ZWJraXRfdGVzdHMucHkKQEAgLTMyNyw2ICszMjcs OSBAQCBkZWYgcGFyc2VfYXJncyhhcmdzKToKICAgICAgICAgb3B0cGFyc2UubWFrZV9vcHRpb24o CiAgICAgICAgICAgICAiLS11c2UtZ3B1LXByb2Nlc3MiLCBhY3Rpb249InN0b3JlX3RydWUiLCBk ZWZhdWx0PUZhbHNlLAogICAgICAgICAgICAgaGVscD0oIkVuYWJsZSBhbGwgR1BVIHByb2Nlc3Mg cmVsYXRlZCBmZWF0dXJlcywgYWxzbyBzZXQgYWRkaXRpb25hbCBleHBlY3RhdGlvbnMgYW5kIHRo ZSByZXN1bHQgcmVwb3J0IGZsYXZvci4iKSksCisgICAgICAgIG9wdHBhcnNlLm1ha2Vfb3B0aW9u KAorICAgICAgICAgICAgIi0tcHJlZmVyLWludGVncmF0ZWQtZ3B1IiwgYWN0aW9uPSJzdG9yZV90 cnVlIiwgZGVmYXVsdD1GYWxzZSwKKyAgICAgICAgICAgIGhlbHA9KCJQcmVmZXIgdXNpbmcgdGhl IGxvd2VyLXBvd2VyIGludGVncmF0ZWQgR1BVIG9uIGEgZHVhbC1HUFUgc3lzdGVtLiBOb3RlIHRo YXQgb3RoZXIgcnVubmluZyBhcHBsaWNhdGlvbnMgYW5kIHRoZSB0ZXN0cyB0aGVtc2VsdmVzIGNh biBvdmVycmlkZSB0aGlzIHJlcXVlc3QuIikpLAogICAgIF0pKQogCiAgICAgb3B0aW9uX2dyb3Vw X2RlZmluaXRpb25zLmFwcGVuZCgoIldlYiBQbGF0Zm9ybSBUZXN0IFNlcnZlciBPcHRpb25zIiwg WwpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L2Jhc2UucHkgYi9Ub29s cy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvYmFzZS5weQppbmRleCBjNzRmYTM1OWI2MmE3N2RkNmZl MGE1ZmNkZWIxNmNkMDhjZmNjMTE1Li5kZTAwNjY2N2IyZDFlNWU1ZWViOGYyZDFhNDQ4Yjc1NmY3 ZjA2NmNkIDEwMDY0NAotLS0gYS9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvYmFzZS5weQor KysgYi9Ub29scy9TY3JpcHRzL3dlYmtpdHB5L3BvcnQvYmFzZS5weQpAQCAtOTQ5LDcgKzk0OSw3 IEBAIGNsYXNzIFBvcnQob2JqZWN0KToKICAgICAgICAgIiIiUmV0dXJuIGEgbmV3bHkgY3JlYXRl ZCBEcml2ZXIgc3ViY2xhc3MgZm9yIHN0YXJ0aW5nL3N0b3BwaW5nIHRoZSB0ZXN0IGRyaXZlci4i IiIKICAgICAgICAgcmV0dXJuIGRyaXZlci5Ecml2ZXJQcm94eShzZWxmLCB3b3JrZXJfbnVtYmVy LCBzZWxmLl9kcml2ZXJfY2xhc3MoKSwgcGl4ZWxfdGVzdHM9c2VsZi5nZXRfb3B0aW9uKCdwaXhl bF90ZXN0cycpLCBub190aW1lb3V0PW5vX3RpbWVvdXQpCiAKLSAgICBkZWYgc3RhcnRfaGVscGVy KHNlbGYsIHBpeGVsX3Rlc3RzPUZhbHNlKToKKyAgICBkZWYgc3RhcnRfaGVscGVyKHNlbGYsIHBp eGVsX3Rlc3RzPUZhbHNlLCBwcmVmZXJfaW50ZWdyYXRlZF9ncHU9RmFsc2UpOgogICAgICAgICAi IiJJZiBhIHBvcnQgbmVlZHMgdG8gcmVjb25maWd1cmUgZ3JhcGhpY3Mgc2V0dGluZ3Mgb3IgZG8g b3RoZXIKICAgICAgICAgdGhpbmdzIHRvIGVuc3VyZSBhIGtub3duIHRlc3QgY29uZmlndXJhdGlv biwgaXQgc2hvdWxkIG92ZXJyaWRlIHRoaXMKICAgICAgICAgbWV0aG9kLiIiIgpkaWZmIC0tZ2l0 IGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L21hYy5weSBiL1Rvb2xzL1NjcmlwdHMvd2Vi a2l0cHkvcG9ydC9tYWMucHkKaW5kZXggYjVmNjJhOTg3MGZmMDIwNmRlMDc5NDExMDY5Y2FlNTll MWJiNWQ1My4uMzVkNDhjZGY2MmYwZjk2YTkyYTEyODk0NjlmOWRjMjI5ODA3MDRhZiAxMDA2NDQK LS0tIGEvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L21hYy5weQorKysgYi9Ub29scy9TY3Jp cHRzL3dlYmtpdHB5L3BvcnQvbWFjLnB5CkBAIC0yMTIsMTMgKzIxMiwxNSBAQCBjbGFzcyBNYWNQ b3J0KERhcndpblBvcnQpOgogICAgICAgICAgICAgc3VwcG9ydGFibGVfaW5zdGFuY2VzID0gZGVm YXVsdF9jb3VudAogICAgICAgICByZXR1cm4gbWluKHN1cHBvcnRhYmxlX2luc3RhbmNlcywgZGVm YXVsdF9jb3VudCkKIAotICAgIGRlZiBzdGFydF9oZWxwZXIoc2VsZiwgcGl4ZWxfdGVzdHM9RmFs c2UpOgorICAgIGRlZiBzdGFydF9oZWxwZXIoc2VsZiwgcGl4ZWxfdGVzdHM9RmFsc2UsIHByZWZl cl9pbnRlZ3JhdGVkX2dwdT1GYWxzZSk6CiAgICAgICAgIGhlbHBlcl9wYXRoID0gc2VsZi5fcGF0 aF90b19oZWxwZXIoKQogICAgICAgICBpZiBub3QgaGVscGVyX3BhdGg6CiAgICAgICAgICAgICBf bG9nLmVycm9yKCJObyBwYXRoIHRvIExheW91dFRlc3RIZWxwZXIgYmluYXJ5IikKICAgICAgICAg ICAgIHJldHVybiBGYWxzZQogICAgICAgICBfbG9nLmRlYnVnKCJTdGFydGluZyBsYXlvdXQgaGVs cGVyICVzIiAlIGhlbHBlcl9wYXRoKQogICAgICAgICBhcmd1bWVudHMgPSBbaGVscGVyX3BhdGgs ICctLWluc3RhbGwtY29sb3ItcHJvZmlsZSddCisgICAgICAgIGlmIHByZWZlcl9pbnRlZ3JhdGVk X2dwdToKKyAgICAgICAgICAgIGFyZ3VtZW50cy5hcHBlbmQoJy0tcHJlZmVyLWludGVncmF0ZWQt Z3B1JykKICAgICAgICAgc2VsZi5faGVscGVyID0gc2VsZi5fZXhlY3V0aXZlLnBvcGVuKGFyZ3Vt ZW50cywKICAgICAgICAgICAgIHN0ZGluPXNlbGYuX2V4ZWN1dGl2ZS5QSVBFLCBzdGRvdXQ9c2Vs Zi5fZXhlY3V0aXZlLlBJUEUsIHN0ZGVycj1Ob25lKQogICAgICAgICBpc19yZWFkeSA9IHNlbGYu X2hlbHBlci5zdGRvdXQucmVhZGxpbmUoKQpkaWZmIC0tZ2l0IGEvVG9vbHMvU2NyaXB0cy93ZWJr aXRweS9wb3J0L21vY2tfZHJ0LnB5IGIvVG9vbHMvU2NyaXB0cy93ZWJraXRweS9wb3J0L21vY2tf ZHJ0LnB5CmluZGV4IGM5NThkZjQzNzg0NmMwZDVlYTJiZjM1NGIwNzUwNDA4N2I4MTIwNTkuLjgx Y2FlNDhkMGQzY2QwMmU0ZjEzZTJiYzMxMjExYjJhODY5MGM2YzEgMTAwNjQ0Ci0tLSBhL1Rvb2xz L1NjcmlwdHMvd2Via2l0cHkvcG9ydC9tb2NrX2RydC5weQorKysgYi9Ub29scy9TY3JpcHRzL3dl YmtpdHB5L3BvcnQvbW9ja19kcnQucHkKQEAgLTEwMSw3ICsxMDEsNyBAQCBjbGFzcyBNb2NrRFJU UG9ydChvYmplY3QpOgogCiAgICAgICAgIHJldHVybiBuZXdfY21kX2xpbmUKIAotICAgIGRlZiBz dGFydF9oZWxwZXIoc2VsZiwgcGl4ZWxfdGVzdHM9RmFsc2UpOgorICAgIGRlZiBzdGFydF9oZWxw ZXIoc2VsZiwgcGl4ZWxfdGVzdHM9RmFsc2UsIHByZWZlcl9pbnRlZ3JhdGVkX2dwdT1GYWxzZSk6 CiAgICAgICAgIHBhc3MKIAogICAgIGRlZiBzdGFydF9odHRwX3NlcnZlcihzZWxmLCBudW1iZXJf b2Zfc2VydmVycyk6Cg==