From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mail.skyhub.de ([2a01:4f8:120:8448::d00d]) by merlin.infradead.org with esmtp (Exim 4.80.1 #2 (Red Hat Linux)) id 1Vlfmd-0004IT-RU for kexec@lists.infradead.org; Wed, 27 Nov 2013 14:08:06 +0000 Date: Wed, 27 Nov 2013 15:07:32 +0100 From: Borislav Petkov Subject: Re: [PATCH v4 07/12] efi: passing kexec necessary efi data via setup_data Message-ID: <20131127140732.GD32267@pd.tnic> References: <1385445477-9665-1-git-send-email-dyoung@redhat.com> <1385445477-9665-8-git-send-email-dyoung@redhat.com> MIME-Version: 1.0 Content-Disposition: inline In-Reply-To: <1385445477-9665-8-git-send-email-dyoung@redhat.com> 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=twosheds.infradead.org@lists.infradead.org To: Dave Young Cc: mjg59@srcf.ucam.org, linux-efi@vger.kernel.org, toshi.kani@hp.com, matt@console-pimps.org, greg@kroah.com, x86@kernel.org, kexec@lists.infradead.org, linux-kernel@vger.kernel.org, James.Bottomley@HansenPartnership.com, horms@verge.net.au, ebiederm@xmission.com, hpa@zytor.com, vgoyal@redhat.com T24gVHVlLCBOb3YgMjYsIDIwMTMgYXQgMDE6NTc6NTJQTSArMDgwMCwgRGF2ZSBZb3VuZyB3cm90 ZToKPiBBZGQgYSBuZXcgc2V0dXBfZGF0YSB0eXBlIFNFVFVQX0VGSSBmb3Iga2V4ZWMgdXNlLgo+ IFBhc3NpbmcgdGhlIHNhdmVkIGZ3X3ZlbmRvciwgcnVudGltZSwgY29uZmlnIHRhYmxlcyBhbmQK PiBlZmkgcnVudGltZSBtYXBwaW5ncy4KPiAKPiBXaGVuIGVudGVyaW5nIHZpcnR1YWwgbW9kZSwg ZGlyZWN0bHkgbWFwcGluZyB0aGUgZWZpCj4gcnVudGltZSByYWdpb25zIHdoaWNoIHdlIHBhc3Nl ZCBpbiBwcmV2aW91c2x5LiBBbmQgc2tpcAo+IHRoZSBzdGVwIHRvIGNhbGwgU2V0VmlydHVhbEFk ZHJlc3NNYXAuCj4gCj4gU3BlY2lhbGx5IGZvciBIUCB6NDIwIHdvcmtzdGF0aW9uIGl0IG5lZWQg YW5vdGhlciB2YXJpYWJsZQo+IHNhdmluZywKCldoeSB0aGUgc3BlY2lhbCBoYW5kbGluZz8gRG9l cyB0aGF0IG1lYW4sIHRoaXMgaXMgZ29pbmcgdG8gYmUgdGhlIGNhc2UKZm9yIG90aGVyIEhQIFVF RkkgaW1wbGVtZW50YXRpb25zIHRvbz8KCj4gaXQncyB0aGUgc21iaW9zIHBoeXNpY2FsIGFkZHJl c3MsIHRoZSBIUCBiaW9zCj4gYWxzbyB1cGRhdGUgdGhlIFNNQklPUyBhZGRyZXNzIGFmdGVyIGVu dGVyaW5nIHZpcnR1YWwgbW9kZQo+IGJlc2lkZXMgb2YgdGhlIHN0YW5kYXJkIGZ3X3ZlbmRvcixy dW50aW1lIGFuZCBjb25maWcgdGFibGUuCj4gCj4gVGVzdGVkIG9uIG92bWYrcWVtdSwgbGVub3Zv IHRoaW5rcGFkLCBhIGRlbGwgbGFwdG9wIGFuZCBhbgo+IEhQIHo0MjAgd29ya3N0YXRpb24uCj4g Cj4gdjI6IHJlZnJlc2ggYmFzZWQgb24gcHJldmlvdXMgcGF0Y2ggY2hhbmdlcywgY29kZSBjbGVh bnVwLgo+IHYzOiB1c2UgaW9yZW1hcCBpbnN0ZWFkIG9mIHBoeXNfdG9fdmlydCBmb3IgZXNkYXRh Cj4gCj4gU2lnbmVkLW9mZi1ieTogRGF2ZSBZb3VuZyA8ZHlvdW5nQHJlZGhhdC5jb20+Cj4gLS0t Cj4gIGFyY2gveDg2L2luY2x1ZGUvYXNtL2VmaS5oICAgICAgICAgICAgfCAgMTIgKysrCj4gIGFy Y2gveDg2L2luY2x1ZGUvdWFwaS9hc20vYm9vdHBhcmFtLmggfCAgIDEgKwo+ICBhcmNoL3g4Ni9r ZXJuZWwvc2V0dXAuYyAgICAgICAgICAgICAgIHwgICAzICsKPiAgYXJjaC94ODYvcGxhdGZvcm0v ZWZpL2VmaS5jICAgICAgICAgICB8IDE2MSArKysrKysrKysrKysrKysrKysrKysrKysrKysrKyst LS0tCj4gIDQgZmlsZXMgY2hhbmdlZCwgMTYwIGluc2VydGlvbnMoKyksIDE3IGRlbGV0aW9ucygt KQo+IAo+IGRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9lZmkuaCBiL2FyY2gveDg2 L2luY2x1ZGUvYXNtL2VmaS5oCj4gaW5kZXggOWZiYWViMi4uNzNkNTY0MyAxMDA2NDQKPiAtLS0g YS9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9lZmkuaAo+ICsrKyBiL2FyY2gveDg2L2luY2x1ZGUvYXNt L2VmaS5oCj4gQEAgLTEzMyw2ICsxMzMsMTggQEAgZXh0ZXJuIHZvaWQgZWZpX3N5bmNfbG93X2tl cm5lbF9tYXBwaW5ncyh2b2lkKTsKPiAgZXh0ZXJuIHZvaWQgZWZpX3NldHVwX3BhZ2VfdGFibGVz KHZvaWQpOwo+ICBleHRlcm4gdm9pZCBfX2luaXQgb2xkX21hcF9yZWdpb24oZWZpX21lbW9yeV9k ZXNjX3QgKm1kKTsKPiAgCj4gK3N0cnVjdCBlZmlfc2V0dXBfZGF0YSB7Cj4gKwl1NjQgZndfdmVu ZG9yOwo+ICsJdTY0IHJ1bnRpbWU7Cj4gKwl1NjQgdGFibGVzOwo+ICsJdTY0IHNtYmlvczsKPiAr CXU2NCByZXNlcnZlZFs4XTsKCldoYXQncyB0aGF0IGZvcj8KCj4gKwllZmlfbWVtb3J5X2Rlc2Nf dCBtYXBbMF07Cj4gK307Cj4gKwo+ICtleHRlcm4gdm9pZCBwYXJzZV9lZmlfc2V0dXAodTY0IHBo eXNfYWRkciwgdTMyIGRhdGFfbGVuKTsKPiArZXh0ZXJuIHN0cnVjdCBlZmlfc2V0dXBfZGF0YSAq ZXNkYXRhOwo+ICsKPiAgI2lmZGVmIENPTkZJR19FRkkKPiAgCj4gIHN0YXRpYyBpbmxpbmUgYm9v bCBlZmlfaXNfbmF0aXZlKHZvaWQpCgpbIOKApiBdCgo+IGRpZmYgLS1naXQgYS9hcmNoL3g4Ni9w bGF0Zm9ybS9lZmkvZWZpLmMgYi9hcmNoL3g4Ni9wbGF0Zm9ybS9lZmkvZWZpLmMKPiBpbmRleCBj M2EyYWFhLi5mYWZlYjQwIDEwMDY0NAo+IC0tLSBhL2FyY2gveDg2L3BsYXRmb3JtL2VmaS9lZmku Ywo+ICsrKyBiL2FyY2gveDg2L3BsYXRmb3JtL2VmaS9lZmkuYwo+IEBAIC01MDQsOCArNTMxLDEy IEBAIHN0YXRpYyBpbnQgX19pbml0IGVmaV9zeXN0YWJfaW5pdCh2b2lkICpwaHlzKQo+ICAJCX0K PiAgCj4gIAkJZWZpX3N5c3RhYi5oZHIgPSBzeXN0YWI2NC0+aGRyOwo+IC0JCWVmaV9zeXN0YWIu ZndfdmVuZG9yID0gc3lzdGFiNjQtPmZ3X3ZlbmRvcjsKPiAtCQl0bXAgfD0gc3lzdGFiNjQtPmZ3 X3ZlbmRvcjsKPiArCj4gKwkJaWYgKGVzZGF0YSkKPiArCQkJZWZpX3N5c3RhYi5md192ZW5kb3Ig PSAodW5zaWduZWQgbG9uZyllc2RhdGEtPmZ3X3ZlbmRvcjsKPiArCQllbHNlCj4gKwkJCWVmaV9z eXN0YWIuZndfdmVuZG9yID0gc3lzdGFiNjQtPmZ3X3ZlbmRvcjsKCgkJZWZpX3N5c3RhYi5md192 ZW5kb3IgPSBlc2RhdGEgPyAodW5zaWduZWQgbG9uZyllc2RhdGEtPmZ3X3ZlbmRvcgoJCQkJCSAg ICAgIDogc3lzdGFiNjQtPmZ3X3ZlbmRvcjsKCj4gKwkJdG1wIHw9IGVmaV9zeXN0YWIuZndfdmVu ZG9yOwo+ICAJCWVmaV9zeXN0YWIuZndfcmV2aXNpb24gPSBzeXN0YWI2NC0+ZndfcmV2aXNpb247 Cj4gIAkJZWZpX3N5c3RhYi5jb25faW5faGFuZGxlID0gc3lzdGFiNjQtPmNvbl9pbl9oYW5kbGU7 Cj4gIAkJdG1wIHw9IHN5c3RhYjY0LT5jb25faW5faGFuZGxlOwo+IEBAIC01MTksMTMgKzU1MCwy MSBAQCBzdGF0aWMgaW50IF9faW5pdCBlZmlfc3lzdGFiX2luaXQodm9pZCAqcGh5cykKPiAgCQl0 bXAgfD0gc3lzdGFiNjQtPnN0ZGVycl9oYW5kbGU7Cj4gIAkJZWZpX3N5c3RhYi5zdGRlcnIgPSBz eXN0YWI2NC0+c3RkZXJyOwo+ICAJCXRtcCB8PSBzeXN0YWI2NC0+c3RkZXJyOwo+IC0JCWVmaV9z eXN0YWIucnVudGltZSA9ICh2b2lkICopKHVuc2lnbmVkIGxvbmcpc3lzdGFiNjQtPnJ1bnRpbWU7 Cj4gLQkJdG1wIHw9IHN5c3RhYjY0LT5ydW50aW1lOwo+ICsJCWlmIChlc2RhdGEpCj4gKwkJCWVm aV9zeXN0YWIucnVudGltZSA9Cj4gKwkJCQkodm9pZCAqKSh1bnNpZ25lZCBsb25nKWVzZGF0YS0+ cnVudGltZTsKPiArCQllbHNlCj4gKwkJCWVmaV9zeXN0YWIucnVudGltZSA9Cj4gKwkJCQkodm9p ZCAqKSh1bnNpZ25lZCBsb25nKXN5c3RhYjY0LT5ydW50aW1lOwoKRGl0dG8uIFdoaWNoIHdvdWxk IHRha2UgY2FyZSBvZiB0aGVzZSBsaW5lYnJlYWtzIHdoaWNoIGFyZSB1Z2x5LgoKPiArCQl0bXAg fD0gKHVuc2lnbmVkIGxvbmcpZWZpX3N5c3RhYi5ydW50aW1lOwo+ICAJCWVmaV9zeXN0YWIuYm9v dHRpbWUgPSAodm9pZCAqKSh1bnNpZ25lZCBsb25nKXN5c3RhYjY0LT5ib290dGltZTsKPiAgCQl0 bXAgfD0gc3lzdGFiNjQtPmJvb3R0aW1lOwo+ICAJCWVmaV9zeXN0YWIubnJfdGFibGVzID0gc3lz dGFiNjQtPm5yX3RhYmxlczsKPiAtCQllZmlfc3lzdGFiLnRhYmxlcyA9IHN5c3RhYjY0LT50YWJs ZXM7Cj4gLQkJdG1wIHw9IHN5c3RhYjY0LT50YWJsZXM7Cj4gKwkJaWYgKGVzZGF0YSkKPiArCQkJ ZWZpX3N5c3RhYi50YWJsZXMgPSAodW5zaWduZWQgbG9uZyllc2RhdGEtPnRhYmxlczsKPiArCQll bHNlCj4gKwkJCWVmaV9zeXN0YWIudGFibGVzID0gc3lzdGFiNjQtPnRhYmxlczsKCkRpdHRvLgoK PiArCQl0bXAgfD0gZWZpX3N5c3RhYi50YWJsZXM7Cj4gIAo+ICAJCWVhcmx5X2lvdW5tYXAoc3lz dGFiNjQsIHNpemVvZigqc3lzdGFiNjQpKTsKPiAgI2lmZGVmIENPTkZJR19YODZfMzIKPiBAQCAt NjMxLDYgKzY3MCw0MSBAQCBzdGF0aWMgaW50IF9faW5pdCBlZmlfbWVtbWFwX2luaXQodm9pZCkK PiAgCXJldHVybiAwOwo+ICB9Cj4gIAo+ICtzdGF0aWMgaW50IF9faW5pdCBlZmlfcmV1c2VfY29u ZmlnKHU2NCB0YWJsZXMsIGludCBucl90YWJsZXMpCgpTdGF0aWMgZnVuY3Rpb24gLSBubyBuZWVk IGZvciAiZWZpXyIgcHJlZml4LgoKPiArewo+ICsJdm9pZCAqcCwgKnRhYmxlcDsKPiArCWludCBp LCBzejsKPiArCj4gKwlpZiAoIWVmaV9lbmFibGVkKEVGSV82NEJJVCkpCj4gKwkJcmV0dXJuIDA7 Cj4gKwo+ICsJc3ogPSBzaXplb2YoZWZpX2NvbmZpZ190YWJsZV82NF90KTsKPiArCj4gKwlwID0g dGFibGVwID0gZWFybHlfbWVtcmVtYXAodGFibGVzLCBucl90YWJsZXMgKiBzeik7Cj4gKwlpZiAo IXApIHsKPiArCQlwcl9lcnIoIkNvdWxkIG5vdCBtYXAgQ29uZmlndXJhdGlvbiB0YWJsZSFcbiIp Owo+ICsJCXJldHVybiAtRU5PTUVNOwo+ICsJfQo+ICsKPiArCWZvciAoaSA9IDA7IGkgPCBlZmku c3lzdGFiLT5ucl90YWJsZXM7IGkrKykgewo+ICsJCWVmaV9ndWlkX3QgZ3VpZDsKPiArCj4gKwkJ Z3VpZCA9ICgoZWZpX2NvbmZpZ190YWJsZV82NF90ICopcCktPmd1aWQ7Cj4gKwo+ICsJCS8qCj4g KwkJSFAgejQyMCB3b3Jrc3RhdGlvbiBzbWJpb3Mgd2lsbCBiZSBjb252ZXJ0IHRvCj4gKwkJdmly dHVhbCBhZGRyZXNzIGFmdGVyIGVudGVyIHZpcnR1YWwgbW9kZS4KPiArCQlUaHVzIGluIGNhc2Ug a2V4ZWMva2R1bXAgdGhlIHBoeXNpY2FsIGFkZHJlc3MKPiArCQl3aWxsIGJlIHBhc3NlZCBpbiBz ZXR1cF9kYXRhLgoKSXMgdGhhdCB3aGF0IHRoZSBjb21taXQgbWVzc2FnZSBhYm92ZSBzYXlzPyBJ J20gaGF2aW5nIGEgaGFyZCB0aW1lCnBhcnNpbmcgdGhpcyB0ZXh0LgoKPiArCQkqLwo+ICsJCWlm ICghZWZpX2d1aWRjbXAoZ3VpZCwgU01CSU9TX1RBQkxFX0dVSUQpKQo+ICsJCQkoKGVmaV9jb25m aWdfdGFibGVfNjRfdCAqKXApLT50YWJsZSA9IGVzZGF0YS0+c21iaW9zOwoKLi4uYW5kIHlldCB3 ZSBkbyB0aGlzIGZvciAqZXZlcnkqIFVFRkkgYm94LiBXaHkgbm90IEhQIG9ubHk/Cgo+ICsJCXAg Kz0gc3o7Cj4gKwl9Cj4gKwllYXJseV9pb3VubWFwKHRhYmxlcCwgbnJfdGFibGVzICogc3opOwo+ ICsJcmV0dXJuIDA7Cj4gK30KPiArCj4gIHZvaWQgX19pbml0IGVmaV9pbml0KHZvaWQpCj4gIHsK PiAgCWVmaV9jaGFyMTZfdCAqYzE2Owo+IEBAIC02NzYsNiArNzUwLDkgQEAgdm9pZCBfX2luaXQg ZWZpX2luaXQodm9pZCkKPiAgCQllZmkuc3lzdGFiLT5oZHIucmV2aXNpb24gPj4gMTYsCj4gIAkJ ZWZpLnN5c3RhYi0+aGRyLnJldmlzaW9uICYgMHhmZmZmLCB2ZW5kb3IpOwo+ICAKPiArCWlmIChl c2RhdGEgJiYgZXNkYXRhLT5zbWJpb3MpCj4gKwkJZWZpX3JldXNlX2NvbmZpZyhlZmkuc3lzdGFi LT50YWJsZXMsIGVmaS5zeXN0YWItPm5yX3RhYmxlcyk7Cj4gKwo+ICAJaWYgKGVmaV9jb25maWdf aW5pdChhcmNoX3RhYmxlcykpCj4gIAkJcmV0dXJuOwo+ICAKPiBAQCAtODg2LDYgKzk2Myw0MyBA QCByZXQ6Cj4gIH0KPiAgCj4gIC8qCj4gKyAqIG1hcCBlZmkgcmVnaW9ucyB3aGljaCB3YXMgcGFz c2VkIHZpYSBzZXR1cF9kYXRhCj4gKyAqIHRoZSB2aXJ0X2FkZHIgaXMgYSBmaXhlZCBhZGRyIHdo aWNoIHdhcyB1c2VkIGluCj4gKyAqIDFzdCBrZXJuZWwgb2Yga2V4ZWMgYm9vdC4KPiArICovCgpD b21tZW50IHRvIDgwIGNvbHMgcGxzLgoKPiArc3RhdGljIHZvaWQgX19pbml0IGVmaV9tYXBfcmVn aW9uc19maXhlZCh2b2lkKQoKQWxzbyBubyBuZWVkIGZvciAiZWZpXyIgcHJlZml4IGhlcmUuCgo+ ICt7Cj4gKwlpbnQgaTsKPiArCXVuc2lnbmVkIGxvbmcgc2l6ZTsKPiArCWVmaV9tZW1vcnlfZGVz Y190ICptZDsKPiArCXU2NCBlbmQsIHN5c3RhYjsKPiArCXZvaWQgKnA7Cj4gKwo+ICsJZWZpX3J1 bnRpbWVfbWFwID0ga3phbGxvYyhucl9lZmlfcnVudGltZV9tYXAgKiBtZW1tYXAuZGVzY19zaXpl LAo+ICsJCQkJR0ZQX0tFUk5FTCk7CgpBcmcgYWxpZ25tZW50LgoKPiArCWlmICghZWZpX3J1bnRp bWVfbWFwKQo+ICsJCXByX2VycigiT3V0IG9mIG1lbW9yeSwgRUZJIHJ1bnRpbWUgb24gbmVzdGVk IGtleGVjIG5vbi1mdW5jdGlvbmFsIVxuIik7Cj4gKwo+ICsJZm9yIChpID0gMCwgcCA9IGVmaV9y dW50aW1lX21hcDsgaSA8IG5yX2VmaV9ydW50aW1lX21hcDsgaSsrKSB7Cj4gKwkJbWQgPSBlc2Rh dGEtPm1hcCArIGk7Cj4gKwkJZWZpX21hcF9yZWdpb25fZml4ZWQobWQpOwoKR2FhaCwgdGhpcyBm dW5jdGlvbiBzaG91bGQgcHJvYmFibHkgaGF2ZSBhIHJldHZhbCB3aGljaCBzaWduYWxpemVzCnN1 Y2Nlc3MvZmFpbHVyZS4gRm9yIHRoYXQgSSBzaG91bGQgcHJvYmFibHkgdGVhY2ggX19tYXBfcmVn aW9uIHRvIGRvCnRoYXQgdG9vLiBPbiB0aGUgVE9ETyBsaXN0LgoKPiArCQlzaXplID0gbWQtPm51 bV9wYWdlcyA8PCBQQUdFX1NISUZUOwo+ICsJCWVuZCA9IG1kLT5waHlzX2FkZHIgKyBzaXplOwo+ ICsKPiArCQlzeXN0YWIgPSAodTY0KSAodW5zaWduZWQgbG9uZykgZWZpX3BoeXMuc3lzdGFiOwo+ ICsJCWlmIChtZC0+cGh5c19hZGRyIDw9IHN5c3RhYiAmJiBzeXN0YWIgPCBlbmQpIHsKPiArCQkJ c3lzdGFiICs9IG1kLT52aXJ0X2FkZHIgLSBtZC0+cGh5c19hZGRyOwo+ICsJCQllZmkuc3lzdGFi ID0KPiArCQkJCShlZmlfc3lzdGVtX3RhYmxlX3QgKikgKHVuc2lnbmVkIGxvbmcpIHN5c3RhYjsK CkNIRUNLOiBObyBzcGFjZSBpcyBuZWNlc3NhcnkgYWZ0ZXIgYSBjYXN0CiMyMTk6IEZJTEU6IGFy Y2gveDg2L3BsYXRmb3JtL2VmaS9lZmkuYzo5OTM6CisgICAgICAgICAgICAgICAgICAgICAgIGVm aS5zeXN0YWIgPQorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChlZmlfc3lzdGVtX3Rh YmxlX3QgKikgKHVuc2lnbmVkIGxvbmcpIHN5c3RhYjsKCgpBbmQgYWxzbywgdGhvc2UgYnJva2Vu IGxpbmVzIGFyZSB1Z2x5LiBKdXN0IGxldCBpdCBzdGljayBvdXQgb3ZlciA4MCBjb2xzLgoKPiAr CQl9Cj4gKwkJaWYgKGVmaV9ydW50aW1lX21hcCkgewo+ICsJCQltZW1jcHkocCwgbWQsIG1lbW1h cC5kZXNjX3NpemUpOwo+ICsJCQlwICs9IG1lbW1hcC5kZXNjX3NpemU7Cj4gKwkJfQo+ICsJfQo+ ICt9Cj4gKwo+ICsvKgo+ICAgKiBUaGlzIGZ1bmN0aW9uIHdpbGwgc3dpdGNoIHRoZSBFRkkgcnVu dGltZSBzZXJ2aWNlcyB0byB2aXJ0dWFsIG1vZGUuCj4gICAqIEVzc2VudGlhbGx5LCB3ZSBsb29r IHRocm91Z2ggdGhlIEVGSSBtZW1tYXAgYW5kIG1hcCBldmVyeSByZWdpb24gdGhhdAo+ICAgKiBo YXMgdGhlIHJ1bnRpbWUgYXR0cmlidXRlIGJpdCBzZXQgaW4gaXRzIG1lbW9yeSBkZXNjcmlwdG9y IGludG8gdGhlCj4gQEAgLTkwMSw2ICsxMDE1LDEwIEBAIHJldDoKPiAgICogc28gdGhhdCB3ZSdy ZSBpbiBhIGRpZmZlcmVudCBhZGRyZXNzIHNwYWNlIHdoZW4gY2FsbGluZyBhIHJ1bnRpbWUKPiAg ICogZnVuY3Rpb24uIEZvciBmdW5jdGlvbiBhcmd1bWVudHMgcGFzc2luZyB3ZSBkbyBjb3B5IHRo ZSBQR0RzIG9mIHRoZQo+ICAgKiBrZXJuZWwgcGFnZSB0YWJsZSBpbnRvIC0+dHJhbXBvbGluZV9w Z2QgcHJpb3IgdG8gZWFjaCBjYWxsLgo+ICsgKgo+ICsgKiBTcGVjaWFsbHkgZm9yIGtleGVjIGJv b3QgZWZpIHJ1bnRpbWUgbWFwcyBpbiBwcmV2aW91cyBrZXJuZWwgc2hvdWxkCgoJCQkgIGJvb3Qs IC4uLgoKPiArICogYmUgcGFzc2VkIGluIHZpYSBzZXR1cF9kYXRhLiBJbiB0aGF0IGNhc2UgcnVu dGltZSByYW5nZXMgd2lsbCBiZSBtYXBwZWQKCgkJCQkJICAgY2FzZSwgLi4uCgo+ICsgKiB0byBm aXhlZCB2aXJ0dWFsIGFkZHJlc3NlcyBleGFjdGx5IHNhbWUgYXMgdGhlIG9uZXMgaW4gcHJldmlv dXMga2VybmVsLgoKIi4uLiB0byB0aGUgc2FtZSB2aXJ0dWFsIGFkZHJlc3NlcyBhcyB0aGUgZmly c3Qga2VybmVsLiIKCj4gICAqLwo+ICB2b2lkIF9faW5pdCBlZmlfZW50ZXJfdmlydHVhbF9tb2Rl KHZvaWQpCj4gIHsKPiBAQCAtOTE5LDEyICsxMDM3LDE1IEBAIHZvaWQgX19pbml0IGVmaV9lbnRl cl92aXJ0dWFsX21vZGUodm9pZCkKPiAgCQlyZXR1cm47Cj4gIAl9Cj4gIAo+IC0JZWZpX21lcmdl X3JlZ2lvbnMoKTsKPiAtCj4gLQluZXdfbWVtbWFwID0gZWZpX21hcF9yZWdpb25zKCZjb3VudCk7 Cj4gLQlpZiAoIW5ld19tZW1tYXApIHsKPiAtCQlwcl9lcnIoIkVycm9yIHJlYWxsb2NhdGluZyBt ZW1vcnksIEVGSSBydW50aW1lIG5vbi1mdW5jdGlvbmFsIVxuIik7Cj4gLQkJcmV0dXJuOwo+ICsJ aWYgKGVzZGF0YSkKPiArCQllZmlfbWFwX3JlZ2lvbnNfZml4ZWQoKTsKPiArCWVsc2Ugewo+ICsJ CWVmaV9tZXJnZV9yZWdpb25zKCk7Cj4gKwkJbmV3X21lbW1hcCA9IGVmaV9tYXBfcmVnaW9ucygm Y291bnQpOwo+ICsJCWlmICghbmV3X21lbW1hcCkgewo+ICsJCQlwcl9lcnIoIkVycm9yIHJlYWxs b2NhdGluZyBtZW1vcnksIEVGSSBydW50aW1lIG5vbi1mdW5jdGlvbmFsIVxuIik7Cj4gKwkJCXJl dHVybjsKPiArCQl9CgpDSEVDSzogYnJhY2VzIHt9IHNob3VsZCBiZSB1c2VkIG9uIGFsbCBhcm1z IG9mIHRoaXMgc3RhdGVtZW50CiMyNTM6IEZJTEU6IGFyY2gveDg2L3BsYXRmb3JtL2VmaS9lZmku YzoxMDQwOgorICAgICAgIGlmIChlc2RhdGEpClsuLi5dCisgICAgICAgZWxzZSB7ClsuLi5dCgot LSAKUmVnYXJkcy9HcnVzcywKICAgIEJvcmlzLgoKU2VudCBmcm9tIGEgZmF0IGNyYXRlIHVuZGVy IG15IGRlc2suIEZvcm1hdHRpbmcgaXMgZmluZS4KLS0KCl9fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fCmtleGVjIG1haWxpbmcgbGlzdAprZXhlY0BsaXN0cy5p bmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8v a2V4ZWMK From mboxrd@z Thu Jan 1 00:00:00 1970 From: Borislav Petkov Subject: Re: [PATCH v4 07/12] efi: passing kexec necessary efi data via setup_data Date: Wed, 27 Nov 2013 15:07:32 +0100 Message-ID: <20131127140732.GD32267@pd.tnic> References: <1385445477-9665-1-git-send-email-dyoung@redhat.com> <1385445477-9665-8-git-send-email-dyoung@redhat.com> Mime-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: QUOTED-PRINTABLE Return-path: Content-Disposition: inline In-Reply-To: <1385445477-9665-8-git-send-email-dyoung-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org> Sender: linux-efi-owner-u79uwXL29TY76Z2rM5mHXA@public.gmane.org To: Dave Young Cc: linux-kernel-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, linux-efi-u79uwXL29TY76Z2rM5mHXA@public.gmane.org, x86-DgEjT+Ai2ygdnm+yROfE0A@public.gmane.org, mjg59-1xO5oi07KQx4cg9Nei1l7Q@public.gmane.org, hpa-YMNOUZJC4hwAvxtiuMwx3w@public.gmane.org, James.Bottomley-d9PhHud1JfjCXq6kfMZ53/egYHeGw8Jk@public.gmane.org, vgoyal-H+wXaHxf7aLQT0dZR+AlfA@public.gmane.org, ebiederm-aS9lmoZGLiVWk0Htik3J/w@public.gmane.org, horms-/R6kz+dDXgpPR4JQBCEnsQ@public.gmane.org, kexec-IAPFreCvJWM7uuMidbF8XUB+6BGkLq7r@public.gmane.org, greg-U8xfFu+wG4EAvxtiuMwx3w@public.gmane.org, matt-HNK1S37rvNbeXh+fF434Mdi2O/JbrIOy@public.gmane.org, toshi.kani-VXdhtT5mjnY@public.gmane.org List-Id: linux-efi@vger.kernel.org On Tue, Nov 26, 2013 at 01:57:52PM +0800, Dave Young wrote: > Add a new setup_data type SETUP_EFI for kexec use. > Passing the saved fw_vendor, runtime, config tables and > efi runtime mappings. >=20 > When entering virtual mode, directly mapping the efi > runtime ragions which we passed in previously. And skip > the step to call SetVirtualAddressMap. >=20 > Specially for HP z420 workstation it need another variable > saving, Why the special handling? Does that mean, this is going to be the case for other HP UEFI implementations too? > it's the smbios physical address, the HP bios > also update the SMBIOS address after entering virtual mode > besides of the standard fw_vendor,runtime and config table. >=20 > Tested on ovmf+qemu, lenovo thinkpad, a dell laptop and an > HP z420 workstation. >=20 > v2: refresh based on previous patch changes, code cleanup. > v3: use ioremap instead of phys_to_virt for esdata >=20 > Signed-off-by: Dave Young > --- > arch/x86/include/asm/efi.h | 12 +++ > arch/x86/include/uapi/asm/bootparam.h | 1 + > arch/x86/kernel/setup.c | 3 + > arch/x86/platform/efi/efi.c | 161 ++++++++++++++++++++++++= ++++++---- > 4 files changed, 160 insertions(+), 17 deletions(-) >=20 > diff --git a/arch/x86/include/asm/efi.h b/arch/x86/include/asm/efi.h > index 9fbaeb2..73d5643 100644 > --- a/arch/x86/include/asm/efi.h > +++ b/arch/x86/include/asm/efi.h > @@ -133,6 +133,18 @@ extern void efi_sync_low_kernel_mappings(void); > extern void efi_setup_page_tables(void); > extern void __init old_map_region(efi_memory_desc_t *md); > =20 > +struct efi_setup_data { > + u64 fw_vendor; > + u64 runtime; > + u64 tables; > + u64 smbios; > + u64 reserved[8]; What's that for? > + efi_memory_desc_t map[0]; > +}; > + > +extern void parse_efi_setup(u64 phys_addr, u32 data_len); > +extern struct efi_setup_data *esdata; > + > #ifdef CONFIG_EFI > =20 > static inline bool efi_is_native(void) [ =E2=80=A6 ] > diff --git a/arch/x86/platform/efi/efi.c b/arch/x86/platform/efi/efi.= c > index c3a2aaa..fafeb40 100644 > --- a/arch/x86/platform/efi/efi.c > +++ b/arch/x86/platform/efi/efi.c > @@ -504,8 +531,12 @@ static int __init efi_systab_init(void *phys) > } > =20 > efi_systab.hdr =3D systab64->hdr; > - efi_systab.fw_vendor =3D systab64->fw_vendor; > - tmp |=3D systab64->fw_vendor; > + > + if (esdata) > + efi_systab.fw_vendor =3D (unsigned long)esdata->fw_vendor; > + else > + efi_systab.fw_vendor =3D systab64->fw_vendor; efi_systab.fw_vendor =3D esdata ? (unsigned long)esdata->fw_vendor : systab64->fw_vendor; > + tmp |=3D efi_systab.fw_vendor; > efi_systab.fw_revision =3D systab64->fw_revision; > efi_systab.con_in_handle =3D systab64->con_in_handle; > tmp |=3D systab64->con_in_handle; > @@ -519,13 +550,21 @@ static int __init efi_systab_init(void *phys) > tmp |=3D systab64->stderr_handle; > efi_systab.stderr =3D systab64->stderr; > tmp |=3D systab64->stderr; > - efi_systab.runtime =3D (void *)(unsigned long)systab64->runtime; > - tmp |=3D systab64->runtime; > + if (esdata) > + efi_systab.runtime =3D > + (void *)(unsigned long)esdata->runtime; > + else > + efi_systab.runtime =3D > + (void *)(unsigned long)systab64->runtime; Ditto. Which would take care of these linebreaks which are ugly. > + tmp |=3D (unsigned long)efi_systab.runtime; > efi_systab.boottime =3D (void *)(unsigned long)systab64->boottime; > tmp |=3D systab64->boottime; > efi_systab.nr_tables =3D systab64->nr_tables; > - efi_systab.tables =3D systab64->tables; > - tmp |=3D systab64->tables; > + if (esdata) > + efi_systab.tables =3D (unsigned long)esdata->tables; > + else > + efi_systab.tables =3D systab64->tables; Ditto. > + tmp |=3D efi_systab.tables; > =20 > early_iounmap(systab64, sizeof(*systab64)); > #ifdef CONFIG_X86_32 > @@ -631,6 +670,41 @@ static int __init efi_memmap_init(void) > return 0; > } > =20 > +static int __init efi_reuse_config(u64 tables, int nr_tables) Static function - no need for "efi_" prefix. > +{ > + void *p, *tablep; > + int i, sz; > + > + if (!efi_enabled(EFI_64BIT)) > + return 0; > + > + sz =3D sizeof(efi_config_table_64_t); > + > + p =3D tablep =3D early_memremap(tables, nr_tables * sz); > + if (!p) { > + pr_err("Could not map Configuration table!\n"); > + return -ENOMEM; > + } > + > + for (i =3D 0; i < efi.systab->nr_tables; i++) { > + efi_guid_t guid; > + > + guid =3D ((efi_config_table_64_t *)p)->guid; > + > + /* > + HP z420 workstation smbios will be convert to > + virtual address after enter virtual mode. > + Thus in case kexec/kdump the physical address > + will be passed in setup_data. Is that what the commit message above says? I'm having a hard time parsing this text. > + */ > + if (!efi_guidcmp(guid, SMBIOS_TABLE_GUID)) > + ((efi_config_table_64_t *)p)->table =3D esdata->smbios; =2E..and yet we do this for *every* UEFI box. Why not HP only? > + p +=3D sz; > + } > + early_iounmap(tablep, nr_tables * sz); > + return 0; > +} > + > void __init efi_init(void) > { > efi_char16_t *c16; > @@ -676,6 +750,9 @@ void __init efi_init(void) > efi.systab->hdr.revision >> 16, > efi.systab->hdr.revision & 0xffff, vendor); > =20 > + if (esdata && esdata->smbios) > + efi_reuse_config(efi.systab->tables, efi.systab->nr_tables); > + > if (efi_config_init(arch_tables)) > return; > =20 > @@ -886,6 +963,43 @@ ret: > } > =20 > /* > + * map efi regions which was passed via setup_data > + * the virt_addr is a fixed addr which was used in > + * 1st kernel of kexec boot. > + */ Comment to 80 cols pls. > +static void __init efi_map_regions_fixed(void) Also no need for "efi_" prefix here. > +{ > + int i; > + unsigned long size; > + efi_memory_desc_t *md; > + u64 end, systab; > + void *p; > + > + efi_runtime_map =3D kzalloc(nr_efi_runtime_map * memmap.desc_size, > + GFP_KERNEL); Arg alignment. > + if (!efi_runtime_map) > + pr_err("Out of memory, EFI runtime on nested kexec non-functional!= \n"); > + > + for (i =3D 0, p =3D efi_runtime_map; i < nr_efi_runtime_map; i++) { > + md =3D esdata->map + i; > + efi_map_region_fixed(md); Gaah, this function should probably have a retval which signalizes success/failure. For that I should probably teach __map_region to do that too. On the TODO list. > + size =3D md->num_pages << PAGE_SHIFT; > + end =3D md->phys_addr + size; > + > + systab =3D (u64) (unsigned long) efi_phys.systab; > + if (md->phys_addr <=3D systab && systab < end) { > + systab +=3D md->virt_addr - md->phys_addr; > + efi.systab =3D > + (efi_system_table_t *) (unsigned long) systab; CHECK: No space is necessary after a cast #219: FILE: arch/x86/platform/efi/efi.c:993: + efi.systab =3D + (efi_system_table_t *) (unsigned long) = systab; And also, those broken lines are ugly. Just let it stick out over 80 co= ls. > + } > + if (efi_runtime_map) { > + memcpy(p, md, memmap.desc_size); > + p +=3D memmap.desc_size; > + } > + } > +} > + > +/* > * This function will switch the EFI runtime services to virtual mod= e. > * Essentially, we look through the EFI memmap and map every region = that > * has the runtime attribute bit set in its memory descriptor into t= he > @@ -901,6 +1015,10 @@ ret: > * so that we're in a different address space when calling a runtime > * function. For function arguments passing we do copy the PGDs of t= he > * kernel page table into ->trampoline_pgd prior to each call. > + * > + * Specially for kexec boot efi runtime maps in previous kernel shou= ld boot, ... > + * be passed in via setup_data. In that case runtime ranges will be = mapped case, ... > + * to fixed virtual addresses exactly same as the ones in previous k= ernel. "... to the same virtual addresses as the first kernel." > */ > void __init efi_enter_virtual_mode(void) > { > @@ -919,12 +1037,15 @@ void __init efi_enter_virtual_mode(void) > return; > } > =20 > - efi_merge_regions(); > - > - new_memmap =3D efi_map_regions(&count); > - if (!new_memmap) { > - pr_err("Error reallocating memory, EFI runtime non-functional!\n")= ; > - return; > + if (esdata) > + efi_map_regions_fixed(); > + else { > + efi_merge_regions(); > + new_memmap =3D efi_map_regions(&count); > + if (!new_memmap) { > + pr_err("Error reallocating memory, EFI runtime non-functional!\n"= ); > + return; > + } CHECK: braces {} should be used on all arms of this statement #253: FILE: arch/x86/platform/efi/efi.c:1040: + if (esdata) [...] + else { [...] --=20 Regards/Gruss, Boris. Sent from a fat crate under my desk. Formatting is fine. -- From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1752563Ab3K0OHo (ORCPT ); Wed, 27 Nov 2013 09:07:44 -0500 Received: from mail.skyhub.de ([78.46.96.112]:38995 "EHLO mail.skyhub.de" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1751611Ab3K0OHl (ORCPT ); Wed, 27 Nov 2013 09:07:41 -0500 Date: Wed, 27 Nov 2013 15:07:32 +0100 From: Borislav Petkov To: Dave Young Cc: linux-kernel@vger.kernel.org, linux-efi@vger.kernel.org, x86@kernel.org, mjg59@srcf.ucam.org, hpa@zytor.com, James.Bottomley@HansenPartnership.com, vgoyal@redhat.com, ebiederm@xmission.com, horms@verge.net.au, kexec@lists.infradead.org, greg@kroah.com, matt@console-pimps.org, toshi.kani@hp.com Subject: Re: [PATCH v4 07/12] efi: passing kexec necessary efi data via setup_data Message-ID: <20131127140732.GD32267@pd.tnic> References: <1385445477-9665-1-git-send-email-dyoung@redhat.com> <1385445477-9665-8-git-send-email-dyoung@redhat.com> MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Disposition: inline Content-Transfer-Encoding: 8bit In-Reply-To: <1385445477-9665-8-git-send-email-dyoung@redhat.com> User-Agent: Mutt/1.5.21 (2010-09-15) Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org On Tue, Nov 26, 2013 at 01:57:52PM +0800, Dave Young wrote: > Add a new setup_data type SETUP_EFI for kexec use. > Passing the saved fw_vendor, runtime, config tables and > efi runtime mappings. > > When entering virtual mode, directly mapping the efi > runtime ragions which we passed in previously. And skip > the step to call SetVirtualAddressMap. > > Specially for HP z420 workstation it need another variable > saving, Why the special handling? Does that mean, this is going to be the case for other HP UEFI implementations too? > it's the smbios physical address, the HP bios > also update the SMBIOS address after entering virtual mode > besides of the standard fw_vendor,runtime and config table. > > Tested on ovmf+qemu, lenovo thinkpad, a dell laptop and an > HP z420 workstation. > > v2: refresh based on previous patch changes, code cleanup. > v3: use ioremap instead of phys_to_virt for esdata > > Signed-off-by: Dave Young > --- > arch/x86/include/asm/efi.h | 12 +++ > arch/x86/include/uapi/asm/bootparam.h | 1 + > arch/x86/kernel/setup.c | 3 + > arch/x86/platform/efi/efi.c | 161 ++++++++++++++++++++++++++++++---- > 4 files changed, 160 insertions(+), 17 deletions(-) > > diff --git a/arch/x86/include/asm/efi.h b/arch/x86/include/asm/efi.h > index 9fbaeb2..73d5643 100644 > --- a/arch/x86/include/asm/efi.h > +++ b/arch/x86/include/asm/efi.h > @@ -133,6 +133,18 @@ extern void efi_sync_low_kernel_mappings(void); > extern void efi_setup_page_tables(void); > extern void __init old_map_region(efi_memory_desc_t *md); > > +struct efi_setup_data { > + u64 fw_vendor; > + u64 runtime; > + u64 tables; > + u64 smbios; > + u64 reserved[8]; What's that for? > + efi_memory_desc_t map[0]; > +}; > + > +extern void parse_efi_setup(u64 phys_addr, u32 data_len); > +extern struct efi_setup_data *esdata; > + > #ifdef CONFIG_EFI > > static inline bool efi_is_native(void) [ … ] > diff --git a/arch/x86/platform/efi/efi.c b/arch/x86/platform/efi/efi.c > index c3a2aaa..fafeb40 100644 > --- a/arch/x86/platform/efi/efi.c > +++ b/arch/x86/platform/efi/efi.c > @@ -504,8 +531,12 @@ static int __init efi_systab_init(void *phys) > } > > efi_systab.hdr = systab64->hdr; > - efi_systab.fw_vendor = systab64->fw_vendor; > - tmp |= systab64->fw_vendor; > + > + if (esdata) > + efi_systab.fw_vendor = (unsigned long)esdata->fw_vendor; > + else > + efi_systab.fw_vendor = systab64->fw_vendor; efi_systab.fw_vendor = esdata ? (unsigned long)esdata->fw_vendor : systab64->fw_vendor; > + tmp |= efi_systab.fw_vendor; > efi_systab.fw_revision = systab64->fw_revision; > efi_systab.con_in_handle = systab64->con_in_handle; > tmp |= systab64->con_in_handle; > @@ -519,13 +550,21 @@ static int __init efi_systab_init(void *phys) > tmp |= systab64->stderr_handle; > efi_systab.stderr = systab64->stderr; > tmp |= systab64->stderr; > - efi_systab.runtime = (void *)(unsigned long)systab64->runtime; > - tmp |= systab64->runtime; > + if (esdata) > + efi_systab.runtime = > + (void *)(unsigned long)esdata->runtime; > + else > + efi_systab.runtime = > + (void *)(unsigned long)systab64->runtime; Ditto. Which would take care of these linebreaks which are ugly. > + tmp |= (unsigned long)efi_systab.runtime; > efi_systab.boottime = (void *)(unsigned long)systab64->boottime; > tmp |= systab64->boottime; > efi_systab.nr_tables = systab64->nr_tables; > - efi_systab.tables = systab64->tables; > - tmp |= systab64->tables; > + if (esdata) > + efi_systab.tables = (unsigned long)esdata->tables; > + else > + efi_systab.tables = systab64->tables; Ditto. > + tmp |= efi_systab.tables; > > early_iounmap(systab64, sizeof(*systab64)); > #ifdef CONFIG_X86_32 > @@ -631,6 +670,41 @@ static int __init efi_memmap_init(void) > return 0; > } > > +static int __init efi_reuse_config(u64 tables, int nr_tables) Static function - no need for "efi_" prefix. > +{ > + void *p, *tablep; > + int i, sz; > + > + if (!efi_enabled(EFI_64BIT)) > + return 0; > + > + sz = sizeof(efi_config_table_64_t); > + > + p = tablep = early_memremap(tables, nr_tables * sz); > + if (!p) { > + pr_err("Could not map Configuration table!\n"); > + return -ENOMEM; > + } > + > + for (i = 0; i < efi.systab->nr_tables; i++) { > + efi_guid_t guid; > + > + guid = ((efi_config_table_64_t *)p)->guid; > + > + /* > + HP z420 workstation smbios will be convert to > + virtual address after enter virtual mode. > + Thus in case kexec/kdump the physical address > + will be passed in setup_data. Is that what the commit message above says? I'm having a hard time parsing this text. > + */ > + if (!efi_guidcmp(guid, SMBIOS_TABLE_GUID)) > + ((efi_config_table_64_t *)p)->table = esdata->smbios; ...and yet we do this for *every* UEFI box. Why not HP only? > + p += sz; > + } > + early_iounmap(tablep, nr_tables * sz); > + return 0; > +} > + > void __init efi_init(void) > { > efi_char16_t *c16; > @@ -676,6 +750,9 @@ void __init efi_init(void) > efi.systab->hdr.revision >> 16, > efi.systab->hdr.revision & 0xffff, vendor); > > + if (esdata && esdata->smbios) > + efi_reuse_config(efi.systab->tables, efi.systab->nr_tables); > + > if (efi_config_init(arch_tables)) > return; > > @@ -886,6 +963,43 @@ ret: > } > > /* > + * map efi regions which was passed via setup_data > + * the virt_addr is a fixed addr which was used in > + * 1st kernel of kexec boot. > + */ Comment to 80 cols pls. > +static void __init efi_map_regions_fixed(void) Also no need for "efi_" prefix here. > +{ > + int i; > + unsigned long size; > + efi_memory_desc_t *md; > + u64 end, systab; > + void *p; > + > + efi_runtime_map = kzalloc(nr_efi_runtime_map * memmap.desc_size, > + GFP_KERNEL); Arg alignment. > + if (!efi_runtime_map) > + pr_err("Out of memory, EFI runtime on nested kexec non-functional!\n"); > + > + for (i = 0, p = efi_runtime_map; i < nr_efi_runtime_map; i++) { > + md = esdata->map + i; > + efi_map_region_fixed(md); Gaah, this function should probably have a retval which signalizes success/failure. For that I should probably teach __map_region to do that too. On the TODO list. > + size = md->num_pages << PAGE_SHIFT; > + end = md->phys_addr + size; > + > + systab = (u64) (unsigned long) efi_phys.systab; > + if (md->phys_addr <= systab && systab < end) { > + systab += md->virt_addr - md->phys_addr; > + efi.systab = > + (efi_system_table_t *) (unsigned long) systab; CHECK: No space is necessary after a cast #219: FILE: arch/x86/platform/efi/efi.c:993: + efi.systab = + (efi_system_table_t *) (unsigned long) systab; And also, those broken lines are ugly. Just let it stick out over 80 cols. > + } > + if (efi_runtime_map) { > + memcpy(p, md, memmap.desc_size); > + p += memmap.desc_size; > + } > + } > +} > + > +/* > * This function will switch the EFI runtime services to virtual mode. > * Essentially, we look through the EFI memmap and map every region that > * has the runtime attribute bit set in its memory descriptor into the > @@ -901,6 +1015,10 @@ ret: > * so that we're in a different address space when calling a runtime > * function. For function arguments passing we do copy the PGDs of the > * kernel page table into ->trampoline_pgd prior to each call. > + * > + * Specially for kexec boot efi runtime maps in previous kernel should boot, ... > + * be passed in via setup_data. In that case runtime ranges will be mapped case, ... > + * to fixed virtual addresses exactly same as the ones in previous kernel. "... to the same virtual addresses as the first kernel." > */ > void __init efi_enter_virtual_mode(void) > { > @@ -919,12 +1037,15 @@ void __init efi_enter_virtual_mode(void) > return; > } > > - efi_merge_regions(); > - > - new_memmap = efi_map_regions(&count); > - if (!new_memmap) { > - pr_err("Error reallocating memory, EFI runtime non-functional!\n"); > - return; > + if (esdata) > + efi_map_regions_fixed(); > + else { > + efi_merge_regions(); > + new_memmap = efi_map_regions(&count); > + if (!new_memmap) { > + pr_err("Error reallocating memory, EFI runtime non-functional!\n"); > + return; > + } CHECK: braces {} should be used on all arms of this statement #253: FILE: arch/x86/platform/efi/efi.c:1040: + if (esdata) [...] + else { [...] -- Regards/Gruss, Boris. Sent from a fat crate under my desk. Formatting is fine. --