From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alex =?utf-8?Q?Benn=C3=A9e?= Subject: Re: [RFC PATCH v2 06/23] arm64/sve: Check SVE virtualisability Date: Thu, 15 Nov 2018 15:39:01 +0000 Message-ID: <87in0ycpuy.fsf@linaro.org> References: <1538141967-15375-1-git-send-email-Dave.Martin@arm.com> <1538141967-15375-7-git-send-email-Dave.Martin@arm.com> 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 399AF4A32C for ; Thu, 15 Nov 2018 10:39:06 -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 l2heXWZUuqZr for ; Thu, 15 Nov 2018 10:39:05 -0500 (EST) Received: from mail-wm1-f68.google.com (mail-wm1-f68.google.com [209.85.128.68]) by mm01.cs.columbia.edu (Postfix) with ESMTPS id BB34B4A357 for ; Thu, 15 Nov 2018 10:39:04 -0500 (EST) Received: by mail-wm1-f68.google.com with SMTP id w7-v6so19229884wmc.1 for ; Thu, 15 Nov 2018 07:39:04 -0800 (PST) In-reply-to: <1538141967-15375-7-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: Okamoto Takayuki , Christoffer Dall , Ard Biesheuvel , Marc Zyngier , Catalin Marinas , Will Deacon , kvmarm@lists.cs.columbia.edu, linux-arm-kernel@lists.infradead.org List-Id: kvmarm@lists.cs.columbia.edu CkRhdmUgTWFydGluIDxEYXZlLk1hcnRpbkBhcm0uY29tPiB3cml0ZXM6Cgo+IER1ZSB0byB0aGUg d2F5IHRoZSBlZmZlY3RpdmUgU1ZFIHZlY3RvciBsZW5ndGggaXMgY29udHJvbGxlZCBhbmQKPiB0 cmFwcGVkIGF0IGRpZmZlcmVudCBleGNlcHRpb24gbGV2ZWxzLCBjZXJ0YWluIG1pc21hdGNoZXMg aW4gdGhlCj4gc2V0cyBvZiB2ZWN0b3IgbGVuZ3RocyBzdXBwb3J0ZWQgYnkgZGlmZmVyZW50IHBo eXNpY2FsIENQVXMgaW4gdGhlCj4gc3lzdGVtIG1heSBwcmV2ZW50IHN0cmFpZ2h0Zm9yd2FyZCB2 aXJ0dWFsaXNhdGlvbiBvZiBTVkUgYXQgcGFyaXR5Cj4gd2l0aCB0aGUgaG9zdC4KPgo+IFRoaXMg cGF0Y2ggYW5hbHlzZXMgdGhlIGV4dGVudCB0byB3aGljaCBTVkUgY2FuIGJlIHZpcnR1YWxpc2Vk Cj4gc2FmZWx5IHdpdGhvdXQgaW50ZXJmZXJpbmcgd2l0aCBtaWdyYXRpb24gb2YgdmNwdXMgYmV0 d2VlbiBwaHlzaWNhbAo+IENQVXMsIGFuZCByZWplY3RzIGxhdGUgc2Vjb25kYXJ5IENQVXMgdGhh dCB3b3VsZCBlcm9kZSB0aGUKPiBzaXR1YXRpb24gZnVydGhlci4KPgo+IEl0IGlzIGxlZnQgdXAg dG8gS1ZNIHRvIGRlY2lkZSB3aGF0IHRvIGRvIHdpdGggdGhpcyBpbmZvcm1hdGlvbi4KPgo+IFNp Z25lZC1vZmYtYnk6IERhdmUgTWFydGluIDxEYXZlLk1hcnRpbkBhcm0uY29tPgo+IC0tLQo+Cj4g Q2hhbmdlcyBzaW5jZSBSRkN2MToKPgo+ICAqIFRoZSBhbmFseXNpcyBkb25lIGJ5IHRoaXMgcGF0 Y2ggaXMgdGhlIHNhbWUgYXMgaW4gdGhlIHByZXZpb3VzCj4gICAgdmVyc2lvbiwgYnV0IHRoZSBj b21taXQgbWVzc2FnZSB0aGUgcHJpbnRrcyBldGMuIGhhdmUgYmVlbiByZXdvcmRlZAo+ICAgIHRv IGF2b2lkIHRoZSBzdWdnZXN0aW9uIHRoYXQgS1ZNIGlzIGV4cGVjdGVkIHRvIHdvcmsgb24gYSBz eXN0ZW0gd2l0aAo+ICAgIG1pc21hdGNoZWQgU1ZFIGltcGxlbWVudGF0aW9ucy4KPiAtLS0KPiAg YXJjaC9hcm02NC9pbmNsdWRlL2FzbS9mcHNpbWQuaCB8ICAxICsKPiAgYXJjaC9hcm02NC9rZXJu ZWwvY3B1ZmVhdHVyZS5jICB8ICAyICstCj4gIGFyY2gvYXJtNjQva2VybmVsL2Zwc2ltZC5jICAg ICAgfCA4NyArKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKy0tLS0tLQo+ICAzIGZp bGVzIGNoYW5nZWQsIDc2IGluc2VydGlvbnMoKyksIDE0IGRlbGV0aW9ucygtKQo+Cj4gZGlmZiAt LWdpdCBhL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20vZnBzaW1kLmggYi9hcmNoL2FybTY0L2luY2x1 ZGUvYXNtL2Zwc2ltZC5oCj4gaW5kZXggZGQxYWQzOS4uOTY0YWRjOSAxMDA2NDQKPiAtLS0gYS9h cmNoL2FybTY0L2luY2x1ZGUvYXNtL2Zwc2ltZC5oCj4gKysrIGIvYXJjaC9hcm02NC9pbmNsdWRl L2FzbS9mcHNpbWQuaAo+IEBAIC04Nyw2ICs4Nyw3IEBAIGV4dGVybiB2b2lkIHN2ZV9rZXJuZWxf ZW5hYmxlKGNvbnN0IHN0cnVjdCBhcm02NF9jcHVfY2FwYWJpbGl0aWVzICpfX3VudXNlZCk7Cj4g IGV4dGVybiB1NjQgcmVhZF96Y3JfZmVhdHVyZXModm9pZCk7Cj4KPiAgZXh0ZXJuIGludCBfX3Jv X2FmdGVyX2luaXQgc3ZlX21heF92bDsKPiArZXh0ZXJuIGludCBfX3JvX2FmdGVyX2luaXQgc3Zl X21heF92aXJ0dWFsaXNhYmxlX3ZsOwo+Cj4gICNpZmRlZiBDT05GSUdfQVJNNjRfU1ZFCj4KPiBk aWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9rZXJuZWwvY3B1ZmVhdHVyZS5jIGIvYXJjaC9hcm02NC9r ZXJuZWwvY3B1ZmVhdHVyZS5jCj4gaW5kZXggZTIzOGI3OS4uYWExYTU1YiAxMDA2NDQKPiAtLS0g YS9hcmNoL2FybTY0L2tlcm5lbC9jcHVmZWF0dXJlLmMKPiArKysgYi9hcmNoL2FybTY0L2tlcm5l bC9jcHVmZWF0dXJlLmMKPiBAQCAtMTUzMSw3ICsxNTMxLDcgQEAgc3RhdGljIHZvaWQgdmVyaWZ5 X3N2ZV9mZWF0dXJlcyh2b2lkKQo+ICAJdW5zaWduZWQgaW50IGxlbiA9IHpjciAmIFpDUl9FTHhf TEVOX01BU0s7Cj4KPiAgCWlmIChsZW4gPCBzYWZlX2xlbiB8fCBzdmVfdmVyaWZ5X3ZxX21hcCgp KSB7Cj4gLQkJcHJfY3JpdCgiQ1BVJWQ6IFNWRTogcmVxdWlyZWQgdmVjdG9yIGxlbmd0aChzKSBt aXNzaW5nXG4iLAo+ICsJCXByX2NyaXQoIkNQVSVkOiBTVkU6IHZlY3RvciBsZW5ndGggc3VwcG9y dCBtaXNtYXRjaFxuIiwKPiAgCQkJc21wX3Byb2Nlc3Nvcl9pZCgpKTsKPiAgCQljcHVfZGllX2Vh cmx5KCk7Cj4gIAl9Cj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQva2VybmVsL2Zwc2ltZC5jIGIv YXJjaC9hcm02NC9rZXJuZWwvZnBzaW1kLmMKPiBpbmRleCA0MmFhMTU0Li5kMjgwNDJiIDEwMDY0 NAo+IC0tLSBhL2FyY2gvYXJtNjQva2VybmVsL2Zwc2ltZC5jCj4gKysrIGIvYXJjaC9hcm02NC9r ZXJuZWwvZnBzaW1kLmMKPiBAQCAtMTgsNiArMTgsNyBAQAo+ICAgKi8KPgo+ICAjaW5jbHVkZSA8 bGludXgvYml0bWFwLmg+Cj4gKyNpbmNsdWRlIDxsaW51eC9iaXRvcHMuaD4KPiAgI2luY2x1ZGUg PGxpbnV4L2JvdHRvbV9oYWxmLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9idWcuaD4KPiAgI2luY2x1 ZGUgPGxpbnV4L2NhY2hlLmg+Cj4gQEAgLTQ4LDYgKzQ5LDcgQEAKPiAgI2luY2x1ZGUgPGFzbS9z aWdjb250ZXh0Lmg+Cj4gICNpbmNsdWRlIDxhc20vc3lzcmVnLmg+Cj4gICNpbmNsdWRlIDxhc20v dHJhcHMuaD4KPiArI2luY2x1ZGUgPGFzbS92aXJ0Lmg+Cj4KPiAgI2RlZmluZSBGUEVYQ19JT0YJ KDEgPDwgMCkKPiAgI2RlZmluZSBGUEVYQ19EWkYJKDEgPDwgMSkKPiBAQCAtMTMwLDE0ICsxMzIs MTggQEAgc3RhdGljIGludCBzdmVfZGVmYXVsdF92bCA9IC0xOwo+Cj4gIC8qIE1heGltdW0gc3Vw cG9ydGVkIHZlY3RvciBsZW5ndGggYWNyb3NzIGFsbCBDUFVzIChpbml0aWFsbHkgcG9pc29uZWQp ICovCj4gIGludCBfX3JvX2FmdGVyX2luaXQgc3ZlX21heF92bCA9IFNWRV9WTF9NSU47Cj4gK2lu dCBfX3JvX2FmdGVyX2luaXQgc3ZlX21heF92aXJ0dWFsaXNhYmxlX3ZsID0gU1ZFX1ZMX01JTjsK PiAgLyogU2V0IG9mIGF2YWlsYWJsZSB2ZWN0b3IgbGVuZ3RocywgYXMgdnFfdG9fYml0KHZxKTog Ki8KPiAgc3RhdGljIF9fcm9fYWZ0ZXJfaW5pdCBERUNMQVJFX0JJVE1BUChzdmVfdnFfbWFwLCBT VkVfVlFfTUFYKTsKPiArLyogU2V0IG9mIHZlY3RvciBsZW5ndGhzIHByZXNlbnQgb24gYXQgbGVh c3Qgb25lIGNwdTogKi8KPiArc3RhdGljIF9fcm9fYWZ0ZXJfaW5pdCBERUNMQVJFX0JJVE1BUChz dmVfdnFfcGFydGlhbF9tYXAsIFNWRV9WUV9NQVgpOwo+ICBzdGF0aWMgdm9pZCBfX3BlcmNwdSAq ZWZpX3N2ZV9zdGF0ZTsKPgo+ICAjZWxzZSAvKiAhIENPTkZJR19BUk02NF9TVkUgKi8KPgo+ICAv KiBEdW1teSBkZWNsYXJhdGlvbiBmb3IgY29kZSB0aGF0IHdpbGwgYmUgb3B0aW1pc2VkIG91dDog Ki8KPiAgZXh0ZXJuIF9fcm9fYWZ0ZXJfaW5pdCBERUNMQVJFX0JJVE1BUChzdmVfdnFfbWFwLCBT VkVfVlFfTUFYKTsKPiArZXh0ZXJuIF9fcm9fYWZ0ZXJfaW5pdCBERUNMQVJFX0JJVE1BUChzdmVf dnFfcGFydGlhbF9tYXAsIFNWRV9WUV9NQVgpOwo+ICBleHRlcm4gdm9pZCBfX3BlcmNwdSAqZWZp X3N2ZV9zdGF0ZTsKPgo+ICAjZW5kaWYgLyogISBDT05GSUdfQVJNNjRfU1ZFICovCj4gQEAgLTYy MywxMSArNjI5LDggQEAgaW50IHN2ZV9nZXRfY3VycmVudF92bCh2b2lkKQo+ICAJcmV0dXJuIHN2 ZV9wcmN0bF9zdGF0dXMoMCk7Cj4gIH0KPgo+IC0vKgo+IC0gKiBCaXRtYXAgZm9yIHRlbXBvcmFy eSBzdG9yYWdlIG9mIHRoZSBwZXItQ1BVIHNldCBvZiBzdXBwb3J0ZWQgdmVjdG9yIGxlbmd0aHMK PiAtICogZHVyaW5nIHNlY29uZGFyeSBib290Lgo+IC0gKi8KPiAtc3RhdGljIERFQ0xBUkVfQklU TUFQKHN2ZV9zZWNvbmRhcnlfdnFfbWFwLCBTVkVfVlFfTUFYKTsKPiArLyogQml0bWFwcyBmb3Ig dGVtcG9yYXJ5IHN0b3JhZ2UgZHVyaW5nIG1hbmlwdWxhdGlvbiBvZiB2ZWN0b3IgbGVuZ3RoIHNl dHMgKi8KPiArc3RhdGljIERFQ0xBUkVfQklUTUFQKHN2ZV90bXBfdnFfbWFwLCBTVkVfVlFfTUFY KTsKClRoaXMgc2VlbXMgb2RkIGFzIGEgbG9jYWwgZ2xvYmFsLCB3aHkgbm90IGRlY2xhcmVkIGxv Y2FsbHkgd2hlbiB1c2VkPwoKPgo+ICBzdGF0aWMgdm9pZCBzdmVfcHJvYmVfdnFzKERFQ0xBUkVf QklUTUFQKG1hcCwgU1ZFX1ZRX01BWCkpCj4gIHsKPiBAQCAtNjUwLDYgKzY1Myw3IEBAIHN0YXRp YyB2b2lkIHN2ZV9wcm9iZV92cXMoREVDTEFSRV9CSVRNQVAobWFwLCBTVkVfVlFfTUFYKSkKPiAg dm9pZCBfX2luaXQgc3ZlX2luaXRfdnFfbWFwKHZvaWQpCj4gIHsKPiAgCXN2ZV9wcm9iZV92cXMo c3ZlX3ZxX21hcCk7Cj4gKwliaXRtYXBfY29weShzdmVfdnFfcGFydGlhbF9tYXAsIHN2ZV92cV9t YXAsIFNWRV9WUV9NQVgpOwo+ICB9Cj4KPiAgLyoKPiBAQCAtNjU4LDI0ICs2NjIsNjAgQEAgdm9p ZCBfX2luaXQgc3ZlX2luaXRfdnFfbWFwKHZvaWQpCj4gICAqLwo+ICB2b2lkIHN2ZV91cGRhdGVf dnFfbWFwKHZvaWQpCj4gIHsKPiAtCXN2ZV9wcm9iZV92cXMoc3ZlX3NlY29uZGFyeV92cV9tYXAp Owo+IC0JYml0bWFwX2FuZChzdmVfdnFfbWFwLCBzdmVfdnFfbWFwLCBzdmVfc2Vjb25kYXJ5X3Zx X21hcCwgU1ZFX1ZRX01BWCk7Cj4gKwlzdmVfcHJvYmVfdnFzKHN2ZV90bXBfdnFfbWFwKTsKPiAr CWJpdG1hcF9hbmQoc3ZlX3ZxX21hcCwgc3ZlX3ZxX21hcCwgc3ZlX3RtcF92cV9tYXAsCj4gKwkJ ICAgU1ZFX1ZRX01BWCk7Cj4gKwliaXRtYXBfb3Ioc3ZlX3ZxX3BhcnRpYWxfbWFwLCBzdmVfdnFf cGFydGlhbF9tYXAsIHN2ZV90bXBfdnFfbWFwLAo+ICsJCSAgU1ZFX1ZRX01BWCk7Cj4gIH0KCkkn bSBub3QgcXVpdGUgZm9sbG93aW5nIHdoYXQncyBnb2luZyBvbiBoZXJlLiBUaGlzIGlzIHRyYWNr aW5nIGJvdGggdGhlCnZlY3RvciBsZW5ndGhzIGF2YWlsYWJsZSBvbiBhbGwgQ1BVcyBhbmQgdGhl IG9uZXMgYXZhaWxhYmxlIG9uIGF0IGxlYXN0Cm9uZSBDUFU/IFRoaXMgcmFpc2VzIGEgc29tZSBx dWVzdGlvbnM6CgogIC0gZG8gc3VjaCBmcmFua2VuLW1hY2hpbmVzIGV4aXN0IG9yIGFyZSBleHBl Y3RlZCB0byBleGl0PwogIC0gaG93IGRvIHdlIGVuc3VyZSB0aGlzIGlzIGFsd2F5cyB1cHRvIGRh dGU/CiAgLSB3aGF0IGhhcHBlbnMgd2hlbiB3ZSBob3RwbHVnIGEgbmV3IENQVSB3aXRoIGxlc3Mg YXZhaWxhYmxlIFZRPwoKPgo+ICAvKiBDaGVjayB3aGV0aGVyIHRoZSBjdXJyZW50IENQVSBzdXBw b3J0cyBhbGwgVlFzIGluIHRoZSBjb21taXR0ZWQgc2V0ICovCj4gIGludCBzdmVfdmVyaWZ5X3Zx X21hcCh2b2lkKQo+ICB7Cj4gLQlpbnQgcmV0ID0gMDsKPiArCWludCByZXQgPSAtRUlOVkFMOwo+ ICsJdW5zaWduZWQgbG9uZyBiOwo+Cj4gLQlzdmVfcHJvYmVfdnFzKHN2ZV9zZWNvbmRhcnlfdnFf bWFwKTsKPiAtCWJpdG1hcF9hbmRub3Qoc3ZlX3NlY29uZGFyeV92cV9tYXAsIHN2ZV92cV9tYXAs IHN2ZV9zZWNvbmRhcnlfdnFfbWFwLAo+IC0JCSAgICAgIFNWRV9WUV9NQVgpOwo+IC0JaWYgKCFi aXRtYXBfZW1wdHkoc3ZlX3NlY29uZGFyeV92cV9tYXAsIFNWRV9WUV9NQVgpKSB7Cj4gKwlzdmVf cHJvYmVfdnFzKHN2ZV90bXBfdnFfbWFwKTsKPiArCj4gKwliaXRtYXBfY29tcGxlbWVudChzdmVf dG1wX3ZxX21hcCwgc3ZlX3RtcF92cV9tYXAsIFNWRV9WUV9NQVgpOwo+ICsJaWYgKGJpdG1hcF9p bnRlcnNlY3RzKHN2ZV90bXBfdnFfbWFwLCBzdmVfdnFfbWFwLCBTVkVfVlFfTUFYKSkgewo+ICAJ CXByX3dhcm4oIlNWRTogY3B1JWQ6IFJlcXVpcmVkIHZlY3RvciBsZW5ndGgocykgbWlzc2luZ1xu IiwKPiAgCQkJc21wX3Byb2Nlc3Nvcl9pZCgpKTsKPiAtCQlyZXQgPSAtRUlOVkFMOwo+ICsJCWdv dG8gZXJyb3I7CgpUaGUgdXNlIG9mIGdvdG8gc2VlbXMgYSBsaXR0bGUgcHJlbWF0dXJlIGNvbnNp ZGVyaW5nIHdlIGRvbid0IGhhdmUgYW55CmNsZWFuLXVwIHRvIGRvLgoKPiArCX0KPiArCj4gKwlp ZiAoIUlTX0VOQUJMRUQoQ09ORklHX0tWTSkgfHwgIWlzX2h5cF9tb2RlX2F2YWlsYWJsZSgpKQo+ ICsJCWdvdG8gb2s7Cj4gKwo+ICsJLyoKPiArCSAqIEZvciBLVk0sIGl0IGlzIG5lY2Vzc2FyeSB0 byBlbnN1cmUgdGhhdCB0aGlzIENQVSBkb2Vzbid0Cj4gKwkgKiBzdXBwb3J0IGFueSB2ZWN0b3Ig bGVuZ3RoIHRoYXQgZ3Vlc3RzIG1heSBoYXZlIHByb2JlZCBhcwo+ICsJICogdW5zdXBwb3J0ZWQu Cj4gKwkgKi8KPiArCj4gKwkvKiBSZWNvdmVyIHRoZSBzZXQgb2Ygc3VwcG9ydGVkIFZRczogKi8K PiArCWJpdG1hcF9jb21wbGVtZW50KHN2ZV90bXBfdnFfbWFwLCBzdmVfdG1wX3ZxX21hcCwgU1ZF X1ZRX01BWCk7Cj4gKwkvKiBGaW5kIFZRcyBzdXBwb3J0ZWQgdGhhdCBhcmUgbm90IGdsb2JhbGx5 IHN1cHBvcnRlZDogKi8KPiArCWJpdG1hcF9hbmRub3Qoc3ZlX3RtcF92cV9tYXAsIHN2ZV90bXBf dnFfbWFwLCBzdmVfdnFfbWFwLCBTVkVfVlFfTUFYKTsKPiArCj4gKwkvKiBGaW5kIHRoZSBsb3dl c3Qgc3VjaCBWUSwgaWYgYW55OiAqLwo+ICsJYiA9IGZpbmRfbGFzdF9iaXQoc3ZlX3RtcF92cV9t YXAsIFNWRV9WUV9NQVgpOwo+ICsJaWYgKGIgPj0gU1ZFX1ZRX01BWCkKPiArCQlnb3RvIG9rOyAv KiBubyBtaXNtYXRjaGVzICovCj4gKwo+ICsJLyoKPiArCSAqIE1pc21hdGNoZXMgYWJvdmUgc3Zl X21heF92aXJ0dWFsaXNhYmxlX3ZsIGFyZSBmaW5lLCBzaW5jZQo+ICsJICogbm8gZ3Vlc3QgaXMg YWxsb3dlZCB0byBjb25maWd1cmUgWkNSX0VMMi5MRU4gdG8gZXhjZWVkIHRoaXM6Cj4gKwkgKi8K PiArCWlmIChzdmVfdmxfZnJvbV92cShiaXRfdG9fdnEoYikpIDw9IHN2ZV9tYXhfdmlydHVhbGlz YWJsZV92bCkgewo+ICsJCXByX3dhcm4oIlNWRTogY3B1JWQ6IFVuc3VwcG9ydGVkIHZlY3RvciBs ZW5ndGgocykgcHJlc2VudFxuIiwKPiArCQkJc21wX3Byb2Nlc3Nvcl9pZCgpKTsKPiArCQlnb3Rv IGVycm9yOwo+ICAJfQo+Cj4gK29rOgo+ICsJcmV0ID0gMDsKPiArZXJyb3I6Cj4gIAlyZXR1cm4g cmV0Owo+ICB9Cj4KPiBAQCAtNzQzLDYgKzc4Myw3IEBAIHU2NCByZWFkX3pjcl9mZWF0dXJlcyh2 b2lkKQo+ICB2b2lkIF9faW5pdCBzdmVfc2V0dXAodm9pZCkKPiAgewo+ICAJdTY0IHpjcjsKPiAr CXVuc2lnbmVkIGxvbmcgYjsKPgo+ICAJaWYgKCFzeXN0ZW1fc3VwcG9ydHNfc3ZlKCkpCj4gIAkJ cmV0dXJuOwo+IEBAIC03NzEsMTEgKzgxMiwzMSBAQCB2b2lkIF9faW5pdCBzdmVfc2V0dXAodm9p ZCkKPiAgCSAqLwo+ICAJc3ZlX2RlZmF1bHRfdmwgPSBmaW5kX3N1cHBvcnRlZF92ZWN0b3JfbGVu Z3RoKDY0KTsKPgo+ICsJYml0bWFwX2FuZG5vdChzdmVfdG1wX3ZxX21hcCwgc3ZlX3ZxX3BhcnRp YWxfbWFwLCBzdmVfdnFfbWFwLAo+ICsJCSAgICAgIFNWRV9WUV9NQVgpOwo+ICsKPiArCWIgPSBm aW5kX2xhc3RfYml0KHN2ZV90bXBfdnFfbWFwLCBTVkVfVlFfTUFYKTsKPiArCWlmIChiID49IFNW RV9WUV9NQVgpCj4gKwkJLyogTm8gbm9uLXZpcnR1YWxpc2FibGUgVkxzIGZvdW5kICovCj4gKwkJ c3ZlX21heF92aXJ0dWFsaXNhYmxlX3ZsID0gU1ZFX1ZRX01BWDsKPiArCWVsc2UgaWYgKFdBUk5f T04oYiA9PSBTVkVfVlFfTUFYIC0gMSkpCj4gKwkJLyogTm8gdmlydHVhbGlzYWJsZSBWTHM/ICBU aGlzIGlzIGFyY2hpdGVjdHVyYWxseSBmb3JiaWRkZW4uICovCj4gKwkJc3ZlX21heF92aXJ0dWFs aXNhYmxlX3ZsID0gU1ZFX1ZRX01JTjsKPiArCWVsc2UgLyogYiArIDEgPCBTVkVfVlFfTUFYICov Cj4gKwkJc3ZlX21heF92aXJ0dWFsaXNhYmxlX3ZsID0gc3ZlX3ZsX2Zyb21fdnEoYml0X3RvX3Zx KGIgKyAxKSk7Cj4gKwo+ICsJaWYgKHN2ZV9tYXhfdmlydHVhbGlzYWJsZV92bCA+IHN2ZV9tYXhf dmwpCj4gKwkJc3ZlX21heF92aXJ0dWFsaXNhYmxlX3ZsID0gc3ZlX21heF92bDsKPiArCj4gIAlw cl9pbmZvKCJTVkU6IG1heGltdW0gYXZhaWxhYmxlIHZlY3RvciBsZW5ndGggJXUgYnl0ZXMgcGVy IHZlY3RvclxuIiwKPiAgCQlzdmVfbWF4X3ZsKTsKPiAgCXByX2luZm8oIlNWRTogZGVmYXVsdCB2 ZWN0b3IgbGVuZ3RoICV1IGJ5dGVzIHBlciB2ZWN0b3JcbiIsCj4gIAkJc3ZlX2RlZmF1bHRfdmwp Owo+Cj4gKwkvKiBLVk0gZGVjaWRlcyB3aGV0aGVyIHRvIHN1cHBvcnQgbWlzbWF0Y2hlZCBzeXN0 ZW1zLiBKdXN0IHdhcm4gaGVyZTogKi8KPiArCWlmIChzdmVfbWF4X3ZpcnR1YWxpc2FibGVfdmwg PCBzdmVfbWF4X3ZsKQo+ICsJCXByX2luZm8oIlNWRTogdW52aXJ0dWFsaXNhYmxlIHZlY3RvciBs ZW5ndGhzIHByZXNlbnRcbiIpOwo+ICsKPiAgCXN2ZV9lZmlfc2V0dXAoKTsKPiAgfQoKCi0tCkFs ZXggQmVubsOpZQpfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f Xwprdm1hcm0gbWFpbGluZyBsaXN0Cmt2bWFybUBsaXN0cy5jcy5jb2x1bWJpYS5lZHUKaHR0cHM6 Ly9saXN0cy5jcy5jb2x1bWJpYS5lZHUvbWFpbG1hbi9saXN0aW5mby9rdm1hcm0K From mboxrd@z Thu Jan 1 00:00:00 1970 From: alex.bennee@linaro.org (Alex =?utf-8?Q?Benn=C3=A9e?=) Date: Thu, 15 Nov 2018 15:39:01 +0000 Subject: [RFC PATCH v2 06/23] arm64/sve: Check SVE virtualisability In-Reply-To: <1538141967-15375-7-git-send-email-Dave.Martin@arm.com> References: <1538141967-15375-1-git-send-email-Dave.Martin@arm.com> <1538141967-15375-7-git-send-email-Dave.Martin@arm.com> Message-ID: <87in0ycpuy.fsf@linaro.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Dave Martin writes: > Due to the way the effective SVE vector length is controlled and > trapped at different exception levels, certain mismatches in the > sets of vector lengths supported by different physical CPUs in the > system may prevent straightforward virtualisation of SVE at parity > with the host. > > This patch analyses the extent to which SVE can be virtualised > safely without interfering with migration of vcpus between physical > CPUs, and rejects late secondary CPUs that would erode the > situation further. > > It is left up to KVM to decide what to do with this information. > > Signed-off-by: Dave Martin > --- > > Changes since RFCv1: > > * The analysis done by this patch is the same as in the previous > version, but the commit message the printks etc. have been reworded > to avoid the suggestion that KVM is expected to work on a system with > mismatched SVE implementations. > --- > arch/arm64/include/asm/fpsimd.h | 1 + > arch/arm64/kernel/cpufeature.c | 2 +- > arch/arm64/kernel/fpsimd.c | 87 +++++++++++++++++++++++++++++++++++------ > 3 files changed, 76 insertions(+), 14 deletions(-) > > diff --git a/arch/arm64/include/asm/fpsimd.h b/arch/arm64/include/asm/fpsimd.h > index dd1ad39..964adc9 100644 > --- a/arch/arm64/include/asm/fpsimd.h > +++ b/arch/arm64/include/asm/fpsimd.h > @@ -87,6 +87,7 @@ extern void sve_kernel_enable(const struct arm64_cpu_capabilities *__unused); > extern u64 read_zcr_features(void); > > extern int __ro_after_init sve_max_vl; > +extern int __ro_after_init sve_max_virtualisable_vl; > > #ifdef CONFIG_ARM64_SVE > > diff --git a/arch/arm64/kernel/cpufeature.c b/arch/arm64/kernel/cpufeature.c > index e238b79..aa1a55b 100644 > --- a/arch/arm64/kernel/cpufeature.c > +++ b/arch/arm64/kernel/cpufeature.c > @@ -1531,7 +1531,7 @@ static void verify_sve_features(void) > unsigned int len = zcr & ZCR_ELx_LEN_MASK; > > if (len < safe_len || sve_verify_vq_map()) { > - pr_crit("CPU%d: SVE: required vector length(s) missing\n", > + pr_crit("CPU%d: SVE: vector length support mismatch\n", > smp_processor_id()); > cpu_die_early(); > } > diff --git a/arch/arm64/kernel/fpsimd.c b/arch/arm64/kernel/fpsimd.c > index 42aa154..d28042b 100644 > --- a/arch/arm64/kernel/fpsimd.c > +++ b/arch/arm64/kernel/fpsimd.c > @@ -18,6 +18,7 @@ > */ > > #include > +#include > #include > #include > #include > @@ -48,6 +49,7 @@ > #include > #include > #include > +#include > > #define FPEXC_IOF (1 << 0) > #define FPEXC_DZF (1 << 1) > @@ -130,14 +132,18 @@ static int sve_default_vl = -1; > > /* Maximum supported vector length across all CPUs (initially poisoned) */ > int __ro_after_init sve_max_vl = SVE_VL_MIN; > +int __ro_after_init sve_max_virtualisable_vl = SVE_VL_MIN; > /* Set of available vector lengths, as vq_to_bit(vq): */ > static __ro_after_init DECLARE_BITMAP(sve_vq_map, SVE_VQ_MAX); > +/* Set of vector lengths present on at least one cpu: */ > +static __ro_after_init DECLARE_BITMAP(sve_vq_partial_map, SVE_VQ_MAX); > static void __percpu *efi_sve_state; > > #else /* ! CONFIG_ARM64_SVE */ > > /* Dummy declaration for code that will be optimised out: */ > extern __ro_after_init DECLARE_BITMAP(sve_vq_map, SVE_VQ_MAX); > +extern __ro_after_init DECLARE_BITMAP(sve_vq_partial_map, SVE_VQ_MAX); > extern void __percpu *efi_sve_state; > > #endif /* ! CONFIG_ARM64_SVE */ > @@ -623,11 +629,8 @@ int sve_get_current_vl(void) > return sve_prctl_status(0); > } > > -/* > - * Bitmap for temporary storage of the per-CPU set of supported vector lengths > - * during secondary boot. > - */ > -static DECLARE_BITMAP(sve_secondary_vq_map, SVE_VQ_MAX); > +/* Bitmaps for temporary storage during manipulation of vector length sets */ > +static DECLARE_BITMAP(sve_tmp_vq_map, SVE_VQ_MAX); This seems odd as a local global, why not declared locally when used? > > static void sve_probe_vqs(DECLARE_BITMAP(map, SVE_VQ_MAX)) > { > @@ -650,6 +653,7 @@ static void sve_probe_vqs(DECLARE_BITMAP(map, SVE_VQ_MAX)) > void __init sve_init_vq_map(void) > { > sve_probe_vqs(sve_vq_map); > + bitmap_copy(sve_vq_partial_map, sve_vq_map, SVE_VQ_MAX); > } > > /* > @@ -658,24 +662,60 @@ void __init sve_init_vq_map(void) > */ > void sve_update_vq_map(void) > { > - sve_probe_vqs(sve_secondary_vq_map); > - bitmap_and(sve_vq_map, sve_vq_map, sve_secondary_vq_map, SVE_VQ_MAX); > + sve_probe_vqs(sve_tmp_vq_map); > + bitmap_and(sve_vq_map, sve_vq_map, sve_tmp_vq_map, > + SVE_VQ_MAX); > + bitmap_or(sve_vq_partial_map, sve_vq_partial_map, sve_tmp_vq_map, > + SVE_VQ_MAX); > } I'm not quite following what's going on here. This is tracking both the vector lengths available on all CPUs and the ones available on at least one CPU? This raises a some questions: - do such franken-machines exist or are expected to exit? - how do we ensure this is always upto date? - what happens when we hotplug a new CPU with less available VQ? > > /* Check whether the current CPU supports all VQs in the committed set */ > int sve_verify_vq_map(void) > { > - int ret = 0; > + int ret = -EINVAL; > + unsigned long b; > > - sve_probe_vqs(sve_secondary_vq_map); > - bitmap_andnot(sve_secondary_vq_map, sve_vq_map, sve_secondary_vq_map, > - SVE_VQ_MAX); > - if (!bitmap_empty(sve_secondary_vq_map, SVE_VQ_MAX)) { > + sve_probe_vqs(sve_tmp_vq_map); > + > + bitmap_complement(sve_tmp_vq_map, sve_tmp_vq_map, SVE_VQ_MAX); > + if (bitmap_intersects(sve_tmp_vq_map, sve_vq_map, SVE_VQ_MAX)) { > pr_warn("SVE: cpu%d: Required vector length(s) missing\n", > smp_processor_id()); > - ret = -EINVAL; > + goto error; The use of goto seems a little premature considering we don't have any clean-up to do. > + } > + > + if (!IS_ENABLED(CONFIG_KVM) || !is_hyp_mode_available()) > + goto ok; > + > + /* > + * For KVM, it is necessary to ensure that this CPU doesn't > + * support any vector length that guests may have probed as > + * unsupported. > + */ > + > + /* Recover the set of supported VQs: */ > + bitmap_complement(sve_tmp_vq_map, sve_tmp_vq_map, SVE_VQ_MAX); > + /* Find VQs supported that are not globally supported: */ > + bitmap_andnot(sve_tmp_vq_map, sve_tmp_vq_map, sve_vq_map, SVE_VQ_MAX); > + > + /* Find the lowest such VQ, if any: */ > + b = find_last_bit(sve_tmp_vq_map, SVE_VQ_MAX); > + if (b >= SVE_VQ_MAX) > + goto ok; /* no mismatches */ > + > + /* > + * Mismatches above sve_max_virtualisable_vl are fine, since > + * no guest is allowed to configure ZCR_EL2.LEN to exceed this: > + */ > + if (sve_vl_from_vq(bit_to_vq(b)) <= sve_max_virtualisable_vl) { > + pr_warn("SVE: cpu%d: Unsupported vector length(s) present\n", > + smp_processor_id()); > + goto error; > } > > +ok: > + ret = 0; > +error: > return ret; > } > > @@ -743,6 +783,7 @@ u64 read_zcr_features(void) > void __init sve_setup(void) > { > u64 zcr; > + unsigned long b; > > if (!system_supports_sve()) > return; > @@ -771,11 +812,31 @@ void __init sve_setup(void) > */ > sve_default_vl = find_supported_vector_length(64); > > + bitmap_andnot(sve_tmp_vq_map, sve_vq_partial_map, sve_vq_map, > + SVE_VQ_MAX); > + > + b = find_last_bit(sve_tmp_vq_map, SVE_VQ_MAX); > + if (b >= SVE_VQ_MAX) > + /* No non-virtualisable VLs found */ > + sve_max_virtualisable_vl = SVE_VQ_MAX; > + else if (WARN_ON(b == SVE_VQ_MAX - 1)) > + /* No virtualisable VLs? This is architecturally forbidden. */ > + sve_max_virtualisable_vl = SVE_VQ_MIN; > + else /* b + 1 < SVE_VQ_MAX */ > + sve_max_virtualisable_vl = sve_vl_from_vq(bit_to_vq(b + 1)); > + > + if (sve_max_virtualisable_vl > sve_max_vl) > + sve_max_virtualisable_vl = sve_max_vl; > + > pr_info("SVE: maximum available vector length %u bytes per vector\n", > sve_max_vl); > pr_info("SVE: default vector length %u bytes per vector\n", > sve_default_vl); > > + /* KVM decides whether to support mismatched systems. Just warn here: */ > + if (sve_max_virtualisable_vl < sve_max_vl) > + pr_info("SVE: unvirtualisable vector lengths present\n"); > + > sve_efi_setup(); > } -- Alex Benn?e