From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alexey G Subject: Re: [Qemu-devel] [PATCH] xen-hvm: stop faking I/O to access PCI config space Date: Thu, 3 May 2018 22:41:28 +1000 Message-ID: <20180503224128.00005cf7@gmail.com> References: <1525346320-24553-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 1fEDYN-0002jd-Mi for xen-devel@lists.xenproject.org; Thu, 03 May 2018 12:41:43 +0000 Received: by mail-lf0-x244.google.com with SMTP id o123-v6so25729104lfe.8 for ; Thu, 03 May 2018 05:41:41 -0700 (PDT) In-Reply-To: <1525346320-24553-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: Paul Durrant Cc: Stefano Stabellini , Eduardo Habkost , "Michael S. Tsirkin" , qemu-devel@nongnu.org, Anthony Perard , Paolo Bonzini , Marcel Apfelbaum , xen-devel@lists.xenproject.org, Richard Henderson List-Id: xen-devel@lists.xenproject.org T24gVGh1LCAzIE1heSAyMDE4IDEyOjE4OjQwICswMTAwClBhdWwgRHVycmFudCA8cGF1bC5kdXJy YW50QGNpdHJpeC5jb20+IHdyb3RlOgoKPlRoaXMgcGF0Y2ggcmVtb3ZlcyB0aGUgY3VycmVudCBo YWNrZXJ5IHdoZXJlIElPUkVRX1RZUEVfUENJX0NPTkZJRwo+cmVxeWVzdHMgYXJlIGhhbmRsZWQg YnkgZmFraW5nIFBJTyB0byAweGNmOCBhbmQgMHhjZmMgYW5kIHJlcGxhY2VzIGl0Cj53aXRoIGRp cmVjdCBjYWxscyB0byBwY2lfaG9zdF9jb25maWdfcmVhZC93cml0ZV9jb21tb24oKS4KPkRvaW5n IHNvIG5lY2Vzc2l0YXRlcyBtYXBwaW5nIEJERnMgdG8gUENJRGV2aWNlcyBidXQgbWFpbnRhaW5p bmcgYQo+c2ltcGxlIFFMSVNUIGluIHhlbl9kZXZpY2VfcmVhbGl6ZS91bnJlYWxpemUoKSB3aWxs IHN1ZmZpY2UuCj4KPk5PVEU6IHdoaWxzdCBjb25maWcgc3BhY2UgYWNjZXNzZXMgYXJlIGN1cnJl bnRseSBsaW1pdGVkIHRvCj4gICAgICBQQ0lfQ09ORklHX1NQQUNFX1NJWkUsIHRoaXMgcGF0Y2gg cGF2ZXMgdGhlIHdheSB0byBpbmNyZWFzaW5nIHRoZQo+ICAgICAgbGltaXQgdG8gUENJRV9DT05G SUdfU1BBQ0VfU0laRSB3aGVuIFhlbiBnYWlucyB0aGUgYWJpbGl0eSB0bwo+ICAgICAgZW11bGF0 ZSBNQ0ZHIHRhYmxlIGFjY2Vzc2VzLgo+Cj5TaWduZWQtb2ZmLWJ5OiBQYXVsIER1cnJhbnQgPHBh dWwuZHVycmFudEBjaXRyaXguY29tPgoKTWlub3IgcHJvYmxlbSBoZXJlIGlzIGEgcG9zc2libGUg aW5jb21wYXRpYmlsaXR5IHdpdGggUENJLVBDSSBicmlkZ2VzCndoaWNoIHdlJ2xsIG5lZWQgdG8g dXNlIGV2ZW50dWFsbHkgZm9yIFEzNSBQVCAtLSBJSVJDIGNoYW5naW5nIHNlY29uZGFyeQpidXMg bnVtYmVycyBkbyBub3QgY2F1c2UgdW5yZWFsaXplL3JlYWxpemUgcGFpciB0byBiZSBjYWxsZWQg Zm9yCmFmZmVjdGVkIFBDSSBkZXZpY2VzLiBUaGlzIG1lYW5zIHRoYXQgZGV2X2xpc3QgbWF5IGNv bnRhaW4gc3RhbGUgQkRGCmluZm9ybWF0aW9uIGlmIGFueSByZWxhdGVkIGJ1cyBudW1iZXIgY2hh bmdlLgoKQW55d2F5LCBQQ0ktUENJIGJyaWRnZXMgYW5kIHRoZWlyIHNlY29uZGFyeSBidXMgbnVt YmVycyBtdXN0IGJlIGhhbmRsZWQKc3BlY2lmaWNhbGx5LCBzbyBpdCBjYW4gYmUgaWdub3JlZCBm b3Igbm93LgoKSSdsbCB0cnkgdG8gcmV1c2UgdGhpcyBwYXRjaCBmb3IgbXkgWGVuIHBhdGNoIGZv ciBzdXBwb3J0aW5nIE1NQ09ORklHCmlvcmVxIGZvcndhcmRpbmcgdG8gbXVsdGlwbGUgaW9yZXEg c2VydmVycy4KCj4tLQo+Q2M6IFN0ZWZhbm8gU3RhYmVsbGluaSA8c3N0YWJlbGxpbmlAa2VybmVs Lm9yZz4KPkNjOiBBbnRob255IFBlcmFyZCA8YW50aG9ueS5wZXJhcmRAY2l0cml4LmNvbT4KPkNj OiAiTWljaGFlbCBTLiBUc2lya2luIiA8bXN0QHJlZGhhdC5jb20+Cj5DYzogTWFyY2VsIEFwZmVs YmF1bSA8bWFyY2VsQHJlZGhhdC5jb20+Cj5DYzogUGFvbG8gQm9uemluaSA8cGJvbnppbmlAcmVk aGF0LmNvbT4KPkNjOiBSaWNoYXJkIEhlbmRlcnNvbiA8cnRoQHR3aWRkbGUubmV0Pgo+Q2M6IEVk dWFyZG8gSGFia29zdCA8ZWhhYmtvc3RAcmVkaGF0LmNvbT4KPi0tLQo+IGh3L2kzODYveGVuL3Ry YWNlLWV2ZW50cyB8ICAgMiArCj4gaHcvaTM4Ni94ZW4veGVuLWh2bS5jICAgIHwgMTAxCj4gKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLS0tLS0gMiBmaWxlcyBjaGFu Z2VkLCA4Mwo+IGluc2VydGlvbnMoKyksIDIwIGRlbGV0aW9ucygtKQo+Cj5kaWZmIC0tZ2l0IGEv aHcvaTM4Ni94ZW4vdHJhY2UtZXZlbnRzIGIvaHcvaTM4Ni94ZW4vdHJhY2UtZXZlbnRzCj5pbmRl eCA4ZGFiN2JjLi5mNTc2ZjFiIDEwMDY0NAo+LS0tIGEvaHcvaTM4Ni94ZW4vdHJhY2UtZXZlbnRz Cj4rKysgYi9ody9pMzg2L3hlbi90cmFjZS1ldmVudHMKPkBAIC0xNSw2ICsxNSw4IEBAIGNwdV9p b3JlcV9waW8odm9pZCAqcmVxLCB1aW50MzJfdCBkaXIsIHVpbnQzMl90IGRmLAo+dWludDMyX3Qg ZGF0YV9pc19wdHIsIHVpbnQ2NAo+IGNwdV9pb3JlcV9waW9fcmVhZF9yZWcodm9pZCAqcmVxLCB1 aW50NjRfdCBkYXRhLCB1aW50NjRfdCBhZGRyLAo+IHVpbnQzMl90IHNpemUpICJJL089JXAgcGlv IHJlYWQgcmVnIGRhdGE9MHglIlBSSXg2NCIgcG9ydD0weCUiUFJJeDY0Igo+IHNpemU9JWQiIGNw dV9pb3JlcV9waW9fd3JpdGVfcmVnKHZvaWQgKnJlcSwgdWludDY0X3QgZGF0YSwgdWludDY0X3QK PiBhZGRyLCB1aW50MzJfdCBzaXplKSAiSS9PPSVwIHBpbyB3cml0ZSByZWcgZGF0YT0weCUiUFJJ eDY0Igo+IHBvcnQ9MHglIlBSSXg2NCIgc2l6ZT0lZCIgY3B1X2lvcmVxX21vdmUodm9pZCAqcmVx LCB1aW50MzJfdCBkaXIsCj4gdWludDMyX3QgZGYsIHVpbnQzMl90IGRhdGFfaXNfcHRyLCB1aW50 NjRfdCBhZGRyLCB1aW50NjRfdCBkYXRhLAo+IHVpbnQzMl90IGNvdW50LCB1aW50MzJfdCBzaXpl KSAiSS9PPSVwIGNvcHkgZGlyPSVkIGRmPSVkIHB0cj0lZAo+IHBvcnQ9MHglIlBSSXg2NCIgZGF0 YT0weCUiUFJJeDY0IiBjb3VudD0lZCBzaXplPSVkIgo+K2NwdV9pb3JlcV9jb25maWdfcmVhZCh2 b2lkICpyZXEsIHVpbnQzMl90IHNiZGYsIHVpbnQzMl90IHJlZywKPnVpbnQzMl90IHNpemUsIHVp bnQzMl90IGRhdGEpICJJL089JXAgc2JkZj0weCV4IHJlZz0ldSBzaXplPSV1Cj5kYXRhPTB4JXgi ICtjcHVfaW9yZXFfY29uZmlnX3dyaXRlKHZvaWQgKnJlcSwgdWludDMyX3Qgc2JkZiwgdWludDMy X3QKPnJlZywgdWludDMyX3Qgc2l6ZSwgdWludDMyX3QgZGF0YSkgIkkvTz0lcCBzYmRmPTB4JXgg cmVnPSV1IHNpemU9JXUKPmRhdGE9MHgleCIKPiAKPiAjIHhlbi1tYXBjYWNoZS5jCj4geGVuX21h cF9jYWNoZSh1aW50NjRfdCBwaHlzX2FkZHIpICJ3YW50IDB4JSJQUkl4NjQKPmRpZmYgLS1naXQg YS9ody9pMzg2L3hlbi94ZW4taHZtLmMgYi9ody9pMzg2L3hlbi94ZW4taHZtLmMKPmluZGV4IGNh YTU2M2IuLmMxMzlkMjkgMTAwNjQ0Cj4tLS0gYS9ody9pMzg2L3hlbi94ZW4taHZtLmMKPisrKyBi L2h3L2kzODYveGVuL3hlbi1odm0uYwo+QEAgLTEyLDYgKzEyLDcgQEAKPiAKPiAjaW5jbHVkZSAi Y3B1LmgiCj4gI2luY2x1ZGUgImh3L3BjaS9wY2kuaCIKPisjaW5jbHVkZSAiaHcvcGNpL3BjaV9o b3N0LmgiCj4gI2luY2x1ZGUgImh3L2kzODYvcGMuaCIKPiAjaW5jbHVkZSAiaHcvaTM4Ni9hcGlj LW1zaWRlZi5oIgo+ICNpbmNsdWRlICJody94ZW4veGVuX2NvbW1vbi5oIgo+QEAgLTg2LDYgKzg3 LDEyIEBAIHR5cGVkZWYgc3RydWN0IFhlblBoeXNtYXAgewo+ICAgICBRTElTVF9FTlRSWShYZW5Q aHlzbWFwKSBsaXN0Owo+IH0gWGVuUGh5c21hcDsKPiAKPit0eXBlZGVmIHN0cnVjdCBYZW5QY2lE ZXZpY2Ugewo+KyAgICBQQ0lEZXZpY2UgKnBjaV9kZXY7Cj4rICAgIHVpbnQzMl90IHNiZGY7Cj4r ICAgIFFMSVNUX0VOVFJZKFhlblBjaURldmljZSkgZW50cnk7Cj4rfSBYZW5QY2lEZXZpY2U7Cj4r Cj4gdHlwZWRlZiBzdHJ1Y3QgWGVuSU9TdGF0ZSB7Cj4gICAgIGlvc2VydmlkX3QgaW9zZXJ2aWQ7 Cj4gICAgIHNoYXJlZF9pb3BhZ2VfdCAqc2hhcmVkX3BhZ2U7Cj5AQCAtMTA1LDYgKzExMiw3IEBA IHR5cGVkZWYgc3RydWN0IFhlbklPU3RhdGUgewo+ICAgICBzdHJ1Y3QgeHNfaGFuZGxlICp4ZW5z dG9yZTsKPiAgICAgTWVtb3J5TGlzdGVuZXIgbWVtb3J5X2xpc3RlbmVyOwo+ICAgICBNZW1vcnlM aXN0ZW5lciBpb19saXN0ZW5lcjsKPisgICAgUUxJU1RfSEVBRCgsIFhlblBjaURldmljZSkgZGV2 X2xpc3Q7Cj4gICAgIERldmljZUxpc3RlbmVyIGRldmljZV9saXN0ZW5lcjsKPiAgICAgUUxJU1Rf SEVBRCgsIFhlblBoeXNtYXApIHBoeXNtYXA7Cj4gICAgIGh3YWRkciBmcmVlX3BoeXNfb2Zmc2V0 Owo+QEAgLTU2OSw2ICs1NzcsMTIgQEAgc3RhdGljIHZvaWQgeGVuX2RldmljZV9yZWFsaXplKERl dmljZUxpc3RlbmVyCj4qbGlzdGVuZXIsCj4gCj4gICAgIGlmIChvYmplY3RfZHluYW1pY19jYXN0 KE9CSkVDVChkZXYpLCBUWVBFX1BDSV9ERVZJQ0UpKSB7Cj4gICAgICAgICBQQ0lEZXZpY2UgKnBj aV9kZXYgPSBQQ0lfREVWSUNFKGRldik7Cj4rICAgICAgICBYZW5QY2lEZXZpY2UgKnhlbmRldiA9 IGdfbmV3KFhlblBjaURldmljZSwgMSk7Cj4rCj4rICAgICAgICB4ZW5kZXYtPnBjaV9kZXYgPSBw Y2lfZGV2Owo+KyAgICAgICAgeGVuZGV2LT5zYmRmID0gUENJX0JVSUxEX0JERihwY2lfZGV2X2J1 c19udW0ocGNpX2RldiksCj4rICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBj aV9kZXYtPmRldmZuKTsKPisgICAgICAgIFFMSVNUX0lOU0VSVF9IRUFEKCZzdGF0ZS0+ZGV2X2xp c3QsIHhlbmRldiwgZW50cnkpOwo+IAo+ICAgICAgICAgeGVuX21hcF9wY2lkZXYoeGVuX2RvbWlk LCBzdGF0ZS0+aW9zZXJ2aWQsIHBjaV9kZXYpOwo+ICAgICB9Cj5AQCAtNTgxLDggKzU5NSwxNyBA QCBzdGF0aWMgdm9pZCB4ZW5fZGV2aWNlX3VucmVhbGl6ZShEZXZpY2VMaXN0ZW5lcgo+Kmxpc3Rl bmVyLAo+IAo+ICAgICBpZiAob2JqZWN0X2R5bmFtaWNfY2FzdChPQkpFQ1QoZGV2KSwgVFlQRV9Q Q0lfREVWSUNFKSkgewo+ICAgICAgICAgUENJRGV2aWNlICpwY2lfZGV2ID0gUENJX0RFVklDRShk ZXYpOwo+KyAgICAgICAgWGVuUGNpRGV2aWNlICp4ZW5kZXYsICpuZXh0Owo+IAo+ICAgICAgICAg eGVuX3VubWFwX3BjaWRldih4ZW5fZG9taWQsIHN0YXRlLT5pb3NlcnZpZCwgcGNpX2Rldik7Cj4r Cj4rICAgICAgICBRTElTVF9GT1JFQUNIX1NBRkUoeGVuZGV2LCAmc3RhdGUtPmRldl9saXN0LCBl bnRyeSwgbmV4dCkgewo+KyAgICAgICAgICAgIGlmICh4ZW5kZXYtPnBjaV9kZXYgPT0gcGNpX2Rl dikgewo+KyAgICAgICAgICAgICAgICBRTElTVF9SRU1PVkUoeGVuZGV2LCBlbnRyeSk7Cj4rICAg ICAgICAgICAgICAgIGdfZnJlZSh4ZW5kZXYpOwo+KyAgICAgICAgICAgICAgICBicmVhazsKPisg ICAgICAgICAgICB9Cj4rICAgICAgICB9Cj4gICAgIH0KPiB9Cj4gCj5AQCAtOTAzLDYgKzkyNiw2 MSBAQCBzdGF0aWMgdm9pZCBjcHVfaW9yZXFfbW92ZShpb3JlcV90ICpyZXEpCj4gICAgIH0KPiB9 Cj4gCj4rc3RhdGljIHZvaWQgY3B1X2lvcmVxX2NvbmZpZyhYZW5JT1N0YXRlICpzdGF0ZSwgaW9y ZXFfdCAqcmVxKQo+K3sKPisgICAgdWludDMyX3Qgc2JkZiA9IHJlcS0+YWRkciA+PiAzMjsKPisg ICAgdWludDMyX3QgcmVnID0gcmVxLT5hZGRyOwo+KyAgICBYZW5QY2lEZXZpY2UgKnhlbmRldjsK PisKPisgICAgaWYgKHJlcS0+c2l6ZSA+IHNpemVvZih1aW50MzJfdCkpIHsKPisgICAgICAgIGh3 X2Vycm9yKCJQQ0kgY29uZmlnIGFjY2VzczogYmFkIHNpemUgKCV1KSIsIHJlcS0+c2l6ZSk7Cj4r ICAgIH0KPisKPisgICAgUUxJU1RfRk9SRUFDSCh4ZW5kZXYsICZzdGF0ZS0+ZGV2X2xpc3QsIGVu dHJ5KSB7Cj4rICAgICAgICB1bnNpZ25lZCBpbnQgaTsKPisKPisgICAgICAgIGlmICh4ZW5kZXYt PnNiZGYgIT0gc2JkZikgewo+KyAgICAgICAgICAgIGNvbnRpbnVlOwo+KyAgICAgICAgfQo+Kwo+ KyAgICAgICAgaWYgKHJlcS0+ZGlyID09IElPUkVRX1JFQUQpIHsKPisgICAgICAgICAgICBpZiAo IXJlcS0+ZGF0YV9pc19wdHIpIHsKPisgICAgICAgICAgICAgICAgcmVxLT5kYXRhID0gcGNpX2hv c3RfY29uZmlnX3JlYWRfY29tbW9uKAo+KyAgICAgICAgICAgICAgICAgICAgeGVuZGV2LT5wY2lf ZGV2LCByZWcsIFBDSV9DT05GSUdfU1BBQ0VfU0laRSwKPisgICAgICAgICAgICAgICAgICAgIHJl cS0+c2l6ZSk7Cj4rICAgICAgICAgICAgICAgIHRyYWNlX2NwdV9pb3JlcV9jb25maWdfcmVhZChy ZXEsIHNiZGYsIHJlZywgcmVxLT5zaXplLAo+KyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgcmVxLT5kYXRhKTsKPisgICAgICAgICAgICB9IGVsc2Ugewo+KyAgICAg ICAgICAgICAgICBmb3IgKGkgPSAwOyBpIDwgcmVxLT5jb3VudDsgaSsrKSB7Cj4rICAgICAgICAg ICAgICAgICAgICB1aW50MzJfdCB0bXA7Cj4rCj4rICAgICAgICAgICAgICAgICAgICB0bXAgPSBw Y2lfaG9zdF9jb25maWdfcmVhZF9jb21tb24oCj4rICAgICAgICAgICAgICAgICAgICAgICAgeGVu ZGV2LT5wY2lfZGV2LCByZWcsIFBDSV9DT05GSUdfU1BBQ0VfU0laRSwKPisgICAgICAgICAgICAg ICAgICAgICAgICByZXEtPnNpemUpOwo+KyAgICAgICAgICAgICAgICAgICAgd3JpdGVfcGh5c19y ZXFfaXRlbShyZXEtPmRhdGEsIHJlcSwgaSwgJnRtcCk7Cj4rICAgICAgICAgICAgICAgIH0KPisg ICAgICAgICAgICB9Cj4rICAgICAgICB9IGVsc2UgaWYgKHJlcS0+ZGlyID09IElPUkVRX1dSSVRF KSB7Cj4rICAgICAgICAgICAgaWYgKCFyZXEtPmRhdGFfaXNfcHRyKSB7Cj4rICAgICAgICAgICAg ICAgIHRyYWNlX2NwdV9pb3JlcV9jb25maWdfd3JpdGUocmVxLCBzYmRmLCByZWcsCj5yZXEtPnNp emUsCj4rICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVxLT5k YXRhKTsKPisgICAgICAgICAgICAgICAgcGNpX2hvc3RfY29uZmlnX3dyaXRlX2NvbW1vbigKPisg ICAgICAgICAgICAgICAgICAgIHhlbmRldi0+cGNpX2RldiwgcmVnLCBQQ0lfQ09ORklHX1NQQUNF X1NJWkUsCj5yZXEtPmRhdGEsCj4rICAgICAgICAgICAgICAgICAgICByZXEtPnNpemUpOwo+KyAg ICAgICAgICAgIH0gZWxzZSB7Cj4rICAgICAgICAgICAgICAgIGZvciAoaSA9IDA7IGkgPCByZXEt PmNvdW50OyBpKyspIHsKPisgICAgICAgICAgICAgICAgICAgIHVpbnQzMl90IHRtcCA9IDA7Cj4r Cj4rICAgICAgICAgICAgICAgICAgICByZWFkX3BoeXNfcmVxX2l0ZW0ocmVxLT5kYXRhLCByZXEs IGksICZ0bXApOwo+KyAgICAgICAgICAgICAgICAgICAgcGNpX2hvc3RfY29uZmlnX3dyaXRlX2Nv bW1vbigKPisgICAgICAgICAgICAgICAgICAgICAgICB4ZW5kZXYtPnBjaV9kZXYsIHJlZywgUENJ X0NPTkZJR19TUEFDRV9TSVpFLAo+dG1wLAo+KyAgICAgICAgICAgICAgICAgICAgICAgIHJlcS0+ c2l6ZSk7Cj4rICAgICAgICAgICAgICAgIH0KPisgICAgICAgICAgICB9Cj4rICAgICAgICB9Cj4r ICAgIH0KPit9Cj4rCj4gc3RhdGljIHZvaWQgcmVnc190b19jcHUodm13YXJlX3JlZ3NfdCAqdm1w b3J0X3JlZ3MsIGlvcmVxX3QgKnJlcSkKPiB7Cj4gICAgIFg4NkNQVSAqY3B1Owo+QEAgLTk3NSwy NyArMTA1Myw5IEBAIHN0YXRpYyB2b2lkIGhhbmRsZV9pb3JlcShYZW5JT1N0YXRlICpzdGF0ZSwK PmlvcmVxX3QgKnJlcSkKPiAgICAgICAgIGNhc2UgSU9SRVFfVFlQRV9JTlZBTElEQVRFOgo+ICAg ICAgICAgICAgIHhlbl9pbnZhbGlkYXRlX21hcF9jYWNoZSgpOwo+ICAgICAgICAgICAgIGJyZWFr Owo+LSAgICAgICAgY2FzZSBJT1JFUV9UWVBFX1BDSV9DT05GSUc6IHsKPi0gICAgICAgICAgICB1 aW50MzJfdCBzYmRmID0gcmVxLT5hZGRyID4+IDMyOwo+LSAgICAgICAgICAgIHVpbnQzMl90IHZh bDsKPi0KPi0gICAgICAgICAgICAvKiBGYWtlIGEgd3JpdGUgdG8gcG9ydCAweENGOCBzbyB0aGF0 Cj4tICAgICAgICAgICAgICogdGhlIGNvbmZpZyBzcGFjZSBhY2Nlc3Mgd2lsbCB0YXJnZXQgdGhl Cj4tICAgICAgICAgICAgICogY29ycmVjdCBkZXZpY2UgbW9kZWwuCj4tICAgICAgICAgICAgICov Cj4tICAgICAgICAgICAgdmFsID0gKDF1IDw8IDMxKSB8Cj4tICAgICAgICAgICAgICAgICAgKChy ZXEtPmFkZHIgJiAweDBmMDApIDw8IDE2KSB8Cj4tICAgICAgICAgICAgICAgICAgKChzYmRmICYg MHhmZmZmKSA8PCA4KSB8Cj4tICAgICAgICAgICAgICAgICAgKHJlcS0+YWRkciAmIDB4ZmMpOwo+ LSAgICAgICAgICAgIGRvX291dHAoMHhjZjgsIDQsIHZhbCk7Cj4tCj4tICAgICAgICAgICAgLyog Tm93IGlzc3VlIHRoZSBjb25maWcgc3BhY2UgYWNjZXNzIHZpYQo+LSAgICAgICAgICAgICAqIHBv cnQgMHhDRkMKPi0gICAgICAgICAgICAgKi8KPi0gICAgICAgICAgICByZXEtPmFkZHIgPSAweGNm YyB8IChyZXEtPmFkZHIgJiAweDAzKTsKPi0gICAgICAgICAgICBjcHVfaW9yZXFfcGlvKHJlcSk7 Cj4rICAgICAgICBjYXNlIElPUkVRX1RZUEVfUENJX0NPTkZJRzoKPisgICAgICAgICAgICBjcHVf aW9yZXFfY29uZmlnKHN0YXRlLCByZXEpOwo+ICAgICAgICAgICAgIGJyZWFrOwo+LSAgICAgICAg fQo+ICAgICAgICAgZGVmYXVsdDoKPiAgICAgICAgICAgICBod19lcnJvcigiSW52YWxpZCBpb3Jl cSB0eXBlIDB4JXhcbiIsIHJlcS0+dHlwZSk7Cj4gICAgIH0KPkBAIC0xMzY2LDYgKzE0MjYsNyBA QCB2b2lkIHhlbl9odm1faW5pdChQQ01hY2hpbmVTdGF0ZSAqcGNtcywKPk1lbW9yeVJlZ2lvbiAq KnJhbV9tZW1vcnkpCj4gICAgIG1lbW9yeV9saXN0ZW5lcl9yZWdpc3Rlcigmc3RhdGUtPmlvX2xp c3RlbmVyLCAmYWRkcmVzc19zcGFjZV9pbyk7Cj4gCj4gICAgIHN0YXRlLT5kZXZpY2VfbGlzdGVu ZXIgPSB4ZW5fZGV2aWNlX2xpc3RlbmVyOwo+KyAgICBRTElTVF9JTklUKCZzdGF0ZS0+ZGV2X2xp c3QpOwo+ICAgICBkZXZpY2VfbGlzdGVuZXJfcmVnaXN0ZXIoJnN0YXRlLT5kZXZpY2VfbGlzdGVu ZXIpOwo+IAo+ICAgICAvKiBJbml0aWFsaXplIGJhY2tlbmQgY29yZSAmIGRyaXZlcnMgKi8KCgpf X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpYZW4tZGV2ZWwg bWFpbGluZyBsaXN0Clhlbi1kZXZlbEBsaXN0cy54ZW5wcm9qZWN0Lm9yZwpodHRwczovL2xpc3Rz LnhlbnByb2plY3Qub3JnL21haWxtYW4vbGlzdGluZm8veGVuLWRldmVs From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:49902) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1fEDYS-00068N-EN for qemu-devel@nongnu.org; Thu, 03 May 2018 08:41:49 -0400 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1fEDYM-0003K3-54 for qemu-devel@nongnu.org; Thu, 03 May 2018 08:41:48 -0400 Received: from mail-lf0-x242.google.com ([2a00:1450:4010:c07::242]:35094) by eggs.gnu.org with esmtps (TLS1.0:RSA_AES_128_CBC_SHA1:16) (Exim 4.71) (envelope-from ) id 1fEDYL-0003JJ-PO for qemu-devel@nongnu.org; Thu, 03 May 2018 08:41:42 -0400 Received: by mail-lf0-x242.google.com with SMTP id y72-v6so12008355lfd.2 for ; Thu, 03 May 2018 05:41:41 -0700 (PDT) Date: Thu, 3 May 2018 22:41:28 +1000 From: Alexey G Message-ID: <20180503224128.00005cf7@gmail.com> In-Reply-To: <1525346320-24553-1-git-send-email-paul.durrant@citrix.com> References: <1525346320-24553-1-git-send-email-paul.durrant@citrix.com> MIME-Version: 1.0 Content-Type: text/plain; charset=US-ASCII Content-Transfer-Encoding: 7bit Subject: Re: [Qemu-devel] [PATCH] xen-hvm: stop faking I/O to access PCI config space List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Paul Durrant Cc: xen-devel@lists.xenproject.org, qemu-devel@nongnu.org, Stefano Stabellini , Eduardo Habkost , "Michael S. Tsirkin" , Marcel Apfelbaum , Anthony Perard , Paolo Bonzini , Richard Henderson On Thu, 3 May 2018 12:18:40 +0100 Paul Durrant wrote: >This patch removes the current hackery where IOREQ_TYPE_PCI_CONFIG >reqyests are handled by faking PIO to 0xcf8 and 0xcfc and replaces it >with direct calls to pci_host_config_read/write_common(). >Doing so necessitates mapping BDFs to PCIDevices but maintaining a >simple QLIST in xen_device_realize/unrealize() will suffice. > >NOTE: whilst config space accesses are currently limited to > PCI_CONFIG_SPACE_SIZE, this patch paves the way to increasing the > limit to PCIE_CONFIG_SPACE_SIZE when Xen gains the ability to > emulate MCFG table accesses. > >Signed-off-by: Paul Durrant Minor problem here is a possible incompatibility with PCI-PCI bridges which we'll need to use eventually for Q35 PT -- IIRC changing secondary bus numbers do not cause unrealize/realize pair to be called for affected PCI devices. This means that dev_list may contain stale BDF information if any related bus number change. Anyway, PCI-PCI bridges and their secondary bus numbers must be handled specifically, so it can be ignored for now. I'll try to reuse this patch for my Xen patch for supporting MMCONFIG ioreq forwarding to multiple ioreq servers. >-- >Cc: Stefano Stabellini >Cc: Anthony Perard >Cc: "Michael S. Tsirkin" >Cc: Marcel Apfelbaum >Cc: Paolo Bonzini >Cc: Richard Henderson >Cc: Eduardo Habkost >--- > hw/i386/xen/trace-events | 2 + > hw/i386/xen/xen-hvm.c | 101 > +++++++++++++++++++++++++++++++++++++---------- 2 files changed, 83 > insertions(+), 20 deletions(-) > >diff --git a/hw/i386/xen/trace-events b/hw/i386/xen/trace-events >index 8dab7bc..f576f1b 100644 >--- a/hw/i386/xen/trace-events >+++ b/hw/i386/xen/trace-events >@@ -15,6 +15,8 @@ cpu_ioreq_pio(void *req, uint32_t dir, uint32_t df, >uint32_t data_is_ptr, uint64 > cpu_ioreq_pio_read_reg(void *req, uint64_t data, uint64_t addr, > uint32_t size) "I/O=%p pio read reg data=0x%"PRIx64" port=0x%"PRIx64" > size=%d" cpu_ioreq_pio_write_reg(void *req, uint64_t data, uint64_t > addr, uint32_t size) "I/O=%p pio write reg data=0x%"PRIx64" > port=0x%"PRIx64" size=%d" cpu_ioreq_move(void *req, uint32_t dir, > uint32_t df, uint32_t data_is_ptr, uint64_t addr, uint64_t data, > uint32_t count, uint32_t size) "I/O=%p copy dir=%d df=%d ptr=%d > port=0x%"PRIx64" data=0x%"PRIx64" count=%d size=%d" >+cpu_ioreq_config_read(void *req, uint32_t sbdf, uint32_t reg, >uint32_t size, uint32_t data) "I/O=%p sbdf=0x%x reg=%u size=%u >data=0x%x" +cpu_ioreq_config_write(void *req, uint32_t sbdf, uint32_t >reg, uint32_t size, uint32_t data) "I/O=%p sbdf=0x%x reg=%u size=%u >data=0x%x" > > # xen-mapcache.c > xen_map_cache(uint64_t phys_addr) "want 0x%"PRIx64 >diff --git a/hw/i386/xen/xen-hvm.c b/hw/i386/xen/xen-hvm.c >index caa563b..c139d29 100644 >--- a/hw/i386/xen/xen-hvm.c >+++ b/hw/i386/xen/xen-hvm.c >@@ -12,6 +12,7 @@ > > #include "cpu.h" > #include "hw/pci/pci.h" >+#include "hw/pci/pci_host.h" > #include "hw/i386/pc.h" > #include "hw/i386/apic-msidef.h" > #include "hw/xen/xen_common.h" >@@ -86,6 +87,12 @@ typedef struct XenPhysmap { > QLIST_ENTRY(XenPhysmap) list; > } XenPhysmap; > >+typedef struct XenPciDevice { >+ PCIDevice *pci_dev; >+ uint32_t sbdf; >+ QLIST_ENTRY(XenPciDevice) entry; >+} XenPciDevice; >+ > typedef struct XenIOState { > ioservid_t ioservid; > shared_iopage_t *shared_page; >@@ -105,6 +112,7 @@ typedef struct XenIOState { > struct xs_handle *xenstore; > MemoryListener memory_listener; > MemoryListener io_listener; >+ QLIST_HEAD(, XenPciDevice) dev_list; > DeviceListener device_listener; > QLIST_HEAD(, XenPhysmap) physmap; > hwaddr free_phys_offset; >@@ -569,6 +577,12 @@ static void xen_device_realize(DeviceListener >*listener, > > if (object_dynamic_cast(OBJECT(dev), TYPE_PCI_DEVICE)) { > PCIDevice *pci_dev = PCI_DEVICE(dev); >+ XenPciDevice *xendev = g_new(XenPciDevice, 1); >+ >+ xendev->pci_dev = pci_dev; >+ xendev->sbdf = PCI_BUILD_BDF(pci_dev_bus_num(pci_dev), >+ pci_dev->devfn); >+ QLIST_INSERT_HEAD(&state->dev_list, xendev, entry); > > xen_map_pcidev(xen_domid, state->ioservid, pci_dev); > } >@@ -581,8 +595,17 @@ static void xen_device_unrealize(DeviceListener >*listener, > > if (object_dynamic_cast(OBJECT(dev), TYPE_PCI_DEVICE)) { > PCIDevice *pci_dev = PCI_DEVICE(dev); >+ XenPciDevice *xendev, *next; > > xen_unmap_pcidev(xen_domid, state->ioservid, pci_dev); >+ >+ QLIST_FOREACH_SAFE(xendev, &state->dev_list, entry, next) { >+ if (xendev->pci_dev == pci_dev) { >+ QLIST_REMOVE(xendev, entry); >+ g_free(xendev); >+ break; >+ } >+ } > } > } > >@@ -903,6 +926,61 @@ static void cpu_ioreq_move(ioreq_t *req) > } > } > >+static void cpu_ioreq_config(XenIOState *state, ioreq_t *req) >+{ >+ uint32_t sbdf = req->addr >> 32; >+ uint32_t reg = req->addr; >+ XenPciDevice *xendev; >+ >+ if (req->size > sizeof(uint32_t)) { >+ hw_error("PCI config access: bad size (%u)", req->size); >+ } >+ >+ QLIST_FOREACH(xendev, &state->dev_list, entry) { >+ unsigned int i; >+ >+ if (xendev->sbdf != sbdf) { >+ continue; >+ } >+ >+ if (req->dir == IOREQ_READ) { >+ if (!req->data_is_ptr) { >+ req->data = pci_host_config_read_common( >+ xendev->pci_dev, reg, PCI_CONFIG_SPACE_SIZE, >+ req->size); >+ trace_cpu_ioreq_config_read(req, sbdf, reg, req->size, >+ req->data); >+ } else { >+ for (i = 0; i < req->count; i++) { >+ uint32_t tmp; >+ >+ tmp = pci_host_config_read_common( >+ xendev->pci_dev, reg, PCI_CONFIG_SPACE_SIZE, >+ req->size); >+ write_phys_req_item(req->data, req, i, &tmp); >+ } >+ } >+ } else if (req->dir == IOREQ_WRITE) { >+ if (!req->data_is_ptr) { >+ trace_cpu_ioreq_config_write(req, sbdf, reg, >req->size, >+ req->data); >+ pci_host_config_write_common( >+ xendev->pci_dev, reg, PCI_CONFIG_SPACE_SIZE, >req->data, >+ req->size); >+ } else { >+ for (i = 0; i < req->count; i++) { >+ uint32_t tmp = 0; >+ >+ read_phys_req_item(req->data, req, i, &tmp); >+ pci_host_config_write_common( >+ xendev->pci_dev, reg, PCI_CONFIG_SPACE_SIZE, >tmp, >+ req->size); >+ } >+ } >+ } >+ } >+} >+ > static void regs_to_cpu(vmware_regs_t *vmport_regs, ioreq_t *req) > { > X86CPU *cpu; >@@ -975,27 +1053,9 @@ static void handle_ioreq(XenIOState *state, >ioreq_t *req) > case IOREQ_TYPE_INVALIDATE: > xen_invalidate_map_cache(); > break; >- case IOREQ_TYPE_PCI_CONFIG: { >- uint32_t sbdf = req->addr >> 32; >- uint32_t val; >- >- /* Fake a write to port 0xCF8 so that >- * the config space access will target the >- * correct device model. >- */ >- val = (1u << 31) | >- ((req->addr & 0x0f00) << 16) | >- ((sbdf & 0xffff) << 8) | >- (req->addr & 0xfc); >- do_outp(0xcf8, 4, val); >- >- /* Now issue the config space access via >- * port 0xCFC >- */ >- req->addr = 0xcfc | (req->addr & 0x03); >- cpu_ioreq_pio(req); >+ case IOREQ_TYPE_PCI_CONFIG: >+ cpu_ioreq_config(state, req); > break; >- } > default: > hw_error("Invalid ioreq type 0x%x\n", req->type); > } >@@ -1366,6 +1426,7 @@ void xen_hvm_init(PCMachineState *pcms, >MemoryRegion **ram_memory) > memory_listener_register(&state->io_listener, &address_space_io); > > state->device_listener = xen_device_listener; >+ QLIST_INIT(&state->dev_list); > device_listener_register(&state->device_listener); > > /* Initialize backend core & drivers */