From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from [222.73.24.84] (helo=song.cn.fujitsu.com) by merlin.infradead.org with esmtp (Exim 4.80.1 #2 (Red Hat Linux)) id 1UEaQN-0008LH-7v for kexec@lists.infradead.org; Sun, 10 Mar 2013 07:12:05 +0000 Message-ID: <513C2553.5050402@cn.fujitsu.com> Date: Sun, 10 Mar 2013 14:16:51 +0800 From: Zhang Yanfei MIME-Version: 1.0 Subject: Re: [PATCH v2 07/20] vmcore: copy non page-size aligned head and tail pages in 2nd kernel References: <20130302083447.31252.93914.stgit@localhost6.localdomain6> <20130302083627.31252.41277.stgit@localhost6.localdomain6> In-Reply-To: <20130302083627.31252.41277.stgit@localhost6.localdomain6> 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: HATAYAMA Daisuke Cc: kexec@lists.infradead.org, heiko.carstens@de.ibm.com, linux-kernel@vger.kernel.org, lisa.mitchell@hp.com, kumagai-atsushi@mxc.nes.nec.co.jp, ebiederm@xmission.com, akpm@linux-foundation.org, cpw@sgi.com, vgoyal@redhat.com 5LqOIDIwMTPlubQwM+aciDAy5pelIDE2OjM2LCBIQVRBWUFNQSBEYWlzdWtlIOWGmemBkzoKPiBE dWUgdG8gbW1hcCgpIHJlcXVpcmVtZW50LCB3ZSBuZWVkIHRvIGNvcHkgcGFnZXMgbm90IHN0YXJ0 aW5nIG9yCj4gZW5kaW5nIHdpdGggcGFnZS1zaXplIGFsaWduZWQgYWRkcmVzcyBpbiAybmQga2Vy bmVsIGFuZCB0byBtYXAgdGhlbSB0bwo+IHVzZXItc3BhY2UuCj4gCj4gRm9yIGV4YW1wbGUsIHNl ZSB0aGUgbWFwIGJlbG93Ogo+IAo+ICAgICAwMDAwMDAwMC0wMDAxZmZmZiA6IHJlc2VydmVkCj4g ICAgIDAwMDEwMDAwLTAwMDlmN2ZmIDogU3lzdGVtIFJBTQo+ICAgICAwMDA5ZjgwMC0wMDA5ZmZm ZiA6IHJlc2VydmVkCj4gCj4gd2hlcmUgdGhlIFN5c3RlbSBSQU0gZW5kcyB3aXRoIDB4OWY4MDAg dGhhdCBpcyBub3QgcGFnZS1zaXplCj4gYWxpZ25lZC4gVGhpcyBtYXAgaXMgZGl2aWRlZCBpbnRv IHR3byBwYXJ0czoKPiAKPiAgICAgMDAwMTAwMDAtMDAwOWRmZmYKCjAwMDEwMDAwLTAwMDllZmZm Cgo+ICAgICAwMDA5ZjAwMC0wMDA5ZjdmZgo+IAo+IGFuZCB0aGUgZmlyc3Qgb25lIGlzIGtlcHQg aW4gb2xkIG1lbW9yeSBhbmQgdGhlIDJuZCBvbmUgaXMgY29waWVkIGludG8KPiBidWZmZXIgb24g Mm5kIGtlcm5lbC4KPiAKPiBUaGlzIGtpbmQgb2Ygbm9uLXBhZ2Utc2l6ZS1hbGlnbmVkIGFyZWEg Y2FuIGFsd2F5cyBvY2N1ciBzaW5jZSBhbnkKPiBwYXJ0IG9mIFN5c3RlbSBSQU0gY2FuIGJlIGNv bnZlcnRlZCBpbnRvIHJlc2VydmVkIGFyZWEgYXQgcnVudGltZS4KPiAKPiBJZiBub3QgZG9pbmcg Y29weWluZyBsaWtlIHRoaXMgYW5kIGlmIHJlbWFwcGluZyBub24gcGFnZS1zaXplIGFsaWduZWQK PiBwYWdlcyBvbiBvbGQgbWVtb3J5IGRpcmVjdGx5LCBtbWFwKCkgaGFkIHRvIGV4cG9ydCBtZW1v cnkgd2hpY2ggaXMgbm90Cj4gZHVtcCB0YXJnZXQgdG8gdXNlci1zcGFjZS4gSW4gdGhlIGFib3Zl IGV4YW1wbGUgdGhpcyBpcyByZXNlcnZlZAo+IDB4OWY4MDAtMHhhMDAwMC4KPiAKPiBTaWduZWQt b2ZmLWJ5OiBIQVRBWUFNQSBEYWlzdWtlIDxkLmhhdGF5YW1hQGpwLmZ1aml0c3UuY29tPgo+IC0t LQo+IAo+ICBmcy9wcm9jL3ZtY29yZS5jIHwgIDE5MiArKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKysrKysrKysrKysrKysrKystLS0tLS0KPiAgMSBmaWxlcyBjaGFuZ2VkLCAxNzIgaW5z ZXJ0aW9ucygrKSwgMjAgZGVsZXRpb25zKC0pCj4gCj4gZGlmZiAtLWdpdCBhL2ZzL3Byb2Mvdm1j b3JlLmMgYi9mcy9wcm9jL3ZtY29yZS5jCj4gaW5kZXggYzUxMWNmNC4uNmIwNzFiNCAxMDA2NDQK PiAtLS0gYS9mcy9wcm9jL3ZtY29yZS5jCj4gKysrIGIvZnMvcHJvYy92bWNvcmUuYwo+IEBAIC00 NzQsMTEgKzQ3NCwxMCBAQCBzdGF0aWMgaW50IF9faW5pdCBwcm9jZXNzX3B0bG9hZF9wcm9ncmFt X2hlYWRlcnNfZWxmNjQoY2hhciAqZWxmcHRyLAo+ICAJCQkJCQlzaXplX3QgZWxmc3osCj4gIAkJ CQkJCXN0cnVjdCBsaXN0X2hlYWQgKnZjX2xpc3QpCj4gIHsKPiAtCWludCBpOwo+ICsJaW50IGks IHJjOwo+ICAJRWxmNjRfRWhkciAqZWhkcl9wdHI7Cj4gIAlFbGY2NF9QaGRyICpwaGRyX3B0cjsK PiAgCWxvZmZfdCB2bWNvcmVfb2ZmOwo+IC0Jc3RydWN0IHZtY29yZSAqbmV3Owo+ICAKPiAgCWVo ZHJfcHRyID0gKEVsZjY0X0VoZHIgKillbGZwdHI7Cj4gIAlwaGRyX3B0ciA9IChFbGY2NF9QaGRy KikoZWxmcHRyICsgZWhkcl9wdHItPmVfcGhvZmYpOyAvKiBQVF9OT1RFIGhkciAqLwo+IEBAIC00 ODgsMjAgKzQ4Nyw5NyBAQCBzdGF0aWMgaW50IF9faW5pdCBwcm9jZXNzX3B0bG9hZF9wcm9ncmFt X2hlYWRlcnNfZWxmNjQoY2hhciAqZWxmcHRyLAo+ICAJCQkJCQkgIFBBR0VfU0laRSk7Cj4gIAo+ ICAJZm9yIChpID0gMDsgaSA8IGVoZHJfcHRyLT5lX3BobnVtOyBpKyssIHBoZHJfcHRyKyspIHsK PiArCQl1NjQgc3RhcnQsIGVuZCwgcmVzdDsKPiArCj4gIAkJaWYgKHBoZHJfcHRyLT5wX3R5cGUg IT0gUFRfTE9BRCkKPiAgCQkJY29udGludWU7Cj4gIAo+IC0JCS8qIEFkZCB0aGlzIGNvbnRpZ3Vv dXMgY2h1bmsgb2YgbWVtb3J5IHRvIHZtY29yZSBsaXN0LiovCj4gLQkJbmV3ID0gZ2V0X25ld19l bGVtZW50KCk7Cj4gLQkJaWYgKCFuZXcpCj4gLQkJCXJldHVybiAtRU5PTUVNOwo+IC0JCW5ldy0+ cGFkZHIgPSBwaGRyX3B0ci0+cF9vZmZzZXQ7Cj4gLQkJbmV3LT5zaXplID0gcGhkcl9wdHItPnBf bWVtc3o7Cj4gLQkJbGlzdF9hZGRfdGFpbCgmbmV3LT5saXN0LCB2Y19saXN0KTsKPiArCQlzdGFy dCA9IHBoZHJfcHRyLT5wX29mZnNldDsKPiArCQllbmQgPSBwaGRyX3B0ci0+cF9vZmZzZXQgKyBw aGRyX3B0ci0+cF9tZW1zejsKPiArCQlyZXN0ID0gcGhkcl9wdHItPnBfbWVtc3o7Cj4gKwo+ICsJ CWlmIChzdGFydCAmIH5QQUdFX01BU0spIHsKPiArCQkJdTY0IHBhZGRyLCBsZW47Cj4gKwkJCWNo YXIgKmJ1ZjsKPiArCQkJc3RydWN0IHZtY29yZSAqbmV3Owo+ICsKPiArCQkJcGFkZHIgPSBzdGFy dDsKPiArCQkJbGVuID0gbWluKHJvdW5kdXAoc3RhcnQsUEFHRV9TSVpFKSwgZW5kKSAtIHN0YXJ0 Owo+ICsKPiArCQkJYnVmID0gKGNoYXIgKilnZXRfemVyb2VkX3BhZ2UoR0ZQX0tFUk5FTCk7Cj4g KwkJCWlmICghYnVmKQo+ICsJCQkJcmV0dXJuIC1FTk9NRU07Cj4gKwkJCXJjID0gcmVhZF9mcm9t X29sZG1lbShidWYgKyAoc3RhcnQgJiB+UEFHRV9NQVNLKSwgbGVuLAo+ICsJCQkJCSAgICAgICZw YWRkciwgMCk7Cj4gKwkJCWlmIChyYyA8IDApIHsKPiArCQkJCWZyZWVfcGFnZXMoKHVuc2lnbmVk IGxvbmcpYnVmLCAwKTsKPiArCQkJCXJldHVybiByYzsKPiArCQkJfQo+ICsKPiArCQkJbmV3ID0g Z2V0X25ld19lbGVtZW50KCk7Cj4gKwkJCWlmICghbmV3KSB7Cj4gKwkJCQlmcmVlX3BhZ2VzKCh1 bnNpZ25lZCBsb25nKWJ1ZiwgMCk7Cj4gKwkJCQlyZXR1cm4gLUVOT01FTTsKPiArCQkJfQo+ICsJ CQluZXctPmZsYWcgfD0gTUVNX1RZUEVfQ1VSUkVOVF9LRVJORUw7Cj4gKwkJCW5ldy0+c2l6ZSA9 IFBBR0VfU0laRTsKPiArCQkJbmV3LT5idWYgPSBidWY7Cj4gKwkJCWxpc3RfYWRkX3RhaWwoJm5l dy0+bGlzdCwgdmNfbGlzdCk7Cj4gKwo+ICsJCQlyZXN0IC09IGxlbjsKPiArCQl9Cj4gKwo+ICsJ CWlmIChyZXN0ID4gMCAmJgo+ICsJCSAgICByb3VuZHVwKHN0YXJ0LCBQQUdFX1NJWkUpIDwgcm91 bmRkb3duKGVuZCwgUEFHRV9TSVpFKSkgewo+ICsJCQl1NjQgcGFkZHIsIGxlbjsKPiArCQkJc3Ry dWN0IHZtY29yZSAqbmV3Owo+ICsKPiArCQkJcGFkZHIgPSByb3VuZHVwKHN0YXJ0LCBQQUdFX1NJ WkUpOwo+ICsJCQlsZW4gPXJvdW5kZG93bihlbmQsUEFHRV9TSVpFKS1yb3VuZHVwKHN0YXJ0LFBB R0VfU0laRSk7Cj4gKwo+ICsJCQluZXcgPSBnZXRfbmV3X2VsZW1lbnQoKTsKPiArCQkJaWYgKCFu ZXcpCj4gKwkJCQlyZXR1cm4gLUVOT01FTTsKPiArCQkJbmV3LT5wYWRkciA9IHBhZGRyOwo+ICsJ CQluZXctPnNpemUgPSBsZW47Cj4gKwkJCWxpc3RfYWRkX3RhaWwoJm5ldy0+bGlzdCwgdmNfbGlz dCk7Cj4gKwo+ICsJCQlyZXN0IC09IGxlbjsKPiArCQl9Cj4gKwo+ICsJCWlmIChyZXN0ID4gMCkg ewo+ICsJCQl1NjQgcGFkZHIsIGxlbjsKPiArCQkJY2hhciAqYnVmOwo+ICsJCQlzdHJ1Y3Qgdm1j b3JlICpuZXc7Cj4gKwo+ICsJCQlwYWRkciA9IHJvdW5kZG93bihlbmQsIFBBR0VfU0laRSk7Cj4g KwkJCWxlbiA9IGVuZCAtIHJvdW5kZG93bihlbmQsIFBBR0VfU0laRSk7Cj4gKwo+ICsJCQlidWYg PSAoY2hhciAqKWdldF96ZXJvZWRfcGFnZShHRlBfS0VSTkVMKTsKPiArCQkJaWYgKCFidWYpCj4g KwkJCQlyZXR1cm4gLUVOT01FTTsKPiArCQkJcmMgPSByZWFkX2Zyb21fb2xkbWVtKGJ1ZiwgbGVu LCAmcGFkZHIsIDApOwo+ICsJCQlpZiAocmMgPCAwKSB7Cj4gKwkJCQlmcmVlX3BhZ2VzKCh1bnNp Z25lZCBsb25nKWJ1ZiwgMCk7Cj4gKwkJCQlyZXR1cm4gcmM7Cj4gKwkJCX0KPiArCj4gKwkJCW5l dyA9IGdldF9uZXdfZWxlbWVudCgpOwo+ICsJCQlpZiAoIW5ldykgewo+ICsJCQkJZnJlZV9wYWdl cygodW5zaWduZWQgbG9uZylidWYsIDApOwo+ICsJCQkJcmV0dXJuIC1FTk9NRU07Cj4gKwkJCX0K PiArCQkJbmV3LT5mbGFnIHw9IE1FTV9UWVBFX0NVUlJFTlRfS0VSTkVMOwo+ICsJCQluZXctPnNp emUgPSBQQUdFX1NJWkU7Cj4gKwkJCW5ldy0+YnVmID0gYnVmOwo+ICsJCQlsaXN0X2FkZF90YWls KCZuZXctPmxpc3QsIHZjX2xpc3QpOwo+ICsKPiArCQkJcmVzdCAtPSBsZW47Cj4gKwkJfQo+ICAK PiAgCQkvKiBVcGRhdGUgdGhlIHByb2dyYW0gaGVhZGVyIG9mZnNldC4gKi8KPiAgCQlwaGRyX3B0 ci0+cF9vZmZzZXQgPSB2bWNvcmVfb2ZmOwo+IC0JCXZtY29yZV9vZmYgPSB2bWNvcmVfb2ZmICsg cGhkcl9wdHItPnBfbWVtc3o7Cj4gKwkJdm1jb3JlX29mZiArPXJvdW5kdXAoZW5kLFBBR0VfU0la RSktcm91bmRkb3duKHN0YXJ0LFBBR0VfU0laRSk7CgpIZXJlIHRoZSBjb2RlIGNoYW5nZXMgcGhk cl9wdHItPnBfb2Zmc2V0IHRvIGEgbmV3IHBhZ2Utc2l6ZSBhbGlnbmVkIG9mZnNldC4KQnV0IGl0 IHNlZW1zIHRoZSBwaGRyX3B0ci0+cF9wYWRkciBpcyBzdGlsbCB0aGUgbm9uIHBhZ2Utc2l6ZSBh bGlnbmVkCnBoeXNpY2FsIGFkZHJlc3M/IERvZXMgdGhlIG1pc21hdGNoIG9mIGEgUFRfTE9BRCBz ZWdtZW50IGFuZCB0aGUgcGh5c2ljYWwKbWVtb3J5IG9jY3VyPwoKT3IsIGxhdGVyIGluIG1ha2Vk dW1wZmlsZSwgaXQgd2lsbCBjaGVjayB0aGUgcGhkcl9wdHItPnBhZGRyIHRvIHNlZSBpZiBpdApp cyBwYWdlLXNpemUgYWxpZ25lZCBhbmQgYWxzbyBwaGRyX3B0ci0+cF9tZW1zeiB0byBnZXQgdGhl IHJlYWwgbWVtb3J5IHNpemUsCm5vdCBpbmNsdWRpbmcgcGFkZGluZz8KCj4gIAl9Cj4gIAlyZXR1 cm4gMDsKPiAgfQo+IEBAIC01MTAsMTEgKzU4NiwxMCBAQCBzdGF0aWMgaW50IF9faW5pdCBwcm9j ZXNzX3B0bG9hZF9wcm9ncmFtX2hlYWRlcnNfZWxmMzIoY2hhciAqZWxmcHRyLAo+ICAJCQkJCQlz aXplX3QgZWxmc3osCj4gIAkJCQkJCXN0cnVjdCBsaXN0X2hlYWQgKnZjX2xpc3QpCj4gIHsKPiAt CWludCBpOwo+ICsJaW50IGksIHJjOwo+ICAJRWxmMzJfRWhkciAqZWhkcl9wdHI7Cj4gIAlFbGYz Ml9QaGRyICpwaGRyX3B0cjsKPiAgCWxvZmZfdCB2bWNvcmVfb2ZmOwo+IC0Jc3RydWN0IHZtY29y ZSAqbmV3Owo+ICAKPiAgCWVoZHJfcHRyID0gKEVsZjMyX0VoZHIgKillbGZwdHI7Cj4gIAlwaGRy X3B0ciA9IChFbGYzMl9QaGRyKikoZWxmcHRyICsgZWhkcl9wdHItPmVfcGhvZmYpOyAvKiBQVF9O T1RFIGhkciAqLwo+IEBAIC01MjQsMjAgKzU5OSw5NyBAQCBzdGF0aWMgaW50IF9faW5pdCBwcm9j ZXNzX3B0bG9hZF9wcm9ncmFtX2hlYWRlcnNfZWxmMzIoY2hhciAqZWxmcHRyLAo+ICAJCQkJCQkg UEFHRV9TSVpFKTsKPiAgCj4gIAlmb3IgKGkgPSAwOyBpIDwgZWhkcl9wdHItPmVfcGhudW07IGkr KywgcGhkcl9wdHIrKykgewo+ICsJCXU2NCBzdGFydCwgZW5kLCByZXN0Owo+ICsKPiAgCQlpZiAo cGhkcl9wdHItPnBfdHlwZSAhPSBQVF9MT0FEKQo+ICAJCQljb250aW51ZTsKPiAgCj4gLQkJLyog QWRkIHRoaXMgY29udGlndW91cyBjaHVuayBvZiBtZW1vcnkgdG8gdm1jb3JlIGxpc3QuKi8KPiAt CQluZXcgPSBnZXRfbmV3X2VsZW1lbnQoKTsKPiAtCQlpZiAoIW5ldykKPiAtCQkJcmV0dXJuIC1F Tk9NRU07Cj4gLQkJbmV3LT5wYWRkciA9IHBoZHJfcHRyLT5wX29mZnNldDsKPiAtCQluZXctPnNp emUgPSBwaGRyX3B0ci0+cF9tZW1zejsKPiAtCQlsaXN0X2FkZF90YWlsKCZuZXctPmxpc3QsIHZj X2xpc3QpOwo+ICsJCXN0YXJ0ID0gcGhkcl9wdHItPnBfb2Zmc2V0Owo+ICsJCWVuZCA9IHBoZHJf cHRyLT5wX29mZnNldCArIHBoZHJfcHRyLT5wX21lbXN6Owo+ICsJCXJlc3QgPSBwaGRyX3B0ci0+ cF9tZW1zejsKPiArCj4gKwkJaWYgKHN0YXJ0ICYgflBBR0VfTUFTSykgewo+ICsJCQl1NjQgcGFk ZHIsIGxlbjsKPiArCQkJY2hhciAqYnVmOwo+ICsJCQlzdHJ1Y3Qgdm1jb3JlICpuZXc7Cj4gKwo+ ICsJCQlwYWRkciA9IHN0YXJ0Owo+ICsJCQlsZW4gPSBtaW4ocm91bmR1cChzdGFydCxQQUdFX1NJ WkUpLCBlbmQpIC0gc3RhcnQ7Cj4gKwo+ICsJCQlidWYgPSAoY2hhciAqKWdldF96ZXJvZWRfcGFn ZShHRlBfS0VSTkVMKTsKPiArCQkJaWYgKCFidWYpCj4gKwkJCQlyZXR1cm4gLUVOT01FTTsKPiAr CQkJcmMgPSByZWFkX2Zyb21fb2xkbWVtKGJ1ZiArIChzdGFydCAmIH5QQUdFX01BU0spLCBsZW4s Cj4gKwkJCQkJICAgICAgJnBhZGRyLCAwKTsKPiArCQkJaWYgKHJjIDwgMCkgewo+ICsJCQkJZnJl ZV9wYWdlcygodW5zaWduZWQgbG9uZylidWYsIDApOwo+ICsJCQkJcmV0dXJuIHJjOwo+ICsJCQl9 Cj4gKwo+ICsJCQluZXcgPSBnZXRfbmV3X2VsZW1lbnQoKTsKPiArCQkJaWYgKCFuZXcpIHsKPiAr CQkJCWZyZWVfcGFnZXMoKHVuc2lnbmVkIGxvbmcpYnVmLCAwKTsKPiArCQkJCXJldHVybiAtRU5P TUVNOwo+ICsJCQl9Cj4gKwkJCW5ldy0+ZmxhZyB8PSBNRU1fVFlQRV9DVVJSRU5UX0tFUk5FTDsK PiArCQkJbmV3LT5zaXplID0gUEFHRV9TSVpFOwo+ICsJCQluZXctPmJ1ZiA9IGJ1ZjsKPiArCQkJ bGlzdF9hZGRfdGFpbCgmbmV3LT5saXN0LCB2Y19saXN0KTsKPiArCj4gKwkJCXJlc3QgLT0gbGVu Owo+ICsJCX0KPiArCj4gKwkJaWYgKHJlc3QgPiAwICYmCj4gKwkJICAgIHJvdW5kdXAoc3RhcnQs IFBBR0VfU0laRSkgPCByb3VuZGRvd24oZW5kLCBQQUdFX1NJWkUpKSB7Cj4gKwkJCXU2NCBwYWRk ciwgbGVuOwo+ICsJCQlzdHJ1Y3Qgdm1jb3JlICpuZXc7Cj4gKwo+ICsJCQlwYWRkciA9IHJvdW5k dXAoc3RhcnQsIFBBR0VfU0laRSk7Cj4gKwkJCWxlbiA9cm91bmRkb3duKGVuZCxQQUdFX1NJWkUp LXJvdW5kdXAoc3RhcnQsUEFHRV9TSVpFKTsKPiArCj4gKwkJCW5ldyA9IGdldF9uZXdfZWxlbWVu dCgpOwo+ICsJCQlpZiAoIW5ldykKPiArCQkJCXJldHVybiAtRU5PTUVNOwo+ICsJCQluZXctPnBh ZGRyID0gcGFkZHI7Cj4gKwkJCW5ldy0+c2l6ZSA9IGxlbjsKPiArCQkJbGlzdF9hZGRfdGFpbCgm bmV3LT5saXN0LCB2Y19saXN0KTsKPiArCj4gKwkJCXJlc3QgLT0gbGVuOwo+ICsJCX0KPiArCj4g KwkJaWYgKHJlc3QgPiAwKSB7Cj4gKwkJCXU2NCBwYWRkciwgbGVuOwo+ICsJCQljaGFyICpidWY7 Cj4gKwkJCXN0cnVjdCB2bWNvcmUgKm5ldzsKPiArCj4gKwkJCXBhZGRyID0gcm91bmRkb3duKGVu ZCwgUEFHRV9TSVpFKTsKPiArCQkJbGVuID0gZW5kIC0gcm91bmRkb3duKGVuZCwgUEFHRV9TSVpF KTsKPiArCj4gKwkJCWJ1ZiA9IChjaGFyICopZ2V0X3plcm9lZF9wYWdlKEdGUF9LRVJORUwpOwo+ ICsJCQlpZiAoIWJ1ZikKPiArCQkJCXJldHVybiAtRU5PTUVNOwo+ICsJCQlyYyA9IHJlYWRfZnJv bV9vbGRtZW0oYnVmLCBsZW4sICZwYWRkciwgMCk7Cj4gKwkJCWlmIChyYyA8IDApIHsKPiArCQkJ CWZyZWVfcGFnZXMoKHVuc2lnbmVkIGxvbmcpYnVmLCAwKTsKPiArCQkJCXJldHVybiByYzsKPiAr CQkJfQo+ICsKPiArCQkJbmV3ID0gZ2V0X25ld19lbGVtZW50KCk7Cj4gKwkJCWlmICghbmV3KSB7 Cj4gKwkJCQlmcmVlX3BhZ2VzKCh1bnNpZ25lZCBsb25nKWJ1ZiwgMCk7Cj4gKwkJCQlyZXR1cm4g LUVOT01FTTsKPiArCQkJfQo+ICsJCQluZXctPmZsYWcgfD0gTUVNX1RZUEVfQ1VSUkVOVF9LRVJO RUw7Cj4gKwkJCW5ldy0+c2l6ZSA9IFBBR0VfU0laRTsKPiArCQkJbmV3LT5idWYgPSBidWY7Cj4g KwkJCWxpc3RfYWRkX3RhaWwoJm5ldy0+bGlzdCwgdmNfbGlzdCk7Cj4gKwo+ICsJCQlyZXN0IC09 IGxlbjsKPiArCQl9Cj4gIAo+ICAJCS8qIFVwZGF0ZSB0aGUgcHJvZ3JhbSBoZWFkZXIgb2Zmc2V0 ICovCj4gIAkJcGhkcl9wdHItPnBfb2Zmc2V0ID0gdm1jb3JlX29mZjsKPiAtCQl2bWNvcmVfb2Zm ID0gdm1jb3JlX29mZiArIHBoZHJfcHRyLT5wX21lbXN6Owo+ICsJCXZtY29yZV9vZmYgKz1yb3Vu ZHVwKGVuZCxQQUdFX1NJWkUpLXJvdW5kZG93bihzdGFydCxQQUdFX1NJWkUpOwo+ICAJfQo+ICAJ cmV0dXJuIDA7Cj4gIH0KPiAKPiAKPiBfX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fXwo+IGtleGVjIG1haWxpbmcgbGlzdAo+IGtleGVjQGxpc3RzLmluZnJhZGVh ZC5vcmcKPiBodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2tleGVj Cj4gCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18Ka2V4 ZWMgbWFpbGluZyBsaXN0CmtleGVjQGxpc3RzLmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmlu ZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9rZXhlYwo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751663Ab3CJHME (ORCPT ); Sun, 10 Mar 2013 03:12:04 -0400 Received: from cn.fujitsu.com ([222.73.24.84]:27894 "EHLO song.cn.fujitsu.com" rhost-flags-OK-FAIL-OK-OK) by vger.kernel.org with ESMTP id S1751260Ab3CJHMC convert rfc822-to-8bit (ORCPT ); Sun, 10 Mar 2013 03:12:02 -0400 X-IronPort-AV: E=Sophos;i="4.84,817,1355068800"; d="scan'208";a="6843846" Message-ID: <513C2553.5050402@cn.fujitsu.com> Date: Sun, 10 Mar 2013 14:16:51 +0800 From: Zhang Yanfei User-Agent: Mozilla/5.0 (X11; Linux x86_64; rv:10.0.8) Gecko/20121012 Thunderbird/10.0.8 MIME-Version: 1.0 To: HATAYAMA Daisuke CC: vgoyal@redhat.com, ebiederm@xmission.com, cpw@sgi.com, kumagai-atsushi@mxc.nes.nec.co.jp, lisa.mitchell@hp.com, heiko.carstens@de.ibm.com, akpm@linux-foundation.org, kexec@lists.infradead.org, linux-kernel@vger.kernel.org Subject: Re: [PATCH v2 07/20] vmcore: copy non page-size aligned head and tail pages in 2nd kernel References: <20130302083447.31252.93914.stgit@localhost6.localdomain6> <20130302083627.31252.41277.stgit@localhost6.localdomain6> In-Reply-To: <20130302083627.31252.41277.stgit@localhost6.localdomain6> X-MIMETrack: Itemize by SMTP Server on mailserver/fnst(Release 8.5.3|September 15, 2011) at 2013/03/10 14:17:12, Serialize by Router on mailserver/fnst(Release 8.5.3|September 15, 2011) at 2013/03/10 14:17:18 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 于 2013年03月02日 16:36, HATAYAMA Daisuke 写道: > Due to mmap() requirement, we need to copy pages not starting or > ending with page-size aligned address in 2nd kernel and to map them to > user-space. > > For example, see the map below: > > 00000000-0001ffff : reserved > 00010000-0009f7ff : System RAM > 0009f800-0009ffff : reserved > > where the System RAM ends with 0x9f800 that is not page-size > aligned. This map is divided into two parts: > > 00010000-0009dfff 00010000-0009efff > 0009f000-0009f7ff > > and the first one is kept in old memory and the 2nd one is copied into > buffer on 2nd kernel. > > This kind of non-page-size-aligned area can always occur since any > part of System RAM can be converted into reserved area at runtime. > > If not doing copying like this and if remapping non page-size aligned > pages on old memory directly, mmap() had to export memory which is not > dump target to user-space. In the above example this is reserved > 0x9f800-0xa0000. > > Signed-off-by: HATAYAMA Daisuke > --- > > fs/proc/vmcore.c | 192 ++++++++++++++++++++++++++++++++++++++++++++++++------ > 1 files changed, 172 insertions(+), 20 deletions(-) > > diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c > index c511cf4..6b071b4 100644 > --- a/fs/proc/vmcore.c > +++ b/fs/proc/vmcore.c > @@ -474,11 +474,10 @@ static int __init process_ptload_program_headers_elf64(char *elfptr, > size_t elfsz, > struct list_head *vc_list) > { > - int i; > + int i, rc; > Elf64_Ehdr *ehdr_ptr; > Elf64_Phdr *phdr_ptr; > loff_t vmcore_off; > - struct vmcore *new; > > ehdr_ptr = (Elf64_Ehdr *)elfptr; > phdr_ptr = (Elf64_Phdr*)(elfptr + ehdr_ptr->e_phoff); /* PT_NOTE hdr */ > @@ -488,20 +487,97 @@ static int __init process_ptload_program_headers_elf64(char *elfptr, > PAGE_SIZE); > > for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) { > + u64 start, end, rest; > + > if (phdr_ptr->p_type != PT_LOAD) > continue; > > - /* Add this contiguous chunk of memory to vmcore list.*/ > - new = get_new_element(); > - if (!new) > - return -ENOMEM; > - new->paddr = phdr_ptr->p_offset; > - new->size = phdr_ptr->p_memsz; > - list_add_tail(&new->list, vc_list); > + start = phdr_ptr->p_offset; > + end = phdr_ptr->p_offset + phdr_ptr->p_memsz; > + rest = phdr_ptr->p_memsz; > + > + if (start & ~PAGE_MASK) { > + u64 paddr, len; > + char *buf; > + struct vmcore *new; > + > + paddr = start; > + len = min(roundup(start,PAGE_SIZE), end) - start; > + > + buf = (char *)get_zeroed_page(GFP_KERNEL); > + if (!buf) > + return -ENOMEM; > + rc = read_from_oldmem(buf + (start & ~PAGE_MASK), len, > + &paddr, 0); > + if (rc < 0) { > + free_pages((unsigned long)buf, 0); > + return rc; > + } > + > + new = get_new_element(); > + if (!new) { > + free_pages((unsigned long)buf, 0); > + return -ENOMEM; > + } > + new->flag |= MEM_TYPE_CURRENT_KERNEL; > + new->size = PAGE_SIZE; > + new->buf = buf; > + list_add_tail(&new->list, vc_list); > + > + rest -= len; > + } > + > + if (rest > 0 && > + roundup(start, PAGE_SIZE) < rounddown(end, PAGE_SIZE)) { > + u64 paddr, len; > + struct vmcore *new; > + > + paddr = roundup(start, PAGE_SIZE); > + len =rounddown(end,PAGE_SIZE)-roundup(start,PAGE_SIZE); > + > + new = get_new_element(); > + if (!new) > + return -ENOMEM; > + new->paddr = paddr; > + new->size = len; > + list_add_tail(&new->list, vc_list); > + > + rest -= len; > + } > + > + if (rest > 0) { > + u64 paddr, len; > + char *buf; > + struct vmcore *new; > + > + paddr = rounddown(end, PAGE_SIZE); > + len = end - rounddown(end, PAGE_SIZE); > + > + buf = (char *)get_zeroed_page(GFP_KERNEL); > + if (!buf) > + return -ENOMEM; > + rc = read_from_oldmem(buf, len, &paddr, 0); > + if (rc < 0) { > + free_pages((unsigned long)buf, 0); > + return rc; > + } > + > + new = get_new_element(); > + if (!new) { > + free_pages((unsigned long)buf, 0); > + return -ENOMEM; > + } > + new->flag |= MEM_TYPE_CURRENT_KERNEL; > + new->size = PAGE_SIZE; > + new->buf = buf; > + list_add_tail(&new->list, vc_list); > + > + rest -= len; > + } > > /* Update the program header offset. */ > phdr_ptr->p_offset = vmcore_off; > - vmcore_off = vmcore_off + phdr_ptr->p_memsz; > + vmcore_off +=roundup(end,PAGE_SIZE)-rounddown(start,PAGE_SIZE); Here the code changes phdr_ptr->p_offset to a new page-size aligned offset. But it seems the phdr_ptr->p_paddr is still the non page-size aligned physical address? Does the mismatch of a PT_LOAD segment and the physical memory occur? Or, later in makedumpfile, it will check the phdr_ptr->paddr to see if it is page-size aligned and also phdr_ptr->p_memsz to get the real memory size, not including padding? > } > return 0; > } > @@ -510,11 +586,10 @@ static int __init process_ptload_program_headers_elf32(char *elfptr, > size_t elfsz, > struct list_head *vc_list) > { > - int i; > + int i, rc; > Elf32_Ehdr *ehdr_ptr; > Elf32_Phdr *phdr_ptr; > loff_t vmcore_off; > - struct vmcore *new; > > ehdr_ptr = (Elf32_Ehdr *)elfptr; > phdr_ptr = (Elf32_Phdr*)(elfptr + ehdr_ptr->e_phoff); /* PT_NOTE hdr */ > @@ -524,20 +599,97 @@ static int __init process_ptload_program_headers_elf32(char *elfptr, > PAGE_SIZE); > > for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) { > + u64 start, end, rest; > + > if (phdr_ptr->p_type != PT_LOAD) > continue; > > - /* Add this contiguous chunk of memory to vmcore list.*/ > - new = get_new_element(); > - if (!new) > - return -ENOMEM; > - new->paddr = phdr_ptr->p_offset; > - new->size = phdr_ptr->p_memsz; > - list_add_tail(&new->list, vc_list); > + start = phdr_ptr->p_offset; > + end = phdr_ptr->p_offset + phdr_ptr->p_memsz; > + rest = phdr_ptr->p_memsz; > + > + if (start & ~PAGE_MASK) { > + u64 paddr, len; > + char *buf; > + struct vmcore *new; > + > + paddr = start; > + len = min(roundup(start,PAGE_SIZE), end) - start; > + > + buf = (char *)get_zeroed_page(GFP_KERNEL); > + if (!buf) > + return -ENOMEM; > + rc = read_from_oldmem(buf + (start & ~PAGE_MASK), len, > + &paddr, 0); > + if (rc < 0) { > + free_pages((unsigned long)buf, 0); > + return rc; > + } > + > + new = get_new_element(); > + if (!new) { > + free_pages((unsigned long)buf, 0); > + return -ENOMEM; > + } > + new->flag |= MEM_TYPE_CURRENT_KERNEL; > + new->size = PAGE_SIZE; > + new->buf = buf; > + list_add_tail(&new->list, vc_list); > + > + rest -= len; > + } > + > + if (rest > 0 && > + roundup(start, PAGE_SIZE) < rounddown(end, PAGE_SIZE)) { > + u64 paddr, len; > + struct vmcore *new; > + > + paddr = roundup(start, PAGE_SIZE); > + len =rounddown(end,PAGE_SIZE)-roundup(start,PAGE_SIZE); > + > + new = get_new_element(); > + if (!new) > + return -ENOMEM; > + new->paddr = paddr; > + new->size = len; > + list_add_tail(&new->list, vc_list); > + > + rest -= len; > + } > + > + if (rest > 0) { > + u64 paddr, len; > + char *buf; > + struct vmcore *new; > + > + paddr = rounddown(end, PAGE_SIZE); > + len = end - rounddown(end, PAGE_SIZE); > + > + buf = (char *)get_zeroed_page(GFP_KERNEL); > + if (!buf) > + return -ENOMEM; > + rc = read_from_oldmem(buf, len, &paddr, 0); > + if (rc < 0) { > + free_pages((unsigned long)buf, 0); > + return rc; > + } > + > + new = get_new_element(); > + if (!new) { > + free_pages((unsigned long)buf, 0); > + return -ENOMEM; > + } > + new->flag |= MEM_TYPE_CURRENT_KERNEL; > + new->size = PAGE_SIZE; > + new->buf = buf; > + list_add_tail(&new->list, vc_list); > + > + rest -= len; > + } > > /* Update the program header offset */ > phdr_ptr->p_offset = vmcore_off; > - vmcore_off = vmcore_off + phdr_ptr->p_memsz; > + vmcore_off +=roundup(end,PAGE_SIZE)-rounddown(start,PAGE_SIZE); > } > return 0; > } > > > _______________________________________________ > kexec mailing list > kexec@lists.infradead.org > http://lists.infradead.org/mailman/listinfo/kexec >