From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Date: Thu, 6 Feb 2020 09:37:53 +0100 (CET) From: =?utf-8?Q?Cl=C3=A9ment?= Leger Message-ID: <1065812225.2604892.1580978273748.JavaMail.zimbra@kalray.eu> In-Reply-To: <20200205224936.GB25901@xps15> References: <20200129163013.GA16538@xps15> <20200204174412.16814-1-cleger@kalray.eu> <20200204174412.16814-3-cleger@kalray.eu> <20200205224936.GB25901@xps15> Subject: Re: [PATCH v3 2/2] remoteproc: Add elf64 support in elf loader MIME-Version: 1.0 Content-Type: text/plain; charset=utf-8 Content-Transfer-Encoding: quoted-printable To: Mathieu Poirier Cc: Ohad Ben-Cohen , Bjorn Andersson , Jonathan Corbet , Shawn Guo , Sascha Hauer , linux-remoteproc , Pengutronix Kernel Team , Fabio Estevam , NXP Linux Team , Andy Gross , Patrice Chotard , linux-doc , linux-kernel , linux-arm-kernel , linux-arm-msm , Arnaud Pouliquen , Loic PALLARDY , s-anna List-ID: Hi Mathieu, ----- On 5 Feb, 2020, at 23:49, Mathieu Poirier mathieu.poirier@linaro.org = wrote: > On Tue, Feb 04, 2020 at 06:44:12PM +0100, Clement Leger wrote: >> elf32 and elf64 mainly differ by their types. In order to avoid >> copy/pasting the whole loader code, generate static inline functions >> which will access values according to the elf class. It allows to keep a >> common loader basis. >> In order to accommodate both elf types sizes, the maximum size for a >> elf header member is chosen using the maximum value of both elf class. >>=20 >> Signed-off-by: Clement Leger >> Tested-by: Arnaud POULIQUEN >> --- >> Documentation/remoteproc.txt | 2 +- >> drivers/remoteproc/remoteproc_elf_loader.c | 147 ++++++++++++++++++----= ------- >> drivers/remoteproc/remoteproc_elf_loader.h | 69 ++++++++++++++ >> drivers/remoteproc/remoteproc_internal.h | 2 +- >> drivers/remoteproc/st_remoteproc.c | 2 +- >> include/linux/remoteproc.h | 4 +- >> 6 files changed, 167 insertions(+), 59 deletions(-) >> create mode 100644 drivers/remoteproc/remoteproc_elf_loader.h >>=20 >> diff --git a/Documentation/remoteproc.txt b/Documentation/remoteproc.txt >> index 03c3d2e568b0..2be1147256e0 100644 >> --- a/Documentation/remoteproc.txt >> +++ b/Documentation/remoteproc.txt >> @@ -230,7 +230,7 @@ in the used rings. >> Binary Firmware Structure >> =3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D=3D= =3D=3D >> =20 >> -At this point remoteproc only supports ELF32 firmware binaries. However= , >> +At this point remoteproc supports ELF32 and ELF64 firmware binaries. Ho= wever, >> it is quite expected that other platforms/devices which we'd want to >> support with this framework will be based on different binary formats. >> =20 >> diff --git a/drivers/remoteproc/remoteproc_elf_loader.c >> b/drivers/remoteproc/remoteproc_elf_loader.c >> index 606aae166eba..21fd2b2fe5ae 100644 >> --- a/drivers/remoteproc/remoteproc_elf_loader.c >> +++ b/drivers/remoteproc/remoteproc_elf_loader.c >> @@ -23,6 +23,7 @@ >> #include >> =20 >> #include "remoteproc_internal.h" >> +#include "remoteproc_elf_loader.h" >> =20 >> /** >> * rproc_elf_sanity_check() - Sanity Check ELF firmware image >> @@ -35,8 +36,16 @@ int rproc_elf_sanity_check(struct rproc *rproc, const= struct >> firmware *fw) >> { >> =09const char *name =3D rproc->firmware; >> =09struct device *dev =3D &rproc->dev; >> +=09/* >> +=09 * Elf files are beginning with the same structure. Thus, to simplif= y >> +=09 * header parsing, we can use the elf32_hdr one for both elf64 and >> +=09 * elf32. >> +=09 */ >> =09struct elf32_hdr *ehdr; >> +=09u32 elf_shdr_size; >> +=09u64 phoff, shoff; >> =09char class; >> +=09u16 phnum; >> =20 >> =09if (!fw) { >> =09=09dev_err(dev, "failed to load %s\n", name); >> @@ -50,13 +59,22 @@ int rproc_elf_sanity_check(struct rproc *rproc, cons= t struct >> firmware *fw) >> =20 >> =09ehdr =3D (struct elf32_hdr *)fw->data; >> =20 >> -=09/* We only support ELF32 at this point */ >> +=09if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG)) { >> +=09=09dev_err(dev, "Image is corrupted (bad magic)\n"); >> +=09=09return -EINVAL; >> +=09} >> + >> =09class =3D ehdr->e_ident[EI_CLASS]; >> -=09if (class !=3D ELFCLASS32) { >> +=09if (class !=3D ELFCLASS32 && class !=3D ELFCLASS64) { >> =09=09dev_err(dev, "Unsupported class: %d\n", class); >> =09=09return -EINVAL; >> =09} >> =20 >> +=09if (class =3D=3D ELFCLASS64 && fw->size < sizeof(struct elf64_hdr)) = { >> +=09=09dev_err(dev, "elf64 header is too small\n"); >> +=09=09return -EINVAL; >> +=09} >> + >> =09/* We assume the firmware has the same endianness as the host */ >> # ifdef __LITTLE_ENDIAN >> =09if (ehdr->e_ident[EI_DATA] !=3D ELFDATA2LSB) { >> @@ -67,26 +85,29 @@ int rproc_elf_sanity_check(struct rproc *rproc, cons= t struct >> firmware *fw) >> =09=09return -EINVAL; >> =09} >> =20 >> -=09if (fw->size < ehdr->e_shoff + sizeof(struct elf32_shdr)) { >> -=09=09dev_err(dev, "Image is too small\n"); >> -=09=09return -EINVAL; >> -=09} >> +=09phoff =3D elf_hdr_e_phoff(class, fw->data); >> +=09shoff =3D elf_hdr_e_shoff(class, fw->data); >> +=09phnum =3D elf_hdr_e_phnum(class, fw->data); >> +=09elf_shdr_size =3D elf_size_of_shdr(class); >> =20 >> -=09if (memcmp(ehdr->e_ident, ELFMAG, SELFMAG)) { >> -=09=09dev_err(dev, "Image is corrupted (bad magic)\n"); >> +=09if (fw->size < shoff + elf_shdr_size) { >> +=09=09dev_err(dev, "Image is too small\n"); >> =09=09return -EINVAL; >> =09} >> =20 >> -=09if (ehdr->e_phnum =3D=3D 0) { >> +=09if (phnum =3D=3D 0) { >> =09=09dev_err(dev, "No loadable segments\n"); >> =09=09return -EINVAL; >> =09} >> =20 >> -=09if (ehdr->e_phoff > fw->size) { >> +=09if (phoff > fw->size) { >> =09=09dev_err(dev, "Firmware size is too small\n"); >> =09=09return -EINVAL; >> =09} >> =20 >> +=09dev_dbg(dev, "Firmware is an elf%d file\n", >> +=09=09class =3D=3D ELFCLASS32 ? 32 : 64); >> + >> =09return 0; >> } >> EXPORT_SYMBOL(rproc_elf_sanity_check); >> @@ -102,11 +123,9 @@ EXPORT_SYMBOL(rproc_elf_sanity_check); >> * Note that the boot address is not a configurable property of all rem= ote >> * processors. Some will always boot at a specific hard-coded address. >> */ >> -u32 rproc_elf_get_boot_addr(struct rproc *rproc, const struct firmware = *fw) >> +u64 rproc_elf_get_boot_addr(struct rproc *rproc, const struct firmware = *fw) >> { >> -=09struct elf32_hdr *ehdr =3D (struct elf32_hdr *)fw->data; >> - >> -=09return ehdr->e_entry; >> +=09return elf_hdr_e_entry(fw_elf_get_class(fw), fw->data); >> } >> EXPORT_SYMBOL(rproc_elf_get_boot_addr); >> =20 >> @@ -137,37 +156,41 @@ EXPORT_SYMBOL(rproc_elf_get_boot_addr); >> int rproc_elf_load_segments(struct rproc *rproc, const struct firmware = *fw) >> { >> =09struct device *dev =3D &rproc->dev; >> -=09struct elf32_hdr *ehdr; >> -=09struct elf32_phdr *phdr; >> +=09const void *ehdr, *phdr; >> =09int i, ret =3D 0; >> +=09u16 phnum; >> =09const u8 *elf_data =3D fw->data; >> +=09u8 class =3D fw_elf_get_class(fw); >> +=09u32 elf_phdr_size =3D elf_size_of_phdr(class); >> =20 >> -=09ehdr =3D (struct elf32_hdr *)elf_data; >> -=09phdr =3D (struct elf32_phdr *)(elf_data + ehdr->e_phoff); >> +=09ehdr =3D elf_data; >> +=09phnum =3D elf_hdr_e_phnum(class, ehdr); >> +=09phdr =3D elf_data + elf_hdr_e_phoff(class, ehdr); >> =20 >> =09/* go through the available ELF segments */ >> -=09for (i =3D 0; i < ehdr->e_phnum; i++, phdr++) { >> -=09=09u32 da =3D phdr->p_paddr; >> -=09=09u32 memsz =3D phdr->p_memsz; >> -=09=09u32 filesz =3D phdr->p_filesz; >> -=09=09u32 offset =3D phdr->p_offset; >> +=09for (i =3D 0; i < phnum; i++, phdr +=3D elf_phdr_size) { >> +=09=09u64 da =3D elf_phdr_p_paddr(class, phdr); >> +=09=09u64 memsz =3D elf_phdr_p_memsz(class, phdr); >> +=09=09u64 filesz =3D elf_phdr_p_filesz(class, phdr); >> +=09=09u64 offset =3D elf_phdr_p_offset(class, phdr); >> +=09=09u32 type =3D elf_phdr_p_type(class, phdr); >> =09=09void *ptr; >> =20 >> -=09=09if (phdr->p_type !=3D PT_LOAD) >> +=09=09if (type !=3D PT_LOAD) >> =09=09=09continue; >> =20 >> -=09=09dev_dbg(dev, "phdr: type %d da 0x%x memsz 0x%x filesz 0x%x\n", >> -=09=09=09phdr->p_type, da, memsz, filesz); >> +=09=09dev_dbg(dev, "phdr: type %d da 0x%llx memsz 0x%llx filesz 0x%llx\= n", >> +=09=09=09type, da, memsz, filesz); >> =20 >> =09=09if (filesz > memsz) { >> -=09=09=09dev_err(dev, "bad phdr filesz 0x%x memsz 0x%x\n", >> +=09=09=09dev_err(dev, "bad phdr filesz 0x%llx memsz 0x%llx\n", >> =09=09=09=09filesz, memsz); >> =09=09=09ret =3D -EINVAL; >> =09=09=09break; >> =09=09} >> =20 >> =09=09if (offset + filesz > fw->size) { >> -=09=09=09dev_err(dev, "truncated fw: need 0x%x avail 0x%zx\n", >> +=09=09=09dev_err(dev, "truncated fw: need 0x%llx avail 0x%zx\n", >> =09=09=09=09offset + filesz, fw->size); >> =09=09=09ret =3D -EINVAL; >> =09=09=09break; >> @@ -176,14 +199,15 @@ int rproc_elf_load_segments(struct rproc *rproc, c= onst >> struct firmware *fw) >> =09=09/* grab the kernel address for this device address */ >> =09=09ptr =3D rproc_da_to_va(rproc, da, memsz); >> =09=09if (!ptr) { >> -=09=09=09dev_err(dev, "bad phdr da 0x%x mem 0x%x\n", da, memsz); >> +=09=09=09dev_err(dev, "bad phdr da 0x%llx mem 0x%llx\n", da, >> +=09=09=09=09memsz); >> =09=09=09ret =3D -EINVAL; >> =09=09=09break; >> =09=09} >> =20 >> =09=09/* put the segment where the remote processor expects it */ >> -=09=09if (phdr->p_filesz) >> -=09=09=09memcpy(ptr, elf_data + phdr->p_offset, filesz); >> +=09=09if (filesz) >> +=09=09=09memcpy(ptr, elf_data + offset, filesz); >> =20 >> =09=09/* >> =09=09 * Zero out remaining memory for this segment. >> @@ -200,24 +224,35 @@ int rproc_elf_load_segments(struct rproc *rproc, c= onst >> struct firmware *fw) >> } >> EXPORT_SYMBOL(rproc_elf_load_segments); >> =20 >> -static struct elf32_shdr * >> -find_table(struct device *dev, struct elf32_hdr *ehdr, size_t fw_size) >> +static const void * >> +find_table(struct device *dev, const struct firmware *fw) >> { >> -=09struct elf32_shdr *shdr; >> +=09const void *shdr, *name_table_shdr; >> =09int i; >> =09const char *name_table; >> =09struct resource_table *table =3D NULL; >> -=09const u8 *elf_data =3D (void *)ehdr; >> +=09const u8 *elf_data =3D (void *)fw->data; >> +=09u8 class =3D fw_elf_get_class(fw); >> +=09size_t fw_size =3D fw->size; >> +=09const void *ehdr =3D elf_data; >> +=09u16 shnum =3D elf_hdr_e_shnum(class, ehdr); >> +=09u32 elf_shdr_size =3D elf_size_of_shdr(class); >> +=09u16 shstrndx =3D elf_hdr_e_shstrndx(class, ehdr); >> =20 >> =09/* look for the resource table and handle it */ >> -=09shdr =3D (struct elf32_shdr *)(elf_data + ehdr->e_shoff); >> -=09name_table =3D elf_data + shdr[ehdr->e_shstrndx].sh_offset; >> - >> -=09for (i =3D 0; i < ehdr->e_shnum; i++, shdr++) { >> -=09=09u32 size =3D shdr->sh_size; >> -=09=09u32 offset =3D shdr->sh_offset; >> - >> -=09=09if (strcmp(name_table + shdr->sh_name, ".resource_table")) >> +=09/* First, get the section header according to the elf class */ >> +=09shdr =3D elf_data + elf_hdr_e_shoff(class, ehdr); >> +=09/* Compute name table section header entry in shdr array */ >> +=09name_table_shdr =3D shdr + (shstrndx * elf_shdr_size); >> +=09/* Finally, compute the name table section address in elf */ >> +=09name_table =3D elf_data + elf_shdr_sh_offset(class, name_table_shdr)= ; >> + >> +=09for (i =3D 0; i < shnum; i++, shdr +=3D elf_shdr_size) { >> +=09=09u64 size =3D elf_shdr_sh_size(class, shdr); >> +=09=09u64 offset =3D elf_shdr_sh_offset(class, shdr); >> +=09=09u32 name =3D elf_shdr_sh_name(class, shdr); >> + >> +=09=09if (strcmp(name_table + name, ".resource_table")) >> =09=09=09continue; >> =20 >> =09=09table =3D (struct resource_table *)(elf_data + offset); >> @@ -270,21 +305,21 @@ find_table(struct device *dev, struct elf32_hdr *e= hdr, >> size_t fw_size) >> */ >> int rproc_elf_load_rsc_table(struct rproc *rproc, const struct firmware= *fw) >> { >> -=09struct elf32_hdr *ehdr; >> -=09struct elf32_shdr *shdr; >> +=09const void *shdr; >> =09struct device *dev =3D &rproc->dev; >> =09struct resource_table *table =3D NULL; >> =09const u8 *elf_data =3D fw->data; >> =09size_t tablesz; >> +=09u8 class =3D fw_elf_get_class(fw); >> +=09u64 sh_offset; >> =20 >> -=09ehdr =3D (struct elf32_hdr *)elf_data; >> - >> -=09shdr =3D find_table(dev, ehdr, fw->size); >> +=09shdr =3D find_table(dev, fw); >> =09if (!shdr) >> =09=09return -EINVAL; >> =20 >> -=09table =3D (struct resource_table *)(elf_data + shdr->sh_offset); >> -=09tablesz =3D shdr->sh_size; >> +=09sh_offset =3D elf_shdr_sh_offset(class, shdr); >> +=09table =3D (struct resource_table *)(elf_data + sh_offset); >> +=09tablesz =3D elf_shdr_sh_size(class, shdr); >> =20 >> =09/* >> =09 * Create a copy of the resource table. When a virtio device starts >> @@ -317,13 +352,17 @@ EXPORT_SYMBOL(rproc_elf_load_rsc_table); >> struct resource_table *rproc_elf_find_loaded_rsc_table(struct rproc *rp= roc, >> =09=09=09=09=09=09 const struct firmware *fw) >> { >> -=09struct elf32_hdr *ehdr =3D (struct elf32_hdr *)fw->data; >> -=09struct elf32_shdr *shdr; >> +=09const void *shdr; >> +=09u64 sh_addr, sh_size; >> +=09u8 class =3D fw_elf_get_class(fw); >> =20 >> -=09shdr =3D find_table(&rproc->dev, ehdr, fw->size); >> +=09shdr =3D find_table(&rproc->dev, fw); >> =09if (!shdr) >> =09=09return NULL; >> =20 >> -=09return rproc_da_to_va(rproc, shdr->sh_addr, shdr->sh_size); >> +=09sh_addr =3D elf_shdr_sh_addr(class, shdr); >> +=09sh_size =3D elf_shdr_sh_size(class, shdr); >> + >> +=09return rproc_da_to_va(rproc, sh_addr, sh_size); >> } >> EXPORT_SYMBOL(rproc_elf_find_loaded_rsc_table); >> diff --git a/drivers/remoteproc/remoteproc_elf_loader.h >> b/drivers/remoteproc/remoteproc_elf_loader.h >> new file mode 100644 >> index 000000000000..fac3565734f9 >> --- /dev/null >> +++ b/drivers/remoteproc/remoteproc_elf_loader.h >> @@ -0,0 +1,69 @@ >> +/* SPDX-License-Identifier: GPL-2.0 */ >> +/* >> + * Remote processor elf loader defines >> + * >> + * Copyright (C) 2019 Kalray, Inc. >> + */ >> + >> +#ifndef REMOTEPROC_ELF_LOADER_H >> +#define REMOTEPROC_ELF_LOADER_H >> + >> +#include >> +#include >> + >> +/** >> + * fw_elf_get_class - Get elf class >> + * @fw: the ELF firmware image >> + * >> + * Note that we use and elf32_hdr to access the class since the start o= f the >> + * struct is the same for both elf class >> + * >> + * Return: elf class of the firmware >> + */ >> +static inline u8 fw_elf_get_class(const struct firmware *fw) >> +{ >> +=09struct elf32_hdr *ehdr =3D (struct elf32_hdr *)fw->data; >> + >> +=09return ehdr->e_ident[EI_CLASS]; >> +} >> + >> +#define ELF_GET_FIELD(__s, __field, __type) \ >> +static inline __type elf_##__s##_##__field(u8 class, const void *arg) \ >> +{ \ >> +=09if (class =3D=3D ELFCLASS32) \ >> +=09=09return (__type) ((const struct elf32_##__s *) arg)->__field; \ >> +=09else \ >> +=09=09return (__type) ((const struct elf64_##__s *) arg)->__field; \ >> +} >> + >> +ELF_GET_FIELD(hdr, e_entry, u64) >> +ELF_GET_FIELD(hdr, e_phnum, u16) >> +ELF_GET_FIELD(hdr, e_shnum, u16) >> +ELF_GET_FIELD(hdr, e_phoff, u64) >> +ELF_GET_FIELD(hdr, e_shoff, u64) >> +ELF_GET_FIELD(hdr, e_shstrndx, u16) >> + >> +ELF_GET_FIELD(phdr, p_paddr, u64) >> +ELF_GET_FIELD(phdr, p_filesz, u64) >> +ELF_GET_FIELD(phdr, p_memsz, u64) >> +ELF_GET_FIELD(phdr, p_type, u32) >> +ELF_GET_FIELD(phdr, p_offset, u64) >> + >> +ELF_GET_FIELD(shdr, sh_size, u64) >> +ELF_GET_FIELD(shdr, sh_offset, u64) >> +ELF_GET_FIELD(shdr, sh_name, u32) >> +ELF_GET_FIELD(shdr, sh_addr, u64) >> + >> +#define ELF_STRUCT_SIZE(__s) \ >> +static inline unsigned long elf_size_of_##__s(u8 class) \ >> +{ \ >> +=09if (class =3D=3D ELFCLASS32)\ >> +=09=09return sizeof(struct elf32_##__s); \ >> +=09else \ >> +=09=09return sizeof(struct elf64_##__s); \ >> +} >> + >> +ELF_STRUCT_SIZE(shdr) >> +ELF_STRUCT_SIZE(phdr) >> + >> +#endif /* REMOTEPROC_ELF_LOADER_H */ >> diff --git a/drivers/remoteproc/remoteproc_internal.h >> b/drivers/remoteproc/remoteproc_internal.h >> index 004867061721..eeb26434220e 100644 >> --- a/drivers/remoteproc/remoteproc_internal.h >> +++ b/drivers/remoteproc/remoteproc_internal.h >> @@ -55,7 +55,7 @@ phys_addr_t rproc_va_to_pa(void *cpu_addr); >> int rproc_trigger_recovery(struct rproc *rproc); >> =20 >> int rproc_elf_sanity_check(struct rproc *rproc, const struct firmware *= fw); >> -u32 rproc_elf_get_boot_addr(struct rproc *rproc, const struct firmware = *fw); >> +u64 rproc_elf_get_boot_addr(struct rproc *rproc, const struct firmware = *fw); >> int rproc_elf_load_segments(struct rproc *rproc, const struct firmware = *fw); >> int rproc_elf_load_rsc_table(struct rproc *rproc, const struct firmware= *fw); >> struct resource_table *rproc_elf_find_loaded_rsc_table(struct rproc *rp= roc, >> diff --git a/drivers/remoteproc/st_remoteproc.c >> b/drivers/remoteproc/st_remoteproc.c >> index ee13d23b43a9..a3268d95a50e 100644 >> --- a/drivers/remoteproc/st_remoteproc.c >> +++ b/drivers/remoteproc/st_remoteproc.c >> @@ -190,7 +190,7 @@ static int st_rproc_start(struct rproc *rproc) >> =09=09} >> =09} >> =20 >> -=09dev_info(&rproc->dev, "Started from 0x%x\n", rproc->bootaddr); >> +=09dev_info(&rproc->dev, "Started from 0x%llx\n", rproc->bootaddr); >> =20 >> =09return 0; >> =20 >> diff --git a/include/linux/remoteproc.h b/include/linux/remoteproc.h >> index f84bd5fe0211..82cebca9344c 100644 >> --- a/include/linux/remoteproc.h >> +++ b/include/linux/remoteproc.h >> @@ -382,7 +382,7 @@ struct rproc_ops { >> =09=09=09=09struct rproc *rproc, const struct firmware *fw); >> =09int (*load)(struct rproc *rproc, const struct firmware *fw); >> =09int (*sanity_check)(struct rproc *rproc, const struct firmware *fw); >> -=09u32 (*get_boot_addr)(struct rproc *rproc, const struct firmware *fw)= ; >> +=09u64 (*get_boot_addr)(struct rproc *rproc, const struct firmware *fw)= ; >> }; >> =20 >> /** >> @@ -498,7 +498,7 @@ struct rproc { >> =09int num_traces; >> =09struct list_head carveouts; >> =09struct list_head mappings; >> -=09u32 bootaddr; >> +=09u64 bootaddr; >=20 > That will cause problems for rproc_coredump()[1] and fixing it properly > likely means that a 32 or 64 elf should be generated based on the type of= image > that was loaded. This is also true if ->p_vaddr and ->p_paddr (also in t= he same > function) are to be handled properly. >=20 > I'm interested in your opinion on this. Indeed, you are right ! I'm "afraid" I will have to fix that ! Most sane thing to do is to dump an elf with the input elf class. I will make a V4 with a patch for that. Thanks, Cl=C3=A9ment >=20 > Thanks, > Mathieu >=20 > [1]. > https://elixir.bootlin.com/linux/latest/source/drivers/remoteproc/remotep= roc_core.c#L1600 >=20 >> =09struct list_head rvdevs; >> =09struct list_head subdevs; >> =09struct idr notifyids; >> -- >> 2.15.0.276.g89ea799 From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-4.2 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,URIBL_DBL_ABUSE_MALW autolearn=no autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 989BDC2D0B1 for ; Thu, 6 Feb 2020 08:38:06 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 69847214AF for ; Thu, 6 Feb 2020 08:38:06 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="Teb8k6F/"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=kalray.eu header.i=@kalray.eu header.b="hudIdxVU" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 69847214AF Authentication-Results: mail.kernel.org; dmarc=fail (p=quarantine dis=none) header.from=kalray.eu Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20170209; h=Sender: Content-Transfer-Encoding:Content-Type:Cc:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:Subject:References: In-Reply-To:Message-ID:To:From:Date:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=zxKg0G+Ly98e5LzPJulMy0TVTEVPLr2NrgM5KZzOZ4k=; b=Teb8k6F/E8mvuK 0XBfcrcaLM2zB3QHgt91hyTklt3C5tD0RcxTTrq/cDl9Vl9Tu+YHD5j2Dzcq2NN3z1dSPa5LEJhXo u20vp4Pr0a4w/FaOdVWHwTIXnEss20teL/B7ltNUsbWmczcKzLz3bkiNhnk2Kb71OizfiJHL4e85h EFFYpeH9Fzchy5U+/xgiZXkYtzUhdwmW7pZai1aDEGm+mvnghmwtX3MYSJ0r3IkUX+1YxUV/lMPHR Qe0TXYrM7L/U8x1YtgAuyNcuEK6U8gt5HVY+GVOT3FX9S8C6CYK/cpjUswG0QhgXDtFPB4o51C7eI Ud7nYEbBnTBcehkUIuuw==; Received: from localhost ([127.0.0.1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1izcfk-0008My-4h; Thu, 06 Feb 2020 08:38:04 +0000 Received: from zimbra2.kalray.eu ([92.103.151.219]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1izcfg-0008M9-8c for linux-arm-kernel@lists.infradead.org; Thu, 06 Feb 2020 08:38:03 +0000 Received: from localhost (localhost [127.0.0.1]) by zimbra2.kalray.eu (Postfix) with ESMTP id 9858127E03A0; Thu, 6 Feb 2020 09:37:55 +0100 (CET) Received: from zimbra2.kalray.eu ([127.0.0.1]) by localhost (zimbra2.kalray.eu [127.0.0.1]) (amavisd-new, port 10032) with ESMTP id cyO7F9rmyerp; Thu, 6 Feb 2020 09:37:54 +0100 (CET) Received: from localhost (localhost [127.0.0.1]) by zimbra2.kalray.eu (Postfix) with ESMTP id E0AE227E0C42; Thu, 6 Feb 2020 09:37:53 +0100 (CET) DKIM-Filter: OpenDKIM Filter v2.10.3 zimbra2.kalray.eu E0AE227E0C42 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=kalray.eu; s=32AE1B44-9502-11E5-BA35-3734643DEF29; t=1580978273; bh=l2mAeXngR/5BNCZbuh9+mPg0UQnp76NPA6/k85Bg4q4=; h=Date:From:To:Message-ID:MIME-Version; b=hudIdxVU5ITKekTYQmrcTD7EeH2P0b/tzXYJeoLiPypP26D4jg1oXgMo5cwav/7JN dzUnIgFBuhCRUpjbMFBaFiznGuj+M+ULIb4sEb5+ihOmHDHUCS0knmgdtKN0e4pRL3 OdyqpFTzdLKFXuedrIItVJziXz6l6f3eXc/cUJCM= X-Virus-Scanned: amavisd-new at zimbra2.kalray.eu Received: from zimbra2.kalray.eu ([127.0.0.1]) by localhost (zimbra2.kalray.eu [127.0.0.1]) (amavisd-new, port 10026) with ESMTP id J5-WDM_nHfGe; Thu, 6 Feb 2020 09:37:53 +0100 (CET) Received: from zimbra2.kalray.eu (localhost [127.0.0.1]) by zimbra2.kalray.eu (Postfix) with ESMTP id BE6CB27E03A0; Thu, 6 Feb 2020 09:37:53 +0100 (CET) Date: Thu, 6 Feb 2020 09:37:53 +0100 (CET) From: =?utf-8?Q?Cl=C3=A9ment?= Leger To: Mathieu Poirier Message-ID: <1065812225.2604892.1580978273748.JavaMail.zimbra@kalray.eu> In-Reply-To: <20200205224936.GB25901@xps15> References: <20200129163013.GA16538@xps15> <20200204174412.16814-1-cleger@kalray.eu> <20200204174412.16814-3-cleger@kalray.eu> <20200205224936.GB25901@xps15> Subject: Re: [PATCH v3 2/2] remoteproc: Add elf64 support in elf loader MIME-Version: 1.0 X-Originating-IP: [192.168.40.202] X-Mailer: Zimbra 8.8.15_GA_3895 (ZimbraWebClient - GC75 (Linux)/8.8.15_GA_3895) Thread-Topic: remoteproc: Add elf64 support in elf loader Thread-Index: V6XODUe4azDGASdnez4hZiYZ5aNL9A== X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200206_003800_716309_86847BA4 X-CRM114-Status: GOOD ( 11.36 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Ohad Ben-Cohen , Loic PALLARDY , Arnaud Pouliquen , Jonathan Corbet , Fabio Estevam , Sascha Hauer , linux-doc , linux-remoteproc , Patrice Chotard , Bjorn Andersson , Andy Gross , NXP Linux Team , Pengutronix Kernel Team , linux-arm-msm , s-anna , Shawn Guo , linux-kernel , linux-arm-kernel Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-arm-kernel" Errors-To: linux-arm-kernel-bounces+infradead-linux-arm-kernel=archiver.kernel.org@lists.infradead.org SGkgTWF0aGlldSwKCi0tLS0tIE9uIDUgRmViLCAyMDIwLCBhdCAyMzo0OSwgTWF0aGlldSBQb2ly aWVyIG1hdGhpZXUucG9pcmllckBsaW5hcm8ub3JnIHdyb3RlOgoKPiBPbiBUdWUsIEZlYiAwNCwg MjAyMCBhdCAwNjo0NDoxMlBNICswMTAwLCBDbGVtZW50IExlZ2VyIHdyb3RlOgo+PiBlbGYzMiBh bmQgZWxmNjQgbWFpbmx5IGRpZmZlciBieSB0aGVpciB0eXBlcy4gSW4gb3JkZXIgdG8gYXZvaWQK Pj4gY29weS9wYXN0aW5nIHRoZSB3aG9sZSBsb2FkZXIgY29kZSwgZ2VuZXJhdGUgc3RhdGljIGlu bGluZSBmdW5jdGlvbnMKPj4gd2hpY2ggd2lsbCBhY2Nlc3MgdmFsdWVzIGFjY29yZGluZyB0byB0 aGUgZWxmIGNsYXNzLiBJdCBhbGxvd3MgdG8ga2VlcCBhCj4+IGNvbW1vbiBsb2FkZXIgYmFzaXMu Cj4+IEluIG9yZGVyIHRvIGFjY29tbW9kYXRlIGJvdGggZWxmIHR5cGVzIHNpemVzLCB0aGUgbWF4 aW11bSBzaXplIGZvciBhCj4+IGVsZiBoZWFkZXIgbWVtYmVyIGlzIGNob3NlbiB1c2luZyB0aGUg bWF4aW11bSB2YWx1ZSBvZiBib3RoIGVsZiBjbGFzcy4KPj4gCj4+IFNpZ25lZC1vZmYtYnk6IENs ZW1lbnQgTGVnZXIgPGNsZWdlckBrYWxyYXkuZXU+Cj4+IFRlc3RlZC1ieTogQXJuYXVkIFBPVUxJ UVVFTiA8YXJuYXVkLnBvdWxpcXVlbkBzdC5jb20+Cj4+IC0tLQo+PiAgRG9jdW1lbnRhdGlvbi9y ZW1vdGVwcm9jLnR4dCAgICAgICAgICAgICAgIHwgICAyICstCj4+ICBkcml2ZXJzL3JlbW90ZXBy b2MvcmVtb3RlcHJvY19lbGZfbG9hZGVyLmMgfCAxNDcgKysrKysrKysrKysrKysrKysrLS0tLS0t LS0tLS0KPj4gIGRyaXZlcnMvcmVtb3RlcHJvYy9yZW1vdGVwcm9jX2VsZl9sb2FkZXIuaCB8ICA2 OSArKysrKysrKysrKysrKwo+PiAgZHJpdmVycy9yZW1vdGVwcm9jL3JlbW90ZXByb2NfaW50ZXJu YWwuaCAgIHwgICAyICstCj4+ICBkcml2ZXJzL3JlbW90ZXByb2Mvc3RfcmVtb3RlcHJvYy5jICAg ICAgICAgfCAgIDIgKy0KPj4gIGluY2x1ZGUvbGludXgvcmVtb3RlcHJvYy5oICAgICAgICAgICAg ICAgICB8ICAgNCArLQo+PiAgNiBmaWxlcyBjaGFuZ2VkLCAxNjcgaW5zZXJ0aW9ucygrKSwgNTkg ZGVsZXRpb25zKC0pCj4+ICBjcmVhdGUgbW9kZSAxMDA2NDQgZHJpdmVycy9yZW1vdGVwcm9jL3Jl bW90ZXByb2NfZWxmX2xvYWRlci5oCj4+IAo+PiBkaWZmIC0tZ2l0IGEvRG9jdW1lbnRhdGlvbi9y ZW1vdGVwcm9jLnR4dCBiL0RvY3VtZW50YXRpb24vcmVtb3RlcHJvYy50eHQKPj4gaW5kZXggMDNj M2QyZTU2OGIwLi4yYmUxMTQ3MjU2ZTAgMTAwNjQ0Cj4+IC0tLSBhL0RvY3VtZW50YXRpb24vcmVt b3RlcHJvYy50eHQKPj4gKysrIGIvRG9jdW1lbnRhdGlvbi9yZW1vdGVwcm9jLnR4dAo+PiBAQCAt MjMwLDcgKzIzMCw3IEBAIGluIHRoZSB1c2VkIHJpbmdzLgo+PiAgQmluYXJ5IEZpcm13YXJlIFN0 cnVjdHVyZQo+PiAgPT09PT09PT09PT09PT09PT09PT09PT09PQo+PiAgCj4+IC1BdCB0aGlzIHBv aW50IHJlbW90ZXByb2Mgb25seSBzdXBwb3J0cyBFTEYzMiBmaXJtd2FyZSBiaW5hcmllcy4gSG93 ZXZlciwKPj4gK0F0IHRoaXMgcG9pbnQgcmVtb3RlcHJvYyBzdXBwb3J0cyBFTEYzMiBhbmQgRUxG NjQgZmlybXdhcmUgYmluYXJpZXMuIEhvd2V2ZXIsCj4+ICBpdCBpcyBxdWl0ZSBleHBlY3RlZCB0 aGF0IG90aGVyIHBsYXRmb3Jtcy9kZXZpY2VzIHdoaWNoIHdlJ2Qgd2FudCB0bwo+PiAgc3VwcG9y dCB3aXRoIHRoaXMgZnJhbWV3b3JrIHdpbGwgYmUgYmFzZWQgb24gZGlmZmVyZW50IGJpbmFyeSBm b3JtYXRzLgo+PiAgCj4+IGRpZmYgLS1naXQgYS9kcml2ZXJzL3JlbW90ZXByb2MvcmVtb3RlcHJv Y19lbGZfbG9hZGVyLmMKPj4gYi9kcml2ZXJzL3JlbW90ZXByb2MvcmVtb3RlcHJvY19lbGZfbG9h ZGVyLmMKPj4gaW5kZXggNjA2YWFlMTY2ZWJhLi4yMWZkMmIyZmU1YWUgMTAwNjQ0Cj4+IC0tLSBh L2RyaXZlcnMvcmVtb3RlcHJvYy9yZW1vdGVwcm9jX2VsZl9sb2FkZXIuYwo+PiArKysgYi9kcml2 ZXJzL3JlbW90ZXByb2MvcmVtb3RlcHJvY19lbGZfbG9hZGVyLmMKPj4gQEAgLTIzLDYgKzIzLDcg QEAKPj4gICNpbmNsdWRlIDxsaW51eC9lbGYuaD4KPj4gIAo+PiAgI2luY2x1ZGUgInJlbW90ZXBy b2NfaW50ZXJuYWwuaCIKPj4gKyNpbmNsdWRlICJyZW1vdGVwcm9jX2VsZl9sb2FkZXIuaCIKPj4g IAo+PiAgLyoqCj4+ICAgKiBycHJvY19lbGZfc2FuaXR5X2NoZWNrKCkgLSBTYW5pdHkgQ2hlY2sg RUxGIGZpcm13YXJlIGltYWdlCj4+IEBAIC0zNSw4ICszNiwxNiBAQCBpbnQgcnByb2NfZWxmX3Nh bml0eV9jaGVjayhzdHJ1Y3QgcnByb2MgKnJwcm9jLCBjb25zdCBzdHJ1Y3QKPj4gZmlybXdhcmUg KmZ3KQo+PiAgewo+PiAgCWNvbnN0IGNoYXIgKm5hbWUgPSBycHJvYy0+ZmlybXdhcmU7Cj4+ICAJ c3RydWN0IGRldmljZSAqZGV2ID0gJnJwcm9jLT5kZXY7Cj4+ICsJLyoKPj4gKwkgKiBFbGYgZmls ZXMgYXJlIGJlZ2lubmluZyB3aXRoIHRoZSBzYW1lIHN0cnVjdHVyZS4gVGh1cywgdG8gc2ltcGxp ZnkKPj4gKwkgKiBoZWFkZXIgcGFyc2luZywgd2UgY2FuIHVzZSB0aGUgZWxmMzJfaGRyIG9uZSBm b3IgYm90aCBlbGY2NCBhbmQKPj4gKwkgKiBlbGYzMi4KPj4gKwkgKi8KPj4gIAlzdHJ1Y3QgZWxm MzJfaGRyICplaGRyOwo+PiArCXUzMiBlbGZfc2hkcl9zaXplOwo+PiArCXU2NCBwaG9mZiwgc2hv ZmY7Cj4+ICAJY2hhciBjbGFzczsKPj4gKwl1MTYgcGhudW07Cj4+ICAKPj4gIAlpZiAoIWZ3KSB7 Cj4+ICAJCWRldl9lcnIoZGV2LCAiZmFpbGVkIHRvIGxvYWQgJXNcbiIsIG5hbWUpOwo+PiBAQCAt NTAsMTMgKzU5LDIyIEBAIGludCBycHJvY19lbGZfc2FuaXR5X2NoZWNrKHN0cnVjdCBycHJvYyAq cnByb2MsIGNvbnN0IHN0cnVjdAo+PiBmaXJtd2FyZSAqZncpCj4+ICAKPj4gIAllaGRyID0gKHN0 cnVjdCBlbGYzMl9oZHIgKilmdy0+ZGF0YTsKPj4gIAo+PiAtCS8qIFdlIG9ubHkgc3VwcG9ydCBF TEYzMiBhdCB0aGlzIHBvaW50ICovCj4+ICsJaWYgKG1lbWNtcChlaGRyLT5lX2lkZW50LCBFTEZN QUcsIFNFTEZNQUcpKSB7Cj4+ICsJCWRldl9lcnIoZGV2LCAiSW1hZ2UgaXMgY29ycnVwdGVkIChi YWQgbWFnaWMpXG4iKTsKPj4gKwkJcmV0dXJuIC1FSU5WQUw7Cj4+ICsJfQo+PiArCj4+ICAJY2xh c3MgPSBlaGRyLT5lX2lkZW50W0VJX0NMQVNTXTsKPj4gLQlpZiAoY2xhc3MgIT0gRUxGQ0xBU1Mz Mikgewo+PiArCWlmIChjbGFzcyAhPSBFTEZDTEFTUzMyICYmIGNsYXNzICE9IEVMRkNMQVNTNjQp IHsKPj4gIAkJZGV2X2VycihkZXYsICJVbnN1cHBvcnRlZCBjbGFzczogJWRcbiIsIGNsYXNzKTsK Pj4gIAkJcmV0dXJuIC1FSU5WQUw7Cj4+ICAJfQo+PiAgCj4+ICsJaWYgKGNsYXNzID09IEVMRkNM QVNTNjQgJiYgZnctPnNpemUgPCBzaXplb2Yoc3RydWN0IGVsZjY0X2hkcikpIHsKPj4gKwkJZGV2 X2VycihkZXYsICJlbGY2NCBoZWFkZXIgaXMgdG9vIHNtYWxsXG4iKTsKPj4gKwkJcmV0dXJuIC1F SU5WQUw7Cj4+ICsJfQo+PiArCj4+ICAJLyogV2UgYXNzdW1lIHRoZSBmaXJtd2FyZSBoYXMgdGhl IHNhbWUgZW5kaWFubmVzcyBhcyB0aGUgaG9zdCAqLwo+PiAgIyBpZmRlZiBfX0xJVFRMRV9FTkRJ QU4KPj4gIAlpZiAoZWhkci0+ZV9pZGVudFtFSV9EQVRBXSAhPSBFTEZEQVRBMkxTQikgewo+PiBA QCAtNjcsMjYgKzg1LDI5IEBAIGludCBycHJvY19lbGZfc2FuaXR5X2NoZWNrKHN0cnVjdCBycHJv YyAqcnByb2MsIGNvbnN0IHN0cnVjdAo+PiBmaXJtd2FyZSAqZncpCj4+ICAJCXJldHVybiAtRUlO VkFMOwo+PiAgCX0KPj4gIAo+PiAtCWlmIChmdy0+c2l6ZSA8IGVoZHItPmVfc2hvZmYgKyBzaXpl b2Yoc3RydWN0IGVsZjMyX3NoZHIpKSB7Cj4+IC0JCWRldl9lcnIoZGV2LCAiSW1hZ2UgaXMgdG9v IHNtYWxsXG4iKTsKPj4gLQkJcmV0dXJuIC1FSU5WQUw7Cj4+IC0JfQo+PiArCXBob2ZmID0gZWxm X2hkcl9lX3Bob2ZmKGNsYXNzLCBmdy0+ZGF0YSk7Cj4+ICsJc2hvZmYgPSBlbGZfaGRyX2Vfc2hv ZmYoY2xhc3MsIGZ3LT5kYXRhKTsKPj4gKwlwaG51bSA9ICBlbGZfaGRyX2VfcGhudW0oY2xhc3Ms IGZ3LT5kYXRhKTsKPj4gKwllbGZfc2hkcl9zaXplID0gZWxmX3NpemVfb2Zfc2hkcihjbGFzcyk7 Cj4+ICAKPj4gLQlpZiAobWVtY21wKGVoZHItPmVfaWRlbnQsIEVMRk1BRywgU0VMRk1BRykpIHsK Pj4gLQkJZGV2X2VycihkZXYsICJJbWFnZSBpcyBjb3JydXB0ZWQgKGJhZCBtYWdpYylcbiIpOwo+ PiArCWlmIChmdy0+c2l6ZSA8IHNob2ZmICsgZWxmX3NoZHJfc2l6ZSkgewo+PiArCQlkZXZfZXJy KGRldiwgIkltYWdlIGlzIHRvbyBzbWFsbFxuIik7Cj4+ICAJCXJldHVybiAtRUlOVkFMOwo+PiAg CX0KPj4gIAo+PiAtCWlmIChlaGRyLT5lX3BobnVtID09IDApIHsKPj4gKwlpZiAocGhudW0gPT0g MCkgewo+PiAgCQlkZXZfZXJyKGRldiwgIk5vIGxvYWRhYmxlIHNlZ21lbnRzXG4iKTsKPj4gIAkJ cmV0dXJuIC1FSU5WQUw7Cj4+ICAJfQo+PiAgCj4+IC0JaWYgKGVoZHItPmVfcGhvZmYgPiBmdy0+ c2l6ZSkgewo+PiArCWlmIChwaG9mZiA+IGZ3LT5zaXplKSB7Cj4+ICAJCWRldl9lcnIoZGV2LCAi RmlybXdhcmUgc2l6ZSBpcyB0b28gc21hbGxcbiIpOwo+PiAgCQlyZXR1cm4gLUVJTlZBTDsKPj4g IAl9Cj4+ICAKPj4gKwlkZXZfZGJnKGRldiwgIkZpcm13YXJlIGlzIGFuIGVsZiVkIGZpbGVcbiIs Cj4+ICsJCWNsYXNzID09IEVMRkNMQVNTMzIgPyAzMiA6IDY0KTsKPj4gKwo+PiAgCXJldHVybiAw Owo+PiAgfQo+PiAgRVhQT1JUX1NZTUJPTChycHJvY19lbGZfc2FuaXR5X2NoZWNrKTsKPj4gQEAg LTEwMiwxMSArMTIzLDkgQEAgRVhQT1JUX1NZTUJPTChycHJvY19lbGZfc2FuaXR5X2NoZWNrKTsK Pj4gICAqIE5vdGUgdGhhdCB0aGUgYm9vdCBhZGRyZXNzIGlzIG5vdCBhIGNvbmZpZ3VyYWJsZSBw cm9wZXJ0eSBvZiBhbGwgcmVtb3RlCj4+ICAgKiBwcm9jZXNzb3JzLiBTb21lIHdpbGwgYWx3YXlz IGJvb3QgYXQgYSBzcGVjaWZpYyBoYXJkLWNvZGVkIGFkZHJlc3MuCj4+ICAgKi8KPj4gLXUzMiBy cHJvY19lbGZfZ2V0X2Jvb3RfYWRkcihzdHJ1Y3QgcnByb2MgKnJwcm9jLCBjb25zdCBzdHJ1Y3Qg ZmlybXdhcmUgKmZ3KQo+PiArdTY0IHJwcm9jX2VsZl9nZXRfYm9vdF9hZGRyKHN0cnVjdCBycHJv YyAqcnByb2MsIGNvbnN0IHN0cnVjdCBmaXJtd2FyZSAqZncpCj4+ICB7Cj4+IC0Jc3RydWN0IGVs ZjMyX2hkciAqZWhkciAgPSAoc3RydWN0IGVsZjMyX2hkciAqKWZ3LT5kYXRhOwo+PiAtCj4+IC0J cmV0dXJuIGVoZHItPmVfZW50cnk7Cj4+ICsJcmV0dXJuIGVsZl9oZHJfZV9lbnRyeShmd19lbGZf Z2V0X2NsYXNzKGZ3KSwgZnctPmRhdGEpOwo+PiAgfQo+PiAgRVhQT1JUX1NZTUJPTChycHJvY19l bGZfZ2V0X2Jvb3RfYWRkcik7Cj4+ICAKPj4gQEAgLTEzNywzNyArMTU2LDQxIEBAIEVYUE9SVF9T WU1CT0wocnByb2NfZWxmX2dldF9ib290X2FkZHIpOwo+PiAgaW50IHJwcm9jX2VsZl9sb2FkX3Nl Z21lbnRzKHN0cnVjdCBycHJvYyAqcnByb2MsIGNvbnN0IHN0cnVjdCBmaXJtd2FyZSAqZncpCj4+ ICB7Cj4+ICAJc3RydWN0IGRldmljZSAqZGV2ID0gJnJwcm9jLT5kZXY7Cj4+IC0Jc3RydWN0IGVs ZjMyX2hkciAqZWhkcjsKPj4gLQlzdHJ1Y3QgZWxmMzJfcGhkciAqcGhkcjsKPj4gKwljb25zdCB2 b2lkICplaGRyLCAqcGhkcjsKPj4gIAlpbnQgaSwgcmV0ID0gMDsKPj4gKwl1MTYgcGhudW07Cj4+ ICAJY29uc3QgdTggKmVsZl9kYXRhID0gZnctPmRhdGE7Cj4+ICsJdTggY2xhc3MgPSBmd19lbGZf Z2V0X2NsYXNzKGZ3KTsKPj4gKwl1MzIgZWxmX3BoZHJfc2l6ZSA9IGVsZl9zaXplX29mX3BoZHIo Y2xhc3MpOwo+PiAgCj4+IC0JZWhkciA9IChzdHJ1Y3QgZWxmMzJfaGRyICopZWxmX2RhdGE7Cj4+ IC0JcGhkciA9IChzdHJ1Y3QgZWxmMzJfcGhkciAqKShlbGZfZGF0YSArIGVoZHItPmVfcGhvZmYp Owo+PiArCWVoZHIgPSBlbGZfZGF0YTsKPj4gKwlwaG51bSA9IGVsZl9oZHJfZV9waG51bShjbGFz cywgZWhkcik7Cj4+ICsJcGhkciA9IGVsZl9kYXRhICsgZWxmX2hkcl9lX3Bob2ZmKGNsYXNzLCBl aGRyKTsKPj4gIAo+PiAgCS8qIGdvIHRocm91Z2ggdGhlIGF2YWlsYWJsZSBFTEYgc2VnbWVudHMg Ki8KPj4gLQlmb3IgKGkgPSAwOyBpIDwgZWhkci0+ZV9waG51bTsgaSsrLCBwaGRyKyspIHsKPj4g LQkJdTMyIGRhID0gcGhkci0+cF9wYWRkcjsKPj4gLQkJdTMyIG1lbXN6ID0gcGhkci0+cF9tZW1z ejsKPj4gLQkJdTMyIGZpbGVzeiA9IHBoZHItPnBfZmlsZXN6Owo+PiAtCQl1MzIgb2Zmc2V0ID0g cGhkci0+cF9vZmZzZXQ7Cj4+ICsJZm9yIChpID0gMDsgaSA8IHBobnVtOyBpKyssIHBoZHIgKz0g ZWxmX3BoZHJfc2l6ZSkgewo+PiArCQl1NjQgZGEgPSBlbGZfcGhkcl9wX3BhZGRyKGNsYXNzLCBw aGRyKTsKPj4gKwkJdTY0IG1lbXN6ID0gZWxmX3BoZHJfcF9tZW1zeihjbGFzcywgcGhkcik7Cj4+ ICsJCXU2NCBmaWxlc3ogPSBlbGZfcGhkcl9wX2ZpbGVzeihjbGFzcywgcGhkcik7Cj4+ICsJCXU2 NCBvZmZzZXQgPSBlbGZfcGhkcl9wX29mZnNldChjbGFzcywgcGhkcik7Cj4+ICsJCXUzMiB0eXBl ID0gZWxmX3BoZHJfcF90eXBlKGNsYXNzLCBwaGRyKTsKPj4gIAkJdm9pZCAqcHRyOwo+PiAgCj4+ IC0JCWlmIChwaGRyLT5wX3R5cGUgIT0gUFRfTE9BRCkKPj4gKwkJaWYgKHR5cGUgIT0gUFRfTE9B RCkKPj4gIAkJCWNvbnRpbnVlOwo+PiAgCj4+IC0JCWRldl9kYmcoZGV2LCAicGhkcjogdHlwZSAl ZCBkYSAweCV4IG1lbXN6IDB4JXggZmlsZXN6IDB4JXhcbiIsCj4+IC0JCQlwaGRyLT5wX3R5cGUs IGRhLCBtZW1zeiwgZmlsZXN6KTsKPj4gKwkJZGV2X2RiZyhkZXYsICJwaGRyOiB0eXBlICVkIGRh IDB4JWxseCBtZW1zeiAweCVsbHggZmlsZXN6IDB4JWxseFxuIiwKPj4gKwkJCXR5cGUsIGRhLCBt ZW1zeiwgZmlsZXN6KTsKPj4gIAo+PiAgCQlpZiAoZmlsZXN6ID4gbWVtc3opIHsKPj4gLQkJCWRl dl9lcnIoZGV2LCAiYmFkIHBoZHIgZmlsZXN6IDB4JXggbWVtc3ogMHgleFxuIiwKPj4gKwkJCWRl dl9lcnIoZGV2LCAiYmFkIHBoZHIgZmlsZXN6IDB4JWxseCBtZW1zeiAweCVsbHhcbiIsCj4+ICAJ CQkJZmlsZXN6LCBtZW1zeik7Cj4+ICAJCQlyZXQgPSAtRUlOVkFMOwo+PiAgCQkJYnJlYWs7Cj4+ ICAJCX0KPj4gIAo+PiAgCQlpZiAob2Zmc2V0ICsgZmlsZXN6ID4gZnctPnNpemUpIHsKPj4gLQkJ CWRldl9lcnIoZGV2LCAidHJ1bmNhdGVkIGZ3OiBuZWVkIDB4JXggYXZhaWwgMHglenhcbiIsCj4+ ICsJCQlkZXZfZXJyKGRldiwgInRydW5jYXRlZCBmdzogbmVlZCAweCVsbHggYXZhaWwgMHglenhc biIsCj4+ICAJCQkJb2Zmc2V0ICsgZmlsZXN6LCBmdy0+c2l6ZSk7Cj4+ICAJCQlyZXQgPSAtRUlO VkFMOwo+PiAgCQkJYnJlYWs7Cj4+IEBAIC0xNzYsMTQgKzE5OSwxNSBAQCBpbnQgcnByb2NfZWxm X2xvYWRfc2VnbWVudHMoc3RydWN0IHJwcm9jICpycHJvYywgY29uc3QKPj4gc3RydWN0IGZpcm13 YXJlICpmdykKPj4gIAkJLyogZ3JhYiB0aGUga2VybmVsIGFkZHJlc3MgZm9yIHRoaXMgZGV2aWNl IGFkZHJlc3MgKi8KPj4gIAkJcHRyID0gcnByb2NfZGFfdG9fdmEocnByb2MsIGRhLCBtZW1zeik7 Cj4+ICAJCWlmICghcHRyKSB7Cj4+IC0JCQlkZXZfZXJyKGRldiwgImJhZCBwaGRyIGRhIDB4JXgg bWVtIDB4JXhcbiIsIGRhLCBtZW1zeik7Cj4+ICsJCQlkZXZfZXJyKGRldiwgImJhZCBwaGRyIGRh IDB4JWxseCBtZW0gMHglbGx4XG4iLCBkYSwKPj4gKwkJCQltZW1zeik7Cj4+ICAJCQlyZXQgPSAt RUlOVkFMOwo+PiAgCQkJYnJlYWs7Cj4+ICAJCX0KPj4gIAo+PiAgCQkvKiBwdXQgdGhlIHNlZ21l bnQgd2hlcmUgdGhlIHJlbW90ZSBwcm9jZXNzb3IgZXhwZWN0cyBpdCAqLwo+PiAtCQlpZiAocGhk ci0+cF9maWxlc3opCj4+IC0JCQltZW1jcHkocHRyLCBlbGZfZGF0YSArIHBoZHItPnBfb2Zmc2V0 LCBmaWxlc3opOwo+PiArCQlpZiAoZmlsZXN6KQo+PiArCQkJbWVtY3B5KHB0ciwgZWxmX2RhdGEg KyBvZmZzZXQsIGZpbGVzeik7Cj4+ICAKPj4gIAkJLyoKPj4gIAkJICogWmVybyBvdXQgcmVtYWlu aW5nIG1lbW9yeSBmb3IgdGhpcyBzZWdtZW50Lgo+PiBAQCAtMjAwLDI0ICsyMjQsMzUgQEAgaW50 IHJwcm9jX2VsZl9sb2FkX3NlZ21lbnRzKHN0cnVjdCBycHJvYyAqcnByb2MsIGNvbnN0Cj4+IHN0 cnVjdCBmaXJtd2FyZSAqZncpCj4+ICB9Cj4+ICBFWFBPUlRfU1lNQk9MKHJwcm9jX2VsZl9sb2Fk X3NlZ21lbnRzKTsKPj4gIAo+PiAtc3RhdGljIHN0cnVjdCBlbGYzMl9zaGRyICoKPj4gLWZpbmRf dGFibGUoc3RydWN0IGRldmljZSAqZGV2LCBzdHJ1Y3QgZWxmMzJfaGRyICplaGRyLCBzaXplX3Qg Zndfc2l6ZSkKPj4gK3N0YXRpYyBjb25zdCB2b2lkICoKPj4gK2ZpbmRfdGFibGUoc3RydWN0IGRl dmljZSAqZGV2LCBjb25zdCBzdHJ1Y3QgZmlybXdhcmUgKmZ3KQo+PiAgewo+PiAtCXN0cnVjdCBl bGYzMl9zaGRyICpzaGRyOwo+PiArCWNvbnN0IHZvaWQgKnNoZHIsICpuYW1lX3RhYmxlX3NoZHI7 Cj4+ICAJaW50IGk7Cj4+ICAJY29uc3QgY2hhciAqbmFtZV90YWJsZTsKPj4gIAlzdHJ1Y3QgcmVz b3VyY2VfdGFibGUgKnRhYmxlID0gTlVMTDsKPj4gLQljb25zdCB1OCAqZWxmX2RhdGEgPSAodm9p ZCAqKWVoZHI7Cj4+ICsJY29uc3QgdTggKmVsZl9kYXRhID0gKHZvaWQgKilmdy0+ZGF0YTsKPj4g Kwl1OCBjbGFzcyA9IGZ3X2VsZl9nZXRfY2xhc3MoZncpOwo+PiArCXNpemVfdCBmd19zaXplID0g ZnctPnNpemU7Cj4+ICsJY29uc3Qgdm9pZCAqZWhkciA9IGVsZl9kYXRhOwo+PiArCXUxNiBzaG51 bSA9IGVsZl9oZHJfZV9zaG51bShjbGFzcywgZWhkcik7Cj4+ICsJdTMyIGVsZl9zaGRyX3NpemUg PSBlbGZfc2l6ZV9vZl9zaGRyKGNsYXNzKTsKPj4gKwl1MTYgc2hzdHJuZHggPSBlbGZfaGRyX2Vf c2hzdHJuZHgoY2xhc3MsIGVoZHIpOwo+PiAgCj4+ICAJLyogbG9vayBmb3IgdGhlIHJlc291cmNl IHRhYmxlIGFuZCBoYW5kbGUgaXQgKi8KPj4gLQlzaGRyID0gKHN0cnVjdCBlbGYzMl9zaGRyICop KGVsZl9kYXRhICsgZWhkci0+ZV9zaG9mZik7Cj4+IC0JbmFtZV90YWJsZSA9IGVsZl9kYXRhICsg c2hkcltlaGRyLT5lX3Noc3RybmR4XS5zaF9vZmZzZXQ7Cj4+IC0KPj4gLQlmb3IgKGkgPSAwOyBp IDwgZWhkci0+ZV9zaG51bTsgaSsrLCBzaGRyKyspIHsKPj4gLQkJdTMyIHNpemUgPSBzaGRyLT5z aF9zaXplOwo+PiAtCQl1MzIgb2Zmc2V0ID0gc2hkci0+c2hfb2Zmc2V0Owo+PiAtCj4+IC0JCWlm IChzdHJjbXAobmFtZV90YWJsZSArIHNoZHItPnNoX25hbWUsICIucmVzb3VyY2VfdGFibGUiKSkK Pj4gKwkvKiBGaXJzdCwgZ2V0IHRoZSBzZWN0aW9uIGhlYWRlciBhY2NvcmRpbmcgdG8gdGhlIGVs ZiBjbGFzcyAqLwo+PiArCXNoZHIgPSBlbGZfZGF0YSArIGVsZl9oZHJfZV9zaG9mZihjbGFzcywg ZWhkcik7Cj4+ICsJLyogQ29tcHV0ZSBuYW1lIHRhYmxlIHNlY3Rpb24gaGVhZGVyIGVudHJ5IGlu IHNoZHIgYXJyYXkgKi8KPj4gKwluYW1lX3RhYmxlX3NoZHIgPSBzaGRyICsgKHNoc3RybmR4ICog ZWxmX3NoZHJfc2l6ZSk7Cj4+ICsJLyogRmluYWxseSwgY29tcHV0ZSB0aGUgbmFtZSB0YWJsZSBz ZWN0aW9uIGFkZHJlc3MgaW4gZWxmICovCj4+ICsJbmFtZV90YWJsZSA9IGVsZl9kYXRhICsgZWxm X3NoZHJfc2hfb2Zmc2V0KGNsYXNzLCBuYW1lX3RhYmxlX3NoZHIpOwo+PiArCj4+ICsJZm9yIChp ID0gMDsgaSA8IHNobnVtOyBpKyssIHNoZHIgKz0gZWxmX3NoZHJfc2l6ZSkgewo+PiArCQl1NjQg c2l6ZSA9IGVsZl9zaGRyX3NoX3NpemUoY2xhc3MsIHNoZHIpOwo+PiArCQl1NjQgb2Zmc2V0ID0g ZWxmX3NoZHJfc2hfb2Zmc2V0KGNsYXNzLCBzaGRyKTsKPj4gKwkJdTMyIG5hbWUgPSBlbGZfc2hk cl9zaF9uYW1lKGNsYXNzLCBzaGRyKTsKPj4gKwo+PiArCQlpZiAoc3RyY21wKG5hbWVfdGFibGUg KyBuYW1lLCAiLnJlc291cmNlX3RhYmxlIikpCj4+ICAJCQljb250aW51ZTsKPj4gIAo+PiAgCQl0 YWJsZSA9IChzdHJ1Y3QgcmVzb3VyY2VfdGFibGUgKikoZWxmX2RhdGEgKyBvZmZzZXQpOwo+PiBA QCAtMjcwLDIxICszMDUsMjEgQEAgZmluZF90YWJsZShzdHJ1Y3QgZGV2aWNlICpkZXYsIHN0cnVj dCBlbGYzMl9oZHIgKmVoZHIsCj4+IHNpemVfdCBmd19zaXplKQo+PiAgICovCj4+ICBpbnQgcnBy b2NfZWxmX2xvYWRfcnNjX3RhYmxlKHN0cnVjdCBycHJvYyAqcnByb2MsIGNvbnN0IHN0cnVjdCBm aXJtd2FyZSAqZncpCj4+ICB7Cj4+IC0Jc3RydWN0IGVsZjMyX2hkciAqZWhkcjsKPj4gLQlzdHJ1 Y3QgZWxmMzJfc2hkciAqc2hkcjsKPj4gKwljb25zdCB2b2lkICpzaGRyOwo+PiAgCXN0cnVjdCBk ZXZpY2UgKmRldiA9ICZycHJvYy0+ZGV2Owo+PiAgCXN0cnVjdCByZXNvdXJjZV90YWJsZSAqdGFi bGUgPSBOVUxMOwo+PiAgCWNvbnN0IHU4ICplbGZfZGF0YSA9IGZ3LT5kYXRhOwo+PiAgCXNpemVf dCB0YWJsZXN6Owo+PiArCXU4IGNsYXNzID0gZndfZWxmX2dldF9jbGFzcyhmdyk7Cj4+ICsJdTY0 IHNoX29mZnNldDsKPj4gIAo+PiAtCWVoZHIgPSAoc3RydWN0IGVsZjMyX2hkciAqKWVsZl9kYXRh Owo+PiAtCj4+IC0Jc2hkciA9IGZpbmRfdGFibGUoZGV2LCBlaGRyLCBmdy0+c2l6ZSk7Cj4+ICsJ c2hkciA9IGZpbmRfdGFibGUoZGV2LCBmdyk7Cj4+ICAJaWYgKCFzaGRyKQo+PiAgCQlyZXR1cm4g LUVJTlZBTDsKPj4gIAo+PiAtCXRhYmxlID0gKHN0cnVjdCByZXNvdXJjZV90YWJsZSAqKShlbGZf ZGF0YSArIHNoZHItPnNoX29mZnNldCk7Cj4+IC0JdGFibGVzeiA9IHNoZHItPnNoX3NpemU7Cj4+ ICsJc2hfb2Zmc2V0ID0gZWxmX3NoZHJfc2hfb2Zmc2V0KGNsYXNzLCBzaGRyKTsKPj4gKwl0YWJs ZSA9IChzdHJ1Y3QgcmVzb3VyY2VfdGFibGUgKikoZWxmX2RhdGEgKyBzaF9vZmZzZXQpOwo+PiAr CXRhYmxlc3ogPSBlbGZfc2hkcl9zaF9zaXplKGNsYXNzLCBzaGRyKTsKPj4gIAo+PiAgCS8qCj4+ ICAJICogQ3JlYXRlIGEgY29weSBvZiB0aGUgcmVzb3VyY2UgdGFibGUuIFdoZW4gYSB2aXJ0aW8g ZGV2aWNlIHN0YXJ0cwo+PiBAQCAtMzE3LDEzICszNTIsMTcgQEAgRVhQT1JUX1NZTUJPTChycHJv Y19lbGZfbG9hZF9yc2NfdGFibGUpOwo+PiAgc3RydWN0IHJlc291cmNlX3RhYmxlICpycHJvY19l bGZfZmluZF9sb2FkZWRfcnNjX3RhYmxlKHN0cnVjdCBycHJvYyAqcnByb2MsCj4+ICAJCQkJCQkg ICAgICAgY29uc3Qgc3RydWN0IGZpcm13YXJlICpmdykKPj4gIHsKPj4gLQlzdHJ1Y3QgZWxmMzJf aGRyICplaGRyID0gKHN0cnVjdCBlbGYzMl9oZHIgKilmdy0+ZGF0YTsKPj4gLQlzdHJ1Y3QgZWxm MzJfc2hkciAqc2hkcjsKPj4gKwljb25zdCB2b2lkICpzaGRyOwo+PiArCXU2NCBzaF9hZGRyLCBz aF9zaXplOwo+PiArCXU4IGNsYXNzID0gZndfZWxmX2dldF9jbGFzcyhmdyk7Cj4+ICAKPj4gLQlz aGRyID0gZmluZF90YWJsZSgmcnByb2MtPmRldiwgZWhkciwgZnctPnNpemUpOwo+PiArCXNoZHIg PSBmaW5kX3RhYmxlKCZycHJvYy0+ZGV2LCBmdyk7Cj4+ICAJaWYgKCFzaGRyKQo+PiAgCQlyZXR1 cm4gTlVMTDsKPj4gIAo+PiAtCXJldHVybiBycHJvY19kYV90b192YShycHJvYywgc2hkci0+c2hf YWRkciwgc2hkci0+c2hfc2l6ZSk7Cj4+ICsJc2hfYWRkciA9IGVsZl9zaGRyX3NoX2FkZHIoY2xh c3MsIHNoZHIpOwo+PiArCXNoX3NpemUgPSBlbGZfc2hkcl9zaF9zaXplKGNsYXNzLCBzaGRyKTsK Pj4gKwo+PiArCXJldHVybiBycHJvY19kYV90b192YShycHJvYywgc2hfYWRkciwgc2hfc2l6ZSk7 Cj4+ICB9Cj4+ICBFWFBPUlRfU1lNQk9MKHJwcm9jX2VsZl9maW5kX2xvYWRlZF9yc2NfdGFibGUp Owo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVycy9yZW1vdGVwcm9jL3JlbW90ZXByb2NfZWxmX2xvYWRl ci5oCj4+IGIvZHJpdmVycy9yZW1vdGVwcm9jL3JlbW90ZXByb2NfZWxmX2xvYWRlci5oCj4+IG5l dyBmaWxlIG1vZGUgMTAwNjQ0Cj4+IGluZGV4IDAwMDAwMDAwMDAwMC4uZmFjMzU2NTczNGY5Cj4+ IC0tLSAvZGV2L251bGwKPj4gKysrIGIvZHJpdmVycy9yZW1vdGVwcm9jL3JlbW90ZXByb2NfZWxm X2xvYWRlci5oCj4+IEBAIC0wLDAgKzEsNjkgQEAKPj4gKy8qIFNQRFgtTGljZW5zZS1JZGVudGlm aWVyOiBHUEwtMi4wICovCj4+ICsvKgo+PiArICogUmVtb3RlIHByb2Nlc3NvciBlbGYgbG9hZGVy IGRlZmluZXMKPj4gKyAqCj4+ICsgKiBDb3B5cmlnaHQgKEMpIDIwMTkgS2FscmF5LCBJbmMuCj4+ ICsgKi8KPj4gKwo+PiArI2lmbmRlZiBSRU1PVEVQUk9DX0VMRl9MT0FERVJfSAo+PiArI2RlZmlu ZSBSRU1PVEVQUk9DX0VMRl9MT0FERVJfSAo+PiArCj4+ICsjaW5jbHVkZSA8bGludXgvZWxmLmg+ Cj4+ICsjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KPj4gKwo+PiArLyoqCj4+ICsgKiBmd19lbGZf Z2V0X2NsYXNzIC0gR2V0IGVsZiBjbGFzcwo+PiArICogQGZ3OiB0aGUgRUxGIGZpcm13YXJlIGlt YWdlCj4+ICsgKgo+PiArICogTm90ZSB0aGF0IHdlIHVzZSBhbmQgZWxmMzJfaGRyIHRvIGFjY2Vz cyB0aGUgY2xhc3Mgc2luY2UgdGhlIHN0YXJ0IG9mIHRoZQo+PiArICogc3RydWN0IGlzIHRoZSBz YW1lIGZvciBib3RoIGVsZiBjbGFzcwo+PiArICoKPj4gKyAqIFJldHVybjogZWxmIGNsYXNzIG9m IHRoZSBmaXJtd2FyZQo+PiArICovCj4+ICtzdGF0aWMgaW5saW5lIHU4IGZ3X2VsZl9nZXRfY2xh c3MoY29uc3Qgc3RydWN0IGZpcm13YXJlICpmdykKPj4gK3sKPj4gKwlzdHJ1Y3QgZWxmMzJfaGRy ICplaGRyID0gKHN0cnVjdCBlbGYzMl9oZHIgKilmdy0+ZGF0YTsKPj4gKwo+PiArCXJldHVybiBl aGRyLT5lX2lkZW50W0VJX0NMQVNTXTsKPj4gK30KPj4gKwo+PiArI2RlZmluZSBFTEZfR0VUX0ZJ RUxEKF9fcywgX19maWVsZCwgX190eXBlKSBcCj4+ICtzdGF0aWMgaW5saW5lIF9fdHlwZSBlbGZf IyNfX3MjI18jI19fZmllbGQodTggY2xhc3MsIGNvbnN0IHZvaWQgKmFyZykgXAo+PiAreyBcCj4+ ICsJaWYgKGNsYXNzID09IEVMRkNMQVNTMzIpIFwKPj4gKwkJcmV0dXJuIChfX3R5cGUpICgoY29u c3Qgc3RydWN0IGVsZjMyXyMjX19zICopIGFyZyktPl9fZmllbGQ7IFwKPj4gKwllbHNlIFwKPj4g KwkJcmV0dXJuIChfX3R5cGUpICgoY29uc3Qgc3RydWN0IGVsZjY0XyMjX19zICopIGFyZyktPl9f ZmllbGQ7IFwKPj4gK30KPj4gKwo+PiArRUxGX0dFVF9GSUVMRChoZHIsIGVfZW50cnksIHU2NCkK Pj4gK0VMRl9HRVRfRklFTEQoaGRyLCBlX3BobnVtLCB1MTYpCj4+ICtFTEZfR0VUX0ZJRUxEKGhk ciwgZV9zaG51bSwgdTE2KQo+PiArRUxGX0dFVF9GSUVMRChoZHIsIGVfcGhvZmYsIHU2NCkKPj4g K0VMRl9HRVRfRklFTEQoaGRyLCBlX3Nob2ZmLCB1NjQpCj4+ICtFTEZfR0VUX0ZJRUxEKGhkciwg ZV9zaHN0cm5keCwgdTE2KQo+PiArCj4+ICtFTEZfR0VUX0ZJRUxEKHBoZHIsIHBfcGFkZHIsIHU2 NCkKPj4gK0VMRl9HRVRfRklFTEQocGhkciwgcF9maWxlc3osIHU2NCkKPj4gK0VMRl9HRVRfRklF TEQocGhkciwgcF9tZW1zeiwgdTY0KQo+PiArRUxGX0dFVF9GSUVMRChwaGRyLCBwX3R5cGUsIHUz MikKPj4gK0VMRl9HRVRfRklFTEQocGhkciwgcF9vZmZzZXQsIHU2NCkKPj4gKwo+PiArRUxGX0dF VF9GSUVMRChzaGRyLCBzaF9zaXplLCB1NjQpCj4+ICtFTEZfR0VUX0ZJRUxEKHNoZHIsIHNoX29m ZnNldCwgdTY0KQo+PiArRUxGX0dFVF9GSUVMRChzaGRyLCBzaF9uYW1lLCB1MzIpCj4+ICtFTEZf R0VUX0ZJRUxEKHNoZHIsIHNoX2FkZHIsIHU2NCkKPj4gKwo+PiArI2RlZmluZSBFTEZfU1RSVUNU X1NJWkUoX19zKSBcCj4+ICtzdGF0aWMgaW5saW5lIHVuc2lnbmVkIGxvbmcgZWxmX3NpemVfb2Zf IyNfX3ModTggY2xhc3MpIFwKPj4gK3sgXAo+PiArCWlmIChjbGFzcyA9PSBFTEZDTEFTUzMyKVwK Pj4gKwkJcmV0dXJuIHNpemVvZihzdHJ1Y3QgZWxmMzJfIyNfX3MpOyBcCj4+ICsJZWxzZSBcCj4+ ICsJCXJldHVybiBzaXplb2Yoc3RydWN0IGVsZjY0XyMjX19zKTsgXAo+PiArfQo+PiArCj4+ICtF TEZfU1RSVUNUX1NJWkUoc2hkcikKPj4gK0VMRl9TVFJVQ1RfU0laRShwaGRyKQo+PiArCj4+ICsj ZW5kaWYgLyogUkVNT1RFUFJPQ19FTEZfTE9BREVSX0ggKi8KPj4gZGlmZiAtLWdpdCBhL2RyaXZl cnMvcmVtb3RlcHJvYy9yZW1vdGVwcm9jX2ludGVybmFsLmgKPj4gYi9kcml2ZXJzL3JlbW90ZXBy b2MvcmVtb3RlcHJvY19pbnRlcm5hbC5oCj4+IGluZGV4IDAwNDg2NzA2MTcyMS4uZWViMjY0MzQy MjBlIDEwMDY0NAo+PiAtLS0gYS9kcml2ZXJzL3JlbW90ZXByb2MvcmVtb3RlcHJvY19pbnRlcm5h bC5oCj4+ICsrKyBiL2RyaXZlcnMvcmVtb3RlcHJvYy9yZW1vdGVwcm9jX2ludGVybmFsLmgKPj4g QEAgLTU1LDcgKzU1LDcgQEAgcGh5c19hZGRyX3QgcnByb2NfdmFfdG9fcGEodm9pZCAqY3B1X2Fk ZHIpOwo+PiAgaW50IHJwcm9jX3RyaWdnZXJfcmVjb3Zlcnkoc3RydWN0IHJwcm9jICpycHJvYyk7 Cj4+ICAKPj4gIGludCBycHJvY19lbGZfc2FuaXR5X2NoZWNrKHN0cnVjdCBycHJvYyAqcnByb2Ms IGNvbnN0IHN0cnVjdCBmaXJtd2FyZSAqZncpOwo+PiAtdTMyIHJwcm9jX2VsZl9nZXRfYm9vdF9h ZGRyKHN0cnVjdCBycHJvYyAqcnByb2MsIGNvbnN0IHN0cnVjdCBmaXJtd2FyZSAqZncpOwo+PiAr dTY0IHJwcm9jX2VsZl9nZXRfYm9vdF9hZGRyKHN0cnVjdCBycHJvYyAqcnByb2MsIGNvbnN0IHN0 cnVjdCBmaXJtd2FyZSAqZncpOwo+PiAgaW50IHJwcm9jX2VsZl9sb2FkX3NlZ21lbnRzKHN0cnVj dCBycHJvYyAqcnByb2MsIGNvbnN0IHN0cnVjdCBmaXJtd2FyZSAqZncpOwo+PiAgaW50IHJwcm9j X2VsZl9sb2FkX3JzY190YWJsZShzdHJ1Y3QgcnByb2MgKnJwcm9jLCBjb25zdCBzdHJ1Y3QgZmly bXdhcmUgKmZ3KTsKPj4gIHN0cnVjdCByZXNvdXJjZV90YWJsZSAqcnByb2NfZWxmX2ZpbmRfbG9h ZGVkX3JzY190YWJsZShzdHJ1Y3QgcnByb2MgKnJwcm9jLAo+PiBkaWZmIC0tZ2l0IGEvZHJpdmVy cy9yZW1vdGVwcm9jL3N0X3JlbW90ZXByb2MuYwo+PiBiL2RyaXZlcnMvcmVtb3RlcHJvYy9zdF9y ZW1vdGVwcm9jLmMKPj4gaW5kZXggZWUxM2QyM2I0M2E5Li5hMzI2OGQ5NWE1MGUgMTAwNjQ0Cj4+ IC0tLSBhL2RyaXZlcnMvcmVtb3RlcHJvYy9zdF9yZW1vdGVwcm9jLmMKPj4gKysrIGIvZHJpdmVy cy9yZW1vdGVwcm9jL3N0X3JlbW90ZXByb2MuYwo+PiBAQCAtMTkwLDcgKzE5MCw3IEBAIHN0YXRp YyBpbnQgc3RfcnByb2Nfc3RhcnQoc3RydWN0IHJwcm9jICpycHJvYykKPj4gIAkJfQo+PiAgCX0K Pj4gIAo+PiAtCWRldl9pbmZvKCZycHJvYy0+ZGV2LCAiU3RhcnRlZCBmcm9tIDB4JXhcbiIsIHJw cm9jLT5ib290YWRkcik7Cj4+ICsJZGV2X2luZm8oJnJwcm9jLT5kZXYsICJTdGFydGVkIGZyb20g MHglbGx4XG4iLCBycHJvYy0+Ym9vdGFkZHIpOwo+PiAgCj4+ICAJcmV0dXJuIDA7Cj4+ICAKPj4g ZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvcmVtb3RlcHJvYy5oIGIvaW5jbHVkZS9saW51eC9y ZW1vdGVwcm9jLmgKPj4gaW5kZXggZjg0YmQ1ZmUwMjExLi44MmNlYmNhOTM0NGMgMTAwNjQ0Cj4+ IC0tLSBhL2luY2x1ZGUvbGludXgvcmVtb3RlcHJvYy5oCj4+ICsrKyBiL2luY2x1ZGUvbGludXgv cmVtb3RlcHJvYy5oCj4+IEBAIC0zODIsNyArMzgyLDcgQEAgc3RydWN0IHJwcm9jX29wcyB7Cj4+ ICAJCQkJc3RydWN0IHJwcm9jICpycHJvYywgY29uc3Qgc3RydWN0IGZpcm13YXJlICpmdyk7Cj4+ ICAJaW50ICgqbG9hZCkoc3RydWN0IHJwcm9jICpycHJvYywgY29uc3Qgc3RydWN0IGZpcm13YXJl ICpmdyk7Cj4+ICAJaW50ICgqc2FuaXR5X2NoZWNrKShzdHJ1Y3QgcnByb2MgKnJwcm9jLCBjb25z dCBzdHJ1Y3QgZmlybXdhcmUgKmZ3KTsKPj4gLQl1MzIgKCpnZXRfYm9vdF9hZGRyKShzdHJ1Y3Qg cnByb2MgKnJwcm9jLCBjb25zdCBzdHJ1Y3QgZmlybXdhcmUgKmZ3KTsKPj4gKwl1NjQgKCpnZXRf Ym9vdF9hZGRyKShzdHJ1Y3QgcnByb2MgKnJwcm9jLCBjb25zdCBzdHJ1Y3QgZmlybXdhcmUgKmZ3 KTsKPj4gIH07Cj4+ICAKPj4gIC8qKgo+PiBAQCAtNDk4LDcgKzQ5OCw3IEBAIHN0cnVjdCBycHJv YyB7Cj4+ICAJaW50IG51bV90cmFjZXM7Cj4+ICAJc3RydWN0IGxpc3RfaGVhZCBjYXJ2ZW91dHM7 Cj4+ICAJc3RydWN0IGxpc3RfaGVhZCBtYXBwaW5nczsKPj4gLQl1MzIgYm9vdGFkZHI7Cj4+ICsJ dTY0IGJvb3RhZGRyOwo+IAo+IFRoYXQgd2lsbCBjYXVzZSBwcm9ibGVtcyBmb3IgcnByb2NfY29y ZWR1bXAoKVsxXSBhbmQgZml4aW5nIGl0IHByb3Blcmx5Cj4gbGlrZWx5IG1lYW5zIHRoYXQgYSAz MiBvciA2NCBlbGYgc2hvdWxkIGJlIGdlbmVyYXRlZCBiYXNlZCBvbiB0aGUgdHlwZSBvZiBpbWFn ZQo+IHRoYXQgd2FzIGxvYWRlZC4gIFRoaXMgaXMgYWxzbyB0cnVlIGlmIC0+cF92YWRkciBhbmQg LT5wX3BhZGRyIChhbHNvIGluIHRoZSBzYW1lCj4gZnVuY3Rpb24pIGFyZSB0byBiZSBoYW5kbGVk IHByb3Blcmx5Lgo+IAo+IEknbSBpbnRlcmVzdGVkIGluIHlvdXIgb3BpbmlvbiBvbiB0aGlzLgoK SW5kZWVkLCB5b3UgYXJlIHJpZ2h0ICEKCkknbSAiYWZyYWlkIiBJIHdpbGwgaGF2ZSB0byBmaXgg dGhhdCAhCk1vc3Qgc2FuZSB0aGluZyB0byBkbyBpcyB0byBkdW1wIGFuIGVsZiB3aXRoIHRoZSBp bnB1dCBlbGYgY2xhc3MuCkkgd2lsbCBtYWtlIGEgVjQgd2l0aCBhIHBhdGNoIGZvciB0aGF0LgoK VGhhbmtzLAoKQ2zDqW1lbnQKCj4gCj4gVGhhbmtzLAo+IE1hdGhpZXUKPiAKPiBbMV0uCj4gaHR0 cHM6Ly9lbGl4aXIuYm9vdGxpbi5jb20vbGludXgvbGF0ZXN0L3NvdXJjZS9kcml2ZXJzL3JlbW90 ZXByb2MvcmVtb3RlcHJvY19jb3JlLmMjTDE2MDAKPiAKPj4gIAlzdHJ1Y3QgbGlzdF9oZWFkIHJ2 ZGV2czsKPj4gIAlzdHJ1Y3QgbGlzdF9oZWFkIHN1YmRldnM7Cj4+ICAJc3RydWN0IGlkciBub3Rp ZnlpZHM7Cj4+IC0tCj4+IDIuMTUuMC4yNzYuZzg5ZWE3OTkKCl9fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fCmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0 CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5mcmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFk ZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xpbnV4LWFybS1rZXJuZWwK