From mboxrd@z Thu Jan 1 00:00:00 1970 From: John Stultz Subject: [PATCH v15 5/5] kselftests: Add dma-heap test Date: Wed, 6 Nov 2019 04:22:52 +0000 Message-ID: <20191106042252.72452-6-john.stultz@linaro.org> References: <20191106042252.72452-1-john.stultz@linaro.org> Return-path: In-Reply-To: <20191106042252.72452-1-john.stultz@linaro.org> Sender: linux-kernel-owner@vger.kernel.org To: lkml Cc: John Stultz , Benjamin Gaignard , Sumit Semwal , Liam Mark , Pratik Patel , Brian Starkey , Vincent Donnefort , Sudipto Paul , "Andrew F . Davis" , Christoph Hellwig , Chenbo Feng , Alistair Strachan , Hridya Valsaraju , Sandeep Patil , Hillf Danton , Dave Airlie , dri-devel@lists.freedesktop.org List-Id: dri-devel@lists.freedesktop.org Add very trivial allocation and import test for dma-heaps, utilizing the vgem driver as a test importer. A good chunk of this code taken from: tools/testing/selftests/android/ion/ionmap_test.c Originally by Laura Abbott Cc: Benjamin Gaignard Cc: Sumit Semwal Cc: Liam Mark Cc: Pratik Patel Cc: Brian Starkey Cc: Vincent Donnefort Cc: Sudipto Paul Cc: Andrew F. Davis Cc: Christoph Hellwig Cc: Chenbo Feng Cc: Alistair Strachan Cc: Hridya Valsaraju Cc: Sandeep Patil Cc: Hillf Danton Cc: Dave Airlie Cc: dri-devel@lists.freedesktop.org Reviewed-by: Benjamin Gaignard Reviewed-by: Brian Starkey Acked-by: Sandeep Patil Acked-by: Laura Abbott Tested-by: Ayan Kumar Halder Signed-off-by: John Stultz --- v2: * Switched to use reworked dma-heap apis v3: * Add simple mmap * Utilize dma-buf testdev to test importing v4: * Rework to use vgem * Pass in fd_flags to match interface changes * Skip . and .. dirs v6: * Number of style/cleanups suggested by Brian v7: * Whitespace fixup for checkpatch v8: * More checkpatch whitespace fixups v9: * Better handling error returns out to main, suggested by Brian Starkey * Switch to using snprintf, suggested by Brian v14: * Fix a missing return value * Add calls to test the GET_FEATURES ioctl * Build fix reported by kernel test robot and fixed by Xiao Yang * Minor Makefile cleanups v15: * Remove usage of dropped get_features ioctl --- tools/testing/selftests/dmabuf-heaps/Makefile | 6 + .../selftests/dmabuf-heaps/dmabuf-heap.c | 238 ++++++++++++++++++ 2 files changed, 244 insertions(+) create mode 100644 tools/testing/selftests/dmabuf-heaps/Makefile create mode 100644 tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c diff --git a/tools/testing/selftests/dmabuf-heaps/Makefile b/tools/testing/selftests/dmabuf-heaps/Makefile new file mode 100644 index 000000000000..607c2acd2082 --- /dev/null +++ b/tools/testing/selftests/dmabuf-heaps/Makefile @@ -0,0 +1,6 @@ +# SPDX-License-Identifier: GPL-2.0 +CFLAGS += -static -O3 -Wl,-no-as-needed -Wall -I../../../../usr/include + +TEST_GEN_PROGS = dmabuf-heap + +include ../lib.mk diff --git a/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c b/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c new file mode 100644 index 000000000000..efca067ba96c --- /dev/null +++ b/tools/testing/selftests/dmabuf-heaps/dmabuf-heap.c @@ -0,0 +1,238 @@ +// SPDX-License-Identifier: GPL-2.0 + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include + +#include "../../../../include/uapi/linux/dma-heap.h" + +#define DEVPATH "/dev/dma_heap" + +static int check_vgem(int fd) +{ + drm_version_t version = { 0 }; + char name[5]; + int ret; + + version.name_len = 4; + version.name = name; + + ret = ioctl(fd, DRM_IOCTL_VERSION, &version); + if (ret) + return 0; + + return !strcmp(name, "vgem"); +} + +static int open_vgem(void) +{ + int i, fd; + const char *drmstr = "/dev/dri/card"; + + fd = -1; + for (i = 0; i < 16; i++) { + char name[80]; + + snprintf(name, 80, "%s%u", drmstr, i); + + fd = open(name, O_RDWR); + if (fd < 0) + continue; + + if (!check_vgem(fd)) { + close(fd); + fd = -1; + continue; + } else { + break; + } + } + return fd; +} + +static int import_vgem_fd(int vgem_fd, int dma_buf_fd, uint32_t *handle) +{ + struct drm_prime_handle import_handle = { + .fd = dma_buf_fd, + .flags = 0, + .handle = 0, + }; + int ret; + + ret = ioctl(vgem_fd, DRM_IOCTL_PRIME_FD_TO_HANDLE, &import_handle); + if (ret == 0) + *handle = import_handle.handle; + return ret; +} + +static void close_handle(int vgem_fd, uint32_t handle) +{ + struct drm_gem_close close = { + .handle = handle, + }; + + ioctl(vgem_fd, DRM_IOCTL_GEM_CLOSE, &close); +} + +static int dmabuf_heap_open(char *name) +{ + int ret, fd; + char buf[256]; + + ret = snprintf(buf, 256, "%s/%s", DEVPATH, name); + if (ret < 0) { + printf("snprintf failed!\n"); + return ret; + } + + fd = open(buf, O_RDWR); + if (fd < 0) + printf("open %s failed!\n", buf); + return fd; +} + +static int dmabuf_heap_alloc(int fd, size_t len, unsigned int flags, + int *dmabuf_fd) +{ + struct dma_heap_allocation_data data = { + .len = len, + .fd_flags = O_RDWR | O_CLOEXEC, + .heap_flags = flags, + }; + int ret; + + if (!dmabuf_fd) + return -EINVAL; + + ret = ioctl(fd, DMA_HEAP_IOC_ALLOC, &data); + if (ret < 0) + return ret; + *dmabuf_fd = (int)data.fd; + return ret; +} + +static void dmabuf_sync(int fd, int start_stop) +{ + struct dma_buf_sync sync = { + .flags = start_stop | DMA_BUF_SYNC_RW, + }; + int ret; + + ret = ioctl(fd, DMA_BUF_IOCTL_SYNC, &sync); + if (ret) + printf("sync failed %d\n", errno); +} + +#define ONE_MEG (1024 * 1024) + +static int do_test(char *heap_name) +{ + int heap_fd = -1, dmabuf_fd = -1, importer_fd = -1; + uint32_t handle = 0; + void *p = NULL; + int ret; + + printf("Testing heap: %s\n", heap_name); + + heap_fd = dmabuf_heap_open(heap_name); + if (heap_fd < 0) + return -1; + + printf("Allocating 1 MEG\n"); + ret = dmabuf_heap_alloc(heap_fd, ONE_MEG, 0, &dmabuf_fd); + if (ret) { + printf("Allocation Failed!\n"); + ret = -1; + goto out; + } + /* mmap and write a simple pattern */ + p = mmap(NULL, + ONE_MEG, + PROT_READ | PROT_WRITE, + MAP_SHARED, + dmabuf_fd, + 0); + if (p == MAP_FAILED) { + printf("mmap() failed: %m\n"); + ret = -1; + goto out; + } + printf("mmap passed\n"); + + dmabuf_sync(dmabuf_fd, DMA_BUF_SYNC_START); + memset(p, 1, ONE_MEG / 2); + memset((char *)p + ONE_MEG / 2, 0, ONE_MEG / 2); + dmabuf_sync(dmabuf_fd, DMA_BUF_SYNC_END); + + importer_fd = open_vgem(); + if (importer_fd < 0) { + ret = importer_fd; + printf("Failed to open vgem\n"); + goto out; + } + + ret = import_vgem_fd(importer_fd, dmabuf_fd, &handle); + if (ret < 0) { + printf("Failed to import buffer\n"); + goto out; + } + printf("import passed\n"); + + dmabuf_sync(dmabuf_fd, DMA_BUF_SYNC_START); + memset(p, 0xff, ONE_MEG); + dmabuf_sync(dmabuf_fd, DMA_BUF_SYNC_END); + printf("syncs passed\n"); + + close_handle(importer_fd, handle); + ret = 0; + +out: + if (p) + munmap(p, ONE_MEG); + if (importer_fd >= 0) + close(importer_fd); + if (dmabuf_fd >= 0) + close(dmabuf_fd); + if (heap_fd >= 0) + close(heap_fd); + + return ret; +} + +int main(void) +{ + DIR *d; + struct dirent *dir; + int ret = -1; + + d = opendir(DEVPATH); + if (!d) { + printf("No %s directory?\n", DEVPATH); + return -1; + } + + while ((dir = readdir(d)) != NULL) { + if (!strncmp(dir->d_name, ".", 2)) + continue; + if (!strncmp(dir->d_name, "..", 3)) + continue; + + ret = do_test(dir->d_name); + if (ret) + break; + } + closedir(d); + + return ret; +} -- 2.17.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 X-Spam-Level: X-Spam-Status: No, score=-7.0 required=3.0 tests=HEADER_FROM_DIFFERENT_DOMAINS, INCLUDES_PATCH,MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS, UNWANTED_LANGUAGE_BODY,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id CAABAC5DF64 for ; Wed, 6 Nov 2019 04:23:16 +0000 (UTC) Received: from gabe.freedesktop.org (gabe.freedesktop.org [131.252.210.177]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 97C552084C for ; Wed, 6 Nov 2019 04:23:16 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 97C552084C Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=linaro.org Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=dri-devel-bounces@lists.freedesktop.org Received: from gabe.freedesktop.org (localhost [127.0.0.1]) by gabe.freedesktop.org (Postfix) with ESMTP id 0C6506EBEE; Wed, 6 Nov 2019 04:23:16 +0000 (UTC) Received: from mail-pl1-x644.google.com (mail-pl1-x644.google.com [IPv6:2607:f8b0:4864:20::644]) by gabe.freedesktop.org (Postfix) with ESMTPS id 161406EBEB for ; Wed, 6 Nov 2019 04:23:08 +0000 (UTC) Received: by mail-pl1-x644.google.com with SMTP id l4so5565050plt.13 for ; Tue, 05 Nov 2019 20:23:08 -0800 (PST) X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references; bh=UtTKts7n6PwB/KSUdkueiRv1jM81Y5uAXuxP+Ek2MAU=; b=PF2qKXvrG4KjunxL2wfgV6S5PO48smswco0RNFPyhMoy6XTU5iEnGr8eZHGOFUn4gH WVGAY/KSYeLnW8uRnI+iBqh+eBPMnkxjzfz+NeqvK+no9fL+1+BB31saSJrY0wWoxXHO 1bceKmzL2ATtf0Yu1HAWH/wOJ7DqINx/SCTG1+0ETEs5LBlinNiu8+QCAdx1w7tyqU0j QiD+bTuWaPRIwyNOxXYkvN1ra6R3mLPV/9+cDIkz+4/nSrZY/m30YTe21tAg/cM+VFho cdbDAvlYLWWhK3V1TmrroAJkAg0IB580aRuxG2xrdRH7v8jRoKiYmFvddzdDwfBITXMQ 6hFw== X-Gm-Message-State: APjAAAWYYDK7Fta/VRBTus6MmCwiF5zTCA/235jR9vMyAgEs+2X0o9+S 9fUGrLVWtH9UCBBFRuVEudsaqg== X-Google-Smtp-Source: APXvYqxyDRrtA0GraHS6OeTmC5cm+tpYnMLVkj2j3n9+AfoWSwLV4JEpLjaz2cTZIBShxeGJcOfftA== X-Received: by 2002:a17:902:322:: with SMTP id 31mr409718pld.293.1573014187513; Tue, 05 Nov 2019 20:23:07 -0800 (PST) Received: from localhost.localdomain (c-67-170-172-113.hsd1.or.comcast.net. [67.170.172.113]) by smtp.gmail.com with ESMTPSA id n15sm23730289pfq.146.2019.11.05.20.23.06 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 05 Nov 2019 20:23:07 -0800 (PST) From: John Stultz To: lkml Subject: [PATCH v15 5/5] kselftests: Add dma-heap test Date: Wed, 6 Nov 2019 04:22:52 +0000 Message-Id: <20191106042252.72452-6-john.stultz@linaro.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20191106042252.72452-1-john.stultz@linaro.org> References: <20191106042252.72452-1-john.stultz@linaro.org> X-Mailman-Original-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references; bh=UtTKts7n6PwB/KSUdkueiRv1jM81Y5uAXuxP+Ek2MAU=; b=TNerTCHdR/xBMOsoi2KWvCd5wto/Yno6XdqjK6FABEeKXtahodPeaWep+1SW5Quiln jt8R0OrM42dMW7h/4Xytu+ifBAwjfK/K+xaB4StGggJSl/GFeE1A15UV+qc7dRgOONge KFvX1PM2VGgAT1hk9v39Ox3ZxNhmYPkG3HCGUhEQWba/ym5/r+Pq6x0azkUfrxLfv4QE dw24QAOTz0Vp3B4DyjXBbJdwA7K6lXpNDZuXY3WE+kbcjJq8XqhJ3vgSSC5gXIQ4AzMj 3+Z50L/ucPOlBlvmJu7S88huuIfH4sqevRAfC1h4s7ohHH0O4C6naJKXgB4BTHWIp4D8 xhSA== X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.23 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Hillf Danton , Sandeep Patil , Vincent Donnefort , Chenbo Feng , Alistair Strachan , Liam Mark , Christoph Hellwig , dri-devel@lists.freedesktop.org, "Andrew F . Davis" , Hridya Valsaraju , Sudipto Paul , Pratik Patel MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" Message-ID: <20191106042252.uXU0240jdOoS-G2ssM20PhXqO1qVpkrZKr88OxRr1nE@z> QWRkIHZlcnkgdHJpdmlhbCBhbGxvY2F0aW9uIGFuZCBpbXBvcnQgdGVzdCBmb3IgZG1hLWhlYXBz LAp1dGlsaXppbmcgdGhlIHZnZW0gZHJpdmVyIGFzIGEgdGVzdCBpbXBvcnRlci4KCkEgZ29vZCBj aHVuayBvZiB0aGlzIGNvZGUgdGFrZW4gZnJvbToKICB0b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9h bmRyb2lkL2lvbi9pb25tYXBfdGVzdC5jCiAgT3JpZ2luYWxseSBieSBMYXVyYSBBYmJvdHQgPGxh YmJvdHRAcmVkaGF0LmNvbT4KCkNjOiBCZW5qYW1pbiBHYWlnbmFyZCA8YmVuamFtaW4uZ2FpZ25h cmRAbGluYXJvLm9yZz4KQ2M6IFN1bWl0IFNlbXdhbCA8c3VtaXQuc2Vtd2FsQGxpbmFyby5vcmc+ CkNjOiBMaWFtIE1hcmsgPGxtYXJrQGNvZGVhdXJvcmEub3JnPgpDYzogUHJhdGlrIFBhdGVsIDxw cmF0aWtwQGNvZGVhdXJvcmEub3JnPgpDYzogQnJpYW4gU3RhcmtleSA8QnJpYW4uU3RhcmtleUBh cm0uY29tPgpDYzogVmluY2VudCBEb25uZWZvcnQgPFZpbmNlbnQuRG9ubmVmb3J0QGFybS5jb20+ CkNjOiBTdWRpcHRvIFBhdWwgPFN1ZGlwdG8uUGF1bEBhcm0uY29tPgpDYzogQW5kcmV3IEYuIERh dmlzIDxhZmRAdGkuY29tPgpDYzogQ2hyaXN0b3BoIEhlbGx3aWcgPGhjaEBpbmZyYWRlYWQub3Jn PgpDYzogQ2hlbmJvIEZlbmcgPGZlbmdjQGdvb2dsZS5jb20+CkNjOiBBbGlzdGFpciBTdHJhY2hh biA8YXN0cmFjaGFuQGdvb2dsZS5jb20+CkNjOiBIcmlkeWEgVmFsc2FyYWp1IDxocmlkeWFAZ29v Z2xlLmNvbT4KQ2M6IFNhbmRlZXAgUGF0aWwgPHNzcGF0aWxAZ29vZ2xlLmNvbT4KQ2M6IEhpbGxm IERhbnRvbiA8aGRhbnRvbkBzaW5hLmNvbT4KQ2M6IERhdmUgQWlybGllIDxhaXJsaWVkQGdtYWls LmNvbT4KQ2M6IGRyaS1kZXZlbEBsaXN0cy5mcmVlZGVza3RvcC5vcmcKUmV2aWV3ZWQtYnk6IEJl bmphbWluIEdhaWduYXJkIDxiZW5qYW1pbi5nYWlnbmFyZEBsaW5hcm8ub3JnPgpSZXZpZXdlZC1i eTogQnJpYW4gU3RhcmtleSA8YnJpYW4uc3RhcmtleUBhcm0uY29tPgpBY2tlZC1ieTogU2FuZGVl cCBQYXRpbCA8c3NwYXRpbEBhbmRyb2lkLmNvbT4KQWNrZWQtYnk6IExhdXJhIEFiYm90dCA8bGFi Ym90dEByZWRoYXQuY29tPgpUZXN0ZWQtYnk6IEF5YW4gS3VtYXIgSGFsZGVyIDxheWFuLmhhbGRl ckBhcm0uY29tPgpTaWduZWQtb2ZmLWJ5OiBKb2huIFN0dWx0eiA8am9obi5zdHVsdHpAbGluYXJv Lm9yZz4KLS0tCnYyOgoqIFN3aXRjaGVkIHRvIHVzZSByZXdvcmtlZCBkbWEtaGVhcCBhcGlzCnYz OgoqIEFkZCBzaW1wbGUgbW1hcAoqIFV0aWxpemUgZG1hLWJ1ZiB0ZXN0ZGV2IHRvIHRlc3QgaW1w b3J0aW5nCnY0OgoqIFJld29yayB0byB1c2UgdmdlbQoqIFBhc3MgaW4gZmRfZmxhZ3MgdG8gbWF0 Y2ggaW50ZXJmYWNlIGNoYW5nZXMKKiBTa2lwIC4gYW5kIC4uIGRpcnMKdjY6CiogTnVtYmVyIG9m IHN0eWxlL2NsZWFudXBzIHN1Z2dlc3RlZCBieSBCcmlhbgp2NzoKKiBXaGl0ZXNwYWNlIGZpeHVw IGZvciBjaGVja3BhdGNoCnY4OgoqIE1vcmUgY2hlY2twYXRjaCB3aGl0ZXNwYWNlIGZpeHVwcwp2 OToKKiBCZXR0ZXIgaGFuZGxpbmcgZXJyb3IgcmV0dXJucyBvdXQgdG8gbWFpbiwgc3VnZ2VzdGVk CiAgYnkgQnJpYW4gU3RhcmtleQoqIFN3aXRjaCB0byB1c2luZyBzbnByaW50Ziwgc3VnZ2VzdGVk IGJ5IEJyaWFuCnYxNDoKKiBGaXggYSBtaXNzaW5nIHJldHVybiB2YWx1ZQoqIEFkZCBjYWxscyB0 byB0ZXN0IHRoZSBHRVRfRkVBVFVSRVMgaW9jdGwKKiBCdWlsZCBmaXggcmVwb3J0ZWQgYnkga2Vy bmVsIHRlc3Qgcm9ib3QgPGxrcEBpbnRlbC5jb20+CiAgYW5kIGZpeGVkIGJ5IFhpYW8gWWFuZyA8 aWNlX3lhbmd4aWFvQDE2My5jb20+CiogTWlub3IgTWFrZWZpbGUgY2xlYW51cHMKdjE1OgoqIFJl bW92ZSB1c2FnZSBvZiBkcm9wcGVkIGdldF9mZWF0dXJlcyBpb2N0bAotLS0KIHRvb2xzL3Rlc3Rp bmcvc2VsZnRlc3RzL2RtYWJ1Zi1oZWFwcy9NYWtlZmlsZSB8ICAgNiArCiAuLi4vc2VsZnRlc3Rz L2RtYWJ1Zi1oZWFwcy9kbWFidWYtaGVhcC5jICAgICAgfCAyMzggKysrKysrKysrKysrKysrKysr CiAyIGZpbGVzIGNoYW5nZWQsIDI0NCBpbnNlcnRpb25zKCspCiBjcmVhdGUgbW9kZSAxMDA2NDQg dG9vbHMvdGVzdGluZy9zZWxmdGVzdHMvZG1hYnVmLWhlYXBzL01ha2VmaWxlCiBjcmVhdGUgbW9k ZSAxMDA2NDQgdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMvZG1hYnVmLWhlYXBzL2RtYWJ1Zi1oZWFw LmMKCmRpZmYgLS1naXQgYS90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9kbWFidWYtaGVhcHMvTWFr ZWZpbGUgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9kbWFidWYtaGVhcHMvTWFrZWZpbGUKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwLi42MDdjMmFjZDIwODIKLS0tIC9k ZXYvbnVsbAorKysgYi90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9kbWFidWYtaGVhcHMvTWFrZWZp bGUKQEAgLTAsMCArMSw2IEBACisjIFNQRFgtTGljZW5zZS1JZGVudGlmaWVyOiBHUEwtMi4wCitD RkxBR1MgKz0gLXN0YXRpYyAtTzMgLVdsLC1uby1hcy1uZWVkZWQgLVdhbGwgLUkuLi8uLi8uLi8u Li91c3IvaW5jbHVkZQorCitURVNUX0dFTl9QUk9HUyA9IGRtYWJ1Zi1oZWFwCisKK2luY2x1ZGUg Li4vbGliLm1rCmRpZmYgLS1naXQgYS90b29scy90ZXN0aW5nL3NlbGZ0ZXN0cy9kbWFidWYtaGVh cHMvZG1hYnVmLWhlYXAuYyBiL3Rvb2xzL3Rlc3Rpbmcvc2VsZnRlc3RzL2RtYWJ1Zi1oZWFwcy9k bWFidWYtaGVhcC5jCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMC4uZWZj YTA2N2JhOTZjCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvdGVzdGluZy9zZWxmdGVzdHMvZG1h YnVmLWhlYXBzL2RtYWJ1Zi1oZWFwLmMKQEAgLTAsMCArMSwyMzggQEAKKy8vIFNQRFgtTGljZW5z ZS1JZGVudGlmaWVyOiBHUEwtMi4wCisKKyNpbmNsdWRlIDxkaXJlbnQuaD4KKyNpbmNsdWRlIDxl cnJuby5oPgorI2luY2x1ZGUgPGZjbnRsLmg+CisjaW5jbHVkZSA8c3RkaW8uaD4KKyNpbmNsdWRl IDxzdGRsaWIuaD4KKyNpbmNsdWRlIDxzdGRpbnQuaD4KKyNpbmNsdWRlIDxzdHJpbmcuaD4KKyNp bmNsdWRlIDx1bmlzdGQuaD4KKyNpbmNsdWRlIDxzeXMvaW9jdGwuaD4KKyNpbmNsdWRlIDxzeXMv bW1hbi5oPgorI2luY2x1ZGUgPHN5cy90eXBlcy5oPgorCisjaW5jbHVkZSA8bGludXgvZG1hLWJ1 Zi5oPgorI2luY2x1ZGUgPGRybS9kcm0uaD4KKworI2luY2x1ZGUgIi4uLy4uLy4uLy4uL2luY2x1 ZGUvdWFwaS9saW51eC9kbWEtaGVhcC5oIgorCisjZGVmaW5lIERFVlBBVEggIi9kZXYvZG1hX2hl YXAiCisKK3N0YXRpYyBpbnQgY2hlY2tfdmdlbShpbnQgZmQpCit7CisJZHJtX3ZlcnNpb25fdCB2 ZXJzaW9uID0geyAwIH07CisJY2hhciBuYW1lWzVdOworCWludCByZXQ7CisKKwl2ZXJzaW9uLm5h bWVfbGVuID0gNDsKKwl2ZXJzaW9uLm5hbWUgPSBuYW1lOworCisJcmV0ID0gaW9jdGwoZmQsIERS TV9JT0NUTF9WRVJTSU9OLCAmdmVyc2lvbik7CisJaWYgKHJldCkKKwkJcmV0dXJuIDA7CisKKwly ZXR1cm4gIXN0cmNtcChuYW1lLCAidmdlbSIpOworfQorCitzdGF0aWMgaW50IG9wZW5fdmdlbSh2 b2lkKQoreworCWludCBpLCBmZDsKKwljb25zdCBjaGFyICpkcm1zdHIgPSAiL2Rldi9kcmkvY2Fy ZCI7CisKKwlmZCA9IC0xOworCWZvciAoaSA9IDA7IGkgPCAxNjsgaSsrKSB7CisJCWNoYXIgbmFt ZVs4MF07CisKKwkJc25wcmludGYobmFtZSwgODAsICIlcyV1IiwgZHJtc3RyLCBpKTsKKworCQlm ZCA9IG9wZW4obmFtZSwgT19SRFdSKTsKKwkJaWYgKGZkIDwgMCkKKwkJCWNvbnRpbnVlOworCisJ CWlmICghY2hlY2tfdmdlbShmZCkpIHsKKwkJCWNsb3NlKGZkKTsKKwkJCWZkID0gLTE7CisJCQlj b250aW51ZTsKKwkJfSBlbHNlIHsKKwkJCWJyZWFrOworCQl9CisJfQorCXJldHVybiBmZDsKK30K Kworc3RhdGljIGludCBpbXBvcnRfdmdlbV9mZChpbnQgdmdlbV9mZCwgaW50IGRtYV9idWZfZmQs IHVpbnQzMl90ICpoYW5kbGUpCit7CisJc3RydWN0IGRybV9wcmltZV9oYW5kbGUgaW1wb3J0X2hh bmRsZSA9IHsKKwkJLmZkID0gZG1hX2J1Zl9mZCwKKwkJLmZsYWdzID0gMCwKKwkJLmhhbmRsZSA9 IDAsCisJIH07CisJaW50IHJldDsKKworCXJldCA9IGlvY3RsKHZnZW1fZmQsIERSTV9JT0NUTF9Q UklNRV9GRF9UT19IQU5ETEUsICZpbXBvcnRfaGFuZGxlKTsKKwlpZiAocmV0ID09IDApCisJCSpo YW5kbGUgPSBpbXBvcnRfaGFuZGxlLmhhbmRsZTsKKwlyZXR1cm4gcmV0OworfQorCitzdGF0aWMg dm9pZCBjbG9zZV9oYW5kbGUoaW50IHZnZW1fZmQsIHVpbnQzMl90IGhhbmRsZSkKK3sKKwlzdHJ1 Y3QgZHJtX2dlbV9jbG9zZSBjbG9zZSA9IHsKKwkJLmhhbmRsZSA9IGhhbmRsZSwKKwl9OworCisJ aW9jdGwodmdlbV9mZCwgRFJNX0lPQ1RMX0dFTV9DTE9TRSwgJmNsb3NlKTsKK30KKworc3RhdGlj IGludCBkbWFidWZfaGVhcF9vcGVuKGNoYXIgKm5hbWUpCit7CisJaW50IHJldCwgZmQ7CisJY2hh ciBidWZbMjU2XTsKKworCXJldCA9IHNucHJpbnRmKGJ1ZiwgMjU2LCAiJXMvJXMiLCBERVZQQVRI LCBuYW1lKTsKKwlpZiAocmV0IDwgMCkgeworCQlwcmludGYoInNucHJpbnRmIGZhaWxlZCFcbiIp OworCQlyZXR1cm4gcmV0OworCX0KKworCWZkID0gb3BlbihidWYsIE9fUkRXUik7CisJaWYgKGZk IDwgMCkKKwkJcHJpbnRmKCJvcGVuICVzIGZhaWxlZCFcbiIsIGJ1Zik7CisJcmV0dXJuIGZkOwor fQorCitzdGF0aWMgaW50IGRtYWJ1Zl9oZWFwX2FsbG9jKGludCBmZCwgc2l6ZV90IGxlbiwgdW5z aWduZWQgaW50IGZsYWdzLAorCQkJICAgICBpbnQgKmRtYWJ1Zl9mZCkKK3sKKwlzdHJ1Y3QgZG1h X2hlYXBfYWxsb2NhdGlvbl9kYXRhIGRhdGEgPSB7CisJCS5sZW4gPSBsZW4sCisJCS5mZF9mbGFn cyA9IE9fUkRXUiB8IE9fQ0xPRVhFQywKKwkJLmhlYXBfZmxhZ3MgPSBmbGFncywKKwl9OworCWlu dCByZXQ7CisKKwlpZiAoIWRtYWJ1Zl9mZCkKKwkJcmV0dXJuIC1FSU5WQUw7CisKKwlyZXQgPSBp b2N0bChmZCwgRE1BX0hFQVBfSU9DX0FMTE9DLCAmZGF0YSk7CisJaWYgKHJldCA8IDApCisJCXJl dHVybiByZXQ7CisJKmRtYWJ1Zl9mZCA9IChpbnQpZGF0YS5mZDsKKwlyZXR1cm4gcmV0OworfQor CitzdGF0aWMgdm9pZCBkbWFidWZfc3luYyhpbnQgZmQsIGludCBzdGFydF9zdG9wKQoreworCXN0 cnVjdCBkbWFfYnVmX3N5bmMgc3luYyA9IHsKKwkJLmZsYWdzID0gc3RhcnRfc3RvcCB8IERNQV9C VUZfU1lOQ19SVywKKwl9OworCWludCByZXQ7CisKKwlyZXQgPSBpb2N0bChmZCwgRE1BX0JVRl9J T0NUTF9TWU5DLCAmc3luYyk7CisJaWYgKHJldCkKKwkJcHJpbnRmKCJzeW5jIGZhaWxlZCAlZFxu IiwgZXJybm8pOworfQorCisjZGVmaW5lIE9ORV9NRUcgKDEwMjQgKiAxMDI0KQorCitzdGF0aWMg aW50IGRvX3Rlc3QoY2hhciAqaGVhcF9uYW1lKQoreworCWludCBoZWFwX2ZkID0gLTEsIGRtYWJ1 Zl9mZCA9IC0xLCBpbXBvcnRlcl9mZCA9IC0xOworCXVpbnQzMl90IGhhbmRsZSA9IDA7CisJdm9p ZCAqcCA9IE5VTEw7CisJaW50IHJldDsKKworCXByaW50ZigiVGVzdGluZyBoZWFwOiAlc1xuIiwg aGVhcF9uYW1lKTsKKworCWhlYXBfZmQgPSBkbWFidWZfaGVhcF9vcGVuKGhlYXBfbmFtZSk7CisJ aWYgKGhlYXBfZmQgPCAwKQorCQlyZXR1cm4gLTE7CisKKwlwcmludGYoIkFsbG9jYXRpbmcgMSBN RUdcbiIpOworCXJldCA9IGRtYWJ1Zl9oZWFwX2FsbG9jKGhlYXBfZmQsIE9ORV9NRUcsIDAsICZk bWFidWZfZmQpOworCWlmIChyZXQpIHsKKwkJcHJpbnRmKCJBbGxvY2F0aW9uIEZhaWxlZCFcbiIp OworCQlyZXQgPSAtMTsKKwkJZ290byBvdXQ7CisJfQorCS8qIG1tYXAgYW5kIHdyaXRlIGEgc2lt cGxlIHBhdHRlcm4gKi8KKwlwID0gbW1hcChOVUxMLAorCQkgT05FX01FRywKKwkJIFBST1RfUkVB RCB8IFBST1RfV1JJVEUsCisJCSBNQVBfU0hBUkVELAorCQkgZG1hYnVmX2ZkLAorCQkgMCk7CisJ aWYgKHAgPT0gTUFQX0ZBSUxFRCkgeworCQlwcmludGYoIm1tYXAoKSBmYWlsZWQ6ICVtXG4iKTsK KwkJcmV0ID0gLTE7CisJCWdvdG8gb3V0OworCX0KKwlwcmludGYoIm1tYXAgcGFzc2VkXG4iKTsK KworCWRtYWJ1Zl9zeW5jKGRtYWJ1Zl9mZCwgRE1BX0JVRl9TWU5DX1NUQVJUKTsKKwltZW1zZXQo cCwgMSwgT05FX01FRyAvIDIpOworCW1lbXNldCgoY2hhciAqKXAgKyBPTkVfTUVHIC8gMiwgMCwg T05FX01FRyAvIDIpOworCWRtYWJ1Zl9zeW5jKGRtYWJ1Zl9mZCwgRE1BX0JVRl9TWU5DX0VORCk7 CisKKwlpbXBvcnRlcl9mZCA9IG9wZW5fdmdlbSgpOworCWlmIChpbXBvcnRlcl9mZCA8IDApIHsK KwkJcmV0ID0gaW1wb3J0ZXJfZmQ7CisJCXByaW50ZigiRmFpbGVkIHRvIG9wZW4gdmdlbVxuIik7 CisJCWdvdG8gb3V0OworCX0KKworCXJldCA9IGltcG9ydF92Z2VtX2ZkKGltcG9ydGVyX2ZkLCBk bWFidWZfZmQsICZoYW5kbGUpOworCWlmIChyZXQgPCAwKSB7CisJCXByaW50ZigiRmFpbGVkIHRv IGltcG9ydCBidWZmZXJcbiIpOworCQlnb3RvIG91dDsKKwl9CisJcHJpbnRmKCJpbXBvcnQgcGFz c2VkXG4iKTsKKworCWRtYWJ1Zl9zeW5jKGRtYWJ1Zl9mZCwgRE1BX0JVRl9TWU5DX1NUQVJUKTsK KwltZW1zZXQocCwgMHhmZiwgT05FX01FRyk7CisJZG1hYnVmX3N5bmMoZG1hYnVmX2ZkLCBETUFf QlVGX1NZTkNfRU5EKTsKKwlwcmludGYoInN5bmNzIHBhc3NlZFxuIik7CisKKwljbG9zZV9oYW5k bGUoaW1wb3J0ZXJfZmQsIGhhbmRsZSk7CisJcmV0ID0gMDsKKworb3V0OgorCWlmIChwKQorCQlt dW5tYXAocCwgT05FX01FRyk7CisJaWYgKGltcG9ydGVyX2ZkID49IDApCisJCWNsb3NlKGltcG9y dGVyX2ZkKTsKKwlpZiAoZG1hYnVmX2ZkID49IDApCisJCWNsb3NlKGRtYWJ1Zl9mZCk7CisJaWYg KGhlYXBfZmQgPj0gMCkKKwkJY2xvc2UoaGVhcF9mZCk7CisKKwlyZXR1cm4gcmV0OworfQorCitp bnQgbWFpbih2b2lkKQoreworCURJUiAqZDsKKwlzdHJ1Y3QgZGlyZW50ICpkaXI7CisJaW50IHJl dCA9IC0xOworCisJZCA9IG9wZW5kaXIoREVWUEFUSCk7CisJaWYgKCFkKSB7CisJCXByaW50Zigi Tm8gJXMgZGlyZWN0b3J5P1xuIiwgREVWUEFUSCk7CisJCXJldHVybiAtMTsKKwl9CisKKwl3aGls ZSAoKGRpciA9IHJlYWRkaXIoZCkpICE9IE5VTEwpIHsKKwkJaWYgKCFzdHJuY21wKGRpci0+ZF9u YW1lLCAiLiIsIDIpKQorCQkJY29udGludWU7CisJCWlmICghc3RybmNtcChkaXItPmRfbmFtZSwg Ii4uIiwgMykpCisJCQljb250aW51ZTsKKworCQlyZXQgPSBkb190ZXN0KGRpci0+ZF9uYW1lKTsK KwkJaWYgKHJldCkKKwkJCWJyZWFrOworCX0KKwljbG9zZWRpcihkKTsKKworCXJldHVybiByZXQ7 Cit9Ci0tIAoyLjE3LjEKCl9fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19f X19fX19fCmRyaS1kZXZlbCBtYWlsaW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9w Lm9yZwpodHRwczovL2xpc3RzLmZyZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1k ZXZlbA==