From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mx3-rdu2.redhat.com ([66.187.233.73] helo=mx1.redhat.com) by merlin.infradead.org with esmtps (Exim 4.90_1 #2 (Red Hat Linux)) id 1fVHuh-0003qF-B0 for kexec@lists.infradead.org; Tue, 19 Jun 2018 14:47:20 +0000 Subject: Re: [PATCH 4/4 V3] Help to dump the old memory encrypted into vmcore file References: <20180616082714.32035-1-lijiang@redhat.com> <20180616082714.32035-5-lijiang@redhat.com> <20180619031653.GA7101@dhcp-128-65.nay.redhat.com> From: lijiang Message-ID: Date: Tue, 19 Jun 2018 22:46:41 +0800 MIME-Version: 1.0 In-Reply-To: <20180619031653.GA7101@dhcp-128-65.nay.redhat.com> Content-Language: en-US List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "kexec" Errors-To: kexec-bounces+dwmw2=infradead.org@lists.infradead.org To: Dave Young Cc: thomas.lendacky@amd.com, iommu@lists.linux-foundation.org, kexec@lists.infradead.org, linux-kernel@vger.kernel.org 5ZyoIDIwMTjlubQwNuaciDE55pelIDExOjE2LCBEYXZlIFlvdW5nIOWGmemBkzoKPiBPbiAwNi8x Ni8xOCBhdCAwNDoyN3BtLCBMaWFuYm8gSmlhbmcgd3JvdGU6Cj4+IEluIGtkdW1wIG1vZGUsIHdl IG5lZWQgdG8gZHVtcCB0aGUgb2xkIG1lbW9yeSBpbnRvIHZtY29yZSBmaWxlLAo+PiBpZiBTTUUg aXMgZW5hYmxlZCBpbiB0aGUgZmlyc3Qga2VybmVsLCB3ZSBtdXN0IHJlbWFwIHRoZSBvbGQKPj4g bWVtb3J5IGluIGVuY3J5cHRlZCBtYW5uZXIsIHdoaWNoIHdpbGwgYmUgYXV0b21hdGljYWxseSBk ZWNyeXB0ZWQKPj4gd2hlbiB3ZSByZWFkIGZyb20gRFJBTS4gSXQgaGVscHMgdG8gcGFyc2UgdGhl IHZtY29yZSBmb3Igc29tZSB0b29scy4KPj4KPj4gU2lnbmVkLW9mZi1ieTogTGlhbmJvIEppYW5n IDxsaWppYW5nQHJlZGhhdC5jb20+Cj4+IC0tLQo+PiBTb21lIGNoYW5nZXM6Cj4+IDEuIGFkZCBh IG5ldyBmaWxlIGFuZCBtb2RpZnkgTWFrZWZpbGUuCj4+IDIuIHJlbW92ZSBzb21lIGNvZGUgaW4g c2V2X2FjdGl2ZSgpLgo+Pgo+PiAgYXJjaC94ODYva2VybmVsL01ha2VmaWxlICAgICAgICAgICAg IHwgIDEgKwo+PiAgYXJjaC94ODYva2VybmVsL2NyYXNoX2R1bXBfZW5jcnlwdC5jIHwgNTMgKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCj4+ICBmcy9wcm9jL3ZtY29yZS5jICAg ICAgICAgICAgICAgICAgICAgfCAyMCArKysrKysrKysrLS0tLQo+PiAgaW5jbHVkZS9saW51eC9j cmFzaF9kdW1wLmggICAgICAgICAgIHwgMTEgKysrKysrKysKPj4gIDQgZmlsZXMgY2hhbmdlZCwg NzkgaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkKPj4gIGNyZWF0ZSBtb2RlIDEwMDY0NCBh cmNoL3g4Ni9rZXJuZWwvY3Jhc2hfZHVtcF9lbmNyeXB0LmMKPj4KPj4gZGlmZiAtLWdpdCBhL2Fy Y2gveDg2L2tlcm5lbC9NYWtlZmlsZSBiL2FyY2gveDg2L2tlcm5lbC9NYWtlZmlsZQo+PiBpbmRl eCAwMmQ2ZjVjLi5hZmI1YmFkIDEwMDY0NAo+PiAtLS0gYS9hcmNoL3g4Ni9rZXJuZWwvTWFrZWZp bGUKPj4gKysrIGIvYXJjaC94ODYva2VybmVsL01ha2VmaWxlCj4+IEBAIC05Niw2ICs5Niw3IEBA IG9iai0kKENPTkZJR19LRVhFQ19DT1JFKQkrPSBtYWNoaW5lX2tleGVjXyQoQklUUykubwo+PiAg b2JqLSQoQ09ORklHX0tFWEVDX0NPUkUpCSs9IHJlbG9jYXRlX2tlcm5lbF8kKEJJVFMpLm8gY3Jh c2gubwo+PiAgb2JqLSQoQ09ORklHX0tFWEVDX0ZJTEUpCSs9IGtleGVjLWJ6aW1hZ2U2NC5vCj4+ ICBvYmotJChDT05GSUdfQ1JBU0hfRFVNUCkJKz0gY3Jhc2hfZHVtcF8kKEJJVFMpLm8KPj4gK29i ai0kKENPTkZJR19BTURfTUVNX0VOQ1JZUFQpCSs9IGNyYXNoX2R1bXBfZW5jcnlwdC5vCj4+ICBv YmoteQkJCQkrPSBrcHJvYmVzLwo+PiAgb2JqLSQoQ09ORklHX01PRFVMRVMpCQkrPSBtb2R1bGUu bwo+PiAgb2JqLSQoQ09ORklHX0RPVUJMRUZBVUxUKQkrPSBkb3VibGVmYXVsdC5vCj4+IGRpZmYg LS1naXQgYS9hcmNoL3g4Ni9rZXJuZWwvY3Jhc2hfZHVtcF9lbmNyeXB0LmMgYi9hcmNoL3g4Ni9r ZXJuZWwvY3Jhc2hfZHVtcF9lbmNyeXB0LmMKPj4gbmV3IGZpbGUgbW9kZSAxMDA2NDQKPj4gaW5k ZXggMDAwMDAwMC4uZTQ0ZWYzMwo+PiAtLS0gL2Rldi9udWxsCj4+ICsrKyBiL2FyY2gveDg2L2tl cm5lbC9jcmFzaF9kdW1wX2VuY3J5cHQuYwo+PiBAQCAtMCwwICsxLDUzIEBACj4+ICsvLyBTUERY LUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAo+PiArLyoKPj4gKyAqCU1lbW9yeSBwcmVzZXJ2 aW5nIHJlYm9vdCByZWxhdGVkIGNvZGUuCj4+ICsgKgo+PiArICoJQ3JlYXRlZCBieTogTGlhbmJv IEppYW5nIChsaWppYW5nQHJlZGhhdC5jb20pCj4+ICsgKglDb3B5cmlnaHQgKEMpIFJlZEhhdCBD b3Jwb3JhdGlvbiwgMjAxOC4gQWxsIHJpZ2h0cyByZXNlcnZlZAo+PiArICovCj4+ICsKPj4gKyNp bmNsdWRlIDxsaW51eC9lcnJuby5oPgo+PiArI2luY2x1ZGUgPGxpbnV4L2NyYXNoX2R1bXAuaD4K Pj4gKyNpbmNsdWRlIDxsaW51eC91YWNjZXNzLmg+Cj4+ICsjaW5jbHVkZSA8bGludXgvaW8uaD4K Pj4gKwo+PiArLyoqCj4+ICsgKiBjb3B5X29sZG1lbV9wYWdlX2VuY3J5cHRlZCAtIGNvcHkgb25l IHBhZ2UgZnJvbSAib2xkbWVtIGVuY3J5cHRlZCIKPj4gKyAqIEBwZm46IHBhZ2UgZnJhbWUgbnVt YmVyIHRvIGJlIGNvcGllZAo+PiArICogQGJ1ZjogdGFyZ2V0IG1lbW9yeSBhZGRyZXNzIGZvciB0 aGUgY29weTsgdGhpcyBjYW4gYmUgaW4ga2VybmVsIGFkZHJlc3MKPj4gKyAqCXNwYWNlIG9yIHVz ZXIgYWRkcmVzcyBzcGFjZSAoc2VlIEB1c2VyYnVmKQo+PiArICogQGNzaXplOiBudW1iZXIgb2Yg Ynl0ZXMgdG8gY29weQo+PiArICogQG9mZnNldDogb2Zmc2V0IGluIGJ5dGVzIGludG8gdGhlIHBh Z2UgKGJhc2VkIG9uIHBmbikgdG8gYmVnaW4gdGhlIGNvcHkKPj4gKyAqIEB1c2VyYnVmOiBpZiBz ZXQsIEBidWYgaXMgaW4gdXNlciBhZGRyZXNzIHNwYWNlLCB1c2UgY29weV90b191c2VyKCksCj4+ ICsgKglvdGhlcndpc2UgQGJ1ZiBpcyBpbiBrZXJuZWwgYWRkcmVzcyBzcGFjZSwgdXNlIG1lbWNw eSgpLgo+PiArICoKPj4gKyAqIENvcHkgYSBwYWdlIGZyb20gIm9sZG1lbSBlbmNyeXB0ZWQiLiBG b3IgdGhpcyBwYWdlLCB0aGVyZSBpcyBubyBwdGUKPj4gKyAqIG1hcHBlZCBpbiB0aGUgY3VycmVu dCBrZXJuZWwuIFdlIHN0aXRjaCB1cCBhIHB0ZSwgc2ltaWxhciB0bwo+PiArICoga21hcF9hdG9t aWMuCj4+ICsgKi8KPj4gKwo+PiArc3NpemVfdCBjb3B5X29sZG1lbV9wYWdlX2VuY3J5cHRlZCh1 bnNpZ25lZCBsb25nIHBmbiwgY2hhciAqYnVmLAo+PiArCQlzaXplX3QgY3NpemUsIHVuc2lnbmVk IGxvbmcgb2Zmc2V0LCBpbnQgdXNlcmJ1ZikKPj4gK3sKPj4gKwl2b2lkICAqdmFkZHI7Cj4+ICsK Pj4gKwlpZiAoIWNzaXplKQo+PiArCQlyZXR1cm4gMDsKPj4gKwo+PiArCXZhZGRyID0gKF9fZm9y Y2Ugdm9pZCAqKWlvcmVtYXBfZW5jcnlwdGVkKHBmbiA8PCBQQUdFX1NISUZULAo+PiArCQkJCQkJ ICBQQUdFX1NJWkUpOwo+PiArCWlmICghdmFkZHIpCj4+ICsJCXJldHVybiAtRU5PTUVNOwo+PiAr Cj4+ICsJaWYgKHVzZXJidWYpIHsKPj4gKwkJaWYgKGNvcHlfdG9fdXNlcigodm9pZCBfX3VzZXIg KilidWYsIHZhZGRyICsgb2Zmc2V0LCBjc2l6ZSkpIHsKPj4gKwkJCWlvdW5tYXAoKHZvaWQgX19p b21lbSAqKXZhZGRyKTsKPj4gKwkJCXJldHVybiAtRUZBVUxUOwo+PiArCQl9Cj4+ICsJfSBlbHNl Cj4+ICsJCW1lbWNweShidWYsIHZhZGRyICsgb2Zmc2V0LCBjc2l6ZSk7Cj4+ICsKPj4gKwlzZXRf aW91bm1hcF9ub25sYXp5KCk7Cj4+ICsJaW91bm1hcCgodm9pZCBfX2lvbWVtICopdmFkZHIpOwo+ PiArCXJldHVybiBjc2l6ZTsKPj4gK30KPj4gZGlmZiAtLWdpdCBhL2ZzL3Byb2Mvdm1jb3JlLmMg Yi9mcy9wcm9jL3ZtY29yZS5jCj4+IGluZGV4IGE0NWYwYWYuLjUyMDAyNjYgMTAwNjQ0Cj4+IC0t LSBhL2ZzL3Byb2Mvdm1jb3JlLmMKPj4gKysrIGIvZnMvcHJvYy92bWNvcmUuYwo+PiBAQCAtMjUs NiArMjUsOCBAQAo+PiAgI2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KPj4gICNpbmNsdWRlIDxh c20vaW8uaD4KPj4gICNpbmNsdWRlICJpbnRlcm5hbC5oIgo+PiArI2luY2x1ZGUgPGxpbnV4L21l bV9lbmNyeXB0Lmg+Cj4+ICsjaW5jbHVkZSA8YXNtL3BndGFibGUuaD4KPj4gIAo+PiAgLyogTGlz dCByZXByZXNlbnRpbmcgY2h1bmtzIG9mIGNvbnRpZ3VvdXMgbWVtb3J5IGFyZWFzIGFuZCB0aGVp ciBvZmZzZXRzIGluCj4+ICAgKiB2bWNvcmUgZmlsZS4KPj4gQEAgLTg2LDcgKzg4LDggQEAgc3Rh dGljIGludCBwZm5faXNfcmFtKHVuc2lnbmVkIGxvbmcgcGZuKQo+PiAgCj4+ICAvKiBSZWFkcyBh IHBhZ2UgZnJvbSB0aGUgb2xkbWVtIGRldmljZSBmcm9tIGdpdmVuIG9mZnNldC4gKi8KPj4gIHN0 YXRpYyBzc2l6ZV90IHJlYWRfZnJvbV9vbGRtZW0oY2hhciAqYnVmLCBzaXplX3QgY291bnQsCj4+ IC0JCQkJdTY0ICpwcG9zLCBpbnQgdXNlcmJ1ZikKPj4gKwkJCQl1NjQgKnBwb3MsIGludCB1c2Vy YnVmLAo+PiArCQkJCWJvb2wgZW5jcnlwdGVkKQo+PiAgewo+PiAgCXVuc2lnbmVkIGxvbmcgcGZu LCBvZmZzZXQ7Cj4+ICAJc2l6ZV90IG5yX2J5dGVzOwo+PiBAQCAtMTA4LDggKzExMSwxMSBAQCBz dGF0aWMgc3NpemVfdCByZWFkX2Zyb21fb2xkbWVtKGNoYXIgKmJ1Ziwgc2l6ZV90IGNvdW50LAo+ PiAgCQlpZiAocGZuX2lzX3JhbShwZm4pID09IDApCj4+ICAJCQltZW1zZXQoYnVmLCAwLCBucl9i eXRlcyk7Cj4+ICAJCWVsc2Ugewo+PiAtCQkJdG1wID0gY29weV9vbGRtZW1fcGFnZShwZm4sIGJ1 ZiwgbnJfYnl0ZXMsCj4+IC0JCQkJCQlvZmZzZXQsIHVzZXJidWYpOwo+PiArCQkJdG1wID0gZW5j cnlwdGVkID8gY29weV9vbGRtZW1fcGFnZV9lbmNyeXB0ZWQocGZuLAo+PiArCQkJCQkgICAgYnVm LCBucl9ieXRlcywgb2Zmc2V0LCB1c2VyYnVmKQo+PiArCQkJCQk6IGNvcHlfb2xkbWVtX3BhZ2Uo cGZuLCBidWYsIG5yX2J5dGVzLAo+PiArCQkJCQkJCSAgIG9mZnNldCwgdXNlcmJ1Zik7Cj4+ICsK Pj4gIAkJCWlmICh0bXAgPCAwKQo+PiAgCQkJCXJldHVybiB0bXA7Cj4+ICAJCX0KPj4gQEAgLTE0 Myw3ICsxNDksNyBAQCB2b2lkIF9fd2VhayBlbGZjb3JlaGRyX2ZyZWUodW5zaWduZWQgbG9uZyBs b25nIGFkZHIpCj4+ICAgKi8KPj4gIHNzaXplX3QgX193ZWFrIGVsZmNvcmVoZHJfcmVhZChjaGFy ICpidWYsIHNpemVfdCBjb3VudCwgdTY0ICpwcG9zKQo+PiAgewo+PiAtCXJldHVybiByZWFkX2Zy b21fb2xkbWVtKGJ1ZiwgY291bnQsIHBwb3MsIDApOwo+PiArCXJldHVybiByZWFkX2Zyb21fb2xk bWVtKGJ1ZiwgY291bnQsIHBwb3MsIDAsIGZhbHNlKTsKPiAKPiBUaGUgZWxmIGhlYWRlciBhY3R1 YWxseSBzdGF5cyBpbiBrZHVtcCBrZXJuZWwgcmVzZXJ2ZWQgbWVtb3J5IHNvIGl0IGlzCj4gbm90 ICJvbGRtZW0iLCB0aGUgb3JpZ2luYWwgZnVuY3Rpb24gaXMgbWlzbGVhZGluZyBhbmQgZG9pbmcg dW5uZWNlc3NhcnkKPiB0aGluZ3MuICBCdXQgYXMgZm9yIHlvdXIgcGF0Y2ggbWF5YmUgdXNpbmcg aXQgYXMgaXMgaXMgZ29vZCBmb3IgdGhlIHRpbWUKPiBiZWluZyBhbmQgYWRkIGEgY29kZSBjb21t ZW50IHdoeSB0aGUgZW5jcnlwdGVkIGlzICJmYWxzZSIuCj4gClRoYW5rIHlvdSwgRGF2ZS4gSXQg aXMgYSBnb29kIGlkZWEgdG8gYWRkIHNvbWUgY29tbWVudHMgZm9yIHRoZSBjb2RlLgpJIHJlY2hl Y2tlZCB0aGUgY29kZSwgdGhlIGVsZiBoZWFkZXIgc2hvdWxkIGJlIHN0aWxsIHRoZSBvbGQgbWVt b3J5IGluIHRoZSBmaXJzdCBrZXJuZWwsCmJ1dCB3aHkgaXMgdGhlIG9sZCBtZW1vcnkgdW5lbmNy eXB0ZWQ/IEJlY2F1c2UgaXQgY29waWVzIHRoZSBlbGYgaGVhZGVyIGZyb20gdGhlIG1lbW9yeQpl bmNyeXB0ZWQodXNlciBzcGFjZSkgdG8gdGhlIG1lbW9yeSB1bmVuY3J5cHRlZChrZXJuZWwgc3Bh Y2UpIHdoZW4gU01FIGlzIGFjdGl2YXRlZCBpbiB0aGUKZmlyc3Qga2VybmVsLCB0aGlzIG9wZXJh dGlvbiBqdXN0IGxlYWRzIHRvIGRlY3J5cHRpb24uCgpUaGFua3MuCkxpYW5ibwo+IAkvKiBlbGZj b3JlaGRyIHN0YXlzIGluIGtkdW1wIGtlcm5lbCBtZW1vcnkgYW5kIGl0IGlzIG5vdCBlbmNyeXB0 ZWQuICovCj4gCXJldHVybiByZWFkX2Zyb21fb2xkbWVtKGJ1ZiwgY291bnQsIHBwb3MsIDAsIGZh bHNlKTsKPiAKPiAKPiBJJ20gdGhpbmtpbmcgdG8gbW92ZSB0aGUgZnVuY3Rpb24gdG8gc29tZXRo aW5nIGxpa2UgYmVsb3csIHN0aWxsIG5vdCBzdXJlCj4gbWVtcmVtYXAgd29ya3Mgb24gZXZlcnkg YXJjaGVzIG9yIG5vdCwgc3RpbGwgbmVlZCBtb3JlIHRlc3QKPiAKPiBkaWZmIC0tZ2l0IGEvZnMv cHJvYy92bWNvcmUuYyBiL2ZzL3Byb2Mvdm1jb3JlLmMKPiBpbmRleCBjZmI2Njc0MzMxZmQuLjQw YzAxY2M0MmIzOCAxMDA2NDQKPiAtLS0gYS9mcy9wcm9jL3ZtY29yZS5jCj4gKysrIGIvZnMvcHJv Yy92bWNvcmUuYwo+IEBAIC0xMzYsNiArMTM2LDI0IEBAIHN0YXRpYyBzc2l6ZV90IHJlYWRfZnJv bV9vbGRtZW0oY2hhciAqYnVmLCBzaXplX3QgY291bnQsCj4gIAlyZXR1cm4gcmVhZDsKPiAgfQo+ ICAKPiArc3RhdGljIHNzaXplX3QgcmVhZF9mcm9tX21lbShjaGFyICpidWYsIHNpemVfdCBjb3Vu dCwgdTY0ICpwcG9zKQo+ICt7Cj4gKwlyZXNvdXJjZV9zaXplX3Qgb2Zmc2V0ID0gKHJlc291cmNl X3NpemVfdCkqcHBvczsKPiArCWNoYXIgKmtidWY7Cj4gKwo+ICsJaWYgKCFjb3VudCkKPiArCQly ZXR1cm4gMDsKPiArCj4gKwlrYnVmID0gbWVtcmVtYXAob2Zmc2V0LCBjb3VudCwgTUVNUkVNQVBf V0IpOwo+ICsJaWYgKCFrYnVmKQo+ICsJCXJldHVybiAwOwo+ICsKPiArCW1lbWNweShidWYsIGti dWYsIGNvdW50KTsKPiArCW1lbXVubWFwKGtidWYpOwo+ICsKPiArCXJldHVybiBjb3VudDsKPiAr fQo+ICsKPiAgLyoKPiAgICogQXJjaGl0ZWN0dXJlcyBtYXkgb3ZlcnJpZGUgdGhpcyBmdW5jdGlv biB0byBhbGxvY2F0ZSBFTEYgaGVhZGVyIGluIDJuZCBrZXJuZWwKPiAgICovCj4gQEAgLTE1NSw3 ICsxNzMsNyBAQCB2b2lkIF9fd2VhayBlbGZjb3JlaGRyX2ZyZWUodW5zaWduZWQgbG9uZyBsb25n IGFkZHIpCj4gICAqLwo+ICBzc2l6ZV90IF9fd2VhayBlbGZjb3JlaGRyX3JlYWQoY2hhciAqYnVm LCBzaXplX3QgY291bnQsIHU2NCAqcHBvcykKPiAgewo+IC0JcmV0dXJuIHJlYWRfZnJvbV9vbGRt ZW0oYnVmLCBjb3VudCwgcHBvcywgMCk7Cj4gKwlyZXR1cm4gcmVhZF9mcm9tX21lbShidWYsIGNv dW50LCBwcG9zKTsKPiAgfQo+ICAKPiAgLyoKPiAgCj4gCj4+ICB9Cj4+ICAKPj4gIC8qCj4+IEBA IC0xNTEsNyArMTU3LDcgQEAgc3NpemVfdCBfX3dlYWsgZWxmY29yZWhkcl9yZWFkKGNoYXIgKmJ1 Ziwgc2l6ZV90IGNvdW50LCB1NjQgKnBwb3MpCj4+ICAgKi8KPj4gIHNzaXplX3QgX193ZWFrIGVs ZmNvcmVoZHJfcmVhZF9ub3RlcyhjaGFyICpidWYsIHNpemVfdCBjb3VudCwgdTY0ICpwcG9zKQo+ PiAgewo+PiAtCXJldHVybiByZWFkX2Zyb21fb2xkbWVtKGJ1ZiwgY291bnQsIHBwb3MsIDApOwo+ PiArCXJldHVybiByZWFkX2Zyb21fb2xkbWVtKGJ1ZiwgY291bnQsIHBwb3MsIDAsIHNtZV9hY3Rp dmUoKSk7Cj4+ICB9Cj4+ICAKPj4gIC8qCj4+IEBAIC0xNjEsNiArMTY3LDcgQEAgaW50IF9fd2Vh ayByZW1hcF9vbGRtZW1fcGZuX3JhbmdlKHN0cnVjdCB2bV9hcmVhX3N0cnVjdCAqdm1hLAo+PiAg CQkJCSAgdW5zaWduZWQgbG9uZyBmcm9tLCB1bnNpZ25lZCBsb25nIHBmbiwKPj4gIAkJCQkgIHVu c2lnbmVkIGxvbmcgc2l6ZSwgcGdwcm90X3QgcHJvdCkKPj4gIHsKPj4gKwlwcm90ID0gcGdwcm90 X2VuY3J5cHRlZChwcm90KTsKPj4gIAlyZXR1cm4gcmVtYXBfcGZuX3JhbmdlKHZtYSwgZnJvbSwg cGZuLCBzaXplLCBwcm90KTsKPj4gIH0KPj4gIAo+PiBAQCAtMjM1LDcgKzI0Miw4IEBAIHN0YXRp YyBzc2l6ZV90IF9fcmVhZF92bWNvcmUoY2hhciAqYnVmZmVyLCBzaXplX3QgYnVmbGVuLCBsb2Zm X3QgKmZwb3MsCj4+ICAJCQkJCSAgICBtLT5vZmZzZXQgKyBtLT5zaXplIC0gKmZwb3MsCj4+ICAJ CQkJCSAgICBidWZsZW4pOwo+PiAgCQkJc3RhcnQgPSBtLT5wYWRkciArICpmcG9zIC0gbS0+b2Zm c2V0Owo+PiAtCQkJdG1wID0gcmVhZF9mcm9tX29sZG1lbShidWZmZXIsIHRzeiwgJnN0YXJ0LCB1 c2VyYnVmKTsKPj4gKwkJCXRtcCA9IHJlYWRfZnJvbV9vbGRtZW0oYnVmZmVyLCB0c3osICZzdGFy dCwgdXNlcmJ1ZiwKPj4gKwkJCQkJCXNtZV9hY3RpdmUoKSk7Cj4+ICAJCQlpZiAodG1wIDwgMCkK Pj4gIAkJCQlyZXR1cm4gdG1wOwo+PiAgCQkJYnVmbGVuIC09IHRzejsKPj4gZGlmZiAtLWdpdCBh L2luY2x1ZGUvbGludXgvY3Jhc2hfZHVtcC5oIGIvaW5jbHVkZS9saW51eC9jcmFzaF9kdW1wLmgK Pj4gaW5kZXggZjdhYzJhYS4uZjM0MTRmZiAxMDA2NDQKPj4gLS0tIGEvaW5jbHVkZS9saW51eC9j cmFzaF9kdW1wLmgKPj4gKysrIGIvaW5jbHVkZS9saW51eC9jcmFzaF9kdW1wLmgKPj4gQEAgLTI1 LDYgKzI1LDE3IEBAIGV4dGVybiBpbnQgcmVtYXBfb2xkbWVtX3Bmbl9yYW5nZShzdHJ1Y3Qgdm1f YXJlYV9zdHJ1Y3QgKnZtYSwKPj4gIAo+PiAgZXh0ZXJuIHNzaXplX3QgY29weV9vbGRtZW1fcGFn ZSh1bnNpZ25lZCBsb25nLCBjaGFyICosIHNpemVfdCwKPj4gIAkJCQkJCXVuc2lnbmVkIGxvbmcs IGludCk7Cj4+ICsjaWZkZWYgQ09ORklHX0FNRF9NRU1fRU5DUllQVAo+PiArZXh0ZXJuIHNzaXpl X3QgY29weV9vbGRtZW1fcGFnZV9lbmNyeXB0ZWQodW5zaWduZWQgbG9uZyBwZm4sIGNoYXIgKmJ1 ZiwKPj4gKwkJCQkJICAgc2l6ZV90IGNzaXplLCB1bnNpZ25lZCBsb25nIG9mZnNldCwKPj4gKwkJ CQkJICAgaW50IHVzZXJidWYpOwo+PiArI2Vsc2UKPj4gK3N0YXRpYyBpbmxpbmUgc3NpemVfdCBj b3B5X29sZG1lbV9wYWdlX2VuY3J5cHRlZCh1bnNpZ25lZCBsb25nIHBmbiwgY2hhciAqYnVmLAo+ PiArCQkJCQlzaXplX3QgY3NpemUsIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LAo+PiArCQkJCQlpbnQg dXNlcmJ1Zikgewo+IAo+IFBlcnNvbmFsbHkgSSBwcmVmZXIgYmVsb3cgYmVjYXVzZSBpdCBpcyB0 b28gbG9uZzoKPiAKPiBzdGF0aWMgaW5saW5lCj4gc3NpemVfdCBjb3B5X29sZG1lbV9wYWdlX2Vu Y3J5cHRlZCh1bnNpZ25lZCBsb25nIHBmbiwgY2hhciAqYnVmLCBzaXplX3QgY3NpemUsCj4gCQkJ CSAgIHVuc2lnbmVkIGxvbmcgb2Zmc2V0LCBpbnQgdXNlcmJ1ZikKPiB7Cj4gCXJldHVybiAwOwo+ IH0KPiAJCQkKPiAKPj4gKwlyZXR1cm4gY3NpemU7Cj4gCj4gQXMgYWJvdmUgaXQgc2hvdWxkIGJl IHJldHVybiAwOwo+IAo+PiArfQo+PiArI2VuZGlmCj4+ICB2b2lkIHZtY29yZV9jbGVhbnVwKHZv aWQpOwo+PiAgCj4+ICAvKiBBcmNoaXRlY3R1cmUgY29kZSBkZWZpbmVzIHRoaXMgaWYgdGhlcmUg YXJlIG90aGVyIHBvc3NpYmxlIEVMRgo+PiAtLSAKPj4gMi45LjUKPj4KPj4KPj4gX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KPj4ga2V4ZWMgbWFpbGluZyBs aXN0Cj4+IGtleGVjQGxpc3RzLmluZnJhZGVhZC5vcmcKPj4gaHR0cDovL2xpc3RzLmluZnJhZGVh ZC5vcmcvbWFpbG1hbi9saXN0aW5mby9rZXhlYwo+IAo+IFRoYW5rcwo+IERhdmUKPiAKCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmtleGVjIG1haWxpbmcg bGlzdAprZXhlY0BsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3Jn L21haWxtYW4vbGlzdGluZm8va2V4ZWMK From mboxrd@z Thu Jan 1 00:00:00 1970 From: lijiang Subject: Re: [PATCH 4/4 V3] Help to dump the old memory encrypted into vmcore file Date: Tue, 19 Jun 2018 22:46:41 +0800 Message-ID: References: <20180616082714.32035-1-lijiang@redhat.com> <20180616082714.32035-5-lijiang@redhat.com> <20180619031653.GA7101@dhcp-128-65.nay.redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8bit Return-path: In-Reply-To: <20180619031653.GA7101@dhcp-128-65.nay.redhat.com> Content-Language: en-US Sender: linux-kernel-owner@vger.kernel.org To: Dave Young Cc: linux-kernel@vger.kernel.org, thomas.lendacky@amd.com, iommu@lists.linux-foundation.org, kexec@lists.infradead.org List-Id: iommu@lists.linux-foundation.org 在 2018年06月19日 11:16, Dave Young 写道: > On 06/16/18 at 04:27pm, Lianbo Jiang wrote: >> In kdump mode, we need to dump the old memory into vmcore file, >> if SME is enabled in the first kernel, we must remap the old >> memory in encrypted manner, which will be automatically decrypted >> when we read from DRAM. It helps to parse the vmcore for some tools. >> >> Signed-off-by: Lianbo Jiang >> --- >> Some changes: >> 1. add a new file and modify Makefile. >> 2. remove some code in sev_active(). >> >> arch/x86/kernel/Makefile | 1 + >> arch/x86/kernel/crash_dump_encrypt.c | 53 ++++++++++++++++++++++++++++++++++++ >> fs/proc/vmcore.c | 20 ++++++++++---- >> include/linux/crash_dump.h | 11 ++++++++ >> 4 files changed, 79 insertions(+), 6 deletions(-) >> create mode 100644 arch/x86/kernel/crash_dump_encrypt.c >> >> diff --git a/arch/x86/kernel/Makefile b/arch/x86/kernel/Makefile >> index 02d6f5c..afb5bad 100644 >> --- a/arch/x86/kernel/Makefile >> +++ b/arch/x86/kernel/Makefile >> @@ -96,6 +96,7 @@ obj-$(CONFIG_KEXEC_CORE) += machine_kexec_$(BITS).o >> obj-$(CONFIG_KEXEC_CORE) += relocate_kernel_$(BITS).o crash.o >> obj-$(CONFIG_KEXEC_FILE) += kexec-bzimage64.o >> obj-$(CONFIG_CRASH_DUMP) += crash_dump_$(BITS).o >> +obj-$(CONFIG_AMD_MEM_ENCRYPT) += crash_dump_encrypt.o >> obj-y += kprobes/ >> obj-$(CONFIG_MODULES) += module.o >> obj-$(CONFIG_DOUBLEFAULT) += doublefault.o >> diff --git a/arch/x86/kernel/crash_dump_encrypt.c b/arch/x86/kernel/crash_dump_encrypt.c >> new file mode 100644 >> index 0000000..e44ef33 >> --- /dev/null >> +++ b/arch/x86/kernel/crash_dump_encrypt.c >> @@ -0,0 +1,53 @@ >> +// SPDX-License-Identifier: GPL-2.0 >> +/* >> + * Memory preserving reboot related code. >> + * >> + * Created by: Lianbo Jiang (lijiang@redhat.com) >> + * Copyright (C) RedHat Corporation, 2018. All rights reserved >> + */ >> + >> +#include >> +#include >> +#include >> +#include >> + >> +/** >> + * copy_oldmem_page_encrypted - copy one page from "oldmem encrypted" >> + * @pfn: page frame number to be copied >> + * @buf: target memory address for the copy; this can be in kernel address >> + * space or user address space (see @userbuf) >> + * @csize: number of bytes to copy >> + * @offset: offset in bytes into the page (based on pfn) to begin the copy >> + * @userbuf: if set, @buf is in user address space, use copy_to_user(), >> + * otherwise @buf is in kernel address space, use memcpy(). >> + * >> + * Copy a page from "oldmem encrypted". For this page, there is no pte >> + * mapped in the current kernel. We stitch up a pte, similar to >> + * kmap_atomic. >> + */ >> + >> +ssize_t copy_oldmem_page_encrypted(unsigned long pfn, char *buf, >> + size_t csize, unsigned long offset, int userbuf) >> +{ >> + void *vaddr; >> + >> + if (!csize) >> + return 0; >> + >> + vaddr = (__force void *)ioremap_encrypted(pfn << PAGE_SHIFT, >> + PAGE_SIZE); >> + if (!vaddr) >> + return -ENOMEM; >> + >> + if (userbuf) { >> + if (copy_to_user((void __user *)buf, vaddr + offset, csize)) { >> + iounmap((void __iomem *)vaddr); >> + return -EFAULT; >> + } >> + } else >> + memcpy(buf, vaddr + offset, csize); >> + >> + set_iounmap_nonlazy(); >> + iounmap((void __iomem *)vaddr); >> + return csize; >> +} >> diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c >> index a45f0af..5200266 100644 >> --- a/fs/proc/vmcore.c >> +++ b/fs/proc/vmcore.c >> @@ -25,6 +25,8 @@ >> #include >> #include >> #include "internal.h" >> +#include >> +#include >> >> /* List representing chunks of contiguous memory areas and their offsets in >> * vmcore file. >> @@ -86,7 +88,8 @@ static int pfn_is_ram(unsigned long pfn) >> >> /* Reads a page from the oldmem device from given offset. */ >> static ssize_t read_from_oldmem(char *buf, size_t count, >> - u64 *ppos, int userbuf) >> + u64 *ppos, int userbuf, >> + bool encrypted) >> { >> unsigned long pfn, offset; >> size_t nr_bytes; >> @@ -108,8 +111,11 @@ static ssize_t read_from_oldmem(char *buf, size_t count, >> if (pfn_is_ram(pfn) == 0) >> memset(buf, 0, nr_bytes); >> else { >> - tmp = copy_oldmem_page(pfn, buf, nr_bytes, >> - offset, userbuf); >> + tmp = encrypted ? copy_oldmem_page_encrypted(pfn, >> + buf, nr_bytes, offset, userbuf) >> + : copy_oldmem_page(pfn, buf, nr_bytes, >> + offset, userbuf); >> + >> if (tmp < 0) >> return tmp; >> } >> @@ -143,7 +149,7 @@ void __weak elfcorehdr_free(unsigned long long addr) >> */ >> ssize_t __weak elfcorehdr_read(char *buf, size_t count, u64 *ppos) >> { >> - return read_from_oldmem(buf, count, ppos, 0); >> + return read_from_oldmem(buf, count, ppos, 0, false); > > The elf header actually stays in kdump kernel reserved memory so it is > not "oldmem", the original function is misleading and doing unnecessary > things. But as for your patch maybe using it as is is good for the time > being and add a code comment why the encrypted is "false". > Thank you, Dave. It is a good idea to add some comments for the code. I rechecked the code, the elf header should be still the old memory in the first kernel, but why is the old memory unencrypted? Because it copies the elf header from the memory encrypted(user space) to the memory unencrypted(kernel space) when SME is activated in the first kernel, this operation just leads to decryption. Thanks. Lianbo > /* elfcorehdr stays in kdump kernel memory and it is not encrypted. */ > return read_from_oldmem(buf, count, ppos, 0, false); > > > I'm thinking to move the function to something like below, still not sure > memremap works on every arches or not, still need more test > > diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c > index cfb6674331fd..40c01cc42b38 100644 > --- a/fs/proc/vmcore.c > +++ b/fs/proc/vmcore.c > @@ -136,6 +136,24 @@ static ssize_t read_from_oldmem(char *buf, size_t count, > return read; > } > > +static ssize_t read_from_mem(char *buf, size_t count, u64 *ppos) > +{ > + resource_size_t offset = (resource_size_t)*ppos; > + char *kbuf; > + > + if (!count) > + return 0; > + > + kbuf = memremap(offset, count, MEMREMAP_WB); > + if (!kbuf) > + return 0; > + > + memcpy(buf, kbuf, count); > + memunmap(kbuf); > + > + return count; > +} > + > /* > * Architectures may override this function to allocate ELF header in 2nd kernel > */ > @@ -155,7 +173,7 @@ void __weak elfcorehdr_free(unsigned long long addr) > */ > ssize_t __weak elfcorehdr_read(char *buf, size_t count, u64 *ppos) > { > - return read_from_oldmem(buf, count, ppos, 0); > + return read_from_mem(buf, count, ppos); > } > > /* > > >> } >> >> /* >> @@ -151,7 +157,7 @@ ssize_t __weak elfcorehdr_read(char *buf, size_t count, u64 *ppos) >> */ >> ssize_t __weak elfcorehdr_read_notes(char *buf, size_t count, u64 *ppos) >> { >> - return read_from_oldmem(buf, count, ppos, 0); >> + return read_from_oldmem(buf, count, ppos, 0, sme_active()); >> } >> >> /* >> @@ -161,6 +167,7 @@ int __weak remap_oldmem_pfn_range(struct vm_area_struct *vma, >> unsigned long from, unsigned long pfn, >> unsigned long size, pgprot_t prot) >> { >> + prot = pgprot_encrypted(prot); >> return remap_pfn_range(vma, from, pfn, size, prot); >> } >> >> @@ -235,7 +242,8 @@ static ssize_t __read_vmcore(char *buffer, size_t buflen, loff_t *fpos, >> m->offset + m->size - *fpos, >> buflen); >> start = m->paddr + *fpos - m->offset; >> - tmp = read_from_oldmem(buffer, tsz, &start, userbuf); >> + tmp = read_from_oldmem(buffer, tsz, &start, userbuf, >> + sme_active()); >> if (tmp < 0) >> return tmp; >> buflen -= tsz; >> diff --git a/include/linux/crash_dump.h b/include/linux/crash_dump.h >> index f7ac2aa..f3414ff 100644 >> --- a/include/linux/crash_dump.h >> +++ b/include/linux/crash_dump.h >> @@ -25,6 +25,17 @@ extern int remap_oldmem_pfn_range(struct vm_area_struct *vma, >> >> extern ssize_t copy_oldmem_page(unsigned long, char *, size_t, >> unsigned long, int); >> +#ifdef CONFIG_AMD_MEM_ENCRYPT >> +extern ssize_t copy_oldmem_page_encrypted(unsigned long pfn, char *buf, >> + size_t csize, unsigned long offset, >> + int userbuf); >> +#else >> +static inline ssize_t copy_oldmem_page_encrypted(unsigned long pfn, char *buf, >> + size_t csize, unsigned long offset, >> + int userbuf) { > > Personally I prefer below because it is too long: > > static inline > ssize_t copy_oldmem_page_encrypted(unsigned long pfn, char *buf, size_t csize, > unsigned long offset, int userbuf) > { > return 0; > } > > >> + return csize; > > As above it should be return 0; > >> +} >> +#endif >> void vmcore_cleanup(void); >> >> /* Architecture code defines this if there are other possible ELF >> -- >> 2.9.5 >> >> >> _______________________________________________ >> kexec mailing list >> kexec@lists.infradead.org >> http://lists.infradead.org/mailman/listinfo/kexec > > Thanks > Dave >