From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1755019Ab3CEIir (ORCPT ); Tue, 5 Mar 2013 03:38:47 -0500 Received: from cn.fujitsu.com ([222.73.24.84]:12055 "EHLO song.cn.fujitsu.com" rhost-flags-OK-FAIL-OK-OK) by vger.kernel.org with ESMTP id S1753608Ab3CEIiq convert rfc822-to-8bit (ORCPT ); Tue, 5 Mar 2013 03:38:46 -0500 X-IronPort-AV: E=Sophos;i="4.84,786,1355068800"; d="scan'208";a="6816089" Message-ID: <5135AEA5.7000605@cn.fujitsu.com> Date: Tue, 05 Mar 2013 16:36:53 +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 02/20] vmcore: rearrange program headers without assuming consequtive PT_NOTE entries References: <20130302083447.31252.93914.stgit@localhost6.localdomain6> <20130302083559.31252.60341.stgit@localhost6.localdomain6> In-Reply-To: <20130302083559.31252.60341.stgit@localhost6.localdomain6> X-MIMETrack: Itemize by SMTP Server on mailserver/fnst(Release 8.5.3|September 15, 2011) at 2013/03/05 16:37:42, Serialize by Router on mailserver/fnst(Release 8.5.3|September 15, 2011) at 2013/03/05 16:37:43 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:35, HATAYAMA Daisuke 写道: > Current code assumes all PT_NOTE headers are placed at the beginning > of program header table and they are consequtive. But the assumption > could be broken by future changes on either kexec-tools or the 1st > kernel. This patch removes the assumption and rearranges program > headers as the following conditions are satisfied: > > - PT_NOTE entry is unique at the first entry, > > - the order of program headers are unchanged during this > rearrangement, only their positions are changed in positive > direction. > > - unused part that occurs in the bottom of program headers are filled > with 0. > > Also, this patch adds one exceptional case where the number of PT_NOTE > entries is somehow 0. Then, immediately go out of the function. > > Signed-off-by: HATAYAMA Daisuke > --- > > fs/proc/vmcore.c | 92 +++++++++++++++++++++++++++++++++++++++++++----------- > 1 files changed, 74 insertions(+), 18 deletions(-) > > diff --git a/fs/proc/vmcore.c b/fs/proc/vmcore.c > index abf4f01..b5c9e33 100644 > --- a/fs/proc/vmcore.c > +++ b/fs/proc/vmcore.c > @@ -251,8 +251,7 @@ static u64 __init get_vmcore_size_elf32(char *elfptr) > static int __init merge_note_headers_elf64(char *elfptr, size_t *elfsz, > struct list_head *vc_list) > { > - int i, nr_ptnote=0, rc=0; > - char *tmp; > + int i, j, nr_ptnote=0, i_ptnote, rc=0; After applying the patch, there are two "j" defined. 251 static int __init merge_note_headers_elf64(char *elfptr, size_t *elfsz, 252 struct list_head *vc_list) 253 { 254 int i, j, nr_ptnote=0, i_ptnote, rc=0; 255 Elf64_Ehdr *ehdr_ptr; 256 Elf64_Phdr phdr, *phdr_ptr; 257 Elf64_Nhdr *nhdr_ptr; 258 u64 phdr_sz = 0, note_off; 259 260 ehdr_ptr = (Elf64_Ehdr *)elfptr; 261 phdr_ptr = (Elf64_Phdr*)(elfptr + ehdr_ptr->e_phoff); 262 for (i = 0; i < ehdr_ptr->e_phnum; i++, phdr_ptr++) { 263 int j; 264 void *notes_section; 265 struct vmcore *new; line 254 and 263. > Elf64_Ehdr *ehdr_ptr; > Elf64_Phdr phdr, *phdr_ptr; > Elf64_Nhdr *nhdr_ptr; > @@ -302,6 +301,39 @@ static int __init merge_note_headers_elf64(char *elfptr, size_t *elfsz, > kfree(notes_section); > } > > + if (nr_ptnote == 0) > + goto out; > + > + phdr_ptr = (Elf64_Phdr *)(elfptr + ehdr_ptr->e_phoff); > + > + /* Remove unwanted PT_NOTE program headers. */ > + > + /* - 1st pass shifts non-PT_NOTE entries until the first > + PT_NOTE entry. */ > + i_ptnote = -1; > + for (i = 0; i < ehdr_ptr->e_phnum; ++i) { > + if (phdr_ptr[i].p_type == PT_NOTE) { > + i_ptnote = i; > + break; > + } > + } > + BUG_ON(i_ptnote == -1); /* impossible case since nr_ptnote > 0. */ > + memmove(phdr_ptr + 1, phdr_ptr, i_ptnote * sizeof(Elf64_Phdr)); is there any problem with this move? What is the batch bytes for every loop of memmove? if i_ptnode == 2, so we have ------------------------------------- | PT_LOAD 1 | PT_LOAD 2 | PT_NOTE 1 | ------------------------------------- --> ------------------------------------- | | PT_LOAD 1 | PT_LOAD 2 | ------------------------------------- right? In the move, Does PT_LOAD 1 overwrite the original PT_LOAD 2? > + > + /* - 2nd pass moves the remaining non-PT_NOTE entries under > + the first PT_NOTE entry. */ > + for (i = j = i_ptnote + 1; i < ehdr_ptr->e_phnum; i++) { > + if (phdr_ptr[i].p_type != PT_NOTE) { > + memmove(phdr_ptr + j, phdr_ptr + i, > + sizeof(Elf64_Phdr)); > + j++; > + } > + } > + > + /* - Finally, fill unused part with 0. */ > + memset(phdr_ptr + ehdr_ptr->e_phnum - (nr_ptnote - 1), 0, > + (nr_ptnote - 1) * sizeof(Elf64_Phdr)); > + > /* Prepare merged PT_NOTE program header. */ > phdr.p_type = PT_NOTE; > phdr.p_flags = 0; > @@ -313,18 +345,14 @@ static int __init merge_note_headers_elf64(char *elfptr, size_t *elfsz, > phdr.p_align = 0; > > /* Add merged PT_NOTE program header*/ > - tmp = elfptr + ehdr_ptr->e_phoff; > - memcpy(tmp, &phdr, sizeof(phdr)); > - tmp += sizeof(phdr); > + memcpy(phdr_ptr, &phdr, sizeof(Elf64_Phdr)); > > - /* Remove unwanted PT_NOTE program headers. */ > - i = (nr_ptnote - 1) * sizeof(Elf64_Phdr); > - *elfsz = *elfsz - i; > - memmove(tmp, tmp+i, ((*elfsz)-ehdr_ptr->e_phoff-sizeof(Elf64_Phdr))); > + *elfsz = *elfsz - (nr_ptnote - 1) * sizeof(Elf64_Phdr); > > /* Modify e_phnum to reflect merged headers. */ > ehdr_ptr->e_phnum = ehdr_ptr->e_phnum - nr_ptnote + 1; > > +out: > return 0; > } > > @@ -332,8 +360,7 @@ static int __init merge_note_headers_elf64(char *elfptr, size_t *elfsz, > static int __init merge_note_headers_elf32(char *elfptr, size_t *elfsz, > struct list_head *vc_list) > { > - int i, nr_ptnote=0, rc=0; > - char *tmp; > + int i, j, nr_ptnote=0, i_ptnote, rc=0; > Elf32_Ehdr *ehdr_ptr; > Elf32_Phdr phdr, *phdr_ptr; > Elf32_Nhdr *nhdr_ptr; > @@ -383,6 +410,39 @@ static int __init merge_note_headers_elf32(char *elfptr, size_t *elfsz, > kfree(notes_section); > } > > + if (nr_ptnote == 0) > + goto out; > + > + phdr_ptr = (Elf32_Phdr *)(elfptr + ehdr_ptr->e_phoff); > + > + /* Remove unwanted PT_NOTE program headers. */ > + > + /* - 1st pass shifts non-PT_NOTE entries until the first > + PT_NOTE entry. */ > + i_ptnote = -1; > + for (i = 0; i < ehdr_ptr->e_phnum; ++i) { > + if (phdr_ptr[i].p_type == PT_NOTE) { > + i_ptnote = i; > + break; > + } > + } > + BUG_ON(i_ptnote == -1); /* impossible case since nr_ptnote > 0. */ > + memmove(phdr_ptr + 1, phdr_ptr, i_ptnote * sizeof(Elf32_Phdr)); > + > + /* - 2nd pass moves the remaining non-PT_NOTE entries under > + the first PT_NOTE entry. */ > + for (i = j = i_ptnote + 1; i < ehdr_ptr->e_phnum; i++) { > + if (phdr_ptr[i].p_type != PT_NOTE) { > + memmove(phdr_ptr + j, phdr_ptr + i, > + sizeof(Elf32_Phdr)); > + j++; > + } > + } > + > + /* - Finally, fill unused part with 0. */ > + memset(phdr_ptr + ehdr_ptr->e_phnum - (nr_ptnote - 1), 0, > + (nr_ptnote - 1) * sizeof(Elf32_Phdr)); > + > /* Prepare merged PT_NOTE program header. */ > phdr.p_type = PT_NOTE; > phdr.p_flags = 0; > @@ -394,18 +454,14 @@ static int __init merge_note_headers_elf32(char *elfptr, size_t *elfsz, > phdr.p_align = 0; > > /* Add merged PT_NOTE program header*/ > - tmp = elfptr + ehdr_ptr->e_phoff; > - memcpy(tmp, &phdr, sizeof(phdr)); > - tmp += sizeof(phdr); > + memcpy(phdr_ptr, &phdr, sizeof(Elf32_Phdr)); > > - /* Remove unwanted PT_NOTE program headers. */ > - i = (nr_ptnote - 1) * sizeof(Elf32_Phdr); > - *elfsz = *elfsz - i; > - memmove(tmp, tmp+i, ((*elfsz)-ehdr_ptr->e_phoff-sizeof(Elf32_Phdr))); > + *elfsz = *elfsz - (nr_ptnote - 1) * sizeof(Elf32_Phdr); > > /* Modify e_phnum to reflect merged headers. */ > ehdr_ptr->e_phnum = ehdr_ptr->e_phnum - nr_ptnote + 1; > > +out: > return 0; > } > > > > _______________________________________________ > kexec mailing list > kexec@lists.infradead.org > http://lists.infradead.org/mailman/listinfo/kexec > 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 1UCnOe-0006q5-Ek for kexec@lists.infradead.org; Tue, 05 Mar 2013 08:38:54 +0000 Message-ID: <5135AEA5.7000605@cn.fujitsu.com> Date: Tue, 05 Mar 2013 16:36:53 +0800 From: Zhang Yanfei MIME-Version: 1.0 Subject: Re: [PATCH v2 02/20] vmcore: rearrange program headers without assuming consequtive PT_NOTE entries References: <20130302083447.31252.93914.stgit@localhost6.localdomain6> <20130302083559.31252.60341.stgit@localhost6.localdomain6> In-Reply-To: <20130302083559.31252.60341.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+aciDAy5pelIDE2OjM1LCBIQVRBWUFNQSBEYWlzdWtlIOWGmemBkzoKPiBD dXJyZW50IGNvZGUgYXNzdW1lcyBhbGwgUFRfTk9URSBoZWFkZXJzIGFyZSBwbGFjZWQgYXQgdGhl IGJlZ2lubmluZwo+IG9mIHByb2dyYW0gaGVhZGVyIHRhYmxlIGFuZCB0aGV5IGFyZSBjb25zZXF1 dGl2ZS4gQnV0IHRoZSBhc3N1bXB0aW9uCj4gY291bGQgYmUgYnJva2VuIGJ5IGZ1dHVyZSBjaGFu Z2VzIG9uIGVpdGhlciBrZXhlYy10b29scyBvciB0aGUgMXN0Cj4ga2VybmVsLiBUaGlzIHBhdGNo IHJlbW92ZXMgdGhlIGFzc3VtcHRpb24gYW5kIHJlYXJyYW5nZXMgcHJvZ3JhbQo+IGhlYWRlcnMg YXMgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZSBzYXRpc2ZpZWQ6Cj4gCj4gLSBQVF9OT1RF IGVudHJ5IGlzIHVuaXF1ZSBhdCB0aGUgZmlyc3QgZW50cnksCj4gCj4gLSB0aGUgb3JkZXIgb2Yg cHJvZ3JhbSBoZWFkZXJzIGFyZSB1bmNoYW5nZWQgZHVyaW5nIHRoaXMKPiAgIHJlYXJyYW5nZW1l bnQsIG9ubHkgdGhlaXIgcG9zaXRpb25zIGFyZSBjaGFuZ2VkIGluIHBvc2l0aXZlCj4gICBkaXJl Y3Rpb24uCj4gCj4gLSB1bnVzZWQgcGFydCB0aGF0IG9jY3VycyBpbiB0aGUgYm90dG9tIG9mIHBy b2dyYW0gaGVhZGVycyBhcmUgZmlsbGVkCj4gICB3aXRoIDAuCj4gCj4gQWxzbywgdGhpcyBwYXRj aCBhZGRzIG9uZSBleGNlcHRpb25hbCBjYXNlIHdoZXJlIHRoZSBudW1iZXIgb2YgUFRfTk9URQo+ IGVudHJpZXMgaXMgc29tZWhvdyAwLiBUaGVuLCBpbW1lZGlhdGVseSBnbyBvdXQgb2YgdGhlIGZ1 bmN0aW9uLgo+IAo+IFNpZ25lZC1vZmYtYnk6IEhBVEFZQU1BIERhaXN1a2UgPGQuaGF0YXlhbWFA anAuZnVqaXRzdS5jb20+Cj4gLS0tCj4gCj4gIGZzL3Byb2Mvdm1jb3JlLmMgfCAgIDkyICsrKysr KysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKystLS0tLS0tLS0tLQo+ICAxIGZp bGVzIGNoYW5nZWQsIDc0IGluc2VydGlvbnMoKyksIDE4IGRlbGV0aW9ucygtKQo+IAo+IGRpZmYg LS1naXQgYS9mcy9wcm9jL3ZtY29yZS5jIGIvZnMvcHJvYy92bWNvcmUuYwo+IGluZGV4IGFiZjRm MDEuLmI1YzllMzMgMTAwNjQ0Cj4gLS0tIGEvZnMvcHJvYy92bWNvcmUuYwo+ICsrKyBiL2ZzL3By b2Mvdm1jb3JlLmMKPiBAQCAtMjUxLDggKzI1MSw3IEBAIHN0YXRpYyB1NjQgX19pbml0IGdldF92 bWNvcmVfc2l6ZV9lbGYzMihjaGFyICplbGZwdHIpCj4gIHN0YXRpYyBpbnQgX19pbml0IG1lcmdl X25vdGVfaGVhZGVyc19lbGY2NChjaGFyICplbGZwdHIsIHNpemVfdCAqZWxmc3osCj4gIAkJCQkJ CXN0cnVjdCBsaXN0X2hlYWQgKnZjX2xpc3QpCj4gIHsKPiAtCWludCBpLCBucl9wdG5vdGU9MCwg cmM9MDsKPiAtCWNoYXIgKnRtcDsKPiArCWludCBpLCBqLCBucl9wdG5vdGU9MCwgaV9wdG5vdGUs IHJjPTA7CgpBZnRlciBhcHBseWluZyB0aGUgcGF0Y2gsIHRoZXJlIGFyZSB0d28gImoiIGRlZmlu ZWQuCgoyNTEgc3RhdGljIGludCBfX2luaXQgbWVyZ2Vfbm90ZV9oZWFkZXJzX2VsZjY0KGNoYXIg KmVsZnB0ciwgc2l6ZV90ICplbGZzeiwKMjUyICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIHN0cnVjdCBsaXN0X2hlYWQgKnZjX2xpc3QpCjI1MyB7CjI1NCAg ICAgICAgIGludCBpLCBqLCBucl9wdG5vdGU9MCwgaV9wdG5vdGUsIHJjPTA7CjI1NSAgICAgICAg IEVsZjY0X0VoZHIgKmVoZHJfcHRyOwoyNTYgICAgICAgICBFbGY2NF9QaGRyIHBoZHIsICpwaGRy X3B0cjsKMjU3ICAgICAgICAgRWxmNjRfTmhkciAqbmhkcl9wdHI7CjI1OCAgICAgICAgIHU2NCBw aGRyX3N6ID0gMCwgbm90ZV9vZmY7CjI1OSAKMjYwICAgICAgICAgZWhkcl9wdHIgPSAoRWxmNjRf RWhkciAqKWVsZnB0cjsKMjYxICAgICAgICAgcGhkcl9wdHIgPSAoRWxmNjRfUGhkciopKGVsZnB0 ciArIGVoZHJfcHRyLT5lX3Bob2ZmKTsKMjYyICAgICAgICAgZm9yIChpID0gMDsgaSA8IGVoZHJf cHRyLT5lX3BobnVtOyBpKyssIHBoZHJfcHRyKyspIHsKMjYzICAgICAgICAgICAgICAgICBpbnQg ajsKMjY0ICAgICAgICAgICAgICAgICB2b2lkICpub3Rlc19zZWN0aW9uOwoyNjUgICAgICAgICAg ICAgICAgIHN0cnVjdCB2bWNvcmUgKm5ldzsKCgpsaW5lIDI1NCBhbmQgMjYzLgoKCj4gIAlFbGY2 NF9FaGRyICplaGRyX3B0cjsKPiAgCUVsZjY0X1BoZHIgcGhkciwgKnBoZHJfcHRyOwo+ICAJRWxm NjRfTmhkciAqbmhkcl9wdHI7Cj4gQEAgLTMwMiw2ICszMDEsMzkgQEAgc3RhdGljIGludCBfX2lu aXQgbWVyZ2Vfbm90ZV9oZWFkZXJzX2VsZjY0KGNoYXIgKmVsZnB0ciwgc2l6ZV90ICplbGZzeiwK PiAgCQlrZnJlZShub3Rlc19zZWN0aW9uKTsKPiAgCX0KPiAgCj4gKwlpZiAobnJfcHRub3RlID09 IDApCj4gKwkJZ290byBvdXQ7Cj4gKwo+ICsJcGhkcl9wdHIgPSAoRWxmNjRfUGhkciAqKShlbGZw dHIgKyBlaGRyX3B0ci0+ZV9waG9mZik7Cj4gKwo+ICsJLyogUmVtb3ZlIHVud2FudGVkIFBUX05P VEUgcHJvZ3JhbSBoZWFkZXJzLiAqLwo+ICsKPiArICAgICAgICAvKiAtIDFzdCBwYXNzIHNoaWZ0 cyBub24tUFRfTk9URSBlbnRyaWVzIHVudGlsIHRoZSBmaXJzdAo+ICsJICAgICBQVF9OT1RFIGVu dHJ5LiAqLwo+ICsJaV9wdG5vdGUgPSAtMTsKPiArCWZvciAoaSA9IDA7IGkgPCBlaGRyX3B0ci0+ ZV9waG51bTsgKytpKSB7Cj4gKwkJaWYgKHBoZHJfcHRyW2ldLnBfdHlwZSA9PSBQVF9OT1RFKSB7 Cj4gKwkJCWlfcHRub3RlID0gaTsKPiArCQkJYnJlYWs7Cj4gKwkJfQo+ICsJfQo+ICsJQlVHX09O KGlfcHRub3RlID09IC0xKTsgLyogaW1wb3NzaWJsZSBjYXNlIHNpbmNlIG5yX3B0bm90ZSA+IDAu ICovCj4gKwltZW1tb3ZlKHBoZHJfcHRyICsgMSwgcGhkcl9wdHIsCWlfcHRub3RlICogc2l6ZW9m KEVsZjY0X1BoZHIpKTsKCmlzIHRoZXJlIGFueSBwcm9ibGVtIHdpdGggdGhpcyBtb3ZlPyBXaGF0 IGlzIHRoZSBiYXRjaCBieXRlcyBmb3IgZXZlcnkgbG9vcApvZiBtZW1tb3ZlPyAKCmlmIGlfcHRu b2RlID09IDIsIHNvIHdlIGhhdmUKCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0KfCBQVF9MT0FEIDEgfCBQVF9MT0FEIDIgfCBQVF9OT1RFIDEgfAotLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tCgotLT4KCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0KfCAgICAgICAgICAgfCBQVF9MT0FEIDEgfCBQVF9MT0FEIDIgfAotLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCgpyaWdodD8gSW4gdGhlIG1vdmUsIERvZXMgUFRf TE9BRCAxIG92ZXJ3cml0ZSB0aGUgb3JpZ2luYWwgUFRfTE9BRCAyPwoKPiArCj4gKwkvKiAtIDJu ZCBwYXNzIG1vdmVzIHRoZSByZW1haW5pbmcgbm9uLVBUX05PVEUgZW50cmllcyB1bmRlcgo+ICsJ ICAgICB0aGUgZmlyc3QgUFRfTk9URSBlbnRyeS4gKi8KPiArCWZvciAoaSA9IGogPSBpX3B0bm90 ZSArIDE7IGkgPCBlaGRyX3B0ci0+ZV9waG51bTsgaSsrKSB7Cj4gKwkJaWYgKHBoZHJfcHRyW2ld LnBfdHlwZSAhPSBQVF9OT1RFKSB7Cj4gKwkJCW1lbW1vdmUocGhkcl9wdHIgKyBqLCBwaGRyX3B0 ciArIGksCj4gKwkJCQlzaXplb2YoRWxmNjRfUGhkcikpOwo+ICsJCQlqKys7Cj4gKwkJfQo+ICsJ fQo+ICsKPiArCS8qIC0gRmluYWxseSwgZmlsbCB1bnVzZWQgcGFydCB3aXRoIDAuICovCj4gKwlt ZW1zZXQocGhkcl9wdHIgKyBlaGRyX3B0ci0+ZV9waG51bSAtIChucl9wdG5vdGUgLSAxKSwgMCwK PiArCSAgICAgICAobnJfcHRub3RlIC0gMSkgKiBzaXplb2YoRWxmNjRfUGhkcikpOwo+ICsKPiAg CS8qIFByZXBhcmUgbWVyZ2VkIFBUX05PVEUgcHJvZ3JhbSBoZWFkZXIuICovCj4gIAlwaGRyLnBf dHlwZSAgICA9IFBUX05PVEU7Cj4gIAlwaGRyLnBfZmxhZ3MgICA9IDA7Cj4gQEAgLTMxMywxOCAr MzQ1LDE0IEBAIHN0YXRpYyBpbnQgX19pbml0IG1lcmdlX25vdGVfaGVhZGVyc19lbGY2NChjaGFy ICplbGZwdHIsIHNpemVfdCAqZWxmc3osCj4gIAlwaGRyLnBfYWxpZ24gICA9IDA7Cj4gIAo+ICAJ LyogQWRkIG1lcmdlZCBQVF9OT1RFIHByb2dyYW0gaGVhZGVyKi8KPiAtCXRtcCA9IGVsZnB0ciAr IGVoZHJfcHRyLT5lX3Bob2ZmOwo+IC0JbWVtY3B5KHRtcCwgJnBoZHIsIHNpemVvZihwaGRyKSk7 Cj4gLQl0bXAgKz0gc2l6ZW9mKHBoZHIpOwo+ICsJbWVtY3B5KHBoZHJfcHRyLCAmcGhkciwgc2l6 ZW9mKEVsZjY0X1BoZHIpKTsKPiAgCj4gLQkvKiBSZW1vdmUgdW53YW50ZWQgUFRfTk9URSBwcm9n cmFtIGhlYWRlcnMuICovCj4gLQlpID0gKG5yX3B0bm90ZSAtIDEpICogc2l6ZW9mKEVsZjY0X1Bo ZHIpOwo+IC0JKmVsZnN6ID0gKmVsZnN6IC0gaTsKPiAtCW1lbW1vdmUodG1wLCB0bXAraSwgKCgq ZWxmc3opLWVoZHJfcHRyLT5lX3Bob2ZmLXNpemVvZihFbGY2NF9QaGRyKSkpOwo+ICsJKmVsZnN6 ID0gKmVsZnN6IC0gKG5yX3B0bm90ZSAtIDEpICogc2l6ZW9mKEVsZjY0X1BoZHIpOwo+ICAKPiAg CS8qIE1vZGlmeSBlX3BobnVtIHRvIHJlZmxlY3QgbWVyZ2VkIGhlYWRlcnMuICovCj4gIAllaGRy X3B0ci0+ZV9waG51bSA9IGVoZHJfcHRyLT5lX3BobnVtIC0gbnJfcHRub3RlICsgMTsKPiAgCj4g K291dDoKPiAgCXJldHVybiAwOwo+ICB9Cj4gIAo+IEBAIC0zMzIsOCArMzYwLDcgQEAgc3RhdGlj IGludCBfX2luaXQgbWVyZ2Vfbm90ZV9oZWFkZXJzX2VsZjY0KGNoYXIgKmVsZnB0ciwgc2l6ZV90 ICplbGZzeiwKPiAgc3RhdGljIGludCBfX2luaXQgbWVyZ2Vfbm90ZV9oZWFkZXJzX2VsZjMyKGNo YXIgKmVsZnB0ciwgc2l6ZV90ICplbGZzeiwKPiAgCQkJCQkJc3RydWN0IGxpc3RfaGVhZCAqdmNf bGlzdCkKPiAgewo+IC0JaW50IGksIG5yX3B0bm90ZT0wLCByYz0wOwo+IC0JY2hhciAqdG1wOwo+ ICsJaW50IGksIGosIG5yX3B0bm90ZT0wLCBpX3B0bm90ZSwgcmM9MDsKPiAgCUVsZjMyX0VoZHIg KmVoZHJfcHRyOwo+ICAJRWxmMzJfUGhkciBwaGRyLCAqcGhkcl9wdHI7Cj4gIAlFbGYzMl9OaGRy ICpuaGRyX3B0cjsKPiBAQCAtMzgzLDYgKzQxMCwzOSBAQCBzdGF0aWMgaW50IF9faW5pdCBtZXJn ZV9ub3RlX2hlYWRlcnNfZWxmMzIoY2hhciAqZWxmcHRyLCBzaXplX3QgKmVsZnN6LAo+ICAJCWtm cmVlKG5vdGVzX3NlY3Rpb24pOwo+ICAJfQo+ICAKPiArCWlmIChucl9wdG5vdGUgPT0gMCkKPiAr CQlnb3RvIG91dDsKPiArCj4gKwlwaGRyX3B0ciA9IChFbGYzMl9QaGRyICopKGVsZnB0ciArIGVo ZHJfcHRyLT5lX3Bob2ZmKTsKPiArCj4gKwkvKiBSZW1vdmUgdW53YW50ZWQgUFRfTk9URSBwcm9n cmFtIGhlYWRlcnMuICovCj4gKwo+ICsJLyogLSAxc3QgcGFzcyBzaGlmdHMgbm9uLVBUX05PVEUg ZW50cmllcyB1bnRpbCB0aGUgZmlyc3QKPiArCSAgICAgUFRfTk9URSBlbnRyeS4gKi8KPiArCWlf cHRub3RlID0gLTE7Cj4gKwlmb3IgKGkgPSAwOyBpIDwgZWhkcl9wdHItPmVfcGhudW07ICsraSkg ewo+ICsJCWlmIChwaGRyX3B0cltpXS5wX3R5cGUgPT0gUFRfTk9URSkgewo+ICsJCQlpX3B0bm90 ZSA9IGk7Cj4gKwkJCWJyZWFrOwo+ICsJCX0KPiArCX0KPiArCUJVR19PTihpX3B0bm90ZSA9PSAt MSk7IC8qIGltcG9zc2libGUgY2FzZSBzaW5jZSBucl9wdG5vdGUgPiAwLiAqLwo+ICsJbWVtbW92 ZShwaGRyX3B0ciArIDEsIHBoZHJfcHRyLCBpX3B0bm90ZSAqIHNpemVvZihFbGYzMl9QaGRyKSk7 Cj4gKwo+ICsJLyogLSAybmQgcGFzcyBtb3ZlcyB0aGUgcmVtYWluaW5nIG5vbi1QVF9OT1RFIGVu dHJpZXMgdW5kZXIKPiArCSAgICAgdGhlIGZpcnN0IFBUX05PVEUgZW50cnkuICovCj4gKwlmb3Ig KGkgPSBqID0gaV9wdG5vdGUgKyAxOyBpIDwgZWhkcl9wdHItPmVfcGhudW07IGkrKykgewo+ICsJ CWlmIChwaGRyX3B0cltpXS5wX3R5cGUgIT0gUFRfTk9URSkgewo+ICsJCQltZW1tb3ZlKHBoZHJf cHRyICsgaiwgcGhkcl9wdHIgKyBpLAo+ICsJCQkJc2l6ZW9mKEVsZjMyX1BoZHIpKTsKPiArCQkJ aisrOwo+ICsJCX0KPiArCX0KPiArCj4gKwkvKiAtIEZpbmFsbHksIGZpbGwgdW51c2VkIHBhcnQg d2l0aCAwLiAqLwo+ICsJbWVtc2V0KHBoZHJfcHRyICsgZWhkcl9wdHItPmVfcGhudW0gLSAobnJf cHRub3RlIC0gMSksIDAsCj4gKwkgICAgICAgKG5yX3B0bm90ZSAtIDEpICogc2l6ZW9mKEVsZjMy X1BoZHIpKTsKPiArCj4gIAkvKiBQcmVwYXJlIG1lcmdlZCBQVF9OT1RFIHByb2dyYW0gaGVhZGVy LiAqLwo+ICAJcGhkci5wX3R5cGUgICAgPSBQVF9OT1RFOwo+ICAJcGhkci5wX2ZsYWdzICAgPSAw Owo+IEBAIC0zOTQsMTggKzQ1NCwxNCBAQCBzdGF0aWMgaW50IF9faW5pdCBtZXJnZV9ub3RlX2hl YWRlcnNfZWxmMzIoY2hhciAqZWxmcHRyLCBzaXplX3QgKmVsZnN6LAo+ICAJcGhkci5wX2FsaWdu ICAgPSAwOwo+ICAKPiAgCS8qIEFkZCBtZXJnZWQgUFRfTk9URSBwcm9ncmFtIGhlYWRlciovCj4g LQl0bXAgPSBlbGZwdHIgKyBlaGRyX3B0ci0+ZV9waG9mZjsKPiAtCW1lbWNweSh0bXAsICZwaGRy LCBzaXplb2YocGhkcikpOwo+IC0JdG1wICs9IHNpemVvZihwaGRyKTsKPiArCW1lbWNweShwaGRy X3B0ciwgJnBoZHIsIHNpemVvZihFbGYzMl9QaGRyKSk7Cj4gIAo+IC0JLyogUmVtb3ZlIHVud2Fu dGVkIFBUX05PVEUgcHJvZ3JhbSBoZWFkZXJzLiAqLwo+IC0JaSA9IChucl9wdG5vdGUgLSAxKSAq IHNpemVvZihFbGYzMl9QaGRyKTsKPiAtCSplbGZzeiA9ICplbGZzeiAtIGk7Cj4gLQltZW1tb3Zl KHRtcCwgdG1wK2ksICgoKmVsZnN6KS1laGRyX3B0ci0+ZV9waG9mZi1zaXplb2YoRWxmMzJfUGhk cikpKTsKPiArCSplbGZzeiA9ICplbGZzeiAtIChucl9wdG5vdGUgLSAxKSAqIHNpemVvZihFbGYz Ml9QaGRyKTsKPiAgCj4gIAkvKiBNb2RpZnkgZV9waG51bSB0byByZWZsZWN0IG1lcmdlZCBoZWFk ZXJzLiAqLwo+ICAJZWhkcl9wdHItPmVfcGhudW0gPSBlaGRyX3B0ci0+ZV9waG51bSAtIG5yX3B0 bm90ZSArIDE7Cj4gIAo+ICtvdXQ6Cj4gIAlyZXR1cm4gMDsKPiAgfQo+ICAKPiAKPiAKPiBfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwo+IGtleGVjIG1haWxp bmcgbGlzdAo+IGtleGVjQGxpc3RzLmluZnJhZGVhZC5vcmcKPiBodHRwOi8vbGlzdHMuaW5mcmFk ZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2tleGVjCj4gCgoKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18Ka2V4ZWMgbWFpbGluZyBsaXN0CmtleGVjQGxpc3Rz LmluZnJhZGVhZC5vcmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5m by9rZXhlYwo=