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=-7.1 required=3.0 tests=DKIMWL_WL_HIGH,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, UNWANTED_LANGUAGE_BODY,USER_AGENT_GIT autolearn=ham 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 9F8C7C433DF for ; Mon, 1 Jun 2020 14:28:25 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 6A9262068D for ; Mon, 1 Jun 2020 14:28:25 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="NxOgmo5l" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727815AbgFAO2Y (ORCPT ); Mon, 1 Jun 2020 10:28:24 -0400 Received: from mailout1.w1.samsung.com ([210.118.77.11]:55359 "EHLO mailout1.w1.samsung.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727000AbgFAO2O (ORCPT ); Mon, 1 Jun 2020 10:28:14 -0400 Received: from eucas1p2.samsung.com (unknown [182.198.249.207]) by mailout1.w1.samsung.com (KnoxPortal) with ESMTP id 20200601142812euoutp0118ff54af71a1e510b2fb793ce693be81~UccypCv_R1115911159euoutp01I for ; Mon, 1 Jun 2020 14:28:12 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout1.w1.samsung.com 20200601142812euoutp0118ff54af71a1e510b2fb793ce693be81~UccypCv_R1115911159euoutp01I DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1591021692; bh=W1N0pk+zwBpYOwOEoTj035sNHYsI+JRLIt8m73+L2QA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=NxOgmo5l6KH+BlcTdKT9jtRcRDzyoS+l8jVjqZX+44PUCVV0lmGBCWZKG7SiFtUsA s6pFG2SNRQXK6idAXQtZHL6Z6h4qFfvXu0g3Y1v8sfPVVmooCE2LWt+IF/Q4LWnJ8I AUbhL4eoC5OisqIL59kUYCte+H4qCNMtcs7z5PR4= Received: from eusmges3new.samsung.com (unknown [203.254.199.245]) by eucas1p2.samsung.com (KnoxPortal) with ESMTP id 20200601142811eucas1p2cfb8d4a2932683df1904664cb20905bd~UccyVyu-51927019270eucas1p2h; Mon, 1 Jun 2020 14:28:11 +0000 (GMT) Received: from eucas1p2.samsung.com ( [182.198.249.207]) by eusmges3new.samsung.com (EUCPMTA) with SMTP id 6F.6D.60698.B7015DE5; Mon, 1 Jun 2020 15:28:11 +0100 (BST) Received: from eusmtrp1.samsung.com (unknown [182.198.249.138]) by eucas1p1.samsung.com (KnoxPortal) with ESMTPA id 20200601142811eucas1p1604c8e6ca06c09f1ec821ea5e1918c53~UccyCywhV2463924639eucas1p1s; Mon, 1 Jun 2020 14:28:11 +0000 (GMT) Received: from eusmgms2.samsung.com (unknown [182.198.249.180]) by eusmtrp1.samsung.com (KnoxPortal) with ESMTP id 20200601142811eusmtrp124c99c66d75d0868cf5e64e0be948c7b~UccyB7wtx3017330173eusmtrp1k; Mon, 1 Jun 2020 14:28:11 +0000 (GMT) X-AuditID: cbfec7f5-a29ff7000001ed1a-e3-5ed5107b84ac Received: from eusmtip1.samsung.com ( [203.254.199.221]) by eusmgms2.samsung.com (EUCPMTA) with SMTP id 53.FB.07950.B7015DE5; Mon, 1 Jun 2020 15:28:11 +0100 (BST) Received: from localhost (unknown [106.120.51.46]) by eusmtip1.samsung.com (KnoxPortal) with ESMTPA id 20200601142811eusmtip150f76db6f64f8a7d964f5310398f8b42~Uccx3HTOv1539715397eusmtip1n; Mon, 1 Jun 2020 14:28:11 +0000 (GMT) From: =?UTF-8?q?=C5=81ukasz=20Stelmach?= To: Russell King , Masahiro Yamada , Nick Desaulniers , Thomas Gleixner , Enrico Weigelt , Kees Cook , Ingo Molnar , Ben Dooks , linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Cc: AKASHI Takahiro , Bartlomiej Zolnierkiewicz , Marek Szyprowski , =?UTF-8?q?=C5=81ukasz=20Stelmach?= Subject: [PATCH 5/5] arm: kexec_file: load zImage or uImage, initrd and dtb Date: Mon, 1 Jun 2020 16:27:54 +0200 Message-Id: <20200601142754.26139-6-l.stelmach@samsung.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20200601142754.26139-1-l.stelmach@samsung.com> MIME-Version: 1.0 Organization: Samsung R&D Institute Poland Content-Transfer-Encoding: 8bit X-Brightmail-Tracker: H4sIAAAAAAAAA02Sa0hTYRjHe89tR2t2nIZPFoZDSYW0WNkBpbQLnArKL32JspYdTNwsdrKy m1rmvfKCadsgSa1ly3TqKrOUlZotl2KZ0dVUSlEJS7p5ye0o+e3/PM/v//zfB14al30gPemY uCO8Jk6pklPOhLn594sVJ5lXkSuNTQq2qugOyeZVNGLsm+QHGPs8S82+sRgQa+rtItnOOj3F WgoeIvb2k/cStudTN8nemnyG2G85Uxg73vCbYKtNBXiYC9fZ1YFzuqQOgpso/4pzxaZ4zlSe QXHvuuopbsRmk3DVpYlczrdhirtYU4647yaviPm7nEMP8KqYo7wmaN0+54NZNy/ih39q0fGR yRNJqPFUJnKigVkN5wwPsUzkTMsYAwJr0+WZ4geCTlvtTPEdweOhfGrWYrzSTomDGwgm+nMl YvEFwdvP9zE7RTHhcKnsKWkfuDNjGNQVpDksOPMSQU+D2UG5Mdsgo6TCsZdgfEGbm0/atZQJ gfuPinExbxmk3bjrYJyYUGi0jmIi4wqtV/oIu17IBIDx7GuHxqf5c7U63B4GTC4NhtQpUly0 Ccx3R2e0Gwy21EhEvRSs+dnTZnpaJ0J+XrDozUZg1v8iRCYE3tn+UHYGZ/zhTl2Q2A6Hs5lt pGh1ge5hV/EJLpBnLsTFthTSU2Ui7QMVl+pnFnrChUEDykFy7ZxjtHMO0P7PKkZ4OfLg4wV1 NC8o4vhjgYJSLcTHRQdGHVKb0PSvs062jN1Dj8b3WxBDI/kCaeXHl5EyUnlUSFBbENC43F26 oc0aKZMeUCac4DWH9mriVbxgQUtoQu4hVVwb2CNjopVH+FieP8xrZqcY7eSZhAqM+8eMPr69 QSkSzWL58/WVNesGyOWvhyXeZSu39PvsvBnr/+dxFKCi5qKeDjSxcZcq9sfe0+1eRKXOP0oR vKbQ+9bfeX7VDQoDNhR+veq2rr8wL4xepNs+WfKlr9Rd2F2yo7UtfHO6d4rfmeSWhOuJWyPa h9YWnz+lr9YHPbnqKyeEg8pVAbhGUP4DHJ8LRXEDAAA= X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFnrDIsWRmVeSWpSXmKPExsVy+t/xu7rVAlfjDKbclbXYOGM9q8WkdQeY LG427mayONOda3Hz0ApGi02Pr7FaXN41h83i0NS9jBZrj9xlt3j44Aarxep/pxgtPkz4z2Tx Z/9PFovNm6YyO/B5XL52kdljdsNFFo+/q14weyzYVOqxaVUnm8eda3vYPN6dO8fusXlJvceE D2/ZPPq2rGL0+LxJLoA7Ss+mKL+0JFUhI7+4xFYp2tDCSM/Q0kLPyMRSz9DYPNbKyFRJ384m JTUnsyy1SN8uQS+je2Ufc8H3WYwV7/5VNTAeqOli5OSQEDCRWDPzAhuILSSwlFFiyhLrLkYO oLiUxMq56RAlwhJ/rnVBlTxllLi0wR7EZhNwlOhfeoK1i5GLQ0TgL5PEwVmn2UAcZoFrjBIb J5xkBqkSFvCW6Fy8DqybRUBVYtbEyawgNq+AtcTOfQuYITbIS7Qv3w5WwylgI3Hg9CcmiG3W Eu+ndTNB1AtKnJz5hAXkOGYBdYn184RAwvwCWhJrmq6zgNjMQGOat85mnsAoNAtJxyyEjllI qhYwMq9iFEktLc5Nzy020itOzC0uzUvXS87P3cQIjOltx35u2cHY9S74EKMAB6MSD++G+1fi hFgTy4orcw8xSnAwK4nwOp09HSfEm5JYWZValB9fVJqTWnyI0RTozYnMUqLJ+cB0k1cSb2hq aG5haWhubG5sZqEkztshcDBGSCA9sSQ1OzW1ILUIpo+Jg1OqgbGMZ/qyvdceq/oUP7I5wnDk dGvoOd3gOV5WdkGhz5QsDp/6ZPevyXtbun522ked9ytebE6bZP1Z+E9L9Qv3wtXrfR6afVas ELz24Viv5I93G+a1TeHk3KIhn5ZTn23mY8+90kov4piP6eIsxp6Pb1nVltQ9dMtw091zcafa mX8e1YerOS28LymxFGckGmoxFxUnAgDYjMeB/wIAAA== X-CMS-MailID: 20200601142811eucas1p1604c8e6ca06c09f1ec821ea5e1918c53 X-Msg-Generator: CA Content-Type: text/plain; charset="utf-8" X-RootMTR: 20200601142811eucas1p1604c8e6ca06c09f1ec821ea5e1918c53 X-EPHeader: CA CMS-TYPE: 201P X-CMS-RootMailID: 20200601142811eucas1p1604c8e6ca06c09f1ec821ea5e1918c53 References: <20200601142754.26139-1-l.stelmach@samsung.com> Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This is kexec_file_load implementation for ARM. It loads zImage and initrd from file descripters and resuses DTB. Most code is derived from arm64 kexec_file_load implementation and from kexec-tools. Cc: AKASHI Takahiro Signed-off-by: Łukasz Stelmach --- arch/arm/Kconfig | 15 ++ arch/arm/include/asm/image.h | 26 ++++ arch/arm/include/asm/kexec.h | 14 ++ arch/arm/kernel/Makefile | 5 +- arch/arm/kernel/kexec_uimage.c | 80 ++++++++++ arch/arm/kernel/kexec_zimage.c | 199 +++++++++++++++++++++++++ arch/arm/kernel/machine_kexec.c | 11 +- arch/arm/kernel/machine_kexec_file.c | 209 +++++++++++++++++++++++++++ 8 files changed, 554 insertions(+), 5 deletions(-) create mode 100644 arch/arm/kernel/kexec_uimage.c create mode 100644 arch/arm/kernel/kexec_zimage.c create mode 100644 arch/arm/kernel/machine_kexec_file.c diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig index c77c93c485a0..6adb849cb304 100644 --- a/arch/arm/Kconfig +++ b/arch/arm/Kconfig @@ -1917,6 +1917,21 @@ config KEXEC is properly shutdown, so do not be surprised if this code does not initially work for you. +config KEXEC_FILE + bool "Kexec file based system call (EXPERIMENTAL)" + depends on (!SMP || PM_SLEEP_SMP) + depends on USE_OF + select KEXEC_CORE + select CRC32 + help + This is new version of kexec system call. This system call is + file based and takes file descriptors as system call argument + for kernel and initramfs as opposed to list of segments as + accepted by previous system call. + + The kernel to be loaded MUST support Flattened Device Tree + (selected with CONFIG_USE_OF). + config ATAGS_PROC bool "Export atags in procfs" depends on ATAGS && KEXEC diff --git a/arch/arm/include/asm/image.h b/arch/arm/include/asm/image.h index 624438740f23..95f23837b04f 100644 --- a/arch/arm/include/asm/image.h +++ b/arch/arm/include/asm/image.h @@ -8,8 +8,13 @@ (((x) >> 8) & 0x0000ff00) | \ (((x) << 8) & 0x00ff0000) | \ (((x) << 24) & 0xff000000)) +#define UIMAGE_MAGIC(x) (x) #else #define ZIMAGE_MAGIC(x) (x) +#define UIMAGE_MAGIC(x) ((((x) >> 24) & 0x000000ff) | \ + (((x) >> 8) & 0x0000ff00) | \ + (((x) << 8) & 0x00ff0000) | \ + (((x) << 24) & 0xff000000)) #endif #define ARM_ZIMAGE_MAGIC1 ZIMAGE_MAGIC(0x016f2818) @@ -17,6 +22,12 @@ #define ARM_ZIMAGE_MAGIC3 ZIMAGE_MAGIC(0x5a534c4b) #define ARM_ZIMAGE_MAGIC4 ZIMAGE_MAGIC(0x5a534344) +#define ARM_UIMAGE_MAGIC UIMAGE_MAGIC(0x27051956) +#define ARM_UIMAGE_NAME_LEN 32 +#define ARM_UIMAGE_TYPE_KERNEL 2 +#define ARM_UIMAGE_TYPE_KERNEL_NOLOAD 14 +#define ARM_UIMAGE_ARCH_ARM 2 + #ifndef __ASSEMBLY__ #include @@ -33,6 +44,21 @@ struct arm_zimage_header { __le32 extension_tag_offset; }; +struct arm_uimage_header { + __be32 magic; + __be32 hdr_crc; + __be32 time; + __be32 size; + __be32 load; + __be32 entry; + __be32 crc; + __u8 os; + __u8 arch; + __u8 type; + __u8 comp; + __u8 name[ARM_UIMAGE_NAME_LEN]; +}; + struct arm_zimage_tag { struct tag_header hdr; union { diff --git a/arch/arm/include/asm/kexec.h b/arch/arm/include/asm/kexec.h index 22751b5b5735..fda35afa7195 100644 --- a/arch/arm/include/asm/kexec.h +++ b/arch/arm/include/asm/kexec.h @@ -83,6 +83,20 @@ static inline struct page *boot_pfn_to_page(unsigned long boot_pfn) } #define boot_pfn_to_page boot_pfn_to_page +#ifdef CONFIG_KEXEC_FILE + +extern const struct kexec_file_ops kexec_zimage_ops; +extern const struct kexec_file_ops kexec_uimage_ops; + +struct kimage; + +extern int load_other_segments(struct kimage *image, + unsigned long kernel_load_addr, unsigned long kernel_size, + char *initrd, unsigned long initrd_len, + unsigned long initrd_offset, char *cmdline); + +#endif /* CONFIG_KEXEC_FILE */ + #endif /* __ASSEMBLY__ */ #endif /* CONFIG_KEXEC */ diff --git a/arch/arm/kernel/Makefile b/arch/arm/kernel/Makefile index 89e5d864e923..466c683bb551 100644 --- a/arch/arm/kernel/Makefile +++ b/arch/arm/kernel/Makefile @@ -3,6 +3,7 @@ # Makefile for the linux kernel. # +CFLAGS_kexec_zimage.o := -DTEXT_OFFSET=$(TEXT_OFFSET) CPPFLAGS_vmlinux.lds := -DTEXT_OFFSET=$(TEXT_OFFSET) AFLAGS_head.o := -DTEXT_OFFSET=$(TEXT_OFFSET) @@ -56,7 +57,9 @@ obj-$(CONFIG_FUNCTION_TRACER) += entry-ftrace.o obj-$(CONFIG_DYNAMIC_FTRACE) += ftrace.o insn.o patch.o obj-$(CONFIG_FUNCTION_GRAPH_TRACER) += ftrace.o insn.o patch.o obj-$(CONFIG_JUMP_LABEL) += jump_label.o insn.o patch.o -obj-$(CONFIG_KEXEC) += machine_kexec.o relocate_kernel.o +obj-$(CONFIG_KEXEC_CORE) += machine_kexec.o relocate_kernel.o +obj-$(CONFIG_KEXEC_FILE) += machine_kexec_file.o kexec_zimage.o \ + kexec_uimage.o # Main staffs in KPROBES are in arch/arm/probes/ . obj-$(CONFIG_KPROBES) += patch.o insn.o obj-$(CONFIG_OABI_COMPAT) += sys_oabi-compat.o diff --git a/arch/arm/kernel/kexec_uimage.c b/arch/arm/kernel/kexec_uimage.c new file mode 100644 index 000000000000..47033574e24e --- /dev/null +++ b/arch/arm/kernel/kexec_uimage.c @@ -0,0 +1,80 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Kexec uImage loader + * + * Copyright (C) 2020 Samsung Electronics + * Author: Łukasz Stelmach + */ + +#define pr_fmt(fmt) "kexec_file(uImage): " fmt + +#include +#include +#include +#include + +#define crc32_ones(crc, buf, len) \ + (crc32(crc ^ 0xffffffff, buf, len) ^ 0xffffffff) + +static int uimage_probe(const char *uimage_buf, unsigned long uimage_len) +{ + const struct arm_uimage_header *h = + (struct arm_uimage_header *) uimage_buf; + struct arm_uimage_header uhdr; + unsigned long zoff = sizeof(struct arm_uimage_header); + uint32_t crc; + + if (h->magic != ARM_UIMAGE_MAGIC) + return -EINVAL; + + if (h->type != ARM_UIMAGE_TYPE_KERNEL && + h->type != ARM_UIMAGE_TYPE_KERNEL_NOLOAD){ + pr_debug("Invalid image type: %d\n", h->type); + return -EINVAL; + } + + if (h->arch != ARM_UIMAGE_ARCH_ARM) { + pr_debug("Invalidy image arch: %d\n", h->arch); + return -EINVAL; + } + + memcpy((char *)&uhdr, h, sizeof(uhdr)); + crc = be32_to_cpu(uhdr.hdr_crc); + uhdr.hdr_crc = 0; + + if (crc32_ones(0, (char *)&uhdr, sizeof(uhdr)) != crc) { + pr_debug("Corrupt header, CRC do not match\n"); + return -EINVAL; + } + + crc = be32_to_cpu(uhdr.crc); + if (crc32_ones(0, uimage_buf + zoff, uimage_len - zoff) != crc) { + pr_debug("Corrupt zImage, CRC do not match\n"); + return -EINVAL; + } + + return kexec_zimage_ops.probe(uimage_buf + zoff, + uimage_len - zoff); +} + +static void *uimage_load(struct kimage *image, + char *uimage, unsigned long uimage_len, + char *initrd, unsigned long initrd_len, + char *cmdline, unsigned long cmdline_len) +{ + const struct arm_uimage_header *h = + (struct arm_uimage_header *) uimage; + unsigned long zimage_offset = sizeof(struct arm_uimage_header); + + pr_debug("Loading uImage"); + return kexec_zimage_ops.load(image, + uimage + zimage_offset, + uimage_len - zimage_offset, + initrd, initrd_len, + cmdline, cmdline_len); +} + +const struct kexec_file_ops kexec_uimage_ops = { + .probe = uimage_probe, + .load = uimage_load, +}; diff --git a/arch/arm/kernel/kexec_zimage.c b/arch/arm/kernel/kexec_zimage.c new file mode 100644 index 000000000000..d09795fc9072 --- /dev/null +++ b/arch/arm/kernel/kexec_zimage.c @@ -0,0 +1,199 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Kexec zImage loader + * + * Copyright (C) 2020 Samsung Electronics + * Author: Łukasz Stelmach + */ + +#define pr_fmt(fmt) "kexec_file(zImage): " fmt + +#include +#include +#include +#include +#include + +#define byte_size(t) ((t)->hdr.size << 2) + +static const void *find_extension_tag(const char *buf, + unsigned long len, + uint32_t tag_id) +{ + const struct arm_zimage_header *h = (const struct arm_zimage_header *)buf; + const struct arm_zimage_tag *tag; + uint32_t offset, size; + uint32_t max = len - sizeof(struct tag_header); + + if (len < sizeof(*h) || + h->magic != ARM_ZIMAGE_MAGIC1 || + h->magic2 != ARM_ZIMAGE_MAGIC2) + return NULL; + + for (offset = h->extension_tag_offset; + (tag = (void *)(buf + offset)) != NULL && + offset < max && + (size = le32_to_cpu(byte_size(tag))) != 0 && + offset + size < len; + offset += size) { + pr_debug(" offset 0x%08x tag 0x%08x size %u\n", + offset, le32_to_cpu(tag->hdr.tag), size); + if (tag->hdr.tag == tag_id) + return tag; + } + + return NULL; +} + +static int zimage_probe(const char *kernel_buf, unsigned long kernel_len) +{ + const struct arm_zimage_header *h = + (struct arm_zimage_header *)(kernel_buf); + + if (!h || (kernel_len < sizeof(*h))) + return -EINVAL; + + if ((h->magic != ARM_ZIMAGE_MAGIC1) || + (h->magic2 != ARM_ZIMAGE_MAGIC2)) + return -EINVAL; + + return 0; +} + + +#if defined(DEBUG) +#define debug_offsets() ({ \ + pr_debug("Image offsets:\n"); \ + pr_debug(" kernel 0x%08lx 0x%08lx\n", kernel_offset, kernel_len); \ + pr_debug(" zimage 0x%08lx 0x%08lx\n", zimage_offset, zimage_len); \ + pr_debug(" initrd 0x%08lx 0x%08lx\n", initrd_offset, initrd_len); \ +}) +#else +#define debug_offsets() +#endif + +static void *zimage_load(struct kimage *image, + char *zimage, unsigned long zimage_len, + char *initrd, unsigned long initrd_len, + char *cmdline, unsigned long cmdline_len) +{ + struct arm_zimage_header *h; + struct kexec_buf kbuf; + struct kexec_segment *zimage_segment; + const struct arm_zimage_tag *klsz_tag; + const struct arm_zimage_tag_dc *dcsz_tag; + int ret = -EINVAL; + + unsigned long zimage_mem = 0x20000; /* malloc 64kB + stack 4 kB + some bss */ + unsigned long kernel_len = zimage_len * 4; /* 4:1 compression */ + unsigned long kernel_offset = memblock_start_of_DRAM() + + ALIGN(TEXT_OFFSET, PAGE_SIZE); + unsigned long zimage_offset = kernel_offset + + ALIGN(kernel_len, PAGE_SIZE); + unsigned long initrd_offset = zimage_offset + + ALIGN(zimage_len + zimage_mem, PAGE_SIZE); + + if (image->type == KEXEC_TYPE_CRASH) { + kernel_offset += crashk_res.start; + zimage_offset += crashk_res.start; + initrd_offset += crashk_res.start; + } + debug_offsets(); + + h = (struct arm_zimage_header *)zimage; + + klsz_tag = find_extension_tag(zimage, zimage_len, ZIMAGE_TAG_KRNL_SIZE); + if (klsz_tag) { + uint32_t *p = (void *)zimage + + le32_to_cpu(klsz_tag->u.krnl_size.size_ptr); + uint32_t edata_size = le32_to_cpu(get_unaligned(p)); + uint32_t bss_size = le32_to_cpu(klsz_tag->u.krnl_size.bss_size); + + kernel_len = edata_size + bss_size; + + pr_debug("Decompressed kernel sizes:\n"); + pr_debug(" text+data 0x%08lx bss 0x%08lx total 0x%08lx\n", + (unsigned long)edata_size, + (unsigned long)bss_size, + (unsigned long)kernel_len); + + zimage_offset = kernel_offset + ALIGN(edata_size, PAGE_SIZE); + initrd_offset = zimage_offset + + max(ALIGN(zimage_len + 0x20000, PAGE_SIZE), + ALIGN((unsigned long)bss_size, PAGE_SIZE)); + debug_offsets(); + } + + dcsz_tag = find_extension_tag(zimage, zimage_len, + ZIMAGE_TAG_DECOMP_SIZE); + if (dcsz_tag) { + uint32_t bss_size = le32_to_cpu(dcsz_tag->u.decomp_size.bss_size); + uint32_t stack_size = le32_to_cpu(dcsz_tag->u.decomp_size.stack_size); + uint32_t malloc_size = le32_to_cpu(dcsz_tag->u.decomp_size.malloc_size); + + zimage_mem = bss_size + stack_size + malloc_size; + + pr_debug("Decompressor memory requirements:\n"); + pr_debug(" bss 0x%08lx stack 0x%08lx malloc 0x%08lx total 0x%08lx\n", + (unsigned long)bss_size, + (unsigned long)stack_size, + (unsigned long)malloc_size, + zimage_mem); + + initrd_offset = max(ALIGN(zimage_offset + zimage_len + + bss_size + stack_size + + malloc_size, PAGE_SIZE), + ALIGN(kernel_offset + kernel_len, PAGE_SIZE)); + debug_offsets(); + } + + /* + * zImage MUST be loaded into the first 128 MiB of physical + * memory for proper memory detection. Should the uncompressed + * kernel be larger than 128 MiB, zImage relocation becomes + * unavoidable and it is best to rely on the relocation code. + */ + if (((zimage_offset - kernel_offset) + PAGE_SIZE + 0x8000) >= SZ_128M) { + pr_debug("The kernel is too big (%ld MiB) to avoid " + "zImage relocation. Loading zimage at 0x%08lx\n", + ((zimage_offset - kernel_offset) >> 20), + kernel_offset); + zimage_offset = kernel_offset; + } + + kbuf.image = image; + kbuf.top_down = false; + + kbuf.buf_min = zimage_offset; + kbuf.buf_max = ULONG_MAX; + kbuf.buffer = zimage; + kbuf.bufsz = zimage_len; + kbuf.buf_align = PAGE_SIZE; + + kbuf.mem = KEXEC_BUF_MEM_UNKNOWN; + kbuf.memsz = zimage_len; + + ret = kexec_add_buffer(&kbuf); + if (ret) + return ERR_PTR(ret); + + pr_debug("Loaded zImage at 0x%lx bufsz=0x%lx memsz=0x%lx\n", + kbuf.mem, kbuf.bufsz, kbuf.memsz); + + initrd_offset += kbuf.mem - zimage_offset; + debug_offsets(); + + zimage_segment = &image->segment[image->nr_segments - 1]; + image->start = zimage_segment->mem; + + ret = load_other_segments(image, + zimage_segment->mem, zimage_segment->memsz, + initrd, initrd_len, initrd_offset, + cmdline); + return ERR_PTR(ret); +} + +const struct kexec_file_ops kexec_zimage_ops = { + .probe = zimage_probe, + .load = zimage_load, +}; diff --git a/arch/arm/kernel/machine_kexec.c b/arch/arm/kernel/machine_kexec.c index c10a2dfd53d1..2e4780efabb4 100644 --- a/arch/arm/kernel/machine_kexec.c +++ b/arch/arm/kernel/machine_kexec.c @@ -93,10 +93,13 @@ int machine_kexec_prepare(struct kimage *image) current_segment->memsz)) return -EINVAL; - err = get_user(header, (__be32*)current_segment->buf); - if (err) - return err; - + if (image->file_mode) { + header = *(__be32 *)current_segment->buf; + } else { + err = get_user(header, (__be32 *)current_segment->buf); + if (err) + return err; + } if (header == cpu_to_be32(OF_DT_HEADER)) image->arch.kernel_r2 = current_segment->mem; } diff --git a/arch/arm/kernel/machine_kexec_file.c b/arch/arm/kernel/machine_kexec_file.c new file mode 100644 index 000000000000..ead680f1e795 --- /dev/null +++ b/arch/arm/kernel/machine_kexec_file.c @@ -0,0 +1,209 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * kexec_file for arm + * + * Copyright (C) 2018 Linaro Limited + * Copyright (C) 2020 Samsung Electronics + * Authors: + * AKASHI Takahiro + * Łukasz Stelmach + * + */ + +#define pr_fmt(fmt) "kexec_file: " fmt + +#include +#include +#include +#include + +/* relevant device tree properties */ +#define FDT_PROP_INITRD_START "linux,initrd-start" +#define FDT_PROP_INITRD_END "linux,initrd-end" +#define FDT_PROP_BOOTARGS "bootargs" +#define FDT_PROP_RNG_SEED "rng-seed" + +static int setup_dtb(struct kimage *image, + unsigned long initrd_load_addr, unsigned long initrd_len, + char *cmdline, void *dtb) +{ + int off, ret; + + ret = fdt_path_offset(dtb, "/chosen"); + if (ret < 0) + goto out; + + off = ret; + + /* add bootargs */ + if (cmdline) { + ret = fdt_setprop_string(dtb, off, FDT_PROP_BOOTARGS, cmdline); + if (ret) + goto out; + } else { + ret = fdt_delprop(dtb, off, FDT_PROP_BOOTARGS); + if (ret && (ret != -FDT_ERR_NOTFOUND)) + goto out; + } + + /* add initrd-* */ + if (initrd_load_addr) { + ret = fdt_setprop_u64(dtb, off, FDT_PROP_INITRD_START, + initrd_load_addr); + if (ret) + goto out; + + ret = fdt_setprop_u64(dtb, off, FDT_PROP_INITRD_END, + initrd_load_addr + initrd_len); + if (ret) + goto out; + } else { + ret = fdt_delprop(dtb, off, FDT_PROP_INITRD_START); + if (ret && (ret != -FDT_ERR_NOTFOUND)) + goto out; + + ret = fdt_delprop(dtb, off, FDT_PROP_INITRD_END); + if (ret && (ret != -FDT_ERR_NOTFOUND)) + goto out; + } + + /* add rng-seed */ + if (rng_is_initialized()) { + char seed[128]; + get_random_bytes(seed, sizeof(seed)); + + ret = fdt_setprop(dtb, off, FDT_PROP_RNG_SEED, + seed, sizeof(seed)); + if (ret) + goto out; + } else { + pr_notice("RNG is not initialised: omitting \"%s\" property\n", + FDT_PROP_RNG_SEED); + ret = 0; + } + +out: + if (ret) + return (ret == -FDT_ERR_NOSPACE) ? -ENOMEM : -EINVAL; + + return 0; +} +/* + * More space needed so that we can add initrd, bootargs and kaslr-seed. + */ +#define DTB_EXTRA_SPACE 0x1000 + +static int create_dtb(struct kimage *image, + unsigned long initrd_load_addr, unsigned long initrd_len, + char *cmdline, void **dtb) +{ + void *buf; + size_t buf_size; + size_t cmdline_len; + int ret; + + cmdline_len = cmdline ? strlen(cmdline) : 0; + buf_size = fdt_totalsize(initial_boot_params) + + cmdline_len + DTB_EXTRA_SPACE; + + for (;;) { + buf = vmalloc(buf_size); + if (!buf) + return -ENOMEM; + + /* duplicate a device tree blob */ + ret = fdt_open_into(initial_boot_params, buf, buf_size); + if (ret) + return -EINVAL; + + ret = setup_dtb(image, initrd_load_addr, initrd_len, + cmdline, buf); + if (ret) { + vfree(buf); + if (ret == -ENOMEM) { + /* unlikely, but just in case */ + buf_size += DTB_EXTRA_SPACE; + continue; + } else { + return ret; + } + } + + /* trim it */ + fdt_pack(buf); + *dtb = buf; + + return 0; + } +} + +int load_other_segments(struct kimage *image, + unsigned long zimage_load_addr, + unsigned long zimage_len, + char *initrd, + unsigned long initrd_len, + unsigned long initrd_offset, + char *cmdline) +{ + struct kexec_buf kbuf; + void *dtb = NULL; + unsigned long initrd_load_addr = 0; + unsigned long dtb_len; + int ret = 0; + + kbuf.image = image; + /* not allocate anything below the kernel */ + kbuf.buf_min = initrd_offset; + if (initrd) { + kbuf.buffer = initrd; + kbuf.bufsz = initrd_len; + kbuf.mem = KEXEC_BUF_MEM_UNKNOWN; + kbuf.memsz = initrd_len; + kbuf.buf_align = PAGE_SIZE; + kbuf.buf_max = ULONG_MAX; + kbuf.top_down = false; + + ret = kexec_add_buffer(&kbuf); + if (ret) + goto out_err; + + pr_debug("Loaded initrd at 0x%lx bufsz=0x%lx memsz=0x%lx\n", + kbuf.mem, kbuf.bufsz, kbuf.memsz); + + initrd_load_addr = kbuf.mem; + kbuf.buf_min = initrd_load_addr + kbuf.memsz; + } + + /* load dtb */ + ret = create_dtb(image, initrd_load_addr, initrd_len, cmdline, &dtb); + if (ret) { + pr_err("Preparing for new dtb failed\n"); + goto out_err; + } + + dtb_len = fdt_totalsize(dtb); + kbuf.buffer = dtb; + kbuf.bufsz = dtb_len; + kbuf.mem = KEXEC_BUF_MEM_UNKNOWN; + kbuf.memsz = dtb_len; + kbuf.buf_align = PAGE_SIZE; + kbuf.buf_max = ULONG_MAX; + kbuf.top_down = false; + + ret = kexec_add_buffer(&kbuf); + if (ret) + goto out_err; + + pr_debug("Loaded dtb at 0x%lx bufsz=0x%lx memsz=0x%lx\n", + kbuf.mem, kbuf.bufsz, kbuf.memsz); + return 0; +out_err: + vfree(dtb); + return ret; +} + +const struct kexec_file_ops * const kexec_file_loaders[] = { + &kexec_uimage_ops, + &kexec_zimage_ops, + NULL +}; -- 2.26.2 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=-7.0 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,UNWANTED_LANGUAGE_BODY,USER_AGENT_GIT autolearn=ham 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 DE94CC433E0 for ; Mon, 1 Jun 2020 14:29:36 +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 A2F2C2068D for ; Mon, 1 Jun 2020 14:29:36 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="hpAkfq9y"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="NxOgmo5l" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org A2F2C2068D Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=samsung.com 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:References:MIME-Version:In-Reply-To: Message-Id:Date:Subject:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=izVxW28unQEfmraxmHwIHJFCPFt/tE6vb6+enPtnYUU=; b=hpAkfq9y7H+Dj+ 0Yy9arWosBYNr/8m4vIhZS2GA0OJbpP4mq1Y6iJfULjcSSmjkoxZI7bqGrRyzps7dRiMPcP1ofrGd bz6CKR9/lOUzmGLnDUDz8k2TCJATm+2z6VeC0q0J2/YnRUsjkYBMlgXqzVVmgehA8USvRbSWB7u18 rnFy3bIo2IwTFhwAxIrV/O9YQXTm/VcedNFa7E8HN0N8Fw/fWFAOD9oM9JviCbvTE7pAaABzFJNlB ZiBKzYlmans0ieD5h6os+bg8HDlVmdqk8CTQzGDS9NdypiVniM1WOhHAkLV/+VK8QfCx8hI1heBQB 9FYCfnIWUQMRJ8KD+UaA==; 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 1jflRY-0004c8-0K; Mon, 01 Jun 2020 14:29:36 +0000 Received: from mailout2.w1.samsung.com ([210.118.77.12]) by bombadil.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1jflQD-0003NU-SP for linux-arm-kernel@lists.infradead.org; Mon, 01 Jun 2020 14:28:17 +0000 Received: from eucas1p2.samsung.com (unknown [182.198.249.207]) by mailout2.w1.samsung.com (KnoxPortal) with ESMTP id 20200601142812euoutp02627ee5251bf159c7d848309190a59993~UccylZ5sf2486824868euoutp02p for ; Mon, 1 Jun 2020 14:28:12 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout2.w1.samsung.com 20200601142812euoutp02627ee5251bf159c7d848309190a59993~UccylZ5sf2486824868euoutp02p DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1591021692; bh=W1N0pk+zwBpYOwOEoTj035sNHYsI+JRLIt8m73+L2QA=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=NxOgmo5l6KH+BlcTdKT9jtRcRDzyoS+l8jVjqZX+44PUCVV0lmGBCWZKG7SiFtUsA s6pFG2SNRQXK6idAXQtZHL6Z6h4qFfvXu0g3Y1v8sfPVVmooCE2LWt+IF/Q4LWnJ8I AUbhL4eoC5OisqIL59kUYCte+H4qCNMtcs7z5PR4= Received: from eusmges3new.samsung.com (unknown [203.254.199.245]) by eucas1p2.samsung.com (KnoxPortal) with ESMTP id 20200601142811eucas1p2cfb8d4a2932683df1904664cb20905bd~UccyVyu-51927019270eucas1p2h; Mon, 1 Jun 2020 14:28:11 +0000 (GMT) Received: from eucas1p2.samsung.com ( [182.198.249.207]) by eusmges3new.samsung.com (EUCPMTA) with SMTP id 6F.6D.60698.B7015DE5; Mon, 1 Jun 2020 15:28:11 +0100 (BST) Received: from eusmtrp1.samsung.com (unknown [182.198.249.138]) by eucas1p1.samsung.com (KnoxPortal) with ESMTPA id 20200601142811eucas1p1604c8e6ca06c09f1ec821ea5e1918c53~UccyCywhV2463924639eucas1p1s; Mon, 1 Jun 2020 14:28:11 +0000 (GMT) Received: from eusmgms2.samsung.com (unknown [182.198.249.180]) by eusmtrp1.samsung.com (KnoxPortal) with ESMTP id 20200601142811eusmtrp124c99c66d75d0868cf5e64e0be948c7b~UccyB7wtx3017330173eusmtrp1k; Mon, 1 Jun 2020 14:28:11 +0000 (GMT) X-AuditID: cbfec7f5-a29ff7000001ed1a-e3-5ed5107b84ac Received: from eusmtip1.samsung.com ( [203.254.199.221]) by eusmgms2.samsung.com (EUCPMTA) with SMTP id 53.FB.07950.B7015DE5; Mon, 1 Jun 2020 15:28:11 +0100 (BST) Received: from localhost (unknown [106.120.51.46]) by eusmtip1.samsung.com (KnoxPortal) with ESMTPA id 20200601142811eusmtip150f76db6f64f8a7d964f5310398f8b42~Uccx3HTOv1539715397eusmtip1n; Mon, 1 Jun 2020 14:28:11 +0000 (GMT) From: =?UTF-8?q?=C5=81ukasz=20Stelmach?= To: Russell King , Masahiro Yamada , Nick Desaulniers , Thomas Gleixner , Enrico Weigelt , Kees Cook , Ingo Molnar , Ben Dooks , linux-arm-kernel@lists.infradead.org, linux-kernel@vger.kernel.org Subject: [PATCH 5/5] arm: kexec_file: load zImage or uImage, initrd and dtb Date: Mon, 1 Jun 2020 16:27:54 +0200 Message-Id: <20200601142754.26139-6-l.stelmach@samsung.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20200601142754.26139-1-l.stelmach@samsung.com> MIME-Version: 1.0 Organization: Samsung R&D Institute Poland X-Brightmail-Tracker: H4sIAAAAAAAAA02Sa0hTYRjHe89tR2t2nIZPFoZDSYW0WNkBpbQLnArKL32JspYdTNwsdrKy m1rmvfKCadsgSa1ly3TqKrOUlZotl2KZ0dVUSlEJS7p5ye0o+e3/PM/v//zfB14al30gPemY uCO8Jk6pklPOhLn594sVJ5lXkSuNTQq2qugOyeZVNGLsm+QHGPs8S82+sRgQa+rtItnOOj3F WgoeIvb2k/cStudTN8nemnyG2G85Uxg73vCbYKtNBXiYC9fZ1YFzuqQOgpso/4pzxaZ4zlSe QXHvuuopbsRmk3DVpYlczrdhirtYU4647yaviPm7nEMP8KqYo7wmaN0+54NZNy/ih39q0fGR yRNJqPFUJnKigVkN5wwPsUzkTMsYAwJr0+WZ4geCTlvtTPEdweOhfGrWYrzSTomDGwgm+nMl YvEFwdvP9zE7RTHhcKnsKWkfuDNjGNQVpDksOPMSQU+D2UG5Mdsgo6TCsZdgfEGbm0/atZQJ gfuPinExbxmk3bjrYJyYUGi0jmIi4wqtV/oIu17IBIDx7GuHxqf5c7U63B4GTC4NhtQpUly0 Ccx3R2e0Gwy21EhEvRSs+dnTZnpaJ0J+XrDozUZg1v8iRCYE3tn+UHYGZ/zhTl2Q2A6Hs5lt pGh1ge5hV/EJLpBnLsTFthTSU2Ui7QMVl+pnFnrChUEDykFy7ZxjtHMO0P7PKkZ4OfLg4wV1 NC8o4vhjgYJSLcTHRQdGHVKb0PSvs062jN1Dj8b3WxBDI/kCaeXHl5EyUnlUSFBbENC43F26 oc0aKZMeUCac4DWH9mriVbxgQUtoQu4hVVwb2CNjopVH+FieP8xrZqcY7eSZhAqM+8eMPr69 QSkSzWL58/WVNesGyOWvhyXeZSu39PvsvBnr/+dxFKCi5qKeDjSxcZcq9sfe0+1eRKXOP0oR vKbQ+9bfeX7VDQoDNhR+veq2rr8wL4xepNs+WfKlr9Rd2F2yo7UtfHO6d4rfmeSWhOuJWyPa h9YWnz+lr9YHPbnqKyeEg8pVAbhGUP4DHJ8LRXEDAAA= X-Brightmail-Tracker: H4sIAAAAAAAAA+NgFnrDIsWRmVeSWpSXmKPExsVy+t/xu7rVAlfjDKbclbXYOGM9q8WkdQeY LG427mayONOda3Hz0ApGi02Pr7FaXN41h83i0NS9jBZrj9xlt3j44Aarxep/pxgtPkz4z2Tx Z/9PFovNm6YyO/B5XL52kdljdsNFFo+/q14weyzYVOqxaVUnm8eda3vYPN6dO8fusXlJvceE D2/ZPPq2rGL0+LxJLoA7Ss+mKL+0JFUhI7+4xFYp2tDCSM/Q0kLPyMRSz9DYPNbKyFRJ384m JTUnsyy1SN8uQS+je2Ufc8H3WYwV7/5VNTAeqOli5OSQEDCRWDPzAhuILSSwlFFiyhLrLkYO oLiUxMq56RAlwhJ/rnVBlTxllLi0wR7EZhNwlOhfeoK1i5GLQ0TgL5PEwVmn2UAcZoFrjBIb J5xkBqkSFvCW6Fy8DqybRUBVYtbEyawgNq+AtcTOfQuYITbIS7Qv3w5WwylgI3Hg9CcmiG3W Eu+ndTNB1AtKnJz5hAXkOGYBdYn184RAwvwCWhJrmq6zgNjMQGOat85mnsAoNAtJxyyEjllI qhYwMq9iFEktLc5Nzy020itOzC0uzUvXS87P3cQIjOltx35u2cHY9S74EKMAB6MSD++G+1fi hFgTy4orcw8xSnAwK4nwOp09HSfEm5JYWZValB9fVJqTWnyI0RTozYnMUqLJ+cB0k1cSb2hq aG5haWhubG5sZqEkztshcDBGSCA9sSQ1OzW1ILUIpo+Jg1OqgbGMZ/qyvdceq/oUP7I5wnDk dGvoOd3gOV5WdkGhz5QsDp/6ZPevyXtbun522ked9ytebE6bZP1Z+E9L9Qv3wtXrfR6afVas ELz24Viv5I93G+a1TeHk3KIhn5ZTn23mY8+90kov4piP6eIsxp6Pb1nVltQ9dMtw091zcafa mX8e1YerOS28LymxFGckGmoxFxUnAgDYjMeB/wIAAA== X-CMS-MailID: 20200601142811eucas1p1604c8e6ca06c09f1ec821ea5e1918c53 X-Msg-Generator: CA X-RootMTR: 20200601142811eucas1p1604c8e6ca06c09f1ec821ea5e1918c53 X-EPHeader: CA CMS-TYPE: 201P X-CMS-RootMailID: 20200601142811eucas1p1604c8e6ca06c09f1ec821ea5e1918c53 References: <20200601142754.26139-1-l.stelmach@samsung.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200601_072814_199695_8A557FD9 X-CRM114-Status: GOOD ( 24.56 ) 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: AKASHI Takahiro , Marek Szyprowski , =?UTF-8?q?=C5=81ukasz=20Stelmach?= , Bartlomiej Zolnierkiewicz 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 VGhpcyBpcyBrZXhlY19maWxlX2xvYWQgaW1wbGVtZW50YXRpb24gZm9yIEFSTS4gSXQgbG9hZHMg ekltYWdlIGFuZAppbml0cmQgZnJvbSBmaWxlIGRlc2NyaXB0ZXJzIGFuZCByZXN1c2VzIERUQi4K Ck1vc3QgY29kZSBpcyBkZXJpdmVkIGZyb20gYXJtNjQga2V4ZWNfZmlsZV9sb2FkIGltcGxlbWVu dGF0aW9uCmFuZCBmcm9tIGtleGVjLXRvb2xzLgoKQ2M6IEFLQVNISSBUYWthaGlybyA8dGFrYWhp cm8uYWthc2hpQGxpbmFyby5vcmc+ClNpZ25lZC1vZmYtYnk6IMWBdWthc3ogU3RlbG1hY2ggPGwu c3RlbG1hY2hAc2Ftc3VuZy5jb20+Ci0tLQogYXJjaC9hcm0vS2NvbmZpZyAgICAgICAgICAgICAg ICAgICAgIHwgIDE1ICsrCiBhcmNoL2FybS9pbmNsdWRlL2FzbS9pbWFnZS5oICAgICAgICAgfCAg MjYgKysrKwogYXJjaC9hcm0vaW5jbHVkZS9hc20va2V4ZWMuaCAgICAgICAgIHwgIDE0ICsrCiBh cmNoL2FybS9rZXJuZWwvTWFrZWZpbGUgICAgICAgICAgICAgfCAgIDUgKy0KIGFyY2gvYXJtL2tl cm5lbC9rZXhlY191aW1hZ2UuYyAgICAgICB8ICA4MCArKysrKysrKysrCiBhcmNoL2FybS9rZXJu ZWwva2V4ZWNfemltYWdlLmMgICAgICAgfCAxOTkgKysrKysrKysrKysrKysrKysrKysrKysrKwog YXJjaC9hcm0va2VybmVsL21hY2hpbmVfa2V4ZWMuYyAgICAgIHwgIDExICstCiBhcmNoL2FybS9r ZXJuZWwvbWFjaGluZV9rZXhlY19maWxlLmMgfCAyMDkgKysrKysrKysrKysrKysrKysrKysrKysr KysrCiA4IGZpbGVzIGNoYW5nZWQsIDU1NCBpbnNlcnRpb25zKCspLCA1IGRlbGV0aW9ucygtKQog Y3JlYXRlIG1vZGUgMTAwNjQ0IGFyY2gvYXJtL2tlcm5lbC9rZXhlY191aW1hZ2UuYwogY3JlYXRl IG1vZGUgMTAwNjQ0IGFyY2gvYXJtL2tlcm5lbC9rZXhlY196aW1hZ2UuYwogY3JlYXRlIG1vZGUg MTAwNjQ0IGFyY2gvYXJtL2tlcm5lbC9tYWNoaW5lX2tleGVjX2ZpbGUuYwoKZGlmZiAtLWdpdCBh L2FyY2gvYXJtL0tjb25maWcgYi9hcmNoL2FybS9LY29uZmlnCmluZGV4IGM3N2M5M2M0ODVhMC4u NmFkYjg0OWNiMzA0IDEwMDY0NAotLS0gYS9hcmNoL2FybS9LY29uZmlnCisrKyBiL2FyY2gvYXJt L0tjb25maWcKQEAgLTE5MTcsNiArMTkxNywyMSBAQCBjb25maWcgS0VYRUMKIAkgIGlzIHByb3Bl cmx5IHNodXRkb3duLCBzbyBkbyBub3QgYmUgc3VycHJpc2VkIGlmIHRoaXMgY29kZSBkb2VzIG5v dAogCSAgaW5pdGlhbGx5IHdvcmsgZm9yIHlvdS4KIAorY29uZmlnIEtFWEVDX0ZJTEUKKwlib29s ICJLZXhlYyBmaWxlIGJhc2VkIHN5c3RlbSBjYWxsIChFWFBFUklNRU5UQUwpIgorCWRlcGVuZHMg b24gKCFTTVAgfHwgUE1fU0xFRVBfU01QKQorCWRlcGVuZHMgb24gVVNFX09GCisJc2VsZWN0IEtF WEVDX0NPUkUKKwlzZWxlY3QgQ1JDMzIKKwloZWxwCisJICBUaGlzIGlzIG5ldyB2ZXJzaW9uIG9m IGtleGVjIHN5c3RlbSBjYWxsLiBUaGlzIHN5c3RlbSBjYWxsIGlzCisJICBmaWxlIGJhc2VkIGFu ZCB0YWtlcyBmaWxlIGRlc2NyaXB0b3JzIGFzIHN5c3RlbSBjYWxsIGFyZ3VtZW50CisJICBmb3Ig a2VybmVsIGFuZCBpbml0cmFtZnMgYXMgb3Bwb3NlZCB0byBsaXN0IG9mIHNlZ21lbnRzIGFzCisJ ICBhY2NlcHRlZCBieSBwcmV2aW91cyBzeXN0ZW0gY2FsbC4KKworCSAgVGhlIGtlcm5lbCB0byBi ZSBsb2FkZWQgTVVTVCBzdXBwb3J0IEZsYXR0ZW5lZCBEZXZpY2UgVHJlZQorCSAgKHNlbGVjdGVk IHdpdGggQ09ORklHX1VTRV9PRikuCisKIGNvbmZpZyBBVEFHU19QUk9DCiAJYm9vbCAiRXhwb3J0 IGF0YWdzIGluIHByb2NmcyIKIAlkZXBlbmRzIG9uIEFUQUdTICYmIEtFWEVDCmRpZmYgLS1naXQg YS9hcmNoL2FybS9pbmNsdWRlL2FzbS9pbWFnZS5oIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20vaW1h Z2UuaAppbmRleCA2MjQ0Mzg3NDBmMjMuLjk1ZjIzODM3YjA0ZiAxMDA2NDQKLS0tIGEvYXJjaC9h cm0vaW5jbHVkZS9hc20vaW1hZ2UuaAorKysgYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9pbWFnZS5o CkBAIC04LDggKzgsMTMgQEAKIAkJCSAoKCh4KSA+PiAgOCkgJiAweDAwMDBmZjAwKSB8ICBcCiAJ CQkgKCgoeCkgPDwgIDgpICYgMHgwMGZmMDAwMCkgfCAgXAogCQkJICgoKHgpIDw8IDI0KSAmIDB4 ZmYwMDAwMDApKQorI2RlZmluZSBVSU1BR0VfTUFHSUMoeCkgKHgpCiAjZWxzZQogI2RlZmluZSBa SU1BR0VfTUFHSUMoeCkgKHgpCisjZGVmaW5lIFVJTUFHRV9NQUdJQyh4KSAoKCgoeCkgPj4gMjQp ICYgMHgwMDAwMDBmZikgfCBcCisJCQkgKCgoeCkgPj4gIDgpICYgMHgwMDAwZmYwMCkgfCAgXAor CQkJICgoKHgpIDw8ICA4KSAmIDB4MDBmZjAwMDApIHwgIFwKKwkJCSAoKCh4KSA8PCAyNCkgJiAw eGZmMDAwMDAwKSkKICNlbmRpZgogCiAjZGVmaW5lIEFSTV9aSU1BR0VfTUFHSUMxIFpJTUFHRV9N QUdJQygweDAxNmYyODE4KQpAQCAtMTcsNiArMjIsMTIgQEAKICNkZWZpbmUgQVJNX1pJTUFHRV9N QUdJQzMgWklNQUdFX01BR0lDKDB4NWE1MzRjNGIpCiAjZGVmaW5lIEFSTV9aSU1BR0VfTUFHSUM0 IFpJTUFHRV9NQUdJQygweDVhNTM0MzQ0KQogCisjZGVmaW5lIEFSTV9VSU1BR0VfTUFHSUMgVUlN QUdFX01BR0lDKDB4MjcwNTE5NTYpCisjZGVmaW5lIEFSTV9VSU1BR0VfTkFNRV9MRU4JCTMyCisj ZGVmaW5lIEFSTV9VSU1BR0VfVFlQRV9LRVJORUwJCTIKKyNkZWZpbmUgQVJNX1VJTUFHRV9UWVBF X0tFUk5FTF9OT0xPQUQJMTQKKyNkZWZpbmUgQVJNX1VJTUFHRV9BUkNIX0FSTQkJMgorCiAjaWZu ZGVmIF9fQVNTRU1CTFlfXwogCiAjaW5jbHVkZSA8bGludXgvdHlwZXMuaD4KQEAgLTMzLDYgKzQ0 LDIxIEBAIHN0cnVjdCBhcm1femltYWdlX2hlYWRlciB7CiAJX19sZTMyIGV4dGVuc2lvbl90YWdf b2Zmc2V0OwogfTsKIAorc3RydWN0IGFybV91aW1hZ2VfaGVhZGVyIHsKKwlfX2JlMzIgbWFnaWM7 CisJX19iZTMyIGhkcl9jcmM7CisJX19iZTMyIHRpbWU7CisJX19iZTMyIHNpemU7CisJX19iZTMy IGxvYWQ7CisJX19iZTMyIGVudHJ5OworCV9fYmUzMiBjcmM7CisJX191OCAgIG9zOworCV9fdTgg ICBhcmNoOworCV9fdTggICB0eXBlOworCV9fdTggICBjb21wOworCV9fdTggICBuYW1lW0FSTV9V SU1BR0VfTkFNRV9MRU5dOworfTsKKwogc3RydWN0IGFybV96aW1hZ2VfdGFnIHsKIAlzdHJ1Y3Qg dGFnX2hlYWRlciBoZHI7CiAJdW5pb24gewpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0vaW5jbHVkZS9h c20va2V4ZWMuaCBiL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2tleGVjLmgKaW5kZXggMjI3NTFiNWI1 NzM1Li5mZGEzNWFmYTcxOTUgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2tleGVj LmgKKysrIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20va2V4ZWMuaApAQCAtODMsNiArODMsMjAgQEAg c3RhdGljIGlubGluZSBzdHJ1Y3QgcGFnZSAqYm9vdF9wZm5fdG9fcGFnZSh1bnNpZ25lZCBsb25n IGJvb3RfcGZuKQogfQogI2RlZmluZSBib290X3Bmbl90b19wYWdlIGJvb3RfcGZuX3RvX3BhZ2UK IAorI2lmZGVmIENPTkZJR19LRVhFQ19GSUxFCisKK2V4dGVybiBjb25zdCBzdHJ1Y3Qga2V4ZWNf ZmlsZV9vcHMga2V4ZWNfemltYWdlX29wczsKK2V4dGVybiBjb25zdCBzdHJ1Y3Qga2V4ZWNfZmls ZV9vcHMga2V4ZWNfdWltYWdlX29wczsKKworc3RydWN0IGtpbWFnZTsKKworZXh0ZXJuIGludCBs b2FkX290aGVyX3NlZ21lbnRzKHN0cnVjdCBraW1hZ2UgKmltYWdlLAorCQl1bnNpZ25lZCBsb25n IGtlcm5lbF9sb2FkX2FkZHIsIHVuc2lnbmVkIGxvbmcga2VybmVsX3NpemUsCisJCWNoYXIgKmlu aXRyZCwgdW5zaWduZWQgbG9uZyBpbml0cmRfbGVuLAorCQl1bnNpZ25lZCBsb25nIGluaXRyZF9v ZmZzZXQsIGNoYXIgKmNtZGxpbmUpOworCisjZW5kaWYgLyogQ09ORklHX0tFWEVDX0ZJTEUgKi8K KwogI2VuZGlmIC8qIF9fQVNTRU1CTFlfXyAqLwogCiAjZW5kaWYgLyogQ09ORklHX0tFWEVDICov CmRpZmYgLS1naXQgYS9hcmNoL2FybS9rZXJuZWwvTWFrZWZpbGUgYi9hcmNoL2FybS9rZXJuZWwv TWFrZWZpbGUKaW5kZXggODllNWQ4NjRlOTIzLi40NjZjNjgzYmI1NTEgMTAwNjQ0Ci0tLSBhL2Fy Y2gvYXJtL2tlcm5lbC9NYWtlZmlsZQorKysgYi9hcmNoL2FybS9rZXJuZWwvTWFrZWZpbGUKQEAg LTMsNiArMyw3IEBACiAjIE1ha2VmaWxlIGZvciB0aGUgbGludXgga2VybmVsLgogIwogCitDRkxB R1Nfa2V4ZWNfemltYWdlLm8gOj0gLURURVhUX09GRlNFVD0kKFRFWFRfT0ZGU0VUKQogQ1BQRkxB R1Nfdm1saW51eC5sZHMgOj0gLURURVhUX09GRlNFVD0kKFRFWFRfT0ZGU0VUKQogQUZMQUdTX2hl YWQubyAgICAgICAgOj0gLURURVhUX09GRlNFVD0kKFRFWFRfT0ZGU0VUKQogCkBAIC01Niw3ICs1 Nyw5IEBAIG9iai0kKENPTkZJR19GVU5DVElPTl9UUkFDRVIpCSs9IGVudHJ5LWZ0cmFjZS5vCiBv YmotJChDT05GSUdfRFlOQU1JQ19GVFJBQ0UpCSs9IGZ0cmFjZS5vIGluc24ubyBwYXRjaC5vCiBv YmotJChDT05GSUdfRlVOQ1RJT05fR1JBUEhfVFJBQ0VSKQkrPSBmdHJhY2UubyBpbnNuLm8gcGF0 Y2gubwogb2JqLSQoQ09ORklHX0pVTVBfTEFCRUwpCSs9IGp1bXBfbGFiZWwubyBpbnNuLm8gcGF0 Y2gubwotb2JqLSQoQ09ORklHX0tFWEVDKQkJKz0gbWFjaGluZV9rZXhlYy5vIHJlbG9jYXRlX2tl cm5lbC5vCitvYmotJChDT05GSUdfS0VYRUNfQ09SRSkJKz0gbWFjaGluZV9rZXhlYy5vIHJlbG9j YXRlX2tlcm5lbC5vCitvYmotJChDT05GSUdfS0VYRUNfRklMRSkJKz0gbWFjaGluZV9rZXhlY19m aWxlLm8ga2V4ZWNfemltYWdlLm8JXAorCQkJCSAgIGtleGVjX3VpbWFnZS5vCiAjIE1haW4gc3Rh ZmZzIGluIEtQUk9CRVMgYXJlIGluIGFyY2gvYXJtL3Byb2Jlcy8gLgogb2JqLSQoQ09ORklHX0tQ Uk9CRVMpCQkrPSBwYXRjaC5vIGluc24ubwogb2JqLSQoQ09ORklHX09BQklfQ09NUEFUKQkrPSBz eXNfb2FiaS1jb21wYXQubwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va2VybmVsL2tleGVjX3VpbWFn ZS5jIGIvYXJjaC9hcm0va2VybmVsL2tleGVjX3VpbWFnZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAwMDAwMC4uNDcwMzM1NzRlMjRlCi0tLSAvZGV2L251bGwKKysrIGIvYXJj aC9hcm0va2VybmVsL2tleGVjX3VpbWFnZS5jCkBAIC0wLDAgKzEsODAgQEAKKy8vIFNQRFgtTGlj ZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisvKgorICogS2V4ZWMgdUltYWdlIGxvYWRlcgorICoK KyAqIENvcHlyaWdodCAoQykgMjAyMCBTYW1zdW5nIEVsZWN0cm9uaWNzCisgKiBBdXRob3I6IMWB dWthc3ogU3RlbG1hY2ggPGwuc3RlbG1hY2hAc2Ftc3VuZy5jb20+CisgKi8KKworI2RlZmluZSBw cl9mbXQoZm10KQkia2V4ZWNfZmlsZSh1SW1hZ2UpOiAiIGZtdAorCisjaW5jbHVkZSA8YXNtL2lt YWdlLmg+CisjaW5jbHVkZSA8bGludXgvY3JjMzIuaD4KKyNpbmNsdWRlIDxsaW51eC9lcnIuaD4K KyNpbmNsdWRlIDxsaW51eC9rZXhlYy5oPgorCisjZGVmaW5lIGNyYzMyX29uZXMoY3JjLCBidWYs IGxlbikgXAorCShjcmMzMihjcmMgXiAweGZmZmZmZmZmLCBidWYsIGxlbikgXiAweGZmZmZmZmZm KQorCitzdGF0aWMgaW50IHVpbWFnZV9wcm9iZShjb25zdCBjaGFyICp1aW1hZ2VfYnVmLCB1bnNp Z25lZCBsb25nIHVpbWFnZV9sZW4pCit7CisJY29uc3Qgc3RydWN0IGFybV91aW1hZ2VfaGVhZGVy ICpoID0KKwkJKHN0cnVjdCBhcm1fdWltYWdlX2hlYWRlciAqKSB1aW1hZ2VfYnVmOworCXN0cnVj dCBhcm1fdWltYWdlX2hlYWRlciB1aGRyOworCXVuc2lnbmVkIGxvbmcgem9mZiA9IHNpemVvZihz dHJ1Y3QgYXJtX3VpbWFnZV9oZWFkZXIpOworCXVpbnQzMl90IGNyYzsKKworCWlmIChoLT5tYWdp YyAhPSBBUk1fVUlNQUdFX01BR0lDKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWlmIChoLT50eXBl ICE9IEFSTV9VSU1BR0VfVFlQRV9LRVJORUwgJiYKKwkgICAgaC0+dHlwZSAhPSBBUk1fVUlNQUdF X1RZUEVfS0VSTkVMX05PTE9BRCl7CisJCXByX2RlYnVnKCJJbnZhbGlkIGltYWdlIHR5cGU6ICVk XG4iLCBoLT50eXBlKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJaWYgKGgtPmFyY2ggIT0g QVJNX1VJTUFHRV9BUkNIX0FSTSkgeworCQlwcl9kZWJ1ZygiSW52YWxpZHkgaW1hZ2UgYXJjaDog JWRcbiIsIGgtPmFyY2gpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwltZW1jcHkoKGNoYXIg KikmdWhkciwgaCwgc2l6ZW9mKHVoZHIpKTsKKwljcmMgPSBiZTMyX3RvX2NwdSh1aGRyLmhkcl9j cmMpOworCXVoZHIuaGRyX2NyYyA9IDA7CisKKwlpZiAoY3JjMzJfb25lcygwLCAoY2hhciAqKSZ1 aGRyLCBzaXplb2YodWhkcikpICE9IGNyYykgeworCQlwcl9kZWJ1ZygiQ29ycnVwdCBoZWFkZXIs IENSQyBkbyBub3QgbWF0Y2hcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwljcmMgPSBi ZTMyX3RvX2NwdSh1aGRyLmNyYyk7CisJaWYgKGNyYzMyX29uZXMoMCwgdWltYWdlX2J1ZiArIHpv ZmYsIHVpbWFnZV9sZW4gLSB6b2ZmKSAhPSBjcmMpIHsKKwkJcHJfZGVidWcoIkNvcnJ1cHQgeklt YWdlLCBDUkMgZG8gbm90IG1hdGNoXG4iKTsKKwkJcmV0dXJuIC1FSU5WQUw7CisJfQorCisJcmV0 dXJuIGtleGVjX3ppbWFnZV9vcHMucHJvYmUodWltYWdlX2J1ZiArIHpvZmYsCisJCQkJICAgICAg dWltYWdlX2xlbiAtIHpvZmYpOworfQorCitzdGF0aWMgdm9pZCAqdWltYWdlX2xvYWQoc3RydWN0 IGtpbWFnZSAqaW1hZ2UsCisJCQkJY2hhciAqdWltYWdlLCB1bnNpZ25lZCBsb25nIHVpbWFnZV9s ZW4sCisJCQkJY2hhciAqaW5pdHJkLCB1bnNpZ25lZCBsb25nIGluaXRyZF9sZW4sCisJCQkJY2hh ciAqY21kbGluZSwgdW5zaWduZWQgbG9uZyBjbWRsaW5lX2xlbikKK3sKKwljb25zdCBzdHJ1Y3Qg YXJtX3VpbWFnZV9oZWFkZXIgKmggPQorCQkoc3RydWN0IGFybV91aW1hZ2VfaGVhZGVyICopIHVp bWFnZTsKKwl1bnNpZ25lZCBsb25nIHppbWFnZV9vZmZzZXQgPSBzaXplb2Yoc3RydWN0IGFybV91 aW1hZ2VfaGVhZGVyKTsKKworCXByX2RlYnVnKCJMb2FkaW5nIHVJbWFnZSIpOworCXJldHVybiBr ZXhlY196aW1hZ2Vfb3BzLmxvYWQoaW1hZ2UsCisJCQkJICAgICB1aW1hZ2UgKyB6aW1hZ2Vfb2Zm c2V0LAorCQkJCSAgICAgdWltYWdlX2xlbiAtIHppbWFnZV9vZmZzZXQsCisJCQkJICAgICBpbml0 cmQsIGluaXRyZF9sZW4sCisJCQkJICAgICBjbWRsaW5lLCBjbWRsaW5lX2xlbik7Cit9CisKK2Nv bnN0IHN0cnVjdCBrZXhlY19maWxlX29wcyBrZXhlY191aW1hZ2Vfb3BzID0geworCS5wcm9iZSA9 IHVpbWFnZV9wcm9iZSwKKwkubG9hZCA9IHVpbWFnZV9sb2FkLAorfTsKZGlmZiAtLWdpdCBhL2Fy Y2gvYXJtL2tlcm5lbC9rZXhlY196aW1hZ2UuYyBiL2FyY2gvYXJtL2tlcm5lbC9rZXhlY196aW1h Z2UuYwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAuLmQwOTc5NWZjOTA3 MgotLS0gL2Rldi9udWxsCisrKyBiL2FyY2gvYXJtL2tlcm5lbC9rZXhlY196aW1hZ2UuYwpAQCAt MCwwICsxLDE5OSBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKy8qCisg KiBLZXhlYyB6SW1hZ2UgbG9hZGVyCisgKgorICogQ29weXJpZ2h0IChDKSAyMDIwIFNhbXN1bmcg RWxlY3Ryb25pY3MKKyAqIEF1dGhvcjogxYF1a2FzeiBTdGVsbWFjaCA8bC5zdGVsbWFjaEBzYW1z dW5nLmNvbT4KKyAqLworCisjZGVmaW5lIHByX2ZtdChmbXQpCSJrZXhlY19maWxlKHpJbWFnZSk6 ICIgZm10CisKKyNpbmNsdWRlIDxhc20vaW1hZ2UuaD4KKyNpbmNsdWRlIDxhc20vdW5hbGlnbmVk Lmg+CisjaW5jbHVkZSA8bGludXgvZXJyLmg+CisjaW5jbHVkZSA8bGludXgva2V4ZWMuaD4KKyNp bmNsdWRlIDxsaW51eC9tZW1ibG9jay5oPgorCisjZGVmaW5lIGJ5dGVfc2l6ZSh0KSAgICAoKHQp LT5oZHIuc2l6ZSA8PCAyKQorCitzdGF0aWMgY29uc3Qgdm9pZCAqZmluZF9leHRlbnNpb25fdGFn KGNvbnN0IGNoYXIgKmJ1ZiwKKwkJCQkJCSAgICAgICB1bnNpZ25lZCBsb25nIGxlbiwKKwkJCQkJ CSAgICAgICB1aW50MzJfdCB0YWdfaWQpCit7CisJY29uc3Qgc3RydWN0IGFybV96aW1hZ2VfaGVh ZGVyICpoID0gKGNvbnN0IHN0cnVjdCBhcm1femltYWdlX2hlYWRlciAqKWJ1ZjsKKwljb25zdCBz dHJ1Y3QgYXJtX3ppbWFnZV90YWcgKnRhZzsKKwl1aW50MzJfdCBvZmZzZXQsIHNpemU7CisJdWlu dDMyX3QgbWF4ID0gbGVuIC0gc2l6ZW9mKHN0cnVjdCB0YWdfaGVhZGVyKTsKKworCWlmIChsZW4g PCBzaXplb2YoKmgpIHx8CisJICAgIGgtPm1hZ2ljICE9IEFSTV9aSU1BR0VfTUFHSUMxIHx8CisJ ICAgIGgtPm1hZ2ljMiAhPSBBUk1fWklNQUdFX01BR0lDMikKKwkJcmV0dXJuIE5VTEw7CisKKwlm b3IgKG9mZnNldCA9IGgtPmV4dGVuc2lvbl90YWdfb2Zmc2V0OworCSAgICAgKHRhZyA9ICh2b2lk ICopKGJ1ZiArIG9mZnNldCkpICE9IE5VTEwgJiYKKwkJICAgICBvZmZzZXQgPCBtYXggJiYKKwkJ ICAgICAoc2l6ZSA9IGxlMzJfdG9fY3B1KGJ5dGVfc2l6ZSh0YWcpKSkgIT0gMCAmJgorCQkgICAg IG9mZnNldCArIHNpemUgPCBsZW47CisJICAgICBvZmZzZXQgKz0gc2l6ZSkgeworCQlwcl9kZWJ1 ZygiICBvZmZzZXQgMHglMDh4IHRhZyAweCUwOHggc2l6ZSAldVxuIiwKKwkJCSAgb2Zmc2V0LCBs ZTMyX3RvX2NwdSh0YWctPmhkci50YWcpLCBzaXplKTsKKwkJaWYgKHRhZy0+aGRyLnRhZyA9PSB0 YWdfaWQpCisJCQlyZXR1cm4gdGFnOworCX0KKworCXJldHVybiBOVUxMOworfQorCitzdGF0aWMg aW50IHppbWFnZV9wcm9iZShjb25zdCBjaGFyICprZXJuZWxfYnVmLCB1bnNpZ25lZCBsb25nIGtl cm5lbF9sZW4pCit7CisJY29uc3Qgc3RydWN0IGFybV96aW1hZ2VfaGVhZGVyICpoID0KKwkJKHN0 cnVjdCBhcm1femltYWdlX2hlYWRlciAqKShrZXJuZWxfYnVmKTsKKworCWlmICghaCB8fCAoa2Vy bmVsX2xlbiA8IHNpemVvZigqaCkpKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCWlmICgoaC0+bWFn aWMgIT0gQVJNX1pJTUFHRV9NQUdJQzEpIHx8CisJICAgIChoLT5tYWdpYzIgIT0gQVJNX1pJTUFH RV9NQUdJQzIpKQorCQlyZXR1cm4gLUVJTlZBTDsKKworCXJldHVybiAwOworfQorCisKKyNpZiBk ZWZpbmVkKERFQlVHKQorI2RlZmluZSBkZWJ1Z19vZmZzZXRzKCkgKHsJCQlcCisJcHJfZGVidWco IkltYWdlIG9mZnNldHM6XG4iKTsJCVwKKwlwcl9kZWJ1ZygiICBrZXJuZWwgMHglMDhseCAweCUw OGx4XG4iLCBrZXJuZWxfb2Zmc2V0LCBrZXJuZWxfbGVuKTsgXAorCXByX2RlYnVnKCIgIHppbWFn ZSAweCUwOGx4IDB4JTA4bHhcbiIsIHppbWFnZV9vZmZzZXQsIHppbWFnZV9sZW4pOyBcCisJcHJf ZGVidWcoIiAgaW5pdHJkIDB4JTA4bHggMHglMDhseFxuIiwgaW5pdHJkX29mZnNldCwgaW5pdHJk X2xlbik7IFwKK30pCisjZWxzZQorI2RlZmluZSBkZWJ1Z19vZmZzZXRzKCkKKyNlbmRpZgorCitz dGF0aWMgdm9pZCAqemltYWdlX2xvYWQoc3RydWN0IGtpbWFnZSAqaW1hZ2UsCisJCQkJY2hhciAq emltYWdlLCB1bnNpZ25lZCBsb25nIHppbWFnZV9sZW4sCisJCQkJY2hhciAqaW5pdHJkLCB1bnNp Z25lZCBsb25nIGluaXRyZF9sZW4sCisJCQkJY2hhciAqY21kbGluZSwgdW5zaWduZWQgbG9uZyBj bWRsaW5lX2xlbikKK3sKKwlzdHJ1Y3QgYXJtX3ppbWFnZV9oZWFkZXIgKmg7CisJc3RydWN0IGtl eGVjX2J1ZiBrYnVmOworCXN0cnVjdCBrZXhlY19zZWdtZW50ICp6aW1hZ2Vfc2VnbWVudDsKKwlj b25zdCBzdHJ1Y3QgYXJtX3ppbWFnZV90YWcgKmtsc3pfdGFnOworCWNvbnN0IHN0cnVjdCBhcm1f emltYWdlX3RhZ19kYyAqZGNzel90YWc7CisJaW50IHJldCA9IC1FSU5WQUw7CisKKwl1bnNpZ25l ZCBsb25nIHppbWFnZV9tZW0gPSAweDIwMDAwOyAvKiBtYWxsb2MgNjRrQiArIHN0YWNrIDQga0Ig KyBzb21lIGJzcyAqLworCXVuc2lnbmVkIGxvbmcga2VybmVsX2xlbiA9IHppbWFnZV9sZW4gKiA0 OyAvKiA0OjEgY29tcHJlc3Npb24gKi8KKwl1bnNpZ25lZCBsb25nIGtlcm5lbF9vZmZzZXQgPSBt ZW1ibG9ja19zdGFydF9vZl9EUkFNKCkgKworCQlBTElHTihURVhUX09GRlNFVCwgUEFHRV9TSVpF KTsKKwl1bnNpZ25lZCBsb25nIHppbWFnZV9vZmZzZXQgPSBrZXJuZWxfb2Zmc2V0ICsKKwkJQUxJ R04oa2VybmVsX2xlbiwgUEFHRV9TSVpFKTsKKwl1bnNpZ25lZCBsb25nIGluaXRyZF9vZmZzZXQg PSB6aW1hZ2Vfb2Zmc2V0ICsKKwkJQUxJR04oemltYWdlX2xlbiArIHppbWFnZV9tZW0sIFBBR0Vf U0laRSk7CisKKwlpZiAoaW1hZ2UtPnR5cGUgPT0gS0VYRUNfVFlQRV9DUkFTSCkgeworCQlrZXJu ZWxfb2Zmc2V0ICs9IGNyYXNoa19yZXMuc3RhcnQ7CisJCXppbWFnZV9vZmZzZXQgKz0gY3Jhc2hr X3Jlcy5zdGFydDsKKwkJaW5pdHJkX29mZnNldCArPSBjcmFzaGtfcmVzLnN0YXJ0OworCX0KKwlk ZWJ1Z19vZmZzZXRzKCk7CisKKwloID0gKHN0cnVjdCBhcm1femltYWdlX2hlYWRlciAqKXppbWFn ZTsKKworCWtsc3pfdGFnID0gZmluZF9leHRlbnNpb25fdGFnKHppbWFnZSwgemltYWdlX2xlbiwg WklNQUdFX1RBR19LUk5MX1NJWkUpOworCWlmIChrbHN6X3RhZykgeworCQl1aW50MzJfdCAqcCA9 ICh2b2lkICopemltYWdlICsKKwkJCWxlMzJfdG9fY3B1KGtsc3pfdGFnLT51Lmtybmxfc2l6ZS5z aXplX3B0cik7CisJCXVpbnQzMl90IGVkYXRhX3NpemUgPSBsZTMyX3RvX2NwdShnZXRfdW5hbGln bmVkKHApKTsKKwkJdWludDMyX3QgYnNzX3NpemUgPSBsZTMyX3RvX2NwdShrbHN6X3RhZy0+dS5r cm5sX3NpemUuYnNzX3NpemUpOworCisJCWtlcm5lbF9sZW4gPSBlZGF0YV9zaXplICsgYnNzX3Np emU7CisKKwkJcHJfZGVidWcoIkRlY29tcHJlc3NlZCBrZXJuZWwgc2l6ZXM6XG4iKTsKKwkJcHJf ZGVidWcoIiB0ZXh0K2RhdGEgMHglMDhseCBic3MgMHglMDhseCB0b3RhbCAweCUwOGx4XG4iLAor CQkJICh1bnNpZ25lZCBsb25nKWVkYXRhX3NpemUsCisJCQkgKHVuc2lnbmVkIGxvbmcpYnNzX3Np emUsCisJCQkgKHVuc2lnbmVkIGxvbmcpa2VybmVsX2xlbik7CisKKwkJemltYWdlX29mZnNldCA9 IGtlcm5lbF9vZmZzZXQgKyBBTElHTihlZGF0YV9zaXplLCBQQUdFX1NJWkUpOworCQlpbml0cmRf b2Zmc2V0ID0gemltYWdlX29mZnNldCArCisJCQltYXgoQUxJR04oemltYWdlX2xlbiArIDB4MjAw MDAsIFBBR0VfU0laRSksCisJCQkgICAgQUxJR04oKHVuc2lnbmVkIGxvbmcpYnNzX3NpemUsIFBB R0VfU0laRSkpOworCQlkZWJ1Z19vZmZzZXRzKCk7CisJfQorCisJZGNzel90YWcgPSBmaW5kX2V4 dGVuc2lvbl90YWcoemltYWdlLCB6aW1hZ2VfbGVuLAorCQkJCSAgICAgIFpJTUFHRV9UQUdfREVD T01QX1NJWkUpOworCWlmIChkY3N6X3RhZykgeworCQl1aW50MzJfdCBic3Nfc2l6ZSA9IGxlMzJf dG9fY3B1KGRjc3pfdGFnLT51LmRlY29tcF9zaXplLmJzc19zaXplKTsKKwkJdWludDMyX3Qgc3Rh Y2tfc2l6ZSA9IGxlMzJfdG9fY3B1KGRjc3pfdGFnLT51LmRlY29tcF9zaXplLnN0YWNrX3NpemUp OworCQl1aW50MzJfdCBtYWxsb2Nfc2l6ZSA9IGxlMzJfdG9fY3B1KGRjc3pfdGFnLT51LmRlY29t cF9zaXplLm1hbGxvY19zaXplKTsKKworCQl6aW1hZ2VfbWVtID0gYnNzX3NpemUgKyBzdGFja19z aXplICsgbWFsbG9jX3NpemU7CisKKwkJcHJfZGVidWcoIkRlY29tcHJlc3NvciBtZW1vcnkgcmVx dWlyZW1lbnRzOlxuIik7CisJCXByX2RlYnVnKCIgYnNzIDB4JTA4bHggc3RhY2sgMHglMDhseCBt YWxsb2MgMHglMDhseCB0b3RhbCAweCUwOGx4XG4iLAorCQkJICh1bnNpZ25lZCBsb25nKWJzc19z aXplLAorCQkJICh1bnNpZ25lZCBsb25nKXN0YWNrX3NpemUsCisJCQkgKHVuc2lnbmVkIGxvbmcp bWFsbG9jX3NpemUsCisJCQkgemltYWdlX21lbSk7CisKKwkJaW5pdHJkX29mZnNldCA9IG1heChB TElHTih6aW1hZ2Vfb2Zmc2V0ICsgemltYWdlX2xlbiArCisJCQkJCSAgYnNzX3NpemUgKyBzdGFj a19zaXplICsKKwkJCQkJICBtYWxsb2Nfc2l6ZSwgUEFHRV9TSVpFKSwKKwkJCQkgICAgQUxJR04o a2VybmVsX29mZnNldCArIGtlcm5lbF9sZW4sIFBBR0VfU0laRSkpOworCQlkZWJ1Z19vZmZzZXRz KCk7CisJfQorCisJLyoKKwkgKiB6SW1hZ2UgTVVTVCBiZSBsb2FkZWQgaW50byB0aGUgZmlyc3Qg MTI4IE1pQiBvZiBwaHlzaWNhbAorCSAqIG1lbW9yeSBmb3IgcHJvcGVyIG1lbW9yeSBkZXRlY3Rp b24uIFNob3VsZCB0aGUgdW5jb21wcmVzc2VkCisJICoga2VybmVsIGJlIGxhcmdlciB0aGFuIDEy OCBNaUIsIHpJbWFnZSByZWxvY2F0aW9uIGJlY29tZXMKKwkgKiB1bmF2b2lkYWJsZSBhbmQgaXQg aXMgYmVzdCB0byByZWx5IG9uIHRoZSByZWxvY2F0aW9uIGNvZGUuCisJICovCisJaWYgKCgoemlt YWdlX29mZnNldCAtIGtlcm5lbF9vZmZzZXQpICsgUEFHRV9TSVpFICsgMHg4MDAwKSA+PSBTWl8x MjhNKSB7CisJCXByX2RlYnVnKCJUaGUga2VybmVsIGlzIHRvbyBiaWcgKCVsZCBNaUIpIHRvIGF2 b2lkICIKKwkJCSAiekltYWdlIHJlbG9jYXRpb24uIExvYWRpbmcgemltYWdlIGF0IDB4JTA4bHhc biIsCisJCQkgKCh6aW1hZ2Vfb2Zmc2V0IC0ga2VybmVsX29mZnNldCkgPj4gMjApLAorCQkJIGtl cm5lbF9vZmZzZXQpOworCQl6aW1hZ2Vfb2Zmc2V0ID0ga2VybmVsX29mZnNldDsKKwl9CisKKwlr YnVmLmltYWdlID0gaW1hZ2U7CisJa2J1Zi50b3BfZG93biA9IGZhbHNlOworCisJa2J1Zi5idWZf bWluID0gemltYWdlX29mZnNldDsKKwlrYnVmLmJ1Zl9tYXggPSBVTE9OR19NQVg7CisJa2J1Zi5i dWZmZXIgPSB6aW1hZ2U7CisJa2J1Zi5idWZzeiA9IHppbWFnZV9sZW47CisJa2J1Zi5idWZfYWxp Z24gPSBQQUdFX1NJWkU7CisKKwlrYnVmLm1lbSA9IEtFWEVDX0JVRl9NRU1fVU5LTk9XTjsKKwlr YnVmLm1lbXN6ID0gemltYWdlX2xlbjsKKworCXJldCA9IGtleGVjX2FkZF9idWZmZXIoJmtidWYp OworCWlmIChyZXQpCisJCXJldHVybiBFUlJfUFRSKHJldCk7CisKKwlwcl9kZWJ1ZygiTG9hZGVk IHpJbWFnZSBhdCAweCVseCBidWZzej0weCVseCBtZW1zej0weCVseFxuIiwKKwkJIGtidWYubWVt LCBrYnVmLmJ1ZnN6LCBrYnVmLm1lbXN6KTsKKworCWluaXRyZF9vZmZzZXQgKz0ga2J1Zi5tZW0g LSB6aW1hZ2Vfb2Zmc2V0OworCWRlYnVnX29mZnNldHMoKTsKKworCXppbWFnZV9zZWdtZW50ID0g JmltYWdlLT5zZWdtZW50W2ltYWdlLT5ucl9zZWdtZW50cyAtIDFdOworCWltYWdlLT5zdGFydCA9 IHppbWFnZV9zZWdtZW50LT5tZW07CisKKwlyZXQgPSBsb2FkX290aGVyX3NlZ21lbnRzKGltYWdl LAorCQkJCSAgemltYWdlX3NlZ21lbnQtPm1lbSwgemltYWdlX3NlZ21lbnQtPm1lbXN6LAorCQkJ CSAgaW5pdHJkLCBpbml0cmRfbGVuLCBpbml0cmRfb2Zmc2V0LAorCQkJCSAgY21kbGluZSk7CisJ cmV0dXJuIEVSUl9QVFIocmV0KTsKK30KKworY29uc3Qgc3RydWN0IGtleGVjX2ZpbGVfb3BzIGtl eGVjX3ppbWFnZV9vcHMgPSB7CisJLnByb2JlID0gemltYWdlX3Byb2JlLAorCS5sb2FkID0gemlt YWdlX2xvYWQsCit9OwpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va2VybmVsL21hY2hpbmVfa2V4ZWMu YyBiL2FyY2gvYXJtL2tlcm5lbC9tYWNoaW5lX2tleGVjLmMKaW5kZXggYzEwYTJkZmQ1M2QxLi4y ZTQ3ODBlZmFiYjQgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2tlcm5lbC9tYWNoaW5lX2tleGVjLmMK KysrIGIvYXJjaC9hcm0va2VybmVsL21hY2hpbmVfa2V4ZWMuYwpAQCAtOTMsMTAgKzkzLDEzIEBA IGludCBtYWNoaW5lX2tleGVjX3ByZXBhcmUoc3RydWN0IGtpbWFnZSAqaW1hZ2UpCiAJCQkJCSAg ICAgICBjdXJyZW50X3NlZ21lbnQtPm1lbXN6KSkKIAkJCXJldHVybiAtRUlOVkFMOwogCi0JCWVy ciA9IGdldF91c2VyKGhlYWRlciwgKF9fYmUzMiopY3VycmVudF9zZWdtZW50LT5idWYpOwotCQlp ZiAoZXJyKQotCQkJcmV0dXJuIGVycjsKLQorCQlpZiAoaW1hZ2UtPmZpbGVfbW9kZSkgeworCQkJ aGVhZGVyID0gKihfX2JlMzIgKiljdXJyZW50X3NlZ21lbnQtPmJ1ZjsKKwkJfSBlbHNlIHsKKwkJ CWVyciA9IGdldF91c2VyKGhlYWRlciwgKF9fYmUzMiAqKWN1cnJlbnRfc2VnbWVudC0+YnVmKTsK KwkJCWlmIChlcnIpCisJCQkJcmV0dXJuIGVycjsKKwkJfQogCQlpZiAoaGVhZGVyID09IGNwdV90 b19iZTMyKE9GX0RUX0hFQURFUikpCiAJCQlpbWFnZS0+YXJjaC5rZXJuZWxfcjIgPSBjdXJyZW50 X3NlZ21lbnQtPm1lbTsKIAl9CmRpZmYgLS1naXQgYS9hcmNoL2FybS9rZXJuZWwvbWFjaGluZV9r ZXhlY19maWxlLmMgYi9hcmNoL2FybS9rZXJuZWwvbWFjaGluZV9rZXhlY19maWxlLmMKbmV3IGZp bGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5lYWQ2ODBmMWU3OTUKLS0tIC9kZXYv bnVsbAorKysgYi9hcmNoL2FybS9rZXJuZWwvbWFjaGluZV9rZXhlY19maWxlLmMKQEAgLTAsMCAr MSwyMDkgQEAKKy8vIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisvKgorICoga2V4 ZWNfZmlsZSBmb3IgYXJtCisgKgorICogQ29weXJpZ2h0IChDKSAyMDE4IExpbmFybyBMaW1pdGVk CisgKiBDb3B5cmlnaHQgKEMpIDIwMjAgU2Ftc3VuZyBFbGVjdHJvbmljcworICogQXV0aG9yczoK KyAqICAgICBBS0FTSEkgVGFrYWhpcm8gPHRha2FoaXJvLmFrYXNoaUBsaW5hcm8ub3JnPgorICog ICAgIMWBdWthc3ogU3RlbG1hY2ggPGwuc3RlbG1hY2hAc2Ftc3VuZy5jb20+CisgKgorICovCisK KyNkZWZpbmUgcHJfZm10KGZtdCkgImtleGVjX2ZpbGU6ICIgZm10CisKKyNpbmNsdWRlIDxsaW51 eC9rZXhlYy5oPgorI2luY2x1ZGUgPGxpbnV4L2xpYmZkdC5oPgorI2luY2x1ZGUgPGxpbnV4L29m X2ZkdC5oPgorI2luY2x1ZGUgPGxpbnV4L3JhbmRvbS5oPgorCisvKiByZWxldmFudCBkZXZpY2Ug dHJlZSBwcm9wZXJ0aWVzICovCisjZGVmaW5lIEZEVF9QUk9QX0lOSVRSRF9TVEFSVAkibGludXgs aW5pdHJkLXN0YXJ0IgorI2RlZmluZSBGRFRfUFJPUF9JTklUUkRfRU5ECSJsaW51eCxpbml0cmQt ZW5kIgorI2RlZmluZSBGRFRfUFJPUF9CT09UQVJHUwkiYm9vdGFyZ3MiCisjZGVmaW5lIEZEVF9Q Uk9QX1JOR19TRUVECSJybmctc2VlZCIKKworc3RhdGljIGludCBzZXR1cF9kdGIoc3RydWN0IGtp bWFnZSAqaW1hZ2UsCisJCSAgICAgdW5zaWduZWQgbG9uZyBpbml0cmRfbG9hZF9hZGRyLCB1bnNp Z25lZCBsb25nIGluaXRyZF9sZW4sCisJCSAgICAgY2hhciAqY21kbGluZSwgdm9pZCAqZHRiKQor eworCWludCBvZmYsIHJldDsKKworCXJldCA9IGZkdF9wYXRoX29mZnNldChkdGIsICIvY2hvc2Vu Iik7CisJaWYgKHJldCA8IDApCisJCWdvdG8gb3V0OworCisJb2ZmID0gcmV0OworCisJLyogYWRk IGJvb3RhcmdzICovCisJaWYgKGNtZGxpbmUpIHsKKwkJcmV0ID0gZmR0X3NldHByb3Bfc3RyaW5n KGR0Yiwgb2ZmLCBGRFRfUFJPUF9CT09UQVJHUywgY21kbGluZSk7CisJCWlmIChyZXQpCisJCQln b3RvIG91dDsKKwl9IGVsc2UgeworCQlyZXQgPSBmZHRfZGVscHJvcChkdGIsIG9mZiwgRkRUX1BS T1BfQk9PVEFSR1MpOworCQlpZiAocmV0ICYmIChyZXQgIT0gLUZEVF9FUlJfTk9URk9VTkQpKQor CQkJZ290byBvdXQ7CisJfQorCisJLyogYWRkIGluaXRyZC0qICovCisJaWYgKGluaXRyZF9sb2Fk X2FkZHIpIHsKKwkJcmV0ID0gZmR0X3NldHByb3BfdTY0KGR0Yiwgb2ZmLCBGRFRfUFJPUF9JTklU UkRfU1RBUlQsCisJCQkJICAgICAgaW5pdHJkX2xvYWRfYWRkcik7CisJCWlmIChyZXQpCisJCQln b3RvIG91dDsKKworCQlyZXQgPSBmZHRfc2V0cHJvcF91NjQoZHRiLCBvZmYsIEZEVF9QUk9QX0lO SVRSRF9FTkQsCisJCQkJICAgICAgaW5pdHJkX2xvYWRfYWRkciArIGluaXRyZF9sZW4pOworCQlp ZiAocmV0KQorCQkJZ290byBvdXQ7CisJfSBlbHNlIHsKKwkJcmV0ID0gZmR0X2RlbHByb3AoZHRi LCBvZmYsIEZEVF9QUk9QX0lOSVRSRF9TVEFSVCk7CisJCWlmIChyZXQgJiYgKHJldCAhPSAtRkRU X0VSUl9OT1RGT1VORCkpCisJCQlnb3RvIG91dDsKKworCQlyZXQgPSBmZHRfZGVscHJvcChkdGIs IG9mZiwgRkRUX1BST1BfSU5JVFJEX0VORCk7CisJCWlmIChyZXQgJiYgKHJldCAhPSAtRkRUX0VS Ul9OT1RGT1VORCkpCisJCQlnb3RvIG91dDsKKwl9CisKKwkvKiBhZGQgcm5nLXNlZWQgKi8KKwlp ZiAocm5nX2lzX2luaXRpYWxpemVkKCkpIHsKKwkJY2hhciBzZWVkWzEyOF07CisJCWdldF9yYW5k b21fYnl0ZXMoc2VlZCwgc2l6ZW9mKHNlZWQpKTsKKworCQlyZXQgPSBmZHRfc2V0cHJvcChkdGIs IG9mZiwgRkRUX1BST1BfUk5HX1NFRUQsCisJCQkJICBzZWVkLCBzaXplb2Yoc2VlZCkpOworCQlp ZiAocmV0KQorCQkJZ290byBvdXQ7CisJfSBlbHNlIHsKKwkJcHJfbm90aWNlKCJSTkcgaXMgbm90 IGluaXRpYWxpc2VkOiBvbWl0dGluZyBcIiVzXCIgcHJvcGVydHlcbiIsCisJCQkJRkRUX1BST1Bf Uk5HX1NFRUQpOworCQlyZXQgPSAwOworCX0KKworb3V0OgorCWlmIChyZXQpCisJCXJldHVybiAo cmV0ID09IC1GRFRfRVJSX05PU1BBQ0UpID8gLUVOT01FTSA6IC1FSU5WQUw7CisKKwlyZXR1cm4g MDsKK30KKy8qCisgKiBNb3JlIHNwYWNlIG5lZWRlZCBzbyB0aGF0IHdlIGNhbiBhZGQgaW5pdHJk LCBib290YXJncyBhbmQga2FzbHItc2VlZC4KKyAqLworI2RlZmluZSBEVEJfRVhUUkFfU1BBQ0Ug MHgxMDAwCisKK3N0YXRpYyBpbnQgY3JlYXRlX2R0YihzdHJ1Y3Qga2ltYWdlICppbWFnZSwKKwkJ ICAgICAgdW5zaWduZWQgbG9uZyBpbml0cmRfbG9hZF9hZGRyLCB1bnNpZ25lZCBsb25nIGluaXRy ZF9sZW4sCisJCSAgICAgIGNoYXIgKmNtZGxpbmUsIHZvaWQgKipkdGIpCit7CisJdm9pZCAqYnVm OworCXNpemVfdCBidWZfc2l6ZTsKKwlzaXplX3QgY21kbGluZV9sZW47CisJaW50IHJldDsKKwor CWNtZGxpbmVfbGVuID0gY21kbGluZSA/IHN0cmxlbihjbWRsaW5lKSA6IDA7CisJYnVmX3NpemUg PSBmZHRfdG90YWxzaXplKGluaXRpYWxfYm9vdF9wYXJhbXMpCisJCQkrIGNtZGxpbmVfbGVuICsg RFRCX0VYVFJBX1NQQUNFOworCisJZm9yICg7OykgeworCQlidWYgPSB2bWFsbG9jKGJ1Zl9zaXpl KTsKKwkJaWYgKCFidWYpCisJCQlyZXR1cm4gLUVOT01FTTsKKworCQkvKiBkdXBsaWNhdGUgYSBk ZXZpY2UgdHJlZSBibG9iICovCisJCXJldCA9IGZkdF9vcGVuX2ludG8oaW5pdGlhbF9ib290X3Bh cmFtcywgYnVmLCBidWZfc2l6ZSk7CisJCWlmIChyZXQpCisJCQlyZXR1cm4gLUVJTlZBTDsKKwor CQlyZXQgPSBzZXR1cF9kdGIoaW1hZ2UsIGluaXRyZF9sb2FkX2FkZHIsIGluaXRyZF9sZW4sCisJ CQkJY21kbGluZSwgYnVmKTsKKwkJaWYgKHJldCkgeworCQkJdmZyZWUoYnVmKTsKKwkJCWlmIChy ZXQgPT0gLUVOT01FTSkgeworCQkJCS8qIHVubGlrZWx5LCBidXQganVzdCBpbiBjYXNlICovCisJ CQkJYnVmX3NpemUgKz0gRFRCX0VYVFJBX1NQQUNFOworCQkJCWNvbnRpbnVlOworCQkJfSBlbHNl IHsKKwkJCQlyZXR1cm4gcmV0OworCQkJfQorCQl9CisKKwkJLyogdHJpbSBpdCAqLworCQlmZHRf cGFjayhidWYpOworCQkqZHRiID0gYnVmOworCisJCXJldHVybiAwOworCX0KK30KKworaW50IGxv YWRfb3RoZXJfc2VnbWVudHMoc3RydWN0IGtpbWFnZSAqaW1hZ2UsCisJCQl1bnNpZ25lZCBsb25n IHppbWFnZV9sb2FkX2FkZHIsCisJCQl1bnNpZ25lZCBsb25nIHppbWFnZV9sZW4sCisJCQljaGFy ICppbml0cmQsCisJCQl1bnNpZ25lZCBsb25nIGluaXRyZF9sZW4sCisJCQl1bnNpZ25lZCBsb25n IGluaXRyZF9vZmZzZXQsCisJCQljaGFyICpjbWRsaW5lKQoreworCXN0cnVjdCBrZXhlY19idWYg a2J1ZjsKKwl2b2lkICpkdGIgPSBOVUxMOworCXVuc2lnbmVkIGxvbmcgaW5pdHJkX2xvYWRfYWRk ciA9IDA7CisJdW5zaWduZWQgbG9uZyBkdGJfbGVuOworCWludCByZXQgPSAwOworCisJa2J1Zi5p bWFnZSA9IGltYWdlOworCS8qIG5vdCBhbGxvY2F0ZSBhbnl0aGluZyBiZWxvdyB0aGUga2VybmVs ICovCisJa2J1Zi5idWZfbWluID0gaW5pdHJkX29mZnNldDsKKwlpZiAoaW5pdHJkKSB7CisJCWti dWYuYnVmZmVyID0gaW5pdHJkOworCQlrYnVmLmJ1ZnN6ID0gaW5pdHJkX2xlbjsKKwkJa2J1Zi5t ZW0gPSBLRVhFQ19CVUZfTUVNX1VOS05PV047CisJCWtidWYubWVtc3ogPSBpbml0cmRfbGVuOwor CQlrYnVmLmJ1Zl9hbGlnbiA9IFBBR0VfU0laRTsKKwkJa2J1Zi5idWZfbWF4ID0gVUxPTkdfTUFY OworCQlrYnVmLnRvcF9kb3duID0gZmFsc2U7CisKKwkJcmV0ID0ga2V4ZWNfYWRkX2J1ZmZlcigm a2J1Zik7CisJCWlmIChyZXQpCisJCQlnb3RvIG91dF9lcnI7CisKKwkJcHJfZGVidWcoIkxvYWRl ZCBpbml0cmQgYXQgMHglbHggYnVmc3o9MHglbHggbWVtc3o9MHglbHhcbiIsCisJCQkJa2J1Zi5t ZW0sIGtidWYuYnVmc3osIGtidWYubWVtc3opOworCisJCWluaXRyZF9sb2FkX2FkZHIgPSBrYnVm Lm1lbTsKKwkJa2J1Zi5idWZfbWluID0gaW5pdHJkX2xvYWRfYWRkciArIGtidWYubWVtc3o7CisJ fQorCisJLyogbG9hZCBkdGIgKi8KKwlyZXQgPSBjcmVhdGVfZHRiKGltYWdlLCBpbml0cmRfbG9h ZF9hZGRyLCBpbml0cmRfbGVuLCBjbWRsaW5lLCAmZHRiKTsKKwlpZiAocmV0KSB7CisJCXByX2Vy cigiUHJlcGFyaW5nIGZvciBuZXcgZHRiIGZhaWxlZFxuIik7CisJCWdvdG8gb3V0X2VycjsKKwl9 CisKKwlkdGJfbGVuID0gZmR0X3RvdGFsc2l6ZShkdGIpOworCWtidWYuYnVmZmVyID0gZHRiOwor CWtidWYuYnVmc3ogPSBkdGJfbGVuOworCWtidWYubWVtID0gS0VYRUNfQlVGX01FTV9VTktOT1dO OworCWtidWYubWVtc3ogPSBkdGJfbGVuOworCWtidWYuYnVmX2FsaWduID0gUEFHRV9TSVpFOwor CWtidWYuYnVmX21heCA9IFVMT05HX01BWDsKKwlrYnVmLnRvcF9kb3duID0gZmFsc2U7CisKKwly ZXQgPSBrZXhlY19hZGRfYnVmZmVyKCZrYnVmKTsKKwlpZiAocmV0KQorCQlnb3RvIG91dF9lcnI7 CisKKwlwcl9kZWJ1ZygiTG9hZGVkIGR0YiBhdCAweCVseCBidWZzej0weCVseCBtZW1zej0weCVs eFxuIiwKKwkJIGtidWYubWVtLCBrYnVmLmJ1ZnN6LCBrYnVmLm1lbXN6KTsKKwlyZXR1cm4gMDsK K291dF9lcnI6CisJdmZyZWUoZHRiKTsKKwlyZXR1cm4gcmV0OworfQorCitjb25zdCBzdHJ1Y3Qg a2V4ZWNfZmlsZV9vcHMgKiBjb25zdCBrZXhlY19maWxlX2xvYWRlcnNbXSA9IHsKKwkma2V4ZWNf dWltYWdlX29wcywKKwkma2V4ZWNfemltYWdlX29wcywKKwlOVUxMCit9OwotLSAKMi4yNi4yCgoK X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX18KbGludXgtYXJt LWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtlcm5lbEBsaXN0cy5pbmZyYWRlYWQub3Jn Cmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtYXJtLWtl cm5lbAo=