From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alex =?utf-8?Q?Benn=C3=A9e?= Subject: Re: [PATCH v10 14/18] KVM: arm64: Save host SVE context as appropriate Date: Thu, 24 May 2018 15:49:51 +0100 Message-ID: <871se1t8fk.fsf@linaro.org> References: <1527005119-6842-1-git-send-email-Dave.Martin@arm.com> <1527005119-6842-15-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: <1527005119-6842-15-git-send-email-Dave.Martin@arm.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+linux-arm-kernel=m.gmane.org@lists.infradead.org To: Dave Martin Cc: 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+IFRoaXMgcGF0Y2gg YWRkcyBTVkUgY29udGV4dCBzYXZpbmcgdG8gdGhlIGh5cCBGUFNJTUQgY29udGV4dCBzd2l0Y2gK PiBwYXRoLiAgVGhpcyBtZWFucyB0aGF0IGl0IGlzIG5vIGxvbmdlciBuZWNlc3NhcnkgdG8gc2F2 ZSB0aGUgaG9zdAo+IFNWRSBzdGF0ZSBpbiBhZHZhbmNlIG9mIGVudGVyaW5nIHRoZSBndWVzdCwg d2hlbiBpbiB1c2UuCj4KPiBJbiBvcmRlciB0byBhdm9pZCBhZGRpbmcgcG9pbnRsZXNzIGNvbXBs ZXhpdHkgdG8gdGhlIGNvZGUsIFZIRSBpcwo+IGFzc3VtZWQgaWYgU1ZFIGlzIGluIHVzZS4gIFZI RSBpcyBhbiBhcmNoaXRlY3R1cmFsIHByZXJlcXVpc2l0ZSBmb3IKPiBTVkUsIHNvIHRoZXJlIGlz IG5vIGdvb2QgcmVhc29uIHRvIHR1cm4gQ09ORklHX0FSTTY0X1ZIRSBvZmYgaW4KPiBrZXJuZWxz IHRoYXQgc3VwcG9ydCBib3RoIFNWRSBhbmQgS1ZNLgo+Cj4gSGlzdG9yaWNhbGx5LCBzb2Z0d2Fy ZSBtb2RlbHMgZXhpc3QgdGhhdCBjYW4gZXhwb3NlIHRoZQo+IGFyY2hpdGVjdHVyYWxseSBpbnZh bGlkIGNvbmZpZ3VyYXRpb24gb2YgU1ZFIHdpdGhvdXQgVkhFLCBzbyBpZgo+IHRoaXMgc2l0dWF0 aW9uIGlzIGRldGVjdGVkIGF0IGt2bV9pbml0KCkgdGltZSB0aGVuIEtWTSB3aWxsIGJlCj4gZGlz YWJsZWQuCj4KPiBTaWduZWQtb2ZmLWJ5OiBEYXZlIE1hcnRpbiA8RGF2ZS5NYXJ0aW5AYXJtLmNv bT4KPgo+IC0tLQo+Cj4gICogVGFncyBzdHJpcHBlZCBzaW5jZSB2OCwgcGxlYXNlIHJlY29uZmly bSBpZiBwb3NzaWJsZToKPgo+IEZvcm1lcmx5LVJldmlld2VkLWJ5OiBDaHJpc3RvZmZlciBEYWxs IDxjaHJpc3RvZmZlci5kYWxsIGF0IGFybS5jb20+Cj4gRm9ybWVybHktQWNrZWQtYnk6IE1hcmMg WnluZ2llciA8bWFyYy56eW5naWVyIGF0IGFybS5jb20+Cj4gRm9ybWVybHktQWNrZWQtYnk6IENh dGFsaW4gTWFyaW5hcyA8Y2F0YWxpbi5tYXJpbmFzIGF0IGFybS5jb20+Cj4KPiBDaGFuZ2VzIHNp bmNlIHY5Ogo+Cj4gUmVxdWVzdGVkIGJ5IE1hcmMgWnluZ2llcjoKPgo+ICAqIElubGluZSBjaGVj ayBmb3IgVkhFIGlmIFNWRSBpcyBwcmVzZW50IGludG8ga3ZtX2hvc3QuaC4KPgo+ICAgIFRoZSBj aGVjayBoYXMgYmVlbiByZW5hbWVkIHRvIHRoZSBtb3JlIHNwZWNpZmljCj4gICAga3ZtX2FyY2hf Y2hlY2tfc3ZlX2hhc192aGUoKSwgYW5kIHRoZSBrdm1fcHJfdW5pbXBsKCkgbW92ZWQgYmFjayB0 bwo+ICAgIGFybS5jICh0byBhdm9pZCBjaXJjdWxhciBpbmNsdWRlIGlzc3VlcykuCj4KPiAgICBh cm0uYyBpcyBub3Qgc2luZ2xlLWFyY2ggY29kZSwgYnV0IGl0IGlzIGFsbCBBcm0tc3BlY2lmaWMs IHNvCj4gICAgYWRkaW5nIGEgaG9vayBsaWtlIHRoaXMgZG9lc24ndCBzZWVtIHRvbyB1bnJlYXNv bmFibGUuCj4KPiBDaGFuZ2VzIHNpbmNlIHY4Ogo+Cj4gICogQWRkIGt2bV9hcmNoX2NoZWNrX3N1 cHBvcnRlZCgpIGhvb2ssIGFuZCBtb3ZlIGFybTY0LXNwZWNpZmljIGNoZWNrCj4gICAgZm9yIFNW RS1pbXBsaWVzLVZIRSBpbnRvIGFyY2gvYXJtNjQvLgo+Cj4gICAgRHVlIHRvIGNpcmN1bGFyIGhl YWRlciBkZXBlbmRlbmN5IHByb2JsZW1zLCBpdCBpcyBkaWZmaWN1bHQgdG8gZ2V0Cj4gICAgdGhl IHByb3RvdHlwZSBmb3Iga3ZtX3ByXyooKSBmdW5jdGlvbnMgaW4gPGFzbS9rdm1faG9zdC5oPiwg c28gdGhpcwo+ICAgIHBhdGNoIHB1dHMgYXJtNjQncyBrdm1fYXJjaF9jaGVja19zdXBwb3J0ZWQo KSBob29rIG91dCBvZiBsaW5lLgo+ICAgIFRoaXMgaXMgbm90IGEgaG90IGZ1bmN0aW9uLgo+IC0t LQo+ICBhcmNoL2FybS9pbmNsdWRlL2FzbS9rdm1faG9zdC5oICAgfCAgMSArCj4gIGFyY2gvYXJt NjQvS2NvbmZpZyAgICAgICAgICAgICAgICB8ICA3ICsrKysrKysKPiAgYXJjaC9hcm02NC9pbmNs dWRlL2FzbS9rdm1faG9zdC5oIHwgMTMgKysrKysrKysrKysrKwo+ICBhcmNoL2FybTY0L2t2bS9m cHNpbWQuYyAgICAgICAgICAgfCAgMSAtCj4gIGFyY2gvYXJtNjQva3ZtL2h5cC9zd2l0Y2guYyAg ICAgICB8IDIwICsrKysrKysrKysrKysrKysrKystCj4gIHZpcnQva3ZtL2FybS9hcm0uYyAgICAg ICAgICAgICAgICB8ICA3ICsrKysrKysKPiAgNiBmaWxlcyBjaGFuZ2VkLCA0NyBpbnNlcnRpb25z KCspLCAyIGRlbGV0aW9ucygtKQo+Cj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2luY2x1ZGUvYXNt L2t2bV9ob3N0LmggYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9rdm1faG9zdC5oCj4gaW5kZXggYWM4 NzBiMi4uM2I4NWJiYiAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9rdm1faG9z dC5oCj4gKysrIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20va3ZtX2hvc3QuaAo+IEBAIC0yODAsNiAr MjgwLDcgQEAgdm9pZCBrdm1fbW11X3dwX21lbW9yeV9yZWdpb24oc3RydWN0IGt2bSAqa3ZtLCBp bnQgc2xvdCk7Cj4KPiAgc3RydWN0IGt2bV92Y3B1ICprdm1fbXBpZHJfdG9fdmNwdShzdHJ1Y3Qg a3ZtICprdm0sIHVuc2lnbmVkIGxvbmcgbXBpZHIpOwo+Cj4gK3N0YXRpYyBpbmxpbmUgYm9vbCBr dm1fYXJjaF9jaGVja19zdmVfaGFzX3ZoZSh2b2lkKSB7IHJldHVybiB0cnVlOyB9Cj4gIHN0YXRp YyBpbmxpbmUgdm9pZCBrdm1fYXJjaF9oYXJkd2FyZV91bnNldHVwKHZvaWQpIHt9Cj4gIHN0YXRp YyBpbmxpbmUgdm9pZCBrdm1fYXJjaF9zeW5jX2V2ZW50cyhzdHJ1Y3Qga3ZtICprdm0pIHt9Cj4g IHN0YXRpYyBpbmxpbmUgdm9pZCBrdm1fYXJjaF92Y3B1X3VuaW5pdChzdHJ1Y3Qga3ZtX3ZjcHUg KnZjcHUpIHt9Cj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQvS2NvbmZpZyBiL2FyY2gvYXJtNjQv S2NvbmZpZwo+IGluZGV4IGViMmNmNDkuLmIwZDM4MjAgMTAwNjQ0Cj4gLS0tIGEvYXJjaC9hcm02 NC9LY29uZmlnCj4gKysrIGIvYXJjaC9hcm02NC9LY29uZmlnCj4gQEAgLTExMzAsNiArMTEzMCw3 IEBAIGVuZG1lbnUKPiAgY29uZmlnIEFSTTY0X1NWRQo+ICAJYm9vbCAiQVJNIFNjYWxhYmxlIFZl Y3RvciBFeHRlbnNpb24gc3VwcG9ydCIKPiAgCWRlZmF1bHQgeQo+ICsJZGVwZW5kcyBvbiAhS1ZN IHx8IEFSTTY0X1ZIRQo+ICAJaGVscAo+ICAJICBUaGUgU2NhbGFibGUgVmVjdG9yIEV4dGVuc2lv biAoU1ZFKSBpcyBhbiBleHRlbnNpb24gdG8gdGhlIEFBcmNoNjQKPiAgCSAgZXhlY3V0aW9uIHN0 YXRlIHdoaWNoIGNvbXBsZW1lbnRzIGFuZCBleHRlbmRzIHRoZSBTSU1EIGZ1bmN0aW9uYWxpdHkK PiBAQCAtMTE1NSw2ICsxMTU2LDEyIEBAIGNvbmZpZyBBUk02NF9TVkUKPiAgCSAgYm9vdGluZyB0 aGUga2VybmVsLiAgSWYgdW5zdXJlIGFuZCB5b3UgYXJlIG5vdCBvYnNlcnZpbmcgdGhlc2UKPiAg CSAgc3ltcHRvbXMsIHlvdSBzaG91bGQgYXNzdW1lIHRoYXQgaXQgaXMgc2FmZSB0byBzYXkgWS4K Pgo+ICsJICBDUFVzIHRoYXQgc3VwcG9ydCBTVkUgYXJlIGFyY2hpdGVjdHVyYWxseSByZXF1aXJl ZCB0byBzdXBwb3J0IHRoZQo+ICsJICBWaXJ0dWFsaXphdGlvbiBIb3N0IEV4dGVuc2lvbnMgKFZI RSksIHNvIHRoZSBrZXJuZWwgbWFrZXMgbm8KPiArCSAgcHJvdmlzaW9uIGZvciBzdXBwb3J0aW5n IFNWRSBhbG9uZ3NpZGUgS1ZNIHdpdGhvdXQgVkhFIGVuYWJsZWQuCj4gKwkgIFRodXMsIHlvdSB3 aWxsIG5lZWQgdG8gZW5hYmxlIENPTkZJR19BUk02NF9WSEUgaWYgeW91IHdhbnQgdG8gc3VwcG9y dAo+ICsJICBLVk0gaW4gdGhlIHNhbWUga2VybmVsIGltYWdlLgo+ICsKPiAgY29uZmlnIEFSTTY0 X01PRFVMRV9QTFRTCj4gIAlib29sCj4gIAlzZWxlY3QgSEFWRV9NT0RfQVJDSF9TUEVDSUZJQwo+ IGRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmggYi9hcmNoL2Fy bTY0L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKPiBpbmRleCBiM2ZlNzMwLi4wNmQ1YTYxIDEwMDY0 NAo+IC0tLSBhL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX2hvc3QuaAo+ICsrKyBiL2FyY2gv YXJtNjQvaW5jbHVkZS9hc20va3ZtX2hvc3QuaAo+IEBAIC00MDUsNiArNDA1LDE5IEBAIHN0YXRp YyBpbmxpbmUgdm9pZCBfX2NwdV9pbml0X2h5cF9tb2RlKHBoeXNfYWRkcl90IHBnZF9wdHIsCj4g IAlrdm1fY2FsbF9oeXAoX19rdm1fc2V0X3RwaWRyX2VsMiwgdHBpZHJfZWwyKTsKPiAgfQo+Cj4g K3N0YXRpYyBpbmxpbmUgYm9vbCBrdm1fYXJjaF9jaGVja19zdmVfaGFzX3ZoZSh2b2lkKQo+ICt7 Cj4gKwkvKgo+ICsJICogVGhlIEFybSBhcmNoaXRlY3R1cmUgc3BlY2lmaWVzIHRoYXQgaW1scGVt ZW50YXRpb24gb2YgU1ZFCj4gKwkgKiByZXF1aXJlcyBWSEUgYWxzbyB0byBiZSBpbXBsZW1lbnRl ZC4gIFRoZSBLVk0gY29kZSBmb3IgYXJtNjQKPiArCSAqIHJlbGllcyBvbiB0aGlzIHdoZW4gU1ZF IGlzIHByZXNlbnQ6Cj4gKwkgKi8KPiArCWlmIChzeXN0ZW1fc3VwcG9ydHNfc3ZlKCkpCj4gKwkJ cmV0dXJuIGhhc192aGUoKTsKPiArCWVsc2UKPiArCQlyZXR1cm4gdHJ1ZTsKPiArfQo+ICsKPiAg c3RhdGljIGlubGluZSB2b2lkIGt2bV9hcmNoX2hhcmR3YXJlX3Vuc2V0dXAodm9pZCkge30KPiAg c3RhdGljIGlubGluZSB2b2lkIGt2bV9hcmNoX3N5bmNfZXZlbnRzKHN0cnVjdCBrdm0gKmt2bSkg e30KPiAgc3RhdGljIGlubGluZSB2b2lkIGt2bV9hcmNoX3ZjcHVfdW5pbml0KHN0cnVjdCBrdm1f dmNwdSAqdmNwdSkge30KPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9rdm0vZnBzaW1kLmMgYi9h cmNoL2FybTY0L2t2bS9mcHNpbWQuYwo+IGluZGV4IDM2NTkzM2EuLmRjNmVjZmEgMTAwNjQ0Cj4g LS0tIGEvYXJjaC9hcm02NC9rdm0vZnBzaW1kLmMKPiArKysgYi9hcmNoL2FybTY0L2t2bS9mcHNp bWQuYwo+IEBAIC01OSw3ICs1OSw2IEBAIGludCBrdm1fYXJjaF92Y3B1X3J1bl9tYXBfZnAoc3Ry dWN0IGt2bV92Y3B1ICp2Y3B1KQo+ICAgKi8KPiAgdm9pZCBrdm1fYXJjaF92Y3B1X2xvYWRfZnAo c3RydWN0IGt2bV92Y3B1ICp2Y3B1KQo+ICB7Cj4gLQlCVUdfT04oc3lzdGVtX3N1cHBvcnRzX3N2 ZSgpKTsKPiAgCUJVR19PTighY3VycmVudC0+bW0pOwo+Cj4gIAl2Y3B1LT5hcmNoLmZsYWdzICY9 IH4oS1ZNX0FSTTY0X0ZQX0VOQUJMRUQgfCBLVk1fQVJNNjRfSE9TVF9TVkVfSU5fVVNFKTsKPiBk aWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9rdm0vaHlwL3N3aXRjaC5jIGIvYXJjaC9hcm02NC9rdm0v aHlwL3N3aXRjaC5jCj4gaW5kZXggMTE4ZjMwMC4uYTZhOGM3ZCAxMDA2NDQKPiAtLS0gYS9hcmNo L2FybTY0L2t2bS9oeXAvc3dpdGNoLmMKPiArKysgYi9hcmNoL2FybTY0L2t2bS9oeXAvc3dpdGNo LmMKPiBAQCAtMjEsNiArMjEsNyBAQAo+Cj4gICNpbmNsdWRlIDxrdm0vYXJtX3BzY2kuaD4KPgo+ ICsjaW5jbHVkZSA8YXNtL2NwdWZlYXR1cmUuaD4KPiAgI2luY2x1ZGUgPGFzbS9rdm1fYXNtLmg+ Cj4gICNpbmNsdWRlIDxhc20va3ZtX2VtdWxhdGUuaD4KPiAgI2luY2x1ZGUgPGFzbS9rdm1faG9z dC5oPgo+IEBAIC0yOCw2ICsyOSw3IEBACj4gICNpbmNsdWRlIDxhc20va3ZtX21tdS5oPgo+ICAj aW5jbHVkZSA8YXNtL2Zwc2ltZC5oPgo+ICAjaW5jbHVkZSA8YXNtL2RlYnVnLW1vbml0b3JzLmg+ Cj4gKyNpbmNsdWRlIDxhc20vcHJvY2Vzc29yLmg+Cj4gICNpbmNsdWRlIDxhc20vdGhyZWFkX2lu Zm8uaD4KPgo+ICAvKiBDaGVjayB3aGV0aGVyIHRoZSBGUCByZWdzIHdlcmUgZGlydGllZCB3aGls ZSBpbiB0aGUgaG9zdC1zaWRlIHJ1biBsb29wOiAqLwo+IEBAIC0zMjksNiArMzMxLDggQEAgc3Rh dGljIGJvb2wgX19oeXBfdGV4dCBfX3NraXBfaW5zdHIoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQo+ ICB2b2lkIF9faHlwX3RleHQgX19oeXBfc3dpdGNoX2Zwc2ltZCh1NjQgZXNyIF9fYWx3YXlzX3Vu dXNlZCwKPiAgCQkJCSAgICBzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCj4gIHsKPiArCXN0cnVjdCB1 c2VyX2Zwc2ltZF9zdGF0ZSAqaG9zdF9mcHNpbWQgPSB2Y3B1LT5hcmNoLmhvc3RfZnBzaW1kX3N0 YXRlOwo+ICsKPiAgCWlmIChoYXNfdmhlKCkpCj4gIAkJd3JpdGVfc3lzcmVnKHJlYWRfc3lzcmVn KGNwYWNyX2VsMSkgfCBDUEFDUl9FTDFfRlBFTiwKPiAgCQkJICAgICBjcGFjcl9lbDEpOwo+IEBA IC0zMzksNyArMzQzLDIxIEBAIHZvaWQgX19oeXBfdGV4dCBfX2h5cF9zd2l0Y2hfZnBzaW1kKHU2 NCBlc3IgX19hbHdheXNfdW51c2VkLAo+ICAJaXNiKCk7Cj4KPiAgCWlmICh2Y3B1LT5hcmNoLmZs YWdzICYgS1ZNX0FSTTY0X0ZQX0hPU1QpIHsKPiAtCQlfX2Zwc2ltZF9zYXZlX3N0YXRlKHZjcHUt PmFyY2guaG9zdF9mcHNpbWRfc3RhdGUpOwo+ICsJCS8qCj4gKwkJICogSW4gdGhlIFNWRSBjYXNl LCBWSEUgaXMgYXNzdW1lZDogaXQgaXMgZW5mb3JjZWQgYnkKPiArCQkgKiBLY29uZmlnIGFuZCBr dm1fYXJjaF9pbml0KCkuCj4gKwkJICovCj4gKwkJaWYgKHN5c3RlbV9zdXBwb3J0c19zdmUoKSAm Jgo+ICsJCSAgICAodmNwdS0+YXJjaC5mbGFncyAmIEtWTV9BUk02NF9IT1NUX1NWRV9JTl9VU0Up KSB7Cj4gKwkJCXN0cnVjdCB0aHJlYWRfc3RydWN0ICp0aHJlYWQgPSBjb250YWluZXJfb2YoCj4g KwkJCQlob3N0X2Zwc2ltZCwKPiArCQkJCXN0cnVjdCB0aHJlYWRfc3RydWN0LCB1dy5mcHNpbWRf c3RhdGUpOwo+ICsKPiArCQkJc3ZlX3NhdmVfc3RhdGUoc3ZlX3BmZnIodGhyZWFkKSwgJmhvc3Rf ZnBzaW1kLT5mcHNyKTsKPiArCQl9IGVsc2Ugewo+ICsJCQlfX2Zwc2ltZF9zYXZlX3N0YXRlKGhv c3RfZnBzaW1kKTsKPiArCQl9Cj4gKwo+ICAJCXZjcHUtPmFyY2guZmxhZ3MgJj0gfktWTV9BUk02 NF9GUF9IT1NUOwo+ICAJfQo+Cj4gZGlmZiAtLWdpdCBhL3ZpcnQva3ZtL2FybS9hcm0uYyBiL3Zp cnQva3ZtL2FybS9hcm0uYwo+IGluZGV4IGJlZTIyNmMuLmNlN2M2ZjMgMTAwNjQ0Cj4gLS0tIGEv dmlydC9rdm0vYXJtL2FybS5jCj4gKysrIGIvdmlydC9rdm0vYXJtL2FybS5jCj4gQEAgLTE2LDYg KzE2LDcgQEAKPiAgICogRm91bmRhdGlvbiwgNTEgRnJhbmtsaW4gU3RyZWV0LCBGaWZ0aCBGbG9v ciwgQm9zdG9uLCBNQSAgMDIxMTAtMTMwMSwgVVNBLgo+ICAgKi8KPgo+ICsjaW5jbHVkZSA8bGlu dXgvYnVnLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9jcHVfcG0uaD4KPiAgI2luY2x1ZGUgPGxpbnV4 L2Vycm5vLmg+Cj4gICNpbmNsdWRlIDxsaW51eC9lcnIuaD4KPiBAQCAtNDEsNiArNDIsNyBAQAo+ ICAjaW5jbHVkZSA8YXNtL21tYW4uaD4KPiAgI2luY2x1ZGUgPGFzbS90bGJmbHVzaC5oPgo+ICAj aW5jbHVkZSA8YXNtL2NhY2hlZmx1c2guaD4KPiArI2luY2x1ZGUgPGFzbS9jcHVmZWF0dXJlLmg+ Cj4gICNpbmNsdWRlIDxhc20vdmlydC5oPgo+ICAjaW5jbHVkZSA8YXNtL2t2bV9hcm0uaD4KPiAg I2luY2x1ZGUgPGFzbS9rdm1fYXNtLmg+Cj4gQEAgLTE1NzQsNiArMTU3NiwxMSBAQCBpbnQga3Zt X2FyY2hfaW5pdCh2b2lkICpvcGFxdWUpCj4gIAkJcmV0dXJuIC1FTk9ERVY7Cj4gIAl9Cj4KPiAr CWlmICgha3ZtX2FyY2hfY2hlY2tfc3ZlX2hhc192aGUoKSkgewo+ICsJCWt2bV9wcl91bmltcGwo IlNWRSBzeXN0ZW0gd2l0aG91dCBWSEUgdW5zdXBwb3J0ZWQuICBCcm9rZW4gY3B1PyIpOwo+ICsJ CXJldHVybiAtRU5PREVWOwo+ICsJfQo+ICsKCkFoaCB0aGlzIGlzIGdvaW5nIHRvIGJlIGEgcGFp biB3aGVuIHBlb3BsZSB3YW50IHRvIGVuYWJsZSBzeXN0ZW0KZW11bGF0aW9uIGZvciBTVkUgaW4g UUVNVSBnaXZlbiBvdXIgcGF0Y2h5IGZlYXR1cmUgaW1wbGVtZW50YXRpb24gKGkuZS4Kd2UgaGF2 ZW4ndCBkb25lIFZIRSB5ZXQpLiBIb3dldmVyIHRoYXQncyB0b3RhbGx5IG91ciBwcm9ibGVtIG5v dCB5b3Vycwo7LSkKClJldmlld2VkLWJ5OiBBbGV4IEJlbm7DqWUgPGFsZXguYmVubmVlQGxpbmFy by5vcmc+CgoKPiAgCWZvcl9lYWNoX29ubGluZV9jcHUoY3B1KSB7Cj4gIAkJc21wX2NhbGxfZnVu Y3Rpb25fc2luZ2xlKGNwdSwgY2hlY2tfa3ZtX3RhcmdldF9jcHUsICZyZXQsIDEpOwo+ICAJCWlm IChyZXQgPCAwKSB7CgoKLS0KQWxleCBCZW5uw6llCgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwpsaW51eC1hcm0ta2VybmVsIG1haWxpbmcgbGlzdApsaW51 eC1hcm0ta2VybmVsQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5v cmcvbWFpbG1hbi9saXN0aW5mby9saW51eC1hcm0ta2VybmVsCg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: alex.bennee@linaro.org (Alex =?utf-8?Q?Benn=C3=A9e?=) Date: Thu, 24 May 2018 15:49:51 +0100 Subject: [PATCH v10 14/18] KVM: arm64: Save host SVE context as appropriate In-Reply-To: <1527005119-6842-15-git-send-email-Dave.Martin@arm.com> References: <1527005119-6842-1-git-send-email-Dave.Martin@arm.com> <1527005119-6842-15-git-send-email-Dave.Martin@arm.com> Message-ID: <871se1t8fk.fsf@linaro.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Dave Martin writes: > This patch adds SVE context saving to the hyp FPSIMD context switch > path. This means that it is no longer necessary to save the host > SVE state in advance of entering the guest, when in use. > > In order to avoid adding pointless complexity to the code, VHE is > assumed if SVE is in use. VHE is an architectural prerequisite for > SVE, so there is no good reason to turn CONFIG_ARM64_VHE off in > kernels that support both SVE and KVM. > > Historically, software models exist that can expose the > architecturally invalid configuration of SVE without VHE, so if > this situation is detected at kvm_init() time then KVM will be > disabled. > > Signed-off-by: Dave Martin > > --- > > * Tags stripped since v8, please reconfirm if possible: > > Formerly-Reviewed-by: Christoffer Dall > Formerly-Acked-by: Marc Zyngier > Formerly-Acked-by: Catalin Marinas > > Changes since v9: > > Requested by Marc Zyngier: > > * Inline check for VHE if SVE is present into kvm_host.h. > > The check has been renamed to the more specific > kvm_arch_check_sve_has_vhe(), and the kvm_pr_unimpl() moved back to > arm.c (to avoid circular include issues). > > arm.c is not single-arch code, but it is all Arm-specific, so > adding a hook like this doesn't seem too unreasonable. > > Changes since v8: > > * Add kvm_arch_check_supported() hook, and move arm64-specific check > for SVE-implies-VHE into arch/arm64/. > > Due to circular header dependency problems, it is difficult to get > the prototype for kvm_pr_*() functions in , so this > patch puts arm64's kvm_arch_check_supported() hook out of line. > This is not a hot function. > --- > arch/arm/include/asm/kvm_host.h | 1 + > arch/arm64/Kconfig | 7 +++++++ > arch/arm64/include/asm/kvm_host.h | 13 +++++++++++++ > arch/arm64/kvm/fpsimd.c | 1 - > arch/arm64/kvm/hyp/switch.c | 20 +++++++++++++++++++- > virt/kvm/arm/arm.c | 7 +++++++ > 6 files changed, 47 insertions(+), 2 deletions(-) > > diff --git a/arch/arm/include/asm/kvm_host.h b/arch/arm/include/asm/kvm_host.h > index ac870b2..3b85bbb 100644 > --- a/arch/arm/include/asm/kvm_host.h > +++ b/arch/arm/include/asm/kvm_host.h > @@ -280,6 +280,7 @@ void kvm_mmu_wp_memory_region(struct kvm *kvm, int slot); > > struct kvm_vcpu *kvm_mpidr_to_vcpu(struct kvm *kvm, unsigned long mpidr); > > +static inline bool kvm_arch_check_sve_has_vhe(void) { return true; } > static inline void kvm_arch_hardware_unsetup(void) {} > static inline void kvm_arch_sync_events(struct kvm *kvm) {} > static inline void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) {} > diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig > index eb2cf49..b0d3820 100644 > --- a/arch/arm64/Kconfig > +++ b/arch/arm64/Kconfig > @@ -1130,6 +1130,7 @@ endmenu > config ARM64_SVE > bool "ARM Scalable Vector Extension support" > default y > + depends on !KVM || ARM64_VHE > help > The Scalable Vector Extension (SVE) is an extension to the AArch64 > execution state which complements and extends the SIMD functionality > @@ -1155,6 +1156,12 @@ config ARM64_SVE > booting the kernel. If unsure and you are not observing these > symptoms, you should assume that it is safe to say Y. > > + CPUs that support SVE are architecturally required to support the > + Virtualization Host Extensions (VHE), so the kernel makes no > + provision for supporting SVE alongside KVM without VHE enabled. > + Thus, you will need to enable CONFIG_ARM64_VHE if you want to support > + KVM in the same kernel image. > + > config ARM64_MODULE_PLTS > bool > select HAVE_MOD_ARCH_SPECIFIC > diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h > index b3fe730..06d5a61 100644 > --- a/arch/arm64/include/asm/kvm_host.h > +++ b/arch/arm64/include/asm/kvm_host.h > @@ -405,6 +405,19 @@ static inline void __cpu_init_hyp_mode(phys_addr_t pgd_ptr, > kvm_call_hyp(__kvm_set_tpidr_el2, tpidr_el2); > } > > +static inline bool kvm_arch_check_sve_has_vhe(void) > +{ > + /* > + * The Arm architecture specifies that imlpementation of SVE > + * requires VHE also to be implemented. The KVM code for arm64 > + * relies on this when SVE is present: > + */ > + if (system_supports_sve()) > + return has_vhe(); > + else > + return true; > +} > + > static inline void kvm_arch_hardware_unsetup(void) {} > static inline void kvm_arch_sync_events(struct kvm *kvm) {} > static inline void kvm_arch_vcpu_uninit(struct kvm_vcpu *vcpu) {} > diff --git a/arch/arm64/kvm/fpsimd.c b/arch/arm64/kvm/fpsimd.c > index 365933a..dc6ecfa 100644 > --- a/arch/arm64/kvm/fpsimd.c > +++ b/arch/arm64/kvm/fpsimd.c > @@ -59,7 +59,6 @@ int kvm_arch_vcpu_run_map_fp(struct kvm_vcpu *vcpu) > */ > void kvm_arch_vcpu_load_fp(struct kvm_vcpu *vcpu) > { > - BUG_ON(system_supports_sve()); > BUG_ON(!current->mm); > > vcpu->arch.flags &= ~(KVM_ARM64_FP_ENABLED | KVM_ARM64_HOST_SVE_IN_USE); > diff --git a/arch/arm64/kvm/hyp/switch.c b/arch/arm64/kvm/hyp/switch.c > index 118f300..a6a8c7d 100644 > --- a/arch/arm64/kvm/hyp/switch.c > +++ b/arch/arm64/kvm/hyp/switch.c > @@ -21,6 +21,7 @@ > > #include > > +#include > #include > #include > #include > @@ -28,6 +29,7 @@ > #include > #include > #include > +#include > #include > > /* Check whether the FP regs were dirtied while in the host-side run loop: */ > @@ -329,6 +331,8 @@ static bool __hyp_text __skip_instr(struct kvm_vcpu *vcpu) > void __hyp_text __hyp_switch_fpsimd(u64 esr __always_unused, > struct kvm_vcpu *vcpu) > { > + struct user_fpsimd_state *host_fpsimd = vcpu->arch.host_fpsimd_state; > + > if (has_vhe()) > write_sysreg(read_sysreg(cpacr_el1) | CPACR_EL1_FPEN, > cpacr_el1); > @@ -339,7 +343,21 @@ void __hyp_text __hyp_switch_fpsimd(u64 esr __always_unused, > isb(); > > if (vcpu->arch.flags & KVM_ARM64_FP_HOST) { > - __fpsimd_save_state(vcpu->arch.host_fpsimd_state); > + /* > + * In the SVE case, VHE is assumed: it is enforced by > + * Kconfig and kvm_arch_init(). > + */ > + if (system_supports_sve() && > + (vcpu->arch.flags & KVM_ARM64_HOST_SVE_IN_USE)) { > + struct thread_struct *thread = container_of( > + host_fpsimd, > + struct thread_struct, uw.fpsimd_state); > + > + sve_save_state(sve_pffr(thread), &host_fpsimd->fpsr); > + } else { > + __fpsimd_save_state(host_fpsimd); > + } > + > vcpu->arch.flags &= ~KVM_ARM64_FP_HOST; > } > > diff --git a/virt/kvm/arm/arm.c b/virt/kvm/arm/arm.c > index bee226c..ce7c6f3 100644 > --- a/virt/kvm/arm/arm.c > +++ b/virt/kvm/arm/arm.c > @@ -16,6 +16,7 @@ > * Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. > */ > > +#include > #include > #include > #include > @@ -41,6 +42,7 @@ > #include > #include > #include > +#include > #include > #include > #include > @@ -1574,6 +1576,11 @@ int kvm_arch_init(void *opaque) > return -ENODEV; > } > > + if (!kvm_arch_check_sve_has_vhe()) { > + kvm_pr_unimpl("SVE system without VHE unsupported. Broken cpu?"); > + return -ENODEV; > + } > + Ahh this is going to be a pain when people want to enable system emulation for SVE in QEMU given our patchy feature implementation (i.e. we haven't done VHE yet). However that's totally our problem not yours ;-) Reviewed-by: Alex Benn?e > for_each_online_cpu(cpu) { > smp_call_function_single(cpu, check_kvm_target_cpu, &ret, 1); > if (ret < 0) { -- Alex Benn?e