From mboxrd@z Thu Jan 1 00:00:00 1970 From: Paul Durrant Subject: [PATCH v3 01/18] xen: re-name XenDevice to XenLegacyDevice... Date: Tue, 11 Dec 2018 10:47:01 +0000 Message-ID: <1544525238-3527-2-git-send-email-paul.durrant@citrix.com> References: <1544525238-3527-1-git-send-email-paul.durrant@citrix.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from us1-rack-dfw2.inumbo.com ([104.130.134.6]) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1gWfZq-00054n-Hd for xen-devel@lists.xenproject.org; Tue, 11 Dec 2018 10:47:46 +0000 In-Reply-To: <1544525238-3527-1-git-send-email-paul.durrant@citrix.com> List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" To: qemu-devel@nongnu.org, qemu-block@nongnu.org, xen-devel@lists.xenproject.org Cc: Kevin Wolf , Stefano Stabellini , Eduardo Habkost , "Michael S. Tsirkin" , Jason Wang , Greg Kurz , Max Reitz , Paul Durrant , Gerd Hoffmann , Marcel Apfelbaum , Paolo Bonzini , =?UTF-8?q?Marc-Andr=C3=A9=20Lureau?= , Richard Henderson List-Id: xen-devel@lists.xenproject.org Li4uYW5kIHhlbl9iYWNrZW5kLmggdG8geGVuLWxlZ2FjeS1iYWNrZW5kLmgKClJhdGhlciB0aGFu IGF0dGVtcHRpbmcgdG8gY29udmVydCB0aGUgZXhpc3RpbmcgYmFja2VuZCBpbmZyYXN0cnVjdHVy ZSB0bwpiZSBRT00gY29tcGxpYW50ICh3aGljaCB3b3VsZCBiZSBoYXJkIHRvIGRvIGluIGFuIGlu Y3JlbWVudGFsIGZhc2hpb24pLApzdWJzZXF1ZW50IHBhdGNoZXMgd2lsbCBpbnRyb2R1Y2UgYSBj b21wbGV0ZWx5IG5ldyBmcmFtZXdvcmsgZm9yIFhlbiBQVgpiYWNrZW5kcy4gSGVuY2UgaXQgaXMg bmVjZXNzYXJ5IHRvIHJlLW5hbWUgcGFydHMgb2YgZXhpc3RpbmcgY29kZSB0byBhdm9pZApuYW1l IGNsYXNoZXMuIFRoZSByZS1uYW1lZCAnbGVnYWN5JyBpbmZyYXN0cnVjdHVyZSB3aWxsIGJlIHJl bW92ZWQgb25jZSBhbGwKYmFja2VuZHMgaGF2ZSBiZWVuIHBvcnRlZCB0byB0aGUgbmV3IGZyYW1l d29yay4KClRoaXMgcGF0Y2ggaXMgcHVyZWx5IGNvc21ldGljLiBObyBmdW5jdGlvbmFsIGNoYW5n ZS4KClNpZ25lZC1vZmYtYnk6IFBhdWwgRHVycmFudCA8cGF1bC5kdXJyYW50QGNpdHJpeC5jb20+ CkFja2VkLWJ5OiBBbnRob255IFBlcmFyZCA8YW50aG9ueS5wZXJhcmRAY2l0cml4LmNvbT4KLS0t CkNjOiBTdGVmYW5vIFN0YWJlbGxpbmkgPHNzdGFiZWxsaW5pQGtlcm5lbC5vcmc+CkNjOiBHcmVn IEt1cnogPGdyb3VnQGthb2Qub3JnPgpDYzogS2V2aW4gV29sZiA8a3dvbGZAcmVkaGF0LmNvbT4K Q2M6IE1heCBSZWl0eiA8bXJlaXR6QHJlZGhhdC5jb20+CkNjOiAiTWFyYy1BbmRyw6kgTHVyZWF1 IiA8bWFyY2FuZHJlLmx1cmVhdUByZWRoYXQuY29tPgpDYzogUGFvbG8gQm9uemluaSA8cGJvbnpp bmlAcmVkaGF0LmNvbT4KQ2M6IFJpY2hhcmQgSGVuZGVyc29uIDxydGhAdHdpZGRsZS5uZXQ+CkNj OiBFZHVhcmRvIEhhYmtvc3QgPGVoYWJrb3N0QHJlZGhhdC5jb20+CkNjOiAiTWljaGFlbCBTLiBU c2lya2luIiA8bXN0QHJlZGhhdC5jb20+CkNjOiBNYXJjZWwgQXBmZWxiYXVtIDxtYXJjZWwuYXBm ZWxiYXVtQGdtYWlsLmNvbT4KQ2M6IEphc29uIFdhbmcgPGphc293YW5nQHJlZGhhdC5jb20+CkNj OiBHZXJkIEhvZmZtYW5uIDxrcmF4ZWxAcmVkaGF0LmNvbT4KLS0tCiBody85cGZzL3hlbi05cC1i YWNrZW5kLmMgICAgICAgICAgICB8ICAxNiArLQogaHcvYmxvY2sveGVuX2Rpc2suYyAgICAgICAg ICAgICAgICAgfCAgMjQgKy0KIGh3L2NoYXIveGVuX2NvbnNvbGUuYyAgICAgICAgICAgICAgIHwg IDEyICstCiBody9kaXNwbGF5L3hlbmZiLmMgICAgICAgICAgICAgICAgICB8ICAyNSArLQogaHcv aTM4Ni94ZW4veGVuLWh2bS5jICAgICAgICAgICAgICAgfCAgIDIgKy0KIGh3L2kzODYveGVuL3hl bi1tYXBjYWNoZS5jICAgICAgICAgIHwgICAyICstCiBody9pMzg2L3hlbi94ZW5fcGxhdGZvcm0u YyAgICAgICAgICB8ICAgMiArLQogaHcvbmV0L3hlbl9uaWMuYyAgICAgICAgICAgICAgICAgICAg fCAgMTQgKy0KIGh3L3VzYi94ZW4tdXNiLmMgICAgICAgICAgICAgICAgICAgIHwgIDI1ICstCiBo dy94ZW4vTWFrZWZpbGUub2JqcyAgICAgICAgICAgICAgICB8ICAgMiArLQogaHcveGVuL3hlbi1j b21tb24uYyAgICAgICAgICAgICAgICAgfCAgIDIgKy0KIGh3L3hlbi94ZW4tbGVnYWN5LWJhY2tl bmQuYyAgICAgICAgIHwgODU0ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwog aHcveGVuL3hlbl9iYWNrZW5kLmMgICAgICAgICAgICAgICAgfCA4NDUgLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0KIGh3L3hlbi94ZW5fZGV2Y29uZmlnLmMgICAgICAgICAgICAg IHwgICAyICstCiBody94ZW4veGVuX3B0LmMgICAgICAgICAgICAgICAgICAgICB8ICAgMiArLQog aHcveGVuL3hlbl9wdF9jb25maWdfaW5pdC5jICAgICAgICAgfCAgIDIgKy0KIGh3L3hlbi94ZW5f cHRfZ3JhcGhpY3MuYyAgICAgICAgICAgIHwgICAyICstCiBody94ZW4veGVuX3B0X21zaS5jICAg ICAgICAgICAgICAgICB8ICAgMiArLQogaHcveGVuL3hlbl9wdmRldi5jICAgICAgICAgICAgICAg ICAgfCAgMjAgKy0KIGh3L3hlbnB2L3hlbl9kb21haW5idWlsZC5jICAgICAgICAgIHwgICAyICst CiBody94ZW5wdi94ZW5fbWFjaGluZV9wdi5jICAgICAgICAgICB8ICAgMiArLQogaW5jbHVkZS9o dy94ZW4veGVuLWxlZ2FjeS1iYWNrZW5kLmggfCAxMDQgKysrKysKIGluY2x1ZGUvaHcveGVuL3hl bl9iYWNrZW5kLmggICAgICAgIHwgIDk5IC0tLS0tCiBpbmNsdWRlL2h3L3hlbi94ZW5fcHZkZXYu aCAgICAgICAgICB8ICAzOCArLQogMjQgZmlsZXMgY2hhbmdlZCwgMTA1OSBpbnNlcnRpb25zKCsp LCAxMDQxIGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IGh3L3hlbi94ZW4tbGVnYWN5 LWJhY2tlbmQuYwogZGVsZXRlIG1vZGUgMTAwNjQ0IGh3L3hlbi94ZW5fYmFja2VuZC5jCiBjcmVh dGUgbW9kZSAxMDA2NDQgaW5jbHVkZS9ody94ZW4veGVuLWxlZ2FjeS1iYWNrZW5kLmgKIGRlbGV0 ZSBtb2RlIDEwMDY0NCBpbmNsdWRlL2h3L3hlbi94ZW5fYmFja2VuZC5oCgpkaWZmIC0tZ2l0IGEv aHcvOXBmcy94ZW4tOXAtYmFja2VuZC5jIGIvaHcvOXBmcy94ZW4tOXAtYmFja2VuZC5jCmluZGV4 IDNmNTRhMjEuLjM4NTlhMDYgMTAwNjQ0Ci0tLSBhL2h3LzlwZnMveGVuLTlwLWJhY2tlbmQuYwor KysgYi9ody85cGZzL3hlbi05cC1iYWNrZW5kLmMKQEAgLTEyLDcgKzEyLDcgQEAKIAogI2luY2x1 ZGUgImh3L2h3LmgiCiAjaW5jbHVkZSAiaHcvOXBmcy85cC5oIgotI2luY2x1ZGUgImh3L3hlbi94 ZW5fYmFja2VuZC5oIgorI2luY2x1ZGUgImh3L3hlbi94ZW4tbGVnYWN5LWJhY2tlbmQuaCIKICNp bmNsdWRlICJody85cGZzL3hlbi05cGZzLmgiCiAjaW5jbHVkZSAicWFwaS9lcnJvci5oIgogI2lu Y2x1ZGUgInFlbXUvY29uZmlnLWZpbGUuaCIKQEAgLTQ1LDcgKzQ1LDcgQEAgdHlwZWRlZiBzdHJ1 Y3QgWGVuOXBmc1JpbmcgewogfSBYZW45cGZzUmluZzsKIAogdHlwZWRlZiBzdHJ1Y3QgWGVuOXBm c0RldiB7Ci0gICAgc3RydWN0IFhlbkRldmljZSB4ZW5kZXY7ICAvKiBtdXN0IGJlIGZpcnN0ICov CisgICAgc3RydWN0IFhlbkxlZ2FjeURldmljZSB4ZW5kZXY7ICAvKiBtdXN0IGJlIGZpcnN0ICov CiAgICAgVjlmc1N0YXRlIHN0YXRlOwogICAgIGNoYXIgKnBhdGg7CiAgICAgY2hhciAqc2VjdXJp dHlfbW9kZWw7CkBAIC01Niw3ICs1Niw3IEBAIHR5cGVkZWYgc3RydWN0IFhlbjlwZnNEZXYgewog ICAgIFhlbjlwZnNSaW5nICpyaW5nczsKIH0gWGVuOXBmc0RldjsKIAotc3RhdGljIHZvaWQgeGVu XzlwZnNfZGlzY29ubmVjdChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpOworc3RhdGljIHZvaWQg eGVuXzlwZnNfZGlzY29ubmVjdChzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpOwogCiBz dGF0aWMgdm9pZCB4ZW5fOXBmc19pbl9zZyhYZW45cGZzUmluZyAqcmluZywKICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHN0cnVjdCBpb3ZlYyAqaW5fc2csCkBAIC0yNDMsNyArMjQzLDcgQEAg c3RhdGljIGNvbnN0IFY5ZnNUcmFuc3BvcnQgeGVuXzlwX3RyYW5zcG9ydCA9IHsKICAgICAucHVz aF9hbmRfbm90aWZ5ID0geGVuXzlwZnNfcHVzaF9hbmRfbm90aWZ5LAogfTsKIAotc3RhdGljIGlu dCB4ZW5fOXBmc19pbml0KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKK3N0YXRpYyBpbnQgeGVu XzlwZnNfaW5pdChzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpCiB7CiAgICAgcmV0dXJu IDA7CiB9CkBAIC0zMDUsNyArMzA1LDcgQEAgc3RhdGljIHZvaWQgeGVuXzlwZnNfZXZ0Y2huX2V2 ZW50KHZvaWQgKm9wYXF1ZSkKICAgICBxZW11X2JoX3NjaGVkdWxlKHJpbmctPmJoKTsKIH0KIAot c3RhdGljIHZvaWQgeGVuXzlwZnNfZGlzY29ubmVjdChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYp CitzdGF0aWMgdm9pZCB4ZW5fOXBmc19kaXNjb25uZWN0KHN0cnVjdCBYZW5MZWdhY3lEZXZpY2Ug KnhlbmRldikKIHsKICAgICBYZW45cGZzRGV2ICp4ZW5fOXBkZXYgPSBjb250YWluZXJfb2YoeGVu ZGV2LCBYZW45cGZzRGV2LCB4ZW5kZXYpOwogICAgIGludCBpOwpAQCAtMzIxLDcgKzMyMSw3IEBA IHN0YXRpYyB2b2lkIHhlbl85cGZzX2Rpc2Nvbm5lY3Qoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2 KQogICAgIH0KIH0KIAotc3RhdGljIGludCB4ZW5fOXBmc19mcmVlKHN0cnVjdCBYZW5EZXZpY2Ug KnhlbmRldikKK3N0YXRpYyBpbnQgeGVuXzlwZnNfZnJlZShzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNl ICp4ZW5kZXYpCiB7CiAgICAgWGVuOXBmc0RldiAqeGVuXzlwZGV2ID0gY29udGFpbmVyX29mKHhl bmRldiwgWGVuOXBmc0RldiwgeGVuZGV2KTsKICAgICBpbnQgaTsKQEAgLTM1NCw3ICszNTQsNyBA QCBzdGF0aWMgaW50IHhlbl85cGZzX2ZyZWUoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQogICAg IHJldHVybiAwOwogfQogCi1zdGF0aWMgaW50IHhlbl85cGZzX2Nvbm5lY3Qoc3RydWN0IFhlbkRl dmljZSAqeGVuZGV2KQorc3RhdGljIGludCB4ZW5fOXBmc19jb25uZWN0KHN0cnVjdCBYZW5MZWdh Y3lEZXZpY2UgKnhlbmRldikKIHsKICAgICBFcnJvciAqZXJyID0gTlVMTDsKICAgICBpbnQgaTsK QEAgLTQ2Nyw3ICs0NjcsNyBAQCBvdXQ6CiAgICAgcmV0dXJuIC0xOwogfQogCi1zdGF0aWMgdm9p ZCB4ZW5fOXBmc19hbGxvYyhzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCitzdGF0aWMgdm9pZCB4 ZW5fOXBmc19hbGxvYyhzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpCiB7CiAgICAgeGVu c3RvcmVfd3JpdGVfYmVfc3RyKHhlbmRldiwgInZlcnNpb25zIiwgVkVSU0lPTlMpOwogICAgIHhl bnN0b3JlX3dyaXRlX2JlX2ludCh4ZW5kZXYsICJtYXgtcmluZ3MiLCBNQVhfUklOR1MpOwpkaWZm IC0tZ2l0IGEvaHcvYmxvY2sveGVuX2Rpc2suYyBiL2h3L2Jsb2NrL3hlbl9kaXNrLmMKaW5kZXgg MzZlZmY5NC4uNzVmZTU1ZiAxMDA2NDQKLS0tIGEvaHcvYmxvY2sveGVuX2Rpc2suYworKysgYi9o dy9ibG9jay94ZW5fZGlzay5jCkBAIC0yNSw3ICsyNSw3IEBACiAjaW5jbHVkZSA8c3lzL3Vpby5o PgogCiAjaW5jbHVkZSAiaHcvaHcuaCIKLSNpbmNsdWRlICJody94ZW4veGVuX2JhY2tlbmQuaCIK KyNpbmNsdWRlICJody94ZW4veGVuLWxlZ2FjeS1iYWNrZW5kLmgiCiAjaW5jbHVkZSAieGVuX2Js a2lmLmgiCiAjaW5jbHVkZSAic3lzZW11L2Jsb2NrZGV2LmgiCiAjaW5jbHVkZSAic3lzZW11L2lv dGhyZWFkLmgiCkBAIC02Myw3ICs2Myw3IEBAIHN0cnVjdCBpb3JlcSB7CiAjZGVmaW5lIE1BWF9S SU5HX1BBR0VfT1JERVIgNAogCiBzdHJ1Y3QgWGVuQmxrRGV2IHsKLSAgICBzdHJ1Y3QgWGVuRGV2 aWNlICAgIHhlbmRldjsgIC8qIG11c3QgYmUgZmlyc3QgKi8KKyAgICBzdHJ1Y3QgWGVuTGVnYWN5 RGV2aWNlICAgIHhlbmRldjsgIC8qIG11c3QgYmUgZmlyc3QgKi8KICAgICBjaGFyICAgICAgICAg ICAgICAgICpwYXJhbXM7CiAgICAgY2hhciAgICAgICAgICAgICAgICAqbW9kZTsKICAgICBjaGFy ICAgICAgICAgICAgICAgICp0eXBlOwpAQCAtMTc5LDcgKzE3OSw3IEBAIHN0YXRpYyB2b2lkIGlv cmVxX3JlbGVhc2Uoc3RydWN0IGlvcmVxICppb3JlcSwgYm9vbCBmaW5pc2gpCiBzdGF0aWMgaW50 IGlvcmVxX3BhcnNlKHN0cnVjdCBpb3JlcSAqaW9yZXEpCiB7CiAgICAgc3RydWN0IFhlbkJsa0Rl diAqYmxrZGV2ID0gaW9yZXEtPmJsa2RldjsKLSAgICBzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYg PSAmYmxrZGV2LT54ZW5kZXY7CisgICAgc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2ID0g JmJsa2Rldi0+eGVuZGV2OwogICAgIHNpemVfdCBsZW47CiAgICAgaW50IGk7CiAKQEAgLTI0Myw3 ICsyNDMsNyBAQCBlcnI6CiBzdGF0aWMgaW50IGlvcmVxX2dyYW50X2NvcHkoc3RydWN0IGlvcmVx ICppb3JlcSkKIHsKICAgICBzdHJ1Y3QgWGVuQmxrRGV2ICpibGtkZXYgPSBpb3JlcS0+YmxrZGV2 OwotICAgIHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiA9ICZibGtkZXYtPnhlbmRldjsKKyAgICBz dHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYgPSAmYmxrZGV2LT54ZW5kZXY7CiAgICAgWGVu R3JhbnRDb3B5U2VnbWVudCBzZWdzW0JMS0lGX01BWF9TRUdNRU5UU19QRVJfUkVRVUVTVF07CiAg ICAgaW50IGksIGNvdW50LCByYzsKICAgICBpbnQ2NF90IGZpbGVfYmxrID0gYmxrZGV2LT5maWxl X2JsazsKQEAgLTI4OSw3ICsyODksNyBAQCBzdGF0aWMgdm9pZCBxZW11X2Fpb19jb21wbGV0ZSh2 b2lkICpvcGFxdWUsIGludCByZXQpCiB7CiAgICAgc3RydWN0IGlvcmVxICppb3JlcSA9IG9wYXF1 ZTsKICAgICBzdHJ1Y3QgWGVuQmxrRGV2ICpibGtkZXYgPSBpb3JlcS0+YmxrZGV2OwotICAgIHN0 cnVjdCBYZW5EZXZpY2UgKnhlbmRldiA9ICZibGtkZXYtPnhlbmRldjsKKyAgICBzdHJ1Y3QgWGVu TGVnYWN5RGV2aWNlICp4ZW5kZXYgPSAmYmxrZGV2LT54ZW5kZXY7CiAKICAgICBhaW9fY29udGV4 dF9hY3F1aXJlKGJsa2Rldi0+Y3R4KTsKIApAQCAtNjA4LDcgKzYwOCw3IEBAIHN0YXRpYyB2b2lk IGJsa19iaCh2b2lkICpvcGFxdWUpCiAgICAgYWlvX2NvbnRleHRfcmVsZWFzZShibGtkZXYtPmN0 eCk7CiB9CiAKLXN0YXRpYyB2b2lkIGJsa19hbGxvYyhzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYp CitzdGF0aWMgdm9pZCBibGtfYWxsb2Moc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2KQog ewogICAgIHN0cnVjdCBYZW5CbGtEZXYgKmJsa2RldiA9IGNvbnRhaW5lcl9vZih4ZW5kZXYsIHN0 cnVjdCBYZW5CbGtEZXYsIHhlbmRldik7CiAgICAgRXJyb3IgKmVyciA9IE5VTEw7CkBAIC02Mjgs NyArNjI4LDcgQEAgc3RhdGljIHZvaWQgYmxrX2FsbG9jKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRl dikKIAogc3RhdGljIHZvaWQgYmxrX3BhcnNlX2Rpc2NhcmQoc3RydWN0IFhlbkJsa0RldiAqYmxr ZGV2KQogewotICAgIHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiA9ICZibGtkZXYtPnhlbmRldjsK KyAgICBzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYgPSAmYmxrZGV2LT54ZW5kZXY7CiAg ICAgaW50IGVuYWJsZTsKIAogICAgIGJsa2Rldi0+ZmVhdHVyZV9kaXNjYXJkID0gdHJ1ZTsKQEAg LTY0Miw3ICs2NDIsNyBAQCBzdGF0aWMgdm9pZCBibGtfcGFyc2VfZGlzY2FyZChzdHJ1Y3QgWGVu QmxrRGV2ICpibGtkZXYpCiAgICAgfQogfQogCi1zdGF0aWMgaW50IGJsa19pbml0KHN0cnVjdCBY ZW5EZXZpY2UgKnhlbmRldikKK3N0YXRpYyBpbnQgYmxrX2luaXQoc3RydWN0IFhlbkxlZ2FjeURl dmljZSAqeGVuZGV2KQogewogICAgIHN0cnVjdCBYZW5CbGtEZXYgKmJsa2RldiA9IGNvbnRhaW5l cl9vZih4ZW5kZXYsIHN0cnVjdCBYZW5CbGtEZXYsIHhlbmRldik7CiAgICAgaW50IGluZm8gPSAw OwpAQCAtNzM3LDcgKzczNyw3IEBAIG91dF9lcnJvcjoKICAgICByZXR1cm4gLTE7CiB9CiAKLXN0 YXRpYyBpbnQgYmxrX2Nvbm5lY3Qoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQorc3RhdGljIGlu dCBibGtfY29ubmVjdChzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpCiB7CiAgICAgc3Ry dWN0IFhlbkJsa0RldiAqYmxrZGV2ID0gY29udGFpbmVyX29mKHhlbmRldiwgc3RydWN0IFhlbkJs a0RldiwgeGVuZGV2KTsKICAgICBpbnQgaW5kZXgsIHFmbGFnczsKQEAgLTk0MSw3ICs5NDEsNyBA QCBzdGF0aWMgaW50IGJsa19jb25uZWN0KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKICAgICBy ZXR1cm4gMDsKIH0KIAotc3RhdGljIHZvaWQgYmxrX2Rpc2Nvbm5lY3Qoc3RydWN0IFhlbkRldmlj ZSAqeGVuZGV2KQorc3RhdGljIHZvaWQgYmxrX2Rpc2Nvbm5lY3Qoc3RydWN0IFhlbkxlZ2FjeURl dmljZSAqeGVuZGV2KQogewogICAgIHN0cnVjdCBYZW5CbGtEZXYgKmJsa2RldiA9IGNvbnRhaW5l cl9vZih4ZW5kZXYsIHN0cnVjdCBYZW5CbGtEZXYsIHhlbmRldik7CiAKQEAgLTk2Niw3ICs5NjYs NyBAQCBzdGF0aWMgdm9pZCBibGtfZGlzY29ubmVjdChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYp CiAgICAgfQogfQogCi1zdGF0aWMgaW50IGJsa19mcmVlKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRl dikKK3N0YXRpYyBpbnQgYmxrX2ZyZWUoc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2KQog ewogICAgIHN0cnVjdCBYZW5CbGtEZXYgKmJsa2RldiA9IGNvbnRhaW5lcl9vZih4ZW5kZXYsIHN0 cnVjdCBYZW5CbGtEZXYsIHhlbmRldik7CiAgICAgc3RydWN0IGlvcmVxICppb3JlcTsKQEAgLTk5 Miw3ICs5OTIsNyBAQCBzdGF0aWMgaW50IGJsa19mcmVlKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRl dikKICAgICByZXR1cm4gMDsKIH0KIAotc3RhdGljIHZvaWQgYmxrX2V2ZW50KHN0cnVjdCBYZW5E ZXZpY2UgKnhlbmRldikKK3N0YXRpYyB2b2lkIGJsa19ldmVudChzdHJ1Y3QgWGVuTGVnYWN5RGV2 aWNlICp4ZW5kZXYpCiB7CiAgICAgc3RydWN0IFhlbkJsa0RldiAqYmxrZGV2ID0gY29udGFpbmVy X29mKHhlbmRldiwgc3RydWN0IFhlbkJsa0RldiwgeGVuZGV2KTsKIApkaWZmIC0tZ2l0IGEvaHcv Y2hhci94ZW5fY29uc29sZS5jIGIvaHcvY2hhci94ZW5fY29uc29sZS5jCmluZGV4IDQ0ZjcyMzYu LjQ2MGFkYzEgMTAwNjQ0Ci0tLSBhL2h3L2NoYXIveGVuX2NvbnNvbGUuYworKysgYi9ody9jaGFy L3hlbl9jb25zb2xlLmMKQEAgLTI2LDcgKzI2LDcgQEAKICNpbmNsdWRlICJxYXBpL2Vycm9yLmgi CiAjaW5jbHVkZSAiaHcvaHcuaCIKICNpbmNsdWRlICJjaGFyZGV2L2NoYXItZmUuaCIKLSNpbmNs dWRlICJody94ZW4veGVuX2JhY2tlbmQuaCIKKyNpbmNsdWRlICJody94ZW4veGVuLWxlZ2FjeS1i YWNrZW5kLmgiCiAKICNpbmNsdWRlIDx4ZW4vaW8vY29uc29sZS5oPgogCkBAIC0zOSw3ICszOSw3 IEBAIHN0cnVjdCBidWZmZXIgewogfTsKIAogc3RydWN0IFhlbkNvbnNvbGUgewotICAgIHN0cnVj dCBYZW5EZXZpY2UgIHhlbmRldjsgIC8qIG11c3QgYmUgZmlyc3QgKi8KKyAgICBzdHJ1Y3QgWGVu TGVnYWN5RGV2aWNlICB4ZW5kZXY7ICAvKiBtdXN0IGJlIGZpcnN0ICovCiAgICAgc3RydWN0IGJ1 ZmZlciAgICAgYnVmZmVyOwogICAgIGNoYXIgICAgICAgICAgICAgIGNvbnNvbGVbWEVOX0JVRlNJ WkVdOwogICAgIGludCAgICAgICAgICAgICAgIHJpbmdfcmVmOwpAQCAtMTczLDcgKzE3Myw3IEBA IHN0YXRpYyB2b2lkIHhlbmNvbnNfc2VuZChzdHJ1Y3QgWGVuQ29uc29sZSAqY29uKQogCiAvKiAt LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLSAqLwogCi1zdGF0aWMgaW50IGNvbl9pbml0KHN0cnVjdCBYZW5EZXZpY2UgKnhl bmRldikKK3N0YXRpYyBpbnQgY29uX2luaXQoc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2 KQogewogICAgIHN0cnVjdCBYZW5Db25zb2xlICpjb24gPSBjb250YWluZXJfb2YoeGVuZGV2LCBz dHJ1Y3QgWGVuQ29uc29sZSwgeGVuZGV2KTsKICAgICBjaGFyICp0eXBlLCAqZG9tLCBsYWJlbFsz Ml07CkBAIC0yMjIsNyArMjIyLDcgQEAgb3V0OgogICAgIHJldHVybiByZXQ7CiB9CiAKLXN0YXRp YyBpbnQgY29uX2luaXRpYWxpc2Uoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQorc3RhdGljIGlu dCBjb25faW5pdGlhbGlzZShzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpCiB7CiAgICAg c3RydWN0IFhlbkNvbnNvbGUgKmNvbiA9IGNvbnRhaW5lcl9vZih4ZW5kZXYsIHN0cnVjdCBYZW5D b25zb2xlLCB4ZW5kZXYpOwogICAgIGludCBsaW1pdDsKQEAgLTI1OSw3ICsyNTksNyBAQCBzdGF0 aWMgaW50IGNvbl9pbml0aWFsaXNlKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKICAgICByZXR1 cm4gMDsKIH0KIAotc3RhdGljIHZvaWQgY29uX2Rpc2Nvbm5lY3Qoc3RydWN0IFhlbkRldmljZSAq eGVuZGV2KQorc3RhdGljIHZvaWQgY29uX2Rpc2Nvbm5lY3Qoc3RydWN0IFhlbkxlZ2FjeURldmlj ZSAqeGVuZGV2KQogewogICAgIHN0cnVjdCBYZW5Db25zb2xlICpjb24gPSBjb250YWluZXJfb2Yo eGVuZGV2LCBzdHJ1Y3QgWGVuQ29uc29sZSwgeGVuZGV2KTsKIApAQCAtMjc2LDcgKzI3Niw3IEBA IHN0YXRpYyB2b2lkIGNvbl9kaXNjb25uZWN0KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKICAg ICB9CiB9CiAKLXN0YXRpYyB2b2lkIGNvbl9ldmVudChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYp CitzdGF0aWMgdm9pZCBjb25fZXZlbnQoc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2KQog ewogICAgIHN0cnVjdCBYZW5Db25zb2xlICpjb24gPSBjb250YWluZXJfb2YoeGVuZGV2LCBzdHJ1 Y3QgWGVuQ29uc29sZSwgeGVuZGV2KTsKIApkaWZmIC0tZ2l0IGEvaHcvZGlzcGxheS94ZW5mYi5j IGIvaHcvZGlzcGxheS94ZW5mYi5jCmluZGV4IDAzMzBkYzYuLjYyMDJmMTEgMTAwNjQ0Ci0tLSBh L2h3L2Rpc3BsYXkveGVuZmIuYworKysgYi9ody9kaXNwbGF5L3hlbmZiLmMKQEAgLTMwLDcgKzMw LDcgQEAKICNpbmNsdWRlICJody9ody5oIgogI2luY2x1ZGUgInVpL2lucHV0LmgiCiAjaW5jbHVk ZSAidWkvY29uc29sZS5oIgotI2luY2x1ZGUgImh3L3hlbi94ZW5fYmFja2VuZC5oIgorI2luY2x1 ZGUgImh3L3hlbi94ZW4tbGVnYWN5LWJhY2tlbmQuaCIKIAogI2luY2x1ZGUgPHhlbi9ldmVudF9j aGFubmVsLmg+CiAjaW5jbHVkZSA8eGVuL2lvL2ZiaWYuaD4KQEAgLTQ2LDcgKzQ2LDcgQEAKIC8q IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tICovCiAKIHN0cnVjdCBjb21tb24gewotICAgIHN0cnVjdCBYZW5EZXZpY2Ug IHhlbmRldjsgIC8qIG11c3QgYmUgZmlyc3QgKi8KKyAgICBzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNl ICB4ZW5kZXY7ICAvKiBtdXN0IGJlIGZpcnN0ICovCiAgICAgdm9pZCAgICAgICAgICAgICAgKnBh Z2U7CiB9OwogCkBAIC0zNDIsMTQgKzM0MiwxNCBAQCBzdGF0aWMgUWVtdUlucHV0SGFuZGxlciB4 ZW5mYl9yZWxfbW91c2UgPSB7CiAgICAgLnN5bmMgID0geGVuZmJfbW91c2Vfc3luYywKIH07CiAK LXN0YXRpYyBpbnQgaW5wdXRfaW5pdChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCitzdGF0aWMg aW50IGlucHV0X2luaXQoc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2KQogewogICAgIHhl bnN0b3JlX3dyaXRlX2JlX2ludCh4ZW5kZXYsICJmZWF0dXJlLWFicy1wb2ludGVyIiwgMSk7CiAg ICAgeGVuc3RvcmVfd3JpdGVfYmVfaW50KHhlbmRldiwgImZlYXR1cmUtcmF3LXBvaW50ZXIiLCAx KTsKICAgICByZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCBpbnB1dF9pbml0aWFsaXNlKHN0cnVj dCBYZW5EZXZpY2UgKnhlbmRldikKK3N0YXRpYyBpbnQgaW5wdXRfaW5pdGlhbGlzZShzdHJ1Y3Qg WGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpCiB7CiAgICAgc3RydWN0IFhlbklucHV0ICppbiA9IGNv bnRhaW5lcl9vZih4ZW5kZXYsIHN0cnVjdCBYZW5JbnB1dCwgYy54ZW5kZXYpOwogICAgIGludCBy YzsKQEAgLTM2MSw3ICszNjEsNyBAQCBzdGF0aWMgaW50IGlucHV0X2luaXRpYWxpc2Uoc3RydWN0 IFhlbkRldmljZSAqeGVuZGV2KQogICAgIHJldHVybiAwOwogfQogCi1zdGF0aWMgdm9pZCBpbnB1 dF9jb25uZWN0ZWQoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQorc3RhdGljIHZvaWQgaW5wdXRf Y29ubmVjdGVkKHN0cnVjdCBYZW5MZWdhY3lEZXZpY2UgKnhlbmRldikKIHsKICAgICBzdHJ1Y3Qg WGVuSW5wdXQgKmluID0gY29udGFpbmVyX29mKHhlbmRldiwgc3RydWN0IFhlbklucHV0LCBjLnhl bmRldik7CiAKQEAgLTM5NSw3ICszOTUsNyBAQCBzdGF0aWMgdm9pZCBpbnB1dF9jb25uZWN0ZWQo c3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQogICAgIH0KIH0KIAotc3RhdGljIHZvaWQgaW5wdXRf ZGlzY29ubmVjdChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCitzdGF0aWMgdm9pZCBpbnB1dF9k aXNjb25uZWN0KHN0cnVjdCBYZW5MZWdhY3lEZXZpY2UgKnhlbmRldikKIHsKICAgICBzdHJ1Y3Qg WGVuSW5wdXQgKmluID0gY29udGFpbmVyX29mKHhlbmRldiwgc3RydWN0IFhlbklucHV0LCBjLnhl bmRldik7CiAKQEAgLTQxMCw3ICs0MTAsNyBAQCBzdGF0aWMgdm9pZCBpbnB1dF9kaXNjb25uZWN0 KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKICAgICBjb21tb25fdW5iaW5kKCZpbi0+Yyk7CiB9 CiAKLXN0YXRpYyB2b2lkIGlucHV0X2V2ZW50KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKK3N0 YXRpYyB2b2lkIGlucHV0X2V2ZW50KHN0cnVjdCBYZW5MZWdhY3lEZXZpY2UgKnhlbmRldikKIHsK ICAgICBzdHJ1Y3QgWGVuSW5wdXQgKnhlbmZiID0gY29udGFpbmVyX29mKHhlbmRldiwgc3RydWN0 IFhlbklucHV0LCBjLnhlbmRldik7CiAgICAgc3RydWN0IHhlbmtiZF9wYWdlICpwYWdlID0geGVu ZmItPmMucGFnZTsKQEAgLTg2Nyw3ICs4NjcsNyBAQCBzdGF0aWMgdm9pZCB4ZW5mYl9oYW5kbGVf ZXZlbnRzKHN0cnVjdCBYZW5GQiAqeGVuZmIpCiAgICAgcGFnZS0+b3V0X2NvbnMgPSBjb25zOwog fQogCi1zdGF0aWMgaW50IGZiX2luaXQoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQorc3RhdGlj IGludCBmYl9pbml0KHN0cnVjdCBYZW5MZWdhY3lEZXZpY2UgKnhlbmRldikKIHsKICNpZmRlZiBY RU5GQl9UWVBFX1JFU0laRQogICAgIHhlbnN0b3JlX3dyaXRlX2JlX2ludCh4ZW5kZXYsICJmZWF0 dXJlLXJlc2l6ZSIsIDEpOwpAQCAtODc1LDcgKzg3NSw3IEBAIHN0YXRpYyBpbnQgZmJfaW5pdChz dHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCiAgICAgcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyBpbnQg ZmJfaW5pdGlhbGlzZShzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCitzdGF0aWMgaW50IGZiX2lu aXRpYWxpc2Uoc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2KQogewogICAgIHN0cnVjdCBY ZW5GQiAqZmIgPSBjb250YWluZXJfb2YoeGVuZGV2LCBzdHJ1Y3QgWGVuRkIsIGMueGVuZGV2KTsK ICAgICBzdHJ1Y3QgeGVuZmJfcGFnZSAqZmJfcGFnZTsKQEAgLTkxMiw3ICs5MTIsNyBAQCBzdGF0 aWMgaW50IGZiX2luaXRpYWxpc2Uoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQogICAgIHJldHVy biAwOwogfQogCi1zdGF0aWMgdm9pZCBmYl9kaXNjb25uZWN0KHN0cnVjdCBYZW5EZXZpY2UgKnhl bmRldikKK3N0YXRpYyB2b2lkIGZiX2Rpc2Nvbm5lY3Qoc3RydWN0IFhlbkxlZ2FjeURldmljZSAq eGVuZGV2KQogewogICAgIHN0cnVjdCBYZW5GQiAqZmIgPSBjb250YWluZXJfb2YoeGVuZGV2LCBz dHJ1Y3QgWGVuRkIsIGMueGVuZGV2KTsKIApAQCAtOTM1LDcgKzkzNSw4IEBAIHN0YXRpYyB2b2lk IGZiX2Rpc2Nvbm5lY3Qoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQogICAgIGZiLT5idWdfdHJp Z2dlciAgICA9IDA7CiB9CiAKLXN0YXRpYyB2b2lkIGZiX2Zyb250ZW5kX2NoYW5nZWQoc3RydWN0 IFhlbkRldmljZSAqeGVuZGV2LCBjb25zdCBjaGFyICpub2RlKQorc3RhdGljIHZvaWQgZmJfZnJv bnRlbmRfY2hhbmdlZChzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKm5vZGUpCiB7CiAgICAgc3RydWN0IFhl bkZCICpmYiA9IGNvbnRhaW5lcl9vZih4ZW5kZXYsIHN0cnVjdCBYZW5GQiwgYy54ZW5kZXYpOwog CkBAIC05NTMsNyArOTU0LDcgQEAgc3RhdGljIHZvaWQgZmJfZnJvbnRlbmRfY2hhbmdlZChzdHJ1 Y3QgWGVuRGV2aWNlICp4ZW5kZXYsIGNvbnN0IGNoYXIgKm5vZGUpCiAgICAgfQogfQogCi1zdGF0 aWMgdm9pZCBmYl9ldmVudChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCitzdGF0aWMgdm9pZCBm Yl9ldmVudChzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpCiB7CiAgICAgc3RydWN0IFhl bkZCICp4ZW5mYiA9IGNvbnRhaW5lcl9vZih4ZW5kZXYsIHN0cnVjdCBYZW5GQiwgYy54ZW5kZXYp OwogCmRpZmYgLS1naXQgYS9ody9pMzg2L3hlbi94ZW4taHZtLmMgYi9ody9pMzg2L3hlbi94ZW4t aHZtLmMKaW5kZXggOTM1YTM2Ny4uMWQ2Mzc2MyAxMDA2NDQKLS0tIGEvaHcvaTM4Ni94ZW4veGVu LWh2bS5jCisrKyBiL2h3L2kzODYveGVuL3hlbi1odm0uYwpAQCAtMTYsNyArMTYsNyBAQAogI2lu Y2x1ZGUgImh3L2kzODYvcGMuaCIKICNpbmNsdWRlICJody9pMzg2L2FwaWMtbXNpZGVmLmgiCiAj aW5jbHVkZSAiaHcveGVuL3hlbl9jb21tb24uaCIKLSNpbmNsdWRlICJody94ZW4veGVuX2JhY2tl bmQuaCIKKyNpbmNsdWRlICJody94ZW4veGVuLWxlZ2FjeS1iYWNrZW5kLmgiCiAjaW5jbHVkZSAi cWFwaS9lcnJvci5oIgogI2luY2x1ZGUgInFhcGkvcWFwaS1jb21tYW5kcy1taXNjLmgiCiAjaW5j bHVkZSAicWVtdS9lcnJvci1yZXBvcnQuaCIKZGlmZiAtLWdpdCBhL2h3L2kzODYveGVuL3hlbi1t YXBjYWNoZS5jIGIvaHcvaTM4Ni94ZW4veGVuLW1hcGNhY2hlLmMKaW5kZXggNGU0ZjA2OS4uOTEz NGE3YiAxMDA2NDQKLS0tIGEvaHcvaTM4Ni94ZW4veGVuLW1hcGNhY2hlLmMKKysrIGIvaHcvaTM4 Ni94ZW4veGVuLW1hcGNhY2hlLmMKQEAgLTE0LDcgKzE0LDcgQEAKIAogI2luY2x1ZGUgPHN5cy9y ZXNvdXJjZS5oPgogCi0jaW5jbHVkZSAiaHcveGVuL3hlbl9iYWNrZW5kLmgiCisjaW5jbHVkZSAi aHcveGVuL3hlbi1sZWdhY3ktYmFja2VuZC5oIgogI2luY2x1ZGUgInFlbXUvYml0bWFwLmgiCiAK ICNpbmNsdWRlIDx4ZW4vaHZtL3BhcmFtcy5oPgpkaWZmIC0tZ2l0IGEvaHcvaTM4Ni94ZW4veGVu X3BsYXRmb3JtLmMgYi9ody9pMzg2L3hlbi94ZW5fcGxhdGZvcm0uYwppbmRleCBkZWI3YTBjLi4x NmFmYjU0IDEwMDY0NAotLS0gYS9ody9pMzg2L3hlbi94ZW5fcGxhdGZvcm0uYworKysgYi9ody9p Mzg2L3hlbi94ZW5fcGxhdGZvcm0uYwpAQCAtMzAsNyArMzAsNyBAQAogI2luY2x1ZGUgImh3L3Bj aS9wY2kuaCIKICNpbmNsdWRlICJody9pcnEuaCIKICNpbmNsdWRlICJody94ZW4veGVuX2NvbW1v bi5oIgotI2luY2x1ZGUgImh3L3hlbi94ZW5fYmFja2VuZC5oIgorI2luY2x1ZGUgImh3L3hlbi94 ZW4tbGVnYWN5LWJhY2tlbmQuaCIKICNpbmNsdWRlICJ0cmFjZS5oIgogI2luY2x1ZGUgImV4ZWMv YWRkcmVzcy1zcGFjZXMuaCIKICNpbmNsdWRlICJzeXNlbXUvYmxvY2stYmFja2VuZC5oIgpkaWZm IC0tZ2l0IGEvaHcvbmV0L3hlbl9uaWMuYyBiL2h3L25ldC94ZW5fbmljLmMKaW5kZXggNDZhOGRi Zi4uMzdjZGE4ZSAxMDA2NDQKLS0tIGEvaHcvbmV0L3hlbl9uaWMuYworKysgYi9ody9uZXQveGVu X25pYy5jCkBAIC0yOCwxNCArMjgsMTQgQEAKICNpbmNsdWRlICJuZXQvbmV0LmgiCiAjaW5jbHVk ZSAibmV0L2NoZWNrc3VtLmgiCiAjaW5jbHVkZSAibmV0L3V0aWwuaCIKLSNpbmNsdWRlICJody94 ZW4veGVuX2JhY2tlbmQuaCIKKyNpbmNsdWRlICJody94ZW4veGVuLWxlZ2FjeS1iYWNrZW5kLmgi CiAKICNpbmNsdWRlIDx4ZW4vaW8vbmV0aWYuaD4KIAogLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwogCiBzdHJ1Y3QgWGVu TmV0RGV2IHsKLSAgICBzdHJ1Y3QgWGVuRGV2aWNlICAgICAgeGVuZGV2OyAgLyogbXVzdCBiZSBm aXJzdCAqLworICAgIHN0cnVjdCBYZW5MZWdhY3lEZXZpY2UgICAgICB4ZW5kZXY7ICAvKiBtdXN0 IGJlIGZpcnN0ICovCiAgICAgY2hhciAgICAgICAgICAgICAgICAgICptYWM7CiAgICAgaW50ICAg ICAgICAgICAgICAgICAgIHR4X3dvcms7CiAgICAgaW50ICAgICAgICAgICAgICAgICAgIHR4X3Jp bmdfcmVmOwpAQCAtMjc2LDcgKzI3Niw3IEBAIHN0YXRpYyBOZXRDbGllbnRJbmZvIG5ldF94ZW5f aW5mbyA9IHsKICAgICAucmVjZWl2ZSA9IG5ldF9yeF9wYWNrZXQsCiB9OwogCi1zdGF0aWMgaW50 IG5ldF9pbml0KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKK3N0YXRpYyBpbnQgbmV0X2luaXQo c3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2KQogewogICAgIHN0cnVjdCBYZW5OZXREZXYg Km5ldGRldiA9IGNvbnRhaW5lcl9vZih4ZW5kZXYsIHN0cnVjdCBYZW5OZXREZXYsIHhlbmRldik7 CiAKQEAgLTMwOCw3ICszMDgsNyBAQCBzdGF0aWMgaW50IG5ldF9pbml0KHN0cnVjdCBYZW5EZXZp Y2UgKnhlbmRldikKICAgICByZXR1cm4gMDsKIH0KIAotc3RhdGljIGludCBuZXRfY29ubmVjdChz dHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCitzdGF0aWMgaW50IG5ldF9jb25uZWN0KHN0cnVjdCBY ZW5MZWdhY3lEZXZpY2UgKnhlbmRldikKIHsKICAgICBzdHJ1Y3QgWGVuTmV0RGV2ICpuZXRkZXYg PSBjb250YWluZXJfb2YoeGVuZGV2LCBzdHJ1Y3QgWGVuTmV0RGV2LCB4ZW5kZXYpOwogICAgIGlu dCByeF9jb3B5OwpAQCAtMzYzLDcgKzM2Myw3IEBAIHN0YXRpYyBpbnQgbmV0X2Nvbm5lY3Qoc3Ry dWN0IFhlbkRldmljZSAqeGVuZGV2KQogICAgIHJldHVybiAwOwogfQogCi1zdGF0aWMgdm9pZCBu ZXRfZGlzY29ubmVjdChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCitzdGF0aWMgdm9pZCBuZXRf ZGlzY29ubmVjdChzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpCiB7CiAgICAgc3RydWN0 IFhlbk5ldERldiAqbmV0ZGV2ID0gY29udGFpbmVyX29mKHhlbmRldiwgc3RydWN0IFhlbk5ldERl diwgeGVuZGV2KTsKIApAQCAtMzc5LDE0ICszNzksMTQgQEAgc3RhdGljIHZvaWQgbmV0X2Rpc2Nv bm5lY3Qoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQogICAgIH0KIH0KIAotc3RhdGljIHZvaWQg bmV0X2V2ZW50KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKK3N0YXRpYyB2b2lkIG5ldF9ldmVu dChzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpCiB7CiAgICAgc3RydWN0IFhlbk5ldERl diAqbmV0ZGV2ID0gY29udGFpbmVyX29mKHhlbmRldiwgc3RydWN0IFhlbk5ldERldiwgeGVuZGV2 KTsKICAgICBuZXRfdHhfcGFja2V0cyhuZXRkZXYpOwogICAgIHFlbXVfZmx1c2hfcXVldWVkX3Bh Y2tldHMocWVtdV9nZXRfcXVldWUobmV0ZGV2LT5uaWMpKTsKIH0KIAotc3RhdGljIGludCBuZXRf ZnJlZShzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCitzdGF0aWMgaW50IG5ldF9mcmVlKHN0cnVj dCBYZW5MZWdhY3lEZXZpY2UgKnhlbmRldikKIHsKICAgICBzdHJ1Y3QgWGVuTmV0RGV2ICpuZXRk ZXYgPSBjb250YWluZXJfb2YoeGVuZGV2LCBzdHJ1Y3QgWGVuTmV0RGV2LCB4ZW5kZXYpOwogCmRp ZmYgLS1naXQgYS9ody91c2IveGVuLXVzYi5jIGIvaHcvdXNiL3hlbi11c2IuYwppbmRleCA1YjJl MjFlLi45YjJkYTZlIDEwMDY0NAotLS0gYS9ody91c2IveGVuLXVzYi5jCisrKyBiL2h3L3VzYi94 ZW4tdXNiLmMKQEAgLTI3LDcgKzI3LDcgQEAKICNpbmNsdWRlICJxZW11L29wdGlvbi5oIgogI2lu Y2x1ZGUgImh3L3N5c2J1cy5oIgogI2luY2x1ZGUgImh3L3VzYi5oIgotI2luY2x1ZGUgImh3L3hl bi94ZW5fYmFja2VuZC5oIgorI2luY2x1ZGUgImh3L3hlbi94ZW4tbGVnYWN5LWJhY2tlbmQuaCIK ICNpbmNsdWRlICJtb25pdG9yL3FkZXYuaCIKICNpbmNsdWRlICJxYXBpL3FtcC9xZGljdC5oIgog I2luY2x1ZGUgInFhcGkvcW1wL3FzdHJpbmcuaCIKQEAgLTk5LDcgKzk5LDcgQEAgc3RydWN0IHVz YmJhY2tfaG90cGx1ZyB7CiB9OwogCiBzdHJ1Y3QgdXNiYmFja19pbmZvIHsKLSAgICBzdHJ1Y3Qg WGVuRGV2aWNlICAgICAgICAgeGVuZGV2OyAgLyogbXVzdCBiZSBmaXJzdCAqLworICAgIHN0cnVj dCBYZW5MZWdhY3lEZXZpY2UgICAgICAgICB4ZW5kZXY7ICAvKiBtdXN0IGJlIGZpcnN0ICovCiAg ICAgVVNCQnVzICAgICAgICAgICAgICAgICAgIGJ1czsKICAgICB2b2lkICAgICAgICAgICAgICAg ICAgICAgKnVyYl9zcmluZzsKICAgICB2b2lkICAgICAgICAgICAgICAgICAgICAgKmNvbm5fc3Jp bmc7CkBAIC0xNDIsNyArMTQyLDcgQEAgc3RhdGljIGludCB1c2JiYWNrX2dudHRhYl9tYXAoc3Ry dWN0IHVzYmJhY2tfcmVxICp1c2JiYWNrX3JlcSkKICAgICB1bnNpZ25lZCBpbnQgbnJfc2Vncywg aSwgcHJvdDsKICAgICB1aW50MzJfdCByZWZbVVNCSUZfTUFYX1NFR01FTlRTX1BFUl9SRVFVRVNU XTsKICAgICBzdHJ1Y3QgdXNiYmFja19pbmZvICp1c2JpZiA9IHVzYmJhY2tfcmVxLT51c2JpZjsK LSAgICBzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYgPSAmdXNiaWYtPnhlbmRldjsKKyAgICBzdHJ1 Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYgPSAmdXNiaWYtPnhlbmRldjsKICAgICBzdHJ1Y3Qg dXNiaWZfcmVxdWVzdF9zZWdtZW50ICpzZWc7CiAgICAgdm9pZCAqYWRkcjsKIApAQCAtMjIwLDcg KzIyMCw3IEBAIHN0YXRpYyBpbnQgdXNiYmFja19nbnR0YWJfbWFwKHN0cnVjdCB1c2JiYWNrX3Jl cSAqdXNiYmFja19yZXEpCiAKIHN0YXRpYyBpbnQgdXNiYmFja19pbml0X3BhY2tldChzdHJ1Y3Qg dXNiYmFja19yZXEgKnVzYmJhY2tfcmVxKQogewotICAgIHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRl diA9ICZ1c2JiYWNrX3JlcS0+dXNiaWYtPnhlbmRldjsKKyAgICBzdHJ1Y3QgWGVuTGVnYWN5RGV2 aWNlICp4ZW5kZXYgPSAmdXNiYmFja19yZXEtPnVzYmlmLT54ZW5kZXY7CiAgICAgVVNCUGFja2V0 ICpwYWNrZXQgPSAmdXNiYmFja19yZXEtPnBhY2tldDsKICAgICBVU0JEZXZpY2UgKmRldiA9IHVz YmJhY2tfcmVxLT5zdHViLT5kZXY7CiAgICAgVVNCRW5kcG9pbnQgKmVwOwpAQCAtMjc5LDcgKzI3 OSw3IEBAIHN0YXRpYyB2b2lkIHVzYmJhY2tfZG9fcmVzcG9uc2Uoc3RydWN0IHVzYmJhY2tfcmVx ICp1c2JiYWNrX3JlcSwgaW50MzJfdCBzdGF0dXMsCiB7CiAgICAgc3RydWN0IHVzYmJhY2tfaW5m byAqdXNiaWY7CiAgICAgc3RydWN0IHVzYmlmX3VyYl9yZXNwb25zZSAqcmVzOwotICAgIHN0cnVj dCBYZW5EZXZpY2UgKnhlbmRldjsKKyAgICBzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXY7 CiAgICAgdW5zaWduZWQgaW50IG5vdGlmeTsKIAogICAgIHVzYmlmID0gdXNiYmFja19yZXEtPnVz YmlmOwpAQCAtODI0LDcgKzgyNCw3IEBAIHN0YXRpYyB2b2lkIHVzYmJhY2tfcHJvY2Vzc19wb3J0 KHN0cnVjdCB1c2JiYWNrX2luZm8gKnVzYmlmLCB1bnNpZ25lZCBwb3J0KQogICAgIGdfZnJlZShi dXNpZCk7CiB9CiAKLXN0YXRpYyB2b2lkIHVzYmJhY2tfZGlzY29ubmVjdChzdHJ1Y3QgWGVuRGV2 aWNlICp4ZW5kZXYpCitzdGF0aWMgdm9pZCB1c2JiYWNrX2Rpc2Nvbm5lY3Qoc3RydWN0IFhlbkxl Z2FjeURldmljZSAqeGVuZGV2KQogewogICAgIHN0cnVjdCB1c2JiYWNrX2luZm8gKnVzYmlmOwog ICAgIHVuc2lnbmVkIGludCBpOwpAQCAtODUzLDcgKzg1Myw3IEBAIHN0YXRpYyB2b2lkIHVzYmJh Y2tfZGlzY29ubmVjdChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCiAgICAgVFJfQlVTKHhlbmRl diwgImZpbmlzaGVkXG4iKTsKIH0KIAotc3RhdGljIGludCB1c2JiYWNrX2Nvbm5lY3Qoc3RydWN0 IFhlbkRldmljZSAqeGVuZGV2KQorc3RhdGljIGludCB1c2JiYWNrX2Nvbm5lY3Qoc3RydWN0IFhl bkxlZ2FjeURldmljZSAqeGVuZGV2KQogewogICAgIHN0cnVjdCB1c2JiYWNrX2luZm8gKnVzYmlm OwogICAgIHN0cnVjdCB1c2JpZl91cmJfc3JpbmcgKnVyYl9zcmluZzsKQEAgLTkwOSw3ICs5MDks OCBAQCBzdGF0aWMgaW50IHVzYmJhY2tfY29ubmVjdChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYp CiAgICAgcmV0dXJuIDA7CiB9CiAKLXN0YXRpYyB2b2lkIHVzYmJhY2tfYmFja2VuZF9jaGFuZ2Vk KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgY29uc3QgY2hhciAqbm9kZSkKK3N0YXRpYyB2b2lk IHVzYmJhY2tfYmFja2VuZF9jaGFuZ2VkKHN0cnVjdCBYZW5MZWdhY3lEZXZpY2UgKnhlbmRldiwK KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKm5vZGUpCiB7 CiAgICAgc3RydWN0IHVzYmJhY2tfaW5mbyAqdXNiaWY7CiAgICAgdW5zaWduZWQgaW50IGk7CkBA IC05MjIsNyArOTIzLDcgQEAgc3RhdGljIHZvaWQgdXNiYmFja19iYWNrZW5kX2NoYW5nZWQoc3Ry dWN0IFhlbkRldmljZSAqeGVuZGV2LCBjb25zdCBjaGFyICpub2RlKQogICAgIH0KIH0KIAotc3Rh dGljIGludCB1c2JiYWNrX2luaXQoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQorc3RhdGljIGlu dCB1c2JiYWNrX2luaXQoc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2KQogewogICAgIHN0 cnVjdCB1c2JiYWNrX2luZm8gKnVzYmlmOwogCkBAIC0xMDAxLDcgKzEwMDIsNyBAQCBzdGF0aWMg VVNCUG9ydE9wcyB4ZW5fdXNiX3BvcnRfb3BzID0gewogc3RhdGljIFVTQkJ1c09wcyB4ZW5fdXNi X2J1c19vcHMgPSB7CiB9OwogCi1zdGF0aWMgdm9pZCB1c2JiYWNrX2FsbG9jKHN0cnVjdCBYZW5E ZXZpY2UgKnhlbmRldikKK3N0YXRpYyB2b2lkIHVzYmJhY2tfYWxsb2Moc3RydWN0IFhlbkxlZ2Fj eURldmljZSAqeGVuZGV2KQogewogICAgIHN0cnVjdCB1c2JiYWNrX2luZm8gKnVzYmlmOwogICAg IFVTQlBvcnQgKnA7CkBAIC0xMDI3LDcgKzEwMjgsNyBAQCBzdGF0aWMgdm9pZCB1c2JiYWNrX2Fs bG9jKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKICAgICB4ZW5fYmVfc2V0X21heF9ncmFudF9y ZWZzKHhlbmRldiwgbWF4X2dyYW50cyk7CiB9CiAKLXN0YXRpYyBpbnQgdXNiYmFja19mcmVlKHN0 cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKK3N0YXRpYyBpbnQgdXNiYmFja19mcmVlKHN0cnVjdCBY ZW5MZWdhY3lEZXZpY2UgKnhlbmRldikKIHsKICAgICBzdHJ1Y3QgdXNiYmFja19pbmZvICp1c2Jp ZjsKICAgICBzdHJ1Y3QgdXNiYmFja19yZXEgKnVzYmJhY2tfcmVxOwpAQCAtMTA2Niw3ICsxMDY3 LDcgQEAgc3RhdGljIGludCB1c2JiYWNrX2ZyZWUoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQog ICAgIHJldHVybiAwOwogfQogCi1zdGF0aWMgdm9pZCB1c2JiYWNrX2V2ZW50KHN0cnVjdCBYZW5E ZXZpY2UgKnhlbmRldikKK3N0YXRpYyB2b2lkIHVzYmJhY2tfZXZlbnQoc3RydWN0IFhlbkxlZ2Fj eURldmljZSAqeGVuZGV2KQogewogICAgIHN0cnVjdCB1c2JiYWNrX2luZm8gKnVzYmlmOwogCmRp ZmYgLS1naXQgYS9ody94ZW4vTWFrZWZpbGUub2JqcyBiL2h3L3hlbi9NYWtlZmlsZS5vYmpzCmlu ZGV4IDllYTVjNzMuLjNmNjRhNDQgMTAwNjQ0Ci0tLSBhL2h3L3hlbi9NYWtlZmlsZS5vYmpzCisr KyBiL2h3L3hlbi9NYWtlZmlsZS5vYmpzCkBAIC0xLDUgKzEsNSBAQAogIyB4ZW4gYmFja2VuZCBk cml2ZXIgc3VwcG9ydAotY29tbW9uLW9iai0kKENPTkZJR19YRU4pICs9IHhlbl9iYWNrZW5kLm8g eGVuX2RldmNvbmZpZy5vIHhlbl9wdmRldi5vIHhlbi1jb21tb24ubworY29tbW9uLW9iai0kKENP TkZJR19YRU4pICs9IHhlbi1sZWdhY3ktYmFja2VuZC5vIHhlbl9kZXZjb25maWcubyB4ZW5fcHZk ZXYubyB4ZW4tY29tbW9uLm8KIAogb2JqLSQoQ09ORklHX1hFTl9QQ0lfUEFTU1RIUk9VR0gpICs9 IHhlbi1ob3N0LXBjaS1kZXZpY2Uubwogb2JqLSQoQ09ORklHX1hFTl9QQ0lfUEFTU1RIUk9VR0gp ICs9IHhlbl9wdC5vIHhlbl9wdF9jb25maWdfaW5pdC5vIHhlbl9wdF9ncmFwaGljcy5vIHhlbl9w dF9tc2kubwpkaWZmIC0tZ2l0IGEvaHcveGVuL3hlbi1jb21tb24uYyBiL2h3L3hlbi94ZW4tY29t bW9uLmMKaW5kZXggNmVjMTRjNy4uZWYxMzBiMiAxMDA2NDQKLS0tIGEvaHcveGVuL3hlbi1jb21t b24uYworKysgYi9ody94ZW4veGVuLWNvbW1vbi5jCkBAIC0xMCw3ICsxMCw3IEBACiAKICNpbmNs dWRlICJxZW11L29zZGVwLmgiCiAjaW5jbHVkZSAicWVtdS9lcnJvci1yZXBvcnQuaCIKLSNpbmNs dWRlICJody94ZW4veGVuX2JhY2tlbmQuaCIKKyNpbmNsdWRlICJody94ZW4veGVuLWxlZ2FjeS1i YWNrZW5kLmgiCiAjaW5jbHVkZSAiY2hhcmRldi9jaGFyLmgiCiAjaW5jbHVkZSAic3lzZW11L2Fj Y2VsLmgiCiAjaW5jbHVkZSAibWlncmF0aW9uL21pc2MuaCIKZGlmZiAtLWdpdCBhL2h3L3hlbi94 ZW4tbGVnYWN5LWJhY2tlbmQuYyBiL2h3L3hlbi94ZW4tbGVnYWN5LWJhY2tlbmQuYwpuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wYzI2MDIzCi0tLSAvZGV2L251bGwKKysrIGIv aHcveGVuL3hlbi1sZWdhY3ktYmFja2VuZC5jCkBAIC0wLDAgKzEsODU0IEBACisvKgorICogIHhl biBiYWNrZW5kIGRyaXZlciBpbmZyYXN0cnVjdHVyZQorICogIChjKSAyMDA4IEdlcmQgSG9mZm1h bm4gPGtyYXhlbEByZWRoYXQuY29tPgorICoKKyAqICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0 d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yIG1vZGlmeQorICogIGl0IHVuZGVy IHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVk IGJ5CisgKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgdW5kZXIgdmVyc2lvbiAyIG9m IHRoZSBMaWNlbnNlLgorICoKKyAqICBUaGlzIHByb2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhl IGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKKyAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFO VFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgorICogIE1FUkNIQU5UQUJJ TElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUKKyAqICBH TlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3IgbW9yZSBkZXRhaWxzLgorICoKKyAqICBZb3Ug c2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGlj ZW5zZSBhbG9uZworICogIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHNlZSA8aHR0cDovL3d3 dy5nbnUub3JnL2xpY2Vuc2VzLz4uCisgKgorICogIENvbnRyaWJ1dGlvbnMgYWZ0ZXIgMjAxMi0w MS0xMyBhcmUgbGljZW5zZWQgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZQorICogIEdOVSBHUEwsIHZl cnNpb24gMiBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgorICovCisKKy8q CisgKiBUT0RPOiBhZGQgc29tZSB4ZW5idXMgLyB4ZW5zdG9yZSBjb25jZXB0cyBvdmVydmlldyBo ZXJlLgorICovCisKKyNpbmNsdWRlICJxZW11L29zZGVwLmgiCisjaW5jbHVkZSA8c3lzL3NpZ25h bC5oPgorCisjaW5jbHVkZSAiaHcvaHcuaCIKKyNpbmNsdWRlICJody9zeXNidXMuaCIKKyNpbmNs dWRlICJody9ib2FyZHMuaCIKKyNpbmNsdWRlICJxZW11L2xvZy5oIgorI2luY2x1ZGUgInFhcGkv ZXJyb3IuaCIKKyNpbmNsdWRlICJody94ZW4veGVuLWxlZ2FjeS1iYWNrZW5kLmgiCisjaW5jbHVk ZSAiaHcveGVuL3hlbl9wdmRldi5oIgorI2luY2x1ZGUgIm1vbml0b3IvcWRldi5oIgorCisjaW5j bHVkZSA8eGVuL2dyYW50X3RhYmxlLmg+CisKK0RldmljZVN0YXRlICp4ZW5fc3lzZGV2OworQnVz U3RhdGUgKnhlbl9zeXNidXM7CisKKy8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KKworLyogcHVibGljICovCitzdHJ1Y3Qg eHNfaGFuZGxlICp4ZW5zdG9yZTsKK2NvbnN0IGNoYXIgKnhlbl9wcm90b2NvbDsKKworLyogcHJp dmF0ZSAqLworc3RhdGljIGJvb2wgeGVuX2ZlYXR1cmVfZ3JhbnRfY29weTsKK3N0YXRpYyBpbnQg ZGVidWc7CisKK2ludCB4ZW5zdG9yZV93cml0ZV9iZV9zdHIoc3RydWN0IFhlbkxlZ2FjeURldmlj ZSAqeGVuZGV2LCBjb25zdCBjaGFyICpub2RlLAorICAgICAgICAgICAgICAgICAgICAgICAgICBj b25zdCBjaGFyICp2YWwpCit7CisgICAgcmV0dXJuIHhlbnN0b3JlX3dyaXRlX3N0cih4ZW5kZXYt PmJlLCBub2RlLCB2YWwpOworfQorCitpbnQgeGVuc3RvcmVfd3JpdGVfYmVfaW50KHN0cnVjdCBY ZW5MZWdhY3lEZXZpY2UgKnhlbmRldiwgY29uc3QgY2hhciAqbm9kZSwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgaW50IGl2YWwpCit7CisgICAgcmV0dXJuIHhlbnN0b3JlX3dyaXRlX2ludCh4 ZW5kZXYtPmJlLCBub2RlLCBpdmFsKTsKK30KKworaW50IHhlbnN0b3JlX3dyaXRlX2JlX2ludDY0 KHN0cnVjdCBYZW5MZWdhY3lEZXZpY2UgKnhlbmRldiwgY29uc3QgY2hhciAqbm9kZSwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgICBpbnQ2NF90IGl2YWwpCit7CisgICAgcmV0dXJuIHhlbnN0 b3JlX3dyaXRlX2ludDY0KHhlbmRldi0+YmUsIG5vZGUsIGl2YWwpOworfQorCitjaGFyICp4ZW5z dG9yZV9yZWFkX2JlX3N0cihzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYsIGNvbnN0IGNo YXIgKm5vZGUpCit7CisgICAgcmV0dXJuIHhlbnN0b3JlX3JlYWRfc3RyKHhlbmRldi0+YmUsIG5v ZGUpOworfQorCitpbnQgeGVuc3RvcmVfcmVhZF9iZV9pbnQoc3RydWN0IFhlbkxlZ2FjeURldmlj ZSAqeGVuZGV2LCBjb25zdCBjaGFyICpub2RlLAorICAgICAgICAgICAgICAgICAgICAgICAgIGlu dCAqaXZhbCkKK3sKKyAgICByZXR1cm4geGVuc3RvcmVfcmVhZF9pbnQoeGVuZGV2LT5iZSwgbm9k ZSwgaXZhbCk7Cit9CisKK2NoYXIgKnhlbnN0b3JlX3JlYWRfZmVfc3RyKHN0cnVjdCBYZW5MZWdh Y3lEZXZpY2UgKnhlbmRldiwgY29uc3QgY2hhciAqbm9kZSkKK3sKKyAgICByZXR1cm4geGVuc3Rv cmVfcmVhZF9zdHIoeGVuZGV2LT5mZSwgbm9kZSk7Cit9CisKK2ludCB4ZW5zdG9yZV9yZWFkX2Zl X2ludChzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYsIGNvbnN0IGNoYXIgKm5vZGUsCisg ICAgICAgICAgICAgICAgICAgICAgICAgaW50ICppdmFsKQoreworICAgIHJldHVybiB4ZW5zdG9y ZV9yZWFkX2ludCh4ZW5kZXYtPmZlLCBub2RlLCBpdmFsKTsKK30KKworaW50IHhlbnN0b3JlX3Jl YWRfZmVfdWludDY0KHN0cnVjdCBYZW5MZWdhY3lEZXZpY2UgKnhlbmRldiwgY29uc3QgY2hhciAq bm9kZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICB1aW50NjRfdCAqdXZhbCkKK3sKKyAg ICByZXR1cm4geGVuc3RvcmVfcmVhZF91aW50NjQoeGVuZGV2LT5mZSwgbm9kZSwgdXZhbCk7Cit9 CisKKy8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0gKi8KKworaW50IHhlbl9iZV9zZXRfc3RhdGUoc3RydWN0IFhlbkxlZ2FjeURl dmljZSAqeGVuZGV2LCBlbnVtIHhlbmJ1c19zdGF0ZSBzdGF0ZSkKK3sKKyAgICBpbnQgcmM7CisK KyAgICByYyA9IHhlbnN0b3JlX3dyaXRlX2JlX2ludCh4ZW5kZXYsICJzdGF0ZSIsIHN0YXRlKTsK KyAgICBpZiAocmMgPCAwKSB7CisgICAgICAgIHJldHVybiByYzsKKyAgICB9CisgICAgeGVuX3B2 X3ByaW50Zih4ZW5kZXYsIDEsICJiYWNrZW5kIHN0YXRlOiAlcyAtPiAlc1xuIiwKKyAgICAgICAg ICAgICAgICAgIHhlbmJ1c19zdHJzdGF0ZSh4ZW5kZXYtPmJlX3N0YXRlKSwgeGVuYnVzX3N0cnN0 YXRlKHN0YXRlKSk7CisgICAgeGVuZGV2LT5iZV9zdGF0ZSA9IHN0YXRlOworICAgIHJldHVybiAw OworfQorCit2b2lkIHhlbl9iZV9zZXRfbWF4X2dyYW50X3JlZnMoc3RydWN0IFhlbkxlZ2FjeURl dmljZSAqeGVuZGV2LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGlu dCBucl9yZWZzKQoreworICAgIGFzc2VydCh4ZW5kZXYtPm9wcy0+ZmxhZ3MgJiBERVZPUFNfRkxB R19ORUVEX0dOVERFVik7CisKKyAgICBpZiAoeGVuZ250dGFiX3NldF9tYXhfZ3JhbnRzKHhlbmRl di0+Z250dGFiZGV2LCBucl9yZWZzKSkgeworICAgICAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwg MCwgInhlbmdudHRhYl9zZXRfbWF4X2dyYW50cyBmYWlsZWQ6ICVzXG4iLAorICAgICAgICAgICAg ICAgICAgICAgIHN0cmVycm9yKGVycm5vKSk7CisgICAgfQorfQorCit2b2lkICp4ZW5fYmVfbWFw X2dyYW50X3JlZnMoc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2LCB1aW50MzJfdCAqcmVm cywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBpbnQgbnJfcmVmcywgaW50 IHByb3QpCit7CisgICAgdm9pZCAqcHRyOworCisgICAgYXNzZXJ0KHhlbmRldi0+b3BzLT5mbGFn cyAmIERFVk9QU19GTEFHX05FRURfR05UREVWKTsKKworICAgIHB0ciA9IHhlbmdudHRhYl9tYXBf ZG9tYWluX2dyYW50X3JlZnMoeGVuZGV2LT5nbnR0YWJkZXYsIG5yX3JlZnMsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4ZW5fZG9taWQsIHJlZnMsIHByb3QpOwor ICAgIGlmICghcHRyKSB7CisgICAgICAgIHhlbl9wdl9wcmludGYoeGVuZGV2LCAwLAorICAgICAg ICAgICAgICAgICAgICAgICJ4ZW5nbnR0YWJfbWFwX2RvbWFpbl9ncmFudF9yZWZzIGZhaWxlZDog JXNcbiIsCisgICAgICAgICAgICAgICAgICAgICAgc3RyZXJyb3IoZXJybm8pKTsKKyAgICB9CisK KyAgICByZXR1cm4gcHRyOworfQorCit2b2lkIHhlbl9iZV91bm1hcF9ncmFudF9yZWZzKHN0cnVj dCBYZW5MZWdhY3lEZXZpY2UgKnhlbmRldiwgdm9pZCAqcHRyLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICB1bnNpZ25lZCBpbnQgbnJfcmVmcykKK3sKKyAgICBhc3NlcnQoeGVuZGV2LT5v cHMtPmZsYWdzICYgREVWT1BTX0ZMQUdfTkVFRF9HTlRERVYpOworCisgICAgaWYgKHhlbmdudHRh Yl91bm1hcCh4ZW5kZXYtPmdudHRhYmRldiwgcHRyLCBucl9yZWZzKSkgeworICAgICAgICB4ZW5f cHZfcHJpbnRmKHhlbmRldiwgMCwgInhlbmdudHRhYl91bm1hcCBmYWlsZWQ6ICVzXG4iLAorICAg ICAgICAgICAgICAgICAgICAgIHN0cmVycm9yKGVycm5vKSk7CisgICAgfQorfQorCitzdGF0aWMg aW50IGNvbXBhdF9jb3B5X2dyYW50X3JlZnMoc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2 LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJvb2wgdG9fZG9tYWluLAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFhlbkdyYW50Q29weVNlZ21lbnQgc2Vnc1td LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGludCBucl9zZWdz KQoreworICAgIHVpbnQzMl90ICpyZWZzID0gZ19uZXcodWludDMyX3QsIG5yX3NlZ3MpOworICAg IGludCBwcm90ID0gdG9fZG9tYWluID8gUFJPVF9XUklURSA6IFBST1RfUkVBRDsKKyAgICB2b2lk ICpwYWdlczsKKyAgICB1bnNpZ25lZCBpbnQgaTsKKworICAgIGZvciAoaSA9IDA7IGkgPCBucl9z ZWdzOyBpKyspIHsKKyAgICAgICAgWGVuR3JhbnRDb3B5U2VnbWVudCAqc2VnID0gJnNlZ3NbaV07 CisKKyAgICAgICAgcmVmc1tpXSA9IHRvX2RvbWFpbiA/CisgICAgICAgICAgICBzZWctPmRlc3Qu Zm9yZWlnbi5yZWYgOiBzZWctPnNvdXJjZS5mb3JlaWduLnJlZjsKKyAgICB9CisKKyAgICBwYWdl cyA9IHhlbmdudHRhYl9tYXBfZG9tYWluX2dyYW50X3JlZnMoeGVuZGV2LT5nbnR0YWJkZXYsIG5y X3NlZ3MsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhlbl9k b21pZCwgcmVmcywgcHJvdCk7CisgICAgaWYgKCFwYWdlcykgeworICAgICAgICB4ZW5fcHZfcHJp bnRmKHhlbmRldiwgMCwKKyAgICAgICAgICAgICAgICAgICAgICAieGVuZ250dGFiX21hcF9kb21h aW5fZ3JhbnRfcmVmcyBmYWlsZWQ6ICVzXG4iLAorICAgICAgICAgICAgICAgICAgICAgIHN0cmVy cm9yKGVycm5vKSk7CisgICAgICAgIGdfZnJlZShyZWZzKTsKKyAgICAgICAgcmV0dXJuIC0xOwor ICAgIH0KKworICAgIGZvciAoaSA9IDA7IGkgPCBucl9zZWdzOyBpKyspIHsKKyAgICAgICAgWGVu R3JhbnRDb3B5U2VnbWVudCAqc2VnID0gJnNlZ3NbaV07CisgICAgICAgIHZvaWQgKnBhZ2UgPSBw YWdlcyArIChpICogWENfUEFHRV9TSVpFKTsKKworICAgICAgICBpZiAodG9fZG9tYWluKSB7Cisg ICAgICAgICAgICBtZW1jcHkocGFnZSArIHNlZy0+ZGVzdC5mb3JlaWduLm9mZnNldCwgc2VnLT5z b3VyY2UudmlydCwKKyAgICAgICAgICAgICAgICAgICBzZWctPmxlbik7CisgICAgICAgIH0gZWxz ZSB7CisgICAgICAgICAgICBtZW1jcHkoc2VnLT5kZXN0LnZpcnQsIHBhZ2UgKyBzZWctPnNvdXJj ZS5mb3JlaWduLm9mZnNldCwKKyAgICAgICAgICAgICAgICAgICBzZWctPmxlbik7CisgICAgICAg IH0KKyAgICB9CisKKyAgICBpZiAoeGVuZ250dGFiX3VubWFwKHhlbmRldi0+Z250dGFiZGV2LCBw YWdlcywgbnJfc2VncykpIHsKKyAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDAsICJ4ZW5n bnR0YWJfdW5tYXAgZmFpbGVkOiAlc1xuIiwKKyAgICAgICAgICAgICAgICAgICAgICBzdHJlcnJv cihlcnJubykpOworICAgIH0KKworICAgIGdfZnJlZShyZWZzKTsKKyAgICByZXR1cm4gMDsKK30K KworaW50IHhlbl9iZV9jb3B5X2dyYW50X3JlZnMoc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVu ZGV2LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgYm9vbCB0b19kb21haW4sCisgICAgICAg ICAgICAgICAgICAgICAgICAgICBYZW5HcmFudENvcHlTZWdtZW50IHNlZ3NbXSwKKyAgICAgICAg ICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGludCBucl9zZWdzKQoreworICAgIHhlbmdudHRh Yl9ncmFudF9jb3B5X3NlZ21lbnRfdCAqeGVuZ250dGFiX3NlZ3M7CisgICAgdW5zaWduZWQgaW50 IGk7CisgICAgaW50IHJjOworCisgICAgYXNzZXJ0KHhlbmRldi0+b3BzLT5mbGFncyAmIERFVk9Q U19GTEFHX05FRURfR05UREVWKTsKKworICAgIGlmICgheGVuX2ZlYXR1cmVfZ3JhbnRfY29weSkg eworICAgICAgICByZXR1cm4gY29tcGF0X2NvcHlfZ3JhbnRfcmVmcyh4ZW5kZXYsIHRvX2RvbWFp biwgc2VncywgbnJfc2Vncyk7CisgICAgfQorCisgICAgeGVuZ250dGFiX3NlZ3MgPSBnX25ldzAo eGVuZ250dGFiX2dyYW50X2NvcHlfc2VnbWVudF90LCBucl9zZWdzKTsKKworICAgIGZvciAoaSA9 IDA7IGkgPCBucl9zZWdzOyBpKyspIHsKKyAgICAgICAgWGVuR3JhbnRDb3B5U2VnbWVudCAqc2Vn ID0gJnNlZ3NbaV07CisgICAgICAgIHhlbmdudHRhYl9ncmFudF9jb3B5X3NlZ21lbnRfdCAqeGVu Z250dGFiX3NlZyA9ICZ4ZW5nbnR0YWJfc2Vnc1tpXTsKKworICAgICAgICBpZiAodG9fZG9tYWlu KSB7CisgICAgICAgICAgICB4ZW5nbnR0YWJfc2VnLT5mbGFncyA9IEdOVENPUFlfZGVzdF9ncmVm OworICAgICAgICAgICAgeGVuZ250dGFiX3NlZy0+ZGVzdC5mb3JlaWduLmRvbWlkID0geGVuX2Rv bWlkOworICAgICAgICAgICAgeGVuZ250dGFiX3NlZy0+ZGVzdC5mb3JlaWduLnJlZiA9IHNlZy0+ ZGVzdC5mb3JlaWduLnJlZjsKKyAgICAgICAgICAgIHhlbmdudHRhYl9zZWctPmRlc3QuZm9yZWln bi5vZmZzZXQgPSBzZWctPmRlc3QuZm9yZWlnbi5vZmZzZXQ7CisgICAgICAgICAgICB4ZW5nbnR0 YWJfc2VnLT5zb3VyY2UudmlydCA9IHNlZy0+c291cmNlLnZpcnQ7CisgICAgICAgIH0gZWxzZSB7 CisgICAgICAgICAgICB4ZW5nbnR0YWJfc2VnLT5mbGFncyA9IEdOVENPUFlfc291cmNlX2dyZWY7 CisgICAgICAgICAgICB4ZW5nbnR0YWJfc2VnLT5zb3VyY2UuZm9yZWlnbi5kb21pZCA9IHhlbl9k b21pZDsKKyAgICAgICAgICAgIHhlbmdudHRhYl9zZWctPnNvdXJjZS5mb3JlaWduLnJlZiA9IHNl Zy0+c291cmNlLmZvcmVpZ24ucmVmOworICAgICAgICAgICAgeGVuZ250dGFiX3NlZy0+c291cmNl LmZvcmVpZ24ub2Zmc2V0ID0KKyAgICAgICAgICAgICAgICBzZWctPnNvdXJjZS5mb3JlaWduLm9m ZnNldDsKKyAgICAgICAgICAgIHhlbmdudHRhYl9zZWctPmRlc3QudmlydCA9IHNlZy0+ZGVzdC52 aXJ0OworICAgICAgICB9CisKKyAgICAgICAgeGVuZ250dGFiX3NlZy0+bGVuID0gc2VnLT5sZW47 CisgICAgfQorCisgICAgcmMgPSB4ZW5nbnR0YWJfZ3JhbnRfY29weSh4ZW5kZXYtPmdudHRhYmRl diwgbnJfc2VncywgeGVuZ250dGFiX3NlZ3MpOworCisgICAgaWYgKHJjKSB7CisgICAgICAgIHhl bl9wdl9wcmludGYoeGVuZGV2LCAwLCAieGVuZ250dGFiX2NvcHkgZmFpbGVkOiAlc1xuIiwKKyAg ICAgICAgICAgICAgICAgICAgICBzdHJlcnJvcihlcnJubykpOworICAgIH0KKworICAgIGZvciAo aSA9IDA7IGkgPCBucl9zZWdzOyBpKyspIHsKKyAgICAgICAgeGVuZ250dGFiX2dyYW50X2NvcHlf c2VnbWVudF90ICp4ZW5nbnR0YWJfc2VnID0KKyAgICAgICAgICAgICZ4ZW5nbnR0YWJfc2Vnc1tp XTsKKworICAgICAgICBpZiAoeGVuZ250dGFiX3NlZy0+c3RhdHVzICE9IEdOVFNUX29rYXkpIHsK KyAgICAgICAgICAgIHhlbl9wdl9wcmludGYoeGVuZGV2LCAwLCAic2VnbWVudFsldV0gc3RhdHVz OiAlZFxuIiwgaSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgeGVuZ250dGFiX3NlZy0+c3Rh dHVzKTsKKyAgICAgICAgICAgIHJjID0gLTE7CisgICAgICAgIH0KKyAgICB9CisKKyAgICBnX2Zy ZWUoeGVuZ250dGFiX3NlZ3MpOworICAgIHJldHVybiByYzsKK30KKworLyoKKyAqIGdldCB4ZW4g YmFja2VuZCBkZXZpY2UsIGFsbG9jYXRlIGEgbmV3IG9uZSBpZiBpdCBkb2Vzbid0IGV4aXN0Lgor ICovCitzdGF0aWMgc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuX2JlX2dldF94ZW5kZXYoY29u c3QgY2hhciAqdHlwZSwgaW50IGRvbSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICBpbnQgZGV2LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHN0cnVjdCBYZW5EZXZPcHMgKm9wcykKK3sKKyAgICBzdHJ1Y3Qg WGVuTGVnYWN5RGV2aWNlICp4ZW5kZXY7CisKKyAgICB4ZW5kZXYgPSB4ZW5fcHZfZmluZF94ZW5k ZXYodHlwZSwgZG9tLCBkZXYpOworICAgIGlmICh4ZW5kZXYpIHsKKyAgICAgICAgcmV0dXJuIHhl bmRldjsKKyAgICB9CisKKyAgICAvKiBpbml0IG5ldyB4ZW5kZXYgKi8KKyAgICB4ZW5kZXYgPSBn X21hbGxvYzAob3BzLT5zaXplKTsKKyAgICBvYmplY3RfaW5pdGlhbGl6ZSgmeGVuZGV2LT5xZGV2 LCBvcHMtPnNpemUsIFRZUEVfWEVOQkFDS0VORCk7CisgICAgT0JKRUNUKHhlbmRldiktPmZyZWUg PSBnX2ZyZWU7CisgICAgcWRldl9zZXRfcGFyZW50X2J1cyhERVZJQ0UoeGVuZGV2KSwgeGVuX3N5 c2J1cyk7CisgICAgcWRldl9zZXRfaWQoREVWSUNFKHhlbmRldiksIGdfc3RyZHVwX3ByaW50Zigi eGVuLSVzLSVkIiwgdHlwZSwgZGV2KSk7CisgICAgcWRldl9pbml0X25vZmFpbChERVZJQ0UoeGVu ZGV2KSk7CisgICAgb2JqZWN0X3VucmVmKE9CSkVDVCh4ZW5kZXYpKTsKKworICAgIHhlbmRldi0+ dHlwZSAgPSB0eXBlOworICAgIHhlbmRldi0+ZG9tICAgPSBkb207CisgICAgeGVuZGV2LT5kZXYg ICA9IGRldjsKKyAgICB4ZW5kZXYtPm9wcyAgID0gb3BzOworCisgICAgc25wcmludGYoeGVuZGV2 LT5iZSwgc2l6ZW9mKHhlbmRldi0+YmUpLCAiYmFja2VuZC8lcy8lZC8lZCIsCisgICAgICAgICAg ICAgeGVuZGV2LT50eXBlLCB4ZW5kZXYtPmRvbSwgeGVuZGV2LT5kZXYpOworICAgIHNucHJpbnRm KHhlbmRldi0+bmFtZSwgc2l6ZW9mKHhlbmRldi0+bmFtZSksICIlcy0lZCIsCisgICAgICAgICAg ICAgeGVuZGV2LT50eXBlLCB4ZW5kZXYtPmRldik7CisKKyAgICB4ZW5kZXYtPmRlYnVnICAgICAg PSBkZWJ1ZzsKKyAgICB4ZW5kZXYtPmxvY2FsX3BvcnQgPSAtMTsKKworICAgIHhlbmRldi0+ZXZ0 Y2huZGV2ID0geGVuZXZ0Y2huX29wZW4oTlVMTCwgMCk7CisgICAgaWYgKHhlbmRldi0+ZXZ0Y2hu ZGV2ID09IE5VTEwpIHsKKyAgICAgICAgeGVuX3B2X3ByaW50ZihOVUxMLCAwLCAiY2FuJ3Qgb3Bl biBldnRjaG4gZGV2aWNlXG4iKTsKKyAgICAgICAgcWRldl91bnBsdWcoREVWSUNFKHhlbmRldiks IE5VTEwpOworICAgICAgICByZXR1cm4gTlVMTDsKKyAgICB9CisgICAgcWVtdV9zZXRfY2xvZXhl Yyh4ZW5ldnRjaG5fZmQoeGVuZGV2LT5ldnRjaG5kZXYpKTsKKworICAgIHhlbl9wdl9pbnNlcnRf eGVuZGV2KHhlbmRldik7CisKKyAgICBpZiAoeGVuZGV2LT5vcHMtPmFsbG9jKSB7CisgICAgICAg IHhlbmRldi0+b3BzLT5hbGxvYyh4ZW5kZXYpOworICAgIH0KKworICAgIHJldHVybiB4ZW5kZXY7 Cit9CisKKworLyoKKyAqIFN5bmMgaW50ZXJuYWwgZGF0YSBzdHJ1Y3R1cmVzIG9uIHhlbnN0b3Jl IHVwZGF0ZXMuCisgKiBOb2RlIHNwZWNpZmllcyB0aGUgY2hhbmdlZCBmaWVsZC4gIG5vZGUgPSBO VUxMIG1lYW5zCisgKiB1cGRhdGUgYWxsIGZpZWxkcyAodXNlZCBmb3IgaW5pdGlhbGl6YXRpb24p LgorICovCitzdGF0aWMgdm9pZCB4ZW5fYmVfYmFja2VuZF9jaGFuZ2VkKHN0cnVjdCBYZW5MZWdh Y3lEZXZpY2UgKnhlbmRldiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29u c3QgY2hhciAqbm9kZSkKK3sKKyAgICBpZiAobm9kZSA9PSBOVUxMICB8fCAgc3RyY21wKG5vZGUs ICJvbmxpbmUiKSA9PSAwKSB7CisgICAgICAgIGlmICh4ZW5zdG9yZV9yZWFkX2JlX2ludCh4ZW5k ZXYsICJvbmxpbmUiLCAmeGVuZGV2LT5vbmxpbmUpID09IC0xKSB7CisgICAgICAgICAgICB4ZW5k ZXYtPm9ubGluZSA9IDA7CisgICAgICAgIH0KKyAgICB9CisKKyAgICBpZiAobm9kZSkgeworICAg ICAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMiwgImJhY2tlbmQgdXBkYXRlOiAlc1xuIiwgbm9k ZSk7CisgICAgICAgIGlmICh4ZW5kZXYtPm9wcy0+YmFja2VuZF9jaGFuZ2VkKSB7CisgICAgICAg ICAgICB4ZW5kZXYtPm9wcy0+YmFja2VuZF9jaGFuZ2VkKHhlbmRldiwgbm9kZSk7CisgICAgICAg IH0KKyAgICB9Cit9CisKK3N0YXRpYyB2b2lkIHhlbl9iZV9mcm9udGVuZF9jaGFuZ2VkKHN0cnVj dCBYZW5MZWdhY3lEZXZpY2UgKnhlbmRldiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIGNvbnN0IGNoYXIgKm5vZGUpCit7CisgICAgaW50IGZlX3N0YXRlOworCisgICAgaWYg KG5vZGUgPT0gTlVMTCAgfHwgIHN0cmNtcChub2RlLCAic3RhdGUiKSA9PSAwKSB7CisgICAgICAg IGlmICh4ZW5zdG9yZV9yZWFkX2ZlX2ludCh4ZW5kZXYsICJzdGF0ZSIsICZmZV9zdGF0ZSkgPT0g LTEpIHsKKyAgICAgICAgICAgIGZlX3N0YXRlID0gWGVuYnVzU3RhdGVVbmtub3duOworICAgICAg ICB9CisgICAgICAgIGlmICh4ZW5kZXYtPmZlX3N0YXRlICE9IGZlX3N0YXRlKSB7CisgICAgICAg ICAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMSwgImZyb250ZW5kIHN0YXRlOiAlcyAtPiAlc1xu IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgeGVuYnVzX3N0cnN0YXRlKHhlbmRldi0+ZmVf c3RhdGUpLAorICAgICAgICAgICAgICAgICAgICAgICAgICB4ZW5idXNfc3Ryc3RhdGUoZmVfc3Rh dGUpKTsKKyAgICAgICAgfQorICAgICAgICB4ZW5kZXYtPmZlX3N0YXRlID0gZmVfc3RhdGU7Cisg ICAgfQorICAgIGlmIChub2RlID09IE5VTEwgIHx8ICBzdHJjbXAobm9kZSwgInByb3RvY29sIikg PT0gMCkgeworICAgICAgICBnX2ZyZWUoeGVuZGV2LT5wcm90b2NvbCk7CisgICAgICAgIHhlbmRl di0+cHJvdG9jb2wgPSB4ZW5zdG9yZV9yZWFkX2ZlX3N0cih4ZW5kZXYsICJwcm90b2NvbCIpOwor ICAgICAgICBpZiAoeGVuZGV2LT5wcm90b2NvbCkgeworICAgICAgICAgICAgeGVuX3B2X3ByaW50 Zih4ZW5kZXYsIDEsICJmcm9udGVuZCBwcm90b2NvbDogJXNcbiIsCisgICAgICAgICAgICAgICAg ICAgICAgICAgIHhlbmRldi0+cHJvdG9jb2wpOworICAgICAgICB9CisgICAgfQorCisgICAgaWYg KG5vZGUpIHsKKyAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDIsICJmcm9udGVuZCB1cGRh dGU6ICVzXG4iLCBub2RlKTsKKyAgICAgICAgaWYgKHhlbmRldi0+b3BzLT5mcm9udGVuZF9jaGFu Z2VkKSB7CisgICAgICAgICAgICB4ZW5kZXYtPm9wcy0+ZnJvbnRlbmRfY2hhbmdlZCh4ZW5kZXYs IG5vZGUpOworICAgICAgICB9CisgICAgfQorfQorCisvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCisvKiBDaGVjayBmb3Ig cG9zc2libGUgc3RhdGUgdHJhbnNpdGlvbnMgYW5kIHBlcmZvcm0gdGhlbS4gICAgICAgICovCisK Ky8qCisgKiBJbml0aWFsIHhlbmRldiBzZXR1cC4gIFJlYWQgZnJvbnRlbmQgcGF0aCwgcmVnaXN0 ZXIgd2F0Y2ggZm9yIGl0LgorICogU2hvdWxkIHN1Y2NlZWQgb25jZSB4ZW5kIGZpbmlzaGVkIHNl dHRpbmcgdXAgdGhlIGJhY2tlbmQgZGV2aWNlLgorICoKKyAqIEFsc28gc2V0cyBpbml0aWFsIHN0 YXRlICgtPiBJbml0aWFsaXppbmcpIHdoZW4gZG9uZS4gIFdoaWNoCisgKiBvbmx5IGFmZmVjdHMg dGhlIHhlbmRldi0+YmVfc3RhdGUgdmFyaWFibGUgYXMgeGVuYnVzIHNob3VsZAorICogYWxyZWFk eSBiZSBwdXQgaW50byB0aGF0IHN0YXRlIGJ5IHhlbmQuCisgKi8KK3N0YXRpYyBpbnQgeGVuX2Jl X3RyeV9zZXR1cChzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpCit7CisgICAgY2hhciB0 b2tlbltYRU5fQlVGU0laRV07CisgICAgaW50IGJlX3N0YXRlOworCisgICAgaWYgKHhlbnN0b3Jl X3JlYWRfYmVfaW50KHhlbmRldiwgInN0YXRlIiwgJmJlX3N0YXRlKSA9PSAtMSkgeworICAgICAg ICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMCwgInJlYWRpbmcgYmFja2VuZCBzdGF0ZSBmYWlsZWRc biIpOworICAgICAgICByZXR1cm4gLTE7CisgICAgfQorCisgICAgaWYgKGJlX3N0YXRlICE9IFhl bmJ1c1N0YXRlSW5pdGlhbGlzaW5nKSB7CisgICAgICAgIHhlbl9wdl9wcmludGYoeGVuZGV2LCAw LCAiaW5pdGlhbCBiYWNrZW5kIHN0YXRlIGlzIHdyb25nICglcylcbiIsCisgICAgICAgICAgICAg ICAgICAgICAgeGVuYnVzX3N0cnN0YXRlKGJlX3N0YXRlKSk7CisgICAgICAgIHJldHVybiAtMTsK KyAgICB9CisKKyAgICB4ZW5kZXYtPmZlID0geGVuc3RvcmVfcmVhZF9iZV9zdHIoeGVuZGV2LCAi ZnJvbnRlbmQiKTsKKyAgICBpZiAoeGVuZGV2LT5mZSA9PSBOVUxMKSB7CisgICAgICAgIHhlbl9w dl9wcmludGYoeGVuZGV2LCAwLCAicmVhZGluZyBmcm9udGVuZCBwYXRoIGZhaWxlZFxuIik7Cisg ICAgICAgIHJldHVybiAtMTsKKyAgICB9CisKKyAgICAvKiBzZXR1cCBmcm9udGVuZCB3YXRjaCAq LworICAgIHNucHJpbnRmKHRva2VuLCBzaXplb2YodG9rZW4pLCAiZmU6JXAiLCB4ZW5kZXYpOwor ICAgIGlmICgheHNfd2F0Y2goeGVuc3RvcmUsIHhlbmRldi0+ZmUsIHRva2VuKSkgeworICAgICAg ICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMCwgIndhdGNoaW5nIGZyb250ZW5kIHBhdGggKCVzKSBm YWlsZWRcbiIsCisgICAgICAgICAgICAgICAgICAgICAgeGVuZGV2LT5mZSk7CisgICAgICAgIHJl dHVybiAtMTsKKyAgICB9CisgICAgeGVuX2JlX3NldF9zdGF0ZSh4ZW5kZXYsIFhlbmJ1c1N0YXRl SW5pdGlhbGlzaW5nKTsKKworICAgIHhlbl9iZV9iYWNrZW5kX2NoYW5nZWQoeGVuZGV2LCBOVUxM KTsKKyAgICB4ZW5fYmVfZnJvbnRlbmRfY2hhbmdlZCh4ZW5kZXYsIE5VTEwpOworICAgIHJldHVy biAwOworfQorCisvKgorICogVHJ5IGluaXRpYWxpemUgeGVuZGV2LiAgUHJlcGFyZSBldmVyeXRo aW5nIHRoZSBiYWNrZW5kIGNhbiBkbworICogd2l0aG91dCBzeW5jaHJvbml6aW5nIHdpdGggdGhl IGZyb250ZW5kLiAgRmFrZXMgaG90cGx1Zy1zdGF0dXMuICBObworICogaG90cGx1ZyBpbnZvbHZl ZCBoZXJlIGJlY2F1c2UgdGhpcyBpcyBhYm91dCB1c2Vyc3BhY2UgZHJpdmVycywgdGh1cworICog dGhlcmUgYXJlIGtlcm5lbCBiYWNrZW5kIGRldmljZXMgd2hpY2ggY291bGQgaW52b2tlIGhvdHBs dWcuCisgKgorICogR29lcyB0byBJbml0V2FpdCBvbiBzdWNjZXNzLgorICovCitzdGF0aWMgaW50 IHhlbl9iZV90cnlfaW5pdChzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpCit7CisgICAg aW50IHJjID0gMDsKKworICAgIGlmICgheGVuZGV2LT5vbmxpbmUpIHsKKyAgICAgICAgeGVuX3B2 X3ByaW50Zih4ZW5kZXYsIDEsICJub3Qgb25saW5lXG4iKTsKKyAgICAgICAgcmV0dXJuIC0xOwor ICAgIH0KKworICAgIGlmICh4ZW5kZXYtPm9wcy0+aW5pdCkgeworICAgICAgICByYyA9IHhlbmRl di0+b3BzLT5pbml0KHhlbmRldik7CisgICAgfQorICAgIGlmIChyYyAhPSAwKSB7CisgICAgICAg IHhlbl9wdl9wcmludGYoeGVuZGV2LCAxLCAiaW5pdCgpIGZhaWxlZFxuIik7CisgICAgICAgIHJl dHVybiByYzsKKyAgICB9CisKKyAgICB4ZW5zdG9yZV93cml0ZV9iZV9zdHIoeGVuZGV2LCAiaG90 cGx1Zy1zdGF0dXMiLCAiY29ubmVjdGVkIik7CisgICAgeGVuX2JlX3NldF9zdGF0ZSh4ZW5kZXYs IFhlbmJ1c1N0YXRlSW5pdFdhaXQpOworICAgIHJldHVybiAwOworfQorCisvKgorICogVHJ5IHRv IGluaXRpYWxpc2UgeGVuZGV2LiAgRGVwZW5kcyBvbiB0aGUgZnJvbnRlbmQgYmVpbmcgcmVhZHkK KyAqIGZvciBpdCAoc2hhcmVkIHJpbmcgYW5kIGV2dGNobiBpbmZvIGluIHhlbnN0b3JlLCBzdGF0 ZSBiZWluZworICogSW5pdGlhbGlzZWQgb3IgQ29ubmVjdGVkKS4KKyAqCisgKiBHb2VzIHRvIENv bm5lY3RlZCBvbiBzdWNjZXNzLgorICovCitzdGF0aWMgaW50IHhlbl9iZV90cnlfaW5pdGlhbGlz ZShzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpCit7CisgICAgaW50IHJjID0gMDsKKwor ICAgIGlmICh4ZW5kZXYtPmZlX3N0YXRlICE9IFhlbmJ1c1N0YXRlSW5pdGlhbGlzZWQgICYmCisg ICAgICAgIHhlbmRldi0+ZmVfc3RhdGUgIT0gWGVuYnVzU3RhdGVDb25uZWN0ZWQpIHsKKyAgICAg ICAgaWYgKHhlbmRldi0+b3BzLT5mbGFncyAmIERFVk9QU19GTEFHX0lHTk9SRV9TVEFURSkgewor ICAgICAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDIsICJmcm9udGVuZCBub3QgcmVhZHks IGlnbm9yaW5nXG4iKTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIHhlbl9wdl9wcmlu dGYoeGVuZGV2LCAyLCAiZnJvbnRlbmQgbm90IHJlYWR5ICh5ZXQpXG4iKTsKKyAgICAgICAgICAg IHJldHVybiAtMTsKKyAgICAgICAgfQorICAgIH0KKworICAgIGlmICh4ZW5kZXYtPm9wcy0+Zmxh Z3MgJiBERVZPUFNfRkxBR19ORUVEX0dOVERFVikgeworICAgICAgICB4ZW5kZXYtPmdudHRhYmRl diA9IHhlbmdudHRhYl9vcGVuKE5VTEwsIDApOworICAgICAgICBpZiAoeGVuZGV2LT5nbnR0YWJk ZXYgPT0gTlVMTCkgeworICAgICAgICAgICAgeGVuX3B2X3ByaW50ZihOVUxMLCAwLCAiY2FuJ3Qg b3BlbiBnbnR0YWIgZGV2aWNlXG4iKTsKKyAgICAgICAgICAgIHJldHVybiAtMTsKKyAgICAgICAg fQorICAgIH0gZWxzZSB7CisgICAgICAgIHhlbmRldi0+Z250dGFiZGV2ID0gTlVMTDsKKyAgICB9 CisKKyAgICBpZiAoeGVuZGV2LT5vcHMtPmluaXRpYWxpc2UpIHsKKyAgICAgICAgcmMgPSB4ZW5k ZXYtPm9wcy0+aW5pdGlhbGlzZSh4ZW5kZXYpOworICAgIH0KKyAgICBpZiAocmMgIT0gMCkgewor ICAgICAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMCwgImluaXRpYWxpc2UoKSBmYWlsZWRcbiIp OworICAgICAgICByZXR1cm4gcmM7CisgICAgfQorCisgICAgeGVuX2JlX3NldF9zdGF0ZSh4ZW5k ZXYsIFhlbmJ1c1N0YXRlQ29ubmVjdGVkKTsKKyAgICByZXR1cm4gMDsKK30KKworLyoKKyAqIFRy eSB0byBsZXQgeGVuZGV2IGtub3cgdGhhdCBpdCBpcyBjb25uZWN0ZWQuICBEZXBlbmRzIG9uIHRo ZQorICogZnJvbnRlbmQgYmVpbmcgQ29ubmVjdGVkLiAgTm90ZSB0aGF0IHRoaXMgbWF5IGJlIGNh bGxlZCBtb3JlCisgKiB0aGFuIG9uY2Ugc2luY2UgdGhlIGJhY2tlbmQgc3RhdGUgaXMgbm90IG1v ZGlmaWVkLgorICovCitzdGF0aWMgdm9pZCB4ZW5fYmVfdHJ5X2Nvbm5lY3RlZChzdHJ1Y3QgWGVu TGVnYWN5RGV2aWNlICp4ZW5kZXYpCit7CisgICAgaWYgKCF4ZW5kZXYtPm9wcy0+Y29ubmVjdGVk KSB7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBpZiAoeGVuZGV2LT5mZV9zdGF0ZSAh PSBYZW5idXNTdGF0ZUNvbm5lY3RlZCkgeworICAgICAgICBpZiAoeGVuZGV2LT5vcHMtPmZsYWdz ICYgREVWT1BTX0ZMQUdfSUdOT1JFX1NUQVRFKSB7CisgICAgICAgICAgICB4ZW5fcHZfcHJpbnRm KHhlbmRldiwgMiwgImZyb250ZW5kIG5vdCByZWFkeSwgaWdub3JpbmdcbiIpOworICAgICAgICB9 IGVsc2UgeworICAgICAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDIsICJmcm9udGVuZCBu b3QgcmVhZHkgKHlldClcbiIpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAg fQorCisgICAgeGVuZGV2LT5vcHMtPmNvbm5lY3RlZCh4ZW5kZXYpOworfQorCisvKgorICogVGVh cmRvd24gY29ubmVjdGlvbi4KKyAqCisgKiBHb2VzIHRvIENsb3NlZCB3aGVuIGRvbmUuCisgKi8K K3N0YXRpYyB2b2lkIHhlbl9iZV9kaXNjb25uZWN0KHN0cnVjdCBYZW5MZWdhY3lEZXZpY2UgKnhl bmRldiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVudW0geGVuYnVzX3N0YXRlIHN0 YXRlKQoreworICAgIGlmICh4ZW5kZXYtPmJlX3N0YXRlICE9IFhlbmJ1c1N0YXRlQ2xvc2luZyAm JgorICAgICAgICB4ZW5kZXYtPmJlX3N0YXRlICE9IFhlbmJ1c1N0YXRlQ2xvc2VkICAmJgorICAg ICAgICB4ZW5kZXYtPm9wcy0+ZGlzY29ubmVjdCkgeworICAgICAgICB4ZW5kZXYtPm9wcy0+ZGlz Y29ubmVjdCh4ZW5kZXYpOworICAgIH0KKyAgICBpZiAoeGVuZGV2LT5nbnR0YWJkZXYpIHsKKyAg ICAgICAgeGVuZ250dGFiX2Nsb3NlKHhlbmRldi0+Z250dGFiZGV2KTsKKyAgICAgICAgeGVuZGV2 LT5nbnR0YWJkZXYgPSBOVUxMOworICAgIH0KKyAgICBpZiAoeGVuZGV2LT5iZV9zdGF0ZSAhPSBz dGF0ZSkgeworICAgICAgICB4ZW5fYmVfc2V0X3N0YXRlKHhlbmRldiwgc3RhdGUpOworICAgIH0K K30KKworLyoKKyAqIFRyeSB0byByZXNldCB4ZW5kZXYsIGZvciByZWNvbm5lY3Rpb24gYnkgYW5v dGhlciBmcm9udGVuZCBpbnN0YW5jZS4KKyAqLworc3RhdGljIGludCB4ZW5fYmVfdHJ5X3Jlc2V0 KHN0cnVjdCBYZW5MZWdhY3lEZXZpY2UgKnhlbmRldikKK3sKKyAgICBpZiAoeGVuZGV2LT5mZV9z dGF0ZSAhPSBYZW5idXNTdGF0ZUluaXRpYWxpc2luZykgeworICAgICAgICByZXR1cm4gLTE7Cisg ICAgfQorCisgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDEsICJkZXZpY2UgcmVzZXQgKGZvciBy ZS1jb25uZWN0KVxuIik7CisgICAgeGVuX2JlX3NldF9zdGF0ZSh4ZW5kZXYsIFhlbmJ1c1N0YXRl SW5pdGlhbGlzaW5nKTsKKyAgICByZXR1cm4gMDsKK30KKworLyoKKyAqIHN0YXRlIGNoYW5nZSBk aXNwYXRjaGVyIGZ1bmN0aW9uCisgKi8KK3ZvaWQgeGVuX2JlX2NoZWNrX3N0YXRlKHN0cnVjdCBY ZW5MZWdhY3lEZXZpY2UgKnhlbmRldikKK3sKKyAgICBpbnQgcmMgPSAwOworCisgICAgLyogZnJv bnRlbmQgbWF5IHJlcXVlc3Qgc2h1dGRvd24gZnJvbSBhbG1vc3QgYW55d2hlcmUgKi8KKyAgICBp ZiAoeGVuZGV2LT5mZV9zdGF0ZSA9PSBYZW5idXNTdGF0ZUNsb3NpbmcgfHwKKyAgICAgICAgeGVu ZGV2LT5mZV9zdGF0ZSA9PSBYZW5idXNTdGF0ZUNsb3NlZCkgeworICAgICAgICB4ZW5fYmVfZGlz Y29ubmVjdCh4ZW5kZXYsIHhlbmRldi0+ZmVfc3RhdGUpOworICAgICAgICByZXR1cm47CisgICAg fQorCisgICAgLyogY2hlY2sgZm9yIHBvc3NpYmxlIGJhY2tlbmQgc3RhdGUgdHJhbnNpdGlvbnMg Ki8KKyAgICBmb3IgKDs7KSB7CisgICAgICAgIHN3aXRjaCAoeGVuZGV2LT5iZV9zdGF0ZSkgewor ICAgICAgICBjYXNlIFhlbmJ1c1N0YXRlVW5rbm93bjoKKyAgICAgICAgICAgIHJjID0geGVuX2Jl X3RyeV9zZXR1cCh4ZW5kZXYpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgWGVu YnVzU3RhdGVJbml0aWFsaXNpbmc6CisgICAgICAgICAgICByYyA9IHhlbl9iZV90cnlfaW5pdCh4 ZW5kZXYpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgWGVuYnVzU3RhdGVJbml0 V2FpdDoKKyAgICAgICAgICAgIHJjID0geGVuX2JlX3RyeV9pbml0aWFsaXNlKHhlbmRldik7Cisg ICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSBYZW5idXNTdGF0ZUNvbm5lY3RlZDoKKyAg ICAgICAgICAgIC8qIHhlbmRldi0+YmVfc3RhdGUgZG9lc24ndCBjaGFuZ2UgKi8KKyAgICAgICAg ICAgIHhlbl9iZV90cnlfY29ubmVjdGVkKHhlbmRldik7CisgICAgICAgICAgICByYyA9IC0xOwor ICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgWGVuYnVzU3RhdGVDbG9zZWQ6CisgICAg ICAgICAgICByYyA9IHhlbl9iZV90cnlfcmVzZXQoeGVuZGV2KTsKKyAgICAgICAgICAgIGJyZWFr OworICAgICAgICBkZWZhdWx0OgorICAgICAgICAgICAgcmMgPSAtMTsKKyAgICAgICAgfQorICAg ICAgICBpZiAocmMgIT0gMCkgeworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICB9 Cit9CisKKy8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0gKi8KKworc3RhdGljIGludCB4ZW5zdG9yZV9zY2FuKGNvbnN0IGNoYXIg KnR5cGUsIGludCBkb20sIHN0cnVjdCBYZW5EZXZPcHMgKm9wcykKK3sKKyAgICBzdHJ1Y3QgWGVu TGVnYWN5RGV2aWNlICp4ZW5kZXY7CisgICAgY2hhciBwYXRoW1hFTl9CVUZTSVpFXSwgdG9rZW5b WEVOX0JVRlNJWkVdOworICAgIGNoYXIgKipkZXYgPSBOVUxMOworICAgIHVuc2lnbmVkIGludCBj ZGV2LCBqOworCisgICAgLyogc2V0dXAgd2F0Y2ggKi8KKyAgICBzbnByaW50Zih0b2tlbiwgc2l6 ZW9mKHRva2VuKSwgImJlOiVwOiVkOiVwIiwgdHlwZSwgZG9tLCBvcHMpOworICAgIHNucHJpbnRm KHBhdGgsIHNpemVvZihwYXRoKSwgImJhY2tlbmQvJXMvJWQiLCB0eXBlLCBkb20pOworICAgIGlm ICgheHNfd2F0Y2goeGVuc3RvcmUsIHBhdGgsIHRva2VuKSkgeworICAgICAgICB4ZW5fcHZfcHJp bnRmKE5VTEwsIDAsICJ4ZW4gYmU6IHdhdGNoaW5nIGJhY2tlbmQgcGF0aCAoJXMpIGZhaWxlZFxu IiwKKyAgICAgICAgICAgICAgICAgICAgICBwYXRoKTsKKyAgICAgICAgcmV0dXJuIC0xOworICAg IH0KKworICAgIC8qIGxvb2sgZm9yIGJhY2tlbmRzICovCisgICAgZGV2ID0geHNfZGlyZWN0b3J5 KHhlbnN0b3JlLCAwLCBwYXRoLCAmY2Rldik7CisgICAgaWYgKCFkZXYpIHsKKyAgICAgICAgcmV0 dXJuIDA7CisgICAgfQorICAgIGZvciAoaiA9IDA7IGogPCBjZGV2OyBqKyspIHsKKyAgICAgICAg eGVuZGV2ID0geGVuX2JlX2dldF94ZW5kZXYodHlwZSwgZG9tLCBhdG9pKGRldltqXSksIG9wcyk7 CisgICAgICAgIGlmICh4ZW5kZXYgPT0gTlVMTCkgeworICAgICAgICAgICAgY29udGludWU7Cisg ICAgICAgIH0KKyAgICAgICAgeGVuX2JlX2NoZWNrX3N0YXRlKHhlbmRldik7CisgICAgfQorICAg IGZyZWUoZGV2KTsKKyAgICByZXR1cm4gMDsKK30KKwordm9pZCB4ZW5zdG9yZV91cGRhdGVfYmUo Y2hhciAqd2F0Y2gsIGNoYXIgKnR5cGUsIGludCBkb20sCisgICAgICAgICAgICAgICAgICAgICAg ICBzdHJ1Y3QgWGVuRGV2T3BzICpvcHMpCit7CisgICAgc3RydWN0IFhlbkxlZ2FjeURldmljZSAq eGVuZGV2OworICAgIGNoYXIgcGF0aFtYRU5fQlVGU0laRV0sICpiZXBhdGg7CisgICAgdW5zaWdu ZWQgaW50IGxlbiwgZGV2OworCisgICAgbGVuID0gc25wcmludGYocGF0aCwgc2l6ZW9mKHBhdGgp LCAiYmFja2VuZC8lcy8lZCIsIHR5cGUsIGRvbSk7CisgICAgaWYgKHN0cm5jbXAocGF0aCwgd2F0 Y2gsIGxlbikgIT0gMCkgeworICAgICAgICByZXR1cm47CisgICAgfQorICAgIGlmIChzc2NhbmYo d2F0Y2ggKyBsZW4sICIvJXUvJTI1NXMiLCAmZGV2LCBwYXRoKSAhPSAyKSB7CisgICAgICAgIHN0 cmNweShwYXRoLCAiIik7CisgICAgICAgIGlmIChzc2NhbmYod2F0Y2ggKyBsZW4sICIvJXUiLCAm ZGV2KSAhPSAxKSB7CisgICAgICAgICAgICBkZXYgPSAtMTsKKyAgICAgICAgfQorICAgIH0KKyAg ICBpZiAoZGV2ID09IC0xKSB7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICB4ZW5kZXYg PSB4ZW5fYmVfZ2V0X3hlbmRldih0eXBlLCBkb20sIGRldiwgb3BzKTsKKyAgICBpZiAoeGVuZGV2 ICE9IE5VTEwpIHsKKyAgICAgICAgYmVwYXRoID0geHNfcmVhZCh4ZW5zdG9yZSwgMCwgeGVuZGV2 LT5iZSwgJmxlbik7CisgICAgICAgIGlmIChiZXBhdGggPT0gTlVMTCkgeworICAgICAgICAgICAg eGVuX3B2X2RlbF94ZW5kZXYoeGVuZGV2KTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAg IGZyZWUoYmVwYXRoKTsKKyAgICAgICAgICAgIHhlbl9iZV9iYWNrZW5kX2NoYW5nZWQoeGVuZGV2 LCBwYXRoKTsKKyAgICAgICAgICAgIHhlbl9iZV9jaGVja19zdGF0ZSh4ZW5kZXYpOworICAgICAg ICB9CisgICAgfQorfQorCit2b2lkIHhlbnN0b3JlX3VwZGF0ZV9mZShjaGFyICp3YXRjaCwgc3Ry dWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2KQoreworICAgIGNoYXIgKm5vZGU7CisgICAgdW5z aWduZWQgaW50IGxlbjsKKworICAgIGxlbiA9IHN0cmxlbih4ZW5kZXYtPmZlKTsKKyAgICBpZiAo c3RybmNtcCh4ZW5kZXYtPmZlLCB3YXRjaCwgbGVuKSAhPSAwKSB7CisgICAgICAgIHJldHVybjsK KyAgICB9CisgICAgaWYgKHdhdGNoW2xlbl0gIT0gJy8nKSB7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisgICAgbm9kZSA9IHdhdGNoICsgbGVuICsgMTsKKworICAgIHhlbl9iZV9mcm9udGVuZF9j aGFuZ2VkKHhlbmRldiwgbm9kZSk7CisgICAgeGVuX2JlX2NoZWNrX3N0YXRlKHhlbmRldik7Cit9 CisvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLSAqLworCitpbnQgeGVuX2JlX2luaXQodm9pZCkKK3sKKyAgICB4ZW5n bnR0YWJfaGFuZGxlICpnbnR0YWJkZXY7CisKKyAgICB4ZW5zdG9yZSA9IHhzX2RhZW1vbl9vcGVu KCk7CisgICAgaWYgKCF4ZW5zdG9yZSkgeworICAgICAgICB4ZW5fcHZfcHJpbnRmKE5VTEwsIDAs ICJjYW4ndCBjb25uZWN0IHRvIHhlbnN0b3JlZFxuIik7CisgICAgICAgIHJldHVybiAtMTsKKyAg ICB9CisKKyAgICBxZW11X3NldF9mZF9oYW5kbGVyKHhzX2ZpbGVubyh4ZW5zdG9yZSksIHhlbnN0 b3JlX3VwZGF0ZSwgTlVMTCwgTlVMTCk7CisKKyAgICBpZiAoeGVuX3hjID09IE5VTEwgfHwgeGVu X2ZtZW0gPT0gTlVMTCkgeworICAgICAgICAvKiBDaGVjayBpZiB4ZW5faW5pdCgpIGhhdmUgYmVl biBjYWxsZWQgKi8KKyAgICAgICAgZ290byBlcnI7CisgICAgfQorCisgICAgZ250dGFiZGV2ID0g eGVuZ250dGFiX29wZW4oTlVMTCwgMCk7CisgICAgaWYgKGdudHRhYmRldiAhPSBOVUxMKSB7Cisg ICAgICAgIGlmICh4ZW5nbnR0YWJfZ3JhbnRfY29weShnbnR0YWJkZXYsIDAsIE5VTEwpID09IDAp IHsKKyAgICAgICAgICAgIHhlbl9mZWF0dXJlX2dyYW50X2NvcHkgPSB0cnVlOworICAgICAgICB9 CisgICAgICAgIHhlbmdudHRhYl9jbG9zZShnbnR0YWJkZXYpOworICAgIH0KKworICAgIHhlbl9z eXNkZXYgPSBxZGV2X2NyZWF0ZShOVUxMLCBUWVBFX1hFTlNZU0RFVik7CisgICAgcWRldl9pbml0 X25vZmFpbCh4ZW5fc3lzZGV2KTsKKyAgICB4ZW5fc3lzYnVzID0gcWJ1c19jcmVhdGUoVFlQRV9Y RU5TWVNCVVMsIERFVklDRSh4ZW5fc3lzZGV2KSwgInhlbi1zeXNidXMiKTsKKyAgICBxYnVzX3Nl dF9idXNfaG90cGx1Z19oYW5kbGVyKHhlbl9zeXNidXMsICZlcnJvcl9hYm9ydCk7CisKKyAgICBy ZXR1cm4gMDsKKworZXJyOgorICAgIHFlbXVfc2V0X2ZkX2hhbmRsZXIoeHNfZmlsZW5vKHhlbnN0 b3JlKSwgTlVMTCwgTlVMTCwgTlVMTCk7CisgICAgeHNfZGFlbW9uX2Nsb3NlKHhlbnN0b3JlKTsK KyAgICB4ZW5zdG9yZSA9IE5VTEw7CisKKyAgICByZXR1cm4gLTE7Cit9CisKK3N0YXRpYyB2b2lk IHhlbl9zZXRfZHluYW1pY19zeXNidXModm9pZCkKK3sKKyAgICBPYmplY3QgKm1hY2hpbmUgPSBx ZGV2X2dldF9tYWNoaW5lKCk7CisgICAgT2JqZWN0Q2xhc3MgKm9jID0gb2JqZWN0X2dldF9jbGFz cyhtYWNoaW5lKTsKKyAgICBNYWNoaW5lQ2xhc3MgKm1jID0gTUFDSElORV9DTEFTUyhvYyk7CisK KyAgICBtYWNoaW5lX2NsYXNzX2FsbG93X2R5bmFtaWNfc3lzYnVzX2RldihtYywgVFlQRV9YRU5T WVNERVYpOworfQorCitpbnQgeGVuX2JlX3JlZ2lzdGVyKGNvbnN0IGNoYXIgKnR5cGUsIHN0cnVj dCBYZW5EZXZPcHMgKm9wcykKK3sKKyAgICBjaGFyIHBhdGhbNTBdOworICAgIGludCByYzsKKwor ICAgIGlmIChvcHMtPmJhY2tlbmRfcmVnaXN0ZXIpIHsKKyAgICAgICAgcmMgPSBvcHMtPmJhY2tl bmRfcmVnaXN0ZXIoKTsKKyAgICAgICAgaWYgKHJjKSB7CisgICAgICAgICAgICByZXR1cm4gcmM7 CisgICAgICAgIH0KKyAgICB9CisKKyAgICBzbnByaW50ZihwYXRoLCBzaXplb2YocGF0aCksICJk ZXZpY2UtbW9kZWwvJXUvYmFja2VuZHMvJXMiLCB4ZW5fZG9taWQsCisgICAgICAgICAgICAgdHlw ZSk7CisgICAgeGVuc3RvcmVfbWtkaXIocGF0aCwgWFNfUEVSTV9OT05FKTsKKworICAgIHJldHVy biB4ZW5zdG9yZV9zY2FuKHR5cGUsIHhlbl9kb21pZCwgb3BzKTsKK30KKwordm9pZCB4ZW5fYmVf cmVnaXN0ZXJfY29tbW9uKHZvaWQpCit7CisgICAgeGVuX3NldF9keW5hbWljX3N5c2J1cygpOwor CisgICAgeGVuX2JlX3JlZ2lzdGVyKCJjb25zb2xlIiwgJnhlbl9jb25zb2xlX29wcyk7CisgICAg eGVuX2JlX3JlZ2lzdGVyKCJ2a2JkIiwgJnhlbl9rYmRtb3VzZV9vcHMpOworICAgIHhlbl9iZV9y ZWdpc3RlcigicWRpc2siLCAmeGVuX2Jsa2Rldl9vcHMpOworI2lmZGVmIENPTkZJR19WSVJURlMK KyAgICB4ZW5fYmVfcmVnaXN0ZXIoIjlwZnMiLCAmeGVuXzlwZnNfb3BzKTsKKyNlbmRpZgorI2lm ZGVmIENPTkZJR19VU0JfTElCVVNCCisgICAgeGVuX2JlX3JlZ2lzdGVyKCJxdXNiIiwgJnhlbl91 c2Jfb3BzKTsKKyNlbmRpZgorfQorCitpbnQgeGVuX2JlX2JpbmRfZXZ0Y2huKHN0cnVjdCBYZW5M ZWdhY3lEZXZpY2UgKnhlbmRldikKK3sKKyAgICBpZiAoeGVuZGV2LT5sb2NhbF9wb3J0ICE9IC0x KSB7CisgICAgICAgIHJldHVybiAwOworICAgIH0KKyAgICB4ZW5kZXYtPmxvY2FsX3BvcnQgPSB4 ZW5ldnRjaG5fYmluZF9pbnRlcmRvbWFpbgorICAgICAgICAoeGVuZGV2LT5ldnRjaG5kZXYsIHhl bmRldi0+ZG9tLCB4ZW5kZXYtPnJlbW90ZV9wb3J0KTsKKyAgICBpZiAoeGVuZGV2LT5sb2NhbF9w b3J0ID09IC0xKSB7CisgICAgICAgIHhlbl9wdl9wcmludGYoeGVuZGV2LCAwLCAieGVuZXZ0Y2hu X2JpbmRfaW50ZXJkb21haW4gZmFpbGVkXG4iKTsKKyAgICAgICAgcmV0dXJuIC0xOworICAgIH0K KyAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMiwgImJpbmQgZXZ0Y2huIHBvcnQgJWRcbiIsIHhl bmRldi0+bG9jYWxfcG9ydCk7CisgICAgcWVtdV9zZXRfZmRfaGFuZGxlcih4ZW5ldnRjaG5fZmQo eGVuZGV2LT5ldnRjaG5kZXYpLAorICAgICAgICAgICAgICAgICAgICAgICAgeGVuX3B2X2V2dGNo bl9ldmVudCwgTlVMTCwgeGVuZGV2KTsKKyAgICByZXR1cm4gMDsKK30KKworCitzdGF0aWMgUHJv cGVydHkgeGVuZGV2X3Byb3BlcnRpZXNbXSA9IHsKKyAgICBERUZJTkVfUFJPUF9FTkRfT0ZfTElT VCgpLAorfTsKKworc3RhdGljIHZvaWQgeGVuZGV2X2NsYXNzX2luaXQoT2JqZWN0Q2xhc3MgKmts YXNzLCB2b2lkICpkYXRhKQoreworICAgIERldmljZUNsYXNzICpkYyA9IERFVklDRV9DTEFTUyhr bGFzcyk7CisKKyAgICBkYy0+cHJvcHMgPSB4ZW5kZXZfcHJvcGVydGllczsKKyAgICBzZXRfYml0 KERFVklDRV9DQVRFR09SWV9NSVNDLCBkYy0+Y2F0ZWdvcmllcyk7CisgICAgLyogeGVuLWJhY2tl bmQgZGV2aWNlcyBjYW4gYmUgcGx1Z2dlZC91bnBsdWdnZWQgZHluYW1pY2FsbHkgKi8KKyAgICBk Yy0+dXNlcl9jcmVhdGFibGUgPSB0cnVlOworfQorCitzdGF0aWMgY29uc3QgVHlwZUluZm8geGVu ZGV2X3R5cGVfaW5mbyA9IHsKKyAgICAubmFtZSAgICAgICAgICA9IFRZUEVfWEVOQkFDS0VORCwK KyAgICAucGFyZW50ICAgICAgICA9IFRZUEVfWEVOU1lTREVWLAorICAgIC5jbGFzc19pbml0ICAg ID0geGVuZGV2X2NsYXNzX2luaXQsCisgICAgLmluc3RhbmNlX3NpemUgPSBzaXplb2Yoc3RydWN0 IFhlbkxlZ2FjeURldmljZSksCit9OworCitzdGF0aWMgdm9pZCB4ZW5fc3lzYnVzX2NsYXNzX2lu aXQoT2JqZWN0Q2xhc3MgKmtsYXNzLCB2b2lkICpkYXRhKQoreworICAgIEhvdHBsdWdIYW5kbGVy Q2xhc3MgKmhjID0gSE9UUExVR19IQU5ETEVSX0NMQVNTKGtsYXNzKTsKKworICAgIGhjLT51bnBs dWcgPSBxZGV2X3NpbXBsZV9kZXZpY2VfdW5wbHVnX2NiOworfQorCitzdGF0aWMgY29uc3QgVHlw ZUluZm8geGVuc3lzYnVzX2luZm8gPSB7CisgICAgLm5hbWUgICAgICAgPSBUWVBFX1hFTlNZU0JV UywKKyAgICAucGFyZW50ICAgICA9IFRZUEVfQlVTLAorICAgIC5jbGFzc19pbml0ID0geGVuX3N5 c2J1c19jbGFzc19pbml0LAorICAgIC5pbnRlcmZhY2VzID0gKEludGVyZmFjZUluZm9bXSkgewor ICAgICAgICB7IFRZUEVfSE9UUExVR19IQU5ETEVSIH0sCisgICAgICAgIHsgfQorICAgIH0KK307 CisKK3N0YXRpYyBpbnQgeGVuX3N5c2Rldl9pbml0KFN5c0J1c0RldmljZSAqZGV2KQoreworICAg IHJldHVybiAwOworfQorCitzdGF0aWMgUHJvcGVydHkgeGVuX3N5c2Rldl9wcm9wZXJ0aWVzW10g PSB7CisgICAgey8qIGVuZCBvZiBwcm9wZXJ0eSBsaXN0ICovfSwKK307CisKK3N0YXRpYyB2b2lk IHhlbl9zeXNkZXZfY2xhc3NfaW5pdChPYmplY3RDbGFzcyAqa2xhc3MsIHZvaWQgKmRhdGEpCit7 CisgICAgRGV2aWNlQ2xhc3MgKmRjID0gREVWSUNFX0NMQVNTKGtsYXNzKTsKKyAgICBTeXNCdXNE ZXZpY2VDbGFzcyAqayA9IFNZU19CVVNfREVWSUNFX0NMQVNTKGtsYXNzKTsKKworICAgIGstPmlu aXQgPSB4ZW5fc3lzZGV2X2luaXQ7CisgICAgZGMtPnByb3BzID0geGVuX3N5c2Rldl9wcm9wZXJ0 aWVzOworICAgIGRjLT5idXNfdHlwZSA9IFRZUEVfWEVOU1lTQlVTOworfQorCitzdGF0aWMgY29u c3QgVHlwZUluZm8geGVuc3lzZGV2X2luZm8gPSB7CisgICAgLm5hbWUgICAgICAgICAgPSBUWVBF X1hFTlNZU0RFViwKKyAgICAucGFyZW50ICAgICAgICA9IFRZUEVfU1lTX0JVU19ERVZJQ0UsCisg ICAgLmluc3RhbmNlX3NpemUgPSBzaXplb2YoU3lzQnVzRGV2aWNlKSwKKyAgICAuY2xhc3NfaW5p dCAgICA9IHhlbl9zeXNkZXZfY2xhc3NfaW5pdCwKK307CisKK3N0YXRpYyB2b2lkIHhlbmJlX3Jl Z2lzdGVyX3R5cGVzKHZvaWQpCit7CisgICAgdHlwZV9yZWdpc3Rlcl9zdGF0aWMoJnhlbnN5c2J1 c19pbmZvKTsKKyAgICB0eXBlX3JlZ2lzdGVyX3N0YXRpYygmeGVuc3lzZGV2X2luZm8pOworICAg IHR5cGVfcmVnaXN0ZXJfc3RhdGljKCZ4ZW5kZXZfdHlwZV9pbmZvKTsKK30KKwordHlwZV9pbml0 KHhlbmJlX3JlZ2lzdGVyX3R5cGVzKQpkaWZmIC0tZ2l0IGEvaHcveGVuL3hlbl9iYWNrZW5kLmMg Yi9ody94ZW4veGVuX2JhY2tlbmQuYwpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOWE4 ZTg3Ny4uMDAwMDAwMAotLS0gYS9ody94ZW4veGVuX2JhY2tlbmQuYworKysgL2Rldi9udWxsCkBA IC0xLDg0NSArMCwwIEBACi0vKgotICogIHhlbiBiYWNrZW5kIGRyaXZlciBpbmZyYXN0cnVjdHVy ZQotICogIChjKSAyMDA4IEdlcmQgSG9mZm1hbm4gPGtyYXhlbEByZWRoYXQuY29tPgotICoKLSAq ICBUaGlzIHByb2dyYW0gaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQg YW5kL29yIG1vZGlmeQotICogIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwg UHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5Ci0gKiAgdGhlIEZyZWUgU29mdHdhcmUgRm91 bmRhdGlvbjsgdW5kZXIgdmVyc2lvbiAyIG9mIHRoZSBMaWNlbnNlLgotICoKLSAqICBUaGlzIHBy b2dyYW0gaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwK LSAqICBidXQgV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3 YXJyYW50eSBvZgotICogIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIgUFVSUE9TRS4gIFNlZSB0aGUKLSAqICBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBmb3Ig bW9yZSBkZXRhaWxzLgotICoKLSAqICBZb3Ugc2hvdWxkIGhhdmUgcmVjZWl2ZWQgYSBjb3B5IG9m IHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSBhbG9uZwotICogIHdpdGggdGhpcyBwcm9n cmFtOyBpZiBub3QsIHNlZSA8aHR0cDovL3d3dy5nbnUub3JnL2xpY2Vuc2VzLz4uCi0gKgotICog IENvbnRyaWJ1dGlvbnMgYWZ0ZXIgMjAxMi0wMS0xMyBhcmUgbGljZW5zZWQgdW5kZXIgdGhlIHRl cm1zIG9mIHRoZQotICogIEdOVSBHUEwsIHZlcnNpb24gMiBvciAoYXQgeW91ciBvcHRpb24pIGFu eSBsYXRlciB2ZXJzaW9uLgotICovCi0KLS8qCi0gKiBUT0RPOiBhZGQgc29tZSB4ZW5idXMgLyB4 ZW5zdG9yZSBjb25jZXB0cyBvdmVydmlldyBoZXJlLgotICovCi0KLSNpbmNsdWRlICJxZW11L29z ZGVwLmgiCi0jaW5jbHVkZSA8c3lzL3NpZ25hbC5oPgotCi0jaW5jbHVkZSAiaHcvaHcuaCIKLSNp bmNsdWRlICJody9zeXNidXMuaCIKLSNpbmNsdWRlICJody9ib2FyZHMuaCIKLSNpbmNsdWRlICJx ZW11L2xvZy5oIgotI2luY2x1ZGUgInFhcGkvZXJyb3IuaCIKLSNpbmNsdWRlICJody94ZW4veGVu X2JhY2tlbmQuaCIKLSNpbmNsdWRlICJody94ZW4veGVuX3B2ZGV2LmgiCi0jaW5jbHVkZSAibW9u aXRvci9xZGV2LmgiCi0KLSNpbmNsdWRlIDx4ZW4vZ3JhbnRfdGFibGUuaD4KLQotRGV2aWNlU3Rh dGUgKnhlbl9zeXNkZXY7Ci1CdXNTdGF0ZSAqeGVuX3N5c2J1czsKLQotLyogLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwotCi0v KiBwdWJsaWMgKi8KLXN0cnVjdCB4c19oYW5kbGUgKnhlbnN0b3JlID0gTlVMTDsKLWNvbnN0IGNo YXIgKnhlbl9wcm90b2NvbDsKLQotLyogcHJpdmF0ZSAqLwotc3RhdGljIGJvb2wgeGVuX2ZlYXR1 cmVfZ3JhbnRfY29weTsKLXN0YXRpYyBpbnQgZGVidWc7Ci0KLWludCB4ZW5zdG9yZV93cml0ZV9i ZV9zdHIoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2LCBjb25zdCBjaGFyICpub2RlLCBjb25zdCBj aGFyICp2YWwpCi17Ci0gICAgcmV0dXJuIHhlbnN0b3JlX3dyaXRlX3N0cih4ZW5kZXYtPmJlLCBu b2RlLCB2YWwpOwotfQotCi1pbnQgeGVuc3RvcmVfd3JpdGVfYmVfaW50KHN0cnVjdCBYZW5EZXZp Y2UgKnhlbmRldiwgY29uc3QgY2hhciAqbm9kZSwgaW50IGl2YWwpCi17Ci0gICAgcmV0dXJuIHhl bnN0b3JlX3dyaXRlX2ludCh4ZW5kZXYtPmJlLCBub2RlLCBpdmFsKTsKLX0KLQotaW50IHhlbnN0 b3JlX3dyaXRlX2JlX2ludDY0KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgY29uc3QgY2hhciAq bm9kZSwgaW50NjRfdCBpdmFsKQotewotICAgIHJldHVybiB4ZW5zdG9yZV93cml0ZV9pbnQ2NCh4 ZW5kZXYtPmJlLCBub2RlLCBpdmFsKTsKLX0KLQotY2hhciAqeGVuc3RvcmVfcmVhZF9iZV9zdHIo c3RydWN0IFhlbkRldmljZSAqeGVuZGV2LCBjb25zdCBjaGFyICpub2RlKQotewotICAgIHJldHVy biB4ZW5zdG9yZV9yZWFkX3N0cih4ZW5kZXYtPmJlLCBub2RlKTsKLX0KLQotaW50IHhlbnN0b3Jl X3JlYWRfYmVfaW50KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgY29uc3QgY2hhciAqbm9kZSwg aW50ICppdmFsKQotewotICAgIHJldHVybiB4ZW5zdG9yZV9yZWFkX2ludCh4ZW5kZXYtPmJlLCBu b2RlLCBpdmFsKTsKLX0KLQotY2hhciAqeGVuc3RvcmVfcmVhZF9mZV9zdHIoc3RydWN0IFhlbkRl dmljZSAqeGVuZGV2LCBjb25zdCBjaGFyICpub2RlKQotewotICAgIHJldHVybiB4ZW5zdG9yZV9y ZWFkX3N0cih4ZW5kZXYtPmZlLCBub2RlKTsKLX0KLQotaW50IHhlbnN0b3JlX3JlYWRfZmVfaW50 KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgY29uc3QgY2hhciAqbm9kZSwgaW50ICppdmFsKQot ewotICAgIHJldHVybiB4ZW5zdG9yZV9yZWFkX2ludCh4ZW5kZXYtPmZlLCBub2RlLCBpdmFsKTsK LX0KLQotaW50IHhlbnN0b3JlX3JlYWRfZmVfdWludDY0KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRl diwgY29uc3QgY2hhciAqbm9kZSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICB1aW50NjRf dCAqdXZhbCkKLXsKLSAgICByZXR1cm4geGVuc3RvcmVfcmVhZF91aW50NjQoeGVuZGV2LT5mZSwg bm9kZSwgdXZhbCk7Ci19Ci0KLS8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KLQotaW50IHhlbl9iZV9zZXRfc3RhdGUoc3Ry dWN0IFhlbkRldmljZSAqeGVuZGV2LCBlbnVtIHhlbmJ1c19zdGF0ZSBzdGF0ZSkKLXsKLSAgICBp bnQgcmM7Ci0KLSAgICByYyA9IHhlbnN0b3JlX3dyaXRlX2JlX2ludCh4ZW5kZXYsICJzdGF0ZSIs IHN0YXRlKTsKLSAgICBpZiAocmMgPCAwKSB7Ci0gICAgICAgIHJldHVybiByYzsKLSAgICB9Ci0g ICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDEsICJiYWNrZW5kIHN0YXRlOiAlcyAtPiAlc1xuIiwK LSAgICAgICAgICAgICAgICAgIHhlbmJ1c19zdHJzdGF0ZSh4ZW5kZXYtPmJlX3N0YXRlKSwgeGVu YnVzX3N0cnN0YXRlKHN0YXRlKSk7Ci0gICAgeGVuZGV2LT5iZV9zdGF0ZSA9IHN0YXRlOwotICAg IHJldHVybiAwOwotfQotCi12b2lkIHhlbl9iZV9zZXRfbWF4X2dyYW50X3JlZnMoc3RydWN0IFhl bkRldmljZSAqeGVuZGV2LAotICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVk IGludCBucl9yZWZzKQotewotICAgIGFzc2VydCh4ZW5kZXYtPm9wcy0+ZmxhZ3MgJiBERVZPUFNf RkxBR19ORUVEX0dOVERFVik7Ci0KLSAgICBpZiAoeGVuZ250dGFiX3NldF9tYXhfZ3JhbnRzKHhl bmRldi0+Z250dGFiZGV2LCBucl9yZWZzKSkgewotICAgICAgICB4ZW5fcHZfcHJpbnRmKHhlbmRl diwgMCwgInhlbmdudHRhYl9zZXRfbWF4X2dyYW50cyBmYWlsZWQ6ICVzXG4iLAotICAgICAgICAg ICAgICAgICAgICAgIHN0cmVycm9yKGVycm5vKSk7Ci0gICAgfQotfQotCi12b2lkICp4ZW5fYmVf bWFwX2dyYW50X3JlZnMoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2LCB1aW50MzJfdCAqcmVmcywK LSAgICAgICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBpbnQgbnJfcmVmcywgaW50IHBy b3QpCi17Ci0gICAgdm9pZCAqcHRyOwotCi0gICAgYXNzZXJ0KHhlbmRldi0+b3BzLT5mbGFncyAm IERFVk9QU19GTEFHX05FRURfR05UREVWKTsKLQotICAgIHB0ciA9IHhlbmdudHRhYl9tYXBfZG9t YWluX2dyYW50X3JlZnMoeGVuZGV2LT5nbnR0YWJkZXYsIG5yX3JlZnMsCi0gICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4ZW5fZG9taWQsIHJlZnMsIHByb3QpOwotICAg IGlmICghcHRyKSB7Ci0gICAgICAgIHhlbl9wdl9wcmludGYoeGVuZGV2LCAwLAotICAgICAgICAg ICAgICAgICAgICAgICJ4ZW5nbnR0YWJfbWFwX2RvbWFpbl9ncmFudF9yZWZzIGZhaWxlZDogJXNc biIsCi0gICAgICAgICAgICAgICAgICAgICAgc3RyZXJyb3IoZXJybm8pKTsKLSAgICB9Ci0KLSAg ICByZXR1cm4gcHRyOwotfQotCi12b2lkIHhlbl9iZV91bm1hcF9ncmFudF9yZWZzKHN0cnVjdCBY ZW5EZXZpY2UgKnhlbmRldiwgdm9pZCAqcHRyLAotICAgICAgICAgICAgICAgICAgICAgICAgICAg ICB1bnNpZ25lZCBpbnQgbnJfcmVmcykKLXsKLSAgICBhc3NlcnQoeGVuZGV2LT5vcHMtPmZsYWdz ICYgREVWT1BTX0ZMQUdfTkVFRF9HTlRERVYpOwotCi0gICAgaWYgKHhlbmdudHRhYl91bm1hcCh4 ZW5kZXYtPmdudHRhYmRldiwgcHRyLCBucl9yZWZzKSkgewotICAgICAgICB4ZW5fcHZfcHJpbnRm KHhlbmRldiwgMCwgInhlbmdudHRhYl91bm1hcCBmYWlsZWQ6ICVzXG4iLAotICAgICAgICAgICAg ICAgICAgICAgIHN0cmVycm9yKGVycm5vKSk7Ci0gICAgfQotfQotCi1zdGF0aWMgaW50IGNvbXBh dF9jb3B5X2dyYW50X3JlZnMoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2LAotICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIGJvb2wgdG9fZG9tYWluLAotICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFhlbkdyYW50Q29weVNlZ21lbnQgc2Vnc1tdLAotICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGludCBucl9zZWdzKQotewotICAgIHVpbnQz Ml90ICpyZWZzID0gZ19uZXcodWludDMyX3QsIG5yX3NlZ3MpOwotICAgIGludCBwcm90ID0gdG9f ZG9tYWluID8gUFJPVF9XUklURSA6IFBST1RfUkVBRDsKLSAgICB2b2lkICpwYWdlczsKLSAgICB1 bnNpZ25lZCBpbnQgaTsKLQotICAgIGZvciAoaSA9IDA7IGkgPCBucl9zZWdzOyBpKyspIHsKLSAg ICAgICAgWGVuR3JhbnRDb3B5U2VnbWVudCAqc2VnID0gJnNlZ3NbaV07Ci0KLSAgICAgICAgcmVm c1tpXSA9IHRvX2RvbWFpbiA/Ci0gICAgICAgICAgICBzZWctPmRlc3QuZm9yZWlnbi5yZWYgOiBz ZWctPnNvdXJjZS5mb3JlaWduLnJlZjsKLSAgICB9Ci0KLSAgICBwYWdlcyA9IHhlbmdudHRhYl9t YXBfZG9tYWluX2dyYW50X3JlZnMoeGVuZGV2LT5nbnR0YWJkZXYsIG5yX3NlZ3MsCi0gICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhlbl9kb21pZCwgcmVmcywgcHJv dCk7Ci0gICAgaWYgKCFwYWdlcykgewotICAgICAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMCwK LSAgICAgICAgICAgICAgICAgICAgICAieGVuZ250dGFiX21hcF9kb21haW5fZ3JhbnRfcmVmcyBm YWlsZWQ6ICVzXG4iLAotICAgICAgICAgICAgICAgICAgICAgIHN0cmVycm9yKGVycm5vKSk7Ci0g ICAgICAgIGdfZnJlZShyZWZzKTsKLSAgICAgICAgcmV0dXJuIC0xOwotICAgIH0KLQotICAgIGZv ciAoaSA9IDA7IGkgPCBucl9zZWdzOyBpKyspIHsKLSAgICAgICAgWGVuR3JhbnRDb3B5U2VnbWVu dCAqc2VnID0gJnNlZ3NbaV07Ci0gICAgICAgIHZvaWQgKnBhZ2UgPSBwYWdlcyArIChpICogWENf UEFHRV9TSVpFKTsKLQotICAgICAgICBpZiAodG9fZG9tYWluKSB7Ci0gICAgICAgICAgICBtZW1j cHkocGFnZSArIHNlZy0+ZGVzdC5mb3JlaWduLm9mZnNldCwgc2VnLT5zb3VyY2UudmlydCwKLSAg ICAgICAgICAgICAgICAgICBzZWctPmxlbik7Ci0gICAgICAgIH0gZWxzZSB7Ci0gICAgICAgICAg ICBtZW1jcHkoc2VnLT5kZXN0LnZpcnQsIHBhZ2UgKyBzZWctPnNvdXJjZS5mb3JlaWduLm9mZnNl dCwKLSAgICAgICAgICAgICAgICAgICBzZWctPmxlbik7Ci0gICAgICAgIH0KLSAgICB9Ci0KLSAg ICBpZiAoeGVuZ250dGFiX3VubWFwKHhlbmRldi0+Z250dGFiZGV2LCBwYWdlcywgbnJfc2Vncykp IHsKLSAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDAsICJ4ZW5nbnR0YWJfdW5tYXAgZmFp bGVkOiAlc1xuIiwKLSAgICAgICAgICAgICAgICAgICAgICBzdHJlcnJvcihlcnJubykpOwotICAg IH0KLQotICAgIGdfZnJlZShyZWZzKTsKLSAgICByZXR1cm4gMDsKLX0KLQotaW50IHhlbl9iZV9j b3B5X2dyYW50X3JlZnMoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2LAotICAgICAgICAgICAgICAg ICAgICAgICAgICAgYm9vbCB0b19kb21haW4sCi0gICAgICAgICAgICAgICAgICAgICAgICAgICBY ZW5HcmFudENvcHlTZWdtZW50IHNlZ3NbXSwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgIHVu c2lnbmVkIGludCBucl9zZWdzKQotewotICAgIHhlbmdudHRhYl9ncmFudF9jb3B5X3NlZ21lbnRf dCAqeGVuZ250dGFiX3NlZ3M7Ci0gICAgdW5zaWduZWQgaW50IGk7Ci0gICAgaW50IHJjOwotCi0g ICAgYXNzZXJ0KHhlbmRldi0+b3BzLT5mbGFncyAmIERFVk9QU19GTEFHX05FRURfR05UREVWKTsK LQotICAgIGlmICgheGVuX2ZlYXR1cmVfZ3JhbnRfY29weSkgewotICAgICAgICByZXR1cm4gY29t cGF0X2NvcHlfZ3JhbnRfcmVmcyh4ZW5kZXYsIHRvX2RvbWFpbiwgc2VncywgbnJfc2Vncyk7Ci0g ICAgfQotCi0gICAgeGVuZ250dGFiX3NlZ3MgPSBnX25ldzAoeGVuZ250dGFiX2dyYW50X2NvcHlf c2VnbWVudF90LCBucl9zZWdzKTsKLQotICAgIGZvciAoaSA9IDA7IGkgPCBucl9zZWdzOyBpKysp IHsKLSAgICAgICAgWGVuR3JhbnRDb3B5U2VnbWVudCAqc2VnID0gJnNlZ3NbaV07Ci0gICAgICAg IHhlbmdudHRhYl9ncmFudF9jb3B5X3NlZ21lbnRfdCAqeGVuZ250dGFiX3NlZyA9ICZ4ZW5nbnR0 YWJfc2Vnc1tpXTsKLQotICAgICAgICBpZiAodG9fZG9tYWluKSB7Ci0gICAgICAgICAgICB4ZW5n bnR0YWJfc2VnLT5mbGFncyA9IEdOVENPUFlfZGVzdF9ncmVmOwotICAgICAgICAgICAgeGVuZ250 dGFiX3NlZy0+ZGVzdC5mb3JlaWduLmRvbWlkID0geGVuX2RvbWlkOwotICAgICAgICAgICAgeGVu Z250dGFiX3NlZy0+ZGVzdC5mb3JlaWduLnJlZiA9IHNlZy0+ZGVzdC5mb3JlaWduLnJlZjsKLSAg ICAgICAgICAgIHhlbmdudHRhYl9zZWctPmRlc3QuZm9yZWlnbi5vZmZzZXQgPSBzZWctPmRlc3Qu Zm9yZWlnbi5vZmZzZXQ7Ci0gICAgICAgICAgICB4ZW5nbnR0YWJfc2VnLT5zb3VyY2UudmlydCA9 IHNlZy0+c291cmNlLnZpcnQ7Ci0gICAgICAgIH0gZWxzZSB7Ci0gICAgICAgICAgICB4ZW5nbnR0 YWJfc2VnLT5mbGFncyA9IEdOVENPUFlfc291cmNlX2dyZWY7Ci0gICAgICAgICAgICB4ZW5nbnR0 YWJfc2VnLT5zb3VyY2UuZm9yZWlnbi5kb21pZCA9IHhlbl9kb21pZDsKLSAgICAgICAgICAgIHhl bmdudHRhYl9zZWctPnNvdXJjZS5mb3JlaWduLnJlZiA9IHNlZy0+c291cmNlLmZvcmVpZ24ucmVm OwotICAgICAgICAgICAgeGVuZ250dGFiX3NlZy0+c291cmNlLmZvcmVpZ24ub2Zmc2V0ID0KLSAg ICAgICAgICAgICAgICBzZWctPnNvdXJjZS5mb3JlaWduLm9mZnNldDsKLSAgICAgICAgICAgIHhl bmdudHRhYl9zZWctPmRlc3QudmlydCA9IHNlZy0+ZGVzdC52aXJ0OwotICAgICAgICB9Ci0KLSAg ICAgICAgeGVuZ250dGFiX3NlZy0+bGVuID0gc2VnLT5sZW47Ci0gICAgfQotCi0gICAgcmMgPSB4 ZW5nbnR0YWJfZ3JhbnRfY29weSh4ZW5kZXYtPmdudHRhYmRldiwgbnJfc2VncywgeGVuZ250dGFi X3NlZ3MpOwotCi0gICAgaWYgKHJjKSB7Ci0gICAgICAgIHhlbl9wdl9wcmludGYoeGVuZGV2LCAw LCAieGVuZ250dGFiX2NvcHkgZmFpbGVkOiAlc1xuIiwKLSAgICAgICAgICAgICAgICAgICAgICBz dHJlcnJvcihlcnJubykpOwotICAgIH0KLQotICAgIGZvciAoaSA9IDA7IGkgPCBucl9zZWdzOyBp KyspIHsKLSAgICAgICAgeGVuZ250dGFiX2dyYW50X2NvcHlfc2VnbWVudF90ICp4ZW5nbnR0YWJf c2VnID0KLSAgICAgICAgICAgICZ4ZW5nbnR0YWJfc2Vnc1tpXTsKLQotICAgICAgICBpZiAoeGVu Z250dGFiX3NlZy0+c3RhdHVzICE9IEdOVFNUX29rYXkpIHsKLSAgICAgICAgICAgIHhlbl9wdl9w cmludGYoeGVuZGV2LCAwLCAic2VnbWVudFsldV0gc3RhdHVzOiAlZFxuIiwgaSwKLSAgICAgICAg ICAgICAgICAgICAgICAgICAgeGVuZ250dGFiX3NlZy0+c3RhdHVzKTsKLSAgICAgICAgICAgIHJj ID0gLTE7Ci0gICAgICAgIH0KLSAgICB9Ci0KLSAgICBnX2ZyZWUoeGVuZ250dGFiX3NlZ3MpOwot ICAgIHJldHVybiByYzsKLX0KLQotLyoKLSAqIGdldCB4ZW4gYmFja2VuZCBkZXZpY2UsIGFsbG9j YXRlIGEgbmV3IG9uZSBpZiBpdCBkb2Vzbid0IGV4aXN0LgotICovCi1zdGF0aWMgc3RydWN0IFhl bkRldmljZSAqeGVuX2JlX2dldF94ZW5kZXYoY29uc3QgY2hhciAqdHlwZSwgaW50IGRvbSwgaW50 IGRldiwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3Qg WGVuRGV2T3BzICpvcHMpCi17Ci0gICAgc3RydWN0IFhlbkRldmljZSAqeGVuZGV2OwotCi0gICAg eGVuZGV2ID0geGVuX3B2X2ZpbmRfeGVuZGV2KHR5cGUsIGRvbSwgZGV2KTsKLSAgICBpZiAoeGVu ZGV2KSB7Ci0gICAgICAgIHJldHVybiB4ZW5kZXY7Ci0gICAgfQotCi0gICAgLyogaW5pdCBuZXcg eGVuZGV2ICovCi0gICAgeGVuZGV2ID0gZ19tYWxsb2MwKG9wcy0+c2l6ZSk7Ci0gICAgb2JqZWN0 X2luaXRpYWxpemUoJnhlbmRldi0+cWRldiwgb3BzLT5zaXplLCBUWVBFX1hFTkJBQ0tFTkQpOwot ICAgIE9CSkVDVCh4ZW5kZXYpLT5mcmVlID0gZ19mcmVlOwotICAgIHFkZXZfc2V0X3BhcmVudF9i dXMoREVWSUNFKHhlbmRldiksIHhlbl9zeXNidXMpOwotICAgIHFkZXZfc2V0X2lkKERFVklDRSh4 ZW5kZXYpLCBnX3N0cmR1cF9wcmludGYoInhlbi0lcy0lZCIsIHR5cGUsIGRldikpOwotICAgIHFk ZXZfaW5pdF9ub2ZhaWwoREVWSUNFKHhlbmRldikpOwotICAgIG9iamVjdF91bnJlZihPQkpFQ1Qo eGVuZGV2KSk7Ci0KLSAgICB4ZW5kZXYtPnR5cGUgID0gdHlwZTsKLSAgICB4ZW5kZXYtPmRvbSAg ID0gZG9tOwotICAgIHhlbmRldi0+ZGV2ICAgPSBkZXY7Ci0gICAgeGVuZGV2LT5vcHMgICA9IG9w czsKLQotICAgIHNucHJpbnRmKHhlbmRldi0+YmUsIHNpemVvZih4ZW5kZXYtPmJlKSwgImJhY2tl bmQvJXMvJWQvJWQiLAotICAgICAgICAgICAgIHhlbmRldi0+dHlwZSwgeGVuZGV2LT5kb20sIHhl bmRldi0+ZGV2KTsKLSAgICBzbnByaW50Zih4ZW5kZXYtPm5hbWUsIHNpemVvZih4ZW5kZXYtPm5h bWUpLCAiJXMtJWQiLAotICAgICAgICAgICAgIHhlbmRldi0+dHlwZSwgeGVuZGV2LT5kZXYpOwot Ci0gICAgeGVuZGV2LT5kZWJ1ZyAgICAgID0gZGVidWc7Ci0gICAgeGVuZGV2LT5sb2NhbF9wb3J0 ID0gLTE7Ci0KLSAgICB4ZW5kZXYtPmV2dGNobmRldiA9IHhlbmV2dGNobl9vcGVuKE5VTEwsIDAp OwotICAgIGlmICh4ZW5kZXYtPmV2dGNobmRldiA9PSBOVUxMKSB7Ci0gICAgICAgIHhlbl9wdl9w cmludGYoTlVMTCwgMCwgImNhbid0IG9wZW4gZXZ0Y2huIGRldmljZVxuIik7Ci0gICAgICAgIHFk ZXZfdW5wbHVnKERFVklDRSh4ZW5kZXYpLCBOVUxMKTsKLSAgICAgICAgcmV0dXJuIE5VTEw7Ci0g ICAgfQotICAgIHFlbXVfc2V0X2Nsb2V4ZWMoeGVuZXZ0Y2huX2ZkKHhlbmRldi0+ZXZ0Y2huZGV2 KSk7Ci0KLSAgICB4ZW5fcHZfaW5zZXJ0X3hlbmRldih4ZW5kZXYpOwotCi0gICAgaWYgKHhlbmRl di0+b3BzLT5hbGxvYykgewotICAgICAgICB4ZW5kZXYtPm9wcy0+YWxsb2MoeGVuZGV2KTsKLSAg ICB9Ci0KLSAgICByZXR1cm4geGVuZGV2OwotfQotCi0KLS8qCi0gKiBTeW5jIGludGVybmFsIGRh dGEgc3RydWN0dXJlcyBvbiB4ZW5zdG9yZSB1cGRhdGVzLgotICogTm9kZSBzcGVjaWZpZXMgdGhl IGNoYW5nZWQgZmllbGQuICBub2RlID0gTlVMTCBtZWFucwotICogdXBkYXRlIGFsbCBmaWVsZHMg KHVzZWQgZm9yIGluaXRpYWxpemF0aW9uKS4KLSAqLwotc3RhdGljIHZvaWQgeGVuX2JlX2JhY2tl bmRfY2hhbmdlZChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYsIGNvbnN0IGNoYXIgKm5vZGUpCi17 Ci0gICAgaWYgKG5vZGUgPT0gTlVMTCAgfHwgIHN0cmNtcChub2RlLCAib25saW5lIikgPT0gMCkg ewotICAgICAgICBpZiAoeGVuc3RvcmVfcmVhZF9iZV9pbnQoeGVuZGV2LCAib25saW5lIiwgJnhl bmRldi0+b25saW5lKSA9PSAtMSkgewotICAgICAgICAgICAgeGVuZGV2LT5vbmxpbmUgPSAwOwot ICAgICAgICB9Ci0gICAgfQotCi0gICAgaWYgKG5vZGUpIHsKLSAgICAgICAgeGVuX3B2X3ByaW50 Zih4ZW5kZXYsIDIsICJiYWNrZW5kIHVwZGF0ZTogJXNcbiIsIG5vZGUpOwotICAgICAgICBpZiAo eGVuZGV2LT5vcHMtPmJhY2tlbmRfY2hhbmdlZCkgewotICAgICAgICAgICAgeGVuZGV2LT5vcHMt PmJhY2tlbmRfY2hhbmdlZCh4ZW5kZXYsIG5vZGUpOwotICAgICAgICB9Ci0gICAgfQotfQotCi1z dGF0aWMgdm9pZCB4ZW5fYmVfZnJvbnRlbmRfY2hhbmdlZChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5k ZXYsIGNvbnN0IGNoYXIgKm5vZGUpCi17Ci0gICAgaW50IGZlX3N0YXRlOwotCi0gICAgaWYgKG5v ZGUgPT0gTlVMTCAgfHwgIHN0cmNtcChub2RlLCAic3RhdGUiKSA9PSAwKSB7Ci0gICAgICAgIGlm ICh4ZW5zdG9yZV9yZWFkX2ZlX2ludCh4ZW5kZXYsICJzdGF0ZSIsICZmZV9zdGF0ZSkgPT0gLTEp IHsKLSAgICAgICAgICAgIGZlX3N0YXRlID0gWGVuYnVzU3RhdGVVbmtub3duOwotICAgICAgICB9 Ci0gICAgICAgIGlmICh4ZW5kZXYtPmZlX3N0YXRlICE9IGZlX3N0YXRlKSB7Ci0gICAgICAgICAg ICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMSwgImZyb250ZW5kIHN0YXRlOiAlcyAtPiAlc1xuIiwK LSAgICAgICAgICAgICAgICAgICAgICAgICAgeGVuYnVzX3N0cnN0YXRlKHhlbmRldi0+ZmVfc3Rh dGUpLAotICAgICAgICAgICAgICAgICAgICAgICAgICB4ZW5idXNfc3Ryc3RhdGUoZmVfc3RhdGUp KTsKLSAgICAgICAgfQotICAgICAgICB4ZW5kZXYtPmZlX3N0YXRlID0gZmVfc3RhdGU7Ci0gICAg fQotICAgIGlmIChub2RlID09IE5VTEwgIHx8ICBzdHJjbXAobm9kZSwgInByb3RvY29sIikgPT0g MCkgewotICAgICAgICBnX2ZyZWUoeGVuZGV2LT5wcm90b2NvbCk7Ci0gICAgICAgIHhlbmRldi0+ cHJvdG9jb2wgPSB4ZW5zdG9yZV9yZWFkX2ZlX3N0cih4ZW5kZXYsICJwcm90b2NvbCIpOwotICAg ICAgICBpZiAoeGVuZGV2LT5wcm90b2NvbCkgewotICAgICAgICAgICAgeGVuX3B2X3ByaW50Zih4 ZW5kZXYsIDEsICJmcm9udGVuZCBwcm90b2NvbDogJXNcbiIsCi0gICAgICAgICAgICAgICAgICAg ICAgICAgIHhlbmRldi0+cHJvdG9jb2wpOwotICAgICAgICB9Ci0gICAgfQotCi0gICAgaWYgKG5v ZGUpIHsKLSAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDIsICJmcm9udGVuZCB1cGRhdGU6 ICVzXG4iLCBub2RlKTsKLSAgICAgICAgaWYgKHhlbmRldi0+b3BzLT5mcm9udGVuZF9jaGFuZ2Vk KSB7Ci0gICAgICAgICAgICB4ZW5kZXYtPm9wcy0+ZnJvbnRlbmRfY2hhbmdlZCh4ZW5kZXYsIG5v ZGUpOwotICAgICAgICB9Ci0gICAgfQotfQotCi0vKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCi0vKiBDaGVjayBmb3IgcG9z c2libGUgc3RhdGUgdHJhbnNpdGlvbnMgYW5kIHBlcmZvcm0gdGhlbS4gICAgICAgICovCi0KLS8q Ci0gKiBJbml0aWFsIHhlbmRldiBzZXR1cC4gIFJlYWQgZnJvbnRlbmQgcGF0aCwgcmVnaXN0ZXIg d2F0Y2ggZm9yIGl0LgotICogU2hvdWxkIHN1Y2NlZWQgb25jZSB4ZW5kIGZpbmlzaGVkIHNldHRp bmcgdXAgdGhlIGJhY2tlbmQgZGV2aWNlLgotICoKLSAqIEFsc28gc2V0cyBpbml0aWFsIHN0YXRl ICgtPiBJbml0aWFsaXppbmcpIHdoZW4gZG9uZS4gIFdoaWNoCi0gKiBvbmx5IGFmZmVjdHMgdGhl IHhlbmRldi0+YmVfc3RhdGUgdmFyaWFibGUgYXMgeGVuYnVzIHNob3VsZAotICogYWxyZWFkeSBi ZSBwdXQgaW50byB0aGF0IHN0YXRlIGJ5IHhlbmQuCi0gKi8KLXN0YXRpYyBpbnQgeGVuX2JlX3Ry eV9zZXR1cChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCi17Ci0gICAgY2hhciB0b2tlbltYRU5f QlVGU0laRV07Ci0gICAgaW50IGJlX3N0YXRlOwotCi0gICAgaWYgKHhlbnN0b3JlX3JlYWRfYmVf aW50KHhlbmRldiwgInN0YXRlIiwgJmJlX3N0YXRlKSA9PSAtMSkgewotICAgICAgICB4ZW5fcHZf cHJpbnRmKHhlbmRldiwgMCwgInJlYWRpbmcgYmFja2VuZCBzdGF0ZSBmYWlsZWRcbiIpOwotICAg ICAgICByZXR1cm4gLTE7Ci0gICAgfQotCi0gICAgaWYgKGJlX3N0YXRlICE9IFhlbmJ1c1N0YXRl SW5pdGlhbGlzaW5nKSB7Ci0gICAgICAgIHhlbl9wdl9wcmludGYoeGVuZGV2LCAwLCAiaW5pdGlh bCBiYWNrZW5kIHN0YXRlIGlzIHdyb25nICglcylcbiIsCi0gICAgICAgICAgICAgICAgICAgICAg eGVuYnVzX3N0cnN0YXRlKGJlX3N0YXRlKSk7Ci0gICAgICAgIHJldHVybiAtMTsKLSAgICB9Ci0K LSAgICB4ZW5kZXYtPmZlID0geGVuc3RvcmVfcmVhZF9iZV9zdHIoeGVuZGV2LCAiZnJvbnRlbmQi KTsKLSAgICBpZiAoeGVuZGV2LT5mZSA9PSBOVUxMKSB7Ci0gICAgICAgIHhlbl9wdl9wcmludGYo eGVuZGV2LCAwLCAicmVhZGluZyBmcm9udGVuZCBwYXRoIGZhaWxlZFxuIik7Ci0gICAgICAgIHJl dHVybiAtMTsKLSAgICB9Ci0KLSAgICAvKiBzZXR1cCBmcm9udGVuZCB3YXRjaCAqLwotICAgIHNu cHJpbnRmKHRva2VuLCBzaXplb2YodG9rZW4pLCAiZmU6JXAiLCB4ZW5kZXYpOwotICAgIGlmICgh eHNfd2F0Y2goeGVuc3RvcmUsIHhlbmRldi0+ZmUsIHRva2VuKSkgewotICAgICAgICB4ZW5fcHZf cHJpbnRmKHhlbmRldiwgMCwgIndhdGNoaW5nIGZyb250ZW5kIHBhdGggKCVzKSBmYWlsZWRcbiIs Ci0gICAgICAgICAgICAgICAgICAgICAgeGVuZGV2LT5mZSk7Ci0gICAgICAgIHJldHVybiAtMTsK LSAgICB9Ci0gICAgeGVuX2JlX3NldF9zdGF0ZSh4ZW5kZXYsIFhlbmJ1c1N0YXRlSW5pdGlhbGlz aW5nKTsKLQotICAgIHhlbl9iZV9iYWNrZW5kX2NoYW5nZWQoeGVuZGV2LCBOVUxMKTsKLSAgICB4 ZW5fYmVfZnJvbnRlbmRfY2hhbmdlZCh4ZW5kZXYsIE5VTEwpOwotICAgIHJldHVybiAwOwotfQot Ci0vKgotICogVHJ5IGluaXRpYWxpemUgeGVuZGV2LiAgUHJlcGFyZSBldmVyeXRoaW5nIHRoZSBi YWNrZW5kIGNhbiBkbwotICogd2l0aG91dCBzeW5jaHJvbml6aW5nIHdpdGggdGhlIGZyb250ZW5k LiAgRmFrZXMgaG90cGx1Zy1zdGF0dXMuICBObwotICogaG90cGx1ZyBpbnZvbHZlZCBoZXJlIGJl Y2F1c2UgdGhpcyBpcyBhYm91dCB1c2Vyc3BhY2UgZHJpdmVycywgdGh1cwotICogdGhlcmUgYXJl IGtlcm5lbCBiYWNrZW5kIGRldmljZXMgd2hpY2ggY291bGQgaW52b2tlIGhvdHBsdWcuCi0gKgot ICogR29lcyB0byBJbml0V2FpdCBvbiBzdWNjZXNzLgotICovCi1zdGF0aWMgaW50IHhlbl9iZV90 cnlfaW5pdChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCi17Ci0gICAgaW50IHJjID0gMDsKLQot ICAgIGlmICgheGVuZGV2LT5vbmxpbmUpIHsKLSAgICAgICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYs IDEsICJub3Qgb25saW5lXG4iKTsKLSAgICAgICAgcmV0dXJuIC0xOwotICAgIH0KLQotICAgIGlm ICh4ZW5kZXYtPm9wcy0+aW5pdCkgewotICAgICAgICByYyA9IHhlbmRldi0+b3BzLT5pbml0KHhl bmRldik7Ci0gICAgfQotICAgIGlmIChyYyAhPSAwKSB7Ci0gICAgICAgIHhlbl9wdl9wcmludGYo eGVuZGV2LCAxLCAiaW5pdCgpIGZhaWxlZFxuIik7Ci0gICAgICAgIHJldHVybiByYzsKLSAgICB9 Ci0KLSAgICB4ZW5zdG9yZV93cml0ZV9iZV9zdHIoeGVuZGV2LCAiaG90cGx1Zy1zdGF0dXMiLCAi Y29ubmVjdGVkIik7Ci0gICAgeGVuX2JlX3NldF9zdGF0ZSh4ZW5kZXYsIFhlbmJ1c1N0YXRlSW5p dFdhaXQpOwotICAgIHJldHVybiAwOwotfQotCi0vKgotICogVHJ5IHRvIGluaXRpYWxpc2UgeGVu ZGV2LiAgRGVwZW5kcyBvbiB0aGUgZnJvbnRlbmQgYmVpbmcgcmVhZHkKLSAqIGZvciBpdCAoc2hh cmVkIHJpbmcgYW5kIGV2dGNobiBpbmZvIGluIHhlbnN0b3JlLCBzdGF0ZSBiZWluZwotICogSW5p dGlhbGlzZWQgb3IgQ29ubmVjdGVkKS4KLSAqCi0gKiBHb2VzIHRvIENvbm5lY3RlZCBvbiBzdWNj ZXNzLgotICovCi1zdGF0aWMgaW50IHhlbl9iZV90cnlfaW5pdGlhbGlzZShzdHJ1Y3QgWGVuRGV2 aWNlICp4ZW5kZXYpCi17Ci0gICAgaW50IHJjID0gMDsKLQotICAgIGlmICh4ZW5kZXYtPmZlX3N0 YXRlICE9IFhlbmJ1c1N0YXRlSW5pdGlhbGlzZWQgICYmCi0gICAgICAgIHhlbmRldi0+ZmVfc3Rh dGUgIT0gWGVuYnVzU3RhdGVDb25uZWN0ZWQpIHsKLSAgICAgICAgaWYgKHhlbmRldi0+b3BzLT5m bGFncyAmIERFVk9QU19GTEFHX0lHTk9SRV9TVEFURSkgewotICAgICAgICAgICAgeGVuX3B2X3By aW50Zih4ZW5kZXYsIDIsICJmcm9udGVuZCBub3QgcmVhZHksIGlnbm9yaW5nXG4iKTsKLSAgICAg ICAgfSBlbHNlIHsKLSAgICAgICAgICAgIHhlbl9wdl9wcmludGYoeGVuZGV2LCAyLCAiZnJvbnRl bmQgbm90IHJlYWR5ICh5ZXQpXG4iKTsKLSAgICAgICAgICAgIHJldHVybiAtMTsKLSAgICAgICAg fQotICAgIH0KLQotICAgIGlmICh4ZW5kZXYtPm9wcy0+ZmxhZ3MgJiBERVZPUFNfRkxBR19ORUVE X0dOVERFVikgewotICAgICAgICB4ZW5kZXYtPmdudHRhYmRldiA9IHhlbmdudHRhYl9vcGVuKE5V TEwsIDApOwotICAgICAgICBpZiAoeGVuZGV2LT5nbnR0YWJkZXYgPT0gTlVMTCkgewotICAgICAg ICAgICAgeGVuX3B2X3ByaW50ZihOVUxMLCAwLCAiY2FuJ3Qgb3BlbiBnbnR0YWIgZGV2aWNlXG4i KTsKLSAgICAgICAgICAgIHJldHVybiAtMTsKLSAgICAgICAgfQotICAgIH0gZWxzZSB7Ci0gICAg ICAgIHhlbmRldi0+Z250dGFiZGV2ID0gTlVMTDsKLSAgICB9Ci0KLSAgICBpZiAoeGVuZGV2LT5v cHMtPmluaXRpYWxpc2UpIHsKLSAgICAgICAgcmMgPSB4ZW5kZXYtPm9wcy0+aW5pdGlhbGlzZSh4 ZW5kZXYpOwotICAgIH0KLSAgICBpZiAocmMgIT0gMCkgewotICAgICAgICB4ZW5fcHZfcHJpbnRm KHhlbmRldiwgMCwgImluaXRpYWxpc2UoKSBmYWlsZWRcbiIpOwotICAgICAgICByZXR1cm4gcmM7 Ci0gICAgfQotCi0gICAgeGVuX2JlX3NldF9zdGF0ZSh4ZW5kZXYsIFhlbmJ1c1N0YXRlQ29ubmVj dGVkKTsKLSAgICByZXR1cm4gMDsKLX0KLQotLyoKLSAqIFRyeSB0byBsZXQgeGVuZGV2IGtub3cg dGhhdCBpdCBpcyBjb25uZWN0ZWQuICBEZXBlbmRzIG9uIHRoZQotICogZnJvbnRlbmQgYmVpbmcg Q29ubmVjdGVkLiAgTm90ZSB0aGF0IHRoaXMgbWF5IGJlIGNhbGxlZCBtb3JlCi0gKiB0aGFuIG9u Y2Ugc2luY2UgdGhlIGJhY2tlbmQgc3RhdGUgaXMgbm90IG1vZGlmaWVkLgotICovCi1zdGF0aWMg dm9pZCB4ZW5fYmVfdHJ5X2Nvbm5lY3RlZChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCi17Ci0g ICAgaWYgKCF4ZW5kZXYtPm9wcy0+Y29ubmVjdGVkKSB7Ci0gICAgICAgIHJldHVybjsKLSAgICB9 Ci0KLSAgICBpZiAoeGVuZGV2LT5mZV9zdGF0ZSAhPSBYZW5idXNTdGF0ZUNvbm5lY3RlZCkgewot ICAgICAgICBpZiAoeGVuZGV2LT5vcHMtPmZsYWdzICYgREVWT1BTX0ZMQUdfSUdOT1JFX1NUQVRF KSB7Ci0gICAgICAgICAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMiwgImZyb250ZW5kIG5vdCBy ZWFkeSwgaWdub3JpbmdcbiIpOwotICAgICAgICB9IGVsc2UgewotICAgICAgICAgICAgeGVuX3B2 X3ByaW50Zih4ZW5kZXYsIDIsICJmcm9udGVuZCBub3QgcmVhZHkgKHlldClcbiIpOwotICAgICAg ICAgICAgcmV0dXJuOwotICAgICAgICB9Ci0gICAgfQotCi0gICAgeGVuZGV2LT5vcHMtPmNvbm5l Y3RlZCh4ZW5kZXYpOwotfQotCi0vKgotICogVGVhcmRvd24gY29ubmVjdGlvbi4KLSAqCi0gKiBH b2VzIHRvIENsb3NlZCB3aGVuIGRvbmUuCi0gKi8KLXN0YXRpYyB2b2lkIHhlbl9iZV9kaXNjb25u ZWN0KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgZW51bSB4ZW5idXNfc3RhdGUgc3RhdGUpCi17 Ci0gICAgaWYgKHhlbmRldi0+YmVfc3RhdGUgIT0gWGVuYnVzU3RhdGVDbG9zaW5nICYmCi0gICAg ICAgIHhlbmRldi0+YmVfc3RhdGUgIT0gWGVuYnVzU3RhdGVDbG9zZWQgICYmCi0gICAgICAgIHhl bmRldi0+b3BzLT5kaXNjb25uZWN0KSB7Ci0gICAgICAgIHhlbmRldi0+b3BzLT5kaXNjb25uZWN0 KHhlbmRldik7Ci0gICAgfQotICAgIGlmICh4ZW5kZXYtPmdudHRhYmRldikgewotICAgICAgICB4 ZW5nbnR0YWJfY2xvc2UoeGVuZGV2LT5nbnR0YWJkZXYpOwotICAgICAgICB4ZW5kZXYtPmdudHRh YmRldiA9IE5VTEw7Ci0gICAgfQotICAgIGlmICh4ZW5kZXYtPmJlX3N0YXRlICE9IHN0YXRlKSB7 Ci0gICAgICAgIHhlbl9iZV9zZXRfc3RhdGUoeGVuZGV2LCBzdGF0ZSk7Ci0gICAgfQotfQotCi0v KgotICogVHJ5IHRvIHJlc2V0IHhlbmRldiwgZm9yIHJlY29ubmVjdGlvbiBieSBhbm90aGVyIGZy b250ZW5kIGluc3RhbmNlLgotICovCi1zdGF0aWMgaW50IHhlbl9iZV90cnlfcmVzZXQoc3RydWN0 IFhlbkRldmljZSAqeGVuZGV2KQotewotICAgIGlmICh4ZW5kZXYtPmZlX3N0YXRlICE9IFhlbmJ1 c1N0YXRlSW5pdGlhbGlzaW5nKSB7Ci0gICAgICAgIHJldHVybiAtMTsKLSAgICB9Ci0KLSAgICB4 ZW5fcHZfcHJpbnRmKHhlbmRldiwgMSwgImRldmljZSByZXNldCAoZm9yIHJlLWNvbm5lY3QpXG4i KTsKLSAgICB4ZW5fYmVfc2V0X3N0YXRlKHhlbmRldiwgWGVuYnVzU3RhdGVJbml0aWFsaXNpbmcp OwotICAgIHJldHVybiAwOwotfQotCi0vKgotICogc3RhdGUgY2hhbmdlIGRpc3BhdGNoZXIgZnVu Y3Rpb24KLSAqLwotdm9pZCB4ZW5fYmVfY2hlY2tfc3RhdGUoc3RydWN0IFhlbkRldmljZSAqeGVu ZGV2KQotewotICAgIGludCByYyA9IDA7Ci0KLSAgICAvKiBmcm9udGVuZCBtYXkgcmVxdWVzdCBz aHV0ZG93biBmcm9tIGFsbW9zdCBhbnl3aGVyZSAqLwotICAgIGlmICh4ZW5kZXYtPmZlX3N0YXRl ID09IFhlbmJ1c1N0YXRlQ2xvc2luZyB8fAotICAgICAgICB4ZW5kZXYtPmZlX3N0YXRlID09IFhl bmJ1c1N0YXRlQ2xvc2VkKSB7Ci0gICAgICAgIHhlbl9iZV9kaXNjb25uZWN0KHhlbmRldiwgeGVu ZGV2LT5mZV9zdGF0ZSk7Ci0gICAgICAgIHJldHVybjsKLSAgICB9Ci0KLSAgICAvKiBjaGVjayBm b3IgcG9zc2libGUgYmFja2VuZCBzdGF0ZSB0cmFuc2l0aW9ucyAqLwotICAgIGZvciAoOzspIHsK LSAgICAgICAgc3dpdGNoICh4ZW5kZXYtPmJlX3N0YXRlKSB7Ci0gICAgICAgIGNhc2UgWGVuYnVz U3RhdGVVbmtub3duOgotICAgICAgICAgICAgcmMgPSB4ZW5fYmVfdHJ5X3NldHVwKHhlbmRldik7 Ci0gICAgICAgICAgICBicmVhazsKLSAgICAgICAgY2FzZSBYZW5idXNTdGF0ZUluaXRpYWxpc2lu ZzoKLSAgICAgICAgICAgIHJjID0geGVuX2JlX3RyeV9pbml0KHhlbmRldik7Ci0gICAgICAgICAg ICBicmVhazsKLSAgICAgICAgY2FzZSBYZW5idXNTdGF0ZUluaXRXYWl0OgotICAgICAgICAgICAg cmMgPSB4ZW5fYmVfdHJ5X2luaXRpYWxpc2UoeGVuZGV2KTsKLSAgICAgICAgICAgIGJyZWFrOwot ICAgICAgICBjYXNlIFhlbmJ1c1N0YXRlQ29ubmVjdGVkOgotICAgICAgICAgICAgLyogeGVuZGV2 LT5iZV9zdGF0ZSBkb2Vzbid0IGNoYW5nZSAqLwotICAgICAgICAgICAgeGVuX2JlX3RyeV9jb25u ZWN0ZWQoeGVuZGV2KTsKLSAgICAgICAgICAgIHJjID0gLTE7Ci0gICAgICAgICAgICBicmVhazsK LSAgICAgICAgY2FzZSBYZW5idXNTdGF0ZUNsb3NlZDoKLSAgICAgICAgICAgIHJjID0geGVuX2Jl X3RyeV9yZXNldCh4ZW5kZXYpOwotICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAgIGRlZmF1bHQ6 Ci0gICAgICAgICAgICByYyA9IC0xOwotICAgICAgICB9Ci0gICAgICAgIGlmIChyYyAhPSAwKSB7 Ci0gICAgICAgICAgICBicmVhazsKLSAgICAgICAgfQotICAgIH0KLX0KLQotLyogLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwot Ci1zdGF0aWMgaW50IHhlbnN0b3JlX3NjYW4oY29uc3QgY2hhciAqdHlwZSwgaW50IGRvbSwgc3Ry dWN0IFhlbkRldk9wcyAqb3BzKQotewotICAgIHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldjsKLSAg ICBjaGFyIHBhdGhbWEVOX0JVRlNJWkVdLCB0b2tlbltYRU5fQlVGU0laRV07Ci0gICAgY2hhciAq KmRldiA9IE5VTEw7Ci0gICAgdW5zaWduZWQgaW50IGNkZXYsIGo7Ci0KLSAgICAvKiBzZXR1cCB3 YXRjaCAqLwotICAgIHNucHJpbnRmKHRva2VuLCBzaXplb2YodG9rZW4pLCAiYmU6JXA6JWQ6JXAi LCB0eXBlLCBkb20sIG9wcyk7Ci0gICAgc25wcmludGYocGF0aCwgc2l6ZW9mKHBhdGgpLCAiYmFj a2VuZC8lcy8lZCIsIHR5cGUsIGRvbSk7Ci0gICAgaWYgKCF4c193YXRjaCh4ZW5zdG9yZSwgcGF0 aCwgdG9rZW4pKSB7Ci0gICAgICAgIHhlbl9wdl9wcmludGYoTlVMTCwgMCwgInhlbiBiZTogd2F0 Y2hpbmcgYmFja2VuZCBwYXRoICglcykgZmFpbGVkXG4iLAotICAgICAgICAgICAgICAgICAgICAg IHBhdGgpOwotICAgICAgICByZXR1cm4gLTE7Ci0gICAgfQotCi0gICAgLyogbG9vayBmb3IgYmFj a2VuZHMgKi8KLSAgICBkZXYgPSB4c19kaXJlY3RvcnkoeGVuc3RvcmUsIDAsIHBhdGgsICZjZGV2 KTsKLSAgICBpZiAoIWRldikgewotICAgICAgICByZXR1cm4gMDsKLSAgICB9Ci0gICAgZm9yIChq ID0gMDsgaiA8IGNkZXY7IGorKykgewotICAgICAgICB4ZW5kZXYgPSB4ZW5fYmVfZ2V0X3hlbmRl dih0eXBlLCBkb20sIGF0b2koZGV2W2pdKSwgb3BzKTsKLSAgICAgICAgaWYgKHhlbmRldiA9PSBO VUxMKSB7Ci0gICAgICAgICAgICBjb250aW51ZTsKLSAgICAgICAgfQotICAgICAgICB4ZW5fYmVf Y2hlY2tfc3RhdGUoeGVuZGV2KTsKLSAgICB9Ci0gICAgZnJlZShkZXYpOwotICAgIHJldHVybiAw OwotfQotCi12b2lkIHhlbnN0b3JlX3VwZGF0ZV9iZShjaGFyICp3YXRjaCwgY2hhciAqdHlwZSwg aW50IGRvbSwKLSAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBYZW5EZXZPcHMgKm9wcykK LXsKLSAgICBzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXY7Ci0gICAgY2hhciBwYXRoW1hFTl9CVUZT SVpFXSwgKmJlcGF0aDsKLSAgICB1bnNpZ25lZCBpbnQgbGVuLCBkZXY7Ci0KLSAgICBsZW4gPSBz bnByaW50ZihwYXRoLCBzaXplb2YocGF0aCksICJiYWNrZW5kLyVzLyVkIiwgdHlwZSwgZG9tKTsK LSAgICBpZiAoc3RybmNtcChwYXRoLCB3YXRjaCwgbGVuKSAhPSAwKSB7Ci0gICAgICAgIHJldHVy bjsKLSAgICB9Ci0gICAgaWYgKHNzY2FuZih3YXRjaCtsZW4sICIvJXUvJTI1NXMiLCAmZGV2LCBw YXRoKSAhPSAyKSB7Ci0gICAgICAgIHN0cmNweShwYXRoLCAiIik7Ci0gICAgICAgIGlmIChzc2Nh bmYod2F0Y2grbGVuLCAiLyV1IiwgJmRldikgIT0gMSkgewotICAgICAgICAgICAgZGV2ID0gLTE7 Ci0gICAgICAgIH0KLSAgICB9Ci0gICAgaWYgKGRldiA9PSAtMSkgewotICAgICAgICByZXR1cm47 Ci0gICAgfQotCi0gICAgeGVuZGV2ID0geGVuX2JlX2dldF94ZW5kZXYodHlwZSwgZG9tLCBkZXYs IG9wcyk7Ci0gICAgaWYgKHhlbmRldiAhPSBOVUxMKSB7Ci0gICAgICAgIGJlcGF0aCA9IHhzX3Jl YWQoeGVuc3RvcmUsIDAsIHhlbmRldi0+YmUsICZsZW4pOwotICAgICAgICBpZiAoYmVwYXRoID09 IE5VTEwpIHsKLSAgICAgICAgICAgIHhlbl9wdl9kZWxfeGVuZGV2KHhlbmRldik7Ci0gICAgICAg IH0gZWxzZSB7Ci0gICAgICAgICAgICBmcmVlKGJlcGF0aCk7Ci0gICAgICAgICAgICB4ZW5fYmVf YmFja2VuZF9jaGFuZ2VkKHhlbmRldiwgcGF0aCk7Ci0gICAgICAgICAgICB4ZW5fYmVfY2hlY2tf c3RhdGUoeGVuZGV2KTsKLSAgICAgICAgfQotICAgIH0KLX0KLQotdm9pZCB4ZW5zdG9yZV91cGRh dGVfZmUoY2hhciAqd2F0Y2gsIHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKLXsKLSAgICBjaGFy ICpub2RlOwotICAgIHVuc2lnbmVkIGludCBsZW47Ci0KLSAgICBsZW4gPSBzdHJsZW4oeGVuZGV2 LT5mZSk7Ci0gICAgaWYgKHN0cm5jbXAoeGVuZGV2LT5mZSwgd2F0Y2gsIGxlbikgIT0gMCkgewot ICAgICAgICByZXR1cm47Ci0gICAgfQotICAgIGlmICh3YXRjaFtsZW5dICE9ICcvJykgewotICAg ICAgICByZXR1cm47Ci0gICAgfQotICAgIG5vZGUgPSB3YXRjaCArIGxlbiArIDE7Ci0KLSAgICB4 ZW5fYmVfZnJvbnRlbmRfY2hhbmdlZCh4ZW5kZXYsIG5vZGUpOwotICAgIHhlbl9iZV9jaGVja19z dGF0ZSh4ZW5kZXYpOwotfQotLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KLQotaW50IHhlbl9iZV9pbml0KHZv aWQpCi17Ci0gICAgeGVuZ250dGFiX2hhbmRsZSAqZ250dGFiZGV2OwotCi0gICAgeGVuc3RvcmUg PSB4c19kYWVtb25fb3BlbigpOwotICAgIGlmICgheGVuc3RvcmUpIHsKLSAgICAgICAgeGVuX3B2 X3ByaW50ZihOVUxMLCAwLCAiY2FuJ3QgY29ubmVjdCB0byB4ZW5zdG9yZWRcbiIpOwotICAgICAg ICByZXR1cm4gLTE7Ci0gICAgfQotCi0gICAgcWVtdV9zZXRfZmRfaGFuZGxlcih4c19maWxlbm8o eGVuc3RvcmUpLCB4ZW5zdG9yZV91cGRhdGUsIE5VTEwsIE5VTEwpOwotCi0gICAgaWYgKHhlbl94 YyA9PSBOVUxMIHx8IHhlbl9mbWVtID09IE5VTEwpIHsKLSAgICAgICAgLyogQ2hlY2sgaWYgeGVu X2luaXQoKSBoYXZlIGJlZW4gY2FsbGVkICovCi0gICAgICAgIGdvdG8gZXJyOwotICAgIH0KLQot ICAgIGdudHRhYmRldiA9IHhlbmdudHRhYl9vcGVuKE5VTEwsIDApOwotICAgIGlmIChnbnR0YWJk ZXYgIT0gTlVMTCkgewotICAgICAgICBpZiAoeGVuZ250dGFiX2dyYW50X2NvcHkoZ250dGFiZGV2 LCAwLCBOVUxMKSA9PSAwKSB7Ci0gICAgICAgICAgICB4ZW5fZmVhdHVyZV9ncmFudF9jb3B5ID0g dHJ1ZTsKLSAgICAgICAgfQotICAgICAgICB4ZW5nbnR0YWJfY2xvc2UoZ250dGFiZGV2KTsKLSAg ICB9Ci0KLSAgICB4ZW5fc3lzZGV2ID0gcWRldl9jcmVhdGUoTlVMTCwgVFlQRV9YRU5TWVNERVYp OwotICAgIHFkZXZfaW5pdF9ub2ZhaWwoeGVuX3N5c2Rldik7Ci0gICAgeGVuX3N5c2J1cyA9IHFi dXNfY3JlYXRlKFRZUEVfWEVOU1lTQlVTLCBERVZJQ0UoeGVuX3N5c2RldiksICJ4ZW4tc3lzYnVz Iik7Ci0gICAgcWJ1c19zZXRfYnVzX2hvdHBsdWdfaGFuZGxlcih4ZW5fc3lzYnVzLCAmZXJyb3Jf YWJvcnQpOwotCi0gICAgcmV0dXJuIDA7Ci0KLWVycjoKLSAgICBxZW11X3NldF9mZF9oYW5kbGVy KHhzX2ZpbGVubyh4ZW5zdG9yZSksIE5VTEwsIE5VTEwsIE5VTEwpOwotICAgIHhzX2RhZW1vbl9j bG9zZSh4ZW5zdG9yZSk7Ci0gICAgeGVuc3RvcmUgPSBOVUxMOwotCi0gICAgcmV0dXJuIC0xOwot fQotCi1zdGF0aWMgdm9pZCB4ZW5fc2V0X2R5bmFtaWNfc3lzYnVzKHZvaWQpCi17Ci0gICAgT2Jq ZWN0ICptYWNoaW5lID0gcWRldl9nZXRfbWFjaGluZSgpOwotICAgIE9iamVjdENsYXNzICpvYyA9 IG9iamVjdF9nZXRfY2xhc3MobWFjaGluZSk7Ci0gICAgTWFjaGluZUNsYXNzICptYyA9IE1BQ0hJ TkVfQ0xBU1Mob2MpOwotCi0gICAgbWFjaGluZV9jbGFzc19hbGxvd19keW5hbWljX3N5c2J1c19k ZXYobWMsIFRZUEVfWEVOU1lTREVWKTsKLX0KLQotaW50IHhlbl9iZV9yZWdpc3Rlcihjb25zdCBj aGFyICp0eXBlLCBzdHJ1Y3QgWGVuRGV2T3BzICpvcHMpCi17Ci0gICAgY2hhciBwYXRoWzUwXTsK LSAgICBpbnQgcmM7Ci0KLSAgICBpZiAob3BzLT5iYWNrZW5kX3JlZ2lzdGVyKSB7Ci0gICAgICAg IHJjID0gb3BzLT5iYWNrZW5kX3JlZ2lzdGVyKCk7Ci0gICAgICAgIGlmIChyYykgewotICAgICAg ICAgICAgcmV0dXJuIHJjOwotICAgICAgICB9Ci0gICAgfQotCi0gICAgc25wcmludGYocGF0aCwg c2l6ZW9mKHBhdGgpLCAiZGV2aWNlLW1vZGVsLyV1L2JhY2tlbmRzLyVzIiwgeGVuX2RvbWlkLAot ICAgICAgICAgICAgIHR5cGUpOwotICAgIHhlbnN0b3JlX21rZGlyKHBhdGgsIFhTX1BFUk1fTk9O RSk7Ci0KLSAgICByZXR1cm4geGVuc3RvcmVfc2Nhbih0eXBlLCB4ZW5fZG9taWQsIG9wcyk7Ci19 Ci0KLXZvaWQgeGVuX2JlX3JlZ2lzdGVyX2NvbW1vbih2b2lkKQotewotICAgIHhlbl9zZXRfZHlu YW1pY19zeXNidXMoKTsKLQotICAgIHhlbl9iZV9yZWdpc3RlcigiY29uc29sZSIsICZ4ZW5fY29u c29sZV9vcHMpOwotICAgIHhlbl9iZV9yZWdpc3RlcigidmtiZCIsICZ4ZW5fa2JkbW91c2Vfb3Bz KTsKLSAgICB4ZW5fYmVfcmVnaXN0ZXIoInFkaXNrIiwgJnhlbl9ibGtkZXZfb3BzKTsKLSNpZmRl ZiBDT05GSUdfVklSVEZTCi0gICAgeGVuX2JlX3JlZ2lzdGVyKCI5cGZzIiwgJnhlbl85cGZzX29w cyk7Ci0jZW5kaWYKLSNpZmRlZiBDT05GSUdfVVNCX0xJQlVTQgotICAgIHhlbl9iZV9yZWdpc3Rl cigicXVzYiIsICZ4ZW5fdXNiX29wcyk7Ci0jZW5kaWYKLX0KLQotaW50IHhlbl9iZV9iaW5kX2V2 dGNobihzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCi17Ci0gICAgaWYgKHhlbmRldi0+bG9jYWxf cG9ydCAhPSAtMSkgewotICAgICAgICByZXR1cm4gMDsKLSAgICB9Ci0gICAgeGVuZGV2LT5sb2Nh bF9wb3J0ID0geGVuZXZ0Y2huX2JpbmRfaW50ZXJkb21haW4KLSAgICAgICAgKHhlbmRldi0+ZXZ0 Y2huZGV2LCB4ZW5kZXYtPmRvbSwgeGVuZGV2LT5yZW1vdGVfcG9ydCk7Ci0gICAgaWYgKHhlbmRl di0+bG9jYWxfcG9ydCA9PSAtMSkgewotICAgICAgICB4ZW5fcHZfcHJpbnRmKHhlbmRldiwgMCwg InhlbmV2dGNobl9iaW5kX2ludGVyZG9tYWluIGZhaWxlZFxuIik7Ci0gICAgICAgIHJldHVybiAt MTsKLSAgICB9Ci0gICAgeGVuX3B2X3ByaW50Zih4ZW5kZXYsIDIsICJiaW5kIGV2dGNobiBwb3J0 ICVkXG4iLCB4ZW5kZXYtPmxvY2FsX3BvcnQpOwotICAgIHFlbXVfc2V0X2ZkX2hhbmRsZXIoeGVu ZXZ0Y2huX2ZkKHhlbmRldi0+ZXZ0Y2huZGV2KSwKLSAgICAgICAgICAgICAgICAgICAgICAgIHhl bl9wdl9ldnRjaG5fZXZlbnQsIE5VTEwsIHhlbmRldik7Ci0gICAgcmV0dXJuIDA7Ci19Ci0KLQot c3RhdGljIFByb3BlcnR5IHhlbmRldl9wcm9wZXJ0aWVzW10gPSB7Ci0gICAgREVGSU5FX1BST1Bf RU5EX09GX0xJU1QoKSwKLX07Ci0KLXN0YXRpYyB2b2lkIHhlbmRldl9jbGFzc19pbml0KE9iamVj dENsYXNzICprbGFzcywgdm9pZCAqZGF0YSkKLXsKLSAgICBEZXZpY2VDbGFzcyAqZGMgPSBERVZJ Q0VfQ0xBU1Moa2xhc3MpOwotCi0gICAgZGMtPnByb3BzID0geGVuZGV2X3Byb3BlcnRpZXM7Ci0g ICAgc2V0X2JpdChERVZJQ0VfQ0FURUdPUllfTUlTQywgZGMtPmNhdGVnb3JpZXMpOwotICAgIC8q IHhlbi1iYWNrZW5kIGRldmljZXMgY2FuIGJlIHBsdWdnZWQvdW5wbHVnZ2VkIGR5bmFtaWNhbGx5 ICovCi0gICAgZGMtPnVzZXJfY3JlYXRhYmxlID0gdHJ1ZTsKLX0KLQotc3RhdGljIGNvbnN0IFR5 cGVJbmZvIHhlbmRldl90eXBlX2luZm8gPSB7Ci0gICAgLm5hbWUgICAgICAgICAgPSBUWVBFX1hF TkJBQ0tFTkQsCi0gICAgLnBhcmVudCAgICAgICAgPSBUWVBFX1hFTlNZU0RFViwKLSAgICAuY2xh c3NfaW5pdCAgICA9IHhlbmRldl9jbGFzc19pbml0LAotICAgIC5pbnN0YW5jZV9zaXplID0gc2l6 ZW9mKHN0cnVjdCBYZW5EZXZpY2UpLAotfTsKLQotc3RhdGljIHZvaWQgeGVuX3N5c2J1c19jbGFz c19pbml0KE9iamVjdENsYXNzICprbGFzcywgdm9pZCAqZGF0YSkKLXsKLSAgICBIb3RwbHVnSGFu ZGxlckNsYXNzICpoYyA9IEhPVFBMVUdfSEFORExFUl9DTEFTUyhrbGFzcyk7Ci0KLSAgICBoYy0+ dW5wbHVnID0gcWRldl9zaW1wbGVfZGV2aWNlX3VucGx1Z19jYjsKLX0KLQotc3RhdGljIGNvbnN0 IFR5cGVJbmZvIHhlbnN5c2J1c19pbmZvID0gewotICAgIC5uYW1lICAgICAgID0gVFlQRV9YRU5T WVNCVVMsCi0gICAgLnBhcmVudCAgICAgPSBUWVBFX0JVUywKLSAgICAuY2xhc3NfaW5pdCA9IHhl bl9zeXNidXNfY2xhc3NfaW5pdCwKLSAgICAuaW50ZXJmYWNlcyA9IChJbnRlcmZhY2VJbmZvW10p IHsKLSAgICAgICAgeyBUWVBFX0hPVFBMVUdfSEFORExFUiB9LAotICAgICAgICB7IH0KLSAgICB9 Ci19OwotCi1zdGF0aWMgaW50IHhlbl9zeXNkZXZfaW5pdChTeXNCdXNEZXZpY2UgKmRldikKLXsK LSAgICByZXR1cm4gMDsKLX0KLQotc3RhdGljIFByb3BlcnR5IHhlbl9zeXNkZXZfcHJvcGVydGll c1tdID0gewotICAgIHsvKiBlbmQgb2YgcHJvcGVydHkgbGlzdCAqL30sCi19OwotCi1zdGF0aWMg dm9pZCB4ZW5fc3lzZGV2X2NsYXNzX2luaXQoT2JqZWN0Q2xhc3MgKmtsYXNzLCB2b2lkICpkYXRh KQotewotICAgIERldmljZUNsYXNzICpkYyA9IERFVklDRV9DTEFTUyhrbGFzcyk7Ci0gICAgU3lz QnVzRGV2aWNlQ2xhc3MgKmsgPSBTWVNfQlVTX0RFVklDRV9DTEFTUyhrbGFzcyk7Ci0KLSAgICBr LT5pbml0ID0geGVuX3N5c2Rldl9pbml0OwotICAgIGRjLT5wcm9wcyA9IHhlbl9zeXNkZXZfcHJv cGVydGllczsKLSAgICBkYy0+YnVzX3R5cGUgPSBUWVBFX1hFTlNZU0JVUzsKLX0KLQotc3RhdGlj IGNvbnN0IFR5cGVJbmZvIHhlbnN5c2Rldl9pbmZvID0gewotICAgIC5uYW1lICAgICAgICAgID0g VFlQRV9YRU5TWVNERVYsCi0gICAgLnBhcmVudCAgICAgICAgPSBUWVBFX1NZU19CVVNfREVWSUNF LAotICAgIC5pbnN0YW5jZV9zaXplID0gc2l6ZW9mKFN5c0J1c0RldmljZSksCi0gICAgLmNsYXNz X2luaXQgICAgPSB4ZW5fc3lzZGV2X2NsYXNzX2luaXQsCi19OwotCi1zdGF0aWMgdm9pZCB4ZW5i ZV9yZWdpc3Rlcl90eXBlcyh2b2lkKQotewotICAgIHR5cGVfcmVnaXN0ZXJfc3RhdGljKCZ4ZW5z eXNidXNfaW5mbyk7Ci0gICAgdHlwZV9yZWdpc3Rlcl9zdGF0aWMoJnhlbnN5c2Rldl9pbmZvKTsK LSAgICB0eXBlX3JlZ2lzdGVyX3N0YXRpYygmeGVuZGV2X3R5cGVfaW5mbyk7Ci19Ci0KLXR5cGVf aW5pdCh4ZW5iZV9yZWdpc3Rlcl90eXBlcykKZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW5fZGV2Y29u ZmlnLmMgYi9ody94ZW4veGVuX2RldmNvbmZpZy5jCmluZGV4IGFlYmMxOWIuLjFiMzBiZDcgMTAw NjQ0Ci0tLSBhL2h3L3hlbi94ZW5fZGV2Y29uZmlnLmMKKysrIGIvaHcveGVuL3hlbl9kZXZjb25m aWcuYwpAQCAtMSw1ICsxLDUgQEAKICNpbmNsdWRlICJxZW11L29zZGVwLmgiCi0jaW5jbHVkZSAi aHcveGVuL3hlbl9iYWNrZW5kLmgiCisjaW5jbHVkZSAiaHcveGVuL3hlbi1sZWdhY3ktYmFja2Vu ZC5oIgogI2luY2x1ZGUgInFlbXUvb3B0aW9uLmgiCiAjaW5jbHVkZSAic3lzZW11L2Jsb2NrZGV2 LmgiCiAKZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW5fcHQuYyBiL2h3L3hlbi94ZW5fcHQuYwppbmRl eCBmMWYzYTM3Li5iMjBiZjNhIDEwMDY0NAotLS0gYS9ody94ZW4veGVuX3B0LmMKKysrIGIvaHcv eGVuL3hlbl9wdC5jCkBAIC01OSw3ICs1OSw3IEBACiAjaW5jbHVkZSAiaHcvcGNpL3BjaS5oIgog I2luY2x1ZGUgImh3L3hlbi94ZW4uaCIKICNpbmNsdWRlICJody9pMzg2L3BjLmgiCi0jaW5jbHVk ZSAiaHcveGVuL3hlbl9iYWNrZW5kLmgiCisjaW5jbHVkZSAiaHcveGVuL3hlbi1sZWdhY3ktYmFj a2VuZC5oIgogI2luY2x1ZGUgInhlbl9wdC5oIgogI2luY2x1ZGUgInFlbXUvcmFuZ2UuaCIKICNp bmNsdWRlICJleGVjL2FkZHJlc3Mtc3BhY2VzLmgiCmRpZmYgLS1naXQgYS9ody94ZW4veGVuX3B0 X2NvbmZpZ19pbml0LmMgYi9ody94ZW4veGVuX3B0X2NvbmZpZ19pbml0LmMKaW5kZXggNDdmOTAx MC4uODExMTIwNCAxMDA2NDQKLS0tIGEvaHcveGVuL3hlbl9wdF9jb25maWdfaW5pdC5jCisrKyBi L2h3L3hlbi94ZW5fcHRfY29uZmlnX2luaXQuYwpAQCAtMTUsNyArMTUsNyBAQAogI2luY2x1ZGUg InFlbXUvb3NkZXAuaCIKICNpbmNsdWRlICJxYXBpL2Vycm9yLmgiCiAjaW5jbHVkZSAicWVtdS90 aW1lci5oIgotI2luY2x1ZGUgImh3L3hlbi94ZW5fYmFja2VuZC5oIgorI2luY2x1ZGUgImh3L3hl bi94ZW4tbGVnYWN5LWJhY2tlbmQuaCIKICNpbmNsdWRlICJ4ZW5fcHQuaCIKIAogI2RlZmluZSBY RU5fUFRfTUVSR0VfVkFMVUUodmFsdWUsIGRhdGEsIHZhbF9tYXNrKSBcCmRpZmYgLS1naXQgYS9o dy94ZW4veGVuX3B0X2dyYXBoaWNzLmMgYi9ody94ZW4veGVuX3B0X2dyYXBoaWNzLmMKaW5kZXgg MTM1YzhkZi4uMTMwY2M2YyAxMDA2NDQKLS0tIGEvaHcveGVuL3hlbl9wdF9ncmFwaGljcy5jCisr KyBiL2h3L3hlbi94ZW5fcHRfZ3JhcGhpY3MuYwpAQCAtNSw3ICs1LDcgQEAKICNpbmNsdWRlICJx YXBpL2Vycm9yLmgiCiAjaW5jbHVkZSAieGVuX3B0LmgiCiAjaW5jbHVkZSAieGVuLWhvc3QtcGNp LWRldmljZS5oIgotI2luY2x1ZGUgImh3L3hlbi94ZW5fYmFja2VuZC5oIgorI2luY2x1ZGUgImh3 L3hlbi94ZW4tbGVnYWN5LWJhY2tlbmQuaCIKIAogc3RhdGljIHVuc2lnbmVkIGxvbmcgaWdkX2d1 ZXN0X29wcmVnaW9uOwogc3RhdGljIHVuc2lnbmVkIGxvbmcgaWdkX2hvc3Rfb3ByZWdpb247CmRp ZmYgLS1naXQgYS9ody94ZW4veGVuX3B0X21zaS5jIGIvaHcveGVuL3hlbl9wdF9tc2kuYwppbmRl eCBjYzUxNGY5Li5mYjRiODg3IDEwMDY0NAotLS0gYS9ody94ZW4veGVuX3B0X21zaS5jCisrKyBi L2h3L3hlbi94ZW5fcHRfbXNpLmMKQEAgLTExLDcgKzExLDcgQEAKIAogI2luY2x1ZGUgInFlbXUv b3NkZXAuaCIKIAotI2luY2x1ZGUgImh3L3hlbi94ZW5fYmFja2VuZC5oIgorI2luY2x1ZGUgImh3 L3hlbi94ZW4tbGVnYWN5LWJhY2tlbmQuaCIKICNpbmNsdWRlICJ4ZW5fcHQuaCIKICNpbmNsdWRl ICJody9pMzg2L2FwaWMtbXNpZGVmLmgiCiAKZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW5fcHZkZXYu YyBiL2h3L3hlbi94ZW5fcHZkZXYuYwppbmRleCBhZWQ3ODNlLi42MWRlMDkxIDEwMDY0NAotLS0g YS9ody94ZW4veGVuX3B2ZGV2LmMKKysrIGIvaHcveGVuL3hlbl9wdmRldi5jCkBAIC0yMCw3ICsy MCw3IEBACiAjaW5jbHVkZSAicWVtdS9vc2RlcC5oIgogI2luY2x1ZGUgInFlbXUvbG9nLmgiCiAj aW5jbHVkZSAiaHcvcWRldi1jb3JlLmgiCi0jaW5jbHVkZSAiaHcveGVuL3hlbl9iYWNrZW5kLmgi CisjaW5jbHVkZSAiaHcveGVuL3hlbi1sZWdhY3ktYmFja2VuZC5oIgogI2luY2x1ZGUgImh3L3hl bi94ZW5fcHZkZXYuaCIKIAogLyogcHJpdmF0ZSAqLwpAQCAtMzQsNyArMzQsNyBAQCBzdHJ1Y3Qg eHNfZGlycyB7CiBzdGF0aWMgUVRBSUxRX0hFQUQoeHNfZGlyc19oZWFkLCB4c19kaXJzKSB4c19j bGVhbnVwID0KICAgICBRVEFJTFFfSEVBRF9JTklUSUFMSVpFUih4c19jbGVhbnVwKTsKIAotc3Rh dGljIFFUQUlMUV9IRUFEKFhlbkRldmljZUhlYWQsIFhlbkRldmljZSkgeGVuZGV2cyA9CitzdGF0 aWMgUVRBSUxRX0hFQUQoWGVuTGVnYWN5RGV2aWNlSGVhZCwgWGVuTGVnYWN5RGV2aWNlKSB4ZW5k ZXZzID0KICAgICBRVEFJTFFfSEVBRF9JTklUSUFMSVpFUih4ZW5kZXZzKTsKIAogLyogLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAq LwpAQCAtMTk1LDcgKzE5NSw3IEBAIGNvbnN0IGNoYXIgKnhlbmJ1c19zdHJzdGF0ZShlbnVtIHhl bmJ1c19zdGF0ZSBzdGF0ZSkKICAqICAyID09IG5vaXN5IGRlYnVnIG1lc3NhZ2VzIChsb2dmaWxl IG9ubHkpLgogICogIDMgPT0gd2lsbCBmbG9vZCB5b3VyIGxvZyAobG9nZmlsZSBvbmx5KS4KICAq Lwotdm9pZCB4ZW5fcHZfcHJpbnRmKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgaW50IG1zZ19s ZXZlbCwKK3ZvaWQgeGVuX3B2X3ByaW50ZihzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYs IGludCBtc2dfbGV2ZWwsCiAgICAgICAgICAgICAgICAgICAgY29uc3QgY2hhciAqZm10LCAuLi4p CiB7CiAgICAgdmFfbGlzdCBhcmdzOwpAQCAtMjMwLDcgKzIzMCw3IEBAIHZvaWQgeGVuX3B2X3By aW50ZihzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYsIGludCBtc2dfbGV2ZWwsCiAKIHZvaWQgeGVu X3B2X2V2dGNobl9ldmVudCh2b2lkICpvcGFxdWUpCiB7Ci0gICAgc3RydWN0IFhlbkRldmljZSAq eGVuZGV2ID0gb3BhcXVlOworICAgIHN0cnVjdCBYZW5MZWdhY3lEZXZpY2UgKnhlbmRldiA9IG9w YXF1ZTsKICAgICBldnRjaG5fcG9ydF90IHBvcnQ7CiAKICAgICBwb3J0ID0geGVuZXZ0Y2huX3Bl bmRpbmcoeGVuZGV2LT5ldnRjaG5kZXYpOwpAQCAtMjQ3LDcgKzI0Nyw3IEBAIHZvaWQgeGVuX3B2 X2V2dGNobl9ldmVudCh2b2lkICpvcGFxdWUpCiAgICAgfQogfQogCi12b2lkIHhlbl9wdl91bmJp bmRfZXZ0Y2huKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldikKK3ZvaWQgeGVuX3B2X3VuYmluZF9l dnRjaG4oc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2KQogewogICAgIGlmICh4ZW5kZXYt PmxvY2FsX3BvcnQgPT0gLTEpIHsKICAgICAgICAgcmV0dXJuOwpAQCAtMjU4LDE2ICsyNTgsMTYg QEAgdm9pZCB4ZW5fcHZfdW5iaW5kX2V2dGNobihzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpCiAg ICAgeGVuZGV2LT5sb2NhbF9wb3J0ID0gLTE7CiB9CiAKLWludCB4ZW5fcHZfc2VuZF9ub3RpZnko c3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQoraW50IHhlbl9wdl9zZW5kX25vdGlmeShzdHJ1Y3Qg WGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpCiB7CiAgICAgcmV0dXJuIHhlbmV2dGNobl9ub3RpZnko eGVuZGV2LT5ldnRjaG5kZXYsIHhlbmRldi0+bG9jYWxfcG9ydCk7CiB9CiAKIC8qIC0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8K IAotc3RydWN0IFhlbkRldmljZSAqeGVuX3B2X2ZpbmRfeGVuZGV2KGNvbnN0IGNoYXIgKnR5cGUs IGludCBkb20sIGludCBkZXYpCitzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5fcHZfZmluZF94 ZW5kZXYoY29uc3QgY2hhciAqdHlwZSwgaW50IGRvbSwgaW50IGRldikKIHsKLSAgICBzdHJ1Y3Qg WGVuRGV2aWNlICp4ZW5kZXY7CisgICAgc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2Owog CiAgICAgUVRBSUxRX0ZPUkVBQ0goeGVuZGV2LCAmeGVuZGV2cywgbmV4dCkgewogICAgICAgICBp ZiAoeGVuZGV2LT5kb20gIT0gZG9tKSB7CkBAIC0yODcsNyArMjg3LDcgQEAgc3RydWN0IFhlbkRl dmljZSAqeGVuX3B2X2ZpbmRfeGVuZGV2KGNvbnN0IGNoYXIgKnR5cGUsIGludCBkb20sIGludCBk ZXYpCiAvKgogICogcmVsZWFzZSB4ZW4gYmFja2VuZCBkZXZpY2UuCiAgKi8KLXZvaWQgeGVuX3B2 X2RlbF94ZW5kZXYoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQordm9pZCB4ZW5fcHZfZGVsX3hl bmRldihzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpCiB7CiAgICAgaWYgKHhlbmRldi0+ b3BzLT5mcmVlKSB7CiAgICAgICAgIHhlbmRldi0+b3BzLT5mcmVlKHhlbmRldik7CkBAIC0zMTIs NyArMzEyLDcgQEAgdm9pZCB4ZW5fcHZfZGVsX3hlbmRldihzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5k ZXYpCiAgICAgcWRldl91bnBsdWcoJnhlbmRldi0+cWRldiwgTlVMTCk7CiB9CiAKLXZvaWQgeGVu X3B2X2luc2VydF94ZW5kZXYoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KQordm9pZCB4ZW5fcHZf aW5zZXJ0X3hlbmRldihzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpCiB7CiAgICAgUVRB SUxRX0lOU0VSVF9UQUlMKCZ4ZW5kZXZzLCB4ZW5kZXYsIG5leHQpOwogfQpkaWZmIC0tZ2l0IGEv aHcveGVucHYveGVuX2RvbWFpbmJ1aWxkLmMgYi9ody94ZW5wdi94ZW5fZG9tYWluYnVpbGQuYwpp bmRleCAxODhhY2FjLi5kZWIyOGNmIDEwMDY0NAotLS0gYS9ody94ZW5wdi94ZW5fZG9tYWluYnVp bGQuYworKysgYi9ody94ZW5wdi94ZW5fZG9tYWluYnVpbGQuYwpAQCAtMSw2ICsxLDYgQEAKICNp bmNsdWRlICJxZW11L29zZGVwLmgiCiAjaW5jbHVkZSAicWVtdS91bml0cy5oIgotI2luY2x1ZGUg Imh3L3hlbi94ZW5fYmFja2VuZC5oIgorI2luY2x1ZGUgImh3L3hlbi94ZW4tbGVnYWN5LWJhY2tl bmQuaCIKICNpbmNsdWRlICJ4ZW5fZG9tYWluYnVpbGQuaCIKICNpbmNsdWRlICJxZW11L3RpbWVy LmgiCiAjaW5jbHVkZSAicWVtdS9sb2cuaCIKZGlmZiAtLWdpdCBhL2h3L3hlbnB2L3hlbl9tYWNo aW5lX3B2LmMgYi9ody94ZW5wdi94ZW5fbWFjaGluZV9wdi5jCmluZGV4IDQ0ZDY3YjguLjhjODZm YjcgMTAwNjQ0Ci0tLSBhL2h3L3hlbnB2L3hlbl9tYWNoaW5lX3B2LmMKKysrIGIvaHcveGVucHYv eGVuX21hY2hpbmVfcHYuYwpAQCAtMjYsNyArMjYsNyBAQAogI2luY2x1ZGUgInFlbXUvZXJyb3It cmVwb3J0LmgiCiAjaW5jbHVkZSAiaHcvaHcuaCIKICNpbmNsdWRlICJody9ib2FyZHMuaCIKLSNp bmNsdWRlICJody94ZW4veGVuX2JhY2tlbmQuaCIKKyNpbmNsdWRlICJody94ZW4veGVuLWxlZ2Fj eS1iYWNrZW5kLmgiCiAjaW5jbHVkZSAieGVuX2RvbWFpbmJ1aWxkLmgiCiAjaW5jbHVkZSAic3lz ZW11L2Jsb2NrLWJhY2tlbmQuaCIKIApkaWZmIC0tZ2l0IGEvaW5jbHVkZS9ody94ZW4veGVuLWxl Z2FjeS1iYWNrZW5kLmggYi9pbmNsdWRlL2h3L3hlbi94ZW4tbGVnYWN5LWJhY2tlbmQuaApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yMGNiNDdiCi0tLSAvZGV2L251bGwKKysr IGIvaW5jbHVkZS9ody94ZW4veGVuLWxlZ2FjeS1iYWNrZW5kLmgKQEAgLTAsMCArMSwxMDQgQEAK KyNpZm5kZWYgUUVNVV9IV19YRU5fQkFDS0VORF9ICisjZGVmaW5lIFFFTVVfSFdfWEVOX0JBQ0tF TkRfSAorCisjaW5jbHVkZSAiaHcveGVuL3hlbl9jb21tb24uaCIKKyNpbmNsdWRlICJody94ZW4v eGVuX3B2ZGV2LmgiCisjaW5jbHVkZSAic3lzZW11L3N5c2VtdS5oIgorI2luY2x1ZGUgIm5ldC9u ZXQuaCIKKworI2RlZmluZSBUWVBFX1hFTlNZU0RFViAieGVuLXN5c2RldiIKKyNkZWZpbmUgVFlQ RV9YRU5TWVNCVVMgInhlbi1zeXNidXMiCisjZGVmaW5lIFRZUEVfWEVOQkFDS0VORCAieGVuLWJh Y2tlbmQiCisKKyNkZWZpbmUgWEVOQkFDS0VORF9ERVZJQ0Uob2JqKSBcCisgICAgT0JKRUNUX0NI RUNLKFhlbkxlZ2FjeURldmljZSwgKG9iaiksIFRZUEVfWEVOQkFDS0VORCkKKworLyogdmFyaWFi bGVzICovCitleHRlcm4gc3RydWN0IHhzX2hhbmRsZSAqeGVuc3RvcmU7CitleHRlcm4gY29uc3Qg Y2hhciAqeGVuX3Byb3RvY29sOworZXh0ZXJuIERldmljZVN0YXRlICp4ZW5fc3lzZGV2OworZXh0 ZXJuIEJ1c1N0YXRlICp4ZW5fc3lzYnVzOworCitpbnQgeGVuc3RvcmVfbWtkaXIoY2hhciAqcGF0 aCwgaW50IHApOworaW50IHhlbnN0b3JlX3dyaXRlX2JlX3N0cihzdHJ1Y3QgWGVuTGVnYWN5RGV2 aWNlICp4ZW5kZXYsIGNvbnN0IGNoYXIgKm5vZGUsCisgICAgICAgICAgICAgICAgICAgICAgICAg IGNvbnN0IGNoYXIgKnZhbCk7CitpbnQgeGVuc3RvcmVfd3JpdGVfYmVfaW50KHN0cnVjdCBYZW5M ZWdhY3lEZXZpY2UgKnhlbmRldiwgY29uc3QgY2hhciAqbm9kZSwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgaW50IGl2YWwpOworaW50IHhlbnN0b3JlX3dyaXRlX2JlX2ludDY0KHN0cnVjdCBY ZW5MZWdhY3lEZXZpY2UgKnhlbmRldiwgY29uc3QgY2hhciAqbm9kZSwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgICBpbnQ2NF90IGl2YWwpOworY2hhciAqeGVuc3RvcmVfcmVhZF9iZV9zdHIo c3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2LCBjb25zdCBjaGFyICpub2RlKTsKK2ludCB4 ZW5zdG9yZV9yZWFkX2JlX2ludChzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYsIGNvbnN0 IGNoYXIgKm5vZGUsCisgICAgICAgICAgICAgICAgICAgICAgICAgaW50ICppdmFsKTsKK3ZvaWQg eGVuc3RvcmVfdXBkYXRlX2ZlKGNoYXIgKndhdGNoLCBzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4 ZW5kZXYpOwordm9pZCB4ZW5zdG9yZV91cGRhdGVfYmUoY2hhciAqd2F0Y2gsIGNoYXIgKnR5cGUs IGludCBkb20sCisgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3QgWGVuRGV2T3BzICpvcHMp OworY2hhciAqeGVuc3RvcmVfcmVhZF9mZV9zdHIoc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVu ZGV2LCBjb25zdCBjaGFyICpub2RlKTsKK2ludCB4ZW5zdG9yZV9yZWFkX2ZlX2ludChzdHJ1Y3Qg WGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYsIGNvbnN0IGNoYXIgKm5vZGUsCisgICAgICAgICAgICAg ICAgICAgICAgICAgaW50ICppdmFsKTsKK2ludCB4ZW5zdG9yZV9yZWFkX2ZlX3VpbnQ2NChzdHJ1 Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYsIGNvbnN0IGNoYXIgKm5vZGUsCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgdWludDY0X3QgKnV2YWwpOworCit2b2lkIHhlbl9iZV9jaGVja19z dGF0ZShzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYpOworCisvKiB4ZW4gYmFja2VuZCBk cml2ZXIgYml0cyAqLworaW50IHhlbl9iZV9pbml0KHZvaWQpOwordm9pZCB4ZW5fYmVfcmVnaXN0 ZXJfY29tbW9uKHZvaWQpOworaW50IHhlbl9iZV9yZWdpc3Rlcihjb25zdCBjaGFyICp0eXBlLCBz dHJ1Y3QgWGVuRGV2T3BzICpvcHMpOworaW50IHhlbl9iZV9zZXRfc3RhdGUoc3RydWN0IFhlbkxl Z2FjeURldmljZSAqeGVuZGV2LCBlbnVtIHhlbmJ1c19zdGF0ZSBzdGF0ZSk7CitpbnQgeGVuX2Jl X2JpbmRfZXZ0Y2huKHN0cnVjdCBYZW5MZWdhY3lEZXZpY2UgKnhlbmRldik7Cit2b2lkIHhlbl9i ZV9zZXRfbWF4X2dyYW50X3JlZnMoc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2LAorICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGludCBucl9yZWZzKTsKK3ZvaWQg Knhlbl9iZV9tYXBfZ3JhbnRfcmVmcyhzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYsIHVp bnQzMl90ICpyZWZzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGludCBu cl9yZWZzLCBpbnQgcHJvdCk7Cit2b2lkIHhlbl9iZV91bm1hcF9ncmFudF9yZWZzKHN0cnVjdCBY ZW5MZWdhY3lEZXZpY2UgKnhlbmRldiwgdm9pZCAqcHRyLAorICAgICAgICAgICAgICAgICAgICAg ICAgICAgICB1bnNpZ25lZCBpbnQgbnJfcmVmcyk7CisKK3R5cGVkZWYgc3RydWN0IFhlbkdyYW50 Q29weVNlZ21lbnQgeworICAgIHVuaW9uIHsKKyAgICAgICAgdm9pZCAqdmlydDsKKyAgICAgICAg c3RydWN0IHsKKyAgICAgICAgICAgIHVpbnQzMl90IHJlZjsKKyAgICAgICAgICAgIG9mZl90IG9m ZnNldDsKKyAgICAgICAgfSBmb3JlaWduOworICAgIH0gc291cmNlLCBkZXN0OworICAgIHNpemVf dCBsZW47Cit9IFhlbkdyYW50Q29weVNlZ21lbnQ7CisKK2ludCB4ZW5fYmVfY29weV9ncmFudF9y ZWZzKHN0cnVjdCBYZW5MZWdhY3lEZXZpY2UgKnhlbmRldiwKKyAgICAgICAgICAgICAgICAgICAg ICAgICAgIGJvb2wgdG9fZG9tYWluLCBYZW5HcmFudENvcHlTZWdtZW50IHNlZ3NbXSwKKyAgICAg ICAgICAgICAgICAgICAgICAgICAgIHVuc2lnbmVkIGludCBucl9zZWdzKTsKKworc3RhdGljIGlu bGluZSB2b2lkICp4ZW5fYmVfbWFwX2dyYW50X3JlZihzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4 ZW5kZXYsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVpbnQzMl90 IHJlZiwgaW50IHByb3QpCit7CisgICAgcmV0dXJuIHhlbl9iZV9tYXBfZ3JhbnRfcmVmcyh4ZW5k ZXYsICZyZWYsIDEsIHByb3QpOworfQorCitzdGF0aWMgaW5saW5lIHZvaWQgeGVuX2JlX3VubWFw X2dyYW50X3JlZihzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYsCisgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2b2lkICpwdHIpCit7CisgICAgcmV0dXJuIHhl bl9iZV91bm1hcF9ncmFudF9yZWZzKHhlbmRldiwgcHRyLCAxKTsKK30KKworLyogYWN0dWFsIGJh Y2tlbmQgZHJpdmVycyAqLworZXh0ZXJuIHN0cnVjdCBYZW5EZXZPcHMgeGVuX2NvbnNvbGVfb3Bz OyAgICAgIC8qIHhlbl9jb25zb2xlLmMgICAgICovCitleHRlcm4gc3RydWN0IFhlbkRldk9wcyB4 ZW5fa2JkbW91c2Vfb3BzOyAgICAgLyogeGVuX2ZyYW1lYnVmZmVyLmMgKi8KK2V4dGVybiBzdHJ1 Y3QgWGVuRGV2T3BzIHhlbl9mcmFtZWJ1ZmZlcl9vcHM7ICAvKiB4ZW5fZnJhbWVidWZmZXIuYyAq LworZXh0ZXJuIHN0cnVjdCBYZW5EZXZPcHMgeGVuX2Jsa2Rldl9vcHM7ICAgICAgIC8qIHhlbl9k aXNrLmMgICAgICAgICovCisjaWZkZWYgQ09ORklHX1ZJUlRGUworZXh0ZXJuIHN0cnVjdCBYZW5E ZXZPcHMgeGVuXzlwZnNfb3BzOyAgICAgICAvKiB4ZW4tOXAtYmFja2VuZC5jICAgICAgICAqLwor I2VuZGlmCitleHRlcm4gc3RydWN0IFhlbkRldk9wcyB4ZW5fbmV0ZGV2X29wczsgICAgICAgLyog eGVuX25pYy5jICAgICAgICAgKi8KKyNpZmRlZiBDT05GSUdfVVNCX0xJQlVTQgorZXh0ZXJuIHN0 cnVjdCBYZW5EZXZPcHMgeGVuX3VzYl9vcHM7ICAgICAgICAgIC8qIHhlbi11c2IuYyAgICAgICAg ICovCisjZW5kaWYKKworLyogY29uZmlndXJhdGlvbiAoYWthIHhlbmJ1cyBzZXR1cCkgKi8KK3Zv aWQgeGVuX2NvbmZpZ19jbGVhbnVwKHZvaWQpOworaW50IHhlbl9jb25maWdfZGV2X2JsayhEcml2 ZUluZm8gKmRpc2spOworaW50IHhlbl9jb25maWdfZGV2X25pYyhOSUNJbmZvICpuaWMpOworaW50 IHhlbl9jb25maWdfZGV2X3ZmYihpbnQgdmRldiwgY29uc3QgY2hhciAqdHlwZSk7CitpbnQgeGVu X2NvbmZpZ19kZXZfdmtiZChpbnQgdmRldik7CitpbnQgeGVuX2NvbmZpZ19kZXZfY29uc29sZShp bnQgdmRldik7CisKKyNlbmRpZiAvKiBRRU1VX0hXX1hFTl9CQUNLRU5EX0ggKi8KZGlmZiAtLWdp dCBhL2luY2x1ZGUvaHcveGVuL3hlbl9iYWNrZW5kLmggYi9pbmNsdWRlL2h3L3hlbi94ZW5fYmFj a2VuZC5oCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA5YzE3ZmRkLi4wMDAwMDAwCi0t LSBhL2luY2x1ZGUvaHcveGVuL3hlbl9iYWNrZW5kLmgKKysrIC9kZXYvbnVsbApAQCAtMSw5OSAr MCwwIEBACi0jaWZuZGVmIFFFTVVfSFdfWEVOX0JBQ0tFTkRfSAotI2RlZmluZSBRRU1VX0hXX1hF Tl9CQUNLRU5EX0gKLQotI2luY2x1ZGUgImh3L3hlbi94ZW5fY29tbW9uLmgiCi0jaW5jbHVkZSAi aHcveGVuL3hlbl9wdmRldi5oIgotI2luY2x1ZGUgInN5c2VtdS9zeXNlbXUuaCIKLSNpbmNsdWRl ICJuZXQvbmV0LmgiCi0KLSNkZWZpbmUgVFlQRV9YRU5TWVNERVYgInhlbi1zeXNkZXYiCi0jZGVm aW5lIFRZUEVfWEVOU1lTQlVTICJ4ZW4tc3lzYnVzIgotI2RlZmluZSBUWVBFX1hFTkJBQ0tFTkQg Inhlbi1iYWNrZW5kIgotCi0jZGVmaW5lIFhFTkJBQ0tFTkRfREVWSUNFKG9iaikgXAotICAgIE9C SkVDVF9DSEVDSyhYZW5EZXZpY2UsIChvYmopLCBUWVBFX1hFTkJBQ0tFTkQpCi0KLS8qIHZhcmlh YmxlcyAqLwotZXh0ZXJuIHN0cnVjdCB4c19oYW5kbGUgKnhlbnN0b3JlOwotZXh0ZXJuIGNvbnN0 IGNoYXIgKnhlbl9wcm90b2NvbDsKLWV4dGVybiBEZXZpY2VTdGF0ZSAqeGVuX3N5c2RldjsKLWV4 dGVybiBCdXNTdGF0ZSAqeGVuX3N5c2J1czsKLQotaW50IHhlbnN0b3JlX21rZGlyKGNoYXIgKnBh dGgsIGludCBwKTsKLWludCB4ZW5zdG9yZV93cml0ZV9iZV9zdHIoc3RydWN0IFhlbkRldmljZSAq eGVuZGV2LCBjb25zdCBjaGFyICpub2RlLCBjb25zdCBjaGFyICp2YWwpOwotaW50IHhlbnN0b3Jl X3dyaXRlX2JlX2ludChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYsIGNvbnN0IGNoYXIgKm5vZGUs IGludCBpdmFsKTsKLWludCB4ZW5zdG9yZV93cml0ZV9iZV9pbnQ2NChzdHJ1Y3QgWGVuRGV2aWNl ICp4ZW5kZXYsIGNvbnN0IGNoYXIgKm5vZGUsIGludDY0X3QgaXZhbCk7Ci1jaGFyICp4ZW5zdG9y ZV9yZWFkX2JlX3N0cihzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYsIGNvbnN0IGNoYXIgKm5vZGUp OwotaW50IHhlbnN0b3JlX3JlYWRfYmVfaW50KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgY29u c3QgY2hhciAqbm9kZSwgaW50ICppdmFsKTsKLXZvaWQgeGVuc3RvcmVfdXBkYXRlX2ZlKGNoYXIg KndhdGNoLCBzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpOwotdm9pZCB4ZW5zdG9yZV91cGRhdGVf YmUoY2hhciAqd2F0Y2gsIGNoYXIgKnR5cGUsIGludCBkb20sCi0gICAgICAgICAgICAgICAgICAg ICAgICBzdHJ1Y3QgWGVuRGV2T3BzICpvcHMpOwotY2hhciAqeGVuc3RvcmVfcmVhZF9mZV9zdHIo c3RydWN0IFhlbkRldmljZSAqeGVuZGV2LCBjb25zdCBjaGFyICpub2RlKTsKLWludCB4ZW5zdG9y ZV9yZWFkX2ZlX2ludChzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYsIGNvbnN0IGNoYXIgKm5vZGUs IGludCAqaXZhbCk7Ci1pbnQgeGVuc3RvcmVfcmVhZF9mZV91aW50NjQoc3RydWN0IFhlbkRldmlj ZSAqeGVuZGV2LCBjb25zdCBjaGFyICpub2RlLAotICAgICAgICAgICAgICAgICAgICAgICAgICAg IHVpbnQ2NF90ICp1dmFsKTsKLQotdm9pZCB4ZW5fYmVfY2hlY2tfc3RhdGUoc3RydWN0IFhlbkRl dmljZSAqeGVuZGV2KTsKLQotLyogeGVuIGJhY2tlbmQgZHJpdmVyIGJpdHMgKi8KLWludCB4ZW5f YmVfaW5pdCh2b2lkKTsKLXZvaWQgeGVuX2JlX3JlZ2lzdGVyX2NvbW1vbih2b2lkKTsKLWludCB4 ZW5fYmVfcmVnaXN0ZXIoY29uc3QgY2hhciAqdHlwZSwgc3RydWN0IFhlbkRldk9wcyAqb3BzKTsK LWludCB4ZW5fYmVfc2V0X3N0YXRlKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgZW51bSB4ZW5i dXNfc3RhdGUgc3RhdGUpOwotaW50IHhlbl9iZV9iaW5kX2V2dGNobihzdHJ1Y3QgWGVuRGV2aWNl ICp4ZW5kZXYpOwotdm9pZCB4ZW5fYmVfc2V0X21heF9ncmFudF9yZWZzKHN0cnVjdCBYZW5EZXZp Y2UgKnhlbmRldiwKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBpbnQg bnJfcmVmcyk7Ci12b2lkICp4ZW5fYmVfbWFwX2dyYW50X3JlZnMoc3RydWN0IFhlbkRldmljZSAq eGVuZGV2LCB1aW50MzJfdCAqcmVmcywKLSAgICAgICAgICAgICAgICAgICAgICAgICAgICB1bnNp Z25lZCBpbnQgbnJfcmVmcywgaW50IHByb3QpOwotdm9pZCB4ZW5fYmVfdW5tYXBfZ3JhbnRfcmVm cyhzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYsIHZvaWQgKnB0ciwKLSAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgdW5zaWduZWQgaW50IG5yX3JlZnMpOwotCi10eXBlZGVmIHN0cnVjdCBYZW5H cmFudENvcHlTZWdtZW50IHsKLSAgICB1bmlvbiB7Ci0gICAgICAgIHZvaWQgKnZpcnQ7Ci0gICAg ICAgIHN0cnVjdCB7Ci0gICAgICAgICAgICB1aW50MzJfdCByZWY7Ci0gICAgICAgICAgICBvZmZf dCBvZmZzZXQ7Ci0gICAgICAgIH0gZm9yZWlnbjsKLSAgICB9IHNvdXJjZSwgZGVzdDsKLSAgICBz aXplX3QgbGVuOwotfSBYZW5HcmFudENvcHlTZWdtZW50OwotCi1pbnQgeGVuX2JlX2NvcHlfZ3Jh bnRfcmVmcyhzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYsCi0gICAgICAgICAgICAgICAgICAgICAg ICAgICBib29sIHRvX2RvbWFpbiwgWGVuR3JhbnRDb3B5U2VnbWVudCBzZWdzW10sCi0gICAgICAg ICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBpbnQgbnJfc2Vncyk7Ci0KLXN0YXRpYyBpbmxp bmUgdm9pZCAqeGVuX2JlX21hcF9ncmFudF9yZWYoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2LAot ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB1aW50MzJfdCByZWYsIGlu dCBwcm90KQotewotICAgIHJldHVybiB4ZW5fYmVfbWFwX2dyYW50X3JlZnMoeGVuZGV2LCAmcmVm LCAxLCBwcm90KTsKLX0KLQotc3RhdGljIGlubGluZSB2b2lkIHhlbl9iZV91bm1hcF9ncmFudF9y ZWYoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2LAotICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgdm9pZCAqcHRyKQotewotICAgIHJldHVybiB4ZW5fYmVfdW5tYXBfZ3Jh bnRfcmVmcyh4ZW5kZXYsIHB0ciwgMSk7Ci19Ci0KLS8qIGFjdHVhbCBiYWNrZW5kIGRyaXZlcnMg Ki8KLWV4dGVybiBzdHJ1Y3QgWGVuRGV2T3BzIHhlbl9jb25zb2xlX29wczsgICAgICAvKiB4ZW5f Y29uc29sZS5jICAgICAqLwotZXh0ZXJuIHN0cnVjdCBYZW5EZXZPcHMgeGVuX2tiZG1vdXNlX29w czsgICAgIC8qIHhlbl9mcmFtZWJ1ZmZlci5jICovCi1leHRlcm4gc3RydWN0IFhlbkRldk9wcyB4 ZW5fZnJhbWVidWZmZXJfb3BzOyAgLyogeGVuX2ZyYW1lYnVmZmVyLmMgKi8KLWV4dGVybiBzdHJ1 Y3QgWGVuRGV2T3BzIHhlbl9ibGtkZXZfb3BzOyAgICAgICAvKiB4ZW5fZGlzay5jICAgICAgICAq LwotI2lmZGVmIENPTkZJR19WSVJURlMKLWV4dGVybiBzdHJ1Y3QgWGVuRGV2T3BzIHhlbl85cGZz X29wczsgICAgICAgLyogeGVuLTlwLWJhY2tlbmQuYyAgICAgICAgKi8KLSNlbmRpZgotZXh0ZXJu IHN0cnVjdCBYZW5EZXZPcHMgeGVuX25ldGRldl9vcHM7ICAgICAgIC8qIHhlbl9uaWMuYyAgICAg ICAgICovCi0jaWZkZWYgQ09ORklHX1VTQl9MSUJVU0IKLWV4dGVybiBzdHJ1Y3QgWGVuRGV2T3Bz IHhlbl91c2Jfb3BzOyAgICAgICAgICAvKiB4ZW4tdXNiLmMgICAgICAgICAqLwotI2VuZGlmCi0K LS8qIGNvbmZpZ3VyYXRpb24gKGFrYSB4ZW5idXMgc2V0dXApICovCi12b2lkIHhlbl9jb25maWdf Y2xlYW51cCh2b2lkKTsKLWludCB4ZW5fY29uZmlnX2Rldl9ibGsoRHJpdmVJbmZvICpkaXNrKTsK LWludCB4ZW5fY29uZmlnX2Rldl9uaWMoTklDSW5mbyAqbmljKTsKLWludCB4ZW5fY29uZmlnX2Rl dl92ZmIoaW50IHZkZXYsIGNvbnN0IGNoYXIgKnR5cGUpOwotaW50IHhlbl9jb25maWdfZGV2X3Zr YmQoaW50IHZkZXYpOwotaW50IHhlbl9jb25maWdfZGV2X2NvbnNvbGUoaW50IHZkZXYpOwotCi0j ZW5kaWYgLyogUUVNVV9IV19YRU5fQkFDS0VORF9IICovCmRpZmYgLS1naXQgYS9pbmNsdWRlL2h3 L3hlbi94ZW5fcHZkZXYuaCBiL2luY2x1ZGUvaHcveGVuL3hlbl9wdmRldi5oCmluZGV4IGQ0NzNl OWIuLjgzZTUxNzQgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvaHcveGVuL3hlbl9wdmRldi5oCisrKyBi L2luY2x1ZGUvaHcveGVuL3hlbl9wdmRldi5oCkBAIC02LDcgKzYsNyBAQAogCiAjZGVmaW5lIFhF Tl9CVUZTSVpFIDEwMjQKIAotc3RydWN0IFhlbkRldmljZTsKK3N0cnVjdCBYZW5MZWdhY3lEZXZp Y2U7CiAKIC8qIGRyaXZlciB1c2VzIGdyYW50IHRhYmxlcyAgLT4gIG9wZW4gZ250ZGV2IGRldmlj ZSAoeGVuZGV2LT5nbnR0YWJkZXYpICovCiAjZGVmaW5lIERFVk9QU19GTEFHX05FRURfR05UREVW ICAgMQpAQCAtMTYsMTkgKzE2LDIxIEBAIHN0cnVjdCBYZW5EZXZpY2U7CiBzdHJ1Y3QgWGVuRGV2 T3BzIHsKICAgICBzaXplX3QgICAgc2l6ZTsKICAgICB1aW50MzJfdCAgZmxhZ3M7Ci0gICAgdm9p ZCAgICAgICgqYWxsb2MpKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldik7Ci0gICAgaW50ICAgICAg ICgqaW5pdCkoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KTsKLSAgICBpbnQgICAgICAgKCppbml0 aWFsaXNlKShzdHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpOwotICAgIHZvaWQgICAgICAoKmNvbm5l Y3RlZCkoc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KTsKLSAgICB2b2lkICAgICAgKCpldmVudCko c3RydWN0IFhlbkRldmljZSAqeGVuZGV2KTsKLSAgICB2b2lkICAgICAgKCpkaXNjb25uZWN0KShz dHJ1Y3QgWGVuRGV2aWNlICp4ZW5kZXYpOwotICAgIGludCAgICAgICAoKmZyZWUpKHN0cnVjdCBY ZW5EZXZpY2UgKnhlbmRldik7Ci0gICAgdm9pZCAgICAgICgqYmFja2VuZF9jaGFuZ2VkKShzdHJ1 Y3QgWGVuRGV2aWNlICp4ZW5kZXYsIGNvbnN0IGNoYXIgKm5vZGUpOwotICAgIHZvaWQgICAgICAo KmZyb250ZW5kX2NoYW5nZWQpKHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldiwgY29uc3QgY2hhciAq bm9kZSk7CisgICAgdm9pZCAgICAgICgqYWxsb2MpKHN0cnVjdCBYZW5MZWdhY3lEZXZpY2UgKnhl bmRldik7CisgICAgaW50ICAgICAgICgqaW5pdCkoc3RydWN0IFhlbkxlZ2FjeURldmljZSAqeGVu ZGV2KTsKKyAgICBpbnQgICAgICAgKCppbml0aWFsaXNlKShzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNl ICp4ZW5kZXYpOworICAgIHZvaWQgICAgICAoKmNvbm5lY3RlZCkoc3RydWN0IFhlbkxlZ2FjeURl dmljZSAqeGVuZGV2KTsKKyAgICB2b2lkICAgICAgKCpldmVudCkoc3RydWN0IFhlbkxlZ2FjeURl dmljZSAqeGVuZGV2KTsKKyAgICB2b2lkICAgICAgKCpkaXNjb25uZWN0KShzdHJ1Y3QgWGVuTGVn YWN5RGV2aWNlICp4ZW5kZXYpOworICAgIGludCAgICAgICAoKmZyZWUpKHN0cnVjdCBYZW5MZWdh Y3lEZXZpY2UgKnhlbmRldik7CisgICAgdm9pZCAgICAgICgqYmFja2VuZF9jaGFuZ2VkKShzdHJ1 Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICBjb25zdCBjaGFyICpub2RlKTsKKyAgICB2b2lkICAgICAgKCpmcm9udGVuZF9jaGFuZ2Vk KShzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgY29uc3QgY2hhciAqbm9kZSk7CiAgICAgaW50ICAgICAgICgqYmFja2VuZF9y ZWdpc3Rlcikodm9pZCk7CiB9OwogCi1zdHJ1Y3QgWGVuRGV2aWNlIHsKK3N0cnVjdCBYZW5MZWdh Y3lEZXZpY2UgewogICAgIERldmljZVN0YXRlICAgICAgICBxZGV2OwogICAgIGNvbnN0IGNoYXIg ICAgICAgICAqdHlwZTsKICAgICBpbnQgICAgICAgICAgICAgICAgZG9tOwpAQCAtNDksNyArNTEs NyBAQCBzdHJ1Y3QgWGVuRGV2aWNlIHsKICAgICB4ZW5nbnR0YWJfaGFuZGxlICAgKmdudHRhYmRl djsKIAogICAgIHN0cnVjdCBYZW5EZXZPcHMgICAqb3BzOwotICAgIFFUQUlMUV9FTlRSWShYZW5E ZXZpY2UpIG5leHQ7CisgICAgUVRBSUxRX0VOVFJZKFhlbkxlZ2FjeURldmljZSkgbmV4dDsKIH07 CiAKIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0gKi8KQEAgLTY2LDE0ICs2OCwxNCBAQCB2b2lkIHhlbnN0b3JlX3VwZGF0ZSh2 b2lkICp1bnVzZWQpOwogY29uc3QgY2hhciAqeGVuYnVzX3N0cnN0YXRlKGVudW0geGVuYnVzX3N0 YXRlIHN0YXRlKTsKIAogdm9pZCB4ZW5fcHZfZXZ0Y2huX2V2ZW50KHZvaWQgKm9wYXF1ZSk7Ci12 b2lkIHhlbl9wdl9pbnNlcnRfeGVuZGV2KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldik7Ci12b2lk IHhlbl9wdl9kZWxfeGVuZGV2KHN0cnVjdCBYZW5EZXZpY2UgKnhlbmRldik7Ci1zdHJ1Y3QgWGVu RGV2aWNlICp4ZW5fcHZfZmluZF94ZW5kZXYoY29uc3QgY2hhciAqdHlwZSwgaW50IGRvbSwgaW50 IGRldik7Cit2b2lkIHhlbl9wdl9pbnNlcnRfeGVuZGV2KHN0cnVjdCBYZW5MZWdhY3lEZXZpY2Ug KnhlbmRldik7Cit2b2lkIHhlbl9wdl9kZWxfeGVuZGV2KHN0cnVjdCBYZW5MZWdhY3lEZXZpY2Ug KnhlbmRldik7CitzdHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5fcHZfZmluZF94ZW5kZXYoY29u c3QgY2hhciAqdHlwZSwgaW50IGRvbSwgaW50IGRldik7CiAKLXZvaWQgeGVuX3B2X3VuYmluZF9l dnRjaG4oc3RydWN0IFhlbkRldmljZSAqeGVuZGV2KTsKLWludCB4ZW5fcHZfc2VuZF9ub3RpZnko c3RydWN0IFhlbkRldmljZSAqeGVuZGV2KTsKK3ZvaWQgeGVuX3B2X3VuYmluZF9ldnRjaG4oc3Ry dWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2KTsKK2ludCB4ZW5fcHZfc2VuZF9ub3RpZnkoc3Ry dWN0IFhlbkxlZ2FjeURldmljZSAqeGVuZGV2KTsKIAotdm9pZCB4ZW5fcHZfcHJpbnRmKHN0cnVj dCBYZW5EZXZpY2UgKnhlbmRldiwgaW50IG1zZ19sZXZlbCwKK3ZvaWQgeGVuX3B2X3ByaW50Zihz dHJ1Y3QgWGVuTGVnYWN5RGV2aWNlICp4ZW5kZXYsIGludCBtc2dfbGV2ZWwsCiAgICAgICAgICAg ICAgICAgICAgY29uc3QgY2hhciAqZm10LCAuLi4pICBHQ0NfRk1UX0FUVFIoMywgNCk7CiAKICNl bmRpZiAvKiBRRU1VX0hXX1hFTl9QVkRFVl9IICovCi0tIAoyLjEuNAoKCl9fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5nIGxpc3QK WGVuLWRldmVsQGxpc3RzLnhlbnByb2plY3Qub3JnCmh0dHBzOi8vbGlzdHMueGVucHJvamVjdC5v cmcvbWFpbG1hbi9saXN0aW5mby94ZW4tZGV2ZWw= From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:56120) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gWfa9-0004OL-3b for qemu-devel@nongnu.org; Tue, 11 Dec 2018 05:48:13 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1gWfa1-0000HG-PC for qemu-devel@nongnu.org; Tue, 11 Dec 2018 05:48:05 -0500 From: Paul Durrant Date: Tue, 11 Dec 2018 10:47:01 +0000 Message-ID: <1544525238-3527-2-git-send-email-paul.durrant@citrix.com> In-Reply-To: <1544525238-3527-1-git-send-email-paul.durrant@citrix.com> References: <1544525238-3527-1-git-send-email-paul.durrant@citrix.com> MIME-Version: 1.0 Content-Type: text/plain; charset="UTF-8" Content-Transfer-Encoding: 8bit Subject: [Qemu-devel] [PATCH v3 01/18] xen: re-name XenDevice to XenLegacyDevice... List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: qemu-devel@nongnu.org, qemu-block@nongnu.org, xen-devel@lists.xenproject.org Cc: Paul Durrant , Stefano Stabellini , Greg Kurz , Kevin Wolf , Max Reitz , =?UTF-8?q?Marc-Andr=C3=A9=20Lureau?= , Paolo Bonzini , Richard Henderson , Eduardo Habkost , "Michael S. Tsirkin" , Marcel Apfelbaum , Jason Wang , Gerd Hoffmann ...and xen_backend.h to xen-legacy-backend.h Rather than attempting to convert the existing backend infrastructure to be QOM compliant (which would be hard to do in an incremental fashion), subsequent patches will introduce a completely new framework for Xen PV backends. Hence it is necessary to re-name parts of existing code to avoid name clashes. The re-named 'legacy' infrastructure will be removed once all backends have been ported to the new framework. This patch is purely cosmetic. No functional change. Signed-off-by: Paul Durrant Acked-by: Anthony Perard --- Cc: Stefano Stabellini Cc: Greg Kurz Cc: Kevin Wolf Cc: Max Reitz Cc: "Marc-André Lureau" Cc: Paolo Bonzini Cc: Richard Henderson Cc: Eduardo Habkost Cc: "Michael S. Tsirkin" Cc: Marcel Apfelbaum Cc: Jason Wang Cc: Gerd Hoffmann --- hw/9pfs/xen-9p-backend.c | 16 +- hw/block/xen_disk.c | 24 +- hw/char/xen_console.c | 12 +- hw/display/xenfb.c | 25 +- hw/i386/xen/xen-hvm.c | 2 +- hw/i386/xen/xen-mapcache.c | 2 +- hw/i386/xen/xen_platform.c | 2 +- hw/net/xen_nic.c | 14 +- hw/usb/xen-usb.c | 25 +- hw/xen/Makefile.objs | 2 +- hw/xen/xen-common.c | 2 +- hw/xen/xen-legacy-backend.c | 854 ++++++++++++++++++++++++++++++++++++ hw/xen/xen_backend.c | 845 ----------------------------------- hw/xen/xen_devconfig.c | 2 +- hw/xen/xen_pt.c | 2 +- hw/xen/xen_pt_config_init.c | 2 +- hw/xen/xen_pt_graphics.c | 2 +- hw/xen/xen_pt_msi.c | 2 +- hw/xen/xen_pvdev.c | 20 +- hw/xenpv/xen_domainbuild.c | 2 +- hw/xenpv/xen_machine_pv.c | 2 +- include/hw/xen/xen-legacy-backend.h | 104 +++++ include/hw/xen/xen_backend.h | 99 ----- include/hw/xen/xen_pvdev.h | 38 +- 24 files changed, 1059 insertions(+), 1041 deletions(-) create mode 100644 hw/xen/xen-legacy-backend.c delete mode 100644 hw/xen/xen_backend.c create mode 100644 include/hw/xen/xen-legacy-backend.h delete mode 100644 include/hw/xen/xen_backend.h diff --git a/hw/9pfs/xen-9p-backend.c b/hw/9pfs/xen-9p-backend.c index 3f54a21..3859a06 100644 --- a/hw/9pfs/xen-9p-backend.c +++ b/hw/9pfs/xen-9p-backend.c @@ -12,7 +12,7 @@ #include "hw/hw.h" #include "hw/9pfs/9p.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include "hw/9pfs/xen-9pfs.h" #include "qapi/error.h" #include "qemu/config-file.h" @@ -45,7 +45,7 @@ typedef struct Xen9pfsRing { } Xen9pfsRing; typedef struct Xen9pfsDev { - struct XenDevice xendev; /* must be first */ + struct XenLegacyDevice xendev; /* must be first */ V9fsState state; char *path; char *security_model; @@ -56,7 +56,7 @@ typedef struct Xen9pfsDev { Xen9pfsRing *rings; } Xen9pfsDev; -static void xen_9pfs_disconnect(struct XenDevice *xendev); +static void xen_9pfs_disconnect(struct XenLegacyDevice *xendev); static void xen_9pfs_in_sg(Xen9pfsRing *ring, struct iovec *in_sg, @@ -243,7 +243,7 @@ static const V9fsTransport xen_9p_transport = { .push_and_notify = xen_9pfs_push_and_notify, }; -static int xen_9pfs_init(struct XenDevice *xendev) +static int xen_9pfs_init(struct XenLegacyDevice *xendev) { return 0; } @@ -305,7 +305,7 @@ static void xen_9pfs_evtchn_event(void *opaque) qemu_bh_schedule(ring->bh); } -static void xen_9pfs_disconnect(struct XenDevice *xendev) +static void xen_9pfs_disconnect(struct XenLegacyDevice *xendev) { Xen9pfsDev *xen_9pdev = container_of(xendev, Xen9pfsDev, xendev); int i; @@ -321,7 +321,7 @@ static void xen_9pfs_disconnect(struct XenDevice *xendev) } } -static int xen_9pfs_free(struct XenDevice *xendev) +static int xen_9pfs_free(struct XenLegacyDevice *xendev) { Xen9pfsDev *xen_9pdev = container_of(xendev, Xen9pfsDev, xendev); int i; @@ -354,7 +354,7 @@ static int xen_9pfs_free(struct XenDevice *xendev) return 0; } -static int xen_9pfs_connect(struct XenDevice *xendev) +static int xen_9pfs_connect(struct XenLegacyDevice *xendev) { Error *err = NULL; int i; @@ -467,7 +467,7 @@ out: return -1; } -static void xen_9pfs_alloc(struct XenDevice *xendev) +static void xen_9pfs_alloc(struct XenLegacyDevice *xendev) { xenstore_write_be_str(xendev, "versions", VERSIONS); xenstore_write_be_int(xendev, "max-rings", MAX_RINGS); diff --git a/hw/block/xen_disk.c b/hw/block/xen_disk.c index 36eff94..75fe55f 100644 --- a/hw/block/xen_disk.c +++ b/hw/block/xen_disk.c @@ -25,7 +25,7 @@ #include #include "hw/hw.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include "xen_blkif.h" #include "sysemu/blockdev.h" #include "sysemu/iothread.h" @@ -63,7 +63,7 @@ struct ioreq { #define MAX_RING_PAGE_ORDER 4 struct XenBlkDev { - struct XenDevice xendev; /* must be first */ + struct XenLegacyDevice xendev; /* must be first */ char *params; char *mode; char *type; @@ -179,7 +179,7 @@ static void ioreq_release(struct ioreq *ioreq, bool finish) static int ioreq_parse(struct ioreq *ioreq) { struct XenBlkDev *blkdev = ioreq->blkdev; - struct XenDevice *xendev = &blkdev->xendev; + struct XenLegacyDevice *xendev = &blkdev->xendev; size_t len; int i; @@ -243,7 +243,7 @@ err: static int ioreq_grant_copy(struct ioreq *ioreq) { struct XenBlkDev *blkdev = ioreq->blkdev; - struct XenDevice *xendev = &blkdev->xendev; + struct XenLegacyDevice *xendev = &blkdev->xendev; XenGrantCopySegment segs[BLKIF_MAX_SEGMENTS_PER_REQUEST]; int i, count, rc; int64_t file_blk = blkdev->file_blk; @@ -289,7 +289,7 @@ static void qemu_aio_complete(void *opaque, int ret) { struct ioreq *ioreq = opaque; struct XenBlkDev *blkdev = ioreq->blkdev; - struct XenDevice *xendev = &blkdev->xendev; + struct XenLegacyDevice *xendev = &blkdev->xendev; aio_context_acquire(blkdev->ctx); @@ -608,7 +608,7 @@ static void blk_bh(void *opaque) aio_context_release(blkdev->ctx); } -static void blk_alloc(struct XenDevice *xendev) +static void blk_alloc(struct XenLegacyDevice *xendev) { struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); Error *err = NULL; @@ -628,7 +628,7 @@ static void blk_alloc(struct XenDevice *xendev) static void blk_parse_discard(struct XenBlkDev *blkdev) { - struct XenDevice *xendev = &blkdev->xendev; + struct XenLegacyDevice *xendev = &blkdev->xendev; int enable; blkdev->feature_discard = true; @@ -642,7 +642,7 @@ static void blk_parse_discard(struct XenBlkDev *blkdev) } } -static int blk_init(struct XenDevice *xendev) +static int blk_init(struct XenLegacyDevice *xendev) { struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); int info = 0; @@ -737,7 +737,7 @@ out_error: return -1; } -static int blk_connect(struct XenDevice *xendev) +static int blk_connect(struct XenLegacyDevice *xendev) { struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); int index, qflags; @@ -941,7 +941,7 @@ static int blk_connect(struct XenDevice *xendev) return 0; } -static void blk_disconnect(struct XenDevice *xendev) +static void blk_disconnect(struct XenLegacyDevice *xendev) { struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); @@ -966,7 +966,7 @@ static void blk_disconnect(struct XenDevice *xendev) } } -static int blk_free(struct XenDevice *xendev) +static int blk_free(struct XenLegacyDevice *xendev) { struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); struct ioreq *ioreq; @@ -992,7 +992,7 @@ static int blk_free(struct XenDevice *xendev) return 0; } -static void blk_event(struct XenDevice *xendev) +static void blk_event(struct XenLegacyDevice *xendev) { struct XenBlkDev *blkdev = container_of(xendev, struct XenBlkDev, xendev); diff --git a/hw/char/xen_console.c b/hw/char/xen_console.c index 44f7236..460adc1 100644 --- a/hw/char/xen_console.c +++ b/hw/char/xen_console.c @@ -26,7 +26,7 @@ #include "qapi/error.h" #include "hw/hw.h" #include "chardev/char-fe.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include @@ -39,7 +39,7 @@ struct buffer { }; struct XenConsole { - struct XenDevice xendev; /* must be first */ + struct XenLegacyDevice xendev; /* must be first */ struct buffer buffer; char console[XEN_BUFSIZE]; int ring_ref; @@ -173,7 +173,7 @@ static void xencons_send(struct XenConsole *con) /* -------------------------------------------------------------------- */ -static int con_init(struct XenDevice *xendev) +static int con_init(struct XenLegacyDevice *xendev) { struct XenConsole *con = container_of(xendev, struct XenConsole, xendev); char *type, *dom, label[32]; @@ -222,7 +222,7 @@ out: return ret; } -static int con_initialise(struct XenDevice *xendev) +static int con_initialise(struct XenLegacyDevice *xendev) { struct XenConsole *con = container_of(xendev, struct XenConsole, xendev); int limit; @@ -259,7 +259,7 @@ static int con_initialise(struct XenDevice *xendev) return 0; } -static void con_disconnect(struct XenDevice *xendev) +static void con_disconnect(struct XenLegacyDevice *xendev) { struct XenConsole *con = container_of(xendev, struct XenConsole, xendev); @@ -276,7 +276,7 @@ static void con_disconnect(struct XenDevice *xendev) } } -static void con_event(struct XenDevice *xendev) +static void con_event(struct XenLegacyDevice *xendev) { struct XenConsole *con = container_of(xendev, struct XenConsole, xendev); diff --git a/hw/display/xenfb.c b/hw/display/xenfb.c index 0330dc6..6202f11 100644 --- a/hw/display/xenfb.c +++ b/hw/display/xenfb.c @@ -30,7 +30,7 @@ #include "hw/hw.h" #include "ui/input.h" #include "ui/console.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include #include @@ -46,7 +46,7 @@ /* -------------------------------------------------------------------- */ struct common { - struct XenDevice xendev; /* must be first */ + struct XenLegacyDevice xendev; /* must be first */ void *page; }; @@ -342,14 +342,14 @@ static QemuInputHandler xenfb_rel_mouse = { .sync = xenfb_mouse_sync, }; -static int input_init(struct XenDevice *xendev) +static int input_init(struct XenLegacyDevice *xendev) { xenstore_write_be_int(xendev, "feature-abs-pointer", 1); xenstore_write_be_int(xendev, "feature-raw-pointer", 1); return 0; } -static int input_initialise(struct XenDevice *xendev) +static int input_initialise(struct XenLegacyDevice *xendev) { struct XenInput *in = container_of(xendev, struct XenInput, c.xendev); int rc; @@ -361,7 +361,7 @@ static int input_initialise(struct XenDevice *xendev) return 0; } -static void input_connected(struct XenDevice *xendev) +static void input_connected(struct XenLegacyDevice *xendev) { struct XenInput *in = container_of(xendev, struct XenInput, c.xendev); @@ -395,7 +395,7 @@ static void input_connected(struct XenDevice *xendev) } } -static void input_disconnect(struct XenDevice *xendev) +static void input_disconnect(struct XenLegacyDevice *xendev) { struct XenInput *in = container_of(xendev, struct XenInput, c.xendev); @@ -410,7 +410,7 @@ static void input_disconnect(struct XenDevice *xendev) common_unbind(&in->c); } -static void input_event(struct XenDevice *xendev) +static void input_event(struct XenLegacyDevice *xendev) { struct XenInput *xenfb = container_of(xendev, struct XenInput, c.xendev); struct xenkbd_page *page = xenfb->c.page; @@ -867,7 +867,7 @@ static void xenfb_handle_events(struct XenFB *xenfb) page->out_cons = cons; } -static int fb_init(struct XenDevice *xendev) +static int fb_init(struct XenLegacyDevice *xendev) { #ifdef XENFB_TYPE_RESIZE xenstore_write_be_int(xendev, "feature-resize", 1); @@ -875,7 +875,7 @@ static int fb_init(struct XenDevice *xendev) return 0; } -static int fb_initialise(struct XenDevice *xendev) +static int fb_initialise(struct XenLegacyDevice *xendev) { struct XenFB *fb = container_of(xendev, struct XenFB, c.xendev); struct xenfb_page *fb_page; @@ -912,7 +912,7 @@ static int fb_initialise(struct XenDevice *xendev) return 0; } -static void fb_disconnect(struct XenDevice *xendev) +static void fb_disconnect(struct XenLegacyDevice *xendev) { struct XenFB *fb = container_of(xendev, struct XenFB, c.xendev); @@ -935,7 +935,8 @@ static void fb_disconnect(struct XenDevice *xendev) fb->bug_trigger = 0; } -static void fb_frontend_changed(struct XenDevice *xendev, const char *node) +static void fb_frontend_changed(struct XenLegacyDevice *xendev, + const char *node) { struct XenFB *fb = container_of(xendev, struct XenFB, c.xendev); @@ -953,7 +954,7 @@ static void fb_frontend_changed(struct XenDevice *xendev, const char *node) } } -static void fb_event(struct XenDevice *xendev) +static void fb_event(struct XenLegacyDevice *xendev) { struct XenFB *xenfb = container_of(xendev, struct XenFB, c.xendev); diff --git a/hw/i386/xen/xen-hvm.c b/hw/i386/xen/xen-hvm.c index 935a367..1d63763 100644 --- a/hw/i386/xen/xen-hvm.c +++ b/hw/i386/xen/xen-hvm.c @@ -16,7 +16,7 @@ #include "hw/i386/pc.h" #include "hw/i386/apic-msidef.h" #include "hw/xen/xen_common.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include "qapi/error.h" #include "qapi/qapi-commands-misc.h" #include "qemu/error-report.h" diff --git a/hw/i386/xen/xen-mapcache.c b/hw/i386/xen/xen-mapcache.c index 4e4f069..9134a7b 100644 --- a/hw/i386/xen/xen-mapcache.c +++ b/hw/i386/xen/xen-mapcache.c @@ -14,7 +14,7 @@ #include -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include "qemu/bitmap.h" #include diff --git a/hw/i386/xen/xen_platform.c b/hw/i386/xen/xen_platform.c index deb7a0c..16afb54 100644 --- a/hw/i386/xen/xen_platform.c +++ b/hw/i386/xen/xen_platform.c @@ -30,7 +30,7 @@ #include "hw/pci/pci.h" #include "hw/irq.h" #include "hw/xen/xen_common.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include "trace.h" #include "exec/address-spaces.h" #include "sysemu/block-backend.h" diff --git a/hw/net/xen_nic.c b/hw/net/xen_nic.c index 46a8dbf..37cda8e 100644 --- a/hw/net/xen_nic.c +++ b/hw/net/xen_nic.c @@ -28,14 +28,14 @@ #include "net/net.h" #include "net/checksum.h" #include "net/util.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include /* ------------------------------------------------------------- */ struct XenNetDev { - struct XenDevice xendev; /* must be first */ + struct XenLegacyDevice xendev; /* must be first */ char *mac; int tx_work; int tx_ring_ref; @@ -276,7 +276,7 @@ static NetClientInfo net_xen_info = { .receive = net_rx_packet, }; -static int net_init(struct XenDevice *xendev) +static int net_init(struct XenLegacyDevice *xendev) { struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev); @@ -308,7 +308,7 @@ static int net_init(struct XenDevice *xendev) return 0; } -static int net_connect(struct XenDevice *xendev) +static int net_connect(struct XenLegacyDevice *xendev) { struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev); int rx_copy; @@ -363,7 +363,7 @@ static int net_connect(struct XenDevice *xendev) return 0; } -static void net_disconnect(struct XenDevice *xendev) +static void net_disconnect(struct XenLegacyDevice *xendev) { struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev); @@ -379,14 +379,14 @@ static void net_disconnect(struct XenDevice *xendev) } } -static void net_event(struct XenDevice *xendev) +static void net_event(struct XenLegacyDevice *xendev) { struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev); net_tx_packets(netdev); qemu_flush_queued_packets(qemu_get_queue(netdev->nic)); } -static int net_free(struct XenDevice *xendev) +static int net_free(struct XenLegacyDevice *xendev) { struct XenNetDev *netdev = container_of(xendev, struct XenNetDev, xendev); diff --git a/hw/usb/xen-usb.c b/hw/usb/xen-usb.c index 5b2e21e..9b2da6e 100644 --- a/hw/usb/xen-usb.c +++ b/hw/usb/xen-usb.c @@ -27,7 +27,7 @@ #include "qemu/option.h" #include "hw/sysbus.h" #include "hw/usb.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include "monitor/qdev.h" #include "qapi/qmp/qdict.h" #include "qapi/qmp/qstring.h" @@ -99,7 +99,7 @@ struct usbback_hotplug { }; struct usbback_info { - struct XenDevice xendev; /* must be first */ + struct XenLegacyDevice xendev; /* must be first */ USBBus bus; void *urb_sring; void *conn_sring; @@ -142,7 +142,7 @@ static int usbback_gnttab_map(struct usbback_req *usbback_req) unsigned int nr_segs, i, prot; uint32_t ref[USBIF_MAX_SEGMENTS_PER_REQUEST]; struct usbback_info *usbif = usbback_req->usbif; - struct XenDevice *xendev = &usbif->xendev; + struct XenLegacyDevice *xendev = &usbif->xendev; struct usbif_request_segment *seg; void *addr; @@ -220,7 +220,7 @@ static int usbback_gnttab_map(struct usbback_req *usbback_req) static int usbback_init_packet(struct usbback_req *usbback_req) { - struct XenDevice *xendev = &usbback_req->usbif->xendev; + struct XenLegacyDevice *xendev = &usbback_req->usbif->xendev; USBPacket *packet = &usbback_req->packet; USBDevice *dev = usbback_req->stub->dev; USBEndpoint *ep; @@ -279,7 +279,7 @@ static void usbback_do_response(struct usbback_req *usbback_req, int32_t status, { struct usbback_info *usbif; struct usbif_urb_response *res; - struct XenDevice *xendev; + struct XenLegacyDevice *xendev; unsigned int notify; usbif = usbback_req->usbif; @@ -824,7 +824,7 @@ static void usbback_process_port(struct usbback_info *usbif, unsigned port) g_free(busid); } -static void usbback_disconnect(struct XenDevice *xendev) +static void usbback_disconnect(struct XenLegacyDevice *xendev) { struct usbback_info *usbif; unsigned int i; @@ -853,7 +853,7 @@ static void usbback_disconnect(struct XenDevice *xendev) TR_BUS(xendev, "finished\n"); } -static int usbback_connect(struct XenDevice *xendev) +static int usbback_connect(struct XenLegacyDevice *xendev) { struct usbback_info *usbif; struct usbif_urb_sring *urb_sring; @@ -909,7 +909,8 @@ static int usbback_connect(struct XenDevice *xendev) return 0; } -static void usbback_backend_changed(struct XenDevice *xendev, const char *node) +static void usbback_backend_changed(struct XenLegacyDevice *xendev, + const char *node) { struct usbback_info *usbif; unsigned int i; @@ -922,7 +923,7 @@ static void usbback_backend_changed(struct XenDevice *xendev, const char *node) } } -static int usbback_init(struct XenDevice *xendev) +static int usbback_init(struct XenLegacyDevice *xendev) { struct usbback_info *usbif; @@ -1001,7 +1002,7 @@ static USBPortOps xen_usb_port_ops = { static USBBusOps xen_usb_bus_ops = { }; -static void usbback_alloc(struct XenDevice *xendev) +static void usbback_alloc(struct XenLegacyDevice *xendev) { struct usbback_info *usbif; USBPort *p; @@ -1027,7 +1028,7 @@ static void usbback_alloc(struct XenDevice *xendev) xen_be_set_max_grant_refs(xendev, max_grants); } -static int usbback_free(struct XenDevice *xendev) +static int usbback_free(struct XenLegacyDevice *xendev) { struct usbback_info *usbif; struct usbback_req *usbback_req; @@ -1066,7 +1067,7 @@ static int usbback_free(struct XenDevice *xendev) return 0; } -static void usbback_event(struct XenDevice *xendev) +static void usbback_event(struct XenLegacyDevice *xendev) { struct usbback_info *usbif; diff --git a/hw/xen/Makefile.objs b/hw/xen/Makefile.objs index 9ea5c73..3f64a44 100644 --- a/hw/xen/Makefile.objs +++ b/hw/xen/Makefile.objs @@ -1,5 +1,5 @@ # xen backend driver support -common-obj-$(CONFIG_XEN) += xen_backend.o xen_devconfig.o xen_pvdev.o xen-common.o +common-obj-$(CONFIG_XEN) += xen-legacy-backend.o xen_devconfig.o xen_pvdev.o xen-common.o obj-$(CONFIG_XEN_PCI_PASSTHROUGH) += xen-host-pci-device.o obj-$(CONFIG_XEN_PCI_PASSTHROUGH) += xen_pt.o xen_pt_config_init.o xen_pt_graphics.o xen_pt_msi.o diff --git a/hw/xen/xen-common.c b/hw/xen/xen-common.c index 6ec14c7..ef130b2 100644 --- a/hw/xen/xen-common.c +++ b/hw/xen/xen-common.c @@ -10,7 +10,7 @@ #include "qemu/osdep.h" #include "qemu/error-report.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include "chardev/char.h" #include "sysemu/accel.h" #include "migration/misc.h" diff --git a/hw/xen/xen-legacy-backend.c b/hw/xen/xen-legacy-backend.c new file mode 100644 index 0000000..0c26023 --- /dev/null +++ b/hw/xen/xen-legacy-backend.c @@ -0,0 +1,854 @@ +/* + * xen backend driver infrastructure + * (c) 2008 Gerd Hoffmann + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; under version 2 of the License. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License along + * with this program; if not, see . + * + * Contributions after 2012-01-13 are licensed under the terms of the + * GNU GPL, version 2 or (at your option) any later version. + */ + +/* + * TODO: add some xenbus / xenstore concepts overview here. + */ + +#include "qemu/osdep.h" +#include + +#include "hw/hw.h" +#include "hw/sysbus.h" +#include "hw/boards.h" +#include "qemu/log.h" +#include "qapi/error.h" +#include "hw/xen/xen-legacy-backend.h" +#include "hw/xen/xen_pvdev.h" +#include "monitor/qdev.h" + +#include + +DeviceState *xen_sysdev; +BusState *xen_sysbus; + +/* ------------------------------------------------------------- */ + +/* public */ +struct xs_handle *xenstore; +const char *xen_protocol; + +/* private */ +static bool xen_feature_grant_copy; +static int debug; + +int xenstore_write_be_str(struct XenLegacyDevice *xendev, const char *node, + const char *val) +{ + return xenstore_write_str(xendev->be, node, val); +} + +int xenstore_write_be_int(struct XenLegacyDevice *xendev, const char *node, + int ival) +{ + return xenstore_write_int(xendev->be, node, ival); +} + +int xenstore_write_be_int64(struct XenLegacyDevice *xendev, const char *node, + int64_t ival) +{ + return xenstore_write_int64(xendev->be, node, ival); +} + +char *xenstore_read_be_str(struct XenLegacyDevice *xendev, const char *node) +{ + return xenstore_read_str(xendev->be, node); +} + +int xenstore_read_be_int(struct XenLegacyDevice *xendev, const char *node, + int *ival) +{ + return xenstore_read_int(xendev->be, node, ival); +} + +char *xenstore_read_fe_str(struct XenLegacyDevice *xendev, const char *node) +{ + return xenstore_read_str(xendev->fe, node); +} + +int xenstore_read_fe_int(struct XenLegacyDevice *xendev, const char *node, + int *ival) +{ + return xenstore_read_int(xendev->fe, node, ival); +} + +int xenstore_read_fe_uint64(struct XenLegacyDevice *xendev, const char *node, + uint64_t *uval) +{ + return xenstore_read_uint64(xendev->fe, node, uval); +} + +/* ------------------------------------------------------------- */ + +int xen_be_set_state(struct XenLegacyDevice *xendev, enum xenbus_state state) +{ + int rc; + + rc = xenstore_write_be_int(xendev, "state", state); + if (rc < 0) { + return rc; + } + xen_pv_printf(xendev, 1, "backend state: %s -> %s\n", + xenbus_strstate(xendev->be_state), xenbus_strstate(state)); + xendev->be_state = state; + return 0; +} + +void xen_be_set_max_grant_refs(struct XenLegacyDevice *xendev, + unsigned int nr_refs) +{ + assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV); + + if (xengnttab_set_max_grants(xendev->gnttabdev, nr_refs)) { + xen_pv_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n", + strerror(errno)); + } +} + +void *xen_be_map_grant_refs(struct XenLegacyDevice *xendev, uint32_t *refs, + unsigned int nr_refs, int prot) +{ + void *ptr; + + assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV); + + ptr = xengnttab_map_domain_grant_refs(xendev->gnttabdev, nr_refs, + xen_domid, refs, prot); + if (!ptr) { + xen_pv_printf(xendev, 0, + "xengnttab_map_domain_grant_refs failed: %s\n", + strerror(errno)); + } + + return ptr; +} + +void xen_be_unmap_grant_refs(struct XenLegacyDevice *xendev, void *ptr, + unsigned int nr_refs) +{ + assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV); + + if (xengnttab_unmap(xendev->gnttabdev, ptr, nr_refs)) { + xen_pv_printf(xendev, 0, "xengnttab_unmap failed: %s\n", + strerror(errno)); + } +} + +static int compat_copy_grant_refs(struct XenLegacyDevice *xendev, + bool to_domain, + XenGrantCopySegment segs[], + unsigned int nr_segs) +{ + uint32_t *refs = g_new(uint32_t, nr_segs); + int prot = to_domain ? PROT_WRITE : PROT_READ; + void *pages; + unsigned int i; + + for (i = 0; i < nr_segs; i++) { + XenGrantCopySegment *seg = &segs[i]; + + refs[i] = to_domain ? + seg->dest.foreign.ref : seg->source.foreign.ref; + } + + pages = xengnttab_map_domain_grant_refs(xendev->gnttabdev, nr_segs, + xen_domid, refs, prot); + if (!pages) { + xen_pv_printf(xendev, 0, + "xengnttab_map_domain_grant_refs failed: %s\n", + strerror(errno)); + g_free(refs); + return -1; + } + + for (i = 0; i < nr_segs; i++) { + XenGrantCopySegment *seg = &segs[i]; + void *page = pages + (i * XC_PAGE_SIZE); + + if (to_domain) { + memcpy(page + seg->dest.foreign.offset, seg->source.virt, + seg->len); + } else { + memcpy(seg->dest.virt, page + seg->source.foreign.offset, + seg->len); + } + } + + if (xengnttab_unmap(xendev->gnttabdev, pages, nr_segs)) { + xen_pv_printf(xendev, 0, "xengnttab_unmap failed: %s\n", + strerror(errno)); + } + + g_free(refs); + return 0; +} + +int xen_be_copy_grant_refs(struct XenLegacyDevice *xendev, + bool to_domain, + XenGrantCopySegment segs[], + unsigned int nr_segs) +{ + xengnttab_grant_copy_segment_t *xengnttab_segs; + unsigned int i; + int rc; + + assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV); + + if (!xen_feature_grant_copy) { + return compat_copy_grant_refs(xendev, to_domain, segs, nr_segs); + } + + xengnttab_segs = g_new0(xengnttab_grant_copy_segment_t, nr_segs); + + for (i = 0; i < nr_segs; i++) { + XenGrantCopySegment *seg = &segs[i]; + xengnttab_grant_copy_segment_t *xengnttab_seg = &xengnttab_segs[i]; + + if (to_domain) { + xengnttab_seg->flags = GNTCOPY_dest_gref; + xengnttab_seg->dest.foreign.domid = xen_domid; + xengnttab_seg->dest.foreign.ref = seg->dest.foreign.ref; + xengnttab_seg->dest.foreign.offset = seg->dest.foreign.offset; + xengnttab_seg->source.virt = seg->source.virt; + } else { + xengnttab_seg->flags = GNTCOPY_source_gref; + xengnttab_seg->source.foreign.domid = xen_domid; + xengnttab_seg->source.foreign.ref = seg->source.foreign.ref; + xengnttab_seg->source.foreign.offset = + seg->source.foreign.offset; + xengnttab_seg->dest.virt = seg->dest.virt; + } + + xengnttab_seg->len = seg->len; + } + + rc = xengnttab_grant_copy(xendev->gnttabdev, nr_segs, xengnttab_segs); + + if (rc) { + xen_pv_printf(xendev, 0, "xengnttab_copy failed: %s\n", + strerror(errno)); + } + + for (i = 0; i < nr_segs; i++) { + xengnttab_grant_copy_segment_t *xengnttab_seg = + &xengnttab_segs[i]; + + if (xengnttab_seg->status != GNTST_okay) { + xen_pv_printf(xendev, 0, "segment[%u] status: %d\n", i, + xengnttab_seg->status); + rc = -1; + } + } + + g_free(xengnttab_segs); + return rc; +} + +/* + * get xen backend device, allocate a new one if it doesn't exist. + */ +static struct XenLegacyDevice *xen_be_get_xendev(const char *type, int dom, + int dev, + struct XenDevOps *ops) +{ + struct XenLegacyDevice *xendev; + + xendev = xen_pv_find_xendev(type, dom, dev); + if (xendev) { + return xendev; + } + + /* init new xendev */ + xendev = g_malloc0(ops->size); + object_initialize(&xendev->qdev, ops->size, TYPE_XENBACKEND); + OBJECT(xendev)->free = g_free; + qdev_set_parent_bus(DEVICE(xendev), xen_sysbus); + qdev_set_id(DEVICE(xendev), g_strdup_printf("xen-%s-%d", type, dev)); + qdev_init_nofail(DEVICE(xendev)); + object_unref(OBJECT(xendev)); + + xendev->type = type; + xendev->dom = dom; + xendev->dev = dev; + xendev->ops = ops; + + snprintf(xendev->be, sizeof(xendev->be), "backend/%s/%d/%d", + xendev->type, xendev->dom, xendev->dev); + snprintf(xendev->name, sizeof(xendev->name), "%s-%d", + xendev->type, xendev->dev); + + xendev->debug = debug; + xendev->local_port = -1; + + xendev->evtchndev = xenevtchn_open(NULL, 0); + if (xendev->evtchndev == NULL) { + xen_pv_printf(NULL, 0, "can't open evtchn device\n"); + qdev_unplug(DEVICE(xendev), NULL); + return NULL; + } + qemu_set_cloexec(xenevtchn_fd(xendev->evtchndev)); + + xen_pv_insert_xendev(xendev); + + if (xendev->ops->alloc) { + xendev->ops->alloc(xendev); + } + + return xendev; +} + + +/* + * Sync internal data structures on xenstore updates. + * Node specifies the changed field. node = NULL means + * update all fields (used for initialization). + */ +static void xen_be_backend_changed(struct XenLegacyDevice *xendev, + const char *node) +{ + if (node == NULL || strcmp(node, "online") == 0) { + if (xenstore_read_be_int(xendev, "online", &xendev->online) == -1) { + xendev->online = 0; + } + } + + if (node) { + xen_pv_printf(xendev, 2, "backend update: %s\n", node); + if (xendev->ops->backend_changed) { + xendev->ops->backend_changed(xendev, node); + } + } +} + +static void xen_be_frontend_changed(struct XenLegacyDevice *xendev, + const char *node) +{ + int fe_state; + + if (node == NULL || strcmp(node, "state") == 0) { + if (xenstore_read_fe_int(xendev, "state", &fe_state) == -1) { + fe_state = XenbusStateUnknown; + } + if (xendev->fe_state != fe_state) { + xen_pv_printf(xendev, 1, "frontend state: %s -> %s\n", + xenbus_strstate(xendev->fe_state), + xenbus_strstate(fe_state)); + } + xendev->fe_state = fe_state; + } + if (node == NULL || strcmp(node, "protocol") == 0) { + g_free(xendev->protocol); + xendev->protocol = xenstore_read_fe_str(xendev, "protocol"); + if (xendev->protocol) { + xen_pv_printf(xendev, 1, "frontend protocol: %s\n", + xendev->protocol); + } + } + + if (node) { + xen_pv_printf(xendev, 2, "frontend update: %s\n", node); + if (xendev->ops->frontend_changed) { + xendev->ops->frontend_changed(xendev, node); + } + } +} + +/* ------------------------------------------------------------- */ +/* Check for possible state transitions and perform them. */ + +/* + * Initial xendev setup. Read frontend path, register watch for it. + * Should succeed once xend finished setting up the backend device. + * + * Also sets initial state (-> Initializing) when done. Which + * only affects the xendev->be_state variable as xenbus should + * already be put into that state by xend. + */ +static int xen_be_try_setup(struct XenLegacyDevice *xendev) +{ + char token[XEN_BUFSIZE]; + int be_state; + + if (xenstore_read_be_int(xendev, "state", &be_state) == -1) { + xen_pv_printf(xendev, 0, "reading backend state failed\n"); + return -1; + } + + if (be_state != XenbusStateInitialising) { + xen_pv_printf(xendev, 0, "initial backend state is wrong (%s)\n", + xenbus_strstate(be_state)); + return -1; + } + + xendev->fe = xenstore_read_be_str(xendev, "frontend"); + if (xendev->fe == NULL) { + xen_pv_printf(xendev, 0, "reading frontend path failed\n"); + return -1; + } + + /* setup frontend watch */ + snprintf(token, sizeof(token), "fe:%p", xendev); + if (!xs_watch(xenstore, xendev->fe, token)) { + xen_pv_printf(xendev, 0, "watching frontend path (%s) failed\n", + xendev->fe); + return -1; + } + xen_be_set_state(xendev, XenbusStateInitialising); + + xen_be_backend_changed(xendev, NULL); + xen_be_frontend_changed(xendev, NULL); + return 0; +} + +/* + * Try initialize xendev. Prepare everything the backend can do + * without synchronizing with the frontend. Fakes hotplug-status. No + * hotplug involved here because this is about userspace drivers, thus + * there are kernel backend devices which could invoke hotplug. + * + * Goes to InitWait on success. + */ +static int xen_be_try_init(struct XenLegacyDevice *xendev) +{ + int rc = 0; + + if (!xendev->online) { + xen_pv_printf(xendev, 1, "not online\n"); + return -1; + } + + if (xendev->ops->init) { + rc = xendev->ops->init(xendev); + } + if (rc != 0) { + xen_pv_printf(xendev, 1, "init() failed\n"); + return rc; + } + + xenstore_write_be_str(xendev, "hotplug-status", "connected"); + xen_be_set_state(xendev, XenbusStateInitWait); + return 0; +} + +/* + * Try to initialise xendev. Depends on the frontend being ready + * for it (shared ring and evtchn info in xenstore, state being + * Initialised or Connected). + * + * Goes to Connected on success. + */ +static int xen_be_try_initialise(struct XenLegacyDevice *xendev) +{ + int rc = 0; + + if (xendev->fe_state != XenbusStateInitialised && + xendev->fe_state != XenbusStateConnected) { + if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) { + xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n"); + } else { + xen_pv_printf(xendev, 2, "frontend not ready (yet)\n"); + return -1; + } + } + + if (xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV) { + xendev->gnttabdev = xengnttab_open(NULL, 0); + if (xendev->gnttabdev == NULL) { + xen_pv_printf(NULL, 0, "can't open gnttab device\n"); + return -1; + } + } else { + xendev->gnttabdev = NULL; + } + + if (xendev->ops->initialise) { + rc = xendev->ops->initialise(xendev); + } + if (rc != 0) { + xen_pv_printf(xendev, 0, "initialise() failed\n"); + return rc; + } + + xen_be_set_state(xendev, XenbusStateConnected); + return 0; +} + +/* + * Try to let xendev know that it is connected. Depends on the + * frontend being Connected. Note that this may be called more + * than once since the backend state is not modified. + */ +static void xen_be_try_connected(struct XenLegacyDevice *xendev) +{ + if (!xendev->ops->connected) { + return; + } + + if (xendev->fe_state != XenbusStateConnected) { + if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) { + xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n"); + } else { + xen_pv_printf(xendev, 2, "frontend not ready (yet)\n"); + return; + } + } + + xendev->ops->connected(xendev); +} + +/* + * Teardown connection. + * + * Goes to Closed when done. + */ +static void xen_be_disconnect(struct XenLegacyDevice *xendev, + enum xenbus_state state) +{ + if (xendev->be_state != XenbusStateClosing && + xendev->be_state != XenbusStateClosed && + xendev->ops->disconnect) { + xendev->ops->disconnect(xendev); + } + if (xendev->gnttabdev) { + xengnttab_close(xendev->gnttabdev); + xendev->gnttabdev = NULL; + } + if (xendev->be_state != state) { + xen_be_set_state(xendev, state); + } +} + +/* + * Try to reset xendev, for reconnection by another frontend instance. + */ +static int xen_be_try_reset(struct XenLegacyDevice *xendev) +{ + if (xendev->fe_state != XenbusStateInitialising) { + return -1; + } + + xen_pv_printf(xendev, 1, "device reset (for re-connect)\n"); + xen_be_set_state(xendev, XenbusStateInitialising); + return 0; +} + +/* + * state change dispatcher function + */ +void xen_be_check_state(struct XenLegacyDevice *xendev) +{ + int rc = 0; + + /* frontend may request shutdown from almost anywhere */ + if (xendev->fe_state == XenbusStateClosing || + xendev->fe_state == XenbusStateClosed) { + xen_be_disconnect(xendev, xendev->fe_state); + return; + } + + /* check for possible backend state transitions */ + for (;;) { + switch (xendev->be_state) { + case XenbusStateUnknown: + rc = xen_be_try_setup(xendev); + break; + case XenbusStateInitialising: + rc = xen_be_try_init(xendev); + break; + case XenbusStateInitWait: + rc = xen_be_try_initialise(xendev); + break; + case XenbusStateConnected: + /* xendev->be_state doesn't change */ + xen_be_try_connected(xendev); + rc = -1; + break; + case XenbusStateClosed: + rc = xen_be_try_reset(xendev); + break; + default: + rc = -1; + } + if (rc != 0) { + break; + } + } +} + +/* ------------------------------------------------------------- */ + +static int xenstore_scan(const char *type, int dom, struct XenDevOps *ops) +{ + struct XenLegacyDevice *xendev; + char path[XEN_BUFSIZE], token[XEN_BUFSIZE]; + char **dev = NULL; + unsigned int cdev, j; + + /* setup watch */ + snprintf(token, sizeof(token), "be:%p:%d:%p", type, dom, ops); + snprintf(path, sizeof(path), "backend/%s/%d", type, dom); + if (!xs_watch(xenstore, path, token)) { + xen_pv_printf(NULL, 0, "xen be: watching backend path (%s) failed\n", + path); + return -1; + } + + /* look for backends */ + dev = xs_directory(xenstore, 0, path, &cdev); + if (!dev) { + return 0; + } + for (j = 0; j < cdev; j++) { + xendev = xen_be_get_xendev(type, dom, atoi(dev[j]), ops); + if (xendev == NULL) { + continue; + } + xen_be_check_state(xendev); + } + free(dev); + return 0; +} + +void xenstore_update_be(char *watch, char *type, int dom, + struct XenDevOps *ops) +{ + struct XenLegacyDevice *xendev; + char path[XEN_BUFSIZE], *bepath; + unsigned int len, dev; + + len = snprintf(path, sizeof(path), "backend/%s/%d", type, dom); + if (strncmp(path, watch, len) != 0) { + return; + } + if (sscanf(watch + len, "/%u/%255s", &dev, path) != 2) { + strcpy(path, ""); + if (sscanf(watch + len, "/%u", &dev) != 1) { + dev = -1; + } + } + if (dev == -1) { + return; + } + + xendev = xen_be_get_xendev(type, dom, dev, ops); + if (xendev != NULL) { + bepath = xs_read(xenstore, 0, xendev->be, &len); + if (bepath == NULL) { + xen_pv_del_xendev(xendev); + } else { + free(bepath); + xen_be_backend_changed(xendev, path); + xen_be_check_state(xendev); + } + } +} + +void xenstore_update_fe(char *watch, struct XenLegacyDevice *xendev) +{ + char *node; + unsigned int len; + + len = strlen(xendev->fe); + if (strncmp(xendev->fe, watch, len) != 0) { + return; + } + if (watch[len] != '/') { + return; + } + node = watch + len + 1; + + xen_be_frontend_changed(xendev, node); + xen_be_check_state(xendev); +} +/* -------------------------------------------------------------------- */ + +int xen_be_init(void) +{ + xengnttab_handle *gnttabdev; + + xenstore = xs_daemon_open(); + if (!xenstore) { + xen_pv_printf(NULL, 0, "can't connect to xenstored\n"); + return -1; + } + + qemu_set_fd_handler(xs_fileno(xenstore), xenstore_update, NULL, NULL); + + if (xen_xc == NULL || xen_fmem == NULL) { + /* Check if xen_init() have been called */ + goto err; + } + + gnttabdev = xengnttab_open(NULL, 0); + if (gnttabdev != NULL) { + if (xengnttab_grant_copy(gnttabdev, 0, NULL) == 0) { + xen_feature_grant_copy = true; + } + xengnttab_close(gnttabdev); + } + + xen_sysdev = qdev_create(NULL, TYPE_XENSYSDEV); + qdev_init_nofail(xen_sysdev); + xen_sysbus = qbus_create(TYPE_XENSYSBUS, DEVICE(xen_sysdev), "xen-sysbus"); + qbus_set_bus_hotplug_handler(xen_sysbus, &error_abort); + + return 0; + +err: + qemu_set_fd_handler(xs_fileno(xenstore), NULL, NULL, NULL); + xs_daemon_close(xenstore); + xenstore = NULL; + + return -1; +} + +static void xen_set_dynamic_sysbus(void) +{ + Object *machine = qdev_get_machine(); + ObjectClass *oc = object_get_class(machine); + MachineClass *mc = MACHINE_CLASS(oc); + + machine_class_allow_dynamic_sysbus_dev(mc, TYPE_XENSYSDEV); +} + +int xen_be_register(const char *type, struct XenDevOps *ops) +{ + char path[50]; + int rc; + + if (ops->backend_register) { + rc = ops->backend_register(); + if (rc) { + return rc; + } + } + + snprintf(path, sizeof(path), "device-model/%u/backends/%s", xen_domid, + type); + xenstore_mkdir(path, XS_PERM_NONE); + + return xenstore_scan(type, xen_domid, ops); +} + +void xen_be_register_common(void) +{ + xen_set_dynamic_sysbus(); + + xen_be_register("console", &xen_console_ops); + xen_be_register("vkbd", &xen_kbdmouse_ops); + xen_be_register("qdisk", &xen_blkdev_ops); +#ifdef CONFIG_VIRTFS + xen_be_register("9pfs", &xen_9pfs_ops); +#endif +#ifdef CONFIG_USB_LIBUSB + xen_be_register("qusb", &xen_usb_ops); +#endif +} + +int xen_be_bind_evtchn(struct XenLegacyDevice *xendev) +{ + if (xendev->local_port != -1) { + return 0; + } + xendev->local_port = xenevtchn_bind_interdomain + (xendev->evtchndev, xendev->dom, xendev->remote_port); + if (xendev->local_port == -1) { + xen_pv_printf(xendev, 0, "xenevtchn_bind_interdomain failed\n"); + return -1; + } + xen_pv_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port); + qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev), + xen_pv_evtchn_event, NULL, xendev); + return 0; +} + + +static Property xendev_properties[] = { + DEFINE_PROP_END_OF_LIST(), +}; + +static void xendev_class_init(ObjectClass *klass, void *data) +{ + DeviceClass *dc = DEVICE_CLASS(klass); + + dc->props = xendev_properties; + set_bit(DEVICE_CATEGORY_MISC, dc->categories); + /* xen-backend devices can be plugged/unplugged dynamically */ + dc->user_creatable = true; +} + +static const TypeInfo xendev_type_info = { + .name = TYPE_XENBACKEND, + .parent = TYPE_XENSYSDEV, + .class_init = xendev_class_init, + .instance_size = sizeof(struct XenLegacyDevice), +}; + +static void xen_sysbus_class_init(ObjectClass *klass, void *data) +{ + HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass); + + hc->unplug = qdev_simple_device_unplug_cb; +} + +static const TypeInfo xensysbus_info = { + .name = TYPE_XENSYSBUS, + .parent = TYPE_BUS, + .class_init = xen_sysbus_class_init, + .interfaces = (InterfaceInfo[]) { + { TYPE_HOTPLUG_HANDLER }, + { } + } +}; + +static int xen_sysdev_init(SysBusDevice *dev) +{ + return 0; +} + +static Property xen_sysdev_properties[] = { + {/* end of property list */}, +}; + +static void xen_sysdev_class_init(ObjectClass *klass, void *data) +{ + DeviceClass *dc = DEVICE_CLASS(klass); + SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); + + k->init = xen_sysdev_init; + dc->props = xen_sysdev_properties; + dc->bus_type = TYPE_XENSYSBUS; +} + +static const TypeInfo xensysdev_info = { + .name = TYPE_XENSYSDEV, + .parent = TYPE_SYS_BUS_DEVICE, + .instance_size = sizeof(SysBusDevice), + .class_init = xen_sysdev_class_init, +}; + +static void xenbe_register_types(void) +{ + type_register_static(&xensysbus_info); + type_register_static(&xensysdev_info); + type_register_static(&xendev_type_info); +} + +type_init(xenbe_register_types) diff --git a/hw/xen/xen_backend.c b/hw/xen/xen_backend.c deleted file mode 100644 index 9a8e877..0000000 --- a/hw/xen/xen_backend.c +++ /dev/null @@ -1,845 +0,0 @@ -/* - * xen backend driver infrastructure - * (c) 2008 Gerd Hoffmann - * - * This program is free software; you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation; under version 2 of the License. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License along - * with this program; if not, see . - * - * Contributions after 2012-01-13 are licensed under the terms of the - * GNU GPL, version 2 or (at your option) any later version. - */ - -/* - * TODO: add some xenbus / xenstore concepts overview here. - */ - -#include "qemu/osdep.h" -#include - -#include "hw/hw.h" -#include "hw/sysbus.h" -#include "hw/boards.h" -#include "qemu/log.h" -#include "qapi/error.h" -#include "hw/xen/xen_backend.h" -#include "hw/xen/xen_pvdev.h" -#include "monitor/qdev.h" - -#include - -DeviceState *xen_sysdev; -BusState *xen_sysbus; - -/* ------------------------------------------------------------- */ - -/* public */ -struct xs_handle *xenstore = NULL; -const char *xen_protocol; - -/* private */ -static bool xen_feature_grant_copy; -static int debug; - -int xenstore_write_be_str(struct XenDevice *xendev, const char *node, const char *val) -{ - return xenstore_write_str(xendev->be, node, val); -} - -int xenstore_write_be_int(struct XenDevice *xendev, const char *node, int ival) -{ - return xenstore_write_int(xendev->be, node, ival); -} - -int xenstore_write_be_int64(struct XenDevice *xendev, const char *node, int64_t ival) -{ - return xenstore_write_int64(xendev->be, node, ival); -} - -char *xenstore_read_be_str(struct XenDevice *xendev, const char *node) -{ - return xenstore_read_str(xendev->be, node); -} - -int xenstore_read_be_int(struct XenDevice *xendev, const char *node, int *ival) -{ - return xenstore_read_int(xendev->be, node, ival); -} - -char *xenstore_read_fe_str(struct XenDevice *xendev, const char *node) -{ - return xenstore_read_str(xendev->fe, node); -} - -int xenstore_read_fe_int(struct XenDevice *xendev, const char *node, int *ival) -{ - return xenstore_read_int(xendev->fe, node, ival); -} - -int xenstore_read_fe_uint64(struct XenDevice *xendev, const char *node, - uint64_t *uval) -{ - return xenstore_read_uint64(xendev->fe, node, uval); -} - -/* ------------------------------------------------------------- */ - -int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state) -{ - int rc; - - rc = xenstore_write_be_int(xendev, "state", state); - if (rc < 0) { - return rc; - } - xen_pv_printf(xendev, 1, "backend state: %s -> %s\n", - xenbus_strstate(xendev->be_state), xenbus_strstate(state)); - xendev->be_state = state; - return 0; -} - -void xen_be_set_max_grant_refs(struct XenDevice *xendev, - unsigned int nr_refs) -{ - assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV); - - if (xengnttab_set_max_grants(xendev->gnttabdev, nr_refs)) { - xen_pv_printf(xendev, 0, "xengnttab_set_max_grants failed: %s\n", - strerror(errno)); - } -} - -void *xen_be_map_grant_refs(struct XenDevice *xendev, uint32_t *refs, - unsigned int nr_refs, int prot) -{ - void *ptr; - - assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV); - - ptr = xengnttab_map_domain_grant_refs(xendev->gnttabdev, nr_refs, - xen_domid, refs, prot); - if (!ptr) { - xen_pv_printf(xendev, 0, - "xengnttab_map_domain_grant_refs failed: %s\n", - strerror(errno)); - } - - return ptr; -} - -void xen_be_unmap_grant_refs(struct XenDevice *xendev, void *ptr, - unsigned int nr_refs) -{ - assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV); - - if (xengnttab_unmap(xendev->gnttabdev, ptr, nr_refs)) { - xen_pv_printf(xendev, 0, "xengnttab_unmap failed: %s\n", - strerror(errno)); - } -} - -static int compat_copy_grant_refs(struct XenDevice *xendev, - bool to_domain, - XenGrantCopySegment segs[], - unsigned int nr_segs) -{ - uint32_t *refs = g_new(uint32_t, nr_segs); - int prot = to_domain ? PROT_WRITE : PROT_READ; - void *pages; - unsigned int i; - - for (i = 0; i < nr_segs; i++) { - XenGrantCopySegment *seg = &segs[i]; - - refs[i] = to_domain ? - seg->dest.foreign.ref : seg->source.foreign.ref; - } - - pages = xengnttab_map_domain_grant_refs(xendev->gnttabdev, nr_segs, - xen_domid, refs, prot); - if (!pages) { - xen_pv_printf(xendev, 0, - "xengnttab_map_domain_grant_refs failed: %s\n", - strerror(errno)); - g_free(refs); - return -1; - } - - for (i = 0; i < nr_segs; i++) { - XenGrantCopySegment *seg = &segs[i]; - void *page = pages + (i * XC_PAGE_SIZE); - - if (to_domain) { - memcpy(page + seg->dest.foreign.offset, seg->source.virt, - seg->len); - } else { - memcpy(seg->dest.virt, page + seg->source.foreign.offset, - seg->len); - } - } - - if (xengnttab_unmap(xendev->gnttabdev, pages, nr_segs)) { - xen_pv_printf(xendev, 0, "xengnttab_unmap failed: %s\n", - strerror(errno)); - } - - g_free(refs); - return 0; -} - -int xen_be_copy_grant_refs(struct XenDevice *xendev, - bool to_domain, - XenGrantCopySegment segs[], - unsigned int nr_segs) -{ - xengnttab_grant_copy_segment_t *xengnttab_segs; - unsigned int i; - int rc; - - assert(xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV); - - if (!xen_feature_grant_copy) { - return compat_copy_grant_refs(xendev, to_domain, segs, nr_segs); - } - - xengnttab_segs = g_new0(xengnttab_grant_copy_segment_t, nr_segs); - - for (i = 0; i < nr_segs; i++) { - XenGrantCopySegment *seg = &segs[i]; - xengnttab_grant_copy_segment_t *xengnttab_seg = &xengnttab_segs[i]; - - if (to_domain) { - xengnttab_seg->flags = GNTCOPY_dest_gref; - xengnttab_seg->dest.foreign.domid = xen_domid; - xengnttab_seg->dest.foreign.ref = seg->dest.foreign.ref; - xengnttab_seg->dest.foreign.offset = seg->dest.foreign.offset; - xengnttab_seg->source.virt = seg->source.virt; - } else { - xengnttab_seg->flags = GNTCOPY_source_gref; - xengnttab_seg->source.foreign.domid = xen_domid; - xengnttab_seg->source.foreign.ref = seg->source.foreign.ref; - xengnttab_seg->source.foreign.offset = - seg->source.foreign.offset; - xengnttab_seg->dest.virt = seg->dest.virt; - } - - xengnttab_seg->len = seg->len; - } - - rc = xengnttab_grant_copy(xendev->gnttabdev, nr_segs, xengnttab_segs); - - if (rc) { - xen_pv_printf(xendev, 0, "xengnttab_copy failed: %s\n", - strerror(errno)); - } - - for (i = 0; i < nr_segs; i++) { - xengnttab_grant_copy_segment_t *xengnttab_seg = - &xengnttab_segs[i]; - - if (xengnttab_seg->status != GNTST_okay) { - xen_pv_printf(xendev, 0, "segment[%u] status: %d\n", i, - xengnttab_seg->status); - rc = -1; - } - } - - g_free(xengnttab_segs); - return rc; -} - -/* - * get xen backend device, allocate a new one if it doesn't exist. - */ -static struct XenDevice *xen_be_get_xendev(const char *type, int dom, int dev, - struct XenDevOps *ops) -{ - struct XenDevice *xendev; - - xendev = xen_pv_find_xendev(type, dom, dev); - if (xendev) { - return xendev; - } - - /* init new xendev */ - xendev = g_malloc0(ops->size); - object_initialize(&xendev->qdev, ops->size, TYPE_XENBACKEND); - OBJECT(xendev)->free = g_free; - qdev_set_parent_bus(DEVICE(xendev), xen_sysbus); - qdev_set_id(DEVICE(xendev), g_strdup_printf("xen-%s-%d", type, dev)); - qdev_init_nofail(DEVICE(xendev)); - object_unref(OBJECT(xendev)); - - xendev->type = type; - xendev->dom = dom; - xendev->dev = dev; - xendev->ops = ops; - - snprintf(xendev->be, sizeof(xendev->be), "backend/%s/%d/%d", - xendev->type, xendev->dom, xendev->dev); - snprintf(xendev->name, sizeof(xendev->name), "%s-%d", - xendev->type, xendev->dev); - - xendev->debug = debug; - xendev->local_port = -1; - - xendev->evtchndev = xenevtchn_open(NULL, 0); - if (xendev->evtchndev == NULL) { - xen_pv_printf(NULL, 0, "can't open evtchn device\n"); - qdev_unplug(DEVICE(xendev), NULL); - return NULL; - } - qemu_set_cloexec(xenevtchn_fd(xendev->evtchndev)); - - xen_pv_insert_xendev(xendev); - - if (xendev->ops->alloc) { - xendev->ops->alloc(xendev); - } - - return xendev; -} - - -/* - * Sync internal data structures on xenstore updates. - * Node specifies the changed field. node = NULL means - * update all fields (used for initialization). - */ -static void xen_be_backend_changed(struct XenDevice *xendev, const char *node) -{ - if (node == NULL || strcmp(node, "online") == 0) { - if (xenstore_read_be_int(xendev, "online", &xendev->online) == -1) { - xendev->online = 0; - } - } - - if (node) { - xen_pv_printf(xendev, 2, "backend update: %s\n", node); - if (xendev->ops->backend_changed) { - xendev->ops->backend_changed(xendev, node); - } - } -} - -static void xen_be_frontend_changed(struct XenDevice *xendev, const char *node) -{ - int fe_state; - - if (node == NULL || strcmp(node, "state") == 0) { - if (xenstore_read_fe_int(xendev, "state", &fe_state) == -1) { - fe_state = XenbusStateUnknown; - } - if (xendev->fe_state != fe_state) { - xen_pv_printf(xendev, 1, "frontend state: %s -> %s\n", - xenbus_strstate(xendev->fe_state), - xenbus_strstate(fe_state)); - } - xendev->fe_state = fe_state; - } - if (node == NULL || strcmp(node, "protocol") == 0) { - g_free(xendev->protocol); - xendev->protocol = xenstore_read_fe_str(xendev, "protocol"); - if (xendev->protocol) { - xen_pv_printf(xendev, 1, "frontend protocol: %s\n", - xendev->protocol); - } - } - - if (node) { - xen_pv_printf(xendev, 2, "frontend update: %s\n", node); - if (xendev->ops->frontend_changed) { - xendev->ops->frontend_changed(xendev, node); - } - } -} - -/* ------------------------------------------------------------- */ -/* Check for possible state transitions and perform them. */ - -/* - * Initial xendev setup. Read frontend path, register watch for it. - * Should succeed once xend finished setting up the backend device. - * - * Also sets initial state (-> Initializing) when done. Which - * only affects the xendev->be_state variable as xenbus should - * already be put into that state by xend. - */ -static int xen_be_try_setup(struct XenDevice *xendev) -{ - char token[XEN_BUFSIZE]; - int be_state; - - if (xenstore_read_be_int(xendev, "state", &be_state) == -1) { - xen_pv_printf(xendev, 0, "reading backend state failed\n"); - return -1; - } - - if (be_state != XenbusStateInitialising) { - xen_pv_printf(xendev, 0, "initial backend state is wrong (%s)\n", - xenbus_strstate(be_state)); - return -1; - } - - xendev->fe = xenstore_read_be_str(xendev, "frontend"); - if (xendev->fe == NULL) { - xen_pv_printf(xendev, 0, "reading frontend path failed\n"); - return -1; - } - - /* setup frontend watch */ - snprintf(token, sizeof(token), "fe:%p", xendev); - if (!xs_watch(xenstore, xendev->fe, token)) { - xen_pv_printf(xendev, 0, "watching frontend path (%s) failed\n", - xendev->fe); - return -1; - } - xen_be_set_state(xendev, XenbusStateInitialising); - - xen_be_backend_changed(xendev, NULL); - xen_be_frontend_changed(xendev, NULL); - return 0; -} - -/* - * Try initialize xendev. Prepare everything the backend can do - * without synchronizing with the frontend. Fakes hotplug-status. No - * hotplug involved here because this is about userspace drivers, thus - * there are kernel backend devices which could invoke hotplug. - * - * Goes to InitWait on success. - */ -static int xen_be_try_init(struct XenDevice *xendev) -{ - int rc = 0; - - if (!xendev->online) { - xen_pv_printf(xendev, 1, "not online\n"); - return -1; - } - - if (xendev->ops->init) { - rc = xendev->ops->init(xendev); - } - if (rc != 0) { - xen_pv_printf(xendev, 1, "init() failed\n"); - return rc; - } - - xenstore_write_be_str(xendev, "hotplug-status", "connected"); - xen_be_set_state(xendev, XenbusStateInitWait); - return 0; -} - -/* - * Try to initialise xendev. Depends on the frontend being ready - * for it (shared ring and evtchn info in xenstore, state being - * Initialised or Connected). - * - * Goes to Connected on success. - */ -static int xen_be_try_initialise(struct XenDevice *xendev) -{ - int rc = 0; - - if (xendev->fe_state != XenbusStateInitialised && - xendev->fe_state != XenbusStateConnected) { - if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) { - xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n"); - } else { - xen_pv_printf(xendev, 2, "frontend not ready (yet)\n"); - return -1; - } - } - - if (xendev->ops->flags & DEVOPS_FLAG_NEED_GNTDEV) { - xendev->gnttabdev = xengnttab_open(NULL, 0); - if (xendev->gnttabdev == NULL) { - xen_pv_printf(NULL, 0, "can't open gnttab device\n"); - return -1; - } - } else { - xendev->gnttabdev = NULL; - } - - if (xendev->ops->initialise) { - rc = xendev->ops->initialise(xendev); - } - if (rc != 0) { - xen_pv_printf(xendev, 0, "initialise() failed\n"); - return rc; - } - - xen_be_set_state(xendev, XenbusStateConnected); - return 0; -} - -/* - * Try to let xendev know that it is connected. Depends on the - * frontend being Connected. Note that this may be called more - * than once since the backend state is not modified. - */ -static void xen_be_try_connected(struct XenDevice *xendev) -{ - if (!xendev->ops->connected) { - return; - } - - if (xendev->fe_state != XenbusStateConnected) { - if (xendev->ops->flags & DEVOPS_FLAG_IGNORE_STATE) { - xen_pv_printf(xendev, 2, "frontend not ready, ignoring\n"); - } else { - xen_pv_printf(xendev, 2, "frontend not ready (yet)\n"); - return; - } - } - - xendev->ops->connected(xendev); -} - -/* - * Teardown connection. - * - * Goes to Closed when done. - */ -static void xen_be_disconnect(struct XenDevice *xendev, enum xenbus_state state) -{ - if (xendev->be_state != XenbusStateClosing && - xendev->be_state != XenbusStateClosed && - xendev->ops->disconnect) { - xendev->ops->disconnect(xendev); - } - if (xendev->gnttabdev) { - xengnttab_close(xendev->gnttabdev); - xendev->gnttabdev = NULL; - } - if (xendev->be_state != state) { - xen_be_set_state(xendev, state); - } -} - -/* - * Try to reset xendev, for reconnection by another frontend instance. - */ -static int xen_be_try_reset(struct XenDevice *xendev) -{ - if (xendev->fe_state != XenbusStateInitialising) { - return -1; - } - - xen_pv_printf(xendev, 1, "device reset (for re-connect)\n"); - xen_be_set_state(xendev, XenbusStateInitialising); - return 0; -} - -/* - * state change dispatcher function - */ -void xen_be_check_state(struct XenDevice *xendev) -{ - int rc = 0; - - /* frontend may request shutdown from almost anywhere */ - if (xendev->fe_state == XenbusStateClosing || - xendev->fe_state == XenbusStateClosed) { - xen_be_disconnect(xendev, xendev->fe_state); - return; - } - - /* check for possible backend state transitions */ - for (;;) { - switch (xendev->be_state) { - case XenbusStateUnknown: - rc = xen_be_try_setup(xendev); - break; - case XenbusStateInitialising: - rc = xen_be_try_init(xendev); - break; - case XenbusStateInitWait: - rc = xen_be_try_initialise(xendev); - break; - case XenbusStateConnected: - /* xendev->be_state doesn't change */ - xen_be_try_connected(xendev); - rc = -1; - break; - case XenbusStateClosed: - rc = xen_be_try_reset(xendev); - break; - default: - rc = -1; - } - if (rc != 0) { - break; - } - } -} - -/* ------------------------------------------------------------- */ - -static int xenstore_scan(const char *type, int dom, struct XenDevOps *ops) -{ - struct XenDevice *xendev; - char path[XEN_BUFSIZE], token[XEN_BUFSIZE]; - char **dev = NULL; - unsigned int cdev, j; - - /* setup watch */ - snprintf(token, sizeof(token), "be:%p:%d:%p", type, dom, ops); - snprintf(path, sizeof(path), "backend/%s/%d", type, dom); - if (!xs_watch(xenstore, path, token)) { - xen_pv_printf(NULL, 0, "xen be: watching backend path (%s) failed\n", - path); - return -1; - } - - /* look for backends */ - dev = xs_directory(xenstore, 0, path, &cdev); - if (!dev) { - return 0; - } - for (j = 0; j < cdev; j++) { - xendev = xen_be_get_xendev(type, dom, atoi(dev[j]), ops); - if (xendev == NULL) { - continue; - } - xen_be_check_state(xendev); - } - free(dev); - return 0; -} - -void xenstore_update_be(char *watch, char *type, int dom, - struct XenDevOps *ops) -{ - struct XenDevice *xendev; - char path[XEN_BUFSIZE], *bepath; - unsigned int len, dev; - - len = snprintf(path, sizeof(path), "backend/%s/%d", type, dom); - if (strncmp(path, watch, len) != 0) { - return; - } - if (sscanf(watch+len, "/%u/%255s", &dev, path) != 2) { - strcpy(path, ""); - if (sscanf(watch+len, "/%u", &dev) != 1) { - dev = -1; - } - } - if (dev == -1) { - return; - } - - xendev = xen_be_get_xendev(type, dom, dev, ops); - if (xendev != NULL) { - bepath = xs_read(xenstore, 0, xendev->be, &len); - if (bepath == NULL) { - xen_pv_del_xendev(xendev); - } else { - free(bepath); - xen_be_backend_changed(xendev, path); - xen_be_check_state(xendev); - } - } -} - -void xenstore_update_fe(char *watch, struct XenDevice *xendev) -{ - char *node; - unsigned int len; - - len = strlen(xendev->fe); - if (strncmp(xendev->fe, watch, len) != 0) { - return; - } - if (watch[len] != '/') { - return; - } - node = watch + len + 1; - - xen_be_frontend_changed(xendev, node); - xen_be_check_state(xendev); -} -/* -------------------------------------------------------------------- */ - -int xen_be_init(void) -{ - xengnttab_handle *gnttabdev; - - xenstore = xs_daemon_open(); - if (!xenstore) { - xen_pv_printf(NULL, 0, "can't connect to xenstored\n"); - return -1; - } - - qemu_set_fd_handler(xs_fileno(xenstore), xenstore_update, NULL, NULL); - - if (xen_xc == NULL || xen_fmem == NULL) { - /* Check if xen_init() have been called */ - goto err; - } - - gnttabdev = xengnttab_open(NULL, 0); - if (gnttabdev != NULL) { - if (xengnttab_grant_copy(gnttabdev, 0, NULL) == 0) { - xen_feature_grant_copy = true; - } - xengnttab_close(gnttabdev); - } - - xen_sysdev = qdev_create(NULL, TYPE_XENSYSDEV); - qdev_init_nofail(xen_sysdev); - xen_sysbus = qbus_create(TYPE_XENSYSBUS, DEVICE(xen_sysdev), "xen-sysbus"); - qbus_set_bus_hotplug_handler(xen_sysbus, &error_abort); - - return 0; - -err: - qemu_set_fd_handler(xs_fileno(xenstore), NULL, NULL, NULL); - xs_daemon_close(xenstore); - xenstore = NULL; - - return -1; -} - -static void xen_set_dynamic_sysbus(void) -{ - Object *machine = qdev_get_machine(); - ObjectClass *oc = object_get_class(machine); - MachineClass *mc = MACHINE_CLASS(oc); - - machine_class_allow_dynamic_sysbus_dev(mc, TYPE_XENSYSDEV); -} - -int xen_be_register(const char *type, struct XenDevOps *ops) -{ - char path[50]; - int rc; - - if (ops->backend_register) { - rc = ops->backend_register(); - if (rc) { - return rc; - } - } - - snprintf(path, sizeof(path), "device-model/%u/backends/%s", xen_domid, - type); - xenstore_mkdir(path, XS_PERM_NONE); - - return xenstore_scan(type, xen_domid, ops); -} - -void xen_be_register_common(void) -{ - xen_set_dynamic_sysbus(); - - xen_be_register("console", &xen_console_ops); - xen_be_register("vkbd", &xen_kbdmouse_ops); - xen_be_register("qdisk", &xen_blkdev_ops); -#ifdef CONFIG_VIRTFS - xen_be_register("9pfs", &xen_9pfs_ops); -#endif -#ifdef CONFIG_USB_LIBUSB - xen_be_register("qusb", &xen_usb_ops); -#endif -} - -int xen_be_bind_evtchn(struct XenDevice *xendev) -{ - if (xendev->local_port != -1) { - return 0; - } - xendev->local_port = xenevtchn_bind_interdomain - (xendev->evtchndev, xendev->dom, xendev->remote_port); - if (xendev->local_port == -1) { - xen_pv_printf(xendev, 0, "xenevtchn_bind_interdomain failed\n"); - return -1; - } - xen_pv_printf(xendev, 2, "bind evtchn port %d\n", xendev->local_port); - qemu_set_fd_handler(xenevtchn_fd(xendev->evtchndev), - xen_pv_evtchn_event, NULL, xendev); - return 0; -} - - -static Property xendev_properties[] = { - DEFINE_PROP_END_OF_LIST(), -}; - -static void xendev_class_init(ObjectClass *klass, void *data) -{ - DeviceClass *dc = DEVICE_CLASS(klass); - - dc->props = xendev_properties; - set_bit(DEVICE_CATEGORY_MISC, dc->categories); - /* xen-backend devices can be plugged/unplugged dynamically */ - dc->user_creatable = true; -} - -static const TypeInfo xendev_type_info = { - .name = TYPE_XENBACKEND, - .parent = TYPE_XENSYSDEV, - .class_init = xendev_class_init, - .instance_size = sizeof(struct XenDevice), -}; - -static void xen_sysbus_class_init(ObjectClass *klass, void *data) -{ - HotplugHandlerClass *hc = HOTPLUG_HANDLER_CLASS(klass); - - hc->unplug = qdev_simple_device_unplug_cb; -} - -static const TypeInfo xensysbus_info = { - .name = TYPE_XENSYSBUS, - .parent = TYPE_BUS, - .class_init = xen_sysbus_class_init, - .interfaces = (InterfaceInfo[]) { - { TYPE_HOTPLUG_HANDLER }, - { } - } -}; - -static int xen_sysdev_init(SysBusDevice *dev) -{ - return 0; -} - -static Property xen_sysdev_properties[] = { - {/* end of property list */}, -}; - -static void xen_sysdev_class_init(ObjectClass *klass, void *data) -{ - DeviceClass *dc = DEVICE_CLASS(klass); - SysBusDeviceClass *k = SYS_BUS_DEVICE_CLASS(klass); - - k->init = xen_sysdev_init; - dc->props = xen_sysdev_properties; - dc->bus_type = TYPE_XENSYSBUS; -} - -static const TypeInfo xensysdev_info = { - .name = TYPE_XENSYSDEV, - .parent = TYPE_SYS_BUS_DEVICE, - .instance_size = sizeof(SysBusDevice), - .class_init = xen_sysdev_class_init, -}; - -static void xenbe_register_types(void) -{ - type_register_static(&xensysbus_info); - type_register_static(&xensysdev_info); - type_register_static(&xendev_type_info); -} - -type_init(xenbe_register_types) diff --git a/hw/xen/xen_devconfig.c b/hw/xen/xen_devconfig.c index aebc19b..1b30bd7 100644 --- a/hw/xen/xen_devconfig.c +++ b/hw/xen/xen_devconfig.c @@ -1,5 +1,5 @@ #include "qemu/osdep.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include "qemu/option.h" #include "sysemu/blockdev.h" diff --git a/hw/xen/xen_pt.c b/hw/xen/xen_pt.c index f1f3a37..b20bf3a 100644 --- a/hw/xen/xen_pt.c +++ b/hw/xen/xen_pt.c @@ -59,7 +59,7 @@ #include "hw/pci/pci.h" #include "hw/xen/xen.h" #include "hw/i386/pc.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include "xen_pt.h" #include "qemu/range.h" #include "exec/address-spaces.h" diff --git a/hw/xen/xen_pt_config_init.c b/hw/xen/xen_pt_config_init.c index 47f9010..8111204 100644 --- a/hw/xen/xen_pt_config_init.c +++ b/hw/xen/xen_pt_config_init.c @@ -15,7 +15,7 @@ #include "qemu/osdep.h" #include "qapi/error.h" #include "qemu/timer.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include "xen_pt.h" #define XEN_PT_MERGE_VALUE(value, data, val_mask) \ diff --git a/hw/xen/xen_pt_graphics.c b/hw/xen/xen_pt_graphics.c index 135c8df..130cc6c 100644 --- a/hw/xen/xen_pt_graphics.c +++ b/hw/xen/xen_pt_graphics.c @@ -5,7 +5,7 @@ #include "qapi/error.h" #include "xen_pt.h" #include "xen-host-pci-device.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" static unsigned long igd_guest_opregion; static unsigned long igd_host_opregion; diff --git a/hw/xen/xen_pt_msi.c b/hw/xen/xen_pt_msi.c index cc514f9..fb4b887 100644 --- a/hw/xen/xen_pt_msi.c +++ b/hw/xen/xen_pt_msi.c @@ -11,7 +11,7 @@ #include "qemu/osdep.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include "xen_pt.h" #include "hw/i386/apic-msidef.h" diff --git a/hw/xen/xen_pvdev.c b/hw/xen/xen_pvdev.c index aed783e..61de091 100644 --- a/hw/xen/xen_pvdev.c +++ b/hw/xen/xen_pvdev.c @@ -20,7 +20,7 @@ #include "qemu/osdep.h" #include "qemu/log.h" #include "hw/qdev-core.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include "hw/xen/xen_pvdev.h" /* private */ @@ -34,7 +34,7 @@ struct xs_dirs { static QTAILQ_HEAD(xs_dirs_head, xs_dirs) xs_cleanup = QTAILQ_HEAD_INITIALIZER(xs_cleanup); -static QTAILQ_HEAD(XenDeviceHead, XenDevice) xendevs = +static QTAILQ_HEAD(XenLegacyDeviceHead, XenLegacyDevice) xendevs = QTAILQ_HEAD_INITIALIZER(xendevs); /* ------------------------------------------------------------- */ @@ -195,7 +195,7 @@ const char *xenbus_strstate(enum xenbus_state state) * 2 == noisy debug messages (logfile only). * 3 == will flood your log (logfile only). */ -void xen_pv_printf(struct XenDevice *xendev, int msg_level, +void xen_pv_printf(struct XenLegacyDevice *xendev, int msg_level, const char *fmt, ...) { va_list args; @@ -230,7 +230,7 @@ void xen_pv_printf(struct XenDevice *xendev, int msg_level, void xen_pv_evtchn_event(void *opaque) { - struct XenDevice *xendev = opaque; + struct XenLegacyDevice *xendev = opaque; evtchn_port_t port; port = xenevtchn_pending(xendev->evtchndev); @@ -247,7 +247,7 @@ void xen_pv_evtchn_event(void *opaque) } } -void xen_pv_unbind_evtchn(struct XenDevice *xendev) +void xen_pv_unbind_evtchn(struct XenLegacyDevice *xendev) { if (xendev->local_port == -1) { return; @@ -258,16 +258,16 @@ void xen_pv_unbind_evtchn(struct XenDevice *xendev) xendev->local_port = -1; } -int xen_pv_send_notify(struct XenDevice *xendev) +int xen_pv_send_notify(struct XenLegacyDevice *xendev) { return xenevtchn_notify(xendev->evtchndev, xendev->local_port); } /* ------------------------------------------------------------- */ -struct XenDevice *xen_pv_find_xendev(const char *type, int dom, int dev) +struct XenLegacyDevice *xen_pv_find_xendev(const char *type, int dom, int dev) { - struct XenDevice *xendev; + struct XenLegacyDevice *xendev; QTAILQ_FOREACH(xendev, &xendevs, next) { if (xendev->dom != dom) { @@ -287,7 +287,7 @@ struct XenDevice *xen_pv_find_xendev(const char *type, int dom, int dev) /* * release xen backend device. */ -void xen_pv_del_xendev(struct XenDevice *xendev) +void xen_pv_del_xendev(struct XenLegacyDevice *xendev) { if (xendev->ops->free) { xendev->ops->free(xendev); @@ -312,7 +312,7 @@ void xen_pv_del_xendev(struct XenDevice *xendev) qdev_unplug(&xendev->qdev, NULL); } -void xen_pv_insert_xendev(struct XenDevice *xendev) +void xen_pv_insert_xendev(struct XenLegacyDevice *xendev) { QTAILQ_INSERT_TAIL(&xendevs, xendev, next); } diff --git a/hw/xenpv/xen_domainbuild.c b/hw/xenpv/xen_domainbuild.c index 188acac..deb28cf 100644 --- a/hw/xenpv/xen_domainbuild.c +++ b/hw/xenpv/xen_domainbuild.c @@ -1,6 +1,6 @@ #include "qemu/osdep.h" #include "qemu/units.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include "xen_domainbuild.h" #include "qemu/timer.h" #include "qemu/log.h" diff --git a/hw/xenpv/xen_machine_pv.c b/hw/xenpv/xen_machine_pv.c index 44d67b8..8c86fb7 100644 --- a/hw/xenpv/xen_machine_pv.c +++ b/hw/xenpv/xen_machine_pv.c @@ -26,7 +26,7 @@ #include "qemu/error-report.h" #include "hw/hw.h" #include "hw/boards.h" -#include "hw/xen/xen_backend.h" +#include "hw/xen/xen-legacy-backend.h" #include "xen_domainbuild.h" #include "sysemu/block-backend.h" diff --git a/include/hw/xen/xen-legacy-backend.h b/include/hw/xen/xen-legacy-backend.h new file mode 100644 index 0000000..20cb47b --- /dev/null +++ b/include/hw/xen/xen-legacy-backend.h @@ -0,0 +1,104 @@ +#ifndef QEMU_HW_XEN_BACKEND_H +#define QEMU_HW_XEN_BACKEND_H + +#include "hw/xen/xen_common.h" +#include "hw/xen/xen_pvdev.h" +#include "sysemu/sysemu.h" +#include "net/net.h" + +#define TYPE_XENSYSDEV "xen-sysdev" +#define TYPE_XENSYSBUS "xen-sysbus" +#define TYPE_XENBACKEND "xen-backend" + +#define XENBACKEND_DEVICE(obj) \ + OBJECT_CHECK(XenLegacyDevice, (obj), TYPE_XENBACKEND) + +/* variables */ +extern struct xs_handle *xenstore; +extern const char *xen_protocol; +extern DeviceState *xen_sysdev; +extern BusState *xen_sysbus; + +int xenstore_mkdir(char *path, int p); +int xenstore_write_be_str(struct XenLegacyDevice *xendev, const char *node, + const char *val); +int xenstore_write_be_int(struct XenLegacyDevice *xendev, const char *node, + int ival); +int xenstore_write_be_int64(struct XenLegacyDevice *xendev, const char *node, + int64_t ival); +char *xenstore_read_be_str(struct XenLegacyDevice *xendev, const char *node); +int xenstore_read_be_int(struct XenLegacyDevice *xendev, const char *node, + int *ival); +void xenstore_update_fe(char *watch, struct XenLegacyDevice *xendev); +void xenstore_update_be(char *watch, char *type, int dom, + struct XenDevOps *ops); +char *xenstore_read_fe_str(struct XenLegacyDevice *xendev, const char *node); +int xenstore_read_fe_int(struct XenLegacyDevice *xendev, const char *node, + int *ival); +int xenstore_read_fe_uint64(struct XenLegacyDevice *xendev, const char *node, + uint64_t *uval); + +void xen_be_check_state(struct XenLegacyDevice *xendev); + +/* xen backend driver bits */ +int xen_be_init(void); +void xen_be_register_common(void); +int xen_be_register(const char *type, struct XenDevOps *ops); +int xen_be_set_state(struct XenLegacyDevice *xendev, enum xenbus_state state); +int xen_be_bind_evtchn(struct XenLegacyDevice *xendev); +void xen_be_set_max_grant_refs(struct XenLegacyDevice *xendev, + unsigned int nr_refs); +void *xen_be_map_grant_refs(struct XenLegacyDevice *xendev, uint32_t *refs, + unsigned int nr_refs, int prot); +void xen_be_unmap_grant_refs(struct XenLegacyDevice *xendev, void *ptr, + unsigned int nr_refs); + +typedef struct XenGrantCopySegment { + union { + void *virt; + struct { + uint32_t ref; + off_t offset; + } foreign; + } source, dest; + size_t len; +} XenGrantCopySegment; + +int xen_be_copy_grant_refs(struct XenLegacyDevice *xendev, + bool to_domain, XenGrantCopySegment segs[], + unsigned int nr_segs); + +static inline void *xen_be_map_grant_ref(struct XenLegacyDevice *xendev, + uint32_t ref, int prot) +{ + return xen_be_map_grant_refs(xendev, &ref, 1, prot); +} + +static inline void xen_be_unmap_grant_ref(struct XenLegacyDevice *xendev, + void *ptr) +{ + return xen_be_unmap_grant_refs(xendev, ptr, 1); +} + +/* actual backend drivers */ +extern struct XenDevOps xen_console_ops; /* xen_console.c */ +extern struct XenDevOps xen_kbdmouse_ops; /* xen_framebuffer.c */ +extern struct XenDevOps xen_framebuffer_ops; /* xen_framebuffer.c */ +extern struct XenDevOps xen_blkdev_ops; /* xen_disk.c */ +#ifdef CONFIG_VIRTFS +extern struct XenDevOps xen_9pfs_ops; /* xen-9p-backend.c */ +#endif +extern struct XenDevOps xen_netdev_ops; /* xen_nic.c */ +#ifdef CONFIG_USB_LIBUSB +extern struct XenDevOps xen_usb_ops; /* xen-usb.c */ +#endif + +/* configuration (aka xenbus setup) */ +void xen_config_cleanup(void); +int xen_config_dev_blk(DriveInfo *disk); +int xen_config_dev_nic(NICInfo *nic); +int xen_config_dev_vfb(int vdev, const char *type); +int xen_config_dev_vkbd(int vdev); +int xen_config_dev_console(int vdev); + +#endif /* QEMU_HW_XEN_BACKEND_H */ diff --git a/include/hw/xen/xen_backend.h b/include/hw/xen/xen_backend.h deleted file mode 100644 index 9c17fdd..0000000 --- a/include/hw/xen/xen_backend.h +++ /dev/null @@ -1,99 +0,0 @@ -#ifndef QEMU_HW_XEN_BACKEND_H -#define QEMU_HW_XEN_BACKEND_H - -#include "hw/xen/xen_common.h" -#include "hw/xen/xen_pvdev.h" -#include "sysemu/sysemu.h" -#include "net/net.h" - -#define TYPE_XENSYSDEV "xen-sysdev" -#define TYPE_XENSYSBUS "xen-sysbus" -#define TYPE_XENBACKEND "xen-backend" - -#define XENBACKEND_DEVICE(obj) \ - OBJECT_CHECK(XenDevice, (obj), TYPE_XENBACKEND) - -/* variables */ -extern struct xs_handle *xenstore; -extern const char *xen_protocol; -extern DeviceState *xen_sysdev; -extern BusState *xen_sysbus; - -int xenstore_mkdir(char *path, int p); -int xenstore_write_be_str(struct XenDevice *xendev, const char *node, const char *val); -int xenstore_write_be_int(struct XenDevice *xendev, const char *node, int ival); -int xenstore_write_be_int64(struct XenDevice *xendev, const char *node, int64_t ival); -char *xenstore_read_be_str(struct XenDevice *xendev, const char *node); -int xenstore_read_be_int(struct XenDevice *xendev, const char *node, int *ival); -void xenstore_update_fe(char *watch, struct XenDevice *xendev); -void xenstore_update_be(char *watch, char *type, int dom, - struct XenDevOps *ops); -char *xenstore_read_fe_str(struct XenDevice *xendev, const char *node); -int xenstore_read_fe_int(struct XenDevice *xendev, const char *node, int *ival); -int xenstore_read_fe_uint64(struct XenDevice *xendev, const char *node, - uint64_t *uval); - -void xen_be_check_state(struct XenDevice *xendev); - -/* xen backend driver bits */ -int xen_be_init(void); -void xen_be_register_common(void); -int xen_be_register(const char *type, struct XenDevOps *ops); -int xen_be_set_state(struct XenDevice *xendev, enum xenbus_state state); -int xen_be_bind_evtchn(struct XenDevice *xendev); -void xen_be_set_max_grant_refs(struct XenDevice *xendev, - unsigned int nr_refs); -void *xen_be_map_grant_refs(struct XenDevice *xendev, uint32_t *refs, - unsigned int nr_refs, int prot); -void xen_be_unmap_grant_refs(struct XenDevice *xendev, void *ptr, - unsigned int nr_refs); - -typedef struct XenGrantCopySegment { - union { - void *virt; - struct { - uint32_t ref; - off_t offset; - } foreign; - } source, dest; - size_t len; -} XenGrantCopySegment; - -int xen_be_copy_grant_refs(struct XenDevice *xendev, - bool to_domain, XenGrantCopySegment segs[], - unsigned int nr_segs); - -static inline void *xen_be_map_grant_ref(struct XenDevice *xendev, - uint32_t ref, int prot) -{ - return xen_be_map_grant_refs(xendev, &ref, 1, prot); -} - -static inline void xen_be_unmap_grant_ref(struct XenDevice *xendev, - void *ptr) -{ - return xen_be_unmap_grant_refs(xendev, ptr, 1); -} - -/* actual backend drivers */ -extern struct XenDevOps xen_console_ops; /* xen_console.c */ -extern struct XenDevOps xen_kbdmouse_ops; /* xen_framebuffer.c */ -extern struct XenDevOps xen_framebuffer_ops; /* xen_framebuffer.c */ -extern struct XenDevOps xen_blkdev_ops; /* xen_disk.c */ -#ifdef CONFIG_VIRTFS -extern struct XenDevOps xen_9pfs_ops; /* xen-9p-backend.c */ -#endif -extern struct XenDevOps xen_netdev_ops; /* xen_nic.c */ -#ifdef CONFIG_USB_LIBUSB -extern struct XenDevOps xen_usb_ops; /* xen-usb.c */ -#endif - -/* configuration (aka xenbus setup) */ -void xen_config_cleanup(void); -int xen_config_dev_blk(DriveInfo *disk); -int xen_config_dev_nic(NICInfo *nic); -int xen_config_dev_vfb(int vdev, const char *type); -int xen_config_dev_vkbd(int vdev); -int xen_config_dev_console(int vdev); - -#endif /* QEMU_HW_XEN_BACKEND_H */ diff --git a/include/hw/xen/xen_pvdev.h b/include/hw/xen/xen_pvdev.h index d473e9b..83e5174 100644 --- a/include/hw/xen/xen_pvdev.h +++ b/include/hw/xen/xen_pvdev.h @@ -6,7 +6,7 @@ #define XEN_BUFSIZE 1024 -struct XenDevice; +struct XenLegacyDevice; /* driver uses grant tables -> open gntdev device (xendev->gnttabdev) */ #define DEVOPS_FLAG_NEED_GNTDEV 1 @@ -16,19 +16,21 @@ struct XenDevice; struct XenDevOps { size_t size; uint32_t flags; - void (*alloc)(struct XenDevice *xendev); - int (*init)(struct XenDevice *xendev); - int (*initialise)(struct XenDevice *xendev); - void (*connected)(struct XenDevice *xendev); - void (*event)(struct XenDevice *xendev); - void (*disconnect)(struct XenDevice *xendev); - int (*free)(struct XenDevice *xendev); - void (*backend_changed)(struct XenDevice *xendev, const char *node); - void (*frontend_changed)(struct XenDevice *xendev, const char *node); + void (*alloc)(struct XenLegacyDevice *xendev); + int (*init)(struct XenLegacyDevice *xendev); + int (*initialise)(struct XenLegacyDevice *xendev); + void (*connected)(struct XenLegacyDevice *xendev); + void (*event)(struct XenLegacyDevice *xendev); + void (*disconnect)(struct XenLegacyDevice *xendev); + int (*free)(struct XenLegacyDevice *xendev); + void (*backend_changed)(struct XenLegacyDevice *xendev, + const char *node); + void (*frontend_changed)(struct XenLegacyDevice *xendev, + const char *node); int (*backend_register)(void); }; -struct XenDevice { +struct XenLegacyDevice { DeviceState qdev; const char *type; int dom; @@ -49,7 +51,7 @@ struct XenDevice { xengnttab_handle *gnttabdev; struct XenDevOps *ops; - QTAILQ_ENTRY(XenDevice) next; + QTAILQ_ENTRY(XenLegacyDevice) next; }; /* ------------------------------------------------------------- */ @@ -66,14 +68,14 @@ void xenstore_update(void *unused); const char *xenbus_strstate(enum xenbus_state state); void xen_pv_evtchn_event(void *opaque); -void xen_pv_insert_xendev(struct XenDevice *xendev); -void xen_pv_del_xendev(struct XenDevice *xendev); -struct XenDevice *xen_pv_find_xendev(const char *type, int dom, int dev); +void xen_pv_insert_xendev(struct XenLegacyDevice *xendev); +void xen_pv_del_xendev(struct XenLegacyDevice *xendev); +struct XenLegacyDevice *xen_pv_find_xendev(const char *type, int dom, int dev); -void xen_pv_unbind_evtchn(struct XenDevice *xendev); -int xen_pv_send_notify(struct XenDevice *xendev); +void xen_pv_unbind_evtchn(struct XenLegacyDevice *xendev); +int xen_pv_send_notify(struct XenLegacyDevice *xendev); -void xen_pv_printf(struct XenDevice *xendev, int msg_level, +void xen_pv_printf(struct XenLegacyDevice *xendev, int msg_level, const char *fmt, ...) GCC_FMT_ATTR(3, 4); #endif /* QEMU_HW_XEN_PVDEV_H */ -- 2.1.4