From mboxrd@z Thu Jan 1 00:00:00 1970 From: Marc Zyngier Subject: Re: [PATCH v2 08/21] arm64: KVM: Implement debug save/restore Date: Mon, 30 Nov 2015 12:24:36 +0000 Message-ID: <20151130122436.2d1515d2@arm.com> References: <1448650215-15218-1-git-send-email-marc.zyngier@arm.com> <1448650215-15218-9-git-send-email-marc.zyngier@arm.com> <87d1urbstj.fsf@linaro.org> 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 0F33E4130B for ; Mon, 30 Nov 2015 07:23:27 -0500 (EST) 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 0VSKWeNEEm4F for ; Mon, 30 Nov 2015 07:23:26 -0500 (EST) Received: from foss.arm.com (foss.arm.com [217.140.101.70]) by mm01.cs.columbia.edu (Postfix) with ESMTP id DEFF9412ED for ; Mon, 30 Nov 2015 07:23:25 -0500 (EST) In-Reply-To: <87d1urbstj.fsf@linaro.org> 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: Alex =?ISO-8859-1?Q?Benn=E9e?= Cc: kvm@vger.kernel.org, Ard Biesheuvel , Catalin Marinas , kvmarm@lists.cs.columbia.edu, linux-arm-kernel@lists.infradead.org List-Id: kvmarm@lists.cs.columbia.edu T24gTW9uLCAzMCBOb3YgMjAxNSAxMjowMDoyNCArMDAwMApBbGV4IEJlbm7DqWUgPGFsZXguYmVu bmVlQGxpbmFyby5vcmc+IHdyb3RlOgoKPiAKPiBNYXJjIFp5bmdpZXIgPG1hcmMuenluZ2llckBh cm0uY29tPiB3cml0ZXM6Cj4gCj4gPiBJbXBsZW1lbnQgdGhlIGRlYnVnIHNhdmUgcmVzdG9yZSBh cyBhIGRpcmVjdCB0cmFuc2xhdGlvbiBvZgo+ID4gdGhlIGFzc2VtYmx5IGNvZGUgdmVyc2lvbi4K PiA+Cj4gPiBTaWduZWQtb2ZmLWJ5OiBNYXJjIFp5bmdpZXIgPG1hcmMuenluZ2llckBhcm0uY29t Pgo+ID4gLS0tCj4gPiAgYXJjaC9hcm02NC9rdm0vaHlwL01ha2VmaWxlICAgfCAgIDEgKwo+ID4g IGFyY2gvYXJtNjQva3ZtL2h5cC9kZWJ1Zy1zci5jIHwgMTMwICsrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKwo+ID4gIGFyY2gvYXJtNjQva3ZtL2h5cC9oeXAuaCAgICAg IHwgICA5ICsrKwo+ID4gIDMgZmlsZXMgY2hhbmdlZCwgMTQwIGluc2VydGlvbnMoKykKPiA+ICBj cmVhdGUgbW9kZSAxMDA2NDQgYXJjaC9hcm02NC9rdm0vaHlwL2RlYnVnLXNyLmMKPiA+Cj4gPiBk aWZmIC0tZ2l0IGEvYXJjaC9hcm02NC9rdm0vaHlwL01ha2VmaWxlIGIvYXJjaC9hcm02NC9rdm0v aHlwL01ha2VmaWxlCj4gPiBpbmRleCBlYzk0MjAwLi5lYzE0Y2FjIDEwMDY0NAo+ID4gLS0tIGEv YXJjaC9hcm02NC9rdm0vaHlwL01ha2VmaWxlCj4gPiArKysgYi9hcmNoL2FybTY0L2t2bS9oeXAv TWFrZWZpbGUKPiA+IEBAIC02LDMgKzYsNCBAQCBvYmotJChDT05GSUdfS1ZNX0FSTV9IT1NUKSAr PSB2Z2ljLXYyLXNyLm8KPiA+ICBvYmotJChDT05GSUdfS1ZNX0FSTV9IT1NUKSArPSB2Z2ljLXYz LXNyLm8KPiA+ICBvYmotJChDT05GSUdfS1ZNX0FSTV9IT1NUKSArPSB0aW1lci1zci5vCj4gPiAg b2JqLSQoQ09ORklHX0tWTV9BUk1fSE9TVCkgKz0gc3lzcmVnLXNyLm8KPiA+ICtvYmotJChDT05G SUdfS1ZNX0FSTV9IT1NUKSArPSBkZWJ1Zy1zci5vCj4gPiBkaWZmIC0tZ2l0IGEvYXJjaC9hcm02 NC9rdm0vaHlwL2RlYnVnLXNyLmMgYi9hcmNoL2FybTY0L2t2bS9oeXAvZGVidWctc3IuYwo+ID4g bmV3IGZpbGUgbW9kZSAxMDA2NDQKPiA+IGluZGV4IDAwMDAwMDAuLmEwYjJiOTkKPiA+IC0tLSAv ZGV2L251bGwKPiA+ICsrKyBiL2FyY2gvYXJtNjQva3ZtL2h5cC9kZWJ1Zy1zci5jCj4gPiBAQCAt MCwwICsxLDEzMCBAQAo+ID4gKy8qCj4gPiArICogQ29weXJpZ2h0IChDKSAyMDE1IC0gQVJNIEx0 ZAo+ID4gKyAqIEF1dGhvcjogTWFyYyBaeW5naWVyIDxtYXJjLnp5bmdpZXJAYXJtLmNvbT4KPiA+ ICsgKgo+ID4gKyAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlz dHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5Cj4gPiArICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHRo ZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSB2ZXJzaW9uIDIgYXMKPiA+ICsgKiBwdWJsaXNo ZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbi4KPiA+ICsgKgo+ID4gKyAqIFRoaXMg cHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVs LAo+ID4gKyAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBs aWVkIHdhcnJhbnR5IG9mCj4gPiArICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEg UEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZQo+ID4gKyAqIEdOVSBHZW5lcmFsIFB1YmxpYyBM aWNlbnNlIGZvciBtb3JlIGRldGFpbHMuCj4gPiArICoKPiA+ICsgKiBZb3Ugc2hvdWxkIGhhdmUg cmVjZWl2ZWQgYSBjb3B5IG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZQo+ID4gKyAq IGFsb25nIHdpdGggdGhpcyBwcm9ncmFtLiAgSWYgbm90LCBzZWUgPGh0dHA6Ly93d3cuZ251Lm9y Zy9saWNlbnNlcy8+Lgo+ID4gKyAqLwo+ID4gKwo+ID4gKyNpbmNsdWRlIDxsaW51eC9jb21waWxl ci5oPgo+ID4gKyNpbmNsdWRlIDxsaW51eC9rdm1faG9zdC5oPgo+ID4gKwo+ID4gKyNpbmNsdWRl IDxhc20va3ZtX21tdS5oPgo+ID4gKwo+ID4gKyNpbmNsdWRlICJoeXAuaCIKPiA+ICsKPiA+ICsj ZGVmaW5lIHJlYWRfZGVidWcocixuKQkJcmVhZF9zeXNyZWcociMjbiMjX2VsMSkKPiA+ICsjZGVm aW5lIHdyaXRlX2RlYnVnKHYscixuKQl3cml0ZV9zeXNyZWcodiwgciMjbiMjX2VsMSkKPiA+ICsK PiA+ICsjZGVmaW5lIHNhdmVfZGVidWcocHRyLHJlZyxucikJCQkJCQlcCj4gPiArCXN3aXRjaCAo bnIpIHsJCQkJCQkJXAo+ID4gKwljYXNlIDE1OglwdHJbMTVdID0gcmVhZF9kZWJ1ZyhyZWcsIDE1 KTsJCQlcCj4gPiArCWNhc2UgMTQ6CXB0clsxNF0gPSByZWFkX2RlYnVnKHJlZywgMTQpOwkJCVwK PiA+ICsJY2FzZSAxMzoJcHRyWzEzXSA9IHJlYWRfZGVidWcocmVnLCAxMyk7CQkJXAo+ID4gKwlj YXNlIDEyOglwdHJbMTJdID0gcmVhZF9kZWJ1ZyhyZWcsIDEyKTsJCQlcCj4gPiArCWNhc2UgMTE6 CXB0clsxMV0gPSByZWFkX2RlYnVnKHJlZywgMTEpOwkJCVwKPiA+ICsJY2FzZSAxMDoJcHRyWzEw XSA9IHJlYWRfZGVidWcocmVnLCAxMCk7CQkJXAo+ID4gKwljYXNlIDk6CQlwdHJbOV0gPSByZWFk X2RlYnVnKHJlZywgOSk7CQkJXAo+ID4gKwljYXNlIDg6CQlwdHJbOF0gPSByZWFkX2RlYnVnKHJl ZywgOCk7CQkJXAo+ID4gKwljYXNlIDc6CQlwdHJbN10gPSByZWFkX2RlYnVnKHJlZywgNyk7CQkJ XAo+ID4gKwljYXNlIDY6CQlwdHJbNl0gPSByZWFkX2RlYnVnKHJlZywgNik7CQkJXAo+ID4gKwlj YXNlIDU6CQlwdHJbNV0gPSByZWFkX2RlYnVnKHJlZywgNSk7CQkJXAo+ID4gKwljYXNlIDQ6CQlw dHJbNF0gPSByZWFkX2RlYnVnKHJlZywgNCk7CQkJXAo+ID4gKwljYXNlIDM6CQlwdHJbM10gPSBy ZWFkX2RlYnVnKHJlZywgMyk7CQkJXAo+ID4gKwljYXNlIDI6CQlwdHJbMl0gPSByZWFkX2RlYnVn KHJlZywgMik7CQkJXAo+ID4gKwljYXNlIDE6CQlwdHJbMV0gPSByZWFkX2RlYnVnKHJlZywgMSk7 CQkJXAo+ID4gKwlkZWZhdWx0OglwdHJbMF0gPSByZWFkX2RlYnVnKHJlZywgMCk7CQkJXAo+ID4g Kwl9Cj4gPiArCj4gPiArI2RlZmluZSByZXN0b3JlX2RlYnVnKHB0cixyZWcsbnIpCQkJCQlcCj4g PiArCXN3aXRjaCAobnIpIHsJCQkJCQkJXAo+ID4gKwljYXNlIDE1Ogl3cml0ZV9kZWJ1ZyhwdHJb MTVdLCByZWcsIDE1KTsJCQlcCj4gPiArCWNhc2UgMTQ6CXdyaXRlX2RlYnVnKHB0clsxNF0sIHJl ZywgMTQpOwkJCVwKPiA+ICsJY2FzZSAxMzoJd3JpdGVfZGVidWcocHRyWzEzXSwgcmVnLCAxMyk7 CQkJXAo+ID4gKwljYXNlIDEyOgl3cml0ZV9kZWJ1ZyhwdHJbMTJdLCByZWcsIDEyKTsJCQlcCj4g PiArCWNhc2UgMTE6CXdyaXRlX2RlYnVnKHB0clsxMV0sIHJlZywgMTEpOwkJCVwKPiA+ICsJY2Fz ZSAxMDoJd3JpdGVfZGVidWcocHRyWzEwXSwgcmVnLCAxMCk7CQkJXAo+ID4gKwljYXNlIDk6CQl3 cml0ZV9kZWJ1ZyhwdHJbOV0sIHJlZywgOSk7CQkJXAo+ID4gKwljYXNlIDg6CQl3cml0ZV9kZWJ1 ZyhwdHJbOF0sIHJlZywgOCk7CQkJXAo+ID4gKwljYXNlIDc6CQl3cml0ZV9kZWJ1ZyhwdHJbN10s IHJlZywgNyk7CQkJXAo+ID4gKwljYXNlIDY6CQl3cml0ZV9kZWJ1ZyhwdHJbNl0sIHJlZywgNik7 CQkJXAo+ID4gKwljYXNlIDU6CQl3cml0ZV9kZWJ1ZyhwdHJbNV0sIHJlZywgNSk7CQkJXAo+ID4g KwljYXNlIDQ6CQl3cml0ZV9kZWJ1ZyhwdHJbNF0sIHJlZywgNCk7CQkJXAo+ID4gKwljYXNlIDM6 CQl3cml0ZV9kZWJ1ZyhwdHJbM10sIHJlZywgMyk7CQkJXAo+ID4gKwljYXNlIDI6CQl3cml0ZV9k ZWJ1ZyhwdHJbMl0sIHJlZywgMik7CQkJXAo+ID4gKwljYXNlIDE6CQl3cml0ZV9kZWJ1ZyhwdHJb MV0sIHJlZywgMSk7CQkJXAo+ID4gKwlkZWZhdWx0Ogl3cml0ZV9kZWJ1ZyhwdHJbMF0sIHJlZywg MCk7CQkJXAo+ID4gKwl9Cj4gPiArCj4gPiArdm9pZCBfX2h5cF90ZXh0IF9fZGVidWdfc2F2ZV9z dGF0ZShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsCj4gPiArCQkJCSAgIHN0cnVjdCBrdm1fZ3Vlc3Rf ZGVidWdfYXJjaCAqZGJnLAo+ID4gKwkJCQkgICBzdHJ1Y3Qga3ZtX2NwdV9jb250ZXh0ICpjdHh0 KQo+ID4gK3sKPiA+ICsJaWYgKHZjcHUtPmFyY2guZGVidWdfZmxhZ3MgJiBLVk1fQVJNNjRfREVC VUdfRElSVFkpIHsKPiA+ICsJCXU2NCBhYTY0ZGZyMCA9IHJlYWRfc3lzcmVnKGlkX2FhNjRkZnIw X2VsMSk7Cj4gPiArCQlpbnQgYnJwcywgd3JwczsKPiA+ICsKPiA+ICsJCWJycHMgPSAoYWE2NGRm cjAgPj4gMTIpICYgMHhmOwo+ID4gKwkJd3JwcyA9IChhYTY0ZGZyMCA+PiAyMCkgJiAweGY7Cj4g Cj4gSSdtIHN1cmUgd2UgaGF2ZSB0aGF0IGRlZmluZWQgLSBnZXRfbnVtX2JycHMvd3JwcygpIC0g YnV0IEkgZG9uJ3Qga25vdwo+IGlmIHRoZSBjb21waWxlciB3b3VsZCBkbyBhIGJldHRlciBqb2Ig d2l0aCBpdC4KClRoZSBwcm9ibGVtIGlzIHRoYXQgaXQgbGl2ZXMgaW4gdGhlIG1haW4ga2VybmVs IHRleHQsIHdoaWNoIG1ha2VzIGl0CnVuYXZhaWxhYmxlIHRvIHRoZSBoeXAgY29kZS4KCj4gPiAr Cj4gPiArCQlzYXZlX2RlYnVnKGRiZy0+ZGJnX2JjciwgZGJnYmNyLCBicnBzKTsKPiA+ICsJCXNh dmVfZGVidWcoZGJnLT5kYmdfYnZyLCBkYmdidnIsIGJycHMpOwo+ID4gKwkJc2F2ZV9kZWJ1Zyhk YmctPmRiZ193Y3IsIGRiZ3djciwgd3Jwcyk7Cj4gPiArCQlzYXZlX2RlYnVnKGRiZy0+ZGJnX3d2 ciwgZGJnd3ZyLCB3cnBzKTsKPiA+ICsKPiA+ICsJCWN0eHQtPnN5c19yZWdzW01EQ0NJTlRfRUwx XSA9IHJlYWRfc3lzcmVnKG1kY2NpbnRfZWwxKTsKPiA+ICsJfQo+ID4gK30KPiA+ICsKPiA+ICt2 b2lkIF9faHlwX3RleHQgX19kZWJ1Z19yZXN0b3JlX3N0YXRlKHN0cnVjdCBrdm1fdmNwdSAqdmNw dSwKPiA+ICsJCQkJICAgICAgc3RydWN0IGt2bV9ndWVzdF9kZWJ1Z19hcmNoICpkYmcsCj4gPiAr CQkJCSAgICAgIHN0cnVjdCBrdm1fY3B1X2NvbnRleHQgKmN0eHQpCj4gPiArewo+ID4gKwlpZiAo dmNwdS0+YXJjaC5kZWJ1Z19mbGFncyAmIEtWTV9BUk02NF9ERUJVR19ESVJUWSkgewo+ID4gKwkJ dTY0IGFhNjRkZnIwID0gcmVhZF9zeXNyZWcoaWRfYWE2NGRmcjBfZWwxKTsKPiA+ICsJCWludCBi cnBzLCB3cnBzOwo+ID4gKwo+ID4gKwkJYnJwcyA9IChhYTY0ZGZyMCA+PiAxMikgJiAweGY7Cj4g PiArCQl3cnBzID0gKGFhNjRkZnIwID4+IDIwKSAmIDB4ZjsKPiA+ICsKPiA+ICsJCXJlc3RvcmVf ZGVidWcoZGJnLT5kYmdfYmNyLCBkYmdiY3IsIGJycHMpOwo+ID4gKwkJcmVzdG9yZV9kZWJ1Zyhk YmctPmRiZ19idnIsIGRiZ2J2ciwgYnJwcyk7Cj4gPiArCQlyZXN0b3JlX2RlYnVnKGRiZy0+ZGJn X3djciwgZGJnd2NyLCB3cnBzKTsKPiA+ICsJCXJlc3RvcmVfZGVidWcoZGJnLT5kYmdfd3ZyLCBk Ymd3dnIsIHdycHMpOwo+ID4gKwo+ID4gKwkJd3JpdGVfc3lzcmVnKGN0eHQtPnN5c19yZWdzW01E Q0NJTlRfRUwxXSwgbWRjY2ludF9lbDEpOwo+ID4gKwl9Cj4gPiArfQo+ID4gKwo+ID4gK3ZvaWQg X19oeXBfdGV4dCBfX2RlYnVnX2NvbmRfc2F2ZV9ob3N0X3N0YXRlKHN0cnVjdCBrdm1fdmNwdSAq dmNwdSkKPiA+ICt7Cj4gPiArCWlmICgodmNwdS0+YXJjaC5jdHh0LnN5c19yZWdzW01EU0NSX0VM MV0gJiBEQkdfTURTQ1JfS0RFKSB8fAo+ID4gKwkgICAgKHZjcHUtPmFyY2guY3R4dC5zeXNfcmVn c1tNRFNDUl9FTDFdICYgREJHX01EU0NSX0tERSkpCj4gPiArCQl2Y3B1LT5hcmNoLmRlYnVnX2Zs YWdzIHw9IEtWTV9BUk02NF9ERUJVR19ESVJUWTsKPiA+ICsKPiA+ICsJX19kZWJ1Z19zYXZlX3N0 YXRlKHZjcHUsICZ2Y3B1LT5hcmNoLmhvc3RfZGVidWdfc3RhdGUsCj4gPiArCQkJICAga2Vybl9o eXBfdmEodmNwdS0+YXJjaC5ob3N0X2NwdV9jb250ZXh0KSk7Cj4gPiArfQo+ID4gKwo+ID4gK3Zv aWQgX19oeXBfdGV4dCBfX2RlYnVnX2NvbmRfcmVzdG9yZV9ob3N0X3N0YXRlKHN0cnVjdCBrdm1f dmNwdSAqdmNwdSkKPiA+ICt7Cj4gPiArCWlmICh2Y3B1LT5hcmNoLmRlYnVnX2ZsYWdzICYgS1ZN X0FSTTY0X0RFQlVHX0RJUlRZKSB7Cj4gPiArCQlfX2RlYnVnX3Jlc3RvcmVfc3RhdGUodmNwdSwg JnZjcHUtPmFyY2guaG9zdF9kZWJ1Z19zdGF0ZSwKPiA+ICsJCQkJICAgICAga2Vybl9oeXBfdmEo dmNwdS0+YXJjaC5ob3N0X2NwdV9jb250ZXh0KSk7Cj4gPiArCQl2Y3B1LT5hcmNoLmRlYnVnX2Zs YWdzICY9IH5LVk1fQVJNNjRfREVCVUdfRElSVFk7Cj4gPiArCX0KPiA+ICt9Cj4gPiArCj4gPiAr dTMyIF9faHlwX3RleHQgX19kZWJ1Z19yZWFkX21kY3JfZWwyKHZvaWQpCj4gPiArewo+ID4gKwly ZXR1cm4gcmVhZF9zeXNyZWcobWRjcl9lbDIpOwo+ID4gK30KPiA+IGRpZmYgLS1naXQgYS9hcmNo L2FybTY0L2t2bS9oeXAvaHlwLmggYi9hcmNoL2FybTY0L2t2bS9oeXAvaHlwLmgKPiA+IGluZGV4 IDQ2MzkzMzAuLjI1ODEyMzIgMTAwNjQ0Cj4gPiAtLS0gYS9hcmNoL2FybTY0L2t2bS9oeXAvaHlw LmgKPiA+ICsrKyBiL2FyY2gvYXJtNjQva3ZtL2h5cC9oeXAuaAo+ID4gQEAgLTQxLDUgKzQxLDE0 IEBAIHZvaWQgX19zeXNyZWdfcmVzdG9yZV9zdGF0ZShzdHJ1Y3Qga3ZtX2NwdV9jb250ZXh0ICpj dHh0KTsKPiA+ICB2b2lkIF9fc3lzcmVnMzJfc2F2ZV9zdGF0ZShzdHJ1Y3Qga3ZtX3ZjcHUgKnZj cHUpOwo+ID4gIHZvaWQgX19zeXNyZWczMl9yZXN0b3JlX3N0YXRlKHN0cnVjdCBrdm1fdmNwdSAq dmNwdSk7Cj4gPgo+ID4gK3ZvaWQgX19kZWJ1Z19zYXZlX3N0YXRlKHN0cnVjdCBrdm1fdmNwdSAq dmNwdSwKPiA+ICsJCQlzdHJ1Y3Qga3ZtX2d1ZXN0X2RlYnVnX2FyY2ggKmRiZywKPiA+ICsJCQlz dHJ1Y3Qga3ZtX2NwdV9jb250ZXh0ICpjdHh0KTsKPiA+ICt2b2lkIF9fZGVidWdfcmVzdG9yZV9z dGF0ZShzdHJ1Y3Qga3ZtX3ZjcHUgKnZjcHUsCj4gPiArCQkJICAgc3RydWN0IGt2bV9ndWVzdF9k ZWJ1Z19hcmNoICpkYmcsCj4gPiArCQkJICAgc3RydWN0IGt2bV9jcHVfY29udGV4dCAqY3R4dCk7 Cj4gPiArdm9pZCBfX2RlYnVnX2NvbmRfc2F2ZV9ob3N0X3N0YXRlKHN0cnVjdCBrdm1fdmNwdSAq dmNwdSk7Cj4gPiArdm9pZCBfX2RlYnVnX2NvbmRfcmVzdG9yZV9ob3N0X3N0YXRlKHN0cnVjdCBr dm1fdmNwdSAqdmNwdSk7Cj4gPiArCj4gPiAgI2VuZGlmIC8qIF9fQVJNNjRfS1ZNX0hZUF9IX18g Ki8KPiAKPiBJIHNwdW4gaXQgdXAgYWdhaW5zdCBteSBLVk0gZGVidWcgdGVzdHMgYW5kIGV2ZXJ5 dGhpbmcgd2FzIGZpbmUuIEhhdmUgYToKPiAKPiBUZXN0ZWQtYnk6IEFsZXggQmVubsOpZSA8YWxl eC5iZW5uZWVAbGluYXJvLm9yZz4KPiBSZXZpZXdlZC1ieTogQWxleCBCZW5uw6llIDxhbGV4LmJl bm5lZUBsaW5hcm8ub3JnPgoKQXdlc29tZS4gVGhhbmtzIEFsZXghCgoJTS4KLS0gCkphenogaXMg bm90IGRlYWQuIEl0IGp1c3Qgc21lbGxzIGZ1bm55LgpfX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fXwprdm1hcm0gbWFpbGluZyBsaXN0Cmt2bWFybUBsaXN0cy5j cy5jb2x1bWJpYS5lZHUKaHR0cHM6Ly9saXN0cy5jcy5jb2x1bWJpYS5lZHUvbWFpbG1hbi9saXN0 aW5mby9rdm1hcm0K From mboxrd@z Thu Jan 1 00:00:00 1970 From: marc.zyngier@arm.com (Marc Zyngier) Date: Mon, 30 Nov 2015 12:24:36 +0000 Subject: [PATCH v2 08/21] arm64: KVM: Implement debug save/restore In-Reply-To: <87d1urbstj.fsf@linaro.org> References: <1448650215-15218-1-git-send-email-marc.zyngier@arm.com> <1448650215-15218-9-git-send-email-marc.zyngier@arm.com> <87d1urbstj.fsf@linaro.org> Message-ID: <20151130122436.2d1515d2@arm.com> To: linux-arm-kernel@lists.infradead.org List-Id: linux-arm-kernel.lists.infradead.org On Mon, 30 Nov 2015 12:00:24 +0000 Alex Benn?e wrote: > > Marc Zyngier writes: > > > Implement the debug save restore as a direct translation of > > the assembly code version. > > > > Signed-off-by: Marc Zyngier > > --- > > arch/arm64/kvm/hyp/Makefile | 1 + > > arch/arm64/kvm/hyp/debug-sr.c | 130 ++++++++++++++++++++++++++++++++++++++++++ > > arch/arm64/kvm/hyp/hyp.h | 9 +++ > > 3 files changed, 140 insertions(+) > > create mode 100644 arch/arm64/kvm/hyp/debug-sr.c > > > > diff --git a/arch/arm64/kvm/hyp/Makefile b/arch/arm64/kvm/hyp/Makefile > > index ec94200..ec14cac 100644 > > --- a/arch/arm64/kvm/hyp/Makefile > > +++ b/arch/arm64/kvm/hyp/Makefile > > @@ -6,3 +6,4 @@ obj-$(CONFIG_KVM_ARM_HOST) += vgic-v2-sr.o > > obj-$(CONFIG_KVM_ARM_HOST) += vgic-v3-sr.o > > obj-$(CONFIG_KVM_ARM_HOST) += timer-sr.o > > obj-$(CONFIG_KVM_ARM_HOST) += sysreg-sr.o > > +obj-$(CONFIG_KVM_ARM_HOST) += debug-sr.o > > diff --git a/arch/arm64/kvm/hyp/debug-sr.c b/arch/arm64/kvm/hyp/debug-sr.c > > new file mode 100644 > > index 0000000..a0b2b99 > > --- /dev/null > > +++ b/arch/arm64/kvm/hyp/debug-sr.c > > @@ -0,0 +1,130 @@ > > +/* > > + * Copyright (C) 2015 - ARM Ltd > > + * Author: Marc Zyngier > > + * > > + * This program is free software; you can redistribute it and/or modify > > + * it under the terms of the GNU General Public License version 2 as > > + * published by the Free Software Foundation. > > + * > > + * This program is distributed in the hope that it will be useful, > > + * but WITHOUT ANY WARRANTY; without even the implied warranty of > > + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the > > + * GNU General Public License for more details. > > + * > > + * You should have received a copy of the GNU General Public License > > + * along with this program. If not, see . > > + */ > > + > > +#include > > +#include > > + > > +#include > > + > > +#include "hyp.h" > > + > > +#define read_debug(r,n) read_sysreg(r##n##_el1) > > +#define write_debug(v,r,n) write_sysreg(v, r##n##_el1) > > + > > +#define save_debug(ptr,reg,nr) \ > > + switch (nr) { \ > > + case 15: ptr[15] = read_debug(reg, 15); \ > > + case 14: ptr[14] = read_debug(reg, 14); \ > > + case 13: ptr[13] = read_debug(reg, 13); \ > > + case 12: ptr[12] = read_debug(reg, 12); \ > > + case 11: ptr[11] = read_debug(reg, 11); \ > > + case 10: ptr[10] = read_debug(reg, 10); \ > > + case 9: ptr[9] = read_debug(reg, 9); \ > > + case 8: ptr[8] = read_debug(reg, 8); \ > > + case 7: ptr[7] = read_debug(reg, 7); \ > > + case 6: ptr[6] = read_debug(reg, 6); \ > > + case 5: ptr[5] = read_debug(reg, 5); \ > > + case 4: ptr[4] = read_debug(reg, 4); \ > > + case 3: ptr[3] = read_debug(reg, 3); \ > > + case 2: ptr[2] = read_debug(reg, 2); \ > > + case 1: ptr[1] = read_debug(reg, 1); \ > > + default: ptr[0] = read_debug(reg, 0); \ > > + } > > + > > +#define restore_debug(ptr,reg,nr) \ > > + switch (nr) { \ > > + case 15: write_debug(ptr[15], reg, 15); \ > > + case 14: write_debug(ptr[14], reg, 14); \ > > + case 13: write_debug(ptr[13], reg, 13); \ > > + case 12: write_debug(ptr[12], reg, 12); \ > > + case 11: write_debug(ptr[11], reg, 11); \ > > + case 10: write_debug(ptr[10], reg, 10); \ > > + case 9: write_debug(ptr[9], reg, 9); \ > > + case 8: write_debug(ptr[8], reg, 8); \ > > + case 7: write_debug(ptr[7], reg, 7); \ > > + case 6: write_debug(ptr[6], reg, 6); \ > > + case 5: write_debug(ptr[5], reg, 5); \ > > + case 4: write_debug(ptr[4], reg, 4); \ > > + case 3: write_debug(ptr[3], reg, 3); \ > > + case 2: write_debug(ptr[2], reg, 2); \ > > + case 1: write_debug(ptr[1], reg, 1); \ > > + default: write_debug(ptr[0], reg, 0); \ > > + } > > + > > +void __hyp_text __debug_save_state(struct kvm_vcpu *vcpu, > > + struct kvm_guest_debug_arch *dbg, > > + struct kvm_cpu_context *ctxt) > > +{ > > + if (vcpu->arch.debug_flags & KVM_ARM64_DEBUG_DIRTY) { > > + u64 aa64dfr0 = read_sysreg(id_aa64dfr0_el1); > > + int brps, wrps; > > + > > + brps = (aa64dfr0 >> 12) & 0xf; > > + wrps = (aa64dfr0 >> 20) & 0xf; > > I'm sure we have that defined - get_num_brps/wrps() - but I don't know > if the compiler would do a better job with it. The problem is that it lives in the main kernel text, which makes it unavailable to the hyp code. > > + > > + save_debug(dbg->dbg_bcr, dbgbcr, brps); > > + save_debug(dbg->dbg_bvr, dbgbvr, brps); > > + save_debug(dbg->dbg_wcr, dbgwcr, wrps); > > + save_debug(dbg->dbg_wvr, dbgwvr, wrps); > > + > > + ctxt->sys_regs[MDCCINT_EL1] = read_sysreg(mdccint_el1); > > + } > > +} > > + > > +void __hyp_text __debug_restore_state(struct kvm_vcpu *vcpu, > > + struct kvm_guest_debug_arch *dbg, > > + struct kvm_cpu_context *ctxt) > > +{ > > + if (vcpu->arch.debug_flags & KVM_ARM64_DEBUG_DIRTY) { > > + u64 aa64dfr0 = read_sysreg(id_aa64dfr0_el1); > > + int brps, wrps; > > + > > + brps = (aa64dfr0 >> 12) & 0xf; > > + wrps = (aa64dfr0 >> 20) & 0xf; > > + > > + restore_debug(dbg->dbg_bcr, dbgbcr, brps); > > + restore_debug(dbg->dbg_bvr, dbgbvr, brps); > > + restore_debug(dbg->dbg_wcr, dbgwcr, wrps); > > + restore_debug(dbg->dbg_wvr, dbgwvr, wrps); > > + > > + write_sysreg(ctxt->sys_regs[MDCCINT_EL1], mdccint_el1); > > + } > > +} > > + > > +void __hyp_text __debug_cond_save_host_state(struct kvm_vcpu *vcpu) > > +{ > > + if ((vcpu->arch.ctxt.sys_regs[MDSCR_EL1] & DBG_MDSCR_KDE) || > > + (vcpu->arch.ctxt.sys_regs[MDSCR_EL1] & DBG_MDSCR_KDE)) > > + vcpu->arch.debug_flags |= KVM_ARM64_DEBUG_DIRTY; > > + > > + __debug_save_state(vcpu, &vcpu->arch.host_debug_state, > > + kern_hyp_va(vcpu->arch.host_cpu_context)); > > +} > > + > > +void __hyp_text __debug_cond_restore_host_state(struct kvm_vcpu *vcpu) > > +{ > > + if (vcpu->arch.debug_flags & KVM_ARM64_DEBUG_DIRTY) { > > + __debug_restore_state(vcpu, &vcpu->arch.host_debug_state, > > + kern_hyp_va(vcpu->arch.host_cpu_context)); > > + vcpu->arch.debug_flags &= ~KVM_ARM64_DEBUG_DIRTY; > > + } > > +} > > + > > +u32 __hyp_text __debug_read_mdcr_el2(void) > > +{ > > + return read_sysreg(mdcr_el2); > > +} > > diff --git a/arch/arm64/kvm/hyp/hyp.h b/arch/arm64/kvm/hyp/hyp.h > > index 4639330..2581232 100644 > > --- a/arch/arm64/kvm/hyp/hyp.h > > +++ b/arch/arm64/kvm/hyp/hyp.h > > @@ -41,5 +41,14 @@ void __sysreg_restore_state(struct kvm_cpu_context *ctxt); > > void __sysreg32_save_state(struct kvm_vcpu *vcpu); > > void __sysreg32_restore_state(struct kvm_vcpu *vcpu); > > > > +void __debug_save_state(struct kvm_vcpu *vcpu, > > + struct kvm_guest_debug_arch *dbg, > > + struct kvm_cpu_context *ctxt); > > +void __debug_restore_state(struct kvm_vcpu *vcpu, > > + struct kvm_guest_debug_arch *dbg, > > + struct kvm_cpu_context *ctxt); > > +void __debug_cond_save_host_state(struct kvm_vcpu *vcpu); > > +void __debug_cond_restore_host_state(struct kvm_vcpu *vcpu); > > + > > #endif /* __ARM64_KVM_HYP_H__ */ > > I spun it up against my KVM debug tests and everything was fine. Have a: > > Tested-by: Alex Benn?e > Reviewed-by: Alex Benn?e Awesome. Thanks Alex! M. -- Jazz is not dead. It just smells funny.