From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Tian, Kevin" Subject: [PATCH 4/12] PM interface between dom0 and Xen Date: Tue, 15 May 2007 22:17:20 +0800 Message-ID: Mime-Version: 1.0 Content-Type: multipart/mixed; boundary="----_=_NextPart_001_01C796FB.BFDF6E1F" Return-path: Content-Class: urn:content-classes:message 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@lists.xensource.com List-Id: xen-devel@lists.xenproject.org ------_=_NextPart_001_01C796FB.BFDF6E1F Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable Define pm interfaces between dom0 and Xen, with one to register sleep info and the other for triggering sleep state. "acpi_sleep=3Ds3_mode/s3_bios" option is also supported by piggybacking video flag/mode to xen at trigger point. Signed-off-by Ke Yu Signed-off-by Kevin Tian diff -r fc995dc97a94 xen/arch/x86/acpi/power.c --- a/xen/arch/x86/acpi/power.c Mon May 14 18:27:46 2007 -0400 +++ b/xen/arch/x86/acpi/power.c Mon May 14 18:29:06 2007 -0400 @@ -28,6 +28,16 @@ u8 sleep_states[ACPI_S_STATE_COUNT]; u8 sleep_states[ACPI_S_STATE_COUNT]; DEFINE_SPINLOCK(pm_lock); =20 +struct acpi_sleep_info { + uint16_t pm1a_cnt; + uint16_t pm1b_cnt; + uint16_t pm1a_evt; + uint16_t pm1b_evt; + uint16_t pm1a_cnt_val; + uint16_t pm1b_cnt_val; + uint32_t sleep_state; +} acpi_sinfo; + extern void do_suspend_lowlevel(void); =20 static char *acpi_states[ACPI_S_STATE_COUNT] =3D @@ -95,7 +105,7 @@ void __init acpi_reserve_bootmem(void) acpi_wakeup_address =3D (unsigned long)__va(0x7000); } =20 -/* Add suspend failure recover later */ +/* XXX: Add suspend failure recover later */ static int device_power_down(void) { console_suspend(); @@ -124,6 +134,7 @@ static void device_power_up(void) console_resume(); } =20 +/* Main interface to do xen specific suspend/resume */ int enter_state(u32 state) { struct domain *d; @@ -152,7 +163,6 @@ int enter_state(u32 state) =20 ACPI_FLUSH_CPU_CACHE(); =20 - /* Do arch specific saving of state. */ if (state > ACPI_STATE_S1) { error =3D acpi_save_state_mem(); if (error) @@ -165,7 +175,7 @@ int enter_state(u32 state) break; default: error =3D -EINVAL; - goto Powerup; + break; } =20 pmprintk(XENLOG_INFO, "Back to C!\n"); @@ -185,6 +195,97 @@ int enter_state(u32 state) spin_unlock(&pm_lock); return error; =20 +} + +/* + * Xen just requires address of pm1x_cnt, and ACPI interpreter + * is still kept in dom0. Address of xen wakeup stub will be + * returned, and then dom0 writes that address to FACS. + */ +int set_acpi_sleep_info(struct xenpf_set_acpi_sleep *info) +{ + if (acpi_sinfo.pm1a_cnt) + pmprintk(XENLOG_WARNING, "Multiple setting on acpi sleep info\n"); + + acpi_sinfo.pm1a_cnt =3D info->pm1a_cnt_port; + acpi_sinfo.pm1b_cnt =3D info->pm1b_cnt_port; + acpi_sinfo.pm1a_evt =3D info->pm1a_evt_port; + acpi_sinfo.pm1b_evt =3D info->pm1b_evt_port; + info->xen_waking_vec =3D (uint64_t)__pa(acpi_wakeup_address); + + pmprintk(XENLOG_INFO, "pm1a[%x],pm1b[%x],pm1a_e[%x],pm1b_e[%x]" + "wake[%"PRIx64"]", + acpi_sinfo.pm1a_cnt, acpi_sinfo.pm1b_cnt, + acpi_sinfo.pm1a_evt, acpi_sinfo.pm1b_evt, + info->xen_waking_vec); + return 0; +} + +/* + * Dom0 issues this hypercall in place of writing pm1a_cnt. Xen then + * takes over the control and put the system into sleep state really. + * Also video flags and mode are passed here, in case user may use + * "acpi_sleep=3D***" for video resume. + * + * Guest may issue a two-phases write to PM1x_CNT, to work + * around poorly implemented hardware. It's better to keep + * this logic here. Two writes can be differentiated by=20 + * enable bit setting. + */ +int acpi_enter_sleep(struct xenpf_enter_acpi_sleep *sleep) +{ + if (!acpi_sinfo.pm1a_cnt) + return -EPERM; + + /* Sanity check */ + if (acpi_sinfo.pm1b_cnt_val && + ((sleep->pm1a_cnt_val ^ sleep->pm1b_cnt_val) & + ACPI_BITMASK_SLEEP_ENABLE)) { + pmprintk(XENLOG_ERR, "Mismatched pm1a/pm1b setting\n"); + return -EINVAL; + } + + /* Write #1 */ + if (!(sleep->pm1a_cnt_val & ACPI_BITMASK_SLEEP_ENABLE)) { + outw((u16)sleep->pm1a_cnt_val, acpi_sinfo.pm1a_cnt); + if (acpi_sinfo.pm1b_cnt) + outw((u16)sleep->pm1b_cnt_val, acpi_sinfo.pm1b_cnt); + return 0; + } + + /* Write #2 */ + acpi_sinfo.pm1a_cnt_val =3D sleep->pm1a_cnt_val; + acpi_sinfo.pm1b_cnt_val =3D sleep->pm1b_cnt_val; + acpi_sinfo.sleep_state =3D sleep->sleep_state; + acpi_video_flags =3D sleep->video_flags; + saved_videomode =3D sleep->video_mode; + + return enter_state(acpi_sinfo.sleep_state); +} + +static int acpi_get_wake_status(void) +{ + uint16_t val; + + /* Wake status is the 15th bit of PM1 status register. (ACPI spec 3.0) */ + val =3D inw(acpi_sinfo.pm1a_evt) | inw(acpi_sinfo.pm1b_evt); + val &=3D ACPI_BITMASK_WAKE_STATUS; + val >>=3D ACPI_BITPOSITION_WAKE_STATUS; + return val; +} + +/* System is really put into sleep state by this stub */ +acpi_status asmlinkage acpi_enter_sleep_state(u8 sleep_state) +{ + ACPI_FLUSH_CPU_CACHE(); + + outw((u16)acpi_sinfo.pm1a_cnt_val, acpi_sinfo.pm1a_cnt); + if (acpi_sinfo.pm1b_cnt) + outw((u16)acpi_sinfo.pm1b_cnt_val, acpi_sinfo.pm1b_cnt); + =20 + /* Wait until we enter sleep state, and spin until we wake */ + while (!acpi_get_wake_status()); + return_ACPI_STATUS(AE_OK); } =20 static int __init acpi_sleep_init(void) diff -r fc995dc97a94 xen/arch/x86/platform_hypercall.c --- a/xen/arch/x86/platform_hypercall.c Mon May 14 18:27:46 2007 -0400 +++ b/xen/arch/x86/platform_hypercall.c Mon May 14 18:29:06 2007 -0400 @@ -18,6 +18,7 @@ #include #include #include +#include #include #include #include @@ -151,6 +152,20 @@ ret_t do_platform_op(XEN_GUEST_HANDLE(xe } break; =20 + case XENPF_set_acpi_sleep: + { + ret =3D set_acpi_sleep_info(&op->u.set_acpi_sleep); + if (!ret && copy_to_guest(u_xenpf_op, op, 1)) + ret =3D -EFAULT; + } + break; + + case XENPF_enter_acpi_sleep: + { + ret =3D acpi_enter_sleep(&op->u.enter_acpi_sleep); + } + break; + default: ret =3D -ENOSYS; break; diff -r fc995dc97a94 xen/include/public/platform.h --- a/xen/include/public/platform.h Mon May 14 18:27:46 2007 -0400 +++ b/xen/include/public/platform.h Mon May 14 18:29:06 2007 -0400 @@ -114,6 +114,31 @@ typedef struct xenpf_platform_quirk xenp typedef struct xenpf_platform_quirk xenpf_platform_quirk_t; DEFINE_XEN_GUEST_HANDLE(xenpf_platform_quirk_t); =20 +#define XENPF_set_acpi_sleep 40 +struct xenpf_set_acpi_sleep { + /* IN variables. */ + uint16_t pm1a_cnt_port; + uint16_t pm1b_cnt_port; + uint16_t pm1a_evt_port; + uint16_t pm1b_evt_port; + /* OUT variables */ + uint64_t xen_waking_vec; /* Tell dom0 to set FACS waking vector */ +}; +typedef struct xenpf_set_acpi_sleep xenpf_set_acpi_sleep_t; +DEFINE_XEN_GUEST_HANDLE(xenpf_set_acpi_sleep_t); + +#define XENPF_enter_acpi_sleep 41 +struct xenpf_enter_acpi_sleep { + /* IN variables */ + uint16_t pm1a_cnt_val; + uint16_t pm1b_cnt_val; + uint32_t sleep_state; /* Which state to enter */ + uint32_t video_flags; /* S3_bios or s3_mode */ + uint32_t video_mode; /* Mode setting for s3_mode */ +}; +typedef struct xenpf_enter_acpi_sleep xenpf_enter_acpi_sleep_t; +DEFINE_XEN_GUEST_HANDLE(xenpf_enter_acpi_sleep_t); + struct xen_platform_op { uint32_t cmd; uint32_t interface_version; /* XENPF_INTERFACE_VERSION */ @@ -124,6 +149,8 @@ struct xen_platform_op { struct xenpf_read_memtype read_memtype; struct xenpf_microcode_update microcode; struct xenpf_platform_quirk platform_quirk; + struct xenpf_set_acpi_sleep set_acpi_sleep; + struct xenpf_enter_acpi_sleep enter_acpi_sleep; uint8_t pad[128]; } u; }; diff -r fc995dc97a94 xen/include/xen/acpi.h --- a/xen/include/xen/acpi.h Mon May 14 18:27:46 2007 -0400 +++ b/xen/include/xen/acpi.h Mon May 14 18:29:06 2007 -0400 @@ -535,4 +535,15 @@ static inline int acpi_get_pxm(acpi_hand =20 extern int pnpacpi_disabled; =20 +#include +#ifdef COMPAT +#define xenpf_set_acpi_sleep compat_pf_set_acpi_sleep +#define xenpf_enter_acpi_sleep compat_pf_enter_acpi_sleep +#endif /* COMPAT */ + +extern unsigned long acpi_video_flags; +extern unsigned long saved_videomode; +extern int set_acpi_sleep_info(struct xenpf_set_acpi_sleep *info); +extern int acpi_enter_sleep(struct xenpf_enter_acpi_sleep *sleep); +extern int acpi_enter_state(u32 state); #endif /*_LINUX_ACPI_H*/ ------_=_NextPart_001_01C796FB.BFDF6E1F Content-Type: application/octet-stream; name="acpi_sleep_interface.patch" Content-Transfer-Encoding: base64 Content-Description: acpi_sleep_interface.patch Content-Disposition: attachment; filename="acpi_sleep_interface.patch" RGVmaW5lIHBtIGludGVyZmFjZXMgYmV0d2VlbiBkb20wIGFuZCBYZW4sIHdpdGggb25lDQp0byBy ZWdpc3RlciBzbGVlcCBpbmZvIGFuZCB0aGUgb3RoZXIgZm9yIHRyaWdnZXJpbmcNCnNsZWVwIHN0 YXRlLiAiYWNwaV9zbGVlcD1zM19tb2RlL3MzX2Jpb3MiIG9wdGlvbiBpcw0KYWxzbyBzdXBwb3J0 ZWQgYnkgcGlnZ3liYWNraW5nIHZpZGVvIGZsYWcvbW9kZSB0bw0KeGVuIGF0IHRyaWdnZXIgcG9p bnQuDQoNClNpZ25lZC1vZmYtYnkgS2UgWXUgPGtlLnl1QGludGVsLmNvbT4NClNpZ25lZC1vZmYt YnkgS2V2aW4gVGlhbiA8a2V2aW4udGlhbkBpbnRlbC5jb20+DQoNCmRpZmYgLXIgZmM5OTVkYzk3 YTk0IHhlbi9hcmNoL3g4Ni9hY3BpL3Bvd2VyLmMNCi0tLSBhL3hlbi9hcmNoL3g4Ni9hY3BpL3Bv d2VyLmMJTW9uIE1heSAxNCAxODoyNzo0NiAyMDA3IC0wNDAwDQorKysgYi94ZW4vYXJjaC94ODYv YWNwaS9wb3dlci5jCU1vbiBNYXkgMTQgMTg6Mjk6MDYgMjAwNyAtMDQwMA0KQEAgLTI4LDYgKzI4 LDE2IEBAIHU4IHNsZWVwX3N0YXRlc1tBQ1BJX1NfU1RBVEVfQ09VTlRdOw0KIHU4IHNsZWVwX3N0 YXRlc1tBQ1BJX1NfU1RBVEVfQ09VTlRdOw0KIERFRklORV9TUElOTE9DSyhwbV9sb2NrKTsNCiAN CitzdHJ1Y3QgYWNwaV9zbGVlcF9pbmZvIHsNCisgICAgdWludDE2X3QgcG0xYV9jbnQ7DQorICAg IHVpbnQxNl90IHBtMWJfY250Ow0KKyAgICB1aW50MTZfdCBwbTFhX2V2dDsNCisgICAgdWludDE2 X3QgcG0xYl9ldnQ7DQorICAgIHVpbnQxNl90IHBtMWFfY250X3ZhbDsNCisgICAgdWludDE2X3Qg cG0xYl9jbnRfdmFsOw0KKyAgICB1aW50MzJfdCBzbGVlcF9zdGF0ZTsNCit9IGFjcGlfc2luZm87 DQorDQogZXh0ZXJuIHZvaWQgZG9fc3VzcGVuZF9sb3dsZXZlbCh2b2lkKTsNCiANCiBzdGF0aWMg Y2hhciAqYWNwaV9zdGF0ZXNbQUNQSV9TX1NUQVRFX0NPVU5UXSA9DQpAQCAtOTUsNyArMTA1LDcg QEAgdm9pZCBfX2luaXQgYWNwaV9yZXNlcnZlX2Jvb3RtZW0odm9pZCkNCiAgICAgYWNwaV93YWtl dXBfYWRkcmVzcyA9ICh1bnNpZ25lZCBsb25nKV9fdmEoMHg3MDAwKTsNCiB9DQogDQotLyogQWRk IHN1c3BlbmQgZmFpbHVyZSByZWNvdmVyIGxhdGVyICovDQorLyogWFhYOiBBZGQgc3VzcGVuZCBm YWlsdXJlIHJlY292ZXIgbGF0ZXIgKi8NCiBzdGF0aWMgaW50IGRldmljZV9wb3dlcl9kb3duKHZv aWQpDQogew0KICAgICBjb25zb2xlX3N1c3BlbmQoKTsNCkBAIC0xMjQsNiArMTM0LDcgQEAgc3Rh dGljIHZvaWQgZGV2aWNlX3Bvd2VyX3VwKHZvaWQpDQogICAgIGNvbnNvbGVfcmVzdW1lKCk7DQog fQ0KIA0KKy8qIE1haW4gaW50ZXJmYWNlIHRvIGRvIHhlbiBzcGVjaWZpYyBzdXNwZW5kL3Jlc3Vt ZSAqLw0KIGludCBlbnRlcl9zdGF0ZSh1MzIgc3RhdGUpDQogew0KICAgICBzdHJ1Y3QgZG9tYWlu ICpkOw0KQEAgLTE1Miw3ICsxNjMsNiBAQCBpbnQgZW50ZXJfc3RhdGUodTMyIHN0YXRlKQ0KIA0K ICAgICBBQ1BJX0ZMVVNIX0NQVV9DQUNIRSgpOw0KIA0KLSAgICAvKiBEbyBhcmNoIHNwZWNpZmlj IHNhdmluZyBvZiBzdGF0ZS4gKi8NCiAgICAgaWYgKHN0YXRlID4gQUNQSV9TVEFURV9TMSkgew0K ICAgICAgICAgZXJyb3IgPSBhY3BpX3NhdmVfc3RhdGVfbWVtKCk7DQogICAgICAgICBpZiAoZXJy b3IpDQpAQCAtMTY1LDcgKzE3NSw3IEBAIGludCBlbnRlcl9zdGF0ZSh1MzIgc3RhdGUpDQogICAg ICAgICAgICAgYnJlYWs7DQogICAgICAgICBkZWZhdWx0Og0KICAgICAgICAgICAgIGVycm9yID0g LUVJTlZBTDsNCi0gICAgICAgICAgICBnb3RvIFBvd2VydXA7DQorICAgICAgICAgICAgYnJlYWs7 DQogICAgIH0NCiANCiAgICAgcG1wcmludGsoWEVOTE9HX0lORk8sICJCYWNrIHRvIEMhXG4iKTsN CkBAIC0xODUsNiArMTk1LDk3IEBAIGludCBlbnRlcl9zdGF0ZSh1MzIgc3RhdGUpDQogICAgIHNw aW5fdW5sb2NrKCZwbV9sb2NrKTsNCiAgICAgcmV0dXJuIGVycm9yOw0KIA0KK30NCisNCisvKg0K KyAqIFhlbiBqdXN0IHJlcXVpcmVzIGFkZHJlc3Mgb2YgcG0xeF9jbnQsIGFuZCBBQ1BJIGludGVy cHJldGVyDQorICogaXMgc3RpbGwga2VwdCBpbiBkb20wLiBBZGRyZXNzIG9mIHhlbiB3YWtldXAg c3R1YiB3aWxsIGJlDQorICogcmV0dXJuZWQsIGFuZCB0aGVuIGRvbTAgd3JpdGVzIHRoYXQgYWRk cmVzcyB0byBGQUNTLg0KKyAqLw0KK2ludCBzZXRfYWNwaV9zbGVlcF9pbmZvKHN0cnVjdCB4ZW5w Zl9zZXRfYWNwaV9zbGVlcCAqaW5mbykNCit7DQorICAgIGlmIChhY3BpX3NpbmZvLnBtMWFfY250 KQ0KKyAgICAgICAgcG1wcmludGsoWEVOTE9HX1dBUk5JTkcsICJNdWx0aXBsZSBzZXR0aW5nIG9u IGFjcGkgc2xlZXAgaW5mb1xuIik7DQorDQorICAgIGFjcGlfc2luZm8ucG0xYV9jbnQgPSBpbmZv LT5wbTFhX2NudF9wb3J0Ow0KKyAgICBhY3BpX3NpbmZvLnBtMWJfY250ID0gaW5mby0+cG0xYl9j bnRfcG9ydDsNCisgICAgYWNwaV9zaW5mby5wbTFhX2V2dCA9IGluZm8tPnBtMWFfZXZ0X3BvcnQ7 DQorICAgIGFjcGlfc2luZm8ucG0xYl9ldnQgPSBpbmZvLT5wbTFiX2V2dF9wb3J0Ow0KKyAgICBp bmZvLT54ZW5fd2FraW5nX3ZlYyA9ICh1aW50NjRfdClfX3BhKGFjcGlfd2FrZXVwX2FkZHJlc3Mp Ow0KKw0KKyAgICBwbXByaW50ayhYRU5MT0dfSU5GTywgInBtMWFbJXhdLHBtMWJbJXhdLHBtMWFf ZVsleF0scG0xYl9lWyV4XSINCisgICAgICAgICAgICAgICAgICAgICAgICJ3YWtlWyUiUFJJeDY0 Il0iLA0KKyAgICAgICAgICAgICAgICAgICAgICAgYWNwaV9zaW5mby5wbTFhX2NudCwgYWNwaV9z aW5mby5wbTFiX2NudCwNCisgICAgICAgICAgICAgICAgICAgICAgIGFjcGlfc2luZm8ucG0xYV9l dnQsIGFjcGlfc2luZm8ucG0xYl9ldnQsDQorICAgICAgICAgICAgICAgICAgICAgICBpbmZvLT54 ZW5fd2FraW5nX3ZlYyk7DQorICAgIHJldHVybiAwOw0KK30NCisNCisvKg0KKyAqIERvbTAgaXNz dWVzIHRoaXMgaHlwZXJjYWxsIGluIHBsYWNlIG9mIHdyaXRpbmcgcG0xYV9jbnQuIFhlbiB0aGVu DQorICogdGFrZXMgb3ZlciB0aGUgY29udHJvbCBhbmQgcHV0IHRoZSBzeXN0ZW0gaW50byBzbGVl cCBzdGF0ZSByZWFsbHkuDQorICogQWxzbyB2aWRlbyBmbGFncyBhbmQgbW9kZSBhcmUgcGFzc2Vk IGhlcmUsIGluIGNhc2UgdXNlciBtYXkgdXNlDQorICogImFjcGlfc2xlZXA9KioqIiBmb3Igdmlk ZW8gcmVzdW1lLg0KKyAqDQorICogR3Vlc3QgbWF5IGlzc3VlIGEgdHdvLXBoYXNlcyB3cml0ZSB0 byBQTTF4X0NOVCwgdG8gd29yaw0KKyAqIGFyb3VuZCBwb29ybHkgaW1wbGVtZW50ZWQgaGFyZHdh cmUuIEl0J3MgYmV0dGVyIHRvIGtlZXANCisgKiB0aGlzIGxvZ2ljIGhlcmUuIFR3byB3cml0ZXMg Y2FuIGJlIGRpZmZlcmVudGlhdGVkIGJ5IA0KKyAqIGVuYWJsZSBiaXQgc2V0dGluZy4NCisgKi8N CitpbnQgYWNwaV9lbnRlcl9zbGVlcChzdHJ1Y3QgeGVucGZfZW50ZXJfYWNwaV9zbGVlcCAqc2xl ZXApDQorew0KKyAgICBpZiAoIWFjcGlfc2luZm8ucG0xYV9jbnQpDQorICAgICAgICByZXR1cm4g LUVQRVJNOw0KKw0KKyAgICAvKiBTYW5pdHkgY2hlY2sgKi8NCisgICAgaWYgKGFjcGlfc2luZm8u cG0xYl9jbnRfdmFsICYmDQorICAgICAgICAoKHNsZWVwLT5wbTFhX2NudF92YWwgXiBzbGVlcC0+ cG0xYl9jbnRfdmFsKSAmDQorICAgICAgICAgQUNQSV9CSVRNQVNLX1NMRUVQX0VOQUJMRSkpIHsN CisgICAgICAgIHBtcHJpbnRrKFhFTkxPR19FUlIsICJNaXNtYXRjaGVkIHBtMWEvcG0xYiBzZXR0 aW5nXG4iKTsNCisgICAgICAgIHJldHVybiAtRUlOVkFMOw0KKyAgICB9DQorDQorICAgIC8qIFdy aXRlICMxICovDQorICAgIGlmICghKHNsZWVwLT5wbTFhX2NudF92YWwgJiBBQ1BJX0JJVE1BU0tf U0xFRVBfRU5BQkxFKSkgew0KKyAgICAgICAgb3V0dygodTE2KXNsZWVwLT5wbTFhX2NudF92YWws IGFjcGlfc2luZm8ucG0xYV9jbnQpOw0KKyAgICAgICAgaWYgKGFjcGlfc2luZm8ucG0xYl9jbnQp DQorICAgICAgICAgICAgb3V0dygodTE2KXNsZWVwLT5wbTFiX2NudF92YWwsIGFjcGlfc2luZm8u cG0xYl9jbnQpOw0KKyAgICAgICAgcmV0dXJuIDA7DQorICAgIH0NCisNCisgICAgLyogV3JpdGUg IzIgKi8NCisgICAgYWNwaV9zaW5mby5wbTFhX2NudF92YWwgPSBzbGVlcC0+cG0xYV9jbnRfdmFs Ow0KKyAgICBhY3BpX3NpbmZvLnBtMWJfY250X3ZhbCA9IHNsZWVwLT5wbTFiX2NudF92YWw7DQor ICAgIGFjcGlfc2luZm8uc2xlZXBfc3RhdGUgPSBzbGVlcC0+c2xlZXBfc3RhdGU7DQorICAgIGFj cGlfdmlkZW9fZmxhZ3MgPSBzbGVlcC0+dmlkZW9fZmxhZ3M7DQorICAgIHNhdmVkX3ZpZGVvbW9k ZSA9IHNsZWVwLT52aWRlb19tb2RlOw0KKw0KKyAgICByZXR1cm4gZW50ZXJfc3RhdGUoYWNwaV9z aW5mby5zbGVlcF9zdGF0ZSk7DQorfQ0KKw0KK3N0YXRpYyBpbnQgYWNwaV9nZXRfd2FrZV9zdGF0 dXModm9pZCkNCit7DQorICAgIHVpbnQxNl90IHZhbDsNCisNCisgICAgLyogV2FrZSBzdGF0dXMg aXMgdGhlIDE1dGggYml0IG9mIFBNMSBzdGF0dXMgcmVnaXN0ZXIuIChBQ1BJIHNwZWMgMy4wKSAq Lw0KKyAgICB2YWwgPSBpbncoYWNwaV9zaW5mby5wbTFhX2V2dCkgfCBpbncoYWNwaV9zaW5mby5w bTFiX2V2dCk7DQorICAgIHZhbCAmPSBBQ1BJX0JJVE1BU0tfV0FLRV9TVEFUVVM7DQorICAgIHZh bCA+Pj0gQUNQSV9CSVRQT1NJVElPTl9XQUtFX1NUQVRVUzsNCisgICAgcmV0dXJuIHZhbDsNCit9 DQorDQorLyogU3lzdGVtIGlzIHJlYWxseSBwdXQgaW50byBzbGVlcCBzdGF0ZSBieSB0aGlzIHN0 dWIgKi8NCithY3BpX3N0YXR1cyBhc21saW5rYWdlIGFjcGlfZW50ZXJfc2xlZXBfc3RhdGUodTgg c2xlZXBfc3RhdGUpDQorew0KKyAgICBBQ1BJX0ZMVVNIX0NQVV9DQUNIRSgpOw0KKw0KKyAgICBv dXR3KCh1MTYpYWNwaV9zaW5mby5wbTFhX2NudF92YWwsIGFjcGlfc2luZm8ucG0xYV9jbnQpOw0K KyAgICBpZiAoYWNwaV9zaW5mby5wbTFiX2NudCkNCisgICAgICAgIG91dHcoKHUxNilhY3BpX3Np bmZvLnBtMWJfY250X3ZhbCwgYWNwaV9zaW5mby5wbTFiX2NudCk7DQorICAgIA0KKyAgICAvKiBX YWl0IHVudGlsIHdlIGVudGVyIHNsZWVwIHN0YXRlLCBhbmQgc3BpbiB1bnRpbCB3ZSB3YWtlICov DQorICAgIHdoaWxlICghYWNwaV9nZXRfd2FrZV9zdGF0dXMoKSk7DQorICAgIHJldHVybl9BQ1BJ X1NUQVRVUyhBRV9PSyk7DQogfQ0KIA0KIHN0YXRpYyBpbnQgX19pbml0IGFjcGlfc2xlZXBfaW5p dCh2b2lkKQ0KZGlmZiAtciBmYzk5NWRjOTdhOTQgeGVuL2FyY2gveDg2L3BsYXRmb3JtX2h5cGVy Y2FsbC5jDQotLS0gYS94ZW4vYXJjaC94ODYvcGxhdGZvcm1faHlwZXJjYWxsLmMJTW9uIE1heSAx NCAxODoyNzo0NiAyMDA3IC0wNDAwDQorKysgYi94ZW4vYXJjaC94ODYvcGxhdGZvcm1faHlwZXJj YWxsLmMJTW9uIE1heSAxNCAxODoyOTowNiAyMDA3IC0wNDAwDQpAQCAtMTgsNiArMTgsNyBAQA0K ICNpbmNsdWRlIDx4ZW4vY29uc29sZS5oPg0KICNpbmNsdWRlIDx4ZW4vaW9jYXAuaD4NCiAjaW5j bHVkZSA8eGVuL2d1ZXN0X2FjY2Vzcy5oPg0KKyNpbmNsdWRlIDx4ZW4vYWNwaS5oPg0KICNpbmNs dWRlIDxhc20vY3VycmVudC5oPg0KICNpbmNsdWRlIDxwdWJsaWMvcGxhdGZvcm0uaD4NCiAjaW5j bHVkZSA8YXNtL210cnIuaD4NCkBAIC0xNTEsNiArMTUyLDIwIEBAIHJldF90IGRvX3BsYXRmb3Jt X29wKFhFTl9HVUVTVF9IQU5ETEUoeGUNCiAgICAgfQ0KICAgICBicmVhazsNCiANCisgICAgY2Fz ZSBYRU5QRl9zZXRfYWNwaV9zbGVlcDoNCisgICAgew0KKyAgICAgICAgcmV0ID0gc2V0X2FjcGlf c2xlZXBfaW5mbygmb3AtPnUuc2V0X2FjcGlfc2xlZXApOw0KKyAgICAgICAgaWYgKCFyZXQgJiYg Y29weV90b19ndWVzdCh1X3hlbnBmX29wLCBvcCwgMSkpDQorICAgICAgICAgICAgcmV0ID0gLUVG QVVMVDsNCisgICAgfQ0KKyAgICBicmVhazsNCisNCisgICAgY2FzZSBYRU5QRl9lbnRlcl9hY3Bp X3NsZWVwOg0KKyAgICB7DQorICAgICAgICByZXQgPSBhY3BpX2VudGVyX3NsZWVwKCZvcC0+dS5l bnRlcl9hY3BpX3NsZWVwKTsNCisgICAgfQ0KKyAgICBicmVhazsNCisNCiAgICAgZGVmYXVsdDoN CiAgICAgICAgIHJldCA9IC1FTk9TWVM7DQogICAgICAgICBicmVhazsNCmRpZmYgLXIgZmM5OTVk Yzk3YTk0IHhlbi9pbmNsdWRlL3B1YmxpYy9wbGF0Zm9ybS5oDQotLS0gYS94ZW4vaW5jbHVkZS9w dWJsaWMvcGxhdGZvcm0uaAlNb24gTWF5IDE0IDE4OjI3OjQ2IDIwMDcgLTA0MDANCisrKyBiL3hl bi9pbmNsdWRlL3B1YmxpYy9wbGF0Zm9ybS5oCU1vbiBNYXkgMTQgMTg6Mjk6MDYgMjAwNyAtMDQw MA0KQEAgLTExNCw2ICsxMTQsMzEgQEAgdHlwZWRlZiBzdHJ1Y3QgeGVucGZfcGxhdGZvcm1fcXVp cmsgeGVucA0KIHR5cGVkZWYgc3RydWN0IHhlbnBmX3BsYXRmb3JtX3F1aXJrIHhlbnBmX3BsYXRm b3JtX3F1aXJrX3Q7DQogREVGSU5FX1hFTl9HVUVTVF9IQU5ETEUoeGVucGZfcGxhdGZvcm1fcXVp cmtfdCk7DQogDQorI2RlZmluZSBYRU5QRl9zZXRfYWNwaV9zbGVlcCAgICAgIDQwDQorc3RydWN0 IHhlbnBmX3NldF9hY3BpX3NsZWVwIHsNCisgICAgLyogSU4gdmFyaWFibGVzLiAqLw0KKyAgICB1 aW50MTZfdCBwbTFhX2NudF9wb3J0Ow0KKyAgICB1aW50MTZfdCBwbTFiX2NudF9wb3J0Ow0KKyAg ICB1aW50MTZfdCBwbTFhX2V2dF9wb3J0Ow0KKyAgICB1aW50MTZfdCBwbTFiX2V2dF9wb3J0Ow0K KyAgICAvKiBPVVQgdmFyaWFibGVzICovDQorICAgIHVpbnQ2NF90IHhlbl93YWtpbmdfdmVjOyAg IC8qIFRlbGwgZG9tMCB0byBzZXQgRkFDUyB3YWtpbmcgdmVjdG9yICovDQorfTsNCit0eXBlZGVm IHN0cnVjdCB4ZW5wZl9zZXRfYWNwaV9zbGVlcCB4ZW5wZl9zZXRfYWNwaV9zbGVlcF90Ow0KK0RF RklORV9YRU5fR1VFU1RfSEFORExFKHhlbnBmX3NldF9hY3BpX3NsZWVwX3QpOw0KKw0KKyNkZWZp bmUgWEVOUEZfZW50ZXJfYWNwaV9zbGVlcCAgICA0MQ0KK3N0cnVjdCB4ZW5wZl9lbnRlcl9hY3Bp X3NsZWVwIHsNCisgICAgLyogSU4gdmFyaWFibGVzICovDQorICAgIHVpbnQxNl90IHBtMWFfY250 X3ZhbDsNCisgICAgdWludDE2X3QgcG0xYl9jbnRfdmFsOw0KKyAgICB1aW50MzJfdCBzbGVlcF9z dGF0ZTsgICAgICAgLyogV2hpY2ggc3RhdGUgdG8gZW50ZXIgKi8NCisgICAgdWludDMyX3Qgdmlk ZW9fZmxhZ3M7ICAgICAgIC8qIFMzX2Jpb3Mgb3IgczNfbW9kZSAqLw0KKyAgICB1aW50MzJfdCB2 aWRlb19tb2RlOyAgICAgICAgLyogTW9kZSBzZXR0aW5nIGZvciBzM19tb2RlICovDQorfTsNCit0 eXBlZGVmIHN0cnVjdCB4ZW5wZl9lbnRlcl9hY3BpX3NsZWVwIHhlbnBmX2VudGVyX2FjcGlfc2xl ZXBfdDsNCitERUZJTkVfWEVOX0dVRVNUX0hBTkRMRSh4ZW5wZl9lbnRlcl9hY3BpX3NsZWVwX3Qp Ow0KKw0KIHN0cnVjdCB4ZW5fcGxhdGZvcm1fb3Agew0KICAgICB1aW50MzJfdCBjbWQ7DQogICAg IHVpbnQzMl90IGludGVyZmFjZV92ZXJzaW9uOyAvKiBYRU5QRl9JTlRFUkZBQ0VfVkVSU0lPTiAq Lw0KQEAgLTEyNCw2ICsxNDksOCBAQCBzdHJ1Y3QgeGVuX3BsYXRmb3JtX29wIHsNCiAgICAgICAg IHN0cnVjdCB4ZW5wZl9yZWFkX21lbXR5cGUgICAgICByZWFkX21lbXR5cGU7DQogICAgICAgICBz dHJ1Y3QgeGVucGZfbWljcm9jb2RlX3VwZGF0ZSAgbWljcm9jb2RlOw0KICAgICAgICAgc3RydWN0 IHhlbnBmX3BsYXRmb3JtX3F1aXJrICAgIHBsYXRmb3JtX3F1aXJrOw0KKyAgICAgICAgc3RydWN0 IHhlbnBmX3NldF9hY3BpX3NsZWVwICAgIHNldF9hY3BpX3NsZWVwOw0KKyAgICAgICAgc3RydWN0 IHhlbnBmX2VudGVyX2FjcGlfc2xlZXAgIGVudGVyX2FjcGlfc2xlZXA7DQogICAgICAgICB1aW50 OF90ICAgICAgICAgICAgICAgICAgICAgICAgcGFkWzEyOF07DQogICAgIH0gdTsNCiB9Ow0KZGlm ZiAtciBmYzk5NWRjOTdhOTQgeGVuL2luY2x1ZGUveGVuL2FjcGkuaA0KLS0tIGEveGVuL2luY2x1 ZGUveGVuL2FjcGkuaAlNb24gTWF5IDE0IDE4OjI3OjQ2IDIwMDcgLTA0MDANCisrKyBiL3hlbi9p bmNsdWRlL3hlbi9hY3BpLmgJTW9uIE1heSAxNCAxODoyOTowNiAyMDA3IC0wNDAwDQpAQCAtNTM1 LDQgKzUzNSwxNSBAQCBzdGF0aWMgaW5saW5lIGludCBhY3BpX2dldF9weG0oYWNwaV9oYW5kDQog DQogZXh0ZXJuIGludCBwbnBhY3BpX2Rpc2FibGVkOw0KIA0KKyNpbmNsdWRlIDxwdWJsaWMvcGxh dGZvcm0uaD4NCisjaWZkZWYgQ09NUEFUDQorI2RlZmluZSB4ZW5wZl9zZXRfYWNwaV9zbGVlcCBj b21wYXRfcGZfc2V0X2FjcGlfc2xlZXANCisjZGVmaW5lIHhlbnBmX2VudGVyX2FjcGlfc2xlZXAg Y29tcGF0X3BmX2VudGVyX2FjcGlfc2xlZXANCisjZW5kaWYgLyogQ09NUEFUICovDQorDQorZXh0 ZXJuIHVuc2lnbmVkIGxvbmcgYWNwaV92aWRlb19mbGFnczsNCitleHRlcm4gdW5zaWduZWQgbG9u ZyBzYXZlZF92aWRlb21vZGU7DQorZXh0ZXJuIGludCBzZXRfYWNwaV9zbGVlcF9pbmZvKHN0cnVj dCB4ZW5wZl9zZXRfYWNwaV9zbGVlcCAqaW5mbyk7DQorZXh0ZXJuIGludCBhY3BpX2VudGVyX3Ns ZWVwKHN0cnVjdCB4ZW5wZl9lbnRlcl9hY3BpX3NsZWVwICpzbGVlcCk7DQorZXh0ZXJuIGludCBh Y3BpX2VudGVyX3N0YXRlKHUzMiBzdGF0ZSk7DQogI2VuZGlmIC8qX0xJTlVYX0FDUElfSCovDQo= ------_=_NextPart_001_01C796FB.BFDF6E1F 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 ------_=_NextPart_001_01C796FB.BFDF6E1F--