From: Dan Magenheimer Subject: [RFC] [PATCH] use "reliable" tsc properly when available, but verify Date: Mon, 28 Sep 2009 13:19:03 -0700 (PDT) Message-ID: <2dfff4cc-866b-406f-b964-5ec95714a2d7@default> Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="__12541691572183275abhmt001.oracle.com" Return-path: List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Sender: xen-devel-bounces@lists.xensource.com Errors-To: xen-devel-bounces@lists.xensource.com To: "Xen-Devel (E-mail)" List-Id: xen-devel@lists.xenproject.org --__12541691572183275abhmt001.oracle.com Content-Type: text/plain; charset=us-ascii Content-Transfer-Encoding: quoted-printable (This is compile-tested only. Review requested especially where marked with FIXME. Also, code that does write_tsc in smpboot.c may also need patching. And Linux does a touch_nmi_watchdog()... does Xen need to do anything similar?) Most modern Intel and AMD processors and servers have fully synchronized, non-stop TSCs that don't even stop in C3 state. Recent upstream Linux kernels test a cpuid bit and record this capability as X86_FEATURE_TSC_RELIABLE. According to Intel, all recent Intel processors AND the systems built on them have this property. According to AMD, many recent AMD processors (and all recent server processors) have this property but apparently some of the systems built on them do not. So we trust but verify... if the cpuid bit is set we assume a reliable tsc, but use the Linux boottime check_tsc_warp algorithm to periodically verify that the tsc hasn't skewed. If it has, we fall back to Xen managing (and periodically writing) the TSC. The check_tsc_warp algorithm is CPU-intensive, so we test it on a decaying schedule, at 1sec, 2sec, 4sec, 8sec, 16sec, 32sec, etc. Also correct mis-spelling of NOSTOP to NONSTOP to match the Linux spelling. Signed-off-by: Dan Magenheimer diff -r 1e33261a814f xen/arch/x86/Makefile --- a/xen/arch/x86/Makefile=09Mon Sep 28 13:59:35 2009 +0100 +++ b/xen/arch/x86/Makefile=09Mon Sep 28 13:26:11 2009 -0600 @@ -45,6 +45,7 @@ obj-y +=3D string.o obj-y +=3D string.o obj-y +=3D sysctl.o obj-y +=3D time.o +obj-y +=3D tsc_sync.o obj-y +=3D trace.o obj-y +=3D traps.o obj-y +=3D usercopy.o diff -r 1e33261a814f xen/arch/x86/cpu/amd.c --- a/xen/arch/x86/cpu/amd.c=09Mon Sep 28 13:59:35 2009 +0100 +++ b/xen/arch/x86/cpu/amd.c=09Mon Sep 28 13:26:11 2009 -0600 @@ -463,7 +463,9 @@ static void __devinit init_amd(struct cp =09=09c->x86_power =3D cpuid_edx(0x80000007); =09=09if (c->x86_power & (1<<8)) { =09=09=09set_bit(X86_FEATURE_CONSTANT_TSC, c->x86_capability); -=09=09=09set_bit(X86_FEATURE_NOSTOP_TSC, c->x86_capability); +=09=09=09set_bit(X86_FEATURE_NONSTOP_TSC, c->x86_capability); + if ( c->x86 !=3D 0x11 ) +=09=09=09 set_bit(X86_FEATURE_TSC_RELIABLE, c->x86_capability); =09=09} =09} =20 diff -r 1e33261a814f xen/arch/x86/cpu/intel.c --- a/xen/arch/x86/cpu/intel.c=09Mon Sep 28 13:59:35 2009 +0100 +++ b/xen/arch/x86/cpu/intel.c=09Mon Sep 28 13:26:11 2009 -0600 @@ -226,7 +226,8 @@ static void __devinit init_intel(struct=20 =09=09set_bit(X86_FEATURE_CONSTANT_TSC, c->x86_capability); =09if (cpuid_edx(0x80000007) & (1u<<8)) { =09=09set_bit(X86_FEATURE_CONSTANT_TSC, c->x86_capability); -=09=09set_bit(X86_FEATURE_NOSTOP_TSC, c->x86_capability); +=09=09set_bit(X86_FEATURE_NONSTOP_TSC, c->x86_capability); +=09=09set_bit(X86_FEATURE_TSC_RELIABLE, c->x86_capability); =09} =09if ((c->cpuid_level >=3D 0x00000006) && =09 (cpuid_eax(0x00000006) & (1u<<2))) diff -r 1e33261a814f xen/arch/x86/time.c --- a/xen/arch/x86/time.c=09Mon Sep 28 13:59:35 2009 +0100 +++ b/xen/arch/x86/time.c=09Mon Sep 28 13:26:11 2009 -0600 @@ -698,7 +698,7 @@ void cstate_restore_tsc(void) s_time_t stime_delta; u64 new_tsc; =20 - if ( boot_cpu_has(X86_FEATURE_NOSTOP_TSC) ) + if ( boot_cpu_has(X86_FEATURE_NONSTOP_TSC) ) return; =20 stime_delta =3D read_platform_stime() - t->stime_master_stamp; @@ -1100,6 +1100,11 @@ struct calibration_rendezvous { u64 master_tsc_stamp; }; =20 +static void (*rendezvous_func) (void *info); +static int tsc_reliable =3D 0; +static unsigned long tsc_max_warp =3D 0; +static unsigned long tsc_verify_decay =3D 0; + static void time_calibration_tsc_rendezvous(void *_r) { int i; @@ -1180,6 +1185,50 @@ static void time_calibration_std_rendezv raise_softirq(TIME_CALIBRATE_SOFTIRQ); } =20 +static void time_verify_tsc_calibration_rendezvous(void *_r) +{ + struct cpu_calibration *c =3D &this_cpu(cpu_calibration); + struct calibration_rendezvous *r =3D _r; + unsigned int total_cpus =3D cpus_weight(r->cpu_calibration_map); + + /* check_tsc_warp is VERY expensive so test only on log2 intervals */ + tsc_verify_decay++; + if ( !(tsc_verify_decay & (tsc_verify_decay-1)) ) + { + if ( smp_processor_id() =3D=3D 0 ) + { + while ( atomic_read(&r->semaphore) !=3D (total_cpus - 1) ) + mb(); + check_tsc_warp(cpu_khz, &tsc_max_warp); + atomic_inc(&r->semaphore); + } + else + { + atomic_inc(&r->semaphore); + while ( atomic_read(&r->semaphore) < total_cpus ) + mb(); + check_tsc_warp(cpu_khz, &tsc_max_warp); + atomic_inc(&r->semaphore); + while ( atomic_read(&r->semaphore) > total_cpus ) + mb(); + } + } + + if ( tsc_max_warp && smp_processor_id() =3D=3D 0 ) + { + printk("TSC warp detected (%lu cycles), disabling reliable TSC\n", + tsc_max_warp); + tsc_reliable =3D -1; + rendezvous_func =3D time_calibration_tsc_rendezvous; + } + + rdtscll(c->local_tsc_stamp); + c->stime_local_stamp =3D get_s_time(); + c->stime_master_stamp =3D r->master_stime; + + raise_softirq(TIME_CALIBRATE_SOFTIRQ); +} + static void time_calibration(void *unused) { struct calibration_rendezvous r =3D { @@ -1188,11 +1237,7 @@ static void time_calibration(void *unuse }; =20 /* @wait=3D1 because we must wait for all cpus before freeing @r. */ - on_selected_cpus(&r.cpu_calibration_map, - opt_consistent_tscs - ? time_calibration_tsc_rendezvous - : time_calibration_std_rendezvous, - &r, 1); + on_selected_cpus(&r.cpu_calibration_map, rendezvous_func, &r, 1); } =20 void init_percpu_time(void) @@ -1219,16 +1264,19 @@ void init_percpu_time(void) /* Late init function (after all CPUs are booted). */ int __init init_xen_time(void) { - if ( !boot_cpu_has(X86_FEATURE_CONSTANT_TSC) ) - opt_consistent_tscs =3D 0; - - /* If we have constant TSCs then scale factor can be shared. */ - if ( opt_consistent_tscs ) + /* If we have reliable TSCs then scale factor can be shared. */ + if ( boot_cpu_has(X86_FEATURE_TSC_RELIABLE) ) { int cpu; for_each_possible_cpu ( cpu ) per_cpu(cpu_time, cpu).tsc_scale =3D per_cpu(cpu_time, 0).tsc_= scale; + rendezvous_func =3D time_verify_tsc_calibration_rendezvous; + tsc_reliable =3D 1; } + else if ( boot_cpu_has(X86_FEATURE_CONSTANT_TSC) ) + rendezvous_func =3D time_calibration_tsc_rendezvous; + else + rendezvous_func =3D time_calibration_std_rendezvous; =20 open_softirq(TIME_CALIBRATE_SOFTIRQ, local_time_calibration); =20 @@ -1463,6 +1511,13 @@ static void dump_softtsc(unsigned char k struct domain *d; int domcnt =3D 0; =20 + if ( tsc_reliable > 0 ) + printk("TSC is reliable\n"); + else if ( tsc_reliable < 0 ) + printk("Hardware determined TSC reliable, verification failed with= " + "warp =3D %lu cycles\n", tsc_max_warp); + else + printk("TSC is not reliable\n"); for_each_domain ( d ) { if ( !d->arch.vtsc ) diff -r 1e33261a814f xen/arch/x86/tsc_sync.c --- /dev/null=09Thu Jan 01 00:00:00 1970 +0000 +++ b/xen/arch/x86/tsc_sync.c=09Mon Sep 28 13:26:11 2009 -0600 @@ -0,0 +1,93 @@ +/* + * check TSC synchronization. + * + * Copyright (C) 2006, Red Hat, Inc., Ingo Molnar + * Modified for Xen by Dan Magenheimer, Oracle Corp. + * + * We check whether all boot CPUs have their TSC's synchronized, + * print a warning if not and turn off the TSC clock-source. + * + * The warp-check is point-to-point between two CPUs, the CPU + * initiating the bootup is the 'source CPU', the freshly booting + * CPU is the 'target CPU'. + * + * Only two CPUs may participate - they can enter in any order. + * ( The serial nature of the boot logic and the CPU hotplug lock + * protects against more than 2 CPUs entering this code. ) + */ +#include +#include +#include +#include + +/* FIXME Are these OK for Xen? Xen has no _raw_spin_lock() */ +#define rdtsc_barrier mb +#define raw_spinlock_t spinlock_t +#define __raw_spin_lock spin_lock +#define __raw_spin_unlock spin_unlock +#define __RAW_SPIN_LOCK_UNLOCKED SPIN_LOCK_UNLOCKED + +/* + * We use a raw spinlock in this exceptional case, because + * we want to have the fastest, inlined, non-debug version + * of a critical section, to be able to prove TSC time-warps: + */ +static __cpuinitdata raw_spinlock_t sync_lock =3D __RAW_SPIN_LOCK_UNLOCKED= ; + +static __cpuinitdata cycles_t last_tsc; + +/* + * TSC-warp measurement loop running on both CPUs: + */ +void check_tsc_warp(unsigned long tsc_khz, unsigned long *max_warp) +{ +=09cycles_t start, now, prev, end; +=09int i; + +=09rdtsc_barrier(); +=09start =3D get_cycles(); +=09rdtsc_barrier(); +=09/* +=09 * The measurement runs for 2 msecs: +=09 */ +=09end =3D start + tsc_khz * 2ULL; +=09now =3D start; + +=09for (i =3D 0; ; i++) { +=09=09/* +=09=09 * We take the global lock, measure TSC, save the +=09=09 * previous TSC that was measured (possibly on +=09=09 * another CPU) and update the previous TSC timestamp. +=09=09 */ +=09=09__raw_spin_lock(&sync_lock); +=09=09prev =3D last_tsc; +=09=09rdtsc_barrier(); +=09=09now =3D get_cycles(); +=09=09rdtsc_barrier(); +=09=09last_tsc =3D now; +=09=09__raw_spin_unlock(&sync_lock); + +=09=09/* +=09=09 * Be nice every now and then (and also check whether +=09=09 * measurement is done [we also insert a 10 million +=09=09 * loops safety exit, so we dont lock up in case the +=09=09 * TSC readout is totally broken]): +=09=09 */ +=09=09if (unlikely(!(i & 7))) { +=09=09=09if (now > end || i > 10000000) +=09=09=09=09break; +=09=09=09cpu_relax(); +=09=09=09/*touch_nmi_watchdog();*/ +=09=09} +=09=09/* +=09=09 * Outside the critical section we can now see whether +=09=09 * we saw a time-warp of the TSC going backwards: +=09=09 */ +=09=09if (unlikely(prev > now)) { +=09=09=09__raw_spin_lock(&sync_lock); +=09=09=09if ( *max_warp > prev - now ) +=09=09=09=09*max_warp =3D prev - now; +=09=09=09__raw_spin_unlock(&sync_lock); +=09=09} +=09} +} diff -r 1e33261a814f xen/include/asm-x86/cpufeature.h --- a/xen/include/asm-x86/cpufeature.h=09Mon Sep 28 13:59:35 2009 +0100 +++ b/xen/include/asm-x86/cpufeature.h=09Mon Sep 28 13:26:11 2009 -0600 @@ -74,9 +74,10 @@ #define X86_FEATURE_P3=09=09(3*32+ 6) /* P3 */ #define X86_FEATURE_P4=09=09(3*32+ 7) /* P4 */ #define X86_FEATURE_CONSTANT_TSC (3*32+ 8) /* TSC ticks at a constant rate= */ -#define X86_FEATURE_NOSTOP_TSC=09(3*32+ 9) /* TSC does not stop in C state= s */ +#define X86_FEATURE_NONSTOP_TSC=09(3*32+ 9) /* TSC does not stop in C stat= es */ #define X86_FEATURE_ARAT=09(3*32+ 10) /* Always running APIC timer */ #define X86_FEATURE_ARCH_PERFMON (3*32+11) /* Intel Architectural PerfMon = */ +#define X86_FEATURE_TSC_RELIABLE (3*32+12) /* TSC is known to be reliable = */ =20 /* Intel-defined CPU features, CPUID level 0x00000001 (ecx), word 4 */ #define X86_FEATURE_XMM3=09(4*32+ 0) /* Streaming SIMD Extensions-3 */ diff -r 1e33261a814f xen/include/asm-x86/time.h --- a/xen/include/asm-x86/time.h=09Mon Sep 28 13:59:35 2009 +0100 +++ b/xen/include/asm-x86/time.h=09Mon Sep 28 13:26:11 2009 -0600 @@ -43,4 +43,6 @@ uint64_t ns_to_acpi_pm_tick(uint64_t ns) =20 void pv_soft_rdtsc(struct vcpu *v, struct cpu_user_regs *regs); =20 +void check_tsc_warp(unsigned long tsc_khz, unsigned long *max_warp); + #endif /* __X86_TIME_H__ */ --__12541691572183275abhmt001.oracle.com Content-Type: application/octet-stream; name="tsc-reliable.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="tsc-reliable.patch" ZGlmZiAtciAxZTMzMjYxYTgxNGYgeGVuL2FyY2gveDg2L01ha2VmaWxlCi0tLSBhL3hlbi9hcmNo L3g4Ni9NYWtlZmlsZQlNb24gU2VwIDI4IDEzOjU5OjM1IDIwMDkgKzAxMDAKKysrIGIveGVuL2Fy Y2gveDg2L01ha2VmaWxlCU1vbiBTZXAgMjggMTM6MjY6MTEgMjAwOSAtMDYwMApAQCAtNDUsNiAr NDUsNyBAQCBvYmoteSArPSBzdHJpbmcubwogb2JqLXkgKz0gc3RyaW5nLm8KIG9iai15ICs9IHN5 c2N0bC5vCiBvYmoteSArPSB0aW1lLm8KK29iai15ICs9IHRzY19zeW5jLm8KIG9iai15ICs9IHRy YWNlLm8KIG9iai15ICs9IHRyYXBzLm8KIG9iai15ICs9IHVzZXJjb3B5Lm8KZGlmZiAtciAxZTMz MjYxYTgxNGYgeGVuL2FyY2gveDg2L2NwdS9hbWQuYwotLS0gYS94ZW4vYXJjaC94ODYvY3B1L2Ft ZC5jCU1vbiBTZXAgMjggMTM6NTk6MzUgMjAwOSArMDEwMAorKysgYi94ZW4vYXJjaC94ODYvY3B1 L2FtZC5jCU1vbiBTZXAgMjggMTM6MjY6MTEgMjAwOSAtMDYwMApAQCAtNDYzLDcgKzQ2Myw5IEBA IHN0YXRpYyB2b2lkIF9fZGV2aW5pdCBpbml0X2FtZChzdHJ1Y3QgY3AKIAkJYy0+eDg2X3Bvd2Vy ID0gY3B1aWRfZWR4KDB4ODAwMDAwMDcpOwogCQlpZiAoYy0+eDg2X3Bvd2VyICYgKDE8PDgpKSB7 CiAJCQlzZXRfYml0KFg4Nl9GRUFUVVJFX0NPTlNUQU5UX1RTQywgYy0+eDg2X2NhcGFiaWxpdHkp OwotCQkJc2V0X2JpdChYODZfRkVBVFVSRV9OT1NUT1BfVFNDLCBjLT54ODZfY2FwYWJpbGl0eSk7 CisJCQlzZXRfYml0KFg4Nl9GRUFUVVJFX05PTlNUT1BfVFNDLCBjLT54ODZfY2FwYWJpbGl0eSk7 CisgICAgICAgICAgICAgICAgICAgICAgICBpZiAoIGMtPng4NiAhPSAweDExICkKKwkJCSAgICBz ZXRfYml0KFg4Nl9GRUFUVVJFX1RTQ19SRUxJQUJMRSwgYy0+eDg2X2NhcGFiaWxpdHkpOwogCQl9 CiAJfQogCmRpZmYgLXIgMWUzMzI2MWE4MTRmIHhlbi9hcmNoL3g4Ni9jcHUvaW50ZWwuYwotLS0g YS94ZW4vYXJjaC94ODYvY3B1L2ludGVsLmMJTW9uIFNlcCAyOCAxMzo1OTozNSAyMDA5ICswMTAw CisrKyBiL3hlbi9hcmNoL3g4Ni9jcHUvaW50ZWwuYwlNb24gU2VwIDI4IDEzOjI2OjExIDIwMDkg LTA2MDAKQEAgLTIyNiw3ICsyMjYsOCBAQCBzdGF0aWMgdm9pZCBfX2RldmluaXQgaW5pdF9pbnRl bChzdHJ1Y3QgCiAJCXNldF9iaXQoWDg2X0ZFQVRVUkVfQ09OU1RBTlRfVFNDLCBjLT54ODZfY2Fw YWJpbGl0eSk7CiAJaWYgKGNwdWlkX2VkeCgweDgwMDAwMDA3KSAmICgxdTw8OCkpIHsKIAkJc2V0 X2JpdChYODZfRkVBVFVSRV9DT05TVEFOVF9UU0MsIGMtPng4Nl9jYXBhYmlsaXR5KTsKLQkJc2V0 X2JpdChYODZfRkVBVFVSRV9OT1NUT1BfVFNDLCBjLT54ODZfY2FwYWJpbGl0eSk7CisJCXNldF9i aXQoWDg2X0ZFQVRVUkVfTk9OU1RPUF9UU0MsIGMtPng4Nl9jYXBhYmlsaXR5KTsKKwkJc2V0X2Jp dChYODZfRkVBVFVSRV9UU0NfUkVMSUFCTEUsIGMtPng4Nl9jYXBhYmlsaXR5KTsKIAl9CiAJaWYg KChjLT5jcHVpZF9sZXZlbCA+PSAweDAwMDAwMDA2KSAmJgogCSAgICAoY3B1aWRfZWF4KDB4MDAw MDAwMDYpICYgKDF1PDwyKSkpCmRpZmYgLXIgMWUzMzI2MWE4MTRmIHhlbi9hcmNoL3g4Ni90aW1l LmMKLS0tIGEveGVuL2FyY2gveDg2L3RpbWUuYwlNb24gU2VwIDI4IDEzOjU5OjM1IDIwMDkgKzAx MDAKKysrIGIveGVuL2FyY2gveDg2L3RpbWUuYwlNb24gU2VwIDI4IDEzOjI2OjExIDIwMDkgLTA2 MDAKQEAgLTY5OCw3ICs2OTgsNyBAQCB2b2lkIGNzdGF0ZV9yZXN0b3JlX3RzYyh2b2lkKQogICAg IHNfdGltZV90IHN0aW1lX2RlbHRhOwogICAgIHU2NCBuZXdfdHNjOwogCi0gICAgaWYgKCBib290 X2NwdV9oYXMoWDg2X0ZFQVRVUkVfTk9TVE9QX1RTQykgKQorICAgIGlmICggYm9vdF9jcHVfaGFz KFg4Nl9GRUFUVVJFX05PTlNUT1BfVFNDKSApCiAgICAgICAgIHJldHVybjsKIAogICAgIHN0aW1l X2RlbHRhID0gcmVhZF9wbGF0Zm9ybV9zdGltZSgpIC0gdC0+c3RpbWVfbWFzdGVyX3N0YW1wOwpA QCAtMTEwMCw2ICsxMTAwLDExIEBAIHN0cnVjdCBjYWxpYnJhdGlvbl9yZW5kZXp2b3VzIHsKICAg ICB1NjQgbWFzdGVyX3RzY19zdGFtcDsKIH07CiAKK3N0YXRpYyB2b2lkICgqcmVuZGV6dm91c19m dW5jKSAodm9pZCAqaW5mbyk7CitzdGF0aWMgaW50IHRzY19yZWxpYWJsZSA9IDA7CitzdGF0aWMg dW5zaWduZWQgbG9uZyB0c2NfbWF4X3dhcnAgPSAwOworc3RhdGljIHVuc2lnbmVkIGxvbmcgdHNj X3ZlcmlmeV9kZWNheSA9IDA7CisKIHN0YXRpYyB2b2lkIHRpbWVfY2FsaWJyYXRpb25fdHNjX3Jl bmRlenZvdXModm9pZCAqX3IpCiB7CiAgICAgaW50IGk7CkBAIC0xMTgwLDYgKzExODUsNTAgQEAg c3RhdGljIHZvaWQgdGltZV9jYWxpYnJhdGlvbl9zdGRfcmVuZGV6dgogICAgIHJhaXNlX3NvZnRp cnEoVElNRV9DQUxJQlJBVEVfU09GVElSUSk7CiB9CiAKK3N0YXRpYyB2b2lkIHRpbWVfdmVyaWZ5 X3RzY19jYWxpYnJhdGlvbl9yZW5kZXp2b3VzKHZvaWQgKl9yKQoreworICAgIHN0cnVjdCBjcHVf Y2FsaWJyYXRpb24gKmMgPSAmdGhpc19jcHUoY3B1X2NhbGlicmF0aW9uKTsKKyAgICBzdHJ1Y3Qg Y2FsaWJyYXRpb25fcmVuZGV6dm91cyAqciA9IF9yOworICAgIHVuc2lnbmVkIGludCB0b3RhbF9j cHVzID0gY3B1c193ZWlnaHQoci0+Y3B1X2NhbGlicmF0aW9uX21hcCk7CisKKyAgICAvKiBjaGVj a190c2Nfd2FycCBpcyBWRVJZIGV4cGVuc2l2ZSBzbyB0ZXN0IG9ubHkgb24gbG9nMiBpbnRlcnZh bHMgKi8KKyAgICB0c2NfdmVyaWZ5X2RlY2F5Kys7CisgICAgaWYgKCAhKHRzY192ZXJpZnlfZGVj YXkgJiAodHNjX3ZlcmlmeV9kZWNheS0xKSkgKQorICAgIHsKKyAgICAgICAgaWYgKCBzbXBfcHJv Y2Vzc29yX2lkKCkgPT0gMCApCisgICAgICAgIHsKKyAgICAgICAgICAgIHdoaWxlICggYXRvbWlj X3JlYWQoJnItPnNlbWFwaG9yZSkgIT0gKHRvdGFsX2NwdXMgLSAxKSApCisgICAgICAgICAgICAg ICAgbWIoKTsKKyAgICAgICAgICAgIGNoZWNrX3RzY193YXJwKGNwdV9raHosICZ0c2NfbWF4X3dh cnApOworICAgICAgICAgICAgYXRvbWljX2luYygmci0+c2VtYXBob3JlKTsKKyAgICAgICAgfQor ICAgICAgICBlbHNlCisgICAgICAgIHsKKyAgICAgICAgICAgIGF0b21pY19pbmMoJnItPnNlbWFw aG9yZSk7CisgICAgICAgICAgICB3aGlsZSAoIGF0b21pY19yZWFkKCZyLT5zZW1hcGhvcmUpIDwg dG90YWxfY3B1cyApCisgICAgICAgICAgICAgICAgbWIoKTsKKyAgICAgICAgICAgIGNoZWNrX3Rz Y193YXJwKGNwdV9raHosICZ0c2NfbWF4X3dhcnApOworICAgICAgICAgICAgYXRvbWljX2luYygm ci0+c2VtYXBob3JlKTsKKyAgICAgICAgICAgIHdoaWxlICggYXRvbWljX3JlYWQoJnItPnNlbWFw aG9yZSkgPiB0b3RhbF9jcHVzICkKKyAgICAgICAgICAgICAgICBtYigpOworICAgICAgICB9Cisg ICAgfQorCisgICAgaWYgKCB0c2NfbWF4X3dhcnAgJiYgc21wX3Byb2Nlc3Nvcl9pZCgpID09IDAg KQorICAgIHsKKyAgICAgICAgcHJpbnRrKCJUU0Mgd2FycCBkZXRlY3RlZCAoJWx1IGN5Y2xlcyks IGRpc2FibGluZyByZWxpYWJsZSBUU0NcbiIsCisgICAgICAgICAgICAgICAgdHNjX21heF93YXJw KTsKKyAgICAgICAgdHNjX3JlbGlhYmxlID0gLTE7CisgICAgICAgIHJlbmRlenZvdXNfZnVuYyA9 IHRpbWVfY2FsaWJyYXRpb25fdHNjX3JlbmRlenZvdXM7CisgICAgfQorCisgICAgcmR0c2NsbChj LT5sb2NhbF90c2Nfc3RhbXApOworICAgIGMtPnN0aW1lX2xvY2FsX3N0YW1wID0gZ2V0X3NfdGlt ZSgpOworICAgIGMtPnN0aW1lX21hc3Rlcl9zdGFtcCA9IHItPm1hc3Rlcl9zdGltZTsKKworICAg IHJhaXNlX3NvZnRpcnEoVElNRV9DQUxJQlJBVEVfU09GVElSUSk7Cit9CisKIHN0YXRpYyB2b2lk IHRpbWVfY2FsaWJyYXRpb24odm9pZCAqdW51c2VkKQogewogICAgIHN0cnVjdCBjYWxpYnJhdGlv bl9yZW5kZXp2b3VzIHIgPSB7CkBAIC0xMTg4LDExICsxMjM3LDcgQEAgc3RhdGljIHZvaWQgdGlt ZV9jYWxpYnJhdGlvbih2b2lkICp1bnVzZQogICAgIH07CiAKICAgICAvKiBAd2FpdD0xIGJlY2F1 c2Ugd2UgbXVzdCB3YWl0IGZvciBhbGwgY3B1cyBiZWZvcmUgZnJlZWluZyBAci4gKi8KLSAgICBv bl9zZWxlY3RlZF9jcHVzKCZyLmNwdV9jYWxpYnJhdGlvbl9tYXAsCi0gICAgICAgICAgICAgICAg ICAgICBvcHRfY29uc2lzdGVudF90c2NzCi0gICAgICAgICAgICAgICAgICAgICA/IHRpbWVfY2Fs aWJyYXRpb25fdHNjX3JlbmRlenZvdXMKLSAgICAgICAgICAgICAgICAgICAgIDogdGltZV9jYWxp YnJhdGlvbl9zdGRfcmVuZGV6dm91cywKLSAgICAgICAgICAgICAgICAgICAgICZyLCAxKTsKKyAg ICBvbl9zZWxlY3RlZF9jcHVzKCZyLmNwdV9jYWxpYnJhdGlvbl9tYXAsIHJlbmRlenZvdXNfZnVu YywgJnIsIDEpOwogfQogCiB2b2lkIGluaXRfcGVyY3B1X3RpbWUodm9pZCkKQEAgLTEyMTksMTYg KzEyNjQsMTkgQEAgdm9pZCBpbml0X3BlcmNwdV90aW1lKHZvaWQpCiAvKiBMYXRlIGluaXQgZnVu Y3Rpb24gKGFmdGVyIGFsbCBDUFVzIGFyZSBib290ZWQpLiAqLwogaW50IF9faW5pdCBpbml0X3hl bl90aW1lKHZvaWQpCiB7Ci0gICAgaWYgKCAhYm9vdF9jcHVfaGFzKFg4Nl9GRUFUVVJFX0NPTlNU QU5UX1RTQykgKQotICAgICAgICBvcHRfY29uc2lzdGVudF90c2NzID0gMDsKLQotICAgIC8qIElm IHdlIGhhdmUgY29uc3RhbnQgVFNDcyB0aGVuIHNjYWxlIGZhY3RvciBjYW4gYmUgc2hhcmVkLiAq LwotICAgIGlmICggb3B0X2NvbnNpc3RlbnRfdHNjcyApCisgICAgLyogSWYgd2UgaGF2ZSByZWxp YWJsZSBUU0NzIHRoZW4gc2NhbGUgZmFjdG9yIGNhbiBiZSBzaGFyZWQuICovCisgICAgaWYgKCBi b290X2NwdV9oYXMoWDg2X0ZFQVRVUkVfVFNDX1JFTElBQkxFKSApCiAgICAgewogICAgICAgICBp bnQgY3B1OwogICAgICAgICBmb3JfZWFjaF9wb3NzaWJsZV9jcHUgKCBjcHUgKQogICAgICAgICAg ICAgcGVyX2NwdShjcHVfdGltZSwgY3B1KS50c2Nfc2NhbGUgPSBwZXJfY3B1KGNwdV90aW1lLCAw KS50c2Nfc2NhbGU7CisgICAgICAgIHJlbmRlenZvdXNfZnVuYyA9IHRpbWVfdmVyaWZ5X3RzY19j YWxpYnJhdGlvbl9yZW5kZXp2b3VzOworICAgICAgICB0c2NfcmVsaWFibGUgPSAxOwogICAgIH0K KyAgICBlbHNlIGlmICggYm9vdF9jcHVfaGFzKFg4Nl9GRUFUVVJFX0NPTlNUQU5UX1RTQykgKQor ICAgICAgICByZW5kZXp2b3VzX2Z1bmMgPSB0aW1lX2NhbGlicmF0aW9uX3RzY19yZW5kZXp2b3Vz OworICAgIGVsc2UKKyAgICAgICAgcmVuZGV6dm91c19mdW5jID0gdGltZV9jYWxpYnJhdGlvbl9z dGRfcmVuZGV6dm91czsKIAogICAgIG9wZW5fc29mdGlycShUSU1FX0NBTElCUkFURV9TT0ZUSVJR LCBsb2NhbF90aW1lX2NhbGlicmF0aW9uKTsKIApAQCAtMTQ2Myw2ICsxNTExLDEzIEBAIHN0YXRp YyB2b2lkIGR1bXBfc29mdHRzYyh1bnNpZ25lZCBjaGFyIGsKICAgICBzdHJ1Y3QgZG9tYWluICpk OwogICAgIGludCBkb21jbnQgPSAwOwogCisgICAgaWYgKCB0c2NfcmVsaWFibGUgPiAwICkKKyAg ICAgICAgcHJpbnRrKCJUU0MgaXMgcmVsaWFibGVcbiIpOworICAgIGVsc2UgaWYgKCB0c2NfcmVs aWFibGUgPCAwICkKKyAgICAgICAgcHJpbnRrKCJIYXJkd2FyZSBkZXRlcm1pbmVkIFRTQyByZWxp YWJsZSwgdmVyaWZpY2F0aW9uIGZhaWxlZCB3aXRoICIKKyAgICAgICAgICAgICAgICJ3YXJwID0g JWx1IGN5Y2xlc1xuIiwgdHNjX21heF93YXJwKTsKKyAgICBlbHNlCisgICAgICAgIHByaW50aygi VFNDIGlzIG5vdCByZWxpYWJsZVxuIik7CiAgICAgZm9yX2VhY2hfZG9tYWluICggZCApCiAgICAg ewogICAgICAgICBpZiAoICFkLT5hcmNoLnZ0c2MgKQpkaWZmIC1yIDFlMzMyNjFhODE0ZiB4ZW4v YXJjaC94ODYvdHNjX3N5bmMuYwotLS0gL2Rldi9udWxsCVRodSBKYW4gMDEgMDA6MDA6MDAgMTk3 MCArMDAwMAorKysgYi94ZW4vYXJjaC94ODYvdHNjX3N5bmMuYwlNb24gU2VwIDI4IDEzOjI2OjEx IDIwMDkgLTA2MDAKQEAgLTAsMCArMSw5MyBAQAorLyoKKyAqIGNoZWNrIFRTQyBzeW5jaHJvbml6 YXRpb24uCisgKgorICogQ29weXJpZ2h0IChDKSAyMDA2LCBSZWQgSGF0LCBJbmMuLCBJbmdvIE1v bG5hcgorICogTW9kaWZpZWQgZm9yIFhlbiBieSBEYW4gTWFnZW5oZWltZXIsIE9yYWNsZSBDb3Jw LgorICoKKyAqIFdlIGNoZWNrIHdoZXRoZXIgYWxsIGJvb3QgQ1BVcyBoYXZlIHRoZWlyIFRTQydz IHN5bmNocm9uaXplZCwKKyAqIHByaW50IGEgd2FybmluZyBpZiBub3QgYW5kIHR1cm4gb2ZmIHRo ZSBUU0MgY2xvY2stc291cmNlLgorICoKKyAqIFRoZSB3YXJwLWNoZWNrIGlzIHBvaW50LXRvLXBv aW50IGJldHdlZW4gdHdvIENQVXMsIHRoZSBDUFUKKyAqIGluaXRpYXRpbmcgdGhlIGJvb3R1cCBp cyB0aGUgJ3NvdXJjZSBDUFUnLCB0aGUgZnJlc2hseSBib290aW5nCisgKiBDUFUgaXMgdGhlICd0 YXJnZXQgQ1BVJy4KKyAqCisgKiBPbmx5IHR3byBDUFVzIG1heSBwYXJ0aWNpcGF0ZSAtIHRoZXkg Y2FuIGVudGVyIGluIGFueSBvcmRlci4KKyAqICggVGhlIHNlcmlhbCBuYXR1cmUgb2YgdGhlIGJv b3QgbG9naWMgYW5kIHRoZSBDUFUgaG90cGx1ZyBsb2NrCisgKiAgIHByb3RlY3RzIGFnYWluc3Qg bW9yZSB0aGFuIDIgQ1BVcyBlbnRlcmluZyB0aGlzIGNvZGUuICkKKyAqLworI2luY2x1ZGUgPHhl bi9jb25maWcuaD4KKyNpbmNsdWRlIDx4ZW4vc3BpbmxvY2suaD4KKyNpbmNsdWRlIDxhc20vcHJv Y2Vzc29yLmg+CisjaW5jbHVkZSA8YXNtL3RpbWUuaD4KKworLyogRklYTUUgQXJlIHRoZXNlIE9L IGZvciBYZW4/IFhlbiBoYXMgbm8gX3Jhd19zcGluX2xvY2soKSAqLworI2RlZmluZSByZHRzY19i YXJyaWVyICBtYgorI2RlZmluZSByYXdfc3BpbmxvY2tfdCBzcGlubG9ja190CisjZGVmaW5lIF9f cmF3X3NwaW5fbG9jayBzcGluX2xvY2sKKyNkZWZpbmUgX19yYXdfc3Bpbl91bmxvY2sgc3Bpbl91 bmxvY2sKKyNkZWZpbmUgX19SQVdfU1BJTl9MT0NLX1VOTE9DS0VEICBTUElOX0xPQ0tfVU5MT0NL RUQKKworLyoKKyAqIFdlIHVzZSBhIHJhdyBzcGlubG9jayBpbiB0aGlzIGV4Y2VwdGlvbmFsIGNh c2UsIGJlY2F1c2UKKyAqIHdlIHdhbnQgdG8gaGF2ZSB0aGUgZmFzdGVzdCwgaW5saW5lZCwgbm9u LWRlYnVnIHZlcnNpb24KKyAqIG9mIGEgY3JpdGljYWwgc2VjdGlvbiwgdG8gYmUgYWJsZSB0byBw cm92ZSBUU0MgdGltZS13YXJwczoKKyAqLworc3RhdGljIF9fY3B1aW5pdGRhdGEgcmF3X3NwaW5s b2NrX3Qgc3luY19sb2NrID0gX19SQVdfU1BJTl9MT0NLX1VOTE9DS0VEOworCitzdGF0aWMgX19j cHVpbml0ZGF0YSBjeWNsZXNfdCBsYXN0X3RzYzsKKworLyoKKyAqIFRTQy13YXJwIG1lYXN1cmVt ZW50IGxvb3AgcnVubmluZyBvbiBib3RoIENQVXM6CisgKi8KK3ZvaWQgY2hlY2tfdHNjX3dhcnAo dW5zaWduZWQgbG9uZyB0c2Nfa2h6LCB1bnNpZ25lZCBsb25nICptYXhfd2FycCkKK3sKKwljeWNs ZXNfdCBzdGFydCwgbm93LCBwcmV2LCBlbmQ7CisJaW50IGk7CisKKwlyZHRzY19iYXJyaWVyKCk7 CisJc3RhcnQgPSBnZXRfY3ljbGVzKCk7CisJcmR0c2NfYmFycmllcigpOworCS8qCisJICogVGhl IG1lYXN1cmVtZW50IHJ1bnMgZm9yIDIgbXNlY3M6CisJICovCisJZW5kID0gc3RhcnQgKyB0c2Nf a2h6ICogMlVMTDsKKwlub3cgPSBzdGFydDsKKworCWZvciAoaSA9IDA7IDsgaSsrKSB7CisJCS8q CisJCSAqIFdlIHRha2UgdGhlIGdsb2JhbCBsb2NrLCBtZWFzdXJlIFRTQywgc2F2ZSB0aGUKKwkJ ICogcHJldmlvdXMgVFNDIHRoYXQgd2FzIG1lYXN1cmVkIChwb3NzaWJseSBvbgorCQkgKiBhbm90 aGVyIENQVSkgYW5kIHVwZGF0ZSB0aGUgcHJldmlvdXMgVFNDIHRpbWVzdGFtcC4KKwkJICovCisJ CV9fcmF3X3NwaW5fbG9jaygmc3luY19sb2NrKTsKKwkJcHJldiA9IGxhc3RfdHNjOworCQlyZHRz Y19iYXJyaWVyKCk7CisJCW5vdyA9IGdldF9jeWNsZXMoKTsKKwkJcmR0c2NfYmFycmllcigpOwor CQlsYXN0X3RzYyA9IG5vdzsKKwkJX19yYXdfc3Bpbl91bmxvY2soJnN5bmNfbG9jayk7CisKKwkJ LyoKKwkJICogQmUgbmljZSBldmVyeSBub3cgYW5kIHRoZW4gKGFuZCBhbHNvIGNoZWNrIHdoZXRo ZXIKKwkJICogbWVhc3VyZW1lbnQgaXMgZG9uZSBbd2UgYWxzbyBpbnNlcnQgYSAxMCBtaWxsaW9u CisJCSAqIGxvb3BzIHNhZmV0eSBleGl0LCBzbyB3ZSBkb250IGxvY2sgdXAgaW4gY2FzZSB0aGUK KwkJICogVFNDIHJlYWRvdXQgaXMgdG90YWxseSBicm9rZW5dKToKKwkJICovCisJCWlmICh1bmxp a2VseSghKGkgJiA3KSkpIHsKKwkJCWlmIChub3cgPiBlbmQgfHwgaSA+IDEwMDAwMDAwKQorCQkJ CWJyZWFrOworCQkJY3B1X3JlbGF4KCk7CisJCQkvKnRvdWNoX25taV93YXRjaGRvZygpOyovCisJ CX0KKwkJLyoKKwkJICogT3V0c2lkZSB0aGUgY3JpdGljYWwgc2VjdGlvbiB3ZSBjYW4gbm93IHNl ZSB3aGV0aGVyCisJCSAqIHdlIHNhdyBhIHRpbWUtd2FycCBvZiB0aGUgVFNDIGdvaW5nIGJhY2t3 YXJkczoKKwkJICovCisJCWlmICh1bmxpa2VseShwcmV2ID4gbm93KSkgeworCQkJX19yYXdfc3Bp bl9sb2NrKCZzeW5jX2xvY2spOworCQkJaWYgKCAqbWF4X3dhcnAgPiBwcmV2IC0gbm93ICkKKwkJ CQkqbWF4X3dhcnAgPSBwcmV2IC0gbm93OworCQkJX19yYXdfc3Bpbl91bmxvY2soJnN5bmNfbG9j ayk7CisJCX0KKwl9Cit9CmRpZmYgLXIgMWUzMzI2MWE4MTRmIHhlbi9pbmNsdWRlL2FzbS14ODYv Y3B1ZmVhdHVyZS5oCi0tLSBhL3hlbi9pbmNsdWRlL2FzbS14ODYvY3B1ZmVhdHVyZS5oCU1vbiBT ZXAgMjggMTM6NTk6MzUgMjAwOSArMDEwMAorKysgYi94ZW4vaW5jbHVkZS9hc20teDg2L2NwdWZl YXR1cmUuaAlNb24gU2VwIDI4IDEzOjI2OjExIDIwMDkgLTA2MDAKQEAgLTc0LDkgKzc0LDEwIEBA CiAjZGVmaW5lIFg4Nl9GRUFUVVJFX1AzCQkoMyozMisgNikgLyogUDMgKi8KICNkZWZpbmUgWDg2 X0ZFQVRVUkVfUDQJCSgzKjMyKyA3KSAvKiBQNCAqLwogI2RlZmluZSBYODZfRkVBVFVSRV9DT05T VEFOVF9UU0MgKDMqMzIrIDgpIC8qIFRTQyB0aWNrcyBhdCBhIGNvbnN0YW50IHJhdGUgKi8KLSNk ZWZpbmUgWDg2X0ZFQVRVUkVfTk9TVE9QX1RTQwkoMyozMisgOSkgLyogVFNDIGRvZXMgbm90IHN0 b3AgaW4gQyBzdGF0ZXMgKi8KKyNkZWZpbmUgWDg2X0ZFQVRVUkVfTk9OU1RPUF9UU0MJKDMqMzIr IDkpIC8qIFRTQyBkb2VzIG5vdCBzdG9wIGluIEMgc3RhdGVzICovCiAjZGVmaW5lIFg4Nl9GRUFU VVJFX0FSQVQJKDMqMzIrIDEwKSAvKiBBbHdheXMgcnVubmluZyBBUElDIHRpbWVyICovCiAjZGVm aW5lIFg4Nl9GRUFUVVJFX0FSQ0hfUEVSRk1PTiAoMyozMisxMSkgLyogSW50ZWwgQXJjaGl0ZWN0 dXJhbCBQZXJmTW9uICovCisjZGVmaW5lIFg4Nl9GRUFUVVJFX1RTQ19SRUxJQUJMRSAoMyozMisx MikgLyogVFNDIGlzIGtub3duIHRvIGJlIHJlbGlhYmxlICovCiAKIC8qIEludGVsLWRlZmluZWQg Q1BVIGZlYXR1cmVzLCBDUFVJRCBsZXZlbCAweDAwMDAwMDAxIChlY3gpLCB3b3JkIDQgKi8KICNk ZWZpbmUgWDg2X0ZFQVRVUkVfWE1NMwkoNCozMisgMCkgLyogU3RyZWFtaW5nIFNJTUQgRXh0ZW5z aW9ucy0zICovCmRpZmYgLXIgMWUzMzI2MWE4MTRmIHhlbi9pbmNsdWRlL2FzbS14ODYvdGltZS5o Ci0tLSBhL3hlbi9pbmNsdWRlL2FzbS14ODYvdGltZS5oCU1vbiBTZXAgMjggMTM6NTk6MzUgMjAw OSArMDEwMAorKysgYi94ZW4vaW5jbHVkZS9hc20teDg2L3RpbWUuaAlNb24gU2VwIDI4IDEzOjI2 OjExIDIwMDkgLTA2MDAKQEAgLTQzLDQgKzQzLDYgQEAgdWludDY0X3QgbnNfdG9fYWNwaV9wbV90 aWNrKHVpbnQ2NF90IG5zKQogCiB2b2lkIHB2X3NvZnRfcmR0c2Moc3RydWN0IHZjcHUgKnYsIHN0 cnVjdCBjcHVfdXNlcl9yZWdzICpyZWdzKTsKIAordm9pZCBjaGVja190c2Nfd2FycCh1bnNpZ25l ZCBsb25nIHRzY19raHosIHVuc2lnbmVkIGxvbmcgKm1heF93YXJwKTsKKwogI2VuZGlmIC8qIF9f WDg2X1RJTUVfSF9fICovCg== --__12541691572183275abhmt001.oracle.com Content-Type: text/plain; charset="us-ascii" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit Content-Disposition: inline _______________________________________________ Xen-devel mailing list Xen-devel@lists.xensource.com http://lists.xensource.com/xen-devel --__12541691572183275abhmt001.oracle.com--