From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1751660AbdGaSz1 (ORCPT ); Mon, 31 Jul 2017 14:55:27 -0400 Received: from mail-wm0-f67.google.com ([74.125.82.67]:34084 "EHLO mail-wm0-f67.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1750967AbdGaSzZ (ORCPT ); Mon, 31 Jul 2017 14:55:25 -0400 From: Tvrtko Ursulin X-Google-Original-From: Tvrtko Ursulin To: Intel-gfx@lists.freedesktop.org Cc: tursulin@ursulin.net, Tvrtko Ursulin , Chris Wilson , linux-kernel@vger.kernel.org Subject: [PATCH 5/5] tools/testing/scatterlist: Test new __sg_alloc_table_from_pages Date: Mon, 31 Jul 2017 19:55:12 +0100 Message-Id: <20170731185512.20010-5-tvrtko.ursulin@linux.intel.com> X-Mailer: git-send-email 2.9.4 In-Reply-To: <20170731185512.20010-1-tvrtko.ursulin@linux.intel.com> References: <20170731185512.20010-1-tvrtko.ursulin@linux.intel.com> Sender: linux-kernel-owner@vger.kernel.org List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: Tvrtko Ursulin Exercise the new __sg_alloc_table_from_pages API (and through it also the old sg_alloc_table_from_pages), checking that the created table has the expected number of segments depending on the sequence of input pages and other conditions. Signed-off-by: Tvrtko Ursulin Cc: Chris Wilson Cc: linux-kernel@vger.kernel.org --- tools/testing/scatterlist/Makefile | 30 +++++++++ tools/testing/scatterlist/linux/mm.h | 125 +++++++++++++++++++++++++++++++++++ tools/testing/scatterlist/main.c | 112 +++++++++++++++++++++++++++++++ 3 files changed, 267 insertions(+) create mode 100644 tools/testing/scatterlist/Makefile create mode 100644 tools/testing/scatterlist/linux/mm.h create mode 100644 tools/testing/scatterlist/main.c diff --git a/tools/testing/scatterlist/Makefile b/tools/testing/scatterlist/Makefile new file mode 100644 index 000000000000..0867e0ef32d6 --- /dev/null +++ b/tools/testing/scatterlist/Makefile @@ -0,0 +1,30 @@ +CFLAGS += -I. -I../../include -g -O2 -Wall -fsanitize=address +LDFLAGS += -fsanitize=address +TARGETS = main +OFILES = main.o scatterlist.o + +ifeq ($(BUILD), 32) + CFLAGS += -m32 + LDFLAGS += -m32 +endif + +targets: include $(TARGETS) + +main: $(OFILES) + +clean: + $(RM) $(TARGETS) $(OFILES) scatterlist.c linux/scatterlist.h linux/highmem.h linux/kmemleak.h asm/io.h + @rmdir asm + +scatterlist.c: ../../../lib/scatterlist.c + @sed -e 's/^static //' -e 's/__always_inline //' -e 's/inline //' < $< > $@ + +.PHONY: include + +include: ../../../include/linux/scatterlist.h + @mkdir -p linux + @mkdir -p asm + @touch asm/io.h + @touch linux/highmem.h + @touch linux/kmemleak.h + @cp $< linux/scatterlist.h diff --git a/tools/testing/scatterlist/linux/mm.h b/tools/testing/scatterlist/linux/mm.h new file mode 100644 index 000000000000..ccbb248ebdc1 --- /dev/null +++ b/tools/testing/scatterlist/linux/mm.h @@ -0,0 +1,125 @@ +#ifndef _LINUX_MM_H +#define _LINUX_MM_H + +#include +#include +#include +#include +#include +#include + +typedef unsigned long dma_addr_t; + +#define unlikely + +#define BUG_ON(x) assert(!(x)) + +#define WARN_ON(condition) ({ \ + int __ret_warn_on = !!(condition); \ + unlikely(__ret_warn_on); \ +}) + +#define WARN_ON_ONCE(condition) ({ \ + int __ret_warn_on = !!(condition); \ + if (unlikely(__ret_warn_on)) \ + assert(0); \ + unlikely(__ret_warn_on); \ +}) + +#define PAGE_SIZE (4096) +#define PAGE_SHIFT (12) +#define PAGE_MASK (~(PAGE_SIZE-1)) + +#define __ALIGN_KERNEL(x, a) __ALIGN_KERNEL_MASK(x, (typeof(x))(a) - 1) +#define __ALIGN_KERNEL_MASK(x, mask) (((x) + (mask)) & ~(mask)) +#define ALIGN(x, a) __ALIGN_KERNEL((x), (a)) + +#define PAGE_ALIGN(addr) ALIGN(addr, PAGE_SIZE) + +#define offset_in_page(p) ((unsigned long)(p) & ~PAGE_MASK) + +#define virt_to_page(x) ((void *)x) +#define page_address(x) ((void *)x) + +static inline unsigned long page_to_phys(struct page *page) +{ + assert(0); + + return 0; +} + +#define page_to_pfn(page) ((unsigned long)(page) / PAGE_SIZE) +#define pfn_to_page(pfn) (void *)((pfn) * PAGE_SIZE) +#define nth_page(page,n) pfn_to_page(page_to_pfn((page)) + (n)) + +#define __min(t1, t2, min1, min2, x, y) ({ \ + t1 min1 = (x); \ + t2 min2 = (y); \ + (void) (&min1 == &min2); \ + min1 < min2 ? min1 : min2; }) + +#define ___PASTE(a,b) a##b +#define __PASTE(a,b) ___PASTE(a,b) + +#define __UNIQUE_ID(prefix) __PASTE(__PASTE(__UNIQUE_ID_, prefix), __COUNTER__) + +#define min(x, y) \ + __min(typeof(x), typeof(y), \ + __UNIQUE_ID(min1_), __UNIQUE_ID(min2_), \ + x, y) + +#define min_t(type, x, y) \ + __min(type, type, \ + __UNIQUE_ID(min1_), __UNIQUE_ID(min2_), \ + x, y) + +#define preemptible() (1) + +static inline void *kmap(struct page *page) +{ + assert(0); + + return NULL; +} + +static inline void *kmap_atomic(struct page *page) +{ + assert(0); + + return NULL; +} + +static inline void kunmap(void *addr) +{ + assert(0); +} + +static inline void kunmap_atomic(void *addr) +{ + assert(0); +} + +static inline unsigned long __get_free_page(unsigned int flags) +{ + return (unsigned long)malloc(PAGE_SIZE); +} + +static inline void free_page(unsigned long page) +{ + free((void *)page); +} + +static inline void *kmalloc(unsigned int size, unsigned int flags) +{ + return malloc(size); +} + +#define kfree(x) free(x) + +#define kmemleak_alloc(a, b, c, d) +#define kmemleak_free(a) + +#define PageSlab(p) (0) +#define flush_kernel_dcache_page(p) + +#endif diff --git a/tools/testing/scatterlist/main.c b/tools/testing/scatterlist/main.c new file mode 100644 index 000000000000..edf9b2960734 --- /dev/null +++ b/tools/testing/scatterlist/main.c @@ -0,0 +1,112 @@ +#include +#include + +#include + +#define MAX_PAGES (64) + +static unsigned +_set_pages(struct page **pages, const unsigned *array, unsigned num) +{ + unsigned int i; + + assert(num < MAX_PAGES); + + for (i = 0; i < num; i++) + pages[i] = (struct page *)(unsigned long) + ((1 + array[i]) * PAGE_SIZE); + + return num; +} + +#define set_pages(p, a) _set_pages((p), (a), sizeof(a) / sizeof(a[0])) + +#define check_and_free(_st, _ret, _nents) \ +{ \ + assert((_ret) == 0); \ + assert((_st)->nents == _nents); \ + assert((_st)->orig_nents == _nents); \ + sg_free_table(_st); \ +} + +static int +alloc_tbl(struct sg_table *st, struct page **pages, unsigned nr_pages, + unsigned offset, unsigned size, unsigned max) +{ + return __sg_alloc_table_from_pages(st, pages, nr_pages, offset, size, + max, GFP_KERNEL); +} + +int main(void) +{ + const unsigned int sgmax = SCATTERLIST_MAX_SEGMENT; + struct page *pages[MAX_PAGES]; + struct sg_table st; + int ret; + + ret = set_pages(pages, ((unsigned []){ 0 })); + ret = alloc_tbl(&st, pages, ret, 0, ret * PAGE_SIZE, PAGE_SIZE + 1); + assert(ret == -EINVAL); + + ret = set_pages(pages, ((unsigned []){ 0 })); + ret = alloc_tbl(&st, pages, ret, 0, ret * PAGE_SIZE, 0); + assert(ret == -EINVAL); + + ret = set_pages(pages, ((unsigned []){ 0 })); + ret = alloc_tbl(&st, pages, ret, 0, ret * PAGE_SIZE, sgmax); + check_and_free(&st, ret, 1); + + ret = set_pages(pages, ((unsigned []){ 0 })); + ret = alloc_tbl(&st, pages, ret, 0, ret, sgmax); + check_and_free(&st, ret, 1); + + ret = set_pages(pages, ((unsigned []){ 0, 1 })); + ret = alloc_tbl(&st, pages, ret, 0, ret * PAGE_SIZE, sgmax); + check_and_free(&st, ret, 1); + + ret = set_pages(pages, ((unsigned []){ 0, 2 })); + ret = alloc_tbl(&st, pages, ret, 0, ret * PAGE_SIZE, sgmax); + check_and_free(&st, ret, 2); + + ret = set_pages(pages, ((unsigned []){ 0, 1, 3 })); + ret = alloc_tbl(&st, pages, ret, 0, ret * PAGE_SIZE, sgmax); + check_and_free(&st, ret, 2); + + ret = set_pages(pages, ((unsigned []){ 0, 1, 3, 4 })); + ret = alloc_tbl(&st, pages, ret, 0, ret * PAGE_SIZE, sgmax); + check_and_free(&st, ret, 2); + + ret = set_pages(pages, ((unsigned []){ 0, 1, 3, 4, 5 })); + ret = alloc_tbl(&st, pages, ret, 0, ret * PAGE_SIZE, sgmax); + check_and_free(&st, ret, 2); + + ret = set_pages(pages, ((unsigned []){ 0, 1, 3, 4, 6 })); + ret = alloc_tbl(&st, pages, ret, 0, ret * PAGE_SIZE, sgmax); + check_and_free(&st, ret, 3); + + ret = set_pages(pages, ((unsigned []){ 0, 2, 4, 6, 8 })); + ret = alloc_tbl(&st, pages, ret, 0, ret * PAGE_SIZE, sgmax); + check_and_free(&st, ret, 5); + + ret = set_pages(pages, ((unsigned []){ 0, 1, 2, 3, 4 })); + ret = alloc_tbl(&st, pages, ret, 0, ret * PAGE_SIZE, sgmax); + check_and_free(&st, ret, 1); + + ret = set_pages(pages, ((unsigned []){ 0, 1, 2, 3, 4 })); + ret = alloc_tbl(&st, pages, ret, 0, ret * PAGE_SIZE, 2 * PAGE_SIZE); + check_and_free(&st, ret, 3); + + ret = set_pages(pages, ((unsigned []){ 0, 1, 2, 3, 4, 5})); + ret = alloc_tbl(&st, pages, ret, 0, ret * PAGE_SIZE, 2 * PAGE_SIZE); + check_and_free(&st, ret, 3); + + ret = set_pages(pages, ((unsigned []){ 0, 2, 3, 4, 5, 6})); + ret = alloc_tbl(&st, pages, ret, 0, ret * PAGE_SIZE, 2 * PAGE_SIZE); + check_and_free(&st, ret, 4); + + ret = set_pages(pages, ((unsigned []){ 0, 1, 3, 4, 5, 6})); + ret = alloc_tbl(&st, pages, ret, 0, ret * PAGE_SIZE, 2 * PAGE_SIZE); + check_and_free(&st, ret, 3); + + return 0; +} -- 2.9.4 From mboxrd@z Thu Jan 1 00:00:00 1970 From: Tvrtko Ursulin Subject: [PATCH 5/5] tools/testing/scatterlist: Test new __sg_alloc_table_from_pages Date: Mon, 31 Jul 2017 19:55:12 +0100 Message-ID: <20170731185512.20010-5-tvrtko.ursulin@linux.intel.com> References: <20170731185512.20010-1-tvrtko.ursulin@linux.intel.com> Mime-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Return-path: Received: from mail-wm0-x242.google.com (mail-wm0-x242.google.com [IPv6:2a00:1450:400c:c09::242]) by gabe.freedesktop.org (Postfix) with ESMTPS id 614F86E9C7 for ; Mon, 31 Jul 2017 18:55:25 +0000 (UTC) Received: by mail-wm0-x242.google.com with SMTP id y206so14042188wmd.5 for ; Mon, 31 Jul 2017 11:55:25 -0700 (PDT) In-Reply-To: <20170731185512.20010-1-tvrtko.ursulin@linux.intel.com> List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Errors-To: intel-gfx-bounces@lists.freedesktop.org Sender: "Intel-gfx" To: Intel-gfx@lists.freedesktop.org Cc: linux-kernel@vger.kernel.org List-Id: intel-gfx@lists.freedesktop.org RnJvbTogVHZydGtvIFVyc3VsaW4gPHR2cnRrby51cnN1bGluQGludGVsLmNvbT4KCkV4ZXJjaXNl IHRoZSBuZXcgX19zZ19hbGxvY190YWJsZV9mcm9tX3BhZ2VzIEFQSSAoYW5kIHRocm91Z2gKaXQg YWxzbyB0aGUgb2xkIHNnX2FsbG9jX3RhYmxlX2Zyb21fcGFnZXMpLCBjaGVja2luZyB0aGF0IHRo ZQpjcmVhdGVkIHRhYmxlIGhhcyB0aGUgZXhwZWN0ZWQgbnVtYmVyIG9mIHNlZ21lbnRzIGRlcGVu ZGluZyBvbgp0aGUgc2VxdWVuY2Ugb2YgaW5wdXQgcGFnZXMgYW5kIG90aGVyIGNvbmRpdGlvbnMu CgpTaWduZWQtb2ZmLWJ5OiBUdnJ0a28gVXJzdWxpbiA8dHZydGtvLnVyc3VsaW5AaW50ZWwuY29t PgpDYzogQ2hyaXMgV2lsc29uIDxjaHJpc0BjaHJpcy13aWxzb24uY28udWs+CkNjOiBsaW51eC1r ZXJuZWxAdmdlci5rZXJuZWwub3JnCi0tLQogdG9vbHMvdGVzdGluZy9zY2F0dGVybGlzdC9NYWtl ZmlsZSAgIHwgIDMwICsrKysrKysrKwogdG9vbHMvdGVzdGluZy9zY2F0dGVybGlzdC9saW51eC9t bS5oIHwgMTI1ICsrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrKysrCiB0b29scy90ZXN0 aW5nL3NjYXR0ZXJsaXN0L21haW4uYyAgICAgfCAxMTIgKysrKysrKysrKysrKysrKysrKysrKysr KysrKysrKwogMyBmaWxlcyBjaGFuZ2VkLCAyNjcgaW5zZXJ0aW9ucygrKQogY3JlYXRlIG1vZGUg MTAwNjQ0IHRvb2xzL3Rlc3Rpbmcvc2NhdHRlcmxpc3QvTWFrZWZpbGUKIGNyZWF0ZSBtb2RlIDEw MDY0NCB0b29scy90ZXN0aW5nL3NjYXR0ZXJsaXN0L2xpbnV4L21tLmgKIGNyZWF0ZSBtb2RlIDEw MDY0NCB0b29scy90ZXN0aW5nL3NjYXR0ZXJsaXN0L21haW4uYwoKZGlmZiAtLWdpdCBhL3Rvb2xz L3Rlc3Rpbmcvc2NhdHRlcmxpc3QvTWFrZWZpbGUgYi90b29scy90ZXN0aW5nL3NjYXR0ZXJsaXN0 L01ha2VmaWxlCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uMDg2N2Uw ZWYzMmQ2Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvdGVzdGluZy9zY2F0dGVybGlzdC9NYWtl ZmlsZQpAQCAtMCwwICsxLDMwIEBACitDRkxBR1MgKz0gLUkuIC1JLi4vLi4vaW5jbHVkZSAtZyAt TzIgLVdhbGwgLWZzYW5pdGl6ZT1hZGRyZXNzCitMREZMQUdTICs9IC1mc2FuaXRpemU9YWRkcmVz cworVEFSR0VUUyA9IG1haW4KK09GSUxFUyA9IG1haW4ubyBzY2F0dGVybGlzdC5vCisKK2lmZXEg KCQoQlVJTEQpLCAzMikKKyAgICAgICAgQ0ZMQUdTICs9IC1tMzIKKyAgICAgICAgTERGTEFHUyAr PSAtbTMyCitlbmRpZgorCit0YXJnZXRzOiBpbmNsdWRlICQoVEFSR0VUUykKKworbWFpbjogJChP RklMRVMpCisKK2NsZWFuOgorCSQoUk0pICQoVEFSR0VUUykgJChPRklMRVMpIHNjYXR0ZXJsaXN0 LmMgbGludXgvc2NhdHRlcmxpc3QuaCBsaW51eC9oaWdobWVtLmggbGludXgva21lbWxlYWsuaCBh c20vaW8uaAorCUBybWRpciBhc20KKworc2NhdHRlcmxpc3QuYzogLi4vLi4vLi4vbGliL3NjYXR0 ZXJsaXN0LmMKKwlAc2VkIC1lICdzL15zdGF0aWMgLy8nIC1lICdzL19fYWx3YXlzX2lubGluZSAv LycgLWUgJ3MvaW5saW5lIC8vJyA8ICQ8ID4gJEAKKworLlBIT05ZOiBpbmNsdWRlCisKK2luY2x1 ZGU6IC4uLy4uLy4uL2luY2x1ZGUvbGludXgvc2NhdHRlcmxpc3QuaAorCUBta2RpciAtcCBsaW51 eAorCUBta2RpciAtcCBhc20KKwlAdG91Y2ggYXNtL2lvLmgKKwlAdG91Y2ggbGludXgvaGlnaG1l bS5oCisJQHRvdWNoIGxpbnV4L2ttZW1sZWFrLmgKKwlAY3AgJDwgbGludXgvc2NhdHRlcmxpc3Qu aApkaWZmIC0tZ2l0IGEvdG9vbHMvdGVzdGluZy9zY2F0dGVybGlzdC9saW51eC9tbS5oIGIvdG9v bHMvdGVzdGluZy9zY2F0dGVybGlzdC9saW51eC9tbS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMC4uY2NiYjI0OGViZGMxCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMv dGVzdGluZy9zY2F0dGVybGlzdC9saW51eC9tbS5oCkBAIC0wLDAgKzEsMTI1IEBACisjaWZuZGVm IF9MSU5VWF9NTV9ICisjZGVmaW5lIF9MSU5VWF9NTV9ICisKKyNpbmNsdWRlIDxhc3NlcnQuaD4K KyNpbmNsdWRlIDxzdHJpbmcuaD4KKyNpbmNsdWRlIDxzdGRsaWIuaD4KKyNpbmNsdWRlIDxlcnJu by5oPgorI2luY2x1ZGUgPGxpbWl0cy5oPgorI2luY2x1ZGUgPHN0ZGlvLmg+CisKK3R5cGVkZWYg dW5zaWduZWQgbG9uZyBkbWFfYWRkcl90OworCisjZGVmaW5lIHVubGlrZWx5CisKKyNkZWZpbmUg QlVHX09OKHgpIGFzc2VydCghKHgpKQorCisjZGVmaW5lIFdBUk5fT04oY29uZGl0aW9uKSAoeyAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBcCisgICAgICAgIGludCBf X3JldF93YXJuX29uID0gISEoY29uZGl0aW9uKTsgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBcCisgICAgICAgIHVubGlrZWx5KF9fcmV0X3dhcm5fb24pOyAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICBcCit9KQorCisjZGVmaW5lIFdBUk5fT05fT05DRShjb25kaXRp b24pICh7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgICAgICBpbnQgX19yZXRf d2Fybl9vbiA9ICEhKGNvbmRpdGlvbik7ICAgICAgICAgICAgICAgICAgICAgIFwKKyAgICAgICAg aWYgKHVubGlrZWx5KF9fcmV0X3dhcm5fb24pKSAgICAgICAgICAgICAgICAgICAgICAgICAgICBc CisgICAgICAgICAgICAgICAgYXNzZXJ0KDApOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgXAorICAgICAgICB1bmxpa2VseShfX3JldF93YXJuX29uKTsgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIFwKK30pCisKKyNkZWZpbmUgUEFHRV9TSVpFCSg0MDk2KQorI2Rl ZmluZSBQQUdFX1NISUZUCSgxMikKKyNkZWZpbmUgUEFHRV9NQVNLCSh+KFBBR0VfU0laRS0xKSkK KworI2RlZmluZSBfX0FMSUdOX0tFUk5FTCh4LCBhKSAgICAgICAgICAgIF9fQUxJR05fS0VSTkVM X01BU0soeCwgKHR5cGVvZih4KSkoYSkgLSAxKQorI2RlZmluZSBfX0FMSUdOX0tFUk5FTF9NQVNL KHgsIG1hc2spICAgICgoKHgpICsgKG1hc2spKSAmIH4obWFzaykpCisjZGVmaW5lIEFMSUdOKHgs IGEpICAgICAgICAgICAgIF9fQUxJR05fS0VSTkVMKCh4KSwgKGEpKQorCisjZGVmaW5lIFBBR0Vf QUxJR04oYWRkcikgQUxJR04oYWRkciwgUEFHRV9TSVpFKQorCisjZGVmaW5lIG9mZnNldF9pbl9w YWdlKHApCSgodW5zaWduZWQgbG9uZykocCkgJiB+UEFHRV9NQVNLKQorCisjZGVmaW5lIHZpcnRf dG9fcGFnZSh4KQkoKHZvaWQgKil4KQorI2RlZmluZSBwYWdlX2FkZHJlc3MoeCkJKCh2b2lkICop eCkKKworc3RhdGljIGlubGluZSB1bnNpZ25lZCBsb25nIHBhZ2VfdG9fcGh5cyhzdHJ1Y3QgcGFn ZSAqcGFnZSkKK3sKKwlhc3NlcnQoMCk7CisKKwlyZXR1cm4gMDsKK30KKworI2RlZmluZSBwYWdl X3RvX3BmbihwYWdlKSAoKHVuc2lnbmVkIGxvbmcpKHBhZ2UpIC8gUEFHRV9TSVpFKQorI2RlZmlu ZSBwZm5fdG9fcGFnZShwZm4pICh2b2lkICopKChwZm4pICogUEFHRV9TSVpFKQorI2RlZmluZSBu dGhfcGFnZShwYWdlLG4pIHBmbl90b19wYWdlKHBhZ2VfdG9fcGZuKChwYWdlKSkgKyAobikpCisK KyNkZWZpbmUgX19taW4odDEsIHQyLCBtaW4xLCBtaW4yLCB4LCB5KSAoeyAgICAgICAgICAgICAg XAorICAgICAgICB0MSBtaW4xID0gKHgpOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICBcCisgICAgICAgIHQyIG1pbjIgPSAoeSk7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIFwKKyAgICAgICAgKHZvaWQpICgmbWluMSA9PSAmbWluMik7ICAgICAgICAgICAgICAgICAg ICAgICAgXAorICAgICAgICBtaW4xIDwgbWluMiA/IG1pbjEgOiBtaW4yOyB9KQorCisjZGVmaW5l IF9fX1BBU1RFKGEsYikgYSMjYgorI2RlZmluZSBfX1BBU1RFKGEsYikgX19fUEFTVEUoYSxiKQor CisjZGVmaW5lIF9fVU5JUVVFX0lEKHByZWZpeCkgX19QQVNURShfX1BBU1RFKF9fVU5JUVVFX0lE XywgcHJlZml4KSwgX19DT1VOVEVSX18pCisKKyNkZWZpbmUgbWluKHgsIHkpICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgXAorICAgICAgICBfX21pbih0eXBlb2YoeCksIHR5 cGVvZih5KSwgICAgICAgICAgICAgICAgICAgICBcCisgICAgICAgICAgICAgIF9fVU5JUVVFX0lE KG1pbjFfKSwgX19VTklRVUVfSUQobWluMl8pLCAgIFwKKyAgICAgICAgICAgICAgeCwgeSkKKwor I2RlZmluZSBtaW5fdCh0eXBlLCB4LCB5KSAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBc CisgICAgICAgIF9fbWluKHR5cGUsIHR5cGUsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IFwKKyAgICAgICAgICAgICAgX19VTklRVUVfSUQobWluMV8pLCBfX1VOSVFVRV9JRChtaW4yXyks ICAgXAorICAgICAgICAgICAgICB4LCB5KQorCisjZGVmaW5lIHByZWVtcHRpYmxlKCkgKDEpCisK K3N0YXRpYyBpbmxpbmUgdm9pZCAqa21hcChzdHJ1Y3QgcGFnZSAqcGFnZSkKK3sKKwlhc3NlcnQo MCk7CisKKwlyZXR1cm4gTlVMTDsKK30KKworc3RhdGljIGlubGluZSB2b2lkICprbWFwX2F0b21p YyhzdHJ1Y3QgcGFnZSAqcGFnZSkKK3sKKwlhc3NlcnQoMCk7CisKKwlyZXR1cm4gTlVMTDsKK30K Kworc3RhdGljIGlubGluZSB2b2lkIGt1bm1hcCh2b2lkICphZGRyKQoreworCWFzc2VydCgwKTsK K30KKworc3RhdGljIGlubGluZSB2b2lkIGt1bm1hcF9hdG9taWModm9pZCAqYWRkcikKK3sKKwlh c3NlcnQoMCk7Cit9CisKK3N0YXRpYyBpbmxpbmUgdW5zaWduZWQgbG9uZyBfX2dldF9mcmVlX3Bh Z2UodW5zaWduZWQgaW50IGZsYWdzKQoreworCXJldHVybiAodW5zaWduZWQgbG9uZyltYWxsb2Mo UEFHRV9TSVpFKTsKK30KKworc3RhdGljIGlubGluZSB2b2lkIGZyZWVfcGFnZSh1bnNpZ25lZCBs b25nIHBhZ2UpCit7CisJZnJlZSgodm9pZCAqKXBhZ2UpOworfQorCitzdGF0aWMgaW5saW5lIHZv aWQgKmttYWxsb2ModW5zaWduZWQgaW50IHNpemUsIHVuc2lnbmVkIGludCBmbGFncykKK3sKKwly ZXR1cm4gbWFsbG9jKHNpemUpOworfQorCisjZGVmaW5lIGtmcmVlKHgpIGZyZWUoeCkKKworI2Rl ZmluZSBrbWVtbGVha19hbGxvYyhhLCBiLCBjLCBkKQorI2RlZmluZSBrbWVtbGVha19mcmVlKGEp CisKKyNkZWZpbmUgUGFnZVNsYWIocCkgKDApCisjZGVmaW5lIGZsdXNoX2tlcm5lbF9kY2FjaGVf cGFnZShwKQorCisjZW5kaWYKZGlmZiAtLWdpdCBhL3Rvb2xzL3Rlc3Rpbmcvc2NhdHRlcmxpc3Qv bWFpbi5jIGIvdG9vbHMvdGVzdGluZy9zY2F0dGVybGlzdC9tYWluLmMKbmV3IGZpbGUgbW9kZSAx MDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi5lZGY5YjI5NjA3MzQKLS0tIC9kZXYvbnVsbAorKysg Yi90b29scy90ZXN0aW5nL3NjYXR0ZXJsaXN0L21haW4uYwpAQCAtMCwwICsxLDExMiBAQAorI2lu Y2x1ZGUgPHN0ZGlvLmg+CisjaW5jbHVkZSA8YXNzZXJ0Lmg+CisKKyNpbmNsdWRlIDxsaW51eC9z Y2F0dGVybGlzdC5oPgorCisjZGVmaW5lIE1BWF9QQUdFUyAoNjQpCisKK3N0YXRpYyB1bnNpZ25l ZAorX3NldF9wYWdlcyhzdHJ1Y3QgcGFnZSAqKnBhZ2VzLCBjb25zdCB1bnNpZ25lZCAqYXJyYXks IHVuc2lnbmVkIG51bSkKK3sKKwl1bnNpZ25lZCBpbnQgaTsKKworCWFzc2VydChudW0gPCBNQVhf UEFHRVMpOworCisJZm9yIChpID0gMDsgaSA8IG51bTsgaSsrKQorCQlwYWdlc1tpXSA9IChzdHJ1 Y3QgcGFnZSAqKSh1bnNpZ25lZCBsb25nKQorCQkJICAgKCgxICsgYXJyYXlbaV0pICogUEFHRV9T SVpFKTsKKworCXJldHVybiBudW07Cit9CisKKyNkZWZpbmUgc2V0X3BhZ2VzKHAsIGEpIF9zZXRf cGFnZXMoKHApLCAoYSksIHNpemVvZihhKSAvIHNpemVvZihhWzBdKSkKKworI2RlZmluZSBjaGVj a19hbmRfZnJlZShfc3QsIF9yZXQsIF9uZW50cykgXAoreyBcCisJYXNzZXJ0KChfcmV0KSA9PSAw KTsgXAorCWFzc2VydCgoX3N0KS0+bmVudHMgPT0gX25lbnRzKTsgXAorCWFzc2VydCgoX3N0KS0+ b3JpZ19uZW50cyA9PSBfbmVudHMpOyBcCisJc2dfZnJlZV90YWJsZShfc3QpOyBcCit9CisKK3N0 YXRpYyBpbnQKK2FsbG9jX3RibChzdHJ1Y3Qgc2dfdGFibGUgKnN0LCBzdHJ1Y3QgcGFnZSAqKnBh Z2VzLCB1bnNpZ25lZCBucl9wYWdlcywKKwkgIHVuc2lnbmVkIG9mZnNldCwgdW5zaWduZWQgc2l6 ZSwgdW5zaWduZWQgbWF4KQoreworCXJldHVybiBfX3NnX2FsbG9jX3RhYmxlX2Zyb21fcGFnZXMo c3QsIHBhZ2VzLCBucl9wYWdlcywgb2Zmc2V0LCBzaXplLAorCQkJCQkgICBtYXgsIEdGUF9LRVJO RUwpOworfQorCitpbnQgbWFpbih2b2lkKQoreworCWNvbnN0IHVuc2lnbmVkIGludCBzZ21heCA9 IFNDQVRURVJMSVNUX01BWF9TRUdNRU5UOworCXN0cnVjdCBwYWdlICpwYWdlc1tNQVhfUEFHRVNd OworCXN0cnVjdCBzZ190YWJsZSBzdDsKKwlpbnQgcmV0OworCisJcmV0ID0gc2V0X3BhZ2VzKHBh Z2VzLCAoKHVuc2lnbmVkIFtdKXsgMCB9KSk7CisJcmV0ID0gYWxsb2NfdGJsKCZzdCwgcGFnZXMs IHJldCwgMCwgcmV0ICogUEFHRV9TSVpFLCBQQUdFX1NJWkUgKyAxKTsKKwlhc3NlcnQocmV0ID09 IC1FSU5WQUwpOworCisJcmV0ID0gc2V0X3BhZ2VzKHBhZ2VzLCAoKHVuc2lnbmVkIFtdKXsgMCB9 KSk7CisJcmV0ID0gYWxsb2NfdGJsKCZzdCwgcGFnZXMsIHJldCwgMCwgcmV0ICogUEFHRV9TSVpF LCAwKTsKKwlhc3NlcnQocmV0ID09IC1FSU5WQUwpOworCisJcmV0ID0gc2V0X3BhZ2VzKHBhZ2Vz LCAoKHVuc2lnbmVkIFtdKXsgMCB9KSk7CisJcmV0ID0gYWxsb2NfdGJsKCZzdCwgcGFnZXMsIHJl dCwgMCwgcmV0ICogUEFHRV9TSVpFLCBzZ21heCk7CisJY2hlY2tfYW5kX2ZyZWUoJnN0LCByZXQs IDEpOworCisJcmV0ID0gc2V0X3BhZ2VzKHBhZ2VzLCAoKHVuc2lnbmVkIFtdKXsgMCB9KSk7CisJ cmV0ID0gYWxsb2NfdGJsKCZzdCwgcGFnZXMsIHJldCwgMCwgcmV0LCBzZ21heCk7CisJY2hlY2tf YW5kX2ZyZWUoJnN0LCByZXQsIDEpOworCisJcmV0ID0gc2V0X3BhZ2VzKHBhZ2VzLCAoKHVuc2ln bmVkIFtdKXsgMCwgMSB9KSk7CisJcmV0ID0gYWxsb2NfdGJsKCZzdCwgcGFnZXMsIHJldCwgMCwg cmV0ICogUEFHRV9TSVpFLCBzZ21heCk7CisJY2hlY2tfYW5kX2ZyZWUoJnN0LCByZXQsIDEpOwor CisJcmV0ID0gc2V0X3BhZ2VzKHBhZ2VzLCAoKHVuc2lnbmVkIFtdKXsgMCwgMiB9KSk7CisJcmV0 ID0gYWxsb2NfdGJsKCZzdCwgcGFnZXMsIHJldCwgMCwgcmV0ICogUEFHRV9TSVpFLCBzZ21heCk7 CisJY2hlY2tfYW5kX2ZyZWUoJnN0LCByZXQsIDIpOworCisJcmV0ID0gc2V0X3BhZ2VzKHBhZ2Vz LCAoKHVuc2lnbmVkIFtdKXsgMCwgMSwgMyB9KSk7CisJcmV0ID0gYWxsb2NfdGJsKCZzdCwgcGFn ZXMsIHJldCwgMCwgcmV0ICogUEFHRV9TSVpFLCBzZ21heCk7CisJY2hlY2tfYW5kX2ZyZWUoJnN0 LCByZXQsIDIpOworCisJcmV0ID0gc2V0X3BhZ2VzKHBhZ2VzLCAoKHVuc2lnbmVkIFtdKXsgMCwg MSwgMywgNCB9KSk7CisJcmV0ID0gYWxsb2NfdGJsKCZzdCwgcGFnZXMsIHJldCwgMCwgcmV0ICog UEFHRV9TSVpFLCBzZ21heCk7CisJY2hlY2tfYW5kX2ZyZWUoJnN0LCByZXQsIDIpOworCisJcmV0 ID0gc2V0X3BhZ2VzKHBhZ2VzLCAoKHVuc2lnbmVkIFtdKXsgMCwgMSwgMywgNCwgNSB9KSk7CisJ cmV0ID0gYWxsb2NfdGJsKCZzdCwgcGFnZXMsIHJldCwgMCwgcmV0ICogUEFHRV9TSVpFLCBzZ21h eCk7CisJY2hlY2tfYW5kX2ZyZWUoJnN0LCByZXQsIDIpOworCisJcmV0ID0gc2V0X3BhZ2VzKHBh Z2VzLCAoKHVuc2lnbmVkIFtdKXsgMCwgMSwgMywgNCwgNiB9KSk7CisJcmV0ID0gYWxsb2NfdGJs KCZzdCwgcGFnZXMsIHJldCwgMCwgcmV0ICogUEFHRV9TSVpFLCBzZ21heCk7CisJY2hlY2tfYW5k X2ZyZWUoJnN0LCByZXQsIDMpOworCisJcmV0ID0gc2V0X3BhZ2VzKHBhZ2VzLCAoKHVuc2lnbmVk IFtdKXsgMCwgMiwgNCwgNiwgOCB9KSk7CisJcmV0ID0gYWxsb2NfdGJsKCZzdCwgcGFnZXMsIHJl dCwgMCwgcmV0ICogUEFHRV9TSVpFLCBzZ21heCk7CisJY2hlY2tfYW5kX2ZyZWUoJnN0LCByZXQs IDUpOworCisJcmV0ID0gc2V0X3BhZ2VzKHBhZ2VzLCAoKHVuc2lnbmVkIFtdKXsgMCwgMSwgMiwg MywgNCB9KSk7CisJcmV0ID0gYWxsb2NfdGJsKCZzdCwgcGFnZXMsIHJldCwgMCwgcmV0ICogUEFH RV9TSVpFLCBzZ21heCk7CisJY2hlY2tfYW5kX2ZyZWUoJnN0LCByZXQsIDEpOworCisJcmV0ID0g c2V0X3BhZ2VzKHBhZ2VzLCAoKHVuc2lnbmVkIFtdKXsgMCwgMSwgMiwgMywgNCB9KSk7CisJcmV0 ID0gYWxsb2NfdGJsKCZzdCwgcGFnZXMsIHJldCwgMCwgcmV0ICogUEFHRV9TSVpFLCAyICogUEFH RV9TSVpFKTsKKwljaGVja19hbmRfZnJlZSgmc3QsIHJldCwgMyk7CisKKwlyZXQgPSBzZXRfcGFn ZXMocGFnZXMsICgodW5zaWduZWQgW10peyAwLCAxLCAyLCAzLCA0LCA1fSkpOworCXJldCA9IGFs bG9jX3RibCgmc3QsIHBhZ2VzLCByZXQsIDAsIHJldCAqIFBBR0VfU0laRSwgMiAqIFBBR0VfU0la RSk7CisJY2hlY2tfYW5kX2ZyZWUoJnN0LCByZXQsIDMpOworCisJcmV0ID0gc2V0X3BhZ2VzKHBh Z2VzLCAoKHVuc2lnbmVkIFtdKXsgMCwgMiwgMywgNCwgNSwgNn0pKTsKKwlyZXQgPSBhbGxvY190 YmwoJnN0LCBwYWdlcywgcmV0LCAwLCByZXQgKiBQQUdFX1NJWkUsIDIgKiBQQUdFX1NJWkUpOwor CWNoZWNrX2FuZF9mcmVlKCZzdCwgcmV0LCA0KTsKKworCXJldCA9IHNldF9wYWdlcyhwYWdlcywg KCh1bnNpZ25lZCBbXSl7IDAsIDEsIDMsIDQsIDUsIDZ9KSk7CisJcmV0ID0gYWxsb2NfdGJsKCZz dCwgcGFnZXMsIHJldCwgMCwgcmV0ICogUEFHRV9TSVpFLCAyICogUEFHRV9TSVpFKTsKKwljaGVj a19hbmRfZnJlZSgmc3QsIHJldCwgMyk7CisKKwlyZXR1cm4gMDsKK30KLS0gCjIuOS40CgpfX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fXwpJbnRlbC1nZnggbWFp bGluZyBsaXN0CkludGVsLWdmeEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKaHR0cHM6Ly9saXN0cy5m cmVlZGVza3RvcC5vcmcvbWFpbG1hbi9saXN0aW5mby9pbnRlbC1nZngK