228137 2021-07-20 20:34:41 -0700 Improve time precision when cross-origin isolated via COOP+COEP 2021-09-01 14:35:11 -0700 1 1 1 Unclassified WebKit JavaScriptCore WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED https://bugs.webkit.org/show_bug.cgi?id=180910 InRadar P2 Normal --- 229559 228755 1 keith_miller cdumez achristensen annulen anthony.bowker cdumez darin esprehn+autocc ews-watchlist ggaren gyuyoung.kim kangil.han rniwa ryuan.choi saam sam sergio webkit-bug-importer ysuzuki oldest_to_newest 1778354 0 keith_miller 2021-07-20 20:34:41 -0700 It doesn’t make any sense to keep time precision reduced if SAB is enabled for a page. 1778603 1 sam 2021-07-21 16:53:39 -0700 (I'm terrible with acronyms, sorry) what is SAB? 1778617 2 ysuzuki 2021-07-21 17:34:31 -0700 (In reply to Sam Weinig from comment #1) > (I'm terrible with acronyms, sorry) what is SAB? SharedArrayBuffer :) 1778720 3 sam 2021-07-22 09:28:36 -0700 (In reply to Yusuke Suzuki from comment #2) > (In reply to Sam Weinig from comment #1) > > (I'm terrible with acronyms, sorry) what is SAB? > > SharedArrayBuffer :) Ah! Thanks!. 1779944 4 webkit-bug-importer 2021-07-27 20:35:17 -0700 <rdar://problem/81197138> 1788063 5 cdumez 2021-08-27 10:39:19 -0700 According to https://developer.chrome.com/blog/cross-origin-isolated-hr-timers/ and blink code inspection, it looks like Chrome is using 100us precision in general and 5ns when cross-origin isolated. It looks like WebKit is using a much higher 1ms precision in general currently. I guess we need to decide what precision we want to use when cross-origin-isolated. Do we want to go back to 100us, like before r226495? It would still make us nowhere near Chrome in terms of precision. 1788068 6 cdumez 2021-08-27 10:49:23 -0700 (In reply to Chris Dumez from comment #5) > According to > https://developer.chrome.com/blog/cross-origin-isolated-hr-timers/ and blink > code inspection, it looks like Chrome is using 100us precision in general > and 5ns when cross-origin isolated. > > It looks like WebKit is using a much higher 1ms precision in general > currently. > > I guess we need to decide what precision we want to use when > cross-origin-isolated. Do we want to go back to 100us, like before r226495? > It would still make us nowhere near Chrome in terms of precision. Looks like Gecko is using 1ms for general precision and 20us for cross-origin-isolated precision. Maybe we should at least match Gecko from cross-origin-isolated precision? 1788074 7 keith_miller 2021-08-27 10:56:34 -0700 I'm not positive but I would guess that someone could get a statistically significant sub-us precision from SAB (due to scheduling on the timer thread). So once we have SAB it's not clear how much value there is around giving something greater than 1us timing. It's probably worth verifying my assumption though. 1788115 8 rniwa 2021-08-27 12:30:26 -0700 Matching Gecko makes sense. We need to come up with a strategy to mitigate malicious websites using timing attacks to read out history database. Full GPU process support & move of visited link color work done in GPU process will mitigate that to a large extent. 1788148 9 436668 cdumez 2021-08-27 13:39:38 -0700 Created attachment 436668 Patch 1788149 10 436669 cdumez 2021-08-27 13:40:53 -0700 Created attachment 436669 Patch 1788186 11 436669 rniwa 2021-08-27 14:46:57 -0700 Comment on attachment 436669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=436669&action=review > Source/WebCore/page/Performance.cpp:63 > +constexpr Seconds highTimePrecision { 20_us }; Does Mozilla allow 20microseconds without jitters or with jitters? If with jitters, since we don't have jitters, we may want to stick with 50microseconds. > Source/WebCore/page/Performance.cpp:97 > +void Performance::setShouldAllowHighPrecisionTime() Maybe we should call this allowHighPrecisionTime? > Source/WebCore/page/Performance.cpp:104 > - double resolution = (1000_us).seconds(); > + double resolution = shouldAllowHighPrecisionTime ? highTimePrecision.seconds() : regularTimePrecision.seconds(); It's not great that we'd have to do a runtime switch on every function call although the branch prediction helps. Can this also be static given we determine this at web process initialization time? 1789328 12 436669 cdumez 2021-09-01 08:28:09 -0700 Comment on attachment 436669 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=436669&action=review >> Source/WebCore/page/Performance.cpp:63 >> +constexpr Seconds highTimePrecision { 20_us }; > > Does Mozilla allow 20microseconds without jitters or with jitters? > If with jitters, since we don't have jitters, we may want to stick with 50microseconds. I don't know what jitters means here. I am not sure what the answer is. The fact is though that Chrome is providing much more accuracy. Also, according to both Phil and Keith, SharedArrayBuffer already provides a much greater precision anyway. 1789331 13 437034 cdumez 2021-09-01 08:35:55 -0700 Created attachment 437034 Patch 1789381 14 achristensen 2021-09-01 11:26:51 -0700 (In reply to Chris Dumez from comment #5) > According to > https://developer.chrome.com/blog/cross-origin-isolated-hr-timers/ and blink > code inspection, it looks like Chrome is using 100us precision in general > and 5ns when cross-origin isolated. 5us not 5ns. > I don't know what jitters means here. I am not sure what the answer is. "jitters" here means adding a random value in an attempt to make timing attacks harder. That sounds expensive and not as helpful as you might think. (In reply to Ryosuke Niwa from comment #11) > Does Mozilla allow 20microseconds without jitters or with jitters? I think both. 1789383 15 rniwa 2021-09-01 11:35:04 -0700 (In reply to Alex Christensen from comment #14) > > (In reply to Ryosuke Niwa from comment #11) > > Does Mozilla allow 20microseconds without jitters or with jitters? > I think both. What do you mean by both? Either you have a jitter, not, right? This is about https://bugzilla.mozilla.org/show_bug.cgi?id=1425462 1789384 16 achristensen 2021-09-01 11:36:40 -0700 I think 20us is the high resolution precision when jitters are used and when they are not used. I'm referring to https://searchfox.org/mozilla-central/search?q=clampedAndJittered&redirect=false 1789387 17 rniwa 2021-09-01 11:40:29 -0700 (In reply to Alex Christensen from comment #16) > I think 20us is the high resolution precision when jitters are used and when > they are not used. I'm referring to > https://searchfox.org/mozilla-central/ > search?q=clampedAndJittered&redirect=false But is jitters enabled when COOP+COEP is on? If so, we may need to reduce our precision to 40-50us. My precious study concluded that having jitter is roughly equivalent to 2-5x precision loss. 1789388 18 achristensen 2021-09-01 11:42:20 -0700 It looks like Gecko only has jitters on when COOP+COEP is on. 1789390 19 rniwa 2021-09-01 11:45:00 -0700 (In reply to Alex Christensen from comment #18) > It looks like Gecko only has jitters on when COOP+COEP is on. Really? No jitters when isolation is off? That's contrary to https://bugzilla.mozilla.org/show_bug.cgi?id=1451790. 1789391 20 437034 achristensen 2021-09-01 11:49:15 -0700 Comment on attachment 437034 Patch I'm just looking at unconditionalClamping in nsRFPService::ReduceTimePrecisionImpl in searchfox. I think I actually got it backwards. I think they only jitter when coop/coep is off. 1789392 21 rniwa 2021-09-01 11:52:15 -0700 (In reply to Alex Christensen from comment #20) > Comment on attachment 437034 [details] > Patch > > I'm just looking at unconditionalClamping in > nsRFPService::ReduceTimePrecisionImpl in searchfox. I think I actually got > it backwards. I think they only jitter when coop/coep is off. Ok, that makes sense. So maybe it's okay for us to match Gekco's precision when COOP+COEP is turned on. 1789393 22 achristensen 2021-09-01 11:53:10 -0700 I think we should. 20us seems better 1789396 23 437048 cdumez 2021-09-01 11:55:18 -0700 Created attachment 437048 Patch 1789402 24 437048 rniwa 2021-09-01 12:05:13 -0700 Comment on attachment 437048 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=437048&action=review > Source/WebCore/page/Performance.cpp:99 > - double resolution = (1000_us).seconds(); > + double resolution = timePrecision.seconds(); > double reduced = std::floor(seconds.seconds() / resolution) * resolution; I still don't like the fact we'd be doing memory dependent math here now. Can we instead if else two cases so that division is done with an immediate value (compile time constant)? 1789406 25 437048 cdumez 2021-09-01 12:14:20 -0700 Comment on attachment 437048 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=437048&action=review > Source/WebCore/page/Performance.cpp:61 > +constexpr Seconds highTimePrecision { 20_us }; So: ``` constexpr auto highTimeResolution { 20_us.seconds() }; constexpr auto lowTimeResolution { 1_ms.seconds() }; static bool shouldUseHighTimeResolution = false; ``` >> Source/WebCore/page/Performance.cpp:99 >> double reduced = std::floor(seconds.seconds() / resolution) * resolution; > > I still don't like the fact we'd be doing memory dependent math here now. > Can we instead if else two cases so that division is done with an immediate value (compile time constant)? And then: ``` double reduced; if (shouldUseHighTimeResolution) reduced = std::floor(seconds.seconds() / highTimeResolution) * highTimeResolution; else reduced = std::floor(seconds.seconds() / lowTimeResolution) * lowTimeResolution; ``` Is that it? Looks a bit weird. 1789410 26 437048 achristensen 2021-09-01 12:22:16 -0700 Comment on attachment 437048 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=437048&action=review > Source/WebCore/page/Performance.cpp:103 > +void Performance::allowHighPrecisionTime() We could also assert that shouldUseHighTimeResolution was false before this change. 1789418 27 rniwa 2021-09-01 12:39:13 -0700 More like this: template <Seconds precision> Seconds reduceTimeToPrecision(Seconds seconds) { double resolution = precision.seconds(); double reduced = std::floor(seconds.seconds() / resolution) * resolution; return Seconds(reduced); } Seconds Performance::reduceTimeResolution(Seconds seconds) { return s_highPrecisionTimeIsAllowed ? reduceTimeToPrecision<20_us>(reseconds) : reduceTimeToPrecision<1000_us>(reseconds); } 1789420 28 darin 2021-09-01 12:46:43 -0700 Is this a real difference? Is there a guarantee the compiler will generate more secure code if we do it this way? 1789435 29 rniwa 2021-09-01 13:06:34 -0700 (In reply to Darin Adler from comment #28) > Is this a real difference? Is there a guarantee the compiler will generate > more secure code if we do it this way? Oh, I'm not concerned about security. I'm rather concerned of the performance implication on relying on a non-local/stack memory value to do computation. Having a memory load dependent branch is a lot cheaper because of the branch predictor in CPU. 1789445 30 cdumez 2021-09-01 13:20:20 -0700 (In reply to Ryosuke Niwa from comment #27) > More like this: > > template <Seconds precision> Seconds reduceTimeToPrecision(Seconds seconds) > { > double resolution = precision.seconds(); > double reduced = std::floor(seconds.seconds() / resolution) * resolution; > return Seconds(reduced); > } I don't think we can use Seconds as template parameter until C++20, at least that's what the compiler tells me. 1789455 31 cdumez 2021-09-01 13:24:09 -0700 FYI, with clang -03, this program: ``` static double timePrecision { 0.001 }; __attribute__((noinline)) double reduceTimePrecision(double value) { return std::floor(value / timePrecision) * timePrecision; } int main() { printf("%f", reduceTimePrecision(0.234556475859)); return 0; } ``` gives ``` .LCPI0_0: .quad 0x3f50624dd2f1a9fc # double 0.001 _Z19reduceTimePrecisiond: # @_Z19reduceTimePrecisiond pushq %rax divsd .LCPI0_0(%rip), %xmm0 callq floor@PLT mulsd .LCPI0_0(%rip), %xmm0 popq %rax retq .LCPI1_0: .quad 0x3fce05f2547090c9 # double 0.234556475859 main: # @main pushq %rax movsd .LCPI1_0(%rip), %xmm0 # xmm0 = mem[0],zero callq _Z19reduceTimePrecisiond movl $.L.str, %edi movb $1, %al callq printf xorl %eax, %eax popq %rcx retq .L.str: .asciz "%f" ``` while this program: ``` constexpr double highTimePrecision { 0.00002 }; constexpr double lowTimePrecision { 0.001 }; static bool s_highPrecisionTimeIsAllowed { false }; __attribute__((noinline)) double reduceTimePrecision(double value) { if (s_highPrecisionTimeIsAllowed) return std::floor(value / highTimePrecision) * highTimePrecision; else return std::floor(value / lowTimePrecision) * lowTimePrecision;} int main() { printf("%f", reduceTimePrecision(0.234556475859)); return 0; } ``` gives ``` .LCPI0_0: .quad 0x3f50624dd2f1a9fc # double 0.001 _Z19reduceTimePrecisiond: # @_Z19reduceTimePrecisiond pushq %rax divsd .LCPI0_0(%rip), %xmm0 callq floor@PLT mulsd .LCPI0_0(%rip), %xmm0 popq %rax retq .LCPI1_0: .quad 0x3fce05f2547090c9 # double 0.234556475859 main: # @main pushq %rax movsd .LCPI1_0(%rip), %xmm0 # xmm0 = mem[0],zero callq _Z19reduceTimePrecisiond movl $.L.str, %edi movb $1, %al callq printf xorl %eax, %eax popq %rcx retq _GLOBAL__sub_I_example.cpp: # @_GLOBAL__sub_I_example.cpp pushq %rax movl $_ZStL8__ioinit, %edi callq _ZNSt8ios_base4InitC1Ev movl $_ZNSt8ios_base4InitD1Ev, %edi movl $_ZStL8__ioinit, %esi movl $__dso_handle, %edx popq %rax jmp __cxa_atexit # TAILCALL .L.str: .asciz "%f" ``` 1789459 32 cdumez 2021-09-01 13:27:08 -0700 Sorry, bad copy / paste, trying again: FYI, with clang -03, this program: ``` static double timePrecision { 0.001 }; __attribute__((noinline)) double reduceTimePrecision(double value) { return std::floor(value / timePrecision) * timePrecision; } int main() { printf("%f", reduceTimePrecision(0.234556475859)); return 0; } ``` gives ``` .LCPI0_0: .quad 0x3f50624dd2f1a9fc # double 0.001 _Z19reduceTimePrecisiond: # @_Z19reduceTimePrecisiond pushq %rax divsd .LCPI0_0(%rip), %xmm0 callq floor@PLT mulsd .LCPI0_0(%rip), %xmm0 popq %rax retq .LCPI1_0: .quad 0x3fce05f2547090c9 # double 0.234556475859 main: # @main pushq %rax movsd .LCPI1_0(%rip), %xmm0 # xmm0 = mem[0],zero callq _Z19reduceTimePrecisiond movl $.L.str, %edi movb $1, %al callq printf xorl %eax, %eax popq %rcx retq .L.str: .asciz "%f" ``` while this program: ``` constexpr double highTimePrecision { 0.00002 }; constexpr double lowTimePrecision { 0.001 }; static bool s_highPrecisionTimeIsAllowed { false }; __attribute__((noinline)) double reduceTimePrecision(double value) { if (s_highPrecisionTimeIsAllowed) return std::floor(value / highTimePrecision) * highTimePrecision; else return std::floor(value / lowTimePrecision) * lowTimePrecision;} int main() { printf("%f", reduceTimePrecision(0.234556475859)); return 0; } ``` gives ``` .LCPI0_0: .quad 0x3f50624dd2f1a9fc # double 0.001 _Z19reduceTimePrecisiond: # @_Z19reduceTimePrecisiond pushq %rax divsd .LCPI0_0(%rip), %xmm0 callq floor@PLT mulsd .LCPI0_0(%rip), %xmm0 popq %rax retq .LCPI1_0: .quad 0x3fce05f2547090c9 # double 0.234556475859 main: # @main pushq %rax movsd .LCPI1_0(%rip), %xmm0 # xmm0 = mem[0],zero callq _Z19reduceTimePrecisiond movl $.L.str, %edi movb $1, %al callq printf xorl %eax, %eax popq %rcx retq .L.str: .asciz "%f" ``` 1789461 33 cdumez 2021-09-01 13:31:26 -0700 Arg, the compiler is optimizing away some things I don't want it too. Adding volatile to help: FYI, with clang -03, this program: ``` static volatile double timePrecision { 0.001 }; __attribute__((noinline)) double reduceTimePrecision(double value) { return std::floor(value / timePrecision) * timePrecision; } int main() { printf("%f", reduceTimePrecision(0.234556475859)); return 0; } ``` gives ``` _Z19reduceTimePrecisiond: # @_Z19reduceTimePrecisiond pushq %rax divsd _ZL13timePrecision(%rip), %xmm0 callq floor@PLT mulsd _ZL13timePrecision(%rip), %xmm0 popq %rax retq .LCPI1_0: .quad 0x3fce05f2547090c9 # double 0.234556475859 main: # @main pushq %rax movsd .LCPI1_0(%rip), %xmm0 # xmm0 = mem[0],zero callq _Z19reduceTimePrecisiond movl $.L.str, %edi movb $1, %al callq printf xorl %eax, %eax popq %rcx retq _ZL13timePrecision: .quad 0x3f50624dd2f1a9fc # double 0.001 .L.str: .asciz "%f" ``` while this program: ``` constexpr double highTimePrecision { 0.00002 }; constexpr double lowTimePrecision { 0.001 }; static volatile bool s_highPrecisionTimeIsAllowed { false }; __attribute__((noinline)) double reduceTimePrecision(double value) { if (s_highPrecisionTimeIsAllowed) return std::floor(value / highTimePrecision) * highTimePrecision; else return std::floor(value / lowTimePrecision) * lowTimePrecision;} int main() { printf("%f", reduceTimePrecision(0.234556475859)); return 0; } ``` gives ``` .LCPI0_0: .quad 0x3ef4f8b588e368f1 # double 2.0000000000000002E-5 .quad 0x3f50624dd2f1a9fc # double 0.001 _Z19reduceTimePrecisiond: # @_Z19reduceTimePrecisiond pushq %rax xorl %eax, %eax cmpb $0, _ZL28s_highPrecisionTimeIsAllowed(%rip) sete %al movsd .LCPI0_0(,%rax,8), %xmm1 # xmm1 = mem[0],zero movsd %xmm1, (%rsp) # 8-byte Spill divsd %xmm1, %xmm0 callq floor@PLT mulsd (%rsp), %xmm0 # 8-byte Folded Reload popq %rax retq .LCPI1_0: .quad 0x3fce05f2547090c9 # double 0.234556475859 main: # @main pushq %rax movsd .LCPI1_0(%rip), %xmm0 # xmm0 = mem[0],zero callq _Z19reduceTimePrecisiond movl $.L.str, %edi movb $1, %al callq printf xorl %eax, %eax popq %rcx retq .L.str: .asciz "%f" ``` 1789471 34 rniwa 2021-09-01 13:57:46 -0700 Hm... weird that we're not using an immediate value for the double values. Some quick search tells me that this might be a limitation of the assembly language itself. 1789478 35 437048 rniwa 2021-09-01 14:21:07 -0700 Comment on attachment 437048 Patch Ok, sounds like this is the optimal approach after taking with Yusuke. 1789491 36 ews-feeder 2021-09-01 14:35:07 -0700 Committed r281879 (241209@main): <https://commits.webkit.org/241209@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 437048. 436668 2021-08-27 13:39:38 -0700 2021-08-27 13:40:51 -0700 Patch bug-228137-20210827133937.patch text/plain 10401 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjgxNzA5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggN2JkMjM2MWU2Y2VjNWIw MDc3ZThjZGU0MmE5ZDg0ZTMwYzJiNGNhYS4uZjMxZTBkZTQ2NWJlMGQ5YzVkMjkxYWQxZDYzZWU1 OTljN2QwOWEzYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDIxLTA4LTI3ICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgSW1wcm92ZSB0aW1lciBwcmVj aXNpb24gd2hlbiBjcm9zcy1vcmlnaW4gaXNvbGF0ZWQgdmlhIENPT1ArQ09FUAorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI4MTM3CisgICAgICAgIDxy ZGFyOi8vcHJvYmxlbS84MTE5NzEzOD4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICBJbmNyZWFzZSB0aGUgcHJlY2lzaW9uIG9mIG91ciBoaWdoIHByZWNp c2lvbiB0aW1lICh1c2VkIGJ5IHBlcmZvcm1hbmNlLm5vdygpKSBmcm9tCisgICAgICAgIDFtcyB0 byAyMHVzIHdoZW4gY3Jvc3Mtb3JpZ2luIGlzb2xhdGVkIHZpYSBDT09QPXNhbWUtb3JpZ2luICsg Q09FUD1yZXF1aXJlLWNvcnAuCisgICAgICAgIFByZWNpc2lvbiByZW1haW5zIHRoZSBzYW1lICgx bXMpIHdoZW4gbm90IGNyb3NzLW9yaWdpbiBpc29sYXRlZC4KKworICAgICAgICBUaGlzIGFsaWdu cyBvdXIgYmVoYXZpb3Igd2l0aCBGaXJlZm94LgorCisgICAgICAgIE5vdGUgdGhhdCBDaHJvbWUg cHJvdmlkZXMgaGlnaGVyIHByZWNpc2lvbiAoMTAwdXMgaW4gZ2VuZXJhbCBhbmQgNXVzIHdoZW4K KyAgICAgICAgY3Jvc3Mtb3JpZ2luLWlzb2xhdGVkKS4KKworICAgICAgICAqIEhlYWRlcnMuY21h a2U6CisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAg ICAqIHBhZ2UvUGVyZm9ybWFuY2UuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UGVyZm9ybWFuY2U6 OnNldFNob3VsZEFsbG93SGlnaFByZWNpc2lvblRpbWUpOgorICAgICAgICAoV2ViQ29yZTo6UGVy Zm9ybWFuY2U6OnJlZHVjZVRpbWVSZXNvbHV0aW9uKToKKyAgICAgICAgKiBwYWdlL1BlcmZvcm1h bmNlLmg6CisKIDIwMjEtMDgtMjcgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KIAog ICAgICAgICBFbmFibGUgU2hhcmVkQXJyYXlCdWZmZXIgc3VwcG9ydCB3aGVuIENPT1AvQ09FUCBo ZWFkZXJzIGFyZSB1c2VkCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZyBiL1Nv dXJjZS9XZWJLaXQvQ2hhbmdlTG9nCmluZGV4IDdjYTdjNmRiMmQ0NDAzOWNkZGZkZjczYjVjODE5 NjRmY2VjODk1ZDIuLmRhN2RkYzI4NTljZWNiNjQxM2Y2MzZiOGNiYjhiYTllOWE2Mzg4MjkgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjQgQEAKKzIwMjEtMDgtMjcgIENocmlzIER1bWV6ICA8Y2R1bWV6 QGFwcGxlLmNvbT4KKworICAgICAgICBJbXByb3ZlIHRpbWVyIHByZWNpc2lvbiB3aGVuIGNyb3Nz LW9yaWdpbiBpc29sYXRlZCB2aWEgQ09PUCtDT0VQCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjgxMzcKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzgx MTk3MTM4PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFBhc3MgYSAnaXNDcm9zc09yaWdpbklzb2xhdGVkJyBmbGFnIGZyb20gdGhlIFVJUHJvY2VzcyB0 byB0aGUgV2ViUHJvY2VzcworICAgICAgICB2aWEgV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVy cyBzbyB0aGF0IHRoZSBXZWJQcm9jZXNzIGtub3dzIGl0IGNhbgorICAgICAgICBlbmFibGUgaGln aCBwcmVjaXNpb24gdGltZS4KKworICAgICAgICAqIFNoYXJlZC9XZWJQcm9jZXNzQ3JlYXRpb25Q YXJhbWV0ZXJzLmNwcDoKKyAgICAgICAgKFdlYktpdDo6V2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1l dGVyczo6ZW5jb2RlIGNvbnN0KToKKyAgICAgICAgKFdlYktpdDo6V2ViUHJvY2Vzc0NyZWF0aW9u UGFyYW1ldGVyczo6ZGVjb2RlKToKKyAgICAgICAgKiBTaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9u UGFyYW1ldGVycy5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9XZWJQcm9jZXNzUG9vbC5jcHA6Cisg ICAgICAgIChXZWJLaXQ6OldlYlByb2Nlc3NQb29sOjppbml0aWFsaXplTmV3V2ViUHJvY2Vzcyk6 CisgICAgICAgICogV2ViUHJvY2Vzcy9XZWJQcm9jZXNzLmNwcDoKKyAgICAgICAgKFdlYktpdDo6 V2ViUHJvY2Vzczo6aW5pdGlhbGl6ZVdlYlByb2Nlc3MpOgorCiAyMDIxLTA4LTI3ICBDaHJpcyBE dW1leiAgPGNkdW1lekBhcHBsZS5jb20+CiAKICAgICAgICAgRW5hYmxlIFNoYXJlZEFycmF5QnVm ZmVyIHN1cHBvcnQgd2hlbiBDT09QL0NPRVAgaGVhZGVycyBhcmUgdXNlZApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvSGVhZGVycy5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL0hlYWRlcnMuY21h a2UKaW5kZXggZWIwN2I4MGM5OTMzZDY5YThjMzYzMTkxOGM3NWRiZTRlMzdhOTJiOC4uNWMyYmMx NWZhNjAwZjk0ZWZmMTFiOWRmNWM1NmZiMGEwN2MyN2M1YiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvSGVhZGVycy5jbWFrZQorKysgYi9Tb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNtYWtlCkBA IC05MjQsNiArOTI0LDcgQEAgc2V0KFdlYkNvcmVfUFJJVkFURV9GUkFNRVdPUktfSEVBREVSUwog ICAgIHBhZ2UvUGFnZU92ZXJsYXkuaAogICAgIHBhZ2UvUGFnZU92ZXJsYXlDb250cm9sbGVyLmgK ICAgICBwYWdlL1BhZ2VQYXN0ZWJvYXJkQ29udGV4dC5oCisgICAgcGFnZS9QZXJmb3JtYW5jZS5o CiAgICAgcGFnZS9QZXJmb3JtYW5jZUxvZ2dpbmcuaAogICAgIHBhZ2UvUGVyZm9ybWFuY2VMb2dn aW5nQ2xpZW50LmgKICAgICBwYWdlL1BvaW50ZXJDYXB0dXJlQ29udHJvbGxlci5oCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2ogYi9T b3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggZDBh YTBlOGQyYjliOTEwNzNiOTgzYTY4Y2Y1OWY3ZTY2YTJhNTM3NS4uOTdlMTliODIxMjM5MmIzZmM4 ZDVjNTljZWVjYTVmZmQwMmQ2MTVjMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29y ZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMjczNiw3ICsyNzM2LDcgQEAKIAkJOEE0MTNB RTAxMjA3QkJBNTAwODIwMTZFIC8qIFNjcmlwdFJ1bm5lci5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEE0MTNBREUxMjA3QkJBNTAwODIwMTZFIC8qIFNj cmlwdFJ1bm5lci5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07 IH07CiAJCThBN0NDOTZCMTIwNzZENzMwMDFENDU4OCAvKiBQZW5kaW5nU2NyaXB0LmggaW4gSGVh ZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QTdDQzk2QTEyMDc2RDcz MDAxRDQ1ODggLyogUGVuZGluZ1NjcmlwdC5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0g KFByaXZhdGUsICk7IH07IH07CiAJCThBODFCRjg1MTFEQ0ZEOTAwMERBMkI5OCAvKiBOZXR3b3Jr TG9hZE1ldHJpY3MuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJl ZiA9IDhBODFCRjg0MTFEQ0ZEOTAwMERBMkI5OCAvKiBOZXR3b3JrTG9hZE1ldHJpY3MuaCAqLzsg c2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwotCQk4QTg0NEQwNTEx RDNDMThFMDAxNDA2NUMgLyogUGVyZm9ybWFuY2UuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBC WEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhBODQ0RDAyMTFEM0MxOEUwMDE0MDY1QyAvKiBQZXJmb3Jt YW5jZS5oICovOyB9OworCQk4QTg0NEQwNTExRDNDMThFMDAxNDA2NUMgLyogUGVyZm9ybWFuY2Uu aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhBODQ0RDAy MTFEM0MxOEUwMDE0MDY1QyAvKiBQZXJmb3JtYW5jZS5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJV VEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCThBOUE1ODcxMTFFODRDMzYwMDhBQ0ZEMSAvKiBK U1BlcmZvcm1hbmNlTmF2aWdhdGlvbi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gOEE5QTU4NkYxMUU4NEMzNjAwOEFDRkQxIC8qIEpTUGVyZm9ybWFuY2VO YXZpZ2F0aW9uLmggKi87IH07CiAJCThBOUE1ODc1MTFFODRDODEwMDhBQ0ZEMSAvKiBKU1BlcmZv cm1hbmNlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4 QTlBNTg3MzExRTg0QzgxMDA4QUNGRDEgLyogSlNQZXJmb3JtYW5jZS5oICovOyB9OwogCQk4QTlB NTg4ODExRTg0RjM3MDA4QUNGRDEgLyogSlNQZXJmb3JtYW5jZVRpbWluZy5oIGluIEhlYWRlcnMg Ki8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEE5QTU4NzcxMUU4NEM5ODAwOEFD RkQxIC8qIEpTUGVyZm9ybWFuY2VUaW1pbmcuaCAqLzsgfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BhZ2UvUGVyZm9ybWFuY2UuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QZXJmb3Jt YW5jZS5jcHAKaW5kZXggYWI0YTcwZWE0MzFjNWE3ZGY2ZTc4MjdmYWNjZWEzNmQzM2Y4MGJlMy4u NDc1ZGU4NzVmNmNkYTdhY2EwNmU0MjdlYTQ5ZmU5MjA4MWNkM2IyOSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGFnZS9QZXJmb3JtYW5jZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFn ZS9QZXJmb3JtYW5jZS5jcHAKQEAgLTU4LDYgKzU4LDEwIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK IAogV1RGX01BS0VfSVNPX0FMTE9DQVRFRF9JTVBMKFBlcmZvcm1hbmNlKTsKIAorc3RhdGljIGJv b2wgc2hvdWxkQWxsb3dIaWdoUHJlY2lzaW9uVGltZSB7IGZhbHNlIH07Citjb25zdGV4cHIgU2Vj b25kcyByZWd1bGFyVGltZVByZWNpc2lvbiB7IDFfbXMgfTsKK2NvbnN0ZXhwciBTZWNvbmRzIGhp Z2hUaW1lUHJlY2lzaW9uIHsgMjBfdXMgfTsKKwogUGVyZm9ybWFuY2U6OlBlcmZvcm1hbmNlKFNj cmlwdEV4ZWN1dGlvbkNvbnRleHQqIGNvbnRleHQsIE1vbm90b25pY1RpbWUgdGltZU9yaWdpbikK ICAgICA6IENvbnRleHREZXN0cnVjdGlvbk9ic2VydmVyKGNvbnRleHQpCiAgICAgLCBtX3Jlc291 cmNlVGltaW5nQnVmZmVyRnVsbFRpbWVyKCp0aGlzLCAmUGVyZm9ybWFuY2U6OnJlc291cmNlVGlt aW5nQnVmZmVyRnVsbFRpbWVyRmlyZWQpIC8vIEZJWE1FOiBNaWdyYXRlIHRoaXMgdG8gdGhlIGV2 ZW50IGxvb3AgYXMgd2VsbC4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTIyOTA0NApAQCAtOTAsOSArOTQsMTQgQEAgUmVkdWNlZFJlc29sdXRpb25TZWNvbmRzIFBlcmZv cm1hbmNlOjpub3dJblJlZHVjZWRSZXNvbHV0aW9uU2Vjb25kcygpIGNvbnN0CiAgICAgcmV0dXJu IHJlZHVjZVRpbWVSZXNvbHV0aW9uKG5vdyk7CiB9CiAKK3ZvaWQgUGVyZm9ybWFuY2U6OnNldFNo b3VsZEFsbG93SGlnaFByZWNpc2lvblRpbWUoKQoreworICAgIHNob3VsZEFsbG93SGlnaFByZWNp c2lvblRpbWUgPSB0cnVlOworfQorCiBTZWNvbmRzIFBlcmZvcm1hbmNlOjpyZWR1Y2VUaW1lUmVz b2x1dGlvbihTZWNvbmRzIHNlY29uZHMpCiB7Ci0gICAgZG91YmxlIHJlc29sdXRpb24gPSAoMTAw MF91cykuc2Vjb25kcygpOworICAgIGRvdWJsZSByZXNvbHV0aW9uID0gc2hvdWxkQWxsb3dIaWdo UHJlY2lzaW9uVGltZSA/IGhpZ2hUaW1lUHJlY2lzaW9uLnNlY29uZHMoKSA6IHJlZ3VsYXJUaW1l UHJlY2lzaW9uLnNlY29uZHMoKTsKICAgICBkb3VibGUgcmVkdWNlZCA9IHN0ZDo6Zmxvb3Ioc2Vj b25kcy5zZWNvbmRzKCkgLyByZXNvbHV0aW9uKSAqIHJlc29sdXRpb247CiAgICAgcmV0dXJuIFNl Y29uZHMocmVkdWNlZCk7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BlcmZv cm1hbmNlLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BlcmZvcm1hbmNlLmgKaW5kZXggYzU1NWUw ZWM4OWNlOTlkZWYxNjdjMTkyZGIwMjNlMGU2MGViYjJmNi4uMzExNGRiMjY5ZDhiYWE1MGFiZjRl NTc2MjI0Mjg3YzVkYTI1YTQ5ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9QZXJm b3JtYW5jZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGVyZm9ybWFuY2UuaApAQCAtMTA1 LDYgKzEwNSw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHJlZ2lzdGVyUGVyZm9ybWFuY2VPYnNlcnZl cihQZXJmb3JtYW5jZU9ic2VydmVyJik7CiAgICAgdm9pZCB1bnJlZ2lzdGVyUGVyZm9ybWFuY2VP YnNlcnZlcihQZXJmb3JtYW5jZU9ic2VydmVyJik7CiAKKyAgICBXRUJDT1JFX0VYUE9SVCBzdGF0 aWMgdm9pZCBzZXRTaG91bGRBbGxvd0hpZ2hQcmVjaXNpb25UaW1lKCk7CiAgICAgc3RhdGljIFNl Y29uZHMgcmVkdWNlVGltZVJlc29sdXRpb24oU2Vjb25kcyk7CiAKICAgICBET01IaWdoUmVzVGlt ZVN0YW1wIHJlbGF0aXZlVGltZUZyb21UaW1lT3JpZ2luSW5SZWR1Y2VkUmVzb2x1dGlvbihNb25v dG9uaWNUaW1lKSBjb25zdDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlBy b2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMuY3BwIGIvU291cmNlL1dlYktpdC9TaGFyZWQvV2ViUHJv Y2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5jcHAKaW5kZXggYWZmYjU4YjI5NzQ0ODI5MTE3ZDE3ZDFl MmE2MTQ3ZTIxYmY4YjZhMS4uMjdjYzFlMzZiYTM5M2Q0MGFkZjRhZjkyMzYxOTVkMWE2NGYzYzA2 ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFy YW1ldGVycy5jcHAKKysrIGIvU291cmNlL1dlYktpdC9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9u UGFyYW1ldGVycy5jcHAKQEAgLTEyMiw2ICsxMjIsNyBAQCB2b2lkIFdlYlByb2Nlc3NDcmVhdGlv blBhcmFtZXRlcnM6OmVuY29kZShJUEM6OkVuY29kZXImIGVuY29kZXIpIGNvbnN0CiAgICAgZW5j b2RlciA8PCBtZW1vcnlDYWNoZURpc2FibGVkOwogICAgIGVuY29kZXIgPDwgYXR0clN0eWxlRW5h YmxlZDsKICAgICBlbmNvZGVyIDw8IHNob3VsZFRocm93RXhjZXB0aW9uRm9yR2xvYmFsQ29uc3Rh bnRSZWRlY2xhcmF0aW9uOworICAgIGVuY29kZXIgPDwgaXNDcm9zc09yaWdpbklzb2xhdGVkOwog CiAjaWYgRU5BQkxFKFNFUlZJQ0VfQ09OVFJPTFMpCiAgICAgZW5jb2RlciA8PCBoYXNJbWFnZVNl cnZpY2VzOwpAQCAtMzg5LDYgKzM5MCw4IEBAIGJvb2wgV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1l dGVyczo6ZGVjb2RlKElQQzo6RGVjb2RlciYgZGVjb2RlciwgV2ViUHJvY2Vzc0NyZWF0CiAgICAg ICAgIHJldHVybiBmYWxzZTsKICAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHBhcmFtZXRlcnMuc2hv dWxkVGhyb3dFeGNlcHRpb25Gb3JHbG9iYWxDb25zdGFudFJlZGVjbGFyYXRpb24pKQogICAgICAg ICByZXR1cm4gZmFsc2U7CisgICAgaWYgKCFkZWNvZGVyLmRlY29kZShwYXJhbWV0ZXJzLmlzQ3Jv c3NPcmlnaW5Jc29sYXRlZCkpCisgICAgICAgIHJldHVybiBmYWxzZTsKIAogI2lmIEVOQUJMRShT RVJWSUNFX0NPTlRST0xTKQogICAgIGlmICghZGVjb2Rlci5kZWNvZGUocGFyYW1ldGVycy5oYXNJ bWFnZVNlcnZpY2VzKSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlByb2Nl c3NDcmVhdGlvblBhcmFtZXRlcnMuaCBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlByb2Nlc3ND cmVhdGlvblBhcmFtZXRlcnMuaAppbmRleCBkYzZiMjI5N2QyZjhhZDlhODI1MWYyMjgyMmQ5ZGFj ZDhlYzg5MTZmLi4xNTQ4ZjM0MDAyYTgxNWNjOTJjMWUwZjdiNTI1N2I4MmRjN2ZhMmJhIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9XZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJz LmgKKysrIGIvU291cmNlL1dlYktpdC9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVy cy5oCkBAIC0xMzUsNiArMTM1LDcgQEAgc3RydWN0IFdlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRl cnMgewogICAgIGJvb2wgbWVtb3J5Q2FjaGVEaXNhYmxlZCB7IGZhbHNlIH07CiAgICAgYm9vbCBh dHRyU3R5bGVFbmFibGVkIHsgZmFsc2UgfTsKICAgICBib29sIHNob3VsZFRocm93RXhjZXB0aW9u Rm9yR2xvYmFsQ29uc3RhbnRSZWRlY2xhcmF0aW9uIHsgdHJ1ZSB9OworICAgIGJvb2wgaXNDcm9z c09yaWdpbklzb2xhdGVkIHsgZmFsc2UgfTsgLy8gY3Jvc3Mtb3JpZ2luIGlzb2xhdGlvbiB2aWEg Q09PUCtDT0VQLgogCiAjaWYgRU5BQkxFKFNFUlZJQ0VfQ09OVFJPTFMpCiAgICAgYm9vbCBoYXNJ bWFnZVNlcnZpY2VzIHsgZmFsc2UgfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvVUlQcm9j ZXNzL1dlYlByb2Nlc3NQb29sLmNwcCBiL1NvdXJjZS9XZWJLaXQvVUlQcm9jZXNzL1dlYlByb2Nl c3NQb29sLmNwcAppbmRleCBkZTNjYTE4YTAzOGRkYTY4YjhmODMxMDJhOWQyODhkOTdlN2QzMjlh Li5iMzEzZjQ1MTAzNDZjZTA3YjE1MDQxMTI5MGJiNWVkZWQ2NzcxMGZkIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQcm9jZXNzUG9vbC5jcHAKKysrIGIvU291cmNlL1dl YktpdC9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Bvb2wuY3BwCkBAIC04MDMsNiArODAzLDcgQEAgdm9p ZCBXZWJQcm9jZXNzUG9vbDo6aW5pdGlhbGl6ZU5ld1dlYlByb2Nlc3MoV2ViUHJvY2Vzc1Byb3h5 JiBwcm9jZXNzLCBXZWJzaXRlRGEKICAgICBwYXJhbWV0ZXJzLm1lbW9yeUNhY2hlRGlzYWJsZWQg PSBtX21lbW9yeUNhY2hlRGlzYWJsZWQ7CiAgICAgcGFyYW1ldGVycy5hdHRyU3R5bGVFbmFibGVk ID0gbV9jb25maWd1cmF0aW9uLT5hdHRyU3R5bGVFbmFibGVkKCk7CiAgICAgcGFyYW1ldGVycy5z aG91bGRUaHJvd0V4Y2VwdGlvbkZvckdsb2JhbENvbnN0YW50UmVkZWNsYXJhdGlvbiA9IG1fY29u ZmlndXJhdGlvbi0+c2hvdWxkVGhyb3dFeGNlcHRpb25Gb3JHbG9iYWxDb25zdGFudFJlZGVjbGFy YXRpb24oKTsKKyAgICBwYXJhbWV0ZXJzLmlzQ3Jvc3NPcmlnaW5Jc29sYXRlZCA9IHByb2Nlc3Mu aXNDcm9zc09yaWdpbklzb2xhdGVkKCk7CiAKICNpZiBFTkFCTEUoU0VSVklDRV9DT05UUk9MUykK ICAgICBhdXRvJiBzZXJ2aWNlQ29udHJvbGxlciA9IFNlcnZpY2VzQ29udHJvbGxlcjo6c2luZ2xl dG9uKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUHJvY2Vzcy5j cHAgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUHJvY2Vzcy5jcHAKaW5kZXggMjcyYjU0 N2ZlZDM1OWZjZDI3ZTZiYmRmNzY1OTE0YzNhYjkzYmI4OS4uMTAwMzRhMjZjMzRlYTE4YTY0NjUw Zjc3MjAxOGZlMmZjZDQ3MTM1MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNz L1dlYlByb2Nlc3MuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9XZWJQcm9jZXNz LmNwcApAQCAtMTIxLDYgKzEyMSw3IEBACiAjaW5jbHVkZSA8V2ViQ29yZS9OZXR3b3JrU3RvcmFn ZVNlc3Npb24uaD4KICNpbmNsdWRlIDxXZWJDb3JlL1BhZ2UuaD4KICNpbmNsdWRlIDxXZWJDb3Jl L1BhZ2VHcm91cC5oPgorI2luY2x1ZGUgPFdlYkNvcmUvUGVyZm9ybWFuY2UuaD4KICNpbmNsdWRl IDxXZWJDb3JlL1BsYXRmb3JtS2V5Ym9hcmRFdmVudC5oPgogI2luY2x1ZGUgPFdlYkNvcmUvUGxh dGZvcm1NZWRpYVNlc3Npb25NYW5hZ2VyLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9Qcm9jZXNzV2Fy bWluZy5oPgpAQCAtNTUwLDYgKzU1MSw5IEBAIHZvaWQgV2ViUHJvY2Vzczo6aW5pdGlhbGl6ZVdl YlByb2Nlc3MoV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycyYmIHBhcmFtZXRlcnMpCiAgICAg V2ViUmVzb3VyY2VMb2FkT2JzZXJ2ZXI6OnNldFNob3VsZExvZ1VzZXJJbnRlcmFjdGlvbihwYXJh bWV0ZXJzLnNob3VsZExvZ1VzZXJJbnRlcmFjdGlvbik7CiAjZW5kaWYKIAorICAgIGlmIChwYXJh bWV0ZXJzLmlzQ3Jvc3NPcmlnaW5Jc29sYXRlZCkKKyAgICAgICAgUGVyZm9ybWFuY2U6OnNldFNo b3VsZEFsbG93SGlnaFByZWNpc2lvblRpbWUoKTsKKwogI2lmIFBMQVRGT1JNKENPQ09BKQogICAg IGlmIChtX3Byb2Nlc3NUeXBlID09IFByb2Nlc3NUeXBlOjpQcmV3YXJtZWRXZWJDb250ZW50KQog ICAgICAgICBwcmV3YXJtR2xvYmFsbHkoKTsK 436669 2021-08-27 13:40:53 -0700 2021-09-01 08:35:53 -0700 Patch bug-228137-20210827134052.patch text/plain 10399 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjgxNzA5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggN2JkMjM2MWU2Y2VjNWIw MDc3ZThjZGU0MmE5ZDg0ZTMwYzJiNGNhYS4uNWM2MTg0NjlkMWE4ZjllMmZhN2I5ZDljMTQ2YzA0 NmI4ZTlmMTg5ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDIxLTA4LTI3ICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgSW1wcm92ZSB0aW1lIHByZWNp c2lvbiB3aGVuIGNyb3NzLW9yaWdpbiBpc29sYXRlZCB2aWEgQ09PUCtDT0VQCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjgxMzcKKyAgICAgICAgPHJk YXI6Ly9wcm9ibGVtLzgxMTk3MTM4PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEluY3JlYXNlIHRoZSBwcmVjaXNpb24gb2Ygb3VyIGhpZ2ggcHJlY2lz aW9uIHRpbWUgKHVzZWQgYnkgcGVyZm9ybWFuY2Uubm93KCkpIGZyb20KKyAgICAgICAgMW1zIHRv IDIwdXMgd2hlbiBjcm9zcy1vcmlnaW4gaXNvbGF0ZWQgdmlhIENPT1A9c2FtZS1vcmlnaW4gKyBD T0VQPXJlcXVpcmUtY29ycC4KKyAgICAgICAgUHJlY2lzaW9uIHJlbWFpbnMgdGhlIHNhbWUgKDFt cykgd2hlbiBub3QgY3Jvc3Mtb3JpZ2luIGlzb2xhdGVkLgorCisgICAgICAgIFRoaXMgYWxpZ25z IG91ciBiZWhhdmlvciB3aXRoIEZpcmVmb3guCisKKyAgICAgICAgTm90ZSB0aGF0IENocm9tZSBw cm92aWRlcyBoaWdoZXIgcHJlY2lzaW9uICgxMDB1cyBpbiBnZW5lcmFsIGFuZCA1dXMgd2hlbgor ICAgICAgICBjcm9zcy1vcmlnaW4taXNvbGF0ZWQpLgorCisgICAgICAgICogSGVhZGVycy5jbWFr ZToKKyAgICAgICAgKiBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAg ICogcGFnZS9QZXJmb3JtYW5jZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQZXJmb3JtYW5jZTo6 c2V0U2hvdWxkQWxsb3dIaWdoUHJlY2lzaW9uVGltZSk6CisgICAgICAgIChXZWJDb3JlOjpQZXJm b3JtYW5jZTo6cmVkdWNlVGltZVJlc29sdXRpb24pOgorICAgICAgICAqIHBhZ2UvUGVyZm9ybWFu Y2UuaDoKKwogMjAyMS0wOC0yNyAgQ2hyaXMgRHVtZXogIDxjZHVtZXpAYXBwbGUuY29tPgogCiAg ICAgICAgIEVuYWJsZSBTaGFyZWRBcnJheUJ1ZmZlciBzdXBwb3J0IHdoZW4gQ09PUC9DT0VQIGhl YWRlcnMgYXJlIHVzZWQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvQ2hhbmdlTG9nIGIvU291 cmNlL1dlYktpdC9DaGFuZ2VMb2cKaW5kZXggN2NhN2M2ZGIyZDQ0MDM5Y2RkZmRmNzNiNWM4MTk2 NGZjZWM4OTVkMi4uY2U2ZTY4OWI2MWQ0ZDhkNTljYmJkNzFjOGY4MzRhODAyYTYzYjk4MCAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9DaGFu Z2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAyMS0wOC0yNyAgQ2hyaXMgRHVtZXogIDxjZHVtZXpA YXBwbGUuY29tPgorCisgICAgICAgIEltcHJvdmUgdGltZSBwcmVjaXNpb24gd2hlbiBjcm9zcy1v cmlnaW4gaXNvbGF0ZWQgdmlhIENPT1ArQ09FUAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI4MTM3CisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS84MTE5 NzEzOD4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBQ YXNzIGEgJ2lzQ3Jvc3NPcmlnaW5Jc29sYXRlZCcgZmxhZyBmcm9tIHRoZSBVSVByb2Nlc3MgdG8g dGhlIFdlYlByb2Nlc3MKKyAgICAgICAgdmlhIFdlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMg c28gdGhhdCB0aGUgV2ViUHJvY2VzcyBrbm93cyBpdCBjYW4KKyAgICAgICAgZW5hYmxlIGhpZ2gg cHJlY2lzaW9uIHRpbWUuCisKKyAgICAgICAgKiBTaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFy YW1ldGVycy5jcHA6CisgICAgICAgIChXZWJLaXQ6OldlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRl cnM6OmVuY29kZSBjb25zdCk6CisgICAgICAgIChXZWJLaXQ6OldlYlByb2Nlc3NDcmVhdGlvblBh cmFtZXRlcnM6OmRlY29kZSk6CisgICAgICAgICogU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBh cmFtZXRlcnMuaDoKKyAgICAgICAgKiBVSVByb2Nlc3MvV2ViUHJvY2Vzc1Bvb2wuY3BwOgorICAg ICAgICAoV2ViS2l0OjpXZWJQcm9jZXNzUG9vbDo6aW5pdGlhbGl6ZU5ld1dlYlByb2Nlc3MpOgor ICAgICAgICAqIFdlYlByb2Nlc3MvV2ViUHJvY2Vzcy5jcHA6CisgICAgICAgIChXZWJLaXQ6Oldl YlByb2Nlc3M6OmluaXRpYWxpemVXZWJQcm9jZXNzKToKKwogMjAyMS0wOC0yNyAgQ2hyaXMgRHVt ZXogIDxjZHVtZXpAYXBwbGUuY29tPgogCiAgICAgICAgIEVuYWJsZSBTaGFyZWRBcnJheUJ1ZmZl ciBzdXBwb3J0IHdoZW4gQ09PUC9DT0VQIGhlYWRlcnMgYXJlIHVzZWQKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL0hlYWRlcnMuY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9IZWFkZXJzLmNtYWtl CmluZGV4IGViMDdiODBjOTkzM2Q2OWE4YzM2MzE5MThjNzVkYmU0ZTM3YTkyYjguLjVjMmJjMTVm YTYwMGY5NGVmZjExYjlkZjVjNTZmYjBhMDdjMjdjNWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL0hlYWRlcnMuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvSGVhZGVycy5jbWFrZQpAQCAt OTI0LDYgKzkyNCw3IEBAIHNldChXZWJDb3JlX1BSSVZBVEVfRlJBTUVXT1JLX0hFQURFUlMKICAg ICBwYWdlL1BhZ2VPdmVybGF5LmgKICAgICBwYWdlL1BhZ2VPdmVybGF5Q29udHJvbGxlci5oCiAg ICAgcGFnZS9QYWdlUGFzdGVib2FyZENvbnRleHQuaAorICAgIHBhZ2UvUGVyZm9ybWFuY2UuaAog ICAgIHBhZ2UvUGVyZm9ybWFuY2VMb2dnaW5nLmgKICAgICBwYWdlL1BlcmZvcm1hbmNlTG9nZ2lu Z0NsaWVudC5oCiAgICAgcGFnZS9Qb2ludGVyQ2FwdHVyZUNvbnRyb2xsZXIuaApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291 cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IGQwYWEw ZThkMmI5YjkxMDczYjk4M2E2OGNmNTlmN2U2NmEyYTUzNzUuLjk3ZTE5YjgyMTIzOTJiM2ZjOGQ1 YzU5Y2VlY2E1ZmZkMDJkNjE1YzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUu eGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhj b2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTI3MzYsNyArMjczNiw3IEBACiAJCThBNDEzQUUw MTIwN0JCQTUwMDgyMDE2RSAvKiBTY3JpcHRSdW5uZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9 IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhBNDEzQURFMTIwN0JCQTUwMDgyMDE2RSAvKiBTY3Jp cHRSdW5uZXIuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9 OwogCQk4QTdDQzk2QjEyMDc2RDczMDAxRDQ1ODggLyogUGVuZGluZ1NjcmlwdC5oIGluIEhlYWRl cnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEE3Q0M5NkExMjA3NkQ3MzAw MUQ0NTg4IC8qIFBlbmRpbmdTY3JpcHQuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQ cml2YXRlLCApOyB9OyB9OwogCQk4QTgxQkY4NTExRENGRDkwMDBEQTJCOTggLyogTmV0d29ya0xv YWRNZXRyaWNzLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSA4QTgxQkY4NDExRENGRDkwMDBEQTJCOTggLyogTmV0d29ya0xvYWRNZXRyaWNzLmggKi87IHNl dHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKLQkJOEE4NDREMDUxMUQz QzE4RTAwMTQwNjVDIC8qIFBlcmZvcm1hbmNlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSA4QTg0NEQwMjExRDNDMThFMDAxNDA2NUMgLyogUGVyZm9ybWFu Y2UuaCAqLzsgfTsKKwkJOEE4NDREMDUxMUQzQzE4RTAwMTQwNjVDIC8qIFBlcmZvcm1hbmNlLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4QTg0NEQwMjEx RDNDMThFMDAxNDA2NUMgLyogUGVyZm9ybWFuY2UuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRF UyA9IChQcml2YXRlLCApOyB9OyB9OwogCQk4QTlBNTg3MTExRTg0QzM2MDA4QUNGRDEgLyogSlNQ ZXJmb3JtYW5jZU5hdmlnYXRpb24uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IDhBOUE1ODZGMTFFODRDMzYwMDhBQ0ZEMSAvKiBKU1BlcmZvcm1hbmNlTmF2 aWdhdGlvbi5oICovOyB9OwogCQk4QTlBNTg3NTExRTg0QzgxMDA4QUNGRDEgLyogSlNQZXJmb3Jt YW5jZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gOEE5 QTU4NzMxMUU4NEM4MTAwOEFDRkQxIC8qIEpTUGVyZm9ybWFuY2UuaCAqLzsgfTsKIAkJOEE5QTU4 ODgxMUU4NEYzNzAwOEFDRkQxIC8qIEpTUGVyZm9ybWFuY2VUaW1pbmcuaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDhBOUE1ODc3MTFFODRDOTgwMDhBQ0ZE MSAvKiBKU1BlcmZvcm1hbmNlVGltaW5nLmggKi87IH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wYWdlL1BlcmZvcm1hbmNlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGVyZm9ybWFu Y2UuY3BwCmluZGV4IGFiNGE3MGVhNDMxYzVhN2RmNmU3ODI3ZmFjY2VhMzZkMzNmODBiZTMuLjQ3 NWRlODc1ZjZjZGE3YWNhMDZlNDI3ZWE0OWZlOTIwODFjZDNiMjkgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvUGVyZm9ybWFuY2UuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv UGVyZm9ybWFuY2UuY3BwCkBAIC01OCw2ICs1OCwxMCBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK IFdURl9NQUtFX0lTT19BTExPQ0FURURfSU1QTChQZXJmb3JtYW5jZSk7CiAKK3N0YXRpYyBib29s IHNob3VsZEFsbG93SGlnaFByZWNpc2lvblRpbWUgeyBmYWxzZSB9OworY29uc3RleHByIFNlY29u ZHMgcmVndWxhclRpbWVQcmVjaXNpb24geyAxX21zIH07Citjb25zdGV4cHIgU2Vjb25kcyBoaWdo VGltZVByZWNpc2lvbiB7IDIwX3VzIH07CisKIFBlcmZvcm1hbmNlOjpQZXJmb3JtYW5jZShTY3Jp cHRFeGVjdXRpb25Db250ZXh0KiBjb250ZXh0LCBNb25vdG9uaWNUaW1lIHRpbWVPcmlnaW4pCiAg ICAgOiBDb250ZXh0RGVzdHJ1Y3Rpb25PYnNlcnZlcihjb250ZXh0KQogICAgICwgbV9yZXNvdXJj ZVRpbWluZ0J1ZmZlckZ1bGxUaW1lcigqdGhpcywgJlBlcmZvcm1hbmNlOjpyZXNvdXJjZVRpbWlu Z0J1ZmZlckZ1bGxUaW1lckZpcmVkKSAvLyBGSVhNRTogTWlncmF0ZSB0aGlzIHRvIHRoZSBldmVu dCBsb29wIGFzIHdlbGwuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0y MjkwNDQKQEAgLTkwLDkgKzk0LDE0IEBAIFJlZHVjZWRSZXNvbHV0aW9uU2Vjb25kcyBQZXJmb3Jt YW5jZTo6bm93SW5SZWR1Y2VkUmVzb2x1dGlvblNlY29uZHMoKSBjb25zdAogICAgIHJldHVybiBy ZWR1Y2VUaW1lUmVzb2x1dGlvbihub3cpOwogfQogCit2b2lkIFBlcmZvcm1hbmNlOjpzZXRTaG91 bGRBbGxvd0hpZ2hQcmVjaXNpb25UaW1lKCkKK3sKKyAgICBzaG91bGRBbGxvd0hpZ2hQcmVjaXNp b25UaW1lID0gdHJ1ZTsKK30KKwogU2Vjb25kcyBQZXJmb3JtYW5jZTo6cmVkdWNlVGltZVJlc29s dXRpb24oU2Vjb25kcyBzZWNvbmRzKQogewotICAgIGRvdWJsZSByZXNvbHV0aW9uID0gKDEwMDBf dXMpLnNlY29uZHMoKTsKKyAgICBkb3VibGUgcmVzb2x1dGlvbiA9IHNob3VsZEFsbG93SGlnaFBy ZWNpc2lvblRpbWUgPyBoaWdoVGltZVByZWNpc2lvbi5zZWNvbmRzKCkgOiByZWd1bGFyVGltZVBy ZWNpc2lvbi5zZWNvbmRzKCk7CiAgICAgZG91YmxlIHJlZHVjZWQgPSBzdGQ6OmZsb29yKHNlY29u ZHMuc2Vjb25kcygpIC8gcmVzb2x1dGlvbikgKiByZXNvbHV0aW9uOwogICAgIHJldHVybiBTZWNv bmRzKHJlZHVjZWQpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9QZXJmb3Jt YW5jZS5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QZXJmb3JtYW5jZS5oCmluZGV4IGM1NTVlMGVj ODljZTk5ZGVmMTY3YzE5MmRiMDIzZTBlNjBlYmIyZjYuLjMxMTRkYjI2OWQ4YmFhNTBhYmY0ZTU3 NjIyNDI4N2M1ZGEyNWE0OWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGVyZm9y bWFuY2UuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1BlcmZvcm1hbmNlLmgKQEAgLTEwNSw2 ICsxMDUsNyBAQCBwdWJsaWM6CiAgICAgdm9pZCByZWdpc3RlclBlcmZvcm1hbmNlT2JzZXJ2ZXIo UGVyZm9ybWFuY2VPYnNlcnZlciYpOwogICAgIHZvaWQgdW5yZWdpc3RlclBlcmZvcm1hbmNlT2Jz ZXJ2ZXIoUGVyZm9ybWFuY2VPYnNlcnZlciYpOwogCisgICAgV0VCQ09SRV9FWFBPUlQgc3RhdGlj IHZvaWQgc2V0U2hvdWxkQWxsb3dIaWdoUHJlY2lzaW9uVGltZSgpOwogICAgIHN0YXRpYyBTZWNv bmRzIHJlZHVjZVRpbWVSZXNvbHV0aW9uKFNlY29uZHMpOwogCiAgICAgRE9NSGlnaFJlc1RpbWVT dGFtcCByZWxhdGl2ZVRpbWVGcm9tVGltZU9yaWdpbkluUmVkdWNlZFJlc29sdXRpb24oTW9ub3Rv bmljVGltZSkgY29uc3Q7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9XZWJQcm9j ZXNzQ3JlYXRpb25QYXJhbWV0ZXJzLmNwcCBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlByb2Nl c3NDcmVhdGlvblBhcmFtZXRlcnMuY3BwCmluZGV4IGFmZmI1OGIyOTc0NDgyOTExN2QxN2QxZTJh NjE0N2UyMWJmOGI2YTEuLjI3Y2MxZTM2YmEzOTNkNDBhZGY0YWY5MjM2MTk1ZDFhNjRmM2MwNmYg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFt ZXRlcnMuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBh cmFtZXRlcnMuY3BwCkBAIC0xMjIsNiArMTIyLDcgQEAgdm9pZCBXZWJQcm9jZXNzQ3JlYXRpb25Q YXJhbWV0ZXJzOjplbmNvZGUoSVBDOjpFbmNvZGVyJiBlbmNvZGVyKSBjb25zdAogICAgIGVuY29k ZXIgPDwgbWVtb3J5Q2FjaGVEaXNhYmxlZDsKICAgICBlbmNvZGVyIDw8IGF0dHJTdHlsZUVuYWJs ZWQ7CiAgICAgZW5jb2RlciA8PCBzaG91bGRUaHJvd0V4Y2VwdGlvbkZvckdsb2JhbENvbnN0YW50 UmVkZWNsYXJhdGlvbjsKKyAgICBlbmNvZGVyIDw8IGlzQ3Jvc3NPcmlnaW5Jc29sYXRlZDsKIAog I2lmIEVOQUJMRShTRVJWSUNFX0NPTlRST0xTKQogICAgIGVuY29kZXIgPDwgaGFzSW1hZ2VTZXJ2 aWNlczsKQEAgLTM4OSw2ICszOTAsOCBAQCBib29sIFdlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRl cnM6OmRlY29kZShJUEM6OkRlY29kZXImIGRlY29kZXIsIFdlYlByb2Nlc3NDcmVhdAogICAgICAg ICByZXR1cm4gZmFsc2U7CiAgICAgaWYgKCFkZWNvZGVyLmRlY29kZShwYXJhbWV0ZXJzLnNob3Vs ZFRocm93RXhjZXB0aW9uRm9yR2xvYmFsQ29uc3RhbnRSZWRlY2xhcmF0aW9uKSkKICAgICAgICAg cmV0dXJuIGZhbHNlOworICAgIGlmICghZGVjb2Rlci5kZWNvZGUocGFyYW1ldGVycy5pc0Nyb3Nz T3JpZ2luSXNvbGF0ZWQpKQorICAgICAgICByZXR1cm4gZmFsc2U7CiAKICNpZiBFTkFCTEUoU0VS VklDRV9DT05UUk9MUykKICAgICBpZiAoIWRlY29kZXIuZGVjb2RlKHBhcmFtZXRlcnMuaGFzSW1h Z2VTZXJ2aWNlcykpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9XZWJQcm9jZXNz Q3JlYXRpb25QYXJhbWV0ZXJzLmggYi9Tb3VyY2UvV2ViS2l0L1NoYXJlZC9XZWJQcm9jZXNzQ3Jl YXRpb25QYXJhbWV0ZXJzLmgKaW5kZXggZGM2YjIyOTdkMmY4YWQ5YTgyNTFmMjI4MjJkOWRhY2Q4 ZWM4OTE2Zi4uMTU0OGYzNDAwMmE4MTVjYzkyYzFlMGY3YjUyNTdiODJkYzdmYTJiYSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9TaGFyZWQvV2ViUHJvY2Vzc0NyZWF0aW9uUGFyYW1ldGVycy5o CisrKyBiL1NvdXJjZS9XZWJLaXQvU2hhcmVkL1dlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMu aApAQCAtMTM1LDYgKzEzNSw3IEBAIHN0cnVjdCBXZWJQcm9jZXNzQ3JlYXRpb25QYXJhbWV0ZXJz IHsKICAgICBib29sIG1lbW9yeUNhY2hlRGlzYWJsZWQgeyBmYWxzZSB9OwogICAgIGJvb2wgYXR0 clN0eWxlRW5hYmxlZCB7IGZhbHNlIH07CiAgICAgYm9vbCBzaG91bGRUaHJvd0V4Y2VwdGlvbkZv ckdsb2JhbENvbnN0YW50UmVkZWNsYXJhdGlvbiB7IHRydWUgfTsKKyAgICBib29sIGlzQ3Jvc3NP cmlnaW5Jc29sYXRlZCB7IGZhbHNlIH07IC8vIGNyb3NzLW9yaWdpbiBpc29sYXRpb24gdmlhIENP T1ArQ09FUC4KIAogI2lmIEVOQUJMRShTRVJWSUNFX0NPTlRST0xTKQogICAgIGJvb2wgaGFzSW1h Z2VTZXJ2aWNlcyB7IGZhbHNlIH07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vz cy9XZWJQcm9jZXNzUG9vbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L1VJUHJvY2Vzcy9XZWJQcm9jZXNz UG9vbC5jcHAKaW5kZXggZGUzY2ExOGEwMzhkZGE2OGI4ZjgzMTAyYTlkMjg4ZDk3ZTdkMzI5YS4u YjMxM2Y0NTEwMzQ2Y2UwN2IxNTA0MTEyOTBiYjVlZGVkNjc3MTBmZCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9VSVByb2Nlc3MvV2ViUHJvY2Vzc1Bvb2wuY3BwCisrKyBiL1NvdXJjZS9XZWJL aXQvVUlQcm9jZXNzL1dlYlByb2Nlc3NQb29sLmNwcApAQCAtODAzLDYgKzgwMyw3IEBAIHZvaWQg V2ViUHJvY2Vzc1Bvb2w6OmluaXRpYWxpemVOZXdXZWJQcm9jZXNzKFdlYlByb2Nlc3NQcm94eSYg cHJvY2VzcywgV2Vic2l0ZURhCiAgICAgcGFyYW1ldGVycy5tZW1vcnlDYWNoZURpc2FibGVkID0g bV9tZW1vcnlDYWNoZURpc2FibGVkOwogICAgIHBhcmFtZXRlcnMuYXR0clN0eWxlRW5hYmxlZCA9 IG1fY29uZmlndXJhdGlvbi0+YXR0clN0eWxlRW5hYmxlZCgpOwogICAgIHBhcmFtZXRlcnMuc2hv dWxkVGhyb3dFeGNlcHRpb25Gb3JHbG9iYWxDb25zdGFudFJlZGVjbGFyYXRpb24gPSBtX2NvbmZp Z3VyYXRpb24tPnNob3VsZFRocm93RXhjZXB0aW9uRm9yR2xvYmFsQ29uc3RhbnRSZWRlY2xhcmF0 aW9uKCk7CisgICAgcGFyYW1ldGVycy5pc0Nyb3NzT3JpZ2luSXNvbGF0ZWQgPSBwcm9jZXNzLmlz Q3Jvc3NPcmlnaW5Jc29sYXRlZCgpOwogCiAjaWYgRU5BQkxFKFNFUlZJQ0VfQ09OVFJPTFMpCiAg ICAgYXV0byYgc2VydmljZUNvbnRyb2xsZXIgPSBTZXJ2aWNlc0NvbnRyb2xsZXI6OnNpbmdsZXRv bigpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlByb2Nlc3MuY3Bw IGIvU291cmNlL1dlYktpdC9XZWJQcm9jZXNzL1dlYlByb2Nlc3MuY3BwCmluZGV4IDI3MmI1NDdm ZWQzNTlmY2QyN2U2YmJkZjc2NTkxNGMzYWI5M2JiODkuLjEwMDM0YTI2YzM0ZWExOGE2NDY1MGY3 NzIwMThmZTJmY2Q0NzEzNTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvV2ViUHJvY2Vzcy9X ZWJQcm9jZXNzLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L1dlYlByb2Nlc3MvV2ViUHJvY2Vzcy5j cHAKQEAgLTEyMSw2ICsxMjEsNyBAQAogI2luY2x1ZGUgPFdlYkNvcmUvTmV0d29ya1N0b3JhZ2VT ZXNzaW9uLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9QYWdlLmg+CiAjaW5jbHVkZSA8V2ViQ29yZS9Q YWdlR3JvdXAuaD4KKyNpbmNsdWRlIDxXZWJDb3JlL1BlcmZvcm1hbmNlLmg+CiAjaW5jbHVkZSA8 V2ViQ29yZS9QbGF0Zm9ybUtleWJvYXJkRXZlbnQuaD4KICNpbmNsdWRlIDxXZWJDb3JlL1BsYXRm b3JtTWVkaWFTZXNzaW9uTWFuYWdlci5oPgogI2luY2x1ZGUgPFdlYkNvcmUvUHJvY2Vzc1dhcm1p bmcuaD4KQEAgLTU1MCw2ICs1NTEsOSBAQCB2b2lkIFdlYlByb2Nlc3M6OmluaXRpYWxpemVXZWJQ cm9jZXNzKFdlYlByb2Nlc3NDcmVhdGlvblBhcmFtZXRlcnMmJiBwYXJhbWV0ZXJzKQogICAgIFdl YlJlc291cmNlTG9hZE9ic2VydmVyOjpzZXRTaG91bGRMb2dVc2VySW50ZXJhY3Rpb24ocGFyYW1l dGVycy5zaG91bGRMb2dVc2VySW50ZXJhY3Rpb24pOwogI2VuZGlmCiAKKyAgICBpZiAocGFyYW1l dGVycy5pc0Nyb3NzT3JpZ2luSXNvbGF0ZWQpCisgICAgICAgIFBlcmZvcm1hbmNlOjpzZXRTaG91 bGRBbGxvd0hpZ2hQcmVjaXNpb25UaW1lKCk7CisKICNpZiBQTEFURk9STShDT0NPQSkKICAgICBp ZiAobV9wcm9jZXNzVHlwZSA9PSBQcm9jZXNzVHlwZTo6UHJld2FybWVkV2ViQ29udGVudCkKICAg ICAgICAgcHJld2FybUdsb2JhbGx5KCk7Cg== 437034 2021-09-01 08:35:55 -0700 2021-09-01 11:55:15 -0700 Patch bug-228137-20210901083555.patch text/plain 4293 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjgxODUwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDZlN2QxNDY2MGZmNGEx ZDMyZjI2ZGZiMDEwOTRhODljNDljNWFhYi4uNzk4ODhkYTFmZTllM2EyMDMwNTZhZWY4OWJmOGRj YWY4MjI4OGIyNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI1IEBACisyMDIxLTA5LTAxICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgSW1wcm92ZSB0aW1lIHByZWNp c2lvbiB3aGVuIGNyb3NzLW9yaWdpbiBpc29sYXRlZCB2aWEgQ09PUCtDT0VQCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjgxMzcKKyAgICAgICAgPHJk YXI6Ly9wcm9ibGVtLzgxMTk3MTM4PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEluY3JlYXNlIHRoZSBwcmVjaXNpb24gb2Ygb3VyIGhpZ2ggcHJlY2lz aW9uIHRpbWUgKHVzZWQgYnkgcGVyZm9ybWFuY2Uubm93KCkpIGZyb20KKyAgICAgICAgMW1zIHRv IDUwdXMgd2hlbiBjcm9zcy1vcmlnaW4gaXNvbGF0ZWQgdmlhIENPT1A9c2FtZS1vcmlnaW4gKyBD T0VQPXJlcXVpcmUtY29ycC4KKyAgICAgICAgUHJlY2lzaW9uIHJlbWFpbnMgdGhlIHNhbWUgKDFt cykgd2hlbiBub3QgY3Jvc3Mtb3JpZ2luIGlzb2xhdGVkLgorCisgICAgICAgIE5vdGUgdGhhdCBD aHJvbWUgcHJvdmlkZXMgaGlnaGVyIHByZWNpc2lvbiAoMTAwdXMgaW4gZ2VuZXJhbCBhbmQgNXVz IHdoZW4KKyAgICAgICAgY3Jvc3Mtb3JpZ2luLWlzb2xhdGVkKS4gRmlyZWZveCBzZWVtcyB0byB1 c2UgMW1zIGluIGdlbmVyYWwgYW5kIDIwdXMgd2hlbiBpc29sYXRlZC4KKworICAgICAgICAqIGRv bS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlNjcmlwdEV4 ZWN1dGlvbkNvbnRleHQ6OnNldENyb3NzT3JpZ2luTW9kZSk6CisgICAgICAgICogcGFnZS9QZXJm b3JtYW5jZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQZXJmb3JtYW5jZTo6cmVkdWNlVGltZVJl c29sdXRpb24pOgorICAgICAgICAoV2ViQ29yZTo6UGVyZm9ybWFuY2U6OmFsbG93SGlnaFByZWNp c2lvblRpbWUpOgorICAgICAgICAqIHBhZ2UvUGVyZm9ybWFuY2UuaDoKKwogMjAyMS0wOS0wMSAg Q2hyaXMgRHVtZXogIDxjZHVtZXpAYXBwbGUuY29tPgogCiAgICAgICAgIFJlZ3Jlc3Npb24ocjI3 MjYwNykgUmVtb3ZhbCBvZiBhbGVydCgpL2NvbmZpcm0oKSBpbiB0aGlyZC1wYXJ0eSBpZnJhbWVz IGJyZWFrcyBTYWxlc2ZvcmNlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vU2NyaXB0 RXhlY3V0aW9uQ29udGV4dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9u Q29udGV4dC5jcHAKaW5kZXggYjdkNjRkMjcyZWQxYmY4YmI5NzMzNTU4OTc3MmExYmUxOTA4N2Q5 NC4uZWM0MjU3ODI5ZWNjMzM2NTk2Yzg5NDQ5M2FhMzFlZjk5YTQ4N2U4ZSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250ZXh0LmNwcApAQCAtNDcsNiArNDcsNyBA QAogI2luY2x1ZGUgIk1lc3NhZ2VQb3J0LmgiCiAjaW5jbHVkZSAiTmF2aWdhdG9yLmgiCiAjaW5j bHVkZSAiUGFnZS5oIgorI2luY2x1ZGUgIlBlcmZvcm1hbmNlLmgiCiAjaW5jbHVkZSAiUHVibGlj VVJMTWFuYWdlci5oIgogI2luY2x1ZGUgIlJlamVjdGVkUHJvbWlzZVRyYWNrZXIuaCIKICNpbmNs dWRlICJSZXNvdXJjZVJlcXVlc3QuaCIKQEAgLTYyOCw2ICs2MjksOCBAQCBTZXJ2aWNlV29ya2Vy Q29udGFpbmVyKiBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjplbnN1cmVTZXJ2aWNlV29ya2VyQ29u dGFpbmVyKCkKIHZvaWQgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6c2V0Q3Jvc3NPcmlnaW5Nb2Rl KENyb3NzT3JpZ2luTW9kZSBjcm9zc09yaWdpbk1vZGUpCiB7CiAgICAgZ2xvYmFsQ3Jvc3NPcmln aW5Nb2RlID0gY3Jvc3NPcmlnaW5Nb2RlOworICAgIGlmIChjcm9zc09yaWdpbk1vZGUgPT0gQ3Jv c3NPcmlnaW5Nb2RlOjpJc29sYXRlZCkKKyAgICAgICAgUGVyZm9ybWFuY2U6OmFsbG93SGlnaFBy ZWNpc2lvblRpbWUoKTsKIH0KIAogQ3Jvc3NPcmlnaW5Nb2RlIFNjcmlwdEV4ZWN1dGlvbkNvbnRl eHQ6OmNyb3NzT3JpZ2luTW9kZSgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1Bl cmZvcm1hbmNlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGVyZm9ybWFuY2UuY3BwCmluZGV4 IGFiNGE3MGVhNDMxYzVhN2RmNmU3ODI3ZmFjY2VhMzZkMzNmODBiZTMuLjcyZjc4YWIxZmVmMWI5 ZGQyNDA0ZDlkNjUyNGMxN2NhMzg1YWNiYjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvUGVyZm9ybWFuY2UuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGVyZm9ybWFuY2Uu Y3BwCkBAIC01OCw2ICs1OCw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogV1RGX01BS0VfSVNP X0FMTE9DQVRFRF9JTVBMKFBlcmZvcm1hbmNlKTsKIAorY29uc3RleHByIFNlY29uZHMgaGlnaFRp bWVQcmVjaXNpb24geyA1MF91cyB9Oworc3RhdGljIFNlY29uZHMgdGltZVByZWNpc2lvbiB7IDFf bXMgfTsKKwogUGVyZm9ybWFuY2U6OlBlcmZvcm1hbmNlKFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQq IGNvbnRleHQsIE1vbm90b25pY1RpbWUgdGltZU9yaWdpbikKICAgICA6IENvbnRleHREZXN0cnVj dGlvbk9ic2VydmVyKGNvbnRleHQpCiAgICAgLCBtX3Jlc291cmNlVGltaW5nQnVmZmVyRnVsbFRp bWVyKCp0aGlzLCAmUGVyZm9ybWFuY2U6OnJlc291cmNlVGltaW5nQnVmZmVyRnVsbFRpbWVyRmly ZWQpIC8vIEZJWE1FOiBNaWdyYXRlIHRoaXMgdG8gdGhlIGV2ZW50IGxvb3AgYXMgd2VsbC4gaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIyOTA0NApAQCAtOTIsMTEgKzk1 LDE2IEBAIFJlZHVjZWRSZXNvbHV0aW9uU2Vjb25kcyBQZXJmb3JtYW5jZTo6bm93SW5SZWR1Y2Vk UmVzb2x1dGlvblNlY29uZHMoKSBjb25zdAogCiBTZWNvbmRzIFBlcmZvcm1hbmNlOjpyZWR1Y2VU aW1lUmVzb2x1dGlvbihTZWNvbmRzIHNlY29uZHMpCiB7Ci0gICAgZG91YmxlIHJlc29sdXRpb24g PSAoMTAwMF91cykuc2Vjb25kcygpOworICAgIGRvdWJsZSByZXNvbHV0aW9uID0gdGltZVByZWNp c2lvbi5zZWNvbmRzKCk7CiAgICAgZG91YmxlIHJlZHVjZWQgPSBzdGQ6OmZsb29yKHNlY29uZHMu c2Vjb25kcygpIC8gcmVzb2x1dGlvbikgKiByZXNvbHV0aW9uOwogICAgIHJldHVybiBTZWNvbmRz KHJlZHVjZWQpOwogfQogCit2b2lkIFBlcmZvcm1hbmNlOjphbGxvd0hpZ2hQcmVjaXNpb25UaW1l KCkKK3sKKyAgICB0aW1lUHJlY2lzaW9uID0gaGlnaFRpbWVQcmVjaXNpb247Cit9CisKIERPTUhp Z2hSZXNUaW1lU3RhbXAgUGVyZm9ybWFuY2U6OnJlbGF0aXZlVGltZUZyb21UaW1lT3JpZ2luSW5S ZWR1Y2VkUmVzb2x1dGlvbihNb25vdG9uaWNUaW1lIHRpbWVzdGFtcCkgY29uc3QKIHsKICAgICBT ZWNvbmRzIHNlY29uZHMgPSB0aW1lc3RhbXAgLSBtX3RpbWVPcmlnaW47CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wYWdlL1BlcmZvcm1hbmNlLmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1Bl cmZvcm1hbmNlLmgKaW5kZXggYzU1NWUwZWM4OWNlOTlkZWYxNjdjMTkyZGIwMjNlMGU2MGViYjJm Ni4uYTJlMGQwNjBhMTQwZGYzODRjZjdkMDU4OWY5NzZkMmU5ZjgzYWZhMyAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGFnZS9QZXJmb3JtYW5jZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvUGVyZm9ybWFuY2UuaApAQCAtMTA1LDYgKzEwNSw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHJl Z2lzdGVyUGVyZm9ybWFuY2VPYnNlcnZlcihQZXJmb3JtYW5jZU9ic2VydmVyJik7CiAgICAgdm9p ZCB1bnJlZ2lzdGVyUGVyZm9ybWFuY2VPYnNlcnZlcihQZXJmb3JtYW5jZU9ic2VydmVyJik7CiAK KyAgICBzdGF0aWMgdm9pZCBhbGxvd0hpZ2hQcmVjaXNpb25UaW1lKCk7CiAgICAgc3RhdGljIFNl Y29uZHMgcmVkdWNlVGltZVJlc29sdXRpb24oU2Vjb25kcyk7CiAKICAgICBET01IaWdoUmVzVGlt ZVN0YW1wIHJlbGF0aXZlVGltZUZyb21UaW1lT3JpZ2luSW5SZWR1Y2VkUmVzb2x1dGlvbihNb25v dG9uaWNUaW1lKSBjb25zdDsK 437048 2021-09-01 11:55:18 -0700 2021-09-01 14:35:09 -0700 Patch bug-228137-20210901115517.patch text/plain 4232 cdumez U3VidmVyc2lvbiBSZXZpc2lvbjogMjgxODY1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMGQ4MjI5YjI4ZjkwMzBm MDE5MzhiOGY5YmZlZGJhN2U2M2IxOTY0ZC4uNGVkNDcxOTJmMDc0NmVmMjEyMDk1OTFhYjNlMDkw YmUxNjkwYzFhZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI3IEBACisyMDIxLTA5LTAxICBDaHJp cyBEdW1leiAgPGNkdW1lekBhcHBsZS5jb20+CisKKyAgICAgICAgSW1wcm92ZSB0aW1lIHByZWNp c2lvbiB3aGVuIGNyb3NzLW9yaWdpbiBpc29sYXRlZCB2aWEgQ09PUCtDT0VQCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMjgxMzcKKyAgICAgICAgPHJk YXI6Ly9wcm9ibGVtLzgxMTk3MTM4PgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgIEluY3JlYXNlIHRoZSBwcmVjaXNpb24gb2Ygb3VyIGhpZ2ggcHJlY2lz aW9uIHRpbWUgKHVzZWQgYnkgcGVyZm9ybWFuY2Uubm93KCkpIGZyb20KKyAgICAgICAgMW1zIHRv IDIwdXMgd2hlbiBjcm9zcy1vcmlnaW4gaXNvbGF0ZWQgdmlhIENPT1A9c2FtZS1vcmlnaW4gKyBD T0VQPXJlcXVpcmUtY29ycC4KKyAgICAgICAgUHJlY2lzaW9uIHJlbWFpbnMgdGhlIHNhbWUgKDFt cykgd2hlbiBub3QgY3Jvc3Mtb3JpZ2luIGlzb2xhdGVkLgorCisgICAgICAgIFRoaXMgYWxpZ25z IG91ciBiZWhhdmlvciB3aXRoIEZpcmVmb3guCisKKyAgICAgICAgTm90ZSB0aGF0IENocm9tZSBw cm92aWRlcyBoaWdoZXIgcHJlY2lzaW9uICgxMDB1cyBpbiBnZW5lcmFsIGFuZCA1dXMgd2hlbgor ICAgICAgICBjcm9zcy1vcmlnaW4taXNvbGF0ZWQpLgorCisgICAgICAgICogZG9tL1NjcmlwdEV4 ZWN1dGlvbkNvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6U2NyaXB0RXhlY3V0aW9uQ29u dGV4dDo6c2V0Q3Jvc3NPcmlnaW5Nb2RlKToKKyAgICAgICAgKiBwYWdlL1BlcmZvcm1hbmNlLmNw cDoKKyAgICAgICAgKFdlYkNvcmU6OlBlcmZvcm1hbmNlOjpyZWR1Y2VUaW1lUmVzb2x1dGlvbik6 CisgICAgICAgIChXZWJDb3JlOjpQZXJmb3JtYW5jZTo6YWxsb3dIaWdoUHJlY2lzaW9uVGltZSk6 CisgICAgICAgICogcGFnZS9QZXJmb3JtYW5jZS5oOgorCiAyMDIxLTA5LTAxICBLaW1tbyBLaW5u dW5lbiAgPGtraW5udW5lbkBhcHBsZS5jb20+CiAKICAgICAgICAgSW1hZ2VSZW5kZXJpbmdNb2Rl LmggaXMgbm90IHVzZWQKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRFeGVj dXRpb25Db250ZXh0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9TY3JpcHRFeGVjdXRpb25Db250 ZXh0LmNwcAppbmRleCBiN2Q2NGQyNzJlZDFiZjhiYjk3MzM1NTg5NzcyYTFiZTE5MDg3ZDk0Li5l YzQyNTc4MjllY2MzMzY1OTZjODk0NDkzYWEzMWVmOTlhNDg3ZThlIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9kb20vU2NyaXB0RXhlY3V0aW9uQ29udGV4dC5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvZG9tL1NjcmlwdEV4ZWN1dGlvbkNvbnRleHQuY3BwCkBAIC00Nyw2ICs0Nyw3IEBACiAj aW5jbHVkZSAiTWVzc2FnZVBvcnQuaCIKICNpbmNsdWRlICJOYXZpZ2F0b3IuaCIKICNpbmNsdWRl ICJQYWdlLmgiCisjaW5jbHVkZSAiUGVyZm9ybWFuY2UuaCIKICNpbmNsdWRlICJQdWJsaWNVUkxN YW5hZ2VyLmgiCiAjaW5jbHVkZSAiUmVqZWN0ZWRQcm9taXNlVHJhY2tlci5oIgogI2luY2x1ZGUg IlJlc291cmNlUmVxdWVzdC5oIgpAQCAtNjI4LDYgKzYyOSw4IEBAIFNlcnZpY2VXb3JrZXJDb250 YWluZXIqIFNjcmlwdEV4ZWN1dGlvbkNvbnRleHQ6OmVuc3VyZVNlcnZpY2VXb3JrZXJDb250YWlu ZXIoKQogdm9pZCBTY3JpcHRFeGVjdXRpb25Db250ZXh0OjpzZXRDcm9zc09yaWdpbk1vZGUoQ3Jv c3NPcmlnaW5Nb2RlIGNyb3NzT3JpZ2luTW9kZSkKIHsKICAgICBnbG9iYWxDcm9zc09yaWdpbk1v ZGUgPSBjcm9zc09yaWdpbk1vZGU7CisgICAgaWYgKGNyb3NzT3JpZ2luTW9kZSA9PSBDcm9zc09y aWdpbk1vZGU6Oklzb2xhdGVkKQorICAgICAgICBQZXJmb3JtYW5jZTo6YWxsb3dIaWdoUHJlY2lz aW9uVGltZSgpOwogfQogCiBDcm9zc09yaWdpbk1vZGUgU2NyaXB0RXhlY3V0aW9uQ29udGV4dDo6 Y3Jvc3NPcmlnaW5Nb2RlKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGVyZm9y bWFuY2UuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QZXJmb3JtYW5jZS5jcHAKaW5kZXggNTcx YWYzYWU5NGYxMTQxMmFmYWJhMWZkNzBlMTc2N2FiZmVhYzk2My4uOTE3OTZlYzRiYTlhODkyYTBm NWY1ZTlmMjk0YTZhMWU0YmY1NmJlMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9Q ZXJmb3JtYW5jZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QZXJmb3JtYW5jZS5jcHAK QEAgLTU4LDYgKzU4LDkgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBXVEZfTUFLRV9JU09fQUxM T0NBVEVEX0lNUEwoUGVyZm9ybWFuY2UpOwogCitjb25zdGV4cHIgU2Vjb25kcyBoaWdoVGltZVBy ZWNpc2lvbiB7IDIwX3VzIH07CitzdGF0aWMgU2Vjb25kcyB0aW1lUHJlY2lzaW9uIHsgMV9tcyB9 OworCiBQZXJmb3JtYW5jZTo6UGVyZm9ybWFuY2UoU2NyaXB0RXhlY3V0aW9uQ29udGV4dCogY29u dGV4dCwgTW9ub3RvbmljVGltZSB0aW1lT3JpZ2luKQogICAgIDogQ29udGV4dERlc3RydWN0aW9u T2JzZXJ2ZXIoY29udGV4dCkKICAgICAsIG1fcmVzb3VyY2VUaW1pbmdCdWZmZXJGdWxsVGltZXIo KnRoaXMsICZQZXJmb3JtYW5jZTo6cmVzb3VyY2VUaW1pbmdCdWZmZXJGdWxsVGltZXJGaXJlZCkg Ly8gRklYTUU6IE1pZ3JhdGUgdGhpcyB0byB0aGUgZXZlbnQgbG9vcCBhcyB3ZWxsLiBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjI5MDQ0CkBAIC05MiwxMSArOTUsMTYg QEAgUmVkdWNlZFJlc29sdXRpb25TZWNvbmRzIFBlcmZvcm1hbmNlOjpub3dJblJlZHVjZWRSZXNv bHV0aW9uU2Vjb25kcygpIGNvbnN0CiAKIFNlY29uZHMgUGVyZm9ybWFuY2U6OnJlZHVjZVRpbWVS ZXNvbHV0aW9uKFNlY29uZHMgc2Vjb25kcykKIHsKLSAgICBkb3VibGUgcmVzb2x1dGlvbiA9ICgx MDAwX3VzKS5zZWNvbmRzKCk7CisgICAgZG91YmxlIHJlc29sdXRpb24gPSB0aW1lUHJlY2lzaW9u LnNlY29uZHMoKTsKICAgICBkb3VibGUgcmVkdWNlZCA9IHN0ZDo6Zmxvb3Ioc2Vjb25kcy5zZWNv bmRzKCkgLyByZXNvbHV0aW9uKSAqIHJlc29sdXRpb247CiAgICAgcmV0dXJuIFNlY29uZHMocmVk dWNlZCk7CiB9CiAKK3ZvaWQgUGVyZm9ybWFuY2U6OmFsbG93SGlnaFByZWNpc2lvblRpbWUoKQor eworICAgIHRpbWVQcmVjaXNpb24gPSBoaWdoVGltZVByZWNpc2lvbjsKK30KKwogRE9NSGlnaFJl c1RpbWVTdGFtcCBQZXJmb3JtYW5jZTo6cmVsYXRpdmVUaW1lRnJvbVRpbWVPcmlnaW5JblJlZHVj ZWRSZXNvbHV0aW9uKE1vbm90b25pY1RpbWUgdGltZXN0YW1wKSBjb25zdAogewogICAgIFNlY29u ZHMgc2Vjb25kcyA9IHRpbWVzdGFtcCAtIG1fdGltZU9yaWdpbjsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvUGVyZm9ybWFuY2UuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUGVyZm9y bWFuY2UuaAppbmRleCA4NmRlNTA2YThjZTA4MWExYTJlMzdlNGJlMDI2NTEyMDMzMGFjNDEzLi5j NTIwNjlmYjM5YzI5MDBlZmEyNTM5ZDAwYjg1ZmJkNDQ5ZGY4ZWViIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL1BlcmZvcm1hbmNlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9Q ZXJmb3JtYW5jZS5oCkBAIC0xMDYsNiArMTA2LDcgQEAgcHVibGljOgogICAgIHZvaWQgcmVnaXN0 ZXJQZXJmb3JtYW5jZU9ic2VydmVyKFBlcmZvcm1hbmNlT2JzZXJ2ZXImKTsKICAgICB2b2lkIHVu cmVnaXN0ZXJQZXJmb3JtYW5jZU9ic2VydmVyKFBlcmZvcm1hbmNlT2JzZXJ2ZXImKTsKIAorICAg IHN0YXRpYyB2b2lkIGFsbG93SGlnaFByZWNpc2lvblRpbWUoKTsKICAgICBzdGF0aWMgU2Vjb25k cyByZWR1Y2VUaW1lUmVzb2x1dGlvbihTZWNvbmRzKTsKIAogICAgIERPTUhpZ2hSZXNUaW1lU3Rh bXAgcmVsYXRpdmVUaW1lRnJvbVRpbWVPcmlnaW5JblJlZHVjZWRSZXNvbHV0aW9uKE1vbm90b25p Y1RpbWUpIGNvbnN0Owo=