From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dave Martin Subject: [PATCH v5 24/30] arm64/sve: KVM: Prevent guests from using SVE Date: Tue, 31 Oct 2017 15:51:16 +0000 Message-ID: <1509465082-30427-25-git-send-email-Dave.Martin@arm.com> References: <1509465082-30427-1-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: <1509465082-30427-1-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: linux-arm-kernel@lists.infradead.org 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 List-Id: linux-arch.vger.kernel.org VW50aWwgS1ZNIGhhcyBmdWxsIFNWRSBzdXBwb3J0LCBndWVzdHMgbXVzdCBub3QgYmUgYWxsb3dl ZCB0bwpleGVjdXRlIFNWRSBpbnN0cnVjdGlvbnMuCgpUaGlzIHBhdGNoIGVuYWJsZXMgdGhlIG5l Y2Vzc2FyeSB0cmFwcywgYW5kIGFsc28gZW5zdXJlcyB0aGF0IHRoZQp0cmFwcyBhcmUgZGlzYWJs ZWQgYWdhaW4gb24gZXhpdCBmcm9tIHRoZSBndWVzdCBzbyB0aGF0IHRoZSBob3N0CmNhbiBzdGls bCB1c2UgU1ZFIGlmIGl0IHdhbnRzIHRvLgoKT24gZ3Vlc3QgZXhpdCwgaGlnaCBiaXRzIG9mIHRo ZSBTVkUgWm4gcmVnaXN0ZXJzIG1heSBoYXZlIGJlZW4KY2xvYmJlcmVkIGFzIGEgc2lkZS1lZmZl Y3QgdGhlIGV4ZWN1dGlvbiBvZiBGUFNJTUQgaW5zdHJ1Y3Rpb25zIGluCnRoZSBndWVzdC4gIFRo ZSBleGlzdGluZyBLVk0gaG9zdCBGUFNJTUQgcmVzdG9yZSBjb2RlIGlzIG5vdApzdWZmaWNpZW50 IHRvIHJlc3RvcmUgdGhlc2UgYml0cywgc28gdGhpcyBwYXRjaCBleHBsaWNpdGx5IG1hcmtzCnRo ZSBDUFUgYXMgbm90IGNvbnRhaW5pbmcgY2FjaGVkIHZlY3RvciBzdGF0ZSBmb3IgYW55IHRhc2ss IHRodXMKZm9yY2luZyBhIHJlbG9hZCBvbiB0aGUgbmV4dCByZXR1cm4gdG8gdXNlcnNwYWNlLiAg VGhpcyBpcyBhbgppbnRlcmltIG1lYXN1cmUsIGluIGFkdmFuY2Ugb2YgYWRkaW5nIGZ1bGwgU1ZF IGF3YXJlbmVzcyB0byBLVk0uCgpUaGlzIG1hcmtpbmcgb2YgY2FjaGVkIHZlY3RvciBzdGF0ZSBp biB0aGUgQ1BVIGFzIGludmFsaWQgaXMgZG9uZQp1c2luZyBfX3RoaXNfY3B1X3dyaXRlKGZwc2lt ZF9sYXN0X3N0YXRlLCBOVUxMKSBpbiBmcHNpbWQuYy4gIER1ZQp0byB0aGUgcmVwZWF0ZWQgdXNl IG9mIHRoaXMgcmF0aGVyIG9ic2N1cmUgb3BlcmF0aW9uLCBpdCBtYWtlcwpzZW5zZSB0byBmYWN0 b3IgaXQgb3V0IGFzIGEgc2VwYXJhdGUgaGVscGVyIHdpdGggYSBjbGVhcmVyIG5hbWUuClRoaXMg cGF0Y2ggZmFjdG9ycyBpdCBvdXQgYXMgZnBzaW1kX2ZsdXNoX2NwdV9zdGF0ZSgpLCBhbmQgcG9y dHMKYWxsIGNhbGxlcnMgdG8gdXNlIGl0LgoKQXMgYSBzaWRlIGVmZmVjdCBvZiB0aGlzIHJlZmFj dG9yaW5nLCBhIHRoaXNfY3B1X3dyaXRlKCkgaW4KZnBzaW1kX2NwdV9wbV9ub3RpZmllcigpIGlz IGNoYW5nZWQgdG8gX190aGlzX2NwdV93cml0ZSgpLiAgVGhpcwpzaG91bGQgYmUgZmluZSwgc2lu Y2UgY3B1X3BtX2VudGVyKCkgaXMgc3VwcG9zZWQgdG8gYmUgY2FsbGVkIG9ubHkKd2l0aCBpbnRl cnJ1cHRzIGRpc2FibGVkLgoKU2lnbmVkLW9mZi1ieTogRGF2ZSBNYXJ0aW4gPERhdmUuTWFydGlu QGFybS5jb20+ClJldmlld2VkLWJ5OiBBbGV4IEJlbm7DqWUgPGFsZXguYmVubmVlQGxpbmFyby5v cmc+ClJldmlld2VkLWJ5OiBDaHJpc3RvZmZlciBEYWxsIDxjaHJpc3RvZmZlci5kYWxsQGxpbmFy by5vcmc+CkFja2VkLWJ5OiBDYXRhbGluIE1hcmluYXMgPGNhdGFsaW4ubWFyaW5hc0Bhcm0uY29t PgpBY2tlZC1ieTogTWFyYyBaeW5naWVyIDxtYXJjLnp5bmdpZXJAYXJtLmNvbT4KQ2M6IEFyZCBC aWVzaGV1dmVsIDxhcmQuYmllc2hldXZlbEBsaW5hcm8ub3JnPgotLS0KIGFyY2gvYXJtL2luY2x1 ZGUvYXNtL2t2bV9ob3N0LmggICB8ICAzICsrKwogYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9mcHNp bWQuaCAgIHwgIDEgKwogYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1fYXJtLmggIHwgIDQgKysr LQogYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1faG9zdC5oIHwgMTEgKysrKysrKysrKysKIGFy Y2gvYXJtNjQva2VybmVsL2Zwc2ltZC5jICAgICAgICB8IDMxICsrKysrKysrKysrKysrKysrKysr KysrKysrKysrLS0KIGFyY2gvYXJtNjQva3ZtL2h5cC9zd2l0Y2guYyAgICAgICB8ICA2ICsrKy0t LQogdmlydC9rdm0vYXJtL2FybS5jICAgICAgICAgICAgICAgIHwgIDMgKysrCiA3IGZpbGVzIGNo YW5nZWQsIDUzIGluc2VydGlvbnMoKyksIDYgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvYXJj aC9hcm0vaW5jbHVkZS9hc20va3ZtX2hvc3QuaCBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2t2bV9o b3N0LmgKaW5kZXggNGE4NzlmNi4uMjQyMTUxZSAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vaW5jbHVk ZS9hc20va3ZtX2hvc3QuaAorKysgYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9rdm1faG9zdC5oCkBA IC0yOTMsNCArMjkzLDcgQEAgaW50IGt2bV9hcm1fdmNwdV9hcmNoX2dldF9hdHRyKHN0cnVjdCBr dm1fdmNwdSAqdmNwdSwKIGludCBrdm1fYXJtX3ZjcHVfYXJjaF9oYXNfYXR0cihzdHJ1Y3Qga3Zt X3ZjcHUgKnZjcHUsCiAJCQkgICAgICAgc3RydWN0IGt2bV9kZXZpY2VfYXR0ciAqYXR0cik7CiAK Ky8qIEFsbCBob3N0IEZQL1NJTUQgc3RhdGUgaXMgcmVzdG9yZWQgb24gZ3Vlc3QgZXhpdCwgc28g bm90aGluZyB0byBzYXZlOiAqLworc3RhdGljIGlubGluZSB2b2lkIGt2bV9mcHNpbWRfZmx1c2hf Y3B1X3N0YXRlKHZvaWQpIHt9CisKICNlbmRpZiAvKiBfX0FSTV9LVk1fSE9TVF9IX18gKi8KZGlm ZiAtLWdpdCBhL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20vZnBzaW1kLmggYi9hcmNoL2FybTY0L2lu Y2x1ZGUvYXNtL2Zwc2ltZC5oCmluZGV4IGI4Njg0MTIuLjc0ZjM0MzkgMTAwNjQ0Ci0tLSBhL2Fy Y2gvYXJtNjQvaW5jbHVkZS9hc20vZnBzaW1kLmgKKysrIGIvYXJjaC9hcm02NC9pbmNsdWRlL2Fz bS9mcHNpbWQuaApAQCAtNzQsNiArNzQsNyBAQCBleHRlcm4gdm9pZCBmcHNpbWRfcmVzdG9yZV9j dXJyZW50X3N0YXRlKHZvaWQpOwogZXh0ZXJuIHZvaWQgZnBzaW1kX3VwZGF0ZV9jdXJyZW50X3N0 YXRlKHN0cnVjdCBmcHNpbWRfc3RhdGUgKnN0YXRlKTsKIAogZXh0ZXJuIHZvaWQgZnBzaW1kX2Zs dXNoX3Rhc2tfc3RhdGUoc3RydWN0IHRhc2tfc3RydWN0ICp0YXJnZXQpOworZXh0ZXJuIHZvaWQg c3ZlX2ZsdXNoX2NwdV9zdGF0ZSh2b2lkKTsKIAogLyogTWF4aW11bSBWTCB0aGF0IFNWRSBWTC1h Z25vc3RpYyBzb2Z0d2FyZSBjYW4gdHJhbnNwYXJlbnRseSBzdXBwb3J0ICovCiAjZGVmaW5lIFNW RV9WTF9BUkNIX01BWCAweDEwMApkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9r dm1fYXJtLmggYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9hcm0uaAppbmRleCBkYmYwNTM3 Li43ZjA2OWZmIDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9hcm0uaAor KysgYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9hcm0uaApAQCAtMTg2LDcgKzE4Niw4IEBA CiAjZGVmaW5lIENQVFJfRUwyX1RUQQkoMSA8PCAyMCkKICNkZWZpbmUgQ1BUUl9FTDJfVEZQCSgx IDw8IENQVFJfRUwyX1RGUF9TSElGVCkKICNkZWZpbmUgQ1BUUl9FTDJfVFoJKDEgPDwgOCkKLSNk ZWZpbmUgQ1BUUl9FTDJfREVGQVVMVAkweDAwMDAzM2ZmCisjZGVmaW5lIENQVFJfRUwyX1JFUzEJ MHgwMDAwMzJmZiAvKiBrbm93biBSRVMxIGJpdHMgaW4gQ1BUUl9FTDIgKi8KKyNkZWZpbmUgQ1BU Ul9FTDJfREVGQVVMVAlDUFRSX0VMMl9SRVMxCiAKIC8qIEh5cCBEZWJ1ZyBDb25maWd1cmF0aW9u IFJlZ2lzdGVyIGJpdHMgKi8KICNkZWZpbmUgTURDUl9FTDJfVFBNUwkJKDEgPDwgMTQpCkBAIC0y MzcsNSArMjM4LDYgQEAKIAogI2RlZmluZSBDUEFDUl9FTDFfRlBFTgkJKDMgPDwgMjApCiAjZGVm aW5lIENQQUNSX0VMMV9UVEEJCSgxIDw8IDI4KQorI2RlZmluZSBDUEFDUl9FTDFfREVGQVVMVAko Q1BBQ1JfRUwxX0ZQRU4gfCBDUEFDUl9FTDFfWkVOX0VMMUVOKQogCiAjZW5kaWYgLyogX19BUk02 NF9LVk1fQVJNX0hfXyAqLwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1f aG9zdC5oIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1faG9zdC5oCmluZGV4IGU5MjNiNTgu LjY3NDkxMmQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX2hvc3QuaAor KysgYi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKQEAgLTI1LDYgKzI1LDcgQEAK ICNpbmNsdWRlIDxsaW51eC90eXBlcy5oPgogI2luY2x1ZGUgPGxpbnV4L2t2bV90eXBlcy5oPgog I2luY2x1ZGUgPGFzbS9jcHVmZWF0dXJlLmg+CisjaW5jbHVkZSA8YXNtL2Zwc2ltZC5oPgogI2lu Y2x1ZGUgPGFzbS9rdm0uaD4KICNpbmNsdWRlIDxhc20va3ZtX2FzbS5oPgogI2luY2x1ZGUgPGFz bS9rdm1fbW1pby5oPgpAQCAtMzg0LDQgKzM4NSwxNCBAQCBzdGF0aWMgaW5saW5lIHZvaWQgX19j cHVfaW5pdF9zdGFnZTIodm9pZCkKIAkJICAiUEFSYW5nZSBpcyAlZCBiaXRzLCB1bnN1cHBvcnRl ZCBjb25maWd1cmF0aW9uISIsIHBhcmFuZ2UpOwogfQogCisvKgorICogQWxsIGhvc3QgRlAvU0lN RCBzdGF0ZSBpcyByZXN0b3JlZCBvbiBndWVzdCBleGl0LCBzbyBub3RoaW5nIG5lZWRzCisgKiBk b2luZyBoZXJlIGV4Y2VwdCBpbiB0aGUgU1ZFIGNhc2U6CisqLworc3RhdGljIGlubGluZSB2b2lk IGt2bV9mcHNpbWRfZmx1c2hfY3B1X3N0YXRlKHZvaWQpCit7CisJaWYgKHN5c3RlbV9zdXBwb3J0 c19zdmUoKSkKKwkJc3ZlX2ZsdXNoX2NwdV9zdGF0ZSgpOworfQorCiAjZW5kaWYgLyogX19BUk02 NF9LVk1fSE9TVF9IX18gKi8KZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQva2VybmVsL2Zwc2ltZC5j IGIvYXJjaC9hcm02NC9rZXJuZWwvZnBzaW1kLmMKaW5kZXggNGRhNjRmYy4uNDJmYzczMSAxMDA2 NDQKLS0tIGEvYXJjaC9hcm02NC9rZXJuZWwvZnBzaW1kLmMKKysrIGIvYXJjaC9hcm02NC9rZXJu ZWwvZnBzaW1kLmMKQEAgLTEwNDksNiArMTA0OSwzMyBAQCB2b2lkIGZwc2ltZF9mbHVzaF90YXNr X3N0YXRlKHN0cnVjdCB0YXNrX3N0cnVjdCAqdCkKIAl0LT50aHJlYWQuZnBzaW1kX3N0YXRlLmNw dSA9IE5SX0NQVVM7CiB9CiAKK3N0YXRpYyBpbmxpbmUgdm9pZCBmcHNpbWRfZmx1c2hfY3B1X3N0 YXRlKHZvaWQpCit7CisJX190aGlzX2NwdV93cml0ZShmcHNpbWRfbGFzdF9zdGF0ZSwgTlVMTCk7 Cit9CisKKy8qCisgKiBJbnZhbGlkYXRlIGFueSB0YXNrIFNWRSBzdGF0ZSBjdXJyZW50bHkgaGVs ZCBpbiB0aGlzIENQVSdzIHJlZ3MuCisgKgorICogVGhpcyBpcyB1c2VkIHRvIHByZXZlbnQgdGhl IGtlcm5lbCBmcm9tIHRyeWluZyB0byByZXVzZSBTVkUgcmVnaXN0ZXIgZGF0YQorICogdGhhdCBp cyBkZXRyb3llZCBieSBLVk0gZ3Vlc3QgZW50ZXIvZXhpdC4gIFRoaXMgZnVuY3Rpb24gc2hvdWxk IGdvIGF3YXkgd2hlbgorICogS1ZNIFNWRSBzdXBwb3J0IGlzIGltcGxlbWVudGVkLiAgRG9uJ3Qg dXNlIGl0IGZvciBhbnl0aGluZyBlbHNlLgorICovCisjaWZkZWYgQ09ORklHX0FSTTY0X1NWRQor dm9pZCBzdmVfZmx1c2hfY3B1X3N0YXRlKHZvaWQpCit7CisJc3RydWN0IGZwc2ltZF9zdGF0ZSAq Y29uc3QgZnBzdGF0ZSA9IF9fdGhpc19jcHVfcmVhZChmcHNpbWRfbGFzdF9zdGF0ZSk7CisJc3Ry dWN0IHRhc2tfc3RydWN0ICp0c2s7CisKKwlpZiAoIWZwc3RhdGUpCisJCXJldHVybjsKKworCXRz ayA9IGNvbnRhaW5lcl9vZihmcHN0YXRlLCBzdHJ1Y3QgdGFza19zdHJ1Y3QsIHRocmVhZC5mcHNp bWRfc3RhdGUpOworCWlmICh0ZXN0X3Rza190aHJlYWRfZmxhZyh0c2ssIFRJRl9TVkUpKQorCQlm cHNpbWRfZmx1c2hfY3B1X3N0YXRlKCk7Cit9CisjZW5kaWYgLyogQ09ORklHX0FSTTY0X1NWRSAq LworCiAjaWZkZWYgQ09ORklHX0tFUk5FTF9NT0RFX05FT04KIAogREVGSU5FX1BFUl9DUFUoYm9v bCwga2VybmVsX25lb25fYnVzeSk7CkBAIC0xMDg5LDcgKzExMTYsNyBAQCB2b2lkIGtlcm5lbF9u ZW9uX2JlZ2luKHZvaWQpCiAJfQogCiAJLyogSW52YWxpZGF0ZSBhbnkgdGFzayBzdGF0ZSByZW1h aW5pbmcgaW4gdGhlIGZwc2ltZCByZWdzOiAqLwotCV9fdGhpc19jcHVfd3JpdGUoZnBzaW1kX2xh c3Rfc3RhdGUsIE5VTEwpOworCWZwc2ltZF9mbHVzaF9jcHVfc3RhdGUoKTsKIAogCXByZWVtcHRf ZGlzYWJsZSgpOwogCkBAIC0xMjEwLDcgKzEyMzcsNyBAQCBzdGF0aWMgaW50IGZwc2ltZF9jcHVf cG1fbm90aWZpZXIoc3RydWN0IG5vdGlmaWVyX2Jsb2NrICpzZWxmLAogCWNhc2UgQ1BVX1BNX0VO VEVSOgogCQlpZiAoY3VycmVudC0+bW0pCiAJCQl0YXNrX2Zwc2ltZF9zYXZlKCk7Ci0JCXRoaXNf Y3B1X3dyaXRlKGZwc2ltZF9sYXN0X3N0YXRlLCBOVUxMKTsKKwkJZnBzaW1kX2ZsdXNoX2NwdV9z dGF0ZSgpOwogCQlicmVhazsKIAljYXNlIENQVV9QTV9FWElUOgogCQlpZiAoY3VycmVudC0+bW0p CmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2t2bS9oeXAvc3dpdGNoLmMgYi9hcmNoL2FybTY0L2t2 bS9oeXAvc3dpdGNoLmMKaW5kZXggMzVhOTBiOC4uOTUxZjNlYiAxMDA2NDQKLS0tIGEvYXJjaC9h cm02NC9rdm0vaHlwL3N3aXRjaC5jCisrKyBiL2FyY2gvYXJtNjQva3ZtL2h5cC9zd2l0Y2guYwpA QCAtNDgsNyArNDgsNyBAQCBzdGF0aWMgdm9pZCBfX2h5cF90ZXh0IF9fYWN0aXZhdGVfdHJhcHNf dmhlKHZvaWQpCiAKIAl2YWwgPSByZWFkX3N5c3JlZyhjcGFjcl9lbDEpOwogCXZhbCB8PSBDUEFD Ul9FTDFfVFRBOwotCXZhbCAmPSB+Q1BBQ1JfRUwxX0ZQRU47CisJdmFsICY9IH4oQ1BBQ1JfRUwx X0ZQRU4gfCBDUEFDUl9FTDFfWkVOKTsKIAl3cml0ZV9zeXNyZWcodmFsLCBjcGFjcl9lbDEpOwog CiAJd3JpdGVfc3lzcmVnKF9fa3ZtX2h5cF92ZWN0b3IsIHZiYXJfZWwxKTsKQEAgLTU5LDcgKzU5 LDcgQEAgc3RhdGljIHZvaWQgX19oeXBfdGV4dCBfX2FjdGl2YXRlX3RyYXBzX252aGUodm9pZCkK IAl1NjQgdmFsOwogCiAJdmFsID0gQ1BUUl9FTDJfREVGQVVMVDsKLQl2YWwgfD0gQ1BUUl9FTDJf VFRBIHwgQ1BUUl9FTDJfVEZQOworCXZhbCB8PSBDUFRSX0VMMl9UVEEgfCBDUFRSX0VMMl9URlAg fCBDUFRSX0VMMl9UWjsKIAl3cml0ZV9zeXNyZWcodmFsLCBjcHRyX2VsMik7CiB9CiAKQEAgLTEx Nyw3ICsxMTcsNyBAQCBzdGF0aWMgdm9pZCBfX2h5cF90ZXh0IF9fZGVhY3RpdmF0ZV90cmFwc192 aGUodm9pZCkKIAogCXdyaXRlX3N5c3JlZyhtZGNyX2VsMiwgbWRjcl9lbDIpOwogCXdyaXRlX3N5 c3JlZyhIQ1JfSE9TVF9WSEVfRkxBR1MsIGhjcl9lbDIpOwotCXdyaXRlX3N5c3JlZyhDUEFDUl9F TDFfRlBFTiwgY3BhY3JfZWwxKTsKKwl3cml0ZV9zeXNyZWcoQ1BBQ1JfRUwxX0RFRkFVTFQsIGNw YWNyX2VsMSk7CiAJd3JpdGVfc3lzcmVnKHZlY3RvcnMsIHZiYXJfZWwxKTsKIH0KIApkaWZmIC0t Z2l0IGEvdmlydC9rdm0vYXJtL2FybS5jIGIvdmlydC9rdm0vYXJtL2FybS5jCmluZGV4IGI5ZjY4 ZTQuLjRkM2NmOWMgMTAwNjQ0Ci0tLSBhL3ZpcnQva3ZtL2FybS9hcm0uYworKysgYi92aXJ0L2t2 bS9hcm0vYXJtLmMKQEAgLTY1Miw2ICs2NTIsOSBAQCBpbnQga3ZtX2FyY2hfdmNwdV9pb2N0bF9y dW4oc3RydWN0IGt2bV92Y3B1ICp2Y3B1LCBzdHJ1Y3Qga3ZtX3J1biAqcnVuKQogCQkgKi8KIAkJ cHJlZW1wdF9kaXNhYmxlKCk7CiAKKwkJLyogRmx1c2ggRlAvU0lNRCBzdGF0ZSB0aGF0IGNhbid0 IHN1cnZpdmUgZ3Vlc3QgZW50cnkvZXhpdCAqLworCQlrdm1fZnBzaW1kX2ZsdXNoX2NwdV9zdGF0 ZSgpOworCiAJCWt2bV9wbXVfZmx1c2hfaHdzdGF0ZSh2Y3B1KTsKIAogCQlrdm1fdGltZXJfZmx1 c2hfaHdzdGF0ZSh2Y3B1KTsKLS0gCjIuMS40CgpfX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fXwprdm1hcm0gbWFpbGluZyBsaXN0Cmt2bWFybUBsaXN0cy5jcy5j b2x1bWJpYS5lZHUKaHR0cHM6Ly9saXN0cy5jcy5jb2x1bWJpYS5lZHUvbWFpbG1hbi9saXN0aW5m by9rdm1hcm0K From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from foss.arm.com ([217.140.101.70]:37846 "EHLO foss.arm.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S932213AbdJaPwS (ORCPT ); Tue, 31 Oct 2017 11:52:18 -0400 From: Dave Martin Subject: [PATCH v5 24/30] arm64/sve: KVM: Prevent guests from using SVE Date: Tue, 31 Oct 2017 15:51:16 +0000 Message-ID: <1509465082-30427-25-git-send-email-Dave.Martin@arm.com> In-Reply-To: <1509465082-30427-1-git-send-email-Dave.Martin@arm.com> References: <1509465082-30427-1-git-send-email-Dave.Martin@arm.com> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Sender: linux-arch-owner@vger.kernel.org List-ID: To: linux-arm-kernel@lists.infradead.org Cc: Catalin Marinas , Will Deacon , Ard Biesheuvel , =?UTF-8?q?Alex=20Benn=C3=A9e?= , Szabolcs Nagy , Okamoto Takayuki , kvmarm@lists.cs.columbia.edu, libc-alpha@sourceware.org, linux-arch@vger.kernel.org Message-ID: <20171031155116.kdlAWtIadgaUw0-3ZGlC-eZx84tfs1TOY28IvFDbD4Y@z> Until KVM has full SVE support, guests must not be allowed to execute SVE instructions. This patch enables the necessary traps, and also ensures that the traps are disabled again on exit from the guest so that the host can still use SVE if it wants to. On guest exit, high bits of the SVE Zn registers may have been clobbered as a side-effect the execution of FPSIMD instructions in the guest. The existing KVM host FPSIMD restore code is not sufficient to restore these bits, so this patch explicitly marks the CPU as not containing cached vector state for any task, thus forcing a reload on the next return to userspace. This is an interim measure, in advance of adding full SVE awareness to KVM. This marking of cached vector state in the CPU as invalid is done using __this_cpu_write(fpsimd_last_state, NULL) in fpsimd.c. Due to the repeated use of this rather obscure operation, it makes sense to factor it out as a separate helper with a clearer name. This patch factors it out as fpsimd_flush_cpu_state(), and ports all callers to use it. As a side effect of this refactoring, a this_cpu_write() in fpsimd_cpu_pm_notifier() is changed to __this_cpu_write(). This should be fine, since cpu_pm_enter() is supposed to be called only with interrupts disabled. Signed-off-by: Dave Martin Reviewed-by: Alex Bennée Reviewed-by: Christoffer Dall Acked-by: Catalin Marinas Acked-by: Marc Zyngier Cc: Ard Biesheuvel --- arch/arm/include/asm/kvm_host.h | 3 +++ arch/arm64/include/asm/fpsimd.h | 1 + arch/arm64/include/asm/kvm_arm.h | 4 +++- arch/arm64/include/asm/kvm_host.h | 11 +++++++++++ arch/arm64/kernel/fpsimd.c | 31 +++++++++++++++++++++++++++++-- arch/arm64/kvm/hyp/switch.c | 6 +++--- virt/kvm/arm/arm.c | 3 +++ 7 files changed, 53 insertions(+), 6 deletions(-) diff --git a/arch/arm/include/asm/kvm_host.h b/arch/arm/include/asm/kvm_host.h index 4a879f6..242151e 100644 --- a/arch/arm/include/asm/kvm_host.h +++ b/arch/arm/include/asm/kvm_host.h @@ -293,4 +293,7 @@ int kvm_arm_vcpu_arch_get_attr(struct kvm_vcpu *vcpu, int kvm_arm_vcpu_arch_has_attr(struct kvm_vcpu *vcpu, struct kvm_device_attr *attr); +/* All host FP/SIMD state is restored on guest exit, so nothing to save: */ +static inline void kvm_fpsimd_flush_cpu_state(void) {} + #endif /* __ARM_KVM_HOST_H__ */ diff --git a/arch/arm64/include/asm/fpsimd.h b/arch/arm64/include/asm/fpsimd.h index b868412..74f3439 100644 --- a/arch/arm64/include/asm/fpsimd.h +++ b/arch/arm64/include/asm/fpsimd.h @@ -74,6 +74,7 @@ extern void fpsimd_restore_current_state(void); extern void fpsimd_update_current_state(struct fpsimd_state *state); extern void fpsimd_flush_task_state(struct task_struct *target); +extern void sve_flush_cpu_state(void); /* Maximum VL that SVE VL-agnostic software can transparently support */ #define SVE_VL_ARCH_MAX 0x100 diff --git a/arch/arm64/include/asm/kvm_arm.h b/arch/arm64/include/asm/kvm_arm.h index dbf0537..7f069ff 100644 --- a/arch/arm64/include/asm/kvm_arm.h +++ b/arch/arm64/include/asm/kvm_arm.h @@ -186,7 +186,8 @@ #define CPTR_EL2_TTA (1 << 20) #define CPTR_EL2_TFP (1 << CPTR_EL2_TFP_SHIFT) #define CPTR_EL2_TZ (1 << 8) -#define CPTR_EL2_DEFAULT 0x000033ff +#define CPTR_EL2_RES1 0x000032ff /* known RES1 bits in CPTR_EL2 */ +#define CPTR_EL2_DEFAULT CPTR_EL2_RES1 /* Hyp Debug Configuration Register bits */ #define MDCR_EL2_TPMS (1 << 14) @@ -237,5 +238,6 @@ #define CPACR_EL1_FPEN (3 << 20) #define CPACR_EL1_TTA (1 << 28) +#define CPACR_EL1_DEFAULT (CPACR_EL1_FPEN | CPACR_EL1_ZEN_EL1EN) #endif /* __ARM64_KVM_ARM_H__ */ diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h index e923b58..674912d 100644 --- a/arch/arm64/include/asm/kvm_host.h +++ b/arch/arm64/include/asm/kvm_host.h @@ -25,6 +25,7 @@ #include #include #include +#include #include #include #include @@ -384,4 +385,14 @@ static inline void __cpu_init_stage2(void) "PARange is %d bits, unsupported configuration!", parange); } +/* + * All host FP/SIMD state is restored on guest exit, so nothing needs + * doing here except in the SVE case: +*/ +static inline void kvm_fpsimd_flush_cpu_state(void) +{ + if (system_supports_sve()) + sve_flush_cpu_state(); +} + #endif /* __ARM64_KVM_HOST_H__ */ diff --git a/arch/arm64/kernel/fpsimd.c b/arch/arm64/kernel/fpsimd.c index 4da64fc..42fc731 100644 --- a/arch/arm64/kernel/fpsimd.c +++ b/arch/arm64/kernel/fpsimd.c @@ -1049,6 +1049,33 @@ void fpsimd_flush_task_state(struct task_struct *t) t->thread.fpsimd_state.cpu = NR_CPUS; } +static inline void fpsimd_flush_cpu_state(void) +{ + __this_cpu_write(fpsimd_last_state, NULL); +} + +/* + * Invalidate any task SVE state currently held in this CPU's regs. + * + * This is used to prevent the kernel from trying to reuse SVE register data + * that is detroyed by KVM guest enter/exit. This function should go away when + * KVM SVE support is implemented. Don't use it for anything else. + */ +#ifdef CONFIG_ARM64_SVE +void sve_flush_cpu_state(void) +{ + struct fpsimd_state *const fpstate = __this_cpu_read(fpsimd_last_state); + struct task_struct *tsk; + + if (!fpstate) + return; + + tsk = container_of(fpstate, struct task_struct, thread.fpsimd_state); + if (test_tsk_thread_flag(tsk, TIF_SVE)) + fpsimd_flush_cpu_state(); +} +#endif /* CONFIG_ARM64_SVE */ + #ifdef CONFIG_KERNEL_MODE_NEON DEFINE_PER_CPU(bool, kernel_neon_busy); @@ -1089,7 +1116,7 @@ void kernel_neon_begin(void) } /* Invalidate any task state remaining in the fpsimd regs: */ - __this_cpu_write(fpsimd_last_state, NULL); + fpsimd_flush_cpu_state(); preempt_disable(); @@ -1210,7 +1237,7 @@ static int fpsimd_cpu_pm_notifier(struct notifier_block *self, case CPU_PM_ENTER: if (current->mm) task_fpsimd_save(); - this_cpu_write(fpsimd_last_state, NULL); + fpsimd_flush_cpu_state(); break; case CPU_PM_EXIT: if (current->mm) diff --git a/arch/arm64/kvm/hyp/switch.c b/arch/arm64/kvm/hyp/switch.c index 35a90b8..951f3eb 100644 --- a/arch/arm64/kvm/hyp/switch.c +++ b/arch/arm64/kvm/hyp/switch.c @@ -48,7 +48,7 @@ static void __hyp_text __activate_traps_vhe(void) val = read_sysreg(cpacr_el1); val |= CPACR_EL1_TTA; - val &= ~CPACR_EL1_FPEN; + val &= ~(CPACR_EL1_FPEN | CPACR_EL1_ZEN); write_sysreg(val, cpacr_el1); write_sysreg(__kvm_hyp_vector, vbar_el1); @@ -59,7 +59,7 @@ static void __hyp_text __activate_traps_nvhe(void) u64 val; val = CPTR_EL2_DEFAULT; - val |= CPTR_EL2_TTA | CPTR_EL2_TFP; + val |= CPTR_EL2_TTA | CPTR_EL2_TFP | CPTR_EL2_TZ; write_sysreg(val, cptr_el2); } @@ -117,7 +117,7 @@ static void __hyp_text __deactivate_traps_vhe(void) write_sysreg(mdcr_el2, mdcr_el2); write_sysreg(HCR_HOST_VHE_FLAGS, hcr_el2); - write_sysreg(CPACR_EL1_FPEN, cpacr_el1); + write_sysreg(CPACR_EL1_DEFAULT, cpacr_el1); write_sysreg(vectors, vbar_el1); } diff --git a/virt/kvm/arm/arm.c b/virt/kvm/arm/arm.c index b9f68e4..4d3cf9c 100644 --- a/virt/kvm/arm/arm.c +++ b/virt/kvm/arm/arm.c @@ -652,6 +652,9 @@ int kvm_arch_vcpu_ioctl_run(struct kvm_vcpu *vcpu, struct kvm_run *run) */ preempt_disable(); + /* Flush FP/SIMD state that can't survive guest entry/exit */ + kvm_fpsimd_flush_cpu_state(); + kvm_pmu_flush_hwstate(vcpu); kvm_timer_flush_hwstate(vcpu); -- 2.1.4