From mboxrd@z Thu Jan 1 00:00:00 1970 From: Juergen Gross Subject: [PATCH v4 01/19] xen: add some xen headers Date: Fri, 2 Nov 2018 13:37:20 +0100 Message-ID: <20181102123738.16395-2-jgross@suse.com> References: <20181102123738.16395-1-jgross@suse.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20181102123738.16395-1-jgross@suse.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: grub-devel@gnu.org Cc: hans@knorrie.org, phcoder@gmail.com, daniel.kiper@oracle.com, Juergen Gross , xen-devel@lists.xen.org List-Id: xen-devel@lists.xenproject.org SW4gb3JkZXIgdG8gc3VwcG9ydCBncnViMiBpbiBYZW4gUFZIIGVudmlyb25tZW50IHNvbWUgYWRk aXRpb25hbCBYZW4KaGVhZGVycyBhcmUgbmVlZGVkIGFzIGdydWIyIHdpbGwgYmUgc3RhcnRlZCBp biBQVkggbW9kZSByZXF1aXJpbmcgdG8KdXNlIHNldmVyYWwgSFZNIGh5cGVyY2FsbHMgYW5kIHN0 cnVjdHVyZXMuCgpBZGQgdGhlIG5lZWRlZCBoZWFkZXJzIGZyb20gWGVuIDQuMTAgYmVpbmcgdGhl IGZpcnN0IFhlbiB2ZXJzaW9uIHdpdGgKZnVsbCAobm90IG9ubHkgZXhwZXJpbWVudGFsKSBQVkgg Z3Vlc3Qgc3VwcG9ydC4KClNpZ25lZC1vZmYtYnk6IEp1ZXJnZW4gR3Jvc3MgPGpncm9zc0BzdXNl LmNvbT4KUmV2aWV3ZWQtYnk6IERhbmllbCBLaXBlciA8ZGFuaWVsLmtpcGVyQG9yYWNsZS5jb20+ Ci0tLQpWMjogdXBkYXRlIGNvbW1pdCBtZXNzYWdlIChEYW5pZWwgS2lwZXIpCi0tLQogaW5jbHVk ZS94ZW4vaHZtL2h2bV9vcC5oICAgICB8IDI5NiArKysrKysrKysrKysrKysrKysrCiBpbmNsdWRl L3hlbi9odm0vcGFyYW1zLmggICAgIHwgMjg0ICsrKysrKysrKysrKysrKysrKwogaW5jbHVkZS94 ZW4vaHZtL3N0YXJ0X2luZm8uaCB8ICA5OCArKysrKysrCiBpbmNsdWRlL3hlbi9tZW1vcnkuaCAg ICAgICAgIHwgNjY1ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysK IGluY2x1ZGUveGVuL3BoeXNkZXYuaCAgICAgICAgfCAzODcgKysrKysrKysrKysrKysrKysrKysr KysrKwogaW5jbHVkZS94ZW4vdHJhY2UuaCAgICAgICAgICB8IDMzOSArKysrKysrKysrKysrKysr KysrKysrCiBpbmNsdWRlL3hlbi94ZW4uaCAgICAgICAgICAgIHwgMTA0ICsrKysrLS0KIDcgZmls ZXMgY2hhbmdlZCwgMjE0MiBpbnNlcnRpb25zKCspLCAzMSBkZWxldGlvbnMoLSkKIGNyZWF0ZSBt b2RlIDEwMDY0NCBpbmNsdWRlL3hlbi9odm0vaHZtX29wLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBp bmNsdWRlL3hlbi9odm0vcGFyYW1zLmgKIGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL3hlbi9o dm0vc3RhcnRfaW5mby5oCiBjcmVhdGUgbW9kZSAxMDA2NDQgaW5jbHVkZS94ZW4vbWVtb3J5LmgK IGNyZWF0ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL3hlbi9waHlzZGV2LmgKIGNyZWF0ZSBtb2RlIDEw MDY0NCBpbmNsdWRlL3hlbi90cmFjZS5oCgpkaWZmIC0tZ2l0IGEvaW5jbHVkZS94ZW4vaHZtL2h2 bV9vcC5oIGIvaW5jbHVkZS94ZW4vaHZtL2h2bV9vcC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMC4uMGJkYWZkZjU5Ci0tLSAvZGV2L251bGwKKysrIGIvaW5jbHVkZS94ZW4v aHZtL2h2bV9vcC5oCkBAIC0wLDAgKzEsMjk2IEBACisvKgorICogUGVybWlzc2lvbiBpcyBoZXJl YnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24gb2J0YWluaW5nIGEgY29w eQorICogb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1bWVudGF0aW9uIGZpbGVz ICh0aGUgIlNvZnR3YXJlIiksIHRvCisgKiBkZWFsIGluIHRoZSBTb2Z0d2FyZSB3aXRob3V0IHJl c3RyaWN0aW9uLCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uIHRoZQorICogcmlnaHRzIHRv IHVzZSwgY29weSwgbW9kaWZ5LCBtZXJnZSwgcHVibGlzaCwgZGlzdHJpYnV0ZSwgc3VibGljZW5z ZSwgYW5kL29yCisgKiBzZWxsIGNvcGllcyBvZiB0aGUgU29mdHdhcmUsIGFuZCB0byBwZXJtaXQg cGVyc29ucyB0byB3aG9tIHRoZSBTb2Z0d2FyZSBpcworICogZnVybmlzaGVkIHRvIGRvIHNvLCBz dWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKKyAqCisgKiBUaGUgYWJvdmUgY29w eXJpZ2h0IG5vdGljZSBhbmQgdGhpcyBwZXJtaXNzaW9uIG5vdGljZSBzaGFsbCBiZSBpbmNsdWRl ZCBpbgorICogYWxsIGNvcGllcyBvciBzdWJzdGFudGlhbCBwb3J0aW9ucyBvZiB0aGUgU29mdHdh cmUuCisgKgorICogVEhFIFNPRlRXQVJFIElTIFBST1ZJREVEICJBUyBJUyIsIFdJVEhPVVQgV0FS UkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1IKKyAqIElNUExJRUQsIElOQ0xVRElORyBCVVQg Tk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZLAorICogRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJTkdFTUVOVC4gSU4gTk8g RVZFTlQgU0hBTEwgVEhFCisgKiBBVVRIT1JTIE9SIENPUFlSSUdIVCBIT0xERVJTIEJFIExJQUJM RSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSCisgKiBMSUFCSUxJVFksIFdIRVRIRVIg SU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lTRSwgQVJJU0lORworICog RlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09GVFdBUkUgT1IgVEhFIFVT RSBPUiBPVEhFUgorICogREVBTElOR1MgSU4gVEhFIFNPRlRXQVJFLgorICoKKyAqIENvcHlyaWdo dCAoYykgMjAwNywgS2VpciBGcmFzZXIKKyAqLworCisjaWZuZGVmIF9fWEVOX1BVQkxJQ19IVk1f SFZNX09QX0hfXworI2RlZmluZSBfX1hFTl9QVUJMSUNfSFZNX0hWTV9PUF9IX18KKworI2luY2x1 ZGUgIi4uL3hlbi5oIgorI2luY2x1ZGUgIi4uL3RyYWNlLmgiCisjaW5jbHVkZSAiLi4vZXZlbnRf Y2hhbm5lbC5oIgorCisvKiBHZXQvc2V0IHN1YmNvbW1hbmRzOiBleHRyYSBhcmd1bWVudCA9PSBw b2ludGVyIHRvIHhlbl9odm1fcGFyYW0gc3RydWN0LiAqLworI2RlZmluZSBIVk1PUF9zZXRfcGFy YW0gICAgICAgICAgIDAKKyNkZWZpbmUgSFZNT1BfZ2V0X3BhcmFtICAgICAgICAgICAxCitzdHJ1 Y3QgeGVuX2h2bV9wYXJhbSB7CisgICAgZG9taWRfdCAgZG9taWQ7ICAgIC8qIElOICovCisgICAg dWludDMyX3QgaW5kZXg7ICAgIC8qIElOICovCisgICAgdWludDY0X3QgdmFsdWU7ICAgIC8qIElO L09VVCAqLworfTsKK3R5cGVkZWYgc3RydWN0IHhlbl9odm1fcGFyYW0geGVuX2h2bV9wYXJhbV90 OworREVGSU5FX1hFTl9HVUVTVF9IQU5ETEUoeGVuX2h2bV9wYXJhbV90KTsKKworI2lmIF9fWEVO X0lOVEVSRkFDRV9WRVJTSU9OX18gPCAweDAwMDQwOTAwCisKKy8qIFNldCB0aGUgbG9naWNhbCBs ZXZlbCBvZiBvbmUgb2YgYSBkb21haW4ncyBQQ0kgSU5UeCB3aXJlcy4gKi8KKyNkZWZpbmUgSFZN T1Bfc2V0X3BjaV9pbnR4X2xldmVsICAyCitzdHJ1Y3QgeGVuX2h2bV9zZXRfcGNpX2ludHhfbGV2 ZWwgeworICAgIC8qIERvbWFpbiB0byBiZSB1cGRhdGVkLiAqLworICAgIGRvbWlkX3QgIGRvbWlk OworICAgIC8qIFBDSSBJTlR4IGlkZW50aWZpY2F0aW9uIGluIFBDSSB0b3BvbG9neSAoZG9tYWlu OmJ1czpkZXZpY2U6aW50eCkuICovCisgICAgdWludDhfdCAgZG9tYWluLCBidXMsIGRldmljZSwg aW50eDsKKyAgICAvKiBBc3NlcnRpb24gbGV2ZWwgKDAgPSB1bmFzc2VydGVkLCAxID0gYXNzZXJ0 ZWQpLiAqLworICAgIHVpbnQ4X3QgIGxldmVsOworfTsKK3R5cGVkZWYgc3RydWN0IHhlbl9odm1f c2V0X3BjaV9pbnR4X2xldmVsIHhlbl9odm1fc2V0X3BjaV9pbnR4X2xldmVsX3Q7CitERUZJTkVf WEVOX0dVRVNUX0hBTkRMRSh4ZW5faHZtX3NldF9wY2lfaW50eF9sZXZlbF90KTsKKworLyogU2V0 IHRoZSBsb2dpY2FsIGxldmVsIG9mIG9uZSBvZiBhIGRvbWFpbidzIElTQSBJUlEgd2lyZXMuICov CisjZGVmaW5lIEhWTU9QX3NldF9pc2FfaXJxX2xldmVsICAgMworc3RydWN0IHhlbl9odm1fc2V0 X2lzYV9pcnFfbGV2ZWwgeworICAgIC8qIERvbWFpbiB0byBiZSB1cGRhdGVkLiAqLworICAgIGRv bWlkX3QgIGRvbWlkOworICAgIC8qIElTQSBkZXZpY2UgaWRlbnRpZmljYXRpb24sIGJ5IElTQSBJ UlEgKDAtMTUpLiAqLworICAgIHVpbnQ4X3QgIGlzYV9pcnE7CisgICAgLyogQXNzZXJ0aW9uIGxl dmVsICgwID0gdW5hc3NlcnRlZCwgMSA9IGFzc2VydGVkKS4gKi8KKyAgICB1aW50OF90ICBsZXZl bDsKK307Cit0eXBlZGVmIHN0cnVjdCB4ZW5faHZtX3NldF9pc2FfaXJxX2xldmVsIHhlbl9odm1f c2V0X2lzYV9pcnFfbGV2ZWxfdDsKK0RFRklORV9YRU5fR1VFU1RfSEFORExFKHhlbl9odm1fc2V0 X2lzYV9pcnFfbGV2ZWxfdCk7CisKKyNkZWZpbmUgSFZNT1Bfc2V0X3BjaV9saW5rX3JvdXRlICA0 CitzdHJ1Y3QgeGVuX2h2bV9zZXRfcGNpX2xpbmtfcm91dGUgeworICAgIC8qIERvbWFpbiB0byBi ZSB1cGRhdGVkLiAqLworICAgIGRvbWlkX3QgIGRvbWlkOworICAgIC8qIFBDSSBsaW5rIGlkZW50 aWZpZXIgKDAtMykuICovCisgICAgdWludDhfdCAgbGluazsKKyAgICAvKiBJU0EgSVJRICgxLTE1 KSwgb3IgMCAoZGlzYWJsZSBsaW5rKS4gKi8KKyAgICB1aW50OF90ICBpc2FfaXJxOworfTsKK3R5 cGVkZWYgc3RydWN0IHhlbl9odm1fc2V0X3BjaV9saW5rX3JvdXRlIHhlbl9odm1fc2V0X3BjaV9s aW5rX3JvdXRlX3Q7CitERUZJTkVfWEVOX0dVRVNUX0hBTkRMRSh4ZW5faHZtX3NldF9wY2lfbGlu a19yb3V0ZV90KTsKKworI2VuZGlmIC8qIF9fWEVOX0lOVEVSRkFDRV9WRVJTSU9OX18gPCAweDAw MDQwOTAwICovCisKKy8qIEZsdXNoZXMgYWxsIFZDUFUgVExCczogQGFyZyBtdXN0IGJlIE5VTEwu ICovCisjZGVmaW5lIEhWTU9QX2ZsdXNoX3RsYnMgICAgICAgICAgNQorCit0eXBlZGVmIGVudW0g eworICAgIEhWTU1FTV9yYW1fcncsICAgICAgICAgICAgIC8qIE5vcm1hbCByZWFkL3dyaXRlIGd1 ZXN0IFJBTSAqLworICAgIEhWTU1FTV9yYW1fcm8sICAgICAgICAgICAgIC8qIFJlYWQtb25seTsg d3JpdGVzIGFyZSBkaXNjYXJkZWQgKi8KKyAgICBIVk1NRU1fbW1pb19kbSwgICAgICAgICAgICAv KiBSZWFkcyBhbmQgd3JpdGUgZ28gdG8gdGhlIGRldmljZSBtb2RlbCAqLworI2lmIF9fWEVOX0lO VEVSRkFDRV9WRVJTSU9OX18gPCAweDAwMDQwNzAwCisgICAgSFZNTUVNX21taW9fd3JpdGVfZG0s ICAgICAgLyogUmVhZC1vbmx5OyB3cml0ZXMgZ28gdG8gdGhlIGRldmljZSBtb2RlbCAqLworI2Vs c2UKKyAgICBIVk1NRU1fdW51c2VkLCAgICAgICAgICAgICAvKiBQbGFjZWhvbGRlcjsgc2V0dGlu ZyBtZW1vcnkgdG8gdGhpcyB0eXBlCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg d2lsbCBmYWlsIGZvciBjb2RlIGFmdGVyIDQuNy4wICovCisjZW5kaWYKKyAgICBIVk1NRU1faW9y ZXFfc2VydmVyICAgICAgICAvKiBNZW1vcnkgdHlwZSBjbGFpbWVkIGJ5IGFuIGlvcmVxIHNlcnZl cjsgdHlwZQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNoYW5nZXMgdG8gdGhp cyB2YWx1ZSBhcmUgb25seSBhbGxvd2VkIGFmdGVyCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgYW4gaW9yZXEgc2VydmVyIGhhcyBjbGFpbWVkIGl0cyBvd25lcnNoaXAuCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgT25seSBwYWdlcyB3aXRoIEhWTU1FTV9yYW1f cncgYXJlIGFsbG93ZWQgdG8KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjaGFu Z2UgdG8gdGhpcyB0eXBlOyBjb252ZXJzZWx5LCBwYWdlcyB3aXRoCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgdGhpcyB0eXBlIGFyZSBvbmx5IGFsbG93ZWQgdG8gYmUgY2hhbmdl ZCBiYWNrCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgdG8gSFZNTUVNX3JhbV9y dy4gKi8KK30gaHZtbWVtX3R5cGVfdDsKKworLyogSGludCBmcm9tIFBWIGRyaXZlcnMgZm9yIHBh Z2V0YWJsZSBkZXN0cnVjdGlvbi4gKi8KKyNkZWZpbmUgSFZNT1BfcGFnZXRhYmxlX2R5aW5nICAg ICAgICA5CitzdHJ1Y3QgeGVuX2h2bV9wYWdldGFibGVfZHlpbmcgeworICAgIC8qIERvbWFpbiB3 aXRoIGEgcGFnZXRhYmxlIGFib3V0IHRvIGJlIGRlc3Ryb3llZC4gKi8KKyAgICBkb21pZF90ICBk b21pZDsKKyAgICB1aW50MTZfdCBwYWRbM107IC8qIGFsaWduIG5leHQgZmllbGQgb24gOC1ieXRl IGJvdW5kYXJ5ICovCisgICAgLyogZ3Vlc3QgcGh5c2ljYWwgYWRkcmVzcyBvZiB0aGUgdG9wbGV2 ZWwgcGFnZXRhYmxlIGR5aW5nICovCisgICAgdWludDY0X3QgZ3BhOworfTsKK3R5cGVkZWYgc3Ry dWN0IHhlbl9odm1fcGFnZXRhYmxlX2R5aW5nIHhlbl9odm1fcGFnZXRhYmxlX2R5aW5nX3Q7CitE RUZJTkVfWEVOX0dVRVNUX0hBTkRMRSh4ZW5faHZtX3BhZ2V0YWJsZV9keWluZ190KTsKKworLyog R2V0IHRoZSBjdXJyZW50IFhlbiB0aW1lLCBpbiBuYW5vc2Vjb25kcyBzaW5jZSBzeXN0ZW0gYm9v dC4gKi8KKyNkZWZpbmUgSFZNT1BfZ2V0X3RpbWUgICAgICAgICAgICAgIDEwCitzdHJ1Y3QgeGVu X2h2bV9nZXRfdGltZSB7CisgICAgdWludDY0X3Qgbm93OyAgICAgIC8qIE9VVCAqLworfTsKK3R5 cGVkZWYgc3RydWN0IHhlbl9odm1fZ2V0X3RpbWUgeGVuX2h2bV9nZXRfdGltZV90OworREVGSU5F X1hFTl9HVUVTVF9IQU5ETEUoeGVuX2h2bV9nZXRfdGltZV90KTsKKworI2RlZmluZSBIVk1PUF94 ZW50cmFjZSAgICAgICAgICAgICAgMTEKK3N0cnVjdCB4ZW5faHZtX3hlbnRyYWNlIHsKKyAgICB1 aW50MTZfdCBldmVudCwgZXh0cmFfYnl0ZXM7CisgICAgdWludDhfdCBleHRyYVtUUkFDRV9FWFRS QV9NQVggKiBzaXplb2YodWludDMyX3QpXTsKK307Cit0eXBlZGVmIHN0cnVjdCB4ZW5faHZtX3hl bnRyYWNlIHhlbl9odm1feGVudHJhY2VfdDsKK0RFRklORV9YRU5fR1VFU1RfSEFORExFKHhlbl9o dm1feGVudHJhY2VfdCk7CisKKy8qIEZvbGxvd2luZyB0b29scy1vbmx5IGludGVyZmFjZXMgbWF5 IGNoYW5nZSBpbiBmdXR1cmUuICovCisjaWYgZGVmaW5lZChfX1hFTl9fKSB8fCBkZWZpbmVkKF9f WEVOX1RPT0xTX18pCisKKy8qIERlcHJlY2F0ZWQgYnkgWEVOTUVNX2FjY2Vzc19vcF9zZXRfYWNj ZXNzICovCisjZGVmaW5lIEhWTU9QX3NldF9tZW1fYWNjZXNzICAgICAgICAxMgorCisvKiBEZXBy ZWNhdGVkIGJ5IFhFTk1FTV9hY2Nlc3Nfb3BfZ2V0X2FjY2VzcyAqLworI2RlZmluZSBIVk1PUF9n ZXRfbWVtX2FjY2VzcyAgICAgICAgMTMKKworI2VuZGlmIC8qIGRlZmluZWQoX19YRU5fXykgfHwg ZGVmaW5lZChfX1hFTl9UT09MU19fKSAqLworCisjZGVmaW5lIEhWTU9QX2dldF9tZW1fdHlwZSAg ICAxNQorLyogUmV0dXJuIGh2bW1lbV90eXBlX3QgZm9yIHRoZSBzcGVjaWZpZWQgcGZuLiAqLwor c3RydWN0IHhlbl9odm1fZ2V0X21lbV90eXBlIHsKKyAgICAvKiBEb21haW4gdG8gYmUgcXVlcmll ZC4gKi8KKyAgICBkb21pZF90IGRvbWlkOworICAgIC8qIE9VVCB2YXJpYWJsZS4gKi8KKyAgICB1 aW50MTZfdCBtZW1fdHlwZTsKKyAgICB1aW50MTZfdCBwYWRbMl07IC8qIGFsaWduIG5leHQgZmll bGQgb24gOC1ieXRlIGJvdW5kYXJ5ICovCisgICAgLyogSU4gdmFyaWFibGUuICovCisgICAgdWlu dDY0X3QgcGZuOworfTsKK3R5cGVkZWYgc3RydWN0IHhlbl9odm1fZ2V0X21lbV90eXBlIHhlbl9o dm1fZ2V0X21lbV90eXBlX3Q7CitERUZJTkVfWEVOX0dVRVNUX0hBTkRMRSh4ZW5faHZtX2dldF9t ZW1fdHlwZV90KTsKKworLyogRm9sbG93aW5nIHRvb2xzLW9ubHkgaW50ZXJmYWNlcyBtYXkgY2hh bmdlIGluIGZ1dHVyZS4gKi8KKyNpZiBkZWZpbmVkKF9fWEVOX18pIHx8IGRlZmluZWQoX19YRU5f VE9PTFNfXykKKworLyoKKyAqIERlZmluaXRpb25zIHJlbGF0aW5nIHRvIERNT1BfY3JlYXRlX2lv cmVxX3NlcnZlci4gKERlZmluZWQgaGVyZSBmb3IKKyAqIGJhY2t3YXJkcyBjb21wYXRpYmlsaXR5 KS4KKyAqLworCisjZGVmaW5lIEhWTV9JT1JFUVNSVl9CVUZJT1JFUV9PRkYgICAgMAorI2RlZmlu ZSBIVk1fSU9SRVFTUlZfQlVGSU9SRVFfTEVHQUNZIDEKKy8qCisgKiBVc2UgdGhpcyB3aGVuIHJl YWRfcG9pbnRlciBnZXRzIHVwZGF0ZWQgYXRvbWljYWxseSBhbmQKKyAqIHRoZSBwb2ludGVyIHBh aXIgZ2V0cyByZWFkIGF0b21pY2FsbHk6CisgKi8KKyNkZWZpbmUgSFZNX0lPUkVRU1JWX0JVRklP UkVRX0FUT01JQyAyCisKKyNlbmRpZiAvKiBkZWZpbmVkKF9fWEVOX18pIHx8IGRlZmluZWQoX19Y RU5fVE9PTFNfXykgKi8KKworI2lmIGRlZmluZWQoX19pMzg2X18pIHx8IGRlZmluZWQoX194ODZf NjRfXykKKworLyoKKyAqIEhWTU9QX3NldF9ldnRjaG5fdXBjYWxsX3ZlY3RvcjogU2V0IGEgPHZl Y3Rvcj4gdGhhdCBzaG91bGQgYmUgdXNlZCBmb3IgZXZlbnQKKyAqICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgY2hhbm5lbCB1cGNhbGxzIG9uIHRoZSBzcGVjaWZpZWQgPHZjcHU+LiBJ ZiBzZXQsCisgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHRoaXMgdmVjdG9yIHdp bGwgYmUgdXNlZCBpbiBwcmVmZXJlbmNlIHRvIHRoZQorICogICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICBkb21haW4gZ2xvYmFsIGNhbGxiYWNrIHZpYSAoc2VlCisgKiAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIEhWTV9QQVJBTV9DQUxMQkFDS19JUlEpLgorICovCisjZGVm aW5lIEhWTU9QX3NldF9ldnRjaG5fdXBjYWxsX3ZlY3RvciAyMworc3RydWN0IHhlbl9odm1fZXZ0 Y2huX3VwY2FsbF92ZWN0b3IgeworICAgIHVpbnQzMl90IHZjcHU7CisgICAgdWludDhfdCB2ZWN0 b3I7Cit9OwordHlwZWRlZiBzdHJ1Y3QgeGVuX2h2bV9ldnRjaG5fdXBjYWxsX3ZlY3RvciB4ZW5f aHZtX2V2dGNobl91cGNhbGxfdmVjdG9yX3Q7CitERUZJTkVfWEVOX0dVRVNUX0hBTkRMRSh4ZW5f aHZtX2V2dGNobl91cGNhbGxfdmVjdG9yX3QpOworCisjZW5kaWYgLyogZGVmaW5lZChfX2kzODZf XykgfHwgZGVmaW5lZChfX3g4Nl82NF9fKSAqLworCisjZGVmaW5lIEhWTU9QX2d1ZXN0X3JlcXVl c3Rfdm1fZXZlbnQgMjQKKworLyogSFZNT1BfYWx0cDJtOiBwZXJmb3JtIGFsdHAybSBzdGF0ZSBv cGVyYXRpb25zICovCisjZGVmaW5lIEhWTU9QX2FsdHAybSAyNQorCisjZGVmaW5lIEhWTU9QX0FM VFAyTV9JTlRFUkZBQ0VfVkVSU0lPTiAweDAwMDAwMDAxCisKK3N0cnVjdCB4ZW5faHZtX2FsdHAy bV9kb21haW5fc3RhdGUgeworICAgIC8qIElOIG9yIE9VVCB2YXJpYWJsZSBvbi9vZmYgKi8KKyAg ICB1aW50OF90IHN0YXRlOworfTsKK3R5cGVkZWYgc3RydWN0IHhlbl9odm1fYWx0cDJtX2RvbWFp bl9zdGF0ZSB4ZW5faHZtX2FsdHAybV9kb21haW5fc3RhdGVfdDsKK0RFRklORV9YRU5fR1VFU1Rf SEFORExFKHhlbl9odm1fYWx0cDJtX2RvbWFpbl9zdGF0ZV90KTsKKworc3RydWN0IHhlbl9odm1f YWx0cDJtX3ZjcHVfZW5hYmxlX25vdGlmeSB7CisgICAgdWludDMyX3QgdmNwdV9pZDsKKyAgICB1 aW50MzJfdCBwYWQ7CisgICAgLyogI1ZFIGluZm8gYXJlYSBnZm4gKi8KKyAgICB1aW50NjRfdCBn Zm47Cit9OwordHlwZWRlZiBzdHJ1Y3QgeGVuX2h2bV9hbHRwMm1fdmNwdV9lbmFibGVfbm90aWZ5 IHhlbl9odm1fYWx0cDJtX3ZjcHVfZW5hYmxlX25vdGlmeV90OworREVGSU5FX1hFTl9HVUVTVF9I QU5ETEUoeGVuX2h2bV9hbHRwMm1fdmNwdV9lbmFibGVfbm90aWZ5X3QpOworCitzdHJ1Y3QgeGVu X2h2bV9hbHRwMm1fdmlldyB7CisgICAgLyogSU4vT1VUIHZhcmlhYmxlICovCisgICAgdWludDE2 X3QgdmlldzsKKyAgICAvKiBDcmVhdGUgdmlldyBvbmx5OiBkZWZhdWx0IGFjY2VzcyB0eXBlCisg ICAgICogTk9URTogY3VycmVudGx5IGlnbm9yZWQgKi8KKyAgICB1aW50MTZfdCBodm1tZW1fZGVm YXVsdF9hY2Nlc3M7IC8qIHhlbm1lbV9hY2Nlc3NfdCAqLworfTsKK3R5cGVkZWYgc3RydWN0IHhl bl9odm1fYWx0cDJtX3ZpZXcgeGVuX2h2bV9hbHRwMm1fdmlld190OworREVGSU5FX1hFTl9HVUVT VF9IQU5ETEUoeGVuX2h2bV9hbHRwMm1fdmlld190KTsKKworc3RydWN0IHhlbl9odm1fYWx0cDJt X3NldF9tZW1fYWNjZXNzIHsKKyAgICAvKiB2aWV3ICovCisgICAgdWludDE2X3QgdmlldzsKKyAg ICAvKiBNZW1vcnkgdHlwZSAqLworICAgIHVpbnQxNl90IGh2bW1lbV9hY2Nlc3M7IC8qIHhlbm1l bV9hY2Nlc3NfdCAqLworICAgIHVpbnQzMl90IHBhZDsKKyAgICAvKiBnZm4gKi8KKyAgICB1aW50 NjRfdCBnZm47Cit9OwordHlwZWRlZiBzdHJ1Y3QgeGVuX2h2bV9hbHRwMm1fc2V0X21lbV9hY2Nl c3MgeGVuX2h2bV9hbHRwMm1fc2V0X21lbV9hY2Nlc3NfdDsKK0RFRklORV9YRU5fR1VFU1RfSEFO RExFKHhlbl9odm1fYWx0cDJtX3NldF9tZW1fYWNjZXNzX3QpOworCitzdHJ1Y3QgeGVuX2h2bV9h bHRwMm1fY2hhbmdlX2dmbiB7CisgICAgLyogdmlldyAqLworICAgIHVpbnQxNl90IHZpZXc7Cisg ICAgdWludDE2X3QgcGFkMTsKKyAgICB1aW50MzJfdCBwYWQyOworICAgIC8qIG9sZCBnZm4gKi8K KyAgICB1aW50NjRfdCBvbGRfZ2ZuOworICAgIC8qIG5ldyBnZm4sIElOVkFMSURfR0ZOICh+MFVM KSBtZWFucyByZXZlcnQgKi8KKyAgICB1aW50NjRfdCBuZXdfZ2ZuOworfTsKK3R5cGVkZWYgc3Ry dWN0IHhlbl9odm1fYWx0cDJtX2NoYW5nZV9nZm4geGVuX2h2bV9hbHRwMm1fY2hhbmdlX2dmbl90 OworREVGSU5FX1hFTl9HVUVTVF9IQU5ETEUoeGVuX2h2bV9hbHRwMm1fY2hhbmdlX2dmbl90KTsK Kworc3RydWN0IHhlbl9odm1fYWx0cDJtX29wIHsKKyAgICB1aW50MzJfdCB2ZXJzaW9uOyAgIC8q IEhWTU9QX0FMVFAyTV9JTlRFUkZBQ0VfVkVSU0lPTiAqLworICAgIHVpbnQzMl90IGNtZDsKKy8q IEdldC9zZXQgdGhlIGFsdHAybSBzdGF0ZSBmb3IgYSBkb21haW4gKi8KKyNkZWZpbmUgSFZNT1Bf YWx0cDJtX2dldF9kb21haW5fc3RhdGUgICAgIDEKKyNkZWZpbmUgSFZNT1BfYWx0cDJtX3NldF9k b21haW5fc3RhdGUgICAgIDIKKy8qIFNldCB0aGUgY3VycmVudCBWQ1BVIHRvIHJlY2VpdmUgYWx0 cDJtIGV2ZW50IG5vdGlmaWNhdGlvbnMgKi8KKyNkZWZpbmUgSFZNT1BfYWx0cDJtX3ZjcHVfZW5h YmxlX25vdGlmeSAgIDMKKy8qIENyZWF0ZSBhIG5ldyB2aWV3ICovCisjZGVmaW5lIEhWTU9QX2Fs dHAybV9jcmVhdGVfcDJtICAgICAgICAgICA0CisvKiBEZXN0cm95IGEgdmlldyAqLworI2RlZmlu ZSBIVk1PUF9hbHRwMm1fZGVzdHJveV9wMm0gICAgICAgICAgNQorLyogU3dpdGNoIHZpZXcgZm9y IGFuIGVudGlyZSBkb21haW4gKi8KKyNkZWZpbmUgSFZNT1BfYWx0cDJtX3N3aXRjaF9wMm0gICAg ICAgICAgIDYKKy8qIE5vdGlmeSB0aGF0IGEgcGFnZSBvZiBtZW1vcnkgaXMgdG8gaGF2ZSBzcGVj aWZpYyBhY2Nlc3MgdHlwZXMgKi8KKyNkZWZpbmUgSFZNT1BfYWx0cDJtX3NldF9tZW1fYWNjZXNz ICAgICAgIDcKKy8qIENoYW5nZSBhIHAybSBlbnRyeSB0byBoYXZlIGEgZGlmZmVyZW50IGdmbi0+ bWZuIG1hcHBpbmcgKi8KKyNkZWZpbmUgSFZNT1BfYWx0cDJtX2NoYW5nZV9nZm4gICAgICAgICAg IDgKKyAgICBkb21pZF90IGRvbWFpbjsKKyAgICB1aW50MTZfdCBwYWQxOworICAgIHVpbnQzMl90 IHBhZDI7CisgICAgdW5pb24geworICAgICAgICBzdHJ1Y3QgeGVuX2h2bV9hbHRwMm1fZG9tYWlu X3N0YXRlICAgICAgIGRvbWFpbl9zdGF0ZTsKKyAgICAgICAgc3RydWN0IHhlbl9odm1fYWx0cDJt X3ZjcHVfZW5hYmxlX25vdGlmeSBlbmFibGVfbm90aWZ5OworICAgICAgICBzdHJ1Y3QgeGVuX2h2 bV9hbHRwMm1fdmlldyAgICAgICAgICAgICAgIHZpZXc7CisgICAgICAgIHN0cnVjdCB4ZW5faHZt X2FsdHAybV9zZXRfbWVtX2FjY2VzcyAgICAgc2V0X21lbV9hY2Nlc3M7CisgICAgICAgIHN0cnVj dCB4ZW5faHZtX2FsdHAybV9jaGFuZ2VfZ2ZuICAgICAgICAgY2hhbmdlX2dmbjsKKyAgICAgICAg dWludDhfdCBwYWRbNjRdOworICAgIH0gdTsKK307Cit0eXBlZGVmIHN0cnVjdCB4ZW5faHZtX2Fs dHAybV9vcCB4ZW5faHZtX2FsdHAybV9vcF90OworREVGSU5FX1hFTl9HVUVTVF9IQU5ETEUoeGVu X2h2bV9hbHRwMm1fb3BfdCk7CisKKyNlbmRpZiAvKiBfX1hFTl9QVUJMSUNfSFZNX0hWTV9PUF9I X18gKi8KKworLyoKKyAqIExvY2FsIHZhcmlhYmxlczoKKyAqIG1vZGU6IEMKKyAqIGMtZmlsZS1z dHlsZTogIkJTRCIKKyAqIGMtYmFzaWMtb2Zmc2V0OiA0CisgKiB0YWItd2lkdGg6IDQKKyAqIGlu ZGVudC10YWJzLW1vZGU6IG5pbAorICogRW5kOgorICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL3hl bi9odm0vcGFyYW1zLmggYi9pbmNsdWRlL3hlbi9odm0vcGFyYW1zLmgKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwLi4yZWMyZTdjODAKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNs dWRlL3hlbi9odm0vcGFyYW1zLmgKQEAgLTAsMCArMSwyODQgQEAKKy8qCisgKiBQZXJtaXNzaW9u IGlzIGhlcmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5p bmcgYSBjb3B5CisgKiBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRp b24gZmlsZXMgKHRoZSAiU29mdHdhcmUiKSwgdG8KKyAqIGRlYWwgaW4gdGhlIFNvZnR3YXJlIHdp dGhvdXQgcmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlCisgKiBy aWdodHMgdG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBz dWJsaWNlbnNlLCBhbmQvb3IKKyAqIHNlbGwgY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRv IHBlcm1pdCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3YXJlIGlzCisgKiBmdXJuaXNoZWQgdG8g ZG8gc28sIHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOgorICoKKyAqIFRoZSBh Ym92ZSBjb3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJl IGluY2x1ZGVkIGluCisgKiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRo ZSBTb2Z0d2FyZS4KKyAqCisgKiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lU SE9VVCBXQVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgorICogSU1QTElFRCwgSU5DTFVE SU5HIEJVVCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFks CisgKiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OSU5GUklOR0VNRU5U LiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUKKyAqIEFVVEhPUlMgT1IgQ09QWVJJR0hUIEhPTERFUlMg QkUgTElBQkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1IgT1RIRVIKKyAqIExJQUJJTElUWSwg V0hFVEhFUiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLCBBUklT SU5HCisgKiBGUk9NLCBPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBP UiBUSEUgVVNFIE9SIE9USEVSCisgKiBERUFMSU5HUyBJTiBUSEUgU09GVFdBUkUuCisgKgorICog Q29weXJpZ2h0IChjKSAyMDA3LCBLZWlyIEZyYXNlcgorICovCisKKyNpZm5kZWYgX19YRU5fUFVC TElDX0hWTV9QQVJBTVNfSF9fCisjZGVmaW5lIF9fWEVOX1BVQkxJQ19IVk1fUEFSQU1TX0hfXwor CisjaW5jbHVkZSAiaHZtX29wLmgiCisKKy8qCisgKiBQYXJhbWV0ZXIgc3BhY2UgZm9yIEhWTU9Q X3tzZXQsZ2V0fV9wYXJhbS4KKyAqLworCisjZGVmaW5lIEhWTV9QQVJBTV9DQUxMQkFDS19JUlEg MAorI2RlZmluZSBIVk1fUEFSQU1fQ0FMTEJBQ0tfSVJRX1RZUEVfTUFTSyB4ZW5fbWtfdWxsb25n KDB4RkYwMDAwMDAwMDAwMDAwMCkKKy8qCisgKiBIb3cgc2hvdWxkIENQVTAgZXZlbnQtY2hhbm5l bCBub3RpZmljYXRpb25zIGJlIGRlbGl2ZXJlZD8KKyAqCisgKiBJZiB2YWwgPT0gMCB0aGVuIENQ VTAgZXZlbnQtY2hhbm5lbCBub3RpZmljYXRpb25zIGFyZSBub3QgZGVsaXZlcmVkLgorICogSWYg dmFsICE9IDAsIHZhbFs2Mzo1Nl0gZW5jb2RlcyB0aGUgdHlwZSwgYXMgZm9sbG93czoKKyAqLwor CisjZGVmaW5lIEhWTV9QQVJBTV9DQUxMQkFDS19UWVBFX0dTSSAgICAgIDAKKy8qCisgKiB2YWxb NTU6MF0gaXMgYSBkZWxpdmVyeSBHU0kuICBHU0kgMCBjYW5ub3QgYmUgdXNlZCwgYXMgaXQgYWxp YXNlcyB2YWwgPT0gMCwKKyAqIGFuZCBkaXNhYmxlcyBhbGwgbm90aWZpY2F0aW9ucy4KKyAqLwor CisjZGVmaW5lIEhWTV9QQVJBTV9DQUxMQkFDS19UWVBFX1BDSV9JTlRYIDEKKy8qCisgKiB2YWxb NTU6MF0gaXMgYSBkZWxpdmVyeSBQQ0kgSU5UeCBsaW5lOgorICogRG9tYWluID0gdmFsWzQ3OjMy XSwgQnVzID0gdmFsWzMxOjE2XSBEZXZGbiA9IHZhbFsxNTo4XSwgSW50WCA9IHZhbFsxOjBdCisg Ki8KKworI2lmIGRlZmluZWQoX19pMzg2X18pIHx8IGRlZmluZWQoX194ODZfNjRfXykKKyNkZWZp bmUgSFZNX1BBUkFNX0NBTExCQUNLX1RZUEVfVkVDVE9SICAgMgorLyoKKyAqIHZhbFs3OjBdIGlz IGEgdmVjdG9yIG51bWJlci4gIENoZWNrIGZvciBYRU5GRUFUX2h2bV9jYWxsYmFja192ZWN0b3Ig dG8ga25vdworICogaWYgdGhpcyBkZWxpdmVyeSBtZXRob2QgaXMgYXZhaWxhYmxlLgorICovCisj ZWxpZiBkZWZpbmVkKF9fYXJtX18pIHx8IGRlZmluZWQoX19hYXJjaDY0X18pCisjZGVmaW5lIEhW TV9QQVJBTV9DQUxMQkFDS19UWVBFX1BQSSAgICAgIDIKKy8qCisgKiB2YWxbNTU6MTZdIG5lZWRz IHRvIGJlIHplcm8uCisgKiB2YWxbMTU6OF0gaXMgaW50ZXJydXB0IGZsYWcgb2YgdGhlIFBQSSB1 c2VkIGJ5IGV2ZW50LWNoYW5uZWw6CisgKiAgYml0IDg6IHRoZSBQUEkgaXMgZWRnZSgxKSBvciBs ZXZlbCgwKSB0cmlnZ2VyZWQKKyAqICBiaXQgOTogdGhlIFBQSSBpcyBhY3RpdmUgbG93KDEpIG9y IGhpZ2goMCkKKyAqIHZhbFs3OjBdIGlzIGEgUFBJIG51bWJlciB1c2VkIGJ5IGV2ZW50LWNoYW5u ZWwuCisgKiBUaGlzIGlzIG9ubHkgdXNlZCBieSBBUk0vQVJNNjQgYW5kIG1hc2tpbmcvZW9pIHRo ZSBpbnRlcnJ1cHQgYXNzb2NpYXRlZCB0bworICogdGhlIG5vdGlmaWNhdGlvbiBpcyBoYW5kbGVk IGJ5IHRoZSBpbnRlcnJ1cHQgY29udHJvbGxlci4KKyAqLworI2RlZmluZSBIVk1fUEFSQU1fQ0FM TEJBQ0tfVFlQRV9QUElfRkxBR19NQVNLICAgICAgMHhGRjAwCisjZGVmaW5lIEhWTV9QQVJBTV9D QUxMQkFDS19UWVBFX1BQSV9GTEFHX0xPV19MRVZFTCAyCisjZW5kaWYKKworLyoKKyAqIFRoZXNl IGFyZSBub3QgdXNlZCBieSBYZW4uIFRoZXkgYXJlIGhlcmUgZm9yIGNvbnZlbmllbmNlIG9mIEhW TS1ndWVzdAorICogeGVuYnVzIGltcGxlbWVudGF0aW9ucy4KKyAqLworI2RlZmluZSBIVk1fUEFS QU1fU1RPUkVfUEZOICAgIDEKKyNkZWZpbmUgSFZNX1BBUkFNX1NUT1JFX0VWVENITiAyCisKKyNk ZWZpbmUgSFZNX1BBUkFNX1BBRV9FTkFCTEVEICA0CisKKyNkZWZpbmUgSFZNX1BBUkFNX0lPUkVR X1BGTiAgICA1CisKKyNkZWZpbmUgSFZNX1BBUkFNX0JVRklPUkVRX1BGTiA2CisjZGVmaW5lIEhW TV9QQVJBTV9CVUZJT1JFUV9FVlRDSE4gMjYKKworI2lmIGRlZmluZWQoX19pMzg2X18pIHx8IGRl ZmluZWQoX194ODZfNjRfXykKKworLyoKKyAqIFZpcmlkaWFuIGVubGlnaHRlbm1lbnRzCisgKgor ICogKFNlZSBodHRwOi8vZG93bmxvYWQubWljcm9zb2Z0LmNvbS9kb3dubG9hZC9BL0IvNC9BQjQz QTM0RS1CREQwLTRGQTYtQkRFRi03OUVFRjE2RTg4MEIvSHlwZXJ2aXNvciUyMFRvcCUyMExldmVs JTIwRnVuY3Rpb25hbCUyMFNwZWNpZmljYXRpb24lMjB2NC4wLmRvY3gpCisgKgorICogVG8gZXhw b3NlIHZpcmlkaWFuIGVubGlnaHRlbm1lbnRzIHRvIHRoZSBndWVzdCBzZXQgdGhpcyBwYXJhbWV0 ZXIKKyAqIHRvIHRoZSBkZXNpcmVkIGZlYXR1cmUgbWFzay4gVGhlIGJhc2UgZmVhdHVyZSBzZXQg bXVzdCBiZSBwcmVzZW50CisgKiBpbiBhbnkgdmFsaWQgZmVhdHVyZSBtYXNrLgorICovCisjZGVm aW5lIEhWTV9QQVJBTV9WSVJJRElBTiAgICAgOQorCisvKiBCYXNlK0ZyZXEgdmlyaWRpYW4gZmVh dHVyZSBzZXRzOgorICoKKyAqIC0gSHlwZXJjYWxsIE1TUnMgKEhWX1g2NF9NU1JfR1VFU1RfT1Nf SUQgYW5kIEhWX1g2NF9NU1JfSFlQRVJDQUxMKQorICogLSBBUElDIGFjY2VzcyBNU1JzIChIVl9Y NjRfTVNSX0VPSSwgSFZfWDY0X01TUl9JQ1IgYW5kIEhWX1g2NF9NU1JfVFBSKQorICogLSBWaXJ0 dWFsIFByb2Nlc3NvciBpbmRleCBNU1IgKEhWX1g2NF9NU1JfVlBfSU5ERVgpCisgKiAtIFRpbWVy IGZyZXF1ZW5jeSBNU1JzIChIVl9YNjRfTVNSX1RTQ19GUkVRVUVOQ1kgYW5kCisgKiAgIEhWX1g2 NF9NU1JfQVBJQ19GUkVRVUVOQ1kpCisgKi8KKyNkZWZpbmUgX0hWTVBWX2Jhc2VfZnJlcSAwCisj ZGVmaW5lIEhWTVBWX2Jhc2VfZnJlcSAgKDEgPDwgX0hWTVBWX2Jhc2VfZnJlcSkKKworLyogRmVh dHVyZSBzZXQgbW9kaWZpY2F0aW9ucyAqLworCisvKiBEaXNhYmxlIHRpbWVyIGZyZXF1ZW5jeSBN U1JzIChIVl9YNjRfTVNSX1RTQ19GUkVRVUVOQ1kgYW5kCisgKiBIVl9YNjRfTVNSX0FQSUNfRlJF UVVFTkNZKS4KKyAqIFRoaXMgbW9kaWZpY2F0aW9uIHJlc3RvcmVzIHRoZSB2aXJpZGlhbiBmZWF0 dXJlIHNldCB0byB0aGUKKyAqIG9yaWdpbmFsICdiYXNlJyBzZXQgZXhwb3NlZCBpbiByZWxlYXNl cyBwcmlvciB0byBYZW4gNC40LgorICovCisjZGVmaW5lIF9IVk1QVl9ub19mcmVxIDEKKyNkZWZp bmUgSFZNUFZfbm9fZnJlcSAgKDEgPDwgX0hWTVBWX25vX2ZyZXEpCisKKy8qIEVuYWJsZSBQYXJ0 aXRpb24gVGltZSBSZWZlcmVuY2UgQ291bnRlciAoSFZfWDY0X01TUl9USU1FX1JFRl9DT1VOVCkg Ki8KKyNkZWZpbmUgX0hWTVBWX3RpbWVfcmVmX2NvdW50IDIKKyNkZWZpbmUgSFZNUFZfdGltZV9y ZWZfY291bnQgICgxIDw8IF9IVk1QVl90aW1lX3JlZl9jb3VudCkKKworLyogRW5hYmxlIFJlZmVy ZW5jZSBUU0MgUGFnZSAoSFZfWDY0X01TUl9SRUZFUkVOQ0VfVFNDKSAqLworI2RlZmluZSBfSFZN UFZfcmVmZXJlbmNlX3RzYyAzCisjZGVmaW5lIEhWTVBWX3JlZmVyZW5jZV90c2MgICgxIDw8IF9I Vk1QVl9yZWZlcmVuY2VfdHNjKQorCisvKiBVc2UgSHlwZXJjYWxsIGZvciByZW1vdGUgVExCIGZs dXNoICovCisjZGVmaW5lIF9IVk1QVl9oY2FsbF9yZW1vdGVfdGxiX2ZsdXNoIDQKKyNkZWZpbmUg SFZNUFZfaGNhbGxfcmVtb3RlX3RsYl9mbHVzaCAoMSA8PCBfSFZNUFZfaGNhbGxfcmVtb3RlX3Rs Yl9mbHVzaCkKKworLyogVXNlIEFQSUMgYXNzaXN0ICovCisjZGVmaW5lIF9IVk1QVl9hcGljX2Fz c2lzdCA1CisjZGVmaW5lIEhWTVBWX2FwaWNfYXNzaXN0ICgxIDw8IF9IVk1QVl9hcGljX2Fzc2lz dCkKKworLyogRW5hYmxlIGNyYXNoIE1TUnMgKi8KKyNkZWZpbmUgX0hWTVBWX2NyYXNoX2N0bCA2 CisjZGVmaW5lIEhWTVBWX2NyYXNoX2N0bCAoMSA8PCBfSFZNUFZfY3Jhc2hfY3RsKQorCisjZGVm aW5lIEhWTVBWX2ZlYXR1cmVfbWFzayBcCisgICAgICAgIChIVk1QVl9iYXNlX2ZyZXEgfCBcCisg ICAgICAgICBIVk1QVl9ub19mcmVxIHwgXAorICAgICAgICAgSFZNUFZfdGltZV9yZWZfY291bnQg fCBcCisgICAgICAgICBIVk1QVl9yZWZlcmVuY2VfdHNjIHwgXAorICAgICAgICAgSFZNUFZfaGNh bGxfcmVtb3RlX3RsYl9mbHVzaCB8IFwKKyAgICAgICAgIEhWTVBWX2FwaWNfYXNzaXN0IHwgXAor ICAgICAgICAgSFZNUFZfY3Jhc2hfY3RsKQorCisjZW5kaWYKKworLyoKKyAqIFNldCBtb2RlIGZv ciB2aXJ0dWFsIHRpbWVycyAoY3VycmVudGx5IHg4NiBvbmx5KToKKyAqICBkZWxheV9mb3JfbWlz c2VkX3RpY2tzIChkZWZhdWx0KToKKyAqICAgRG8gbm90IGFkdmFuY2UgYSB2Y3B1J3MgdGltZSBi ZXlvbmQgdGhlIGNvcnJlY3QgZGVsaXZlcnkgdGltZSBmb3IKKyAqICAgaW50ZXJydXB0cyB0aGF0 IGhhdmUgYmVlbiBtaXNzZWQgZHVlIHRvIHByZWVtcHRpb24uIERlbGl2ZXIgbWlzc2VkCisgKiAg IGludGVycnVwdHMgd2hlbiB0aGUgdmNwdSBpcyByZXNjaGVkdWxlZCBhbmQgYWR2YW5jZSB0aGUg dmNwdSdzIHZpcnR1YWwKKyAqICAgdGltZSBzdGVwd2lzZSBmb3IgZWFjaCBvbmUuCisgKiAgbm9f ZGVsYXlfZm9yX21pc3NlZF90aWNrczoKKyAqICAgQXMgYWJvdmUsIG1pc3NlZCBpbnRlcnJ1cHRz IGFyZSBkZWxpdmVyZWQsIGJ1dCBndWVzdCB0aW1lIGFsd2F5cyB0cmFja3MKKyAqICAgd2FsbGNs b2NrIChpLmUuLCByZWFsKSB0aW1lIHdoaWxlIGRvaW5nIHNvLgorICogIG5vX21pc3NlZF90aWNr c19wZW5kaW5nOgorICogICBObyBtaXNzZWQgaW50ZXJydXB0cyBhcmUgaGVsZCBwZW5kaW5nLiBJ bnN0ZWFkLCB0byBlbnN1cmUgdGlja3MgYXJlCisgKiAgIGRlbGl2ZXJlZCBhdCBzb21lIG5vbi16 ZXJvIHJhdGUsIGlmIHdlIGRldGVjdCBtaXNzZWQgdGlja3MgdGhlbiB0aGUKKyAqICAgaW50ZXJu YWwgdGljayBhbGFybSBpcyBub3QgZGlzYWJsZWQgaWYgdGhlIFZDUFUgaXMgcHJlZW1wdGVkIGR1 cmluZyB0aGUKKyAqICAgbmV4dCB0aWNrIHBlcmlvZC4KKyAqICBvbmVfbWlzc2VkX3RpY2tfcGVu ZGluZzoKKyAqICAgTWlzc2VkIGludGVycnVwdHMgYXJlIGNvbGxhcHNlZCB0b2dldGhlciBhbmQg ZGVsaXZlcmVkIGFzIG9uZSAnbGF0ZSB0aWNrJy4KKyAqICAgR3Vlc3QgdGltZSBhbHdheXMgdHJh Y2tzIHdhbGxjbG9jayAoaS5lLiwgcmVhbCkgdGltZS4KKyAqLworI2RlZmluZSBIVk1fUEFSQU1f VElNRVJfTU9ERSAgIDEwCisjZGVmaW5lIEhWTVBUTV9kZWxheV9mb3JfbWlzc2VkX3RpY2tzICAg IDAKKyNkZWZpbmUgSFZNUFRNX25vX2RlbGF5X2Zvcl9taXNzZWRfdGlja3MgMQorI2RlZmluZSBI Vk1QVE1fbm9fbWlzc2VkX3RpY2tzX3BlbmRpbmcgICAyCisjZGVmaW5lIEhWTVBUTV9vbmVfbWlz c2VkX3RpY2tfcGVuZGluZyAgIDMKKworLyogQm9vbGVhbjogRW5hYmxlIHZpcnR1YWwgSFBFVCAo aGlnaC1wcmVjaXNpb24gZXZlbnQgdGltZXIpPyAoeDg2LW9ubHkpICovCisjZGVmaW5lIEhWTV9Q QVJBTV9IUEVUX0VOQUJMRUQgMTEKKworLyogSWRlbnRpdHktbWFwIHBhZ2UgZGlyZWN0b3J5IHVz ZWQgYnkgSW50ZWwgRVBUIHdoZW4gQ1IwLlBHPTAuICovCisjZGVmaW5lIEhWTV9QQVJBTV9JREVO VF9QVCAgICAgMTIKKworLyogRGV2aWNlIE1vZGVsIGRvbWFpbiwgZGVmYXVsdHMgdG8gMC4gKi8K KyNkZWZpbmUgSFZNX1BBUkFNX0RNX0RPTUFJTiAgICAxMworCisvKiBBQ1BJIFMgc3RhdGU6IGN1 cnJlbnRseSBzdXBwb3J0IFMwIGFuZCBTMyBvbiB4ODYuICovCisjZGVmaW5lIEhWTV9QQVJBTV9B Q1BJX1NfU1RBVEUgMTQKKworLyogVFNTIHVzZWQgb24gSW50ZWwgd2hlbiBDUjAuUEU9MC4gKi8K KyNkZWZpbmUgSFZNX1BBUkFNX1ZNODZfVFNTICAgICAxNQorCisvKiBCb29sZWFuOiBFbmFibGUg YWxpZ25pbmcgYWxsIHBlcmlvZGljIHZwdHMgdG8gcmVkdWNlIGludGVycnVwdHMgKi8KKyNkZWZp bmUgSFZNX1BBUkFNX1ZQVF9BTElHTiAgICAxNgorCisvKiBDb25zb2xlIGRlYnVnIHNoYXJlZCBt ZW1vcnkgcmluZyBhbmQgZXZlbnQgY2hhbm5lbCAqLworI2RlZmluZSBIVk1fUEFSQU1fQ09OU09M RV9QRk4gICAgMTcKKyNkZWZpbmUgSFZNX1BBUkFNX0NPTlNPTEVfRVZUQ0hOIDE4CisKKy8qCisg KiBTZWxlY3QgbG9jYXRpb24gb2YgQUNQSSBQTTFhIGFuZCBUTVIgY29udHJvbCBibG9ja3MuIEN1 cnJlbnRseSB0d28gbG9jYXRpb25zCisgKiBhcmUgc3VwcG9ydGVkLCBzcGVjaWZpZWQgYnkgdmVy c2lvbiAwIG9yIDEgaW4gdGhpcyBwYXJhbWV0ZXI6CisgKiAgIC0gMDogZGVmYXVsdCwgdXNlIHRo ZSBvbGQgYWRkcmVzc2VzCisgKiAgICAgICAgUE0xQV9FVlQgPT0gMHgxZjQwOyBQTTFBX0NOVCA9 PSAweDFmNDQ7IFBNX1RNUiA9PSAweDFmNDgKKyAqICAgLSAxOiB1c2UgdGhlIG5ldyBkZWZhdWx0 IHFlbXUgYWRkcmVzc2VzCisgKiAgICAgICAgUE0xQV9FVlQgPT0gMHhiMDAwOyBQTTFBX0NOVCA9 PSAweGIwMDQ7IFBNX1RNUiA9PSAweGIwMDgKKyAqIFlvdSBjYW4gZmluZCB0aGVzZSBhZGRyZXNz IGRlZmluaXRpb25zIGluIDxodm0vaW9yZXEuaD4KKyAqLworI2RlZmluZSBIVk1fUEFSQU1fQUNQ SV9JT1BPUlRTX0xPQ0FUSU9OIDE5CisKKy8qIERlcHJlY2F0ZWQgKi8KKyNkZWZpbmUgSFZNX1BB UkFNX01FTU9SWV9FVkVOVF9DUjAgICAgICAgICAgMjAKKyNkZWZpbmUgSFZNX1BBUkFNX01FTU9S WV9FVkVOVF9DUjMgICAgICAgICAgMjEKKyNkZWZpbmUgSFZNX1BBUkFNX01FTU9SWV9FVkVOVF9D UjQgICAgICAgICAgMjIKKyNkZWZpbmUgSFZNX1BBUkFNX01FTU9SWV9FVkVOVF9JTlQzICAgICAg ICAgMjMKKyNkZWZpbmUgSFZNX1BBUkFNX01FTU9SWV9FVkVOVF9TSU5HTEVfU1RFUCAgMjUKKyNk ZWZpbmUgSFZNX1BBUkFNX01FTU9SWV9FVkVOVF9NU1IgICAgICAgICAgMzAKKworLyogQm9vbGVh bjogRW5hYmxlIG5lc3RlZGh2bSAoaHZtIG9ubHkpICovCisjZGVmaW5lIEhWTV9QQVJBTV9ORVNU RURIVk0gICAgMjQKKworLyogUGFyYW1zIGZvciB0aGUgbWVtIGV2ZW50IHJpbmdzICovCisjZGVm aW5lIEhWTV9QQVJBTV9QQUdJTkdfUklOR19QRk4gICAyNworI2RlZmluZSBIVk1fUEFSQU1fTU9O SVRPUl9SSU5HX1BGTiAgMjgKKyNkZWZpbmUgSFZNX1BBUkFNX1NIQVJJTkdfUklOR19QRk4gIDI5 CisKKy8qIFNIVVRET1dOXyogYWN0aW9uIGluIGNhc2Ugb2YgYSB0cmlwbGUgZmF1bHQgKi8KKyNk ZWZpbmUgSFZNX1BBUkFNX1RSSVBMRV9GQVVMVF9SRUFTT04gMzEKKworI2RlZmluZSBIVk1fUEFS QU1fSU9SRVFfU0VSVkVSX1BGTiAzMgorI2RlZmluZSBIVk1fUEFSQU1fTlJfSU9SRVFfU0VSVkVS X1BBR0VTIDMzCisKKy8qIExvY2F0aW9uIG9mIHRoZSBWTSBHZW5lcmF0aW9uIElEIGluIGd1ZXN0 IHBoeXNpY2FsIGFkZHJlc3Mgc3BhY2UuICovCisjZGVmaW5lIEhWTV9QQVJBTV9WTV9HRU5FUkFU SU9OX0lEX0FERFIgMzQKKworLyoKKyAqIFNldCBtb2RlIGZvciBhbHRwMm06CisgKiAgZGlzYWJs ZWQ6IGRvbid0IGFjdGl2YXRlIGFsdHAybSAoZGVmYXVsdCkKKyAqICBtaXhlZDogYWxsb3cgYWNj ZXNzIHRvIGFsbCBhbHRwMm0gb3BzIGZvciBib3RoIGluLWd1ZXN0IGFuZCBleHRlcm5hbCB0b29s cworICogIGV4dGVybmFsOiBhbGxvdyBhY2Nlc3MgdG8gZXh0ZXJuYWwgcHJpdmlsZWdlZCB0b29s cyBvbmx5CisgKiAgbGltaXRlZDogZ3Vlc3Qgb25seSBoYXMgbGltaXRlZCBhY2Nlc3MgKGllLiBj b250cm9sIFZNRlVOQyBhbmQgI1ZFKQorICovCisjZGVmaW5lIEhWTV9QQVJBTV9BTFRQMk0gICAg ICAgMzUKKyNkZWZpbmUgWEVOX0FMVFAyTV9kaXNhYmxlZCAgICAgIDAKKyNkZWZpbmUgWEVOX0FM VFAyTV9taXhlZCAgICAgICAgIDEKKyNkZWZpbmUgWEVOX0FMVFAyTV9leHRlcm5hbCAgICAgIDIK KyNkZWZpbmUgWEVOX0FMVFAyTV9saW1pdGVkICAgICAgIDMKKworLyoKKyAqIFNpemUgb2YgdGhl IHg4NyBGUFUgRklQL0ZEUCByZWdpc3RlcnMgdGhhdCB0aGUgaHlwZXJ2aXNvciBuZWVkcyB0bwor ICogc2F2ZS9yZXN0b3JlLiAgVGhpcyBpcyBhIHdvcmthcm91bmQgZm9yIGEgaGFyZHdhcmUgbGlt aXRhdGlvbiB0aGF0CisgKiBkb2VzIG5vdCBhbGxvdyB0aGUgZnVsbCBGSVAvRkRQIGFuZCBGQ1Mv RkRTIHRvIGJlIHJlc3RvcmVkLgorICoKKyAqIFZhbGlkIHZhbHVlcyBhcmU6CisgKgorICogODog c2F2ZS9yZXN0b3JlIDY0LWJpdCBGSVAvRkRQIGFuZCBjbGVhciBGQ1MvRkRTIChkZWZhdWx0IGlm IENQVQorICogICAgaGFzIEZQQ1NEUyBmZWF0dXJlKS4KKyAqCisgKiA0OiBzYXZlL3Jlc3RvcmUg MzItYml0IEZJUC9GRFAsIEZDUy9GRFMsIGFuZCBjbGVhciB1cHBlciAzMi1iaXRzIG9mCisgKiAg ICBGSVAvRkRQLgorICoKKyAqIDA6IGFsbG93IGh5cGVydmlzb3IgdG8gY2hvb3NlIGJhc2VkIG9u IHRoZSB2YWx1ZSBvZiBGSVAvRkRQCisgKiAgICAoZGVmYXVsdCBpZiBDUFUgZG9lcyBub3QgaGF2 ZSBGUENTRFMpLgorICoKKyAqIElmIEZQQ1NEUyAoYml0IDEzIGluIENQVUlEIGxlYWYgMHg3LCBz dWJsZWFmIDB4MCkgaXMgc2V0LCB0aGUgQ1BVCisgKiBuZXZlciBzYXZlcyBGQ1MvRkRTIGFuZCB0 aGlzIHBhcmFtZXRlciBzaG91bGQgYmUgbGVmdCBhdCB0aGUKKyAqIGRlZmF1bHQgb2YgOC4KKyAq LworI2RlZmluZSBIVk1fUEFSQU1fWDg3X0ZJUF9XSURUSCAzNgorCisvKgorICogVFNTIChhbmQg aXRzIHNpemUpIHVzZWQgb24gSW50ZWwgd2hlbiBDUjAuUEU9MC4gVGhlIGFkZHJlc3Mgb2NjdXBp ZXMKKyAqIHRoZSBsb3cgMzIgYml0cywgd2hpbGUgdGhlIHNpemUgaXMgaW4gdGhlIGhpZ2ggMzIg b25lcy4KKyAqLworI2RlZmluZSBIVk1fUEFSQU1fVk04Nl9UU1NfU0laRUQgMzcKKworLyogRW5h YmxlIE1DQSBjYXBhYmlsaXRpZXMuICovCisjZGVmaW5lIEhWTV9QQVJBTV9NQ0FfQ0FQIDM4Cisj ZGVmaW5lIFhFTl9IVk1fTUNBX0NBUF9MTUNFICAgKHhlbl9ta191bGxvbmcoMSkgPDwgMCkKKyNk ZWZpbmUgWEVOX0hWTV9NQ0FfQ0FQX01BU0sgICBYRU5fSFZNX01DQV9DQVBfTE1DRQorCisjZGVm aW5lIEhWTV9OUl9QQVJBTVMgMzkKKworI2VuZGlmIC8qIF9fWEVOX1BVQkxJQ19IVk1fUEFSQU1T X0hfXyAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS94ZW4vaHZtL3N0YXJ0X2luZm8uaCBiL2luY2x1 ZGUveGVuL2h2bS9zdGFydF9pbmZvLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAw MDAwLi42NDg0MTU5NzYKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL3hlbi9odm0vc3RhcnRf aW5mby5oCkBAIC0wLDAgKzEsOTggQEAKKy8qCisgKiBQZXJtaXNzaW9uIGlzIGhlcmVieSBncmFu dGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYSBjb3B5CisgKiBv ZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmlsZXMgKHRoZSAi U29mdHdhcmUiKSwgdG8KKyAqIGRlYWwgaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQgcmVzdHJpY3Rp b24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlCisgKiByaWdodHMgdG8gdXNlLCBj b3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNlbnNlLCBhbmQv b3IKKyAqIHNlbGwgY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1pdCBwZXJzb25z IHRvIHdob20gdGhlIFNvZnR3YXJlIGlzCisgKiBmdXJuaXNoZWQgdG8gZG8gc28sIHN1YmplY3Qg dG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOgorICoKKyAqIFRoZSBhYm92ZSBjb3B5cmlnaHQg bm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1ZGVkIGluCisg KiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0d2FyZS4KKyAq CisgKiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9VVCBXQVJSQU5UWSBP RiBBTlkgS0lORCwgRVhQUkVTUyBPUgorICogSU1QTElFRCwgSU5DTFVESU5HIEJVVCBOT1QgTElN SVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFksCisgKiBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OSU5GUklOR0VNRU5ULiBJTiBOTyBFVkVOVCBT SEFMTCBUSEUKKyAqIEFVVEhPUlMgT1IgQ09QWVJJR0hUIEhPTERFUlMgQkUgTElBQkxFIEZPUiBB TlkgQ0xBSU0sIERBTUFHRVMgT1IgT1RIRVIKKyAqIExJQUJJTElUWSwgV0hFVEhFUiBJTiBBTiBB Q1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLCBBUklTSU5HCisgKiBGUk9NLCBP VVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUgVVNFIE9SIE9U SEVSCisgKiBERUFMSU5HUyBJTiBUSEUgU09GVFdBUkUuCisgKgorICogQ29weXJpZ2h0IChjKSAy MDE2LCBDaXRyaXggU3lzdGVtcywgSW5jLgorICovCisKKyNpZm5kZWYgX19YRU5fUFVCTElDX0FS Q0hfWDg2X0hWTV9TVEFSVF9JTkZPX0hfXworI2RlZmluZSBfX1hFTl9QVUJMSUNfQVJDSF9YODZf SFZNX1NUQVJUX0lORk9fSF9fCisKKy8qCisgKiBTdGFydCBvZiBkYXkgc3RydWN0dXJlIHBhc3Nl ZCB0byBQVkggZ3Vlc3RzIGFuZCB0byBIVk0gZ3Vlc3RzIGluICVlYnguCisgKgorICogTk9URTog bm90aGluZyB3aWxsIGJlIGxvYWRlZCBhdCBwaHlzaWNhbCBhZGRyZXNzIDAsIHNvIGEgMCB2YWx1 ZSBpbiBhbnkKKyAqIG9mIHRoZSBhZGRyZXNzIGZpZWxkcyBzaG91bGQgYmUgdHJlYXRlZCBhcyBu b3QgcHJlc2VudC4KKyAqCisgKiAgMCArLS0tLS0tLS0tLS0tLS0tLSsKKyAqICAgIHwgbWFnaWMg ICAgICAgICAgfCBDb250YWlucyB0aGUgbWFnaWMgdmFsdWUgWEVOX0hWTV9TVEFSVF9NQUdJQ19W QUxVRQorICogICAgfCAgICAgICAgICAgICAgICB8ICgieEVuMyIgd2l0aCB0aGUgMHg4MCBiaXQg b2YgdGhlICJFIiBzZXQpLgorICogIDQgKy0tLS0tLS0tLS0tLS0tLS0rCisgKiAgICB8IHZlcnNp b24gICAgICAgIHwgVmVyc2lvbiBvZiB0aGlzIHN0cnVjdHVyZS4gQ3VycmVudCB2ZXJzaW9uIGlz IDAuIE5ldworICogICAgfCAgICAgICAgICAgICAgICB8IHZlcnNpb25zIGFyZSBndWFyYW50ZWVk IHRvIGJlIGJhY2t3YXJkcy1jb21wYXRpYmxlLgorICogIDggKy0tLS0tLS0tLS0tLS0tLS0rCisg KiAgICB8IGZsYWdzICAgICAgICAgIHwgU0lGX3h4eCBmbGFncy4KKyAqIDEyICstLS0tLS0tLS0t LS0tLS0tKworICogICAgfCBucl9tb2R1bGVzICAgICB8IE51bWJlciBvZiBtb2R1bGVzIHBhc3Nl ZCB0byB0aGUga2VybmVsLgorICogMTYgKy0tLS0tLS0tLS0tLS0tLS0rCisgKiAgICB8IG1vZGxp c3RfcGFkZHIgIHwgUGh5c2ljYWwgYWRkcmVzcyBvZiBhbiBhcnJheSBvZiBtb2R1bGVzCisgKiAg ICB8ICAgICAgICAgICAgICAgIHwgKGxheW91dCBvZiB0aGUgc3RydWN0dXJlIGJlbG93KS4KKyAq IDI0ICstLS0tLS0tLS0tLS0tLS0tKworICogICAgfCBjbWRsaW5lX3BhZGRyICB8IFBoeXNpY2Fs IGFkZHJlc3Mgb2YgdGhlIGNvbW1hbmQgbGluZSwKKyAqICAgIHwgICAgICAgICAgICAgICAgfCBh IHplcm8tdGVybWluYXRlZCBBU0NJSSBzdHJpbmcuCisgKiAzMiArLS0tLS0tLS0tLS0tLS0tLSsK KyAqICAgIHwgcnNkcF9wYWRkciAgICAgfCBQaHlzaWNhbCBhZGRyZXNzIG9mIHRoZSBSU0RQIEFD UEkgZGF0YSBzdHJ1Y3R1cmUuCisgKiA0MCArLS0tLS0tLS0tLS0tLS0tLSsKKyAqCisgKiBUaGUg bGF5b3V0IG9mIGVhY2ggZW50cnkgaW4gdGhlIG1vZHVsZSBzdHJ1Y3R1cmUgaXMgdGhlIGZvbGxv d2luZzoKKyAqCisgKiAgMCArLS0tLS0tLS0tLS0tLS0tLSsKKyAqICAgIHwgcGFkZHIgICAgICAg ICAgfCBQaHlzaWNhbCBhZGRyZXNzIG9mIHRoZSBtb2R1bGUuCisgKiAgOCArLS0tLS0tLS0tLS0t LS0tLSsKKyAqICAgIHwgc2l6ZSAgICAgICAgICAgfCBTaXplIG9mIHRoZSBtb2R1bGUgaW4gYnl0 ZXMuCisgKiAxNiArLS0tLS0tLS0tLS0tLS0tLSsKKyAqICAgIHwgY21kbGluZV9wYWRkciAgfCBQ aHlzaWNhbCBhZGRyZXNzIG9mIHRoZSBjb21tYW5kIGxpbmUsCisgKiAgICB8ICAgICAgICAgICAg ICAgIHwgYSB6ZXJvLXRlcm1pbmF0ZWQgQVNDSUkgc3RyaW5nLgorICogMjQgKy0tLS0tLS0tLS0t LS0tLS0rCisgKiAgICB8IHJlc2VydmVkICAgICAgIHwKKyAqIDMyICstLS0tLS0tLS0tLS0tLS0t KworICoKKyAqIFRoZSBhZGRyZXNzIGFuZCBzaXplcyBhcmUgYWx3YXlzIGEgNjRiaXQgbGl0dGxl IGVuZGlhbiB1bnNpZ25lZCBpbnRlZ2VyLgorICoKKyAqIE5COiBYZW4gb24geDg2IHdpbGwgYWx3 YXlzIHRyeSB0byBwbGFjZSBhbGwgdGhlIGRhdGEgYmVsb3cgdGhlIDRHaUIKKyAqIGJvdW5kYXJ5 LgorICovCisjZGVmaW5lIFhFTl9IVk1fU1RBUlRfTUFHSUNfVkFMVUUgMHgzMzZlYzU3OAorCisv KgorICogQyByZXByZXNlbnRhdGlvbiBvZiB0aGUgeDg2L0hWTSBzdGFydCBpbmZvIGxheW91dC4K KyAqCisgKiBUaGUgY2Fub25pY2FsIGRlZmluaXRpb24gb2YgdGhpcyBsYXlvdXQgaXMgYWJvdmUs IHRoaXMgaXMganVzdCBhIHdheSB0bworICogcmVwcmVzZW50IHRoZSBsYXlvdXQgZGVzY3JpYmVk IHRoZXJlIHVzaW5nIEMgdHlwZXMuCisgKi8KK3N0cnVjdCBodm1fc3RhcnRfaW5mbyB7CisgICAg dWludDMyX3QgbWFnaWM7ICAgICAgICAgICAgIC8qIENvbnRhaW5zIHRoZSBtYWdpYyB2YWx1ZSAw eDMzNmVjNTc4ICAgICAgICovCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qICgi eEVuMyIgd2l0aCB0aGUgMHg4MCBiaXQgb2YgdGhlICJFIiBzZXQpLiovCisgICAgdWludDMyX3Qg dmVyc2lvbjsgICAgICAgICAgIC8qIFZlcnNpb24gb2YgdGhpcyBzdHJ1Y3R1cmUuICAgICAgICAg ICAgICAgICovCisgICAgdWludDMyX3QgZmxhZ3M7ICAgICAgICAgICAgIC8qIFNJRl94eHggZmxh Z3MuICAgICAgICAgICAgICAgICAgICAgICAgICAgICovCisgICAgdWludDMyX3QgbnJfbW9kdWxl czsgICAgICAgIC8qIE51bWJlciBvZiBtb2R1bGVzIHBhc3NlZCB0byB0aGUga2VybmVsLiAgICov CisgICAgdWludDY0X3QgbW9kbGlzdF9wYWRkcjsgICAgIC8qIFBoeXNpY2FsIGFkZHJlc3Mgb2Yg YW4gYXJyYXkgb2YgICAgICAgICAgICovCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IC8qIGh2bV9tb2RsaXN0X2VudHJ5LiAgICAgICAgICAgICAgICAgICAgICAgICovCisgICAgdWlu dDY0X3QgY21kbGluZV9wYWRkcjsgICAgIC8qIFBoeXNpY2FsIGFkZHJlc3Mgb2YgdGhlIGNvbW1h bmQgbGluZS4gICAgICovCisgICAgdWludDY0X3QgcnNkcF9wYWRkcjsgICAgICAgIC8qIFBoeXNp Y2FsIGFkZHJlc3Mgb2YgdGhlIFJTRFAgQUNQSSBkYXRhICAgICovCisgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIC8qIHN0cnVjdHVyZS4gICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICovCit9OworCitzdHJ1Y3QgaHZtX21vZGxpc3RfZW50cnkgeworICAgIHVpbnQ2NF90IHBh ZGRyOyAgICAgICAgICAgICAvKiBQaHlzaWNhbCBhZGRyZXNzIG9mIHRoZSBtb2R1bGUuICAgICAg ICAgICAqLworICAgIHVpbnQ2NF90IHNpemU7ICAgICAgICAgICAgICAvKiBTaXplIG9mIHRoZSBt b2R1bGUgaW4gYnl0ZXMuICAgICAgICAgICAgICAqLworICAgIHVpbnQ2NF90IGNtZGxpbmVfcGFk ZHI7ICAgICAvKiBQaHlzaWNhbCBhZGRyZXNzIG9mIHRoZSBjb21tYW5kIGxpbmUuICAgICAqLwor ICAgIHVpbnQ2NF90IHJlc2VydmVkOworfTsKKworI2VuZGlmIC8qIF9fWEVOX1BVQkxJQ19BUkNI X1g4Nl9IVk1fU1RBUlRfSU5GT19IX18gKi8KZGlmZiAtLWdpdCBhL2luY2x1ZGUveGVuL21lbW9y eS5oIGIvaW5jbHVkZS94ZW4vbWVtb3J5LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwLi4yOTM4NmRmOTgKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL3hlbi9tZW1vcnku aApAQCAtMCwwICsxLDY2NSBAQAorLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICogbWVtb3J5LmgK KyAqIAorICogTWVtb3J5IHJlc2VydmF0aW9uIGFuZCBpbmZvcm1hdGlvbi4KKyAqIAorICogUGVy bWlzc2lvbiBpcyBoZXJlYnkgZ3JhbnRlZCwgZnJlZSBvZiBjaGFyZ2UsIHRvIGFueSBwZXJzb24g b2J0YWluaW5nIGEgY29weQorICogb2YgdGhpcyBzb2Z0d2FyZSBhbmQgYXNzb2NpYXRlZCBkb2N1 bWVudGF0aW9uIGZpbGVzICh0aGUgIlNvZnR3YXJlIiksIHRvCisgKiBkZWFsIGluIHRoZSBTb2Z0 d2FyZSB3aXRob3V0IHJlc3RyaWN0aW9uLCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uIHRo ZQorICogcmlnaHRzIHRvIHVzZSwgY29weSwgbW9kaWZ5LCBtZXJnZSwgcHVibGlzaCwgZGlzdHJp YnV0ZSwgc3VibGljZW5zZSwgYW5kL29yCisgKiBzZWxsIGNvcGllcyBvZiB0aGUgU29mdHdhcmUs IGFuZCB0byBwZXJtaXQgcGVyc29ucyB0byB3aG9tIHRoZSBTb2Z0d2FyZSBpcworICogZnVybmlz aGVkIHRvIGRvIHNvLCBzdWJqZWN0IHRvIHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKKyAqCisg KiBUaGUgYWJvdmUgY29weXJpZ2h0IG5vdGljZSBhbmQgdGhpcyBwZXJtaXNzaW9uIG5vdGljZSBz aGFsbCBiZSBpbmNsdWRlZCBpbgorICogYWxsIGNvcGllcyBvciBzdWJzdGFudGlhbCBwb3J0aW9u cyBvZiB0aGUgU29mdHdhcmUuCisgKgorICogVEhFIFNPRlRXQVJFIElTIFBST1ZJREVEICJBUyBJ UyIsIFdJVEhPVVQgV0FSUkFOVFkgT0YgQU5ZIEtJTkQsIEVYUFJFU1MgT1IKKyAqIElNUExJRUQs IElOQ0xVRElORyBCVVQgTk9UIExJTUlURUQgVE8gVEhFIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZLAorICogRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQU5EIE5PTklORlJJ TkdFTUVOVC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFCisgKiBBVVRIT1JTIE9SIENPUFlSSUdIVCBI T0xERVJTIEJFIExJQUJMRSBGT1IgQU5ZIENMQUlNLCBEQU1BR0VTIE9SIE9USEVSCisgKiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQU4gQUNUSU9OIE9GIENPTlRSQUNULCBUT1JUIE9SIE9USEVSV0lT RSwgQVJJU0lORworICogRlJPTSwgT1VUIE9GIE9SIElOIENPTk5FQ1RJT04gV0lUSCBUSEUgU09G VFdBUkUgT1IgVEhFIFVTRSBPUiBPVEhFUgorICogREVBTElOR1MgSU4gVEhFIFNPRlRXQVJFLgor ICoKKyAqIENvcHlyaWdodCAoYykgMjAwNSwgS2VpciBGcmFzZXIgPGtlaXJAeGVuc291cmNlLmNv bT4KKyAqLworCisjaWZuZGVmIF9fWEVOX1BVQkxJQ19NRU1PUllfSF9fCisjZGVmaW5lIF9fWEVO X1BVQkxJQ19NRU1PUllfSF9fCisKKyNpbmNsdWRlICJ4ZW4uaCIKKyNpbmNsdWRlICJwaHlzZGV2 LmgiCisKKy8qCisgKiBJbmNyZWFzZSBvciBkZWNyZWFzZSB0aGUgc3BlY2lmaWVkIGRvbWFpbidz IG1lbW9yeSByZXNlcnZhdGlvbi4gUmV0dXJucyB0aGUKKyAqIG51bWJlciBvZiBleHRlbnRzIHN1 Y2Nlc3NmdWxseSBhbGxvY2F0ZWQgb3IgZnJlZWQuCisgKiBhcmcgPT0gYWRkciBvZiBzdHJ1Y3Qg eGVuX21lbW9yeV9yZXNlcnZhdGlvbi4KKyAqLworI2RlZmluZSBYRU5NRU1faW5jcmVhc2VfcmVz ZXJ2YXRpb24gMAorI2RlZmluZSBYRU5NRU1fZGVjcmVhc2VfcmVzZXJ2YXRpb24gMQorI2RlZmlu ZSBYRU5NRU1fcG9wdWxhdGVfcGh5c21hcCAgICAgNgorCisjaWYgX19YRU5fSU5URVJGQUNFX1ZF UlNJT05fXyA+PSAweDAwMDMwMjA5CisvKgorICogTWF4aW11bSAjIGJpdHMgYWRkcmVzc2FibGUg YnkgdGhlIHVzZXIgb2YgdGhlIGFsbG9jYXRlZCByZWdpb24gKGUuZy4sIEkvTyAKKyAqIGRldmlj ZXMgb2Z0ZW4gaGF2ZSBhIDMyLWJpdCBsaW1pdGF0aW9uIGV2ZW4gaW4gNjQtYml0IHN5c3RlbXMp LiBJZiB6ZXJvIAorICogdGhlbiB0aGUgdXNlciBoYXMgbm8gYWRkcmVzc2luZyByZXN0cmljdGlv bi4gVGhpcyBmaWVsZCBpcyBub3QgdXNlZCBieSAKKyAqIFhFTk1FTV9kZWNyZWFzZV9yZXNlcnZh dGlvbi4KKyAqLworI2RlZmluZSBYRU5NRU1GX2FkZHJlc3NfYml0cyh4KSAgICAgKHgpCisjZGVm aW5lIFhFTk1FTUZfZ2V0X2FkZHJlc3NfYml0cyh4KSAoKHgpICYgMHhmZnUpCisvKiBOVU1BIG5v ZGUgdG8gYWxsb2NhdGUgZnJvbS4gKi8KKyNkZWZpbmUgWEVOTUVNRl9ub2RlKHgpICAgICAoKCh4 KSArIDEpIDw8IDgpCisjZGVmaW5lIFhFTk1FTUZfZ2V0X25vZGUoeCkgKCgoKHgpID4+IDgpIC0g MSkgJiAweGZmdSkKKy8qIEZsYWcgdG8gcG9wdWxhdGUgcGh5c21hcCB3aXRoIHBvcHVsYXRlLW9u LWRlbWFuZCBlbnRyaWVzICovCisjZGVmaW5lIFhFTk1FTUZfcG9wdWxhdGVfb25fZGVtYW5kICgx PDwxNikKKy8qIEZsYWcgdG8gcmVxdWVzdCBhbGxvY2F0aW9uIG9ubHkgZnJvbSB0aGUgbm9kZSBz cGVjaWZpZWQgKi8KKyNkZWZpbmUgWEVOTUVNRl9leGFjdF9ub2RlX3JlcXVlc3QgICgxPDwxNykK KyNkZWZpbmUgWEVOTUVNRl9leGFjdF9ub2RlKG4pIChYRU5NRU1GX25vZGUobikgfCBYRU5NRU1G X2V4YWN0X25vZGVfcmVxdWVzdCkKKy8qIEZsYWcgdG8gaW5kaWNhdGUgdGhlIG5vZGUgc3BlY2lm aWVkIGlzIHZpcnR1YWwgbm9kZSAqLworI2RlZmluZSBYRU5NRU1GX3Zub2RlICAoMTw8MTgpCisj ZW5kaWYKKworc3RydWN0IHhlbl9tZW1vcnlfcmVzZXJ2YXRpb24geworCisgICAgLyoKKyAgICAg KiBYRU5NRU1faW5jcmVhc2VfcmVzZXJ2YXRpb246CisgICAgICogICBPVVQ6IE1GTiAoKm5vdCog R01GTikgYmFzZXMgb2YgZXh0ZW50cyB0aGF0IHdlcmUgYWxsb2NhdGVkCisgICAgICogWEVOTUVN X2RlY3JlYXNlX3Jlc2VydmF0aW9uOgorICAgICAqICAgSU46ICBHTUZOIGJhc2VzIG9mIGV4dGVu dHMgdG8gZnJlZQorICAgICAqIFhFTk1FTV9wb3B1bGF0ZV9waHlzbWFwOgorICAgICAqICAgSU46 ICBHUEZOIGJhc2VzIG9mIGV4dGVudHMgdG8gcG9wdWxhdGUgd2l0aCBtZW1vcnkKKyAgICAgKiAg IE9VVDogR01GTiBiYXNlcyBvZiBleHRlbnRzIHRoYXQgd2VyZSBhbGxvY2F0ZWQKKyAgICAgKiAg IChOQi4gVGhpcyBjb21tYW5kIGFsc28gdXBkYXRlcyB0aGUgbWFjaF90b19waHlzIHRyYW5zbGF0 aW9uIHRhYmxlKQorICAgICAqIFhFTk1FTV9jbGFpbV9wYWdlczoKKyAgICAgKiAgIElOOiBtdXN0 IGJlIHplcm8KKyAgICAgKi8KKyAgICBYRU5fR1VFU1RfSEFORExFKHhlbl9wZm5fdCkgZXh0ZW50 X3N0YXJ0OworCisgICAgLyogTnVtYmVyIG9mIGV4dGVudHMsIGFuZCBzaXplL2FsaWdubWVudCBv ZiBlYWNoICgyXmV4dGVudF9vcmRlciBwYWdlcykuICovCisgICAgeGVuX3Vsb25nX3QgICAgbnJf ZXh0ZW50czsKKyAgICB1bnNpZ25lZCBpbnQgICBleHRlbnRfb3JkZXI7CisKKyNpZiBfX1hFTl9J TlRFUkZBQ0VfVkVSU0lPTl9fID49IDB4MDAwMzAyMDkKKyAgICAvKiBYRU5NRU1GIGZsYWdzLiAq LworICAgIHVuc2lnbmVkIGludCAgIG1lbV9mbGFnczsKKyNlbHNlCisgICAgdW5zaWduZWQgaW50 ICAgYWRkcmVzc19iaXRzOworI2VuZGlmCisKKyAgICAvKgorICAgICAqIERvbWFpbiB3aG9zZSBy ZXNlcnZhdGlvbiBpcyBiZWluZyBjaGFuZ2VkLgorICAgICAqIFVucHJpdmlsZWdlZCBkb21haW5z IGNhbiBzcGVjaWZ5IG9ubHkgRE9NSURfU0VMRi4KKyAgICAgKi8KKyAgICBkb21pZF90ICAgICAg ICBkb21pZDsKK307Cit0eXBlZGVmIHN0cnVjdCB4ZW5fbWVtb3J5X3Jlc2VydmF0aW9uIHhlbl9t ZW1vcnlfcmVzZXJ2YXRpb25fdDsKK0RFRklORV9YRU5fR1VFU1RfSEFORExFKHhlbl9tZW1vcnlf cmVzZXJ2YXRpb25fdCk7CisKKy8qCisgKiBBbiBhdG9taWMgZXhjaGFuZ2Ugb2YgbWVtb3J5IHBh Z2VzLiBJZiByZXR1cm4gY29kZSBpcyB6ZXJvIHRoZW4KKyAqIEBvdXQuZXh0ZW50X2xpc3QgcHJv dmlkZXMgR01GTnMgb2YgdGhlIG5ld2x5LWFsbG9jYXRlZCBtZW1vcnkuCisgKiBSZXR1cm5zIHpl cm8gb24gY29tcGxldGUgc3VjY2Vzcywgb3RoZXJ3aXNlIGEgbmVnYXRpdmUgZXJyb3IgY29kZS4K KyAqIE9uIGNvbXBsZXRlIHN1Y2Nlc3MgdGhlbiBhbHdheXMgQG5yX2V4Y2hhbmdlZCA9PSBAaW4u bnJfZXh0ZW50cy4KKyAqIE9uIHBhcnRpYWwgc3VjY2VzcyBAbnJfZXhjaGFuZ2VkIGluZGljYXRl cyBob3cgbXVjaCB3b3JrIHdhcyBkb25lLgorICoKKyAqIE5vdGUgdGhhdCBvbmx5IFBWIGd1ZXN0 cyBjYW4gdXNlIHRoaXMgb3BlcmF0aW9uLgorICovCisjZGVmaW5lIFhFTk1FTV9leGNoYW5nZSAg ICAgICAgICAgICAxMQorc3RydWN0IHhlbl9tZW1vcnlfZXhjaGFuZ2UgeworICAgIC8qCisgICAg ICogW0lOXSBEZXRhaWxzIG9mIG1lbW9yeSBleHRlbnRzIHRvIGJlIGV4Y2hhbmdlZCAoR01GTiBi YXNlcykuCisgICAgICogTm90ZSB0aGF0IEBpbi5hZGRyZXNzX2JpdHMgaXMgaWdub3JlZCBhbmQg dW51c2VkLgorICAgICAqLworICAgIHN0cnVjdCB4ZW5fbWVtb3J5X3Jlc2VydmF0aW9uIGluOwor CisgICAgLyoKKyAgICAgKiBbSU4vT1VUXSBEZXRhaWxzIG9mIG5ldyBtZW1vcnkgZXh0ZW50cy4K KyAgICAgKiBXZSByZXF1aXJlIHRoYXQ6CisgICAgICogIDEuIEBpbi5kb21pZCA9PSBAb3V0LmRv bWlkCisgICAgICogIDIuIEBpbi5ucl9leHRlbnRzICA8PCBAaW4uZXh0ZW50X29yZGVyID09IAor ICAgICAqICAgICBAb3V0Lm5yX2V4dGVudHMgPDwgQG91dC5leHRlbnRfb3JkZXIKKyAgICAgKiAg My4gQGluLmV4dGVudF9zdGFydCBhbmQgQG91dC5leHRlbnRfc3RhcnQgbGlzdHMgbXVzdCBub3Qg b3ZlcmxhcAorICAgICAqICA0LiBAb3V0LmV4dGVudF9zdGFydCBsaXN0cyBHUEZOIGJhc2VzIHRv IGJlIHBvcHVsYXRlZAorICAgICAqICA1LiBAb3V0LmV4dGVudF9zdGFydCBpcyBvdmVyd3JpdHRl biB3aXRoIGFsbG9jYXRlZCBHTUZOIGJhc2VzCisgICAgICovCisgICAgc3RydWN0IHhlbl9tZW1v cnlfcmVzZXJ2YXRpb24gb3V0OworCisgICAgLyoKKyAgICAgKiBbT1VUXSBOdW1iZXIgb2YgaW5w dXQgZXh0ZW50cyB0aGF0IHdlcmUgc3VjY2Vzc2Z1bGx5IGV4Y2hhbmdlZDoKKyAgICAgKiAgMS4g VGhlIGZpcnN0IEBucl9leGNoYW5nZWQgaW5wdXQgZXh0ZW50cyB3ZXJlIHN1Y2Nlc3NmdWxseQor ICAgICAqICAgICBkZWFsbG9jYXRlZC4KKyAgICAgKiAgMi4gVGhlIGNvcnJlc3BvbmRpbmcgZmly c3QgZW50cmllcyBpbiB0aGUgb3V0cHV0IGV4dGVudCBsaXN0IGNvcnJlY3RseQorICAgICAqICAg ICBpbmRpY2F0ZSB0aGUgR01GTnMgdGhhdCB3ZXJlIHN1Y2Nlc3NmdWxseSBleGNoYW5nZWQuCisg ICAgICogIDMuIEFsbCBvdGhlciBpbnB1dCBhbmQgb3V0cHV0IGV4dGVudHMgYXJlIHVudG91Y2hl ZC4KKyAgICAgKiAgNC4gSWYgbm90IGFsbCBpbnB1dCBleGVudHMgYXJlIGV4Y2hhbmdlZCB0aGVu IHRoZSByZXR1cm4gY29kZSBvZiB0aGlzCisgICAgICogICAgIGNvbW1hbmQgd2lsbCBiZSBub24t emVyby4KKyAgICAgKiAgNS4gVEhJUyBGSUVMRCBNVVNUIEJFIElOSVRJQUxJU0VEIFRPIFpFUk8g QlkgVEhFIENBTExFUiEKKyAgICAgKi8KKyAgICB4ZW5fdWxvbmdfdCBucl9leGNoYW5nZWQ7Cit9 OwordHlwZWRlZiBzdHJ1Y3QgeGVuX21lbW9yeV9leGNoYW5nZSB4ZW5fbWVtb3J5X2V4Y2hhbmdl X3Q7CitERUZJTkVfWEVOX0dVRVNUX0hBTkRMRSh4ZW5fbWVtb3J5X2V4Y2hhbmdlX3QpOworCisv KgorICogUmV0dXJucyB0aGUgbWF4aW11bSBtYWNoaW5lIGZyYW1lIG51bWJlciBvZiBtYXBwZWQg UkFNIGluIHRoaXMgc3lzdGVtLgorICogVGhpcyBjb21tYW5kIGFsd2F5cyBzdWNjZWVkcyAoaXQg bmV2ZXIgcmV0dXJucyBhbiBlcnJvciBjb2RlKS4KKyAqIGFyZyA9PSBOVUxMLgorICovCisjZGVm aW5lIFhFTk1FTV9tYXhpbXVtX3JhbV9wYWdlICAgICAyCisKKy8qCisgKiBSZXR1cm5zIHRoZSBj dXJyZW50IG9yIG1heGltdW0gbWVtb3J5IHJlc2VydmF0aW9uLCBpbiBwYWdlcywgb2YgdGhlCisg KiBzcGVjaWZpZWQgZG9tYWluIChtYXkgYmUgRE9NSURfU0VMRikuIFJldHVybnMgLXZlIGVycmNv ZGUgb24gZmFpbHVyZS4KKyAqIGFyZyA9PSBhZGRyIG9mIGRvbWlkX3QuCisgKi8KKyNkZWZpbmUg WEVOTUVNX2N1cnJlbnRfcmVzZXJ2YXRpb24gIDMKKyNkZWZpbmUgWEVOTUVNX21heGltdW1fcmVz ZXJ2YXRpb24gIDQKKworLyoKKyAqIFJldHVybnMgdGhlIG1heGltdW0gR1BGTiBpbiB1c2UgYnkg dGhlIGd1ZXN0LCBvciAtdmUgZXJyY29kZSBvbiBmYWlsdXJlLgorICovCisjZGVmaW5lIFhFTk1F TV9tYXhpbXVtX2dwZm4gICAgICAgICAxNAorCisvKgorICogUmV0dXJucyBhIGxpc3Qgb2YgTUZO IGJhc2VzIG9mIDJNQiBleHRlbnRzIGNvbXByaXNpbmcgdGhlIG1hY2hpbmVfdG9fcGh5cworICog bWFwcGluZyB0YWJsZS4gQXJjaGl0ZWN0dXJlcyB3aGljaCBkbyBub3QgaGF2ZSBhIG0ycCB0YWJs ZSBkbyBub3QgaW1wbGVtZW50CisgKiB0aGlzIGNvbW1hbmQuCisgKiBhcmcgPT0gYWRkciBvZiB4 ZW5fbWFjaHBoeXNfbWZuX2xpc3RfdC4KKyAqLworI2RlZmluZSBYRU5NRU1fbWFjaHBoeXNfbWZu X2xpc3QgICAgNQorc3RydWN0IHhlbl9tYWNocGh5c19tZm5fbGlzdCB7CisgICAgLyoKKyAgICAg KiBTaXplIG9mIHRoZSAnZXh0ZW50X3N0YXJ0JyBhcnJheS4gRmV3ZXIgZW50cmllcyB3aWxsIGJl IGZpbGxlZCBpZiB0aGUKKyAgICAgKiBtYWNocGh5cyB0YWJsZSBpcyBzbWFsbGVyIHRoYW4gbWF4 X2V4dGVudHMgKiAyTUIuCisgICAgICovCisgICAgdW5zaWduZWQgaW50IG1heF9leHRlbnRzOwor CisgICAgLyoKKyAgICAgKiBQb2ludGVyIHRvIGJ1ZmZlciB0byBmaWxsIHdpdGggbGlzdCBvZiBl eHRlbnQgc3RhcnRzLiBJZiB0aGVyZSBhcmUKKyAgICAgKiBhbnkgbGFyZ2UgZGlzY29udGlndWl0 aWVzIGluIHRoZSBtYWNoaW5lIGFkZHJlc3Mgc3BhY2UsIDJNQiBnYXBzIGluCisgICAgICogdGhl IG1hY2hwaHlzIHRhYmxlIHdpbGwgYmUgcmVwcmVzZW50ZWQgYnkgYW4gTUZOIGJhc2Ugb2YgemVy by4KKyAgICAgKi8KKyAgICBYRU5fR1VFU1RfSEFORExFKHhlbl9wZm5fdCkgZXh0ZW50X3N0YXJ0 OworCisgICAgLyoKKyAgICAgKiBOdW1iZXIgb2YgZXh0ZW50cyB3cml0dGVuIHRvIHRoZSBhYm92 ZSBhcnJheS4gVGhpcyB3aWxsIGJlIHNtYWxsZXIKKyAgICAgKiB0aGFuICdtYXhfZXh0ZW50cycg aWYgdGhlIG1hY2hwaHlzIHRhYmxlIGlzIHNtYWxsZXIgdGhhbiBtYXhfZSAqIDJNQi4KKyAgICAg Ki8KKyAgICB1bnNpZ25lZCBpbnQgbnJfZXh0ZW50czsKK307Cit0eXBlZGVmIHN0cnVjdCB4ZW5f bWFjaHBoeXNfbWZuX2xpc3QgeGVuX21hY2hwaHlzX21mbl9saXN0X3Q7CitERUZJTkVfWEVOX0dV RVNUX0hBTkRMRSh4ZW5fbWFjaHBoeXNfbWZuX2xpc3RfdCk7CisKKy8qCisgKiBGb3IgYSBjb21w YXQgY2FsbGVyLCB0aGlzIGlzIGlkZW50aWNhbCB0byBYRU5NRU1fbWFjaHBoeXNfbWZuX2xpc3Qu CisgKgorICogRm9yIGEgbm9uIGNvbXBhdCBjYWxsZXIsIHRoaXMgZnVuY3Rpb25zIHNpbWlsYXJs eSB0bworICogWEVOTUVNX21hY2hwaHlzX21mbl9saXN0LCBidXQgcmV0dXJucyB0aGUgbWZucyBt YWtpbmcgdXAgdGhlIGNvbXBhdGliaWxpdHkKKyAqIG0ycCB0YWJsZS4KKyAqLworI2RlZmluZSBY RU5NRU1fbWFjaHBoeXNfY29tcGF0X21mbl9saXN0ICAgICAyNQorCisvKgorICogUmV0dXJucyB0 aGUgbG9jYXRpb24gaW4gdmlydHVhbCBhZGRyZXNzIHNwYWNlIG9mIHRoZSBtYWNoaW5lX3RvX3Bo eXMKKyAqIG1hcHBpbmcgdGFibGUuIEFyY2hpdGVjdHVyZXMgd2hpY2ggZG8gbm90IGhhdmUgYSBt MnAgdGFibGUsIG9yIHdoaWNoIGRvIG5vdAorICogbWFwIGl0IGJ5IGRlZmF1bHQgaW50byBndWVz dCBhZGRyZXNzIHNwYWNlLCBkbyBub3QgaW1wbGVtZW50IHRoaXMgY29tbWFuZC4KKyAqIGFyZyA9 PSBhZGRyIG9mIHhlbl9tYWNocGh5c19tYXBwaW5nX3QuCisgKi8KKyNkZWZpbmUgWEVOTUVNX21h Y2hwaHlzX21hcHBpbmcgICAgIDEyCitzdHJ1Y3QgeGVuX21hY2hwaHlzX21hcHBpbmcgeworICAg IHhlbl91bG9uZ190IHZfc3RhcnQsIHZfZW5kOyAvKiBTdGFydCBhbmQgZW5kIHZpcnR1YWwgYWRk cmVzc2VzLiAgICovCisgICAgeGVuX3Vsb25nX3QgbWF4X21mbjsgICAgICAgIC8qIE1heGltdW0g TUZOIHRoYXQgY2FuIGJlIGxvb2tlZCB1cC4gKi8KK307Cit0eXBlZGVmIHN0cnVjdCB4ZW5fbWFj aHBoeXNfbWFwcGluZyB4ZW5fbWFjaHBoeXNfbWFwcGluZ190OworREVGSU5FX1hFTl9HVUVTVF9I QU5ETEUoeGVuX21hY2hwaHlzX21hcHBpbmdfdCk7CisKKy8qIFNvdXJjZSBtYXBwaW5nIHNwYWNl LiAqLworLyogYCBlbnVtIHBoeXNfbWFwX3NwYWNlIHsgKi8KKyNkZWZpbmUgWEVOTUFQU1BBQ0Vf c2hhcmVkX2luZm8gIDAgLyogc2hhcmVkIGluZm8gcGFnZSAqLworI2RlZmluZSBYRU5NQVBTUEFD RV9ncmFudF90YWJsZSAgMSAvKiBncmFudCB0YWJsZSBwYWdlICovCisjZGVmaW5lIFhFTk1BUFNQ QUNFX2dtZm4gICAgICAgICAyIC8qIEdNRk4gKi8KKyNkZWZpbmUgWEVOTUFQU1BBQ0VfZ21mbl9y YW5nZSAgIDMgLyogR01GTiByYW5nZSwgWEVOTUVNX2FkZF90b19waHlzbWFwIG9ubHkuICovCisj ZGVmaW5lIFhFTk1BUFNQQUNFX2dtZm5fZm9yZWlnbiA0IC8qIEdNRk4gZnJvbSBhbm90aGVyIGRv bSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICogWEVOTUVNX2FkZF90b19w aHlzbWFwX2JhdGNoIG9ubHkuICovCisjZGVmaW5lIFhFTk1BUFNQQUNFX2Rldl9tbWlvICAgICA1 IC8qIGRldmljZSBtbWlvIHJlZ2lvbgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBBUk0gb25seTsgdGhlIHJlZ2lvbiBpcyBtYXBwZWQgaW4KKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgU3RhZ2UtMiB1c2luZyB0aGUgTm9ybWFsIE1lbW9yeQorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBJbm5lci9PdXRlciBXcml0ZS1CYWNr IENhY2hlYWJsZQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtZW1vcnkg YXR0cmlidXRlLiAqLworLyogYCB9ICovCisKKy8qCisgKiBTZXRzIHRoZSBHUEZOIGF0IHdoaWNo IGEgcGFydGljdWxhciBwYWdlIGFwcGVhcnMgaW4gdGhlIHNwZWNpZmllZCBndWVzdCdzCisgKiBw c2V1ZG9waHlzaWNhbCBhZGRyZXNzIHNwYWNlLgorICogYXJnID09IGFkZHIgb2YgeGVuX2FkZF90 b19waHlzbWFwX3QuCisgKi8KKyNkZWZpbmUgWEVOTUVNX2FkZF90b19waHlzbWFwICAgICAgNwor c3RydWN0IHhlbl9hZGRfdG9fcGh5c21hcCB7CisgICAgLyogV2hpY2ggZG9tYWluIHRvIGNoYW5n ZSB0aGUgbWFwcGluZyBmb3IuICovCisgICAgZG9taWRfdCBkb21pZDsKKworICAgIC8qIE51bWJl ciBvZiBwYWdlcyB0byBnbyB0aHJvdWdoIGZvciBnbWZuX3JhbmdlICovCisgICAgdWludDE2X3Qg ICAgc2l6ZTsKKworICAgIHVuc2lnbmVkIGludCBzcGFjZTsgLyogPT4gZW51bSBwaHlzX21hcF9z cGFjZSAqLworCisjZGVmaW5lIFhFTk1BUElEWF9ncmFudF90YWJsZV9zdGF0dXMgMHg4MDAwMDAw MAorCisgICAgLyogSW5kZXggaW50byBzcGFjZSBiZWluZyBtYXBwZWQuICovCisgICAgeGVuX3Vs b25nX3QgaWR4OworCisgICAgLyogR1BGTiBpbiBkb21pZCB3aGVyZSB0aGUgc291cmNlIG1hcHBp bmcgcGFnZSBzaG91bGQgYXBwZWFyLiAqLworICAgIHhlbl9wZm5fdCAgICAgZ3BmbjsKK307Cit0 eXBlZGVmIHN0cnVjdCB4ZW5fYWRkX3RvX3BoeXNtYXAgeGVuX2FkZF90b19waHlzbWFwX3Q7CitE RUZJTkVfWEVOX0dVRVNUX0hBTkRMRSh4ZW5fYWRkX3RvX3BoeXNtYXBfdCk7CisKKy8qIEEgYmF0 Y2hlZCB2ZXJzaW9uIG9mIGFkZF90b19waHlzbWFwLiAqLworI2RlZmluZSBYRU5NRU1fYWRkX3Rv X3BoeXNtYXBfYmF0Y2ggMjMKK3N0cnVjdCB4ZW5fYWRkX3RvX3BoeXNtYXBfYmF0Y2ggeworICAg IC8qIElOICovCisgICAgLyogV2hpY2ggZG9tYWluIHRvIGNoYW5nZSB0aGUgbWFwcGluZyBmb3Iu ICovCisgICAgZG9taWRfdCBkb21pZDsKKyAgICB1aW50MTZfdCBzcGFjZTsgLyogPT4gZW51bSBw aHlzX21hcF9zcGFjZSAqLworCisgICAgLyogTnVtYmVyIG9mIHBhZ2VzIHRvIGdvIHRocm91Z2gg Ki8KKyAgICB1aW50MTZfdCBzaXplOworCisjaWYgX19YRU5fSU5URVJGQUNFX1ZFUlNJT05fXyA8 IDB4MDAwNDA3MDAKKyAgICBkb21pZF90IGZvcmVpZ25fZG9taWQ7IC8qIElGRiBnbWZuX2ZvcmVp Z24uIFNob3VsZCBiZSAwIGZvciBvdGhlciBzcGFjZXMuICovCisjZWxzZQorICAgIHVuaW9uIHhl bl9hZGRfdG9fcGh5c21hcF9iYXRjaF9leHRyYSB7CisgICAgICAgIGRvbWlkX3QgZm9yZWlnbl9k b21pZDsgLyogZ21mbl9mb3JlaWduICovCisgICAgICAgIHVpbnQxNl90IHJlczA7ICAvKiBBbGwg dGhlIG90aGVyIHNwYWNlcy4gU2hvdWxkIGJlIDAgKi8KKyAgICB9IHU7CisjZW5kaWYKKworICAg IC8qIEluZGV4ZXMgaW50byBzcGFjZSBiZWluZyBtYXBwZWQuICovCisgICAgWEVOX0dVRVNUX0hB TkRMRSh4ZW5fdWxvbmdfdCkgaWR4czsKKworICAgIC8qIEdQRk4gaW4gZG9taWQgd2hlcmUgdGhl IHNvdXJjZSBtYXBwaW5nIHBhZ2Ugc2hvdWxkIGFwcGVhci4gKi8KKyAgICBYRU5fR1VFU1RfSEFO RExFKHhlbl9wZm5fdCkgZ3BmbnM7CisKKyAgICAvKiBPVVQgKi8KKworICAgIC8qIFBlciBpbmRl eCBlcnJvciBjb2RlLiAqLworICAgIFhFTl9HVUVTVF9IQU5ETEUoaW50KSBlcnJzOworfTsKK3R5 cGVkZWYgc3RydWN0IHhlbl9hZGRfdG9fcGh5c21hcF9iYXRjaCB4ZW5fYWRkX3RvX3BoeXNtYXBf YmF0Y2hfdDsKK0RFRklORV9YRU5fR1VFU1RfSEFORExFKHhlbl9hZGRfdG9fcGh5c21hcF9iYXRj aF90KTsKKworI2lmIF9fWEVOX0lOVEVSRkFDRV9WRVJTSU9OX18gPCAweDAwMDQwNDAwCisjZGVm aW5lIFhFTk1FTV9hZGRfdG9fcGh5c21hcF9yYW5nZSBYRU5NRU1fYWRkX3RvX3BoeXNtYXBfYmF0 Y2gKKyNkZWZpbmUgeGVuX2FkZF90b19waHlzbWFwX3JhbmdlIHhlbl9hZGRfdG9fcGh5c21hcF9i YXRjaAordHlwZWRlZiBzdHJ1Y3QgeGVuX2FkZF90b19waHlzbWFwX2JhdGNoIHhlbl9hZGRfdG9f cGh5c21hcF9yYW5nZV90OworREVGSU5FX1hFTl9HVUVTVF9IQU5ETEUoeGVuX2FkZF90b19waHlz bWFwX3JhbmdlX3QpOworI2VuZGlmCisKKy8qCisgKiBVbm1hcHMgdGhlIHBhZ2UgYXBwZWFyaW5n IGF0IGEgcGFydGljdWxhciBHUEZOIGZyb20gdGhlIHNwZWNpZmllZCBndWVzdCdzCisgKiBwc2V1 ZG9waHlzaWNhbCBhZGRyZXNzIHNwYWNlLgorICogYXJnID09IGFkZHIgb2YgeGVuX3JlbW92ZV9m cm9tX3BoeXNtYXBfdC4KKyAqLworI2RlZmluZSBYRU5NRU1fcmVtb3ZlX2Zyb21fcGh5c21hcCAg ICAgIDE1CitzdHJ1Y3QgeGVuX3JlbW92ZV9mcm9tX3BoeXNtYXAgeworICAgIC8qIFdoaWNoIGRv bWFpbiB0byBjaGFuZ2UgdGhlIG1hcHBpbmcgZm9yLiAqLworICAgIGRvbWlkX3QgZG9taWQ7CisK KyAgICAvKiBHUEZOIG9mIHRoZSBjdXJyZW50IG1hcHBpbmcgb2YgdGhlIHBhZ2UuICovCisgICAg eGVuX3Bmbl90ICAgICBncGZuOworfTsKK3R5cGVkZWYgc3RydWN0IHhlbl9yZW1vdmVfZnJvbV9w aHlzbWFwIHhlbl9yZW1vdmVfZnJvbV9waHlzbWFwX3Q7CitERUZJTkVfWEVOX0dVRVNUX0hBTkRM RSh4ZW5fcmVtb3ZlX2Zyb21fcGh5c21hcF90KTsKKworLyoqKiBSRU1PVkVEICoqKi8KKy8qI2Rl ZmluZSBYRU5NRU1fdHJhbnNsYXRlX2dwZm5fbGlzdCAgOCovCisKKy8qCisgKiBSZXR1cm5zIHRo ZSBwc2V1ZG8tcGh5c2ljYWwgbWVtb3J5IG1hcCBhcyBpdCB3YXMgd2hlbiB0aGUgZG9tYWluCisg KiB3YXMgc3RhcnRlZCAoc3BlY2lmaWVkIGJ5IFhFTk1FTV9zZXRfbWVtb3J5X21hcCkuCisgKiBh cmcgPT0gYWRkciBvZiB4ZW5fbWVtb3J5X21hcF90LgorICovCisjZGVmaW5lIFhFTk1FTV9tZW1v cnlfbWFwICAgICAgICAgICA5CitzdHJ1Y3QgeGVuX21lbW9yeV9tYXAgeworICAgIC8qCisgICAg ICogT24gY2FsbCB0aGUgbnVtYmVyIG9mIGVudHJpZXMgd2hpY2ggY2FuIGJlIHN0b3JlZCBpbiBi dWZmZXIuIE9uCisgICAgICogcmV0dXJuIHRoZSBudW1iZXIgb2YgZW50cmllcyB3aGljaCBoYXZl IGJlZW4gc3RvcmVkIGluCisgICAgICogYnVmZmVyLgorICAgICAqLworICAgIHVuc2lnbmVkIGlu dCBucl9lbnRyaWVzOworCisgICAgLyoKKyAgICAgKiBFbnRyaWVzIGluIHRoZSBidWZmZXIgYXJl IGluIHRoZSBzYW1lIGZvcm1hdCBhcyByZXR1cm5lZCBieSB0aGUKKyAgICAgKiBCSU9TIElOVCAw eDE1IEVBWD0weEU4MjAgY2FsbC4KKyAgICAgKi8KKyAgICBYRU5fR1VFU1RfSEFORExFKHZvaWQp IGJ1ZmZlcjsKK307Cit0eXBlZGVmIHN0cnVjdCB4ZW5fbWVtb3J5X21hcCB4ZW5fbWVtb3J5X21h cF90OworREVGSU5FX1hFTl9HVUVTVF9IQU5ETEUoeGVuX21lbW9yeV9tYXBfdCk7CisKKy8qCisg KiBSZXR1cm5zIHRoZSByZWFsIHBoeXNpY2FsIG1lbW9yeSBtYXAuIFBhc3NlcyB0aGUgc2FtZSBz dHJ1Y3R1cmUgYXMKKyAqIFhFTk1FTV9tZW1vcnlfbWFwLgorICogU3BlY2lmeWluZyBidWZmZXIg YXMgTlVMTCB3aWxsIHJldHVybiB0aGUgbnVtYmVyIG9mIGVudHJpZXMgcmVxdWlyZWQKKyAqIHRv IHN0b3JlIHRoZSBjb21wbGV0ZSBtZW1vcnkgbWFwLgorICogYXJnID09IGFkZHIgb2YgeGVuX21l bW9yeV9tYXBfdC4KKyAqLworI2RlZmluZSBYRU5NRU1fbWFjaGluZV9tZW1vcnlfbWFwICAgMTAK KworLyoKKyAqIFNldCB0aGUgcHNldWRvLXBoeXNpY2FsIG1lbW9yeSBtYXAgb2YgYSBkb21haW4s IGFzIHJldHVybmVkIGJ5CisgKiBYRU5NRU1fbWVtb3J5X21hcC4KKyAqIGFyZyA9PSBhZGRyIG9m IHhlbl9mb3JlaWduX21lbW9yeV9tYXBfdC4KKyAqLworI2RlZmluZSBYRU5NRU1fc2V0X21lbW9y eV9tYXAgICAgICAgMTMKK3N0cnVjdCB4ZW5fZm9yZWlnbl9tZW1vcnlfbWFwIHsKKyAgICBkb21p ZF90IGRvbWlkOworICAgIHN0cnVjdCB4ZW5fbWVtb3J5X21hcCBtYXA7Cit9OwordHlwZWRlZiBz dHJ1Y3QgeGVuX2ZvcmVpZ25fbWVtb3J5X21hcCB4ZW5fZm9yZWlnbl9tZW1vcnlfbWFwX3Q7CitE RUZJTkVfWEVOX0dVRVNUX0hBTkRMRSh4ZW5fZm9yZWlnbl9tZW1vcnlfbWFwX3QpOworCisjZGVm aW5lIFhFTk1FTV9zZXRfcG9kX3RhcmdldCAgICAgICAxNgorI2RlZmluZSBYRU5NRU1fZ2V0X3Bv ZF90YXJnZXQgICAgICAgMTcKK3N0cnVjdCB4ZW5fcG9kX3RhcmdldCB7CisgICAgLyogSU4gKi8K KyAgICB1aW50NjRfdCB0YXJnZXRfcGFnZXM7CisgICAgLyogT1VUICovCisgICAgdWludDY0X3Qg dG90X3BhZ2VzOworICAgIHVpbnQ2NF90IHBvZF9jYWNoZV9wYWdlczsKKyAgICB1aW50NjRfdCBw b2RfZW50cmllczsKKyAgICAvKiBJTiAqLworICAgIGRvbWlkX3QgZG9taWQ7Cit9OwordHlwZWRl ZiBzdHJ1Y3QgeGVuX3BvZF90YXJnZXQgeGVuX3BvZF90YXJnZXRfdDsKKworI2lmIGRlZmluZWQo X19YRU5fXykgfHwgZGVmaW5lZChfX1hFTl9UT09MU19fKQorCisjaWZuZGVmIHVpbnQ2NF9hbGln bmVkX3QKKyNkZWZpbmUgdWludDY0X2FsaWduZWRfdCB1aW50NjRfdAorI2VuZGlmCisKKy8qCisg KiBHZXQgdGhlIG51bWJlciBvZiBNRk5zIHNhdmVkIHRocm91Z2ggbWVtb3J5IHNoYXJpbmcuCisg KiBUaGUgY2FsbCBuZXZlciBmYWlscy4gCisgKi8KKyNkZWZpbmUgWEVOTUVNX2dldF9zaGFyaW5n X2ZyZWVkX3BhZ2VzICAgIDE4CisjZGVmaW5lIFhFTk1FTV9nZXRfc2hhcmluZ19zaGFyZWRfcGFn ZXMgICAxOQorCisjZGVmaW5lIFhFTk1FTV9wYWdpbmdfb3AgICAgICAgICAgICAgICAgICAgIDIw CisjZGVmaW5lIFhFTk1FTV9wYWdpbmdfb3Bfbm9taW5hdGUgICAgICAgICAgIDAKKyNkZWZpbmUg WEVOTUVNX3BhZ2luZ19vcF9ldmljdCAgICAgICAgICAgICAgMQorI2RlZmluZSBYRU5NRU1fcGFn aW5nX29wX3ByZXAgICAgICAgICAgICAgICAyCisKK3N0cnVjdCB4ZW5fbWVtX3BhZ2luZ19vcCB7 CisgICAgdWludDhfdCAgICAgb3A7ICAgICAgICAgLyogWEVOTUVNX3BhZ2luZ19vcF8qICovCisg ICAgZG9taWRfdCAgICAgZG9tYWluOworCisgICAgLyogUEFHSU5HX1BSRVAgSU46IGJ1ZmZlciB0 byBpbW1lZGlhdGVseSBmaWxsIHBhZ2UgaW4gKi8KKyAgICB1aW50NjRfYWxpZ25lZF90ICAgIGJ1 ZmZlcjsKKyAgICAvKiBPdGhlciBPUHMgKi8KKyAgICB1aW50NjRfYWxpZ25lZF90ICAgIGdmbjsg ICAgICAgICAgIC8qIElOOiAgZ2ZuIG9mIHBhZ2UgYmVpbmcgb3BlcmF0ZWQgb24gKi8KK307Cit0 eXBlZGVmIHN0cnVjdCB4ZW5fbWVtX3BhZ2luZ19vcCB4ZW5fbWVtX3BhZ2luZ19vcF90OworREVG SU5FX1hFTl9HVUVTVF9IQU5ETEUoeGVuX21lbV9wYWdpbmdfb3BfdCk7CisKKyNkZWZpbmUgWEVO TUVNX2FjY2Vzc19vcCAgICAgICAgICAgICAgICAgICAgMjEKKyNkZWZpbmUgWEVOTUVNX2FjY2Vz c19vcF9zZXRfYWNjZXNzICAgICAgICAgMAorI2RlZmluZSBYRU5NRU1fYWNjZXNzX29wX2dldF9h Y2Nlc3MgICAgICAgICAxCisvKgorICogWEVOTUVNX2FjY2Vzc19vcF9lbmFibGVfZW11bGF0ZSBh bmQgWEVOTUVNX2FjY2Vzc19vcF9kaXNhYmxlX2VtdWxhdGUgYXJlCisgKiBjdXJyZW50bHkgdW51 c2VkLCBidXQgc2luY2UgdGhleSBoYXZlIGJlZW4gaW4gdXNlIHBsZWFzZSBkbyBub3QgcmV1c2Ug dGhlbS4KKyAqCisgKiAjZGVmaW5lIFhFTk1FTV9hY2Nlc3Nfb3BfZW5hYmxlX2VtdWxhdGUgICAg IDIKKyAqICNkZWZpbmUgWEVOTUVNX2FjY2Vzc19vcF9kaXNhYmxlX2VtdWxhdGUgICAgMworICov CisjZGVmaW5lIFhFTk1FTV9hY2Nlc3Nfb3Bfc2V0X2FjY2Vzc19tdWx0aSAgIDQKKwordHlwZWRl ZiBlbnVtIHsKKyAgICBYRU5NRU1fYWNjZXNzX24sCisgICAgWEVOTUVNX2FjY2Vzc19yLAorICAg IFhFTk1FTV9hY2Nlc3NfdywKKyAgICBYRU5NRU1fYWNjZXNzX3J3LAorICAgIFhFTk1FTV9hY2Nl c3NfeCwKKyAgICBYRU5NRU1fYWNjZXNzX3J4LAorICAgIFhFTk1FTV9hY2Nlc3Nfd3gsCisgICAg WEVOTUVNX2FjY2Vzc19yd3gsCisgICAgLyoKKyAgICAgKiBQYWdlIHN0YXJ0cyBvZmYgYXMgci14 LCBidXQgYXV0b21hdGljYWxseQorICAgICAqIGNoYW5nZSB0byByLXcgb24gYSB3cml0ZQorICAg ICAqLworICAgIFhFTk1FTV9hY2Nlc3NfcngycncsCisgICAgLyoKKyAgICAgKiBMb2cgYWNjZXNz OiBzdGFydHMgb2ZmIGFzIG4sIGF1dG9tYXRpY2FsbHkKKyAgICAgKiBnb2VzIHRvIHJ3eCwgZ2Vu ZXJhdGluZyBhbiBldmVudCB3aXRob3V0CisgICAgICogcGF1c2luZyB0aGUgdmNwdQorICAgICAq LworICAgIFhFTk1FTV9hY2Nlc3NfbjJyd3gsCisgICAgLyogVGFrZSB0aGUgZG9tYWluIGRlZmF1 bHQgKi8KKyAgICBYRU5NRU1fYWNjZXNzX2RlZmF1bHQKK30geGVubWVtX2FjY2Vzc190OworCitz dHJ1Y3QgeGVuX21lbV9hY2Nlc3Nfb3AgeworICAgIC8qIFhFTk1FTV9hY2Nlc3Nfb3BfKiAqLwor ICAgIHVpbnQ4X3Qgb3A7CisgICAgLyogeGVubWVtX2FjY2Vzc190ICovCisgICAgdWludDhfdCBh Y2Nlc3M7CisgICAgZG9taWRfdCBkb21pZDsKKyAgICAvKgorICAgICAqIE51bWJlciBvZiBwYWdl cyBmb3Igc2V0IG9wIChvciBzaXplIG9mIHBmbl9saXN0IGZvcgorICAgICAqIFhFTk1FTV9hY2Nl c3Nfb3Bfc2V0X2FjY2Vzc19tdWx0aSkKKyAgICAgKiBJZ25vcmVkIG9uIHNldHRpbmcgZGVmYXVs dCBhY2Nlc3MgYW5kIG90aGVyIG9wcworICAgICAqLworICAgIHVpbnQzMl90IG5yOworICAgIC8q CisgICAgICogRmlyc3QgcGZuIGZvciBzZXQgb3AKKyAgICAgKiBwZm4gZm9yIGdldCBvcAorICAg ICAqIH4wdWxsIGlzIHVzZWQgdG8gc2V0IGFuZCBnZXQgdGhlIGRlZmF1bHQgYWNjZXNzIGZvciBw YWdlcworICAgICAqLworICAgIHVpbnQ2NF9hbGlnbmVkX3QgcGZuOworICAgIC8qCisgICAgICog TGlzdCBvZiBwZm5zIHRvIHNldCBhY2Nlc3MgZm9yCisgICAgICogVXNlZCBvbmx5IHdpdGggWEVO TUVNX2FjY2Vzc19vcF9zZXRfYWNjZXNzX211bHRpCisgICAgICovCisgICAgWEVOX0dVRVNUX0hB TkRMRShjb25zdF91aW50NjQpIHBmbl9saXN0OworICAgIC8qCisgICAgICogQ29ycmVzcG9uZGlu ZyBsaXN0IG9mIGFjY2VzcyBzZXR0aW5ncyBmb3IgcGZuX2xpc3QKKyAgICAgKiBVc2VkIG9ubHkg d2l0aCBYRU5NRU1fYWNjZXNzX29wX3NldF9hY2Nlc3NfbXVsdGkKKyAgICAgKi8KKyAgICBYRU5f R1VFU1RfSEFORExFKGNvbnN0X3VpbnQ4KSBhY2Nlc3NfbGlzdDsKK307Cit0eXBlZGVmIHN0cnVj dCB4ZW5fbWVtX2FjY2Vzc19vcCB4ZW5fbWVtX2FjY2Vzc19vcF90OworREVGSU5FX1hFTl9HVUVT VF9IQU5ETEUoeGVuX21lbV9hY2Nlc3Nfb3BfdCk7CisKKyNkZWZpbmUgWEVOTUVNX3NoYXJpbmdf b3AgICAgICAgICAgICAgICAgICAgMjIKKyNkZWZpbmUgWEVOTUVNX3NoYXJpbmdfb3Bfbm9taW5h dGVfZ2ZuICAgICAgMAorI2RlZmluZSBYRU5NRU1fc2hhcmluZ19vcF9ub21pbmF0ZV9ncmVmICAg ICAxCisjZGVmaW5lIFhFTk1FTV9zaGFyaW5nX29wX3NoYXJlICAgICAgICAgICAgIDIKKyNkZWZp bmUgWEVOTUVNX3NoYXJpbmdfb3BfZGVidWdfZ2ZuICAgICAgICAgMworI2RlZmluZSBYRU5NRU1f c2hhcmluZ19vcF9kZWJ1Z19tZm4gICAgICAgICA0CisjZGVmaW5lIFhFTk1FTV9zaGFyaW5nX29w X2RlYnVnX2dyZWYgICAgICAgIDUKKyNkZWZpbmUgWEVOTUVNX3NoYXJpbmdfb3BfYWRkX3BoeXNt YXAgICAgICAgNgorI2RlZmluZSBYRU5NRU1fc2hhcmluZ19vcF9hdWRpdCAgICAgICAgICAgICA3 CisjZGVmaW5lIFhFTk1FTV9zaGFyaW5nX29wX3JhbmdlX3NoYXJlICAgICAgIDgKKworI2RlZmlu ZSBYRU5NRU1fU0hBUklOR19PUF9TX0hBTkRMRV9JTlZBTElEICAoLTEwKQorI2RlZmluZSBYRU5N RU1fU0hBUklOR19PUF9DX0hBTkRMRV9JTlZBTElEICAoLTkpCisKKy8qIFRoZSBmb2xsb3dpbmcg YWxsb3dzIHNoYXJpbmcgb2YgZ3JhbnQgcmVmcy4gVGhpcyBpcyB1c2VmdWwKKyAqIGZvciBzaGFy aW5nIHV0aWxpdGllcyBzaXR0aW5nIGFzICJmaWx0ZXJzIiBpbiBJTyBiYWNrZW5kcworICogKGUu Zy4gbWVtc2hyICsgYmxrdGFwKDIpKS4gVGhlIElPIGJhY2tlbmQgaXMgb25seSBleHBvc2VkIAor ICogdG8gZ3JhbnQgcmVmZXJlbmNlcywgYW5kIHRoaXMgYWxsb3dzIHNoYXJpbmcgb2YgdGhlIGdy ZWZzICovCisjZGVmaW5lIFhFTk1FTV9TSEFSSU5HX09QX0ZJRUxEX0lTX0dSRUZfRkxBRyAgICh4 ZW5fbWtfdWxsb25nKDEpIDw8IDYyKQorCisjZGVmaW5lIFhFTk1FTV9TSEFSSU5HX09QX0ZJRUxE X01BS0VfR1JFRihmaWVsZCwgdmFsKSAgXAorICAgIChmaWVsZCkgPSAoWEVOTUVNX1NIQVJJTkdf T1BfRklFTERfSVNfR1JFRl9GTEFHIHwgdmFsKQorI2RlZmluZSBYRU5NRU1fU0hBUklOR19PUF9G SUVMRF9JU19HUkVGKGZpZWxkKSAgICAgICAgIFwKKyAgICAoKGZpZWxkKSAmIFhFTk1FTV9TSEFS SU5HX09QX0ZJRUxEX0lTX0dSRUZfRkxBRykKKyNkZWZpbmUgWEVOTUVNX1NIQVJJTkdfT1BfRklF TERfR0VUX0dSRUYoZmllbGQpICAgICAgICBcCisgICAgKChmaWVsZCkgJiAoflhFTk1FTV9TSEFS SU5HX09QX0ZJRUxEX0lTX0dSRUZfRkxBRykpCisKK3N0cnVjdCB4ZW5fbWVtX3NoYXJpbmdfb3Ag eworICAgIHVpbnQ4X3QgICAgIG9wOyAgICAgLyogWEVOTUVNX3NoYXJpbmdfb3BfKiAqLworICAg IGRvbWlkX3QgICAgIGRvbWFpbjsKKworICAgIHVuaW9uIHsKKyAgICAgICAgc3RydWN0IG1lbV9z aGFyaW5nX29wX25vbWluYXRlIHsgIC8qIE9QX05PTUlOQVRFX3h4eCAgICAgICAgICAgKi8KKyAg ICAgICAgICAgIHVuaW9uIHsKKyAgICAgICAgICAgICAgICB1aW50NjRfYWxpZ25lZF90IGdmbjsg ICAgIC8qIElOOiBnZm4gdG8gbm9taW5hdGUgICAgICAgKi8KKyAgICAgICAgICAgICAgICB1aW50 MzJfdCAgICAgIGdyYW50X3JlZjsgIC8qIElOOiBncmFudCByZWYgdG8gbm9taW5hdGUgKi8KKyAg ICAgICAgICAgIH0gdTsKKyAgICAgICAgICAgIHVpbnQ2NF9hbGlnbmVkX3QgIGhhbmRsZTsgICAg IC8qIE9VVDogdGhlIGhhbmRsZSAgICAgICAgICAgKi8KKyAgICAgICAgfSBub21pbmF0ZTsKKyAg ICAgICAgc3RydWN0IG1lbV9zaGFyaW5nX29wX3NoYXJlIHsgICAgIC8qIE9QX1NIQVJFL0FERF9Q SFlTTUFQICovCisgICAgICAgICAgICB1aW50NjRfYWxpZ25lZF90IHNvdXJjZV9nZm47ICAgIC8q IElOOiB0aGUgZ2ZuIG9mIHRoZSBzb3VyY2UgcGFnZSAqLworICAgICAgICAgICAgdWludDY0X2Fs aWduZWRfdCBzb3VyY2VfaGFuZGxlOyAvKiBJTjogaGFuZGxlIHRvIHRoZSBzb3VyY2UgcGFnZSAq LworICAgICAgICAgICAgdWludDY0X2FsaWduZWRfdCBjbGllbnRfZ2ZuOyAgICAvKiBJTjogdGhl IGNsaWVudCBnZm4gKi8KKyAgICAgICAgICAgIHVpbnQ2NF9hbGlnbmVkX3QgY2xpZW50X2hhbmRs ZTsgLyogSU46IGhhbmRsZSB0byB0aGUgY2xpZW50IHBhZ2UgKi8KKyAgICAgICAgICAgIGRvbWlk X3QgIGNsaWVudF9kb21haW47IC8qIElOOiB0aGUgY2xpZW50IGRvbWFpbiBpZCAqLworICAgICAg ICB9IHNoYXJlOworICAgICAgICBzdHJ1Y3QgbWVtX3NoYXJpbmdfb3BfcmFuZ2UgeyAgICAgICAg IC8qIE9QX1JBTkdFX1NIQVJFICovCisgICAgICAgICAgICB1aW50NjRfYWxpZ25lZF90IGZpcnN0 X2dmbjsgICAgICAvKiBJTjogdGhlIGZpcnN0IGdmbiAqLworICAgICAgICAgICAgdWludDY0X2Fs aWduZWRfdCBsYXN0X2dmbjsgICAgICAgLyogSU46IHRoZSBsYXN0IGdmbiAqLworICAgICAgICAg ICAgdWludDY0X2FsaWduZWRfdCBvcGFxdWU7ICAgICAgICAgLyogTXVzdCBiZSBzZXQgdG8gMCAq LworICAgICAgICAgICAgZG9taWRfdCBjbGllbnRfZG9tYWluOyAgICAgICAgICAgLyogSU46IHRo ZSBjbGllbnQgZG9tYWluIGlkICovCisgICAgICAgICAgICB1aW50MTZfdCBfcGFkWzNdOyAgICAg ICAgICAgICAgICAvKiBNdXN0IGJlIHNldCB0byAwICovCisgICAgICAgIH0gcmFuZ2U7CisgICAg ICAgIHN0cnVjdCBtZW1fc2hhcmluZ19vcF9kZWJ1ZyB7ICAgICAvKiBPUF9ERUJVR194eHggKi8K KyAgICAgICAgICAgIHVuaW9uIHsKKyAgICAgICAgICAgICAgICB1aW50NjRfYWxpZ25lZF90IGdm bjsgICAgICAvKiBJTjogZ2ZuIHRvIGRlYnVnICAgICAgICAgICovCisgICAgICAgICAgICAgICAg dWludDY0X2FsaWduZWRfdCBtZm47ICAgICAgLyogSU46IG1mbiB0byBkZWJ1ZyAgICAgICAgICAq LworICAgICAgICAgICAgICAgIHVpbnQzMl90IGdyZWY7ICAgICAvKiBJTjogZ3JlZiB0byBkZWJ1 ZyAgICAgICAgICovCisgICAgICAgICAgICB9IHU7CisgICAgICAgIH0gZGVidWc7CisgICAgfSB1 OworfTsKK3R5cGVkZWYgc3RydWN0IHhlbl9tZW1fc2hhcmluZ19vcCB4ZW5fbWVtX3NoYXJpbmdf b3BfdDsKK0RFRklORV9YRU5fR1VFU1RfSEFORExFKHhlbl9tZW1fc2hhcmluZ19vcF90KTsKKwor LyoKKyAqIEF0dGVtcHQgdG8gc3Rha2UgYSBjbGFpbSBmb3IgYSBkb21haW4gb24gYSBxdWFudGl0 eSBvZiBwYWdlcworICogb2Ygc3lzdGVtIFJBTSwgYnV0IF9ub3RfIGFzc2lnbiBzcGVjaWZpYyBw YWdlZnJhbWVzLiAgT25seQorICogYXJpdGhtZXRpYyBpcyBwZXJmb3JtZWQgc28gdGhlIGh5cGVy Y2FsbCBpcyB2ZXJ5IGZhc3QgYW5kIG5lZWQKKyAqIG5vdCBiZSBwcmVlbXB0aWJsZSwgdGh1cyBz aWRlc3RlcHBpbmcgdGltZS1vZi1jaGVjay10aW1lLW9mLXVzZQorICogcmFjZXMgZm9yIG1lbW9y eSBhbGxvY2F0aW9uLiAgUmV0dXJucyAwIGlmIHRoZSBoeXBlcnZpc29yIHBhZ2UKKyAqIGFsbG9j YXRvciBoYXMgYXRvbWljYWxseSBhbmQgc3VjY2Vzc2Z1bGx5IGNsYWltZWQgdGhlIHJlcXVlc3Rl ZAorICogbnVtYmVyIG9mIHBhZ2VzLCBlbHNlIG5vbi16ZXJvLgorICoKKyAqIEFueSBkb21haW4g bWF5IGhhdmUgb25seSBvbmUgYWN0aXZlIGNsYWltLiAgV2hlbiBzdWZmaWNpZW50IG1lbW9yeQor ICogaGFzIGJlZW4gYWxsb2NhdGVkIHRvIHJlc29sdmUgdGhlIGNsYWltLCB0aGUgY2xhaW0gc2ls ZW50bHkgZXhwaXJlcy4KKyAqIENsYWltaW5nIHplcm8gcGFnZXMgZWZmZWN0aXZlbHkgcmVzZXRz IGFueSBvdXRzdGFuZGluZyBjbGFpbSBhbmQKKyAqIGlzIGFsd2F5cyBzdWNjZXNzZnVsLgorICoK KyAqIE5vdGUgdGhhdCBhIHZhbGlkIGNsYWltIG1heSBiZSBzdGFrZWQgZXZlbiBhZnRlciBtZW1v cnkgaGFzIGJlZW4KKyAqIGFsbG9jYXRlZCBmb3IgYSBkb21haW4uICBJbiB0aGlzIGNhc2UsIHRo ZSBjbGFpbSBpcyBub3QgaW5jcmVtZW50YWwsCisgKiBpLmUuIGlmIHRoZSBkb21haW4ncyB0b3Rf cGFnZXMgaXMgMywgYW5kIGEgY2xhaW0gaXMgc3Rha2VkIGZvciAxMCwKKyAqIG9ubHkgNyBhZGRp dGlvbmFsIHBhZ2VzIGFyZSBjbGFpbWVkLgorICoKKyAqIENhbGxlciBtdXN0IGJlIHByaXZpbGVn ZWQgb3IgdGhlIGh5cGVyY2FsbCBmYWlscy4KKyAqLworI2RlZmluZSBYRU5NRU1fY2xhaW1fcGFn ZXMgICAgICAgICAgICAgICAgICAyNAorCisvKgorICogWEVOTUVNX2NsYWltX3BhZ2VzIGZsYWdz IC0gdGhlIGFyZSBubyBmbGFncyBhdCB0aGlzIHRpbWUuCisgKiBUaGUgemVybyB2YWx1ZSBpcyBh cHByb3ByaWF0ZS4KKyAqLworCisvKgorICogV2l0aCBzb21lIGxlZ2FjeSBkZXZpY2VzLCBjZXJ0 YWluIGd1ZXN0LXBoeXNpY2FsIGFkZHJlc3NlcyBjYW5ub3Qgc2FmZWx5CisgKiBiZSB1c2VkIGZv ciBvdGhlciBwdXJwb3NlcywgZS5nLiB0byBtYXAgZ3Vlc3QgUkFNLiAgVGhpcyBoeXBlcmNhbGwK KyAqIGVudW1lcmF0ZXMgdGhvc2UgcmVnaW9ucyBzbyB0aGUgdG9vbHN0YWNrIGNhbiBhdm9pZCB1 c2luZyB0aGVtLgorICovCisjZGVmaW5lIFhFTk1FTV9yZXNlcnZlZF9kZXZpY2VfbWVtb3J5X21h cCAgIDI3CitzdHJ1Y3QgeGVuX3Jlc2VydmVkX2RldmljZV9tZW1vcnkgeworICAgIHhlbl9wZm5f dCBzdGFydF9wZm47CisgICAgeGVuX3Vsb25nX3QgbnJfcGFnZXM7Cit9OwordHlwZWRlZiBzdHJ1 Y3QgeGVuX3Jlc2VydmVkX2RldmljZV9tZW1vcnkgeGVuX3Jlc2VydmVkX2RldmljZV9tZW1vcnlf dDsKK0RFRklORV9YRU5fR1VFU1RfSEFORExFKHhlbl9yZXNlcnZlZF9kZXZpY2VfbWVtb3J5X3Qp OworCitzdHJ1Y3QgeGVuX3Jlc2VydmVkX2RldmljZV9tZW1vcnlfbWFwIHsKKyNkZWZpbmUgWEVO TUVNX1JETV9BTEwgMSAvKiBSZXF1ZXN0IGFsbCByZWdpb25zIChpZ25vcmUgZGV2IHVuaW9uKS4g Ki8KKyAgICAvKiBJTiAqLworICAgIHVpbnQzMl90IGZsYWdzOworICAgIC8qCisgICAgICogSU4v T1VUCisgICAgICoKKyAgICAgKiBHZXRzIHNldCB0byB0aGUgcmVxdWlyZWQgbnVtYmVyIG9mIGVu dHJpZXMgd2hlbiB0b28gbG93LAorICAgICAqIHNpZ25hbGVkIGJ5IGVycm9yIGNvZGUgLUVSQU5H RS4KKyAgICAgKi8KKyAgICB1bnNpZ25lZCBpbnQgbnJfZW50cmllczsKKyAgICAvKiBPVVQgKi8K KyAgICBYRU5fR1VFU1RfSEFORExFKHhlbl9yZXNlcnZlZF9kZXZpY2VfbWVtb3J5X3QpIGJ1ZmZl cjsKKyAgICAvKiBJTiAqLworICAgIHVuaW9uIHsKKyAgICAgICAgc3RydWN0IHBoeXNkZXZfcGNp X2RldmljZSBwY2k7CisgICAgfSBkZXY7Cit9OwordHlwZWRlZiBzdHJ1Y3QgeGVuX3Jlc2VydmVk X2RldmljZV9tZW1vcnlfbWFwIHhlbl9yZXNlcnZlZF9kZXZpY2VfbWVtb3J5X21hcF90OworREVG SU5FX1hFTl9HVUVTVF9IQU5ETEUoeGVuX3Jlc2VydmVkX2RldmljZV9tZW1vcnlfbWFwX3QpOwor CisjZW5kaWYgLyogZGVmaW5lZChfX1hFTl9fKSB8fCBkZWZpbmVkKF9fWEVOX1RPT0xTX18pICov CisKKy8qCisgKiBYRU5NRU1fZ2V0X3ZudW1haW5mbyB1c2VkIGJ5IGd1ZXN0IHRvIGdldAorICog dk5VTUEgdG9wb2xvZ3kgZnJvbSBoeXBlcnZpc29yLgorICovCisjZGVmaW5lIFhFTk1FTV9nZXRf dm51bWFpbmZvICAgICAgICAgICAgICAgIDI2CisKKy8qIHZOVU1BIG5vZGUgbWVtb3J5IHJhbmdl cyAqLworc3RydWN0IHhlbl92bWVtcmFuZ2UgeworICAgIHVpbnQ2NF90IHN0YXJ0LCBlbmQ7Cisg ICAgdW5zaWduZWQgaW50IGZsYWdzOworICAgIHVuc2lnbmVkIGludCBuaWQ7Cit9OwordHlwZWRl ZiBzdHJ1Y3QgeGVuX3ZtZW1yYW5nZSB4ZW5fdm1lbXJhbmdlX3Q7CitERUZJTkVfWEVOX0dVRVNU X0hBTkRMRSh4ZW5fdm1lbXJhbmdlX3QpOworCisvKgorICogdk5VTUEgdG9wb2xvZ3kgc3BlY2lm aWVzIHZOVU1BIG5vZGUgbnVtYmVyLCBkaXN0YW5jZSB0YWJsZSwKKyAqIG1lbW9yeSByYW5nZXMg YW5kIHZjcHUgbWFwcGluZyBwcm92aWRlZCBmb3IgZ3Vlc3RzLgorICogWEVOTUVNX2dldF92bnVt YWluZm8gaHlwZXJjYWxsIGV4cGVjdHMgdG8gc2VlIGZyb20gZ3Vlc3QKKyAqIG5yX3Zub2Rlcywg bnJfdm1lbXJhbmdlcyBhbmQgbnJfdmNwdXMgdG8gaW5kaWNhdGUgYXZhaWxhYmxlIG1lbW9yeS4K KyAqIEFmdGVyIGZpbGxpbmcgZ3Vlc3RzIHN0cnVjdHVyZXMsIG5yX3Zub2RlcywgbnJfdm1lbXJh bmdlcyBhbmQgbnJfdmNwdXMKKyAqIGNvcGllZCBiYWNrIHRvIGd1ZXN0LiBEb21haW4gcmV0dXJu cyBleHBlY3RlZCB2YWx1ZXMgb2YgbnJfdm5vZGVzLAorICogbnJfdm1lbXJhbmdlcyBhbmQgbnJf dmNwdXMgdG8gZ3Vlc3QgaWYgdGhlIHZhbHVlcyB3aGVyZSBpbmNvcnJlY3QuCisgKi8KK3N0cnVj dCB4ZW5fdm51bWFfdG9wb2xvZ3lfaW5mbyB7CisgICAgLyogSU4gKi8KKyAgICBkb21pZF90IGRv bWlkOworICAgIHVpbnQxNl90IHBhZDsKKyAgICAvKiBJTi9PVVQgKi8KKyAgICB1bnNpZ25lZCBp bnQgbnJfdm5vZGVzOworICAgIHVuc2lnbmVkIGludCBucl92Y3B1czsKKyAgICB1bnNpZ25lZCBp bnQgbnJfdm1lbXJhbmdlczsKKyAgICAvKiBPVVQgKi8KKyAgICB1bmlvbiB7CisgICAgICAgIFhF Tl9HVUVTVF9IQU5ETEUodWludCkgaDsKKyAgICAgICAgdWludDY0X3QgcGFkOworICAgIH0gdmRp c3RhbmNlOworICAgIHVuaW9uIHsKKyAgICAgICAgWEVOX0dVRVNUX0hBTkRMRSh1aW50KSBoOwor ICAgICAgICB1aW50NjRfdCBwYWQ7CisgICAgfSB2Y3B1X3RvX3Zub2RlOworICAgIHVuaW9uIHsK KyAgICAgICAgWEVOX0dVRVNUX0hBTkRMRSh4ZW5fdm1lbXJhbmdlX3QpIGg7CisgICAgICAgIHVp bnQ2NF90IHBhZDsKKyAgICB9IHZtZW1yYW5nZTsKK307Cit0eXBlZGVmIHN0cnVjdCB4ZW5fdm51 bWFfdG9wb2xvZ3lfaW5mbyB4ZW5fdm51bWFfdG9wb2xvZ3lfaW5mb190OworREVGSU5FX1hFTl9H VUVTVF9IQU5ETEUoeGVuX3ZudW1hX3RvcG9sb2d5X2luZm9fdCk7CisKKy8qIE5leHQgYXZhaWxh YmxlIHN1Ym9wIG51bWJlciBpcyAyOCAqLworCisjZW5kaWYgLyogX19YRU5fUFVCTElDX01FTU9S WV9IX18gKi8KKworLyoKKyAqIExvY2FsIHZhcmlhYmxlczoKKyAqIG1vZGU6IEMKKyAqIGMtZmls ZS1zdHlsZTogIkJTRCIKKyAqIGMtYmFzaWMtb2Zmc2V0OiA0CisgKiB0YWItd2lkdGg6IDQKKyAq IGluZGVudC10YWJzLW1vZGU6IG5pbAorICogRW5kOgorICovCmRpZmYgLS1naXQgYS9pbmNsdWRl L3hlbi9waHlzZGV2LmggYi9pbmNsdWRlL3hlbi9waHlzZGV2LmgKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwLi4wZTU0NjM1NjIKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRl L3hlbi9waHlzZGV2LmgKQEAgLTAsMCArMSwzODcgQEAKKy8qCisgKiBQZXJtaXNzaW9uIGlzIGhl cmVieSBncmFudGVkLCBmcmVlIG9mIGNoYXJnZSwgdG8gYW55IHBlcnNvbiBvYnRhaW5pbmcgYSBj b3B5CisgKiBvZiB0aGlzIHNvZnR3YXJlIGFuZCBhc3NvY2lhdGVkIGRvY3VtZW50YXRpb24gZmls ZXMgKHRoZSAiU29mdHdhcmUiKSwgdG8KKyAqIGRlYWwgaW4gdGhlIFNvZnR3YXJlIHdpdGhvdXQg cmVzdHJpY3Rpb24sIGluY2x1ZGluZyB3aXRob3V0IGxpbWl0YXRpb24gdGhlCisgKiByaWdodHMg dG8gdXNlLCBjb3B5LCBtb2RpZnksIG1lcmdlLCBwdWJsaXNoLCBkaXN0cmlidXRlLCBzdWJsaWNl bnNlLCBhbmQvb3IKKyAqIHNlbGwgY29waWVzIG9mIHRoZSBTb2Z0d2FyZSwgYW5kIHRvIHBlcm1p dCBwZXJzb25zIHRvIHdob20gdGhlIFNvZnR3YXJlIGlzCisgKiBmdXJuaXNoZWQgdG8gZG8gc28s IHN1YmplY3QgdG8gdGhlIGZvbGxvd2luZyBjb25kaXRpb25zOgorICoKKyAqIFRoZSBhYm92ZSBj b3B5cmlnaHQgbm90aWNlIGFuZCB0aGlzIHBlcm1pc3Npb24gbm90aWNlIHNoYWxsIGJlIGluY2x1 ZGVkIGluCisgKiBhbGwgY29waWVzIG9yIHN1YnN0YW50aWFsIHBvcnRpb25zIG9mIHRoZSBTb2Z0 d2FyZS4KKyAqCisgKiBUSEUgU09GVFdBUkUgSVMgUFJPVklERUQgIkFTIElTIiwgV0lUSE9VVCBX QVJSQU5UWSBPRiBBTlkgS0lORCwgRVhQUkVTUyBPUgorICogSU1QTElFRCwgSU5DTFVESU5HIEJV VCBOT1QgTElNSVRFRCBUTyBUSEUgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFksCisgKiBG SVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBTkQgTk9OSU5GUklOR0VNRU5ULiBJTiBO TyBFVkVOVCBTSEFMTCBUSEUKKyAqIEFVVEhPUlMgT1IgQ09QWVJJR0hUIEhPTERFUlMgQkUgTElB QkxFIEZPUiBBTlkgQ0xBSU0sIERBTUFHRVMgT1IgT1RIRVIKKyAqIExJQUJJTElUWSwgV0hFVEhF UiBJTiBBTiBBQ1RJT04gT0YgQ09OVFJBQ1QsIFRPUlQgT1IgT1RIRVJXSVNFLCBBUklTSU5HCisg KiBGUk9NLCBPVVQgT0YgT1IgSU4gQ09OTkVDVElPTiBXSVRIIFRIRSBTT0ZUV0FSRSBPUiBUSEUg VVNFIE9SIE9USEVSCisgKiBERUFMSU5HUyBJTiBUSEUgU09GVFdBUkUuCisgKgorICogQ29weXJp Z2h0IChjKSAyMDA2LCBLZWlyIEZyYXNlcgorICovCisKKyNpZm5kZWYgX19YRU5fUFVCTElDX1BI WVNERVZfSF9fCisjZGVmaW5lIF9fWEVOX1BVQkxJQ19QSFlTREVWX0hfXworCisjaW5jbHVkZSAi eGVuLmgiCisKKy8qCisgKiBQcm90b3R5cGUgZm9yIHRoaXMgaHlwZXJjYWxsIGlzOgorICogIGlu dCBwaHlzZGV2X29wKGludCBjbWQsIHZvaWQgKmFyZ3MpCisgKiBAY21kICA9PSBQSFlTREVWT1Bf Pz8/IChwaHlzZGV2IG9wZXJhdGlvbikuCisgKiBAYXJncyA9PSBPcGVyYXRpb24tc3BlY2lmaWMg ZXh0cmEgYXJndW1lbnRzIChOVUxMIGlmIG5vbmUpLgorICovCisKKy8qCisgKiBOb3RpZnkgZW5k LW9mLWludGVycnVwdCAoRU9JKSBmb3IgdGhlIHNwZWNpZmllZCBJUlEuCisgKiBAYXJnID09IHBv aW50ZXIgdG8gcGh5c2Rldl9lb2kgc3RydWN0dXJlLgorICovCisjZGVmaW5lIFBIWVNERVZPUF9l b2kgICAgICAgICAgICAgICAgICAgMTIKK3N0cnVjdCBwaHlzZGV2X2VvaSB7CisgICAgLyogSU4g Ki8KKyAgICB1aW50MzJfdCBpcnE7Cit9OwordHlwZWRlZiBzdHJ1Y3QgcGh5c2Rldl9lb2kgcGh5 c2Rldl9lb2lfdDsKK0RFRklORV9YRU5fR1VFU1RfSEFORExFKHBoeXNkZXZfZW9pX3QpOworCisv KgorICogUmVnaXN0ZXIgYSBzaGFyZWQgcGFnZSBmb3IgdGhlIGh5cGVydmlzb3IgdG8gaW5kaWNh dGUgd2hldGhlciB0aGUgZ3Vlc3QKKyAqIG11c3QgaXNzdWUgUEhZU0RFVk9QX2VvaS4gVGhlIHNl bWFudGljcyBvZiBQSFlTREVWT1BfZW9pIGNoYW5nZSBzbGlnaHRseQorICogb25jZSB0aGUgZ3Vl c3QgdXNlZCB0aGlzIGZ1bmN0aW9uIGluIHRoYXQgdGhlIGFzc29jaWF0ZWQgZXZlbnQgY2hhbm5l bAorICogd2lsbCBhdXRvbWF0aWNhbGx5IGdldCB1bm1hc2tlZC4gVGhlIHBhZ2UgcmVnaXN0ZXJl ZCBpcyB1c2VkIGFzIGEgYml0CisgKiBhcnJheSBpbmRleGVkIGJ5IFhlbidzIFBJUlEgdmFsdWUu CisgKi8KKyNkZWZpbmUgUEhZU0RFVk9QX3BpcnFfZW9pX2dtZm5fdjEgICAgICAgMTcKKy8qCisg KiBSZWdpc3RlciBhIHNoYXJlZCBwYWdlIGZvciB0aGUgaHlwZXJ2aXNvciB0byBpbmRpY2F0ZSB3 aGV0aGVyIHRoZQorICogZ3Vlc3QgbXVzdCBpc3N1ZSBQSFlTREVWT1BfZW9pLiBUaGlzIGh5cGVy Y2FsbCBpcyB2ZXJ5IHNpbWlsYXIgdG8KKyAqIFBIWVNERVZPUF9waXJxX2VvaV9nbWZuX3YxIGJ1 dCBpdCBkb2Vzbid0IGNoYW5nZSB0aGUgc2VtYW50aWNzIG9mCisgKiBQSFlTREVWT1BfZW9pLiBU aGUgcGFnZSByZWdpc3RlcmVkIGlzIHVzZWQgYXMgYSBiaXQgYXJyYXkgaW5kZXhlZCBieQorICog WGVuJ3MgUElSUSB2YWx1ZS4KKyAqLworI2RlZmluZSBQSFlTREVWT1BfcGlycV9lb2lfZ21mbl92 MiAgICAgICAyOAorc3RydWN0IHBoeXNkZXZfcGlycV9lb2lfZ21mbiB7CisgICAgLyogSU4gKi8K KyAgICB4ZW5fcGZuX3QgZ21mbjsKK307Cit0eXBlZGVmIHN0cnVjdCBwaHlzZGV2X3BpcnFfZW9p X2dtZm4gcGh5c2Rldl9waXJxX2VvaV9nbWZuX3Q7CitERUZJTkVfWEVOX0dVRVNUX0hBTkRMRShw aHlzZGV2X3BpcnFfZW9pX2dtZm5fdCk7CisKKy8qCisgKiBRdWVyeSB0aGUgc3RhdHVzIG9mIGFu IElSUSBsaW5lLgorICogQGFyZyA9PSBwb2ludGVyIHRvIHBoeXNkZXZfaXJxX3N0YXR1c19xdWVy eSBzdHJ1Y3R1cmUuCisgKi8KKyNkZWZpbmUgUEhZU0RFVk9QX2lycV9zdGF0dXNfcXVlcnkgICAg ICAgNQorc3RydWN0IHBoeXNkZXZfaXJxX3N0YXR1c19xdWVyeSB7CisgICAgLyogSU4gKi8KKyAg ICB1aW50MzJfdCBpcnE7CisgICAgLyogT1VUICovCisgICAgdWludDMyX3QgZmxhZ3M7IC8qIFhF TklSUVNUQVRfKiAqLworfTsKK3R5cGVkZWYgc3RydWN0IHBoeXNkZXZfaXJxX3N0YXR1c19xdWVy eSBwaHlzZGV2X2lycV9zdGF0dXNfcXVlcnlfdDsKK0RFRklORV9YRU5fR1VFU1RfSEFORExFKHBo eXNkZXZfaXJxX3N0YXR1c19xdWVyeV90KTsKKworLyogTmVlZCB0byBjYWxsIFBIWVNERVZPUF9l b2kgd2hlbiB0aGUgSVJRIGhhcyBiZWVuIHNlcnZpY2VkPyAqLworI2RlZmluZSBfWEVOSVJRU1RB VF9uZWVkc19lb2kgICAoMCkKKyNkZWZpbmUgIFhFTklSUVNUQVRfbmVlZHNfZW9pICAgKDFVPDxf WEVOSVJRU1RBVF9uZWVkc19lb2kpCisKKy8qIElSUSBzaGFyZWQgYnkgbXVsdGlwbGUgZ3Vlc3Rz PyAqLworI2RlZmluZSBfWEVOSVJRU1RBVF9zaGFyZWQgICAgICAoMSkKKyNkZWZpbmUgIFhFTklS UVNUQVRfc2hhcmVkICAgICAgKDFVPDxfWEVOSVJRU1RBVF9zaGFyZWQpCisKKy8qCisgKiBTZXQg dGhlIGN1cnJlbnQgVkNQVSdzIEkvTyBwcml2aWxlZ2UgbGV2ZWwuCisgKiBAYXJnID09IHBvaW50 ZXIgdG8gcGh5c2Rldl9zZXRfaW9wbCBzdHJ1Y3R1cmUuCisgKi8KKyNkZWZpbmUgUEhZU0RFVk9Q X3NldF9pb3BsICAgICAgICAgICAgICAgNgorc3RydWN0IHBoeXNkZXZfc2V0X2lvcGwgeworICAg IC8qIElOICovCisgICAgdWludDMyX3QgaW9wbDsKK307Cit0eXBlZGVmIHN0cnVjdCBwaHlzZGV2 X3NldF9pb3BsIHBoeXNkZXZfc2V0X2lvcGxfdDsKK0RFRklORV9YRU5fR1VFU1RfSEFORExFKHBo eXNkZXZfc2V0X2lvcGxfdCk7CisKKy8qCisgKiBTZXQgdGhlIGN1cnJlbnQgVkNQVSdzIEkvTy1w b3J0IHBlcm1pc3Npb25zIGJpdG1hcC4KKyAqIEBhcmcgPT0gcG9pbnRlciB0byBwaHlzZGV2X3Nl dF9pb2JpdG1hcCBzdHJ1Y3R1cmUuCisgKi8KKyNkZWZpbmUgUEhZU0RFVk9QX3NldF9pb2JpdG1h cCAgICAgICAgICAgNworc3RydWN0IHBoeXNkZXZfc2V0X2lvYml0bWFwIHsKKyAgICAvKiBJTiAq LworI2lmIF9fWEVOX0lOVEVSRkFDRV9WRVJTSU9OX18gPj0gMHgwMDAzMDIwNQorICAgIFhFTl9H VUVTVF9IQU5ETEUodWludDgpIGJpdG1hcDsKKyNlbHNlCisgICAgdWludDhfdCAqYml0bWFwOwor I2VuZGlmCisgICAgdWludDMyX3QgbnJfcG9ydHM7Cit9OwordHlwZWRlZiBzdHJ1Y3QgcGh5c2Rl dl9zZXRfaW9iaXRtYXAgcGh5c2Rldl9zZXRfaW9iaXRtYXBfdDsKK0RFRklORV9YRU5fR1VFU1Rf SEFORExFKHBoeXNkZXZfc2V0X2lvYml0bWFwX3QpOworCisvKgorICogUmVhZCBvciB3cml0ZSBh biBJTy1BUElDIHJlZ2lzdGVyLgorICogQGFyZyA9PSBwb2ludGVyIHRvIHBoeXNkZXZfYXBpYyBz dHJ1Y3R1cmUuCisgKi8KKyNkZWZpbmUgUEhZU0RFVk9QX2FwaWNfcmVhZCAgICAgICAgICAgICAg OAorI2RlZmluZSBQSFlTREVWT1BfYXBpY193cml0ZSAgICAgICAgICAgICA5CitzdHJ1Y3QgcGh5 c2Rldl9hcGljIHsKKyAgICAvKiBJTiAqLworICAgIHVuc2lnbmVkIGxvbmcgYXBpY19waHlzYmFz ZTsKKyAgICB1aW50MzJfdCByZWc7CisgICAgLyogSU4gb3IgT1VUICovCisgICAgdWludDMyX3Qg dmFsdWU7Cit9OwordHlwZWRlZiBzdHJ1Y3QgcGh5c2Rldl9hcGljIHBoeXNkZXZfYXBpY190Owor REVGSU5FX1hFTl9HVUVTVF9IQU5ETEUocGh5c2Rldl9hcGljX3QpOworCisvKgorICogQWxsb2Nh dGUgb3IgZnJlZSBhIHBoeXNpY2FsIHVwY2FsbCB2ZWN0b3IgZm9yIHRoZSBzcGVjaWZpZWQgSVJR IGxpbmUuCisgKiBAYXJnID09IHBvaW50ZXIgdG8gcGh5c2Rldl9pcnEgc3RydWN0dXJlLgorICov CisjZGVmaW5lIFBIWVNERVZPUF9hbGxvY19pcnFfdmVjdG9yICAgICAgMTAKKyNkZWZpbmUgUEhZ U0RFVk9QX2ZyZWVfaXJxX3ZlY3RvciAgICAgICAxMQorc3RydWN0IHBoeXNkZXZfaXJxIHsKKyAg ICAvKiBJTiAqLworICAgIHVpbnQzMl90IGlycTsKKyAgICAvKiBJTiBvciBPVVQgKi8KKyAgICB1 aW50MzJfdCB2ZWN0b3I7Cit9OwordHlwZWRlZiBzdHJ1Y3QgcGh5c2Rldl9pcnEgcGh5c2Rldl9p cnFfdDsKK0RFRklORV9YRU5fR1VFU1RfSEFORExFKHBoeXNkZXZfaXJxX3QpOworIAorI2RlZmlu ZSBNQVBfUElSUV9UWVBFX01TSSAgICAgICAgICAgICAgIDB4MAorI2RlZmluZSBNQVBfUElSUV9U WVBFX0dTSSAgICAgICAgICAgICAgIDB4MQorI2RlZmluZSBNQVBfUElSUV9UWVBFX1VOS05PV04g ICAgICAgICAgIDB4MgorI2RlZmluZSBNQVBfUElSUV9UWVBFX01TSV9TRUcgICAgICAgICAgIDB4 MworI2RlZmluZSBNQVBfUElSUV9UWVBFX01VTFRJX01TSSAgICAgICAgIDB4NAorCisjZGVmaW5l IFBIWVNERVZPUF9tYXBfcGlycSAgICAgICAgICAgICAgIDEzCitzdHJ1Y3QgcGh5c2Rldl9tYXBf cGlycSB7CisgICAgZG9taWRfdCBkb21pZDsKKyAgICAvKiBJTiAqLworICAgIGludCB0eXBlOwor ICAgIC8qIElOIChpZ25vcmVkIGZvciAuLi5fTVVMVElfTVNJKSAqLworICAgIGludCBpbmRleDsK KyAgICAvKiBJTiBvciBPVVQgKi8KKyAgICBpbnQgcGlycTsKKyAgICAvKiBJTiAtIGhpZ2ggMTYg Yml0cyBob2xkIHNlZ21lbnQgZm9yIC4uLl9NU0lfU0VHIGFuZCAuLi5fTVVMVElfTVNJICovCisg ICAgaW50IGJ1czsKKyAgICAvKiBJTiAqLworICAgIGludCBkZXZmbjsKKyAgICAvKiBJTiAoYWxz byBPVVQgZm9yIC4uLl9NVUxUSV9NU0kpICovCisgICAgaW50IGVudHJ5X25yOworICAgIC8qIElO ICovCisgICAgdWludDY0X3QgdGFibGVfYmFzZTsKK307Cit0eXBlZGVmIHN0cnVjdCBwaHlzZGV2 X21hcF9waXJxIHBoeXNkZXZfbWFwX3BpcnFfdDsKK0RFRklORV9YRU5fR1VFU1RfSEFORExFKHBo eXNkZXZfbWFwX3BpcnFfdCk7CisKKyNkZWZpbmUgUEhZU0RFVk9QX3VubWFwX3BpcnEgICAgICAg ICAgICAgMTQKK3N0cnVjdCBwaHlzZGV2X3VubWFwX3BpcnEgeworICAgIGRvbWlkX3QgZG9taWQ7 CisgICAgLyogSU4gKi8KKyAgICBpbnQgcGlycTsKK307CisKK3R5cGVkZWYgc3RydWN0IHBoeXNk ZXZfdW5tYXBfcGlycSBwaHlzZGV2X3VubWFwX3BpcnFfdDsKK0RFRklORV9YRU5fR1VFU1RfSEFO RExFKHBoeXNkZXZfdW5tYXBfcGlycV90KTsKKworI2RlZmluZSBQSFlTREVWT1BfbWFuYWdlX3Bj aV9hZGQgICAgICAgICAxNQorI2RlZmluZSBQSFlTREVWT1BfbWFuYWdlX3BjaV9yZW1vdmUgICAg ICAxNgorc3RydWN0IHBoeXNkZXZfbWFuYWdlX3BjaSB7CisgICAgLyogSU4gKi8KKyAgICB1aW50 OF90IGJ1czsKKyAgICB1aW50OF90IGRldmZuOworfTsgCisKK3R5cGVkZWYgc3RydWN0IHBoeXNk ZXZfbWFuYWdlX3BjaSBwaHlzZGV2X21hbmFnZV9wY2lfdDsKK0RFRklORV9YRU5fR1VFU1RfSEFO RExFKHBoeXNkZXZfbWFuYWdlX3BjaV90KTsKKworI2RlZmluZSBQSFlTREVWT1BfcmVzdG9yZV9t c2kgICAgICAgICAgICAxOQorc3RydWN0IHBoeXNkZXZfcmVzdG9yZV9tc2kgeworICAgIC8qIElO ICovCisgICAgdWludDhfdCBidXM7CisgICAgdWludDhfdCBkZXZmbjsKK307Cit0eXBlZGVmIHN0 cnVjdCBwaHlzZGV2X3Jlc3RvcmVfbXNpIHBoeXNkZXZfcmVzdG9yZV9tc2lfdDsKK0RFRklORV9Y RU5fR1VFU1RfSEFORExFKHBoeXNkZXZfcmVzdG9yZV9tc2lfdCk7CisKKyNkZWZpbmUgUEhZU0RF Vk9QX21hbmFnZV9wY2lfYWRkX2V4dCAgICAgMjAKK3N0cnVjdCBwaHlzZGV2X21hbmFnZV9wY2lf ZXh0IHsKKyAgICAvKiBJTiAqLworICAgIHVpbnQ4X3QgYnVzOworICAgIHVpbnQ4X3QgZGV2Zm47 CisgICAgdW5zaWduZWQgaXNfZXh0Zm47CisgICAgdW5zaWduZWQgaXNfdmlydGZuOworICAgIHN0 cnVjdCB7CisgICAgICAgIHVpbnQ4X3QgYnVzOworICAgICAgICB1aW50OF90IGRldmZuOworICAg IH0gcGh5c2ZuOworfTsKKwordHlwZWRlZiBzdHJ1Y3QgcGh5c2Rldl9tYW5hZ2VfcGNpX2V4dCBw aHlzZGV2X21hbmFnZV9wY2lfZXh0X3Q7CitERUZJTkVfWEVOX0dVRVNUX0hBTkRMRShwaHlzZGV2 X21hbmFnZV9wY2lfZXh0X3QpOworCisvKgorICogQXJndW1lbnQgdG8gcGh5c2Rldl9vcF9jb21w YXQoKSBoeXBlcmNhbGwuIFN1cGVyY2VkZWQgYnkgbmV3IHBoeXNkZXZfb3AoKQorICogaHlwZXJj YWxsIHNpbmNlIDB4MDAwMzAyMDIuCisgKi8KK3N0cnVjdCBwaHlzZGV2X29wIHsKKyAgICB1aW50 MzJfdCBjbWQ7CisgICAgdW5pb24geworICAgICAgICBzdHJ1Y3QgcGh5c2Rldl9pcnFfc3RhdHVz X3F1ZXJ5ICAgICAgaXJxX3N0YXR1c19xdWVyeTsKKyAgICAgICAgc3RydWN0IHBoeXNkZXZfc2V0 X2lvcGwgICAgICAgICAgICAgIHNldF9pb3BsOworICAgICAgICBzdHJ1Y3QgcGh5c2Rldl9zZXRf aW9iaXRtYXAgICAgICAgICAgc2V0X2lvYml0bWFwOworICAgICAgICBzdHJ1Y3QgcGh5c2Rldl9h cGljICAgICAgICAgICAgICAgICAgYXBpY19vcDsKKyAgICAgICAgc3RydWN0IHBoeXNkZXZfaXJx ICAgICAgICAgICAgICAgICAgIGlycV9vcDsKKyAgICB9IHU7Cit9OwordHlwZWRlZiBzdHJ1Y3Qg cGh5c2Rldl9vcCBwaHlzZGV2X29wX3Q7CitERUZJTkVfWEVOX0dVRVNUX0hBTkRMRShwaHlzZGV2 X29wX3QpOworCisjZGVmaW5lIFBIWVNERVZPUF9zZXR1cF9nc2kgICAgMjEKK3N0cnVjdCBwaHlz ZGV2X3NldHVwX2dzaSB7CisgICAgaW50IGdzaTsKKyAgICAvKiBJTiAqLworICAgIHVpbnQ4X3Qg dHJpZ2dlcmluZzsKKyAgICAvKiBJTiAqLworICAgIHVpbnQ4X3QgcG9sYXJpdHk7CisgICAgLyog SU4gKi8KK307CisKK3R5cGVkZWYgc3RydWN0IHBoeXNkZXZfc2V0dXBfZ3NpIHBoeXNkZXZfc2V0 dXBfZ3NpX3Q7CitERUZJTkVfWEVOX0dVRVNUX0hBTkRMRShwaHlzZGV2X3NldHVwX2dzaV90KTsK KworLyogbGVhdmUgUEhZU0RFVk9QIDIyIGZyZWUgKi8KKworLyogdHlwZSBpcyBNQVBfUElSUV9U WVBFX0dTSSBvciBNQVBfUElSUV9UWVBFX01TSQorICogdGhlIGh5cGVyY2FsbCByZXR1cm5zIGEg ZnJlZSBwaXJxICovCisjZGVmaW5lIFBIWVNERVZPUF9nZXRfZnJlZV9waXJxICAgIDIzCitzdHJ1 Y3QgcGh5c2Rldl9nZXRfZnJlZV9waXJxIHsKKyAgICAvKiBJTiAqLyAKKyAgICBpbnQgdHlwZTsK KyAgICAvKiBPVVQgKi8KKyAgICB1aW50MzJfdCBwaXJxOworfTsKKwordHlwZWRlZiBzdHJ1Y3Qg cGh5c2Rldl9nZXRfZnJlZV9waXJxIHBoeXNkZXZfZ2V0X2ZyZWVfcGlycV90OworREVGSU5FX1hF Tl9HVUVTVF9IQU5ETEUocGh5c2Rldl9nZXRfZnJlZV9waXJxX3QpOworCisjZGVmaW5lIFhFTl9Q Q0lfTU1DRkdfUkVTRVJWRUQgICAgICAgICAweDEKKworI2RlZmluZSBQSFlTREVWT1BfcGNpX21t Y2ZnX3Jlc2VydmVkICAgIDI0CitzdHJ1Y3QgcGh5c2Rldl9wY2lfbW1jZmdfcmVzZXJ2ZWQgewor ICAgIHVpbnQ2NF90IGFkZHJlc3M7CisgICAgdWludDE2X3Qgc2VnbWVudDsKKyAgICB1aW50OF90 IHN0YXJ0X2J1czsKKyAgICB1aW50OF90IGVuZF9idXM7CisgICAgdWludDMyX3QgZmxhZ3M7Cit9 OwordHlwZWRlZiBzdHJ1Y3QgcGh5c2Rldl9wY2lfbW1jZmdfcmVzZXJ2ZWQgcGh5c2Rldl9wY2lf bW1jZmdfcmVzZXJ2ZWRfdDsKK0RFRklORV9YRU5fR1VFU1RfSEFORExFKHBoeXNkZXZfcGNpX21t Y2ZnX3Jlc2VydmVkX3QpOworCisjZGVmaW5lIFhFTl9QQ0lfREVWX0VYVEZOICAgICAgICAgICAg ICAweDEKKyNkZWZpbmUgWEVOX1BDSV9ERVZfVklSVEZOICAgICAgICAgICAgIDB4MgorI2RlZmlu ZSBYRU5fUENJX0RFVl9QWE0gICAgICAgICAgICAgICAgMHg0CisKKyNkZWZpbmUgUEhZU0RFVk9Q X3BjaV9kZXZpY2VfYWRkICAgICAgICAyNQorc3RydWN0IHBoeXNkZXZfcGNpX2RldmljZV9hZGQg eworICAgIC8qIElOICovCisgICAgdWludDE2X3Qgc2VnOworICAgIHVpbnQ4X3QgYnVzOworICAg IHVpbnQ4X3QgZGV2Zm47CisgICAgdWludDMyX3QgZmxhZ3M7CisgICAgc3RydWN0IHsKKyAgICAg ICAgdWludDhfdCBidXM7CisgICAgICAgIHVpbnQ4X3QgZGV2Zm47CisgICAgfSBwaHlzZm47Cisg ICAgLyoKKyAgICAgKiBPcHRpb25hbCBwYXJhbWV0ZXJzIGFycmF5LgorICAgICAqIEZpcnN0IGVs ZW1lbnQgKFswXSkgaXMgUFhNIGRvbWFpbiBhc3NvY2lhdGVkIHdpdGggdGhlIGRldmljZSAoaWYK KyAgICAgKiBYRU5fUENJX0RFVl9QWE0gaXMgc2V0KQorICAgICAqLworI2lmIGRlZmluZWQoX19T VERDX1ZFUlNJT05fXykgJiYgX19TVERDX1ZFUlNJT05fXyA+PSAxOTk5MDFMCisgICAgdWludDMy X3Qgb3B0YXJyW107CisjZWxpZiBkZWZpbmVkKF9fR05VQ19fKQorICAgIHVpbnQzMl90IG9wdGFy clswXTsKKyNlbmRpZgorfTsKK3R5cGVkZWYgc3RydWN0IHBoeXNkZXZfcGNpX2RldmljZV9hZGQg cGh5c2Rldl9wY2lfZGV2aWNlX2FkZF90OworREVGSU5FX1hFTl9HVUVTVF9IQU5ETEUocGh5c2Rl dl9wY2lfZGV2aWNlX2FkZF90KTsKKworI2RlZmluZSBQSFlTREVWT1BfcGNpX2RldmljZV9yZW1v dmUgICAgIDI2CisjZGVmaW5lIFBIWVNERVZPUF9yZXN0b3JlX21zaV9leHQgICAgICAgMjcKKy8q CisgKiBEb20wIHNob3VsZCB1c2UgdGhlc2UgdHdvIHRvIGFubm91bmNlIE1NSU8gcmVzb3VyY2Vz IGFzc2lnbmVkIHRvCisgKiBNU0ktWCBjYXBhYmxlIGRldmljZXMgd29uJ3QgKHByZXBhcmUpIG9y IG1heSAocmVsZWFzZSkgY2hhbmdlLgorICovCisjZGVmaW5lIFBIWVNERVZPUF9wcmVwYXJlX21z aXggICAgICAgICAgMzAKKyNkZWZpbmUgUEhZU0RFVk9QX3JlbGVhc2VfbXNpeCAgICAgICAgICAz MQorc3RydWN0IHBoeXNkZXZfcGNpX2RldmljZSB7CisgICAgLyogSU4gKi8KKyAgICB1aW50MTZf dCBzZWc7CisgICAgdWludDhfdCBidXM7CisgICAgdWludDhfdCBkZXZmbjsKK307Cit0eXBlZGVm IHN0cnVjdCBwaHlzZGV2X3BjaV9kZXZpY2UgcGh5c2Rldl9wY2lfZGV2aWNlX3Q7CitERUZJTkVf WEVOX0dVRVNUX0hBTkRMRShwaHlzZGV2X3BjaV9kZXZpY2VfdCk7CisKKyNkZWZpbmUgUEhZU0RF Vk9QX0RCR1BfUkVTRVRfUFJFUEFSRSAgICAxCisjZGVmaW5lIFBIWVNERVZPUF9EQkdQX1JFU0VU X0RPTkUgICAgICAgMgorCisjZGVmaW5lIFBIWVNERVZPUF9EQkdQX0JVU19VTktOT1dOICAgICAg MAorI2RlZmluZSBQSFlTREVWT1BfREJHUF9CVVNfUENJICAgICAgICAgIDEKKworI2RlZmluZSBQ SFlTREVWT1BfZGJncF9vcCAgICAgICAgICAgICAgIDI5CitzdHJ1Y3QgcGh5c2Rldl9kYmdwX29w IHsKKyAgICAvKiBJTiAqLworICAgIHVpbnQ4X3Qgb3A7CisgICAgdWludDhfdCBidXM7CisgICAg dW5pb24geworICAgICAgICBzdHJ1Y3QgcGh5c2Rldl9wY2lfZGV2aWNlIHBjaTsKKyAgICB9IHU7 Cit9OwordHlwZWRlZiBzdHJ1Y3QgcGh5c2Rldl9kYmdwX29wIHBoeXNkZXZfZGJncF9vcF90Owor REVGSU5FX1hFTl9HVUVTVF9IQU5ETEUocGh5c2Rldl9kYmdwX29wX3QpOworCisvKgorICogTm90 aWZ5IHRoYXQgc29tZSBQSVJRLWJvdW5kIGV2ZW50IGNoYW5uZWxzIGhhdmUgYmVlbiB1bm1hc2tl ZC4KKyAqICoqIFRoaXMgY29tbWFuZCBpcyBvYnNvbGV0ZSBzaW5jZSBpbnRlcmZhY2UgdmVyc2lv biAweDAwMDMwMjAyIGFuZCBpcyAqKgorICogKiogdW5zdXBwb3J0ZWQgYnkgbmV3ZXIgdmVyc2lv bnMgb2YgWGVuLiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICoqCisgKi8KKyNkZWZpbmUg UEhZU0RFVk9QX0lSUV9VTk1BU0tfTk9USUZZICAgICAgNAorCisjaWYgX19YRU5fSU5URVJGQUNF X1ZFUlNJT05fXyA8IDB4MDAwNDA2MDAKKy8qCisgKiBUaGVzZSBhbGwtY2FwaXRhbHMgcGh5c2Rl diBvcGVyYXRpb24gbmFtZXMgYXJlIHN1cGVyY2VkZWQgYnkgdGhlIG5ldyBuYW1lcworICogKGRl ZmluZWQgYWJvdmUpIHNpbmNlIGludGVyZmFjZSB2ZXJzaW9uIDB4MDAwMzAyMDIuIFRoZSBndWFy ZCBhYm92ZSB3YXMKKyAqIGFkZGVkIHBvc3QtNC41IG9ubHkgdGhvdWdoIGFuZCBoZW5jZSBzaG91 bGRuJ3QgY2hlY2sgZm9yIDB4MDAwMzAyMDIuCisgKi8KKyNkZWZpbmUgUEhZU0RFVk9QX0lSUV9T VEFUVVNfUVVFUlkgICAgICAgUEhZU0RFVk9QX2lycV9zdGF0dXNfcXVlcnkKKyNkZWZpbmUgUEhZ U0RFVk9QX1NFVF9JT1BMICAgICAgICAgICAgICAgUEhZU0RFVk9QX3NldF9pb3BsCisjZGVmaW5l IFBIWVNERVZPUF9TRVRfSU9CSVRNQVAgICAgICAgICAgIFBIWVNERVZPUF9zZXRfaW9iaXRtYXAK KyNkZWZpbmUgUEhZU0RFVk9QX0FQSUNfUkVBRCAgICAgICAgICAgICAgUEhZU0RFVk9QX2FwaWNf cmVhZAorI2RlZmluZSBQSFlTREVWT1BfQVBJQ19XUklURSAgICAgICAgICAgICBQSFlTREVWT1Bf YXBpY193cml0ZQorI2RlZmluZSBQSFlTREVWT1BfQVNTSUdOX1ZFQ1RPUiAgICAgICAgICBQSFlT REVWT1BfYWxsb2NfaXJxX3ZlY3RvcgorI2RlZmluZSBQSFlTREVWT1BfRlJFRV9WRUNUT1IgICAg ICAgICAgICBQSFlTREVWT1BfZnJlZV9pcnFfdmVjdG9yCisjZGVmaW5lIFBIWVNERVZPUF9JUlFf TkVFRFNfVU5NQVNLX05PVElGWSBYRU5JUlFTVEFUX25lZWRzX2VvaQorI2RlZmluZSBQSFlTREVW T1BfSVJRX1NIQVJFRCAgICAgICAgICAgICBYRU5JUlFTVEFUX3NoYXJlZAorI2VuZGlmCisKKyNp ZiBfX1hFTl9JTlRFUkZBQ0VfVkVSU0lPTl9fIDwgMHgwMDA0MDIwMAorI2RlZmluZSBQSFlTREVW T1BfcGlycV9lb2lfZ21mbiBQSFlTREVWT1BfcGlycV9lb2lfZ21mbl92MQorI2Vsc2UKKyNkZWZp bmUgUEhZU0RFVk9QX3BpcnFfZW9pX2dtZm4gUEhZU0RFVk9QX3BpcnFfZW9pX2dtZm5fdjIKKyNl bmRpZgorCisjZW5kaWYgLyogX19YRU5fUFVCTElDX1BIWVNERVZfSF9fICovCisKKy8qCisgKiBM b2NhbCB2YXJpYWJsZXM6CisgKiBtb2RlOiBDCisgKiBjLWZpbGUtc3R5bGU6ICJCU0QiCisgKiBj LWJhc2ljLW9mZnNldDogNAorICogdGFiLXdpZHRoOiA0CisgKiBpbmRlbnQtdGFicy1tb2RlOiBu aWwKKyAqIEVuZDoKKyAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVkZS94ZW4vdHJhY2UuaCBiL2luY2x1 ZGUveGVuL3RyYWNlLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwLi4zNzQ2 YmZmMjYKLS0tIC9kZXYvbnVsbAorKysgYi9pbmNsdWRlL3hlbi90cmFjZS5oCkBAIC0wLDAgKzEs MzM5IEBACisvKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioq KioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCisgKiBpbmNsdWRlL3B1YmxpYy90cmFjZS5o CisgKiAKKyAqIFBlcm1pc3Npb24gaXMgaGVyZWJ5IGdyYW50ZWQsIGZyZWUgb2YgY2hhcmdlLCB0 byBhbnkgcGVyc29uIG9idGFpbmluZyBhIGNvcHkKKyAqIG9mIHRoaXMgc29mdHdhcmUgYW5kIGFz c29jaWF0ZWQgZG9jdW1lbnRhdGlvbiBmaWxlcyAodGhlICJTb2Z0d2FyZSIpLCB0bworICogZGVh bCBpbiB0aGUgU29mdHdhcmUgd2l0aG91dCByZXN0cmljdGlvbiwgaW5jbHVkaW5nIHdpdGhvdXQg bGltaXRhdGlvbiB0aGUKKyAqIHJpZ2h0cyB0byB1c2UsIGNvcHksIG1vZGlmeSwgbWVyZ2UsIHB1 Ymxpc2gsIGRpc3RyaWJ1dGUsIHN1YmxpY2Vuc2UsIGFuZC9vcgorICogc2VsbCBjb3BpZXMgb2Yg dGhlIFNvZnR3YXJlLCBhbmQgdG8gcGVybWl0IHBlcnNvbnMgdG8gd2hvbSB0aGUgU29mdHdhcmUg aXMKKyAqIGZ1cm5pc2hlZCB0byBkbyBzbywgc3ViamVjdCB0byB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnM6CisgKgorICogVGhlIGFib3ZlIGNvcHlyaWdodCBub3RpY2UgYW5kIHRoaXMgcGVybWlz c2lvbiBub3RpY2Ugc2hhbGwgYmUgaW5jbHVkZWQgaW4KKyAqIGFsbCBjb3BpZXMgb3Igc3Vic3Rh bnRpYWwgcG9ydGlvbnMgb2YgdGhlIFNvZnR3YXJlLgorICoKKyAqIFRIRSBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCAiQVMgSVMiLCBXSVRIT1VUIFdBUlJBTlRZIE9GIEFOWSBLSU5ELCBFWFBSRVNTIE9S CisgKiBJTVBMSUVELCBJTkNMVURJTkcgQlVUIE5PVCBMSU1JVEVEIFRPIFRIRSBXQVJSQU5USUVT IE9GIE1FUkNIQU5UQUJJTElUWSwKKyAqIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NF IEFORCBOT05JTkZSSU5HRU1FTlQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRQorICogQVVUSE9SUyBP UiBDT1BZUklHSFQgSE9MREVSUyBCRSBMSUFCTEUgRk9SIEFOWSBDTEFJTSwgREFNQUdFUyBPUiBP VEhFUgorICogTElBQklMSVRZLCBXSEVUSEVSIElOIEFOIEFDVElPTiBPRiBDT05UUkFDVCwgVE9S VCBPUiBPVEhFUldJU0UsIEFSSVNJTkcKKyAqIEZST00sIE9VVCBPRiBPUiBJTiBDT05ORUNUSU9O IFdJVEggVEhFIFNPRlRXQVJFIE9SIFRIRSBVU0UgT1IgT1RIRVIKKyAqIERFQUxJTkdTIElOIFRI RSBTT0ZUV0FSRS4KKyAqCisgKiBNYXJrIFdpbGxpYW1zb24sIChDKSAyMDA0IEludGVsIFJlc2Vh cmNoIENhbWJyaWRnZQorICogQ29weXJpZ2h0IChDKSAyMDA1IEJpbiBSZW4KKyAqLworCisjaWZu ZGVmIF9fWEVOX1BVQkxJQ19UUkFDRV9IX18KKyNkZWZpbmUgX19YRU5fUFVCTElDX1RSQUNFX0hf XworCisjZGVmaW5lIFRSQUNFX0VYVFJBX01BWCAgICA3CisjZGVmaW5lIFRSQUNFX0VYVFJBX1NI SUZUIDI4CisKKy8qIFRyYWNlIGNsYXNzZXMgKi8KKyNkZWZpbmUgVFJDX0NMU19TSElGVCAxNgor I2RlZmluZSBUUkNfR0VOICAgICAgMHgwMDAxZjAwMCAgICAvKiBHZW5lcmFsIHRyYWNlICAgICAg ICAgICAgKi8KKyNkZWZpbmUgVFJDX1NDSEVEICAgIDB4MDAwMmYwMDAgICAgLyogWGVuIFNjaGVk dWxlciB0cmFjZSAgICAgICovCisjZGVmaW5lIFRSQ19ET00wT1AgICAweDAwMDRmMDAwICAgIC8q IFhlbiBET00wIG9wZXJhdGlvbiB0cmFjZSAqLworI2RlZmluZSBUUkNfSFZNICAgICAgMHgwMDA4 ZjAwMCAgICAvKiBYZW4gSFZNIHRyYWNlICAgICAgICAgICAgKi8KKyNkZWZpbmUgVFJDX01FTSAg ICAgIDB4MDAxMGYwMDAgICAgLyogWGVuIG1lbW9yeSB0cmFjZSAgICAgICAgICovCisjZGVmaW5l IFRSQ19QViAgICAgICAweDAwMjBmMDAwICAgIC8qIFhlbiBQViB0cmFjZXMgICAgICAgICAgICAq LworI2RlZmluZSBUUkNfU0hBRE9XICAgMHgwMDQwZjAwMCAgICAvKiBYZW4gc2hhZG93IHRyYWNp bmcgICAgICAgKi8KKyNkZWZpbmUgVFJDX0hXICAgICAgIDB4MDA4MGYwMDAgICAgLyogWGVuIGhh cmR3YXJlLXJlbGF0ZWQgdHJhY2VzICovCisjZGVmaW5lIFRSQ19HVUVTVCAgICAweDA4MDBmMDAw ICAgIC8qIEd1ZXN0LWdlbmVyYXRlZCB0cmFjZXMgICAqLworI2RlZmluZSBUUkNfQUxMICAgICAg MHgwZmZmZjAwMAorI2RlZmluZSBUUkNfSERfVE9fRVZFTlQoeCkgKCh4KSYweDBmZmZmZmZmKQor I2RlZmluZSBUUkNfSERfQ1lDTEVfRkxBRyAoMVVMPDwzMSkKKyNkZWZpbmUgVFJDX0hEX0lOQ0xV REVTX0NZQ0xFX0NPVU5UKHgpICggISEoICh4KSAmIFRSQ19IRF9DWUNMRV9GTEFHICkgKQorI2Rl ZmluZSBUUkNfSERfRVhUUkEoeCkgICAgKCgoeCk+PlRSQUNFX0VYVFJBX1NISUZUKSZUUkFDRV9F WFRSQV9NQVgpCisKKy8qIFRyYWNlIHN1YmNsYXNzZXMgKi8KKyNkZWZpbmUgVFJDX1NVQkNMU19T SElGVCAxMgorCisvKiB0cmFjZSBzdWJjbGFzc2VzIGZvciBTVk0gKi8KKyNkZWZpbmUgVFJDX0hW TV9FTlRSWUVYSVQgICAweDAwMDgxMDAwICAgLyogVk1FTlRSWSBhbmQgI1ZNRVhJVCAgICAgICAq LworI2RlZmluZSBUUkNfSFZNX0hBTkRMRVIgICAgIDB4MDAwODIwMDAgICAvKiB2YXJpb3VzIEhW TSBoYW5kbGVycyAgICAgICovCisjZGVmaW5lIFRSQ19IVk1fRU1VTCAgICAgICAgMHgwMDA4NDAw MCAgIC8qIGVtdWxhdGVkIGRldmljZXMgKi8KKworI2RlZmluZSBUUkNfU0NIRURfTUlOICAgICAg IDB4MDAwMjEwMDAgICAvKiBKdXN0IHJ1bnN0YXRlIGNoYW5nZXMgKi8KKyNkZWZpbmUgVFJDX1ND SEVEX0NMQVNTICAgICAweDAwMDIyMDAwICAgLyogU2NoZWR1bGVyLXNwZWNpZmljICAgICovCisj ZGVmaW5lIFRSQ19TQ0hFRF9WRVJCT1NFICAgMHgwMDAyODAwMCAgIC8qIE1vcmUgaW5jbHVzaXZl IHNjaGVkdWxpbmcgKi8KKworLyoKKyAqIFRoZSBoaWdoZXN0IDMgYml0cyBvZiB0aGUgbGFzdCAx MiBiaXRzIG9mIFRSQ19TQ0hFRF9DTEFTUyBhYm92ZSBhcmUKKyAqIHJlc2VydmVkIGZvciBlbmNv ZGluZyB3aGF0IHNjaGVkdWxlciBwcm9kdWNlZCB0aGUgaW5mb3JtYXRpb24uIFRoZQorICogYWN0 dWFsIGV2ZW50IGlzIGVuY29kZWQgaW4gdGhlIGxhc3QgOSBiaXRzLgorICoKKyAqIFRoaXMgbWVh bnMgd2UgaGF2ZSA4IHNjaGVkdWxpbmcgSURzIGF2YWlsYWJsZSAod2hpY2ggbWVhbnMgYXQgbW9z dCA4CisgKiBzY2hlZHVsZXJzIGdlbmVyYXRpbmcgZXZlbnRzKSBhbmQsIGluIGVhY2ggc2NoZWR1 bGVyLCB1cCB0byA1MTIKKyAqIGRpZmZlcmVudCBldmVudHMuCisgKi8KKyNkZWZpbmUgVFJDX1ND SEVEX0lEX0JJVFMgMworI2RlZmluZSBUUkNfU0NIRURfSURfU0hJRlQgKFRSQ19TVUJDTFNfU0hJ RlQgLSBUUkNfU0NIRURfSURfQklUUykKKyNkZWZpbmUgVFJDX1NDSEVEX0lEX01BU0sgKCgoMVVM PDxUUkNfU0NIRURfSURfQklUUykgLSAxKSA8PCBUUkNfU0NIRURfSURfU0hJRlQpCisjZGVmaW5l IFRSQ19TQ0hFRF9FVlRfTUFTSyAofihUUkNfU0NIRURfSURfTUFTSykpCisKKy8qIFBlci1zY2hl ZHVsZXIgSURzLCB0byBpZGVudGlmeSBzY2hlZHVsZXIgc3BlY2lmaWMgZXZlbnRzICovCisjZGVm aW5lIFRSQ19TQ0hFRF9DU0NIRUQgICAwCisjZGVmaW5lIFRSQ19TQ0hFRF9DU0NIRUQyICAxCisv KiAjZGVmaW5lIFhFTl9TQ0hFRFVMRVJfU0VERiAyIChSZW1vdmVkKSAqLworI2RlZmluZSBUUkNf U0NIRURfQVJJTkM2NTMgMworI2RlZmluZSBUUkNfU0NIRURfUlREUyAgICAgNAorI2RlZmluZSBU UkNfU0NIRURfU05VTEwgICAgNQorCisvKiBQZXItc2NoZWR1bGVyIHRyYWNpbmcgKi8KKyNkZWZp bmUgVFJDX1NDSEVEX0NMQVNTX0VWVChfYywgX2UpIFwKKyAgKCAoIFRSQ19TQ0hFRF9DTEFTUyB8 IFwKKyAgICAgICgoVFJDX1NDSEVEXyMjX2MgPDwgVFJDX1NDSEVEX0lEX1NISUZUKSAmIFRSQ19T Q0hFRF9JRF9NQVNLKSApICsgXAorICAgIChfZSAmIFRSQ19TQ0hFRF9FVlRfTUFTSykgKQorCisv KiBUcmFjZSBjbGFzc2VzIGZvciBET00wIG9wZXJhdGlvbnMgKi8KKyNkZWZpbmUgVFJDX0RPTTBf RE9NT1BTICAgICAweDAwMDQxMDAwICAgLyogRG9tYWlucyBtYW5pcHVsYXRpb25zICovCisKKy8q IFRyYWNlIGNsYXNzZXMgZm9yIEhhcmR3YXJlICovCisjZGVmaW5lIFRSQ19IV19QTSAgICAgICAg ICAgMHgwMDgwMTAwMCAgIC8qIFBvd2VyIG1hbmFnZW1lbnQgdHJhY2VzICovCisjZGVmaW5lIFRS Q19IV19JUlEgICAgICAgICAgMHgwMDgwMjAwMCAgIC8qIFRyYWNlcyByZWxhdGluZyB0byB0aGUg aGFuZGxpbmcgb2YgSVJRcyAqLworCisvKiBUcmFjZSBldmVudHMgcGVyIGNsYXNzICovCisjZGVm aW5lIFRSQ19MT1NUX1JFQ09SRFMgICAgICAgIChUUkNfR0VOICsgMSkKKyNkZWZpbmUgVFJDX1RS QUNFX1dSQVBfQlVGRkVSICAoVFJDX0dFTiArIDIpCisjZGVmaW5lIFRSQ19UUkFDRV9DUFVfQ0hB TkdFICAgIChUUkNfR0VOICsgMykKKworI2RlZmluZSBUUkNfU0NIRURfUlVOU1RBVEVfQ0hBTkdF ICAgKFRSQ19TQ0hFRF9NSU4gKyAxKQorI2RlZmluZSBUUkNfU0NIRURfQ09OVElOVUVfUlVOTklO RyAgKFRSQ19TQ0hFRF9NSU4gKyAyKQorI2RlZmluZSBUUkNfU0NIRURfRE9NX0FERCAgICAgICAg KFRSQ19TQ0hFRF9WRVJCT1NFICsgIDEpCisjZGVmaW5lIFRSQ19TQ0hFRF9ET01fUkVNICAgICAg ICAoVFJDX1NDSEVEX1ZFUkJPU0UgKyAgMikKKyNkZWZpbmUgVFJDX1NDSEVEX1NMRUVQICAgICAg ICAgIChUUkNfU0NIRURfVkVSQk9TRSArICAzKQorI2RlZmluZSBUUkNfU0NIRURfV0FLRSAgICAg ICAgICAgKFRSQ19TQ0hFRF9WRVJCT1NFICsgIDQpCisjZGVmaW5lIFRSQ19TQ0hFRF9ZSUVMRCAg ICAgICAgICAoVFJDX1NDSEVEX1ZFUkJPU0UgKyAgNSkKKyNkZWZpbmUgVFJDX1NDSEVEX0JMT0NL ICAgICAgICAgIChUUkNfU0NIRURfVkVSQk9TRSArICA2KQorI2RlZmluZSBUUkNfU0NIRURfU0hV VERPV04gICAgICAgKFRSQ19TQ0hFRF9WRVJCT1NFICsgIDcpCisjZGVmaW5lIFRSQ19TQ0hFRF9D VEwgICAgICAgICAgICAoVFJDX1NDSEVEX1ZFUkJPU0UgKyAgOCkKKyNkZWZpbmUgVFJDX1NDSEVE X0FESkRPTSAgICAgICAgIChUUkNfU0NIRURfVkVSQk9TRSArICA5KQorI2RlZmluZSBUUkNfU0NI RURfU1dJVENIICAgICAgICAgKFRSQ19TQ0hFRF9WRVJCT1NFICsgMTApCisjZGVmaW5lIFRSQ19T Q0hFRF9TX1RJTUVSX0ZOICAgICAoVFJDX1NDSEVEX1ZFUkJPU0UgKyAxMSkKKyNkZWZpbmUgVFJD X1NDSEVEX1RfVElNRVJfRk4gICAgIChUUkNfU0NIRURfVkVSQk9TRSArIDEyKQorI2RlZmluZSBU UkNfU0NIRURfRE9NX1RJTUVSX0ZOICAgKFRSQ19TQ0hFRF9WRVJCT1NFICsgMTMpCisjZGVmaW5l IFRSQ19TQ0hFRF9TV0lUQ0hfSU5GUFJFViAoVFJDX1NDSEVEX1ZFUkJPU0UgKyAxNCkKKyNkZWZp bmUgVFJDX1NDSEVEX1NXSVRDSF9JTkZORVhUIChUUkNfU0NIRURfVkVSQk9TRSArIDE1KQorI2Rl ZmluZSBUUkNfU0NIRURfU0hVVERPV05fQ09ERSAgKFRSQ19TQ0hFRF9WRVJCT1NFICsgMTYpCisj ZGVmaW5lIFRSQ19TQ0hFRF9TV0lUQ0hfSU5GQ09OVCAoVFJDX1NDSEVEX1ZFUkJPU0UgKyAxNykK KworI2RlZmluZSBUUkNfRE9NMF9ET01fQUREICAgICAgICAgKFRSQ19ET00wX0RPTU9QUyArIDEp CisjZGVmaW5lIFRSQ19ET00wX0RPTV9SRU0gICAgICAgICAoVFJDX0RPTTBfRE9NT1BTICsgMikK KworI2RlZmluZSBUUkNfTUVNX1BBR0VfR1JBTlRfTUFQICAgICAgKFRSQ19NRU0gKyAxKQorI2Rl ZmluZSBUUkNfTUVNX1BBR0VfR1JBTlRfVU5NQVAgICAgKFRSQ19NRU0gKyAyKQorI2RlZmluZSBU UkNfTUVNX1BBR0VfR1JBTlRfVFJBTlNGRVIgKFRSQ19NRU0gKyAzKQorI2RlZmluZSBUUkNfTUVN X1NFVF9QMk1fRU5UUlkgICAgICAgKFRSQ19NRU0gKyA0KQorI2RlZmluZSBUUkNfTUVNX0RFQ1JF QVNFX1JFU0VSVkFUSU9OIChUUkNfTUVNICsgNSkKKyNkZWZpbmUgVFJDX01FTV9QT0RfUE9QVUxB VEUgICAgICAgIChUUkNfTUVNICsgMTYpCisjZGVmaW5lIFRSQ19NRU1fUE9EX1pFUk9fUkVDTEFJ TSAgICAoVFJDX01FTSArIDE3KQorI2RlZmluZSBUUkNfTUVNX1BPRF9TVVBFUlBBR0VfU1BMSU5U RVIgKFRSQ19NRU0gKyAxOCkKKworI2RlZmluZSBUUkNfUFZfRU5UUlkgICAweDAwMjAxMDAwIC8q IEh5cGVydmlzb3IgZW50cnkgcG9pbnRzIGZvciBQViBndWVzdHMuICovCisjZGVmaW5lIFRSQ19Q Vl9TVUJDQUxMIDB4MDAyMDIwMDAgLyogU3ViLWNhbGwgaW4gYSBtdWx0aWNhbGwgaHlwZXJjYWxs ICovCisKKyNkZWZpbmUgVFJDX1BWX0hZUEVSQ0FMTCAgICAgICAgICAgICAoVFJDX1BWX0VOVFJZ ICsgIDEpCisjZGVmaW5lIFRSQ19QVl9UUkFQICAgICAgICAgICAgICAgICAgKFRSQ19QVl9FTlRS WSArICAzKQorI2RlZmluZSBUUkNfUFZfUEFHRV9GQVVMVCAgICAgICAgICAgIChUUkNfUFZfRU5U UlkgKyAgNCkKKyNkZWZpbmUgVFJDX1BWX0ZPUkNFRF9JTlZBTElEX09QICAgICAoVFJDX1BWX0VO VFJZICsgIDUpCisjZGVmaW5lIFRSQ19QVl9FTVVMQVRFX1BSSVZPUCAgICAgICAgKFRSQ19QVl9F TlRSWSArICA2KQorI2RlZmluZSBUUkNfUFZfRU1VTEFURV80R0IgICAgICAgICAgIChUUkNfUFZf RU5UUlkgKyAgNykKKyNkZWZpbmUgVFJDX1BWX01BVEhfU1RBVEVfUkVTVE9SRSAgICAoVFJDX1BW X0VOVFJZICsgIDgpCisjZGVmaW5lIFRSQ19QVl9QQUdJTkdfRklYVVAgICAgICAgICAgKFRSQ19Q Vl9FTlRSWSArICA5KQorI2RlZmluZSBUUkNfUFZfR0RUX0xEVF9NQVBQSU5HX0ZBVUxUIChUUkNf UFZfRU5UUlkgKyAxMCkKKyNkZWZpbmUgVFJDX1BWX1BUV1JfRU1VTEFUSU9OICAgICAgICAoVFJD X1BWX0VOVFJZICsgMTEpCisjZGVmaW5lIFRSQ19QVl9QVFdSX0VNVUxBVElPTl9QQUUgICAgKFRS Q19QVl9FTlRSWSArIDEyKQorI2RlZmluZSBUUkNfUFZfSFlQRVJDQUxMX1YyICAgICAgICAgIChU UkNfUFZfRU5UUlkgKyAxMykKKyNkZWZpbmUgVFJDX1BWX0hZUEVSQ0FMTF9TVUJDQUxMICAgICAo VFJDX1BWX1NVQkNBTEwgKyAxNCkKKworLyoKKyAqIFRSQ19QVl9IWVBFUkNBTExfVjIgZm9ybWF0 CisgKgorICogT25seSBzb21lIG9mIHRoZSBoeXBlcmNhbGwgYXJndW1lbnQgYXJlIHJlY29yZGVk LiBCaXQgZmllbGRzIEEwIHRvCisgKiBBNSBpbiB0aGUgZmlyc3QgZXh0cmEgd29yZCBhcmUgc2V0 IGlmIHRoZSBhcmd1bWVudCBpcyBwcmVzZW50IGFuZAorICogdGhlIGFyZ3VtZW50cyB0aGVtc2Vs dmVzIGFyZSBwYWNrZWQgc2VxdWVudGlhbGx5IGluIHRoZSBmb2xsb3dpbmcKKyAqIHdvcmRzLgor ICoKKyAqIFRoZSBUUkNfNjRfRkxBRyBiaXQgaXMgbm90IHNldCBmb3IgdGhlc2UgZXZlbnRzIChl dmVuIGlmIHRoZXJlIGFyZQorICogNjQtYml0IGFyZ3VtZW50cyBpbiB0aGUgcmVjb3JkKS4KKyAq CisgKiBXb3JkCisgKiAwICAgIGJpdCAzMSAzMHwyOSAyOHwyNyAyNnwyNSAyNHwyMyAyMnwyMSAy MHwxOSAuLi4gMAorICogICAgICAgICAgQTUgICB8QTQgICB8QTMgICB8QTIgICB8QTEgICB8QTAg ICB8SHlwZXJjYWxsIG9wCisgKiAxICAgIEZpcnN0IDMyIGJpdCAob3IgbG93IHdvcmQgb2YgZmly c3QgNjQgYml0KSBhcmcgaW4gcmVjb3JkCisgKiAyICAgIFNlY29uZCAzMiBiaXQgKG9yIGhpZ2gg d29yZCBvZiBmaXJzdCA2NCBiaXQpIGFyZyBpbiByZWNvcmQKKyAqIC4uLgorICoKKyAqIEEwLUE1 IGJpdGZpZWxkIHZhbHVlczoKKyAqCisgKiAgIDAwYiAgQXJndW1lbnQgbm90IHByZXNlbnQKKyAq ICAgMDFiICAzMi1iaXQgYXJndW1lbnQgcHJlc2VudAorICogICAxMGIgIDY0LWJpdCBhcmd1bWVu dCBwcmVzZW50CisgKiAgIDExYiAgUmVzZXJ2ZWQKKyAqLworI2RlZmluZSBUUkNfUFZfSFlQRVJD QUxMX1YyX0FSR18zMihpKSAoMHgxIDw8ICgyMCArIDIqKGkpKSkKKyNkZWZpbmUgVFJDX1BWX0hZ UEVSQ0FMTF9WMl9BUkdfNjQoaSkgKDB4MiA8PCAoMjAgKyAyKihpKSkpCisjZGVmaW5lIFRSQ19Q Vl9IWVBFUkNBTExfVjJfQVJHX01BU0sgICgweGZmZjAwMDAwKQorCisjZGVmaW5lIFRSQ19TSEFE T1dfTk9UX1NIQURPVyAgICAgICAgICAgICAgICAgKFRSQ19TSEFET1cgKyAgMSkKKyNkZWZpbmUg VFJDX1NIQURPV19GQVNUX1BST1BBR0FURSAgICAgICAgICAgICAoVFJDX1NIQURPVyArICAyKQor I2RlZmluZSBUUkNfU0hBRE9XX0ZBU1RfTU1JTyAgICAgICAgICAgICAgICAgIChUUkNfU0hBRE9X ICsgIDMpCisjZGVmaW5lIFRSQ19TSEFET1dfRkFMU0VfRkFTVF9QQVRIICAgICAgICAgICAgKFRS Q19TSEFET1cgKyAgNCkKKyNkZWZpbmUgVFJDX1NIQURPV19NTUlPICAgICAgICAgICAgICAgICAg ICAgICAoVFJDX1NIQURPVyArICA1KQorI2RlZmluZSBUUkNfU0hBRE9XX0ZJWFVQICAgICAgICAg ICAgICAgICAgICAgIChUUkNfU0hBRE9XICsgIDYpCisjZGVmaW5lIFRSQ19TSEFET1dfRE9NRl9E WUlORyAgICAgICAgICAgICAgICAgKFRSQ19TSEFET1cgKyAgNykKKyNkZWZpbmUgVFJDX1NIQURP V19FTVVMQVRFICAgICAgICAgICAgICAgICAgICAoVFJDX1NIQURPVyArICA4KQorI2RlZmluZSBU UkNfU0hBRE9XX0VNVUxBVEVfVU5TSEFET1dfVVNFUiAgICAgIChUUkNfU0hBRE9XICsgIDkpCisj ZGVmaW5lIFRSQ19TSEFET1dfRU1VTEFURV9VTlNIQURPV19FVlRJTkogICAgKFRSQ19TSEFET1cg KyAxMCkKKyNkZWZpbmUgVFJDX1NIQURPV19FTVVMQVRFX1VOU0hBRE9XX1VOSEFORExFRCAoVFJD X1NIQURPVyArIDExKQorI2RlZmluZSBUUkNfU0hBRE9XX1dSTUFQX0JGICAgICAgICAgICAgICAg ICAgIChUUkNfU0hBRE9XICsgMTIpCisjZGVmaW5lIFRSQ19TSEFET1dfUFJFQUxMT0NfVU5QSU4g ICAgICAgICAgICAgKFRSQ19TSEFET1cgKyAxMykKKyNkZWZpbmUgVFJDX1NIQURPV19SRVNZTkNf RlVMTCAgICAgICAgICAgICAgICAoVFJDX1NIQURPVyArIDE0KQorI2RlZmluZSBUUkNfU0hBRE9X X1JFU1lOQ19PTkxZICAgICAgICAgICAgICAgIChUUkNfU0hBRE9XICsgMTUpCisKKy8qIHRyYWNl IGV2ZW50cyBwZXIgc3ViY2xhc3MgKi8KKyNkZWZpbmUgVFJDX0hWTV9ORVNURURGTEFHICAgICAg KDB4NDAwKQorI2RlZmluZSBUUkNfSFZNX1ZNRU5UUlkgICAgICAgICAoVFJDX0hWTV9FTlRSWUVY SVQgKyAweDAxKQorI2RlZmluZSBUUkNfSFZNX1ZNRVhJVCAgICAgICAgICAoVFJDX0hWTV9FTlRS WUVYSVQgKyAweDAyKQorI2RlZmluZSBUUkNfSFZNX1ZNRVhJVDY0ICAgICAgICAoVFJDX0hWTV9F TlRSWUVYSVQgKyBUUkNfNjRfRkxBRyArIDB4MDIpCisjZGVmaW5lIFRSQ19IVk1fUEZfWEVOICAg ICAgICAgIChUUkNfSFZNX0hBTkRMRVIgKyAweDAxKQorI2RlZmluZSBUUkNfSFZNX1BGX1hFTjY0 ICAgICAgICAoVFJDX0hWTV9IQU5ETEVSICsgVFJDXzY0X0ZMQUcgKyAweDAxKQorI2RlZmluZSBU UkNfSFZNX1BGX0lOSkVDVCAgICAgICAoVFJDX0hWTV9IQU5ETEVSICsgMHgwMikKKyNkZWZpbmUg VFJDX0hWTV9QRl9JTkpFQ1Q2NCAgICAgKFRSQ19IVk1fSEFORExFUiArIFRSQ182NF9GTEFHICsg MHgwMikKKyNkZWZpbmUgVFJDX0hWTV9JTkpfRVhDICAgICAgICAgKFRSQ19IVk1fSEFORExFUiAr IDB4MDMpCisjZGVmaW5lIFRSQ19IVk1fSU5KX1ZJUlEgICAgICAgIChUUkNfSFZNX0hBTkRMRVIg KyAweDA0KQorI2RlZmluZSBUUkNfSFZNX1JFSU5KX1ZJUlEgICAgICAoVFJDX0hWTV9IQU5ETEVS ICsgMHgwNSkKKyNkZWZpbmUgVFJDX0hWTV9JT19SRUFEICAgICAgICAgKFRSQ19IVk1fSEFORExF UiArIDB4MDYpCisjZGVmaW5lIFRSQ19IVk1fSU9fV1JJVEUgICAgICAgIChUUkNfSFZNX0hBTkRM RVIgKyAweDA3KQorI2RlZmluZSBUUkNfSFZNX0NSX1JFQUQgICAgICAgICAoVFJDX0hWTV9IQU5E TEVSICsgMHgwOCkKKyNkZWZpbmUgVFJDX0hWTV9DUl9SRUFENjQgICAgICAgKFRSQ19IVk1fSEFO RExFUiArIFRSQ182NF9GTEFHICsgMHgwOCkKKyNkZWZpbmUgVFJDX0hWTV9DUl9XUklURSAgICAg ICAgKFRSQ19IVk1fSEFORExFUiArIDB4MDkpCisjZGVmaW5lIFRSQ19IVk1fQ1JfV1JJVEU2NCAg ICAgIChUUkNfSFZNX0hBTkRMRVIgKyBUUkNfNjRfRkxBRyArIDB4MDkpCisjZGVmaW5lIFRSQ19I Vk1fRFJfUkVBRCAgICAgICAgIChUUkNfSFZNX0hBTkRMRVIgKyAweDBBKQorI2RlZmluZSBUUkNf SFZNX0RSX1dSSVRFICAgICAgICAoVFJDX0hWTV9IQU5ETEVSICsgMHgwQikKKyNkZWZpbmUgVFJD X0hWTV9NU1JfUkVBRCAgICAgICAgKFRSQ19IVk1fSEFORExFUiArIDB4MEMpCisjZGVmaW5lIFRS Q19IVk1fTVNSX1dSSVRFICAgICAgIChUUkNfSFZNX0hBTkRMRVIgKyAweDBEKQorI2RlZmluZSBU UkNfSFZNX0NQVUlEICAgICAgICAgICAoVFJDX0hWTV9IQU5ETEVSICsgMHgwRSkKKyNkZWZpbmUg VFJDX0hWTV9JTlRSICAgICAgICAgICAgKFRSQ19IVk1fSEFORExFUiArIDB4MEYpCisjZGVmaW5l IFRSQ19IVk1fTk1JICAgICAgICAgICAgIChUUkNfSFZNX0hBTkRMRVIgKyAweDEwKQorI2RlZmlu ZSBUUkNfSFZNX1NNSSAgICAgICAgICAgICAoVFJDX0hWTV9IQU5ETEVSICsgMHgxMSkKKyNkZWZp bmUgVFJDX0hWTV9WTU1DQUxMICAgICAgICAgKFRSQ19IVk1fSEFORExFUiArIDB4MTIpCisjZGVm aW5lIFRSQ19IVk1fSExUICAgICAgICAgICAgIChUUkNfSFZNX0hBTkRMRVIgKyAweDEzKQorI2Rl ZmluZSBUUkNfSFZNX0lOVkxQRyAgICAgICAgICAoVFJDX0hWTV9IQU5ETEVSICsgMHgxNCkKKyNk ZWZpbmUgVFJDX0hWTV9JTlZMUEc2NCAgICAgICAgKFRSQ19IVk1fSEFORExFUiArIFRSQ182NF9G TEFHICsgMHgxNCkKKyNkZWZpbmUgVFJDX0hWTV9NQ0UgICAgICAgICAgICAgKFRSQ19IVk1fSEFO RExFUiArIDB4MTUpCisjZGVmaW5lIFRSQ19IVk1fSU9QT1JUX1JFQUQgICAgIChUUkNfSFZNX0hB TkRMRVIgKyAweDE2KQorI2RlZmluZSBUUkNfSFZNX0lPTUVNX1JFQUQgICAgICAoVFJDX0hWTV9I QU5ETEVSICsgMHgxNykKKyNkZWZpbmUgVFJDX0hWTV9DTFRTICAgICAgICAgICAgKFRSQ19IVk1f SEFORExFUiArIDB4MTgpCisjZGVmaW5lIFRSQ19IVk1fTE1TVyAgICAgICAgICAgIChUUkNfSFZN X0hBTkRMRVIgKyAweDE5KQorI2RlZmluZSBUUkNfSFZNX0xNU1c2NCAgICAgICAgICAoVFJDX0hW TV9IQU5ETEVSICsgVFJDXzY0X0ZMQUcgKyAweDE5KQorI2RlZmluZSBUUkNfSFZNX1JEVFNDICAg ICAgICAgICAoVFJDX0hWTV9IQU5ETEVSICsgMHgxYSkKKyNkZWZpbmUgVFJDX0hWTV9JTlRSX1dJ TkRPVyAgICAgKFRSQ19IVk1fSEFORExFUiArIDB4MjApCisjZGVmaW5lIFRSQ19IVk1fTlBGICAg ICAgICAgICAgIChUUkNfSFZNX0hBTkRMRVIgKyAweDIxKQorI2RlZmluZSBUUkNfSFZNX1JFQUxN T0RFX0VNVUxBVEUgKFRSQ19IVk1fSEFORExFUiArIDB4MjIpCisjZGVmaW5lIFRSQ19IVk1fVFJB UCAgICAgICAgICAgICAoVFJDX0hWTV9IQU5ETEVSICsgMHgyMykKKyNkZWZpbmUgVFJDX0hWTV9U UkFQX0RFQlVHICAgICAgIChUUkNfSFZNX0hBTkRMRVIgKyAweDI0KQorI2RlZmluZSBUUkNfSFZN X1ZMQVBJQyAgICAgICAgICAgKFRSQ19IVk1fSEFORExFUiArIDB4MjUpCisKKyNkZWZpbmUgVFJD X0hWTV9JT1BPUlRfV1JJVEUgICAgKFRSQ19IVk1fSEFORExFUiArIDB4MjE2KQorI2RlZmluZSBU UkNfSFZNX0lPTUVNX1dSSVRFICAgICAoVFJDX0hWTV9IQU5ETEVSICsgMHgyMTcpCisKKy8qIFRy YWNlIGV2ZW50cyBmb3IgZW11bGF0ZWQgZGV2aWNlcyAqLworI2RlZmluZSBUUkNfSFZNX0VNVUxf SFBFVF9TVEFSVF9USU1FUiAgKFRSQ19IVk1fRU1VTCArIDB4MSkKKyNkZWZpbmUgVFJDX0hWTV9F TVVMX1BJVF9TVEFSVF9USU1FUiAgIChUUkNfSFZNX0VNVUwgKyAweDIpCisjZGVmaW5lIFRSQ19I Vk1fRU1VTF9SVENfU1RBUlRfVElNRVIgICAoVFJDX0hWTV9FTVVMICsgMHgzKQorI2RlZmluZSBU UkNfSFZNX0VNVUxfTEFQSUNfU1RBUlRfVElNRVIgKFRSQ19IVk1fRU1VTCArIDB4NCkKKyNkZWZp bmUgVFJDX0hWTV9FTVVMX0hQRVRfU1RPUF9USU1FUiAgIChUUkNfSFZNX0VNVUwgKyAweDUpCisj ZGVmaW5lIFRSQ19IVk1fRU1VTF9QSVRfU1RPUF9USU1FUiAgICAoVFJDX0hWTV9FTVVMICsgMHg2 KQorI2RlZmluZSBUUkNfSFZNX0VNVUxfUlRDX1NUT1BfVElNRVIgICAgKFRSQ19IVk1fRU1VTCAr IDB4NykKKyNkZWZpbmUgVFJDX0hWTV9FTVVMX0xBUElDX1NUT1BfVElNRVIgIChUUkNfSFZNX0VN VUwgKyAweDgpCisjZGVmaW5lIFRSQ19IVk1fRU1VTF9QSVRfVElNRVJfQ0IgICAgICAoVFJDX0hW TV9FTVVMICsgMHg5KQorI2RlZmluZSBUUkNfSFZNX0VNVUxfTEFQSUNfVElNRVJfQ0IgICAgKFRS Q19IVk1fRU1VTCArIDB4QSkKKyNkZWZpbmUgVFJDX0hWTV9FTVVMX1BJQ19JTlRfT1VUUFVUICAg IChUUkNfSFZNX0VNVUwgKyAweEIpCisjZGVmaW5lIFRSQ19IVk1fRU1VTF9QSUNfS0lDSyAgICAg ICAgICAoVFJDX0hWTV9FTVVMICsgMHhDKQorI2RlZmluZSBUUkNfSFZNX0VNVUxfUElDX0lOVEFD SyAgICAgICAgKFRSQ19IVk1fRU1VTCArIDB4RCkKKyNkZWZpbmUgVFJDX0hWTV9FTVVMX1BJQ19Q T1NFREdFICAgICAgIChUUkNfSFZNX0VNVUwgKyAweEUpCisjZGVmaW5lIFRSQ19IVk1fRU1VTF9Q SUNfTkVHRURHRSAgICAgICAoVFJDX0hWTV9FTVVMICsgMHhGKQorI2RlZmluZSBUUkNfSFZNX0VN VUxfUElDX1BFTkRfSVJRX0NBTEwgKFRSQ19IVk1fRU1VTCArIDB4MTApCisjZGVmaW5lIFRSQ19I Vk1fRU1VTF9MQVBJQ19QSUNfSU5UUiAgICAoVFJDX0hWTV9FTVVMICsgMHgxMSkKKworLyogdHJh Y2UgZXZlbnRzIGZvciBwZXIgY2xhc3MgKi8KKyNkZWZpbmUgVFJDX1BNX0ZSRVFfQ0hBTkdFICAg ICAgKFRSQ19IV19QTSArIDB4MDEpCisjZGVmaW5lIFRSQ19QTV9JRExFX0VOVFJZICAgICAgIChU UkNfSFdfUE0gKyAweDAyKQorI2RlZmluZSBUUkNfUE1fSURMRV9FWElUICAgICAgICAoVFJDX0hX X1BNICsgMHgwMykKKworLyogVHJhY2UgZXZlbnRzIGZvciBJUlFzICovCisjZGVmaW5lIFRSQ19I V19JUlFfTU9WRV9DTEVBTlVQX0RFTEFZIChUUkNfSFdfSVJRICsgMHgxKQorI2RlZmluZSBUUkNf SFdfSVJRX01PVkVfQ0xFQU5VUCAgICAgICAoVFJDX0hXX0lSUSArIDB4MikKKyNkZWZpbmUgVFJD X0hXX0lSUV9CSU5EX1ZFQ1RPUiAgICAgICAgKFRSQ19IV19JUlEgKyAweDMpCisjZGVmaW5lIFRS Q19IV19JUlFfQ0xFQVJfVkVDVE9SICAgICAgIChUUkNfSFdfSVJRICsgMHg0KQorI2RlZmluZSBU UkNfSFdfSVJRX01PVkVfRklOSVNIICAgICAgICAoVFJDX0hXX0lSUSArIDB4NSkKKyNkZWZpbmUg VFJDX0hXX0lSUV9BU1NJR05fVkVDVE9SICAgICAgKFRSQ19IV19JUlEgKyAweDYpCisjZGVmaW5l IFRSQ19IV19JUlFfVU5NQVBQRURfVkVDVE9SICAgIChUUkNfSFdfSVJRICsgMHg3KQorI2RlZmlu ZSBUUkNfSFdfSVJRX0hBTkRMRUQgICAgICAgICAgICAoVFJDX0hXX0lSUSArIDB4OCkKKworLyoK KyAqIEV2ZW50IEZsYWdzCisgKgorICogU29tZSBldmVudHMgKGUuZywgVFJDX1BWX1RSQVAgYW5k IFRSQ19IVk1fSU9NRU1fUkVBRCkgaGF2ZSBtdWx0aXBsZQorICogcmVjb3JkIGZvcm1hdHMuICBU aGVzZSBldmVudCBmbGFncyBkaXN0aW5ndWlzaCBiZXR3ZWVuIHRoZQorICogZGlmZmVyZW50IGZv cm1hdHMuCisgKi8KKyNkZWZpbmUgVFJDXzY0X0ZMQUcgMHgxMDAgLyogQWRkcmVzc2VzIGFyZSA2 NCBiaXRzIChpbnN0ZWFkIG9mIDMyIGJpdHMpICovCisKKy8qIFRoaXMgc3RydWN0dXJlIHJlcHJl c2VudHMgYSBzaW5nbGUgdHJhY2UgYnVmZmVyIHJlY29yZC4gKi8KK3N0cnVjdCB0X3JlYyB7Cisg ICAgdWludDMyX3QgZXZlbnQ6Mjg7CisgICAgdWludDMyX3QgZXh0cmFfdTMyOjM7ICAgICAgICAg LyogIyBlbnRyaWVzIGluIHRyYWlsaW5nIGV4dHJhX3UzMltdIGFycmF5ICovCisgICAgdWludDMy X3QgY3ljbGVzX2luY2x1ZGVkOjE7ICAgLyogdS5jeWNsZXMgb3IgdS5ub19jeWNsZXM/ICovCisg ICAgdW5pb24geworICAgICAgICBzdHJ1Y3QgeworICAgICAgICAgICAgdWludDMyX3QgY3ljbGVz X2xvLCBjeWNsZXNfaGk7IC8qIGN5Y2xlIGNvdW50ZXIgdGltZXN0YW1wICovCisgICAgICAgICAg ICB1aW50MzJfdCBleHRyYV91MzJbN107ICAgICAgICAgLyogZXZlbnQgZGF0YSBpdGVtcyAqLwor ICAgICAgICB9IGN5Y2xlczsKKyAgICAgICAgc3RydWN0IHsKKyAgICAgICAgICAgIHVpbnQzMl90 IGV4dHJhX3UzMls3XTsgICAgICAgICAvKiBldmVudCBkYXRhIGl0ZW1zICovCisgICAgICAgIH0g bm9jeWNsZXM7CisgICAgfSB1OworfTsKKworLyoKKyAqIFRoaXMgc3RydWN0dXJlIGNvbnRhaW5z IHRoZSBtZXRhZGF0YSBmb3IgYSBzaW5nbGUgdHJhY2UgYnVmZmVyLiAgVGhlIGhlYWQKKyAqIGZp ZWxkLCBpbmRleGVzIGludG8gYW4gYXJyYXkgb2Ygc3RydWN0IHRfcmVjJ3MuCisgKi8KK3N0cnVj dCB0X2J1ZiB7CisgICAgLyogQXNzdW1lIHRoZSBkYXRhIGJ1ZmZlciBzaXplIGlzIFguICBYIGlz IGdlbmVyYWxseSBub3QgYSBwb3dlciBvZiAyLgorICAgICAqIENPTlMgYW5kIFBST0QgYXJlIGlu Y3JlbWVudGVkIG1vZHVsbyAoMipYKToKKyAgICAgKiAgICAgMCA8PSBjb25zIDwgMipYCisgICAg ICogICAgIDAgPD0gcHJvZCA8IDIqWAorICAgICAqIFRoaXMgaXMgZG9uZSBiZWNhdXNlIGFkZGl0 aW9uIG1vZHVsbyBYIGJyZWFrcyBhdCAyXjMyIHdoZW4gWCBpcyBub3QgYQorICAgICAqIHBvd2Vy IG9mIDI6CisgICAgICogICAgICgoKDJeMzIgLSAxKSAlIFgpICsgMSkgJSBYICE9ICgyXjMyKSAl IFgKKyAgICAgKi8KKyAgICB1aW50MzJfdCBjb25zOyAgIC8qIE9mZnNldCBvZiBuZXh0IGl0ZW0g dG8gYmUgY29uc3VtZWQgYnkgY29udHJvbCB0b29scy4gKi8KKyAgICB1aW50MzJfdCBwcm9kOyAg IC8qIE9mZnNldCBvZiBuZXh0IGl0ZW0gdG8gYmUgcHJvZHVjZWQgYnkgWGVuLiAgICAgICAgICAg Ki8KKyAgICAvKiAgUmVjb3JkcyBmb2xsb3cgaW1tZWRpYXRlbHkgYWZ0ZXIgdGhlIG1ldGEtZGF0 YSBoZWFkZXIuICAgICovCit9OworCisvKiBTdHJ1Y3R1cmUgdXNlZCB0byBwYXNzIE1GTnMgdG8g dGhlIHRyYWNlIGJ1ZmZlcnMgYmFjayB0byB0cmFjZSBjb25zdW1lcnMuCisgKiBPZmZzZXQgaXMg YW4gb2Zmc2V0IGludG8gdGhlIG1hcHBlZCBzdHJ1Y3R1cmUgd2hlcmUgdGhlIG1mbiBsaXN0IHdp bGwgYmUgaGVsZC4KKyAqIE1GTnMgd2lsbCBiZSBhdCAoKHVuc2lnbmVkIGxvbmcgKikodF9pbmZv KSkrKHRfaW5mby0+Y3B1X29mZnNldFtjcHVdKS4KKyAqLworc3RydWN0IHRfaW5mbyB7CisgICAg dWludDE2X3QgdGJ1Zl9zaXplOyAvKiBTaXplIGluIHBhZ2VzIG9mIGVhY2ggdHJhY2UgYnVmZmVy ICovCisgICAgdWludDE2X3QgbWZuX29mZnNldFtdOyAgLyogT2Zmc2V0IHdpdGhpbiB0X2luZm8g c3RydWN0dXJlIG9mIHRoZSBwYWdlIGxpc3QgcGVyIGNwdSAqLworICAgIC8qIE1GTiBsaXN0cyBp bW1lZGlhdGVseSBhZnRlciB0aGUgaGVhZGVyICovCit9OworCisjZW5kaWYgLyogX19YRU5fUFVC TElDX1RSQUNFX0hfXyAqLworCisvKgorICogTG9jYWwgdmFyaWFibGVzOgorICogbW9kZTogQwor ICogYy1maWxlLXN0eWxlOiAiQlNEIgorICogYy1iYXNpYy1vZmZzZXQ6IDQKKyAqIHRhYi13aWR0 aDogNAorICogaW5kZW50LXRhYnMtbW9kZTogbmlsCisgKiBFbmQ6CisgKi8KZGlmZiAtLWdpdCBh L2luY2x1ZGUveGVuL3hlbi5oIGIvaW5jbHVkZS94ZW4veGVuLmgKaW5kZXggNmM5ZTQyYjJiLi4z MDgxMDlmMTcgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUveGVuL3hlbi5oCisrKyBiL2luY2x1ZGUveGVu L3hlbi5oCkBAIC01MywxNyArNTMsMjIgQEAgREVGSU5FX1hFTl9HVUVTVF9IQU5ETEUodWludDY0 X3QpOwogREVGSU5FX1hFTl9HVUVTVF9IQU5ETEUoeGVuX3Bmbl90KTsKIERFRklORV9YRU5fR1VF U1RfSEFORExFKHhlbl91bG9uZ190KTsKIAotLyogVHVybiBhIHBsYWluIG51bWJlciBpbnRvIGEg QyB1bnNpZ25lZCAobG9uZykgY29uc3RhbnQuICovCisvKiBUdXJuIGEgcGxhaW4gbnVtYmVyIGlu dG8gYSBDIHVuc2lnbmVkIChsb25nIChsb25nKSkgY29uc3RhbnQuICovCiAjZGVmaW5lIF9feGVu X21rX3VpbnQoeCkgIHggIyMgVQogI2RlZmluZSBfX3hlbl9ta191bG9uZyh4KSB4ICMjIFVMCisj aWZuZGVmIF9feGVuX21rX3VsbG9uZworIyBkZWZpbmUgX194ZW5fbWtfdWxsb25nKHgpIHggIyMg VUxMCisjZW5kaWYKICNkZWZpbmUgeGVuX21rX3VpbnQoeCkgICAgX194ZW5fbWtfdWludCh4KQog I2RlZmluZSB4ZW5fbWtfdWxvbmcoeCkgICBfX3hlbl9ta191bG9uZyh4KQorI2RlZmluZSB4ZW5f bWtfdWxsb25nKHgpICBfX3hlbl9ta191bGxvbmcoeCkKIAogI2Vsc2UKIAogLyogSW4gYXNzZW1i bHkgY29kZSB3ZSBjYW5ub3QgdXNlIEMgbnVtZXJpYyBjb25zdGFudCBzdWZmaXhlcy4gKi8KLSNk ZWZpbmUgeGVuX21rX3VpbnQoeCkgIHgKLSNkZWZpbmUgeGVuX21rX3Vsb25nKHgpIHgKKyNkZWZp bmUgeGVuX21rX3VpbnQoeCkgICB4CisjZGVmaW5lIHhlbl9ta191bG9uZyh4KSAgeAorI2RlZmlu ZSB4ZW5fbWtfdWxsb25nKHgpIHgKIAogI2VuZGlmCiAKQEAgLTExNSw2ICsxMjAsNyBAQCBERUZJ TkVfWEVOX0dVRVNUX0hBTkRMRSh4ZW5fdWxvbmdfdCk7CiAjZGVmaW5lIF9fSFlQRVJWSVNPUl90 bWVtX29wICAgICAgICAgICAgICAzOAogI2RlZmluZSBfX0hZUEVSVklTT1JfeGNfcmVzZXJ2ZWRf b3AgICAgICAgMzkgLyogcmVzZXJ2ZWQgZm9yIFhlbkNsaWVudCAqLwogI2RlZmluZSBfX0hZUEVS VklTT1JfeGVucG11X29wICAgICAgICAgICAgNDAKKyNkZWZpbmUgX19IWVBFUlZJU09SX2RtX29w ICAgICAgICAgICAgICAgIDQxCiAKIC8qIEFyY2hpdGVjdHVyZS1zcGVjaWZpYyBoeXBlcmNhbGwg ZGVmaW5pdGlvbnMuICovCiAjZGVmaW5lIF9fSFlQRVJWSVNPUl9hcmNoXzAgICAgICAgICAgICAg ICA0OApAQCAtNTAxLDYgKzUwNywyMSBAQCBERUZJTkVfWEVOX0dVRVNUX0hBTkRMRShtbXVleHRf b3BfdCk7CiAvKiB4ODYvUEFFIGd1ZXN0czogc3VwcG9ydCBQRFBUcyBhYm92ZSA0R0IuICovCiAj ZGVmaW5lIFZNQVNTVF9UWVBFX3BhZV9leHRlbmRlZF9jcjMgICAgIDMKIAorLyoKKyAqIHg4NiBn dWVzdHM6IFNhbmUgYmVoYXZpb3VyIGZvciB2aXJ0dWFsIGlvcGwKKyAqICAtIHZpcnR1YWwgaW9w bCB1cGRhdGVkIGZyb20gZG9faXJldCgpIGh5cGVyY2FsbHMuCisgKiAgLSB2aXJ0dWFsIGlvcGwg cmVwb3J0ZWQgaW4gYm91bmNlIGZyYW1lcy4KKyAqICAtIGd1ZXN0IGtlcm5lbHMgYXNzdW1lZCB0 byBiZSBsZXZlbCAwIGZvciB0aGUgcHVycG9zZSBvZiBpb3BsIGNoZWNrcy4KKyAqLworI2RlZmlu ZSBWTUFTU1RfVFlQRV9hcmNoaXRlY3R1cmFsX2lvcGwgICA0CisKKy8qCisgKiBBbGwgZ3Vlc3Rz OiBhY3RpdmF0ZSB1cGRhdGUgaW5kaWNhdG9yIGluIHZjcHVfcnVuc3RhdGVfaW5mbworICogRW5h YmxlIHNldHRpbmcgdGhlIFhFTl9SVU5TVEFURV9VUERBVEUgZmxhZyBpbiBndWVzdCBtZW1vcnkg bWFwcGVkCisgKiB2Y3B1X3J1bnN0YXRlX2luZm8gZHVyaW5nIHVwZGF0ZXMgb2YgdGhlIHJ1bnN0 YXRlIGluZm9ybWF0aW9uLgorICovCisjZGVmaW5lIFZNQVNTVF9UWVBFX3J1bnN0YXRlX3VwZGF0 ZV9mbGFnIDUKKwogLyoKICAqIHg4Ni82NCBndWVzdHM6IHN0cmljdGx5IGhpZGUgTTJQIGZyb20g dXNlciBtb2RlLgogICogVGhpcyBhbGxvd3MgdGhlIGd1ZXN0IHRvIGNvbnRyb2wgcmVzcGVjdGl2 ZSBoeXBlcnZpc29yIGJlaGF2aW9yOgpAQCAtNTI5LDE2ICs1NTAsMjEgQEAgREVGSU5FX1hFTl9H VUVTVF9IQU5ETEUobW11ZXh0X29wX3QpOwogICogaXMgdXNlZnVsIHRvIGVuc3VyZSB0aGF0IG5v IG1hcHBpbmdzIHRvIHRoZSBPUydzIG93biBoZWFwIGFyZSBhY2NpZGVudGFsbHkKICAqIGluc3Rh bGxlZC4gKGUuZy4sIGluIExpbnV4IHRoaXMgY291bGQgY2F1c2UgaGF2b2MgYXMgcmVmZXJlbmNl IGNvdW50cwogICogYXJlbid0IGFkanVzdGVkIG9uIHRoZSBJL08tbWFwcGluZyBjb2RlIHBhdGgp LgotICogVGhpcyBvbmx5IG1ha2VzIHNlbnNlIGluIE1NVUVYVF9TRVRfRk9SRUlHTkRPTSwgYnV0 IGluIHRoYXQgY29udGV4dCBjYW4KLSAqIGJlIHNwZWNpZmllZCBieSBhbnkgY2FsbGluZyBkb21h aW4uCisgKiBUaGlzIG9ubHkgbWFrZXMgc2Vuc2UgYXMgSFlQRVJWSVNPUl9tbXVfdXBkYXRlKCkn cyBhbmQKKyAqIEhZUEVSVklTT1JfdXBkYXRlX3ZhX21hcHBpbmdfb3RoZXJkb21haW4oKSdzICJm b3JlaWduZG9tIiBhcmd1bWVudC4gRm9yCisgKiBIWVBFUlZJU09SX21tdV91cGRhdGUoKSBjb250 ZXh0IGl0IGNhbiBiZSBzcGVjaWZpZWQgYnkgYW55IGNhbGxpbmcgZG9tYWluLAorICogb3RoZXJ3 aXNlIGl0J3Mgb25seSBwZXJtaXR0ZWQgaWYgdGhlIGNhbGxlciBpcyBwcml2aWxlZ2VkLgogICov CiAjZGVmaW5lIERPTUlEX0lPICAgICAgICAgICAgIHhlbl9ta191aW50KDB4N0ZGMSkKIAogLyoK ICAqIERPTUlEX1hFTiBpcyB1c2VkIHRvIGFsbG93IHByaXZpbGVnZWQgZG9tYWlucyB0byBtYXAg cmVzdHJpY3RlZCBwYXJ0cyBvZgogICogWGVuJ3MgaGVhcCBzcGFjZSAoZS5nLiwgdGhlIG1hY2hp bmVfdG9fcGh5cyB0YWJsZSkuCi0gKiBUaGlzIG9ubHkgbWFrZXMgc2Vuc2UgaW4gTU1VRVhUX1NF VF9GT1JFSUdORE9NLCBhbmQgaXMgb25seSBwZXJtaXR0ZWQgaWYKLSAqIHRoZSBjYWxsZXIgaXMg cHJpdmlsZWdlZC4KKyAqIFRoaXMgb25seSBtYWtlcyBzZW5zZSBhcworICogLSBIWVBFUlZJU09S X21tdV91cGRhdGUoKSdzLCBIWVBFUlZJU09SX21tdWV4dF9vcCgpJ3MsIG9yCisgKiAgIEhZUEVS VklTT1JfdXBkYXRlX3ZhX21hcHBpbmdfb3RoZXJkb21haW4oKSdzICJmb3JlaWduZG9tIiBhcmd1 bWVudCwKKyAqIC0gd2l0aCBYRU5NQVBTUEFDRV9nbWZuX2ZvcmVpZ24sCisgKiBhbmQgaXMgb25s eSBwZXJtaXR0ZWQgaWYgdGhlIGNhbGxlciBpcyBwcml2aWxlZ2VkLgogICovCiAjZGVmaW5lIERP TUlEX1hFTiAgICAgICAgICAgIHhlbl9ta191aW50KDB4N0ZGMikKIApAQCAtNjE0LDEwICs2NDAs MTggQEAgc3RydWN0IHZjcHVfdGltZV9pbmZvIHsKICAgICAgKi8KICAgICB1aW50MzJfdCB0c2Nf dG9fc3lzdGVtX211bDsKICAgICBpbnQ4X3QgICB0c2Nfc2hpZnQ7CisjaWYgX19YRU5fSU5URVJG QUNFX1ZFUlNJT05fXyA+IDB4MDQwNjAwCisgICAgdWludDhfdCAgZmxhZ3M7CisgICAgdWludDhf dCAgcGFkMVsyXTsKKyNlbHNlCiAgICAgaW50OF90ICAgcGFkMVszXTsKKyNlbmRpZgogfTsgLyog MzIgYnl0ZXMgKi8KIHR5cGVkZWYgc3RydWN0IHZjcHVfdGltZV9pbmZvIHZjcHVfdGltZV9pbmZv X3Q7CiAKKyNkZWZpbmUgWEVOX1BWQ0xPQ0tfVFNDX1NUQUJMRV9CSVQgICAgICgxIDw8IDApCisj ZGVmaW5lIFhFTl9QVkNMT0NLX0dVRVNUX1NUT1BQRUQgICAgICAoMSA8PCAxKQorCiBzdHJ1Y3Qg dmNwdV9pbmZvIHsKICAgICAvKgogICAgICAqICdldnRjaG5fdXBjYWxsX3BlbmRpbmcnIGlzIHdy aXR0ZW4gbm9uLXplcm8gYnkgWGVuIHRvIGluZGljYXRlCkBAIC03MzYsNyArNzcwLDcgQEAgdHlw ZWRlZiBzdHJ1Y3Qgc2hhcmVkX2luZm8gc2hhcmVkX2luZm9fdDsKICAqICAgICAgICAgKG1heSBi ZSBvbWl0dGVkKQogICogICAgICBjLiBsaXN0IG9mIGFsbG9jYXRlZCBwYWdlIGZyYW1lcyBbbWZu X2xpc3QsIG5yX3BhZ2VzXQogICogICAgICAgICAodW5sZXNzIHJlbG9jYXRlZCBkdWUgdG8gWEVO X0VMRk5PVEVfSU5JVF9QMk0pCi0gKiAgICAgIGQuIHN0YXJ0X2luZm9fdCBzdHJ1Y3R1cmUgICAg ICAgIFtyZWdpc3RlciBFU0kgKHg4NildCisgKiAgICAgIGQuIHN0YXJ0X2luZm9fdCBzdHJ1Y3R1 cmUgICAgICAgIFtyZWdpc3RlciByU0kgKHg4NildCiAgKiAgICAgICAgIGluIGNhc2Ugb2YgZG9t MCB0aGlzIHBhZ2UgY29udGFpbnMgdGhlIGNvbnNvbGUgaW5mbywgdG9vCiAgKiAgICAgIGUuIHVu bGVzcyBkb20wOiB4ZW5zdG9yZSByaW5nIHBhZ2UKICAqICAgICAgZi4gdW5sZXNzIGRvbTA6IGNv bnNvbGUgcmluZyBwYWdlCkBAIC03OTcsMjkgKzgzMSw2IEBAIHN0cnVjdCBzdGFydF9pbmZvIHsK IH07CiB0eXBlZGVmIHN0cnVjdCBzdGFydF9pbmZvIHN0YXJ0X2luZm9fdDsKIAotLyoKLSAqIFN0 YXJ0IG9mIGRheSBzdHJ1Y3R1cmUgcGFzc2VkIHRvIFBWSCBndWVzdHMgaW4gJWVieC4KLSAqCi0g KiBOT1RFOiBub3RoaW5nIHdpbGwgYmUgbG9hZGVkIGF0IHBoeXNpY2FsIGFkZHJlc3MgMCwgc28K LSAqIGEgMCB2YWx1ZSBpbiBhbnkgb2YgdGhlIGFkZHJlc3MgZmllbGRzIHNob3VsZCBiZSB0cmVh dGVkCi0gKiBhcyBub3QgcHJlc2VudC4KLSAqLwotc3RydWN0IGh2bV9zdGFydF9pbmZvIHsKLSNk ZWZpbmUgSFZNX1NUQVJUX01BR0lDX1ZBTFVFIDB4MzM2ZWM1NzgKLSAgICB1aW50MzJfdCBtYWdp YzsgICAgICAgICAgICAgLyogQ29udGFpbnMgdGhlIG1hZ2ljIHZhbHVlIDB4MzM2ZWM1NzggICAg ICAgKi8KLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogKCJ4RW4zIiB3aXRoIHRo ZSAweDgwIGJpdCBvZiB0aGUgIkUiIHNldCkuKi8KLSAgICB1aW50MzJfdCBmbGFnczsgICAgICAg ICAgICAgLyogU0lGX3h4eCBmbGFncy4gICAgICAgICAgICAgICAgICAgICAgICAgICAgKi8KLSAg ICB1aW50MzJfdCBjbWRsaW5lX3BhZGRyOyAgICAgLyogUGh5c2ljYWwgYWRkcmVzcyBvZiB0aGUg Y29tbWFuZCBsaW5lLiAgICAgKi8KLSAgICB1aW50MzJfdCBucl9tb2R1bGVzOyAgICAgICAgLyog TnVtYmVyIG9mIG1vZHVsZXMgcGFzc2VkIHRvIHRoZSBrZXJuZWwuICAgKi8KLSAgICB1aW50MzJf dCBtb2RsaXN0X3BhZGRyOyAgICAgLyogUGh5c2ljYWwgYWRkcmVzcyBvZiBhbiBhcnJheSBvZiAg ICAgICAgICAgKi8KLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogaHZtX21vZGxp c3RfZW50cnkuICAgICAgICAgICAgICAgICAgICAgICAgKi8KLX07Ci0KLXN0cnVjdCBodm1fbW9k bGlzdF9lbnRyeSB7Ci0gICAgdWludDMyX3QgcGFkZHI7ICAgICAgICAgICAgIC8qIFBoeXNpY2Fs IGFkZHJlc3Mgb2YgdGhlIG1vZHVsZS4gICAgICAgICAgICovCi0gICAgdWludDMyX3Qgc2l6ZTsg ICAgICAgICAgICAgIC8qIFNpemUgb2YgdGhlIG1vZHVsZSBpbiBieXRlcy4gICAgICAgICAgICAg ICovCi19OwotCiAvKiBOZXcgY29uc29sZSB1bmlvbiBmb3IgZG9tMCBpbnRyb2R1Y2VkIGluIDB4 MDAwMzAyMDMuICovCiAjaWYgX19YRU5fSU5URVJGQUNFX1ZFUlNJT05fXyA8IDB4MDAwMzAyMDMK ICNkZWZpbmUgY29uc29sZV9tZm4gICAgY29uc29sZS5kb21VLm1mbgpAQCAtOTE5LDYgKzkzMCwz NyBAQCBfX0RFRklORV9YRU5fR1VFU1RfSEFORExFKHVpbnQxNiwgdWludDE2X3QpOwogX19ERUZJ TkVfWEVOX0dVRVNUX0hBTkRMRSh1aW50MzIsIHVpbnQzMl90KTsKIF9fREVGSU5FX1hFTl9HVUVT VF9IQU5ETEUodWludDY0LCB1aW50NjRfdCk7CiAKK3R5cGVkZWYgc3RydWN0IHsKKyAgICB1aW50 OF90IGFbMTZdOworfSB4ZW5fdXVpZF90OworCisvKgorICogWEVOX0RFRklORV9VVUlEKDB4MDAx MTIyMzMsIDB4NDQ1NSwgMHg2Njc3LCAweDg4OTksCisgKiAgICAgICAgICAgICAgICAgMHhhYSwg MHhiYiwgMHhjYywgMHhkZCwgMHhlZSwgMHhmZikKKyAqIHdpbGwgY29uc3RydWN0IFVVSUQgMDAx MTIyMzMtNDQ1NS02Njc3LTg4OTktYWFiYmNjZGRlZWZmIHByZXNlbnRlZCBhcworICogezB4MDAs IDB4MTEsIDB4MjIsIDB4MzMsIDB4NDQsIDB4NTUsIDB4NjYsIDB4NzcsIDB4ODgsCisgKiAweDk5 LCAweGFhLCAweGJiLCAweGNjLCAweGRkLCAweGVlLCAweGZmfTsKKyAqCisgKiBOQjogVGhpcyBp cyBjb21wYXRpYmxlIHdpdGggTGludXgga2VybmVsIGFuZCB3aXRoIGxpYnV1aWQsIGJ1dCBpdCBp cyBub3QKKyAqIGNvbXBhdGlibGUgd2l0aCBNaWNyb3NvZnQsIGFzIHRoZXkgdXNlIG1peGVkLWVu ZGlhbiBlbmNvZGluZyAoc29tZQorICogY29tcG9uZW50cyBhcmUgbGl0dGxlLWVuZGlhbiwgc29t ZSBhcmUgYmlnLWVuZGlhbikuCisgKi8KKyNkZWZpbmUgWEVOX0RFRklORV9VVUlEXyhhLCBiLCBj LCBkLCBlMSwgZTIsIGUzLCBlNCwgZTUsIGU2KSAgICAgICAgICAgIFwKKyAgICB7eygoYSkgPj4g MjQpICYgMHhGRiwgKChhKSA+PiAxNikgJiAweEZGLCAgICAgICAgICAgICAgICAgICAgICAgICAg IFwKKyAgICAgICgoYSkgPj4gIDgpICYgMHhGRiwgKChhKSA+PiAgMCkgJiAweEZGLCAgICAgICAg ICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICgoYikgPj4gIDgpICYgMHhGRiwgKChiKSA+PiAg MCkgJiAweEZGLCAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICgoYykgPj4gIDgp ICYgMHhGRiwgKChjKSA+PiAgMCkgJiAweEZGLCAgICAgICAgICAgICAgICAgICAgICAgICAgIFwK KyAgICAgICgoZCkgPj4gIDgpICYgMHhGRiwgKChkKSA+PiAgMCkgJiAweEZGLCAgICAgICAgICAg ICAgICAgICAgICAgICAgIFwKKyAgICAgICAgICAgICAgICBlMSwgZTIsIGUzLCBlNCwgZTUsIGU2 fX0KKworI2lmIGRlZmluZWQoX19TVERDX1ZFUlNJT05fXykgPyBfX1NURENfVkVSU0lPTl9fID49 IDE5OTkwMUwgOiBkZWZpbmVkKF9fR05VQ19fKQorI2RlZmluZSBYRU5fREVGSU5FX1VVSUQoYSwg YiwgYywgZCwgZTEsIGUyLCBlMywgZTQsIGU1LCBlNikgICAgICAgICAgICAgXAorICAgICgoeGVu X3V1aWRfdClYRU5fREVGSU5FX1VVSURfKGEsIGIsIGMsIGQsIGUxLCBlMiwgZTMsIGU0LCBlNSwg ZTYpKQorI2Vsc2UKKyNkZWZpbmUgWEVOX0RFRklORV9VVUlEKGEsIGIsIGMsIGQsIGUxLCBlMiwg ZTMsIGU0LCBlNSwgZTYpICAgICAgICAgICAgIFwKKyAgICBYRU5fREVGSU5FX1VVSURfKGEsIGIs IGMsIGQsIGUxLCBlMiwgZTMsIGU0LCBlNSwgZTYpCisjZW5kaWYgLyogX19TVERDX1ZFUlNJT05f XyAvIF9fR05VQ19fICovCisKICNlbmRpZiAvKiAhX19BU1NFTUJMWV9fICovCiAKIC8qIERlZmF1 bHQgZGVmaW5pdGlvbnMgZm9yIG1hY3JvcyB1c2VkIGJ5IGRvbWN0bC9zeXNjdGwuICovCi0tIAoy LjE2LjQKCgpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpY ZW4tZGV2ZWwgbWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9yZwpodHRw czovL2xpc3RzLnhlbnByb2plY3Qub3JnL21haWxtYW4vbGlzdGluZm8veGVuLWRldmVs From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from list by lists.gnu.org with archive (Exim 4.71) id 1gIYwg-0007bF-P5 for mharc-grub-devel@gnu.org; Fri, 02 Nov 2018 08:53:02 -0400 Received: from eggs.gnu.org ([2001:4830:134:3::10]:43472) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gIYwO-0005NV-6D for grub-devel@gnu.org; Fri, 02 Nov 2018 08:52:52 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1gIYhu-000528-Lm for grub-devel@gnu.org; Fri, 02 Nov 2018 08:37:55 -0400 Received: from mx2.suse.de ([195.135.220.15]:49996 helo=mx1.suse.de) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1gIYht-0004uy-UH for grub-devel@gnu.org; Fri, 02 Nov 2018 08:37:46 -0400 X-Virus-Scanned: by amavisd-new at test-mx.suse.de Received: from relay1.suse.de (unknown [195.135.220.254]) by mx1.suse.de (Postfix) with ESMTP id 96A93AD05; Fri, 2 Nov 2018 12:37:41 +0000 (UTC) From: Juergen Gross To: grub-devel@gnu.org Cc: xen-devel@lists.xen.org, phcoder@gmail.com, daniel.kiper@oracle.com, hans@knorrie.org, Juergen Gross Subject: [PATCH v4 01/19] xen: add some xen headers Date: Fri, 2 Nov 2018 13:37:20 +0100 Message-Id: <20181102123738.16395-2-jgross@suse.com> X-Mailer: git-send-email 2.16.4 In-Reply-To: <20181102123738.16395-1-jgross@suse.com> References: <20181102123738.16395-1-jgross@suse.com> X-detected-operating-system: by eggs.gnu.org: GNU/Linux 2.2.x-3.x (no timestamps) [generic] X-Received-From: 195.135.220.15 X-BeenThere: grub-devel@gnu.org X-Mailman-Version: 2.1.21 Precedence: list List-Id: The development of GNU GRUB List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Fri, 02 Nov 2018 12:52:53 -0000 In order to support grub2 in Xen PVH environment some additional Xen headers are needed as grub2 will be started in PVH mode requiring to use several HVM hypercalls and structures. Add the needed headers from Xen 4.10 being the first Xen version with full (not only experimental) PVH guest support. Signed-off-by: Juergen Gross Reviewed-by: Daniel Kiper --- V2: update commit message (Daniel Kiper) --- include/xen/hvm/hvm_op.h | 296 +++++++++++++++++++ include/xen/hvm/params.h | 284 ++++++++++++++++++ include/xen/hvm/start_info.h | 98 +++++++ include/xen/memory.h | 665 +++++++++++++++++++++++++++++++++++++++++++ include/xen/physdev.h | 387 +++++++++++++++++++++++++ include/xen/trace.h | 339 ++++++++++++++++++++++ include/xen/xen.h | 104 +++++-- 7 files changed, 2142 insertions(+), 31 deletions(-) create mode 100644 include/xen/hvm/hvm_op.h create mode 100644 include/xen/hvm/params.h create mode 100644 include/xen/hvm/start_info.h create mode 100644 include/xen/memory.h create mode 100644 include/xen/physdev.h create mode 100644 include/xen/trace.h diff --git a/include/xen/hvm/hvm_op.h b/include/xen/hvm/hvm_op.h new file mode 100644 index 000000000..0bdafdf59 --- /dev/null +++ b/include/xen/hvm/hvm_op.h @@ -0,0 +1,296 @@ +/* + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Copyright (c) 2007, Keir Fraser + */ + +#ifndef __XEN_PUBLIC_HVM_HVM_OP_H__ +#define __XEN_PUBLIC_HVM_HVM_OP_H__ + +#include "../xen.h" +#include "../trace.h" +#include "../event_channel.h" + +/* Get/set subcommands: extra argument == pointer to xen_hvm_param struct. */ +#define HVMOP_set_param 0 +#define HVMOP_get_param 1 +struct xen_hvm_param { + domid_t domid; /* IN */ + uint32_t index; /* IN */ + uint64_t value; /* IN/OUT */ +}; +typedef struct xen_hvm_param xen_hvm_param_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_param_t); + +#if __XEN_INTERFACE_VERSION__ < 0x00040900 + +/* Set the logical level of one of a domain's PCI INTx wires. */ +#define HVMOP_set_pci_intx_level 2 +struct xen_hvm_set_pci_intx_level { + /* Domain to be updated. */ + domid_t domid; + /* PCI INTx identification in PCI topology (domain:bus:device:intx). */ + uint8_t domain, bus, device, intx; + /* Assertion level (0 = unasserted, 1 = asserted). */ + uint8_t level; +}; +typedef struct xen_hvm_set_pci_intx_level xen_hvm_set_pci_intx_level_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_set_pci_intx_level_t); + +/* Set the logical level of one of a domain's ISA IRQ wires. */ +#define HVMOP_set_isa_irq_level 3 +struct xen_hvm_set_isa_irq_level { + /* Domain to be updated. */ + domid_t domid; + /* ISA device identification, by ISA IRQ (0-15). */ + uint8_t isa_irq; + /* Assertion level (0 = unasserted, 1 = asserted). */ + uint8_t level; +}; +typedef struct xen_hvm_set_isa_irq_level xen_hvm_set_isa_irq_level_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_set_isa_irq_level_t); + +#define HVMOP_set_pci_link_route 4 +struct xen_hvm_set_pci_link_route { + /* Domain to be updated. */ + domid_t domid; + /* PCI link identifier (0-3). */ + uint8_t link; + /* ISA IRQ (1-15), or 0 (disable link). */ + uint8_t isa_irq; +}; +typedef struct xen_hvm_set_pci_link_route xen_hvm_set_pci_link_route_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_set_pci_link_route_t); + +#endif /* __XEN_INTERFACE_VERSION__ < 0x00040900 */ + +/* Flushes all VCPU TLBs: @arg must be NULL. */ +#define HVMOP_flush_tlbs 5 + +typedef enum { + HVMMEM_ram_rw, /* Normal read/write guest RAM */ + HVMMEM_ram_ro, /* Read-only; writes are discarded */ + HVMMEM_mmio_dm, /* Reads and write go to the device model */ +#if __XEN_INTERFACE_VERSION__ < 0x00040700 + HVMMEM_mmio_write_dm, /* Read-only; writes go to the device model */ +#else + HVMMEM_unused, /* Placeholder; setting memory to this type + will fail for code after 4.7.0 */ +#endif + HVMMEM_ioreq_server /* Memory type claimed by an ioreq server; type + changes to this value are only allowed after + an ioreq server has claimed its ownership. + Only pages with HVMMEM_ram_rw are allowed to + change to this type; conversely, pages with + this type are only allowed to be changed back + to HVMMEM_ram_rw. */ +} hvmmem_type_t; + +/* Hint from PV drivers for pagetable destruction. */ +#define HVMOP_pagetable_dying 9 +struct xen_hvm_pagetable_dying { + /* Domain with a pagetable about to be destroyed. */ + domid_t domid; + uint16_t pad[3]; /* align next field on 8-byte boundary */ + /* guest physical address of the toplevel pagetable dying */ + uint64_t gpa; +}; +typedef struct xen_hvm_pagetable_dying xen_hvm_pagetable_dying_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_pagetable_dying_t); + +/* Get the current Xen time, in nanoseconds since system boot. */ +#define HVMOP_get_time 10 +struct xen_hvm_get_time { + uint64_t now; /* OUT */ +}; +typedef struct xen_hvm_get_time xen_hvm_get_time_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_get_time_t); + +#define HVMOP_xentrace 11 +struct xen_hvm_xentrace { + uint16_t event, extra_bytes; + uint8_t extra[TRACE_EXTRA_MAX * sizeof(uint32_t)]; +}; +typedef struct xen_hvm_xentrace xen_hvm_xentrace_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_xentrace_t); + +/* Following tools-only interfaces may change in future. */ +#if defined(__XEN__) || defined(__XEN_TOOLS__) + +/* Deprecated by XENMEM_access_op_set_access */ +#define HVMOP_set_mem_access 12 + +/* Deprecated by XENMEM_access_op_get_access */ +#define HVMOP_get_mem_access 13 + +#endif /* defined(__XEN__) || defined(__XEN_TOOLS__) */ + +#define HVMOP_get_mem_type 15 +/* Return hvmmem_type_t for the specified pfn. */ +struct xen_hvm_get_mem_type { + /* Domain to be queried. */ + domid_t domid; + /* OUT variable. */ + uint16_t mem_type; + uint16_t pad[2]; /* align next field on 8-byte boundary */ + /* IN variable. */ + uint64_t pfn; +}; +typedef struct xen_hvm_get_mem_type xen_hvm_get_mem_type_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_get_mem_type_t); + +/* Following tools-only interfaces may change in future. */ +#if defined(__XEN__) || defined(__XEN_TOOLS__) + +/* + * Definitions relating to DMOP_create_ioreq_server. (Defined here for + * backwards compatibility). + */ + +#define HVM_IOREQSRV_BUFIOREQ_OFF 0 +#define HVM_IOREQSRV_BUFIOREQ_LEGACY 1 +/* + * Use this when read_pointer gets updated atomically and + * the pointer pair gets read atomically: + */ +#define HVM_IOREQSRV_BUFIOREQ_ATOMIC 2 + +#endif /* defined(__XEN__) || defined(__XEN_TOOLS__) */ + +#if defined(__i386__) || defined(__x86_64__) + +/* + * HVMOP_set_evtchn_upcall_vector: Set a that should be used for event + * channel upcalls on the specified . If set, + * this vector will be used in preference to the + * domain global callback via (see + * HVM_PARAM_CALLBACK_IRQ). + */ +#define HVMOP_set_evtchn_upcall_vector 23 +struct xen_hvm_evtchn_upcall_vector { + uint32_t vcpu; + uint8_t vector; +}; +typedef struct xen_hvm_evtchn_upcall_vector xen_hvm_evtchn_upcall_vector_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_evtchn_upcall_vector_t); + +#endif /* defined(__i386__) || defined(__x86_64__) */ + +#define HVMOP_guest_request_vm_event 24 + +/* HVMOP_altp2m: perform altp2m state operations */ +#define HVMOP_altp2m 25 + +#define HVMOP_ALTP2M_INTERFACE_VERSION 0x00000001 + +struct xen_hvm_altp2m_domain_state { + /* IN or OUT variable on/off */ + uint8_t state; +}; +typedef struct xen_hvm_altp2m_domain_state xen_hvm_altp2m_domain_state_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_altp2m_domain_state_t); + +struct xen_hvm_altp2m_vcpu_enable_notify { + uint32_t vcpu_id; + uint32_t pad; + /* #VE info area gfn */ + uint64_t gfn; +}; +typedef struct xen_hvm_altp2m_vcpu_enable_notify xen_hvm_altp2m_vcpu_enable_notify_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_altp2m_vcpu_enable_notify_t); + +struct xen_hvm_altp2m_view { + /* IN/OUT variable */ + uint16_t view; + /* Create view only: default access type + * NOTE: currently ignored */ + uint16_t hvmmem_default_access; /* xenmem_access_t */ +}; +typedef struct xen_hvm_altp2m_view xen_hvm_altp2m_view_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_altp2m_view_t); + +struct xen_hvm_altp2m_set_mem_access { + /* view */ + uint16_t view; + /* Memory type */ + uint16_t hvmmem_access; /* xenmem_access_t */ + uint32_t pad; + /* gfn */ + uint64_t gfn; +}; +typedef struct xen_hvm_altp2m_set_mem_access xen_hvm_altp2m_set_mem_access_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_altp2m_set_mem_access_t); + +struct xen_hvm_altp2m_change_gfn { + /* view */ + uint16_t view; + uint16_t pad1; + uint32_t pad2; + /* old gfn */ + uint64_t old_gfn; + /* new gfn, INVALID_GFN (~0UL) means revert */ + uint64_t new_gfn; +}; +typedef struct xen_hvm_altp2m_change_gfn xen_hvm_altp2m_change_gfn_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_altp2m_change_gfn_t); + +struct xen_hvm_altp2m_op { + uint32_t version; /* HVMOP_ALTP2M_INTERFACE_VERSION */ + uint32_t cmd; +/* Get/set the altp2m state for a domain */ +#define HVMOP_altp2m_get_domain_state 1 +#define HVMOP_altp2m_set_domain_state 2 +/* Set the current VCPU to receive altp2m event notifications */ +#define HVMOP_altp2m_vcpu_enable_notify 3 +/* Create a new view */ +#define HVMOP_altp2m_create_p2m 4 +/* Destroy a view */ +#define HVMOP_altp2m_destroy_p2m 5 +/* Switch view for an entire domain */ +#define HVMOP_altp2m_switch_p2m 6 +/* Notify that a page of memory is to have specific access types */ +#define HVMOP_altp2m_set_mem_access 7 +/* Change a p2m entry to have a different gfn->mfn mapping */ +#define HVMOP_altp2m_change_gfn 8 + domid_t domain; + uint16_t pad1; + uint32_t pad2; + union { + struct xen_hvm_altp2m_domain_state domain_state; + struct xen_hvm_altp2m_vcpu_enable_notify enable_notify; + struct xen_hvm_altp2m_view view; + struct xen_hvm_altp2m_set_mem_access set_mem_access; + struct xen_hvm_altp2m_change_gfn change_gfn; + uint8_t pad[64]; + } u; +}; +typedef struct xen_hvm_altp2m_op xen_hvm_altp2m_op_t; +DEFINE_XEN_GUEST_HANDLE(xen_hvm_altp2m_op_t); + +#endif /* __XEN_PUBLIC_HVM_HVM_OP_H__ */ + +/* + * Local variables: + * mode: C + * c-file-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */ diff --git a/include/xen/hvm/params.h b/include/xen/hvm/params.h new file mode 100644 index 000000000..2ec2e7c80 --- /dev/null +++ b/include/xen/hvm/params.h @@ -0,0 +1,284 @@ +/* + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Copyright (c) 2007, Keir Fraser + */ + +#ifndef __XEN_PUBLIC_HVM_PARAMS_H__ +#define __XEN_PUBLIC_HVM_PARAMS_H__ + +#include "hvm_op.h" + +/* + * Parameter space for HVMOP_{set,get}_param. + */ + +#define HVM_PARAM_CALLBACK_IRQ 0 +#define HVM_PARAM_CALLBACK_IRQ_TYPE_MASK xen_mk_ullong(0xFF00000000000000) +/* + * How should CPU0 event-channel notifications be delivered? + * + * If val == 0 then CPU0 event-channel notifications are not delivered. + * If val != 0, val[63:56] encodes the type, as follows: + */ + +#define HVM_PARAM_CALLBACK_TYPE_GSI 0 +/* + * val[55:0] is a delivery GSI. GSI 0 cannot be used, as it aliases val == 0, + * and disables all notifications. + */ + +#define HVM_PARAM_CALLBACK_TYPE_PCI_INTX 1 +/* + * val[55:0] is a delivery PCI INTx line: + * Domain = val[47:32], Bus = val[31:16] DevFn = val[15:8], IntX = val[1:0] + */ + +#if defined(__i386__) || defined(__x86_64__) +#define HVM_PARAM_CALLBACK_TYPE_VECTOR 2 +/* + * val[7:0] is a vector number. Check for XENFEAT_hvm_callback_vector to know + * if this delivery method is available. + */ +#elif defined(__arm__) || defined(__aarch64__) +#define HVM_PARAM_CALLBACK_TYPE_PPI 2 +/* + * val[55:16] needs to be zero. + * val[15:8] is interrupt flag of the PPI used by event-channel: + * bit 8: the PPI is edge(1) or level(0) triggered + * bit 9: the PPI is active low(1) or high(0) + * val[7:0] is a PPI number used by event-channel. + * This is only used by ARM/ARM64 and masking/eoi the interrupt associated to + * the notification is handled by the interrupt controller. + */ +#define HVM_PARAM_CALLBACK_TYPE_PPI_FLAG_MASK 0xFF00 +#define HVM_PARAM_CALLBACK_TYPE_PPI_FLAG_LOW_LEVEL 2 +#endif + +/* + * These are not used by Xen. They are here for convenience of HVM-guest + * xenbus implementations. + */ +#define HVM_PARAM_STORE_PFN 1 +#define HVM_PARAM_STORE_EVTCHN 2 + +#define HVM_PARAM_PAE_ENABLED 4 + +#define HVM_PARAM_IOREQ_PFN 5 + +#define HVM_PARAM_BUFIOREQ_PFN 6 +#define HVM_PARAM_BUFIOREQ_EVTCHN 26 + +#if defined(__i386__) || defined(__x86_64__) + +/* + * Viridian enlightenments + * + * (See http://download.microsoft.com/download/A/B/4/AB43A34E-BDD0-4FA6-BDEF-79EEF16E880B/Hypervisor%20Top%20Level%20Functional%20Specification%20v4.0.docx) + * + * To expose viridian enlightenments to the guest set this parameter + * to the desired feature mask. The base feature set must be present + * in any valid feature mask. + */ +#define HVM_PARAM_VIRIDIAN 9 + +/* Base+Freq viridian feature sets: + * + * - Hypercall MSRs (HV_X64_MSR_GUEST_OS_ID and HV_X64_MSR_HYPERCALL) + * - APIC access MSRs (HV_X64_MSR_EOI, HV_X64_MSR_ICR and HV_X64_MSR_TPR) + * - Virtual Processor index MSR (HV_X64_MSR_VP_INDEX) + * - Timer frequency MSRs (HV_X64_MSR_TSC_FREQUENCY and + * HV_X64_MSR_APIC_FREQUENCY) + */ +#define _HVMPV_base_freq 0 +#define HVMPV_base_freq (1 << _HVMPV_base_freq) + +/* Feature set modifications */ + +/* Disable timer frequency MSRs (HV_X64_MSR_TSC_FREQUENCY and + * HV_X64_MSR_APIC_FREQUENCY). + * This modification restores the viridian feature set to the + * original 'base' set exposed in releases prior to Xen 4.4. + */ +#define _HVMPV_no_freq 1 +#define HVMPV_no_freq (1 << _HVMPV_no_freq) + +/* Enable Partition Time Reference Counter (HV_X64_MSR_TIME_REF_COUNT) */ +#define _HVMPV_time_ref_count 2 +#define HVMPV_time_ref_count (1 << _HVMPV_time_ref_count) + +/* Enable Reference TSC Page (HV_X64_MSR_REFERENCE_TSC) */ +#define _HVMPV_reference_tsc 3 +#define HVMPV_reference_tsc (1 << _HVMPV_reference_tsc) + +/* Use Hypercall for remote TLB flush */ +#define _HVMPV_hcall_remote_tlb_flush 4 +#define HVMPV_hcall_remote_tlb_flush (1 << _HVMPV_hcall_remote_tlb_flush) + +/* Use APIC assist */ +#define _HVMPV_apic_assist 5 +#define HVMPV_apic_assist (1 << _HVMPV_apic_assist) + +/* Enable crash MSRs */ +#define _HVMPV_crash_ctl 6 +#define HVMPV_crash_ctl (1 << _HVMPV_crash_ctl) + +#define HVMPV_feature_mask \ + (HVMPV_base_freq | \ + HVMPV_no_freq | \ + HVMPV_time_ref_count | \ + HVMPV_reference_tsc | \ + HVMPV_hcall_remote_tlb_flush | \ + HVMPV_apic_assist | \ + HVMPV_crash_ctl) + +#endif + +/* + * Set mode for virtual timers (currently x86 only): + * delay_for_missed_ticks (default): + * Do not advance a vcpu's time beyond the correct delivery time for + * interrupts that have been missed due to preemption. Deliver missed + * interrupts when the vcpu is rescheduled and advance the vcpu's virtual + * time stepwise for each one. + * no_delay_for_missed_ticks: + * As above, missed interrupts are delivered, but guest time always tracks + * wallclock (i.e., real) time while doing so. + * no_missed_ticks_pending: + * No missed interrupts are held pending. Instead, to ensure ticks are + * delivered at some non-zero rate, if we detect missed ticks then the + * internal tick alarm is not disabled if the VCPU is preempted during the + * next tick period. + * one_missed_tick_pending: + * Missed interrupts are collapsed together and delivered as one 'late tick'. + * Guest time always tracks wallclock (i.e., real) time. + */ +#define HVM_PARAM_TIMER_MODE 10 +#define HVMPTM_delay_for_missed_ticks 0 +#define HVMPTM_no_delay_for_missed_ticks 1 +#define HVMPTM_no_missed_ticks_pending 2 +#define HVMPTM_one_missed_tick_pending 3 + +/* Boolean: Enable virtual HPET (high-precision event timer)? (x86-only) */ +#define HVM_PARAM_HPET_ENABLED 11 + +/* Identity-map page directory used by Intel EPT when CR0.PG=0. */ +#define HVM_PARAM_IDENT_PT 12 + +/* Device Model domain, defaults to 0. */ +#define HVM_PARAM_DM_DOMAIN 13 + +/* ACPI S state: currently support S0 and S3 on x86. */ +#define HVM_PARAM_ACPI_S_STATE 14 + +/* TSS used on Intel when CR0.PE=0. */ +#define HVM_PARAM_VM86_TSS 15 + +/* Boolean: Enable aligning all periodic vpts to reduce interrupts */ +#define HVM_PARAM_VPT_ALIGN 16 + +/* Console debug shared memory ring and event channel */ +#define HVM_PARAM_CONSOLE_PFN 17 +#define HVM_PARAM_CONSOLE_EVTCHN 18 + +/* + * Select location of ACPI PM1a and TMR control blocks. Currently two locations + * are supported, specified by version 0 or 1 in this parameter: + * - 0: default, use the old addresses + * PM1A_EVT == 0x1f40; PM1A_CNT == 0x1f44; PM_TMR == 0x1f48 + * - 1: use the new default qemu addresses + * PM1A_EVT == 0xb000; PM1A_CNT == 0xb004; PM_TMR == 0xb008 + * You can find these address definitions in + */ +#define HVM_PARAM_ACPI_IOPORTS_LOCATION 19 + +/* Deprecated */ +#define HVM_PARAM_MEMORY_EVENT_CR0 20 +#define HVM_PARAM_MEMORY_EVENT_CR3 21 +#define HVM_PARAM_MEMORY_EVENT_CR4 22 +#define HVM_PARAM_MEMORY_EVENT_INT3 23 +#define HVM_PARAM_MEMORY_EVENT_SINGLE_STEP 25 +#define HVM_PARAM_MEMORY_EVENT_MSR 30 + +/* Boolean: Enable nestedhvm (hvm only) */ +#define HVM_PARAM_NESTEDHVM 24 + +/* Params for the mem event rings */ +#define HVM_PARAM_PAGING_RING_PFN 27 +#define HVM_PARAM_MONITOR_RING_PFN 28 +#define HVM_PARAM_SHARING_RING_PFN 29 + +/* SHUTDOWN_* action in case of a triple fault */ +#define HVM_PARAM_TRIPLE_FAULT_REASON 31 + +#define HVM_PARAM_IOREQ_SERVER_PFN 32 +#define HVM_PARAM_NR_IOREQ_SERVER_PAGES 33 + +/* Location of the VM Generation ID in guest physical address space. */ +#define HVM_PARAM_VM_GENERATION_ID_ADDR 34 + +/* + * Set mode for altp2m: + * disabled: don't activate altp2m (default) + * mixed: allow access to all altp2m ops for both in-guest and external tools + * external: allow access to external privileged tools only + * limited: guest only has limited access (ie. control VMFUNC and #VE) + */ +#define HVM_PARAM_ALTP2M 35 +#define XEN_ALTP2M_disabled 0 +#define XEN_ALTP2M_mixed 1 +#define XEN_ALTP2M_external 2 +#define XEN_ALTP2M_limited 3 + +/* + * Size of the x87 FPU FIP/FDP registers that the hypervisor needs to + * save/restore. This is a workaround for a hardware limitation that + * does not allow the full FIP/FDP and FCS/FDS to be restored. + * + * Valid values are: + * + * 8: save/restore 64-bit FIP/FDP and clear FCS/FDS (default if CPU + * has FPCSDS feature). + * + * 4: save/restore 32-bit FIP/FDP, FCS/FDS, and clear upper 32-bits of + * FIP/FDP. + * + * 0: allow hypervisor to choose based on the value of FIP/FDP + * (default if CPU does not have FPCSDS). + * + * If FPCSDS (bit 13 in CPUID leaf 0x7, subleaf 0x0) is set, the CPU + * never saves FCS/FDS and this parameter should be left at the + * default of 8. + */ +#define HVM_PARAM_X87_FIP_WIDTH 36 + +/* + * TSS (and its size) used on Intel when CR0.PE=0. The address occupies + * the low 32 bits, while the size is in the high 32 ones. + */ +#define HVM_PARAM_VM86_TSS_SIZED 37 + +/* Enable MCA capabilities. */ +#define HVM_PARAM_MCA_CAP 38 +#define XEN_HVM_MCA_CAP_LMCE (xen_mk_ullong(1) << 0) +#define XEN_HVM_MCA_CAP_MASK XEN_HVM_MCA_CAP_LMCE + +#define HVM_NR_PARAMS 39 + +#endif /* __XEN_PUBLIC_HVM_PARAMS_H__ */ diff --git a/include/xen/hvm/start_info.h b/include/xen/hvm/start_info.h new file mode 100644 index 000000000..648415976 --- /dev/null +++ b/include/xen/hvm/start_info.h @@ -0,0 +1,98 @@ +/* + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Copyright (c) 2016, Citrix Systems, Inc. + */ + +#ifndef __XEN_PUBLIC_ARCH_X86_HVM_START_INFO_H__ +#define __XEN_PUBLIC_ARCH_X86_HVM_START_INFO_H__ + +/* + * Start of day structure passed to PVH guests and to HVM guests in %ebx. + * + * NOTE: nothing will be loaded at physical address 0, so a 0 value in any + * of the address fields should be treated as not present. + * + * 0 +----------------+ + * | magic | Contains the magic value XEN_HVM_START_MAGIC_VALUE + * | | ("xEn3" with the 0x80 bit of the "E" set). + * 4 +----------------+ + * | version | Version of this structure. Current version is 0. New + * | | versions are guaranteed to be backwards-compatible. + * 8 +----------------+ + * | flags | SIF_xxx flags. + * 12 +----------------+ + * | nr_modules | Number of modules passed to the kernel. + * 16 +----------------+ + * | modlist_paddr | Physical address of an array of modules + * | | (layout of the structure below). + * 24 +----------------+ + * | cmdline_paddr | Physical address of the command line, + * | | a zero-terminated ASCII string. + * 32 +----------------+ + * | rsdp_paddr | Physical address of the RSDP ACPI data structure. + * 40 +----------------+ + * + * The layout of each entry in the module structure is the following: + * + * 0 +----------------+ + * | paddr | Physical address of the module. + * 8 +----------------+ + * | size | Size of the module in bytes. + * 16 +----------------+ + * | cmdline_paddr | Physical address of the command line, + * | | a zero-terminated ASCII string. + * 24 +----------------+ + * | reserved | + * 32 +----------------+ + * + * The address and sizes are always a 64bit little endian unsigned integer. + * + * NB: Xen on x86 will always try to place all the data below the 4GiB + * boundary. + */ +#define XEN_HVM_START_MAGIC_VALUE 0x336ec578 + +/* + * C representation of the x86/HVM start info layout. + * + * The canonical definition of this layout is above, this is just a way to + * represent the layout described there using C types. + */ +struct hvm_start_info { + uint32_t magic; /* Contains the magic value 0x336ec578 */ + /* ("xEn3" with the 0x80 bit of the "E" set).*/ + uint32_t version; /* Version of this structure. */ + uint32_t flags; /* SIF_xxx flags. */ + uint32_t nr_modules; /* Number of modules passed to the kernel. */ + uint64_t modlist_paddr; /* Physical address of an array of */ + /* hvm_modlist_entry. */ + uint64_t cmdline_paddr; /* Physical address of the command line. */ + uint64_t rsdp_paddr; /* Physical address of the RSDP ACPI data */ + /* structure. */ +}; + +struct hvm_modlist_entry { + uint64_t paddr; /* Physical address of the module. */ + uint64_t size; /* Size of the module in bytes. */ + uint64_t cmdline_paddr; /* Physical address of the command line. */ + uint64_t reserved; +}; + +#endif /* __XEN_PUBLIC_ARCH_X86_HVM_START_INFO_H__ */ diff --git a/include/xen/memory.h b/include/xen/memory.h new file mode 100644 index 000000000..29386df98 --- /dev/null +++ b/include/xen/memory.h @@ -0,0 +1,665 @@ +/****************************************************************************** + * memory.h + * + * Memory reservation and information. + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Copyright (c) 2005, Keir Fraser + */ + +#ifndef __XEN_PUBLIC_MEMORY_H__ +#define __XEN_PUBLIC_MEMORY_H__ + +#include "xen.h" +#include "physdev.h" + +/* + * Increase or decrease the specified domain's memory reservation. Returns the + * number of extents successfully allocated or freed. + * arg == addr of struct xen_memory_reservation. + */ +#define XENMEM_increase_reservation 0 +#define XENMEM_decrease_reservation 1 +#define XENMEM_populate_physmap 6 + +#if __XEN_INTERFACE_VERSION__ >= 0x00030209 +/* + * Maximum # bits addressable by the user of the allocated region (e.g., I/O + * devices often have a 32-bit limitation even in 64-bit systems). If zero + * then the user has no addressing restriction. This field is not used by + * XENMEM_decrease_reservation. + */ +#define XENMEMF_address_bits(x) (x) +#define XENMEMF_get_address_bits(x) ((x) & 0xffu) +/* NUMA node to allocate from. */ +#define XENMEMF_node(x) (((x) + 1) << 8) +#define XENMEMF_get_node(x) ((((x) >> 8) - 1) & 0xffu) +/* Flag to populate physmap with populate-on-demand entries */ +#define XENMEMF_populate_on_demand (1<<16) +/* Flag to request allocation only from the node specified */ +#define XENMEMF_exact_node_request (1<<17) +#define XENMEMF_exact_node(n) (XENMEMF_node(n) | XENMEMF_exact_node_request) +/* Flag to indicate the node specified is virtual node */ +#define XENMEMF_vnode (1<<18) +#endif + +struct xen_memory_reservation { + + /* + * XENMEM_increase_reservation: + * OUT: MFN (*not* GMFN) bases of extents that were allocated + * XENMEM_decrease_reservation: + * IN: GMFN bases of extents to free + * XENMEM_populate_physmap: + * IN: GPFN bases of extents to populate with memory + * OUT: GMFN bases of extents that were allocated + * (NB. This command also updates the mach_to_phys translation table) + * XENMEM_claim_pages: + * IN: must be zero + */ + XEN_GUEST_HANDLE(xen_pfn_t) extent_start; + + /* Number of extents, and size/alignment of each (2^extent_order pages). */ + xen_ulong_t nr_extents; + unsigned int extent_order; + +#if __XEN_INTERFACE_VERSION__ >= 0x00030209 + /* XENMEMF flags. */ + unsigned int mem_flags; +#else + unsigned int address_bits; +#endif + + /* + * Domain whose reservation is being changed. + * Unprivileged domains can specify only DOMID_SELF. + */ + domid_t domid; +}; +typedef struct xen_memory_reservation xen_memory_reservation_t; +DEFINE_XEN_GUEST_HANDLE(xen_memory_reservation_t); + +/* + * An atomic exchange of memory pages. If return code is zero then + * @out.extent_list provides GMFNs of the newly-allocated memory. + * Returns zero on complete success, otherwise a negative error code. + * On complete success then always @nr_exchanged == @in.nr_extents. + * On partial success @nr_exchanged indicates how much work was done. + * + * Note that only PV guests can use this operation. + */ +#define XENMEM_exchange 11 +struct xen_memory_exchange { + /* + * [IN] Details of memory extents to be exchanged (GMFN bases). + * Note that @in.address_bits is ignored and unused. + */ + struct xen_memory_reservation in; + + /* + * [IN/OUT] Details of new memory extents. + * We require that: + * 1. @in.domid == @out.domid + * 2. @in.nr_extents << @in.extent_order == + * @out.nr_extents << @out.extent_order + * 3. @in.extent_start and @out.extent_start lists must not overlap + * 4. @out.extent_start lists GPFN bases to be populated + * 5. @out.extent_start is overwritten with allocated GMFN bases + */ + struct xen_memory_reservation out; + + /* + * [OUT] Number of input extents that were successfully exchanged: + * 1. The first @nr_exchanged input extents were successfully + * deallocated. + * 2. The corresponding first entries in the output extent list correctly + * indicate the GMFNs that were successfully exchanged. + * 3. All other input and output extents are untouched. + * 4. If not all input exents are exchanged then the return code of this + * command will be non-zero. + * 5. THIS FIELD MUST BE INITIALISED TO ZERO BY THE CALLER! + */ + xen_ulong_t nr_exchanged; +}; +typedef struct xen_memory_exchange xen_memory_exchange_t; +DEFINE_XEN_GUEST_HANDLE(xen_memory_exchange_t); + +/* + * Returns the maximum machine frame number of mapped RAM in this system. + * This command always succeeds (it never returns an error code). + * arg == NULL. + */ +#define XENMEM_maximum_ram_page 2 + +/* + * Returns the current or maximum memory reservation, in pages, of the + * specified domain (may be DOMID_SELF). Returns -ve errcode on failure. + * arg == addr of domid_t. + */ +#define XENMEM_current_reservation 3 +#define XENMEM_maximum_reservation 4 + +/* + * Returns the maximum GPFN in use by the guest, or -ve errcode on failure. + */ +#define XENMEM_maximum_gpfn 14 + +/* + * Returns a list of MFN bases of 2MB extents comprising the machine_to_phys + * mapping table. Architectures which do not have a m2p table do not implement + * this command. + * arg == addr of xen_machphys_mfn_list_t. + */ +#define XENMEM_machphys_mfn_list 5 +struct xen_machphys_mfn_list { + /* + * Size of the 'extent_start' array. Fewer entries will be filled if the + * machphys table is smaller than max_extents * 2MB. + */ + unsigned int max_extents; + + /* + * Pointer to buffer to fill with list of extent starts. If there are + * any large discontiguities in the machine address space, 2MB gaps in + * the machphys table will be represented by an MFN base of zero. + */ + XEN_GUEST_HANDLE(xen_pfn_t) extent_start; + + /* + * Number of extents written to the above array. This will be smaller + * than 'max_extents' if the machphys table is smaller than max_e * 2MB. + */ + unsigned int nr_extents; +}; +typedef struct xen_machphys_mfn_list xen_machphys_mfn_list_t; +DEFINE_XEN_GUEST_HANDLE(xen_machphys_mfn_list_t); + +/* + * For a compat caller, this is identical to XENMEM_machphys_mfn_list. + * + * For a non compat caller, this functions similarly to + * XENMEM_machphys_mfn_list, but returns the mfns making up the compatibility + * m2p table. + */ +#define XENMEM_machphys_compat_mfn_list 25 + +/* + * Returns the location in virtual address space of the machine_to_phys + * mapping table. Architectures which do not have a m2p table, or which do not + * map it by default into guest address space, do not implement this command. + * arg == addr of xen_machphys_mapping_t. + */ +#define XENMEM_machphys_mapping 12 +struct xen_machphys_mapping { + xen_ulong_t v_start, v_end; /* Start and end virtual addresses. */ + xen_ulong_t max_mfn; /* Maximum MFN that can be looked up. */ +}; +typedef struct xen_machphys_mapping xen_machphys_mapping_t; +DEFINE_XEN_GUEST_HANDLE(xen_machphys_mapping_t); + +/* Source mapping space. */ +/* ` enum phys_map_space { */ +#define XENMAPSPACE_shared_info 0 /* shared info page */ +#define XENMAPSPACE_grant_table 1 /* grant table page */ +#define XENMAPSPACE_gmfn 2 /* GMFN */ +#define XENMAPSPACE_gmfn_range 3 /* GMFN range, XENMEM_add_to_physmap only. */ +#define XENMAPSPACE_gmfn_foreign 4 /* GMFN from another dom, + * XENMEM_add_to_physmap_batch only. */ +#define XENMAPSPACE_dev_mmio 5 /* device mmio region + ARM only; the region is mapped in + Stage-2 using the Normal Memory + Inner/Outer Write-Back Cacheable + memory attribute. */ +/* ` } */ + +/* + * Sets the GPFN at which a particular page appears in the specified guest's + * pseudophysical address space. + * arg == addr of xen_add_to_physmap_t. + */ +#define XENMEM_add_to_physmap 7 +struct xen_add_to_physmap { + /* Which domain to change the mapping for. */ + domid_t domid; + + /* Number of pages to go through for gmfn_range */ + uint16_t size; + + unsigned int space; /* => enum phys_map_space */ + +#define XENMAPIDX_grant_table_status 0x80000000 + + /* Index into space being mapped. */ + xen_ulong_t idx; + + /* GPFN in domid where the source mapping page should appear. */ + xen_pfn_t gpfn; +}; +typedef struct xen_add_to_physmap xen_add_to_physmap_t; +DEFINE_XEN_GUEST_HANDLE(xen_add_to_physmap_t); + +/* A batched version of add_to_physmap. */ +#define XENMEM_add_to_physmap_batch 23 +struct xen_add_to_physmap_batch { + /* IN */ + /* Which domain to change the mapping for. */ + domid_t domid; + uint16_t space; /* => enum phys_map_space */ + + /* Number of pages to go through */ + uint16_t size; + +#if __XEN_INTERFACE_VERSION__ < 0x00040700 + domid_t foreign_domid; /* IFF gmfn_foreign. Should be 0 for other spaces. */ +#else + union xen_add_to_physmap_batch_extra { + domid_t foreign_domid; /* gmfn_foreign */ + uint16_t res0; /* All the other spaces. Should be 0 */ + } u; +#endif + + /* Indexes into space being mapped. */ + XEN_GUEST_HANDLE(xen_ulong_t) idxs; + + /* GPFN in domid where the source mapping page should appear. */ + XEN_GUEST_HANDLE(xen_pfn_t) gpfns; + + /* OUT */ + + /* Per index error code. */ + XEN_GUEST_HANDLE(int) errs; +}; +typedef struct xen_add_to_physmap_batch xen_add_to_physmap_batch_t; +DEFINE_XEN_GUEST_HANDLE(xen_add_to_physmap_batch_t); + +#if __XEN_INTERFACE_VERSION__ < 0x00040400 +#define XENMEM_add_to_physmap_range XENMEM_add_to_physmap_batch +#define xen_add_to_physmap_range xen_add_to_physmap_batch +typedef struct xen_add_to_physmap_batch xen_add_to_physmap_range_t; +DEFINE_XEN_GUEST_HANDLE(xen_add_to_physmap_range_t); +#endif + +/* + * Unmaps the page appearing at a particular GPFN from the specified guest's + * pseudophysical address space. + * arg == addr of xen_remove_from_physmap_t. + */ +#define XENMEM_remove_from_physmap 15 +struct xen_remove_from_physmap { + /* Which domain to change the mapping for. */ + domid_t domid; + + /* GPFN of the current mapping of the page. */ + xen_pfn_t gpfn; +}; +typedef struct xen_remove_from_physmap xen_remove_from_physmap_t; +DEFINE_XEN_GUEST_HANDLE(xen_remove_from_physmap_t); + +/*** REMOVED ***/ +/*#define XENMEM_translate_gpfn_list 8*/ + +/* + * Returns the pseudo-physical memory map as it was when the domain + * was started (specified by XENMEM_set_memory_map). + * arg == addr of xen_memory_map_t. + */ +#define XENMEM_memory_map 9 +struct xen_memory_map { + /* + * On call the number of entries which can be stored in buffer. On + * return the number of entries which have been stored in + * buffer. + */ + unsigned int nr_entries; + + /* + * Entries in the buffer are in the same format as returned by the + * BIOS INT 0x15 EAX=0xE820 call. + */ + XEN_GUEST_HANDLE(void) buffer; +}; +typedef struct xen_memory_map xen_memory_map_t; +DEFINE_XEN_GUEST_HANDLE(xen_memory_map_t); + +/* + * Returns the real physical memory map. Passes the same structure as + * XENMEM_memory_map. + * Specifying buffer as NULL will return the number of entries required + * to store the complete memory map. + * arg == addr of xen_memory_map_t. + */ +#define XENMEM_machine_memory_map 10 + +/* + * Set the pseudo-physical memory map of a domain, as returned by + * XENMEM_memory_map. + * arg == addr of xen_foreign_memory_map_t. + */ +#define XENMEM_set_memory_map 13 +struct xen_foreign_memory_map { + domid_t domid; + struct xen_memory_map map; +}; +typedef struct xen_foreign_memory_map xen_foreign_memory_map_t; +DEFINE_XEN_GUEST_HANDLE(xen_foreign_memory_map_t); + +#define XENMEM_set_pod_target 16 +#define XENMEM_get_pod_target 17 +struct xen_pod_target { + /* IN */ + uint64_t target_pages; + /* OUT */ + uint64_t tot_pages; + uint64_t pod_cache_pages; + uint64_t pod_entries; + /* IN */ + domid_t domid; +}; +typedef struct xen_pod_target xen_pod_target_t; + +#if defined(__XEN__) || defined(__XEN_TOOLS__) + +#ifndef uint64_aligned_t +#define uint64_aligned_t uint64_t +#endif + +/* + * Get the number of MFNs saved through memory sharing. + * The call never fails. + */ +#define XENMEM_get_sharing_freed_pages 18 +#define XENMEM_get_sharing_shared_pages 19 + +#define XENMEM_paging_op 20 +#define XENMEM_paging_op_nominate 0 +#define XENMEM_paging_op_evict 1 +#define XENMEM_paging_op_prep 2 + +struct xen_mem_paging_op { + uint8_t op; /* XENMEM_paging_op_* */ + domid_t domain; + + /* PAGING_PREP IN: buffer to immediately fill page in */ + uint64_aligned_t buffer; + /* Other OPs */ + uint64_aligned_t gfn; /* IN: gfn of page being operated on */ +}; +typedef struct xen_mem_paging_op xen_mem_paging_op_t; +DEFINE_XEN_GUEST_HANDLE(xen_mem_paging_op_t); + +#define XENMEM_access_op 21 +#define XENMEM_access_op_set_access 0 +#define XENMEM_access_op_get_access 1 +/* + * XENMEM_access_op_enable_emulate and XENMEM_access_op_disable_emulate are + * currently unused, but since they have been in use please do not reuse them. + * + * #define XENMEM_access_op_enable_emulate 2 + * #define XENMEM_access_op_disable_emulate 3 + */ +#define XENMEM_access_op_set_access_multi 4 + +typedef enum { + XENMEM_access_n, + XENMEM_access_r, + XENMEM_access_w, + XENMEM_access_rw, + XENMEM_access_x, + XENMEM_access_rx, + XENMEM_access_wx, + XENMEM_access_rwx, + /* + * Page starts off as r-x, but automatically + * change to r-w on a write + */ + XENMEM_access_rx2rw, + /* + * Log access: starts off as n, automatically + * goes to rwx, generating an event without + * pausing the vcpu + */ + XENMEM_access_n2rwx, + /* Take the domain default */ + XENMEM_access_default +} xenmem_access_t; + +struct xen_mem_access_op { + /* XENMEM_access_op_* */ + uint8_t op; + /* xenmem_access_t */ + uint8_t access; + domid_t domid; + /* + * Number of pages for set op (or size of pfn_list for + * XENMEM_access_op_set_access_multi) + * Ignored on setting default access and other ops + */ + uint32_t nr; + /* + * First pfn for set op + * pfn for get op + * ~0ull is used to set and get the default access for pages + */ + uint64_aligned_t pfn; + /* + * List of pfns to set access for + * Used only with XENMEM_access_op_set_access_multi + */ + XEN_GUEST_HANDLE(const_uint64) pfn_list; + /* + * Corresponding list of access settings for pfn_list + * Used only with XENMEM_access_op_set_access_multi + */ + XEN_GUEST_HANDLE(const_uint8) access_list; +}; +typedef struct xen_mem_access_op xen_mem_access_op_t; +DEFINE_XEN_GUEST_HANDLE(xen_mem_access_op_t); + +#define XENMEM_sharing_op 22 +#define XENMEM_sharing_op_nominate_gfn 0 +#define XENMEM_sharing_op_nominate_gref 1 +#define XENMEM_sharing_op_share 2 +#define XENMEM_sharing_op_debug_gfn 3 +#define XENMEM_sharing_op_debug_mfn 4 +#define XENMEM_sharing_op_debug_gref 5 +#define XENMEM_sharing_op_add_physmap 6 +#define XENMEM_sharing_op_audit 7 +#define XENMEM_sharing_op_range_share 8 + +#define XENMEM_SHARING_OP_S_HANDLE_INVALID (-10) +#define XENMEM_SHARING_OP_C_HANDLE_INVALID (-9) + +/* The following allows sharing of grant refs. This is useful + * for sharing utilities sitting as "filters" in IO backends + * (e.g. memshr + blktap(2)). The IO backend is only exposed + * to grant references, and this allows sharing of the grefs */ +#define XENMEM_SHARING_OP_FIELD_IS_GREF_FLAG (xen_mk_ullong(1) << 62) + +#define XENMEM_SHARING_OP_FIELD_MAKE_GREF(field, val) \ + (field) = (XENMEM_SHARING_OP_FIELD_IS_GREF_FLAG | val) +#define XENMEM_SHARING_OP_FIELD_IS_GREF(field) \ + ((field) & XENMEM_SHARING_OP_FIELD_IS_GREF_FLAG) +#define XENMEM_SHARING_OP_FIELD_GET_GREF(field) \ + ((field) & (~XENMEM_SHARING_OP_FIELD_IS_GREF_FLAG)) + +struct xen_mem_sharing_op { + uint8_t op; /* XENMEM_sharing_op_* */ + domid_t domain; + + union { + struct mem_sharing_op_nominate { /* OP_NOMINATE_xxx */ + union { + uint64_aligned_t gfn; /* IN: gfn to nominate */ + uint32_t grant_ref; /* IN: grant ref to nominate */ + } u; + uint64_aligned_t handle; /* OUT: the handle */ + } nominate; + struct mem_sharing_op_share { /* OP_SHARE/ADD_PHYSMAP */ + uint64_aligned_t source_gfn; /* IN: the gfn of the source page */ + uint64_aligned_t source_handle; /* IN: handle to the source page */ + uint64_aligned_t client_gfn; /* IN: the client gfn */ + uint64_aligned_t client_handle; /* IN: handle to the client page */ + domid_t client_domain; /* IN: the client domain id */ + } share; + struct mem_sharing_op_range { /* OP_RANGE_SHARE */ + uint64_aligned_t first_gfn; /* IN: the first gfn */ + uint64_aligned_t last_gfn; /* IN: the last gfn */ + uint64_aligned_t opaque; /* Must be set to 0 */ + domid_t client_domain; /* IN: the client domain id */ + uint16_t _pad[3]; /* Must be set to 0 */ + } range; + struct mem_sharing_op_debug { /* OP_DEBUG_xxx */ + union { + uint64_aligned_t gfn; /* IN: gfn to debug */ + uint64_aligned_t mfn; /* IN: mfn to debug */ + uint32_t gref; /* IN: gref to debug */ + } u; + } debug; + } u; +}; +typedef struct xen_mem_sharing_op xen_mem_sharing_op_t; +DEFINE_XEN_GUEST_HANDLE(xen_mem_sharing_op_t); + +/* + * Attempt to stake a claim for a domain on a quantity of pages + * of system RAM, but _not_ assign specific pageframes. Only + * arithmetic is performed so the hypercall is very fast and need + * not be preemptible, thus sidestepping time-of-check-time-of-use + * races for memory allocation. Returns 0 if the hypervisor page + * allocator has atomically and successfully claimed the requested + * number of pages, else non-zero. + * + * Any domain may have only one active claim. When sufficient memory + * has been allocated to resolve the claim, the claim silently expires. + * Claiming zero pages effectively resets any outstanding claim and + * is always successful. + * + * Note that a valid claim may be staked even after memory has been + * allocated for a domain. In this case, the claim is not incremental, + * i.e. if the domain's tot_pages is 3, and a claim is staked for 10, + * only 7 additional pages are claimed. + * + * Caller must be privileged or the hypercall fails. + */ +#define XENMEM_claim_pages 24 + +/* + * XENMEM_claim_pages flags - the are no flags at this time. + * The zero value is appropriate. + */ + +/* + * With some legacy devices, certain guest-physical addresses cannot safely + * be used for other purposes, e.g. to map guest RAM. This hypercall + * enumerates those regions so the toolstack can avoid using them. + */ +#define XENMEM_reserved_device_memory_map 27 +struct xen_reserved_device_memory { + xen_pfn_t start_pfn; + xen_ulong_t nr_pages; +}; +typedef struct xen_reserved_device_memory xen_reserved_device_memory_t; +DEFINE_XEN_GUEST_HANDLE(xen_reserved_device_memory_t); + +struct xen_reserved_device_memory_map { +#define XENMEM_RDM_ALL 1 /* Request all regions (ignore dev union). */ + /* IN */ + uint32_t flags; + /* + * IN/OUT + * + * Gets set to the required number of entries when too low, + * signaled by error code -ERANGE. + */ + unsigned int nr_entries; + /* OUT */ + XEN_GUEST_HANDLE(xen_reserved_device_memory_t) buffer; + /* IN */ + union { + struct physdev_pci_device pci; + } dev; +}; +typedef struct xen_reserved_device_memory_map xen_reserved_device_memory_map_t; +DEFINE_XEN_GUEST_HANDLE(xen_reserved_device_memory_map_t); + +#endif /* defined(__XEN__) || defined(__XEN_TOOLS__) */ + +/* + * XENMEM_get_vnumainfo used by guest to get + * vNUMA topology from hypervisor. + */ +#define XENMEM_get_vnumainfo 26 + +/* vNUMA node memory ranges */ +struct xen_vmemrange { + uint64_t start, end; + unsigned int flags; + unsigned int nid; +}; +typedef struct xen_vmemrange xen_vmemrange_t; +DEFINE_XEN_GUEST_HANDLE(xen_vmemrange_t); + +/* + * vNUMA topology specifies vNUMA node number, distance table, + * memory ranges and vcpu mapping provided for guests. + * XENMEM_get_vnumainfo hypercall expects to see from guest + * nr_vnodes, nr_vmemranges and nr_vcpus to indicate available memory. + * After filling guests structures, nr_vnodes, nr_vmemranges and nr_vcpus + * copied back to guest. Domain returns expected values of nr_vnodes, + * nr_vmemranges and nr_vcpus to guest if the values where incorrect. + */ +struct xen_vnuma_topology_info { + /* IN */ + domid_t domid; + uint16_t pad; + /* IN/OUT */ + unsigned int nr_vnodes; + unsigned int nr_vcpus; + unsigned int nr_vmemranges; + /* OUT */ + union { + XEN_GUEST_HANDLE(uint) h; + uint64_t pad; + } vdistance; + union { + XEN_GUEST_HANDLE(uint) h; + uint64_t pad; + } vcpu_to_vnode; + union { + XEN_GUEST_HANDLE(xen_vmemrange_t) h; + uint64_t pad; + } vmemrange; +}; +typedef struct xen_vnuma_topology_info xen_vnuma_topology_info_t; +DEFINE_XEN_GUEST_HANDLE(xen_vnuma_topology_info_t); + +/* Next available subop number is 28 */ + +#endif /* __XEN_PUBLIC_MEMORY_H__ */ + +/* + * Local variables: + * mode: C + * c-file-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */ diff --git a/include/xen/physdev.h b/include/xen/physdev.h new file mode 100644 index 000000000..0e5463562 --- /dev/null +++ b/include/xen/physdev.h @@ -0,0 +1,387 @@ +/* + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Copyright (c) 2006, Keir Fraser + */ + +#ifndef __XEN_PUBLIC_PHYSDEV_H__ +#define __XEN_PUBLIC_PHYSDEV_H__ + +#include "xen.h" + +/* + * Prototype for this hypercall is: + * int physdev_op(int cmd, void *args) + * @cmd == PHYSDEVOP_??? (physdev operation). + * @args == Operation-specific extra arguments (NULL if none). + */ + +/* + * Notify end-of-interrupt (EOI) for the specified IRQ. + * @arg == pointer to physdev_eoi structure. + */ +#define PHYSDEVOP_eoi 12 +struct physdev_eoi { + /* IN */ + uint32_t irq; +}; +typedef struct physdev_eoi physdev_eoi_t; +DEFINE_XEN_GUEST_HANDLE(physdev_eoi_t); + +/* + * Register a shared page for the hypervisor to indicate whether the guest + * must issue PHYSDEVOP_eoi. The semantics of PHYSDEVOP_eoi change slightly + * once the guest used this function in that the associated event channel + * will automatically get unmasked. The page registered is used as a bit + * array indexed by Xen's PIRQ value. + */ +#define PHYSDEVOP_pirq_eoi_gmfn_v1 17 +/* + * Register a shared page for the hypervisor to indicate whether the + * guest must issue PHYSDEVOP_eoi. This hypercall is very similar to + * PHYSDEVOP_pirq_eoi_gmfn_v1 but it doesn't change the semantics of + * PHYSDEVOP_eoi. The page registered is used as a bit array indexed by + * Xen's PIRQ value. + */ +#define PHYSDEVOP_pirq_eoi_gmfn_v2 28 +struct physdev_pirq_eoi_gmfn { + /* IN */ + xen_pfn_t gmfn; +}; +typedef struct physdev_pirq_eoi_gmfn physdev_pirq_eoi_gmfn_t; +DEFINE_XEN_GUEST_HANDLE(physdev_pirq_eoi_gmfn_t); + +/* + * Query the status of an IRQ line. + * @arg == pointer to physdev_irq_status_query structure. + */ +#define PHYSDEVOP_irq_status_query 5 +struct physdev_irq_status_query { + /* IN */ + uint32_t irq; + /* OUT */ + uint32_t flags; /* XENIRQSTAT_* */ +}; +typedef struct physdev_irq_status_query physdev_irq_status_query_t; +DEFINE_XEN_GUEST_HANDLE(physdev_irq_status_query_t); + +/* Need to call PHYSDEVOP_eoi when the IRQ has been serviced? */ +#define _XENIRQSTAT_needs_eoi (0) +#define XENIRQSTAT_needs_eoi (1U<<_XENIRQSTAT_needs_eoi) + +/* IRQ shared by multiple guests? */ +#define _XENIRQSTAT_shared (1) +#define XENIRQSTAT_shared (1U<<_XENIRQSTAT_shared) + +/* + * Set the current VCPU's I/O privilege level. + * @arg == pointer to physdev_set_iopl structure. + */ +#define PHYSDEVOP_set_iopl 6 +struct physdev_set_iopl { + /* IN */ + uint32_t iopl; +}; +typedef struct physdev_set_iopl physdev_set_iopl_t; +DEFINE_XEN_GUEST_HANDLE(physdev_set_iopl_t); + +/* + * Set the current VCPU's I/O-port permissions bitmap. + * @arg == pointer to physdev_set_iobitmap structure. + */ +#define PHYSDEVOP_set_iobitmap 7 +struct physdev_set_iobitmap { + /* IN */ +#if __XEN_INTERFACE_VERSION__ >= 0x00030205 + XEN_GUEST_HANDLE(uint8) bitmap; +#else + uint8_t *bitmap; +#endif + uint32_t nr_ports; +}; +typedef struct physdev_set_iobitmap physdev_set_iobitmap_t; +DEFINE_XEN_GUEST_HANDLE(physdev_set_iobitmap_t); + +/* + * Read or write an IO-APIC register. + * @arg == pointer to physdev_apic structure. + */ +#define PHYSDEVOP_apic_read 8 +#define PHYSDEVOP_apic_write 9 +struct physdev_apic { + /* IN */ + unsigned long apic_physbase; + uint32_t reg; + /* IN or OUT */ + uint32_t value; +}; +typedef struct physdev_apic physdev_apic_t; +DEFINE_XEN_GUEST_HANDLE(physdev_apic_t); + +/* + * Allocate or free a physical upcall vector for the specified IRQ line. + * @arg == pointer to physdev_irq structure. + */ +#define PHYSDEVOP_alloc_irq_vector 10 +#define PHYSDEVOP_free_irq_vector 11 +struct physdev_irq { + /* IN */ + uint32_t irq; + /* IN or OUT */ + uint32_t vector; +}; +typedef struct physdev_irq physdev_irq_t; +DEFINE_XEN_GUEST_HANDLE(physdev_irq_t); + +#define MAP_PIRQ_TYPE_MSI 0x0 +#define MAP_PIRQ_TYPE_GSI 0x1 +#define MAP_PIRQ_TYPE_UNKNOWN 0x2 +#define MAP_PIRQ_TYPE_MSI_SEG 0x3 +#define MAP_PIRQ_TYPE_MULTI_MSI 0x4 + +#define PHYSDEVOP_map_pirq 13 +struct physdev_map_pirq { + domid_t domid; + /* IN */ + int type; + /* IN (ignored for ..._MULTI_MSI) */ + int index; + /* IN or OUT */ + int pirq; + /* IN - high 16 bits hold segment for ..._MSI_SEG and ..._MULTI_MSI */ + int bus; + /* IN */ + int devfn; + /* IN (also OUT for ..._MULTI_MSI) */ + int entry_nr; + /* IN */ + uint64_t table_base; +}; +typedef struct physdev_map_pirq physdev_map_pirq_t; +DEFINE_XEN_GUEST_HANDLE(physdev_map_pirq_t); + +#define PHYSDEVOP_unmap_pirq 14 +struct physdev_unmap_pirq { + domid_t domid; + /* IN */ + int pirq; +}; + +typedef struct physdev_unmap_pirq physdev_unmap_pirq_t; +DEFINE_XEN_GUEST_HANDLE(physdev_unmap_pirq_t); + +#define PHYSDEVOP_manage_pci_add 15 +#define PHYSDEVOP_manage_pci_remove 16 +struct physdev_manage_pci { + /* IN */ + uint8_t bus; + uint8_t devfn; +}; + +typedef struct physdev_manage_pci physdev_manage_pci_t; +DEFINE_XEN_GUEST_HANDLE(physdev_manage_pci_t); + +#define PHYSDEVOP_restore_msi 19 +struct physdev_restore_msi { + /* IN */ + uint8_t bus; + uint8_t devfn; +}; +typedef struct physdev_restore_msi physdev_restore_msi_t; +DEFINE_XEN_GUEST_HANDLE(physdev_restore_msi_t); + +#define PHYSDEVOP_manage_pci_add_ext 20 +struct physdev_manage_pci_ext { + /* IN */ + uint8_t bus; + uint8_t devfn; + unsigned is_extfn; + unsigned is_virtfn; + struct { + uint8_t bus; + uint8_t devfn; + } physfn; +}; + +typedef struct physdev_manage_pci_ext physdev_manage_pci_ext_t; +DEFINE_XEN_GUEST_HANDLE(physdev_manage_pci_ext_t); + +/* + * Argument to physdev_op_compat() hypercall. Superceded by new physdev_op() + * hypercall since 0x00030202. + */ +struct physdev_op { + uint32_t cmd; + union { + struct physdev_irq_status_query irq_status_query; + struct physdev_set_iopl set_iopl; + struct physdev_set_iobitmap set_iobitmap; + struct physdev_apic apic_op; + struct physdev_irq irq_op; + } u; +}; +typedef struct physdev_op physdev_op_t; +DEFINE_XEN_GUEST_HANDLE(physdev_op_t); + +#define PHYSDEVOP_setup_gsi 21 +struct physdev_setup_gsi { + int gsi; + /* IN */ + uint8_t triggering; + /* IN */ + uint8_t polarity; + /* IN */ +}; + +typedef struct physdev_setup_gsi physdev_setup_gsi_t; +DEFINE_XEN_GUEST_HANDLE(physdev_setup_gsi_t); + +/* leave PHYSDEVOP 22 free */ + +/* type is MAP_PIRQ_TYPE_GSI or MAP_PIRQ_TYPE_MSI + * the hypercall returns a free pirq */ +#define PHYSDEVOP_get_free_pirq 23 +struct physdev_get_free_pirq { + /* IN */ + int type; + /* OUT */ + uint32_t pirq; +}; + +typedef struct physdev_get_free_pirq physdev_get_free_pirq_t; +DEFINE_XEN_GUEST_HANDLE(physdev_get_free_pirq_t); + +#define XEN_PCI_MMCFG_RESERVED 0x1 + +#define PHYSDEVOP_pci_mmcfg_reserved 24 +struct physdev_pci_mmcfg_reserved { + uint64_t address; + uint16_t segment; + uint8_t start_bus; + uint8_t end_bus; + uint32_t flags; +}; +typedef struct physdev_pci_mmcfg_reserved physdev_pci_mmcfg_reserved_t; +DEFINE_XEN_GUEST_HANDLE(physdev_pci_mmcfg_reserved_t); + +#define XEN_PCI_DEV_EXTFN 0x1 +#define XEN_PCI_DEV_VIRTFN 0x2 +#define XEN_PCI_DEV_PXM 0x4 + +#define PHYSDEVOP_pci_device_add 25 +struct physdev_pci_device_add { + /* IN */ + uint16_t seg; + uint8_t bus; + uint8_t devfn; + uint32_t flags; + struct { + uint8_t bus; + uint8_t devfn; + } physfn; + /* + * Optional parameters array. + * First element ([0]) is PXM domain associated with the device (if + * XEN_PCI_DEV_PXM is set) + */ +#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + uint32_t optarr[]; +#elif defined(__GNUC__) + uint32_t optarr[0]; +#endif +}; +typedef struct physdev_pci_device_add physdev_pci_device_add_t; +DEFINE_XEN_GUEST_HANDLE(physdev_pci_device_add_t); + +#define PHYSDEVOP_pci_device_remove 26 +#define PHYSDEVOP_restore_msi_ext 27 +/* + * Dom0 should use these two to announce MMIO resources assigned to + * MSI-X capable devices won't (prepare) or may (release) change. + */ +#define PHYSDEVOP_prepare_msix 30 +#define PHYSDEVOP_release_msix 31 +struct physdev_pci_device { + /* IN */ + uint16_t seg; + uint8_t bus; + uint8_t devfn; +}; +typedef struct physdev_pci_device physdev_pci_device_t; +DEFINE_XEN_GUEST_HANDLE(physdev_pci_device_t); + +#define PHYSDEVOP_DBGP_RESET_PREPARE 1 +#define PHYSDEVOP_DBGP_RESET_DONE 2 + +#define PHYSDEVOP_DBGP_BUS_UNKNOWN 0 +#define PHYSDEVOP_DBGP_BUS_PCI 1 + +#define PHYSDEVOP_dbgp_op 29 +struct physdev_dbgp_op { + /* IN */ + uint8_t op; + uint8_t bus; + union { + struct physdev_pci_device pci; + } u; +}; +typedef struct physdev_dbgp_op physdev_dbgp_op_t; +DEFINE_XEN_GUEST_HANDLE(physdev_dbgp_op_t); + +/* + * Notify that some PIRQ-bound event channels have been unmasked. + * ** This command is obsolete since interface version 0x00030202 and is ** + * ** unsupported by newer versions of Xen. ** + */ +#define PHYSDEVOP_IRQ_UNMASK_NOTIFY 4 + +#if __XEN_INTERFACE_VERSION__ < 0x00040600 +/* + * These all-capitals physdev operation names are superceded by the new names + * (defined above) since interface version 0x00030202. The guard above was + * added post-4.5 only though and hence shouldn't check for 0x00030202. + */ +#define PHYSDEVOP_IRQ_STATUS_QUERY PHYSDEVOP_irq_status_query +#define PHYSDEVOP_SET_IOPL PHYSDEVOP_set_iopl +#define PHYSDEVOP_SET_IOBITMAP PHYSDEVOP_set_iobitmap +#define PHYSDEVOP_APIC_READ PHYSDEVOP_apic_read +#define PHYSDEVOP_APIC_WRITE PHYSDEVOP_apic_write +#define PHYSDEVOP_ASSIGN_VECTOR PHYSDEVOP_alloc_irq_vector +#define PHYSDEVOP_FREE_VECTOR PHYSDEVOP_free_irq_vector +#define PHYSDEVOP_IRQ_NEEDS_UNMASK_NOTIFY XENIRQSTAT_needs_eoi +#define PHYSDEVOP_IRQ_SHARED XENIRQSTAT_shared +#endif + +#if __XEN_INTERFACE_VERSION__ < 0x00040200 +#define PHYSDEVOP_pirq_eoi_gmfn PHYSDEVOP_pirq_eoi_gmfn_v1 +#else +#define PHYSDEVOP_pirq_eoi_gmfn PHYSDEVOP_pirq_eoi_gmfn_v2 +#endif + +#endif /* __XEN_PUBLIC_PHYSDEV_H__ */ + +/* + * Local variables: + * mode: C + * c-file-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */ diff --git a/include/xen/trace.h b/include/xen/trace.h new file mode 100644 index 000000000..3746bff26 --- /dev/null +++ b/include/xen/trace.h @@ -0,0 +1,339 @@ +/****************************************************************************** + * include/public/trace.h + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to + * deal in the Software without restriction, including without limitation the + * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or + * sell copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING + * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + * + * Mark Williamson, (C) 2004 Intel Research Cambridge + * Copyright (C) 2005 Bin Ren + */ + +#ifndef __XEN_PUBLIC_TRACE_H__ +#define __XEN_PUBLIC_TRACE_H__ + +#define TRACE_EXTRA_MAX 7 +#define TRACE_EXTRA_SHIFT 28 + +/* Trace classes */ +#define TRC_CLS_SHIFT 16 +#define TRC_GEN 0x0001f000 /* General trace */ +#define TRC_SCHED 0x0002f000 /* Xen Scheduler trace */ +#define TRC_DOM0OP 0x0004f000 /* Xen DOM0 operation trace */ +#define TRC_HVM 0x0008f000 /* Xen HVM trace */ +#define TRC_MEM 0x0010f000 /* Xen memory trace */ +#define TRC_PV 0x0020f000 /* Xen PV traces */ +#define TRC_SHADOW 0x0040f000 /* Xen shadow tracing */ +#define TRC_HW 0x0080f000 /* Xen hardware-related traces */ +#define TRC_GUEST 0x0800f000 /* Guest-generated traces */ +#define TRC_ALL 0x0ffff000 +#define TRC_HD_TO_EVENT(x) ((x)&0x0fffffff) +#define TRC_HD_CYCLE_FLAG (1UL<<31) +#define TRC_HD_INCLUDES_CYCLE_COUNT(x) ( !!( (x) & TRC_HD_CYCLE_FLAG ) ) +#define TRC_HD_EXTRA(x) (((x)>>TRACE_EXTRA_SHIFT)&TRACE_EXTRA_MAX) + +/* Trace subclasses */ +#define TRC_SUBCLS_SHIFT 12 + +/* trace subclasses for SVM */ +#define TRC_HVM_ENTRYEXIT 0x00081000 /* VMENTRY and #VMEXIT */ +#define TRC_HVM_HANDLER 0x00082000 /* various HVM handlers */ +#define TRC_HVM_EMUL 0x00084000 /* emulated devices */ + +#define TRC_SCHED_MIN 0x00021000 /* Just runstate changes */ +#define TRC_SCHED_CLASS 0x00022000 /* Scheduler-specific */ +#define TRC_SCHED_VERBOSE 0x00028000 /* More inclusive scheduling */ + +/* + * The highest 3 bits of the last 12 bits of TRC_SCHED_CLASS above are + * reserved for encoding what scheduler produced the information. The + * actual event is encoded in the last 9 bits. + * + * This means we have 8 scheduling IDs available (which means at most 8 + * schedulers generating events) and, in each scheduler, up to 512 + * different events. + */ +#define TRC_SCHED_ID_BITS 3 +#define TRC_SCHED_ID_SHIFT (TRC_SUBCLS_SHIFT - TRC_SCHED_ID_BITS) +#define TRC_SCHED_ID_MASK (((1UL<cpu_offset[cpu]). + */ +struct t_info { + uint16_t tbuf_size; /* Size in pages of each trace buffer */ + uint16_t mfn_offset[]; /* Offset within t_info structure of the page list per cpu */ + /* MFN lists immediately after the header */ +}; + +#endif /* __XEN_PUBLIC_TRACE_H__ */ + +/* + * Local variables: + * mode: C + * c-file-style: "BSD" + * c-basic-offset: 4 + * tab-width: 4 + * indent-tabs-mode: nil + * End: + */ diff --git a/include/xen/xen.h b/include/xen/xen.h index 6c9e42b2b..308109f17 100644 --- a/include/xen/xen.h +++ b/include/xen/xen.h @@ -53,17 +53,22 @@ DEFINE_XEN_GUEST_HANDLE(uint64_t); DEFINE_XEN_GUEST_HANDLE(xen_pfn_t); DEFINE_XEN_GUEST_HANDLE(xen_ulong_t); -/* Turn a plain number into a C unsigned (long) constant. */ +/* Turn a plain number into a C unsigned (long (long)) constant. */ #define __xen_mk_uint(x) x ## U #define __xen_mk_ulong(x) x ## UL +#ifndef __xen_mk_ullong +# define __xen_mk_ullong(x) x ## ULL +#endif #define xen_mk_uint(x) __xen_mk_uint(x) #define xen_mk_ulong(x) __xen_mk_ulong(x) +#define xen_mk_ullong(x) __xen_mk_ullong(x) #else /* In assembly code we cannot use C numeric constant suffixes. */ -#define xen_mk_uint(x) x -#define xen_mk_ulong(x) x +#define xen_mk_uint(x) x +#define xen_mk_ulong(x) x +#define xen_mk_ullong(x) x #endif @@ -115,6 +120,7 @@ DEFINE_XEN_GUEST_HANDLE(xen_ulong_t); #define __HYPERVISOR_tmem_op 38 #define __HYPERVISOR_xc_reserved_op 39 /* reserved for XenClient */ #define __HYPERVISOR_xenpmu_op 40 +#define __HYPERVISOR_dm_op 41 /* Architecture-specific hypercall definitions. */ #define __HYPERVISOR_arch_0 48 @@ -501,6 +507,21 @@ DEFINE_XEN_GUEST_HANDLE(mmuext_op_t); /* x86/PAE guests: support PDPTs above 4GB. */ #define VMASST_TYPE_pae_extended_cr3 3 +/* + * x86 guests: Sane behaviour for virtual iopl + * - virtual iopl updated from do_iret() hypercalls. + * - virtual iopl reported in bounce frames. + * - guest kernels assumed to be level 0 for the purpose of iopl checks. + */ +#define VMASST_TYPE_architectural_iopl 4 + +/* + * All guests: activate update indicator in vcpu_runstate_info + * Enable setting the XEN_RUNSTATE_UPDATE flag in guest memory mapped + * vcpu_runstate_info during updates of the runstate information. + */ +#define VMASST_TYPE_runstate_update_flag 5 + /* * x86/64 guests: strictly hide M2P from user mode. * This allows the guest to control respective hypervisor behavior: @@ -529,16 +550,21 @@ DEFINE_XEN_GUEST_HANDLE(mmuext_op_t); * is useful to ensure that no mappings to the OS's own heap are accidentally * installed. (e.g., in Linux this could cause havoc as reference counts * aren't adjusted on the I/O-mapping code path). - * This only makes sense in MMUEXT_SET_FOREIGNDOM, but in that context can - * be specified by any calling domain. + * This only makes sense as HYPERVISOR_mmu_update()'s and + * HYPERVISOR_update_va_mapping_otherdomain()'s "foreigndom" argument. For + * HYPERVISOR_mmu_update() context it can be specified by any calling domain, + * otherwise it's only permitted if the caller is privileged. */ #define DOMID_IO xen_mk_uint(0x7FF1) /* * DOMID_XEN is used to allow privileged domains to map restricted parts of * Xen's heap space (e.g., the machine_to_phys table). - * This only makes sense in MMUEXT_SET_FOREIGNDOM, and is only permitted if - * the caller is privileged. + * This only makes sense as + * - HYPERVISOR_mmu_update()'s, HYPERVISOR_mmuext_op()'s, or + * HYPERVISOR_update_va_mapping_otherdomain()'s "foreigndom" argument, + * - with XENMAPSPACE_gmfn_foreign, + * and is only permitted if the caller is privileged. */ #define DOMID_XEN xen_mk_uint(0x7FF2) @@ -614,10 +640,18 @@ struct vcpu_time_info { */ uint32_t tsc_to_system_mul; int8_t tsc_shift; +#if __XEN_INTERFACE_VERSION__ > 0x040600 + uint8_t flags; + uint8_t pad1[2]; +#else int8_t pad1[3]; +#endif }; /* 32 bytes */ typedef struct vcpu_time_info vcpu_time_info_t; +#define XEN_PVCLOCK_TSC_STABLE_BIT (1 << 0) +#define XEN_PVCLOCK_GUEST_STOPPED (1 << 1) + struct vcpu_info { /* * 'evtchn_upcall_pending' is written non-zero by Xen to indicate @@ -736,7 +770,7 @@ typedef struct shared_info shared_info_t; * (may be omitted) * c. list of allocated page frames [mfn_list, nr_pages] * (unless relocated due to XEN_ELFNOTE_INIT_P2M) - * d. start_info_t structure [register ESI (x86)] + * d. start_info_t structure [register rSI (x86)] * in case of dom0 this page contains the console info, too * e. unless dom0: xenstore ring page * f. unless dom0: console ring page @@ -797,29 +831,6 @@ struct start_info { }; typedef struct start_info start_info_t; -/* - * Start of day structure passed to PVH guests in %ebx. - * - * NOTE: nothing will be loaded at physical address 0, so - * a 0 value in any of the address fields should be treated - * as not present. - */ -struct hvm_start_info { -#define HVM_START_MAGIC_VALUE 0x336ec578 - uint32_t magic; /* Contains the magic value 0x336ec578 */ - /* ("xEn3" with the 0x80 bit of the "E" set).*/ - uint32_t flags; /* SIF_xxx flags. */ - uint32_t cmdline_paddr; /* Physical address of the command line. */ - uint32_t nr_modules; /* Number of modules passed to the kernel. */ - uint32_t modlist_paddr; /* Physical address of an array of */ - /* hvm_modlist_entry. */ -}; - -struct hvm_modlist_entry { - uint32_t paddr; /* Physical address of the module. */ - uint32_t size; /* Size of the module in bytes. */ -}; - /* New console union for dom0 introduced in 0x00030203. */ #if __XEN_INTERFACE_VERSION__ < 0x00030203 #define console_mfn console.domU.mfn @@ -919,6 +930,37 @@ __DEFINE_XEN_GUEST_HANDLE(uint16, uint16_t); __DEFINE_XEN_GUEST_HANDLE(uint32, uint32_t); __DEFINE_XEN_GUEST_HANDLE(uint64, uint64_t); +typedef struct { + uint8_t a[16]; +} xen_uuid_t; + +/* + * XEN_DEFINE_UUID(0x00112233, 0x4455, 0x6677, 0x8899, + * 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff) + * will construct UUID 00112233-4455-6677-8899-aabbccddeeff presented as + * {0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66, 0x77, 0x88, + * 0x99, 0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}; + * + * NB: This is compatible with Linux kernel and with libuuid, but it is not + * compatible with Microsoft, as they use mixed-endian encoding (some + * components are little-endian, some are big-endian). + */ +#define XEN_DEFINE_UUID_(a, b, c, d, e1, e2, e3, e4, e5, e6) \ + {{((a) >> 24) & 0xFF, ((a) >> 16) & 0xFF, \ + ((a) >> 8) & 0xFF, ((a) >> 0) & 0xFF, \ + ((b) >> 8) & 0xFF, ((b) >> 0) & 0xFF, \ + ((c) >> 8) & 0xFF, ((c) >> 0) & 0xFF, \ + ((d) >> 8) & 0xFF, ((d) >> 0) & 0xFF, \ + e1, e2, e3, e4, e5, e6}} + +#if defined(__STDC_VERSION__) ? __STDC_VERSION__ >= 199901L : defined(__GNUC__) +#define XEN_DEFINE_UUID(a, b, c, d, e1, e2, e3, e4, e5, e6) \ + ((xen_uuid_t)XEN_DEFINE_UUID_(a, b, c, d, e1, e2, e3, e4, e5, e6)) +#else +#define XEN_DEFINE_UUID(a, b, c, d, e1, e2, e3, e4, e5, e6) \ + XEN_DEFINE_UUID_(a, b, c, d, e1, e2, e3, e4, e5, e6) +#endif /* __STDC_VERSION__ / __GNUC__ */ + #endif /* !__ASSEMBLY__ */ /* Default definitions for macros used by domctl/sysctl. */ -- 2.16.4