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 Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 0D931C00144 for ; Tue, 2 Aug 2022 01:56:08 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S235772AbiHBB4H (ORCPT ); Mon, 1 Aug 2022 21:56:07 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:38628 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S235795AbiHBBzb (ORCPT ); Mon, 1 Aug 2022 21:55:31 -0400 Received: from ams.source.kernel.org (ams.source.kernel.org [145.40.68.75]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 019C54B482; Mon, 1 Aug 2022 18:53:53 -0700 (PDT) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ams.source.kernel.org (Postfix) with ESMTPS id 2FE8EB81913; Tue, 2 Aug 2022 01:53:51 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6C662C433D6; Tue, 2 Aug 2022 01:53:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1659405229; bh=GORFM1idi3kTQnV6VihqUFIxcib5JgKkOuMTQPkEH70=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Vq+z0xXjfjbWIMydJCs9sw6LD8Q6gLO3b+HF9QB2QiC3PgjJGIQM0EGENZHVGeErl AI0+mjRgSgjYRc+Qs4M3sydA826IfENNy2Q6kyRFksJAurGqsN0DRmxguxdgWbxU1p CUHNqk6fCc4HFyE2SdqhnfGMGCcKEG7kCv+OHqqhfj6e/y7zipuiHkcdwPqo6RUaAj WzRuXbzUMJO2P3IjmKQtNQaiUnhfvOQyZGnjD7GYcsyBuWoZY9hs1v3UsW7qz96bqs G7qHrOuaCUQMvoiYKiC+Pfy8tmOkc7O0DqjkaUCklJf3KkO2eY/Jjx92O46wrWyeKI BakcCxFD8Yyjg== From: Miguel Ojeda To: Linus Torvalds , Greg Kroah-Hartman Cc: rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, Jarkko Sakkinen , Miguel Ojeda , Alex Gaynor , Finn Behrens , Adam Bratschi-Kaye , Wedson Almeida Filho , Michael Ellerman , Sven Van Asbroeck , Gary Guo , Boris-Chengbiao Zhou , Boqun Feng , Douglas Su , Dariusz Sosnowski , Antonio Terceiro , Daniel Xu , Miguel Cano , David Gow , Tiago Lam , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Martin Rodriguez Reboredo , Masahiro Yamada , Michal Marek , Nick Desaulniers , Russell King , Catalin Marinas , Will Deacon , Benjamin Herrenschmidt , Paul Mackerras , Paul Walmsley , Palmer Dabbelt , Albert Ou , Richard Weinberger , Anton Ivanov , Johannes Berg , Thomas Gleixner , Ingo Molnar , Borislav Petkov , Dave Hansen , x86@kernel.org, "H. Peter Anvin" , linux-kbuild@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linuxppc-dev@lists.ozlabs.org, linux-riscv@lists.infradead.org, linux-um@lists.infradead.org Subject: [PATCH v8 27/31] Kbuild: add Rust support Date: Tue, 2 Aug 2022 03:50:14 +0200 Message-Id: <20220802015052.10452-28-ojeda@kernel.org> In-Reply-To: <20220802015052.10452-1-ojeda@kernel.org> References: <20220802015052.10452-1-ojeda@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kbuild@vger.kernel.org Having all the new files in place, we now enable Rust support in the build system, including `Kconfig` entries related to Rust, the Rust configuration printer, the target specification generation script, the version detection script and a few other bits. Co-developed-by: Alex Gaynor Signed-off-by: Alex Gaynor Co-developed-by: Finn Behrens Signed-off-by: Finn Behrens Co-developed-by: Adam Bratschi-Kaye Signed-off-by: Adam Bratschi-Kaye Co-developed-by: Wedson Almeida Filho Signed-off-by: Wedson Almeida Filho Co-developed-by: Michael Ellerman Signed-off-by: Michael Ellerman Co-developed-by: Sven Van Asbroeck Signed-off-by: Sven Van Asbroeck Co-developed-by: Gary Guo Signed-off-by: Gary Guo Co-developed-by: Boris-Chengbiao Zhou Signed-off-by: Boris-Chengbiao Zhou Co-developed-by: Boqun Feng Signed-off-by: Boqun Feng Co-developed-by: Douglas Su Signed-off-by: Douglas Su Co-developed-by: Dariusz Sosnowski Signed-off-by: Dariusz Sosnowski Co-developed-by: Antonio Terceiro Signed-off-by: Antonio Terceiro Co-developed-by: Daniel Xu Signed-off-by: Daniel Xu Co-developed-by: Miguel Cano Signed-off-by: Miguel Cano Co-developed-by: David Gow Signed-off-by: David Gow Co-developed-by: Tiago Lam Signed-off-by: Tiago Lam Co-developed-by: Björn Roy Baron Signed-off-by: Björn Roy Baron Co-developed-by: Martin Rodriguez Reboredo Signed-off-by: Martin Rodriguez Reboredo Signed-off-by: Miguel Ojeda --- .gitignore | 6 + .rustfmt.toml | 12 + Makefile | 172 +++++++- arch/Kconfig | 6 + arch/arm/Kconfig | 1 + arch/arm64/Kconfig | 1 + arch/powerpc/Kconfig | 1 + arch/riscv/Kconfig | 1 + arch/riscv/Makefile | 5 + arch/um/Kconfig | 1 + arch/x86/Kconfig | 1 + arch/x86/Makefile | 10 + include/linux/compiler_types.h | 6 +- init/Kconfig | 46 +- lib/Kconfig.debug | 82 ++++ rust/.gitignore | 10 + rust/Makefile | 415 +++++++++++++++++++ rust/bindgen_parameters | 21 + scripts/.gitignore | 1 + scripts/Kconfig.include | 6 +- scripts/Makefile | 3 + scripts/Makefile.build | 60 +++ scripts/Makefile.debug | 10 + scripts/Makefile.host | 34 +- scripts/Makefile.lib | 12 + scripts/Makefile.modfinal | 8 +- scripts/cc-version.sh | 12 +- scripts/generate_rust_target.rs | 232 +++++++++++ scripts/is_rust_module.sh | 16 + scripts/kconfig/confdata.c | 75 ++++ scripts/min-tool-version.sh | 6 + scripts/rust-is-available-bindgen-libclang.h | 2 + scripts/rust-is-available.sh | 160 +++++++ 33 files changed, 1408 insertions(+), 26 deletions(-) create mode 100644 .rustfmt.toml create mode 100644 rust/.gitignore create mode 100644 rust/Makefile create mode 100644 rust/bindgen_parameters create mode 100644 scripts/generate_rust_target.rs create mode 100755 scripts/is_rust_module.sh create mode 100644 scripts/rust-is-available-bindgen-libclang.h create mode 100755 scripts/rust-is-available.sh diff --git a/.gitignore b/.gitignore index 265959544978..5da004814678 100644 --- a/.gitignore +++ b/.gitignore @@ -37,6 +37,8 @@ *.o *.o.* *.patch +*.rmeta +*.rsi *.s *.so *.so.dbg @@ -97,6 +99,7 @@ modules.order !.gitattributes !.gitignore !.mailmap +!.rustfmt.toml # # Generated include files @@ -162,3 +165,6 @@ x509.genkey # Documentation toolchain sphinx_*/ + +# Rust analyzer configuration +/rust-project.json diff --git a/.rustfmt.toml b/.rustfmt.toml new file mode 100644 index 000000000000..3de5cc497465 --- /dev/null +++ b/.rustfmt.toml @@ -0,0 +1,12 @@ +edition = "2021" +newline_style = "Unix" + +# Unstable options that help catching some mistakes in formatting and that we may want to enable +# when they become stable. +# +# They are kept here since they are useful to run from time to time. +#format_code_in_doc_comments = true +#reorder_impl_items = true +#comment_width = 100 +#wrap_comments = true +#normalize_comments = true diff --git a/Makefile b/Makefile index df92892325ae..cd1d545f316b 100644 --- a/Makefile +++ b/Makefile @@ -120,6 +120,15 @@ endif export KBUILD_CHECKSRC +# Enable "clippy" (a linter) as part of the Rust compilation. +# +# Use 'make CLIPPY=1' to enable it. +ifeq ("$(origin CLIPPY)", "command line") + KBUILD_CLIPPY := $(CLIPPY) +endif + +export KBUILD_CLIPPY + # Use make M=dir or set the environment variable KBUILD_EXTMOD to specify the # directory of external module to build. Setting M= takes precedence. ifeq ("$(origin M)", "command line") @@ -267,14 +276,14 @@ no-dot-config-targets := $(clean-targets) \ cscope gtags TAGS tags help% %docs check% coccicheck \ $(version_h) headers headers_% archheaders archscripts \ %asm-generic kernelversion %src-pkg dt_binding_check \ - outputmakefile + outputmakefile rustavailable rustfmt rustfmtcheck # Installation targets should not require compiler. Unfortunately, vdso_install # is an exception where build artifacts may be updated. This must be fixed. no-compiler-targets := $(no-dot-config-targets) install dtbs_install \ headers_install modules_install kernelrelease image_name no-sync-config-targets := $(no-dot-config-targets) %install kernelrelease \ image_name -single-targets := %.a %.i %.ko %.lds %.ll %.lst %.mod %.o %.s %.symtypes %/ +single-targets := %.a %.i %.rsi %.ko %.lds %.ll %.lst %.mod %.o %.s %.symtypes %/ config-build := mixed-build := @@ -436,6 +445,7 @@ else HOSTCC = gcc HOSTCXX = g++ endif +HOSTRUSTC = rustc HOSTPKG_CONFIG = pkg-config KBUILD_USERHOSTCFLAGS := -Wall -Wmissing-prototypes -Wstrict-prototypes \ @@ -444,8 +454,26 @@ KBUILD_USERHOSTCFLAGS := -Wall -Wmissing-prototypes -Wstrict-prototypes \ KBUILD_USERCFLAGS := $(KBUILD_USERHOSTCFLAGS) $(USERCFLAGS) KBUILD_USERLDFLAGS := $(USERLDFLAGS) +# These flags apply to all Rust code in the tree, including the kernel and +# host programs. +export rust_common_flags := --edition=2021 \ + -Zbinary_dep_depinfo=y \ + -Dunsafe_op_in_unsafe_fn -Drust_2018_idioms \ + -Dunreachable_pub -Dnon_ascii_idents \ + -Wmissing_docs \ + -Drustdoc::missing_crate_level_docs \ + -Dclippy::correctness -Dclippy::style \ + -Dclippy::suspicious -Dclippy::complexity \ + -Dclippy::perf \ + -Dclippy::let_unit_value -Dclippy::mut_mut \ + -Dclippy::needless_bitwise_bool \ + -Dclippy::needless_continue \ + -Wclippy::dbg_macro + KBUILD_HOSTCFLAGS := $(KBUILD_USERHOSTCFLAGS) $(HOST_LFS_CFLAGS) $(HOSTCFLAGS) KBUILD_HOSTCXXFLAGS := -Wall -O2 $(HOST_LFS_CFLAGS) $(HOSTCXXFLAGS) +KBUILD_HOSTRUSTFLAGS := $(rust_common_flags) -O -Cstrip=debuginfo \ + -Zallow-features= $(HOSTRUSTFLAGS) KBUILD_HOSTLDFLAGS := $(HOST_LFS_LDFLAGS) $(HOSTLDFLAGS) KBUILD_HOSTLDLIBS := $(HOST_LFS_LIBS) $(HOSTLDLIBS) @@ -470,6 +498,12 @@ OBJDUMP = $(CROSS_COMPILE)objdump READELF = $(CROSS_COMPILE)readelf STRIP = $(CROSS_COMPILE)strip endif +RUSTC = rustc +RUSTDOC = rustdoc +RUSTFMT = rustfmt +CLIPPY_DRIVER = clippy-driver +BINDGEN = bindgen +CARGO = cargo PAHOLE = pahole RESOLVE_BTFIDS = $(objtree)/tools/bpf/resolve_btfids/resolve_btfids LEX = flex @@ -495,9 +529,11 @@ CHECKFLAGS := -D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ \ -Wbitwise -Wno-return-void -Wno-unknown-attribute $(CF) NOSTDINC_FLAGS := CFLAGS_MODULE = +RUSTFLAGS_MODULE = AFLAGS_MODULE = LDFLAGS_MODULE = CFLAGS_KERNEL = +RUSTFLAGS_KERNEL = AFLAGS_KERNEL = LDFLAGS_vmlinux = @@ -526,15 +562,42 @@ KBUILD_CFLAGS := -Wall -Wundef -Werror=strict-prototypes -Wno-trigraphs \ -Werror=return-type -Wno-format-security \ -std=gnu11 KBUILD_CPPFLAGS := -D__KERNEL__ +KBUILD_RUSTFLAGS := $(rust_common_flags) \ + --target=$(objtree)/rust/target.json \ + -Cpanic=abort -Cembed-bitcode=n -Clto=n \ + -Cforce-unwind-tables=n -Ccodegen-units=1 \ + -Csymbol-mangling-version=v0 \ + -Crelocation-model=static \ + -Zfunction-sections=n \ + -Dclippy::float_arithmetic + KBUILD_AFLAGS_KERNEL := KBUILD_CFLAGS_KERNEL := +KBUILD_RUSTFLAGS_KERNEL := KBUILD_AFLAGS_MODULE := -DMODULE KBUILD_CFLAGS_MODULE := -DMODULE +KBUILD_RUSTFLAGS_MODULE := --cfg MODULE KBUILD_LDFLAGS_MODULE := KBUILD_LDFLAGS := CLANG_FLAGS := +ifeq ($(KBUILD_CLIPPY),1) + RUSTC_OR_CLIPPY_QUIET := CLIPPY + RUSTC_OR_CLIPPY = $(CLIPPY_DRIVER) +else + RUSTC_OR_CLIPPY_QUIET := RUSTC + RUSTC_OR_CLIPPY = $(RUSTC) +endif + +ifdef RUST_LIB_SRC + export RUST_LIB_SRC +endif + +export RUSTC_BOOTSTRAP := 1 + export ARCH SRCARCH CONFIG_SHELL BASH HOSTCC KBUILD_HOSTCFLAGS CROSS_COMPILE LD CC HOSTPKG_CONFIG +export RUSTC RUSTDOC RUSTFMT RUSTC_OR_CLIPPY_QUIET RUSTC_OR_CLIPPY BINDGEN CARGO +export HOSTRUSTC KBUILD_HOSTRUSTFLAGS export CPP AR NM STRIP OBJCOPY OBJDUMP READELF PAHOLE RESOLVE_BTFIDS LEX YACC AWK INSTALLKERNEL export PERL PYTHON3 CHECK CHECKFLAGS MAKE UTS_MACHINE HOSTCXX export KGZIP KBZIP2 KLZOP LZMA LZ4 XZ ZSTD @@ -543,9 +606,10 @@ export KBUILD_USERCFLAGS KBUILD_USERLDFLAGS export KBUILD_CPPFLAGS NOSTDINC_FLAGS LINUXINCLUDE OBJCOPYFLAGS KBUILD_LDFLAGS export KBUILD_CFLAGS CFLAGS_KERNEL CFLAGS_MODULE +export KBUILD_RUSTFLAGS RUSTFLAGS_KERNEL RUSTFLAGS_MODULE export KBUILD_AFLAGS AFLAGS_KERNEL AFLAGS_MODULE -export KBUILD_AFLAGS_MODULE KBUILD_CFLAGS_MODULE KBUILD_LDFLAGS_MODULE -export KBUILD_AFLAGS_KERNEL KBUILD_CFLAGS_KERNEL +export KBUILD_AFLAGS_MODULE KBUILD_CFLAGS_MODULE KBUILD_RUSTFLAGS_MODULE KBUILD_LDFLAGS_MODULE +export KBUILD_AFLAGS_KERNEL KBUILD_CFLAGS_KERNEL KBUILD_RUSTFLAGS_KERNEL export PAHOLE_FLAGS # Files to ignore in find ... statements @@ -726,7 +790,7 @@ $(KCONFIG_CONFIG): # # Do not use $(call cmd,...) here. That would suppress prompts from syncconfig, # so you cannot notice that Kconfig is waiting for the user input. -%/config/auto.conf %/config/auto.conf.cmd %/generated/autoconf.h: $(KCONFIG_CONFIG) +%/config/auto.conf %/config/auto.conf.cmd %/generated/autoconf.h %/generated/rustc_cfg: $(KCONFIG_CONFIG) $(Q)$(kecho) " SYNC $@" $(Q)$(MAKE) -f $(srctree)/Makefile syncconfig else # !may-sync-config @@ -755,12 +819,20 @@ KBUILD_CFLAGS += $(call cc-disable-warning, address-of-packed-member) ifdef CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE KBUILD_CFLAGS += -O2 +KBUILD_RUSTFLAGS += -Copt-level=2 else ifdef CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE_O3 KBUILD_CFLAGS += -O3 +KBUILD_RUSTFLAGS += -Copt-level=3 else ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE KBUILD_CFLAGS += -Os +KBUILD_RUSTFLAGS += -Copt-level=s endif +# Always set `debug-assertions` and `overflow-checks` because their default +# depends on `opt-level` and `debug-assertions`, respectively. +KBUILD_RUSTFLAGS += -Cdebug-assertions=$(if $(CONFIG_RUST_DEBUG_ASSERTIONS),y,n) +KBUILD_RUSTFLAGS += -Coverflow-checks=$(if $(CONFIG_RUST_OVERFLOW_CHECKS),y,n) + # Tell gcc to never replace conditional load with a non-conditional one ifdef CONFIG_CC_IS_GCC # gcc-10 renamed --param=allow-store-data-races=0 to @@ -791,6 +863,9 @@ KBUILD_CFLAGS-$(CONFIG_WERROR) += -Werror KBUILD_CFLAGS-$(CONFIG_CC_NO_ARRAY_BOUNDS) += -Wno-array-bounds KBUILD_CFLAGS += $(KBUILD_CFLAGS-y) $(CONFIG_CC_IMPLICIT_FALLTHROUGH) +KBUILD_RUSTFLAGS-$(CONFIG_WERROR) += -Dwarnings +KBUILD_RUSTFLAGS += $(KBUILD_RUSTFLAGS-y) + ifdef CONFIG_CC_IS_CLANG KBUILD_CPPFLAGS += -Qunused-arguments # The kernel builds with '-std=gnu11' so use of GNU extensions is acceptable. @@ -811,12 +886,15 @@ KBUILD_CFLAGS += $(call cc-disable-warning, dangling-pointer) ifdef CONFIG_FRAME_POINTER KBUILD_CFLAGS += -fno-omit-frame-pointer -fno-optimize-sibling-calls +KBUILD_RUSTFLAGS += -Cforce-frame-pointers=y else # Some targets (ARM with Thumb2, for example), can't be built with frame # pointers. For those, we don't have FUNCTION_TRACER automatically # select FRAME_POINTER. However, FUNCTION_TRACER adds -pg, and this is # incompatible with -fomit-frame-pointer with current GCC, so we don't use # -fomit-frame-pointer with FUNCTION_TRACER. +# In the Rust target specification, "frame-pointer" is set explicitly +# to "may-omit". ifndef CONFIG_FUNCTION_TRACER KBUILD_CFLAGS += -fomit-frame-pointer endif @@ -881,8 +959,10 @@ ifdef CONFIG_DEBUG_SECTION_MISMATCH KBUILD_CFLAGS += -fno-inline-functions-called-once endif +# `rustc`'s `-Zfunction-sections` applies to data too (as of 1.59.0). ifdef CONFIG_LD_DEAD_CODE_DATA_ELIMINATION KBUILD_CFLAGS_KERNEL += -ffunction-sections -fdata-sections +KBUILD_RUSTFLAGS_KERNEL += -Zfunction-sections=y LDFLAGS_vmlinux += --gc-sections endif @@ -1025,10 +1105,11 @@ include $(addprefix $(srctree)/, $(include-y)) # Do not add $(call cc-option,...) below this line. When you build the kernel # from the clean source tree, the GCC plugins do not exist at this point. -# Add user supplied CPPFLAGS, AFLAGS and CFLAGS as the last assignments +# Add user supplied CPPFLAGS, AFLAGS, CFLAGS and RUSTFLAGS as the last assignments KBUILD_CPPFLAGS += $(KCPPFLAGS) KBUILD_AFLAGS += $(KAFLAGS) KBUILD_CFLAGS += $(KCFLAGS) +KBUILD_RUSTFLAGS += $(KRUSTFLAGS) KBUILD_LDFLAGS_MODULE += --build-id=sha1 LDFLAGS_vmlinux += --build-id=sha1 @@ -1097,6 +1178,7 @@ export MODULES_NSDEPS := $(extmod_prefix)modules.nsdeps ifeq ($(KBUILD_EXTMOD),) core-y += kernel/ certs/ mm/ fs/ ipc/ security/ crypto/ core-$(CONFIG_BLOCK) += block/ +core-$(CONFIG_RUST) += rust/ vmlinux-dirs := $(patsubst %/,%,$(filter %/, \ $(core-y) $(core-m) $(drivers-y) $(drivers-m) \ @@ -1201,6 +1283,10 @@ prepare0: archprepare # All the preparing.. prepare: prepare0 +ifdef CONFIG_RUST + $(Q)$(CONFIG_SHELL) $(srctree)/scripts/rust-is-available.sh -v + $(Q)$(MAKE) $(build)=rust +endif PHONY += remove-stale-files remove-stale-files: @@ -1490,7 +1576,7 @@ endif # CONFIG_MODULES # Directories & files removed with 'make clean' CLEAN_FILES += include/ksym vmlinux.symvers modules-only.symvers \ modules.builtin modules.builtin.modinfo modules.nsdeps \ - compile_commands.json .thinlto-cache + compile_commands.json .thinlto-cache rust/test rust/doc # Directories & files removed with 'make mrproper' MRPROPER_FILES += include/config include/generated \ @@ -1501,7 +1587,8 @@ MRPROPER_FILES += include/config include/generated \ certs/signing_key.pem \ certs/x509.genkey \ vmlinux-gdb.py \ - *.spec + *.spec \ + rust/target.json rust/libmacros.so # clean - Delete most, but leave enough to build external modules # @@ -1526,6 +1613,9 @@ $(mrproper-dirs): mrproper: clean $(mrproper-dirs) $(call cmd,rmfiles) + @find . $(RCS_FIND_IGNORE) \ + \( -name '*.rmeta' \) \ + -type f -print | xargs rm -f # distclean # @@ -1613,6 +1703,24 @@ help: @echo ' kselftest-merge - Merge all the config dependencies of' @echo ' kselftest to existing .config.' @echo '' + @echo 'Rust targets:' + @echo ' rustavailable - Checks whether the Rust toolchain is' + @echo ' available and, if not, explains why.' + @echo ' rustfmt - Reformat all the Rust code in the kernel' + @echo ' rustfmtcheck - Checks if all the Rust code in the kernel' + @echo ' is formatted, printing a diff otherwise.' + @echo ' rustdoc - Generate Rust documentation' + @echo ' (requires kernel .config)' + @echo ' rusttest - Runs the Rust tests' + @echo ' (requires kernel .config; downloads external repos)' + @echo ' rust-analyzer - Generate rust-project.json rust-analyzer support file' + @echo ' (requires kernel .config)' + @echo ' dir/file.[os] - Build specified target only' + @echo ' dir/file.rsi - Build macro expanded source, similar to C preprocessing.' + @echo ' Run with RUSTFMT=n to skip reformatting if needed.' + @echo ' The output is not intended to be compilable.' + @echo ' dir/file.ll - Build the LLVM assembly file' + @echo '' @$(if $(dtstree), \ echo 'Devicetree:'; \ echo '* dtbs - Build device tree blobs for enabled boards'; \ @@ -1685,6 +1793,52 @@ PHONY += $(DOC_TARGETS) $(DOC_TARGETS): $(Q)$(MAKE) $(build)=Documentation $@ + +# Rust targets +# --------------------------------------------------------------------------- + +# "Is Rust available?" target +PHONY += rustavailable +rustavailable: + $(Q)$(CONFIG_SHELL) $(srctree)/scripts/rust-is-available.sh -v && echo "Rust is available!" + +# Documentation target +# +# Using the singular to avoid running afoul of `no-dot-config-targets`. +PHONY += rustdoc +rustdoc: prepare + $(Q)$(MAKE) $(build)=rust $@ + +# Testing target +PHONY += rusttest +rusttest: prepare + $(Q)$(MAKE) $(build)=rust $@ + +# Formatting targets +PHONY += rustfmt rustfmtcheck + +# We skip `rust/alloc` since we want to minimize the diff w.r.t. upstream. +# +# We match using absolute paths since `find` does not resolve them +# when matching, which is a problem when e.g. `srctree` is `..`. +# We `grep` afterwards in order to remove the directory entry itself. +rustfmt: + $(Q)find $(abs_srctree) -type f -name '*.rs' \ + -o -path $(abs_srctree)/rust/alloc -prune \ + -o -path $(abs_objtree)/rust/test -prune \ + | grep -Fv $(abs_srctree)/rust/alloc \ + | grep -Fv $(abs_objtree)/rust/test \ + | grep -Fv generated \ + | xargs $(RUSTFMT) $(rustfmt_flags) + +rustfmtcheck: rustfmt_flags = --check +rustfmtcheck: rustfmt + +# IDE support targets +PHONY += rust-analyzer +rust-analyzer: + $(Q)$(MAKE) $(build)=rust $@ + # Misc # --------------------------------------------------------------------------- @@ -1852,7 +2006,7 @@ $(clean-dirs): clean: $(clean-dirs) $(call cmd,rmfiles) @find $(or $(KBUILD_EXTMOD), .) $(RCS_FIND_IGNORE) \ - \( -name '*.[aios]' -o -name '*.ko' -o -name '.*.cmd' \ + \( -name '*.[aios]' -o -name '*.rsi' -o -name '*.ko' -o -name '.*.cmd' \ -o -name '*.ko.*' \ -o -name '*.dtb' -o -name '*.dtbo' -o -name '*.dtb.S' -o -name '*.dt.yaml' \ -o -name '*.dwo' -o -name '*.lst' \ diff --git a/arch/Kconfig b/arch/Kconfig index 71b9272acb28..d5038cf8dd49 100644 --- a/arch/Kconfig +++ b/arch/Kconfig @@ -353,6 +353,12 @@ config HAVE_RSEQ This symbol should be selected by an architecture if it supports an implementation of restartable sequences. +config HAVE_RUST + bool + help + This symbol should be selected by an architecture if it + supports Rust. + config HAVE_FUNCTION_ARG_ACCESS_API bool help diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig index 7630ba9cb6cc..147655a4fc27 100644 --- a/arch/arm/Kconfig +++ b/arch/arm/Kconfig @@ -116,6 +116,7 @@ config ARM select MMU_GATHER_RCU_TABLE_FREE if SMP && ARM_LPAE select HAVE_REGS_AND_STACK_ACCESS_API select HAVE_RSEQ + select HAVE_RUST if CPU_32v6 || CPU_32v6K select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS select HAVE_UID16 diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig index 1652a9800ebe..aaeb70358979 100644 --- a/arch/arm64/Kconfig +++ b/arch/arm64/Kconfig @@ -201,6 +201,7 @@ config ARM64 select HAVE_FUNCTION_ARG_ACCESS_API select MMU_GATHER_RCU_TABLE_FREE select HAVE_RSEQ + select HAVE_RUST select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS select HAVE_KPROBES diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig index 4d8f26c1399b..edab3cc9edf5 100644 --- a/arch/powerpc/Kconfig +++ b/arch/powerpc/Kconfig @@ -243,6 +243,7 @@ config PPC select HAVE_REGS_AND_STACK_ACCESS_API select HAVE_RELIABLE_STACKTRACE select HAVE_RSEQ + select HAVE_RUST if PPC64 && CPU_LITTLE_ENDIAN select HAVE_SETUP_PER_CPU_AREA if PPC64 select HAVE_SOFTIRQ_ON_OWN_STACK select HAVE_STACKPROTECTOR if PPC32 && $(cc-option,-mstack-protector-guard=tls -mstack-protector-guard-reg=r2) diff --git a/arch/riscv/Kconfig b/arch/riscv/Kconfig index fcbb81feb7ad..5b53b41528f6 100644 --- a/arch/riscv/Kconfig +++ b/arch/riscv/Kconfig @@ -104,6 +104,7 @@ config RISCV select HAVE_PERF_REGS select HAVE_PERF_USER_STACK_DUMP select HAVE_REGS_AND_STACK_ACCESS_API + select HAVE_RUST if 64BIT select HAVE_FUNCTION_ARG_ACCESS_API select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS diff --git a/arch/riscv/Makefile b/arch/riscv/Makefile index 81029d40a672..24ebe042406e 100644 --- a/arch/riscv/Makefile +++ b/arch/riscv/Makefile @@ -26,6 +26,8 @@ ifeq ($(CONFIG_ARCH_RV64I),y) KBUILD_CFLAGS += -mabi=lp64 KBUILD_AFLAGS += -mabi=lp64 + KBUILD_RUSTFLAGS += -Ctarget-cpu=generic-rv64 + KBUILD_LDFLAGS += -melf64lriscv else BITS := 32 @@ -33,6 +35,9 @@ else KBUILD_CFLAGS += -mabi=ilp32 KBUILD_AFLAGS += -mabi=ilp32 + + KBUILD_RUSTFLAGS += -Ctarget-cpu=generic-rv32 + KBUILD_LDFLAGS += -melf32lriscv endif diff --git a/arch/um/Kconfig b/arch/um/Kconfig index 4ec22e156a2e..6dc06a7bf8b7 100644 --- a/arch/um/Kconfig +++ b/arch/um/Kconfig @@ -25,6 +25,7 @@ config UML select TRACE_IRQFLAGS_SUPPORT select TTY # Needed for line.c select HAVE_ARCH_VMAP_STACK + select HAVE_RUST if X86_64 config MMU bool diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index 52a7f91527fe..4d5a3f256cbc 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig @@ -258,6 +258,7 @@ config X86 select HAVE_STATIC_CALL_INLINE if HAVE_OBJTOOL select HAVE_PREEMPT_DYNAMIC_CALL select HAVE_RSEQ + select HAVE_RUST if X86_64 select HAVE_SYSCALL_TRACEPOINTS select HAVE_UACCESS_VALIDATION if HAVE_OBJTOOL select HAVE_UNSTABLE_SCHED_CLOCK diff --git a/arch/x86/Makefile b/arch/x86/Makefile index 7854685c5f25..bab595003f07 100644 --- a/arch/x86/Makefile +++ b/arch/x86/Makefile @@ -68,6 +68,7 @@ export BITS # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53383 # KBUILD_CFLAGS += -mno-sse -mno-mmx -mno-sse2 -mno-3dnow -mno-avx +KBUILD_RUSTFLAGS += -Ctarget-feature=-sse,-sse2,-sse3,-ssse3,-sse4.1,-sse4.2,-avx,-avx2 ifeq ($(CONFIG_X86_KERNEL_IBT),y) # @@ -155,8 +156,17 @@ else cflags-$(CONFIG_GENERIC_CPU) += -mtune=generic KBUILD_CFLAGS += $(cflags-y) + rustflags-$(CONFIG_MK8) += -Ctarget-cpu=k8 + rustflags-$(CONFIG_MPSC) += -Ctarget-cpu=nocona + rustflags-$(CONFIG_MCORE2) += -Ctarget-cpu=core2 + rustflags-$(CONFIG_MATOM) += -Ctarget-cpu=atom + rustflags-$(CONFIG_GENERIC_CPU) += -Ztune-cpu=generic + KBUILD_RUSTFLAGS += $(rustflags-y) + KBUILD_CFLAGS += -mno-red-zone KBUILD_CFLAGS += -mcmodel=kernel + KBUILD_RUSTFLAGS += -Cno-redzone=y + KBUILD_RUSTFLAGS += -Ccode-model=kernel endif # diff --git a/include/linux/compiler_types.h b/include/linux/compiler_types.h index 4f2a819fd60a..50b3f6b9502e 100644 --- a/include/linux/compiler_types.h +++ b/include/linux/compiler_types.h @@ -4,8 +4,12 @@ #ifndef __ASSEMBLY__ +/* + * Skipped when running bindgen due to a libclang issue; + * see https://github.com/rust-lang/rust-bindgen/issues/2244. + */ #if defined(CONFIG_DEBUG_INFO_BTF) && defined(CONFIG_PAHOLE_HAS_BTF_TAG) && \ - __has_attribute(btf_type_tag) + __has_attribute(btf_type_tag) && !defined(__BINDGEN__) # define BTF_TYPE_TAG(value) __attribute__((btf_type_tag(#value))) #else # define BTF_TYPE_TAG(value) /* nothing */ diff --git a/init/Kconfig b/init/Kconfig index c7900e8975f1..6f62dbea8283 100644 --- a/init/Kconfig +++ b/init/Kconfig @@ -60,6 +60,17 @@ config LLD_VERSION default $(ld-version) if LD_IS_LLD default 0 +config RUST_IS_AVAILABLE + def_bool $(success,$(srctree)/scripts/rust-is-available.sh) + help + This shows whether a suitable Rust toolchain is available (found). + + Please see Documentation/rust/quick-start.rst for instructions on how + to satify the build requirements of Rust support. + + In particular, the Makefile target 'rustavailable' is useful to check + why the Rust toolchain is not being detected. + config CC_CAN_LINK bool default $(success,$(srctree)/scripts/cc-can-link.sh $(CC) $(CLANG_FLAGS) $(USERCFLAGS) $(USERLDFLAGS) $(m64-flag)) if 64BIT @@ -151,7 +162,8 @@ config WERROR default COMPILE_TEST help A kernel build should not cause any compiler warnings, and this - enables the '-Werror' flag to enforce that rule by default. + enables the '-Werror' (for C) and '-Dwarnings' (for Rust) flags + to enforce that rule by default. However, if you have a new (or very old) compiler with odd and unusual warnings, or you have some architecture with problems, @@ -1898,6 +1910,38 @@ config PROFILING Say Y here to enable the extended profiling support mechanisms used by profilers. +config RUST + bool "Rust support" + depends on HAVE_RUST + depends on RUST_IS_AVAILABLE + depends on !MODVERSIONS + depends on !GCC_PLUGINS + depends on !RANDSTRUCT + depends on !DEBUG_INFO_BTF + select CONSTRUCTORS + help + Enables Rust support in the kernel. + + This allows other Rust-related options, like drivers written in Rust, + to be selected. + + It is also required to be able to load external kernel modules + written in Rust. + + See Documentation/rust/ for more information. + + If unsure, say N. + +config RUSTC_VERSION_TEXT + string + depends on RUST + default $(shell,command -v $(RUSTC) >/dev/null 2>&1 && $(RUSTC) --version || echo n) + +config BINDGEN_VERSION_TEXT + string + depends on RUST + default $(shell,command -v $(BINDGEN) >/dev/null 2>&1 && $(BINDGEN) --version || echo n) + # # Place an empty function call at each tracepoint site. Can be # dynamically changed for a probe function. diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index 2e24db4bff19..ae3c43e0092e 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -2688,6 +2688,88 @@ config HYPERV_TESTING endmenu # "Kernel Testing and Coverage" +menu "Rust hacking" + +config RUST_DEBUG_ASSERTIONS + bool "Debug assertions" + depends on RUST + help + Enables rustc's `-Cdebug-assertions` codegen option. + + This flag lets you turn `cfg(debug_assertions)` conditional + compilation on or off. This can be used to enable extra debugging + code in development but not in production. For example, it controls + the behavior of the standard library's `debug_assert!` macro. + + Note that this will apply to all Rust code, including `core`. + + If unsure, say N. + +config RUST_OVERFLOW_CHECKS + bool "Overflow checks" + default y + depends on RUST + help + Enables rustc's `-Coverflow-checks` codegen option. + + This flag allows you to control the behavior of runtime integer + overflow. When overflow-checks are enabled, a Rust panic will occur + on overflow. + + Note that this will apply to all Rust code, including `core`. + + If unsure, say Y. + +choice + prompt "Build-time assertions" + default RUST_BUILD_ASSERT_DENY + depends on RUST + help + Controls how are `build_error!` and `build_assert!` handled during build. + + If calls to them exist in the binary, it may indicate a violated invariant + or that the optimizer failed to verify the invariant during compilation. + You can choose to abort compilation or ignore them during build and let the + check be carried to runtime. + + If optimizations are turned off, you cannot select "Deny". + + If unsure, say "Deny". + +config RUST_BUILD_ASSERT_ALLOW + bool "Allow" + help + Unoptimized calls to `build_error!` will be converted to `panic!` + and checked at runtime. + +config RUST_BUILD_ASSERT_WARN + bool "Warn" + help + Unoptimized calls to `build_error!` will be converted to `panic!` + and checked at runtime, but warnings will be generated when building. + +config RUST_BUILD_ASSERT_DENY + bool "Deny" + help + Unoptimized calls to `build_error!` will abort compilation. + +endchoice + +config RUST_KERNEL_KUNIT_TEST + bool "KUnit test for the `kernel` crate" if !KUNIT_ALL_TESTS + depends on RUST && KUNIT=y + default KUNIT_ALL_TESTS + help + This builds the documentation tests of the `kernel` crate + as KUnit tests. + + For more information on KUnit and unit tests in general, + please refer to the KUnit documentation in Documentation/dev-tools/kunit/. + + If unsure, say N. + +endmenu # "Rust" + source "Documentation/Kconfig" endmenu # Kernel hacking diff --git a/rust/.gitignore b/rust/.gitignore new file mode 100644 index 000000000000..89b602d91109 --- /dev/null +++ b/rust/.gitignore @@ -0,0 +1,10 @@ +# SPDX-License-Identifier: GPL-2.0 + +target.json +bindings_generated.rs +bindings_helpers_generated.rs +exports_*_generated.h +doctests_kernel_generated.rs +doctests_kernel_generated_kunit.c +doc/ +test/ diff --git a/rust/Makefile b/rust/Makefile new file mode 100644 index 000000000000..30ce13fa8dad --- /dev/null +++ b/rust/Makefile @@ -0,0 +1,415 @@ +# SPDX-License-Identifier: GPL-2.0 + +always-$(CONFIG_RUST) += target.json +no-clean-files += target.json + +obj-$(CONFIG_RUST) += core.o compiler_builtins.o +always-$(CONFIG_RUST) += exports_core_generated.h + +# Missing prototypes are expected in the helpers since these are exported +# for Rust only, thus there is no header nor prototypes. +obj-$(CONFIG_RUST) += helpers.o +CFLAGS_REMOVE_helpers.o = -Wmissing-prototypes -Wmissing-declarations + +always-$(CONFIG_RUST) += libmacros.so +no-clean-files += libmacros.so + +always-$(CONFIG_RUST) += bindings/bindings_generated.rs bindings/bindings_helpers_generated.rs +obj-$(CONFIG_RUST) += alloc.o bindings.o kernel.o +always-$(CONFIG_RUST) += exports_alloc_generated.h exports_bindings_generated.h \ + exports_kernel_generated.h + +ifdef CONFIG_RUST_BUILD_ASSERT_DENY +always-$(CONFIG_RUST) += build_error.o +else +obj-$(CONFIG_RUST) += build_error.o +endif + +obj-$(CONFIG_RUST) += exports.o + +obj-$(CONFIG_RUST_KERNEL_KUNIT_TEST) += doctests_kernel_generated.o +obj-$(CONFIG_RUST_KERNEL_KUNIT_TEST) += doctests_kernel_generated_kunit.o + +# Avoids running `$(RUSTC)` for the sysroot when it may not be available. +ifdef CONFIG_RUST + +# `$(rust_flags)` is passed in case the user added `--sysroot`. +rustc_sysroot := $(shell $(RUSTC) $(rust_flags) --print sysroot) +rustc_host_target := $(shell $(RUSTC) --version --verbose | grep -F 'host: ' | cut -d' ' -f2) +RUST_LIB_SRC ?= $(rustc_sysroot)/lib/rustlib/src/rust/library + +ifeq ($(quiet),silent_) +cargo_quiet=-q +rust_test_quiet=-q +rustdoc_test_quiet=--test-args -q +rustdoc_test_kernel_quiet=>/dev/null +else ifeq ($(quiet),quiet_) +rust_test_quiet=-q +rustdoc_test_quiet=--test-args -q +rustdoc_test_kernel_quiet=>/dev/null +else +cargo_quiet=--verbose +endif + +core-cfgs = \ + --cfg no_fp_fmt_parse + +alloc-cfgs = \ + --cfg no_global_oom_handling \ + --cfg no_rc \ + --cfg no_sync + +quiet_cmd_rustdoc = RUSTDOC $(if $(rustdoc_host),H, ) $< + cmd_rustdoc = \ + OBJTREE=$(abspath $(objtree)) \ + $(RUSTDOC) $(if $(rustdoc_host),$(rust_common_flags),$(rust_flags)) \ + $(rustc_target_flags) -L$(objtree)/$(obj) \ + --output $(objtree)/$(obj)/doc \ + --crate-name $(subst rustdoc-,,$@) \ + @$(objtree)/include/generated/rustc_cfg $< + +# The `html_logo_url` and `html_favicon_url` forms of the `doc` attribute +# can be used to specify a custom logo. However: +# - The given value is used as-is, thus it cannot be relative or a local file +# (unlike the non-custom case) since the generated docs have subfolders. +# - It requires adding it to every crate. +# - It requires changing `core` which comes from the sysroot. +# +# Using `-Zcrate-attr` would solve the last two points, but not the first. +# The https://github.com/rust-lang/rfcs/pull/3226 RFC suggests two new +# command-like flags to solve the issue. Meanwhile, we use the non-custom case +# and then retouch the generated files. +rustdoc: rustdoc-core rustdoc-macros rustdoc-compiler_builtins \ + rustdoc-alloc rustdoc-kernel + $(Q)cp $(srctree)/Documentation/images/logo.svg $(objtree)/$(obj)/doc + $(Q)cp $(srctree)/Documentation/images/COPYING-logo $(objtree)/$(obj)/doc + $(Q)find $(objtree)/$(obj)/doc -name '*.html' -type f -print0 | xargs -0 sed -Ei \ + -e 's:rust-logo\.svg:logo.svg:g' \ + -e 's:rust-logo\.png:logo.svg:g' \ + -e 's:favicon\.svg:logo.svg:g' \ + -e 's:::g' + $(Q)echo '.logo-container > img { object-fit: contain; }' \ + >> $(objtree)/$(obj)/doc/rustdoc.css + +rustdoc-macros: private rustdoc_host = yes +rustdoc-macros: private rustc_target_flags = --crate-type proc-macro \ + --extern proc_macro +rustdoc-macros: $(src)/macros/lib.rs FORCE + $(call if_changed,rustdoc) + +rustdoc-core: private rustc_target_flags = $(core-cfgs) +rustdoc-core: $(RUST_LIB_SRC)/core/src/lib.rs FORCE + $(call if_changed,rustdoc) + +rustdoc-compiler_builtins: $(src)/compiler_builtins.rs rustdoc-core FORCE + $(call if_changed,rustdoc) + +# We need to allow `rustdoc::broken_intra_doc_links` because some +# `no_global_oom_handling` functions refer to non-`no_global_oom_handling` +# functions. Ideally `rustdoc` would have a way to distinguish broken links +# due to things that are "configured out" vs. entirely non-existing ones. +rustdoc-alloc: private rustc_target_flags = $(alloc-cfgs) \ + -Arustdoc::broken_intra_doc_links +rustdoc-alloc: $(src)/alloc/lib.rs rustdoc-core rustdoc-compiler_builtins FORCE + $(call if_changed,rustdoc) + +rustdoc-kernel: private rustc_target_flags = --extern alloc \ + --extern build_error --extern macros=$(objtree)/$(obj)/libmacros.so \ + --extern bindings +rustdoc-kernel: $(src)/kernel/lib.rs rustdoc-core rustdoc-macros \ + rustdoc-compiler_builtins rustdoc-alloc $(obj)/libmacros.so \ + $(obj)/bindings.o FORCE + $(call if_changed,rustdoc) + +quiet_cmd_rustc_test_library = RUSTC TL $< + cmd_rustc_test_library = \ + OBJTREE=$(abspath $(objtree)) \ + $(RUSTC) $(rust_common_flags) \ + @$(objtree)/include/generated/rustc_cfg $(rustc_target_flags) \ + --crate-type $(if $(rustc_test_library_proc),proc-macro,rlib) \ + --out-dir $(objtree)/$(obj)/test --cfg testlib \ + --sysroot $(objtree)/$(obj)/test/sysroot \ + -L$(objtree)/$(obj)/test \ + --crate-name $(subst rusttest-,,$(subst rusttestlib-,,$@)) $< + +rusttestlib-build_error: $(src)/build_error.rs rusttest-prepare FORCE + $(call if_changed,rustc_test_library) + +rusttestlib-macros: private rustc_target_flags = --extern proc_macro +rusttestlib-macros: private rustc_test_library_proc = yes +rusttestlib-macros: $(src)/macros/lib.rs rusttest-prepare FORCE + $(call if_changed,rustc_test_library) + +rusttestlib-bindings: $(src)/bindings/lib.rs rusttest-prepare FORCE + $(call if_changed,rustc_test_library) + +quiet_cmd_rustdoc_test = RUSTDOC T $< + cmd_rustdoc_test = \ + OBJTREE=$(abspath $(objtree)) \ + $(RUSTDOC) --test $(rust_common_flags) \ + @$(objtree)/include/generated/rustc_cfg \ + $(rustc_target_flags) $(rustdoc_test_target_flags) \ + --sysroot $(objtree)/$(obj)/test/sysroot $(rustdoc_test_quiet) \ + -L$(objtree)/$(obj)/test --output $(objtree)/$(obj)/doc \ + --crate-name $(subst rusttest-,,$@) $< + +quiet_cmd_rustdoc_test_kernel = RUSTDOC TK $< + cmd_rustdoc_test_kernel = \ + rm -rf $(objtree)/$(obj)/test/doctests/kernel; \ + mkdir -p $(objtree)/$(obj)/test/doctests/kernel; \ + OBJTREE=$(abspath $(objtree)) \ + $(RUSTDOC) --test $(rust_flags) \ + @$(objtree)/include/generated/rustc_cfg \ + -L$(objtree)/$(obj) --extern alloc --extern kernel \ + --extern build_error --extern macros \ + --extern bindings \ + --no-run --crate-name kernel -Zunstable-options \ + --test-builder $(srctree)/scripts/rustdoc_test_builder.py \ + $< $(rustdoc_test_kernel_quiet); \ + $(srctree)/scripts/rustdoc_test_gen.py + +%/doctests_kernel_generated.rs %/doctests_kernel_generated_kunit.c: $(src)/kernel/lib.rs $(obj)/kernel.o FORCE + $(call if_changed,rustdoc_test_kernel) + +# We cannot use `-Zpanic-abort-tests` because some tests are dynamic, +# so for the moment we skip `-Cpanic=abort`. +quiet_cmd_rustc_test = RUSTC T $< + cmd_rustc_test = \ + OBJTREE=$(abspath $(objtree)) \ + $(RUSTC) --test $(rust_common_flags) \ + @$(objtree)/include/generated/rustc_cfg \ + $(rustc_target_flags) --out-dir $(objtree)/$(obj)/test \ + --sysroot $(objtree)/$(obj)/test/sysroot \ + -L$(objtree)/$(obj)/test \ + --crate-name $(subst rusttest-,,$@) $<; \ + $(objtree)/$(obj)/test/$(subst rusttest-,,$@) $(rust_test_quiet) \ + $(rustc_test_run_flags) + +rusttest: rusttest-macros rusttest-kernel + +# This prepares a custom sysroot with our custom `alloc` instead of +# the standard one. +# +# This requires several hacks: +# - Unlike `core` and `alloc`, `std` depends on more than a dozen crates, +# including third-party crates that need to be downloaded, plus custom +# `build.rs` steps. Thus hardcoding things here is not maintainable. +# - `cargo` knows how to build the standard library, but it is an unstable +# feature so far (`-Zbuild-std`). +# - `cargo` only considers the use case of building the standard library +# to use it in a given package. Thus we need to create a dummy package +# and pick the generated libraries from there. +# - Since we only keep a subset of upstream `alloc` in-tree, we need +# to recreate it on the fly by putting our sources on top. +# - The usual ways of modifying the dependency graph in `cargo` do not seem +# to apply for the `-Zbuild-std` steps, thus we have to mislead it +# by modifying the sources in the sysroot. +# - To avoid messing with the user's Rust installation, we create a clone +# of the sysroot. However, `cargo` ignores `RUSTFLAGS` in the `-Zbuild-std` +# steps, thus we use a wrapper binary passed via `RUSTC` to pass the flag. +# +# In the future, we hope to avoid the whole ordeal by either: +# - Making the `test` crate not depend on `std` (either improving upstream +# or having our own custom crate). +# - Making the tests run in kernel space (requires the previous point). +# - Making `std` and friends be more like a "normal" crate, so that +# `-Zbuild-std` and related hacks are not needed. +quiet_cmd_rustsysroot = RUSTSYSROOT + cmd_rustsysroot = \ + rm -rf $(objtree)/$(obj)/test; \ + mkdir -p $(objtree)/$(obj)/test; \ + cp -a $(rustc_sysroot) $(objtree)/$(obj)/test/sysroot; \ + cp -r $(srctree)/$(src)/alloc/* \ + $(objtree)/$(obj)/test/sysroot/lib/rustlib/src/rust/library/alloc/src; \ + echo '\#!/bin/sh' > $(objtree)/$(obj)/test/rustc_sysroot; \ + echo "$(RUSTC) --sysroot=$(abspath $(objtree)/$(obj)/test/sysroot) \"\$$@\"" \ + >> $(objtree)/$(obj)/test/rustc_sysroot; \ + chmod u+x $(objtree)/$(obj)/test/rustc_sysroot; \ + $(CARGO) -q new $(objtree)/$(obj)/test/dummy; \ + RUSTC=$(objtree)/$(obj)/test/rustc_sysroot $(CARGO) $(cargo_quiet) \ + test -Zbuild-std --target $(rustc_host_target) \ + --manifest-path $(objtree)/$(obj)/test/dummy/Cargo.toml; \ + rm $(objtree)/$(obj)/test/sysroot/lib/rustlib/$(rustc_host_target)/lib/*; \ + cp $(objtree)/$(obj)/test/dummy/target/$(rustc_host_target)/debug/deps/* \ + $(objtree)/$(obj)/test/sysroot/lib/rustlib/$(rustc_host_target)/lib + +rusttest-prepare: FORCE + $(call if_changed,rustsysroot) + +rusttest-macros: private rustc_target_flags = --extern proc_macro +rusttest-macros: private rustdoc_test_target_flags = --crate-type proc-macro +rusttest-macros: $(src)/macros/lib.rs rusttest-prepare FORCE + $(call if_changed,rustc_test) + $(call if_changed,rustdoc_test) + +rusttest-kernel: private rustc_target_flags = --extern alloc \ + --extern build_error --extern macros --extern bindings +rusttest-kernel: $(src)/kernel/lib.rs rusttest-prepare \ + rusttestlib-build_error rusttestlib-macros rusttestlib-bindings FORCE + $(call if_changed,rustc_test) + $(call if_changed,rustc_test_library) + +filechk_rust_target = $(objtree)/scripts/generate_rust_target < $< + +$(obj)/target.json: $(objtree)/include/config/auto.conf FORCE + $(call filechk,rust_target) + +ifdef CONFIG_CC_IS_CLANG +bindgen_c_flags = $(c_flags) +else +# bindgen relies on libclang to parse C. Ideally, bindgen would support a GCC +# plugin backend and/or the Clang driver would be perfectly compatible with GCC. +# +# For the moment, here we are tweaking the flags on the fly. This is a hack, +# and some kernel configurations may not work (e.g. `GCC_PLUGIN_RANDSTRUCT` +# if we end up using one of those structs). +bindgen_skip_c_flags := -mno-fp-ret-in-387 -mpreferred-stack-boundary=% \ + -mskip-rax-setup -mgeneral-regs-only -msign-return-address=% \ + -mindirect-branch=thunk-extern -mindirect-branch-register \ + -mfunction-return=thunk-extern -mrecord-mcount -mabi=lp64 \ + -mstack-protector-guard% -mtraceback=no \ + -mno-pointers-to-nested-functions -mno-string \ + -mno-strict-align -mstrict-align \ + -fconserve-stack -falign-jumps=% -falign-loops=% \ + -femit-struct-debug-baseonly -fno-ipa-cp-clone -fno-ipa-sra \ + -fno-partial-inlining -fplugin-arg-arm_ssp_per_task_plugin-% \ + -fno-reorder-blocks -fno-allow-store-data-races -fasan-shadow-offset=% \ + -fzero-call-used-regs=% -fno-stack-clash-protection \ + -fno-inline-functions-called-once \ + --param=% --param asan-% + +# Derived from `scripts/Makefile.clang`. +BINDGEN_TARGET_arm := arm-linux-gnueabi +BINDGEN_TARGET_arm64 := aarch64-linux-gnu +BINDGEN_TARGET_powerpc := powerpc64le-linux-gnu +BINDGEN_TARGET_riscv := riscv64-linux-gnu +BINDGEN_TARGET_x86 := x86_64-linux-gnu +BINDGEN_TARGET := $(BINDGEN_TARGET_$(SRCARCH)) + +# All warnings are inhibited since GCC builds are very experimental, +# many GCC warnings are not supported by Clang, they may only appear in +# some configurations, with new GCC versions, etc. +bindgen_extra_c_flags = -w --target=$(BINDGEN_TARGET) + +bindgen_c_flags = $(filter-out $(bindgen_skip_c_flags), $(c_flags)) \ + $(bindgen_extra_c_flags) +endif + +ifdef CONFIG_LTO +bindgen_c_flags_lto = $(filter-out $(CC_FLAGS_LTO), $(bindgen_c_flags)) +else +bindgen_c_flags_lto = $(bindgen_c_flags) +endif + +bindgen_c_flags_final = $(bindgen_c_flags_lto) -D__BINDGEN__ + +quiet_cmd_bindgen = BINDGEN $@ + cmd_bindgen = \ + $(BINDGEN) $< $(bindgen_target_flags) \ + --use-core --with-derive-default --ctypes-prefix core::ffi --no-layout-tests \ + --no-debug '.*' \ + --size_t-is-usize -o $@ -- $(bindgen_c_flags_final) -DMODULE \ + $(bindgen_target_cflags) $(bindgen_target_extra) + +$(obj)/bindings/bindings_generated.rs: private bindgen_target_flags = \ + $(shell grep -v '^\#\|^$$' $(srctree)/$(src)/bindgen_parameters) +$(obj)/bindings/bindings_generated.rs: $(src)/bindings/bindings_helper.h \ + $(src)/bindgen_parameters FORCE + $(call if_changed_dep,bindgen) + +# See `CFLAGS_REMOVE_helpers.o` above. In addition, Clang on C does not warn +# with `-Wmissing-declarations` (unlike GCC), so it is not strictly needed here +# given it is `libclang`; but for consistency, future Clang changes and/or +# a potential future GCC backend for `bindgen`, we disable it too. +$(obj)/bindings/bindings_helpers_generated.rs: private bindgen_target_flags = \ + --blacklist-type '.*' --whitelist-var '' \ + --whitelist-function 'rust_helper_.*' +$(obj)/bindings/bindings_helpers_generated.rs: private bindgen_target_cflags = \ + -I$(objtree)/$(obj) -Wno-missing-prototypes -Wno-missing-declarations +$(obj)/bindings/bindings_helpers_generated.rs: private bindgen_target_extra = ; \ + sed -Ei 's/pub fn rust_helper_([a-zA-Z0-9_]*)/#[link_name="rust_helper_\1"]\n pub fn \1/g' $@ +$(obj)/bindings/bindings_helpers_generated.rs: $(src)/helpers.c FORCE + $(call if_changed_dep,bindgen) + +quiet_cmd_exports = EXPORTS $@ + cmd_exports = \ + $(NM) -p --defined-only $< \ + | grep -E ' (T|R|D) ' | cut -d ' ' -f 3 \ + | xargs -Isymbol \ + echo 'EXPORT_SYMBOL_RUST_GPL(symbol);' > $@ + +$(obj)/exports_core_generated.h: $(obj)/core.o FORCE + $(call if_changed,exports) + +$(obj)/exports_alloc_generated.h: $(obj)/alloc.o FORCE + $(call if_changed,exports) + +$(obj)/exports_bindings_generated.h: $(obj)/bindings.o FORCE + $(call if_changed,exports) + +$(obj)/exports_kernel_generated.h: $(obj)/kernel.o FORCE + $(call if_changed,exports) + +quiet_cmd_rustc_procmacro = $(RUSTC_OR_CLIPPY_QUIET) P $@ + cmd_rustc_procmacro = \ + $(RUSTC_OR_CLIPPY) $(rust_common_flags) \ + --emit=dep-info,link --extern proc_macro \ + --crate-type proc-macro --out-dir $(objtree)/$(obj) \ + --crate-name $(patsubst lib%.so,%,$(notdir $@)) $<; \ + mv $(objtree)/$(obj)/$(patsubst lib%.so,%,$(notdir $@)).d $(depfile); \ + sed -i '/^\#/d' $(depfile) + +# Procedural macros can only be used with the `rustc` that compiled it. +# Therefore, to get `libmacros.so` automatically recompiled when the compiler +# version changes, we add `core.o` as a dependency (even if it is not needed). +$(obj)/libmacros.so: $(src)/macros/lib.rs $(obj)/core.o FORCE + $(call if_changed_dep,rustc_procmacro) + +quiet_cmd_rustc_library = $(if $(skip_clippy),RUSTC,$(RUSTC_OR_CLIPPY_QUIET)) L $@ + cmd_rustc_library = \ + OBJTREE=$(abspath $(objtree)) \ + $(if $(skip_clippy),$(RUSTC),$(RUSTC_OR_CLIPPY)) \ + $(filter-out $(skip_flags),$(rust_flags) $(rustc_target_flags)) \ + --emit=dep-info,obj,metadata --crate-type rlib \ + --out-dir $(objtree)/$(obj) -L$(objtree)/$(obj) \ + --crate-name $(patsubst %.o,%,$(notdir $@)) $<; \ + mv $(objtree)/$(obj)/$(patsubst %.o,%,$(notdir $@)).d $(depfile); \ + sed -i '/^\#/d' $(depfile) \ + $(if $(rustc_objcopy),;$(OBJCOPY) $(rustc_objcopy) $@) + +rust-analyzer: + $(Q)$(srctree)/scripts/generate_rust_analyzer.py $(srctree) $(objtree) \ + $(RUST_LIB_SRC) > $(objtree)/rust-project.json + +$(obj)/core.o: private skip_clippy = 1 +$(obj)/core.o: private skip_flags = -Dunreachable_pub +$(obj)/core.o: private rustc_target_flags = $(core-cfgs) +$(obj)/core.o: $(RUST_LIB_SRC)/core/src/lib.rs $(obj)/target.json FORCE + $(call if_changed_dep,rustc_library) + +$(obj)/compiler_builtins.o: private rustc_objcopy = -w -W '__*' +$(obj)/compiler_builtins.o: $(src)/compiler_builtins.rs $(obj)/core.o FORCE + $(call if_changed_dep,rustc_library) + +$(obj)/alloc.o: private skip_clippy = 1 +$(obj)/alloc.o: private skip_flags = -Dunreachable_pub +$(obj)/alloc.o: private rustc_target_flags = $(alloc-cfgs) +$(obj)/alloc.o: $(src)/alloc/lib.rs $(obj)/compiler_builtins.o FORCE + $(call if_changed_dep,rustc_library) + +$(obj)/build_error.o: $(src)/build_error.rs $(obj)/compiler_builtins.o FORCE + $(call if_changed_dep,rustc_library) + +$(obj)/bindings.o: $(src)/bindings/lib.rs \ + $(obj)/compiler_builtins.o \ + $(obj)/bindings/bindings_generated.rs \ + $(obj)/bindings/bindings_helpers_generated.rs FORCE + $(call if_changed_dep,rustc_library) + +$(obj)/kernel.o: private rustc_target_flags = --extern alloc \ + --extern build_error --extern macros --extern bindings +$(obj)/kernel.o: $(src)/kernel/lib.rs $(obj)/alloc.o $(obj)/build_error.o \ + $(obj)/libmacros.so $(obj)/bindings.o FORCE + $(call if_changed_dep,rustc_library) + +endif # CONFIG_RUST diff --git a/rust/bindgen_parameters b/rust/bindgen_parameters new file mode 100644 index 000000000000..be4963bf7203 --- /dev/null +++ b/rust/bindgen_parameters @@ -0,0 +1,21 @@ +# SPDX-License-Identifier: GPL-2.0 + +--opaque-type xregs_state +--opaque-type desc_struct +--opaque-type arch_lbr_state +--opaque-type local_apic + +# Packed type cannot transitively contain a `#[repr(align)]` type. +--opaque-type x86_msi_data +--opaque-type x86_msi_addr_lo + +# `try` is a reserved keyword since Rust 2018; solved in `bindgen` v0.59.2, +# commit 2aed6b021680 ("context: Escape the try keyword properly"). +--opaque-type kunit_try_catch + +# If SMP is disabled, `arch_spinlock_t` is defined as a ZST which triggers a Rust +# warning. We don't need to peek into it anyway. +--opaque-type spinlock + +# `seccomp`'s comment gets understood as a doctest +--no-doc-comments diff --git a/scripts/.gitignore b/scripts/.gitignore index eed308bef604..b7aec8eb1bd4 100644 --- a/scripts/.gitignore +++ b/scripts/.gitignore @@ -1,6 +1,7 @@ # SPDX-License-Identifier: GPL-2.0-only /asn1_compiler /bin2c +/generate_rust_target /insert-sys-cert /kallsyms /module.lds diff --git a/scripts/Kconfig.include b/scripts/Kconfig.include index 0496efd6e117..83e850321eb6 100644 --- a/scripts/Kconfig.include +++ b/scripts/Kconfig.include @@ -36,12 +36,12 @@ ld-option = $(success,$(LD) -v $(1)) as-instr = $(success,printf "%b\n" "$(1)" | $(CC) $(CLANG_FLAGS) -c -x assembler -o /dev/null -) # check if $(CC) and $(LD) exist -$(error-if,$(failure,command -v $(CC)),compiler '$(CC)' not found) +$(error-if,$(failure,command -v $(CC)),C compiler '$(CC)' not found) $(error-if,$(failure,command -v $(LD)),linker '$(LD)' not found) -# Get the compiler name, version, and error out if it is not supported. +# Get the C compiler name, version, and error out if it is not supported. cc-info := $(shell,$(srctree)/scripts/cc-version.sh $(CC)) -$(error-if,$(success,test -z "$(cc-info)"),Sorry$(comma) this compiler is not supported.) +$(error-if,$(success,test -z "$(cc-info)"),Sorry$(comma) this C compiler is not supported.) cc-name := $(shell,set -- $(cc-info) && echo $1) cc-version := $(shell,set -- $(cc-info) && echo $2) diff --git a/scripts/Makefile b/scripts/Makefile index f084f08ed176..1575af84d557 100644 --- a/scripts/Makefile +++ b/scripts/Makefile @@ -10,6 +10,9 @@ hostprogs-always-$(CONFIG_BUILDTIME_TABLE_SORT) += sorttable hostprogs-always-$(CONFIG_ASN1) += asn1_compiler hostprogs-always-$(CONFIG_MODULE_SIG_FORMAT) += sign-file hostprogs-always-$(CONFIG_SYSTEM_EXTRA_CERTIFICATE) += insert-sys-cert +hostprogs-always-$(CONFIG_RUST) += generate_rust_target + +generate_rust_target-rust := y HOSTCFLAGS_sorttable.o = -I$(srctree)/tools/include HOSTLDLIBS_sorttable = -lpthread diff --git a/scripts/Makefile.build b/scripts/Makefile.build index cac070aee791..5c495713f1b1 100644 --- a/scripts/Makefile.build +++ b/scripts/Makefile.build @@ -26,6 +26,7 @@ EXTRA_CPPFLAGS := EXTRA_LDFLAGS := asflags-y := ccflags-y := +rustflags-y := cppflags-y := ldflags-y := @@ -271,6 +272,65 @@ quiet_cmd_cc_lst_c = MKLST $@ $(obj)/%.lst: $(src)/%.c FORCE $(call if_changed_dep,cc_lst_c) +# Compile Rust sources (.rs) +# --------------------------------------------------------------------------- + +rust_allowed_features := allocator_api,bench_black_box,core_ffi_c,generic_associated_types,const_ptr_offset_from,const_refs_to_cell + +rust_common_cmd = \ + RUST_MODFILE=$(modfile) $(RUSTC_OR_CLIPPY) $(rust_flags) \ + -Zallow-features=$(rust_allowed_features) \ + -Zcrate-attr=no_std \ + -Zcrate-attr='feature($(rust_allowed_features))' \ + --extern alloc --extern kernel \ + --crate-type rlib --out-dir $(obj) -L $(objtree)/rust/ \ + --crate-name $(basename $(notdir $@)) + +rust_handle_depfile = \ + mv $(obj)/$(basename $(notdir $@)).d $(depfile); \ + sed -i '/^\#/d' $(depfile) + +# `--emit=obj`, `--emit=asm` and `--emit=llvm-ir` imply a single codegen unit +# will be used. We explicitly request `-Ccodegen-units=1` in any case, and +# the compiler shows a warning if it is not 1. However, if we ever stop +# requesting it explicitly and we start using some other `--emit` that does not +# imply it (and for which codegen is performed), then we would be out of sync, +# i.e. the outputs we would get for the different single targets (e.g. `.ll`) +# would not match each other. + +quiet_cmd_rustc_o_rs = $(RUSTC_OR_CLIPPY_QUIET) $(quiet_modtag) $@ + cmd_rustc_o_rs = \ + $(rust_common_cmd) --emit=dep-info,obj $<; \ + $(rust_handle_depfile) + +$(obj)/%.o: $(src)/%.rs FORCE + $(call if_changed_dep,rustc_o_rs) + +quiet_cmd_rustc_rsi_rs = $(RUSTC_OR_CLIPPY_QUIET) $(quiet_modtag) $@ + cmd_rustc_rsi_rs = \ + $(rust_common_cmd) --emit=dep-info -Zunpretty=expanded $< >$@; \ + command -v $(RUSTFMT) >/dev/null && $(RUSTFMT) $@; \ + $(rust_handle_depfile) + +$(obj)/%.rsi: $(src)/%.rs FORCE + $(call if_changed_dep,rustc_rsi_rs) + +quiet_cmd_rustc_s_rs = $(RUSTC_OR_CLIPPY_QUIET) $(quiet_modtag) $@ + cmd_rustc_s_rs = \ + $(rust_common_cmd) --emit=dep-info,asm $<; \ + $(rust_handle_depfile) + +$(obj)/%.s: $(src)/%.rs FORCE + $(call if_changed_dep,rustc_s_rs) + +quiet_cmd_rustc_ll_rs = $(RUSTC_OR_CLIPPY_QUIET) $(quiet_modtag) $@ + cmd_rustc_ll_rs = \ + $(rust_common_cmd) --emit=dep-info,llvm-ir $<; \ + $(rust_handle_depfile) + +$(obj)/%.ll: $(src)/%.rs FORCE + $(call if_changed_dep,rustc_ll_rs) + # Compile assembler sources (.S) # --------------------------------------------------------------------------- diff --git a/scripts/Makefile.debug b/scripts/Makefile.debug index 9f39b0130551..fe87389d52c0 100644 --- a/scripts/Makefile.debug +++ b/scripts/Makefile.debug @@ -1,4 +1,5 @@ DEBUG_CFLAGS := +DEBUG_RUSTFLAGS := ifdef CONFIG_DEBUG_INFO_SPLIT DEBUG_CFLAGS += -gsplit-dwarf @@ -10,6 +11,12 @@ ifndef CONFIG_AS_IS_LLVM KBUILD_AFLAGS += -Wa,-gdwarf-2 endif +ifdef CONFIG_DEBUG_INFO_REDUCED +DEBUG_RUSTFLAGS += -Cdebuginfo=1 +else +DEBUG_RUSTFLAGS += -Cdebuginfo=2 +endif + ifndef CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT dwarf-version-$(CONFIG_DEBUG_INFO_DWARF4) := 4 dwarf-version-$(CONFIG_DEBUG_INFO_DWARF5) := 5 @@ -31,3 +38,6 @@ endif KBUILD_CFLAGS += $(DEBUG_CFLAGS) export DEBUG_CFLAGS + +KBUILD_RUSTFLAGS += $(DEBUG_RUSTFLAGS) +export DEBUG_RUSTFLAGS diff --git a/scripts/Makefile.host b/scripts/Makefile.host index 278b4d6ac945..da133780b751 100644 --- a/scripts/Makefile.host +++ b/scripts/Makefile.host @@ -22,6 +22,8 @@ $(obj)/%.tab.c $(obj)/%.tab.h: $(src)/%.y FORCE # to preprocess a data file. # # Both C and C++ are supported, but preferred language is C for such utilities. +# Rust is also supported, but it may only be used in scenarios where a Rust +# toolchain is required to be available (e.g. when `CONFIG_RUST` is enabled). # # Sample syntax (see Documentation/kbuild/makefiles.rst for reference) # hostprogs := bin2hex @@ -37,15 +39,20 @@ $(obj)/%.tab.c $(obj)/%.tab.h: $(src)/%.y FORCE # qconf-objs := menu.o # Will compile qconf as a C++ program, and menu as a C program. # They are linked as C++ code to the executable qconf +# +# hostprogs := target +# target-rust := y +# Will compile `target` as a Rust program, using `target.rs` as the crate root. +# The crate may consist of several source files. # C code # Executables compiled from a single .c file host-csingle := $(foreach m,$(hostprogs), \ - $(if $($(m)-objs)$($(m)-cxxobjs),,$(m))) + $(if $($(m)-objs)$($(m)-cxxobjs)$($(m)-rust),,$(m))) # C executables linked based on several .o files host-cmulti := $(foreach m,$(hostprogs),\ - $(if $($(m)-cxxobjs),,$(if $($(m)-objs),$(m)))) + $(if $($(m)-cxxobjs)$($(m)-rust),,$(if $($(m)-objs),$(m)))) # Object (.o) files compiled from .c files host-cobjs := $(sort $(foreach m,$(hostprogs),$($(m)-objs))) @@ -58,11 +65,17 @@ host-cxxmulti := $(foreach m,$(hostprogs),$(if $($(m)-cxxobjs),$(m))) # C++ Object (.o) files compiled from .cc files host-cxxobjs := $(sort $(foreach m,$(host-cxxmulti),$($(m)-cxxobjs))) +# Rust code +# Executables compiled from a single Rust crate (which may consist of +# one or more .rs files) +host-rust := $(foreach m,$(hostprogs),$(if $($(m)-rust),$(m))) + host-csingle := $(addprefix $(obj)/,$(host-csingle)) host-cmulti := $(addprefix $(obj)/,$(host-cmulti)) host-cobjs := $(addprefix $(obj)/,$(host-cobjs)) host-cxxmulti := $(addprefix $(obj)/,$(host-cxxmulti)) host-cxxobjs := $(addprefix $(obj)/,$(host-cxxobjs)) +host-rust := $(addprefix $(obj)/,$(host-rust)) ##### # Handle options to gcc. Support building with separate output directory @@ -71,6 +84,8 @@ _hostc_flags = $(KBUILD_HOSTCFLAGS) $(HOST_EXTRACFLAGS) \ $(HOSTCFLAGS_$(target-stem).o) _hostcxx_flags = $(KBUILD_HOSTCXXFLAGS) $(HOST_EXTRACXXFLAGS) \ $(HOSTCXXFLAGS_$(target-stem).o) +_hostrust_flags = $(KBUILD_HOSTRUSTFLAGS) $(HOST_EXTRARUSTFLAGS) \ + $(HOSTRUSTFLAGS_$(target-stem)) # $(objtree)/$(obj) for including generated headers from checkin source files ifeq ($(KBUILD_EXTMOD),) @@ -82,6 +97,7 @@ endif hostc_flags = -Wp,-MMD,$(depfile) $(_hostc_flags) hostcxx_flags = -Wp,-MMD,$(depfile) $(_hostcxx_flags) +hostrust_flags = $(_hostrust_flags) ##### # Compile programs on the host @@ -128,5 +144,17 @@ quiet_cmd_host-cxxobjs = HOSTCXX $@ $(host-cxxobjs): $(obj)/%.o: $(src)/%.cc FORCE $(call if_changed_dep,host-cxxobjs) +# Create executable from a single Rust crate (which may consist of +# one or more `.rs` files) +# host-rust -> Executable +quiet_cmd_host-rust = HOSTRUSTC $@ + cmd_host-rust = \ + $(HOSTRUSTC) $(hostrust_flags) --emit=dep-info,link \ + --out-dir=$(obj)/ $<; \ + mv $(obj)/$(target-stem).d $(depfile); \ + sed -i '/^\#/d' $(depfile) +$(host-rust): $(obj)/%: $(src)/%.rs FORCE + $(call if_changed_dep,host-rust) + targets += $(host-csingle) $(host-cmulti) $(host-cobjs) \ - $(host-cxxmulti) $(host-cxxobjs) + $(host-cxxmulti) $(host-cxxobjs) $(host-rust) diff --git a/scripts/Makefile.lib b/scripts/Makefile.lib index 3fb6a99e78c4..c88b98b5dc44 100644 --- a/scripts/Makefile.lib +++ b/scripts/Makefile.lib @@ -8,6 +8,7 @@ ldflags-y += $(EXTRA_LDFLAGS) # flags that take effect in current and sub directories KBUILD_AFLAGS += $(subdir-asflags-y) KBUILD_CFLAGS += $(subdir-ccflags-y) +KBUILD_RUSTFLAGS += $(subdir-rustflags-y) # Figure out what we need to build from the various variables # =========================================================================== @@ -128,6 +129,10 @@ _c_flags = $(filter-out $(CFLAGS_REMOVE_$(target-stem).o), \ $(filter-out $(ccflags-remove-y), \ $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS) $(ccflags-y)) \ $(CFLAGS_$(target-stem).o)) +_rust_flags = $(filter-out $(RUSTFLAGS_REMOVE_$(target-stem).o), \ + $(filter-out $(rustflags-remove-y), \ + $(KBUILD_RUSTFLAGS) $(rustflags-y)) \ + $(RUSTFLAGS_$(target-stem).o)) _a_flags = $(filter-out $(AFLAGS_REMOVE_$(target-stem).o), \ $(filter-out $(asflags-remove-y), \ $(KBUILD_CPPFLAGS) $(KBUILD_AFLAGS) $(asflags-y)) \ @@ -202,6 +207,11 @@ modkern_cflags = \ $(KBUILD_CFLAGS_MODULE) $(CFLAGS_MODULE), \ $(KBUILD_CFLAGS_KERNEL) $(CFLAGS_KERNEL) $(modfile_flags)) +modkern_rustflags = \ + $(if $(part-of-module), \ + $(KBUILD_RUSTFLAGS_MODULE) $(RUSTFLAGS_MODULE), \ + $(KBUILD_RUSTFLAGS_KERNEL) $(RUSTFLAGS_KERNEL)) + modkern_aflags = $(if $(part-of-module), \ $(KBUILD_AFLAGS_MODULE) $(AFLAGS_MODULE), \ $(KBUILD_AFLAGS_KERNEL) $(AFLAGS_KERNEL)) @@ -211,6 +221,8 @@ c_flags = -Wp,-MMD,$(depfile) $(NOSTDINC_FLAGS) $(LINUXINCLUDE) \ $(_c_flags) $(modkern_cflags) \ $(basename_flags) $(modname_flags) +rust_flags = $(_rust_flags) $(modkern_rustflags) @$(objtree)/include/generated/rustc_cfg + a_flags = -Wp,-MMD,$(depfile) $(NOSTDINC_FLAGS) $(LINUXINCLUDE) \ $(_a_flags) $(modkern_aflags) diff --git a/scripts/Makefile.modfinal b/scripts/Makefile.modfinal index 35100e981f4a..9a1fa6aa30fe 100644 --- a/scripts/Makefile.modfinal +++ b/scripts/Makefile.modfinal @@ -39,11 +39,13 @@ quiet_cmd_ld_ko_o = LD [M] $@ quiet_cmd_btf_ko = BTF [M] $@ cmd_btf_ko = \ - if [ -f vmlinux ]; then \ + if [ ! -f vmlinux ]; then \ + printf "Skipping BTF generation for %s due to unavailability of vmlinux\n" $@ 1>&2; \ + elif [ -n "$(CONFIG_RUST)" ] && $(srctree)/scripts/is_rust_module.sh $@; then \ + printf "Skipping BTF generation for %s because it's a Rust module\n" $@ 1>&2; \ + else \ LLVM_OBJCOPY="$(OBJCOPY)" $(PAHOLE) -J $(PAHOLE_FLAGS) --btf_base vmlinux $@; \ $(RESOLVE_BTFIDS) -b vmlinux $@; \ - else \ - printf "Skipping BTF generation for %s due to unavailability of vmlinux\n" $@ 1>&2; \ fi; # Same as newer-prereqs, but allows to exclude specified extra dependencies diff --git a/scripts/cc-version.sh b/scripts/cc-version.sh index f1952c522466..2401c86fcf53 100755 --- a/scripts/cc-version.sh +++ b/scripts/cc-version.sh @@ -1,13 +1,13 @@ #!/bin/sh # SPDX-License-Identifier: GPL-2.0 # -# Print the compiler name and its version in a 5 or 6-digit form. +# Print the C compiler name and its version in a 5 or 6-digit form. # Also, perform the minimum version check. set -e -# Print the compiler name and some version components. -get_compiler_info() +# Print the C compiler name and some version components. +get_c_compiler_info() { cat <<- EOF | "$@" -E -P -x c - 2>/dev/null #if defined(__clang__) @@ -32,7 +32,7 @@ get_canonical_version() # $@ instead of $1 because multiple words might be given, e.g. CC="ccache gcc". orig_args="$@" -set -- $(get_compiler_info "$@") +set -- $(get_c_compiler_info "$@") name=$1 @@ -52,7 +52,7 @@ ICC) min_version=$($min_tool_version icc) ;; *) - echo "$orig_args: unknown compiler" >&2 + echo "$orig_args: unknown C compiler" >&2 exit 1 ;; esac @@ -62,7 +62,7 @@ min_cversion=$(get_canonical_version $min_version) if [ "$cversion" -lt "$min_cversion" ]; then echo >&2 "***" - echo >&2 "*** Compiler is too old." + echo >&2 "*** C compiler is too old." echo >&2 "*** Your $name version: $version" echo >&2 "*** Minimum $name version: $min_version" echo >&2 "***" diff --git a/scripts/generate_rust_target.rs b/scripts/generate_rust_target.rs new file mode 100644 index 000000000000..0a1ba95d74e7 --- /dev/null +++ b/scripts/generate_rust_target.rs @@ -0,0 +1,232 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! The custom target specification file generator for `rustc`. +//! +//! To configure a target from scratch, a JSON-encoded file has to be passed +//! to `rustc` (introduced in [RFC 131]). These options and the file itself are +//! unstable. Eventually, `rustc` should provide a way to do this in a stable +//! manner. For instance, via command-line arguments. Therefore, this file +//! should avoid using keys which can be set via `-C` or `-Z` options. +//! +//! [RFC 131]: https://rust-lang.github.io/rfcs/0131-target-specification.html + +use std::{ + collections::HashMap, + fmt::{Display, Formatter, Result}, + io::BufRead, +}; + +enum Value { + Boolean(bool), + Number(i32), + String(String), + Object(Object), +} + +type Object = Vec<(String, Value)>; + +/// Minimal "almost JSON" generator (e.g. no `null`s, no arrays, no escaping), +/// enough for this purpose. +impl Display for Value { + fn fmt(&self, formatter: &mut Formatter<'_>) -> Result { + match self { + Value::Boolean(boolean) => write!(formatter, "{}", boolean), + Value::Number(number) => write!(formatter, "{}", number), + Value::String(string) => write!(formatter, "\"{}\"", string), + Value::Object(object) => { + formatter.write_str("{")?; + if let [ref rest @ .., ref last] = object[..] { + for (key, value) in rest { + write!(formatter, "\"{}\": {},", key, value)?; + } + write!(formatter, "\"{}\": {}", last.0, last.1)?; + } + formatter.write_str("}") + } + } + } +} + +struct TargetSpec(Object); + +impl TargetSpec { + fn new() -> TargetSpec { + TargetSpec(Vec::new()) + } +} + +trait Push { + fn push(&mut self, key: &str, value: T); +} + +impl Push for TargetSpec { + fn push(&mut self, key: &str, value: bool) { + self.0.push((key.to_string(), Value::Boolean(value))); + } +} + +impl Push for TargetSpec { + fn push(&mut self, key: &str, value: i32) { + self.0.push((key.to_string(), Value::Number(value))); + } +} + +impl Push for TargetSpec { + fn push(&mut self, key: &str, value: String) { + self.0.push((key.to_string(), Value::String(value))); + } +} + +impl Push<&str> for TargetSpec { + fn push(&mut self, key: &str, value: &str) { + self.push(key, value.to_string()); + } +} + +impl Push for TargetSpec { + fn push(&mut self, key: &str, value: Object) { + self.0.push((key.to_string(), Value::Object(value))); + } +} + +impl Display for TargetSpec { + fn fmt(&self, formatter: &mut Formatter<'_>) -> Result { + // We add some newlines for clarity. + formatter.write_str("{\n")?; + if let [ref rest @ .., ref last] = self.0[..] { + for (key, value) in rest { + write!(formatter, " \"{}\": {},\n", key, value)?; + } + write!(formatter, " \"{}\": {}\n", last.0, last.1)?; + } + formatter.write_str("}") + } +} + +struct KernelConfig(HashMap); + +impl KernelConfig { + /// Parses `include/config/auto.conf` from `stdin`. + fn from_stdin() -> KernelConfig { + let mut result = HashMap::new(); + + let stdin = std::io::stdin(); + let mut handle = stdin.lock(); + let mut line = String::new(); + + loop { + line.clear(); + + if handle.read_line(&mut line).unwrap() == 0 { + break; + } + + if line.starts_with('#') { + continue; + } + + let (key, value) = line.split_once('=').expect("Missing `=` in line."); + result.insert(key.to_string(), value.trim_end_matches('\n').to_string()); + } + + KernelConfig(result) + } + + /// Does the option exist in the configuration (any value)? + /// + /// The argument must be passed without the `CONFIG_` prefix. + /// This avoids repetition and it also avoids `fixdep` making us + /// depend on it. + fn has(&self, option: &str) -> bool { + let option = "CONFIG_".to_owned() + option; + self.0.contains_key(&option) + } +} + +fn main() { + let cfg = KernelConfig::from_stdin(); + let mut ts = TargetSpec::new(); + + // `llvm-target`s are taken from `scripts/Makefile.clang`. + if cfg.has("ARM") { + ts.push("arch", "arm"); + ts.push( + "data-layout", + "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64", + ); + ts.push("features", "+strict-align,+v6"); + ts.push("llvm-target", "arm-linux-gnueabi"); + ts.push("max-atomic-width", 64); + ts.push("target-mcount", "\\u0001__gnu_mcount_nc"); + ts.push("target-pointer-width", "32"); + } else if cfg.has("ARM64") { + ts.push("arch", "aarch64"); + ts.push( + "data-layout", + "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128", + ); + ts.push("disable-redzone", true); + ts.push("features", "+strict-align,-neon,-fp-armv8"); + ts.push("llvm-target", "aarch64-linux-gnu"); + ts.push("max-atomic-width", 128); + ts.push("target-pointer-width", "64"); + } else if cfg.has("PPC") { + ts.push("arch", "powerpc64"); + ts.push("code-model", "large"); + ts.push("data-layout", "e-m:e-i64:64-n32:64"); + ts.push("features", "-altivec,-vsx,-hard-float"); + ts.push("llvm-target", "powerpc64le-linux-gnu"); + ts.push("max-atomic-width", 64); + ts.push("target-mcount", "_mcount"); + ts.push("target-pointer-width", "64"); + } else if cfg.has("RISCV") { + if cfg.has("64BIT") { + ts.push("arch", "riscv64"); + ts.push("data-layout", "e-m:e-p:64:64-i64:64-i128:128-n64-S128"); + ts.push("llvm-target", "riscv64-linux-gnu"); + ts.push("target-pointer-width", "64"); + } else { + ts.push("arch", "riscv32"); + ts.push("data-layout", "e-m:e-p:32:32-i64:64-n32-S128"); + ts.push("llvm-target", "riscv32-linux-gnu"); + ts.push("target-pointer-width", "32"); + } + ts.push("code-model", "medium"); + ts.push("disable-redzone", true); + let mut features = "+m,+a".to_string(); + if cfg.has("RISCV_ISA_C") { + features += ",+c"; + } + ts.push("features", features); + } else if cfg.has("X86_64") { + ts.push("arch", "x86_64"); + ts.push( + "data-layout", + "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", + ); + let mut features = "-3dnow,-3dnowa,-mmx,+soft-float".to_string(); + if cfg.has("RETPOLINE") { + features += ",+retpoline-external-thunk"; + } + ts.push("features", features); + ts.push("llvm-target", "x86_64-linux-gnu"); + ts.push("target-pointer-width", "64"); + } else { + panic!("Unsupported architecture"); + } + + ts.push("emit-debug-gdb-scripts", false); + ts.push("frame-pointer", "may-omit"); + ts.push( + "stack-probes", + vec![("kind".to_string(), Value::String("none".to_string()))], + ); + + // Everything else is LE, whether `CPU_LITTLE_ENDIAN` is declared or not + // (e.g. x86). It is also `rustc`'s default. + if cfg.has("CPU_BIG_ENDIAN") { + ts.push("target-endian", "big"); + } + + println!("{}", ts); +} diff --git a/scripts/is_rust_module.sh b/scripts/is_rust_module.sh new file mode 100755 index 000000000000..28b3831a7593 --- /dev/null +++ b/scripts/is_rust_module.sh @@ -0,0 +1,16 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0 +# +# is_rust_module.sh module.ko +# +# Returns `0` if `module.ko` is a Rust module, `1` otherwise. + +set -e + +# Using the `16_` prefix ensures other symbols with the same substring +# are not picked up (even if it would be unlikely). The last part is +# used just in case LLVM decides to use the `.` suffix. +# +# In the future, checking for the `.comment` section may be another +# option, see https://github.com/rust-lang/rust/pull/97550. +${NM} "$*" | grep -qE '^[0-9a-fA-F]+ r _R[^[:space:]]+16___IS_RUST_MODULE[^[:space:]]*$' diff --git a/scripts/kconfig/confdata.c b/scripts/kconfig/confdata.c index c4340c90e172..b7c9f1dd5e42 100644 --- a/scripts/kconfig/confdata.c +++ b/scripts/kconfig/confdata.c @@ -216,6 +216,13 @@ static const char *conf_get_autoheader_name(void) return name ? name : "include/generated/autoconf.h"; } +static const char *conf_get_rustccfg_name(void) +{ + char *name = getenv("KCONFIG_RUSTCCFG"); + + return name ? name : "include/generated/rustc_cfg"; +} + static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p) { char *p2; @@ -605,6 +612,9 @@ static const struct comment_style comment_style_c = { static void conf_write_heading(FILE *fp, const struct comment_style *cs) { + if (!cs) + return; + fprintf(fp, "%s\n", cs->prefix); fprintf(fp, "%s Automatically generated file; DO NOT EDIT.\n", @@ -745,6 +755,65 @@ static void print_symbol_for_c(FILE *fp, struct symbol *sym) free(escaped); } +static void print_symbol_for_rustccfg(FILE *fp, struct symbol *sym) +{ + const char *val; + const char *val_prefix = ""; + char *val_prefixed = NULL; + size_t val_prefixed_len; + char *escaped = NULL; + + if (sym->type == S_UNKNOWN) + return; + + val = sym_get_string_value(sym); + + switch (sym->type) { + case S_BOOLEAN: + case S_TRISTATE: + /* + * We do not care about disabled ones, i.e. no need for + * what otherwise are "comments" in other printers. + */ + if (*val == 'n') + return; + + /* + * To have similar functionality to the C macro `IS_ENABLED()` + * we provide an empty `--cfg CONFIG_X` here in both `y` + * and `m` cases. + * + * Then, the common `fprintf()` below will also give us + * a `--cfg CONFIG_X="y"` or `--cfg CONFIG_X="m"`, which can + * be used as the equivalent of `IS_BUILTIN()`/`IS_MODULE()`. + */ + fprintf(fp, "--cfg=%s%s\n", CONFIG_, sym->name); + break; + case S_HEX: + if (val[0] != '0' || (val[1] != 'x' && val[1] != 'X')) + val_prefix = "0x"; + break; + default: + break; + } + + if (strlen(val_prefix) > 0) { + val_prefixed_len = strlen(val) + strlen(val_prefix) + 1; + val_prefixed = xmalloc(val_prefixed_len); + snprintf(val_prefixed, val_prefixed_len, "%s%s", val_prefix, val); + val = val_prefixed; + } + + /* All values get escaped: the `--cfg` option only takes strings */ + escaped = escape_string_value(val); + val = escaped; + + fprintf(fp, "--cfg=%s%s=%s\n", CONFIG_, sym->name, val); + + free(escaped); + free(val_prefixed); +} + /* * Write out a minimal config. * All values that has default values are skipped as this is redundant. @@ -1132,6 +1201,12 @@ int conf_write_autoconf(int overwrite) if (ret) return ret; + ret = __conf_write_autoconf(conf_get_rustccfg_name(), + print_symbol_for_rustccfg, + NULL); + if (ret) + return ret; + /* * Create include/config/auto.conf. This must be the last step because * Kbuild has a dependency on auto.conf and this marks the successful diff --git a/scripts/min-tool-version.sh b/scripts/min-tool-version.sh index 250925aab101..b6593eac5003 100755 --- a/scripts/min-tool-version.sh +++ b/scripts/min-tool-version.sh @@ -30,6 +30,12 @@ llvm) echo 11.0.0 fi ;; +rustc) + echo 1.62.0 + ;; +bindgen) + echo 0.56.0 + ;; *) echo "$1: unknown tool" >&2 exit 1 diff --git a/scripts/rust-is-available-bindgen-libclang.h b/scripts/rust-is-available-bindgen-libclang.h new file mode 100644 index 000000000000..0ef6db10d674 --- /dev/null +++ b/scripts/rust-is-available-bindgen-libclang.h @@ -0,0 +1,2 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#pragma message("clang version " __clang_version__) diff --git a/scripts/rust-is-available.sh b/scripts/rust-is-available.sh new file mode 100755 index 000000000000..0ddad3fcd32c --- /dev/null +++ b/scripts/rust-is-available.sh @@ -0,0 +1,160 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0 +# +# Tests whether a suitable Rust toolchain is available. +# +# Pass `-v` for human output and more checks (as warnings). + +set -e + +min_tool_version=$(dirname $0)/min-tool-version.sh + +# Convert the version string x.y.z to a canonical up-to-7-digits form. +# +# Note that this function uses one more digit (compared to other +# instances in other version scripts) to give a bit more space to +# `rustc` since it will reach 1.100.0 in late 2026. +get_canonical_version() +{ + IFS=. + set -- $1 + echo $((100000 * $1 + 100 * $2 + $3)) +} + +# Check that the Rust compiler exists. +if ! command -v "$RUSTC" >/dev/null; then + if [ "$1" = -v ]; then + echo >&2 "***" + echo >&2 "*** Rust compiler '$RUSTC' could not be found." + echo >&2 "***" + fi + exit 1 +fi + +# Check that the Rust bindings generator exists. +if ! command -v "$BINDGEN" >/dev/null; then + if [ "$1" = -v ]; then + echo >&2 "***" + echo >&2 "*** Rust bindings generator '$BINDGEN' could not be found." + echo >&2 "***" + fi + exit 1 +fi + +# Check that the Rust compiler version is suitable. +# +# Non-stable and distributions' versions may have a version suffix, e.g. `-dev`. +rust_compiler_version=$( \ + LC_ALL=C "$RUSTC" --version 2>/dev/null \ + | head -n 1 \ + | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' \ +) +rust_compiler_min_version=$($min_tool_version rustc) +rust_compiler_cversion=$(get_canonical_version $rust_compiler_version) +rust_compiler_min_cversion=$(get_canonical_version $rust_compiler_min_version) +if [ "$rust_compiler_cversion" -lt "$rust_compiler_min_cversion" ]; then + if [ "$1" = -v ]; then + echo >&2 "***" + echo >&2 "*** Rust compiler '$RUSTC' is too old." + echo >&2 "*** Your version: $rust_compiler_version" + echo >&2 "*** Minimum version: $rust_compiler_min_version" + echo >&2 "***" + fi + exit 1 +fi +if [ "$1" = -v ] && [ "$rust_compiler_cversion" -gt "$rust_compiler_min_cversion" ]; then + echo >&2 "***" + echo >&2 "*** Rust compiler '$RUSTC' is too new. This may or may not work." + echo >&2 "*** Your version: $rust_compiler_version" + echo >&2 "*** Expected version: $rust_compiler_min_version" + echo >&2 "***" +fi + +# Check that the Rust bindings generator is suitable. +# +# Non-stable and distributions' versions may have a version suffix, e.g. `-dev`. +rust_bindings_generator_version=$( \ + LC_ALL=C "$BINDGEN" --version 2>/dev/null \ + | head -n 1 \ + | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' \ +) +rust_bindings_generator_min_version=$($min_tool_version bindgen) +rust_bindings_generator_cversion=$(get_canonical_version $rust_bindings_generator_version) +rust_bindings_generator_min_cversion=$(get_canonical_version $rust_bindings_generator_min_version) +if [ "$rust_bindings_generator_cversion" -lt "$rust_bindings_generator_min_cversion" ]; then + if [ "$1" = -v ]; then + echo >&2 "***" + echo >&2 "*** Rust bindings generator '$BINDGEN' is too old." + echo >&2 "*** Your version: $rust_bindings_generator_version" + echo >&2 "*** Minimum version: $rust_bindings_generator_min_version" + echo >&2 "***" + fi + exit 1 +fi +if [ "$1" = -v ] && [ "$rust_bindings_generator_cversion" -gt "$rust_bindings_generator_min_cversion" ]; then + echo >&2 "***" + echo >&2 "*** Rust bindings generator '$BINDGEN' is too new. This may or may not work." + echo >&2 "*** Your version: $rust_bindings_generator_version" + echo >&2 "*** Expected version: $rust_bindings_generator_min_version" + echo >&2 "***" +fi + +# Check that the `libclang` used by the Rust bindings generator is suitable. +bindgen_libclang_version=$( \ + LC_ALL=C "$BINDGEN" $(dirname $0)/rust-is-available-bindgen-libclang.h 2>&1 >/dev/null \ + | grep -F 'clang version ' \ + | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' \ + | head -n 1 \ +) +bindgen_libclang_min_version=$($min_tool_version llvm) +bindgen_libclang_cversion=$(get_canonical_version $bindgen_libclang_version) +bindgen_libclang_min_cversion=$(get_canonical_version $bindgen_libclang_min_version) +if [ "$bindgen_libclang_cversion" -lt "$bindgen_libclang_min_cversion" ]; then + if [ "$1" = -v ]; then + echo >&2 "***" + echo >&2 "*** libclang (used by the Rust bindings generator '$BINDGEN') is too old." + echo >&2 "*** Your version: $bindgen_libclang_version" + echo >&2 "*** Minimum version: $bindgen_libclang_min_version" + echo >&2 "***" + fi + exit 1 +fi + +# If the C compiler is Clang, then we can also check whether its version +# matches the `libclang` version used by the Rust bindings generator. +# +# In the future, we might be able to perform a full version check, see +# https://github.com/rust-lang/rust-bindgen/issues/2138. +if [ "$1" = -v ]; then + cc_name=$($(dirname $0)/cc-version.sh "$CC" | cut -f1 -d' ') + if [ "$cc_name" = Clang ]; then + clang_version=$( \ + LC_ALL=C "$CC" --version 2>/dev/null \ + | sed -nE '1s:.*version ([0-9]+\.[0-9]+\.[0-9]+).*:\1:p' + ) + if [ "$clang_version" != "$bindgen_libclang_version" ]; then + echo >&2 "***" + echo >&2 "*** libclang (used by the Rust bindings generator '$BINDGEN')" + echo >&2 "*** version does not match Clang's. This may be a problem." + echo >&2 "*** libclang version: $bindgen_libclang_version" + echo >&2 "*** Clang version: $clang_version" + echo >&2 "***" + fi + fi +fi + +# Check that the source code for the `core` standard library exists. +# +# `$KRUSTFLAGS` is passed in case the user added `--sysroot`. +rustc_sysroot=$("$RUSTC" $KRUSTFLAGS --print sysroot) +rustc_src=${RUST_LIB_SRC:-"$rustc_sysroot/lib/rustlib/src/rust/library"} +rustc_src_core="$rustc_src/core/src/lib.rs" +if [ ! -e "$rustc_src_core" ]; then + if [ "$1" = -v ]; then + echo >&2 "***" + echo >&2 "*** Source code for the 'core' standard library could not be found" + echo >&2 "*** at '$rustc_src_core'." + echo >&2 "***" + fi + exit 1 +fi -- 2.37.1 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 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 smtp.lore.kernel.org (Postfix) with ESMTPS id 8938CC19F2A for ; Tue, 2 Aug 2022 01:54:19 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=3FhVke/c6vgcc34jzyKxlJG5sL7QhnHMmf7XR2XvAFc=; b=FG+X/uElziYRpX Iaw3ZYzM+VyJqfJsOOY5KVs13eDGMOPSOxls4SpdHcqOe71rJVyQXa9vGZj8p5bhBR4wDuV6HGfxI 1puHMPcLK8HYFh/w4/LV2CEEXGsacVy2kKVjM3HD6q02dO32VhyIXDKVaHYtUSQvEh6iWe3TB3bHA kus/zzEIfsuK7u7eoiSgoo3GFmAReoTFs5wM/GhfMt42mGcENsg4jkguDLvUtXOXVxgXmOBvlUmyo 45ftaZ+W0/WaeJa4ZJIjEeNqEarG0orpsHtlFUWNms+KWLSVVr2HmMEikX6lEgUOeCCEGV4I8wMzd kKJ+rhy0mWOa/URLwqSQ==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1oIh6k-009ndJ-Ed; Tue, 02 Aug 2022 01:54:06 +0000 Received: from dfw.source.kernel.org ([2604:1380:4641:c500::1]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1oIh6V-009nJ6-8t; Tue, 02 Aug 2022 01:53:56 +0000 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 8CB8561072; Tue, 2 Aug 2022 01:53:50 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6C662C433D6; Tue, 2 Aug 2022 01:53:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1659405229; bh=GORFM1idi3kTQnV6VihqUFIxcib5JgKkOuMTQPkEH70=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Vq+z0xXjfjbWIMydJCs9sw6LD8Q6gLO3b+HF9QB2QiC3PgjJGIQM0EGENZHVGeErl AI0+mjRgSgjYRc+Qs4M3sydA826IfENNy2Q6kyRFksJAurGqsN0DRmxguxdgWbxU1p CUHNqk6fCc4HFyE2SdqhnfGMGCcKEG7kCv+OHqqhfj6e/y7zipuiHkcdwPqo6RUaAj WzRuXbzUMJO2P3IjmKQtNQaiUnhfvOQyZGnjD7GYcsyBuWoZY9hs1v3UsW7qz96bqs G7qHrOuaCUQMvoiYKiC+Pfy8tmOkc7O0DqjkaUCklJf3KkO2eY/Jjx92O46wrWyeKI BakcCxFD8Yyjg== From: Miguel Ojeda To: Linus Torvalds , Greg Kroah-Hartman Cc: rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, Jarkko Sakkinen , Miguel Ojeda , Alex Gaynor , Finn Behrens , Adam Bratschi-Kaye , Wedson Almeida Filho , Michael Ellerman , Sven Van Asbroeck , Gary Guo , Boris-Chengbiao Zhou , Boqun Feng , Douglas Su , Dariusz Sosnowski , Antonio Terceiro , Daniel Xu , Miguel Cano , David Gow , Tiago Lam , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Martin Rodriguez Reboredo , Masahiro Yamada , Michal Marek , Nick Desaulniers , Russell King , Catalin Marinas , Will Deacon , Benjamin Herrenschmidt , Paul Mackerras , Paul Walmsley , Palmer Dabbelt , Albert Ou , Richard Weinberger , Anton Ivanov , Johannes Berg , Thomas Gleixner , Ingo Molnar , Borislav Petkov , Dave Hansen , x86@kernel.org, "H. Peter Anvin" , linux-kbuild@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linuxppc-dev@lists.ozlabs.org, linux-riscv@lists.infradead.org, linux-um@lists.infradead.org Subject: [PATCH v8 27/31] Kbuild: add Rust support Date: Tue, 2 Aug 2022 03:50:14 +0200 Message-Id: <20220802015052.10452-28-ojeda@kernel.org> In-Reply-To: <20220802015052.10452-1-ojeda@kernel.org> References: <20220802015052.10452-1-ojeda@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220801_185351_567550_4B412C5B X-CRM114-Status: GOOD ( 25.67 ) X-BeenThere: linux-riscv@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-riscv" Errors-To: linux-riscv-bounces+linux-riscv=archiver.kernel.org@lists.infradead.org SGF2aW5nIGFsbCB0aGUgbmV3IGZpbGVzIGluIHBsYWNlLCB3ZSBub3cgZW5hYmxlIFJ1c3Qgc3Vw cG9ydAppbiB0aGUgYnVpbGQgc3lzdGVtLCBpbmNsdWRpbmcgYEtjb25maWdgIGVudHJpZXMgcmVs YXRlZCB0byBSdXN0LAp0aGUgUnVzdCBjb25maWd1cmF0aW9uIHByaW50ZXIsIHRoZSB0YXJnZXQg c3BlY2lmaWNhdGlvbgpnZW5lcmF0aW9uIHNjcmlwdCwgdGhlIHZlcnNpb24gZGV0ZWN0aW9uIHNj cmlwdCBhbmQgYSBmZXcKb3RoZXIgYml0cy4KCkNvLWRldmVsb3BlZC1ieTogQWxleCBHYXlub3Ig PGFsZXguZ2F5bm9yQGdtYWlsLmNvbT4KU2lnbmVkLW9mZi1ieTogQWxleCBHYXlub3IgPGFsZXgu Z2F5bm9yQGdtYWlsLmNvbT4KQ28tZGV2ZWxvcGVkLWJ5OiBGaW5uIEJlaHJlbnMgPG1lQGtsb2Vu ay5kZT4KU2lnbmVkLW9mZi1ieTogRmlubiBCZWhyZW5zIDxtZUBrbG9lbmsuZGU+CkNvLWRldmVs b3BlZC1ieTogQWRhbSBCcmF0c2NoaS1LYXllIDxhcmsuZW1haWxAZ21haWwuY29tPgpTaWduZWQt b2ZmLWJ5OiBBZGFtIEJyYXRzY2hpLUtheWUgPGFyay5lbWFpbEBnbWFpbC5jb20+CkNvLWRldmVs b3BlZC1ieTogV2Vkc29uIEFsbWVpZGEgRmlsaG8gPHdlZHNvbmFmQGdvb2dsZS5jb20+ClNpZ25l ZC1vZmYtYnk6IFdlZHNvbiBBbG1laWRhIEZpbGhvIDx3ZWRzb25hZkBnb29nbGUuY29tPgpDby1k ZXZlbG9wZWQtYnk6IE1pY2hhZWwgRWxsZXJtYW4gPG1wZUBlbGxlcm1hbi5pZC5hdT4KU2lnbmVk LW9mZi1ieTogTWljaGFlbCBFbGxlcm1hbiA8bXBlQGVsbGVybWFuLmlkLmF1PgpDby1kZXZlbG9w ZWQtYnk6IFN2ZW4gVmFuIEFzYnJvZWNrIDx0aGVzdmVuNzNAZ21haWwuY29tPgpTaWduZWQtb2Zm LWJ5OiBTdmVuIFZhbiBBc2Jyb2VjayA8dGhlc3ZlbjczQGdtYWlsLmNvbT4KQ28tZGV2ZWxvcGVk LWJ5OiBHYXJ5IEd1byA8Z2FyeUBnYXJ5Z3VvLm5ldD4KU2lnbmVkLW9mZi1ieTogR2FyeSBHdW8g PGdhcnlAZ2FyeWd1by5uZXQ+CkNvLWRldmVsb3BlZC1ieTogQm9yaXMtQ2hlbmdiaWFvIFpob3Ug PGJvYm8xMjM5QHdlYi5kZT4KU2lnbmVkLW9mZi1ieTogQm9yaXMtQ2hlbmdiaWFvIFpob3UgPGJv Ym8xMjM5QHdlYi5kZT4KQ28tZGV2ZWxvcGVkLWJ5OiBCb3F1biBGZW5nIDxib3F1bi5mZW5nQGdt YWlsLmNvbT4KU2lnbmVkLW9mZi1ieTogQm9xdW4gRmVuZyA8Ym9xdW4uZmVuZ0BnbWFpbC5jb20+ CkNvLWRldmVsb3BlZC1ieTogRG91Z2xhcyBTdSA8ZDB1OS5zdUBvdXRsb29rLmNvbT4KU2lnbmVk LW9mZi1ieTogRG91Z2xhcyBTdSA8ZDB1OS5zdUBvdXRsb29rLmNvbT4KQ28tZGV2ZWxvcGVkLWJ5 OiBEYXJpdXN6IFNvc25vd3NraSA8ZHNvc25vd3NraUBkc29zbm93c2tpLnBsPgpTaWduZWQtb2Zm LWJ5OiBEYXJpdXN6IFNvc25vd3NraSA8ZHNvc25vd3NraUBkc29zbm93c2tpLnBsPgpDby1kZXZl bG9wZWQtYnk6IEFudG9uaW8gVGVyY2Vpcm8gPGFudG9uaW8udGVyY2Vpcm9AbGluYXJvLm9yZz4K U2lnbmVkLW9mZi1ieTogQW50b25pbyBUZXJjZWlybyA8YW50b25pby50ZXJjZWlyb0BsaW5hcm8u b3JnPgpDby1kZXZlbG9wZWQtYnk6IERhbmllbCBYdSA8ZHh1QGR4dXV1Lnh5ej4KU2lnbmVkLW9m Zi1ieTogRGFuaWVsIFh1IDxkeHVAZHh1dXUueHl6PgpDby1kZXZlbG9wZWQtYnk6IE1pZ3VlbCBD YW5vIDxtYWNhbnJvakBnbWFpbC5jb20+ClNpZ25lZC1vZmYtYnk6IE1pZ3VlbCBDYW5vIDxtYWNh bnJvakBnbWFpbC5jb20+CkNvLWRldmVsb3BlZC1ieTogRGF2aWQgR293IDxkYXZpZGdvd0Bnb29n bGUuY29tPgpTaWduZWQtb2ZmLWJ5OiBEYXZpZCBHb3cgPGRhdmlkZ293QGdvb2dsZS5jb20+CkNv LWRldmVsb3BlZC1ieTogVGlhZ28gTGFtIDx0aWFnb2xhbUBnbWFpbC5jb20+ClNpZ25lZC1vZmYt Ynk6IFRpYWdvIExhbSA8dGlhZ29sYW1AZ21haWwuY29tPgpDby1kZXZlbG9wZWQtYnk6IEJqw7Zy biBSb3kgQmFyb24gPGJqb3JuM19naEBwcm90b25tYWlsLmNvbT4KU2lnbmVkLW9mZi1ieTogQmrD tnJuIFJveSBCYXJvbiA8Ympvcm4zX2doQHByb3Rvbm1haWwuY29tPgpDby1kZXZlbG9wZWQtYnk6 IE1hcnRpbiBSb2RyaWd1ZXogUmVib3JlZG8gPHlha295b2t1QGdtYWlsLmNvbT4KU2lnbmVkLW9m Zi1ieTogTWFydGluIFJvZHJpZ3VleiBSZWJvcmVkbyA8eWFrb3lva3VAZ21haWwuY29tPgpTaWdu ZWQtb2ZmLWJ5OiBNaWd1ZWwgT2plZGEgPG9qZWRhQGtlcm5lbC5vcmc+Ci0tLQogLmdpdGlnbm9y ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDYgKwogLnJ1c3RmbXQudG9t bCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMTIgKwogTWFrZWZpbGUgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAxNzIgKysrKysrKy0KIGFyY2gvS2NvbmZp ZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICA2ICsKIGFyY2gvYXJtL0tjb25m aWcgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvYXJtNjQvS2NvbmZp ZyAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvcG93ZXJwYy9LY29uZmln ICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvcmlzY3YvS2NvbmZpZyAgICAg ICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvcmlzY3YvTWFrZWZpbGUgICAgICAg ICAgICAgICAgICAgICAgICAgIHwgICA1ICsKIGFyY2gvdW0vS2NvbmZpZyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gveDg2L0tjb25maWcgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHwgICAxICsKIGFyY2gveDg2L01ha2VmaWxlICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgIDEwICsKIGluY2x1ZGUvbGludXgvY29tcGlsZXJfdHlwZXMuaCAgICAgICAg ICAgICAgIHwgICA2ICstCiBpbml0L0tjb25maWcgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICB8ICA0NiArLQogbGliL0tjb25maWcuZGVidWcgICAgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgODIgKysrKwogcnVzdC8uZ2l0aWdub3JlICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgMTAgKwogcnVzdC9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg fCA0MTUgKysrKysrKysrKysrKysrKysrKwogcnVzdC9iaW5kZ2VuX3BhcmFtZXRlcnMgICAgICAg ICAgICAgICAgICAgICAgfCAgMjEgKwogc2NyaXB0cy8uZ2l0aWdub3JlICAgICAgICAgICAgICAg ICAgICAgICAgICAgfCAgIDEgKwogc2NyaXB0cy9LY29uZmlnLmluY2x1ZGUgICAgICAgICAgICAg ICAgICAgICAgfCAgIDYgKy0KIHNjcmlwdHMvTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHwgICAzICsKIHNjcmlwdHMvTWFrZWZpbGUuYnVpbGQgICAgICAgICAgICAgICAgICAg ICAgIHwgIDYwICsrKwogc2NyaXB0cy9NYWtlZmlsZS5kZWJ1ZyAgICAgICAgICAgICAgICAgICAg ICAgfCAgMTAgKwogc2NyaXB0cy9NYWtlZmlsZS5ob3N0ICAgICAgICAgICAgICAgICAgICAgICAg fCAgMzQgKy0KIHNjcmlwdHMvTWFrZWZpbGUubGliICAgICAgICAgICAgICAgICAgICAgICAgIHwg IDEyICsKIHNjcmlwdHMvTWFrZWZpbGUubW9kZmluYWwgICAgICAgICAgICAgICAgICAgIHwgICA4 ICstCiBzY3JpcHRzL2NjLXZlcnNpb24uc2ggICAgICAgICAgICAgICAgICAgICAgICB8ICAxMiAr LQogc2NyaXB0cy9nZW5lcmF0ZV9ydXN0X3RhcmdldC5ycyAgICAgICAgICAgICAgfCAyMzIgKysr KysrKysrKysKIHNjcmlwdHMvaXNfcnVzdF9tb2R1bGUuc2ggICAgICAgICAgICAgICAgICAgIHwg IDE2ICsKIHNjcmlwdHMva2NvbmZpZy9jb25mZGF0YS5jICAgICAgICAgICAgICAgICAgIHwgIDc1 ICsrKysKIHNjcmlwdHMvbWluLXRvb2wtdmVyc2lvbi5zaCAgICAgICAgICAgICAgICAgIHwgICA2 ICsKIHNjcmlwdHMvcnVzdC1pcy1hdmFpbGFibGUtYmluZGdlbi1saWJjbGFuZy5oIHwgICAyICsK IHNjcmlwdHMvcnVzdC1pcy1hdmFpbGFibGUuc2ggICAgICAgICAgICAgICAgIHwgMTYwICsrKysr KysKIDMzIGZpbGVzIGNoYW5nZWQsIDE0MDggaW5zZXJ0aW9ucygrKSwgMjYgZGVsZXRpb25zKC0p CiBjcmVhdGUgbW9kZSAxMDA2NDQgLnJ1c3RmbXQudG9tbAogY3JlYXRlIG1vZGUgMTAwNjQ0IHJ1 c3QvLmdpdGlnbm9yZQogY3JlYXRlIG1vZGUgMTAwNjQ0IHJ1c3QvTWFrZWZpbGUKIGNyZWF0ZSBt b2RlIDEwMDY0NCBydXN0L2JpbmRnZW5fcGFyYW1ldGVycwogY3JlYXRlIG1vZGUgMTAwNjQ0IHNj cmlwdHMvZ2VuZXJhdGVfcnVzdF90YXJnZXQucnMKIGNyZWF0ZSBtb2RlIDEwMDc1NSBzY3JpcHRz L2lzX3J1c3RfbW9kdWxlLnNoCiBjcmVhdGUgbW9kZSAxMDA2NDQgc2NyaXB0cy9ydXN0LWlzLWF2 YWlsYWJsZS1iaW5kZ2VuLWxpYmNsYW5nLmgKIGNyZWF0ZSBtb2RlIDEwMDc1NSBzY3JpcHRzL3J1 c3QtaXMtYXZhaWxhYmxlLnNoCgpkaWZmIC0tZ2l0IGEvLmdpdGlnbm9yZSBiLy5naXRpZ25vcmUK aW5kZXggMjY1OTU5NTQ0OTc4Li41ZGEwMDQ4MTQ2NzggMTAwNjQ0Ci0tLSBhLy5naXRpZ25vcmUK KysrIGIvLmdpdGlnbm9yZQpAQCAtMzcsNiArMzcsOCBAQAogKi5vCiAqLm8uKgogKi5wYXRjaAor Ki5ybWV0YQorKi5yc2kKICoucwogKi5zbwogKi5zby5kYmcKQEAgLTk3LDYgKzk5LDcgQEAgbW9k dWxlcy5vcmRlcgogIS5naXRhdHRyaWJ1dGVzCiAhLmdpdGlnbm9yZQogIS5tYWlsbWFwCishLnJ1 c3RmbXQudG9tbAogCiAjCiAjIEdlbmVyYXRlZCBpbmNsdWRlIGZpbGVzCkBAIC0xNjIsMyArMTY1 LDYgQEAgeDUwOS5nZW5rZXkKIAogIyBEb2N1bWVudGF0aW9uIHRvb2xjaGFpbgogc3BoaW54Xyov CisKKyMgUnVzdCBhbmFseXplciBjb25maWd1cmF0aW9uCisvcnVzdC1wcm9qZWN0Lmpzb24KZGlm ZiAtLWdpdCBhLy5ydXN0Zm10LnRvbWwgYi8ucnVzdGZtdC50b21sCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uM2RlNWNjNDk3NDY1Ci0tLSAvZGV2L251bGwKKysrIGIv LnJ1c3RmbXQudG9tbApAQCAtMCwwICsxLDEyIEBACitlZGl0aW9uID0gIjIwMjEiCituZXdsaW5l X3N0eWxlID0gIlVuaXgiCisKKyMgVW5zdGFibGUgb3B0aW9ucyB0aGF0IGhlbHAgY2F0Y2hpbmcg c29tZSBtaXN0YWtlcyBpbiBmb3JtYXR0aW5nIGFuZCB0aGF0IHdlIG1heSB3YW50IHRvIGVuYWJs ZQorIyB3aGVuIHRoZXkgYmVjb21lIHN0YWJsZS4KKyMKKyMgVGhleSBhcmUga2VwdCBoZXJlIHNp bmNlIHRoZXkgYXJlIHVzZWZ1bCB0byBydW4gZnJvbSB0aW1lIHRvIHRpbWUuCisjZm9ybWF0X2Nv ZGVfaW5fZG9jX2NvbW1lbnRzID0gdHJ1ZQorI3Jlb3JkZXJfaW1wbF9pdGVtcyA9IHRydWUKKyNj b21tZW50X3dpZHRoID0gMTAwCisjd3JhcF9jb21tZW50cyA9IHRydWUKKyNub3JtYWxpemVfY29t bWVudHMgPSB0cnVlCmRpZmYgLS1naXQgYS9NYWtlZmlsZSBiL01ha2VmaWxlCmluZGV4IGRmOTI4 OTIzMjVhZS4uY2QxZDU0NWYzMTZiIDEwMDY0NAotLS0gYS9NYWtlZmlsZQorKysgYi9NYWtlZmls ZQpAQCAtMTIwLDYgKzEyMCwxNSBAQCBlbmRpZgogCiBleHBvcnQgS0JVSUxEX0NIRUNLU1JDCiAK KyMgRW5hYmxlICJjbGlwcHkiIChhIGxpbnRlcikgYXMgcGFydCBvZiB0aGUgUnVzdCBjb21waWxh dGlvbi4KKyMKKyMgVXNlICdtYWtlIENMSVBQWT0xJyB0byBlbmFibGUgaXQuCitpZmVxICgiJChv cmlnaW4gQ0xJUFBZKSIsICJjb21tYW5kIGxpbmUiKQorICBLQlVJTERfQ0xJUFBZIDo9ICQoQ0xJ UFBZKQorZW5kaWYKKworZXhwb3J0IEtCVUlMRF9DTElQUFkKKwogIyBVc2UgbWFrZSBNPWRpciBv ciBzZXQgdGhlIGVudmlyb25tZW50IHZhcmlhYmxlIEtCVUlMRF9FWFRNT0QgdG8gc3BlY2lmeSB0 aGUKICMgZGlyZWN0b3J5IG9mIGV4dGVybmFsIG1vZHVsZSB0byBidWlsZC4gU2V0dGluZyBNPSB0 YWtlcyBwcmVjZWRlbmNlLgogaWZlcSAoIiQob3JpZ2luIE0pIiwgImNvbW1hbmQgbGluZSIpCkBA IC0yNjcsMTQgKzI3NiwxNCBAQCBuby1kb3QtY29uZmlnLXRhcmdldHMgOj0gJChjbGVhbi10YXJn ZXRzKSBcCiAJCQkgY3Njb3BlIGd0YWdzIFRBR1MgdGFncyBoZWxwJSAlZG9jcyBjaGVjayUgY29j Y2ljaGVjayBcCiAJCQkgJCh2ZXJzaW9uX2gpIGhlYWRlcnMgaGVhZGVyc18lIGFyY2hoZWFkZXJz IGFyY2hzY3JpcHRzIFwKIAkJCSAlYXNtLWdlbmVyaWMga2VybmVsdmVyc2lvbiAlc3JjLXBrZyBk dF9iaW5kaW5nX2NoZWNrIFwKLQkJCSBvdXRwdXRtYWtlZmlsZQorCQkJIG91dHB1dG1ha2VmaWxl IHJ1c3RhdmFpbGFibGUgcnVzdGZtdCBydXN0Zm10Y2hlY2sKICMgSW5zdGFsbGF0aW9uIHRhcmdl dHMgc2hvdWxkIG5vdCByZXF1aXJlIGNvbXBpbGVyLiBVbmZvcnR1bmF0ZWx5LCB2ZHNvX2luc3Rh bGwKICMgaXMgYW4gZXhjZXB0aW9uIHdoZXJlIGJ1aWxkIGFydGlmYWN0cyBtYXkgYmUgdXBkYXRl ZC4gVGhpcyBtdXN0IGJlIGZpeGVkLgogbm8tY29tcGlsZXItdGFyZ2V0cyA6PSAkKG5vLWRvdC1j b25maWctdGFyZ2V0cykgaW5zdGFsbCBkdGJzX2luc3RhbGwgXAogCQkJaGVhZGVyc19pbnN0YWxs IG1vZHVsZXNfaW5zdGFsbCBrZXJuZWxyZWxlYXNlIGltYWdlX25hbWUKIG5vLXN5bmMtY29uZmln LXRhcmdldHMgOj0gJChuby1kb3QtY29uZmlnLXRhcmdldHMpICVpbnN0YWxsIGtlcm5lbHJlbGVh c2UgXAogCQkJICBpbWFnZV9uYW1lCi1zaW5nbGUtdGFyZ2V0cyA6PSAlLmEgJS5pICUua28gJS5s ZHMgJS5sbCAlLmxzdCAlLm1vZCAlLm8gJS5zICUuc3ltdHlwZXMgJS8KK3NpbmdsZS10YXJnZXRz IDo9ICUuYSAlLmkgJS5yc2kgJS5rbyAlLmxkcyAlLmxsICUubHN0ICUubW9kICUubyAlLnMgJS5z eW10eXBlcyAlLwogCiBjb25maWctYnVpbGQJOj0KIG1peGVkLWJ1aWxkCTo9CkBAIC00MzYsNiAr NDQ1LDcgQEAgZWxzZQogSE9TVENDCT0gZ2NjCiBIT1NUQ1hYCT0gZysrCiBlbmRpZgorSE9TVFJV U1RDID0gcnVzdGMKIEhPU1RQS0dfQ09ORklHCT0gcGtnLWNvbmZpZwogCiBLQlVJTERfVVNFUkhP U1RDRkxBR1MgOj0gLVdhbGwgLVdtaXNzaW5nLXByb3RvdHlwZXMgLVdzdHJpY3QtcHJvdG90eXBl cyBcCkBAIC00NDQsOCArNDU0LDI2IEBAIEtCVUlMRF9VU0VSSE9TVENGTEFHUyA6PSAtV2FsbCAt V21pc3NpbmctcHJvdG90eXBlcyAtV3N0cmljdC1wcm90b3R5cGVzIFwKIEtCVUlMRF9VU0VSQ0ZM QUdTICA6PSAkKEtCVUlMRF9VU0VSSE9TVENGTEFHUykgJChVU0VSQ0ZMQUdTKQogS0JVSUxEX1VT RVJMREZMQUdTIDo9ICQoVVNFUkxERkxBR1MpCiAKKyMgVGhlc2UgZmxhZ3MgYXBwbHkgdG8gYWxs IFJ1c3QgY29kZSBpbiB0aGUgdHJlZSwgaW5jbHVkaW5nIHRoZSBrZXJuZWwgYW5kCisjIGhvc3Qg cHJvZ3JhbXMuCitleHBvcnQgcnVzdF9jb21tb25fZmxhZ3MgOj0gLS1lZGl0aW9uPTIwMjEgXAor CQkJICAgIC1aYmluYXJ5X2RlcF9kZXBpbmZvPXkgXAorCQkJICAgIC1EdW5zYWZlX29wX2luX3Vu c2FmZV9mbiAtRHJ1c3RfMjAxOF9pZGlvbXMgXAorCQkJICAgIC1EdW5yZWFjaGFibGVfcHViIC1E bm9uX2FzY2lpX2lkZW50cyBcCisJCQkgICAgLVdtaXNzaW5nX2RvY3MgXAorCQkJICAgIC1EcnVz dGRvYzo6bWlzc2luZ19jcmF0ZV9sZXZlbF9kb2NzIFwKKwkJCSAgICAtRGNsaXBweTo6Y29ycmVj dG5lc3MgLURjbGlwcHk6OnN0eWxlIFwKKwkJCSAgICAtRGNsaXBweTo6c3VzcGljaW91cyAtRGNs aXBweTo6Y29tcGxleGl0eSBcCisJCQkgICAgLURjbGlwcHk6OnBlcmYgXAorCQkJICAgIC1EY2xp cHB5OjpsZXRfdW5pdF92YWx1ZSAtRGNsaXBweTo6bXV0X211dCBcCisJCQkgICAgLURjbGlwcHk6 Om5lZWRsZXNzX2JpdHdpc2VfYm9vbCBcCisJCQkgICAgLURjbGlwcHk6Om5lZWRsZXNzX2NvbnRp bnVlIFwKKwkJCSAgICAtV2NsaXBweTo6ZGJnX21hY3JvCisKIEtCVUlMRF9IT1NUQ0ZMQUdTICAg Oj0gJChLQlVJTERfVVNFUkhPU1RDRkxBR1MpICQoSE9TVF9MRlNfQ0ZMQUdTKSAkKEhPU1RDRkxB R1MpCiBLQlVJTERfSE9TVENYWEZMQUdTIDo9IC1XYWxsIC1PMiAkKEhPU1RfTEZTX0NGTEFHUykg JChIT1NUQ1hYRkxBR1MpCitLQlVJTERfSE9TVFJVU1RGTEFHUyA6PSAkKHJ1c3RfY29tbW9uX2Zs YWdzKSAtTyAtQ3N0cmlwPWRlYnVnaW5mbyBcCisJCQktWmFsbG93LWZlYXR1cmVzPSAkKEhPU1RS VVNURkxBR1MpCiBLQlVJTERfSE9TVExERkxBR1MgIDo9ICQoSE9TVF9MRlNfTERGTEFHUykgJChI T1NUTERGTEFHUykKIEtCVUlMRF9IT1NUTERMSUJTICAgOj0gJChIT1NUX0xGU19MSUJTKSAkKEhP U1RMRExJQlMpCiAKQEAgLTQ3MCw2ICs0OTgsMTIgQEAgT0JKRFVNUAkJPSAkKENST1NTX0NPTVBJ TEUpb2JqZHVtcAogUkVBREVMRgkJPSAkKENST1NTX0NPTVBJTEUpcmVhZGVsZgogU1RSSVAJCT0g JChDUk9TU19DT01QSUxFKXN0cmlwCiBlbmRpZgorUlVTVEMJCT0gcnVzdGMKK1JVU1RET0MJCT0g cnVzdGRvYworUlVTVEZNVAkJPSBydXN0Zm10CitDTElQUFlfRFJJVkVSCT0gY2xpcHB5LWRyaXZl cgorQklOREdFTgkJPSBiaW5kZ2VuCitDQVJHTwkJPSBjYXJnbwogUEFIT0xFCQk9IHBhaG9sZQog UkVTT0xWRV9CVEZJRFMJPSAkKG9ianRyZWUpL3Rvb2xzL2JwZi9yZXNvbHZlX2J0Zmlkcy9yZXNv bHZlX2J0ZmlkcwogTEVYCQk9IGZsZXgKQEAgLTQ5NSw5ICs1MjksMTEgQEAgQ0hFQ0tGTEFHUyAg ICAgOj0gLURfX2xpbnV4X18gLURsaW51eCAtRF9fU1REQ19fIC1EdW5peCAtRF9fdW5peF9fIFwK IAkJICAtV2JpdHdpc2UgLVduby1yZXR1cm4tdm9pZCAtV25vLXVua25vd24tYXR0cmlidXRlICQo Q0YpCiBOT1NURElOQ19GTEFHUyA6PQogQ0ZMQUdTX01PRFVMRSAgID0KK1JVU1RGTEFHU19NT0RV TEUgPQogQUZMQUdTX01PRFVMRSAgID0KIExERkxBR1NfTU9EVUxFICA9CiBDRkxBR1NfS0VSTkVM CT0KK1JVU1RGTEFHU19LRVJORUwgPQogQUZMQUdTX0tFUk5FTAk9CiBMREZMQUdTX3ZtbGludXgg PQogCkBAIC01MjYsMTUgKzU2Miw0MiBAQCBLQlVJTERfQ0ZMQUdTICAgOj0gLVdhbGwgLVd1bmRl ZiAtV2Vycm9yPXN0cmljdC1wcm90b3R5cGVzIC1Xbm8tdHJpZ3JhcGhzIFwKIAkJICAgLVdlcnJv cj1yZXR1cm4tdHlwZSAtV25vLWZvcm1hdC1zZWN1cml0eSBcCiAJCSAgIC1zdGQ9Z251MTEKIEtC VUlMRF9DUFBGTEFHUyA6PSAtRF9fS0VSTkVMX18KK0tCVUlMRF9SVVNURkxBR1MgOj0gJChydXN0 X2NvbW1vbl9mbGFncykgXAorCQkgICAgLS10YXJnZXQ9JChvYmp0cmVlKS9ydXN0L3RhcmdldC5q c29uIFwKKwkJICAgIC1DcGFuaWM9YWJvcnQgLUNlbWJlZC1iaXRjb2RlPW4gLUNsdG89biBcCisJ CSAgICAtQ2ZvcmNlLXVud2luZC10YWJsZXM9biAtQ2NvZGVnZW4tdW5pdHM9MSBcCisJCSAgICAt Q3N5bWJvbC1tYW5nbGluZy12ZXJzaW9uPXYwIFwKKwkJICAgIC1DcmVsb2NhdGlvbi1tb2RlbD1z dGF0aWMgXAorCQkgICAgLVpmdW5jdGlvbi1zZWN0aW9ucz1uIFwKKwkJICAgIC1EY2xpcHB5Ojpm bG9hdF9hcml0aG1ldGljCisKIEtCVUlMRF9BRkxBR1NfS0VSTkVMIDo9CiBLQlVJTERfQ0ZMQUdT X0tFUk5FTCA6PQorS0JVSUxEX1JVU1RGTEFHU19LRVJORUwgOj0KIEtCVUlMRF9BRkxBR1NfTU9E VUxFICA6PSAtRE1PRFVMRQogS0JVSUxEX0NGTEFHU19NT0RVTEUgIDo9IC1ETU9EVUxFCitLQlVJ TERfUlVTVEZMQUdTX01PRFVMRSA6PSAtLWNmZyBNT0RVTEUKIEtCVUlMRF9MREZMQUdTX01PRFVM RSA6PQogS0JVSUxEX0xERkxBR1MgOj0KIENMQU5HX0ZMQUdTIDo9CiAKK2lmZXEgKCQoS0JVSUxE X0NMSVBQWSksMSkKKwlSVVNUQ19PUl9DTElQUFlfUVVJRVQgOj0gQ0xJUFBZCisJUlVTVENfT1Jf Q0xJUFBZID0gJChDTElQUFlfRFJJVkVSKQorZWxzZQorCVJVU1RDX09SX0NMSVBQWV9RVUlFVCA6 PSBSVVNUQworCVJVU1RDX09SX0NMSVBQWSA9ICQoUlVTVEMpCitlbmRpZgorCitpZmRlZiBSVVNU X0xJQl9TUkMKKwlleHBvcnQgUlVTVF9MSUJfU1JDCitlbmRpZgorCitleHBvcnQgUlVTVENfQk9P VFNUUkFQIDo9IDEKKwogZXhwb3J0IEFSQ0ggU1JDQVJDSCBDT05GSUdfU0hFTEwgQkFTSCBIT1NU Q0MgS0JVSUxEX0hPU1RDRkxBR1MgQ1JPU1NfQ09NUElMRSBMRCBDQyBIT1NUUEtHX0NPTkZJRwor ZXhwb3J0IFJVU1RDIFJVU1RET0MgUlVTVEZNVCBSVVNUQ19PUl9DTElQUFlfUVVJRVQgUlVTVENf T1JfQ0xJUFBZIEJJTkRHRU4gQ0FSR08KK2V4cG9ydCBIT1NUUlVTVEMgS0JVSUxEX0hPU1RSVVNU RkxBR1MKIGV4cG9ydCBDUFAgQVIgTk0gU1RSSVAgT0JKQ09QWSBPQkpEVU1QIFJFQURFTEYgUEFI T0xFIFJFU09MVkVfQlRGSURTIExFWCBZQUNDIEFXSyBJTlNUQUxMS0VSTkVMCiBleHBvcnQgUEVS TCBQWVRIT04zIENIRUNLIENIRUNLRkxBR1MgTUFLRSBVVFNfTUFDSElORSBIT1NUQ1hYCiBleHBv cnQgS0daSVAgS0JaSVAyIEtMWk9QIExaTUEgTFo0IFhaIFpTVEQKQEAgLTU0Myw5ICs2MDYsMTAg QEAgZXhwb3J0IEtCVUlMRF9VU0VSQ0ZMQUdTIEtCVUlMRF9VU0VSTERGTEFHUwogCiBleHBvcnQg S0JVSUxEX0NQUEZMQUdTIE5PU1RESU5DX0ZMQUdTIExJTlVYSU5DTFVERSBPQkpDT1BZRkxBR1Mg S0JVSUxEX0xERkxBR1MKIGV4cG9ydCBLQlVJTERfQ0ZMQUdTIENGTEFHU19LRVJORUwgQ0ZMQUdT X01PRFVMRQorZXhwb3J0IEtCVUlMRF9SVVNURkxBR1MgUlVTVEZMQUdTX0tFUk5FTCBSVVNURkxB R1NfTU9EVUxFCiBleHBvcnQgS0JVSUxEX0FGTEFHUyBBRkxBR1NfS0VSTkVMIEFGTEFHU19NT0RV TEUKLWV4cG9ydCBLQlVJTERfQUZMQUdTX01PRFVMRSBLQlVJTERfQ0ZMQUdTX01PRFVMRSBLQlVJ TERfTERGTEFHU19NT0RVTEUKLWV4cG9ydCBLQlVJTERfQUZMQUdTX0tFUk5FTCBLQlVJTERfQ0ZM QUdTX0tFUk5FTAorZXhwb3J0IEtCVUlMRF9BRkxBR1NfTU9EVUxFIEtCVUlMRF9DRkxBR1NfTU9E VUxFIEtCVUlMRF9SVVNURkxBR1NfTU9EVUxFIEtCVUlMRF9MREZMQUdTX01PRFVMRQorZXhwb3J0 IEtCVUlMRF9BRkxBR1NfS0VSTkVMIEtCVUlMRF9DRkxBR1NfS0VSTkVMIEtCVUlMRF9SVVNURkxB R1NfS0VSTkVMCiBleHBvcnQgUEFIT0xFX0ZMQUdTCiAKICMgRmlsZXMgdG8gaWdub3JlIGluIGZp bmQgLi4uIHN0YXRlbWVudHMKQEAgLTcyNiw3ICs3OTAsNyBAQCAkKEtDT05GSUdfQ09ORklHKToK ICMKICMgRG8gbm90IHVzZSAkKGNhbGwgY21kLC4uLikgaGVyZS4gVGhhdCB3b3VsZCBzdXBwcmVz cyBwcm9tcHRzIGZyb20gc3luY2NvbmZpZywKICMgc28geW91IGNhbm5vdCBub3RpY2UgdGhhdCBL Y29uZmlnIGlzIHdhaXRpbmcgZm9yIHRoZSB1c2VyIGlucHV0LgotJS9jb25maWcvYXV0by5jb25m ICUvY29uZmlnL2F1dG8uY29uZi5jbWQgJS9nZW5lcmF0ZWQvYXV0b2NvbmYuaDogJChLQ09ORklH X0NPTkZJRykKKyUvY29uZmlnL2F1dG8uY29uZiAlL2NvbmZpZy9hdXRvLmNvbmYuY21kICUvZ2Vu ZXJhdGVkL2F1dG9jb25mLmggJS9nZW5lcmF0ZWQvcnVzdGNfY2ZnOiAkKEtDT05GSUdfQ09ORklH KQogCSQoUSkkKGtlY2hvKSAiICBTWU5DICAgICRAIgogCSQoUSkkKE1BS0UpIC1mICQoc3JjdHJl ZSkvTWFrZWZpbGUgc3luY2NvbmZpZwogZWxzZSAjICFtYXktc3luYy1jb25maWcKQEAgLTc1NSwx MiArODE5LDIwIEBAIEtCVUlMRF9DRkxBR1MJKz0gJChjYWxsIGNjLWRpc2FibGUtd2FybmluZywg YWRkcmVzcy1vZi1wYWNrZWQtbWVtYmVyKQogCiBpZmRlZiBDT05GSUdfQ0NfT1BUSU1JWkVfRk9S X1BFUkZPUk1BTkNFCiBLQlVJTERfQ0ZMQUdTICs9IC1PMgorS0JVSUxEX1JVU1RGTEFHUyArPSAt Q29wdC1sZXZlbD0yCiBlbHNlIGlmZGVmIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfUEVSRk9STUFO Q0VfTzMKIEtCVUlMRF9DRkxBR1MgKz0gLU8zCitLQlVJTERfUlVTVEZMQUdTICs9IC1Db3B0LWxl dmVsPTMKIGVsc2UgaWZkZWYgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFCiBLQlVJTERfQ0ZM QUdTICs9IC1PcworS0JVSUxEX1JVU1RGTEFHUyArPSAtQ29wdC1sZXZlbD1zCiBlbmRpZgogCisj IEFsd2F5cyBzZXQgYGRlYnVnLWFzc2VydGlvbnNgIGFuZCBgb3ZlcmZsb3ctY2hlY2tzYCBiZWNh dXNlIHRoZWlyIGRlZmF1bHQKKyMgZGVwZW5kcyBvbiBgb3B0LWxldmVsYCBhbmQgYGRlYnVnLWFz c2VydGlvbnNgLCByZXNwZWN0aXZlbHkuCitLQlVJTERfUlVTVEZMQUdTICs9IC1DZGVidWctYXNz ZXJ0aW9ucz0kKGlmICQoQ09ORklHX1JVU1RfREVCVUdfQVNTRVJUSU9OUykseSxuKQorS0JVSUxE X1JVU1RGTEFHUyArPSAtQ292ZXJmbG93LWNoZWNrcz0kKGlmICQoQ09ORklHX1JVU1RfT1ZFUkZM T1dfQ0hFQ0tTKSx5LG4pCisKICMgVGVsbCBnY2MgdG8gbmV2ZXIgcmVwbGFjZSBjb25kaXRpb25h bCBsb2FkIHdpdGggYSBub24tY29uZGl0aW9uYWwgb25lCiBpZmRlZiBDT05GSUdfQ0NfSVNfR0ND CiAjIGdjYy0xMCByZW5hbWVkIC0tcGFyYW09YWxsb3ctc3RvcmUtZGF0YS1yYWNlcz0wIHRvCkBA IC03OTEsNiArODYzLDkgQEAgS0JVSUxEX0NGTEFHUy0kKENPTkZJR19XRVJST1IpICs9IC1XZXJy b3IKIEtCVUlMRF9DRkxBR1MtJChDT05GSUdfQ0NfTk9fQVJSQVlfQk9VTkRTKSArPSAtV25vLWFy cmF5LWJvdW5kcwogS0JVSUxEX0NGTEFHUyArPSAkKEtCVUlMRF9DRkxBR1MteSkgJChDT05GSUdf Q0NfSU1QTElDSVRfRkFMTFRIUk9VR0gpCiAKK0tCVUlMRF9SVVNURkxBR1MtJChDT05GSUdfV0VS Uk9SKSArPSAtRHdhcm5pbmdzCitLQlVJTERfUlVTVEZMQUdTICs9ICQoS0JVSUxEX1JVU1RGTEFH Uy15KQorCiBpZmRlZiBDT05GSUdfQ0NfSVNfQ0xBTkcKIEtCVUlMRF9DUFBGTEFHUyArPSAtUXVu dXNlZC1hcmd1bWVudHMKICMgVGhlIGtlcm5lbCBidWlsZHMgd2l0aCAnLXN0ZD1nbnUxMScgc28g dXNlIG9mIEdOVSBleHRlbnNpb25zIGlzIGFjY2VwdGFibGUuCkBAIC04MTEsMTIgKzg4NiwxNSBA QCBLQlVJTERfQ0ZMQUdTICs9ICQoY2FsbCBjYy1kaXNhYmxlLXdhcm5pbmcsIGRhbmdsaW5nLXBv aW50ZXIpCiAKIGlmZGVmIENPTkZJR19GUkFNRV9QT0lOVEVSCiBLQlVJTERfQ0ZMQUdTCSs9IC1m bm8tb21pdC1mcmFtZS1wb2ludGVyIC1mbm8tb3B0aW1pemUtc2libGluZy1jYWxscworS0JVSUxE X1JVU1RGTEFHUyArPSAtQ2ZvcmNlLWZyYW1lLXBvaW50ZXJzPXkKIGVsc2UKICMgU29tZSB0YXJn ZXRzIChBUk0gd2l0aCBUaHVtYjIsIGZvciBleGFtcGxlKSwgY2FuJ3QgYmUgYnVpbHQgd2l0aCBm cmFtZQogIyBwb2ludGVycy4gIEZvciB0aG9zZSwgd2UgZG9uJ3QgaGF2ZSBGVU5DVElPTl9UUkFD RVIgYXV0b21hdGljYWxseQogIyBzZWxlY3QgRlJBTUVfUE9JTlRFUi4gIEhvd2V2ZXIsIEZVTkNU SU9OX1RSQUNFUiBhZGRzIC1wZywgYW5kIHRoaXMgaXMKICMgaW5jb21wYXRpYmxlIHdpdGggLWZv bWl0LWZyYW1lLXBvaW50ZXIgd2l0aCBjdXJyZW50IEdDQywgc28gd2UgZG9uJ3QgdXNlCiAjIC1m b21pdC1mcmFtZS1wb2ludGVyIHdpdGggRlVOQ1RJT05fVFJBQ0VSLgorIyBJbiB0aGUgUnVzdCB0 YXJnZXQgc3BlY2lmaWNhdGlvbiwgImZyYW1lLXBvaW50ZXIiIGlzIHNldCBleHBsaWNpdGx5Cisj IHRvICJtYXktb21pdCIuCiBpZm5kZWYgQ09ORklHX0ZVTkNUSU9OX1RSQUNFUgogS0JVSUxEX0NG TEFHUwkrPSAtZm9taXQtZnJhbWUtcG9pbnRlcgogZW5kaWYKQEAgLTg4MSw4ICs5NTksMTAgQEAg aWZkZWYgQ09ORklHX0RFQlVHX1NFQ1RJT05fTUlTTUFUQ0gKIEtCVUlMRF9DRkxBR1MgKz0gLWZu by1pbmxpbmUtZnVuY3Rpb25zLWNhbGxlZC1vbmNlCiBlbmRpZgogCisjIGBydXN0Y2AncyBgLVpm dW5jdGlvbi1zZWN0aW9uc2AgYXBwbGllcyB0byBkYXRhIHRvbyAoYXMgb2YgMS41OS4wKS4KIGlm ZGVmIENPTkZJR19MRF9ERUFEX0NPREVfREFUQV9FTElNSU5BVElPTgogS0JVSUxEX0NGTEFHU19L RVJORUwgKz0gLWZmdW5jdGlvbi1zZWN0aW9ucyAtZmRhdGEtc2VjdGlvbnMKK0tCVUlMRF9SVVNU RkxBR1NfS0VSTkVMICs9IC1aZnVuY3Rpb24tc2VjdGlvbnM9eQogTERGTEFHU192bWxpbnV4ICs9 IC0tZ2Mtc2VjdGlvbnMKIGVuZGlmCiAKQEAgLTEwMjUsMTAgKzExMDUsMTEgQEAgaW5jbHVkZSAk KGFkZHByZWZpeCAkKHNyY3RyZWUpLywgJChpbmNsdWRlLXkpKQogIyBEbyBub3QgYWRkICQoY2Fs bCBjYy1vcHRpb24sLi4uKSBiZWxvdyB0aGlzIGxpbmUuIFdoZW4geW91IGJ1aWxkIHRoZSBrZXJu ZWwKICMgZnJvbSB0aGUgY2xlYW4gc291cmNlIHRyZWUsIHRoZSBHQ0MgcGx1Z2lucyBkbyBub3Qg ZXhpc3QgYXQgdGhpcyBwb2ludC4KIAotIyBBZGQgdXNlciBzdXBwbGllZCBDUFBGTEFHUywgQUZM QUdTIGFuZCBDRkxBR1MgYXMgdGhlIGxhc3QgYXNzaWdubWVudHMKKyMgQWRkIHVzZXIgc3VwcGxp ZWQgQ1BQRkxBR1MsIEFGTEFHUywgQ0ZMQUdTIGFuZCBSVVNURkxBR1MgYXMgdGhlIGxhc3QgYXNz aWdubWVudHMKIEtCVUlMRF9DUFBGTEFHUyArPSAkKEtDUFBGTEFHUykKIEtCVUlMRF9BRkxBR1Mg ICArPSAkKEtBRkxBR1MpCiBLQlVJTERfQ0ZMQUdTICAgKz0gJChLQ0ZMQUdTKQorS0JVSUxEX1JV U1RGTEFHUyArPSAkKEtSVVNURkxBR1MpCiAKIEtCVUlMRF9MREZMQUdTX01PRFVMRSArPSAtLWJ1 aWxkLWlkPXNoYTEKIExERkxBR1Nfdm1saW51eCArPSAtLWJ1aWxkLWlkPXNoYTEKQEAgLTEwOTcs NiArMTE3OCw3IEBAIGV4cG9ydCBNT0RVTEVTX05TREVQUyA6PSAkKGV4dG1vZF9wcmVmaXgpbW9k dWxlcy5uc2RlcHMKIGlmZXEgKCQoS0JVSUxEX0VYVE1PRCksKQogY29yZS15CQkJKz0ga2VybmVs LyBjZXJ0cy8gbW0vIGZzLyBpcGMvIHNlY3VyaXR5LyBjcnlwdG8vCiBjb3JlLSQoQ09ORklHX0JM T0NLKQkrPSBibG9jay8KK2NvcmUtJChDT05GSUdfUlVTVCkJKz0gcnVzdC8KIAogdm1saW51eC1k aXJzCTo9ICQocGF0c3Vic3QgJS8sJSwkKGZpbHRlciAlLywgXAogCQkgICAgICQoY29yZS15KSAk KGNvcmUtbSkgJChkcml2ZXJzLXkpICQoZHJpdmVycy1tKSBcCkBAIC0xMjAxLDYgKzEyODMsMTAg QEAgcHJlcGFyZTA6IGFyY2hwcmVwYXJlCiAKICMgQWxsIHRoZSBwcmVwYXJpbmcuLgogcHJlcGFy ZTogcHJlcGFyZTAKK2lmZGVmIENPTkZJR19SVVNUCisJJChRKSQoQ09ORklHX1NIRUxMKSAkKHNy Y3RyZWUpL3NjcmlwdHMvcnVzdC1pcy1hdmFpbGFibGUuc2ggLXYKKwkkKFEpJChNQUtFKSAkKGJ1 aWxkKT1ydXN0CitlbmRpZgogCiBQSE9OWSArPSByZW1vdmUtc3RhbGUtZmlsZXMKIHJlbW92ZS1z dGFsZS1maWxlczoKQEAgLTE0OTAsNyArMTU3Niw3IEBAIGVuZGlmICMgQ09ORklHX01PRFVMRVMK ICMgRGlyZWN0b3JpZXMgJiBmaWxlcyByZW1vdmVkIHdpdGggJ21ha2UgY2xlYW4nCiBDTEVBTl9G SUxFUyArPSBpbmNsdWRlL2tzeW0gdm1saW51eC5zeW12ZXJzIG1vZHVsZXMtb25seS5zeW12ZXJz IFwKIAkgICAgICAgbW9kdWxlcy5idWlsdGluIG1vZHVsZXMuYnVpbHRpbi5tb2RpbmZvIG1vZHVs ZXMubnNkZXBzIFwKLQkgICAgICAgY29tcGlsZV9jb21tYW5kcy5qc29uIC50aGlubHRvLWNhY2hl CisJICAgICAgIGNvbXBpbGVfY29tbWFuZHMuanNvbiAudGhpbmx0by1jYWNoZSBydXN0L3Rlc3Qg cnVzdC9kb2MKIAogIyBEaXJlY3RvcmllcyAmIGZpbGVzIHJlbW92ZWQgd2l0aCAnbWFrZSBtcnBy b3BlcicKIE1SUFJPUEVSX0ZJTEVTICs9IGluY2x1ZGUvY29uZmlnIGluY2x1ZGUvZ2VuZXJhdGVk ICAgICAgICAgIFwKQEAgLTE1MDEsNyArMTU4Nyw4IEBAIE1SUFJPUEVSX0ZJTEVTICs9IGluY2x1 ZGUvY29uZmlnIGluY2x1ZGUvZ2VuZXJhdGVkICAgICAgICAgIFwKIAkJICBjZXJ0cy9zaWduaW5n X2tleS5wZW0gXAogCQkgIGNlcnRzL3g1MDkuZ2Vua2V5IFwKIAkJICB2bWxpbnV4LWdkYi5weSBc Ci0JCSAgKi5zcGVjCisJCSAgKi5zcGVjIFwKKwkJICBydXN0L3RhcmdldC5qc29uIHJ1c3QvbGli bWFjcm9zLnNvCiAKICMgY2xlYW4gLSBEZWxldGUgbW9zdCwgYnV0IGxlYXZlIGVub3VnaCB0byBi dWlsZCBleHRlcm5hbCBtb2R1bGVzCiAjCkBAIC0xNTI2LDYgKzE2MTMsOSBAQCAkKG1ycHJvcGVy LWRpcnMpOgogCiBtcnByb3BlcjogY2xlYW4gJChtcnByb3Blci1kaXJzKQogCSQoY2FsbCBjbWQs cm1maWxlcykKKwlAZmluZCAuICQoUkNTX0ZJTkRfSUdOT1JFKSBcCisJCVwoIC1uYW1lICcqLnJt ZXRhJyBcKSBcCisJCS10eXBlIGYgLXByaW50IHwgeGFyZ3Mgcm0gLWYKIAogIyBkaXN0Y2xlYW4K ICMKQEAgLTE2MTMsNiArMTcwMywyNCBAQCBoZWxwOgogCUBlY2hvICAnICBrc2VsZnRlc3QtbWVy Z2UgICAtIE1lcmdlIGFsbCB0aGUgY29uZmlnIGRlcGVuZGVuY2llcyBvZicKIAlAZWNobyAgJwkJ ICAgICAga3NlbGZ0ZXN0IHRvIGV4aXN0aW5nIC5jb25maWcuJwogCUBlY2hvICAnJworCUBlY2hv ICAnUnVzdCB0YXJnZXRzOicKKwlAZWNobyAgJyAgcnVzdGF2YWlsYWJsZSAgIC0gQ2hlY2tzIHdo ZXRoZXIgdGhlIFJ1c3QgdG9vbGNoYWluIGlzJworCUBlY2hvICAnCQkgICAgYXZhaWxhYmxlIGFu ZCwgaWYgbm90LCBleHBsYWlucyB3aHkuJworCUBlY2hvICAnICBydXN0Zm10CSAgLSBSZWZvcm1h dCBhbGwgdGhlIFJ1c3QgY29kZSBpbiB0aGUga2VybmVsJworCUBlY2hvICAnICBydXN0Zm10Y2hl Y2sJICAtIENoZWNrcyBpZiBhbGwgdGhlIFJ1c3QgY29kZSBpbiB0aGUga2VybmVsJworCUBlY2hv ICAnCQkgICAgaXMgZm9ybWF0dGVkLCBwcmludGluZyBhIGRpZmYgb3RoZXJ3aXNlLicKKwlAZWNo byAgJyAgcnVzdGRvYwkgIC0gR2VuZXJhdGUgUnVzdCBkb2N1bWVudGF0aW9uJworCUBlY2hvICAn CQkgICAgKHJlcXVpcmVzIGtlcm5lbCAuY29uZmlnKScKKwlAZWNobyAgJyAgcnVzdHRlc3QgICAg ICAgIC0gUnVucyB0aGUgUnVzdCB0ZXN0cycKKwlAZWNobyAgJyAgICAgICAgICAgICAgICAgICAg KHJlcXVpcmVzIGtlcm5lbCAuY29uZmlnOyBkb3dubG9hZHMgZXh0ZXJuYWwgcmVwb3MpJworCUBl Y2hvICAnICBydXN0LWFuYWx5emVyCSAgLSBHZW5lcmF0ZSBydXN0LXByb2plY3QuanNvbiBydXN0 LWFuYWx5emVyIHN1cHBvcnQgZmlsZScKKwlAZWNobyAgJwkJICAgIChyZXF1aXJlcyBrZXJuZWwg LmNvbmZpZyknCisJQGVjaG8gICcgIGRpci9maWxlLltvc10gICAtIEJ1aWxkIHNwZWNpZmllZCB0 YXJnZXQgb25seScKKwlAZWNobyAgJyAgZGlyL2ZpbGUucnNpICAgIC0gQnVpbGQgbWFjcm8gZXhw YW5kZWQgc291cmNlLCBzaW1pbGFyIHRvIEMgcHJlcHJvY2Vzc2luZy4nCisJQGVjaG8gICcgICAg ICAgICAgICAgICAgICAgIFJ1biB3aXRoIFJVU1RGTVQ9biB0byBza2lwIHJlZm9ybWF0dGluZyBp ZiBuZWVkZWQuJworCUBlY2hvICAnICAgICAgICAgICAgICAgICAgICBUaGUgb3V0cHV0IGlzIG5v dCBpbnRlbmRlZCB0byBiZSBjb21waWxhYmxlLicKKwlAZWNobyAgJyAgZGlyL2ZpbGUubGwgICAg IC0gQnVpbGQgdGhlIExMVk0gYXNzZW1ibHkgZmlsZScKKwlAZWNobyAgJycKIAlAJChpZiAkKGR0 c3RyZWUpLCBcCiAJCWVjaG8gJ0RldmljZXRyZWU6JzsgXAogCQllY2hvICcqIGR0YnMgICAgICAg ICAgICAgLSBCdWlsZCBkZXZpY2UgdHJlZSBibG9icyBmb3IgZW5hYmxlZCBib2FyZHMnOyBcCkBA IC0xNjg1LDYgKzE3OTMsNTIgQEAgUEhPTlkgKz0gJChET0NfVEFSR0VUUykKICQoRE9DX1RBUkdF VFMpOgogCSQoUSkkKE1BS0UpICQoYnVpbGQpPURvY3VtZW50YXRpb24gJEAKIAorCisjIFJ1c3Qg dGFyZ2V0cworIyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworIyAiSXMgUnVzdCBhdmFpbGFibGU/IiB0 YXJnZXQKK1BIT05ZICs9IHJ1c3RhdmFpbGFibGUKK3J1c3RhdmFpbGFibGU6CisJJChRKSQoQ09O RklHX1NIRUxMKSAkKHNyY3RyZWUpL3NjcmlwdHMvcnVzdC1pcy1hdmFpbGFibGUuc2ggLXYgJiYg ZWNobyAiUnVzdCBpcyBhdmFpbGFibGUhIgorCisjIERvY3VtZW50YXRpb24gdGFyZ2V0CisjCisj IFVzaW5nIHRoZSBzaW5ndWxhciB0byBhdm9pZCBydW5uaW5nIGFmb3VsIG9mIGBuby1kb3QtY29u ZmlnLXRhcmdldHNgLgorUEhPTlkgKz0gcnVzdGRvYworcnVzdGRvYzogcHJlcGFyZQorCSQoUSkk KE1BS0UpICQoYnVpbGQpPXJ1c3QgJEAKKworIyBUZXN0aW5nIHRhcmdldAorUEhPTlkgKz0gcnVz dHRlc3QKK3J1c3R0ZXN0OiBwcmVwYXJlCisJJChRKSQoTUFLRSkgJChidWlsZCk9cnVzdCAkQAor CisjIEZvcm1hdHRpbmcgdGFyZ2V0cworUEhPTlkgKz0gcnVzdGZtdCBydXN0Zm10Y2hlY2sKKwor IyBXZSBza2lwIGBydXN0L2FsbG9jYCBzaW5jZSB3ZSB3YW50IHRvIG1pbmltaXplIHRoZSBkaWZm IHcuci50LiB1cHN0cmVhbS4KKyMKKyMgV2UgbWF0Y2ggdXNpbmcgYWJzb2x1dGUgcGF0aHMgc2lu Y2UgYGZpbmRgIGRvZXMgbm90IHJlc29sdmUgdGhlbQorIyB3aGVuIG1hdGNoaW5nLCB3aGljaCBp cyBhIHByb2JsZW0gd2hlbiBlLmcuIGBzcmN0cmVlYCBpcyBgLi5gLgorIyBXZSBgZ3JlcGAgYWZ0 ZXJ3YXJkcyBpbiBvcmRlciB0byByZW1vdmUgdGhlIGRpcmVjdG9yeSBlbnRyeSBpdHNlbGYuCity dXN0Zm10OgorCSQoUSlmaW5kICQoYWJzX3NyY3RyZWUpIC10eXBlIGYgLW5hbWUgJyoucnMnIFwK KwkJLW8gLXBhdGggJChhYnNfc3JjdHJlZSkvcnVzdC9hbGxvYyAtcHJ1bmUgXAorCQktbyAtcGF0 aCAkKGFic19vYmp0cmVlKS9ydXN0L3Rlc3QgLXBydW5lIFwKKwkJfCBncmVwIC1GdiAkKGFic19z cmN0cmVlKS9ydXN0L2FsbG9jIFwKKwkJfCBncmVwIC1GdiAkKGFic19vYmp0cmVlKS9ydXN0L3Rl c3QgXAorCQl8IGdyZXAgLUZ2IGdlbmVyYXRlZCBcCisJCXwgeGFyZ3MgJChSVVNURk1UKSAkKHJ1 c3RmbXRfZmxhZ3MpCisKK3J1c3RmbXRjaGVjazogcnVzdGZtdF9mbGFncyA9IC0tY2hlY2sKK3J1 c3RmbXRjaGVjazogcnVzdGZtdAorCisjIElERSBzdXBwb3J0IHRhcmdldHMKK1BIT05ZICs9IHJ1 c3QtYW5hbHl6ZXIKK3J1c3QtYW5hbHl6ZXI6CisJJChRKSQoTUFLRSkgJChidWlsZCk9cnVzdCAk QAorCiAjIE1pc2MKICMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKQEAgLTE4NTIsNyArMjAwNiw3IEBA ICQoY2xlYW4tZGlycyk6CiBjbGVhbjogJChjbGVhbi1kaXJzKQogCSQoY2FsbCBjbWQscm1maWxl cykKIAlAZmluZCAkKG9yICQoS0JVSUxEX0VYVE1PRCksIC4pICQoUkNTX0ZJTkRfSUdOT1JFKSBc Ci0JCVwoIC1uYW1lICcqLlthaW9zXScgLW8gLW5hbWUgJyoua28nIC1vIC1uYW1lICcuKi5jbWQn IFwKKwkJXCggLW5hbWUgJyouW2Fpb3NdJyAtbyAtbmFtZSAnKi5yc2knIC1vIC1uYW1lICcqLmtv JyAtbyAtbmFtZSAnLiouY21kJyBcCiAJCS1vIC1uYW1lICcqLmtvLionIFwKIAkJLW8gLW5hbWUg JyouZHRiJyAtbyAtbmFtZSAnKi5kdGJvJyAtbyAtbmFtZSAnKi5kdGIuUycgLW8gLW5hbWUgJyou ZHQueWFtbCcgXAogCQktbyAtbmFtZSAnKi5kd28nIC1vIC1uYW1lICcqLmxzdCcgXApkaWZmIC0t Z2l0IGEvYXJjaC9LY29uZmlnIGIvYXJjaC9LY29uZmlnCmluZGV4IDcxYjkyNzJhY2IyOC4uZDUw MzhjZjhkZDQ5IDEwMDY0NAotLS0gYS9hcmNoL0tjb25maWcKKysrIGIvYXJjaC9LY29uZmlnCkBA IC0zNTMsNiArMzUzLDEyIEBAIGNvbmZpZyBIQVZFX1JTRVEKIAkgIFRoaXMgc3ltYm9sIHNob3Vs ZCBiZSBzZWxlY3RlZCBieSBhbiBhcmNoaXRlY3R1cmUgaWYgaXQKIAkgIHN1cHBvcnRzIGFuIGlt cGxlbWVudGF0aW9uIG9mIHJlc3RhcnRhYmxlIHNlcXVlbmNlcy4KIAorY29uZmlnIEhBVkVfUlVT VAorCWJvb2wKKwloZWxwCisJICBUaGlzIHN5bWJvbCBzaG91bGQgYmUgc2VsZWN0ZWQgYnkgYW4g YXJjaGl0ZWN0dXJlIGlmIGl0CisJICBzdXBwb3J0cyBSdXN0LgorCiBjb25maWcgSEFWRV9GVU5D VElPTl9BUkdfQUNDRVNTX0FQSQogCWJvb2wKIAloZWxwCmRpZmYgLS1naXQgYS9hcmNoL2FybS9L Y29uZmlnIGIvYXJjaC9hcm0vS2NvbmZpZwppbmRleCA3NjMwYmE5Y2I2Y2MuLjE0NzY1NWE0ZmMy NyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vS2NvbmZpZworKysgYi9hcmNoL2FybS9LY29uZmlnCkBA IC0xMTYsNiArMTE2LDcgQEAgY29uZmlnIEFSTQogCXNlbGVjdCBNTVVfR0FUSEVSX1JDVV9UQUJM RV9GUkVFIGlmIFNNUCAmJiBBUk1fTFBBRQogCXNlbGVjdCBIQVZFX1JFR1NfQU5EX1NUQUNLX0FD Q0VTU19BUEkKIAlzZWxlY3QgSEFWRV9SU0VRCisJc2VsZWN0IEhBVkVfUlVTVCBpZiBDUFVfMzJ2 NiB8fCBDUFVfMzJ2NksKIAlzZWxlY3QgSEFWRV9TVEFDS1BST1RFQ1RPUgogCXNlbGVjdCBIQVZF X1NZU0NBTExfVFJBQ0VQT0lOVFMKIAlzZWxlY3QgSEFWRV9VSUQxNgpkaWZmIC0tZ2l0IGEvYXJj aC9hcm02NC9LY29uZmlnIGIvYXJjaC9hcm02NC9LY29uZmlnCmluZGV4IDE2NTJhOTgwMGViZS4u YWFlYjcwMzU4OTc5IDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L0tjb25maWcKKysrIGIvYXJjaC9h cm02NC9LY29uZmlnCkBAIC0yMDEsNiArMjAxLDcgQEAgY29uZmlnIEFSTTY0CiAJc2VsZWN0IEhB VkVfRlVOQ1RJT05fQVJHX0FDQ0VTU19BUEkKIAlzZWxlY3QgTU1VX0dBVEhFUl9SQ1VfVEFCTEVf RlJFRQogCXNlbGVjdCBIQVZFX1JTRVEKKwlzZWxlY3QgSEFWRV9SVVNUCiAJc2VsZWN0IEhBVkVf U1RBQ0tQUk9URUNUT1IKIAlzZWxlY3QgSEFWRV9TWVNDQUxMX1RSQUNFUE9JTlRTCiAJc2VsZWN0 IEhBVkVfS1BST0JFUwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL0tjb25maWcgYi9hcmNoL3Bv d2VycGMvS2NvbmZpZwppbmRleCA0ZDhmMjZjMTM5OWIuLmVkYWIzY2M5ZWRmNSAxMDA2NDQKLS0t IGEvYXJjaC9wb3dlcnBjL0tjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL0tjb25maWcKQEAgLTI0 Myw2ICsyNDMsNyBAQCBjb25maWcgUFBDCiAJc2VsZWN0IEhBVkVfUkVHU19BTkRfU1RBQ0tfQUND RVNTX0FQSQogCXNlbGVjdCBIQVZFX1JFTElBQkxFX1NUQUNLVFJBQ0UKIAlzZWxlY3QgSEFWRV9S U0VRCisJc2VsZWN0IEhBVkVfUlVTVAkJCWlmIFBQQzY0ICYmIENQVV9MSVRUTEVfRU5ESUFOCiAJ c2VsZWN0IEhBVkVfU0VUVVBfUEVSX0NQVV9BUkVBCQlpZiBQUEM2NAogCXNlbGVjdCBIQVZFX1NP RlRJUlFfT05fT1dOX1NUQUNLCiAJc2VsZWN0IEhBVkVfU1RBQ0tQUk9URUNUT1IJCWlmIFBQQzMy ICYmICQoY2Mtb3B0aW9uLC1tc3RhY2stcHJvdGVjdG9yLWd1YXJkPXRscyAtbXN0YWNrLXByb3Rl Y3Rvci1ndWFyZC1yZWc9cjIpCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L0tjb25maWcgYi9hcmNo L3Jpc2N2L0tjb25maWcKaW5kZXggZmNiYjgxZmViN2FkLi41YjUzYjQxNTI4ZjYgMTAwNjQ0Ci0t LSBhL2FyY2gvcmlzY3YvS2NvbmZpZworKysgYi9hcmNoL3Jpc2N2L0tjb25maWcKQEAgLTEwNCw2 ICsxMDQsNyBAQCBjb25maWcgUklTQ1YKIAlzZWxlY3QgSEFWRV9QRVJGX1JFR1MKIAlzZWxlY3Qg SEFWRV9QRVJGX1VTRVJfU1RBQ0tfRFVNUAogCXNlbGVjdCBIQVZFX1JFR1NfQU5EX1NUQUNLX0FD Q0VTU19BUEkKKwlzZWxlY3QgSEFWRV9SVVNUIGlmIDY0QklUCiAJc2VsZWN0IEhBVkVfRlVOQ1RJ T05fQVJHX0FDQ0VTU19BUEkKIAlzZWxlY3QgSEFWRV9TVEFDS1BST1RFQ1RPUgogCXNlbGVjdCBI QVZFX1NZU0NBTExfVFJBQ0VQT0lOVFMKZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvTWFrZWZpbGUg Yi9hcmNoL3Jpc2N2L01ha2VmaWxlCmluZGV4IDgxMDI5ZDQwYTY3Mi4uMjRlYmUwNDI0MDZlIDEw MDY0NAotLS0gYS9hcmNoL3Jpc2N2L01ha2VmaWxlCisrKyBiL2FyY2gvcmlzY3YvTWFrZWZpbGUK QEAgLTI2LDYgKzI2LDggQEAgaWZlcSAoJChDT05GSUdfQVJDSF9SVjY0SSkseSkKIAlLQlVJTERf Q0ZMQUdTICs9IC1tYWJpPWxwNjQKIAlLQlVJTERfQUZMQUdTICs9IC1tYWJpPWxwNjQKIAorCUtC VUlMRF9SVVNURkxBR1MgKz0gLUN0YXJnZXQtY3B1PWdlbmVyaWMtcnY2NAorCiAJS0JVSUxEX0xE RkxBR1MgKz0gLW1lbGY2NGxyaXNjdgogZWxzZQogCUJJVFMgOj0gMzIKQEAgLTMzLDYgKzM1LDkg QEAgZWxzZQogCiAJS0JVSUxEX0NGTEFHUyArPSAtbWFiaT1pbHAzMgogCUtCVUlMRF9BRkxBR1Mg Kz0gLW1hYmk9aWxwMzIKKworCUtCVUlMRF9SVVNURkxBR1MgKz0gLUN0YXJnZXQtY3B1PWdlbmVy aWMtcnYzMgorCiAJS0JVSUxEX0xERkxBR1MgKz0gLW1lbGYzMmxyaXNjdgogZW5kaWYKIApkaWZm IC0tZ2l0IGEvYXJjaC91bS9LY29uZmlnIGIvYXJjaC91bS9LY29uZmlnCmluZGV4IDRlYzIyZTE1 NmEyZS4uNmRjMDZhN2JmOGI3IDEwMDY0NAotLS0gYS9hcmNoL3VtL0tjb25maWcKKysrIGIvYXJj aC91bS9LY29uZmlnCkBAIC0yNSw2ICsyNSw3IEBAIGNvbmZpZyBVTUwKIAlzZWxlY3QgVFJBQ0Vf SVJRRkxBR1NfU1VQUE9SVAogCXNlbGVjdCBUVFkgIyBOZWVkZWQgZm9yIGxpbmUuYwogCXNlbGVj dCBIQVZFX0FSQ0hfVk1BUF9TVEFDSworCXNlbGVjdCBIQVZFX1JVU1QJCQlpZiBYODZfNjQKIAog Y29uZmlnIE1NVQogCWJvb2wKZGlmZiAtLWdpdCBhL2FyY2gveDg2L0tjb25maWcgYi9hcmNoL3g4 Ni9LY29uZmlnCmluZGV4IDUyYTdmOTE1MjdmZS4uNGQ1YTNmMjU2Y2JjIDEwMDY0NAotLS0gYS9h cmNoL3g4Ni9LY29uZmlnCisrKyBiL2FyY2gveDg2L0tjb25maWcKQEAgLTI1OCw2ICsyNTgsNyBA QCBjb25maWcgWDg2CiAJc2VsZWN0IEhBVkVfU1RBVElDX0NBTExfSU5MSU5FCQlpZiBIQVZFX09C SlRPT0wKIAlzZWxlY3QgSEFWRV9QUkVFTVBUX0RZTkFNSUNfQ0FMTAogCXNlbGVjdCBIQVZFX1JT RVEKKwlzZWxlY3QgSEFWRV9SVVNUCQkJaWYgWDg2XzY0CiAJc2VsZWN0IEhBVkVfU1lTQ0FMTF9U UkFDRVBPSU5UUwogCXNlbGVjdCBIQVZFX1VBQ0NFU1NfVkFMSURBVElPTgkJaWYgSEFWRV9PQkpU T09MCiAJc2VsZWN0IEhBVkVfVU5TVEFCTEVfU0NIRURfQ0xPQ0sKZGlmZiAtLWdpdCBhL2FyY2gv eDg2L01ha2VmaWxlIGIvYXJjaC94ODYvTWFrZWZpbGUKaW5kZXggNzg1NDY4NWM1ZjI1Li5iYWI1 OTUwMDNmMDcgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L01ha2VmaWxlCisrKyBiL2FyY2gveDg2L01h a2VmaWxlCkBAIC02OCw2ICs2OCw3IEBAIGV4cG9ydCBCSVRTCiAjICAgIGh0dHBzOi8vZ2NjLmdu dS5vcmcvYnVnemlsbGEvc2hvd19idWcuY2dpP2lkPTUzMzgzCiAjCiBLQlVJTERfQ0ZMQUdTICs9 IC1tbm8tc3NlIC1tbm8tbW14IC1tbm8tc3NlMiAtbW5vLTNkbm93IC1tbm8tYXZ4CitLQlVJTERf UlVTVEZMQUdTICs9IC1DdGFyZ2V0LWZlYXR1cmU9LXNzZSwtc3NlMiwtc3NlMywtc3NzZTMsLXNz ZTQuMSwtc3NlNC4yLC1hdngsLWF2eDIKIAogaWZlcSAoJChDT05GSUdfWDg2X0tFUk5FTF9JQlQp LHkpCiAjCkBAIC0xNTUsOCArMTU2LDE3IEBAIGVsc2UKICAgICAgICAgY2ZsYWdzLSQoQ09ORklH X0dFTkVSSUNfQ1BVKQkrPSAtbXR1bmU9Z2VuZXJpYwogICAgICAgICBLQlVJTERfQ0ZMQUdTICs9 ICQoY2ZsYWdzLXkpCiAKKyAgICAgICAgcnVzdGZsYWdzLSQoQ09ORklHX01LOCkJCSs9IC1DdGFy Z2V0LWNwdT1rOAorICAgICAgICBydXN0ZmxhZ3MtJChDT05GSUdfTVBTQykJKz0gLUN0YXJnZXQt Y3B1PW5vY29uYQorICAgICAgICBydXN0ZmxhZ3MtJChDT05GSUdfTUNPUkUyKQkrPSAtQ3Rhcmdl dC1jcHU9Y29yZTIKKyAgICAgICAgcnVzdGZsYWdzLSQoQ09ORklHX01BVE9NKQkrPSAtQ3Rhcmdl dC1jcHU9YXRvbQorICAgICAgICBydXN0ZmxhZ3MtJChDT05GSUdfR0VORVJJQ19DUFUpCSs9IC1a dHVuZS1jcHU9Z2VuZXJpYworICAgICAgICBLQlVJTERfUlVTVEZMQUdTICs9ICQocnVzdGZsYWdz LXkpCisKICAgICAgICAgS0JVSUxEX0NGTEFHUyArPSAtbW5vLXJlZC16b25lCiAgICAgICAgIEtC VUlMRF9DRkxBR1MgKz0gLW1jbW9kZWw9a2VybmVsCisgICAgICAgIEtCVUlMRF9SVVNURkxBR1Mg Kz0gLUNuby1yZWR6b25lPXkKKyAgICAgICAgS0JVSUxEX1JVU1RGTEFHUyArPSAtQ2NvZGUtbW9k ZWw9a2VybmVsCiBlbmRpZgogCiAjCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2NvbXBpbGVy X3R5cGVzLmggYi9pbmNsdWRlL2xpbnV4L2NvbXBpbGVyX3R5cGVzLmgKaW5kZXggNGYyYTgxOWZk NjBhLi41MGIzZjZiOTUwMmUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvY29tcGlsZXJfdHlw ZXMuaAorKysgYi9pbmNsdWRlL2xpbnV4L2NvbXBpbGVyX3R5cGVzLmgKQEAgLTQsOCArNCwxMiBA QAogCiAjaWZuZGVmIF9fQVNTRU1CTFlfXwogCisvKgorICogU2tpcHBlZCB3aGVuIHJ1bm5pbmcg YmluZGdlbiBkdWUgdG8gYSBsaWJjbGFuZyBpc3N1ZTsKKyAqIHNlZSBodHRwczovL2dpdGh1Yi5j b20vcnVzdC1sYW5nL3J1c3QtYmluZGdlbi9pc3N1ZXMvMjI0NC4KKyAqLwogI2lmIGRlZmluZWQo Q09ORklHX0RFQlVHX0lORk9fQlRGKSAmJiBkZWZpbmVkKENPTkZJR19QQUhPTEVfSEFTX0JURl9U QUcpICYmIFwKLQlfX2hhc19hdHRyaWJ1dGUoYnRmX3R5cGVfdGFnKQorCV9faGFzX2F0dHJpYnV0 ZShidGZfdHlwZV90YWcpICYmICFkZWZpbmVkKF9fQklOREdFTl9fKQogIyBkZWZpbmUgQlRGX1RZ UEVfVEFHKHZhbHVlKSBfX2F0dHJpYnV0ZV9fKChidGZfdHlwZV90YWcoI3ZhbHVlKSkpCiAjZWxz ZQogIyBkZWZpbmUgQlRGX1RZUEVfVEFHKHZhbHVlKSAvKiBub3RoaW5nICovCmRpZmYgLS1naXQg YS9pbml0L0tjb25maWcgYi9pbml0L0tjb25maWcKaW5kZXggYzc5MDBlODk3NWYxLi42ZjYyZGJl YTgyODMgMTAwNjQ0Ci0tLSBhL2luaXQvS2NvbmZpZworKysgYi9pbml0L0tjb25maWcKQEAgLTYw LDYgKzYwLDE3IEBAIGNvbmZpZyBMTERfVkVSU0lPTgogCWRlZmF1bHQgJChsZC12ZXJzaW9uKSBp ZiBMRF9JU19MTEQKIAlkZWZhdWx0IDAKIAorY29uZmlnIFJVU1RfSVNfQVZBSUxBQkxFCisJZGVm X2Jvb2wgJChzdWNjZXNzLCQoc3JjdHJlZSkvc2NyaXB0cy9ydXN0LWlzLWF2YWlsYWJsZS5zaCkK KwloZWxwCisJICBUaGlzIHNob3dzIHdoZXRoZXIgYSBzdWl0YWJsZSBSdXN0IHRvb2xjaGFpbiBp cyBhdmFpbGFibGUgKGZvdW5kKS4KKworCSAgUGxlYXNlIHNlZSBEb2N1bWVudGF0aW9uL3J1c3Qv cXVpY2stc3RhcnQucnN0IGZvciBpbnN0cnVjdGlvbnMgb24gaG93CisJICB0byBzYXRpZnkgdGhl IGJ1aWxkIHJlcXVpcmVtZW50cyBvZiBSdXN0IHN1cHBvcnQuCisKKwkgIEluIHBhcnRpY3VsYXIs IHRoZSBNYWtlZmlsZSB0YXJnZXQgJ3J1c3RhdmFpbGFibGUnIGlzIHVzZWZ1bCB0byBjaGVjawor CSAgd2h5IHRoZSBSdXN0IHRvb2xjaGFpbiBpcyBub3QgYmVpbmcgZGV0ZWN0ZWQuCisKIGNvbmZp ZyBDQ19DQU5fTElOSwogCWJvb2wKIAlkZWZhdWx0ICQoc3VjY2VzcywkKHNyY3RyZWUpL3Njcmlw dHMvY2MtY2FuLWxpbmsuc2ggJChDQykgJChDTEFOR19GTEFHUykgJChVU0VSQ0ZMQUdTKSAkKFVT RVJMREZMQUdTKSAkKG02NC1mbGFnKSkgaWYgNjRCSVQKQEAgLTE1MSw3ICsxNjIsOCBAQCBjb25m aWcgV0VSUk9SCiAJZGVmYXVsdCBDT01QSUxFX1RFU1QKIAloZWxwCiAJICBBIGtlcm5lbCBidWls ZCBzaG91bGQgbm90IGNhdXNlIGFueSBjb21waWxlciB3YXJuaW5ncywgYW5kIHRoaXMKLQkgIGVu YWJsZXMgdGhlICctV2Vycm9yJyBmbGFnIHRvIGVuZm9yY2UgdGhhdCBydWxlIGJ5IGRlZmF1bHQu CisJICBlbmFibGVzIHRoZSAnLVdlcnJvcicgKGZvciBDKSBhbmQgJy1Ed2FybmluZ3MnIChmb3Ig UnVzdCkgZmxhZ3MKKwkgIHRvIGVuZm9yY2UgdGhhdCBydWxlIGJ5IGRlZmF1bHQuCiAKIAkgIEhv d2V2ZXIsIGlmIHlvdSBoYXZlIGEgbmV3IChvciB2ZXJ5IG9sZCkgY29tcGlsZXIgd2l0aCBvZGQg YW5kCiAJICB1bnVzdWFsIHdhcm5pbmdzLCBvciB5b3UgaGF2ZSBzb21lIGFyY2hpdGVjdHVyZSB3 aXRoIHByb2JsZW1zLApAQCAtMTg5OCw2ICsxOTEwLDM4IEBAIGNvbmZpZyBQUk9GSUxJTkcKIAkg IFNheSBZIGhlcmUgdG8gZW5hYmxlIHRoZSBleHRlbmRlZCBwcm9maWxpbmcgc3VwcG9ydCBtZWNo YW5pc21zIHVzZWQKIAkgIGJ5IHByb2ZpbGVycy4KIAorY29uZmlnIFJVU1QKKwlib29sICJSdXN0 IHN1cHBvcnQiCisJZGVwZW5kcyBvbiBIQVZFX1JVU1QKKwlkZXBlbmRzIG9uIFJVU1RfSVNfQVZB SUxBQkxFCisJZGVwZW5kcyBvbiAhTU9EVkVSU0lPTlMKKwlkZXBlbmRzIG9uICFHQ0NfUExVR0lO UworCWRlcGVuZHMgb24gIVJBTkRTVFJVQ1QKKwlkZXBlbmRzIG9uICFERUJVR19JTkZPX0JURgor CXNlbGVjdCBDT05TVFJVQ1RPUlMKKwloZWxwCisJICBFbmFibGVzIFJ1c3Qgc3VwcG9ydCBpbiB0 aGUga2VybmVsLgorCisJICBUaGlzIGFsbG93cyBvdGhlciBSdXN0LXJlbGF0ZWQgb3B0aW9ucywg bGlrZSBkcml2ZXJzIHdyaXR0ZW4gaW4gUnVzdCwKKwkgIHRvIGJlIHNlbGVjdGVkLgorCisJICBJ dCBpcyBhbHNvIHJlcXVpcmVkIHRvIGJlIGFibGUgdG8gbG9hZCBleHRlcm5hbCBrZXJuZWwgbW9k dWxlcworCSAgd3JpdHRlbiBpbiBSdXN0LgorCisJICBTZWUgRG9jdW1lbnRhdGlvbi9ydXN0LyBm b3IgbW9yZSBpbmZvcm1hdGlvbi4KKworCSAgSWYgdW5zdXJlLCBzYXkgTi4KKworY29uZmlnIFJV U1RDX1ZFUlNJT05fVEVYVAorCXN0cmluZworCWRlcGVuZHMgb24gUlVTVAorCWRlZmF1bHQgJChz aGVsbCxjb21tYW5kIC12ICQoUlVTVEMpID4vZGV2L251bGwgMj4mMSAmJiAkKFJVU1RDKSAtLXZl cnNpb24gfHwgZWNobyBuKQorCitjb25maWcgQklOREdFTl9WRVJTSU9OX1RFWFQKKwlzdHJpbmcK KwlkZXBlbmRzIG9uIFJVU1QKKwlkZWZhdWx0ICQoc2hlbGwsY29tbWFuZCAtdiAkKEJJTkRHRU4p ID4vZGV2L251bGwgMj4mMSAmJiAkKEJJTkRHRU4pIC0tdmVyc2lvbiB8fCBlY2hvIG4pCisKICMK ICMgUGxhY2UgYW4gZW1wdHkgZnVuY3Rpb24gY2FsbCBhdCBlYWNoIHRyYWNlcG9pbnQgc2l0ZS4g Q2FuIGJlCiAjIGR5bmFtaWNhbGx5IGNoYW5nZWQgZm9yIGEgcHJvYmUgZnVuY3Rpb24uCmRpZmYg LS1naXQgYS9saWIvS2NvbmZpZy5kZWJ1ZyBiL2xpYi9LY29uZmlnLmRlYnVnCmluZGV4IDJlMjRk YjRiZmYxOS4uYWUzYzQzZTAwOTJlIDEwMDY0NAotLS0gYS9saWIvS2NvbmZpZy5kZWJ1ZworKysg Yi9saWIvS2NvbmZpZy5kZWJ1ZwpAQCAtMjY4OCw2ICsyNjg4LDg4IEBAIGNvbmZpZyBIWVBFUlZf VEVTVElORwogCiBlbmRtZW51ICMgIktlcm5lbCBUZXN0aW5nIGFuZCBDb3ZlcmFnZSIKIAorbWVu dSAiUnVzdCBoYWNraW5nIgorCitjb25maWcgUlVTVF9ERUJVR19BU1NFUlRJT05TCisJYm9vbCAi RGVidWcgYXNzZXJ0aW9ucyIKKwlkZXBlbmRzIG9uIFJVU1QKKwloZWxwCisJICBFbmFibGVzIHJ1 c3RjJ3MgYC1DZGVidWctYXNzZXJ0aW9uc2AgY29kZWdlbiBvcHRpb24uCisKKwkgIFRoaXMgZmxh ZyBsZXRzIHlvdSB0dXJuIGBjZmcoZGVidWdfYXNzZXJ0aW9ucylgIGNvbmRpdGlvbmFsCisJICBj b21waWxhdGlvbiBvbiBvciBvZmYuIFRoaXMgY2FuIGJlIHVzZWQgdG8gZW5hYmxlIGV4dHJhIGRl YnVnZ2luZworCSAgY29kZSBpbiBkZXZlbG9wbWVudCBidXQgbm90IGluIHByb2R1Y3Rpb24uIEZv ciBleGFtcGxlLCBpdCBjb250cm9scworCSAgdGhlIGJlaGF2aW9yIG9mIHRoZSBzdGFuZGFyZCBs aWJyYXJ5J3MgYGRlYnVnX2Fzc2VydCFgIG1hY3JvLgorCisJICBOb3RlIHRoYXQgdGhpcyB3aWxs IGFwcGx5IHRvIGFsbCBSdXN0IGNvZGUsIGluY2x1ZGluZyBgY29yZWAuCisKKwkgIElmIHVuc3Vy ZSwgc2F5IE4uCisKK2NvbmZpZyBSVVNUX09WRVJGTE9XX0NIRUNLUworCWJvb2wgIk92ZXJmbG93 IGNoZWNrcyIKKwlkZWZhdWx0IHkKKwlkZXBlbmRzIG9uIFJVU1QKKwloZWxwCisJICBFbmFibGVz IHJ1c3RjJ3MgYC1Db3ZlcmZsb3ctY2hlY2tzYCBjb2RlZ2VuIG9wdGlvbi4KKworCSAgVGhpcyBm bGFnIGFsbG93cyB5b3UgdG8gY29udHJvbCB0aGUgYmVoYXZpb3Igb2YgcnVudGltZSBpbnRlZ2Vy CisJICBvdmVyZmxvdy4gV2hlbiBvdmVyZmxvdy1jaGVja3MgYXJlIGVuYWJsZWQsIGEgUnVzdCBw YW5pYyB3aWxsIG9jY3VyCisJICBvbiBvdmVyZmxvdy4KKworCSAgTm90ZSB0aGF0IHRoaXMgd2ls bCBhcHBseSB0byBhbGwgUnVzdCBjb2RlLCBpbmNsdWRpbmcgYGNvcmVgLgorCisJICBJZiB1bnN1 cmUsIHNheSBZLgorCitjaG9pY2UKKwlwcm9tcHQgIkJ1aWxkLXRpbWUgYXNzZXJ0aW9ucyIKKwlk ZWZhdWx0IFJVU1RfQlVJTERfQVNTRVJUX0RFTlkKKwlkZXBlbmRzIG9uIFJVU1QKKwloZWxwCisJ ICBDb250cm9scyBob3cgYXJlIGBidWlsZF9lcnJvciFgIGFuZCBgYnVpbGRfYXNzZXJ0IWAgaGFu ZGxlZCBkdXJpbmcgYnVpbGQuCisKKwkgIElmIGNhbGxzIHRvIHRoZW0gZXhpc3QgaW4gdGhlIGJp bmFyeSwgaXQgbWF5IGluZGljYXRlIGEgdmlvbGF0ZWQgaW52YXJpYW50CisJICBvciB0aGF0IHRo ZSBvcHRpbWl6ZXIgZmFpbGVkIHRvIHZlcmlmeSB0aGUgaW52YXJpYW50IGR1cmluZyBjb21waWxh dGlvbi4KKwkgIFlvdSBjYW4gY2hvb3NlIHRvIGFib3J0IGNvbXBpbGF0aW9uIG9yIGlnbm9yZSB0 aGVtIGR1cmluZyBidWlsZCBhbmQgbGV0IHRoZQorCSAgY2hlY2sgYmUgY2FycmllZCB0byBydW50 aW1lLgorCisJICBJZiBvcHRpbWl6YXRpb25zIGFyZSB0dXJuZWQgb2ZmLCB5b3UgY2Fubm90IHNl bGVjdCAiRGVueSIuCisKKwkgIElmIHVuc3VyZSwgc2F5ICJEZW55Ii4KKworY29uZmlnIFJVU1Rf QlVJTERfQVNTRVJUX0FMTE9XCisJYm9vbCAiQWxsb3ciCisJaGVscAorCSAgVW5vcHRpbWl6ZWQg Y2FsbHMgdG8gYGJ1aWxkX2Vycm9yIWAgd2lsbCBiZSBjb252ZXJ0ZWQgdG8gYHBhbmljIWAKKwkg IGFuZCBjaGVja2VkIGF0IHJ1bnRpbWUuCisKK2NvbmZpZyBSVVNUX0JVSUxEX0FTU0VSVF9XQVJO CisJYm9vbCAiV2FybiIKKwloZWxwCisJICBVbm9wdGltaXplZCBjYWxscyB0byBgYnVpbGRfZXJy b3IhYCB3aWxsIGJlIGNvbnZlcnRlZCB0byBgcGFuaWMhYAorCSAgYW5kIGNoZWNrZWQgYXQgcnVu dGltZSwgYnV0IHdhcm5pbmdzIHdpbGwgYmUgZ2VuZXJhdGVkIHdoZW4gYnVpbGRpbmcuCisKK2Nv bmZpZyBSVVNUX0JVSUxEX0FTU0VSVF9ERU5ZCisJYm9vbCAiRGVueSIKKwloZWxwCisJICBVbm9w dGltaXplZCBjYWxscyB0byBgYnVpbGRfZXJyb3IhYCB3aWxsIGFib3J0IGNvbXBpbGF0aW9uLgor CitlbmRjaG9pY2UKKworY29uZmlnIFJVU1RfS0VSTkVMX0tVTklUX1RFU1QKKwlib29sICJLVW5p dCB0ZXN0IGZvciB0aGUgYGtlcm5lbGAgY3JhdGUiIGlmICFLVU5JVF9BTExfVEVTVFMKKwlkZXBl bmRzIG9uIFJVU1QgJiYgS1VOSVQ9eQorCWRlZmF1bHQgS1VOSVRfQUxMX1RFU1RTCisJaGVscAor CSAgVGhpcyBidWlsZHMgdGhlIGRvY3VtZW50YXRpb24gdGVzdHMgb2YgdGhlIGBrZXJuZWxgIGNy YXRlCisJICBhcyBLVW5pdCB0ZXN0cy4KKworCSAgRm9yIG1vcmUgaW5mb3JtYXRpb24gb24gS1Vu aXQgYW5kIHVuaXQgdGVzdHMgaW4gZ2VuZXJhbCwKKwkgIHBsZWFzZSByZWZlciB0byB0aGUgS1Vu aXQgZG9jdW1lbnRhdGlvbiBpbiBEb2N1bWVudGF0aW9uL2Rldi10b29scy9rdW5pdC8uCisKKwkg IElmIHVuc3VyZSwgc2F5IE4uCisKK2VuZG1lbnUgIyAiUnVzdCIKKwogc291cmNlICJEb2N1bWVu dGF0aW9uL0tjb25maWciCiAKIGVuZG1lbnUgIyBLZXJuZWwgaGFja2luZwpkaWZmIC0tZ2l0IGEv cnVzdC8uZ2l0aWdub3JlIGIvcnVzdC8uZ2l0aWdub3JlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMC4uODliNjAyZDkxMTA5Ci0tLSAvZGV2L251bGwKKysrIGIvcnVzdC8u Z2l0aWdub3JlCkBAIC0wLDAgKzEsMTAgQEAKKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQ TC0yLjAKKwordGFyZ2V0Lmpzb24KK2JpbmRpbmdzX2dlbmVyYXRlZC5ycworYmluZGluZ3NfaGVs cGVyc19nZW5lcmF0ZWQucnMKK2V4cG9ydHNfKl9nZW5lcmF0ZWQuaAorZG9jdGVzdHNfa2VybmVs X2dlbmVyYXRlZC5ycworZG9jdGVzdHNfa2VybmVsX2dlbmVyYXRlZF9rdW5pdC5jCitkb2MvCit0 ZXN0LwpkaWZmIC0tZ2l0IGEvcnVzdC9NYWtlZmlsZSBiL3J1c3QvTWFrZWZpbGUKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4zMGNlMTNmYThkYWQKLS0tIC9kZXYvbnVs bAorKysgYi9ydXN0L01ha2VmaWxlCkBAIC0wLDAgKzEsNDE1IEBACisjIFNQRFgtTGljZW5zZS1J ZGVudGlmaWVyOiBHUEwtMi4wCisKK2Fsd2F5cy0kKENPTkZJR19SVVNUKSArPSB0YXJnZXQuanNv bgorbm8tY2xlYW4tZmlsZXMgKz0gdGFyZ2V0Lmpzb24KKworb2JqLSQoQ09ORklHX1JVU1QpICs9 IGNvcmUubyBjb21waWxlcl9idWlsdGlucy5vCithbHdheXMtJChDT05GSUdfUlVTVCkgKz0gZXhw b3J0c19jb3JlX2dlbmVyYXRlZC5oCisKKyMgTWlzc2luZyBwcm90b3R5cGVzIGFyZSBleHBlY3Rl ZCBpbiB0aGUgaGVscGVycyBzaW5jZSB0aGVzZSBhcmUgZXhwb3J0ZWQKKyMgZm9yIFJ1c3Qgb25s eSwgdGh1cyB0aGVyZSBpcyBubyBoZWFkZXIgbm9yIHByb3RvdHlwZXMuCitvYmotJChDT05GSUdf UlVTVCkgKz0gaGVscGVycy5vCitDRkxBR1NfUkVNT1ZFX2hlbHBlcnMubyA9IC1XbWlzc2luZy1w cm90b3R5cGVzIC1XbWlzc2luZy1kZWNsYXJhdGlvbnMKKworYWx3YXlzLSQoQ09ORklHX1JVU1Qp ICs9IGxpYm1hY3Jvcy5zbworbm8tY2xlYW4tZmlsZXMgKz0gbGlibWFjcm9zLnNvCisKK2Fsd2F5 cy0kKENPTkZJR19SVVNUKSArPSBiaW5kaW5ncy9iaW5kaW5nc19nZW5lcmF0ZWQucnMgYmluZGlu Z3MvYmluZGluZ3NfaGVscGVyc19nZW5lcmF0ZWQucnMKK29iai0kKENPTkZJR19SVVNUKSArPSBh bGxvYy5vIGJpbmRpbmdzLm8ga2VybmVsLm8KK2Fsd2F5cy0kKENPTkZJR19SVVNUKSArPSBleHBv cnRzX2FsbG9jX2dlbmVyYXRlZC5oIGV4cG9ydHNfYmluZGluZ3NfZ2VuZXJhdGVkLmggXAorICAg IGV4cG9ydHNfa2VybmVsX2dlbmVyYXRlZC5oCisKK2lmZGVmIENPTkZJR19SVVNUX0JVSUxEX0FT U0VSVF9ERU5ZCithbHdheXMtJChDT05GSUdfUlVTVCkgKz0gYnVpbGRfZXJyb3IubworZWxzZQor b2JqLSQoQ09ORklHX1JVU1QpICs9IGJ1aWxkX2Vycm9yLm8KK2VuZGlmCisKK29iai0kKENPTkZJ R19SVVNUKSArPSBleHBvcnRzLm8KKworb2JqLSQoQ09ORklHX1JVU1RfS0VSTkVMX0tVTklUX1RF U1QpICs9IGRvY3Rlc3RzX2tlcm5lbF9nZW5lcmF0ZWQubworb2JqLSQoQ09ORklHX1JVU1RfS0VS TkVMX0tVTklUX1RFU1QpICs9IGRvY3Rlc3RzX2tlcm5lbF9nZW5lcmF0ZWRfa3VuaXQubworCisj IEF2b2lkcyBydW5uaW5nIGAkKFJVU1RDKWAgZm9yIHRoZSBzeXNyb290IHdoZW4gaXQgbWF5IG5v dCBiZSBhdmFpbGFibGUuCitpZmRlZiBDT05GSUdfUlVTVAorCisjIGAkKHJ1c3RfZmxhZ3MpYCBp cyBwYXNzZWQgaW4gY2FzZSB0aGUgdXNlciBhZGRlZCBgLS1zeXNyb290YC4KK3J1c3RjX3N5c3Jv b3QgOj0gJChzaGVsbCAkKFJVU1RDKSAkKHJ1c3RfZmxhZ3MpIC0tcHJpbnQgc3lzcm9vdCkKK3J1 c3RjX2hvc3RfdGFyZ2V0IDo9ICQoc2hlbGwgJChSVVNUQykgLS12ZXJzaW9uIC0tdmVyYm9zZSB8 IGdyZXAgLUYgJ2hvc3Q6ICcgfCBjdXQgLWQnICcgLWYyKQorUlVTVF9MSUJfU1JDID89ICQocnVz dGNfc3lzcm9vdCkvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeQorCitpZmVxICgkKHF1aWV0 KSxzaWxlbnRfKQorY2FyZ29fcXVpZXQ9LXEKK3J1c3RfdGVzdF9xdWlldD0tcQorcnVzdGRvY190 ZXN0X3F1aWV0PS0tdGVzdC1hcmdzIC1xCitydXN0ZG9jX3Rlc3Rfa2VybmVsX3F1aWV0PT4vZGV2 L251bGwKK2Vsc2UgaWZlcSAoJChxdWlldCkscXVpZXRfKQorcnVzdF90ZXN0X3F1aWV0PS1xCity dXN0ZG9jX3Rlc3RfcXVpZXQ9LS10ZXN0LWFyZ3MgLXEKK3J1c3Rkb2NfdGVzdF9rZXJuZWxfcXVp ZXQ9Pi9kZXYvbnVsbAorZWxzZQorY2FyZ29fcXVpZXQ9LS12ZXJib3NlCitlbmRpZgorCitjb3Jl LWNmZ3MgPSBcCisgICAgLS1jZmcgbm9fZnBfZm10X3BhcnNlCisKK2FsbG9jLWNmZ3MgPSBcCisg ICAgLS1jZmcgbm9fZ2xvYmFsX29vbV9oYW5kbGluZyBcCisgICAgLS1jZmcgbm9fcmMgXAorICAg IC0tY2ZnIG5vX3N5bmMKKworcXVpZXRfY21kX3J1c3Rkb2MgPSBSVVNURE9DICQoaWYgJChydXN0 ZG9jX2hvc3QpLEgsICkgJDwKKyAgICAgIGNtZF9ydXN0ZG9jID0gXAorCU9CSlRSRUU9JChhYnNw YXRoICQob2JqdHJlZSkpIFwKKwkkKFJVU1RET0MpICQoaWYgJChydXN0ZG9jX2hvc3QpLCQocnVz dF9jb21tb25fZmxhZ3MpLCQocnVzdF9mbGFncykpIFwKKwkJJChydXN0Y190YXJnZXRfZmxhZ3Mp IC1MJChvYmp0cmVlKS8kKG9iaikgXAorCQktLW91dHB1dCAkKG9ianRyZWUpLyQob2JqKS9kb2Mg XAorCQktLWNyYXRlLW5hbWUgJChzdWJzdCBydXN0ZG9jLSwsJEApIFwKKwkJQCQob2JqdHJlZSkv aW5jbHVkZS9nZW5lcmF0ZWQvcnVzdGNfY2ZnICQ8CisKKyMgVGhlIGBodG1sX2xvZ29fdXJsYCBh bmQgYGh0bWxfZmF2aWNvbl91cmxgIGZvcm1zIG9mIHRoZSBgZG9jYCBhdHRyaWJ1dGUKKyMgY2Fu IGJlIHVzZWQgdG8gc3BlY2lmeSBhIGN1c3RvbSBsb2dvLiBIb3dldmVyOgorIyAgIC0gVGhlIGdp dmVuIHZhbHVlIGlzIHVzZWQgYXMtaXMsIHRodXMgaXQgY2Fubm90IGJlIHJlbGF0aXZlIG9yIGEg bG9jYWwgZmlsZQorIyAgICAgKHVubGlrZSB0aGUgbm9uLWN1c3RvbSBjYXNlKSBzaW5jZSB0aGUg Z2VuZXJhdGVkIGRvY3MgaGF2ZSBzdWJmb2xkZXJzLgorIyAgIC0gSXQgcmVxdWlyZXMgYWRkaW5n IGl0IHRvIGV2ZXJ5IGNyYXRlLgorIyAgIC0gSXQgcmVxdWlyZXMgY2hhbmdpbmcgYGNvcmVgIHdo aWNoIGNvbWVzIGZyb20gdGhlIHN5c3Jvb3QuCisjCisjIFVzaW5nIGAtWmNyYXRlLWF0dHJgIHdv dWxkIHNvbHZlIHRoZSBsYXN0IHR3byBwb2ludHMsIGJ1dCBub3QgdGhlIGZpcnN0LgorIyBUaGUg aHR0cHM6Ly9naXRodWIuY29tL3J1c3QtbGFuZy9yZmNzL3B1bGwvMzIyNiBSRkMgc3VnZ2VzdHMg dHdvIG5ldworIyBjb21tYW5kLWxpa2UgZmxhZ3MgdG8gc29sdmUgdGhlIGlzc3VlLiBNZWFud2hp bGUsIHdlIHVzZSB0aGUgbm9uLWN1c3RvbSBjYXNlCisjIGFuZCB0aGVuIHJldG91Y2ggdGhlIGdl bmVyYXRlZCBmaWxlcy4KK3J1c3Rkb2M6IHJ1c3Rkb2MtY29yZSBydXN0ZG9jLW1hY3JvcyBydXN0 ZG9jLWNvbXBpbGVyX2J1aWx0aW5zIFwKKyAgICBydXN0ZG9jLWFsbG9jIHJ1c3Rkb2Mta2VybmVs CisJJChRKWNwICQoc3JjdHJlZSkvRG9jdW1lbnRhdGlvbi9pbWFnZXMvbG9nby5zdmcgJChvYmp0 cmVlKS8kKG9iaikvZG9jCisJJChRKWNwICQoc3JjdHJlZSkvRG9jdW1lbnRhdGlvbi9pbWFnZXMv Q09QWUlORy1sb2dvICQob2JqdHJlZSkvJChvYmopL2RvYworCSQoUSlmaW5kICQob2JqdHJlZSkv JChvYmopL2RvYyAtbmFtZSAnKi5odG1sJyAtdHlwZSBmIC1wcmludDAgfCB4YXJncyAtMCBzZWQg LUVpIFwKKwkJLWUgJ3M6cnVzdC1sb2dvXC5zdmc6bG9nby5zdmc6ZycgXAorCQktZSAnczpydXN0 LWxvZ29cLnBuZzpsb2dvLnN2ZzpnJyBcCisJCS1lICdzOmZhdmljb25cLnN2Zzpsb2dvLnN2Zzpn JyBcCisJCS1lICdzOjxsaW5rIHJlbD0iYWx0ZXJuYXRlIGljb24iIHR5cGU9ImltYWdlL3BuZyIg aHJlZj0iWy4vXSpmYXZpY29uLSgxNngxNnwzMngzMilcLnBuZyI+OjpnJworCSQoUSllY2hvICcu bG9nby1jb250YWluZXIgPiBpbWcgeyBvYmplY3QtZml0OiBjb250YWluOyB9JyBcCisJCT4+ICQo b2JqdHJlZSkvJChvYmopL2RvYy9ydXN0ZG9jLmNzcworCitydXN0ZG9jLW1hY3JvczogcHJpdmF0 ZSBydXN0ZG9jX2hvc3QgPSB5ZXMKK3J1c3Rkb2MtbWFjcm9zOiBwcml2YXRlIHJ1c3RjX3Rhcmdl dF9mbGFncyA9IC0tY3JhdGUtdHlwZSBwcm9jLW1hY3JvIFwKKyAgICAtLWV4dGVybiBwcm9jX21h Y3JvCitydXN0ZG9jLW1hY3JvczogJChzcmMpL21hY3Jvcy9saWIucnMgRk9SQ0UKKwkkKGNhbGwg aWZfY2hhbmdlZCxydXN0ZG9jKQorCitydXN0ZG9jLWNvcmU6IHByaXZhdGUgcnVzdGNfdGFyZ2V0 X2ZsYWdzID0gJChjb3JlLWNmZ3MpCitydXN0ZG9jLWNvcmU6ICQoUlVTVF9MSUJfU1JDKS9jb3Jl L3NyYy9saWIucnMgRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxydXN0ZG9jKQorCitydXN0ZG9j LWNvbXBpbGVyX2J1aWx0aW5zOiAkKHNyYykvY29tcGlsZXJfYnVpbHRpbnMucnMgcnVzdGRvYy1j b3JlIEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWQscnVzdGRvYykKKworIyBXZSBuZWVkIHRvIGFs bG93IGBydXN0ZG9jOjpicm9rZW5faW50cmFfZG9jX2xpbmtzYCBiZWNhdXNlIHNvbWUKKyMgYG5v X2dsb2JhbF9vb21faGFuZGxpbmdgIGZ1bmN0aW9ucyByZWZlciB0byBub24tYG5vX2dsb2JhbF9v b21faGFuZGxpbmdgCisjIGZ1bmN0aW9ucy4gSWRlYWxseSBgcnVzdGRvY2Agd291bGQgaGF2ZSBh IHdheSB0byBkaXN0aW5ndWlzaCBicm9rZW4gbGlua3MKKyMgZHVlIHRvIHRoaW5ncyB0aGF0IGFy ZSAiY29uZmlndXJlZCBvdXQiIHZzLiBlbnRpcmVseSBub24tZXhpc3Rpbmcgb25lcy4KK3J1c3Rk b2MtYWxsb2M6IHByaXZhdGUgcnVzdGNfdGFyZ2V0X2ZsYWdzID0gJChhbGxvYy1jZmdzKSBcCisg ICAgLUFydXN0ZG9jOjpicm9rZW5faW50cmFfZG9jX2xpbmtzCitydXN0ZG9jLWFsbG9jOiAkKHNy YykvYWxsb2MvbGliLnJzIHJ1c3Rkb2MtY29yZSBydXN0ZG9jLWNvbXBpbGVyX2J1aWx0aW5zIEZP UkNFCisJJChjYWxsIGlmX2NoYW5nZWQscnVzdGRvYykKKworcnVzdGRvYy1rZXJuZWw6IHByaXZh dGUgcnVzdGNfdGFyZ2V0X2ZsYWdzID0gLS1leHRlcm4gYWxsb2MgXAorICAgIC0tZXh0ZXJuIGJ1 aWxkX2Vycm9yIC0tZXh0ZXJuIG1hY3Jvcz0kKG9ianRyZWUpLyQob2JqKS9saWJtYWNyb3Muc28g XAorICAgIC0tZXh0ZXJuIGJpbmRpbmdzCitydXN0ZG9jLWtlcm5lbDogJChzcmMpL2tlcm5lbC9s aWIucnMgcnVzdGRvYy1jb3JlIHJ1c3Rkb2MtbWFjcm9zIFwKKyAgICBydXN0ZG9jLWNvbXBpbGVy X2J1aWx0aW5zIHJ1c3Rkb2MtYWxsb2MgJChvYmopL2xpYm1hY3Jvcy5zbyBcCisgICAgJChvYmop L2JpbmRpbmdzLm8gRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxydXN0ZG9jKQorCitxdWlldF9j bWRfcnVzdGNfdGVzdF9saWJyYXJ5ID0gUlVTVEMgVEwgJDwKKyAgICAgIGNtZF9ydXN0Y190ZXN0 X2xpYnJhcnkgPSBcCisJT0JKVFJFRT0kKGFic3BhdGggJChvYmp0cmVlKSkgXAorCSQoUlVTVEMp ICQocnVzdF9jb21tb25fZmxhZ3MpIFwKKwkJQCQob2JqdHJlZSkvaW5jbHVkZS9nZW5lcmF0ZWQv cnVzdGNfY2ZnICQocnVzdGNfdGFyZ2V0X2ZsYWdzKSBcCisJCS0tY3JhdGUtdHlwZSAkKGlmICQo cnVzdGNfdGVzdF9saWJyYXJ5X3Byb2MpLHByb2MtbWFjcm8scmxpYikgXAorCQktLW91dC1kaXIg JChvYmp0cmVlKS8kKG9iaikvdGVzdCAtLWNmZyB0ZXN0bGliIFwKKwkJLS1zeXNyb290ICQob2Jq dHJlZSkvJChvYmopL3Rlc3Qvc3lzcm9vdCBcCisJCS1MJChvYmp0cmVlKS8kKG9iaikvdGVzdCBc CisJCS0tY3JhdGUtbmFtZSAkKHN1YnN0IHJ1c3R0ZXN0LSwsJChzdWJzdCBydXN0dGVzdGxpYi0s LCRAKSkgJDwKKworcnVzdHRlc3RsaWItYnVpbGRfZXJyb3I6ICQoc3JjKS9idWlsZF9lcnJvci5y cyBydXN0dGVzdC1wcmVwYXJlIEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWQscnVzdGNfdGVzdF9s aWJyYXJ5KQorCitydXN0dGVzdGxpYi1tYWNyb3M6IHByaXZhdGUgcnVzdGNfdGFyZ2V0X2ZsYWdz ID0gLS1leHRlcm4gcHJvY19tYWNybworcnVzdHRlc3RsaWItbWFjcm9zOiBwcml2YXRlIHJ1c3Rj X3Rlc3RfbGlicmFyeV9wcm9jID0geWVzCitydXN0dGVzdGxpYi1tYWNyb3M6ICQoc3JjKS9tYWNy b3MvbGliLnJzIHJ1c3R0ZXN0LXByZXBhcmUgRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxydXN0 Y190ZXN0X2xpYnJhcnkpCisKK3J1c3R0ZXN0bGliLWJpbmRpbmdzOiAkKHNyYykvYmluZGluZ3Mv bGliLnJzIHJ1c3R0ZXN0LXByZXBhcmUgRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxydXN0Y190 ZXN0X2xpYnJhcnkpCisKK3F1aWV0X2NtZF9ydXN0ZG9jX3Rlc3QgPSBSVVNURE9DIFQgJDwKKyAg ICAgIGNtZF9ydXN0ZG9jX3Rlc3QgPSBcCisJT0JKVFJFRT0kKGFic3BhdGggJChvYmp0cmVlKSkg XAorCSQoUlVTVERPQykgLS10ZXN0ICQocnVzdF9jb21tb25fZmxhZ3MpIFwKKwkJQCQob2JqdHJl ZSkvaW5jbHVkZS9nZW5lcmF0ZWQvcnVzdGNfY2ZnIFwKKwkJJChydXN0Y190YXJnZXRfZmxhZ3Mp ICQocnVzdGRvY190ZXN0X3RhcmdldF9mbGFncykgXAorCQktLXN5c3Jvb3QgJChvYmp0cmVlKS8k KG9iaikvdGVzdC9zeXNyb290ICQocnVzdGRvY190ZXN0X3F1aWV0KSBcCisJCS1MJChvYmp0cmVl KS8kKG9iaikvdGVzdCAtLW91dHB1dCAkKG9ianRyZWUpLyQob2JqKS9kb2MgXAorCQktLWNyYXRl LW5hbWUgJChzdWJzdCBydXN0dGVzdC0sLCRAKSAkPAorCitxdWlldF9jbWRfcnVzdGRvY190ZXN0 X2tlcm5lbCA9IFJVU1RET0MgVEsgJDwKKyAgICAgIGNtZF9ydXN0ZG9jX3Rlc3Rfa2VybmVsID0g XAorCXJtIC1yZiAkKG9ianRyZWUpLyQob2JqKS90ZXN0L2RvY3Rlc3RzL2tlcm5lbDsgXAorCW1r ZGlyIC1wICQob2JqdHJlZSkvJChvYmopL3Rlc3QvZG9jdGVzdHMva2VybmVsOyBcCisJT0JKVFJF RT0kKGFic3BhdGggJChvYmp0cmVlKSkgXAorCSQoUlVTVERPQykgLS10ZXN0ICQocnVzdF9mbGFn cykgXAorCQlAJChvYmp0cmVlKS9pbmNsdWRlL2dlbmVyYXRlZC9ydXN0Y19jZmcgXAorCQktTCQo b2JqdHJlZSkvJChvYmopIC0tZXh0ZXJuIGFsbG9jIC0tZXh0ZXJuIGtlcm5lbCBcCisJCS0tZXh0 ZXJuIGJ1aWxkX2Vycm9yIC0tZXh0ZXJuIG1hY3JvcyBcCisJCS0tZXh0ZXJuIGJpbmRpbmdzIFwK KwkJLS1uby1ydW4gLS1jcmF0ZS1uYW1lIGtlcm5lbCAtWnVuc3RhYmxlLW9wdGlvbnMgXAorCQkt LXRlc3QtYnVpbGRlciAkKHNyY3RyZWUpL3NjcmlwdHMvcnVzdGRvY190ZXN0X2J1aWxkZXIucHkg XAorCQkkPCAkKHJ1c3Rkb2NfdGVzdF9rZXJuZWxfcXVpZXQpOyBcCisJJChzcmN0cmVlKS9zY3Jp cHRzL3J1c3Rkb2NfdGVzdF9nZW4ucHkKKworJS9kb2N0ZXN0c19rZXJuZWxfZ2VuZXJhdGVkLnJz ICUvZG9jdGVzdHNfa2VybmVsX2dlbmVyYXRlZF9rdW5pdC5jOiAkKHNyYykva2VybmVsL2xpYi5y cyAkKG9iaikva2VybmVsLm8gRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxydXN0ZG9jX3Rlc3Rf a2VybmVsKQorCisjIFdlIGNhbm5vdCB1c2UgYC1acGFuaWMtYWJvcnQtdGVzdHNgIGJlY2F1c2Ug c29tZSB0ZXN0cyBhcmUgZHluYW1pYywKKyMgc28gZm9yIHRoZSBtb21lbnQgd2Ugc2tpcCBgLUNw YW5pYz1hYm9ydGAuCitxdWlldF9jbWRfcnVzdGNfdGVzdCA9IFJVU1RDIFQgICQ8CisgICAgICBj bWRfcnVzdGNfdGVzdCA9IFwKKwlPQkpUUkVFPSQoYWJzcGF0aCAkKG9ianRyZWUpKSBcCisJJChS VVNUQykgLS10ZXN0ICQocnVzdF9jb21tb25fZmxhZ3MpIFwKKwkJQCQob2JqdHJlZSkvaW5jbHVk ZS9nZW5lcmF0ZWQvcnVzdGNfY2ZnIFwKKwkJJChydXN0Y190YXJnZXRfZmxhZ3MpIC0tb3V0LWRp ciAkKG9ianRyZWUpLyQob2JqKS90ZXN0IFwKKwkJLS1zeXNyb290ICQob2JqdHJlZSkvJChvYmop L3Rlc3Qvc3lzcm9vdCBcCisJCS1MJChvYmp0cmVlKS8kKG9iaikvdGVzdCBcCisJCS0tY3JhdGUt bmFtZSAkKHN1YnN0IHJ1c3R0ZXN0LSwsJEApICQ8OyBcCisJJChvYmp0cmVlKS8kKG9iaikvdGVz dC8kKHN1YnN0IHJ1c3R0ZXN0LSwsJEApICQocnVzdF90ZXN0X3F1aWV0KSBcCisJCSQocnVzdGNf dGVzdF9ydW5fZmxhZ3MpCisKK3J1c3R0ZXN0OiBydXN0dGVzdC1tYWNyb3MgcnVzdHRlc3Qta2Vy bmVsCisKKyMgVGhpcyBwcmVwYXJlcyBhIGN1c3RvbSBzeXNyb290IHdpdGggb3VyIGN1c3RvbSBg YWxsb2NgIGluc3RlYWQgb2YKKyMgdGhlIHN0YW5kYXJkIG9uZS4KKyMKKyMgVGhpcyByZXF1aXJl cyBzZXZlcmFsIGhhY2tzOgorIyAgIC0gVW5saWtlIGBjb3JlYCBhbmQgYGFsbG9jYCwgYHN0ZGAg ZGVwZW5kcyBvbiBtb3JlIHRoYW4gYSBkb3plbiBjcmF0ZXMsCisjICAgICBpbmNsdWRpbmcgdGhp cmQtcGFydHkgY3JhdGVzIHRoYXQgbmVlZCB0byBiZSBkb3dubG9hZGVkLCBwbHVzIGN1c3RvbQor IyAgICAgYGJ1aWxkLnJzYCBzdGVwcy4gVGh1cyBoYXJkY29kaW5nIHRoaW5ncyBoZXJlIGlzIG5v dCBtYWludGFpbmFibGUuCisjICAgLSBgY2FyZ29gIGtub3dzIGhvdyB0byBidWlsZCB0aGUgc3Rh bmRhcmQgbGlicmFyeSwgYnV0IGl0IGlzIGFuIHVuc3RhYmxlCisjICAgICBmZWF0dXJlIHNvIGZh ciAoYC1aYnVpbGQtc3RkYCkuCisjICAgLSBgY2FyZ29gIG9ubHkgY29uc2lkZXJzIHRoZSB1c2Ug Y2FzZSBvZiBidWlsZGluZyB0aGUgc3RhbmRhcmQgbGlicmFyeQorIyAgICAgdG8gdXNlIGl0IGlu IGEgZ2l2ZW4gcGFja2FnZS4gVGh1cyB3ZSBuZWVkIHRvIGNyZWF0ZSBhIGR1bW15IHBhY2thZ2UK KyMgICAgIGFuZCBwaWNrIHRoZSBnZW5lcmF0ZWQgbGlicmFyaWVzIGZyb20gdGhlcmUuCisjICAg LSBTaW5jZSB3ZSBvbmx5IGtlZXAgYSBzdWJzZXQgb2YgdXBzdHJlYW0gYGFsbG9jYCBpbi10cmVl LCB3ZSBuZWVkCisjICAgICB0byByZWNyZWF0ZSBpdCBvbiB0aGUgZmx5IGJ5IHB1dHRpbmcgb3Vy IHNvdXJjZXMgb24gdG9wLgorIyAgIC0gVGhlIHVzdWFsIHdheXMgb2YgbW9kaWZ5aW5nIHRoZSBk ZXBlbmRlbmN5IGdyYXBoIGluIGBjYXJnb2AgZG8gbm90IHNlZW0KKyMgICAgIHRvIGFwcGx5IGZv ciB0aGUgYC1aYnVpbGQtc3RkYCBzdGVwcywgdGh1cyB3ZSBoYXZlIHRvIG1pc2xlYWQgaXQKKyMg ICAgIGJ5IG1vZGlmeWluZyB0aGUgc291cmNlcyBpbiB0aGUgc3lzcm9vdC4KKyMgICAtIFRvIGF2 b2lkIG1lc3Npbmcgd2l0aCB0aGUgdXNlcidzIFJ1c3QgaW5zdGFsbGF0aW9uLCB3ZSBjcmVhdGUg YSBjbG9uZQorIyAgICAgb2YgdGhlIHN5c3Jvb3QuIEhvd2V2ZXIsIGBjYXJnb2AgaWdub3JlcyBg UlVTVEZMQUdTYCBpbiB0aGUgYC1aYnVpbGQtc3RkYAorIyAgICAgc3RlcHMsIHRodXMgd2UgdXNl IGEgd3JhcHBlciBiaW5hcnkgcGFzc2VkIHZpYSBgUlVTVENgIHRvIHBhc3MgdGhlIGZsYWcuCisj CisjIEluIHRoZSBmdXR1cmUsIHdlIGhvcGUgdG8gYXZvaWQgdGhlIHdob2xlIG9yZGVhbCBieSBl aXRoZXI6CisjICAgLSBNYWtpbmcgdGhlIGB0ZXN0YCBjcmF0ZSBub3QgZGVwZW5kIG9uIGBzdGRg IChlaXRoZXIgaW1wcm92aW5nIHVwc3RyZWFtCisjICAgICBvciBoYXZpbmcgb3VyIG93biBjdXN0 b20gY3JhdGUpLgorIyAgIC0gTWFraW5nIHRoZSB0ZXN0cyBydW4gaW4ga2VybmVsIHNwYWNlIChy ZXF1aXJlcyB0aGUgcHJldmlvdXMgcG9pbnQpLgorIyAgIC0gTWFraW5nIGBzdGRgIGFuZCBmcmll bmRzIGJlIG1vcmUgbGlrZSBhICJub3JtYWwiIGNyYXRlLCBzbyB0aGF0CisjICAgICBgLVpidWls ZC1zdGRgIGFuZCByZWxhdGVkIGhhY2tzIGFyZSBub3QgbmVlZGVkLgorcXVpZXRfY21kX3J1c3Rz eXNyb290ID0gUlVTVFNZU1JPT1QKKyAgICAgIGNtZF9ydXN0c3lzcm9vdCA9IFwKKwlybSAtcmYg JChvYmp0cmVlKS8kKG9iaikvdGVzdDsgXAorCW1rZGlyIC1wICQob2JqdHJlZSkvJChvYmopL3Rl c3Q7IFwKKwljcCAtYSAkKHJ1c3RjX3N5c3Jvb3QpICQob2JqdHJlZSkvJChvYmopL3Rlc3Qvc3lz cm9vdDsgXAorCWNwIC1yICQoc3JjdHJlZSkvJChzcmMpL2FsbG9jLyogXAorCQkkKG9ianRyZWUp LyQob2JqKS90ZXN0L3N5c3Jvb3QvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9z cmM7IFwKKwllY2hvICdcIyEvYmluL3NoJyA+ICQob2JqdHJlZSkvJChvYmopL3Rlc3QvcnVzdGNf c3lzcm9vdDsgXAorCWVjaG8gIiQoUlVTVEMpIC0tc3lzcm9vdD0kKGFic3BhdGggJChvYmp0cmVl KS8kKG9iaikvdGVzdC9zeXNyb290KSBcIlwkJEBcIiIgXAorCQk+PiAkKG9ianRyZWUpLyQob2Jq KS90ZXN0L3J1c3RjX3N5c3Jvb3Q7IFwKKwljaG1vZCB1K3ggJChvYmp0cmVlKS8kKG9iaikvdGVz dC9ydXN0Y19zeXNyb290OyBcCisJJChDQVJHTykgLXEgbmV3ICQob2JqdHJlZSkvJChvYmopL3Rl c3QvZHVtbXk7IFwKKwlSVVNUQz0kKG9ianRyZWUpLyQob2JqKS90ZXN0L3J1c3RjX3N5c3Jvb3Qg JChDQVJHTykgJChjYXJnb19xdWlldCkgXAorCQl0ZXN0IC1aYnVpbGQtc3RkIC0tdGFyZ2V0ICQo cnVzdGNfaG9zdF90YXJnZXQpIFwKKwkJLS1tYW5pZmVzdC1wYXRoICQob2JqdHJlZSkvJChvYmop L3Rlc3QvZHVtbXkvQ2FyZ28udG9tbDsgXAorCXJtICQob2JqdHJlZSkvJChvYmopL3Rlc3Qvc3lz cm9vdC9saWIvcnVzdGxpYi8kKHJ1c3RjX2hvc3RfdGFyZ2V0KS9saWIvKjsgXAorCWNwICQob2Jq dHJlZSkvJChvYmopL3Rlc3QvZHVtbXkvdGFyZ2V0LyQocnVzdGNfaG9zdF90YXJnZXQpL2RlYnVn L2RlcHMvKiBcCisJCSQob2JqdHJlZSkvJChvYmopL3Rlc3Qvc3lzcm9vdC9saWIvcnVzdGxpYi8k KHJ1c3RjX2hvc3RfdGFyZ2V0KS9saWIKKworcnVzdHRlc3QtcHJlcGFyZTogRk9SQ0UKKwkkKGNh bGwgaWZfY2hhbmdlZCxydXN0c3lzcm9vdCkKKworcnVzdHRlc3QtbWFjcm9zOiBwcml2YXRlIHJ1 c3RjX3RhcmdldF9mbGFncyA9IC0tZXh0ZXJuIHByb2NfbWFjcm8KK3J1c3R0ZXN0LW1hY3Jvczog cHJpdmF0ZSBydXN0ZG9jX3Rlc3RfdGFyZ2V0X2ZsYWdzID0gLS1jcmF0ZS10eXBlIHByb2MtbWFj cm8KK3J1c3R0ZXN0LW1hY3JvczogJChzcmMpL21hY3Jvcy9saWIucnMgcnVzdHRlc3QtcHJlcGFy ZSBGT1JDRQorCSQoY2FsbCBpZl9jaGFuZ2VkLHJ1c3RjX3Rlc3QpCisJJChjYWxsIGlmX2NoYW5n ZWQscnVzdGRvY190ZXN0KQorCitydXN0dGVzdC1rZXJuZWw6IHByaXZhdGUgcnVzdGNfdGFyZ2V0 X2ZsYWdzID0gLS1leHRlcm4gYWxsb2MgXAorICAgIC0tZXh0ZXJuIGJ1aWxkX2Vycm9yIC0tZXh0 ZXJuIG1hY3JvcyAtLWV4dGVybiBiaW5kaW5ncworcnVzdHRlc3Qta2VybmVsOiAkKHNyYykva2Vy bmVsL2xpYi5ycyBydXN0dGVzdC1wcmVwYXJlIFwKKyAgICBydXN0dGVzdGxpYi1idWlsZF9lcnJv ciBydXN0dGVzdGxpYi1tYWNyb3MgcnVzdHRlc3RsaWItYmluZGluZ3MgRk9SQ0UKKwkkKGNhbGwg aWZfY2hhbmdlZCxydXN0Y190ZXN0KQorCSQoY2FsbCBpZl9jaGFuZ2VkLHJ1c3RjX3Rlc3RfbGli cmFyeSkKKworZmlsZWNoa19ydXN0X3RhcmdldCA9ICQob2JqdHJlZSkvc2NyaXB0cy9nZW5lcmF0 ZV9ydXN0X3RhcmdldCA8ICQ8CisKKyQob2JqKS90YXJnZXQuanNvbjogJChvYmp0cmVlKS9pbmNs dWRlL2NvbmZpZy9hdXRvLmNvbmYgRk9SQ0UKKwkkKGNhbGwgZmlsZWNoayxydXN0X3RhcmdldCkK KworaWZkZWYgQ09ORklHX0NDX0lTX0NMQU5HCitiaW5kZ2VuX2NfZmxhZ3MgPSAkKGNfZmxhZ3Mp CitlbHNlCisjIGJpbmRnZW4gcmVsaWVzIG9uIGxpYmNsYW5nIHRvIHBhcnNlIEMuIElkZWFsbHks IGJpbmRnZW4gd291bGQgc3VwcG9ydCBhIEdDQworIyBwbHVnaW4gYmFja2VuZCBhbmQvb3IgdGhl IENsYW5nIGRyaXZlciB3b3VsZCBiZSBwZXJmZWN0bHkgY29tcGF0aWJsZSB3aXRoIEdDQy4KKyMK KyMgRm9yIHRoZSBtb21lbnQsIGhlcmUgd2UgYXJlIHR3ZWFraW5nIHRoZSBmbGFncyBvbiB0aGUg Zmx5LiBUaGlzIGlzIGEgaGFjaywKKyMgYW5kIHNvbWUga2VybmVsIGNvbmZpZ3VyYXRpb25zIG1h eSBub3Qgd29yayAoZS5nLiBgR0NDX1BMVUdJTl9SQU5EU1RSVUNUYAorIyBpZiB3ZSBlbmQgdXAg dXNpbmcgb25lIG9mIHRob3NlIHN0cnVjdHMpLgorYmluZGdlbl9za2lwX2NfZmxhZ3MgOj0gLW1u by1mcC1yZXQtaW4tMzg3IC1tcHJlZmVycmVkLXN0YWNrLWJvdW5kYXJ5PSUgXAorCS1tc2tpcC1y YXgtc2V0dXAgLW1nZW5lcmFsLXJlZ3Mtb25seSAtbXNpZ24tcmV0dXJuLWFkZHJlc3M9JSBcCisJ LW1pbmRpcmVjdC1icmFuY2g9dGh1bmstZXh0ZXJuIC1taW5kaXJlY3QtYnJhbmNoLXJlZ2lzdGVy IFwKKwktbWZ1bmN0aW9uLXJldHVybj10aHVuay1leHRlcm4gLW1yZWNvcmQtbWNvdW50IC1tYWJp PWxwNjQgXAorCS1tc3RhY2stcHJvdGVjdG9yLWd1YXJkJSAtbXRyYWNlYmFjaz1ubyBcCisJLW1u by1wb2ludGVycy10by1uZXN0ZWQtZnVuY3Rpb25zIC1tbm8tc3RyaW5nIFwKKwktbW5vLXN0cmlj dC1hbGlnbiAtbXN0cmljdC1hbGlnbiBcCisJLWZjb25zZXJ2ZS1zdGFjayAtZmFsaWduLWp1bXBz PSUgLWZhbGlnbi1sb29wcz0lIFwKKwktZmVtaXQtc3RydWN0LWRlYnVnLWJhc2Vvbmx5IC1mbm8t aXBhLWNwLWNsb25lIC1mbm8taXBhLXNyYSBcCisJLWZuby1wYXJ0aWFsLWlubGluaW5nIC1mcGx1 Z2luLWFyZy1hcm1fc3NwX3Blcl90YXNrX3BsdWdpbi0lIFwKKwktZm5vLXJlb3JkZXItYmxvY2tz IC1mbm8tYWxsb3ctc3RvcmUtZGF0YS1yYWNlcyAtZmFzYW4tc2hhZG93LW9mZnNldD0lIFwKKwkt Znplcm8tY2FsbC11c2VkLXJlZ3M9JSAtZm5vLXN0YWNrLWNsYXNoLXByb3RlY3Rpb24gXAorCS1m bm8taW5saW5lLWZ1bmN0aW9ucy1jYWxsZWQtb25jZSBcCisJLS1wYXJhbT0lIC0tcGFyYW0gYXNh bi0lCisKKyMgRGVyaXZlZCBmcm9tIGBzY3JpcHRzL01ha2VmaWxlLmNsYW5nYC4KK0JJTkRHRU5f VEFSR0VUX2FybQk6PSBhcm0tbGludXgtZ251ZWFiaQorQklOREdFTl9UQVJHRVRfYXJtNjQJOj0g YWFyY2g2NC1saW51eC1nbnUKK0JJTkRHRU5fVEFSR0VUX3Bvd2VycGMJOj0gcG93ZXJwYzY0bGUt bGludXgtZ251CitCSU5ER0VOX1RBUkdFVF9yaXNjdgk6PSByaXNjdjY0LWxpbnV4LWdudQorQklO REdFTl9UQVJHRVRfeDg2CTo9IHg4Nl82NC1saW51eC1nbnUKK0JJTkRHRU5fVEFSR0VUCQk6PSAk KEJJTkRHRU5fVEFSR0VUXyQoU1JDQVJDSCkpCisKKyMgQWxsIHdhcm5pbmdzIGFyZSBpbmhpYml0 ZWQgc2luY2UgR0NDIGJ1aWxkcyBhcmUgdmVyeSBleHBlcmltZW50YWwsCisjIG1hbnkgR0NDIHdh cm5pbmdzIGFyZSBub3Qgc3VwcG9ydGVkIGJ5IENsYW5nLCB0aGV5IG1heSBvbmx5IGFwcGVhciBp bgorIyBzb21lIGNvbmZpZ3VyYXRpb25zLCB3aXRoIG5ldyBHQ0MgdmVyc2lvbnMsIGV0Yy4KK2Jp bmRnZW5fZXh0cmFfY19mbGFncyA9IC13IC0tdGFyZ2V0PSQoQklOREdFTl9UQVJHRVQpCisKK2Jp bmRnZW5fY19mbGFncyA9ICQoZmlsdGVyLW91dCAkKGJpbmRnZW5fc2tpcF9jX2ZsYWdzKSwgJChj X2ZsYWdzKSkgXAorCSQoYmluZGdlbl9leHRyYV9jX2ZsYWdzKQorZW5kaWYKKworaWZkZWYgQ09O RklHX0xUTworYmluZGdlbl9jX2ZsYWdzX2x0byA9ICQoZmlsdGVyLW91dCAkKENDX0ZMQUdTX0xU TyksICQoYmluZGdlbl9jX2ZsYWdzKSkKK2Vsc2UKK2JpbmRnZW5fY19mbGFnc19sdG8gPSAkKGJp bmRnZW5fY19mbGFncykKK2VuZGlmCisKK2JpbmRnZW5fY19mbGFnc19maW5hbCA9ICQoYmluZGdl bl9jX2ZsYWdzX2x0bykgLURfX0JJTkRHRU5fXworCitxdWlldF9jbWRfYmluZGdlbiA9IEJJTkRH RU4gJEAKKyAgICAgIGNtZF9iaW5kZ2VuID0gXAorCSQoQklOREdFTikgJDwgJChiaW5kZ2VuX3Rh cmdldF9mbGFncykgXAorCQktLXVzZS1jb3JlIC0td2l0aC1kZXJpdmUtZGVmYXVsdCAtLWN0eXBl cy1wcmVmaXggY29yZTo6ZmZpIC0tbm8tbGF5b3V0LXRlc3RzIFwKKwkJLS1uby1kZWJ1ZyAnLion IFwKKwkJLS1zaXplX3QtaXMtdXNpemUgLW8gJEAgLS0gJChiaW5kZ2VuX2NfZmxhZ3NfZmluYWwp IC1ETU9EVUxFIFwKKwkJJChiaW5kZ2VuX3RhcmdldF9jZmxhZ3MpICQoYmluZGdlbl90YXJnZXRf ZXh0cmEpCisKKyQob2JqKS9iaW5kaW5ncy9iaW5kaW5nc19nZW5lcmF0ZWQucnM6IHByaXZhdGUg YmluZGdlbl90YXJnZXRfZmxhZ3MgPSBcCisgICAgJChzaGVsbCBncmVwIC12ICdeXCNcfF4kJCcg JChzcmN0cmVlKS8kKHNyYykvYmluZGdlbl9wYXJhbWV0ZXJzKQorJChvYmopL2JpbmRpbmdzL2Jp bmRpbmdzX2dlbmVyYXRlZC5yczogJChzcmMpL2JpbmRpbmdzL2JpbmRpbmdzX2hlbHBlci5oIFwK KyAgICAkKHNyYykvYmluZGdlbl9wYXJhbWV0ZXJzIEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWRf ZGVwLGJpbmRnZW4pCisKKyMgU2VlIGBDRkxBR1NfUkVNT1ZFX2hlbHBlcnMub2AgYWJvdmUuIElu IGFkZGl0aW9uLCBDbGFuZyBvbiBDIGRvZXMgbm90IHdhcm4KKyMgd2l0aCBgLVdtaXNzaW5nLWRl Y2xhcmF0aW9uc2AgKHVubGlrZSBHQ0MpLCBzbyBpdCBpcyBub3Qgc3RyaWN0bHkgbmVlZGVkIGhl cmUKKyMgZ2l2ZW4gaXQgaXMgYGxpYmNsYW5nYDsgYnV0IGZvciBjb25zaXN0ZW5jeSwgZnV0dXJl IENsYW5nIGNoYW5nZXMgYW5kL29yCisjIGEgcG90ZW50aWFsIGZ1dHVyZSBHQ0MgYmFja2VuZCBm b3IgYGJpbmRnZW5gLCB3ZSBkaXNhYmxlIGl0IHRvby4KKyQob2JqKS9iaW5kaW5ncy9iaW5kaW5n c19oZWxwZXJzX2dlbmVyYXRlZC5yczogcHJpdmF0ZSBiaW5kZ2VuX3RhcmdldF9mbGFncyA9IFwK KyAgICAtLWJsYWNrbGlzdC10eXBlICcuKicgLS13aGl0ZWxpc3QtdmFyICcnIFwKKyAgICAtLXdo aXRlbGlzdC1mdW5jdGlvbiAncnVzdF9oZWxwZXJfLionCiskKG9iaikvYmluZGluZ3MvYmluZGlu Z3NfaGVscGVyc19nZW5lcmF0ZWQucnM6IHByaXZhdGUgYmluZGdlbl90YXJnZXRfY2ZsYWdzID0g XAorICAgIC1JJChvYmp0cmVlKS8kKG9iaikgLVduby1taXNzaW5nLXByb3RvdHlwZXMgLVduby1t aXNzaW5nLWRlY2xhcmF0aW9ucworJChvYmopL2JpbmRpbmdzL2JpbmRpbmdzX2hlbHBlcnNfZ2Vu ZXJhdGVkLnJzOiBwcml2YXRlIGJpbmRnZW5fdGFyZ2V0X2V4dHJhID0gOyBcCisgICAgc2VkIC1F aSAncy9wdWIgZm4gcnVzdF9oZWxwZXJfKFthLXpBLVowLTlfXSopLyNbbGlua19uYW1lPSJydXN0 X2hlbHBlcl9cMSJdXG4gICAgcHViIGZuIFwxL2cnICRACiskKG9iaikvYmluZGluZ3MvYmluZGlu Z3NfaGVscGVyc19nZW5lcmF0ZWQucnM6ICQoc3JjKS9oZWxwZXJzLmMgRk9SQ0UKKwkkKGNhbGwg aWZfY2hhbmdlZF9kZXAsYmluZGdlbikKKworcXVpZXRfY21kX2V4cG9ydHMgPSBFWFBPUlRTICRA CisgICAgICBjbWRfZXhwb3J0cyA9IFwKKwkkKE5NKSAtcCAtLWRlZmluZWQtb25seSAkPCBcCisJ CXwgZ3JlcCAtRSAnIChUfFJ8RCkgJyB8IGN1dCAtZCAnICcgLWYgMyBcCisJCXwgeGFyZ3MgLUlz eW1ib2wgXAorCQllY2hvICdFWFBPUlRfU1lNQk9MX1JVU1RfR1BMKHN5bWJvbCk7JyA+ICRACisK KyQob2JqKS9leHBvcnRzX2NvcmVfZ2VuZXJhdGVkLmg6ICQob2JqKS9jb3JlLm8gRk9SQ0UKKwkk KGNhbGwgaWZfY2hhbmdlZCxleHBvcnRzKQorCiskKG9iaikvZXhwb3J0c19hbGxvY19nZW5lcmF0 ZWQuaDogJChvYmopL2FsbG9jLm8gRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxleHBvcnRzKQor CiskKG9iaikvZXhwb3J0c19iaW5kaW5nc19nZW5lcmF0ZWQuaDogJChvYmopL2JpbmRpbmdzLm8g Rk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxleHBvcnRzKQorCiskKG9iaikvZXhwb3J0c19rZXJu ZWxfZ2VuZXJhdGVkLmg6ICQob2JqKS9rZXJuZWwubyBGT1JDRQorCSQoY2FsbCBpZl9jaGFuZ2Vk LGV4cG9ydHMpCisKK3F1aWV0X2NtZF9ydXN0Y19wcm9jbWFjcm8gPSAkKFJVU1RDX09SX0NMSVBQ WV9RVUlFVCkgUCAkQAorICAgICAgY21kX3J1c3RjX3Byb2NtYWNybyA9IFwKKwkkKFJVU1RDX09S X0NMSVBQWSkgJChydXN0X2NvbW1vbl9mbGFncykgXAorCQktLWVtaXQ9ZGVwLWluZm8sbGluayAt LWV4dGVybiBwcm9jX21hY3JvIFwKKwkJLS1jcmF0ZS10eXBlIHByb2MtbWFjcm8gLS1vdXQtZGly ICQob2JqdHJlZSkvJChvYmopIFwKKwkJLS1jcmF0ZS1uYW1lICQocGF0c3Vic3QgbGliJS5zbywl LCQobm90ZGlyICRAKSkgJDw7IFwKKwltdiAkKG9ianRyZWUpLyQob2JqKS8kKHBhdHN1YnN0IGxp YiUuc28sJSwkKG5vdGRpciAkQCkpLmQgJChkZXBmaWxlKTsgXAorCXNlZCAtaSAnL15cIy9kJyAk KGRlcGZpbGUpCisKKyMgUHJvY2VkdXJhbCBtYWNyb3MgY2FuIG9ubHkgYmUgdXNlZCB3aXRoIHRo ZSBgcnVzdGNgIHRoYXQgY29tcGlsZWQgaXQuCisjIFRoZXJlZm9yZSwgdG8gZ2V0IGBsaWJtYWNy b3Muc29gIGF1dG9tYXRpY2FsbHkgcmVjb21waWxlZCB3aGVuIHRoZSBjb21waWxlcgorIyB2ZXJz aW9uIGNoYW5nZXMsIHdlIGFkZCBgY29yZS5vYCBhcyBhIGRlcGVuZGVuY3kgKGV2ZW4gaWYgaXQg aXMgbm90IG5lZWRlZCkuCiskKG9iaikvbGlibWFjcm9zLnNvOiAkKHNyYykvbWFjcm9zL2xpYi5y cyAkKG9iaikvY29yZS5vIEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWRfZGVwLHJ1c3RjX3Byb2Nt YWNybykKKworcXVpZXRfY21kX3J1c3RjX2xpYnJhcnkgPSAkKGlmICQoc2tpcF9jbGlwcHkpLFJV U1RDLCQoUlVTVENfT1JfQ0xJUFBZX1FVSUVUKSkgTCAkQAorICAgICAgY21kX3J1c3RjX2xpYnJh cnkgPSBcCisJT0JKVFJFRT0kKGFic3BhdGggJChvYmp0cmVlKSkgXAorCSQoaWYgJChza2lwX2Ns aXBweSksJChSVVNUQyksJChSVVNUQ19PUl9DTElQUFkpKSBcCisJCSQoZmlsdGVyLW91dCAkKHNr aXBfZmxhZ3MpLCQocnVzdF9mbGFncykgJChydXN0Y190YXJnZXRfZmxhZ3MpKSBcCisJCS0tZW1p dD1kZXAtaW5mbyxvYmosbWV0YWRhdGEgLS1jcmF0ZS10eXBlIHJsaWIgXAorCQktLW91dC1kaXIg JChvYmp0cmVlKS8kKG9iaikgLUwkKG9ianRyZWUpLyQob2JqKSBcCisJCS0tY3JhdGUtbmFtZSAk KHBhdHN1YnN0ICUubywlLCQobm90ZGlyICRAKSkgJDw7IFwKKwltdiAkKG9ianRyZWUpLyQob2Jq KS8kKHBhdHN1YnN0ICUubywlLCQobm90ZGlyICRAKSkuZCAkKGRlcGZpbGUpOyBcCisJc2VkIC1p ICcvXlwjL2QnICQoZGVwZmlsZSkgXAorCSQoaWYgJChydXN0Y19vYmpjb3B5KSw7JChPQkpDT1BZ KSAkKHJ1c3RjX29iamNvcHkpICRAKQorCitydXN0LWFuYWx5emVyOgorCSQoUSkkKHNyY3RyZWUp L3NjcmlwdHMvZ2VuZXJhdGVfcnVzdF9hbmFseXplci5weSAkKHNyY3RyZWUpICQob2JqdHJlZSkg XAorCQkkKFJVU1RfTElCX1NSQykgPiAkKG9ianRyZWUpL3J1c3QtcHJvamVjdC5qc29uCisKKyQo b2JqKS9jb3JlLm86IHByaXZhdGUgc2tpcF9jbGlwcHkgPSAxCiskKG9iaikvY29yZS5vOiBwcml2 YXRlIHNraXBfZmxhZ3MgPSAtRHVucmVhY2hhYmxlX3B1YgorJChvYmopL2NvcmUubzogcHJpdmF0 ZSBydXN0Y190YXJnZXRfZmxhZ3MgPSAkKGNvcmUtY2ZncykKKyQob2JqKS9jb3JlLm86ICQoUlVT VF9MSUJfU1JDKS9jb3JlL3NyYy9saWIucnMgJChvYmopL3RhcmdldC5qc29uIEZPUkNFCisJJChj YWxsIGlmX2NoYW5nZWRfZGVwLHJ1c3RjX2xpYnJhcnkpCisKKyQob2JqKS9jb21waWxlcl9idWls dGlucy5vOiBwcml2YXRlIHJ1c3RjX29iamNvcHkgPSAtdyAtVyAnX18qJworJChvYmopL2NvbXBp bGVyX2J1aWx0aW5zLm86ICQoc3JjKS9jb21waWxlcl9idWlsdGlucy5ycyAkKG9iaikvY29yZS5v IEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWRfZGVwLHJ1c3RjX2xpYnJhcnkpCisKKyQob2JqKS9h bGxvYy5vOiBwcml2YXRlIHNraXBfY2xpcHB5ID0gMQorJChvYmopL2FsbG9jLm86IHByaXZhdGUg c2tpcF9mbGFncyA9IC1EdW5yZWFjaGFibGVfcHViCiskKG9iaikvYWxsb2MubzogcHJpdmF0ZSBy dXN0Y190YXJnZXRfZmxhZ3MgPSAkKGFsbG9jLWNmZ3MpCiskKG9iaikvYWxsb2MubzogJChzcmMp L2FsbG9jL2xpYi5ycyAkKG9iaikvY29tcGlsZXJfYnVpbHRpbnMubyBGT1JDRQorCSQoY2FsbCBp Zl9jaGFuZ2VkX2RlcCxydXN0Y19saWJyYXJ5KQorCiskKG9iaikvYnVpbGRfZXJyb3IubzogJChz cmMpL2J1aWxkX2Vycm9yLnJzICQob2JqKS9jb21waWxlcl9idWlsdGlucy5vIEZPUkNFCisJJChj YWxsIGlmX2NoYW5nZWRfZGVwLHJ1c3RjX2xpYnJhcnkpCisKKyQob2JqKS9iaW5kaW5ncy5vOiAk KHNyYykvYmluZGluZ3MvbGliLnJzIFwKKyAgICAkKG9iaikvY29tcGlsZXJfYnVpbHRpbnMubyBc CisgICAgJChvYmopL2JpbmRpbmdzL2JpbmRpbmdzX2dlbmVyYXRlZC5ycyBcCisgICAgJChvYmop L2JpbmRpbmdzL2JpbmRpbmdzX2hlbHBlcnNfZ2VuZXJhdGVkLnJzIEZPUkNFCisJJChjYWxsIGlm X2NoYW5nZWRfZGVwLHJ1c3RjX2xpYnJhcnkpCisKKyQob2JqKS9rZXJuZWwubzogcHJpdmF0ZSBy dXN0Y190YXJnZXRfZmxhZ3MgPSAtLWV4dGVybiBhbGxvYyBcCisgICAgLS1leHRlcm4gYnVpbGRf ZXJyb3IgLS1leHRlcm4gbWFjcm9zIC0tZXh0ZXJuIGJpbmRpbmdzCiskKG9iaikva2VybmVsLm86 ICQoc3JjKS9rZXJuZWwvbGliLnJzICQob2JqKS9hbGxvYy5vICQob2JqKS9idWlsZF9lcnJvci5v IFwKKyAgICAkKG9iaikvbGlibWFjcm9zLnNvICQob2JqKS9iaW5kaW5ncy5vIEZPUkNFCisJJChj YWxsIGlmX2NoYW5nZWRfZGVwLHJ1c3RjX2xpYnJhcnkpCisKK2VuZGlmICMgQ09ORklHX1JVU1QK ZGlmZiAtLWdpdCBhL3J1c3QvYmluZGdlbl9wYXJhbWV0ZXJzIGIvcnVzdC9iaW5kZ2VuX3BhcmFt ZXRlcnMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5iZTQ5NjNiZjcy MDMKLS0tIC9kZXYvbnVsbAorKysgYi9ydXN0L2JpbmRnZW5fcGFyYW1ldGVycwpAQCAtMCwwICsx LDIxIEBACisjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisKKy0tb3BhcXVlLXR5 cGUgeHJlZ3Nfc3RhdGUKKy0tb3BhcXVlLXR5cGUgZGVzY19zdHJ1Y3QKKy0tb3BhcXVlLXR5cGUg YXJjaF9sYnJfc3RhdGUKKy0tb3BhcXVlLXR5cGUgbG9jYWxfYXBpYworCisjIFBhY2tlZCB0eXBl IGNhbm5vdCB0cmFuc2l0aXZlbHkgY29udGFpbiBhIGAjW3JlcHIoYWxpZ24pXWAgdHlwZS4KKy0t b3BhcXVlLXR5cGUgeDg2X21zaV9kYXRhCistLW9wYXF1ZS10eXBlIHg4Nl9tc2lfYWRkcl9sbwor CisjIGB0cnlgIGlzIGEgcmVzZXJ2ZWQga2V5d29yZCBzaW5jZSBSdXN0IDIwMTg7IHNvbHZlZCBp biBgYmluZGdlbmAgdjAuNTkuMiwKKyMgY29tbWl0IDJhZWQ2YjAyMTY4MCAoImNvbnRleHQ6IEVz Y2FwZSB0aGUgdHJ5IGtleXdvcmQgcHJvcGVybHkiKS4KKy0tb3BhcXVlLXR5cGUga3VuaXRfdHJ5 X2NhdGNoCisKKyMgSWYgU01QIGlzIGRpc2FibGVkLCBgYXJjaF9zcGlubG9ja190YCBpcyBkZWZp bmVkIGFzIGEgWlNUIHdoaWNoIHRyaWdnZXJzIGEgUnVzdAorIyB3YXJuaW5nLiBXZSBkb24ndCBu ZWVkIHRvIHBlZWsgaW50byBpdCBhbnl3YXkuCistLW9wYXF1ZS10eXBlIHNwaW5sb2NrCisKKyMg YHNlY2NvbXBgJ3MgY29tbWVudCBnZXRzIHVuZGVyc3Rvb2QgYXMgYSBkb2N0ZXN0CistLW5vLWRv Yy1jb21tZW50cwpkaWZmIC0tZ2l0IGEvc2NyaXB0cy8uZ2l0aWdub3JlIGIvc2NyaXB0cy8uZ2l0 aWdub3JlCmluZGV4IGVlZDMwOGJlZjYwNC4uYjdhZWM4ZWIxYmQ0IDEwMDY0NAotLS0gYS9zY3Jp cHRzLy5naXRpZ25vcmUKKysrIGIvc2NyaXB0cy8uZ2l0aWdub3JlCkBAIC0xLDYgKzEsNyBAQAog IyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5CiAvYXNuMV9jb21waWxlcgog L2JpbjJjCisvZ2VuZXJhdGVfcnVzdF90YXJnZXQKIC9pbnNlcnQtc3lzLWNlcnQKIC9rYWxsc3lt cwogL21vZHVsZS5sZHMKZGlmZiAtLWdpdCBhL3NjcmlwdHMvS2NvbmZpZy5pbmNsdWRlIGIvc2Ny aXB0cy9LY29uZmlnLmluY2x1ZGUKaW5kZXggMDQ5NmVmZDZlMTE3Li44M2U4NTAzMjFlYjYgMTAw NjQ0Ci0tLSBhL3NjcmlwdHMvS2NvbmZpZy5pbmNsdWRlCisrKyBiL3NjcmlwdHMvS2NvbmZpZy5p bmNsdWRlCkBAIC0zNiwxMiArMzYsMTIgQEAgbGQtb3B0aW9uID0gJChzdWNjZXNzLCQoTEQpIC12 ICQoMSkpCiBhcy1pbnN0ciA9ICQoc3VjY2VzcyxwcmludGYgIiViXG4iICIkKDEpIiB8ICQoQ0Mp ICQoQ0xBTkdfRkxBR1MpIC1jIC14IGFzc2VtYmxlciAtbyAvZGV2L251bGwgLSkKIAogIyBjaGVj ayBpZiAkKENDKSBhbmQgJChMRCkgZXhpc3QKLSQoZXJyb3ItaWYsJChmYWlsdXJlLGNvbW1hbmQg LXYgJChDQykpLGNvbXBpbGVyICckKENDKScgbm90IGZvdW5kKQorJChlcnJvci1pZiwkKGZhaWx1 cmUsY29tbWFuZCAtdiAkKENDKSksQyBjb21waWxlciAnJChDQyknIG5vdCBmb3VuZCkKICQoZXJy b3ItaWYsJChmYWlsdXJlLGNvbW1hbmQgLXYgJChMRCkpLGxpbmtlciAnJChMRCknIG5vdCBmb3Vu ZCkKIAotIyBHZXQgdGhlIGNvbXBpbGVyIG5hbWUsIHZlcnNpb24sIGFuZCBlcnJvciBvdXQgaWYg aXQgaXMgbm90IHN1cHBvcnRlZC4KKyMgR2V0IHRoZSBDIGNvbXBpbGVyIG5hbWUsIHZlcnNpb24s IGFuZCBlcnJvciBvdXQgaWYgaXQgaXMgbm90IHN1cHBvcnRlZC4KIGNjLWluZm8gOj0gJChzaGVs bCwkKHNyY3RyZWUpL3NjcmlwdHMvY2MtdmVyc2lvbi5zaCAkKENDKSkKLSQoZXJyb3ItaWYsJChz dWNjZXNzLHRlc3QgLXogIiQoY2MtaW5mbykiKSxTb3JyeSQoY29tbWEpIHRoaXMgY29tcGlsZXIg aXMgbm90IHN1cHBvcnRlZC4pCiskKGVycm9yLWlmLCQoc3VjY2Vzcyx0ZXN0IC16ICIkKGNjLWlu Zm8pIiksU29ycnkkKGNvbW1hKSB0aGlzIEMgY29tcGlsZXIgaXMgbm90IHN1cHBvcnRlZC4pCiBj Yy1uYW1lIDo9ICQoc2hlbGwsc2V0IC0tICQoY2MtaW5mbykgJiYgZWNobyAkMSkKIGNjLXZlcnNp b24gOj0gJChzaGVsbCxzZXQgLS0gJChjYy1pbmZvKSAmJiBlY2hvICQyKQogCmRpZmYgLS1naXQg YS9zY3JpcHRzL01ha2VmaWxlIGIvc2NyaXB0cy9NYWtlZmlsZQppbmRleCBmMDg0ZjA4ZWQxNzYu LjE1NzVhZjg0ZDU1NyAxMDA2NDQKLS0tIGEvc2NyaXB0cy9NYWtlZmlsZQorKysgYi9zY3JpcHRz L01ha2VmaWxlCkBAIC0xMCw2ICsxMCw5IEBAIGhvc3Rwcm9ncy1hbHdheXMtJChDT05GSUdfQlVJ TERUSU1FX1RBQkxFX1NPUlQpCQkrPSBzb3J0dGFibGUKIGhvc3Rwcm9ncy1hbHdheXMtJChDT05G SUdfQVNOMSkJCQkJKz0gYXNuMV9jb21waWxlcgogaG9zdHByb2dzLWFsd2F5cy0kKENPTkZJR19N T0RVTEVfU0lHX0ZPUk1BVCkJCSs9IHNpZ24tZmlsZQogaG9zdHByb2dzLWFsd2F5cy0kKENPTkZJ R19TWVNURU1fRVhUUkFfQ0VSVElGSUNBVEUpCSs9IGluc2VydC1zeXMtY2VydAoraG9zdHByb2dz LWFsd2F5cy0kKENPTkZJR19SVVNUKQkJCQkrPSBnZW5lcmF0ZV9ydXN0X3RhcmdldAorCitnZW5l cmF0ZV9ydXN0X3RhcmdldC1ydXN0IDo9IHkKIAogSE9TVENGTEFHU19zb3J0dGFibGUubyA9IC1J JChzcmN0cmVlKS90b29scy9pbmNsdWRlCiBIT1NUTERMSUJTX3NvcnR0YWJsZSA9IC1scHRocmVh ZApkaWZmIC0tZ2l0IGEvc2NyaXB0cy9NYWtlZmlsZS5idWlsZCBiL3NjcmlwdHMvTWFrZWZpbGUu YnVpbGQKaW5kZXggY2FjMDcwYWVlNzkxLi41YzQ5NTcxM2YxYjEgMTAwNjQ0Ci0tLSBhL3Njcmlw dHMvTWFrZWZpbGUuYnVpbGQKKysrIGIvc2NyaXB0cy9NYWtlZmlsZS5idWlsZApAQCAtMjYsNiAr MjYsNyBAQCBFWFRSQV9DUFBGTEFHUyA6PQogRVhUUkFfTERGTEFHUyAgOj0KIGFzZmxhZ3MteSAg Oj0KIGNjZmxhZ3MteSAgOj0KK3J1c3RmbGFncy15IDo9CiBjcHBmbGFncy15IDo9CiBsZGZsYWdz LXkgIDo9CiAKQEAgLTI3MSw2ICsyNzIsNjUgQEAgcXVpZXRfY21kX2NjX2xzdF9jID0gTUtMU1Qg ICAkQAogJChvYmopLyUubHN0OiAkKHNyYykvJS5jIEZPUkNFCiAJJChjYWxsIGlmX2NoYW5nZWRf ZGVwLGNjX2xzdF9jKQogCisjIENvbXBpbGUgUnVzdCBzb3VyY2VzICgucnMpCisjIC0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLQorCitydXN0X2FsbG93ZWRfZmVhdHVyZXMgOj0gYWxsb2NhdG9yX2FwaSxiZW5j aF9ibGFja19ib3gsY29yZV9mZmlfYyxnZW5lcmljX2Fzc29jaWF0ZWRfdHlwZXMsY29uc3RfcHRy X29mZnNldF9mcm9tLGNvbnN0X3JlZnNfdG9fY2VsbAorCitydXN0X2NvbW1vbl9jbWQgPSBcCisJ UlVTVF9NT0RGSUxFPSQobW9kZmlsZSkgJChSVVNUQ19PUl9DTElQUFkpICQocnVzdF9mbGFncykg XAorCS1aYWxsb3ctZmVhdHVyZXM9JChydXN0X2FsbG93ZWRfZmVhdHVyZXMpIFwKKwktWmNyYXRl LWF0dHI9bm9fc3RkIFwKKwktWmNyYXRlLWF0dHI9J2ZlYXR1cmUoJChydXN0X2FsbG93ZWRfZmVh dHVyZXMpKScgXAorCS0tZXh0ZXJuIGFsbG9jIC0tZXh0ZXJuIGtlcm5lbCBcCisJLS1jcmF0ZS10 eXBlIHJsaWIgLS1vdXQtZGlyICQob2JqKSAtTCAkKG9ianRyZWUpL3J1c3QvIFwKKwktLWNyYXRl LW5hbWUgJChiYXNlbmFtZSAkKG5vdGRpciAkQCkpCisKK3J1c3RfaGFuZGxlX2RlcGZpbGUgPSBc CisJbXYgJChvYmopLyQoYmFzZW5hbWUgJChub3RkaXIgJEApKS5kICQoZGVwZmlsZSk7IFwKKwlz ZWQgLWkgJy9eXCMvZCcgJChkZXBmaWxlKQorCisjIGAtLWVtaXQ9b2JqYCwgYC0tZW1pdD1hc21g IGFuZCBgLS1lbWl0PWxsdm0taXJgIGltcGx5IGEgc2luZ2xlIGNvZGVnZW4gdW5pdAorIyB3aWxs IGJlIHVzZWQuIFdlIGV4cGxpY2l0bHkgcmVxdWVzdCBgLUNjb2RlZ2VuLXVuaXRzPTFgIGluIGFu eSBjYXNlLCBhbmQKKyMgdGhlIGNvbXBpbGVyIHNob3dzIGEgd2FybmluZyBpZiBpdCBpcyBub3Qg MS4gSG93ZXZlciwgaWYgd2UgZXZlciBzdG9wCisjIHJlcXVlc3RpbmcgaXQgZXhwbGljaXRseSBh bmQgd2Ugc3RhcnQgdXNpbmcgc29tZSBvdGhlciBgLS1lbWl0YCB0aGF0IGRvZXMgbm90CisjIGlt cGx5IGl0IChhbmQgZm9yIHdoaWNoIGNvZGVnZW4gaXMgcGVyZm9ybWVkKSwgdGhlbiB3ZSB3b3Vs ZCBiZSBvdXQgb2Ygc3luYywKKyMgaS5lLiB0aGUgb3V0cHV0cyB3ZSB3b3VsZCBnZXQgZm9yIHRo ZSBkaWZmZXJlbnQgc2luZ2xlIHRhcmdldHMgKGUuZy4gYC5sbGApCisjIHdvdWxkIG5vdCBtYXRj aCBlYWNoIG90aGVyLgorCitxdWlldF9jbWRfcnVzdGNfb19ycyA9ICQoUlVTVENfT1JfQ0xJUFBZ X1FVSUVUKSAkKHF1aWV0X21vZHRhZykgJEAKKyAgICAgIGNtZF9ydXN0Y19vX3JzID0gXAorCSQo cnVzdF9jb21tb25fY21kKSAtLWVtaXQ9ZGVwLWluZm8sb2JqICQ8OyBcCisJJChydXN0X2hhbmRs ZV9kZXBmaWxlKQorCiskKG9iaikvJS5vOiAkKHNyYykvJS5ycyBGT1JDRQorCSQoY2FsbCBpZl9j aGFuZ2VkX2RlcCxydXN0Y19vX3JzKQorCitxdWlldF9jbWRfcnVzdGNfcnNpX3JzID0gJChSVVNU Q19PUl9DTElQUFlfUVVJRVQpICQocXVpZXRfbW9kdGFnKSAkQAorICAgICAgY21kX3J1c3RjX3Jz aV9ycyA9IFwKKwkkKHJ1c3RfY29tbW9uX2NtZCkgLS1lbWl0PWRlcC1pbmZvIC1adW5wcmV0dHk9 ZXhwYW5kZWQgJDwgPiRAOyBcCisJY29tbWFuZCAtdiAkKFJVU1RGTVQpID4vZGV2L251bGwgJiYg JChSVVNURk1UKSAkQDsgXAorCSQocnVzdF9oYW5kbGVfZGVwZmlsZSkKKworJChvYmopLyUucnNp OiAkKHNyYykvJS5ycyBGT1JDRQorCSQoY2FsbCBpZl9jaGFuZ2VkX2RlcCxydXN0Y19yc2lfcnMp CisKK3F1aWV0X2NtZF9ydXN0Y19zX3JzID0gJChSVVNUQ19PUl9DTElQUFlfUVVJRVQpICQocXVp ZXRfbW9kdGFnKSAkQAorICAgICAgY21kX3J1c3RjX3NfcnMgPSBcCisJJChydXN0X2NvbW1vbl9j bWQpIC0tZW1pdD1kZXAtaW5mbyxhc20gJDw7IFwKKwkkKHJ1c3RfaGFuZGxlX2RlcGZpbGUpCisK KyQob2JqKS8lLnM6ICQoc3JjKS8lLnJzIEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWRfZGVwLHJ1 c3RjX3NfcnMpCisKK3F1aWV0X2NtZF9ydXN0Y19sbF9ycyA9ICQoUlVTVENfT1JfQ0xJUFBZX1FV SUVUKSAkKHF1aWV0X21vZHRhZykgJEAKKyAgICAgIGNtZF9ydXN0Y19sbF9ycyA9IFwKKwkkKHJ1 c3RfY29tbW9uX2NtZCkgLS1lbWl0PWRlcC1pbmZvLGxsdm0taXIgJDw7IFwKKwkkKHJ1c3RfaGFu ZGxlX2RlcGZpbGUpCisKKyQob2JqKS8lLmxsOiAkKHNyYykvJS5ycyBGT1JDRQorCSQoY2FsbCBp Zl9jaGFuZ2VkX2RlcCxydXN0Y19sbF9ycykKKwogIyBDb21waWxlIGFzc2VtYmxlciBzb3VyY2Vz ICguUykKICMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKZGlmZiAtLWdpdCBhL3NjcmlwdHMvTWFrZWZp bGUuZGVidWcgYi9zY3JpcHRzL01ha2VmaWxlLmRlYnVnCmluZGV4IDlmMzliMDEzMDU1MS4uZmU4 NzM4OWQ1MmMwIDEwMDY0NAotLS0gYS9zY3JpcHRzL01ha2VmaWxlLmRlYnVnCisrKyBiL3Njcmlw dHMvTWFrZWZpbGUuZGVidWcKQEAgLTEsNCArMSw1IEBACiBERUJVR19DRkxBR1MJOj0KK0RFQlVH X1JVU1RGTEFHUwk6PQogCiBpZmRlZiBDT05GSUdfREVCVUdfSU5GT19TUExJVAogREVCVUdfQ0ZM QUdTCSs9IC1nc3BsaXQtZHdhcmYKQEAgLTEwLDYgKzExLDEyIEBAIGlmbmRlZiBDT05GSUdfQVNf SVNfTExWTQogS0JVSUxEX0FGTEFHUwkrPSAtV2EsLWdkd2FyZi0yCiBlbmRpZgogCitpZmRlZiBD T05GSUdfREVCVUdfSU5GT19SRURVQ0VECitERUJVR19SVVNURkxBR1MgKz0gLUNkZWJ1Z2luZm89 MQorZWxzZQorREVCVUdfUlVTVEZMQUdTICs9IC1DZGVidWdpbmZvPTIKK2VuZGlmCisKIGlmbmRl ZiBDT05GSUdfREVCVUdfSU5GT19EV0FSRl9UT09MQ0hBSU5fREVGQVVMVAogZHdhcmYtdmVyc2lv bi0kKENPTkZJR19ERUJVR19JTkZPX0RXQVJGNCkgOj0gNAogZHdhcmYtdmVyc2lvbi0kKENPTkZJ R19ERUJVR19JTkZPX0RXQVJGNSkgOj0gNQpAQCAtMzEsMyArMzgsNiBAQCBlbmRpZgogCiBLQlVJ TERfQ0ZMQUdTICs9ICQoREVCVUdfQ0ZMQUdTKQogZXhwb3J0IERFQlVHX0NGTEFHUworCitLQlVJ TERfUlVTVEZMQUdTICs9ICQoREVCVUdfUlVTVEZMQUdTKQorZXhwb3J0IERFQlVHX1JVU1RGTEFH UwpkaWZmIC0tZ2l0IGEvc2NyaXB0cy9NYWtlZmlsZS5ob3N0IGIvc2NyaXB0cy9NYWtlZmlsZS5o b3N0CmluZGV4IDI3OGI0ZDZhYzk0NS4uZGExMzM3ODBiNzUxIDEwMDY0NAotLS0gYS9zY3JpcHRz L01ha2VmaWxlLmhvc3QKKysrIGIvc2NyaXB0cy9NYWtlZmlsZS5ob3N0CkBAIC0yMiw2ICsyMiw4 IEBAICQob2JqKS8lLnRhYi5jICQob2JqKS8lLnRhYi5oOiAkKHNyYykvJS55IEZPUkNFCiAjIHRv IHByZXByb2Nlc3MgYSBkYXRhIGZpbGUuCiAjCiAjIEJvdGggQyBhbmQgQysrIGFyZSBzdXBwb3J0 ZWQsIGJ1dCBwcmVmZXJyZWQgbGFuZ3VhZ2UgaXMgQyBmb3Igc3VjaCB1dGlsaXRpZXMuCisjIFJ1 c3QgaXMgYWxzbyBzdXBwb3J0ZWQsIGJ1dCBpdCBtYXkgb25seSBiZSB1c2VkIGluIHNjZW5hcmlv cyB3aGVyZSBhIFJ1c3QKKyMgdG9vbGNoYWluIGlzIHJlcXVpcmVkIHRvIGJlIGF2YWlsYWJsZSAo ZS5nLiB3aGVuICBgQ09ORklHX1JVU1RgIGlzIGVuYWJsZWQpLgogIwogIyBTYW1wbGUgc3ludGF4 IChzZWUgRG9jdW1lbnRhdGlvbi9rYnVpbGQvbWFrZWZpbGVzLnJzdCBmb3IgcmVmZXJlbmNlKQog IyBob3N0cHJvZ3MgOj0gYmluMmhleApAQCAtMzcsMTUgKzM5LDIwIEBAICQob2JqKS8lLnRhYi5j ICQob2JqKS8lLnRhYi5oOiAkKHNyYykvJS55IEZPUkNFCiAjIHFjb25mLW9ianMgICAgICA6PSBt ZW51Lm8KICMgV2lsbCBjb21waWxlIHFjb25mIGFzIGEgQysrIHByb2dyYW0sIGFuZCBtZW51IGFz IGEgQyBwcm9ncmFtLgogIyBUaGV5IGFyZSBsaW5rZWQgYXMgQysrIGNvZGUgdG8gdGhlIGV4ZWN1 dGFibGUgcWNvbmYKKyMKKyMgaG9zdHByb2dzICAgOj0gdGFyZ2V0CisjIHRhcmdldC1ydXN0IDo9 IHkKKyMgV2lsbCBjb21waWxlIGB0YXJnZXRgIGFzIGEgUnVzdCBwcm9ncmFtLCB1c2luZyBgdGFy Z2V0LnJzYCBhcyB0aGUgY3JhdGUgcm9vdC4KKyMgVGhlIGNyYXRlIG1heSBjb25zaXN0IG9mIHNl dmVyYWwgc291cmNlIGZpbGVzLgogCiAjIEMgY29kZQogIyBFeGVjdXRhYmxlcyBjb21waWxlZCBm cm9tIGEgc2luZ2xlIC5jIGZpbGUKIGhvc3QtY3NpbmdsZQk6PSAkKGZvcmVhY2ggbSwkKGhvc3Rw cm9ncyksIFwKLQkJCSQoaWYgJCgkKG0pLW9ianMpJCgkKG0pLWN4eG9ianMpLCwkKG0pKSkKKwkJ CSQoaWYgJCgkKG0pLW9ianMpJCgkKG0pLWN4eG9ianMpJCgkKG0pLXJ1c3QpLCwkKG0pKSkKIAog IyBDIGV4ZWN1dGFibGVzIGxpbmtlZCBiYXNlZCBvbiBzZXZlcmFsIC5vIGZpbGVzCiBob3N0LWNt dWx0aQk6PSAkKGZvcmVhY2ggbSwkKGhvc3Rwcm9ncyksXAotCQkgICAkKGlmICQoJChtKS1jeHhv YmpzKSwsJChpZiAkKCQobSktb2JqcyksJChtKSkpKQorCQkgICAkKGlmICQoJChtKS1jeHhvYmpz KSQoJChtKS1ydXN0KSwsJChpZiAkKCQobSktb2JqcyksJChtKSkpKQogCiAjIE9iamVjdCAoLm8p IGZpbGVzIGNvbXBpbGVkIGZyb20gLmMgZmlsZXMKIGhvc3QtY29ianMJOj0gJChzb3J0ICQoZm9y ZWFjaCBtLCQoaG9zdHByb2dzKSwkKCQobSktb2JqcykpKQpAQCAtNTgsMTEgKzY1LDE3IEBAIGhv c3QtY3h4bXVsdGkJOj0gJChmb3JlYWNoIG0sJChob3N0cHJvZ3MpLCQoaWYgJCgkKG0pLWN4eG9i anMpLCQobSkpKQogIyBDKysgT2JqZWN0ICgubykgZmlsZXMgY29tcGlsZWQgZnJvbSAuY2MgZmls ZXMKIGhvc3QtY3h4b2Jqcwk6PSAkKHNvcnQgJChmb3JlYWNoIG0sJChob3N0LWN4eG11bHRpKSwk KCQobSktY3h4b2JqcykpKQogCisjIFJ1c3QgY29kZQorIyBFeGVjdXRhYmxlcyBjb21waWxlZCBm cm9tIGEgc2luZ2xlIFJ1c3QgY3JhdGUgKHdoaWNoIG1heSBjb25zaXN0IG9mCisjIG9uZSBvciBt b3JlIC5ycyBmaWxlcykKK2hvc3QtcnVzdAk6PSAkKGZvcmVhY2ggbSwkKGhvc3Rwcm9ncyksJChp ZiAkKCQobSktcnVzdCksJChtKSkpCisKIGhvc3QtY3NpbmdsZQk6PSAkKGFkZHByZWZpeCAkKG9i aikvLCQoaG9zdC1jc2luZ2xlKSkKIGhvc3QtY211bHRpCTo9ICQoYWRkcHJlZml4ICQob2JqKS8s JChob3N0LWNtdWx0aSkpCiBob3N0LWNvYmpzCTo9ICQoYWRkcHJlZml4ICQob2JqKS8sJChob3N0 LWNvYmpzKSkKIGhvc3QtY3h4bXVsdGkJOj0gJChhZGRwcmVmaXggJChvYmopLywkKGhvc3QtY3h4 bXVsdGkpKQogaG9zdC1jeHhvYmpzCTo9ICQoYWRkcHJlZml4ICQob2JqKS8sJChob3N0LWN4eG9i anMpKQoraG9zdC1ydXN0CTo9ICQoYWRkcHJlZml4ICQob2JqKS8sJChob3N0LXJ1c3QpKQogCiAj IyMjIwogIyBIYW5kbGUgb3B0aW9ucyB0byBnY2MuIFN1cHBvcnQgYnVpbGRpbmcgd2l0aCBzZXBh cmF0ZSBvdXRwdXQgZGlyZWN0b3J5CkBAIC03MSw2ICs4NCw4IEBAIF9ob3N0Y19mbGFncyAgID0g JChLQlVJTERfSE9TVENGTEFHUykgICAkKEhPU1RfRVhUUkFDRkxBR1MpICAgXAogICAgICAgICAg ICAgICAgICAkKEhPU1RDRkxBR1NfJCh0YXJnZXQtc3RlbSkubykKIF9ob3N0Y3h4X2ZsYWdzID0g JChLQlVJTERfSE9TVENYWEZMQUdTKSAkKEhPU1RfRVhUUkFDWFhGTEFHUykgXAogICAgICAgICAg ICAgICAgICAkKEhPU1RDWFhGTEFHU18kKHRhcmdldC1zdGVtKS5vKQorX2hvc3RydXN0X2ZsYWdz ID0gJChLQlVJTERfSE9TVFJVU1RGTEFHUykgJChIT1NUX0VYVFJBUlVTVEZMQUdTKSBcCisgICAg ICAgICAgICAgICAgICAkKEhPU1RSVVNURkxBR1NfJCh0YXJnZXQtc3RlbSkpCiAKICMgJChvYmp0 cmVlKS8kKG9iaikgZm9yIGluY2x1ZGluZyBnZW5lcmF0ZWQgaGVhZGVycyBmcm9tIGNoZWNraW4g c291cmNlIGZpbGVzCiBpZmVxICgkKEtCVUlMRF9FWFRNT0QpLCkKQEAgLTgyLDYgKzk3LDcgQEAg ZW5kaWYKIAogaG9zdGNfZmxhZ3MgICAgPSAtV3AsLU1NRCwkKGRlcGZpbGUpICQoX2hvc3RjX2Zs YWdzKQogaG9zdGN4eF9mbGFncyAgPSAtV3AsLU1NRCwkKGRlcGZpbGUpICQoX2hvc3RjeHhfZmxh Z3MpCitob3N0cnVzdF9mbGFncyA9ICQoX2hvc3RydXN0X2ZsYWdzKQogCiAjIyMjIwogIyBDb21w aWxlIHByb2dyYW1zIG9uIHRoZSBob3N0CkBAIC0xMjgsNSArMTQ0LDE3IEBAIHF1aWV0X2NtZF9o b3N0LWN4eG9ianMJPSBIT1NUQ1hYICRACiAkKGhvc3QtY3h4b2Jqcyk6ICQob2JqKS8lLm86ICQo c3JjKS8lLmNjIEZPUkNFCiAJJChjYWxsIGlmX2NoYW5nZWRfZGVwLGhvc3QtY3h4b2JqcykKIAor IyBDcmVhdGUgZXhlY3V0YWJsZSBmcm9tIGEgc2luZ2xlIFJ1c3QgY3JhdGUgKHdoaWNoIG1heSBj b25zaXN0IG9mCisjIG9uZSBvciBtb3JlIGAucnNgIGZpbGVzKQorIyBob3N0LXJ1c3QgLT4gRXhl Y3V0YWJsZQorcXVpZXRfY21kX2hvc3QtcnVzdAk9IEhPU1RSVVNUQyAkQAorICAgICAgY21kX2hv c3QtcnVzdAk9IFwKKwkkKEhPU1RSVVNUQykgJChob3N0cnVzdF9mbGFncykgLS1lbWl0PWRlcC1p bmZvLGxpbmsgXAorCQktLW91dC1kaXI9JChvYmopLyAkPDsgXAorCW12ICQob2JqKS8kKHRhcmdl dC1zdGVtKS5kICQoZGVwZmlsZSk7IFwKKwlzZWQgLWkgJy9eXCMvZCcgJChkZXBmaWxlKQorJCho b3N0LXJ1c3QpOiAkKG9iaikvJTogJChzcmMpLyUucnMgRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdl ZF9kZXAsaG9zdC1ydXN0KQorCiB0YXJnZXRzICs9ICQoaG9zdC1jc2luZ2xlKSAkKGhvc3QtY211 bHRpKSAkKGhvc3QtY29ianMpIFwKLQkgICAkKGhvc3QtY3h4bXVsdGkpICQoaG9zdC1jeHhvYmpz KQorCSAgICQoaG9zdC1jeHhtdWx0aSkgJChob3N0LWN4eG9ianMpICQoaG9zdC1ydXN0KQpkaWZm IC0tZ2l0IGEvc2NyaXB0cy9NYWtlZmlsZS5saWIgYi9zY3JpcHRzL01ha2VmaWxlLmxpYgppbmRl eCAzZmI2YTk5ZTc4YzQuLmM4OGI5OGI1ZGM0NCAxMDA2NDQKLS0tIGEvc2NyaXB0cy9NYWtlZmls ZS5saWIKKysrIGIvc2NyaXB0cy9NYWtlZmlsZS5saWIKQEAgLTgsNiArOCw3IEBAIGxkZmxhZ3Mt eSAgKz0gJChFWFRSQV9MREZMQUdTKQogIyBmbGFncyB0aGF0IHRha2UgZWZmZWN0IGluIGN1cnJl bnQgYW5kIHN1YiBkaXJlY3RvcmllcwogS0JVSUxEX0FGTEFHUyArPSAkKHN1YmRpci1hc2ZsYWdz LXkpCiBLQlVJTERfQ0ZMQUdTICs9ICQoc3ViZGlyLWNjZmxhZ3MteSkKK0tCVUlMRF9SVVNURkxB R1MgKz0gJChzdWJkaXItcnVzdGZsYWdzLXkpCiAKICMgRmlndXJlIG91dCB3aGF0IHdlIG5lZWQg dG8gYnVpbGQgZnJvbSB0aGUgdmFyaW91cyB2YXJpYWJsZXMKICMgPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 CkBAIC0xMjgsNiArMTI5LDEwIEBAIF9jX2ZsYWdzICAgICAgID0gJChmaWx0ZXItb3V0ICQoQ0ZM QUdTX1JFTU9WRV8kKHRhcmdldC1zdGVtKS5vKSwgXAogICAgICAgICAgICAgICAgICAgICAgJChm aWx0ZXItb3V0ICQoY2NmbGFncy1yZW1vdmUteSksIFwKICAgICAgICAgICAgICAgICAgICAgICAg ICAkKEtCVUlMRF9DUFBGTEFHUykgJChLQlVJTERfQ0ZMQUdTKSAkKGNjZmxhZ3MteSkpIFwKICAg ICAgICAgICAgICAgICAgICAgICQoQ0ZMQUdTXyQodGFyZ2V0LXN0ZW0pLm8pKQorX3J1c3RfZmxh Z3MgICAgPSAkKGZpbHRlci1vdXQgJChSVVNURkxBR1NfUkVNT1ZFXyQodGFyZ2V0LXN0ZW0pLm8p LCBcCisgICAgICAgICAgICAgICAgICAgICAkKGZpbHRlci1vdXQgJChydXN0ZmxhZ3MtcmVtb3Zl LXkpLCBcCisgICAgICAgICAgICAgICAgICAgICAgICAgJChLQlVJTERfUlVTVEZMQUdTKSAkKHJ1 c3RmbGFncy15KSkgXAorICAgICAgICAgICAgICAgICAgICAgJChSVVNURkxBR1NfJCh0YXJnZXQt c3RlbSkubykpCiBfYV9mbGFncyAgICAgICA9ICQoZmlsdGVyLW91dCAkKEFGTEFHU19SRU1PVkVf JCh0YXJnZXQtc3RlbSkubyksIFwKICAgICAgICAgICAgICAgICAgICAgICQoZmlsdGVyLW91dCAk KGFzZmxhZ3MtcmVtb3ZlLXkpLCBcCiAgICAgICAgICAgICAgICAgICAgICAgICAgJChLQlVJTERf Q1BQRkxBR1MpICQoS0JVSUxEX0FGTEFHUykgJChhc2ZsYWdzLXkpKSBcCkBAIC0yMDIsNiArMjA3 LDExIEBAIG1vZGtlcm5fY2ZsYWdzID0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBcCiAJCSQoS0JVSUxEX0NGTEFHU19NT0RVTEUpICQoQ0ZMQUdTX01PRFVMRSksIFwK IAkJJChLQlVJTERfQ0ZMQUdTX0tFUk5FTCkgJChDRkxBR1NfS0VSTkVMKSAkKG1vZGZpbGVfZmxh Z3MpKQogCittb2RrZXJuX3J1c3RmbGFncyA9ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFwKKwkkKGlmICQocGFydC1vZi1tb2R1bGUpLCAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgXAorCQkkKEtCVUlMRF9SVVNURkxBR1NfTU9EVUxFKSAkKFJV U1RGTEFHU19NT0RVTEUpLCBcCisJCSQoS0JVSUxEX1JVU1RGTEFHU19LRVJORUwpICQoUlVTVEZM QUdTX0tFUk5FTCkpCisKIG1vZGtlcm5fYWZsYWdzID0gJChpZiAkKHBhcnQtb2YtbW9kdWxlKSwJ CQkJXAogCQkJJChLQlVJTERfQUZMQUdTX01PRFVMRSkgJChBRkxBR1NfTU9EVUxFKSwJXAogCQkJ JChLQlVJTERfQUZMQUdTX0tFUk5FTCkgJChBRkxBR1NfS0VSTkVMKSkKQEAgLTIxMSw2ICsyMjEs OCBAQCBjX2ZsYWdzICAgICAgICA9IC1XcCwtTU1ELCQoZGVwZmlsZSkgJChOT1NURElOQ19GTEFH UykgJChMSU5VWElOQ0xVREUpICAgICBcCiAJCSAkKF9jX2ZsYWdzKSAkKG1vZGtlcm5fY2ZsYWdz KSAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKIAkJICQoYmFzZW5hbWVfZmxhZ3MpICQobW9k bmFtZV9mbGFncykKIAorcnVzdF9mbGFncyAgICAgPSAkKF9ydXN0X2ZsYWdzKSAkKG1vZGtlcm5f cnVzdGZsYWdzKSBAJChvYmp0cmVlKS9pbmNsdWRlL2dlbmVyYXRlZC9ydXN0Y19jZmcKKwogYV9m bGFncyAgICAgICAgPSAtV3AsLU1NRCwkKGRlcGZpbGUpICQoTk9TVERJTkNfRkxBR1MpICQoTElO VVhJTkNMVURFKSAgICAgXAogCQkgJChfYV9mbGFncykgJChtb2RrZXJuX2FmbGFncykKIApkaWZm IC0tZ2l0IGEvc2NyaXB0cy9NYWtlZmlsZS5tb2RmaW5hbCBiL3NjcmlwdHMvTWFrZWZpbGUubW9k ZmluYWwKaW5kZXggMzUxMDBlOTgxZjRhLi45YTFmYTZhYTMwZmUgMTAwNjQ0Ci0tLSBhL3Njcmlw dHMvTWFrZWZpbGUubW9kZmluYWwKKysrIGIvc2NyaXB0cy9NYWtlZmlsZS5tb2RmaW5hbApAQCAt MzksMTEgKzM5LDEzIEBAIHF1aWV0X2NtZF9sZF9rb19vID0gTEQgW01dICAkQAogCiBxdWlldF9j bWRfYnRmX2tvID0gQlRGIFtNXSAkQAogICAgICAgY21kX2J0Zl9rbyA9IAkJCQkJCQlcCi0JaWYg WyAtZiB2bWxpbnV4IF07IHRoZW4JCQkJCQlcCisJaWYgWyAhIC1mIHZtbGludXggXTsgdGhlbgkJ CQkJXAorCQlwcmludGYgIlNraXBwaW5nIEJURiBnZW5lcmF0aW9uIGZvciAlcyBkdWUgdG8gdW5h dmFpbGFiaWxpdHkgb2Ygdm1saW51eFxuIiAkQCAxPiYyOyBcCisJZWxpZiBbIC1uICIkKENPTkZJ R19SVVNUKSIgXSAmJiAkKHNyY3RyZWUpL3NjcmlwdHMvaXNfcnVzdF9tb2R1bGUuc2ggJEA7IHRo ZW4gCQlcCisJCXByaW50ZiAiU2tpcHBpbmcgQlRGIGdlbmVyYXRpb24gZm9yICVzIGJlY2F1c2Ug aXQncyBhIFJ1c3QgbW9kdWxlXG4iICRAIDE+JjI7IFwKKwllbHNlCQkJCQkJCQlcCiAJCUxMVk1f T0JKQ09QWT0iJChPQkpDT1BZKSIgJChQQUhPTEUpIC1KICQoUEFIT0xFX0ZMQUdTKSAtLWJ0Zl9i YXNlIHZtbGludXggJEA7IFwKIAkJJChSRVNPTFZFX0JURklEUykgLWIgdm1saW51eCAkQDsgCQkJ XAotCWVsc2UJCQkJCQkJCVwKLQkJcHJpbnRmICJTa2lwcGluZyBCVEYgZ2VuZXJhdGlvbiBmb3Ig JXMgZHVlIHRvIHVuYXZhaWxhYmlsaXR5IG9mIHZtbGludXhcbiIgJEAgMT4mMjsgXAogCWZpOwog CiAjIFNhbWUgYXMgbmV3ZXItcHJlcmVxcywgYnV0IGFsbG93cyB0byBleGNsdWRlIHNwZWNpZmll ZCBleHRyYSBkZXBlbmRlbmNpZXMKZGlmZiAtLWdpdCBhL3NjcmlwdHMvY2MtdmVyc2lvbi5zaCBi L3NjcmlwdHMvY2MtdmVyc2lvbi5zaAppbmRleCBmMTk1MmM1MjI0NjYuLjI0MDFjODZmY2Y1MyAx MDA3NTUKLS0tIGEvc2NyaXB0cy9jYy12ZXJzaW9uLnNoCisrKyBiL3NjcmlwdHMvY2MtdmVyc2lv bi5zaApAQCAtMSwxMyArMSwxMyBAQAogIyEvYmluL3NoCiAjIFNQRFgtTGljZW5zZS1JZGVudGlm aWVyOiBHUEwtMi4wCiAjCi0jIFByaW50IHRoZSBjb21waWxlciBuYW1lIGFuZCBpdHMgdmVyc2lv biBpbiBhIDUgb3IgNi1kaWdpdCBmb3JtLgorIyBQcmludCB0aGUgQyBjb21waWxlciBuYW1lIGFu ZCBpdHMgdmVyc2lvbiBpbiBhIDUgb3IgNi1kaWdpdCBmb3JtLgogIyBBbHNvLCBwZXJmb3JtIHRo ZSBtaW5pbXVtIHZlcnNpb24gY2hlY2suCiAKIHNldCAtZQogCi0jIFByaW50IHRoZSBjb21waWxl ciBuYW1lIGFuZCBzb21lIHZlcnNpb24gY29tcG9uZW50cy4KLWdldF9jb21waWxlcl9pbmZvKCkK KyMgUHJpbnQgdGhlIEMgY29tcGlsZXIgbmFtZSBhbmQgc29tZSB2ZXJzaW9uIGNvbXBvbmVudHMu CitnZXRfY19jb21waWxlcl9pbmZvKCkKIHsKIAljYXQgPDwtIEVPRiB8ICIkQCIgLUUgLVAgLXgg YyAtIDI+L2Rldi9udWxsCiAJI2lmIGRlZmluZWQoX19jbGFuZ19fKQpAQCAtMzIsNyArMzIsNyBA QCBnZXRfY2Fub25pY2FsX3ZlcnNpb24oKQogCiAjICRAIGluc3RlYWQgb2YgJDEgYmVjYXVzZSBt dWx0aXBsZSB3b3JkcyBtaWdodCBiZSBnaXZlbiwgZS5nLiBDQz0iY2NhY2hlIGdjYyIuCiBvcmln X2FyZ3M9IiRAIgotc2V0IC0tICQoZ2V0X2NvbXBpbGVyX2luZm8gIiRAIikKK3NldCAtLSAkKGdl dF9jX2NvbXBpbGVyX2luZm8gIiRAIikKIAogbmFtZT0kMQogCkBAIC01Miw3ICs1Miw3IEBAIElD QykKIAltaW5fdmVyc2lvbj0kKCRtaW5fdG9vbF92ZXJzaW9uIGljYykKIAk7OwogKikKLQllY2hv ICIkb3JpZ19hcmdzOiB1bmtub3duIGNvbXBpbGVyIiA+JjIKKwllY2hvICIkb3JpZ19hcmdzOiB1 bmtub3duIEMgY29tcGlsZXIiID4mMgogCWV4aXQgMQogCTs7CiBlc2FjCkBAIC02Miw3ICs2Miw3 IEBAIG1pbl9jdmVyc2lvbj0kKGdldF9jYW5vbmljYWxfdmVyc2lvbiAkbWluX3ZlcnNpb24pCiAK IGlmIFsgIiRjdmVyc2lvbiIgLWx0ICIkbWluX2N2ZXJzaW9uIiBdOyB0aGVuCiAJZWNobyA+JjIg IioqKiIKLQllY2hvID4mMiAiKioqIENvbXBpbGVyIGlzIHRvbyBvbGQuIgorCWVjaG8gPiYyICIq KiogQyBjb21waWxlciBpcyB0b28gb2xkLiIKIAllY2hvID4mMiAiKioqICAgWW91ciAkbmFtZSB2 ZXJzaW9uOiAgICAkdmVyc2lvbiIKIAllY2hvID4mMiAiKioqICAgTWluaW11bSAkbmFtZSB2ZXJz aW9uOiAkbWluX3ZlcnNpb24iCiAJZWNobyA+JjIgIioqKiIKZGlmZiAtLWdpdCBhL3NjcmlwdHMv Z2VuZXJhdGVfcnVzdF90YXJnZXQucnMgYi9zY3JpcHRzL2dlbmVyYXRlX3J1c3RfdGFyZ2V0LnJz Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMGExYmE5NWQ3NGU3Ci0t LSAvZGV2L251bGwKKysrIGIvc2NyaXB0cy9nZW5lcmF0ZV9ydXN0X3RhcmdldC5ycwpAQCAtMCww ICsxLDIzMiBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKworLy8hIFRo ZSBjdXN0b20gdGFyZ2V0IHNwZWNpZmljYXRpb24gZmlsZSBnZW5lcmF0b3IgZm9yIGBydXN0Y2Au CisvLyEKKy8vISBUbyBjb25maWd1cmUgYSB0YXJnZXQgZnJvbSBzY3JhdGNoLCBhIEpTT04tZW5j b2RlZCBmaWxlIGhhcyB0byBiZSBwYXNzZWQKKy8vISB0byBgcnVzdGNgIChpbnRyb2R1Y2VkIGlu IFtSRkMgMTMxXSkuIFRoZXNlIG9wdGlvbnMgYW5kIHRoZSBmaWxlIGl0c2VsZiBhcmUKKy8vISB1 bnN0YWJsZS4gRXZlbnR1YWxseSwgYHJ1c3RjYCBzaG91bGQgcHJvdmlkZSBhIHdheSB0byBkbyB0 aGlzIGluIGEgc3RhYmxlCisvLyEgbWFubmVyLiBGb3IgaW5zdGFuY2UsIHZpYSBjb21tYW5kLWxp bmUgYXJndW1lbnRzLiBUaGVyZWZvcmUsIHRoaXMgZmlsZQorLy8hIHNob3VsZCBhdm9pZCB1c2lu ZyBrZXlzIHdoaWNoIGNhbiBiZSBzZXQgdmlhIGAtQ2Agb3IgYC1aYCBvcHRpb25zLgorLy8hCisv LyEgW1JGQyAxMzFdOiBodHRwczovL3J1c3QtbGFuZy5naXRodWIuaW8vcmZjcy8wMTMxLXRhcmdl dC1zcGVjaWZpY2F0aW9uLmh0bWwKKwordXNlIHN0ZDo6eworICAgIGNvbGxlY3Rpb25zOjpIYXNo TWFwLAorICAgIGZtdDo6e0Rpc3BsYXksIEZvcm1hdHRlciwgUmVzdWx0fSwKKyAgICBpbzo6QnVm UmVhZCwKK307CisKK2VudW0gVmFsdWUgeworICAgIEJvb2xlYW4oYm9vbCksCisgICAgTnVtYmVy KGkzMiksCisgICAgU3RyaW5nKFN0cmluZyksCisgICAgT2JqZWN0KE9iamVjdCksCit9CisKK3R5 cGUgT2JqZWN0ID0gVmVjPChTdHJpbmcsIFZhbHVlKT47CisKKy8vLyBNaW5pbWFsICJhbG1vc3Qg SlNPTiIgZ2VuZXJhdG9yIChlLmcuIG5vIGBudWxsYHMsIG5vIGFycmF5cywgbm8gZXNjYXBpbmcp LAorLy8vIGVub3VnaCBmb3IgdGhpcyBwdXJwb3NlLgoraW1wbCBEaXNwbGF5IGZvciBWYWx1ZSB7 CisgICAgZm4gZm10KCZzZWxmLCBmb3JtYXR0ZXI6ICZtdXQgRm9ybWF0dGVyPCdfPikgLT4gUmVz dWx0IHsKKyAgICAgICAgbWF0Y2ggc2VsZiB7CisgICAgICAgICAgICBWYWx1ZTo6Qm9vbGVhbihi b29sZWFuKSA9PiB3cml0ZSEoZm9ybWF0dGVyLCAie30iLCBib29sZWFuKSwKKyAgICAgICAgICAg IFZhbHVlOjpOdW1iZXIobnVtYmVyKSA9PiB3cml0ZSEoZm9ybWF0dGVyLCAie30iLCBudW1iZXIp LAorICAgICAgICAgICAgVmFsdWU6OlN0cmluZyhzdHJpbmcpID0+IHdyaXRlIShmb3JtYXR0ZXIs ICJcInt9XCIiLCBzdHJpbmcpLAorICAgICAgICAgICAgVmFsdWU6Ok9iamVjdChvYmplY3QpID0+ IHsKKyAgICAgICAgICAgICAgICBmb3JtYXR0ZXIud3JpdGVfc3RyKCJ7Iik/OworICAgICAgICAg ICAgICAgIGlmIGxldCBbcmVmIHJlc3QgQCAuLiwgcmVmIGxhc3RdID0gb2JqZWN0Wy4uXSB7Cisg ICAgICAgICAgICAgICAgICAgIGZvciAoa2V5LCB2YWx1ZSkgaW4gcmVzdCB7CisgICAgICAgICAg ICAgICAgICAgICAgICB3cml0ZSEoZm9ybWF0dGVyLCAiXCJ7fVwiOiB7fSwiLCBrZXksIHZhbHVl KT87CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgd3JpdGUhKGZv cm1hdHRlciwgIlwie31cIjoge30iLCBsYXN0LjAsIGxhc3QuMSk/OworICAgICAgICAgICAgICAg IH0KKyAgICAgICAgICAgICAgICBmb3JtYXR0ZXIud3JpdGVfc3RyKCJ9IikKKyAgICAgICAgICAg IH0KKyAgICAgICAgfQorICAgIH0KK30KKworc3RydWN0IFRhcmdldFNwZWMoT2JqZWN0KTsKKwor aW1wbCBUYXJnZXRTcGVjIHsKKyAgICBmbiBuZXcoKSAtPiBUYXJnZXRTcGVjIHsKKyAgICAgICAg VGFyZ2V0U3BlYyhWZWM6Om5ldygpKQorICAgIH0KK30KKwordHJhaXQgUHVzaDxUPiB7CisgICAg Zm4gcHVzaCgmbXV0IHNlbGYsIGtleTogJnN0ciwgdmFsdWU6IFQpOworfQorCitpbXBsIFB1c2g8 Ym9vbD4gZm9yIFRhcmdldFNwZWMgeworICAgIGZuIHB1c2goJm11dCBzZWxmLCBrZXk6ICZzdHIs IHZhbHVlOiBib29sKSB7CisgICAgICAgIHNlbGYuMC5wdXNoKChrZXkudG9fc3RyaW5nKCksIFZh bHVlOjpCb29sZWFuKHZhbHVlKSkpOworICAgIH0KK30KKworaW1wbCBQdXNoPGkzMj4gZm9yIFRh cmdldFNwZWMgeworICAgIGZuIHB1c2goJm11dCBzZWxmLCBrZXk6ICZzdHIsIHZhbHVlOiBpMzIp IHsKKyAgICAgICAgc2VsZi4wLnB1c2goKGtleS50b19zdHJpbmcoKSwgVmFsdWU6Ok51bWJlcih2 YWx1ZSkpKTsKKyAgICB9Cit9CisKK2ltcGwgUHVzaDxTdHJpbmc+IGZvciBUYXJnZXRTcGVjIHsK KyAgICBmbiBwdXNoKCZtdXQgc2VsZiwga2V5OiAmc3RyLCB2YWx1ZTogU3RyaW5nKSB7CisgICAg ICAgIHNlbGYuMC5wdXNoKChrZXkudG9fc3RyaW5nKCksIFZhbHVlOjpTdHJpbmcodmFsdWUpKSk7 CisgICAgfQorfQorCitpbXBsIFB1c2g8JnN0cj4gZm9yIFRhcmdldFNwZWMgeworICAgIGZuIHB1 c2goJm11dCBzZWxmLCBrZXk6ICZzdHIsIHZhbHVlOiAmc3RyKSB7CisgICAgICAgIHNlbGYucHVz aChrZXksIHZhbHVlLnRvX3N0cmluZygpKTsKKyAgICB9Cit9CisKK2ltcGwgUHVzaDxPYmplY3Q+ IGZvciBUYXJnZXRTcGVjIHsKKyAgICBmbiBwdXNoKCZtdXQgc2VsZiwga2V5OiAmc3RyLCB2YWx1 ZTogT2JqZWN0KSB7CisgICAgICAgIHNlbGYuMC5wdXNoKChrZXkudG9fc3RyaW5nKCksIFZhbHVl OjpPYmplY3QodmFsdWUpKSk7CisgICAgfQorfQorCitpbXBsIERpc3BsYXkgZm9yIFRhcmdldFNw ZWMgeworICAgIGZuIGZtdCgmc2VsZiwgZm9ybWF0dGVyOiAmbXV0IEZvcm1hdHRlcjwnXz4pIC0+ IFJlc3VsdCB7CisgICAgICAgIC8vIFdlIGFkZCBzb21lIG5ld2xpbmVzIGZvciBjbGFyaXR5Lgor ICAgICAgICBmb3JtYXR0ZXIud3JpdGVfc3RyKCJ7XG4iKT87CisgICAgICAgIGlmIGxldCBbcmVm IHJlc3QgQCAuLiwgcmVmIGxhc3RdID0gc2VsZi4wWy4uXSB7CisgICAgICAgICAgICBmb3IgKGtl eSwgdmFsdWUpIGluIHJlc3QgeworICAgICAgICAgICAgICAgIHdyaXRlIShmb3JtYXR0ZXIsICIg ICAgXCJ7fVwiOiB7fSxcbiIsIGtleSwgdmFsdWUpPzsKKyAgICAgICAgICAgIH0KKyAgICAgICAg ICAgIHdyaXRlIShmb3JtYXR0ZXIsICIgICAgXCJ7fVwiOiB7fVxuIiwgbGFzdC4wLCBsYXN0LjEp PzsKKyAgICAgICAgfQorICAgICAgICBmb3JtYXR0ZXIud3JpdGVfc3RyKCJ9IikKKyAgICB9Cit9 CisKK3N0cnVjdCBLZXJuZWxDb25maWcoSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4pOworCitpbXBs IEtlcm5lbENvbmZpZyB7CisgICAgLy8vIFBhcnNlcyBgaW5jbHVkZS9jb25maWcvYXV0by5jb25m YCBmcm9tIGBzdGRpbmAuCisgICAgZm4gZnJvbV9zdGRpbigpIC0+IEtlcm5lbENvbmZpZyB7Cisg ICAgICAgIGxldCBtdXQgcmVzdWx0ID0gSGFzaE1hcDo6bmV3KCk7CisKKyAgICAgICAgbGV0IHN0 ZGluID0gc3RkOjppbzo6c3RkaW4oKTsKKyAgICAgICAgbGV0IG11dCBoYW5kbGUgPSBzdGRpbi5s b2NrKCk7CisgICAgICAgIGxldCBtdXQgbGluZSA9IFN0cmluZzo6bmV3KCk7CisKKyAgICAgICAg bG9vcCB7CisgICAgICAgICAgICBsaW5lLmNsZWFyKCk7CisKKyAgICAgICAgICAgIGlmIGhhbmRs ZS5yZWFkX2xpbmUoJm11dCBsaW5lKS51bndyYXAoKSA9PSAwIHsKKyAgICAgICAgICAgICAgICBi cmVhazsKKyAgICAgICAgICAgIH0KKworICAgICAgICAgICAgaWYgbGluZS5zdGFydHNfd2l0aCgn IycpIHsKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIH0KKworICAgICAg ICAgICAgbGV0IChrZXksIHZhbHVlKSA9IGxpbmUuc3BsaXRfb25jZSgnPScpLmV4cGVjdCgiTWlz c2luZyBgPWAgaW4gbGluZS4iKTsKKyAgICAgICAgICAgIHJlc3VsdC5pbnNlcnQoa2V5LnRvX3N0 cmluZygpLCB2YWx1ZS50cmltX2VuZF9tYXRjaGVzKCdcbicpLnRvX3N0cmluZygpKTsKKyAgICAg ICAgfQorCisgICAgICAgIEtlcm5lbENvbmZpZyhyZXN1bHQpCisgICAgfQorCisgICAgLy8vIERv ZXMgdGhlIG9wdGlvbiBleGlzdCBpbiB0aGUgY29uZmlndXJhdGlvbiAoYW55IHZhbHVlKT8KKyAg ICAvLy8KKyAgICAvLy8gVGhlIGFyZ3VtZW50IG11c3QgYmUgcGFzc2VkIHdpdGhvdXQgdGhlIGBD T05GSUdfYCBwcmVmaXguCisgICAgLy8vIFRoaXMgYXZvaWRzIHJlcGV0aXRpb24gYW5kIGl0IGFs c28gYXZvaWRzIGBmaXhkZXBgIG1ha2luZyB1cworICAgIC8vLyBkZXBlbmQgb24gaXQuCisgICAg Zm4gaGFzKCZzZWxmLCBvcHRpb246ICZzdHIpIC0+IGJvb2wgeworICAgICAgICBsZXQgb3B0aW9u ID0gIkNPTkZJR18iLnRvX293bmVkKCkgKyBvcHRpb247CisgICAgICAgIHNlbGYuMC5jb250YWlu c19rZXkoJm9wdGlvbikKKyAgICB9Cit9CisKK2ZuIG1haW4oKSB7CisgICAgbGV0IGNmZyA9IEtl cm5lbENvbmZpZzo6ZnJvbV9zdGRpbigpOworICAgIGxldCBtdXQgdHMgPSBUYXJnZXRTcGVjOjpu ZXcoKTsKKworICAgIC8vIGBsbHZtLXRhcmdldGBzIGFyZSB0YWtlbiBmcm9tIGBzY3JpcHRzL01h a2VmaWxlLmNsYW5nYC4KKyAgICBpZiBjZmcuaGFzKCJBUk0iKSB7CisgICAgICAgIHRzLnB1c2go ImFyY2giLCAiYXJtIik7CisgICAgICAgIHRzLnB1c2goCisgICAgICAgICAgICAiZGF0YS1sYXlv dXQiLAorICAgICAgICAgICAgImUtbTplLXA6MzI6MzItRmk4LWk2NDo2NC12MTI4OjY0OjEyOC1h OjA6MzItbjMyLVM2NCIsCisgICAgICAgICk7CisgICAgICAgIHRzLnB1c2goImZlYXR1cmVzIiwg IitzdHJpY3QtYWxpZ24sK3Y2Iik7CisgICAgICAgIHRzLnB1c2goImxsdm0tdGFyZ2V0IiwgImFy bS1saW51eC1nbnVlYWJpIik7CisgICAgICAgIHRzLnB1c2goIm1heC1hdG9taWMtd2lkdGgiLCA2 NCk7CisgICAgICAgIHRzLnB1c2goInRhcmdldC1tY291bnQiLCAiXFx1MDAwMV9fZ251X21jb3Vu dF9uYyIpOworICAgICAgICB0cy5wdXNoKCJ0YXJnZXQtcG9pbnRlci13aWR0aCIsICIzMiIpOwor ICAgIH0gZWxzZSBpZiBjZmcuaGFzKCJBUk02NCIpIHsKKyAgICAgICAgdHMucHVzaCgiYXJjaCIs ICJhYXJjaDY0Iik7CisgICAgICAgIHRzLnB1c2goCisgICAgICAgICAgICAiZGF0YS1sYXlvdXQi LAorICAgICAgICAgICAgImUtbTplLWk4Ojg6MzItaTE2OjE2OjMyLWk2NDo2NC1pMTI4OjEyOC1u MzI6NjQtUzEyOCIsCisgICAgICAgICk7CisgICAgICAgIHRzLnB1c2goImRpc2FibGUtcmVkem9u ZSIsIHRydWUpOworICAgICAgICB0cy5wdXNoKCJmZWF0dXJlcyIsICIrc3RyaWN0LWFsaWduLC1u ZW9uLC1mcC1hcm12OCIpOworICAgICAgICB0cy5wdXNoKCJsbHZtLXRhcmdldCIsICJhYXJjaDY0 LWxpbnV4LWdudSIpOworICAgICAgICB0cy5wdXNoKCJtYXgtYXRvbWljLXdpZHRoIiwgMTI4KTsK KyAgICAgICAgdHMucHVzaCgidGFyZ2V0LXBvaW50ZXItd2lkdGgiLCAiNjQiKTsKKyAgICB9IGVs c2UgaWYgY2ZnLmhhcygiUFBDIikgeworICAgICAgICB0cy5wdXNoKCJhcmNoIiwgInBvd2VycGM2 NCIpOworICAgICAgICB0cy5wdXNoKCJjb2RlLW1vZGVsIiwgImxhcmdlIik7CisgICAgICAgIHRz LnB1c2goImRhdGEtbGF5b3V0IiwgImUtbTplLWk2NDo2NC1uMzI6NjQiKTsKKyAgICAgICAgdHMu cHVzaCgiZmVhdHVyZXMiLCAiLWFsdGl2ZWMsLXZzeCwtaGFyZC1mbG9hdCIpOworICAgICAgICB0 cy5wdXNoKCJsbHZtLXRhcmdldCIsICJwb3dlcnBjNjRsZS1saW51eC1nbnUiKTsKKyAgICAgICAg dHMucHVzaCgibWF4LWF0b21pYy13aWR0aCIsIDY0KTsKKyAgICAgICAgdHMucHVzaCgidGFyZ2V0 LW1jb3VudCIsICJfbWNvdW50Iik7CisgICAgICAgIHRzLnB1c2goInRhcmdldC1wb2ludGVyLXdp ZHRoIiwgIjY0Iik7CisgICAgfSBlbHNlIGlmIGNmZy5oYXMoIlJJU0NWIikgeworICAgICAgICBp ZiBjZmcuaGFzKCI2NEJJVCIpIHsKKyAgICAgICAgICAgIHRzLnB1c2goImFyY2giLCAicmlzY3Y2 NCIpOworICAgICAgICAgICAgdHMucHVzaCgiZGF0YS1sYXlvdXQiLCAiZS1tOmUtcDo2NDo2NC1p NjQ6NjQtaTEyODoxMjgtbjY0LVMxMjgiKTsKKyAgICAgICAgICAgIHRzLnB1c2goImxsdm0tdGFy Z2V0IiwgInJpc2N2NjQtbGludXgtZ251Iik7CisgICAgICAgICAgICB0cy5wdXNoKCJ0YXJnZXQt cG9pbnRlci13aWR0aCIsICI2NCIpOworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgdHMu cHVzaCgiYXJjaCIsICJyaXNjdjMyIik7CisgICAgICAgICAgICB0cy5wdXNoKCJkYXRhLWxheW91 dCIsICJlLW06ZS1wOjMyOjMyLWk2NDo2NC1uMzItUzEyOCIpOworICAgICAgICAgICAgdHMucHVz aCgibGx2bS10YXJnZXQiLCAicmlzY3YzMi1saW51eC1nbnUiKTsKKyAgICAgICAgICAgIHRzLnB1 c2goInRhcmdldC1wb2ludGVyLXdpZHRoIiwgIjMyIik7CisgICAgICAgIH0KKyAgICAgICAgdHMu cHVzaCgiY29kZS1tb2RlbCIsICJtZWRpdW0iKTsKKyAgICAgICAgdHMucHVzaCgiZGlzYWJsZS1y ZWR6b25lIiwgdHJ1ZSk7CisgICAgICAgIGxldCBtdXQgZmVhdHVyZXMgPSAiK20sK2EiLnRvX3N0 cmluZygpOworICAgICAgICBpZiBjZmcuaGFzKCJSSVNDVl9JU0FfQyIpIHsKKyAgICAgICAgICAg IGZlYXR1cmVzICs9ICIsK2MiOworICAgICAgICB9CisgICAgICAgIHRzLnB1c2goImZlYXR1cmVz IiwgZmVhdHVyZXMpOworICAgIH0gZWxzZSBpZiBjZmcuaGFzKCJYODZfNjQiKSB7CisgICAgICAg IHRzLnB1c2goImFyY2giLCAieDg2XzY0Iik7CisgICAgICAgIHRzLnB1c2goCisgICAgICAgICAg ICAiZGF0YS1sYXlvdXQiLAorICAgICAgICAgICAgImUtbTplLXAyNzA6MzI6MzItcDI3MTozMjoz Mi1wMjcyOjY0OjY0LWk2NDo2NC1mODA6MTI4LW44OjE2OjMyOjY0LVMxMjgiLAorICAgICAgICAp OworICAgICAgICBsZXQgbXV0IGZlYXR1cmVzID0gIi0zZG5vdywtM2Rub3dhLC1tbXgsK3NvZnQt ZmxvYXQiLnRvX3N0cmluZygpOworICAgICAgICBpZiBjZmcuaGFzKCJSRVRQT0xJTkUiKSB7Cisg ICAgICAgICAgICBmZWF0dXJlcyArPSAiLCtyZXRwb2xpbmUtZXh0ZXJuYWwtdGh1bmsiOworICAg ICAgICB9CisgICAgICAgIHRzLnB1c2goImZlYXR1cmVzIiwgZmVhdHVyZXMpOworICAgICAgICB0 cy5wdXNoKCJsbHZtLXRhcmdldCIsICJ4ODZfNjQtbGludXgtZ251Iik7CisgICAgICAgIHRzLnB1 c2goInRhcmdldC1wb2ludGVyLXdpZHRoIiwgIjY0Iik7CisgICAgfSBlbHNlIHsKKyAgICAgICAg cGFuaWMhKCJVbnN1cHBvcnRlZCBhcmNoaXRlY3R1cmUiKTsKKyAgICB9CisKKyAgICB0cy5wdXNo KCJlbWl0LWRlYnVnLWdkYi1zY3JpcHRzIiwgZmFsc2UpOworICAgIHRzLnB1c2goImZyYW1lLXBv aW50ZXIiLCAibWF5LW9taXQiKTsKKyAgICB0cy5wdXNoKAorICAgICAgICAic3RhY2stcHJvYmVz IiwKKyAgICAgICAgdmVjIVsoImtpbmQiLnRvX3N0cmluZygpLCBWYWx1ZTo6U3RyaW5nKCJub25l Ii50b19zdHJpbmcoKSkpXSwKKyAgICApOworCisgICAgLy8gRXZlcnl0aGluZyBlbHNlIGlzIExF LCB3aGV0aGVyIGBDUFVfTElUVExFX0VORElBTmAgaXMgZGVjbGFyZWQgb3Igbm90CisgICAgLy8g KGUuZy4geDg2KS4gSXQgaXMgYWxzbyBgcnVzdGNgJ3MgZGVmYXVsdC4KKyAgICBpZiBjZmcuaGFz KCJDUFVfQklHX0VORElBTiIpIHsKKyAgICAgICAgdHMucHVzaCgidGFyZ2V0LWVuZGlhbiIsICJi aWciKTsKKyAgICB9CisKKyAgICBwcmludGxuISgie30iLCB0cyk7Cit9CmRpZmYgLS1naXQgYS9z Y3JpcHRzL2lzX3J1c3RfbW9kdWxlLnNoIGIvc2NyaXB0cy9pc19ydXN0X21vZHVsZS5zaApuZXcg ZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAuLjI4YjM4MzFhNzU5MwotLS0gL2Rl di9udWxsCisrKyBiL3NjcmlwdHMvaXNfcnVzdF9tb2R1bGUuc2gKQEAgLTAsMCArMSwxNiBAQAor IyEvYmluL3NoCisjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisjCisjIGlzX3J1 c3RfbW9kdWxlLnNoIG1vZHVsZS5rbworIworIyBSZXR1cm5zIGAwYCBpZiBgbW9kdWxlLmtvYCBp cyBhIFJ1c3QgbW9kdWxlLCBgMWAgb3RoZXJ3aXNlLgorCitzZXQgLWUKKworIyBVc2luZyB0aGUg YDE2X2AgcHJlZml4IGVuc3VyZXMgb3RoZXIgc3ltYm9scyB3aXRoIHRoZSBzYW1lIHN1YnN0cmlu ZworIyBhcmUgbm90IHBpY2tlZCB1cCAoZXZlbiBpZiBpdCB3b3VsZCBiZSB1bmxpa2VseSkuIFRo ZSBsYXN0IHBhcnQgaXMKKyMgdXNlZCBqdXN0IGluIGNhc2UgTExWTSBkZWNpZGVzIHRvIHVzZSB0 aGUgYC5gIHN1ZmZpeC4KKyMKKyMgSW4gdGhlIGZ1dHVyZSwgY2hlY2tpbmcgZm9yIHRoZSBgLmNv bW1lbnRgIHNlY3Rpb24gbWF5IGJlIGFub3RoZXIKKyMgb3B0aW9uLCBzZWUgaHR0cHM6Ly9naXRo dWIuY29tL3J1c3QtbGFuZy9ydXN0L3B1bGwvOTc1NTAuCiske05NfSAiJCoiIHwgZ3JlcCAtcUUg J15bMC05YS1mQS1GXSsgciBfUlteWzpzcGFjZTpdXSsxNl9fX0lTX1JVU1RfTU9EVUxFW15bOnNw YWNlOl1dKiQnCmRpZmYgLS1naXQgYS9zY3JpcHRzL2tjb25maWcvY29uZmRhdGEuYyBiL3Njcmlw dHMva2NvbmZpZy9jb25mZGF0YS5jCmluZGV4IGM0MzQwYzkwZTE3Mi4uYjdjOWYxZGQ1ZTQyIDEw MDY0NAotLS0gYS9zY3JpcHRzL2tjb25maWcvY29uZmRhdGEuYworKysgYi9zY3JpcHRzL2tjb25m aWcvY29uZmRhdGEuYwpAQCAtMjE2LDYgKzIxNiwxMyBAQCBzdGF0aWMgY29uc3QgY2hhciAqY29u Zl9nZXRfYXV0b2hlYWRlcl9uYW1lKHZvaWQpCiAJcmV0dXJuIG5hbWUgPyBuYW1lIDogImluY2x1 ZGUvZ2VuZXJhdGVkL2F1dG9jb25mLmgiOwogfQogCitzdGF0aWMgY29uc3QgY2hhciAqY29uZl9n ZXRfcnVzdGNjZmdfbmFtZSh2b2lkKQoreworCWNoYXIgKm5hbWUgPSBnZXRlbnYoIktDT05GSUdf UlVTVENDRkciKTsKKworCXJldHVybiBuYW1lID8gbmFtZSA6ICJpbmNsdWRlL2dlbmVyYXRlZC9y dXN0Y19jZmciOworfQorCiBzdGF0aWMgaW50IGNvbmZfc2V0X3N5bV92YWwoc3RydWN0IHN5bWJv bCAqc3ltLCBpbnQgZGVmLCBpbnQgZGVmX2ZsYWdzLCBjaGFyICpwKQogewogCWNoYXIgKnAyOwpA QCAtNjA1LDYgKzYxMiw5IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgY29tbWVudF9zdHlsZSBjb21t ZW50X3N0eWxlX2MgPSB7CiAKIHN0YXRpYyB2b2lkIGNvbmZfd3JpdGVfaGVhZGluZyhGSUxFICpm cCwgY29uc3Qgc3RydWN0IGNvbW1lbnRfc3R5bGUgKmNzKQogeworCWlmICghY3MpCisJCXJldHVy bjsKKwogCWZwcmludGYoZnAsICIlc1xuIiwgY3MtPnByZWZpeCk7CiAKIAlmcHJpbnRmKGZwLCAi JXMgQXV0b21hdGljYWxseSBnZW5lcmF0ZWQgZmlsZTsgRE8gTk9UIEVESVQuXG4iLApAQCAtNzQ1 LDYgKzc1NSw2NSBAQCBzdGF0aWMgdm9pZCBwcmludF9zeW1ib2xfZm9yX2MoRklMRSAqZnAsIHN0 cnVjdCBzeW1ib2wgKnN5bSkKIAlmcmVlKGVzY2FwZWQpOwogfQogCitzdGF0aWMgdm9pZCBwcmlu dF9zeW1ib2xfZm9yX3J1c3RjY2ZnKEZJTEUgKmZwLCBzdHJ1Y3Qgc3ltYm9sICpzeW0pCit7CisJ Y29uc3QgY2hhciAqdmFsOworCWNvbnN0IGNoYXIgKnZhbF9wcmVmaXggPSAiIjsKKwljaGFyICp2 YWxfcHJlZml4ZWQgPSBOVUxMOworCXNpemVfdCB2YWxfcHJlZml4ZWRfbGVuOworCWNoYXIgKmVz Y2FwZWQgPSBOVUxMOworCisJaWYgKHN5bS0+dHlwZSA9PSBTX1VOS05PV04pCisJCXJldHVybjsK KworCXZhbCA9IHN5bV9nZXRfc3RyaW5nX3ZhbHVlKHN5bSk7CisKKwlzd2l0Y2ggKHN5bS0+dHlw ZSkgeworCWNhc2UgU19CT09MRUFOOgorCWNhc2UgU19UUklTVEFURToKKwkJLyoKKwkJICogV2Ug ZG8gbm90IGNhcmUgYWJvdXQgZGlzYWJsZWQgb25lcywgaS5lLiBubyBuZWVkIGZvcgorCQkgKiB3 aGF0IG90aGVyd2lzZSBhcmUgImNvbW1lbnRzIiBpbiBvdGhlciBwcmludGVycy4KKwkJICovCisJ CWlmICgqdmFsID09ICduJykKKwkJCXJldHVybjsKKworCQkvKgorCQkgKiBUbyBoYXZlIHNpbWls YXIgZnVuY3Rpb25hbGl0eSB0byB0aGUgQyBtYWNybyBgSVNfRU5BQkxFRCgpYAorCQkgKiB3ZSBw cm92aWRlIGFuIGVtcHR5IGAtLWNmZyBDT05GSUdfWGAgaGVyZSBpbiBib3RoIGB5YAorCQkgKiBh bmQgYG1gIGNhc2VzLgorCQkgKgorCQkgKiBUaGVuLCB0aGUgY29tbW9uIGBmcHJpbnRmKClgIGJl bG93IHdpbGwgYWxzbyBnaXZlIHVzCisJCSAqIGEgYC0tY2ZnIENPTkZJR19YPSJ5ImAgb3IgYC0t Y2ZnIENPTkZJR19YPSJtImAsIHdoaWNoIGNhbgorCQkgKiBiZSB1c2VkIGFzIHRoZSBlcXVpdmFs ZW50IG9mIGBJU19CVUlMVElOKClgL2BJU19NT0RVTEUoKWAuCisJCSAqLworCQlmcHJpbnRmKGZw LCAiLS1jZmc9JXMlc1xuIiwgQ09ORklHXywgc3ltLT5uYW1lKTsKKwkJYnJlYWs7CisJY2FzZSBT X0hFWDoKKwkJaWYgKHZhbFswXSAhPSAnMCcgfHwgKHZhbFsxXSAhPSAneCcgJiYgdmFsWzFdICE9 ICdYJykpCisJCQl2YWxfcHJlZml4ID0gIjB4IjsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJYnJl YWs7CisJfQorCisJaWYgKHN0cmxlbih2YWxfcHJlZml4KSA+IDApIHsKKwkJdmFsX3ByZWZpeGVk X2xlbiA9IHN0cmxlbih2YWwpICsgc3RybGVuKHZhbF9wcmVmaXgpICsgMTsKKwkJdmFsX3ByZWZp eGVkID0geG1hbGxvYyh2YWxfcHJlZml4ZWRfbGVuKTsKKwkJc25wcmludGYodmFsX3ByZWZpeGVk LCB2YWxfcHJlZml4ZWRfbGVuLCAiJXMlcyIsIHZhbF9wcmVmaXgsIHZhbCk7CisJCXZhbCA9IHZh bF9wcmVmaXhlZDsKKwl9CisKKwkvKiBBbGwgdmFsdWVzIGdldCBlc2NhcGVkOiB0aGUgYC0tY2Zn YCBvcHRpb24gb25seSB0YWtlcyBzdHJpbmdzICovCisJZXNjYXBlZCA9IGVzY2FwZV9zdHJpbmdf dmFsdWUodmFsKTsKKwl2YWwgPSBlc2NhcGVkOworCisJZnByaW50ZihmcCwgIi0tY2ZnPSVzJXM9 JXNcbiIsIENPTkZJR18sIHN5bS0+bmFtZSwgdmFsKTsKKworCWZyZWUoZXNjYXBlZCk7CisJZnJl ZSh2YWxfcHJlZml4ZWQpOworfQorCiAvKgogICogV3JpdGUgb3V0IGEgbWluaW1hbCBjb25maWcu CiAgKiBBbGwgdmFsdWVzIHRoYXQgaGFzIGRlZmF1bHQgdmFsdWVzIGFyZSBza2lwcGVkIGFzIHRo aXMgaXMgcmVkdW5kYW50LgpAQCAtMTEzMiw2ICsxMjAxLDEyIEBAIGludCBjb25mX3dyaXRlX2F1 dG9jb25mKGludCBvdmVyd3JpdGUpCiAJaWYgKHJldCkKIAkJcmV0dXJuIHJldDsKIAorCXJldCA9 IF9fY29uZl93cml0ZV9hdXRvY29uZihjb25mX2dldF9ydXN0Y2NmZ19uYW1lKCksCisJCQkJICAg IHByaW50X3N5bWJvbF9mb3JfcnVzdGNjZmcsCisJCQkJICAgIE5VTEwpOworCWlmIChyZXQpCisJ CXJldHVybiByZXQ7CisKIAkvKgogCSAqIENyZWF0ZSBpbmNsdWRlL2NvbmZpZy9hdXRvLmNvbmYu IFRoaXMgbXVzdCBiZSB0aGUgbGFzdCBzdGVwIGJlY2F1c2UKIAkgKiBLYnVpbGQgaGFzIGEgZGVw ZW5kZW5jeSBvbiBhdXRvLmNvbmYgYW5kIHRoaXMgbWFya3MgdGhlIHN1Y2Nlc3NmdWwKZGlmZiAt LWdpdCBhL3NjcmlwdHMvbWluLXRvb2wtdmVyc2lvbi5zaCBiL3NjcmlwdHMvbWluLXRvb2wtdmVy c2lvbi5zaAppbmRleCAyNTA5MjVhYWIxMDEuLmI2NTkzZWFjNTAwMyAxMDA3NTUKLS0tIGEvc2Ny aXB0cy9taW4tdG9vbC12ZXJzaW9uLnNoCisrKyBiL3NjcmlwdHMvbWluLXRvb2wtdmVyc2lvbi5z aApAQCAtMzAsNiArMzAsMTIgQEAgbGx2bSkKIAkJZWNobyAxMS4wLjAKIAlmaQogCTs7CitydXN0 YykKKwllY2hvIDEuNjIuMAorCTs7CitiaW5kZ2VuKQorCWVjaG8gMC41Ni4wCisJOzsKICopCiAJ ZWNobyAiJDE6IHVua25vd24gdG9vbCIgPiYyCiAJZXhpdCAxCmRpZmYgLS1naXQgYS9zY3JpcHRz L3J1c3QtaXMtYXZhaWxhYmxlLWJpbmRnZW4tbGliY2xhbmcuaCBiL3NjcmlwdHMvcnVzdC1pcy1h dmFpbGFibGUtYmluZGdlbi1saWJjbGFuZy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMC4uMGVmNmRiMTBkNjc0Ci0tLSAvZGV2L251bGwKKysrIGIvc2NyaXB0cy9ydXN0 LWlzLWF2YWlsYWJsZS1iaW5kZ2VuLWxpYmNsYW5nLmgKQEAgLTAsMCArMSwyIEBACisvKiBTUERY LUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCAqLworI3ByYWdtYSBtZXNzYWdlKCJjbGFuZyB2 ZXJzaW9uICIgX19jbGFuZ192ZXJzaW9uX18pCmRpZmYgLS1naXQgYS9zY3JpcHRzL3J1c3QtaXMt YXZhaWxhYmxlLnNoIGIvc2NyaXB0cy9ydXN0LWlzLWF2YWlsYWJsZS5zaApuZXcgZmlsZSBtb2Rl IDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAuLjBkZGFkM2ZjZDMyYwotLS0gL2Rldi9udWxsCisr KyBiL3NjcmlwdHMvcnVzdC1pcy1hdmFpbGFibGUuc2gKQEAgLTAsMCArMSwxNjAgQEAKKyMhL2Jp bi9zaAorIyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorIworIyBUZXN0cyB3aGV0 aGVyIGEgc3VpdGFibGUgUnVzdCB0b29sY2hhaW4gaXMgYXZhaWxhYmxlLgorIworIyBQYXNzIGAt dmAgZm9yIGh1bWFuIG91dHB1dCBhbmQgbW9yZSBjaGVja3MgKGFzIHdhcm5pbmdzKS4KKworc2V0 IC1lCisKK21pbl90b29sX3ZlcnNpb249JChkaXJuYW1lICQwKS9taW4tdG9vbC12ZXJzaW9uLnNo CisKKyMgQ29udmVydCB0aGUgdmVyc2lvbiBzdHJpbmcgeC55LnogdG8gYSBjYW5vbmljYWwgdXAt dG8tNy1kaWdpdHMgZm9ybS4KKyMKKyMgTm90ZSB0aGF0IHRoaXMgZnVuY3Rpb24gdXNlcyBvbmUg bW9yZSBkaWdpdCAoY29tcGFyZWQgdG8gb3RoZXIKKyMgaW5zdGFuY2VzIGluIG90aGVyIHZlcnNp b24gc2NyaXB0cykgdG8gZ2l2ZSBhIGJpdCBtb3JlIHNwYWNlIHRvCisjIGBydXN0Y2Agc2luY2Ug aXQgd2lsbCByZWFjaCAxLjEwMC4wIGluIGxhdGUgMjAyNi4KK2dldF9jYW5vbmljYWxfdmVyc2lv bigpCit7CisJSUZTPS4KKwlzZXQgLS0gJDEKKwllY2hvICQoKDEwMDAwMCAqICQxICsgMTAwICog JDIgKyAkMykpCit9CisKKyMgQ2hlY2sgdGhhdCB0aGUgUnVzdCBjb21waWxlciBleGlzdHMuCitp ZiAhIGNvbW1hbmQgLXYgIiRSVVNUQyIgPi9kZXYvbnVsbDsgdGhlbgorCWlmIFsgIiQxIiA9IC12 IF07IHRoZW4KKwkJZWNobyA+JjIgIioqKiIKKwkJZWNobyA+JjIgIioqKiBSdXN0IGNvbXBpbGVy ICckUlVTVEMnIGNvdWxkIG5vdCBiZSBmb3VuZC4iCisJCWVjaG8gPiYyICIqKioiCisJZmkKKwll eGl0IDEKK2ZpCisKKyMgQ2hlY2sgdGhhdCB0aGUgUnVzdCBiaW5kaW5ncyBnZW5lcmF0b3IgZXhp c3RzLgoraWYgISBjb21tYW5kIC12ICIkQklOREdFTiIgPi9kZXYvbnVsbDsgdGhlbgorCWlmIFsg IiQxIiA9IC12IF07IHRoZW4KKwkJZWNobyA+JjIgIioqKiIKKwkJZWNobyA+JjIgIioqKiBSdXN0 IGJpbmRpbmdzIGdlbmVyYXRvciAnJEJJTkRHRU4nIGNvdWxkIG5vdCBiZSBmb3VuZC4iCisJCWVj aG8gPiYyICIqKioiCisJZmkKKwlleGl0IDEKK2ZpCisKKyMgQ2hlY2sgdGhhdCB0aGUgUnVzdCBj b21waWxlciB2ZXJzaW9uIGlzIHN1aXRhYmxlLgorIworIyBOb24tc3RhYmxlIGFuZCBkaXN0cmli dXRpb25zJyB2ZXJzaW9ucyBtYXkgaGF2ZSBhIHZlcnNpb24gc3VmZml4LCBlLmcuIGAtZGV2YC4K K3J1c3RfY29tcGlsZXJfdmVyc2lvbj0kKCBcCisJTENfQUxMPUMgIiRSVVNUQyIgLS12ZXJzaW9u IDI+L2Rldi9udWxsIFwKKwkJfCBoZWFkIC1uIDEgXAorCQl8IGdyZXAgLW9FICdbMC05XStcLlsw LTldK1wuWzAtOV0rJyBcCispCitydXN0X2NvbXBpbGVyX21pbl92ZXJzaW9uPSQoJG1pbl90b29s X3ZlcnNpb24gcnVzdGMpCitydXN0X2NvbXBpbGVyX2N2ZXJzaW9uPSQoZ2V0X2Nhbm9uaWNhbF92 ZXJzaW9uICRydXN0X2NvbXBpbGVyX3ZlcnNpb24pCitydXN0X2NvbXBpbGVyX21pbl9jdmVyc2lv bj0kKGdldF9jYW5vbmljYWxfdmVyc2lvbiAkcnVzdF9jb21waWxlcl9taW5fdmVyc2lvbikKK2lm IFsgIiRydXN0X2NvbXBpbGVyX2N2ZXJzaW9uIiAtbHQgIiRydXN0X2NvbXBpbGVyX21pbl9jdmVy c2lvbiIgXTsgdGhlbgorCWlmIFsgIiQxIiA9IC12IF07IHRoZW4KKwkJZWNobyA+JjIgIioqKiIK KwkJZWNobyA+JjIgIioqKiBSdXN0IGNvbXBpbGVyICckUlVTVEMnIGlzIHRvbyBvbGQuIgorCQll Y2hvID4mMiAiKioqICAgWW91ciB2ZXJzaW9uOiAgICAkcnVzdF9jb21waWxlcl92ZXJzaW9uIgor CQllY2hvID4mMiAiKioqICAgTWluaW11bSB2ZXJzaW9uOiAkcnVzdF9jb21waWxlcl9taW5fdmVy c2lvbiIKKwkJZWNobyA+JjIgIioqKiIKKwlmaQorCWV4aXQgMQorZmkKK2lmIFsgIiQxIiA9IC12 IF0gJiYgWyAiJHJ1c3RfY29tcGlsZXJfY3ZlcnNpb24iIC1ndCAiJHJ1c3RfY29tcGlsZXJfbWlu X2N2ZXJzaW9uIiBdOyB0aGVuCisJZWNobyA+JjIgIioqKiIKKwllY2hvID4mMiAiKioqIFJ1c3Qg Y29tcGlsZXIgJyRSVVNUQycgaXMgdG9vIG5ldy4gVGhpcyBtYXkgb3IgbWF5IG5vdCB3b3JrLiIK KwllY2hvID4mMiAiKioqICAgWW91ciB2ZXJzaW9uOiAgICAgJHJ1c3RfY29tcGlsZXJfdmVyc2lv biIKKwllY2hvID4mMiAiKioqICAgRXhwZWN0ZWQgdmVyc2lvbjogJHJ1c3RfY29tcGlsZXJfbWlu X3ZlcnNpb24iCisJZWNobyA+JjIgIioqKiIKK2ZpCisKKyMgQ2hlY2sgdGhhdCB0aGUgUnVzdCBi aW5kaW5ncyBnZW5lcmF0b3IgaXMgc3VpdGFibGUuCisjCisjIE5vbi1zdGFibGUgYW5kIGRpc3Ry aWJ1dGlvbnMnIHZlcnNpb25zIG1heSBoYXZlIGEgdmVyc2lvbiBzdWZmaXgsIGUuZy4gYC1kZXZg LgorcnVzdF9iaW5kaW5nc19nZW5lcmF0b3JfdmVyc2lvbj0kKCBcCisJTENfQUxMPUMgIiRCSU5E R0VOIiAtLXZlcnNpb24gMj4vZGV2L251bGwgXAorCQl8IGhlYWQgLW4gMSBcCisJCXwgZ3JlcCAt b0UgJ1swLTldK1wuWzAtOV0rXC5bMC05XSsnIFwKKykKK3J1c3RfYmluZGluZ3NfZ2VuZXJhdG9y X21pbl92ZXJzaW9uPSQoJG1pbl90b29sX3ZlcnNpb24gYmluZGdlbikKK3J1c3RfYmluZGluZ3Nf Z2VuZXJhdG9yX2N2ZXJzaW9uPSQoZ2V0X2Nhbm9uaWNhbF92ZXJzaW9uICRydXN0X2JpbmRpbmdz X2dlbmVyYXRvcl92ZXJzaW9uKQorcnVzdF9iaW5kaW5nc19nZW5lcmF0b3JfbWluX2N2ZXJzaW9u PSQoZ2V0X2Nhbm9uaWNhbF92ZXJzaW9uICRydXN0X2JpbmRpbmdzX2dlbmVyYXRvcl9taW5fdmVy c2lvbikKK2lmIFsgIiRydXN0X2JpbmRpbmdzX2dlbmVyYXRvcl9jdmVyc2lvbiIgLWx0ICIkcnVz dF9iaW5kaW5nc19nZW5lcmF0b3JfbWluX2N2ZXJzaW9uIiBdOyB0aGVuCisJaWYgWyAiJDEiID0g LXYgXTsgdGhlbgorCQllY2hvID4mMiAiKioqIgorCQllY2hvID4mMiAiKioqIFJ1c3QgYmluZGlu Z3MgZ2VuZXJhdG9yICckQklOREdFTicgaXMgdG9vIG9sZC4iCisJCWVjaG8gPiYyICIqKiogICBZ b3VyIHZlcnNpb246ICAgICRydXN0X2JpbmRpbmdzX2dlbmVyYXRvcl92ZXJzaW9uIgorCQllY2hv ID4mMiAiKioqICAgTWluaW11bSB2ZXJzaW9uOiAkcnVzdF9iaW5kaW5nc19nZW5lcmF0b3JfbWlu X3ZlcnNpb24iCisJCWVjaG8gPiYyICIqKioiCisJZmkKKwlleGl0IDEKK2ZpCitpZiBbICIkMSIg PSAtdiBdICYmIFsgIiRydXN0X2JpbmRpbmdzX2dlbmVyYXRvcl9jdmVyc2lvbiIgLWd0ICIkcnVz dF9iaW5kaW5nc19nZW5lcmF0b3JfbWluX2N2ZXJzaW9uIiBdOyB0aGVuCisJZWNobyA+JjIgIioq KiIKKwllY2hvID4mMiAiKioqIFJ1c3QgYmluZGluZ3MgZ2VuZXJhdG9yICckQklOREdFTicgaXMg dG9vIG5ldy4gVGhpcyBtYXkgb3IgbWF5IG5vdCB3b3JrLiIKKwllY2hvID4mMiAiKioqICAgWW91 ciB2ZXJzaW9uOiAgICAgJHJ1c3RfYmluZGluZ3NfZ2VuZXJhdG9yX3ZlcnNpb24iCisJZWNobyA+ JjIgIioqKiAgIEV4cGVjdGVkIHZlcnNpb246ICRydXN0X2JpbmRpbmdzX2dlbmVyYXRvcl9taW5f dmVyc2lvbiIKKwllY2hvID4mMiAiKioqIgorZmkKKworIyBDaGVjayB0aGF0IHRoZSBgbGliY2xh bmdgIHVzZWQgYnkgdGhlIFJ1c3QgYmluZGluZ3MgZ2VuZXJhdG9yIGlzIHN1aXRhYmxlLgorYmlu ZGdlbl9saWJjbGFuZ192ZXJzaW9uPSQoIFwKKwlMQ19BTEw9QyAiJEJJTkRHRU4iICQoZGlybmFt ZSAkMCkvcnVzdC1pcy1hdmFpbGFibGUtYmluZGdlbi1saWJjbGFuZy5oIDI+JjEgPi9kZXYvbnVs bCBcCisJCXwgZ3JlcCAtRiAnY2xhbmcgdmVyc2lvbiAnIFwKKwkJfCBncmVwIC1vRSAnWzAtOV0r XC5bMC05XStcLlswLTldKycgXAorCQl8IGhlYWQgLW4gMSBcCispCitiaW5kZ2VuX2xpYmNsYW5n X21pbl92ZXJzaW9uPSQoJG1pbl90b29sX3ZlcnNpb24gbGx2bSkKK2JpbmRnZW5fbGliY2xhbmdf Y3ZlcnNpb249JChnZXRfY2Fub25pY2FsX3ZlcnNpb24gJGJpbmRnZW5fbGliY2xhbmdfdmVyc2lv bikKK2JpbmRnZW5fbGliY2xhbmdfbWluX2N2ZXJzaW9uPSQoZ2V0X2Nhbm9uaWNhbF92ZXJzaW9u ICRiaW5kZ2VuX2xpYmNsYW5nX21pbl92ZXJzaW9uKQoraWYgWyAiJGJpbmRnZW5fbGliY2xhbmdf Y3ZlcnNpb24iIC1sdCAiJGJpbmRnZW5fbGliY2xhbmdfbWluX2N2ZXJzaW9uIiBdOyB0aGVuCisJ aWYgWyAiJDEiID0gLXYgXTsgdGhlbgorCQllY2hvID4mMiAiKioqIgorCQllY2hvID4mMiAiKioq IGxpYmNsYW5nICh1c2VkIGJ5IHRoZSBSdXN0IGJpbmRpbmdzIGdlbmVyYXRvciAnJEJJTkRHRU4n KSBpcyB0b28gb2xkLiIKKwkJZWNobyA+JjIgIioqKiAgIFlvdXIgdmVyc2lvbjogICAgJGJpbmRn ZW5fbGliY2xhbmdfdmVyc2lvbiIKKwkJZWNobyA+JjIgIioqKiAgIE1pbmltdW0gdmVyc2lvbjog JGJpbmRnZW5fbGliY2xhbmdfbWluX3ZlcnNpb24iCisJCWVjaG8gPiYyICIqKioiCisJZmkKKwll eGl0IDEKK2ZpCisKKyMgSWYgdGhlIEMgY29tcGlsZXIgaXMgQ2xhbmcsIHRoZW4gd2UgY2FuIGFs c28gY2hlY2sgd2hldGhlciBpdHMgdmVyc2lvbgorIyBtYXRjaGVzIHRoZSBgbGliY2xhbmdgIHZl cnNpb24gdXNlZCBieSB0aGUgUnVzdCBiaW5kaW5ncyBnZW5lcmF0b3IuCisjCisjIEluIHRoZSBm dXR1cmUsIHdlIG1pZ2h0IGJlIGFibGUgdG8gcGVyZm9ybSBhIGZ1bGwgdmVyc2lvbiBjaGVjaywg c2VlCisjIGh0dHBzOi8vZ2l0aHViLmNvbS9ydXN0LWxhbmcvcnVzdC1iaW5kZ2VuL2lzc3Vlcy8y MTM4LgoraWYgWyAiJDEiID0gLXYgXTsgdGhlbgorCWNjX25hbWU9JCgkKGRpcm5hbWUgJDApL2Nj LXZlcnNpb24uc2ggIiRDQyIgfCBjdXQgLWYxIC1kJyAnKQorCWlmIFsgIiRjY19uYW1lIiA9IENs YW5nIF07IHRoZW4KKwkJY2xhbmdfdmVyc2lvbj0kKCBcCisJCQlMQ19BTEw9QyAiJENDIiAtLXZl cnNpb24gMj4vZGV2L251bGwgXAorCQkJCXwgc2VkIC1uRSAnMXM6Lip2ZXJzaW9uIChbMC05XStc LlswLTldK1wuWzAtOV0rKS4qOlwxOnAnCisJCSkKKwkJaWYgWyAiJGNsYW5nX3ZlcnNpb24iICE9 ICIkYmluZGdlbl9saWJjbGFuZ192ZXJzaW9uIiBdOyB0aGVuCisJCQllY2hvID4mMiAiKioqIgor CQkJZWNobyA+JjIgIioqKiBsaWJjbGFuZyAodXNlZCBieSB0aGUgUnVzdCBiaW5kaW5ncyBnZW5l cmF0b3IgJyRCSU5ER0VOJykiCisJCQllY2hvID4mMiAiKioqIHZlcnNpb24gZG9lcyBub3QgbWF0 Y2ggQ2xhbmcncy4gVGhpcyBtYXkgYmUgYSBwcm9ibGVtLiIKKwkJCWVjaG8gPiYyICIqKiogICBs aWJjbGFuZyB2ZXJzaW9uOiAkYmluZGdlbl9saWJjbGFuZ192ZXJzaW9uIgorCQkJZWNobyA+JjIg IioqKiAgIENsYW5nIHZlcnNpb246ICAgICRjbGFuZ192ZXJzaW9uIgorCQkJZWNobyA+JjIgIioq KiIKKwkJZmkKKwlmaQorZmkKKworIyBDaGVjayB0aGF0IHRoZSBzb3VyY2UgY29kZSBmb3IgdGhl IGBjb3JlYCBzdGFuZGFyZCBsaWJyYXJ5IGV4aXN0cy4KKyMKKyMgYCRLUlVTVEZMQUdTYCBpcyBw YXNzZWQgaW4gY2FzZSB0aGUgdXNlciBhZGRlZCBgLS1zeXNyb290YC4KK3J1c3RjX3N5c3Jvb3Q9 JCgiJFJVU1RDIiAkS1JVU1RGTEFHUyAtLXByaW50IHN5c3Jvb3QpCitydXN0Y19zcmM9JHtSVVNU X0xJQl9TUkM6LSIkcnVzdGNfc3lzcm9vdC9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5In0K K3J1c3RjX3NyY19jb3JlPSIkcnVzdGNfc3JjL2NvcmUvc3JjL2xpYi5ycyIKK2lmIFsgISAtZSAi JHJ1c3RjX3NyY19jb3JlIiBdOyB0aGVuCisJaWYgWyAiJDEiID0gLXYgXTsgdGhlbgorCQllY2hv ID4mMiAiKioqIgorCQllY2hvID4mMiAiKioqIFNvdXJjZSBjb2RlIGZvciB0aGUgJ2NvcmUnIHN0 YW5kYXJkIGxpYnJhcnkgY291bGQgbm90IGJlIGZvdW5kIgorCQllY2hvID4mMiAiKioqIGF0ICck cnVzdGNfc3JjX2NvcmUnLiIKKwkJZWNobyA+JjIgIioqKiIKKwlmaQorCWV4aXQgMQorZmkKLS0g CjIuMzcuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CmxpbnV4LXJpc2N2IG1haWxpbmcgbGlzdApsaW51eC1yaXNjdkBsaXN0cy5pbmZyYWRlYWQub3Jn Cmh0dHA6Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtcmlzY3YK From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: From: Miguel Ojeda Subject: [PATCH v8 27/31] Kbuild: add Rust support Date: Tue, 2 Aug 2022 03:50:14 +0200 Message-Id: <20220802015052.10452-28-ojeda@kernel.org> In-Reply-To: <20220802015052.10452-1-ojeda@kernel.org> References: <20220802015052.10452-1-ojeda@kernel.org> MIME-Version: 1.0 List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Sender: "linux-um" Errors-To: linux-um-bounces+geert=linux-m68k.org@lists.infradead.org To: Linus Torvalds , Greg Kroah-Hartman Cc: rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, Jarkko Sakkinen , Miguel Ojeda , Alex Gaynor , Finn Behrens , Adam Bratschi-Kaye , Wedson Almeida Filho , Michael Ellerman , Sven Van Asbroeck , Gary Guo , Boris-Chengbiao Zhou , Boqun Feng , Douglas Su , Dariusz Sosnowski , Antonio Terceiro , Daniel Xu , Miguel Cano , David Gow , Tiago Lam , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Martin Rodriguez Reboredo , Masahiro Yamada , Michal Marek , Nick Desaulniers , Russell King , Catalin Marinas , Will Deacon , Benjamin Herrenschmidt , Paul Mackerras , Paul Walmsley , Palmer Dabbelt , Albert Ou , Richard Weinberger , Anton Ivanov , Johannes Berg , Thomas Gleixner , Ingo Molnar , Borislav Petkov , Dave Hansen , x86@kernel.org, "H. Peter Anvin" , linux-kbuild@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linuxppc-dev@lists.ozlabs.org, linux-riscv@lists.infradead.org, linux-um@lists.infradead.org SGF2aW5nIGFsbCB0aGUgbmV3IGZpbGVzIGluIHBsYWNlLCB3ZSBub3cgZW5hYmxlIFJ1c3Qgc3Vw cG9ydAppbiB0aGUgYnVpbGQgc3lzdGVtLCBpbmNsdWRpbmcgYEtjb25maWdgIGVudHJpZXMgcmVs YXRlZCB0byBSdXN0LAp0aGUgUnVzdCBjb25maWd1cmF0aW9uIHByaW50ZXIsIHRoZSB0YXJnZXQg c3BlY2lmaWNhdGlvbgpnZW5lcmF0aW9uIHNjcmlwdCwgdGhlIHZlcnNpb24gZGV0ZWN0aW9uIHNj cmlwdCBhbmQgYSBmZXcKb3RoZXIgYml0cy4KCkNvLWRldmVsb3BlZC1ieTogQWxleCBHYXlub3Ig PGFsZXguZ2F5bm9yQGdtYWlsLmNvbT4KU2lnbmVkLW9mZi1ieTogQWxleCBHYXlub3IgPGFsZXgu Z2F5bm9yQGdtYWlsLmNvbT4KQ28tZGV2ZWxvcGVkLWJ5OiBGaW5uIEJlaHJlbnMgPG1lQGtsb2Vu ay5kZT4KU2lnbmVkLW9mZi1ieTogRmlubiBCZWhyZW5zIDxtZUBrbG9lbmsuZGU+CkNvLWRldmVs b3BlZC1ieTogQWRhbSBCcmF0c2NoaS1LYXllIDxhcmsuZW1haWxAZ21haWwuY29tPgpTaWduZWQt b2ZmLWJ5OiBBZGFtIEJyYXRzY2hpLUtheWUgPGFyay5lbWFpbEBnbWFpbC5jb20+CkNvLWRldmVs b3BlZC1ieTogV2Vkc29uIEFsbWVpZGEgRmlsaG8gPHdlZHNvbmFmQGdvb2dsZS5jb20+ClNpZ25l ZC1vZmYtYnk6IFdlZHNvbiBBbG1laWRhIEZpbGhvIDx3ZWRzb25hZkBnb29nbGUuY29tPgpDby1k ZXZlbG9wZWQtYnk6IE1pY2hhZWwgRWxsZXJtYW4gPG1wZUBlbGxlcm1hbi5pZC5hdT4KU2lnbmVk LW9mZi1ieTogTWljaGFlbCBFbGxlcm1hbiA8bXBlQGVsbGVybWFuLmlkLmF1PgpDby1kZXZlbG9w ZWQtYnk6IFN2ZW4gVmFuIEFzYnJvZWNrIDx0aGVzdmVuNzNAZ21haWwuY29tPgpTaWduZWQtb2Zm LWJ5OiBTdmVuIFZhbiBBc2Jyb2VjayA8dGhlc3ZlbjczQGdtYWlsLmNvbT4KQ28tZGV2ZWxvcGVk LWJ5OiBHYXJ5IEd1byA8Z2FyeUBnYXJ5Z3VvLm5ldD4KU2lnbmVkLW9mZi1ieTogR2FyeSBHdW8g PGdhcnlAZ2FyeWd1by5uZXQ+CkNvLWRldmVsb3BlZC1ieTogQm9yaXMtQ2hlbmdiaWFvIFpob3Ug PGJvYm8xMjM5QHdlYi5kZT4KU2lnbmVkLW9mZi1ieTogQm9yaXMtQ2hlbmdiaWFvIFpob3UgPGJv Ym8xMjM5QHdlYi5kZT4KQ28tZGV2ZWxvcGVkLWJ5OiBCb3F1biBGZW5nIDxib3F1bi5mZW5nQGdt YWlsLmNvbT4KU2lnbmVkLW9mZi1ieTogQm9xdW4gRmVuZyA8Ym9xdW4uZmVuZ0BnbWFpbC5jb20+ CkNvLWRldmVsb3BlZC1ieTogRG91Z2xhcyBTdSA8ZDB1OS5zdUBvdXRsb29rLmNvbT4KU2lnbmVk LW9mZi1ieTogRG91Z2xhcyBTdSA8ZDB1OS5zdUBvdXRsb29rLmNvbT4KQ28tZGV2ZWxvcGVkLWJ5 OiBEYXJpdXN6IFNvc25vd3NraSA8ZHNvc25vd3NraUBkc29zbm93c2tpLnBsPgpTaWduZWQtb2Zm LWJ5OiBEYXJpdXN6IFNvc25vd3NraSA8ZHNvc25vd3NraUBkc29zbm93c2tpLnBsPgpDby1kZXZl bG9wZWQtYnk6IEFudG9uaW8gVGVyY2Vpcm8gPGFudG9uaW8udGVyY2Vpcm9AbGluYXJvLm9yZz4K U2lnbmVkLW9mZi1ieTogQW50b25pbyBUZXJjZWlybyA8YW50b25pby50ZXJjZWlyb0BsaW5hcm8u b3JnPgpDby1kZXZlbG9wZWQtYnk6IERhbmllbCBYdSA8ZHh1QGR4dXV1Lnh5ej4KU2lnbmVkLW9m Zi1ieTogRGFuaWVsIFh1IDxkeHVAZHh1dXUueHl6PgpDby1kZXZlbG9wZWQtYnk6IE1pZ3VlbCBD YW5vIDxtYWNhbnJvakBnbWFpbC5jb20+ClNpZ25lZC1vZmYtYnk6IE1pZ3VlbCBDYW5vIDxtYWNh bnJvakBnbWFpbC5jb20+CkNvLWRldmVsb3BlZC1ieTogRGF2aWQgR293IDxkYXZpZGdvd0Bnb29n bGUuY29tPgpTaWduZWQtb2ZmLWJ5OiBEYXZpZCBHb3cgPGRhdmlkZ293QGdvb2dsZS5jb20+CkNv LWRldmVsb3BlZC1ieTogVGlhZ28gTGFtIDx0aWFnb2xhbUBnbWFpbC5jb20+ClNpZ25lZC1vZmYt Ynk6IFRpYWdvIExhbSA8dGlhZ29sYW1AZ21haWwuY29tPgpDby1kZXZlbG9wZWQtYnk6IEJqw7Zy biBSb3kgQmFyb24gPGJqb3JuM19naEBwcm90b25tYWlsLmNvbT4KU2lnbmVkLW9mZi1ieTogQmrD tnJuIFJveSBCYXJvbiA8Ympvcm4zX2doQHByb3Rvbm1haWwuY29tPgpDby1kZXZlbG9wZWQtYnk6 IE1hcnRpbiBSb2RyaWd1ZXogUmVib3JlZG8gPHlha295b2t1QGdtYWlsLmNvbT4KU2lnbmVkLW9m Zi1ieTogTWFydGluIFJvZHJpZ3VleiBSZWJvcmVkbyA8eWFrb3lva3VAZ21haWwuY29tPgpTaWdu ZWQtb2ZmLWJ5OiBNaWd1ZWwgT2plZGEgPG9qZWRhQGtlcm5lbC5vcmc+Ci0tLQogLmdpdGlnbm9y ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDYgKwogLnJ1c3RmbXQudG9t bCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMTIgKwogTWFrZWZpbGUgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAxNzIgKysrKysrKy0KIGFyY2gvS2NvbmZp ZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICA2ICsKIGFyY2gvYXJtL0tjb25m aWcgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvYXJtNjQvS2NvbmZp ZyAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvcG93ZXJwYy9LY29uZmln ICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvcmlzY3YvS2NvbmZpZyAgICAg ICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvcmlzY3YvTWFrZWZpbGUgICAgICAg ICAgICAgICAgICAgICAgICAgIHwgICA1ICsKIGFyY2gvdW0vS2NvbmZpZyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gveDg2L0tjb25maWcgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHwgICAxICsKIGFyY2gveDg2L01ha2VmaWxlICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgIDEwICsKIGluY2x1ZGUvbGludXgvY29tcGlsZXJfdHlwZXMuaCAgICAgICAg ICAgICAgIHwgICA2ICstCiBpbml0L0tjb25maWcgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICB8ICA0NiArLQogbGliL0tjb25maWcuZGVidWcgICAgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgODIgKysrKwogcnVzdC8uZ2l0aWdub3JlICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgMTAgKwogcnVzdC9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg fCA0MTUgKysrKysrKysrKysrKysrKysrKwogcnVzdC9iaW5kZ2VuX3BhcmFtZXRlcnMgICAgICAg ICAgICAgICAgICAgICAgfCAgMjEgKwogc2NyaXB0cy8uZ2l0aWdub3JlICAgICAgICAgICAgICAg ICAgICAgICAgICAgfCAgIDEgKwogc2NyaXB0cy9LY29uZmlnLmluY2x1ZGUgICAgICAgICAgICAg ICAgICAgICAgfCAgIDYgKy0KIHNjcmlwdHMvTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHwgICAzICsKIHNjcmlwdHMvTWFrZWZpbGUuYnVpbGQgICAgICAgICAgICAgICAgICAg ICAgIHwgIDYwICsrKwogc2NyaXB0cy9NYWtlZmlsZS5kZWJ1ZyAgICAgICAgICAgICAgICAgICAg ICAgfCAgMTAgKwogc2NyaXB0cy9NYWtlZmlsZS5ob3N0ICAgICAgICAgICAgICAgICAgICAgICAg fCAgMzQgKy0KIHNjcmlwdHMvTWFrZWZpbGUubGliICAgICAgICAgICAgICAgICAgICAgICAgIHwg IDEyICsKIHNjcmlwdHMvTWFrZWZpbGUubW9kZmluYWwgICAgICAgICAgICAgICAgICAgIHwgICA4 ICstCiBzY3JpcHRzL2NjLXZlcnNpb24uc2ggICAgICAgICAgICAgICAgICAgICAgICB8ICAxMiAr LQogc2NyaXB0cy9nZW5lcmF0ZV9ydXN0X3RhcmdldC5ycyAgICAgICAgICAgICAgfCAyMzIgKysr KysrKysrKysKIHNjcmlwdHMvaXNfcnVzdF9tb2R1bGUuc2ggICAgICAgICAgICAgICAgICAgIHwg IDE2ICsKIHNjcmlwdHMva2NvbmZpZy9jb25mZGF0YS5jICAgICAgICAgICAgICAgICAgIHwgIDc1 ICsrKysKIHNjcmlwdHMvbWluLXRvb2wtdmVyc2lvbi5zaCAgICAgICAgICAgICAgICAgIHwgICA2 ICsKIHNjcmlwdHMvcnVzdC1pcy1hdmFpbGFibGUtYmluZGdlbi1saWJjbGFuZy5oIHwgICAyICsK IHNjcmlwdHMvcnVzdC1pcy1hdmFpbGFibGUuc2ggICAgICAgICAgICAgICAgIHwgMTYwICsrKysr KysKIDMzIGZpbGVzIGNoYW5nZWQsIDE0MDggaW5zZXJ0aW9ucygrKSwgMjYgZGVsZXRpb25zKC0p CiBjcmVhdGUgbW9kZSAxMDA2NDQgLnJ1c3RmbXQudG9tbAogY3JlYXRlIG1vZGUgMTAwNjQ0IHJ1 c3QvLmdpdGlnbm9yZQogY3JlYXRlIG1vZGUgMTAwNjQ0IHJ1c3QvTWFrZWZpbGUKIGNyZWF0ZSBt b2RlIDEwMDY0NCBydXN0L2JpbmRnZW5fcGFyYW1ldGVycwogY3JlYXRlIG1vZGUgMTAwNjQ0IHNj cmlwdHMvZ2VuZXJhdGVfcnVzdF90YXJnZXQucnMKIGNyZWF0ZSBtb2RlIDEwMDc1NSBzY3JpcHRz L2lzX3J1c3RfbW9kdWxlLnNoCiBjcmVhdGUgbW9kZSAxMDA2NDQgc2NyaXB0cy9ydXN0LWlzLWF2 YWlsYWJsZS1iaW5kZ2VuLWxpYmNsYW5nLmgKIGNyZWF0ZSBtb2RlIDEwMDc1NSBzY3JpcHRzL3J1 c3QtaXMtYXZhaWxhYmxlLnNoCgpkaWZmIC0tZ2l0IGEvLmdpdGlnbm9yZSBiLy5naXRpZ25vcmUK aW5kZXggMjY1OTU5NTQ0OTc4Li41ZGEwMDQ4MTQ2NzggMTAwNjQ0Ci0tLSBhLy5naXRpZ25vcmUK KysrIGIvLmdpdGlnbm9yZQpAQCAtMzcsNiArMzcsOCBAQAogKi5vCiAqLm8uKgogKi5wYXRjaAor Ki5ybWV0YQorKi5yc2kKICoucwogKi5zbwogKi5zby5kYmcKQEAgLTk3LDYgKzk5LDcgQEAgbW9k dWxlcy5vcmRlcgogIS5naXRhdHRyaWJ1dGVzCiAhLmdpdGlnbm9yZQogIS5tYWlsbWFwCishLnJ1 c3RmbXQudG9tbAogCiAjCiAjIEdlbmVyYXRlZCBpbmNsdWRlIGZpbGVzCkBAIC0xNjIsMyArMTY1 LDYgQEAgeDUwOS5nZW5rZXkKIAogIyBEb2N1bWVudGF0aW9uIHRvb2xjaGFpbgogc3BoaW54Xyov CisKKyMgUnVzdCBhbmFseXplciBjb25maWd1cmF0aW9uCisvcnVzdC1wcm9qZWN0Lmpzb24KZGlm ZiAtLWdpdCBhLy5ydXN0Zm10LnRvbWwgYi8ucnVzdGZtdC50b21sCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uM2RlNWNjNDk3NDY1Ci0tLSAvZGV2L251bGwKKysrIGIv LnJ1c3RmbXQudG9tbApAQCAtMCwwICsxLDEyIEBACitlZGl0aW9uID0gIjIwMjEiCituZXdsaW5l X3N0eWxlID0gIlVuaXgiCisKKyMgVW5zdGFibGUgb3B0aW9ucyB0aGF0IGhlbHAgY2F0Y2hpbmcg c29tZSBtaXN0YWtlcyBpbiBmb3JtYXR0aW5nIGFuZCB0aGF0IHdlIG1heSB3YW50IHRvIGVuYWJs ZQorIyB3aGVuIHRoZXkgYmVjb21lIHN0YWJsZS4KKyMKKyMgVGhleSBhcmUga2VwdCBoZXJlIHNp bmNlIHRoZXkgYXJlIHVzZWZ1bCB0byBydW4gZnJvbSB0aW1lIHRvIHRpbWUuCisjZm9ybWF0X2Nv ZGVfaW5fZG9jX2NvbW1lbnRzID0gdHJ1ZQorI3Jlb3JkZXJfaW1wbF9pdGVtcyA9IHRydWUKKyNj b21tZW50X3dpZHRoID0gMTAwCisjd3JhcF9jb21tZW50cyA9IHRydWUKKyNub3JtYWxpemVfY29t bWVudHMgPSB0cnVlCmRpZmYgLS1naXQgYS9NYWtlZmlsZSBiL01ha2VmaWxlCmluZGV4IGRmOTI4 OTIzMjVhZS4uY2QxZDU0NWYzMTZiIDEwMDY0NAotLS0gYS9NYWtlZmlsZQorKysgYi9NYWtlZmls ZQpAQCAtMTIwLDYgKzEyMCwxNSBAQCBlbmRpZgogCiBleHBvcnQgS0JVSUxEX0NIRUNLU1JDCiAK KyMgRW5hYmxlICJjbGlwcHkiIChhIGxpbnRlcikgYXMgcGFydCBvZiB0aGUgUnVzdCBjb21waWxh dGlvbi4KKyMKKyMgVXNlICdtYWtlIENMSVBQWT0xJyB0byBlbmFibGUgaXQuCitpZmVxICgiJChv cmlnaW4gQ0xJUFBZKSIsICJjb21tYW5kIGxpbmUiKQorICBLQlVJTERfQ0xJUFBZIDo9ICQoQ0xJ UFBZKQorZW5kaWYKKworZXhwb3J0IEtCVUlMRF9DTElQUFkKKwogIyBVc2UgbWFrZSBNPWRpciBv ciBzZXQgdGhlIGVudmlyb25tZW50IHZhcmlhYmxlIEtCVUlMRF9FWFRNT0QgdG8gc3BlY2lmeSB0 aGUKICMgZGlyZWN0b3J5IG9mIGV4dGVybmFsIG1vZHVsZSB0byBidWlsZC4gU2V0dGluZyBNPSB0 YWtlcyBwcmVjZWRlbmNlLgogaWZlcSAoIiQob3JpZ2luIE0pIiwgImNvbW1hbmQgbGluZSIpCkBA IC0yNjcsMTQgKzI3NiwxNCBAQCBuby1kb3QtY29uZmlnLXRhcmdldHMgOj0gJChjbGVhbi10YXJn ZXRzKSBcCiAJCQkgY3Njb3BlIGd0YWdzIFRBR1MgdGFncyBoZWxwJSAlZG9jcyBjaGVjayUgY29j Y2ljaGVjayBcCiAJCQkgJCh2ZXJzaW9uX2gpIGhlYWRlcnMgaGVhZGVyc18lIGFyY2hoZWFkZXJz IGFyY2hzY3JpcHRzIFwKIAkJCSAlYXNtLWdlbmVyaWMga2VybmVsdmVyc2lvbiAlc3JjLXBrZyBk dF9iaW5kaW5nX2NoZWNrIFwKLQkJCSBvdXRwdXRtYWtlZmlsZQorCQkJIG91dHB1dG1ha2VmaWxl IHJ1c3RhdmFpbGFibGUgcnVzdGZtdCBydXN0Zm10Y2hlY2sKICMgSW5zdGFsbGF0aW9uIHRhcmdl dHMgc2hvdWxkIG5vdCByZXF1aXJlIGNvbXBpbGVyLiBVbmZvcnR1bmF0ZWx5LCB2ZHNvX2luc3Rh bGwKICMgaXMgYW4gZXhjZXB0aW9uIHdoZXJlIGJ1aWxkIGFydGlmYWN0cyBtYXkgYmUgdXBkYXRl ZC4gVGhpcyBtdXN0IGJlIGZpeGVkLgogbm8tY29tcGlsZXItdGFyZ2V0cyA6PSAkKG5vLWRvdC1j b25maWctdGFyZ2V0cykgaW5zdGFsbCBkdGJzX2luc3RhbGwgXAogCQkJaGVhZGVyc19pbnN0YWxs IG1vZHVsZXNfaW5zdGFsbCBrZXJuZWxyZWxlYXNlIGltYWdlX25hbWUKIG5vLXN5bmMtY29uZmln LXRhcmdldHMgOj0gJChuby1kb3QtY29uZmlnLXRhcmdldHMpICVpbnN0YWxsIGtlcm5lbHJlbGVh c2UgXAogCQkJICBpbWFnZV9uYW1lCi1zaW5nbGUtdGFyZ2V0cyA6PSAlLmEgJS5pICUua28gJS5s ZHMgJS5sbCAlLmxzdCAlLm1vZCAlLm8gJS5zICUuc3ltdHlwZXMgJS8KK3NpbmdsZS10YXJnZXRz IDo9ICUuYSAlLmkgJS5yc2kgJS5rbyAlLmxkcyAlLmxsICUubHN0ICUubW9kICUubyAlLnMgJS5z eW10eXBlcyAlLwogCiBjb25maWctYnVpbGQJOj0KIG1peGVkLWJ1aWxkCTo9CkBAIC00MzYsNiAr NDQ1LDcgQEAgZWxzZQogSE9TVENDCT0gZ2NjCiBIT1NUQ1hYCT0gZysrCiBlbmRpZgorSE9TVFJV U1RDID0gcnVzdGMKIEhPU1RQS0dfQ09ORklHCT0gcGtnLWNvbmZpZwogCiBLQlVJTERfVVNFUkhP U1RDRkxBR1MgOj0gLVdhbGwgLVdtaXNzaW5nLXByb3RvdHlwZXMgLVdzdHJpY3QtcHJvdG90eXBl cyBcCkBAIC00NDQsOCArNDU0LDI2IEBAIEtCVUlMRF9VU0VSSE9TVENGTEFHUyA6PSAtV2FsbCAt V21pc3NpbmctcHJvdG90eXBlcyAtV3N0cmljdC1wcm90b3R5cGVzIFwKIEtCVUlMRF9VU0VSQ0ZM QUdTICA6PSAkKEtCVUlMRF9VU0VSSE9TVENGTEFHUykgJChVU0VSQ0ZMQUdTKQogS0JVSUxEX1VT RVJMREZMQUdTIDo9ICQoVVNFUkxERkxBR1MpCiAKKyMgVGhlc2UgZmxhZ3MgYXBwbHkgdG8gYWxs IFJ1c3QgY29kZSBpbiB0aGUgdHJlZSwgaW5jbHVkaW5nIHRoZSBrZXJuZWwgYW5kCisjIGhvc3Qg cHJvZ3JhbXMuCitleHBvcnQgcnVzdF9jb21tb25fZmxhZ3MgOj0gLS1lZGl0aW9uPTIwMjEgXAor CQkJICAgIC1aYmluYXJ5X2RlcF9kZXBpbmZvPXkgXAorCQkJICAgIC1EdW5zYWZlX29wX2luX3Vu c2FmZV9mbiAtRHJ1c3RfMjAxOF9pZGlvbXMgXAorCQkJICAgIC1EdW5yZWFjaGFibGVfcHViIC1E bm9uX2FzY2lpX2lkZW50cyBcCisJCQkgICAgLVdtaXNzaW5nX2RvY3MgXAorCQkJICAgIC1EcnVz dGRvYzo6bWlzc2luZ19jcmF0ZV9sZXZlbF9kb2NzIFwKKwkJCSAgICAtRGNsaXBweTo6Y29ycmVj dG5lc3MgLURjbGlwcHk6OnN0eWxlIFwKKwkJCSAgICAtRGNsaXBweTo6c3VzcGljaW91cyAtRGNs aXBweTo6Y29tcGxleGl0eSBcCisJCQkgICAgLURjbGlwcHk6OnBlcmYgXAorCQkJICAgIC1EY2xp cHB5OjpsZXRfdW5pdF92YWx1ZSAtRGNsaXBweTo6bXV0X211dCBcCisJCQkgICAgLURjbGlwcHk6 Om5lZWRsZXNzX2JpdHdpc2VfYm9vbCBcCisJCQkgICAgLURjbGlwcHk6Om5lZWRsZXNzX2NvbnRp bnVlIFwKKwkJCSAgICAtV2NsaXBweTo6ZGJnX21hY3JvCisKIEtCVUlMRF9IT1NUQ0ZMQUdTICAg Oj0gJChLQlVJTERfVVNFUkhPU1RDRkxBR1MpICQoSE9TVF9MRlNfQ0ZMQUdTKSAkKEhPU1RDRkxB R1MpCiBLQlVJTERfSE9TVENYWEZMQUdTIDo9IC1XYWxsIC1PMiAkKEhPU1RfTEZTX0NGTEFHUykg JChIT1NUQ1hYRkxBR1MpCitLQlVJTERfSE9TVFJVU1RGTEFHUyA6PSAkKHJ1c3RfY29tbW9uX2Zs YWdzKSAtTyAtQ3N0cmlwPWRlYnVnaW5mbyBcCisJCQktWmFsbG93LWZlYXR1cmVzPSAkKEhPU1RS VVNURkxBR1MpCiBLQlVJTERfSE9TVExERkxBR1MgIDo9ICQoSE9TVF9MRlNfTERGTEFHUykgJChI T1NUTERGTEFHUykKIEtCVUlMRF9IT1NUTERMSUJTICAgOj0gJChIT1NUX0xGU19MSUJTKSAkKEhP U1RMRExJQlMpCiAKQEAgLTQ3MCw2ICs0OTgsMTIgQEAgT0JKRFVNUAkJPSAkKENST1NTX0NPTVBJ TEUpb2JqZHVtcAogUkVBREVMRgkJPSAkKENST1NTX0NPTVBJTEUpcmVhZGVsZgogU1RSSVAJCT0g JChDUk9TU19DT01QSUxFKXN0cmlwCiBlbmRpZgorUlVTVEMJCT0gcnVzdGMKK1JVU1RET0MJCT0g cnVzdGRvYworUlVTVEZNVAkJPSBydXN0Zm10CitDTElQUFlfRFJJVkVSCT0gY2xpcHB5LWRyaXZl cgorQklOREdFTgkJPSBiaW5kZ2VuCitDQVJHTwkJPSBjYXJnbwogUEFIT0xFCQk9IHBhaG9sZQog UkVTT0xWRV9CVEZJRFMJPSAkKG9ianRyZWUpL3Rvb2xzL2JwZi9yZXNvbHZlX2J0Zmlkcy9yZXNv bHZlX2J0ZmlkcwogTEVYCQk9IGZsZXgKQEAgLTQ5NSw5ICs1MjksMTEgQEAgQ0hFQ0tGTEFHUyAg ICAgOj0gLURfX2xpbnV4X18gLURsaW51eCAtRF9fU1REQ19fIC1EdW5peCAtRF9fdW5peF9fIFwK IAkJICAtV2JpdHdpc2UgLVduby1yZXR1cm4tdm9pZCAtV25vLXVua25vd24tYXR0cmlidXRlICQo Q0YpCiBOT1NURElOQ19GTEFHUyA6PQogQ0ZMQUdTX01PRFVMRSAgID0KK1JVU1RGTEFHU19NT0RV TEUgPQogQUZMQUdTX01PRFVMRSAgID0KIExERkxBR1NfTU9EVUxFICA9CiBDRkxBR1NfS0VSTkVM CT0KK1JVU1RGTEFHU19LRVJORUwgPQogQUZMQUdTX0tFUk5FTAk9CiBMREZMQUdTX3ZtbGludXgg PQogCkBAIC01MjYsMTUgKzU2Miw0MiBAQCBLQlVJTERfQ0ZMQUdTICAgOj0gLVdhbGwgLVd1bmRl ZiAtV2Vycm9yPXN0cmljdC1wcm90b3R5cGVzIC1Xbm8tdHJpZ3JhcGhzIFwKIAkJICAgLVdlcnJv cj1yZXR1cm4tdHlwZSAtV25vLWZvcm1hdC1zZWN1cml0eSBcCiAJCSAgIC1zdGQ9Z251MTEKIEtC VUlMRF9DUFBGTEFHUyA6PSAtRF9fS0VSTkVMX18KK0tCVUlMRF9SVVNURkxBR1MgOj0gJChydXN0 X2NvbW1vbl9mbGFncykgXAorCQkgICAgLS10YXJnZXQ9JChvYmp0cmVlKS9ydXN0L3RhcmdldC5q c29uIFwKKwkJICAgIC1DcGFuaWM9YWJvcnQgLUNlbWJlZC1iaXRjb2RlPW4gLUNsdG89biBcCisJ CSAgICAtQ2ZvcmNlLXVud2luZC10YWJsZXM9biAtQ2NvZGVnZW4tdW5pdHM9MSBcCisJCSAgICAt Q3N5bWJvbC1tYW5nbGluZy12ZXJzaW9uPXYwIFwKKwkJICAgIC1DcmVsb2NhdGlvbi1tb2RlbD1z dGF0aWMgXAorCQkgICAgLVpmdW5jdGlvbi1zZWN0aW9ucz1uIFwKKwkJICAgIC1EY2xpcHB5Ojpm bG9hdF9hcml0aG1ldGljCisKIEtCVUlMRF9BRkxBR1NfS0VSTkVMIDo9CiBLQlVJTERfQ0ZMQUdT X0tFUk5FTCA6PQorS0JVSUxEX1JVU1RGTEFHU19LRVJORUwgOj0KIEtCVUlMRF9BRkxBR1NfTU9E VUxFICA6PSAtRE1PRFVMRQogS0JVSUxEX0NGTEFHU19NT0RVTEUgIDo9IC1ETU9EVUxFCitLQlVJ TERfUlVTVEZMQUdTX01PRFVMRSA6PSAtLWNmZyBNT0RVTEUKIEtCVUlMRF9MREZMQUdTX01PRFVM RSA6PQogS0JVSUxEX0xERkxBR1MgOj0KIENMQU5HX0ZMQUdTIDo9CiAKK2lmZXEgKCQoS0JVSUxE X0NMSVBQWSksMSkKKwlSVVNUQ19PUl9DTElQUFlfUVVJRVQgOj0gQ0xJUFBZCisJUlVTVENfT1Jf Q0xJUFBZID0gJChDTElQUFlfRFJJVkVSKQorZWxzZQorCVJVU1RDX09SX0NMSVBQWV9RVUlFVCA6 PSBSVVNUQworCVJVU1RDX09SX0NMSVBQWSA9ICQoUlVTVEMpCitlbmRpZgorCitpZmRlZiBSVVNU X0xJQl9TUkMKKwlleHBvcnQgUlVTVF9MSUJfU1JDCitlbmRpZgorCitleHBvcnQgUlVTVENfQk9P VFNUUkFQIDo9IDEKKwogZXhwb3J0IEFSQ0ggU1JDQVJDSCBDT05GSUdfU0hFTEwgQkFTSCBIT1NU Q0MgS0JVSUxEX0hPU1RDRkxBR1MgQ1JPU1NfQ09NUElMRSBMRCBDQyBIT1NUUEtHX0NPTkZJRwor ZXhwb3J0IFJVU1RDIFJVU1RET0MgUlVTVEZNVCBSVVNUQ19PUl9DTElQUFlfUVVJRVQgUlVTVENf T1JfQ0xJUFBZIEJJTkRHRU4gQ0FSR08KK2V4cG9ydCBIT1NUUlVTVEMgS0JVSUxEX0hPU1RSVVNU RkxBR1MKIGV4cG9ydCBDUFAgQVIgTk0gU1RSSVAgT0JKQ09QWSBPQkpEVU1QIFJFQURFTEYgUEFI T0xFIFJFU09MVkVfQlRGSURTIExFWCBZQUNDIEFXSyBJTlNUQUxMS0VSTkVMCiBleHBvcnQgUEVS TCBQWVRIT04zIENIRUNLIENIRUNLRkxBR1MgTUFLRSBVVFNfTUFDSElORSBIT1NUQ1hYCiBleHBv cnQgS0daSVAgS0JaSVAyIEtMWk9QIExaTUEgTFo0IFhaIFpTVEQKQEAgLTU0Myw5ICs2MDYsMTAg QEAgZXhwb3J0IEtCVUlMRF9VU0VSQ0ZMQUdTIEtCVUlMRF9VU0VSTERGTEFHUwogCiBleHBvcnQg S0JVSUxEX0NQUEZMQUdTIE5PU1RESU5DX0ZMQUdTIExJTlVYSU5DTFVERSBPQkpDT1BZRkxBR1Mg S0JVSUxEX0xERkxBR1MKIGV4cG9ydCBLQlVJTERfQ0ZMQUdTIENGTEFHU19LRVJORUwgQ0ZMQUdT X01PRFVMRQorZXhwb3J0IEtCVUlMRF9SVVNURkxBR1MgUlVTVEZMQUdTX0tFUk5FTCBSVVNURkxB R1NfTU9EVUxFCiBleHBvcnQgS0JVSUxEX0FGTEFHUyBBRkxBR1NfS0VSTkVMIEFGTEFHU19NT0RV TEUKLWV4cG9ydCBLQlVJTERfQUZMQUdTX01PRFVMRSBLQlVJTERfQ0ZMQUdTX01PRFVMRSBLQlVJ TERfTERGTEFHU19NT0RVTEUKLWV4cG9ydCBLQlVJTERfQUZMQUdTX0tFUk5FTCBLQlVJTERfQ0ZM QUdTX0tFUk5FTAorZXhwb3J0IEtCVUlMRF9BRkxBR1NfTU9EVUxFIEtCVUlMRF9DRkxBR1NfTU9E VUxFIEtCVUlMRF9SVVNURkxBR1NfTU9EVUxFIEtCVUlMRF9MREZMQUdTX01PRFVMRQorZXhwb3J0 IEtCVUlMRF9BRkxBR1NfS0VSTkVMIEtCVUlMRF9DRkxBR1NfS0VSTkVMIEtCVUlMRF9SVVNURkxB R1NfS0VSTkVMCiBleHBvcnQgUEFIT0xFX0ZMQUdTCiAKICMgRmlsZXMgdG8gaWdub3JlIGluIGZp bmQgLi4uIHN0YXRlbWVudHMKQEAgLTcyNiw3ICs3OTAsNyBAQCAkKEtDT05GSUdfQ09ORklHKToK ICMKICMgRG8gbm90IHVzZSAkKGNhbGwgY21kLC4uLikgaGVyZS4gVGhhdCB3b3VsZCBzdXBwcmVz cyBwcm9tcHRzIGZyb20gc3luY2NvbmZpZywKICMgc28geW91IGNhbm5vdCBub3RpY2UgdGhhdCBL Y29uZmlnIGlzIHdhaXRpbmcgZm9yIHRoZSB1c2VyIGlucHV0LgotJS9jb25maWcvYXV0by5jb25m ICUvY29uZmlnL2F1dG8uY29uZi5jbWQgJS9nZW5lcmF0ZWQvYXV0b2NvbmYuaDogJChLQ09ORklH X0NPTkZJRykKKyUvY29uZmlnL2F1dG8uY29uZiAlL2NvbmZpZy9hdXRvLmNvbmYuY21kICUvZ2Vu ZXJhdGVkL2F1dG9jb25mLmggJS9nZW5lcmF0ZWQvcnVzdGNfY2ZnOiAkKEtDT05GSUdfQ09ORklH KQogCSQoUSkkKGtlY2hvKSAiICBTWU5DICAgICRAIgogCSQoUSkkKE1BS0UpIC1mICQoc3JjdHJl ZSkvTWFrZWZpbGUgc3luY2NvbmZpZwogZWxzZSAjICFtYXktc3luYy1jb25maWcKQEAgLTc1NSwx MiArODE5LDIwIEBAIEtCVUlMRF9DRkxBR1MJKz0gJChjYWxsIGNjLWRpc2FibGUtd2FybmluZywg YWRkcmVzcy1vZi1wYWNrZWQtbWVtYmVyKQogCiBpZmRlZiBDT05GSUdfQ0NfT1BUSU1JWkVfRk9S X1BFUkZPUk1BTkNFCiBLQlVJTERfQ0ZMQUdTICs9IC1PMgorS0JVSUxEX1JVU1RGTEFHUyArPSAt Q29wdC1sZXZlbD0yCiBlbHNlIGlmZGVmIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfUEVSRk9STUFO Q0VfTzMKIEtCVUlMRF9DRkxBR1MgKz0gLU8zCitLQlVJTERfUlVTVEZMQUdTICs9IC1Db3B0LWxl dmVsPTMKIGVsc2UgaWZkZWYgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFCiBLQlVJTERfQ0ZM QUdTICs9IC1PcworS0JVSUxEX1JVU1RGTEFHUyArPSAtQ29wdC1sZXZlbD1zCiBlbmRpZgogCisj IEFsd2F5cyBzZXQgYGRlYnVnLWFzc2VydGlvbnNgIGFuZCBgb3ZlcmZsb3ctY2hlY2tzYCBiZWNh dXNlIHRoZWlyIGRlZmF1bHQKKyMgZGVwZW5kcyBvbiBgb3B0LWxldmVsYCBhbmQgYGRlYnVnLWFz c2VydGlvbnNgLCByZXNwZWN0aXZlbHkuCitLQlVJTERfUlVTVEZMQUdTICs9IC1DZGVidWctYXNz ZXJ0aW9ucz0kKGlmICQoQ09ORklHX1JVU1RfREVCVUdfQVNTRVJUSU9OUykseSxuKQorS0JVSUxE X1JVU1RGTEFHUyArPSAtQ292ZXJmbG93LWNoZWNrcz0kKGlmICQoQ09ORklHX1JVU1RfT1ZFUkZM T1dfQ0hFQ0tTKSx5LG4pCisKICMgVGVsbCBnY2MgdG8gbmV2ZXIgcmVwbGFjZSBjb25kaXRpb25h bCBsb2FkIHdpdGggYSBub24tY29uZGl0aW9uYWwgb25lCiBpZmRlZiBDT05GSUdfQ0NfSVNfR0ND CiAjIGdjYy0xMCByZW5hbWVkIC0tcGFyYW09YWxsb3ctc3RvcmUtZGF0YS1yYWNlcz0wIHRvCkBA IC03OTEsNiArODYzLDkgQEAgS0JVSUxEX0NGTEFHUy0kKENPTkZJR19XRVJST1IpICs9IC1XZXJy b3IKIEtCVUlMRF9DRkxBR1MtJChDT05GSUdfQ0NfTk9fQVJSQVlfQk9VTkRTKSArPSAtV25vLWFy cmF5LWJvdW5kcwogS0JVSUxEX0NGTEFHUyArPSAkKEtCVUlMRF9DRkxBR1MteSkgJChDT05GSUdf Q0NfSU1QTElDSVRfRkFMTFRIUk9VR0gpCiAKK0tCVUlMRF9SVVNURkxBR1MtJChDT05GSUdfV0VS Uk9SKSArPSAtRHdhcm5pbmdzCitLQlVJTERfUlVTVEZMQUdTICs9ICQoS0JVSUxEX1JVU1RGTEFH Uy15KQorCiBpZmRlZiBDT05GSUdfQ0NfSVNfQ0xBTkcKIEtCVUlMRF9DUFBGTEFHUyArPSAtUXVu dXNlZC1hcmd1bWVudHMKICMgVGhlIGtlcm5lbCBidWlsZHMgd2l0aCAnLXN0ZD1nbnUxMScgc28g dXNlIG9mIEdOVSBleHRlbnNpb25zIGlzIGFjY2VwdGFibGUuCkBAIC04MTEsMTIgKzg4NiwxNSBA QCBLQlVJTERfQ0ZMQUdTICs9ICQoY2FsbCBjYy1kaXNhYmxlLXdhcm5pbmcsIGRhbmdsaW5nLXBv aW50ZXIpCiAKIGlmZGVmIENPTkZJR19GUkFNRV9QT0lOVEVSCiBLQlVJTERfQ0ZMQUdTCSs9IC1m bm8tb21pdC1mcmFtZS1wb2ludGVyIC1mbm8tb3B0aW1pemUtc2libGluZy1jYWxscworS0JVSUxE X1JVU1RGTEFHUyArPSAtQ2ZvcmNlLWZyYW1lLXBvaW50ZXJzPXkKIGVsc2UKICMgU29tZSB0YXJn ZXRzIChBUk0gd2l0aCBUaHVtYjIsIGZvciBleGFtcGxlKSwgY2FuJ3QgYmUgYnVpbHQgd2l0aCBm cmFtZQogIyBwb2ludGVycy4gIEZvciB0aG9zZSwgd2UgZG9uJ3QgaGF2ZSBGVU5DVElPTl9UUkFD RVIgYXV0b21hdGljYWxseQogIyBzZWxlY3QgRlJBTUVfUE9JTlRFUi4gIEhvd2V2ZXIsIEZVTkNU SU9OX1RSQUNFUiBhZGRzIC1wZywgYW5kIHRoaXMgaXMKICMgaW5jb21wYXRpYmxlIHdpdGggLWZv bWl0LWZyYW1lLXBvaW50ZXIgd2l0aCBjdXJyZW50IEdDQywgc28gd2UgZG9uJ3QgdXNlCiAjIC1m b21pdC1mcmFtZS1wb2ludGVyIHdpdGggRlVOQ1RJT05fVFJBQ0VSLgorIyBJbiB0aGUgUnVzdCB0 YXJnZXQgc3BlY2lmaWNhdGlvbiwgImZyYW1lLXBvaW50ZXIiIGlzIHNldCBleHBsaWNpdGx5Cisj IHRvICJtYXktb21pdCIuCiBpZm5kZWYgQ09ORklHX0ZVTkNUSU9OX1RSQUNFUgogS0JVSUxEX0NG TEFHUwkrPSAtZm9taXQtZnJhbWUtcG9pbnRlcgogZW5kaWYKQEAgLTg4MSw4ICs5NTksMTAgQEAg aWZkZWYgQ09ORklHX0RFQlVHX1NFQ1RJT05fTUlTTUFUQ0gKIEtCVUlMRF9DRkxBR1MgKz0gLWZu by1pbmxpbmUtZnVuY3Rpb25zLWNhbGxlZC1vbmNlCiBlbmRpZgogCisjIGBydXN0Y2AncyBgLVpm dW5jdGlvbi1zZWN0aW9uc2AgYXBwbGllcyB0byBkYXRhIHRvbyAoYXMgb2YgMS41OS4wKS4KIGlm ZGVmIENPTkZJR19MRF9ERUFEX0NPREVfREFUQV9FTElNSU5BVElPTgogS0JVSUxEX0NGTEFHU19L RVJORUwgKz0gLWZmdW5jdGlvbi1zZWN0aW9ucyAtZmRhdGEtc2VjdGlvbnMKK0tCVUlMRF9SVVNU RkxBR1NfS0VSTkVMICs9IC1aZnVuY3Rpb24tc2VjdGlvbnM9eQogTERGTEFHU192bWxpbnV4ICs9 IC0tZ2Mtc2VjdGlvbnMKIGVuZGlmCiAKQEAgLTEwMjUsMTAgKzExMDUsMTEgQEAgaW5jbHVkZSAk KGFkZHByZWZpeCAkKHNyY3RyZWUpLywgJChpbmNsdWRlLXkpKQogIyBEbyBub3QgYWRkICQoY2Fs bCBjYy1vcHRpb24sLi4uKSBiZWxvdyB0aGlzIGxpbmUuIFdoZW4geW91IGJ1aWxkIHRoZSBrZXJu ZWwKICMgZnJvbSB0aGUgY2xlYW4gc291cmNlIHRyZWUsIHRoZSBHQ0MgcGx1Z2lucyBkbyBub3Qg ZXhpc3QgYXQgdGhpcyBwb2ludC4KIAotIyBBZGQgdXNlciBzdXBwbGllZCBDUFBGTEFHUywgQUZM QUdTIGFuZCBDRkxBR1MgYXMgdGhlIGxhc3QgYXNzaWdubWVudHMKKyMgQWRkIHVzZXIgc3VwcGxp ZWQgQ1BQRkxBR1MsIEFGTEFHUywgQ0ZMQUdTIGFuZCBSVVNURkxBR1MgYXMgdGhlIGxhc3QgYXNz aWdubWVudHMKIEtCVUlMRF9DUFBGTEFHUyArPSAkKEtDUFBGTEFHUykKIEtCVUlMRF9BRkxBR1Mg ICArPSAkKEtBRkxBR1MpCiBLQlVJTERfQ0ZMQUdTICAgKz0gJChLQ0ZMQUdTKQorS0JVSUxEX1JV U1RGTEFHUyArPSAkKEtSVVNURkxBR1MpCiAKIEtCVUlMRF9MREZMQUdTX01PRFVMRSArPSAtLWJ1 aWxkLWlkPXNoYTEKIExERkxBR1Nfdm1saW51eCArPSAtLWJ1aWxkLWlkPXNoYTEKQEAgLTEwOTcs NiArMTE3OCw3IEBAIGV4cG9ydCBNT0RVTEVTX05TREVQUyA6PSAkKGV4dG1vZF9wcmVmaXgpbW9k dWxlcy5uc2RlcHMKIGlmZXEgKCQoS0JVSUxEX0VYVE1PRCksKQogY29yZS15CQkJKz0ga2VybmVs LyBjZXJ0cy8gbW0vIGZzLyBpcGMvIHNlY3VyaXR5LyBjcnlwdG8vCiBjb3JlLSQoQ09ORklHX0JM T0NLKQkrPSBibG9jay8KK2NvcmUtJChDT05GSUdfUlVTVCkJKz0gcnVzdC8KIAogdm1saW51eC1k aXJzCTo9ICQocGF0c3Vic3QgJS8sJSwkKGZpbHRlciAlLywgXAogCQkgICAgICQoY29yZS15KSAk KGNvcmUtbSkgJChkcml2ZXJzLXkpICQoZHJpdmVycy1tKSBcCkBAIC0xMjAxLDYgKzEyODMsMTAg QEAgcHJlcGFyZTA6IGFyY2hwcmVwYXJlCiAKICMgQWxsIHRoZSBwcmVwYXJpbmcuLgogcHJlcGFy ZTogcHJlcGFyZTAKK2lmZGVmIENPTkZJR19SVVNUCisJJChRKSQoQ09ORklHX1NIRUxMKSAkKHNy Y3RyZWUpL3NjcmlwdHMvcnVzdC1pcy1hdmFpbGFibGUuc2ggLXYKKwkkKFEpJChNQUtFKSAkKGJ1 aWxkKT1ydXN0CitlbmRpZgogCiBQSE9OWSArPSByZW1vdmUtc3RhbGUtZmlsZXMKIHJlbW92ZS1z dGFsZS1maWxlczoKQEAgLTE0OTAsNyArMTU3Niw3IEBAIGVuZGlmICMgQ09ORklHX01PRFVMRVMK ICMgRGlyZWN0b3JpZXMgJiBmaWxlcyByZW1vdmVkIHdpdGggJ21ha2UgY2xlYW4nCiBDTEVBTl9G SUxFUyArPSBpbmNsdWRlL2tzeW0gdm1saW51eC5zeW12ZXJzIG1vZHVsZXMtb25seS5zeW12ZXJz IFwKIAkgICAgICAgbW9kdWxlcy5idWlsdGluIG1vZHVsZXMuYnVpbHRpbi5tb2RpbmZvIG1vZHVs ZXMubnNkZXBzIFwKLQkgICAgICAgY29tcGlsZV9jb21tYW5kcy5qc29uIC50aGlubHRvLWNhY2hl CisJICAgICAgIGNvbXBpbGVfY29tbWFuZHMuanNvbiAudGhpbmx0by1jYWNoZSBydXN0L3Rlc3Qg cnVzdC9kb2MKIAogIyBEaXJlY3RvcmllcyAmIGZpbGVzIHJlbW92ZWQgd2l0aCAnbWFrZSBtcnBy b3BlcicKIE1SUFJPUEVSX0ZJTEVTICs9IGluY2x1ZGUvY29uZmlnIGluY2x1ZGUvZ2VuZXJhdGVk ICAgICAgICAgIFwKQEAgLTE1MDEsNyArMTU4Nyw4IEBAIE1SUFJPUEVSX0ZJTEVTICs9IGluY2x1 ZGUvY29uZmlnIGluY2x1ZGUvZ2VuZXJhdGVkICAgICAgICAgIFwKIAkJICBjZXJ0cy9zaWduaW5n X2tleS5wZW0gXAogCQkgIGNlcnRzL3g1MDkuZ2Vua2V5IFwKIAkJICB2bWxpbnV4LWdkYi5weSBc Ci0JCSAgKi5zcGVjCisJCSAgKi5zcGVjIFwKKwkJICBydXN0L3RhcmdldC5qc29uIHJ1c3QvbGli bWFjcm9zLnNvCiAKICMgY2xlYW4gLSBEZWxldGUgbW9zdCwgYnV0IGxlYXZlIGVub3VnaCB0byBi dWlsZCBleHRlcm5hbCBtb2R1bGVzCiAjCkBAIC0xNTI2LDYgKzE2MTMsOSBAQCAkKG1ycHJvcGVy LWRpcnMpOgogCiBtcnByb3BlcjogY2xlYW4gJChtcnByb3Blci1kaXJzKQogCSQoY2FsbCBjbWQs cm1maWxlcykKKwlAZmluZCAuICQoUkNTX0ZJTkRfSUdOT1JFKSBcCisJCVwoIC1uYW1lICcqLnJt ZXRhJyBcKSBcCisJCS10eXBlIGYgLXByaW50IHwgeGFyZ3Mgcm0gLWYKIAogIyBkaXN0Y2xlYW4K ICMKQEAgLTE2MTMsNiArMTcwMywyNCBAQCBoZWxwOgogCUBlY2hvICAnICBrc2VsZnRlc3QtbWVy Z2UgICAtIE1lcmdlIGFsbCB0aGUgY29uZmlnIGRlcGVuZGVuY2llcyBvZicKIAlAZWNobyAgJwkJ ICAgICAga3NlbGZ0ZXN0IHRvIGV4aXN0aW5nIC5jb25maWcuJwogCUBlY2hvICAnJworCUBlY2hv ICAnUnVzdCB0YXJnZXRzOicKKwlAZWNobyAgJyAgcnVzdGF2YWlsYWJsZSAgIC0gQ2hlY2tzIHdo ZXRoZXIgdGhlIFJ1c3QgdG9vbGNoYWluIGlzJworCUBlY2hvICAnCQkgICAgYXZhaWxhYmxlIGFu ZCwgaWYgbm90LCBleHBsYWlucyB3aHkuJworCUBlY2hvICAnICBydXN0Zm10CSAgLSBSZWZvcm1h dCBhbGwgdGhlIFJ1c3QgY29kZSBpbiB0aGUga2VybmVsJworCUBlY2hvICAnICBydXN0Zm10Y2hl Y2sJICAtIENoZWNrcyBpZiBhbGwgdGhlIFJ1c3QgY29kZSBpbiB0aGUga2VybmVsJworCUBlY2hv ICAnCQkgICAgaXMgZm9ybWF0dGVkLCBwcmludGluZyBhIGRpZmYgb3RoZXJ3aXNlLicKKwlAZWNo byAgJyAgcnVzdGRvYwkgIC0gR2VuZXJhdGUgUnVzdCBkb2N1bWVudGF0aW9uJworCUBlY2hvICAn CQkgICAgKHJlcXVpcmVzIGtlcm5lbCAuY29uZmlnKScKKwlAZWNobyAgJyAgcnVzdHRlc3QgICAg ICAgIC0gUnVucyB0aGUgUnVzdCB0ZXN0cycKKwlAZWNobyAgJyAgICAgICAgICAgICAgICAgICAg KHJlcXVpcmVzIGtlcm5lbCAuY29uZmlnOyBkb3dubG9hZHMgZXh0ZXJuYWwgcmVwb3MpJworCUBl Y2hvICAnICBydXN0LWFuYWx5emVyCSAgLSBHZW5lcmF0ZSBydXN0LXByb2plY3QuanNvbiBydXN0 LWFuYWx5emVyIHN1cHBvcnQgZmlsZScKKwlAZWNobyAgJwkJICAgIChyZXF1aXJlcyBrZXJuZWwg LmNvbmZpZyknCisJQGVjaG8gICcgIGRpci9maWxlLltvc10gICAtIEJ1aWxkIHNwZWNpZmllZCB0 YXJnZXQgb25seScKKwlAZWNobyAgJyAgZGlyL2ZpbGUucnNpICAgIC0gQnVpbGQgbWFjcm8gZXhw YW5kZWQgc291cmNlLCBzaW1pbGFyIHRvIEMgcHJlcHJvY2Vzc2luZy4nCisJQGVjaG8gICcgICAg ICAgICAgICAgICAgICAgIFJ1biB3aXRoIFJVU1RGTVQ9biB0byBza2lwIHJlZm9ybWF0dGluZyBp ZiBuZWVkZWQuJworCUBlY2hvICAnICAgICAgICAgICAgICAgICAgICBUaGUgb3V0cHV0IGlzIG5v dCBpbnRlbmRlZCB0byBiZSBjb21waWxhYmxlLicKKwlAZWNobyAgJyAgZGlyL2ZpbGUubGwgICAg IC0gQnVpbGQgdGhlIExMVk0gYXNzZW1ibHkgZmlsZScKKwlAZWNobyAgJycKIAlAJChpZiAkKGR0 c3RyZWUpLCBcCiAJCWVjaG8gJ0RldmljZXRyZWU6JzsgXAogCQllY2hvICcqIGR0YnMgICAgICAg ICAgICAgLSBCdWlsZCBkZXZpY2UgdHJlZSBibG9icyBmb3IgZW5hYmxlZCBib2FyZHMnOyBcCkBA IC0xNjg1LDYgKzE3OTMsNTIgQEAgUEhPTlkgKz0gJChET0NfVEFSR0VUUykKICQoRE9DX1RBUkdF VFMpOgogCSQoUSkkKE1BS0UpICQoYnVpbGQpPURvY3VtZW50YXRpb24gJEAKIAorCisjIFJ1c3Qg dGFyZ2V0cworIyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworIyAiSXMgUnVzdCBhdmFpbGFibGU/IiB0 YXJnZXQKK1BIT05ZICs9IHJ1c3RhdmFpbGFibGUKK3J1c3RhdmFpbGFibGU6CisJJChRKSQoQ09O RklHX1NIRUxMKSAkKHNyY3RyZWUpL3NjcmlwdHMvcnVzdC1pcy1hdmFpbGFibGUuc2ggLXYgJiYg ZWNobyAiUnVzdCBpcyBhdmFpbGFibGUhIgorCisjIERvY3VtZW50YXRpb24gdGFyZ2V0CisjCisj IFVzaW5nIHRoZSBzaW5ndWxhciB0byBhdm9pZCBydW5uaW5nIGFmb3VsIG9mIGBuby1kb3QtY29u ZmlnLXRhcmdldHNgLgorUEhPTlkgKz0gcnVzdGRvYworcnVzdGRvYzogcHJlcGFyZQorCSQoUSkk KE1BS0UpICQoYnVpbGQpPXJ1c3QgJEAKKworIyBUZXN0aW5nIHRhcmdldAorUEhPTlkgKz0gcnVz dHRlc3QKK3J1c3R0ZXN0OiBwcmVwYXJlCisJJChRKSQoTUFLRSkgJChidWlsZCk9cnVzdCAkQAor CisjIEZvcm1hdHRpbmcgdGFyZ2V0cworUEhPTlkgKz0gcnVzdGZtdCBydXN0Zm10Y2hlY2sKKwor IyBXZSBza2lwIGBydXN0L2FsbG9jYCBzaW5jZSB3ZSB3YW50IHRvIG1pbmltaXplIHRoZSBkaWZm IHcuci50LiB1cHN0cmVhbS4KKyMKKyMgV2UgbWF0Y2ggdXNpbmcgYWJzb2x1dGUgcGF0aHMgc2lu Y2UgYGZpbmRgIGRvZXMgbm90IHJlc29sdmUgdGhlbQorIyB3aGVuIG1hdGNoaW5nLCB3aGljaCBp cyBhIHByb2JsZW0gd2hlbiBlLmcuIGBzcmN0cmVlYCBpcyBgLi5gLgorIyBXZSBgZ3JlcGAgYWZ0 ZXJ3YXJkcyBpbiBvcmRlciB0byByZW1vdmUgdGhlIGRpcmVjdG9yeSBlbnRyeSBpdHNlbGYuCity dXN0Zm10OgorCSQoUSlmaW5kICQoYWJzX3NyY3RyZWUpIC10eXBlIGYgLW5hbWUgJyoucnMnIFwK KwkJLW8gLXBhdGggJChhYnNfc3JjdHJlZSkvcnVzdC9hbGxvYyAtcHJ1bmUgXAorCQktbyAtcGF0 aCAkKGFic19vYmp0cmVlKS9ydXN0L3Rlc3QgLXBydW5lIFwKKwkJfCBncmVwIC1GdiAkKGFic19z cmN0cmVlKS9ydXN0L2FsbG9jIFwKKwkJfCBncmVwIC1GdiAkKGFic19vYmp0cmVlKS9ydXN0L3Rl c3QgXAorCQl8IGdyZXAgLUZ2IGdlbmVyYXRlZCBcCisJCXwgeGFyZ3MgJChSVVNURk1UKSAkKHJ1 c3RmbXRfZmxhZ3MpCisKK3J1c3RmbXRjaGVjazogcnVzdGZtdF9mbGFncyA9IC0tY2hlY2sKK3J1 c3RmbXRjaGVjazogcnVzdGZtdAorCisjIElERSBzdXBwb3J0IHRhcmdldHMKK1BIT05ZICs9IHJ1 c3QtYW5hbHl6ZXIKK3J1c3QtYW5hbHl6ZXI6CisJJChRKSQoTUFLRSkgJChidWlsZCk9cnVzdCAk QAorCiAjIE1pc2MKICMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKQEAgLTE4NTIsNyArMjAwNiw3IEBA ICQoY2xlYW4tZGlycyk6CiBjbGVhbjogJChjbGVhbi1kaXJzKQogCSQoY2FsbCBjbWQscm1maWxl cykKIAlAZmluZCAkKG9yICQoS0JVSUxEX0VYVE1PRCksIC4pICQoUkNTX0ZJTkRfSUdOT1JFKSBc Ci0JCVwoIC1uYW1lICcqLlthaW9zXScgLW8gLW5hbWUgJyoua28nIC1vIC1uYW1lICcuKi5jbWQn IFwKKwkJXCggLW5hbWUgJyouW2Fpb3NdJyAtbyAtbmFtZSAnKi5yc2knIC1vIC1uYW1lICcqLmtv JyAtbyAtbmFtZSAnLiouY21kJyBcCiAJCS1vIC1uYW1lICcqLmtvLionIFwKIAkJLW8gLW5hbWUg JyouZHRiJyAtbyAtbmFtZSAnKi5kdGJvJyAtbyAtbmFtZSAnKi5kdGIuUycgLW8gLW5hbWUgJyou ZHQueWFtbCcgXAogCQktbyAtbmFtZSAnKi5kd28nIC1vIC1uYW1lICcqLmxzdCcgXApkaWZmIC0t Z2l0IGEvYXJjaC9LY29uZmlnIGIvYXJjaC9LY29uZmlnCmluZGV4IDcxYjkyNzJhY2IyOC4uZDUw MzhjZjhkZDQ5IDEwMDY0NAotLS0gYS9hcmNoL0tjb25maWcKKysrIGIvYXJjaC9LY29uZmlnCkBA IC0zNTMsNiArMzUzLDEyIEBAIGNvbmZpZyBIQVZFX1JTRVEKIAkgIFRoaXMgc3ltYm9sIHNob3Vs ZCBiZSBzZWxlY3RlZCBieSBhbiBhcmNoaXRlY3R1cmUgaWYgaXQKIAkgIHN1cHBvcnRzIGFuIGlt cGxlbWVudGF0aW9uIG9mIHJlc3RhcnRhYmxlIHNlcXVlbmNlcy4KIAorY29uZmlnIEhBVkVfUlVT VAorCWJvb2wKKwloZWxwCisJICBUaGlzIHN5bWJvbCBzaG91bGQgYmUgc2VsZWN0ZWQgYnkgYW4g YXJjaGl0ZWN0dXJlIGlmIGl0CisJICBzdXBwb3J0cyBSdXN0LgorCiBjb25maWcgSEFWRV9GVU5D VElPTl9BUkdfQUNDRVNTX0FQSQogCWJvb2wKIAloZWxwCmRpZmYgLS1naXQgYS9hcmNoL2FybS9L Y29uZmlnIGIvYXJjaC9hcm0vS2NvbmZpZwppbmRleCA3NjMwYmE5Y2I2Y2MuLjE0NzY1NWE0ZmMy NyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vS2NvbmZpZworKysgYi9hcmNoL2FybS9LY29uZmlnCkBA IC0xMTYsNiArMTE2LDcgQEAgY29uZmlnIEFSTQogCXNlbGVjdCBNTVVfR0FUSEVSX1JDVV9UQUJM RV9GUkVFIGlmIFNNUCAmJiBBUk1fTFBBRQogCXNlbGVjdCBIQVZFX1JFR1NfQU5EX1NUQUNLX0FD Q0VTU19BUEkKIAlzZWxlY3QgSEFWRV9SU0VRCisJc2VsZWN0IEhBVkVfUlVTVCBpZiBDUFVfMzJ2 NiB8fCBDUFVfMzJ2NksKIAlzZWxlY3QgSEFWRV9TVEFDS1BST1RFQ1RPUgogCXNlbGVjdCBIQVZF X1NZU0NBTExfVFJBQ0VQT0lOVFMKIAlzZWxlY3QgSEFWRV9VSUQxNgpkaWZmIC0tZ2l0IGEvYXJj aC9hcm02NC9LY29uZmlnIGIvYXJjaC9hcm02NC9LY29uZmlnCmluZGV4IDE2NTJhOTgwMGViZS4u YWFlYjcwMzU4OTc5IDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L0tjb25maWcKKysrIGIvYXJjaC9h cm02NC9LY29uZmlnCkBAIC0yMDEsNiArMjAxLDcgQEAgY29uZmlnIEFSTTY0CiAJc2VsZWN0IEhB VkVfRlVOQ1RJT05fQVJHX0FDQ0VTU19BUEkKIAlzZWxlY3QgTU1VX0dBVEhFUl9SQ1VfVEFCTEVf RlJFRQogCXNlbGVjdCBIQVZFX1JTRVEKKwlzZWxlY3QgSEFWRV9SVVNUCiAJc2VsZWN0IEhBVkVf U1RBQ0tQUk9URUNUT1IKIAlzZWxlY3QgSEFWRV9TWVNDQUxMX1RSQUNFUE9JTlRTCiAJc2VsZWN0 IEhBVkVfS1BST0JFUwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL0tjb25maWcgYi9hcmNoL3Bv d2VycGMvS2NvbmZpZwppbmRleCA0ZDhmMjZjMTM5OWIuLmVkYWIzY2M5ZWRmNSAxMDA2NDQKLS0t IGEvYXJjaC9wb3dlcnBjL0tjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL0tjb25maWcKQEAgLTI0 Myw2ICsyNDMsNyBAQCBjb25maWcgUFBDCiAJc2VsZWN0IEhBVkVfUkVHU19BTkRfU1RBQ0tfQUND RVNTX0FQSQogCXNlbGVjdCBIQVZFX1JFTElBQkxFX1NUQUNLVFJBQ0UKIAlzZWxlY3QgSEFWRV9S U0VRCisJc2VsZWN0IEhBVkVfUlVTVAkJCWlmIFBQQzY0ICYmIENQVV9MSVRUTEVfRU5ESUFOCiAJ c2VsZWN0IEhBVkVfU0VUVVBfUEVSX0NQVV9BUkVBCQlpZiBQUEM2NAogCXNlbGVjdCBIQVZFX1NP RlRJUlFfT05fT1dOX1NUQUNLCiAJc2VsZWN0IEhBVkVfU1RBQ0tQUk9URUNUT1IJCWlmIFBQQzMy ICYmICQoY2Mtb3B0aW9uLC1tc3RhY2stcHJvdGVjdG9yLWd1YXJkPXRscyAtbXN0YWNrLXByb3Rl Y3Rvci1ndWFyZC1yZWc9cjIpCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L0tjb25maWcgYi9hcmNo L3Jpc2N2L0tjb25maWcKaW5kZXggZmNiYjgxZmViN2FkLi41YjUzYjQxNTI4ZjYgMTAwNjQ0Ci0t LSBhL2FyY2gvcmlzY3YvS2NvbmZpZworKysgYi9hcmNoL3Jpc2N2L0tjb25maWcKQEAgLTEwNCw2 ICsxMDQsNyBAQCBjb25maWcgUklTQ1YKIAlzZWxlY3QgSEFWRV9QRVJGX1JFR1MKIAlzZWxlY3Qg SEFWRV9QRVJGX1VTRVJfU1RBQ0tfRFVNUAogCXNlbGVjdCBIQVZFX1JFR1NfQU5EX1NUQUNLX0FD Q0VTU19BUEkKKwlzZWxlY3QgSEFWRV9SVVNUIGlmIDY0QklUCiAJc2VsZWN0IEhBVkVfRlVOQ1RJ T05fQVJHX0FDQ0VTU19BUEkKIAlzZWxlY3QgSEFWRV9TVEFDS1BST1RFQ1RPUgogCXNlbGVjdCBI QVZFX1NZU0NBTExfVFJBQ0VQT0lOVFMKZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvTWFrZWZpbGUg Yi9hcmNoL3Jpc2N2L01ha2VmaWxlCmluZGV4IDgxMDI5ZDQwYTY3Mi4uMjRlYmUwNDI0MDZlIDEw MDY0NAotLS0gYS9hcmNoL3Jpc2N2L01ha2VmaWxlCisrKyBiL2FyY2gvcmlzY3YvTWFrZWZpbGUK QEAgLTI2LDYgKzI2LDggQEAgaWZlcSAoJChDT05GSUdfQVJDSF9SVjY0SSkseSkKIAlLQlVJTERf Q0ZMQUdTICs9IC1tYWJpPWxwNjQKIAlLQlVJTERfQUZMQUdTICs9IC1tYWJpPWxwNjQKIAorCUtC VUlMRF9SVVNURkxBR1MgKz0gLUN0YXJnZXQtY3B1PWdlbmVyaWMtcnY2NAorCiAJS0JVSUxEX0xE RkxBR1MgKz0gLW1lbGY2NGxyaXNjdgogZWxzZQogCUJJVFMgOj0gMzIKQEAgLTMzLDYgKzM1LDkg QEAgZWxzZQogCiAJS0JVSUxEX0NGTEFHUyArPSAtbWFiaT1pbHAzMgogCUtCVUlMRF9BRkxBR1Mg Kz0gLW1hYmk9aWxwMzIKKworCUtCVUlMRF9SVVNURkxBR1MgKz0gLUN0YXJnZXQtY3B1PWdlbmVy aWMtcnYzMgorCiAJS0JVSUxEX0xERkxBR1MgKz0gLW1lbGYzMmxyaXNjdgogZW5kaWYKIApkaWZm IC0tZ2l0IGEvYXJjaC91bS9LY29uZmlnIGIvYXJjaC91bS9LY29uZmlnCmluZGV4IDRlYzIyZTE1 NmEyZS4uNmRjMDZhN2JmOGI3IDEwMDY0NAotLS0gYS9hcmNoL3VtL0tjb25maWcKKysrIGIvYXJj aC91bS9LY29uZmlnCkBAIC0yNSw2ICsyNSw3IEBAIGNvbmZpZyBVTUwKIAlzZWxlY3QgVFJBQ0Vf SVJRRkxBR1NfU1VQUE9SVAogCXNlbGVjdCBUVFkgIyBOZWVkZWQgZm9yIGxpbmUuYwogCXNlbGVj dCBIQVZFX0FSQ0hfVk1BUF9TVEFDSworCXNlbGVjdCBIQVZFX1JVU1QJCQlpZiBYODZfNjQKIAog Y29uZmlnIE1NVQogCWJvb2wKZGlmZiAtLWdpdCBhL2FyY2gveDg2L0tjb25maWcgYi9hcmNoL3g4 Ni9LY29uZmlnCmluZGV4IDUyYTdmOTE1MjdmZS4uNGQ1YTNmMjU2Y2JjIDEwMDY0NAotLS0gYS9h cmNoL3g4Ni9LY29uZmlnCisrKyBiL2FyY2gveDg2L0tjb25maWcKQEAgLTI1OCw2ICsyNTgsNyBA QCBjb25maWcgWDg2CiAJc2VsZWN0IEhBVkVfU1RBVElDX0NBTExfSU5MSU5FCQlpZiBIQVZFX09C SlRPT0wKIAlzZWxlY3QgSEFWRV9QUkVFTVBUX0RZTkFNSUNfQ0FMTAogCXNlbGVjdCBIQVZFX1JT RVEKKwlzZWxlY3QgSEFWRV9SVVNUCQkJaWYgWDg2XzY0CiAJc2VsZWN0IEhBVkVfU1lTQ0FMTF9U UkFDRVBPSU5UUwogCXNlbGVjdCBIQVZFX1VBQ0NFU1NfVkFMSURBVElPTgkJaWYgSEFWRV9PQkpU T09MCiAJc2VsZWN0IEhBVkVfVU5TVEFCTEVfU0NIRURfQ0xPQ0sKZGlmZiAtLWdpdCBhL2FyY2gv eDg2L01ha2VmaWxlIGIvYXJjaC94ODYvTWFrZWZpbGUKaW5kZXggNzg1NDY4NWM1ZjI1Li5iYWI1 OTUwMDNmMDcgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L01ha2VmaWxlCisrKyBiL2FyY2gveDg2L01h a2VmaWxlCkBAIC02OCw2ICs2OCw3IEBAIGV4cG9ydCBCSVRTCiAjICAgIGh0dHBzOi8vZ2NjLmdu dS5vcmcvYnVnemlsbGEvc2hvd19idWcuY2dpP2lkPTUzMzgzCiAjCiBLQlVJTERfQ0ZMQUdTICs9 IC1tbm8tc3NlIC1tbm8tbW14IC1tbm8tc3NlMiAtbW5vLTNkbm93IC1tbm8tYXZ4CitLQlVJTERf UlVTVEZMQUdTICs9IC1DdGFyZ2V0LWZlYXR1cmU9LXNzZSwtc3NlMiwtc3NlMywtc3NzZTMsLXNz ZTQuMSwtc3NlNC4yLC1hdngsLWF2eDIKIAogaWZlcSAoJChDT05GSUdfWDg2X0tFUk5FTF9JQlQp LHkpCiAjCkBAIC0xNTUsOCArMTU2LDE3IEBAIGVsc2UKICAgICAgICAgY2ZsYWdzLSQoQ09ORklH X0dFTkVSSUNfQ1BVKQkrPSAtbXR1bmU9Z2VuZXJpYwogICAgICAgICBLQlVJTERfQ0ZMQUdTICs9 ICQoY2ZsYWdzLXkpCiAKKyAgICAgICAgcnVzdGZsYWdzLSQoQ09ORklHX01LOCkJCSs9IC1DdGFy Z2V0LWNwdT1rOAorICAgICAgICBydXN0ZmxhZ3MtJChDT05GSUdfTVBTQykJKz0gLUN0YXJnZXQt Y3B1PW5vY29uYQorICAgICAgICBydXN0ZmxhZ3MtJChDT05GSUdfTUNPUkUyKQkrPSAtQ3Rhcmdl dC1jcHU9Y29yZTIKKyAgICAgICAgcnVzdGZsYWdzLSQoQ09ORklHX01BVE9NKQkrPSAtQ3Rhcmdl dC1jcHU9YXRvbQorICAgICAgICBydXN0ZmxhZ3MtJChDT05GSUdfR0VORVJJQ19DUFUpCSs9IC1a dHVuZS1jcHU9Z2VuZXJpYworICAgICAgICBLQlVJTERfUlVTVEZMQUdTICs9ICQocnVzdGZsYWdz LXkpCisKICAgICAgICAgS0JVSUxEX0NGTEFHUyArPSAtbW5vLXJlZC16b25lCiAgICAgICAgIEtC VUlMRF9DRkxBR1MgKz0gLW1jbW9kZWw9a2VybmVsCisgICAgICAgIEtCVUlMRF9SVVNURkxBR1Mg Kz0gLUNuby1yZWR6b25lPXkKKyAgICAgICAgS0JVSUxEX1JVU1RGTEFHUyArPSAtQ2NvZGUtbW9k ZWw9a2VybmVsCiBlbmRpZgogCiAjCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2NvbXBpbGVy X3R5cGVzLmggYi9pbmNsdWRlL2xpbnV4L2NvbXBpbGVyX3R5cGVzLmgKaW5kZXggNGYyYTgxOWZk NjBhLi41MGIzZjZiOTUwMmUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvY29tcGlsZXJfdHlw ZXMuaAorKysgYi9pbmNsdWRlL2xpbnV4L2NvbXBpbGVyX3R5cGVzLmgKQEAgLTQsOCArNCwxMiBA QAogCiAjaWZuZGVmIF9fQVNTRU1CTFlfXwogCisvKgorICogU2tpcHBlZCB3aGVuIHJ1bm5pbmcg YmluZGdlbiBkdWUgdG8gYSBsaWJjbGFuZyBpc3N1ZTsKKyAqIHNlZSBodHRwczovL2dpdGh1Yi5j b20vcnVzdC1sYW5nL3J1c3QtYmluZGdlbi9pc3N1ZXMvMjI0NC4KKyAqLwogI2lmIGRlZmluZWQo Q09ORklHX0RFQlVHX0lORk9fQlRGKSAmJiBkZWZpbmVkKENPTkZJR19QQUhPTEVfSEFTX0JURl9U QUcpICYmIFwKLQlfX2hhc19hdHRyaWJ1dGUoYnRmX3R5cGVfdGFnKQorCV9faGFzX2F0dHJpYnV0 ZShidGZfdHlwZV90YWcpICYmICFkZWZpbmVkKF9fQklOREdFTl9fKQogIyBkZWZpbmUgQlRGX1RZ UEVfVEFHKHZhbHVlKSBfX2F0dHJpYnV0ZV9fKChidGZfdHlwZV90YWcoI3ZhbHVlKSkpCiAjZWxz ZQogIyBkZWZpbmUgQlRGX1RZUEVfVEFHKHZhbHVlKSAvKiBub3RoaW5nICovCmRpZmYgLS1naXQg YS9pbml0L0tjb25maWcgYi9pbml0L0tjb25maWcKaW5kZXggYzc5MDBlODk3NWYxLi42ZjYyZGJl YTgyODMgMTAwNjQ0Ci0tLSBhL2luaXQvS2NvbmZpZworKysgYi9pbml0L0tjb25maWcKQEAgLTYw LDYgKzYwLDE3IEBAIGNvbmZpZyBMTERfVkVSU0lPTgogCWRlZmF1bHQgJChsZC12ZXJzaW9uKSBp ZiBMRF9JU19MTEQKIAlkZWZhdWx0IDAKIAorY29uZmlnIFJVU1RfSVNfQVZBSUxBQkxFCisJZGVm X2Jvb2wgJChzdWNjZXNzLCQoc3JjdHJlZSkvc2NyaXB0cy9ydXN0LWlzLWF2YWlsYWJsZS5zaCkK KwloZWxwCisJICBUaGlzIHNob3dzIHdoZXRoZXIgYSBzdWl0YWJsZSBSdXN0IHRvb2xjaGFpbiBp cyBhdmFpbGFibGUgKGZvdW5kKS4KKworCSAgUGxlYXNlIHNlZSBEb2N1bWVudGF0aW9uL3J1c3Qv cXVpY2stc3RhcnQucnN0IGZvciBpbnN0cnVjdGlvbnMgb24gaG93CisJICB0byBzYXRpZnkgdGhl IGJ1aWxkIHJlcXVpcmVtZW50cyBvZiBSdXN0IHN1cHBvcnQuCisKKwkgIEluIHBhcnRpY3VsYXIs IHRoZSBNYWtlZmlsZSB0YXJnZXQgJ3J1c3RhdmFpbGFibGUnIGlzIHVzZWZ1bCB0byBjaGVjawor CSAgd2h5IHRoZSBSdXN0IHRvb2xjaGFpbiBpcyBub3QgYmVpbmcgZGV0ZWN0ZWQuCisKIGNvbmZp ZyBDQ19DQU5fTElOSwogCWJvb2wKIAlkZWZhdWx0ICQoc3VjY2VzcywkKHNyY3RyZWUpL3Njcmlw dHMvY2MtY2FuLWxpbmsuc2ggJChDQykgJChDTEFOR19GTEFHUykgJChVU0VSQ0ZMQUdTKSAkKFVT RVJMREZMQUdTKSAkKG02NC1mbGFnKSkgaWYgNjRCSVQKQEAgLTE1MSw3ICsxNjIsOCBAQCBjb25m aWcgV0VSUk9SCiAJZGVmYXVsdCBDT01QSUxFX1RFU1QKIAloZWxwCiAJICBBIGtlcm5lbCBidWls ZCBzaG91bGQgbm90IGNhdXNlIGFueSBjb21waWxlciB3YXJuaW5ncywgYW5kIHRoaXMKLQkgIGVu YWJsZXMgdGhlICctV2Vycm9yJyBmbGFnIHRvIGVuZm9yY2UgdGhhdCBydWxlIGJ5IGRlZmF1bHQu CisJICBlbmFibGVzIHRoZSAnLVdlcnJvcicgKGZvciBDKSBhbmQgJy1Ed2FybmluZ3MnIChmb3Ig UnVzdCkgZmxhZ3MKKwkgIHRvIGVuZm9yY2UgdGhhdCBydWxlIGJ5IGRlZmF1bHQuCiAKIAkgIEhv d2V2ZXIsIGlmIHlvdSBoYXZlIGEgbmV3IChvciB2ZXJ5IG9sZCkgY29tcGlsZXIgd2l0aCBvZGQg YW5kCiAJICB1bnVzdWFsIHdhcm5pbmdzLCBvciB5b3UgaGF2ZSBzb21lIGFyY2hpdGVjdHVyZSB3 aXRoIHByb2JsZW1zLApAQCAtMTg5OCw2ICsxOTEwLDM4IEBAIGNvbmZpZyBQUk9GSUxJTkcKIAkg IFNheSBZIGhlcmUgdG8gZW5hYmxlIHRoZSBleHRlbmRlZCBwcm9maWxpbmcgc3VwcG9ydCBtZWNo YW5pc21zIHVzZWQKIAkgIGJ5IHByb2ZpbGVycy4KIAorY29uZmlnIFJVU1QKKwlib29sICJSdXN0 IHN1cHBvcnQiCisJZGVwZW5kcyBvbiBIQVZFX1JVU1QKKwlkZXBlbmRzIG9uIFJVU1RfSVNfQVZB SUxBQkxFCisJZGVwZW5kcyBvbiAhTU9EVkVSU0lPTlMKKwlkZXBlbmRzIG9uICFHQ0NfUExVR0lO UworCWRlcGVuZHMgb24gIVJBTkRTVFJVQ1QKKwlkZXBlbmRzIG9uICFERUJVR19JTkZPX0JURgor CXNlbGVjdCBDT05TVFJVQ1RPUlMKKwloZWxwCisJICBFbmFibGVzIFJ1c3Qgc3VwcG9ydCBpbiB0 aGUga2VybmVsLgorCisJICBUaGlzIGFsbG93cyBvdGhlciBSdXN0LXJlbGF0ZWQgb3B0aW9ucywg bGlrZSBkcml2ZXJzIHdyaXR0ZW4gaW4gUnVzdCwKKwkgIHRvIGJlIHNlbGVjdGVkLgorCisJICBJ dCBpcyBhbHNvIHJlcXVpcmVkIHRvIGJlIGFibGUgdG8gbG9hZCBleHRlcm5hbCBrZXJuZWwgbW9k dWxlcworCSAgd3JpdHRlbiBpbiBSdXN0LgorCisJICBTZWUgRG9jdW1lbnRhdGlvbi9ydXN0LyBm b3IgbW9yZSBpbmZvcm1hdGlvbi4KKworCSAgSWYgdW5zdXJlLCBzYXkgTi4KKworY29uZmlnIFJV U1RDX1ZFUlNJT05fVEVYVAorCXN0cmluZworCWRlcGVuZHMgb24gUlVTVAorCWRlZmF1bHQgJChz aGVsbCxjb21tYW5kIC12ICQoUlVTVEMpID4vZGV2L251bGwgMj4mMSAmJiAkKFJVU1RDKSAtLXZl cnNpb24gfHwgZWNobyBuKQorCitjb25maWcgQklOREdFTl9WRVJTSU9OX1RFWFQKKwlzdHJpbmcK KwlkZXBlbmRzIG9uIFJVU1QKKwlkZWZhdWx0ICQoc2hlbGwsY29tbWFuZCAtdiAkKEJJTkRHRU4p ID4vZGV2L251bGwgMj4mMSAmJiAkKEJJTkRHRU4pIC0tdmVyc2lvbiB8fCBlY2hvIG4pCisKICMK ICMgUGxhY2UgYW4gZW1wdHkgZnVuY3Rpb24gY2FsbCBhdCBlYWNoIHRyYWNlcG9pbnQgc2l0ZS4g Q2FuIGJlCiAjIGR5bmFtaWNhbGx5IGNoYW5nZWQgZm9yIGEgcHJvYmUgZnVuY3Rpb24uCmRpZmYg LS1naXQgYS9saWIvS2NvbmZpZy5kZWJ1ZyBiL2xpYi9LY29uZmlnLmRlYnVnCmluZGV4IDJlMjRk YjRiZmYxOS4uYWUzYzQzZTAwOTJlIDEwMDY0NAotLS0gYS9saWIvS2NvbmZpZy5kZWJ1ZworKysg Yi9saWIvS2NvbmZpZy5kZWJ1ZwpAQCAtMjY4OCw2ICsyNjg4LDg4IEBAIGNvbmZpZyBIWVBFUlZf VEVTVElORwogCiBlbmRtZW51ICMgIktlcm5lbCBUZXN0aW5nIGFuZCBDb3ZlcmFnZSIKIAorbWVu dSAiUnVzdCBoYWNraW5nIgorCitjb25maWcgUlVTVF9ERUJVR19BU1NFUlRJT05TCisJYm9vbCAi RGVidWcgYXNzZXJ0aW9ucyIKKwlkZXBlbmRzIG9uIFJVU1QKKwloZWxwCisJICBFbmFibGVzIHJ1 c3RjJ3MgYC1DZGVidWctYXNzZXJ0aW9uc2AgY29kZWdlbiBvcHRpb24uCisKKwkgIFRoaXMgZmxh ZyBsZXRzIHlvdSB0dXJuIGBjZmcoZGVidWdfYXNzZXJ0aW9ucylgIGNvbmRpdGlvbmFsCisJICBj b21waWxhdGlvbiBvbiBvciBvZmYuIFRoaXMgY2FuIGJlIHVzZWQgdG8gZW5hYmxlIGV4dHJhIGRl YnVnZ2luZworCSAgY29kZSBpbiBkZXZlbG9wbWVudCBidXQgbm90IGluIHByb2R1Y3Rpb24uIEZv ciBleGFtcGxlLCBpdCBjb250cm9scworCSAgdGhlIGJlaGF2aW9yIG9mIHRoZSBzdGFuZGFyZCBs aWJyYXJ5J3MgYGRlYnVnX2Fzc2VydCFgIG1hY3JvLgorCisJICBOb3RlIHRoYXQgdGhpcyB3aWxs IGFwcGx5IHRvIGFsbCBSdXN0IGNvZGUsIGluY2x1ZGluZyBgY29yZWAuCisKKwkgIElmIHVuc3Vy ZSwgc2F5IE4uCisKK2NvbmZpZyBSVVNUX09WRVJGTE9XX0NIRUNLUworCWJvb2wgIk92ZXJmbG93 IGNoZWNrcyIKKwlkZWZhdWx0IHkKKwlkZXBlbmRzIG9uIFJVU1QKKwloZWxwCisJICBFbmFibGVz IHJ1c3RjJ3MgYC1Db3ZlcmZsb3ctY2hlY2tzYCBjb2RlZ2VuIG9wdGlvbi4KKworCSAgVGhpcyBm bGFnIGFsbG93cyB5b3UgdG8gY29udHJvbCB0aGUgYmVoYXZpb3Igb2YgcnVudGltZSBpbnRlZ2Vy CisJICBvdmVyZmxvdy4gV2hlbiBvdmVyZmxvdy1jaGVja3MgYXJlIGVuYWJsZWQsIGEgUnVzdCBw YW5pYyB3aWxsIG9jY3VyCisJICBvbiBvdmVyZmxvdy4KKworCSAgTm90ZSB0aGF0IHRoaXMgd2ls bCBhcHBseSB0byBhbGwgUnVzdCBjb2RlLCBpbmNsdWRpbmcgYGNvcmVgLgorCisJICBJZiB1bnN1 cmUsIHNheSBZLgorCitjaG9pY2UKKwlwcm9tcHQgIkJ1aWxkLXRpbWUgYXNzZXJ0aW9ucyIKKwlk ZWZhdWx0IFJVU1RfQlVJTERfQVNTRVJUX0RFTlkKKwlkZXBlbmRzIG9uIFJVU1QKKwloZWxwCisJ ICBDb250cm9scyBob3cgYXJlIGBidWlsZF9lcnJvciFgIGFuZCBgYnVpbGRfYXNzZXJ0IWAgaGFu ZGxlZCBkdXJpbmcgYnVpbGQuCisKKwkgIElmIGNhbGxzIHRvIHRoZW0gZXhpc3QgaW4gdGhlIGJp bmFyeSwgaXQgbWF5IGluZGljYXRlIGEgdmlvbGF0ZWQgaW52YXJpYW50CisJICBvciB0aGF0IHRo ZSBvcHRpbWl6ZXIgZmFpbGVkIHRvIHZlcmlmeSB0aGUgaW52YXJpYW50IGR1cmluZyBjb21waWxh dGlvbi4KKwkgIFlvdSBjYW4gY2hvb3NlIHRvIGFib3J0IGNvbXBpbGF0aW9uIG9yIGlnbm9yZSB0 aGVtIGR1cmluZyBidWlsZCBhbmQgbGV0IHRoZQorCSAgY2hlY2sgYmUgY2FycmllZCB0byBydW50 aW1lLgorCisJICBJZiBvcHRpbWl6YXRpb25zIGFyZSB0dXJuZWQgb2ZmLCB5b3UgY2Fubm90IHNl bGVjdCAiRGVueSIuCisKKwkgIElmIHVuc3VyZSwgc2F5ICJEZW55Ii4KKworY29uZmlnIFJVU1Rf QlVJTERfQVNTRVJUX0FMTE9XCisJYm9vbCAiQWxsb3ciCisJaGVscAorCSAgVW5vcHRpbWl6ZWQg Y2FsbHMgdG8gYGJ1aWxkX2Vycm9yIWAgd2lsbCBiZSBjb252ZXJ0ZWQgdG8gYHBhbmljIWAKKwkg IGFuZCBjaGVja2VkIGF0IHJ1bnRpbWUuCisKK2NvbmZpZyBSVVNUX0JVSUxEX0FTU0VSVF9XQVJO CisJYm9vbCAiV2FybiIKKwloZWxwCisJICBVbm9wdGltaXplZCBjYWxscyB0byBgYnVpbGRfZXJy b3IhYCB3aWxsIGJlIGNvbnZlcnRlZCB0byBgcGFuaWMhYAorCSAgYW5kIGNoZWNrZWQgYXQgcnVu dGltZSwgYnV0IHdhcm5pbmdzIHdpbGwgYmUgZ2VuZXJhdGVkIHdoZW4gYnVpbGRpbmcuCisKK2Nv bmZpZyBSVVNUX0JVSUxEX0FTU0VSVF9ERU5ZCisJYm9vbCAiRGVueSIKKwloZWxwCisJICBVbm9w dGltaXplZCBjYWxscyB0byBgYnVpbGRfZXJyb3IhYCB3aWxsIGFib3J0IGNvbXBpbGF0aW9uLgor CitlbmRjaG9pY2UKKworY29uZmlnIFJVU1RfS0VSTkVMX0tVTklUX1RFU1QKKwlib29sICJLVW5p dCB0ZXN0IGZvciB0aGUgYGtlcm5lbGAgY3JhdGUiIGlmICFLVU5JVF9BTExfVEVTVFMKKwlkZXBl bmRzIG9uIFJVU1QgJiYgS1VOSVQ9eQorCWRlZmF1bHQgS1VOSVRfQUxMX1RFU1RTCisJaGVscAor CSAgVGhpcyBidWlsZHMgdGhlIGRvY3VtZW50YXRpb24gdGVzdHMgb2YgdGhlIGBrZXJuZWxgIGNy YXRlCisJICBhcyBLVW5pdCB0ZXN0cy4KKworCSAgRm9yIG1vcmUgaW5mb3JtYXRpb24gb24gS1Vu aXQgYW5kIHVuaXQgdGVzdHMgaW4gZ2VuZXJhbCwKKwkgIHBsZWFzZSByZWZlciB0byB0aGUgS1Vu aXQgZG9jdW1lbnRhdGlvbiBpbiBEb2N1bWVudGF0aW9uL2Rldi10b29scy9rdW5pdC8uCisKKwkg IElmIHVuc3VyZSwgc2F5IE4uCisKK2VuZG1lbnUgIyAiUnVzdCIKKwogc291cmNlICJEb2N1bWVu dGF0aW9uL0tjb25maWciCiAKIGVuZG1lbnUgIyBLZXJuZWwgaGFja2luZwpkaWZmIC0tZ2l0IGEv cnVzdC8uZ2l0aWdub3JlIGIvcnVzdC8uZ2l0aWdub3JlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMC4uODliNjAyZDkxMTA5Ci0tLSAvZGV2L251bGwKKysrIGIvcnVzdC8u Z2l0aWdub3JlCkBAIC0wLDAgKzEsMTAgQEAKKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQ TC0yLjAKKwordGFyZ2V0Lmpzb24KK2JpbmRpbmdzX2dlbmVyYXRlZC5ycworYmluZGluZ3NfaGVs cGVyc19nZW5lcmF0ZWQucnMKK2V4cG9ydHNfKl9nZW5lcmF0ZWQuaAorZG9jdGVzdHNfa2VybmVs X2dlbmVyYXRlZC5ycworZG9jdGVzdHNfa2VybmVsX2dlbmVyYXRlZF9rdW5pdC5jCitkb2MvCit0 ZXN0LwpkaWZmIC0tZ2l0IGEvcnVzdC9NYWtlZmlsZSBiL3J1c3QvTWFrZWZpbGUKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4zMGNlMTNmYThkYWQKLS0tIC9kZXYvbnVs bAorKysgYi9ydXN0L01ha2VmaWxlCkBAIC0wLDAgKzEsNDE1IEBACisjIFNQRFgtTGljZW5zZS1J ZGVudGlmaWVyOiBHUEwtMi4wCisKK2Fsd2F5cy0kKENPTkZJR19SVVNUKSArPSB0YXJnZXQuanNv bgorbm8tY2xlYW4tZmlsZXMgKz0gdGFyZ2V0Lmpzb24KKworb2JqLSQoQ09ORklHX1JVU1QpICs9 IGNvcmUubyBjb21waWxlcl9idWlsdGlucy5vCithbHdheXMtJChDT05GSUdfUlVTVCkgKz0gZXhw b3J0c19jb3JlX2dlbmVyYXRlZC5oCisKKyMgTWlzc2luZyBwcm90b3R5cGVzIGFyZSBleHBlY3Rl ZCBpbiB0aGUgaGVscGVycyBzaW5jZSB0aGVzZSBhcmUgZXhwb3J0ZWQKKyMgZm9yIFJ1c3Qgb25s eSwgdGh1cyB0aGVyZSBpcyBubyBoZWFkZXIgbm9yIHByb3RvdHlwZXMuCitvYmotJChDT05GSUdf UlVTVCkgKz0gaGVscGVycy5vCitDRkxBR1NfUkVNT1ZFX2hlbHBlcnMubyA9IC1XbWlzc2luZy1w cm90b3R5cGVzIC1XbWlzc2luZy1kZWNsYXJhdGlvbnMKKworYWx3YXlzLSQoQ09ORklHX1JVU1Qp ICs9IGxpYm1hY3Jvcy5zbworbm8tY2xlYW4tZmlsZXMgKz0gbGlibWFjcm9zLnNvCisKK2Fsd2F5 cy0kKENPTkZJR19SVVNUKSArPSBiaW5kaW5ncy9iaW5kaW5nc19nZW5lcmF0ZWQucnMgYmluZGlu Z3MvYmluZGluZ3NfaGVscGVyc19nZW5lcmF0ZWQucnMKK29iai0kKENPTkZJR19SVVNUKSArPSBh bGxvYy5vIGJpbmRpbmdzLm8ga2VybmVsLm8KK2Fsd2F5cy0kKENPTkZJR19SVVNUKSArPSBleHBv cnRzX2FsbG9jX2dlbmVyYXRlZC5oIGV4cG9ydHNfYmluZGluZ3NfZ2VuZXJhdGVkLmggXAorICAg IGV4cG9ydHNfa2VybmVsX2dlbmVyYXRlZC5oCisKK2lmZGVmIENPTkZJR19SVVNUX0JVSUxEX0FT U0VSVF9ERU5ZCithbHdheXMtJChDT05GSUdfUlVTVCkgKz0gYnVpbGRfZXJyb3IubworZWxzZQor b2JqLSQoQ09ORklHX1JVU1QpICs9IGJ1aWxkX2Vycm9yLm8KK2VuZGlmCisKK29iai0kKENPTkZJ R19SVVNUKSArPSBleHBvcnRzLm8KKworb2JqLSQoQ09ORklHX1JVU1RfS0VSTkVMX0tVTklUX1RF U1QpICs9IGRvY3Rlc3RzX2tlcm5lbF9nZW5lcmF0ZWQubworb2JqLSQoQ09ORklHX1JVU1RfS0VS TkVMX0tVTklUX1RFU1QpICs9IGRvY3Rlc3RzX2tlcm5lbF9nZW5lcmF0ZWRfa3VuaXQubworCisj IEF2b2lkcyBydW5uaW5nIGAkKFJVU1RDKWAgZm9yIHRoZSBzeXNyb290IHdoZW4gaXQgbWF5IG5v dCBiZSBhdmFpbGFibGUuCitpZmRlZiBDT05GSUdfUlVTVAorCisjIGAkKHJ1c3RfZmxhZ3MpYCBp cyBwYXNzZWQgaW4gY2FzZSB0aGUgdXNlciBhZGRlZCBgLS1zeXNyb290YC4KK3J1c3RjX3N5c3Jv b3QgOj0gJChzaGVsbCAkKFJVU1RDKSAkKHJ1c3RfZmxhZ3MpIC0tcHJpbnQgc3lzcm9vdCkKK3J1 c3RjX2hvc3RfdGFyZ2V0IDo9ICQoc2hlbGwgJChSVVNUQykgLS12ZXJzaW9uIC0tdmVyYm9zZSB8 IGdyZXAgLUYgJ2hvc3Q6ICcgfCBjdXQgLWQnICcgLWYyKQorUlVTVF9MSUJfU1JDID89ICQocnVz dGNfc3lzcm9vdCkvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeQorCitpZmVxICgkKHF1aWV0 KSxzaWxlbnRfKQorY2FyZ29fcXVpZXQ9LXEKK3J1c3RfdGVzdF9xdWlldD0tcQorcnVzdGRvY190 ZXN0X3F1aWV0PS0tdGVzdC1hcmdzIC1xCitydXN0ZG9jX3Rlc3Rfa2VybmVsX3F1aWV0PT4vZGV2 L251bGwKK2Vsc2UgaWZlcSAoJChxdWlldCkscXVpZXRfKQorcnVzdF90ZXN0X3F1aWV0PS1xCity dXN0ZG9jX3Rlc3RfcXVpZXQ9LS10ZXN0LWFyZ3MgLXEKK3J1c3Rkb2NfdGVzdF9rZXJuZWxfcXVp ZXQ9Pi9kZXYvbnVsbAorZWxzZQorY2FyZ29fcXVpZXQ9LS12ZXJib3NlCitlbmRpZgorCitjb3Jl LWNmZ3MgPSBcCisgICAgLS1jZmcgbm9fZnBfZm10X3BhcnNlCisKK2FsbG9jLWNmZ3MgPSBcCisg ICAgLS1jZmcgbm9fZ2xvYmFsX29vbV9oYW5kbGluZyBcCisgICAgLS1jZmcgbm9fcmMgXAorICAg IC0tY2ZnIG5vX3N5bmMKKworcXVpZXRfY21kX3J1c3Rkb2MgPSBSVVNURE9DICQoaWYgJChydXN0 ZG9jX2hvc3QpLEgsICkgJDwKKyAgICAgIGNtZF9ydXN0ZG9jID0gXAorCU9CSlRSRUU9JChhYnNw YXRoICQob2JqdHJlZSkpIFwKKwkkKFJVU1RET0MpICQoaWYgJChydXN0ZG9jX2hvc3QpLCQocnVz dF9jb21tb25fZmxhZ3MpLCQocnVzdF9mbGFncykpIFwKKwkJJChydXN0Y190YXJnZXRfZmxhZ3Mp IC1MJChvYmp0cmVlKS8kKG9iaikgXAorCQktLW91dHB1dCAkKG9ianRyZWUpLyQob2JqKS9kb2Mg XAorCQktLWNyYXRlLW5hbWUgJChzdWJzdCBydXN0ZG9jLSwsJEApIFwKKwkJQCQob2JqdHJlZSkv aW5jbHVkZS9nZW5lcmF0ZWQvcnVzdGNfY2ZnICQ8CisKKyMgVGhlIGBodG1sX2xvZ29fdXJsYCBh bmQgYGh0bWxfZmF2aWNvbl91cmxgIGZvcm1zIG9mIHRoZSBgZG9jYCBhdHRyaWJ1dGUKKyMgY2Fu IGJlIHVzZWQgdG8gc3BlY2lmeSBhIGN1c3RvbSBsb2dvLiBIb3dldmVyOgorIyAgIC0gVGhlIGdp dmVuIHZhbHVlIGlzIHVzZWQgYXMtaXMsIHRodXMgaXQgY2Fubm90IGJlIHJlbGF0aXZlIG9yIGEg bG9jYWwgZmlsZQorIyAgICAgKHVubGlrZSB0aGUgbm9uLWN1c3RvbSBjYXNlKSBzaW5jZSB0aGUg Z2VuZXJhdGVkIGRvY3MgaGF2ZSBzdWJmb2xkZXJzLgorIyAgIC0gSXQgcmVxdWlyZXMgYWRkaW5n IGl0IHRvIGV2ZXJ5IGNyYXRlLgorIyAgIC0gSXQgcmVxdWlyZXMgY2hhbmdpbmcgYGNvcmVgIHdo aWNoIGNvbWVzIGZyb20gdGhlIHN5c3Jvb3QuCisjCisjIFVzaW5nIGAtWmNyYXRlLWF0dHJgIHdv dWxkIHNvbHZlIHRoZSBsYXN0IHR3byBwb2ludHMsIGJ1dCBub3QgdGhlIGZpcnN0LgorIyBUaGUg aHR0cHM6Ly9naXRodWIuY29tL3J1c3QtbGFuZy9yZmNzL3B1bGwvMzIyNiBSRkMgc3VnZ2VzdHMg dHdvIG5ldworIyBjb21tYW5kLWxpa2UgZmxhZ3MgdG8gc29sdmUgdGhlIGlzc3VlLiBNZWFud2hp bGUsIHdlIHVzZSB0aGUgbm9uLWN1c3RvbSBjYXNlCisjIGFuZCB0aGVuIHJldG91Y2ggdGhlIGdl bmVyYXRlZCBmaWxlcy4KK3J1c3Rkb2M6IHJ1c3Rkb2MtY29yZSBydXN0ZG9jLW1hY3JvcyBydXN0 ZG9jLWNvbXBpbGVyX2J1aWx0aW5zIFwKKyAgICBydXN0ZG9jLWFsbG9jIHJ1c3Rkb2Mta2VybmVs CisJJChRKWNwICQoc3JjdHJlZSkvRG9jdW1lbnRhdGlvbi9pbWFnZXMvbG9nby5zdmcgJChvYmp0 cmVlKS8kKG9iaikvZG9jCisJJChRKWNwICQoc3JjdHJlZSkvRG9jdW1lbnRhdGlvbi9pbWFnZXMv Q09QWUlORy1sb2dvICQob2JqdHJlZSkvJChvYmopL2RvYworCSQoUSlmaW5kICQob2JqdHJlZSkv JChvYmopL2RvYyAtbmFtZSAnKi5odG1sJyAtdHlwZSBmIC1wcmludDAgfCB4YXJncyAtMCBzZWQg LUVpIFwKKwkJLWUgJ3M6cnVzdC1sb2dvXC5zdmc6bG9nby5zdmc6ZycgXAorCQktZSAnczpydXN0 LWxvZ29cLnBuZzpsb2dvLnN2ZzpnJyBcCisJCS1lICdzOmZhdmljb25cLnN2Zzpsb2dvLnN2Zzpn JyBcCisJCS1lICdzOjxsaW5rIHJlbD0iYWx0ZXJuYXRlIGljb24iIHR5cGU9ImltYWdlL3BuZyIg aHJlZj0iWy4vXSpmYXZpY29uLSgxNngxNnwzMngzMilcLnBuZyI+OjpnJworCSQoUSllY2hvICcu bG9nby1jb250YWluZXIgPiBpbWcgeyBvYmplY3QtZml0OiBjb250YWluOyB9JyBcCisJCT4+ICQo b2JqdHJlZSkvJChvYmopL2RvYy9ydXN0ZG9jLmNzcworCitydXN0ZG9jLW1hY3JvczogcHJpdmF0 ZSBydXN0ZG9jX2hvc3QgPSB5ZXMKK3J1c3Rkb2MtbWFjcm9zOiBwcml2YXRlIHJ1c3RjX3Rhcmdl dF9mbGFncyA9IC0tY3JhdGUtdHlwZSBwcm9jLW1hY3JvIFwKKyAgICAtLWV4dGVybiBwcm9jX21h Y3JvCitydXN0ZG9jLW1hY3JvczogJChzcmMpL21hY3Jvcy9saWIucnMgRk9SQ0UKKwkkKGNhbGwg aWZfY2hhbmdlZCxydXN0ZG9jKQorCitydXN0ZG9jLWNvcmU6IHByaXZhdGUgcnVzdGNfdGFyZ2V0 X2ZsYWdzID0gJChjb3JlLWNmZ3MpCitydXN0ZG9jLWNvcmU6ICQoUlVTVF9MSUJfU1JDKS9jb3Jl L3NyYy9saWIucnMgRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxydXN0ZG9jKQorCitydXN0ZG9j LWNvbXBpbGVyX2J1aWx0aW5zOiAkKHNyYykvY29tcGlsZXJfYnVpbHRpbnMucnMgcnVzdGRvYy1j b3JlIEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWQscnVzdGRvYykKKworIyBXZSBuZWVkIHRvIGFs bG93IGBydXN0ZG9jOjpicm9rZW5faW50cmFfZG9jX2xpbmtzYCBiZWNhdXNlIHNvbWUKKyMgYG5v X2dsb2JhbF9vb21faGFuZGxpbmdgIGZ1bmN0aW9ucyByZWZlciB0byBub24tYG5vX2dsb2JhbF9v b21faGFuZGxpbmdgCisjIGZ1bmN0aW9ucy4gSWRlYWxseSBgcnVzdGRvY2Agd291bGQgaGF2ZSBh IHdheSB0byBkaXN0aW5ndWlzaCBicm9rZW4gbGlua3MKKyMgZHVlIHRvIHRoaW5ncyB0aGF0IGFy ZSAiY29uZmlndXJlZCBvdXQiIHZzLiBlbnRpcmVseSBub24tZXhpc3Rpbmcgb25lcy4KK3J1c3Rk b2MtYWxsb2M6IHByaXZhdGUgcnVzdGNfdGFyZ2V0X2ZsYWdzID0gJChhbGxvYy1jZmdzKSBcCisg ICAgLUFydXN0ZG9jOjpicm9rZW5faW50cmFfZG9jX2xpbmtzCitydXN0ZG9jLWFsbG9jOiAkKHNy YykvYWxsb2MvbGliLnJzIHJ1c3Rkb2MtY29yZSBydXN0ZG9jLWNvbXBpbGVyX2J1aWx0aW5zIEZP UkNFCisJJChjYWxsIGlmX2NoYW5nZWQscnVzdGRvYykKKworcnVzdGRvYy1rZXJuZWw6IHByaXZh dGUgcnVzdGNfdGFyZ2V0X2ZsYWdzID0gLS1leHRlcm4gYWxsb2MgXAorICAgIC0tZXh0ZXJuIGJ1 aWxkX2Vycm9yIC0tZXh0ZXJuIG1hY3Jvcz0kKG9ianRyZWUpLyQob2JqKS9saWJtYWNyb3Muc28g XAorICAgIC0tZXh0ZXJuIGJpbmRpbmdzCitydXN0ZG9jLWtlcm5lbDogJChzcmMpL2tlcm5lbC9s aWIucnMgcnVzdGRvYy1jb3JlIHJ1c3Rkb2MtbWFjcm9zIFwKKyAgICBydXN0ZG9jLWNvbXBpbGVy X2J1aWx0aW5zIHJ1c3Rkb2MtYWxsb2MgJChvYmopL2xpYm1hY3Jvcy5zbyBcCisgICAgJChvYmop L2JpbmRpbmdzLm8gRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxydXN0ZG9jKQorCitxdWlldF9j bWRfcnVzdGNfdGVzdF9saWJyYXJ5ID0gUlVTVEMgVEwgJDwKKyAgICAgIGNtZF9ydXN0Y190ZXN0 X2xpYnJhcnkgPSBcCisJT0JKVFJFRT0kKGFic3BhdGggJChvYmp0cmVlKSkgXAorCSQoUlVTVEMp ICQocnVzdF9jb21tb25fZmxhZ3MpIFwKKwkJQCQob2JqdHJlZSkvaW5jbHVkZS9nZW5lcmF0ZWQv cnVzdGNfY2ZnICQocnVzdGNfdGFyZ2V0X2ZsYWdzKSBcCisJCS0tY3JhdGUtdHlwZSAkKGlmICQo cnVzdGNfdGVzdF9saWJyYXJ5X3Byb2MpLHByb2MtbWFjcm8scmxpYikgXAorCQktLW91dC1kaXIg JChvYmp0cmVlKS8kKG9iaikvdGVzdCAtLWNmZyB0ZXN0bGliIFwKKwkJLS1zeXNyb290ICQob2Jq dHJlZSkvJChvYmopL3Rlc3Qvc3lzcm9vdCBcCisJCS1MJChvYmp0cmVlKS8kKG9iaikvdGVzdCBc CisJCS0tY3JhdGUtbmFtZSAkKHN1YnN0IHJ1c3R0ZXN0LSwsJChzdWJzdCBydXN0dGVzdGxpYi0s LCRAKSkgJDwKKworcnVzdHRlc3RsaWItYnVpbGRfZXJyb3I6ICQoc3JjKS9idWlsZF9lcnJvci5y cyBydXN0dGVzdC1wcmVwYXJlIEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWQscnVzdGNfdGVzdF9s aWJyYXJ5KQorCitydXN0dGVzdGxpYi1tYWNyb3M6IHByaXZhdGUgcnVzdGNfdGFyZ2V0X2ZsYWdz ID0gLS1leHRlcm4gcHJvY19tYWNybworcnVzdHRlc3RsaWItbWFjcm9zOiBwcml2YXRlIHJ1c3Rj X3Rlc3RfbGlicmFyeV9wcm9jID0geWVzCitydXN0dGVzdGxpYi1tYWNyb3M6ICQoc3JjKS9tYWNy b3MvbGliLnJzIHJ1c3R0ZXN0LXByZXBhcmUgRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxydXN0 Y190ZXN0X2xpYnJhcnkpCisKK3J1c3R0ZXN0bGliLWJpbmRpbmdzOiAkKHNyYykvYmluZGluZ3Mv bGliLnJzIHJ1c3R0ZXN0LXByZXBhcmUgRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxydXN0Y190 ZXN0X2xpYnJhcnkpCisKK3F1aWV0X2NtZF9ydXN0ZG9jX3Rlc3QgPSBSVVNURE9DIFQgJDwKKyAg ICAgIGNtZF9ydXN0ZG9jX3Rlc3QgPSBcCisJT0JKVFJFRT0kKGFic3BhdGggJChvYmp0cmVlKSkg XAorCSQoUlVTVERPQykgLS10ZXN0ICQocnVzdF9jb21tb25fZmxhZ3MpIFwKKwkJQCQob2JqdHJl ZSkvaW5jbHVkZS9nZW5lcmF0ZWQvcnVzdGNfY2ZnIFwKKwkJJChydXN0Y190YXJnZXRfZmxhZ3Mp ICQocnVzdGRvY190ZXN0X3RhcmdldF9mbGFncykgXAorCQktLXN5c3Jvb3QgJChvYmp0cmVlKS8k KG9iaikvdGVzdC9zeXNyb290ICQocnVzdGRvY190ZXN0X3F1aWV0KSBcCisJCS1MJChvYmp0cmVl KS8kKG9iaikvdGVzdCAtLW91dHB1dCAkKG9ianRyZWUpLyQob2JqKS9kb2MgXAorCQktLWNyYXRl LW5hbWUgJChzdWJzdCBydXN0dGVzdC0sLCRAKSAkPAorCitxdWlldF9jbWRfcnVzdGRvY190ZXN0 X2tlcm5lbCA9IFJVU1RET0MgVEsgJDwKKyAgICAgIGNtZF9ydXN0ZG9jX3Rlc3Rfa2VybmVsID0g XAorCXJtIC1yZiAkKG9ianRyZWUpLyQob2JqKS90ZXN0L2RvY3Rlc3RzL2tlcm5lbDsgXAorCW1r ZGlyIC1wICQob2JqdHJlZSkvJChvYmopL3Rlc3QvZG9jdGVzdHMva2VybmVsOyBcCisJT0JKVFJF RT0kKGFic3BhdGggJChvYmp0cmVlKSkgXAorCSQoUlVTVERPQykgLS10ZXN0ICQocnVzdF9mbGFn cykgXAorCQlAJChvYmp0cmVlKS9pbmNsdWRlL2dlbmVyYXRlZC9ydXN0Y19jZmcgXAorCQktTCQo b2JqdHJlZSkvJChvYmopIC0tZXh0ZXJuIGFsbG9jIC0tZXh0ZXJuIGtlcm5lbCBcCisJCS0tZXh0 ZXJuIGJ1aWxkX2Vycm9yIC0tZXh0ZXJuIG1hY3JvcyBcCisJCS0tZXh0ZXJuIGJpbmRpbmdzIFwK KwkJLS1uby1ydW4gLS1jcmF0ZS1uYW1lIGtlcm5lbCAtWnVuc3RhYmxlLW9wdGlvbnMgXAorCQkt LXRlc3QtYnVpbGRlciAkKHNyY3RyZWUpL3NjcmlwdHMvcnVzdGRvY190ZXN0X2J1aWxkZXIucHkg XAorCQkkPCAkKHJ1c3Rkb2NfdGVzdF9rZXJuZWxfcXVpZXQpOyBcCisJJChzcmN0cmVlKS9zY3Jp cHRzL3J1c3Rkb2NfdGVzdF9nZW4ucHkKKworJS9kb2N0ZXN0c19rZXJuZWxfZ2VuZXJhdGVkLnJz ICUvZG9jdGVzdHNfa2VybmVsX2dlbmVyYXRlZF9rdW5pdC5jOiAkKHNyYykva2VybmVsL2xpYi5y cyAkKG9iaikva2VybmVsLm8gRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxydXN0ZG9jX3Rlc3Rf a2VybmVsKQorCisjIFdlIGNhbm5vdCB1c2UgYC1acGFuaWMtYWJvcnQtdGVzdHNgIGJlY2F1c2Ug c29tZSB0ZXN0cyBhcmUgZHluYW1pYywKKyMgc28gZm9yIHRoZSBtb21lbnQgd2Ugc2tpcCBgLUNw YW5pYz1hYm9ydGAuCitxdWlldF9jbWRfcnVzdGNfdGVzdCA9IFJVU1RDIFQgICQ8CisgICAgICBj bWRfcnVzdGNfdGVzdCA9IFwKKwlPQkpUUkVFPSQoYWJzcGF0aCAkKG9ianRyZWUpKSBcCisJJChS VVNUQykgLS10ZXN0ICQocnVzdF9jb21tb25fZmxhZ3MpIFwKKwkJQCQob2JqdHJlZSkvaW5jbHVk ZS9nZW5lcmF0ZWQvcnVzdGNfY2ZnIFwKKwkJJChydXN0Y190YXJnZXRfZmxhZ3MpIC0tb3V0LWRp ciAkKG9ianRyZWUpLyQob2JqKS90ZXN0IFwKKwkJLS1zeXNyb290ICQob2JqdHJlZSkvJChvYmop L3Rlc3Qvc3lzcm9vdCBcCisJCS1MJChvYmp0cmVlKS8kKG9iaikvdGVzdCBcCisJCS0tY3JhdGUt bmFtZSAkKHN1YnN0IHJ1c3R0ZXN0LSwsJEApICQ8OyBcCisJJChvYmp0cmVlKS8kKG9iaikvdGVz dC8kKHN1YnN0IHJ1c3R0ZXN0LSwsJEApICQocnVzdF90ZXN0X3F1aWV0KSBcCisJCSQocnVzdGNf dGVzdF9ydW5fZmxhZ3MpCisKK3J1c3R0ZXN0OiBydXN0dGVzdC1tYWNyb3MgcnVzdHRlc3Qta2Vy bmVsCisKKyMgVGhpcyBwcmVwYXJlcyBhIGN1c3RvbSBzeXNyb290IHdpdGggb3VyIGN1c3RvbSBg YWxsb2NgIGluc3RlYWQgb2YKKyMgdGhlIHN0YW5kYXJkIG9uZS4KKyMKKyMgVGhpcyByZXF1aXJl cyBzZXZlcmFsIGhhY2tzOgorIyAgIC0gVW5saWtlIGBjb3JlYCBhbmQgYGFsbG9jYCwgYHN0ZGAg ZGVwZW5kcyBvbiBtb3JlIHRoYW4gYSBkb3plbiBjcmF0ZXMsCisjICAgICBpbmNsdWRpbmcgdGhp cmQtcGFydHkgY3JhdGVzIHRoYXQgbmVlZCB0byBiZSBkb3dubG9hZGVkLCBwbHVzIGN1c3RvbQor IyAgICAgYGJ1aWxkLnJzYCBzdGVwcy4gVGh1cyBoYXJkY29kaW5nIHRoaW5ncyBoZXJlIGlzIG5v dCBtYWludGFpbmFibGUuCisjICAgLSBgY2FyZ29gIGtub3dzIGhvdyB0byBidWlsZCB0aGUgc3Rh bmRhcmQgbGlicmFyeSwgYnV0IGl0IGlzIGFuIHVuc3RhYmxlCisjICAgICBmZWF0dXJlIHNvIGZh ciAoYC1aYnVpbGQtc3RkYCkuCisjICAgLSBgY2FyZ29gIG9ubHkgY29uc2lkZXJzIHRoZSB1c2Ug Y2FzZSBvZiBidWlsZGluZyB0aGUgc3RhbmRhcmQgbGlicmFyeQorIyAgICAgdG8gdXNlIGl0IGlu IGEgZ2l2ZW4gcGFja2FnZS4gVGh1cyB3ZSBuZWVkIHRvIGNyZWF0ZSBhIGR1bW15IHBhY2thZ2UK KyMgICAgIGFuZCBwaWNrIHRoZSBnZW5lcmF0ZWQgbGlicmFyaWVzIGZyb20gdGhlcmUuCisjICAg LSBTaW5jZSB3ZSBvbmx5IGtlZXAgYSBzdWJzZXQgb2YgdXBzdHJlYW0gYGFsbG9jYCBpbi10cmVl LCB3ZSBuZWVkCisjICAgICB0byByZWNyZWF0ZSBpdCBvbiB0aGUgZmx5IGJ5IHB1dHRpbmcgb3Vy IHNvdXJjZXMgb24gdG9wLgorIyAgIC0gVGhlIHVzdWFsIHdheXMgb2YgbW9kaWZ5aW5nIHRoZSBk ZXBlbmRlbmN5IGdyYXBoIGluIGBjYXJnb2AgZG8gbm90IHNlZW0KKyMgICAgIHRvIGFwcGx5IGZv ciB0aGUgYC1aYnVpbGQtc3RkYCBzdGVwcywgdGh1cyB3ZSBoYXZlIHRvIG1pc2xlYWQgaXQKKyMg ICAgIGJ5IG1vZGlmeWluZyB0aGUgc291cmNlcyBpbiB0aGUgc3lzcm9vdC4KKyMgICAtIFRvIGF2 b2lkIG1lc3Npbmcgd2l0aCB0aGUgdXNlcidzIFJ1c3QgaW5zdGFsbGF0aW9uLCB3ZSBjcmVhdGUg YSBjbG9uZQorIyAgICAgb2YgdGhlIHN5c3Jvb3QuIEhvd2V2ZXIsIGBjYXJnb2AgaWdub3JlcyBg UlVTVEZMQUdTYCBpbiB0aGUgYC1aYnVpbGQtc3RkYAorIyAgICAgc3RlcHMsIHRodXMgd2UgdXNl IGEgd3JhcHBlciBiaW5hcnkgcGFzc2VkIHZpYSBgUlVTVENgIHRvIHBhc3MgdGhlIGZsYWcuCisj CisjIEluIHRoZSBmdXR1cmUsIHdlIGhvcGUgdG8gYXZvaWQgdGhlIHdob2xlIG9yZGVhbCBieSBl aXRoZXI6CisjICAgLSBNYWtpbmcgdGhlIGB0ZXN0YCBjcmF0ZSBub3QgZGVwZW5kIG9uIGBzdGRg IChlaXRoZXIgaW1wcm92aW5nIHVwc3RyZWFtCisjICAgICBvciBoYXZpbmcgb3VyIG93biBjdXN0 b20gY3JhdGUpLgorIyAgIC0gTWFraW5nIHRoZSB0ZXN0cyBydW4gaW4ga2VybmVsIHNwYWNlIChy ZXF1aXJlcyB0aGUgcHJldmlvdXMgcG9pbnQpLgorIyAgIC0gTWFraW5nIGBzdGRgIGFuZCBmcmll bmRzIGJlIG1vcmUgbGlrZSBhICJub3JtYWwiIGNyYXRlLCBzbyB0aGF0CisjICAgICBgLVpidWls ZC1zdGRgIGFuZCByZWxhdGVkIGhhY2tzIGFyZSBub3QgbmVlZGVkLgorcXVpZXRfY21kX3J1c3Rz eXNyb290ID0gUlVTVFNZU1JPT1QKKyAgICAgIGNtZF9ydXN0c3lzcm9vdCA9IFwKKwlybSAtcmYg JChvYmp0cmVlKS8kKG9iaikvdGVzdDsgXAorCW1rZGlyIC1wICQob2JqdHJlZSkvJChvYmopL3Rl c3Q7IFwKKwljcCAtYSAkKHJ1c3RjX3N5c3Jvb3QpICQob2JqdHJlZSkvJChvYmopL3Rlc3Qvc3lz cm9vdDsgXAorCWNwIC1yICQoc3JjdHJlZSkvJChzcmMpL2FsbG9jLyogXAorCQkkKG9ianRyZWUp LyQob2JqKS90ZXN0L3N5c3Jvb3QvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9z cmM7IFwKKwllY2hvICdcIyEvYmluL3NoJyA+ICQob2JqdHJlZSkvJChvYmopL3Rlc3QvcnVzdGNf c3lzcm9vdDsgXAorCWVjaG8gIiQoUlVTVEMpIC0tc3lzcm9vdD0kKGFic3BhdGggJChvYmp0cmVl KS8kKG9iaikvdGVzdC9zeXNyb290KSBcIlwkJEBcIiIgXAorCQk+PiAkKG9ianRyZWUpLyQob2Jq KS90ZXN0L3J1c3RjX3N5c3Jvb3Q7IFwKKwljaG1vZCB1K3ggJChvYmp0cmVlKS8kKG9iaikvdGVz dC9ydXN0Y19zeXNyb290OyBcCisJJChDQVJHTykgLXEgbmV3ICQob2JqdHJlZSkvJChvYmopL3Rl c3QvZHVtbXk7IFwKKwlSVVNUQz0kKG9ianRyZWUpLyQob2JqKS90ZXN0L3J1c3RjX3N5c3Jvb3Qg JChDQVJHTykgJChjYXJnb19xdWlldCkgXAorCQl0ZXN0IC1aYnVpbGQtc3RkIC0tdGFyZ2V0ICQo cnVzdGNfaG9zdF90YXJnZXQpIFwKKwkJLS1tYW5pZmVzdC1wYXRoICQob2JqdHJlZSkvJChvYmop L3Rlc3QvZHVtbXkvQ2FyZ28udG9tbDsgXAorCXJtICQob2JqdHJlZSkvJChvYmopL3Rlc3Qvc3lz cm9vdC9saWIvcnVzdGxpYi8kKHJ1c3RjX2hvc3RfdGFyZ2V0KS9saWIvKjsgXAorCWNwICQob2Jq dHJlZSkvJChvYmopL3Rlc3QvZHVtbXkvdGFyZ2V0LyQocnVzdGNfaG9zdF90YXJnZXQpL2RlYnVn L2RlcHMvKiBcCisJCSQob2JqdHJlZSkvJChvYmopL3Rlc3Qvc3lzcm9vdC9saWIvcnVzdGxpYi8k KHJ1c3RjX2hvc3RfdGFyZ2V0KS9saWIKKworcnVzdHRlc3QtcHJlcGFyZTogRk9SQ0UKKwkkKGNh bGwgaWZfY2hhbmdlZCxydXN0c3lzcm9vdCkKKworcnVzdHRlc3QtbWFjcm9zOiBwcml2YXRlIHJ1 c3RjX3RhcmdldF9mbGFncyA9IC0tZXh0ZXJuIHByb2NfbWFjcm8KK3J1c3R0ZXN0LW1hY3Jvczog cHJpdmF0ZSBydXN0ZG9jX3Rlc3RfdGFyZ2V0X2ZsYWdzID0gLS1jcmF0ZS10eXBlIHByb2MtbWFj cm8KK3J1c3R0ZXN0LW1hY3JvczogJChzcmMpL21hY3Jvcy9saWIucnMgcnVzdHRlc3QtcHJlcGFy ZSBGT1JDRQorCSQoY2FsbCBpZl9jaGFuZ2VkLHJ1c3RjX3Rlc3QpCisJJChjYWxsIGlmX2NoYW5n ZWQscnVzdGRvY190ZXN0KQorCitydXN0dGVzdC1rZXJuZWw6IHByaXZhdGUgcnVzdGNfdGFyZ2V0 X2ZsYWdzID0gLS1leHRlcm4gYWxsb2MgXAorICAgIC0tZXh0ZXJuIGJ1aWxkX2Vycm9yIC0tZXh0 ZXJuIG1hY3JvcyAtLWV4dGVybiBiaW5kaW5ncworcnVzdHRlc3Qta2VybmVsOiAkKHNyYykva2Vy bmVsL2xpYi5ycyBydXN0dGVzdC1wcmVwYXJlIFwKKyAgICBydXN0dGVzdGxpYi1idWlsZF9lcnJv ciBydXN0dGVzdGxpYi1tYWNyb3MgcnVzdHRlc3RsaWItYmluZGluZ3MgRk9SQ0UKKwkkKGNhbGwg aWZfY2hhbmdlZCxydXN0Y190ZXN0KQorCSQoY2FsbCBpZl9jaGFuZ2VkLHJ1c3RjX3Rlc3RfbGli cmFyeSkKKworZmlsZWNoa19ydXN0X3RhcmdldCA9ICQob2JqdHJlZSkvc2NyaXB0cy9nZW5lcmF0 ZV9ydXN0X3RhcmdldCA8ICQ8CisKKyQob2JqKS90YXJnZXQuanNvbjogJChvYmp0cmVlKS9pbmNs dWRlL2NvbmZpZy9hdXRvLmNvbmYgRk9SQ0UKKwkkKGNhbGwgZmlsZWNoayxydXN0X3RhcmdldCkK KworaWZkZWYgQ09ORklHX0NDX0lTX0NMQU5HCitiaW5kZ2VuX2NfZmxhZ3MgPSAkKGNfZmxhZ3Mp CitlbHNlCisjIGJpbmRnZW4gcmVsaWVzIG9uIGxpYmNsYW5nIHRvIHBhcnNlIEMuIElkZWFsbHks IGJpbmRnZW4gd291bGQgc3VwcG9ydCBhIEdDQworIyBwbHVnaW4gYmFja2VuZCBhbmQvb3IgdGhl IENsYW5nIGRyaXZlciB3b3VsZCBiZSBwZXJmZWN0bHkgY29tcGF0aWJsZSB3aXRoIEdDQy4KKyMK KyMgRm9yIHRoZSBtb21lbnQsIGhlcmUgd2UgYXJlIHR3ZWFraW5nIHRoZSBmbGFncyBvbiB0aGUg Zmx5LiBUaGlzIGlzIGEgaGFjaywKKyMgYW5kIHNvbWUga2VybmVsIGNvbmZpZ3VyYXRpb25zIG1h eSBub3Qgd29yayAoZS5nLiBgR0NDX1BMVUdJTl9SQU5EU1RSVUNUYAorIyBpZiB3ZSBlbmQgdXAg dXNpbmcgb25lIG9mIHRob3NlIHN0cnVjdHMpLgorYmluZGdlbl9za2lwX2NfZmxhZ3MgOj0gLW1u by1mcC1yZXQtaW4tMzg3IC1tcHJlZmVycmVkLXN0YWNrLWJvdW5kYXJ5PSUgXAorCS1tc2tpcC1y YXgtc2V0dXAgLW1nZW5lcmFsLXJlZ3Mtb25seSAtbXNpZ24tcmV0dXJuLWFkZHJlc3M9JSBcCisJ LW1pbmRpcmVjdC1icmFuY2g9dGh1bmstZXh0ZXJuIC1taW5kaXJlY3QtYnJhbmNoLXJlZ2lzdGVy IFwKKwktbWZ1bmN0aW9uLXJldHVybj10aHVuay1leHRlcm4gLW1yZWNvcmQtbWNvdW50IC1tYWJp PWxwNjQgXAorCS1tc3RhY2stcHJvdGVjdG9yLWd1YXJkJSAtbXRyYWNlYmFjaz1ubyBcCisJLW1u by1wb2ludGVycy10by1uZXN0ZWQtZnVuY3Rpb25zIC1tbm8tc3RyaW5nIFwKKwktbW5vLXN0cmlj dC1hbGlnbiAtbXN0cmljdC1hbGlnbiBcCisJLWZjb25zZXJ2ZS1zdGFjayAtZmFsaWduLWp1bXBz PSUgLWZhbGlnbi1sb29wcz0lIFwKKwktZmVtaXQtc3RydWN0LWRlYnVnLWJhc2Vvbmx5IC1mbm8t aXBhLWNwLWNsb25lIC1mbm8taXBhLXNyYSBcCisJLWZuby1wYXJ0aWFsLWlubGluaW5nIC1mcGx1 Z2luLWFyZy1hcm1fc3NwX3Blcl90YXNrX3BsdWdpbi0lIFwKKwktZm5vLXJlb3JkZXItYmxvY2tz IC1mbm8tYWxsb3ctc3RvcmUtZGF0YS1yYWNlcyAtZmFzYW4tc2hhZG93LW9mZnNldD0lIFwKKwkt Znplcm8tY2FsbC11c2VkLXJlZ3M9JSAtZm5vLXN0YWNrLWNsYXNoLXByb3RlY3Rpb24gXAorCS1m bm8taW5saW5lLWZ1bmN0aW9ucy1jYWxsZWQtb25jZSBcCisJLS1wYXJhbT0lIC0tcGFyYW0gYXNh bi0lCisKKyMgRGVyaXZlZCBmcm9tIGBzY3JpcHRzL01ha2VmaWxlLmNsYW5nYC4KK0JJTkRHRU5f VEFSR0VUX2FybQk6PSBhcm0tbGludXgtZ251ZWFiaQorQklOREdFTl9UQVJHRVRfYXJtNjQJOj0g YWFyY2g2NC1saW51eC1nbnUKK0JJTkRHRU5fVEFSR0VUX3Bvd2VycGMJOj0gcG93ZXJwYzY0bGUt bGludXgtZ251CitCSU5ER0VOX1RBUkdFVF9yaXNjdgk6PSByaXNjdjY0LWxpbnV4LWdudQorQklO REdFTl9UQVJHRVRfeDg2CTo9IHg4Nl82NC1saW51eC1nbnUKK0JJTkRHRU5fVEFSR0VUCQk6PSAk KEJJTkRHRU5fVEFSR0VUXyQoU1JDQVJDSCkpCisKKyMgQWxsIHdhcm5pbmdzIGFyZSBpbmhpYml0 ZWQgc2luY2UgR0NDIGJ1aWxkcyBhcmUgdmVyeSBleHBlcmltZW50YWwsCisjIG1hbnkgR0NDIHdh cm5pbmdzIGFyZSBub3Qgc3VwcG9ydGVkIGJ5IENsYW5nLCB0aGV5IG1heSBvbmx5IGFwcGVhciBp bgorIyBzb21lIGNvbmZpZ3VyYXRpb25zLCB3aXRoIG5ldyBHQ0MgdmVyc2lvbnMsIGV0Yy4KK2Jp bmRnZW5fZXh0cmFfY19mbGFncyA9IC13IC0tdGFyZ2V0PSQoQklOREdFTl9UQVJHRVQpCisKK2Jp bmRnZW5fY19mbGFncyA9ICQoZmlsdGVyLW91dCAkKGJpbmRnZW5fc2tpcF9jX2ZsYWdzKSwgJChj X2ZsYWdzKSkgXAorCSQoYmluZGdlbl9leHRyYV9jX2ZsYWdzKQorZW5kaWYKKworaWZkZWYgQ09O RklHX0xUTworYmluZGdlbl9jX2ZsYWdzX2x0byA9ICQoZmlsdGVyLW91dCAkKENDX0ZMQUdTX0xU TyksICQoYmluZGdlbl9jX2ZsYWdzKSkKK2Vsc2UKK2JpbmRnZW5fY19mbGFnc19sdG8gPSAkKGJp bmRnZW5fY19mbGFncykKK2VuZGlmCisKK2JpbmRnZW5fY19mbGFnc19maW5hbCA9ICQoYmluZGdl bl9jX2ZsYWdzX2x0bykgLURfX0JJTkRHRU5fXworCitxdWlldF9jbWRfYmluZGdlbiA9IEJJTkRH RU4gJEAKKyAgICAgIGNtZF9iaW5kZ2VuID0gXAorCSQoQklOREdFTikgJDwgJChiaW5kZ2VuX3Rh cmdldF9mbGFncykgXAorCQktLXVzZS1jb3JlIC0td2l0aC1kZXJpdmUtZGVmYXVsdCAtLWN0eXBl cy1wcmVmaXggY29yZTo6ZmZpIC0tbm8tbGF5b3V0LXRlc3RzIFwKKwkJLS1uby1kZWJ1ZyAnLion IFwKKwkJLS1zaXplX3QtaXMtdXNpemUgLW8gJEAgLS0gJChiaW5kZ2VuX2NfZmxhZ3NfZmluYWwp IC1ETU9EVUxFIFwKKwkJJChiaW5kZ2VuX3RhcmdldF9jZmxhZ3MpICQoYmluZGdlbl90YXJnZXRf ZXh0cmEpCisKKyQob2JqKS9iaW5kaW5ncy9iaW5kaW5nc19nZW5lcmF0ZWQucnM6IHByaXZhdGUg YmluZGdlbl90YXJnZXRfZmxhZ3MgPSBcCisgICAgJChzaGVsbCBncmVwIC12ICdeXCNcfF4kJCcg JChzcmN0cmVlKS8kKHNyYykvYmluZGdlbl9wYXJhbWV0ZXJzKQorJChvYmopL2JpbmRpbmdzL2Jp bmRpbmdzX2dlbmVyYXRlZC5yczogJChzcmMpL2JpbmRpbmdzL2JpbmRpbmdzX2hlbHBlci5oIFwK KyAgICAkKHNyYykvYmluZGdlbl9wYXJhbWV0ZXJzIEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWRf ZGVwLGJpbmRnZW4pCisKKyMgU2VlIGBDRkxBR1NfUkVNT1ZFX2hlbHBlcnMub2AgYWJvdmUuIElu IGFkZGl0aW9uLCBDbGFuZyBvbiBDIGRvZXMgbm90IHdhcm4KKyMgd2l0aCBgLVdtaXNzaW5nLWRl Y2xhcmF0aW9uc2AgKHVubGlrZSBHQ0MpLCBzbyBpdCBpcyBub3Qgc3RyaWN0bHkgbmVlZGVkIGhl cmUKKyMgZ2l2ZW4gaXQgaXMgYGxpYmNsYW5nYDsgYnV0IGZvciBjb25zaXN0ZW5jeSwgZnV0dXJl IENsYW5nIGNoYW5nZXMgYW5kL29yCisjIGEgcG90ZW50aWFsIGZ1dHVyZSBHQ0MgYmFja2VuZCBm b3IgYGJpbmRnZW5gLCB3ZSBkaXNhYmxlIGl0IHRvby4KKyQob2JqKS9iaW5kaW5ncy9iaW5kaW5n c19oZWxwZXJzX2dlbmVyYXRlZC5yczogcHJpdmF0ZSBiaW5kZ2VuX3RhcmdldF9mbGFncyA9IFwK KyAgICAtLWJsYWNrbGlzdC10eXBlICcuKicgLS13aGl0ZWxpc3QtdmFyICcnIFwKKyAgICAtLXdo aXRlbGlzdC1mdW5jdGlvbiAncnVzdF9oZWxwZXJfLionCiskKG9iaikvYmluZGluZ3MvYmluZGlu Z3NfaGVscGVyc19nZW5lcmF0ZWQucnM6IHByaXZhdGUgYmluZGdlbl90YXJnZXRfY2ZsYWdzID0g XAorICAgIC1JJChvYmp0cmVlKS8kKG9iaikgLVduby1taXNzaW5nLXByb3RvdHlwZXMgLVduby1t aXNzaW5nLWRlY2xhcmF0aW9ucworJChvYmopL2JpbmRpbmdzL2JpbmRpbmdzX2hlbHBlcnNfZ2Vu ZXJhdGVkLnJzOiBwcml2YXRlIGJpbmRnZW5fdGFyZ2V0X2V4dHJhID0gOyBcCisgICAgc2VkIC1F aSAncy9wdWIgZm4gcnVzdF9oZWxwZXJfKFthLXpBLVowLTlfXSopLyNbbGlua19uYW1lPSJydXN0 X2hlbHBlcl9cMSJdXG4gICAgcHViIGZuIFwxL2cnICRACiskKG9iaikvYmluZGluZ3MvYmluZGlu Z3NfaGVscGVyc19nZW5lcmF0ZWQucnM6ICQoc3JjKS9oZWxwZXJzLmMgRk9SQ0UKKwkkKGNhbGwg aWZfY2hhbmdlZF9kZXAsYmluZGdlbikKKworcXVpZXRfY21kX2V4cG9ydHMgPSBFWFBPUlRTICRA CisgICAgICBjbWRfZXhwb3J0cyA9IFwKKwkkKE5NKSAtcCAtLWRlZmluZWQtb25seSAkPCBcCisJ CXwgZ3JlcCAtRSAnIChUfFJ8RCkgJyB8IGN1dCAtZCAnICcgLWYgMyBcCisJCXwgeGFyZ3MgLUlz eW1ib2wgXAorCQllY2hvICdFWFBPUlRfU1lNQk9MX1JVU1RfR1BMKHN5bWJvbCk7JyA+ICRACisK KyQob2JqKS9leHBvcnRzX2NvcmVfZ2VuZXJhdGVkLmg6ICQob2JqKS9jb3JlLm8gRk9SQ0UKKwkk KGNhbGwgaWZfY2hhbmdlZCxleHBvcnRzKQorCiskKG9iaikvZXhwb3J0c19hbGxvY19nZW5lcmF0 ZWQuaDogJChvYmopL2FsbG9jLm8gRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxleHBvcnRzKQor CiskKG9iaikvZXhwb3J0c19iaW5kaW5nc19nZW5lcmF0ZWQuaDogJChvYmopL2JpbmRpbmdzLm8g Rk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxleHBvcnRzKQorCiskKG9iaikvZXhwb3J0c19rZXJu ZWxfZ2VuZXJhdGVkLmg6ICQob2JqKS9rZXJuZWwubyBGT1JDRQorCSQoY2FsbCBpZl9jaGFuZ2Vk LGV4cG9ydHMpCisKK3F1aWV0X2NtZF9ydXN0Y19wcm9jbWFjcm8gPSAkKFJVU1RDX09SX0NMSVBQ WV9RVUlFVCkgUCAkQAorICAgICAgY21kX3J1c3RjX3Byb2NtYWNybyA9IFwKKwkkKFJVU1RDX09S X0NMSVBQWSkgJChydXN0X2NvbW1vbl9mbGFncykgXAorCQktLWVtaXQ9ZGVwLWluZm8sbGluayAt LWV4dGVybiBwcm9jX21hY3JvIFwKKwkJLS1jcmF0ZS10eXBlIHByb2MtbWFjcm8gLS1vdXQtZGly ICQob2JqdHJlZSkvJChvYmopIFwKKwkJLS1jcmF0ZS1uYW1lICQocGF0c3Vic3QgbGliJS5zbywl LCQobm90ZGlyICRAKSkgJDw7IFwKKwltdiAkKG9ianRyZWUpLyQob2JqKS8kKHBhdHN1YnN0IGxp YiUuc28sJSwkKG5vdGRpciAkQCkpLmQgJChkZXBmaWxlKTsgXAorCXNlZCAtaSAnL15cIy9kJyAk KGRlcGZpbGUpCisKKyMgUHJvY2VkdXJhbCBtYWNyb3MgY2FuIG9ubHkgYmUgdXNlZCB3aXRoIHRo ZSBgcnVzdGNgIHRoYXQgY29tcGlsZWQgaXQuCisjIFRoZXJlZm9yZSwgdG8gZ2V0IGBsaWJtYWNy b3Muc29gIGF1dG9tYXRpY2FsbHkgcmVjb21waWxlZCB3aGVuIHRoZSBjb21waWxlcgorIyB2ZXJz aW9uIGNoYW5nZXMsIHdlIGFkZCBgY29yZS5vYCBhcyBhIGRlcGVuZGVuY3kgKGV2ZW4gaWYgaXQg aXMgbm90IG5lZWRlZCkuCiskKG9iaikvbGlibWFjcm9zLnNvOiAkKHNyYykvbWFjcm9zL2xpYi5y cyAkKG9iaikvY29yZS5vIEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWRfZGVwLHJ1c3RjX3Byb2Nt YWNybykKKworcXVpZXRfY21kX3J1c3RjX2xpYnJhcnkgPSAkKGlmICQoc2tpcF9jbGlwcHkpLFJV U1RDLCQoUlVTVENfT1JfQ0xJUFBZX1FVSUVUKSkgTCAkQAorICAgICAgY21kX3J1c3RjX2xpYnJh cnkgPSBcCisJT0JKVFJFRT0kKGFic3BhdGggJChvYmp0cmVlKSkgXAorCSQoaWYgJChza2lwX2Ns aXBweSksJChSVVNUQyksJChSVVNUQ19PUl9DTElQUFkpKSBcCisJCSQoZmlsdGVyLW91dCAkKHNr aXBfZmxhZ3MpLCQocnVzdF9mbGFncykgJChydXN0Y190YXJnZXRfZmxhZ3MpKSBcCisJCS0tZW1p dD1kZXAtaW5mbyxvYmosbWV0YWRhdGEgLS1jcmF0ZS10eXBlIHJsaWIgXAorCQktLW91dC1kaXIg JChvYmp0cmVlKS8kKG9iaikgLUwkKG9ianRyZWUpLyQob2JqKSBcCisJCS0tY3JhdGUtbmFtZSAk KHBhdHN1YnN0ICUubywlLCQobm90ZGlyICRAKSkgJDw7IFwKKwltdiAkKG9ianRyZWUpLyQob2Jq KS8kKHBhdHN1YnN0ICUubywlLCQobm90ZGlyICRAKSkuZCAkKGRlcGZpbGUpOyBcCisJc2VkIC1p ICcvXlwjL2QnICQoZGVwZmlsZSkgXAorCSQoaWYgJChydXN0Y19vYmpjb3B5KSw7JChPQkpDT1BZ KSAkKHJ1c3RjX29iamNvcHkpICRAKQorCitydXN0LWFuYWx5emVyOgorCSQoUSkkKHNyY3RyZWUp L3NjcmlwdHMvZ2VuZXJhdGVfcnVzdF9hbmFseXplci5weSAkKHNyY3RyZWUpICQob2JqdHJlZSkg XAorCQkkKFJVU1RfTElCX1NSQykgPiAkKG9ianRyZWUpL3J1c3QtcHJvamVjdC5qc29uCisKKyQo b2JqKS9jb3JlLm86IHByaXZhdGUgc2tpcF9jbGlwcHkgPSAxCiskKG9iaikvY29yZS5vOiBwcml2 YXRlIHNraXBfZmxhZ3MgPSAtRHVucmVhY2hhYmxlX3B1YgorJChvYmopL2NvcmUubzogcHJpdmF0 ZSBydXN0Y190YXJnZXRfZmxhZ3MgPSAkKGNvcmUtY2ZncykKKyQob2JqKS9jb3JlLm86ICQoUlVT VF9MSUJfU1JDKS9jb3JlL3NyYy9saWIucnMgJChvYmopL3RhcmdldC5qc29uIEZPUkNFCisJJChj YWxsIGlmX2NoYW5nZWRfZGVwLHJ1c3RjX2xpYnJhcnkpCisKKyQob2JqKS9jb21waWxlcl9idWls dGlucy5vOiBwcml2YXRlIHJ1c3RjX29iamNvcHkgPSAtdyAtVyAnX18qJworJChvYmopL2NvbXBp bGVyX2J1aWx0aW5zLm86ICQoc3JjKS9jb21waWxlcl9idWlsdGlucy5ycyAkKG9iaikvY29yZS5v IEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWRfZGVwLHJ1c3RjX2xpYnJhcnkpCisKKyQob2JqKS9h bGxvYy5vOiBwcml2YXRlIHNraXBfY2xpcHB5ID0gMQorJChvYmopL2FsbG9jLm86IHByaXZhdGUg c2tpcF9mbGFncyA9IC1EdW5yZWFjaGFibGVfcHViCiskKG9iaikvYWxsb2MubzogcHJpdmF0ZSBy dXN0Y190YXJnZXRfZmxhZ3MgPSAkKGFsbG9jLWNmZ3MpCiskKG9iaikvYWxsb2MubzogJChzcmMp L2FsbG9jL2xpYi5ycyAkKG9iaikvY29tcGlsZXJfYnVpbHRpbnMubyBGT1JDRQorCSQoY2FsbCBp Zl9jaGFuZ2VkX2RlcCxydXN0Y19saWJyYXJ5KQorCiskKG9iaikvYnVpbGRfZXJyb3IubzogJChz cmMpL2J1aWxkX2Vycm9yLnJzICQob2JqKS9jb21waWxlcl9idWlsdGlucy5vIEZPUkNFCisJJChj YWxsIGlmX2NoYW5nZWRfZGVwLHJ1c3RjX2xpYnJhcnkpCisKKyQob2JqKS9iaW5kaW5ncy5vOiAk KHNyYykvYmluZGluZ3MvbGliLnJzIFwKKyAgICAkKG9iaikvY29tcGlsZXJfYnVpbHRpbnMubyBc CisgICAgJChvYmopL2JpbmRpbmdzL2JpbmRpbmdzX2dlbmVyYXRlZC5ycyBcCisgICAgJChvYmop L2JpbmRpbmdzL2JpbmRpbmdzX2hlbHBlcnNfZ2VuZXJhdGVkLnJzIEZPUkNFCisJJChjYWxsIGlm X2NoYW5nZWRfZGVwLHJ1c3RjX2xpYnJhcnkpCisKKyQob2JqKS9rZXJuZWwubzogcHJpdmF0ZSBy dXN0Y190YXJnZXRfZmxhZ3MgPSAtLWV4dGVybiBhbGxvYyBcCisgICAgLS1leHRlcm4gYnVpbGRf ZXJyb3IgLS1leHRlcm4gbWFjcm9zIC0tZXh0ZXJuIGJpbmRpbmdzCiskKG9iaikva2VybmVsLm86 ICQoc3JjKS9rZXJuZWwvbGliLnJzICQob2JqKS9hbGxvYy5vICQob2JqKS9idWlsZF9lcnJvci5v IFwKKyAgICAkKG9iaikvbGlibWFjcm9zLnNvICQob2JqKS9iaW5kaW5ncy5vIEZPUkNFCisJJChj YWxsIGlmX2NoYW5nZWRfZGVwLHJ1c3RjX2xpYnJhcnkpCisKK2VuZGlmICMgQ09ORklHX1JVU1QK ZGlmZiAtLWdpdCBhL3J1c3QvYmluZGdlbl9wYXJhbWV0ZXJzIGIvcnVzdC9iaW5kZ2VuX3BhcmFt ZXRlcnMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5iZTQ5NjNiZjcy MDMKLS0tIC9kZXYvbnVsbAorKysgYi9ydXN0L2JpbmRnZW5fcGFyYW1ldGVycwpAQCAtMCwwICsx LDIxIEBACisjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisKKy0tb3BhcXVlLXR5 cGUgeHJlZ3Nfc3RhdGUKKy0tb3BhcXVlLXR5cGUgZGVzY19zdHJ1Y3QKKy0tb3BhcXVlLXR5cGUg YXJjaF9sYnJfc3RhdGUKKy0tb3BhcXVlLXR5cGUgbG9jYWxfYXBpYworCisjIFBhY2tlZCB0eXBl IGNhbm5vdCB0cmFuc2l0aXZlbHkgY29udGFpbiBhIGAjW3JlcHIoYWxpZ24pXWAgdHlwZS4KKy0t b3BhcXVlLXR5cGUgeDg2X21zaV9kYXRhCistLW9wYXF1ZS10eXBlIHg4Nl9tc2lfYWRkcl9sbwor CisjIGB0cnlgIGlzIGEgcmVzZXJ2ZWQga2V5d29yZCBzaW5jZSBSdXN0IDIwMTg7IHNvbHZlZCBp biBgYmluZGdlbmAgdjAuNTkuMiwKKyMgY29tbWl0IDJhZWQ2YjAyMTY4MCAoImNvbnRleHQ6IEVz Y2FwZSB0aGUgdHJ5IGtleXdvcmQgcHJvcGVybHkiKS4KKy0tb3BhcXVlLXR5cGUga3VuaXRfdHJ5 X2NhdGNoCisKKyMgSWYgU01QIGlzIGRpc2FibGVkLCBgYXJjaF9zcGlubG9ja190YCBpcyBkZWZp bmVkIGFzIGEgWlNUIHdoaWNoIHRyaWdnZXJzIGEgUnVzdAorIyB3YXJuaW5nLiBXZSBkb24ndCBu ZWVkIHRvIHBlZWsgaW50byBpdCBhbnl3YXkuCistLW9wYXF1ZS10eXBlIHNwaW5sb2NrCisKKyMg YHNlY2NvbXBgJ3MgY29tbWVudCBnZXRzIHVuZGVyc3Rvb2QgYXMgYSBkb2N0ZXN0CistLW5vLWRv Yy1jb21tZW50cwpkaWZmIC0tZ2l0IGEvc2NyaXB0cy8uZ2l0aWdub3JlIGIvc2NyaXB0cy8uZ2l0 aWdub3JlCmluZGV4IGVlZDMwOGJlZjYwNC4uYjdhZWM4ZWIxYmQ0IDEwMDY0NAotLS0gYS9zY3Jp cHRzLy5naXRpZ25vcmUKKysrIGIvc2NyaXB0cy8uZ2l0aWdub3JlCkBAIC0xLDYgKzEsNyBAQAog IyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5CiAvYXNuMV9jb21waWxlcgog L2JpbjJjCisvZ2VuZXJhdGVfcnVzdF90YXJnZXQKIC9pbnNlcnQtc3lzLWNlcnQKIC9rYWxsc3lt cwogL21vZHVsZS5sZHMKZGlmZiAtLWdpdCBhL3NjcmlwdHMvS2NvbmZpZy5pbmNsdWRlIGIvc2Ny aXB0cy9LY29uZmlnLmluY2x1ZGUKaW5kZXggMDQ5NmVmZDZlMTE3Li44M2U4NTAzMjFlYjYgMTAw NjQ0Ci0tLSBhL3NjcmlwdHMvS2NvbmZpZy5pbmNsdWRlCisrKyBiL3NjcmlwdHMvS2NvbmZpZy5p bmNsdWRlCkBAIC0zNiwxMiArMzYsMTIgQEAgbGQtb3B0aW9uID0gJChzdWNjZXNzLCQoTEQpIC12 ICQoMSkpCiBhcy1pbnN0ciA9ICQoc3VjY2VzcyxwcmludGYgIiViXG4iICIkKDEpIiB8ICQoQ0Mp ICQoQ0xBTkdfRkxBR1MpIC1jIC14IGFzc2VtYmxlciAtbyAvZGV2L251bGwgLSkKIAogIyBjaGVj ayBpZiAkKENDKSBhbmQgJChMRCkgZXhpc3QKLSQoZXJyb3ItaWYsJChmYWlsdXJlLGNvbW1hbmQg LXYgJChDQykpLGNvbXBpbGVyICckKENDKScgbm90IGZvdW5kKQorJChlcnJvci1pZiwkKGZhaWx1 cmUsY29tbWFuZCAtdiAkKENDKSksQyBjb21waWxlciAnJChDQyknIG5vdCBmb3VuZCkKICQoZXJy b3ItaWYsJChmYWlsdXJlLGNvbW1hbmQgLXYgJChMRCkpLGxpbmtlciAnJChMRCknIG5vdCBmb3Vu ZCkKIAotIyBHZXQgdGhlIGNvbXBpbGVyIG5hbWUsIHZlcnNpb24sIGFuZCBlcnJvciBvdXQgaWYg aXQgaXMgbm90IHN1cHBvcnRlZC4KKyMgR2V0IHRoZSBDIGNvbXBpbGVyIG5hbWUsIHZlcnNpb24s IGFuZCBlcnJvciBvdXQgaWYgaXQgaXMgbm90IHN1cHBvcnRlZC4KIGNjLWluZm8gOj0gJChzaGVs bCwkKHNyY3RyZWUpL3NjcmlwdHMvY2MtdmVyc2lvbi5zaCAkKENDKSkKLSQoZXJyb3ItaWYsJChz dWNjZXNzLHRlc3QgLXogIiQoY2MtaW5mbykiKSxTb3JyeSQoY29tbWEpIHRoaXMgY29tcGlsZXIg aXMgbm90IHN1cHBvcnRlZC4pCiskKGVycm9yLWlmLCQoc3VjY2Vzcyx0ZXN0IC16ICIkKGNjLWlu Zm8pIiksU29ycnkkKGNvbW1hKSB0aGlzIEMgY29tcGlsZXIgaXMgbm90IHN1cHBvcnRlZC4pCiBj Yy1uYW1lIDo9ICQoc2hlbGwsc2V0IC0tICQoY2MtaW5mbykgJiYgZWNobyAkMSkKIGNjLXZlcnNp b24gOj0gJChzaGVsbCxzZXQgLS0gJChjYy1pbmZvKSAmJiBlY2hvICQyKQogCmRpZmYgLS1naXQg YS9zY3JpcHRzL01ha2VmaWxlIGIvc2NyaXB0cy9NYWtlZmlsZQppbmRleCBmMDg0ZjA4ZWQxNzYu LjE1NzVhZjg0ZDU1NyAxMDA2NDQKLS0tIGEvc2NyaXB0cy9NYWtlZmlsZQorKysgYi9zY3JpcHRz L01ha2VmaWxlCkBAIC0xMCw2ICsxMCw5IEBAIGhvc3Rwcm9ncy1hbHdheXMtJChDT05GSUdfQlVJ TERUSU1FX1RBQkxFX1NPUlQpCQkrPSBzb3J0dGFibGUKIGhvc3Rwcm9ncy1hbHdheXMtJChDT05G SUdfQVNOMSkJCQkJKz0gYXNuMV9jb21waWxlcgogaG9zdHByb2dzLWFsd2F5cy0kKENPTkZJR19N T0RVTEVfU0lHX0ZPUk1BVCkJCSs9IHNpZ24tZmlsZQogaG9zdHByb2dzLWFsd2F5cy0kKENPTkZJ R19TWVNURU1fRVhUUkFfQ0VSVElGSUNBVEUpCSs9IGluc2VydC1zeXMtY2VydAoraG9zdHByb2dz LWFsd2F5cy0kKENPTkZJR19SVVNUKQkJCQkrPSBnZW5lcmF0ZV9ydXN0X3RhcmdldAorCitnZW5l cmF0ZV9ydXN0X3RhcmdldC1ydXN0IDo9IHkKIAogSE9TVENGTEFHU19zb3J0dGFibGUubyA9IC1J JChzcmN0cmVlKS90b29scy9pbmNsdWRlCiBIT1NUTERMSUJTX3NvcnR0YWJsZSA9IC1scHRocmVh ZApkaWZmIC0tZ2l0IGEvc2NyaXB0cy9NYWtlZmlsZS5idWlsZCBiL3NjcmlwdHMvTWFrZWZpbGUu YnVpbGQKaW5kZXggY2FjMDcwYWVlNzkxLi41YzQ5NTcxM2YxYjEgMTAwNjQ0Ci0tLSBhL3Njcmlw dHMvTWFrZWZpbGUuYnVpbGQKKysrIGIvc2NyaXB0cy9NYWtlZmlsZS5idWlsZApAQCAtMjYsNiAr MjYsNyBAQCBFWFRSQV9DUFBGTEFHUyA6PQogRVhUUkFfTERGTEFHUyAgOj0KIGFzZmxhZ3MteSAg Oj0KIGNjZmxhZ3MteSAgOj0KK3J1c3RmbGFncy15IDo9CiBjcHBmbGFncy15IDo9CiBsZGZsYWdz LXkgIDo9CiAKQEAgLTI3MSw2ICsyNzIsNjUgQEAgcXVpZXRfY21kX2NjX2xzdF9jID0gTUtMU1Qg ICAkQAogJChvYmopLyUubHN0OiAkKHNyYykvJS5jIEZPUkNFCiAJJChjYWxsIGlmX2NoYW5nZWRf ZGVwLGNjX2xzdF9jKQogCisjIENvbXBpbGUgUnVzdCBzb3VyY2VzICgucnMpCisjIC0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLQorCitydXN0X2FsbG93ZWRfZmVhdHVyZXMgOj0gYWxsb2NhdG9yX2FwaSxiZW5j aF9ibGFja19ib3gsY29yZV9mZmlfYyxnZW5lcmljX2Fzc29jaWF0ZWRfdHlwZXMsY29uc3RfcHRy X29mZnNldF9mcm9tLGNvbnN0X3JlZnNfdG9fY2VsbAorCitydXN0X2NvbW1vbl9jbWQgPSBcCisJ UlVTVF9NT0RGSUxFPSQobW9kZmlsZSkgJChSVVNUQ19PUl9DTElQUFkpICQocnVzdF9mbGFncykg XAorCS1aYWxsb3ctZmVhdHVyZXM9JChydXN0X2FsbG93ZWRfZmVhdHVyZXMpIFwKKwktWmNyYXRl LWF0dHI9bm9fc3RkIFwKKwktWmNyYXRlLWF0dHI9J2ZlYXR1cmUoJChydXN0X2FsbG93ZWRfZmVh dHVyZXMpKScgXAorCS0tZXh0ZXJuIGFsbG9jIC0tZXh0ZXJuIGtlcm5lbCBcCisJLS1jcmF0ZS10 eXBlIHJsaWIgLS1vdXQtZGlyICQob2JqKSAtTCAkKG9ianRyZWUpL3J1c3QvIFwKKwktLWNyYXRl LW5hbWUgJChiYXNlbmFtZSAkKG5vdGRpciAkQCkpCisKK3J1c3RfaGFuZGxlX2RlcGZpbGUgPSBc CisJbXYgJChvYmopLyQoYmFzZW5hbWUgJChub3RkaXIgJEApKS5kICQoZGVwZmlsZSk7IFwKKwlz ZWQgLWkgJy9eXCMvZCcgJChkZXBmaWxlKQorCisjIGAtLWVtaXQ9b2JqYCwgYC0tZW1pdD1hc21g IGFuZCBgLS1lbWl0PWxsdm0taXJgIGltcGx5IGEgc2luZ2xlIGNvZGVnZW4gdW5pdAorIyB3aWxs IGJlIHVzZWQuIFdlIGV4cGxpY2l0bHkgcmVxdWVzdCBgLUNjb2RlZ2VuLXVuaXRzPTFgIGluIGFu eSBjYXNlLCBhbmQKKyMgdGhlIGNvbXBpbGVyIHNob3dzIGEgd2FybmluZyBpZiBpdCBpcyBub3Qg MS4gSG93ZXZlciwgaWYgd2UgZXZlciBzdG9wCisjIHJlcXVlc3RpbmcgaXQgZXhwbGljaXRseSBh bmQgd2Ugc3RhcnQgdXNpbmcgc29tZSBvdGhlciBgLS1lbWl0YCB0aGF0IGRvZXMgbm90CisjIGlt cGx5IGl0IChhbmQgZm9yIHdoaWNoIGNvZGVnZW4gaXMgcGVyZm9ybWVkKSwgdGhlbiB3ZSB3b3Vs ZCBiZSBvdXQgb2Ygc3luYywKKyMgaS5lLiB0aGUgb3V0cHV0cyB3ZSB3b3VsZCBnZXQgZm9yIHRo ZSBkaWZmZXJlbnQgc2luZ2xlIHRhcmdldHMgKGUuZy4gYC5sbGApCisjIHdvdWxkIG5vdCBtYXRj aCBlYWNoIG90aGVyLgorCitxdWlldF9jbWRfcnVzdGNfb19ycyA9ICQoUlVTVENfT1JfQ0xJUFBZ X1FVSUVUKSAkKHF1aWV0X21vZHRhZykgJEAKKyAgICAgIGNtZF9ydXN0Y19vX3JzID0gXAorCSQo cnVzdF9jb21tb25fY21kKSAtLWVtaXQ9ZGVwLWluZm8sb2JqICQ8OyBcCisJJChydXN0X2hhbmRs ZV9kZXBmaWxlKQorCiskKG9iaikvJS5vOiAkKHNyYykvJS5ycyBGT1JDRQorCSQoY2FsbCBpZl9j aGFuZ2VkX2RlcCxydXN0Y19vX3JzKQorCitxdWlldF9jbWRfcnVzdGNfcnNpX3JzID0gJChSVVNU Q19PUl9DTElQUFlfUVVJRVQpICQocXVpZXRfbW9kdGFnKSAkQAorICAgICAgY21kX3J1c3RjX3Jz aV9ycyA9IFwKKwkkKHJ1c3RfY29tbW9uX2NtZCkgLS1lbWl0PWRlcC1pbmZvIC1adW5wcmV0dHk9 ZXhwYW5kZWQgJDwgPiRAOyBcCisJY29tbWFuZCAtdiAkKFJVU1RGTVQpID4vZGV2L251bGwgJiYg JChSVVNURk1UKSAkQDsgXAorCSQocnVzdF9oYW5kbGVfZGVwZmlsZSkKKworJChvYmopLyUucnNp OiAkKHNyYykvJS5ycyBGT1JDRQorCSQoY2FsbCBpZl9jaGFuZ2VkX2RlcCxydXN0Y19yc2lfcnMp CisKK3F1aWV0X2NtZF9ydXN0Y19zX3JzID0gJChSVVNUQ19PUl9DTElQUFlfUVVJRVQpICQocXVp ZXRfbW9kdGFnKSAkQAorICAgICAgY21kX3J1c3RjX3NfcnMgPSBcCisJJChydXN0X2NvbW1vbl9j bWQpIC0tZW1pdD1kZXAtaW5mbyxhc20gJDw7IFwKKwkkKHJ1c3RfaGFuZGxlX2RlcGZpbGUpCisK KyQob2JqKS8lLnM6ICQoc3JjKS8lLnJzIEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWRfZGVwLHJ1 c3RjX3NfcnMpCisKK3F1aWV0X2NtZF9ydXN0Y19sbF9ycyA9ICQoUlVTVENfT1JfQ0xJUFBZX1FV SUVUKSAkKHF1aWV0X21vZHRhZykgJEAKKyAgICAgIGNtZF9ydXN0Y19sbF9ycyA9IFwKKwkkKHJ1 c3RfY29tbW9uX2NtZCkgLS1lbWl0PWRlcC1pbmZvLGxsdm0taXIgJDw7IFwKKwkkKHJ1c3RfaGFu ZGxlX2RlcGZpbGUpCisKKyQob2JqKS8lLmxsOiAkKHNyYykvJS5ycyBGT1JDRQorCSQoY2FsbCBp Zl9jaGFuZ2VkX2RlcCxydXN0Y19sbF9ycykKKwogIyBDb21waWxlIGFzc2VtYmxlciBzb3VyY2Vz ICguUykKICMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKZGlmZiAtLWdpdCBhL3NjcmlwdHMvTWFrZWZp bGUuZGVidWcgYi9zY3JpcHRzL01ha2VmaWxlLmRlYnVnCmluZGV4IDlmMzliMDEzMDU1MS4uZmU4 NzM4OWQ1MmMwIDEwMDY0NAotLS0gYS9zY3JpcHRzL01ha2VmaWxlLmRlYnVnCisrKyBiL3Njcmlw dHMvTWFrZWZpbGUuZGVidWcKQEAgLTEsNCArMSw1IEBACiBERUJVR19DRkxBR1MJOj0KK0RFQlVH X1JVU1RGTEFHUwk6PQogCiBpZmRlZiBDT05GSUdfREVCVUdfSU5GT19TUExJVAogREVCVUdfQ0ZM QUdTCSs9IC1nc3BsaXQtZHdhcmYKQEAgLTEwLDYgKzExLDEyIEBAIGlmbmRlZiBDT05GSUdfQVNf SVNfTExWTQogS0JVSUxEX0FGTEFHUwkrPSAtV2EsLWdkd2FyZi0yCiBlbmRpZgogCitpZmRlZiBD T05GSUdfREVCVUdfSU5GT19SRURVQ0VECitERUJVR19SVVNURkxBR1MgKz0gLUNkZWJ1Z2luZm89 MQorZWxzZQorREVCVUdfUlVTVEZMQUdTICs9IC1DZGVidWdpbmZvPTIKK2VuZGlmCisKIGlmbmRl ZiBDT05GSUdfREVCVUdfSU5GT19EV0FSRl9UT09MQ0hBSU5fREVGQVVMVAogZHdhcmYtdmVyc2lv bi0kKENPTkZJR19ERUJVR19JTkZPX0RXQVJGNCkgOj0gNAogZHdhcmYtdmVyc2lvbi0kKENPTkZJ R19ERUJVR19JTkZPX0RXQVJGNSkgOj0gNQpAQCAtMzEsMyArMzgsNiBAQCBlbmRpZgogCiBLQlVJ TERfQ0ZMQUdTICs9ICQoREVCVUdfQ0ZMQUdTKQogZXhwb3J0IERFQlVHX0NGTEFHUworCitLQlVJ TERfUlVTVEZMQUdTICs9ICQoREVCVUdfUlVTVEZMQUdTKQorZXhwb3J0IERFQlVHX1JVU1RGTEFH UwpkaWZmIC0tZ2l0IGEvc2NyaXB0cy9NYWtlZmlsZS5ob3N0IGIvc2NyaXB0cy9NYWtlZmlsZS5o b3N0CmluZGV4IDI3OGI0ZDZhYzk0NS4uZGExMzM3ODBiNzUxIDEwMDY0NAotLS0gYS9zY3JpcHRz L01ha2VmaWxlLmhvc3QKKysrIGIvc2NyaXB0cy9NYWtlZmlsZS5ob3N0CkBAIC0yMiw2ICsyMiw4 IEBAICQob2JqKS8lLnRhYi5jICQob2JqKS8lLnRhYi5oOiAkKHNyYykvJS55IEZPUkNFCiAjIHRv IHByZXByb2Nlc3MgYSBkYXRhIGZpbGUuCiAjCiAjIEJvdGggQyBhbmQgQysrIGFyZSBzdXBwb3J0 ZWQsIGJ1dCBwcmVmZXJyZWQgbGFuZ3VhZ2UgaXMgQyBmb3Igc3VjaCB1dGlsaXRpZXMuCisjIFJ1 c3QgaXMgYWxzbyBzdXBwb3J0ZWQsIGJ1dCBpdCBtYXkgb25seSBiZSB1c2VkIGluIHNjZW5hcmlv cyB3aGVyZSBhIFJ1c3QKKyMgdG9vbGNoYWluIGlzIHJlcXVpcmVkIHRvIGJlIGF2YWlsYWJsZSAo ZS5nLiB3aGVuICBgQ09ORklHX1JVU1RgIGlzIGVuYWJsZWQpLgogIwogIyBTYW1wbGUgc3ludGF4 IChzZWUgRG9jdW1lbnRhdGlvbi9rYnVpbGQvbWFrZWZpbGVzLnJzdCBmb3IgcmVmZXJlbmNlKQog IyBob3N0cHJvZ3MgOj0gYmluMmhleApAQCAtMzcsMTUgKzM5LDIwIEBAICQob2JqKS8lLnRhYi5j ICQob2JqKS8lLnRhYi5oOiAkKHNyYykvJS55IEZPUkNFCiAjIHFjb25mLW9ianMgICAgICA6PSBt ZW51Lm8KICMgV2lsbCBjb21waWxlIHFjb25mIGFzIGEgQysrIHByb2dyYW0sIGFuZCBtZW51IGFz IGEgQyBwcm9ncmFtLgogIyBUaGV5IGFyZSBsaW5rZWQgYXMgQysrIGNvZGUgdG8gdGhlIGV4ZWN1 dGFibGUgcWNvbmYKKyMKKyMgaG9zdHByb2dzICAgOj0gdGFyZ2V0CisjIHRhcmdldC1ydXN0IDo9 IHkKKyMgV2lsbCBjb21waWxlIGB0YXJnZXRgIGFzIGEgUnVzdCBwcm9ncmFtLCB1c2luZyBgdGFy Z2V0LnJzYCBhcyB0aGUgY3JhdGUgcm9vdC4KKyMgVGhlIGNyYXRlIG1heSBjb25zaXN0IG9mIHNl dmVyYWwgc291cmNlIGZpbGVzLgogCiAjIEMgY29kZQogIyBFeGVjdXRhYmxlcyBjb21waWxlZCBm cm9tIGEgc2luZ2xlIC5jIGZpbGUKIGhvc3QtY3NpbmdsZQk6PSAkKGZvcmVhY2ggbSwkKGhvc3Rw cm9ncyksIFwKLQkJCSQoaWYgJCgkKG0pLW9ianMpJCgkKG0pLWN4eG9ianMpLCwkKG0pKSkKKwkJ CSQoaWYgJCgkKG0pLW9ianMpJCgkKG0pLWN4eG9ianMpJCgkKG0pLXJ1c3QpLCwkKG0pKSkKIAog IyBDIGV4ZWN1dGFibGVzIGxpbmtlZCBiYXNlZCBvbiBzZXZlcmFsIC5vIGZpbGVzCiBob3N0LWNt dWx0aQk6PSAkKGZvcmVhY2ggbSwkKGhvc3Rwcm9ncyksXAotCQkgICAkKGlmICQoJChtKS1jeHhv YmpzKSwsJChpZiAkKCQobSktb2JqcyksJChtKSkpKQorCQkgICAkKGlmICQoJChtKS1jeHhvYmpz KSQoJChtKS1ydXN0KSwsJChpZiAkKCQobSktb2JqcyksJChtKSkpKQogCiAjIE9iamVjdCAoLm8p IGZpbGVzIGNvbXBpbGVkIGZyb20gLmMgZmlsZXMKIGhvc3QtY29ianMJOj0gJChzb3J0ICQoZm9y ZWFjaCBtLCQoaG9zdHByb2dzKSwkKCQobSktb2JqcykpKQpAQCAtNTgsMTEgKzY1LDE3IEBAIGhv c3QtY3h4bXVsdGkJOj0gJChmb3JlYWNoIG0sJChob3N0cHJvZ3MpLCQoaWYgJCgkKG0pLWN4eG9i anMpLCQobSkpKQogIyBDKysgT2JqZWN0ICgubykgZmlsZXMgY29tcGlsZWQgZnJvbSAuY2MgZmls ZXMKIGhvc3QtY3h4b2Jqcwk6PSAkKHNvcnQgJChmb3JlYWNoIG0sJChob3N0LWN4eG11bHRpKSwk KCQobSktY3h4b2JqcykpKQogCisjIFJ1c3QgY29kZQorIyBFeGVjdXRhYmxlcyBjb21waWxlZCBm cm9tIGEgc2luZ2xlIFJ1c3QgY3JhdGUgKHdoaWNoIG1heSBjb25zaXN0IG9mCisjIG9uZSBvciBt b3JlIC5ycyBmaWxlcykKK2hvc3QtcnVzdAk6PSAkKGZvcmVhY2ggbSwkKGhvc3Rwcm9ncyksJChp ZiAkKCQobSktcnVzdCksJChtKSkpCisKIGhvc3QtY3NpbmdsZQk6PSAkKGFkZHByZWZpeCAkKG9i aikvLCQoaG9zdC1jc2luZ2xlKSkKIGhvc3QtY211bHRpCTo9ICQoYWRkcHJlZml4ICQob2JqKS8s JChob3N0LWNtdWx0aSkpCiBob3N0LWNvYmpzCTo9ICQoYWRkcHJlZml4ICQob2JqKS8sJChob3N0 LWNvYmpzKSkKIGhvc3QtY3h4bXVsdGkJOj0gJChhZGRwcmVmaXggJChvYmopLywkKGhvc3QtY3h4 bXVsdGkpKQogaG9zdC1jeHhvYmpzCTo9ICQoYWRkcHJlZml4ICQob2JqKS8sJChob3N0LWN4eG9i anMpKQoraG9zdC1ydXN0CTo9ICQoYWRkcHJlZml4ICQob2JqKS8sJChob3N0LXJ1c3QpKQogCiAj IyMjIwogIyBIYW5kbGUgb3B0aW9ucyB0byBnY2MuIFN1cHBvcnQgYnVpbGRpbmcgd2l0aCBzZXBh cmF0ZSBvdXRwdXQgZGlyZWN0b3J5CkBAIC03MSw2ICs4NCw4IEBAIF9ob3N0Y19mbGFncyAgID0g JChLQlVJTERfSE9TVENGTEFHUykgICAkKEhPU1RfRVhUUkFDRkxBR1MpICAgXAogICAgICAgICAg ICAgICAgICAkKEhPU1RDRkxBR1NfJCh0YXJnZXQtc3RlbSkubykKIF9ob3N0Y3h4X2ZsYWdzID0g JChLQlVJTERfSE9TVENYWEZMQUdTKSAkKEhPU1RfRVhUUkFDWFhGTEFHUykgXAogICAgICAgICAg ICAgICAgICAkKEhPU1RDWFhGTEFHU18kKHRhcmdldC1zdGVtKS5vKQorX2hvc3RydXN0X2ZsYWdz ID0gJChLQlVJTERfSE9TVFJVU1RGTEFHUykgJChIT1NUX0VYVFJBUlVTVEZMQUdTKSBcCisgICAg ICAgICAgICAgICAgICAkKEhPU1RSVVNURkxBR1NfJCh0YXJnZXQtc3RlbSkpCiAKICMgJChvYmp0 cmVlKS8kKG9iaikgZm9yIGluY2x1ZGluZyBnZW5lcmF0ZWQgaGVhZGVycyBmcm9tIGNoZWNraW4g c291cmNlIGZpbGVzCiBpZmVxICgkKEtCVUlMRF9FWFRNT0QpLCkKQEAgLTgyLDYgKzk3LDcgQEAg ZW5kaWYKIAogaG9zdGNfZmxhZ3MgICAgPSAtV3AsLU1NRCwkKGRlcGZpbGUpICQoX2hvc3RjX2Zs YWdzKQogaG9zdGN4eF9mbGFncyAgPSAtV3AsLU1NRCwkKGRlcGZpbGUpICQoX2hvc3RjeHhfZmxh Z3MpCitob3N0cnVzdF9mbGFncyA9ICQoX2hvc3RydXN0X2ZsYWdzKQogCiAjIyMjIwogIyBDb21w aWxlIHByb2dyYW1zIG9uIHRoZSBob3N0CkBAIC0xMjgsNSArMTQ0LDE3IEBAIHF1aWV0X2NtZF9o b3N0LWN4eG9ianMJPSBIT1NUQ1hYICRACiAkKGhvc3QtY3h4b2Jqcyk6ICQob2JqKS8lLm86ICQo c3JjKS8lLmNjIEZPUkNFCiAJJChjYWxsIGlmX2NoYW5nZWRfZGVwLGhvc3QtY3h4b2JqcykKIAor IyBDcmVhdGUgZXhlY3V0YWJsZSBmcm9tIGEgc2luZ2xlIFJ1c3QgY3JhdGUgKHdoaWNoIG1heSBj b25zaXN0IG9mCisjIG9uZSBvciBtb3JlIGAucnNgIGZpbGVzKQorIyBob3N0LXJ1c3QgLT4gRXhl Y3V0YWJsZQorcXVpZXRfY21kX2hvc3QtcnVzdAk9IEhPU1RSVVNUQyAkQAorICAgICAgY21kX2hv c3QtcnVzdAk9IFwKKwkkKEhPU1RSVVNUQykgJChob3N0cnVzdF9mbGFncykgLS1lbWl0PWRlcC1p bmZvLGxpbmsgXAorCQktLW91dC1kaXI9JChvYmopLyAkPDsgXAorCW12ICQob2JqKS8kKHRhcmdl dC1zdGVtKS5kICQoZGVwZmlsZSk7IFwKKwlzZWQgLWkgJy9eXCMvZCcgJChkZXBmaWxlKQorJCho b3N0LXJ1c3QpOiAkKG9iaikvJTogJChzcmMpLyUucnMgRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdl ZF9kZXAsaG9zdC1ydXN0KQorCiB0YXJnZXRzICs9ICQoaG9zdC1jc2luZ2xlKSAkKGhvc3QtY211 bHRpKSAkKGhvc3QtY29ianMpIFwKLQkgICAkKGhvc3QtY3h4bXVsdGkpICQoaG9zdC1jeHhvYmpz KQorCSAgICQoaG9zdC1jeHhtdWx0aSkgJChob3N0LWN4eG9ianMpICQoaG9zdC1ydXN0KQpkaWZm IC0tZ2l0IGEvc2NyaXB0cy9NYWtlZmlsZS5saWIgYi9zY3JpcHRzL01ha2VmaWxlLmxpYgppbmRl eCAzZmI2YTk5ZTc4YzQuLmM4OGI5OGI1ZGM0NCAxMDA2NDQKLS0tIGEvc2NyaXB0cy9NYWtlZmls ZS5saWIKKysrIGIvc2NyaXB0cy9NYWtlZmlsZS5saWIKQEAgLTgsNiArOCw3IEBAIGxkZmxhZ3Mt eSAgKz0gJChFWFRSQV9MREZMQUdTKQogIyBmbGFncyB0aGF0IHRha2UgZWZmZWN0IGluIGN1cnJl bnQgYW5kIHN1YiBkaXJlY3RvcmllcwogS0JVSUxEX0FGTEFHUyArPSAkKHN1YmRpci1hc2ZsYWdz LXkpCiBLQlVJTERfQ0ZMQUdTICs9ICQoc3ViZGlyLWNjZmxhZ3MteSkKK0tCVUlMRF9SVVNURkxB R1MgKz0gJChzdWJkaXItcnVzdGZsYWdzLXkpCiAKICMgRmlndXJlIG91dCB3aGF0IHdlIG5lZWQg dG8gYnVpbGQgZnJvbSB0aGUgdmFyaW91cyB2YXJpYWJsZXMKICMgPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 CkBAIC0xMjgsNiArMTI5LDEwIEBAIF9jX2ZsYWdzICAgICAgID0gJChmaWx0ZXItb3V0ICQoQ0ZM QUdTX1JFTU9WRV8kKHRhcmdldC1zdGVtKS5vKSwgXAogICAgICAgICAgICAgICAgICAgICAgJChm aWx0ZXItb3V0ICQoY2NmbGFncy1yZW1vdmUteSksIFwKICAgICAgICAgICAgICAgICAgICAgICAg ICAkKEtCVUlMRF9DUFBGTEFHUykgJChLQlVJTERfQ0ZMQUdTKSAkKGNjZmxhZ3MteSkpIFwKICAg ICAgICAgICAgICAgICAgICAgICQoQ0ZMQUdTXyQodGFyZ2V0LXN0ZW0pLm8pKQorX3J1c3RfZmxh Z3MgICAgPSAkKGZpbHRlci1vdXQgJChSVVNURkxBR1NfUkVNT1ZFXyQodGFyZ2V0LXN0ZW0pLm8p LCBcCisgICAgICAgICAgICAgICAgICAgICAkKGZpbHRlci1vdXQgJChydXN0ZmxhZ3MtcmVtb3Zl LXkpLCBcCisgICAgICAgICAgICAgICAgICAgICAgICAgJChLQlVJTERfUlVTVEZMQUdTKSAkKHJ1 c3RmbGFncy15KSkgXAorICAgICAgICAgICAgICAgICAgICAgJChSVVNURkxBR1NfJCh0YXJnZXQt c3RlbSkubykpCiBfYV9mbGFncyAgICAgICA9ICQoZmlsdGVyLW91dCAkKEFGTEFHU19SRU1PVkVf JCh0YXJnZXQtc3RlbSkubyksIFwKICAgICAgICAgICAgICAgICAgICAgICQoZmlsdGVyLW91dCAk KGFzZmxhZ3MtcmVtb3ZlLXkpLCBcCiAgICAgICAgICAgICAgICAgICAgICAgICAgJChLQlVJTERf Q1BQRkxBR1MpICQoS0JVSUxEX0FGTEFHUykgJChhc2ZsYWdzLXkpKSBcCkBAIC0yMDIsNiArMjA3 LDExIEBAIG1vZGtlcm5fY2ZsYWdzID0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBcCiAJCSQoS0JVSUxEX0NGTEFHU19NT0RVTEUpICQoQ0ZMQUdTX01PRFVMRSksIFwK IAkJJChLQlVJTERfQ0ZMQUdTX0tFUk5FTCkgJChDRkxBR1NfS0VSTkVMKSAkKG1vZGZpbGVfZmxh Z3MpKQogCittb2RrZXJuX3J1c3RmbGFncyA9ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFwKKwkkKGlmICQocGFydC1vZi1tb2R1bGUpLCAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgXAorCQkkKEtCVUlMRF9SVVNURkxBR1NfTU9EVUxFKSAkKFJV U1RGTEFHU19NT0RVTEUpLCBcCisJCSQoS0JVSUxEX1JVU1RGTEFHU19LRVJORUwpICQoUlVTVEZM QUdTX0tFUk5FTCkpCisKIG1vZGtlcm5fYWZsYWdzID0gJChpZiAkKHBhcnQtb2YtbW9kdWxlKSwJ CQkJXAogCQkJJChLQlVJTERfQUZMQUdTX01PRFVMRSkgJChBRkxBR1NfTU9EVUxFKSwJXAogCQkJ JChLQlVJTERfQUZMQUdTX0tFUk5FTCkgJChBRkxBR1NfS0VSTkVMKSkKQEAgLTIxMSw2ICsyMjEs OCBAQCBjX2ZsYWdzICAgICAgICA9IC1XcCwtTU1ELCQoZGVwZmlsZSkgJChOT1NURElOQ19GTEFH UykgJChMSU5VWElOQ0xVREUpICAgICBcCiAJCSAkKF9jX2ZsYWdzKSAkKG1vZGtlcm5fY2ZsYWdz KSAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKIAkJICQoYmFzZW5hbWVfZmxhZ3MpICQobW9k bmFtZV9mbGFncykKIAorcnVzdF9mbGFncyAgICAgPSAkKF9ydXN0X2ZsYWdzKSAkKG1vZGtlcm5f cnVzdGZsYWdzKSBAJChvYmp0cmVlKS9pbmNsdWRlL2dlbmVyYXRlZC9ydXN0Y19jZmcKKwogYV9m bGFncyAgICAgICAgPSAtV3AsLU1NRCwkKGRlcGZpbGUpICQoTk9TVERJTkNfRkxBR1MpICQoTElO VVhJTkNMVURFKSAgICAgXAogCQkgJChfYV9mbGFncykgJChtb2RrZXJuX2FmbGFncykKIApkaWZm IC0tZ2l0IGEvc2NyaXB0cy9NYWtlZmlsZS5tb2RmaW5hbCBiL3NjcmlwdHMvTWFrZWZpbGUubW9k ZmluYWwKaW5kZXggMzUxMDBlOTgxZjRhLi45YTFmYTZhYTMwZmUgMTAwNjQ0Ci0tLSBhL3Njcmlw dHMvTWFrZWZpbGUubW9kZmluYWwKKysrIGIvc2NyaXB0cy9NYWtlZmlsZS5tb2RmaW5hbApAQCAt MzksMTEgKzM5LDEzIEBAIHF1aWV0X2NtZF9sZF9rb19vID0gTEQgW01dICAkQAogCiBxdWlldF9j bWRfYnRmX2tvID0gQlRGIFtNXSAkQAogICAgICAgY21kX2J0Zl9rbyA9IAkJCQkJCQlcCi0JaWYg WyAtZiB2bWxpbnV4IF07IHRoZW4JCQkJCQlcCisJaWYgWyAhIC1mIHZtbGludXggXTsgdGhlbgkJ CQkJXAorCQlwcmludGYgIlNraXBwaW5nIEJURiBnZW5lcmF0aW9uIGZvciAlcyBkdWUgdG8gdW5h dmFpbGFiaWxpdHkgb2Ygdm1saW51eFxuIiAkQCAxPiYyOyBcCisJZWxpZiBbIC1uICIkKENPTkZJ R19SVVNUKSIgXSAmJiAkKHNyY3RyZWUpL3NjcmlwdHMvaXNfcnVzdF9tb2R1bGUuc2ggJEA7IHRo ZW4gCQlcCisJCXByaW50ZiAiU2tpcHBpbmcgQlRGIGdlbmVyYXRpb24gZm9yICVzIGJlY2F1c2Ug aXQncyBhIFJ1c3QgbW9kdWxlXG4iICRAIDE+JjI7IFwKKwllbHNlCQkJCQkJCQlcCiAJCUxMVk1f T0JKQ09QWT0iJChPQkpDT1BZKSIgJChQQUhPTEUpIC1KICQoUEFIT0xFX0ZMQUdTKSAtLWJ0Zl9i YXNlIHZtbGludXggJEA7IFwKIAkJJChSRVNPTFZFX0JURklEUykgLWIgdm1saW51eCAkQDsgCQkJ XAotCWVsc2UJCQkJCQkJCVwKLQkJcHJpbnRmICJTa2lwcGluZyBCVEYgZ2VuZXJhdGlvbiBmb3Ig JXMgZHVlIHRvIHVuYXZhaWxhYmlsaXR5IG9mIHZtbGludXhcbiIgJEAgMT4mMjsgXAogCWZpOwog CiAjIFNhbWUgYXMgbmV3ZXItcHJlcmVxcywgYnV0IGFsbG93cyB0byBleGNsdWRlIHNwZWNpZmll ZCBleHRyYSBkZXBlbmRlbmNpZXMKZGlmZiAtLWdpdCBhL3NjcmlwdHMvY2MtdmVyc2lvbi5zaCBi L3NjcmlwdHMvY2MtdmVyc2lvbi5zaAppbmRleCBmMTk1MmM1MjI0NjYuLjI0MDFjODZmY2Y1MyAx MDA3NTUKLS0tIGEvc2NyaXB0cy9jYy12ZXJzaW9uLnNoCisrKyBiL3NjcmlwdHMvY2MtdmVyc2lv bi5zaApAQCAtMSwxMyArMSwxMyBAQAogIyEvYmluL3NoCiAjIFNQRFgtTGljZW5zZS1JZGVudGlm aWVyOiBHUEwtMi4wCiAjCi0jIFByaW50IHRoZSBjb21waWxlciBuYW1lIGFuZCBpdHMgdmVyc2lv biBpbiBhIDUgb3IgNi1kaWdpdCBmb3JtLgorIyBQcmludCB0aGUgQyBjb21waWxlciBuYW1lIGFu ZCBpdHMgdmVyc2lvbiBpbiBhIDUgb3IgNi1kaWdpdCBmb3JtLgogIyBBbHNvLCBwZXJmb3JtIHRo ZSBtaW5pbXVtIHZlcnNpb24gY2hlY2suCiAKIHNldCAtZQogCi0jIFByaW50IHRoZSBjb21waWxl ciBuYW1lIGFuZCBzb21lIHZlcnNpb24gY29tcG9uZW50cy4KLWdldF9jb21waWxlcl9pbmZvKCkK KyMgUHJpbnQgdGhlIEMgY29tcGlsZXIgbmFtZSBhbmQgc29tZSB2ZXJzaW9uIGNvbXBvbmVudHMu CitnZXRfY19jb21waWxlcl9pbmZvKCkKIHsKIAljYXQgPDwtIEVPRiB8ICIkQCIgLUUgLVAgLXgg YyAtIDI+L2Rldi9udWxsCiAJI2lmIGRlZmluZWQoX19jbGFuZ19fKQpAQCAtMzIsNyArMzIsNyBA QCBnZXRfY2Fub25pY2FsX3ZlcnNpb24oKQogCiAjICRAIGluc3RlYWQgb2YgJDEgYmVjYXVzZSBt dWx0aXBsZSB3b3JkcyBtaWdodCBiZSBnaXZlbiwgZS5nLiBDQz0iY2NhY2hlIGdjYyIuCiBvcmln X2FyZ3M9IiRAIgotc2V0IC0tICQoZ2V0X2NvbXBpbGVyX2luZm8gIiRAIikKK3NldCAtLSAkKGdl dF9jX2NvbXBpbGVyX2luZm8gIiRAIikKIAogbmFtZT0kMQogCkBAIC01Miw3ICs1Miw3IEBAIElD QykKIAltaW5fdmVyc2lvbj0kKCRtaW5fdG9vbF92ZXJzaW9uIGljYykKIAk7OwogKikKLQllY2hv ICIkb3JpZ19hcmdzOiB1bmtub3duIGNvbXBpbGVyIiA+JjIKKwllY2hvICIkb3JpZ19hcmdzOiB1 bmtub3duIEMgY29tcGlsZXIiID4mMgogCWV4aXQgMQogCTs7CiBlc2FjCkBAIC02Miw3ICs2Miw3 IEBAIG1pbl9jdmVyc2lvbj0kKGdldF9jYW5vbmljYWxfdmVyc2lvbiAkbWluX3ZlcnNpb24pCiAK IGlmIFsgIiRjdmVyc2lvbiIgLWx0ICIkbWluX2N2ZXJzaW9uIiBdOyB0aGVuCiAJZWNobyA+JjIg IioqKiIKLQllY2hvID4mMiAiKioqIENvbXBpbGVyIGlzIHRvbyBvbGQuIgorCWVjaG8gPiYyICIq KiogQyBjb21waWxlciBpcyB0b28gb2xkLiIKIAllY2hvID4mMiAiKioqICAgWW91ciAkbmFtZSB2 ZXJzaW9uOiAgICAkdmVyc2lvbiIKIAllY2hvID4mMiAiKioqICAgTWluaW11bSAkbmFtZSB2ZXJz aW9uOiAkbWluX3ZlcnNpb24iCiAJZWNobyA+JjIgIioqKiIKZGlmZiAtLWdpdCBhL3NjcmlwdHMv Z2VuZXJhdGVfcnVzdF90YXJnZXQucnMgYi9zY3JpcHRzL2dlbmVyYXRlX3J1c3RfdGFyZ2V0LnJz Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMGExYmE5NWQ3NGU3Ci0t LSAvZGV2L251bGwKKysrIGIvc2NyaXB0cy9nZW5lcmF0ZV9ydXN0X3RhcmdldC5ycwpAQCAtMCww ICsxLDIzMiBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKworLy8hIFRo ZSBjdXN0b20gdGFyZ2V0IHNwZWNpZmljYXRpb24gZmlsZSBnZW5lcmF0b3IgZm9yIGBydXN0Y2Au CisvLyEKKy8vISBUbyBjb25maWd1cmUgYSB0YXJnZXQgZnJvbSBzY3JhdGNoLCBhIEpTT04tZW5j b2RlZCBmaWxlIGhhcyB0byBiZSBwYXNzZWQKKy8vISB0byBgcnVzdGNgIChpbnRyb2R1Y2VkIGlu IFtSRkMgMTMxXSkuIFRoZXNlIG9wdGlvbnMgYW5kIHRoZSBmaWxlIGl0c2VsZiBhcmUKKy8vISB1 bnN0YWJsZS4gRXZlbnR1YWxseSwgYHJ1c3RjYCBzaG91bGQgcHJvdmlkZSBhIHdheSB0byBkbyB0 aGlzIGluIGEgc3RhYmxlCisvLyEgbWFubmVyLiBGb3IgaW5zdGFuY2UsIHZpYSBjb21tYW5kLWxp bmUgYXJndW1lbnRzLiBUaGVyZWZvcmUsIHRoaXMgZmlsZQorLy8hIHNob3VsZCBhdm9pZCB1c2lu ZyBrZXlzIHdoaWNoIGNhbiBiZSBzZXQgdmlhIGAtQ2Agb3IgYC1aYCBvcHRpb25zLgorLy8hCisv LyEgW1JGQyAxMzFdOiBodHRwczovL3J1c3QtbGFuZy5naXRodWIuaW8vcmZjcy8wMTMxLXRhcmdl dC1zcGVjaWZpY2F0aW9uLmh0bWwKKwordXNlIHN0ZDo6eworICAgIGNvbGxlY3Rpb25zOjpIYXNo TWFwLAorICAgIGZtdDo6e0Rpc3BsYXksIEZvcm1hdHRlciwgUmVzdWx0fSwKKyAgICBpbzo6QnVm UmVhZCwKK307CisKK2VudW0gVmFsdWUgeworICAgIEJvb2xlYW4oYm9vbCksCisgICAgTnVtYmVy KGkzMiksCisgICAgU3RyaW5nKFN0cmluZyksCisgICAgT2JqZWN0KE9iamVjdCksCit9CisKK3R5 cGUgT2JqZWN0ID0gVmVjPChTdHJpbmcsIFZhbHVlKT47CisKKy8vLyBNaW5pbWFsICJhbG1vc3Qg SlNPTiIgZ2VuZXJhdG9yIChlLmcuIG5vIGBudWxsYHMsIG5vIGFycmF5cywgbm8gZXNjYXBpbmcp LAorLy8vIGVub3VnaCBmb3IgdGhpcyBwdXJwb3NlLgoraW1wbCBEaXNwbGF5IGZvciBWYWx1ZSB7 CisgICAgZm4gZm10KCZzZWxmLCBmb3JtYXR0ZXI6ICZtdXQgRm9ybWF0dGVyPCdfPikgLT4gUmVz dWx0IHsKKyAgICAgICAgbWF0Y2ggc2VsZiB7CisgICAgICAgICAgICBWYWx1ZTo6Qm9vbGVhbihi b29sZWFuKSA9PiB3cml0ZSEoZm9ybWF0dGVyLCAie30iLCBib29sZWFuKSwKKyAgICAgICAgICAg IFZhbHVlOjpOdW1iZXIobnVtYmVyKSA9PiB3cml0ZSEoZm9ybWF0dGVyLCAie30iLCBudW1iZXIp LAorICAgICAgICAgICAgVmFsdWU6OlN0cmluZyhzdHJpbmcpID0+IHdyaXRlIShmb3JtYXR0ZXIs ICJcInt9XCIiLCBzdHJpbmcpLAorICAgICAgICAgICAgVmFsdWU6Ok9iamVjdChvYmplY3QpID0+ IHsKKyAgICAgICAgICAgICAgICBmb3JtYXR0ZXIud3JpdGVfc3RyKCJ7Iik/OworICAgICAgICAg ICAgICAgIGlmIGxldCBbcmVmIHJlc3QgQCAuLiwgcmVmIGxhc3RdID0gb2JqZWN0Wy4uXSB7Cisg ICAgICAgICAgICAgICAgICAgIGZvciAoa2V5LCB2YWx1ZSkgaW4gcmVzdCB7CisgICAgICAgICAg ICAgICAgICAgICAgICB3cml0ZSEoZm9ybWF0dGVyLCAiXCJ7fVwiOiB7fSwiLCBrZXksIHZhbHVl KT87CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgd3JpdGUhKGZv cm1hdHRlciwgIlwie31cIjoge30iLCBsYXN0LjAsIGxhc3QuMSk/OworICAgICAgICAgICAgICAg IH0KKyAgICAgICAgICAgICAgICBmb3JtYXR0ZXIud3JpdGVfc3RyKCJ9IikKKyAgICAgICAgICAg IH0KKyAgICAgICAgfQorICAgIH0KK30KKworc3RydWN0IFRhcmdldFNwZWMoT2JqZWN0KTsKKwor aW1wbCBUYXJnZXRTcGVjIHsKKyAgICBmbiBuZXcoKSAtPiBUYXJnZXRTcGVjIHsKKyAgICAgICAg VGFyZ2V0U3BlYyhWZWM6Om5ldygpKQorICAgIH0KK30KKwordHJhaXQgUHVzaDxUPiB7CisgICAg Zm4gcHVzaCgmbXV0IHNlbGYsIGtleTogJnN0ciwgdmFsdWU6IFQpOworfQorCitpbXBsIFB1c2g8 Ym9vbD4gZm9yIFRhcmdldFNwZWMgeworICAgIGZuIHB1c2goJm11dCBzZWxmLCBrZXk6ICZzdHIs IHZhbHVlOiBib29sKSB7CisgICAgICAgIHNlbGYuMC5wdXNoKChrZXkudG9fc3RyaW5nKCksIFZh bHVlOjpCb29sZWFuKHZhbHVlKSkpOworICAgIH0KK30KKworaW1wbCBQdXNoPGkzMj4gZm9yIFRh cmdldFNwZWMgeworICAgIGZuIHB1c2goJm11dCBzZWxmLCBrZXk6ICZzdHIsIHZhbHVlOiBpMzIp IHsKKyAgICAgICAgc2VsZi4wLnB1c2goKGtleS50b19zdHJpbmcoKSwgVmFsdWU6Ok51bWJlcih2 YWx1ZSkpKTsKKyAgICB9Cit9CisKK2ltcGwgUHVzaDxTdHJpbmc+IGZvciBUYXJnZXRTcGVjIHsK KyAgICBmbiBwdXNoKCZtdXQgc2VsZiwga2V5OiAmc3RyLCB2YWx1ZTogU3RyaW5nKSB7CisgICAg ICAgIHNlbGYuMC5wdXNoKChrZXkudG9fc3RyaW5nKCksIFZhbHVlOjpTdHJpbmcodmFsdWUpKSk7 CisgICAgfQorfQorCitpbXBsIFB1c2g8JnN0cj4gZm9yIFRhcmdldFNwZWMgeworICAgIGZuIHB1 c2goJm11dCBzZWxmLCBrZXk6ICZzdHIsIHZhbHVlOiAmc3RyKSB7CisgICAgICAgIHNlbGYucHVz aChrZXksIHZhbHVlLnRvX3N0cmluZygpKTsKKyAgICB9Cit9CisKK2ltcGwgUHVzaDxPYmplY3Q+ IGZvciBUYXJnZXRTcGVjIHsKKyAgICBmbiBwdXNoKCZtdXQgc2VsZiwga2V5OiAmc3RyLCB2YWx1 ZTogT2JqZWN0KSB7CisgICAgICAgIHNlbGYuMC5wdXNoKChrZXkudG9fc3RyaW5nKCksIFZhbHVl OjpPYmplY3QodmFsdWUpKSk7CisgICAgfQorfQorCitpbXBsIERpc3BsYXkgZm9yIFRhcmdldFNw ZWMgeworICAgIGZuIGZtdCgmc2VsZiwgZm9ybWF0dGVyOiAmbXV0IEZvcm1hdHRlcjwnXz4pIC0+ IFJlc3VsdCB7CisgICAgICAgIC8vIFdlIGFkZCBzb21lIG5ld2xpbmVzIGZvciBjbGFyaXR5Lgor ICAgICAgICBmb3JtYXR0ZXIud3JpdGVfc3RyKCJ7XG4iKT87CisgICAgICAgIGlmIGxldCBbcmVm IHJlc3QgQCAuLiwgcmVmIGxhc3RdID0gc2VsZi4wWy4uXSB7CisgICAgICAgICAgICBmb3IgKGtl eSwgdmFsdWUpIGluIHJlc3QgeworICAgICAgICAgICAgICAgIHdyaXRlIShmb3JtYXR0ZXIsICIg ICAgXCJ7fVwiOiB7fSxcbiIsIGtleSwgdmFsdWUpPzsKKyAgICAgICAgICAgIH0KKyAgICAgICAg ICAgIHdyaXRlIShmb3JtYXR0ZXIsICIgICAgXCJ7fVwiOiB7fVxuIiwgbGFzdC4wLCBsYXN0LjEp PzsKKyAgICAgICAgfQorICAgICAgICBmb3JtYXR0ZXIud3JpdGVfc3RyKCJ9IikKKyAgICB9Cit9 CisKK3N0cnVjdCBLZXJuZWxDb25maWcoSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4pOworCitpbXBs IEtlcm5lbENvbmZpZyB7CisgICAgLy8vIFBhcnNlcyBgaW5jbHVkZS9jb25maWcvYXV0by5jb25m YCBmcm9tIGBzdGRpbmAuCisgICAgZm4gZnJvbV9zdGRpbigpIC0+IEtlcm5lbENvbmZpZyB7Cisg ICAgICAgIGxldCBtdXQgcmVzdWx0ID0gSGFzaE1hcDo6bmV3KCk7CisKKyAgICAgICAgbGV0IHN0 ZGluID0gc3RkOjppbzo6c3RkaW4oKTsKKyAgICAgICAgbGV0IG11dCBoYW5kbGUgPSBzdGRpbi5s b2NrKCk7CisgICAgICAgIGxldCBtdXQgbGluZSA9IFN0cmluZzo6bmV3KCk7CisKKyAgICAgICAg bG9vcCB7CisgICAgICAgICAgICBsaW5lLmNsZWFyKCk7CisKKyAgICAgICAgICAgIGlmIGhhbmRs ZS5yZWFkX2xpbmUoJm11dCBsaW5lKS51bndyYXAoKSA9PSAwIHsKKyAgICAgICAgICAgICAgICBi cmVhazsKKyAgICAgICAgICAgIH0KKworICAgICAgICAgICAgaWYgbGluZS5zdGFydHNfd2l0aCgn IycpIHsKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIH0KKworICAgICAg ICAgICAgbGV0IChrZXksIHZhbHVlKSA9IGxpbmUuc3BsaXRfb25jZSgnPScpLmV4cGVjdCgiTWlz c2luZyBgPWAgaW4gbGluZS4iKTsKKyAgICAgICAgICAgIHJlc3VsdC5pbnNlcnQoa2V5LnRvX3N0 cmluZygpLCB2YWx1ZS50cmltX2VuZF9tYXRjaGVzKCdcbicpLnRvX3N0cmluZygpKTsKKyAgICAg ICAgfQorCisgICAgICAgIEtlcm5lbENvbmZpZyhyZXN1bHQpCisgICAgfQorCisgICAgLy8vIERv ZXMgdGhlIG9wdGlvbiBleGlzdCBpbiB0aGUgY29uZmlndXJhdGlvbiAoYW55IHZhbHVlKT8KKyAg ICAvLy8KKyAgICAvLy8gVGhlIGFyZ3VtZW50IG11c3QgYmUgcGFzc2VkIHdpdGhvdXQgdGhlIGBD T05GSUdfYCBwcmVmaXguCisgICAgLy8vIFRoaXMgYXZvaWRzIHJlcGV0aXRpb24gYW5kIGl0IGFs c28gYXZvaWRzIGBmaXhkZXBgIG1ha2luZyB1cworICAgIC8vLyBkZXBlbmQgb24gaXQuCisgICAg Zm4gaGFzKCZzZWxmLCBvcHRpb246ICZzdHIpIC0+IGJvb2wgeworICAgICAgICBsZXQgb3B0aW9u ID0gIkNPTkZJR18iLnRvX293bmVkKCkgKyBvcHRpb247CisgICAgICAgIHNlbGYuMC5jb250YWlu c19rZXkoJm9wdGlvbikKKyAgICB9Cit9CisKK2ZuIG1haW4oKSB7CisgICAgbGV0IGNmZyA9IEtl cm5lbENvbmZpZzo6ZnJvbV9zdGRpbigpOworICAgIGxldCBtdXQgdHMgPSBUYXJnZXRTcGVjOjpu ZXcoKTsKKworICAgIC8vIGBsbHZtLXRhcmdldGBzIGFyZSB0YWtlbiBmcm9tIGBzY3JpcHRzL01h a2VmaWxlLmNsYW5nYC4KKyAgICBpZiBjZmcuaGFzKCJBUk0iKSB7CisgICAgICAgIHRzLnB1c2go ImFyY2giLCAiYXJtIik7CisgICAgICAgIHRzLnB1c2goCisgICAgICAgICAgICAiZGF0YS1sYXlv dXQiLAorICAgICAgICAgICAgImUtbTplLXA6MzI6MzItRmk4LWk2NDo2NC12MTI4OjY0OjEyOC1h OjA6MzItbjMyLVM2NCIsCisgICAgICAgICk7CisgICAgICAgIHRzLnB1c2goImZlYXR1cmVzIiwg IitzdHJpY3QtYWxpZ24sK3Y2Iik7CisgICAgICAgIHRzLnB1c2goImxsdm0tdGFyZ2V0IiwgImFy bS1saW51eC1nbnVlYWJpIik7CisgICAgICAgIHRzLnB1c2goIm1heC1hdG9taWMtd2lkdGgiLCA2 NCk7CisgICAgICAgIHRzLnB1c2goInRhcmdldC1tY291bnQiLCAiXFx1MDAwMV9fZ251X21jb3Vu dF9uYyIpOworICAgICAgICB0cy5wdXNoKCJ0YXJnZXQtcG9pbnRlci13aWR0aCIsICIzMiIpOwor ICAgIH0gZWxzZSBpZiBjZmcuaGFzKCJBUk02NCIpIHsKKyAgICAgICAgdHMucHVzaCgiYXJjaCIs ICJhYXJjaDY0Iik7CisgICAgICAgIHRzLnB1c2goCisgICAgICAgICAgICAiZGF0YS1sYXlvdXQi LAorICAgICAgICAgICAgImUtbTplLWk4Ojg6MzItaTE2OjE2OjMyLWk2NDo2NC1pMTI4OjEyOC1u MzI6NjQtUzEyOCIsCisgICAgICAgICk7CisgICAgICAgIHRzLnB1c2goImRpc2FibGUtcmVkem9u ZSIsIHRydWUpOworICAgICAgICB0cy5wdXNoKCJmZWF0dXJlcyIsICIrc3RyaWN0LWFsaWduLC1u ZW9uLC1mcC1hcm12OCIpOworICAgICAgICB0cy5wdXNoKCJsbHZtLXRhcmdldCIsICJhYXJjaDY0 LWxpbnV4LWdudSIpOworICAgICAgICB0cy5wdXNoKCJtYXgtYXRvbWljLXdpZHRoIiwgMTI4KTsK KyAgICAgICAgdHMucHVzaCgidGFyZ2V0LXBvaW50ZXItd2lkdGgiLCAiNjQiKTsKKyAgICB9IGVs c2UgaWYgY2ZnLmhhcygiUFBDIikgeworICAgICAgICB0cy5wdXNoKCJhcmNoIiwgInBvd2VycGM2 NCIpOworICAgICAgICB0cy5wdXNoKCJjb2RlLW1vZGVsIiwgImxhcmdlIik7CisgICAgICAgIHRz LnB1c2goImRhdGEtbGF5b3V0IiwgImUtbTplLWk2NDo2NC1uMzI6NjQiKTsKKyAgICAgICAgdHMu cHVzaCgiZmVhdHVyZXMiLCAiLWFsdGl2ZWMsLXZzeCwtaGFyZC1mbG9hdCIpOworICAgICAgICB0 cy5wdXNoKCJsbHZtLXRhcmdldCIsICJwb3dlcnBjNjRsZS1saW51eC1nbnUiKTsKKyAgICAgICAg dHMucHVzaCgibWF4LWF0b21pYy13aWR0aCIsIDY0KTsKKyAgICAgICAgdHMucHVzaCgidGFyZ2V0 LW1jb3VudCIsICJfbWNvdW50Iik7CisgICAgICAgIHRzLnB1c2goInRhcmdldC1wb2ludGVyLXdp ZHRoIiwgIjY0Iik7CisgICAgfSBlbHNlIGlmIGNmZy5oYXMoIlJJU0NWIikgeworICAgICAgICBp ZiBjZmcuaGFzKCI2NEJJVCIpIHsKKyAgICAgICAgICAgIHRzLnB1c2goImFyY2giLCAicmlzY3Y2 NCIpOworICAgICAgICAgICAgdHMucHVzaCgiZGF0YS1sYXlvdXQiLCAiZS1tOmUtcDo2NDo2NC1p NjQ6NjQtaTEyODoxMjgtbjY0LVMxMjgiKTsKKyAgICAgICAgICAgIHRzLnB1c2goImxsdm0tdGFy Z2V0IiwgInJpc2N2NjQtbGludXgtZ251Iik7CisgICAgICAgICAgICB0cy5wdXNoKCJ0YXJnZXQt cG9pbnRlci13aWR0aCIsICI2NCIpOworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgdHMu cHVzaCgiYXJjaCIsICJyaXNjdjMyIik7CisgICAgICAgICAgICB0cy5wdXNoKCJkYXRhLWxheW91 dCIsICJlLW06ZS1wOjMyOjMyLWk2NDo2NC1uMzItUzEyOCIpOworICAgICAgICAgICAgdHMucHVz aCgibGx2bS10YXJnZXQiLCAicmlzY3YzMi1saW51eC1nbnUiKTsKKyAgICAgICAgICAgIHRzLnB1 c2goInRhcmdldC1wb2ludGVyLXdpZHRoIiwgIjMyIik7CisgICAgICAgIH0KKyAgICAgICAgdHMu cHVzaCgiY29kZS1tb2RlbCIsICJtZWRpdW0iKTsKKyAgICAgICAgdHMucHVzaCgiZGlzYWJsZS1y ZWR6b25lIiwgdHJ1ZSk7CisgICAgICAgIGxldCBtdXQgZmVhdHVyZXMgPSAiK20sK2EiLnRvX3N0 cmluZygpOworICAgICAgICBpZiBjZmcuaGFzKCJSSVNDVl9JU0FfQyIpIHsKKyAgICAgICAgICAg IGZlYXR1cmVzICs9ICIsK2MiOworICAgICAgICB9CisgICAgICAgIHRzLnB1c2goImZlYXR1cmVz IiwgZmVhdHVyZXMpOworICAgIH0gZWxzZSBpZiBjZmcuaGFzKCJYODZfNjQiKSB7CisgICAgICAg IHRzLnB1c2goImFyY2giLCAieDg2XzY0Iik7CisgICAgICAgIHRzLnB1c2goCisgICAgICAgICAg ICAiZGF0YS1sYXlvdXQiLAorICAgICAgICAgICAgImUtbTplLXAyNzA6MzI6MzItcDI3MTozMjoz Mi1wMjcyOjY0OjY0LWk2NDo2NC1mODA6MTI4LW44OjE2OjMyOjY0LVMxMjgiLAorICAgICAgICAp OworICAgICAgICBsZXQgbXV0IGZlYXR1cmVzID0gIi0zZG5vdywtM2Rub3dhLC1tbXgsK3NvZnQt ZmxvYXQiLnRvX3N0cmluZygpOworICAgICAgICBpZiBjZmcuaGFzKCJSRVRQT0xJTkUiKSB7Cisg ICAgICAgICAgICBmZWF0dXJlcyArPSAiLCtyZXRwb2xpbmUtZXh0ZXJuYWwtdGh1bmsiOworICAg ICAgICB9CisgICAgICAgIHRzLnB1c2goImZlYXR1cmVzIiwgZmVhdHVyZXMpOworICAgICAgICB0 cy5wdXNoKCJsbHZtLXRhcmdldCIsICJ4ODZfNjQtbGludXgtZ251Iik7CisgICAgICAgIHRzLnB1 c2goInRhcmdldC1wb2ludGVyLXdpZHRoIiwgIjY0Iik7CisgICAgfSBlbHNlIHsKKyAgICAgICAg cGFuaWMhKCJVbnN1cHBvcnRlZCBhcmNoaXRlY3R1cmUiKTsKKyAgICB9CisKKyAgICB0cy5wdXNo KCJlbWl0LWRlYnVnLWdkYi1zY3JpcHRzIiwgZmFsc2UpOworICAgIHRzLnB1c2goImZyYW1lLXBv aW50ZXIiLCAibWF5LW9taXQiKTsKKyAgICB0cy5wdXNoKAorICAgICAgICAic3RhY2stcHJvYmVz IiwKKyAgICAgICAgdmVjIVsoImtpbmQiLnRvX3N0cmluZygpLCBWYWx1ZTo6U3RyaW5nKCJub25l Ii50b19zdHJpbmcoKSkpXSwKKyAgICApOworCisgICAgLy8gRXZlcnl0aGluZyBlbHNlIGlzIExF LCB3aGV0aGVyIGBDUFVfTElUVExFX0VORElBTmAgaXMgZGVjbGFyZWQgb3Igbm90CisgICAgLy8g KGUuZy4geDg2KS4gSXQgaXMgYWxzbyBgcnVzdGNgJ3MgZGVmYXVsdC4KKyAgICBpZiBjZmcuaGFz KCJDUFVfQklHX0VORElBTiIpIHsKKyAgICAgICAgdHMucHVzaCgidGFyZ2V0LWVuZGlhbiIsICJi aWciKTsKKyAgICB9CisKKyAgICBwcmludGxuISgie30iLCB0cyk7Cit9CmRpZmYgLS1naXQgYS9z Y3JpcHRzL2lzX3J1c3RfbW9kdWxlLnNoIGIvc2NyaXB0cy9pc19ydXN0X21vZHVsZS5zaApuZXcg ZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAuLjI4YjM4MzFhNzU5MwotLS0gL2Rl di9udWxsCisrKyBiL3NjcmlwdHMvaXNfcnVzdF9tb2R1bGUuc2gKQEAgLTAsMCArMSwxNiBAQAor IyEvYmluL3NoCisjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisjCisjIGlzX3J1 c3RfbW9kdWxlLnNoIG1vZHVsZS5rbworIworIyBSZXR1cm5zIGAwYCBpZiBgbW9kdWxlLmtvYCBp cyBhIFJ1c3QgbW9kdWxlLCBgMWAgb3RoZXJ3aXNlLgorCitzZXQgLWUKKworIyBVc2luZyB0aGUg YDE2X2AgcHJlZml4IGVuc3VyZXMgb3RoZXIgc3ltYm9scyB3aXRoIHRoZSBzYW1lIHN1YnN0cmlu ZworIyBhcmUgbm90IHBpY2tlZCB1cCAoZXZlbiBpZiBpdCB3b3VsZCBiZSB1bmxpa2VseSkuIFRo ZSBsYXN0IHBhcnQgaXMKKyMgdXNlZCBqdXN0IGluIGNhc2UgTExWTSBkZWNpZGVzIHRvIHVzZSB0 aGUgYC5gIHN1ZmZpeC4KKyMKKyMgSW4gdGhlIGZ1dHVyZSwgY2hlY2tpbmcgZm9yIHRoZSBgLmNv bW1lbnRgIHNlY3Rpb24gbWF5IGJlIGFub3RoZXIKKyMgb3B0aW9uLCBzZWUgaHR0cHM6Ly9naXRo dWIuY29tL3J1c3QtbGFuZy9ydXN0L3B1bGwvOTc1NTAuCiske05NfSAiJCoiIHwgZ3JlcCAtcUUg J15bMC05YS1mQS1GXSsgciBfUlteWzpzcGFjZTpdXSsxNl9fX0lTX1JVU1RfTU9EVUxFW15bOnNw YWNlOl1dKiQnCmRpZmYgLS1naXQgYS9zY3JpcHRzL2tjb25maWcvY29uZmRhdGEuYyBiL3Njcmlw dHMva2NvbmZpZy9jb25mZGF0YS5jCmluZGV4IGM0MzQwYzkwZTE3Mi4uYjdjOWYxZGQ1ZTQyIDEw MDY0NAotLS0gYS9zY3JpcHRzL2tjb25maWcvY29uZmRhdGEuYworKysgYi9zY3JpcHRzL2tjb25m aWcvY29uZmRhdGEuYwpAQCAtMjE2LDYgKzIxNiwxMyBAQCBzdGF0aWMgY29uc3QgY2hhciAqY29u Zl9nZXRfYXV0b2hlYWRlcl9uYW1lKHZvaWQpCiAJcmV0dXJuIG5hbWUgPyBuYW1lIDogImluY2x1 ZGUvZ2VuZXJhdGVkL2F1dG9jb25mLmgiOwogfQogCitzdGF0aWMgY29uc3QgY2hhciAqY29uZl9n ZXRfcnVzdGNjZmdfbmFtZSh2b2lkKQoreworCWNoYXIgKm5hbWUgPSBnZXRlbnYoIktDT05GSUdf UlVTVENDRkciKTsKKworCXJldHVybiBuYW1lID8gbmFtZSA6ICJpbmNsdWRlL2dlbmVyYXRlZC9y dXN0Y19jZmciOworfQorCiBzdGF0aWMgaW50IGNvbmZfc2V0X3N5bV92YWwoc3RydWN0IHN5bWJv bCAqc3ltLCBpbnQgZGVmLCBpbnQgZGVmX2ZsYWdzLCBjaGFyICpwKQogewogCWNoYXIgKnAyOwpA QCAtNjA1LDYgKzYxMiw5IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgY29tbWVudF9zdHlsZSBjb21t ZW50X3N0eWxlX2MgPSB7CiAKIHN0YXRpYyB2b2lkIGNvbmZfd3JpdGVfaGVhZGluZyhGSUxFICpm cCwgY29uc3Qgc3RydWN0IGNvbW1lbnRfc3R5bGUgKmNzKQogeworCWlmICghY3MpCisJCXJldHVy bjsKKwogCWZwcmludGYoZnAsICIlc1xuIiwgY3MtPnByZWZpeCk7CiAKIAlmcHJpbnRmKGZwLCAi JXMgQXV0b21hdGljYWxseSBnZW5lcmF0ZWQgZmlsZTsgRE8gTk9UIEVESVQuXG4iLApAQCAtNzQ1 LDYgKzc1NSw2NSBAQCBzdGF0aWMgdm9pZCBwcmludF9zeW1ib2xfZm9yX2MoRklMRSAqZnAsIHN0 cnVjdCBzeW1ib2wgKnN5bSkKIAlmcmVlKGVzY2FwZWQpOwogfQogCitzdGF0aWMgdm9pZCBwcmlu dF9zeW1ib2xfZm9yX3J1c3RjY2ZnKEZJTEUgKmZwLCBzdHJ1Y3Qgc3ltYm9sICpzeW0pCit7CisJ Y29uc3QgY2hhciAqdmFsOworCWNvbnN0IGNoYXIgKnZhbF9wcmVmaXggPSAiIjsKKwljaGFyICp2 YWxfcHJlZml4ZWQgPSBOVUxMOworCXNpemVfdCB2YWxfcHJlZml4ZWRfbGVuOworCWNoYXIgKmVz Y2FwZWQgPSBOVUxMOworCisJaWYgKHN5bS0+dHlwZSA9PSBTX1VOS05PV04pCisJCXJldHVybjsK KworCXZhbCA9IHN5bV9nZXRfc3RyaW5nX3ZhbHVlKHN5bSk7CisKKwlzd2l0Y2ggKHN5bS0+dHlw ZSkgeworCWNhc2UgU19CT09MRUFOOgorCWNhc2UgU19UUklTVEFURToKKwkJLyoKKwkJICogV2Ug ZG8gbm90IGNhcmUgYWJvdXQgZGlzYWJsZWQgb25lcywgaS5lLiBubyBuZWVkIGZvcgorCQkgKiB3 aGF0IG90aGVyd2lzZSBhcmUgImNvbW1lbnRzIiBpbiBvdGhlciBwcmludGVycy4KKwkJICovCisJ CWlmICgqdmFsID09ICduJykKKwkJCXJldHVybjsKKworCQkvKgorCQkgKiBUbyBoYXZlIHNpbWls YXIgZnVuY3Rpb25hbGl0eSB0byB0aGUgQyBtYWNybyBgSVNfRU5BQkxFRCgpYAorCQkgKiB3ZSBw cm92aWRlIGFuIGVtcHR5IGAtLWNmZyBDT05GSUdfWGAgaGVyZSBpbiBib3RoIGB5YAorCQkgKiBh bmQgYG1gIGNhc2VzLgorCQkgKgorCQkgKiBUaGVuLCB0aGUgY29tbW9uIGBmcHJpbnRmKClgIGJl bG93IHdpbGwgYWxzbyBnaXZlIHVzCisJCSAqIGEgYC0tY2ZnIENPTkZJR19YPSJ5ImAgb3IgYC0t Y2ZnIENPTkZJR19YPSJtImAsIHdoaWNoIGNhbgorCQkgKiBiZSB1c2VkIGFzIHRoZSBlcXVpdmFs ZW50IG9mIGBJU19CVUlMVElOKClgL2BJU19NT0RVTEUoKWAuCisJCSAqLworCQlmcHJpbnRmKGZw LCAiLS1jZmc9JXMlc1xuIiwgQ09ORklHXywgc3ltLT5uYW1lKTsKKwkJYnJlYWs7CisJY2FzZSBT X0hFWDoKKwkJaWYgKHZhbFswXSAhPSAnMCcgfHwgKHZhbFsxXSAhPSAneCcgJiYgdmFsWzFdICE9 ICdYJykpCisJCQl2YWxfcHJlZml4ID0gIjB4IjsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJYnJl YWs7CisJfQorCisJaWYgKHN0cmxlbih2YWxfcHJlZml4KSA+IDApIHsKKwkJdmFsX3ByZWZpeGVk X2xlbiA9IHN0cmxlbih2YWwpICsgc3RybGVuKHZhbF9wcmVmaXgpICsgMTsKKwkJdmFsX3ByZWZp eGVkID0geG1hbGxvYyh2YWxfcHJlZml4ZWRfbGVuKTsKKwkJc25wcmludGYodmFsX3ByZWZpeGVk LCB2YWxfcHJlZml4ZWRfbGVuLCAiJXMlcyIsIHZhbF9wcmVmaXgsIHZhbCk7CisJCXZhbCA9IHZh bF9wcmVmaXhlZDsKKwl9CisKKwkvKiBBbGwgdmFsdWVzIGdldCBlc2NhcGVkOiB0aGUgYC0tY2Zn YCBvcHRpb24gb25seSB0YWtlcyBzdHJpbmdzICovCisJZXNjYXBlZCA9IGVzY2FwZV9zdHJpbmdf dmFsdWUodmFsKTsKKwl2YWwgPSBlc2NhcGVkOworCisJZnByaW50ZihmcCwgIi0tY2ZnPSVzJXM9 JXNcbiIsIENPTkZJR18sIHN5bS0+bmFtZSwgdmFsKTsKKworCWZyZWUoZXNjYXBlZCk7CisJZnJl ZSh2YWxfcHJlZml4ZWQpOworfQorCiAvKgogICogV3JpdGUgb3V0IGEgbWluaW1hbCBjb25maWcu CiAgKiBBbGwgdmFsdWVzIHRoYXQgaGFzIGRlZmF1bHQgdmFsdWVzIGFyZSBza2lwcGVkIGFzIHRo aXMgaXMgcmVkdW5kYW50LgpAQCAtMTEzMiw2ICsxMjAxLDEyIEBAIGludCBjb25mX3dyaXRlX2F1 dG9jb25mKGludCBvdmVyd3JpdGUpCiAJaWYgKHJldCkKIAkJcmV0dXJuIHJldDsKIAorCXJldCA9 IF9fY29uZl93cml0ZV9hdXRvY29uZihjb25mX2dldF9ydXN0Y2NmZ19uYW1lKCksCisJCQkJICAg IHByaW50X3N5bWJvbF9mb3JfcnVzdGNjZmcsCisJCQkJICAgIE5VTEwpOworCWlmIChyZXQpCisJ CXJldHVybiByZXQ7CisKIAkvKgogCSAqIENyZWF0ZSBpbmNsdWRlL2NvbmZpZy9hdXRvLmNvbmYu IFRoaXMgbXVzdCBiZSB0aGUgbGFzdCBzdGVwIGJlY2F1c2UKIAkgKiBLYnVpbGQgaGFzIGEgZGVw ZW5kZW5jeSBvbiBhdXRvLmNvbmYgYW5kIHRoaXMgbWFya3MgdGhlIHN1Y2Nlc3NmdWwKZGlmZiAt LWdpdCBhL3NjcmlwdHMvbWluLXRvb2wtdmVyc2lvbi5zaCBiL3NjcmlwdHMvbWluLXRvb2wtdmVy c2lvbi5zaAppbmRleCAyNTA5MjVhYWIxMDEuLmI2NTkzZWFjNTAwMyAxMDA3NTUKLS0tIGEvc2Ny aXB0cy9taW4tdG9vbC12ZXJzaW9uLnNoCisrKyBiL3NjcmlwdHMvbWluLXRvb2wtdmVyc2lvbi5z aApAQCAtMzAsNiArMzAsMTIgQEAgbGx2bSkKIAkJZWNobyAxMS4wLjAKIAlmaQogCTs7CitydXN0 YykKKwllY2hvIDEuNjIuMAorCTs7CitiaW5kZ2VuKQorCWVjaG8gMC41Ni4wCisJOzsKICopCiAJ ZWNobyAiJDE6IHVua25vd24gdG9vbCIgPiYyCiAJZXhpdCAxCmRpZmYgLS1naXQgYS9zY3JpcHRz L3J1c3QtaXMtYXZhaWxhYmxlLWJpbmRnZW4tbGliY2xhbmcuaCBiL3NjcmlwdHMvcnVzdC1pcy1h dmFpbGFibGUtYmluZGdlbi1saWJjbGFuZy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMC4uMGVmNmRiMTBkNjc0Ci0tLSAvZGV2L251bGwKKysrIGIvc2NyaXB0cy9ydXN0 LWlzLWF2YWlsYWJsZS1iaW5kZ2VuLWxpYmNsYW5nLmgKQEAgLTAsMCArMSwyIEBACisvKiBTUERY LUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCAqLworI3ByYWdtYSBtZXNzYWdlKCJjbGFuZyB2 ZXJzaW9uICIgX19jbGFuZ192ZXJzaW9uX18pCmRpZmYgLS1naXQgYS9zY3JpcHRzL3J1c3QtaXMt YXZhaWxhYmxlLnNoIGIvc2NyaXB0cy9ydXN0LWlzLWF2YWlsYWJsZS5zaApuZXcgZmlsZSBtb2Rl IDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAuLjBkZGFkM2ZjZDMyYwotLS0gL2Rldi9udWxsCisr KyBiL3NjcmlwdHMvcnVzdC1pcy1hdmFpbGFibGUuc2gKQEAgLTAsMCArMSwxNjAgQEAKKyMhL2Jp bi9zaAorIyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorIworIyBUZXN0cyB3aGV0 aGVyIGEgc3VpdGFibGUgUnVzdCB0b29sY2hhaW4gaXMgYXZhaWxhYmxlLgorIworIyBQYXNzIGAt dmAgZm9yIGh1bWFuIG91dHB1dCBhbmQgbW9yZSBjaGVja3MgKGFzIHdhcm5pbmdzKS4KKworc2V0 IC1lCisKK21pbl90b29sX3ZlcnNpb249JChkaXJuYW1lICQwKS9taW4tdG9vbC12ZXJzaW9uLnNo CisKKyMgQ29udmVydCB0aGUgdmVyc2lvbiBzdHJpbmcgeC55LnogdG8gYSBjYW5vbmljYWwgdXAt dG8tNy1kaWdpdHMgZm9ybS4KKyMKKyMgTm90ZSB0aGF0IHRoaXMgZnVuY3Rpb24gdXNlcyBvbmUg bW9yZSBkaWdpdCAoY29tcGFyZWQgdG8gb3RoZXIKKyMgaW5zdGFuY2VzIGluIG90aGVyIHZlcnNp b24gc2NyaXB0cykgdG8gZ2l2ZSBhIGJpdCBtb3JlIHNwYWNlIHRvCisjIGBydXN0Y2Agc2luY2Ug aXQgd2lsbCByZWFjaCAxLjEwMC4wIGluIGxhdGUgMjAyNi4KK2dldF9jYW5vbmljYWxfdmVyc2lv bigpCit7CisJSUZTPS4KKwlzZXQgLS0gJDEKKwllY2hvICQoKDEwMDAwMCAqICQxICsgMTAwICog JDIgKyAkMykpCit9CisKKyMgQ2hlY2sgdGhhdCB0aGUgUnVzdCBjb21waWxlciBleGlzdHMuCitp ZiAhIGNvbW1hbmQgLXYgIiRSVVNUQyIgPi9kZXYvbnVsbDsgdGhlbgorCWlmIFsgIiQxIiA9IC12 IF07IHRoZW4KKwkJZWNobyA+JjIgIioqKiIKKwkJZWNobyA+JjIgIioqKiBSdXN0IGNvbXBpbGVy ICckUlVTVEMnIGNvdWxkIG5vdCBiZSBmb3VuZC4iCisJCWVjaG8gPiYyICIqKioiCisJZmkKKwll eGl0IDEKK2ZpCisKKyMgQ2hlY2sgdGhhdCB0aGUgUnVzdCBiaW5kaW5ncyBnZW5lcmF0b3IgZXhp c3RzLgoraWYgISBjb21tYW5kIC12ICIkQklOREdFTiIgPi9kZXYvbnVsbDsgdGhlbgorCWlmIFsg IiQxIiA9IC12IF07IHRoZW4KKwkJZWNobyA+JjIgIioqKiIKKwkJZWNobyA+JjIgIioqKiBSdXN0 IGJpbmRpbmdzIGdlbmVyYXRvciAnJEJJTkRHRU4nIGNvdWxkIG5vdCBiZSBmb3VuZC4iCisJCWVj aG8gPiYyICIqKioiCisJZmkKKwlleGl0IDEKK2ZpCisKKyMgQ2hlY2sgdGhhdCB0aGUgUnVzdCBj b21waWxlciB2ZXJzaW9uIGlzIHN1aXRhYmxlLgorIworIyBOb24tc3RhYmxlIGFuZCBkaXN0cmli dXRpb25zJyB2ZXJzaW9ucyBtYXkgaGF2ZSBhIHZlcnNpb24gc3VmZml4LCBlLmcuIGAtZGV2YC4K K3J1c3RfY29tcGlsZXJfdmVyc2lvbj0kKCBcCisJTENfQUxMPUMgIiRSVVNUQyIgLS12ZXJzaW9u IDI+L2Rldi9udWxsIFwKKwkJfCBoZWFkIC1uIDEgXAorCQl8IGdyZXAgLW9FICdbMC05XStcLlsw LTldK1wuWzAtOV0rJyBcCispCitydXN0X2NvbXBpbGVyX21pbl92ZXJzaW9uPSQoJG1pbl90b29s X3ZlcnNpb24gcnVzdGMpCitydXN0X2NvbXBpbGVyX2N2ZXJzaW9uPSQoZ2V0X2Nhbm9uaWNhbF92 ZXJzaW9uICRydXN0X2NvbXBpbGVyX3ZlcnNpb24pCitydXN0X2NvbXBpbGVyX21pbl9jdmVyc2lv bj0kKGdldF9jYW5vbmljYWxfdmVyc2lvbiAkcnVzdF9jb21waWxlcl9taW5fdmVyc2lvbikKK2lm IFsgIiRydXN0X2NvbXBpbGVyX2N2ZXJzaW9uIiAtbHQgIiRydXN0X2NvbXBpbGVyX21pbl9jdmVy c2lvbiIgXTsgdGhlbgorCWlmIFsgIiQxIiA9IC12IF07IHRoZW4KKwkJZWNobyA+JjIgIioqKiIK KwkJZWNobyA+JjIgIioqKiBSdXN0IGNvbXBpbGVyICckUlVTVEMnIGlzIHRvbyBvbGQuIgorCQll Y2hvID4mMiAiKioqICAgWW91ciB2ZXJzaW9uOiAgICAkcnVzdF9jb21waWxlcl92ZXJzaW9uIgor CQllY2hvID4mMiAiKioqICAgTWluaW11bSB2ZXJzaW9uOiAkcnVzdF9jb21waWxlcl9taW5fdmVy c2lvbiIKKwkJZWNobyA+JjIgIioqKiIKKwlmaQorCWV4aXQgMQorZmkKK2lmIFsgIiQxIiA9IC12 IF0gJiYgWyAiJHJ1c3RfY29tcGlsZXJfY3ZlcnNpb24iIC1ndCAiJHJ1c3RfY29tcGlsZXJfbWlu X2N2ZXJzaW9uIiBdOyB0aGVuCisJZWNobyA+JjIgIioqKiIKKwllY2hvID4mMiAiKioqIFJ1c3Qg Y29tcGlsZXIgJyRSVVNUQycgaXMgdG9vIG5ldy4gVGhpcyBtYXkgb3IgbWF5IG5vdCB3b3JrLiIK KwllY2hvID4mMiAiKioqICAgWW91ciB2ZXJzaW9uOiAgICAgJHJ1c3RfY29tcGlsZXJfdmVyc2lv biIKKwllY2hvID4mMiAiKioqICAgRXhwZWN0ZWQgdmVyc2lvbjogJHJ1c3RfY29tcGlsZXJfbWlu X3ZlcnNpb24iCisJZWNobyA+JjIgIioqKiIKK2ZpCisKKyMgQ2hlY2sgdGhhdCB0aGUgUnVzdCBi aW5kaW5ncyBnZW5lcmF0b3IgaXMgc3VpdGFibGUuCisjCisjIE5vbi1zdGFibGUgYW5kIGRpc3Ry aWJ1dGlvbnMnIHZlcnNpb25zIG1heSBoYXZlIGEgdmVyc2lvbiBzdWZmaXgsIGUuZy4gYC1kZXZg LgorcnVzdF9iaW5kaW5nc19nZW5lcmF0b3JfdmVyc2lvbj0kKCBcCisJTENfQUxMPUMgIiRCSU5E R0VOIiAtLXZlcnNpb24gMj4vZGV2L251bGwgXAorCQl8IGhlYWQgLW4gMSBcCisJCXwgZ3JlcCAt b0UgJ1swLTldK1wuWzAtOV0rXC5bMC05XSsnIFwKKykKK3J1c3RfYmluZGluZ3NfZ2VuZXJhdG9y X21pbl92ZXJzaW9uPSQoJG1pbl90b29sX3ZlcnNpb24gYmluZGdlbikKK3J1c3RfYmluZGluZ3Nf Z2VuZXJhdG9yX2N2ZXJzaW9uPSQoZ2V0X2Nhbm9uaWNhbF92ZXJzaW9uICRydXN0X2JpbmRpbmdz X2dlbmVyYXRvcl92ZXJzaW9uKQorcnVzdF9iaW5kaW5nc19nZW5lcmF0b3JfbWluX2N2ZXJzaW9u PSQoZ2V0X2Nhbm9uaWNhbF92ZXJzaW9uICRydXN0X2JpbmRpbmdzX2dlbmVyYXRvcl9taW5fdmVy c2lvbikKK2lmIFsgIiRydXN0X2JpbmRpbmdzX2dlbmVyYXRvcl9jdmVyc2lvbiIgLWx0ICIkcnVz dF9iaW5kaW5nc19nZW5lcmF0b3JfbWluX2N2ZXJzaW9uIiBdOyB0aGVuCisJaWYgWyAiJDEiID0g LXYgXTsgdGhlbgorCQllY2hvID4mMiAiKioqIgorCQllY2hvID4mMiAiKioqIFJ1c3QgYmluZGlu Z3MgZ2VuZXJhdG9yICckQklOREdFTicgaXMgdG9vIG9sZC4iCisJCWVjaG8gPiYyICIqKiogICBZ b3VyIHZlcnNpb246ICAgICRydXN0X2JpbmRpbmdzX2dlbmVyYXRvcl92ZXJzaW9uIgorCQllY2hv ID4mMiAiKioqICAgTWluaW11bSB2ZXJzaW9uOiAkcnVzdF9iaW5kaW5nc19nZW5lcmF0b3JfbWlu X3ZlcnNpb24iCisJCWVjaG8gPiYyICIqKioiCisJZmkKKwlleGl0IDEKK2ZpCitpZiBbICIkMSIg PSAtdiBdICYmIFsgIiRydXN0X2JpbmRpbmdzX2dlbmVyYXRvcl9jdmVyc2lvbiIgLWd0ICIkcnVz dF9iaW5kaW5nc19nZW5lcmF0b3JfbWluX2N2ZXJzaW9uIiBdOyB0aGVuCisJZWNobyA+JjIgIioq KiIKKwllY2hvID4mMiAiKioqIFJ1c3QgYmluZGluZ3MgZ2VuZXJhdG9yICckQklOREdFTicgaXMg dG9vIG5ldy4gVGhpcyBtYXkgb3IgbWF5IG5vdCB3b3JrLiIKKwllY2hvID4mMiAiKioqICAgWW91 ciB2ZXJzaW9uOiAgICAgJHJ1c3RfYmluZGluZ3NfZ2VuZXJhdG9yX3ZlcnNpb24iCisJZWNobyA+ JjIgIioqKiAgIEV4cGVjdGVkIHZlcnNpb246ICRydXN0X2JpbmRpbmdzX2dlbmVyYXRvcl9taW5f dmVyc2lvbiIKKwllY2hvID4mMiAiKioqIgorZmkKKworIyBDaGVjayB0aGF0IHRoZSBgbGliY2xh bmdgIHVzZWQgYnkgdGhlIFJ1c3QgYmluZGluZ3MgZ2VuZXJhdG9yIGlzIHN1aXRhYmxlLgorYmlu ZGdlbl9saWJjbGFuZ192ZXJzaW9uPSQoIFwKKwlMQ19BTEw9QyAiJEJJTkRHRU4iICQoZGlybmFt ZSAkMCkvcnVzdC1pcy1hdmFpbGFibGUtYmluZGdlbi1saWJjbGFuZy5oIDI+JjEgPi9kZXYvbnVs bCBcCisJCXwgZ3JlcCAtRiAnY2xhbmcgdmVyc2lvbiAnIFwKKwkJfCBncmVwIC1vRSAnWzAtOV0r XC5bMC05XStcLlswLTldKycgXAorCQl8IGhlYWQgLW4gMSBcCispCitiaW5kZ2VuX2xpYmNsYW5n X21pbl92ZXJzaW9uPSQoJG1pbl90b29sX3ZlcnNpb24gbGx2bSkKK2JpbmRnZW5fbGliY2xhbmdf Y3ZlcnNpb249JChnZXRfY2Fub25pY2FsX3ZlcnNpb24gJGJpbmRnZW5fbGliY2xhbmdfdmVyc2lv bikKK2JpbmRnZW5fbGliY2xhbmdfbWluX2N2ZXJzaW9uPSQoZ2V0X2Nhbm9uaWNhbF92ZXJzaW9u ICRiaW5kZ2VuX2xpYmNsYW5nX21pbl92ZXJzaW9uKQoraWYgWyAiJGJpbmRnZW5fbGliY2xhbmdf Y3ZlcnNpb24iIC1sdCAiJGJpbmRnZW5fbGliY2xhbmdfbWluX2N2ZXJzaW9uIiBdOyB0aGVuCisJ aWYgWyAiJDEiID0gLXYgXTsgdGhlbgorCQllY2hvID4mMiAiKioqIgorCQllY2hvID4mMiAiKioq IGxpYmNsYW5nICh1c2VkIGJ5IHRoZSBSdXN0IGJpbmRpbmdzIGdlbmVyYXRvciAnJEJJTkRHRU4n KSBpcyB0b28gb2xkLiIKKwkJZWNobyA+JjIgIioqKiAgIFlvdXIgdmVyc2lvbjogICAgJGJpbmRn ZW5fbGliY2xhbmdfdmVyc2lvbiIKKwkJZWNobyA+JjIgIioqKiAgIE1pbmltdW0gdmVyc2lvbjog JGJpbmRnZW5fbGliY2xhbmdfbWluX3ZlcnNpb24iCisJCWVjaG8gPiYyICIqKioiCisJZmkKKwll eGl0IDEKK2ZpCisKKyMgSWYgdGhlIEMgY29tcGlsZXIgaXMgQ2xhbmcsIHRoZW4gd2UgY2FuIGFs c28gY2hlY2sgd2hldGhlciBpdHMgdmVyc2lvbgorIyBtYXRjaGVzIHRoZSBgbGliY2xhbmdgIHZl cnNpb24gdXNlZCBieSB0aGUgUnVzdCBiaW5kaW5ncyBnZW5lcmF0b3IuCisjCisjIEluIHRoZSBm dXR1cmUsIHdlIG1pZ2h0IGJlIGFibGUgdG8gcGVyZm9ybSBhIGZ1bGwgdmVyc2lvbiBjaGVjaywg c2VlCisjIGh0dHBzOi8vZ2l0aHViLmNvbS9ydXN0LWxhbmcvcnVzdC1iaW5kZ2VuL2lzc3Vlcy8y MTM4LgoraWYgWyAiJDEiID0gLXYgXTsgdGhlbgorCWNjX25hbWU9JCgkKGRpcm5hbWUgJDApL2Nj LXZlcnNpb24uc2ggIiRDQyIgfCBjdXQgLWYxIC1kJyAnKQorCWlmIFsgIiRjY19uYW1lIiA9IENs YW5nIF07IHRoZW4KKwkJY2xhbmdfdmVyc2lvbj0kKCBcCisJCQlMQ19BTEw9QyAiJENDIiAtLXZl cnNpb24gMj4vZGV2L251bGwgXAorCQkJCXwgc2VkIC1uRSAnMXM6Lip2ZXJzaW9uIChbMC05XStc LlswLTldK1wuWzAtOV0rKS4qOlwxOnAnCisJCSkKKwkJaWYgWyAiJGNsYW5nX3ZlcnNpb24iICE9 ICIkYmluZGdlbl9saWJjbGFuZ192ZXJzaW9uIiBdOyB0aGVuCisJCQllY2hvID4mMiAiKioqIgor CQkJZWNobyA+JjIgIioqKiBsaWJjbGFuZyAodXNlZCBieSB0aGUgUnVzdCBiaW5kaW5ncyBnZW5l cmF0b3IgJyRCSU5ER0VOJykiCisJCQllY2hvID4mMiAiKioqIHZlcnNpb24gZG9lcyBub3QgbWF0 Y2ggQ2xhbmcncy4gVGhpcyBtYXkgYmUgYSBwcm9ibGVtLiIKKwkJCWVjaG8gPiYyICIqKiogICBs aWJjbGFuZyB2ZXJzaW9uOiAkYmluZGdlbl9saWJjbGFuZ192ZXJzaW9uIgorCQkJZWNobyA+JjIg IioqKiAgIENsYW5nIHZlcnNpb246ICAgICRjbGFuZ192ZXJzaW9uIgorCQkJZWNobyA+JjIgIioq KiIKKwkJZmkKKwlmaQorZmkKKworIyBDaGVjayB0aGF0IHRoZSBzb3VyY2UgY29kZSBmb3IgdGhl IGBjb3JlYCBzdGFuZGFyZCBsaWJyYXJ5IGV4aXN0cy4KKyMKKyMgYCRLUlVTVEZMQUdTYCBpcyBw YXNzZWQgaW4gY2FzZSB0aGUgdXNlciBhZGRlZCBgLS1zeXNyb290YC4KK3J1c3RjX3N5c3Jvb3Q9 JCgiJFJVU1RDIiAkS1JVU1RGTEFHUyAtLXByaW50IHN5c3Jvb3QpCitydXN0Y19zcmM9JHtSVVNU X0xJQl9TUkM6LSIkcnVzdGNfc3lzcm9vdC9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5In0K K3J1c3RjX3NyY19jb3JlPSIkcnVzdGNfc3JjL2NvcmUvc3JjL2xpYi5ycyIKK2lmIFsgISAtZSAi JHJ1c3RjX3NyY19jb3JlIiBdOyB0aGVuCisJaWYgWyAiJDEiID0gLXYgXTsgdGhlbgorCQllY2hv ID4mMiAiKioqIgorCQllY2hvID4mMiAiKioqIFNvdXJjZSBjb2RlIGZvciB0aGUgJ2NvcmUnIHN0 YW5kYXJkIGxpYnJhcnkgY291bGQgbm90IGJlIGZvdW5kIgorCQllY2hvID4mMiAiKioqIGF0ICck cnVzdGNfc3JjX2NvcmUnLiIKKwkJZWNobyA+JjIgIioqKiIKKwlmaQorCWV4aXQgMQorZmkKLS0g CjIuMzcuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CmxpbnV4LXVtIG1haWxpbmcgbGlzdApsaW51eC11bUBsaXN0cy5pbmZyYWRlYWQub3JnCmh0dHA6 Ly9saXN0cy5pbmZyYWRlYWQub3JnL21haWxtYW4vbGlzdGluZm8vbGludXgtdW0K 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 Received: from lists.ozlabs.org (lists.ozlabs.org [112.213.38.117]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.lore.kernel.org (Postfix) with ESMTPS id 311DFC19F2C for ; Tue, 2 Aug 2022 01:54:35 +0000 (UTC) Received: from boromir.ozlabs.org (localhost [IPv6:::1]) by lists.ozlabs.org (Postfix) with ESMTP id 4LxdMs4JGvz3c6p for ; Tue, 2 Aug 2022 11:54:33 +1000 (AEST) Authentication-Results: lists.ozlabs.org; dkim=fail reason="signature verification failed" (2048-bit key; unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20201202 header.b=Vq+z0xXj; dkim-atps=neutral Authentication-Results: lists.ozlabs.org; spf=pass (sender SPF authorized) smtp.mailfrom=kernel.org (client-ip=139.178.84.217; helo=dfw.source.kernel.org; envelope-from=ojeda@kernel.org; receiver=) Authentication-Results: lists.ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=kernel.org header.i=@kernel.org header.a=rsa-sha256 header.s=k20201202 header.b=Vq+z0xXj; dkim-atps=neutral Received: from dfw.source.kernel.org (dfw.source.kernel.org [139.178.84.217]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by lists.ozlabs.org (Postfix) with ESMTPS id 4LxdM53YYqz2x9p for ; Tue, 2 Aug 2022 11:53:53 +1000 (AEST) Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 8CB8561072; Tue, 2 Aug 2022 01:53:50 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6C662C433D6; Tue, 2 Aug 2022 01:53:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1659405229; bh=GORFM1idi3kTQnV6VihqUFIxcib5JgKkOuMTQPkEH70=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Vq+z0xXjfjbWIMydJCs9sw6LD8Q6gLO3b+HF9QB2QiC3PgjJGIQM0EGENZHVGeErl AI0+mjRgSgjYRc+Qs4M3sydA826IfENNy2Q6kyRFksJAurGqsN0DRmxguxdgWbxU1p CUHNqk6fCc4HFyE2SdqhnfGMGCcKEG7kCv+OHqqhfj6e/y7zipuiHkcdwPqo6RUaAj WzRuXbzUMJO2P3IjmKQtNQaiUnhfvOQyZGnjD7GYcsyBuWoZY9hs1v3UsW7qz96bqs G7qHrOuaCUQMvoiYKiC+Pfy8tmOkc7O0DqjkaUCklJf3KkO2eY/Jjx92O46wrWyeKI BakcCxFD8Yyjg== From: Miguel Ojeda To: Linus Torvalds , Greg Kroah-Hartman Subject: [PATCH v8 27/31] Kbuild: add Rust support Date: Tue, 2 Aug 2022 03:50:14 +0200 Message-Id: <20220802015052.10452-28-ojeda@kernel.org> In-Reply-To: <20220802015052.10452-1-ojeda@kernel.org> References: <20220802015052.10452-1-ojeda@kernel.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit X-BeenThere: linuxppc-dev@lists.ozlabs.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Linux on PowerPC Developers Mail List List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Sven Van Asbroeck , Catalin Marinas , Dave Hansen , Miguel Cano , Paul Mackerras , Gary Guo , Douglas Su , Borislav Petkov , linux-riscv@lists.infradead.org, Will Deacon , Martin Rodriguez Reboredo , Anton Ivanov , "H. Peter Anvin" , Masahiro Yamada , x86@kernel.org, Russell King , Ingo Molnar , Wedson Almeida Filho , Alex Gaynor , Antonio Terceiro , Miguel Ojeda , Adam Bratschi-Kaye , Albert Ou , rust-for-linux@vger.kernel.org, linux-kbuild@vger.kernel.org, Boqun Feng , linux-um@lists.infradead.org, =?UTF-8?q?Bj=C3=B 6rn=20Roy=20Baron?= , Michal Marek , Daniel Xu , David Gow , Paul Walmsley , Dariusz Sosnowski , linux-arm-kernel@lists.infradead.org, Tiago Lam , Thomas Gleixner , Nick Desaulniers , linux-kernel@vger.kernel.org, Boris-Chengbiao Zhou , Jarkko Sakkinen , Palmer Dabbelt , Richard Weinberger , Finn Behrens , Johannes Berg , linuxppc-dev@lists.ozlabs.org Errors-To: linuxppc-dev-bounces+linuxppc-dev=archiver.kernel.org@lists.ozlabs.org Sender: "Linuxppc-dev" Having all the new files in place, we now enable Rust support in the build system, including `Kconfig` entries related to Rust, the Rust configuration printer, the target specification generation script, the version detection script and a few other bits. Co-developed-by: Alex Gaynor Signed-off-by: Alex Gaynor Co-developed-by: Finn Behrens Signed-off-by: Finn Behrens Co-developed-by: Adam Bratschi-Kaye Signed-off-by: Adam Bratschi-Kaye Co-developed-by: Wedson Almeida Filho Signed-off-by: Wedson Almeida Filho Co-developed-by: Michael Ellerman Signed-off-by: Michael Ellerman Co-developed-by: Sven Van Asbroeck Signed-off-by: Sven Van Asbroeck Co-developed-by: Gary Guo Signed-off-by: Gary Guo Co-developed-by: Boris-Chengbiao Zhou Signed-off-by: Boris-Chengbiao Zhou Co-developed-by: Boqun Feng Signed-off-by: Boqun Feng Co-developed-by: Douglas Su Signed-off-by: Douglas Su Co-developed-by: Dariusz Sosnowski Signed-off-by: Dariusz Sosnowski Co-developed-by: Antonio Terceiro Signed-off-by: Antonio Terceiro Co-developed-by: Daniel Xu Signed-off-by: Daniel Xu Co-developed-by: Miguel Cano Signed-off-by: Miguel Cano Co-developed-by: David Gow Signed-off-by: David Gow Co-developed-by: Tiago Lam Signed-off-by: Tiago Lam Co-developed-by: Björn Roy Baron Signed-off-by: Björn Roy Baron Co-developed-by: Martin Rodriguez Reboredo Signed-off-by: Martin Rodriguez Reboredo Signed-off-by: Miguel Ojeda --- .gitignore | 6 + .rustfmt.toml | 12 + Makefile | 172 +++++++- arch/Kconfig | 6 + arch/arm/Kconfig | 1 + arch/arm64/Kconfig | 1 + arch/powerpc/Kconfig | 1 + arch/riscv/Kconfig | 1 + arch/riscv/Makefile | 5 + arch/um/Kconfig | 1 + arch/x86/Kconfig | 1 + arch/x86/Makefile | 10 + include/linux/compiler_types.h | 6 +- init/Kconfig | 46 +- lib/Kconfig.debug | 82 ++++ rust/.gitignore | 10 + rust/Makefile | 415 +++++++++++++++++++ rust/bindgen_parameters | 21 + scripts/.gitignore | 1 + scripts/Kconfig.include | 6 +- scripts/Makefile | 3 + scripts/Makefile.build | 60 +++ scripts/Makefile.debug | 10 + scripts/Makefile.host | 34 +- scripts/Makefile.lib | 12 + scripts/Makefile.modfinal | 8 +- scripts/cc-version.sh | 12 +- scripts/generate_rust_target.rs | 232 +++++++++++ scripts/is_rust_module.sh | 16 + scripts/kconfig/confdata.c | 75 ++++ scripts/min-tool-version.sh | 6 + scripts/rust-is-available-bindgen-libclang.h | 2 + scripts/rust-is-available.sh | 160 +++++++ 33 files changed, 1408 insertions(+), 26 deletions(-) create mode 100644 .rustfmt.toml create mode 100644 rust/.gitignore create mode 100644 rust/Makefile create mode 100644 rust/bindgen_parameters create mode 100644 scripts/generate_rust_target.rs create mode 100755 scripts/is_rust_module.sh create mode 100644 scripts/rust-is-available-bindgen-libclang.h create mode 100755 scripts/rust-is-available.sh diff --git a/.gitignore b/.gitignore index 265959544978..5da004814678 100644 --- a/.gitignore +++ b/.gitignore @@ -37,6 +37,8 @@ *.o *.o.* *.patch +*.rmeta +*.rsi *.s *.so *.so.dbg @@ -97,6 +99,7 @@ modules.order !.gitattributes !.gitignore !.mailmap +!.rustfmt.toml # # Generated include files @@ -162,3 +165,6 @@ x509.genkey # Documentation toolchain sphinx_*/ + +# Rust analyzer configuration +/rust-project.json diff --git a/.rustfmt.toml b/.rustfmt.toml new file mode 100644 index 000000000000..3de5cc497465 --- /dev/null +++ b/.rustfmt.toml @@ -0,0 +1,12 @@ +edition = "2021" +newline_style = "Unix" + +# Unstable options that help catching some mistakes in formatting and that we may want to enable +# when they become stable. +# +# They are kept here since they are useful to run from time to time. +#format_code_in_doc_comments = true +#reorder_impl_items = true +#comment_width = 100 +#wrap_comments = true +#normalize_comments = true diff --git a/Makefile b/Makefile index df92892325ae..cd1d545f316b 100644 --- a/Makefile +++ b/Makefile @@ -120,6 +120,15 @@ endif export KBUILD_CHECKSRC +# Enable "clippy" (a linter) as part of the Rust compilation. +# +# Use 'make CLIPPY=1' to enable it. +ifeq ("$(origin CLIPPY)", "command line") + KBUILD_CLIPPY := $(CLIPPY) +endif + +export KBUILD_CLIPPY + # Use make M=dir or set the environment variable KBUILD_EXTMOD to specify the # directory of external module to build. Setting M= takes precedence. ifeq ("$(origin M)", "command line") @@ -267,14 +276,14 @@ no-dot-config-targets := $(clean-targets) \ cscope gtags TAGS tags help% %docs check% coccicheck \ $(version_h) headers headers_% archheaders archscripts \ %asm-generic kernelversion %src-pkg dt_binding_check \ - outputmakefile + outputmakefile rustavailable rustfmt rustfmtcheck # Installation targets should not require compiler. Unfortunately, vdso_install # is an exception where build artifacts may be updated. This must be fixed. no-compiler-targets := $(no-dot-config-targets) install dtbs_install \ headers_install modules_install kernelrelease image_name no-sync-config-targets := $(no-dot-config-targets) %install kernelrelease \ image_name -single-targets := %.a %.i %.ko %.lds %.ll %.lst %.mod %.o %.s %.symtypes %/ +single-targets := %.a %.i %.rsi %.ko %.lds %.ll %.lst %.mod %.o %.s %.symtypes %/ config-build := mixed-build := @@ -436,6 +445,7 @@ else HOSTCC = gcc HOSTCXX = g++ endif +HOSTRUSTC = rustc HOSTPKG_CONFIG = pkg-config KBUILD_USERHOSTCFLAGS := -Wall -Wmissing-prototypes -Wstrict-prototypes \ @@ -444,8 +454,26 @@ KBUILD_USERHOSTCFLAGS := -Wall -Wmissing-prototypes -Wstrict-prototypes \ KBUILD_USERCFLAGS := $(KBUILD_USERHOSTCFLAGS) $(USERCFLAGS) KBUILD_USERLDFLAGS := $(USERLDFLAGS) +# These flags apply to all Rust code in the tree, including the kernel and +# host programs. +export rust_common_flags := --edition=2021 \ + -Zbinary_dep_depinfo=y \ + -Dunsafe_op_in_unsafe_fn -Drust_2018_idioms \ + -Dunreachable_pub -Dnon_ascii_idents \ + -Wmissing_docs \ + -Drustdoc::missing_crate_level_docs \ + -Dclippy::correctness -Dclippy::style \ + -Dclippy::suspicious -Dclippy::complexity \ + -Dclippy::perf \ + -Dclippy::let_unit_value -Dclippy::mut_mut \ + -Dclippy::needless_bitwise_bool \ + -Dclippy::needless_continue \ + -Wclippy::dbg_macro + KBUILD_HOSTCFLAGS := $(KBUILD_USERHOSTCFLAGS) $(HOST_LFS_CFLAGS) $(HOSTCFLAGS) KBUILD_HOSTCXXFLAGS := -Wall -O2 $(HOST_LFS_CFLAGS) $(HOSTCXXFLAGS) +KBUILD_HOSTRUSTFLAGS := $(rust_common_flags) -O -Cstrip=debuginfo \ + -Zallow-features= $(HOSTRUSTFLAGS) KBUILD_HOSTLDFLAGS := $(HOST_LFS_LDFLAGS) $(HOSTLDFLAGS) KBUILD_HOSTLDLIBS := $(HOST_LFS_LIBS) $(HOSTLDLIBS) @@ -470,6 +498,12 @@ OBJDUMP = $(CROSS_COMPILE)objdump READELF = $(CROSS_COMPILE)readelf STRIP = $(CROSS_COMPILE)strip endif +RUSTC = rustc +RUSTDOC = rustdoc +RUSTFMT = rustfmt +CLIPPY_DRIVER = clippy-driver +BINDGEN = bindgen +CARGO = cargo PAHOLE = pahole RESOLVE_BTFIDS = $(objtree)/tools/bpf/resolve_btfids/resolve_btfids LEX = flex @@ -495,9 +529,11 @@ CHECKFLAGS := -D__linux__ -Dlinux -D__STDC__ -Dunix -D__unix__ \ -Wbitwise -Wno-return-void -Wno-unknown-attribute $(CF) NOSTDINC_FLAGS := CFLAGS_MODULE = +RUSTFLAGS_MODULE = AFLAGS_MODULE = LDFLAGS_MODULE = CFLAGS_KERNEL = +RUSTFLAGS_KERNEL = AFLAGS_KERNEL = LDFLAGS_vmlinux = @@ -526,15 +562,42 @@ KBUILD_CFLAGS := -Wall -Wundef -Werror=strict-prototypes -Wno-trigraphs \ -Werror=return-type -Wno-format-security \ -std=gnu11 KBUILD_CPPFLAGS := -D__KERNEL__ +KBUILD_RUSTFLAGS := $(rust_common_flags) \ + --target=$(objtree)/rust/target.json \ + -Cpanic=abort -Cembed-bitcode=n -Clto=n \ + -Cforce-unwind-tables=n -Ccodegen-units=1 \ + -Csymbol-mangling-version=v0 \ + -Crelocation-model=static \ + -Zfunction-sections=n \ + -Dclippy::float_arithmetic + KBUILD_AFLAGS_KERNEL := KBUILD_CFLAGS_KERNEL := +KBUILD_RUSTFLAGS_KERNEL := KBUILD_AFLAGS_MODULE := -DMODULE KBUILD_CFLAGS_MODULE := -DMODULE +KBUILD_RUSTFLAGS_MODULE := --cfg MODULE KBUILD_LDFLAGS_MODULE := KBUILD_LDFLAGS := CLANG_FLAGS := +ifeq ($(KBUILD_CLIPPY),1) + RUSTC_OR_CLIPPY_QUIET := CLIPPY + RUSTC_OR_CLIPPY = $(CLIPPY_DRIVER) +else + RUSTC_OR_CLIPPY_QUIET := RUSTC + RUSTC_OR_CLIPPY = $(RUSTC) +endif + +ifdef RUST_LIB_SRC + export RUST_LIB_SRC +endif + +export RUSTC_BOOTSTRAP := 1 + export ARCH SRCARCH CONFIG_SHELL BASH HOSTCC KBUILD_HOSTCFLAGS CROSS_COMPILE LD CC HOSTPKG_CONFIG +export RUSTC RUSTDOC RUSTFMT RUSTC_OR_CLIPPY_QUIET RUSTC_OR_CLIPPY BINDGEN CARGO +export HOSTRUSTC KBUILD_HOSTRUSTFLAGS export CPP AR NM STRIP OBJCOPY OBJDUMP READELF PAHOLE RESOLVE_BTFIDS LEX YACC AWK INSTALLKERNEL export PERL PYTHON3 CHECK CHECKFLAGS MAKE UTS_MACHINE HOSTCXX export KGZIP KBZIP2 KLZOP LZMA LZ4 XZ ZSTD @@ -543,9 +606,10 @@ export KBUILD_USERCFLAGS KBUILD_USERLDFLAGS export KBUILD_CPPFLAGS NOSTDINC_FLAGS LINUXINCLUDE OBJCOPYFLAGS KBUILD_LDFLAGS export KBUILD_CFLAGS CFLAGS_KERNEL CFLAGS_MODULE +export KBUILD_RUSTFLAGS RUSTFLAGS_KERNEL RUSTFLAGS_MODULE export KBUILD_AFLAGS AFLAGS_KERNEL AFLAGS_MODULE -export KBUILD_AFLAGS_MODULE KBUILD_CFLAGS_MODULE KBUILD_LDFLAGS_MODULE -export KBUILD_AFLAGS_KERNEL KBUILD_CFLAGS_KERNEL +export KBUILD_AFLAGS_MODULE KBUILD_CFLAGS_MODULE KBUILD_RUSTFLAGS_MODULE KBUILD_LDFLAGS_MODULE +export KBUILD_AFLAGS_KERNEL KBUILD_CFLAGS_KERNEL KBUILD_RUSTFLAGS_KERNEL export PAHOLE_FLAGS # Files to ignore in find ... statements @@ -726,7 +790,7 @@ $(KCONFIG_CONFIG): # # Do not use $(call cmd,...) here. That would suppress prompts from syncconfig, # so you cannot notice that Kconfig is waiting for the user input. -%/config/auto.conf %/config/auto.conf.cmd %/generated/autoconf.h: $(KCONFIG_CONFIG) +%/config/auto.conf %/config/auto.conf.cmd %/generated/autoconf.h %/generated/rustc_cfg: $(KCONFIG_CONFIG) $(Q)$(kecho) " SYNC $@" $(Q)$(MAKE) -f $(srctree)/Makefile syncconfig else # !may-sync-config @@ -755,12 +819,20 @@ KBUILD_CFLAGS += $(call cc-disable-warning, address-of-packed-member) ifdef CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE KBUILD_CFLAGS += -O2 +KBUILD_RUSTFLAGS += -Copt-level=2 else ifdef CONFIG_CC_OPTIMIZE_FOR_PERFORMANCE_O3 KBUILD_CFLAGS += -O3 +KBUILD_RUSTFLAGS += -Copt-level=3 else ifdef CONFIG_CC_OPTIMIZE_FOR_SIZE KBUILD_CFLAGS += -Os +KBUILD_RUSTFLAGS += -Copt-level=s endif +# Always set `debug-assertions` and `overflow-checks` because their default +# depends on `opt-level` and `debug-assertions`, respectively. +KBUILD_RUSTFLAGS += -Cdebug-assertions=$(if $(CONFIG_RUST_DEBUG_ASSERTIONS),y,n) +KBUILD_RUSTFLAGS += -Coverflow-checks=$(if $(CONFIG_RUST_OVERFLOW_CHECKS),y,n) + # Tell gcc to never replace conditional load with a non-conditional one ifdef CONFIG_CC_IS_GCC # gcc-10 renamed --param=allow-store-data-races=0 to @@ -791,6 +863,9 @@ KBUILD_CFLAGS-$(CONFIG_WERROR) += -Werror KBUILD_CFLAGS-$(CONFIG_CC_NO_ARRAY_BOUNDS) += -Wno-array-bounds KBUILD_CFLAGS += $(KBUILD_CFLAGS-y) $(CONFIG_CC_IMPLICIT_FALLTHROUGH) +KBUILD_RUSTFLAGS-$(CONFIG_WERROR) += -Dwarnings +KBUILD_RUSTFLAGS += $(KBUILD_RUSTFLAGS-y) + ifdef CONFIG_CC_IS_CLANG KBUILD_CPPFLAGS += -Qunused-arguments # The kernel builds with '-std=gnu11' so use of GNU extensions is acceptable. @@ -811,12 +886,15 @@ KBUILD_CFLAGS += $(call cc-disable-warning, dangling-pointer) ifdef CONFIG_FRAME_POINTER KBUILD_CFLAGS += -fno-omit-frame-pointer -fno-optimize-sibling-calls +KBUILD_RUSTFLAGS += -Cforce-frame-pointers=y else # Some targets (ARM with Thumb2, for example), can't be built with frame # pointers. For those, we don't have FUNCTION_TRACER automatically # select FRAME_POINTER. However, FUNCTION_TRACER adds -pg, and this is # incompatible with -fomit-frame-pointer with current GCC, so we don't use # -fomit-frame-pointer with FUNCTION_TRACER. +# In the Rust target specification, "frame-pointer" is set explicitly +# to "may-omit". ifndef CONFIG_FUNCTION_TRACER KBUILD_CFLAGS += -fomit-frame-pointer endif @@ -881,8 +959,10 @@ ifdef CONFIG_DEBUG_SECTION_MISMATCH KBUILD_CFLAGS += -fno-inline-functions-called-once endif +# `rustc`'s `-Zfunction-sections` applies to data too (as of 1.59.0). ifdef CONFIG_LD_DEAD_CODE_DATA_ELIMINATION KBUILD_CFLAGS_KERNEL += -ffunction-sections -fdata-sections +KBUILD_RUSTFLAGS_KERNEL += -Zfunction-sections=y LDFLAGS_vmlinux += --gc-sections endif @@ -1025,10 +1105,11 @@ include $(addprefix $(srctree)/, $(include-y)) # Do not add $(call cc-option,...) below this line. When you build the kernel # from the clean source tree, the GCC plugins do not exist at this point. -# Add user supplied CPPFLAGS, AFLAGS and CFLAGS as the last assignments +# Add user supplied CPPFLAGS, AFLAGS, CFLAGS and RUSTFLAGS as the last assignments KBUILD_CPPFLAGS += $(KCPPFLAGS) KBUILD_AFLAGS += $(KAFLAGS) KBUILD_CFLAGS += $(KCFLAGS) +KBUILD_RUSTFLAGS += $(KRUSTFLAGS) KBUILD_LDFLAGS_MODULE += --build-id=sha1 LDFLAGS_vmlinux += --build-id=sha1 @@ -1097,6 +1178,7 @@ export MODULES_NSDEPS := $(extmod_prefix)modules.nsdeps ifeq ($(KBUILD_EXTMOD),) core-y += kernel/ certs/ mm/ fs/ ipc/ security/ crypto/ core-$(CONFIG_BLOCK) += block/ +core-$(CONFIG_RUST) += rust/ vmlinux-dirs := $(patsubst %/,%,$(filter %/, \ $(core-y) $(core-m) $(drivers-y) $(drivers-m) \ @@ -1201,6 +1283,10 @@ prepare0: archprepare # All the preparing.. prepare: prepare0 +ifdef CONFIG_RUST + $(Q)$(CONFIG_SHELL) $(srctree)/scripts/rust-is-available.sh -v + $(Q)$(MAKE) $(build)=rust +endif PHONY += remove-stale-files remove-stale-files: @@ -1490,7 +1576,7 @@ endif # CONFIG_MODULES # Directories & files removed with 'make clean' CLEAN_FILES += include/ksym vmlinux.symvers modules-only.symvers \ modules.builtin modules.builtin.modinfo modules.nsdeps \ - compile_commands.json .thinlto-cache + compile_commands.json .thinlto-cache rust/test rust/doc # Directories & files removed with 'make mrproper' MRPROPER_FILES += include/config include/generated \ @@ -1501,7 +1587,8 @@ MRPROPER_FILES += include/config include/generated \ certs/signing_key.pem \ certs/x509.genkey \ vmlinux-gdb.py \ - *.spec + *.spec \ + rust/target.json rust/libmacros.so # clean - Delete most, but leave enough to build external modules # @@ -1526,6 +1613,9 @@ $(mrproper-dirs): mrproper: clean $(mrproper-dirs) $(call cmd,rmfiles) + @find . $(RCS_FIND_IGNORE) \ + \( -name '*.rmeta' \) \ + -type f -print | xargs rm -f # distclean # @@ -1613,6 +1703,24 @@ help: @echo ' kselftest-merge - Merge all the config dependencies of' @echo ' kselftest to existing .config.' @echo '' + @echo 'Rust targets:' + @echo ' rustavailable - Checks whether the Rust toolchain is' + @echo ' available and, if not, explains why.' + @echo ' rustfmt - Reformat all the Rust code in the kernel' + @echo ' rustfmtcheck - Checks if all the Rust code in the kernel' + @echo ' is formatted, printing a diff otherwise.' + @echo ' rustdoc - Generate Rust documentation' + @echo ' (requires kernel .config)' + @echo ' rusttest - Runs the Rust tests' + @echo ' (requires kernel .config; downloads external repos)' + @echo ' rust-analyzer - Generate rust-project.json rust-analyzer support file' + @echo ' (requires kernel .config)' + @echo ' dir/file.[os] - Build specified target only' + @echo ' dir/file.rsi - Build macro expanded source, similar to C preprocessing.' + @echo ' Run with RUSTFMT=n to skip reformatting if needed.' + @echo ' The output is not intended to be compilable.' + @echo ' dir/file.ll - Build the LLVM assembly file' + @echo '' @$(if $(dtstree), \ echo 'Devicetree:'; \ echo '* dtbs - Build device tree blobs for enabled boards'; \ @@ -1685,6 +1793,52 @@ PHONY += $(DOC_TARGETS) $(DOC_TARGETS): $(Q)$(MAKE) $(build)=Documentation $@ + +# Rust targets +# --------------------------------------------------------------------------- + +# "Is Rust available?" target +PHONY += rustavailable +rustavailable: + $(Q)$(CONFIG_SHELL) $(srctree)/scripts/rust-is-available.sh -v && echo "Rust is available!" + +# Documentation target +# +# Using the singular to avoid running afoul of `no-dot-config-targets`. +PHONY += rustdoc +rustdoc: prepare + $(Q)$(MAKE) $(build)=rust $@ + +# Testing target +PHONY += rusttest +rusttest: prepare + $(Q)$(MAKE) $(build)=rust $@ + +# Formatting targets +PHONY += rustfmt rustfmtcheck + +# We skip `rust/alloc` since we want to minimize the diff w.r.t. upstream. +# +# We match using absolute paths since `find` does not resolve them +# when matching, which is a problem when e.g. `srctree` is `..`. +# We `grep` afterwards in order to remove the directory entry itself. +rustfmt: + $(Q)find $(abs_srctree) -type f -name '*.rs' \ + -o -path $(abs_srctree)/rust/alloc -prune \ + -o -path $(abs_objtree)/rust/test -prune \ + | grep -Fv $(abs_srctree)/rust/alloc \ + | grep -Fv $(abs_objtree)/rust/test \ + | grep -Fv generated \ + | xargs $(RUSTFMT) $(rustfmt_flags) + +rustfmtcheck: rustfmt_flags = --check +rustfmtcheck: rustfmt + +# IDE support targets +PHONY += rust-analyzer +rust-analyzer: + $(Q)$(MAKE) $(build)=rust $@ + # Misc # --------------------------------------------------------------------------- @@ -1852,7 +2006,7 @@ $(clean-dirs): clean: $(clean-dirs) $(call cmd,rmfiles) @find $(or $(KBUILD_EXTMOD), .) $(RCS_FIND_IGNORE) \ - \( -name '*.[aios]' -o -name '*.ko' -o -name '.*.cmd' \ + \( -name '*.[aios]' -o -name '*.rsi' -o -name '*.ko' -o -name '.*.cmd' \ -o -name '*.ko.*' \ -o -name '*.dtb' -o -name '*.dtbo' -o -name '*.dtb.S' -o -name '*.dt.yaml' \ -o -name '*.dwo' -o -name '*.lst' \ diff --git a/arch/Kconfig b/arch/Kconfig index 71b9272acb28..d5038cf8dd49 100644 --- a/arch/Kconfig +++ b/arch/Kconfig @@ -353,6 +353,12 @@ config HAVE_RSEQ This symbol should be selected by an architecture if it supports an implementation of restartable sequences. +config HAVE_RUST + bool + help + This symbol should be selected by an architecture if it + supports Rust. + config HAVE_FUNCTION_ARG_ACCESS_API bool help diff --git a/arch/arm/Kconfig b/arch/arm/Kconfig index 7630ba9cb6cc..147655a4fc27 100644 --- a/arch/arm/Kconfig +++ b/arch/arm/Kconfig @@ -116,6 +116,7 @@ config ARM select MMU_GATHER_RCU_TABLE_FREE if SMP && ARM_LPAE select HAVE_REGS_AND_STACK_ACCESS_API select HAVE_RSEQ + select HAVE_RUST if CPU_32v6 || CPU_32v6K select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS select HAVE_UID16 diff --git a/arch/arm64/Kconfig b/arch/arm64/Kconfig index 1652a9800ebe..aaeb70358979 100644 --- a/arch/arm64/Kconfig +++ b/arch/arm64/Kconfig @@ -201,6 +201,7 @@ config ARM64 select HAVE_FUNCTION_ARG_ACCESS_API select MMU_GATHER_RCU_TABLE_FREE select HAVE_RSEQ + select HAVE_RUST select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS select HAVE_KPROBES diff --git a/arch/powerpc/Kconfig b/arch/powerpc/Kconfig index 4d8f26c1399b..edab3cc9edf5 100644 --- a/arch/powerpc/Kconfig +++ b/arch/powerpc/Kconfig @@ -243,6 +243,7 @@ config PPC select HAVE_REGS_AND_STACK_ACCESS_API select HAVE_RELIABLE_STACKTRACE select HAVE_RSEQ + select HAVE_RUST if PPC64 && CPU_LITTLE_ENDIAN select HAVE_SETUP_PER_CPU_AREA if PPC64 select HAVE_SOFTIRQ_ON_OWN_STACK select HAVE_STACKPROTECTOR if PPC32 && $(cc-option,-mstack-protector-guard=tls -mstack-protector-guard-reg=r2) diff --git a/arch/riscv/Kconfig b/arch/riscv/Kconfig index fcbb81feb7ad..5b53b41528f6 100644 --- a/arch/riscv/Kconfig +++ b/arch/riscv/Kconfig @@ -104,6 +104,7 @@ config RISCV select HAVE_PERF_REGS select HAVE_PERF_USER_STACK_DUMP select HAVE_REGS_AND_STACK_ACCESS_API + select HAVE_RUST if 64BIT select HAVE_FUNCTION_ARG_ACCESS_API select HAVE_STACKPROTECTOR select HAVE_SYSCALL_TRACEPOINTS diff --git a/arch/riscv/Makefile b/arch/riscv/Makefile index 81029d40a672..24ebe042406e 100644 --- a/arch/riscv/Makefile +++ b/arch/riscv/Makefile @@ -26,6 +26,8 @@ ifeq ($(CONFIG_ARCH_RV64I),y) KBUILD_CFLAGS += -mabi=lp64 KBUILD_AFLAGS += -mabi=lp64 + KBUILD_RUSTFLAGS += -Ctarget-cpu=generic-rv64 + KBUILD_LDFLAGS += -melf64lriscv else BITS := 32 @@ -33,6 +35,9 @@ else KBUILD_CFLAGS += -mabi=ilp32 KBUILD_AFLAGS += -mabi=ilp32 + + KBUILD_RUSTFLAGS += -Ctarget-cpu=generic-rv32 + KBUILD_LDFLAGS += -melf32lriscv endif diff --git a/arch/um/Kconfig b/arch/um/Kconfig index 4ec22e156a2e..6dc06a7bf8b7 100644 --- a/arch/um/Kconfig +++ b/arch/um/Kconfig @@ -25,6 +25,7 @@ config UML select TRACE_IRQFLAGS_SUPPORT select TTY # Needed for line.c select HAVE_ARCH_VMAP_STACK + select HAVE_RUST if X86_64 config MMU bool diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index 52a7f91527fe..4d5a3f256cbc 100644 --- a/arch/x86/Kconfig +++ b/arch/x86/Kconfig @@ -258,6 +258,7 @@ config X86 select HAVE_STATIC_CALL_INLINE if HAVE_OBJTOOL select HAVE_PREEMPT_DYNAMIC_CALL select HAVE_RSEQ + select HAVE_RUST if X86_64 select HAVE_SYSCALL_TRACEPOINTS select HAVE_UACCESS_VALIDATION if HAVE_OBJTOOL select HAVE_UNSTABLE_SCHED_CLOCK diff --git a/arch/x86/Makefile b/arch/x86/Makefile index 7854685c5f25..bab595003f07 100644 --- a/arch/x86/Makefile +++ b/arch/x86/Makefile @@ -68,6 +68,7 @@ export BITS # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=53383 # KBUILD_CFLAGS += -mno-sse -mno-mmx -mno-sse2 -mno-3dnow -mno-avx +KBUILD_RUSTFLAGS += -Ctarget-feature=-sse,-sse2,-sse3,-ssse3,-sse4.1,-sse4.2,-avx,-avx2 ifeq ($(CONFIG_X86_KERNEL_IBT),y) # @@ -155,8 +156,17 @@ else cflags-$(CONFIG_GENERIC_CPU) += -mtune=generic KBUILD_CFLAGS += $(cflags-y) + rustflags-$(CONFIG_MK8) += -Ctarget-cpu=k8 + rustflags-$(CONFIG_MPSC) += -Ctarget-cpu=nocona + rustflags-$(CONFIG_MCORE2) += -Ctarget-cpu=core2 + rustflags-$(CONFIG_MATOM) += -Ctarget-cpu=atom + rustflags-$(CONFIG_GENERIC_CPU) += -Ztune-cpu=generic + KBUILD_RUSTFLAGS += $(rustflags-y) + KBUILD_CFLAGS += -mno-red-zone KBUILD_CFLAGS += -mcmodel=kernel + KBUILD_RUSTFLAGS += -Cno-redzone=y + KBUILD_RUSTFLAGS += -Ccode-model=kernel endif # diff --git a/include/linux/compiler_types.h b/include/linux/compiler_types.h index 4f2a819fd60a..50b3f6b9502e 100644 --- a/include/linux/compiler_types.h +++ b/include/linux/compiler_types.h @@ -4,8 +4,12 @@ #ifndef __ASSEMBLY__ +/* + * Skipped when running bindgen due to a libclang issue; + * see https://github.com/rust-lang/rust-bindgen/issues/2244. + */ #if defined(CONFIG_DEBUG_INFO_BTF) && defined(CONFIG_PAHOLE_HAS_BTF_TAG) && \ - __has_attribute(btf_type_tag) + __has_attribute(btf_type_tag) && !defined(__BINDGEN__) # define BTF_TYPE_TAG(value) __attribute__((btf_type_tag(#value))) #else # define BTF_TYPE_TAG(value) /* nothing */ diff --git a/init/Kconfig b/init/Kconfig index c7900e8975f1..6f62dbea8283 100644 --- a/init/Kconfig +++ b/init/Kconfig @@ -60,6 +60,17 @@ config LLD_VERSION default $(ld-version) if LD_IS_LLD default 0 +config RUST_IS_AVAILABLE + def_bool $(success,$(srctree)/scripts/rust-is-available.sh) + help + This shows whether a suitable Rust toolchain is available (found). + + Please see Documentation/rust/quick-start.rst for instructions on how + to satify the build requirements of Rust support. + + In particular, the Makefile target 'rustavailable' is useful to check + why the Rust toolchain is not being detected. + config CC_CAN_LINK bool default $(success,$(srctree)/scripts/cc-can-link.sh $(CC) $(CLANG_FLAGS) $(USERCFLAGS) $(USERLDFLAGS) $(m64-flag)) if 64BIT @@ -151,7 +162,8 @@ config WERROR default COMPILE_TEST help A kernel build should not cause any compiler warnings, and this - enables the '-Werror' flag to enforce that rule by default. + enables the '-Werror' (for C) and '-Dwarnings' (for Rust) flags + to enforce that rule by default. However, if you have a new (or very old) compiler with odd and unusual warnings, or you have some architecture with problems, @@ -1898,6 +1910,38 @@ config PROFILING Say Y here to enable the extended profiling support mechanisms used by profilers. +config RUST + bool "Rust support" + depends on HAVE_RUST + depends on RUST_IS_AVAILABLE + depends on !MODVERSIONS + depends on !GCC_PLUGINS + depends on !RANDSTRUCT + depends on !DEBUG_INFO_BTF + select CONSTRUCTORS + help + Enables Rust support in the kernel. + + This allows other Rust-related options, like drivers written in Rust, + to be selected. + + It is also required to be able to load external kernel modules + written in Rust. + + See Documentation/rust/ for more information. + + If unsure, say N. + +config RUSTC_VERSION_TEXT + string + depends on RUST + default $(shell,command -v $(RUSTC) >/dev/null 2>&1 && $(RUSTC) --version || echo n) + +config BINDGEN_VERSION_TEXT + string + depends on RUST + default $(shell,command -v $(BINDGEN) >/dev/null 2>&1 && $(BINDGEN) --version || echo n) + # # Place an empty function call at each tracepoint site. Can be # dynamically changed for a probe function. diff --git a/lib/Kconfig.debug b/lib/Kconfig.debug index 2e24db4bff19..ae3c43e0092e 100644 --- a/lib/Kconfig.debug +++ b/lib/Kconfig.debug @@ -2688,6 +2688,88 @@ config HYPERV_TESTING endmenu # "Kernel Testing and Coverage" +menu "Rust hacking" + +config RUST_DEBUG_ASSERTIONS + bool "Debug assertions" + depends on RUST + help + Enables rustc's `-Cdebug-assertions` codegen option. + + This flag lets you turn `cfg(debug_assertions)` conditional + compilation on or off. This can be used to enable extra debugging + code in development but not in production. For example, it controls + the behavior of the standard library's `debug_assert!` macro. + + Note that this will apply to all Rust code, including `core`. + + If unsure, say N. + +config RUST_OVERFLOW_CHECKS + bool "Overflow checks" + default y + depends on RUST + help + Enables rustc's `-Coverflow-checks` codegen option. + + This flag allows you to control the behavior of runtime integer + overflow. When overflow-checks are enabled, a Rust panic will occur + on overflow. + + Note that this will apply to all Rust code, including `core`. + + If unsure, say Y. + +choice + prompt "Build-time assertions" + default RUST_BUILD_ASSERT_DENY + depends on RUST + help + Controls how are `build_error!` and `build_assert!` handled during build. + + If calls to them exist in the binary, it may indicate a violated invariant + or that the optimizer failed to verify the invariant during compilation. + You can choose to abort compilation or ignore them during build and let the + check be carried to runtime. + + If optimizations are turned off, you cannot select "Deny". + + If unsure, say "Deny". + +config RUST_BUILD_ASSERT_ALLOW + bool "Allow" + help + Unoptimized calls to `build_error!` will be converted to `panic!` + and checked at runtime. + +config RUST_BUILD_ASSERT_WARN + bool "Warn" + help + Unoptimized calls to `build_error!` will be converted to `panic!` + and checked at runtime, but warnings will be generated when building. + +config RUST_BUILD_ASSERT_DENY + bool "Deny" + help + Unoptimized calls to `build_error!` will abort compilation. + +endchoice + +config RUST_KERNEL_KUNIT_TEST + bool "KUnit test for the `kernel` crate" if !KUNIT_ALL_TESTS + depends on RUST && KUNIT=y + default KUNIT_ALL_TESTS + help + This builds the documentation tests of the `kernel` crate + as KUnit tests. + + For more information on KUnit and unit tests in general, + please refer to the KUnit documentation in Documentation/dev-tools/kunit/. + + If unsure, say N. + +endmenu # "Rust" + source "Documentation/Kconfig" endmenu # Kernel hacking diff --git a/rust/.gitignore b/rust/.gitignore new file mode 100644 index 000000000000..89b602d91109 --- /dev/null +++ b/rust/.gitignore @@ -0,0 +1,10 @@ +# SPDX-License-Identifier: GPL-2.0 + +target.json +bindings_generated.rs +bindings_helpers_generated.rs +exports_*_generated.h +doctests_kernel_generated.rs +doctests_kernel_generated_kunit.c +doc/ +test/ diff --git a/rust/Makefile b/rust/Makefile new file mode 100644 index 000000000000..30ce13fa8dad --- /dev/null +++ b/rust/Makefile @@ -0,0 +1,415 @@ +# SPDX-License-Identifier: GPL-2.0 + +always-$(CONFIG_RUST) += target.json +no-clean-files += target.json + +obj-$(CONFIG_RUST) += core.o compiler_builtins.o +always-$(CONFIG_RUST) += exports_core_generated.h + +# Missing prototypes are expected in the helpers since these are exported +# for Rust only, thus there is no header nor prototypes. +obj-$(CONFIG_RUST) += helpers.o +CFLAGS_REMOVE_helpers.o = -Wmissing-prototypes -Wmissing-declarations + +always-$(CONFIG_RUST) += libmacros.so +no-clean-files += libmacros.so + +always-$(CONFIG_RUST) += bindings/bindings_generated.rs bindings/bindings_helpers_generated.rs +obj-$(CONFIG_RUST) += alloc.o bindings.o kernel.o +always-$(CONFIG_RUST) += exports_alloc_generated.h exports_bindings_generated.h \ + exports_kernel_generated.h + +ifdef CONFIG_RUST_BUILD_ASSERT_DENY +always-$(CONFIG_RUST) += build_error.o +else +obj-$(CONFIG_RUST) += build_error.o +endif + +obj-$(CONFIG_RUST) += exports.o + +obj-$(CONFIG_RUST_KERNEL_KUNIT_TEST) += doctests_kernel_generated.o +obj-$(CONFIG_RUST_KERNEL_KUNIT_TEST) += doctests_kernel_generated_kunit.o + +# Avoids running `$(RUSTC)` for the sysroot when it may not be available. +ifdef CONFIG_RUST + +# `$(rust_flags)` is passed in case the user added `--sysroot`. +rustc_sysroot := $(shell $(RUSTC) $(rust_flags) --print sysroot) +rustc_host_target := $(shell $(RUSTC) --version --verbose | grep -F 'host: ' | cut -d' ' -f2) +RUST_LIB_SRC ?= $(rustc_sysroot)/lib/rustlib/src/rust/library + +ifeq ($(quiet),silent_) +cargo_quiet=-q +rust_test_quiet=-q +rustdoc_test_quiet=--test-args -q +rustdoc_test_kernel_quiet=>/dev/null +else ifeq ($(quiet),quiet_) +rust_test_quiet=-q +rustdoc_test_quiet=--test-args -q +rustdoc_test_kernel_quiet=>/dev/null +else +cargo_quiet=--verbose +endif + +core-cfgs = \ + --cfg no_fp_fmt_parse + +alloc-cfgs = \ + --cfg no_global_oom_handling \ + --cfg no_rc \ + --cfg no_sync + +quiet_cmd_rustdoc = RUSTDOC $(if $(rustdoc_host),H, ) $< + cmd_rustdoc = \ + OBJTREE=$(abspath $(objtree)) \ + $(RUSTDOC) $(if $(rustdoc_host),$(rust_common_flags),$(rust_flags)) \ + $(rustc_target_flags) -L$(objtree)/$(obj) \ + --output $(objtree)/$(obj)/doc \ + --crate-name $(subst rustdoc-,,$@) \ + @$(objtree)/include/generated/rustc_cfg $< + +# The `html_logo_url` and `html_favicon_url` forms of the `doc` attribute +# can be used to specify a custom logo. However: +# - The given value is used as-is, thus it cannot be relative or a local file +# (unlike the non-custom case) since the generated docs have subfolders. +# - It requires adding it to every crate. +# - It requires changing `core` which comes from the sysroot. +# +# Using `-Zcrate-attr` would solve the last two points, but not the first. +# The https://github.com/rust-lang/rfcs/pull/3226 RFC suggests two new +# command-like flags to solve the issue. Meanwhile, we use the non-custom case +# and then retouch the generated files. +rustdoc: rustdoc-core rustdoc-macros rustdoc-compiler_builtins \ + rustdoc-alloc rustdoc-kernel + $(Q)cp $(srctree)/Documentation/images/logo.svg $(objtree)/$(obj)/doc + $(Q)cp $(srctree)/Documentation/images/COPYING-logo $(objtree)/$(obj)/doc + $(Q)find $(objtree)/$(obj)/doc -name '*.html' -type f -print0 | xargs -0 sed -Ei \ + -e 's:rust-logo\.svg:logo.svg:g' \ + -e 's:rust-logo\.png:logo.svg:g' \ + -e 's:favicon\.svg:logo.svg:g' \ + -e 's:::g' + $(Q)echo '.logo-container > img { object-fit: contain; }' \ + >> $(objtree)/$(obj)/doc/rustdoc.css + +rustdoc-macros: private rustdoc_host = yes +rustdoc-macros: private rustc_target_flags = --crate-type proc-macro \ + --extern proc_macro +rustdoc-macros: $(src)/macros/lib.rs FORCE + $(call if_changed,rustdoc) + +rustdoc-core: private rustc_target_flags = $(core-cfgs) +rustdoc-core: $(RUST_LIB_SRC)/core/src/lib.rs FORCE + $(call if_changed,rustdoc) + +rustdoc-compiler_builtins: $(src)/compiler_builtins.rs rustdoc-core FORCE + $(call if_changed,rustdoc) + +# We need to allow `rustdoc::broken_intra_doc_links` because some +# `no_global_oom_handling` functions refer to non-`no_global_oom_handling` +# functions. Ideally `rustdoc` would have a way to distinguish broken links +# due to things that are "configured out" vs. entirely non-existing ones. +rustdoc-alloc: private rustc_target_flags = $(alloc-cfgs) \ + -Arustdoc::broken_intra_doc_links +rustdoc-alloc: $(src)/alloc/lib.rs rustdoc-core rustdoc-compiler_builtins FORCE + $(call if_changed,rustdoc) + +rustdoc-kernel: private rustc_target_flags = --extern alloc \ + --extern build_error --extern macros=$(objtree)/$(obj)/libmacros.so \ + --extern bindings +rustdoc-kernel: $(src)/kernel/lib.rs rustdoc-core rustdoc-macros \ + rustdoc-compiler_builtins rustdoc-alloc $(obj)/libmacros.so \ + $(obj)/bindings.o FORCE + $(call if_changed,rustdoc) + +quiet_cmd_rustc_test_library = RUSTC TL $< + cmd_rustc_test_library = \ + OBJTREE=$(abspath $(objtree)) \ + $(RUSTC) $(rust_common_flags) \ + @$(objtree)/include/generated/rustc_cfg $(rustc_target_flags) \ + --crate-type $(if $(rustc_test_library_proc),proc-macro,rlib) \ + --out-dir $(objtree)/$(obj)/test --cfg testlib \ + --sysroot $(objtree)/$(obj)/test/sysroot \ + -L$(objtree)/$(obj)/test \ + --crate-name $(subst rusttest-,,$(subst rusttestlib-,,$@)) $< + +rusttestlib-build_error: $(src)/build_error.rs rusttest-prepare FORCE + $(call if_changed,rustc_test_library) + +rusttestlib-macros: private rustc_target_flags = --extern proc_macro +rusttestlib-macros: private rustc_test_library_proc = yes +rusttestlib-macros: $(src)/macros/lib.rs rusttest-prepare FORCE + $(call if_changed,rustc_test_library) + +rusttestlib-bindings: $(src)/bindings/lib.rs rusttest-prepare FORCE + $(call if_changed,rustc_test_library) + +quiet_cmd_rustdoc_test = RUSTDOC T $< + cmd_rustdoc_test = \ + OBJTREE=$(abspath $(objtree)) \ + $(RUSTDOC) --test $(rust_common_flags) \ + @$(objtree)/include/generated/rustc_cfg \ + $(rustc_target_flags) $(rustdoc_test_target_flags) \ + --sysroot $(objtree)/$(obj)/test/sysroot $(rustdoc_test_quiet) \ + -L$(objtree)/$(obj)/test --output $(objtree)/$(obj)/doc \ + --crate-name $(subst rusttest-,,$@) $< + +quiet_cmd_rustdoc_test_kernel = RUSTDOC TK $< + cmd_rustdoc_test_kernel = \ + rm -rf $(objtree)/$(obj)/test/doctests/kernel; \ + mkdir -p $(objtree)/$(obj)/test/doctests/kernel; \ + OBJTREE=$(abspath $(objtree)) \ + $(RUSTDOC) --test $(rust_flags) \ + @$(objtree)/include/generated/rustc_cfg \ + -L$(objtree)/$(obj) --extern alloc --extern kernel \ + --extern build_error --extern macros \ + --extern bindings \ + --no-run --crate-name kernel -Zunstable-options \ + --test-builder $(srctree)/scripts/rustdoc_test_builder.py \ + $< $(rustdoc_test_kernel_quiet); \ + $(srctree)/scripts/rustdoc_test_gen.py + +%/doctests_kernel_generated.rs %/doctests_kernel_generated_kunit.c: $(src)/kernel/lib.rs $(obj)/kernel.o FORCE + $(call if_changed,rustdoc_test_kernel) + +# We cannot use `-Zpanic-abort-tests` because some tests are dynamic, +# so for the moment we skip `-Cpanic=abort`. +quiet_cmd_rustc_test = RUSTC T $< + cmd_rustc_test = \ + OBJTREE=$(abspath $(objtree)) \ + $(RUSTC) --test $(rust_common_flags) \ + @$(objtree)/include/generated/rustc_cfg \ + $(rustc_target_flags) --out-dir $(objtree)/$(obj)/test \ + --sysroot $(objtree)/$(obj)/test/sysroot \ + -L$(objtree)/$(obj)/test \ + --crate-name $(subst rusttest-,,$@) $<; \ + $(objtree)/$(obj)/test/$(subst rusttest-,,$@) $(rust_test_quiet) \ + $(rustc_test_run_flags) + +rusttest: rusttest-macros rusttest-kernel + +# This prepares a custom sysroot with our custom `alloc` instead of +# the standard one. +# +# This requires several hacks: +# - Unlike `core` and `alloc`, `std` depends on more than a dozen crates, +# including third-party crates that need to be downloaded, plus custom +# `build.rs` steps. Thus hardcoding things here is not maintainable. +# - `cargo` knows how to build the standard library, but it is an unstable +# feature so far (`-Zbuild-std`). +# - `cargo` only considers the use case of building the standard library +# to use it in a given package. Thus we need to create a dummy package +# and pick the generated libraries from there. +# - Since we only keep a subset of upstream `alloc` in-tree, we need +# to recreate it on the fly by putting our sources on top. +# - The usual ways of modifying the dependency graph in `cargo` do not seem +# to apply for the `-Zbuild-std` steps, thus we have to mislead it +# by modifying the sources in the sysroot. +# - To avoid messing with the user's Rust installation, we create a clone +# of the sysroot. However, `cargo` ignores `RUSTFLAGS` in the `-Zbuild-std` +# steps, thus we use a wrapper binary passed via `RUSTC` to pass the flag. +# +# In the future, we hope to avoid the whole ordeal by either: +# - Making the `test` crate not depend on `std` (either improving upstream +# or having our own custom crate). +# - Making the tests run in kernel space (requires the previous point). +# - Making `std` and friends be more like a "normal" crate, so that +# `-Zbuild-std` and related hacks are not needed. +quiet_cmd_rustsysroot = RUSTSYSROOT + cmd_rustsysroot = \ + rm -rf $(objtree)/$(obj)/test; \ + mkdir -p $(objtree)/$(obj)/test; \ + cp -a $(rustc_sysroot) $(objtree)/$(obj)/test/sysroot; \ + cp -r $(srctree)/$(src)/alloc/* \ + $(objtree)/$(obj)/test/sysroot/lib/rustlib/src/rust/library/alloc/src; \ + echo '\#!/bin/sh' > $(objtree)/$(obj)/test/rustc_sysroot; \ + echo "$(RUSTC) --sysroot=$(abspath $(objtree)/$(obj)/test/sysroot) \"\$$@\"" \ + >> $(objtree)/$(obj)/test/rustc_sysroot; \ + chmod u+x $(objtree)/$(obj)/test/rustc_sysroot; \ + $(CARGO) -q new $(objtree)/$(obj)/test/dummy; \ + RUSTC=$(objtree)/$(obj)/test/rustc_sysroot $(CARGO) $(cargo_quiet) \ + test -Zbuild-std --target $(rustc_host_target) \ + --manifest-path $(objtree)/$(obj)/test/dummy/Cargo.toml; \ + rm $(objtree)/$(obj)/test/sysroot/lib/rustlib/$(rustc_host_target)/lib/*; \ + cp $(objtree)/$(obj)/test/dummy/target/$(rustc_host_target)/debug/deps/* \ + $(objtree)/$(obj)/test/sysroot/lib/rustlib/$(rustc_host_target)/lib + +rusttest-prepare: FORCE + $(call if_changed,rustsysroot) + +rusttest-macros: private rustc_target_flags = --extern proc_macro +rusttest-macros: private rustdoc_test_target_flags = --crate-type proc-macro +rusttest-macros: $(src)/macros/lib.rs rusttest-prepare FORCE + $(call if_changed,rustc_test) + $(call if_changed,rustdoc_test) + +rusttest-kernel: private rustc_target_flags = --extern alloc \ + --extern build_error --extern macros --extern bindings +rusttest-kernel: $(src)/kernel/lib.rs rusttest-prepare \ + rusttestlib-build_error rusttestlib-macros rusttestlib-bindings FORCE + $(call if_changed,rustc_test) + $(call if_changed,rustc_test_library) + +filechk_rust_target = $(objtree)/scripts/generate_rust_target < $< + +$(obj)/target.json: $(objtree)/include/config/auto.conf FORCE + $(call filechk,rust_target) + +ifdef CONFIG_CC_IS_CLANG +bindgen_c_flags = $(c_flags) +else +# bindgen relies on libclang to parse C. Ideally, bindgen would support a GCC +# plugin backend and/or the Clang driver would be perfectly compatible with GCC. +# +# For the moment, here we are tweaking the flags on the fly. This is a hack, +# and some kernel configurations may not work (e.g. `GCC_PLUGIN_RANDSTRUCT` +# if we end up using one of those structs). +bindgen_skip_c_flags := -mno-fp-ret-in-387 -mpreferred-stack-boundary=% \ + -mskip-rax-setup -mgeneral-regs-only -msign-return-address=% \ + -mindirect-branch=thunk-extern -mindirect-branch-register \ + -mfunction-return=thunk-extern -mrecord-mcount -mabi=lp64 \ + -mstack-protector-guard% -mtraceback=no \ + -mno-pointers-to-nested-functions -mno-string \ + -mno-strict-align -mstrict-align \ + -fconserve-stack -falign-jumps=% -falign-loops=% \ + -femit-struct-debug-baseonly -fno-ipa-cp-clone -fno-ipa-sra \ + -fno-partial-inlining -fplugin-arg-arm_ssp_per_task_plugin-% \ + -fno-reorder-blocks -fno-allow-store-data-races -fasan-shadow-offset=% \ + -fzero-call-used-regs=% -fno-stack-clash-protection \ + -fno-inline-functions-called-once \ + --param=% --param asan-% + +# Derived from `scripts/Makefile.clang`. +BINDGEN_TARGET_arm := arm-linux-gnueabi +BINDGEN_TARGET_arm64 := aarch64-linux-gnu +BINDGEN_TARGET_powerpc := powerpc64le-linux-gnu +BINDGEN_TARGET_riscv := riscv64-linux-gnu +BINDGEN_TARGET_x86 := x86_64-linux-gnu +BINDGEN_TARGET := $(BINDGEN_TARGET_$(SRCARCH)) + +# All warnings are inhibited since GCC builds are very experimental, +# many GCC warnings are not supported by Clang, they may only appear in +# some configurations, with new GCC versions, etc. +bindgen_extra_c_flags = -w --target=$(BINDGEN_TARGET) + +bindgen_c_flags = $(filter-out $(bindgen_skip_c_flags), $(c_flags)) \ + $(bindgen_extra_c_flags) +endif + +ifdef CONFIG_LTO +bindgen_c_flags_lto = $(filter-out $(CC_FLAGS_LTO), $(bindgen_c_flags)) +else +bindgen_c_flags_lto = $(bindgen_c_flags) +endif + +bindgen_c_flags_final = $(bindgen_c_flags_lto) -D__BINDGEN__ + +quiet_cmd_bindgen = BINDGEN $@ + cmd_bindgen = \ + $(BINDGEN) $< $(bindgen_target_flags) \ + --use-core --with-derive-default --ctypes-prefix core::ffi --no-layout-tests \ + --no-debug '.*' \ + --size_t-is-usize -o $@ -- $(bindgen_c_flags_final) -DMODULE \ + $(bindgen_target_cflags) $(bindgen_target_extra) + +$(obj)/bindings/bindings_generated.rs: private bindgen_target_flags = \ + $(shell grep -v '^\#\|^$$' $(srctree)/$(src)/bindgen_parameters) +$(obj)/bindings/bindings_generated.rs: $(src)/bindings/bindings_helper.h \ + $(src)/bindgen_parameters FORCE + $(call if_changed_dep,bindgen) + +# See `CFLAGS_REMOVE_helpers.o` above. In addition, Clang on C does not warn +# with `-Wmissing-declarations` (unlike GCC), so it is not strictly needed here +# given it is `libclang`; but for consistency, future Clang changes and/or +# a potential future GCC backend for `bindgen`, we disable it too. +$(obj)/bindings/bindings_helpers_generated.rs: private bindgen_target_flags = \ + --blacklist-type '.*' --whitelist-var '' \ + --whitelist-function 'rust_helper_.*' +$(obj)/bindings/bindings_helpers_generated.rs: private bindgen_target_cflags = \ + -I$(objtree)/$(obj) -Wno-missing-prototypes -Wno-missing-declarations +$(obj)/bindings/bindings_helpers_generated.rs: private bindgen_target_extra = ; \ + sed -Ei 's/pub fn rust_helper_([a-zA-Z0-9_]*)/#[link_name="rust_helper_\1"]\n pub fn \1/g' $@ +$(obj)/bindings/bindings_helpers_generated.rs: $(src)/helpers.c FORCE + $(call if_changed_dep,bindgen) + +quiet_cmd_exports = EXPORTS $@ + cmd_exports = \ + $(NM) -p --defined-only $< \ + | grep -E ' (T|R|D) ' | cut -d ' ' -f 3 \ + | xargs -Isymbol \ + echo 'EXPORT_SYMBOL_RUST_GPL(symbol);' > $@ + +$(obj)/exports_core_generated.h: $(obj)/core.o FORCE + $(call if_changed,exports) + +$(obj)/exports_alloc_generated.h: $(obj)/alloc.o FORCE + $(call if_changed,exports) + +$(obj)/exports_bindings_generated.h: $(obj)/bindings.o FORCE + $(call if_changed,exports) + +$(obj)/exports_kernel_generated.h: $(obj)/kernel.o FORCE + $(call if_changed,exports) + +quiet_cmd_rustc_procmacro = $(RUSTC_OR_CLIPPY_QUIET) P $@ + cmd_rustc_procmacro = \ + $(RUSTC_OR_CLIPPY) $(rust_common_flags) \ + --emit=dep-info,link --extern proc_macro \ + --crate-type proc-macro --out-dir $(objtree)/$(obj) \ + --crate-name $(patsubst lib%.so,%,$(notdir $@)) $<; \ + mv $(objtree)/$(obj)/$(patsubst lib%.so,%,$(notdir $@)).d $(depfile); \ + sed -i '/^\#/d' $(depfile) + +# Procedural macros can only be used with the `rustc` that compiled it. +# Therefore, to get `libmacros.so` automatically recompiled when the compiler +# version changes, we add `core.o` as a dependency (even if it is not needed). +$(obj)/libmacros.so: $(src)/macros/lib.rs $(obj)/core.o FORCE + $(call if_changed_dep,rustc_procmacro) + +quiet_cmd_rustc_library = $(if $(skip_clippy),RUSTC,$(RUSTC_OR_CLIPPY_QUIET)) L $@ + cmd_rustc_library = \ + OBJTREE=$(abspath $(objtree)) \ + $(if $(skip_clippy),$(RUSTC),$(RUSTC_OR_CLIPPY)) \ + $(filter-out $(skip_flags),$(rust_flags) $(rustc_target_flags)) \ + --emit=dep-info,obj,metadata --crate-type rlib \ + --out-dir $(objtree)/$(obj) -L$(objtree)/$(obj) \ + --crate-name $(patsubst %.o,%,$(notdir $@)) $<; \ + mv $(objtree)/$(obj)/$(patsubst %.o,%,$(notdir $@)).d $(depfile); \ + sed -i '/^\#/d' $(depfile) \ + $(if $(rustc_objcopy),;$(OBJCOPY) $(rustc_objcopy) $@) + +rust-analyzer: + $(Q)$(srctree)/scripts/generate_rust_analyzer.py $(srctree) $(objtree) \ + $(RUST_LIB_SRC) > $(objtree)/rust-project.json + +$(obj)/core.o: private skip_clippy = 1 +$(obj)/core.o: private skip_flags = -Dunreachable_pub +$(obj)/core.o: private rustc_target_flags = $(core-cfgs) +$(obj)/core.o: $(RUST_LIB_SRC)/core/src/lib.rs $(obj)/target.json FORCE + $(call if_changed_dep,rustc_library) + +$(obj)/compiler_builtins.o: private rustc_objcopy = -w -W '__*' +$(obj)/compiler_builtins.o: $(src)/compiler_builtins.rs $(obj)/core.o FORCE + $(call if_changed_dep,rustc_library) + +$(obj)/alloc.o: private skip_clippy = 1 +$(obj)/alloc.o: private skip_flags = -Dunreachable_pub +$(obj)/alloc.o: private rustc_target_flags = $(alloc-cfgs) +$(obj)/alloc.o: $(src)/alloc/lib.rs $(obj)/compiler_builtins.o FORCE + $(call if_changed_dep,rustc_library) + +$(obj)/build_error.o: $(src)/build_error.rs $(obj)/compiler_builtins.o FORCE + $(call if_changed_dep,rustc_library) + +$(obj)/bindings.o: $(src)/bindings/lib.rs \ + $(obj)/compiler_builtins.o \ + $(obj)/bindings/bindings_generated.rs \ + $(obj)/bindings/bindings_helpers_generated.rs FORCE + $(call if_changed_dep,rustc_library) + +$(obj)/kernel.o: private rustc_target_flags = --extern alloc \ + --extern build_error --extern macros --extern bindings +$(obj)/kernel.o: $(src)/kernel/lib.rs $(obj)/alloc.o $(obj)/build_error.o \ + $(obj)/libmacros.so $(obj)/bindings.o FORCE + $(call if_changed_dep,rustc_library) + +endif # CONFIG_RUST diff --git a/rust/bindgen_parameters b/rust/bindgen_parameters new file mode 100644 index 000000000000..be4963bf7203 --- /dev/null +++ b/rust/bindgen_parameters @@ -0,0 +1,21 @@ +# SPDX-License-Identifier: GPL-2.0 + +--opaque-type xregs_state +--opaque-type desc_struct +--opaque-type arch_lbr_state +--opaque-type local_apic + +# Packed type cannot transitively contain a `#[repr(align)]` type. +--opaque-type x86_msi_data +--opaque-type x86_msi_addr_lo + +# `try` is a reserved keyword since Rust 2018; solved in `bindgen` v0.59.2, +# commit 2aed6b021680 ("context: Escape the try keyword properly"). +--opaque-type kunit_try_catch + +# If SMP is disabled, `arch_spinlock_t` is defined as a ZST which triggers a Rust +# warning. We don't need to peek into it anyway. +--opaque-type spinlock + +# `seccomp`'s comment gets understood as a doctest +--no-doc-comments diff --git a/scripts/.gitignore b/scripts/.gitignore index eed308bef604..b7aec8eb1bd4 100644 --- a/scripts/.gitignore +++ b/scripts/.gitignore @@ -1,6 +1,7 @@ # SPDX-License-Identifier: GPL-2.0-only /asn1_compiler /bin2c +/generate_rust_target /insert-sys-cert /kallsyms /module.lds diff --git a/scripts/Kconfig.include b/scripts/Kconfig.include index 0496efd6e117..83e850321eb6 100644 --- a/scripts/Kconfig.include +++ b/scripts/Kconfig.include @@ -36,12 +36,12 @@ ld-option = $(success,$(LD) -v $(1)) as-instr = $(success,printf "%b\n" "$(1)" | $(CC) $(CLANG_FLAGS) -c -x assembler -o /dev/null -) # check if $(CC) and $(LD) exist -$(error-if,$(failure,command -v $(CC)),compiler '$(CC)' not found) +$(error-if,$(failure,command -v $(CC)),C compiler '$(CC)' not found) $(error-if,$(failure,command -v $(LD)),linker '$(LD)' not found) -# Get the compiler name, version, and error out if it is not supported. +# Get the C compiler name, version, and error out if it is not supported. cc-info := $(shell,$(srctree)/scripts/cc-version.sh $(CC)) -$(error-if,$(success,test -z "$(cc-info)"),Sorry$(comma) this compiler is not supported.) +$(error-if,$(success,test -z "$(cc-info)"),Sorry$(comma) this C compiler is not supported.) cc-name := $(shell,set -- $(cc-info) && echo $1) cc-version := $(shell,set -- $(cc-info) && echo $2) diff --git a/scripts/Makefile b/scripts/Makefile index f084f08ed176..1575af84d557 100644 --- a/scripts/Makefile +++ b/scripts/Makefile @@ -10,6 +10,9 @@ hostprogs-always-$(CONFIG_BUILDTIME_TABLE_SORT) += sorttable hostprogs-always-$(CONFIG_ASN1) += asn1_compiler hostprogs-always-$(CONFIG_MODULE_SIG_FORMAT) += sign-file hostprogs-always-$(CONFIG_SYSTEM_EXTRA_CERTIFICATE) += insert-sys-cert +hostprogs-always-$(CONFIG_RUST) += generate_rust_target + +generate_rust_target-rust := y HOSTCFLAGS_sorttable.o = -I$(srctree)/tools/include HOSTLDLIBS_sorttable = -lpthread diff --git a/scripts/Makefile.build b/scripts/Makefile.build index cac070aee791..5c495713f1b1 100644 --- a/scripts/Makefile.build +++ b/scripts/Makefile.build @@ -26,6 +26,7 @@ EXTRA_CPPFLAGS := EXTRA_LDFLAGS := asflags-y := ccflags-y := +rustflags-y := cppflags-y := ldflags-y := @@ -271,6 +272,65 @@ quiet_cmd_cc_lst_c = MKLST $@ $(obj)/%.lst: $(src)/%.c FORCE $(call if_changed_dep,cc_lst_c) +# Compile Rust sources (.rs) +# --------------------------------------------------------------------------- + +rust_allowed_features := allocator_api,bench_black_box,core_ffi_c,generic_associated_types,const_ptr_offset_from,const_refs_to_cell + +rust_common_cmd = \ + RUST_MODFILE=$(modfile) $(RUSTC_OR_CLIPPY) $(rust_flags) \ + -Zallow-features=$(rust_allowed_features) \ + -Zcrate-attr=no_std \ + -Zcrate-attr='feature($(rust_allowed_features))' \ + --extern alloc --extern kernel \ + --crate-type rlib --out-dir $(obj) -L $(objtree)/rust/ \ + --crate-name $(basename $(notdir $@)) + +rust_handle_depfile = \ + mv $(obj)/$(basename $(notdir $@)).d $(depfile); \ + sed -i '/^\#/d' $(depfile) + +# `--emit=obj`, `--emit=asm` and `--emit=llvm-ir` imply a single codegen unit +# will be used. We explicitly request `-Ccodegen-units=1` in any case, and +# the compiler shows a warning if it is not 1. However, if we ever stop +# requesting it explicitly and we start using some other `--emit` that does not +# imply it (and for which codegen is performed), then we would be out of sync, +# i.e. the outputs we would get for the different single targets (e.g. `.ll`) +# would not match each other. + +quiet_cmd_rustc_o_rs = $(RUSTC_OR_CLIPPY_QUIET) $(quiet_modtag) $@ + cmd_rustc_o_rs = \ + $(rust_common_cmd) --emit=dep-info,obj $<; \ + $(rust_handle_depfile) + +$(obj)/%.o: $(src)/%.rs FORCE + $(call if_changed_dep,rustc_o_rs) + +quiet_cmd_rustc_rsi_rs = $(RUSTC_OR_CLIPPY_QUIET) $(quiet_modtag) $@ + cmd_rustc_rsi_rs = \ + $(rust_common_cmd) --emit=dep-info -Zunpretty=expanded $< >$@; \ + command -v $(RUSTFMT) >/dev/null && $(RUSTFMT) $@; \ + $(rust_handle_depfile) + +$(obj)/%.rsi: $(src)/%.rs FORCE + $(call if_changed_dep,rustc_rsi_rs) + +quiet_cmd_rustc_s_rs = $(RUSTC_OR_CLIPPY_QUIET) $(quiet_modtag) $@ + cmd_rustc_s_rs = \ + $(rust_common_cmd) --emit=dep-info,asm $<; \ + $(rust_handle_depfile) + +$(obj)/%.s: $(src)/%.rs FORCE + $(call if_changed_dep,rustc_s_rs) + +quiet_cmd_rustc_ll_rs = $(RUSTC_OR_CLIPPY_QUIET) $(quiet_modtag) $@ + cmd_rustc_ll_rs = \ + $(rust_common_cmd) --emit=dep-info,llvm-ir $<; \ + $(rust_handle_depfile) + +$(obj)/%.ll: $(src)/%.rs FORCE + $(call if_changed_dep,rustc_ll_rs) + # Compile assembler sources (.S) # --------------------------------------------------------------------------- diff --git a/scripts/Makefile.debug b/scripts/Makefile.debug index 9f39b0130551..fe87389d52c0 100644 --- a/scripts/Makefile.debug +++ b/scripts/Makefile.debug @@ -1,4 +1,5 @@ DEBUG_CFLAGS := +DEBUG_RUSTFLAGS := ifdef CONFIG_DEBUG_INFO_SPLIT DEBUG_CFLAGS += -gsplit-dwarf @@ -10,6 +11,12 @@ ifndef CONFIG_AS_IS_LLVM KBUILD_AFLAGS += -Wa,-gdwarf-2 endif +ifdef CONFIG_DEBUG_INFO_REDUCED +DEBUG_RUSTFLAGS += -Cdebuginfo=1 +else +DEBUG_RUSTFLAGS += -Cdebuginfo=2 +endif + ifndef CONFIG_DEBUG_INFO_DWARF_TOOLCHAIN_DEFAULT dwarf-version-$(CONFIG_DEBUG_INFO_DWARF4) := 4 dwarf-version-$(CONFIG_DEBUG_INFO_DWARF5) := 5 @@ -31,3 +38,6 @@ endif KBUILD_CFLAGS += $(DEBUG_CFLAGS) export DEBUG_CFLAGS + +KBUILD_RUSTFLAGS += $(DEBUG_RUSTFLAGS) +export DEBUG_RUSTFLAGS diff --git a/scripts/Makefile.host b/scripts/Makefile.host index 278b4d6ac945..da133780b751 100644 --- a/scripts/Makefile.host +++ b/scripts/Makefile.host @@ -22,6 +22,8 @@ $(obj)/%.tab.c $(obj)/%.tab.h: $(src)/%.y FORCE # to preprocess a data file. # # Both C and C++ are supported, but preferred language is C for such utilities. +# Rust is also supported, but it may only be used in scenarios where a Rust +# toolchain is required to be available (e.g. when `CONFIG_RUST` is enabled). # # Sample syntax (see Documentation/kbuild/makefiles.rst for reference) # hostprogs := bin2hex @@ -37,15 +39,20 @@ $(obj)/%.tab.c $(obj)/%.tab.h: $(src)/%.y FORCE # qconf-objs := menu.o # Will compile qconf as a C++ program, and menu as a C program. # They are linked as C++ code to the executable qconf +# +# hostprogs := target +# target-rust := y +# Will compile `target` as a Rust program, using `target.rs` as the crate root. +# The crate may consist of several source files. # C code # Executables compiled from a single .c file host-csingle := $(foreach m,$(hostprogs), \ - $(if $($(m)-objs)$($(m)-cxxobjs),,$(m))) + $(if $($(m)-objs)$($(m)-cxxobjs)$($(m)-rust),,$(m))) # C executables linked based on several .o files host-cmulti := $(foreach m,$(hostprogs),\ - $(if $($(m)-cxxobjs),,$(if $($(m)-objs),$(m)))) + $(if $($(m)-cxxobjs)$($(m)-rust),,$(if $($(m)-objs),$(m)))) # Object (.o) files compiled from .c files host-cobjs := $(sort $(foreach m,$(hostprogs),$($(m)-objs))) @@ -58,11 +65,17 @@ host-cxxmulti := $(foreach m,$(hostprogs),$(if $($(m)-cxxobjs),$(m))) # C++ Object (.o) files compiled from .cc files host-cxxobjs := $(sort $(foreach m,$(host-cxxmulti),$($(m)-cxxobjs))) +# Rust code +# Executables compiled from a single Rust crate (which may consist of +# one or more .rs files) +host-rust := $(foreach m,$(hostprogs),$(if $($(m)-rust),$(m))) + host-csingle := $(addprefix $(obj)/,$(host-csingle)) host-cmulti := $(addprefix $(obj)/,$(host-cmulti)) host-cobjs := $(addprefix $(obj)/,$(host-cobjs)) host-cxxmulti := $(addprefix $(obj)/,$(host-cxxmulti)) host-cxxobjs := $(addprefix $(obj)/,$(host-cxxobjs)) +host-rust := $(addprefix $(obj)/,$(host-rust)) ##### # Handle options to gcc. Support building with separate output directory @@ -71,6 +84,8 @@ _hostc_flags = $(KBUILD_HOSTCFLAGS) $(HOST_EXTRACFLAGS) \ $(HOSTCFLAGS_$(target-stem).o) _hostcxx_flags = $(KBUILD_HOSTCXXFLAGS) $(HOST_EXTRACXXFLAGS) \ $(HOSTCXXFLAGS_$(target-stem).o) +_hostrust_flags = $(KBUILD_HOSTRUSTFLAGS) $(HOST_EXTRARUSTFLAGS) \ + $(HOSTRUSTFLAGS_$(target-stem)) # $(objtree)/$(obj) for including generated headers from checkin source files ifeq ($(KBUILD_EXTMOD),) @@ -82,6 +97,7 @@ endif hostc_flags = -Wp,-MMD,$(depfile) $(_hostc_flags) hostcxx_flags = -Wp,-MMD,$(depfile) $(_hostcxx_flags) +hostrust_flags = $(_hostrust_flags) ##### # Compile programs on the host @@ -128,5 +144,17 @@ quiet_cmd_host-cxxobjs = HOSTCXX $@ $(host-cxxobjs): $(obj)/%.o: $(src)/%.cc FORCE $(call if_changed_dep,host-cxxobjs) +# Create executable from a single Rust crate (which may consist of +# one or more `.rs` files) +# host-rust -> Executable +quiet_cmd_host-rust = HOSTRUSTC $@ + cmd_host-rust = \ + $(HOSTRUSTC) $(hostrust_flags) --emit=dep-info,link \ + --out-dir=$(obj)/ $<; \ + mv $(obj)/$(target-stem).d $(depfile); \ + sed -i '/^\#/d' $(depfile) +$(host-rust): $(obj)/%: $(src)/%.rs FORCE + $(call if_changed_dep,host-rust) + targets += $(host-csingle) $(host-cmulti) $(host-cobjs) \ - $(host-cxxmulti) $(host-cxxobjs) + $(host-cxxmulti) $(host-cxxobjs) $(host-rust) diff --git a/scripts/Makefile.lib b/scripts/Makefile.lib index 3fb6a99e78c4..c88b98b5dc44 100644 --- a/scripts/Makefile.lib +++ b/scripts/Makefile.lib @@ -8,6 +8,7 @@ ldflags-y += $(EXTRA_LDFLAGS) # flags that take effect in current and sub directories KBUILD_AFLAGS += $(subdir-asflags-y) KBUILD_CFLAGS += $(subdir-ccflags-y) +KBUILD_RUSTFLAGS += $(subdir-rustflags-y) # Figure out what we need to build from the various variables # =========================================================================== @@ -128,6 +129,10 @@ _c_flags = $(filter-out $(CFLAGS_REMOVE_$(target-stem).o), \ $(filter-out $(ccflags-remove-y), \ $(KBUILD_CPPFLAGS) $(KBUILD_CFLAGS) $(ccflags-y)) \ $(CFLAGS_$(target-stem).o)) +_rust_flags = $(filter-out $(RUSTFLAGS_REMOVE_$(target-stem).o), \ + $(filter-out $(rustflags-remove-y), \ + $(KBUILD_RUSTFLAGS) $(rustflags-y)) \ + $(RUSTFLAGS_$(target-stem).o)) _a_flags = $(filter-out $(AFLAGS_REMOVE_$(target-stem).o), \ $(filter-out $(asflags-remove-y), \ $(KBUILD_CPPFLAGS) $(KBUILD_AFLAGS) $(asflags-y)) \ @@ -202,6 +207,11 @@ modkern_cflags = \ $(KBUILD_CFLAGS_MODULE) $(CFLAGS_MODULE), \ $(KBUILD_CFLAGS_KERNEL) $(CFLAGS_KERNEL) $(modfile_flags)) +modkern_rustflags = \ + $(if $(part-of-module), \ + $(KBUILD_RUSTFLAGS_MODULE) $(RUSTFLAGS_MODULE), \ + $(KBUILD_RUSTFLAGS_KERNEL) $(RUSTFLAGS_KERNEL)) + modkern_aflags = $(if $(part-of-module), \ $(KBUILD_AFLAGS_MODULE) $(AFLAGS_MODULE), \ $(KBUILD_AFLAGS_KERNEL) $(AFLAGS_KERNEL)) @@ -211,6 +221,8 @@ c_flags = -Wp,-MMD,$(depfile) $(NOSTDINC_FLAGS) $(LINUXINCLUDE) \ $(_c_flags) $(modkern_cflags) \ $(basename_flags) $(modname_flags) +rust_flags = $(_rust_flags) $(modkern_rustflags) @$(objtree)/include/generated/rustc_cfg + a_flags = -Wp,-MMD,$(depfile) $(NOSTDINC_FLAGS) $(LINUXINCLUDE) \ $(_a_flags) $(modkern_aflags) diff --git a/scripts/Makefile.modfinal b/scripts/Makefile.modfinal index 35100e981f4a..9a1fa6aa30fe 100644 --- a/scripts/Makefile.modfinal +++ b/scripts/Makefile.modfinal @@ -39,11 +39,13 @@ quiet_cmd_ld_ko_o = LD [M] $@ quiet_cmd_btf_ko = BTF [M] $@ cmd_btf_ko = \ - if [ -f vmlinux ]; then \ + if [ ! -f vmlinux ]; then \ + printf "Skipping BTF generation for %s due to unavailability of vmlinux\n" $@ 1>&2; \ + elif [ -n "$(CONFIG_RUST)" ] && $(srctree)/scripts/is_rust_module.sh $@; then \ + printf "Skipping BTF generation for %s because it's a Rust module\n" $@ 1>&2; \ + else \ LLVM_OBJCOPY="$(OBJCOPY)" $(PAHOLE) -J $(PAHOLE_FLAGS) --btf_base vmlinux $@; \ $(RESOLVE_BTFIDS) -b vmlinux $@; \ - else \ - printf "Skipping BTF generation for %s due to unavailability of vmlinux\n" $@ 1>&2; \ fi; # Same as newer-prereqs, but allows to exclude specified extra dependencies diff --git a/scripts/cc-version.sh b/scripts/cc-version.sh index f1952c522466..2401c86fcf53 100755 --- a/scripts/cc-version.sh +++ b/scripts/cc-version.sh @@ -1,13 +1,13 @@ #!/bin/sh # SPDX-License-Identifier: GPL-2.0 # -# Print the compiler name and its version in a 5 or 6-digit form. +# Print the C compiler name and its version in a 5 or 6-digit form. # Also, perform the minimum version check. set -e -# Print the compiler name and some version components. -get_compiler_info() +# Print the C compiler name and some version components. +get_c_compiler_info() { cat <<- EOF | "$@" -E -P -x c - 2>/dev/null #if defined(__clang__) @@ -32,7 +32,7 @@ get_canonical_version() # $@ instead of $1 because multiple words might be given, e.g. CC="ccache gcc". orig_args="$@" -set -- $(get_compiler_info "$@") +set -- $(get_c_compiler_info "$@") name=$1 @@ -52,7 +52,7 @@ ICC) min_version=$($min_tool_version icc) ;; *) - echo "$orig_args: unknown compiler" >&2 + echo "$orig_args: unknown C compiler" >&2 exit 1 ;; esac @@ -62,7 +62,7 @@ min_cversion=$(get_canonical_version $min_version) if [ "$cversion" -lt "$min_cversion" ]; then echo >&2 "***" - echo >&2 "*** Compiler is too old." + echo >&2 "*** C compiler is too old." echo >&2 "*** Your $name version: $version" echo >&2 "*** Minimum $name version: $min_version" echo >&2 "***" diff --git a/scripts/generate_rust_target.rs b/scripts/generate_rust_target.rs new file mode 100644 index 000000000000..0a1ba95d74e7 --- /dev/null +++ b/scripts/generate_rust_target.rs @@ -0,0 +1,232 @@ +// SPDX-License-Identifier: GPL-2.0 + +//! The custom target specification file generator for `rustc`. +//! +//! To configure a target from scratch, a JSON-encoded file has to be passed +//! to `rustc` (introduced in [RFC 131]). These options and the file itself are +//! unstable. Eventually, `rustc` should provide a way to do this in a stable +//! manner. For instance, via command-line arguments. Therefore, this file +//! should avoid using keys which can be set via `-C` or `-Z` options. +//! +//! [RFC 131]: https://rust-lang.github.io/rfcs/0131-target-specification.html + +use std::{ + collections::HashMap, + fmt::{Display, Formatter, Result}, + io::BufRead, +}; + +enum Value { + Boolean(bool), + Number(i32), + String(String), + Object(Object), +} + +type Object = Vec<(String, Value)>; + +/// Minimal "almost JSON" generator (e.g. no `null`s, no arrays, no escaping), +/// enough for this purpose. +impl Display for Value { + fn fmt(&self, formatter: &mut Formatter<'_>) -> Result { + match self { + Value::Boolean(boolean) => write!(formatter, "{}", boolean), + Value::Number(number) => write!(formatter, "{}", number), + Value::String(string) => write!(formatter, "\"{}\"", string), + Value::Object(object) => { + formatter.write_str("{")?; + if let [ref rest @ .., ref last] = object[..] { + for (key, value) in rest { + write!(formatter, "\"{}\": {},", key, value)?; + } + write!(formatter, "\"{}\": {}", last.0, last.1)?; + } + formatter.write_str("}") + } + } + } +} + +struct TargetSpec(Object); + +impl TargetSpec { + fn new() -> TargetSpec { + TargetSpec(Vec::new()) + } +} + +trait Push { + fn push(&mut self, key: &str, value: T); +} + +impl Push for TargetSpec { + fn push(&mut self, key: &str, value: bool) { + self.0.push((key.to_string(), Value::Boolean(value))); + } +} + +impl Push for TargetSpec { + fn push(&mut self, key: &str, value: i32) { + self.0.push((key.to_string(), Value::Number(value))); + } +} + +impl Push for TargetSpec { + fn push(&mut self, key: &str, value: String) { + self.0.push((key.to_string(), Value::String(value))); + } +} + +impl Push<&str> for TargetSpec { + fn push(&mut self, key: &str, value: &str) { + self.push(key, value.to_string()); + } +} + +impl Push for TargetSpec { + fn push(&mut self, key: &str, value: Object) { + self.0.push((key.to_string(), Value::Object(value))); + } +} + +impl Display for TargetSpec { + fn fmt(&self, formatter: &mut Formatter<'_>) -> Result { + // We add some newlines for clarity. + formatter.write_str("{\n")?; + if let [ref rest @ .., ref last] = self.0[..] { + for (key, value) in rest { + write!(formatter, " \"{}\": {},\n", key, value)?; + } + write!(formatter, " \"{}\": {}\n", last.0, last.1)?; + } + formatter.write_str("}") + } +} + +struct KernelConfig(HashMap); + +impl KernelConfig { + /// Parses `include/config/auto.conf` from `stdin`. + fn from_stdin() -> KernelConfig { + let mut result = HashMap::new(); + + let stdin = std::io::stdin(); + let mut handle = stdin.lock(); + let mut line = String::new(); + + loop { + line.clear(); + + if handle.read_line(&mut line).unwrap() == 0 { + break; + } + + if line.starts_with('#') { + continue; + } + + let (key, value) = line.split_once('=').expect("Missing `=` in line."); + result.insert(key.to_string(), value.trim_end_matches('\n').to_string()); + } + + KernelConfig(result) + } + + /// Does the option exist in the configuration (any value)? + /// + /// The argument must be passed without the `CONFIG_` prefix. + /// This avoids repetition and it also avoids `fixdep` making us + /// depend on it. + fn has(&self, option: &str) -> bool { + let option = "CONFIG_".to_owned() + option; + self.0.contains_key(&option) + } +} + +fn main() { + let cfg = KernelConfig::from_stdin(); + let mut ts = TargetSpec::new(); + + // `llvm-target`s are taken from `scripts/Makefile.clang`. + if cfg.has("ARM") { + ts.push("arch", "arm"); + ts.push( + "data-layout", + "e-m:e-p:32:32-Fi8-i64:64-v128:64:128-a:0:32-n32-S64", + ); + ts.push("features", "+strict-align,+v6"); + ts.push("llvm-target", "arm-linux-gnueabi"); + ts.push("max-atomic-width", 64); + ts.push("target-mcount", "\\u0001__gnu_mcount_nc"); + ts.push("target-pointer-width", "32"); + } else if cfg.has("ARM64") { + ts.push("arch", "aarch64"); + ts.push( + "data-layout", + "e-m:e-i8:8:32-i16:16:32-i64:64-i128:128-n32:64-S128", + ); + ts.push("disable-redzone", true); + ts.push("features", "+strict-align,-neon,-fp-armv8"); + ts.push("llvm-target", "aarch64-linux-gnu"); + ts.push("max-atomic-width", 128); + ts.push("target-pointer-width", "64"); + } else if cfg.has("PPC") { + ts.push("arch", "powerpc64"); + ts.push("code-model", "large"); + ts.push("data-layout", "e-m:e-i64:64-n32:64"); + ts.push("features", "-altivec,-vsx,-hard-float"); + ts.push("llvm-target", "powerpc64le-linux-gnu"); + ts.push("max-atomic-width", 64); + ts.push("target-mcount", "_mcount"); + ts.push("target-pointer-width", "64"); + } else if cfg.has("RISCV") { + if cfg.has("64BIT") { + ts.push("arch", "riscv64"); + ts.push("data-layout", "e-m:e-p:64:64-i64:64-i128:128-n64-S128"); + ts.push("llvm-target", "riscv64-linux-gnu"); + ts.push("target-pointer-width", "64"); + } else { + ts.push("arch", "riscv32"); + ts.push("data-layout", "e-m:e-p:32:32-i64:64-n32-S128"); + ts.push("llvm-target", "riscv32-linux-gnu"); + ts.push("target-pointer-width", "32"); + } + ts.push("code-model", "medium"); + ts.push("disable-redzone", true); + let mut features = "+m,+a".to_string(); + if cfg.has("RISCV_ISA_C") { + features += ",+c"; + } + ts.push("features", features); + } else if cfg.has("X86_64") { + ts.push("arch", "x86_64"); + ts.push( + "data-layout", + "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128", + ); + let mut features = "-3dnow,-3dnowa,-mmx,+soft-float".to_string(); + if cfg.has("RETPOLINE") { + features += ",+retpoline-external-thunk"; + } + ts.push("features", features); + ts.push("llvm-target", "x86_64-linux-gnu"); + ts.push("target-pointer-width", "64"); + } else { + panic!("Unsupported architecture"); + } + + ts.push("emit-debug-gdb-scripts", false); + ts.push("frame-pointer", "may-omit"); + ts.push( + "stack-probes", + vec![("kind".to_string(), Value::String("none".to_string()))], + ); + + // Everything else is LE, whether `CPU_LITTLE_ENDIAN` is declared or not + // (e.g. x86). It is also `rustc`'s default. + if cfg.has("CPU_BIG_ENDIAN") { + ts.push("target-endian", "big"); + } + + println!("{}", ts); +} diff --git a/scripts/is_rust_module.sh b/scripts/is_rust_module.sh new file mode 100755 index 000000000000..28b3831a7593 --- /dev/null +++ b/scripts/is_rust_module.sh @@ -0,0 +1,16 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0 +# +# is_rust_module.sh module.ko +# +# Returns `0` if `module.ko` is a Rust module, `1` otherwise. + +set -e + +# Using the `16_` prefix ensures other symbols with the same substring +# are not picked up (even if it would be unlikely). The last part is +# used just in case LLVM decides to use the `.` suffix. +# +# In the future, checking for the `.comment` section may be another +# option, see https://github.com/rust-lang/rust/pull/97550. +${NM} "$*" | grep -qE '^[0-9a-fA-F]+ r _R[^[:space:]]+16___IS_RUST_MODULE[^[:space:]]*$' diff --git a/scripts/kconfig/confdata.c b/scripts/kconfig/confdata.c index c4340c90e172..b7c9f1dd5e42 100644 --- a/scripts/kconfig/confdata.c +++ b/scripts/kconfig/confdata.c @@ -216,6 +216,13 @@ static const char *conf_get_autoheader_name(void) return name ? name : "include/generated/autoconf.h"; } +static const char *conf_get_rustccfg_name(void) +{ + char *name = getenv("KCONFIG_RUSTCCFG"); + + return name ? name : "include/generated/rustc_cfg"; +} + static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p) { char *p2; @@ -605,6 +612,9 @@ static const struct comment_style comment_style_c = { static void conf_write_heading(FILE *fp, const struct comment_style *cs) { + if (!cs) + return; + fprintf(fp, "%s\n", cs->prefix); fprintf(fp, "%s Automatically generated file; DO NOT EDIT.\n", @@ -745,6 +755,65 @@ static void print_symbol_for_c(FILE *fp, struct symbol *sym) free(escaped); } +static void print_symbol_for_rustccfg(FILE *fp, struct symbol *sym) +{ + const char *val; + const char *val_prefix = ""; + char *val_prefixed = NULL; + size_t val_prefixed_len; + char *escaped = NULL; + + if (sym->type == S_UNKNOWN) + return; + + val = sym_get_string_value(sym); + + switch (sym->type) { + case S_BOOLEAN: + case S_TRISTATE: + /* + * We do not care about disabled ones, i.e. no need for + * what otherwise are "comments" in other printers. + */ + if (*val == 'n') + return; + + /* + * To have similar functionality to the C macro `IS_ENABLED()` + * we provide an empty `--cfg CONFIG_X` here in both `y` + * and `m` cases. + * + * Then, the common `fprintf()` below will also give us + * a `--cfg CONFIG_X="y"` or `--cfg CONFIG_X="m"`, which can + * be used as the equivalent of `IS_BUILTIN()`/`IS_MODULE()`. + */ + fprintf(fp, "--cfg=%s%s\n", CONFIG_, sym->name); + break; + case S_HEX: + if (val[0] != '0' || (val[1] != 'x' && val[1] != 'X')) + val_prefix = "0x"; + break; + default: + break; + } + + if (strlen(val_prefix) > 0) { + val_prefixed_len = strlen(val) + strlen(val_prefix) + 1; + val_prefixed = xmalloc(val_prefixed_len); + snprintf(val_prefixed, val_prefixed_len, "%s%s", val_prefix, val); + val = val_prefixed; + } + + /* All values get escaped: the `--cfg` option only takes strings */ + escaped = escape_string_value(val); + val = escaped; + + fprintf(fp, "--cfg=%s%s=%s\n", CONFIG_, sym->name, val); + + free(escaped); + free(val_prefixed); +} + /* * Write out a minimal config. * All values that has default values are skipped as this is redundant. @@ -1132,6 +1201,12 @@ int conf_write_autoconf(int overwrite) if (ret) return ret; + ret = __conf_write_autoconf(conf_get_rustccfg_name(), + print_symbol_for_rustccfg, + NULL); + if (ret) + return ret; + /* * Create include/config/auto.conf. This must be the last step because * Kbuild has a dependency on auto.conf and this marks the successful diff --git a/scripts/min-tool-version.sh b/scripts/min-tool-version.sh index 250925aab101..b6593eac5003 100755 --- a/scripts/min-tool-version.sh +++ b/scripts/min-tool-version.sh @@ -30,6 +30,12 @@ llvm) echo 11.0.0 fi ;; +rustc) + echo 1.62.0 + ;; +bindgen) + echo 0.56.0 + ;; *) echo "$1: unknown tool" >&2 exit 1 diff --git a/scripts/rust-is-available-bindgen-libclang.h b/scripts/rust-is-available-bindgen-libclang.h new file mode 100644 index 000000000000..0ef6db10d674 --- /dev/null +++ b/scripts/rust-is-available-bindgen-libclang.h @@ -0,0 +1,2 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#pragma message("clang version " __clang_version__) diff --git a/scripts/rust-is-available.sh b/scripts/rust-is-available.sh new file mode 100755 index 000000000000..0ddad3fcd32c --- /dev/null +++ b/scripts/rust-is-available.sh @@ -0,0 +1,160 @@ +#!/bin/sh +# SPDX-License-Identifier: GPL-2.0 +# +# Tests whether a suitable Rust toolchain is available. +# +# Pass `-v` for human output and more checks (as warnings). + +set -e + +min_tool_version=$(dirname $0)/min-tool-version.sh + +# Convert the version string x.y.z to a canonical up-to-7-digits form. +# +# Note that this function uses one more digit (compared to other +# instances in other version scripts) to give a bit more space to +# `rustc` since it will reach 1.100.0 in late 2026. +get_canonical_version() +{ + IFS=. + set -- $1 + echo $((100000 * $1 + 100 * $2 + $3)) +} + +# Check that the Rust compiler exists. +if ! command -v "$RUSTC" >/dev/null; then + if [ "$1" = -v ]; then + echo >&2 "***" + echo >&2 "*** Rust compiler '$RUSTC' could not be found." + echo >&2 "***" + fi + exit 1 +fi + +# Check that the Rust bindings generator exists. +if ! command -v "$BINDGEN" >/dev/null; then + if [ "$1" = -v ]; then + echo >&2 "***" + echo >&2 "*** Rust bindings generator '$BINDGEN' could not be found." + echo >&2 "***" + fi + exit 1 +fi + +# Check that the Rust compiler version is suitable. +# +# Non-stable and distributions' versions may have a version suffix, e.g. `-dev`. +rust_compiler_version=$( \ + LC_ALL=C "$RUSTC" --version 2>/dev/null \ + | head -n 1 \ + | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' \ +) +rust_compiler_min_version=$($min_tool_version rustc) +rust_compiler_cversion=$(get_canonical_version $rust_compiler_version) +rust_compiler_min_cversion=$(get_canonical_version $rust_compiler_min_version) +if [ "$rust_compiler_cversion" -lt "$rust_compiler_min_cversion" ]; then + if [ "$1" = -v ]; then + echo >&2 "***" + echo >&2 "*** Rust compiler '$RUSTC' is too old." + echo >&2 "*** Your version: $rust_compiler_version" + echo >&2 "*** Minimum version: $rust_compiler_min_version" + echo >&2 "***" + fi + exit 1 +fi +if [ "$1" = -v ] && [ "$rust_compiler_cversion" -gt "$rust_compiler_min_cversion" ]; then + echo >&2 "***" + echo >&2 "*** Rust compiler '$RUSTC' is too new. This may or may not work." + echo >&2 "*** Your version: $rust_compiler_version" + echo >&2 "*** Expected version: $rust_compiler_min_version" + echo >&2 "***" +fi + +# Check that the Rust bindings generator is suitable. +# +# Non-stable and distributions' versions may have a version suffix, e.g. `-dev`. +rust_bindings_generator_version=$( \ + LC_ALL=C "$BINDGEN" --version 2>/dev/null \ + | head -n 1 \ + | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' \ +) +rust_bindings_generator_min_version=$($min_tool_version bindgen) +rust_bindings_generator_cversion=$(get_canonical_version $rust_bindings_generator_version) +rust_bindings_generator_min_cversion=$(get_canonical_version $rust_bindings_generator_min_version) +if [ "$rust_bindings_generator_cversion" -lt "$rust_bindings_generator_min_cversion" ]; then + if [ "$1" = -v ]; then + echo >&2 "***" + echo >&2 "*** Rust bindings generator '$BINDGEN' is too old." + echo >&2 "*** Your version: $rust_bindings_generator_version" + echo >&2 "*** Minimum version: $rust_bindings_generator_min_version" + echo >&2 "***" + fi + exit 1 +fi +if [ "$1" = -v ] && [ "$rust_bindings_generator_cversion" -gt "$rust_bindings_generator_min_cversion" ]; then + echo >&2 "***" + echo >&2 "*** Rust bindings generator '$BINDGEN' is too new. This may or may not work." + echo >&2 "*** Your version: $rust_bindings_generator_version" + echo >&2 "*** Expected version: $rust_bindings_generator_min_version" + echo >&2 "***" +fi + +# Check that the `libclang` used by the Rust bindings generator is suitable. +bindgen_libclang_version=$( \ + LC_ALL=C "$BINDGEN" $(dirname $0)/rust-is-available-bindgen-libclang.h 2>&1 >/dev/null \ + | grep -F 'clang version ' \ + | grep -oE '[0-9]+\.[0-9]+\.[0-9]+' \ + | head -n 1 \ +) +bindgen_libclang_min_version=$($min_tool_version llvm) +bindgen_libclang_cversion=$(get_canonical_version $bindgen_libclang_version) +bindgen_libclang_min_cversion=$(get_canonical_version $bindgen_libclang_min_version) +if [ "$bindgen_libclang_cversion" -lt "$bindgen_libclang_min_cversion" ]; then + if [ "$1" = -v ]; then + echo >&2 "***" + echo >&2 "*** libclang (used by the Rust bindings generator '$BINDGEN') is too old." + echo >&2 "*** Your version: $bindgen_libclang_version" + echo >&2 "*** Minimum version: $bindgen_libclang_min_version" + echo >&2 "***" + fi + exit 1 +fi + +# If the C compiler is Clang, then we can also check whether its version +# matches the `libclang` version used by the Rust bindings generator. +# +# In the future, we might be able to perform a full version check, see +# https://github.com/rust-lang/rust-bindgen/issues/2138. +if [ "$1" = -v ]; then + cc_name=$($(dirname $0)/cc-version.sh "$CC" | cut -f1 -d' ') + if [ "$cc_name" = Clang ]; then + clang_version=$( \ + LC_ALL=C "$CC" --version 2>/dev/null \ + | sed -nE '1s:.*version ([0-9]+\.[0-9]+\.[0-9]+).*:\1:p' + ) + if [ "$clang_version" != "$bindgen_libclang_version" ]; then + echo >&2 "***" + echo >&2 "*** libclang (used by the Rust bindings generator '$BINDGEN')" + echo >&2 "*** version does not match Clang's. This may be a problem." + echo >&2 "*** libclang version: $bindgen_libclang_version" + echo >&2 "*** Clang version: $clang_version" + echo >&2 "***" + fi + fi +fi + +# Check that the source code for the `core` standard library exists. +# +# `$KRUSTFLAGS` is passed in case the user added `--sysroot`. +rustc_sysroot=$("$RUSTC" $KRUSTFLAGS --print sysroot) +rustc_src=${RUST_LIB_SRC:-"$rustc_sysroot/lib/rustlib/src/rust/library"} +rustc_src_core="$rustc_src/core/src/lib.rs" +if [ ! -e "$rustc_src_core" ]; then + if [ "$1" = -v ]; then + echo >&2 "***" + echo >&2 "*** Source code for the 'core' standard library could not be found" + echo >&2 "*** at '$rustc_src_core'." + echo >&2 "***" + fi + exit 1 +fi -- 2.37.1 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 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 smtp.lore.kernel.org (Postfix) with ESMTPS id E5EA9C19F2C for ; Tue, 2 Aug 2022 01:55:15 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=vH7oEdv5PRiHo26XnhPX+Q8k867QNQhd46b4EceZ6sA=; b=WuqaBa8Iyew29J 0hyfZs2/Tveglr7kGbzKHF5K6W9cry+RmC+uQbH5eqBEDsKL7FW7adV8aEjSdyrf130xwC9zkoS/9 IEjddgsfHjZPcMyqjtPL+voUwqsFJiWlON8XH5csBTQuTtGSfRg5JZuGBrhXg6zOW50pQonhpsmj7 aMedT0R4Tg4SlfvV4xFxvqqY5+Ey2hiCXVXhr11wWB2X3h1DoubA58HOtM9GMVg5oEzJU6/CA6GNO 1/FrpB8MJOl1PacCf7jGhPic42iqMTI5jxGm6D1TmU4aQW1cgVYfNc/W2NbTVw0FxysDofHT0sczh gKncBg8MopawjLZDP+uw==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1oIh6c-009nQt-3G; Tue, 02 Aug 2022 01:53:58 +0000 Received: from dfw.source.kernel.org ([2604:1380:4641:c500::1]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1oIh6V-009nJ6-8t; Tue, 02 Aug 2022 01:53:56 +0000 Received: from smtp.kernel.org (relay.kernel.org [52.25.139.140]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by dfw.source.kernel.org (Postfix) with ESMTPS id 8CB8561072; Tue, 2 Aug 2022 01:53:50 +0000 (UTC) Received: by smtp.kernel.org (Postfix) with ESMTPSA id 6C662C433D6; Tue, 2 Aug 2022 01:53:38 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1659405229; bh=GORFM1idi3kTQnV6VihqUFIxcib5JgKkOuMTQPkEH70=; h=From:To:Cc:Subject:Date:In-Reply-To:References:From; b=Vq+z0xXjfjbWIMydJCs9sw6LD8Q6gLO3b+HF9QB2QiC3PgjJGIQM0EGENZHVGeErl AI0+mjRgSgjYRc+Qs4M3sydA826IfENNy2Q6kyRFksJAurGqsN0DRmxguxdgWbxU1p CUHNqk6fCc4HFyE2SdqhnfGMGCcKEG7kCv+OHqqhfj6e/y7zipuiHkcdwPqo6RUaAj WzRuXbzUMJO2P3IjmKQtNQaiUnhfvOQyZGnjD7GYcsyBuWoZY9hs1v3UsW7qz96bqs G7qHrOuaCUQMvoiYKiC+Pfy8tmOkc7O0DqjkaUCklJf3KkO2eY/Jjx92O46wrWyeKI BakcCxFD8Yyjg== From: Miguel Ojeda To: Linus Torvalds , Greg Kroah-Hartman Cc: rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, Jarkko Sakkinen , Miguel Ojeda , Alex Gaynor , Finn Behrens , Adam Bratschi-Kaye , Wedson Almeida Filho , Michael Ellerman , Sven Van Asbroeck , Gary Guo , Boris-Chengbiao Zhou , Boqun Feng , Douglas Su , Dariusz Sosnowski , Antonio Terceiro , Daniel Xu , Miguel Cano , David Gow , Tiago Lam , =?UTF-8?q?Bj=C3=B6rn=20Roy=20Baron?= , Martin Rodriguez Reboredo , Masahiro Yamada , Michal Marek , Nick Desaulniers , Russell King , Catalin Marinas , Will Deacon , Benjamin Herrenschmidt , Paul Mackerras , Paul Walmsley , Palmer Dabbelt , Albert Ou , Richard Weinberger , Anton Ivanov , Johannes Berg , Thomas Gleixner , Ingo Molnar , Borislav Petkov , Dave Hansen , x86@kernel.org, "H. Peter Anvin" , linux-kbuild@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linuxppc-dev@lists.ozlabs.org, linux-riscv@lists.infradead.org, linux-um@lists.infradead.org Subject: [PATCH v8 27/31] Kbuild: add Rust support Date: Tue, 2 Aug 2022 03:50:14 +0200 Message-Id: <20220802015052.10452-28-ojeda@kernel.org> In-Reply-To: <20220802015052.10452-1-ojeda@kernel.org> References: <20220802015052.10452-1-ojeda@kernel.org> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20220801_185351_567550_4B412C5B X-CRM114-Status: GOOD ( 25.67 ) X-BeenThere: linux-arm-kernel@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , 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 SGF2aW5nIGFsbCB0aGUgbmV3IGZpbGVzIGluIHBsYWNlLCB3ZSBub3cgZW5hYmxlIFJ1c3Qgc3Vw cG9ydAppbiB0aGUgYnVpbGQgc3lzdGVtLCBpbmNsdWRpbmcgYEtjb25maWdgIGVudHJpZXMgcmVs YXRlZCB0byBSdXN0LAp0aGUgUnVzdCBjb25maWd1cmF0aW9uIHByaW50ZXIsIHRoZSB0YXJnZXQg c3BlY2lmaWNhdGlvbgpnZW5lcmF0aW9uIHNjcmlwdCwgdGhlIHZlcnNpb24gZGV0ZWN0aW9uIHNj cmlwdCBhbmQgYSBmZXcKb3RoZXIgYml0cy4KCkNvLWRldmVsb3BlZC1ieTogQWxleCBHYXlub3Ig PGFsZXguZ2F5bm9yQGdtYWlsLmNvbT4KU2lnbmVkLW9mZi1ieTogQWxleCBHYXlub3IgPGFsZXgu Z2F5bm9yQGdtYWlsLmNvbT4KQ28tZGV2ZWxvcGVkLWJ5OiBGaW5uIEJlaHJlbnMgPG1lQGtsb2Vu ay5kZT4KU2lnbmVkLW9mZi1ieTogRmlubiBCZWhyZW5zIDxtZUBrbG9lbmsuZGU+CkNvLWRldmVs b3BlZC1ieTogQWRhbSBCcmF0c2NoaS1LYXllIDxhcmsuZW1haWxAZ21haWwuY29tPgpTaWduZWQt b2ZmLWJ5OiBBZGFtIEJyYXRzY2hpLUtheWUgPGFyay5lbWFpbEBnbWFpbC5jb20+CkNvLWRldmVs b3BlZC1ieTogV2Vkc29uIEFsbWVpZGEgRmlsaG8gPHdlZHNvbmFmQGdvb2dsZS5jb20+ClNpZ25l ZC1vZmYtYnk6IFdlZHNvbiBBbG1laWRhIEZpbGhvIDx3ZWRzb25hZkBnb29nbGUuY29tPgpDby1k ZXZlbG9wZWQtYnk6IE1pY2hhZWwgRWxsZXJtYW4gPG1wZUBlbGxlcm1hbi5pZC5hdT4KU2lnbmVk LW9mZi1ieTogTWljaGFlbCBFbGxlcm1hbiA8bXBlQGVsbGVybWFuLmlkLmF1PgpDby1kZXZlbG9w ZWQtYnk6IFN2ZW4gVmFuIEFzYnJvZWNrIDx0aGVzdmVuNzNAZ21haWwuY29tPgpTaWduZWQtb2Zm LWJ5OiBTdmVuIFZhbiBBc2Jyb2VjayA8dGhlc3ZlbjczQGdtYWlsLmNvbT4KQ28tZGV2ZWxvcGVk LWJ5OiBHYXJ5IEd1byA8Z2FyeUBnYXJ5Z3VvLm5ldD4KU2lnbmVkLW9mZi1ieTogR2FyeSBHdW8g PGdhcnlAZ2FyeWd1by5uZXQ+CkNvLWRldmVsb3BlZC1ieTogQm9yaXMtQ2hlbmdiaWFvIFpob3Ug PGJvYm8xMjM5QHdlYi5kZT4KU2lnbmVkLW9mZi1ieTogQm9yaXMtQ2hlbmdiaWFvIFpob3UgPGJv Ym8xMjM5QHdlYi5kZT4KQ28tZGV2ZWxvcGVkLWJ5OiBCb3F1biBGZW5nIDxib3F1bi5mZW5nQGdt YWlsLmNvbT4KU2lnbmVkLW9mZi1ieTogQm9xdW4gRmVuZyA8Ym9xdW4uZmVuZ0BnbWFpbC5jb20+ CkNvLWRldmVsb3BlZC1ieTogRG91Z2xhcyBTdSA8ZDB1OS5zdUBvdXRsb29rLmNvbT4KU2lnbmVk LW9mZi1ieTogRG91Z2xhcyBTdSA8ZDB1OS5zdUBvdXRsb29rLmNvbT4KQ28tZGV2ZWxvcGVkLWJ5 OiBEYXJpdXN6IFNvc25vd3NraSA8ZHNvc25vd3NraUBkc29zbm93c2tpLnBsPgpTaWduZWQtb2Zm LWJ5OiBEYXJpdXN6IFNvc25vd3NraSA8ZHNvc25vd3NraUBkc29zbm93c2tpLnBsPgpDby1kZXZl bG9wZWQtYnk6IEFudG9uaW8gVGVyY2Vpcm8gPGFudG9uaW8udGVyY2Vpcm9AbGluYXJvLm9yZz4K U2lnbmVkLW9mZi1ieTogQW50b25pbyBUZXJjZWlybyA8YW50b25pby50ZXJjZWlyb0BsaW5hcm8u b3JnPgpDby1kZXZlbG9wZWQtYnk6IERhbmllbCBYdSA8ZHh1QGR4dXV1Lnh5ej4KU2lnbmVkLW9m Zi1ieTogRGFuaWVsIFh1IDxkeHVAZHh1dXUueHl6PgpDby1kZXZlbG9wZWQtYnk6IE1pZ3VlbCBD YW5vIDxtYWNhbnJvakBnbWFpbC5jb20+ClNpZ25lZC1vZmYtYnk6IE1pZ3VlbCBDYW5vIDxtYWNh bnJvakBnbWFpbC5jb20+CkNvLWRldmVsb3BlZC1ieTogRGF2aWQgR293IDxkYXZpZGdvd0Bnb29n bGUuY29tPgpTaWduZWQtb2ZmLWJ5OiBEYXZpZCBHb3cgPGRhdmlkZ293QGdvb2dsZS5jb20+CkNv LWRldmVsb3BlZC1ieTogVGlhZ28gTGFtIDx0aWFnb2xhbUBnbWFpbC5jb20+ClNpZ25lZC1vZmYt Ynk6IFRpYWdvIExhbSA8dGlhZ29sYW1AZ21haWwuY29tPgpDby1kZXZlbG9wZWQtYnk6IEJqw7Zy biBSb3kgQmFyb24gPGJqb3JuM19naEBwcm90b25tYWlsLmNvbT4KU2lnbmVkLW9mZi1ieTogQmrD tnJuIFJveSBCYXJvbiA8Ympvcm4zX2doQHByb3Rvbm1haWwuY29tPgpDby1kZXZlbG9wZWQtYnk6 IE1hcnRpbiBSb2RyaWd1ZXogUmVib3JlZG8gPHlha295b2t1QGdtYWlsLmNvbT4KU2lnbmVkLW9m Zi1ieTogTWFydGluIFJvZHJpZ3VleiBSZWJvcmVkbyA8eWFrb3lva3VAZ21haWwuY29tPgpTaWdu ZWQtb2ZmLWJ5OiBNaWd1ZWwgT2plZGEgPG9qZWRhQGtlcm5lbC5vcmc+Ci0tLQogLmdpdGlnbm9y ZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDYgKwogLnJ1c3RmbXQudG9t bCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgMTIgKwogTWFrZWZpbGUgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAxNzIgKysrKysrKy0KIGFyY2gvS2NvbmZp ZyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICA2ICsKIGFyY2gvYXJtL0tjb25m aWcgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvYXJtNjQvS2NvbmZp ZyAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvcG93ZXJwYy9LY29uZmln ICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvcmlzY3YvS2NvbmZpZyAgICAg ICAgICAgICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gvcmlzY3YvTWFrZWZpbGUgICAgICAg ICAgICAgICAgICAgICAgICAgIHwgICA1ICsKIGFyY2gvdW0vS2NvbmZpZyAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIHwgICAxICsKIGFyY2gveDg2L0tjb25maWcgICAgICAgICAgICAgICAg ICAgICAgICAgICAgIHwgICAxICsKIGFyY2gveDg2L01ha2VmaWxlICAgICAgICAgICAgICAgICAg ICAgICAgICAgIHwgIDEwICsKIGluY2x1ZGUvbGludXgvY29tcGlsZXJfdHlwZXMuaCAgICAgICAg ICAgICAgIHwgICA2ICstCiBpbml0L0tjb25maWcgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICB8ICA0NiArLQogbGliL0tjb25maWcuZGVidWcgICAgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgODIgKysrKwogcnVzdC8uZ2l0aWdub3JlICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgfCAgMTAgKwogcnVzdC9NYWtlZmlsZSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg fCA0MTUgKysrKysrKysrKysrKysrKysrKwogcnVzdC9iaW5kZ2VuX3BhcmFtZXRlcnMgICAgICAg ICAgICAgICAgICAgICAgfCAgMjEgKwogc2NyaXB0cy8uZ2l0aWdub3JlICAgICAgICAgICAgICAg ICAgICAgICAgICAgfCAgIDEgKwogc2NyaXB0cy9LY29uZmlnLmluY2x1ZGUgICAgICAgICAgICAg ICAgICAgICAgfCAgIDYgKy0KIHNjcmlwdHMvTWFrZWZpbGUgICAgICAgICAgICAgICAgICAgICAg ICAgICAgIHwgICAzICsKIHNjcmlwdHMvTWFrZWZpbGUuYnVpbGQgICAgICAgICAgICAgICAgICAg ICAgIHwgIDYwICsrKwogc2NyaXB0cy9NYWtlZmlsZS5kZWJ1ZyAgICAgICAgICAgICAgICAgICAg ICAgfCAgMTAgKwogc2NyaXB0cy9NYWtlZmlsZS5ob3N0ICAgICAgICAgICAgICAgICAgICAgICAg fCAgMzQgKy0KIHNjcmlwdHMvTWFrZWZpbGUubGliICAgICAgICAgICAgICAgICAgICAgICAgIHwg IDEyICsKIHNjcmlwdHMvTWFrZWZpbGUubW9kZmluYWwgICAgICAgICAgICAgICAgICAgIHwgICA4 ICstCiBzY3JpcHRzL2NjLXZlcnNpb24uc2ggICAgICAgICAgICAgICAgICAgICAgICB8ICAxMiAr LQogc2NyaXB0cy9nZW5lcmF0ZV9ydXN0X3RhcmdldC5ycyAgICAgICAgICAgICAgfCAyMzIgKysr KysrKysrKysKIHNjcmlwdHMvaXNfcnVzdF9tb2R1bGUuc2ggICAgICAgICAgICAgICAgICAgIHwg IDE2ICsKIHNjcmlwdHMva2NvbmZpZy9jb25mZGF0YS5jICAgICAgICAgICAgICAgICAgIHwgIDc1 ICsrKysKIHNjcmlwdHMvbWluLXRvb2wtdmVyc2lvbi5zaCAgICAgICAgICAgICAgICAgIHwgICA2 ICsKIHNjcmlwdHMvcnVzdC1pcy1hdmFpbGFibGUtYmluZGdlbi1saWJjbGFuZy5oIHwgICAyICsK IHNjcmlwdHMvcnVzdC1pcy1hdmFpbGFibGUuc2ggICAgICAgICAgICAgICAgIHwgMTYwICsrKysr KysKIDMzIGZpbGVzIGNoYW5nZWQsIDE0MDggaW5zZXJ0aW9ucygrKSwgMjYgZGVsZXRpb25zKC0p CiBjcmVhdGUgbW9kZSAxMDA2NDQgLnJ1c3RmbXQudG9tbAogY3JlYXRlIG1vZGUgMTAwNjQ0IHJ1 c3QvLmdpdGlnbm9yZQogY3JlYXRlIG1vZGUgMTAwNjQ0IHJ1c3QvTWFrZWZpbGUKIGNyZWF0ZSBt b2RlIDEwMDY0NCBydXN0L2JpbmRnZW5fcGFyYW1ldGVycwogY3JlYXRlIG1vZGUgMTAwNjQ0IHNj cmlwdHMvZ2VuZXJhdGVfcnVzdF90YXJnZXQucnMKIGNyZWF0ZSBtb2RlIDEwMDc1NSBzY3JpcHRz L2lzX3J1c3RfbW9kdWxlLnNoCiBjcmVhdGUgbW9kZSAxMDA2NDQgc2NyaXB0cy9ydXN0LWlzLWF2 YWlsYWJsZS1iaW5kZ2VuLWxpYmNsYW5nLmgKIGNyZWF0ZSBtb2RlIDEwMDc1NSBzY3JpcHRzL3J1 c3QtaXMtYXZhaWxhYmxlLnNoCgpkaWZmIC0tZ2l0IGEvLmdpdGlnbm9yZSBiLy5naXRpZ25vcmUK aW5kZXggMjY1OTU5NTQ0OTc4Li41ZGEwMDQ4MTQ2NzggMTAwNjQ0Ci0tLSBhLy5naXRpZ25vcmUK KysrIGIvLmdpdGlnbm9yZQpAQCAtMzcsNiArMzcsOCBAQAogKi5vCiAqLm8uKgogKi5wYXRjaAor Ki5ybWV0YQorKi5yc2kKICoucwogKi5zbwogKi5zby5kYmcKQEAgLTk3LDYgKzk5LDcgQEAgbW9k dWxlcy5vcmRlcgogIS5naXRhdHRyaWJ1dGVzCiAhLmdpdGlnbm9yZQogIS5tYWlsbWFwCishLnJ1 c3RmbXQudG9tbAogCiAjCiAjIEdlbmVyYXRlZCBpbmNsdWRlIGZpbGVzCkBAIC0xNjIsMyArMTY1 LDYgQEAgeDUwOS5nZW5rZXkKIAogIyBEb2N1bWVudGF0aW9uIHRvb2xjaGFpbgogc3BoaW54Xyov CisKKyMgUnVzdCBhbmFseXplciBjb25maWd1cmF0aW9uCisvcnVzdC1wcm9qZWN0Lmpzb24KZGlm ZiAtLWdpdCBhLy5ydXN0Zm10LnRvbWwgYi8ucnVzdGZtdC50b21sCm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uM2RlNWNjNDk3NDY1Ci0tLSAvZGV2L251bGwKKysrIGIv LnJ1c3RmbXQudG9tbApAQCAtMCwwICsxLDEyIEBACitlZGl0aW9uID0gIjIwMjEiCituZXdsaW5l X3N0eWxlID0gIlVuaXgiCisKKyMgVW5zdGFibGUgb3B0aW9ucyB0aGF0IGhlbHAgY2F0Y2hpbmcg c29tZSBtaXN0YWtlcyBpbiBmb3JtYXR0aW5nIGFuZCB0aGF0IHdlIG1heSB3YW50IHRvIGVuYWJs ZQorIyB3aGVuIHRoZXkgYmVjb21lIHN0YWJsZS4KKyMKKyMgVGhleSBhcmUga2VwdCBoZXJlIHNp bmNlIHRoZXkgYXJlIHVzZWZ1bCB0byBydW4gZnJvbSB0aW1lIHRvIHRpbWUuCisjZm9ybWF0X2Nv ZGVfaW5fZG9jX2NvbW1lbnRzID0gdHJ1ZQorI3Jlb3JkZXJfaW1wbF9pdGVtcyA9IHRydWUKKyNj b21tZW50X3dpZHRoID0gMTAwCisjd3JhcF9jb21tZW50cyA9IHRydWUKKyNub3JtYWxpemVfY29t bWVudHMgPSB0cnVlCmRpZmYgLS1naXQgYS9NYWtlZmlsZSBiL01ha2VmaWxlCmluZGV4IGRmOTI4 OTIzMjVhZS4uY2QxZDU0NWYzMTZiIDEwMDY0NAotLS0gYS9NYWtlZmlsZQorKysgYi9NYWtlZmls ZQpAQCAtMTIwLDYgKzEyMCwxNSBAQCBlbmRpZgogCiBleHBvcnQgS0JVSUxEX0NIRUNLU1JDCiAK KyMgRW5hYmxlICJjbGlwcHkiIChhIGxpbnRlcikgYXMgcGFydCBvZiB0aGUgUnVzdCBjb21waWxh dGlvbi4KKyMKKyMgVXNlICdtYWtlIENMSVBQWT0xJyB0byBlbmFibGUgaXQuCitpZmVxICgiJChv cmlnaW4gQ0xJUFBZKSIsICJjb21tYW5kIGxpbmUiKQorICBLQlVJTERfQ0xJUFBZIDo9ICQoQ0xJ UFBZKQorZW5kaWYKKworZXhwb3J0IEtCVUlMRF9DTElQUFkKKwogIyBVc2UgbWFrZSBNPWRpciBv ciBzZXQgdGhlIGVudmlyb25tZW50IHZhcmlhYmxlIEtCVUlMRF9FWFRNT0QgdG8gc3BlY2lmeSB0 aGUKICMgZGlyZWN0b3J5IG9mIGV4dGVybmFsIG1vZHVsZSB0byBidWlsZC4gU2V0dGluZyBNPSB0 YWtlcyBwcmVjZWRlbmNlLgogaWZlcSAoIiQob3JpZ2luIE0pIiwgImNvbW1hbmQgbGluZSIpCkBA IC0yNjcsMTQgKzI3NiwxNCBAQCBuby1kb3QtY29uZmlnLXRhcmdldHMgOj0gJChjbGVhbi10YXJn ZXRzKSBcCiAJCQkgY3Njb3BlIGd0YWdzIFRBR1MgdGFncyBoZWxwJSAlZG9jcyBjaGVjayUgY29j Y2ljaGVjayBcCiAJCQkgJCh2ZXJzaW9uX2gpIGhlYWRlcnMgaGVhZGVyc18lIGFyY2hoZWFkZXJz IGFyY2hzY3JpcHRzIFwKIAkJCSAlYXNtLWdlbmVyaWMga2VybmVsdmVyc2lvbiAlc3JjLXBrZyBk dF9iaW5kaW5nX2NoZWNrIFwKLQkJCSBvdXRwdXRtYWtlZmlsZQorCQkJIG91dHB1dG1ha2VmaWxl IHJ1c3RhdmFpbGFibGUgcnVzdGZtdCBydXN0Zm10Y2hlY2sKICMgSW5zdGFsbGF0aW9uIHRhcmdl dHMgc2hvdWxkIG5vdCByZXF1aXJlIGNvbXBpbGVyLiBVbmZvcnR1bmF0ZWx5LCB2ZHNvX2luc3Rh bGwKICMgaXMgYW4gZXhjZXB0aW9uIHdoZXJlIGJ1aWxkIGFydGlmYWN0cyBtYXkgYmUgdXBkYXRl ZC4gVGhpcyBtdXN0IGJlIGZpeGVkLgogbm8tY29tcGlsZXItdGFyZ2V0cyA6PSAkKG5vLWRvdC1j b25maWctdGFyZ2V0cykgaW5zdGFsbCBkdGJzX2luc3RhbGwgXAogCQkJaGVhZGVyc19pbnN0YWxs IG1vZHVsZXNfaW5zdGFsbCBrZXJuZWxyZWxlYXNlIGltYWdlX25hbWUKIG5vLXN5bmMtY29uZmln LXRhcmdldHMgOj0gJChuby1kb3QtY29uZmlnLXRhcmdldHMpICVpbnN0YWxsIGtlcm5lbHJlbGVh c2UgXAogCQkJICBpbWFnZV9uYW1lCi1zaW5nbGUtdGFyZ2V0cyA6PSAlLmEgJS5pICUua28gJS5s ZHMgJS5sbCAlLmxzdCAlLm1vZCAlLm8gJS5zICUuc3ltdHlwZXMgJS8KK3NpbmdsZS10YXJnZXRz IDo9ICUuYSAlLmkgJS5yc2kgJS5rbyAlLmxkcyAlLmxsICUubHN0ICUubW9kICUubyAlLnMgJS5z eW10eXBlcyAlLwogCiBjb25maWctYnVpbGQJOj0KIG1peGVkLWJ1aWxkCTo9CkBAIC00MzYsNiAr NDQ1LDcgQEAgZWxzZQogSE9TVENDCT0gZ2NjCiBIT1NUQ1hYCT0gZysrCiBlbmRpZgorSE9TVFJV U1RDID0gcnVzdGMKIEhPU1RQS0dfQ09ORklHCT0gcGtnLWNvbmZpZwogCiBLQlVJTERfVVNFUkhP U1RDRkxBR1MgOj0gLVdhbGwgLVdtaXNzaW5nLXByb3RvdHlwZXMgLVdzdHJpY3QtcHJvdG90eXBl cyBcCkBAIC00NDQsOCArNDU0LDI2IEBAIEtCVUlMRF9VU0VSSE9TVENGTEFHUyA6PSAtV2FsbCAt V21pc3NpbmctcHJvdG90eXBlcyAtV3N0cmljdC1wcm90b3R5cGVzIFwKIEtCVUlMRF9VU0VSQ0ZM QUdTICA6PSAkKEtCVUlMRF9VU0VSSE9TVENGTEFHUykgJChVU0VSQ0ZMQUdTKQogS0JVSUxEX1VT RVJMREZMQUdTIDo9ICQoVVNFUkxERkxBR1MpCiAKKyMgVGhlc2UgZmxhZ3MgYXBwbHkgdG8gYWxs IFJ1c3QgY29kZSBpbiB0aGUgdHJlZSwgaW5jbHVkaW5nIHRoZSBrZXJuZWwgYW5kCisjIGhvc3Qg cHJvZ3JhbXMuCitleHBvcnQgcnVzdF9jb21tb25fZmxhZ3MgOj0gLS1lZGl0aW9uPTIwMjEgXAor CQkJICAgIC1aYmluYXJ5X2RlcF9kZXBpbmZvPXkgXAorCQkJICAgIC1EdW5zYWZlX29wX2luX3Vu c2FmZV9mbiAtRHJ1c3RfMjAxOF9pZGlvbXMgXAorCQkJICAgIC1EdW5yZWFjaGFibGVfcHViIC1E bm9uX2FzY2lpX2lkZW50cyBcCisJCQkgICAgLVdtaXNzaW5nX2RvY3MgXAorCQkJICAgIC1EcnVz dGRvYzo6bWlzc2luZ19jcmF0ZV9sZXZlbF9kb2NzIFwKKwkJCSAgICAtRGNsaXBweTo6Y29ycmVj dG5lc3MgLURjbGlwcHk6OnN0eWxlIFwKKwkJCSAgICAtRGNsaXBweTo6c3VzcGljaW91cyAtRGNs aXBweTo6Y29tcGxleGl0eSBcCisJCQkgICAgLURjbGlwcHk6OnBlcmYgXAorCQkJICAgIC1EY2xp cHB5OjpsZXRfdW5pdF92YWx1ZSAtRGNsaXBweTo6bXV0X211dCBcCisJCQkgICAgLURjbGlwcHk6 Om5lZWRsZXNzX2JpdHdpc2VfYm9vbCBcCisJCQkgICAgLURjbGlwcHk6Om5lZWRsZXNzX2NvbnRp bnVlIFwKKwkJCSAgICAtV2NsaXBweTo6ZGJnX21hY3JvCisKIEtCVUlMRF9IT1NUQ0ZMQUdTICAg Oj0gJChLQlVJTERfVVNFUkhPU1RDRkxBR1MpICQoSE9TVF9MRlNfQ0ZMQUdTKSAkKEhPU1RDRkxB R1MpCiBLQlVJTERfSE9TVENYWEZMQUdTIDo9IC1XYWxsIC1PMiAkKEhPU1RfTEZTX0NGTEFHUykg JChIT1NUQ1hYRkxBR1MpCitLQlVJTERfSE9TVFJVU1RGTEFHUyA6PSAkKHJ1c3RfY29tbW9uX2Zs YWdzKSAtTyAtQ3N0cmlwPWRlYnVnaW5mbyBcCisJCQktWmFsbG93LWZlYXR1cmVzPSAkKEhPU1RS VVNURkxBR1MpCiBLQlVJTERfSE9TVExERkxBR1MgIDo9ICQoSE9TVF9MRlNfTERGTEFHUykgJChI T1NUTERGTEFHUykKIEtCVUlMRF9IT1NUTERMSUJTICAgOj0gJChIT1NUX0xGU19MSUJTKSAkKEhP U1RMRExJQlMpCiAKQEAgLTQ3MCw2ICs0OTgsMTIgQEAgT0JKRFVNUAkJPSAkKENST1NTX0NPTVBJ TEUpb2JqZHVtcAogUkVBREVMRgkJPSAkKENST1NTX0NPTVBJTEUpcmVhZGVsZgogU1RSSVAJCT0g JChDUk9TU19DT01QSUxFKXN0cmlwCiBlbmRpZgorUlVTVEMJCT0gcnVzdGMKK1JVU1RET0MJCT0g cnVzdGRvYworUlVTVEZNVAkJPSBydXN0Zm10CitDTElQUFlfRFJJVkVSCT0gY2xpcHB5LWRyaXZl cgorQklOREdFTgkJPSBiaW5kZ2VuCitDQVJHTwkJPSBjYXJnbwogUEFIT0xFCQk9IHBhaG9sZQog UkVTT0xWRV9CVEZJRFMJPSAkKG9ianRyZWUpL3Rvb2xzL2JwZi9yZXNvbHZlX2J0Zmlkcy9yZXNv bHZlX2J0ZmlkcwogTEVYCQk9IGZsZXgKQEAgLTQ5NSw5ICs1MjksMTEgQEAgQ0hFQ0tGTEFHUyAg ICAgOj0gLURfX2xpbnV4X18gLURsaW51eCAtRF9fU1REQ19fIC1EdW5peCAtRF9fdW5peF9fIFwK IAkJICAtV2JpdHdpc2UgLVduby1yZXR1cm4tdm9pZCAtV25vLXVua25vd24tYXR0cmlidXRlICQo Q0YpCiBOT1NURElOQ19GTEFHUyA6PQogQ0ZMQUdTX01PRFVMRSAgID0KK1JVU1RGTEFHU19NT0RV TEUgPQogQUZMQUdTX01PRFVMRSAgID0KIExERkxBR1NfTU9EVUxFICA9CiBDRkxBR1NfS0VSTkVM CT0KK1JVU1RGTEFHU19LRVJORUwgPQogQUZMQUdTX0tFUk5FTAk9CiBMREZMQUdTX3ZtbGludXgg PQogCkBAIC01MjYsMTUgKzU2Miw0MiBAQCBLQlVJTERfQ0ZMQUdTICAgOj0gLVdhbGwgLVd1bmRl ZiAtV2Vycm9yPXN0cmljdC1wcm90b3R5cGVzIC1Xbm8tdHJpZ3JhcGhzIFwKIAkJICAgLVdlcnJv cj1yZXR1cm4tdHlwZSAtV25vLWZvcm1hdC1zZWN1cml0eSBcCiAJCSAgIC1zdGQ9Z251MTEKIEtC VUlMRF9DUFBGTEFHUyA6PSAtRF9fS0VSTkVMX18KK0tCVUlMRF9SVVNURkxBR1MgOj0gJChydXN0 X2NvbW1vbl9mbGFncykgXAorCQkgICAgLS10YXJnZXQ9JChvYmp0cmVlKS9ydXN0L3RhcmdldC5q c29uIFwKKwkJICAgIC1DcGFuaWM9YWJvcnQgLUNlbWJlZC1iaXRjb2RlPW4gLUNsdG89biBcCisJ CSAgICAtQ2ZvcmNlLXVud2luZC10YWJsZXM9biAtQ2NvZGVnZW4tdW5pdHM9MSBcCisJCSAgICAt Q3N5bWJvbC1tYW5nbGluZy12ZXJzaW9uPXYwIFwKKwkJICAgIC1DcmVsb2NhdGlvbi1tb2RlbD1z dGF0aWMgXAorCQkgICAgLVpmdW5jdGlvbi1zZWN0aW9ucz1uIFwKKwkJICAgIC1EY2xpcHB5Ojpm bG9hdF9hcml0aG1ldGljCisKIEtCVUlMRF9BRkxBR1NfS0VSTkVMIDo9CiBLQlVJTERfQ0ZMQUdT X0tFUk5FTCA6PQorS0JVSUxEX1JVU1RGTEFHU19LRVJORUwgOj0KIEtCVUlMRF9BRkxBR1NfTU9E VUxFICA6PSAtRE1PRFVMRQogS0JVSUxEX0NGTEFHU19NT0RVTEUgIDo9IC1ETU9EVUxFCitLQlVJ TERfUlVTVEZMQUdTX01PRFVMRSA6PSAtLWNmZyBNT0RVTEUKIEtCVUlMRF9MREZMQUdTX01PRFVM RSA6PQogS0JVSUxEX0xERkxBR1MgOj0KIENMQU5HX0ZMQUdTIDo9CiAKK2lmZXEgKCQoS0JVSUxE X0NMSVBQWSksMSkKKwlSVVNUQ19PUl9DTElQUFlfUVVJRVQgOj0gQ0xJUFBZCisJUlVTVENfT1Jf Q0xJUFBZID0gJChDTElQUFlfRFJJVkVSKQorZWxzZQorCVJVU1RDX09SX0NMSVBQWV9RVUlFVCA6 PSBSVVNUQworCVJVU1RDX09SX0NMSVBQWSA9ICQoUlVTVEMpCitlbmRpZgorCitpZmRlZiBSVVNU X0xJQl9TUkMKKwlleHBvcnQgUlVTVF9MSUJfU1JDCitlbmRpZgorCitleHBvcnQgUlVTVENfQk9P VFNUUkFQIDo9IDEKKwogZXhwb3J0IEFSQ0ggU1JDQVJDSCBDT05GSUdfU0hFTEwgQkFTSCBIT1NU Q0MgS0JVSUxEX0hPU1RDRkxBR1MgQ1JPU1NfQ09NUElMRSBMRCBDQyBIT1NUUEtHX0NPTkZJRwor ZXhwb3J0IFJVU1RDIFJVU1RET0MgUlVTVEZNVCBSVVNUQ19PUl9DTElQUFlfUVVJRVQgUlVTVENf T1JfQ0xJUFBZIEJJTkRHRU4gQ0FSR08KK2V4cG9ydCBIT1NUUlVTVEMgS0JVSUxEX0hPU1RSVVNU RkxBR1MKIGV4cG9ydCBDUFAgQVIgTk0gU1RSSVAgT0JKQ09QWSBPQkpEVU1QIFJFQURFTEYgUEFI T0xFIFJFU09MVkVfQlRGSURTIExFWCBZQUNDIEFXSyBJTlNUQUxMS0VSTkVMCiBleHBvcnQgUEVS TCBQWVRIT04zIENIRUNLIENIRUNLRkxBR1MgTUFLRSBVVFNfTUFDSElORSBIT1NUQ1hYCiBleHBv cnQgS0daSVAgS0JaSVAyIEtMWk9QIExaTUEgTFo0IFhaIFpTVEQKQEAgLTU0Myw5ICs2MDYsMTAg QEAgZXhwb3J0IEtCVUlMRF9VU0VSQ0ZMQUdTIEtCVUlMRF9VU0VSTERGTEFHUwogCiBleHBvcnQg S0JVSUxEX0NQUEZMQUdTIE5PU1RESU5DX0ZMQUdTIExJTlVYSU5DTFVERSBPQkpDT1BZRkxBR1Mg S0JVSUxEX0xERkxBR1MKIGV4cG9ydCBLQlVJTERfQ0ZMQUdTIENGTEFHU19LRVJORUwgQ0ZMQUdT X01PRFVMRQorZXhwb3J0IEtCVUlMRF9SVVNURkxBR1MgUlVTVEZMQUdTX0tFUk5FTCBSVVNURkxB R1NfTU9EVUxFCiBleHBvcnQgS0JVSUxEX0FGTEFHUyBBRkxBR1NfS0VSTkVMIEFGTEFHU19NT0RV TEUKLWV4cG9ydCBLQlVJTERfQUZMQUdTX01PRFVMRSBLQlVJTERfQ0ZMQUdTX01PRFVMRSBLQlVJ TERfTERGTEFHU19NT0RVTEUKLWV4cG9ydCBLQlVJTERfQUZMQUdTX0tFUk5FTCBLQlVJTERfQ0ZM QUdTX0tFUk5FTAorZXhwb3J0IEtCVUlMRF9BRkxBR1NfTU9EVUxFIEtCVUlMRF9DRkxBR1NfTU9E VUxFIEtCVUlMRF9SVVNURkxBR1NfTU9EVUxFIEtCVUlMRF9MREZMQUdTX01PRFVMRQorZXhwb3J0 IEtCVUlMRF9BRkxBR1NfS0VSTkVMIEtCVUlMRF9DRkxBR1NfS0VSTkVMIEtCVUlMRF9SVVNURkxB R1NfS0VSTkVMCiBleHBvcnQgUEFIT0xFX0ZMQUdTCiAKICMgRmlsZXMgdG8gaWdub3JlIGluIGZp bmQgLi4uIHN0YXRlbWVudHMKQEAgLTcyNiw3ICs3OTAsNyBAQCAkKEtDT05GSUdfQ09ORklHKToK ICMKICMgRG8gbm90IHVzZSAkKGNhbGwgY21kLC4uLikgaGVyZS4gVGhhdCB3b3VsZCBzdXBwcmVz cyBwcm9tcHRzIGZyb20gc3luY2NvbmZpZywKICMgc28geW91IGNhbm5vdCBub3RpY2UgdGhhdCBL Y29uZmlnIGlzIHdhaXRpbmcgZm9yIHRoZSB1c2VyIGlucHV0LgotJS9jb25maWcvYXV0by5jb25m ICUvY29uZmlnL2F1dG8uY29uZi5jbWQgJS9nZW5lcmF0ZWQvYXV0b2NvbmYuaDogJChLQ09ORklH X0NPTkZJRykKKyUvY29uZmlnL2F1dG8uY29uZiAlL2NvbmZpZy9hdXRvLmNvbmYuY21kICUvZ2Vu ZXJhdGVkL2F1dG9jb25mLmggJS9nZW5lcmF0ZWQvcnVzdGNfY2ZnOiAkKEtDT05GSUdfQ09ORklH KQogCSQoUSkkKGtlY2hvKSAiICBTWU5DICAgICRAIgogCSQoUSkkKE1BS0UpIC1mICQoc3JjdHJl ZSkvTWFrZWZpbGUgc3luY2NvbmZpZwogZWxzZSAjICFtYXktc3luYy1jb25maWcKQEAgLTc1NSwx MiArODE5LDIwIEBAIEtCVUlMRF9DRkxBR1MJKz0gJChjYWxsIGNjLWRpc2FibGUtd2FybmluZywg YWRkcmVzcy1vZi1wYWNrZWQtbWVtYmVyKQogCiBpZmRlZiBDT05GSUdfQ0NfT1BUSU1JWkVfRk9S X1BFUkZPUk1BTkNFCiBLQlVJTERfQ0ZMQUdTICs9IC1PMgorS0JVSUxEX1JVU1RGTEFHUyArPSAt Q29wdC1sZXZlbD0yCiBlbHNlIGlmZGVmIENPTkZJR19DQ19PUFRJTUlaRV9GT1JfUEVSRk9STUFO Q0VfTzMKIEtCVUlMRF9DRkxBR1MgKz0gLU8zCitLQlVJTERfUlVTVEZMQUdTICs9IC1Db3B0LWxl dmVsPTMKIGVsc2UgaWZkZWYgQ09ORklHX0NDX09QVElNSVpFX0ZPUl9TSVpFCiBLQlVJTERfQ0ZM QUdTICs9IC1PcworS0JVSUxEX1JVU1RGTEFHUyArPSAtQ29wdC1sZXZlbD1zCiBlbmRpZgogCisj IEFsd2F5cyBzZXQgYGRlYnVnLWFzc2VydGlvbnNgIGFuZCBgb3ZlcmZsb3ctY2hlY2tzYCBiZWNh dXNlIHRoZWlyIGRlZmF1bHQKKyMgZGVwZW5kcyBvbiBgb3B0LWxldmVsYCBhbmQgYGRlYnVnLWFz c2VydGlvbnNgLCByZXNwZWN0aXZlbHkuCitLQlVJTERfUlVTVEZMQUdTICs9IC1DZGVidWctYXNz ZXJ0aW9ucz0kKGlmICQoQ09ORklHX1JVU1RfREVCVUdfQVNTRVJUSU9OUykseSxuKQorS0JVSUxE X1JVU1RGTEFHUyArPSAtQ292ZXJmbG93LWNoZWNrcz0kKGlmICQoQ09ORklHX1JVU1RfT1ZFUkZM T1dfQ0hFQ0tTKSx5LG4pCisKICMgVGVsbCBnY2MgdG8gbmV2ZXIgcmVwbGFjZSBjb25kaXRpb25h bCBsb2FkIHdpdGggYSBub24tY29uZGl0aW9uYWwgb25lCiBpZmRlZiBDT05GSUdfQ0NfSVNfR0ND CiAjIGdjYy0xMCByZW5hbWVkIC0tcGFyYW09YWxsb3ctc3RvcmUtZGF0YS1yYWNlcz0wIHRvCkBA IC03OTEsNiArODYzLDkgQEAgS0JVSUxEX0NGTEFHUy0kKENPTkZJR19XRVJST1IpICs9IC1XZXJy b3IKIEtCVUlMRF9DRkxBR1MtJChDT05GSUdfQ0NfTk9fQVJSQVlfQk9VTkRTKSArPSAtV25vLWFy cmF5LWJvdW5kcwogS0JVSUxEX0NGTEFHUyArPSAkKEtCVUlMRF9DRkxBR1MteSkgJChDT05GSUdf Q0NfSU1QTElDSVRfRkFMTFRIUk9VR0gpCiAKK0tCVUlMRF9SVVNURkxBR1MtJChDT05GSUdfV0VS Uk9SKSArPSAtRHdhcm5pbmdzCitLQlVJTERfUlVTVEZMQUdTICs9ICQoS0JVSUxEX1JVU1RGTEFH Uy15KQorCiBpZmRlZiBDT05GSUdfQ0NfSVNfQ0xBTkcKIEtCVUlMRF9DUFBGTEFHUyArPSAtUXVu dXNlZC1hcmd1bWVudHMKICMgVGhlIGtlcm5lbCBidWlsZHMgd2l0aCAnLXN0ZD1nbnUxMScgc28g dXNlIG9mIEdOVSBleHRlbnNpb25zIGlzIGFjY2VwdGFibGUuCkBAIC04MTEsMTIgKzg4NiwxNSBA QCBLQlVJTERfQ0ZMQUdTICs9ICQoY2FsbCBjYy1kaXNhYmxlLXdhcm5pbmcsIGRhbmdsaW5nLXBv aW50ZXIpCiAKIGlmZGVmIENPTkZJR19GUkFNRV9QT0lOVEVSCiBLQlVJTERfQ0ZMQUdTCSs9IC1m bm8tb21pdC1mcmFtZS1wb2ludGVyIC1mbm8tb3B0aW1pemUtc2libGluZy1jYWxscworS0JVSUxE X1JVU1RGTEFHUyArPSAtQ2ZvcmNlLWZyYW1lLXBvaW50ZXJzPXkKIGVsc2UKICMgU29tZSB0YXJn ZXRzIChBUk0gd2l0aCBUaHVtYjIsIGZvciBleGFtcGxlKSwgY2FuJ3QgYmUgYnVpbHQgd2l0aCBm cmFtZQogIyBwb2ludGVycy4gIEZvciB0aG9zZSwgd2UgZG9uJ3QgaGF2ZSBGVU5DVElPTl9UUkFD RVIgYXV0b21hdGljYWxseQogIyBzZWxlY3QgRlJBTUVfUE9JTlRFUi4gIEhvd2V2ZXIsIEZVTkNU SU9OX1RSQUNFUiBhZGRzIC1wZywgYW5kIHRoaXMgaXMKICMgaW5jb21wYXRpYmxlIHdpdGggLWZv bWl0LWZyYW1lLXBvaW50ZXIgd2l0aCBjdXJyZW50IEdDQywgc28gd2UgZG9uJ3QgdXNlCiAjIC1m b21pdC1mcmFtZS1wb2ludGVyIHdpdGggRlVOQ1RJT05fVFJBQ0VSLgorIyBJbiB0aGUgUnVzdCB0 YXJnZXQgc3BlY2lmaWNhdGlvbiwgImZyYW1lLXBvaW50ZXIiIGlzIHNldCBleHBsaWNpdGx5Cisj IHRvICJtYXktb21pdCIuCiBpZm5kZWYgQ09ORklHX0ZVTkNUSU9OX1RSQUNFUgogS0JVSUxEX0NG TEFHUwkrPSAtZm9taXQtZnJhbWUtcG9pbnRlcgogZW5kaWYKQEAgLTg4MSw4ICs5NTksMTAgQEAg aWZkZWYgQ09ORklHX0RFQlVHX1NFQ1RJT05fTUlTTUFUQ0gKIEtCVUlMRF9DRkxBR1MgKz0gLWZu by1pbmxpbmUtZnVuY3Rpb25zLWNhbGxlZC1vbmNlCiBlbmRpZgogCisjIGBydXN0Y2AncyBgLVpm dW5jdGlvbi1zZWN0aW9uc2AgYXBwbGllcyB0byBkYXRhIHRvbyAoYXMgb2YgMS41OS4wKS4KIGlm ZGVmIENPTkZJR19MRF9ERUFEX0NPREVfREFUQV9FTElNSU5BVElPTgogS0JVSUxEX0NGTEFHU19L RVJORUwgKz0gLWZmdW5jdGlvbi1zZWN0aW9ucyAtZmRhdGEtc2VjdGlvbnMKK0tCVUlMRF9SVVNU RkxBR1NfS0VSTkVMICs9IC1aZnVuY3Rpb24tc2VjdGlvbnM9eQogTERGTEFHU192bWxpbnV4ICs9 IC0tZ2Mtc2VjdGlvbnMKIGVuZGlmCiAKQEAgLTEwMjUsMTAgKzExMDUsMTEgQEAgaW5jbHVkZSAk KGFkZHByZWZpeCAkKHNyY3RyZWUpLywgJChpbmNsdWRlLXkpKQogIyBEbyBub3QgYWRkICQoY2Fs bCBjYy1vcHRpb24sLi4uKSBiZWxvdyB0aGlzIGxpbmUuIFdoZW4geW91IGJ1aWxkIHRoZSBrZXJu ZWwKICMgZnJvbSB0aGUgY2xlYW4gc291cmNlIHRyZWUsIHRoZSBHQ0MgcGx1Z2lucyBkbyBub3Qg ZXhpc3QgYXQgdGhpcyBwb2ludC4KIAotIyBBZGQgdXNlciBzdXBwbGllZCBDUFBGTEFHUywgQUZM QUdTIGFuZCBDRkxBR1MgYXMgdGhlIGxhc3QgYXNzaWdubWVudHMKKyMgQWRkIHVzZXIgc3VwcGxp ZWQgQ1BQRkxBR1MsIEFGTEFHUywgQ0ZMQUdTIGFuZCBSVVNURkxBR1MgYXMgdGhlIGxhc3QgYXNz aWdubWVudHMKIEtCVUlMRF9DUFBGTEFHUyArPSAkKEtDUFBGTEFHUykKIEtCVUlMRF9BRkxBR1Mg ICArPSAkKEtBRkxBR1MpCiBLQlVJTERfQ0ZMQUdTICAgKz0gJChLQ0ZMQUdTKQorS0JVSUxEX1JV U1RGTEFHUyArPSAkKEtSVVNURkxBR1MpCiAKIEtCVUlMRF9MREZMQUdTX01PRFVMRSArPSAtLWJ1 aWxkLWlkPXNoYTEKIExERkxBR1Nfdm1saW51eCArPSAtLWJ1aWxkLWlkPXNoYTEKQEAgLTEwOTcs NiArMTE3OCw3IEBAIGV4cG9ydCBNT0RVTEVTX05TREVQUyA6PSAkKGV4dG1vZF9wcmVmaXgpbW9k dWxlcy5uc2RlcHMKIGlmZXEgKCQoS0JVSUxEX0VYVE1PRCksKQogY29yZS15CQkJKz0ga2VybmVs LyBjZXJ0cy8gbW0vIGZzLyBpcGMvIHNlY3VyaXR5LyBjcnlwdG8vCiBjb3JlLSQoQ09ORklHX0JM T0NLKQkrPSBibG9jay8KK2NvcmUtJChDT05GSUdfUlVTVCkJKz0gcnVzdC8KIAogdm1saW51eC1k aXJzCTo9ICQocGF0c3Vic3QgJS8sJSwkKGZpbHRlciAlLywgXAogCQkgICAgICQoY29yZS15KSAk KGNvcmUtbSkgJChkcml2ZXJzLXkpICQoZHJpdmVycy1tKSBcCkBAIC0xMjAxLDYgKzEyODMsMTAg QEAgcHJlcGFyZTA6IGFyY2hwcmVwYXJlCiAKICMgQWxsIHRoZSBwcmVwYXJpbmcuLgogcHJlcGFy ZTogcHJlcGFyZTAKK2lmZGVmIENPTkZJR19SVVNUCisJJChRKSQoQ09ORklHX1NIRUxMKSAkKHNy Y3RyZWUpL3NjcmlwdHMvcnVzdC1pcy1hdmFpbGFibGUuc2ggLXYKKwkkKFEpJChNQUtFKSAkKGJ1 aWxkKT1ydXN0CitlbmRpZgogCiBQSE9OWSArPSByZW1vdmUtc3RhbGUtZmlsZXMKIHJlbW92ZS1z dGFsZS1maWxlczoKQEAgLTE0OTAsNyArMTU3Niw3IEBAIGVuZGlmICMgQ09ORklHX01PRFVMRVMK ICMgRGlyZWN0b3JpZXMgJiBmaWxlcyByZW1vdmVkIHdpdGggJ21ha2UgY2xlYW4nCiBDTEVBTl9G SUxFUyArPSBpbmNsdWRlL2tzeW0gdm1saW51eC5zeW12ZXJzIG1vZHVsZXMtb25seS5zeW12ZXJz IFwKIAkgICAgICAgbW9kdWxlcy5idWlsdGluIG1vZHVsZXMuYnVpbHRpbi5tb2RpbmZvIG1vZHVs ZXMubnNkZXBzIFwKLQkgICAgICAgY29tcGlsZV9jb21tYW5kcy5qc29uIC50aGlubHRvLWNhY2hl CisJICAgICAgIGNvbXBpbGVfY29tbWFuZHMuanNvbiAudGhpbmx0by1jYWNoZSBydXN0L3Rlc3Qg cnVzdC9kb2MKIAogIyBEaXJlY3RvcmllcyAmIGZpbGVzIHJlbW92ZWQgd2l0aCAnbWFrZSBtcnBy b3BlcicKIE1SUFJPUEVSX0ZJTEVTICs9IGluY2x1ZGUvY29uZmlnIGluY2x1ZGUvZ2VuZXJhdGVk ICAgICAgICAgIFwKQEAgLTE1MDEsNyArMTU4Nyw4IEBAIE1SUFJPUEVSX0ZJTEVTICs9IGluY2x1 ZGUvY29uZmlnIGluY2x1ZGUvZ2VuZXJhdGVkICAgICAgICAgIFwKIAkJICBjZXJ0cy9zaWduaW5n X2tleS5wZW0gXAogCQkgIGNlcnRzL3g1MDkuZ2Vua2V5IFwKIAkJICB2bWxpbnV4LWdkYi5weSBc Ci0JCSAgKi5zcGVjCisJCSAgKi5zcGVjIFwKKwkJICBydXN0L3RhcmdldC5qc29uIHJ1c3QvbGli bWFjcm9zLnNvCiAKICMgY2xlYW4gLSBEZWxldGUgbW9zdCwgYnV0IGxlYXZlIGVub3VnaCB0byBi dWlsZCBleHRlcm5hbCBtb2R1bGVzCiAjCkBAIC0xNTI2LDYgKzE2MTMsOSBAQCAkKG1ycHJvcGVy LWRpcnMpOgogCiBtcnByb3BlcjogY2xlYW4gJChtcnByb3Blci1kaXJzKQogCSQoY2FsbCBjbWQs cm1maWxlcykKKwlAZmluZCAuICQoUkNTX0ZJTkRfSUdOT1JFKSBcCisJCVwoIC1uYW1lICcqLnJt ZXRhJyBcKSBcCisJCS10eXBlIGYgLXByaW50IHwgeGFyZ3Mgcm0gLWYKIAogIyBkaXN0Y2xlYW4K ICMKQEAgLTE2MTMsNiArMTcwMywyNCBAQCBoZWxwOgogCUBlY2hvICAnICBrc2VsZnRlc3QtbWVy Z2UgICAtIE1lcmdlIGFsbCB0aGUgY29uZmlnIGRlcGVuZGVuY2llcyBvZicKIAlAZWNobyAgJwkJ ICAgICAga3NlbGZ0ZXN0IHRvIGV4aXN0aW5nIC5jb25maWcuJwogCUBlY2hvICAnJworCUBlY2hv ICAnUnVzdCB0YXJnZXRzOicKKwlAZWNobyAgJyAgcnVzdGF2YWlsYWJsZSAgIC0gQ2hlY2tzIHdo ZXRoZXIgdGhlIFJ1c3QgdG9vbGNoYWluIGlzJworCUBlY2hvICAnCQkgICAgYXZhaWxhYmxlIGFu ZCwgaWYgbm90LCBleHBsYWlucyB3aHkuJworCUBlY2hvICAnICBydXN0Zm10CSAgLSBSZWZvcm1h dCBhbGwgdGhlIFJ1c3QgY29kZSBpbiB0aGUga2VybmVsJworCUBlY2hvICAnICBydXN0Zm10Y2hl Y2sJICAtIENoZWNrcyBpZiBhbGwgdGhlIFJ1c3QgY29kZSBpbiB0aGUga2VybmVsJworCUBlY2hv ICAnCQkgICAgaXMgZm9ybWF0dGVkLCBwcmludGluZyBhIGRpZmYgb3RoZXJ3aXNlLicKKwlAZWNo byAgJyAgcnVzdGRvYwkgIC0gR2VuZXJhdGUgUnVzdCBkb2N1bWVudGF0aW9uJworCUBlY2hvICAn CQkgICAgKHJlcXVpcmVzIGtlcm5lbCAuY29uZmlnKScKKwlAZWNobyAgJyAgcnVzdHRlc3QgICAg ICAgIC0gUnVucyB0aGUgUnVzdCB0ZXN0cycKKwlAZWNobyAgJyAgICAgICAgICAgICAgICAgICAg KHJlcXVpcmVzIGtlcm5lbCAuY29uZmlnOyBkb3dubG9hZHMgZXh0ZXJuYWwgcmVwb3MpJworCUBl Y2hvICAnICBydXN0LWFuYWx5emVyCSAgLSBHZW5lcmF0ZSBydXN0LXByb2plY3QuanNvbiBydXN0 LWFuYWx5emVyIHN1cHBvcnQgZmlsZScKKwlAZWNobyAgJwkJICAgIChyZXF1aXJlcyBrZXJuZWwg LmNvbmZpZyknCisJQGVjaG8gICcgIGRpci9maWxlLltvc10gICAtIEJ1aWxkIHNwZWNpZmllZCB0 YXJnZXQgb25seScKKwlAZWNobyAgJyAgZGlyL2ZpbGUucnNpICAgIC0gQnVpbGQgbWFjcm8gZXhw YW5kZWQgc291cmNlLCBzaW1pbGFyIHRvIEMgcHJlcHJvY2Vzc2luZy4nCisJQGVjaG8gICcgICAg ICAgICAgICAgICAgICAgIFJ1biB3aXRoIFJVU1RGTVQ9biB0byBza2lwIHJlZm9ybWF0dGluZyBp ZiBuZWVkZWQuJworCUBlY2hvICAnICAgICAgICAgICAgICAgICAgICBUaGUgb3V0cHV0IGlzIG5v dCBpbnRlbmRlZCB0byBiZSBjb21waWxhYmxlLicKKwlAZWNobyAgJyAgZGlyL2ZpbGUubGwgICAg IC0gQnVpbGQgdGhlIExMVk0gYXNzZW1ibHkgZmlsZScKKwlAZWNobyAgJycKIAlAJChpZiAkKGR0 c3RyZWUpLCBcCiAJCWVjaG8gJ0RldmljZXRyZWU6JzsgXAogCQllY2hvICcqIGR0YnMgICAgICAg ICAgICAgLSBCdWlsZCBkZXZpY2UgdHJlZSBibG9icyBmb3IgZW5hYmxlZCBib2FyZHMnOyBcCkBA IC0xNjg1LDYgKzE3OTMsNTIgQEAgUEhPTlkgKz0gJChET0NfVEFSR0VUUykKICQoRE9DX1RBUkdF VFMpOgogCSQoUSkkKE1BS0UpICQoYnVpbGQpPURvY3VtZW50YXRpb24gJEAKIAorCisjIFJ1c3Qg dGFyZ2V0cworIyAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0KKworIyAiSXMgUnVzdCBhdmFpbGFibGU/IiB0 YXJnZXQKK1BIT05ZICs9IHJ1c3RhdmFpbGFibGUKK3J1c3RhdmFpbGFibGU6CisJJChRKSQoQ09O RklHX1NIRUxMKSAkKHNyY3RyZWUpL3NjcmlwdHMvcnVzdC1pcy1hdmFpbGFibGUuc2ggLXYgJiYg ZWNobyAiUnVzdCBpcyBhdmFpbGFibGUhIgorCisjIERvY3VtZW50YXRpb24gdGFyZ2V0CisjCisj IFVzaW5nIHRoZSBzaW5ndWxhciB0byBhdm9pZCBydW5uaW5nIGFmb3VsIG9mIGBuby1kb3QtY29u ZmlnLXRhcmdldHNgLgorUEhPTlkgKz0gcnVzdGRvYworcnVzdGRvYzogcHJlcGFyZQorCSQoUSkk KE1BS0UpICQoYnVpbGQpPXJ1c3QgJEAKKworIyBUZXN0aW5nIHRhcmdldAorUEhPTlkgKz0gcnVz dHRlc3QKK3J1c3R0ZXN0OiBwcmVwYXJlCisJJChRKSQoTUFLRSkgJChidWlsZCk9cnVzdCAkQAor CisjIEZvcm1hdHRpbmcgdGFyZ2V0cworUEhPTlkgKz0gcnVzdGZtdCBydXN0Zm10Y2hlY2sKKwor IyBXZSBza2lwIGBydXN0L2FsbG9jYCBzaW5jZSB3ZSB3YW50IHRvIG1pbmltaXplIHRoZSBkaWZm IHcuci50LiB1cHN0cmVhbS4KKyMKKyMgV2UgbWF0Y2ggdXNpbmcgYWJzb2x1dGUgcGF0aHMgc2lu Y2UgYGZpbmRgIGRvZXMgbm90IHJlc29sdmUgdGhlbQorIyB3aGVuIG1hdGNoaW5nLCB3aGljaCBp cyBhIHByb2JsZW0gd2hlbiBlLmcuIGBzcmN0cmVlYCBpcyBgLi5gLgorIyBXZSBgZ3JlcGAgYWZ0 ZXJ3YXJkcyBpbiBvcmRlciB0byByZW1vdmUgdGhlIGRpcmVjdG9yeSBlbnRyeSBpdHNlbGYuCity dXN0Zm10OgorCSQoUSlmaW5kICQoYWJzX3NyY3RyZWUpIC10eXBlIGYgLW5hbWUgJyoucnMnIFwK KwkJLW8gLXBhdGggJChhYnNfc3JjdHJlZSkvcnVzdC9hbGxvYyAtcHJ1bmUgXAorCQktbyAtcGF0 aCAkKGFic19vYmp0cmVlKS9ydXN0L3Rlc3QgLXBydW5lIFwKKwkJfCBncmVwIC1GdiAkKGFic19z cmN0cmVlKS9ydXN0L2FsbG9jIFwKKwkJfCBncmVwIC1GdiAkKGFic19vYmp0cmVlKS9ydXN0L3Rl c3QgXAorCQl8IGdyZXAgLUZ2IGdlbmVyYXRlZCBcCisJCXwgeGFyZ3MgJChSVVNURk1UKSAkKHJ1 c3RmbXRfZmxhZ3MpCisKK3J1c3RmbXRjaGVjazogcnVzdGZtdF9mbGFncyA9IC0tY2hlY2sKK3J1 c3RmbXRjaGVjazogcnVzdGZtdAorCisjIElERSBzdXBwb3J0IHRhcmdldHMKK1BIT05ZICs9IHJ1 c3QtYW5hbHl6ZXIKK3J1c3QtYW5hbHl6ZXI6CisJJChRKSQoTUFLRSkgJChidWlsZCk9cnVzdCAk QAorCiAjIE1pc2MKICMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKQEAgLTE4NTIsNyArMjAwNiw3IEBA ICQoY2xlYW4tZGlycyk6CiBjbGVhbjogJChjbGVhbi1kaXJzKQogCSQoY2FsbCBjbWQscm1maWxl cykKIAlAZmluZCAkKG9yICQoS0JVSUxEX0VYVE1PRCksIC4pICQoUkNTX0ZJTkRfSUdOT1JFKSBc Ci0JCVwoIC1uYW1lICcqLlthaW9zXScgLW8gLW5hbWUgJyoua28nIC1vIC1uYW1lICcuKi5jbWQn IFwKKwkJXCggLW5hbWUgJyouW2Fpb3NdJyAtbyAtbmFtZSAnKi5yc2knIC1vIC1uYW1lICcqLmtv JyAtbyAtbmFtZSAnLiouY21kJyBcCiAJCS1vIC1uYW1lICcqLmtvLionIFwKIAkJLW8gLW5hbWUg JyouZHRiJyAtbyAtbmFtZSAnKi5kdGJvJyAtbyAtbmFtZSAnKi5kdGIuUycgLW8gLW5hbWUgJyou ZHQueWFtbCcgXAogCQktbyAtbmFtZSAnKi5kd28nIC1vIC1uYW1lICcqLmxzdCcgXApkaWZmIC0t Z2l0IGEvYXJjaC9LY29uZmlnIGIvYXJjaC9LY29uZmlnCmluZGV4IDcxYjkyNzJhY2IyOC4uZDUw MzhjZjhkZDQ5IDEwMDY0NAotLS0gYS9hcmNoL0tjb25maWcKKysrIGIvYXJjaC9LY29uZmlnCkBA IC0zNTMsNiArMzUzLDEyIEBAIGNvbmZpZyBIQVZFX1JTRVEKIAkgIFRoaXMgc3ltYm9sIHNob3Vs ZCBiZSBzZWxlY3RlZCBieSBhbiBhcmNoaXRlY3R1cmUgaWYgaXQKIAkgIHN1cHBvcnRzIGFuIGlt cGxlbWVudGF0aW9uIG9mIHJlc3RhcnRhYmxlIHNlcXVlbmNlcy4KIAorY29uZmlnIEhBVkVfUlVT VAorCWJvb2wKKwloZWxwCisJICBUaGlzIHN5bWJvbCBzaG91bGQgYmUgc2VsZWN0ZWQgYnkgYW4g YXJjaGl0ZWN0dXJlIGlmIGl0CisJICBzdXBwb3J0cyBSdXN0LgorCiBjb25maWcgSEFWRV9GVU5D VElPTl9BUkdfQUNDRVNTX0FQSQogCWJvb2wKIAloZWxwCmRpZmYgLS1naXQgYS9hcmNoL2FybS9L Y29uZmlnIGIvYXJjaC9hcm0vS2NvbmZpZwppbmRleCA3NjMwYmE5Y2I2Y2MuLjE0NzY1NWE0ZmMy NyAxMDA2NDQKLS0tIGEvYXJjaC9hcm0vS2NvbmZpZworKysgYi9hcmNoL2FybS9LY29uZmlnCkBA IC0xMTYsNiArMTE2LDcgQEAgY29uZmlnIEFSTQogCXNlbGVjdCBNTVVfR0FUSEVSX1JDVV9UQUJM RV9GUkVFIGlmIFNNUCAmJiBBUk1fTFBBRQogCXNlbGVjdCBIQVZFX1JFR1NfQU5EX1NUQUNLX0FD Q0VTU19BUEkKIAlzZWxlY3QgSEFWRV9SU0VRCisJc2VsZWN0IEhBVkVfUlVTVCBpZiBDUFVfMzJ2 NiB8fCBDUFVfMzJ2NksKIAlzZWxlY3QgSEFWRV9TVEFDS1BST1RFQ1RPUgogCXNlbGVjdCBIQVZF X1NZU0NBTExfVFJBQ0VQT0lOVFMKIAlzZWxlY3QgSEFWRV9VSUQxNgpkaWZmIC0tZ2l0IGEvYXJj aC9hcm02NC9LY29uZmlnIGIvYXJjaC9hcm02NC9LY29uZmlnCmluZGV4IDE2NTJhOTgwMGViZS4u YWFlYjcwMzU4OTc5IDEwMDY0NAotLS0gYS9hcmNoL2FybTY0L0tjb25maWcKKysrIGIvYXJjaC9h cm02NC9LY29uZmlnCkBAIC0yMDEsNiArMjAxLDcgQEAgY29uZmlnIEFSTTY0CiAJc2VsZWN0IEhB VkVfRlVOQ1RJT05fQVJHX0FDQ0VTU19BUEkKIAlzZWxlY3QgTU1VX0dBVEhFUl9SQ1VfVEFCTEVf RlJFRQogCXNlbGVjdCBIQVZFX1JTRVEKKwlzZWxlY3QgSEFWRV9SVVNUCiAJc2VsZWN0IEhBVkVf U1RBQ0tQUk9URUNUT1IKIAlzZWxlY3QgSEFWRV9TWVNDQUxMX1RSQUNFUE9JTlRTCiAJc2VsZWN0 IEhBVkVfS1BST0JFUwpkaWZmIC0tZ2l0IGEvYXJjaC9wb3dlcnBjL0tjb25maWcgYi9hcmNoL3Bv d2VycGMvS2NvbmZpZwppbmRleCA0ZDhmMjZjMTM5OWIuLmVkYWIzY2M5ZWRmNSAxMDA2NDQKLS0t IGEvYXJjaC9wb3dlcnBjL0tjb25maWcKKysrIGIvYXJjaC9wb3dlcnBjL0tjb25maWcKQEAgLTI0 Myw2ICsyNDMsNyBAQCBjb25maWcgUFBDCiAJc2VsZWN0IEhBVkVfUkVHU19BTkRfU1RBQ0tfQUND RVNTX0FQSQogCXNlbGVjdCBIQVZFX1JFTElBQkxFX1NUQUNLVFJBQ0UKIAlzZWxlY3QgSEFWRV9S U0VRCisJc2VsZWN0IEhBVkVfUlVTVAkJCWlmIFBQQzY0ICYmIENQVV9MSVRUTEVfRU5ESUFOCiAJ c2VsZWN0IEhBVkVfU0VUVVBfUEVSX0NQVV9BUkVBCQlpZiBQUEM2NAogCXNlbGVjdCBIQVZFX1NP RlRJUlFfT05fT1dOX1NUQUNLCiAJc2VsZWN0IEhBVkVfU1RBQ0tQUk9URUNUT1IJCWlmIFBQQzMy ICYmICQoY2Mtb3B0aW9uLC1tc3RhY2stcHJvdGVjdG9yLWd1YXJkPXRscyAtbXN0YWNrLXByb3Rl Y3Rvci1ndWFyZC1yZWc9cjIpCmRpZmYgLS1naXQgYS9hcmNoL3Jpc2N2L0tjb25maWcgYi9hcmNo L3Jpc2N2L0tjb25maWcKaW5kZXggZmNiYjgxZmViN2FkLi41YjUzYjQxNTI4ZjYgMTAwNjQ0Ci0t LSBhL2FyY2gvcmlzY3YvS2NvbmZpZworKysgYi9hcmNoL3Jpc2N2L0tjb25maWcKQEAgLTEwNCw2 ICsxMDQsNyBAQCBjb25maWcgUklTQ1YKIAlzZWxlY3QgSEFWRV9QRVJGX1JFR1MKIAlzZWxlY3Qg SEFWRV9QRVJGX1VTRVJfU1RBQ0tfRFVNUAogCXNlbGVjdCBIQVZFX1JFR1NfQU5EX1NUQUNLX0FD Q0VTU19BUEkKKwlzZWxlY3QgSEFWRV9SVVNUIGlmIDY0QklUCiAJc2VsZWN0IEhBVkVfRlVOQ1RJ T05fQVJHX0FDQ0VTU19BUEkKIAlzZWxlY3QgSEFWRV9TVEFDS1BST1RFQ1RPUgogCXNlbGVjdCBI QVZFX1NZU0NBTExfVFJBQ0VQT0lOVFMKZGlmZiAtLWdpdCBhL2FyY2gvcmlzY3YvTWFrZWZpbGUg Yi9hcmNoL3Jpc2N2L01ha2VmaWxlCmluZGV4IDgxMDI5ZDQwYTY3Mi4uMjRlYmUwNDI0MDZlIDEw MDY0NAotLS0gYS9hcmNoL3Jpc2N2L01ha2VmaWxlCisrKyBiL2FyY2gvcmlzY3YvTWFrZWZpbGUK QEAgLTI2LDYgKzI2LDggQEAgaWZlcSAoJChDT05GSUdfQVJDSF9SVjY0SSkseSkKIAlLQlVJTERf Q0ZMQUdTICs9IC1tYWJpPWxwNjQKIAlLQlVJTERfQUZMQUdTICs9IC1tYWJpPWxwNjQKIAorCUtC VUlMRF9SVVNURkxBR1MgKz0gLUN0YXJnZXQtY3B1PWdlbmVyaWMtcnY2NAorCiAJS0JVSUxEX0xE RkxBR1MgKz0gLW1lbGY2NGxyaXNjdgogZWxzZQogCUJJVFMgOj0gMzIKQEAgLTMzLDYgKzM1LDkg QEAgZWxzZQogCiAJS0JVSUxEX0NGTEFHUyArPSAtbWFiaT1pbHAzMgogCUtCVUlMRF9BRkxBR1Mg Kz0gLW1hYmk9aWxwMzIKKworCUtCVUlMRF9SVVNURkxBR1MgKz0gLUN0YXJnZXQtY3B1PWdlbmVy aWMtcnYzMgorCiAJS0JVSUxEX0xERkxBR1MgKz0gLW1lbGYzMmxyaXNjdgogZW5kaWYKIApkaWZm IC0tZ2l0IGEvYXJjaC91bS9LY29uZmlnIGIvYXJjaC91bS9LY29uZmlnCmluZGV4IDRlYzIyZTE1 NmEyZS4uNmRjMDZhN2JmOGI3IDEwMDY0NAotLS0gYS9hcmNoL3VtL0tjb25maWcKKysrIGIvYXJj aC91bS9LY29uZmlnCkBAIC0yNSw2ICsyNSw3IEBAIGNvbmZpZyBVTUwKIAlzZWxlY3QgVFJBQ0Vf SVJRRkxBR1NfU1VQUE9SVAogCXNlbGVjdCBUVFkgIyBOZWVkZWQgZm9yIGxpbmUuYwogCXNlbGVj dCBIQVZFX0FSQ0hfVk1BUF9TVEFDSworCXNlbGVjdCBIQVZFX1JVU1QJCQlpZiBYODZfNjQKIAog Y29uZmlnIE1NVQogCWJvb2wKZGlmZiAtLWdpdCBhL2FyY2gveDg2L0tjb25maWcgYi9hcmNoL3g4 Ni9LY29uZmlnCmluZGV4IDUyYTdmOTE1MjdmZS4uNGQ1YTNmMjU2Y2JjIDEwMDY0NAotLS0gYS9h cmNoL3g4Ni9LY29uZmlnCisrKyBiL2FyY2gveDg2L0tjb25maWcKQEAgLTI1OCw2ICsyNTgsNyBA QCBjb25maWcgWDg2CiAJc2VsZWN0IEhBVkVfU1RBVElDX0NBTExfSU5MSU5FCQlpZiBIQVZFX09C SlRPT0wKIAlzZWxlY3QgSEFWRV9QUkVFTVBUX0RZTkFNSUNfQ0FMTAogCXNlbGVjdCBIQVZFX1JT RVEKKwlzZWxlY3QgSEFWRV9SVVNUCQkJaWYgWDg2XzY0CiAJc2VsZWN0IEhBVkVfU1lTQ0FMTF9U UkFDRVBPSU5UUwogCXNlbGVjdCBIQVZFX1VBQ0NFU1NfVkFMSURBVElPTgkJaWYgSEFWRV9PQkpU T09MCiAJc2VsZWN0IEhBVkVfVU5TVEFCTEVfU0NIRURfQ0xPQ0sKZGlmZiAtLWdpdCBhL2FyY2gv eDg2L01ha2VmaWxlIGIvYXJjaC94ODYvTWFrZWZpbGUKaW5kZXggNzg1NDY4NWM1ZjI1Li5iYWI1 OTUwMDNmMDcgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L01ha2VmaWxlCisrKyBiL2FyY2gveDg2L01h a2VmaWxlCkBAIC02OCw2ICs2OCw3IEBAIGV4cG9ydCBCSVRTCiAjICAgIGh0dHBzOi8vZ2NjLmdu dS5vcmcvYnVnemlsbGEvc2hvd19idWcuY2dpP2lkPTUzMzgzCiAjCiBLQlVJTERfQ0ZMQUdTICs9 IC1tbm8tc3NlIC1tbm8tbW14IC1tbm8tc3NlMiAtbW5vLTNkbm93IC1tbm8tYXZ4CitLQlVJTERf UlVTVEZMQUdTICs9IC1DdGFyZ2V0LWZlYXR1cmU9LXNzZSwtc3NlMiwtc3NlMywtc3NzZTMsLXNz ZTQuMSwtc3NlNC4yLC1hdngsLWF2eDIKIAogaWZlcSAoJChDT05GSUdfWDg2X0tFUk5FTF9JQlQp LHkpCiAjCkBAIC0xNTUsOCArMTU2LDE3IEBAIGVsc2UKICAgICAgICAgY2ZsYWdzLSQoQ09ORklH X0dFTkVSSUNfQ1BVKQkrPSAtbXR1bmU9Z2VuZXJpYwogICAgICAgICBLQlVJTERfQ0ZMQUdTICs9 ICQoY2ZsYWdzLXkpCiAKKyAgICAgICAgcnVzdGZsYWdzLSQoQ09ORklHX01LOCkJCSs9IC1DdGFy Z2V0LWNwdT1rOAorICAgICAgICBydXN0ZmxhZ3MtJChDT05GSUdfTVBTQykJKz0gLUN0YXJnZXQt Y3B1PW5vY29uYQorICAgICAgICBydXN0ZmxhZ3MtJChDT05GSUdfTUNPUkUyKQkrPSAtQ3Rhcmdl dC1jcHU9Y29yZTIKKyAgICAgICAgcnVzdGZsYWdzLSQoQ09ORklHX01BVE9NKQkrPSAtQ3Rhcmdl dC1jcHU9YXRvbQorICAgICAgICBydXN0ZmxhZ3MtJChDT05GSUdfR0VORVJJQ19DUFUpCSs9IC1a dHVuZS1jcHU9Z2VuZXJpYworICAgICAgICBLQlVJTERfUlVTVEZMQUdTICs9ICQocnVzdGZsYWdz LXkpCisKICAgICAgICAgS0JVSUxEX0NGTEFHUyArPSAtbW5vLXJlZC16b25lCiAgICAgICAgIEtC VUlMRF9DRkxBR1MgKz0gLW1jbW9kZWw9a2VybmVsCisgICAgICAgIEtCVUlMRF9SVVNURkxBR1Mg Kz0gLUNuby1yZWR6b25lPXkKKyAgICAgICAgS0JVSUxEX1JVU1RGTEFHUyArPSAtQ2NvZGUtbW9k ZWw9a2VybmVsCiBlbmRpZgogCiAjCmRpZmYgLS1naXQgYS9pbmNsdWRlL2xpbnV4L2NvbXBpbGVy X3R5cGVzLmggYi9pbmNsdWRlL2xpbnV4L2NvbXBpbGVyX3R5cGVzLmgKaW5kZXggNGYyYTgxOWZk NjBhLi41MGIzZjZiOTUwMmUgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvY29tcGlsZXJfdHlw ZXMuaAorKysgYi9pbmNsdWRlL2xpbnV4L2NvbXBpbGVyX3R5cGVzLmgKQEAgLTQsOCArNCwxMiBA QAogCiAjaWZuZGVmIF9fQVNTRU1CTFlfXwogCisvKgorICogU2tpcHBlZCB3aGVuIHJ1bm5pbmcg YmluZGdlbiBkdWUgdG8gYSBsaWJjbGFuZyBpc3N1ZTsKKyAqIHNlZSBodHRwczovL2dpdGh1Yi5j b20vcnVzdC1sYW5nL3J1c3QtYmluZGdlbi9pc3N1ZXMvMjI0NC4KKyAqLwogI2lmIGRlZmluZWQo Q09ORklHX0RFQlVHX0lORk9fQlRGKSAmJiBkZWZpbmVkKENPTkZJR19QQUhPTEVfSEFTX0JURl9U QUcpICYmIFwKLQlfX2hhc19hdHRyaWJ1dGUoYnRmX3R5cGVfdGFnKQorCV9faGFzX2F0dHJpYnV0 ZShidGZfdHlwZV90YWcpICYmICFkZWZpbmVkKF9fQklOREdFTl9fKQogIyBkZWZpbmUgQlRGX1RZ UEVfVEFHKHZhbHVlKSBfX2F0dHJpYnV0ZV9fKChidGZfdHlwZV90YWcoI3ZhbHVlKSkpCiAjZWxz ZQogIyBkZWZpbmUgQlRGX1RZUEVfVEFHKHZhbHVlKSAvKiBub3RoaW5nICovCmRpZmYgLS1naXQg YS9pbml0L0tjb25maWcgYi9pbml0L0tjb25maWcKaW5kZXggYzc5MDBlODk3NWYxLi42ZjYyZGJl YTgyODMgMTAwNjQ0Ci0tLSBhL2luaXQvS2NvbmZpZworKysgYi9pbml0L0tjb25maWcKQEAgLTYw LDYgKzYwLDE3IEBAIGNvbmZpZyBMTERfVkVSU0lPTgogCWRlZmF1bHQgJChsZC12ZXJzaW9uKSBp ZiBMRF9JU19MTEQKIAlkZWZhdWx0IDAKIAorY29uZmlnIFJVU1RfSVNfQVZBSUxBQkxFCisJZGVm X2Jvb2wgJChzdWNjZXNzLCQoc3JjdHJlZSkvc2NyaXB0cy9ydXN0LWlzLWF2YWlsYWJsZS5zaCkK KwloZWxwCisJICBUaGlzIHNob3dzIHdoZXRoZXIgYSBzdWl0YWJsZSBSdXN0IHRvb2xjaGFpbiBp cyBhdmFpbGFibGUgKGZvdW5kKS4KKworCSAgUGxlYXNlIHNlZSBEb2N1bWVudGF0aW9uL3J1c3Qv cXVpY2stc3RhcnQucnN0IGZvciBpbnN0cnVjdGlvbnMgb24gaG93CisJICB0byBzYXRpZnkgdGhl IGJ1aWxkIHJlcXVpcmVtZW50cyBvZiBSdXN0IHN1cHBvcnQuCisKKwkgIEluIHBhcnRpY3VsYXIs IHRoZSBNYWtlZmlsZSB0YXJnZXQgJ3J1c3RhdmFpbGFibGUnIGlzIHVzZWZ1bCB0byBjaGVjawor CSAgd2h5IHRoZSBSdXN0IHRvb2xjaGFpbiBpcyBub3QgYmVpbmcgZGV0ZWN0ZWQuCisKIGNvbmZp ZyBDQ19DQU5fTElOSwogCWJvb2wKIAlkZWZhdWx0ICQoc3VjY2VzcywkKHNyY3RyZWUpL3Njcmlw dHMvY2MtY2FuLWxpbmsuc2ggJChDQykgJChDTEFOR19GTEFHUykgJChVU0VSQ0ZMQUdTKSAkKFVT RVJMREZMQUdTKSAkKG02NC1mbGFnKSkgaWYgNjRCSVQKQEAgLTE1MSw3ICsxNjIsOCBAQCBjb25m aWcgV0VSUk9SCiAJZGVmYXVsdCBDT01QSUxFX1RFU1QKIAloZWxwCiAJICBBIGtlcm5lbCBidWls ZCBzaG91bGQgbm90IGNhdXNlIGFueSBjb21waWxlciB3YXJuaW5ncywgYW5kIHRoaXMKLQkgIGVu YWJsZXMgdGhlICctV2Vycm9yJyBmbGFnIHRvIGVuZm9yY2UgdGhhdCBydWxlIGJ5IGRlZmF1bHQu CisJICBlbmFibGVzIHRoZSAnLVdlcnJvcicgKGZvciBDKSBhbmQgJy1Ed2FybmluZ3MnIChmb3Ig UnVzdCkgZmxhZ3MKKwkgIHRvIGVuZm9yY2UgdGhhdCBydWxlIGJ5IGRlZmF1bHQuCiAKIAkgIEhv d2V2ZXIsIGlmIHlvdSBoYXZlIGEgbmV3IChvciB2ZXJ5IG9sZCkgY29tcGlsZXIgd2l0aCBvZGQg YW5kCiAJICB1bnVzdWFsIHdhcm5pbmdzLCBvciB5b3UgaGF2ZSBzb21lIGFyY2hpdGVjdHVyZSB3 aXRoIHByb2JsZW1zLApAQCAtMTg5OCw2ICsxOTEwLDM4IEBAIGNvbmZpZyBQUk9GSUxJTkcKIAkg IFNheSBZIGhlcmUgdG8gZW5hYmxlIHRoZSBleHRlbmRlZCBwcm9maWxpbmcgc3VwcG9ydCBtZWNo YW5pc21zIHVzZWQKIAkgIGJ5IHByb2ZpbGVycy4KIAorY29uZmlnIFJVU1QKKwlib29sICJSdXN0 IHN1cHBvcnQiCisJZGVwZW5kcyBvbiBIQVZFX1JVU1QKKwlkZXBlbmRzIG9uIFJVU1RfSVNfQVZB SUxBQkxFCisJZGVwZW5kcyBvbiAhTU9EVkVSU0lPTlMKKwlkZXBlbmRzIG9uICFHQ0NfUExVR0lO UworCWRlcGVuZHMgb24gIVJBTkRTVFJVQ1QKKwlkZXBlbmRzIG9uICFERUJVR19JTkZPX0JURgor CXNlbGVjdCBDT05TVFJVQ1RPUlMKKwloZWxwCisJICBFbmFibGVzIFJ1c3Qgc3VwcG9ydCBpbiB0 aGUga2VybmVsLgorCisJICBUaGlzIGFsbG93cyBvdGhlciBSdXN0LXJlbGF0ZWQgb3B0aW9ucywg bGlrZSBkcml2ZXJzIHdyaXR0ZW4gaW4gUnVzdCwKKwkgIHRvIGJlIHNlbGVjdGVkLgorCisJICBJ dCBpcyBhbHNvIHJlcXVpcmVkIHRvIGJlIGFibGUgdG8gbG9hZCBleHRlcm5hbCBrZXJuZWwgbW9k dWxlcworCSAgd3JpdHRlbiBpbiBSdXN0LgorCisJICBTZWUgRG9jdW1lbnRhdGlvbi9ydXN0LyBm b3IgbW9yZSBpbmZvcm1hdGlvbi4KKworCSAgSWYgdW5zdXJlLCBzYXkgTi4KKworY29uZmlnIFJV U1RDX1ZFUlNJT05fVEVYVAorCXN0cmluZworCWRlcGVuZHMgb24gUlVTVAorCWRlZmF1bHQgJChz aGVsbCxjb21tYW5kIC12ICQoUlVTVEMpID4vZGV2L251bGwgMj4mMSAmJiAkKFJVU1RDKSAtLXZl cnNpb24gfHwgZWNobyBuKQorCitjb25maWcgQklOREdFTl9WRVJTSU9OX1RFWFQKKwlzdHJpbmcK KwlkZXBlbmRzIG9uIFJVU1QKKwlkZWZhdWx0ICQoc2hlbGwsY29tbWFuZCAtdiAkKEJJTkRHRU4p ID4vZGV2L251bGwgMj4mMSAmJiAkKEJJTkRHRU4pIC0tdmVyc2lvbiB8fCBlY2hvIG4pCisKICMK ICMgUGxhY2UgYW4gZW1wdHkgZnVuY3Rpb24gY2FsbCBhdCBlYWNoIHRyYWNlcG9pbnQgc2l0ZS4g Q2FuIGJlCiAjIGR5bmFtaWNhbGx5IGNoYW5nZWQgZm9yIGEgcHJvYmUgZnVuY3Rpb24uCmRpZmYg LS1naXQgYS9saWIvS2NvbmZpZy5kZWJ1ZyBiL2xpYi9LY29uZmlnLmRlYnVnCmluZGV4IDJlMjRk YjRiZmYxOS4uYWUzYzQzZTAwOTJlIDEwMDY0NAotLS0gYS9saWIvS2NvbmZpZy5kZWJ1ZworKysg Yi9saWIvS2NvbmZpZy5kZWJ1ZwpAQCAtMjY4OCw2ICsyNjg4LDg4IEBAIGNvbmZpZyBIWVBFUlZf VEVTVElORwogCiBlbmRtZW51ICMgIktlcm5lbCBUZXN0aW5nIGFuZCBDb3ZlcmFnZSIKIAorbWVu dSAiUnVzdCBoYWNraW5nIgorCitjb25maWcgUlVTVF9ERUJVR19BU1NFUlRJT05TCisJYm9vbCAi RGVidWcgYXNzZXJ0aW9ucyIKKwlkZXBlbmRzIG9uIFJVU1QKKwloZWxwCisJICBFbmFibGVzIHJ1 c3RjJ3MgYC1DZGVidWctYXNzZXJ0aW9uc2AgY29kZWdlbiBvcHRpb24uCisKKwkgIFRoaXMgZmxh ZyBsZXRzIHlvdSB0dXJuIGBjZmcoZGVidWdfYXNzZXJ0aW9ucylgIGNvbmRpdGlvbmFsCisJICBj b21waWxhdGlvbiBvbiBvciBvZmYuIFRoaXMgY2FuIGJlIHVzZWQgdG8gZW5hYmxlIGV4dHJhIGRl YnVnZ2luZworCSAgY29kZSBpbiBkZXZlbG9wbWVudCBidXQgbm90IGluIHByb2R1Y3Rpb24uIEZv ciBleGFtcGxlLCBpdCBjb250cm9scworCSAgdGhlIGJlaGF2aW9yIG9mIHRoZSBzdGFuZGFyZCBs aWJyYXJ5J3MgYGRlYnVnX2Fzc2VydCFgIG1hY3JvLgorCisJICBOb3RlIHRoYXQgdGhpcyB3aWxs IGFwcGx5IHRvIGFsbCBSdXN0IGNvZGUsIGluY2x1ZGluZyBgY29yZWAuCisKKwkgIElmIHVuc3Vy ZSwgc2F5IE4uCisKK2NvbmZpZyBSVVNUX09WRVJGTE9XX0NIRUNLUworCWJvb2wgIk92ZXJmbG93 IGNoZWNrcyIKKwlkZWZhdWx0IHkKKwlkZXBlbmRzIG9uIFJVU1QKKwloZWxwCisJICBFbmFibGVz IHJ1c3RjJ3MgYC1Db3ZlcmZsb3ctY2hlY2tzYCBjb2RlZ2VuIG9wdGlvbi4KKworCSAgVGhpcyBm bGFnIGFsbG93cyB5b3UgdG8gY29udHJvbCB0aGUgYmVoYXZpb3Igb2YgcnVudGltZSBpbnRlZ2Vy CisJICBvdmVyZmxvdy4gV2hlbiBvdmVyZmxvdy1jaGVja3MgYXJlIGVuYWJsZWQsIGEgUnVzdCBw YW5pYyB3aWxsIG9jY3VyCisJICBvbiBvdmVyZmxvdy4KKworCSAgTm90ZSB0aGF0IHRoaXMgd2ls bCBhcHBseSB0byBhbGwgUnVzdCBjb2RlLCBpbmNsdWRpbmcgYGNvcmVgLgorCisJICBJZiB1bnN1 cmUsIHNheSBZLgorCitjaG9pY2UKKwlwcm9tcHQgIkJ1aWxkLXRpbWUgYXNzZXJ0aW9ucyIKKwlk ZWZhdWx0IFJVU1RfQlVJTERfQVNTRVJUX0RFTlkKKwlkZXBlbmRzIG9uIFJVU1QKKwloZWxwCisJ ICBDb250cm9scyBob3cgYXJlIGBidWlsZF9lcnJvciFgIGFuZCBgYnVpbGRfYXNzZXJ0IWAgaGFu ZGxlZCBkdXJpbmcgYnVpbGQuCisKKwkgIElmIGNhbGxzIHRvIHRoZW0gZXhpc3QgaW4gdGhlIGJp bmFyeSwgaXQgbWF5IGluZGljYXRlIGEgdmlvbGF0ZWQgaW52YXJpYW50CisJICBvciB0aGF0IHRo ZSBvcHRpbWl6ZXIgZmFpbGVkIHRvIHZlcmlmeSB0aGUgaW52YXJpYW50IGR1cmluZyBjb21waWxh dGlvbi4KKwkgIFlvdSBjYW4gY2hvb3NlIHRvIGFib3J0IGNvbXBpbGF0aW9uIG9yIGlnbm9yZSB0 aGVtIGR1cmluZyBidWlsZCBhbmQgbGV0IHRoZQorCSAgY2hlY2sgYmUgY2FycmllZCB0byBydW50 aW1lLgorCisJICBJZiBvcHRpbWl6YXRpb25zIGFyZSB0dXJuZWQgb2ZmLCB5b3UgY2Fubm90IHNl bGVjdCAiRGVueSIuCisKKwkgIElmIHVuc3VyZSwgc2F5ICJEZW55Ii4KKworY29uZmlnIFJVU1Rf QlVJTERfQVNTRVJUX0FMTE9XCisJYm9vbCAiQWxsb3ciCisJaGVscAorCSAgVW5vcHRpbWl6ZWQg Y2FsbHMgdG8gYGJ1aWxkX2Vycm9yIWAgd2lsbCBiZSBjb252ZXJ0ZWQgdG8gYHBhbmljIWAKKwkg IGFuZCBjaGVja2VkIGF0IHJ1bnRpbWUuCisKK2NvbmZpZyBSVVNUX0JVSUxEX0FTU0VSVF9XQVJO CisJYm9vbCAiV2FybiIKKwloZWxwCisJICBVbm9wdGltaXplZCBjYWxscyB0byBgYnVpbGRfZXJy b3IhYCB3aWxsIGJlIGNvbnZlcnRlZCB0byBgcGFuaWMhYAorCSAgYW5kIGNoZWNrZWQgYXQgcnVu dGltZSwgYnV0IHdhcm5pbmdzIHdpbGwgYmUgZ2VuZXJhdGVkIHdoZW4gYnVpbGRpbmcuCisKK2Nv bmZpZyBSVVNUX0JVSUxEX0FTU0VSVF9ERU5ZCisJYm9vbCAiRGVueSIKKwloZWxwCisJICBVbm9w dGltaXplZCBjYWxscyB0byBgYnVpbGRfZXJyb3IhYCB3aWxsIGFib3J0IGNvbXBpbGF0aW9uLgor CitlbmRjaG9pY2UKKworY29uZmlnIFJVU1RfS0VSTkVMX0tVTklUX1RFU1QKKwlib29sICJLVW5p dCB0ZXN0IGZvciB0aGUgYGtlcm5lbGAgY3JhdGUiIGlmICFLVU5JVF9BTExfVEVTVFMKKwlkZXBl bmRzIG9uIFJVU1QgJiYgS1VOSVQ9eQorCWRlZmF1bHQgS1VOSVRfQUxMX1RFU1RTCisJaGVscAor CSAgVGhpcyBidWlsZHMgdGhlIGRvY3VtZW50YXRpb24gdGVzdHMgb2YgdGhlIGBrZXJuZWxgIGNy YXRlCisJICBhcyBLVW5pdCB0ZXN0cy4KKworCSAgRm9yIG1vcmUgaW5mb3JtYXRpb24gb24gS1Vu aXQgYW5kIHVuaXQgdGVzdHMgaW4gZ2VuZXJhbCwKKwkgIHBsZWFzZSByZWZlciB0byB0aGUgS1Vu aXQgZG9jdW1lbnRhdGlvbiBpbiBEb2N1bWVudGF0aW9uL2Rldi10b29scy9rdW5pdC8uCisKKwkg IElmIHVuc3VyZSwgc2F5IE4uCisKK2VuZG1lbnUgIyAiUnVzdCIKKwogc291cmNlICJEb2N1bWVu dGF0aW9uL0tjb25maWciCiAKIGVuZG1lbnUgIyBLZXJuZWwgaGFja2luZwpkaWZmIC0tZ2l0IGEv cnVzdC8uZ2l0aWdub3JlIGIvcnVzdC8uZ2l0aWdub3JlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMC4uODliNjAyZDkxMTA5Ci0tLSAvZGV2L251bGwKKysrIGIvcnVzdC8u Z2l0aWdub3JlCkBAIC0wLDAgKzEsMTAgQEAKKyMgU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQ TC0yLjAKKwordGFyZ2V0Lmpzb24KK2JpbmRpbmdzX2dlbmVyYXRlZC5ycworYmluZGluZ3NfaGVs cGVyc19nZW5lcmF0ZWQucnMKK2V4cG9ydHNfKl9nZW5lcmF0ZWQuaAorZG9jdGVzdHNfa2VybmVs X2dlbmVyYXRlZC5ycworZG9jdGVzdHNfa2VybmVsX2dlbmVyYXRlZF9rdW5pdC5jCitkb2MvCit0 ZXN0LwpkaWZmIC0tZ2l0IGEvcnVzdC9NYWtlZmlsZSBiL3J1c3QvTWFrZWZpbGUKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi4zMGNlMTNmYThkYWQKLS0tIC9kZXYvbnVs bAorKysgYi9ydXN0L01ha2VmaWxlCkBAIC0wLDAgKzEsNDE1IEBACisjIFNQRFgtTGljZW5zZS1J ZGVudGlmaWVyOiBHUEwtMi4wCisKK2Fsd2F5cy0kKENPTkZJR19SVVNUKSArPSB0YXJnZXQuanNv bgorbm8tY2xlYW4tZmlsZXMgKz0gdGFyZ2V0Lmpzb24KKworb2JqLSQoQ09ORklHX1JVU1QpICs9 IGNvcmUubyBjb21waWxlcl9idWlsdGlucy5vCithbHdheXMtJChDT05GSUdfUlVTVCkgKz0gZXhw b3J0c19jb3JlX2dlbmVyYXRlZC5oCisKKyMgTWlzc2luZyBwcm90b3R5cGVzIGFyZSBleHBlY3Rl ZCBpbiB0aGUgaGVscGVycyBzaW5jZSB0aGVzZSBhcmUgZXhwb3J0ZWQKKyMgZm9yIFJ1c3Qgb25s eSwgdGh1cyB0aGVyZSBpcyBubyBoZWFkZXIgbm9yIHByb3RvdHlwZXMuCitvYmotJChDT05GSUdf UlVTVCkgKz0gaGVscGVycy5vCitDRkxBR1NfUkVNT1ZFX2hlbHBlcnMubyA9IC1XbWlzc2luZy1w cm90b3R5cGVzIC1XbWlzc2luZy1kZWNsYXJhdGlvbnMKKworYWx3YXlzLSQoQ09ORklHX1JVU1Qp ICs9IGxpYm1hY3Jvcy5zbworbm8tY2xlYW4tZmlsZXMgKz0gbGlibWFjcm9zLnNvCisKK2Fsd2F5 cy0kKENPTkZJR19SVVNUKSArPSBiaW5kaW5ncy9iaW5kaW5nc19nZW5lcmF0ZWQucnMgYmluZGlu Z3MvYmluZGluZ3NfaGVscGVyc19nZW5lcmF0ZWQucnMKK29iai0kKENPTkZJR19SVVNUKSArPSBh bGxvYy5vIGJpbmRpbmdzLm8ga2VybmVsLm8KK2Fsd2F5cy0kKENPTkZJR19SVVNUKSArPSBleHBv cnRzX2FsbG9jX2dlbmVyYXRlZC5oIGV4cG9ydHNfYmluZGluZ3NfZ2VuZXJhdGVkLmggXAorICAg IGV4cG9ydHNfa2VybmVsX2dlbmVyYXRlZC5oCisKK2lmZGVmIENPTkZJR19SVVNUX0JVSUxEX0FT U0VSVF9ERU5ZCithbHdheXMtJChDT05GSUdfUlVTVCkgKz0gYnVpbGRfZXJyb3IubworZWxzZQor b2JqLSQoQ09ORklHX1JVU1QpICs9IGJ1aWxkX2Vycm9yLm8KK2VuZGlmCisKK29iai0kKENPTkZJ R19SVVNUKSArPSBleHBvcnRzLm8KKworb2JqLSQoQ09ORklHX1JVU1RfS0VSTkVMX0tVTklUX1RF U1QpICs9IGRvY3Rlc3RzX2tlcm5lbF9nZW5lcmF0ZWQubworb2JqLSQoQ09ORklHX1JVU1RfS0VS TkVMX0tVTklUX1RFU1QpICs9IGRvY3Rlc3RzX2tlcm5lbF9nZW5lcmF0ZWRfa3VuaXQubworCisj IEF2b2lkcyBydW5uaW5nIGAkKFJVU1RDKWAgZm9yIHRoZSBzeXNyb290IHdoZW4gaXQgbWF5IG5v dCBiZSBhdmFpbGFibGUuCitpZmRlZiBDT05GSUdfUlVTVAorCisjIGAkKHJ1c3RfZmxhZ3MpYCBp cyBwYXNzZWQgaW4gY2FzZSB0aGUgdXNlciBhZGRlZCBgLS1zeXNyb290YC4KK3J1c3RjX3N5c3Jv b3QgOj0gJChzaGVsbCAkKFJVU1RDKSAkKHJ1c3RfZmxhZ3MpIC0tcHJpbnQgc3lzcm9vdCkKK3J1 c3RjX2hvc3RfdGFyZ2V0IDo9ICQoc2hlbGwgJChSVVNUQykgLS12ZXJzaW9uIC0tdmVyYm9zZSB8 IGdyZXAgLUYgJ2hvc3Q6ICcgfCBjdXQgLWQnICcgLWYyKQorUlVTVF9MSUJfU1JDID89ICQocnVz dGNfc3lzcm9vdCkvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeQorCitpZmVxICgkKHF1aWV0 KSxzaWxlbnRfKQorY2FyZ29fcXVpZXQ9LXEKK3J1c3RfdGVzdF9xdWlldD0tcQorcnVzdGRvY190 ZXN0X3F1aWV0PS0tdGVzdC1hcmdzIC1xCitydXN0ZG9jX3Rlc3Rfa2VybmVsX3F1aWV0PT4vZGV2 L251bGwKK2Vsc2UgaWZlcSAoJChxdWlldCkscXVpZXRfKQorcnVzdF90ZXN0X3F1aWV0PS1xCity dXN0ZG9jX3Rlc3RfcXVpZXQ9LS10ZXN0LWFyZ3MgLXEKK3J1c3Rkb2NfdGVzdF9rZXJuZWxfcXVp ZXQ9Pi9kZXYvbnVsbAorZWxzZQorY2FyZ29fcXVpZXQ9LS12ZXJib3NlCitlbmRpZgorCitjb3Jl LWNmZ3MgPSBcCisgICAgLS1jZmcgbm9fZnBfZm10X3BhcnNlCisKK2FsbG9jLWNmZ3MgPSBcCisg ICAgLS1jZmcgbm9fZ2xvYmFsX29vbV9oYW5kbGluZyBcCisgICAgLS1jZmcgbm9fcmMgXAorICAg IC0tY2ZnIG5vX3N5bmMKKworcXVpZXRfY21kX3J1c3Rkb2MgPSBSVVNURE9DICQoaWYgJChydXN0 ZG9jX2hvc3QpLEgsICkgJDwKKyAgICAgIGNtZF9ydXN0ZG9jID0gXAorCU9CSlRSRUU9JChhYnNw YXRoICQob2JqdHJlZSkpIFwKKwkkKFJVU1RET0MpICQoaWYgJChydXN0ZG9jX2hvc3QpLCQocnVz dF9jb21tb25fZmxhZ3MpLCQocnVzdF9mbGFncykpIFwKKwkJJChydXN0Y190YXJnZXRfZmxhZ3Mp IC1MJChvYmp0cmVlKS8kKG9iaikgXAorCQktLW91dHB1dCAkKG9ianRyZWUpLyQob2JqKS9kb2Mg XAorCQktLWNyYXRlLW5hbWUgJChzdWJzdCBydXN0ZG9jLSwsJEApIFwKKwkJQCQob2JqdHJlZSkv aW5jbHVkZS9nZW5lcmF0ZWQvcnVzdGNfY2ZnICQ8CisKKyMgVGhlIGBodG1sX2xvZ29fdXJsYCBh bmQgYGh0bWxfZmF2aWNvbl91cmxgIGZvcm1zIG9mIHRoZSBgZG9jYCBhdHRyaWJ1dGUKKyMgY2Fu IGJlIHVzZWQgdG8gc3BlY2lmeSBhIGN1c3RvbSBsb2dvLiBIb3dldmVyOgorIyAgIC0gVGhlIGdp dmVuIHZhbHVlIGlzIHVzZWQgYXMtaXMsIHRodXMgaXQgY2Fubm90IGJlIHJlbGF0aXZlIG9yIGEg bG9jYWwgZmlsZQorIyAgICAgKHVubGlrZSB0aGUgbm9uLWN1c3RvbSBjYXNlKSBzaW5jZSB0aGUg Z2VuZXJhdGVkIGRvY3MgaGF2ZSBzdWJmb2xkZXJzLgorIyAgIC0gSXQgcmVxdWlyZXMgYWRkaW5n IGl0IHRvIGV2ZXJ5IGNyYXRlLgorIyAgIC0gSXQgcmVxdWlyZXMgY2hhbmdpbmcgYGNvcmVgIHdo aWNoIGNvbWVzIGZyb20gdGhlIHN5c3Jvb3QuCisjCisjIFVzaW5nIGAtWmNyYXRlLWF0dHJgIHdv dWxkIHNvbHZlIHRoZSBsYXN0IHR3byBwb2ludHMsIGJ1dCBub3QgdGhlIGZpcnN0LgorIyBUaGUg aHR0cHM6Ly9naXRodWIuY29tL3J1c3QtbGFuZy9yZmNzL3B1bGwvMzIyNiBSRkMgc3VnZ2VzdHMg dHdvIG5ldworIyBjb21tYW5kLWxpa2UgZmxhZ3MgdG8gc29sdmUgdGhlIGlzc3VlLiBNZWFud2hp bGUsIHdlIHVzZSB0aGUgbm9uLWN1c3RvbSBjYXNlCisjIGFuZCB0aGVuIHJldG91Y2ggdGhlIGdl bmVyYXRlZCBmaWxlcy4KK3J1c3Rkb2M6IHJ1c3Rkb2MtY29yZSBydXN0ZG9jLW1hY3JvcyBydXN0 ZG9jLWNvbXBpbGVyX2J1aWx0aW5zIFwKKyAgICBydXN0ZG9jLWFsbG9jIHJ1c3Rkb2Mta2VybmVs CisJJChRKWNwICQoc3JjdHJlZSkvRG9jdW1lbnRhdGlvbi9pbWFnZXMvbG9nby5zdmcgJChvYmp0 cmVlKS8kKG9iaikvZG9jCisJJChRKWNwICQoc3JjdHJlZSkvRG9jdW1lbnRhdGlvbi9pbWFnZXMv Q09QWUlORy1sb2dvICQob2JqdHJlZSkvJChvYmopL2RvYworCSQoUSlmaW5kICQob2JqdHJlZSkv JChvYmopL2RvYyAtbmFtZSAnKi5odG1sJyAtdHlwZSBmIC1wcmludDAgfCB4YXJncyAtMCBzZWQg LUVpIFwKKwkJLWUgJ3M6cnVzdC1sb2dvXC5zdmc6bG9nby5zdmc6ZycgXAorCQktZSAnczpydXN0 LWxvZ29cLnBuZzpsb2dvLnN2ZzpnJyBcCisJCS1lICdzOmZhdmljb25cLnN2Zzpsb2dvLnN2Zzpn JyBcCisJCS1lICdzOjxsaW5rIHJlbD0iYWx0ZXJuYXRlIGljb24iIHR5cGU9ImltYWdlL3BuZyIg aHJlZj0iWy4vXSpmYXZpY29uLSgxNngxNnwzMngzMilcLnBuZyI+OjpnJworCSQoUSllY2hvICcu bG9nby1jb250YWluZXIgPiBpbWcgeyBvYmplY3QtZml0OiBjb250YWluOyB9JyBcCisJCT4+ICQo b2JqdHJlZSkvJChvYmopL2RvYy9ydXN0ZG9jLmNzcworCitydXN0ZG9jLW1hY3JvczogcHJpdmF0 ZSBydXN0ZG9jX2hvc3QgPSB5ZXMKK3J1c3Rkb2MtbWFjcm9zOiBwcml2YXRlIHJ1c3RjX3Rhcmdl dF9mbGFncyA9IC0tY3JhdGUtdHlwZSBwcm9jLW1hY3JvIFwKKyAgICAtLWV4dGVybiBwcm9jX21h Y3JvCitydXN0ZG9jLW1hY3JvczogJChzcmMpL21hY3Jvcy9saWIucnMgRk9SQ0UKKwkkKGNhbGwg aWZfY2hhbmdlZCxydXN0ZG9jKQorCitydXN0ZG9jLWNvcmU6IHByaXZhdGUgcnVzdGNfdGFyZ2V0 X2ZsYWdzID0gJChjb3JlLWNmZ3MpCitydXN0ZG9jLWNvcmU6ICQoUlVTVF9MSUJfU1JDKS9jb3Jl L3NyYy9saWIucnMgRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxydXN0ZG9jKQorCitydXN0ZG9j LWNvbXBpbGVyX2J1aWx0aW5zOiAkKHNyYykvY29tcGlsZXJfYnVpbHRpbnMucnMgcnVzdGRvYy1j b3JlIEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWQscnVzdGRvYykKKworIyBXZSBuZWVkIHRvIGFs bG93IGBydXN0ZG9jOjpicm9rZW5faW50cmFfZG9jX2xpbmtzYCBiZWNhdXNlIHNvbWUKKyMgYG5v X2dsb2JhbF9vb21faGFuZGxpbmdgIGZ1bmN0aW9ucyByZWZlciB0byBub24tYG5vX2dsb2JhbF9v b21faGFuZGxpbmdgCisjIGZ1bmN0aW9ucy4gSWRlYWxseSBgcnVzdGRvY2Agd291bGQgaGF2ZSBh IHdheSB0byBkaXN0aW5ndWlzaCBicm9rZW4gbGlua3MKKyMgZHVlIHRvIHRoaW5ncyB0aGF0IGFy ZSAiY29uZmlndXJlZCBvdXQiIHZzLiBlbnRpcmVseSBub24tZXhpc3Rpbmcgb25lcy4KK3J1c3Rk b2MtYWxsb2M6IHByaXZhdGUgcnVzdGNfdGFyZ2V0X2ZsYWdzID0gJChhbGxvYy1jZmdzKSBcCisg ICAgLUFydXN0ZG9jOjpicm9rZW5faW50cmFfZG9jX2xpbmtzCitydXN0ZG9jLWFsbG9jOiAkKHNy YykvYWxsb2MvbGliLnJzIHJ1c3Rkb2MtY29yZSBydXN0ZG9jLWNvbXBpbGVyX2J1aWx0aW5zIEZP UkNFCisJJChjYWxsIGlmX2NoYW5nZWQscnVzdGRvYykKKworcnVzdGRvYy1rZXJuZWw6IHByaXZh dGUgcnVzdGNfdGFyZ2V0X2ZsYWdzID0gLS1leHRlcm4gYWxsb2MgXAorICAgIC0tZXh0ZXJuIGJ1 aWxkX2Vycm9yIC0tZXh0ZXJuIG1hY3Jvcz0kKG9ianRyZWUpLyQob2JqKS9saWJtYWNyb3Muc28g XAorICAgIC0tZXh0ZXJuIGJpbmRpbmdzCitydXN0ZG9jLWtlcm5lbDogJChzcmMpL2tlcm5lbC9s aWIucnMgcnVzdGRvYy1jb3JlIHJ1c3Rkb2MtbWFjcm9zIFwKKyAgICBydXN0ZG9jLWNvbXBpbGVy X2J1aWx0aW5zIHJ1c3Rkb2MtYWxsb2MgJChvYmopL2xpYm1hY3Jvcy5zbyBcCisgICAgJChvYmop L2JpbmRpbmdzLm8gRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxydXN0ZG9jKQorCitxdWlldF9j bWRfcnVzdGNfdGVzdF9saWJyYXJ5ID0gUlVTVEMgVEwgJDwKKyAgICAgIGNtZF9ydXN0Y190ZXN0 X2xpYnJhcnkgPSBcCisJT0JKVFJFRT0kKGFic3BhdGggJChvYmp0cmVlKSkgXAorCSQoUlVTVEMp ICQocnVzdF9jb21tb25fZmxhZ3MpIFwKKwkJQCQob2JqdHJlZSkvaW5jbHVkZS9nZW5lcmF0ZWQv cnVzdGNfY2ZnICQocnVzdGNfdGFyZ2V0X2ZsYWdzKSBcCisJCS0tY3JhdGUtdHlwZSAkKGlmICQo cnVzdGNfdGVzdF9saWJyYXJ5X3Byb2MpLHByb2MtbWFjcm8scmxpYikgXAorCQktLW91dC1kaXIg JChvYmp0cmVlKS8kKG9iaikvdGVzdCAtLWNmZyB0ZXN0bGliIFwKKwkJLS1zeXNyb290ICQob2Jq dHJlZSkvJChvYmopL3Rlc3Qvc3lzcm9vdCBcCisJCS1MJChvYmp0cmVlKS8kKG9iaikvdGVzdCBc CisJCS0tY3JhdGUtbmFtZSAkKHN1YnN0IHJ1c3R0ZXN0LSwsJChzdWJzdCBydXN0dGVzdGxpYi0s LCRAKSkgJDwKKworcnVzdHRlc3RsaWItYnVpbGRfZXJyb3I6ICQoc3JjKS9idWlsZF9lcnJvci5y cyBydXN0dGVzdC1wcmVwYXJlIEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWQscnVzdGNfdGVzdF9s aWJyYXJ5KQorCitydXN0dGVzdGxpYi1tYWNyb3M6IHByaXZhdGUgcnVzdGNfdGFyZ2V0X2ZsYWdz ID0gLS1leHRlcm4gcHJvY19tYWNybworcnVzdHRlc3RsaWItbWFjcm9zOiBwcml2YXRlIHJ1c3Rj X3Rlc3RfbGlicmFyeV9wcm9jID0geWVzCitydXN0dGVzdGxpYi1tYWNyb3M6ICQoc3JjKS9tYWNy b3MvbGliLnJzIHJ1c3R0ZXN0LXByZXBhcmUgRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxydXN0 Y190ZXN0X2xpYnJhcnkpCisKK3J1c3R0ZXN0bGliLWJpbmRpbmdzOiAkKHNyYykvYmluZGluZ3Mv bGliLnJzIHJ1c3R0ZXN0LXByZXBhcmUgRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxydXN0Y190 ZXN0X2xpYnJhcnkpCisKK3F1aWV0X2NtZF9ydXN0ZG9jX3Rlc3QgPSBSVVNURE9DIFQgJDwKKyAg ICAgIGNtZF9ydXN0ZG9jX3Rlc3QgPSBcCisJT0JKVFJFRT0kKGFic3BhdGggJChvYmp0cmVlKSkg XAorCSQoUlVTVERPQykgLS10ZXN0ICQocnVzdF9jb21tb25fZmxhZ3MpIFwKKwkJQCQob2JqdHJl ZSkvaW5jbHVkZS9nZW5lcmF0ZWQvcnVzdGNfY2ZnIFwKKwkJJChydXN0Y190YXJnZXRfZmxhZ3Mp ICQocnVzdGRvY190ZXN0X3RhcmdldF9mbGFncykgXAorCQktLXN5c3Jvb3QgJChvYmp0cmVlKS8k KG9iaikvdGVzdC9zeXNyb290ICQocnVzdGRvY190ZXN0X3F1aWV0KSBcCisJCS1MJChvYmp0cmVl KS8kKG9iaikvdGVzdCAtLW91dHB1dCAkKG9ianRyZWUpLyQob2JqKS9kb2MgXAorCQktLWNyYXRl LW5hbWUgJChzdWJzdCBydXN0dGVzdC0sLCRAKSAkPAorCitxdWlldF9jbWRfcnVzdGRvY190ZXN0 X2tlcm5lbCA9IFJVU1RET0MgVEsgJDwKKyAgICAgIGNtZF9ydXN0ZG9jX3Rlc3Rfa2VybmVsID0g XAorCXJtIC1yZiAkKG9ianRyZWUpLyQob2JqKS90ZXN0L2RvY3Rlc3RzL2tlcm5lbDsgXAorCW1r ZGlyIC1wICQob2JqdHJlZSkvJChvYmopL3Rlc3QvZG9jdGVzdHMva2VybmVsOyBcCisJT0JKVFJF RT0kKGFic3BhdGggJChvYmp0cmVlKSkgXAorCSQoUlVTVERPQykgLS10ZXN0ICQocnVzdF9mbGFn cykgXAorCQlAJChvYmp0cmVlKS9pbmNsdWRlL2dlbmVyYXRlZC9ydXN0Y19jZmcgXAorCQktTCQo b2JqdHJlZSkvJChvYmopIC0tZXh0ZXJuIGFsbG9jIC0tZXh0ZXJuIGtlcm5lbCBcCisJCS0tZXh0 ZXJuIGJ1aWxkX2Vycm9yIC0tZXh0ZXJuIG1hY3JvcyBcCisJCS0tZXh0ZXJuIGJpbmRpbmdzIFwK KwkJLS1uby1ydW4gLS1jcmF0ZS1uYW1lIGtlcm5lbCAtWnVuc3RhYmxlLW9wdGlvbnMgXAorCQkt LXRlc3QtYnVpbGRlciAkKHNyY3RyZWUpL3NjcmlwdHMvcnVzdGRvY190ZXN0X2J1aWxkZXIucHkg XAorCQkkPCAkKHJ1c3Rkb2NfdGVzdF9rZXJuZWxfcXVpZXQpOyBcCisJJChzcmN0cmVlKS9zY3Jp cHRzL3J1c3Rkb2NfdGVzdF9nZW4ucHkKKworJS9kb2N0ZXN0c19rZXJuZWxfZ2VuZXJhdGVkLnJz ICUvZG9jdGVzdHNfa2VybmVsX2dlbmVyYXRlZF9rdW5pdC5jOiAkKHNyYykva2VybmVsL2xpYi5y cyAkKG9iaikva2VybmVsLm8gRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxydXN0ZG9jX3Rlc3Rf a2VybmVsKQorCisjIFdlIGNhbm5vdCB1c2UgYC1acGFuaWMtYWJvcnQtdGVzdHNgIGJlY2F1c2Ug c29tZSB0ZXN0cyBhcmUgZHluYW1pYywKKyMgc28gZm9yIHRoZSBtb21lbnQgd2Ugc2tpcCBgLUNw YW5pYz1hYm9ydGAuCitxdWlldF9jbWRfcnVzdGNfdGVzdCA9IFJVU1RDIFQgICQ8CisgICAgICBj bWRfcnVzdGNfdGVzdCA9IFwKKwlPQkpUUkVFPSQoYWJzcGF0aCAkKG9ianRyZWUpKSBcCisJJChS VVNUQykgLS10ZXN0ICQocnVzdF9jb21tb25fZmxhZ3MpIFwKKwkJQCQob2JqdHJlZSkvaW5jbHVk ZS9nZW5lcmF0ZWQvcnVzdGNfY2ZnIFwKKwkJJChydXN0Y190YXJnZXRfZmxhZ3MpIC0tb3V0LWRp ciAkKG9ianRyZWUpLyQob2JqKS90ZXN0IFwKKwkJLS1zeXNyb290ICQob2JqdHJlZSkvJChvYmop L3Rlc3Qvc3lzcm9vdCBcCisJCS1MJChvYmp0cmVlKS8kKG9iaikvdGVzdCBcCisJCS0tY3JhdGUt bmFtZSAkKHN1YnN0IHJ1c3R0ZXN0LSwsJEApICQ8OyBcCisJJChvYmp0cmVlKS8kKG9iaikvdGVz dC8kKHN1YnN0IHJ1c3R0ZXN0LSwsJEApICQocnVzdF90ZXN0X3F1aWV0KSBcCisJCSQocnVzdGNf dGVzdF9ydW5fZmxhZ3MpCisKK3J1c3R0ZXN0OiBydXN0dGVzdC1tYWNyb3MgcnVzdHRlc3Qta2Vy bmVsCisKKyMgVGhpcyBwcmVwYXJlcyBhIGN1c3RvbSBzeXNyb290IHdpdGggb3VyIGN1c3RvbSBg YWxsb2NgIGluc3RlYWQgb2YKKyMgdGhlIHN0YW5kYXJkIG9uZS4KKyMKKyMgVGhpcyByZXF1aXJl cyBzZXZlcmFsIGhhY2tzOgorIyAgIC0gVW5saWtlIGBjb3JlYCBhbmQgYGFsbG9jYCwgYHN0ZGAg ZGVwZW5kcyBvbiBtb3JlIHRoYW4gYSBkb3plbiBjcmF0ZXMsCisjICAgICBpbmNsdWRpbmcgdGhp cmQtcGFydHkgY3JhdGVzIHRoYXQgbmVlZCB0byBiZSBkb3dubG9hZGVkLCBwbHVzIGN1c3RvbQor IyAgICAgYGJ1aWxkLnJzYCBzdGVwcy4gVGh1cyBoYXJkY29kaW5nIHRoaW5ncyBoZXJlIGlzIG5v dCBtYWludGFpbmFibGUuCisjICAgLSBgY2FyZ29gIGtub3dzIGhvdyB0byBidWlsZCB0aGUgc3Rh bmRhcmQgbGlicmFyeSwgYnV0IGl0IGlzIGFuIHVuc3RhYmxlCisjICAgICBmZWF0dXJlIHNvIGZh ciAoYC1aYnVpbGQtc3RkYCkuCisjICAgLSBgY2FyZ29gIG9ubHkgY29uc2lkZXJzIHRoZSB1c2Ug Y2FzZSBvZiBidWlsZGluZyB0aGUgc3RhbmRhcmQgbGlicmFyeQorIyAgICAgdG8gdXNlIGl0IGlu IGEgZ2l2ZW4gcGFja2FnZS4gVGh1cyB3ZSBuZWVkIHRvIGNyZWF0ZSBhIGR1bW15IHBhY2thZ2UK KyMgICAgIGFuZCBwaWNrIHRoZSBnZW5lcmF0ZWQgbGlicmFyaWVzIGZyb20gdGhlcmUuCisjICAg LSBTaW5jZSB3ZSBvbmx5IGtlZXAgYSBzdWJzZXQgb2YgdXBzdHJlYW0gYGFsbG9jYCBpbi10cmVl LCB3ZSBuZWVkCisjICAgICB0byByZWNyZWF0ZSBpdCBvbiB0aGUgZmx5IGJ5IHB1dHRpbmcgb3Vy IHNvdXJjZXMgb24gdG9wLgorIyAgIC0gVGhlIHVzdWFsIHdheXMgb2YgbW9kaWZ5aW5nIHRoZSBk ZXBlbmRlbmN5IGdyYXBoIGluIGBjYXJnb2AgZG8gbm90IHNlZW0KKyMgICAgIHRvIGFwcGx5IGZv ciB0aGUgYC1aYnVpbGQtc3RkYCBzdGVwcywgdGh1cyB3ZSBoYXZlIHRvIG1pc2xlYWQgaXQKKyMg ICAgIGJ5IG1vZGlmeWluZyB0aGUgc291cmNlcyBpbiB0aGUgc3lzcm9vdC4KKyMgICAtIFRvIGF2 b2lkIG1lc3Npbmcgd2l0aCB0aGUgdXNlcidzIFJ1c3QgaW5zdGFsbGF0aW9uLCB3ZSBjcmVhdGUg YSBjbG9uZQorIyAgICAgb2YgdGhlIHN5c3Jvb3QuIEhvd2V2ZXIsIGBjYXJnb2AgaWdub3JlcyBg UlVTVEZMQUdTYCBpbiB0aGUgYC1aYnVpbGQtc3RkYAorIyAgICAgc3RlcHMsIHRodXMgd2UgdXNl IGEgd3JhcHBlciBiaW5hcnkgcGFzc2VkIHZpYSBgUlVTVENgIHRvIHBhc3MgdGhlIGZsYWcuCisj CisjIEluIHRoZSBmdXR1cmUsIHdlIGhvcGUgdG8gYXZvaWQgdGhlIHdob2xlIG9yZGVhbCBieSBl aXRoZXI6CisjICAgLSBNYWtpbmcgdGhlIGB0ZXN0YCBjcmF0ZSBub3QgZGVwZW5kIG9uIGBzdGRg IChlaXRoZXIgaW1wcm92aW5nIHVwc3RyZWFtCisjICAgICBvciBoYXZpbmcgb3VyIG93biBjdXN0 b20gY3JhdGUpLgorIyAgIC0gTWFraW5nIHRoZSB0ZXN0cyBydW4gaW4ga2VybmVsIHNwYWNlIChy ZXF1aXJlcyB0aGUgcHJldmlvdXMgcG9pbnQpLgorIyAgIC0gTWFraW5nIGBzdGRgIGFuZCBmcmll bmRzIGJlIG1vcmUgbGlrZSBhICJub3JtYWwiIGNyYXRlLCBzbyB0aGF0CisjICAgICBgLVpidWls ZC1zdGRgIGFuZCByZWxhdGVkIGhhY2tzIGFyZSBub3QgbmVlZGVkLgorcXVpZXRfY21kX3J1c3Rz eXNyb290ID0gUlVTVFNZU1JPT1QKKyAgICAgIGNtZF9ydXN0c3lzcm9vdCA9IFwKKwlybSAtcmYg JChvYmp0cmVlKS8kKG9iaikvdGVzdDsgXAorCW1rZGlyIC1wICQob2JqdHJlZSkvJChvYmopL3Rl c3Q7IFwKKwljcCAtYSAkKHJ1c3RjX3N5c3Jvb3QpICQob2JqdHJlZSkvJChvYmopL3Rlc3Qvc3lz cm9vdDsgXAorCWNwIC1yICQoc3JjdHJlZSkvJChzcmMpL2FsbG9jLyogXAorCQkkKG9ianRyZWUp LyQob2JqKS90ZXN0L3N5c3Jvb3QvbGliL3J1c3RsaWIvc3JjL3J1c3QvbGlicmFyeS9hbGxvYy9z cmM7IFwKKwllY2hvICdcIyEvYmluL3NoJyA+ICQob2JqdHJlZSkvJChvYmopL3Rlc3QvcnVzdGNf c3lzcm9vdDsgXAorCWVjaG8gIiQoUlVTVEMpIC0tc3lzcm9vdD0kKGFic3BhdGggJChvYmp0cmVl KS8kKG9iaikvdGVzdC9zeXNyb290KSBcIlwkJEBcIiIgXAorCQk+PiAkKG9ianRyZWUpLyQob2Jq KS90ZXN0L3J1c3RjX3N5c3Jvb3Q7IFwKKwljaG1vZCB1K3ggJChvYmp0cmVlKS8kKG9iaikvdGVz dC9ydXN0Y19zeXNyb290OyBcCisJJChDQVJHTykgLXEgbmV3ICQob2JqdHJlZSkvJChvYmopL3Rl c3QvZHVtbXk7IFwKKwlSVVNUQz0kKG9ianRyZWUpLyQob2JqKS90ZXN0L3J1c3RjX3N5c3Jvb3Qg JChDQVJHTykgJChjYXJnb19xdWlldCkgXAorCQl0ZXN0IC1aYnVpbGQtc3RkIC0tdGFyZ2V0ICQo cnVzdGNfaG9zdF90YXJnZXQpIFwKKwkJLS1tYW5pZmVzdC1wYXRoICQob2JqdHJlZSkvJChvYmop L3Rlc3QvZHVtbXkvQ2FyZ28udG9tbDsgXAorCXJtICQob2JqdHJlZSkvJChvYmopL3Rlc3Qvc3lz cm9vdC9saWIvcnVzdGxpYi8kKHJ1c3RjX2hvc3RfdGFyZ2V0KS9saWIvKjsgXAorCWNwICQob2Jq dHJlZSkvJChvYmopL3Rlc3QvZHVtbXkvdGFyZ2V0LyQocnVzdGNfaG9zdF90YXJnZXQpL2RlYnVn L2RlcHMvKiBcCisJCSQob2JqdHJlZSkvJChvYmopL3Rlc3Qvc3lzcm9vdC9saWIvcnVzdGxpYi8k KHJ1c3RjX2hvc3RfdGFyZ2V0KS9saWIKKworcnVzdHRlc3QtcHJlcGFyZTogRk9SQ0UKKwkkKGNh bGwgaWZfY2hhbmdlZCxydXN0c3lzcm9vdCkKKworcnVzdHRlc3QtbWFjcm9zOiBwcml2YXRlIHJ1 c3RjX3RhcmdldF9mbGFncyA9IC0tZXh0ZXJuIHByb2NfbWFjcm8KK3J1c3R0ZXN0LW1hY3Jvczog cHJpdmF0ZSBydXN0ZG9jX3Rlc3RfdGFyZ2V0X2ZsYWdzID0gLS1jcmF0ZS10eXBlIHByb2MtbWFj cm8KK3J1c3R0ZXN0LW1hY3JvczogJChzcmMpL21hY3Jvcy9saWIucnMgcnVzdHRlc3QtcHJlcGFy ZSBGT1JDRQorCSQoY2FsbCBpZl9jaGFuZ2VkLHJ1c3RjX3Rlc3QpCisJJChjYWxsIGlmX2NoYW5n ZWQscnVzdGRvY190ZXN0KQorCitydXN0dGVzdC1rZXJuZWw6IHByaXZhdGUgcnVzdGNfdGFyZ2V0 X2ZsYWdzID0gLS1leHRlcm4gYWxsb2MgXAorICAgIC0tZXh0ZXJuIGJ1aWxkX2Vycm9yIC0tZXh0 ZXJuIG1hY3JvcyAtLWV4dGVybiBiaW5kaW5ncworcnVzdHRlc3Qta2VybmVsOiAkKHNyYykva2Vy bmVsL2xpYi5ycyBydXN0dGVzdC1wcmVwYXJlIFwKKyAgICBydXN0dGVzdGxpYi1idWlsZF9lcnJv ciBydXN0dGVzdGxpYi1tYWNyb3MgcnVzdHRlc3RsaWItYmluZGluZ3MgRk9SQ0UKKwkkKGNhbGwg aWZfY2hhbmdlZCxydXN0Y190ZXN0KQorCSQoY2FsbCBpZl9jaGFuZ2VkLHJ1c3RjX3Rlc3RfbGli cmFyeSkKKworZmlsZWNoa19ydXN0X3RhcmdldCA9ICQob2JqdHJlZSkvc2NyaXB0cy9nZW5lcmF0 ZV9ydXN0X3RhcmdldCA8ICQ8CisKKyQob2JqKS90YXJnZXQuanNvbjogJChvYmp0cmVlKS9pbmNs dWRlL2NvbmZpZy9hdXRvLmNvbmYgRk9SQ0UKKwkkKGNhbGwgZmlsZWNoayxydXN0X3RhcmdldCkK KworaWZkZWYgQ09ORklHX0NDX0lTX0NMQU5HCitiaW5kZ2VuX2NfZmxhZ3MgPSAkKGNfZmxhZ3Mp CitlbHNlCisjIGJpbmRnZW4gcmVsaWVzIG9uIGxpYmNsYW5nIHRvIHBhcnNlIEMuIElkZWFsbHks IGJpbmRnZW4gd291bGQgc3VwcG9ydCBhIEdDQworIyBwbHVnaW4gYmFja2VuZCBhbmQvb3IgdGhl IENsYW5nIGRyaXZlciB3b3VsZCBiZSBwZXJmZWN0bHkgY29tcGF0aWJsZSB3aXRoIEdDQy4KKyMK KyMgRm9yIHRoZSBtb21lbnQsIGhlcmUgd2UgYXJlIHR3ZWFraW5nIHRoZSBmbGFncyBvbiB0aGUg Zmx5LiBUaGlzIGlzIGEgaGFjaywKKyMgYW5kIHNvbWUga2VybmVsIGNvbmZpZ3VyYXRpb25zIG1h eSBub3Qgd29yayAoZS5nLiBgR0NDX1BMVUdJTl9SQU5EU1RSVUNUYAorIyBpZiB3ZSBlbmQgdXAg dXNpbmcgb25lIG9mIHRob3NlIHN0cnVjdHMpLgorYmluZGdlbl9za2lwX2NfZmxhZ3MgOj0gLW1u by1mcC1yZXQtaW4tMzg3IC1tcHJlZmVycmVkLXN0YWNrLWJvdW5kYXJ5PSUgXAorCS1tc2tpcC1y YXgtc2V0dXAgLW1nZW5lcmFsLXJlZ3Mtb25seSAtbXNpZ24tcmV0dXJuLWFkZHJlc3M9JSBcCisJ LW1pbmRpcmVjdC1icmFuY2g9dGh1bmstZXh0ZXJuIC1taW5kaXJlY3QtYnJhbmNoLXJlZ2lzdGVy IFwKKwktbWZ1bmN0aW9uLXJldHVybj10aHVuay1leHRlcm4gLW1yZWNvcmQtbWNvdW50IC1tYWJp PWxwNjQgXAorCS1tc3RhY2stcHJvdGVjdG9yLWd1YXJkJSAtbXRyYWNlYmFjaz1ubyBcCisJLW1u by1wb2ludGVycy10by1uZXN0ZWQtZnVuY3Rpb25zIC1tbm8tc3RyaW5nIFwKKwktbW5vLXN0cmlj dC1hbGlnbiAtbXN0cmljdC1hbGlnbiBcCisJLWZjb25zZXJ2ZS1zdGFjayAtZmFsaWduLWp1bXBz PSUgLWZhbGlnbi1sb29wcz0lIFwKKwktZmVtaXQtc3RydWN0LWRlYnVnLWJhc2Vvbmx5IC1mbm8t aXBhLWNwLWNsb25lIC1mbm8taXBhLXNyYSBcCisJLWZuby1wYXJ0aWFsLWlubGluaW5nIC1mcGx1 Z2luLWFyZy1hcm1fc3NwX3Blcl90YXNrX3BsdWdpbi0lIFwKKwktZm5vLXJlb3JkZXItYmxvY2tz IC1mbm8tYWxsb3ctc3RvcmUtZGF0YS1yYWNlcyAtZmFzYW4tc2hhZG93LW9mZnNldD0lIFwKKwkt Znplcm8tY2FsbC11c2VkLXJlZ3M9JSAtZm5vLXN0YWNrLWNsYXNoLXByb3RlY3Rpb24gXAorCS1m bm8taW5saW5lLWZ1bmN0aW9ucy1jYWxsZWQtb25jZSBcCisJLS1wYXJhbT0lIC0tcGFyYW0gYXNh bi0lCisKKyMgRGVyaXZlZCBmcm9tIGBzY3JpcHRzL01ha2VmaWxlLmNsYW5nYC4KK0JJTkRHRU5f VEFSR0VUX2FybQk6PSBhcm0tbGludXgtZ251ZWFiaQorQklOREdFTl9UQVJHRVRfYXJtNjQJOj0g YWFyY2g2NC1saW51eC1nbnUKK0JJTkRHRU5fVEFSR0VUX3Bvd2VycGMJOj0gcG93ZXJwYzY0bGUt bGludXgtZ251CitCSU5ER0VOX1RBUkdFVF9yaXNjdgk6PSByaXNjdjY0LWxpbnV4LWdudQorQklO REdFTl9UQVJHRVRfeDg2CTo9IHg4Nl82NC1saW51eC1nbnUKK0JJTkRHRU5fVEFSR0VUCQk6PSAk KEJJTkRHRU5fVEFSR0VUXyQoU1JDQVJDSCkpCisKKyMgQWxsIHdhcm5pbmdzIGFyZSBpbmhpYml0 ZWQgc2luY2UgR0NDIGJ1aWxkcyBhcmUgdmVyeSBleHBlcmltZW50YWwsCisjIG1hbnkgR0NDIHdh cm5pbmdzIGFyZSBub3Qgc3VwcG9ydGVkIGJ5IENsYW5nLCB0aGV5IG1heSBvbmx5IGFwcGVhciBp bgorIyBzb21lIGNvbmZpZ3VyYXRpb25zLCB3aXRoIG5ldyBHQ0MgdmVyc2lvbnMsIGV0Yy4KK2Jp bmRnZW5fZXh0cmFfY19mbGFncyA9IC13IC0tdGFyZ2V0PSQoQklOREdFTl9UQVJHRVQpCisKK2Jp bmRnZW5fY19mbGFncyA9ICQoZmlsdGVyLW91dCAkKGJpbmRnZW5fc2tpcF9jX2ZsYWdzKSwgJChj X2ZsYWdzKSkgXAorCSQoYmluZGdlbl9leHRyYV9jX2ZsYWdzKQorZW5kaWYKKworaWZkZWYgQ09O RklHX0xUTworYmluZGdlbl9jX2ZsYWdzX2x0byA9ICQoZmlsdGVyLW91dCAkKENDX0ZMQUdTX0xU TyksICQoYmluZGdlbl9jX2ZsYWdzKSkKK2Vsc2UKK2JpbmRnZW5fY19mbGFnc19sdG8gPSAkKGJp bmRnZW5fY19mbGFncykKK2VuZGlmCisKK2JpbmRnZW5fY19mbGFnc19maW5hbCA9ICQoYmluZGdl bl9jX2ZsYWdzX2x0bykgLURfX0JJTkRHRU5fXworCitxdWlldF9jbWRfYmluZGdlbiA9IEJJTkRH RU4gJEAKKyAgICAgIGNtZF9iaW5kZ2VuID0gXAorCSQoQklOREdFTikgJDwgJChiaW5kZ2VuX3Rh cmdldF9mbGFncykgXAorCQktLXVzZS1jb3JlIC0td2l0aC1kZXJpdmUtZGVmYXVsdCAtLWN0eXBl cy1wcmVmaXggY29yZTo6ZmZpIC0tbm8tbGF5b3V0LXRlc3RzIFwKKwkJLS1uby1kZWJ1ZyAnLion IFwKKwkJLS1zaXplX3QtaXMtdXNpemUgLW8gJEAgLS0gJChiaW5kZ2VuX2NfZmxhZ3NfZmluYWwp IC1ETU9EVUxFIFwKKwkJJChiaW5kZ2VuX3RhcmdldF9jZmxhZ3MpICQoYmluZGdlbl90YXJnZXRf ZXh0cmEpCisKKyQob2JqKS9iaW5kaW5ncy9iaW5kaW5nc19nZW5lcmF0ZWQucnM6IHByaXZhdGUg YmluZGdlbl90YXJnZXRfZmxhZ3MgPSBcCisgICAgJChzaGVsbCBncmVwIC12ICdeXCNcfF4kJCcg JChzcmN0cmVlKS8kKHNyYykvYmluZGdlbl9wYXJhbWV0ZXJzKQorJChvYmopL2JpbmRpbmdzL2Jp bmRpbmdzX2dlbmVyYXRlZC5yczogJChzcmMpL2JpbmRpbmdzL2JpbmRpbmdzX2hlbHBlci5oIFwK KyAgICAkKHNyYykvYmluZGdlbl9wYXJhbWV0ZXJzIEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWRf ZGVwLGJpbmRnZW4pCisKKyMgU2VlIGBDRkxBR1NfUkVNT1ZFX2hlbHBlcnMub2AgYWJvdmUuIElu IGFkZGl0aW9uLCBDbGFuZyBvbiBDIGRvZXMgbm90IHdhcm4KKyMgd2l0aCBgLVdtaXNzaW5nLWRl Y2xhcmF0aW9uc2AgKHVubGlrZSBHQ0MpLCBzbyBpdCBpcyBub3Qgc3RyaWN0bHkgbmVlZGVkIGhl cmUKKyMgZ2l2ZW4gaXQgaXMgYGxpYmNsYW5nYDsgYnV0IGZvciBjb25zaXN0ZW5jeSwgZnV0dXJl IENsYW5nIGNoYW5nZXMgYW5kL29yCisjIGEgcG90ZW50aWFsIGZ1dHVyZSBHQ0MgYmFja2VuZCBm b3IgYGJpbmRnZW5gLCB3ZSBkaXNhYmxlIGl0IHRvby4KKyQob2JqKS9iaW5kaW5ncy9iaW5kaW5n c19oZWxwZXJzX2dlbmVyYXRlZC5yczogcHJpdmF0ZSBiaW5kZ2VuX3RhcmdldF9mbGFncyA9IFwK KyAgICAtLWJsYWNrbGlzdC10eXBlICcuKicgLS13aGl0ZWxpc3QtdmFyICcnIFwKKyAgICAtLXdo aXRlbGlzdC1mdW5jdGlvbiAncnVzdF9oZWxwZXJfLionCiskKG9iaikvYmluZGluZ3MvYmluZGlu Z3NfaGVscGVyc19nZW5lcmF0ZWQucnM6IHByaXZhdGUgYmluZGdlbl90YXJnZXRfY2ZsYWdzID0g XAorICAgIC1JJChvYmp0cmVlKS8kKG9iaikgLVduby1taXNzaW5nLXByb3RvdHlwZXMgLVduby1t aXNzaW5nLWRlY2xhcmF0aW9ucworJChvYmopL2JpbmRpbmdzL2JpbmRpbmdzX2hlbHBlcnNfZ2Vu ZXJhdGVkLnJzOiBwcml2YXRlIGJpbmRnZW5fdGFyZ2V0X2V4dHJhID0gOyBcCisgICAgc2VkIC1F aSAncy9wdWIgZm4gcnVzdF9oZWxwZXJfKFthLXpBLVowLTlfXSopLyNbbGlua19uYW1lPSJydXN0 X2hlbHBlcl9cMSJdXG4gICAgcHViIGZuIFwxL2cnICRACiskKG9iaikvYmluZGluZ3MvYmluZGlu Z3NfaGVscGVyc19nZW5lcmF0ZWQucnM6ICQoc3JjKS9oZWxwZXJzLmMgRk9SQ0UKKwkkKGNhbGwg aWZfY2hhbmdlZF9kZXAsYmluZGdlbikKKworcXVpZXRfY21kX2V4cG9ydHMgPSBFWFBPUlRTICRA CisgICAgICBjbWRfZXhwb3J0cyA9IFwKKwkkKE5NKSAtcCAtLWRlZmluZWQtb25seSAkPCBcCisJ CXwgZ3JlcCAtRSAnIChUfFJ8RCkgJyB8IGN1dCAtZCAnICcgLWYgMyBcCisJCXwgeGFyZ3MgLUlz eW1ib2wgXAorCQllY2hvICdFWFBPUlRfU1lNQk9MX1JVU1RfR1BMKHN5bWJvbCk7JyA+ICRACisK KyQob2JqKS9leHBvcnRzX2NvcmVfZ2VuZXJhdGVkLmg6ICQob2JqKS9jb3JlLm8gRk9SQ0UKKwkk KGNhbGwgaWZfY2hhbmdlZCxleHBvcnRzKQorCiskKG9iaikvZXhwb3J0c19hbGxvY19nZW5lcmF0 ZWQuaDogJChvYmopL2FsbG9jLm8gRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxleHBvcnRzKQor CiskKG9iaikvZXhwb3J0c19iaW5kaW5nc19nZW5lcmF0ZWQuaDogJChvYmopL2JpbmRpbmdzLm8g Rk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdlZCxleHBvcnRzKQorCiskKG9iaikvZXhwb3J0c19rZXJu ZWxfZ2VuZXJhdGVkLmg6ICQob2JqKS9rZXJuZWwubyBGT1JDRQorCSQoY2FsbCBpZl9jaGFuZ2Vk LGV4cG9ydHMpCisKK3F1aWV0X2NtZF9ydXN0Y19wcm9jbWFjcm8gPSAkKFJVU1RDX09SX0NMSVBQ WV9RVUlFVCkgUCAkQAorICAgICAgY21kX3J1c3RjX3Byb2NtYWNybyA9IFwKKwkkKFJVU1RDX09S X0NMSVBQWSkgJChydXN0X2NvbW1vbl9mbGFncykgXAorCQktLWVtaXQ9ZGVwLWluZm8sbGluayAt LWV4dGVybiBwcm9jX21hY3JvIFwKKwkJLS1jcmF0ZS10eXBlIHByb2MtbWFjcm8gLS1vdXQtZGly ICQob2JqdHJlZSkvJChvYmopIFwKKwkJLS1jcmF0ZS1uYW1lICQocGF0c3Vic3QgbGliJS5zbywl LCQobm90ZGlyICRAKSkgJDw7IFwKKwltdiAkKG9ianRyZWUpLyQob2JqKS8kKHBhdHN1YnN0IGxp YiUuc28sJSwkKG5vdGRpciAkQCkpLmQgJChkZXBmaWxlKTsgXAorCXNlZCAtaSAnL15cIy9kJyAk KGRlcGZpbGUpCisKKyMgUHJvY2VkdXJhbCBtYWNyb3MgY2FuIG9ubHkgYmUgdXNlZCB3aXRoIHRo ZSBgcnVzdGNgIHRoYXQgY29tcGlsZWQgaXQuCisjIFRoZXJlZm9yZSwgdG8gZ2V0IGBsaWJtYWNy b3Muc29gIGF1dG9tYXRpY2FsbHkgcmVjb21waWxlZCB3aGVuIHRoZSBjb21waWxlcgorIyB2ZXJz aW9uIGNoYW5nZXMsIHdlIGFkZCBgY29yZS5vYCBhcyBhIGRlcGVuZGVuY3kgKGV2ZW4gaWYgaXQg aXMgbm90IG5lZWRlZCkuCiskKG9iaikvbGlibWFjcm9zLnNvOiAkKHNyYykvbWFjcm9zL2xpYi5y cyAkKG9iaikvY29yZS5vIEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWRfZGVwLHJ1c3RjX3Byb2Nt YWNybykKKworcXVpZXRfY21kX3J1c3RjX2xpYnJhcnkgPSAkKGlmICQoc2tpcF9jbGlwcHkpLFJV U1RDLCQoUlVTVENfT1JfQ0xJUFBZX1FVSUVUKSkgTCAkQAorICAgICAgY21kX3J1c3RjX2xpYnJh cnkgPSBcCisJT0JKVFJFRT0kKGFic3BhdGggJChvYmp0cmVlKSkgXAorCSQoaWYgJChza2lwX2Ns aXBweSksJChSVVNUQyksJChSVVNUQ19PUl9DTElQUFkpKSBcCisJCSQoZmlsdGVyLW91dCAkKHNr aXBfZmxhZ3MpLCQocnVzdF9mbGFncykgJChydXN0Y190YXJnZXRfZmxhZ3MpKSBcCisJCS0tZW1p dD1kZXAtaW5mbyxvYmosbWV0YWRhdGEgLS1jcmF0ZS10eXBlIHJsaWIgXAorCQktLW91dC1kaXIg JChvYmp0cmVlKS8kKG9iaikgLUwkKG9ianRyZWUpLyQob2JqKSBcCisJCS0tY3JhdGUtbmFtZSAk KHBhdHN1YnN0ICUubywlLCQobm90ZGlyICRAKSkgJDw7IFwKKwltdiAkKG9ianRyZWUpLyQob2Jq KS8kKHBhdHN1YnN0ICUubywlLCQobm90ZGlyICRAKSkuZCAkKGRlcGZpbGUpOyBcCisJc2VkIC1p ICcvXlwjL2QnICQoZGVwZmlsZSkgXAorCSQoaWYgJChydXN0Y19vYmpjb3B5KSw7JChPQkpDT1BZ KSAkKHJ1c3RjX29iamNvcHkpICRAKQorCitydXN0LWFuYWx5emVyOgorCSQoUSkkKHNyY3RyZWUp L3NjcmlwdHMvZ2VuZXJhdGVfcnVzdF9hbmFseXplci5weSAkKHNyY3RyZWUpICQob2JqdHJlZSkg XAorCQkkKFJVU1RfTElCX1NSQykgPiAkKG9ianRyZWUpL3J1c3QtcHJvamVjdC5qc29uCisKKyQo b2JqKS9jb3JlLm86IHByaXZhdGUgc2tpcF9jbGlwcHkgPSAxCiskKG9iaikvY29yZS5vOiBwcml2 YXRlIHNraXBfZmxhZ3MgPSAtRHVucmVhY2hhYmxlX3B1YgorJChvYmopL2NvcmUubzogcHJpdmF0 ZSBydXN0Y190YXJnZXRfZmxhZ3MgPSAkKGNvcmUtY2ZncykKKyQob2JqKS9jb3JlLm86ICQoUlVT VF9MSUJfU1JDKS9jb3JlL3NyYy9saWIucnMgJChvYmopL3RhcmdldC5qc29uIEZPUkNFCisJJChj YWxsIGlmX2NoYW5nZWRfZGVwLHJ1c3RjX2xpYnJhcnkpCisKKyQob2JqKS9jb21waWxlcl9idWls dGlucy5vOiBwcml2YXRlIHJ1c3RjX29iamNvcHkgPSAtdyAtVyAnX18qJworJChvYmopL2NvbXBp bGVyX2J1aWx0aW5zLm86ICQoc3JjKS9jb21waWxlcl9idWlsdGlucy5ycyAkKG9iaikvY29yZS5v IEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWRfZGVwLHJ1c3RjX2xpYnJhcnkpCisKKyQob2JqKS9h bGxvYy5vOiBwcml2YXRlIHNraXBfY2xpcHB5ID0gMQorJChvYmopL2FsbG9jLm86IHByaXZhdGUg c2tpcF9mbGFncyA9IC1EdW5yZWFjaGFibGVfcHViCiskKG9iaikvYWxsb2MubzogcHJpdmF0ZSBy dXN0Y190YXJnZXRfZmxhZ3MgPSAkKGFsbG9jLWNmZ3MpCiskKG9iaikvYWxsb2MubzogJChzcmMp L2FsbG9jL2xpYi5ycyAkKG9iaikvY29tcGlsZXJfYnVpbHRpbnMubyBGT1JDRQorCSQoY2FsbCBp Zl9jaGFuZ2VkX2RlcCxydXN0Y19saWJyYXJ5KQorCiskKG9iaikvYnVpbGRfZXJyb3IubzogJChz cmMpL2J1aWxkX2Vycm9yLnJzICQob2JqKS9jb21waWxlcl9idWlsdGlucy5vIEZPUkNFCisJJChj YWxsIGlmX2NoYW5nZWRfZGVwLHJ1c3RjX2xpYnJhcnkpCisKKyQob2JqKS9iaW5kaW5ncy5vOiAk KHNyYykvYmluZGluZ3MvbGliLnJzIFwKKyAgICAkKG9iaikvY29tcGlsZXJfYnVpbHRpbnMubyBc CisgICAgJChvYmopL2JpbmRpbmdzL2JpbmRpbmdzX2dlbmVyYXRlZC5ycyBcCisgICAgJChvYmop L2JpbmRpbmdzL2JpbmRpbmdzX2hlbHBlcnNfZ2VuZXJhdGVkLnJzIEZPUkNFCisJJChjYWxsIGlm X2NoYW5nZWRfZGVwLHJ1c3RjX2xpYnJhcnkpCisKKyQob2JqKS9rZXJuZWwubzogcHJpdmF0ZSBy dXN0Y190YXJnZXRfZmxhZ3MgPSAtLWV4dGVybiBhbGxvYyBcCisgICAgLS1leHRlcm4gYnVpbGRf ZXJyb3IgLS1leHRlcm4gbWFjcm9zIC0tZXh0ZXJuIGJpbmRpbmdzCiskKG9iaikva2VybmVsLm86 ICQoc3JjKS9rZXJuZWwvbGliLnJzICQob2JqKS9hbGxvYy5vICQob2JqKS9idWlsZF9lcnJvci5v IFwKKyAgICAkKG9iaikvbGlibWFjcm9zLnNvICQob2JqKS9iaW5kaW5ncy5vIEZPUkNFCisJJChj YWxsIGlmX2NoYW5nZWRfZGVwLHJ1c3RjX2xpYnJhcnkpCisKK2VuZGlmICMgQ09ORklHX1JVU1QK ZGlmZiAtLWdpdCBhL3J1c3QvYmluZGdlbl9wYXJhbWV0ZXJzIGIvcnVzdC9iaW5kZ2VuX3BhcmFt ZXRlcnMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5iZTQ5NjNiZjcy MDMKLS0tIC9kZXYvbnVsbAorKysgYi9ydXN0L2JpbmRnZW5fcGFyYW1ldGVycwpAQCAtMCwwICsx LDIxIEBACisjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisKKy0tb3BhcXVlLXR5 cGUgeHJlZ3Nfc3RhdGUKKy0tb3BhcXVlLXR5cGUgZGVzY19zdHJ1Y3QKKy0tb3BhcXVlLXR5cGUg YXJjaF9sYnJfc3RhdGUKKy0tb3BhcXVlLXR5cGUgbG9jYWxfYXBpYworCisjIFBhY2tlZCB0eXBl IGNhbm5vdCB0cmFuc2l0aXZlbHkgY29udGFpbiBhIGAjW3JlcHIoYWxpZ24pXWAgdHlwZS4KKy0t b3BhcXVlLXR5cGUgeDg2X21zaV9kYXRhCistLW9wYXF1ZS10eXBlIHg4Nl9tc2lfYWRkcl9sbwor CisjIGB0cnlgIGlzIGEgcmVzZXJ2ZWQga2V5d29yZCBzaW5jZSBSdXN0IDIwMTg7IHNvbHZlZCBp biBgYmluZGdlbmAgdjAuNTkuMiwKKyMgY29tbWl0IDJhZWQ2YjAyMTY4MCAoImNvbnRleHQ6IEVz Y2FwZSB0aGUgdHJ5IGtleXdvcmQgcHJvcGVybHkiKS4KKy0tb3BhcXVlLXR5cGUga3VuaXRfdHJ5 X2NhdGNoCisKKyMgSWYgU01QIGlzIGRpc2FibGVkLCBgYXJjaF9zcGlubG9ja190YCBpcyBkZWZp bmVkIGFzIGEgWlNUIHdoaWNoIHRyaWdnZXJzIGEgUnVzdAorIyB3YXJuaW5nLiBXZSBkb24ndCBu ZWVkIHRvIHBlZWsgaW50byBpdCBhbnl3YXkuCistLW9wYXF1ZS10eXBlIHNwaW5sb2NrCisKKyMg YHNlY2NvbXBgJ3MgY29tbWVudCBnZXRzIHVuZGVyc3Rvb2QgYXMgYSBkb2N0ZXN0CistLW5vLWRv Yy1jb21tZW50cwpkaWZmIC0tZ2l0IGEvc2NyaXB0cy8uZ2l0aWdub3JlIGIvc2NyaXB0cy8uZ2l0 aWdub3JlCmluZGV4IGVlZDMwOGJlZjYwNC4uYjdhZWM4ZWIxYmQ0IDEwMDY0NAotLS0gYS9zY3Jp cHRzLy5naXRpZ25vcmUKKysrIGIvc2NyaXB0cy8uZ2l0aWdub3JlCkBAIC0xLDYgKzEsNyBAQAog IyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMC1vbmx5CiAvYXNuMV9jb21waWxlcgog L2JpbjJjCisvZ2VuZXJhdGVfcnVzdF90YXJnZXQKIC9pbnNlcnQtc3lzLWNlcnQKIC9rYWxsc3lt cwogL21vZHVsZS5sZHMKZGlmZiAtLWdpdCBhL3NjcmlwdHMvS2NvbmZpZy5pbmNsdWRlIGIvc2Ny aXB0cy9LY29uZmlnLmluY2x1ZGUKaW5kZXggMDQ5NmVmZDZlMTE3Li44M2U4NTAzMjFlYjYgMTAw NjQ0Ci0tLSBhL3NjcmlwdHMvS2NvbmZpZy5pbmNsdWRlCisrKyBiL3NjcmlwdHMvS2NvbmZpZy5p bmNsdWRlCkBAIC0zNiwxMiArMzYsMTIgQEAgbGQtb3B0aW9uID0gJChzdWNjZXNzLCQoTEQpIC12 ICQoMSkpCiBhcy1pbnN0ciA9ICQoc3VjY2VzcyxwcmludGYgIiViXG4iICIkKDEpIiB8ICQoQ0Mp ICQoQ0xBTkdfRkxBR1MpIC1jIC14IGFzc2VtYmxlciAtbyAvZGV2L251bGwgLSkKIAogIyBjaGVj ayBpZiAkKENDKSBhbmQgJChMRCkgZXhpc3QKLSQoZXJyb3ItaWYsJChmYWlsdXJlLGNvbW1hbmQg LXYgJChDQykpLGNvbXBpbGVyICckKENDKScgbm90IGZvdW5kKQorJChlcnJvci1pZiwkKGZhaWx1 cmUsY29tbWFuZCAtdiAkKENDKSksQyBjb21waWxlciAnJChDQyknIG5vdCBmb3VuZCkKICQoZXJy b3ItaWYsJChmYWlsdXJlLGNvbW1hbmQgLXYgJChMRCkpLGxpbmtlciAnJChMRCknIG5vdCBmb3Vu ZCkKIAotIyBHZXQgdGhlIGNvbXBpbGVyIG5hbWUsIHZlcnNpb24sIGFuZCBlcnJvciBvdXQgaWYg aXQgaXMgbm90IHN1cHBvcnRlZC4KKyMgR2V0IHRoZSBDIGNvbXBpbGVyIG5hbWUsIHZlcnNpb24s IGFuZCBlcnJvciBvdXQgaWYgaXQgaXMgbm90IHN1cHBvcnRlZC4KIGNjLWluZm8gOj0gJChzaGVs bCwkKHNyY3RyZWUpL3NjcmlwdHMvY2MtdmVyc2lvbi5zaCAkKENDKSkKLSQoZXJyb3ItaWYsJChz dWNjZXNzLHRlc3QgLXogIiQoY2MtaW5mbykiKSxTb3JyeSQoY29tbWEpIHRoaXMgY29tcGlsZXIg aXMgbm90IHN1cHBvcnRlZC4pCiskKGVycm9yLWlmLCQoc3VjY2Vzcyx0ZXN0IC16ICIkKGNjLWlu Zm8pIiksU29ycnkkKGNvbW1hKSB0aGlzIEMgY29tcGlsZXIgaXMgbm90IHN1cHBvcnRlZC4pCiBj Yy1uYW1lIDo9ICQoc2hlbGwsc2V0IC0tICQoY2MtaW5mbykgJiYgZWNobyAkMSkKIGNjLXZlcnNp b24gOj0gJChzaGVsbCxzZXQgLS0gJChjYy1pbmZvKSAmJiBlY2hvICQyKQogCmRpZmYgLS1naXQg YS9zY3JpcHRzL01ha2VmaWxlIGIvc2NyaXB0cy9NYWtlZmlsZQppbmRleCBmMDg0ZjA4ZWQxNzYu LjE1NzVhZjg0ZDU1NyAxMDA2NDQKLS0tIGEvc2NyaXB0cy9NYWtlZmlsZQorKysgYi9zY3JpcHRz L01ha2VmaWxlCkBAIC0xMCw2ICsxMCw5IEBAIGhvc3Rwcm9ncy1hbHdheXMtJChDT05GSUdfQlVJ TERUSU1FX1RBQkxFX1NPUlQpCQkrPSBzb3J0dGFibGUKIGhvc3Rwcm9ncy1hbHdheXMtJChDT05G SUdfQVNOMSkJCQkJKz0gYXNuMV9jb21waWxlcgogaG9zdHByb2dzLWFsd2F5cy0kKENPTkZJR19N T0RVTEVfU0lHX0ZPUk1BVCkJCSs9IHNpZ24tZmlsZQogaG9zdHByb2dzLWFsd2F5cy0kKENPTkZJ R19TWVNURU1fRVhUUkFfQ0VSVElGSUNBVEUpCSs9IGluc2VydC1zeXMtY2VydAoraG9zdHByb2dz LWFsd2F5cy0kKENPTkZJR19SVVNUKQkJCQkrPSBnZW5lcmF0ZV9ydXN0X3RhcmdldAorCitnZW5l cmF0ZV9ydXN0X3RhcmdldC1ydXN0IDo9IHkKIAogSE9TVENGTEFHU19zb3J0dGFibGUubyA9IC1J JChzcmN0cmVlKS90b29scy9pbmNsdWRlCiBIT1NUTERMSUJTX3NvcnR0YWJsZSA9IC1scHRocmVh ZApkaWZmIC0tZ2l0IGEvc2NyaXB0cy9NYWtlZmlsZS5idWlsZCBiL3NjcmlwdHMvTWFrZWZpbGUu YnVpbGQKaW5kZXggY2FjMDcwYWVlNzkxLi41YzQ5NTcxM2YxYjEgMTAwNjQ0Ci0tLSBhL3Njcmlw dHMvTWFrZWZpbGUuYnVpbGQKKysrIGIvc2NyaXB0cy9NYWtlZmlsZS5idWlsZApAQCAtMjYsNiAr MjYsNyBAQCBFWFRSQV9DUFBGTEFHUyA6PQogRVhUUkFfTERGTEFHUyAgOj0KIGFzZmxhZ3MteSAg Oj0KIGNjZmxhZ3MteSAgOj0KK3J1c3RmbGFncy15IDo9CiBjcHBmbGFncy15IDo9CiBsZGZsYWdz LXkgIDo9CiAKQEAgLTI3MSw2ICsyNzIsNjUgQEAgcXVpZXRfY21kX2NjX2xzdF9jID0gTUtMU1Qg ICAkQAogJChvYmopLyUubHN0OiAkKHNyYykvJS5jIEZPUkNFCiAJJChjYWxsIGlmX2NoYW5nZWRf ZGVwLGNjX2xzdF9jKQogCisjIENvbXBpbGUgUnVzdCBzb3VyY2VzICgucnMpCisjIC0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLQorCitydXN0X2FsbG93ZWRfZmVhdHVyZXMgOj0gYWxsb2NhdG9yX2FwaSxiZW5j aF9ibGFja19ib3gsY29yZV9mZmlfYyxnZW5lcmljX2Fzc29jaWF0ZWRfdHlwZXMsY29uc3RfcHRy X29mZnNldF9mcm9tLGNvbnN0X3JlZnNfdG9fY2VsbAorCitydXN0X2NvbW1vbl9jbWQgPSBcCisJ UlVTVF9NT0RGSUxFPSQobW9kZmlsZSkgJChSVVNUQ19PUl9DTElQUFkpICQocnVzdF9mbGFncykg XAorCS1aYWxsb3ctZmVhdHVyZXM9JChydXN0X2FsbG93ZWRfZmVhdHVyZXMpIFwKKwktWmNyYXRl LWF0dHI9bm9fc3RkIFwKKwktWmNyYXRlLWF0dHI9J2ZlYXR1cmUoJChydXN0X2FsbG93ZWRfZmVh dHVyZXMpKScgXAorCS0tZXh0ZXJuIGFsbG9jIC0tZXh0ZXJuIGtlcm5lbCBcCisJLS1jcmF0ZS10 eXBlIHJsaWIgLS1vdXQtZGlyICQob2JqKSAtTCAkKG9ianRyZWUpL3J1c3QvIFwKKwktLWNyYXRl LW5hbWUgJChiYXNlbmFtZSAkKG5vdGRpciAkQCkpCisKK3J1c3RfaGFuZGxlX2RlcGZpbGUgPSBc CisJbXYgJChvYmopLyQoYmFzZW5hbWUgJChub3RkaXIgJEApKS5kICQoZGVwZmlsZSk7IFwKKwlz ZWQgLWkgJy9eXCMvZCcgJChkZXBmaWxlKQorCisjIGAtLWVtaXQ9b2JqYCwgYC0tZW1pdD1hc21g IGFuZCBgLS1lbWl0PWxsdm0taXJgIGltcGx5IGEgc2luZ2xlIGNvZGVnZW4gdW5pdAorIyB3aWxs IGJlIHVzZWQuIFdlIGV4cGxpY2l0bHkgcmVxdWVzdCBgLUNjb2RlZ2VuLXVuaXRzPTFgIGluIGFu eSBjYXNlLCBhbmQKKyMgdGhlIGNvbXBpbGVyIHNob3dzIGEgd2FybmluZyBpZiBpdCBpcyBub3Qg MS4gSG93ZXZlciwgaWYgd2UgZXZlciBzdG9wCisjIHJlcXVlc3RpbmcgaXQgZXhwbGljaXRseSBh bmQgd2Ugc3RhcnQgdXNpbmcgc29tZSBvdGhlciBgLS1lbWl0YCB0aGF0IGRvZXMgbm90CisjIGlt cGx5IGl0IChhbmQgZm9yIHdoaWNoIGNvZGVnZW4gaXMgcGVyZm9ybWVkKSwgdGhlbiB3ZSB3b3Vs ZCBiZSBvdXQgb2Ygc3luYywKKyMgaS5lLiB0aGUgb3V0cHV0cyB3ZSB3b3VsZCBnZXQgZm9yIHRo ZSBkaWZmZXJlbnQgc2luZ2xlIHRhcmdldHMgKGUuZy4gYC5sbGApCisjIHdvdWxkIG5vdCBtYXRj aCBlYWNoIG90aGVyLgorCitxdWlldF9jbWRfcnVzdGNfb19ycyA9ICQoUlVTVENfT1JfQ0xJUFBZ X1FVSUVUKSAkKHF1aWV0X21vZHRhZykgJEAKKyAgICAgIGNtZF9ydXN0Y19vX3JzID0gXAorCSQo cnVzdF9jb21tb25fY21kKSAtLWVtaXQ9ZGVwLWluZm8sb2JqICQ8OyBcCisJJChydXN0X2hhbmRs ZV9kZXBmaWxlKQorCiskKG9iaikvJS5vOiAkKHNyYykvJS5ycyBGT1JDRQorCSQoY2FsbCBpZl9j aGFuZ2VkX2RlcCxydXN0Y19vX3JzKQorCitxdWlldF9jbWRfcnVzdGNfcnNpX3JzID0gJChSVVNU Q19PUl9DTElQUFlfUVVJRVQpICQocXVpZXRfbW9kdGFnKSAkQAorICAgICAgY21kX3J1c3RjX3Jz aV9ycyA9IFwKKwkkKHJ1c3RfY29tbW9uX2NtZCkgLS1lbWl0PWRlcC1pbmZvIC1adW5wcmV0dHk9 ZXhwYW5kZWQgJDwgPiRAOyBcCisJY29tbWFuZCAtdiAkKFJVU1RGTVQpID4vZGV2L251bGwgJiYg JChSVVNURk1UKSAkQDsgXAorCSQocnVzdF9oYW5kbGVfZGVwZmlsZSkKKworJChvYmopLyUucnNp OiAkKHNyYykvJS5ycyBGT1JDRQorCSQoY2FsbCBpZl9jaGFuZ2VkX2RlcCxydXN0Y19yc2lfcnMp CisKK3F1aWV0X2NtZF9ydXN0Y19zX3JzID0gJChSVVNUQ19PUl9DTElQUFlfUVVJRVQpICQocXVp ZXRfbW9kdGFnKSAkQAorICAgICAgY21kX3J1c3RjX3NfcnMgPSBcCisJJChydXN0X2NvbW1vbl9j bWQpIC0tZW1pdD1kZXAtaW5mbyxhc20gJDw7IFwKKwkkKHJ1c3RfaGFuZGxlX2RlcGZpbGUpCisK KyQob2JqKS8lLnM6ICQoc3JjKS8lLnJzIEZPUkNFCisJJChjYWxsIGlmX2NoYW5nZWRfZGVwLHJ1 c3RjX3NfcnMpCisKK3F1aWV0X2NtZF9ydXN0Y19sbF9ycyA9ICQoUlVTVENfT1JfQ0xJUFBZX1FV SUVUKSAkKHF1aWV0X21vZHRhZykgJEAKKyAgICAgIGNtZF9ydXN0Y19sbF9ycyA9IFwKKwkkKHJ1 c3RfY29tbW9uX2NtZCkgLS1lbWl0PWRlcC1pbmZvLGxsdm0taXIgJDw7IFwKKwkkKHJ1c3RfaGFu ZGxlX2RlcGZpbGUpCisKKyQob2JqKS8lLmxsOiAkKHNyYykvJS5ycyBGT1JDRQorCSQoY2FsbCBp Zl9jaGFuZ2VkX2RlcCxydXN0Y19sbF9ycykKKwogIyBDb21waWxlIGFzc2VtYmxlciBzb3VyY2Vz ICguUykKICMgLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKZGlmZiAtLWdpdCBhL3NjcmlwdHMvTWFrZWZp bGUuZGVidWcgYi9zY3JpcHRzL01ha2VmaWxlLmRlYnVnCmluZGV4IDlmMzliMDEzMDU1MS4uZmU4 NzM4OWQ1MmMwIDEwMDY0NAotLS0gYS9zY3JpcHRzL01ha2VmaWxlLmRlYnVnCisrKyBiL3Njcmlw dHMvTWFrZWZpbGUuZGVidWcKQEAgLTEsNCArMSw1IEBACiBERUJVR19DRkxBR1MJOj0KK0RFQlVH X1JVU1RGTEFHUwk6PQogCiBpZmRlZiBDT05GSUdfREVCVUdfSU5GT19TUExJVAogREVCVUdfQ0ZM QUdTCSs9IC1nc3BsaXQtZHdhcmYKQEAgLTEwLDYgKzExLDEyIEBAIGlmbmRlZiBDT05GSUdfQVNf SVNfTExWTQogS0JVSUxEX0FGTEFHUwkrPSAtV2EsLWdkd2FyZi0yCiBlbmRpZgogCitpZmRlZiBD T05GSUdfREVCVUdfSU5GT19SRURVQ0VECitERUJVR19SVVNURkxBR1MgKz0gLUNkZWJ1Z2luZm89 MQorZWxzZQorREVCVUdfUlVTVEZMQUdTICs9IC1DZGVidWdpbmZvPTIKK2VuZGlmCisKIGlmbmRl ZiBDT05GSUdfREVCVUdfSU5GT19EV0FSRl9UT09MQ0hBSU5fREVGQVVMVAogZHdhcmYtdmVyc2lv bi0kKENPTkZJR19ERUJVR19JTkZPX0RXQVJGNCkgOj0gNAogZHdhcmYtdmVyc2lvbi0kKENPTkZJ R19ERUJVR19JTkZPX0RXQVJGNSkgOj0gNQpAQCAtMzEsMyArMzgsNiBAQCBlbmRpZgogCiBLQlVJ TERfQ0ZMQUdTICs9ICQoREVCVUdfQ0ZMQUdTKQogZXhwb3J0IERFQlVHX0NGTEFHUworCitLQlVJ TERfUlVTVEZMQUdTICs9ICQoREVCVUdfUlVTVEZMQUdTKQorZXhwb3J0IERFQlVHX1JVU1RGTEFH UwpkaWZmIC0tZ2l0IGEvc2NyaXB0cy9NYWtlZmlsZS5ob3N0IGIvc2NyaXB0cy9NYWtlZmlsZS5o b3N0CmluZGV4IDI3OGI0ZDZhYzk0NS4uZGExMzM3ODBiNzUxIDEwMDY0NAotLS0gYS9zY3JpcHRz L01ha2VmaWxlLmhvc3QKKysrIGIvc2NyaXB0cy9NYWtlZmlsZS5ob3N0CkBAIC0yMiw2ICsyMiw4 IEBAICQob2JqKS8lLnRhYi5jICQob2JqKS8lLnRhYi5oOiAkKHNyYykvJS55IEZPUkNFCiAjIHRv IHByZXByb2Nlc3MgYSBkYXRhIGZpbGUuCiAjCiAjIEJvdGggQyBhbmQgQysrIGFyZSBzdXBwb3J0 ZWQsIGJ1dCBwcmVmZXJyZWQgbGFuZ3VhZ2UgaXMgQyBmb3Igc3VjaCB1dGlsaXRpZXMuCisjIFJ1 c3QgaXMgYWxzbyBzdXBwb3J0ZWQsIGJ1dCBpdCBtYXkgb25seSBiZSB1c2VkIGluIHNjZW5hcmlv cyB3aGVyZSBhIFJ1c3QKKyMgdG9vbGNoYWluIGlzIHJlcXVpcmVkIHRvIGJlIGF2YWlsYWJsZSAo ZS5nLiB3aGVuICBgQ09ORklHX1JVU1RgIGlzIGVuYWJsZWQpLgogIwogIyBTYW1wbGUgc3ludGF4 IChzZWUgRG9jdW1lbnRhdGlvbi9rYnVpbGQvbWFrZWZpbGVzLnJzdCBmb3IgcmVmZXJlbmNlKQog IyBob3N0cHJvZ3MgOj0gYmluMmhleApAQCAtMzcsMTUgKzM5LDIwIEBAICQob2JqKS8lLnRhYi5j ICQob2JqKS8lLnRhYi5oOiAkKHNyYykvJS55IEZPUkNFCiAjIHFjb25mLW9ianMgICAgICA6PSBt ZW51Lm8KICMgV2lsbCBjb21waWxlIHFjb25mIGFzIGEgQysrIHByb2dyYW0sIGFuZCBtZW51IGFz IGEgQyBwcm9ncmFtLgogIyBUaGV5IGFyZSBsaW5rZWQgYXMgQysrIGNvZGUgdG8gdGhlIGV4ZWN1 dGFibGUgcWNvbmYKKyMKKyMgaG9zdHByb2dzICAgOj0gdGFyZ2V0CisjIHRhcmdldC1ydXN0IDo9 IHkKKyMgV2lsbCBjb21waWxlIGB0YXJnZXRgIGFzIGEgUnVzdCBwcm9ncmFtLCB1c2luZyBgdGFy Z2V0LnJzYCBhcyB0aGUgY3JhdGUgcm9vdC4KKyMgVGhlIGNyYXRlIG1heSBjb25zaXN0IG9mIHNl dmVyYWwgc291cmNlIGZpbGVzLgogCiAjIEMgY29kZQogIyBFeGVjdXRhYmxlcyBjb21waWxlZCBm cm9tIGEgc2luZ2xlIC5jIGZpbGUKIGhvc3QtY3NpbmdsZQk6PSAkKGZvcmVhY2ggbSwkKGhvc3Rw cm9ncyksIFwKLQkJCSQoaWYgJCgkKG0pLW9ianMpJCgkKG0pLWN4eG9ianMpLCwkKG0pKSkKKwkJ CSQoaWYgJCgkKG0pLW9ianMpJCgkKG0pLWN4eG9ianMpJCgkKG0pLXJ1c3QpLCwkKG0pKSkKIAog IyBDIGV4ZWN1dGFibGVzIGxpbmtlZCBiYXNlZCBvbiBzZXZlcmFsIC5vIGZpbGVzCiBob3N0LWNt dWx0aQk6PSAkKGZvcmVhY2ggbSwkKGhvc3Rwcm9ncyksXAotCQkgICAkKGlmICQoJChtKS1jeHhv YmpzKSwsJChpZiAkKCQobSktb2JqcyksJChtKSkpKQorCQkgICAkKGlmICQoJChtKS1jeHhvYmpz KSQoJChtKS1ydXN0KSwsJChpZiAkKCQobSktb2JqcyksJChtKSkpKQogCiAjIE9iamVjdCAoLm8p IGZpbGVzIGNvbXBpbGVkIGZyb20gLmMgZmlsZXMKIGhvc3QtY29ianMJOj0gJChzb3J0ICQoZm9y ZWFjaCBtLCQoaG9zdHByb2dzKSwkKCQobSktb2JqcykpKQpAQCAtNTgsMTEgKzY1LDE3IEBAIGhv c3QtY3h4bXVsdGkJOj0gJChmb3JlYWNoIG0sJChob3N0cHJvZ3MpLCQoaWYgJCgkKG0pLWN4eG9i anMpLCQobSkpKQogIyBDKysgT2JqZWN0ICgubykgZmlsZXMgY29tcGlsZWQgZnJvbSAuY2MgZmls ZXMKIGhvc3QtY3h4b2Jqcwk6PSAkKHNvcnQgJChmb3JlYWNoIG0sJChob3N0LWN4eG11bHRpKSwk KCQobSktY3h4b2JqcykpKQogCisjIFJ1c3QgY29kZQorIyBFeGVjdXRhYmxlcyBjb21waWxlZCBm cm9tIGEgc2luZ2xlIFJ1c3QgY3JhdGUgKHdoaWNoIG1heSBjb25zaXN0IG9mCisjIG9uZSBvciBt b3JlIC5ycyBmaWxlcykKK2hvc3QtcnVzdAk6PSAkKGZvcmVhY2ggbSwkKGhvc3Rwcm9ncyksJChp ZiAkKCQobSktcnVzdCksJChtKSkpCisKIGhvc3QtY3NpbmdsZQk6PSAkKGFkZHByZWZpeCAkKG9i aikvLCQoaG9zdC1jc2luZ2xlKSkKIGhvc3QtY211bHRpCTo9ICQoYWRkcHJlZml4ICQob2JqKS8s JChob3N0LWNtdWx0aSkpCiBob3N0LWNvYmpzCTo9ICQoYWRkcHJlZml4ICQob2JqKS8sJChob3N0 LWNvYmpzKSkKIGhvc3QtY3h4bXVsdGkJOj0gJChhZGRwcmVmaXggJChvYmopLywkKGhvc3QtY3h4 bXVsdGkpKQogaG9zdC1jeHhvYmpzCTo9ICQoYWRkcHJlZml4ICQob2JqKS8sJChob3N0LWN4eG9i anMpKQoraG9zdC1ydXN0CTo9ICQoYWRkcHJlZml4ICQob2JqKS8sJChob3N0LXJ1c3QpKQogCiAj IyMjIwogIyBIYW5kbGUgb3B0aW9ucyB0byBnY2MuIFN1cHBvcnQgYnVpbGRpbmcgd2l0aCBzZXBh cmF0ZSBvdXRwdXQgZGlyZWN0b3J5CkBAIC03MSw2ICs4NCw4IEBAIF9ob3N0Y19mbGFncyAgID0g JChLQlVJTERfSE9TVENGTEFHUykgICAkKEhPU1RfRVhUUkFDRkxBR1MpICAgXAogICAgICAgICAg ICAgICAgICAkKEhPU1RDRkxBR1NfJCh0YXJnZXQtc3RlbSkubykKIF9ob3N0Y3h4X2ZsYWdzID0g JChLQlVJTERfSE9TVENYWEZMQUdTKSAkKEhPU1RfRVhUUkFDWFhGTEFHUykgXAogICAgICAgICAg ICAgICAgICAkKEhPU1RDWFhGTEFHU18kKHRhcmdldC1zdGVtKS5vKQorX2hvc3RydXN0X2ZsYWdz ID0gJChLQlVJTERfSE9TVFJVU1RGTEFHUykgJChIT1NUX0VYVFJBUlVTVEZMQUdTKSBcCisgICAg ICAgICAgICAgICAgICAkKEhPU1RSVVNURkxBR1NfJCh0YXJnZXQtc3RlbSkpCiAKICMgJChvYmp0 cmVlKS8kKG9iaikgZm9yIGluY2x1ZGluZyBnZW5lcmF0ZWQgaGVhZGVycyBmcm9tIGNoZWNraW4g c291cmNlIGZpbGVzCiBpZmVxICgkKEtCVUlMRF9FWFRNT0QpLCkKQEAgLTgyLDYgKzk3LDcgQEAg ZW5kaWYKIAogaG9zdGNfZmxhZ3MgICAgPSAtV3AsLU1NRCwkKGRlcGZpbGUpICQoX2hvc3RjX2Zs YWdzKQogaG9zdGN4eF9mbGFncyAgPSAtV3AsLU1NRCwkKGRlcGZpbGUpICQoX2hvc3RjeHhfZmxh Z3MpCitob3N0cnVzdF9mbGFncyA9ICQoX2hvc3RydXN0X2ZsYWdzKQogCiAjIyMjIwogIyBDb21w aWxlIHByb2dyYW1zIG9uIHRoZSBob3N0CkBAIC0xMjgsNSArMTQ0LDE3IEBAIHF1aWV0X2NtZF9o b3N0LWN4eG9ianMJPSBIT1NUQ1hYICRACiAkKGhvc3QtY3h4b2Jqcyk6ICQob2JqKS8lLm86ICQo c3JjKS8lLmNjIEZPUkNFCiAJJChjYWxsIGlmX2NoYW5nZWRfZGVwLGhvc3QtY3h4b2JqcykKIAor IyBDcmVhdGUgZXhlY3V0YWJsZSBmcm9tIGEgc2luZ2xlIFJ1c3QgY3JhdGUgKHdoaWNoIG1heSBj b25zaXN0IG9mCisjIG9uZSBvciBtb3JlIGAucnNgIGZpbGVzKQorIyBob3N0LXJ1c3QgLT4gRXhl Y3V0YWJsZQorcXVpZXRfY21kX2hvc3QtcnVzdAk9IEhPU1RSVVNUQyAkQAorICAgICAgY21kX2hv c3QtcnVzdAk9IFwKKwkkKEhPU1RSVVNUQykgJChob3N0cnVzdF9mbGFncykgLS1lbWl0PWRlcC1p bmZvLGxpbmsgXAorCQktLW91dC1kaXI9JChvYmopLyAkPDsgXAorCW12ICQob2JqKS8kKHRhcmdl dC1zdGVtKS5kICQoZGVwZmlsZSk7IFwKKwlzZWQgLWkgJy9eXCMvZCcgJChkZXBmaWxlKQorJCho b3N0LXJ1c3QpOiAkKG9iaikvJTogJChzcmMpLyUucnMgRk9SQ0UKKwkkKGNhbGwgaWZfY2hhbmdl ZF9kZXAsaG9zdC1ydXN0KQorCiB0YXJnZXRzICs9ICQoaG9zdC1jc2luZ2xlKSAkKGhvc3QtY211 bHRpKSAkKGhvc3QtY29ianMpIFwKLQkgICAkKGhvc3QtY3h4bXVsdGkpICQoaG9zdC1jeHhvYmpz KQorCSAgICQoaG9zdC1jeHhtdWx0aSkgJChob3N0LWN4eG9ianMpICQoaG9zdC1ydXN0KQpkaWZm IC0tZ2l0IGEvc2NyaXB0cy9NYWtlZmlsZS5saWIgYi9zY3JpcHRzL01ha2VmaWxlLmxpYgppbmRl eCAzZmI2YTk5ZTc4YzQuLmM4OGI5OGI1ZGM0NCAxMDA2NDQKLS0tIGEvc2NyaXB0cy9NYWtlZmls ZS5saWIKKysrIGIvc2NyaXB0cy9NYWtlZmlsZS5saWIKQEAgLTgsNiArOCw3IEBAIGxkZmxhZ3Mt eSAgKz0gJChFWFRSQV9MREZMQUdTKQogIyBmbGFncyB0aGF0IHRha2UgZWZmZWN0IGluIGN1cnJl bnQgYW5kIHN1YiBkaXJlY3RvcmllcwogS0JVSUxEX0FGTEFHUyArPSAkKHN1YmRpci1hc2ZsYWdz LXkpCiBLQlVJTERfQ0ZMQUdTICs9ICQoc3ViZGlyLWNjZmxhZ3MteSkKK0tCVUlMRF9SVVNURkxB R1MgKz0gJChzdWJkaXItcnVzdGZsYWdzLXkpCiAKICMgRmlndXJlIG91dCB3aGF0IHdlIG5lZWQg dG8gYnVpbGQgZnJvbSB0aGUgdmFyaW91cyB2YXJpYWJsZXMKICMgPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 CkBAIC0xMjgsNiArMTI5LDEwIEBAIF9jX2ZsYWdzICAgICAgID0gJChmaWx0ZXItb3V0ICQoQ0ZM QUdTX1JFTU9WRV8kKHRhcmdldC1zdGVtKS5vKSwgXAogICAgICAgICAgICAgICAgICAgICAgJChm aWx0ZXItb3V0ICQoY2NmbGFncy1yZW1vdmUteSksIFwKICAgICAgICAgICAgICAgICAgICAgICAg ICAkKEtCVUlMRF9DUFBGTEFHUykgJChLQlVJTERfQ0ZMQUdTKSAkKGNjZmxhZ3MteSkpIFwKICAg ICAgICAgICAgICAgICAgICAgICQoQ0ZMQUdTXyQodGFyZ2V0LXN0ZW0pLm8pKQorX3J1c3RfZmxh Z3MgICAgPSAkKGZpbHRlci1vdXQgJChSVVNURkxBR1NfUkVNT1ZFXyQodGFyZ2V0LXN0ZW0pLm8p LCBcCisgICAgICAgICAgICAgICAgICAgICAkKGZpbHRlci1vdXQgJChydXN0ZmxhZ3MtcmVtb3Zl LXkpLCBcCisgICAgICAgICAgICAgICAgICAgICAgICAgJChLQlVJTERfUlVTVEZMQUdTKSAkKHJ1 c3RmbGFncy15KSkgXAorICAgICAgICAgICAgICAgICAgICAgJChSVVNURkxBR1NfJCh0YXJnZXQt c3RlbSkubykpCiBfYV9mbGFncyAgICAgICA9ICQoZmlsdGVyLW91dCAkKEFGTEFHU19SRU1PVkVf JCh0YXJnZXQtc3RlbSkubyksIFwKICAgICAgICAgICAgICAgICAgICAgICQoZmlsdGVyLW91dCAk KGFzZmxhZ3MtcmVtb3ZlLXkpLCBcCiAgICAgICAgICAgICAgICAgICAgICAgICAgJChLQlVJTERf Q1BQRkxBR1MpICQoS0JVSUxEX0FGTEFHUykgJChhc2ZsYWdzLXkpKSBcCkBAIC0yMDIsNiArMjA3 LDExIEBAIG1vZGtlcm5fY2ZsYWdzID0gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBcCiAJCSQoS0JVSUxEX0NGTEFHU19NT0RVTEUpICQoQ0ZMQUdTX01PRFVMRSksIFwK IAkJJChLQlVJTERfQ0ZMQUdTX0tFUk5FTCkgJChDRkxBR1NfS0VSTkVMKSAkKG1vZGZpbGVfZmxh Z3MpKQogCittb2RrZXJuX3J1c3RmbGFncyA9ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgIFwKKwkkKGlmICQocGFydC1vZi1tb2R1bGUpLCAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgXAorCQkkKEtCVUlMRF9SVVNURkxBR1NfTU9EVUxFKSAkKFJV U1RGTEFHU19NT0RVTEUpLCBcCisJCSQoS0JVSUxEX1JVU1RGTEFHU19LRVJORUwpICQoUlVTVEZM QUdTX0tFUk5FTCkpCisKIG1vZGtlcm5fYWZsYWdzID0gJChpZiAkKHBhcnQtb2YtbW9kdWxlKSwJ CQkJXAogCQkJJChLQlVJTERfQUZMQUdTX01PRFVMRSkgJChBRkxBR1NfTU9EVUxFKSwJXAogCQkJ JChLQlVJTERfQUZMQUdTX0tFUk5FTCkgJChBRkxBR1NfS0VSTkVMKSkKQEAgLTIxMSw2ICsyMjEs OCBAQCBjX2ZsYWdzICAgICAgICA9IC1XcCwtTU1ELCQoZGVwZmlsZSkgJChOT1NURElOQ19GTEFH UykgJChMSU5VWElOQ0xVREUpICAgICBcCiAJCSAkKF9jX2ZsYWdzKSAkKG1vZGtlcm5fY2ZsYWdz KSAgICAgICAgICAgICAgICAgICAgICAgICAgIFwKIAkJICQoYmFzZW5hbWVfZmxhZ3MpICQobW9k bmFtZV9mbGFncykKIAorcnVzdF9mbGFncyAgICAgPSAkKF9ydXN0X2ZsYWdzKSAkKG1vZGtlcm5f cnVzdGZsYWdzKSBAJChvYmp0cmVlKS9pbmNsdWRlL2dlbmVyYXRlZC9ydXN0Y19jZmcKKwogYV9m bGFncyAgICAgICAgPSAtV3AsLU1NRCwkKGRlcGZpbGUpICQoTk9TVERJTkNfRkxBR1MpICQoTElO VVhJTkNMVURFKSAgICAgXAogCQkgJChfYV9mbGFncykgJChtb2RrZXJuX2FmbGFncykKIApkaWZm IC0tZ2l0IGEvc2NyaXB0cy9NYWtlZmlsZS5tb2RmaW5hbCBiL3NjcmlwdHMvTWFrZWZpbGUubW9k ZmluYWwKaW5kZXggMzUxMDBlOTgxZjRhLi45YTFmYTZhYTMwZmUgMTAwNjQ0Ci0tLSBhL3Njcmlw dHMvTWFrZWZpbGUubW9kZmluYWwKKysrIGIvc2NyaXB0cy9NYWtlZmlsZS5tb2RmaW5hbApAQCAt MzksMTEgKzM5LDEzIEBAIHF1aWV0X2NtZF9sZF9rb19vID0gTEQgW01dICAkQAogCiBxdWlldF9j bWRfYnRmX2tvID0gQlRGIFtNXSAkQAogICAgICAgY21kX2J0Zl9rbyA9IAkJCQkJCQlcCi0JaWYg WyAtZiB2bWxpbnV4IF07IHRoZW4JCQkJCQlcCisJaWYgWyAhIC1mIHZtbGludXggXTsgdGhlbgkJ CQkJXAorCQlwcmludGYgIlNraXBwaW5nIEJURiBnZW5lcmF0aW9uIGZvciAlcyBkdWUgdG8gdW5h dmFpbGFiaWxpdHkgb2Ygdm1saW51eFxuIiAkQCAxPiYyOyBcCisJZWxpZiBbIC1uICIkKENPTkZJ R19SVVNUKSIgXSAmJiAkKHNyY3RyZWUpL3NjcmlwdHMvaXNfcnVzdF9tb2R1bGUuc2ggJEA7IHRo ZW4gCQlcCisJCXByaW50ZiAiU2tpcHBpbmcgQlRGIGdlbmVyYXRpb24gZm9yICVzIGJlY2F1c2Ug aXQncyBhIFJ1c3QgbW9kdWxlXG4iICRAIDE+JjI7IFwKKwllbHNlCQkJCQkJCQlcCiAJCUxMVk1f T0JKQ09QWT0iJChPQkpDT1BZKSIgJChQQUhPTEUpIC1KICQoUEFIT0xFX0ZMQUdTKSAtLWJ0Zl9i YXNlIHZtbGludXggJEA7IFwKIAkJJChSRVNPTFZFX0JURklEUykgLWIgdm1saW51eCAkQDsgCQkJ XAotCWVsc2UJCQkJCQkJCVwKLQkJcHJpbnRmICJTa2lwcGluZyBCVEYgZ2VuZXJhdGlvbiBmb3Ig JXMgZHVlIHRvIHVuYXZhaWxhYmlsaXR5IG9mIHZtbGludXhcbiIgJEAgMT4mMjsgXAogCWZpOwog CiAjIFNhbWUgYXMgbmV3ZXItcHJlcmVxcywgYnV0IGFsbG93cyB0byBleGNsdWRlIHNwZWNpZmll ZCBleHRyYSBkZXBlbmRlbmNpZXMKZGlmZiAtLWdpdCBhL3NjcmlwdHMvY2MtdmVyc2lvbi5zaCBi L3NjcmlwdHMvY2MtdmVyc2lvbi5zaAppbmRleCBmMTk1MmM1MjI0NjYuLjI0MDFjODZmY2Y1MyAx MDA3NTUKLS0tIGEvc2NyaXB0cy9jYy12ZXJzaW9uLnNoCisrKyBiL3NjcmlwdHMvY2MtdmVyc2lv bi5zaApAQCAtMSwxMyArMSwxMyBAQAogIyEvYmluL3NoCiAjIFNQRFgtTGljZW5zZS1JZGVudGlm aWVyOiBHUEwtMi4wCiAjCi0jIFByaW50IHRoZSBjb21waWxlciBuYW1lIGFuZCBpdHMgdmVyc2lv biBpbiBhIDUgb3IgNi1kaWdpdCBmb3JtLgorIyBQcmludCB0aGUgQyBjb21waWxlciBuYW1lIGFu ZCBpdHMgdmVyc2lvbiBpbiBhIDUgb3IgNi1kaWdpdCBmb3JtLgogIyBBbHNvLCBwZXJmb3JtIHRo ZSBtaW5pbXVtIHZlcnNpb24gY2hlY2suCiAKIHNldCAtZQogCi0jIFByaW50IHRoZSBjb21waWxl ciBuYW1lIGFuZCBzb21lIHZlcnNpb24gY29tcG9uZW50cy4KLWdldF9jb21waWxlcl9pbmZvKCkK KyMgUHJpbnQgdGhlIEMgY29tcGlsZXIgbmFtZSBhbmQgc29tZSB2ZXJzaW9uIGNvbXBvbmVudHMu CitnZXRfY19jb21waWxlcl9pbmZvKCkKIHsKIAljYXQgPDwtIEVPRiB8ICIkQCIgLUUgLVAgLXgg YyAtIDI+L2Rldi9udWxsCiAJI2lmIGRlZmluZWQoX19jbGFuZ19fKQpAQCAtMzIsNyArMzIsNyBA QCBnZXRfY2Fub25pY2FsX3ZlcnNpb24oKQogCiAjICRAIGluc3RlYWQgb2YgJDEgYmVjYXVzZSBt dWx0aXBsZSB3b3JkcyBtaWdodCBiZSBnaXZlbiwgZS5nLiBDQz0iY2NhY2hlIGdjYyIuCiBvcmln X2FyZ3M9IiRAIgotc2V0IC0tICQoZ2V0X2NvbXBpbGVyX2luZm8gIiRAIikKK3NldCAtLSAkKGdl dF9jX2NvbXBpbGVyX2luZm8gIiRAIikKIAogbmFtZT0kMQogCkBAIC01Miw3ICs1Miw3IEBAIElD QykKIAltaW5fdmVyc2lvbj0kKCRtaW5fdG9vbF92ZXJzaW9uIGljYykKIAk7OwogKikKLQllY2hv ICIkb3JpZ19hcmdzOiB1bmtub3duIGNvbXBpbGVyIiA+JjIKKwllY2hvICIkb3JpZ19hcmdzOiB1 bmtub3duIEMgY29tcGlsZXIiID4mMgogCWV4aXQgMQogCTs7CiBlc2FjCkBAIC02Miw3ICs2Miw3 IEBAIG1pbl9jdmVyc2lvbj0kKGdldF9jYW5vbmljYWxfdmVyc2lvbiAkbWluX3ZlcnNpb24pCiAK IGlmIFsgIiRjdmVyc2lvbiIgLWx0ICIkbWluX2N2ZXJzaW9uIiBdOyB0aGVuCiAJZWNobyA+JjIg IioqKiIKLQllY2hvID4mMiAiKioqIENvbXBpbGVyIGlzIHRvbyBvbGQuIgorCWVjaG8gPiYyICIq KiogQyBjb21waWxlciBpcyB0b28gb2xkLiIKIAllY2hvID4mMiAiKioqICAgWW91ciAkbmFtZSB2 ZXJzaW9uOiAgICAkdmVyc2lvbiIKIAllY2hvID4mMiAiKioqICAgTWluaW11bSAkbmFtZSB2ZXJz aW9uOiAkbWluX3ZlcnNpb24iCiAJZWNobyA+JjIgIioqKiIKZGlmZiAtLWdpdCBhL3NjcmlwdHMv Z2VuZXJhdGVfcnVzdF90YXJnZXQucnMgYi9zY3JpcHRzL2dlbmVyYXRlX3J1c3RfdGFyZ2V0LnJz Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMGExYmE5NWQ3NGU3Ci0t LSAvZGV2L251bGwKKysrIGIvc2NyaXB0cy9nZW5lcmF0ZV9ydXN0X3RhcmdldC5ycwpAQCAtMCww ICsxLDIzMiBAQAorLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEdQTC0yLjAKKworLy8hIFRo ZSBjdXN0b20gdGFyZ2V0IHNwZWNpZmljYXRpb24gZmlsZSBnZW5lcmF0b3IgZm9yIGBydXN0Y2Au CisvLyEKKy8vISBUbyBjb25maWd1cmUgYSB0YXJnZXQgZnJvbSBzY3JhdGNoLCBhIEpTT04tZW5j b2RlZCBmaWxlIGhhcyB0byBiZSBwYXNzZWQKKy8vISB0byBgcnVzdGNgIChpbnRyb2R1Y2VkIGlu IFtSRkMgMTMxXSkuIFRoZXNlIG9wdGlvbnMgYW5kIHRoZSBmaWxlIGl0c2VsZiBhcmUKKy8vISB1 bnN0YWJsZS4gRXZlbnR1YWxseSwgYHJ1c3RjYCBzaG91bGQgcHJvdmlkZSBhIHdheSB0byBkbyB0 aGlzIGluIGEgc3RhYmxlCisvLyEgbWFubmVyLiBGb3IgaW5zdGFuY2UsIHZpYSBjb21tYW5kLWxp bmUgYXJndW1lbnRzLiBUaGVyZWZvcmUsIHRoaXMgZmlsZQorLy8hIHNob3VsZCBhdm9pZCB1c2lu ZyBrZXlzIHdoaWNoIGNhbiBiZSBzZXQgdmlhIGAtQ2Agb3IgYC1aYCBvcHRpb25zLgorLy8hCisv LyEgW1JGQyAxMzFdOiBodHRwczovL3J1c3QtbGFuZy5naXRodWIuaW8vcmZjcy8wMTMxLXRhcmdl dC1zcGVjaWZpY2F0aW9uLmh0bWwKKwordXNlIHN0ZDo6eworICAgIGNvbGxlY3Rpb25zOjpIYXNo TWFwLAorICAgIGZtdDo6e0Rpc3BsYXksIEZvcm1hdHRlciwgUmVzdWx0fSwKKyAgICBpbzo6QnVm UmVhZCwKK307CisKK2VudW0gVmFsdWUgeworICAgIEJvb2xlYW4oYm9vbCksCisgICAgTnVtYmVy KGkzMiksCisgICAgU3RyaW5nKFN0cmluZyksCisgICAgT2JqZWN0KE9iamVjdCksCit9CisKK3R5 cGUgT2JqZWN0ID0gVmVjPChTdHJpbmcsIFZhbHVlKT47CisKKy8vLyBNaW5pbWFsICJhbG1vc3Qg SlNPTiIgZ2VuZXJhdG9yIChlLmcuIG5vIGBudWxsYHMsIG5vIGFycmF5cywgbm8gZXNjYXBpbmcp LAorLy8vIGVub3VnaCBmb3IgdGhpcyBwdXJwb3NlLgoraW1wbCBEaXNwbGF5IGZvciBWYWx1ZSB7 CisgICAgZm4gZm10KCZzZWxmLCBmb3JtYXR0ZXI6ICZtdXQgRm9ybWF0dGVyPCdfPikgLT4gUmVz dWx0IHsKKyAgICAgICAgbWF0Y2ggc2VsZiB7CisgICAgICAgICAgICBWYWx1ZTo6Qm9vbGVhbihi b29sZWFuKSA9PiB3cml0ZSEoZm9ybWF0dGVyLCAie30iLCBib29sZWFuKSwKKyAgICAgICAgICAg IFZhbHVlOjpOdW1iZXIobnVtYmVyKSA9PiB3cml0ZSEoZm9ybWF0dGVyLCAie30iLCBudW1iZXIp LAorICAgICAgICAgICAgVmFsdWU6OlN0cmluZyhzdHJpbmcpID0+IHdyaXRlIShmb3JtYXR0ZXIs ICJcInt9XCIiLCBzdHJpbmcpLAorICAgICAgICAgICAgVmFsdWU6Ok9iamVjdChvYmplY3QpID0+ IHsKKyAgICAgICAgICAgICAgICBmb3JtYXR0ZXIud3JpdGVfc3RyKCJ7Iik/OworICAgICAgICAg ICAgICAgIGlmIGxldCBbcmVmIHJlc3QgQCAuLiwgcmVmIGxhc3RdID0gb2JqZWN0Wy4uXSB7Cisg ICAgICAgICAgICAgICAgICAgIGZvciAoa2V5LCB2YWx1ZSkgaW4gcmVzdCB7CisgICAgICAgICAg ICAgICAgICAgICAgICB3cml0ZSEoZm9ybWF0dGVyLCAiXCJ7fVwiOiB7fSwiLCBrZXksIHZhbHVl KT87CisgICAgICAgICAgICAgICAgICAgIH0KKyAgICAgICAgICAgICAgICAgICAgd3JpdGUhKGZv cm1hdHRlciwgIlwie31cIjoge30iLCBsYXN0LjAsIGxhc3QuMSk/OworICAgICAgICAgICAgICAg IH0KKyAgICAgICAgICAgICAgICBmb3JtYXR0ZXIud3JpdGVfc3RyKCJ9IikKKyAgICAgICAgICAg IH0KKyAgICAgICAgfQorICAgIH0KK30KKworc3RydWN0IFRhcmdldFNwZWMoT2JqZWN0KTsKKwor aW1wbCBUYXJnZXRTcGVjIHsKKyAgICBmbiBuZXcoKSAtPiBUYXJnZXRTcGVjIHsKKyAgICAgICAg VGFyZ2V0U3BlYyhWZWM6Om5ldygpKQorICAgIH0KK30KKwordHJhaXQgUHVzaDxUPiB7CisgICAg Zm4gcHVzaCgmbXV0IHNlbGYsIGtleTogJnN0ciwgdmFsdWU6IFQpOworfQorCitpbXBsIFB1c2g8 Ym9vbD4gZm9yIFRhcmdldFNwZWMgeworICAgIGZuIHB1c2goJm11dCBzZWxmLCBrZXk6ICZzdHIs IHZhbHVlOiBib29sKSB7CisgICAgICAgIHNlbGYuMC5wdXNoKChrZXkudG9fc3RyaW5nKCksIFZh bHVlOjpCb29sZWFuKHZhbHVlKSkpOworICAgIH0KK30KKworaW1wbCBQdXNoPGkzMj4gZm9yIFRh cmdldFNwZWMgeworICAgIGZuIHB1c2goJm11dCBzZWxmLCBrZXk6ICZzdHIsIHZhbHVlOiBpMzIp IHsKKyAgICAgICAgc2VsZi4wLnB1c2goKGtleS50b19zdHJpbmcoKSwgVmFsdWU6Ok51bWJlcih2 YWx1ZSkpKTsKKyAgICB9Cit9CisKK2ltcGwgUHVzaDxTdHJpbmc+IGZvciBUYXJnZXRTcGVjIHsK KyAgICBmbiBwdXNoKCZtdXQgc2VsZiwga2V5OiAmc3RyLCB2YWx1ZTogU3RyaW5nKSB7CisgICAg ICAgIHNlbGYuMC5wdXNoKChrZXkudG9fc3RyaW5nKCksIFZhbHVlOjpTdHJpbmcodmFsdWUpKSk7 CisgICAgfQorfQorCitpbXBsIFB1c2g8JnN0cj4gZm9yIFRhcmdldFNwZWMgeworICAgIGZuIHB1 c2goJm11dCBzZWxmLCBrZXk6ICZzdHIsIHZhbHVlOiAmc3RyKSB7CisgICAgICAgIHNlbGYucHVz aChrZXksIHZhbHVlLnRvX3N0cmluZygpKTsKKyAgICB9Cit9CisKK2ltcGwgUHVzaDxPYmplY3Q+ IGZvciBUYXJnZXRTcGVjIHsKKyAgICBmbiBwdXNoKCZtdXQgc2VsZiwga2V5OiAmc3RyLCB2YWx1 ZTogT2JqZWN0KSB7CisgICAgICAgIHNlbGYuMC5wdXNoKChrZXkudG9fc3RyaW5nKCksIFZhbHVl OjpPYmplY3QodmFsdWUpKSk7CisgICAgfQorfQorCitpbXBsIERpc3BsYXkgZm9yIFRhcmdldFNw ZWMgeworICAgIGZuIGZtdCgmc2VsZiwgZm9ybWF0dGVyOiAmbXV0IEZvcm1hdHRlcjwnXz4pIC0+ IFJlc3VsdCB7CisgICAgICAgIC8vIFdlIGFkZCBzb21lIG5ld2xpbmVzIGZvciBjbGFyaXR5Lgor ICAgICAgICBmb3JtYXR0ZXIud3JpdGVfc3RyKCJ7XG4iKT87CisgICAgICAgIGlmIGxldCBbcmVm IHJlc3QgQCAuLiwgcmVmIGxhc3RdID0gc2VsZi4wWy4uXSB7CisgICAgICAgICAgICBmb3IgKGtl eSwgdmFsdWUpIGluIHJlc3QgeworICAgICAgICAgICAgICAgIHdyaXRlIShmb3JtYXR0ZXIsICIg ICAgXCJ7fVwiOiB7fSxcbiIsIGtleSwgdmFsdWUpPzsKKyAgICAgICAgICAgIH0KKyAgICAgICAg ICAgIHdyaXRlIShmb3JtYXR0ZXIsICIgICAgXCJ7fVwiOiB7fVxuIiwgbGFzdC4wLCBsYXN0LjEp PzsKKyAgICAgICAgfQorICAgICAgICBmb3JtYXR0ZXIud3JpdGVfc3RyKCJ9IikKKyAgICB9Cit9 CisKK3N0cnVjdCBLZXJuZWxDb25maWcoSGFzaE1hcDxTdHJpbmcsIFN0cmluZz4pOworCitpbXBs IEtlcm5lbENvbmZpZyB7CisgICAgLy8vIFBhcnNlcyBgaW5jbHVkZS9jb25maWcvYXV0by5jb25m YCBmcm9tIGBzdGRpbmAuCisgICAgZm4gZnJvbV9zdGRpbigpIC0+IEtlcm5lbENvbmZpZyB7Cisg ICAgICAgIGxldCBtdXQgcmVzdWx0ID0gSGFzaE1hcDo6bmV3KCk7CisKKyAgICAgICAgbGV0IHN0 ZGluID0gc3RkOjppbzo6c3RkaW4oKTsKKyAgICAgICAgbGV0IG11dCBoYW5kbGUgPSBzdGRpbi5s b2NrKCk7CisgICAgICAgIGxldCBtdXQgbGluZSA9IFN0cmluZzo6bmV3KCk7CisKKyAgICAgICAg bG9vcCB7CisgICAgICAgICAgICBsaW5lLmNsZWFyKCk7CisKKyAgICAgICAgICAgIGlmIGhhbmRs ZS5yZWFkX2xpbmUoJm11dCBsaW5lKS51bndyYXAoKSA9PSAwIHsKKyAgICAgICAgICAgICAgICBi cmVhazsKKyAgICAgICAgICAgIH0KKworICAgICAgICAgICAgaWYgbGluZS5zdGFydHNfd2l0aCgn IycpIHsKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKyAgICAgICAgICAgIH0KKworICAgICAg ICAgICAgbGV0IChrZXksIHZhbHVlKSA9IGxpbmUuc3BsaXRfb25jZSgnPScpLmV4cGVjdCgiTWlz c2luZyBgPWAgaW4gbGluZS4iKTsKKyAgICAgICAgICAgIHJlc3VsdC5pbnNlcnQoa2V5LnRvX3N0 cmluZygpLCB2YWx1ZS50cmltX2VuZF9tYXRjaGVzKCdcbicpLnRvX3N0cmluZygpKTsKKyAgICAg ICAgfQorCisgICAgICAgIEtlcm5lbENvbmZpZyhyZXN1bHQpCisgICAgfQorCisgICAgLy8vIERv ZXMgdGhlIG9wdGlvbiBleGlzdCBpbiB0aGUgY29uZmlndXJhdGlvbiAoYW55IHZhbHVlKT8KKyAg ICAvLy8KKyAgICAvLy8gVGhlIGFyZ3VtZW50IG11c3QgYmUgcGFzc2VkIHdpdGhvdXQgdGhlIGBD T05GSUdfYCBwcmVmaXguCisgICAgLy8vIFRoaXMgYXZvaWRzIHJlcGV0aXRpb24gYW5kIGl0IGFs c28gYXZvaWRzIGBmaXhkZXBgIG1ha2luZyB1cworICAgIC8vLyBkZXBlbmQgb24gaXQuCisgICAg Zm4gaGFzKCZzZWxmLCBvcHRpb246ICZzdHIpIC0+IGJvb2wgeworICAgICAgICBsZXQgb3B0aW9u ID0gIkNPTkZJR18iLnRvX293bmVkKCkgKyBvcHRpb247CisgICAgICAgIHNlbGYuMC5jb250YWlu c19rZXkoJm9wdGlvbikKKyAgICB9Cit9CisKK2ZuIG1haW4oKSB7CisgICAgbGV0IGNmZyA9IEtl cm5lbENvbmZpZzo6ZnJvbV9zdGRpbigpOworICAgIGxldCBtdXQgdHMgPSBUYXJnZXRTcGVjOjpu ZXcoKTsKKworICAgIC8vIGBsbHZtLXRhcmdldGBzIGFyZSB0YWtlbiBmcm9tIGBzY3JpcHRzL01h a2VmaWxlLmNsYW5nYC4KKyAgICBpZiBjZmcuaGFzKCJBUk0iKSB7CisgICAgICAgIHRzLnB1c2go ImFyY2giLCAiYXJtIik7CisgICAgICAgIHRzLnB1c2goCisgICAgICAgICAgICAiZGF0YS1sYXlv dXQiLAorICAgICAgICAgICAgImUtbTplLXA6MzI6MzItRmk4LWk2NDo2NC12MTI4OjY0OjEyOC1h OjA6MzItbjMyLVM2NCIsCisgICAgICAgICk7CisgICAgICAgIHRzLnB1c2goImZlYXR1cmVzIiwg IitzdHJpY3QtYWxpZ24sK3Y2Iik7CisgICAgICAgIHRzLnB1c2goImxsdm0tdGFyZ2V0IiwgImFy bS1saW51eC1nbnVlYWJpIik7CisgICAgICAgIHRzLnB1c2goIm1heC1hdG9taWMtd2lkdGgiLCA2 NCk7CisgICAgICAgIHRzLnB1c2goInRhcmdldC1tY291bnQiLCAiXFx1MDAwMV9fZ251X21jb3Vu dF9uYyIpOworICAgICAgICB0cy5wdXNoKCJ0YXJnZXQtcG9pbnRlci13aWR0aCIsICIzMiIpOwor ICAgIH0gZWxzZSBpZiBjZmcuaGFzKCJBUk02NCIpIHsKKyAgICAgICAgdHMucHVzaCgiYXJjaCIs ICJhYXJjaDY0Iik7CisgICAgICAgIHRzLnB1c2goCisgICAgICAgICAgICAiZGF0YS1sYXlvdXQi LAorICAgICAgICAgICAgImUtbTplLWk4Ojg6MzItaTE2OjE2OjMyLWk2NDo2NC1pMTI4OjEyOC1u MzI6NjQtUzEyOCIsCisgICAgICAgICk7CisgICAgICAgIHRzLnB1c2goImRpc2FibGUtcmVkem9u ZSIsIHRydWUpOworICAgICAgICB0cy5wdXNoKCJmZWF0dXJlcyIsICIrc3RyaWN0LWFsaWduLC1u ZW9uLC1mcC1hcm12OCIpOworICAgICAgICB0cy5wdXNoKCJsbHZtLXRhcmdldCIsICJhYXJjaDY0 LWxpbnV4LWdudSIpOworICAgICAgICB0cy5wdXNoKCJtYXgtYXRvbWljLXdpZHRoIiwgMTI4KTsK KyAgICAgICAgdHMucHVzaCgidGFyZ2V0LXBvaW50ZXItd2lkdGgiLCAiNjQiKTsKKyAgICB9IGVs c2UgaWYgY2ZnLmhhcygiUFBDIikgeworICAgICAgICB0cy5wdXNoKCJhcmNoIiwgInBvd2VycGM2 NCIpOworICAgICAgICB0cy5wdXNoKCJjb2RlLW1vZGVsIiwgImxhcmdlIik7CisgICAgICAgIHRz LnB1c2goImRhdGEtbGF5b3V0IiwgImUtbTplLWk2NDo2NC1uMzI6NjQiKTsKKyAgICAgICAgdHMu cHVzaCgiZmVhdHVyZXMiLCAiLWFsdGl2ZWMsLXZzeCwtaGFyZC1mbG9hdCIpOworICAgICAgICB0 cy5wdXNoKCJsbHZtLXRhcmdldCIsICJwb3dlcnBjNjRsZS1saW51eC1nbnUiKTsKKyAgICAgICAg dHMucHVzaCgibWF4LWF0b21pYy13aWR0aCIsIDY0KTsKKyAgICAgICAgdHMucHVzaCgidGFyZ2V0 LW1jb3VudCIsICJfbWNvdW50Iik7CisgICAgICAgIHRzLnB1c2goInRhcmdldC1wb2ludGVyLXdp ZHRoIiwgIjY0Iik7CisgICAgfSBlbHNlIGlmIGNmZy5oYXMoIlJJU0NWIikgeworICAgICAgICBp ZiBjZmcuaGFzKCI2NEJJVCIpIHsKKyAgICAgICAgICAgIHRzLnB1c2goImFyY2giLCAicmlzY3Y2 NCIpOworICAgICAgICAgICAgdHMucHVzaCgiZGF0YS1sYXlvdXQiLCAiZS1tOmUtcDo2NDo2NC1p NjQ6NjQtaTEyODoxMjgtbjY0LVMxMjgiKTsKKyAgICAgICAgICAgIHRzLnB1c2goImxsdm0tdGFy Z2V0IiwgInJpc2N2NjQtbGludXgtZ251Iik7CisgICAgICAgICAgICB0cy5wdXNoKCJ0YXJnZXQt cG9pbnRlci13aWR0aCIsICI2NCIpOworICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgdHMu cHVzaCgiYXJjaCIsICJyaXNjdjMyIik7CisgICAgICAgICAgICB0cy5wdXNoKCJkYXRhLWxheW91 dCIsICJlLW06ZS1wOjMyOjMyLWk2NDo2NC1uMzItUzEyOCIpOworICAgICAgICAgICAgdHMucHVz aCgibGx2bS10YXJnZXQiLCAicmlzY3YzMi1saW51eC1nbnUiKTsKKyAgICAgICAgICAgIHRzLnB1 c2goInRhcmdldC1wb2ludGVyLXdpZHRoIiwgIjMyIik7CisgICAgICAgIH0KKyAgICAgICAgdHMu cHVzaCgiY29kZS1tb2RlbCIsICJtZWRpdW0iKTsKKyAgICAgICAgdHMucHVzaCgiZGlzYWJsZS1y ZWR6b25lIiwgdHJ1ZSk7CisgICAgICAgIGxldCBtdXQgZmVhdHVyZXMgPSAiK20sK2EiLnRvX3N0 cmluZygpOworICAgICAgICBpZiBjZmcuaGFzKCJSSVNDVl9JU0FfQyIpIHsKKyAgICAgICAgICAg IGZlYXR1cmVzICs9ICIsK2MiOworICAgICAgICB9CisgICAgICAgIHRzLnB1c2goImZlYXR1cmVz IiwgZmVhdHVyZXMpOworICAgIH0gZWxzZSBpZiBjZmcuaGFzKCJYODZfNjQiKSB7CisgICAgICAg IHRzLnB1c2goImFyY2giLCAieDg2XzY0Iik7CisgICAgICAgIHRzLnB1c2goCisgICAgICAgICAg ICAiZGF0YS1sYXlvdXQiLAorICAgICAgICAgICAgImUtbTplLXAyNzA6MzI6MzItcDI3MTozMjoz Mi1wMjcyOjY0OjY0LWk2NDo2NC1mODA6MTI4LW44OjE2OjMyOjY0LVMxMjgiLAorICAgICAgICAp OworICAgICAgICBsZXQgbXV0IGZlYXR1cmVzID0gIi0zZG5vdywtM2Rub3dhLC1tbXgsK3NvZnQt ZmxvYXQiLnRvX3N0cmluZygpOworICAgICAgICBpZiBjZmcuaGFzKCJSRVRQT0xJTkUiKSB7Cisg ICAgICAgICAgICBmZWF0dXJlcyArPSAiLCtyZXRwb2xpbmUtZXh0ZXJuYWwtdGh1bmsiOworICAg ICAgICB9CisgICAgICAgIHRzLnB1c2goImZlYXR1cmVzIiwgZmVhdHVyZXMpOworICAgICAgICB0 cy5wdXNoKCJsbHZtLXRhcmdldCIsICJ4ODZfNjQtbGludXgtZ251Iik7CisgICAgICAgIHRzLnB1 c2goInRhcmdldC1wb2ludGVyLXdpZHRoIiwgIjY0Iik7CisgICAgfSBlbHNlIHsKKyAgICAgICAg cGFuaWMhKCJVbnN1cHBvcnRlZCBhcmNoaXRlY3R1cmUiKTsKKyAgICB9CisKKyAgICB0cy5wdXNo KCJlbWl0LWRlYnVnLWdkYi1zY3JpcHRzIiwgZmFsc2UpOworICAgIHRzLnB1c2goImZyYW1lLXBv aW50ZXIiLCAibWF5LW9taXQiKTsKKyAgICB0cy5wdXNoKAorICAgICAgICAic3RhY2stcHJvYmVz IiwKKyAgICAgICAgdmVjIVsoImtpbmQiLnRvX3N0cmluZygpLCBWYWx1ZTo6U3RyaW5nKCJub25l Ii50b19zdHJpbmcoKSkpXSwKKyAgICApOworCisgICAgLy8gRXZlcnl0aGluZyBlbHNlIGlzIExF LCB3aGV0aGVyIGBDUFVfTElUVExFX0VORElBTmAgaXMgZGVjbGFyZWQgb3Igbm90CisgICAgLy8g KGUuZy4geDg2KS4gSXQgaXMgYWxzbyBgcnVzdGNgJ3MgZGVmYXVsdC4KKyAgICBpZiBjZmcuaGFz KCJDUFVfQklHX0VORElBTiIpIHsKKyAgICAgICAgdHMucHVzaCgidGFyZ2V0LWVuZGlhbiIsICJi aWciKTsKKyAgICB9CisKKyAgICBwcmludGxuISgie30iLCB0cyk7Cit9CmRpZmYgLS1naXQgYS9z Y3JpcHRzL2lzX3J1c3RfbW9kdWxlLnNoIGIvc2NyaXB0cy9pc19ydXN0X21vZHVsZS5zaApuZXcg ZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAuLjI4YjM4MzFhNzU5MwotLS0gL2Rl di9udWxsCisrKyBiL3NjcmlwdHMvaXNfcnVzdF9tb2R1bGUuc2gKQEAgLTAsMCArMSwxNiBAQAor IyEvYmluL3NoCisjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCisjCisjIGlzX3J1 c3RfbW9kdWxlLnNoIG1vZHVsZS5rbworIworIyBSZXR1cm5zIGAwYCBpZiBgbW9kdWxlLmtvYCBp cyBhIFJ1c3QgbW9kdWxlLCBgMWAgb3RoZXJ3aXNlLgorCitzZXQgLWUKKworIyBVc2luZyB0aGUg YDE2X2AgcHJlZml4IGVuc3VyZXMgb3RoZXIgc3ltYm9scyB3aXRoIHRoZSBzYW1lIHN1YnN0cmlu ZworIyBhcmUgbm90IHBpY2tlZCB1cCAoZXZlbiBpZiBpdCB3b3VsZCBiZSB1bmxpa2VseSkuIFRo ZSBsYXN0IHBhcnQgaXMKKyMgdXNlZCBqdXN0IGluIGNhc2UgTExWTSBkZWNpZGVzIHRvIHVzZSB0 aGUgYC5gIHN1ZmZpeC4KKyMKKyMgSW4gdGhlIGZ1dHVyZSwgY2hlY2tpbmcgZm9yIHRoZSBgLmNv bW1lbnRgIHNlY3Rpb24gbWF5IGJlIGFub3RoZXIKKyMgb3B0aW9uLCBzZWUgaHR0cHM6Ly9naXRo dWIuY29tL3J1c3QtbGFuZy9ydXN0L3B1bGwvOTc1NTAuCiske05NfSAiJCoiIHwgZ3JlcCAtcUUg J15bMC05YS1mQS1GXSsgciBfUlteWzpzcGFjZTpdXSsxNl9fX0lTX1JVU1RfTU9EVUxFW15bOnNw YWNlOl1dKiQnCmRpZmYgLS1naXQgYS9zY3JpcHRzL2tjb25maWcvY29uZmRhdGEuYyBiL3Njcmlw dHMva2NvbmZpZy9jb25mZGF0YS5jCmluZGV4IGM0MzQwYzkwZTE3Mi4uYjdjOWYxZGQ1ZTQyIDEw MDY0NAotLS0gYS9zY3JpcHRzL2tjb25maWcvY29uZmRhdGEuYworKysgYi9zY3JpcHRzL2tjb25m aWcvY29uZmRhdGEuYwpAQCAtMjE2LDYgKzIxNiwxMyBAQCBzdGF0aWMgY29uc3QgY2hhciAqY29u Zl9nZXRfYXV0b2hlYWRlcl9uYW1lKHZvaWQpCiAJcmV0dXJuIG5hbWUgPyBuYW1lIDogImluY2x1 ZGUvZ2VuZXJhdGVkL2F1dG9jb25mLmgiOwogfQogCitzdGF0aWMgY29uc3QgY2hhciAqY29uZl9n ZXRfcnVzdGNjZmdfbmFtZSh2b2lkKQoreworCWNoYXIgKm5hbWUgPSBnZXRlbnYoIktDT05GSUdf UlVTVENDRkciKTsKKworCXJldHVybiBuYW1lID8gbmFtZSA6ICJpbmNsdWRlL2dlbmVyYXRlZC9y dXN0Y19jZmciOworfQorCiBzdGF0aWMgaW50IGNvbmZfc2V0X3N5bV92YWwoc3RydWN0IHN5bWJv bCAqc3ltLCBpbnQgZGVmLCBpbnQgZGVmX2ZsYWdzLCBjaGFyICpwKQogewogCWNoYXIgKnAyOwpA QCAtNjA1LDYgKzYxMiw5IEBAIHN0YXRpYyBjb25zdCBzdHJ1Y3QgY29tbWVudF9zdHlsZSBjb21t ZW50X3N0eWxlX2MgPSB7CiAKIHN0YXRpYyB2b2lkIGNvbmZfd3JpdGVfaGVhZGluZyhGSUxFICpm cCwgY29uc3Qgc3RydWN0IGNvbW1lbnRfc3R5bGUgKmNzKQogeworCWlmICghY3MpCisJCXJldHVy bjsKKwogCWZwcmludGYoZnAsICIlc1xuIiwgY3MtPnByZWZpeCk7CiAKIAlmcHJpbnRmKGZwLCAi JXMgQXV0b21hdGljYWxseSBnZW5lcmF0ZWQgZmlsZTsgRE8gTk9UIEVESVQuXG4iLApAQCAtNzQ1 LDYgKzc1NSw2NSBAQCBzdGF0aWMgdm9pZCBwcmludF9zeW1ib2xfZm9yX2MoRklMRSAqZnAsIHN0 cnVjdCBzeW1ib2wgKnN5bSkKIAlmcmVlKGVzY2FwZWQpOwogfQogCitzdGF0aWMgdm9pZCBwcmlu dF9zeW1ib2xfZm9yX3J1c3RjY2ZnKEZJTEUgKmZwLCBzdHJ1Y3Qgc3ltYm9sICpzeW0pCit7CisJ Y29uc3QgY2hhciAqdmFsOworCWNvbnN0IGNoYXIgKnZhbF9wcmVmaXggPSAiIjsKKwljaGFyICp2 YWxfcHJlZml4ZWQgPSBOVUxMOworCXNpemVfdCB2YWxfcHJlZml4ZWRfbGVuOworCWNoYXIgKmVz Y2FwZWQgPSBOVUxMOworCisJaWYgKHN5bS0+dHlwZSA9PSBTX1VOS05PV04pCisJCXJldHVybjsK KworCXZhbCA9IHN5bV9nZXRfc3RyaW5nX3ZhbHVlKHN5bSk7CisKKwlzd2l0Y2ggKHN5bS0+dHlw ZSkgeworCWNhc2UgU19CT09MRUFOOgorCWNhc2UgU19UUklTVEFURToKKwkJLyoKKwkJICogV2Ug ZG8gbm90IGNhcmUgYWJvdXQgZGlzYWJsZWQgb25lcywgaS5lLiBubyBuZWVkIGZvcgorCQkgKiB3 aGF0IG90aGVyd2lzZSBhcmUgImNvbW1lbnRzIiBpbiBvdGhlciBwcmludGVycy4KKwkJICovCisJ CWlmICgqdmFsID09ICduJykKKwkJCXJldHVybjsKKworCQkvKgorCQkgKiBUbyBoYXZlIHNpbWls YXIgZnVuY3Rpb25hbGl0eSB0byB0aGUgQyBtYWNybyBgSVNfRU5BQkxFRCgpYAorCQkgKiB3ZSBw cm92aWRlIGFuIGVtcHR5IGAtLWNmZyBDT05GSUdfWGAgaGVyZSBpbiBib3RoIGB5YAorCQkgKiBh bmQgYG1gIGNhc2VzLgorCQkgKgorCQkgKiBUaGVuLCB0aGUgY29tbW9uIGBmcHJpbnRmKClgIGJl bG93IHdpbGwgYWxzbyBnaXZlIHVzCisJCSAqIGEgYC0tY2ZnIENPTkZJR19YPSJ5ImAgb3IgYC0t Y2ZnIENPTkZJR19YPSJtImAsIHdoaWNoIGNhbgorCQkgKiBiZSB1c2VkIGFzIHRoZSBlcXVpdmFs ZW50IG9mIGBJU19CVUlMVElOKClgL2BJU19NT0RVTEUoKWAuCisJCSAqLworCQlmcHJpbnRmKGZw LCAiLS1jZmc9JXMlc1xuIiwgQ09ORklHXywgc3ltLT5uYW1lKTsKKwkJYnJlYWs7CisJY2FzZSBT X0hFWDoKKwkJaWYgKHZhbFswXSAhPSAnMCcgfHwgKHZhbFsxXSAhPSAneCcgJiYgdmFsWzFdICE9 ICdYJykpCisJCQl2YWxfcHJlZml4ID0gIjB4IjsKKwkJYnJlYWs7CisJZGVmYXVsdDoKKwkJYnJl YWs7CisJfQorCisJaWYgKHN0cmxlbih2YWxfcHJlZml4KSA+IDApIHsKKwkJdmFsX3ByZWZpeGVk X2xlbiA9IHN0cmxlbih2YWwpICsgc3RybGVuKHZhbF9wcmVmaXgpICsgMTsKKwkJdmFsX3ByZWZp eGVkID0geG1hbGxvYyh2YWxfcHJlZml4ZWRfbGVuKTsKKwkJc25wcmludGYodmFsX3ByZWZpeGVk LCB2YWxfcHJlZml4ZWRfbGVuLCAiJXMlcyIsIHZhbF9wcmVmaXgsIHZhbCk7CisJCXZhbCA9IHZh bF9wcmVmaXhlZDsKKwl9CisKKwkvKiBBbGwgdmFsdWVzIGdldCBlc2NhcGVkOiB0aGUgYC0tY2Zn YCBvcHRpb24gb25seSB0YWtlcyBzdHJpbmdzICovCisJZXNjYXBlZCA9IGVzY2FwZV9zdHJpbmdf dmFsdWUodmFsKTsKKwl2YWwgPSBlc2NhcGVkOworCisJZnByaW50ZihmcCwgIi0tY2ZnPSVzJXM9 JXNcbiIsIENPTkZJR18sIHN5bS0+bmFtZSwgdmFsKTsKKworCWZyZWUoZXNjYXBlZCk7CisJZnJl ZSh2YWxfcHJlZml4ZWQpOworfQorCiAvKgogICogV3JpdGUgb3V0IGEgbWluaW1hbCBjb25maWcu CiAgKiBBbGwgdmFsdWVzIHRoYXQgaGFzIGRlZmF1bHQgdmFsdWVzIGFyZSBza2lwcGVkIGFzIHRo aXMgaXMgcmVkdW5kYW50LgpAQCAtMTEzMiw2ICsxMjAxLDEyIEBAIGludCBjb25mX3dyaXRlX2F1 dG9jb25mKGludCBvdmVyd3JpdGUpCiAJaWYgKHJldCkKIAkJcmV0dXJuIHJldDsKIAorCXJldCA9 IF9fY29uZl93cml0ZV9hdXRvY29uZihjb25mX2dldF9ydXN0Y2NmZ19uYW1lKCksCisJCQkJICAg IHByaW50X3N5bWJvbF9mb3JfcnVzdGNjZmcsCisJCQkJICAgIE5VTEwpOworCWlmIChyZXQpCisJ CXJldHVybiByZXQ7CisKIAkvKgogCSAqIENyZWF0ZSBpbmNsdWRlL2NvbmZpZy9hdXRvLmNvbmYu IFRoaXMgbXVzdCBiZSB0aGUgbGFzdCBzdGVwIGJlY2F1c2UKIAkgKiBLYnVpbGQgaGFzIGEgZGVw ZW5kZW5jeSBvbiBhdXRvLmNvbmYgYW5kIHRoaXMgbWFya3MgdGhlIHN1Y2Nlc3NmdWwKZGlmZiAt LWdpdCBhL3NjcmlwdHMvbWluLXRvb2wtdmVyc2lvbi5zaCBiL3NjcmlwdHMvbWluLXRvb2wtdmVy c2lvbi5zaAppbmRleCAyNTA5MjVhYWIxMDEuLmI2NTkzZWFjNTAwMyAxMDA3NTUKLS0tIGEvc2Ny aXB0cy9taW4tdG9vbC12ZXJzaW9uLnNoCisrKyBiL3NjcmlwdHMvbWluLXRvb2wtdmVyc2lvbi5z aApAQCAtMzAsNiArMzAsMTIgQEAgbGx2bSkKIAkJZWNobyAxMS4wLjAKIAlmaQogCTs7CitydXN0 YykKKwllY2hvIDEuNjIuMAorCTs7CitiaW5kZ2VuKQorCWVjaG8gMC41Ni4wCisJOzsKICopCiAJ ZWNobyAiJDE6IHVua25vd24gdG9vbCIgPiYyCiAJZXhpdCAxCmRpZmYgLS1naXQgYS9zY3JpcHRz L3J1c3QtaXMtYXZhaWxhYmxlLWJpbmRnZW4tbGliY2xhbmcuaCBiL3NjcmlwdHMvcnVzdC1pcy1h dmFpbGFibGUtYmluZGdlbi1saWJjbGFuZy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAw MDAwMDAwMDAwMC4uMGVmNmRiMTBkNjc0Ci0tLSAvZGV2L251bGwKKysrIGIvc2NyaXB0cy9ydXN0 LWlzLWF2YWlsYWJsZS1iaW5kZ2VuLWxpYmNsYW5nLmgKQEAgLTAsMCArMSwyIEBACisvKiBTUERY LUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMCAqLworI3ByYWdtYSBtZXNzYWdlKCJjbGFuZyB2 ZXJzaW9uICIgX19jbGFuZ192ZXJzaW9uX18pCmRpZmYgLS1naXQgYS9zY3JpcHRzL3J1c3QtaXMt YXZhaWxhYmxlLnNoIGIvc2NyaXB0cy9ydXN0LWlzLWF2YWlsYWJsZS5zaApuZXcgZmlsZSBtb2Rl IDEwMDc1NQppbmRleCAwMDAwMDAwMDAwMDAuLjBkZGFkM2ZjZDMyYwotLS0gL2Rldi9udWxsCisr KyBiL3NjcmlwdHMvcnVzdC1pcy1hdmFpbGFibGUuc2gKQEAgLTAsMCArMSwxNjAgQEAKKyMhL2Jp bi9zaAorIyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogR1BMLTIuMAorIworIyBUZXN0cyB3aGV0 aGVyIGEgc3VpdGFibGUgUnVzdCB0b29sY2hhaW4gaXMgYXZhaWxhYmxlLgorIworIyBQYXNzIGAt dmAgZm9yIGh1bWFuIG91dHB1dCBhbmQgbW9yZSBjaGVja3MgKGFzIHdhcm5pbmdzKS4KKworc2V0 IC1lCisKK21pbl90b29sX3ZlcnNpb249JChkaXJuYW1lICQwKS9taW4tdG9vbC12ZXJzaW9uLnNo CisKKyMgQ29udmVydCB0aGUgdmVyc2lvbiBzdHJpbmcgeC55LnogdG8gYSBjYW5vbmljYWwgdXAt dG8tNy1kaWdpdHMgZm9ybS4KKyMKKyMgTm90ZSB0aGF0IHRoaXMgZnVuY3Rpb24gdXNlcyBvbmUg bW9yZSBkaWdpdCAoY29tcGFyZWQgdG8gb3RoZXIKKyMgaW5zdGFuY2VzIGluIG90aGVyIHZlcnNp b24gc2NyaXB0cykgdG8gZ2l2ZSBhIGJpdCBtb3JlIHNwYWNlIHRvCisjIGBydXN0Y2Agc2luY2Ug aXQgd2lsbCByZWFjaCAxLjEwMC4wIGluIGxhdGUgMjAyNi4KK2dldF9jYW5vbmljYWxfdmVyc2lv bigpCit7CisJSUZTPS4KKwlzZXQgLS0gJDEKKwllY2hvICQoKDEwMDAwMCAqICQxICsgMTAwICog JDIgKyAkMykpCit9CisKKyMgQ2hlY2sgdGhhdCB0aGUgUnVzdCBjb21waWxlciBleGlzdHMuCitp ZiAhIGNvbW1hbmQgLXYgIiRSVVNUQyIgPi9kZXYvbnVsbDsgdGhlbgorCWlmIFsgIiQxIiA9IC12 IF07IHRoZW4KKwkJZWNobyA+JjIgIioqKiIKKwkJZWNobyA+JjIgIioqKiBSdXN0IGNvbXBpbGVy ICckUlVTVEMnIGNvdWxkIG5vdCBiZSBmb3VuZC4iCisJCWVjaG8gPiYyICIqKioiCisJZmkKKwll eGl0IDEKK2ZpCisKKyMgQ2hlY2sgdGhhdCB0aGUgUnVzdCBiaW5kaW5ncyBnZW5lcmF0b3IgZXhp c3RzLgoraWYgISBjb21tYW5kIC12ICIkQklOREdFTiIgPi9kZXYvbnVsbDsgdGhlbgorCWlmIFsg IiQxIiA9IC12IF07IHRoZW4KKwkJZWNobyA+JjIgIioqKiIKKwkJZWNobyA+JjIgIioqKiBSdXN0 IGJpbmRpbmdzIGdlbmVyYXRvciAnJEJJTkRHRU4nIGNvdWxkIG5vdCBiZSBmb3VuZC4iCisJCWVj aG8gPiYyICIqKioiCisJZmkKKwlleGl0IDEKK2ZpCisKKyMgQ2hlY2sgdGhhdCB0aGUgUnVzdCBj b21waWxlciB2ZXJzaW9uIGlzIHN1aXRhYmxlLgorIworIyBOb24tc3RhYmxlIGFuZCBkaXN0cmli dXRpb25zJyB2ZXJzaW9ucyBtYXkgaGF2ZSBhIHZlcnNpb24gc3VmZml4LCBlLmcuIGAtZGV2YC4K K3J1c3RfY29tcGlsZXJfdmVyc2lvbj0kKCBcCisJTENfQUxMPUMgIiRSVVNUQyIgLS12ZXJzaW9u IDI+L2Rldi9udWxsIFwKKwkJfCBoZWFkIC1uIDEgXAorCQl8IGdyZXAgLW9FICdbMC05XStcLlsw LTldK1wuWzAtOV0rJyBcCispCitydXN0X2NvbXBpbGVyX21pbl92ZXJzaW9uPSQoJG1pbl90b29s X3ZlcnNpb24gcnVzdGMpCitydXN0X2NvbXBpbGVyX2N2ZXJzaW9uPSQoZ2V0X2Nhbm9uaWNhbF92 ZXJzaW9uICRydXN0X2NvbXBpbGVyX3ZlcnNpb24pCitydXN0X2NvbXBpbGVyX21pbl9jdmVyc2lv bj0kKGdldF9jYW5vbmljYWxfdmVyc2lvbiAkcnVzdF9jb21waWxlcl9taW5fdmVyc2lvbikKK2lm IFsgIiRydXN0X2NvbXBpbGVyX2N2ZXJzaW9uIiAtbHQgIiRydXN0X2NvbXBpbGVyX21pbl9jdmVy c2lvbiIgXTsgdGhlbgorCWlmIFsgIiQxIiA9IC12IF07IHRoZW4KKwkJZWNobyA+JjIgIioqKiIK KwkJZWNobyA+JjIgIioqKiBSdXN0IGNvbXBpbGVyICckUlVTVEMnIGlzIHRvbyBvbGQuIgorCQll Y2hvID4mMiAiKioqICAgWW91ciB2ZXJzaW9uOiAgICAkcnVzdF9jb21waWxlcl92ZXJzaW9uIgor CQllY2hvID4mMiAiKioqICAgTWluaW11bSB2ZXJzaW9uOiAkcnVzdF9jb21waWxlcl9taW5fdmVy c2lvbiIKKwkJZWNobyA+JjIgIioqKiIKKwlmaQorCWV4aXQgMQorZmkKK2lmIFsgIiQxIiA9IC12 IF0gJiYgWyAiJHJ1c3RfY29tcGlsZXJfY3ZlcnNpb24iIC1ndCAiJHJ1c3RfY29tcGlsZXJfbWlu X2N2ZXJzaW9uIiBdOyB0aGVuCisJZWNobyA+JjIgIioqKiIKKwllY2hvID4mMiAiKioqIFJ1c3Qg Y29tcGlsZXIgJyRSVVNUQycgaXMgdG9vIG5ldy4gVGhpcyBtYXkgb3IgbWF5IG5vdCB3b3JrLiIK KwllY2hvID4mMiAiKioqICAgWW91ciB2ZXJzaW9uOiAgICAgJHJ1c3RfY29tcGlsZXJfdmVyc2lv biIKKwllY2hvID4mMiAiKioqICAgRXhwZWN0ZWQgdmVyc2lvbjogJHJ1c3RfY29tcGlsZXJfbWlu X3ZlcnNpb24iCisJZWNobyA+JjIgIioqKiIKK2ZpCisKKyMgQ2hlY2sgdGhhdCB0aGUgUnVzdCBi aW5kaW5ncyBnZW5lcmF0b3IgaXMgc3VpdGFibGUuCisjCisjIE5vbi1zdGFibGUgYW5kIGRpc3Ry aWJ1dGlvbnMnIHZlcnNpb25zIG1heSBoYXZlIGEgdmVyc2lvbiBzdWZmaXgsIGUuZy4gYC1kZXZg LgorcnVzdF9iaW5kaW5nc19nZW5lcmF0b3JfdmVyc2lvbj0kKCBcCisJTENfQUxMPUMgIiRCSU5E R0VOIiAtLXZlcnNpb24gMj4vZGV2L251bGwgXAorCQl8IGhlYWQgLW4gMSBcCisJCXwgZ3JlcCAt b0UgJ1swLTldK1wuWzAtOV0rXC5bMC05XSsnIFwKKykKK3J1c3RfYmluZGluZ3NfZ2VuZXJhdG9y X21pbl92ZXJzaW9uPSQoJG1pbl90b29sX3ZlcnNpb24gYmluZGdlbikKK3J1c3RfYmluZGluZ3Nf Z2VuZXJhdG9yX2N2ZXJzaW9uPSQoZ2V0X2Nhbm9uaWNhbF92ZXJzaW9uICRydXN0X2JpbmRpbmdz X2dlbmVyYXRvcl92ZXJzaW9uKQorcnVzdF9iaW5kaW5nc19nZW5lcmF0b3JfbWluX2N2ZXJzaW9u PSQoZ2V0X2Nhbm9uaWNhbF92ZXJzaW9uICRydXN0X2JpbmRpbmdzX2dlbmVyYXRvcl9taW5fdmVy c2lvbikKK2lmIFsgIiRydXN0X2JpbmRpbmdzX2dlbmVyYXRvcl9jdmVyc2lvbiIgLWx0ICIkcnVz dF9iaW5kaW5nc19nZW5lcmF0b3JfbWluX2N2ZXJzaW9uIiBdOyB0aGVuCisJaWYgWyAiJDEiID0g LXYgXTsgdGhlbgorCQllY2hvID4mMiAiKioqIgorCQllY2hvID4mMiAiKioqIFJ1c3QgYmluZGlu Z3MgZ2VuZXJhdG9yICckQklOREdFTicgaXMgdG9vIG9sZC4iCisJCWVjaG8gPiYyICIqKiogICBZ b3VyIHZlcnNpb246ICAgICRydXN0X2JpbmRpbmdzX2dlbmVyYXRvcl92ZXJzaW9uIgorCQllY2hv ID4mMiAiKioqICAgTWluaW11bSB2ZXJzaW9uOiAkcnVzdF9iaW5kaW5nc19nZW5lcmF0b3JfbWlu X3ZlcnNpb24iCisJCWVjaG8gPiYyICIqKioiCisJZmkKKwlleGl0IDEKK2ZpCitpZiBbICIkMSIg PSAtdiBdICYmIFsgIiRydXN0X2JpbmRpbmdzX2dlbmVyYXRvcl9jdmVyc2lvbiIgLWd0ICIkcnVz dF9iaW5kaW5nc19nZW5lcmF0b3JfbWluX2N2ZXJzaW9uIiBdOyB0aGVuCisJZWNobyA+JjIgIioq KiIKKwllY2hvID4mMiAiKioqIFJ1c3QgYmluZGluZ3MgZ2VuZXJhdG9yICckQklOREdFTicgaXMg dG9vIG5ldy4gVGhpcyBtYXkgb3IgbWF5IG5vdCB3b3JrLiIKKwllY2hvID4mMiAiKioqICAgWW91 ciB2ZXJzaW9uOiAgICAgJHJ1c3RfYmluZGluZ3NfZ2VuZXJhdG9yX3ZlcnNpb24iCisJZWNobyA+ JjIgIioqKiAgIEV4cGVjdGVkIHZlcnNpb246ICRydXN0X2JpbmRpbmdzX2dlbmVyYXRvcl9taW5f dmVyc2lvbiIKKwllY2hvID4mMiAiKioqIgorZmkKKworIyBDaGVjayB0aGF0IHRoZSBgbGliY2xh bmdgIHVzZWQgYnkgdGhlIFJ1c3QgYmluZGluZ3MgZ2VuZXJhdG9yIGlzIHN1aXRhYmxlLgorYmlu ZGdlbl9saWJjbGFuZ192ZXJzaW9uPSQoIFwKKwlMQ19BTEw9QyAiJEJJTkRHRU4iICQoZGlybmFt ZSAkMCkvcnVzdC1pcy1hdmFpbGFibGUtYmluZGdlbi1saWJjbGFuZy5oIDI+JjEgPi9kZXYvbnVs bCBcCisJCXwgZ3JlcCAtRiAnY2xhbmcgdmVyc2lvbiAnIFwKKwkJfCBncmVwIC1vRSAnWzAtOV0r XC5bMC05XStcLlswLTldKycgXAorCQl8IGhlYWQgLW4gMSBcCispCitiaW5kZ2VuX2xpYmNsYW5n X21pbl92ZXJzaW9uPSQoJG1pbl90b29sX3ZlcnNpb24gbGx2bSkKK2JpbmRnZW5fbGliY2xhbmdf Y3ZlcnNpb249JChnZXRfY2Fub25pY2FsX3ZlcnNpb24gJGJpbmRnZW5fbGliY2xhbmdfdmVyc2lv bikKK2JpbmRnZW5fbGliY2xhbmdfbWluX2N2ZXJzaW9uPSQoZ2V0X2Nhbm9uaWNhbF92ZXJzaW9u ICRiaW5kZ2VuX2xpYmNsYW5nX21pbl92ZXJzaW9uKQoraWYgWyAiJGJpbmRnZW5fbGliY2xhbmdf Y3ZlcnNpb24iIC1sdCAiJGJpbmRnZW5fbGliY2xhbmdfbWluX2N2ZXJzaW9uIiBdOyB0aGVuCisJ aWYgWyAiJDEiID0gLXYgXTsgdGhlbgorCQllY2hvID4mMiAiKioqIgorCQllY2hvID4mMiAiKioq IGxpYmNsYW5nICh1c2VkIGJ5IHRoZSBSdXN0IGJpbmRpbmdzIGdlbmVyYXRvciAnJEJJTkRHRU4n KSBpcyB0b28gb2xkLiIKKwkJZWNobyA+JjIgIioqKiAgIFlvdXIgdmVyc2lvbjogICAgJGJpbmRn ZW5fbGliY2xhbmdfdmVyc2lvbiIKKwkJZWNobyA+JjIgIioqKiAgIE1pbmltdW0gdmVyc2lvbjog JGJpbmRnZW5fbGliY2xhbmdfbWluX3ZlcnNpb24iCisJCWVjaG8gPiYyICIqKioiCisJZmkKKwll eGl0IDEKK2ZpCisKKyMgSWYgdGhlIEMgY29tcGlsZXIgaXMgQ2xhbmcsIHRoZW4gd2UgY2FuIGFs c28gY2hlY2sgd2hldGhlciBpdHMgdmVyc2lvbgorIyBtYXRjaGVzIHRoZSBgbGliY2xhbmdgIHZl cnNpb24gdXNlZCBieSB0aGUgUnVzdCBiaW5kaW5ncyBnZW5lcmF0b3IuCisjCisjIEluIHRoZSBm dXR1cmUsIHdlIG1pZ2h0IGJlIGFibGUgdG8gcGVyZm9ybSBhIGZ1bGwgdmVyc2lvbiBjaGVjaywg c2VlCisjIGh0dHBzOi8vZ2l0aHViLmNvbS9ydXN0LWxhbmcvcnVzdC1iaW5kZ2VuL2lzc3Vlcy8y MTM4LgoraWYgWyAiJDEiID0gLXYgXTsgdGhlbgorCWNjX25hbWU9JCgkKGRpcm5hbWUgJDApL2Nj LXZlcnNpb24uc2ggIiRDQyIgfCBjdXQgLWYxIC1kJyAnKQorCWlmIFsgIiRjY19uYW1lIiA9IENs YW5nIF07IHRoZW4KKwkJY2xhbmdfdmVyc2lvbj0kKCBcCisJCQlMQ19BTEw9QyAiJENDIiAtLXZl cnNpb24gMj4vZGV2L251bGwgXAorCQkJCXwgc2VkIC1uRSAnMXM6Lip2ZXJzaW9uIChbMC05XStc LlswLTldK1wuWzAtOV0rKS4qOlwxOnAnCisJCSkKKwkJaWYgWyAiJGNsYW5nX3ZlcnNpb24iICE9 ICIkYmluZGdlbl9saWJjbGFuZ192ZXJzaW9uIiBdOyB0aGVuCisJCQllY2hvID4mMiAiKioqIgor CQkJZWNobyA+JjIgIioqKiBsaWJjbGFuZyAodXNlZCBieSB0aGUgUnVzdCBiaW5kaW5ncyBnZW5l cmF0b3IgJyRCSU5ER0VOJykiCisJCQllY2hvID4mMiAiKioqIHZlcnNpb24gZG9lcyBub3QgbWF0 Y2ggQ2xhbmcncy4gVGhpcyBtYXkgYmUgYSBwcm9ibGVtLiIKKwkJCWVjaG8gPiYyICIqKiogICBs aWJjbGFuZyB2ZXJzaW9uOiAkYmluZGdlbl9saWJjbGFuZ192ZXJzaW9uIgorCQkJZWNobyA+JjIg IioqKiAgIENsYW5nIHZlcnNpb246ICAgICRjbGFuZ192ZXJzaW9uIgorCQkJZWNobyA+JjIgIioq KiIKKwkJZmkKKwlmaQorZmkKKworIyBDaGVjayB0aGF0IHRoZSBzb3VyY2UgY29kZSBmb3IgdGhl IGBjb3JlYCBzdGFuZGFyZCBsaWJyYXJ5IGV4aXN0cy4KKyMKKyMgYCRLUlVTVEZMQUdTYCBpcyBw YXNzZWQgaW4gY2FzZSB0aGUgdXNlciBhZGRlZCBgLS1zeXNyb290YC4KK3J1c3RjX3N5c3Jvb3Q9 JCgiJFJVU1RDIiAkS1JVU1RGTEFHUyAtLXByaW50IHN5c3Jvb3QpCitydXN0Y19zcmM9JHtSVVNU X0xJQl9TUkM6LSIkcnVzdGNfc3lzcm9vdC9saWIvcnVzdGxpYi9zcmMvcnVzdC9saWJyYXJ5In0K K3J1c3RjX3NyY19jb3JlPSIkcnVzdGNfc3JjL2NvcmUvc3JjL2xpYi5ycyIKK2lmIFsgISAtZSAi JHJ1c3RjX3NyY19jb3JlIiBdOyB0aGVuCisJaWYgWyAiJDEiID0gLXYgXTsgdGhlbgorCQllY2hv ID4mMiAiKioqIgorCQllY2hvID4mMiAiKioqIFNvdXJjZSBjb2RlIGZvciB0aGUgJ2NvcmUnIHN0 YW5kYXJkIGxpYnJhcnkgY291bGQgbm90IGJlIGZvdW5kIgorCQllY2hvID4mMiAiKioqIGF0ICck cnVzdGNfc3JjX2NvcmUnLiIKKwkJZWNobyA+JjIgIioqKiIKKwlmaQorCWV4aXQgMQorZmkKLS0g CjIuMzcuMQoKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f CmxpbnV4LWFybS1rZXJuZWwgbWFpbGluZyBsaXN0CmxpbnV4LWFybS1rZXJuZWxAbGlzdHMuaW5m cmFkZWFkLm9yZwpodHRwOi8vbGlzdHMuaW5mcmFkZWFkLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2xp bnV4LWFybS1rZXJuZWwK