From mboxrd@z Thu Jan 1 00:00:00 1970 From: "Michael S. Tsirkin" Subject: Re: [PATCH RESEND V2] vdpa: introduce virtio pci driver Date: Wed, 10 Jun 2020 02:07:41 -0400 Message-ID: <20200610020728-mutt-send-email-mst@kernel.org> References: <20200610054951.16197-1-jasowang@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-Reply-To: <20200610054951.16197-1-jasowang@redhat.com> Content-Disposition: inline List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: virtualization-bounces@lists.linux-foundation.org Sender: "Virtualization" To: Jason Wang Cc: shahafs@mellanox.com, lulu@redhat.com, saugatm@xilinx.com, mhabets@solarflare.com, vmireyno@marvell.com, linux-kernel@vger.kernel.org, gdawar@xilinx.com, virtualization@lists.linux-foundation.org, eperezma@redhat.com, hanand@xilinx.com, zhangweining@ruijie.com.cn, eli@mellanox.com, lingshan.zhu@intel.com, rob.miller@broadcom.com List-Id: virtualization@lists.linuxfoundation.org T24gV2VkLCBKdW4gMTAsIDIwMjAgYXQgMDE6NDk6NTFQTSArMDgwMCwgSmFzb24gV2FuZyB3cm90 ZToKPiBUaGlzIHBhdGNoIGludHJvZHVjZSBhIHZEUEEgZHJpdmVyIGZvciB2aXJ0aW8tcGNpIGRl dmljZS4gSXQgYnJpZGdlcwo+IHRoZSB2aXJ0aW8tcGNpIGNvbnRyb2wgY29tbWFuZCB0byB0aGUg dkRQQSBidXMuIFRoaXMgd2lsbCBiZSB1c2VkIGZvcgo+IGRldmVsb3BpbmcgbmV3IGZlYXR1cmVz IGZvciBib3RoIHNvZnR3YXJlIHZEUEEgZnJhbWV3b3JrIGFuZCBoYXJkd2FyZQo+IHZEUEEgZmVh dHVyZS4KPiAKPiBDb21wYXJlZCB0byB2ZHBhX3NpbSwgaXQgaGFzIHNldmVyYWwgYWR2YW50YWdl czoKPiAKPiAtIGl0J3MgYSByZWFsIGRldmljZSBkcml2ZXIgd2hpY2ggYWxsb3cgdXMgdG8gcGxh eSB3aXRoIHJlYWwgaGFyZHdhcmUKPiAgIGZlYXR1cmVzCj4gLSB0eXBlIGluZGVwZW5kZW50IGlu c3RlYWQgb2YgbmV0d29ya2luZyBzcGVjaWZpYwo+IAo+IE5vdGUgdGhhdCBzaW5jZSB2aXJ0aW8g c3BlY2lmaWNhdGlvbiBkb2VzIG5vdCBzdXBwb3J0IGdldC9yZXN0b3JlCj4gdmlydHF1ZXVlIHN0 YXRlLiBTbyB3ZSBjYW4gbm90IHVzZSB0aGlzIGRyaXZlciBmb3IgVk0uIFRoaXMgY2FuIGJlCj4g YWRkcmVzc2VkIGJ5IGV4dGVuZGluZyB0aGUgdmlydGlvIHNwZWNpZmljYXRpb24uCj4gCj4gQ29u c2lkZXIgdGhlIGRyaXZlciBpcyBtYWlubHkgZm9yIHRlc3RpbmcgYW5kIGRldmVsb3BtZW50IGZv ciB2RFBBCj4gZmVhdHVyZXMsIGl0IGNhbiBvbmx5IGJlIGJvdW5kIHZpYSBkeW5hbWljIGlkcyB0 byBtYWtlIHN1cmUgaXQncyBub3QKPiBjb25mbGljdCB3aXRoIHRoZSBkcml2ZXJzIGxpa2Ugdmly dGlvLXBjaSBvciBJRkNWRi4KPiAKPiBTaWduZWQtb2ZmLWJ5OiBKYXNvbiBXYW5nIDxqYXNvd2Fu Z0ByZWRoYXQuY29tPgoKZXJyb3I6IHNoYTEgaW5mb3JtYXRpb24gaXMgbGFja2luZyBvciB1c2Vs ZXNzIChkcml2ZXJzL3ZkcGEvS2NvbmZpZykuCgp3aGljaCB0cmVlIGlzIHRoaXMgb24gdG9wIG9m PwoKPiAtLS0KPiBDaGFuZ2VzIHNpbmNlIFYxOgo+IC0gdXNlIE5VTEwgaWRfdGFibGUgdG8gYWxs b3cgZHluYW1pYyBpZHMgb25seQo+IC0gc3F1YXNoIHRoZSBkb29yYmVsbCByZXBvcnRpbmcKPiAt LS0KPiAgZHJpdmVycy92ZHBhL0tjb25maWcgICAgICAgICAgIHwgICA4ICsKPiAgZHJpdmVycy92 ZHBhL01ha2VmaWxlICAgICAgICAgIHwgICAxICsKPiAgZHJpdmVycy92ZHBhL3ZwX3ZkcGEvTWFr ZWZpbGUgIHwgICAyICsKPiAgZHJpdmVycy92ZHBhL3ZwX3ZkcGEvdnBfdmRwYS5jIHwgNjAxICsr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ICA0IGZpbGVzIGNoYW5nZWQsIDYxMiBp bnNlcnRpb25zKCspCj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBkcml2ZXJzL3ZkcGEvdnBfdmRwYS9N YWtlZmlsZQo+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy92ZHBhL3ZwX3ZkcGEvdnBfdmRw YS5jCj4gCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmRwYS9LY29uZmlnIGIvZHJpdmVycy92ZHBh L0tjb25maWcKPiBpbmRleCBlODE0MDA2NWM4YTUuLjVjZWYzYTQ4NzJlMyAxMDA2NDQKPiAtLS0g YS9kcml2ZXJzL3ZkcGEvS2NvbmZpZwo+ICsrKyBiL2RyaXZlcnMvdmRwYS9LY29uZmlnCj4gQEAg LTI4LDQgKzI4LDEyIEBAIGNvbmZpZyBJRkNWRgo+ICAJICBUbyBjb21waWxlIHRoaXMgZHJpdmVy IGFzIGEgbW9kdWxlLCBjaG9vc2UgTSBoZXJlOiB0aGUgbW9kdWxlIHdpbGwKPiAgCSAgYmUgY2Fs bGVkIGlmY3ZmLgo+ICAKPiArY29uZmlnIFZQX1ZEUEEKPiArCXRyaXN0YXRlICJWaXJ0aW8gUENJ IGJyaWRnZSB2RFBBIGRyaXZlciIKPiArCWRlcGVuZHMgb24gUENJX01TSQo+ICsJaGVscAo+ICsJ ICBUaGlzIGtlcm5lbCBtb2R1bGUgdGhhdCBicmlkZ2VzIHZpcnRpbyBQQ0kgZGV2aWNlIHRvIHZE UEEKPiArCSAgYnVzLiBJdCBhbGxvd3MgdXMgdG8gdGVzdCBhbmQgZGV2ZWxvcCB2RFBBIHN1YnN5 c3RlbSBpbnNpZGUKPiArCSAgYW4gVk0gd2l0aCB0aGUgZW11bGF0ZWQgdmlydGlvLXBjaSBkZXZp Y2UKPiArCj4gIGVuZGlmICMgVkRQQQo+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3ZkcGEvTWFrZWZp bGUgYi9kcml2ZXJzL3ZkcGEvTWFrZWZpbGUKPiBpbmRleCA4YmJiNjg2Y2E3YTIuLjM3ZDAwZjQ5 YjNiZiAxMDA2NDQKPiAtLS0gYS9kcml2ZXJzL3ZkcGEvTWFrZWZpbGUKPiArKysgYi9kcml2ZXJz L3ZkcGEvTWFrZWZpbGUKPiBAQCAtMiwzICsyLDQgQEAKPiAgb2JqLSQoQ09ORklHX1ZEUEEpICs9 IHZkcGEubwo+ICBvYmotJChDT05GSUdfVkRQQV9TSU0pICs9IHZkcGFfc2ltLwo+ICBvYmotJChD T05GSUdfSUZDVkYpICAgICs9IGlmY3ZmLwo+ICtvYmotJChDT05GSUdfVlBfVkRQQSkgICAgKz0g dnBfdmRwYS8KPiBkaWZmIC0tZ2l0IGEvZHJpdmVycy92ZHBhL3ZwX3ZkcGEvTWFrZWZpbGUgYi9k cml2ZXJzL3ZkcGEvdnBfdmRwYS9NYWtlZmlsZQo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5k ZXggMDAwMDAwMDAwMDAwLi4yMzEwODhkM2FmN2QKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJp dmVycy92ZHBhL3ZwX3ZkcGEvTWFrZWZpbGUKPiBAQCAtMCwwICsxLDIgQEAKPiArIyBTUERYLUxp Y2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAo+ICtvYmotJChDT05GSUdfVlBfVkRQQSkgKz0gdnBf dmRwYS5vCj4gZGlmZiAtLWdpdCBhL2RyaXZlcnMvdmRwYS92cF92ZHBhL3ZwX3ZkcGEuYyBiL2Ry aXZlcnMvdmRwYS92cF92ZHBhL3ZwX3ZkcGEuYwo+IG5ldyBmaWxlIG1vZGUgMTAwNjQ0Cj4gaW5k ZXggMDAwMDAwMDAwMDAwLi4yMDcwMjk4YWI5ZmMKPiAtLS0gL2Rldi9udWxsCj4gKysrIGIvZHJp dmVycy92ZHBhL3ZwX3ZkcGEvdnBfdmRwYS5jCj4gQEAgLTAsMCArMSw2MDEgQEAKPiArLy8gU1BE WC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAtb25seQo+ICsvKgo+ICsgKiB2RFBBIGJyaWRn ZSBkcml2ZXIgZm9yIG1vZGVybiB2aXJ0aW8tcGNpIGRldmljZQo+ICsgKgo+ICsgKiBDb3B5cmln aHQgKGMpIDIwMjAsIFJlZCBIYXQgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgo+ICsgKiBBdXRo b3I6IEphc29uIFdhbmcgPGphc293YW5nQHJlZGhhdC5jb20+Cj4gKyAqCj4gKyAqIEJhc2VkIG9u IHZpcnRpb19wY2lfbW9kZXJuLmMuCj4gKyAqLwo+ICsKPiArI2luY2x1ZGUgPGxpbnV4L2ludGVy cnVwdC5oPgo+ICsjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9w Y2kuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3ZkcGEuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3ZpcnRp by5oPgo+ICsjaW5jbHVkZSA8bGludXgvdmlydGlvX2NvbmZpZy5oPgo+ICsjaW5jbHVkZSA8bGlu dXgvdmlydGlvX3JpbmcuaD4KPiArI2luY2x1ZGUgPGxpbnV4L3ZpcnRpb19wY2kuaD4KPiArCj4g Ky8qIFRCRDogcmVhZCBmcm9tIGNvbmZpZyBzcGFjZSAqLwo+ICsjZGVmaW5lIFZQX1ZEUEFfTUFY X1FVRVVFIDIKPiArI2RlZmluZSBWUF9WRFBBX0RSSVZFUl9OQU1FICJ2cF92ZHBhIgo+ICsKPiAr I2RlZmluZSBWUF9WRFBBX0ZFQVRVUkVTIFwKPiArCSgoMVVMTCA8PCBWSVJUSU9fRl9BTllfTEFZ T1VUKQkJCXwgXAo+ICsJICgxVUxMIDw8IFZJUlRJT19GX1ZFUlNJT05fMSkJCQl8IFwKPiArCSAo MVVMTCA8PCBWSVJUSU9fRl9PUkRFUl9QTEFURk9STSkJCXwgXAo+ICsJICgxVUxMIDw8IFZJUlRJ T19GX0lPTU1VX1BMQVRGT1JNKSkKPiArCj4gK3N0cnVjdCB2cF92cmluZyB7Cj4gKwl2b2lkIF9f aW9tZW0gKm5vdGlmeTsKPiArCWNoYXIgbXNpeF9uYW1lWzI1Nl07Cj4gKwlyZXNvdXJjZV9zaXpl X3Qgbm90aWZ5X3BhOwo+ICsJc3RydWN0IHZkcGFfY2FsbGJhY2sgY2I7Cj4gKwlpbnQgaXJxOwo+ ICt9Owo+ICsKPiArc3RydWN0IHZwX3ZkcGEgewo+ICsJc3RydWN0IHZkcGFfZGV2aWNlIHZkcGE7 Cj4gKwlzdHJ1Y3QgcGNpX2RldiAqcGRldjsKPiArCj4gKwlzdHJ1Y3QgdmlydGlvX2RldmljZV9p ZCBpZDsKPiArCj4gKwlzdHJ1Y3QgdnBfdnJpbmcgdnJpbmdbVlBfVkRQQV9NQVhfUVVFVUVdOwo+ ICsKPiArCS8qIFRoZSBJTyBtYXBwaW5nIGZvciB0aGUgUENJIGNvbmZpZyBzcGFjZSAqLwo+ICsJ dm9pZCBfX2lvbWVtICogY29uc3QgKmJhc2U7Cj4gKwlzdHJ1Y3QgdmlydGlvX3BjaV9jb21tb25f Y2ZnIF9faW9tZW0gKmNvbW1vbjsKPiArCXZvaWQgX19pb21lbSAqZGV2aWNlOwo+ICsJLyogQmFz ZSBvZiB2cSBub3RpZmljYXRpb25zICovCj4gKwl2b2lkIF9faW9tZW0gKm5vdGlmeTsKPiArCj4g KwkvKiBNdWx0aXBsaWVyIGZvciBxdWV1ZV9ub3RpZnlfb2ZmLiAqLwo+ICsJdTMyIG5vdGlmeV9v ZmZfbXVsdGlwbGllcjsKPiArCj4gKwlpbnQgbW9kZXJuX2JhcnM7Cj4gKwlpbnQgdmVjdG9yczsK PiArfTsKPiArCj4gK3N0YXRpYyBzdHJ1Y3QgdnBfdmRwYSAqdmRwYV90b192cChzdHJ1Y3QgdmRw YV9kZXZpY2UgKnZkcGEpCj4gK3sKPiArCXJldHVybiBjb250YWluZXJfb2YodmRwYSwgc3RydWN0 IHZwX3ZkcGEsIHZkcGEpOwo+ICt9Cj4gKwo+ICsvKgo+ICsgKiBUeXBlLXNhZmUgd3JhcHBlcnMg Zm9yIGlvIGFjY2Vzc2VzLgo+ICsgKiBVc2UgdGhlc2UgdG8gZW5mb3JjZSBhdCBjb21waWxlIHRp bWUgdGhlIGZvbGxvd2luZyBzcGVjIHJlcXVpcmVtZW50Ogo+ICsgKgo+ICsgKiBUaGUgZHJpdmVy IE1VU1QgYWNjZXNzIGVhY2ggZmllbGQgdXNpbmcgdGhlIOKAnG5hdHVyYWzigJ0gYWNjZXNzCj4g KyAqIG1ldGhvZCwgaS5lLiAzMi1iaXQgYWNjZXNzZXMgZm9yIDMyLWJpdCBmaWVsZHMsIDE2LWJp dCBhY2Nlc3Nlcwo+ICsgKiBmb3IgMTYtYml0IGZpZWxkcyBhbmQgOC1iaXQgYWNjZXNzZXMgZm9y IDgtYml0IGZpZWxkcy4KPiArICovCj4gK3N0YXRpYyBpbmxpbmUgdTggdnBfaW9yZWFkOCh1OCBf X2lvbWVtICphZGRyKQo+ICt7Cj4gKwlyZXR1cm4gaW9yZWFkOChhZGRyKTsKPiArfQo+ICtzdGF0 aWMgaW5saW5lIHUxNiB2cF9pb3JlYWQxNihfX2xlMTYgX19pb21lbSAqYWRkcikKPiArewo+ICsJ cmV0dXJuIGlvcmVhZDE2KGFkZHIpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIHUzMiB2cF9p b3JlYWQzMihfX2xlMzIgX19pb21lbSAqYWRkcikKPiArewo+ICsJcmV0dXJuIGlvcmVhZDMyKGFk ZHIpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW5saW5lIHZvaWQgdnBfaW93cml0ZTgodTggdmFsdWUs IHU4IF9faW9tZW0gKmFkZHIpCj4gK3sKPiArCWlvd3JpdGU4KHZhbHVlLCBhZGRyKTsKPiArfQo+ ICsKPiArc3RhdGljIGlubGluZSB2b2lkIHZwX2lvd3JpdGUxNih1MTYgdmFsdWUsIF9fbGUxNiBf X2lvbWVtICphZGRyKQo+ICt7Cj4gKwlpb3dyaXRlMTYodmFsdWUsIGFkZHIpOwo+ICt9Cj4gKwo+ ICtzdGF0aWMgaW5saW5lIHZvaWQgdnBfaW93cml0ZTMyKHUzMiB2YWx1ZSwgX19sZTMyIF9faW9t ZW0gKmFkZHIpCj4gK3sKPiArCWlvd3JpdGUzMih2YWx1ZSwgYWRkcik7Cj4gK30KPiArCj4gK3N0 YXRpYyB2b2lkIHZwX2lvd3JpdGU2NF90d29wYXJ0KHU2NCB2YWwsCj4gKwkJCQkgX19sZTMyIF9f aW9tZW0gKmxvLCBfX2xlMzIgX19pb21lbSAqaGkpCj4gK3sKPiArCXZwX2lvd3JpdGUzMigodTMy KXZhbCwgbG8pOwo+ICsJdnBfaW93cml0ZTMyKHZhbCA+PiAzMiwgaGkpOwo+ICt9Cj4gKwo+ICtz dGF0aWMgaW50IGZpbmRfY2FwYWJpbGl0eShzdHJ1Y3QgcGNpX2RldiAqZGV2LCB1OCBjZmdfdHlw ZSwKPiArCQkJICAgdTMyIGlvcmVzb3VyY2VfdHlwZXMsIGludCAqYmFycykKPiArewo+ICsJaW50 IHBvczsKPiArCj4gKwlmb3IgKHBvcyA9IHBjaV9maW5kX2NhcGFiaWxpdHkoZGV2LCBQQ0lfQ0FQ X0lEX1ZORFIpOwo+ICsJICAgICBwb3MgPiAwOwo+ICsJICAgICBwb3MgPSBwY2lfZmluZF9uZXh0 X2NhcGFiaWxpdHkoZGV2LCBwb3MsIFBDSV9DQVBfSURfVk5EUikpIHsKPiArCQl1OCB0eXBlLCBi YXI7Cj4gKwo+ICsJCXBjaV9yZWFkX2NvbmZpZ19ieXRlKGRldiwgcG9zICsgb2Zmc2V0b2Yoc3Ry dWN0IHZpcnRpb19wY2lfY2FwLAo+ICsJCQkJCQkJIGNmZ190eXBlKSwKPiArCQkJCSAgICAgJnR5 cGUpOwo+ICsJCXBjaV9yZWFkX2NvbmZpZ19ieXRlKGRldiwgcG9zICsgb2Zmc2V0b2Yoc3RydWN0 IHZpcnRpb19wY2lfY2FwLAo+ICsJCQkJCQkJIGJhciksCj4gKwkJCQkgICAgICZiYXIpOwo+ICsK PiArCQkvKiBJZ25vcmUgc3RydWN0dXJlcyB3aXRoIHJlc2VydmVkIEJBUiB2YWx1ZXMgKi8KPiAr CQlpZiAoYmFyID4gMHg1KQo+ICsJCQljb250aW51ZTsKPiArCj4gKwkJaWYgKHR5cGUgPT0gY2Zn X3R5cGUpIHsKPiArCQkJaWYgKHBjaV9yZXNvdXJjZV9sZW4oZGV2LCBiYXIpICYmCj4gKwkJCSAg ICBwY2lfcmVzb3VyY2VfZmxhZ3MoZGV2LCBiYXIpICYgaW9yZXNvdXJjZV90eXBlcykgewo+ICsJ CQkJKmJhcnMgfD0gKDEgPDwgYmFyKTsKPiArCQkJCXJldHVybiBwb3M7Cj4gKwkJCX0KPiArCQl9 Cj4gKwl9Cj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgX19pb21lbSAqbWFw X2NhcGFiaWxpdHkoc3RydWN0IHZwX3ZkcGEgKnZwX3ZkcGEsIGludCBvZmYsCj4gKwkJCQkgICAg cmVzb3VyY2Vfc2l6ZV90ICpwYSkKPiArewo+ICsJc3RydWN0IHBjaV9kZXYgKnBkZXYgPSB2cF92 ZHBhLT5wZGV2Owo+ICsJdTMyIG9mZnNldDsKPiArCXU4IGJhcjsKPiArCj4gKwlwY2lfcmVhZF9j b25maWdfYnl0ZShwZGV2LAo+ICsJCQkgICAgIG9mZiArIG9mZnNldG9mKHN0cnVjdCB2aXJ0aW9f cGNpX2NhcCwgYmFyKSwKPiArCQkJICAgICAmYmFyKTsKPiArCXBjaV9yZWFkX2NvbmZpZ19kd29y ZChwZGV2LAo+ICsJCQkgICAgICBvZmYgKyBvZmZzZXRvZihzdHJ1Y3QgdmlydGlvX3BjaV9jYXAs IG9mZnNldCksCj4gKwkJCSAgICAgICZvZmZzZXQpOwo+ICsKPiArCWlmIChwYSkKPiArCQkqcGEg PSBwY2lfcmVzb3VyY2Vfc3RhcnQocGRldiwgYmFyKSArIG9mZnNldDsKPiArCj4gKwlyZXR1cm4g dnBfdmRwYS0+YmFzZVtiYXJdICsgb2Zmc2V0Owo+ICt9Cj4gKwo+ICtzdGF0aWMgdTY0IHZwX3Zk cGFfZ2V0X2ZlYXR1cmVzKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSkKPiArewo+ICsJc3RydWN0 IHZwX3ZkcGEgKnZwX3ZkcGEgPSB2ZHBhX3RvX3ZwKHZkcGEpOwo+ICsJdTY0IGZlYXR1cmVzOwo+ ICsKPiArCXZwX2lvd3JpdGUzMigwLCAmdnBfdmRwYS0+Y29tbW9uLT5kZXZpY2VfZmVhdHVyZV9z ZWxlY3QpOwo+ICsJZmVhdHVyZXMgPSB2cF9pb3JlYWQzMigmdnBfdmRwYS0+Y29tbW9uLT5kZXZp Y2VfZmVhdHVyZSk7Cj4gKwl2cF9pb3dyaXRlMzIoMSwgJnZwX3ZkcGEtPmNvbW1vbi0+ZGV2aWNl X2ZlYXR1cmVfc2VsZWN0KTsKPiArCWZlYXR1cmVzIHw9ICgodTY0KXZwX2lvcmVhZDMyKCZ2cF92 ZHBhLT5jb21tb24tPmRldmljZV9mZWF0dXJlKSA8PCAzMik7Cj4gKwlmZWF0dXJlcyAmPSBWUF9W RFBBX0ZFQVRVUkVTOwo+ICsKPiArCXJldHVybiBmZWF0dXJlczsKPiArfQo+ICsKPiArc3RhdGlj IGludCB2cF92ZHBhX3NldF9mZWF0dXJlcyhzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHU2NCBm ZWF0dXJlcykKPiArewo+ICsJc3RydWN0IHZwX3ZkcGEgKnZwX3ZkcGEgPSB2ZHBhX3RvX3ZwKHZk cGEpOwo+ICsKPiArCXZwX2lvd3JpdGUzMigwLCAmdnBfdmRwYS0+Y29tbW9uLT5ndWVzdF9mZWF0 dXJlX3NlbGVjdCk7Cj4gKwl2cF9pb3dyaXRlMzIoKHUzMilmZWF0dXJlcywgJnZwX3ZkcGEtPmNv bW1vbi0+Z3Vlc3RfZmVhdHVyZSk7Cj4gKwl2cF9pb3dyaXRlMzIoMSwgJnZwX3ZkcGEtPmNvbW1v bi0+Z3Vlc3RfZmVhdHVyZV9zZWxlY3QpOwo+ICsJdnBfaW93cml0ZTMyKGZlYXR1cmVzID4+IDMy LCAmdnBfdmRwYS0+Y29tbW9uLT5ndWVzdF9mZWF0dXJlKTsKPiArCj4gKwlyZXR1cm4gMDsKPiAr fQo+ICsKPiArc3RhdGljIHU4IHZwX3ZkcGFfZ2V0X3N0YXR1cyhzdHJ1Y3QgdmRwYV9kZXZpY2Ug KnZkcGEpCj4gK3sKPiArCXN0cnVjdCB2cF92ZHBhICp2cF92ZHBhID0gdmRwYV90b192cCh2ZHBh KTsKPiArCj4gKwlyZXR1cm4gdnBfaW9yZWFkOCgmdnBfdmRwYS0+Y29tbW9uLT5kZXZpY2Vfc3Rh dHVzKTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdnBfdmRwYV9mcmVlX2lycShzdHJ1Y3QgdnBf dmRwYSAqdnBfdmRwYSkKPiArewo+ICsJc3RydWN0IHBjaV9kZXYgKnBkZXYgPSB2cF92ZHBhLT5w ZGV2Owo+ICsJaW50IGk7Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IFZQX1ZEUEFfTUFYX1FVRVVF OyBpKyspIHsKPiArCQlpZiAodnBfdmRwYS0+dnJpbmdbaV0uaXJxICE9IC0xKSB7Cj4gKwkJCXZw X2lvd3JpdGUxNihpLCAmdnBfdmRwYS0+Y29tbW9uLT5xdWV1ZV9zZWxlY3QpOwo+ICsJCQl2cF9p b3dyaXRlMTYoVklSVElPX01TSV9OT19WRUNUT1IsCj4gKwkJCQkgICAgICZ2cF92ZHBhLT5jb21t b24tPnF1ZXVlX21zaXhfdmVjdG9yKTsKPiArCQkJZGV2bV9mcmVlX2lycSgmcGRldi0+ZGV2LCB2 cF92ZHBhLT52cmluZ1tpXS5pcnEsCj4gKwkJCQkgICAgICAmdnBfdmRwYS0+dnJpbmdbaV0pOwo+ ICsJCQl2cF92ZHBhLT52cmluZ1tpXS5pcnEgPSAtMTsKPiArCQl9Cj4gKwl9Cj4gKwo+ICsJaWYg KHZwX3ZkcGEtPnZlY3RvcnMpIHsKPiArCQlwY2lfZnJlZV9pcnFfdmVjdG9ycyhwZGV2KTsKPiAr CQl2cF92ZHBhLT52ZWN0b3JzID0gMDsKPiArCX0KPiArfQo+ICsKPiArc3RhdGljIGlycXJldHVy bl90IHZwX3ZkcGFfaW50cl9oYW5kbGVyKGludCBpcnEsIHZvaWQgKmFyZykKPiArewo+ICsJc3Ry dWN0IHZwX3ZyaW5nICp2cmluZyA9IGFyZzsKPiArCj4gKwlpZiAodnJpbmctPmNiLmNhbGxiYWNr KQo+ICsJCXJldHVybiB2cmluZy0+Y2IuY2FsbGJhY2sodnJpbmctPmNiLnByaXZhdGUpOwo+ICsK PiArCXJldHVybiBJUlFfSEFORExFRDsKPiArfQo+ICsKPiArc3RhdGljIGludCB2cF92ZHBhX3Jl cXVlc3RfaXJxKHN0cnVjdCB2cF92ZHBhICp2cF92ZHBhKQo+ICt7Cj4gKwlzdHJ1Y3QgcGNpX2Rl diAqcGRldiA9IHZwX3ZkcGEtPnBkZXY7Cj4gKwlpbnQgaSwgcmV0LCBpcnE7Cj4gKwo+ICsJcmV0 ID0gcGNpX2FsbG9jX2lycV92ZWN0b3JzKHBkZXYsIFZQX1ZEUEFfTUFYX1FVRVVFLAo+ICsJCQkJ ICAgIFZQX1ZEUEFfTUFYX1FVRVVFLCBQQ0lfSVJRX01TSVgpOwo+ICsJaWYgKHJldCAhPSBWUF9W RFBBX01BWF9RVUVVRSkgewo+ICsJCWRldl9lcnIoJnBkZXYtPmRldiwgInZwX3ZkcGE6IGZhaWwg dG8gYWxsb2NhdGUgaXJxIHZlY3RvcnNcbiIpOwo+ICsJCXJldHVybiByZXQ7Cj4gKwl9Cj4gKwo+ ICsJdnBfdmRwYS0+dmVjdG9ycyA9IFZQX1ZEUEFfTUFYX1FVRVVFOwo+ICsKPiArCWZvciAoaSA9 IDA7IGkgPCBWUF9WRFBBX01BWF9RVUVVRTsgaSsrKSB7Cj4gKwkJc25wcmludGYodnBfdmRwYS0+ dnJpbmdbaV0ubXNpeF9uYW1lLCAyNTYsCj4gKwkJCSJ2cC12ZHBhWyVzXS0lZFxuIiwgcGNpX25h bWUocGRldiksIGkpOwo+ICsJCWlycSA9IHBjaV9pcnFfdmVjdG9yKHBkZXYsIGkpOwo+ICsJCXJl dCA9IGRldm1fcmVxdWVzdF9pcnEoJnBkZXYtPmRldiwgaXJxLAo+ICsJCQkJICAgICAgIHZwX3Zk cGFfaW50cl9oYW5kbGVyLAo+ICsJCQkJICAgICAgIDAsIHZwX3ZkcGEtPnZyaW5nW2ldLm1zaXhf bmFtZSwKPiArCQkJCSAgICAgICAmdnBfdmRwYS0+dnJpbmdbaV0pOwo+ICsJCWlmIChyZXQpIHsK PiArCQkJZGV2X2VycigmcGRldi0+ZGV2LCAidnBfdmRwYTogZmFpbCB0byByZXF1ZXN0IGlycSBm b3IgdnEgJWRcbiIsCj4gKwkJCQlpKTsKPiArCQkJZ290byBlcnI7Cj4gKwkJfQo+ICsJCXZwX2lv d3JpdGUxNihpLCAmdnBfdmRwYS0+Y29tbW9uLT5xdWV1ZV9zZWxlY3QpOwo+ICsJCXZwX2lvd3Jp dGUxNihpLCAmdnBfdmRwYS0+Y29tbW9uLT5xdWV1ZV9tc2l4X3ZlY3Rvcik7Cj4gKwkJdnBfdmRw YS0+dnJpbmdbaV0uaXJxID0gaXJxOwo+ICsJfQo+ICsKPiArCXJldHVybiAwOwo+ICtlcnI6Cj4g Kwl2cF92ZHBhX2ZyZWVfaXJxKHZwX3ZkcGEpOwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiAr c3RhdGljIHZvaWQgdnBfdmRwYV9zZXRfc3RhdHVzKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSwg dTggc3RhdHVzKQo+ICt7Cj4gKwlzdHJ1Y3QgdnBfdmRwYSAqdnBfdmRwYSA9IHZkcGFfdG9fdnAo dmRwYSk7Cj4gKwl1OCBzID0gdnBfdmRwYV9nZXRfc3RhdHVzKHZkcGEpOwo+ICsKPiArCWlmIChz dGF0dXMgJiBWSVJUSU9fQ09ORklHX1NfRFJJVkVSX09LICYmCj4gKwkgICAgIShzICYgVklSVElP X0NPTkZJR19TX0RSSVZFUl9PSykpIHsKPiArCQl2cF92ZHBhX3JlcXVlc3RfaXJxKHZwX3ZkcGEp Owo+ICsJfQo+ICsKPiArCXZwX2lvd3JpdGU4KHN0YXR1cywgJnZwX3ZkcGEtPmNvbW1vbi0+ZGV2 aWNlX3N0YXR1cyk7Cj4gKwo+ICsJaWYgKCEoc3RhdHVzICYgVklSVElPX0NPTkZJR19TX0RSSVZF Ul9PSykgJiYKPiArCSAgICAocyAmIFZJUlRJT19DT05GSUdfU19EUklWRVJfT0spKQo+ICsJCXZw X3ZkcGFfZnJlZV9pcnEodnBfdmRwYSk7Cj4gK30KPiArCj4gK3N0YXRpYyB1MTYgdnBfdmRwYV9n ZXRfdnFfbnVtX21heChzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEpCj4gK3sKPiArCXN0cnVjdCB2 cF92ZHBhICp2cF92ZHBhID0gdmRwYV90b192cCh2ZHBhKTsKPiArCj4gKwlyZXR1cm4gdnBfaW9y ZWFkMTYoJnZwX3ZkcGEtPmNvbW1vbi0+cXVldWVfc2l6ZSk7Cj4gK30KPiArCj4gK3N0YXRpYyB1 NjQgdnBfdmRwYV9nZXRfdnFfc3RhdGUoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhLCB1MTYgcWlk KQo+ICt7Cj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiArc3RhdGljIHN0cnVjdCB2ZHBhX25vdGlm aWNhdGlvbl9hcmVhCj4gK3ZwX3ZkcGFfZ2V0X3ZxX25vdGlmaWNhdGlvbihzdHJ1Y3QgdmRwYV9k ZXZpY2UgKnZkcGEsIHUxNiBxaWQpCj4gK3sKPiArCXN0cnVjdCB2cF92ZHBhICp2cF92ZHBhID0g dmRwYV90b192cCh2ZHBhKTsKPiArCXN0cnVjdCB2ZHBhX25vdGlmaWNhdGlvbl9hcmVhIG5vdGlm eTsKPiArCj4gKwlub3RpZnkuYWRkciA9IHZwX3ZkcGEtPnZyaW5nW3FpZF0ubm90aWZ5X3BhOwo+ ICsJbm90aWZ5LnNpemUgPSB2cF92ZHBhLT5ub3RpZnlfb2ZmX211bHRpcGxpZXI7Cj4gKwo+ICsJ cmV0dXJuIG5vdGlmeTsKPiArfQo+ICsKPiArc3RhdGljIGludCB2cF92ZHBhX3NldF92cV9zdGF0 ZShzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsIHUxNiBxaWQsCj4gKwkJCQl1NjQgbnVtKQo+ICt7 Cj4gKwkvKiBOb3RlIHRoYXQgdGhpcyBpcyBub3Qgc3VwcG9ydGVkIGJ5IHZpcnRpbyBzcGVjaWZp Y2F0aW9uLCBzbwo+ICsJICogd2UgcmV0dXJuIC1FTk9UU1VQUCBoZXJlLiBUaGlzIG1lYW5zIHdl IGNhbid0IHN1cHBvcnQgbGl2ZQo+ICsJICogbWlncmF0aW9uLCB2aG9zdCBkZXZpY2Ugc3RhcnQv c3RvcC4KPiArCSAqLwo+ICsKPiArCXJldHVybiAtRU5PVFNVUFA7Cj4gK30KPiArCj4gK3N0YXRp YyB2b2lkIHZwX3ZkcGFfc2V0X3ZxX2NiKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSwgdTE2IHFp ZCwKPiArCQkJICAgICAgc3RydWN0IHZkcGFfY2FsbGJhY2sgKmNiKQo+ICt7Cj4gKwlzdHJ1Y3Qg dnBfdmRwYSAqdnBfdmRwYSA9IHZkcGFfdG9fdnAodmRwYSk7Cj4gKwo+ICsJdnBfdmRwYS0+dnJp bmdbcWlkXS5jYiA9ICpjYjsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdnBfdmRwYV9zZXRfdnFf cmVhZHkoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhLAo+ICsJCQkJIHUxNiBxaWQsIGJvb2wgcmVh ZHkpCj4gK3sKPiArCXN0cnVjdCB2cF92ZHBhICp2cF92ZHBhID0gdmRwYV90b192cCh2ZHBhKTsK PiArCj4gKwl2cF9pb3dyaXRlMTYocWlkLCAmdnBfdmRwYS0+Y29tbW9uLT5xdWV1ZV9zZWxlY3Qp Owo+ICsJdnBfaW93cml0ZTE2KHJlYWR5LCAmdnBfdmRwYS0+Y29tbW9uLT5xdWV1ZV9lbmFibGUp Owo+ICt9Cj4gKwo+ICtzdGF0aWMgYm9vbCB2cF92ZHBhX2dldF92cV9yZWFkeShzdHJ1Y3QgdmRw YV9kZXZpY2UgKnZkcGEsIHUxNiBxaWQpCj4gK3sKPiArCXN0cnVjdCB2cF92ZHBhICp2cF92ZHBh ID0gdmRwYV90b192cCh2ZHBhKTsKPiArCj4gKwl2cF9pb3dyaXRlMTYocWlkLCAmdnBfdmRwYS0+ Y29tbW9uLT5xdWV1ZV9zZWxlY3QpOwo+ICsKPiArCXJldHVybiB2cF9pb3JlYWQxNigmdnBfdmRw YS0+Y29tbW9uLT5xdWV1ZV9lbmFibGUpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2cF92ZHBh X3NldF92cV9udW0oc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhLCB1MTYgcWlkLAo+ICsJCQkgICAg ICAgdTMyIG51bSkKPiArewo+ICsJc3RydWN0IHZwX3ZkcGEgKnZwX3ZkcGEgPSB2ZHBhX3RvX3Zw KHZkcGEpOwo+ICsKPiArCXZwX2lvd3JpdGUxNihudW0sICZ2cF92ZHBhLT5jb21tb24tPnF1ZXVl X3NpemUpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHZwX3ZkcGFfc2V0X3ZxX2FkZHJlc3Moc3Ry dWN0IHZkcGFfZGV2aWNlICp2ZHBhLCB1MTYgcWlkLAo+ICsJCQkJICB1NjQgZGVzY19hcmVhLCB1 NjQgZHJpdmVyX2FyZWEsCj4gKwkJCQkgIHU2NCBkZXZpY2VfYXJlYSkKPiArewo+ICsJc3RydWN0 IHZwX3ZkcGEgKnZwX3ZkcGEgPSB2ZHBhX3RvX3ZwKHZkcGEpOwo+ICsJc3RydWN0IHZpcnRpb19w Y2lfY29tbW9uX2NmZyBfX2lvbWVtICpjZmcgPSB2cF92ZHBhLT5jb21tb247Cj4gKwo+ICsJdnBf aW93cml0ZTE2KHFpZCwgJmNmZy0+cXVldWVfc2VsZWN0KTsKPiArCXZwX2lvd3JpdGU2NF90d29w YXJ0KGRlc2NfYXJlYSwKPiArCQkJICAgICAmY2ZnLT5xdWV1ZV9kZXNjX2xvLCAmY2ZnLT5xdWV1 ZV9kZXNjX2hpKTsKPiArCXZwX2lvd3JpdGU2NF90d29wYXJ0KGRyaXZlcl9hcmVhLAo+ICsJCQkg ICAgICZjZmctPnF1ZXVlX2F2YWlsX2xvLCAmY2ZnLT5xdWV1ZV9hdmFpbF9oaSk7Cj4gKwl2cF9p b3dyaXRlNjRfdHdvcGFydChkZXZpY2VfYXJlYSwKPiArCQkJICAgICAmY2ZnLT5xdWV1ZV91c2Vk X2xvLCAmY2ZnLT5xdWV1ZV91c2VkX2hpKTsKPiArCj4gKwlyZXR1cm4gMDsKPiArfQo+ICsKPiAr c3RhdGljIHZvaWQgdnBfdmRwYV9raWNrX3ZxKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSwgdTE2 IHFpZCkKPiArewo+ICsJc3RydWN0IHZwX3ZkcGEgKnZwX3ZkcGEgPSB2ZHBhX3RvX3ZwKHZkcGEp Owo+ICsKPiArCXZwX2lvd3JpdGUxNihxaWQsIHZwX3ZkcGEtPnZyaW5nW3FpZF0ubm90aWZ5KTsK PiArfQo+ICsKPiArc3RhdGljIHUzMiB2cF92ZHBhX2dldF9nZW5lcmF0aW9uKHN0cnVjdCB2ZHBh X2RldmljZSAqdmRwYSkKPiArewo+ICsJc3RydWN0IHZwX3ZkcGEgKnZwX3ZkcGEgPSB2ZHBhX3Rv X3ZwKHZkcGEpOwo+ICsKPiArCXJldHVybiB2cF9pb3JlYWQ4KCZ2cF92ZHBhLT5jb21tb24tPmNv bmZpZ19nZW5lcmF0aW9uKTsKPiArfQo+ICsKPiArc3RhdGljIHUzMiB2cF92ZHBhX2dldF9kZXZp Y2VfaWQoc3RydWN0IHZkcGFfZGV2aWNlICp2ZHBhKQo+ICt7Cj4gKwlzdHJ1Y3QgdnBfdmRwYSAq dnBfdmRwYSA9IHZkcGFfdG9fdnAodmRwYSk7Cj4gKwo+ICsJcmV0dXJuIHZwX3ZkcGEtPmlkLmRl dmljZTsKPiArfQo+ICsKPiArc3RhdGljIHUzMiB2cF92ZHBhX2dldF92ZW5kb3JfaWQoc3RydWN0 IHZkcGFfZGV2aWNlICp2ZHBhKQo+ICt7Cj4gKwlzdHJ1Y3QgdnBfdmRwYSAqdnBfdmRwYSA9IHZk cGFfdG9fdnAodmRwYSk7Cj4gKwo+ICsJcmV0dXJuIHZwX3ZkcGEtPmlkLnZlbmRvcjsKPiArfQo+ ICsKPiArc3RhdGljIHUzMiB2cF92ZHBhX2dldF92cV9hbGlnbihzdHJ1Y3QgdmRwYV9kZXZpY2Ug KnZkcGEpCj4gK3sKPiArCXJldHVybiBQQUdFX1NJWkU7Cj4gK30KPiArCj4gK3N0YXRpYyB2b2lk IHZwX3ZkcGFfZ2V0X2NvbmZpZyhzdHJ1Y3QgdmRwYV9kZXZpY2UgKnZkcGEsCj4gKwkJCSAgICAg ICB1bnNpZ25lZCBpbnQgb2Zmc2V0LAo+ICsJCQkgICAgICAgdm9pZCAqYnVmLCB1bnNpZ25lZCBp bnQgbGVuKQo+ICt7Cj4gKwlzdHJ1Y3QgdnBfdmRwYSAqdnBfdmRwYSA9IHZkcGFfdG9fdnAodmRw YSk7Cj4gKwl1OCBvbGQsIG5ldzsKPiArCXU4ICpwOwo+ICsJaW50IGk7Cj4gKwo+ICsJZG8gewo+ ICsJCW9sZCA9IHZwX2lvcmVhZDgoJnZwX3ZkcGEtPmNvbW1vbi0+Y29uZmlnX2dlbmVyYXRpb24p Owo+ICsJCXAgPSBidWY7Cj4gKwkJZm9yIChpID0gMDsgaSA8IGxlbjsgaSsrKQo+ICsJCQkqcCsr ID0gdnBfaW9yZWFkOCh2cF92ZHBhLT5kZXZpY2UgKyBvZmZzZXQgKyBpKTsKPiArCj4gKwkJbmV3 ID0gdnBfaW9yZWFkOCgmdnBfdmRwYS0+Y29tbW9uLT5jb25maWdfZ2VuZXJhdGlvbik7Cj4gKwl9 IHdoaWxlIChvbGQgIT0gbmV3KTsKPiArfQo+ICsKPiArc3RhdGljIHZvaWQgdnBfdmRwYV9zZXRf Y29uZmlnKHN0cnVjdCB2ZHBhX2RldmljZSAqdmRwYSwKPiArCQkJICAgICAgIHVuc2lnbmVkIGlu dCBvZmZzZXQsIGNvbnN0IHZvaWQgKmJ1ZiwKPiArCQkJICAgICAgIHVuc2lnbmVkIGludCBsZW4p Cj4gK3sKPiArCXN0cnVjdCB2cF92ZHBhICp2cF92ZHBhID0gdmRwYV90b192cCh2ZHBhKTsKPiAr CWNvbnN0IHU4ICpwID0gYnVmOwo+ICsJaW50IGk7Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IGxl bjsgaSsrKQo+ICsJCXZwX2lvd3JpdGU4KCpwKyssIHZwX3ZkcGEtPmRldmljZSArIG9mZnNldCAr IGkpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgdm9pZCB2cF92ZHBhX3NldF9jb25maWdfY2Ioc3RydWN0 IHZkcGFfZGV2aWNlICp2ZHBhLAo+ICsJCQkJICBzdHJ1Y3QgdmRwYV9jYWxsYmFjayAqY2IpCj4g K3sKPiArCS8qIFdlIGRvbid0IHN1cHBvcnQgY29uZmlnIGludGVycnVwdCAqLwo+ICt9Cj4gKwo+ ICtzdGF0aWMgY29uc3Qgc3RydWN0IHZkcGFfY29uZmlnX29wcyB2cF92ZHBhX29wcyA9IHsKPiAr CS5nZXRfZmVhdHVyZXMJPSB2cF92ZHBhX2dldF9mZWF0dXJlcywKPiArCS5zZXRfZmVhdHVyZXMJ PSB2cF92ZHBhX3NldF9mZWF0dXJlcywKPiArCS5nZXRfc3RhdHVzCT0gdnBfdmRwYV9nZXRfc3Rh dHVzLAo+ICsJLnNldF9zdGF0dXMJPSB2cF92ZHBhX3NldF9zdGF0dXMsCj4gKwkuZ2V0X3ZxX251 bV9tYXgJPSB2cF92ZHBhX2dldF92cV9udW1fbWF4LAo+ICsJLmdldF92cV9zdGF0ZQk9IHZwX3Zk cGFfZ2V0X3ZxX3N0YXRlLAo+ICsJLmdldF92cV9ub3RpZmljYXRpb24gPSB2cF92ZHBhX2dldF92 cV9ub3RpZmljYXRpb24sCj4gKwkuc2V0X3ZxX3N0YXRlCT0gdnBfdmRwYV9zZXRfdnFfc3RhdGUs Cj4gKwkuc2V0X3ZxX2NiCT0gdnBfdmRwYV9zZXRfdnFfY2IsCj4gKwkuc2V0X3ZxX3JlYWR5CT0g dnBfdmRwYV9zZXRfdnFfcmVhZHksCj4gKwkuZ2V0X3ZxX3JlYWR5CT0gdnBfdmRwYV9nZXRfdnFf cmVhZHksCj4gKwkuc2V0X3ZxX251bQk9IHZwX3ZkcGFfc2V0X3ZxX251bSwKPiArCS5zZXRfdnFf YWRkcmVzcwk9IHZwX3ZkcGFfc2V0X3ZxX2FkZHJlc3MsCj4gKwkua2lja192cQk9IHZwX3ZkcGFf a2lja192cSwKPiArCS5nZXRfZ2VuZXJhdGlvbgk9IHZwX3ZkcGFfZ2V0X2dlbmVyYXRpb24sCj4g KwkuZ2V0X2RldmljZV9pZAk9IHZwX3ZkcGFfZ2V0X2RldmljZV9pZCwKPiArCS5nZXRfdmVuZG9y X2lkCT0gdnBfdmRwYV9nZXRfdmVuZG9yX2lkLAo+ICsJLmdldF92cV9hbGlnbgk9IHZwX3ZkcGFf Z2V0X3ZxX2FsaWduLAo+ICsJLmdldF9jb25maWcJPSB2cF92ZHBhX2dldF9jb25maWcsCj4gKwku c2V0X2NvbmZpZwk9IHZwX3ZkcGFfc2V0X2NvbmZpZywKPiArCS5zZXRfY29uZmlnX2NiICA9IHZw X3ZkcGFfc2V0X2NvbmZpZ19jYiwKPiArfTsKPiArCj4gK3N0YXRpYyBpbnQgdnBfdmRwYV9wcm9i ZShzdHJ1Y3QgcGNpX2RldiAqcGRldiwgY29uc3Qgc3RydWN0IHBjaV9kZXZpY2VfaWQgKmlkKQo+ ICt7Cj4gKwlzdHJ1Y3QgZGV2aWNlICpkZXYgPSAmcGRldi0+ZGV2Owo+ICsJc3RydWN0IHZwX3Zk cGEgKnZwX3ZkcGE7Cj4gKwlpbnQgY29tbW9uLCBub3RpZnksIGRldmljZSwgcmV0LCBpOwo+ICsJ c3RydWN0IHZpcnRpb19kZXZpY2VfaWQgdmlydGlvX2lkOwo+ICsJcmVzb3VyY2Vfc2l6ZV90IG5v dGlmeV9wYTsKPiArCXUxNiBub3RpZnlfb2ZmOwo+ICsKPiArCS8qIFdlIG9ubHkgb3duIGRldmlj ZXMgPj0gMHgxMDAwIGFuZCA8PSAweDEwN2Y6IGxlYXZlIHRoZSByZXN0LiAqLwo+ICsJaWYgKHBk ZXYtPmRldmljZSA8IDB4MTAwMCB8fCBwZGV2LT5kZXZpY2UgPiAweDEwN2YpCj4gKwkJcmV0dXJu IC1FTk9ERVY7Cj4gKwo+ICsJaWYgKHBkZXYtPmRldmljZSA8IDB4MTA0MCkgewo+ICsJCS8qIFRy YW5zaXRpb25hbCBkZXZpY2VzOiB1c2UgdGhlIFBDSSBzdWJzeXN0ZW0gZGV2aWNlIGlkIGFzCj4g KwkJICogdmlydGlvIGRldmljZSBpZCwgc2FtZSBhcyBsZWdhY3kgZHJpdmVyIGFsd2F5cyBkaWQu Cj4gKwkJICovCj4gKwkJdmlydGlvX2lkLmRldmljZSA9IHBkZXYtPnN1YnN5c3RlbV9kZXZpY2U7 Cj4gKwl9IGVsc2Ugewo+ICsJCS8qIE1vZGVybiBkZXZpY2VzOiBzaW1wbHkgdXNlIFBDSSBkZXZp Y2UgaWQsCj4gKwkJICogYnV0IHN0YXJ0IGZyb20gMHgxMDQwLgo+ICsJCSAqLwo+ICsJCXZpcnRp b19pZC5kZXZpY2UgPSBwZGV2LT5kZXZpY2UgLSAweDEwNDA7Cj4gKwl9Cj4gKwl2aXJ0aW9faWQu dmVuZG9yID0gcGRldi0+c3Vic3lzdGVtX3ZlbmRvcjsKPiArCj4gKwlyZXQgPSBwY2ltX2VuYWJs ZV9kZXZpY2UocGRldik7Cj4gKwlpZiAocmV0KSB7Cj4gKwkJZGV2X2VycihkZXYsICJ2cF92ZHBh OiBGYWlsIHRvIGVuYWJsZSBQQ0kgZGV2aWNlXG4iKTsKPiArCQlyZXR1cm4gcmV0Owo+ICsJfQo+ ICsKPiArCXZwX3ZkcGEgPSB2ZHBhX2FsbG9jX2RldmljZShzdHJ1Y3QgdnBfdmRwYSwgdmRwYSwK PiArCQkJCSAgICBkZXYsICZ2cF92ZHBhX29wcyk7Cj4gKwlpZiAodnBfdmRwYSA9PSBOVUxMKSB7 Cj4gKwkJZGV2X2VycihkZXYsICJ2cF92ZHBhOiBGYWlsZWQgdG8gYWxsb2NhdGUgdkRQQSBzdHJ1 Y3R1cmVcbiIpOwo+ICsJCXJldHVybiAtRU5PTUVNOwo+ICsJfQo+ICsKPiArCXBjaV9zZXRfbWFz dGVyKHBkZXYpOwo+ICsJcGNpX3NldF9kcnZkYXRhKHBkZXYsIHZwX3ZkcGEpOwo+ICsKPiArCXZw X3ZkcGEtPnBkZXYgPSBwZGV2Owo+ICsJdnBfdmRwYS0+dmRwYS5kbWFfZGV2ID0gJnBkZXYtPmRl djsKPiArCj4gKwljb21tb24gPSBmaW5kX2NhcGFiaWxpdHkocGRldiwgVklSVElPX1BDSV9DQVBf Q09NTU9OX0NGRywKPiArCQkJCSBJT1JFU09VUkNFX0lPIHwgSU9SRVNPVVJDRV9NRU0sCj4gKwkJ CQkgJnZwX3ZkcGEtPm1vZGVybl9iYXJzKTsKPiArCWlmICghY29tbW9uKSB7Cj4gKwkJZGV2X2Vy cigmcGRldi0+ZGV2LAo+ICsJCQkidnBfdmRwYTogbGVnYWN5IGRldmljZSBpcyBub3Qgc3VwcG9y dGVkXG4iKTsKPiArCQlyZXQgPSAtRU5PREVWOwo+ICsJCWdvdG8gZXJyOwo+ICsJfQo+ICsKPiAr CW5vdGlmeSA9IGZpbmRfY2FwYWJpbGl0eShwZGV2LCBWSVJUSU9fUENJX0NBUF9OT1RJRllfQ0ZH LAo+ICsJCQkJIElPUkVTT1VSQ0VfSU8gfCBJT1JFU09VUkNFX01FTSwKPiArCQkJCSAmdnBfdmRw YS0+bW9kZXJuX2JhcnMpOwo+ICsJaWYgKCFub3RpZnkpIHsKPiArCQlkZXZfZXJyKCZwZGV2LT5k ZXYsCj4gKwkJCSJ2cF92ZHBhOiBtaXNzaW5nIG5vdGlmaWNhdGlvbiBjYXBhYmlsaXRpZXNcbiIp Owo+ICsJCXJldCA9IC1FSU5WQUw7Cj4gKwkJZ290byBlcnI7Cj4gKwl9Cj4gKwo+ICsJZGV2aWNl ID0gZmluZF9jYXBhYmlsaXR5KHBkZXYsIFZJUlRJT19QQ0lfQ0FQX0RFVklDRV9DRkcsCj4gKwkJ CQkgSU9SRVNPVVJDRV9JTyB8IElPUkVTT1VSQ0VfTUVNLAo+ICsJCQkJICZ2cF92ZHBhLT5tb2Rl cm5fYmFycyk7Cj4gKwlpZiAoIWRldmljZSkgewo+ICsJCWRldl9lcnIoJnBkZXYtPmRldiwKPiAr CQkJInZwX3ZkcGE6IG1pc3NpbmcgZGV2aWNlIGNhcGFiaWxpdGllc1xuIik7Cj4gKwkJcmV0ID0g LUVJTlZBTDsKPiArCQlnb3RvIGVycjsKPiArCX0KPiArCj4gKwlyZXQgPSBwY2ltX2lvbWFwX3Jl Z2lvbnMocGRldiwgdnBfdmRwYS0+bW9kZXJuX2JhcnMsCj4gKwkJCQkgVlBfVkRQQV9EUklWRVJf TkFNRSk7Cj4gKwlpZiAocmV0KQo+ICsJCWdvdG8gZXJyOwo+ICsKPiArCXZwX3ZkcGEtPmJhc2Ug PSBwY2ltX2lvbWFwX3RhYmxlKHBkZXYpOwo+ICsKPiArCXJldCA9IGRtYV9zZXRfbWFza19hbmRf Y29oZXJlbnQoJnBkZXYtPmRldiwgRE1BX0JJVF9NQVNLKDY0KSk7Cj4gKwlpZiAocmV0KQo+ICsJ CXJldCA9IGRtYV9zZXRfbWFza19hbmRfY29oZXJlbnQoJnBkZXYtPmRldiwKPiArCQkJCQkJRE1B X0JJVF9NQVNLKDMyKSk7Cj4gKwlpZiAocmV0KQo+ICsJCWRldl93YXJuKCZwZGV2LT5kZXYsICJG YWlsZWQgdG8gZW5hYmxlIDY0LWJpdCBvciAzMi1iaXQgRE1BLiAgVHJ5aW5nIHRvIGNvbnRpbnVl LCBidXQgdGhpcyBtaWdodCBub3Qgd29yay5cbiIpOwo+ICsKPiArCXZwX3ZkcGEtPmRldmljZSA9 IG1hcF9jYXBhYmlsaXR5KHZwX3ZkcGEsIGRldmljZSwgTlVMTCk7Cj4gKwl2cF92ZHBhLT5ub3Rp ZnkgPSBtYXBfY2FwYWJpbGl0eSh2cF92ZHBhLCBub3RpZnksICZub3RpZnlfcGEpOwo+ICsJdnBf dmRwYS0+Y29tbW9uID0gbWFwX2NhcGFiaWxpdHkodnBfdmRwYSwgY29tbW9uLCBOVUxMKTsKPiAr CXZwX3ZkcGEtPmlkID0gdmlydGlvX2lkOwo+ICsKPiArCXJldCA9IHZkcGFfcmVnaXN0ZXJfZGV2 aWNlKCZ2cF92ZHBhLT52ZHBhKTsKPiArCWlmIChyZXQpIHsKPiArCQlkZXZfZXJyKCZwZGV2LT5k ZXYsICJGYWlsZWQgdG8gcmVnaXN0ZXIgdG8gdmRwYSBidXNcbiIpOwo+ICsJCWdvdG8gZXJyOwo+ ICsJfQo+ICsKPiArCXBjaV9yZWFkX2NvbmZpZ19kd29yZChwZGV2LCBub3RpZnkgKyBzaXplb2Yo c3RydWN0IHZpcnRpb19wY2lfY2FwKSwKPiArCQkJICAgICAgJnZwX3ZkcGEtPm5vdGlmeV9vZmZf bXVsdGlwbGllcik7Cj4gKwo+ICsJZm9yIChpID0gMDsgaSA8IFZQX1ZEUEFfTUFYX1FVRVVFOyBp KyspIHsKPiArCQl2cF9pb3dyaXRlMTYoaSwgJnZwX3ZkcGEtPmNvbW1vbi0+cXVldWVfc2VsZWN0 KTsKPiArCQlub3RpZnlfb2ZmID0gdnBfaW9yZWFkMTYoJnZwX3ZkcGEtPmNvbW1vbi0+cXVldWVf bm90aWZ5X29mZik7Cj4gKwkJdnBfdmRwYS0+dnJpbmdbaV0uaXJxID0gLTE7Cj4gKwkJdnBfdmRw YS0+dnJpbmdbaV0ubm90aWZ5ID0gdnBfdmRwYS0+bm90aWZ5ICsKPiArCQkJbm90aWZ5X29mZiAq IHZwX3ZkcGEtPm5vdGlmeV9vZmZfbXVsdGlwbGllcjsKPiArCQl2cF92ZHBhLT52cmluZ1tpXS5u b3RpZnlfcGEgPSBub3RpZnlfcGEgKwo+ICsJCQlub3RpZnlfb2ZmICogdnBfdmRwYS0+bm90aWZ5 X29mZl9tdWx0aXBsaWVyOwo+ICsJfQo+ICsKPiArCXJldHVybiAwOwo+ICsKPiArZXJyOgo+ICsJ cHV0X2RldmljZSgmdnBfdmRwYS0+dmRwYS5kZXYpOwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsK PiArc3RhdGljIHZvaWQgdnBfdmRwYV9yZW1vdmUoc3RydWN0IHBjaV9kZXYgKnBkZXYpCj4gK3sK PiArCXN0cnVjdCB2cF92ZHBhICp2cF92ZHBhID0gcGNpX2dldF9kcnZkYXRhKHBkZXYpOwo+ICsK PiArCXZkcGFfdW5yZWdpc3Rlcl9kZXZpY2UoJnZwX3ZkcGEtPnZkcGEpOwo+ICt9Cj4gKwo+ICtz dGF0aWMgc3RydWN0IHBjaV9kcml2ZXIgdnBfdmRwYV9kcml2ZXIgPSB7Cj4gKwkubmFtZQkJPSAi dnAtdmRwYSIsCj4gKwkuaWRfdGFibGUJPSBOVUxMLCAvKiBvbmx5IGR5bmFtaWMgaWRzICovCj4g KwkucHJvYmUJCT0gdnBfdmRwYV9wcm9iZSwKPiArCS5yZW1vdmUJCT0gdnBfdmRwYV9yZW1vdmUs Cj4gK307Cj4gKwo+ICttb2R1bGVfcGNpX2RyaXZlcih2cF92ZHBhX2RyaXZlcik7Cj4gKwo+ICtN T0RVTEVfQVVUSE9SKCJKYXNvbiBXYW5nIDxqYXNvd2FuZ0ByZWRoYXQuY29tPiIpOwo+ICtNT0RV TEVfREVTQ1JJUFRJT04oInZwLXZkcGEiKTsKPiArTU9EVUxFX0xJQ0VOU0UoIkdQTCIpOwo+ICtN T0RVTEVfVkVSU0lPTigiMSIpOwo+IC0tIAo+IDIuMjAuMQoKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KVmlydHVhbGl6YXRpb24gbWFpbGluZyBsaXN0ClZp cnR1YWxpemF0aW9uQGxpc3RzLmxpbnV4LWZvdW5kYXRpb24ub3JnCmh0dHBzOi8vbGlzdHMubGlu dXhmb3VuZGF0aW9uLm9yZy9tYWlsbWFuL2xpc3RpbmZvL3ZpcnR1YWxpemF0aW9u 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=-6.9 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS 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 28BD2C433E1 for ; Wed, 10 Jun 2020 06:08:01 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id A6BA920734 for ; Wed, 10 Jun 2020 06:08:00 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=redhat.com header.i=@redhat.com header.b="HhrrJBBd" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1726271AbgFJGH7 (ORCPT ); Wed, 10 Jun 2020 02:07:59 -0400 Received: from us-smtp-1.mimecast.com ([207.211.31.81]:27991 "EHLO us-smtp-delivery-1.mimecast.com" rhost-flags-OK-OK-OK-FAIL) by vger.kernel.org with ESMTP id S1725988AbgFJGHx (ORCPT ); Wed, 10 Jun 2020 02:07:53 -0400 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=redhat.com; s=mimecast20190719; t=1591769268; h=from:from:reply-to:subject:subject:date:date:message-id:message-id: to:to:cc:cc:mime-version:mime-version:content-type:content-type: content-transfer-encoding:content-transfer-encoding: in-reply-to:in-reply-to:references:references; bh=NzeOFsK7paj5bcPOCxRYbw7HjKDJ1Cs1lUAb0+D84mQ=; b=HhrrJBBd2zwBwBrjXz4cvEo+oRyNvwngOBRuyMVMthcZ+TZrse6BZuVDkTwcN6Ww9hQqqv 4OJy9c0FzBohWMkHKQQfMwmc2E+yZJ8pdTyW8gkVThH3j7YLqTqZ6WZRAeF275C/f2Sc/j u5ibxXrcnYDvjFEpZC35ix8GqkpnGKU= Received: from mail-wm1-f71.google.com (mail-wm1-f71.google.com [209.85.128.71]) (Using TLS) by relay.mimecast.com with ESMTP id us-mta-387-fLNk-2jRNuW2Ma0Ux97C2w-1; Wed, 10 Jun 2020 02:07:47 -0400 X-MC-Unique: fLNk-2jRNuW2Ma0Ux97C2w-1 Received: by mail-wm1-f71.google.com with SMTP id b65so138293wmb.5 for ; Tue, 09 Jun 2020 23:07:46 -0700 (PDT) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:date:from:to:cc:subject:message-id:references :mime-version:content-disposition:content-transfer-encoding :in-reply-to; bh=NzeOFsK7paj5bcPOCxRYbw7HjKDJ1Cs1lUAb0+D84mQ=; b=AF06ea7K1vJSarnzAXh9ILFBNVyb/EjbnVRBs5pq9JEfLoDEEMhpIEb1sLzRN6RAB2 VTfbXWKB4pwuvhgsditTrvPoMPQ4lIVFv6vfyyGsXVt313/b9homiW/dgG2e6VS2RZay CtQugZj+vtgSZL3zSDv27JK4EJOtIxwx0yvZA494yzvhr3vdKPxG+LUct5ZYqTlmNMNA xtrq91w2M+NXOqK860pJYenXckkA8A9Yu7+SfcJu84Gst2PHvP7GII9Iq9u0U13VNWLZ uG8XbYeRIhib16BudxmBUe605KmHiJv50iLyzkHwFQjn83QAip+kKRRE0nLwK++dVdqY tGfA== X-Gm-Message-State: AOAM532egn7ZhY168jxgkeWGAIOV+NCxrls9s4rTil92Fbm79VT0j5mB nNmg+gUBSIj2xPqJC4ucggleFxjNeCvcUFwsrFi96cVKkwi9GVMn5oetezFE/wblPif9zZuZO1W ZWBQh/b8A7b0TyibyuU1RfK4u X-Received: by 2002:a5d:4446:: with SMTP id x6mr1609816wrr.119.1591769265690; Tue, 09 Jun 2020 23:07:45 -0700 (PDT) X-Google-Smtp-Source: ABdhPJwNJh4uDu7W3HntDY2ADyNX+U6cq931CYG47/dpll8D5hvXsv8nucZKN/sPt1DLUaB6r/ILXQ== X-Received: by 2002:a5d:4446:: with SMTP id x6mr1609777wrr.119.1591769265248; Tue, 09 Jun 2020 23:07:45 -0700 (PDT) Received: from redhat.com (bzq-79-181-55-232.red.bezeqint.net. [79.181.55.232]) by smtp.gmail.com with ESMTPSA id o10sm6652127wrj.37.2020.06.09.23.07.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 09 Jun 2020 23:07:44 -0700 (PDT) Date: Wed, 10 Jun 2020 02:07:41 -0400 From: "Michael S. Tsirkin" To: Jason Wang Cc: linux-kernel@vger.kernel.org, virtualization@lists.linux-foundation.org, rob.miller@broadcom.com, lingshan.zhu@intel.com, eperezma@redhat.com, lulu@redhat.com, shahafs@mellanox.com, hanand@xilinx.com, mhabets@solarflare.com, gdawar@xilinx.com, saugatm@xilinx.com, vmireyno@marvell.com, zhangweining@ruijie.com.cn, eli@mellanox.com Subject: Re: [PATCH RESEND V2] vdpa: introduce virtio pci driver Message-ID: <20200610020728-mutt-send-email-mst@kernel.org> References: <20200610054951.16197-1-jasowang@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <20200610054951.16197-1-jasowang@redhat.com> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Wed, Jun 10, 2020 at 01:49:51PM +0800, Jason Wang wrote: > This patch introduce a vDPA driver for virtio-pci device. It bridges > the virtio-pci control command to the vDPA bus. This will be used for > developing new features for both software vDPA framework and hardware > vDPA feature. > > Compared to vdpa_sim, it has several advantages: > > - it's a real device driver which allow us to play with real hardware > features > - type independent instead of networking specific > > Note that since virtio specification does not support get/restore > virtqueue state. So we can not use this driver for VM. This can be > addressed by extending the virtio specification. > > Consider the driver is mainly for testing and development for vDPA > features, it can only be bound via dynamic ids to make sure it's not > conflict with the drivers like virtio-pci or IFCVF. > > Signed-off-by: Jason Wang error: sha1 information is lacking or useless (drivers/vdpa/Kconfig). which tree is this on top of? > --- > Changes since V1: > - use NULL id_table to allow dynamic ids only > - squash the doorbell reporting > --- > drivers/vdpa/Kconfig | 8 + > drivers/vdpa/Makefile | 1 + > drivers/vdpa/vp_vdpa/Makefile | 2 + > drivers/vdpa/vp_vdpa/vp_vdpa.c | 601 +++++++++++++++++++++++++++++++++ > 4 files changed, 612 insertions(+) > create mode 100644 drivers/vdpa/vp_vdpa/Makefile > create mode 100644 drivers/vdpa/vp_vdpa/vp_vdpa.c > > diff --git a/drivers/vdpa/Kconfig b/drivers/vdpa/Kconfig > index e8140065c8a5..5cef3a4872e3 100644 > --- a/drivers/vdpa/Kconfig > +++ b/drivers/vdpa/Kconfig > @@ -28,4 +28,12 @@ config IFCVF > To compile this driver as a module, choose M here: the module will > be called ifcvf. > > +config VP_VDPA > + tristate "Virtio PCI bridge vDPA driver" > + depends on PCI_MSI > + help > + This kernel module that bridges virtio PCI device to vDPA > + bus. It allows us to test and develop vDPA subsystem inside > + an VM with the emulated virtio-pci device > + > endif # VDPA > diff --git a/drivers/vdpa/Makefile b/drivers/vdpa/Makefile > index 8bbb686ca7a2..37d00f49b3bf 100644 > --- a/drivers/vdpa/Makefile > +++ b/drivers/vdpa/Makefile > @@ -2,3 +2,4 @@ > obj-$(CONFIG_VDPA) += vdpa.o > obj-$(CONFIG_VDPA_SIM) += vdpa_sim/ > obj-$(CONFIG_IFCVF) += ifcvf/ > +obj-$(CONFIG_VP_VDPA) += vp_vdpa/ > diff --git a/drivers/vdpa/vp_vdpa/Makefile b/drivers/vdpa/vp_vdpa/Makefile > new file mode 100644 > index 000000000000..231088d3af7d > --- /dev/null > +++ b/drivers/vdpa/vp_vdpa/Makefile > @@ -0,0 +1,2 @@ > +# SPDX-License-Identifier: GPL-2.0 > +obj-$(CONFIG_VP_VDPA) += vp_vdpa.o > diff --git a/drivers/vdpa/vp_vdpa/vp_vdpa.c b/drivers/vdpa/vp_vdpa/vp_vdpa.c > new file mode 100644 > index 000000000000..2070298ab9fc > --- /dev/null > +++ b/drivers/vdpa/vp_vdpa/vp_vdpa.c > @@ -0,0 +1,601 @@ > +// SPDX-License-Identifier: GPL-2.0-only > +/* > + * vDPA bridge driver for modern virtio-pci device > + * > + * Copyright (c) 2020, Red Hat Inc. All rights reserved. > + * Author: Jason Wang > + * > + * Based on virtio_pci_modern.c. > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +/* TBD: read from config space */ > +#define VP_VDPA_MAX_QUEUE 2 > +#define VP_VDPA_DRIVER_NAME "vp_vdpa" > + > +#define VP_VDPA_FEATURES \ > + ((1ULL << VIRTIO_F_ANY_LAYOUT) | \ > + (1ULL << VIRTIO_F_VERSION_1) | \ > + (1ULL << VIRTIO_F_ORDER_PLATFORM) | \ > + (1ULL << VIRTIO_F_IOMMU_PLATFORM)) > + > +struct vp_vring { > + void __iomem *notify; > + char msix_name[256]; > + resource_size_t notify_pa; > + struct vdpa_callback cb; > + int irq; > +}; > + > +struct vp_vdpa { > + struct vdpa_device vdpa; > + struct pci_dev *pdev; > + > + struct virtio_device_id id; > + > + struct vp_vring vring[VP_VDPA_MAX_QUEUE]; > + > + /* The IO mapping for the PCI config space */ > + void __iomem * const *base; > + struct virtio_pci_common_cfg __iomem *common; > + void __iomem *device; > + /* Base of vq notifications */ > + void __iomem *notify; > + > + /* Multiplier for queue_notify_off. */ > + u32 notify_off_multiplier; > + > + int modern_bars; > + int vectors; > +}; > + > +static struct vp_vdpa *vdpa_to_vp(struct vdpa_device *vdpa) > +{ > + return container_of(vdpa, struct vp_vdpa, vdpa); > +} > + > +/* > + * Type-safe wrappers for io accesses. > + * Use these to enforce at compile time the following spec requirement: > + * > + * The driver MUST access each field using the “natural” access > + * method, i.e. 32-bit accesses for 32-bit fields, 16-bit accesses > + * for 16-bit fields and 8-bit accesses for 8-bit fields. > + */ > +static inline u8 vp_ioread8(u8 __iomem *addr) > +{ > + return ioread8(addr); > +} > +static inline u16 vp_ioread16(__le16 __iomem *addr) > +{ > + return ioread16(addr); > +} > + > +static inline u32 vp_ioread32(__le32 __iomem *addr) > +{ > + return ioread32(addr); > +} > + > +static inline void vp_iowrite8(u8 value, u8 __iomem *addr) > +{ > + iowrite8(value, addr); > +} > + > +static inline void vp_iowrite16(u16 value, __le16 __iomem *addr) > +{ > + iowrite16(value, addr); > +} > + > +static inline void vp_iowrite32(u32 value, __le32 __iomem *addr) > +{ > + iowrite32(value, addr); > +} > + > +static void vp_iowrite64_twopart(u64 val, > + __le32 __iomem *lo, __le32 __iomem *hi) > +{ > + vp_iowrite32((u32)val, lo); > + vp_iowrite32(val >> 32, hi); > +} > + > +static int find_capability(struct pci_dev *dev, u8 cfg_type, > + u32 ioresource_types, int *bars) > +{ > + int pos; > + > + for (pos = pci_find_capability(dev, PCI_CAP_ID_VNDR); > + pos > 0; > + pos = pci_find_next_capability(dev, pos, PCI_CAP_ID_VNDR)) { > + u8 type, bar; > + > + pci_read_config_byte(dev, pos + offsetof(struct virtio_pci_cap, > + cfg_type), > + &type); > + pci_read_config_byte(dev, pos + offsetof(struct virtio_pci_cap, > + bar), > + &bar); > + > + /* Ignore structures with reserved BAR values */ > + if (bar > 0x5) > + continue; > + > + if (type == cfg_type) { > + if (pci_resource_len(dev, bar) && > + pci_resource_flags(dev, bar) & ioresource_types) { > + *bars |= (1 << bar); > + return pos; > + } > + } > + } > + return 0; > +} > + > +static void __iomem *map_capability(struct vp_vdpa *vp_vdpa, int off, > + resource_size_t *pa) > +{ > + struct pci_dev *pdev = vp_vdpa->pdev; > + u32 offset; > + u8 bar; > + > + pci_read_config_byte(pdev, > + off + offsetof(struct virtio_pci_cap, bar), > + &bar); > + pci_read_config_dword(pdev, > + off + offsetof(struct virtio_pci_cap, offset), > + &offset); > + > + if (pa) > + *pa = pci_resource_start(pdev, bar) + offset; > + > + return vp_vdpa->base[bar] + offset; > +} > + > +static u64 vp_vdpa_get_features(struct vdpa_device *vdpa) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + u64 features; > + > + vp_iowrite32(0, &vp_vdpa->common->device_feature_select); > + features = vp_ioread32(&vp_vdpa->common->device_feature); > + vp_iowrite32(1, &vp_vdpa->common->device_feature_select); > + features |= ((u64)vp_ioread32(&vp_vdpa->common->device_feature) << 32); > + features &= VP_VDPA_FEATURES; > + > + return features; > +} > + > +static int vp_vdpa_set_features(struct vdpa_device *vdpa, u64 features) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + > + vp_iowrite32(0, &vp_vdpa->common->guest_feature_select); > + vp_iowrite32((u32)features, &vp_vdpa->common->guest_feature); > + vp_iowrite32(1, &vp_vdpa->common->guest_feature_select); > + vp_iowrite32(features >> 32, &vp_vdpa->common->guest_feature); > + > + return 0; > +} > + > +static u8 vp_vdpa_get_status(struct vdpa_device *vdpa) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + > + return vp_ioread8(&vp_vdpa->common->device_status); > +} > + > +static void vp_vdpa_free_irq(struct vp_vdpa *vp_vdpa) > +{ > + struct pci_dev *pdev = vp_vdpa->pdev; > + int i; > + > + for (i = 0; i < VP_VDPA_MAX_QUEUE; i++) { > + if (vp_vdpa->vring[i].irq != -1) { > + vp_iowrite16(i, &vp_vdpa->common->queue_select); > + vp_iowrite16(VIRTIO_MSI_NO_VECTOR, > + &vp_vdpa->common->queue_msix_vector); > + devm_free_irq(&pdev->dev, vp_vdpa->vring[i].irq, > + &vp_vdpa->vring[i]); > + vp_vdpa->vring[i].irq = -1; > + } > + } > + > + if (vp_vdpa->vectors) { > + pci_free_irq_vectors(pdev); > + vp_vdpa->vectors = 0; > + } > +} > + > +static irqreturn_t vp_vdpa_intr_handler(int irq, void *arg) > +{ > + struct vp_vring *vring = arg; > + > + if (vring->cb.callback) > + return vring->cb.callback(vring->cb.private); > + > + return IRQ_HANDLED; > +} > + > +static int vp_vdpa_request_irq(struct vp_vdpa *vp_vdpa) > +{ > + struct pci_dev *pdev = vp_vdpa->pdev; > + int i, ret, irq; > + > + ret = pci_alloc_irq_vectors(pdev, VP_VDPA_MAX_QUEUE, > + VP_VDPA_MAX_QUEUE, PCI_IRQ_MSIX); > + if (ret != VP_VDPA_MAX_QUEUE) { > + dev_err(&pdev->dev, "vp_vdpa: fail to allocate irq vectors\n"); > + return ret; > + } > + > + vp_vdpa->vectors = VP_VDPA_MAX_QUEUE; > + > + for (i = 0; i < VP_VDPA_MAX_QUEUE; i++) { > + snprintf(vp_vdpa->vring[i].msix_name, 256, > + "vp-vdpa[%s]-%d\n", pci_name(pdev), i); > + irq = pci_irq_vector(pdev, i); > + ret = devm_request_irq(&pdev->dev, irq, > + vp_vdpa_intr_handler, > + 0, vp_vdpa->vring[i].msix_name, > + &vp_vdpa->vring[i]); > + if (ret) { > + dev_err(&pdev->dev, "vp_vdpa: fail to request irq for vq %d\n", > + i); > + goto err; > + } > + vp_iowrite16(i, &vp_vdpa->common->queue_select); > + vp_iowrite16(i, &vp_vdpa->common->queue_msix_vector); > + vp_vdpa->vring[i].irq = irq; > + } > + > + return 0; > +err: > + vp_vdpa_free_irq(vp_vdpa); > + return ret; > +} > + > +static void vp_vdpa_set_status(struct vdpa_device *vdpa, u8 status) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + u8 s = vp_vdpa_get_status(vdpa); > + > + if (status & VIRTIO_CONFIG_S_DRIVER_OK && > + !(s & VIRTIO_CONFIG_S_DRIVER_OK)) { > + vp_vdpa_request_irq(vp_vdpa); > + } > + > + vp_iowrite8(status, &vp_vdpa->common->device_status); > + > + if (!(status & VIRTIO_CONFIG_S_DRIVER_OK) && > + (s & VIRTIO_CONFIG_S_DRIVER_OK)) > + vp_vdpa_free_irq(vp_vdpa); > +} > + > +static u16 vp_vdpa_get_vq_num_max(struct vdpa_device *vdpa) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + > + return vp_ioread16(&vp_vdpa->common->queue_size); > +} > + > +static u64 vp_vdpa_get_vq_state(struct vdpa_device *vdpa, u16 qid) > +{ > + return 0; > +} > + > +static struct vdpa_notification_area > +vp_vdpa_get_vq_notification(struct vdpa_device *vdpa, u16 qid) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + struct vdpa_notification_area notify; > + > + notify.addr = vp_vdpa->vring[qid].notify_pa; > + notify.size = vp_vdpa->notify_off_multiplier; > + > + return notify; > +} > + > +static int vp_vdpa_set_vq_state(struct vdpa_device *vdpa, u16 qid, > + u64 num) > +{ > + /* Note that this is not supported by virtio specification, so > + * we return -ENOTSUPP here. This means we can't support live > + * migration, vhost device start/stop. > + */ > + > + return -ENOTSUPP; > +} > + > +static void vp_vdpa_set_vq_cb(struct vdpa_device *vdpa, u16 qid, > + struct vdpa_callback *cb) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + > + vp_vdpa->vring[qid].cb = *cb; > +} > + > +static void vp_vdpa_set_vq_ready(struct vdpa_device *vdpa, > + u16 qid, bool ready) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + > + vp_iowrite16(qid, &vp_vdpa->common->queue_select); > + vp_iowrite16(ready, &vp_vdpa->common->queue_enable); > +} > + > +static bool vp_vdpa_get_vq_ready(struct vdpa_device *vdpa, u16 qid) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + > + vp_iowrite16(qid, &vp_vdpa->common->queue_select); > + > + return vp_ioread16(&vp_vdpa->common->queue_enable); > +} > + > +static void vp_vdpa_set_vq_num(struct vdpa_device *vdpa, u16 qid, > + u32 num) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + > + vp_iowrite16(num, &vp_vdpa->common->queue_size); > +} > + > +static int vp_vdpa_set_vq_address(struct vdpa_device *vdpa, u16 qid, > + u64 desc_area, u64 driver_area, > + u64 device_area) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + struct virtio_pci_common_cfg __iomem *cfg = vp_vdpa->common; > + > + vp_iowrite16(qid, &cfg->queue_select); > + vp_iowrite64_twopart(desc_area, > + &cfg->queue_desc_lo, &cfg->queue_desc_hi); > + vp_iowrite64_twopart(driver_area, > + &cfg->queue_avail_lo, &cfg->queue_avail_hi); > + vp_iowrite64_twopart(device_area, > + &cfg->queue_used_lo, &cfg->queue_used_hi); > + > + return 0; > +} > + > +static void vp_vdpa_kick_vq(struct vdpa_device *vdpa, u16 qid) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + > + vp_iowrite16(qid, vp_vdpa->vring[qid].notify); > +} > + > +static u32 vp_vdpa_get_generation(struct vdpa_device *vdpa) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + > + return vp_ioread8(&vp_vdpa->common->config_generation); > +} > + > +static u32 vp_vdpa_get_device_id(struct vdpa_device *vdpa) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + > + return vp_vdpa->id.device; > +} > + > +static u32 vp_vdpa_get_vendor_id(struct vdpa_device *vdpa) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + > + return vp_vdpa->id.vendor; > +} > + > +static u32 vp_vdpa_get_vq_align(struct vdpa_device *vdpa) > +{ > + return PAGE_SIZE; > +} > + > +static void vp_vdpa_get_config(struct vdpa_device *vdpa, > + unsigned int offset, > + void *buf, unsigned int len) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + u8 old, new; > + u8 *p; > + int i; > + > + do { > + old = vp_ioread8(&vp_vdpa->common->config_generation); > + p = buf; > + for (i = 0; i < len; i++) > + *p++ = vp_ioread8(vp_vdpa->device + offset + i); > + > + new = vp_ioread8(&vp_vdpa->common->config_generation); > + } while (old != new); > +} > + > +static void vp_vdpa_set_config(struct vdpa_device *vdpa, > + unsigned int offset, const void *buf, > + unsigned int len) > +{ > + struct vp_vdpa *vp_vdpa = vdpa_to_vp(vdpa); > + const u8 *p = buf; > + int i; > + > + for (i = 0; i < len; i++) > + vp_iowrite8(*p++, vp_vdpa->device + offset + i); > +} > + > +static void vp_vdpa_set_config_cb(struct vdpa_device *vdpa, > + struct vdpa_callback *cb) > +{ > + /* We don't support config interrupt */ > +} > + > +static const struct vdpa_config_ops vp_vdpa_ops = { > + .get_features = vp_vdpa_get_features, > + .set_features = vp_vdpa_set_features, > + .get_status = vp_vdpa_get_status, > + .set_status = vp_vdpa_set_status, > + .get_vq_num_max = vp_vdpa_get_vq_num_max, > + .get_vq_state = vp_vdpa_get_vq_state, > + .get_vq_notification = vp_vdpa_get_vq_notification, > + .set_vq_state = vp_vdpa_set_vq_state, > + .set_vq_cb = vp_vdpa_set_vq_cb, > + .set_vq_ready = vp_vdpa_set_vq_ready, > + .get_vq_ready = vp_vdpa_get_vq_ready, > + .set_vq_num = vp_vdpa_set_vq_num, > + .set_vq_address = vp_vdpa_set_vq_address, > + .kick_vq = vp_vdpa_kick_vq, > + .get_generation = vp_vdpa_get_generation, > + .get_device_id = vp_vdpa_get_device_id, > + .get_vendor_id = vp_vdpa_get_vendor_id, > + .get_vq_align = vp_vdpa_get_vq_align, > + .get_config = vp_vdpa_get_config, > + .set_config = vp_vdpa_set_config, > + .set_config_cb = vp_vdpa_set_config_cb, > +}; > + > +static int vp_vdpa_probe(struct pci_dev *pdev, const struct pci_device_id *id) > +{ > + struct device *dev = &pdev->dev; > + struct vp_vdpa *vp_vdpa; > + int common, notify, device, ret, i; > + struct virtio_device_id virtio_id; > + resource_size_t notify_pa; > + u16 notify_off; > + > + /* We only own devices >= 0x1000 and <= 0x107f: leave the rest. */ > + if (pdev->device < 0x1000 || pdev->device > 0x107f) > + return -ENODEV; > + > + if (pdev->device < 0x1040) { > + /* Transitional devices: use the PCI subsystem device id as > + * virtio device id, same as legacy driver always did. > + */ > + virtio_id.device = pdev->subsystem_device; > + } else { > + /* Modern devices: simply use PCI device id, > + * but start from 0x1040. > + */ > + virtio_id.device = pdev->device - 0x1040; > + } > + virtio_id.vendor = pdev->subsystem_vendor; > + > + ret = pcim_enable_device(pdev); > + if (ret) { > + dev_err(dev, "vp_vdpa: Fail to enable PCI device\n"); > + return ret; > + } > + > + vp_vdpa = vdpa_alloc_device(struct vp_vdpa, vdpa, > + dev, &vp_vdpa_ops); > + if (vp_vdpa == NULL) { > + dev_err(dev, "vp_vdpa: Failed to allocate vDPA structure\n"); > + return -ENOMEM; > + } > + > + pci_set_master(pdev); > + pci_set_drvdata(pdev, vp_vdpa); > + > + vp_vdpa->pdev = pdev; > + vp_vdpa->vdpa.dma_dev = &pdev->dev; > + > + common = find_capability(pdev, VIRTIO_PCI_CAP_COMMON_CFG, > + IORESOURCE_IO | IORESOURCE_MEM, > + &vp_vdpa->modern_bars); > + if (!common) { > + dev_err(&pdev->dev, > + "vp_vdpa: legacy device is not supported\n"); > + ret = -ENODEV; > + goto err; > + } > + > + notify = find_capability(pdev, VIRTIO_PCI_CAP_NOTIFY_CFG, > + IORESOURCE_IO | IORESOURCE_MEM, > + &vp_vdpa->modern_bars); > + if (!notify) { > + dev_err(&pdev->dev, > + "vp_vdpa: missing notification capabilities\n"); > + ret = -EINVAL; > + goto err; > + } > + > + device = find_capability(pdev, VIRTIO_PCI_CAP_DEVICE_CFG, > + IORESOURCE_IO | IORESOURCE_MEM, > + &vp_vdpa->modern_bars); > + if (!device) { > + dev_err(&pdev->dev, > + "vp_vdpa: missing device capabilities\n"); > + ret = -EINVAL; > + goto err; > + } > + > + ret = pcim_iomap_regions(pdev, vp_vdpa->modern_bars, > + VP_VDPA_DRIVER_NAME); > + if (ret) > + goto err; > + > + vp_vdpa->base = pcim_iomap_table(pdev); > + > + ret = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)); > + if (ret) > + ret = dma_set_mask_and_coherent(&pdev->dev, > + DMA_BIT_MASK(32)); > + if (ret) > + dev_warn(&pdev->dev, "Failed to enable 64-bit or 32-bit DMA. Trying to continue, but this might not work.\n"); > + > + vp_vdpa->device = map_capability(vp_vdpa, device, NULL); > + vp_vdpa->notify = map_capability(vp_vdpa, notify, ¬ify_pa); > + vp_vdpa->common = map_capability(vp_vdpa, common, NULL); > + vp_vdpa->id = virtio_id; > + > + ret = vdpa_register_device(&vp_vdpa->vdpa); > + if (ret) { > + dev_err(&pdev->dev, "Failed to register to vdpa bus\n"); > + goto err; > + } > + > + pci_read_config_dword(pdev, notify + sizeof(struct virtio_pci_cap), > + &vp_vdpa->notify_off_multiplier); > + > + for (i = 0; i < VP_VDPA_MAX_QUEUE; i++) { > + vp_iowrite16(i, &vp_vdpa->common->queue_select); > + notify_off = vp_ioread16(&vp_vdpa->common->queue_notify_off); > + vp_vdpa->vring[i].irq = -1; > + vp_vdpa->vring[i].notify = vp_vdpa->notify + > + notify_off * vp_vdpa->notify_off_multiplier; > + vp_vdpa->vring[i].notify_pa = notify_pa + > + notify_off * vp_vdpa->notify_off_multiplier; > + } > + > + return 0; > + > +err: > + put_device(&vp_vdpa->vdpa.dev); > + return ret; > +} > + > +static void vp_vdpa_remove(struct pci_dev *pdev) > +{ > + struct vp_vdpa *vp_vdpa = pci_get_drvdata(pdev); > + > + vdpa_unregister_device(&vp_vdpa->vdpa); > +} > + > +static struct pci_driver vp_vdpa_driver = { > + .name = "vp-vdpa", > + .id_table = NULL, /* only dynamic ids */ > + .probe = vp_vdpa_probe, > + .remove = vp_vdpa_remove, > +}; > + > +module_pci_driver(vp_vdpa_driver); > + > +MODULE_AUTHOR("Jason Wang "); > +MODULE_DESCRIPTION("vp-vdpa"); > +MODULE_LICENSE("GPL"); > +MODULE_VERSION("1"); > -- > 2.20.1