From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alex =?utf-8?Q?Benn=C3=A9e?= Subject: Re: [PATCH v10 3/7] hw/vfio/platform: add irq assignment Date: Tue, 17 Feb 2015 11:24:52 +0000 Message-ID: <87egpozsor.fsf@linaro.org> References: <1423799232-10816-1-git-send-email-eric.auger@linaro.org> <1423799232-10816-4-git-send-email-eric.auger@linaro.org> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from localhost (localhost [127.0.0.1]) by mm01.cs.columbia.edu (Postfix) with ESMTP id B5E1545BDA for ; Tue, 17 Feb 2015 06:19:32 -0500 (EST) Received: from mm01.cs.columbia.edu ([127.0.0.1]) by localhost (mm01.cs.columbia.edu [127.0.0.1]) (amavisd-new, port 10024) with ESMTP id 4M0Rc7Ir5nFL for ; Tue, 17 Feb 2015 06:19:31 -0500 (EST) Received: from socrates.bennee.com (static.88-198-71-155.clients.your-server.de [88.198.71.155]) by mm01.cs.columbia.edu (Postfix) with ESMTPS id 078BE45B06 for ; Tue, 17 Feb 2015 06:19:30 -0500 (EST) In-reply-to: <1423799232-10816-4-git-send-email-eric.auger@linaro.org> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: kvmarm-bounces@lists.cs.columbia.edu Sender: kvmarm-bounces@lists.cs.columbia.edu To: Eric Auger Cc: eric.auger@st.com, patches@linaro.org, qemu-devel@nongnu.org, alex.williamson@redhat.com, pbonzini@redhat.com, feng.wu@intel.com, kvmarm@lists.cs.columbia.edu List-Id: kvmarm@lists.cs.columbia.edu CkVyaWMgQXVnZXIgPGVyaWMuYXVnZXJAbGluYXJvLm9yZz4gd3JpdGVzOgoKPiBUaGlzIHBhdGNo IGFkZHMgdGhlIGNvZGUgcmVxdWVzdGVkIHRvIGFzc2lnbiBpbnRlcnJ1cHRzIHRvCj4gYSBndWVz dC4gVGhlIGludGVycnVwdHMgYXJlIG1lZGlhdGVkIHRocm91Z2ggdXNlciBoYW5kbGVkCj4gZXZl bnRmZHMgb25seS4KPgo+IFRoZSBtZWNoYW5pY3MgdG8gc3RhcnQgdGhlIElSUSBoYW5kbGluZyBp cyBub3QgeWV0IHRoZXJlIHRocm91Z2guCj4KPiBTaWduZWQtb2ZmLWJ5OiBFcmljIEF1Z2VyIDxl cmljLmF1Z2VyQGxpbmFyby5vcmc+CgpTZWUgY29tbWVudHMgaW5saW5lLgoKPgo+IC0tLQo+Cj4g djggLT4gdjk6Cj4gLSBmcmVlIGlycSByZWxhdGVkIHJlc291cmNlcyBpbiBjYXNlIG9mIGVycm9y IGluIHZmaW9fcG9wdWxhdGVfZGV2aWNlCj4gLS0tCj4gIGh3L3ZmaW8vcGxhdGZvcm0uYyAgICAg ICAgICAgICAgfCAzMTkgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKwo+ ICBpbmNsdWRlL2h3L3ZmaW8vdmZpby1wbGF0Zm9ybS5oIHwgIDMzICsrKysrCj4gIDIgZmlsZXMg Y2hhbmdlZCwgMzUyIGluc2VydGlvbnMoKykKPgo+IGRpZmYgLS1naXQgYS9ody92ZmlvL3BsYXRm b3JtLmMgYi9ody92ZmlvL3BsYXRmb3JtLmMKPiBpbmRleCBjYWFkYjkyLi5iODVhZDZjIDEwMDY0 NAo+IC0tLSBhL2h3L3ZmaW8vcGxhdGZvcm0uYwo+ICsrKyBiL2h3L3ZmaW8vcGxhdGZvcm0uYwo+ IEBAIC0yMiwxMCArMjIsMjU5IEBACj4gICNpbmNsdWRlICJxZW11L3JhbmdlLmgiCj4gICNpbmNs dWRlICJzeXNlbXUvc3lzZW11LmgiCj4gICNpbmNsdWRlICJleGVjL21lbW9yeS5oIgo+ICsjaW5j bHVkZSAicWVtdS9xdWV1ZS5oIgo+ICAjaW5jbHVkZSAiaHcvc3lzYnVzLmgiCj4gICNpbmNsdWRl ICJ0cmFjZS5oIgo+ICAjaW5jbHVkZSAiaHcvcGxhdGZvcm0tYnVzLmgiCj4gIAo+ICtzdGF0aWMg dm9pZCB2ZmlvX2ludHBfaW50ZXJydXB0KFZGSU9JTlRwICppbnRwKTsKPiArdHlwZWRlZiB2b2lk ICgqZXZlbnRmZF91c2VyX3NpZGVfaGFuZGxlcl90KShWRklPSU5UcCAqaW50cCk7Cj4gK3N0YXRp YyBpbnQgdmZpb19zZXRfdHJpZ2dlcl9ldmVudGZkKFZGSU9JTlRwICppbnRwLAo+ICsgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICBldmVudGZkX3VzZXJfc2lkZV9oYW5kbGVyX3Qg aGFuZGxlcik7Cj4gKwo+ICsvKgo+ICsgKiBGdW5jdGlvbnMgb25seSB1c2VkIHdoZW4gZXZlbnRm ZCBhcmUgaGFuZGxlZCBvbiB1c2VyLXNpZGUKPiArICogaWUuIHdpdGhvdXQgaXJxZmQKPiArICov Cj4gKwo+ICsvKioKPiArICogdmZpb19wbGF0Zm9ybV9lb2kgLSBJUlEgY29tcGxldGlvbiByb3V0 aW5lCj4gKyAqIEB2YmFzZWRldjogdGhlIFZGSU8gZGV2aWNlCj4gKyAqCj4gKyAqIGRlLWFzc2Vy dHMgdGhlIGFjdGl2ZSB2aXJ0dWFsIElSUSBhbmQgdW5tYXNrIHRoZSBwaHlzaWNhbCBJUlEKPiAr ICogKG1hc2tlZCBieSB0aGUgIFZGSU8gZHJpdmVyKS4gSGFuZGxlIHBlbmRpbmcgSVJRcyBpZiBh bnkuCj4gKyAqIGVvaSBmdW5jdGlvbiBpcyBjYWxsZWQgb24gdGhlIGZpcnN0IGFjY2VzcyB0byBh bnkgTU1JTyByZWdpb24KPiArICogYWZ0ZXIgYW4gSVJRIHdhcyB0cmlnZ2VyZWQuIEl0IGlzIGFz c3VtZWQgdGhpcyBhY2Nlc3MgY29ycmVzcG9uZHMKPiArICogdG8gdGhlIElSUSBzdGF0dXMgcmVn aXN0ZXIgcmVzZXQuIFdpdGggc3VjaCBhIG1lY2hhbmlzbSwgYSBzaW5nbGUKPiArICogSVJRIGNh biBiZSBoYW5kbGVkIGF0IGEgdGltZSBzaW5jZSB0aGVyZSBpcyBubyB3YXkgdG8ga25vdyB3aGlj aAo+ICsgKiBJUlEgd2FzIGNvbXBsZXRlZCBieSB0aGUgZ3Vlc3QgKHdlIHdvdWxkIG5lZWQgYWRk aXRpb25hbCBkZXRhaWxzCj4gKyAqIGFib3V0IHRoZSBJUlEgc3RhdHVzIHJlZ2lzdGVyIG1hc2sp Cj4gKyAqLwo+ICtzdGF0aWMgdm9pZCB2ZmlvX3BsYXRmb3JtX2VvaShWRklPRGV2aWNlICp2YmFz ZWRldikKPiArewo+ICsgICAgVkZJT0lOVHAgKmludHA7Cj4gKyAgICBWRklPUGxhdGZvcm1EZXZp Y2UgKnZkZXYgPQo+ICsgICAgICAgIGNvbnRhaW5lcl9vZih2YmFzZWRldiwgVkZJT1BsYXRmb3Jt RGV2aWNlLCB2YmFzZWRldik7Cj4gKwo+ICsgICAgcWVtdV9tdXRleF9sb2NrKCZ2ZGV2LT5pbnRw X211dGV4KTsKPiArICAgIFFMSVNUX0ZPUkVBQ0goaW50cCwgJnZkZXYtPmludHBfbGlzdCwgbmV4 dCkgewo+ICsgICAgICAgIGlmIChpbnRwLT5zdGF0ZSA9PSBWRklPX0lSUV9BQ1RJVkUpIHsKPiAr ICAgICAgICAgICAgdHJhY2VfdmZpb19wbGF0Zm9ybV9lb2koaW50cC0+cGluLAo+ICsgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgIGV2ZW50X25vdGlmaWVyX2dldF9mZCgmaW50cC0+aW50 ZXJydXB0KSk7Cj4gKyAgICAgICAgICAgIGludHAtPnN0YXRlID0gVkZJT19JUlFfSU5BQ1RJVkU7 Cj4gKwo+ICsgICAgICAgICAgICAvKiBkZWFzc2VydCB0aGUgdmlydHVhbCBJUlEgYW5kIHVubWFz ayBwaHlzaWNhbCBvbmUgKi8KPiArICAgICAgICAgICAgcWVtdV9zZXRfaXJxKGludHAtPnFlbXVp cnEsIDApOwo+ICsgICAgICAgICAgICB2ZmlvX3VubWFza19zaW5nbGVfaXJxaW5kZXgodmJhc2Vk ZXYsIGludHAtPnBpbik7Cj4gKwo+ICsgICAgICAgICAgICAvKiBhIHNpbmdsZSBJUlEgY2FuIGJl IGFjdGl2ZSBhdCBhIHRpbWUgKi8KPiArICAgICAgICAgICAgYnJlYWs7Cj4gKyAgICAgICAgfQo+ ICsgICAgfQo+ICsgICAgLyogaW4gY2FzZSB0aGVyZSBhcmUgcGVuZGluZyBJUlFzLCBoYW5kbGUg dGhlbSBvbmUgYXQgYSB0aW1lICovCj4gKyAgICBpZiAoIVFTSU1QTEVRX0VNUFRZKCZ2ZGV2LT5w ZW5kaW5nX2ludHBfcXVldWUpKSB7Cj4gKyAgICAgICAgaW50cCA9IFFTSU1QTEVRX0ZJUlNUKCZ2 ZGV2LT5wZW5kaW5nX2ludHBfcXVldWUpOwo+ICsgICAgICAgIHRyYWNlX3ZmaW9fcGxhdGZvcm1f ZW9pX2hhbmRsZV9wZW5kaW5nKGludHAtPnBpbik7Cj4gKyAgICAgICAgcWVtdV9tdXRleF91bmxv Y2soJnZkZXYtPmludHBfbXV0ZXgpOwo+ICsgICAgICAgIHZmaW9faW50cF9pbnRlcnJ1cHQoaW50 cCk7Cj4gKyAgICAgICAgcWVtdV9tdXRleF9sb2NrKCZ2ZGV2LT5pbnRwX211dGV4KTsKPiArICAg ICAgICBRU0lNUExFUV9SRU1PVkVfSEVBRCgmdmRldi0+cGVuZGluZ19pbnRwX3F1ZXVlLCBwcW5l eHQpOwo+ICsgICAgICAgIHFlbXVfbXV0ZXhfdW5sb2NrKCZ2ZGV2LT5pbnRwX211dGV4KTsKClRo aXMgbG9ja2luZyBpcyB3YXkgdG9vIHVnbHkuIElmIHRoZSBpbnRwIGxvY2sgaXMgcHJvdGVjdGlu ZyB0aGUKc3RydWN0dXJlcyB0aGVuIHJlbGVhc2luZyBpdCBzbyB0aGUgY2hpbGQgZnVuY3Rpb24g Y2FuIGdyYWIgaXQgYWdhaW4gaXMKanVzdCBhc2tpbmcgZm9yIHJhY2VzIHRvIGhhcHBlbi4gUGVy aGFwcyB2ZmlvX2ludHBfaW50ZXJydXB0IGNhbiBiZQpzcGxpdCB0byBoYXZlIGEgX2xvY2toZWxk IHZhcmlhbnQgdGhhdCBjYW4gYmUgdXNlZCBoZXJlIGFuZCB0aGUgb3RoZXIKdmVyc2lvbiBkbyB0 aGUgbG9ja2luZyBiZWZvcmUgY2FsbGluZyB0aGUgX2xvY2toZWxkIGZ1bmN0aW9uLgoKCj4gKyAg ICB9IGVsc2Ugewo+ICsgICAgICAgIHFlbXVfbXV0ZXhfdW5sb2NrKCZ2ZGV2LT5pbnRwX211dGV4 KTsKPiArICAgIH0KPiArfQo+ICsKPiArLyoqCj4gKyAqIHZmaW9fbW1hcF9zZXRfZW5hYmxlZCAt IGVuYWJsZS9kaXNhYmxlIHRoZSBmYXN0IHBhdGggbW9kZQo+ICsgKiBAdmRldjogdGhlIFZGSU8g cGxhdGZvcm0gZGV2aWNlCj4gKyAqIEBlbmFibGVkOiB0aGUgdGFyZ2V0IG1tYXAgc3RhdGUKPiAr ICoKPiArICogdHJ1ZSB+IGZhc3QgcGF0aCA9IE1NSU8gcmVnaW9uIGlzIG1tYXBlZCAobm8gS1ZN IFRSQVApCj4gKyAqIGZhbHNlIH4gc2xvdyBwYXRoID0gTU1JTyByZWdpb24gaXMgdHJhcHBlZCBh bmQgcmVnaW9uIGNhbGxiYWNrcwo+ICsgKiBhcmUgY2FsbGVkIHNsb3cgcGF0aCBlbmFibGVzIHRv IHRyYXAgdGhlIElSUSBzdGF0dXMgcmVnaXN0ZXIKPiArICogZ3Vlc3QgcmVzZXQKPiArKi8KPiAr Cj4gK3N0YXRpYyB2b2lkIHZmaW9fbW1hcF9zZXRfZW5hYmxlZChWRklPUGxhdGZvcm1EZXZpY2Ug KnZkZXYsIGJvb2wgZW5hYmxlZCkKPiArewo+ICsgICAgVkZJT1JlZ2lvbiAqcmVnaW9uOwoKcmVn aW9uIGNvdWxkIGJlIGRlZmluZWQgaW5zaWRlIHRoZSBibG9jaywgbm90IHRoYXQgaXQgbWF0dGVy cyB0b28gbXVjaApmb3IgYSBzbWFsbCBmdW5jdGlvbiBsaWtlIHRoaXMuCgo+ICsgICAgaW50IGk7 Cj4gKwo+ICsgICAgdHJhY2VfdmZpb19wbGF0Zm9ybV9tbWFwX3NldF9lbmFibGVkKGVuYWJsZWQp Owo+ICsKPiArICAgIGZvciAoaSA9IDA7IGkgPCB2ZGV2LT52YmFzZWRldi5udW1fcmVnaW9uczsg aSsrKSB7Cj4gKyAgICAgICAgcmVnaW9uID0gdmRldi0+cmVnaW9uc1tpXTsKPiArCj4gKyAgICAg ICAgLyogcmVnaXN0ZXIgc3BhY2UgaXMgdW5tYXBwZWQgdG8gdHJhcCBFT0kgKi8KPiArICAgICAg ICBtZW1vcnlfcmVnaW9uX3NldF9lbmFibGVkKCZyZWdpb24tPm1tYXBfbWVtLCBlbmFibGVkKTsK PiArICAgIH0KPiArfQo+ICsKPiArLyoqCj4gKyAqIHZmaW9faW50cF9tbWFwX2VuYWJsZSAtIHRp bWVyIGZ1bmN0aW9uLCByZXN0b3JlcyB0aGUgZmFzdCBwYXRoCj4gKyAqIGlmIHRoZXJlIGlzIG5v IG1vcmUgYWN0aXZlIElSUQo+ICsgKiBAb3BhcXVlOiBhY3R1YWxseSBwb2ludHMgdG8gdGhlIFZG SU8gcGxhdGZvcm0gZGV2aWNlCj4gKyAqCj4gKyAqIENhbGxlZCBvbiBtbWFwIHRpbWVyIHRpbW91 dCwgdGhpcyBmdW5jdGlvbiBjaGVja3Mgd2hldGhlciB0aGUKPiArICogSVJRIGlzIHN0aWxsIGFj dGl2ZSBhbmQgaW4gdGhlIG5lZ2F0aXZlIHJlc3RvcmVzIHRoZSBmYXN0IHBhdGguCj4gKyAqIGJ5 IGNvbnN0cnVjdGlvbiBhIHNpbmdsZSBldmVudGZkIGlzIGhhbmRsZWQgYXQgYSB0aW1lLgo+ICsg KiBpZiB0aGUgSVJRIGlzIHN0aWxsIGFjdGl2ZSwgdGhlIHRpbWVyIGlzIHJlc3RhcnRlZC4KPiAr ICovCj4gK3N0YXRpYyB2b2lkIHZmaW9faW50cF9tbWFwX2VuYWJsZSh2b2lkICpvcGFxdWUpCj4g K3sKPiArICAgIFZGSU9JTlRwICp0bXA7Cj4gKyAgICBWRklPUGxhdGZvcm1EZXZpY2UgKnZkZXYg PSAoVkZJT1BsYXRmb3JtRGV2aWNlICopb3BhcXVlOwo+ICsKPiArICAgIHFlbXVfbXV0ZXhfbG9j aygmdmRldi0+aW50cF9tdXRleCk7Cj4gKyAgICBRTElTVF9GT1JFQUNIKHRtcCwgJnZkZXYtPmlu dHBfbGlzdCwgbmV4dCkgewo+ICsgICAgICAgIGlmICh0bXAtPnN0YXRlID09IFZGSU9fSVJRX0FD VElWRSkgewo+ICsgICAgICAgICAgICB0cmFjZV92ZmlvX3BsYXRmb3JtX2ludHBfbW1hcF9lbmFi bGUodG1wLT5waW4pOwo+ICsgICAgICAgICAgICAvKiByZS1wcm9ncmFtIHRoZSB0aW1lciB0byBj aGVjayBhY3RpdmUgc3RhdHVzIGxhdGVyICovCj4gKyAgICAgICAgICAgIHRpbWVyX21vZCh2ZGV2 LT5tbWFwX3RpbWVyLAo+ICsgICAgICAgICAgICAgICAgICAgICAgcWVtdV9jbG9ja19nZXRfbXMo UUVNVV9DTE9DS19WSVJUVUFMKSArCj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgdmRldi0+ bW1hcF90aW1lb3V0KTsKPiArICAgICAgICAgICAgcWVtdV9tdXRleF91bmxvY2soJnZkZXYtPmlu dHBfbXV0ZXgpOwo+ICsgICAgICAgICAgICByZXR1cm47Cj4gKyAgICAgICAgfQo+ICsgICAgfQo+ ICsgICAgdmZpb19tbWFwX3NldF9lbmFibGVkKHZkZXYsIHRydWUpOwo+ICsgICAgcWVtdV9tdXRl eF91bmxvY2soJnZkZXYtPmludHBfbXV0ZXgpOwo+ICt9Cj4gKwo+ICsvKioKPiArICogdmZpb19p bnRwX2ludGVycnVwdCAtIFRoZSB1c2VyLXNpZGUgZXZlbnRmZCBoYW5kbGVyCj4gKyAqIEBvcGFx dWU6IG9wYXF1ZSBwb2ludGVyIHdoaWNoIGluIHByYWN0aWNlIGlzIHRoZSBWRklPSU5UcCoKPiAr ICoKPiArICogdGhlIGZ1bmN0aW9uIGNhbiBiZSBlbnRlcmVkCj4gKyAqIC0gaW4gZXZlbnQgaGFu ZGxlciBjb250ZXh0OiB0aGlzIElSUSBpcyBpbmFjdGl2ZQo+ICsgKiAgIGluIHRoYXQgY2FzZSwg dGhlIHZJUlEgaXMgaW5qZWN0ZWQgaW50byB0aGUgZ3Vlc3QgaWYgdGhlcmUKPiArICogICBpcyBu byBvdGhlciBhY3RpdmUgb3IgcGVuZGluZyBJUlEuCj4gKyAqIC0gaW4gSU9oYW5kbGVyIGNvbnRl eHQ6IHRoaXMgSVJRIGlzIHBlbmRpbmcuCj4gKyAqICAgdGhlcmUgaXMgbm8gQUNUSVZFIElSUQo+ ICsgKi8KPiArc3RhdGljIHZvaWQgdmZpb19pbnRwX2ludGVycnVwdChWRklPSU5UcCAqaW50cCkK PiArewo+ICsgICAgaW50IHJldDsKPiArICAgIFZGSU9JTlRwICp0bXA7Cj4gKyAgICBWRklPUGxh dGZvcm1EZXZpY2UgKnZkZXYgPSBpbnRwLT52ZGV2Owo+ICsgICAgYm9vbCBkZWxheV9oYW5kbGlu ZyA9IGZhbHNlOwo+ICsKPiArICAgIHFlbXVfbXV0ZXhfbG9jaygmdmRldi0+aW50cF9tdXRleCk7 Cj4gKyAgICBpZiAoaW50cC0+c3RhdGUgPT0gVkZJT19JUlFfSU5BQ1RJVkUpIHsKPiArICAgICAg ICBRTElTVF9GT1JFQUNIKHRtcCwgJnZkZXYtPmludHBfbGlzdCwgbmV4dCkgewo+ICsgICAgICAg ICAgICBpZiAodG1wLT5zdGF0ZSA9PSBWRklPX0lSUV9BQ1RJVkUgfHwKPiArICAgICAgICAgICAg ICAgIHRtcC0+c3RhdGUgPT0gVkZJT19JUlFfUEVORElORykgewo+ICsgICAgICAgICAgICAgICAg ZGVsYXlfaGFuZGxpbmcgPSB0cnVlOwo+ICsgICAgICAgICAgICAgICAgYnJlYWs7Cj4gKyAgICAg ICAgICAgIH0KPiArICAgICAgICB9Cj4gKyAgICB9Cj4gKyAgICBpZiAoZGVsYXlfaGFuZGxpbmcp IHsKPiArICAgICAgICAvKgo+ICsgICAgICAgICAqIHRoZSBuZXcgSVJRIGdldHMgYSBwZW5kaW5n IHN0YXR1cyBhbmQgaXMgcHVzaGVkIGluCj4gKyAgICAgICAgICogdGhlIHBlbmRpbmcgcXVldWUK PiArICAgICAgICAgKi8KPiArICAgICAgICBpbnRwLT5zdGF0ZSA9IFZGSU9fSVJRX1BFTkRJTkc7 Cj4gKyAgICAgICAgdHJhY2VfdmZpb19pbnRwX2ludGVycnVwdF9zZXRfcGVuZGluZyhpbnRwLT5w aW4pOwo+ICsgICAgICAgIFFTSU1QTEVRX0lOU0VSVF9UQUlMKCZ2ZGV2LT5wZW5kaW5nX2ludHBf cXVldWUsCj4gKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaW50cCwgcHFuZXh0KTsKPiAr ICAgICAgICByZXQgPSBldmVudF9ub3RpZmllcl90ZXN0X2FuZF9jbGVhcigmaW50cC0+aW50ZXJy dXB0KTsKPiArICAgICAgICBxZW11X211dGV4X3VubG9jaygmdmRldi0+aW50cF9tdXRleCk7Cj4g KyAgICAgICAgcmV0dXJuOwo+ICsgICAgfQo+ICsKPiArICAgIC8qIG5vIGFjdGl2ZSBJUlEsIHRo ZSBuZXcgSVJRIGNhbiBiZSBmb3J3YXJkZWQgdG8gdGhlIGd1ZXN0ICovCj4gKyAgICB0cmFjZV92 ZmlvX3BsYXRmb3JtX2ludHBfaW50ZXJydXB0KGludHAtPnBpbiwKPiArICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgZXZlbnRfbm90aWZpZXJfZ2V0X2ZkKCZpbnRwLT5pbnRlcnJ1cHQpKTsK PiArCj4gKyAgICBpZiAoaW50cC0+c3RhdGUgPT0gVkZJT19JUlFfSU5BQ1RJVkUpIHsKPiArICAg ICAgICByZXQgPSBldmVudF9ub3RpZmllcl90ZXN0X2FuZF9jbGVhcigmaW50cC0+aW50ZXJydXB0 KTsKPiArICAgICAgICBpZiAoIXJldCkgewo+ICsgICAgICAgICAgICBlcnJvcl9yZXBvcnQoIkVy cm9yIHdoZW4gY2xlYXJpbmcgZmQ9JWQgKHJldCA9ICVkKVxuIiwKPiArICAgICAgICAgICAgICAg ICAgICAgICAgIGV2ZW50X25vdGlmaWVyX2dldF9mZCgmaW50cC0+aW50ZXJydXB0KSwgcmV0KTsK PiArICAgICAgICB9Cj4gKyAgICB9IC8qIGVsc2UgdGhpcyBpcyBhIHBlbmRpbmcgSVJRIHRoYXQg bW92ZXMgdG8gQUNUSVZFIHN0YXRlICovCj4gKwo+ICsgICAgaW50cC0+c3RhdGUgPSBWRklPX0lS UV9BQ1RJVkU7Cj4gKwo+ICsgICAgLyogc2V0cyBzbG93IHBhdGggKi8KPiArICAgIHZmaW9fbW1h cF9zZXRfZW5hYmxlZCh2ZGV2LCBmYWxzZSk7Cj4gKwo+ICsgICAgLyogdHJpZ2dlciB0aGUgdmly dHVhbCBJUlEgKi8KPiArICAgIHFlbXVfc2V0X2lycShpbnRwLT5xZW11aXJxLCAxKTsKPiArCj4g KyAgICAvKiBzY2hlZHVsZSB0aGUgbW1hcCB0aW1lciB3aGljaCB3aWxsIHJlc3RvcmUgbW1hcCBw YXRoIGFmdGVyIEVPSSovCj4gKyAgICBpZiAodmRldi0+bW1hcF90aW1lb3V0KSB7Cj4gKyAgICAg ICAgdGltZXJfbW9kKHZkZXYtPm1tYXBfdGltZXIsCj4gKyAgICAgICAgICAgICAgICAgIHFlbXVf Y2xvY2tfZ2V0X21zKFFFTVVfQ0xPQ0tfVklSVFVBTCkgKwo+ICsgICAgICAgICAgICAgICAgICAg ICAgdmRldi0+bW1hcF90aW1lb3V0KTsKPiArICAgIH0KPiArICAgIHFlbXVfbXV0ZXhfdW5sb2Nr KCZ2ZGV2LT5pbnRwX211dGV4KTsKClNlZSBhYm92ZSBmb3IgY29tbWVudHMgYWJvdXQgcmUtZmFj dG9yaW5nIHRoaXMuIEl0J3Mgbm90IHRvdGFsbHkgY2xlYXIKd2hhdCdzIGJlaW5nIHByb3RlY3Rl ZCBieSB0aGUgbXV0ZXgsIGp1c3QgdGhlIHF1ZXVlcyBvciB0aGUgaW50cApzdHJ1Y3R1cmVzIHRo ZW1zZWx2ZXM/Cgo+ICt9Cj4gKwo+ICsvKioKPiArICogdmZpb19zdGFydF9ldmVudGZkX2luamVj dGlvbiAtIHN0YXJ0cyB0aGUgdmlydHVhbCBJUlEgaW5qZWN0aW9uIHVzaW5nCj4gKyAqIHVzZXIt c2lkZSBoYW5kbGVkIGV2ZW50ZmRzCj4gKyAqIEBpbnRwOiB0aGUgSVJRIHN0cnVjdCBwb2ludGVy Cj4gKyAqLwo+ICsKPiArc3RhdGljIGludCB2ZmlvX3N0YXJ0X2V2ZW50ZmRfaW5qZWN0aW9uKFZG SU9JTlRwICppbnRwKQo+ICt7Cj4gKyAgICBpbnQgcmV0Owo+ICsgICAgVkZJT0RldmljZSAqdmJh c2VkZXYgPSAmaW50cC0+dmRldi0+dmJhc2VkZXY7Cj4gKwo+ICsgICAgdmZpb19tYXNrX3Npbmds ZV9pcnFpbmRleCh2YmFzZWRldiwgaW50cC0+cGluKTsKPiArCj4gKyAgICByZXQgPSB2ZmlvX3Nl dF90cmlnZ2VyX2V2ZW50ZmQoaW50cCwgdmZpb19pbnRwX2ludGVycnVwdCk7Cj4gKyAgICBpZiAo cmV0KSB7Cj4gKyAgICAgICAgZXJyb3JfcmVwb3J0KCJ2ZmlvOiBFcnJvcjogRmFpbGVkIHRvIHBh c3MgSVJRIGZkIHRvIHRoZSBkcml2ZXI6ICVtIik7Cj4gKyAgICAgICAgdmZpb191bm1hc2tfc2lu Z2xlX2lycWluZGV4KHZiYXNlZGV2LCBpbnRwLT5waW4pOwo+ICsgICAgICAgIHJldHVybiByZXQ7 Cj4gKyAgICB9Cj4gKyAgICB2ZmlvX3VubWFza19zaW5nbGVfaXJxaW5kZXgodmJhc2VkZXYsIGlu dHAtPnBpbik7Cj4gKyAgICByZXR1cm4gMDsKPiArfQo+ICsKPiArLyoKPiArICogRnVuY3Rpb25z IHVzZWQgd2hhdGV2ZXIgdGhlIGluamVjdGlvbiBtZXRob2QKPiArICovCj4gKwo+ICsvKioKPiAr ICogdmZpb19zZXRfdHJpZ2dlcl9ldmVudGZkIC0gc2V0IFZGSU8gZXZlbnRmZCBoYW5kbGluZwo+ ICsgKiBpZS4gcHJvZ3JhbSB0aGUgVkZJTyBkcml2ZXIgdG8gYXNzb2NpYXRlcyBhIGdpdmVuIElS USBpbmRleAo+ICsgKiB3aXRoIGEgZmQgaGFuZGxlcgo+ICsgKgo+ICsgKiBAaW50cDogSVJRIHN0 cnVjdCBwb2ludGVyCj4gKyAqIEBoYW5kbGVyOiBoYW5kbGVyIHRvIGJlIGNhbGxlZCBvbiBldmVu dGZkIHRyaWdnZXIKPiArICovCj4gK3N0YXRpYyBpbnQgdmZpb19zZXRfdHJpZ2dlcl9ldmVudGZk KFZGSU9JTlRwICppbnRwLAo+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBl dmVudGZkX3VzZXJfc2lkZV9oYW5kbGVyX3QgaGFuZGxlcikKPiArewo+ICsgICAgVkZJT0Rldmlj ZSAqdmJhc2VkZXYgPSAmaW50cC0+dmRldi0+dmJhc2VkZXY7Cj4gKyAgICBzdHJ1Y3QgdmZpb19p cnFfc2V0ICppcnFfc2V0Owo+ICsgICAgaW50IGFyZ3N6LCByZXQ7Cj4gKyAgICBpbnQzMl90ICpw ZmQ7Cj4gKwo+ICsgICAgYXJnc3ogPSBzaXplb2YoKmlycV9zZXQpICsgc2l6ZW9mKCpwZmQpOwo+ ICsgICAgaXJxX3NldCA9IGdfbWFsbG9jMChhcmdzeik7Cj4gKyAgICBpcnFfc2V0LT5hcmdzeiA9 IGFyZ3N6Owo+ICsgICAgaXJxX3NldC0+ZmxhZ3MgPSBWRklPX0lSUV9TRVRfREFUQV9FVkVOVEZE IHwgVkZJT19JUlFfU0VUX0FDVElPTl9UUklHR0VSOwo+ICsgICAgaXJxX3NldC0+aW5kZXggPSBp bnRwLT5waW47Cj4gKyAgICBpcnFfc2V0LT5zdGFydCA9IDA7Cj4gKyAgICBpcnFfc2V0LT5jb3Vu dCA9IDE7Cj4gKyAgICBwZmQgPSAoaW50MzJfdCAqKSZpcnFfc2V0LT5kYXRhOwo+ICsgICAgKnBm ZCA9IGV2ZW50X25vdGlmaWVyX2dldF9mZCgmaW50cC0+aW50ZXJydXB0KTsKPiArICAgIHFlbXVf c2V0X2ZkX2hhbmRsZXIoKnBmZCwgKElPSGFuZGxlciAqKWhhbmRsZXIsIE5VTEwsIGludHApOwo+ ICsgICAgcmV0ID0gaW9jdGwodmJhc2VkZXYtPmZkLCBWRklPX0RFVklDRV9TRVRfSVJRUywgaXJx X3NldCk7Cj4gKyAgICBnX2ZyZWUoaXJxX3NldCk7Cj4gKyAgICBpZiAocmV0IDwgMCkgewo+ICsg ICAgICAgIGVycm9yX3JlcG9ydCgidmZpbzogRmFpbGVkIHRvIHNldCB0cmlnZ2VyIGV2ZW50ZmQ6 ICVtIik7Cj4gKyAgICAgICAgcWVtdV9zZXRfZmRfaGFuZGxlcigqcGZkLCBOVUxMLCBOVUxMLCBO VUxMKTsKPiArICAgIH0KPiArICAgIHJldHVybiByZXQ7Cj4gK30KPiArCj4gIC8qIG5vdCBpbXBs ZW1lbnRlZCB5ZXQgKi8KPiAgc3RhdGljIHZvaWQgdmZpb19wbGF0Zm9ybV9jb21wdXRlX25lZWRz X3Jlc2V0KFZGSU9EZXZpY2UgKnZiYXNlZGV2KQo+ICB7Cj4gQEAgLTM5LDYgKzI4OCw0MCBAQCBz dGF0aWMgaW50IHZmaW9fcGxhdGZvcm1faG90X3Jlc2V0X211bHRpKFZGSU9EZXZpY2UgKnZiYXNl ZGV2KQo+ICB9Cj4gIAo+ICAvKioKPiArICogdmZpb19pbml0X2ludHAgLSBhbGxvY2F0ZSwgaW5p dGlhbGl6ZSB0aGUgSVJRIHN0cnVjdCBwb2ludGVyCj4gKyAqIGFuZCBhZGQgaXQgaW50byB0aGUg bGlzdCBvZiBJUlEKPiArICogQHZiYXNlZGV2OiB0aGUgVkZJTyBkZXZpY2UKPiArICogQGluZGV4 OiBWRklPIGRldmljZSBJUlEgaW5kZXgKPiArICovCj4gK3N0YXRpYyBWRklPSU5UcCAqdmZpb19p bml0X2ludHAoVkZJT0RldmljZSAqdmJhc2VkZXYsIHVuc2lnbmVkIGludCBpbmRleCkKPiArewo+ ICsgICAgaW50IHJldDsKPiArICAgIFZGSU9QbGF0Zm9ybURldmljZSAqdmRldiA9Cj4gKyAgICAg ICAgY29udGFpbmVyX29mKHZiYXNlZGV2LCBWRklPUGxhdGZvcm1EZXZpY2UsIHZiYXNlZGV2KTsK PiArICAgIFN5c0J1c0RldmljZSAqc2JkZXYgPSBTWVNfQlVTX0RFVklDRSh2ZGV2KTsKPiArICAg IFZGSU9JTlRwICppbnRwOwo+ICsKPiArICAgIC8qIGFsbG9jYXRlIGFuZCBwb3B1bGF0ZSBhIG5l dyBWRklPSU5UcCBzdHJ1Y3R1cmUgcHV0IGluIGEgcXVldWUgbGlzdCAqLwo+ICsgICAgaW50cCA9 IGdfbWFsbG9jMChzaXplb2YoKmludHApKTsKPiArICAgIGludHAtPnZkZXYgPSB2ZGV2Owo+ICsg ICAgaW50cC0+cGluID0gaW5kZXg7Cj4gKyAgICBpbnRwLT5zdGF0ZSA9IFZGSU9fSVJRX0lOQUNU SVZFOwo+ICsgICAgc3lzYnVzX2luaXRfaXJxKHNiZGV2LCAmaW50cC0+cWVtdWlycSk7Cj4gKwo+ ICsgICAgLyogR2V0IGFuIGV2ZW50ZmQgZm9yIHRyaWdnZXIgKi8KPiArICAgIHJldCA9IGV2ZW50 X25vdGlmaWVyX2luaXQoJmludHAtPmludGVycnVwdCwgMCk7Cj4gKyAgICBpZiAocmV0KSB7Cj4g KyAgICAgICAgZ19mcmVlKGludHApOwo+ICsgICAgICAgIGVycm9yX3JlcG9ydCgidmZpbzogRXJy b3I6IHRyaWdnZXIgZXZlbnRfbm90aWZpZXJfaW5pdCBmYWlsZWQgIik7Cj4gKyAgICAgICAgcmV0 dXJuIE5VTEw7Cj4gKyAgICB9Cj4gKwo+ICsgICAgLyogc3RvcmUgdGhlIG5ldyBpbnRwIGluIHFs aXN0ICovCj4gKyAgICBRTElTVF9JTlNFUlRfSEVBRCgmdmRldi0+aW50cF9saXN0LCBpbnRwLCBu ZXh0KTsKPiArICAgIHJldHVybiBpbnRwOwo+ICt9Cj4gKwo+ICsvKioKPiAgICogdmZpb19wb3B1 bGF0ZV9kZXZpY2UgLSBpbml0aWFsaXplIE1NSU8gcmVnaW9uIGFuZCBJUlEKPiAgICogQHZiYXNl ZGV2OiB0aGUgVkZJTyBkZXZpY2UKPiAgICoKPiBAQCAtNDcsNyArMzMwLDkgQEAgc3RhdGljIGlu dCB2ZmlvX3BsYXRmb3JtX2hvdF9yZXNldF9tdWx0aShWRklPRGV2aWNlICp2YmFzZWRldikKPiAg ICovCj4gIHN0YXRpYyBpbnQgdmZpb19wb3B1bGF0ZV9kZXZpY2UoVkZJT0RldmljZSAqdmJhc2Vk ZXYpCj4gIHsKPiArICAgIHN0cnVjdCB2ZmlvX2lycV9pbmZvIGlycSA9IHsgLmFyZ3N6ID0gc2l6 ZW9mKGlycSkgfTsKPiAgICAgIHN0cnVjdCB2ZmlvX3JlZ2lvbl9pbmZvIHJlZ19pbmZvID0geyAu YXJnc3ogPSBzaXplb2YocmVnX2luZm8pIH07Cj4gKyAgICBWRklPSU5UcCAqaW50cCwgKnRtcDsK PiAgICAgIGludCBpLCByZXQgPSAtMTsKPiAgICAgIFZGSU9QbGF0Zm9ybURldmljZSAqdmRldiA9 Cj4gICAgICAgICAgY29udGFpbmVyX29mKHZiYXNlZGV2LCBWRklPUGxhdGZvcm1EZXZpY2UsIHZi YXNlZGV2KTsKPiBAQCAtODAsNyArMzY1LDM3IEBAIHN0YXRpYyBpbnQgdmZpb19wb3B1bGF0ZV9k ZXZpY2UoVkZJT0RldmljZSAqdmJhc2VkZXYpCj4gICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAodW5zaWduZWQgbG9uZyl2ZGV2LT5yZWdpb25zW2ldLT5mZF9vZmZzZXQpOwo+ICAgICAgfQo+ ICAKPiArICAgIHZkZXYtPm1tYXBfdGltZXIgPSB0aW1lcl9uZXdfbXMoUUVNVV9DTE9DS19WSVJU VUFMLAo+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB2ZmlvX2ludHBfbW1h cF9lbmFibGUsIHZkZXYpOwo+ICsKPiArICAgIFFTSU1QTEVRX0lOSVQoJnZkZXYtPnBlbmRpbmdf aW50cF9xdWV1ZSk7Cj4gKwo+ICsgICAgZm9yIChpID0gMDsgaSA8IHZiYXNlZGV2LT5udW1faXJx czsgaSsrKSB7Cj4gKyAgICAgICAgaXJxLmluZGV4ID0gaTsKPiArCj4gKyAgICAgICAgcmV0ID0g aW9jdGwodmJhc2VkZXYtPmZkLCBWRklPX0RFVklDRV9HRVRfSVJRX0lORk8sICZpcnEpOwo+ICsg ICAgICAgIGlmIChyZXQpIHsKPiArICAgICAgICAgICAgZXJyb3JfcHJpbnRmKCJ2ZmlvOiBlcnJv ciBnZXR0aW5nIGRldmljZSAlcyBpcnEgaW5mbyIsCj4gKyAgICAgICAgICAgICAgICAgICAgICAg ICB2YmFzZWRldi0+bmFtZSk7Cj4gKyAgICAgICAgICAgIGdvdG8gaXJxX2VycjsKPiArICAgICAg ICB9IGVsc2Ugewo+ICsgICAgICAgICAgICB0cmFjZV92ZmlvX3BsYXRmb3JtX3BvcHVsYXRlX2lu dGVycnVwdHMoaXJxLmluZGV4LAo+ICsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgaXJxLmNvdW50LAo+ICsgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgaXJxLmZsYWdzKTsKPiArICAgICAgICAgICAgaW50 cCA9IHZmaW9faW5pdF9pbnRwKHZiYXNlZGV2LCBpcnEuaW5kZXgpOwo+ICsgICAgICAgICAgICBp ZiAoIWludHApIHsKPiArICAgICAgICAgICAgICAgIGVycm9yX3JlcG9ydCgidmZpbzogRXJyb3Ig aW5zdGFsbGluZyBJUlEgJWQgdXAiLCBpKTsKPiArICAgICAgICAgICAgICAgIGdvdG8gaXJxX2Vy cjsKPiArICAgICAgICAgICAgfQo+ICsgICAgICAgIH0KPiArICAgIH0KPiAgICAgIHJldHVybiAw Owo+ICtpcnFfZXJyOgo+ICsgICAgdGltZXJfZGVsKHZkZXYtPm1tYXBfdGltZXIpOwo+ICsgICAg UUxJU1RfRk9SRUFDSF9TQUZFKGludHAsICZ2ZGV2LT5pbnRwX2xpc3QsIG5leHQsIHRtcCkgewo+ ICsgICAgICAgIFFMSVNUX1JFTU9WRShpbnRwLCBuZXh0KTsKPiArICAgICAgICBnX2ZyZWUoaW50 cCk7Cj4gKyAgICB9Cj4gIGVycm9yOgo+ICAgICAgZm9yIChpID0gMDsgaSA8IHZiYXNlZGV2LT5u dW1fcmVnaW9uczsgaSsrKSB7Cj4gICAgICAgICAgZ19mcmVlKHZkZXYtPnJlZ2lvbnNbaV0pOwo+ IEBAIC05Myw2ICs0MDgsNyBAQCBlcnJvcjoKPiAgc3RhdGljIFZGSU9EZXZpY2VPcHMgdmZpb19w bGF0Zm9ybV9vcHMgPSB7Cj4gICAgICAudmZpb19jb21wdXRlX25lZWRzX3Jlc2V0ID0gdmZpb19w bGF0Zm9ybV9jb21wdXRlX25lZWRzX3Jlc2V0LAo+ICAgICAgLnZmaW9faG90X3Jlc2V0X211bHRp ID0gdmZpb19wbGF0Zm9ybV9ob3RfcmVzZXRfbXVsdGksCj4gKyAgICAudmZpb19lb2kgPSB2Zmlv X3BsYXRmb3JtX2VvaSwKPiAgICAgIC52ZmlvX3BvcHVsYXRlX2RldmljZSA9IHZmaW9fcG9wdWxh dGVfZGV2aWNlLAo+ICB9Owo+ICAKPiBAQCAtMjIwLDYgKzUzNiw3IEBAIHN0YXRpYyB2b2lkIHZm aW9fcGxhdGZvcm1fcmVhbGl6ZShEZXZpY2VTdGF0ZSAqZGV2LCBFcnJvciAqKmVycnApCj4gIAo+ ICAgICAgdmJhc2VkZXYtPnR5cGUgPSBWRklPX0RFVklDRV9UWVBFX1BMQVRGT1JNOwo+ICAgICAg dmJhc2VkZXYtPm9wcyA9ICZ2ZmlvX3BsYXRmb3JtX29wczsKPiArICAgIHZkZXYtPnN0YXJ0X2ly cV9mbiA9IHZmaW9fc3RhcnRfZXZlbnRmZF9pbmplY3Rpb247Cj4gIAo+ICAgICAgdHJhY2VfdmZp b19wbGF0Zm9ybV9yZWFsaXplKHZiYXNlZGV2LT5uYW1lLCB2ZGV2LT5jb21wYXQpOwo+ICAKPiBA QCAtMjQzLDYgKzU2MCw4IEBAIHN0YXRpYyBjb25zdCBWTVN0YXRlRGVzY3JpcHRpb24gdmZpb19w bGF0Zm9ybV92bXN0YXRlID0gewo+ICAKPiAgc3RhdGljIFByb3BlcnR5IHZmaW9fcGxhdGZvcm1f ZGV2X3Byb3BlcnRpZXNbXSA9IHsKPiAgICAgIERFRklORV9QUk9QX1NUUklORygiaG9zdCIsIFZG SU9QbGF0Zm9ybURldmljZSwgdmJhc2VkZXYubmFtZSksCj4gKyAgICBERUZJTkVfUFJPUF9VSU5U MzIoIm1tYXAtdGltZW91dC1tcyIsIFZGSU9QbGF0Zm9ybURldmljZSwKPiArICAgICAgICAgICAg ICAgICAgICAgICBtbWFwX3RpbWVvdXQsIDExMDApLAo+ICAgICAgREVGSU5FX1BST1BfRU5EX09G X0xJU1QoKSwKPiAgfTsKPiAgCj4gZGlmZiAtLWdpdCBhL2luY2x1ZGUvaHcvdmZpby92ZmlvLXBs YXRmb3JtLmggYi9pbmNsdWRlL2h3L3ZmaW8vdmZpby1wbGF0Zm9ybS5oCj4gaW5kZXggMzM4ZjBj Ni4uZTU1YjcxMSAxMDA2NDQKPiAtLS0gYS9pbmNsdWRlL2h3L3ZmaW8vdmZpby1wbGF0Zm9ybS5o Cj4gKysrIGIvaW5jbHVkZS9ody92ZmlvL3ZmaW8tcGxhdGZvcm0uaAo+IEBAIC0xOCwxNiArMTgs NDkgQEAKPiAgCj4gICNpbmNsdWRlICJody9zeXNidXMuaCIKPiAgI2luY2x1ZGUgImh3L3ZmaW8v dmZpby1jb21tb24uaCIKPiArI2luY2x1ZGUgInFlbXUvZXZlbnRfbm90aWZpZXIuaCIKPiArI2lu Y2x1ZGUgInFlbXUvcXVldWUuaCIKPiArI2luY2x1ZGUgImh3L2lycS5oIgo+ICAKPiAgI2RlZmlu ZSBUWVBFX1ZGSU9fUExBVEZPUk0gInZmaW8tcGxhdGZvcm0iCj4gIAo+ICtlbnVtIHsKPiArICAg IFZGSU9fSVJRX0lOQUNUSVZFID0gMCwKPiArICAgIFZGSU9fSVJRX1BFTkRJTkcgPSAxLAo+ICsg ICAgVkZJT19JUlFfQUNUSVZFID0gMiwKPiArICAgIC8qIFZGSU9fSVJRX0FDVElWRV9BTkRfUEVO RElORyBjYW5ub3QgaGFwcGVuIHdpdGggVkZJTyAqLwo+ICt9Owo+ICsKPiArdHlwZWRlZiBzdHJ1 Y3QgVkZJT0lOVHAgewo+ICsgICAgUUxJU1RfRU5UUlkoVkZJT0lOVHApIG5leHQ7IC8qIGVudHJ5 IGZvciBJUlEgbGlzdCAqLwo+ICsgICAgUVNJTVBMRVFfRU5UUlkoVkZJT0lOVHApIHBxbmV4dDsg LyogZW50cnkgZm9yIHBlbmRpbmcgSVJRIHF1ZXVlICovCj4gKyAgICBFdmVudE5vdGlmaWVyIGlu dGVycnVwdDsgLyogZXZlbnRmZCB0cmlnZ2VyZWQgb24gaW50ZXJydXB0ICovCj4gKyAgICBFdmVu dE5vdGlmaWVyIHVubWFzazsgLyogZXZlbnRmZCBmb3IgdW5tYXNrIG9uIFFFTVUgYnlwYXNzICov Cj4gKyAgICBxZW11X2lycSBxZW11aXJxOwo+ICsgICAgc3RydWN0IFZGSU9QbGF0Zm9ybURldmlj ZSAqdmRldjsgLyogYmFjayBwb2ludGVyIHRvIGRldmljZSAqLwo+ICsgICAgaW50IHN0YXRlOyAv KiBpbmFjdGl2ZSwgcGVuZGluZywgYWN0aXZlICovCj4gKyAgICBib29sIGt2bV9hY2NlbDsgLyog c2V0IHdoZW4gUUVNVSBieXBhc3MgdGhyb3VnaCBLVk0gZW5hYmxlZCAqLwo+ICsgICAgdWludDhf dCBwaW47IC8qIGluZGV4ICovCj4gKyAgICB1aW50MzJfdCB2aXJ0dWFsSUQ7IC8qIHZpcnR1YWwg SVJRICovCj4gK30gVkZJT0lOVHA7Cj4gKwo+ICt0eXBlZGVmIGludCAoKnN0YXJ0X2lycV9mbl90 KShWRklPSU5UcCAqaW50cCk7Cj4gKwo+ICB0eXBlZGVmIHN0cnVjdCBWRklPUGxhdGZvcm1EZXZp Y2Ugewo+ICAgICAgU3lzQnVzRGV2aWNlIHNiZGV2Owo+ICAgICAgVkZJT0RldmljZSB2YmFzZWRl djsgLyogbm90IGEgUU9NIG9iamVjdCAqLwo+ICAgICAgVkZJT1JlZ2lvbiAqKnJlZ2lvbnM7Cj4g KyAgICBRTElTVF9IRUFEKCwgVkZJT0lOVHApIGludHBfbGlzdDsgLyogbGlzdCBvZiBJUlEgKi8K PiArICAgIC8qIHF1ZXVlIG9mIHBlbmRpbmcgSVJRICovCj4gKyAgICBRU0lNUExFUV9IRUFEKHBl bmRpbmdfaW50cF9xdWV1ZSwgVkZJT0lOVHApIHBlbmRpbmdfaW50cF9xdWV1ZTsKPiAgICAgIGNo YXIgKmNvbXBhdDsgLyogY29tcGF0aWJpbGl0eSBzdHJpbmcgKi8KPiArICAgIHVpbnQzMl90IG1t YXBfdGltZW91dDsgLyogZGVsYXkgdG8gcmUtZW5hYmxlIG1tYXBzIGFmdGVyIGludGVycnVwdCAq Lwo+ICsgICAgUUVNVVRpbWVyICptbWFwX3RpbWVyOyAvKiBlbmFibGUgbW1hcHMgYWZ0ZXIgcGVy aW9kcyB3L28gaW50ZXJydXB0cyAqLwo+ICsgICAgc3RhcnRfaXJxX2ZuX3Qgc3RhcnRfaXJxX2Zu Owo+ICsgICAgUWVtdU11dGV4ICBpbnRwX211dGV4OwoKSXMgdGhpcyBpbnRwX211dGV4IGp1c3Qg Zm9yIHRoZSBpbnRwX2xpc3Qgb3IgYWxzbyB0aGUKcGVuZGluZ19pbnRwX3F1ZXVlPyBQZXJoYXBz IGNvbnNpZGVyIHJlLWFycmFuZ2luZyB0aGUgc3RydWN0dXJlIGFuZAphZGRpbmcgc29tZSBzcGFj aW5nIHRvIHNob3cgd2hhdCBwcm90ZWN0cyB3aGF0LgoKPiAgfSBWRklPUGxhdGZvcm1EZXZpY2U7 Cj4gIAo+ICsKPiAgdHlwZWRlZiBzdHJ1Y3QgVkZJT1BsYXRmb3JtRGV2aWNlQ2xhc3Mgewo+ICAg ICAgLyo8IHByaXZhdGUgPiovCj4gICAgICBTeXNCdXNEZXZpY2VDbGFzcyBwYXJlbnRfY2xhc3M7 CgotLSAKQWxleCBCZW5uw6llCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fCmt2bWFybSBtYWlsaW5nIGxpc3QKa3ZtYXJtQGxpc3RzLmNzLmNvbHVtYmlhLmVk dQpodHRwczovL2xpc3RzLmNzLmNvbHVtYmlhLmVkdS9tYWlsbWFuL2xpc3RpbmZvL2t2bWFybQo= From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from eggs.gnu.org ([2001:4830:134:3::10]:46481) by lists.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1YNgGz-0008GF-Hn for qemu-devel@nongnu.org; Tue, 17 Feb 2015 06:25:03 -0500 Received: from Debian-exim by eggs.gnu.org with spam-scanned (Exim 4.71) (envelope-from ) id 1YNgGv-0002s3-FA for qemu-devel@nongnu.org; Tue, 17 Feb 2015 06:25:01 -0500 Received: from static.88-198-71-155.clients.your-server.de ([88.198.71.155]:40816 helo=socrates.bennee.com) by eggs.gnu.org with esmtp (Exim 4.71) (envelope-from ) id 1YNgGv-0002rr-4K for qemu-devel@nongnu.org; Tue, 17 Feb 2015 06:24:57 -0500 References: <1423799232-10816-1-git-send-email-eric.auger@linaro.org> <1423799232-10816-4-git-send-email-eric.auger@linaro.org> From: Alex =?utf-8?Q?Benn=C3=A9e?= In-reply-to: <1423799232-10816-4-git-send-email-eric.auger@linaro.org> Date: Tue, 17 Feb 2015 11:24:52 +0000 Message-ID: <87egpozsor.fsf@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit Subject: Re: [Qemu-devel] [PATCH v10 3/7] hw/vfio/platform: add irq assignment List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , To: Eric Auger Cc: peter.maydell@linaro.org, eric.auger@st.com, patches@linaro.org, qemu-devel@nongnu.org, agraf@suse.de, alex.williamson@redhat.com, pbonzini@redhat.com, b.reynal@virtualopensystems.com, feng.wu@intel.com, kvmarm@lists.cs.columbia.edu, christoffer.dall@linaro.org Eric Auger writes: > This patch adds the code requested to assign interrupts to > a guest. The interrupts are mediated through user handled > eventfds only. > > The mechanics to start the IRQ handling is not yet there through. > > Signed-off-by: Eric Auger See comments inline. > > --- > > v8 -> v9: > - free irq related resources in case of error in vfio_populate_device > --- > hw/vfio/platform.c | 319 ++++++++++++++++++++++++++++++++++++++++ > include/hw/vfio/vfio-platform.h | 33 +++++ > 2 files changed, 352 insertions(+) > > diff --git a/hw/vfio/platform.c b/hw/vfio/platform.c > index caadb92..b85ad6c 100644 > --- a/hw/vfio/platform.c > +++ b/hw/vfio/platform.c > @@ -22,10 +22,259 @@ > #include "qemu/range.h" > #include "sysemu/sysemu.h" > #include "exec/memory.h" > +#include "qemu/queue.h" > #include "hw/sysbus.h" > #include "trace.h" > #include "hw/platform-bus.h" > > +static void vfio_intp_interrupt(VFIOINTp *intp); > +typedef void (*eventfd_user_side_handler_t)(VFIOINTp *intp); > +static int vfio_set_trigger_eventfd(VFIOINTp *intp, > + eventfd_user_side_handler_t handler); > + > +/* > + * Functions only used when eventfd are handled on user-side > + * ie. without irqfd > + */ > + > +/** > + * vfio_platform_eoi - IRQ completion routine > + * @vbasedev: the VFIO device > + * > + * de-asserts the active virtual IRQ and unmask the physical IRQ > + * (masked by the VFIO driver). Handle pending IRQs if any. > + * eoi function is called on the first access to any MMIO region > + * after an IRQ was triggered. It is assumed this access corresponds > + * to the IRQ status register reset. With such a mechanism, a single > + * IRQ can be handled at a time since there is no way to know which > + * IRQ was completed by the guest (we would need additional details > + * about the IRQ status register mask) > + */ > +static void vfio_platform_eoi(VFIODevice *vbasedev) > +{ > + VFIOINTp *intp; > + VFIOPlatformDevice *vdev = > + container_of(vbasedev, VFIOPlatformDevice, vbasedev); > + > + qemu_mutex_lock(&vdev->intp_mutex); > + QLIST_FOREACH(intp, &vdev->intp_list, next) { > + if (intp->state == VFIO_IRQ_ACTIVE) { > + trace_vfio_platform_eoi(intp->pin, > + event_notifier_get_fd(&intp->interrupt)); > + intp->state = VFIO_IRQ_INACTIVE; > + > + /* deassert the virtual IRQ and unmask physical one */ > + qemu_set_irq(intp->qemuirq, 0); > + vfio_unmask_single_irqindex(vbasedev, intp->pin); > + > + /* a single IRQ can be active at a time */ > + break; > + } > + } > + /* in case there are pending IRQs, handle them one at a time */ > + if (!QSIMPLEQ_EMPTY(&vdev->pending_intp_queue)) { > + intp = QSIMPLEQ_FIRST(&vdev->pending_intp_queue); > + trace_vfio_platform_eoi_handle_pending(intp->pin); > + qemu_mutex_unlock(&vdev->intp_mutex); > + vfio_intp_interrupt(intp); > + qemu_mutex_lock(&vdev->intp_mutex); > + QSIMPLEQ_REMOVE_HEAD(&vdev->pending_intp_queue, pqnext); > + qemu_mutex_unlock(&vdev->intp_mutex); This locking is way too ugly. If the intp lock is protecting the structures then releasing it so the child function can grab it again is just asking for races to happen. Perhaps vfio_intp_interrupt can be split to have a _lockheld variant that can be used here and the other version do the locking before calling the _lockheld function. > + } else { > + qemu_mutex_unlock(&vdev->intp_mutex); > + } > +} > + > +/** > + * vfio_mmap_set_enabled - enable/disable the fast path mode > + * @vdev: the VFIO platform device > + * @enabled: the target mmap state > + * > + * true ~ fast path = MMIO region is mmaped (no KVM TRAP) > + * false ~ slow path = MMIO region is trapped and region callbacks > + * are called slow path enables to trap the IRQ status register > + * guest reset > +*/ > + > +static void vfio_mmap_set_enabled(VFIOPlatformDevice *vdev, bool enabled) > +{ > + VFIORegion *region; region could be defined inside the block, not that it matters too much for a small function like this. > + int i; > + > + trace_vfio_platform_mmap_set_enabled(enabled); > + > + for (i = 0; i < vdev->vbasedev.num_regions; i++) { > + region = vdev->regions[i]; > + > + /* register space is unmapped to trap EOI */ > + memory_region_set_enabled(®ion->mmap_mem, enabled); > + } > +} > + > +/** > + * vfio_intp_mmap_enable - timer function, restores the fast path > + * if there is no more active IRQ > + * @opaque: actually points to the VFIO platform device > + * > + * Called on mmap timer timout, this function checks whether the > + * IRQ is still active and in the negative restores the fast path. > + * by construction a single eventfd is handled at a time. > + * if the IRQ is still active, the timer is restarted. > + */ > +static void vfio_intp_mmap_enable(void *opaque) > +{ > + VFIOINTp *tmp; > + VFIOPlatformDevice *vdev = (VFIOPlatformDevice *)opaque; > + > + qemu_mutex_lock(&vdev->intp_mutex); > + QLIST_FOREACH(tmp, &vdev->intp_list, next) { > + if (tmp->state == VFIO_IRQ_ACTIVE) { > + trace_vfio_platform_intp_mmap_enable(tmp->pin); > + /* re-program the timer to check active status later */ > + timer_mod(vdev->mmap_timer, > + qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + > + vdev->mmap_timeout); > + qemu_mutex_unlock(&vdev->intp_mutex); > + return; > + } > + } > + vfio_mmap_set_enabled(vdev, true); > + qemu_mutex_unlock(&vdev->intp_mutex); > +} > + > +/** > + * vfio_intp_interrupt - The user-side eventfd handler > + * @opaque: opaque pointer which in practice is the VFIOINTp* > + * > + * the function can be entered > + * - in event handler context: this IRQ is inactive > + * in that case, the vIRQ is injected into the guest if there > + * is no other active or pending IRQ. > + * - in IOhandler context: this IRQ is pending. > + * there is no ACTIVE IRQ > + */ > +static void vfio_intp_interrupt(VFIOINTp *intp) > +{ > + int ret; > + VFIOINTp *tmp; > + VFIOPlatformDevice *vdev = intp->vdev; > + bool delay_handling = false; > + > + qemu_mutex_lock(&vdev->intp_mutex); > + if (intp->state == VFIO_IRQ_INACTIVE) { > + QLIST_FOREACH(tmp, &vdev->intp_list, next) { > + if (tmp->state == VFIO_IRQ_ACTIVE || > + tmp->state == VFIO_IRQ_PENDING) { > + delay_handling = true; > + break; > + } > + } > + } > + if (delay_handling) { > + /* > + * the new IRQ gets a pending status and is pushed in > + * the pending queue > + */ > + intp->state = VFIO_IRQ_PENDING; > + trace_vfio_intp_interrupt_set_pending(intp->pin); > + QSIMPLEQ_INSERT_TAIL(&vdev->pending_intp_queue, > + intp, pqnext); > + ret = event_notifier_test_and_clear(&intp->interrupt); > + qemu_mutex_unlock(&vdev->intp_mutex); > + return; > + } > + > + /* no active IRQ, the new IRQ can be forwarded to the guest */ > + trace_vfio_platform_intp_interrupt(intp->pin, > + event_notifier_get_fd(&intp->interrupt)); > + > + if (intp->state == VFIO_IRQ_INACTIVE) { > + ret = event_notifier_test_and_clear(&intp->interrupt); > + if (!ret) { > + error_report("Error when clearing fd=%d (ret = %d)\n", > + event_notifier_get_fd(&intp->interrupt), ret); > + } > + } /* else this is a pending IRQ that moves to ACTIVE state */ > + > + intp->state = VFIO_IRQ_ACTIVE; > + > + /* sets slow path */ > + vfio_mmap_set_enabled(vdev, false); > + > + /* trigger the virtual IRQ */ > + qemu_set_irq(intp->qemuirq, 1); > + > + /* schedule the mmap timer which will restore mmap path after EOI*/ > + if (vdev->mmap_timeout) { > + timer_mod(vdev->mmap_timer, > + qemu_clock_get_ms(QEMU_CLOCK_VIRTUAL) + > + vdev->mmap_timeout); > + } > + qemu_mutex_unlock(&vdev->intp_mutex); See above for comments about re-factoring this. It's not totally clear what's being protected by the mutex, just the queues or the intp structures themselves? > +} > + > +/** > + * vfio_start_eventfd_injection - starts the virtual IRQ injection using > + * user-side handled eventfds > + * @intp: the IRQ struct pointer > + */ > + > +static int vfio_start_eventfd_injection(VFIOINTp *intp) > +{ > + int ret; > + VFIODevice *vbasedev = &intp->vdev->vbasedev; > + > + vfio_mask_single_irqindex(vbasedev, intp->pin); > + > + ret = vfio_set_trigger_eventfd(intp, vfio_intp_interrupt); > + if (ret) { > + error_report("vfio: Error: Failed to pass IRQ fd to the driver: %m"); > + vfio_unmask_single_irqindex(vbasedev, intp->pin); > + return ret; > + } > + vfio_unmask_single_irqindex(vbasedev, intp->pin); > + return 0; > +} > + > +/* > + * Functions used whatever the injection method > + */ > + > +/** > + * vfio_set_trigger_eventfd - set VFIO eventfd handling > + * ie. program the VFIO driver to associates a given IRQ index > + * with a fd handler > + * > + * @intp: IRQ struct pointer > + * @handler: handler to be called on eventfd trigger > + */ > +static int vfio_set_trigger_eventfd(VFIOINTp *intp, > + eventfd_user_side_handler_t handler) > +{ > + VFIODevice *vbasedev = &intp->vdev->vbasedev; > + struct vfio_irq_set *irq_set; > + int argsz, ret; > + int32_t *pfd; > + > + argsz = sizeof(*irq_set) + sizeof(*pfd); > + irq_set = g_malloc0(argsz); > + irq_set->argsz = argsz; > + irq_set->flags = VFIO_IRQ_SET_DATA_EVENTFD | VFIO_IRQ_SET_ACTION_TRIGGER; > + irq_set->index = intp->pin; > + irq_set->start = 0; > + irq_set->count = 1; > + pfd = (int32_t *)&irq_set->data; > + *pfd = event_notifier_get_fd(&intp->interrupt); > + qemu_set_fd_handler(*pfd, (IOHandler *)handler, NULL, intp); > + ret = ioctl(vbasedev->fd, VFIO_DEVICE_SET_IRQS, irq_set); > + g_free(irq_set); > + if (ret < 0) { > + error_report("vfio: Failed to set trigger eventfd: %m"); > + qemu_set_fd_handler(*pfd, NULL, NULL, NULL); > + } > + return ret; > +} > + > /* not implemented yet */ > static void vfio_platform_compute_needs_reset(VFIODevice *vbasedev) > { > @@ -39,6 +288,40 @@ static int vfio_platform_hot_reset_multi(VFIODevice *vbasedev) > } > > /** > + * vfio_init_intp - allocate, initialize the IRQ struct pointer > + * and add it into the list of IRQ > + * @vbasedev: the VFIO device > + * @index: VFIO device IRQ index > + */ > +static VFIOINTp *vfio_init_intp(VFIODevice *vbasedev, unsigned int index) > +{ > + int ret; > + VFIOPlatformDevice *vdev = > + container_of(vbasedev, VFIOPlatformDevice, vbasedev); > + SysBusDevice *sbdev = SYS_BUS_DEVICE(vdev); > + VFIOINTp *intp; > + > + /* allocate and populate a new VFIOINTp structure put in a queue list */ > + intp = g_malloc0(sizeof(*intp)); > + intp->vdev = vdev; > + intp->pin = index; > + intp->state = VFIO_IRQ_INACTIVE; > + sysbus_init_irq(sbdev, &intp->qemuirq); > + > + /* Get an eventfd for trigger */ > + ret = event_notifier_init(&intp->interrupt, 0); > + if (ret) { > + g_free(intp); > + error_report("vfio: Error: trigger event_notifier_init failed "); > + return NULL; > + } > + > + /* store the new intp in qlist */ > + QLIST_INSERT_HEAD(&vdev->intp_list, intp, next); > + return intp; > +} > + > +/** > * vfio_populate_device - initialize MMIO region and IRQ > * @vbasedev: the VFIO device > * > @@ -47,7 +330,9 @@ static int vfio_platform_hot_reset_multi(VFIODevice *vbasedev) > */ > static int vfio_populate_device(VFIODevice *vbasedev) > { > + struct vfio_irq_info irq = { .argsz = sizeof(irq) }; > struct vfio_region_info reg_info = { .argsz = sizeof(reg_info) }; > + VFIOINTp *intp, *tmp; > int i, ret = -1; > VFIOPlatformDevice *vdev = > container_of(vbasedev, VFIOPlatformDevice, vbasedev); > @@ -80,7 +365,37 @@ static int vfio_populate_device(VFIODevice *vbasedev) > (unsigned long)vdev->regions[i]->fd_offset); > } > > + vdev->mmap_timer = timer_new_ms(QEMU_CLOCK_VIRTUAL, > + vfio_intp_mmap_enable, vdev); > + > + QSIMPLEQ_INIT(&vdev->pending_intp_queue); > + > + for (i = 0; i < vbasedev->num_irqs; i++) { > + irq.index = i; > + > + ret = ioctl(vbasedev->fd, VFIO_DEVICE_GET_IRQ_INFO, &irq); > + if (ret) { > + error_printf("vfio: error getting device %s irq info", > + vbasedev->name); > + goto irq_err; > + } else { > + trace_vfio_platform_populate_interrupts(irq.index, > + irq.count, > + irq.flags); > + intp = vfio_init_intp(vbasedev, irq.index); > + if (!intp) { > + error_report("vfio: Error installing IRQ %d up", i); > + goto irq_err; > + } > + } > + } > return 0; > +irq_err: > + timer_del(vdev->mmap_timer); > + QLIST_FOREACH_SAFE(intp, &vdev->intp_list, next, tmp) { > + QLIST_REMOVE(intp, next); > + g_free(intp); > + } > error: > for (i = 0; i < vbasedev->num_regions; i++) { > g_free(vdev->regions[i]); > @@ -93,6 +408,7 @@ error: > static VFIODeviceOps vfio_platform_ops = { > .vfio_compute_needs_reset = vfio_platform_compute_needs_reset, > .vfio_hot_reset_multi = vfio_platform_hot_reset_multi, > + .vfio_eoi = vfio_platform_eoi, > .vfio_populate_device = vfio_populate_device, > }; > > @@ -220,6 +536,7 @@ static void vfio_platform_realize(DeviceState *dev, Error **errp) > > vbasedev->type = VFIO_DEVICE_TYPE_PLATFORM; > vbasedev->ops = &vfio_platform_ops; > + vdev->start_irq_fn = vfio_start_eventfd_injection; > > trace_vfio_platform_realize(vbasedev->name, vdev->compat); > > @@ -243,6 +560,8 @@ static const VMStateDescription vfio_platform_vmstate = { > > static Property vfio_platform_dev_properties[] = { > DEFINE_PROP_STRING("host", VFIOPlatformDevice, vbasedev.name), > + DEFINE_PROP_UINT32("mmap-timeout-ms", VFIOPlatformDevice, > + mmap_timeout, 1100), > DEFINE_PROP_END_OF_LIST(), > }; > > diff --git a/include/hw/vfio/vfio-platform.h b/include/hw/vfio/vfio-platform.h > index 338f0c6..e55b711 100644 > --- a/include/hw/vfio/vfio-platform.h > +++ b/include/hw/vfio/vfio-platform.h > @@ -18,16 +18,49 @@ > > #include "hw/sysbus.h" > #include "hw/vfio/vfio-common.h" > +#include "qemu/event_notifier.h" > +#include "qemu/queue.h" > +#include "hw/irq.h" > > #define TYPE_VFIO_PLATFORM "vfio-platform" > > +enum { > + VFIO_IRQ_INACTIVE = 0, > + VFIO_IRQ_PENDING = 1, > + VFIO_IRQ_ACTIVE = 2, > + /* VFIO_IRQ_ACTIVE_AND_PENDING cannot happen with VFIO */ > +}; > + > +typedef struct VFIOINTp { > + QLIST_ENTRY(VFIOINTp) next; /* entry for IRQ list */ > + QSIMPLEQ_ENTRY(VFIOINTp) pqnext; /* entry for pending IRQ queue */ > + EventNotifier interrupt; /* eventfd triggered on interrupt */ > + EventNotifier unmask; /* eventfd for unmask on QEMU bypass */ > + qemu_irq qemuirq; > + struct VFIOPlatformDevice *vdev; /* back pointer to device */ > + int state; /* inactive, pending, active */ > + bool kvm_accel; /* set when QEMU bypass through KVM enabled */ > + uint8_t pin; /* index */ > + uint32_t virtualID; /* virtual IRQ */ > +} VFIOINTp; > + > +typedef int (*start_irq_fn_t)(VFIOINTp *intp); > + > typedef struct VFIOPlatformDevice { > SysBusDevice sbdev; > VFIODevice vbasedev; /* not a QOM object */ > VFIORegion **regions; > + QLIST_HEAD(, VFIOINTp) intp_list; /* list of IRQ */ > + /* queue of pending IRQ */ > + QSIMPLEQ_HEAD(pending_intp_queue, VFIOINTp) pending_intp_queue; > char *compat; /* compatibility string */ > + uint32_t mmap_timeout; /* delay to re-enable mmaps after interrupt */ > + QEMUTimer *mmap_timer; /* enable mmaps after periods w/o interrupts */ > + start_irq_fn_t start_irq_fn; > + QemuMutex intp_mutex; Is this intp_mutex just for the intp_list or also the pending_intp_queue? Perhaps consider re-arranging the structure and adding some spacing to show what protects what. > } VFIOPlatformDevice; > > + > typedef struct VFIOPlatformDeviceClass { > /*< private >*/ > SysBusDeviceClass parent_class; -- Alex BennĂ©e