From mboxrd@z Thu Jan 1 00:00:00 1970 From: Paul Durrant Subject: [PATCH v3 04/18] xen: create xenstore areas for XenDevice-s Date: Tue, 11 Dec 2018 10:47:04 +0000 Message-ID: <1544525238-3527-5-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 1gWfZj-0004xj-NS for xen-devel@lists.xenproject.org; Tue, 11 Dec 2018 10:47:39 +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: Anthony Perard , Kevin Wolf , Paul Durrant , Stefano Stabellini , Max Reitz List-Id: xen-devel@lists.xenproject.org VGhpcyBwYXRjaCBhZGRzIGEgbmV3IHNvdXJjZSBtb2R1bGUsIHhlbi1idXMtaGVscGVyLmMsIHdo aWNoIGJ1aWxkcyBvbgpiYXNpYyBsaWJ4ZW5zdG9yZSBwcmltaXRpdmVzIHRvIHByb3ZpZGUgZnVu Y3Rpb25zIHRvIGNyZWF0ZSAoc2V0dGluZwpwZXJtaXNzaW9ucyBhcHByb3ByaWF0ZWx5KSBhbmQg ZGVzdHJveSB4ZW5zdG9yZSBhcmVhcywgYW5kIGZ1bmN0aW9ucyB0bwoncHJpbnRmJyBhbmQgJ3Nj YW5mJyBub2RlcyB0aGVyZWluLiBUaGUgbWFpbiB4ZW4tYnVzIGNvZGUgdGhlbiB1c2VzCnRoZXNl IHByaW1pdGl2ZXMgWzFdIHRvIGluaXRpYWxpemUgYW5kIGRlc3Ryb3kgdGhlIGZyb250ZW5kIGFu ZCBiYWNrZW5kCmFyZWFzIGZvciBhIFhlbkRldmljZSBkdXJpbmcgcmVhbGl6ZSBhbmQgdW5yZWFs aXplIHJlc3BlY3RpdmVseS4KClRoZSAneGVuLWJsb2NrJyBpbXBsZW1lbnRhdGlvbiBpcyBleHRl bmRlZCB3aXRoIGEgJ2dldF9uYW1lJyBtZXRob2QgdGhhdApyZXR1cm5zIHRoZSBWQkQgbnVtYmVy LiBUaGlzIG51bWJlciBpcyByZXF1aXJlZCB0byAnbmFtZScgdGhlIHhlbnN0b3JlCmFyZWFzLgoK Tk9URTogQW4gZXhpdCBoYW5kbGVyIGlzIGFsc28gYWRkZWQgdG8gbWFrZSBzdXJlIHRoZSB4ZW5z dG9yZSBhcmVhcyBhcmUKICAgICAgY2xlYW5lZCB1cCBpZiBRRU1VIHRlcm1pbmF0ZXMgd2l0aG91 dCBkZXZpY2VzIGJlaW5nIHVucmVhbGl6ZWQuCgpbMV0gVGhlICdzY2FuZicgZnVuY3Rpb25zIGFy ZSBhY3R1YWxseSBub3QgeWV0IG5lZWRlZCwgYnV0IHRoZXkgd2lsbCBiZQogICAgbmVlZGVkIGJ5 IGNvZGUgZGVsaXZlcmVkIGluIHN1YnNlcXVlbnQgcGF0Y2hlcy4KClNpZ25lZC1vZmYtYnk6IFBh dWwgRHVycmFudCA8cGF1bC5kdXJyYW50QGNpdHJpeC5jb20+Ci0tLQpDYzogQW50aG9ueSBQZXJh cmQgPGFudGhvbnkucGVyYXJkQGNpdHJpeC5jb20+CkNjOiBTdGVmYW5vIFN0YWJlbGxpbmkgPHNz dGFiZWxsaW5pQGtlcm5lbC5vcmc+CkNjOiBLZXZpbiBXb2xmIDxrd29sZkByZWRoYXQuY29tPgpD YzogTWF4IFJlaXR6IDxtcmVpdHpAcmVkaGF0LmNvbT4KCnYzOgogLSBBZGQgdHJhbnNhY3Rpb24g aWQgcGFyYW1ldGVycyB0byB4ZW4tYnVzLWhlbHBlciBmdW5jdGlvbnMKIC0gTm90IGFkZGVkIEFu dGhvbnkncyBSLWIgYmVjYXVzZSBvZiBjaGFuZ2UKCnYyOgogLSBGaXggYm9pbGVycGxhdGUKIC0g QWRkIGVycm9yIHBvaW50ZXJzIHRvIGFsbCB4c19ub2RlLi4uIGhlbHBlcnMKIC0gQWRkIEdDQ19G TVRfQVRUUiB0byBkZWNsYXJhdGlvbnMgb2YgcHJpbnRmLWxpa2UgaGVscGVycwotLS0KIGh3L2Js b2NrL3hlbi1ibG9jay5jICAgICAgICAgICAgfCAgIDkgKysKIGh3L3hlbi9NYWtlZmlsZS5vYmpz ICAgICAgICAgICAgfCAgIDIgKy0KIGh3L3hlbi90cmFjZS1ldmVudHMgICAgICAgICAgICAgfCAg MTIgKy0KIGh3L3hlbi94ZW4tYnVzLWhlbHBlci5jICAgICAgICAgfCAxNTAgKysrKysrKysrKysr KysrKysrKwogaHcveGVuL3hlbi1idXMuYyAgICAgICAgICAgICAgICB8IDMyMSArKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKystCiBpbmNsdWRlL2h3L3hlbi94ZW4tYnVzLWhl bHBlci5oIHwgIDM5ICsrKysrCiBpbmNsdWRlL2h3L3hlbi94ZW4tYnVzLmggICAgICAgIHwgIDEy ICsrCiA3IGZpbGVzIGNoYW5nZWQsIDU0MCBpbnNlcnRpb25zKCspLCA1IGRlbGV0aW9ucygtKQog Y3JlYXRlIG1vZGUgMTAwNjQ0IGh3L3hlbi94ZW4tYnVzLWhlbHBlci5jCiBjcmVhdGUgbW9kZSAx MDA2NDQgaW5jbHVkZS9ody94ZW4veGVuLWJ1cy1oZWxwZXIuaAoKZGlmZiAtLWdpdCBhL2h3L2Js b2NrL3hlbi1ibG9jay5jIGIvaHcvYmxvY2sveGVuLWJsb2NrLmMKaW5kZXggYzI5YWNiMC4uZmE1 N2JmMSAxMDA2NDQKLS0tIGEvaHcvYmxvY2sveGVuLWJsb2NrLmMKKysrIGIvaHcvYmxvY2sveGVu LWJsb2NrLmMKQEAgLTEzLDYgKzEzLDE0IEBACiAjaW5jbHVkZSAiaHcveGVuL3hlbi1ibG9jay5o IgogI2luY2x1ZGUgInRyYWNlLmgiCiAKK3N0YXRpYyBjaGFyICp4ZW5fYmxvY2tfZ2V0X25hbWUo WGVuRGV2aWNlICp4ZW5kZXYsIEVycm9yICoqZXJycCkKK3sKKyAgICBYZW5CbG9ja0RldmljZSAq YmxvY2tkZXYgPSBYRU5fQkxPQ0tfREVWSUNFKHhlbmRldik7CisgICAgWGVuQmxvY2tWZGV2ICp2 ZGV2ID0gJmJsb2NrZGV2LT52ZGV2OworCisgICAgcmV0dXJuIGdfc3RyZHVwX3ByaW50ZigiJWx1 IiwgdmRldi0+bnVtYmVyKTsKK30KKwogc3RhdGljIHZvaWQgeGVuX2Jsb2NrX3VucmVhbGl6ZShY ZW5EZXZpY2UgKnhlbmRldiwgRXJyb3IgKiplcnJwKQogewogICAgIFhlbkJsb2NrRGV2aWNlICpi bG9ja2RldiA9IFhFTl9CTE9DS19ERVZJQ0UoeGVuZGV2KTsKQEAgLTI2Miw2ICsyNzAsNyBAQCBz dGF0aWMgdm9pZCB4ZW5fYmxvY2tfY2xhc3NfaW5pdChPYmplY3RDbGFzcyAqY2xhc3MsIHZvaWQg KmRhdGEpCiAgICAgRGV2aWNlQ2xhc3MgKmRldl9jbGFzcyA9IERFVklDRV9DTEFTUyhjbGFzcyk7 CiAgICAgWGVuRGV2aWNlQ2xhc3MgKnhlbmRldl9jbGFzcyA9IFhFTl9ERVZJQ0VfQ0xBU1MoY2xh c3MpOwogCisgICAgeGVuZGV2X2NsYXNzLT5nZXRfbmFtZSA9IHhlbl9ibG9ja19nZXRfbmFtZTsK ICAgICB4ZW5kZXZfY2xhc3MtPnJlYWxpemUgPSB4ZW5fYmxvY2tfcmVhbGl6ZTsKICAgICB4ZW5k ZXZfY2xhc3MtPnVucmVhbGl6ZSA9IHhlbl9ibG9ja191bnJlYWxpemU7CiAKZGlmZiAtLWdpdCBh L2h3L3hlbi9NYWtlZmlsZS5vYmpzIGIvaHcveGVuL01ha2VmaWxlLm9ianMKaW5kZXggZDlkNmQ3 Yi4uNzdjMDg2OCAxMDA2NDQKLS0tIGEvaHcveGVuL01ha2VmaWxlLm9ianMKKysrIGIvaHcveGVu L01ha2VmaWxlLm9ianMKQEAgLTEsNSArMSw1IEBACiAjIHhlbiBiYWNrZW5kIGRyaXZlciBzdXBw b3J0Ci1jb21tb24tb2JqLSQoQ09ORklHX1hFTikgKz0geGVuLWxlZ2FjeS1iYWNrZW5kLm8geGVu X2RldmNvbmZpZy5vIHhlbl9wdmRldi5vIHhlbi1jb21tb24ubyB4ZW4tYnVzLm8KK2NvbW1vbi1v YmotJChDT05GSUdfWEVOKSArPSB4ZW4tbGVnYWN5LWJhY2tlbmQubyB4ZW5fZGV2Y29uZmlnLm8g eGVuX3B2ZGV2Lm8geGVuLWNvbW1vbi5vIHhlbi1idXMubyB4ZW4tYnVzLWhlbHBlci5vCiAKIG9i ai0kKENPTkZJR19YRU5fUENJX1BBU1NUSFJPVUdIKSArPSB4ZW4taG9zdC1wY2ktZGV2aWNlLm8K IG9iai0kKENPTkZJR19YRU5fUENJX1BBU1NUSFJPVUdIKSArPSB4ZW5fcHQubyB4ZW5fcHRfY29u ZmlnX2luaXQubyB4ZW5fcHRfZ3JhcGhpY3MubyB4ZW5fcHRfbXNpLm8KZGlmZiAtLWdpdCBhL2h3 L3hlbi90cmFjZS1ldmVudHMgYi9ody94ZW4vdHJhY2UtZXZlbnRzCmluZGV4IDAxNzJjZDQuLjc1 ZGMyMjYgMTAwNjQ0Ci0tLSBhL2h3L3hlbi90cmFjZS1ldmVudHMKKysrIGIvaHcveGVuL3RyYWNl LWV2ZW50cwpAQCAtMTYsNSArMTYsMTMgQEAgeGVuX2RvbWlkX3Jlc3RyaWN0KGludCBlcnIpICJl cnI6ICV1IgogIyBpbmNsdWRlL2h3L3hlbi94ZW4tYnVzLmMKIHhlbl9idXNfcmVhbGl6ZSh2b2lk KSAiIgogeGVuX2J1c191bnJlYWxpemUodm9pZCkgIiIKLXhlbl9kZXZpY2VfcmVhbGl6ZShjb25z dCBjaGFyICp0eXBlKSAidHlwZTogJXMiCi14ZW5fZGV2aWNlX3VucmVhbGl6ZShjb25zdCBjaGFy ICp0eXBlKSAidHlwZTogJXMiCit4ZW5fZGV2aWNlX3JlYWxpemUoY29uc3QgY2hhciAqdHlwZSwg Y2hhciAqbmFtZSkgInR5cGU6ICVzIG5hbWU6ICVzIgoreGVuX2RldmljZV91bnJlYWxpemUoY29u c3QgY2hhciAqdHlwZSwgY2hhciAqbmFtZSkgInR5cGU6ICVzIG5hbWU6ICVzIgoreGVuX2Rldmlj ZV9iYWNrZW5kX3N0YXRlKGNvbnN0IGNoYXIgKnR5cGUsIGNoYXIgKm5hbWUsIGNvbnN0IGNoYXIg KnN0YXRlKSAidHlwZTogJXMgbmFtZTogJXMgLT4gJXMiCit4ZW5fZGV2aWNlX2Zyb250ZW5kX3N0 YXRlKGNvbnN0IGNoYXIgKnR5cGUsIGNoYXIgKm5hbWUsIGNvbnN0IGNoYXIgKnN0YXRlKSAidHlw ZTogJXMgbmFtZTogJXMgLT4gJXMiCisKKyMgaW5jbHVkZS9ody94ZW4veGVuLWJ1cy1oZWxwZXIu YworeHNfbm9kZV9jcmVhdGUoY29uc3QgY2hhciAqbm9kZSkgIiVzIgoreHNfbm9kZV9kZXN0cm95 KGNvbnN0IGNoYXIgKm5vZGUpICIlcyIKK3hzX25vZGVfdnByaW50ZihjaGFyICpwYXRoLCBjaGFy ICp2YWx1ZSkgIiVzICVzIgoreHNfbm9kZV92c2NhbmYoY2hhciAqcGF0aCwgY2hhciAqdmFsdWUp ICIlcyAlcyIKZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW4tYnVzLWhlbHBlci5jIGIvaHcveGVuL3hl bi1idXMtaGVscGVyLmMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMTViM2Fk OAotLS0gL2Rldi9udWxsCisrKyBiL2h3L3hlbi94ZW4tYnVzLWhlbHBlci5jCkBAIC0wLDAgKzEs MTUwIEBACisvKgorICogQ29weXJpZ2h0IChjKSAyMDE4ICBDaXRyaXggU3lzdGVtcyBJbmMuCisg KgorICogVGhpcyB3b3JrIGlzIGxpY2Vuc2VkIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdQ TCwgdmVyc2lvbiAyIG9yIGxhdGVyLgorICogU2VlIHRoZSBDT1BZSU5HIGZpbGUgaW4gdGhlIHRv cC1sZXZlbCBkaXJlY3RvcnkuCisgKi8KKworI2luY2x1ZGUgInFlbXUvb3NkZXAuaCIKKyNpbmNs dWRlICJody9ody5oIgorI2luY2x1ZGUgImh3L3N5c2J1cy5oIgorI2luY2x1ZGUgImh3L3hlbi94 ZW4uaCIKKyNpbmNsdWRlICJody94ZW4veGVuLWJ1cy5oIgorI2luY2x1ZGUgImh3L3hlbi94ZW4t YnVzLWhlbHBlci5oIgorI2luY2x1ZGUgInFhcGkvZXJyb3IuaCIKKworI2luY2x1ZGUgPGdsaWIv Z3ByaW50Zi5oPgorCitzdHJ1Y3QgeHNfc3RhdGUgeworICAgIGVudW0geGVuYnVzX3N0YXRlIHN0 YXRlbnVtOworICAgIGNvbnN0IGNoYXIgKnN0YXRlc3RyOworfTsKKyNkZWZpbmUgWFNfU1RBVEUo c3RhdGUpIHsgc3RhdGUsICNzdGF0ZSB9CisKK3N0YXRpYyBzdHJ1Y3QgeHNfc3RhdGUgeHNfc3Rh dGVbXSA9IHsKKyAgICBYU19TVEFURShYZW5idXNTdGF0ZVVua25vd24pLAorICAgIFhTX1NUQVRF KFhlbmJ1c1N0YXRlSW5pdGlhbGlzaW5nKSwKKyAgICBYU19TVEFURShYZW5idXNTdGF0ZUluaXRX YWl0KSwKKyAgICBYU19TVEFURShYZW5idXNTdGF0ZUluaXRpYWxpc2VkKSwKKyAgICBYU19TVEFU RShYZW5idXNTdGF0ZUNvbm5lY3RlZCksCisgICAgWFNfU1RBVEUoWGVuYnVzU3RhdGVDbG9zaW5n KSwKKyAgICBYU19TVEFURShYZW5idXNTdGF0ZUNsb3NlZCksCisgICAgWFNfU1RBVEUoWGVuYnVz U3RhdGVSZWNvbmZpZ3VyaW5nKSwKKyAgICBYU19TVEFURShYZW5idXNTdGF0ZVJlY29uZmlndXJl ZCksCit9OworCisjdW5kZWYgWFNfU1RBVEUKKworY29uc3QgY2hhciAqeHNfc3Ryc3RhdGUoZW51 bSB4ZW5idXNfc3RhdGUgc3RhdGUpCit7CisgICAgdW5zaWduZWQgaW50IGk7CisKKyAgIGZvciAo aSA9IDA7IGkgPCBBUlJBWV9TSVpFKHhzX3N0YXRlKTsgaSsrKSB7CisgICAgICAgIGlmICh4c19z dGF0ZVtpXS5zdGF0ZW51bSA9PSBzdGF0ZSkgeworICAgICAgICAgICAgcmV0dXJuIHhzX3N0YXRl W2ldLnN0YXRlc3RyOworICAgICAgICB9CisgICAgfQorCisgICAgcmV0dXJuICJJTlZBTElEIjsK K30KKwordm9pZCB4c19ub2RlX2NyZWF0ZShzdHJ1Y3QgeHNfaGFuZGxlICp4c2gsIHhzX3RyYW5z YWN0aW9uX3QgdGlkLAorICAgICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICpub2RlLCBzdHJ1 Y3QgeHNfcGVybWlzc2lvbnMgcGVybXNbXSwKKyAgICAgICAgICAgICAgICAgICAgdW5zaWduZWQg aW50IG5yX3Blcm1zLCBFcnJvciAqKmVycnApCit7CisgICAgdHJhY2VfeHNfbm9kZV9jcmVhdGUo bm9kZSk7CisKKyAgICBpZiAoIXhzX3dyaXRlKHhzaCwgdGlkLCBub2RlLCAiIiwgMCkpIHsKKyAg ICAgICAgZXJyb3Jfc2V0Z19lcnJubyhlcnJwLCBlcnJubywgImZhaWxlZCB0byBjcmVhdGUgbm9k ZSAnJXMnIiwgbm9kZSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBpZiAoIXhzX3Nl dF9wZXJtaXNzaW9ucyh4c2gsIHRpZCwgbm9kZSwgcGVybXMsIG5yX3Blcm1zKSkgeworICAgICAg ICBlcnJvcl9zZXRnX2Vycm5vKGVycnAsIGVycm5vLCAiZmFpbGVkIHRvIHNldCBub2RlICclcycg cGVybWlzc2lvbnMiLAorICAgICAgICAgICAgICAgICAgICAgICAgIG5vZGUpOworICAgIH0KK30K Kwordm9pZCB4c19ub2RlX2Rlc3Ryb3koc3RydWN0IHhzX2hhbmRsZSAqeHNoLCB4c190cmFuc2Fj dGlvbl90IHRpZCwKKyAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKm5vZGUsIEVycm9y ICoqZXJycCkKK3sKKyAgICB0cmFjZV94c19ub2RlX2Rlc3Ryb3kobm9kZSk7CisKKyAgICBpZiAo IXhzX3JtKHhzaCwgdGlkLCBub2RlKSkgeworICAgICAgICBlcnJvcl9zZXRnX2Vycm5vKGVycnAs IGVycm5vLCAiZmFpbGVkIHRvIGRlc3Ryb3kgbm9kZSAnJXMnIiwgbm9kZSk7CisgICAgfQorfQor Cit2b2lkIHhzX25vZGVfdnByaW50ZihzdHJ1Y3QgeHNfaGFuZGxlICp4c2gsIHhzX3RyYW5zYWN0 aW9uX3QgdGlkLAorICAgICAgICAgICAgICAgICAgICAgY29uc3QgY2hhciAqbm9kZSwgY29uc3Qg Y2hhciAqa2V5LCBFcnJvciAqKmVycnAsCisgICAgICAgICAgICAgICAgICAgICBjb25zdCBjaGFy ICpmbXQsIHZhX2xpc3QgYXApCit7CisgICAgY2hhciAqcGF0aCwgKnZhbHVlOworICAgIGludCBs ZW47CisKKyAgICBwYXRoID0gKHN0cmxlbihub2RlKSAhPSAwKSA/IGdfc3RyZHVwX3ByaW50Zigi JXMvJXMiLCBub2RlLCBrZXkpIDoKKyAgICAgICAgZ19zdHJkdXAoa2V5KTsKKyAgICBsZW4gPSBn X3Zhc3ByaW50ZigmdmFsdWUsIGZtdCwgYXApOworCisgICAgdHJhY2VfeHNfbm9kZV92cHJpbnRm KHBhdGgsIHZhbHVlKTsKKworICAgIGlmICgheHNfd3JpdGUoeHNoLCB0aWQsIHBhdGgsIHZhbHVl LCBsZW4pKSB7CisgICAgICAgIGVycm9yX3NldGdfZXJybm8oZXJycCwgZXJybm8sICJmYWlsZWQg dG8gd3JpdGUgJyVzJyB0byAnJXMnIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICB2YWx1ZSwg cGF0aCk7CisgICAgfQorCisgICAgZ19mcmVlKHZhbHVlKTsKKyAgICBnX2ZyZWUocGF0aCk7Cit9 CisKK3ZvaWQgeHNfbm9kZV9wcmludGYoc3RydWN0IHhzX2hhbmRsZSAqeHNoLCAgeHNfdHJhbnNh Y3Rpb25fdCB0aWQsCisgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKm5vZGUsIGNvbnN0 IGNoYXIgKmtleSwgRXJyb3IgKiplcnJwLAorICAgICAgICAgICAgICAgICAgICBjb25zdCBjaGFy ICpmbXQsIC4uLikKK3sKKyAgICB2YV9saXN0IGFwOworCisgICAgdmFfc3RhcnQoYXAsIGZtdCk7 CisgICAgeHNfbm9kZV92cHJpbnRmKHhzaCwgdGlkLCBub2RlLCBrZXksIGVycnAsIGZtdCwgYXAp OworICAgIHZhX2VuZChhcCk7Cit9CisKK2ludCB4c19ub2RlX3ZzY2FuZihzdHJ1Y3QgeHNfaGFu ZGxlICp4c2gsICB4c190cmFuc2FjdGlvbl90IHRpZCwKKyAgICAgICAgICAgICAgICAgICBjb25z dCBjaGFyICpub2RlLCBjb25zdCBjaGFyICprZXksIEVycm9yICoqZXJycCwKKyAgICAgICAgICAg ICAgICAgICBjb25zdCBjaGFyICpmbXQsIHZhX2xpc3QgYXApCit7CisgICAgY2hhciAqcGF0aCwg KnZhbHVlOworICAgIGludCByYzsKKworICAgIHBhdGggPSAoc3RybGVuKG5vZGUpICE9IDApID8g Z19zdHJkdXBfcHJpbnRmKCIlcy8lcyIsIG5vZGUsIGtleSkgOgorICAgICAgICBnX3N0cmR1cChr ZXkpOworICAgIHZhbHVlID0geHNfcmVhZCh4c2gsIHRpZCwgcGF0aCwgTlVMTCk7CisKKyAgICB0 cmFjZV94c19ub2RlX3ZzY2FuZihwYXRoLCB2YWx1ZSk7CisKKyAgICBpZiAodmFsdWUpIHsKKyAg ICAgICAgcmMgPSB2c3NjYW5mKHZhbHVlLCBmbXQsIGFwKTsKKyAgICB9IGVsc2UgeworICAgICAg ICBlcnJvcl9zZXRnX2Vycm5vKGVycnAsIGVycm5vLCAiZmFpbGVkIHRvIHJlYWQgZnJvbSAnJXMn IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICBwYXRoKTsKKyAgICAgICAgcmMgPSBFT0Y7Cisg ICAgfQorCisgICAgZnJlZSh2YWx1ZSk7CisgICAgZ19mcmVlKHBhdGgpOworCisgICAgcmV0dXJu IHJjOworfQorCitpbnQgeHNfbm9kZV9zY2FuZihzdHJ1Y3QgeHNfaGFuZGxlICp4c2gsICB4c190 cmFuc2FjdGlvbl90IHRpZCwKKyAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKm5vZGUsIGNv bnN0IGNoYXIgKmtleSwgRXJyb3IgKiplcnJwLAorICAgICAgICAgICAgICAgICAgY29uc3QgY2hh ciAqZm10LCAuLi4pCit7CisgICAgdmFfbGlzdCBhcDsKKyAgICBpbnQgcmM7CisKKyAgICB2YV9z dGFydChhcCwgZm10KTsKKyAgICByYyA9IHhzX25vZGVfdnNjYW5mKHhzaCwgdGlkLCBub2RlLCBr ZXksIGVycnAsIGZtdCwgYXApOworICAgIHZhX2VuZChhcCk7CisKKyAgICByZXR1cm4gcmM7Cit9 CmRpZmYgLS1naXQgYS9ody94ZW4veGVuLWJ1cy5jIGIvaHcveGVuL3hlbi1idXMuYwppbmRleCBi YzA0ZGE3Li44NDNmZGEyIDEwMDY0NAotLS0gYS9ody94ZW4veGVuLWJ1cy5jCisrKyBiL2h3L3hl bi94ZW4tYnVzLmMKQEAgLTgsMjQgKzgsMTAyIEBACiAjaW5jbHVkZSAicWVtdS9vc2RlcC5oIgog I2luY2x1ZGUgImh3L2h3LmgiCiAjaW5jbHVkZSAiaHcvc3lzYnVzLmgiCisjaW5jbHVkZSAiaHcv eGVuL3hlbi5oIgogI2luY2x1ZGUgImh3L3hlbi94ZW4tYnVzLmgiCisjaW5jbHVkZSAiaHcveGVu L3hlbi1idXMtaGVscGVyLmgiCisjaW5jbHVkZSAibW9uaXRvci9tb25pdG9yLmgiCiAjaW5jbHVk ZSAicWFwaS9lcnJvci5oIgorI2luY2x1ZGUgInN5c2VtdS9zeXNlbXUuaCIKICNpbmNsdWRlICJ0 cmFjZS5oIgogCitzdGF0aWMgY2hhciAqeGVuX2RldmljZV9nZXRfYmFja2VuZF9wYXRoKFhlbkRl dmljZSAqeGVuZGV2KQoreworICAgIFhlbkJ1cyAqeGVuYnVzID0gWEVOX0JVUyhxZGV2X2dldF9w YXJlbnRfYnVzKERFVklDRSh4ZW5kZXYpKSk7CisgICAgWGVuRGV2aWNlQ2xhc3MgKnhlbmRldl9j bGFzcyA9IFhFTl9ERVZJQ0VfR0VUX0NMQVNTKHhlbmRldik7CisgICAgY29uc3QgY2hhciAqdHlw ZSA9IG9iamVjdF9nZXRfdHlwZW5hbWUoT0JKRUNUKHhlbmRldikpOworICAgIGNvbnN0IGNoYXIg KmJhY2tlbmQgPSB4ZW5kZXZfY2xhc3MtPmJhY2tlbmQ7CisKKyAgICBpZiAoIWJhY2tlbmQpIHsK KyAgICAgICAgYmFja2VuZCA9IHR5cGU7CisgICAgfQorCisgICAgcmV0dXJuIGdfc3RyZHVwX3By aW50ZigiL2xvY2FsL2RvbWFpbi8ldS9iYWNrZW5kLyVzLyV1LyVzIiwKKyAgICAgICAgICAgICAg ICAgICAgICAgICAgIHhlbmJ1cy0+YmFja2VuZF9pZCwgYmFja2VuZCwgeGVuZGV2LT5mcm9udGVu ZF9pZCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgIHhlbmRldi0+bmFtZSk7Cit9CisKK3N0 YXRpYyBjaGFyICp4ZW5fZGV2aWNlX2dldF9mcm9udGVuZF9wYXRoKFhlbkRldmljZSAqeGVuZGV2 KQoreworICAgIFhlbkRldmljZUNsYXNzICp4ZW5kZXZfY2xhc3MgPSBYRU5fREVWSUNFX0dFVF9D TEFTUyh4ZW5kZXYpOworICAgIGNvbnN0IGNoYXIgKnR5cGUgPSBvYmplY3RfZ2V0X3R5cGVuYW1l KE9CSkVDVCh4ZW5kZXYpKTsKKyAgICBjb25zdCBjaGFyICpkZXZpY2UgPSB4ZW5kZXZfY2xhc3Mt PmRldmljZTsKKworICAgIGlmICghZGV2aWNlKSB7CisgICAgICAgIGRldmljZSA9IHR5cGU7Cisg ICAgfQorCisgICAgcmV0dXJuIGdfc3RyZHVwX3ByaW50ZigiL2xvY2FsL2RvbWFpbi8ldS9kZXZp Y2UvJXMvJXMiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgeGVuZGV2LT5mcm9udGVuZF9p ZCwgZGV2aWNlLCB4ZW5kZXYtPm5hbWUpOworfQorCitzdGF0aWMgdm9pZCB4ZW5fYnVzX3ByaW50 X2RldihNb25pdG9yICptb24sIERldmljZVN0YXRlICpkZXYsIGludCBpbmRlbnQpCit7CisgICAg WGVuRGV2aWNlICp4ZW5kZXYgPSBYRU5fREVWSUNFKGRldik7CisKKyAgICBtb25pdG9yX3ByaW50 Zihtb24sICIlKnNuYW1lID0gJyVzJyBmcm9udGVuZF9pZCA9ICV1XG4iLAorICAgICAgICAgICAg ICAgICAgIGluZGVudCwgIiIsIHhlbmRldi0+bmFtZSwgeGVuZGV2LT5mcm9udGVuZF9pZCk7Cit9 CisKK3N0YXRpYyBjaGFyICp4ZW5fYnVzX2dldF9kZXZfcGF0aChEZXZpY2VTdGF0ZSAqZGV2KQor eworICAgIHJldHVybiB4ZW5fZGV2aWNlX2dldF9iYWNrZW5kX3BhdGgoWEVOX0RFVklDRShkZXYp KTsKK30KKwogc3RhdGljIHZvaWQgeGVuX2J1c191bnJlYWxpemUoQnVzU3RhdGUgKmJ1cywgRXJy b3IgKiplcnJwKQogeworICAgIFhlbkJ1cyAqeGVuYnVzID0gWEVOX0JVUyhidXMpOworCiAgICAg dHJhY2VfeGVuX2J1c191bnJlYWxpemUoKTsKKworICAgIGlmICgheGVuYnVzLT54c2gpIHsKKyAg ICAgICAgcmV0dXJuOworICAgIH0KKworICAgIHhzX2Nsb3NlKHhlbmJ1cy0+eHNoKTsKIH0KIAog c3RhdGljIHZvaWQgeGVuX2J1c19yZWFsaXplKEJ1c1N0YXRlICpidXMsIEVycm9yICoqZXJycCkK IHsKKyAgICBYZW5CdXMgKnhlbmJ1cyA9IFhFTl9CVVMoYnVzKTsKKyAgICB1bnNpZ25lZCBpbnQg ZG9taWQ7CisKICAgICB0cmFjZV94ZW5fYnVzX3JlYWxpemUoKTsKKworICAgIHhlbmJ1cy0+eHNo ID0geHNfb3BlbigwKTsKKyAgICBpZiAoIXhlbmJ1cy0+eHNoKSB7CisgICAgICAgIGVycm9yX3Nl dGdfZXJybm8oZXJycCwgZXJybm8sICJmYWlsZWQgeHNfb3BlbiIpOworICAgICAgICBnb3RvIGZh aWw7CisgICAgfQorCisgICAgaWYgKHhzX25vZGVfc2NhbmYoeGVuYnVzLT54c2gsIFhCVF9OVUxM LCAiIiwgLyogZG9tYWluIHJvb3Qgbm9kZSAqLworICAgICAgICAgICAgICAgICAgICAgICJkb21p ZCIsIE5VTEwsICIldSIsICZkb21pZCkgPT0gMSkgeworICAgICAgICB4ZW5idXMtPmJhY2tlbmRf aWQgPSBkb21pZDsKKyAgICB9IGVsc2UgeworICAgICAgICB4ZW5idXMtPmJhY2tlbmRfaWQgPSAw OyAvKiBBc3N1bWUgbGFjayBvZiBub2RlIG1lYW5zIGRvbTAgKi8KKyAgICB9CisKKyAgICByZXR1 cm47CisKK2ZhaWw6CisgICAgeGVuX2J1c191bnJlYWxpemUoYnVzLCAmZXJyb3JfYWJvcnQpOwog fQogCiBzdGF0aWMgdm9pZCB4ZW5fYnVzX2NsYXNzX2luaXQoT2JqZWN0Q2xhc3MgKmNsYXNzLCB2 b2lkICpkYXRhKQogewogICAgIEJ1c0NsYXNzICpidXNfY2xhc3MgPSBCVVNfQ0xBU1MoY2xhc3Mp OwogCisgICAgYnVzX2NsYXNzLT5wcmludF9kZXYgPSB4ZW5fYnVzX3ByaW50X2RldjsKKyAgICBi dXNfY2xhc3MtPmdldF9kZXZfcGF0aCA9IHhlbl9idXNfZ2V0X2Rldl9wYXRoOwogICAgIGJ1c19j bGFzcy0+cmVhbGl6ZSA9IHhlbl9idXNfcmVhbGl6ZTsKICAgICBidXNfY2xhc3MtPnVucmVhbGl6 ZSA9IHhlbl9idXNfdW5yZWFsaXplOwogfQpAQCAtNDIsMjcgKzEyMCwyNDEgQEAgc3RhdGljIGNv bnN0IFR5cGVJbmZvIHhlbl9idXNfdHlwZV9pbmZvID0gewogICAgIH0sCiB9OwogCitzdGF0aWMg dm9pZCB4ZW5fZGV2aWNlX2JhY2tlbmRfcHJpbnRmKFhlbkRldmljZSAqeGVuZGV2LCBjb25zdCBj aGFyICprZXksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNo YXIgKmZtdCwgLi4uKQoreworICAgIFhlbkJ1cyAqeGVuYnVzID0gWEVOX0JVUyhxZGV2X2dldF9w YXJlbnRfYnVzKERFVklDRSh4ZW5kZXYpKSk7CisgICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7 CisgICAgdmFfbGlzdCBhcDsKKworICAgIGdfYXNzZXJ0KHhlbmJ1cy0+eHNoKTsKKworICAgIHZh X3N0YXJ0KGFwLCBmbXQpOworICAgIHhzX25vZGVfdnByaW50Zih4ZW5idXMtPnhzaCwgWEJUX05V TEwsIHhlbmRldi0+YmFja2VuZF9wYXRoLCBrZXksCisgICAgICAgICAgICAgICAgICAgICZsb2Nh bF9lcnIsIGZtdCwgYXApOworICAgIHZhX2VuZChhcCk7CisKKyAgICBpZiAobG9jYWxfZXJyKSB7 CisgICAgICAgIGVycm9yX3JlcG9ydF9lcnIobG9jYWxfZXJyKTsKKyAgICB9Cit9CisKK3N0YXRp YyB2b2lkIHhlbl9kZXZpY2VfYmFja2VuZF9zZXRfc3RhdGUoWGVuRGV2aWNlICp4ZW5kZXYsCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGVudW0geGVuYnVzX3N0YXRl IHN0YXRlKQoreworICAgIGNvbnN0IGNoYXIgKnR5cGUgPSBvYmplY3RfZ2V0X3R5cGVuYW1lKE9C SkVDVCh4ZW5kZXYpKTsKKworICAgIGlmICh4ZW5kZXYtPmJhY2tlbmRfc3RhdGUgPT0gc3RhdGUp IHsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIHRyYWNlX3hlbl9kZXZpY2VfYmFja2Vu ZF9zdGF0ZSh0eXBlLCB4ZW5kZXYtPm5hbWUsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHhzX3N0cnN0YXRlKHN0YXRlKSk7CisKKyAgICB4ZW5kZXYtPmJhY2tlbmRfc3RhdGUg PSBzdGF0ZTsKKyAgICB4ZW5fZGV2aWNlX2JhY2tlbmRfcHJpbnRmKHhlbmRldiwgInN0YXRlIiwg IiV1Iiwgc3RhdGUpOworfQorCitzdGF0aWMgdm9pZCB4ZW5fZGV2aWNlX2JhY2tlbmRfY3JlYXRl KFhlbkRldmljZSAqeGVuZGV2LCBFcnJvciAqKmVycnApCit7CisgICAgWGVuQnVzICp4ZW5idXMg PSBYRU5fQlVTKHFkZXZfZ2V0X3BhcmVudF9idXMoREVWSUNFKHhlbmRldikpKTsKKyAgICBzdHJ1 Y3QgeHNfcGVybWlzc2lvbnMgcGVybXNbMl07CisgICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7 CisKKyAgICB4ZW5kZXYtPmJhY2tlbmRfcGF0aCA9IHhlbl9kZXZpY2VfZ2V0X2JhY2tlbmRfcGF0 aCh4ZW5kZXYpOworCisgICAgcGVybXNbMF0uaWQgPSB4ZW5idXMtPmJhY2tlbmRfaWQ7CisgICAg cGVybXNbMF0ucGVybXMgPSBYU19QRVJNX05PTkU7CisgICAgcGVybXNbMV0uaWQgPSB4ZW5kZXYt PmZyb250ZW5kX2lkOworICAgIHBlcm1zWzFdLnBlcm1zID0gWFNfUEVSTV9SRUFEOworCisgICAg Z19hc3NlcnQoeGVuYnVzLT54c2gpOworCisgICAgeHNfbm9kZV9jcmVhdGUoeGVuYnVzLT54c2gs IFhCVF9OVUxMLCB4ZW5kZXYtPmJhY2tlbmRfcGF0aCwgcGVybXMsCisgICAgICAgICAgICAgICAg ICAgQVJSQVlfU0laRShwZXJtcyksICZsb2NhbF9lcnIpOworICAgIGlmIChsb2NhbF9lcnIpIHsK KyAgICAgICAgZXJyb3JfcHJvcGFnYXRlX3ByZXBlbmQoZXJycCwgbG9jYWxfZXJyLAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAiZmFpbGVkIHRvIGNyZWF0ZSBiYWNrZW5kOiAiKTsK KyAgICB9Cit9CisKK3N0YXRpYyB2b2lkIHhlbl9kZXZpY2VfYmFja2VuZF9kZXN0cm95KFhlbkRl dmljZSAqeGVuZGV2KQoreworICAgIFhlbkJ1cyAqeGVuYnVzID0gWEVOX0JVUyhxZGV2X2dldF9w YXJlbnRfYnVzKERFVklDRSh4ZW5kZXYpKSk7CisgICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7 CisKKyAgICBpZiAoIXhlbmRldi0+YmFja2VuZF9wYXRoKSB7CisgICAgICAgIHJldHVybjsKKyAg ICB9CisKKyAgICBnX2Fzc2VydCh4ZW5idXMtPnhzaCk7CisKKyAgICB4c19ub2RlX2Rlc3Ryb3ko eGVuYnVzLT54c2gsIFhCVF9OVUxMLCB4ZW5kZXYtPmJhY2tlbmRfcGF0aCwKKyAgICAgICAgICAg ICAgICAgICAgJmxvY2FsX2Vycik7CisgICAgZ19mcmVlKHhlbmRldi0+YmFja2VuZF9wYXRoKTsK KyAgICB4ZW5kZXYtPmJhY2tlbmRfcGF0aCA9IE5VTEw7CisKKyAgICBpZiAobG9jYWxfZXJyKSB7 CisgICAgICAgIGVycm9yX3JlcG9ydF9lcnIobG9jYWxfZXJyKTsKKyAgICB9Cit9CisKK3N0YXRp YyB2b2lkIHhlbl9kZXZpY2VfZnJvbnRlbmRfcHJpbnRmKFhlbkRldmljZSAqeGVuZGV2LCBjb25z dCBjaGFyICprZXksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25z dCBjaGFyICpmbXQsIC4uLikKK3sKKyAgICBYZW5CdXMgKnhlbmJ1cyA9IFhFTl9CVVMocWRldl9n ZXRfcGFyZW50X2J1cyhERVZJQ0UoeGVuZGV2KSkpOworICAgIEVycm9yICpsb2NhbF9lcnIgPSBO VUxMOworICAgIHZhX2xpc3QgYXA7CisKKyAgICBnX2Fzc2VydCh4ZW5idXMtPnhzaCk7CisKKyAg ICB2YV9zdGFydChhcCwgZm10KTsKKyAgICB4c19ub2RlX3ZwcmludGYoeGVuYnVzLT54c2gsIFhC VF9OVUxMLCB4ZW5kZXYtPmZyb250ZW5kX3BhdGgsIGtleSwKKyAgICAgICAgICAgICAgICAgICAg JmxvY2FsX2VyciwgZm10LCBhcCk7CisgICAgdmFfZW5kKGFwKTsKKworICAgIGlmIChsb2NhbF9l cnIpIHsKKyAgICAgICAgZXJyb3JfcmVwb3J0X2Vycihsb2NhbF9lcnIpOworICAgIH0KK30KKwor c3RhdGljIHZvaWQgeGVuX2RldmljZV9mcm9udGVuZF9zZXRfc3RhdGUoWGVuRGV2aWNlICp4ZW5k ZXYsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBlbnVtIHhlbmJ1 c19zdGF0ZSBzdGF0ZSkKK3sKKyAgICBjb25zdCBjaGFyICp0eXBlID0gb2JqZWN0X2dldF90eXBl bmFtZShPQkpFQ1QoeGVuZGV2KSk7CisKKyAgICBpZiAoeGVuZGV2LT5mcm9udGVuZF9zdGF0ZSA9 PSBzdGF0ZSkgeworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgdHJhY2VfeGVuX2Rldmlj ZV9mcm9udGVuZF9zdGF0ZSh0eXBlLCB4ZW5kZXYtPm5hbWUsCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICB4c19zdHJzdGF0ZShzdGF0ZSkpOworCisgICAgeGVuZGV2LT5mcm9u dGVuZF9zdGF0ZSA9IHN0YXRlOworICAgIHhlbl9kZXZpY2VfZnJvbnRlbmRfcHJpbnRmKHhlbmRl diwgInN0YXRlIiwgIiV1Iiwgc3RhdGUpOworfQorCitzdGF0aWMgdm9pZCB4ZW5fZGV2aWNlX2Zy b250ZW5kX2NyZWF0ZShYZW5EZXZpY2UgKnhlbmRldiwgRXJyb3IgKiplcnJwKQoreworICAgIFhl bkJ1cyAqeGVuYnVzID0gWEVOX0JVUyhxZGV2X2dldF9wYXJlbnRfYnVzKERFVklDRSh4ZW5kZXYp KSk7CisgICAgc3RydWN0IHhzX3Blcm1pc3Npb25zIHBlcm1zWzJdOworICAgIEVycm9yICpsb2Nh bF9lcnIgPSBOVUxMOworCisgICAgeGVuZGV2LT5mcm9udGVuZF9wYXRoID0geGVuX2RldmljZV9n ZXRfZnJvbnRlbmRfcGF0aCh4ZW5kZXYpOworCisgICAgcGVybXNbMF0uaWQgPSB4ZW5kZXYtPmZy b250ZW5kX2lkOworICAgIHBlcm1zWzBdLnBlcm1zID0gWFNfUEVSTV9OT05FOworICAgIHBlcm1z WzFdLmlkID0geGVuYnVzLT5iYWNrZW5kX2lkOworICAgIHBlcm1zWzFdLnBlcm1zID0gWFNfUEVS TV9SRUFEIHwgWFNfUEVSTV9XUklURTsKKworICAgIGdfYXNzZXJ0KHhlbmJ1cy0+eHNoKTsKKwor ICAgIHhzX25vZGVfY3JlYXRlKHhlbmJ1cy0+eHNoLCBYQlRfTlVMTCwgeGVuZGV2LT5mcm9udGVu ZF9wYXRoLCBwZXJtcywKKyAgICAgICAgICAgICAgICAgICBBUlJBWV9TSVpFKHBlcm1zKSwgJmxv Y2FsX2Vycik7CisgICAgaWYgKGxvY2FsX2VycikgeworICAgICAgICBlcnJvcl9wcm9wYWdhdGVf cHJlcGVuZChlcnJwLCBsb2NhbF9lcnIsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICJmYWlsZWQgdG8gY3JlYXRlIGZyb250ZW5kOiAiKTsKKyAgICB9Cit9CisKK3N0YXRpYyB2b2lk IHhlbl9kZXZpY2VfZnJvbnRlbmRfZGVzdHJveShYZW5EZXZpY2UgKnhlbmRldikKK3sKKyAgICBY ZW5CdXMgKnhlbmJ1cyA9IFhFTl9CVVMocWRldl9nZXRfcGFyZW50X2J1cyhERVZJQ0UoeGVuZGV2 KSkpOworICAgIEVycm9yICpsb2NhbF9lcnIgPSBOVUxMOworCisgICAgaWYgKCF4ZW5kZXYtPmZy b250ZW5kX3BhdGgpIHsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIGdfYXNzZXJ0KHhl bmJ1cy0+eHNoKTsKKworICAgIHhzX25vZGVfZGVzdHJveSh4ZW5idXMtPnhzaCwgWEJUX05VTEws IHhlbmRldi0+ZnJvbnRlbmRfcGF0aCwKKyAgICAgICAgICAgICAgICAgICAgJmxvY2FsX2Vycik7 CisgICAgZ19mcmVlKHhlbmRldi0+ZnJvbnRlbmRfcGF0aCk7CisgICAgeGVuZGV2LT5mcm9udGVu ZF9wYXRoID0gTlVMTDsKKworICAgIGlmIChsb2NhbF9lcnIpIHsKKyAgICAgICAgZXJyb3JfcmVw b3J0X2Vycihsb2NhbF9lcnIpOworICAgIH0KK30KKwogc3RhdGljIHZvaWQgeGVuX2RldmljZV91 bnJlYWxpemUoRGV2aWNlU3RhdGUgKmRldiwgRXJyb3IgKiplcnJwKQogewogICAgIFhlbkRldmlj ZSAqeGVuZGV2ID0gWEVOX0RFVklDRShkZXYpOwogICAgIFhlbkRldmljZUNsYXNzICp4ZW5kZXZf Y2xhc3MgPSBYRU5fREVWSUNFX0dFVF9DTEFTUyh4ZW5kZXYpOwogICAgIGNvbnN0IGNoYXIgKnR5 cGUgPSBvYmplY3RfZ2V0X3R5cGVuYW1lKE9CSkVDVCh4ZW5kZXYpKTsKIAotICAgIHRyYWNlX3hl bl9kZXZpY2VfdW5yZWFsaXplKHR5cGUpOworICAgIGlmICgheGVuZGV2LT5uYW1lKSB7CisgICAg ICAgIHJldHVybjsKKyAgICB9CisKKyAgICB0cmFjZV94ZW5fZGV2aWNlX3VucmVhbGl6ZSh0eXBl LCB4ZW5kZXYtPm5hbWUpOworCisgICAgaWYgKHhlbmRldi0+ZXhpdC5ub3RpZnkpIHsKKyAgICAg ICAgcWVtdV9yZW1vdmVfZXhpdF9ub3RpZmllcigmeGVuZGV2LT5leGl0KTsKKyAgICAgICAgeGVu ZGV2LT5leGl0Lm5vdGlmeSA9IE5VTEw7CisgICAgfQogCiAgICAgaWYgKHhlbmRldl9jbGFzcy0+ dW5yZWFsaXplKSB7CiAgICAgICAgIHhlbmRldl9jbGFzcy0+dW5yZWFsaXplKHhlbmRldiwgZXJy cCk7CiAgICAgfQorCisgICAgeGVuX2RldmljZV9mcm9udGVuZF9kZXN0cm95KHhlbmRldik7Cisg ICAgeGVuX2RldmljZV9iYWNrZW5kX2Rlc3Ryb3koeGVuZGV2KTsKKworICAgIGdfZnJlZSh4ZW5k ZXYtPm5hbWUpOworICAgIHhlbmRldi0+bmFtZSA9IE5VTEw7Cit9CisKK3N0YXRpYyB2b2lkIHhl bl9kZXZpY2VfZXhpdChOb3RpZmllciAqbiwgdm9pZCAqZGF0YSkKK3sKKyAgICBYZW5EZXZpY2Ug KnhlbmRldiA9IGNvbnRhaW5lcl9vZihuLCBYZW5EZXZpY2UsIGV4aXQpOworCisgICAgeGVuX2Rl dmljZV91bnJlYWxpemUoREVWSUNFKHhlbmRldiksICZlcnJvcl9hYm9ydCk7CiB9CiAKIHN0YXRp YyB2b2lkIHhlbl9kZXZpY2VfcmVhbGl6ZShEZXZpY2VTdGF0ZSAqZGV2LCBFcnJvciAqKmVycnAp CiB7CiAgICAgWGVuRGV2aWNlICp4ZW5kZXYgPSBYRU5fREVWSUNFKGRldik7CiAgICAgWGVuRGV2 aWNlQ2xhc3MgKnhlbmRldl9jbGFzcyA9IFhFTl9ERVZJQ0VfR0VUX0NMQVNTKHhlbmRldik7Cisg ICAgWGVuQnVzICp4ZW5idXMgPSBYRU5fQlVTKHFkZXZfZ2V0X3BhcmVudF9idXMoREVWSUNFKHhl bmRldikpKTsKICAgICBjb25zdCBjaGFyICp0eXBlID0gb2JqZWN0X2dldF90eXBlbmFtZShPQkpF Q1QoeGVuZGV2KSk7CiAgICAgRXJyb3IgKmxvY2FsX2VyciA9IE5VTEw7CiAKLSAgICB0cmFjZV94 ZW5fZGV2aWNlX3JlYWxpemUodHlwZSk7CisgICAgaWYgKHhlbmRldi0+ZnJvbnRlbmRfaWQgPT0g RE9NSURfSU5WQUxJRCkgeworICAgICAgICB4ZW5kZXYtPmZyb250ZW5kX2lkID0geGVuX2RvbWlk OworICAgIH0KKworICAgIGlmICh4ZW5kZXYtPmZyb250ZW5kX2lkID49IERPTUlEX0ZJUlNUX1JF U0VSVkVEKSB7CisgICAgICAgIGVycm9yX3NldGcoZXJycCwgImludmFsaWQgZnJvbnRlbmQtaWQi KTsKKyAgICAgICAgZ290byB1bnJlYWxpemU7CisgICAgfQorCisgICAgaWYgKCF4ZW5kZXZfY2xh c3MtPmdldF9uYW1lKSB7CisgICAgICAgIGVycm9yX3NldGcoZXJycCwgImdldF9uYW1lIG1ldGhv ZCBub3QgaW1wbGVtZW50ZWQiKTsKKyAgICAgICAgZ290byB1bnJlYWxpemU7CisgICAgfQorCisg ICAgeGVuZGV2LT5uYW1lID0geGVuZGV2X2NsYXNzLT5nZXRfbmFtZSh4ZW5kZXYsICZsb2NhbF9l cnIpOworICAgIGlmIChsb2NhbF9lcnIpIHsKKyAgICAgICAgZXJyb3JfcHJvcGFnYXRlX3ByZXBl bmQoZXJycCwgbG9jYWxfZXJyLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAiZmFp bGVkIHRvIGdldCBkZXZpY2UgbmFtZTogIik7CisgICAgICAgIGdvdG8gdW5yZWFsaXplOworICAg IH0KKworICAgIHRyYWNlX3hlbl9kZXZpY2VfcmVhbGl6ZSh0eXBlLCB4ZW5kZXYtPm5hbWUpOwor CisgICAgeGVuX2RldmljZV9iYWNrZW5kX2NyZWF0ZSh4ZW5kZXYsICZsb2NhbF9lcnIpOworICAg IGlmIChsb2NhbF9lcnIpIHsKKyAgICAgICAgZXJyb3JfcHJvcGFnYXRlKGVycnAsIGxvY2FsX2Vy cik7CisgICAgICAgIGdvdG8gdW5yZWFsaXplOworICAgIH0KKworICAgIHhlbl9kZXZpY2VfZnJv bnRlbmRfY3JlYXRlKHhlbmRldiwgJmxvY2FsX2Vycik7CisgICAgaWYgKGxvY2FsX2Vycikgewor ICAgICAgICBlcnJvcl9wcm9wYWdhdGUoZXJycCwgbG9jYWxfZXJyKTsKKyAgICAgICAgZ290byB1 bnJlYWxpemU7CisgICAgfQogCiAgICAgaWYgKHhlbmRldl9jbGFzcy0+cmVhbGl6ZSkgewogICAg ICAgICB4ZW5kZXZfY2xhc3MtPnJlYWxpemUoeGVuZGV2LCAmbG9jYWxfZXJyKTsKQEAgLTcyLDE4 ICszNjQsNDMgQEAgc3RhdGljIHZvaWQgeGVuX2RldmljZV9yZWFsaXplKERldmljZVN0YXRlICpk ZXYsIEVycm9yICoqZXJycCkKICAgICAgICAgfQogICAgIH0KIAorICAgIHhlbl9kZXZpY2VfYmFj a2VuZF9wcmludGYoeGVuZGV2LCAiZnJvbnRlbmQiLCAiJXMiLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgeGVuZGV2LT5mcm9udGVuZF9wYXRoKTsKKyAgICB4ZW5fZGV2aWNlX2JhY2tl bmRfcHJpbnRmKHhlbmRldiwgImZyb250ZW5kLWlkIiwgIiV1IiwKKyAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHhlbmRldi0+ZnJvbnRlbmRfaWQpOworICAgIHhlbl9kZXZpY2VfYmFja2Vu ZF9wcmludGYoeGVuZGV2LCAib25saW5lIiwgIiV1IiwgMSk7CisgICAgeGVuX2RldmljZV9iYWNr ZW5kX3ByaW50Zih4ZW5kZXYsICJob3RwbHVnLXN0YXR1cyIsICJjb25uZWN0ZWQiKTsKKworICAg IHhlbl9kZXZpY2VfYmFja2VuZF9zZXRfc3RhdGUoeGVuZGV2LCBYZW5idXNTdGF0ZUluaXRXYWl0 KTsKKworICAgIHhlbl9kZXZpY2VfZnJvbnRlbmRfcHJpbnRmKHhlbmRldiwgImJhY2tlbmQiLCAi JXMiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHhlbmRldi0+YmFja2VuZF9wYXRo KTsKKyAgICB4ZW5fZGV2aWNlX2Zyb250ZW5kX3ByaW50Zih4ZW5kZXYsICJiYWNrZW5kLWlkIiwg IiV1IiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB4ZW5idXMtPmJhY2tlbmRfaWQp OworCisgICAgeGVuX2RldmljZV9mcm9udGVuZF9zZXRfc3RhdGUoeGVuZGV2LCBYZW5idXNTdGF0 ZUluaXRpYWxpc2luZyk7CisKKyAgICB4ZW5kZXYtPmV4aXQubm90aWZ5ID0geGVuX2RldmljZV9l eGl0OworICAgIHFlbXVfYWRkX2V4aXRfbm90aWZpZXIoJnhlbmRldi0+ZXhpdCk7CiAgICAgcmV0 dXJuOwogCiB1bnJlYWxpemU6CiAgICAgeGVuX2RldmljZV91bnJlYWxpemUoZGV2LCAmZXJyb3Jf YWJvcnQpOwogfQogCitzdGF0aWMgUHJvcGVydHkgeGVuX2RldmljZV9wcm9wc1tdID0geworICAg IERFRklORV9QUk9QX1VJTlQxNigiZnJvbnRlbmQtaWQiLCBYZW5EZXZpY2UsIGZyb250ZW5kX2lk LAorICAgICAgICAgICAgICAgICAgICAgICBET01JRF9JTlZBTElEKSwKKyAgICBERUZJTkVfUFJP UF9FTkRfT0ZfTElTVCgpCit9OworCiBzdGF0aWMgdm9pZCB4ZW5fZGV2aWNlX2NsYXNzX2luaXQo T2JqZWN0Q2xhc3MgKmNsYXNzLCB2b2lkICpkYXRhKQogewogICAgIERldmljZUNsYXNzICpkZXZf Y2xhc3MgPSBERVZJQ0VfQ0xBU1MoY2xhc3MpOwogCiAgICAgZGV2X2NsYXNzLT5yZWFsaXplID0g eGVuX2RldmljZV9yZWFsaXplOwogICAgIGRldl9jbGFzcy0+dW5yZWFsaXplID0geGVuX2Rldmlj ZV91bnJlYWxpemU7CisgICAgZGV2X2NsYXNzLT5wcm9wcyA9IHhlbl9kZXZpY2VfcHJvcHM7CiAg ICAgZGV2X2NsYXNzLT5idXNfdHlwZSA9IFRZUEVfWEVOX0JVUzsKIH0KIApkaWZmIC0tZ2l0IGEv aW5jbHVkZS9ody94ZW4veGVuLWJ1cy1oZWxwZXIuaCBiL2luY2x1ZGUvaHcveGVuL3hlbi1idXMt aGVscGVyLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNWNkOWMzZAotLS0g L2Rldi9udWxsCisrKyBiL2luY2x1ZGUvaHcveGVuL3hlbi1idXMtaGVscGVyLmgKQEAgLTAsMCAr MSwzOSBAQAorLyoKKyAqIENvcHlyaWdodCAoYykgMjAxOCAgQ2l0cml4IFN5c3RlbXMgSW5jLgor ICoKKyAqIFRoaXMgd29yayBpcyBsaWNlbnNlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBH UEwsIHZlcnNpb24gMiBvciBsYXRlci4KKyAqIFNlZSB0aGUgQ09QWUlORyBmaWxlIGluIHRoZSB0 b3AtbGV2ZWwgZGlyZWN0b3J5LgorICovCisKKyNpZm5kZWYgSFdfWEVOX0JVU19IRUxQRVJfSAor I2RlZmluZSBIV19YRU5fQlVTX0hFTFBFUl9ICisKKyNpbmNsdWRlICJody94ZW4veGVuX2NvbW1v bi5oIgorCitjb25zdCBjaGFyICp4c19zdHJzdGF0ZShlbnVtIHhlbmJ1c19zdGF0ZSBzdGF0ZSk7 CisKK3ZvaWQgeHNfbm9kZV9jcmVhdGUoc3RydWN0IHhzX2hhbmRsZSAqeHNoLCAgeHNfdHJhbnNh Y3Rpb25fdCB0aWQsCisgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKm5vZGUsIHN0cnVj dCB4c19wZXJtaXNzaW9ucyBwZXJtc1tdLAorICAgICAgICAgICAgICAgICAgICB1bnNpZ25lZCBp bnQgbnJfcGVybXMsIEVycm9yICoqZXJycCk7Cit2b2lkIHhzX25vZGVfZGVzdHJveShzdHJ1Y3Qg eHNfaGFuZGxlICp4c2gsICB4c190cmFuc2FjdGlvbl90IHRpZCwKKyAgICAgICAgICAgICAgICAg ICAgIGNvbnN0IGNoYXIgKm5vZGUsIEVycm9yICoqZXJycCk7CisKKy8qIFdyaXRlIHRvIG5vZGUv a2V5IHVubGVzcyBub2RlIGlzIGVtcHR5LCBpbiB3aGljaCBjYXNlIHdyaXRlIHRvIGtleSAqLwor dm9pZCB4c19ub2RlX3ZwcmludGYoc3RydWN0IHhzX2hhbmRsZSAqeHNoLCAgeHNfdHJhbnNhY3Rp b25fdCB0aWQsCisgICAgICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICpub2RlLCBjb25zdCBj aGFyICprZXksIEVycm9yICoqZXJycCwKKyAgICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIg KmZtdCwgdmFfbGlzdCBhcCkKKyAgICBHQ0NfRk1UX0FUVFIoNiwgMCk7Cit2b2lkIHhzX25vZGVf cHJpbnRmKHN0cnVjdCB4c19oYW5kbGUgKnhzaCwgIHhzX3RyYW5zYWN0aW9uX3QgdGlkLAorICAg ICAgICAgICAgICAgICAgICBjb25zdCBjaGFyICpub2RlLCBjb25zdCBjaGFyICprZXksIEVycm9y ICoqZXJycCwKKyAgICAgICAgICAgICAgICAgICAgY29uc3QgY2hhciAqZm10LCAuLi4pCisgICAg R0NDX0ZNVF9BVFRSKDYsIDcpOworCisvKiBSZWFkIGZyb20gbm9kZS9rZXkgdW5sZXNzIG5vZGUg aXMgZW1wdHksIGluIHdoaWNoIGNhc2UgcmVhZCBmcm9tIGtleSAqLworaW50IHhzX25vZGVfdnNj YW5mKHN0cnVjdCB4c19oYW5kbGUgKnhzaCwgIHhzX3RyYW5zYWN0aW9uX3QgdGlkLAorICAgICAg ICAgICAgICAgICAgIGNvbnN0IGNoYXIgKm5vZGUsIGNvbnN0IGNoYXIgKmtleSwgRXJyb3IgKipl cnJwLAorICAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKmZtdCwgdmFfbGlzdCBhcCk7Citp bnQgeHNfbm9kZV9zY2FuZihzdHJ1Y3QgeHNfaGFuZGxlICp4c2gsICB4c190cmFuc2FjdGlvbl90 IHRpZCwKKyAgICAgICAgICAgICAgICAgIGNvbnN0IGNoYXIgKm5vZGUsIGNvbnN0IGNoYXIgKmtl eSwgRXJyb3IgKiplcnJwLAorICAgICAgICAgICAgICAgICAgY29uc3QgY2hhciAqZm10LCAuLi4p OworCisjZW5kaWYgLyogSFdfWEVOX0JVU19IRUxQRVJfSCAqLwpkaWZmIC0tZ2l0IGEvaW5jbHVk ZS9ody94ZW4veGVuLWJ1cy5oIGIvaW5jbHVkZS9ody94ZW4veGVuLWJ1cy5oCmluZGV4IDBjYjEy NDYuLjg1YTc1ZDggMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvaHcveGVuL3hlbi1idXMuaAorKysgYi9p bmNsdWRlL2h3L3hlbi94ZW4tYnVzLmgKQEAgLTgsMTIgKzgsMTkgQEAKICNpZm5kZWYgSFdfWEVO X0JVU19ICiAjZGVmaW5lIEhXX1hFTl9CVVNfSAogCisjaW5jbHVkZSAiaHcveGVuL3hlbl9jb21t b24uaCIKICNpbmNsdWRlICJody9zeXNidXMuaCIKIAogdHlwZWRlZiBzdHJ1Y3QgWGVuRGV2aWNl IHsKICAgICBEZXZpY2VTdGF0ZSBxZGV2OworICAgIGRvbWlkX3QgZnJvbnRlbmRfaWQ7CisgICAg Y2hhciAqbmFtZTsKKyAgICBjaGFyICpiYWNrZW5kX3BhdGgsICpmcm9udGVuZF9wYXRoOworICAg IGVudW0geGVuYnVzX3N0YXRlIGJhY2tlbmRfc3RhdGUsIGZyb250ZW5kX3N0YXRlOworICAgIE5v dGlmaWVyIGV4aXQ7CiB9IFhlbkRldmljZTsKIAordHlwZWRlZiBjaGFyICooKlhlbkRldmljZUdl dE5hbWUpKFhlbkRldmljZSAqeGVuZGV2LCBFcnJvciAqKmVycnApOwogdHlwZWRlZiB2b2lkICgq WGVuRGV2aWNlUmVhbGl6ZSkoWGVuRGV2aWNlICp4ZW5kZXYsIEVycm9yICoqZXJycCk7CiB0eXBl ZGVmIHZvaWQgKCpYZW5EZXZpY2VVbnJlYWxpemUpKFhlbkRldmljZSAqeGVuZGV2LCBFcnJvciAq KmVycnApOwogCkBAIC0yMSw2ICsyOCw5IEBAIHR5cGVkZWYgc3RydWN0IFhlbkRldmljZUNsYXNz IHsKICAgICAvKjwgcHJpdmF0ZSA+Ki8KICAgICBEZXZpY2VDbGFzcyBwYXJlbnRfY2xhc3M7CiAg ICAgLyo8IHB1YmxpYyA+Ki8KKyAgICBjb25zdCBjaGFyICpiYWNrZW5kOworICAgIGNvbnN0IGNo YXIgKmRldmljZTsKKyAgICBYZW5EZXZpY2VHZXROYW1lIGdldF9uYW1lOwogICAgIFhlbkRldmlj ZVJlYWxpemUgcmVhbGl6ZTsKICAgICBYZW5EZXZpY2VVbnJlYWxpemUgdW5yZWFsaXplOwogfSBY ZW5EZXZpY2VDbGFzczsKQEAgLTM1LDYgKzQ1LDggQEAgdHlwZWRlZiBzdHJ1Y3QgWGVuRGV2aWNl Q2xhc3MgewogCiB0eXBlZGVmIHN0cnVjdCBYZW5CdXMgewogICAgIEJ1c1N0YXRlIHFidXM7Cisg ICAgZG9taWRfdCBiYWNrZW5kX2lkOworICAgIHN0cnVjdCB4c19oYW5kbGUgKnhzaDsKIH0gWGVu QnVzOwogCiB0eXBlZGVmIHN0cnVjdCBYZW5CdXNDbGFzcyB7Ci0tIAoyLjEuNAoKCl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fClhlbi1kZXZlbCBtYWlsaW5n IGxpc3QKWGVuLWRldmVsQGxpc3RzLnhlbnByb2plY3Qub3JnCmh0dHBzOi8vbGlzdHMueGVucHJv amVjdC5vcmcvbWFpbG1hbi9saXN0aW5mby94ZW4tZGV2ZWw= From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:56041) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1gWfZr-0003rh-3Q for qemu-devel@nongnu.org; Tue, 11 Dec 2018 05:47:50 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1gWfZo-0000Ab-0p for qemu-devel@nongnu.org; Tue, 11 Dec 2018 05:47:47 -0500 From: Paul Durrant Date: Tue, 11 Dec 2018 10:47:04 +0000 Message-ID: <1544525238-3527-5-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 Subject: [Qemu-devel] [PATCH v3 04/18] xen: create xenstore areas for XenDevice-s 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 , Anthony Perard , Stefano Stabellini , Kevin Wolf , Max Reitz This patch adds a new source module, xen-bus-helper.c, which builds on basic libxenstore primitives to provide functions to create (setting permissions appropriately) and destroy xenstore areas, and functions to 'printf' and 'scanf' nodes therein. The main xen-bus code then uses these primitives [1] to initialize and destroy the frontend and backend areas for a XenDevice during realize and unrealize respectively. The 'xen-block' implementation is extended with a 'get_name' method that returns the VBD number. This number is required to 'name' the xenstore areas. NOTE: An exit handler is also added to make sure the xenstore areas are cleaned up if QEMU terminates without devices being unrealized. [1] The 'scanf' functions are actually not yet needed, but they will be needed by code delivered in subsequent patches. Signed-off-by: Paul Durrant --- Cc: Anthony Perard Cc: Stefano Stabellini Cc: Kevin Wolf Cc: Max Reitz v3: - Add transaction id parameters to xen-bus-helper functions - Not added Anthony's R-b because of change v2: - Fix boilerplate - Add error pointers to all xs_node... helpers - Add GCC_FMT_ATTR to declarations of printf-like helpers --- hw/block/xen-block.c | 9 ++ hw/xen/Makefile.objs | 2 +- hw/xen/trace-events | 12 +- hw/xen/xen-bus-helper.c | 150 +++++++++++++++++++ hw/xen/xen-bus.c | 321 +++++++++++++++++++++++++++++++++++++++- include/hw/xen/xen-bus-helper.h | 39 +++++ include/hw/xen/xen-bus.h | 12 ++ 7 files changed, 540 insertions(+), 5 deletions(-) create mode 100644 hw/xen/xen-bus-helper.c create mode 100644 include/hw/xen/xen-bus-helper.h diff --git a/hw/block/xen-block.c b/hw/block/xen-block.c index c29acb0..fa57bf1 100644 --- a/hw/block/xen-block.c +++ b/hw/block/xen-block.c @@ -13,6 +13,14 @@ #include "hw/xen/xen-block.h" #include "trace.h" +static char *xen_block_get_name(XenDevice *xendev, Error **errp) +{ + XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev); + XenBlockVdev *vdev = &blockdev->vdev; + + return g_strdup_printf("%lu", vdev->number); +} + static void xen_block_unrealize(XenDevice *xendev, Error **errp) { XenBlockDevice *blockdev = XEN_BLOCK_DEVICE(xendev); @@ -262,6 +270,7 @@ static void xen_block_class_init(ObjectClass *class, void *data) DeviceClass *dev_class = DEVICE_CLASS(class); XenDeviceClass *xendev_class = XEN_DEVICE_CLASS(class); + xendev_class->get_name = xen_block_get_name; xendev_class->realize = xen_block_realize; xendev_class->unrealize = xen_block_unrealize; diff --git a/hw/xen/Makefile.objs b/hw/xen/Makefile.objs index d9d6d7b..77c0868 100644 --- a/hw/xen/Makefile.objs +++ b/hw/xen/Makefile.objs @@ -1,5 +1,5 @@ # xen backend driver support -common-obj-$(CONFIG_XEN) += xen-legacy-backend.o xen_devconfig.o xen_pvdev.o xen-common.o xen-bus.o +common-obj-$(CONFIG_XEN) += xen-legacy-backend.o xen_devconfig.o xen_pvdev.o xen-common.o xen-bus.o xen-bus-helper.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/trace-events b/hw/xen/trace-events index 0172cd4..75dc226 100644 --- a/hw/xen/trace-events +++ b/hw/xen/trace-events @@ -16,5 +16,13 @@ xen_domid_restrict(int err) "err: %u" # include/hw/xen/xen-bus.c xen_bus_realize(void) "" xen_bus_unrealize(void) "" -xen_device_realize(const char *type) "type: %s" -xen_device_unrealize(const char *type) "type: %s" +xen_device_realize(const char *type, char *name) "type: %s name: %s" +xen_device_unrealize(const char *type, char *name) "type: %s name: %s" +xen_device_backend_state(const char *type, char *name, const char *state) "type: %s name: %s -> %s" +xen_device_frontend_state(const char *type, char *name, const char *state) "type: %s name: %s -> %s" + +# include/hw/xen/xen-bus-helper.c +xs_node_create(const char *node) "%s" +xs_node_destroy(const char *node) "%s" +xs_node_vprintf(char *path, char *value) "%s %s" +xs_node_vscanf(char *path, char *value) "%s %s" diff --git a/hw/xen/xen-bus-helper.c b/hw/xen/xen-bus-helper.c new file mode 100644 index 0000000..15b3ad8 --- /dev/null +++ b/hw/xen/xen-bus-helper.c @@ -0,0 +1,150 @@ +/* + * Copyright (c) 2018 Citrix Systems Inc. + * + * This work is licensed under the terms of the GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. + */ + +#include "qemu/osdep.h" +#include "hw/hw.h" +#include "hw/sysbus.h" +#include "hw/xen/xen.h" +#include "hw/xen/xen-bus.h" +#include "hw/xen/xen-bus-helper.h" +#include "qapi/error.h" + +#include + +struct xs_state { + enum xenbus_state statenum; + const char *statestr; +}; +#define XS_STATE(state) { state, #state } + +static struct xs_state xs_state[] = { + XS_STATE(XenbusStateUnknown), + XS_STATE(XenbusStateInitialising), + XS_STATE(XenbusStateInitWait), + XS_STATE(XenbusStateInitialised), + XS_STATE(XenbusStateConnected), + XS_STATE(XenbusStateClosing), + XS_STATE(XenbusStateClosed), + XS_STATE(XenbusStateReconfiguring), + XS_STATE(XenbusStateReconfigured), +}; + +#undef XS_STATE + +const char *xs_strstate(enum xenbus_state state) +{ + unsigned int i; + + for (i = 0; i < ARRAY_SIZE(xs_state); i++) { + if (xs_state[i].statenum == state) { + return xs_state[i].statestr; + } + } + + return "INVALID"; +} + +void xs_node_create(struct xs_handle *xsh, xs_transaction_t tid, + const char *node, struct xs_permissions perms[], + unsigned int nr_perms, Error **errp) +{ + trace_xs_node_create(node); + + if (!xs_write(xsh, tid, node, "", 0)) { + error_setg_errno(errp, errno, "failed to create node '%s'", node); + return; + } + + if (!xs_set_permissions(xsh, tid, node, perms, nr_perms)) { + error_setg_errno(errp, errno, "failed to set node '%s' permissions", + node); + } +} + +void xs_node_destroy(struct xs_handle *xsh, xs_transaction_t tid, + const char *node, Error **errp) +{ + trace_xs_node_destroy(node); + + if (!xs_rm(xsh, tid, node)) { + error_setg_errno(errp, errno, "failed to destroy node '%s'", node); + } +} + +void xs_node_vprintf(struct xs_handle *xsh, xs_transaction_t tid, + const char *node, const char *key, Error **errp, + const char *fmt, va_list ap) +{ + char *path, *value; + int len; + + path = (strlen(node) != 0) ? g_strdup_printf("%s/%s", node, key) : + g_strdup(key); + len = g_vasprintf(&value, fmt, ap); + + trace_xs_node_vprintf(path, value); + + if (!xs_write(xsh, tid, path, value, len)) { + error_setg_errno(errp, errno, "failed to write '%s' to '%s'", + value, path); + } + + g_free(value); + g_free(path); +} + +void xs_node_printf(struct xs_handle *xsh, xs_transaction_t tid, + const char *node, const char *key, Error **errp, + const char *fmt, ...) +{ + va_list ap; + + va_start(ap, fmt); + xs_node_vprintf(xsh, tid, node, key, errp, fmt, ap); + va_end(ap); +} + +int xs_node_vscanf(struct xs_handle *xsh, xs_transaction_t tid, + const char *node, const char *key, Error **errp, + const char *fmt, va_list ap) +{ + char *path, *value; + int rc; + + path = (strlen(node) != 0) ? g_strdup_printf("%s/%s", node, key) : + g_strdup(key); + value = xs_read(xsh, tid, path, NULL); + + trace_xs_node_vscanf(path, value); + + if (value) { + rc = vsscanf(value, fmt, ap); + } else { + error_setg_errno(errp, errno, "failed to read from '%s'", + path); + rc = EOF; + } + + free(value); + g_free(path); + + return rc; +} + +int xs_node_scanf(struct xs_handle *xsh, xs_transaction_t tid, + const char *node, const char *key, Error **errp, + const char *fmt, ...) +{ + va_list ap; + int rc; + + va_start(ap, fmt); + rc = xs_node_vscanf(xsh, tid, node, key, errp, fmt, ap); + va_end(ap); + + return rc; +} diff --git a/hw/xen/xen-bus.c b/hw/xen/xen-bus.c index bc04da7..843fda2 100644 --- a/hw/xen/xen-bus.c +++ b/hw/xen/xen-bus.c @@ -8,24 +8,102 @@ #include "qemu/osdep.h" #include "hw/hw.h" #include "hw/sysbus.h" +#include "hw/xen/xen.h" #include "hw/xen/xen-bus.h" +#include "hw/xen/xen-bus-helper.h" +#include "monitor/monitor.h" #include "qapi/error.h" +#include "sysemu/sysemu.h" #include "trace.h" +static char *xen_device_get_backend_path(XenDevice *xendev) +{ + XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); + XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev); + const char *type = object_get_typename(OBJECT(xendev)); + const char *backend = xendev_class->backend; + + if (!backend) { + backend = type; + } + + return g_strdup_printf("/local/domain/%u/backend/%s/%u/%s", + xenbus->backend_id, backend, xendev->frontend_id, + xendev->name); +} + +static char *xen_device_get_frontend_path(XenDevice *xendev) +{ + XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev); + const char *type = object_get_typename(OBJECT(xendev)); + const char *device = xendev_class->device; + + if (!device) { + device = type; + } + + return g_strdup_printf("/local/domain/%u/device/%s/%s", + xendev->frontend_id, device, xendev->name); +} + +static void xen_bus_print_dev(Monitor *mon, DeviceState *dev, int indent) +{ + XenDevice *xendev = XEN_DEVICE(dev); + + monitor_printf(mon, "%*sname = '%s' frontend_id = %u\n", + indent, "", xendev->name, xendev->frontend_id); +} + +static char *xen_bus_get_dev_path(DeviceState *dev) +{ + return xen_device_get_backend_path(XEN_DEVICE(dev)); +} + static void xen_bus_unrealize(BusState *bus, Error **errp) { + XenBus *xenbus = XEN_BUS(bus); + trace_xen_bus_unrealize(); + + if (!xenbus->xsh) { + return; + } + + xs_close(xenbus->xsh); } static void xen_bus_realize(BusState *bus, Error **errp) { + XenBus *xenbus = XEN_BUS(bus); + unsigned int domid; + trace_xen_bus_realize(); + + xenbus->xsh = xs_open(0); + if (!xenbus->xsh) { + error_setg_errno(errp, errno, "failed xs_open"); + goto fail; + } + + if (xs_node_scanf(xenbus->xsh, XBT_NULL, "", /* domain root node */ + "domid", NULL, "%u", &domid) == 1) { + xenbus->backend_id = domid; + } else { + xenbus->backend_id = 0; /* Assume lack of node means dom0 */ + } + + return; + +fail: + xen_bus_unrealize(bus, &error_abort); } static void xen_bus_class_init(ObjectClass *class, void *data) { BusClass *bus_class = BUS_CLASS(class); + bus_class->print_dev = xen_bus_print_dev; + bus_class->get_dev_path = xen_bus_get_dev_path; bus_class->realize = xen_bus_realize; bus_class->unrealize = xen_bus_unrealize; } @@ -42,27 +120,241 @@ static const TypeInfo xen_bus_type_info = { }, }; +static void xen_device_backend_printf(XenDevice *xendev, const char *key, + const char *fmt, ...) +{ + XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); + Error *local_err = NULL; + va_list ap; + + g_assert(xenbus->xsh); + + va_start(ap, fmt); + xs_node_vprintf(xenbus->xsh, XBT_NULL, xendev->backend_path, key, + &local_err, fmt, ap); + va_end(ap); + + if (local_err) { + error_report_err(local_err); + } +} + +static void xen_device_backend_set_state(XenDevice *xendev, + enum xenbus_state state) +{ + const char *type = object_get_typename(OBJECT(xendev)); + + if (xendev->backend_state == state) { + return; + } + + trace_xen_device_backend_state(type, xendev->name, + xs_strstate(state)); + + xendev->backend_state = state; + xen_device_backend_printf(xendev, "state", "%u", state); +} + +static void xen_device_backend_create(XenDevice *xendev, Error **errp) +{ + XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); + struct xs_permissions perms[2]; + Error *local_err = NULL; + + xendev->backend_path = xen_device_get_backend_path(xendev); + + perms[0].id = xenbus->backend_id; + perms[0].perms = XS_PERM_NONE; + perms[1].id = xendev->frontend_id; + perms[1].perms = XS_PERM_READ; + + g_assert(xenbus->xsh); + + xs_node_create(xenbus->xsh, XBT_NULL, xendev->backend_path, perms, + ARRAY_SIZE(perms), &local_err); + if (local_err) { + error_propagate_prepend(errp, local_err, + "failed to create backend: "); + } +} + +static void xen_device_backend_destroy(XenDevice *xendev) +{ + XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); + Error *local_err = NULL; + + if (!xendev->backend_path) { + return; + } + + g_assert(xenbus->xsh); + + xs_node_destroy(xenbus->xsh, XBT_NULL, xendev->backend_path, + &local_err); + g_free(xendev->backend_path); + xendev->backend_path = NULL; + + if (local_err) { + error_report_err(local_err); + } +} + +static void xen_device_frontend_printf(XenDevice *xendev, const char *key, + const char *fmt, ...) +{ + XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); + Error *local_err = NULL; + va_list ap; + + g_assert(xenbus->xsh); + + va_start(ap, fmt); + xs_node_vprintf(xenbus->xsh, XBT_NULL, xendev->frontend_path, key, + &local_err, fmt, ap); + va_end(ap); + + if (local_err) { + error_report_err(local_err); + } +} + +static void xen_device_frontend_set_state(XenDevice *xendev, + enum xenbus_state state) +{ + const char *type = object_get_typename(OBJECT(xendev)); + + if (xendev->frontend_state == state) { + return; + } + + trace_xen_device_frontend_state(type, xendev->name, + xs_strstate(state)); + + xendev->frontend_state = state; + xen_device_frontend_printf(xendev, "state", "%u", state); +} + +static void xen_device_frontend_create(XenDevice *xendev, Error **errp) +{ + XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); + struct xs_permissions perms[2]; + Error *local_err = NULL; + + xendev->frontend_path = xen_device_get_frontend_path(xendev); + + perms[0].id = xendev->frontend_id; + perms[0].perms = XS_PERM_NONE; + perms[1].id = xenbus->backend_id; + perms[1].perms = XS_PERM_READ | XS_PERM_WRITE; + + g_assert(xenbus->xsh); + + xs_node_create(xenbus->xsh, XBT_NULL, xendev->frontend_path, perms, + ARRAY_SIZE(perms), &local_err); + if (local_err) { + error_propagate_prepend(errp, local_err, + "failed to create frontend: "); + } +} + +static void xen_device_frontend_destroy(XenDevice *xendev) +{ + XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); + Error *local_err = NULL; + + if (!xendev->frontend_path) { + return; + } + + g_assert(xenbus->xsh); + + xs_node_destroy(xenbus->xsh, XBT_NULL, xendev->frontend_path, + &local_err); + g_free(xendev->frontend_path); + xendev->frontend_path = NULL; + + if (local_err) { + error_report_err(local_err); + } +} + static void xen_device_unrealize(DeviceState *dev, Error **errp) { XenDevice *xendev = XEN_DEVICE(dev); XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev); const char *type = object_get_typename(OBJECT(xendev)); - trace_xen_device_unrealize(type); + if (!xendev->name) { + return; + } + + trace_xen_device_unrealize(type, xendev->name); + + if (xendev->exit.notify) { + qemu_remove_exit_notifier(&xendev->exit); + xendev->exit.notify = NULL; + } if (xendev_class->unrealize) { xendev_class->unrealize(xendev, errp); } + + xen_device_frontend_destroy(xendev); + xen_device_backend_destroy(xendev); + + g_free(xendev->name); + xendev->name = NULL; +} + +static void xen_device_exit(Notifier *n, void *data) +{ + XenDevice *xendev = container_of(n, XenDevice, exit); + + xen_device_unrealize(DEVICE(xendev), &error_abort); } static void xen_device_realize(DeviceState *dev, Error **errp) { XenDevice *xendev = XEN_DEVICE(dev); XenDeviceClass *xendev_class = XEN_DEVICE_GET_CLASS(xendev); + XenBus *xenbus = XEN_BUS(qdev_get_parent_bus(DEVICE(xendev))); const char *type = object_get_typename(OBJECT(xendev)); Error *local_err = NULL; - trace_xen_device_realize(type); + if (xendev->frontend_id == DOMID_INVALID) { + xendev->frontend_id = xen_domid; + } + + if (xendev->frontend_id >= DOMID_FIRST_RESERVED) { + error_setg(errp, "invalid frontend-id"); + goto unrealize; + } + + if (!xendev_class->get_name) { + error_setg(errp, "get_name method not implemented"); + goto unrealize; + } + + xendev->name = xendev_class->get_name(xendev, &local_err); + if (local_err) { + error_propagate_prepend(errp, local_err, + "failed to get device name: "); + goto unrealize; + } + + trace_xen_device_realize(type, xendev->name); + + xen_device_backend_create(xendev, &local_err); + if (local_err) { + error_propagate(errp, local_err); + goto unrealize; + } + + xen_device_frontend_create(xendev, &local_err); + if (local_err) { + error_propagate(errp, local_err); + goto unrealize; + } if (xendev_class->realize) { xendev_class->realize(xendev, &local_err); @@ -72,18 +364,43 @@ static void xen_device_realize(DeviceState *dev, Error **errp) } } + xen_device_backend_printf(xendev, "frontend", "%s", + xendev->frontend_path); + xen_device_backend_printf(xendev, "frontend-id", "%u", + xendev->frontend_id); + xen_device_backend_printf(xendev, "online", "%u", 1); + xen_device_backend_printf(xendev, "hotplug-status", "connected"); + + xen_device_backend_set_state(xendev, XenbusStateInitWait); + + xen_device_frontend_printf(xendev, "backend", "%s", + xendev->backend_path); + xen_device_frontend_printf(xendev, "backend-id", "%u", + xenbus->backend_id); + + xen_device_frontend_set_state(xendev, XenbusStateInitialising); + + xendev->exit.notify = xen_device_exit; + qemu_add_exit_notifier(&xendev->exit); return; unrealize: xen_device_unrealize(dev, &error_abort); } +static Property xen_device_props[] = { + DEFINE_PROP_UINT16("frontend-id", XenDevice, frontend_id, + DOMID_INVALID), + DEFINE_PROP_END_OF_LIST() +}; + static void xen_device_class_init(ObjectClass *class, void *data) { DeviceClass *dev_class = DEVICE_CLASS(class); dev_class->realize = xen_device_realize; dev_class->unrealize = xen_device_unrealize; + dev_class->props = xen_device_props; dev_class->bus_type = TYPE_XEN_BUS; } diff --git a/include/hw/xen/xen-bus-helper.h b/include/hw/xen/xen-bus-helper.h new file mode 100644 index 0000000..5cd9c3d --- /dev/null +++ b/include/hw/xen/xen-bus-helper.h @@ -0,0 +1,39 @@ +/* + * Copyright (c) 2018 Citrix Systems Inc. + * + * This work is licensed under the terms of the GNU GPL, version 2 or later. + * See the COPYING file in the top-level directory. + */ + +#ifndef HW_XEN_BUS_HELPER_H +#define HW_XEN_BUS_HELPER_H + +#include "hw/xen/xen_common.h" + +const char *xs_strstate(enum xenbus_state state); + +void xs_node_create(struct xs_handle *xsh, xs_transaction_t tid, + const char *node, struct xs_permissions perms[], + unsigned int nr_perms, Error **errp); +void xs_node_destroy(struct xs_handle *xsh, xs_transaction_t tid, + const char *node, Error **errp); + +/* Write to node/key unless node is empty, in which case write to key */ +void xs_node_vprintf(struct xs_handle *xsh, xs_transaction_t tid, + const char *node, const char *key, Error **errp, + const char *fmt, va_list ap) + GCC_FMT_ATTR(6, 0); +void xs_node_printf(struct xs_handle *xsh, xs_transaction_t tid, + const char *node, const char *key, Error **errp, + const char *fmt, ...) + GCC_FMT_ATTR(6, 7); + +/* Read from node/key unless node is empty, in which case read from key */ +int xs_node_vscanf(struct xs_handle *xsh, xs_transaction_t tid, + const char *node, const char *key, Error **errp, + const char *fmt, va_list ap); +int xs_node_scanf(struct xs_handle *xsh, xs_transaction_t tid, + const char *node, const char *key, Error **errp, + const char *fmt, ...); + +#endif /* HW_XEN_BUS_HELPER_H */ diff --git a/include/hw/xen/xen-bus.h b/include/hw/xen/xen-bus.h index 0cb1246..85a75d8 100644 --- a/include/hw/xen/xen-bus.h +++ b/include/hw/xen/xen-bus.h @@ -8,12 +8,19 @@ #ifndef HW_XEN_BUS_H #define HW_XEN_BUS_H +#include "hw/xen/xen_common.h" #include "hw/sysbus.h" typedef struct XenDevice { DeviceState qdev; + domid_t frontend_id; + char *name; + char *backend_path, *frontend_path; + enum xenbus_state backend_state, frontend_state; + Notifier exit; } XenDevice; +typedef char *(*XenDeviceGetName)(XenDevice *xendev, Error **errp); typedef void (*XenDeviceRealize)(XenDevice *xendev, Error **errp); typedef void (*XenDeviceUnrealize)(XenDevice *xendev, Error **errp); @@ -21,6 +28,9 @@ typedef struct XenDeviceClass { /*< private >*/ DeviceClass parent_class; /*< public >*/ + const char *backend; + const char *device; + XenDeviceGetName get_name; XenDeviceRealize realize; XenDeviceUnrealize unrealize; } XenDeviceClass; @@ -35,6 +45,8 @@ typedef struct XenDeviceClass { typedef struct XenBus { BusState qbus; + domid_t backend_id; + struct xs_handle *xsh; } XenBus; typedef struct XenBusClass { -- 2.1.4