From: Dan Magenheimer Subject: [PATCH] verify TSC sync Date: Fri, 18 Dec 2009 10:52:30 -0800 (PST) Message-ID: Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="__126116235313077491abhmt004.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)" , Keir Fraser Cc: Jeremy Fitzhardinge List-Id: xen-devel@lists.xenproject.org --__126116235313077491abhmt004.oracle.com Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Verify TSC sync even on systems with constant and non-stop TSC. We now reserve X86_FEATURE_TSC_RELIABLE for those systems that have been verified. For the record... Jeremy was right! (there, I said it ;-) See linux patch described here: http://patchwork.kernel.org/patch/68397/ (Note, the bulk of this patch is moving 100 lines within the same file to avoid forward references to warp check code.) Signed-off-by: Dan Magenheimer diff -r 1a911fd65e52 xen/arch/x86/cpu/amd.c --- a/xen/arch/x86/cpu/amd.c=09Fri Dec 18 07:53:27 2009 +0000 +++ b/xen/arch/x86/cpu/amd.c=09Fri Dec 18 11:40:25 2009 -0700 @@ -465,8 +465,6 @@ static void __devinit init_amd(struct cp =09=09if (c->x86_power & (1<<8)) { =09=09=09set_bit(X86_FEATURE_CONSTANT_TSC, c->x86_capability); =09=09=09set_bit(X86_FEATURE_NONSTOP_TSC, c->x86_capability); -=09=09=09if (c->x86 !=3D 0x11) -=09=09=09=09set_bit(X86_FEATURE_TSC_RELIABLE, c->x86_capability); =09=09} =09} =20 diff -r 1a911fd65e52 xen/arch/x86/cpu/intel.c --- a/xen/arch/x86/cpu/intel.c=09Fri Dec 18 07:53:27 2009 +0000 +++ b/xen/arch/x86/cpu/intel.c=09Fri Dec 18 11:40:25 2009 -0700 @@ -212,7 +212,6 @@ static void __devinit init_intel(struct=20 =09if (cpuid_edx(0x80000007) & (1u<<8)) { =09=09set_bit(X86_FEATURE_CONSTANT_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 1a911fd65e52 xen/arch/x86/time.c --- a/xen/arch/x86/time.c=09Fri Dec 18 07:53:27 2009 +0000 +++ b/xen/arch/x86/time.c=09Fri Dec 18 11:40:25 2009 -0700 @@ -1135,6 +1135,107 @@ static void local_time_calibration(void) } =20 /* + * TSC Reliability check + */ + +/* + * The Linux original version of this function is + * Copyright (c) 2006, Red Hat, Inc., Ingo Molnar + */ +void check_tsc_warp(unsigned long tsc_khz, unsigned long *max_warp) +{ +#define rdtsc_barrier() mb() + static DEFINE_SPINLOCK(sync_lock); + static cycles_t last_tsc; + + cycles_t start, now, prev, end; + int i; + + rdtsc_barrier(); + start =3D get_cycles(); + rdtsc_barrier(); + + /* The measurement runs for 20 msecs: */ + end =3D start + tsc_khz * 20ULL; + now =3D start; + + for ( i =3D 0; ; i++ ) + { + /* + * We take the global lock, measure TSC, save the + * previous TSC that was measured (possibly on + * another CPU) and update the previous TSC timestamp. + */ + spin_lock(&sync_lock); + prev =3D last_tsc; + rdtsc_barrier(); + now =3D get_cycles(); + rdtsc_barrier(); + last_tsc =3D now; + spin_unlock(&sync_lock); + + /* + * Be nice every now and then (and also check whether measurement = is=20 + * done [we also insert a 10 million loops safety exit, so we dont= =20 + * lock up in case the TSC readout is totally broken]): + */ + if ( unlikely(!(i & 7)) ) + { + if ( (now > end) || (i > 10000000) ) + break; + cpu_relax(); + /*touch_nmi_watchdog();*/ + } + + /* + * Outside the critical section we can now see whether we saw a=20 + * time-warp of the TSC going backwards: + */ + if ( unlikely(prev > now) ) + { + spin_lock(&sync_lock); + if ( *max_warp < prev - now ) + *max_warp =3D prev - now; + spin_unlock(&sync_lock); + } + } +} + +static unsigned long tsc_max_warp, tsc_check_count; +static cpumask_t tsc_check_cpumask =3D CPU_MASK_NONE; + +static void tsc_check_slave(void *unused) +{ + unsigned int cpu =3D smp_processor_id(); + local_irq_disable(); + while ( !cpu_isset(cpu, tsc_check_cpumask) ) + mb(); + check_tsc_warp(cpu_khz, &tsc_max_warp); + cpu_clear(cpu, tsc_check_cpumask); + local_irq_enable(); +} + +void tsc_check_reliability(void) +{ + unsigned int cpu =3D smp_processor_id(); + static DEFINE_SPINLOCK(lock); + + spin_lock(&lock); + + tsc_check_count++; + smp_call_function(tsc_check_slave, NULL, 0); + tsc_check_cpumask =3D cpu_online_map; + local_irq_disable(); + check_tsc_warp(cpu_khz, &tsc_max_warp); + cpu_clear(cpu, tsc_check_cpumask); + local_irq_enable(); + while ( !cpus_empty(tsc_check_cpumask) ) + cpu_relax(); + + spin_unlock(&lock); +} + +/* * Rendezvous for all CPUs in IRQ context. * Master CPU snapshots the platform timer. * All CPUS snapshot their local TSC and extrapolation of system time. @@ -1271,16 +1372,30 @@ void init_percpu_time(void) /* Late init function (after all CPUs are booted). */ int __init init_xen_time(void) { + extern unsigned int max_cstate; + /* If we have constant-rate TSCs then scale factor can be shared. */ if ( boot_cpu_has(X86_FEATURE_CONSTANT_TSC) ) { int cpu; for_each_possible_cpu ( cpu ) per_cpu(cpu_time, cpu).tsc_scale =3D per_cpu(cpu_time, 0).tsc_= scale; - /* If TSCs are not marked as 'reliable', re-sync during rendezvous= . */ - if ( !boot_cpu_has(X86_FEATURE_TSC_RELIABLE) ) + } + if ( (boot_cpu_has(X86_FEATURE_CONSTANT_TSC) && max_cstate <=3D 2) || + boot_cpu_has(X86_FEATURE_NONSTOP_TSC) ) + { + /* + * Sadly, despite processor vendors' best design guidance efforts, + * on some systems, cpus may come out of reset improperly + * synchronized. So we must verify there is no warp and we + * can't do that until all CPUs are booted + */ + tsc_check_reliability(); + if ( tsc_max_warp =3D=3D 0 ) + set_boot_cpu_bit(X86_FEATURE_TSC_RELIABLE); + } + if ( !boot_cpu_has(X86_FEATURE_TSC_RELIABLE) ) time_calibration_rendezvous_fn =3D time_calibration_tsc_rendez= vous; - } =20 open_softirq(TIME_CALIBRATE_SOFTIRQ, local_time_calibration); =20 @@ -1481,107 +1596,6 @@ struct tm wallclock_time(void) } =20 /* - * TSC Reliability check - */ - -/* - * The Linux original version of this function is - * Copyright (c) 2006, Red Hat, Inc., Ingo Molnar - */ -void check_tsc_warp(unsigned long tsc_khz, unsigned long *max_warp) -{ -#define rdtsc_barrier() mb() - static DEFINE_SPINLOCK(sync_lock); - static cycles_t last_tsc; - - cycles_t start, now, prev, end; - int i; - - rdtsc_barrier(); - start =3D get_cycles(); - rdtsc_barrier(); - - /* The measurement runs for 20 msecs: */ - end =3D start + tsc_khz * 20ULL; - now =3D start; - - for ( i =3D 0; ; i++ ) - { - /* - * We take the global lock, measure TSC, save the - * previous TSC that was measured (possibly on - * another CPU) and update the previous TSC timestamp. - */ - spin_lock(&sync_lock); - prev =3D last_tsc; - rdtsc_barrier(); - now =3D get_cycles(); - rdtsc_barrier(); - last_tsc =3D now; - spin_unlock(&sync_lock); - - /* - * Be nice every now and then (and also check whether measurement = is=20 - * done [we also insert a 10 million loops safety exit, so we dont= =20 - * lock up in case the TSC readout is totally broken]): - */ - if ( unlikely(!(i & 7)) ) - { - if ( (now > end) || (i > 10000000) ) - break; - cpu_relax(); - /*touch_nmi_watchdog();*/ - } - - /* - * Outside the critical section we can now see whether we saw a=20 - * time-warp of the TSC going backwards: - */ - if ( unlikely(prev > now) ) - { - spin_lock(&sync_lock); - if ( *max_warp < prev - now ) - *max_warp =3D prev - now; - spin_unlock(&sync_lock); - } - } -} - -static unsigned long tsc_max_warp, tsc_check_count; -static cpumask_t tsc_check_cpumask =3D CPU_MASK_NONE; - -static void tsc_check_slave(void *unused) -{ - unsigned int cpu =3D smp_processor_id(); - local_irq_disable(); - while ( !cpu_isset(cpu, tsc_check_cpumask) ) - mb(); - check_tsc_warp(cpu_khz, &tsc_max_warp); - cpu_clear(cpu, tsc_check_cpumask); - local_irq_enable(); -} - -void tsc_check_reliability(void) -{ - unsigned int cpu =3D smp_processor_id(); - static DEFINE_SPINLOCK(lock); - - spin_lock(&lock); - - tsc_check_count++; - smp_call_function(tsc_check_slave, NULL, 0); - tsc_check_cpumask =3D cpu_online_map; - local_irq_disable(); - check_tsc_warp(cpu_khz, &tsc_max_warp); - cpu_clear(cpu, tsc_check_cpumask); - local_irq_enable(); - while ( !cpus_empty(tsc_check_cpumask) ) - cpu_relax(); - - spin_unlock(&lock); -} - -/* * PV SoftTSC Emulation. */ =20 @@ -1616,19 +1630,10 @@ void pv_soft_rdtsc(struct vcpu *v, struc =20 static int host_tsc_is_safe(void) { - extern unsigned int max_cstate; - if ( boot_cpu_has(X86_FEATURE_TSC_RELIABLE) ) return 1; if ( num_online_cpus() =3D=3D 1 ) return 1; - if ( boot_cpu_has(X86_FEATURE_CONSTANT_TSC) && max_cstate <=3D 2 ) - { - if ( !tsc_check_count ) - tsc_check_reliability(); - if ( tsc_max_warp =3D=3D 0 ) - return 1; - } return 0; } =20 diff -r 1a911fd65e52 xen/include/asm-x86/cpufeature.h --- a/xen/include/asm-x86/cpufeature.h=09Fri Dec 18 07:53:27 2009 +0000 +++ b/xen/include/asm-x86/cpufeature.h=09Fri Dec 18 11:40:25 2009 -0700 @@ -132,6 +132,7 @@ =20 #define cpu_has(c, bit)=09=09test_bit(bit, (c)->x86_capability) #define boot_cpu_has(bit)=09test_bit(bit, boot_cpu_data.x86_capability) +#define set_boot_cpu_bit(bit)=09set_bit(bit, boot_cpu_data.x86_capability) =20 #ifdef __i386__ #define cpu_has_vme=09=09boot_cpu_has(X86_FEATURE_VME) --__126116235313077491abhmt004.oracle.com Content-Type: application/octet-stream; name="verify-tsc-sync.patch" Content-Transfer-Encoding: base64 Content-Disposition: attachment; filename="verify-tsc-sync.patch" ZGlmZiAtciAxYTkxMWZkNjVlNTIgeGVuL2FyY2gveDg2L2NwdS9hbWQuYwotLS0gYS94ZW4vYXJj aC94ODYvY3B1L2FtZC5jCUZyaSBEZWMgMTggMDc6NTM6MjcgMjAwOSArMDAwMAorKysgYi94ZW4v YXJjaC94ODYvY3B1L2FtZC5jCUZyaSBEZWMgMTggMTE6NDA6MjUgMjAwOSAtMDcwMApAQCAtNDY1 LDggKzQ2NSw2IEBAIHN0YXRpYyB2b2lkIF9fZGV2aW5pdCBpbml0X2FtZChzdHJ1Y3QgY3AKIAkJ aWYgKGMtPng4Nl9wb3dlciAmICgxPDw4KSkgewogCQkJc2V0X2JpdChYODZfRkVBVFVSRV9DT05T VEFOVF9UU0MsIGMtPng4Nl9jYXBhYmlsaXR5KTsKIAkJCXNldF9iaXQoWDg2X0ZFQVRVUkVfTk9O U1RPUF9UU0MsIGMtPng4Nl9jYXBhYmlsaXR5KTsKLQkJCWlmIChjLT54ODYgIT0gMHgxMSkKLQkJ CQlzZXRfYml0KFg4Nl9GRUFUVVJFX1RTQ19SRUxJQUJMRSwgYy0+eDg2X2NhcGFiaWxpdHkpOwog CQl9CiAJfQogCmRpZmYgLXIgMWE5MTFmZDY1ZTUyIHhlbi9hcmNoL3g4Ni9jcHUvaW50ZWwuYwot LS0gYS94ZW4vYXJjaC94ODYvY3B1L2ludGVsLmMJRnJpIERlYyAxOCAwNzo1MzoyNyAyMDA5ICsw MDAwCisrKyBiL3hlbi9hcmNoL3g4Ni9jcHUvaW50ZWwuYwlGcmkgRGVjIDE4IDExOjQwOjI1IDIw MDkgLTA3MDAKQEAgLTIxMiw3ICsyMTIsNiBAQCBzdGF0aWMgdm9pZCBfX2RldmluaXQgaW5pdF9p bnRlbChzdHJ1Y3QgCiAJaWYgKGNwdWlkX2VkeCgweDgwMDAwMDA3KSAmICgxdTw8OCkpIHsKIAkJ c2V0X2JpdChYODZfRkVBVFVSRV9DT05TVEFOVF9UU0MsIGMtPng4Nl9jYXBhYmlsaXR5KTsKIAkJ c2V0X2JpdChYODZfRkVBVFVSRV9OT05TVE9QX1RTQywgYy0+eDg2X2NhcGFiaWxpdHkpOwotCQlz ZXRfYml0KFg4Nl9GRUFUVVJFX1RTQ19SRUxJQUJMRSwgYy0+eDg2X2NhcGFiaWxpdHkpOwogCX0K IAlpZiAoKGMtPmNwdWlkX2xldmVsID49IDB4MDAwMDAwMDYpICYmCiAJICAgIChjcHVpZF9lYXgo MHgwMDAwMDAwNikgJiAoMXU8PDIpKSkKZGlmZiAtciAxYTkxMWZkNjVlNTIgeGVuL2FyY2gveDg2 L3RpbWUuYwotLS0gYS94ZW4vYXJjaC94ODYvdGltZS5jCUZyaSBEZWMgMTggMDc6NTM6MjcgMjAw OSArMDAwMAorKysgYi94ZW4vYXJjaC94ODYvdGltZS5jCUZyaSBEZWMgMTggMTE6NDA6MjUgMjAw OSAtMDcwMApAQCAtMTEzNSw2ICsxMTM1LDEwNyBAQCBzdGF0aWMgdm9pZCBsb2NhbF90aW1lX2Nh bGlicmF0aW9uKHZvaWQpCiB9CiAKIC8qCisgKiBUU0MgUmVsaWFiaWxpdHkgY2hlY2sKKyAqLwor CisvKgorICogVGhlIExpbnV4IG9yaWdpbmFsIHZlcnNpb24gb2YgdGhpcyBmdW5jdGlvbiBpcwor ICogQ29weXJpZ2h0IChjKSAyMDA2LCBSZWQgSGF0LCBJbmMuLCBJbmdvIE1vbG5hcgorICovCit2 b2lkIGNoZWNrX3RzY193YXJwKHVuc2lnbmVkIGxvbmcgdHNjX2toeiwgdW5zaWduZWQgbG9uZyAq bWF4X3dhcnApCit7CisjZGVmaW5lIHJkdHNjX2JhcnJpZXIoKSBtYigpCisgICAgc3RhdGljIERF RklORV9TUElOTE9DSyhzeW5jX2xvY2spOworICAgIHN0YXRpYyBjeWNsZXNfdCBsYXN0X3RzYzsK KworICAgIGN5Y2xlc190IHN0YXJ0LCBub3csIHByZXYsIGVuZDsKKyAgICBpbnQgaTsKKworICAg IHJkdHNjX2JhcnJpZXIoKTsKKyAgICBzdGFydCA9IGdldF9jeWNsZXMoKTsKKyAgICByZHRzY19i YXJyaWVyKCk7CisKKyAgICAvKiBUaGUgbWVhc3VyZW1lbnQgcnVucyBmb3IgMjAgbXNlY3M6ICov CisgICAgZW5kID0gc3RhcnQgKyB0c2Nfa2h6ICogMjBVTEw7CisgICAgbm93ID0gc3RhcnQ7CisK KyAgICBmb3IgKCBpID0gMDsgOyBpKysgKQorICAgIHsKKyAgICAgICAgLyoKKyAgICAgICAgICog V2UgdGFrZSB0aGUgZ2xvYmFsIGxvY2ssIG1lYXN1cmUgVFNDLCBzYXZlIHRoZQorICAgICAgICAg KiBwcmV2aW91cyBUU0MgdGhhdCB3YXMgbWVhc3VyZWQgKHBvc3NpYmx5IG9uCisgICAgICAgICAq IGFub3RoZXIgQ1BVKSBhbmQgdXBkYXRlIHRoZSBwcmV2aW91cyBUU0MgdGltZXN0YW1wLgorICAg ICAgICAgKi8KKyAgICAgICAgc3Bpbl9sb2NrKCZzeW5jX2xvY2spOworICAgICAgICBwcmV2ID0g bGFzdF90c2M7CisgICAgICAgIHJkdHNjX2JhcnJpZXIoKTsKKyAgICAgICAgbm93ID0gZ2V0X2N5 Y2xlcygpOworICAgICAgICByZHRzY19iYXJyaWVyKCk7CisgICAgICAgIGxhc3RfdHNjID0gbm93 OworICAgICAgICBzcGluX3VubG9jaygmc3luY19sb2NrKTsKKworICAgICAgICAvKgorICAgICAg ICAgKiBCZSBuaWNlIGV2ZXJ5IG5vdyBhbmQgdGhlbiAoYW5kIGFsc28gY2hlY2sgd2hldGhlciBt ZWFzdXJlbWVudCBpcyAKKyAgICAgICAgICogZG9uZSBbd2UgYWxzbyBpbnNlcnQgYSAxMCBtaWxs aW9uIGxvb3BzIHNhZmV0eSBleGl0LCBzbyB3ZSBkb250IAorICAgICAgICAgKiBsb2NrIHVwIGlu IGNhc2UgdGhlIFRTQyByZWFkb3V0IGlzIHRvdGFsbHkgYnJva2VuXSk6CisgICAgICAgICAqLwor ICAgICAgICBpZiAoIHVubGlrZWx5KCEoaSAmIDcpKSApCisgICAgICAgIHsKKyAgICAgICAgICAg IGlmICggKG5vdyA+IGVuZCkgfHwgKGkgPiAxMDAwMDAwMCkgKQorICAgICAgICAgICAgICAgIGJy ZWFrOworICAgICAgICAgICAgY3B1X3JlbGF4KCk7CisgICAgICAgICAgICAvKnRvdWNoX25taV93 YXRjaGRvZygpOyovCisgICAgICAgIH0KKworICAgICAgICAvKgorICAgICAgICAgKiBPdXRzaWRl IHRoZSBjcml0aWNhbCBzZWN0aW9uIHdlIGNhbiBub3cgc2VlIHdoZXRoZXIgd2Ugc2F3IGEgCisg ICAgICAgICAqIHRpbWUtd2FycCBvZiB0aGUgVFNDIGdvaW5nIGJhY2t3YXJkczoKKyAgICAgICAg ICovCisgICAgICAgIGlmICggdW5saWtlbHkocHJldiA+IG5vdykgKQorICAgICAgICB7CisgICAg ICAgICAgICBzcGluX2xvY2soJnN5bmNfbG9jayk7CisgICAgICAgICAgICBpZiAoICptYXhfd2Fy cCA8IHByZXYgLSBub3cgKQorICAgICAgICAgICAgICAgICptYXhfd2FycCA9IHByZXYgLSBub3c7 CisgICAgICAgICAgICBzcGluX3VubG9jaygmc3luY19sb2NrKTsKKyAgICAgICAgfQorICAgIH0K K30KKworc3RhdGljIHVuc2lnbmVkIGxvbmcgdHNjX21heF93YXJwLCB0c2NfY2hlY2tfY291bnQ7 CitzdGF0aWMgY3B1bWFza190IHRzY19jaGVja19jcHVtYXNrID0gQ1BVX01BU0tfTk9ORTsKKwor c3RhdGljIHZvaWQgdHNjX2NoZWNrX3NsYXZlKHZvaWQgKnVudXNlZCkKK3sKKyAgICB1bnNpZ25l ZCBpbnQgY3B1ID0gc21wX3Byb2Nlc3Nvcl9pZCgpOworICAgIGxvY2FsX2lycV9kaXNhYmxlKCk7 CisgICAgd2hpbGUgKCAhY3B1X2lzc2V0KGNwdSwgdHNjX2NoZWNrX2NwdW1hc2spICkKKyAgICAg ICAgbWIoKTsKKyAgICBjaGVja190c2Nfd2FycChjcHVfa2h6LCAmdHNjX21heF93YXJwKTsKKyAg ICBjcHVfY2xlYXIoY3B1LCB0c2NfY2hlY2tfY3B1bWFzayk7CisgICAgbG9jYWxfaXJxX2VuYWJs ZSgpOworfQorCit2b2lkIHRzY19jaGVja19yZWxpYWJpbGl0eSh2b2lkKQoreworICAgIHVuc2ln bmVkIGludCBjcHUgPSBzbXBfcHJvY2Vzc29yX2lkKCk7CisgICAgc3RhdGljIERFRklORV9TUElO TE9DSyhsb2NrKTsKKworICAgIHNwaW5fbG9jaygmbG9jayk7CisKKyAgICB0c2NfY2hlY2tfY291 bnQrKzsKKyAgICBzbXBfY2FsbF9mdW5jdGlvbih0c2NfY2hlY2tfc2xhdmUsIE5VTEwsIDApOwor ICAgIHRzY19jaGVja19jcHVtYXNrID0gY3B1X29ubGluZV9tYXA7CisgICAgbG9jYWxfaXJxX2Rp c2FibGUoKTsKKyAgICBjaGVja190c2Nfd2FycChjcHVfa2h6LCAmdHNjX21heF93YXJwKTsKKyAg ICBjcHVfY2xlYXIoY3B1LCB0c2NfY2hlY2tfY3B1bWFzayk7CisgICAgbG9jYWxfaXJxX2VuYWJs ZSgpOworICAgIHdoaWxlICggIWNwdXNfZW1wdHkodHNjX2NoZWNrX2NwdW1hc2spICkKKyAgICAg ICAgY3B1X3JlbGF4KCk7CisKKyAgICBzcGluX3VubG9jaygmbG9jayk7Cit9CisKKy8qCiAgKiBS ZW5kZXp2b3VzIGZvciBhbGwgQ1BVcyBpbiBJUlEgY29udGV4dC4KICAqIE1hc3RlciBDUFUgc25h cHNob3RzIHRoZSBwbGF0Zm9ybSB0aW1lci4KICAqIEFsbCBDUFVTIHNuYXBzaG90IHRoZWlyIGxv Y2FsIFRTQyBhbmQgZXh0cmFwb2xhdGlvbiBvZiBzeXN0ZW0gdGltZS4KQEAgLTEyNzEsMTYgKzEz NzIsMzAgQEAgdm9pZCBpbml0X3BlcmNwdV90aW1lKHZvaWQpCiAvKiBMYXRlIGluaXQgZnVuY3Rp b24gKGFmdGVyIGFsbCBDUFVzIGFyZSBib290ZWQpLiAqLwogaW50IF9faW5pdCBpbml0X3hlbl90 aW1lKHZvaWQpCiB7CisgICAgZXh0ZXJuIHVuc2lnbmVkIGludCBtYXhfY3N0YXRlOworCiAgICAg LyogSWYgd2UgaGF2ZSBjb25zdGFudC1yYXRlIFRTQ3MgdGhlbiBzY2FsZSBmYWN0b3IgY2FuIGJl IHNoYXJlZC4gKi8KICAgICBpZiAoIGJvb3RfY3B1X2hhcyhYODZfRkVBVFVSRV9DT05TVEFOVF9U U0MpICkKICAgICB7CiAgICAgICAgIGludCBjcHU7CiAgICAgICAgIGZvcl9lYWNoX3Bvc3NpYmxl X2NwdSAoIGNwdSApCiAgICAgICAgICAgICBwZXJfY3B1KGNwdV90aW1lLCBjcHUpLnRzY19zY2Fs ZSA9IHBlcl9jcHUoY3B1X3RpbWUsIDApLnRzY19zY2FsZTsKLSAgICAgICAgLyogSWYgVFNDcyBh cmUgbm90IG1hcmtlZCBhcyAncmVsaWFibGUnLCByZS1zeW5jIGR1cmluZyByZW5kZXp2b3VzLiAq LwotICAgICAgICBpZiAoICFib290X2NwdV9oYXMoWDg2X0ZFQVRVUkVfVFNDX1JFTElBQkxFKSAp CisgICAgfQorICAgIGlmICggKGJvb3RfY3B1X2hhcyhYODZfRkVBVFVSRV9DT05TVEFOVF9UU0Mp ICYmIG1heF9jc3RhdGUgPD0gMikgfHwKKyAgICAgICAgIGJvb3RfY3B1X2hhcyhYODZfRkVBVFVS RV9OT05TVE9QX1RTQykgKQorICAgIHsKKyAgICAgICAgLyoKKyAgICAgICAgICogU2FkbHksIGRl c3BpdGUgcHJvY2Vzc29yIHZlbmRvcnMnIGJlc3QgZGVzaWduIGd1aWRhbmNlIGVmZm9ydHMsCisg ICAgICAgICAqIG9uIHNvbWUgc3lzdGVtcywgY3B1cyBtYXkgY29tZSBvdXQgb2YgcmVzZXQgaW1w cm9wZXJseQorICAgICAgICAgKiBzeW5jaHJvbml6ZWQuICBTbyB3ZSBtdXN0IHZlcmlmeSB0aGVy ZSBpcyBubyB3YXJwIGFuZCB3ZQorICAgICAgICAgKiBjYW4ndCBkbyB0aGF0IHVudGlsIGFsbCBD UFVzIGFyZSBib290ZWQKKyAgICAgICAgICovCisgICAgICAgIHRzY19jaGVja19yZWxpYWJpbGl0 eSgpOworICAgICAgICBpZiAoIHRzY19tYXhfd2FycCA9PSAwICkKKyAgICAgICAgICAgIHNldF9i b290X2NwdV9iaXQoWDg2X0ZFQVRVUkVfVFNDX1JFTElBQkxFKTsKKyAgICB9CisgICAgaWYgKCAh Ym9vdF9jcHVfaGFzKFg4Nl9GRUFUVVJFX1RTQ19SRUxJQUJMRSkgKQogICAgICAgICAgICAgdGlt ZV9jYWxpYnJhdGlvbl9yZW5kZXp2b3VzX2ZuID0gdGltZV9jYWxpYnJhdGlvbl90c2NfcmVuZGV6 dm91czsKLSAgICB9CiAKICAgICBvcGVuX3NvZnRpcnEoVElNRV9DQUxJQlJBVEVfU09GVElSUSwg bG9jYWxfdGltZV9jYWxpYnJhdGlvbik7CiAKQEAgLTE0ODEsMTA3ICsxNTk2LDYgQEAgc3RydWN0 IHRtIHdhbGxjbG9ja190aW1lKHZvaWQpCiB9CiAKIC8qCi0gKiBUU0MgUmVsaWFiaWxpdHkgY2hl Y2sKLSAqLwotCi0vKgotICogVGhlIExpbnV4IG9yaWdpbmFsIHZlcnNpb24gb2YgdGhpcyBmdW5j dGlvbiBpcwotICogQ29weXJpZ2h0IChjKSAyMDA2LCBSZWQgSGF0LCBJbmMuLCBJbmdvIE1vbG5h cgotICovCi12b2lkIGNoZWNrX3RzY193YXJwKHVuc2lnbmVkIGxvbmcgdHNjX2toeiwgdW5zaWdu ZWQgbG9uZyAqbWF4X3dhcnApCi17Ci0jZGVmaW5lIHJkdHNjX2JhcnJpZXIoKSBtYigpCi0gICAg c3RhdGljIERFRklORV9TUElOTE9DSyhzeW5jX2xvY2spOwotICAgIHN0YXRpYyBjeWNsZXNfdCBs YXN0X3RzYzsKLQotICAgIGN5Y2xlc190IHN0YXJ0LCBub3csIHByZXYsIGVuZDsKLSAgICBpbnQg aTsKLQotICAgIHJkdHNjX2JhcnJpZXIoKTsKLSAgICBzdGFydCA9IGdldF9jeWNsZXMoKTsKLSAg ICByZHRzY19iYXJyaWVyKCk7Ci0KLSAgICAvKiBUaGUgbWVhc3VyZW1lbnQgcnVucyBmb3IgMjAg bXNlY3M6ICovCi0gICAgZW5kID0gc3RhcnQgKyB0c2Nfa2h6ICogMjBVTEw7Ci0gICAgbm93ID0g c3RhcnQ7Ci0KLSAgICBmb3IgKCBpID0gMDsgOyBpKysgKQotICAgIHsKLSAgICAgICAgLyoKLSAg ICAgICAgICogV2UgdGFrZSB0aGUgZ2xvYmFsIGxvY2ssIG1lYXN1cmUgVFNDLCBzYXZlIHRoZQot ICAgICAgICAgKiBwcmV2aW91cyBUU0MgdGhhdCB3YXMgbWVhc3VyZWQgKHBvc3NpYmx5IG9uCi0g ICAgICAgICAqIGFub3RoZXIgQ1BVKSBhbmQgdXBkYXRlIHRoZSBwcmV2aW91cyBUU0MgdGltZXN0 YW1wLgotICAgICAgICAgKi8KLSAgICAgICAgc3Bpbl9sb2NrKCZzeW5jX2xvY2spOwotICAgICAg ICBwcmV2ID0gbGFzdF90c2M7Ci0gICAgICAgIHJkdHNjX2JhcnJpZXIoKTsKLSAgICAgICAgbm93 ID0gZ2V0X2N5Y2xlcygpOwotICAgICAgICByZHRzY19iYXJyaWVyKCk7Ci0gICAgICAgIGxhc3Rf dHNjID0gbm93OwotICAgICAgICBzcGluX3VubG9jaygmc3luY19sb2NrKTsKLQotICAgICAgICAv KgotICAgICAgICAgKiBCZSBuaWNlIGV2ZXJ5IG5vdyBhbmQgdGhlbiAoYW5kIGFsc28gY2hlY2sg d2hldGhlciBtZWFzdXJlbWVudCBpcyAKLSAgICAgICAgICogZG9uZSBbd2UgYWxzbyBpbnNlcnQg YSAxMCBtaWxsaW9uIGxvb3BzIHNhZmV0eSBleGl0LCBzbyB3ZSBkb250IAotICAgICAgICAgKiBs b2NrIHVwIGluIGNhc2UgdGhlIFRTQyByZWFkb3V0IGlzIHRvdGFsbHkgYnJva2VuXSk6Ci0gICAg ICAgICAqLwotICAgICAgICBpZiAoIHVubGlrZWx5KCEoaSAmIDcpKSApCi0gICAgICAgIHsKLSAg ICAgICAgICAgIGlmICggKG5vdyA+IGVuZCkgfHwgKGkgPiAxMDAwMDAwMCkgKQotICAgICAgICAg ICAgICAgIGJyZWFrOwotICAgICAgICAgICAgY3B1X3JlbGF4KCk7Ci0gICAgICAgICAgICAvKnRv dWNoX25taV93YXRjaGRvZygpOyovCi0gICAgICAgIH0KLQotICAgICAgICAvKgotICAgICAgICAg KiBPdXRzaWRlIHRoZSBjcml0aWNhbCBzZWN0aW9uIHdlIGNhbiBub3cgc2VlIHdoZXRoZXIgd2Ug c2F3IGEgCi0gICAgICAgICAqIHRpbWUtd2FycCBvZiB0aGUgVFNDIGdvaW5nIGJhY2t3YXJkczoK LSAgICAgICAgICovCi0gICAgICAgIGlmICggdW5saWtlbHkocHJldiA+IG5vdykgKQotICAgICAg ICB7Ci0gICAgICAgICAgICBzcGluX2xvY2soJnN5bmNfbG9jayk7Ci0gICAgICAgICAgICBpZiAo ICptYXhfd2FycCA8IHByZXYgLSBub3cgKQotICAgICAgICAgICAgICAgICptYXhfd2FycCA9IHBy ZXYgLSBub3c7Ci0gICAgICAgICAgICBzcGluX3VubG9jaygmc3luY19sb2NrKTsKLSAgICAgICAg fQotICAgIH0KLX0KLQotc3RhdGljIHVuc2lnbmVkIGxvbmcgdHNjX21heF93YXJwLCB0c2NfY2hl Y2tfY291bnQ7Ci1zdGF0aWMgY3B1bWFza190IHRzY19jaGVja19jcHVtYXNrID0gQ1BVX01BU0tf Tk9ORTsKLQotc3RhdGljIHZvaWQgdHNjX2NoZWNrX3NsYXZlKHZvaWQgKnVudXNlZCkKLXsKLSAg ICB1bnNpZ25lZCBpbnQgY3B1ID0gc21wX3Byb2Nlc3Nvcl9pZCgpOwotICAgIGxvY2FsX2lycV9k aXNhYmxlKCk7Ci0gICAgd2hpbGUgKCAhY3B1X2lzc2V0KGNwdSwgdHNjX2NoZWNrX2NwdW1hc2sp ICkKLSAgICAgICAgbWIoKTsKLSAgICBjaGVja190c2Nfd2FycChjcHVfa2h6LCAmdHNjX21heF93 YXJwKTsKLSAgICBjcHVfY2xlYXIoY3B1LCB0c2NfY2hlY2tfY3B1bWFzayk7Ci0gICAgbG9jYWxf aXJxX2VuYWJsZSgpOwotfQotCi12b2lkIHRzY19jaGVja19yZWxpYWJpbGl0eSh2b2lkKQotewot ICAgIHVuc2lnbmVkIGludCBjcHUgPSBzbXBfcHJvY2Vzc29yX2lkKCk7Ci0gICAgc3RhdGljIERF RklORV9TUElOTE9DSyhsb2NrKTsKLQotICAgIHNwaW5fbG9jaygmbG9jayk7Ci0KLSAgICB0c2Nf Y2hlY2tfY291bnQrKzsKLSAgICBzbXBfY2FsbF9mdW5jdGlvbih0c2NfY2hlY2tfc2xhdmUsIE5V TEwsIDApOwotICAgIHRzY19jaGVja19jcHVtYXNrID0gY3B1X29ubGluZV9tYXA7Ci0gICAgbG9j YWxfaXJxX2Rpc2FibGUoKTsKLSAgICBjaGVja190c2Nfd2FycChjcHVfa2h6LCAmdHNjX21heF93 YXJwKTsKLSAgICBjcHVfY2xlYXIoY3B1LCB0c2NfY2hlY2tfY3B1bWFzayk7Ci0gICAgbG9jYWxf aXJxX2VuYWJsZSgpOwotICAgIHdoaWxlICggIWNwdXNfZW1wdHkodHNjX2NoZWNrX2NwdW1hc2sp ICkKLSAgICAgICAgY3B1X3JlbGF4KCk7Ci0KLSAgICBzcGluX3VubG9jaygmbG9jayk7Ci19Ci0K LS8qCiAgKiBQViBTb2Z0VFNDIEVtdWxhdGlvbi4KICAqLwogCkBAIC0xNjE2LDE5ICsxNjMwLDEw IEBAIHZvaWQgcHZfc29mdF9yZHRzYyhzdHJ1Y3QgdmNwdSAqdiwgc3RydWMKIAogc3RhdGljIGlu dCBob3N0X3RzY19pc19zYWZlKHZvaWQpCiB7Ci0gICAgZXh0ZXJuIHVuc2lnbmVkIGludCBtYXhf Y3N0YXRlOwotCiAgICAgaWYgKCBib290X2NwdV9oYXMoWDg2X0ZFQVRVUkVfVFNDX1JFTElBQkxF KSApCiAgICAgICAgIHJldHVybiAxOwogICAgIGlmICggbnVtX29ubGluZV9jcHVzKCkgPT0gMSAp CiAgICAgICAgIHJldHVybiAxOwotICAgIGlmICggYm9vdF9jcHVfaGFzKFg4Nl9GRUFUVVJFX0NP TlNUQU5UX1RTQykgJiYgbWF4X2NzdGF0ZSA8PSAyICkKLSAgICB7Ci0gICAgICAgIGlmICggIXRz Y19jaGVja19jb3VudCApCi0gICAgICAgICAgICB0c2NfY2hlY2tfcmVsaWFiaWxpdHkoKTsKLSAg ICAgICAgaWYgKCB0c2NfbWF4X3dhcnAgPT0gMCApCi0gICAgICAgICAgICByZXR1cm4gMTsKLSAg ICB9CiAgICAgcmV0dXJuIDA7CiB9CiAKZGlmZiAtciAxYTkxMWZkNjVlNTIgeGVuL2luY2x1ZGUv YXNtLXg4Ni9jcHVmZWF0dXJlLmgKLS0tIGEveGVuL2luY2x1ZGUvYXNtLXg4Ni9jcHVmZWF0dXJl LmgJRnJpIERlYyAxOCAwNzo1MzoyNyAyMDA5ICswMDAwCisrKyBiL3hlbi9pbmNsdWRlL2FzbS14 ODYvY3B1ZmVhdHVyZS5oCUZyaSBEZWMgMTggMTE6NDA6MjUgMjAwOSAtMDcwMApAQCAtMTMyLDYg KzEzMiw3IEBACiAKICNkZWZpbmUgY3B1X2hhcyhjLCBiaXQpCQl0ZXN0X2JpdChiaXQsIChjKS0+ eDg2X2NhcGFiaWxpdHkpCiAjZGVmaW5lIGJvb3RfY3B1X2hhcyhiaXQpCXRlc3RfYml0KGJpdCwg Ym9vdF9jcHVfZGF0YS54ODZfY2FwYWJpbGl0eSkKKyNkZWZpbmUgc2V0X2Jvb3RfY3B1X2JpdChi aXQpCXNldF9iaXQoYml0LCBib290X2NwdV9kYXRhLng4Nl9jYXBhYmlsaXR5KQogCiAjaWZkZWYg X19pMzg2X18KICNkZWZpbmUgY3B1X2hhc192bWUJCWJvb3RfY3B1X2hhcyhYODZfRkVBVFVSRV9W TUUpCg== --__126116235313077491abhmt004.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 --__126116235313077491abhmt004.oracle.com--