From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 1CB56C3A59F for ; Thu, 29 Aug 2019 08:58:48 +0000 (UTC) Received: from lists.xenproject.org (lists.xenproject.org [192.237.175.120]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id E9B04215EA for ; Thu, 29 Aug 2019 08:58:47 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org E9B04215EA Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=xen-devel-bounces@lists.xenproject.org Received: from localhost ([127.0.0.1] helo=lists.xenproject.org) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1i3GGE-000496-40; Thu, 29 Aug 2019 08:58:30 +0000 Received: from all-amaz-eas1.inumbo.com ([34.197.232.57] helo=us1-amaz-eas2.inumbo.com) by lists.xenproject.org with esmtp (Exim 4.89) (envelope-from ) id 1i3GGC-000491-Tf for xen-devel@lists.xenproject.org; Thu, 29 Aug 2019 08:58:28 +0000 X-Inumbo-ID: 29db32be-ca3b-11e9-ae62-12813bfff9fa Received: from mga05.intel.com (unknown [192.55.52.43]) by us1-amaz-eas2.inumbo.com (Halon) with ESMTPS id 29db32be-ca3b-11e9-ae62-12813bfff9fa; Thu, 29 Aug 2019 08:58:27 +0000 (UTC) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga006.fm.intel.com ([10.253.24.20]) by fmsmga105.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 29 Aug 2019 01:58:26 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.64,442,1559545200"; d="scan'208";a="381572329" Received: from gao-cwp.sh.intel.com ([10.239.159.26]) by fmsmga006.fm.intel.com with ESMTP; 29 Aug 2019 01:58:24 -0700 From: Chao Gao To: xen-devel@lists.xenproject.org, qemu-devel@nongnu.org Date: Thu, 29 Aug 2019 17:02:27 +0800 Message-Id: <1567069347-22841-1-git-send-email-chao.gao@intel.com> X-Mailer: git-send-email 1.9.1 Subject: [Xen-devel] [RFC Patch] xen/pt: Emulate FLR capability X-BeenThere: xen-devel@lists.xenproject.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Xen developer discussion List-Unsubscribe: , List-Post: List-Help: List-Subscribe: , Cc: Stefano Stabellini , Paul Durrant , Jan Beulich , Anthony Perard , Chao Gao , =?UTF-8?q?Roger=20Pau=20Monn=C3=A9?= MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: xen-devel-bounces@lists.xenproject.org Sender: "Xen-devel" Q3VycmVudGx5LCBmb3IgYSBIVk0gb24gWGVuLCBubyByZXNldCBtZXRob2QgaXMgdmlydHVhbGl6 ZWQuIFNvIGluIGEgVk0ncwpwZXJzcGVjdGl2ZSwgYXNzaWduZWQgZGV2aWNlcyBjYW5ub3QgYmUg cmVzZXQuIEJ1dCBzb21lIGRldmljZXMgcmVseSBvbiBQQ0kKcmVzZXQgdG8gcmVjb3ZlciBmcm9t IGhhcmR3YXJlIGhhbmdzLiBXaGVuIGJlaW5nIGFzc2lnbmVkIHRvIGEgVk0sIHRob3NlCmRldmlj ZXMgY2Fubm90IGJlIHJlc2V0IGFuZCB3b24ndCB3b3JrIGFueSBsb25nZXIgaWYgYSBoYXJkd2Fy ZSBoYW5nIG9jY3Vycy4KV2UgaGF2ZSB0byByZWJvb3QgVk0gdG8gdHJpZ2dlciBQQ0kgcmVzZXQg b24gaG9zdCB0byByZWNvdmVyIHRoZSBkZXZpY2UuCgpUaGlzIHBhdGNoIGV4cG9zZXMgRkxSIGNh cGFiaWxpdHkgdG8gVk1zIGlmIHRoZSBhc3NpZ25lZCBkZXZpY2UgY2FuIGJlIHJlc2V0IG9uCmhv c3QuIFdoZW4gVk0gaW5pdGlhdGVzIGFuIEZMUiB0byBhIGRldmljZSwgcWVtdSBjbGVhbnMgdXAg dGhlIGRldmljZSBzdGF0ZSwKKGluY2x1ZGluZyBkaXNhYmxpbmcgb2YgaW50eCBhbmQvb3IgTVNJ IGFuZCB1bm1hcHBpbmcgQkFScyBmcm9tIGd1ZXN0LCBkZWxldGluZwplbXVsYXRlZCByZWdpc3Rl cnMpLCB0aGVuIGluaXRpYXRlIFBDSSByZXNldCB0aHJvdWdoICdyZXNldCcga25vYiB1bmRlciB0 aGUKZGV2aWNlJ3Mgc3lzZnMsIGZpbmFsbHkgaW5pdGlhbGl6ZSB0aGUgZGV2aWNlIGFnYWluLgoK U2lnbmVkLW9mZi1ieTogQ2hhbyBHYW8gPGNoYW8uZ2FvQGludGVsLmNvbT4KLS0tCkRvIHdlIG5l ZWQgdG8gaW50cm9kdWNlIGFuIGF0dHJpYnV0ZSwgbGlrZSAicGVybWlzc2l2ZSIgdG8gZXhwbGlj aXRseQplbmFibGUgRkxSIGNhcGFiaWxpdHkgZW11bGF0aW9uPyBEdXJpbmcgUENJIHJlc2V0LCBp bnRlcnJ1cHRzIGFuZCBCQVJzIGFyZQp1bm1hcHBlZCBmcm9tIHRoZSBndWVzdC4gSXQgc2VlbXMg dGhhdCBndWVzdCBjYW5ub3QgaW50ZXJhY3Qgd2l0aCB0aGUgZGV2aWNlCmRpcmVjdGx5IGV4Y2Vw dCBhY2Nlc3MgdG8gZGV2aWNlJ3MgY29uZmlndXJhdGlvbiBzcGFjZSB3aGljaCBpcyBlbXVsYXRl ZCBieQpxZW11LiBJZiBwcm9wZXIgbWV0aG9kIGNhbiBiZSB1c2VkIHRvIHByZXZlbnQgcWVtdSBh Y2Nlc3NpbmcgdGhlIHBoeXNpY2FsCmRldmljZSB0aGVyZSBpcyBubyBuZXcgc2VjdXJpdHkgaG9s ZSBjYXVzZWQgYnkgdGhlIEZMUiBlbXVsYXRpb24uCgpWTSdzIEZMUiBtYXkgYmUgYmFja2VkIGJ5 IGFueSByZXNldCBmdW5jdGlvbiBvbiBob3N0IHRvIHRoZSBwaHlzaWNhbCBkZXZpY2UsCmZvciBl eGFtcGxlOiBGTFIsIEQzc29mdHJlc2V0LCBzZWNvbmRhcnkgYnVzIHJlc2V0LiBOb3Qgc3VyZSBp dCBpcyBmaW5lIHRvIG1peAp0aGVtLiBHaXZlbiBMaW51eCBrZXJuZWwganVzdCB1c2VzIGFuIHVu aWZpZWQgQVBJIHRvIHJlc2V0IGRldmljZSBhbmQgY2FsbGVyCmNhbm5vdCBjaG9vc2UgYSBzcGVj aWZpYyBvbmUsIGl0IG1pZ2h0IGJlIE9LLgotLS0KIGh3L3hlbi94ZW4taG9zdC1wY2ktZGV2aWNl LmMgfCAzMCArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysKIGh3L3hlbi94ZW4taG9zdC1w Y2ktZGV2aWNlLmggfCAgMyArKysKIGh3L3hlbi94ZW5fcHQuYyAgICAgICAgICAgICAgfCAgOSAr KysrKysrKysKIGh3L3hlbi94ZW5fcHQuaCAgICAgICAgICAgICAgfCAgMSArCiBody94ZW4veGVu X3B0X2NvbmZpZ19pbml0LmMgIHwgMzAgKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0tCiA1 IGZpbGVzIGNoYW5nZWQsIDcwIGluc2VydGlvbnMoKyksIDMgZGVsZXRpb25zKC0pCgpkaWZmIC0t Z2l0IGEvaHcveGVuL3hlbi1ob3N0LXBjaS1kZXZpY2UuYyBiL2h3L3hlbi94ZW4taG9zdC1wY2kt ZGV2aWNlLmMKaW5kZXggMWI0NGRjYWZhZi4uZDU0OTY1NmY0MiAxMDA2NDQKLS0tIGEvaHcveGVu L3hlbi1ob3N0LXBjaS1kZXZpY2UuYworKysgYi9ody94ZW4veGVuLWhvc3QtcGNpLWRldmljZS5j CkBAIC0xOTgsNiArMTk4LDM1IEBAIHN0YXRpYyBib29sIHhlbl9ob3N0X3BjaV9kZXZfaXNfdmly dGZuKFhlbkhvc3RQQ0lEZXZpY2UgKmQpCiAgICAgcmV0dXJuICFzdGF0KHBhdGgsICZidWYpOwog fQogCitzdGF0aWMgYm9vbCB4ZW5faG9zdF9wY2lfcmVzZXRhYmxlKFhlbkhvc3RQQ0lEZXZpY2Ug KmQpCit7CisgICAgY2hhciBwYXRoW1BBVEhfTUFYXTsKKworICAgIHhlbl9ob3N0X3BjaV9zeXNm c19wYXRoKGQsICJyZXNldCIsIHBhdGgsIHNpemVvZihwYXRoKSk7CisKKyAgICByZXR1cm4gIWFj Y2VzcyhwYXRoLCBXX09LKTsKK30KKwordm9pZCB4ZW5faG9zdF9wY2lfcmVzZXQoWGVuSG9zdFBD SURldmljZSAqZCkKK3sKKyAgICBjaGFyIHBhdGhbUEFUSF9NQVhdOworICAgIGludCBmZDsKKwor ICAgIHhlbl9ob3N0X3BjaV9zeXNmc19wYXRoKGQsICJyZXNldCIsIHBhdGgsIHNpemVvZihwYXRo KSk7CisKKyAgICBmZCA9IG9wZW4ocGF0aCwgT19XUk9OTFkpOworICAgIGlmIChmZCA9PSAtMSkg eworICAgICAgICBYRU5fSE9TVF9QQ0lfTE9HKCJYZW4gaG9zdCBwY2kgcmVzZXQ6IG9wZW4gZXJy b3JcbiIpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgaWYgKHdyaXRlKGZkLCAiMSIs IDEpICE9IDEpIHsKKyAgICAgICAgWEVOX0hPU1RfUENJX0xPRygiWGVuIGhvc3QgcGNpIHJlc2V0 OiB3cml0ZSBlcnJvclxuIik7CisgICAgfQorCisgICAgcmV0dXJuOworfQorCiBzdGF0aWMgdm9p ZCB4ZW5faG9zdF9wY2lfY29uZmlnX29wZW4oWGVuSG9zdFBDSURldmljZSAqZCwgRXJyb3IgKipl cnJwKQogewogICAgIGNoYXIgcGF0aFtQQVRIX01BWF07CkBAIC0zNzcsNiArNDA2LDcgQEAgdm9p ZCB4ZW5faG9zdF9wY2lfZGV2aWNlX2dldChYZW5Ib3N0UENJRGV2aWNlICpkLCB1aW50MTZfdCBk b21haW4sCiAgICAgZC0+Y2xhc3NfY29kZSA9IHY7CiAKICAgICBkLT5pc192aXJ0Zm4gPSB4ZW5f aG9zdF9wY2lfZGV2X2lzX3ZpcnRmbihkKTsKKyAgICBkLT5pc19yZXNldGFibGUgPSB4ZW5faG9z dF9wY2lfcmVzZXRhYmxlKGQpOwogCiAgICAgcmV0dXJuOwogCmRpZmYgLS1naXQgYS9ody94ZW4v eGVuLWhvc3QtcGNpLWRldmljZS5oIGIvaHcveGVuL3hlbi1ob3N0LXBjaS1kZXZpY2UuaAppbmRl eCA0ZDhkMzRlY2IwLi5jYWNmOWIzZGY4IDEwMDY0NAotLS0gYS9ody94ZW4veGVuLWhvc3QtcGNp LWRldmljZS5oCisrKyBiL2h3L3hlbi94ZW4taG9zdC1wY2ktZGV2aWNlLmgKQEAgLTMyLDYgKzMy LDcgQEAgdHlwZWRlZiBzdHJ1Y3QgWGVuSG9zdFBDSURldmljZSB7CiAgICAgWGVuSG9zdFBDSUlP UmVnaW9uIHJvbTsKIAogICAgIGJvb2wgaXNfdmlydGZuOworICAgIGJvb2wgaXNfcmVzZXRhYmxl OwogCiAgICAgaW50IGNvbmZpZ19mZDsKIH0gWGVuSG9zdFBDSURldmljZTsKQEAgLTU1LDQgKzU2 LDYgQEAgaW50IHhlbl9ob3N0X3BjaV9zZXRfYmxvY2soWGVuSG9zdFBDSURldmljZSAqZCwgaW50 IHBvcywgdWludDhfdCAqYnVmLAogCiBpbnQgeGVuX2hvc3RfcGNpX2ZpbmRfZXh0X2NhcF9vZmZz ZXQoWGVuSG9zdFBDSURldmljZSAqcywgdWludDMyX3QgY2FwKTsKIAordm9pZCB4ZW5faG9zdF9w Y2lfcmVzZXQoWGVuSG9zdFBDSURldmljZSAqZCk7CisKICNlbmRpZiAvKiBYRU5fSE9TVF9QQ0lf REVWSUNFX0ggKi8KZGlmZiAtLWdpdCBhL2h3L3hlbi94ZW5fcHQuYyBiL2h3L3hlbi94ZW5fcHQu YwppbmRleCA4ZmJhZjJlYWU5Li5kNzUwMzY3YzBhIDEwMDY0NAotLS0gYS9ody94ZW4veGVuX3B0 LmMKKysrIGIvaHcveGVuL3hlbl9wdC5jCkBAIC05MzgsNiArOTM4LDE1IEBAIHN0YXRpYyB2b2lk IHhlbl9wdF91bnJlZ2lzdGVyX2RldmljZShQQ0lEZXZpY2UgKmQpCiAgICAgeGVuX3B0X2Rlc3Ry b3koZCk7CiB9CiAKK3ZvaWQgeGVuX3B0X3Jlc2V0KFhlblBDSVBhc3N0aHJvdWdoU3RhdGUgKnMp Cit7CisgICAgUENJRGV2aWNlICpkID0gUENJX0RFVklDRShzKTsKKworICAgIHhlbl9wdF91bnJl Z2lzdGVyX2RldmljZShkKTsKKyAgICB4ZW5faG9zdF9wY2lfcmVzZXQoJnMtPnJlYWxfZGV2aWNl KTsKKyAgICB4ZW5fcHRfcmVhbGl6ZShkLCBOVUxMKTsKK30KKwogc3RhdGljIFByb3BlcnR5IHhl bl9wY2lfcGFzc3Rocm91Z2hfcHJvcGVydGllc1tdID0gewogICAgIERFRklORV9QUk9QX1BDSV9I T1NUX0RFVkFERFIoImhvc3RhZGRyIiwgWGVuUENJUGFzc3Rocm91Z2hTdGF0ZSwgaG9zdGFkZHIp LAogICAgIERFRklORV9QUk9QX0JPT0woInBlcm1pc3NpdmUiLCBYZW5QQ0lQYXNzdGhyb3VnaFN0 YXRlLCBwZXJtaXNzaXZlLCBmYWxzZSksCmRpZmYgLS1naXQgYS9ody94ZW4veGVuX3B0LmggYi9o dy94ZW4veGVuX3B0LmgKaW5kZXggOTE2N2JiYWY2ZC4uZWQwNWJjMGQzOSAxMDA2NDQKLS0tIGEv aHcveGVuL3hlbl9wdC5oCisrKyBiL2h3L3hlbi94ZW5fcHQuaApAQCAtMzMyLDQgKzMzMiw1IEBA IGludCB4ZW5fcHRfcmVnaXN0ZXJfdmdhX3JlZ2lvbnMoWGVuSG9zdFBDSURldmljZSAqZGV2KTsK IGludCB4ZW5fcHRfdW5yZWdpc3Rlcl92Z2FfcmVnaW9ucyhYZW5Ib3N0UENJRGV2aWNlICpkZXYp Owogdm9pZCB4ZW5fcHRfc2V0dXBfdmdhKFhlblBDSVBhc3N0aHJvdWdoU3RhdGUgKnMsIFhlbkhv c3RQQ0lEZXZpY2UgKmRldiwKICAgICAgICAgICAgICAgICAgICAgIEVycm9yICoqZXJycCk7Cit2 b2lkIHhlbl9wdF9yZXNldChYZW5QQ0lQYXNzdGhyb3VnaFN0YXRlICpzKTsKICNlbmRpZiAvKiBY RU5fUFRfSCAqLwpkaWZmIC0tZ2l0IGEvaHcveGVuL3hlbl9wdF9jb25maWdfaW5pdC5jIGIvaHcv eGVuL3hlbl9wdF9jb25maWdfaW5pdC5jCmluZGV4IDMxZWM1YWRkMWQuLjQzNWFiZDcyODYgMTAw NjQ0Ci0tLSBhL2h3L3hlbi94ZW5fcHRfY29uZmlnX2luaXQuYworKysgYi9ody94ZW4veGVuX3B0 X2NvbmZpZ19pbml0LmMKQEAgLTg1Miw2ICs4NTIsMzAgQEAgc3RhdGljIGlubGluZSB1aW50OF90 IGdldF9kZXZpY2VfdHlwZShYZW5QQ0lQYXNzdGhyb3VnaFN0YXRlICpzLAogICAgIHJldHVybiAo ZmxhZyAmIFBDSV9FWFBfRkxBR1NfVFlQRSkgPj4gNDsKIH0KIAorLyogSW5pdGlhbGl6ZSBEZXZp Y2UgQ2FwYWJpbGl0eSByZWdpc3RlciAqLworc3RhdGljIGludCB4ZW5fcHRfZGV2Y2FwX3JlZ19p bml0KFhlblBDSVBhc3N0aHJvdWdoU3RhdGUgKnMsCisgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgWGVuUFRSZWdJbmZvICpyZWcsIHVpbnQzMl90IHJlYWxfb2Zmc2V0LAorICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgIHVpbnQzMl90ICpkYXRhKQoreworICAgICpkYXRh ID0gcmVnLT5pbml0X3ZhbDsKKworICAgIGlmIChzLT5yZWFsX2RldmljZS5pc19yZXNldGFibGUp IHsKKyAgICAgICAgKmRhdGEgfD0gUENJX0VYUF9ERVZDQVBfRkxSOworICAgIH0KKworICAgIHJl dHVybiAwOworfQorCitzdGF0aWMgaW50IHhlbl9wdF9kZXZjdGxfcmVnX3dyaXRlKFhlblBDSVBh c3N0aHJvdWdoU3RhdGUgKnMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFhl blBUUmVnICpjZmdfZW50cnksIHVpbnQxNl90ICp2YWwsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHVpbnQxNl90IGRldl92YWx1ZSwgdWludDE2X3QgdmFsaWRfbWFzaykKK3sK KyAgICBpZiAocy0+cmVhbF9kZXZpY2UuaXNfcmVzZXRhYmxlICYmICgqdmFsICYgUENJX0VYUF9E RVZDVExfQkNSX0ZMUikpIHsKKyAgICAgICAgeGVuX3B0X3Jlc2V0KHMpOworICAgIH0KKyAgICBy ZXR1cm4geGVuX3B0X3dvcmRfcmVnX3dyaXRlKHMsIGNmZ19lbnRyeSwgdmFsLCBkZXZfdmFsdWUs IHZhbGlkX21hc2spOworfQorCiAvKiBpbml0aWFsaXplIExpbmsgQ29udHJvbCByZWdpc3RlciAq Lwogc3RhdGljIGludCB4ZW5fcHRfbGlua2N0cmxfcmVnX2luaXQoWGVuUENJUGFzc3Rocm91Z2hT dGF0ZSAqcywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFhlblBUUmVnSW5m byAqcmVnLCB1aW50MzJfdCByZWFsX29mZnNldCwKQEAgLTkzMyw3ICs5NTcsNyBAQCBzdGF0aWMg WGVuUFRSZWdJbmZvIHhlbl9wdF9lbXVfcmVnX3BjaWVbXSA9IHsKICAgICAgICAgLmluaXRfdmFs ICAgPSAweDAwMDAwMDAwLAogICAgICAgICAucm9fbWFzayAgICA9IDB4RkZGRkZGRkYsCiAgICAg ICAgIC5lbXVfbWFzayAgID0gMHgxMDAwMDAwMCwKLSAgICAgICAgLmluaXQgICAgICAgPSB4ZW5f cHRfY29tbW9uX3JlZ19pbml0LAorICAgICAgICAuaW5pdCAgICAgICA9IHhlbl9wdF9kZXZjYXBf cmVnX2luaXQsCiAgICAgICAgIC51LmR3LnJlYWQgID0geGVuX3B0X2xvbmdfcmVnX3JlYWQsCiAg ICAgICAgIC51LmR3LndyaXRlID0geGVuX3B0X2xvbmdfcmVnX3dyaXRlLAogICAgIH0sCkBAIC05 NDYsNyArOTcwLDcgQEAgc3RhdGljIFhlblBUUmVnSW5mbyB4ZW5fcHRfZW11X3JlZ19wY2llW10g PSB7CiAgICAgICAgIC5lbXVfbWFzayAgID0gMHhGRkZGLAogICAgICAgICAuaW5pdCAgICAgICA9 IHhlbl9wdF9jb21tb25fcmVnX2luaXQsCiAgICAgICAgIC51LncucmVhZCAgID0geGVuX3B0X3dv cmRfcmVnX3JlYWQsCi0gICAgICAgIC51Lncud3JpdGUgID0geGVuX3B0X3dvcmRfcmVnX3dyaXRl LAorICAgICAgICAudS53LndyaXRlICA9IHhlbl9wdF9kZXZjdGxfcmVnX3dyaXRlLAogICAgIH0s CiAgICAgLyogRGV2aWNlIFN0YXR1cyByZWcgKi8KICAgICB7CkBAIC0xOTY5LDcgKzE5OTMsNyBA QCBzdGF0aWMgdm9pZCB4ZW5fcHRfY29uZmlnX3JlZ19pbml0KFhlblBDSVBhc3N0aHJvdWdoU3Rh dGUgKnMsCiAgICAgICAgICAgICAvKiBNYXNrIG91dCBob3N0IChpbmNsdWRpbmcgcGFzdCBzaXpl KS4gKi8KICAgICAgICAgICAgIG5ld192YWwgPSB2YWwgJiBob3N0X21hc2s7CiAgICAgICAgICAg ICAvKiBNZXJnZSBlbXVsYXRlZCBvbmVzIChleGNsdWRpbmcgdGhlIG5vbi1lbXVsYXRlZCBvbmVz KS4gKi8KLSAgICAgICAgICAgIG5ld192YWwgfD0gZGF0YSAmIGhvc3RfbWFzazsKKyAgICAgICAg ICAgIG5ld192YWwgfD0gZGF0YSAmIH5ob3N0X21hc2s7CiAgICAgICAgICAgICAvKiBMZWF2ZSBp bnRhY3QgaG9zdCBhbmQgZW11bGF0ZWQgdmFsdWVzIHBhc3QgdGhlIHNpemUgLSBldmVuIHRob3Vn aAogICAgICAgICAgICAgICogd2UgZG8gbm90IGNhcmUgYXMgd2Ugd3JpdGUgcGVyIHJlZy0+c2l6 ZSBncmFudWxhcml0eSwgYnV0IGZvciB0aGUKICAgICAgICAgICAgICAqIGxvZ2dpbmcgYmVsb3cg bGV0cyBoYXZlIHRoZSBwcm9wZXIgdmFsdWUuICovCi0tIAoyLjE3LjEKCgpfX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwgbWFpbGluZyBsaXN0 Clhlbi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9yZwpodHRwczovL2xpc3RzLnhlbnByb2plY3Qu b3JnL21haWxtYW4vbGlzdGluZm8veGVuLWRldmVs From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-9.8 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id BAE4EC3A59F for ; Thu, 29 Aug 2019 08:59:25 +0000 (UTC) Received: from lists.gnu.org (lists.gnu.org [209.51.188.17]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 9109C215EA for ; Thu, 29 Aug 2019 08:59:25 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 9109C215EA Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=intel.com Authentication-Results: mail.kernel.org; spf=pass smtp.mailfrom=qemu-devel-bounces+qemu-devel=archiver.kernel.org@nongnu.org Received: from localhost ([::1]:47014 helo=lists1p.gnu.org) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1i3GH6-00012E-Nv for qemu-devel@archiver.kernel.org; Thu, 29 Aug 2019 04:59:24 -0400 Received: from eggs.gnu.org ([2001:470:142:3::10]:60781) by lists.gnu.org with esmtp (Exim 4.90_1) (envelope-from ) id 1i3GGH-0000aL-8d for qemu-devel@nongnu.org; Thu, 29 Aug 2019 04:58:34 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1i3GGE-0006ld-SW for qemu-devel@nongnu.org; Thu, 29 Aug 2019 04:58:32 -0400 Received: from mga09.intel.com ([134.134.136.24]:11741) by eggs.gnu.org with esmtps (TLS1.0:DHE_RSA_AES_256_CBC_SHA1:32) (Exim 4.71) (envelope-from ) id 1i3GGE-0006k0-JD for qemu-devel@nongnu.org; Thu, 29 Aug 2019 04:58:30 -0400 X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from fmsmga006.fm.intel.com ([10.253.24.20]) by orsmga102.jf.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 29 Aug 2019 01:58:26 -0700 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.64,442,1559545200"; d="scan'208";a="381572329" Received: from gao-cwp.sh.intel.com ([10.239.159.26]) by fmsmga006.fm.intel.com with ESMTP; 29 Aug 2019 01:58:24 -0700 From: Chao Gao To: xen-devel@lists.xenproject.org, qemu-devel@nongnu.org Date: Thu, 29 Aug 2019 17:02:27 +0800 Message-Id: <1567069347-22841-1-git-send-email-chao.gao@intel.com> X-Mailer: git-send-email 1.9.1 X-detected-operating-system: by eggs.gnu.org: Genre and OS details not recognized. X-Received-From: 134.134.136.24 Subject: [Qemu-devel] [RFC Patch] xen/pt: Emulate FLR capability X-BeenThere: qemu-devel@nongnu.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Stefano Stabellini , Paul Durrant , Jan Beulich , Anthony Perard , Chao Gao , =?UTF-8?q?Roger=20Pau=20Monn=C3=A9?= Errors-To: qemu-devel-bounces+qemu-devel=archiver.kernel.org@nongnu.org Sender: "Qemu-devel" Currently, for a HVM on Xen, no reset method is virtualized. So in a VM's perspective, assigned devices cannot be reset. But some devices rely on PCI reset to recover from hardware hangs. When being assigned to a VM, those devices cannot be reset and won't work any longer if a hardware hang occurs. We have to reboot VM to trigger PCI reset on host to recover the device. This patch exposes FLR capability to VMs if the assigned device can be reset on host. When VM initiates an FLR to a device, qemu cleans up the device state, (including disabling of intx and/or MSI and unmapping BARs from guest, deleting emulated registers), then initiate PCI reset through 'reset' knob under the device's sysfs, finally initialize the device again. Signed-off-by: Chao Gao --- Do we need to introduce an attribute, like "permissive" to explicitly enable FLR capability emulation? During PCI reset, interrupts and BARs are unmapped from the guest. It seems that guest cannot interact with the device directly except access to device's configuration space which is emulated by qemu. If proper method can be used to prevent qemu accessing the physical device there is no new security hole caused by the FLR emulation. VM's FLR may be backed by any reset function on host to the physical device, for example: FLR, D3softreset, secondary bus reset. Not sure it is fine to mix them. Given Linux kernel just uses an unified API to reset device and caller cannot choose a specific one, it might be OK. --- hw/xen/xen-host-pci-device.c | 30 ++++++++++++++++++++++++++++++ hw/xen/xen-host-pci-device.h | 3 +++ hw/xen/xen_pt.c | 9 +++++++++ hw/xen/xen_pt.h | 1 + hw/xen/xen_pt_config_init.c | 30 +++++++++++++++++++++++++++--- 5 files changed, 70 insertions(+), 3 deletions(-) diff --git a/hw/xen/xen-host-pci-device.c b/hw/xen/xen-host-pci-device.c index 1b44dcafaf..d549656f42 100644 --- a/hw/xen/xen-host-pci-device.c +++ b/hw/xen/xen-host-pci-device.c @@ -198,6 +198,35 @@ static bool xen_host_pci_dev_is_virtfn(XenHostPCIDevice *d) return !stat(path, &buf); } +static bool xen_host_pci_resetable(XenHostPCIDevice *d) +{ + char path[PATH_MAX]; + + xen_host_pci_sysfs_path(d, "reset", path, sizeof(path)); + + return !access(path, W_OK); +} + +void xen_host_pci_reset(XenHostPCIDevice *d) +{ + char path[PATH_MAX]; + int fd; + + xen_host_pci_sysfs_path(d, "reset", path, sizeof(path)); + + fd = open(path, O_WRONLY); + if (fd == -1) { + XEN_HOST_PCI_LOG("Xen host pci reset: open error\n"); + return; + } + + if (write(fd, "1", 1) != 1) { + XEN_HOST_PCI_LOG("Xen host pci reset: write error\n"); + } + + return; +} + static void xen_host_pci_config_open(XenHostPCIDevice *d, Error **errp) { char path[PATH_MAX]; @@ -377,6 +406,7 @@ void xen_host_pci_device_get(XenHostPCIDevice *d, uint16_t domain, d->class_code = v; d->is_virtfn = xen_host_pci_dev_is_virtfn(d); + d->is_resetable = xen_host_pci_resetable(d); return; diff --git a/hw/xen/xen-host-pci-device.h b/hw/xen/xen-host-pci-device.h index 4d8d34ecb0..cacf9b3df8 100644 --- a/hw/xen/xen-host-pci-device.h +++ b/hw/xen/xen-host-pci-device.h @@ -32,6 +32,7 @@ typedef struct XenHostPCIDevice { XenHostPCIIORegion rom; bool is_virtfn; + bool is_resetable; int config_fd; } XenHostPCIDevice; @@ -55,4 +56,6 @@ int xen_host_pci_set_block(XenHostPCIDevice *d, int pos, uint8_t *buf, int xen_host_pci_find_ext_cap_offset(XenHostPCIDevice *s, uint32_t cap); +void xen_host_pci_reset(XenHostPCIDevice *d); + #endif /* XEN_HOST_PCI_DEVICE_H */ diff --git a/hw/xen/xen_pt.c b/hw/xen/xen_pt.c index 8fbaf2eae9..d750367c0a 100644 --- a/hw/xen/xen_pt.c +++ b/hw/xen/xen_pt.c @@ -938,6 +938,15 @@ static void xen_pt_unregister_device(PCIDevice *d) xen_pt_destroy(d); } +void xen_pt_reset(XenPCIPassthroughState *s) +{ + PCIDevice *d = PCI_DEVICE(s); + + xen_pt_unregister_device(d); + xen_host_pci_reset(&s->real_device); + xen_pt_realize(d, NULL); +} + static Property xen_pci_passthrough_properties[] = { DEFINE_PROP_PCI_HOST_DEVADDR("hostaddr", XenPCIPassthroughState, hostaddr), DEFINE_PROP_BOOL("permissive", XenPCIPassthroughState, permissive, false), diff --git a/hw/xen/xen_pt.h b/hw/xen/xen_pt.h index 9167bbaf6d..ed05bc0d39 100644 --- a/hw/xen/xen_pt.h +++ b/hw/xen/xen_pt.h @@ -332,4 +332,5 @@ int xen_pt_register_vga_regions(XenHostPCIDevice *dev); int xen_pt_unregister_vga_regions(XenHostPCIDevice *dev); void xen_pt_setup_vga(XenPCIPassthroughState *s, XenHostPCIDevice *dev, Error **errp); +void xen_pt_reset(XenPCIPassthroughState *s); #endif /* XEN_PT_H */ diff --git a/hw/xen/xen_pt_config_init.c b/hw/xen/xen_pt_config_init.c index 31ec5add1d..435abd7286 100644 --- a/hw/xen/xen_pt_config_init.c +++ b/hw/xen/xen_pt_config_init.c @@ -852,6 +852,30 @@ static inline uint8_t get_device_type(XenPCIPassthroughState *s, return (flag & PCI_EXP_FLAGS_TYPE) >> 4; } +/* Initialize Device Capability register */ +static int xen_pt_devcap_reg_init(XenPCIPassthroughState *s, + XenPTRegInfo *reg, uint32_t real_offset, + uint32_t *data) +{ + *data = reg->init_val; + + if (s->real_device.is_resetable) { + *data |= PCI_EXP_DEVCAP_FLR; + } + + return 0; +} + +static int xen_pt_devctl_reg_write(XenPCIPassthroughState *s, + XenPTReg *cfg_entry, uint16_t *val, + uint16_t dev_value, uint16_t valid_mask) +{ + if (s->real_device.is_resetable && (*val & PCI_EXP_DEVCTL_BCR_FLR)) { + xen_pt_reset(s); + } + return xen_pt_word_reg_write(s, cfg_entry, val, dev_value, valid_mask); +} + /* initialize Link Control register */ static int xen_pt_linkctrl_reg_init(XenPCIPassthroughState *s, XenPTRegInfo *reg, uint32_t real_offset, @@ -933,7 +957,7 @@ static XenPTRegInfo xen_pt_emu_reg_pcie[] = { .init_val = 0x00000000, .ro_mask = 0xFFFFFFFF, .emu_mask = 0x10000000, - .init = xen_pt_common_reg_init, + .init = xen_pt_devcap_reg_init, .u.dw.read = xen_pt_long_reg_read, .u.dw.write = xen_pt_long_reg_write, }, @@ -946,7 +970,7 @@ static XenPTRegInfo xen_pt_emu_reg_pcie[] = { .emu_mask = 0xFFFF, .init = xen_pt_common_reg_init, .u.w.read = xen_pt_word_reg_read, - .u.w.write = xen_pt_word_reg_write, + .u.w.write = xen_pt_devctl_reg_write, }, /* Device Status reg */ { @@ -1969,7 +1993,7 @@ static void xen_pt_config_reg_init(XenPCIPassthroughState *s, /* Mask out host (including past size). */ new_val = val & host_mask; /* Merge emulated ones (excluding the non-emulated ones). */ - new_val |= data & host_mask; + new_val |= data & ~host_mask; /* Leave intact host and emulated values past the size - even though * we do not care as we write per reg->size granularity, but for the * logging below lets have the proper value. */ -- 2.17.1