From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mga02.intel.com ([134.134.136.20]) by canuck.infradead.org with esmtp (Exim 4.63 #1 (Red Hat Linux)) id 1IPU8p-000714-9I for kexec@lists.infradead.org; Sun, 26 Aug 2007 22:15:52 -0400 Subject: RE: [linux-pm] [RFC][PATCH 0/2 -mm] kexec based hibernation From: "Huang, Ying" In-Reply-To: <9D7649D18729DE4BB2BD7B494F7FEDC257EA60@pdsmsx415.ccr.corp.intel.com> References: <9D7649D18729DE4BB2BD7B494F7FEDC257EA60@pdsmsx415.ccr.corp.intel.com> Date: Mon, 27 Aug 2007 10:16:37 +0800 Message-Id: <1188180997.3247.68.camel@caritas-dev.intel.com> Mime-Version: 1.0 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-bounces@lists.infradead.org Errors-To: kexec-bounces+dwmw2=infradead.org+dwmw2=infradead.org@lists.infradead.org To: "Hu, Fenghua" Cc: nigel@nigel.suspend2.net, Kexec Mailing List , linux-kernel@vger.kernel.org, Alan Stern , "Eric W. Biederman" , Pavel Machek , Andrew Morton , linux-pm@lists.linux-foundation.org, Jeremy Maitin-Shepard T24gTW9uLCAyMDA3LTA4LTI3IGF0IDA5OjI4ICswODAwLCBIdSwgRmVuZ2h1YSB3cm90ZToKPiBP bmUgcXVpY2sgcXVlc3Rpb24gaXMsIGNhbiBpdCBpbXByb3ZlIGhpYmVyYXRpb24vd2FrZXVwIHRp bWU/CgpJbiBnZW5lcmFsLCBmb3Iga2V4ZWMgYmFzZWQgaGliZXJuYXRpb24sIHdoYXQgaW5jcmVh c2VzCmhpYmVybmF0aW9uL3dha2V1cCB0aW1lOgoKLSBPbmUgZXh0cmEgTGludXggYm9vdCBpcyBu ZWVkZWQgdG8gaGliZXJuYXRlIGFuZCB3YWtldXAuCgoKV2hhdCBkZWNyZWFzZXMgaGliZXJuYXRp b24vd2FrZXVwIHRpbWU6CgotIE1vc3QgaGliZXJuYXRpb24vd2FrZXVwIHdvcmsgaXMgZG9uZSBp biBmdWxsIGZ1bmN0aW9uYWwgdXNlciBzcGFjZQpwcm9ncmFtLCBzbyBpdCBpcyBwb3NzaWJsZSB0 byBkbyBzb21lIG9wdGltaXphdGlvbiwgc3VjaCBhcyBwYXJhbGxlbApjb21wcmVzc2lvbi4KCgpT bywgSSB0aGluayB0aGUga2V4ZWMgYmFzZWQgaGliZXJuYXRpb24gbWF5IGJlIHNsb3dlciB0aGFu IG9yaWdpbmFsCmltcGxlbWVudGF0aW9uIGluIGdlbmVyYWwuIEluIHRoaXMgcHJvdG90eXBlIGlt cGxlbWVudGF0aW9uLCB0aGUKaGliZXJuYXRpb24vd2FrZXVwIHRpbWUgaXMgbXVjaCBsb25nZXIg dGhhbiBvcmlnaW5hbCBoaWJlcm5hdGlvbi93YWtldXAKaW1wbGVtZW50YXRpb24uIEJ1dCBpdCBo YXMgbXVjaCB0byBiZSBvcHRpbWl6ZWQgYW5kIEkgdGhpbmsgaXQgY2FuCmFwcHJvYWNoIHRoZSBz cGVlZCBvZiB0aGUgb3JpZ2luYWwgaW1wbGVtZW50YXRpb24gYWZ0ZXIgb3B0aW1pemF0aW9uLgoK CkZvciBleGFtcGxlLCB0aGUgaGliZXJuYXRpb24gaW1hZ2UgaXMgYW4gb3JkaW5hcnkgRUxGIGZp bGUsIHNvIGl0IGNhbiBiZQpsb2FkZWQgYnkgYm9vdGxvYWRlciBkaXJlY3RseS4KCkJlc3QgUmVn YXJkcywKSHVhbmcgWWluZwoKPiBCZXN0IHJlZ2FyZHMKPiBIdSwgRmVuZ2h1YQo+IAo+IAo+IC0t LS0tT3JpZ2luYWwgTWVzc2FnZS0tLS0tCj4gRnJvbTogbGludXgtcG0tYm91bmNlc0BsaXN0cy5s aW51eC1mb3VuZGF0aW9uLm9yZyBbbWFpbHRvOmxpbnV4LXBtLWJvdW5jZXNAbGlzdHMubGludXgt Zm91bmRhdGlvbi5vcmddIE9uIEJlaGFsZiBPZiBIdWFuZywgWWluZwo+IFNlbnQ6IDIwMDflubQ4 5pyIMjfml6UgOToxNAo+IFRvOiBFcmljIFcuIEJpZWRlcm1hbjsgUGF2ZWwgTWFjaGVrOyBuaWdl bEBuaWdlbC5zdXNwZW5kMi5uZXQ7IEFuZHJldyBNb3J0b247IEplcmVteSBNYWl0aW4tU2hlcGFy ZDsgQWxhbiBTdGVybgo+IENjOiBsaW51eC1wbUBsaXN0cy5saW51eC1mb3VuZGF0aW9uLm9yZzsg S2V4ZWMgTWFpbGluZyBMaXN0OyBsaW51eC1rZXJuZWxAdmdlci5rZXJuZWwub3JnCj4gU3ViamVj dDogW2xpbnV4LXBtXSBbUkZDXVtQQVRDSCAwLzIgLW1tXSBrZXhlYyBiYXNlZCBoaWJlcm5hdGlv bgo+IAo+IEtleGVjIGJhc2UgaGliZXJuYXRpb24gaGFzIHNvbWUgcG90ZW50aWFsIGFkdmFudGFn ZXMgb3ZlciB1c3dzdXNwIGFuZAo+IFR1eE9uSWNlIChzdXNwZW5kMikuIFNvbWUgbW9zdCBvYnZp b3VzIGFkdmFudGFnZXMgYXJlOgo+IAo+IDEuIFRoZSBoaWJlcm5hdGlvbiBpbWFnZSBzaXplIGNh biBleGNlZWQgaGFsZiBvZiBtZW1vcnkgc2l6ZSBlYXNpbHkuCj4gCj4gMi4gVGhlIGhpYmVybmF0 aW9uIGltYWdlIGNhbiBiZSB3cml0dGVuIHRvIGFuZCByZWFkIGZyb20gYWxtb3N0Cj4gICAgYW55 d2hlcmUsIHN1Y2ggYXMgVVNCIGRpc2ssIE5GUy4KPiAKPiAzLiBJdCBpcyBwb3NzaWJsZSB0byBl bGltaW5hdGUgZnJlZXplciBmcm9tIGtleGVjIGJhc2VkIGhpYmVybmF0aW9uCj4gICAgaW1wbGVt ZW50YXRpb24uCj4gCj4gNC4gQmFzZWQgb24ga2V4ZWMva2R1bXAgaW1wbGVtZW50YXRpb24sIHRo ZSBrZXJuZWwgY29kZSBuZWVkZWQgaXMKPiAgICBsZXNzLgo+IAo+IAo+IFRoaXMgcGF0Y2ggc2V0 IGltcGxlbWVudHMgYSBwcm90b3R5cGUgb2Yga2V4ZWMgYmFzZWQgaGliZXJuYXRpb24uIFRoZQo+ IGtlcm5lbCBmdW5jdGlvbmFsaXRpZXMgYWRkZWQgYXJlIGFzIGZvbGxvdzoKPiAKPiAxLiBKdW1w aW5nIGZyb20ga2V4ZWNlZCBrZXJuZWwgYmFjayB0byBvcmlnaW5hbCBrZXJuZWwuIFRoaXMgaXMg dXNlZAo+ICAgIGJ5IGhpYmVybmF0aW9uIHRvIHNhdmUvbG9hZCBuZWNlc3Nhcnkgc3RhdGUgaW4g b3JpZ2luYWwga2VybmVsIGFuZAo+ICAgIGp1bXBpbmcgYmFjayB0byBvcmlnaW5hbCBrZXJuZWwg YWZ0ZXIgcmVzdG9yZSB0aGUgbWVtb3J5IG9mCj4gICAgb3JpZ2luYWwga2VybmVsLgo+IAo+IDIu IEFkZCB3cml0aW5nIHN1cHBvcnQgdG8gL2Rldi9vbGRtZW0uIFRoaXMgaXMgdXNlZCBieSBoaWJl cm5hdGlvbiB0bwo+ICAgIHJlc3RvcmUgdGhlIG1lbW9yeSBvZiBvcmlnaW5hbCBrZXJuZWwuCj4g Cj4gCj4gVGhlIGhpYmVybmF0aW9uIHByb2Nlc3Mgd2l0aCB0aGUgcGF0Y2ggc2V0IGlzIGFzIGZv bGxvdzoKPiAKPiAxLiBCb290IGEga2VybmVsIEEKPiAKPiAyLiBXb3JrIHVuZGVyIGtlcm5lbCBB Cj4gCj4gMy4gS2V4ZWMgYW5vdGhlciBrZXJuZWwgQiAoY3Jhc2ggZHVtcCBlbmFibGVkKSBpbiBr ZXJuZWwgQS4KPiAKPiA0LiBTYXZlIHRoZSBtZW1vcnkgaW1hZ2Ugb2Yga2VybmVsIEEgdGhyb3Vn aCBjcmFzaCBkdW1wIChzdWNoIGFzICJjcAo+ICAgIC9wcm9jL3ZtY29yZSDigL4iKS4gU2F2ZSB0 aGUgImp1bXAgYnVmZmVyIHBmbiIuCj4gCj4gNS4gU2h1dGRvd24gb3IgcmVib290Cj4gCj4gCj4g VGhlIHJlc3RvcmUgcHJvY2VzcyB3aXRoIHRoZSBwYXRjaCBzZXQgaXMgYXMgZm9sbG93Ogo+IAo+ IDEuIEJvb3QgYSBrZXJuZWwgQwo+IAo+IDIuIEtleGVjIGFub3RoZXIga2VybmVsIEQgKGNyYXNo IGR1bXAgZW5hYmxlZCkgaW4ga2VybmVsIEMuIFRoZSBtZW1vcnkKPiAgICBhcmVhIHVzZWQgYnkg a2VybmVsIEQgbXVzdCBiZSBhIHN1YnNldCBvZiBtZW1vcnkgYXJlYSB1c2VkIGJ5Cj4gICAga2Vy bmVsIEIuCj4gCj4gMy4gUmVzdG9yZSB0aGUgbWVtb3J5IGltYWdlIG9mIGtlcm5lbCBBIHRocm91 Z2ggL2Rldi9vbGRtZW0uIFJlc3RvcmUKPiAgICB0aGUgImp1bXAgYnVmZmVyIHBmbiIuCj4gCj4g NC4gSnVtcCBmcm9tIGtlcm5lbCBEIGJhY2sgdG8ga2VybmVsIEEKPiAKPiA1LiBDb250aW51ZSB3 b3JrIHVuZGVyIGtlcm5lbCBBCj4gCj4gCj4gVGhlIGZvbGxvd2luZyB1c2VyLXNwYWNlIHRvb2xz IGFyZSBuZWVkZWQgdG8gaW1wbGVtZW50IGhpYmVybmF0aW9uIGFuZAo+IHJlc3RvcmUuCj4gCj4g MS4ga2V4ZWMtdG9vbHMgbmVlZHMgdG8gYmUgcGF0Y2hlZCB0byBzdXBwb3J0IGtleGVjIGp1bXAu IFRoZSBwYXRjaCBpcwo+ICAgIGF0dGFjaGVkIGluIHRoaXMgbWFpbC4gVGhlIHByZWNvbXBpbGVk IGtleGVjIGNhbiBiZSBkb3dubG9hZCBmcm9tOgo+ICAgICAgICBodHRwOi8vbGludXgtbWNyNzAw LnNvdXJjZWZvcmdlLm5ldC9ranVtcC9rZXhlYwo+IAo+IDIuIE1lbW9yeSBpbWFnZSBzYXZpbmcg dG9vbC4gQ3VycmVudGx5LCB0aGUgbWVtb3J5IGltYWdlIHNhdmluZyBpcwo+ICAgIGRvbmUgdGhy b3VnaDogImNwIC9wcm9jL3ZtY29yZSA8aW1hZ2UgZmlsZT4iLiBUaGlzIHdpbGwgc2F2ZSBhbGwK PiAgICBtZW1vcnkgcGFnZXMgb2Ygb3JpZ2luYWwga2VybmVsIGluY2x1ZGluZyB0aGUgZnJlZSBw YWdlcy4gTWF5YmUgdGhlCj4gICAgY3Jhc2ggZHVtcCB0b29sICJtYWtlZHVtcGZpbGUiIGNhbiBi ZSB1c2VkIGZvciB0aGlzLCBidXQgaXQgaGFzIG5vdAo+ICAgIGJlZW4gdGVzdGVkLgo+IAo+IDMu IE1lbW9yeSBpbWFnZSByZXN0b3JlIHRvb2wuIEEgc2ltcGxlc3QgbWVtb3J5IGltYWdlIHJlc3Rv cmluZyB0b29sCj4gICAgbmFtZWQgImtyZXN0b3JlIiBpcyBpbXBsZW1lbnRlZC4gSXQgY2FuIGJl IGRvd25sb2FkZWQgZnJvbQo+ICAgIGZvbGxvd2luZyBVUkw6Cj4gICAgICAgIHNvdXJjZTogaHR0 cDovL2xpbnV4LW1jcjcwMC5zb3VyY2Vmb3JnZS5uZXQva2p1bXAva3Jlc3RvcmUudGFyLmd6Cj4g ICAgICAgIGJpbmFyeTogaHR0cDovL2xpbnV4LW1jcjcwMC5zb3VyY2Vmb3JnZS5uZXQva2p1bXAv a3Jlc3RvcmUKPiAKPiAKPiBLbm93biBpc3N1ZXM6Cj4gCj4gMS4gVGhlIGtlcm5lbCBCIHJ1biBh cyBhIGNyYXNoZHVtcCBrZXJuZWwgaW4gcmVzZXJ2ZWQgbWVtb3J5Cj4gICAgcmVnaW9uLiBUaGlz IGlzIHRoZSBiaWdnZXN0IGNvbnN0cmFpbnMgb2YgdGhlIHBhdGNoIHNldCBhbmQgcGxhbmVkCj4g ICAgdG8gYmUgZWxpbWluYXRlZCBpbiB0aGUgZnV0dXJlIHZlcnNpb24uIFRoYXQgaXMsIGluc3Rl YWQgb2YKPiAgICByZXNlcnZpbmcgbWVtb3J5IHJlZ2lvbiBwcmV2aW91c2x5LCB0aGUgbmVlZGVk IG1lbW9yeSByZWdpb24gaXMKPiAgICBiYWNrdXBwZWQgYmVmb3JlIGtleGVjIGFuZCByZXN0b3Jl ZCBhZnRlciBqdW1waW5nIGJhY2suCj4gCj4gMi4gQW5vdGhlciBjb25zdHJhaW5zIG9mIHRoZSBw YXRjaCBzZXQgaXMgdGhhdCB0aGUgQ09ORklHX0FDUEkgbXVzdCBiZQo+ICAgIHR1cm5lZCBvZmYg dG8gbWFrZSBrZXhlYyBqdW1wIHdvcmsuIEJlY2F1c2UgQUNQSSB3aWxsIHB1dCBkZXZpY2VzCj4g ICAgaW50byBsb3cgcG93ZXIgc3RhdGUsIHRoZSBrZXhlY2VkIGtlcm5lbCBjYW4gbm90IGJlIGJv b3RlZCBwcm9wZXJseQo+ICAgIHVuZGVyIGl0LiBUaGlzIGNvbnN0cmFpbnMgY2FuIGJlIGVsaW1p bmF0ZWQgYnkgc2VwYXJhdGluZyB0aGUKPiAgICBzdXNwZW5kIG1ldGhvZCBhbmQgaGliZXJuYXRl IG1ldGhvZCBvZiB0aGUgZGV2aWNlcyBhcyBwcm9wb3NlZAo+ICAgIGVhcmxpZXIgaW4gdGhlIExL TUwuCj4gCj4gMy4gVGhlIHNldHVwIG9mIGhpYmVybmF0aW9uL3Jlc3RvcmUgaXMgZmFpcmx5IGNv bXBsZXguIEkgd2lsbCBjb250aW51ZQo+ICAgIHdvcmtpbmcgb24gc2ltcGxpZnlpbmcuCj4gCj4g NC4gTWVtb3J5IHBhZ2VzIGluY2x1ZGluZyBmcmVlIHBhZ2VzIG9mIGtlcm5lbCBBIGFyZSBzYXZl ZC4gSSB0aGluawo+ICAgIHRoZSAibWFrZWR1bXBmaWxlIiB0b29sIGNhbiBiZSB1c2VkIHRvIGV4 Y2x1ZGUgImZyZWUgcGFnZXMiLCBidXQgSQo+ICAgIGhhdmUgbm90IHRlc3RlZCBpdC4KPiAKPiBO b3csIG9ubHkgdGhlIGkzODYgYXJjaGl0ZWN0dXJlIGlzIHN1cHBvcnRlZC4gVGhlIHBhdGNoIGlz IGJhc2VkIG9uCj4gTGludXgga2VybmVsIDIuNi4yMy1yYzMtbW0xLCBhbmQgaGFzIGJlZW4gdGVz dGVkIG9uIG15IElCTSBUNDIuCj4gCj4gCj4gVXNhZ2U6Cj4gCj4gMS4gQ29tcGlsZSBrZXJuZWwg d2l0aCBmb2xsb3dpbmcgb3B0aW9ucyBzZWxlY3RlZDoKPiAKPiBDT05GSUdfWDg2XzMyPXkKPiBD T05GSUdfUkVMT0NBVEFCTEU9eSAjIG5vdCBuZWVkZWQgc3RyaWN0bHksIGJ1dCBpdCBpcyBtb3Jl IGNvbnZlbmllbnQgd2l0aCBpdAo+IENPTkZJR19LRVhFQz15Cj4gQ09ORklHX0NSQVNIX0RVTVA9 eSAjIG9ubHkgbmVlZGVkIGJ5IGtleGVjZWQga2VybmVsIHRvIHNhdmUvcmVzdG9yZSBtZW1vcnkg aW1hZ2UKPiBDT05GSUdfUE09eQo+IENPTkZJR19LRVhFQ19KVU1QPXkKPiAKPiAyLiBEb3dubG9h ZCB0aGUga2V4ZWMtdG9vbHMtdGVzdGluZyBnaXQgdHJlZSwgYXBwbHkgdGhlIGtleGVjLXRvb2xz Cj4gICAga2p1bXAgcGF0Y2ggYW5kIGNvbXBpbGUuIFRoZSBrZXhlYy10b29scyBranVtcCBwYXRj aCBpcyBhcHBlbmRlZAo+ICAgIHdpdGggdGhlIG1haWwuIFRoZSBwcmVjb21waWxlZCBrZXhlYyBj YW4gYmUgZG93bmxvYWQgZnJvbToKPiAgICAgICAgaHR0cDovL2xpbnV4LW1jcjcwMC5zb3VyY2Vm b3JnZS5uZXQva2p1bXAva2V4ZWMKPiAKPiAzLiBEb3dubG9hZCBhbmQgY29tcGlsZSB0aGUga3Jl c3RvcmUgdG9vbC4gVGhlIHNvdXJjZSBjb2RlIGFuZAo+ICAgIHByZWNvbXBpbGVkIGJpbmFyeSBj YW4gYmUgZG93bmxvYWRlZCBmcm9tIHRoZSBmb2xsb3dpbmcgVVJMOgo+ICAgICAgICBzb3VyY2U6 IGh0dHA6Ly9saW51eC1tY3I3MDAuc291cmNlZm9yZ2UubmV0L2tqdW1wL2tyZXN0b3JlLnRhci5n ego+ICAgICAgICBiaW5hcnk6IGh0dHA6Ly9saW51eC1tY3I3MDAuc291cmNlZm9yZ2UubmV0L2tq dW1wL2tyZXN0b3JlCj4gCj4gNC4gUHJlcGFyZSAzIHJvb3QgcGFydGl0aW9uIHVzZWQgYnkga2Vy bmVsIEEsIGtlcm5lbCBCLCBrZXJuZWwgQywKPiAgICByZWZlcmVkIGFzIC9kZXYvaGRhLCAvZGV2 L2hkYiwgL2Rldi9oZGMgaW4gZm9sbG93aW5nIHRleHQuIFRoaXMgaXMKPiAgICBub3Qgc3RyaWN0 bHkgbmVjZXNzYXJ5LCBJIHVzZSB0aGlzIHNjaGVtZSBmb3IgdGVzdGluZyBkdXJpbmcKPiAgICBk ZXZlbG9wbWVudC4KPiAKPiA1LiBCb290IGtlcm5lbCBjb21waWxlZCBmb3Igbm9ybWFsIHVzYWdl IChrZXJuZWwgQSksIHRoZSByZXNlcnZlZAo+ICAgIGNyYXNoIGtlcm5lbCBtZW1vcnkgcmVnaW9u IG11c3QgYmUgYWRkZWQgdG8ga2VybmVsIGNvbW1hbmQgbGluZSBhcwo+ICAgIGZvbGxvdzoKPiAK PiAgICBjcmFzaGtlcm5lbD08WFg+TUA8WFg+TQo+IAo+ICAgIFdoZXJlLCA8WFg+IHNob3VsZCBi ZSByZXBsYWNlZCBieSB0aGUgcmVhbCBtZW1vcnkgc2l6ZSBhbmQKPiAgICBwb3NpdGlvbi4gSSB1 c2UgMTZNQDMyTSBpbiBteSB0ZXN0aW5nLgo+IAo+IDYuIExvYWQga2VybmVsIGNvbXBpbGVkIGZv ciBoaWJlcm5hdGluZyB1c2FnZSAoa2VybmVsIEIpIGFzIGEKPiAgICBjcmFzaGR1bXAga2VybmVs IHdpdGgga2V4ZWMsIHRoZSBzYW1lIGtlcm5lbCBhcyB0aGF0IG9mIDUgY2FuIGJlCj4gICAgdXNl ZCBpZiBDT05GSUdfUkVMT0NBVEFCTEU9eSBhbmQgQ09ORklHX0NSQVNIX0RVTVA9eSBhcmUKPiAg ICBzZWxlY3RlZC4gVGhlIGtlcm5lbCBjb21tYW5kIGxpbmUgb3B0aW9uIGFzIGZvbGxvdyBzaG91 bGQgYmUKPiAgICBhcHBlbmRlZCB0byBrZXJuZWwgY29tbWFuZCBsaW5lLgo+IAo+ICAgIGtleGVj X2p1bXBfYnVmX3Bmbj1gY2F0IC9zeXMva2VybmVsL2tleGVjX2p1bXBfYnVmX3BmbmAKPiAKPiAg ICBUaGUgLS1lbGY2NC1jb3JlLWhlYWRlcnMgc2hvdWxkIGJlIHNwZWNpZmllZCBpbiBjb21tYW5k IGxpbmUgb2YKPiAgICBrZXhlYywgYmVjYXVzZSBvbmx5IHRoZSA2NGJpdCBFTEYgaXMgc3VwcG9y dGVkIGJ5IGtyZXN0b3JlIHRvb2wuCj4gCj4gICAgRm9yIGV4YW1wbGUsIHRoZSBzaGVsbCBjb21t YW5kIGxpbmUgY2FuIGJlIGFzIGZvbGxvdzoKPiAKPiAgICBrZXhlYyAtcCAvYm9vdC9iekltYWdl IC0tZWxmNjQtY29yZS1oZWFkZXJzIC0tYXBwZW5kPSJyb290PS9kZXYvaGRiCj4gICAgICAgIHNp bmdsZSBrZXhlY19qdW1wX2J1Zl9wZm49YGNhdCAvc3lzL2tlcm5lbC9rZXhlY19qdW1wX2J1Zl9w Zm5gIgo+IAo+IDcuIEp1bXAgdG8gdGhlIGhpYmVybmF0aW5nIGtlcm5lbCAoa2VybmVsIEIpIHdp dGggZm9sbG93aW5nIHNoZWxsCj4gICAgY29tbWFuZCBsaW5lOgo+IAo+ICAgIGtleGVjIC1qCj4g Cj4gOC4gSW4gdGhlIGhpYmVybmF0aW5nIGtlcm5lbCAoa2VybmVsIEIpLCB0aGUgbWVtb3J5IGlt YWdlIG9mCj4gICAgaGliZXJuYXRlZCBrZXJuZWwgKGtlcm5lbCBBKSBjYW4gYmUgc2F2ZWQgYXMg Zm9sbG93Ogo+IAo+ICAgIGNwIC9wcm9jL3ZtY29yZSAuCj4gICAgY3AgL3N5cy9rZXJuZWwva2V4 ZWNfanVtcF9idWZfcGZuIC4KPiAKPiA5LiBTaHV0ZG93biBvciByZWJvb3QgaW4gaGliZXJuYXRp bmcga2VybmVsIChrZXJuZWwgQikuCj4gCj4gMTAuIEJvb3Qga2VybmVsIChrZXJuZWwgQykgY29t cGlsZWQgZm9yIG5vcm1hbCB1c2FnZSBpbiBhbm90aGVyIHJvb3QKPiAgICAgZmlsZSBzeXN0ZW0g KC9kZXYvaGRjKS4KPiAKPiAxMS4gTG9hZCByZXN0b3JlIGtlcm5lbCAoa2VybmVsIEQpIGluIGtl cm5lbCBDIHRocm91Z2gga2V4ZWMuIFRoaXMgaXMKPiAgICAgYWxtb3N0IHNhbWUgYXMgc3RlcCA2 LiBUaGUgcm9vdCBmaWxlIHN5c3RlbSBvZiBrZXJuZWwgRCBzaG91bGQgYmUKPiAgICAgL2Rldi9o ZGIuCj4gCj4gMTIuIEluIHJlc3RvcmUga2VybmVsIChrZXJuZWwgRCksIHRoZSBtZW1vcnkgaW1h Z2Ugb2Yga2VybmVsIEEgY2FuIGJlCj4gICAgIHJlc3RvcmVkIGFzIGZvbGxvdzoKPiAKPiAgICAg IyBnZXQgYmFja3VwIGFkZHJlc3MgdGhyb3VnaCBrZXJuZWwgY29tbWFuZCBsaW5lCj4gICAgIGJh Y2t1cF9hZGRyPWBjYXQgL3Byb2MvY21kbGluZSB8IHRyICcgJyAnwqVuJyB8IGdyZXAga2V4ZWNf YmFja3VwIHwgY3V0IC1kICc9JyAtZiAyYAo+ICAgICBjcCBrZXhlY19qdW1wX2J1Zl9wZm4gL3N5 cy9rZXJuZWwva2V4ZWNfanVtcF9idWZfcGZuCj4gICAgIGtyZXN0b3JlIC1iICRiYWNrdXBfYWRk ciB2bWNvcmUKPiAKPiAxMy4gSnVtcCBiYWNrIHRvIGhpYmVybmF0ZWQga2VybmVsIChrZXJuZWwg QSkKPiAKPiAgICAga2V4ZWMgLWIKPiAKPiAKPiAtLS0KPiAKPiBDaGFuZ2Vsb2cgb2Yga2V4ZWMt dG9vbHMKPiAKPiBBIGNvbW1hbmQgbGluZSBvcHRpb24gLWovLS1qdW1wLXRvIGlzIGFkZGVkIHRv IHN1cHBvcnQganVtcGluZwo+IHRvL2V4ZWN1dGluZyB0aGUgY3VycmVudGx5IGxvYWRlZCBrZXJu ZWwuIEEgY29tbWFuZCBsaW5lIG9wdGlvbgo+IC1iLy0tanVtcC1iYWNrIGlzIGFkZGVkIHRvIHN1 cHBvcnQganVtcGluZyBiYWNrIHRvIHRoZSBvcmlnaW5hbAo+IGtlcm5lbC4gVGhlIGltcGxlbWVu dGF0aW9uIG9mIG9wdGlvbnMgaXMgdG8gY2FsbCBjb3JyZXNwb25kaW5nCj4gc3lzY2FsbC4KPiAK PiBGb3IgaTM4NiBhcmNoaXRlY3R1cmUsIHRoZSBhZGRyZXNzIG9mIGJhY2t1cCBvZiAw4oC+NjQw ayBpcyBwYXNzZWQgdG8KPiBrZXhlY2VkIGtlcm5lbCBhcyBhIGtlcm5lbCBjb21tYW5kIGxpbmUg b3B0aW9uLiBUaGlzIGlzIHVzZWQgYnkKPiBrZXhlY2VkIGtlcm5lbCB0byByZXN0b3JlIHRoZSBi YWNrdXAuCj4gCj4gVGhpcyBwYXRjaCBpcyBhZ2FpbnN0IGtleGVjLXRvb2xzLXRlc3RpbmcgZ2l0 IHRyZWUuCj4gCj4gSW5kZXg6IGtleGVjLXRvb2xzL2tleGVjL2FyY2gvaTM4Ni9jcmFzaGR1bXAt eDg2LmMKPiA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09Cj4gLS0tIGtleGVjLXRvb2xzLm9yaWcva2V4ZWMvYXJjaC9pMzg2 L2NyYXNoZHVtcC14ODYuYwkyMDA3LTA4LTE3IDEzOjQ4OjUxLjAwMDAwMDAwMCArMDgwMAo+ICsr KyBrZXhlYy10b29scy9rZXhlYy9hcmNoL2kzODYvY3Jhc2hkdW1wLXg4Ni5jCTIwMDctMDgtMTcg MTM6NDk6NTAuMDAwMDAwMDAwICswODAwCj4gQEAgLTQyOCw2ICs0MjgsMjkgQEAKPiAgCXJldHVy biAwOwo+ICB9Cj4gIAo+ICsvKiBBZGRzIHRoZSBrZXhlY19iYWNrdXA9IGNvbW1hbmQgbGluZSBw YXJhbWV0ZXIgdG8gY29tbWFuZCBsaW5lLiAqLwo+ICtzdGF0aWMgaW50IGNtZGxpbmVfYWRkX2Jh Y2t1cChjaGFyICpjbWRsaW5lLCB1bnNpZ25lZCBsb25nIGFkZHIpCj4gK3sKPiArCWludCBjbWRs ZW4sIGxlbiwgYWxpZ24gPSAxMDI0Owo+ICsJY2hhciBzdHJbMzBdLCAqcHRyOwo+ICsKPiArCS8q IFBhc3NpbmcgaW4ga2V4ZWNfYmFja3VwPXh4eEsgZm9ybWF0LiBTYXZlcyBzcGFjZSByZXF1aXJl ZAo+ICsJICogaW4gY21kbGluZS4gRW5zdXJlIDFLIGFsaWdubWVudCovCj4gKwlpZiAoYWRkciVh bGlnbikKPiArCQlyZXR1cm4gLTE7Cj4gKwlhZGRyID0gYWRkci9hbGlnbjsKPiArCXB0ciA9IHN0 cjsKPiArCXN0cmNweShzdHIsICIga2V4ZWNfYmFja3VwPSIpOwo+ICsJcHRyICs9IHN0cmxlbihz dHIpOwo+ICsJdWx0b2EoYWRkciwgcHRyKTsKPiArCXN0cmNhdChzdHIsICJLIik7Cj4gKwlsZW4g PSBzdHJsZW4oc3RyKTsKPiArCWNtZGxlbiA9IHN0cmxlbihjbWRsaW5lKSArIGxlbjsKPiArCWlm IChjbWRsZW4gPiAoQ09NTUFORF9MSU5FX1NJWkUgLSAxKSkKPiArCQlkaWUoIkNvbW1hbmQgbGlu ZSBvdmVyZmxvd8KlbiIpOwo+ICsJc3RyY2F0KGNtZGxpbmUsIHN0cik7Cj4gKwlyZXR1cm4gMDsK PiArfQo+ICAKPiAgLyoKPiAgICogVGhpcyByb3V0aW5lIGlzIHNwZWNpZmljIHRvIGkzODYgYXJj aGl0ZWN0dXJlIHRvIG1haW50YWluIHRoZQo+IEBAIC01NzUsNiArNTk4LDcgQEAKPiAgCQlyZXR1 cm4gLTE7Cj4gIAljbWRsaW5lX2FkZF9tZW1tYXAobW9kX2NtZGxpbmUsIG1lbW1hcF9wKTsKPiAg CWNtZGxpbmVfYWRkX2VsZmNvcmVoZHIobW9kX2NtZGxpbmUsIGVsZmNvcmVoZHIpOwo+ICsJY21k bGluZV9hZGRfYmFja3VwKG1vZF9jbWRsaW5lLCBpbmZvLT5iYWNrdXBfc3RhcnQpOwo+ICAJcmV0 dXJuIDA7Cj4gIH0KPiAgCj4gSW5kZXg6IGtleGVjLXRvb2xzL2tleGVjL2tleGVjLXN5c2NhbGwu aAo+ID09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT0KPiAtLS0ga2V4ZWMtdG9vbHMub3JpZy9rZXhlYy9rZXhlYy1zeXNjYWxs LmgJMjAwNy0wOC0xNyAxMzo0ODo1MS4wMDAwMDAwMDAgKzA4MDAKPiArKysga2V4ZWMtdG9vbHMv a2V4ZWMva2V4ZWMtc3lzY2FsbC5oCTIwMDctMDgtMjQgMTM6NDQ6MjIuMDAwMDAwMDAwICswODAw Cj4gQEAgLTIxLDYgKzIxLDggQEAKPiAgI2RlZmluZSBMSU5VWF9SRUJPT1RfQ01EX0tFWEVDX09M RAkweDgxNzI2MzU0Cj4gICNkZWZpbmUgTElOVVhfUkVCT09UX0NNRF9LRVhFQ19PTEQyCTB4MTgy NjM2NDUKPiAgI2RlZmluZSBMSU5VWF9SRUJPT1RfQ01EX0tFWEVDCQkweDQ1NTg0NTQzCj4gKyNk ZWZpbmUgTElOVVhfUkVCT09UX0NNRF9LSlVNUF9UTwkweDM5MjhBNUZECj4gKyNkZWZpbmUgTElO VVhfUkVCT09UX0NNRF9LSlVNUF9CQUNLCTB4NEEzOUI2MEUKPiAgCj4gICNpZmRlZiBfX2kzODZf Xwo+ICAjZGVmaW5lIF9fTlJfa2V4ZWNfbG9hZAkJMjgzCj4gQEAgLTYzLDYgKzY1LDE1IEBACj4g IAlyZXR1cm4gKGxvbmcpIHN5c2NhbGwoX19OUl9yZWJvb3QsIExJTlVYX1JFQk9PVF9NQUdJQzEs IExJTlVYX1JFQk9PVF9NQUdJQzIsIExJTlVYX1JFQk9PVF9DTURfS0VYRUMsIDApOwo+ICB9Cj4g IAo+ICtzdGF0aWMgaW5saW5lIGxvbmcga2V4ZWNfanVtcF90byh2b2lkKQo+ICt7Cj4gKwlyZXR1 cm4gKGxvbmcpIHN5c2NhbGwoX19OUl9yZWJvb3QsIExJTlVYX1JFQk9PVF9NQUdJQzEsIExJTlVY X1JFQk9PVF9NQUdJQzIsIExJTlVYX1JFQk9PVF9DTURfS0pVTVBfVE8sIDApOwo+ICt9Cj4gKwo+ ICtzdGF0aWMgaW5saW5lIGxvbmcga2V4ZWNfanVtcF9iYWNrKHZvaWQpCj4gK3sKPiArCXJldHVy biAobG9uZykgc3lzY2FsbChfX05SX3JlYm9vdCwgTElOVVhfUkVCT09UX01BR0lDMSwgTElOVVhf UkVCT09UX01BR0lDMiwgTElOVVhfUkVCT09UX0NNRF9LSlVNUF9CQUNLLCAwKTsKPiArfQo+ICAK PiAgI2RlZmluZSBLRVhFQ19PTl9DUkFTSCAgMHgwMDAwMDAwMQo+ICAjZGVmaW5lIEtFWEVDX0FS Q0hfTUFTSyAweGZmZmYwMDAwCj4gSW5kZXg6IGtleGVjLXRvb2xzL2tleGVjL2tleGVjLmMKPiA9 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09Cj4gLS0tIGtleGVjLXRvb2xzLm9yaWcva2V4ZWMva2V4ZWMuYwkyMDA3LTA4LTE3 IDEzOjQ4OjUxLjAwMDAwMDAwMCArMDgwMAo+ICsrKyBrZXhlYy10b29scy9rZXhlYy9rZXhlYy5j CTIwMDctMDgtMjQgMTM6NTM6NDMuMDAwMDAwMDAwICswODAwCj4gQEAgLTcxNiw2ICs3MTYsMzMg QEAKPiAgCXJldHVybiAtMTsKPiAgfQo+ICAKPiArLyoKPiArICoJSnVtcCB0byB0aGUgbmV3IGtl cm5lbAo+ICsgKi8KPiArc3RhdGljIGludCBteV9qdW1wX3RvKHZvaWQpCj4gK3sKPiArCWludCBy ZXN1bHQ7Cj4gKwo+ICsJcmVzdWx0ID0ga2V4ZWNfanVtcF90bygpOwo+ICsJaWYgKHJlc3VsdCkK PiArCQlmcHJpbnRmKHN0ZGVyciwgImtleGVjIGp1bXAgdG8gZmFpbGVkOiAlc8KlbiIsCj4gKwkJ CXN0cmVycm9yKGVycm5vKSk7Cj4gKwlyZXR1cm4gcmVzdWx0Owo+ICt9Cj4gKwo+ICsvKgo+ICsg KglKdW1wIGJhY2sgdG8gdGhlIG9yaWdpbmFsIGtlcm5lbAo+ICsgKi8KPiArc3RhdGljIGludCBt eV9qdW1wX2JhY2sodm9pZCkKPiArewo+ICsJaW50IHJlc3VsdDsKPiArCj4gKwlyZXN1bHQgPSBr ZXhlY19qdW1wX2JhY2soKTsKPiArCWZwcmludGYoc3RkZXJyLCAia2V4ZWMganVtcCBiYWNrIGZh aWxlZDogJXPCpW4iLAo+ICsJCXN0cmVycm9yKGVycm5vKSk7Cj4gKwlyZXR1cm4gLTE7Cj4gK30K PiArCj4gIHN0YXRpYyB2b2lkIHZlcnNpb24odm9pZCkKPiAgewo+ICAJcHJpbnRmKFBBQ0tBR0Ug IiAiIFZFUlNJT04gIiByZWxlYXNlZCAiIFJFTEVBU0VfREFURSAiwqVuIik7Cj4gQEAgLTc0Myw2 ICs3NzAsOCBAQAo+ICAJICAgICAgICIgICAgICAgICAgICAgICAgICAgICAgSWYgY2FwdHVyZSBr ZXJuZWwgaXMgYmVpbmcgdW5sb2FkZWTCpW4iCj4gIAkgICAgICAgIiAgICAgICAgICAgICAgICAg ICAgICBzcGVjaWZ5IC1wIHdpdGggLXUuwqVuIgo+ICAJICAgICAgICIgLWUsIC0tZXhlYyAgICAg ICAgICAgRXhlY3V0ZSBhIGN1cnJlbnRseSBsb2FkZWQga2VybmVsLsKlbiIKPiArIAkgICAgICAg IiAtaiwgLS1qdW1wLXRvICAgICAgICBKdW1wIHRvIGEgY3VycmVudGx5IGxvYWRlZCBrZXJuZWwu wqVuIgo+ICsJICAgICAgICIgLWIsIC0tanVtcC1iYWNrICAgICAgSnVtcCBiYWNrIHRvIHRoZSBv cmlnaW5hbCBrZXJuZWwuwqVuIgo+ICAJICAgICAgICIgLXQsIC0tdHlwZT1UWVBFICAgICAgU3Bl Y2lmeSB0aGUgbmV3IGtlcm5lbCBpcyBvZiB0aGlzIHR5cGUuwqVuIgo+ICAJICAgICAgICIgICAg IC0tbWVtLW1pbj08YWRkcj4gU3BlY2lmeSB0aGUgbG93ZXN0IG1lbW9yeSBhZGRyZXNzIHRvwqVu Igo+ICAJICAgICAgICIgICAgICAgICAgICAgICAgICAgICAgbG9hZCBjb2RlIGludG8uwqVuIgo+ IEBAIC03NzMsNiArODAyLDE5IEBACj4gIAlyZXR1cm4gcmV0Owo+ICB9Cj4gIAo+ICtzdGF0aWMg aW50IGtleGVjX2NyYXNoX2xvYWRlZCh2b2lkKQo+ICt7Cj4gKwlpbnQgcmV0Owo+ICsJRklMRSAq ZnA7Cj4gKwo+ICsJZnAgPSBmb3BlbigiL3N5cy9rZXJuZWwva2V4ZWNfY3Jhc2hfbG9hZGVkIiwg InIiKTsKPiArCWlmIChmcCA9PSBOVUxMKQo+ICsJCXJldHVybiAtMTsKPiArCWZzY2FuZihmcCwg IiVkIiwgJnJldCk7Cj4gKwlmY2xvc2UoZnApOwo+ICsJcmV0dXJuIHJldDsKPiArfQo+ICsKPiAg LyogY2hlY2sgd2UgcmV0YWluZWQgdGhlIGluaXRyZCAqLwo+ICB2b2lkIGNoZWNrX3JldXNlX2lu aXRyZCh2b2lkKQo+ICB7Cj4gQEAgLTgwMyw2ICs4NDUsOCBAQAo+ICB7Cj4gIAlpbnQgZG9fbG9h ZCA9IDE7Cj4gIAlpbnQgZG9fZXhlYyA9IDA7Cj4gKwlpbnQgZG9fanVtcF90byA9IDA7Cj4gKwlp bnQgZG9fanVtcF9iYWNrID0gMDsKPiAgCWludCBkb19zaHV0ZG93biA9IDE7Cj4gIAlpbnQgZG9f c3luYyA9IDE7Cj4gIAlpbnQgZG9faWZkb3duID0gMDsKPiBAQCAtODU4LDYgKzkwMiwyMiBAQAo+ ICAJCQlkb19pZmRvd24gPSAxOwo+ICAJCQlkb19leGVjID0gMTsKPiAgCQkJYnJlYWs7Cj4gKwkJ Y2FzZSBPUFRfSlVNUF9UTzoKPiArCQkJZG9fbG9hZCA9IDA7Cj4gKwkJCWRvX3NodXRkb3duID0g MDsKPiArCQkJZG9fc3luYyA9IDE7Cj4gKwkJCWRvX2lmZG93biA9IDA7Cj4gKwkJCWRvX2V4ZWMg PSAwOwo+ICsJCQlkb19qdW1wX3RvID0gMTsKPiArCQkJYnJlYWs7Cj4gKwkJY2FzZSBPUFRfSlVN UF9CQUNLOgo+ICsJCQlkb19sb2FkID0gMDsKPiArCQkJZG9fc2h1dGRvd24gPSAwOwo+ICsJCQlk b19zeW5jID0gMTsKPiArCQkJZG9faWZkb3duID0gMTsKPiArCQkJZG9fZXhlYyA9IDA7Cj4gKwkJ CWRvX2p1bXBfYmFjayA9IDE7Cj4gKwkJCWJyZWFrOwo+ICAJCWNhc2UgT1BUX1RZUEU6Cj4gIAkJ CXR5cGUgPSBvcHRhcmc7Cj4gIAkJCWJyZWFrOwo+IEBAIC05MzYsNiArOTk2LDkgQEAKPiAgCWlm ICgocmVzdWx0ID09IDApICYmIChkb19zaHV0ZG93biB8fCBkb19leGVjKSAmJiAha2V4ZWNfbG9h ZGVkKCkpIHsKPiAgCQlkaWUoIk5vdGhpbmcgaGFzIGJlZW4gbG9hZGVkIcKlbiIpOwo+ICAJfQo+ ICsJaWYgKChyZXN1bHQgPT0gMCkgJiYgZG9fanVtcF90byAmJiAha2V4ZWNfY3Jhc2hfbG9hZGVk KCkpIHsKPiArCQlkaWUoIk5vdGhpbmcgaGFzIGJlZW4gbG9hZGVkIcKlbiIpOwo+ICsJfQo+ICAJ aWYgKChyZXN1bHQgPT0gMCkgJiYgZG9fc2h1dGRvd24pIHsKPiAgCQlyZXN1bHQgPSBteV9zaHV0 ZG93bigpOwo+ICAJfQo+IEBAIC05NDksNiArMTAxMiwxMiBAQAo+ICAJaWYgKChyZXN1bHQgPT0g MCkgJiYgZG9fZXhlYykgewo+ICAJCXJlc3VsdCA9IG15X2V4ZWMoKTsKPiAgCX0KPiArCWlmICgo cmVzdWx0ID09IDApICYmIGRvX2p1bXBfdG8pIHsKPiArCQlyZXN1bHQgPSBteV9qdW1wX3RvKCk7 Cj4gKwl9Cj4gKwlpZiAoKHJlc3VsdCA9PSAwKSAmJiBkb19qdW1wX2JhY2spIHsKPiArCQlyZXN1 bHQgPSBteV9qdW1wX2JhY2soKTsKPiArCX0KPiAgCj4gIAlmZmx1c2goc3Rkb3V0KTsKPiAgCWZm bHVzaChzdGRlcnIpOwo+IEluZGV4OiBrZXhlYy10b29scy9rZXhlYy9rZXhlYy5oCj4gPT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PQo+IC0tLSBrZXhlYy10b29scy5vcmlnL2tleGVjL2tleGVjLmgJMjAwNy0wOC0xNyAxMzo0 ODo1MS4wMDAwMDAwMDAgKzA4MDAKPiArKysga2V4ZWMtdG9vbHMva2V4ZWMva2V4ZWMuaAkyMDA3 LTA4LTI0IDExOjE1OjI3LjAwMDAwMDAwMCArMDgwMAo+IEBAIC0xNTYsNiArMTU2LDggQEAKPiAg I2RlZmluZSBPUFRfRk9SQ0UJCSdmJwo+ICAjZGVmaW5lIE9QVF9OT0lGRE9XTgkJJ3gnCj4gICNk ZWZpbmUgT1BUX0VYRUMJCSdlJwo+ICsjZGVmaW5lIE9QVF9KVU1QX1RPCQknaicKPiArI2RlZmlu ZSBPUFRfSlVNUF9CQUNLCQknYicKPiAgI2RlZmluZSBPUFRfTE9BRAkJJ2wnCj4gICNkZWZpbmUg T1BUX1VOTE9BRAkJJ3UnCj4gICNkZWZpbmUgT1BUX1RZUEUJCSd0Jwo+IEBAIC0xNzIsMTMgKzE3 NCwxNSBAQAo+ICAJeyAibG9hZCIsCQkwLCAwLCBPUFRfTE9BRCB9LCDCpQo+ICAJeyAidW5sb2Fk IiwJCTAsIDAsIE9QVF9VTkxPQUQgfSwgwqUKPiAgCXsgImV4ZWMiLAkJMCwgMCwgT1BUX0VYRUMg fSwgwqUKPiArIAl7ICJqdW1wLXRvIiwJCTAsIDAsIE9QVF9KVU1QX1RPIH0sIMKlCj4gKyAJeyAi anVtcC1iYWNrIiwJCTAsIDAsIE9QVF9KVU1QX0JBQ0sgfSwgwqUKPiAgCXsgInR5cGUiLAkJMSwg MCwgT1BUX1RZUEUgfSwgwqUKPiAgCXsgImxvYWQtcGFuaWMiLCAgICAgICAgIDAsIDAsIE9QVF9Q QU5JQyB9LCDCpQo+ICAJeyAibWVtLW1pbiIsCQkxLCAwLCBPUFRfTUVNX01JTiB9LCDCpQo+ICAJ eyAibWVtLW1heCIsCQkxLCAwLCBPUFRfTUVNX01BWCB9LCDCpQo+ICAJeyAicmV1c2Vpbml0cmQi LAkwLCAwLCBPUFRfUkVVU0VfSU5JVFJEIH0sIMKlCj4gIAo+IC0jZGVmaW5lIEtFWEVDX09QVF9T VFIgImh2ZGZ4bHVldDpwIgo+ICsjZGVmaW5lIEtFWEVDX09QVF9TVFIgImh2ZGZ4bHVlamJ0OnAi Cj4gIAo+ICBleHRlcm4gdm9pZCBkaWUoY2hhciAqZm10LCAuLi4pOwo+ICBleHRlcm4gdm9pZCAq eG1hbGxvYyhzaXplX3Qgc2l6ZSk7Cj4gX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KPiBsaW51eC1wbSBtYWlsaW5nIGxpc3QKPiBsaW51eC1wbUBsaXN0cy5s aW51eC1mb3VuZGF0aW9uLm9yZwo+IGh0dHBzOi8vbGlzdHMubGludXgtZm91bmRhdGlvbi5vcmcv bWFpbG1hbi9saXN0aW5mby9saW51eC1wbQoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX18Ka2V4ZWMgbWFpbGluZyBsaXN0CmtleGVjQGxpc3RzLmluZnJhZGVh ZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9rZXhlYwo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755402AbXH0CP5 (ORCPT ); Sun, 26 Aug 2007 22:15:57 -0400 Received: (majordomo@vger.kernel.org) by vger.kernel.org id S1750949AbXH0CPs (ORCPT ); Sun, 26 Aug 2007 22:15:48 -0400 Received: from mga02.intel.com ([134.134.136.20]:38727 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750908AbXH0CPr convert rfc822-to-8bit (ORCPT ); Sun, 26 Aug 2007 22:15:47 -0400 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="4.19,309,1183359600"; d="scan'208";a="284124509" Subject: RE: [linux-pm] [RFC][PATCH 0/2 -mm] kexec based hibernation From: "Huang, Ying" To: "Hu, Fenghua" Cc: "Eric W. Biederman" , Pavel Machek , nigel@nigel.suspend2.net, Andrew Morton , Jeremy Maitin-Shepard , Alan Stern , linux-pm@lists.linux-foundation.org, Kexec Mailing List , linux-kernel@vger.kernel.org In-Reply-To: <9D7649D18729DE4BB2BD7B494F7FEDC257EA60@pdsmsx415.ccr.corp.intel.com> References: <9D7649D18729DE4BB2BD7B494F7FEDC257EA60@pdsmsx415.ccr.corp.intel.com> Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: 8BIT Date: Mon, 27 Aug 2007 10:16:37 +0800 Message-Id: <1188180997.3247.68.camel@caritas-dev.intel.com> Mime-Version: 1.0 X-Mailer: Evolution 2.10.2 X-OriginalArrivalTime: 27 Aug 2007 02:15:41.0859 (UTC) FILETIME=[2AED9730:01C7E850] Sender: linux-kernel-owner@vger.kernel.org X-Mailing-List: linux-kernel@vger.kernel.org On Mon, 2007-08-27 at 09:28 +0800, Hu, Fenghua wrote: > One quick question is, can it improve hiberation/wakeup time? In general, for kexec based hibernation, what increases hibernation/wakeup time: - One extra Linux boot is needed to hibernate and wakeup. What decreases hibernation/wakeup time: - Most hibernation/wakeup work is done in full functional user space program, so it is possible to do some optimization, such as parallel compression. So, I think the kexec based hibernation may be slower than original implementation in general. In this prototype implementation, the hibernation/wakeup time is much longer than original hibernation/wakeup implementation. But it has much to be optimized and I think it can approach the speed of the original implementation after optimization. For example, the hibernation image is an ordinary ELF file, so it can be loaded by bootloader directly. Best Regards, Huang Ying > Best regards > Hu, Fenghua > > > -----Original Message----- > From: linux-pm-bounces@lists.linux-foundation.org [mailto:linux-pm-bounces@lists.linux-foundation.org] On Behalf Of Huang, Ying > Sent: 2007年8月27日 9:14 > To: Eric W. Biederman; Pavel Machek; nigel@nigel.suspend2.net; Andrew Morton; Jeremy Maitin-Shepard; Alan Stern > Cc: linux-pm@lists.linux-foundation.org; Kexec Mailing List; linux-kernel@vger.kernel.org > Subject: [linux-pm] [RFC][PATCH 0/2 -mm] kexec based hibernation > > Kexec base hibernation has some potential advantages over uswsusp and > TuxOnIce (suspend2). Some most obvious advantages are: > > 1. The hibernation image size can exceed half of memory size easily. > > 2. The hibernation image can be written to and read from almost > anywhere, such as USB disk, NFS. > > 3. It is possible to eliminate freezer from kexec based hibernation > implementation. > > 4. Based on kexec/kdump implementation, the kernel code needed is > less. > > > This patch set implements a prototype of kexec based hibernation. The > kernel functionalities added are as follow: > > 1. Jumping from kexeced kernel back to original kernel. This is used > by hibernation to save/load necessary state in original kernel and > jumping back to original kernel after restore the memory of > original kernel. > > 2. Add writing support to /dev/oldmem. This is used by hibernation to > restore the memory of original kernel. > > > The hibernation process with the patch set is as follow: > > 1. Boot a kernel A > > 2. Work under kernel A > > 3. Kexec another kernel B (crash dump enabled) in kernel A. > > 4. Save the memory image of kernel A through crash dump (such as "cp > /proc/vmcore ‾"). Save the "jump buffer pfn". > > 5. Shutdown or reboot > > > The restore process with the patch set is as follow: > > 1. Boot a kernel C > > 2. Kexec another kernel D (crash dump enabled) in kernel C. The memory > area used by kernel D must be a subset of memory area used by > kernel B. > > 3. Restore the memory image of kernel A through /dev/oldmem. Restore > the "jump buffer pfn". > > 4. Jump from kernel D back to kernel A > > 5. Continue work under kernel A > > > The following user-space tools are needed to implement hibernation and > restore. > > 1. kexec-tools needs to be patched to support kexec jump. The patch is > attached in this mail. The precompiled kexec can be download from: > http://linux-mcr700.sourceforge.net/kjump/kexec > > 2. Memory image saving tool. Currently, the memory image saving is > done through: "cp /proc/vmcore ". This will save all > memory pages of original kernel including the free pages. Maybe the > crash dump tool "makedumpfile" can be used for this, but it has not > been tested. > > 3. Memory image restore tool. A simplest memory image restoring tool > named "krestore" is implemented. It can be downloaded from > following URL: > source: http://linux-mcr700.sourceforge.net/kjump/krestore.tar.gz > binary: http://linux-mcr700.sourceforge.net/kjump/krestore > > > Known issues: > > 1. The kernel B run as a crashdump kernel in reserved memory > region. This is the biggest constrains of the patch set and planed > to be eliminated in the future version. That is, instead of > reserving memory region previously, the needed memory region is > backupped before kexec and restored after jumping back. > > 2. Another constrains of the patch set is that the CONFIG_ACPI must be > turned off to make kexec jump work. Because ACPI will put devices > into low power state, the kexeced kernel can not be booted properly > under it. This constrains can be eliminated by separating the > suspend method and hibernate method of the devices as proposed > earlier in the LKML. > > 3. The setup of hibernation/restore is fairly complex. I will continue > working on simplifying. > > 4. Memory pages including free pages of kernel A are saved. I think > the "makedumpfile" tool can be used to exclude "free pages", but I > have not tested it. > > Now, only the i386 architecture is supported. The patch is based on > Linux kernel 2.6.23-rc3-mm1, and has been tested on my IBM T42. > > > Usage: > > 1. Compile kernel with following options selected: > > CONFIG_X86_32=y > CONFIG_RELOCATABLE=y # not needed strictly, but it is more convenient with it > CONFIG_KEXEC=y > CONFIG_CRASH_DUMP=y # only needed by kexeced kernel to save/restore memory image > CONFIG_PM=y > CONFIG_KEXEC_JUMP=y > > 2. Download the kexec-tools-testing git tree, apply the kexec-tools > kjump patch and compile. The kexec-tools kjump patch is appended > with the mail. The precompiled kexec can be download from: > http://linux-mcr700.sourceforge.net/kjump/kexec > > 3. Download and compile the krestore tool. The source code and > precompiled binary can be downloaded from the following URL: > source: http://linux-mcr700.sourceforge.net/kjump/krestore.tar.gz > binary: http://linux-mcr700.sourceforge.net/kjump/krestore > > 4. Prepare 3 root partition used by kernel A, kernel B, kernel C, > refered as /dev/hda, /dev/hdb, /dev/hdc in following text. This is > not strictly necessary, I use this scheme for testing during > development. > > 5. Boot kernel compiled for normal usage (kernel A), the reserved > crash kernel memory region must be added to kernel command line as > follow: > > crashkernel=M@M > > Where, should be replaced by the real memory size and > position. I use 16M@32M in my testing. > > 6. Load kernel compiled for hibernating usage (kernel B) as a > crashdump kernel with kexec, the same kernel as that of 5 can be > used if CONFIG_RELOCATABLE=y and CONFIG_CRASH_DUMP=y are > selected. The kernel command line option as follow should be > appended to kernel command line. > > kexec_jump_buf_pfn=`cat /sys/kernel/kexec_jump_buf_pfn` > > The --elf64-core-headers should be specified in command line of > kexec, because only the 64bit ELF is supported by krestore tool. > > For example, the shell command line can be as follow: > > kexec -p /boot/bzImage --elf64-core-headers --append="root=/dev/hdb > single kexec_jump_buf_pfn=`cat /sys/kernel/kexec_jump_buf_pfn`" > > 7. Jump to the hibernating kernel (kernel B) with following shell > command line: > > kexec -j > > 8. In the hibernating kernel (kernel B), the memory image of > hibernated kernel (kernel A) can be saved as follow: > > cp /proc/vmcore . > cp /sys/kernel/kexec_jump_buf_pfn . > > 9. Shutdown or reboot in hibernating kernel (kernel B). > > 10. Boot kernel (kernel C) compiled for normal usage in another root > file system (/dev/hdc). > > 11. Load restore kernel (kernel D) in kernel C through kexec. This is > almost same as step 6. The root file system of kernel D should be > /dev/hdb. > > 12. In restore kernel (kernel D), the memory image of kernel A can be > restored as follow: > > # get backup address through kernel command line > backup_addr=`cat /proc/cmdline | tr ' ' '¥n' | grep kexec_backup | cut -d '=' -f 2` > cp kexec_jump_buf_pfn /sys/kernel/kexec_jump_buf_pfn > krestore -b $backup_addr vmcore > > 13. Jump back to hibernated kernel (kernel A) > > kexec -b > > > --- > > Changelog of kexec-tools > > A command line option -j/--jump-to is added to support jumping > to/executing the currently loaded kernel. A command line option > -b/--jump-back is added to support jumping back to the original > kernel. The implementation of options is to call corresponding > syscall. > > For i386 architecture, the address of backup of 0‾640k is passed to > kexeced kernel as a kernel command line option. This is used by > kexeced kernel to restore the backup. > > This patch is against kexec-tools-testing git tree. > > Index: kexec-tools/kexec/arch/i386/crashdump-x86.c > =================================================================== > --- kexec-tools.orig/kexec/arch/i386/crashdump-x86.c 2007-08-17 13:48:51.000000000 +0800 > +++ kexec-tools/kexec/arch/i386/crashdump-x86.c 2007-08-17 13:49:50.000000000 +0800 > @@ -428,6 +428,29 @@ > return 0; > } > > +/* Adds the kexec_backup= command line parameter to command line. */ > +static int cmdline_add_backup(char *cmdline, unsigned long addr) > +{ > + int cmdlen, len, align = 1024; > + char str[30], *ptr; > + > + /* Passing in kexec_backup=xxxK format. Saves space required > + * in cmdline. Ensure 1K alignment*/ > + if (addr%align) > + return -1; > + addr = addr/align; > + ptr = str; > + strcpy(str, " kexec_backup="); > + ptr += strlen(str); > + ultoa(addr, ptr); > + strcat(str, "K"); > + len = strlen(str); > + cmdlen = strlen(cmdline) + len; > + if (cmdlen > (COMMAND_LINE_SIZE - 1)) > + die("Command line overflow¥n"); > + strcat(cmdline, str); > + return 0; > +} > > /* > * This routine is specific to i386 architecture to maintain the > @@ -575,6 +598,7 @@ > return -1; > cmdline_add_memmap(mod_cmdline, memmap_p); > cmdline_add_elfcorehdr(mod_cmdline, elfcorehdr); > + cmdline_add_backup(mod_cmdline, info->backup_start); > return 0; > } > > Index: kexec-tools/kexec/kexec-syscall.h > =================================================================== > --- kexec-tools.orig/kexec/kexec-syscall.h 2007-08-17 13:48:51.000000000 +0800 > +++ kexec-tools/kexec/kexec-syscall.h 2007-08-24 13:44:22.000000000 +0800 > @@ -21,6 +21,8 @@ > #define LINUX_REBOOT_CMD_KEXEC_OLD 0x81726354 > #define LINUX_REBOOT_CMD_KEXEC_OLD2 0x18263645 > #define LINUX_REBOOT_CMD_KEXEC 0x45584543 > +#define LINUX_REBOOT_CMD_KJUMP_TO 0x3928A5FD > +#define LINUX_REBOOT_CMD_KJUMP_BACK 0x4A39B60E > > #ifdef __i386__ > #define __NR_kexec_load 283 > @@ -63,6 +65,15 @@ > return (long) syscall(__NR_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_KEXEC, 0); > } > > +static inline long kexec_jump_to(void) > +{ > + return (long) syscall(__NR_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_KJUMP_TO, 0); > +} > + > +static inline long kexec_jump_back(void) > +{ > + return (long) syscall(__NR_reboot, LINUX_REBOOT_MAGIC1, LINUX_REBOOT_MAGIC2, LINUX_REBOOT_CMD_KJUMP_BACK, 0); > +} > > #define KEXEC_ON_CRASH 0x00000001 > #define KEXEC_ARCH_MASK 0xffff0000 > Index: kexec-tools/kexec/kexec.c > =================================================================== > --- kexec-tools.orig/kexec/kexec.c 2007-08-17 13:48:51.000000000 +0800 > +++ kexec-tools/kexec/kexec.c 2007-08-24 13:53:43.000000000 +0800 > @@ -716,6 +716,33 @@ > return -1; > } > > +/* > + * Jump to the new kernel > + */ > +static int my_jump_to(void) > +{ > + int result; > + > + result = kexec_jump_to(); > + if (result) > + fprintf(stderr, "kexec jump to failed: %s¥n", > + strerror(errno)); > + return result; > +} > + > +/* > + * Jump back to the original kernel > + */ > +static int my_jump_back(void) > +{ > + int result; > + > + result = kexec_jump_back(); > + fprintf(stderr, "kexec jump back failed: %s¥n", > + strerror(errno)); > + return -1; > +} > + > static void version(void) > { > printf(PACKAGE " " VERSION " released " RELEASE_DATE "¥n"); > @@ -743,6 +770,8 @@ > " If capture kernel is being unloaded¥n" > " specify -p with -u.¥n" > " -e, --exec Execute a currently loaded kernel.¥n" > + " -j, --jump-to Jump to a currently loaded kernel.¥n" > + " -b, --jump-back Jump back to the original kernel.¥n" > " -t, --type=TYPE Specify the new kernel is of this type.¥n" > " --mem-min= Specify the lowest memory address to¥n" > " load code into.¥n" > @@ -773,6 +802,19 @@ > return ret; > } > > +static int kexec_crash_loaded(void) > +{ > + int ret; > + FILE *fp; > + > + fp = fopen("/sys/kernel/kexec_crash_loaded", "r"); > + if (fp == NULL) > + return -1; > + fscanf(fp, "%d", &ret); > + fclose(fp); > + return ret; > +} > + > /* check we retained the initrd */ > void check_reuse_initrd(void) > { > @@ -803,6 +845,8 @@ > { > int do_load = 1; > int do_exec = 0; > + int do_jump_to = 0; > + int do_jump_back = 0; > int do_shutdown = 1; > int do_sync = 1; > int do_ifdown = 0; > @@ -858,6 +902,22 @@ > do_ifdown = 1; > do_exec = 1; > break; > + case OPT_JUMP_TO: > + do_load = 0; > + do_shutdown = 0; > + do_sync = 1; > + do_ifdown = 0; > + do_exec = 0; > + do_jump_to = 1; > + break; > + case OPT_JUMP_BACK: > + do_load = 0; > + do_shutdown = 0; > + do_sync = 1; > + do_ifdown = 1; > + do_exec = 0; > + do_jump_back = 1; > + break; > case OPT_TYPE: > type = optarg; > break; > @@ -936,6 +996,9 @@ > if ((result == 0) && (do_shutdown || do_exec) && !kexec_loaded()) { > die("Nothing has been loaded!¥n"); > } > + if ((result == 0) && do_jump_to && !kexec_crash_loaded()) { > + die("Nothing has been loaded!¥n"); > + } > if ((result == 0) && do_shutdown) { > result = my_shutdown(); > } > @@ -949,6 +1012,12 @@ > if ((result == 0) && do_exec) { > result = my_exec(); > } > + if ((result == 0) && do_jump_to) { > + result = my_jump_to(); > + } > + if ((result == 0) && do_jump_back) { > + result = my_jump_back(); > + } > > fflush(stdout); > fflush(stderr); > Index: kexec-tools/kexec/kexec.h > =================================================================== > --- kexec-tools.orig/kexec/kexec.h 2007-08-17 13:48:51.000000000 +0800 > +++ kexec-tools/kexec/kexec.h 2007-08-24 11:15:27.000000000 +0800 > @@ -156,6 +156,8 @@ > #define OPT_FORCE 'f' > #define OPT_NOIFDOWN 'x' > #define OPT_EXEC 'e' > +#define OPT_JUMP_TO 'j' > +#define OPT_JUMP_BACK 'b' > #define OPT_LOAD 'l' > #define OPT_UNLOAD 'u' > #define OPT_TYPE 't' > @@ -172,13 +174,15 @@ > { "load", 0, 0, OPT_LOAD }, ¥ > { "unload", 0, 0, OPT_UNLOAD }, ¥ > { "exec", 0, 0, OPT_EXEC }, ¥ > + { "jump-to", 0, 0, OPT_JUMP_TO }, ¥ > + { "jump-back", 0, 0, OPT_JUMP_BACK }, ¥ > { "type", 1, 0, OPT_TYPE }, ¥ > { "load-panic", 0, 0, OPT_PANIC }, ¥ > { "mem-min", 1, 0, OPT_MEM_MIN }, ¥ > { "mem-max", 1, 0, OPT_MEM_MAX }, ¥ > { "reuseinitrd", 0, 0, OPT_REUSE_INITRD }, ¥ > > -#define KEXEC_OPT_STR "hvdfxluet:p" > +#define KEXEC_OPT_STR "hvdfxluejbt:p" > > extern void die(char *fmt, ...); > extern void *xmalloc(size_t size); > _______________________________________________ > linux-pm mailing list > linux-pm@lists.linux-foundation.org > https://lists.linux-foundation.org/mailman/listinfo/linux-pm