From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga02.intel.com ([134.134.136.20]:35770 "EHLO mga02.intel.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1752987AbdGGAWm (ORCPT ); Thu, 6 Jul 2017 20:22:42 -0400 From: "Williams, Dan J" To: "torvalds@linux-foundation.org" CC: "linux-kernel@vger.kernel.org" , "linux-nvdimm@lists.01.org" , "linux-block@vger.kernel.org" , "viro@zeniv.linux.org.uk" , "x86@kernel.org" , "linux-fsdevel@vger.kernel.org" Subject: [GIT PULL] libnvdimm for 4.13 Date: Fri, 7 Jul 2017 00:22:38 +0000 Message-ID: <1499386957.6081.29.camel@intel.com> Content-Type: text/plain; charset="utf-7" MIME-Version: 1.0 Sender: linux-block-owner@vger.kernel.org List-Id: linux-block@vger.kernel.org Hi Linus, please pull from: git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm tags/libnvdimm-for-4.13 to receive, libnvdimm updates for the latest ACPI and UEFI specifications. This pull request also includes new 'struct dax+AF8-operations' enabling to undo the abuse +AFs-1+AF0- of copy+AF8-user+AF8-nocache() for copy operations to pmem. The dax work originally missed 4.12 to address concerns raised by Al. +AFs-1+AF0-: https://lists.01.org/pipermail/linux-nvdimm/2017-January/008364.html All of the commits in this pull request have appeared in one or more -next releases with no errors reported, however, Stephen did report a late merge conflict between nvdimm.git and the vfs.git tree. Stephen's merge resolution is here:+AKA-http://marc.info/?l+AD0-linux-kernel+ACY-m+AD0-1499064115 07301+ACY-w+AD0-2, but to match Al's changes we appear to also need the incremental change below. Please pull, I believe any straggling +AF8-flushcache() feedback at this point can be fixed up post -rc1. I include commit 0aed55af8834 +ACI-x86, uaccess: introduce copy+AF8-from+AF8-iter+AF8-flushcache for pmem / cache-bypass operations+ACI- at the end of this message for reference. --- diff --git a/include/linux/uio.h b/include/linux/uio.h index 2f46f8d4b508..073bb1feb0d0 100644 --- a/include/linux/uio.h +-+-+- b/include/linux/uio.h +AEAAQA- -97,6 +-97,7 +AEAAQA- size+AF8-t +AF8-copy+AF8-to+AF8-iter(const void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i)+ADs- size+AF8-t +AF8-copy+AF8-from+AF8-iter(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i)+ADs- bool +AF8-copy+AF8-from+AF8-iter+AF8-full(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i)+ADs- size+AF8-t +AF8-copy+AF8-from+AF8-iter+AF8-nocache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i)+ADs- +-size+AF8-t +AF8-copy+AF8-from+AF8-iter+AF8-flushcache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i)+ADs- bool +AF8-copy+AF8-from+AF8-iter+AF8-full+AF8-nocache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i)+ADs- static +AF8AXw-always+AF8-inline +AF8AXw-must+AF8-check +AEAAQA- -151,7 +-152,14 +AEAAQA- bool copy+AF8-from+AF8-iter+AF8-full+AF8-nocache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i) +ACo- IS+AF8-ENABLED(CONFIG+AF8-ARCH+AF8-HAS+AF8-UACCESS+AF8-FLUSHCACHE) before assuming that the +ACo- destination is flushed from the cache on return. +ACo-/ -size+AF8-t copy+AF8-from+AF8-iter+AF8-flushcache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i)+ADs- +-static +AF8AXw-always+AF8-inline +AF8AXw-must+AF8-check +-size+AF8-t copy+AF8-from+AF8-iter+AF8-flushcache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i) +-+AHs- +- if (unlikely(+ACE-check+AF8-copy+AF8-size(addr, bytes, false))) +- return bytes+ADs- +- else +- return +AF8-copy+AF8-from+AF8-iter+AF8-flushcache(addr, bytes, i)+ADs- +-+AH0- +ACM-else static inline size+AF8-t copy+AF8-from+AF8-iter+AF8-flushcache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i) diff --git a/lib/iov+AF8-iter.c b/lib/iov+AF8-iter.c index ee82300d98b9..0d18ede56a36 100644 --- a/lib/iov+AF8-iter.c +-+-+- b/lib/iov+AF8-iter.c +AEAAQA- -642,7 +-642,7 +AEAAQA- size+AF8-t +AF8-copy+AF8-from+AF8-iter+AF8-nocache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i) EXPORT+AF8-SYMBOL(+AF8-copy+AF8-from+AF8-iter+AF8-nocache)+ADs- +ACM-ifdef CONFIG+AF8-ARCH+AF8-HAS+AF8-UACCESS+AF8-FLUSHCACHE -size+AF8-t copy+AF8-from+AF8-iter+AF8-flushcache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i) +-size+AF8-t +AF8-copy+AF8-from+AF8-iter+AF8-flushcache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i) +AHs- char +ACo-to +AD0- addr+ADs- if (unlikely(i-+AD4-type +ACY- ITER+AF8-PIPE)) +AHs- +AEAAQA- -660,7 +-660,7 +AEAAQA- size+AF8-t copy+AF8-from+AF8-iter+AF8-flushcache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i) return bytes+ADs- +AH0- -EXPORT+AF8-SYMBOL+AF8-GPL(copy+AF8-from+AF8-iter+AF8-flushcache)+ADs- +-EXPORT+AF8-SYMBOL+AF8-GPL(+AF8-copy+AF8-from+AF8-iter+AF8-flushcache)+ADs- +ACM-endif bool +AF8-copy+AF8-from+AF8-iter+AF8-full+AF8-nocache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i) --- The following changes since commit 87085ff2e90ecfa91f8bb0cb0ce19ea661bd6f83: thermal: int340x+AF8-thermal: fix compile after the UUID API switch (2017-06-09 16:37:31 +-0200) are available in the git repository at: git://git.kernel.org/pub/scm/linux/kernel/git/nvdimm/nvdimm tags/libnvdimm-for-4.13 for you to fetch changes up to 9d92573fff3ec70785ef1815cc80573f70e7a921: Merge branch 'for-4.13/dax' into libnvdimm-for-next (2017-07-03 16:54:58 -0700) ---------------------------------------------------------------- libnvdimm for 4.13 +ACo- Introduce the +AF8-flushcache() family of memory copy helpers and use them for persistent memory write operations on x86. The +AF8-flushcache() semantic indicates that the cache is either bypassed for the copy operation (movnt) or any lines dirtied by the copy operation are written back (clwb, clflushopt, or clflush). +ACo- Extend dax+AF8-operations with -+AD4-copy+AF8-from+AF8-iter() and -+AD4-flush() operations. These operations and other infrastructure updates allow all persistent memory specific dax functionality to be pushed into libnvdimm and the pmem driver directly. It also allows dax-specific sysfs attributes to be linked to a host device, for example: /sys/block/pmem0/dax/write+AF8-cache +ACo- Add support for the new NVDIMM platform/firmware mechanisms introduced in ACPI 6.2 and UEFI 2.7. This support includes the v1.2 namespace label format, extensions to the address-range-scrub command set, new error injection commands, and a new BTT (block-translation-table) layout. These updates support inter-OS and pre-OS compatibility. +ACo- Fix a longstanding memory corruption bug in nfit+AF8-test. +ACo- Make the pmem and nvdimm-region 'badblocks' sysfs files poll(2) capable. +ACo- Miscellaneous fixes and small updates across libnvdimm and the nfit driver. Acknowledgements that came after the branch was pushed: commit 6aa734a2f38e +ACI-libnvdimm, region, pmem: fix 'badblocks' sysfs+AF8-get+AF8-dirent() reference lifetime+ACI- Reviewed-by: Toshi Kani +ADw-toshi.kani+AEA-hpe.com+AD4- ---------------------------------------------------------------- Arvind Yadav (1): acpi, nfit: constify +ACoAXw-attribute+AF8-group Dan Williams (29): x86, uaccess: introduce copy+AF8-from+AF8-iter+AF8-flushcache for pmem / cache-bypass operations dm: add -+AD4-copy+AF8-from+AF8-iter() dax operation support libnvdimm, label: add v1.2 nvdimm label definitions libnvdimm, label: add v1.2 interleave-set-cookie algorithm libnvdimm, label: honor the lba size specified in v1.2 labels libnvdimm, label: populate the type+AF8-guid property for v1.2 namespaces libnvdimm, label: populate 'isetcookie' for blk-aperture namespaces libnvdimm, label: update 'nlabel' and 'position' handling for local namespaces libnvdimm, label: add v1.2 label checksum support libnvdimm, label: add address abstraction identifiers libnvdimm, label: switch to using v1.2 labels by default filesystem-dax: convert to dax+AF8-copy+AF8-from+AF8-iter() dax, pmem: introduce an optional 'flush' dax+AF8-operation dm: add -+AD4-flush() dax operation support filesystem-dax: convert to dax+AF8-flush() x86, dax: replace clear+AF8-pmem() with open coded memset +- dax+AF8-ops-+AD4-flush x86, dax, libnvdimm: remove wb+AF8-cache+AF8-pmem() indirection x86, libnvdimm, pmem: move arch+AF8-invalidate+AF8-pmem() to libnvdimm x86, libnvdimm, pmem: remove global pmem api libnvdimm, pmem: fix persistence warning libnvdimm, nfit: enable support for volatile ranges dax: remove default copy+AF8-from+AF8-iter fallback dax: convert to bitmask for flags libnvdimm, pmem, dax: export a cache control attribute libnvdimm, pmem: disable dax flushing when pmem is fronting a volatile region acpi, nfit: quiet invalid block-aperture-region warnings libnvdimm, region, pmem: fix 'badblocks' sysfs+AF8-get+AF8-dirent() reference lifetime libnvdimm, namespace: record 'lbasize' for pmem namespaces Merge branch 'for-4.13/dax' into libnvdimm-for-next Jerry Hoemann (5): libnvdimm: passthru functions clear to send acpi, nfit: Enable DSM pass thru for root functions. libnvdimm, acpi, nfit: Add bus level dsm mask for pass thru. acpi, nfit: Show bus+AF8-dsm+AF8-mask in sysfs libnvdimm: New ACPI 6.2 DSM functions Toshi Kani (3): libnvdimm, pmem: Add sysfs notifications to badblocks acpi/nfit: Add support of NVDIMM memory error notification in ACPI 6.2 acpi/nfit: Issue Start ARS to retrieve existing records Vishal Verma (4): libnvdimm, btt: BTT updates for UEFI 2.7 format libnvdimm, btt: fix btt+AF8-rw+AF8-page not returning errors libnvdimm: fix the clear-error check in nsio+AF8-rw+AF8-bytes libnvdimm, btt: convert some info messages to warn/err Yasunori Goto (1): tools/testing/nvdimm: fix nfit+AF8-test buffer overflow MAINTAINERS +AHw- 4 +-- arch/powerpc/sysdev/axonram.c +AHw- 8 +-+- arch/x86/Kconfig +AHw- 1 +- arch/x86/include/asm/pmem.h +AHw- 136 ------------------ arch/x86/include/asm/string+AF8-64.h +AHw- 5 +- arch/x86/include/asm/uaccess+AF8-64.h +AHw- 11 +-+- arch/x86/lib/usercopy+AF8-64.c +AHw- 134 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+- arch/x86/mm/pageattr.c +AHw- 6 +- drivers/acpi/nfit/core.c +AHw- 167 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+----- drivers/acpi/nfit/mce.c +AHw- 2 +-- drivers/acpi/nfit/nfit.h +AHw- 4 +-- drivers/block/brd.c +AHw- 8 +-+- drivers/dax/super.c +AHw- 118 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-- drivers/md/dm-linear.c +AHw- 30 +-+-+-+- drivers/md/dm-stripe.c +AHw- 40 +-+-+-+-+-+- drivers/md/dm.c +AHw- 45 +-+-+-+-+-+- drivers/nvdimm/btt.c +AHw- 45 +-+-+-+--- drivers/nvdimm/btt.h +AHw- 2 +- drivers/nvdimm/btt+AF8-devs.c +AHw- 54 +-+-+-+-+-+-+-- drivers/nvdimm/bus.c +AHw- 15 +-- drivers/nvdimm/claim.c +AHw- 38 +-+-+-+-- drivers/nvdimm/core.c +AHw- 5 +-- drivers/nvdimm/dax+AF8-devs.c +AHw- 10 +-- drivers/nvdimm/dimm+AF8-devs.c +AHw- 10 +-- drivers/nvdimm/label.c +AHw- 251 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+----- drivers/nvdimm/label.h +AHw- 21 +-+-- drivers/nvdimm/namespace+AF8-devs.c +AHw- 282 +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+------- drivers/nvdimm/nd-core.h +AHw- 9 +-+- drivers/nvdimm/nd.h +AHw- 17 +-+-- drivers/nvdimm/pfn+AF8-devs.c +AHw- 12 +-- drivers/nvdimm/pmem.c +AHw- 63 +-+-+-+-+-+-+-+-- drivers/nvdimm/pmem.h +AHw- 15 +-+- drivers/nvdimm/region.c +AHw- 17 +-+-- drivers/nvdimm/region+AF8-devs.c +AHw- 88 +-+-+-+-+-+-+-+----- drivers/s390/block/dcssblk.c +AHw- 8 +-+- fs/dax.c +AHw- 9 +-- include/linux/dax.h +AHw- 12 +-+- include/linux/device-mapper.h +AHw- 6 +- include/linux/libnvdimm.h +AHw- 11 +-- include/linux/nd.h +AHw- 13 +-+- include/linux/pmem.h +AHw- 142 ------------------- include/linux/string.h +AHw- 6 +- include/linux/uio.h +AHw- 15 +-+- include/uapi/linux/ndctl.h +AHw- 42 +-+-+-+-+-- lib/Kconfig +AHw- 3 +- lib/iov+AF8-iter.c +AHw- 22 +-+-+- tools/testing/nvdimm/test/nfit.c +AHw- 2 +-- 47 files changed, 1504 insertions(+-), 460 deletions(-) delete mode 100644 arch/x86/include/asm/pmem.h delete mode 100644 include/linux/pmem.h --- commit 0aed55af88345b5d673240f90e671d79662fb01e Author: Dan Williams +ADw-dan.j.williams+AEA-intel.com+AD4- Date: Mon May 29 12:22:50 2017 -0700 x86, uaccess: introduce copy+AF8-from+AF8-iter+AF8-flushcache for pmem / cache-bypass operations The pmem driver has a need to transfer data with a persistent memory destination and be able to rely on the fact that the destination writes are not cached. It is sufficient for the writes to be flushed to a cpu-store-buffer (non-temporal / +ACI-movnt+ACI- in x86 terms), as we expect userspace to call fsync() to ensure data-writes have reached a power-fail-safe zone in the platform. The fsync() triggers a REQ+AF8-FUA or REQ+AF8-FLUSH to the pmem driver which will turn around and fence previous writes with an +ACI-sfence+ACI-. Implement a +AF8AXw-copy+AF8-from+AF8-user+AF8-inatomic+AF8-flushcache, memcpy+AF8-page+AF8-flushcache, and memcpy+AF8-flushcache, that guarantee that the destination buffer is not dirty in the cpu cache on completion. The new copy+AF8-from+AF8-iter+AF8-flushcache and sub-routines will be used to replace the +ACI-pmem api+ACI- (include/linux/pmem.h +- arch/x86/include/asm/pmem.h). The availability of copy+AF8-from+AF8-iter+AF8-flushcache() and memcpy+AF8-flushcache() are gated by the CONFIG+AF8-ARCH+AF8-HAS+AF8-UACCESS+AF8-FLUSHCACHE config symbol, and fallback to copy+AF8-from+AF8-iter+AF8-nocache() and plain memcpy() otherwise. This is meant to satisfy the concern from Linus that if a driver wants to do something beyond the normal nocache semantics it should be something private to that driver +AFs-1+AF0-, and Al's concern that anything uaccess related belongs with the rest of the uaccess code +AFs-2+AF0-. The first consumer of this interface is a new 'copy+AF8-from+AF8-iter' dax operation so that pmem can inject cache maintenance operations without imposing this overhead on other dax-capable drivers. +AFs-1+AF0-: https://lists.01.org/pipermail/linux-nvdimm/2017-January/008364.html +AFs-2+AF0-: https://lists.01.org/pipermail/linux-nvdimm/2017-April/009942.html Cc: +ADw-x86+AEA-kernel.org+AD4- Cc: Jan Kara +ADw-jack+AEA-suse.cz+AD4- Cc: Jeff Moyer +ADw-jmoyer+AEA-redhat.com+AD4- Cc: Ingo Molnar +ADw-mingo+AEA-redhat.com+AD4- Cc: Christoph Hellwig +ADw-hch+AEA-lst.de+AD4- Cc: Toshi Kani +ADw-toshi.kani+AEA-hpe.com+AD4- Cc: +ACI-H. Peter Anvin+ACI- +ADw-hpa+AEA-zytor.com+AD4- Cc: Al Viro +ADw-viro+AEA-zeniv.linux.org.uk+AD4- Cc: Thomas Gleixner +ADw-tglx+AEA-linutronix.de+AD4- Cc: Matthew Wilcox +ADw-mawilcox+AEA-microsoft.com+AD4- Reviewed-by: Ross Zwisler +ADw-ross.zwisler+AEA-linux.intel.com+AD4- Signed-off-by: Dan Williams +ADw-dan.j.williams+AEA-intel.com+AD4- diff --git a/arch/x86/Kconfig b/arch/x86/Kconfig index 4ccfacc7232a..bb273b2f50b5 100644 --- a/arch/x86/Kconfig +-+-+- b/arch/x86/Kconfig +AEAAQA- -54,6 +-54,7 +AEAAQA- config X86 select ARCH+AF8-HAS+AF8-KCOV if X86+AF8-64 select ARCH+AF8-HAS+AF8-MMIO+AF8-FLUSH select ARCH+AF8-HAS+AF8-PMEM+AF8-API if X86+AF8-64 +- select ARCH+AF8-HAS+AF8-UACCESS+AF8-FLUSHCACHE if X86+AF8-64 select ARCH+AF8-HAS+AF8-SET+AF8-MEMORY select ARCH+AF8-HAS+AF8-SG+AF8-CHAIN select ARCH+AF8-HAS+AF8-STRICT+AF8-KERNEL+AF8-RWX diff --git a/arch/x86/include/asm/string+AF8-64.h b/arch/x86/include/asm/string+AF8-64.h index 733bae07fb29..1f22bc277c45 100644 --- a/arch/x86/include/asm/string+AF8-64.h +-+-+- b/arch/x86/include/asm/string+AF8-64.h +AEAAQA- -109,6 +-109,11 +AEAAQA- memcpy+AF8-mcsafe(void +ACo-dst, const void +ACo-src, size+AF8-t cnt) return 0+ADs- +AH0- +-+ACM-ifdef CONFIG+AF8-ARCH+AF8-HAS+AF8-UACCESS+AF8-FLUSHCACHE +-+ACM-define +AF8AXw-HAVE+AF8-ARCH+AF8-MEMCPY+AF8-FLUSHCACHE 1 +-void memcpy+AF8-flushcache(void +ACo-dst, const void +ACo-src, size+AF8-t cnt)+ADs- +-+ACM-endif +- +ACM-endif /+ACo- +AF8AXw-KERNEL+AF8AXw- +ACo-/ +ACM-endif /+ACo- +AF8-ASM+AF8-X86+AF8-STRING+AF8-64+AF8-H +ACo-/ diff --git a/arch/x86/include/asm/uaccess+AF8-64.h b/arch/x86/include/asm/uaccess+AF8-64.h index c5504b9a472e..b16f6a1d8b26 100644 --- a/arch/x86/include/asm/uaccess+AF8-64.h +-+-+- b/arch/x86/include/asm/uaccess+AF8-64.h +AEAAQA- -171,6 +-171,10 +AEAAQA- unsigned long raw+AF8-copy+AF8-in+AF8-user(void +AF8AXw-user +ACo-dst, const void +AF8AXw-user +ACo-src, unsigne extern long +AF8AXw-copy+AF8-user+AF8-nocache(void +ACo-dst, const void +AF8AXw-user +ACo-src, unsigned size, int zerorest)+ADs- +-extern long +AF8AXw-copy+AF8-user+AF8-flushcache(void +ACo-dst, const void +AF8AXw-user +ACo-src, unsigned size)+ADs- +-extern void memcpy+AF8-page+AF8-flushcache(char +ACo-to, struct page +ACo-page, size+AF8-t offset, +- size+AF8-t len)+ADs- +- static inline int +AF8AXw-copy+AF8-from+AF8-user+AF8-inatomic+AF8-nocache(void +ACo-dst, const void +AF8AXw-user +ACo-src, unsigned size) +AEAAQA- -179,6 +-183,13 +AEAAQA- +AF8AXw-copy+AF8-from+AF8-user+AF8-inatomic+AF8-nocache(void +ACo-dst, const void +AF8AXw-user +ACo-src, return +AF8AXw-copy+AF8-user+AF8-nocache(dst, src, size, 0)+ADs- +AH0- +-static inline int +-+AF8AXw-copy+AF8-from+AF8-user+AF8-flushcache(void +ACo-dst, const void +AF8AXw-user +ACo-src, unsigned size) +-+AHs- +- kasan+AF8-check+AF8-write(dst, size)+ADs- +- return +AF8AXw-copy+AF8-user+AF8-flushcache(dst, src, size)+ADs- +-+AH0- +- unsigned long copy+AF8-user+AF8-handle+AF8-tail(char +ACo-to, char +ACo-from, unsigned len)+ADs- diff --git a/arch/x86/lib/usercopy+AF8-64.c b/arch/x86/lib/usercopy+AF8-64.c index 3b7c40a2e3e1..f42d2fd86ca3 100644 --- a/arch/x86/lib/usercopy+AF8-64.c +-+-+- b/arch/x86/lib/usercopy+AF8-64.c +AEAAQA- -7,6 +-7,7 +AEAAQA- +ACo-/ +ACM-include +ADw-linux/export.h+AD4- +ACM-include +ADw-linux/uaccess.h+AD4- +-+ACM-include +ADw-linux/highmem.h+AD4- /+ACo- +ACo- Zero Userspace +AEAAQA- -73,3 +-74,130 +AEAAQA- copy+AF8-user+AF8-handle+AF8-tail(char +ACo-to, char +ACo-from, unsigned len) clac()+ADs- return len+ADs- +AH0- +- +-+ACM-ifdef CONFIG+AF8-ARCH+AF8-HAS+AF8-UACCESS+AF8-FLUSHCACHE +-/+ACoAKg- +- +ACo- clean+AF8-cache+AF8-range - write back a cache range with CLWB +- +ACo- +AEA-vaddr: virtual start address +- +ACo- +AEA-size: number of bytes to write back +- +ACo- +- +ACo- Write back a cache range using the CLWB (cache line write back) +- +ACo- instruction. Note that +AEA-size is internally rounded up to be cache +- +ACo- line size aligned. +- +ACo-/ +-static void clean+AF8-cache+AF8-range(void +ACo-addr, size+AF8-t size) +-+AHs- +- u16 x86+AF8-clflush+AF8-size +AD0- boot+AF8-cpu+AF8-data.x86+AF8-clflush+AF8-size+ADs- +- unsigned long clflush+AF8-mask +AD0- x86+AF8-clflush+AF8-size - 1+ADs- +- void +ACo-vend +AD0- addr +- size+ADs- +- void +ACo-p+ADs- +- +- for (p +AD0- (void +ACo-)((unsigned long)addr +ACY- +AH4-clflush+AF8-mask)+ADs- +- p +ADw- vend+ADs- p +-+AD0- x86+AF8-clflush+AF8-size) +- clwb(p)+ADs- +-+AH0- +- +-long +AF8AXw-copy+AF8-user+AF8-flushcache(void +ACo-dst, const void +AF8AXw-user +ACo-src, unsigned size) +-+AHs- +- unsigned long flushed, dest +AD0- (unsigned long) dst+ADs- +- long rc +AD0- +AF8AXw-copy+AF8-user+AF8-nocache(dst, src, size, 0)+ADs- +- +- /+ACo- +- +ACo- +AF8AXw-copy+AF8-user+AF8-nocache() uses non-temporal stores for the bulk +- +ACo- of the transfer, but we need to manually flush if the +- +ACo- transfer is unaligned. A cached memory copy is used when +- +ACo- destination or size is not naturally aligned. That is: +- +ACo- - Require 8-byte alignment when size is 8 bytes or larger. +- +ACo- - Require 4-byte alignment when size is 4 bytes. +- +ACo-/ +- if (size +ADw- 8) +AHs- +- if (+ACE-IS+AF8-ALIGNED(dest, 4) +AHwAfA- size +ACEAPQ- 4) +- clean+AF8-cache+AF8-range(dst, 1)+ADs- +- +AH0- else +AHs- +- if (+ACE-IS+AF8-ALIGNED(dest, 8)) +AHs- +- dest +AD0- ALIGN(dest, boot+AF8-cpu+AF8-data.x86+AF8-clflush+AF8-size)+ADs- +- clean+AF8-cache+AF8-range(dst, 1)+ADs- +- +AH0- +- +- flushed +AD0- dest - (unsigned long) dst+ADs- +- if (size +AD4- flushed +ACYAJg- +ACE-IS+AF8-ALIGNED(size - flushed, 8)) +- clean+AF8-cache+AF8-range(dst +- size - 1, 1)+ADs- +- +AH0- +- +- return rc+ADs- +-+AH0- +- +-void memcpy+AF8-flushcache(void +ACoAXw-dst, const void +ACoAXw-src, size+AF8-t size) +-+AHs- +- unsigned long dest +AD0- (unsigned long) +AF8-dst+ADs- +- unsigned long source +AD0- (unsigned long) +AF8-src+ADs- +- +- /+ACo- cache copy and flush to align dest +ACo-/ +- if (+ACE-IS+AF8-ALIGNED(dest, 8)) +AHs- +- unsigned len +AD0- min+AF8-t(unsigned, size, ALIGN(dest, 8) - dest)+ADs- +- +- memcpy((void +ACo-) dest, (void +ACo-) source, len)+ADs- +- clean+AF8-cache+AF8-range((void +ACo-) dest, len)+ADs- +- dest +-+AD0- len+ADs- +- source +-+AD0- len+ADs- +- size -+AD0- len+ADs- +- if (+ACE-size) +- return+ADs- +- +AH0- +- +- /+ACo- 4x8 movnti loop +ACo-/ +- while (size +AD4APQ- 32) +AHs- +- asm(+ACI-movq (+ACU-0), +ACUAJQ-r8+AFw-n+ACI- +- +ACI-movq 8(+ACU-0), +ACUAJQ-r9+AFw-n+ACI- +- +ACI-movq 16(+ACU-0), +ACUAJQ-r10+AFw-n+ACI- +- +ACI-movq 24(+ACU-0), +ACUAJQ-r11+AFw-n+ACI- +- +ACI-movnti +ACUAJQ-r8, (+ACU-1)+AFw-n+ACI- +- +ACI-movnti +ACUAJQ-r9, 8(+ACU-1)+AFw-n+ACI- +- +ACI-movnti +ACUAJQ-r10, 16(+ACU-1)+AFw-n+ACI- +- +ACI-movnti +ACUAJQ-r11, 24(+ACU-1)+AFw-n+ACI- +- :: +ACI-r+ACI- (source), +ACI-r+ACI- (dest) +- : +ACI-memory+ACI-, +ACI-r8+ACI-, +ACI-r9+ACI-, +ACI-r10+ACI-, +ACI-r11+ACI-)+ADs- +- dest +-+AD0- 32+ADs- +- source +-+AD0- 32+ADs- +- size -+AD0- 32+ADs- +- +AH0- +- +- /+ACo- 1x8 movnti loop +ACo-/ +- while (size +AD4APQ- 8) +AHs- +- asm(+ACI-movq (+ACU-0), +ACUAJQ-r8+AFw-n+ACI- +- +ACI-movnti +ACUAJQ-r8, (+ACU-1)+AFw-n+ACI- +- :: +ACI-r+ACI- (source), +ACI-r+ACI- (dest) +- : +ACI-memory+ACI-, +ACI-r8+ACI-)+ADs- +- dest +-+AD0- 8+ADs- +- source +-+AD0- 8+ADs- +- size -+AD0- 8+ADs- +- +AH0- +- +- /+ACo- 1x4 movnti loop +ACo-/ +- while (size +AD4APQ- 4) +AHs- +- asm(+ACI-movl (+ACU-0), +ACUAJQ-r8d+AFw-n+ACI- +- +ACI-movnti +ACUAJQ-r8d, (+ACU-1)+AFw-n+ACI- +- :: +ACI-r+ACI- (source), +ACI-r+ACI- (dest) +- : +ACI-memory+ACI-, +ACI-r8+ACI-)+ADs- +- dest +-+AD0- 4+ADs- +- source +-+AD0- 4+ADs- +- size -+AD0- 4+ADs- +- +AH0- +- +- /+ACo- cache copy for remaining bytes +ACo-/ +- if (size) +AHs- +- memcpy((void +ACo-) dest, (void +ACo-) source, size)+ADs- +- clean+AF8-cache+AF8-range((void +ACo-) dest, size)+ADs- +- +AH0- +-+AH0- +-EXPORT+AF8-SYMBOL+AF8-GPL(memcpy+AF8-flushcache)+ADs- +- +-void memcpy+AF8-page+AF8-flushcache(char +ACo-to, struct page +ACo-page, size+AF8-t offset, +- size+AF8-t len) +-+AHs- +- char +ACo-from +AD0- kmap+AF8-atomic(page)+ADs- +- +- memcpy+AF8-flushcache(to, from +- offset, len)+ADs- +- kunmap+AF8-atomic(from)+ADs- +-+AH0- +-+ACM-endif diff --git a/drivers/acpi/nfit/core.c b/drivers/acpi/nfit/core.c index 656acb5d7166..cbd5596e7562 100644 --- a/drivers/acpi/nfit/core.c +-+-+- b/drivers/acpi/nfit/core.c +AEAAQA- -1842,8 +-1842,7 +AEAAQA- static int acpi+AF8-nfit+AF8-blk+AF8-single+AF8-io(struct nfit+AF8-blk +ACo-nfit+AF8-blk, +AH0- if (rw) - memcpy+AF8-to+AF8-pmem(mmio-+AD4-addr.aperture +- offset, - iobuf +- copied, c)+ADs- +- memcpy+AF8-flushcache(mmio-+AD4-addr.aperture +- offset, iobuf +- copied, c)+ADs- else +AHs- if (nfit+AF8-blk-+AD4-dimm+AF8-flags +ACY- NFIT+AF8-BLK+AF8-READ+AF8-FLUSH) mmio+AF8-flush+AF8-range((void +AF8AXw-force +ACo-) diff --git a/drivers/nvdimm/claim.c b/drivers/nvdimm/claim.c index 7ceb5fa4f2a1..b8b9c8ca7862 100644 --- a/drivers/nvdimm/claim.c +-+-+- b/drivers/nvdimm/claim.c +AEAAQA- -277,7 +-277,7 +AEAAQA- static int nsio+AF8-rw+AF8-bytes(struct nd+AF8-namespace+AF8-common +ACo-ndns, rc +AD0- -EIO+ADs- +AH0- - memcpy+AF8-to+AF8-pmem(nsio-+AD4-addr +- offset, buf, size)+ADs- +- memcpy+AF8-flushcache(nsio-+AD4-addr +- offset, buf, size)+ADs- nvdimm+AF8-flush(to+AF8-nd+AF8-region(ndns-+AD4-dev.parent))+ADs- return rc+ADs- diff --git a/drivers/nvdimm/pmem.c b/drivers/nvdimm/pmem.c index c544d466ea51..2f3aefe565c6 100644 --- a/drivers/nvdimm/pmem.c +-+-+- b/drivers/nvdimm/pmem.c +AEAAQA- -29,6 +-29,7 +AEAAQA- +ACM-include +ADw-linux/pfn+AF8-t.h+AD4- +ACM-include +ADw-linux/slab.h+AD4- +ACM-include +ADw-linux/pmem.h+AD4- +-+ACM-include +ADw-linux/uio.h+AD4- +ACM-include +ADw-linux/dax.h+AD4- +ACM-include +ADw-linux/nd.h+AD4- +ACM-include +ACI-pmem.h+ACI- +AEAAQA- -80,7 +-81,7 +AEAAQA- static void write+AF8-pmem(void +ACo-pmem+AF8-addr, struct page +ACo-page, +AHs- void +ACo-mem +AD0- kmap+AF8-atomic(page)+ADs- - memcpy+AF8-to+AF8-pmem(pmem+AF8-addr, mem +- off, len)+ADs- +- memcpy+AF8-flushcache(pmem+AF8-addr, mem +- off, len)+ADs- kunmap+AF8-atomic(mem)+ADs- +AH0- +AEAAQA- -235,8 +-236,15 +AEAAQA- static long pmem+AF8-dax+AF8-direct+AF8-access(struct dax+AF8-device +ACo-dax+AF8-dev, return +AF8AXw-pmem+AF8-direct+AF8-access(pmem, pgoff, nr+AF8-pages, kaddr, pfn)+ADs- +AH0- +-static size+AF8-t pmem+AF8-copy+AF8-from+AF8-iter(struct dax+AF8-device +ACo-dax+AF8-dev, pgoff+AF8-t pgoff, +- void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i) +-+AHs- +- return copy+AF8-from+AF8-iter+AF8-flushcache(addr, bytes, i)+ADs- +-+AH0- +- static const struct dax+AF8-operations pmem+AF8-dax+AF8-ops +AD0- +AHs- .direct+AF8-access +AD0- pmem+AF8-dax+AF8-direct+AF8-access, +- .copy+AF8-from+AF8-iter +AD0- pmem+AF8-copy+AF8-from+AF8-iter, +AH0AOw- static void pmem+AF8-release+AF8-queue(void +ACo-q) +AEAAQA- -294,7 +-302,8 +AEAAQA- static int pmem+AF8-attach+AF8-disk(struct device +ACo-dev, dev+AF8-set+AF8-drvdata(dev, pmem)+ADs- pmem-+AD4-phys+AF8-addr +AD0- res-+AD4-start+ADs- pmem-+AD4-size +AD0- resource+AF8-size(res)+ADs- - if (nvdimm+AF8-has+AF8-flush(nd+AF8-region) +ADw- 0) +- if (+ACE-IS+AF8-ENABLED(CONFIG+AF8-ARCH+AF8-HAS+AF8-UACCESS+AF8-FLUSHCACHE) +- +AHwAfA- nvdimm+AF8-has+AF8-flush(nd+AF8-region) +ADw- 0) dev+AF8-warn(dev, +ACI-unable to guarantee persistence of writes+AFw-n+ACI-)+ADs- if (+ACE-devm+AF8-request+AF8-mem+AF8-region(dev, res-+AD4-start, resource+AF8-size(res), diff --git a/drivers/nvdimm/region+AF8-devs.c b/drivers/nvdimm/region+AF8-devs.c index b550edf2571f..985b0e11bd73 100644 --- a/drivers/nvdimm/region+AF8-devs.c +-+-+- b/drivers/nvdimm/region+AF8-devs.c +AEAAQA- -1015,8 +-1015,8 +AEAAQA- void nvdimm+AF8-flush(struct nd+AF8-region +ACo-nd+AF8-region) +ACo- The first wmb() is needed to 'sfence' all previous writes +ACo- such that they are architecturally visible for the platform +ACo- buffer flush. Note that we've already arranged for pmem - +ACo- writes to avoid the cache via arch+AF8-memcpy+AF8-to+AF8-pmem(). The - +ACo- final wmb() ensures ordering for the NVDIMM flush write. +- +ACo- writes to avoid the cache via memcpy+AF8-flushcache(). The final +- +ACo- wmb() ensures ordering for the NVDIMM flush write. +ACo-/ wmb()+ADs- for (i +AD0- 0+ADs- i +ADw- nd+AF8-region-+AD4-ndr+AF8-mappings+ADs- i+-+-) diff --git a/include/linux/dax.h b/include/linux/dax.h index 5ec1f6c47716..bbe79ed90e2b 100644 --- a/include/linux/dax.h +-+-+- b/include/linux/dax.h +AEAAQA- -16,6 +-16,9 +AEAAQA- struct dax+AF8-operations +AHs- +ACo-/ long (+ACo-direct+AF8-access)(struct dax+AF8-device +ACo-, pgoff+AF8-t, long, void +ACoAKg-, pfn+AF8-t +ACo-)+ADs- +- /+ACo- copy+AF8-from+AF8-iter: dax-driver override for default copy+AF8-from+AF8-iter +ACo-/ +- size+AF8-t (+ACo-copy+AF8-from+AF8-iter)(struct dax+AF8-device +ACo-, pgoff+AF8-t, void +ACo-, size+AF8-t, +- struct iov+AF8-iter +ACo-)+ADs- +AH0AOw- +ACM-if IS+AF8-ENABLED(CONFIG+AF8-DAX) diff --git a/include/linux/string.h b/include/linux/string.h index 537918f8a98e..7439d83eaa33 100644 --- a/include/linux/string.h +-+-+- b/include/linux/string.h +AEAAQA- -122,6 +-122,12 +AEAAQA- static inline +AF8AXw-must+AF8-check int memcpy+AF8-mcsafe(void +ACo-dst, const void +ACo-src, return 0+ADs- +AH0- +ACM-endif +-+ACM-ifndef +AF8AXw-HAVE+AF8-ARCH+AF8-MEMCPY+AF8-FLUSHCACHE +-static inline void memcpy+AF8-flushcache(void +ACo-dst, const void +ACo-src, size+AF8-t cnt) +-+AHs- +- memcpy(dst, src, cnt)+ADs- +-+AH0- +-+ACM-endif void +ACo-memchr+AF8-inv(const void +ACo-s, int c, size+AF8-t n)+ADs- char +ACo-strreplace(char +ACo-s, char old, char new)+ADs- diff --git a/include/linux/uio.h b/include/linux/uio.h index f2d36a3d3005..55cd54a0e941 100644 --- a/include/linux/uio.h +-+-+- b/include/linux/uio.h +AEAAQA- -95,6 +-95,21 +AEAAQA- size+AF8-t copy+AF8-to+AF8-iter(const void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i)+ADs- size+AF8-t copy+AF8-from+AF8-iter(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i)+ADs- bool copy+AF8-from+AF8-iter+AF8-full(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i)+ADs- size+AF8-t copy+AF8-from+AF8-iter+AF8-nocache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i)+ADs- +-+ACM-ifdef CONFIG+AF8-ARCH+AF8-HAS+AF8-UACCESS+AF8-FLUSHCACHE +-/+ACo- +- +ACo- Note, users like pmem that depend on the stricter semantics of +- +ACo- copy+AF8-from+AF8-iter+AF8-flushcache() than copy+AF8-from+AF8-iter+AF8-nocache() must check for +- +ACo- IS+AF8-ENABLED(CONFIG+AF8-ARCH+AF8-HAS+AF8-UACCESS+AF8-FLUSHCACHE) before assuming that the +- +ACo- destination is flushed from the cache on return. +- +ACo-/ +-size+AF8-t copy+AF8-from+AF8-iter+AF8-flushcache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i)+ADs- +-+ACM-else +-static inline size+AF8-t copy+AF8-from+AF8-iter+AF8-flushcache(void +ACo-addr, size+AF8-t bytes, +- struct iov+AF8-iter +ACo-i) +-+AHs- +- return copy+AF8-from+AF8-iter+AF8-nocache(addr, bytes, i)+ADs- +-+AH0- +-+ACM-endif bool copy+AF8-from+AF8-iter+AF8-full+AF8-nocache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i)+ADs- size+AF8-t iov+AF8-iter+AF8-zero(size+AF8-t bytes, struct iov+AF8-iter +ACo-)+ADs- unsigned long iov+AF8-iter+AF8-alignment(const struct iov+AF8-iter +ACo-i)+ADs- diff --git a/lib/Kconfig b/lib/Kconfig index 0c8b78a9ae2e..2d1c4b3a085c 100644 --- a/lib/Kconfig +-+-+- b/lib/Kconfig +AEAAQA- -548,6 +-548,9 +AEAAQA- config ARCH+AF8-HAS+AF8-SG+AF8-CHAIN config ARCH+AF8-HAS+AF8-PMEM+AF8-API bool +-config ARCH+AF8-HAS+AF8-UACCESS+AF8-FLUSHCACHE +- bool +- config ARCH+AF8-HAS+AF8-MMIO+AF8-FLUSH bool diff --git a/lib/iov+AF8-iter.c b/lib/iov+AF8-iter.c index f835964c9485..c9a69064462f 100644 --- a/lib/iov+AF8-iter.c +-+-+- b/lib/iov+AF8-iter.c +AEAAQA- -615,6 +-615,28 +AEAAQA- size+AF8-t copy+AF8-from+AF8-iter+AF8-nocache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i) +AH0- EXPORT+AF8-SYMBOL(copy+AF8-from+AF8-iter+AF8-nocache)+ADs- +-+ACM-ifdef CONFIG+AF8-ARCH+AF8-HAS+AF8-UACCESS+AF8-FLUSHCACHE +-size+AF8-t copy+AF8-from+AF8-iter+AF8-flushcache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i) +-+AHs- +- char +ACo-to +AD0- addr+ADs- +- if (unlikely(i-+AD4-type +ACY- ITER+AF8-PIPE)) +AHs- +- WARN+AF8-ON(1)+ADs- +- return 0+ADs- +- +AH0- +- iterate+AF8-and+AF8-advance(i, bytes, v, +- +AF8AXw-copy+AF8-from+AF8-user+AF8-flushcache((to +-+AD0- v.iov+AF8-len) - v.iov+AF8-len, +- v.iov+AF8-base, v.iov+AF8-len), +- memcpy+AF8-page+AF8-flushcache((to +-+AD0- v.bv+AF8-len) - v.bv+AF8-len, v.bv+AF8-page, +- v.bv+AF8-offset, v.bv+AF8-len), +- memcpy+AF8-flushcache((to +-+AD0- v.iov+AF8-len) - v.iov+AF8-len, v.iov+AF8-base, +- v.iov+AF8-len) +- ) +- +- return bytes+ADs- +-+AH0- +-EXPORT+AF8-SYMBOL+AF8-GPL(copy+AF8-from+AF8-iter+AF8-flushcache)+ADs- +-+ACM-endif +- bool copy+AF8-from+AF8-iter+AF8-full+AF8-nocache(void +ACo-addr, size+AF8-t bytes, struct iov+AF8-iter +ACo-i) +AHs- char +ACo-to +AD0- addr+ADs- From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: from mga07.intel.com (mga07.intel.com [134.134.136.100]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ml01.01.org (Postfix) with ESMTPS id 0486421CE740B for ; Thu, 6 Jul 2017 17:21:00 -0700 (PDT) From: "Williams, Dan J" Subject: [GIT PULL] libnvdimm for 4.13 Date: Fri, 7 Jul 2017 00:22:38 +0000 Message-ID: <1499386957.6081.29.camel@intel.com> Content-Language: en-US Content-ID: <50E9FF9960AEA045A79246ECFBE9C8CB@intel.com> MIME-Version: 1.0 List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Content-Type: text/plain; charset="utf-7" Content-Transfer-Encoding: base64 Errors-To: linux-nvdimm-bounces@lists.01.org Sender: "Linux-nvdimm" To: "torvalds@linux-foundation.org" Cc: "linux-nvdimm@lists.01.org" , "x86@kernel.org" , "linux-kernel@vger.kernel.org" , "linux-block@vger.kernel.org" , "viro@zeniv.linux.org.uk" , "linux-fsdevel@vger.kernel.org" List-ID: SGkgTGludXMsIHBsZWFzZSBwdWxsIGZyb206CgogIGdpdDovL2dpdC5rZXJuZWwub3JnL3B1Yi9z Y20vbGludXgva2VybmVsL2dpdC9udmRpbW0vbnZkaW1tIHRhZ3MvbGlibnZkaW1tLWZvci00LjEz Cgp0byByZWNlaXZlLCBsaWJudmRpbW0gdXBkYXRlcyBmb3IgdGhlIGxhdGVzdCBBQ1BJIGFuZCBV RUZJCnNwZWNpZmljYXRpb25zLiBUaGlzIHB1bGwgcmVxdWVzdCBhbHNvIGluY2x1ZGVzIG5ldyAn c3RydWN0CmRheF9vcGVyYXRpb25zJyBlbmFibGluZyB0byB1bmRvIHRoZSBhYnVzZSBbMV0gb2Yg Y29weV91c2VyX25vY2FjaGUoKQpmb3IgY29weSBvcGVyYXRpb25zIHRvIHBtZW0uIFRoZSBkYXgg d29yayBvcmlnaW5hbGx5IG1pc3NlZCA0LjEyIHRvCmFkZHJlc3MgY29uY2VybnMgcmFpc2VkIGJ5 IEFsLgoKWzFdOiBodHRwczovL2xpc3RzLjAxLm9yZy9waXBlcm1haWwvbGludXgtbnZkaW1tLzIw MTctSmFudWFyeS8wMDgzNjQuaHRtbAoKQWxsIG9mIHRoZSBjb21taXRzIGluIHRoaXMgcHVsbCBy ZXF1ZXN0IGhhdmUgYXBwZWFyZWQgaW4gb25lIG9yIG1vcmUKLW5leHQgcmVsZWFzZXMgd2l0aCBu byBlcnJvcnMgcmVwb3J0ZWQsIGhvd2V2ZXIsIFN0ZXBoZW4gZGlkIHJlcG9ydCBhCmxhdGUgbWVy Z2UgY29uZmxpY3QgYmV0d2VlbiBudmRpbW0uZ2l0IGFuZCB0aGUgdmZzLmdpdCB0cmVlLiBTdGVw aGVuJ3MKbWVyZ2UgcmVzb2x1dGlvbiBpcyBoZXJlOitBS0EtaHR0cDovL21hcmMuaW5mby8/bD1s aW51eC1rZXJuZWwmbT0xNDk5MDY0MTE1CjA3MzAxJnc9MiwgYnV0IHRvIG1hdGNoIEFsJ3MgY2hh bmdlcyB3ZSBhcHBlYXIgdG8gYWxzbyBuZWVkIHRoZQppbmNyZW1lbnRhbCBjaGFuZ2UgYmVsb3cu CgpQbGVhc2UgcHVsbCwgSSBiZWxpZXZlIGFueSBzdHJhZ2dsaW5nIF9mbHVzaGNhY2hlKCkgZmVl ZGJhY2sgYXQgdGhpcwpwb2ludCBjYW4gYmUgZml4ZWQgdXAgcG9zdCAtcmMxLiBJIGluY2x1ZGUg Y29tbWl0IDBhZWQ1NWFmODgzNCAieDg2LAp1YWNjZXNzOiBpbnRyb2R1Y2UgY29weV9mcm9tX2l0 ZXJfZmx1c2hjYWNoZSBmb3IgcG1lbSAvIGNhY2hlLWJ5cGFzcwpvcGVyYXRpb25zIiBhdCB0aGUg ZW5kIG9mIHRoaXMgbWVzc2FnZSBmb3IgcmVmZXJlbmNlLgoKLS0tCgpkaWZmIC0tZ2l0IGEvaW5j bHVkZS9saW51eC91aW8uaCBiL2luY2x1ZGUvbGludXgvdWlvLmgKaW5kZXggMmY0NmY4ZDRiNTA4 Li4wNzNiYjFmZWIwZDAgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvdWlvLmgKKy0rLSstIGIv aW5jbHVkZS9saW51eC91aW8uaApAQCAtOTcsNiArLTk3LDcgQEAgc2l6ZV90IF9jb3B5X3RvX2l0 ZXIoY29uc3Qgdm9pZCAqYWRkciwgc2l6ZV90IGJ5dGVzLCBzdHJ1Y3QgaW92X2l0ZXIgKmkpOwog c2l6ZV90IF9jb3B5X2Zyb21faXRlcih2b2lkICphZGRyLCBzaXplX3QgYnl0ZXMsIHN0cnVjdCBp b3ZfaXRlciAqaSk7CiBib29sIF9jb3B5X2Zyb21faXRlcl9mdWxsKHZvaWQgKmFkZHIsIHNpemVf dCBieXRlcywgc3RydWN0IGlvdl9pdGVyICppKTsKIHNpemVfdCBfY29weV9mcm9tX2l0ZXJfbm9j YWNoZSh2b2lkICphZGRyLCBzaXplX3QgYnl0ZXMsIHN0cnVjdCBpb3ZfaXRlciAqaSk7Cistc2l6 ZV90IF9jb3B5X2Zyb21faXRlcl9mbHVzaGNhY2hlKHZvaWQgKmFkZHIsIHNpemVfdCBieXRlcywg c3RydWN0IGlvdl9pdGVyICppKTsKIGJvb2wgX2NvcHlfZnJvbV9pdGVyX2Z1bGxfbm9jYWNoZSh2 b2lkICphZGRyLCBzaXplX3QgYnl0ZXMsIHN0cnVjdCBpb3ZfaXRlciAqaSk7CiAKIHN0YXRpYyBf X2Fsd2F5c19pbmxpbmUgX19tdXN0X2NoZWNrCkBAIC0xNTEsNyArLTE1MiwxNCBAQCBib29sIGNv cHlfZnJvbV9pdGVyX2Z1bGxfbm9jYWNoZSh2b2lkICphZGRyLCBzaXplX3QgYnl0ZXMsIHN0cnVj dCBpb3ZfaXRlciAqaSkKICAqIElTX0VOQUJMRUQoQ09ORklHX0FSQ0hfSEFTX1VBQ0NFU1NfRkxV U0hDQUNIRSkgYmVmb3JlIGFzc3VtaW5nIHRoYXQgdGhlCiAgKiBkZXN0aW5hdGlvbiBpcyBmbHVz aGVkIGZyb20gdGhlIGNhY2hlIG9uIHJldHVybi4KICAqLwotc2l6ZV90IGNvcHlfZnJvbV9pdGVy X2ZsdXNoY2FjaGUodm9pZCAqYWRkciwgc2l6ZV90IGJ5dGVzLCBzdHJ1Y3QgaW92X2l0ZXIgKmkp OworLXN0YXRpYyBfX2Fsd2F5c19pbmxpbmUgX19tdXN0X2NoZWNrCistc2l6ZV90IGNvcHlfZnJv bV9pdGVyX2ZsdXNoY2FjaGUodm9pZCAqYWRkciwgc2l6ZV90IGJ5dGVzLCBzdHJ1Y3QgaW92X2l0 ZXIgKmkpCisteworLQlpZiAodW5saWtlbHkoIWNoZWNrX2NvcHlfc2l6ZShhZGRyLCBieXRlcywg ZmFsc2UpKSkKKy0JCXJldHVybiBieXRlczsKKy0JZWxzZQorLQkJcmV0dXJuIF9jb3B5X2Zyb21f aXRlcl9mbHVzaGNhY2hlKGFkZHIsIGJ5dGVzLCBpKTsKKy19CiAjZWxzZQogc3RhdGljIGlubGlu ZSBzaXplX3QgY29weV9mcm9tX2l0ZXJfZmx1c2hjYWNoZSh2b2lkICphZGRyLCBzaXplX3QgYnl0 ZXMsCiAJCQkJICAgICAgIHN0cnVjdCBpb3ZfaXRlciAqaSkKZGlmZiAtLWdpdCBhL2xpYi9pb3Zf aXRlci5jIGIvbGliL2lvdl9pdGVyLmMKaW5kZXggZWU4MjMwMGQ5OGI5Li4wZDE4ZWRlNTZhMzYg MTAwNjQ0Ci0tLSBhL2xpYi9pb3ZfaXRlci5jCistKy0rLSBiL2xpYi9pb3ZfaXRlci5jCkBAIC02 NDIsNyArLTY0Miw3IEBAIHNpemVfdCBfY29weV9mcm9tX2l0ZXJfbm9jYWNoZSh2b2lkICphZGRy LCBzaXplX3QgYnl0ZXMsIHN0cnVjdCBpb3ZfaXRlciAqaSkKIEVYUE9SVF9TWU1CT0woX2NvcHlf ZnJvbV9pdGVyX25vY2FjaGUpOwogCiAjaWZkZWYgQ09ORklHX0FSQ0hfSEFTX1VBQ0NFU1NfRkxV U0hDQUNIRQotc2l6ZV90IGNvcHlfZnJvbV9pdGVyX2ZsdXNoY2FjaGUodm9pZCAqYWRkciwgc2l6 ZV90IGJ5dGVzLCBzdHJ1Y3QgaW92X2l0ZXIgKmkpCistc2l6ZV90IF9jb3B5X2Zyb21faXRlcl9m bHVzaGNhY2hlKHZvaWQgKmFkZHIsIHNpemVfdCBieXRlcywgc3RydWN0IGlvdl9pdGVyICppKQog ewogCWNoYXIgKnRvID0gYWRkcjsKIAlpZiAodW5saWtlbHkoaS0+dHlwZSAmIElURVJfUElQRSkp IHsKQEAgLTY2MCw3ICstNjYwLDcgQEAgc2l6ZV90IGNvcHlfZnJvbV9pdGVyX2ZsdXNoY2FjaGUo dm9pZCAqYWRkciwgc2l6ZV90IGJ5dGVzLCBzdHJ1Y3QgaW92X2l0ZXIgKmkpCiAKIAlyZXR1cm4g Ynl0ZXM7CiB9Ci1FWFBPUlRfU1lNQk9MX0dQTChjb3B5X2Zyb21faXRlcl9mbHVzaGNhY2hlKTsK Ky1FWFBPUlRfU1lNQk9MX0dQTChfY29weV9mcm9tX2l0ZXJfZmx1c2hjYWNoZSk7CiAjZW5kaWYK IAogYm9vbCBfY29weV9mcm9tX2l0ZXJfZnVsbF9ub2NhY2hlKHZvaWQgKmFkZHIsIHNpemVfdCBi eXRlcywgc3RydWN0IGlvdl9pdGVyICppKQoKLS0tCgpUaGUgZm9sbG93aW5nIGNoYW5nZXMgc2lu Y2UgY29tbWl0IDg3MDg1ZmYyZTkwZWNmYTkxZjhiYjBjYjBjZTE5ZWE2NjFiZDZmODM6CgogIHRo ZXJtYWw6IGludDM0MHhfdGhlcm1hbDogZml4IGNvbXBpbGUgYWZ0ZXIgdGhlIFVVSUQgQVBJIHN3 aXRjaCAoMjAxNy0wNi0wOSAxNjozNzozMSArLTAyMDApCgphcmUgYXZhaWxhYmxlIGluIHRoZSBn aXQgcmVwb3NpdG9yeSBhdDoKCiAgZ2l0Oi8vZ2l0Lmtlcm5lbC5vcmcvcHViL3NjbS9saW51eC9r ZXJuZWwvZ2l0L252ZGltbS9udmRpbW0gdGFncy9saWJudmRpbW0tZm9yLTQuMTMKCmZvciB5b3Ug dG8gZmV0Y2ggY2hhbmdlcyB1cCB0byA5ZDkyNTczZmZmM2VjNzA3ODVlZjE4MTVjYzgwNTczZjcw ZTdhOTIxOgoKICBNZXJnZSBicmFuY2ggJ2Zvci00LjEzL2RheCcgaW50byBsaWJudmRpbW0tZm9y LW5leHQgKDIwMTctMDctMDMgMTY6NTQ6NTggLTA3MDApCgotLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCmxpYm52ZGltbSBmb3Ig NC4xMwoKKiBJbnRyb2R1Y2UgdGhlIF9mbHVzaGNhY2hlKCkgZmFtaWx5IG9mIG1lbW9yeSBjb3B5 IGhlbHBlcnMgYW5kIHVzZSB0aGVtCiAgZm9yIHBlcnNpc3RlbnQgbWVtb3J5IHdyaXRlIG9wZXJh dGlvbnMgb24geDg2LiBUaGUgX2ZsdXNoY2FjaGUoKQogIHNlbWFudGljIGluZGljYXRlcyB0aGF0 IHRoZSBjYWNoZSBpcyBlaXRoZXIgYnlwYXNzZWQgZm9yIHRoZSBjb3B5CiAgb3BlcmF0aW9uICht b3ZudCkgb3IgYW55IGxpbmVzIGRpcnRpZWQgYnkgdGhlIGNvcHkgb3BlcmF0aW9uIGFyZQogIHdy aXR0ZW4gYmFjayAoY2x3YiwgY2xmbHVzaG9wdCwgb3IgY2xmbHVzaCkuCgoqIEV4dGVuZCBkYXhf b3BlcmF0aW9ucyB3aXRoIC0+Y29weV9mcm9tX2l0ZXIoKSBhbmQgLT5mbHVzaCgpCiAgb3BlcmF0 aW9ucy4gVGhlc2Ugb3BlcmF0aW9ucyBhbmQgb3RoZXIgaW5mcmFzdHJ1Y3R1cmUgdXBkYXRlcyBh bGxvdwogIGFsbCBwZXJzaXN0ZW50IG1lbW9yeSBzcGVjaWZpYyBkYXggZnVuY3Rpb25hbGl0eSB0 byBiZSBwdXNoZWQgaW50bwogIGxpYm52ZGltbSBhbmQgdGhlIHBtZW0gZHJpdmVyIGRpcmVjdGx5 LiBJdCBhbHNvIGFsbG93cyBkYXgtc3BlY2lmaWMKICBzeXNmcyBhdHRyaWJ1dGVzIHRvIGJlIGxp bmtlZCB0byBhIGhvc3QgZGV2aWNlLCBmb3IgZXhhbXBsZToKICAgICAgL3N5cy9ibG9jay9wbWVt MC9kYXgvd3JpdGVfY2FjaGUKCiogQWRkIHN1cHBvcnQgZm9yIHRoZSBuZXcgTlZESU1NIHBsYXRm b3JtL2Zpcm13YXJlIG1lY2hhbmlzbXMgaW50cm9kdWNlZAogIGluIEFDUEkgNi4yIGFuZCBVRUZJ IDIuNy4gVGhpcyBzdXBwb3J0IGluY2x1ZGVzIHRoZSB2MS4yIG5hbWVzcGFjZQogIGxhYmVsIGZv cm1hdCwgZXh0ZW5zaW9ucyB0byB0aGUgYWRkcmVzcy1yYW5nZS1zY3J1YiBjb21tYW5kIHNldCwg bmV3CiAgZXJyb3IgaW5qZWN0aW9uIGNvbW1hbmRzLCBhbmQgYSBuZXcgQlRUIChibG9jay10cmFu c2xhdGlvbi10YWJsZSkKICBsYXlvdXQuIFRoZXNlIHVwZGF0ZXMgc3VwcG9ydCBpbnRlci1PUyBh bmQgcHJlLU9TIGNvbXBhdGliaWxpdHkuCgoqIEZpeCBhIGxvbmdzdGFuZGluZyBtZW1vcnkgY29y cnVwdGlvbiBidWcgaW4gbmZpdF90ZXN0LgoKKiBNYWtlIHRoZSBwbWVtIGFuZCBudmRpbW0tcmVn aW9uICdiYWRibG9ja3MnIHN5c2ZzIGZpbGVzIHBvbGwoMikKICBjYXBhYmxlLgoKKiBNaXNjZWxs YW5lb3VzIGZpeGVzIGFuZCBzbWFsbCB1cGRhdGVzIGFjcm9zcyBsaWJudmRpbW0gYW5kIHRoZSBu Zml0CiAgZHJpdmVyLgoKQWNrbm93bGVkZ2VtZW50cyB0aGF0IGNhbWUgYWZ0ZXIgdGhlIGJyYW5j aCB3YXMgcHVzaGVkOgoKY29tbWl0IDZhYTczNGEyZjM4ZSAibGlibnZkaW1tLCByZWdpb24sIHBt ZW06IGZpeCAnYmFkYmxvY2tzJwogIHN5c2ZzX2dldF9kaXJlbnQoKSByZWZlcmVuY2UgbGlmZXRp bWUiClJldmlld2VkLWJ5OiBUb3NoaSBLYW5pIDx0b3NoaS5rYW5pQGhwZS5jb20+CgotLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t CkFydmluZCBZYWRhdiAoMSk6CiAgICAgIGFjcGksIG5maXQ6IGNvbnN0aWZ5ICpfYXR0cmlidXRl X2dyb3VwCgpEYW4gV2lsbGlhbXMgKDI5KToKICAgICAgeDg2LCB1YWNjZXNzOiBpbnRyb2R1Y2Ug Y29weV9mcm9tX2l0ZXJfZmx1c2hjYWNoZSBmb3IgcG1lbSAvIGNhY2hlLWJ5cGFzcyBvcGVyYXRp b25zCiAgICAgIGRtOiBhZGQgLT5jb3B5X2Zyb21faXRlcigpIGRheCBvcGVyYXRpb24gc3VwcG9y dAogICAgICBsaWJudmRpbW0sIGxhYmVsOiBhZGQgdjEuMiBudmRpbW0gbGFiZWwgZGVmaW5pdGlv bnMKICAgICAgbGlibnZkaW1tLCBsYWJlbDogYWRkIHYxLjIgaW50ZXJsZWF2ZS1zZXQtY29va2ll IGFsZ29yaXRobQogICAgICBsaWJudmRpbW0sIGxhYmVsOiBob25vciB0aGUgbGJhIHNpemUgc3Bl Y2lmaWVkIGluIHYxLjIgbGFiZWxzCiAgICAgIGxpYm52ZGltbSwgbGFiZWw6IHBvcHVsYXRlIHRo ZSB0eXBlX2d1aWQgcHJvcGVydHkgZm9yIHYxLjIgbmFtZXNwYWNlcwogICAgICBsaWJudmRpbW0s IGxhYmVsOiBwb3B1bGF0ZSAnaXNldGNvb2tpZScgZm9yIGJsay1hcGVydHVyZSBuYW1lc3BhY2Vz CiAgICAgIGxpYm52ZGltbSwgbGFiZWw6IHVwZGF0ZSAnbmxhYmVsJyBhbmQgJ3Bvc2l0aW9uJyBo YW5kbGluZyBmb3IgbG9jYWwgbmFtZXNwYWNlcwogICAgICBsaWJudmRpbW0sIGxhYmVsOiBhZGQg djEuMiBsYWJlbCBjaGVja3N1bSBzdXBwb3J0CiAgICAgIGxpYm52ZGltbSwgbGFiZWw6IGFkZCBh ZGRyZXNzIGFic3RyYWN0aW9uIGlkZW50aWZpZXJzCiAgICAgIGxpYm52ZGltbSwgbGFiZWw6IHN3 aXRjaCB0byB1c2luZyB2MS4yIGxhYmVscyBieSBkZWZhdWx0CiAgICAgIGZpbGVzeXN0ZW0tZGF4 OiBjb252ZXJ0IHRvIGRheF9jb3B5X2Zyb21faXRlcigpCiAgICAgIGRheCwgcG1lbTogaW50cm9k dWNlIGFuIG9wdGlvbmFsICdmbHVzaCcgZGF4X29wZXJhdGlvbgogICAgICBkbTogYWRkIC0+Zmx1 c2goKSBkYXggb3BlcmF0aW9uIHN1cHBvcnQKICAgICAgZmlsZXN5c3RlbS1kYXg6IGNvbnZlcnQg dG8gZGF4X2ZsdXNoKCkKICAgICAgeDg2LCBkYXg6IHJlcGxhY2UgY2xlYXJfcG1lbSgpIHdpdGgg b3BlbiBjb2RlZCBtZW1zZXQgKy0gZGF4X29wcy0+Zmx1c2gKICAgICAgeDg2LCBkYXgsIGxpYm52 ZGltbTogcmVtb3ZlIHdiX2NhY2hlX3BtZW0oKSBpbmRpcmVjdGlvbgogICAgICB4ODYsIGxpYm52 ZGltbSwgcG1lbTogbW92ZSBhcmNoX2ludmFsaWRhdGVfcG1lbSgpIHRvIGxpYm52ZGltbQogICAg ICB4ODYsIGxpYm52ZGltbSwgcG1lbTogcmVtb3ZlIGdsb2JhbCBwbWVtIGFwaQogICAgICBsaWJu dmRpbW0sIHBtZW06IGZpeCBwZXJzaXN0ZW5jZSB3YXJuaW5nCiAgICAgIGxpYm52ZGltbSwgbmZp dDogZW5hYmxlIHN1cHBvcnQgZm9yIHZvbGF0aWxlIHJhbmdlcwogICAgICBkYXg6IHJlbW92ZSBk ZWZhdWx0IGNvcHlfZnJvbV9pdGVyIGZhbGxiYWNrCiAgICAgIGRheDogY29udmVydCB0byBiaXRt YXNrIGZvciBmbGFncwogICAgICBsaWJudmRpbW0sIHBtZW0sIGRheDogZXhwb3J0IGEgY2FjaGUg Y29udHJvbCBhdHRyaWJ1dGUKICAgICAgbGlibnZkaW1tLCBwbWVtOiBkaXNhYmxlIGRheCBmbHVz aGluZyB3aGVuIHBtZW0gaXMgZnJvbnRpbmcgYSB2b2xhdGlsZSByZWdpb24KICAgICAgYWNwaSwg bmZpdDogcXVpZXQgaW52YWxpZCBibG9jay1hcGVydHVyZS1yZWdpb24gd2FybmluZ3MKICAgICAg bGlibnZkaW1tLCByZWdpb24sIHBtZW06IGZpeCAnYmFkYmxvY2tzJyBzeXNmc19nZXRfZGlyZW50 KCkgcmVmZXJlbmNlIGxpZmV0aW1lCiAgICAgIGxpYm52ZGltbSwgbmFtZXNwYWNlOiByZWNvcmQg J2xiYXNpemUnIGZvciBwbWVtIG5hbWVzcGFjZXMKICAgICAgTWVyZ2UgYnJhbmNoICdmb3ItNC4x My9kYXgnIGludG8gbGlibnZkaW1tLWZvci1uZXh0CgpKZXJyeSBIb2VtYW5uICg1KToKICAgICAg bGlibnZkaW1tOiBwYXNzdGhydSBmdW5jdGlvbnMgY2xlYXIgdG8gc2VuZAogICAgICBhY3BpLCBu Zml0OiBFbmFibGUgRFNNIHBhc3MgdGhydSBmb3Igcm9vdCBmdW5jdGlvbnMuCiAgICAgIGxpYm52 ZGltbSwgYWNwaSwgbmZpdDogQWRkIGJ1cyBsZXZlbCBkc20gbWFzayBmb3IgcGFzcyB0aHJ1Lgog ICAgICBhY3BpLCBuZml0OiBTaG93IGJ1c19kc21fbWFzayBpbiBzeXNmcwogICAgICBsaWJudmRp bW06IE5ldyBBQ1BJIDYuMiBEU00gZnVuY3Rpb25zCgpUb3NoaSBLYW5pICgzKToKICAgICAgbGli bnZkaW1tLCBwbWVtOiBBZGQgc3lzZnMgbm90aWZpY2F0aW9ucyB0byBiYWRibG9ja3MKICAgICAg YWNwaS9uZml0OiBBZGQgc3VwcG9ydCBvZiBOVkRJTU0gbWVtb3J5IGVycm9yIG5vdGlmaWNhdGlv biBpbiBBQ1BJIDYuMgogICAgICBhY3BpL25maXQ6IElzc3VlIFN0YXJ0IEFSUyB0byByZXRyaWV2 ZSBleGlzdGluZyByZWNvcmRzCgpWaXNoYWwgVmVybWEgKDQpOgogICAgICBsaWJudmRpbW0sIGJ0 dDogQlRUIHVwZGF0ZXMgZm9yIFVFRkkgMi43IGZvcm1hdAogICAgICBsaWJudmRpbW0sIGJ0dDog Zml4IGJ0dF9yd19wYWdlIG5vdCByZXR1cm5pbmcgZXJyb3JzCiAgICAgIGxpYm52ZGltbTogZml4 IHRoZSBjbGVhci1lcnJvciBjaGVjayBpbiBuc2lvX3J3X2J5dGVzCiAgICAgIGxpYm52ZGltbSwg YnR0OiBjb252ZXJ0IHNvbWUgaW5mbyBtZXNzYWdlcyB0byB3YXJuL2VycgoKWWFzdW5vcmkgR290 byAoMSk6CiAgICAgIHRvb2xzL3Rlc3RpbmcvbnZkaW1tOiBmaXggbmZpdF90ZXN0IGJ1ZmZlciBv dmVyZmxvdwoKIE1BSU5UQUlORVJTICAgICAgICAgICAgICAgICAgICAgICB8ICAgNCArLS0KIGFy Y2gvcG93ZXJwYy9zeXNkZXYvYXhvbnJhbS5jICAgICB8ICAgOCArLSstCiBhcmNoL3g4Ni9LY29u ZmlnICAgICAgICAgICAgICAgICAgfCAgIDEgKy0KIGFyY2gveDg2L2luY2x1ZGUvYXNtL3BtZW0u aCAgICAgICB8IDEzNiAtLS0tLS0tLS0tLS0tLS0tLS0KIGFyY2gveDg2L2luY2x1ZGUvYXNtL3N0 cmluZ182NC5oICB8ICAgNSArLQogYXJjaC94ODYvaW5jbHVkZS9hc20vdWFjY2Vzc182NC5oIHwg IDExICstKy0KIGFyY2gveDg2L2xpYi91c2VyY29weV82NC5jICAgICAgICB8IDEzNCArLSstKy0r LSstKy0rLSstKy0rLSstKy0rLSstKy0rLSstKy0KIGFyY2gveDg2L21tL3BhZ2VhdHRyLmMgICAg ICAgICAgICB8ICAgNiArLQogZHJpdmVycy9hY3BpL25maXQvY29yZS5jICAgICAgICAgIHwgMTY3 ICstKy0rLSstKy0rLSstKy0rLSstKy0rLSstKy0rLSstKy0rLS0tLS0KIGRyaXZlcnMvYWNwaS9u Zml0L21jZS5jICAgICAgICAgICB8ICAgMiArLS0KIGRyaXZlcnMvYWNwaS9uZml0L25maXQuaCAg ICAgICAgICB8ICAgNCArLS0KIGRyaXZlcnMvYmxvY2svYnJkLmMgICAgICAgICAgICAgICB8ICAg OCArLSstCiBkcml2ZXJzL2RheC9zdXBlci5jICAgICAgICAgICAgICAgfCAxMTggKy0rLSstKy0r LSstKy0rLSstKy0rLSstKy0rLSstLQogZHJpdmVycy9tZC9kbS1saW5lYXIuYyAgICAgICAgICAg IHwgIDMwICstKy0rLSstCiBkcml2ZXJzL21kL2RtLXN0cmlwZS5jICAgICAgICAgICAgfCAgNDAg Ky0rLSstKy0rLSstCiBkcml2ZXJzL21kL2RtLmMgICAgICAgICAgICAgICAgICAgfCAgNDUgKy0r LSstKy0rLSstCiBkcml2ZXJzL252ZGltbS9idHQuYyAgICAgICAgICAgICAgfCAgNDUgKy0rLSst Ky0tLQogZHJpdmVycy9udmRpbW0vYnR0LmggICAgICAgICAgICAgIHwgICAyICstCiBkcml2ZXJz L252ZGltbS9idHRfZGV2cy5jICAgICAgICAgfCAgNTQgKy0rLSstKy0rLSstKy0tCiBkcml2ZXJz L252ZGltbS9idXMuYyAgICAgICAgICAgICAgfCAgMTUgKy0tCiBkcml2ZXJzL252ZGltbS9jbGFp bS5jICAgICAgICAgICAgfCAgMzggKy0rLSstKy0tCiBkcml2ZXJzL252ZGltbS9jb3JlLmMgICAg ICAgICAgICAgfCAgIDUgKy0tCiBkcml2ZXJzL252ZGltbS9kYXhfZGV2cy5jICAgICAgICAgfCAg MTAgKy0tCiBkcml2ZXJzL252ZGltbS9kaW1tX2RldnMuYyAgICAgICAgfCAgMTAgKy0tCiBkcml2 ZXJzL252ZGltbS9sYWJlbC5jICAgICAgICAgICAgfCAyNTEgKy0rLSstKy0rLSstKy0rLSstKy0r LSstKy0rLSstKy0rLSstKy0rLSstKy0rLSstKy0rLSstKy0rLS0tLS0KIGRyaXZlcnMvbnZkaW1t L2xhYmVsLmggICAgICAgICAgICB8ICAyMSArLSstLQogZHJpdmVycy9udmRpbW0vbmFtZXNwYWNl X2RldnMuYyAgIHwgMjgyICstKy0rLSstKy0rLSstKy0rLSstKy0rLSstKy0rLSstKy0rLSstKy0r LSstKy0rLSstKy0rLSstKy0rLSstKy0tLS0tLS0KIGRyaXZlcnMvbnZkaW1tL25kLWNvcmUuaCAg ICAgICAgICB8ICAgOSArLSstCiBkcml2ZXJzL252ZGltbS9uZC5oICAgICAgICAgICAgICAgfCAg MTcgKy0rLS0KIGRyaXZlcnMvbnZkaW1tL3Bmbl9kZXZzLmMgICAgICAgICB8ICAxMiArLS0KIGRy aXZlcnMvbnZkaW1tL3BtZW0uYyAgICAgICAgICAgICB8ICA2MyArLSstKy0rLSstKy0rLSstLQog ZHJpdmVycy9udmRpbW0vcG1lbS5oICAgICAgICAgICAgIHwgIDE1ICstKy0KIGRyaXZlcnMvbnZk aW1tL3JlZ2lvbi5jICAgICAgICAgICB8ICAxNyArLSstLQogZHJpdmVycy9udmRpbW0vcmVnaW9u X2RldnMuYyAgICAgIHwgIDg4ICstKy0rLSstKy0rLSstKy0tLS0tCiBkcml2ZXJzL3MzOTAvYmxv Y2svZGNzc2Jsay5jICAgICAgfCAgIDggKy0rLQogZnMvZGF4LmMgICAgICAgICAgICAgICAgICAg ICAgICAgIHwgICA5ICstLQogaW5jbHVkZS9saW51eC9kYXguaCAgICAgICAgICAgICAgIHwgIDEy ICstKy0KIGluY2x1ZGUvbGludXgvZGV2aWNlLW1hcHBlci5oICAgICB8ICAgNiArLQogaW5jbHVk ZS9saW51eC9saWJudmRpbW0uaCAgICAgICAgIHwgIDExICstLQogaW5jbHVkZS9saW51eC9uZC5o ICAgICAgICAgICAgICAgIHwgIDEzICstKy0KIGluY2x1ZGUvbGludXgvcG1lbS5oICAgICAgICAg ICAgICB8IDE0MiAtLS0tLS0tLS0tLS0tLS0tLS0tCiBpbmNsdWRlL2xpbnV4L3N0cmluZy5oICAg ICAgICAgICAgfCAgIDYgKy0KIGluY2x1ZGUvbGludXgvdWlvLmggICAgICAgICAgICAgICB8ICAx NSArLSstCiBpbmNsdWRlL3VhcGkvbGludXgvbmRjdGwuaCAgICAgICAgfCAgNDIgKy0rLSstKy0r LS0KIGxpYi9LY29uZmlnICAgICAgICAgICAgICAgICAgICAgICB8ICAgMyArLQogbGliL2lvdl9p dGVyLmMgICAgICAgICAgICAgICAgICAgIHwgIDIyICstKy0rLQogdG9vbHMvdGVzdGluZy9udmRp bW0vdGVzdC9uZml0LmMgIHwgICAyICstLQogNDcgZmlsZXMgY2hhbmdlZCwgMTUwNCBpbnNlcnRp b25zKCstKSwgNDYwIGRlbGV0aW9ucygtKQogZGVsZXRlIG1vZGUgMTAwNjQ0IGFyY2gveDg2L2lu Y2x1ZGUvYXNtL3BtZW0uaAogZGVsZXRlIG1vZGUgMTAwNjQ0IGluY2x1ZGUvbGludXgvcG1lbS5o CgotLS0KCmNvbW1pdCAwYWVkNTVhZjg4MzQ1YjVkNjczMjQwZjkwZTY3MWQ3OTY2MmZiMDFlCkF1 dGhvcjogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFtc0BpbnRlbC5jb20+CkRhdGU6ICAgTW9u IE1heSAyOSAxMjoyMjo1MCAyMDE3IC0wNzAwCgogICAgeDg2LCB1YWNjZXNzOiBpbnRyb2R1Y2Ug Y29weV9mcm9tX2l0ZXJfZmx1c2hjYWNoZSBmb3IgcG1lbSAvIGNhY2hlLWJ5cGFzcyBvcGVyYXRp b25zCiAgICAKICAgIFRoZSBwbWVtIGRyaXZlciBoYXMgYSBuZWVkIHRvIHRyYW5zZmVyIGRhdGEg d2l0aCBhIHBlcnNpc3RlbnQgbWVtb3J5CiAgICBkZXN0aW5hdGlvbiBhbmQgYmUgYWJsZSB0byBy ZWx5IG9uIHRoZSBmYWN0IHRoYXQgdGhlIGRlc3RpbmF0aW9uIHdyaXRlcyBhcmUgbm90CiAgICBj YWNoZWQuIEl0IGlzIHN1ZmZpY2llbnQgZm9yIHRoZSB3cml0ZXMgdG8gYmUgZmx1c2hlZCB0byBh IGNwdS1zdG9yZS1idWZmZXIKICAgIChub24tdGVtcG9yYWwgLyAibW92bnQiIGluIHg4NiB0ZXJt cyksIGFzIHdlIGV4cGVjdCB1c2Vyc3BhY2UgdG8gY2FsbCBmc3luYygpCiAgICB0byBlbnN1cmUg ZGF0YS13cml0ZXMgaGF2ZSByZWFjaGVkIGEgcG93ZXItZmFpbC1zYWZlIHpvbmUgaW4gdGhlIHBs YXRmb3JtLiBUaGUKICAgIGZzeW5jKCkgdHJpZ2dlcnMgYSBSRVFfRlVBIG9yIFJFUV9GTFVTSCB0 byB0aGUgcG1lbSBkcml2ZXIgd2hpY2ggd2lsbCB0dXJuCiAgICBhcm91bmQgYW5kIGZlbmNlIHBy ZXZpb3VzIHdyaXRlcyB3aXRoIGFuICJzZmVuY2UiLgogICAgCiAgICBJbXBsZW1lbnQgYSBfX2Nv cHlfZnJvbV91c2VyX2luYXRvbWljX2ZsdXNoY2FjaGUsIG1lbWNweV9wYWdlX2ZsdXNoY2FjaGUs IGFuZAogICAgbWVtY3B5X2ZsdXNoY2FjaGUsIHRoYXQgZ3VhcmFudGVlIHRoYXQgdGhlIGRlc3Rp bmF0aW9uIGJ1ZmZlciBpcyBub3QgZGlydHkgaW4KICAgIHRoZSBjcHUgY2FjaGUgb24gY29tcGxl dGlvbi4gVGhlIG5ldyBjb3B5X2Zyb21faXRlcl9mbHVzaGNhY2hlIGFuZCBzdWItcm91dGluZXMK ICAgIHdpbGwgYmUgdXNlZCB0byByZXBsYWNlIHRoZSAicG1lbSBhcGkiIChpbmNsdWRlL2xpbnV4 L3BtZW0uaCArLQogICAgYXJjaC94ODYvaW5jbHVkZS9hc20vcG1lbS5oKS4gVGhlIGF2YWlsYWJp bGl0eSBvZiBjb3B5X2Zyb21faXRlcl9mbHVzaGNhY2hlKCkKICAgIGFuZCBtZW1jcHlfZmx1c2hj YWNoZSgpIGFyZSBnYXRlZCBieSB0aGUgQ09ORklHX0FSQ0hfSEFTX1VBQ0NFU1NfRkxVU0hDQUNI RQogICAgY29uZmlnIHN5bWJvbCwgYW5kIGZhbGxiYWNrIHRvIGNvcHlfZnJvbV9pdGVyX25vY2Fj aGUoKSBhbmQgcGxhaW4gbWVtY3B5KCkKICAgIG90aGVyd2lzZS4KICAgIAogICAgVGhpcyBpcyBt ZWFudCB0byBzYXRpc2Z5IHRoZSBjb25jZXJuIGZyb20gTGludXMgdGhhdCBpZiBhIGRyaXZlciB3 YW50cyB0byBkbwogICAgc29tZXRoaW5nIGJleW9uZCB0aGUgbm9ybWFsIG5vY2FjaGUgc2VtYW50 aWNzIGl0IHNob3VsZCBiZSBzb21ldGhpbmcgcHJpdmF0ZSB0bwogICAgdGhhdCBkcml2ZXIgWzFd LCBhbmQgQWwncyBjb25jZXJuIHRoYXQgYW55dGhpbmcgdWFjY2VzcyByZWxhdGVkIGJlbG9uZ3Mg d2l0aAogICAgdGhlIHJlc3Qgb2YgdGhlIHVhY2Nlc3MgY29kZSBbMl0uCiAgICAKICAgIFRoZSBm aXJzdCBjb25zdW1lciBvZiB0aGlzIGludGVyZmFjZSBpcyBhIG5ldyAnY29weV9mcm9tX2l0ZXIn IGRheCBvcGVyYXRpb24gc28KICAgIHRoYXQgcG1lbSBjYW4gaW5qZWN0IGNhY2hlIG1haW50ZW5h bmNlIG9wZXJhdGlvbnMgd2l0aG91dCBpbXBvc2luZyB0aGlzCiAgICBvdmVyaGVhZCBvbiBvdGhl ciBkYXgtY2FwYWJsZSBkcml2ZXJzLgogICAgCiAgICBbMV06IGh0dHBzOi8vbGlzdHMuMDEub3Jn L3BpcGVybWFpbC9saW51eC1udmRpbW0vMjAxNy1KYW51YXJ5LzAwODM2NC5odG1sCiAgICBbMl06 IGh0dHBzOi8vbGlzdHMuMDEub3JnL3BpcGVybWFpbC9saW51eC1udmRpbW0vMjAxNy1BcHJpbC8w MDk5NDIuaHRtbAogICAgCiAgICBDYzogPHg4NkBrZXJuZWwub3JnPgogICAgQ2M6IEphbiBLYXJh IDxqYWNrQHN1c2UuY3o+CiAgICBDYzogSmVmZiBNb3llciA8am1veWVyQHJlZGhhdC5jb20+CiAg ICBDYzogSW5nbyBNb2xuYXIgPG1pbmdvQHJlZGhhdC5jb20+CiAgICBDYzogQ2hyaXN0b3BoIEhl bGx3aWcgPGhjaEBsc3QuZGU+CiAgICBDYzogVG9zaGkgS2FuaSA8dG9zaGkua2FuaUBocGUuY29t PgogICAgQ2M6ICJILiBQZXRlciBBbnZpbiIgPGhwYUB6eXRvci5jb20+CiAgICBDYzogQWwgVmly byA8dmlyb0B6ZW5pdi5saW51eC5vcmcudWs+CiAgICBDYzogVGhvbWFzIEdsZWl4bmVyIDx0Z2x4 QGxpbnV0cm9uaXguZGU+CiAgICBDYzogTWF0dGhldyBXaWxjb3ggPG1hd2lsY294QG1pY3Jvc29m dC5jb20+CiAgICBSZXZpZXdlZC1ieTogUm9zcyBad2lzbGVyIDxyb3NzLnp3aXNsZXJAbGludXgu aW50ZWwuY29tPgogICAgU2lnbmVkLW9mZi1ieTogRGFuIFdpbGxpYW1zIDxkYW4uai53aWxsaWFt c0BpbnRlbC5jb20+CgpkaWZmIC0tZ2l0IGEvYXJjaC94ODYvS2NvbmZpZyBiL2FyY2gveDg2L0tj b25maWcKaW5kZXggNGNjZmFjYzcyMzJhLi5iYjI3M2IyZjUwYjUgMTAwNjQ0Ci0tLSBhL2FyY2gv eDg2L0tjb25maWcKKy0rLSstIGIvYXJjaC94ODYvS2NvbmZpZwpAQCAtNTQsNiArLTU0LDcgQEAg Y29uZmlnIFg4NgogCXNlbGVjdCBBUkNIX0hBU19LQ09WCQkJaWYgWDg2XzY0CiAJc2VsZWN0IEFS Q0hfSEFTX01NSU9fRkxVU0gKIAlzZWxlY3QgQVJDSF9IQVNfUE1FTV9BUEkJCWlmIFg4Nl82NAor LQlzZWxlY3QgQVJDSF9IQVNfVUFDQ0VTU19GTFVTSENBQ0hFCWlmIFg4Nl82NAogCXNlbGVjdCBB UkNIX0hBU19TRVRfTUVNT1JZCiAJc2VsZWN0IEFSQ0hfSEFTX1NHX0NIQUlOCiAJc2VsZWN0IEFS Q0hfSEFTX1NUUklDVF9LRVJORUxfUldYCmRpZmYgLS1naXQgYS9hcmNoL3g4Ni9pbmNsdWRlL2Fz bS9zdHJpbmdfNjQuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3N0cmluZ182NC5oCmluZGV4IDcz M2JhZTA3ZmIyOS4uMWYyMmJjMjc3YzQ1IDEwMDY0NAotLS0gYS9hcmNoL3g4Ni9pbmNsdWRlL2Fz bS9zdHJpbmdfNjQuaAorLSstKy0gYi9hcmNoL3g4Ni9pbmNsdWRlL2FzbS9zdHJpbmdfNjQuaApA QCAtMTA5LDYgKy0xMDksMTEgQEAgbWVtY3B5X21jc2FmZSh2b2lkICpkc3QsIGNvbnN0IHZvaWQg KnNyYywgc2l6ZV90IGNudCkKIAlyZXR1cm4gMDsKIH0KIAorLSNpZmRlZiBDT05GSUdfQVJDSF9I QVNfVUFDQ0VTU19GTFVTSENBQ0hFCistI2RlZmluZSBfX0hBVkVfQVJDSF9NRU1DUFlfRkxVU0hD QUNIRSAxCistdm9pZCBtZW1jcHlfZmx1c2hjYWNoZSh2b2lkICpkc3QsIGNvbnN0IHZvaWQgKnNy Yywgc2l6ZV90IGNudCk7CistI2VuZGlmCistCiAjZW5kaWYgLyogX19LRVJORUxfXyAqLwogCiAj ZW5kaWYgLyogX0FTTV9YODZfU1RSSU5HXzY0X0ggKi8KZGlmZiAtLWdpdCBhL2FyY2gveDg2L2lu Y2x1ZGUvYXNtL3VhY2Nlc3NfNjQuaCBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3VhY2Nlc3NfNjQu aAppbmRleCBjNTUwNGI5YTQ3MmUuLmIxNmY2YTFkOGIyNiAxMDA2NDQKLS0tIGEvYXJjaC94ODYv aW5jbHVkZS9hc20vdWFjY2Vzc182NC5oCistKy0rLSBiL2FyY2gveDg2L2luY2x1ZGUvYXNtL3Vh Y2Nlc3NfNjQuaApAQCAtMTcxLDYgKy0xNzEsMTAgQEAgdW5zaWduZWQgbG9uZyByYXdfY29weV9p bl91c2VyKHZvaWQgX191c2VyICpkc3QsIGNvbnN0IHZvaWQgX191c2VyICpzcmMsIHVuc2lnbmUK IGV4dGVybiBsb25nIF9fY29weV91c2VyX25vY2FjaGUodm9pZCAqZHN0LCBjb25zdCB2b2lkIF9f dXNlciAqc3JjLAogCQkJCXVuc2lnbmVkIHNpemUsIGludCB6ZXJvcmVzdCk7CiAKKy1leHRlcm4g bG9uZyBfX2NvcHlfdXNlcl9mbHVzaGNhY2hlKHZvaWQgKmRzdCwgY29uc3Qgdm9pZCBfX3VzZXIg KnNyYywgdW5zaWduZWQgc2l6ZSk7CistZXh0ZXJuIHZvaWQgbWVtY3B5X3BhZ2VfZmx1c2hjYWNo ZShjaGFyICp0bywgc3RydWN0IHBhZ2UgKnBhZ2UsIHNpemVfdCBvZmZzZXQsCistCQkJICAgc2l6 ZV90IGxlbik7CistCiBzdGF0aWMgaW5saW5lIGludAogX19jb3B5X2Zyb21fdXNlcl9pbmF0b21p Y19ub2NhY2hlKHZvaWQgKmRzdCwgY29uc3Qgdm9pZCBfX3VzZXIgKnNyYywKIAkJCQkgIHVuc2ln bmVkIHNpemUpCkBAIC0xNzksNiArLTE4MywxMyBAQCBfX2NvcHlfZnJvbV91c2VyX2luYXRvbWlj X25vY2FjaGUodm9pZCAqZHN0LCBjb25zdCB2b2lkIF9fdXNlciAqc3JjLAogCXJldHVybiBfX2Nv cHlfdXNlcl9ub2NhY2hlKGRzdCwgc3JjLCBzaXplLCAwKTsKIH0KIAorLXN0YXRpYyBpbmxpbmUg aW50CistX19jb3B5X2Zyb21fdXNlcl9mbHVzaGNhY2hlKHZvaWQgKmRzdCwgY29uc3Qgdm9pZCBf X3VzZXIgKnNyYywgdW5zaWduZWQgc2l6ZSkKKy17CistCWthc2FuX2NoZWNrX3dyaXRlKGRzdCwg c2l6ZSk7CistCXJldHVybiBfX2NvcHlfdXNlcl9mbHVzaGNhY2hlKGRzdCwgc3JjLCBzaXplKTsK Ky19CistCiB1bnNpZ25lZCBsb25nCiBjb3B5X3VzZXJfaGFuZGxlX3RhaWwoY2hhciAqdG8sIGNo YXIgKmZyb20sIHVuc2lnbmVkIGxlbik7CiAKZGlmZiAtLWdpdCBhL2FyY2gveDg2L2xpYi91c2Vy Y29weV82NC5jIGIvYXJjaC94ODYvbGliL3VzZXJjb3B5XzY0LmMKaW5kZXggM2I3YzQwYTJlM2Ux Li5mNDJkMmZkODZjYTMgMTAwNjQ0Ci0tLSBhL2FyY2gveDg2L2xpYi91c2VyY29weV82NC5jCist Ky0rLSBiL2FyY2gveDg2L2xpYi91c2VyY29weV82NC5jCkBAIC03LDYgKy03LDcgQEAKICAqLwog I2luY2x1ZGUgPGxpbnV4L2V4cG9ydC5oPgogI2luY2x1ZGUgPGxpbnV4L3VhY2Nlc3MuaD4KKy0j aW5jbHVkZSA8bGludXgvaGlnaG1lbS5oPgogCiAvKgogICogWmVybyBVc2Vyc3BhY2UKQEAgLTcz LDMgKy03NCwxMzAgQEAgY29weV91c2VyX2hhbmRsZV90YWlsKGNoYXIgKnRvLCBjaGFyICpmcm9t LCB1bnNpZ25lZCBsZW4pCiAJY2xhYygpOwogCXJldHVybiBsZW47CiB9CistCistI2lmZGVmIENP TkZJR19BUkNIX0hBU19VQUNDRVNTX0ZMVVNIQ0FDSEUKKy0vKioKKy0gKiBjbGVhbl9jYWNoZV9y YW5nZSAtIHdyaXRlIGJhY2sgYSBjYWNoZSByYW5nZSB3aXRoIENMV0IKKy0gKiBAdmFkZHI6CXZp cnR1YWwgc3RhcnQgYWRkcmVzcworLSAqIEBzaXplOgludW1iZXIgb2YgYnl0ZXMgdG8gd3JpdGUg YmFjaworLSAqCistICogV3JpdGUgYmFjayBhIGNhY2hlIHJhbmdlIHVzaW5nIHRoZSBDTFdCIChj YWNoZSBsaW5lIHdyaXRlIGJhY2spCistICogaW5zdHJ1Y3Rpb24uIE5vdGUgdGhhdCBAc2l6ZSBp cyBpbnRlcm5hbGx5IHJvdW5kZWQgdXAgdG8gYmUgY2FjaGUKKy0gKiBsaW5lIHNpemUgYWxpZ25l ZC4KKy0gKi8KKy1zdGF0aWMgdm9pZCBjbGVhbl9jYWNoZV9yYW5nZSh2b2lkICphZGRyLCBzaXpl X3Qgc2l6ZSkKKy17CistCXUxNiB4ODZfY2xmbHVzaF9zaXplID0gYm9vdF9jcHVfZGF0YS54ODZf Y2xmbHVzaF9zaXplOworLQl1bnNpZ25lZCBsb25nIGNsZmx1c2hfbWFzayA9IHg4Nl9jbGZsdXNo X3NpemUgLSAxOworLQl2b2lkICp2ZW5kID0gYWRkciArLSBzaXplOworLQl2b2lkICpwOworLQor LQlmb3IgKHAgPSAodm9pZCAqKSgodW5zaWduZWQgbG9uZylhZGRyICYgK0FINC1jbGZsdXNoX21h c2spOworLQkgICAgIHAgPCB2ZW5kOyBwICstPSB4ODZfY2xmbHVzaF9zaXplKQorLQkJY2x3Yihw KTsKKy19CistCistbG9uZyBfX2NvcHlfdXNlcl9mbHVzaGNhY2hlKHZvaWQgKmRzdCwgY29uc3Qg dm9pZCBfX3VzZXIgKnNyYywgdW5zaWduZWQgc2l6ZSkKKy17CistCXVuc2lnbmVkIGxvbmcgZmx1 c2hlZCwgZGVzdCA9ICh1bnNpZ25lZCBsb25nKSBkc3Q7CistCWxvbmcgcmMgPSBfX2NvcHlfdXNl cl9ub2NhY2hlKGRzdCwgc3JjLCBzaXplLCAwKTsKKy0KKy0JLyoKKy0JICogX19jb3B5X3VzZXJf bm9jYWNoZSgpIHVzZXMgbm9uLXRlbXBvcmFsIHN0b3JlcyBmb3IgdGhlIGJ1bGsKKy0JICogb2Yg dGhlIHRyYW5zZmVyLCBidXQgd2UgbmVlZCB0byBtYW51YWxseSBmbHVzaCBpZiB0aGUKKy0JICog dHJhbnNmZXIgaXMgdW5hbGlnbmVkLiBBIGNhY2hlZCBtZW1vcnkgY29weSBpcyB1c2VkIHdoZW4K Ky0JICogZGVzdGluYXRpb24gb3Igc2l6ZSBpcyBub3QgbmF0dXJhbGx5IGFsaWduZWQuIFRoYXQg aXM6CistCSAqICAgLSBSZXF1aXJlIDgtYnl0ZSBhbGlnbm1lbnQgd2hlbiBzaXplIGlzIDggYnl0 ZXMgb3IgbGFyZ2VyLgorLQkgKiAgIC0gUmVxdWlyZSA0LWJ5dGUgYWxpZ25tZW50IHdoZW4gc2l6 ZSBpcyA0IGJ5dGVzLgorLQkgKi8KKy0JaWYgKHNpemUgPCA4KSB7CistCQlpZiAoIUlTX0FMSUdO RUQoZGVzdCwgNCkgfHwgc2l6ZSAhPSA0KQorLQkJCWNsZWFuX2NhY2hlX3JhbmdlKGRzdCwgMSk7 CistCX0gZWxzZSB7CistCQlpZiAoIUlTX0FMSUdORUQoZGVzdCwgOCkpIHsKKy0JCQlkZXN0ID0g QUxJR04oZGVzdCwgYm9vdF9jcHVfZGF0YS54ODZfY2xmbHVzaF9zaXplKTsKKy0JCQljbGVhbl9j YWNoZV9yYW5nZShkc3QsIDEpOworLQkJfQorLQorLQkJZmx1c2hlZCA9IGRlc3QgLSAodW5zaWdu ZWQgbG9uZykgZHN0OworLQkJaWYgKHNpemUgPiBmbHVzaGVkICYmICFJU19BTElHTkVEKHNpemUg LSBmbHVzaGVkLCA4KSkKKy0JCQljbGVhbl9jYWNoZV9yYW5nZShkc3QgKy0gc2l6ZSAtIDEsIDEp OworLQl9CistCistCXJldHVybiByYzsKKy19CistCistdm9pZCBtZW1jcHlfZmx1c2hjYWNoZSh2 b2lkICpfZHN0LCBjb25zdCB2b2lkICpfc3JjLCBzaXplX3Qgc2l6ZSkKKy17CistCXVuc2lnbmVk IGxvbmcgZGVzdCA9ICh1bnNpZ25lZCBsb25nKSBfZHN0OworLQl1bnNpZ25lZCBsb25nIHNvdXJj ZSA9ICh1bnNpZ25lZCBsb25nKSBfc3JjOworLQorLQkvKiBjYWNoZSBjb3B5IGFuZCBmbHVzaCB0 byBhbGlnbiBkZXN0ICovCistCWlmICghSVNfQUxJR05FRChkZXN0LCA4KSkgeworLQkJdW5zaWdu ZWQgbGVuID0gbWluX3QodW5zaWduZWQsIHNpemUsIEFMSUdOKGRlc3QsIDgpIC0gZGVzdCk7Cist CistCQltZW1jcHkoKHZvaWQgKikgZGVzdCwgKHZvaWQgKikgc291cmNlLCBsZW4pOworLQkJY2xl YW5fY2FjaGVfcmFuZ2UoKHZvaWQgKikgZGVzdCwgbGVuKTsKKy0JCWRlc3QgKy09IGxlbjsKKy0J CXNvdXJjZSArLT0gbGVuOworLQkJc2l6ZSAtPSBsZW47CistCQlpZiAoIXNpemUpCistCQkJcmV0 dXJuOworLQl9CistCistCS8qIDR4OCBtb3ZudGkgbG9vcCAqLworLQl3aGlsZSAoc2l6ZSA+PSAz MikgeworLQkJYXNtKCJtb3ZxICAgICglMCksICUlcjgrQUZ3LW4iCistCQkgICAgIm1vdnEgICA4 KCUwKSwgJSVyOStBRnctbiIKKy0JCSAgICAibW92cSAgMTYoJTApLCAlJXIxMCtBRnctbiIKKy0J CSAgICAibW92cSAgMjQoJTApLCAlJXIxMStBRnctbiIKKy0JCSAgICAibW92bnRpICAlJXI4LCAg ICglMSkrQUZ3LW4iCistCQkgICAgIm1vdm50aSAgJSVyOSwgIDgoJTEpK0FGdy1uIgorLQkJICAg ICJtb3ZudGkgJSVyMTAsIDE2KCUxKStBRnctbiIKKy0JCSAgICAibW92bnRpICUlcjExLCAyNCgl MSkrQUZ3LW4iCistCQkgICAgOjogInIiIChzb3VyY2UpLCAiciIgKGRlc3QpCistCQkgICAgOiAi bWVtb3J5IiwgInI4IiwgInI5IiwgInIxMCIsICJyMTEiKTsKKy0JCWRlc3QgKy09IDMyOworLQkJ c291cmNlICstPSAzMjsKKy0JCXNpemUgLT0gMzI7CistCX0KKy0KKy0JLyogMXg4IG1vdm50aSBs b29wICovCistCXdoaWxlIChzaXplID49IDgpIHsKKy0JCWFzbSgibW92cSAgICAoJTApLCAlJXI4 K0FGdy1uIgorLQkJICAgICJtb3ZudGkgICUlcjgsICAgKCUxKStBRnctbiIKKy0JCSAgICA6OiAi ciIgKHNvdXJjZSksICJyIiAoZGVzdCkKKy0JCSAgICA6ICJtZW1vcnkiLCAicjgiKTsKKy0JCWRl c3QgKy09IDg7CistCQlzb3VyY2UgKy09IDg7CistCQlzaXplIC09IDg7CistCX0KKy0KKy0JLyog MXg0IG1vdm50aSBsb29wICovCistCXdoaWxlIChzaXplID49IDQpIHsKKy0JCWFzbSgibW92bCAg ICAoJTApLCAlJXI4ZCtBRnctbiIKKy0JCSAgICAibW92bnRpICAlJXI4ZCwgICAoJTEpK0FGdy1u IgorLQkJICAgIDo6ICJyIiAoc291cmNlKSwgInIiIChkZXN0KQorLQkJICAgIDogIm1lbW9yeSIs ICJyOCIpOworLQkJZGVzdCArLT0gNDsKKy0JCXNvdXJjZSArLT0gNDsKKy0JCXNpemUgLT0gNDsK Ky0JfQorLQorLQkvKiBjYWNoZSBjb3B5IGZvciByZW1haW5pbmcgYnl0ZXMgKi8KKy0JaWYgKHNp emUpIHsKKy0JCW1lbWNweSgodm9pZCAqKSBkZXN0LCAodm9pZCAqKSBzb3VyY2UsIHNpemUpOwor LQkJY2xlYW5fY2FjaGVfcmFuZ2UoKHZvaWQgKikgZGVzdCwgc2l6ZSk7CistCX0KKy19CistRVhQ T1JUX1NZTUJPTF9HUEwobWVtY3B5X2ZsdXNoY2FjaGUpOworLQorLXZvaWQgbWVtY3B5X3BhZ2Vf Zmx1c2hjYWNoZShjaGFyICp0bywgc3RydWN0IHBhZ2UgKnBhZ2UsIHNpemVfdCBvZmZzZXQsCist CQlzaXplX3QgbGVuKQorLXsKKy0JY2hhciAqZnJvbSA9IGttYXBfYXRvbWljKHBhZ2UpOworLQor LQltZW1jcHlfZmx1c2hjYWNoZSh0bywgZnJvbSArLSBvZmZzZXQsIGxlbik7CistCWt1bm1hcF9h dG9taWMoZnJvbSk7CistfQorLSNlbmRpZgpkaWZmIC0tZ2l0IGEvZHJpdmVycy9hY3BpL25maXQv Y29yZS5jIGIvZHJpdmVycy9hY3BpL25maXQvY29yZS5jCmluZGV4IDY1NmFjYjVkNzE2Ni4uY2Jk NTU5NmU3NTYyIDEwMDY0NAotLS0gYS9kcml2ZXJzL2FjcGkvbmZpdC9jb3JlLmMKKy0rLSstIGIv ZHJpdmVycy9hY3BpL25maXQvY29yZS5jCkBAIC0xODQyLDggKy0xODQyLDcgQEAgc3RhdGljIGlu dCBhY3BpX25maXRfYmxrX3NpbmdsZV9pbyhzdHJ1Y3QgbmZpdF9ibGsgKm5maXRfYmxrLAogCQl9 CiAKIAkJaWYgKHJ3KQotCQkJbWVtY3B5X3RvX3BtZW0obW1pby0+YWRkci5hcGVydHVyZSArLSBv ZmZzZXQsCi0JCQkJCWlvYnVmICstIGNvcGllZCwgYyk7CistCQkJbWVtY3B5X2ZsdXNoY2FjaGUo bW1pby0+YWRkci5hcGVydHVyZSArLSBvZmZzZXQsIGlvYnVmICstIGNvcGllZCwgYyk7CiAJCWVs c2UgewogCQkJaWYgKG5maXRfYmxrLT5kaW1tX2ZsYWdzICYgTkZJVF9CTEtfUkVBRF9GTFVTSCkK IAkJCQltbWlvX2ZsdXNoX3JhbmdlKCh2b2lkIF9fZm9yY2UgKikKZGlmZiAtLWdpdCBhL2RyaXZl cnMvbnZkaW1tL2NsYWltLmMgYi9kcml2ZXJzL252ZGltbS9jbGFpbS5jCmluZGV4IDdjZWI1ZmE0 ZjJhMS4uYjhiOWM4Y2E3ODYyIDEwMDY0NAotLS0gYS9kcml2ZXJzL252ZGltbS9jbGFpbS5jCist Ky0rLSBiL2RyaXZlcnMvbnZkaW1tL2NsYWltLmMKQEAgLTI3Nyw3ICstMjc3LDcgQEAgc3RhdGlj IGludCBuc2lvX3J3X2J5dGVzKHN0cnVjdCBuZF9uYW1lc3BhY2VfY29tbW9uICpuZG5zLAogCQkJ cmMgPSAtRUlPOwogCX0KIAotCW1lbWNweV90b19wbWVtKG5zaW8tPmFkZHIgKy0gb2Zmc2V0LCBi dWYsIHNpemUpOworLQltZW1jcHlfZmx1c2hjYWNoZShuc2lvLT5hZGRyICstIG9mZnNldCwgYnVm LCBzaXplKTsKIAludmRpbW1fZmx1c2godG9fbmRfcmVnaW9uKG5kbnMtPmRldi5wYXJlbnQpKTsK IAogCXJldHVybiByYzsKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZkaW1tL3BtZW0uYyBiL2RyaXZl cnMvbnZkaW1tL3BtZW0uYwppbmRleCBjNTQ0ZDQ2NmVhNTEuLjJmM2FlZmU1NjVjNiAxMDA2NDQK LS0tIGEvZHJpdmVycy9udmRpbW0vcG1lbS5jCistKy0rLSBiL2RyaXZlcnMvbnZkaW1tL3BtZW0u YwpAQCAtMjksNiArLTI5LDcgQEAKICNpbmNsdWRlIDxsaW51eC9wZm5fdC5oPgogI2luY2x1ZGUg PGxpbnV4L3NsYWIuaD4KICNpbmNsdWRlIDxsaW51eC9wbWVtLmg+CistI2luY2x1ZGUgPGxpbnV4 L3Vpby5oPgogI2luY2x1ZGUgPGxpbnV4L2RheC5oPgogI2luY2x1ZGUgPGxpbnV4L25kLmg+CiAj aW5jbHVkZSAicG1lbS5oIgpAQCAtODAsNyArLTgxLDcgQEAgc3RhdGljIHZvaWQgd3JpdGVfcG1l bSh2b2lkICpwbWVtX2FkZHIsIHN0cnVjdCBwYWdlICpwYWdlLAogewogCXZvaWQgKm1lbSA9IGtt YXBfYXRvbWljKHBhZ2UpOwogCi0JbWVtY3B5X3RvX3BtZW0ocG1lbV9hZGRyLCBtZW0gKy0gb2Zm LCBsZW4pOworLQltZW1jcHlfZmx1c2hjYWNoZShwbWVtX2FkZHIsIG1lbSArLSBvZmYsIGxlbik7 CiAJa3VubWFwX2F0b21pYyhtZW0pOwogfQogCkBAIC0yMzUsOCArLTIzNiwxNSBAQCBzdGF0aWMg bG9uZyBwbWVtX2RheF9kaXJlY3RfYWNjZXNzKHN0cnVjdCBkYXhfZGV2aWNlICpkYXhfZGV2LAog CXJldHVybiBfX3BtZW1fZGlyZWN0X2FjY2VzcyhwbWVtLCBwZ29mZiwgbnJfcGFnZXMsIGthZGRy LCBwZm4pOwogfQogCistc3RhdGljIHNpemVfdCBwbWVtX2NvcHlfZnJvbV9pdGVyKHN0cnVjdCBk YXhfZGV2aWNlICpkYXhfZGV2LCBwZ29mZl90IHBnb2ZmLAorLQkJdm9pZCAqYWRkciwgc2l6ZV90 IGJ5dGVzLCBzdHJ1Y3QgaW92X2l0ZXIgKmkpCisteworLQlyZXR1cm4gY29weV9mcm9tX2l0ZXJf Zmx1c2hjYWNoZShhZGRyLCBieXRlcywgaSk7CistfQorLQogc3RhdGljIGNvbnN0IHN0cnVjdCBk YXhfb3BlcmF0aW9ucyBwbWVtX2RheF9vcHMgPSB7CiAJLmRpcmVjdF9hY2Nlc3MgPSBwbWVtX2Rh eF9kaXJlY3RfYWNjZXNzLAorLQkuY29weV9mcm9tX2l0ZXIgPSBwbWVtX2NvcHlfZnJvbV9pdGVy LAogfTsKIAogc3RhdGljIHZvaWQgcG1lbV9yZWxlYXNlX3F1ZXVlKHZvaWQgKnEpCkBAIC0yOTQs NyArLTMwMiw4IEBAIHN0YXRpYyBpbnQgcG1lbV9hdHRhY2hfZGlzayhzdHJ1Y3QgZGV2aWNlICpk ZXYsCiAJZGV2X3NldF9kcnZkYXRhKGRldiwgcG1lbSk7CiAJcG1lbS0+cGh5c19hZGRyID0gcmVz LT5zdGFydDsKIAlwbWVtLT5zaXplID0gcmVzb3VyY2Vfc2l6ZShyZXMpOwotCWlmIChudmRpbW1f aGFzX2ZsdXNoKG5kX3JlZ2lvbikgPCAwKQorLQlpZiAoIUlTX0VOQUJMRUQoQ09ORklHX0FSQ0hf SEFTX1VBQ0NFU1NfRkxVU0hDQUNIRSkKKy0JCQl8fCBudmRpbW1faGFzX2ZsdXNoKG5kX3JlZ2lv bikgPCAwKQogCQlkZXZfd2FybihkZXYsICJ1bmFibGUgdG8gZ3VhcmFudGVlIHBlcnNpc3RlbmNl IG9mIHdyaXRlcytBRnctbiIpOwogCiAJaWYgKCFkZXZtX3JlcXVlc3RfbWVtX3JlZ2lvbihkZXYs IHJlcy0+c3RhcnQsIHJlc291cmNlX3NpemUocmVzKSwKZGlmZiAtLWdpdCBhL2RyaXZlcnMvbnZk aW1tL3JlZ2lvbl9kZXZzLmMgYi9kcml2ZXJzL252ZGltbS9yZWdpb25fZGV2cy5jCmluZGV4IGI1 NTBlZGYyNTcxZi4uOTg1YjBlMTFiZDczIDEwMDY0NAotLS0gYS9kcml2ZXJzL252ZGltbS9yZWdp b25fZGV2cy5jCistKy0rLSBiL2RyaXZlcnMvbnZkaW1tL3JlZ2lvbl9kZXZzLmMKQEAgLTEwMTUs OCArLTEwMTUsOCBAQCB2b2lkIG52ZGltbV9mbHVzaChzdHJ1Y3QgbmRfcmVnaW9uICpuZF9yZWdp b24pCiAJICogVGhlIGZpcnN0IHdtYigpIGlzIG5lZWRlZCB0byAnc2ZlbmNlJyBhbGwgcHJldmlv dXMgd3JpdGVzCiAJICogc3VjaCB0aGF0IHRoZXkgYXJlIGFyY2hpdGVjdHVyYWxseSB2aXNpYmxl IGZvciB0aGUgcGxhdGZvcm0KIAkgKiBidWZmZXIgZmx1c2guICBOb3RlIHRoYXQgd2UndmUgYWxy ZWFkeSBhcnJhbmdlZCBmb3IgcG1lbQotCSAqIHdyaXRlcyB0byBhdm9pZCB0aGUgY2FjaGUgdmlh IGFyY2hfbWVtY3B5X3RvX3BtZW0oKS4gIFRoZQotCSAqIGZpbmFsIHdtYigpIGVuc3VyZXMgb3Jk ZXJpbmcgZm9yIHRoZSBOVkRJTU0gZmx1c2ggd3JpdGUuCistCSAqIHdyaXRlcyB0byBhdm9pZCB0 aGUgY2FjaGUgdmlhIG1lbWNweV9mbHVzaGNhY2hlKCkuICBUaGUgZmluYWwKKy0JICogd21iKCkg ZW5zdXJlcyBvcmRlcmluZyBmb3IgdGhlIE5WRElNTSBmbHVzaCB3cml0ZS4KIAkgKi8KIAl3bWIo KTsKIAlmb3IgKGkgPSAwOyBpIDwgbmRfcmVnaW9uLT5uZHJfbWFwcGluZ3M7IGkrLSstKQpkaWZm IC0tZ2l0IGEvaW5jbHVkZS9saW51eC9kYXguaCBiL2luY2x1ZGUvbGludXgvZGF4LmgKaW5kZXgg NWVjMWY2YzQ3NzE2Li5iYmU3OWVkOTBlMmIgMTAwNjQ0Ci0tLSBhL2luY2x1ZGUvbGludXgvZGF4 LmgKKy0rLSstIGIvaW5jbHVkZS9saW51eC9kYXguaApAQCAtMTYsNiArLTE2LDkgQEAgc3RydWN0 IGRheF9vcGVyYXRpb25zIHsKIAkgKi8KIAlsb25nICgqZGlyZWN0X2FjY2Vzcykoc3RydWN0IGRh eF9kZXZpY2UgKiwgcGdvZmZfdCwgbG9uZywKIAkJCXZvaWQgKiosIHBmbl90ICopOworLQkvKiBj b3B5X2Zyb21faXRlcjogZGF4LWRyaXZlciBvdmVycmlkZSBmb3IgZGVmYXVsdCBjb3B5X2Zyb21f aXRlciAqLworLQlzaXplX3QgKCpjb3B5X2Zyb21faXRlcikoc3RydWN0IGRheF9kZXZpY2UgKiwg cGdvZmZfdCwgdm9pZCAqLCBzaXplX3QsCistCQkJc3RydWN0IGlvdl9pdGVyICopOwogfTsKIAog I2lmIElTX0VOQUJMRUQoQ09ORklHX0RBWCkKZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvc3Ry aW5nLmggYi9pbmNsdWRlL2xpbnV4L3N0cmluZy5oCmluZGV4IDUzNzkxOGY4YTk4ZS4uNzQzOWQ4 M2VhYTMzIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4L3N0cmluZy5oCistKy0rLSBiL2luY2x1 ZGUvbGludXgvc3RyaW5nLmgKQEAgLTEyMiw2ICstMTIyLDEyIEBAIHN0YXRpYyBpbmxpbmUgX19t dXN0X2NoZWNrIGludCBtZW1jcHlfbWNzYWZlKHZvaWQgKmRzdCwgY29uc3Qgdm9pZCAqc3JjLAog CXJldHVybiAwOwogfQogI2VuZGlmCistI2lmbmRlZiBfX0hBVkVfQVJDSF9NRU1DUFlfRkxVU0hD QUNIRQorLXN0YXRpYyBpbmxpbmUgdm9pZCBtZW1jcHlfZmx1c2hjYWNoZSh2b2lkICpkc3QsIGNv bnN0IHZvaWQgKnNyYywgc2l6ZV90IGNudCkKKy17CistCW1lbWNweShkc3QsIHNyYywgY250KTsK Ky19CistI2VuZGlmCiB2b2lkICptZW1jaHJfaW52KGNvbnN0IHZvaWQgKnMsIGludCBjLCBzaXpl X3Qgbik7CiBjaGFyICpzdHJyZXBsYWNlKGNoYXIgKnMsIGNoYXIgb2xkLCBjaGFyIG5ldyk7CiAK ZGlmZiAtLWdpdCBhL2luY2x1ZGUvbGludXgvdWlvLmggYi9pbmNsdWRlL2xpbnV4L3Vpby5oCmlu ZGV4IGYyZDM2YTNkMzAwNS4uNTVjZDU0YTBlOTQxIDEwMDY0NAotLS0gYS9pbmNsdWRlL2xpbnV4 L3Vpby5oCistKy0rLSBiL2luY2x1ZGUvbGludXgvdWlvLmgKQEAgLTk1LDYgKy05NSwyMSBAQCBz aXplX3QgY29weV90b19pdGVyKGNvbnN0IHZvaWQgKmFkZHIsIHNpemVfdCBieXRlcywgc3RydWN0 IGlvdl9pdGVyICppKTsKIHNpemVfdCBjb3B5X2Zyb21faXRlcih2b2lkICphZGRyLCBzaXplX3Qg Ynl0ZXMsIHN0cnVjdCBpb3ZfaXRlciAqaSk7CiBib29sIGNvcHlfZnJvbV9pdGVyX2Z1bGwodm9p ZCAqYWRkciwgc2l6ZV90IGJ5dGVzLCBzdHJ1Y3QgaW92X2l0ZXIgKmkpOwogc2l6ZV90IGNvcHlf ZnJvbV9pdGVyX25vY2FjaGUodm9pZCAqYWRkciwgc2l6ZV90IGJ5dGVzLCBzdHJ1Y3QgaW92X2l0 ZXIgKmkpOworLSNpZmRlZiBDT05GSUdfQVJDSF9IQVNfVUFDQ0VTU19GTFVTSENBQ0hFCistLyoK Ky0gKiBOb3RlLCB1c2VycyBsaWtlIHBtZW0gdGhhdCBkZXBlbmQgb24gdGhlIHN0cmljdGVyIHNl bWFudGljcyBvZgorLSAqIGNvcHlfZnJvbV9pdGVyX2ZsdXNoY2FjaGUoKSB0aGFuIGNvcHlfZnJv bV9pdGVyX25vY2FjaGUoKSBtdXN0IGNoZWNrIGZvcgorLSAqIElTX0VOQUJMRUQoQ09ORklHX0FS Q0hfSEFTX1VBQ0NFU1NfRkxVU0hDQUNIRSkgYmVmb3JlIGFzc3VtaW5nIHRoYXQgdGhlCistICog ZGVzdGluYXRpb24gaXMgZmx1c2hlZCBmcm9tIHRoZSBjYWNoZSBvbiByZXR1cm4uCistICovCist c2l6ZV90IGNvcHlfZnJvbV9pdGVyX2ZsdXNoY2FjaGUodm9pZCAqYWRkciwgc2l6ZV90IGJ5dGVz LCBzdHJ1Y3QgaW92X2l0ZXIgKmkpOworLSNlbHNlCistc3RhdGljIGlubGluZSBzaXplX3QgY29w eV9mcm9tX2l0ZXJfZmx1c2hjYWNoZSh2b2lkICphZGRyLCBzaXplX3QgYnl0ZXMsCistCQkJCSAg ICAgICBzdHJ1Y3QgaW92X2l0ZXIgKmkpCisteworLQlyZXR1cm4gY29weV9mcm9tX2l0ZXJfbm9j YWNoZShhZGRyLCBieXRlcywgaSk7CistfQorLSNlbmRpZgogYm9vbCBjb3B5X2Zyb21faXRlcl9m dWxsX25vY2FjaGUodm9pZCAqYWRkciwgc2l6ZV90IGJ5dGVzLCBzdHJ1Y3QgaW92X2l0ZXIgKmkp Owogc2l6ZV90IGlvdl9pdGVyX3plcm8oc2l6ZV90IGJ5dGVzLCBzdHJ1Y3QgaW92X2l0ZXIgKik7 CiB1bnNpZ25lZCBsb25nIGlvdl9pdGVyX2FsaWdubWVudChjb25zdCBzdHJ1Y3QgaW92X2l0ZXIg KmkpOwpkaWZmIC0tZ2l0IGEvbGliL0tjb25maWcgYi9saWIvS2NvbmZpZwppbmRleCAwYzhiNzhh OWFlMmUuLjJkMWM0YjNhMDg1YyAxMDA2NDQKLS0tIGEvbGliL0tjb25maWcKKy0rLSstIGIvbGli L0tjb25maWcKQEAgLTU0OCw2ICstNTQ4LDkgQEAgY29uZmlnIEFSQ0hfSEFTX1NHX0NIQUlOCiBj b25maWcgQVJDSF9IQVNfUE1FTV9BUEkKIAlib29sCiAKKy1jb25maWcgQVJDSF9IQVNfVUFDQ0VT U19GTFVTSENBQ0hFCistCWJvb2wKKy0KIGNvbmZpZyBBUkNIX0hBU19NTUlPX0ZMVVNICiAJYm9v bAogCmRpZmYgLS1naXQgYS9saWIvaW92X2l0ZXIuYyBiL2xpYi9pb3ZfaXRlci5jCmluZGV4IGY4 MzU5NjRjOTQ4NS4uYzlhNjkwNjQ0NjJmIDEwMDY0NAotLS0gYS9saWIvaW92X2l0ZXIuYworLSst Ky0gYi9saWIvaW92X2l0ZXIuYwpAQCAtNjE1LDYgKy02MTUsMjggQEAgc2l6ZV90IGNvcHlfZnJv bV9pdGVyX25vY2FjaGUodm9pZCAqYWRkciwgc2l6ZV90IGJ5dGVzLCBzdHJ1Y3QgaW92X2l0ZXIg KmkpCiB9CiBFWFBPUlRfU1lNQk9MKGNvcHlfZnJvbV9pdGVyX25vY2FjaGUpOwogCistI2lmZGVm IENPTkZJR19BUkNIX0hBU19VQUNDRVNTX0ZMVVNIQ0FDSEUKKy1zaXplX3QgY29weV9mcm9tX2l0 ZXJfZmx1c2hjYWNoZSh2b2lkICphZGRyLCBzaXplX3QgYnl0ZXMsIHN0cnVjdCBpb3ZfaXRlciAq aSkKKy17CistCWNoYXIgKnRvID0gYWRkcjsKKy0JaWYgKHVubGlrZWx5KGktPnR5cGUgJiBJVEVS X1BJUEUpKSB7CistCQlXQVJOX09OKDEpOworLQkJcmV0dXJuIDA7CistCX0KKy0JaXRlcmF0ZV9h bmRfYWR2YW5jZShpLCBieXRlcywgdiwKKy0JCV9fY29weV9mcm9tX3VzZXJfZmx1c2hjYWNoZSgo dG8gKy09IHYuaW92X2xlbikgLSB2Lmlvdl9sZW4sCistCQkJCQkgdi5pb3ZfYmFzZSwgdi5pb3Zf bGVuKSwKKy0JCW1lbWNweV9wYWdlX2ZsdXNoY2FjaGUoKHRvICstPSB2LmJ2X2xlbikgLSB2LmJ2 X2xlbiwgdi5idl9wYWdlLAorLQkJCQkgdi5idl9vZmZzZXQsIHYuYnZfbGVuKSwKKy0JCW1lbWNw eV9mbHVzaGNhY2hlKCh0byArLT0gdi5pb3ZfbGVuKSAtIHYuaW92X2xlbiwgdi5pb3ZfYmFzZSwK Ky0JCQl2Lmlvdl9sZW4pCistCSkKKy0KKy0JcmV0dXJuIGJ5dGVzOworLX0KKy1FWFBPUlRfU1lN Qk9MX0dQTChjb3B5X2Zyb21faXRlcl9mbHVzaGNhY2hlKTsKKy0jZW5kaWYKKy0KIGJvb2wgY29w eV9mcm9tX2l0ZXJfZnVsbF9ub2NhY2hlKHZvaWQgKmFkZHIsIHNpemVfdCBieXRlcywgc3RydWN0 IGlvdl9pdGVyICppKQogewogCWNoYXIgKnRvID0gYWRkcjsKX19fX19fX19fX19fX19fX19fX19f X19fX19fX19fX19fX19fX19fX19fX19fX18KTGludXgtbnZkaW1tIG1haWxpbmcgbGlzdApMaW51 eC1udmRpbW1AbGlzdHMuMDEub3JnCmh0dHBzOi8vbGlzdHMuMDEub3JnL21haWxtYW4vbGlzdGlu Zm8vbGludXgtbnZkaW1tCg==