From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alex =?utf-8?Q?Benn=C3=A9e?= Subject: Re: [PATCH v4 02/28] arm64: KVM: Hide unsupported AArch64 CPU features from guests Date: Tue, 31 Oct 2017 10:57:32 +0000 Message-ID: <874lqfinz7.fsf@linaro.org> References: <1509101470-7881-1-git-send-email-Dave.Martin@arm.com> <1509101470-7881-3-git-send-email-Dave.Martin@arm.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: In-reply-to: <1509101470-7881-3-git-send-email-Dave.Martin@arm.com> 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: Dave Martin Cc: linux-arch@vger.kernel.org, Okamoto Takayuki , libc-alpha@sourceware.org, Ard Biesheuvel , Szabolcs Nagy , Catalin Marinas , Will Deacon , kvmarm@lists.cs.columbia.edu, linux-arm-kernel@lists.infradead.org List-Id: linux-arch.vger.kernel.org CkRhdmUgTWFydGluIDxEYXZlLk1hcnRpbkBhcm0uY29tPiB3cml0ZXM6Cgo+IEN1cnJlbnRseSwg YSBndWVzdCBrZXJuZWwgc2VlcyB0aGUgdHJ1ZSBDUFUgZmVhdHVyZSByZWdpc3RlcnMKPiAoSURf Kl9FTDEpIHdoZW4gaXQgcmVhZHMgdGhlbSB1c2luZyBNUlMgaW5zdHJ1Y3Rpb25zLiAgVGhpcyBt ZWFucwo+IHRoYXQgdGhlIGd1ZXN0IG1heSBvYnNlcnZlIGZlYXR1cmVzIHRoYXQgYXJlIHByZXNl bnQgaW4gdGhlCj4gaGFyZHdhcmUgYnV0IHRoZSBob3N0IGRvZXNuJ3QgdW5kZXJzdGFuZCBvciBk b2Vzbid0IHByb3ZpZGUgc3VwcG9ydAo+IGZvci4gIEEgZ3Vlc3QgbWF5IGxlZ2ltaXRhdGVseSB0 cnkgdG8gdXNlIHN1Y2ggYSBmZWF0dXJlIGFzIHBlciB0aGUKPiBhcmNoaXRlY3R1cmUsIGJ1dCB1 c2Ugb2YgdGhlIGZlYXR1cmUgbWF5IHRyYXAgaW5zdGVhZCBvZiB3b3JraW5nCj4gbm9ybWFsbHks IHRyaWdnZXJpbmcgdW5kZWYgaW5qZWN0aW9uIGludG8gdGhlIGd1ZXN0Lgo+Cj4gVGhpcyBpcyBu b3QgYSBwcm9ibGVtIGZvciB0aGUgaG9zdCwgYnV0IHRoZSBndWVzdCBtYXkgZ28gd3Jvbmcgd2hl bgo+IHJ1bm5pbmcgb24gbmV3ZXIgaGFyZHdhcmUgdGhhbiB0aGUgaG9zdCBrbm93cyBhYm91dC4K Pgo+IFRoaXMgcGF0Y2ggaGlkZXMgZnJvbSBndWVzdCBWTXMgYW55IEFBcmNoNjQtc3BlY2lmaWMg Q1BVIGZlYXR1cmVzCj4gdGhhdCB0aGUgaG9zdCBkb2Vzbid0IHN1cHBvcnQsIGJ5IGV4cG9zaW5n IHRvIHRoZSBndWVzdCB0aGUKPiBzYW5pdGlzZWQgdmVyc2lvbnMgb2YgdGhlIHJlZ2lzdGVycyBj b21wdXRlZCBieSB0aGUgY3B1ZmVhdHVyZXMKPiBmcmFtZXdvcmssIGluc3RlYWQgb2YgdGhlIHRy dWUgaGFyZHdhcmUgcmVnaXN0ZXJzLiAgVG8gYWNoaWV2ZQo+IHRoaXMsIEhDUl9FTDIuVElEMyBp cyBub3cgc2V0IGZvciBBQXJjaDY0IGd1ZXN0cywgYW5kIGVtdWxhdGlvbgo+IGNvZGUgaXMgYWRk ZWQgdG8gS1ZNIHRvIHJlcG9ydCB0aGUgc2FuaXRpc2VkIHZlcnNpb25zIG9mIHRoZQo+IGFmZmVj dGVkIHJlZ2lzdGVycyBpbiByZXNwb25zZSB0byBNUlMgYW5kIHJlZ2lzdGVyIHJlYWRzIGZyb20K PiB1c2Vyc3BhY2UuCj4KPiBUaGUgYWZmZWN0ZWQgcmVnaXN0ZXJzIGFyZSByZW1vdmVkIGZyb20g aW52YXJpYW50X3N5c19yZWdzW10gKHNpbmNlCj4gdGhlIGludmFyaWFudF9zeXNfcmVncyBoYW5k bGluZyBpcyBubyBsb25nZXIgcXVpdGUgY29ycmVjdCBmb3IKPiB0aGVtKSBhbmQgYWRkZWQgdG8g c3lzX3JlZ19kZXNnc1tdLCB3aXRoIGFwcHJvcHJpYXRlIGFjY2VzcygpLAo+IGdldF91c2VyKCkg YW5kIHNldF91c2VyKCkgbWV0aG9kcy4gIE5vIHJ1bnRpbWUgdmNwdSBzdG9yYWdlIGlzCj4gYWxs b2NhdGVkIGZvciB0aGUgcmVnaXN0ZXJzOiBpbnN0ZWFkLCB0aGV5IGFyZSByZWFkIG9uIGRlbWFu ZCBmcm9tCj4gdGhlIGNwdWZlYXR1cmVzIGZyYW1ld29yay4gIFRoaXMgbWF5IG5lZWQgbW9kaWZp Y2F0aW9uIGluIHRoZQo+IGZ1dHVyZSBpZiB0aGVyZSBpcyBhIG5lZWQgZm9yIHVzZXJzcGFjZSB0 byBjdXN0b21pc2UgdGhlIGZlYXR1cmVzCj4gdmlzaWJsZSB0byB0aGUgZ3Vlc3QuCj4KPiBBdHRl bXB0cyBieSB1c2Vyc3BhY2UgdG8gd3JpdGUgdGhlIHJlZ2lzdGVycyBhcmUgaGFuZGxlZCBzaW1p bGFybHkKPiB0byB0aGUgY3VycmVudCBpbnZhcmlhbnRfc3lzX3JlZ3MgaGFuZGxpbmc6IHdyaXRl cyBhcmUgcGVybWl0dGVkLAo+IGJ1dCBvbmx5IGlmIHRoZXkgZG9uJ3QgYXR0ZW1wdCB0byBjaGFu Z2UgdGhlIHZhbHVlLiAgVGhpcyBpcwo+IHN1ZmZpY2llbnQgdG8gc3VwcG9ydCBWTSBzbmFwc2hv dC9yZXN0b3JlIGZyb20gdXNlcnNwYWNlLgo+Cj4gQmVjYXVzZSBvZiB0aGUgYWRkaXRpb25hbCBy ZWdpc3RlcnMsIHJlc3RvcmluZyBhIFZNIG9uIGFuIG9sZGVyCj4ga2VybmVsIG1heSBub3Qgd29y ayB1bmxlc3MgdXNlcnNwYWNlIGtub3dzIGhvdyB0byBoYW5kbGUgdGhlIGV4dHJhCj4gVk0gcmVn aXN0ZXJzIGV4cG9zZWQgdG8gdGhlIEtWTSB1c2VyIEFCSSBieSB0aGlzIHBhdGNoLgo+Cj4gVW5k ZXIgdGhlIHByaW5jaXBsZSBvZiBsZWFzdCBkYW1hZ2UsIHRoaXMgcGF0Y2ggbWFrZXMgbm8gYXR0 ZW1wdCB0bwo+IGhhbmRsZSBhbnkgb2YgdGhlIG90aGVyIHJlZ2lzdGVycyBjdXJyZW50bHkgaW4K PiBpbnZhcmlhbnRfc3lzX3JlZ3NbXSwgb3IgdG8gZW11bGF0ZSByZWdpc3RlcnMgZm9yIEFBcmNo MzI6IGhvd2V2ZXIsCj4gdGhlc2UgY291bGQgYmUgaGFuZGxlZCBpbiBhIHNpbWlsYXIgd2F5IGlu IGZ1dHVyZSwgYXMgbmVjZXNzYXJ5Lgo+Cj4gU2lnbmVkLW9mZi1ieTogRGF2ZSBNYXJ0aW4gPERh dmUuTWFydGluQGFybS5jb20+Cj4gUmV2aWV3ZWQtYnk6IE1hcmMgWnluZ2llciA8bWFyYy56eW5n aWVyQGFybS5jb20+Cj4gQWNrZWQtYnk6IENhdGFsaW4gTWFyaW5hcyA8Y2F0YWxpbi5tYXJpbmFz QGFybS5jb20+Cj4gQ2M6IENocmlzdG9mZmVyIERhbGwgPGNocmlzdG9mZmVyLmRhbGxAbGluYXJv Lm9yZz4KClJldmlld2VkLWJ5OiBBbGV4IEJlbm7DqWUgPGFsZXguYmVubmVlQGxpbmFyby5vcmc+ Cgo+IC0tLQo+ICBhcmNoL2FybTY0L2luY2x1ZGUvYXNtL3N5c3JlZy5oIHwgICAzICsKPiAgYXJj aC9hcm02NC9rdm0vaHlwL3N3aXRjaC5jICAgICB8ICAgNiArCj4gIGFyY2gvYXJtNjQva3ZtL3N5 c19yZWdzLmMgICAgICAgfCAyODIgKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrLS0t LS0tLQo+ICAzIGZpbGVzIGNoYW5nZWQsIDI0NiBpbnNlcnRpb25zKCspLCA0NSBkZWxldGlvbnMo LSkKPgo+IGRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL3N5c3JlZy5oIGIvYXJj aC9hcm02NC9pbmNsdWRlL2FzbS9zeXNyZWcuaAo+IGluZGV4IDRkY2ViMTIuLjYwOWQ1OWFmIDEw MDY0NAo+IC0tLSBhL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20vc3lzcmVnLmgKPiArKysgYi9hcmNo L2FybTY0L2luY2x1ZGUvYXNtL3N5c3JlZy5oCj4gQEAgLTE0OSw2ICsxNDksOSBAQAo+ICAjZGVm aW5lIFNZU19JRF9BQTY0REZSMF9FTDEJCXN5c19yZWcoMywgMCwgMCwgNSwgMCkKPiAgI2RlZmlu ZSBTWVNfSURfQUE2NERGUjFfRUwxCQlzeXNfcmVnKDMsIDAsIDAsIDUsIDEpCj4KPiArI2RlZmlu ZSBTWVNfSURfQUE2NEFGUjBfRUwxCQlzeXNfcmVnKDMsIDAsIDAsIDUsIDQpCj4gKyNkZWZpbmUg U1lTX0lEX0FBNjRBRlIxX0VMMQkJc3lzX3JlZygzLCAwLCAwLCA1LCA1KQo+ICsKPiAgI2RlZmlu ZSBTWVNfSURfQUE2NElTQVIwX0VMMQkJc3lzX3JlZygzLCAwLCAwLCA2LCAwKQo+ICAjZGVmaW5l IFNZU19JRF9BQTY0SVNBUjFfRUwxCQlzeXNfcmVnKDMsIDAsIDAsIDYsIDEpCj4KPiBkaWZmIC0t Z2l0IGEvYXJjaC9hcm02NC9rdm0vaHlwL3N3aXRjaC5jIGIvYXJjaC9hcm02NC9rdm0vaHlwL3N3 aXRjaC5jCj4gaW5kZXggOTQ1ZTc5Yy4uMzVhOTBiOCAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybTY0 L2t2bS9oeXAvc3dpdGNoLmMKPiArKysgYi9hcmNoL2FybTY0L2t2bS9oeXAvc3dpdGNoLmMKPiBA QCAtODEsMTEgKzgxLDE3IEBAIHN0YXRpYyB2b2lkIF9faHlwX3RleHQgX19hY3RpdmF0ZV90cmFw cyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCj4gIAkgKiBpdCB3aWxsIGNhdXNlIGFuIGV4Y2VwdGlv bi4KPiAgCSAqLwo+ICAJdmFsID0gdmNwdS0+YXJjaC5oY3JfZWwyOwo+ICsKPiAgCWlmICghKHZh bCAmIEhDUl9SVykgJiYgc3lzdGVtX3N1cHBvcnRzX2Zwc2ltZCgpKSB7Cj4gIAkJd3JpdGVfc3lz cmVnKDEgPDwgMzAsIGZwZXhjMzJfZWwyKTsKPiAgCQlpc2IoKTsKPiAgCX0KPiArCj4gKwlpZiAo dmFsICYgSENSX1JXKSAvKiBmb3IgQUFyY2g2NCBvbmx5OiAqLwo+ICsJCXZhbCB8PSBIQ1JfVElE MzsgLyogVElEMzogdHJhcCBmZWF0dXJlIHJlZ2lzdGVyIGFjY2Vzc2VzICovCj4gKwo+ICAJd3Jp dGVfc3lzcmVnKHZhbCwgaGNyX2VsMik7Cj4gKwo+ICAJLyogVHJhcCBvbiBBQXJjaDMyIGNwMTUg YzE1IGFjY2Vzc2VzIChFTDEgb3IgRUwwKSAqLwo+ICAJd3JpdGVfc3lzcmVnKDEgPDwgMTUsIGhz dHJfZWwyKTsKPiAgCS8qCj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQva3ZtL3N5c19yZWdzLmMg Yi9hcmNoL2FybTY0L2t2bS9zeXNfcmVncy5jCj4gaW5kZXggMmUwNzBkMy4uYjFmNzU1MiAxMDA2 NDQKPiAtLS0gYS9hcmNoL2FybTY0L2t2bS9zeXNfcmVncy5jCj4gKysrIGIvYXJjaC9hcm02NC9r dm0vc3lzX3JlZ3MuYwo+IEBAIC04OTIsNiArODkyLDEzNyBAQCBzdGF0aWMgYm9vbCBhY2Nlc3Nf Y250cF9jdmFsKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwKPiAgCXJldHVybiB0cnVlOwo+ICB9Cj4K PiArLyogUmVhZCBhIHNhbml0aXNlZCBjcHVmZWF0dXJlIElEIHJlZ2lzdGVyIGJ5IHN5c19yZWdf ZGVzYyAqLwo+ICtzdGF0aWMgdTY0IHJlYWRfaWRfcmVnKHN0cnVjdCBzeXNfcmVnX2Rlc2MgY29u c3QgKnIsIGJvb2wgcmF6KQo+ICt7Cj4gKwl1MzIgaWQgPSBzeXNfcmVnKCh1MzIpci0+T3AwLCAo dTMyKXItPk9wMSwKPiArCQkJICh1MzIpci0+Q1JuLCAodTMyKXItPkNSbSwgKHUzMilyLT5PcDIp Owo+ICsKPiArCXJldHVybiByYXogPyAwIDogcmVhZF9zYW5pdGlzZWRfZnRyX3JlZyhpZCk7Cj4g K30KPiArCj4gKy8qIGNwdWZlYXR1cmUgSUQgcmVnaXN0ZXIgYWNjZXNzIHRyYXAgaGFuZGxlcnMg Ki8KPiArCj4gK3N0YXRpYyBib29sIF9fYWNjZXNzX2lkX3JlZyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZj cHUsCj4gKwkJCSAgICBzdHJ1Y3Qgc3lzX3JlZ19wYXJhbXMgKnAsCj4gKwkJCSAgICBjb25zdCBz dHJ1Y3Qgc3lzX3JlZ19kZXNjICpyLAo+ICsJCQkgICAgYm9vbCByYXopCj4gK3sKPiArCWlmIChw LT5pc193cml0ZSkKPiArCQlyZXR1cm4gd3JpdGVfdG9fcmVhZF9vbmx5KHZjcHUsIHAsIHIpOwo+ ICsKPiArCXAtPnJlZ3ZhbCA9IHJlYWRfaWRfcmVnKHIsIHJheik7Cj4gKwlyZXR1cm4gdHJ1ZTsK PiArfQo+ICsKPiArc3RhdGljIGJvb2wgYWNjZXNzX2lkX3JlZyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZj cHUsCj4gKwkJCSAgc3RydWN0IHN5c19yZWdfcGFyYW1zICpwLAo+ICsJCQkgIGNvbnN0IHN0cnVj dCBzeXNfcmVnX2Rlc2MgKnIpCj4gK3sKPiArCXJldHVybiBfX2FjY2Vzc19pZF9yZWcodmNwdSwg cCwgciwgZmFsc2UpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgYm9vbCBhY2Nlc3NfcmF6X2lkX3JlZyhz dHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsCj4gKwkJCSAgICAgIHN0cnVjdCBzeXNfcmVnX3BhcmFtcyAq cCwKPiArCQkJICAgICAgY29uc3Qgc3RydWN0IHN5c19yZWdfZGVzYyAqcikKPiArewo+ICsJcmV0 dXJuIF9fYWNjZXNzX2lkX3JlZyh2Y3B1LCBwLCByLCB0cnVlKTsKPiArfQo+ICsKPiArc3RhdGlj IGludCByZWdfZnJvbV91c2VyKHU2NCAqdmFsLCBjb25zdCB2b2lkIF9fdXNlciAqdWFkZHIsIHU2 NCBpZCk7Cj4gK3N0YXRpYyBpbnQgcmVnX3RvX3VzZXIodm9pZCBfX3VzZXIgKnVhZGRyLCBjb25z dCB1NjQgKnZhbCwgdTY0IGlkKTsKPiArc3RhdGljIHU2NCBzeXNfcmVnX3RvX2luZGV4KGNvbnN0 IHN0cnVjdCBzeXNfcmVnX2Rlc2MgKnJlZyk7Cj4gKwo+ICsvKgo+ICsgKiBjcHVmZWF0dXJlIElE IHJlZ2lzdGVyIHVzZXIgYWNjZXNzb3JzCj4gKyAqCj4gKyAqIEZvciBub3csIHRoZXNlIHJlZ2lz dGVycyBhcmUgaW1tdXRhYmxlIGZvciB1c2Vyc3BhY2UsIHNvIG5vIHZhbHVlcwo+ICsgKiBhcmUg c3RvcmVkLCBhbmQgZm9yIHNldF9pZF9yZWcoKSB3ZSBkb24ndCBhbGxvdyB0aGUgZWZmZWN0aXZl IHZhbHVlCj4gKyAqIHRvIGJlIGNoYW5nZWQuCj4gKyAqLwo+ICtzdGF0aWMgaW50IF9fZ2V0X2lk X3JlZyhjb25zdCBzdHJ1Y3Qgc3lzX3JlZ19kZXNjICpyZCwgdm9pZCBfX3VzZXIgKnVhZGRyLAo+ ICsJCQlib29sIHJheikKPiArewo+ICsJY29uc3QgdTY0IGlkID0gc3lzX3JlZ190b19pbmRleChy ZCk7Cj4gKwljb25zdCB1NjQgdmFsID0gcmVhZF9pZF9yZWcocmQsIHJheik7Cj4gKwo+ICsJcmV0 dXJuIHJlZ190b191c2VyKHVhZGRyLCAmdmFsLCBpZCk7Cj4gK30KPiArCj4gK3N0YXRpYyBpbnQg X19zZXRfaWRfcmVnKGNvbnN0IHN0cnVjdCBzeXNfcmVnX2Rlc2MgKnJkLCB2b2lkIF9fdXNlciAq dWFkZHIsCj4gKwkJCWJvb2wgcmF6KQo+ICt7Cj4gKwljb25zdCB1NjQgaWQgPSBzeXNfcmVnX3Rv X2luZGV4KHJkKTsKPiArCWludCBlcnI7Cj4gKwl1NjQgdmFsOwo+ICsKPiArCWVyciA9IHJlZ19m cm9tX3VzZXIoJnZhbCwgdWFkZHIsIGlkKTsKPiArCWlmIChlcnIpCj4gKwkJcmV0dXJuIGVycjsK PiArCj4gKwkvKiBUaGlzIGlzIHdoYXQgd2UgbWVhbiBieSBpbnZhcmlhbnQ6IHlvdSBjYW4ndCBj aGFuZ2UgaXQuICovCj4gKwlpZiAodmFsICE9IHJlYWRfaWRfcmVnKHJkLCByYXopKQo+ICsJCXJl dHVybiAtRUlOVkFMOwo+ICsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGdl dF9pZF9yZWcoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBjb25zdCBzdHJ1Y3Qgc3lzX3JlZ19kZXNj ICpyZCwKPiArCQkgICAgICBjb25zdCBzdHJ1Y3Qga3ZtX29uZV9yZWcgKnJlZywgdm9pZCBfX3Vz ZXIgKnVhZGRyKQo+ICt7Cj4gKwlyZXR1cm4gX19nZXRfaWRfcmVnKHJkLCB1YWRkciwgZmFsc2Up Owo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHNldF9pZF9yZWcoc3RydWN0IGt2bV92Y3B1ICp2Y3B1 LCBjb25zdCBzdHJ1Y3Qgc3lzX3JlZ19kZXNjICpyZCwKPiArCQkgICAgICBjb25zdCBzdHJ1Y3Qg a3ZtX29uZV9yZWcgKnJlZywgdm9pZCBfX3VzZXIgKnVhZGRyKQo+ICt7Cj4gKwlyZXR1cm4gX19z ZXRfaWRfcmVnKHJkLCB1YWRkciwgZmFsc2UpOwo+ICt9Cj4gKwo+ICtzdGF0aWMgaW50IGdldF9y YXpfaWRfcmVnKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgY29uc3Qgc3RydWN0IHN5c19yZWdfZGVz YyAqcmQsCj4gKwkJCSAgY29uc3Qgc3RydWN0IGt2bV9vbmVfcmVnICpyZWcsIHZvaWQgX191c2Vy ICp1YWRkcikKPiArewo+ICsJcmV0dXJuIF9fZ2V0X2lkX3JlZyhyZCwgdWFkZHIsIHRydWUpOwo+ ICt9Cj4gKwo+ICtzdGF0aWMgaW50IHNldF9yYXpfaWRfcmVnKHN0cnVjdCBrdm1fdmNwdSAqdmNw dSwgY29uc3Qgc3RydWN0IHN5c19yZWdfZGVzYyAqcmQsCj4gKwkJCSAgY29uc3Qgc3RydWN0IGt2 bV9vbmVfcmVnICpyZWcsIHZvaWQgX191c2VyICp1YWRkcikKPiArewo+ICsJcmV0dXJuIF9fc2V0 X2lkX3JlZyhyZCwgdWFkZHIsIHRydWUpOwo+ICt9Cj4gKwo+ICsvKiBzeXNfcmVnX2Rlc2MgaW5p dGlhbGlzZXIgZm9yIGtub3duIGNwdWZlYXR1cmUgSUQgcmVnaXN0ZXJzICovCj4gKyNkZWZpbmUg SURfU0FOSVRJU0VEKG5hbWUpIHsJCQlcCj4gKwlTWVNfREVTQyhTWVNfIyNuYW1lKSwJCQlcCj4g KwkuYWNjZXNzCT0gYWNjZXNzX2lkX3JlZywJCVwKPiArCS5nZXRfdXNlciA9IGdldF9pZF9yZWcs CQkJXAo+ICsJLnNldF91c2VyID0gc2V0X2lkX3JlZywJCQlcCj4gK30KPiArCj4gKy8qCj4gKyAq IHN5c19yZWdfZGVzYyBpbml0aWFsaXNlciBmb3IgYXJjaGl0ZWN0dXJhbGx5IHVuYWxsb2NhdGVk IGNwdWZlYXR1cmUgSUQKPiArICogcmVnaXN0ZXIgd2l0aCBlbmNvZGluZyBPcDA9MywgT3AxPTAs IENSbj0wLCBDUm09Y3JtLCBPcDI9b3AyCj4gKyAqICgxIDw9IGNybSA8IDgsIDAgPD0gT3AyIDwg OCkuCj4gKyAqLwo+ICsjZGVmaW5lIElEX1VOQUxMT0NBVEVEKGNybSwgb3AyKSB7CQkJXAo+ICsJ T3AwKDMpLCBPcDEoMCksIENSbigwKSwgQ1JtKGNybSksIE9wMihvcDIpLAlcCj4gKwkuYWNjZXNz ID0gYWNjZXNzX3Jhel9pZF9yZWcsCQkJXAo+ICsJLmdldF91c2VyID0gZ2V0X3Jhel9pZF9yZWcs CQkJXAo+ICsJLnNldF91c2VyID0gc2V0X3Jhel9pZF9yZWcsCQkJXAo+ICt9Cj4gKwo+ICsvKgo+ ICsgKiBzeXNfcmVnX2Rlc2MgaW5pdGlhbGlzZXIgZm9yIGtub3duIElEIHJlZ2lzdGVycyB0aGF0 IHdlIGhpZGUgZnJvbSBndWVzdHMuCj4gKyAqIEZvciBub3csIHRoZXNlIGFyZSBleHBvc2VkIGp1 c3QgbGlrZSB1bmFsbG9jYXRlZCBJRCByZWdzOiB0aGV5IGFwcGVhcgo+ICsgKiBSQVogZm9yIHRo ZSBndWVzdC4KPiArICovCj4gKyNkZWZpbmUgSURfSElEREVOKG5hbWUpIHsJCQlcCj4gKwlTWVNf REVTQyhTWVNfIyNuYW1lKSwJCQlcCj4gKwkuYWNjZXNzID0gYWNjZXNzX3Jhel9pZF9yZWcsCQlc Cj4gKwkuZ2V0X3VzZXIgPSBnZXRfcmF6X2lkX3JlZywJCVwKPiArCS5zZXRfdXNlciA9IHNldF9y YXpfaWRfcmVnLAkJXAo+ICt9Cj4gKwo+ICAvKgo+ICAgKiBBcmNoaXRlY3RlZCBzeXN0ZW0gcmVn aXN0ZXJzLgo+ICAgKiBJbXBvcnRhbnQ6IE11c3QgYmUgc29ydGVkIGFzY2VuZGluZyBieSBPcDAs IE9wMSwgQ1JuLCBDUm0sIE9wMgo+IEBAIC05NDQsNiArMTA3NSw4NCBAQCBzdGF0aWMgY29uc3Qg c3RydWN0IHN5c19yZWdfZGVzYyBzeXNfcmVnX2Rlc2NzW10gPSB7Cj4gIAl7IFNZU19ERVNDKFNZ U19EQkdWQ1IzMl9FTDIpLCBOVUxMLCByZXNldF92YWwsIERCR1ZDUjMyX0VMMiwgMCB9LAo+Cj4g IAl7IFNZU19ERVNDKFNZU19NUElEUl9FTDEpLCBOVUxMLCByZXNldF9tcGlkciwgTVBJRFJfRUwx IH0sCj4gKwo+ICsJLyoKPiArCSAqIElEIHJlZ3M6IGFsbCBJRF9TQU5JVElTRUQoKSBlbnRyaWVz IGhlcmUgbXVzdCBoYXZlIGNvcnJlc3BvbmRpbmcKPiArCSAqIGVudHJpZXMgaW4gYXJtNjRfZnRy X3JlZ3NbXS4KPiArCSAqLwo+ICsKPiArCS8qIEFBcmNoNjQgbWFwcGluZ3Mgb2YgdGhlIEFBcmNo MzIgSUQgcmVnaXN0ZXJzICovCj4gKwkvKiBDUm09MSAqLwo+ICsJSURfU0FOSVRJU0VEKElEX1BG UjBfRUwxKSwKPiArCUlEX1NBTklUSVNFRChJRF9QRlIxX0VMMSksCj4gKwlJRF9TQU5JVElTRUQo SURfREZSMF9FTDEpLAo+ICsJSURfSElEREVOKElEX0FGUjBfRUwxKSwKPiArCUlEX1NBTklUSVNF RChJRF9NTUZSMF9FTDEpLAo+ICsJSURfU0FOSVRJU0VEKElEX01NRlIxX0VMMSksCj4gKwlJRF9T QU5JVElTRUQoSURfTU1GUjJfRUwxKSwKPiArCUlEX1NBTklUSVNFRChJRF9NTUZSM19FTDEpLAo+ ICsKPiArCS8qIENSbT0yICovCj4gKwlJRF9TQU5JVElTRUQoSURfSVNBUjBfRUwxKSwKPiArCUlE X1NBTklUSVNFRChJRF9JU0FSMV9FTDEpLAo+ICsJSURfU0FOSVRJU0VEKElEX0lTQVIyX0VMMSks Cj4gKwlJRF9TQU5JVElTRUQoSURfSVNBUjNfRUwxKSwKPiArCUlEX1NBTklUSVNFRChJRF9JU0FS NF9FTDEpLAo+ICsJSURfU0FOSVRJU0VEKElEX0lTQVI1X0VMMSksCj4gKwlJRF9TQU5JVElTRUQo SURfTU1GUjRfRUwxKSwKPiArCUlEX1VOQUxMT0NBVEVEKDIsNyksCj4gKwo+ICsJLyogQ1JtPTMg Ki8KPiArCUlEX1NBTklUSVNFRChNVkZSMF9FTDEpLAo+ICsJSURfU0FOSVRJU0VEKE1WRlIxX0VM MSksCj4gKwlJRF9TQU5JVElTRUQoTVZGUjJfRUwxKSwKPiArCUlEX1VOQUxMT0NBVEVEKDMsMyks Cj4gKwlJRF9VTkFMTE9DQVRFRCgzLDQpLAo+ICsJSURfVU5BTExPQ0FURUQoMyw1KSwKPiArCUlE X1VOQUxMT0NBVEVEKDMsNiksCj4gKwlJRF9VTkFMTE9DQVRFRCgzLDcpLAo+ICsKPiArCS8qIEFB cmNoNjQgSUQgcmVnaXN0ZXJzICovCj4gKwkvKiBDUm09NCAqLwo+ICsJSURfU0FOSVRJU0VEKElE X0FBNjRQRlIwX0VMMSksCj4gKwlJRF9TQU5JVElTRUQoSURfQUE2NFBGUjFfRUwxKSwKPiArCUlE X1VOQUxMT0NBVEVEKDQsMiksCj4gKwlJRF9VTkFMTE9DQVRFRCg0LDMpLAo+ICsJSURfVU5BTExP Q0FURUQoNCw0KSwKPiArCUlEX1VOQUxMT0NBVEVEKDQsNSksCj4gKwlJRF9VTkFMTE9DQVRFRCg0 LDYpLAo+ICsJSURfVU5BTExPQ0FURUQoNCw3KSwKPiArCj4gKwkvKiBDUm09NSAqLwo+ICsJSURf U0FOSVRJU0VEKElEX0FBNjRERlIwX0VMMSksCj4gKwlJRF9TQU5JVElTRUQoSURfQUE2NERGUjFf RUwxKSwKPiArCUlEX1VOQUxMT0NBVEVEKDUsMiksCj4gKwlJRF9VTkFMTE9DQVRFRCg1LDMpLAo+ ICsJSURfSElEREVOKElEX0FBNjRBRlIwX0VMMSksCj4gKwlJRF9ISURERU4oSURfQUE2NEFGUjFf RUwxKSwKPiArCUlEX1VOQUxMT0NBVEVEKDUsNiksCj4gKwlJRF9VTkFMTE9DQVRFRCg1LDcpLAo+ ICsKPiArCS8qIENSbT02ICovCj4gKwlJRF9TQU5JVElTRUQoSURfQUE2NElTQVIwX0VMMSksCj4g KwlJRF9TQU5JVElTRUQoSURfQUE2NElTQVIxX0VMMSksCj4gKwlJRF9VTkFMTE9DQVRFRCg2LDIp LAo+ICsJSURfVU5BTExPQ0FURUQoNiwzKSwKPiArCUlEX1VOQUxMT0NBVEVEKDYsNCksCj4gKwlJ RF9VTkFMTE9DQVRFRCg2LDUpLAo+ICsJSURfVU5BTExPQ0FURUQoNiw2KSwKPiArCUlEX1VOQUxM T0NBVEVEKDYsNyksCj4gKwo+ICsJLyogQ1JtPTcgKi8KPiArCUlEX1NBTklUSVNFRChJRF9BQTY0 TU1GUjBfRUwxKSwKPiArCUlEX1NBTklUSVNFRChJRF9BQTY0TU1GUjFfRUwxKSwKPiArCUlEX1NB TklUSVNFRChJRF9BQTY0TU1GUjJfRUwxKSwKPiArCUlEX1VOQUxMT0NBVEVEKDcsMyksCj4gKwlJ RF9VTkFMTE9DQVRFRCg3LDQpLAo+ICsJSURfVU5BTExPQ0FURUQoNyw1KSwKPiArCUlEX1VOQUxM T0NBVEVEKDcsNiksCj4gKwlJRF9VTkFMTE9DQVRFRCg3LDcpLAo+ICsKPiAgCXsgU1lTX0RFU0Mo U1lTX1NDVExSX0VMMSksIGFjY2Vzc192bV9yZWcsIHJlc2V0X3ZhbCwgU0NUTFJfRUwxLCAweDAw QzUwMDc4IH0sCj4gIAl7IFNZU19ERVNDKFNZU19DUEFDUl9FTDEpLCBOVUxMLCByZXNldF92YWws IENQQUNSX0VMMSwgMCB9LAo+ICAJeyBTWVNfREVTQyhTWVNfVFRCUjBfRUwxKSwgYWNjZXNzX3Zt X3JlZywgcmVzZXRfdW5rbm93biwgVFRCUjBfRUwxIH0sCj4gQEAgLTE3OTAsOCArMTk5OSw4IEBA IHN0YXRpYyBjb25zdCBzdHJ1Y3Qgc3lzX3JlZ19kZXNjICppbmRleF90b19zeXNfcmVnX2Rlc2Mo c3RydWN0IGt2bV92Y3B1ICp2Y3B1LAo+ICAJaWYgKCFyKQo+ICAJCXIgPSBmaW5kX3JlZygmcGFy YW1zLCBzeXNfcmVnX2Rlc2NzLCBBUlJBWV9TSVpFKHN5c19yZWdfZGVzY3MpKTsKPgo+IC0JLyog Tm90IHNhdmVkIGluIHRoZSBzeXNfcmVnIGFycmF5PyAqLwo+IC0JaWYgKHIgJiYgIXItPnJlZykK PiArCS8qIE5vdCBzYXZlZCBpbiB0aGUgc3lzX3JlZyBhcnJheSBhbmQgbm90IG90aGVyd2lzZSBh Y2Nlc3NpYmxlPyAqLwo+ICsJaWYgKHIgJiYgIShyLT5yZWcgfHwgci0+Z2V0X3VzZXIpKQo+ICAJ CXIgPSBOVUxMOwo+Cj4gIAlyZXR1cm4gcjsKPiBAQCAtMTgxNSwyMCArMjAyNCw2IEBAIHN0YXRp YyBjb25zdCBzdHJ1Y3Qgc3lzX3JlZ19kZXNjICppbmRleF90b19zeXNfcmVnX2Rlc2Moc3RydWN0 IGt2bV92Y3B1ICp2Y3B1LAo+ICBGVU5DVElPTl9JTlZBUklBTlQobWlkcl9lbDEpCj4gIEZVTkNU SU9OX0lOVkFSSUFOVChjdHJfZWwwKQo+ICBGVU5DVElPTl9JTlZBUklBTlQocmV2aWRyX2VsMSkK PiAtRlVOQ1RJT05fSU5WQVJJQU5UKGlkX3BmcjBfZWwxKQo+IC1GVU5DVElPTl9JTlZBUklBTlQo aWRfcGZyMV9lbDEpCj4gLUZVTkNUSU9OX0lOVkFSSUFOVChpZF9kZnIwX2VsMSkKPiAtRlVOQ1RJ T05fSU5WQVJJQU5UKGlkX2FmcjBfZWwxKQo+IC1GVU5DVElPTl9JTlZBUklBTlQoaWRfbW1mcjBf ZWwxKQo+IC1GVU5DVElPTl9JTlZBUklBTlQoaWRfbW1mcjFfZWwxKQo+IC1GVU5DVElPTl9JTlZB UklBTlQoaWRfbW1mcjJfZWwxKQo+IC1GVU5DVElPTl9JTlZBUklBTlQoaWRfbW1mcjNfZWwxKQo+ IC1GVU5DVElPTl9JTlZBUklBTlQoaWRfaXNhcjBfZWwxKQo+IC1GVU5DVElPTl9JTlZBUklBTlQo aWRfaXNhcjFfZWwxKQo+IC1GVU5DVElPTl9JTlZBUklBTlQoaWRfaXNhcjJfZWwxKQo+IC1GVU5D VElPTl9JTlZBUklBTlQoaWRfaXNhcjNfZWwxKQo+IC1GVU5DVElPTl9JTlZBUklBTlQoaWRfaXNh cjRfZWwxKQo+IC1GVU5DVElPTl9JTlZBUklBTlQoaWRfaXNhcjVfZWwxKQo+ICBGVU5DVElPTl9J TlZBUklBTlQoY2xpZHJfZWwxKQo+ICBGVU5DVElPTl9JTlZBUklBTlQoYWlkcl9lbDEpCj4KPiBA QCAtMTgzNiwyMCArMjAzMSw2IEBAIEZVTkNUSU9OX0lOVkFSSUFOVChhaWRyX2VsMSkKPiAgc3Rh dGljIHN0cnVjdCBzeXNfcmVnX2Rlc2MgaW52YXJpYW50X3N5c19yZWdzW10gPSB7Cj4gIAl7IFNZ U19ERVNDKFNZU19NSURSX0VMMSksIE5VTEwsIGdldF9taWRyX2VsMSB9LAo+ICAJeyBTWVNfREVT QyhTWVNfUkVWSURSX0VMMSksIE5VTEwsIGdldF9yZXZpZHJfZWwxIH0sCj4gLQl7IFNZU19ERVND KFNZU19JRF9QRlIwX0VMMSksIE5VTEwsIGdldF9pZF9wZnIwX2VsMSB9LAo+IC0JeyBTWVNfREVT QyhTWVNfSURfUEZSMV9FTDEpLCBOVUxMLCBnZXRfaWRfcGZyMV9lbDEgfSwKPiAtCXsgU1lTX0RF U0MoU1lTX0lEX0RGUjBfRUwxKSwgTlVMTCwgZ2V0X2lkX2RmcjBfZWwxIH0sCj4gLQl7IFNZU19E RVNDKFNZU19JRF9BRlIwX0VMMSksIE5VTEwsIGdldF9pZF9hZnIwX2VsMSB9LAo+IC0JeyBTWVNf REVTQyhTWVNfSURfTU1GUjBfRUwxKSwgTlVMTCwgZ2V0X2lkX21tZnIwX2VsMSB9LAo+IC0JeyBT WVNfREVTQyhTWVNfSURfTU1GUjFfRUwxKSwgTlVMTCwgZ2V0X2lkX21tZnIxX2VsMSB9LAo+IC0J eyBTWVNfREVTQyhTWVNfSURfTU1GUjJfRUwxKSwgTlVMTCwgZ2V0X2lkX21tZnIyX2VsMSB9LAo+ IC0JeyBTWVNfREVTQyhTWVNfSURfTU1GUjNfRUwxKSwgTlVMTCwgZ2V0X2lkX21tZnIzX2VsMSB9 LAo+IC0JeyBTWVNfREVTQyhTWVNfSURfSVNBUjBfRUwxKSwgTlVMTCwgZ2V0X2lkX2lzYXIwX2Vs MSB9LAo+IC0JeyBTWVNfREVTQyhTWVNfSURfSVNBUjFfRUwxKSwgTlVMTCwgZ2V0X2lkX2lzYXIx X2VsMSB9LAo+IC0JeyBTWVNfREVTQyhTWVNfSURfSVNBUjJfRUwxKSwgTlVMTCwgZ2V0X2lkX2lz YXIyX2VsMSB9LAo+IC0JeyBTWVNfREVTQyhTWVNfSURfSVNBUjNfRUwxKSwgTlVMTCwgZ2V0X2lk X2lzYXIzX2VsMSB9LAo+IC0JeyBTWVNfREVTQyhTWVNfSURfSVNBUjRfRUwxKSwgTlVMTCwgZ2V0 X2lkX2lzYXI0X2VsMSB9LAo+IC0JeyBTWVNfREVTQyhTWVNfSURfSVNBUjVfRUwxKSwgTlVMTCwg Z2V0X2lkX2lzYXI1X2VsMSB9LAo+ICAJeyBTWVNfREVTQyhTWVNfQ0xJRFJfRUwxKSwgTlVMTCwg Z2V0X2NsaWRyX2VsMSB9LAo+ICAJeyBTWVNfREVTQyhTWVNfQUlEUl9FTDEpLCBOVUxMLCBnZXRf YWlkcl9lbDEgfSwKPiAgCXsgU1lTX0RFU0MoU1lTX0NUUl9FTDApLCBOVUxMLCBnZXRfY3RyX2Vs MCB9LAo+IEBAIC0yMDc5LDEyICsyMjYwLDMxIEBAIHN0YXRpYyBib29sIGNvcHlfcmVnX3RvX3Vz ZXIoY29uc3Qgc3RydWN0IHN5c19yZWdfZGVzYyAqcmVnLCB1NjQgX191c2VyICoqdWluZCkKPiAg CXJldHVybiB0cnVlOwo+ICB9Cj4KPiArc3RhdGljIGludCB3YWxrX29uZV9zeXNfcmVnKGNvbnN0 IHN0cnVjdCBzeXNfcmVnX2Rlc2MgKnJkLAo+ICsJCQkgICAgdTY0IF9fdXNlciAqKnVpbmQsCj4g KwkJCSAgICB1bnNpZ25lZCBpbnQgKnRvdGFsKQo+ICt7Cj4gKwkvKgo+ICsJICogSWdub3JlIHJl Z2lzdGVycyB3ZSB0cmFwIGJ1dCBkb24ndCBzYXZlLAo+ICsJICogYW5kIGZvciB3aGljaCBubyBj dXN0b20gdXNlciBhY2Nlc3NvciBpcyBwcm92aWRlZC4KPiArCSAqLwo+ICsJaWYgKCEocmQtPnJl ZyB8fCByZC0+Z2V0X3VzZXIpKQo+ICsJCXJldHVybiAwOwo+ICsKPiArCWlmICghY29weV9yZWdf dG9fdXNlcihyZCwgdWluZCkpCj4gKwkJcmV0dXJuIC1FRkFVTFQ7Cj4gKwo+ICsJKCp0b3RhbCkr KzsKPiArCXJldHVybiAwOwo+ICt9Cj4gKwo+ICAvKiBBc3N1bWVkIG9yZGVyZWQgdGFibGVzLCBz ZWUga3ZtX3N5c19yZWdfdGFibGVfaW5pdC4gKi8KPiAgc3RhdGljIGludCB3YWxrX3N5c19yZWdz KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgdTY0IF9fdXNlciAqdWluZCkKPiAgewo+ICAJY29uc3Qg c3RydWN0IHN5c19yZWdfZGVzYyAqaTEsICppMiwgKmVuZDEsICplbmQyOwo+ICAJdW5zaWduZWQg aW50IHRvdGFsID0gMDsKPiAgCXNpemVfdCBudW07Cj4gKwlpbnQgZXJyOwo+Cj4gIAkvKiBXZSBj aGVjayBmb3IgZHVwbGljYXRlcyBoZXJlLCB0byBhbGxvdyBhcmNoLXNwZWNpZmljIG92ZXJyaWRl cy4gKi8KPiAgCWkxID0gZ2V0X3RhcmdldF90YWJsZSh2Y3B1LT5hcmNoLnRhcmdldCwgdHJ1ZSwg Jm51bSk7Cj4gQEAgLTIwOTgsMjEgKzIyOTgsMTMgQEAgc3RhdGljIGludCB3YWxrX3N5c19yZWdz KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwgdTY0IF9fdXNlciAqdWluZCkKPiAgCXdoaWxlIChpMSB8 fCBpMikgewo+ICAJCWludCBjbXAgPSBjbXBfc3lzX3JlZyhpMSwgaTIpOwo+ICAJCS8qIHRhcmdl dC1zcGVjaWZpYyBvdmVycmlkZXMgZ2VuZXJpYyBlbnRyeS4gKi8KPiAtCQlpZiAoY21wIDw9IDAp IHsKPiAtCQkJLyogSWdub3JlIHJlZ2lzdGVycyB3ZSB0cmFwIGJ1dCBkb24ndCBzYXZlLiAqLwo+ IC0JCQlpZiAoaTEtPnJlZykgewo+IC0JCQkJaWYgKCFjb3B5X3JlZ190b191c2VyKGkxLCAmdWlu ZCkpCj4gLQkJCQkJcmV0dXJuIC1FRkFVTFQ7Cj4gLQkJCQl0b3RhbCsrOwo+IC0JCQl9Cj4gLQkJ fSBlbHNlIHsKPiAtCQkJLyogSWdub3JlIHJlZ2lzdGVycyB3ZSB0cmFwIGJ1dCBkb24ndCBzYXZl LiAqLwo+IC0JCQlpZiAoaTItPnJlZykgewo+IC0JCQkJaWYgKCFjb3B5X3JlZ190b191c2VyKGky LCAmdWluZCkpCj4gLQkJCQkJcmV0dXJuIC1FRkFVTFQ7Cj4gLQkJCQl0b3RhbCsrOwo+IC0JCQl9 Cj4gLQkJfQo+ICsJCWlmIChjbXAgPD0gMCkKPiArCQkJZXJyID0gd2Fsa19vbmVfc3lzX3JlZyhp MSwgJnVpbmQsICZ0b3RhbCk7Cj4gKwkJZWxzZQo+ICsJCQllcnIgPSB3YWxrX29uZV9zeXNfcmVn KGkyLCAmdWluZCwgJnRvdGFsKTsKPiArCj4gKwkJaWYgKGVycikKPiArCQkJcmV0dXJuIGVycjsK Pgo+ICAJCWlmIChjbXAgPD0gMCAmJiArK2kxID09IGVuZDEpCj4gIAkJCWkxID0gTlVMTDsKCgot LQpBbGV4IEJlbm7DqWUKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX18Ka3ZtYXJtIG1haWxpbmcgbGlzdAprdm1hcm1AbGlzdHMuY3MuY29sdW1iaWEuZWR1Cmh0 dHBzOi8vbGlzdHMuY3MuY29sdW1iaWEuZWR1L21haWxtYW4vbGlzdGluZm8va3ZtYXJtCg== From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mail-wm0-f66.google.com ([74.125.82.66]:51227 "EHLO mail-wm0-f66.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751430AbdJaK5f (ORCPT ); Tue, 31 Oct 2017 06:57:35 -0400 Received: by mail-wm0-f66.google.com with SMTP id b9so22249323wmh.0 for ; Tue, 31 Oct 2017 03:57:34 -0700 (PDT) References: <1509101470-7881-1-git-send-email-Dave.Martin@arm.com> <1509101470-7881-3-git-send-email-Dave.Martin@arm.com> From: Alex =?utf-8?Q?Benn=C3=A9e?= Subject: Re: [PATCH v4 02/28] arm64: KVM: Hide unsupported AArch64 CPU features from guests In-reply-to: <1509101470-7881-3-git-send-email-Dave.Martin@arm.com> Date: Tue, 31 Oct 2017 10:57:32 +0000 Message-ID: <874lqfinz7.fsf@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable Sender: linux-arch-owner@vger.kernel.org List-ID: To: Dave Martin Cc: linux-arm-kernel@lists.infradead.org, Catalin Marinas , Will Deacon , Ard Biesheuvel , Szabolcs Nagy , Okamoto Takayuki , kvmarm@lists.cs.columbia.edu, libc-alpha@sourceware.org, linux-arch@vger.kernel.org, Christoffer Dall Message-ID: <20171031105732.a8LIFq4HR43e5o2uWwLzpOs9YjHrIEzzkmyUznyTbbI@z> Dave Martin writes: > Currently, a guest kernel sees the true CPU feature registers > (ID_*_EL1) when it reads them using MRS instructions. This means > that the guest may observe features that are present in the > hardware but the host doesn't understand or doesn't provide support > for. A guest may legimitately try to use such a feature as per the > architecture, but use of the feature may trap instead of working > normally, triggering undef injection into the guest. > > This is not a problem for the host, but the guest may go wrong when > running on newer hardware than the host knows about. > > This patch hides from guest VMs any AArch64-specific CPU features > that the host doesn't support, by exposing to the guest the > sanitised versions of the registers computed by the cpufeatures > framework, instead of the true hardware registers. To achieve > this, HCR_EL2.TID3 is now set for AArch64 guests, and emulation > code is added to KVM to report the sanitised versions of the > affected registers in response to MRS and register reads from > userspace. > > The affected registers are removed from invariant_sys_regs[] (since > the invariant_sys_regs handling is no longer quite correct for > them) and added to sys_reg_desgs[], with appropriate access(), > get_user() and set_user() methods. No runtime vcpu storage is > allocated for the registers: instead, they are read on demand from > the cpufeatures framework. This may need modification in the > future if there is a need for userspace to customise the features > visible to the guest. > > Attempts by userspace to write the registers are handled similarly > to the current invariant_sys_regs handling: writes are permitted, > but only if they don't attempt to change the value. This is > sufficient to support VM snapshot/restore from userspace. > > Because of the additional registers, restoring a VM on an older > kernel may not work unless userspace knows how to handle the extra > VM registers exposed to the KVM user ABI by this patch. > > Under the principle of least damage, this patch makes no attempt to > handle any of the other registers currently in > invariant_sys_regs[], or to emulate registers for AArch32: however, > these could be handled in a similar way in future, as necessary. > > Signed-off-by: Dave Martin > Reviewed-by: Marc Zyngier > Acked-by: Catalin Marinas > Cc: Christoffer Dall Reviewed-by: Alex Benn=C3=A9e > --- > arch/arm64/include/asm/sysreg.h | 3 + > arch/arm64/kvm/hyp/switch.c | 6 + > arch/arm64/kvm/sys_regs.c | 282 +++++++++++++++++++++++++++++++++-= ------ > 3 files changed, 246 insertions(+), 45 deletions(-) > > diff --git a/arch/arm64/include/asm/sysreg.h b/arch/arm64/include/asm/sys= reg.h > index 4dceb12..609d59af 100644 > --- a/arch/arm64/include/asm/sysreg.h > +++ b/arch/arm64/include/asm/sysreg.h > @@ -149,6 +149,9 @@ > #define SYS_ID_AA64DFR0_EL1 sys_reg(3, 0, 0, 5, 0) > #define SYS_ID_AA64DFR1_EL1 sys_reg(3, 0, 0, 5, 1) > > +#define SYS_ID_AA64AFR0_EL1 sys_reg(3, 0, 0, 5, 4) > +#define SYS_ID_AA64AFR1_EL1 sys_reg(3, 0, 0, 5, 5) > + > #define SYS_ID_AA64ISAR0_EL1 sys_reg(3, 0, 0, 6, 0) > #define SYS_ID_AA64ISAR1_EL1 sys_reg(3, 0, 0, 6, 1) > > diff --git a/arch/arm64/kvm/hyp/switch.c b/arch/arm64/kvm/hyp/switch.c > index 945e79c..35a90b8 100644 > --- a/arch/arm64/kvm/hyp/switch.c > +++ b/arch/arm64/kvm/hyp/switch.c > @@ -81,11 +81,17 @@ static void __hyp_text __activate_traps(struct kvm_vc= pu *vcpu) > * it will cause an exception. > */ > val =3D vcpu->arch.hcr_el2; > + > if (!(val & HCR_RW) && system_supports_fpsimd()) { > write_sysreg(1 << 30, fpexc32_el2); > isb(); > } > + > + if (val & HCR_RW) /* for AArch64 only: */ > + val |=3D HCR_TID3; /* TID3: trap feature register accesses */ > + > write_sysreg(val, hcr_el2); > + > /* Trap on AArch32 cp15 c15 accesses (EL1 or EL0) */ > write_sysreg(1 << 15, hstr_el2); > /* > diff --git a/arch/arm64/kvm/sys_regs.c b/arch/arm64/kvm/sys_regs.c > index 2e070d3..b1f7552 100644 > --- a/arch/arm64/kvm/sys_regs.c > +++ b/arch/arm64/kvm/sys_regs.c > @@ -892,6 +892,137 @@ static bool access_cntp_cval(struct kvm_vcpu *vcpu, > return true; > } > > +/* Read a sanitised cpufeature ID register by sys_reg_desc */ > +static u64 read_id_reg(struct sys_reg_desc const *r, bool raz) > +{ > + u32 id =3D sys_reg((u32)r->Op0, (u32)r->Op1, > + (u32)r->CRn, (u32)r->CRm, (u32)r->Op2); > + > + return raz ? 0 : read_sanitised_ftr_reg(id); > +} > + > +/* cpufeature ID register access trap handlers */ > + > +static bool __access_id_reg(struct kvm_vcpu *vcpu, > + struct sys_reg_params *p, > + const struct sys_reg_desc *r, > + bool raz) > +{ > + if (p->is_write) > + return write_to_read_only(vcpu, p, r); > + > + p->regval =3D read_id_reg(r, raz); > + return true; > +} > + > +static bool access_id_reg(struct kvm_vcpu *vcpu, > + struct sys_reg_params *p, > + const struct sys_reg_desc *r) > +{ > + return __access_id_reg(vcpu, p, r, false); > +} > + > +static bool access_raz_id_reg(struct kvm_vcpu *vcpu, > + struct sys_reg_params *p, > + const struct sys_reg_desc *r) > +{ > + return __access_id_reg(vcpu, p, r, true); > +} > + > +static int reg_from_user(u64 *val, const void __user *uaddr, u64 id); > +static int reg_to_user(void __user *uaddr, const u64 *val, u64 id); > +static u64 sys_reg_to_index(const struct sys_reg_desc *reg); > + > +/* > + * cpufeature ID register user accessors > + * > + * For now, these registers are immutable for userspace, so no values > + * are stored, and for set_id_reg() we don't allow the effective value > + * to be changed. > + */ > +static int __get_id_reg(const struct sys_reg_desc *rd, void __user *uadd= r, > + bool raz) > +{ > + const u64 id =3D sys_reg_to_index(rd); > + const u64 val =3D read_id_reg(rd, raz); > + > + return reg_to_user(uaddr, &val, id); > +} > + > +static int __set_id_reg(const struct sys_reg_desc *rd, void __user *uadd= r, > + bool raz) > +{ > + const u64 id =3D sys_reg_to_index(rd); > + int err; > + u64 val; > + > + err =3D reg_from_user(&val, uaddr, id); > + if (err) > + return err; > + > + /* This is what we mean by invariant: you can't change it. */ > + if (val !=3D read_id_reg(rd, raz)) > + return -EINVAL; > + > + return 0; > +} > + > +static int get_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *= rd, > + const struct kvm_one_reg *reg, void __user *uaddr) > +{ > + return __get_id_reg(rd, uaddr, false); > +} > + > +static int set_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_desc *= rd, > + const struct kvm_one_reg *reg, void __user *uaddr) > +{ > + return __set_id_reg(rd, uaddr, false); > +} > + > +static int get_raz_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_de= sc *rd, > + const struct kvm_one_reg *reg, void __user *uaddr) > +{ > + return __get_id_reg(rd, uaddr, true); > +} > + > +static int set_raz_id_reg(struct kvm_vcpu *vcpu, const struct sys_reg_de= sc *rd, > + const struct kvm_one_reg *reg, void __user *uaddr) > +{ > + return __set_id_reg(rd, uaddr, true); > +} > + > +/* sys_reg_desc initialiser for known cpufeature ID registers */ > +#define ID_SANITISED(name) { \ > + SYS_DESC(SYS_##name), \ > + .access =3D access_id_reg, \ > + .get_user =3D get_id_reg, \ > + .set_user =3D set_id_reg, \ > +} > + > +/* > + * sys_reg_desc initialiser for architecturally unallocated cpufeature ID > + * register with encoding Op0=3D3, Op1=3D0, CRn=3D0, CRm=3Dcrm, Op2=3Dop2 > + * (1 <=3D crm < 8, 0 <=3D Op2 < 8). > + */ > +#define ID_UNALLOCATED(crm, op2) { \ > + Op0(3), Op1(0), CRn(0), CRm(crm), Op2(op2), \ > + .access =3D access_raz_id_reg, \ > + .get_user =3D get_raz_id_reg, \ > + .set_user =3D set_raz_id_reg, \ > +} > + > +/* > + * sys_reg_desc initialiser for known ID registers that we hide from gue= sts. > + * For now, these are exposed just like unallocated ID regs: they appear > + * RAZ for the guest. > + */ > +#define ID_HIDDEN(name) { \ > + SYS_DESC(SYS_##name), \ > + .access =3D access_raz_id_reg, \ > + .get_user =3D get_raz_id_reg, \ > + .set_user =3D set_raz_id_reg, \ > +} > + > /* > * Architected system registers. > * Important: Must be sorted ascending by Op0, Op1, CRn, CRm, Op2 > @@ -944,6 +1075,84 @@ static const struct sys_reg_desc sys_reg_descs[] = =3D { > { SYS_DESC(SYS_DBGVCR32_EL2), NULL, reset_val, DBGVCR32_EL2, 0 }, > > { SYS_DESC(SYS_MPIDR_EL1), NULL, reset_mpidr, MPIDR_EL1 }, > + > + /* > + * ID regs: all ID_SANITISED() entries here must have corresponding > + * entries in arm64_ftr_regs[]. > + */ > + > + /* AArch64 mappings of the AArch32 ID registers */ > + /* CRm=3D1 */ > + ID_SANITISED(ID_PFR0_EL1), > + ID_SANITISED(ID_PFR1_EL1), > + ID_SANITISED(ID_DFR0_EL1), > + ID_HIDDEN(ID_AFR0_EL1), > + ID_SANITISED(ID_MMFR0_EL1), > + ID_SANITISED(ID_MMFR1_EL1), > + ID_SANITISED(ID_MMFR2_EL1), > + ID_SANITISED(ID_MMFR3_EL1), > + > + /* CRm=3D2 */ > + ID_SANITISED(ID_ISAR0_EL1), > + ID_SANITISED(ID_ISAR1_EL1), > + ID_SANITISED(ID_ISAR2_EL1), > + ID_SANITISED(ID_ISAR3_EL1), > + ID_SANITISED(ID_ISAR4_EL1), > + ID_SANITISED(ID_ISAR5_EL1), > + ID_SANITISED(ID_MMFR4_EL1), > + ID_UNALLOCATED(2,7), > + > + /* CRm=3D3 */ > + ID_SANITISED(MVFR0_EL1), > + ID_SANITISED(MVFR1_EL1), > + ID_SANITISED(MVFR2_EL1), > + ID_UNALLOCATED(3,3), > + ID_UNALLOCATED(3,4), > + ID_UNALLOCATED(3,5), > + ID_UNALLOCATED(3,6), > + ID_UNALLOCATED(3,7), > + > + /* AArch64 ID registers */ > + /* CRm=3D4 */ > + ID_SANITISED(ID_AA64PFR0_EL1), > + ID_SANITISED(ID_AA64PFR1_EL1), > + ID_UNALLOCATED(4,2), > + ID_UNALLOCATED(4,3), > + ID_UNALLOCATED(4,4), > + ID_UNALLOCATED(4,5), > + ID_UNALLOCATED(4,6), > + ID_UNALLOCATED(4,7), > + > + /* CRm=3D5 */ > + ID_SANITISED(ID_AA64DFR0_EL1), > + ID_SANITISED(ID_AA64DFR1_EL1), > + ID_UNALLOCATED(5,2), > + ID_UNALLOCATED(5,3), > + ID_HIDDEN(ID_AA64AFR0_EL1), > + ID_HIDDEN(ID_AA64AFR1_EL1), > + ID_UNALLOCATED(5,6), > + ID_UNALLOCATED(5,7), > + > + /* CRm=3D6 */ > + ID_SANITISED(ID_AA64ISAR0_EL1), > + ID_SANITISED(ID_AA64ISAR1_EL1), > + ID_UNALLOCATED(6,2), > + ID_UNALLOCATED(6,3), > + ID_UNALLOCATED(6,4), > + ID_UNALLOCATED(6,5), > + ID_UNALLOCATED(6,6), > + ID_UNALLOCATED(6,7), > + > + /* CRm=3D7 */ > + ID_SANITISED(ID_AA64MMFR0_EL1), > + ID_SANITISED(ID_AA64MMFR1_EL1), > + ID_SANITISED(ID_AA64MMFR2_EL1), > + ID_UNALLOCATED(7,3), > + ID_UNALLOCATED(7,4), > + ID_UNALLOCATED(7,5), > + ID_UNALLOCATED(7,6), > + ID_UNALLOCATED(7,7), > + > { SYS_DESC(SYS_SCTLR_EL1), access_vm_reg, reset_val, SCTLR_EL1, 0x00C50= 078 }, > { SYS_DESC(SYS_CPACR_EL1), NULL, reset_val, CPACR_EL1, 0 }, > { SYS_DESC(SYS_TTBR0_EL1), access_vm_reg, reset_unknown, TTBR0_EL1 }, > @@ -1790,8 +1999,8 @@ static const struct sys_reg_desc *index_to_sys_reg_= desc(struct kvm_vcpu *vcpu, > if (!r) > r =3D find_reg(¶ms, sys_reg_descs, ARRAY_SIZE(sys_reg_descs)); > > - /* Not saved in the sys_reg array? */ > - if (r && !r->reg) > + /* Not saved in the sys_reg array and not otherwise accessible? */ > + if (r && !(r->reg || r->get_user)) > r =3D NULL; > > return r; > @@ -1815,20 +2024,6 @@ static const struct sys_reg_desc *index_to_sys_reg= _desc(struct kvm_vcpu *vcpu, > FUNCTION_INVARIANT(midr_el1) > FUNCTION_INVARIANT(ctr_el0) > FUNCTION_INVARIANT(revidr_el1) > -FUNCTION_INVARIANT(id_pfr0_el1) > -FUNCTION_INVARIANT(id_pfr1_el1) > -FUNCTION_INVARIANT(id_dfr0_el1) > -FUNCTION_INVARIANT(id_afr0_el1) > -FUNCTION_INVARIANT(id_mmfr0_el1) > -FUNCTION_INVARIANT(id_mmfr1_el1) > -FUNCTION_INVARIANT(id_mmfr2_el1) > -FUNCTION_INVARIANT(id_mmfr3_el1) > -FUNCTION_INVARIANT(id_isar0_el1) > -FUNCTION_INVARIANT(id_isar1_el1) > -FUNCTION_INVARIANT(id_isar2_el1) > -FUNCTION_INVARIANT(id_isar3_el1) > -FUNCTION_INVARIANT(id_isar4_el1) > -FUNCTION_INVARIANT(id_isar5_el1) > FUNCTION_INVARIANT(clidr_el1) > FUNCTION_INVARIANT(aidr_el1) > > @@ -1836,20 +2031,6 @@ FUNCTION_INVARIANT(aidr_el1) > static struct sys_reg_desc invariant_sys_regs[] =3D { > { SYS_DESC(SYS_MIDR_EL1), NULL, get_midr_el1 }, > { SYS_DESC(SYS_REVIDR_EL1), NULL, get_revidr_el1 }, > - { SYS_DESC(SYS_ID_PFR0_EL1), NULL, get_id_pfr0_el1 }, > - { SYS_DESC(SYS_ID_PFR1_EL1), NULL, get_id_pfr1_el1 }, > - { SYS_DESC(SYS_ID_DFR0_EL1), NULL, get_id_dfr0_el1 }, > - { SYS_DESC(SYS_ID_AFR0_EL1), NULL, get_id_afr0_el1 }, > - { SYS_DESC(SYS_ID_MMFR0_EL1), NULL, get_id_mmfr0_el1 }, > - { SYS_DESC(SYS_ID_MMFR1_EL1), NULL, get_id_mmfr1_el1 }, > - { SYS_DESC(SYS_ID_MMFR2_EL1), NULL, get_id_mmfr2_el1 }, > - { SYS_DESC(SYS_ID_MMFR3_EL1), NULL, get_id_mmfr3_el1 }, > - { SYS_DESC(SYS_ID_ISAR0_EL1), NULL, get_id_isar0_el1 }, > - { SYS_DESC(SYS_ID_ISAR1_EL1), NULL, get_id_isar1_el1 }, > - { SYS_DESC(SYS_ID_ISAR2_EL1), NULL, get_id_isar2_el1 }, > - { SYS_DESC(SYS_ID_ISAR3_EL1), NULL, get_id_isar3_el1 }, > - { SYS_DESC(SYS_ID_ISAR4_EL1), NULL, get_id_isar4_el1 }, > - { SYS_DESC(SYS_ID_ISAR5_EL1), NULL, get_id_isar5_el1 }, > { SYS_DESC(SYS_CLIDR_EL1), NULL, get_clidr_el1 }, > { SYS_DESC(SYS_AIDR_EL1), NULL, get_aidr_el1 }, > { SYS_DESC(SYS_CTR_EL0), NULL, get_ctr_el0 }, > @@ -2079,12 +2260,31 @@ static bool copy_reg_to_user(const struct sys_reg= _desc *reg, u64 __user **uind) > return true; > } > > +static int walk_one_sys_reg(const struct sys_reg_desc *rd, > + u64 __user **uind, > + unsigned int *total) > +{ > + /* > + * Ignore registers we trap but don't save, > + * and for which no custom user accessor is provided. > + */ > + if (!(rd->reg || rd->get_user)) > + return 0; > + > + if (!copy_reg_to_user(rd, uind)) > + return -EFAULT; > + > + (*total)++; > + return 0; > +} > + > /* Assumed ordered tables, see kvm_sys_reg_table_init. */ > static int walk_sys_regs(struct kvm_vcpu *vcpu, u64 __user *uind) > { > const struct sys_reg_desc *i1, *i2, *end1, *end2; > unsigned int total =3D 0; > size_t num; > + int err; > > /* We check for duplicates here, to allow arch-specific overrides. */ > i1 =3D get_target_table(vcpu->arch.target, true, &num); > @@ -2098,21 +2298,13 @@ static int walk_sys_regs(struct kvm_vcpu *vcpu, u= 64 __user *uind) > while (i1 || i2) { > int cmp =3D cmp_sys_reg(i1, i2); > /* target-specific overrides generic entry. */ > - if (cmp <=3D 0) { > - /* Ignore registers we trap but don't save. */ > - if (i1->reg) { > - if (!copy_reg_to_user(i1, &uind)) > - return -EFAULT; > - total++; > - } > - } else { > - /* Ignore registers we trap but don't save. */ > - if (i2->reg) { > - if (!copy_reg_to_user(i2, &uind)) > - return -EFAULT; > - total++; > - } > - } > + if (cmp <=3D 0) > + err =3D walk_one_sys_reg(i1, &uind, &total); > + else > + err =3D walk_one_sys_reg(i2, &uind, &total); > + > + if (err) > + return err; > > if (cmp <=3D 0 && ++i1 =3D=3D end1) > i1 =3D NULL; -- Alex Benn=C3=A9e