From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alex =?utf-8?Q?Benn=C3=A9e?= Subject: Re: [PATCH v10 09/18] KVM: arm64: Repurpose vcpu_arch.debug_flags for general-purpose flags Date: Thu, 24 May 2018 10:21:20 +0100 Message-ID: <87a7sptnn3.fsf@linaro.org> References: <1527005119-6842-1-git-send-email-Dave.Martin@arm.com> <1527005119-6842-10-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-10-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+IEluIHN0cnVjdCB2 Y3B1X2FyY2gsIHRoZSBkZWJ1Z19mbGFncyBmaWVsZCBpcyB1c2VkIHRvIHN0b3JlCj4gZGVidWct cmVsYXRlZCBmbGFncyBhYm91dCB0aGUgdmNwdSBzdGF0ZS4KPgo+IFNpbmNlIHdlIGFyZSBhYm91 dCB0byBhZGQgc29tZSBtb3JlIGZsYWdzIHJlbGF0ZWQgdG8gRlBTSU1EIGFuZAo+IFNWRSwgaXQg bWFrZXMgc2Vuc2UgdG8gYWRkIHRoZW0gdG8gdGhlIGV4aXN0aW5nIGZsYWdzIGZpZWxkIHJhdGhl cgo+IHRoYW4gYWRkaW5nIG5ldyBmaWVsZHMuICBTaW5jZSB0aGVyZSBpcyBvbmx5IG9uZSBkZWJ1 Z19mbGFncyBmbGFnCj4gZGVmaW5lZCBzbyBmYXIsIHRoZXJlIGlzIHBsZW50eSBvZiBmcmVlIHNw YWNlIGZvciBleHBhbnNpb24uCj4KPiBJbiBwcmVwYXJhdGlvbiBmb3IgYWRkaW5nIG1vcmUgZmxh Z3MsIHRoaXMgcGF0Y2ggcmVuYW1lcyB0aGUKPiBkZWJ1Z19mbGFncyBmaWVsZCB0byBzaW1wbHkg ImZsYWdzIiwgYW5kIHVwZGF0ZXMgY29tbWVudHMKPiBhcHByb3ByaWF0ZWx5Lgo+Cj4gVGhlIGZs YWcgZGVmaW5pdGlvbnMgYXJlIGFsc28gbW92ZWQgdG8gPGFzbS9rdm1faG9zdC5oPiwgc2luY2UK PiB0aGVpciBwcmVzZW5jZSBpbiA8YXNtL2t2bV9hc20uaD4gd2FzIGZvciBwdXJlbHkgaGlzdG9y aWNhbAo+IHJlYXNvbnM6ICB0aGVzZSBkZWZpbml0aW9ucyBhcmUgbm90IHVzZWQgZnJvbSBhc20g YW55IG1vcmUsIGFuZCBub3QKPiB2ZXJ5IGxpa2VseSB0byBiZSBhcyBtb3JlIEh5cCBhc20gaXMg bWlncmF0ZWQgdG8gQy4KPgo+IEtWTV9BUk02NF9ERUJVR19ESVJUWV9TSElGVCBoYXMgbm90IGJl ZW4gdXNlZCBzaW5jZSBjb21taXQKPiAxZWE2NmQyN2U3YjAgKCJhcm02NDogS1ZNOiBNb3ZlIGF3 YXkgZnJvbSB0aGUgYXNzZW1ibHkgdmVyc2lvbiBvZgo+IHRoZSB3b3JsZCBzd2l0Y2giKSwgc28g dGhpcyBwYXRjaCBnZXRzIHJpZCBvZiB0aGF0IHRvby4KPgo+IE5vIGZ1bmN0aW9uYWwgY2hhbmdl Lgo+Cj4gU2lnbmVkLW9mZi1ieTogRGF2ZSBNYXJ0aW4gPERhdmUuTWFydGluQGFybS5jb20+Cj4g UmV2aWV3ZWQtYnk6IE1hcmMgWnluZ2llciA8bWFyYy56eW5naWVyQGFybS5jb20+Cj4gQWNrZWQt Ynk6IENocmlzdG9mZmVyIERhbGwgPGNocmlzdG9mZmVyLmRhbGxAYXJtLmNvbT4KClJldmlld2Vk LWJ5OiBBbGV4IEJlbm7DqWUgPGFsZXguYmVubmVlQGxpbmFyby5vcmc+Cgo+IC0tLQo+ICBhcmNo L2FybTY0L2luY2x1ZGUvYXNtL2t2bV9hc20uaCAgfCAzIC0tLQo+ICBhcmNoL2FybTY0L2luY2x1 ZGUvYXNtL2t2bV9ob3N0LmggfCA3ICsrKysrLS0KPiAgYXJjaC9hcm02NC9rdm0vZGVidWcuYyAg ICAgICAgICAgIHwgOCArKysrLS0tLQo+ICBhcmNoL2FybTY0L2t2bS9oeXAvZGVidWctc3IuYyAg ICAgfCA2ICsrKy0tLQo+ICBhcmNoL2FybTY0L2t2bS9oeXAvc3lzcmVnLXNyLmMgICAgfCA0ICsr LS0KPiAgYXJjaC9hcm02NC9rdm0vc3lzX3JlZ3MuYyAgICAgICAgIHwgOSArKysrLS0tLS0KPiAg NiBmaWxlcyBjaGFuZ2VkLCAxOCBpbnNlcnRpb25zKCspLCAxOSBkZWxldGlvbnMoLSkKPgo+IGRp ZmYgLS1naXQgYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9hc20uaCBiL2FyY2gvYXJtNjQv aW5jbHVkZS9hc20va3ZtX2FzbS5oCj4gaW5kZXggZjY2NDhhMy4uZjYyY2NiZiAxMDA2NDQKPiAt LS0gYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9hc20uaAo+ICsrKyBiL2FyY2gvYXJtNjQv aW5jbHVkZS9hc20va3ZtX2FzbS5oCj4gQEAgLTMwLDkgKzMwLDYgQEAKPiAgLyogVGhlIGh5cC1z dHViIHdpbGwgcmV0dXJuIHRoaXMgZm9yIGFueSBrdm1fY2FsbF9oeXAoKSBjYWxsICovCj4gICNk ZWZpbmUgQVJNX0VYQ0VQVElPTl9IWVBfR09ORQkgIEhWQ19TVFVCX0VSUgo+Cj4gLSNkZWZpbmUg S1ZNX0FSTTY0X0RFQlVHX0RJUlRZX1NISUZUCTAKPiAtI2RlZmluZSBLVk1fQVJNNjRfREVCVUdf RElSVFkJCSgxIDw8IEtWTV9BUk02NF9ERUJVR19ESVJUWV9TSElGVCkKPiAtCj4gIC8qIFRyYW5z bGF0ZSBhIGtlcm5lbCBhZGRyZXNzIG9mIEBzeW0gaW50byBpdHMgZXF1aXZhbGVudCBsaW5lYXIg bWFwcGluZyAqLwo+ICAjZGVmaW5lIGt2bV9rc3ltX3JlZihzeW0pCQkJCQkJXAo+ICAJKHsJCQkJ CQkJCVwKPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1faG9zdC5oIGIv YXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1faG9zdC5oCj4gaW5kZXggNDY5ZGU4YS4uMTQ2YzE2 NyAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKPiArKysg Yi9hcmNoL2FybTY0L2luY2x1ZGUvYXNtL2t2bV9ob3N0LmgKPiBAQCAtMjE2LDggKzIxNiw4IEBA IHN0cnVjdCBrdm1fdmNwdV9hcmNoIHsKPiAgCS8qIEV4Y2VwdGlvbiBJbmZvcm1hdGlvbiAqLwo+ ICAJc3RydWN0IGt2bV92Y3B1X2ZhdWx0X2luZm8gZmF1bHQ7Cj4KPiAtCS8qIEd1ZXN0IGRlYnVn IHN0YXRlICovCj4gLQl1NjQgZGVidWdfZmxhZ3M7Cj4gKwkvKiBNaXNjZWxsYW5lb3VzIHZjcHUg c3RhdGUgZmxhZ3MgKi8KPiArCXU2NCBmbGFnczsKPgo+ICAJLyoKPiAgCSAqIFdlIG1haW50YWlu IG1vcmUgdGhhbiBhIHNpbmdsZSBzZXQgb2YgZGVidWcgcmVnaXN0ZXJzIHRvIHN1cHBvcnQKPiBA QCAtMjkzLDYgKzI5Myw5IEBAIHN0cnVjdCBrdm1fdmNwdV9hcmNoIHsKPiAgCWJvb2wgc3lzcmVn c19sb2FkZWRfb25fY3B1Owo+ICB9Owo+Cj4gKy8qIHZjcHVfYXJjaCBmbGFncyBmaWVsZCB2YWx1 ZXM6ICovCj4gKyNkZWZpbmUgS1ZNX0FSTTY0X0RFQlVHX0RJUlRZCQkoMSA8PCAwKQo+ICsKPiAg I2RlZmluZSB2Y3B1X2dwX3JlZ3ModikJCSgmKHYpLT5hcmNoLmN0eHQuZ3BfcmVncykKPgo+ICAv Kgo+IGRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2t2bS9kZWJ1Zy5jIGIvYXJjaC9hcm02NC9rdm0v ZGVidWcuYwo+IGluZGV4IGExZjRlYmQuLjAwZDQyMjMgMTAwNjQ0Cj4gLS0tIGEvYXJjaC9hcm02 NC9rdm0vZGVidWcuYwo+ICsrKyBiL2FyY2gvYXJtNjQva3ZtL2RlYnVnLmMKPiBAQCAtMTAzLDcg KzEwMyw3IEBAIHZvaWQga3ZtX2FybV9yZXNldF9kZWJ1Z19wdHIoc3RydWN0IGt2bV92Y3B1ICp2 Y3B1KQo+ICAgKgo+ICAgKiBBZGRpdGlvbmFsbHksIEtWTSBvbmx5IHRyYXBzIGd1ZXN0IGFjY2Vz c2VzIHRvIHRoZSBkZWJ1ZyByZWdpc3RlcnMgaWYKPiAgICogdGhlIGd1ZXN0IGlzIG5vdCBhY3Rp dmVseSB1c2luZyB0aGVtIChzZWUgdGhlIEtWTV9BUk02NF9ERUJVR19ESVJUWQo+IC0gKiBmbGFn IG9uIHZjcHUtPmFyY2guZGVidWdfZmxhZ3MpLiAgU2luY2UgdGhlIGd1ZXN0IG11c3Qgbm90IGlu dGVyZmVyZQo+ICsgKiBmbGFnIG9uIHZjcHUtPmFyY2guZmxhZ3MpLiAgU2luY2UgdGhlIGd1ZXN0 IG11c3Qgbm90IGludGVyZmVyZQo+ICAgKiB3aXRoIHRoZSBoYXJkd2FyZSBzdGF0ZSB3aGVuIGRl YnVnZ2luZyB0aGUgZ3Vlc3QsIHdlIG11c3QgZW5zdXJlIHRoYXQKPiAgICogdHJhcHBpbmcgaXMg ZW5hYmxlZCB3aGVuZXZlciB3ZSBhcmUgZGVidWdnaW5nIHRoZSBndWVzdCB1c2luZyB0aGUKPiAg ICogZGVidWcgcmVnaXN0ZXJzLgo+IEBAIC0xMTEsNyArMTExLDcgQEAgdm9pZCBrdm1fYXJtX3Jl c2V0X2RlYnVnX3B0cihzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCj4KPiAgdm9pZCBrdm1fYXJtX3Nl dHVwX2RlYnVnKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSkKPiAgewo+IC0JYm9vbCB0cmFwX2RlYnVn ID0gISh2Y3B1LT5hcmNoLmRlYnVnX2ZsYWdzICYgS1ZNX0FSTTY0X0RFQlVHX0RJUlRZKTsKPiAr CWJvb2wgdHJhcF9kZWJ1ZyA9ICEodmNwdS0+YXJjaC5mbGFncyAmIEtWTV9BUk02NF9ERUJVR19E SVJUWSk7Cj4gIAl1bnNpZ25lZCBsb25nIG1kc2NyOwo+Cj4gIAl0cmFjZV9rdm1fYXJtX3NldHVw X2RlYnVnKHZjcHUsIHZjcHUtPmd1ZXN0X2RlYnVnKTsKPiBAQCAtMTg0LDcgKzE4NCw3IEBAIHZv aWQga3ZtX2FybV9zZXR1cF9kZWJ1ZyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCj4gIAkJCXZjcHVf d3JpdGVfc3lzX3JlZyh2Y3B1LCBtZHNjciwgTURTQ1JfRUwxKTsKPgo+ICAJCQl2Y3B1LT5hcmNo LmRlYnVnX3B0ciA9ICZ2Y3B1LT5hcmNoLmV4dGVybmFsX2RlYnVnX3N0YXRlOwo+IC0JCQl2Y3B1 LT5hcmNoLmRlYnVnX2ZsYWdzIHw9IEtWTV9BUk02NF9ERUJVR19ESVJUWTsKPiArCQkJdmNwdS0+ YXJjaC5mbGFncyB8PSBLVk1fQVJNNjRfREVCVUdfRElSVFk7Cj4gIAkJCXRyYXBfZGVidWcgPSB0 cnVlOwo+Cj4gIAkJCXRyYWNlX2t2bV9hcm1fc2V0X3JlZ3NldCgiQktQVFMiLCBnZXRfbnVtX2Jy cHMoKSwKPiBAQCAtMjA2LDcgKzIwNiw3IEBAIHZvaWQga3ZtX2FybV9zZXR1cF9kZWJ1ZyhzdHJ1 Y3Qga3ZtX3ZjcHUgKnZjcHUpCj4KPiAgCS8qIElmIEtERSBvciBNREUgYXJlIHNldCwgcGVyZm9y bSBhIGZ1bGwgc2F2ZS9yZXN0b3JlIGN5Y2xlLiAqLwo+ICAJaWYgKHZjcHVfcmVhZF9zeXNfcmVn KHZjcHUsIE1EU0NSX0VMMSkgJiAoREJHX01EU0NSX0tERSB8IERCR19NRFNDUl9NREUpKQo+IC0J CXZjcHUtPmFyY2guZGVidWdfZmxhZ3MgfD0gS1ZNX0FSTTY0X0RFQlVHX0RJUlRZOwo+ICsJCXZj cHUtPmFyY2guZmxhZ3MgfD0gS1ZNX0FSTTY0X0RFQlVHX0RJUlRZOwo+Cj4gIAl0cmFjZV9rdm1f YXJtX3NldF9kcmVnMzIoIk1EQ1JfRUwyIiwgdmNwdS0+YXJjaC5tZGNyX2VsMik7Cj4gIAl0cmFj ZV9rdm1fYXJtX3NldF9kcmVnMzIoIk1EU0NSX0VMMSIsIHZjcHVfcmVhZF9zeXNfcmVnKHZjcHUs IE1EU0NSX0VMMSkpOwo+IGRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2t2bS9oeXAvZGVidWctc3Iu YyBiL2FyY2gvYXJtNjQva3ZtL2h5cC9kZWJ1Zy1zci5jCj4gaW5kZXggM2U3MTdmNi4uNTAwMDk3 NiAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybTY0L2t2bS9oeXAvZGVidWctc3IuYwo+ICsrKyBiL2Fy Y2gvYXJtNjQva3ZtL2h5cC9kZWJ1Zy1zci5jCj4gQEAgLTE2Myw3ICsxNjMsNyBAQCB2b2lkIF9f aHlwX3RleHQgX19kZWJ1Z19zd2l0Y2hfdG9fZ3Vlc3Qoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQo+ ICAJaWYgKCFoYXNfdmhlKCkpCj4gIAkJX19kZWJ1Z19zYXZlX3NwZV9udmhlKCZ2Y3B1LT5hcmNo Lmhvc3RfZGVidWdfc3RhdGUucG1zY3JfZWwxKTsKPgo+IC0JaWYgKCEodmNwdS0+YXJjaC5kZWJ1 Z19mbGFncyAmIEtWTV9BUk02NF9ERUJVR19ESVJUWSkpCj4gKwlpZiAoISh2Y3B1LT5hcmNoLmZs YWdzICYgS1ZNX0FSTTY0X0RFQlVHX0RJUlRZKSkKPiAgCQlyZXR1cm47Cj4KPiAgCWhvc3RfY3R4 dCA9IGtlcm5faHlwX3ZhKHZjcHUtPmFyY2guaG9zdF9jcHVfY29udGV4dCk7Cj4gQEAgLTE4NSw3 ICsxODUsNyBAQCB2b2lkIF9faHlwX3RleHQgX19kZWJ1Z19zd2l0Y2hfdG9faG9zdChzdHJ1Y3Qg a3ZtX3ZjcHUgKnZjcHUpCj4gIAlpZiAoIWhhc192aGUoKSkKPiAgCQlfX2RlYnVnX3Jlc3RvcmVf c3BlX252aGUodmNwdS0+YXJjaC5ob3N0X2RlYnVnX3N0YXRlLnBtc2NyX2VsMSk7Cj4KPiAtCWlm ICghKHZjcHUtPmFyY2guZGVidWdfZmxhZ3MgJiBLVk1fQVJNNjRfREVCVUdfRElSVFkpKQo+ICsJ aWYgKCEodmNwdS0+YXJjaC5mbGFncyAmIEtWTV9BUk02NF9ERUJVR19ESVJUWSkpCj4gIAkJcmV0 dXJuOwo+Cj4gIAlob3N0X2N0eHQgPSBrZXJuX2h5cF92YSh2Y3B1LT5hcmNoLmhvc3RfY3B1X2Nv bnRleHQpOwo+IEBAIC0xOTYsNyArMTk2LDcgQEAgdm9pZCBfX2h5cF90ZXh0IF9fZGVidWdfc3dp dGNoX3RvX2hvc3Qoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQo+ICAJX19kZWJ1Z19zYXZlX3N0YXRl KHZjcHUsIGd1ZXN0X2RiZywgZ3Vlc3RfY3R4dCk7Cj4gIAlfX2RlYnVnX3Jlc3RvcmVfc3RhdGUo dmNwdSwgaG9zdF9kYmcsIGhvc3RfY3R4dCk7Cj4KPiAtCXZjcHUtPmFyY2guZGVidWdfZmxhZ3Mg Jj0gfktWTV9BUk02NF9ERUJVR19ESVJUWTsKPiArCXZjcHUtPmFyY2guZmxhZ3MgJj0gfktWTV9B Uk02NF9ERUJVR19ESVJUWTsKPiAgfQo+Cj4gIHUzMiBfX2h5cF90ZXh0IF9fa3ZtX2dldF9tZGNy X2VsMih2b2lkKQo+IGRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2t2bS9oeXAvc3lzcmVnLXNyLmMg Yi9hcmNoL2FybTY0L2t2bS9oeXAvc3lzcmVnLXNyLmMKPiBpbmRleCBiMzg5NGRmLi4zNWJjMTY4 IDEwMDY0NAo+IC0tLSBhL2FyY2gvYXJtNjQva3ZtL2h5cC9zeXNyZWctc3IuYwo+ICsrKyBiL2Fy Y2gvYXJtNjQva3ZtL2h5cC9zeXNyZWctc3IuYwo+IEBAIC0xOTYsNyArMTk2LDcgQEAgdm9pZCBf X2h5cF90ZXh0IF9fc3lzcmVnMzJfc2F2ZV9zdGF0ZShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUpCj4g IAlzeXNyZWdbREFDUjMyX0VMMl0gPSByZWFkX3N5c3JlZyhkYWNyMzJfZWwyKTsKPiAgCXN5c3Jl Z1tJRlNSMzJfRUwyXSA9IHJlYWRfc3lzcmVnKGlmc3IzMl9lbDIpOwo+Cj4gLQlpZiAoaGFzX3Zo ZSgpIHx8IHZjcHUtPmFyY2guZGVidWdfZmxhZ3MgJiBLVk1fQVJNNjRfREVCVUdfRElSVFkpCj4g KwlpZiAoaGFzX3ZoZSgpIHx8IHZjcHUtPmFyY2guZmxhZ3MgJiBLVk1fQVJNNjRfREVCVUdfRElS VFkpCj4gIAkJc3lzcmVnW0RCR1ZDUjMyX0VMMl0gPSByZWFkX3N5c3JlZyhkYmd2Y3IzMl9lbDIp Owo+ICB9Cj4KPiBAQCAtMjE4LDcgKzIxOCw3IEBAIHZvaWQgX19oeXBfdGV4dCBfX3N5c3JlZzMy X3Jlc3RvcmVfc3RhdGUoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQo+ICAJd3JpdGVfc3lzcmVnKHN5 c3JlZ1tEQUNSMzJfRUwyXSwgZGFjcjMyX2VsMik7Cj4gIAl3cml0ZV9zeXNyZWcoc3lzcmVnW0lG U1IzMl9FTDJdLCBpZnNyMzJfZWwyKTsKPgo+IC0JaWYgKGhhc192aGUoKSB8fCB2Y3B1LT5hcmNo LmRlYnVnX2ZsYWdzICYgS1ZNX0FSTTY0X0RFQlVHX0RJUlRZKQo+ICsJaWYgKGhhc192aGUoKSB8 fCB2Y3B1LT5hcmNoLmZsYWdzICYgS1ZNX0FSTTY0X0RFQlVHX0RJUlRZKQo+ICAJCXdyaXRlX3N5 c3JlZyhzeXNyZWdbREJHVkNSMzJfRUwyXSwgZGJndmNyMzJfZWwyKTsKPiAgfQo+Cj4gZGlmZiAt LWdpdCBhL2FyY2gvYXJtNjQva3ZtL3N5c19yZWdzLmMgYi9hcmNoL2FybTY0L2t2bS9zeXNfcmVn cy5jCj4gaW5kZXggNmUzYjk2OS4uYTQzNjM3MyAxMDA2NDQKPiAtLS0gYS9hcmNoL2FybTY0L2t2 bS9zeXNfcmVncy5jCj4gKysrIGIvYXJjaC9hcm02NC9rdm0vc3lzX3JlZ3MuYwo+IEBAIC0zMSw3 ICszMSw2IEBACj4gICNpbmNsdWRlIDxhc20vZGVidWctbW9uaXRvcnMuaD4KPiAgI2luY2x1ZGUg PGFzbS9lc3IuaD4KPiAgI2luY2x1ZGUgPGFzbS9rdm1fYXJtLmg+Cj4gLSNpbmNsdWRlIDxhc20v a3ZtX2FzbS5oPgo+ICAjaW5jbHVkZSA8YXNtL2t2bV9jb3Byb2MuaD4KPiAgI2luY2x1ZGUgPGFz bS9rdm1fZW11bGF0ZS5oPgo+ICAjaW5jbHVkZSA8YXNtL2t2bV9ob3N0Lmg+Cj4gQEAgLTMzOCw3 ICszMzcsNyBAQCBzdGF0aWMgYm9vbCB0cmFwX2RlYnVnX3JlZ3Moc3RydWN0IGt2bV92Y3B1ICp2 Y3B1LAo+ICB7Cj4gIAlpZiAocC0+aXNfd3JpdGUpIHsKPiAgCQl2Y3B1X3dyaXRlX3N5c19yZWco dmNwdSwgcC0+cmVndmFsLCByLT5yZWcpOwo+IC0JCXZjcHUtPmFyY2guZGVidWdfZmxhZ3MgfD0g S1ZNX0FSTTY0X0RFQlVHX0RJUlRZOwo+ICsJCXZjcHUtPmFyY2guZmxhZ3MgfD0gS1ZNX0FSTTY0 X0RFQlVHX0RJUlRZOwo+ICAJfSBlbHNlIHsKPiAgCQlwLT5yZWd2YWwgPSB2Y3B1X3JlYWRfc3lz X3JlZyh2Y3B1LCByLT5yZWcpOwo+ICAJfQo+IEBAIC0zNjksNyArMzY4LDcgQEAgc3RhdGljIHZv aWQgcmVnX3RvX2RiZyhzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsCj4gIAl9Cj4KPiAgCSpkYmdfcmVn ID0gdmFsOwo+IC0JdmNwdS0+YXJjaC5kZWJ1Z19mbGFncyB8PSBLVk1fQVJNNjRfREVCVUdfRElS VFk7Cj4gKwl2Y3B1LT5hcmNoLmZsYWdzIHw9IEtWTV9BUk02NF9ERUJVR19ESVJUWTsKPiAgfQo+ Cj4gIHN0YXRpYyB2b2lkIGRiZ190b19yZWcoc3RydWN0IGt2bV92Y3B1ICp2Y3B1LAo+IEBAIC0x NDQxLDcgKzE0NDAsNyBAQCBzdGF0aWMgYm9vbCB0cmFwX2RlYnVnMzIoc3RydWN0IGt2bV92Y3B1 ICp2Y3B1LAo+ICB7Cj4gIAlpZiAocC0+aXNfd3JpdGUpIHsKPiAgCQl2Y3B1X2NwMTQodmNwdSwg ci0+cmVnKSA9IHAtPnJlZ3ZhbDsKPiAtCQl2Y3B1LT5hcmNoLmRlYnVnX2ZsYWdzIHw9IEtWTV9B Uk02NF9ERUJVR19ESVJUWTsKPiArCQl2Y3B1LT5hcmNoLmZsYWdzIHw9IEtWTV9BUk02NF9ERUJV R19ESVJUWTsKPiAgCX0gZWxzZSB7Cj4gIAkJcC0+cmVndmFsID0gdmNwdV9jcDE0KHZjcHUsIHIt PnJlZyk7Cj4gIAl9Cj4gQEAgLTE0NzMsNyArMTQ3Miw3IEBAIHN0YXRpYyBib29sIHRyYXBfeHZy KHN0cnVjdCBrdm1fdmNwdSAqdmNwdSwKPiAgCQl2YWwgfD0gcC0+cmVndmFsIDw8IDMyOwo+ICAJ CSpkYmdfcmVnID0gdmFsOwo+Cj4gLQkJdmNwdS0+YXJjaC5kZWJ1Z19mbGFncyB8PSBLVk1fQVJN NjRfREVCVUdfRElSVFk7Cj4gKwkJdmNwdS0+YXJjaC5mbGFncyB8PSBLVk1fQVJNNjRfREVCVUdf RElSVFk7Cj4gIAl9IGVsc2Ugewo+ICAJCXAtPnJlZ3ZhbCA9ICpkYmdfcmVnID4+IDMyOwo+ICAJ fQoKCi0tCkFsZXggQmVubsOpZQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5l bEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4v bGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo= 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 10:21:20 +0100 Subject: [PATCH v10 09/18] KVM: arm64: Repurpose vcpu_arch.debug_flags for general-purpose flags In-Reply-To: <1527005119-6842-10-git-send-email-Dave.Martin@arm.com> References: <1527005119-6842-1-git-send-email-Dave.Martin@arm.com> <1527005119-6842-10-git-send-email-Dave.Martin@arm.com> Message-ID: <87a7sptnn3.fsf@linaro.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Dave Martin writes: > 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 > Acked-by: Christoffer Dall Reviewed-by: Alex Benn?e > --- > 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; > } -- Alex Benn?e