From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dave Martin Subject: [PATCH v11 10/19] KVM: arm64: Repurpose vcpu_arch.debug_flags for general-purpose flags Date: Thu, 24 May 2018 17:56:39 +0100 Message-ID: <1527181008-13549-11-git-send-email-Dave.Martin@arm.com> References: <1527181008-13549-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: <1527181008-13549-1-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: kvmarm@lists.cs.columbia.edu Cc: Christoffer Dall , Ard Biesheuvel , Marc Zyngier , Catalin Marinas , Will Deacon , linux-arm-kernel@lists.infradead.org List-Id: kvmarm@lists.cs.columbia.edu SW4gc3RydWN0IHZjcHVfYXJjaCwgdGhlIGRlYnVnX2ZsYWdzIGZpZWxkIGlzIHVzZWQgdG8gc3Rv cmUKZGVidWctcmVsYXRlZCBmbGFncyBhYm91dCB0aGUgdmNwdSBzdGF0ZS4KClNpbmNlIHdlIGFy ZSBhYm91dCB0byBhZGQgc29tZSBtb3JlIGZsYWdzIHJlbGF0ZWQgdG8gRlBTSU1EIGFuZApTVkUs IGl0IG1ha2VzIHNlbnNlIHRvIGFkZCB0aGVtIHRvIHRoZSBleGlzdGluZyBmbGFncyBmaWVsZCBy YXRoZXIKdGhhbiBhZGRpbmcgbmV3IGZpZWxkcy4gIFNpbmNlIHRoZXJlIGlzIG9ubHkgb25lIGRl YnVnX2ZsYWdzIGZsYWcKZGVmaW5lZCBzbyBmYXIsIHRoZXJlIGlzIHBsZW50eSBvZiBmcmVlIHNw YWNlIGZvciBleHBhbnNpb24uCgpJbiBwcmVwYXJhdGlvbiBmb3IgYWRkaW5nIG1vcmUgZmxhZ3Ms IHRoaXMgcGF0Y2ggcmVuYW1lcyB0aGUKZGVidWdfZmxhZ3MgZmllbGQgdG8gc2ltcGx5ICJmbGFn cyIsIGFuZCB1cGRhdGVzIGNvbW1lbnRzCmFwcHJvcHJpYXRlbHkuCgpUaGUgZmxhZyBkZWZpbml0 aW9ucyBhcmUgYWxzbyBtb3ZlZCB0byA8YXNtL2t2bV9ob3N0Lmg+LCBzaW5jZQp0aGVpciBwcmVz ZW5jZSBpbiA8YXNtL2t2bV9hc20uaD4gd2FzIGZvciBwdXJlbHkgaGlzdG9yaWNhbApyZWFzb25z OiAgdGhlc2UgZGVmaW5pdGlvbnMgYXJlIG5vdCB1c2VkIGZyb20gYXNtIGFueSBtb3JlLCBhbmQg bm90CnZlcnkgbGlrZWx5IHRvIGJlIGFzIG1vcmUgSHlwIGFzbSBpcyBtaWdyYXRlZCB0byBDLgoK S1ZNX0FSTTY0X0RFQlVHX0RJUlRZX1NISUZUIGhhcyBub3QgYmVlbiB1c2VkIHNpbmNlIGNvbW1p dAoxZWE2NmQyN2U3YjAgKCJhcm02NDogS1ZNOiBNb3ZlIGF3YXkgZnJvbSB0aGUgYXNzZW1ibHkg dmVyc2lvbiBvZgp0aGUgd29ybGQgc3dpdGNoIiksIHNvIHRoaXMgcGF0Y2ggZ2V0cyByaWQgb2Yg dGhhdCB0b28uCgpObyBmdW5jdGlvbmFsIGNoYW5nZS4KClNpZ25lZC1vZmYtYnk6IERhdmUgTWFy dGluIDxEYXZlLk1hcnRpbkBhcm0uY29tPgpSZXZpZXdlZC1ieTogTWFyYyBaeW5naWVyIDxtYXJj Lnp5bmdpZXJAYXJtLmNvbT4KUmV2aWV3ZWQtYnk6IEFsZXggQmVubsOpZSA8YWxleC5iZW5uZWVA bGluYXJvLm9yZz4KQWNrZWQtYnk6IENocmlzdG9mZmVyIERhbGwgPGNocmlzdG9mZmVyLmRhbGxA YXJtLmNvbT4KLS0tCiBhcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9hc20uaCAgfCAzIC0tLQog YXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1faG9zdC5oIHwgNyArKysrKy0tCiBhcmNoL2FybTY0 L2t2bS9kZWJ1Zy5jICAgICAgICAgICAgfCA4ICsrKystLS0tCiBhcmNoL2FybTY0L2t2bS9oeXAv ZGVidWctc3IuYyAgICAgfCA2ICsrKy0tLQogYXJjaC9hcm02NC9rdm0vaHlwL3N5c3JlZy1zci5j ICAgIHwgNCArKy0tCiBhcmNoL2FybTY0L2t2bS9zeXNfcmVncy5jICAgICAgICAgfCA5ICsrKyst LS0tLQogNiBmaWxlcyBjaGFuZ2VkLCAxOCBpbnNlcnRpb25zKCspLCAxOSBkZWxldGlvbnMoLSkK CmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9hc20uaCBiL2FyY2gvYXJt NjQvaW5jbHVkZS9hc20va3ZtX2FzbS5oCmluZGV4IGY2NjQ4YTMuLmY2MmNjYmYgMTAwNjQ0Ci0t LSBhL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX2FzbS5oCisrKyBiL2FyY2gvYXJtNjQvaW5j bHVkZS9hc20va3ZtX2FzbS5oCkBAIC0zMCw5ICszMCw2IEBACiAvKiBUaGUgaHlwLXN0dWIgd2ls bCByZXR1cm4gdGhpcyBmb3IgYW55IGt2bV9jYWxsX2h5cCgpIGNhbGwgKi8KICNkZWZpbmUgQVJN X0VYQ0VQVElPTl9IWVBfR09ORQkgIEhWQ19TVFVCX0VSUgogCi0jZGVmaW5lIEtWTV9BUk02NF9E RUJVR19ESVJUWV9TSElGVAkwCi0jZGVmaW5lIEtWTV9BUk02NF9ERUJVR19ESVJUWQkJKDEgPDwg S1ZNX0FSTTY0X0RFQlVHX0RJUlRZX1NISUZUKQotCiAvKiBUcmFuc2xhdGUgYSBrZXJuZWwgYWRk cmVzcyBvZiBAc3ltIGludG8gaXRzIGVxdWl2YWxlbnQgbGluZWFyIG1hcHBpbmcgKi8KICNkZWZp bmUga3ZtX2tzeW1fcmVmKHN5bSkJCQkJCQlcCiAJKHsJCQkJCQkJCVwKZGlmZiAtLWdpdCBhL2Fy Y2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX2hvc3QuaCBiL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20v a3ZtX2hvc3QuaAppbmRleCA0NjlkZThhLi4xNDZjMTY3IDEwMDY0NAotLS0gYS9hcmNoL2FybTY0 L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKKysrIGIvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1f aG9zdC5oCkBAIC0yMTYsOCArMjE2LDggQEAgc3RydWN0IGt2bV92Y3B1X2FyY2ggewogCS8qIEV4 Y2VwdGlvbiBJbmZvcm1hdGlvbiAqLwogCXN0cnVjdCBrdm1fdmNwdV9mYXVsdF9pbmZvIGZhdWx0 OwogCi0JLyogR3Vlc3QgZGVidWcgc3RhdGUgKi8KLQl1NjQgZGVidWdfZmxhZ3M7CisJLyogTWlz Y2VsbGFuZW91cyB2Y3B1IHN0YXRlIGZsYWdzICovCisJdTY0IGZsYWdzOwogCiAJLyoKIAkgKiBX ZSBtYWludGFpbiBtb3JlIHRoYW4gYSBzaW5nbGUgc2V0IG9mIGRlYnVnIHJlZ2lzdGVycyB0byBz dXBwb3J0CkBAIC0yOTMsNiArMjkzLDkgQEAgc3RydWN0IGt2bV92Y3B1X2FyY2ggewogCWJvb2wg c3lzcmVnc19sb2FkZWRfb25fY3B1OwogfTsKIAorLyogdmNwdV9hcmNoIGZsYWdzIGZpZWxkIHZh bHVlczogKi8KKyNkZWZpbmUgS1ZNX0FSTTY0X0RFQlVHX0RJUlRZCQkoMSA8PCAwKQorCiAjZGVm aW5lIHZjcHVfZ3BfcmVncyh2KQkJKCYodiktPmFyY2guY3R4dC5ncF9yZWdzKQogCiAvKgpkaWZm IC0tZ2l0IGEvYXJjaC9hcm02NC9rdm0vZGVidWcuYyBiL2FyY2gvYXJtNjQva3ZtL2RlYnVnLmMK aW5kZXggYTFmNGViZC4uMDBkNDIyMyAxMDA2NDQKLS0tIGEvYXJjaC9hcm02NC9rdm0vZGVidWcu YworKysgYi9hcmNoL2FybTY0L2t2bS9kZWJ1Zy5jCkBAIC0xMDMsNyArMTAzLDcgQEAgdm9pZCBr dm1fYXJtX3Jlc2V0X2RlYnVnX3B0cihzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCiAgKgogICogQWRk aXRpb25hbGx5LCBLVk0gb25seSB0cmFwcyBndWVzdCBhY2Nlc3NlcyB0byB0aGUgZGVidWcgcmVn aXN0ZXJzIGlmCiAgKiB0aGUgZ3Vlc3QgaXMgbm90IGFjdGl2ZWx5IHVzaW5nIHRoZW0gKHNlZSB0 aGUgS1ZNX0FSTTY0X0RFQlVHX0RJUlRZCi0gKiBmbGFnIG9uIHZjcHUtPmFyY2guZGVidWdfZmxh Z3MpLiAgU2luY2UgdGhlIGd1ZXN0IG11c3Qgbm90IGludGVyZmVyZQorICogZmxhZyBvbiB2Y3B1 LT5hcmNoLmZsYWdzKS4gIFNpbmNlIHRoZSBndWVzdCBtdXN0IG5vdCBpbnRlcmZlcmUKICAqIHdp dGggdGhlIGhhcmR3YXJlIHN0YXRlIHdoZW4gZGVidWdnaW5nIHRoZSBndWVzdCwgd2UgbXVzdCBl bnN1cmUgdGhhdAogICogdHJhcHBpbmcgaXMgZW5hYmxlZCB3aGVuZXZlciB3ZSBhcmUgZGVidWdn aW5nIHRoZSBndWVzdCB1c2luZyB0aGUKICAqIGRlYnVnIHJlZ2lzdGVycy4KQEAgLTExMSw3ICsx MTEsNyBAQCB2b2lkIGt2bV9hcm1fcmVzZXRfZGVidWdfcHRyKHN0cnVjdCBrdm1fdmNwdSAqdmNw dSkKIAogdm9pZCBrdm1fYXJtX3NldHVwX2RlYnVnKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSkKIHsK LQlib29sIHRyYXBfZGVidWcgPSAhKHZjcHUtPmFyY2guZGVidWdfZmxhZ3MgJiBLVk1fQVJNNjRf REVCVUdfRElSVFkpOworCWJvb2wgdHJhcF9kZWJ1ZyA9ICEodmNwdS0+YXJjaC5mbGFncyAmIEtW TV9BUk02NF9ERUJVR19ESVJUWSk7CiAJdW5zaWduZWQgbG9uZyBtZHNjcjsKIAogCXRyYWNlX2t2 bV9hcm1fc2V0dXBfZGVidWcodmNwdSwgdmNwdS0+Z3Vlc3RfZGVidWcpOwpAQCAtMTg0LDcgKzE4 NCw3IEBAIHZvaWQga3ZtX2FybV9zZXR1cF9kZWJ1ZyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCiAJ CQl2Y3B1X3dyaXRlX3N5c19yZWcodmNwdSwgbWRzY3IsIE1EU0NSX0VMMSk7CiAKIAkJCXZjcHUt PmFyY2guZGVidWdfcHRyID0gJnZjcHUtPmFyY2guZXh0ZXJuYWxfZGVidWdfc3RhdGU7Ci0JCQl2 Y3B1LT5hcmNoLmRlYnVnX2ZsYWdzIHw9IEtWTV9BUk02NF9ERUJVR19ESVJUWTsKKwkJCXZjcHUt PmFyY2guZmxhZ3MgfD0gS1ZNX0FSTTY0X0RFQlVHX0RJUlRZOwogCQkJdHJhcF9kZWJ1ZyA9IHRy dWU7CiAKIAkJCXRyYWNlX2t2bV9hcm1fc2V0X3JlZ3NldCgiQktQVFMiLCBnZXRfbnVtX2JycHMo KSwKQEAgLTIwNiw3ICsyMDYsNyBAQCB2b2lkIGt2bV9hcm1fc2V0dXBfZGVidWcoc3RydWN0IGt2 bV92Y3B1ICp2Y3B1KQogCiAJLyogSWYgS0RFIG9yIE1ERSBhcmUgc2V0LCBwZXJmb3JtIGEgZnVs bCBzYXZlL3Jlc3RvcmUgY3ljbGUuICovCiAJaWYgKHZjcHVfcmVhZF9zeXNfcmVnKHZjcHUsIE1E U0NSX0VMMSkgJiAoREJHX01EU0NSX0tERSB8IERCR19NRFNDUl9NREUpKQotCQl2Y3B1LT5hcmNo LmRlYnVnX2ZsYWdzIHw9IEtWTV9BUk02NF9ERUJVR19ESVJUWTsKKwkJdmNwdS0+YXJjaC5mbGFn cyB8PSBLVk1fQVJNNjRfREVCVUdfRElSVFk7CiAKIAl0cmFjZV9rdm1fYXJtX3NldF9kcmVnMzIo Ik1EQ1JfRUwyIiwgdmNwdS0+YXJjaC5tZGNyX2VsMik7CiAJdHJhY2Vfa3ZtX2FybV9zZXRfZHJl ZzMyKCJNRFNDUl9FTDEiLCB2Y3B1X3JlYWRfc3lzX3JlZyh2Y3B1LCBNRFNDUl9FTDEpKTsKZGlm ZiAtLWdpdCBhL2FyY2gvYXJtNjQva3ZtL2h5cC9kZWJ1Zy1zci5jIGIvYXJjaC9hcm02NC9rdm0v aHlwL2RlYnVnLXNyLmMKaW5kZXggM2U3MTdmNi4uNTAwMDk3NiAxMDA2NDQKLS0tIGEvYXJjaC9h cm02NC9rdm0vaHlwL2RlYnVnLXNyLmMKKysrIGIvYXJjaC9hcm02NC9rdm0vaHlwL2RlYnVnLXNy LmMKQEAgLTE2Myw3ICsxNjMsNyBAQCB2b2lkIF9faHlwX3RleHQgX19kZWJ1Z19zd2l0Y2hfdG9f Z3Vlc3Qoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQogCWlmICghaGFzX3ZoZSgpKQogCQlfX2RlYnVn X3NhdmVfc3BlX252aGUoJnZjcHUtPmFyY2guaG9zdF9kZWJ1Z19zdGF0ZS5wbXNjcl9lbDEpOwog Ci0JaWYgKCEodmNwdS0+YXJjaC5kZWJ1Z19mbGFncyAmIEtWTV9BUk02NF9ERUJVR19ESVJUWSkp CisJaWYgKCEodmNwdS0+YXJjaC5mbGFncyAmIEtWTV9BUk02NF9ERUJVR19ESVJUWSkpCiAJCXJl dHVybjsKIAogCWhvc3RfY3R4dCA9IGtlcm5faHlwX3ZhKHZjcHUtPmFyY2guaG9zdF9jcHVfY29u dGV4dCk7CkBAIC0xODUsNyArMTg1LDcgQEAgdm9pZCBfX2h5cF90ZXh0IF9fZGVidWdfc3dpdGNo X3RvX2hvc3Qoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQogCWlmICghaGFzX3ZoZSgpKQogCQlfX2Rl YnVnX3Jlc3RvcmVfc3BlX252aGUodmNwdS0+YXJjaC5ob3N0X2RlYnVnX3N0YXRlLnBtc2NyX2Vs MSk7CiAKLQlpZiAoISh2Y3B1LT5hcmNoLmRlYnVnX2ZsYWdzICYgS1ZNX0FSTTY0X0RFQlVHX0RJ UlRZKSkKKwlpZiAoISh2Y3B1LT5hcmNoLmZsYWdzICYgS1ZNX0FSTTY0X0RFQlVHX0RJUlRZKSkK IAkJcmV0dXJuOwogCiAJaG9zdF9jdHh0ID0ga2Vybl9oeXBfdmEodmNwdS0+YXJjaC5ob3N0X2Nw dV9jb250ZXh0KTsKQEAgLTE5Niw3ICsxOTYsNyBAQCB2b2lkIF9faHlwX3RleHQgX19kZWJ1Z19z d2l0Y2hfdG9faG9zdChzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCiAJX19kZWJ1Z19zYXZlX3N0YXRl KHZjcHUsIGd1ZXN0X2RiZywgZ3Vlc3RfY3R4dCk7CiAJX19kZWJ1Z19yZXN0b3JlX3N0YXRlKHZj cHUsIGhvc3RfZGJnLCBob3N0X2N0eHQpOwogCi0JdmNwdS0+YXJjaC5kZWJ1Z19mbGFncyAmPSB+ S1ZNX0FSTTY0X0RFQlVHX0RJUlRZOworCXZjcHUtPmFyY2guZmxhZ3MgJj0gfktWTV9BUk02NF9E RUJVR19ESVJUWTsKIH0KIAogdTMyIF9faHlwX3RleHQgX19rdm1fZ2V0X21kY3JfZWwyKHZvaWQp CmRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2t2bS9oeXAvc3lzcmVnLXNyLmMgYi9hcmNoL2FybTY0 L2t2bS9oeXAvc3lzcmVnLXNyLmMKaW5kZXggYjM4OTRkZi4uMzViYzE2OCAxMDA2NDQKLS0tIGEv YXJjaC9hcm02NC9rdm0vaHlwL3N5c3JlZy1zci5jCisrKyBiL2FyY2gvYXJtNjQva3ZtL2h5cC9z eXNyZWctc3IuYwpAQCAtMTk2LDcgKzE5Niw3IEBAIHZvaWQgX19oeXBfdGV4dCBfX3N5c3JlZzMy X3NhdmVfc3RhdGUoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQogCXN5c3JlZ1tEQUNSMzJfRUwyXSA9 IHJlYWRfc3lzcmVnKGRhY3IzMl9lbDIpOwogCXN5c3JlZ1tJRlNSMzJfRUwyXSA9IHJlYWRfc3lz cmVnKGlmc3IzMl9lbDIpOwogCi0JaWYgKGhhc192aGUoKSB8fCB2Y3B1LT5hcmNoLmRlYnVnX2Zs YWdzICYgS1ZNX0FSTTY0X0RFQlVHX0RJUlRZKQorCWlmIChoYXNfdmhlKCkgfHwgdmNwdS0+YXJj aC5mbGFncyAmIEtWTV9BUk02NF9ERUJVR19ESVJUWSkKIAkJc3lzcmVnW0RCR1ZDUjMyX0VMMl0g PSByZWFkX3N5c3JlZyhkYmd2Y3IzMl9lbDIpOwogfQogCkBAIC0yMTgsNyArMjE4LDcgQEAgdm9p ZCBfX2h5cF90ZXh0IF9fc3lzcmVnMzJfcmVzdG9yZV9zdGF0ZShzdHJ1Y3Qga3ZtX3ZjcHUgKnZj cHUpCiAJd3JpdGVfc3lzcmVnKHN5c3JlZ1tEQUNSMzJfRUwyXSwgZGFjcjMyX2VsMik7CiAJd3Jp dGVfc3lzcmVnKHN5c3JlZ1tJRlNSMzJfRUwyXSwgaWZzcjMyX2VsMik7CiAKLQlpZiAoaGFzX3Zo ZSgpIHx8IHZjcHUtPmFyY2guZGVidWdfZmxhZ3MgJiBLVk1fQVJNNjRfREVCVUdfRElSVFkpCisJ aWYgKGhhc192aGUoKSB8fCB2Y3B1LT5hcmNoLmZsYWdzICYgS1ZNX0FSTTY0X0RFQlVHX0RJUlRZ KQogCQl3cml0ZV9zeXNyZWcoc3lzcmVnW0RCR1ZDUjMyX0VMMl0sIGRiZ3ZjcjMyX2VsMik7CiB9 CiAKZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQva3ZtL3N5c19yZWdzLmMgYi9hcmNoL2FybTY0L2t2 bS9zeXNfcmVncy5jCmluZGV4IDZlM2I5NjkuLmE0MzYzNzMgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJt NjQva3ZtL3N5c19yZWdzLmMKKysrIGIvYXJjaC9hcm02NC9rdm0vc3lzX3JlZ3MuYwpAQCAtMzEs NyArMzEsNiBAQAogI2luY2x1ZGUgPGFzbS9kZWJ1Zy1tb25pdG9ycy5oPgogI2luY2x1ZGUgPGFz bS9lc3IuaD4KICNpbmNsdWRlIDxhc20va3ZtX2FybS5oPgotI2luY2x1ZGUgPGFzbS9rdm1fYXNt Lmg+CiAjaW5jbHVkZSA8YXNtL2t2bV9jb3Byb2MuaD4KICNpbmNsdWRlIDxhc20va3ZtX2VtdWxh dGUuaD4KICNpbmNsdWRlIDxhc20va3ZtX2hvc3QuaD4KQEAgLTMzOCw3ICszMzcsNyBAQCBzdGF0 aWMgYm9vbCB0cmFwX2RlYnVnX3JlZ3Moc3RydWN0IGt2bV92Y3B1ICp2Y3B1LAogewogCWlmIChw LT5pc193cml0ZSkgewogCQl2Y3B1X3dyaXRlX3N5c19yZWcodmNwdSwgcC0+cmVndmFsLCByLT5y ZWcpOwotCQl2Y3B1LT5hcmNoLmRlYnVnX2ZsYWdzIHw9IEtWTV9BUk02NF9ERUJVR19ESVJUWTsK KwkJdmNwdS0+YXJjaC5mbGFncyB8PSBLVk1fQVJNNjRfREVCVUdfRElSVFk7CiAJfSBlbHNlIHsK IAkJcC0+cmVndmFsID0gdmNwdV9yZWFkX3N5c19yZWcodmNwdSwgci0+cmVnKTsKIAl9CkBAIC0z NjksNyArMzY4LDcgQEAgc3RhdGljIHZvaWQgcmVnX3RvX2RiZyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZj cHUsCiAJfQogCiAJKmRiZ19yZWcgPSB2YWw7Ci0JdmNwdS0+YXJjaC5kZWJ1Z19mbGFncyB8PSBL Vk1fQVJNNjRfREVCVUdfRElSVFk7CisJdmNwdS0+YXJjaC5mbGFncyB8PSBLVk1fQVJNNjRfREVC VUdfRElSVFk7CiB9CiAKIHN0YXRpYyB2b2lkIGRiZ190b19yZWcoc3RydWN0IGt2bV92Y3B1ICp2 Y3B1LApAQCAtMTQ0MSw3ICsxNDQwLDcgQEAgc3RhdGljIGJvb2wgdHJhcF9kZWJ1ZzMyKHN0cnVj dCBrdm1fdmNwdSAqdmNwdSwKIHsKIAlpZiAocC0+aXNfd3JpdGUpIHsKIAkJdmNwdV9jcDE0KHZj cHUsIHItPnJlZykgPSBwLT5yZWd2YWw7Ci0JCXZjcHUtPmFyY2guZGVidWdfZmxhZ3MgfD0gS1ZN X0FSTTY0X0RFQlVHX0RJUlRZOworCQl2Y3B1LT5hcmNoLmZsYWdzIHw9IEtWTV9BUk02NF9ERUJV R19ESVJUWTsKIAl9IGVsc2UgewogCQlwLT5yZWd2YWwgPSB2Y3B1X2NwMTQodmNwdSwgci0+cmVn KTsKIAl9CkBAIC0xNDczLDcgKzE0NzIsNyBAQCBzdGF0aWMgYm9vbCB0cmFwX3h2cihzdHJ1Y3Qg a3ZtX3ZjcHUgKnZjcHUsCiAJCXZhbCB8PSBwLT5yZWd2YWwgPDwgMzI7CiAJCSpkYmdfcmVnID0g dmFsOwogCi0JCXZjcHUtPmFyY2guZGVidWdfZmxhZ3MgfD0gS1ZNX0FSTTY0X0RFQlVHX0RJUlRZ OworCQl2Y3B1LT5hcmNoLmZsYWdzIHw9IEtWTV9BUk02NF9ERUJVR19ESVJUWTsKIAl9IGVsc2Ug ewogCQlwLT5yZWd2YWwgPSAqZGJnX3JlZyA+PiAzMjsKIAl9Ci0tIAoyLjEuNAoKCl9fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwg bWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8v bGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK From mboxrd@z Thu Jan 1 00:00:00 1970 From: Dave.Martin@arm.com (Dave Martin) Date: Thu, 24 May 2018 17:56:39 +0100 Subject: [PATCH v11 10/19] KVM: arm64: Repurpose vcpu_arch.debug_flags for general-purpose flags In-Reply-To: <1527181008-13549-1-git-send-email-Dave.Martin@arm.com> References: <1527181008-13549-1-git-send-email-Dave.Martin@arm.com> Message-ID: <1527181008-13549-11-git-send-email-Dave.Martin@arm.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org In struct vcpu_arch, the debug_flags field is used to store debug-related flags about the vcpu state. Since we are about to add some more flags related to FPSIMD and SVE, it makes sense to add them to the existing flags field rather than adding new fields. Since there is only one debug_flags flag defined so far, there is plenty of free space for expansion. In preparation for adding more flags, this patch renames the debug_flags field to simply "flags", and updates comments appropriately. The flag definitions are also moved to , since their presence in was for purely historical reasons: these definitions are not used from asm any more, and not very likely to be as more Hyp asm is migrated to C. KVM_ARM64_DEBUG_DIRTY_SHIFT has not been used since commit 1ea66d27e7b0 ("arm64: KVM: Move away from the assembly version of the world switch"), so this patch gets rid of that too. No functional change. Signed-off-by: Dave Martin Reviewed-by: Marc Zyngier Reviewed-by: Alex Benn?e Acked-by: Christoffer Dall --- arch/arm64/include/asm/kvm_asm.h | 3 --- arch/arm64/include/asm/kvm_host.h | 7 +++++-- arch/arm64/kvm/debug.c | 8 ++++---- arch/arm64/kvm/hyp/debug-sr.c | 6 +++--- arch/arm64/kvm/hyp/sysreg-sr.c | 4 ++-- arch/arm64/kvm/sys_regs.c | 9 ++++----- 6 files changed, 18 insertions(+), 19 deletions(-) diff --git a/arch/arm64/include/asm/kvm_asm.h b/arch/arm64/include/asm/kvm_asm.h index f6648a3..f62ccbf 100644 --- a/arch/arm64/include/asm/kvm_asm.h +++ b/arch/arm64/include/asm/kvm_asm.h @@ -30,9 +30,6 @@ /* The hyp-stub will return this for any kvm_call_hyp() call */ #define ARM_EXCEPTION_HYP_GONE HVC_STUB_ERR -#define KVM_ARM64_DEBUG_DIRTY_SHIFT 0 -#define KVM_ARM64_DEBUG_DIRTY (1 << KVM_ARM64_DEBUG_DIRTY_SHIFT) - /* Translate a kernel address of @sym into its equivalent linear mapping */ #define kvm_ksym_ref(sym) \ ({ \ diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h index 469de8a..146c167 100644 --- a/arch/arm64/include/asm/kvm_host.h +++ b/arch/arm64/include/asm/kvm_host.h @@ -216,8 +216,8 @@ struct kvm_vcpu_arch { /* Exception Information */ struct kvm_vcpu_fault_info fault; - /* Guest debug state */ - u64 debug_flags; + /* Miscellaneous vcpu state flags */ + u64 flags; /* * We maintain more than a single set of debug registers to support @@ -293,6 +293,9 @@ struct kvm_vcpu_arch { bool sysregs_loaded_on_cpu; }; +/* vcpu_arch flags field values: */ +#define KVM_ARM64_DEBUG_DIRTY (1 << 0) + #define vcpu_gp_regs(v) (&(v)->arch.ctxt.gp_regs) /* diff --git a/arch/arm64/kvm/debug.c b/arch/arm64/kvm/debug.c index a1f4ebd..00d4223 100644 --- a/arch/arm64/kvm/debug.c +++ b/arch/arm64/kvm/debug.c @@ -103,7 +103,7 @@ void kvm_arm_reset_debug_ptr(struct kvm_vcpu *vcpu) * * Additionally, KVM only traps guest accesses to the debug registers if * the guest is not actively using them (see the KVM_ARM64_DEBUG_DIRTY - * flag on vcpu->arch.debug_flags). Since the guest must not interfere + * flag on vcpu->arch.flags). Since the guest must not interfere * with the hardware state when debugging the guest, we must ensure that * trapping is enabled whenever we are debugging the guest using the * debug registers. @@ -111,7 +111,7 @@ void kvm_arm_reset_debug_ptr(struct kvm_vcpu *vcpu) void kvm_arm_setup_debug(struct kvm_vcpu *vcpu) { - bool trap_debug = !(vcpu->arch.debug_flags & KVM_ARM64_DEBUG_DIRTY); + bool trap_debug = !(vcpu->arch.flags & KVM_ARM64_DEBUG_DIRTY); unsigned long mdscr; trace_kvm_arm_setup_debug(vcpu, vcpu->guest_debug); @@ -184,7 +184,7 @@ void kvm_arm_setup_debug(struct kvm_vcpu *vcpu) vcpu_write_sys_reg(vcpu, mdscr, MDSCR_EL1); vcpu->arch.debug_ptr = &vcpu->arch.external_debug_state; - vcpu->arch.debug_flags |= KVM_ARM64_DEBUG_DIRTY; + vcpu->arch.flags |= KVM_ARM64_DEBUG_DIRTY; trap_debug = true; trace_kvm_arm_set_regset("BKPTS", get_num_brps(), @@ -206,7 +206,7 @@ void kvm_arm_setup_debug(struct kvm_vcpu *vcpu) /* If KDE or MDE are set, perform a full save/restore cycle. */ if (vcpu_read_sys_reg(vcpu, MDSCR_EL1) & (DBG_MDSCR_KDE | DBG_MDSCR_MDE)) - vcpu->arch.debug_flags |= KVM_ARM64_DEBUG_DIRTY; + vcpu->arch.flags |= KVM_ARM64_DEBUG_DIRTY; trace_kvm_arm_set_dreg32("MDCR_EL2", vcpu->arch.mdcr_el2); trace_kvm_arm_set_dreg32("MDSCR_EL1", vcpu_read_sys_reg(vcpu, MDSCR_EL1)); diff --git a/arch/arm64/kvm/hyp/debug-sr.c b/arch/arm64/kvm/hyp/debug-sr.c index 3e717f6..5000976 100644 --- a/arch/arm64/kvm/hyp/debug-sr.c +++ b/arch/arm64/kvm/hyp/debug-sr.c @@ -163,7 +163,7 @@ void __hyp_text __debug_switch_to_guest(struct kvm_vcpu *vcpu) if (!has_vhe()) __debug_save_spe_nvhe(&vcpu->arch.host_debug_state.pmscr_el1); - if (!(vcpu->arch.debug_flags & KVM_ARM64_DEBUG_DIRTY)) + if (!(vcpu->arch.flags & KVM_ARM64_DEBUG_DIRTY)) return; host_ctxt = kern_hyp_va(vcpu->arch.host_cpu_context); @@ -185,7 +185,7 @@ void __hyp_text __debug_switch_to_host(struct kvm_vcpu *vcpu) if (!has_vhe()) __debug_restore_spe_nvhe(vcpu->arch.host_debug_state.pmscr_el1); - if (!(vcpu->arch.debug_flags & KVM_ARM64_DEBUG_DIRTY)) + if (!(vcpu->arch.flags & KVM_ARM64_DEBUG_DIRTY)) return; host_ctxt = kern_hyp_va(vcpu->arch.host_cpu_context); @@ -196,7 +196,7 @@ void __hyp_text __debug_switch_to_host(struct kvm_vcpu *vcpu) __debug_save_state(vcpu, guest_dbg, guest_ctxt); __debug_restore_state(vcpu, host_dbg, host_ctxt); - vcpu->arch.debug_flags &= ~KVM_ARM64_DEBUG_DIRTY; + vcpu->arch.flags &= ~KVM_ARM64_DEBUG_DIRTY; } u32 __hyp_text __kvm_get_mdcr_el2(void) diff --git a/arch/arm64/kvm/hyp/sysreg-sr.c b/arch/arm64/kvm/hyp/sysreg-sr.c index b3894df..35bc168 100644 --- a/arch/arm64/kvm/hyp/sysreg-sr.c +++ b/arch/arm64/kvm/hyp/sysreg-sr.c @@ -196,7 +196,7 @@ void __hyp_text __sysreg32_save_state(struct kvm_vcpu *vcpu) sysreg[DACR32_EL2] = read_sysreg(dacr32_el2); sysreg[IFSR32_EL2] = read_sysreg(ifsr32_el2); - if (has_vhe() || vcpu->arch.debug_flags & KVM_ARM64_DEBUG_DIRTY) + if (has_vhe() || vcpu->arch.flags & KVM_ARM64_DEBUG_DIRTY) sysreg[DBGVCR32_EL2] = read_sysreg(dbgvcr32_el2); } @@ -218,7 +218,7 @@ void __hyp_text __sysreg32_restore_state(struct kvm_vcpu *vcpu) write_sysreg(sysreg[DACR32_EL2], dacr32_el2); write_sysreg(sysreg[IFSR32_EL2], ifsr32_el2); - if (has_vhe() || vcpu->arch.debug_flags & KVM_ARM64_DEBUG_DIRTY) + if (has_vhe() || vcpu->arch.flags & KVM_ARM64_DEBUG_DIRTY) write_sysreg(sysreg[DBGVCR32_EL2], dbgvcr32_el2); } diff --git a/arch/arm64/kvm/sys_regs.c b/arch/arm64/kvm/sys_regs.c index 6e3b969..a436373 100644 --- a/arch/arm64/kvm/sys_regs.c +++ b/arch/arm64/kvm/sys_regs.c @@ -31,7 +31,6 @@ #include #include #include -#include #include #include #include @@ -338,7 +337,7 @@ static bool trap_debug_regs(struct kvm_vcpu *vcpu, { if (p->is_write) { vcpu_write_sys_reg(vcpu, p->regval, r->reg); - vcpu->arch.debug_flags |= KVM_ARM64_DEBUG_DIRTY; + vcpu->arch.flags |= KVM_ARM64_DEBUG_DIRTY; } else { p->regval = vcpu_read_sys_reg(vcpu, r->reg); } @@ -369,7 +368,7 @@ static void reg_to_dbg(struct kvm_vcpu *vcpu, } *dbg_reg = val; - vcpu->arch.debug_flags |= KVM_ARM64_DEBUG_DIRTY; + vcpu->arch.flags |= KVM_ARM64_DEBUG_DIRTY; } static void dbg_to_reg(struct kvm_vcpu *vcpu, @@ -1441,7 +1440,7 @@ static bool trap_debug32(struct kvm_vcpu *vcpu, { if (p->is_write) { vcpu_cp14(vcpu, r->reg) = p->regval; - vcpu->arch.debug_flags |= KVM_ARM64_DEBUG_DIRTY; + vcpu->arch.flags |= KVM_ARM64_DEBUG_DIRTY; } else { p->regval = vcpu_cp14(vcpu, r->reg); } @@ -1473,7 +1472,7 @@ static bool trap_xvr(struct kvm_vcpu *vcpu, val |= p->regval << 32; *dbg_reg = val; - vcpu->arch.debug_flags |= KVM_ARM64_DEBUG_DIRTY; + vcpu->arch.flags |= KVM_ARM64_DEBUG_DIRTY; } else { p->regval = *dbg_reg >> 32; } -- 2.1.4