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=-10.8 required=3.0 tests=BAYES_00,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,URIBL_BLOCKED,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 BD303C4727E for ; Wed, 30 Sep 2020 18:39:36 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 5E4F02076B for ; Wed, 30 Sep 2020 18:39:36 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="cjZpMEai" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729767AbgI3Sje (ORCPT ); Wed, 30 Sep 2020 14:39:34 -0400 Received: from mailout1.w1.samsung.com ([210.118.77.11]:54050 "EHLO mailout1.w1.samsung.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727438AbgI3Sj1 (ORCPT ); Wed, 30 Sep 2020 14:39:27 -0400 Received: from eucas1p1.samsung.com (unknown [182.198.249.206]) by mailout1.w1.samsung.com (KnoxPortal) with ESMTP id 20200930183925euoutp01ff31d8bb418b016f5cbb21450bcab965~5o7r8MrTo2669126691euoutp01n for ; Wed, 30 Sep 2020 18:39:25 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout1.w1.samsung.com 20200930183925euoutp01ff31d8bb418b016f5cbb21450bcab965~5o7r8MrTo2669126691euoutp01n DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1601491166; bh=DEzENPvTzIj7n5HipV9UGgMD2am2karJlQJEh31H+LM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=cjZpMEaisjAmfNcmBOu74tchVEjynlB7dzd5n+cqcXe1bpOEABi0QTxtWj/HAGvbg vwlioxBZLiQoQLowp+sywwJAvLlcvywi2VFwm2Z9v2TpMjKZY1KIEMHkGQ5TZ+8CmH HN7qDKUHcjVHKm0ujLChA2hhyYFzmbyn19RLV+oQ= Received: from eusmges1new.samsung.com (unknown [203.254.199.242]) by eucas1p2.samsung.com (KnoxPortal) with ESMTP id 20200930183925eucas1p250bf18c8799f50a93d8495f722068afd~5o7rSHAac0658306583eucas1p2v; Wed, 30 Sep 2020 18:39:25 +0000 (GMT) Received: from eucas1p1.samsung.com ( [182.198.249.206]) by eusmges1new.samsung.com (EUCPMTA) with SMTP id 97.A1.06456.DD0D47F5; Wed, 30 Sep 2020 19:39:25 +0100 (BST) Received: from eusmtrp2.samsung.com (unknown [182.198.249.139]) by eucas1p2.samsung.com (KnoxPortal) with ESMTPA id 20200930183924eucas1p281730f3d651fc2c78d6a95e47a2c5220~5o7q_epOQ0657106571eucas1p2-; Wed, 30 Sep 2020 18:39:24 +0000 (GMT) Received: from eusmgms1.samsung.com (unknown [182.198.249.179]) by eusmtrp2.samsung.com (KnoxPortal) with ESMTP id 20200930183924eusmtrp2c72d8659d0d5c71bd05236561ff2f419~5o7q9xwoi3109431094eusmtrp2E; Wed, 30 Sep 2020 18:39:24 +0000 (GMT) X-AuditID: cbfec7f2-809ff70000001938-65-5f74d0dddcd7 Received: from eusmtip1.samsung.com ( [203.254.199.221]) by eusmgms1.samsung.com (EUCPMTA) with SMTP id 47.F8.06314.CD0D47F5; Wed, 30 Sep 2020 19:39:24 +0100 (BST) Received: from localhost (unknown [106.120.51.46]) by eusmtip1.samsung.com (KnoxPortal) with ESMTPA id 20200930183924eusmtip118188b92986ebbbf676216b0b1ce10b6~5o7qxhqgL2620826208eusmtip1R; Wed, 30 Sep 2020 18:39:24 +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, AKASHI Takahiro , kexec@lists.infradead.org, Dave Young Cc: Bartlomiej Zolnierkiewicz , Marek Szyprowski , =?UTF-8?q?=C5=81ukasz=20Stelmach?= Subject: [PATCH v3 4/4] arm: kexec_file: load zImage or uImage, initrd and dtb Date: Wed, 30 Sep 2020 20:34:13 +0200 Message-Id: <20200930183413.17023-5-l.stelmach@samsung.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20200930183413.17023-1-l.stelmach@samsung.com> MIME-Version: 1.0 Organization: Samsung R&D Institute Poland Content-Transfer-Encoding: 8bit X-Brightmail-Tracker: H4sIAAAAAAAAA02Sf0yMcRzH973nueee0vF0tfURilsxoTTkoZjM5tmwNf4z5OjZ+dFd7X5E LN1hUYmcpVytQrpcKS5CP7BjRdH0U1mtIxUpWj/oyKXrOdN/n+/n/Xp/3p/P9iUx0SDfkzws V7EKuSRSTDjjZdXW+hWdb1XhK29rXOh7GSV8Wlf8jEdrLmtwul1bwaNfJ8voiroxHt1uLkC0 qbuVTzeVZxG0Oa0K0XdedAroD5Y2Pl1oq0X0UOokj554asXpUlMatolimlobMCZT04Azf4yf MSbXpGZMxkSC6WitJJhv9fUCpjQvnkkdGiSY709aCObifSNiRkxeYS67nUMi2MjDMawiYON+ 50Ndxtf8aFM2Ov7jYTqmQfnxSciJBGo1dFtKiSTkTIqoAgTa3494dkFEjSIY/rqUE0YQ6IrK 8X+O6wmvBJxgQHC29qPD3oegeSgb2SmCCoVLt17y7YI7ZcGgP82A2x8YlY9gMmOAb6fcqDBI emuZDsQpX2gZ75rOEFLB0D1mRVyeN5wzPCTstRMVAo1vXhAc4wqvrn2a5udQflB0+t10jU3x Zx5kYvYwoG6T0POtheAGbQHt8wLHEW7QX3NfwNXzYfJxztQS5FQdD1d0QZz3AoKyrHEHHwwd 9b8IO4NRS6GkPIBrh0JLfrPDOhvaBl25FWaDriwd49pCOJ8g4mgfKL5U6RjoCSn9BSgVifUz jtHPOED/PysXYUbkwaqVMimrDJSzx/yVEplSLZf6H4ySmdDUJ6yz1Qw/QmONB8yIIpHYRZgq V4WL+JIYZazMjIDExO7CzW/q9omEEZLYE6wiKlyhjmSVZjSPxMUewlU3vuwVUVKJij3KstGs 4p/KI508NehqtTozbp7v1mWGm3u2//TV7SxZuFgrkActsrkvsCyLqDqVNlHrdfJr/tq5s5Zc GQ/UBy5hbLuk+tH3OXd83fryVIWjdyuKe7B2w5pt2AbP5b9u1BwJifzZGxZdvW58vY/FvSJg R+KAtdZP3t/71Lp7T3nvOVtr3OiC5JQs4Q5XrfcuMa48JAn0wxRKyV8UKpq4gAMAAA== X-Brightmail-Tracker: H4sIAAAAAAAAA02SbUhTURzGObt3d1Mc3a6GJ7GUgQRS0+s0j/lC9iHup4jKL/m69KKW22R3 MxXCZaA5QbdA0pliplZLE2dpZGYNcTp1+LqSFA1N/NCLWYqCaXsh8tvDeX7Pc/5/zhFi1B4e IMxVqFmVQpYnJrzx0T3rwqn5CXV6+O5kFOqq7eSje8/f8ZDWoMXR3O0+HhqrlKO+0U0emrM8 Aci87OCj6dcPCGSp6QeoY3BBgD4vfeSjZ3s2gNb1+zy0O7CDo25zDXaWZKYdkxhTr53EmT+m NYxpMmsYs6mCYOYdbwjmu90uYLpbShj9+jeC+fF2lmCqXpgA88t8/KLPVUmcSqlRs8E5Sk4d L06mUYSEjkGSiMgYCS2NTj0TESUOS4jLYvNyC1hVWEKGJGfRNMbPNzeCwq3e+5gWtJXogJcQ kpHwYdmIQAe8hRTZCqB+sgvXAaHTCIBPG7I9jC/cdegID/MFwEWLQeAyCDIRVrcO812GH/kV g+WGVTeFkW0APtqv5rsoX/ICtE2tYC6NkyFwdnsRd2kRGQuXN3eA54ogWP64l3BpLzIOTo0P ujVFymGvYYPn4Q/DkboV93QYeQJ2NlKu40NkKGwv/eCuxJw1d17WY3pAGQ8kjP8TxgNUE8BM wI/VcPJsOUdLOJmc0yiyJZlKuRk4375naKf7FZjqumwBpBCIfUR6hTqd4ssKuCK5BUAhJvYT nRsfTaNEWbKiYlalTFdp8ljOAqKcaxqwgCOZSudPcmboKDoaxdDR0mjpaST2F90l36dQZLZM zd5g2XxW9S/HE3oFaMHJ2PagGd+WqhnrTKIthLYlOkrltR03t2OTzmfMrHWFC34vTT8e3G4w 2ptTTWX9yRX2QG3w1sKnS0cDHde6Nfn+Q9PNgCiUDvMHV7O2h5LEx0Troh7qimxgROqrHh4J /LkXcb2vcgLPid9IDEsZWym9ZRWMmo1Il1ZUXGdNE+NcjowOxVSc7C8VP7ccEQMAAA== X-CMS-MailID: 20200930183924eucas1p281730f3d651fc2c78d6a95e47a2c5220 X-Msg-Generator: CA Content-Type: text/plain; charset="utf-8" X-RootMTR: 20200930183924eucas1p281730f3d651fc2c78d6a95e47a2c5220 X-EPHeader: CA CMS-TYPE: 201P X-CMS-RootMailID: 20200930183924eucas1p281730f3d651fc2c78d6a95e47a2c5220 References: <20200601142754.26139-1-l.stelmach@samsung.com> <20200930183413.17023-1-l.stelmach@samsung.com> 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 | 26 ++++ arch/arm/include/asm/image.h | 26 ++++ arch/arm/include/asm/kexec.h | 16 +- arch/arm/kernel/Makefile | 5 +- arch/arm/kernel/kexec_uimage.c | 80 ++++++++++ arch/arm/kernel/kexec_zimage.c | 197 +++++++++++++++++++++++++ arch/arm/kernel/machine_kexec.c | 11 +- arch/arm/kernel/machine_kexec_file.c | 211 +++++++++++++++++++++++++++ 8 files changed, 566 insertions(+), 6 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 fe2f17eb2b50..65e5540f3ed1 100644 --- a/arch/arm/Kconfig +++ b/arch/arm/Kconfig @@ -1873,6 +1873,32 @@ 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 MMU + depends on USE_OF + select KEXEC_CORE + select CRC32 + help + This is a 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 KEXEC_FILE_UIMAGE + bool "Load legacy uImage files with kexec_file_load() (EXPERIMENTAL)" + depends on KEXEC_FILE + default n + help + This options enables support for the legacy uImage files as + created by mkimage. These are not the new FIT files. + + If unsure say N. + 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 8be6dbc69fbb..15c4fe031d90 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..8e4d0d92269b 100644 --- a/arch/arm/include/asm/kexec.h +++ b/arch/arm/include/asm/kexec.h @@ -2,7 +2,7 @@ #ifndef _ARM_KEXEC_H #define _ARM_KEXEC_H -#ifdef CONFIG_KEXEC +#if defined(CONFIG_KEXEC) || defined(CONFIG_KEXEC_FILE) /* Maximum physical address we can use pages from */ #define KEXEC_SOURCE_MEMORY_LIMIT (-1UL) @@ -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..453ecf7305e2 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 +obj-$(CONFIG_KEXEC_FILE_UIMAGE) += 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..543229a42793 --- /dev/null +++ b/arch/arm/kernel/kexec_zimage.c @@ -0,0 +1,197 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Kexec zImage loader + * + * Copyright (C) 2020 Samsung Electronics + * Authors: + * Łukasz Stelmach + * + * Based on earlier works for kexec-tools by + * Russell King + * + */ + +#define pr_fmt(fmt) "kexec_file(zImage): " fmt + +#include +#include +#include +#include +#include + +#define byte_size(t) ((t)->hdr.size << 2) + +/* + * This function and several pieces below have been taken from + * kexec-tools/kexec/arch/arm/kexec-zImage-arm.c + */ +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 *tag; + int ret = -EINVAL; + + unsigned long zimage_mem = 0x20000; /* malloc 64kB + stack 4 kB + some bss */ + unsigned long kernel_len = zimage_len * 5; /* 5:1 compression */ + unsigned long kernel_offset = memblock_start_of_DRAM(); + 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; + + tag = find_extension_tag(zimage, zimage_len, ZIMAGE_TAG_KRNL_SIZE); + if (tag) { + uint32_t *p = (void *)zimage + + le32_to_cpu(tag->u.krnl_size.size_ptr); + uint32_t edata_size = le32_to_cpu(get_unaligned(p)); + uint32_t bss_size = le32_to_cpu(tag->u.krnl_size.bss_size); + uint32_t text_offset = le32_to_cpu(tag->u.krnl_size.text_offset); + + kernel_offset += ALIGN(text_offset, PAGE_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(); + } + + tag = find_extension_tag(zimage, zimage_len, + ZIMAGE_TAG_ZIMAGE_MEM); + if (tag) { + uint32_t zimage_mem = le32_to_cpu(tag->u.zimage_mem); + + pr_debug("Decompressor requires %d bytes of memory\n", zimage_mem); + + initrd_offset = max(ALIGN(zimage_offset + zimage_len + zimage_mem, 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 a0c229eec0b2..b349d6b8d18c 100644 --- a/arch/arm/kernel/machine_kexec.c +++ b/arch/arm/kernel/machine_kexec.c @@ -91,10 +91,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..a632d351602c --- /dev/null +++ b/arch/arm/kernel/machine_kexec_file.c @@ -0,0 +1,211 @@ +// 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[] = { +#ifdef CONFIG_KEXEC_FILE_UIMAGE + &kexec_uimage_ops, +#endif + &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=-10.7 required=3.0 tests=BAYES_00,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,URIBL_BLOCKED,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 6D848C4727C for ; Wed, 30 Sep 2020 18:41:58 +0000 (UTC) Received: from merlin.infradead.org (merlin.infradead.org [205.233.59.134]) (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 EBAEC20708 for ; Wed, 30 Sep 2020 18:41:57 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=lists.infradead.org header.i=@lists.infradead.org header.b="PbBLtlj5"; dkim=fail reason="signature verification failed" (1024-bit key) header.d=samsung.com header.i=@samsung.com header.b="cjZpMEai" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org EBAEC20708 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+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=merlin.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=KoVPrynRW1a04CitQKaIeVixQbIqs93mOnAWuhku4Nc=; b=PbBLtlj5MNLX8ggrctuOcsRkh qIyuU5N+y4GIN+vwSkJOGK9zOFjZOcQroulupNR3Pc4yJ67j1aHJXPz4ll3WQHgKdaChU6k8pV78n Gm61P9D/0pz7BOCOgoqu/aMUoDKpIrtKRDhmxkDalu66toOR5yftlI1hAlUlpMjk1qSHtVLDGpU4a hbDhEKJDE//eb+XJtF0/8Nz2k4mef1r+QwwnoRukQxJsZbu60WQYkkDl2a8sd8N1IGE1GoxJ1olag 56KVchtLkTBv3z6UNI1NPhcn8A7j8ScELsEOyfGOJI0HQx6Z5PWKVWyhih8G0Crs7n791B8HacyeD /ctiDLajw==; Received: from localhost ([::1] helo=merlin.infradead.org) by merlin.infradead.org with esmtp (Exim 4.92.3 #3 (Red Hat Linux)) id 1kNh1Q-0004BU-KF; Wed, 30 Sep 2020 18:40:12 +0000 Received: from mailout2.w1.samsung.com ([210.118.77.12]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1kNh0h-0003t8-9w for linux-arm-kernel@lists.infradead.org; Wed, 30 Sep 2020 18:39:35 +0000 Received: from eucas1p1.samsung.com (unknown [182.198.249.206]) by mailout2.w1.samsung.com (KnoxPortal) with ESMTP id 20200930183925euoutp0276256a802ab27cc57c167f734b70660f~5o7r7HIOn0171701717euoutp02s for ; Wed, 30 Sep 2020 18:39:25 +0000 (GMT) DKIM-Filter: OpenDKIM Filter v2.11.0 mailout2.w1.samsung.com 20200930183925euoutp0276256a802ab27cc57c167f734b70660f~5o7r7HIOn0171701717euoutp02s DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=samsung.com; s=mail20170921; t=1601491166; bh=DEzENPvTzIj7n5HipV9UGgMD2am2karJlQJEh31H+LM=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=cjZpMEaisjAmfNcmBOu74tchVEjynlB7dzd5n+cqcXe1bpOEABi0QTxtWj/HAGvbg vwlioxBZLiQoQLowp+sywwJAvLlcvywi2VFwm2Z9v2TpMjKZY1KIEMHkGQ5TZ+8CmH HN7qDKUHcjVHKm0ujLChA2hhyYFzmbyn19RLV+oQ= Received: from eusmges1new.samsung.com (unknown [203.254.199.242]) by eucas1p2.samsung.com (KnoxPortal) with ESMTP id 20200930183925eucas1p250bf18c8799f50a93d8495f722068afd~5o7rSHAac0658306583eucas1p2v; Wed, 30 Sep 2020 18:39:25 +0000 (GMT) Received: from eucas1p1.samsung.com ( [182.198.249.206]) by eusmges1new.samsung.com (EUCPMTA) with SMTP id 97.A1.06456.DD0D47F5; Wed, 30 Sep 2020 19:39:25 +0100 (BST) Received: from eusmtrp2.samsung.com (unknown [182.198.249.139]) by eucas1p2.samsung.com (KnoxPortal) with ESMTPA id 20200930183924eucas1p281730f3d651fc2c78d6a95e47a2c5220~5o7q_epOQ0657106571eucas1p2-; Wed, 30 Sep 2020 18:39:24 +0000 (GMT) Received: from eusmgms1.samsung.com (unknown [182.198.249.179]) by eusmtrp2.samsung.com (KnoxPortal) with ESMTP id 20200930183924eusmtrp2c72d8659d0d5c71bd05236561ff2f419~5o7q9xwoi3109431094eusmtrp2E; Wed, 30 Sep 2020 18:39:24 +0000 (GMT) X-AuditID: cbfec7f2-809ff70000001938-65-5f74d0dddcd7 Received: from eusmtip1.samsung.com ( [203.254.199.221]) by eusmgms1.samsung.com (EUCPMTA) with SMTP id 47.F8.06314.CD0D47F5; Wed, 30 Sep 2020 19:39:24 +0100 (BST) Received: from localhost (unknown [106.120.51.46]) by eusmtip1.samsung.com (KnoxPortal) with ESMTPA id 20200930183924eusmtip118188b92986ebbbf676216b0b1ce10b6~5o7qxhqgL2620826208eusmtip1R; Wed, 30 Sep 2020 18:39:24 +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, AKASHI Takahiro , kexec@lists.infradead.org, Dave Young Subject: [PATCH v3 4/4] arm: kexec_file: load zImage or uImage, initrd and dtb Date: Wed, 30 Sep 2020 20:34:13 +0200 Message-Id: <20200930183413.17023-5-l.stelmach@samsung.com> X-Mailer: git-send-email 2.26.2 In-Reply-To: <20200930183413.17023-1-l.stelmach@samsung.com> MIME-Version: 1.0 Organization: Samsung R&D Institute Poland X-Brightmail-Tracker: H4sIAAAAAAAAA02Sf0yMcRzH973nueee0vF0tfURilsxoTTkoZjM5tmwNf4z5OjZ+dFd7X5E LN1hUYmcpVytQrpcKS5CP7BjRdH0U1mtIxUpWj/oyKXrOdN/n+/n/Xp/3p/P9iUx0SDfkzws V7EKuSRSTDjjZdXW+hWdb1XhK29rXOh7GSV8Wlf8jEdrLmtwul1bwaNfJ8voiroxHt1uLkC0 qbuVTzeVZxG0Oa0K0XdedAroD5Y2Pl1oq0X0UOokj554asXpUlMatolimlobMCZT04Azf4yf MSbXpGZMxkSC6WitJJhv9fUCpjQvnkkdGiSY709aCObifSNiRkxeYS67nUMi2MjDMawiYON+ 50Ndxtf8aFM2Ov7jYTqmQfnxSciJBGo1dFtKiSTkTIqoAgTa3494dkFEjSIY/rqUE0YQ6IrK 8X+O6wmvBJxgQHC29qPD3oegeSgb2SmCCoVLt17y7YI7ZcGgP82A2x8YlY9gMmOAb6fcqDBI emuZDsQpX2gZ75rOEFLB0D1mRVyeN5wzPCTstRMVAo1vXhAc4wqvrn2a5udQflB0+t10jU3x Zx5kYvYwoG6T0POtheAGbQHt8wLHEW7QX3NfwNXzYfJxztQS5FQdD1d0QZz3AoKyrHEHHwwd 9b8IO4NRS6GkPIBrh0JLfrPDOhvaBl25FWaDriwd49pCOJ8g4mgfKL5U6RjoCSn9BSgVifUz jtHPOED/PysXYUbkwaqVMimrDJSzx/yVEplSLZf6H4ySmdDUJ6yz1Qw/QmONB8yIIpHYRZgq V4WL+JIYZazMjIDExO7CzW/q9omEEZLYE6wiKlyhjmSVZjSPxMUewlU3vuwVUVKJij3KstGs 4p/KI508NehqtTozbp7v1mWGm3u2//TV7SxZuFgrkActsrkvsCyLqDqVNlHrdfJr/tq5s5Zc GQ/UBy5hbLuk+tH3OXd83fryVIWjdyuKe7B2w5pt2AbP5b9u1BwJifzZGxZdvW58vY/FvSJg R+KAtdZP3t/71Lp7T3nvOVtr3OiC5JQs4Q5XrfcuMa48JAn0wxRKyV8UKpq4gAMAAA== X-Brightmail-Tracker: H4sIAAAAAAAAA02SbUhTURzGObt3d1Mc3a6GJ7GUgQRS0+s0j/lC9iHup4jKL/m69KKW22R3 MxXCZaA5QbdA0pliplZLE2dpZGYNcTp1+LqSFA1N/NCLWYqCaXsh8tvDeX7Pc/5/zhFi1B4e IMxVqFmVQpYnJrzx0T3rwqn5CXV6+O5kFOqq7eSje8/f8ZDWoMXR3O0+HhqrlKO+0U0emrM8 Aci87OCj6dcPCGSp6QeoY3BBgD4vfeSjZ3s2gNb1+zy0O7CDo25zDXaWZKYdkxhTr53EmT+m NYxpMmsYs6mCYOYdbwjmu90uYLpbShj9+jeC+fF2lmCqXpgA88t8/KLPVUmcSqlRs8E5Sk4d L06mUYSEjkGSiMgYCS2NTj0TESUOS4jLYvNyC1hVWEKGJGfRNMbPNzeCwq3e+5gWtJXogJcQ kpHwYdmIQAe8hRTZCqB+sgvXAaHTCIBPG7I9jC/cdegID/MFwEWLQeAyCDIRVrcO812GH/kV g+WGVTeFkW0APtqv5rsoX/ICtE2tYC6NkyFwdnsRd2kRGQuXN3eA54ogWP64l3BpLzIOTo0P ujVFymGvYYPn4Q/DkboV93QYeQJ2NlKu40NkKGwv/eCuxJw1d17WY3pAGQ8kjP8TxgNUE8BM wI/VcPJsOUdLOJmc0yiyJZlKuRk4375naKf7FZjqumwBpBCIfUR6hTqd4ssKuCK5BUAhJvYT nRsfTaNEWbKiYlalTFdp8ljOAqKcaxqwgCOZSudPcmboKDoaxdDR0mjpaST2F90l36dQZLZM zd5g2XxW9S/HE3oFaMHJ2PagGd+WqhnrTKIthLYlOkrltR03t2OTzmfMrHWFC34vTT8e3G4w 2ptTTWX9yRX2QG3w1sKnS0cDHde6Nfn+Q9PNgCiUDvMHV7O2h5LEx0Troh7qimxgROqrHh4J /LkXcb2vcgLPid9IDEsZWym9ZRWMmo1Il1ZUXGdNE+NcjowOxVSc7C8VP7ccEQMAAA== X-CMS-MailID: 20200930183924eucas1p281730f3d651fc2c78d6a95e47a2c5220 X-Msg-Generator: CA X-RootMTR: 20200930183924eucas1p281730f3d651fc2c78d6a95e47a2c5220 X-EPHeader: CA CMS-TYPE: 201P X-CMS-RootMailID: 20200930183924eucas1p281730f3d651fc2c78d6a95e47a2c5220 References: <20200601142754.26139-1-l.stelmach@samsung.com> <20200930183413.17023-1-l.stelmach@samsung.com> X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20200930_143927_666582_C8A2BDE2 X-CRM114-Status: GOOD ( 33.16 ) 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: 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+linux-arm-kernel=archiver.kernel.org@lists.infradead.org VGhpcyBpcyBrZXhlY19maWxlX2xvYWQgaW1wbGVtZW50YXRpb24gZm9yIEFSTS4gSXQgbG9hZHMg ekltYWdlIGFuZAppbml0cmQgZnJvbSBmaWxlIGRlc2NyaXB0ZXJzIGFuZCByZXN1c2VzIERUQi4K Ck1vc3QgY29kZSBpcyBkZXJpdmVkIGZyb20gYXJtNjQga2V4ZWNfZmlsZV9sb2FkIGltcGxlbWVu dGF0aW9uCmFuZCBmcm9tIGtleGVjLXRvb2xzLgoKQ2M6IEFLQVNISSBUYWthaGlybyA8dGFrYWhp cm8uYWthc2hpQGxpbmFyby5vcmc+ClNpZ25lZC1vZmYtYnk6IMWBdWthc3ogU3RlbG1hY2ggPGwu c3RlbG1hY2hAc2Ftc3VuZy5jb20+Ci0tLQogYXJjaC9hcm0vS2NvbmZpZyAgICAgICAgICAgICAg ICAgICAgIHwgIDI2ICsrKysKIGFyY2gvYXJtL2luY2x1ZGUvYXNtL2ltYWdlLmggICAgICAgICB8 ICAyNiArKysrCiBhcmNoL2FybS9pbmNsdWRlL2FzbS9rZXhlYy5oICAgICAgICAgfCAgMTYgKy0K IGFyY2gvYXJtL2tlcm5lbC9NYWtlZmlsZSAgICAgICAgICAgICB8ICAgNSArLQogYXJjaC9hcm0v a2VybmVsL2tleGVjX3VpbWFnZS5jICAgICAgIHwgIDgwICsrKysrKysrKysKIGFyY2gvYXJtL2tl cm5lbC9rZXhlY196aW1hZ2UuYyAgICAgICB8IDE5NyArKysrKysrKysrKysrKysrKysrKysrKysr CiBhcmNoL2FybS9rZXJuZWwvbWFjaGluZV9rZXhlYy5jICAgICAgfCAgMTEgKy0KIGFyY2gvYXJt L2tlcm5lbC9tYWNoaW5lX2tleGVjX2ZpbGUuYyB8IDIxMSArKysrKysrKysrKysrKysrKysrKysr KysrKysKIDggZmlsZXMgY2hhbmdlZCwgNTY2IGluc2VydGlvbnMoKyksIDYgZGVsZXRpb25zKC0p CiBjcmVhdGUgbW9kZSAxMDA2NDQgYXJjaC9hcm0va2VybmVsL2tleGVjX3VpbWFnZS5jCiBjcmVh dGUgbW9kZSAxMDA2NDQgYXJjaC9hcm0va2VybmVsL2tleGVjX3ppbWFnZS5jCiBjcmVhdGUgbW9k ZSAxMDA2NDQgYXJjaC9hcm0va2VybmVsL21hY2hpbmVfa2V4ZWNfZmlsZS5jCgpkaWZmIC0tZ2l0 IGEvYXJjaC9hcm0vS2NvbmZpZyBiL2FyY2gvYXJtL0tjb25maWcKaW5kZXggZmUyZjE3ZWIyYjUw Li42NWU1NTQwZjNlZDEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL0tjb25maWcKKysrIGIvYXJjaC9h cm0vS2NvbmZpZwpAQCAtMTg3Myw2ICsxODczLDMyIEBAIGNvbmZpZyBLRVhFQwogCSAgaXMgcHJv cGVybHkgc2h1dGRvd24sIHNvIGRvIG5vdCBiZSBzdXJwcmlzZWQgaWYgdGhpcyBjb2RlIGRvZXMg bm90CiAJICBpbml0aWFsbHkgd29yayBmb3IgeW91LgogCitjb25maWcgS0VYRUNfRklMRQorCWJv b2wgIktleGVjIGZpbGUgYmFzZWQgc3lzdGVtIGNhbGwgKEVYUEVSSU1FTlRBTCkiCisJZGVwZW5k cyBvbiAoIVNNUCB8fCBQTV9TTEVFUF9TTVApCisJZGVwZW5kcyBvbiBNTVUKKwlkZXBlbmRzIG9u IFVTRV9PRgorCXNlbGVjdCBLRVhFQ19DT1JFCisJc2VsZWN0IENSQzMyCisJaGVscAorCSAgVGhp cyBpcyBhIG5ldyB2ZXJzaW9uIG9mIGtleGVjIHN5c3RlbSBjYWxsLiBUaGlzIHN5c3RlbSBjYWxs IGlzCisJICBmaWxlIGJhc2VkIGFuZCB0YWtlcyBmaWxlIGRlc2NyaXB0b3JzIGFzIHN5c3RlbSBj YWxsIGFyZ3VtZW50CisJICBmb3Iga2VybmVsIGFuZCBpbml0cmFtZnMgYXMgb3Bwb3NlZCB0byBs aXN0IG9mIHNlZ21lbnRzIGFzCisJICBhY2NlcHRlZCBieSBwcmV2aW91cyBzeXN0ZW0gY2FsbC4K KworCSAgVGhlIGtlcm5lbCB0byBiZSBsb2FkZWQgTVVTVCBzdXBwb3J0IEZsYXR0ZW5lZCBEZXZp Y2UgVHJlZQorCSAgKHNlbGVjdGVkIHdpdGggQ09ORklHX1VTRV9PRikuCisKK2NvbmZpZyBLRVhF Q19GSUxFX1VJTUFHRQorCWJvb2wgIkxvYWQgbGVnYWN5IHVJbWFnZSBmaWxlcyB3aXRoIGtleGVj X2ZpbGVfbG9hZCgpIChFWFBFUklNRU5UQUwpIgorCWRlcGVuZHMgb24gS0VYRUNfRklMRQorCWRl ZmF1bHQgbgorCWhlbHAKKwkgIFRoaXMgb3B0aW9ucyBlbmFibGVzIHN1cHBvcnQgZm9yIHRoZSBs ZWdhY3kgdUltYWdlIGZpbGVzIGFzCisJICBjcmVhdGVkIGJ5IG1raW1hZ2UuIFRoZXNlIGFyZSBu b3QgdGhlIG5ldyBGSVQgZmlsZXMuCisKKwkgIElmIHVuc3VyZSBzYXkgTi4KKwogY29uZmlnIEFU QUdTX1BST0MKIAlib29sICJFeHBvcnQgYXRhZ3MgaW4gcHJvY2ZzIgogCWRlcGVuZHMgb24gQVRB R1MgJiYgS0VYRUMKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2ltYWdlLmggYi9h cmNoL2FybS9pbmNsdWRlL2FzbS9pbWFnZS5oCmluZGV4IDhiZTZkYmM2OWZiYi4uMTVjNGZlMDMx ZDkwIDEwMDY0NAotLS0gYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9pbWFnZS5oCisrKyBiL2FyY2gv YXJtL2luY2x1ZGUvYXNtL2ltYWdlLmgKQEAgLTgsOCArOCwxMyBAQAogCQkJICgoKHgpID4+ICA4 KSAmIDB4MDAwMGZmMDApIHwgIFwKIAkJCSAoKCh4KSA8PCAgOCkgJiAweDAwZmYwMDAwKSB8ICBc CiAJCQkgKCgoeCkgPDwgMjQpICYgMHhmZjAwMDAwMCkpCisjZGVmaW5lIFVJTUFHRV9NQUdJQyh4 KSAoeCkKICNlbHNlCiAjZGVmaW5lIFpJTUFHRV9NQUdJQyh4KSAoeCkKKyNkZWZpbmUgVUlNQUdF X01BR0lDKHgpICgoKCh4KSA+PiAyNCkgJiAweDAwMDAwMGZmKSB8IFwKKwkJCSAoKCh4KSA+PiAg OCkgJiAweDAwMDBmZjAwKSB8ICBcCisJCQkgKCgoeCkgPDwgIDgpICYgMHgwMGZmMDAwMCkgfCAg XAorCQkJICgoKHgpIDw8IDI0KSAmIDB4ZmYwMDAwMDApKQogI2VuZGlmCiAKICNkZWZpbmUgQVJN X1pJTUFHRV9NQUdJQzEgWklNQUdFX01BR0lDKDB4MDE2ZjI4MTgpCkBAIC0xNyw2ICsyMiwxMiBA QAogI2RlZmluZSBBUk1fWklNQUdFX01BR0lDMyBaSU1BR0VfTUFHSUMoMHg1YTUzNGM0YikKICNk ZWZpbmUgQVJNX1pJTUFHRV9NQUdJQzQgWklNQUdFX01BR0lDKDB4NWE1MzQzNDQpCiAKKyNkZWZp bmUgQVJNX1VJTUFHRV9NQUdJQyBVSU1BR0VfTUFHSUMoMHgyNzA1MTk1NikKKyNkZWZpbmUgQVJN X1VJTUFHRV9OQU1FX0xFTgkJMzIKKyNkZWZpbmUgQVJNX1VJTUFHRV9UWVBFX0tFUk5FTAkJMgor I2RlZmluZSBBUk1fVUlNQUdFX1RZUEVfS0VSTkVMX05PTE9BRAkxNAorI2RlZmluZSBBUk1fVUlN QUdFX0FSQ0hfQVJNCQkyCisKICNpZm5kZWYgX19BU1NFTUJMWV9fCiAKICNpbmNsdWRlIDxsaW51 eC90eXBlcy5oPgpAQCAtMzMsNiArNDQsMjEgQEAgc3RydWN0IGFybV96aW1hZ2VfaGVhZGVyIHsK IAlfX2xlMzIgZXh0ZW5zaW9uX3RhZ19vZmZzZXQ7CiB9OwogCitzdHJ1Y3QgYXJtX3VpbWFnZV9o ZWFkZXIgeworCV9fYmUzMiBtYWdpYzsKKwlfX2JlMzIgaGRyX2NyYzsKKwlfX2JlMzIgdGltZTsK KwlfX2JlMzIgc2l6ZTsKKwlfX2JlMzIgbG9hZDsKKwlfX2JlMzIgZW50cnk7CisJX19iZTMyIGNy YzsKKwlfX3U4ICAgb3M7CisJX191OCAgIGFyY2g7CisJX191OCAgIHR5cGU7CisJX191OCAgIGNv bXA7CisJX191OCAgIG5hbWVbQVJNX1VJTUFHRV9OQU1FX0xFTl07Cit9OworCiBzdHJ1Y3QgYXJt X3ppbWFnZV90YWcgewogCXN0cnVjdCB0YWdfaGVhZGVyIGhkcjsKIAl1bmlvbiB7CmRpZmYgLS1n aXQgYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9rZXhlYy5oIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20v a2V4ZWMuaAppbmRleCAyMjc1MWI1YjU3MzUuLjhlNGQwZDkyMjY5YiAxMDA2NDQKLS0tIGEvYXJj aC9hcm0vaW5jbHVkZS9hc20va2V4ZWMuaAorKysgYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9rZXhl Yy5oCkBAIC0yLDcgKzIsNyBAQAogI2lmbmRlZiBfQVJNX0tFWEVDX0gKICNkZWZpbmUgX0FSTV9L RVhFQ19ICiAKLSNpZmRlZiBDT05GSUdfS0VYRUMKKyNpZiBkZWZpbmVkKENPTkZJR19LRVhFQykg fHwgZGVmaW5lZChDT05GSUdfS0VYRUNfRklMRSkKIAogLyogTWF4aW11bSBwaHlzaWNhbCBhZGRy ZXNzIHdlIGNhbiB1c2UgcGFnZXMgZnJvbSAqLwogI2RlZmluZSBLRVhFQ19TT1VSQ0VfTUVNT1JZ X0xJTUlUICgtMVVMKQpAQCAtODMsNiArODMsMjAgQEAgc3RhdGljIGlubGluZSBzdHJ1Y3QgcGFn ZSAqYm9vdF9wZm5fdG9fcGFnZSh1bnNpZ25lZCBsb25nIGJvb3RfcGZuKQogfQogI2RlZmluZSBi b290X3Bmbl90b19wYWdlIGJvb3RfcGZuX3RvX3BhZ2UKIAorI2lmZGVmIENPTkZJR19LRVhFQ19G SUxFCisKK2V4dGVybiBjb25zdCBzdHJ1Y3Qga2V4ZWNfZmlsZV9vcHMga2V4ZWNfemltYWdlX29w czsKK2V4dGVybiBjb25zdCBzdHJ1Y3Qga2V4ZWNfZmlsZV9vcHMga2V4ZWNfdWltYWdlX29wczsK Kworc3RydWN0IGtpbWFnZTsKKworZXh0ZXJuIGludCBsb2FkX290aGVyX3NlZ21lbnRzKHN0cnVj dCBraW1hZ2UgKmltYWdlLAorCQl1bnNpZ25lZCBsb25nIGtlcm5lbF9sb2FkX2FkZHIsIHVuc2ln bmVkIGxvbmcga2VybmVsX3NpemUsCisJCWNoYXIgKmluaXRyZCwgdW5zaWduZWQgbG9uZyBpbml0 cmRfbGVuLAorCQl1bnNpZ25lZCBsb25nIGluaXRyZF9vZmZzZXQsIGNoYXIgKmNtZGxpbmUpOwor CisjZW5kaWYgLyogQ09ORklHX0tFWEVDX0ZJTEUgKi8KKwogI2VuZGlmIC8qIF9fQVNTRU1CTFlf XyAqLwogCiAjZW5kaWYgLyogQ09ORklHX0tFWEVDICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9r ZXJuZWwvTWFrZWZpbGUgYi9hcmNoL2FybS9rZXJuZWwvTWFrZWZpbGUKaW5kZXggODllNWQ4NjRl OTIzLi40NTNlY2Y3MzA1ZTIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2tlcm5lbC9NYWtlZmlsZQor KysgYi9hcmNoL2FybS9rZXJuZWwvTWFrZWZpbGUKQEAgLTMsNiArMyw3IEBACiAjIE1ha2VmaWxl IGZvciB0aGUgbGludXgga2VybmVsLgogIwogCitDRkxBR1Nfa2V4ZWNfemltYWdlLm8gOj0gLURU RVhUX09GRlNFVD0kKFRFWFRfT0ZGU0VUKQogQ1BQRkxBR1Nfdm1saW51eC5sZHMgOj0gLURURVhU X09GRlNFVD0kKFRFWFRfT0ZGU0VUKQogQUZMQUdTX2hlYWQubyAgICAgICAgOj0gLURURVhUX09G RlNFVD0kKFRFWFRfT0ZGU0VUKQogCkBAIC01Niw3ICs1Nyw5IEBAIG9iai0kKENPTkZJR19GVU5D VElPTl9UUkFDRVIpCSs9IGVudHJ5LWZ0cmFjZS5vCiBvYmotJChDT05GSUdfRFlOQU1JQ19GVFJB Q0UpCSs9IGZ0cmFjZS5vIGluc24ubyBwYXRjaC5vCiBvYmotJChDT05GSUdfRlVOQ1RJT05fR1JB UEhfVFJBQ0VSKQkrPSBmdHJhY2UubyBpbnNuLm8gcGF0Y2gubwogb2JqLSQoQ09ORklHX0pVTVBf TEFCRUwpCSs9IGp1bXBfbGFiZWwubyBpbnNuLm8gcGF0Y2gubwotb2JqLSQoQ09ORklHX0tFWEVD KQkJKz0gbWFjaGluZV9rZXhlYy5vIHJlbG9jYXRlX2tlcm5lbC5vCitvYmotJChDT05GSUdfS0VY RUNfQ09SRSkJKz0gbWFjaGluZV9rZXhlYy5vIHJlbG9jYXRlX2tlcm5lbC5vCitvYmotJChDT05G SUdfS0VYRUNfRklMRSkJKz0gbWFjaGluZV9rZXhlY19maWxlLm8ga2V4ZWNfemltYWdlLm8KK29i ai0kKENPTkZJR19LRVhFQ19GSUxFX1VJTUFHRSkJKz0ga2V4ZWNfdWltYWdlLm8KICMgTWFpbiBz dGFmZnMgaW4gS1BST0JFUyBhcmUgaW4gYXJjaC9hcm0vcHJvYmVzLyAuCiBvYmotJChDT05GSUdf S1BST0JFUykJCSs9IHBhdGNoLm8gaW5zbi5vCiBvYmotJChDT05GSUdfT0FCSV9DT01QQVQpCSs9 IHN5c19vYWJpLWNvbXBhdC5vCmRpZmYgLS1naXQgYS9hcmNoL2FybS9rZXJuZWwva2V4ZWNfdWlt YWdlLmMgYi9hcmNoL2FybS9rZXJuZWwva2V4ZWNfdWltYWdlLmMKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwLi40NzAzMzU3NGUyNGUKLS0tIC9kZXYvbnVsbAorKysgYi9h cmNoL2FybS9rZXJuZWwva2V4ZWNfdWltYWdlLmMKQEAgLTAsMCArMSw4MCBAQAorLy8gU1BEWC1M aWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKy8qCisgKiBLZXhlYyB1SW1hZ2UgbG9hZGVyCisg KgorICogQ29weXJpZ2h0IChDKSAyMDIwIFNhbXN1bmcgRWxlY3Ryb25pY3MKKyAqIEF1dGhvcjog xYF1a2FzeiBTdGVsbWFjaCA8bC5zdGVsbWFjaEBzYW1zdW5nLmNvbT4KKyAqLworCisjZGVmaW5l IHByX2ZtdChmbXQpCSJrZXhlY19maWxlKHVJbWFnZSk6ICIgZm10CisKKyNpbmNsdWRlIDxhc20v aW1hZ2UuaD4KKyNpbmNsdWRlIDxsaW51eC9jcmMzMi5oPgorI2luY2x1ZGUgPGxpbnV4L2Vyci5o PgorI2luY2x1ZGUgPGxpbnV4L2tleGVjLmg+CisKKyNkZWZpbmUgY3JjMzJfb25lcyhjcmMsIGJ1 ZiwgbGVuKSBcCisJKGNyYzMyKGNyYyBeIDB4ZmZmZmZmZmYsIGJ1ZiwgbGVuKSBeIDB4ZmZmZmZm ZmYpCisKK3N0YXRpYyBpbnQgdWltYWdlX3Byb2JlKGNvbnN0IGNoYXIgKnVpbWFnZV9idWYsIHVu c2lnbmVkIGxvbmcgdWltYWdlX2xlbikKK3sKKwljb25zdCBzdHJ1Y3QgYXJtX3VpbWFnZV9oZWFk ZXIgKmggPQorCQkoc3RydWN0IGFybV91aW1hZ2VfaGVhZGVyICopIHVpbWFnZV9idWY7CisJc3Ry dWN0IGFybV91aW1hZ2VfaGVhZGVyIHVoZHI7CisJdW5zaWduZWQgbG9uZyB6b2ZmID0gc2l6ZW9m KHN0cnVjdCBhcm1fdWltYWdlX2hlYWRlcik7CisJdWludDMyX3QgY3JjOworCisJaWYgKGgtPm1h Z2ljICE9IEFSTV9VSU1BR0VfTUFHSUMpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKGgtPnR5 cGUgIT0gQVJNX1VJTUFHRV9UWVBFX0tFUk5FTCAmJgorCSAgICBoLT50eXBlICE9IEFSTV9VSU1B R0VfVFlQRV9LRVJORUxfTk9MT0FEKXsKKwkJcHJfZGVidWcoIkludmFsaWQgaW1hZ2UgdHlwZTog JWRcbiIsIGgtPnR5cGUpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlpZiAoaC0+YXJjaCAh PSBBUk1fVUlNQUdFX0FSQ0hfQVJNKSB7CisJCXByX2RlYnVnKCJJbnZhbGlkeSBpbWFnZSBhcmNo OiAlZFxuIiwgaC0+YXJjaCk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCW1lbWNweSgoY2hh ciAqKSZ1aGRyLCBoLCBzaXplb2YodWhkcikpOworCWNyYyA9IGJlMzJfdG9fY3B1KHVoZHIuaGRy X2NyYyk7CisJdWhkci5oZHJfY3JjID0gMDsKKworCWlmIChjcmMzMl9vbmVzKDAsIChjaGFyICop JnVoZHIsIHNpemVvZih1aGRyKSkgIT0gY3JjKSB7CisJCXByX2RlYnVnKCJDb3JydXB0IGhlYWRl ciwgQ1JDIGRvIG5vdCBtYXRjaFxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCWNyYyA9 IGJlMzJfdG9fY3B1KHVoZHIuY3JjKTsKKwlpZiAoY3JjMzJfb25lcygwLCB1aW1hZ2VfYnVmICsg em9mZiwgdWltYWdlX2xlbiAtIHpvZmYpICE9IGNyYykgeworCQlwcl9kZWJ1ZygiQ29ycnVwdCB6 SW1hZ2UsIENSQyBkbyBub3QgbWF0Y2hcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwly ZXR1cm4ga2V4ZWNfemltYWdlX29wcy5wcm9iZSh1aW1hZ2VfYnVmICsgem9mZiwKKwkJCQkgICAg ICB1aW1hZ2VfbGVuIC0gem9mZik7Cit9CisKK3N0YXRpYyB2b2lkICp1aW1hZ2VfbG9hZChzdHJ1 Y3Qga2ltYWdlICppbWFnZSwKKwkJCQljaGFyICp1aW1hZ2UsIHVuc2lnbmVkIGxvbmcgdWltYWdl X2xlbiwKKwkJCQljaGFyICppbml0cmQsIHVuc2lnbmVkIGxvbmcgaW5pdHJkX2xlbiwKKwkJCQlj aGFyICpjbWRsaW5lLCB1bnNpZ25lZCBsb25nIGNtZGxpbmVfbGVuKQoreworCWNvbnN0IHN0cnVj dCBhcm1fdWltYWdlX2hlYWRlciAqaCA9CisJCShzdHJ1Y3QgYXJtX3VpbWFnZV9oZWFkZXIgKikg dWltYWdlOworCXVuc2lnbmVkIGxvbmcgemltYWdlX29mZnNldCA9IHNpemVvZihzdHJ1Y3QgYXJt X3VpbWFnZV9oZWFkZXIpOworCisJcHJfZGVidWcoIkxvYWRpbmcgdUltYWdlIik7CisJcmV0dXJu IGtleGVjX3ppbWFnZV9vcHMubG9hZChpbWFnZSwKKwkJCQkgICAgIHVpbWFnZSArIHppbWFnZV9v ZmZzZXQsCisJCQkJICAgICB1aW1hZ2VfbGVuIC0gemltYWdlX29mZnNldCwKKwkJCQkgICAgIGlu aXRyZCwgaW5pdHJkX2xlbiwKKwkJCQkgICAgIGNtZGxpbmUsIGNtZGxpbmVfbGVuKTsKK30KKwor Y29uc3Qgc3RydWN0IGtleGVjX2ZpbGVfb3BzIGtleGVjX3VpbWFnZV9vcHMgPSB7CisJLnByb2Jl ID0gdWltYWdlX3Byb2JlLAorCS5sb2FkID0gdWltYWdlX2xvYWQsCit9OwpkaWZmIC0tZ2l0IGEv YXJjaC9hcm0va2VybmVsL2tleGVjX3ppbWFnZS5jIGIvYXJjaC9hcm0va2VybmVsL2tleGVjX3pp bWFnZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNTQzMjI5YTQy NzkzCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9hcm0va2VybmVsL2tleGVjX3ppbWFnZS5jCkBA IC0wLDAgKzEsMTk3IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorLyoK KyAqIEtleGVjIHpJbWFnZSBsb2FkZXIKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMjAgU2Ftc3Vu ZyBFbGVjdHJvbmljcworICogQXV0aG9yczoKKyAqICAgICDFgXVrYXN6IFN0ZWxtYWNoIDxsLnN0 ZWxtYWNoQHNhbXN1bmcuY29tPgorICoKKyAqIEJhc2VkIG9uIGVhcmxpZXIgd29ya3MgZm9yIGtl eGVjLXRvb2xzIGJ5CisgKiAgICAgUnVzc2VsbCBLaW5nIDxybWsra2VybmVsQGFybWxpbnV4Lm9y Zy51az4KKyAqCisgKi8KKworI2RlZmluZSBwcl9mbXQoZm10KQkia2V4ZWNfZmlsZSh6SW1hZ2Up OiAiIGZtdAorCisjaW5jbHVkZSA8YXNtL2ltYWdlLmg+CisjaW5jbHVkZSA8YXNtL3VuYWxpZ25l ZC5oPgorI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgorI2luY2x1ZGUgPGxpbnV4L2tleGVjLmg+Cisj aW5jbHVkZSA8bGludXgvbWVtYmxvY2suaD4KKworI2RlZmluZSBieXRlX3NpemUodCkgICAgKCh0 KS0+aGRyLnNpemUgPDwgMikKKworLyoKKyAqIFRoaXMgZnVuY3Rpb24gYW5kIHNldmVyYWwgcGll Y2VzIGJlbG93IGhhdmUgYmVlbiB0YWtlbiBmcm9tCisgKiBrZXhlYy10b29scy9rZXhlYy9hcmNo L2FybS9rZXhlYy16SW1hZ2UtYXJtLmMKKyAqLworc3RhdGljIGNvbnN0IHZvaWQgKmZpbmRfZXh0 ZW5zaW9uX3RhZyhjb25zdCBjaGFyICpidWYsCisJCQkJCQkgICAgICAgdW5zaWduZWQgbG9uZyBs ZW4sCisJCQkJCQkgICAgICAgdWludDMyX3QgdGFnX2lkKQoreworCWNvbnN0IHN0cnVjdCBhcm1f emltYWdlX2hlYWRlciAqaCA9IChjb25zdCBzdHJ1Y3QgYXJtX3ppbWFnZV9oZWFkZXIgKilidWY7 CisJY29uc3Qgc3RydWN0IGFybV96aW1hZ2VfdGFnICp0YWc7CisJdWludDMyX3Qgb2Zmc2V0LCBz aXplOworCXVpbnQzMl90IG1heCA9IGxlbiAtIHNpemVvZihzdHJ1Y3QgdGFnX2hlYWRlcik7CisK KwlpZiAobGVuIDwgc2l6ZW9mKCpoKSB8fAorCSAgICBoLT5tYWdpYyAhPSBBUk1fWklNQUdFX01B R0lDMSB8fAorCSAgICBoLT5tYWdpYzIgIT0gQVJNX1pJTUFHRV9NQUdJQzIpCisJCXJldHVybiBO VUxMOworCisJZm9yIChvZmZzZXQgPSBoLT5leHRlbnNpb25fdGFnX29mZnNldDsKKwkgICAgICh0 YWcgPSAodm9pZCAqKShidWYgKyBvZmZzZXQpKSAhPSBOVUxMICYmCisJCSAgICAgb2Zmc2V0IDwg bWF4ICYmCisJCSAgICAgKHNpemUgPSBsZTMyX3RvX2NwdShieXRlX3NpemUodGFnKSkpICE9IDAg JiYKKwkJICAgICBvZmZzZXQgKyBzaXplIDwgbGVuOworCSAgICAgb2Zmc2V0ICs9IHNpemUpIHsK KwkJcHJfZGVidWcoIiAgb2Zmc2V0IDB4JTA4eCB0YWcgMHglMDh4IHNpemUgJXVcbiIsCisJCQkg IG9mZnNldCwgbGUzMl90b19jcHUodGFnLT5oZHIudGFnKSwgc2l6ZSk7CisJCWlmICh0YWctPmhk ci50YWcgPT0gdGFnX2lkKQorCQkJcmV0dXJuIHRhZzsKKwl9CisKKwlyZXR1cm4gTlVMTDsKK30K Kworc3RhdGljIGludCB6aW1hZ2VfcHJvYmUoY29uc3QgY2hhciAqa2VybmVsX2J1ZiwgdW5zaWdu ZWQgbG9uZyBrZXJuZWxfbGVuKQoreworCWNvbnN0IHN0cnVjdCBhcm1femltYWdlX2hlYWRlciAq aCA9CisJCShzdHJ1Y3QgYXJtX3ppbWFnZV9oZWFkZXIgKikoa2VybmVsX2J1Zik7CisKKwlpZiAo IWggfHwgKGtlcm5lbF9sZW4gPCBzaXplb2YoKmgpKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlp ZiAoKGgtPm1hZ2ljICE9IEFSTV9aSU1BR0VfTUFHSUMxKSB8fAorCSAgICAoaC0+bWFnaWMyICE9 IEFSTV9aSU1BR0VfTUFHSUMyKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlyZXR1cm4gMDsKK30K KworCisjaWYgZGVmaW5lZChERUJVRykKKyNkZWZpbmUgZGVidWdfb2Zmc2V0cygpICh7CQkJXAor CXByX2RlYnVnKCJJbWFnZSBvZmZzZXRzOlxuIik7CQlcCisJcHJfZGVidWcoIiAga2VybmVsIDB4 JTA4bHggMHglMDhseFxuIiwga2VybmVsX29mZnNldCwga2VybmVsX2xlbik7IFwKKwlwcl9kZWJ1 ZygiICB6aW1hZ2UgMHglMDhseCAweCUwOGx4XG4iLCB6aW1hZ2Vfb2Zmc2V0LCB6aW1hZ2VfbGVu KTsgXAorCXByX2RlYnVnKCIgIGluaXRyZCAweCUwOGx4IDB4JTA4bHhcbiIsIGluaXRyZF9vZmZz ZXQsIGluaXRyZF9sZW4pOyBcCit9KQorI2Vsc2UKKyNkZWZpbmUgZGVidWdfb2Zmc2V0cygpCisj ZW5kaWYKKworc3RhdGljIHZvaWQgKnppbWFnZV9sb2FkKHN0cnVjdCBraW1hZ2UgKmltYWdlLAor CQkJCWNoYXIgKnppbWFnZSwgdW5zaWduZWQgbG9uZyB6aW1hZ2VfbGVuLAorCQkJCWNoYXIgKmlu aXRyZCwgdW5zaWduZWQgbG9uZyBpbml0cmRfbGVuLAorCQkJCWNoYXIgKmNtZGxpbmUsIHVuc2ln bmVkIGxvbmcgY21kbGluZV9sZW4pCit7CisJc3RydWN0IGFybV96aW1hZ2VfaGVhZGVyICpoOwor CXN0cnVjdCBrZXhlY19idWYga2J1ZjsKKwlzdHJ1Y3Qga2V4ZWNfc2VnbWVudCAqemltYWdlX3Nl Z21lbnQ7CisJY29uc3Qgc3RydWN0IGFybV96aW1hZ2VfdGFnICp0YWc7CisJaW50IHJldCA9IC1F SU5WQUw7CisKKwl1bnNpZ25lZCBsb25nIHppbWFnZV9tZW0gPSAweDIwMDAwOyAvKiBtYWxsb2Mg NjRrQiArIHN0YWNrIDQga0IgKyBzb21lIGJzcyAqLworCXVuc2lnbmVkIGxvbmcga2VybmVsX2xl biA9IHppbWFnZV9sZW4gKiA1OyAvKiA1OjEgY29tcHJlc3Npb24gKi8KKwl1bnNpZ25lZCBsb25n IGtlcm5lbF9vZmZzZXQgPSBtZW1ibG9ja19zdGFydF9vZl9EUkFNKCk7CisJdW5zaWduZWQgbG9u ZyB6aW1hZ2Vfb2Zmc2V0ID0ga2VybmVsX29mZnNldCArCisJCUFMSUdOKGtlcm5lbF9sZW4sIFBB R0VfU0laRSk7CisJdW5zaWduZWQgbG9uZyBpbml0cmRfb2Zmc2V0ID0gemltYWdlX29mZnNldCAr CisJCUFMSUdOKHppbWFnZV9sZW4gKyB6aW1hZ2VfbWVtLCBQQUdFX1NJWkUpOworCisJaWYgKGlt YWdlLT50eXBlID09IEtFWEVDX1RZUEVfQ1JBU0gpIHsKKwkJa2VybmVsX29mZnNldCArPSBjcmFz aGtfcmVzLnN0YXJ0OworCQl6aW1hZ2Vfb2Zmc2V0ICs9IGNyYXNoa19yZXMuc3RhcnQ7CisJCWlu aXRyZF9vZmZzZXQgKz0gY3Jhc2hrX3Jlcy5zdGFydDsKKwl9CisJZGVidWdfb2Zmc2V0cygpOwor CisJaCA9IChzdHJ1Y3QgYXJtX3ppbWFnZV9oZWFkZXIgKil6aW1hZ2U7CisKKwl0YWcgPSBmaW5k X2V4dGVuc2lvbl90YWcoemltYWdlLCB6aW1hZ2VfbGVuLCBaSU1BR0VfVEFHX0tSTkxfU0laRSk7 CisJaWYgKHRhZykgeworCQl1aW50MzJfdCAqcCA9ICh2b2lkICopemltYWdlICsKKwkJCWxlMzJf dG9fY3B1KHRhZy0+dS5rcm5sX3NpemUuc2l6ZV9wdHIpOworCQl1aW50MzJfdCBlZGF0YV9zaXpl ID0gbGUzMl90b19jcHUoZ2V0X3VuYWxpZ25lZChwKSk7CisJCXVpbnQzMl90IGJzc19zaXplID0g bGUzMl90b19jcHUodGFnLT51Lmtybmxfc2l6ZS5ic3Nfc2l6ZSk7CisJCXVpbnQzMl90IHRleHRf b2Zmc2V0ID0gbGUzMl90b19jcHUodGFnLT51Lmtybmxfc2l6ZS50ZXh0X29mZnNldCk7CisKKwkJ a2VybmVsX29mZnNldCArPSBBTElHTih0ZXh0X29mZnNldCwgUEFHRV9TSVpFKTsKKwkJa2VybmVs X2xlbiA9IGVkYXRhX3NpemUgKyBic3Nfc2l6ZTsKKworCQlwcl9kZWJ1ZygiRGVjb21wcmVzc2Vk IGtlcm5lbCBzaXplczpcbiIpOworCQlwcl9kZWJ1ZygiIHRleHQrZGF0YSAweCUwOGx4IGJzcyAw eCUwOGx4IHRvdGFsIDB4JTA4bHhcbiIsCisJCQkgKHVuc2lnbmVkIGxvbmcpZWRhdGFfc2l6ZSwK KwkJCSAodW5zaWduZWQgbG9uZylic3Nfc2l6ZSwKKwkJCSAodW5zaWduZWQgbG9uZylrZXJuZWxf bGVuKTsKKworCQl6aW1hZ2Vfb2Zmc2V0ID0ga2VybmVsX29mZnNldCArIEFMSUdOKGVkYXRhX3Np emUsIFBBR0VfU0laRSk7CisJCWluaXRyZF9vZmZzZXQgPSB6aW1hZ2Vfb2Zmc2V0ICsKKwkJCW1h eChBTElHTih6aW1hZ2VfbGVuICsgMHgyMDAwMCwgUEFHRV9TSVpFKSwKKwkJCSAgICBBTElHTigo dW5zaWduZWQgbG9uZylic3Nfc2l6ZSwgUEFHRV9TSVpFKSk7CisJCWRlYnVnX29mZnNldHMoKTsK Kwl9CisKKwl0YWcgPSBmaW5kX2V4dGVuc2lvbl90YWcoemltYWdlLCB6aW1hZ2VfbGVuLAorCQkJ CSBaSU1BR0VfVEFHX1pJTUFHRV9NRU0pOworCWlmICh0YWcpIHsKKwkJdWludDMyX3QgemltYWdl X21lbSA9IGxlMzJfdG9fY3B1KHRhZy0+dS56aW1hZ2VfbWVtKTsKKworCQlwcl9kZWJ1ZygiRGVj b21wcmVzc29yIHJlcXVpcmVzICVkIGJ5dGVzIG9mIG1lbW9yeVxuIiwgemltYWdlX21lbSk7CisK KwkJaW5pdHJkX29mZnNldCA9IG1heChBTElHTih6aW1hZ2Vfb2Zmc2V0ICsgemltYWdlX2xlbiAr IHppbWFnZV9tZW0sIFBBR0VfU0laRSksCisJCQkJICAgIEFMSUdOKGtlcm5lbF9vZmZzZXQgKyBr ZXJuZWxfbGVuLCBQQUdFX1NJWkUpKTsKKwkJZGVidWdfb2Zmc2V0cygpOworCX0KKworCS8qCisJ ICogekltYWdlIE1VU1QgYmUgbG9hZGVkIGludG8gdGhlIGZpcnN0IDEyOCBNaUIgb2YgcGh5c2lj YWwKKwkgKiBtZW1vcnkgZm9yIHByb3BlciBtZW1vcnkgZGV0ZWN0aW9uLiBTaG91bGQgdGhlIHVu Y29tcHJlc3NlZAorCSAqIGtlcm5lbCBiZSBsYXJnZXIgdGhhbiAxMjggTWlCLCB6SW1hZ2UgcmVs b2NhdGlvbiBiZWNvbWVzCisJICogdW5hdm9pZGFibGUgYW5kIGl0IGlzIGJlc3QgdG8gcmVseSBv biB0aGUgcmVsb2NhdGlvbiBjb2RlLgorCSAqLworCWlmICgoKHppbWFnZV9vZmZzZXQgLSBrZXJu ZWxfb2Zmc2V0KSArIFBBR0VfU0laRSArIDB4ODAwMCkgPj0gU1pfMTI4TSkgeworCQlwcl9kZWJ1 ZygiVGhlIGtlcm5lbCBpcyB0b28gYmlnICglbGQgTWlCKSB0byBhdm9pZCAiCisJCQkgInpJbWFn ZSByZWxvY2F0aW9uLiBMb2FkaW5nIHppbWFnZSBhdCAweCUwOGx4XG4iLAorCQkJICgoemltYWdl X29mZnNldCAtIGtlcm5lbF9vZmZzZXQpID4+IDIwKSwKKwkJCSBrZXJuZWxfb2Zmc2V0KTsKKwkJ emltYWdlX29mZnNldCA9IGtlcm5lbF9vZmZzZXQ7CisJfQorCisJa2J1Zi5pbWFnZSA9IGltYWdl OworCWtidWYudG9wX2Rvd24gPSBmYWxzZTsKKworCWtidWYuYnVmX21pbiA9IHppbWFnZV9vZmZz ZXQ7CisJa2J1Zi5idWZfbWF4ID0gVUxPTkdfTUFYOworCWtidWYuYnVmZmVyID0gemltYWdlOwor CWtidWYuYnVmc3ogPSB6aW1hZ2VfbGVuOworCWtidWYuYnVmX2FsaWduID0gUEFHRV9TSVpFOwor CisJa2J1Zi5tZW0gPSBLRVhFQ19CVUZfTUVNX1VOS05PV047CisJa2J1Zi5tZW1zeiA9IHppbWFn ZV9sZW47CisKKwlyZXQgPSBrZXhlY19hZGRfYnVmZmVyKCZrYnVmKTsKKwlpZiAocmV0KQorCQly ZXR1cm4gRVJSX1BUUihyZXQpOworCisJcHJfZGVidWcoIkxvYWRlZCB6SW1hZ2UgYXQgMHglbHgg YnVmc3o9MHglbHggbWVtc3o9MHglbHhcbiIsCisJCSBrYnVmLm1lbSwga2J1Zi5idWZzeiwga2J1 Zi5tZW1zeik7CisKKwlpbml0cmRfb2Zmc2V0ICs9IGtidWYubWVtIC0gemltYWdlX29mZnNldDsK KwlkZWJ1Z19vZmZzZXRzKCk7CisKKwl6aW1hZ2Vfc2VnbWVudCA9ICZpbWFnZS0+c2VnbWVudFtp bWFnZS0+bnJfc2VnbWVudHMgLSAxXTsKKwlpbWFnZS0+c3RhcnQgPSB6aW1hZ2Vfc2VnbWVudC0+ bWVtOworCisJcmV0ID0gbG9hZF9vdGhlcl9zZWdtZW50cyhpbWFnZSwKKwkJCQkgIHppbWFnZV9z ZWdtZW50LT5tZW0sIHppbWFnZV9zZWdtZW50LT5tZW1zeiwKKwkJCQkgIGluaXRyZCwgaW5pdHJk X2xlbiwgaW5pdHJkX29mZnNldCwKKwkJCQkgIGNtZGxpbmUpOworCXJldHVybiBFUlJfUFRSKHJl dCk7Cit9CisKK2NvbnN0IHN0cnVjdCBrZXhlY19maWxlX29wcyBrZXhlY196aW1hZ2Vfb3BzID0g eworCS5wcm9iZSA9IHppbWFnZV9wcm9iZSwKKwkubG9hZCA9IHppbWFnZV9sb2FkLAorfTsKZGlm ZiAtLWdpdCBhL2FyY2gvYXJtL2tlcm5lbC9tYWNoaW5lX2tleGVjLmMgYi9hcmNoL2FybS9rZXJu ZWwvbWFjaGluZV9rZXhlYy5jCmluZGV4IGEwYzIyOWVlYzBiMi4uYjM0OWQ2YjhkMThjIDEwMDY0 NAotLS0gYS9hcmNoL2FybS9rZXJuZWwvbWFjaGluZV9rZXhlYy5jCisrKyBiL2FyY2gvYXJtL2tl cm5lbC9tYWNoaW5lX2tleGVjLmMKQEAgLTkxLDEwICs5MSwxMyBAQCBpbnQgbWFjaGluZV9rZXhl Y19wcmVwYXJlKHN0cnVjdCBraW1hZ2UgKmltYWdlKQogCQkJCQkgICAgICAgY3VycmVudF9zZWdt ZW50LT5tZW1zeikpCiAJCQlyZXR1cm4gLUVJTlZBTDsKIAotCQllcnIgPSBnZXRfdXNlcihoZWFk ZXIsIChfX2JlMzIqKWN1cnJlbnRfc2VnbWVudC0+YnVmKTsKLQkJaWYgKGVycikKLQkJCXJldHVy biBlcnI7Ci0KKwkJaWYgKGltYWdlLT5maWxlX21vZGUpIHsKKwkJCWhlYWRlciA9ICooX19iZTMy ICopY3VycmVudF9zZWdtZW50LT5idWY7CisJCX0gZWxzZSB7CisJCQllcnIgPSBnZXRfdXNlciho ZWFkZXIsIChfX2JlMzIgKiljdXJyZW50X3NlZ21lbnQtPmJ1Zik7CisJCQlpZiAoZXJyKQorCQkJ CXJldHVybiBlcnI7CisJCX0KIAkJaWYgKGhlYWRlciA9PSBjcHVfdG9fYmUzMihPRl9EVF9IRUFE RVIpKQogCQkJaW1hZ2UtPmFyY2gua2VybmVsX3IyID0gY3VycmVudF9zZWdtZW50LT5tZW07CiAJ fQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va2VybmVsL21hY2hpbmVfa2V4ZWNfZmlsZS5jIGIvYXJj aC9hcm0va2VybmVsL21hY2hpbmVfa2V4ZWNfZmlsZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMC4uYTYzMmQzNTE2MDJjCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9h cm0va2VybmVsL21hY2hpbmVfa2V4ZWNfZmlsZS5jCkBAIC0wLDAgKzEsMjExIEBACisvLyBTUERY LUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorLyoKKyAqIGtleGVjX2ZpbGUgZm9yIGFybQor ICoKKyAqIENvcHlyaWdodCAoQykgMjAxOCBMaW5hcm8gTGltaXRlZAorICogQ29weXJpZ2h0IChD KSAyMDIwIFNhbXN1bmcgRWxlY3Ryb25pY3MKKyAqIEF1dGhvcnM6CisgKiAgICAgQUtBU0hJIFRh a2FoaXJvIDx0YWthaGlyby5ha2FzaGlAbGluYXJvLm9yZz4KKyAqICAgICDFgXVrYXN6IFN0ZWxt YWNoIDxsLnN0ZWxtYWNoQHNhbXN1bmcuY29tPgorICoKKyAqLworCisjZGVmaW5lIHByX2ZtdChm bXQpICJrZXhlY19maWxlOiAiIGZtdAorCisjaW5jbHVkZSA8bGludXgva2V4ZWMuaD4KKyNpbmNs dWRlIDxsaW51eC9saWJmZHQuaD4KKyNpbmNsdWRlIDxsaW51eC9vZl9mZHQuaD4KKyNpbmNsdWRl IDxsaW51eC9yYW5kb20uaD4KKworLyogcmVsZXZhbnQgZGV2aWNlIHRyZWUgcHJvcGVydGllcyAq LworI2RlZmluZSBGRFRfUFJPUF9JTklUUkRfU1RBUlQJImxpbnV4LGluaXRyZC1zdGFydCIKKyNk ZWZpbmUgRkRUX1BST1BfSU5JVFJEX0VORAkibGludXgsaW5pdHJkLWVuZCIKKyNkZWZpbmUgRkRU X1BST1BfQk9PVEFSR1MJImJvb3RhcmdzIgorI2RlZmluZSBGRFRfUFJPUF9STkdfU0VFRAkicm5n LXNlZWQiCisKK3N0YXRpYyBpbnQgc2V0dXBfZHRiKHN0cnVjdCBraW1hZ2UgKmltYWdlLAorCQkg ICAgIHVuc2lnbmVkIGxvbmcgaW5pdHJkX2xvYWRfYWRkciwgdW5zaWduZWQgbG9uZyBpbml0cmRf bGVuLAorCQkgICAgIGNoYXIgKmNtZGxpbmUsIHZvaWQgKmR0YikKK3sKKwlpbnQgb2ZmLCByZXQ7 CisKKwlyZXQgPSBmZHRfcGF0aF9vZmZzZXQoZHRiLCAiL2Nob3NlbiIpOworCWlmIChyZXQgPCAw KQorCQlnb3RvIG91dDsKKworCW9mZiA9IHJldDsKKworCS8qIGFkZCBib290YXJncyAqLworCWlm IChjbWRsaW5lKSB7CisJCXJldCA9IGZkdF9zZXRwcm9wX3N0cmluZyhkdGIsIG9mZiwgRkRUX1BS T1BfQk9PVEFSR1MsIGNtZGxpbmUpOworCQlpZiAocmV0KQorCQkJZ290byBvdXQ7CisJfSBlbHNl IHsKKwkJcmV0ID0gZmR0X2RlbHByb3AoZHRiLCBvZmYsIEZEVF9QUk9QX0JPT1RBUkdTKTsKKwkJ aWYgKHJldCAmJiAocmV0ICE9IC1GRFRfRVJSX05PVEZPVU5EKSkKKwkJCWdvdG8gb3V0OworCX0K KworCS8qIGFkZCBpbml0cmQtKiAqLworCWlmIChpbml0cmRfbG9hZF9hZGRyKSB7CisJCXJldCA9 IGZkdF9zZXRwcm9wX3U2NChkdGIsIG9mZiwgRkRUX1BST1BfSU5JVFJEX1NUQVJULAorCQkJCSAg ICAgIGluaXRyZF9sb2FkX2FkZHIpOworCQlpZiAocmV0KQorCQkJZ290byBvdXQ7CisKKwkJcmV0 ID0gZmR0X3NldHByb3BfdTY0KGR0Yiwgb2ZmLCBGRFRfUFJPUF9JTklUUkRfRU5ELAorCQkJCSAg ICAgIGluaXRyZF9sb2FkX2FkZHIgKyBpbml0cmRfbGVuKTsKKwkJaWYgKHJldCkKKwkJCWdvdG8g b3V0OworCX0gZWxzZSB7CisJCXJldCA9IGZkdF9kZWxwcm9wKGR0Yiwgb2ZmLCBGRFRfUFJPUF9J TklUUkRfU1RBUlQpOworCQlpZiAocmV0ICYmIChyZXQgIT0gLUZEVF9FUlJfTk9URk9VTkQpKQor CQkJZ290byBvdXQ7CisKKwkJcmV0ID0gZmR0X2RlbHByb3AoZHRiLCBvZmYsIEZEVF9QUk9QX0lO SVRSRF9FTkQpOworCQlpZiAocmV0ICYmIChyZXQgIT0gLUZEVF9FUlJfTk9URk9VTkQpKQorCQkJ Z290byBvdXQ7CisJfQorCisJLyogYWRkIHJuZy1zZWVkICovCisJaWYgKHJuZ19pc19pbml0aWFs aXplZCgpKSB7CisJCWNoYXIgc2VlZFsxMjhdOworCQlnZXRfcmFuZG9tX2J5dGVzKHNlZWQsIHNp emVvZihzZWVkKSk7CisKKwkJcmV0ID0gZmR0X3NldHByb3AoZHRiLCBvZmYsIEZEVF9QUk9QX1JO R19TRUVELAorCQkJCSAgc2VlZCwgc2l6ZW9mKHNlZWQpKTsKKwkJaWYgKHJldCkKKwkJCWdvdG8g b3V0OworCX0gZWxzZSB7CisJCXByX25vdGljZSgiUk5HIGlzIG5vdCBpbml0aWFsaXNlZDogb21p dHRpbmcgXCIlc1wiIHByb3BlcnR5XG4iLAorCQkJCUZEVF9QUk9QX1JOR19TRUVEKTsKKwkJcmV0 ID0gMDsKKwl9CisKK291dDoKKwlpZiAocmV0KQorCQlyZXR1cm4gKHJldCA9PSAtRkRUX0VSUl9O T1NQQUNFKSA/IC1FTk9NRU0gOiAtRUlOVkFMOworCisJcmV0dXJuIDA7Cit9CisvKgorICogTW9y ZSBzcGFjZSBuZWVkZWQgc28gdGhhdCB3ZSBjYW4gYWRkIGluaXRyZCwgYm9vdGFyZ3MgYW5kIGth c2xyLXNlZWQuCisgKi8KKyNkZWZpbmUgRFRCX0VYVFJBX1NQQUNFIDB4MTAwMAorCitzdGF0aWMg aW50IGNyZWF0ZV9kdGIoc3RydWN0IGtpbWFnZSAqaW1hZ2UsCisJCSAgICAgIHVuc2lnbmVkIGxv bmcgaW5pdHJkX2xvYWRfYWRkciwgdW5zaWduZWQgbG9uZyBpbml0cmRfbGVuLAorCQkgICAgICBj aGFyICpjbWRsaW5lLCB2b2lkICoqZHRiKQoreworCXZvaWQgKmJ1ZjsKKwlzaXplX3QgYnVmX3Np emU7CisJc2l6ZV90IGNtZGxpbmVfbGVuOworCWludCByZXQ7CisKKwljbWRsaW5lX2xlbiA9IGNt ZGxpbmUgPyBzdHJsZW4oY21kbGluZSkgOiAwOworCWJ1Zl9zaXplID0gZmR0X3RvdGFsc2l6ZShp bml0aWFsX2Jvb3RfcGFyYW1zKQorCQkJKyBjbWRsaW5lX2xlbiArIERUQl9FWFRSQV9TUEFDRTsK KworCWZvciAoOzspIHsKKwkJYnVmID0gdm1hbGxvYyhidWZfc2l6ZSk7CisJCWlmICghYnVmKQor CQkJcmV0dXJuIC1FTk9NRU07CisKKwkJLyogZHVwbGljYXRlIGEgZGV2aWNlIHRyZWUgYmxvYiAq LworCQlyZXQgPSBmZHRfb3Blbl9pbnRvKGluaXRpYWxfYm9vdF9wYXJhbXMsIGJ1ZiwgYnVmX3Np emUpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIC1FSU5WQUw7CisKKwkJcmV0ID0gc2V0dXBfZHRi KGltYWdlLCBpbml0cmRfbG9hZF9hZGRyLCBpbml0cmRfbGVuLAorCQkJCWNtZGxpbmUsIGJ1Zik7 CisJCWlmIChyZXQpIHsKKwkJCXZmcmVlKGJ1Zik7CisJCQlpZiAocmV0ID09IC1FTk9NRU0pIHsK KwkJCQkvKiB1bmxpa2VseSwgYnV0IGp1c3QgaW4gY2FzZSAqLworCQkJCWJ1Zl9zaXplICs9IERU Ql9FWFRSQV9TUEFDRTsKKwkJCQljb250aW51ZTsKKwkJCX0gZWxzZSB7CisJCQkJcmV0dXJuIHJl dDsKKwkJCX0KKwkJfQorCisJCS8qIHRyaW0gaXQgKi8KKwkJZmR0X3BhY2soYnVmKTsKKwkJKmR0 YiA9IGJ1ZjsKKworCQlyZXR1cm4gMDsKKwl9Cit9CisKK2ludCBsb2FkX290aGVyX3NlZ21lbnRz KHN0cnVjdCBraW1hZ2UgKmltYWdlLAorCQkJdW5zaWduZWQgbG9uZyB6aW1hZ2VfbG9hZF9hZGRy LAorCQkJdW5zaWduZWQgbG9uZyB6aW1hZ2VfbGVuLAorCQkJY2hhciAqaW5pdHJkLAorCQkJdW5z aWduZWQgbG9uZyBpbml0cmRfbGVuLAorCQkJdW5zaWduZWQgbG9uZyBpbml0cmRfb2Zmc2V0LAor CQkJY2hhciAqY21kbGluZSkKK3sKKwlzdHJ1Y3Qga2V4ZWNfYnVmIGtidWY7CisJdm9pZCAqZHRi ID0gTlVMTDsKKwl1bnNpZ25lZCBsb25nIGluaXRyZF9sb2FkX2FkZHIgPSAwOworCXVuc2lnbmVk IGxvbmcgZHRiX2xlbjsKKwlpbnQgcmV0ID0gMDsKKworCWtidWYuaW1hZ2UgPSBpbWFnZTsKKwkv KiBub3QgYWxsb2NhdGUgYW55dGhpbmcgYmVsb3cgdGhlIGtlcm5lbCAqLworCWtidWYuYnVmX21p biA9IGluaXRyZF9vZmZzZXQ7CisJaWYgKGluaXRyZCkgeworCQlrYnVmLmJ1ZmZlciA9IGluaXRy ZDsKKwkJa2J1Zi5idWZzeiA9IGluaXRyZF9sZW47CisJCWtidWYubWVtID0gS0VYRUNfQlVGX01F TV9VTktOT1dOOworCQlrYnVmLm1lbXN6ID0gaW5pdHJkX2xlbjsKKwkJa2J1Zi5idWZfYWxpZ24g PSBQQUdFX1NJWkU7CisJCWtidWYuYnVmX21heCA9IFVMT05HX01BWDsKKwkJa2J1Zi50b3BfZG93 biA9IGZhbHNlOworCisJCXJldCA9IGtleGVjX2FkZF9idWZmZXIoJmtidWYpOworCQlpZiAocmV0 KQorCQkJZ290byBvdXRfZXJyOworCisJCXByX2RlYnVnKCJMb2FkZWQgaW5pdHJkIGF0IDB4JWx4 IGJ1ZnN6PTB4JWx4IG1lbXN6PTB4JWx4XG4iLAorCQkJCWtidWYubWVtLCBrYnVmLmJ1ZnN6LCBr YnVmLm1lbXN6KTsKKworCQlpbml0cmRfbG9hZF9hZGRyID0ga2J1Zi5tZW07CisJCWtidWYuYnVm X21pbiA9IGluaXRyZF9sb2FkX2FkZHIgKyBrYnVmLm1lbXN6OworCX0KKworCS8qIGxvYWQgZHRi ICovCisJcmV0ID0gY3JlYXRlX2R0YihpbWFnZSwgaW5pdHJkX2xvYWRfYWRkciwgaW5pdHJkX2xl biwgY21kbGluZSwgJmR0Yik7CisJaWYgKHJldCkgeworCQlwcl9lcnIoIlByZXBhcmluZyBmb3Ig bmV3IGR0YiBmYWlsZWRcbiIpOworCQlnb3RvIG91dF9lcnI7CisJfQorCisJZHRiX2xlbiA9IGZk dF90b3RhbHNpemUoZHRiKTsKKwlrYnVmLmJ1ZmZlciA9IGR0YjsKKwlrYnVmLmJ1ZnN6ID0gZHRi X2xlbjsKKwlrYnVmLm1lbSA9IEtFWEVDX0JVRl9NRU1fVU5LTk9XTjsKKwlrYnVmLm1lbXN6ID0g ZHRiX2xlbjsKKwlrYnVmLmJ1Zl9hbGlnbiA9IFBBR0VfU0laRTsKKwlrYnVmLmJ1Zl9tYXggPSBV TE9OR19NQVg7CisJa2J1Zi50b3BfZG93biA9IGZhbHNlOworCisJcmV0ID0ga2V4ZWNfYWRkX2J1 ZmZlcigma2J1Zik7CisJaWYgKHJldCkKKwkJZ290byBvdXRfZXJyOworCisJcHJfZGVidWcoIkxv YWRlZCBkdGIgYXQgMHglbHggYnVmc3o9MHglbHggbWVtc3o9MHglbHhcbiIsCisJCSBrYnVmLm1l bSwga2J1Zi5idWZzeiwga2J1Zi5tZW1zeik7CisJcmV0dXJuIDA7CitvdXRfZXJyOgorCXZmcmVl KGR0Yik7CisJcmV0dXJuIHJldDsKK30KKworY29uc3Qgc3RydWN0IGtleGVjX2ZpbGVfb3BzICog Y29uc3Qga2V4ZWNfZmlsZV9sb2FkZXJzW10gPSB7CisjaWZkZWYgQ09ORklHX0tFWEVDX0ZJTEVf VUlNQUdFCisJJmtleGVjX3VpbWFnZV9vcHMsCisjZW5kaWYKKwkma2V4ZWNfemltYWdlX29wcywK KwlOVUxMCit9OwotLSAKMi4yNi4yCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18KbGludXgtYXJtLWtlcm5lbCBtYWlsaW5nIGxpc3QKbGludXgtYXJtLWtl cm5lbEBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxt YW4vbGlzdGluZm8vbGludXgtYXJtLWtlcm5lbAo= From mboxrd@z Thu Jan 1 00:00:00 1970 Return-path: Received: from mailout2.w1.samsung.com ([210.118.77.12]) by merlin.infradead.org with esmtps (Exim 4.92.3 #3 (Red Hat Linux)) id 1kNh0h-0003t6-9w for kexec@lists.infradead.org; Wed, 30 Sep 2020 18:39:35 +0000 Received: from eucas1p1.samsung.com (unknown [182.198.249.206]) by mailout2.w1.samsung.com (KnoxPortal) with ESMTP id 20200930183925euoutp02ac7087271604a09979e28906b0406b1f~5o7r6iBA40221702217euoutp02q for ; Wed, 30 Sep 2020 18:39:25 +0000 (GMT) From: =?UTF-8?q?=C5=81ukasz=20Stelmach?= Subject: [PATCH v3 4/4] arm: kexec_file: load zImage or uImage, initrd and dtb Date: Wed, 30 Sep 2020 20:34:13 +0200 Message-Id: <20200930183413.17023-5-l.stelmach@samsung.com> In-Reply-To: <20200930183413.17023-1-l.stelmach@samsung.com> MIME-Version: 1.0 References: <20200601142754.26139-1-l.stelmach@samsung.com> <20200930183413.17023-1-l.stelmach@samsung.com> List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "kexec" Errors-To: kexec-bounces+dwmw2=infradead.org@lists.infradead.org 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, AKASHI Takahiro , kexec@lists.infradead.org, Dave Young Cc: Marek Szyprowski , =?UTF-8?q?=C5=81ukasz=20Stelmach?= , Bartlomiej Zolnierkiewicz VGhpcyBpcyBrZXhlY19maWxlX2xvYWQgaW1wbGVtZW50YXRpb24gZm9yIEFSTS4gSXQgbG9hZHMg ekltYWdlIGFuZAppbml0cmQgZnJvbSBmaWxlIGRlc2NyaXB0ZXJzIGFuZCByZXN1c2VzIERUQi4K Ck1vc3QgY29kZSBpcyBkZXJpdmVkIGZyb20gYXJtNjQga2V4ZWNfZmlsZV9sb2FkIGltcGxlbWVu dGF0aW9uCmFuZCBmcm9tIGtleGVjLXRvb2xzLgoKQ2M6IEFLQVNISSBUYWthaGlybyA8dGFrYWhp cm8uYWthc2hpQGxpbmFyby5vcmc+ClNpZ25lZC1vZmYtYnk6IMWBdWthc3ogU3RlbG1hY2ggPGwu c3RlbG1hY2hAc2Ftc3VuZy5jb20+Ci0tLQogYXJjaC9hcm0vS2NvbmZpZyAgICAgICAgICAgICAg ICAgICAgIHwgIDI2ICsrKysKIGFyY2gvYXJtL2luY2x1ZGUvYXNtL2ltYWdlLmggICAgICAgICB8 ICAyNiArKysrCiBhcmNoL2FybS9pbmNsdWRlL2FzbS9rZXhlYy5oICAgICAgICAgfCAgMTYgKy0K IGFyY2gvYXJtL2tlcm5lbC9NYWtlZmlsZSAgICAgICAgICAgICB8ICAgNSArLQogYXJjaC9hcm0v a2VybmVsL2tleGVjX3VpbWFnZS5jICAgICAgIHwgIDgwICsrKysrKysrKysKIGFyY2gvYXJtL2tl cm5lbC9rZXhlY196aW1hZ2UuYyAgICAgICB8IDE5NyArKysrKysrKysrKysrKysrKysrKysrKysr CiBhcmNoL2FybS9rZXJuZWwvbWFjaGluZV9rZXhlYy5jICAgICAgfCAgMTEgKy0KIGFyY2gvYXJt L2tlcm5lbC9tYWNoaW5lX2tleGVjX2ZpbGUuYyB8IDIxMSArKysrKysrKysrKysrKysrKysrKysr KysrKysKIDggZmlsZXMgY2hhbmdlZCwgNTY2IGluc2VydGlvbnMoKyksIDYgZGVsZXRpb25zKC0p CiBjcmVhdGUgbW9kZSAxMDA2NDQgYXJjaC9hcm0va2VybmVsL2tleGVjX3VpbWFnZS5jCiBjcmVh dGUgbW9kZSAxMDA2NDQgYXJjaC9hcm0va2VybmVsL2tleGVjX3ppbWFnZS5jCiBjcmVhdGUgbW9k ZSAxMDA2NDQgYXJjaC9hcm0va2VybmVsL21hY2hpbmVfa2V4ZWNfZmlsZS5jCgpkaWZmIC0tZ2l0 IGEvYXJjaC9hcm0vS2NvbmZpZyBiL2FyY2gvYXJtL0tjb25maWcKaW5kZXggZmUyZjE3ZWIyYjUw Li42NWU1NTQwZjNlZDEgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL0tjb25maWcKKysrIGIvYXJjaC9h cm0vS2NvbmZpZwpAQCAtMTg3Myw2ICsxODczLDMyIEBAIGNvbmZpZyBLRVhFQwogCSAgaXMgcHJv cGVybHkgc2h1dGRvd24sIHNvIGRvIG5vdCBiZSBzdXJwcmlzZWQgaWYgdGhpcyBjb2RlIGRvZXMg bm90CiAJICBpbml0aWFsbHkgd29yayBmb3IgeW91LgogCitjb25maWcgS0VYRUNfRklMRQorCWJv b2wgIktleGVjIGZpbGUgYmFzZWQgc3lzdGVtIGNhbGwgKEVYUEVSSU1FTlRBTCkiCisJZGVwZW5k cyBvbiAoIVNNUCB8fCBQTV9TTEVFUF9TTVApCisJZGVwZW5kcyBvbiBNTVUKKwlkZXBlbmRzIG9u IFVTRV9PRgorCXNlbGVjdCBLRVhFQ19DT1JFCisJc2VsZWN0IENSQzMyCisJaGVscAorCSAgVGhp cyBpcyBhIG5ldyB2ZXJzaW9uIG9mIGtleGVjIHN5c3RlbSBjYWxsLiBUaGlzIHN5c3RlbSBjYWxs IGlzCisJICBmaWxlIGJhc2VkIGFuZCB0YWtlcyBmaWxlIGRlc2NyaXB0b3JzIGFzIHN5c3RlbSBj YWxsIGFyZ3VtZW50CisJICBmb3Iga2VybmVsIGFuZCBpbml0cmFtZnMgYXMgb3Bwb3NlZCB0byBs aXN0IG9mIHNlZ21lbnRzIGFzCisJICBhY2NlcHRlZCBieSBwcmV2aW91cyBzeXN0ZW0gY2FsbC4K KworCSAgVGhlIGtlcm5lbCB0byBiZSBsb2FkZWQgTVVTVCBzdXBwb3J0IEZsYXR0ZW5lZCBEZXZp Y2UgVHJlZQorCSAgKHNlbGVjdGVkIHdpdGggQ09ORklHX1VTRV9PRikuCisKK2NvbmZpZyBLRVhF Q19GSUxFX1VJTUFHRQorCWJvb2wgIkxvYWQgbGVnYWN5IHVJbWFnZSBmaWxlcyB3aXRoIGtleGVj X2ZpbGVfbG9hZCgpIChFWFBFUklNRU5UQUwpIgorCWRlcGVuZHMgb24gS0VYRUNfRklMRQorCWRl ZmF1bHQgbgorCWhlbHAKKwkgIFRoaXMgb3B0aW9ucyBlbmFibGVzIHN1cHBvcnQgZm9yIHRoZSBs ZWdhY3kgdUltYWdlIGZpbGVzIGFzCisJICBjcmVhdGVkIGJ5IG1raW1hZ2UuIFRoZXNlIGFyZSBu b3QgdGhlIG5ldyBGSVQgZmlsZXMuCisKKwkgIElmIHVuc3VyZSBzYXkgTi4KKwogY29uZmlnIEFU QUdTX1BST0MKIAlib29sICJFeHBvcnQgYXRhZ3MgaW4gcHJvY2ZzIgogCWRlcGVuZHMgb24gQVRB R1MgJiYgS0VYRUMKZGlmZiAtLWdpdCBhL2FyY2gvYXJtL2luY2x1ZGUvYXNtL2ltYWdlLmggYi9h cmNoL2FybS9pbmNsdWRlL2FzbS9pbWFnZS5oCmluZGV4IDhiZTZkYmM2OWZiYi4uMTVjNGZlMDMx ZDkwIDEwMDY0NAotLS0gYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9pbWFnZS5oCisrKyBiL2FyY2gv YXJtL2luY2x1ZGUvYXNtL2ltYWdlLmgKQEAgLTgsOCArOCwxMyBAQAogCQkJICgoKHgpID4+ICA4 KSAmIDB4MDAwMGZmMDApIHwgIFwKIAkJCSAoKCh4KSA8PCAgOCkgJiAweDAwZmYwMDAwKSB8ICBc CiAJCQkgKCgoeCkgPDwgMjQpICYgMHhmZjAwMDAwMCkpCisjZGVmaW5lIFVJTUFHRV9NQUdJQyh4 KSAoeCkKICNlbHNlCiAjZGVmaW5lIFpJTUFHRV9NQUdJQyh4KSAoeCkKKyNkZWZpbmUgVUlNQUdF X01BR0lDKHgpICgoKCh4KSA+PiAyNCkgJiAweDAwMDAwMGZmKSB8IFwKKwkJCSAoKCh4KSA+PiAg OCkgJiAweDAwMDBmZjAwKSB8ICBcCisJCQkgKCgoeCkgPDwgIDgpICYgMHgwMGZmMDAwMCkgfCAg XAorCQkJICgoKHgpIDw8IDI0KSAmIDB4ZmYwMDAwMDApKQogI2VuZGlmCiAKICNkZWZpbmUgQVJN X1pJTUFHRV9NQUdJQzEgWklNQUdFX01BR0lDKDB4MDE2ZjI4MTgpCkBAIC0xNyw2ICsyMiwxMiBA QAogI2RlZmluZSBBUk1fWklNQUdFX01BR0lDMyBaSU1BR0VfTUFHSUMoMHg1YTUzNGM0YikKICNk ZWZpbmUgQVJNX1pJTUFHRV9NQUdJQzQgWklNQUdFX01BR0lDKDB4NWE1MzQzNDQpCiAKKyNkZWZp bmUgQVJNX1VJTUFHRV9NQUdJQyBVSU1BR0VfTUFHSUMoMHgyNzA1MTk1NikKKyNkZWZpbmUgQVJN X1VJTUFHRV9OQU1FX0xFTgkJMzIKKyNkZWZpbmUgQVJNX1VJTUFHRV9UWVBFX0tFUk5FTAkJMgor I2RlZmluZSBBUk1fVUlNQUdFX1RZUEVfS0VSTkVMX05PTE9BRAkxNAorI2RlZmluZSBBUk1fVUlN QUdFX0FSQ0hfQVJNCQkyCisKICNpZm5kZWYgX19BU1NFTUJMWV9fCiAKICNpbmNsdWRlIDxsaW51 eC90eXBlcy5oPgpAQCAtMzMsNiArNDQsMjEgQEAgc3RydWN0IGFybV96aW1hZ2VfaGVhZGVyIHsK IAlfX2xlMzIgZXh0ZW5zaW9uX3RhZ19vZmZzZXQ7CiB9OwogCitzdHJ1Y3QgYXJtX3VpbWFnZV9o ZWFkZXIgeworCV9fYmUzMiBtYWdpYzsKKwlfX2JlMzIgaGRyX2NyYzsKKwlfX2JlMzIgdGltZTsK KwlfX2JlMzIgc2l6ZTsKKwlfX2JlMzIgbG9hZDsKKwlfX2JlMzIgZW50cnk7CisJX19iZTMyIGNy YzsKKwlfX3U4ICAgb3M7CisJX191OCAgIGFyY2g7CisJX191OCAgIHR5cGU7CisJX191OCAgIGNv bXA7CisJX191OCAgIG5hbWVbQVJNX1VJTUFHRV9OQU1FX0xFTl07Cit9OworCiBzdHJ1Y3QgYXJt X3ppbWFnZV90YWcgewogCXN0cnVjdCB0YWdfaGVhZGVyIGhkcjsKIAl1bmlvbiB7CmRpZmYgLS1n aXQgYS9hcmNoL2FybS9pbmNsdWRlL2FzbS9rZXhlYy5oIGIvYXJjaC9hcm0vaW5jbHVkZS9hc20v a2V4ZWMuaAppbmRleCAyMjc1MWI1YjU3MzUuLjhlNGQwZDkyMjY5YiAxMDA2NDQKLS0tIGEvYXJj aC9hcm0vaW5jbHVkZS9hc20va2V4ZWMuaAorKysgYi9hcmNoL2FybS9pbmNsdWRlL2FzbS9rZXhl Yy5oCkBAIC0yLDcgKzIsNyBAQAogI2lmbmRlZiBfQVJNX0tFWEVDX0gKICNkZWZpbmUgX0FSTV9L RVhFQ19ICiAKLSNpZmRlZiBDT05GSUdfS0VYRUMKKyNpZiBkZWZpbmVkKENPTkZJR19LRVhFQykg fHwgZGVmaW5lZChDT05GSUdfS0VYRUNfRklMRSkKIAogLyogTWF4aW11bSBwaHlzaWNhbCBhZGRy ZXNzIHdlIGNhbiB1c2UgcGFnZXMgZnJvbSAqLwogI2RlZmluZSBLRVhFQ19TT1VSQ0VfTUVNT1JZ X0xJTUlUICgtMVVMKQpAQCAtODMsNiArODMsMjAgQEAgc3RhdGljIGlubGluZSBzdHJ1Y3QgcGFn ZSAqYm9vdF9wZm5fdG9fcGFnZSh1bnNpZ25lZCBsb25nIGJvb3RfcGZuKQogfQogI2RlZmluZSBi b290X3Bmbl90b19wYWdlIGJvb3RfcGZuX3RvX3BhZ2UKIAorI2lmZGVmIENPTkZJR19LRVhFQ19G SUxFCisKK2V4dGVybiBjb25zdCBzdHJ1Y3Qga2V4ZWNfZmlsZV9vcHMga2V4ZWNfemltYWdlX29w czsKK2V4dGVybiBjb25zdCBzdHJ1Y3Qga2V4ZWNfZmlsZV9vcHMga2V4ZWNfdWltYWdlX29wczsK Kworc3RydWN0IGtpbWFnZTsKKworZXh0ZXJuIGludCBsb2FkX290aGVyX3NlZ21lbnRzKHN0cnVj dCBraW1hZ2UgKmltYWdlLAorCQl1bnNpZ25lZCBsb25nIGtlcm5lbF9sb2FkX2FkZHIsIHVuc2ln bmVkIGxvbmcga2VybmVsX3NpemUsCisJCWNoYXIgKmluaXRyZCwgdW5zaWduZWQgbG9uZyBpbml0 cmRfbGVuLAorCQl1bnNpZ25lZCBsb25nIGluaXRyZF9vZmZzZXQsIGNoYXIgKmNtZGxpbmUpOwor CisjZW5kaWYgLyogQ09ORklHX0tFWEVDX0ZJTEUgKi8KKwogI2VuZGlmIC8qIF9fQVNTRU1CTFlf XyAqLwogCiAjZW5kaWYgLyogQ09ORklHX0tFWEVDICovCmRpZmYgLS1naXQgYS9hcmNoL2FybS9r ZXJuZWwvTWFrZWZpbGUgYi9hcmNoL2FybS9rZXJuZWwvTWFrZWZpbGUKaW5kZXggODllNWQ4NjRl OTIzLi40NTNlY2Y3MzA1ZTIgMTAwNjQ0Ci0tLSBhL2FyY2gvYXJtL2tlcm5lbC9NYWtlZmlsZQor KysgYi9hcmNoL2FybS9rZXJuZWwvTWFrZWZpbGUKQEAgLTMsNiArMyw3IEBACiAjIE1ha2VmaWxl IGZvciB0aGUgbGludXgga2VybmVsLgogIwogCitDRkxBR1Nfa2V4ZWNfemltYWdlLm8gOj0gLURU RVhUX09GRlNFVD0kKFRFWFRfT0ZGU0VUKQogQ1BQRkxBR1Nfdm1saW51eC5sZHMgOj0gLURURVhU X09GRlNFVD0kKFRFWFRfT0ZGU0VUKQogQUZMQUdTX2hlYWQubyAgICAgICAgOj0gLURURVhUX09G RlNFVD0kKFRFWFRfT0ZGU0VUKQogCkBAIC01Niw3ICs1Nyw5IEBAIG9iai0kKENPTkZJR19GVU5D VElPTl9UUkFDRVIpCSs9IGVudHJ5LWZ0cmFjZS5vCiBvYmotJChDT05GSUdfRFlOQU1JQ19GVFJB Q0UpCSs9IGZ0cmFjZS5vIGluc24ubyBwYXRjaC5vCiBvYmotJChDT05GSUdfRlVOQ1RJT05fR1JB UEhfVFJBQ0VSKQkrPSBmdHJhY2UubyBpbnNuLm8gcGF0Y2gubwogb2JqLSQoQ09ORklHX0pVTVBf TEFCRUwpCSs9IGp1bXBfbGFiZWwubyBpbnNuLm8gcGF0Y2gubwotb2JqLSQoQ09ORklHX0tFWEVD KQkJKz0gbWFjaGluZV9rZXhlYy5vIHJlbG9jYXRlX2tlcm5lbC5vCitvYmotJChDT05GSUdfS0VY RUNfQ09SRSkJKz0gbWFjaGluZV9rZXhlYy5vIHJlbG9jYXRlX2tlcm5lbC5vCitvYmotJChDT05G SUdfS0VYRUNfRklMRSkJKz0gbWFjaGluZV9rZXhlY19maWxlLm8ga2V4ZWNfemltYWdlLm8KK29i ai0kKENPTkZJR19LRVhFQ19GSUxFX1VJTUFHRSkJKz0ga2V4ZWNfdWltYWdlLm8KICMgTWFpbiBz dGFmZnMgaW4gS1BST0JFUyBhcmUgaW4gYXJjaC9hcm0vcHJvYmVzLyAuCiBvYmotJChDT05GSUdf S1BST0JFUykJCSs9IHBhdGNoLm8gaW5zbi5vCiBvYmotJChDT05GSUdfT0FCSV9DT01QQVQpCSs9 IHN5c19vYWJpLWNvbXBhdC5vCmRpZmYgLS1naXQgYS9hcmNoL2FybS9rZXJuZWwva2V4ZWNfdWlt YWdlLmMgYi9hcmNoL2FybS9rZXJuZWwva2V4ZWNfdWltYWdlLmMKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAwLi40NzAzMzU3NGUyNGUKLS0tIC9kZXYvbnVsbAorKysgYi9h cmNoL2FybS9rZXJuZWwva2V4ZWNfdWltYWdlLmMKQEAgLTAsMCArMSw4MCBAQAorLy8gU1BEWC1M aWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKy8qCisgKiBLZXhlYyB1SW1hZ2UgbG9hZGVyCisg KgorICogQ29weXJpZ2h0IChDKSAyMDIwIFNhbXN1bmcgRWxlY3Ryb25pY3MKKyAqIEF1dGhvcjog xYF1a2FzeiBTdGVsbWFjaCA8bC5zdGVsbWFjaEBzYW1zdW5nLmNvbT4KKyAqLworCisjZGVmaW5l IHByX2ZtdChmbXQpCSJrZXhlY19maWxlKHVJbWFnZSk6ICIgZm10CisKKyNpbmNsdWRlIDxhc20v aW1hZ2UuaD4KKyNpbmNsdWRlIDxsaW51eC9jcmMzMi5oPgorI2luY2x1ZGUgPGxpbnV4L2Vyci5o PgorI2luY2x1ZGUgPGxpbnV4L2tleGVjLmg+CisKKyNkZWZpbmUgY3JjMzJfb25lcyhjcmMsIGJ1 ZiwgbGVuKSBcCisJKGNyYzMyKGNyYyBeIDB4ZmZmZmZmZmYsIGJ1ZiwgbGVuKSBeIDB4ZmZmZmZm ZmYpCisKK3N0YXRpYyBpbnQgdWltYWdlX3Byb2JlKGNvbnN0IGNoYXIgKnVpbWFnZV9idWYsIHVu c2lnbmVkIGxvbmcgdWltYWdlX2xlbikKK3sKKwljb25zdCBzdHJ1Y3QgYXJtX3VpbWFnZV9oZWFk ZXIgKmggPQorCQkoc3RydWN0IGFybV91aW1hZ2VfaGVhZGVyICopIHVpbWFnZV9idWY7CisJc3Ry dWN0IGFybV91aW1hZ2VfaGVhZGVyIHVoZHI7CisJdW5zaWduZWQgbG9uZyB6b2ZmID0gc2l6ZW9m KHN0cnVjdCBhcm1fdWltYWdlX2hlYWRlcik7CisJdWludDMyX3QgY3JjOworCisJaWYgKGgtPm1h Z2ljICE9IEFSTV9VSU1BR0VfTUFHSUMpCisJCXJldHVybiAtRUlOVkFMOworCisJaWYgKGgtPnR5 cGUgIT0gQVJNX1VJTUFHRV9UWVBFX0tFUk5FTCAmJgorCSAgICBoLT50eXBlICE9IEFSTV9VSU1B R0VfVFlQRV9LRVJORUxfTk9MT0FEKXsKKwkJcHJfZGVidWcoIkludmFsaWQgaW1hZ2UgdHlwZTog JWRcbiIsIGgtPnR5cGUpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwlpZiAoaC0+YXJjaCAh PSBBUk1fVUlNQUdFX0FSQ0hfQVJNKSB7CisJCXByX2RlYnVnKCJJbnZhbGlkeSBpbWFnZSBhcmNo OiAlZFxuIiwgaC0+YXJjaCk7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCW1lbWNweSgoY2hh ciAqKSZ1aGRyLCBoLCBzaXplb2YodWhkcikpOworCWNyYyA9IGJlMzJfdG9fY3B1KHVoZHIuaGRy X2NyYyk7CisJdWhkci5oZHJfY3JjID0gMDsKKworCWlmIChjcmMzMl9vbmVzKDAsIChjaGFyICop JnVoZHIsIHNpemVvZih1aGRyKSkgIT0gY3JjKSB7CisJCXByX2RlYnVnKCJDb3JydXB0IGhlYWRl ciwgQ1JDIGRvIG5vdCBtYXRjaFxuIik7CisJCXJldHVybiAtRUlOVkFMOworCX0KKworCWNyYyA9 IGJlMzJfdG9fY3B1KHVoZHIuY3JjKTsKKwlpZiAoY3JjMzJfb25lcygwLCB1aW1hZ2VfYnVmICsg em9mZiwgdWltYWdlX2xlbiAtIHpvZmYpICE9IGNyYykgeworCQlwcl9kZWJ1ZygiQ29ycnVwdCB6 SW1hZ2UsIENSQyBkbyBub3QgbWF0Y2hcbiIpOworCQlyZXR1cm4gLUVJTlZBTDsKKwl9CisKKwly ZXR1cm4ga2V4ZWNfemltYWdlX29wcy5wcm9iZSh1aW1hZ2VfYnVmICsgem9mZiwKKwkJCQkgICAg ICB1aW1hZ2VfbGVuIC0gem9mZik7Cit9CisKK3N0YXRpYyB2b2lkICp1aW1hZ2VfbG9hZChzdHJ1 Y3Qga2ltYWdlICppbWFnZSwKKwkJCQljaGFyICp1aW1hZ2UsIHVuc2lnbmVkIGxvbmcgdWltYWdl X2xlbiwKKwkJCQljaGFyICppbml0cmQsIHVuc2lnbmVkIGxvbmcgaW5pdHJkX2xlbiwKKwkJCQlj aGFyICpjbWRsaW5lLCB1bnNpZ25lZCBsb25nIGNtZGxpbmVfbGVuKQoreworCWNvbnN0IHN0cnVj dCBhcm1fdWltYWdlX2hlYWRlciAqaCA9CisJCShzdHJ1Y3QgYXJtX3VpbWFnZV9oZWFkZXIgKikg dWltYWdlOworCXVuc2lnbmVkIGxvbmcgemltYWdlX29mZnNldCA9IHNpemVvZihzdHJ1Y3QgYXJt X3VpbWFnZV9oZWFkZXIpOworCisJcHJfZGVidWcoIkxvYWRpbmcgdUltYWdlIik7CisJcmV0dXJu IGtleGVjX3ppbWFnZV9vcHMubG9hZChpbWFnZSwKKwkJCQkgICAgIHVpbWFnZSArIHppbWFnZV9v ZmZzZXQsCisJCQkJICAgICB1aW1hZ2VfbGVuIC0gemltYWdlX29mZnNldCwKKwkJCQkgICAgIGlu aXRyZCwgaW5pdHJkX2xlbiwKKwkJCQkgICAgIGNtZGxpbmUsIGNtZGxpbmVfbGVuKTsKK30KKwor Y29uc3Qgc3RydWN0IGtleGVjX2ZpbGVfb3BzIGtleGVjX3VpbWFnZV9vcHMgPSB7CisJLnByb2Jl ID0gdWltYWdlX3Byb2JlLAorCS5sb2FkID0gdWltYWdlX2xvYWQsCit9OwpkaWZmIC0tZ2l0IGEv YXJjaC9hcm0va2VybmVsL2tleGVjX3ppbWFnZS5jIGIvYXJjaC9hcm0va2VybmVsL2tleGVjX3pp bWFnZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uNTQzMjI5YTQy NzkzCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9hcm0va2VybmVsL2tleGVjX3ppbWFnZS5jCkBA IC0wLDAgKzEsMTk3IEBACisvLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorLyoK KyAqIEtleGVjIHpJbWFnZSBsb2FkZXIKKyAqCisgKiBDb3B5cmlnaHQgKEMpIDIwMjAgU2Ftc3Vu ZyBFbGVjdHJvbmljcworICogQXV0aG9yczoKKyAqICAgICDFgXVrYXN6IFN0ZWxtYWNoIDxsLnN0 ZWxtYWNoQHNhbXN1bmcuY29tPgorICoKKyAqIEJhc2VkIG9uIGVhcmxpZXIgd29ya3MgZm9yIGtl eGVjLXRvb2xzIGJ5CisgKiAgICAgUnVzc2VsbCBLaW5nIDxybWsra2VybmVsQGFybWxpbnV4Lm9y Zy51az4KKyAqCisgKi8KKworI2RlZmluZSBwcl9mbXQoZm10KQkia2V4ZWNfZmlsZSh6SW1hZ2Up OiAiIGZtdAorCisjaW5jbHVkZSA8YXNtL2ltYWdlLmg+CisjaW5jbHVkZSA8YXNtL3VuYWxpZ25l ZC5oPgorI2luY2x1ZGUgPGxpbnV4L2Vyci5oPgorI2luY2x1ZGUgPGxpbnV4L2tleGVjLmg+Cisj aW5jbHVkZSA8bGludXgvbWVtYmxvY2suaD4KKworI2RlZmluZSBieXRlX3NpemUodCkgICAgKCh0 KS0+aGRyLnNpemUgPDwgMikKKworLyoKKyAqIFRoaXMgZnVuY3Rpb24gYW5kIHNldmVyYWwgcGll Y2VzIGJlbG93IGhhdmUgYmVlbiB0YWtlbiBmcm9tCisgKiBrZXhlYy10b29scy9rZXhlYy9hcmNo L2FybS9rZXhlYy16SW1hZ2UtYXJtLmMKKyAqLworc3RhdGljIGNvbnN0IHZvaWQgKmZpbmRfZXh0 ZW5zaW9uX3RhZyhjb25zdCBjaGFyICpidWYsCisJCQkJCQkgICAgICAgdW5zaWduZWQgbG9uZyBs ZW4sCisJCQkJCQkgICAgICAgdWludDMyX3QgdGFnX2lkKQoreworCWNvbnN0IHN0cnVjdCBhcm1f emltYWdlX2hlYWRlciAqaCA9IChjb25zdCBzdHJ1Y3QgYXJtX3ppbWFnZV9oZWFkZXIgKilidWY7 CisJY29uc3Qgc3RydWN0IGFybV96aW1hZ2VfdGFnICp0YWc7CisJdWludDMyX3Qgb2Zmc2V0LCBz aXplOworCXVpbnQzMl90IG1heCA9IGxlbiAtIHNpemVvZihzdHJ1Y3QgdGFnX2hlYWRlcik7CisK KwlpZiAobGVuIDwgc2l6ZW9mKCpoKSB8fAorCSAgICBoLT5tYWdpYyAhPSBBUk1fWklNQUdFX01B R0lDMSB8fAorCSAgICBoLT5tYWdpYzIgIT0gQVJNX1pJTUFHRV9NQUdJQzIpCisJCXJldHVybiBO VUxMOworCisJZm9yIChvZmZzZXQgPSBoLT5leHRlbnNpb25fdGFnX29mZnNldDsKKwkgICAgICh0 YWcgPSAodm9pZCAqKShidWYgKyBvZmZzZXQpKSAhPSBOVUxMICYmCisJCSAgICAgb2Zmc2V0IDwg bWF4ICYmCisJCSAgICAgKHNpemUgPSBsZTMyX3RvX2NwdShieXRlX3NpemUodGFnKSkpICE9IDAg JiYKKwkJICAgICBvZmZzZXQgKyBzaXplIDwgbGVuOworCSAgICAgb2Zmc2V0ICs9IHNpemUpIHsK KwkJcHJfZGVidWcoIiAgb2Zmc2V0IDB4JTA4eCB0YWcgMHglMDh4IHNpemUgJXVcbiIsCisJCQkg IG9mZnNldCwgbGUzMl90b19jcHUodGFnLT5oZHIudGFnKSwgc2l6ZSk7CisJCWlmICh0YWctPmhk ci50YWcgPT0gdGFnX2lkKQorCQkJcmV0dXJuIHRhZzsKKwl9CisKKwlyZXR1cm4gTlVMTDsKK30K Kworc3RhdGljIGludCB6aW1hZ2VfcHJvYmUoY29uc3QgY2hhciAqa2VybmVsX2J1ZiwgdW5zaWdu ZWQgbG9uZyBrZXJuZWxfbGVuKQoreworCWNvbnN0IHN0cnVjdCBhcm1femltYWdlX2hlYWRlciAq aCA9CisJCShzdHJ1Y3QgYXJtX3ppbWFnZV9oZWFkZXIgKikoa2VybmVsX2J1Zik7CisKKwlpZiAo IWggfHwgKGtlcm5lbF9sZW4gPCBzaXplb2YoKmgpKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlp ZiAoKGgtPm1hZ2ljICE9IEFSTV9aSU1BR0VfTUFHSUMxKSB8fAorCSAgICAoaC0+bWFnaWMyICE9 IEFSTV9aSU1BR0VfTUFHSUMyKSkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlyZXR1cm4gMDsKK30K KworCisjaWYgZGVmaW5lZChERUJVRykKKyNkZWZpbmUgZGVidWdfb2Zmc2V0cygpICh7CQkJXAor CXByX2RlYnVnKCJJbWFnZSBvZmZzZXRzOlxuIik7CQlcCisJcHJfZGVidWcoIiAga2VybmVsIDB4 JTA4bHggMHglMDhseFxuIiwga2VybmVsX29mZnNldCwga2VybmVsX2xlbik7IFwKKwlwcl9kZWJ1 ZygiICB6aW1hZ2UgMHglMDhseCAweCUwOGx4XG4iLCB6aW1hZ2Vfb2Zmc2V0LCB6aW1hZ2VfbGVu KTsgXAorCXByX2RlYnVnKCIgIGluaXRyZCAweCUwOGx4IDB4JTA4bHhcbiIsIGluaXRyZF9vZmZz ZXQsIGluaXRyZF9sZW4pOyBcCit9KQorI2Vsc2UKKyNkZWZpbmUgZGVidWdfb2Zmc2V0cygpCisj ZW5kaWYKKworc3RhdGljIHZvaWQgKnppbWFnZV9sb2FkKHN0cnVjdCBraW1hZ2UgKmltYWdlLAor CQkJCWNoYXIgKnppbWFnZSwgdW5zaWduZWQgbG9uZyB6aW1hZ2VfbGVuLAorCQkJCWNoYXIgKmlu aXRyZCwgdW5zaWduZWQgbG9uZyBpbml0cmRfbGVuLAorCQkJCWNoYXIgKmNtZGxpbmUsIHVuc2ln bmVkIGxvbmcgY21kbGluZV9sZW4pCit7CisJc3RydWN0IGFybV96aW1hZ2VfaGVhZGVyICpoOwor CXN0cnVjdCBrZXhlY19idWYga2J1ZjsKKwlzdHJ1Y3Qga2V4ZWNfc2VnbWVudCAqemltYWdlX3Nl Z21lbnQ7CisJY29uc3Qgc3RydWN0IGFybV96aW1hZ2VfdGFnICp0YWc7CisJaW50IHJldCA9IC1F SU5WQUw7CisKKwl1bnNpZ25lZCBsb25nIHppbWFnZV9tZW0gPSAweDIwMDAwOyAvKiBtYWxsb2Mg NjRrQiArIHN0YWNrIDQga0IgKyBzb21lIGJzcyAqLworCXVuc2lnbmVkIGxvbmcga2VybmVsX2xl biA9IHppbWFnZV9sZW4gKiA1OyAvKiA1OjEgY29tcHJlc3Npb24gKi8KKwl1bnNpZ25lZCBsb25n IGtlcm5lbF9vZmZzZXQgPSBtZW1ibG9ja19zdGFydF9vZl9EUkFNKCk7CisJdW5zaWduZWQgbG9u ZyB6aW1hZ2Vfb2Zmc2V0ID0ga2VybmVsX29mZnNldCArCisJCUFMSUdOKGtlcm5lbF9sZW4sIFBB R0VfU0laRSk7CisJdW5zaWduZWQgbG9uZyBpbml0cmRfb2Zmc2V0ID0gemltYWdlX29mZnNldCAr CisJCUFMSUdOKHppbWFnZV9sZW4gKyB6aW1hZ2VfbWVtLCBQQUdFX1NJWkUpOworCisJaWYgKGlt YWdlLT50eXBlID09IEtFWEVDX1RZUEVfQ1JBU0gpIHsKKwkJa2VybmVsX29mZnNldCArPSBjcmFz aGtfcmVzLnN0YXJ0OworCQl6aW1hZ2Vfb2Zmc2V0ICs9IGNyYXNoa19yZXMuc3RhcnQ7CisJCWlu aXRyZF9vZmZzZXQgKz0gY3Jhc2hrX3Jlcy5zdGFydDsKKwl9CisJZGVidWdfb2Zmc2V0cygpOwor CisJaCA9IChzdHJ1Y3QgYXJtX3ppbWFnZV9oZWFkZXIgKil6aW1hZ2U7CisKKwl0YWcgPSBmaW5k X2V4dGVuc2lvbl90YWcoemltYWdlLCB6aW1hZ2VfbGVuLCBaSU1BR0VfVEFHX0tSTkxfU0laRSk7 CisJaWYgKHRhZykgeworCQl1aW50MzJfdCAqcCA9ICh2b2lkICopemltYWdlICsKKwkJCWxlMzJf dG9fY3B1KHRhZy0+dS5rcm5sX3NpemUuc2l6ZV9wdHIpOworCQl1aW50MzJfdCBlZGF0YV9zaXpl ID0gbGUzMl90b19jcHUoZ2V0X3VuYWxpZ25lZChwKSk7CisJCXVpbnQzMl90IGJzc19zaXplID0g bGUzMl90b19jcHUodGFnLT51Lmtybmxfc2l6ZS5ic3Nfc2l6ZSk7CisJCXVpbnQzMl90IHRleHRf b2Zmc2V0ID0gbGUzMl90b19jcHUodGFnLT51Lmtybmxfc2l6ZS50ZXh0X29mZnNldCk7CisKKwkJ a2VybmVsX29mZnNldCArPSBBTElHTih0ZXh0X29mZnNldCwgUEFHRV9TSVpFKTsKKwkJa2VybmVs X2xlbiA9IGVkYXRhX3NpemUgKyBic3Nfc2l6ZTsKKworCQlwcl9kZWJ1ZygiRGVjb21wcmVzc2Vk IGtlcm5lbCBzaXplczpcbiIpOworCQlwcl9kZWJ1ZygiIHRleHQrZGF0YSAweCUwOGx4IGJzcyAw eCUwOGx4IHRvdGFsIDB4JTA4bHhcbiIsCisJCQkgKHVuc2lnbmVkIGxvbmcpZWRhdGFfc2l6ZSwK KwkJCSAodW5zaWduZWQgbG9uZylic3Nfc2l6ZSwKKwkJCSAodW5zaWduZWQgbG9uZylrZXJuZWxf bGVuKTsKKworCQl6aW1hZ2Vfb2Zmc2V0ID0ga2VybmVsX29mZnNldCArIEFMSUdOKGVkYXRhX3Np emUsIFBBR0VfU0laRSk7CisJCWluaXRyZF9vZmZzZXQgPSB6aW1hZ2Vfb2Zmc2V0ICsKKwkJCW1h eChBTElHTih6aW1hZ2VfbGVuICsgMHgyMDAwMCwgUEFHRV9TSVpFKSwKKwkJCSAgICBBTElHTigo dW5zaWduZWQgbG9uZylic3Nfc2l6ZSwgUEFHRV9TSVpFKSk7CisJCWRlYnVnX29mZnNldHMoKTsK Kwl9CisKKwl0YWcgPSBmaW5kX2V4dGVuc2lvbl90YWcoemltYWdlLCB6aW1hZ2VfbGVuLAorCQkJ CSBaSU1BR0VfVEFHX1pJTUFHRV9NRU0pOworCWlmICh0YWcpIHsKKwkJdWludDMyX3QgemltYWdl X21lbSA9IGxlMzJfdG9fY3B1KHRhZy0+dS56aW1hZ2VfbWVtKTsKKworCQlwcl9kZWJ1ZygiRGVj b21wcmVzc29yIHJlcXVpcmVzICVkIGJ5dGVzIG9mIG1lbW9yeVxuIiwgemltYWdlX21lbSk7CisK KwkJaW5pdHJkX29mZnNldCA9IG1heChBTElHTih6aW1hZ2Vfb2Zmc2V0ICsgemltYWdlX2xlbiAr IHppbWFnZV9tZW0sIFBBR0VfU0laRSksCisJCQkJICAgIEFMSUdOKGtlcm5lbF9vZmZzZXQgKyBr ZXJuZWxfbGVuLCBQQUdFX1NJWkUpKTsKKwkJZGVidWdfb2Zmc2V0cygpOworCX0KKworCS8qCisJ ICogekltYWdlIE1VU1QgYmUgbG9hZGVkIGludG8gdGhlIGZpcnN0IDEyOCBNaUIgb2YgcGh5c2lj YWwKKwkgKiBtZW1vcnkgZm9yIHByb3BlciBtZW1vcnkgZGV0ZWN0aW9uLiBTaG91bGQgdGhlIHVu Y29tcHJlc3NlZAorCSAqIGtlcm5lbCBiZSBsYXJnZXIgdGhhbiAxMjggTWlCLCB6SW1hZ2UgcmVs b2NhdGlvbiBiZWNvbWVzCisJICogdW5hdm9pZGFibGUgYW5kIGl0IGlzIGJlc3QgdG8gcmVseSBv biB0aGUgcmVsb2NhdGlvbiBjb2RlLgorCSAqLworCWlmICgoKHppbWFnZV9vZmZzZXQgLSBrZXJu ZWxfb2Zmc2V0KSArIFBBR0VfU0laRSArIDB4ODAwMCkgPj0gU1pfMTI4TSkgeworCQlwcl9kZWJ1 ZygiVGhlIGtlcm5lbCBpcyB0b28gYmlnICglbGQgTWlCKSB0byBhdm9pZCAiCisJCQkgInpJbWFn ZSByZWxvY2F0aW9uLiBMb2FkaW5nIHppbWFnZSBhdCAweCUwOGx4XG4iLAorCQkJICgoemltYWdl X29mZnNldCAtIGtlcm5lbF9vZmZzZXQpID4+IDIwKSwKKwkJCSBrZXJuZWxfb2Zmc2V0KTsKKwkJ emltYWdlX29mZnNldCA9IGtlcm5lbF9vZmZzZXQ7CisJfQorCisJa2J1Zi5pbWFnZSA9IGltYWdl OworCWtidWYudG9wX2Rvd24gPSBmYWxzZTsKKworCWtidWYuYnVmX21pbiA9IHppbWFnZV9vZmZz ZXQ7CisJa2J1Zi5idWZfbWF4ID0gVUxPTkdfTUFYOworCWtidWYuYnVmZmVyID0gemltYWdlOwor CWtidWYuYnVmc3ogPSB6aW1hZ2VfbGVuOworCWtidWYuYnVmX2FsaWduID0gUEFHRV9TSVpFOwor CisJa2J1Zi5tZW0gPSBLRVhFQ19CVUZfTUVNX1VOS05PV047CisJa2J1Zi5tZW1zeiA9IHppbWFn ZV9sZW47CisKKwlyZXQgPSBrZXhlY19hZGRfYnVmZmVyKCZrYnVmKTsKKwlpZiAocmV0KQorCQly ZXR1cm4gRVJSX1BUUihyZXQpOworCisJcHJfZGVidWcoIkxvYWRlZCB6SW1hZ2UgYXQgMHglbHgg YnVmc3o9MHglbHggbWVtc3o9MHglbHhcbiIsCisJCSBrYnVmLm1lbSwga2J1Zi5idWZzeiwga2J1 Zi5tZW1zeik7CisKKwlpbml0cmRfb2Zmc2V0ICs9IGtidWYubWVtIC0gemltYWdlX29mZnNldDsK KwlkZWJ1Z19vZmZzZXRzKCk7CisKKwl6aW1hZ2Vfc2VnbWVudCA9ICZpbWFnZS0+c2VnbWVudFtp bWFnZS0+bnJfc2VnbWVudHMgLSAxXTsKKwlpbWFnZS0+c3RhcnQgPSB6aW1hZ2Vfc2VnbWVudC0+ bWVtOworCisJcmV0ID0gbG9hZF9vdGhlcl9zZWdtZW50cyhpbWFnZSwKKwkJCQkgIHppbWFnZV9z ZWdtZW50LT5tZW0sIHppbWFnZV9zZWdtZW50LT5tZW1zeiwKKwkJCQkgIGluaXRyZCwgaW5pdHJk X2xlbiwgaW5pdHJkX29mZnNldCwKKwkJCQkgIGNtZGxpbmUpOworCXJldHVybiBFUlJfUFRSKHJl dCk7Cit9CisKK2NvbnN0IHN0cnVjdCBrZXhlY19maWxlX29wcyBrZXhlY196aW1hZ2Vfb3BzID0g eworCS5wcm9iZSA9IHppbWFnZV9wcm9iZSwKKwkubG9hZCA9IHppbWFnZV9sb2FkLAorfTsKZGlm ZiAtLWdpdCBhL2FyY2gvYXJtL2tlcm5lbC9tYWNoaW5lX2tleGVjLmMgYi9hcmNoL2FybS9rZXJu ZWwvbWFjaGluZV9rZXhlYy5jCmluZGV4IGEwYzIyOWVlYzBiMi4uYjM0OWQ2YjhkMThjIDEwMDY0 NAotLS0gYS9hcmNoL2FybS9rZXJuZWwvbWFjaGluZV9rZXhlYy5jCisrKyBiL2FyY2gvYXJtL2tl cm5lbC9tYWNoaW5lX2tleGVjLmMKQEAgLTkxLDEwICs5MSwxMyBAQCBpbnQgbWFjaGluZV9rZXhl Y19wcmVwYXJlKHN0cnVjdCBraW1hZ2UgKmltYWdlKQogCQkJCQkgICAgICAgY3VycmVudF9zZWdt ZW50LT5tZW1zeikpCiAJCQlyZXR1cm4gLUVJTlZBTDsKIAotCQllcnIgPSBnZXRfdXNlcihoZWFk ZXIsIChfX2JlMzIqKWN1cnJlbnRfc2VnbWVudC0+YnVmKTsKLQkJaWYgKGVycikKLQkJCXJldHVy biBlcnI7Ci0KKwkJaWYgKGltYWdlLT5maWxlX21vZGUpIHsKKwkJCWhlYWRlciA9ICooX19iZTMy ICopY3VycmVudF9zZWdtZW50LT5idWY7CisJCX0gZWxzZSB7CisJCQllcnIgPSBnZXRfdXNlciho ZWFkZXIsIChfX2JlMzIgKiljdXJyZW50X3NlZ21lbnQtPmJ1Zik7CisJCQlpZiAoZXJyKQorCQkJ CXJldHVybiBlcnI7CisJCX0KIAkJaWYgKGhlYWRlciA9PSBjcHVfdG9fYmUzMihPRl9EVF9IRUFE RVIpKQogCQkJaW1hZ2UtPmFyY2gua2VybmVsX3IyID0gY3VycmVudF9zZWdtZW50LT5tZW07CiAJ fQpkaWZmIC0tZ2l0IGEvYXJjaC9hcm0va2VybmVsL21hY2hpbmVfa2V4ZWNfZmlsZS5jIGIvYXJj aC9hcm0va2VybmVsL21hY2hpbmVfa2V4ZWNfZmlsZS5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMC4uYTYzMmQzNTE2MDJjCi0tLSAvZGV2L251bGwKKysrIGIvYXJjaC9h cm0va2VybmVsL21hY2hpbmVfa2V4ZWNfZmlsZS5jCkBAIC0wLDAgKzEsMjExIEBACisvLyBTUERY LUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorLyoKKyAqIGtleGVjX2ZpbGUgZm9yIGFybQor ICoKKyAqIENvcHlyaWdodCAoQykgMjAxOCBMaW5hcm8gTGltaXRlZAorICogQ29weXJpZ2h0IChD KSAyMDIwIFNhbXN1bmcgRWxlY3Ryb25pY3MKKyAqIEF1dGhvcnM6CisgKiAgICAgQUtBU0hJIFRh a2FoaXJvIDx0YWthaGlyby5ha2FzaGlAbGluYXJvLm9yZz4KKyAqICAgICDFgXVrYXN6IFN0ZWxt YWNoIDxsLnN0ZWxtYWNoQHNhbXN1bmcuY29tPgorICoKKyAqLworCisjZGVmaW5lIHByX2ZtdChm bXQpICJrZXhlY19maWxlOiAiIGZtdAorCisjaW5jbHVkZSA8bGludXgva2V4ZWMuaD4KKyNpbmNs dWRlIDxsaW51eC9saWJmZHQuaD4KKyNpbmNsdWRlIDxsaW51eC9vZl9mZHQuaD4KKyNpbmNsdWRl IDxsaW51eC9yYW5kb20uaD4KKworLyogcmVsZXZhbnQgZGV2aWNlIHRyZWUgcHJvcGVydGllcyAq LworI2RlZmluZSBGRFRfUFJPUF9JTklUUkRfU1RBUlQJImxpbnV4LGluaXRyZC1zdGFydCIKKyNk ZWZpbmUgRkRUX1BST1BfSU5JVFJEX0VORAkibGludXgsaW5pdHJkLWVuZCIKKyNkZWZpbmUgRkRU X1BST1BfQk9PVEFSR1MJImJvb3RhcmdzIgorI2RlZmluZSBGRFRfUFJPUF9STkdfU0VFRAkicm5n LXNlZWQiCisKK3N0YXRpYyBpbnQgc2V0dXBfZHRiKHN0cnVjdCBraW1hZ2UgKmltYWdlLAorCQkg ICAgIHVuc2lnbmVkIGxvbmcgaW5pdHJkX2xvYWRfYWRkciwgdW5zaWduZWQgbG9uZyBpbml0cmRf bGVuLAorCQkgICAgIGNoYXIgKmNtZGxpbmUsIHZvaWQgKmR0YikKK3sKKwlpbnQgb2ZmLCByZXQ7 CisKKwlyZXQgPSBmZHRfcGF0aF9vZmZzZXQoZHRiLCAiL2Nob3NlbiIpOworCWlmIChyZXQgPCAw KQorCQlnb3RvIG91dDsKKworCW9mZiA9IHJldDsKKworCS8qIGFkZCBib290YXJncyAqLworCWlm IChjbWRsaW5lKSB7CisJCXJldCA9IGZkdF9zZXRwcm9wX3N0cmluZyhkdGIsIG9mZiwgRkRUX1BS T1BfQk9PVEFSR1MsIGNtZGxpbmUpOworCQlpZiAocmV0KQorCQkJZ290byBvdXQ7CisJfSBlbHNl IHsKKwkJcmV0ID0gZmR0X2RlbHByb3AoZHRiLCBvZmYsIEZEVF9QUk9QX0JPT1RBUkdTKTsKKwkJ aWYgKHJldCAmJiAocmV0ICE9IC1GRFRfRVJSX05PVEZPVU5EKSkKKwkJCWdvdG8gb3V0OworCX0K KworCS8qIGFkZCBpbml0cmQtKiAqLworCWlmIChpbml0cmRfbG9hZF9hZGRyKSB7CisJCXJldCA9 IGZkdF9zZXRwcm9wX3U2NChkdGIsIG9mZiwgRkRUX1BST1BfSU5JVFJEX1NUQVJULAorCQkJCSAg ICAgIGluaXRyZF9sb2FkX2FkZHIpOworCQlpZiAocmV0KQorCQkJZ290byBvdXQ7CisKKwkJcmV0 ID0gZmR0X3NldHByb3BfdTY0KGR0Yiwgb2ZmLCBGRFRfUFJPUF9JTklUUkRfRU5ELAorCQkJCSAg ICAgIGluaXRyZF9sb2FkX2FkZHIgKyBpbml0cmRfbGVuKTsKKwkJaWYgKHJldCkKKwkJCWdvdG8g b3V0OworCX0gZWxzZSB7CisJCXJldCA9IGZkdF9kZWxwcm9wKGR0Yiwgb2ZmLCBGRFRfUFJPUF9J TklUUkRfU1RBUlQpOworCQlpZiAocmV0ICYmIChyZXQgIT0gLUZEVF9FUlJfTk9URk9VTkQpKQor CQkJZ290byBvdXQ7CisKKwkJcmV0ID0gZmR0X2RlbHByb3AoZHRiLCBvZmYsIEZEVF9QUk9QX0lO SVRSRF9FTkQpOworCQlpZiAocmV0ICYmIChyZXQgIT0gLUZEVF9FUlJfTk9URk9VTkQpKQorCQkJ Z290byBvdXQ7CisJfQorCisJLyogYWRkIHJuZy1zZWVkICovCisJaWYgKHJuZ19pc19pbml0aWFs aXplZCgpKSB7CisJCWNoYXIgc2VlZFsxMjhdOworCQlnZXRfcmFuZG9tX2J5dGVzKHNlZWQsIHNp emVvZihzZWVkKSk7CisKKwkJcmV0ID0gZmR0X3NldHByb3AoZHRiLCBvZmYsIEZEVF9QUk9QX1JO R19TRUVELAorCQkJCSAgc2VlZCwgc2l6ZW9mKHNlZWQpKTsKKwkJaWYgKHJldCkKKwkJCWdvdG8g b3V0OworCX0gZWxzZSB7CisJCXByX25vdGljZSgiUk5HIGlzIG5vdCBpbml0aWFsaXNlZDogb21p dHRpbmcgXCIlc1wiIHByb3BlcnR5XG4iLAorCQkJCUZEVF9QUk9QX1JOR19TRUVEKTsKKwkJcmV0 ID0gMDsKKwl9CisKK291dDoKKwlpZiAocmV0KQorCQlyZXR1cm4gKHJldCA9PSAtRkRUX0VSUl9O T1NQQUNFKSA/IC1FTk9NRU0gOiAtRUlOVkFMOworCisJcmV0dXJuIDA7Cit9CisvKgorICogTW9y ZSBzcGFjZSBuZWVkZWQgc28gdGhhdCB3ZSBjYW4gYWRkIGluaXRyZCwgYm9vdGFyZ3MgYW5kIGth c2xyLXNlZWQuCisgKi8KKyNkZWZpbmUgRFRCX0VYVFJBX1NQQUNFIDB4MTAwMAorCitzdGF0aWMg aW50IGNyZWF0ZV9kdGIoc3RydWN0IGtpbWFnZSAqaW1hZ2UsCisJCSAgICAgIHVuc2lnbmVkIGxv bmcgaW5pdHJkX2xvYWRfYWRkciwgdW5zaWduZWQgbG9uZyBpbml0cmRfbGVuLAorCQkgICAgICBj aGFyICpjbWRsaW5lLCB2b2lkICoqZHRiKQoreworCXZvaWQgKmJ1ZjsKKwlzaXplX3QgYnVmX3Np emU7CisJc2l6ZV90IGNtZGxpbmVfbGVuOworCWludCByZXQ7CisKKwljbWRsaW5lX2xlbiA9IGNt ZGxpbmUgPyBzdHJsZW4oY21kbGluZSkgOiAwOworCWJ1Zl9zaXplID0gZmR0X3RvdGFsc2l6ZShp bml0aWFsX2Jvb3RfcGFyYW1zKQorCQkJKyBjbWRsaW5lX2xlbiArIERUQl9FWFRSQV9TUEFDRTsK KworCWZvciAoOzspIHsKKwkJYnVmID0gdm1hbGxvYyhidWZfc2l6ZSk7CisJCWlmICghYnVmKQor CQkJcmV0dXJuIC1FTk9NRU07CisKKwkJLyogZHVwbGljYXRlIGEgZGV2aWNlIHRyZWUgYmxvYiAq LworCQlyZXQgPSBmZHRfb3Blbl9pbnRvKGluaXRpYWxfYm9vdF9wYXJhbXMsIGJ1ZiwgYnVmX3Np emUpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIC1FSU5WQUw7CisKKwkJcmV0ID0gc2V0dXBfZHRi KGltYWdlLCBpbml0cmRfbG9hZF9hZGRyLCBpbml0cmRfbGVuLAorCQkJCWNtZGxpbmUsIGJ1Zik7 CisJCWlmIChyZXQpIHsKKwkJCXZmcmVlKGJ1Zik7CisJCQlpZiAocmV0ID09IC1FTk9NRU0pIHsK KwkJCQkvKiB1bmxpa2VseSwgYnV0IGp1c3QgaW4gY2FzZSAqLworCQkJCWJ1Zl9zaXplICs9IERU Ql9FWFRSQV9TUEFDRTsKKwkJCQljb250aW51ZTsKKwkJCX0gZWxzZSB7CisJCQkJcmV0dXJuIHJl dDsKKwkJCX0KKwkJfQorCisJCS8qIHRyaW0gaXQgKi8KKwkJZmR0X3BhY2soYnVmKTsKKwkJKmR0 YiA9IGJ1ZjsKKworCQlyZXR1cm4gMDsKKwl9Cit9CisKK2ludCBsb2FkX290aGVyX3NlZ21lbnRz KHN0cnVjdCBraW1hZ2UgKmltYWdlLAorCQkJdW5zaWduZWQgbG9uZyB6aW1hZ2VfbG9hZF9hZGRy LAorCQkJdW5zaWduZWQgbG9uZyB6aW1hZ2VfbGVuLAorCQkJY2hhciAqaW5pdHJkLAorCQkJdW5z aWduZWQgbG9uZyBpbml0cmRfbGVuLAorCQkJdW5zaWduZWQgbG9uZyBpbml0cmRfb2Zmc2V0LAor CQkJY2hhciAqY21kbGluZSkKK3sKKwlzdHJ1Y3Qga2V4ZWNfYnVmIGtidWY7CisJdm9pZCAqZHRi ID0gTlVMTDsKKwl1bnNpZ25lZCBsb25nIGluaXRyZF9sb2FkX2FkZHIgPSAwOworCXVuc2lnbmVk IGxvbmcgZHRiX2xlbjsKKwlpbnQgcmV0ID0gMDsKKworCWtidWYuaW1hZ2UgPSBpbWFnZTsKKwkv KiBub3QgYWxsb2NhdGUgYW55dGhpbmcgYmVsb3cgdGhlIGtlcm5lbCAqLworCWtidWYuYnVmX21p biA9IGluaXRyZF9vZmZzZXQ7CisJaWYgKGluaXRyZCkgeworCQlrYnVmLmJ1ZmZlciA9IGluaXRy ZDsKKwkJa2J1Zi5idWZzeiA9IGluaXRyZF9sZW47CisJCWtidWYubWVtID0gS0VYRUNfQlVGX01F TV9VTktOT1dOOworCQlrYnVmLm1lbXN6ID0gaW5pdHJkX2xlbjsKKwkJa2J1Zi5idWZfYWxpZ24g PSBQQUdFX1NJWkU7CisJCWtidWYuYnVmX21heCA9IFVMT05HX01BWDsKKwkJa2J1Zi50b3BfZG93 biA9IGZhbHNlOworCisJCXJldCA9IGtleGVjX2FkZF9idWZmZXIoJmtidWYpOworCQlpZiAocmV0 KQorCQkJZ290byBvdXRfZXJyOworCisJCXByX2RlYnVnKCJMb2FkZWQgaW5pdHJkIGF0IDB4JWx4 IGJ1ZnN6PTB4JWx4IG1lbXN6PTB4JWx4XG4iLAorCQkJCWtidWYubWVtLCBrYnVmLmJ1ZnN6LCBr YnVmLm1lbXN6KTsKKworCQlpbml0cmRfbG9hZF9hZGRyID0ga2J1Zi5tZW07CisJCWtidWYuYnVm X21pbiA9IGluaXRyZF9sb2FkX2FkZHIgKyBrYnVmLm1lbXN6OworCX0KKworCS8qIGxvYWQgZHRi ICovCisJcmV0ID0gY3JlYXRlX2R0YihpbWFnZSwgaW5pdHJkX2xvYWRfYWRkciwgaW5pdHJkX2xl biwgY21kbGluZSwgJmR0Yik7CisJaWYgKHJldCkgeworCQlwcl9lcnIoIlByZXBhcmluZyBmb3Ig bmV3IGR0YiBmYWlsZWRcbiIpOworCQlnb3RvIG91dF9lcnI7CisJfQorCisJZHRiX2xlbiA9IGZk dF90b3RhbHNpemUoZHRiKTsKKwlrYnVmLmJ1ZmZlciA9IGR0YjsKKwlrYnVmLmJ1ZnN6ID0gZHRi X2xlbjsKKwlrYnVmLm1lbSA9IEtFWEVDX0JVRl9NRU1fVU5LTk9XTjsKKwlrYnVmLm1lbXN6ID0g ZHRiX2xlbjsKKwlrYnVmLmJ1Zl9hbGlnbiA9IFBBR0VfU0laRTsKKwlrYnVmLmJ1Zl9tYXggPSBV TE9OR19NQVg7CisJa2J1Zi50b3BfZG93biA9IGZhbHNlOworCisJcmV0ID0ga2V4ZWNfYWRkX2J1 ZmZlcigma2J1Zik7CisJaWYgKHJldCkKKwkJZ290byBvdXRfZXJyOworCisJcHJfZGVidWcoIkxv YWRlZCBkdGIgYXQgMHglbHggYnVmc3o9MHglbHggbWVtc3o9MHglbHhcbiIsCisJCSBrYnVmLm1l bSwga2J1Zi5idWZzeiwga2J1Zi5tZW1zeik7CisJcmV0dXJuIDA7CitvdXRfZXJyOgorCXZmcmVl KGR0Yik7CisJcmV0dXJuIHJldDsKK30KKworY29uc3Qgc3RydWN0IGtleGVjX2ZpbGVfb3BzICog Y29uc3Qga2V4ZWNfZmlsZV9sb2FkZXJzW10gPSB7CisjaWZkZWYgQ09ORklHX0tFWEVDX0ZJTEVf VUlNQUdFCisJJmtleGVjX3VpbWFnZV9vcHMsCisjZW5kaWYKKwkma2V4ZWNfemltYWdlX29wcywK KwlOVUxMCit9OwotLSAKMi4yNi4yCgoKX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX18Ka2V4ZWMgbWFpbGluZyBsaXN0CmtleGVjQGxpc3RzLmluZnJhZGVhZC5v cmcKaHR0cDovL2xpc3RzLmluZnJhZGVhZC5vcmcvbWFpbG1hbi9saXN0aW5mby9rZXhlYwo=