From mboxrd@z Thu Jan 1 00:00:00 1970 From: Alex =?utf-8?Q?Benn=C3=A9e?= Subject: Re: [PATCH v6 10/12] KVM: arm64: guest debug, HW assisted debug support Date: Thu, 25 Jun 2015 07:38:33 +0100 Message-ID: <87mvzoxpg6.fsf@linaro.org> References: <1434716630-18260-1-git-send-email-alex.bennee@linaro.org> <1434716630-18260-11-git-send-email-alex.bennee@linaro.org> <20150624202216.GE22785@cbox> 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 C29E756F59 for ; Thu, 25 Jun 2015 02:26:57 -0400 (EDT) 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 vg7Sd3AWuhyn for ; Thu, 25 Jun 2015 02:26:56 -0400 (EDT) Received: from mail-wg0-f47.google.com (mail-wg0-f47.google.com [74.125.82.47]) by mm01.cs.columbia.edu (Postfix) with ESMTPS id 6578F56F52 for ; Thu, 25 Jun 2015 02:26:56 -0400 (EDT) Received: by wgbhy7 with SMTP id hy7so53699033wgb.2 for ; Wed, 24 Jun 2015 23:37:54 -0700 (PDT) In-reply-to: <20150624202216.GE22785@cbox> 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: Christoffer Dall Cc: kvm@vger.kernel.org, "open list:DOCUMENTATION" , Peter Zijlstra , jan.kiszka@siemens.com, Will Deacon , Ingo Molnar , Lorenzo Pieralisi , Russell King , Jonathan Corbet , kvmarm@lists.cs.columbia.edu, Gleb Natapov , zhichao.huang@linaro.org, Catalin Marinas , bp@suse.de, marc.zyngier@arm.com, r65777@freescale.com, linux-arm-kernel@lists.infradead.org, "open list:ABI/API" , open list , dahi@linux.vnet.ibm.com, pbonzini@redhat.com List-Id: kvmarm@lists.cs.columbia.edu CkNocmlzdG9mZmVyIERhbGwgPGNocmlzdG9mZmVyLmRhbGxAbGluYXJvLm9yZz4gd3JpdGVzOgoK PiBPbiBGcmksIEp1biAxOSwgMjAxNSBhdCAwMToyMzo0OFBNICswMTAwLCBBbGV4IEJlbm7DqWUg d3JvdGU6Cj4+IFRoaXMgYWRkcyBzdXBwb3J0IGZvciB1c2Vyc3BhY2UgdG8gY29udHJvbCB0aGUg SFcgZGVidWcgcmVnaXN0ZXJzIGZvcgo+PiBndWVzdCBkZWJ1Zy4gSW4gdGhlIGRlYnVnIGlvY3Rs IHdlIGNvcHkgdGhlIElNUERFRiBkZWZpbmVkIG51bWJlciBvZgo+Cj4gcy9kZWZpbmVkLy8KPgo+ PiByZWdpc3RlcnMgaW50byBhIG5ldyByZWdpc3RlciBzZXQgY2FsbGVkIGhvc3RfZGVidWdfc3Rh dGUuIFRoZXJlIGlzIG5vdwo+PiBhIG5ldyB2Y3B1IHBhcmFtZXRlciBjYWxsZWQgZGVidWdfcHRy IHdoaWNoIHNlbGVjdHMgd2hpY2ggcmVnaXN0ZXIgc2V0Cj4+IGlzIHRvIGNvcGllZCBpbnRvIHRo ZSByZWFsIHJlZ2lzdGVycyB3aGVuIHdvcmxkIHN3aXRjaCBvY2N1cnMuCj4KPiBCdXQgdGhpcyBw YXRjaCBkb2Vzbid0IHNlZW0gdG8gYWRkIHRoZSBkZWJ1Z19wdHIgZmllbGQ/CgpPb3BzLCB5ZXMg dGhlIGNvbW1lbnQgYmVsb25ncyB0byB0aGUgcHJldmlvdXMgcGF0Y2guCgo+Cj4gcy90by8vCj4K Pj4gCj4+IEkndmUgbW92ZWQgc29tZSBoZWxwZXIgZnVuY3Rpb25zIGludG8gdGhlIGh3X2JyZWFr cG9pbnQuaCBoZWFkZXIgZm9yCj4+IHJlLXVzZS4KPj4gCj4+IEFzIHdpdGggc2luZ2xlIHN0ZXAg d2UgbmVlZCB0byB0d2VhayB0aGUgZ3Vlc3QgcmVnaXN0ZXJzIHRvIGVuYWJsZSB0aGUKPj4gZXhj ZXB0aW9ucyBzbyB3ZSBuZWVkIHRvIHNhdmUgYW5kIHJlc3RvcmUgdGhvc2UgYml0cy4KPj4gCj4+ IFR3byBuZXcgY2FwYWJpbGl0aWVzIGhhdmUgYmVlbiBhZGRlZCB0byB0aGUgS1ZNX0VYVEVOU0lP TiBpb2N0bCB0byBhbGxvdwo+PiB1c2Vyc3BhY2UgdG8gcXVlcnkgdGhlIG51bWJlciBvZiBoYXJk d2FyZSBicmVhayBhbmQgd2F0Y2ggcG9pbnRzCj4+IGF2YWlsYWJsZSBvbiB0aGUgaG9zdCBoYXJk d2FyZS4KPj4gCj4+IFNpZ25lZC1vZmYtYnk6IEFsZXggQmVubsOpZSA8YWxleC5iZW5uZWVAbGlu YXJvLm9yZz4KPj4gCj4+IC0tLQo+PiB2Mgo+PiAgICAtIHN3aXRjaGVkIHRvIEMgc2V0dXAKPj4g ICAgLSByZXBsYWNlIGhvc3QgZGVidWcgcmVnaXN0ZXJzIGRpcmVjdGx5IGludG8gY29udGV4dAo+ PiAgICAtIG1pbm9yIHR3ZWFrIHRvIGFwaSBkb2NzCj4+ICAgIC0gc2V0dXAgcmlnaHQgcmVnaXN0 ZXIgZm9yIGRlYnVnCj4+ICAgIC0gYWRkIEZBUl9FTDIgdG8gZGVidWcgZXhpdCBzdHJ1Y3R1cmUK Pj4gICAgLSBhZGQgc3VwcG9ydCBmb3IgdHJhcHBpbmcgZGVidWcgcmVnaXN0ZXIgYWNjZXNzCj4+ IHYzCj4+ICAgIC0gcmVtb3ZlIHN0cmF5IHRyYWNlIHN0YXRlbWVudAo+PiAgICAtIGZpeCBzcGFj aW5nIGFyb3VuZCBvcGVyYXRvcnMgKHZhcmlvdXMpCj4+ICAgIC0gY2xlYW4tdXAgdXNhZ2Ugb2Yg dHJhcF9kZWJ1Zwo+PiAgICAtIGludHJvZHVjZSBkZWJ1Z19wdHIsIHJlcGxhY2UgZXhjZXNzaXZl IG1lbWNweSBzdHVmZgo+PiAgICAtIGRvbid0IHVzZSBtZW1jcHkgaW4gaW9jdGwsIGp1c3QgYXNz aWduCj4+ICAgIC0gdXBkYXRlIGNhcCBpb2N0bCBkb2N1bWVudGF0aW9uCj4+ICAgIC0gcmV3b3Jk IGEgbnVtYmVyIGNvbW1lbnRzCj4+ICAgIC0gcmVuYW1lIGhvc3RfZGVidWdfc3RhdGUtPmV4dGVy bmFsX2RlYnVnX3N0YXRlCj4+IHY0Cj4+ICAgIC0gdXNlIHRoZSBuZXcgdTMyL3U2NCBzcGxpdCBk ZWJ1Z19wdHIgYXBwcm9hY2gKPj4gICAgLSBmaXggc29tZSB3b3JkaW5nL2NvbW1lbnRzCj4+IHY1 Cj4+ICAgIC0gZG9uJ3Qgc2V0IE1EU0NSX0VMMS5LREUgKG5vdCBuZWVkZWQpCj4+IHY2Cj4+ICAg IC0gdXBkYXRlIHdvcmRpbmcgZ2l2ZW4gY2hhbmdlIGluIGNvbW1lbnRhcnkKPj4gICAgLSBLVk1f R1VFU1REQkdfVVNFX0hXX0JQLT5LVk1fR1VFU1REQkdfVVNFX0hXCj4+IC0tLQo+PiAgRG9jdW1l bnRhdGlvbi92aXJ0dWFsL2t2bS9hcGkudHh0ICAgICAgfCAgNyArKysrKystCj4+ICBhcmNoL2Fy bS9rdm0vYXJtLmMgICAgICAgICAgICAgICAgICAgICB8ICA3ICsrKysrKysKPj4gIGFyY2gvYXJt NjQvaW5jbHVkZS9hc20vaHdfYnJlYWtwb2ludC5oIHwgMTIgKysrKysrKysrKysKPj4gIGFyY2gv YXJtNjQvaW5jbHVkZS9hc20va3ZtX2hvc3QuaCAgICAgIHwgIDYgKysrKystCj4+ICBhcmNoL2Fy bTY0L2tlcm5lbC9od19icmVha3BvaW50LmMgICAgICB8IDEyIC0tLS0tLS0tLS0tCj4+ICBhcmNo L2FybTY0L2t2bS9kZWJ1Zy5jICAgICAgICAgICAgICAgICB8IDM3ICsrKysrKysrKysrKysrKysr KysrKysrKysrKysrLS0tLS0KPj4gIGFyY2gvYXJtNjQva3ZtL2hhbmRsZV9leGl0LmMgICAgICAg ICAgIHwgIDYgKysrKysrCj4+ICBhcmNoL2FybTY0L2t2bS9yZXNldC5jICAgICAgICAgICAgICAg ICB8IDEyICsrKysrKysrKysrCj4+ICBpbmNsdWRlL3VhcGkvbGludXgva3ZtLmggICAgICAgICAg ICAgICB8ICAyICsrCj4+ICA5IGZpbGVzIGNoYW5nZWQsIDgyIGluc2VydGlvbnMoKyksIDE5IGRl bGV0aW9ucygtKQo+PiAKPj4gZGlmZiAtLWdpdCBhL0RvY3VtZW50YXRpb24vdmlydHVhbC9rdm0v YXBpLnR4dCBiL0RvY3VtZW50YXRpb24vdmlydHVhbC9rdm0vYXBpLnR4dAo+PiBpbmRleCAzM2M4 MTQzLi5hZGE1N2RmIDEwMDY0NAo+PiAtLS0gYS9Eb2N1bWVudGF0aW9uL3ZpcnR1YWwva3ZtL2Fw aS50eHQKPj4gKysrIGIvRG9jdW1lbnRhdGlvbi92aXJ0dWFsL2t2bS9hcGkudHh0Cj4+IEBAIC0y NjY4LDcgKzI2NjgsNyBAQCBUaGUgdG9wIDE2IGJpdHMgb2YgdGhlIGNvbnRyb2wgZmllbGQgYXJl IGFyY2hpdGVjdHVyZSBzcGVjaWZpYyBjb250cm9sCj4+ICBmbGFncyB3aGljaCBjYW4gaW5jbHVk ZSB0aGUgZm9sbG93aW5nOgo+PiAgCj4+ICAgIC0gS1ZNX0dVRVNUREJHX1VTRV9TV19CUDogICAg IHVzaW5nIHNvZnR3YXJlIGJyZWFrcG9pbnRzIFt4ODYsIGFybTY0XQo+PiAtICAtIEtWTV9HVUVT VERCR19VU0VfSFdfQlA6ICAgICB1c2luZyBoYXJkd2FyZSBicmVha3BvaW50cyBbeDg2LCBzMzkw XQo+PiArICAtIEtWTV9HVUVTVERCR19VU0VfSFdfQlA6ICAgICB1c2luZyBoYXJkd2FyZSBicmVh a3BvaW50cyBbeDg2LCBzMzkwLCBhcm02NF0KPj4gICAgLSBLVk1fR1VFU1REQkdfSU5KRUNUX0RC OiAgICAgaW5qZWN0IERCIHR5cGUgZXhjZXB0aW9uIFt4ODZdCj4+ICAgIC0gS1ZNX0dVRVNUREJH X0lOSkVDVF9CUDogICAgIGluamVjdCBCUCB0eXBlIGV4Y2VwdGlvbiBbeDg2XQo+PiAgICAtIEtW TV9HVUVTVERCR19FWElUX1BFTkRJTkc6ICB0cmlnZ2VyIGFuIGltbWVkaWF0ZSBndWVzdCBleGl0 IFtzMzkwXQo+PiBAQCAtMjY4Myw2ICsyNjgzLDExIEBAIHVwZGF0ZWQgdG8gdGhlIGNvcnJlY3Qg KHN1cHBsaWVkKSB2YWx1ZXMuCj4+ICBUaGUgc2Vjb25kIHBhcnQgb2YgdGhlIHN0cnVjdHVyZSBp cyBhcmNoaXRlY3R1cmUgc3BlY2lmaWMgYW5kCj4+ICB0eXBpY2FsbHkgY29udGFpbnMgYSBzZXQg b2YgZGVidWcgcmVnaXN0ZXJzLgo+PiAgCj4+ICtGb3IgYXJtNjQgdGhlIG51bWJlciBvZiBkZWJ1 ZyByZWdpc3RlcnMgaXMgaW1wbGVtZW50YXRpb24gZGVmaW5lZCBhbmQKPj4gK2NhbiBiZSBkZXRl cm1pbmVkIGJ5IHF1ZXJ5aW5nIHRoZSBLVk1fQ0FQX0dVRVNUX0RFQlVHX0hXX0JQUyBhbmQKPj4g K0tWTV9DQVBfR1VFU1RfREVCVUdfSFdfV1BTIGNhcGFiaWxpdGllcyB3aGljaCByZXR1cm4gYSBw b3NpdGl2ZSBudW1iZXIKPj4gK2luZGljYXRpbmcgdGhlIG51bWJlciBvZiBzdXBwb3J0ZWQgcmVn aXN0ZXJzLgo+PiArCj4+ICBXaGVuIGRlYnVnIGV2ZW50cyBleGl0IHRoZSBtYWluIHJ1biBsb29w IHdpdGggdGhlIHJlYXNvbgo+PiAgS1ZNX0VYSVRfREVCVUcgd2l0aCB0aGUga3ZtX2RlYnVnX2V4 aXRfYXJjaCBwYXJ0IG9mIHRoZSBrdm1fcnVuCj4+ICBzdHJ1Y3R1cmUgY29udGFpbmluZyBhcmNo aXRlY3R1cmUgc3BlY2lmaWMgZGVidWcgaW5mb3JtYXRpb24uCj4+IGRpZmYgLS1naXQgYS9hcmNo L2FybS9rdm0vYXJtLmMgYi9hcmNoL2FybS9rdm0vYXJtLmMKPj4gaW5kZXggMGQxN2M3Yi4uNjBj NDA0NSAxMDA2NDQKPj4gLS0tIGEvYXJjaC9hcm0va3ZtL2FybS5jCj4+ICsrKyBiL2FyY2gvYXJt L2t2bS9hcm0uYwo+PiBAQCAtMzA3LDYgKzMwNyw3IEBAIHZvaWQga3ZtX2FyY2hfdmNwdV9wdXQo c3RydWN0IGt2bV92Y3B1ICp2Y3B1KQo+PiAgCj4+ICAjZGVmaW5lIEtWTV9HVUVTVERCR19WQUxJ RF9NQVNLIChLVk1fR1VFU1REQkdfRU5BQkxFIHwgICAgXAo+PiAgCQkJICAgIEtWTV9HVUVTVERC R19VU0VfU1dfQlAgfCBcCj4+ICsJCQkgICAgS1ZNX0dVRVNUREJHX1VTRV9IVyB8IFwKPj4gIAkJ CSAgICBLVk1fR1VFU1REQkdfU0lOR0xFU1RFUCkKPj4gIAo+PiAgLyoqCj4+IEBAIC0zMjcsNiAr MzI4LDEyIEBAIGludCBrdm1fYXJjaF92Y3B1X2lvY3RsX3NldF9ndWVzdF9kZWJ1ZyhzdHJ1Y3Qg a3ZtX3ZjcHUgKnZjcHUsCj4+ICAKPj4gIAlpZiAoZGJnLT5jb250cm9sICYgS1ZNX0dVRVNUREJH X0VOQUJMRSkgewo+PiAgCQl2Y3B1LT5ndWVzdF9kZWJ1ZyA9IGRiZy0+Y29udHJvbDsKPj4gKwo+ PiArCQkvKiBIYXJkd2FyZSBhc3Npc3RlZCBCcmVhayBhbmQgV2F0Y2ggcG9pbnRzICovCj4+ICsJ CWlmICh2Y3B1LT5ndWVzdF9kZWJ1ZyAmIEtWTV9HVUVTVERCR19VU0VfSFcpIHsKPj4gKwkJCXZj cHUtPmFyY2guZXh0ZXJuYWxfZGVidWdfc3RhdGUgPSBkYmctPmFyY2g7Cj4+ICsJCX0KPj4gKwo+ PiAgCX0gZWxzZSB7Cj4+ICAJCS8qIElmIG5vdCBlbmFibGVkIGNsZWFyIGFsbCBmbGFncyAqLwo+ PiAgCQl2Y3B1LT5ndWVzdF9kZWJ1ZyA9IDA7Cj4+IGRpZmYgLS1naXQgYS9hcmNoL2FybTY0L2lu Y2x1ZGUvYXNtL2h3X2JyZWFrcG9pbnQuaCBiL2FyY2gvYXJtNjQvaW5jbHVkZS9hc20vaHdfYnJl YWtwb2ludC5oCj4+IGluZGV4IDUyYjQ4NGIuLmM0NTA1NTIgMTAwNjQ0Cj4+IC0tLSBhL2FyY2gv YXJtNjQvaW5jbHVkZS9hc20vaHdfYnJlYWtwb2ludC5oCj4+ICsrKyBiL2FyY2gvYXJtNjQvaW5j bHVkZS9hc20vaHdfYnJlYWtwb2ludC5oCj4+IEBAIC0xMzAsNiArMTMwLDE4IEBAIHN0YXRpYyBp bmxpbmUgdm9pZCBwdHJhY2VfaHdfY29weV90aHJlYWQoc3RydWN0IHRhc2tfc3RydWN0ICp0YXNr KQo+PiAgfQo+PiAgI2VuZGlmCj4+ICAKPj4gKy8qIERldGVybWluZSBudW1iZXIgb2YgQlJQIHJl Z2lzdGVycyBhdmFpbGFibGUuICovCj4+ICtzdGF0aWMgaW5saW5lIGludCBnZXRfbnVtX2JycHMo dm9pZCkKPj4gK3sKPj4gKwlyZXR1cm4gKChyZWFkX2NwdWlkKElEX0FBNjRERlIwX0VMMSkgPj4g MTIpICYgMHhmKSArIDE7Cj4+ICt9Cj4+ICsKPj4gKy8qIERldGVybWluZSBudW1iZXIgb2YgV1JQ IHJlZ2lzdGVycyBhdmFpbGFibGUuICovCj4+ICtzdGF0aWMgaW5saW5lIGludCBnZXRfbnVtX3dy cHModm9pZCkKPj4gK3sKPj4gKwlyZXR1cm4gKChyZWFkX2NwdWlkKElEX0FBNjRERlIwX0VMMSkg Pj4gMjApICYgMHhmKSArIDE7Cj4+ICt9Cj4+ICsKPj4gIGV4dGVybiBzdHJ1Y3QgcG11IHBlcmZf b3BzX2JwOwo+PiAgCj4+ICAjZW5kaWYJLyogX19LRVJORUxfXyAqLwo+PiBkaWZmIC0tZ2l0IGEv YXJjaC9hcm02NC9pbmNsdWRlL2FzbS9rdm1faG9zdC5oIGIvYXJjaC9hcm02NC9pbmNsdWRlL2Fz bS9rdm1faG9zdC5oCj4+IGluZGV4IDk2OTdkYWYuLjBhM2VlN2IgMTAwNjQ0Cj4+IC0tLSBhL2Fy Y2gvYXJtNjQvaW5jbHVkZS9hc20va3ZtX2hvc3QuaAo+PiArKysgYi9hcmNoL2FybTY0L2luY2x1 ZGUvYXNtL2t2bV9ob3N0LmgKPj4gQEAgLTExNiwxMyArMTE2LDE3IEBAIHN0cnVjdCBrdm1fdmNw dV9hcmNoIHsKPj4gIAkgKiBkZWJ1Z2dpbmcgdGhlIGd1ZXN0IGZyb20gdGhlIGhvc3QgYW5kIHRv IG1haW50YWluIHNlcGFyYXRlIGhvc3QgYW5kCj4+ICAJICogZ3Vlc3Qgc3RhdGUgZHVyaW5nIHdv cmxkIHN3aXRjaGVzLiB2Y3B1X2RlYnVnX3N0YXRlIGFyZSB0aGUgZGVidWcKPj4gIAkgKiByZWdp c3RlcnMgb2YgdGhlIHZjcHUgYXMgdGhlIGd1ZXN0IHNlZXMgdGhlbS4gIGhvc3RfZGVidWdfc3Rh dGUgYXJlCj4+IC0JICogdGhlIGhvc3QgcmVnaXN0ZXJzIHdoaWNoIGFyZSBzYXZlZCBhbmQgcmVz dG9yZWQgZHVyaW5nIHdvcmxkIHN3aXRjaGVzLgo+PiArCSAqIHRoZSBob3N0IHJlZ2lzdGVycyB3 aGljaCBhcmUgc2F2ZWQgYW5kIHJlc3RvcmVkIGR1cmluZwo+PiArCSAqIHdvcmxkIHN3aXRjaGVz LiBleHRlcm5hbF9kZWJ1Z19zdGF0ZSBjb250YWlucyB0aGUgZGVidWcKPj4gKwkgKiB2YWx1ZXMg d2Ugd2FudCB0byBkZWJ1Z2dpbmcgdGhlIGd1ZXN0LiBUaGlzIGlzIHNldCB2aWEgdGhlCj4KPiBu aXQ6IHMvZGVidWdnaW5nL2RlYnVnLwo+Cj4+ICsJICogS1ZNX1NFVF9HVUVTVF9ERUJVRyBpb2N0 bC4KPj4gIAkgKgo+PiAgCSAqIGRlYnVnX3B0ciBwb2ludHMgdG8gdGhlIHNldCBvZiBkZWJ1ZyBy ZWdpc3RlcnMgdGhhdCBzaG91bGQgYmUgbG9hZGVkCj4+ICAJICogb250byB0aGUgaGFyZHdhcmUg d2hlbiBydW5uaW5nIHRoZSBndWVzdC4KPj4gIAkgKi8KPj4gIAlzdHJ1Y3Qga3ZtX2d1ZXN0X2Rl YnVnX2FyY2ggKmRlYnVnX3B0cjsKPj4gIAlzdHJ1Y3Qga3ZtX2d1ZXN0X2RlYnVnX2FyY2ggdmNw dV9kZWJ1Z19zdGF0ZTsKPj4gKwlzdHJ1Y3Qga3ZtX2d1ZXN0X2RlYnVnX2FyY2ggZXh0ZXJuYWxf ZGVidWdfc3RhdGU7Cj4+ICAKPj4gIAkvKiBQb2ludGVyIHRvIGhvc3QgQ1BVIGNvbnRleHQgKi8K Pj4gIAlrdm1fY3B1X2NvbnRleHRfdCAqaG9zdF9jcHVfY29udGV4dDsKPj4gZGlmZiAtLWdpdCBh L2FyY2gvYXJtNjQva2VybmVsL2h3X2JyZWFrcG9pbnQuYyBiL2FyY2gvYXJtNjQva2VybmVsL2h3 X2JyZWFrcG9pbnQuYwo+PiBpbmRleCBlN2Q5MzRkLi4zYTQxYmJmIDEwMDY0NAo+PiAtLS0gYS9h cmNoL2FybTY0L2tlcm5lbC9od19icmVha3BvaW50LmMKPj4gKysrIGIvYXJjaC9hcm02NC9rZXJu ZWwvaHdfYnJlYWtwb2ludC5jCj4+IEBAIC00OSwxOCArNDksNiBAQCBzdGF0aWMgREVGSU5FX1BF Ul9DUFUoaW50LCBzdGVwcGluZ19rZXJuZWxfYnApOwo+PiAgc3RhdGljIGludCBjb3JlX251bV9i cnBzOwo+PiAgc3RhdGljIGludCBjb3JlX251bV93cnBzOwo+PiAgCj4+IC0vKiBEZXRlcm1pbmUg bnVtYmVyIG9mIEJSUCByZWdpc3RlcnMgYXZhaWxhYmxlLiAqLwo+PiAtc3RhdGljIGludCBnZXRf bnVtX2JycHModm9pZCkKPj4gLXsKPj4gLQlyZXR1cm4gKChyZWFkX2NwdWlkKElEX0FBNjRERlIw X0VMMSkgPj4gMTIpICYgMHhmKSArIDE7Cj4+IC19Cj4+IC0KPj4gLS8qIERldGVybWluZSBudW1i ZXIgb2YgV1JQIHJlZ2lzdGVycyBhdmFpbGFibGUuICovCj4+IC1zdGF0aWMgaW50IGdldF9udW1f d3Jwcyh2b2lkKQo+PiAtewo+PiAtCXJldHVybiAoKHJlYWRfY3B1aWQoSURfQUE2NERGUjBfRUwx KSA+PiAyMCkgJiAweGYpICsgMTsKPj4gLX0KPj4gLQo+PiAgaW50IGh3X2JyZWFrcG9pbnRfc2xv dHMoaW50IHR5cGUpCj4+ICB7Cj4+ICAJLyoKPj4gZGlmZiAtLWdpdCBhL2FyY2gvYXJtNjQva3Zt L2RlYnVnLmMgYi9hcmNoL2FybTY0L2t2bS9kZWJ1Zy5jCj4+IGluZGV4IGQ0MzllYjguLmIyODdi YmMgMTAwNjQ0Cj4+IC0tLSBhL2FyY2gvYXJtNjQva3ZtL2RlYnVnLmMKPj4gKysrIGIvYXJjaC9h cm02NC9rdm0vZGVidWcuYwo+PiBAQCAtOTYsMTAgKzk2LDYgQEAgdm9pZCBrdm1fYXJtX3NldHVw X2RlYnVnKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSkKPj4gIAkJCQlNRENSX0VMMl9URFJBIHwKPj4g IAkJCQlNRENSX0VMMl9URE9TQSk7Cj4+ICAKPj4gLQkvKiBUcmFwIG9uIGFjY2VzcyB0byBkZWJ1 ZyByZWdpc3RlcnM/ICovCj4+IC0JaWYgKHRyYXBfZGVidWcpCj4+IC0JCXZjcHUtPmFyY2gubWRj cl9lbDIgfD0gTURDUl9FTDJfVERBOwo+PiAtCj4+ICAJLyogSXMgR3Vlc3QgZGVidWdnaW5nIGlu IGVmZmVjdD8gKi8KPj4gIAlpZiAodmNwdS0+Z3Vlc3RfZGVidWcpIHsKPj4gIAkJLyogUm91dGUg YWxsIHNvZnR3YXJlIGRlYnVnIGV4Y2VwdGlvbnMgdG8gRUwyICovCj4+IEBAIC0xMzQsMTEgKzEz MCw0MiBAQCB2b2lkIGt2bV9hcm1fc2V0dXBfZGVidWcoc3RydWN0IGt2bV92Y3B1ICp2Y3B1KQo+ PiAgCQl9IGVsc2Ugewo+PiAgCQkJdmNwdV9zeXNfcmVnKHZjcHUsIE1EU0NSX0VMMSkgJj0gfkRC R19NRFNDUl9TUzsKPj4gIAkJfQo+PiArCj4+ICsJCS8qCj4+ICsJCSAqIEhXIEJyZWFrcG9pbnRz IGFuZCB3YXRjaHBvaW50cwo+PiArCQkgKgo+PiArCQkgKiBXZSBzaW1wbHkgc3dpdGNoIHRoZSBk ZWJ1Z19wdHIgdG8gcG9pbnQgdG8gb3VyIG5ldwo+PiArCQkgKiBleHRlcm5hbF9kZWJ1Z19zdGF0 ZSB3aGljaCBoYXMgYmVlbiBwb3B1bGF0ZWQgYnkgdGhlCj4+ICsJCSAqIGRlYnVnIGlvY3RsLiBU aGUgZXhpc3RpbmcgS1ZNX0FSTTY0X0RFQlVHX0RJUlRZCj4+ICsJCSAqIG1lY2hhbmlzbSBlbnN1 cmVzIHRoZSByZWdpc3RlcnMgYXJlIHVwZGF0ZWQgb24gdGhlCj4+ICsJCSAqIHdvcmxkIHN3aXRj aC4KPj4gKwkJICovCj4+ICsJCWlmICh2Y3B1LT5ndWVzdF9kZWJ1ZyAmIEtWTV9HVUVTVERCR19V U0VfSFcpIHsKPj4gKwkJCS8qIEVuYWJsZSBicmVha3BvaW50cy93YXRjaHBvaW50cyAqLwo+PiAr CQkJdmNwdV9zeXNfcmVnKHZjcHUsIE1EU0NSX0VMMSkgfD0gREJHX01EU0NSX01ERTsKPj4gKwo+ PiArCQkJdmNwdS0+YXJjaC5kZWJ1Z19wdHIgPSAmdmNwdS0+YXJjaC5leHRlcm5hbF9kZWJ1Z19z dGF0ZTsKPj4gKwkJCXZjcHUtPmFyY2guZGVidWdfZmxhZ3MgfD0gS1ZNX0FSTTY0X0RFQlVHX0RJ UlRZOwo+PiArCQkJdHJhcF9kZWJ1ZyA9IHRydWU7Cj4+ICsJCX0KPj4gIAl9Cj4+ICsKPj4gKwkv KiBUcmFwIGRlYnVnIHJlZ2lzdGVyIGFjY2VzcyAqLwo+PiArCWlmICh0cmFwX2RlYnVnKQo+PiAr CQl2Y3B1LT5hcmNoLm1kY3JfZWwyIHw9IE1EQ1JfRUwyX1REQTsKPj4gIH0KPj4gIAo+PiAgdm9p ZCBrdm1fYXJtX2NsZWFyX2RlYnVnKHN0cnVjdCBrdm1fdmNwdSAqdmNwdSkKPj4gIHsKPj4gLQlp ZiAodmNwdS0+Z3Vlc3RfZGVidWcpCj4+ICsJaWYgKHZjcHUtPmd1ZXN0X2RlYnVnKSB7Cj4+ICAJ CXJlc3RvcmVfZ3Vlc3RfZGVidWdfcmVncyh2Y3B1KTsKPj4gKwo+PiArCQkvKgo+PiArCQkgKiBJ ZiB3ZSB3ZXJlIHVzaW5nIEhXIGRlYnVnIHdlIG5lZWQgdG8gcmVzdG9yZSB0aGUKPj4gKwkJICog ZGVidWdfcHRyIHRvIHRoZSBndWVzdCBkZWJ1ZyBzdGF0ZS4KPj4gKwkJICovCj4+ICsJCWlmICh2 Y3B1LT5ndWVzdF9kZWJ1ZyAmIEtWTV9HVUVTVERCR19VU0VfSFcpCj4+ICsJCQl2Y3B1LT5hcmNo LmRlYnVnX3B0ciA9ICZ2Y3B1LT5hcmNoLnZjcHVfZGVidWdfc3RhdGU7Cj4KPiBJIHN0aWxsIHRo aW5rIHRoaXMgd291bGQgYmUgbW9yZSBjbGVhbmx5IGRvbmUgaW4gdGhlIHNldHVwX2RlYnVnCj4g ZnVuY3Rpb24sIGJ1dCBvazoKCkkgZG9uJ3QgZm9sbG93LCBzZXR1cF9kZWJ1ZyBpcyBjYWxsZWQg YmVmb3JlIHdlIGVudGVyIEtWTS4gSXQncyBwcmV0dHkKbGlnaHQgd2hlbiBubyBkZWJ1Z2dpbmcg aXMgYmVpbmcgZG9uZSBzbyB0aGlzIGVuc3VyZSB3ZSBsZWF2ZSBzdGF0ZSBob3cKd2Ugd291bGQg bGlrZSBpdCB3aGVuIHdlIHN0b3AgZGVidWdnaW5nLgoKSSBjYW4gbW92ZSBpdCB0byBhbiBlbHNl IGxlZyBpbiBzZXR1cCBpZiB5b3UgcmVhbGx5IHdhbnQuCgo+Cj4gUmV2aWV3ZWQtYnk6IENocmlz dG9mZmVyIERhbGwgPGNocmlzdG9mZmVyLmRhbGxAbGluYXJvLm9yZz4KCi0tIApBbGV4IEJlbm7D qWUKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18Ka3ZtYXJt IG1haWxpbmcgbGlzdAprdm1hcm1AbGlzdHMuY3MuY29sdW1iaWEuZWR1Cmh0dHBzOi8vbGlzdHMu Y3MuY29sdW1iaWEuZWR1L21haWxtYW4vbGlzdGluZm8va3ZtYXJtCg== From mboxrd@z Thu Jan 1 00:00:00 1970 From: alex.bennee@linaro.org (Alex =?utf-8?Q?Benn=C3=A9e?=) Date: Thu, 25 Jun 2015 07:38:33 +0100 Subject: [PATCH v6 10/12] KVM: arm64: guest debug, HW assisted debug support In-Reply-To: <20150624202216.GE22785@cbox> References: <1434716630-18260-1-git-send-email-alex.bennee@linaro.org> <1434716630-18260-11-git-send-email-alex.bennee@linaro.org> <20150624202216.GE22785@cbox> Message-ID: <87mvzoxpg6.fsf@linaro.org> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org Christoffer Dall writes: > On Fri, Jun 19, 2015 at 01:23:48PM +0100, Alex Benn?e wrote: >> This adds support for userspace to control the HW debug registers for >> guest debug. In the debug ioctl we copy the IMPDEF defined number of > > s/defined// > >> registers into a new register set called host_debug_state. There is now >> a new vcpu parameter called debug_ptr which selects which register set >> is to copied into the real registers when world switch occurs. > > But this patch doesn't seem to add the debug_ptr field? Oops, yes the comment belongs to the previous patch. > > s/to// > >> >> I've moved some helper functions into the hw_breakpoint.h header for >> re-use. >> >> As with single step we need to tweak the guest registers to enable the >> exceptions so we need to save and restore those bits. >> >> Two new capabilities have been added to the KVM_EXTENSION ioctl to allow >> userspace to query the number of hardware break and watch points >> available on the host hardware. >> >> Signed-off-by: Alex Benn?e >> >> --- >> v2 >> - switched to C setup >> - replace host debug registers directly into context >> - minor tweak to api docs >> - setup right register for debug >> - add FAR_EL2 to debug exit structure >> - add support for trapping debug register access >> v3 >> - remove stray trace statement >> - fix spacing around operators (various) >> - clean-up usage of trap_debug >> - introduce debug_ptr, replace excessive memcpy stuff >> - don't use memcpy in ioctl, just assign >> - update cap ioctl documentation >> - reword a number comments >> - rename host_debug_state->external_debug_state >> v4 >> - use the new u32/u64 split debug_ptr approach >> - fix some wording/comments >> v5 >> - don't set MDSCR_EL1.KDE (not needed) >> v6 >> - update wording given change in commentary >> - KVM_GUESTDBG_USE_HW_BP->KVM_GUESTDBG_USE_HW >> --- >> Documentation/virtual/kvm/api.txt | 7 ++++++- >> arch/arm/kvm/arm.c | 7 +++++++ >> arch/arm64/include/asm/hw_breakpoint.h | 12 +++++++++++ >> arch/arm64/include/asm/kvm_host.h | 6 +++++- >> arch/arm64/kernel/hw_breakpoint.c | 12 ----------- >> arch/arm64/kvm/debug.c | 37 +++++++++++++++++++++++++++++----- >> arch/arm64/kvm/handle_exit.c | 6 ++++++ >> arch/arm64/kvm/reset.c | 12 +++++++++++ >> include/uapi/linux/kvm.h | 2 ++ >> 9 files changed, 82 insertions(+), 19 deletions(-) >> >> diff --git a/Documentation/virtual/kvm/api.txt b/Documentation/virtual/kvm/api.txt >> index 33c8143..ada57df 100644 >> --- a/Documentation/virtual/kvm/api.txt >> +++ b/Documentation/virtual/kvm/api.txt >> @@ -2668,7 +2668,7 @@ The top 16 bits of the control field are architecture specific control >> flags which can include the following: >> >> - KVM_GUESTDBG_USE_SW_BP: using software breakpoints [x86, arm64] >> - - KVM_GUESTDBG_USE_HW_BP: using hardware breakpoints [x86, s390] >> + - KVM_GUESTDBG_USE_HW_BP: using hardware breakpoints [x86, s390, arm64] >> - KVM_GUESTDBG_INJECT_DB: inject DB type exception [x86] >> - KVM_GUESTDBG_INJECT_BP: inject BP type exception [x86] >> - KVM_GUESTDBG_EXIT_PENDING: trigger an immediate guest exit [s390] >> @@ -2683,6 +2683,11 @@ updated to the correct (supplied) values. >> The second part of the structure is architecture specific and >> typically contains a set of debug registers. >> >> +For arm64 the number of debug registers is implementation defined and >> +can be determined by querying the KVM_CAP_GUEST_DEBUG_HW_BPS and >> +KVM_CAP_GUEST_DEBUG_HW_WPS capabilities which return a positive number >> +indicating the number of supported registers. >> + >> When debug events exit the main run loop with the reason >> KVM_EXIT_DEBUG with the kvm_debug_exit_arch part of the kvm_run >> structure containing architecture specific debug information. >> diff --git a/arch/arm/kvm/arm.c b/arch/arm/kvm/arm.c >> index 0d17c7b..60c4045 100644 >> --- a/arch/arm/kvm/arm.c >> +++ b/arch/arm/kvm/arm.c >> @@ -307,6 +307,7 @@ void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) >> >> #define KVM_GUESTDBG_VALID_MASK (KVM_GUESTDBG_ENABLE | \ >> KVM_GUESTDBG_USE_SW_BP | \ >> + KVM_GUESTDBG_USE_HW | \ >> KVM_GUESTDBG_SINGLESTEP) >> >> /** >> @@ -327,6 +328,12 @@ int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, >> >> if (dbg->control & KVM_GUESTDBG_ENABLE) { >> vcpu->guest_debug = dbg->control; >> + >> + /* Hardware assisted Break and Watch points */ >> + if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW) { >> + vcpu->arch.external_debug_state = dbg->arch; >> + } >> + >> } else { >> /* If not enabled clear all flags */ >> vcpu->guest_debug = 0; >> diff --git a/arch/arm64/include/asm/hw_breakpoint.h b/arch/arm64/include/asm/hw_breakpoint.h >> index 52b484b..c450552 100644 >> --- a/arch/arm64/include/asm/hw_breakpoint.h >> +++ b/arch/arm64/include/asm/hw_breakpoint.h >> @@ -130,6 +130,18 @@ static inline void ptrace_hw_copy_thread(struct task_struct *task) >> } >> #endif >> >> +/* Determine number of BRP registers available. */ >> +static inline int get_num_brps(void) >> +{ >> + return ((read_cpuid(ID_AA64DFR0_EL1) >> 12) & 0xf) + 1; >> +} >> + >> +/* Determine number of WRP registers available. */ >> +static inline int get_num_wrps(void) >> +{ >> + return ((read_cpuid(ID_AA64DFR0_EL1) >> 20) & 0xf) + 1; >> +} >> + >> extern struct pmu perf_ops_bp; >> >> #endif /* __KERNEL__ */ >> diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h >> index 9697daf..0a3ee7b 100644 >> --- a/arch/arm64/include/asm/kvm_host.h >> +++ b/arch/arm64/include/asm/kvm_host.h >> @@ -116,13 +116,17 @@ struct kvm_vcpu_arch { >> * debugging the guest from the host and to maintain separate host and >> * guest state during world switches. vcpu_debug_state are the debug >> * registers of the vcpu as the guest sees them. host_debug_state are >> - * the host registers which are saved and restored during world switches. >> + * the host registers which are saved and restored during >> + * world switches. external_debug_state contains the debug >> + * values we want to debugging the guest. This is set via the > > nit: s/debugging/debug/ > >> + * KVM_SET_GUEST_DEBUG ioctl. >> * >> * debug_ptr points to the set of debug registers that should be loaded >> * onto the hardware when running the guest. >> */ >> struct kvm_guest_debug_arch *debug_ptr; >> struct kvm_guest_debug_arch vcpu_debug_state; >> + struct kvm_guest_debug_arch external_debug_state; >> >> /* Pointer to host CPU context */ >> kvm_cpu_context_t *host_cpu_context; >> diff --git a/arch/arm64/kernel/hw_breakpoint.c b/arch/arm64/kernel/hw_breakpoint.c >> index e7d934d..3a41bbf 100644 >> --- a/arch/arm64/kernel/hw_breakpoint.c >> +++ b/arch/arm64/kernel/hw_breakpoint.c >> @@ -49,18 +49,6 @@ static DEFINE_PER_CPU(int, stepping_kernel_bp); >> static int core_num_brps; >> static int core_num_wrps; >> >> -/* Determine number of BRP registers available. */ >> -static int get_num_brps(void) >> -{ >> - return ((read_cpuid(ID_AA64DFR0_EL1) >> 12) & 0xf) + 1; >> -} >> - >> -/* Determine number of WRP registers available. */ >> -static int get_num_wrps(void) >> -{ >> - return ((read_cpuid(ID_AA64DFR0_EL1) >> 20) & 0xf) + 1; >> -} >> - >> int hw_breakpoint_slots(int type) >> { >> /* >> diff --git a/arch/arm64/kvm/debug.c b/arch/arm64/kvm/debug.c >> index d439eb8..b287bbc 100644 >> --- a/arch/arm64/kvm/debug.c >> +++ b/arch/arm64/kvm/debug.c >> @@ -96,10 +96,6 @@ void kvm_arm_setup_debug(struct kvm_vcpu *vcpu) >> MDCR_EL2_TDRA | >> MDCR_EL2_TDOSA); >> >> - /* Trap on access to debug registers? */ >> - if (trap_debug) >> - vcpu->arch.mdcr_el2 |= MDCR_EL2_TDA; >> - >> /* Is Guest debugging in effect? */ >> if (vcpu->guest_debug) { >> /* Route all software debug exceptions to EL2 */ >> @@ -134,11 +130,42 @@ void kvm_arm_setup_debug(struct kvm_vcpu *vcpu) >> } else { >> vcpu_sys_reg(vcpu, MDSCR_EL1) &= ~DBG_MDSCR_SS; >> } >> + >> + /* >> + * HW Breakpoints and watchpoints >> + * >> + * We simply switch the debug_ptr to point to our new >> + * external_debug_state which has been populated by the >> + * debug ioctl. The existing KVM_ARM64_DEBUG_DIRTY >> + * mechanism ensures the registers are updated on the >> + * world switch. >> + */ >> + if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW) { >> + /* Enable breakpoints/watchpoints */ >> + vcpu_sys_reg(vcpu, MDSCR_EL1) |= DBG_MDSCR_MDE; >> + >> + vcpu->arch.debug_ptr = &vcpu->arch.external_debug_state; >> + vcpu->arch.debug_flags |= KVM_ARM64_DEBUG_DIRTY; >> + trap_debug = true; >> + } >> } >> + >> + /* Trap debug register access */ >> + if (trap_debug) >> + vcpu->arch.mdcr_el2 |= MDCR_EL2_TDA; >> } >> >> void kvm_arm_clear_debug(struct kvm_vcpu *vcpu) >> { >> - if (vcpu->guest_debug) >> + if (vcpu->guest_debug) { >> restore_guest_debug_regs(vcpu); >> + >> + /* >> + * If we were using HW debug we need to restore the >> + * debug_ptr to the guest debug state. >> + */ >> + if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW) >> + vcpu->arch.debug_ptr = &vcpu->arch.vcpu_debug_state; > > I still think this would be more cleanly done in the setup_debug > function, but ok: I don't follow, setup_debug is called before we enter KVM. It's pretty light when no debugging is being done so this ensure we leave state how we would like it when we stop debugging. I can move it to an else leg in setup if you really want. > > Reviewed-by: Christoffer Dall -- Alex Benn?e From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751847AbbFYGiJ (ORCPT ); Thu, 25 Jun 2015 02:38:09 -0400 Received: from mail-wg0-f48.google.com ([74.125.82.48]:34752 "EHLO mail-wg0-f48.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751535AbbFYGhz (ORCPT ); Thu, 25 Jun 2015 02:37:55 -0400 References: <1434716630-18260-1-git-send-email-alex.bennee@linaro.org> <1434716630-18260-11-git-send-email-alex.bennee@linaro.org> <20150624202216.GE22785@cbox> From: Alex =?utf-8?Q?Benn=C3=A9e?= To: Christoffer Dall Cc: kvm@vger.kernel.org, linux-arm-kernel@lists.infradead.org, kvmarm@lists.cs.columbia.edu, marc.zyngier@arm.com, peter.maydell@linaro.org, agraf@suse.de, drjones@redhat.com, pbonzini@redhat.com, zhichao.huang@linaro.org, jan.kiszka@siemens.com, dahi@linux.vnet.ibm.com, r65777@freescale.com, bp@suse.de, Gleb Natapov , Jonathan Corbet , Russell King , Catalin Marinas , Will Deacon , Peter Zijlstra , Lorenzo Pieralisi , Ingo Molnar , "open list\:DOCUMENTATION" , open list , "open list\:ABI\/API" Subject: Re: [PATCH v6 10/12] KVM: arm64: guest debug, HW assisted debug support In-reply-to: <20150624202216.GE22785@cbox> Date: Thu, 25 Jun 2015 07:38:33 +0100 Message-ID: <87mvzoxpg6.fsf@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Christoffer Dall writes: > On Fri, Jun 19, 2015 at 01:23:48PM +0100, Alex Bennée wrote: >> This adds support for userspace to control the HW debug registers for >> guest debug. In the debug ioctl we copy the IMPDEF defined number of > > s/defined// > >> registers into a new register set called host_debug_state. There is now >> a new vcpu parameter called debug_ptr which selects which register set >> is to copied into the real registers when world switch occurs. > > But this patch doesn't seem to add the debug_ptr field? Oops, yes the comment belongs to the previous patch. > > s/to// > >> >> I've moved some helper functions into the hw_breakpoint.h header for >> re-use. >> >> As with single step we need to tweak the guest registers to enable the >> exceptions so we need to save and restore those bits. >> >> Two new capabilities have been added to the KVM_EXTENSION ioctl to allow >> userspace to query the number of hardware break and watch points >> available on the host hardware. >> >> Signed-off-by: Alex Bennée >> >> --- >> v2 >> - switched to C setup >> - replace host debug registers directly into context >> - minor tweak to api docs >> - setup right register for debug >> - add FAR_EL2 to debug exit structure >> - add support for trapping debug register access >> v3 >> - remove stray trace statement >> - fix spacing around operators (various) >> - clean-up usage of trap_debug >> - introduce debug_ptr, replace excessive memcpy stuff >> - don't use memcpy in ioctl, just assign >> - update cap ioctl documentation >> - reword a number comments >> - rename host_debug_state->external_debug_state >> v4 >> - use the new u32/u64 split debug_ptr approach >> - fix some wording/comments >> v5 >> - don't set MDSCR_EL1.KDE (not needed) >> v6 >> - update wording given change in commentary >> - KVM_GUESTDBG_USE_HW_BP->KVM_GUESTDBG_USE_HW >> --- >> Documentation/virtual/kvm/api.txt | 7 ++++++- >> arch/arm/kvm/arm.c | 7 +++++++ >> arch/arm64/include/asm/hw_breakpoint.h | 12 +++++++++++ >> arch/arm64/include/asm/kvm_host.h | 6 +++++- >> arch/arm64/kernel/hw_breakpoint.c | 12 ----------- >> arch/arm64/kvm/debug.c | 37 +++++++++++++++++++++++++++++----- >> arch/arm64/kvm/handle_exit.c | 6 ++++++ >> arch/arm64/kvm/reset.c | 12 +++++++++++ >> include/uapi/linux/kvm.h | 2 ++ >> 9 files changed, 82 insertions(+), 19 deletions(-) >> >> diff --git a/Documentation/virtual/kvm/api.txt b/Documentation/virtual/kvm/api.txt >> index 33c8143..ada57df 100644 >> --- a/Documentation/virtual/kvm/api.txt >> +++ b/Documentation/virtual/kvm/api.txt >> @@ -2668,7 +2668,7 @@ The top 16 bits of the control field are architecture specific control >> flags which can include the following: >> >> - KVM_GUESTDBG_USE_SW_BP: using software breakpoints [x86, arm64] >> - - KVM_GUESTDBG_USE_HW_BP: using hardware breakpoints [x86, s390] >> + - KVM_GUESTDBG_USE_HW_BP: using hardware breakpoints [x86, s390, arm64] >> - KVM_GUESTDBG_INJECT_DB: inject DB type exception [x86] >> - KVM_GUESTDBG_INJECT_BP: inject BP type exception [x86] >> - KVM_GUESTDBG_EXIT_PENDING: trigger an immediate guest exit [s390] >> @@ -2683,6 +2683,11 @@ updated to the correct (supplied) values. >> The second part of the structure is architecture specific and >> typically contains a set of debug registers. >> >> +For arm64 the number of debug registers is implementation defined and >> +can be determined by querying the KVM_CAP_GUEST_DEBUG_HW_BPS and >> +KVM_CAP_GUEST_DEBUG_HW_WPS capabilities which return a positive number >> +indicating the number of supported registers. >> + >> When debug events exit the main run loop with the reason >> KVM_EXIT_DEBUG with the kvm_debug_exit_arch part of the kvm_run >> structure containing architecture specific debug information. >> diff --git a/arch/arm/kvm/arm.c b/arch/arm/kvm/arm.c >> index 0d17c7b..60c4045 100644 >> --- a/arch/arm/kvm/arm.c >> +++ b/arch/arm/kvm/arm.c >> @@ -307,6 +307,7 @@ void kvm_arch_vcpu_put(struct kvm_vcpu *vcpu) >> >> #define KVM_GUESTDBG_VALID_MASK (KVM_GUESTDBG_ENABLE | \ >> KVM_GUESTDBG_USE_SW_BP | \ >> + KVM_GUESTDBG_USE_HW | \ >> KVM_GUESTDBG_SINGLESTEP) >> >> /** >> @@ -327,6 +328,12 @@ int kvm_arch_vcpu_ioctl_set_guest_debug(struct kvm_vcpu *vcpu, >> >> if (dbg->control & KVM_GUESTDBG_ENABLE) { >> vcpu->guest_debug = dbg->control; >> + >> + /* Hardware assisted Break and Watch points */ >> + if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW) { >> + vcpu->arch.external_debug_state = dbg->arch; >> + } >> + >> } else { >> /* If not enabled clear all flags */ >> vcpu->guest_debug = 0; >> diff --git a/arch/arm64/include/asm/hw_breakpoint.h b/arch/arm64/include/asm/hw_breakpoint.h >> index 52b484b..c450552 100644 >> --- a/arch/arm64/include/asm/hw_breakpoint.h >> +++ b/arch/arm64/include/asm/hw_breakpoint.h >> @@ -130,6 +130,18 @@ static inline void ptrace_hw_copy_thread(struct task_struct *task) >> } >> #endif >> >> +/* Determine number of BRP registers available. */ >> +static inline int get_num_brps(void) >> +{ >> + return ((read_cpuid(ID_AA64DFR0_EL1) >> 12) & 0xf) + 1; >> +} >> + >> +/* Determine number of WRP registers available. */ >> +static inline int get_num_wrps(void) >> +{ >> + return ((read_cpuid(ID_AA64DFR0_EL1) >> 20) & 0xf) + 1; >> +} >> + >> extern struct pmu perf_ops_bp; >> >> #endif /* __KERNEL__ */ >> diff --git a/arch/arm64/include/asm/kvm_host.h b/arch/arm64/include/asm/kvm_host.h >> index 9697daf..0a3ee7b 100644 >> --- a/arch/arm64/include/asm/kvm_host.h >> +++ b/arch/arm64/include/asm/kvm_host.h >> @@ -116,13 +116,17 @@ struct kvm_vcpu_arch { >> * debugging the guest from the host and to maintain separate host and >> * guest state during world switches. vcpu_debug_state are the debug >> * registers of the vcpu as the guest sees them. host_debug_state are >> - * the host registers which are saved and restored during world switches. >> + * the host registers which are saved and restored during >> + * world switches. external_debug_state contains the debug >> + * values we want to debugging the guest. This is set via the > > nit: s/debugging/debug/ > >> + * KVM_SET_GUEST_DEBUG ioctl. >> * >> * debug_ptr points to the set of debug registers that should be loaded >> * onto the hardware when running the guest. >> */ >> struct kvm_guest_debug_arch *debug_ptr; >> struct kvm_guest_debug_arch vcpu_debug_state; >> + struct kvm_guest_debug_arch external_debug_state; >> >> /* Pointer to host CPU context */ >> kvm_cpu_context_t *host_cpu_context; >> diff --git a/arch/arm64/kernel/hw_breakpoint.c b/arch/arm64/kernel/hw_breakpoint.c >> index e7d934d..3a41bbf 100644 >> --- a/arch/arm64/kernel/hw_breakpoint.c >> +++ b/arch/arm64/kernel/hw_breakpoint.c >> @@ -49,18 +49,6 @@ static DEFINE_PER_CPU(int, stepping_kernel_bp); >> static int core_num_brps; >> static int core_num_wrps; >> >> -/* Determine number of BRP registers available. */ >> -static int get_num_brps(void) >> -{ >> - return ((read_cpuid(ID_AA64DFR0_EL1) >> 12) & 0xf) + 1; >> -} >> - >> -/* Determine number of WRP registers available. */ >> -static int get_num_wrps(void) >> -{ >> - return ((read_cpuid(ID_AA64DFR0_EL1) >> 20) & 0xf) + 1; >> -} >> - >> int hw_breakpoint_slots(int type) >> { >> /* >> diff --git a/arch/arm64/kvm/debug.c b/arch/arm64/kvm/debug.c >> index d439eb8..b287bbc 100644 >> --- a/arch/arm64/kvm/debug.c >> +++ b/arch/arm64/kvm/debug.c >> @@ -96,10 +96,6 @@ void kvm_arm_setup_debug(struct kvm_vcpu *vcpu) >> MDCR_EL2_TDRA | >> MDCR_EL2_TDOSA); >> >> - /* Trap on access to debug registers? */ >> - if (trap_debug) >> - vcpu->arch.mdcr_el2 |= MDCR_EL2_TDA; >> - >> /* Is Guest debugging in effect? */ >> if (vcpu->guest_debug) { >> /* Route all software debug exceptions to EL2 */ >> @@ -134,11 +130,42 @@ void kvm_arm_setup_debug(struct kvm_vcpu *vcpu) >> } else { >> vcpu_sys_reg(vcpu, MDSCR_EL1) &= ~DBG_MDSCR_SS; >> } >> + >> + /* >> + * HW Breakpoints and watchpoints >> + * >> + * We simply switch the debug_ptr to point to our new >> + * external_debug_state which has been populated by the >> + * debug ioctl. The existing KVM_ARM64_DEBUG_DIRTY >> + * mechanism ensures the registers are updated on the >> + * world switch. >> + */ >> + if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW) { >> + /* Enable breakpoints/watchpoints */ >> + vcpu_sys_reg(vcpu, MDSCR_EL1) |= DBG_MDSCR_MDE; >> + >> + vcpu->arch.debug_ptr = &vcpu->arch.external_debug_state; >> + vcpu->arch.debug_flags |= KVM_ARM64_DEBUG_DIRTY; >> + trap_debug = true; >> + } >> } >> + >> + /* Trap debug register access */ >> + if (trap_debug) >> + vcpu->arch.mdcr_el2 |= MDCR_EL2_TDA; >> } >> >> void kvm_arm_clear_debug(struct kvm_vcpu *vcpu) >> { >> - if (vcpu->guest_debug) >> + if (vcpu->guest_debug) { >> restore_guest_debug_regs(vcpu); >> + >> + /* >> + * If we were using HW debug we need to restore the >> + * debug_ptr to the guest debug state. >> + */ >> + if (vcpu->guest_debug & KVM_GUESTDBG_USE_HW) >> + vcpu->arch.debug_ptr = &vcpu->arch.vcpu_debug_state; > > I still think this would be more cleanly done in the setup_debug > function, but ok: I don't follow, setup_debug is called before we enter KVM. It's pretty light when no debugging is being done so this ensure we leave state how we would like it when we stop debugging. I can move it to an else leg in setup if you really want. > > Reviewed-by: Christoffer Dall -- Alex Bennée