From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755059AbcESRRe (ORCPT ); Thu, 19 May 2016 13:17:34 -0400 Received: from mail.kernel.org ([198.145.29.136]:47697 "EHLO mail.kernel.org" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1754484AbcESRRd (ORCPT ); Thu, 19 May 2016 13:17:33 -0400 Date: Thu, 19 May 2016 18:17:21 +0100 (BST) From: Stefano Stabellini X-X-Sender: sstabellini@sstabellini-ThinkPad-X260 To: Stefano Stabellini cc: Juergen Gross , xen-devel@lists.xenproject.org, linux-kernel@vger.kernel.org, boris.ostrovsky@oracle.com, david.vrabel@citrix.com Subject: Re: [PATCH v3] xen: add steal_clock support on x86 In-Reply-To: Message-ID: References: <1463664367-7675-1-git-send-email-jgross@suse.com> User-Agent: Alpine 2.10 (DEB 1266 2009-07-14) MIME-Version: 1.0 Content-Type: TEXT/PLAIN; charset=US-ASCII Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Thu, 19 May 2016, Stefano Stabellini wrote: > On Thu, 19 May 2016, Juergen Gross wrote: > > The pv_time_ops structure contains a function pointer for the > > "steal_clock" functionality used only by KVM and Xen on ARM. Xen on x86 > > uses its own mechanism to account for the "stolen" time a thread wasn't > > able to run due to hypervisor scheduling. > > > > Add support in Xen arch independent time handling for this feature by > > moving it out of the arm arch into drivers/xen and remove the x86 Xen > > hack. > > > > Signed-off-by: Juergen Gross > > --- > > V3: add #include to avoid build error on arm > > V2: remove the x86 do_stolen_accounting() hack > > --- > > arch/arm/xen/enlighten.c | 17 ++--------------- > > arch/x86/xen/time.c | 44 ++------------------------------------------ > > drivers/xen/time.c | 20 ++++++++++++++++++++ > > include/linux/kernel_stat.h | 1 - > > include/xen/xen-ops.h | 1 + > > kernel/sched/cputime.c | 10 ---------- > > 6 files changed, 25 insertions(+), 68 deletions(-) > > > > diff --git a/arch/arm/xen/enlighten.c b/arch/arm/xen/enlighten.c > > index 75cd734..9163b94 100644 > > --- a/arch/arm/xen/enlighten.c > > +++ b/arch/arm/xen/enlighten.c > > @@ -84,19 +84,6 @@ int xen_unmap_domain_gfn_range(struct vm_area_struct *vma, > > } > > EXPORT_SYMBOL_GPL(xen_unmap_domain_gfn_range); > > > > -static unsigned long long xen_stolen_accounting(int cpu) > > -{ > > - struct vcpu_runstate_info state; > > - > > - BUG_ON(cpu != smp_processor_id()); > > - > > - xen_get_runstate_snapshot(&state); > > - > > - WARN_ON(state.state != RUNSTATE_running); > > - > > - return state.time[RUNSTATE_runnable] + state.time[RUNSTATE_offline]; > > -} > > - > > static void xen_read_wallclock(struct timespec64 *ts) > > { > > u32 version; > > @@ -355,8 +342,8 @@ static int __init xen_guest_init(void) > > > > register_cpu_notifier(&xen_cpu_notifier); > > > > - pv_time_ops.steal_clock = xen_stolen_accounting; > > - static_key_slow_inc(¶virt_steal_enabled); > > + xen_time_setup_guest(); > > You can remove > > #include > > from headers now I believe Sorry for the broken English. I meant: you can remove #include from the top of the file now I believe. > > > if (xen_initial_domain()) > > pvclock_gtod_register_notifier(&xen_pvclock_gtod_notifier); > > > > diff --git a/arch/x86/xen/time.c b/arch/x86/xen/time.c > > index a0a4e55..6be31df 100644 > > --- a/arch/x86/xen/time.c > > +++ b/arch/x86/xen/time.c > > @@ -11,8 +11,6 @@ > > #include > > #include > > #include > > -#include > > -#include > > #include > > #include > > #include > > @@ -31,44 +29,6 @@ > > > > /* Xen may fire a timer up to this many ns early */ > > #define TIMER_SLOP 100000 > > -#define NS_PER_TICK (1000000000LL / HZ) > > - > > -/* snapshots of runstate info */ > > -static DEFINE_PER_CPU(struct vcpu_runstate_info, xen_runstate_snapshot); > > - > > -/* unused ns of stolen time */ > > -static DEFINE_PER_CPU(u64, xen_residual_stolen); > > - > > -static void do_stolen_accounting(void) > > -{ > > - struct vcpu_runstate_info state; > > - struct vcpu_runstate_info *snap; > > - s64 runnable, offline, stolen; > > - cputime_t ticks; > > - > > - xen_get_runstate_snapshot(&state); > > - > > - WARN_ON(state.state != RUNSTATE_running); > > - > > - snap = this_cpu_ptr(&xen_runstate_snapshot); > > - > > - /* work out how much time the VCPU has not been runn*ing* */ > > - runnable = state.time[RUNSTATE_runnable] - snap->time[RUNSTATE_runnable]; > > - offline = state.time[RUNSTATE_offline] - snap->time[RUNSTATE_offline]; > > - > > - *snap = state; > > - > > - /* Add the appropriate number of ticks of stolen time, > > - including any left-overs from last time. */ > > - stolen = runnable + offline + __this_cpu_read(xen_residual_stolen); > > - > > - if (stolen < 0) > > - stolen = 0; > > - > > - ticks = iter_div_u64_rem(stolen, NS_PER_TICK, &stolen); > > - __this_cpu_write(xen_residual_stolen, stolen); > > - account_steal_ticks(ticks); > > -} > > > > /* Get the TSC speed from Xen */ > > static unsigned long xen_tsc_khz(void) > > @@ -335,8 +295,6 @@ static irqreturn_t xen_timer_interrupt(int irq, void *dev_id) > > ret = IRQ_HANDLED; > > } > > > > - do_stolen_accounting(); > > - > > return ret; > > } > > > > @@ -431,6 +389,8 @@ static void __init xen_time_init(void) > > xen_setup_timer(cpu); > > xen_setup_cpu_clockevents(); > > > > + xen_time_setup_guest(); > > + > > if (xen_initial_domain()) > > pvclock_gtod_register_notifier(&xen_pvclock_gtod_notifier); > > } > > diff --git a/drivers/xen/time.c b/drivers/xen/time.c > > index 7107842..2257b66 100644 > > --- a/drivers/xen/time.c > > +++ b/drivers/xen/time.c > > @@ -6,6 +6,7 @@ > > #include > > #include > > > > +#include > > #include > > #include > > > > @@ -75,6 +76,15 @@ bool xen_vcpu_stolen(int vcpu) > > return per_cpu(xen_runstate, vcpu).state == RUNSTATE_runnable; > > } > > > > +static u64 xen_steal_clock(int cpu) > > +{ > > + struct vcpu_runstate_info state; > > + > > + BUG_ON(cpu != smp_processor_id()); > > + xen_get_runstate_snapshot(&state); > > + return state.time[RUNSTATE_runnable] + state.time[RUNSTATE_offline]; > > +} > > + > > void xen_setup_runstate_info(int cpu) > > { > > struct vcpu_register_runstate_memory_area area; > > @@ -86,3 +96,13 @@ void xen_setup_runstate_info(int cpu) > > BUG(); > > } > > > > +void __init xen_time_setup_guest(void) > > +{ > > + pv_time_ops.steal_clock = xen_steal_clock; > > + > > + static_key_slow_inc(¶virt_steal_enabled); > > + /* > > + * We can't set paravirt_steal_rq_enabled as this would require the > > + * capability to read another cpu's runstate info. > > + */ > > +} > > diff --git a/include/linux/kernel_stat.h b/include/linux/kernel_stat.h > > index 25a822f..44fda64 100644 > > --- a/include/linux/kernel_stat.h > > +++ b/include/linux/kernel_stat.h > > @@ -92,7 +92,6 @@ static inline void account_process_tick(struct task_struct *tsk, int user) > > extern void account_process_tick(struct task_struct *, int user); > > #endif > > > > -extern void account_steal_ticks(unsigned long ticks); > > extern void account_idle_ticks(unsigned long ticks); > > > > #endif /* _LINUX_KERNEL_STAT_H */ > > diff --git a/include/xen/xen-ops.h b/include/xen/xen-ops.h > > index 86abe07..5ce51c2 100644 > > --- a/include/xen/xen-ops.h > > +++ b/include/xen/xen-ops.h > > @@ -21,6 +21,7 @@ void xen_resume_notifier_unregister(struct notifier_block *nb); > > > > bool xen_vcpu_stolen(int vcpu); > > void xen_setup_runstate_info(int cpu); > > +void __init xen_time_setup_guest(void); > > please avoid __init in headers > > > > void xen_get_runstate_snapshot(struct vcpu_runstate_info *res); > > > > int xen_setup_shutdown_event(void); > > diff --git a/kernel/sched/cputime.c b/kernel/sched/cputime.c > > index 75f98c5..8c4c6dc 100644 > > --- a/kernel/sched/cputime.c > > +++ b/kernel/sched/cputime.c > > @@ -490,16 +490,6 @@ void account_process_tick(struct task_struct *p, int user_tick) > > } > > > > /* > > - * Account multiple ticks of steal time. > > - * @p: the process from which the cpu time has been stolen > > - * @ticks: number of stolen ticks > > - */ > > -void account_steal_ticks(unsigned long ticks) > > -{ > > - account_steal_time(jiffies_to_cputime(ticks)); > > -} > > - > > -/* > > * Account multiple ticks of idle time. > > * @ticks: number of stolen ticks > > */ > > -- > > 2.6.6 > > > From mboxrd@z Thu Jan 1 00:00:00 1970 From: Stefano Stabellini Subject: Re: [PATCH v3] xen: add steal_clock support on x86 Date: Thu, 19 May 2016 18:17:21 +0100 (BST) Message-ID: References: <1463664367-7675-1-git-send-email-jgross@suse.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail6.bemta5.messagelabs.com ([195.245.231.135]) by lists.xenproject.org with esmtp (Exim 4.84_2) (envelope-from ) id 1b3RZn-0006kD-9e for xen-devel@lists.xenproject.org; Thu, 19 May 2016 17:17:35 +0000 In-Reply-To: List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xen.org Sender: "Xen-devel" To: Stefano Stabellini Cc: Juergen Gross , xen-devel@lists.xenproject.org, boris.ostrovsky@oracle.com, linux-kernel@vger.kernel.org, david.vrabel@citrix.com List-Id: xen-devel@lists.xenproject.org T24gVGh1LCAxOSBNYXkgMjAxNiwgU3RlZmFubyBTdGFiZWxsaW5pIHdyb3RlOgo+IE9uIFRodSwg MTkgTWF5IDIwMTYsIEp1ZXJnZW4gR3Jvc3Mgd3JvdGU6Cj4gPiBUaGUgcHZfdGltZV9vcHMgc3Ry dWN0dXJlIGNvbnRhaW5zIGEgZnVuY3Rpb24gcG9pbnRlciBmb3IgdGhlCj4gPiAic3RlYWxfY2xv Y2siIGZ1bmN0aW9uYWxpdHkgdXNlZCBvbmx5IGJ5IEtWTSBhbmQgWGVuIG9uIEFSTS4gWGVuIG9u IHg4Ngo+ID4gdXNlcyBpdHMgb3duIG1lY2hhbmlzbSB0byBhY2NvdW50IGZvciB0aGUgInN0b2xl biIgdGltZSBhIHRocmVhZCB3YXNuJ3QKPiA+IGFibGUgdG8gcnVuIGR1ZSB0byBoeXBlcnZpc29y IHNjaGVkdWxpbmcuCj4gPiAKPiA+IEFkZCBzdXBwb3J0IGluIFhlbiBhcmNoIGluZGVwZW5kZW50 IHRpbWUgaGFuZGxpbmcgZm9yIHRoaXMgZmVhdHVyZSBieQo+ID4gbW92aW5nIGl0IG91dCBvZiB0 aGUgYXJtIGFyY2ggaW50byBkcml2ZXJzL3hlbiBhbmQgcmVtb3ZlIHRoZSB4ODYgWGVuCj4gPiBo YWNrLgo+ID4gCj4gPiBTaWduZWQtb2ZmLWJ5OiBKdWVyZ2VuIEdyb3NzIDxqZ3Jvc3NAc3VzZS5j b20+Cj4gPiAtLS0KPiA+IFYzOiBhZGQgI2luY2x1ZGUgPGFzbS9wYXJhdmlydC5oPiB0byBhdm9p ZCBidWlsZCBlcnJvciBvbiBhcm0KPiA+IFYyOiByZW1vdmUgdGhlIHg4NiBkb19zdG9sZW5fYWNj b3VudGluZygpIGhhY2sKPiA+IC0tLQo+ID4gIGFyY2gvYXJtL3hlbi9lbmxpZ2h0ZW4uYyAgICB8 IDE3ICsrLS0tLS0tLS0tLS0tLS0tCj4gPiAgYXJjaC94ODYveGVuL3RpbWUuYyAgICAgICAgIHwg NDQgKystLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KPiA+ICBkcml2 ZXJzL3hlbi90aW1lLmMgICAgICAgICAgfCAyMCArKysrKysrKysrKysrKysrKysrKwo+ID4gIGlu Y2x1ZGUvbGludXgva2VybmVsX3N0YXQuaCB8ICAxIC0KPiA+ICBpbmNsdWRlL3hlbi94ZW4tb3Bz LmggICAgICAgfCAgMSArCj4gPiAga2VybmVsL3NjaGVkL2NwdXRpbWUuYyAgICAgIHwgMTAgLS0t LS0tLS0tLQo+ID4gIDYgZmlsZXMgY2hhbmdlZCwgMjUgaW5zZXJ0aW9ucygrKSwgNjggZGVsZXRp b25zKC0pCj4gPiAKPiA+IGRpZmYgLS1naXQgYS9hcmNoL2FybS94ZW4vZW5saWdodGVuLmMgYi9h cmNoL2FybS94ZW4vZW5saWdodGVuLmMKPiA+IGluZGV4IDc1Y2Q3MzQuLjkxNjNiOTQgMTAwNjQ0 Cj4gPiAtLS0gYS9hcmNoL2FybS94ZW4vZW5saWdodGVuLmMKPiA+ICsrKyBiL2FyY2gvYXJtL3hl bi9lbmxpZ2h0ZW4uYwo+ID4gQEAgLTg0LDE5ICs4NCw2IEBAIGludCB4ZW5fdW5tYXBfZG9tYWlu X2dmbl9yYW5nZShzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSwKPiA+ICB9Cj4gPiAgRVhQT1JU X1NZTUJPTF9HUEwoeGVuX3VubWFwX2RvbWFpbl9nZm5fcmFuZ2UpOwo+ID4gIAo+ID4gLXN0YXRp YyB1bnNpZ25lZCBsb25nIGxvbmcgeGVuX3N0b2xlbl9hY2NvdW50aW5nKGludCBjcHUpCj4gPiAt ewo+ID4gLQlzdHJ1Y3QgdmNwdV9ydW5zdGF0ZV9pbmZvIHN0YXRlOwo+ID4gLQo+ID4gLQlCVUdf T04oY3B1ICE9IHNtcF9wcm9jZXNzb3JfaWQoKSk7Cj4gPiAtCj4gPiAtCXhlbl9nZXRfcnVuc3Rh dGVfc25hcHNob3QoJnN0YXRlKTsKPiA+IC0KPiA+IC0JV0FSTl9PTihzdGF0ZS5zdGF0ZSAhPSBS VU5TVEFURV9ydW5uaW5nKTsKPiA+IC0KPiA+IC0JcmV0dXJuIHN0YXRlLnRpbWVbUlVOU1RBVEVf cnVubmFibGVdICsgc3RhdGUudGltZVtSVU5TVEFURV9vZmZsaW5lXTsKPiA+IC19Cj4gPiAtCj4g PiAgc3RhdGljIHZvaWQgeGVuX3JlYWRfd2FsbGNsb2NrKHN0cnVjdCB0aW1lc3BlYzY0ICp0cykK PiA+ICB7Cj4gPiAgCXUzMiB2ZXJzaW9uOwo+ID4gQEAgLTM1NSw4ICszNDIsOCBAQCBzdGF0aWMg aW50IF9faW5pdCB4ZW5fZ3Vlc3RfaW5pdCh2b2lkKQo+ID4gIAo+ID4gIAlyZWdpc3Rlcl9jcHVf bm90aWZpZXIoJnhlbl9jcHVfbm90aWZpZXIpOwo+ID4gIAo+ID4gLQlwdl90aW1lX29wcy5zdGVh bF9jbG9jayA9IHhlbl9zdG9sZW5fYWNjb3VudGluZzsKPiA+IC0Jc3RhdGljX2tleV9zbG93X2lu YygmcGFyYXZpcnRfc3RlYWxfZW5hYmxlZCk7Cj4gPiArCXhlbl90aW1lX3NldHVwX2d1ZXN0KCk7 Cj4gCj4gWW91IGNhbiByZW1vdmUKPiAKPiAjaW5jbHVkZSA8YXNtL3BhcmF2aXJ0Lmg+Cj4gCj4g ZnJvbSBoZWFkZXJzIG5vdyBJIGJlbGlldmUKClNvcnJ5IGZvciB0aGUgYnJva2VuIEVuZ2xpc2gu IEkgbWVhbnQ6IHlvdSBjYW4gcmVtb3ZlICNpbmNsdWRlCjxhc20vcGFyYXZpcnQuaD4gZnJvbSB0 aGUgdG9wIG9mIHRoZSBmaWxlIG5vdyBJIGJlbGlldmUuCgoKPiAKPiA+ICAJaWYgKHhlbl9pbml0 aWFsX2RvbWFpbigpKQo+ID4gIAkJcHZjbG9ja19ndG9kX3JlZ2lzdGVyX25vdGlmaWVyKCZ4ZW5f cHZjbG9ja19ndG9kX25vdGlmaWVyKTsKPiA+ICAKPiA+IGRpZmYgLS1naXQgYS9hcmNoL3g4Ni94 ZW4vdGltZS5jIGIvYXJjaC94ODYveGVuL3RpbWUuYwo+ID4gaW5kZXggYTBhNGU1NS4uNmJlMzFk ZiAxMDA2NDQKPiA+IC0tLSBhL2FyY2gveDg2L3hlbi90aW1lLmMKPiA+ICsrKyBiL2FyY2gveDg2 L3hlbi90aW1lLmMKPiA+IEBAIC0xMSw4ICsxMSw2IEBACj4gPiAgI2luY2x1ZGUgPGxpbnV4L2lu dGVycnVwdC5oPgo+ID4gICNpbmNsdWRlIDxsaW51eC9jbG9ja3NvdXJjZS5oPgo+ID4gICNpbmNs dWRlIDxsaW51eC9jbG9ja2NoaXBzLmg+Cj4gPiAtI2luY2x1ZGUgPGxpbnV4L2tlcm5lbF9zdGF0 Lmg+Cj4gPiAtI2luY2x1ZGUgPGxpbnV4L21hdGg2NC5oPgo+ID4gICNpbmNsdWRlIDxsaW51eC9n ZnAuaD4KPiA+ICAjaW5jbHVkZSA8bGludXgvc2xhYi5oPgo+ID4gICNpbmNsdWRlIDxsaW51eC9w dmNsb2NrX2d0b2QuaD4KPiA+IEBAIC0zMSw0NCArMjksNiBAQAo+ID4gIAo+ID4gIC8qIFhlbiBt YXkgZmlyZSBhIHRpbWVyIHVwIHRvIHRoaXMgbWFueSBucyBlYXJseSAqLwo+ID4gICNkZWZpbmUg VElNRVJfU0xPUAkxMDAwMDAKPiA+IC0jZGVmaW5lIE5TX1BFUl9USUNLCSgxMDAwMDAwMDAwTEwg LyBIWikKPiA+IC0KPiA+IC0vKiBzbmFwc2hvdHMgb2YgcnVuc3RhdGUgaW5mbyAqLwo+ID4gLXN0 YXRpYyBERUZJTkVfUEVSX0NQVShzdHJ1Y3QgdmNwdV9ydW5zdGF0ZV9pbmZvLCB4ZW5fcnVuc3Rh dGVfc25hcHNob3QpOwo+ID4gLQo+ID4gLS8qIHVudXNlZCBucyBvZiBzdG9sZW4gdGltZSAqLwo+ ID4gLXN0YXRpYyBERUZJTkVfUEVSX0NQVSh1NjQsIHhlbl9yZXNpZHVhbF9zdG9sZW4pOwo+ID4g LQo+ID4gLXN0YXRpYyB2b2lkIGRvX3N0b2xlbl9hY2NvdW50aW5nKHZvaWQpCj4gPiAtewo+ID4g LQlzdHJ1Y3QgdmNwdV9ydW5zdGF0ZV9pbmZvIHN0YXRlOwo+ID4gLQlzdHJ1Y3QgdmNwdV9ydW5z dGF0ZV9pbmZvICpzbmFwOwo+ID4gLQlzNjQgcnVubmFibGUsIG9mZmxpbmUsIHN0b2xlbjsKPiA+ IC0JY3B1dGltZV90IHRpY2tzOwo+ID4gLQo+ID4gLQl4ZW5fZ2V0X3J1bnN0YXRlX3NuYXBzaG90 KCZzdGF0ZSk7Cj4gPiAtCj4gPiAtCVdBUk5fT04oc3RhdGUuc3RhdGUgIT0gUlVOU1RBVEVfcnVu bmluZyk7Cj4gPiAtCj4gPiAtCXNuYXAgPSB0aGlzX2NwdV9wdHIoJnhlbl9ydW5zdGF0ZV9zbmFw c2hvdCk7Cj4gPiAtCj4gPiAtCS8qIHdvcmsgb3V0IGhvdyBtdWNoIHRpbWUgdGhlIFZDUFUgaGFz IG5vdCBiZWVuIHJ1bm4qaW5nKiAgKi8KPiA+IC0JcnVubmFibGUgPSBzdGF0ZS50aW1lW1JVTlNU QVRFX3J1bm5hYmxlXSAtIHNuYXAtPnRpbWVbUlVOU1RBVEVfcnVubmFibGVdOwo+ID4gLQlvZmZs aW5lID0gc3RhdGUudGltZVtSVU5TVEFURV9vZmZsaW5lXSAtIHNuYXAtPnRpbWVbUlVOU1RBVEVf b2ZmbGluZV07Cj4gPiAtCj4gPiAtCSpzbmFwID0gc3RhdGU7Cj4gPiAtCj4gPiAtCS8qIEFkZCB0 aGUgYXBwcm9wcmlhdGUgbnVtYmVyIG9mIHRpY2tzIG9mIHN0b2xlbiB0aW1lLAo+ID4gLQkgICBp bmNsdWRpbmcgYW55IGxlZnQtb3ZlcnMgZnJvbSBsYXN0IHRpbWUuICovCj4gPiAtCXN0b2xlbiA9 IHJ1bm5hYmxlICsgb2ZmbGluZSArIF9fdGhpc19jcHVfcmVhZCh4ZW5fcmVzaWR1YWxfc3RvbGVu KTsKPiA+IC0KPiA+IC0JaWYgKHN0b2xlbiA8IDApCj4gPiAtCQlzdG9sZW4gPSAwOwo+ID4gLQo+ ID4gLQl0aWNrcyA9IGl0ZXJfZGl2X3U2NF9yZW0oc3RvbGVuLCBOU19QRVJfVElDSywgJnN0b2xl bik7Cj4gPiAtCV9fdGhpc19jcHVfd3JpdGUoeGVuX3Jlc2lkdWFsX3N0b2xlbiwgc3RvbGVuKTsK PiA+IC0JYWNjb3VudF9zdGVhbF90aWNrcyh0aWNrcyk7Cj4gPiAtfQo+ID4gIAo+ID4gIC8qIEdl dCB0aGUgVFNDIHNwZWVkIGZyb20gWGVuICovCj4gPiAgc3RhdGljIHVuc2lnbmVkIGxvbmcgeGVu X3RzY19raHoodm9pZCkKPiA+IEBAIC0zMzUsOCArMjk1LDYgQEAgc3RhdGljIGlycXJldHVybl90 IHhlbl90aW1lcl9pbnRlcnJ1cHQoaW50IGlycSwgdm9pZCAqZGV2X2lkKQo+ID4gIAkJcmV0ID0g SVJRX0hBTkRMRUQ7Cj4gPiAgCX0KPiA+ICAKPiA+IC0JZG9fc3RvbGVuX2FjY291bnRpbmcoKTsK PiA+IC0KPiA+ICAJcmV0dXJuIHJldDsKPiA+ICB9Cj4gPiAgCj4gPiBAQCAtNDMxLDYgKzM4OSw4 IEBAIHN0YXRpYyB2b2lkIF9faW5pdCB4ZW5fdGltZV9pbml0KHZvaWQpCj4gPiAgCXhlbl9zZXR1 cF90aW1lcihjcHUpOwo+ID4gIAl4ZW5fc2V0dXBfY3B1X2Nsb2NrZXZlbnRzKCk7Cj4gPiAgCj4g PiArCXhlbl90aW1lX3NldHVwX2d1ZXN0KCk7Cj4gPiArCj4gPiAgCWlmICh4ZW5faW5pdGlhbF9k b21haW4oKSkKPiA+ICAJCXB2Y2xvY2tfZ3RvZF9yZWdpc3Rlcl9ub3RpZmllcigmeGVuX3B2Y2xv Y2tfZ3RvZF9ub3RpZmllcik7Cj4gPiAgfQo+ID4gZGlmZiAtLWdpdCBhL2RyaXZlcnMveGVuL3Rp bWUuYyBiL2RyaXZlcnMveGVuL3RpbWUuYwo+ID4gaW5kZXggNzEwNzg0Mi4uMjI1N2I2NiAxMDA2 NDQKPiA+IC0tLSBhL2RyaXZlcnMveGVuL3RpbWUuYwo+ID4gKysrIGIvZHJpdmVycy94ZW4vdGlt ZS5jCj4gPiBAQCAtNiw2ICs2LDcgQEAKPiA+ICAjaW5jbHVkZSA8bGludXgvbWF0aDY0Lmg+Cj4g PiAgI2luY2x1ZGUgPGxpbnV4L2dmcC5oPgo+ID4gIAo+ID4gKyNpbmNsdWRlIDxhc20vcGFyYXZp cnQuaD4KPiA+ICAjaW5jbHVkZSA8YXNtL3hlbi9oeXBlcnZpc29yLmg+Cj4gPiAgI2luY2x1ZGUg PGFzbS94ZW4vaHlwZXJjYWxsLmg+Cj4gPiAgCj4gPiBAQCAtNzUsNiArNzYsMTUgQEAgYm9vbCB4 ZW5fdmNwdV9zdG9sZW4oaW50IHZjcHUpCj4gPiAgCXJldHVybiBwZXJfY3B1KHhlbl9ydW5zdGF0 ZSwgdmNwdSkuc3RhdGUgPT0gUlVOU1RBVEVfcnVubmFibGU7Cj4gPiAgfQo+ID4gIAo+ID4gK3N0 YXRpYyB1NjQgeGVuX3N0ZWFsX2Nsb2NrKGludCBjcHUpCj4gPiArewo+ID4gKwlzdHJ1Y3QgdmNw dV9ydW5zdGF0ZV9pbmZvIHN0YXRlOwo+ID4gKwo+ID4gKwlCVUdfT04oY3B1ICE9IHNtcF9wcm9j ZXNzb3JfaWQoKSk7Cj4gPiArCXhlbl9nZXRfcnVuc3RhdGVfc25hcHNob3QoJnN0YXRlKTsKPiA+ ICsJcmV0dXJuIHN0YXRlLnRpbWVbUlVOU1RBVEVfcnVubmFibGVdICsgc3RhdGUudGltZVtSVU5T VEFURV9vZmZsaW5lXTsKPiA+ICt9Cj4gPiArCj4gPiAgdm9pZCB4ZW5fc2V0dXBfcnVuc3RhdGVf aW5mbyhpbnQgY3B1KQo+ID4gIHsKPiA+ICAJc3RydWN0IHZjcHVfcmVnaXN0ZXJfcnVuc3RhdGVf bWVtb3J5X2FyZWEgYXJlYTsKPiA+IEBAIC04NiwzICs5NiwxMyBAQCB2b2lkIHhlbl9zZXR1cF9y dW5zdGF0ZV9pbmZvKGludCBjcHUpCj4gPiAgCQlCVUcoKTsKPiA+ICB9Cj4gPiAgCj4gPiArdm9p ZCBfX2luaXQgeGVuX3RpbWVfc2V0dXBfZ3Vlc3Qodm9pZCkKPiA+ICt7Cj4gPiArCXB2X3RpbWVf b3BzLnN0ZWFsX2Nsb2NrID0geGVuX3N0ZWFsX2Nsb2NrOwo+ID4gKwo+ID4gKwlzdGF0aWNfa2V5 X3Nsb3dfaW5jKCZwYXJhdmlydF9zdGVhbF9lbmFibGVkKTsKPiA+ICsJLyoKPiA+ICsJICogV2Ug Y2FuJ3Qgc2V0IHBhcmF2aXJ0X3N0ZWFsX3JxX2VuYWJsZWQgYXMgdGhpcyB3b3VsZCByZXF1aXJl IHRoZQo+ID4gKwkgKiBjYXBhYmlsaXR5IHRvIHJlYWQgYW5vdGhlciBjcHUncyBydW5zdGF0ZSBp bmZvLgo+ID4gKwkgKi8KPiA+ICt9Cj4gPiBkaWZmIC0tZ2l0IGEvaW5jbHVkZS9saW51eC9rZXJu ZWxfc3RhdC5oIGIvaW5jbHVkZS9saW51eC9rZXJuZWxfc3RhdC5oCj4gPiBpbmRleCAyNWE4MjJm Li40NGZkYTY0IDEwMDY0NAo+ID4gLS0tIGEvaW5jbHVkZS9saW51eC9rZXJuZWxfc3RhdC5oCj4g PiArKysgYi9pbmNsdWRlL2xpbnV4L2tlcm5lbF9zdGF0LmgKPiA+IEBAIC05Miw3ICs5Miw2IEBA IHN0YXRpYyBpbmxpbmUgdm9pZCBhY2NvdW50X3Byb2Nlc3NfdGljayhzdHJ1Y3QgdGFza19zdHJ1 Y3QgKnRzaywgaW50IHVzZXIpCj4gPiAgZXh0ZXJuIHZvaWQgYWNjb3VudF9wcm9jZXNzX3RpY2so c3RydWN0IHRhc2tfc3RydWN0ICosIGludCB1c2VyKTsKPiA+ICAjZW5kaWYKPiA+ICAKPiA+IC1l eHRlcm4gdm9pZCBhY2NvdW50X3N0ZWFsX3RpY2tzKHVuc2lnbmVkIGxvbmcgdGlja3MpOwo+ID4g IGV4dGVybiB2b2lkIGFjY291bnRfaWRsZV90aWNrcyh1bnNpZ25lZCBsb25nIHRpY2tzKTsKPiA+ ICAKPiA+ICAjZW5kaWYgLyogX0xJTlVYX0tFUk5FTF9TVEFUX0ggKi8KPiA+IGRpZmYgLS1naXQg YS9pbmNsdWRlL3hlbi94ZW4tb3BzLmggYi9pbmNsdWRlL3hlbi94ZW4tb3BzLmgKPiA+IGluZGV4 IDg2YWJlMDcuLjVjZTUxYzIgMTAwNjQ0Cj4gPiAtLS0gYS9pbmNsdWRlL3hlbi94ZW4tb3BzLmgK PiA+ICsrKyBiL2luY2x1ZGUveGVuL3hlbi1vcHMuaAo+ID4gQEAgLTIxLDYgKzIxLDcgQEAgdm9p ZCB4ZW5fcmVzdW1lX25vdGlmaWVyX3VucmVnaXN0ZXIoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpu Yik7Cj4gPiAgCj4gPiAgYm9vbCB4ZW5fdmNwdV9zdG9sZW4oaW50IHZjcHUpOwo+ID4gIHZvaWQg eGVuX3NldHVwX3J1bnN0YXRlX2luZm8oaW50IGNwdSk7Cj4gPiArdm9pZCBfX2luaXQgeGVuX3Rp bWVfc2V0dXBfZ3Vlc3Qodm9pZCk7Cj4gCj4gcGxlYXNlIGF2b2lkIF9faW5pdCBpbiBoZWFkZXJz Cj4gCj4gCj4gPiAgdm9pZCB4ZW5fZ2V0X3J1bnN0YXRlX3NuYXBzaG90KHN0cnVjdCB2Y3B1X3J1 bnN0YXRlX2luZm8gKnJlcyk7Cj4gPiAgCj4gPiAgaW50IHhlbl9zZXR1cF9zaHV0ZG93bl9ldmVu dCh2b2lkKTsKPiA+IGRpZmYgLS1naXQgYS9rZXJuZWwvc2NoZWQvY3B1dGltZS5jIGIva2VybmVs L3NjaGVkL2NwdXRpbWUuYwo+ID4gaW5kZXggNzVmOThjNS4uOGM0YzZkYyAxMDA2NDQKPiA+IC0t LSBhL2tlcm5lbC9zY2hlZC9jcHV0aW1lLmMKPiA+ICsrKyBiL2tlcm5lbC9zY2hlZC9jcHV0aW1l LmMKPiA+IEBAIC00OTAsMTYgKzQ5MCw2IEBAIHZvaWQgYWNjb3VudF9wcm9jZXNzX3RpY2soc3Ry dWN0IHRhc2tfc3RydWN0ICpwLCBpbnQgdXNlcl90aWNrKQo+ID4gIH0KPiA+ICAKPiA+ICAvKgo+ ID4gLSAqIEFjY291bnQgbXVsdGlwbGUgdGlja3Mgb2Ygc3RlYWwgdGltZS4KPiA+IC0gKiBAcDog dGhlIHByb2Nlc3MgZnJvbSB3aGljaCB0aGUgY3B1IHRpbWUgaGFzIGJlZW4gc3RvbGVuCj4gPiAt ICogQHRpY2tzOiBudW1iZXIgb2Ygc3RvbGVuIHRpY2tzCj4gPiAtICovCj4gPiAtdm9pZCBhY2Nv dW50X3N0ZWFsX3RpY2tzKHVuc2lnbmVkIGxvbmcgdGlja3MpCj4gPiAtewo+ID4gLQlhY2NvdW50 X3N0ZWFsX3RpbWUoamlmZmllc190b19jcHV0aW1lKHRpY2tzKSk7Cj4gPiAtfQo+ID4gLQo+ID4g LS8qCj4gPiAgICogQWNjb3VudCBtdWx0aXBsZSB0aWNrcyBvZiBpZGxlIHRpbWUuCj4gPiAgICog QHRpY2tzOiBudW1iZXIgb2Ygc3RvbGVuIHRpY2tzCj4gPiAgICovCj4gPiAtLSAKPiA+IDIuNi42 Cj4gPiAKPiAKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f Clhlbi1kZXZlbCBtYWlsaW5nIGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbi5vcmcKaHR0cDovL2xp c3RzLnhlbi5vcmcveGVuLWRldmVsCg==