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=-12.8 required=3.0 tests=BAYES_00,DKIM_SIGNED, DKIM_VALID,DKIM_VALID_AU,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH, MAILING_LIST_MULTI,SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id DDD7EC4727F for ; Sat, 3 Oct 2020 04:03:09 +0000 (UTC) Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by mail.kernel.org (Postfix) with ESMTP id 9AA37207FF for ; Sat, 3 Oct 2020 04:03:09 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=pass (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="x91paVPF" Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1725804AbgJCEDI (ORCPT ); Sat, 3 Oct 2020 00:03:08 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:39040 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1725730AbgJCEDG (ORCPT ); Sat, 3 Oct 2020 00:03:06 -0400 Received: from mail-pj1-x1041.google.com (mail-pj1-x1041.google.com [IPv6:2607:f8b0:4864:20::1041]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id A0521C0613E2 for ; Fri, 2 Oct 2020 21:03:06 -0700 (PDT) Received: by mail-pj1-x1041.google.com with SMTP id x2so2145901pjk.0 for ; Fri, 02 Oct 2020 21:03:06 -0700 (PDT) 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 :mime-version:content-transfer-encoding; bh=IuKF6WW48YEHCV5GSH/tcw5D/e7OLEfTzOdrRc6wtHY=; b=x91paVPFb6G7oK1ni0qXmGJ3ayJ/22Zz8IsGAEkyMcaJxe+/uaMee8PpMwPnwtdiWR rtuPKnY4DDwTl0BPwWEO3Cr6O0Rn+Y09lV95FXpFcn+Ws0kt7X3GaoRnzr37CyE1rg7G NGNJV+N0HoJn+ZwmuuhrGONcVd5CsSRlereIHcMiJ1mi6bYTtXRTBmBL6JfiHltGVv3i yLr+rxEqcktaVJ/eBHUXG5m6HG0wMr3WliLyONASTHLkYOVBYYIVVfdgVtIDpYRuSx9t 6Em5wYdnfRWwJxew0hvOOG3OBvis/RIqq1Cc8clW/MTuGYQmpnyrzJ/VuSC8m2XBOvL4 x3PA== 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:mime-version:content-transfer-encoding; bh=IuKF6WW48YEHCV5GSH/tcw5D/e7OLEfTzOdrRc6wtHY=; b=aql9tnEJK1t6D/24xZwZ8e78NQT3wxDW5jtMoxescjOnnUEjt2ObFv6YBKEDsaqN5C Kl4JJo7HGhS7MTz89Y0H9RoRfSdvmWLtncanxcMzjKQRHgOO4PUEJDWmqA0q1+LwFJi0 NjjlQNV99yrrb96ptUt/ewpudpmmtp81LdFVBRisuPRxU4sUJ7pzHq+ZXR/+Vwhe4Hw1 H5szSFF8jOiu6MDfXcoxGfXsBw9wBr0381CiTJ3J8oo4KZhXVQDg7lej8Wl9lB+pGQJS On7dHqdUgz5wDozmjtPGcFisepe9uWObCOKU7GsT2FpMacoGJ33sXXIRWd3C6vCQC4NS IK1w== X-Gm-Message-State: AOAM531vKC9yA63nVlYWlD3eFM2dFnr2nehASBmdP5eio6GXKXhgWbBp 04oEIROx1aSQs1iCdrJkWWvvxYxfybXwGg== X-Google-Smtp-Source: ABdhPJxmWKNnKn1ZnvzoG0xdvu5Bdy49rVPU/Lq/QiX+M+CvHIjzjxyXr55yyhURvwMafYqQW6+oYw== X-Received: by 2002:a17:90a:7f8b:: with SMTP id m11mr5894667pjl.121.1601697785820; Fri, 02 Oct 2020 21:03:05 -0700 (PDT) Received: from localhost.localdomain ([2601:1c2:680:1319:692:26ff:feda:3a81]) by smtp.gmail.com with ESMTPSA id 190sm3909290pfy.22.2020.10.02.21.03.03 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 02 Oct 2020 21:03:05 -0700 (PDT) From: John Stultz To: lkml Cc: John Stultz , Sumit Semwal , Liam Mark , Laura Abbott , Brian Starkey , Hridya Valsaraju , Suren Baghdasaryan , Sandeep Patil , Daniel Mentz , Chris Goldsworthy , =?UTF-8?q?=C3=98rjan=20Eide?= , Robin Murphy , Ezequiel Garcia , Simon Ser , James Jones , linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org Subject: [PATCH v3 1/7] dma-buf: system_heap: Rework system heap to use sgtables instead of pagelists Date: Sat, 3 Oct 2020 04:02:51 +0000 Message-Id: <20201003040257.62768-2-john.stultz@linaro.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20201003040257.62768-1-john.stultz@linaro.org> References: <20201003040257.62768-1-john.stultz@linaro.org> MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org In preparation for some patches to optmize the system heap code, rework the dmabuf exporter to utilize sgtables rather then pageslists for tracking the associated pages. This will allow for large order page allocations, as well as more efficient page pooling. In doing so, the system heap stops using the heap-helpers logic which sadly is not quite as generic as I was hoping it to be, so this patch adds heap specific implementations of the dma_buf_ops function handlers. Cc: Sumit Semwal Cc: Liam Mark Cc: Laura Abbott Cc: Brian Starkey Cc: Hridya Valsaraju Cc: Suren Baghdasaryan Cc: Sandeep Patil Cc: Daniel Mentz Cc: Chris Goldsworthy Cc: Ørjan Eide Cc: Robin Murphy Cc: Ezequiel Garcia Cc: Simon Ser Cc: James Jones Cc: linux-media@vger.kernel.org Cc: dri-devel@lists.freedesktop.org Signed-off-by: John Stultz --- v2: * Fix locking issue and an unused return value Reported-by: kernel test robot Julia Lawall * Make system_heap_buf_ops static Reported-by: kernel test robot v3: * Use the new sgtable mapping functions, as Suggested-by: Daniel Mentz --- drivers/dma-buf/heaps/system_heap.c | 344 ++++++++++++++++++++++++---- 1 file changed, 298 insertions(+), 46 deletions(-) diff --git a/drivers/dma-buf/heaps/system_heap.c b/drivers/dma-buf/heaps/system_heap.c index 0bf688e3c023..00ed107b3b76 100644 --- a/drivers/dma-buf/heaps/system_heap.c +++ b/drivers/dma-buf/heaps/system_heap.c @@ -3,7 +3,11 @@ * DMABUF System heap exporter * * Copyright (C) 2011 Google, Inc. - * Copyright (C) 2019 Linaro Ltd. + * Copyright (C) 2019, 2020 Linaro Ltd. + * + * Portions based off of Andrew Davis' SRAM heap: + * Copyright (C) 2019 Texas Instruments Incorporated - http://www.ti.com/ + * Andrew F. Davis */ #include @@ -15,72 +19,321 @@ #include #include #include -#include -#include - -#include "heap-helpers.h" +#include struct dma_heap *sys_heap; -static void system_heap_free(struct heap_helper_buffer *buffer) +struct system_heap_buffer { + struct dma_heap *heap; + struct list_head attachments; + struct mutex lock; + unsigned long len; + struct sg_table sg_table; + int vmap_cnt; + void *vaddr; +}; + +struct dma_heap_attachment { + struct device *dev; + struct sg_table *table; + struct list_head list; +}; + +static struct sg_table *dup_sg_table(struct sg_table *table) { - pgoff_t pg; + struct sg_table *new_table; + int ret, i; + struct scatterlist *sg, *new_sg; + + new_table = kzalloc(sizeof(*new_table), GFP_KERNEL); + if (!new_table) + return ERR_PTR(-ENOMEM); + + ret = sg_alloc_table(new_table, table->orig_nents, GFP_KERNEL); + if (ret) { + kfree(new_table); + return ERR_PTR(-ENOMEM); + } + + new_sg = new_table->sgl; + for_each_sgtable_sg(table, sg, i) { + sg_set_page(new_sg, sg_page(sg), sg->length, sg->offset); + new_sg = sg_next(new_sg); + } + + return new_table; +} + +static int system_heap_attach(struct dma_buf *dmabuf, + struct dma_buf_attachment *attachment) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + struct dma_heap_attachment *a; + struct sg_table *table; + + a = kzalloc(sizeof(*a), GFP_KERNEL); + if (!a) + return -ENOMEM; + + table = dup_sg_table(&buffer->sg_table); + if (IS_ERR(table)) { + kfree(a); + return -ENOMEM; + } + + a->table = table; + a->dev = attachment->dev; + INIT_LIST_HEAD(&a->list); + + attachment->priv = a; + + mutex_lock(&buffer->lock); + list_add(&a->list, &buffer->attachments); + mutex_unlock(&buffer->lock); + + return 0; +} + +static void system_heap_detatch(struct dma_buf *dmabuf, + struct dma_buf_attachment *attachment) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + struct dma_heap_attachment *a = attachment->priv; + + mutex_lock(&buffer->lock); + list_del(&a->list); + mutex_unlock(&buffer->lock); + + sg_free_table(a->table); + kfree(a->table); + kfree(a); +} + +static struct sg_table *system_heap_map_dma_buf(struct dma_buf_attachment *attachment, + enum dma_data_direction direction) +{ + struct dma_heap_attachment *a = attachment->priv; + struct sg_table *table = a->table; + int ret; + + ret = dma_map_sgtable(attachment->dev, table, direction, 0); + if (ret) + return ERR_PTR(ret); + + return table; +} + +static void system_heap_unmap_dma_buf(struct dma_buf_attachment *attachment, + struct sg_table *table, + enum dma_data_direction direction) +{ + dma_unmap_sgtable(attachment->dev, table, direction, 0); +} + +static int system_heap_dma_buf_begin_cpu_access(struct dma_buf *dmabuf, + enum dma_data_direction direction) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + struct dma_heap_attachment *a; + + mutex_lock(&buffer->lock); + + if (buffer->vmap_cnt) + invalidate_kernel_vmap_range(buffer->vaddr, buffer->len); + + list_for_each_entry(a, &buffer->attachments, list) { + dma_sync_sgtable_for_cpu(a->dev, a->table, direction); + } + mutex_unlock(&buffer->lock); + + return 0; +} - for (pg = 0; pg < buffer->pagecount; pg++) - __free_page(buffer->pages[pg]); - kfree(buffer->pages); +static int system_heap_dma_buf_end_cpu_access(struct dma_buf *dmabuf, + enum dma_data_direction direction) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + struct dma_heap_attachment *a; + + mutex_lock(&buffer->lock); + + if (buffer->vmap_cnt) + flush_kernel_vmap_range(buffer->vaddr, buffer->len); + + list_for_each_entry(a, &buffer->attachments, list) { + dma_sync_sgtable_for_device(a->dev, a->table, direction); + } + mutex_unlock(&buffer->lock); + + return 0; +} + +static int system_heap_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + struct sg_table *table = &buffer->sg_table; + unsigned long addr = vma->vm_start; + struct sg_page_iter piter; + int ret; + + for_each_sgtable_page(table, &piter, vma->vm_pgoff) { + struct page *page = sg_page_iter_page(&piter); + + ret = remap_pfn_range(vma, addr, page_to_pfn(page), PAGE_SIZE, + vma->vm_page_prot); + if (ret) + return ret; + addr += PAGE_SIZE; + if (addr >= vma->vm_end) + return 0; + } + return 0; +} + +static void *system_heap_do_vmap(struct system_heap_buffer *buffer) +{ + struct sg_table *table = &buffer->sg_table; + int npages = PAGE_ALIGN(buffer->len) / PAGE_SIZE; + struct page **pages = vmalloc(sizeof(struct page *) * npages); + struct page **tmp = pages; + struct sg_page_iter piter; + void *vaddr; + + if (!pages) + return ERR_PTR(-ENOMEM); + + for_each_sgtable_page(table, &piter, 0) { + WARN_ON(tmp - pages >= npages); + *tmp++ = sg_page_iter_page(&piter); + } + + vaddr = vmap(pages, npages, VM_MAP, PAGE_KERNEL); + vfree(pages); + + if (!vaddr) + return ERR_PTR(-ENOMEM); + + return vaddr; +} + +static void *system_heap_vmap(struct dma_buf *dmabuf) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + void *vaddr; + + mutex_lock(&buffer->lock); + if (buffer->vmap_cnt) { + buffer->vmap_cnt++; + vaddr = buffer->vaddr; + goto out; + } + + vaddr = system_heap_do_vmap(buffer); + if (IS_ERR(vaddr)) + goto out; + + buffer->vaddr = vaddr; + buffer->vmap_cnt++; +out: + mutex_unlock(&buffer->lock); + + return vaddr; +} + +static void system_heap_vunmap(struct dma_buf *dmabuf, void *vaddr) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + + mutex_lock(&buffer->lock); + if (!--buffer->vmap_cnt) { + vunmap(buffer->vaddr); + buffer->vaddr = NULL; + } + mutex_unlock(&buffer->lock); +} + +static void system_heap_dma_buf_release(struct dma_buf *dmabuf) +{ + struct system_heap_buffer *buffer = dmabuf->priv; + struct sg_table *table; + struct scatterlist *sg; + int i; + + table = &buffer->sg_table; + for_each_sgtable_sg(table, sg, i) + __free_page(sg_page(sg)); + sg_free_table(table); kfree(buffer); } +static const struct dma_buf_ops system_heap_buf_ops = { + .attach = system_heap_attach, + .detach = system_heap_detatch, + .map_dma_buf = system_heap_map_dma_buf, + .unmap_dma_buf = system_heap_unmap_dma_buf, + .begin_cpu_access = system_heap_dma_buf_begin_cpu_access, + .end_cpu_access = system_heap_dma_buf_end_cpu_access, + .mmap = system_heap_mmap, + .vmap = system_heap_vmap, + .vunmap = system_heap_vunmap, + .release = system_heap_dma_buf_release, +}; + static int system_heap_allocate(struct dma_heap *heap, unsigned long len, unsigned long fd_flags, unsigned long heap_flags) { - struct heap_helper_buffer *helper_buffer; + struct system_heap_buffer *buffer; + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); struct dma_buf *dmabuf; - int ret = -ENOMEM; + struct sg_table *table; + struct scatterlist *sg; + pgoff_t pagecount; pgoff_t pg; + int i, ret = -ENOMEM; - helper_buffer = kzalloc(sizeof(*helper_buffer), GFP_KERNEL); - if (!helper_buffer) + buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); + if (!buffer) return -ENOMEM; - init_heap_helper_buffer(helper_buffer, system_heap_free); - helper_buffer->heap = heap; - helper_buffer->size = len; - - helper_buffer->pagecount = len / PAGE_SIZE; - helper_buffer->pages = kmalloc_array(helper_buffer->pagecount, - sizeof(*helper_buffer->pages), - GFP_KERNEL); - if (!helper_buffer->pages) { - ret = -ENOMEM; - goto err0; - } + INIT_LIST_HEAD(&buffer->attachments); + mutex_init(&buffer->lock); + buffer->heap = heap; + buffer->len = len; - for (pg = 0; pg < helper_buffer->pagecount; pg++) { + table = &buffer->sg_table; + pagecount = len / PAGE_SIZE; + if (sg_alloc_table(table, pagecount, GFP_KERNEL)) + goto free_buffer; + + sg = table->sgl; + for (pg = 0; pg < pagecount; pg++) { + struct page *page; /* * Avoid trying to allocate memory if the process - * has been killed by by SIGKILL + * has been killed by SIGKILL */ if (fatal_signal_pending(current)) - goto err1; - - helper_buffer->pages[pg] = alloc_page(GFP_KERNEL | __GFP_ZERO); - if (!helper_buffer->pages[pg]) - goto err1; + goto free_pages; + page = alloc_page(GFP_KERNEL | __GFP_ZERO); + if (!page) + goto free_pages; + sg_set_page(sg, page, page_size(page), 0); + sg = sg_next(sg); } /* create the dmabuf */ - dmabuf = heap_helper_export_dmabuf(helper_buffer, fd_flags); + exp_info.ops = &system_heap_buf_ops; + exp_info.size = buffer->len; + exp_info.flags = fd_flags; + exp_info.priv = buffer; + dmabuf = dma_buf_export(&exp_info); if (IS_ERR(dmabuf)) { ret = PTR_ERR(dmabuf); - goto err1; + goto free_pages; } - helper_buffer->dmabuf = dmabuf; - ret = dma_buf_fd(dmabuf, fd_flags); if (ret < 0) { dma_buf_put(dmabuf); @@ -90,12 +343,12 @@ static int system_heap_allocate(struct dma_heap *heap, return ret; -err1: - while (pg > 0) - __free_page(helper_buffer->pages[--pg]); - kfree(helper_buffer->pages); -err0: - kfree(helper_buffer); +free_pages: + for_each_sgtable_sg(table, sg, i) + __free_page(sg_page(sg)); + sg_free_table(table); +free_buffer: + kfree(buffer); return ret; } @@ -107,7 +360,6 @@ static const struct dma_heap_ops system_heap_ops = { static int system_heap_create(void) { struct dma_heap_export_info exp_info; - int ret = 0; exp_info.name = "system"; exp_info.ops = &system_heap_ops; @@ -115,9 +367,9 @@ static int system_heap_create(void) sys_heap = dma_heap_add(&exp_info); if (IS_ERR(sys_heap)) - ret = PTR_ERR(sys_heap); + return PTR_ERR(sys_heap); - return ret; + return 0; } module_init(system_heap_create); MODULE_LICENSE("GPL v2"); -- 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=-12.5 required=3.0 tests=BAYES_00,DKIM_INVALID, DKIM_SIGNED,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_PATCH,MAILING_LIST_MULTI, SIGNED_OFF_BY,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED,USER_AGENT_GIT autolearn=ham autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5B6B6C46466 for ; Sat, 3 Oct 2020 04:03:09 +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 11655207FF for ; Sat, 3 Oct 2020 04:03:08 +0000 (UTC) Authentication-Results: mail.kernel.org; dkim=fail reason="signature verification failed" (2048-bit key) header.d=linaro.org header.i=@linaro.org header.b="x91paVPF" DMARC-Filter: OpenDMARC Filter v1.3.2 mail.kernel.org 11655207FF 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 AB8286EA32; Sat, 3 Oct 2020 04:03:06 +0000 (UTC) Received: from mail-pj1-x1044.google.com (mail-pj1-x1044.google.com [IPv6:2607:f8b0:4864:20::1044]) by gabe.freedesktop.org (Postfix) with ESMTPS id 47D8D6EA32 for ; Sat, 3 Oct 2020 04:03:06 +0000 (UTC) Received: by mail-pj1-x1044.google.com with SMTP id b17so2142912pji.1 for ; Fri, 02 Oct 2020 21:03:06 -0700 (PDT) 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 :mime-version:content-transfer-encoding; bh=IuKF6WW48YEHCV5GSH/tcw5D/e7OLEfTzOdrRc6wtHY=; b=x91paVPFb6G7oK1ni0qXmGJ3ayJ/22Zz8IsGAEkyMcaJxe+/uaMee8PpMwPnwtdiWR rtuPKnY4DDwTl0BPwWEO3Cr6O0Rn+Y09lV95FXpFcn+Ws0kt7X3GaoRnzr37CyE1rg7G NGNJV+N0HoJn+ZwmuuhrGONcVd5CsSRlereIHcMiJ1mi6bYTtXRTBmBL6JfiHltGVv3i yLr+rxEqcktaVJ/eBHUXG5m6HG0wMr3WliLyONASTHLkYOVBYYIVVfdgVtIDpYRuSx9t 6Em5wYdnfRWwJxew0hvOOG3OBvis/RIqq1Cc8clW/MTuGYQmpnyrzJ/VuSC8m2XBOvL4 x3PA== 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:mime-version:content-transfer-encoding; bh=IuKF6WW48YEHCV5GSH/tcw5D/e7OLEfTzOdrRc6wtHY=; b=Cj3yvqQ6AgkClnCOSuwHwvFRG/CnDBmV2XryBhlmjP0JVz9YG1yDNFovaWUHkOuEyt MGeJW/ZGk0IaivO94S5HbJzj6Gw+8ghBZAPiT+J/i+ARabni4QwIwdN90y1fxDBPnQ3Y JaWzgvuY3/nOeNAc4BixzXrpFHNgMjgmZU4PdZA7nduWAlem2g/D6iXkgho7OB/71BEg TN+02pZ70prWJK23zMvwkKp1t5e1M+3NWDiFxuajgGcCITC4P7ZrFrFopqEvE+nfn2Lu b5tlJpYZlodOKl7zirWA+VDSzq9KH6f15MocOIdhGWiKpY2K/aLTKK95G9WAvH14leyZ dBNw== X-Gm-Message-State: AOAM531UKbivGIkPbHWISKp4jGVsxFhWfDH2+BBRxdRFlvTvZrW1PcDv OPgr7X35tixMa5hkev6XkAZ+wQ== X-Google-Smtp-Source: ABdhPJxmWKNnKn1ZnvzoG0xdvu5Bdy49rVPU/Lq/QiX+M+CvHIjzjxyXr55yyhURvwMafYqQW6+oYw== X-Received: by 2002:a17:90a:7f8b:: with SMTP id m11mr5894667pjl.121.1601697785820; Fri, 02 Oct 2020 21:03:05 -0700 (PDT) Received: from localhost.localdomain ([2601:1c2:680:1319:692:26ff:feda:3a81]) by smtp.gmail.com with ESMTPSA id 190sm3909290pfy.22.2020.10.02.21.03.03 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 02 Oct 2020 21:03:05 -0700 (PDT) From: John Stultz To: lkml Subject: [PATCH v3 1/7] dma-buf: system_heap: Rework system heap to use sgtables instead of pagelists Date: Sat, 3 Oct 2020 04:02:51 +0000 Message-Id: <20201003040257.62768-2-john.stultz@linaro.org> X-Mailer: git-send-email 2.17.1 In-Reply-To: <20201003040257.62768-1-john.stultz@linaro.org> References: <20201003040257.62768-1-john.stultz@linaro.org> MIME-Version: 1.0 X-BeenThere: dri-devel@lists.freedesktop.org X-Mailman-Version: 2.1.29 Precedence: list List-Id: Direct Rendering Infrastructure - Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Cc: Sandeep Patil , dri-devel@lists.freedesktop.org, Ezequiel Garcia , Robin Murphy , James Jones , Liam Mark , Laura Abbott , Chris Goldsworthy , Hridya Valsaraju , =?UTF-8?q?=C3=98rjan=20Eide?= , linux-media@vger.kernel.org, Suren Baghdasaryan , Daniel Mentz Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: base64 Errors-To: dri-devel-bounces@lists.freedesktop.org Sender: "dri-devel" SW4gcHJlcGFyYXRpb24gZm9yIHNvbWUgcGF0Y2hlcyB0byBvcHRtaXplIHRoZSBzeXN0ZW0KaGVh cCBjb2RlLCByZXdvcmsgdGhlIGRtYWJ1ZiBleHBvcnRlciB0byB1dGlsaXplIHNndGFibGVzIHJh dGhlcgp0aGVuIHBhZ2VzbGlzdHMgZm9yIHRyYWNraW5nIHRoZSBhc3NvY2lhdGVkIHBhZ2VzLgoK VGhpcyB3aWxsIGFsbG93IGZvciBsYXJnZSBvcmRlciBwYWdlIGFsbG9jYXRpb25zLCBhcyB3ZWxs IGFzCm1vcmUgZWZmaWNpZW50IHBhZ2UgcG9vbGluZy4KCkluIGRvaW5nIHNvLCB0aGUgc3lzdGVt IGhlYXAgc3RvcHMgdXNpbmcgdGhlIGhlYXAtaGVscGVycyBsb2dpYwp3aGljaCBzYWRseSBpcyBu b3QgcXVpdGUgYXMgZ2VuZXJpYyBhcyBJIHdhcyBob3BpbmcgaXQgdG8gYmUsIHNvCnRoaXMgcGF0 Y2ggYWRkcyBoZWFwIHNwZWNpZmljIGltcGxlbWVudGF0aW9ucyBvZiB0aGUgZG1hX2J1Zl9vcHMK ZnVuY3Rpb24gaGFuZGxlcnMuCgpDYzogU3VtaXQgU2Vtd2FsIDxzdW1pdC5zZW13YWxAbGluYXJv Lm9yZz4KQ2M6IExpYW0gTWFyayA8bG1hcmtAY29kZWF1cm9yYS5vcmc+CkNjOiBMYXVyYSBBYmJv dHQgPGxhYmJvdHRAa2VybmVsLm9yZz4KQ2M6IEJyaWFuIFN0YXJrZXkgPEJyaWFuLlN0YXJrZXlA YXJtLmNvbT4KQ2M6IEhyaWR5YSBWYWxzYXJhanUgPGhyaWR5YUBnb29nbGUuY29tPgpDYzogU3Vy ZW4gQmFnaGRhc2FyeWFuIDxzdXJlbmJAZ29vZ2xlLmNvbT4KQ2M6IFNhbmRlZXAgUGF0aWwgPHNz cGF0aWxAZ29vZ2xlLmNvbT4KQ2M6IERhbmllbCBNZW50eiA8ZGFuaWVsbWVudHpAZ29vZ2xlLmNv bT4KQ2M6IENocmlzIEdvbGRzd29ydGh5IDxjZ29sZHN3b0Bjb2RlYXVyb3JhLm9yZz4KQ2M6IMOY cmphbiBFaWRlIDxvcmphbi5laWRlQGFybS5jb20+CkNjOiBSb2JpbiBNdXJwaHkgPHJvYmluLm11 cnBoeUBhcm0uY29tPgpDYzogRXplcXVpZWwgR2FyY2lhIDxlemVxdWllbEBjb2xsYWJvcmEuY29t PgpDYzogU2ltb24gU2VyIDxjb250YWN0QGVtZXJzaW9uLmZyPgpDYzogSmFtZXMgSm9uZXMgPGph am9uZXNAbnZpZGlhLmNvbT4KQ2M6IGxpbnV4LW1lZGlhQHZnZXIua2VybmVsLm9yZwpDYzogZHJp LWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpTaWduZWQtb2ZmLWJ5OiBKb2huIFN0dWx0eiA8 am9obi5zdHVsdHpAbGluYXJvLm9yZz4KLS0tCnYyOgoqIEZpeCBsb2NraW5nIGlzc3VlIGFuZCBh biB1bnVzZWQgcmV0dXJuIHZhbHVlIFJlcG9ydGVkLWJ5OgogICAgIGtlcm5lbCB0ZXN0IHJvYm90 IDxsa3BAaW50ZWwuY29tPgogICAgIEp1bGlhIExhd2FsbCA8anVsaWEubGF3YWxsQGxpcDYuZnI+ CiogTWFrZSBzeXN0ZW1faGVhcF9idWZfb3BzIHN0YXRpYyBSZXBvcnRlZC1ieToKICAgICBrZXJu ZWwgdGVzdCByb2JvdCA8bGtwQGludGVsLmNvbT4KdjM6CiogVXNlIHRoZSBuZXcgc2d0YWJsZSBt YXBwaW5nIGZ1bmN0aW9ucywgYXMgU3VnZ2VzdGVkLWJ5OgogICAgIERhbmllbCBNZW50eiA8ZGFu aWVsbWVudHpAZ29vZ2xlLmNvbT4KLS0tCiBkcml2ZXJzL2RtYS1idWYvaGVhcHMvc3lzdGVtX2hl YXAuYyB8IDM0NCArKysrKysrKysrKysrKysrKysrKysrKystLS0tCiAxIGZpbGUgY2hhbmdlZCwg Mjk4IGluc2VydGlvbnMoKyksIDQ2IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL2RyaXZlcnMv ZG1hLWJ1Zi9oZWFwcy9zeXN0ZW1faGVhcC5jIGIvZHJpdmVycy9kbWEtYnVmL2hlYXBzL3N5c3Rl bV9oZWFwLmMKaW5kZXggMGJmNjg4ZTNjMDIzLi4wMGVkMTA3YjNiNzYgMTAwNjQ0Ci0tLSBhL2Ry aXZlcnMvZG1hLWJ1Zi9oZWFwcy9zeXN0ZW1faGVhcC5jCisrKyBiL2RyaXZlcnMvZG1hLWJ1Zi9o ZWFwcy9zeXN0ZW1faGVhcC5jCkBAIC0zLDcgKzMsMTEgQEAKICAqIERNQUJVRiBTeXN0ZW0gaGVh cCBleHBvcnRlcgogICoKICAqIENvcHlyaWdodCAoQykgMjAxMSBHb29nbGUsIEluYy4KLSAqIENv cHlyaWdodCAoQykgMjAxOSBMaW5hcm8gTHRkLgorICogQ29weXJpZ2h0IChDKSAyMDE5LCAyMDIw IExpbmFybyBMdGQuCisgKgorICogUG9ydGlvbnMgYmFzZWQgb2ZmIG9mIEFuZHJldyBEYXZpcycg U1JBTSBoZWFwOgorICogQ29weXJpZ2h0IChDKSAyMDE5IFRleGFzIEluc3RydW1lbnRzIEluY29y cG9yYXRlZCAtIGh0dHA6Ly93d3cudGkuY29tLworICoJQW5kcmV3IEYuIERhdmlzIDxhZmRAdGku Y29tPgogICovCiAKICNpbmNsdWRlIDxsaW51eC9kbWEtYnVmLmg+CkBAIC0xNSw3MiArMTksMzIx IEBACiAjaW5jbHVkZSA8bGludXgvbW9kdWxlLmg+CiAjaW5jbHVkZSA8bGludXgvc2NhdHRlcmxp c3QuaD4KICNpbmNsdWRlIDxsaW51eC9zbGFiLmg+Ci0jaW5jbHVkZSA8bGludXgvc2NoZWQvc2ln bmFsLmg+Ci0jaW5jbHVkZSA8YXNtL3BhZ2UuaD4KLQotI2luY2x1ZGUgImhlYXAtaGVscGVycy5o IgorI2luY2x1ZGUgPGxpbnV4L3ZtYWxsb2MuaD4KIAogc3RydWN0IGRtYV9oZWFwICpzeXNfaGVh cDsKIAotc3RhdGljIHZvaWQgc3lzdGVtX2hlYXBfZnJlZShzdHJ1Y3QgaGVhcF9oZWxwZXJfYnVm ZmVyICpidWZmZXIpCitzdHJ1Y3Qgc3lzdGVtX2hlYXBfYnVmZmVyIHsKKwlzdHJ1Y3QgZG1hX2hl YXAgKmhlYXA7CisJc3RydWN0IGxpc3RfaGVhZCBhdHRhY2htZW50czsKKwlzdHJ1Y3QgbXV0ZXgg bG9jazsKKwl1bnNpZ25lZCBsb25nIGxlbjsKKwlzdHJ1Y3Qgc2dfdGFibGUgc2dfdGFibGU7CisJ aW50IHZtYXBfY250OworCXZvaWQgKnZhZGRyOworfTsKKworc3RydWN0IGRtYV9oZWFwX2F0dGFj aG1lbnQgeworCXN0cnVjdCBkZXZpY2UgKmRldjsKKwlzdHJ1Y3Qgc2dfdGFibGUgKnRhYmxlOwor CXN0cnVjdCBsaXN0X2hlYWQgbGlzdDsKK307CisKK3N0YXRpYyBzdHJ1Y3Qgc2dfdGFibGUgKmR1 cF9zZ190YWJsZShzdHJ1Y3Qgc2dfdGFibGUgKnRhYmxlKQogewotCXBnb2ZmX3QgcGc7CisJc3Ry dWN0IHNnX3RhYmxlICpuZXdfdGFibGU7CisJaW50IHJldCwgaTsKKwlzdHJ1Y3Qgc2NhdHRlcmxp c3QgKnNnLCAqbmV3X3NnOworCisJbmV3X3RhYmxlID0ga3phbGxvYyhzaXplb2YoKm5ld190YWJs ZSksIEdGUF9LRVJORUwpOworCWlmICghbmV3X3RhYmxlKQorCQlyZXR1cm4gRVJSX1BUUigtRU5P TUVNKTsKKworCXJldCA9IHNnX2FsbG9jX3RhYmxlKG5ld190YWJsZSwgdGFibGUtPm9yaWdfbmVu dHMsIEdGUF9LRVJORUwpOworCWlmIChyZXQpIHsKKwkJa2ZyZWUobmV3X3RhYmxlKTsKKwkJcmV0 dXJuIEVSUl9QVFIoLUVOT01FTSk7CisJfQorCisJbmV3X3NnID0gbmV3X3RhYmxlLT5zZ2w7CisJ Zm9yX2VhY2hfc2d0YWJsZV9zZyh0YWJsZSwgc2csIGkpIHsKKwkJc2dfc2V0X3BhZ2UobmV3X3Nn LCBzZ19wYWdlKHNnKSwgc2ctPmxlbmd0aCwgc2ctPm9mZnNldCk7CisJCW5ld19zZyA9IHNnX25l eHQobmV3X3NnKTsKKwl9CisKKwlyZXR1cm4gbmV3X3RhYmxlOworfQorCitzdGF0aWMgaW50IHN5 c3RlbV9oZWFwX2F0dGFjaChzdHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLAorCQkJICAgICAgc3RydWN0 IGRtYV9idWZfYXR0YWNobWVudCAqYXR0YWNobWVudCkKK3sKKwlzdHJ1Y3Qgc3lzdGVtX2hlYXBf YnVmZmVyICpidWZmZXIgPSBkbWFidWYtPnByaXY7CisJc3RydWN0IGRtYV9oZWFwX2F0dGFjaG1l bnQgKmE7CisJc3RydWN0IHNnX3RhYmxlICp0YWJsZTsKKworCWEgPSBremFsbG9jKHNpemVvZigq YSksIEdGUF9LRVJORUwpOworCWlmICghYSkKKwkJcmV0dXJuIC1FTk9NRU07CisKKwl0YWJsZSA9 IGR1cF9zZ190YWJsZSgmYnVmZmVyLT5zZ190YWJsZSk7CisJaWYgKElTX0VSUih0YWJsZSkpIHsK KwkJa2ZyZWUoYSk7CisJCXJldHVybiAtRU5PTUVNOworCX0KKworCWEtPnRhYmxlID0gdGFibGU7 CisJYS0+ZGV2ID0gYXR0YWNobWVudC0+ZGV2OworCUlOSVRfTElTVF9IRUFEKCZhLT5saXN0KTsK KworCWF0dGFjaG1lbnQtPnByaXYgPSBhOworCisJbXV0ZXhfbG9jaygmYnVmZmVyLT5sb2NrKTsK KwlsaXN0X2FkZCgmYS0+bGlzdCwgJmJ1ZmZlci0+YXR0YWNobWVudHMpOworCW11dGV4X3VubG9j aygmYnVmZmVyLT5sb2NrKTsKKworCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCBzeXN0ZW1f aGVhcF9kZXRhdGNoKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsCisJCQkJc3RydWN0IGRtYV9idWZf YXR0YWNobWVudCAqYXR0YWNobWVudCkKK3sKKwlzdHJ1Y3Qgc3lzdGVtX2hlYXBfYnVmZmVyICpi dWZmZXIgPSBkbWFidWYtPnByaXY7CisJc3RydWN0IGRtYV9oZWFwX2F0dGFjaG1lbnQgKmEgPSBh dHRhY2htZW50LT5wcml2OworCisJbXV0ZXhfbG9jaygmYnVmZmVyLT5sb2NrKTsKKwlsaXN0X2Rl bCgmYS0+bGlzdCk7CisJbXV0ZXhfdW5sb2NrKCZidWZmZXItPmxvY2spOworCisJc2dfZnJlZV90 YWJsZShhLT50YWJsZSk7CisJa2ZyZWUoYS0+dGFibGUpOworCWtmcmVlKGEpOworfQorCitzdGF0 aWMgc3RydWN0IHNnX3RhYmxlICpzeXN0ZW1faGVhcF9tYXBfZG1hX2J1ZihzdHJ1Y3QgZG1hX2J1 Zl9hdHRhY2htZW50ICphdHRhY2htZW50LAorCQkJCQkJZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24g ZGlyZWN0aW9uKQoreworCXN0cnVjdCBkbWFfaGVhcF9hdHRhY2htZW50ICphID0gYXR0YWNobWVu dC0+cHJpdjsKKwlzdHJ1Y3Qgc2dfdGFibGUgKnRhYmxlID0gYS0+dGFibGU7CisJaW50IHJldDsK KworCXJldCA9IGRtYV9tYXBfc2d0YWJsZShhdHRhY2htZW50LT5kZXYsIHRhYmxlLCBkaXJlY3Rp b24sIDApOworCWlmIChyZXQpCisJCXJldHVybiBFUlJfUFRSKHJldCk7CisKKwlyZXR1cm4gdGFi bGU7Cit9CisKK3N0YXRpYyB2b2lkIHN5c3RlbV9oZWFwX3VubWFwX2RtYV9idWYoc3RydWN0IGRt YV9idWZfYXR0YWNobWVudCAqYXR0YWNobWVudCwKKwkJCQkgICAgICBzdHJ1Y3Qgc2dfdGFibGUg KnRhYmxlLAorCQkJCSAgICAgIGVudW0gZG1hX2RhdGFfZGlyZWN0aW9uIGRpcmVjdGlvbikKK3sK KwlkbWFfdW5tYXBfc2d0YWJsZShhdHRhY2htZW50LT5kZXYsIHRhYmxlLCBkaXJlY3Rpb24sIDAp OworfQorCitzdGF0aWMgaW50IHN5c3RlbV9oZWFwX2RtYV9idWZfYmVnaW5fY3B1X2FjY2Vzcyhz dHJ1Y3QgZG1hX2J1ZiAqZG1hYnVmLAorCQkJCQkJZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGly ZWN0aW9uKQoreworCXN0cnVjdCBzeXN0ZW1faGVhcF9idWZmZXIgKmJ1ZmZlciA9IGRtYWJ1Zi0+ cHJpdjsKKwlzdHJ1Y3QgZG1hX2hlYXBfYXR0YWNobWVudCAqYTsKKworCW11dGV4X2xvY2soJmJ1 ZmZlci0+bG9jayk7CisKKwlpZiAoYnVmZmVyLT52bWFwX2NudCkKKwkJaW52YWxpZGF0ZV9rZXJu ZWxfdm1hcF9yYW5nZShidWZmZXItPnZhZGRyLCBidWZmZXItPmxlbik7CisKKwlsaXN0X2Zvcl9l YWNoX2VudHJ5KGEsICZidWZmZXItPmF0dGFjaG1lbnRzLCBsaXN0KSB7CisJCWRtYV9zeW5jX3Nn dGFibGVfZm9yX2NwdShhLT5kZXYsIGEtPnRhYmxlLCBkaXJlY3Rpb24pOworCX0KKwltdXRleF91 bmxvY2soJmJ1ZmZlci0+bG9jayk7CisKKwlyZXR1cm4gMDsKK30KIAotCWZvciAocGcgPSAwOyBw ZyA8IGJ1ZmZlci0+cGFnZWNvdW50OyBwZysrKQotCQlfX2ZyZWVfcGFnZShidWZmZXItPnBhZ2Vz W3BnXSk7Ci0Ja2ZyZWUoYnVmZmVyLT5wYWdlcyk7CitzdGF0aWMgaW50IHN5c3RlbV9oZWFwX2Rt YV9idWZfZW5kX2NwdV9hY2Nlc3Moc3RydWN0IGRtYV9idWYgKmRtYWJ1ZiwKKwkJCQkJICAgICAg ZW51bSBkbWFfZGF0YV9kaXJlY3Rpb24gZGlyZWN0aW9uKQoreworCXN0cnVjdCBzeXN0ZW1faGVh cF9idWZmZXIgKmJ1ZmZlciA9IGRtYWJ1Zi0+cHJpdjsKKwlzdHJ1Y3QgZG1hX2hlYXBfYXR0YWNo bWVudCAqYTsKKworCW11dGV4X2xvY2soJmJ1ZmZlci0+bG9jayk7CisKKwlpZiAoYnVmZmVyLT52 bWFwX2NudCkKKwkJZmx1c2hfa2VybmVsX3ZtYXBfcmFuZ2UoYnVmZmVyLT52YWRkciwgYnVmZmVy LT5sZW4pOworCisJbGlzdF9mb3JfZWFjaF9lbnRyeShhLCAmYnVmZmVyLT5hdHRhY2htZW50cywg bGlzdCkgeworCQlkbWFfc3luY19zZ3RhYmxlX2Zvcl9kZXZpY2UoYS0+ZGV2LCBhLT50YWJsZSwg ZGlyZWN0aW9uKTsKKwl9CisJbXV0ZXhfdW5sb2NrKCZidWZmZXItPmxvY2spOworCisJcmV0dXJu IDA7Cit9CisKK3N0YXRpYyBpbnQgc3lzdGVtX2hlYXBfbW1hcChzdHJ1Y3QgZG1hX2J1ZiAqZG1h YnVmLCBzdHJ1Y3Qgdm1fYXJlYV9zdHJ1Y3QgKnZtYSkKK3sKKwlzdHJ1Y3Qgc3lzdGVtX2hlYXBf YnVmZmVyICpidWZmZXIgPSBkbWFidWYtPnByaXY7CisJc3RydWN0IHNnX3RhYmxlICp0YWJsZSA9 ICZidWZmZXItPnNnX3RhYmxlOworCXVuc2lnbmVkIGxvbmcgYWRkciA9IHZtYS0+dm1fc3RhcnQ7 CisJc3RydWN0IHNnX3BhZ2VfaXRlciBwaXRlcjsKKwlpbnQgcmV0OworCisJZm9yX2VhY2hfc2d0 YWJsZV9wYWdlKHRhYmxlLCAmcGl0ZXIsIHZtYS0+dm1fcGdvZmYpIHsKKwkJc3RydWN0IHBhZ2Ug KnBhZ2UgPSBzZ19wYWdlX2l0ZXJfcGFnZSgmcGl0ZXIpOworCisJCXJldCA9IHJlbWFwX3Bmbl9y YW5nZSh2bWEsIGFkZHIsIHBhZ2VfdG9fcGZuKHBhZ2UpLCBQQUdFX1NJWkUsCisJCQkJICAgICAg dm1hLT52bV9wYWdlX3Byb3QpOworCQlpZiAocmV0KQorCQkJcmV0dXJuIHJldDsKKwkJYWRkciAr PSBQQUdFX1NJWkU7CisJCWlmIChhZGRyID49IHZtYS0+dm1fZW5kKQorCQkJcmV0dXJuIDA7CisJ fQorCXJldHVybiAwOworfQorCitzdGF0aWMgdm9pZCAqc3lzdGVtX2hlYXBfZG9fdm1hcChzdHJ1 Y3Qgc3lzdGVtX2hlYXBfYnVmZmVyICpidWZmZXIpCit7CisJc3RydWN0IHNnX3RhYmxlICp0YWJs ZSA9ICZidWZmZXItPnNnX3RhYmxlOworCWludCBucGFnZXMgPSBQQUdFX0FMSUdOKGJ1ZmZlci0+ bGVuKSAvIFBBR0VfU0laRTsKKwlzdHJ1Y3QgcGFnZSAqKnBhZ2VzID0gdm1hbGxvYyhzaXplb2Yo c3RydWN0IHBhZ2UgKikgKiBucGFnZXMpOworCXN0cnVjdCBwYWdlICoqdG1wID0gcGFnZXM7CisJ c3RydWN0IHNnX3BhZ2VfaXRlciBwaXRlcjsKKwl2b2lkICp2YWRkcjsKKworCWlmICghcGFnZXMp CisJCXJldHVybiBFUlJfUFRSKC1FTk9NRU0pOworCisJZm9yX2VhY2hfc2d0YWJsZV9wYWdlKHRh YmxlLCAmcGl0ZXIsIDApIHsKKwkJV0FSTl9PTih0bXAgLSBwYWdlcyA+PSBucGFnZXMpOworCQkq dG1wKysgPSBzZ19wYWdlX2l0ZXJfcGFnZSgmcGl0ZXIpOworCX0KKworCXZhZGRyID0gdm1hcChw YWdlcywgbnBhZ2VzLCBWTV9NQVAsIFBBR0VfS0VSTkVMKTsKKwl2ZnJlZShwYWdlcyk7CisKKwlp ZiAoIXZhZGRyKQorCQlyZXR1cm4gRVJSX1BUUigtRU5PTUVNKTsKKworCXJldHVybiB2YWRkcjsK K30KKworc3RhdGljIHZvaWQgKnN5c3RlbV9oZWFwX3ZtYXAoc3RydWN0IGRtYV9idWYgKmRtYWJ1 ZikKK3sKKwlzdHJ1Y3Qgc3lzdGVtX2hlYXBfYnVmZmVyICpidWZmZXIgPSBkbWFidWYtPnByaXY7 CisJdm9pZCAqdmFkZHI7CisKKwltdXRleF9sb2NrKCZidWZmZXItPmxvY2spOworCWlmIChidWZm ZXItPnZtYXBfY250KSB7CisJCWJ1ZmZlci0+dm1hcF9jbnQrKzsKKwkJdmFkZHIgPSBidWZmZXIt PnZhZGRyOworCQlnb3RvIG91dDsKKwl9CisKKwl2YWRkciA9IHN5c3RlbV9oZWFwX2RvX3ZtYXAo YnVmZmVyKTsKKwlpZiAoSVNfRVJSKHZhZGRyKSkKKwkJZ290byBvdXQ7CisKKwlidWZmZXItPnZh ZGRyID0gdmFkZHI7CisJYnVmZmVyLT52bWFwX2NudCsrOworb3V0OgorCW11dGV4X3VubG9jaygm YnVmZmVyLT5sb2NrKTsKKworCXJldHVybiB2YWRkcjsKK30KKworc3RhdGljIHZvaWQgc3lzdGVt X2hlYXBfdnVubWFwKHN0cnVjdCBkbWFfYnVmICpkbWFidWYsIHZvaWQgKnZhZGRyKQoreworCXN0 cnVjdCBzeXN0ZW1faGVhcF9idWZmZXIgKmJ1ZmZlciA9IGRtYWJ1Zi0+cHJpdjsKKworCW11dGV4 X2xvY2soJmJ1ZmZlci0+bG9jayk7CisJaWYgKCEtLWJ1ZmZlci0+dm1hcF9jbnQpIHsKKwkJdnVu bWFwKGJ1ZmZlci0+dmFkZHIpOworCQlidWZmZXItPnZhZGRyID0gTlVMTDsKKwl9CisJbXV0ZXhf dW5sb2NrKCZidWZmZXItPmxvY2spOworfQorCitzdGF0aWMgdm9pZCBzeXN0ZW1faGVhcF9kbWFf YnVmX3JlbGVhc2Uoc3RydWN0IGRtYV9idWYgKmRtYWJ1ZikKK3sKKwlzdHJ1Y3Qgc3lzdGVtX2hl YXBfYnVmZmVyICpidWZmZXIgPSBkbWFidWYtPnByaXY7CisJc3RydWN0IHNnX3RhYmxlICp0YWJs ZTsKKwlzdHJ1Y3Qgc2NhdHRlcmxpc3QgKnNnOworCWludCBpOworCisJdGFibGUgPSAmYnVmZmVy LT5zZ190YWJsZTsKKwlmb3JfZWFjaF9zZ3RhYmxlX3NnKHRhYmxlLCBzZywgaSkKKwkJX19mcmVl X3BhZ2Uoc2dfcGFnZShzZykpOworCXNnX2ZyZWVfdGFibGUodGFibGUpOwogCWtmcmVlKGJ1ZmZl cik7CiB9CiAKK3N0YXRpYyBjb25zdCBzdHJ1Y3QgZG1hX2J1Zl9vcHMgc3lzdGVtX2hlYXBfYnVm X29wcyA9IHsKKwkuYXR0YWNoID0gc3lzdGVtX2hlYXBfYXR0YWNoLAorCS5kZXRhY2ggPSBzeXN0 ZW1faGVhcF9kZXRhdGNoLAorCS5tYXBfZG1hX2J1ZiA9IHN5c3RlbV9oZWFwX21hcF9kbWFfYnVm LAorCS51bm1hcF9kbWFfYnVmID0gc3lzdGVtX2hlYXBfdW5tYXBfZG1hX2J1ZiwKKwkuYmVnaW5f Y3B1X2FjY2VzcyA9IHN5c3RlbV9oZWFwX2RtYV9idWZfYmVnaW5fY3B1X2FjY2VzcywKKwkuZW5k X2NwdV9hY2Nlc3MgPSBzeXN0ZW1faGVhcF9kbWFfYnVmX2VuZF9jcHVfYWNjZXNzLAorCS5tbWFw ID0gc3lzdGVtX2hlYXBfbW1hcCwKKwkudm1hcCA9IHN5c3RlbV9oZWFwX3ZtYXAsCisJLnZ1bm1h cCA9IHN5c3RlbV9oZWFwX3Z1bm1hcCwKKwkucmVsZWFzZSA9IHN5c3RlbV9oZWFwX2RtYV9idWZf cmVsZWFzZSwKK307CisKIHN0YXRpYyBpbnQgc3lzdGVtX2hlYXBfYWxsb2NhdGUoc3RydWN0IGRt YV9oZWFwICpoZWFwLAogCQkJCXVuc2lnbmVkIGxvbmcgbGVuLAogCQkJCXVuc2lnbmVkIGxvbmcg ZmRfZmxhZ3MsCiAJCQkJdW5zaWduZWQgbG9uZyBoZWFwX2ZsYWdzKQogewotCXN0cnVjdCBoZWFw X2hlbHBlcl9idWZmZXIgKmhlbHBlcl9idWZmZXI7CisJc3RydWN0IHN5c3RlbV9oZWFwX2J1ZmZl ciAqYnVmZmVyOworCURFRklORV9ETUFfQlVGX0VYUE9SVF9JTkZPKGV4cF9pbmZvKTsKIAlzdHJ1 Y3QgZG1hX2J1ZiAqZG1hYnVmOwotCWludCByZXQgPSAtRU5PTUVNOworCXN0cnVjdCBzZ190YWJs ZSAqdGFibGU7CisJc3RydWN0IHNjYXR0ZXJsaXN0ICpzZzsKKwlwZ29mZl90IHBhZ2Vjb3VudDsK IAlwZ29mZl90IHBnOworCWludCBpLCByZXQgPSAtRU5PTUVNOwogCi0JaGVscGVyX2J1ZmZlciA9 IGt6YWxsb2Moc2l6ZW9mKCpoZWxwZXJfYnVmZmVyKSwgR0ZQX0tFUk5FTCk7Ci0JaWYgKCFoZWxw ZXJfYnVmZmVyKQorCWJ1ZmZlciA9IGt6YWxsb2Moc2l6ZW9mKCpidWZmZXIpLCBHRlBfS0VSTkVM KTsKKwlpZiAoIWJ1ZmZlcikKIAkJcmV0dXJuIC1FTk9NRU07CiAKLQlpbml0X2hlYXBfaGVscGVy X2J1ZmZlcihoZWxwZXJfYnVmZmVyLCBzeXN0ZW1faGVhcF9mcmVlKTsKLQloZWxwZXJfYnVmZmVy LT5oZWFwID0gaGVhcDsKLQloZWxwZXJfYnVmZmVyLT5zaXplID0gbGVuOwotCi0JaGVscGVyX2J1 ZmZlci0+cGFnZWNvdW50ID0gbGVuIC8gUEFHRV9TSVpFOwotCWhlbHBlcl9idWZmZXItPnBhZ2Vz ID0ga21hbGxvY19hcnJheShoZWxwZXJfYnVmZmVyLT5wYWdlY291bnQsCi0JCQkJCSAgICAgc2l6 ZW9mKCpoZWxwZXJfYnVmZmVyLT5wYWdlcyksCi0JCQkJCSAgICAgR0ZQX0tFUk5FTCk7Ci0JaWYg KCFoZWxwZXJfYnVmZmVyLT5wYWdlcykgewotCQlyZXQgPSAtRU5PTUVNOwotCQlnb3RvIGVycjA7 Ci0JfQorCUlOSVRfTElTVF9IRUFEKCZidWZmZXItPmF0dGFjaG1lbnRzKTsKKwltdXRleF9pbml0 KCZidWZmZXItPmxvY2spOworCWJ1ZmZlci0+aGVhcCA9IGhlYXA7CisJYnVmZmVyLT5sZW4gPSBs ZW47CiAKLQlmb3IgKHBnID0gMDsgcGcgPCBoZWxwZXJfYnVmZmVyLT5wYWdlY291bnQ7IHBnKysp IHsKKwl0YWJsZSA9ICZidWZmZXItPnNnX3RhYmxlOworCXBhZ2Vjb3VudCA9IGxlbiAvIFBBR0Vf U0laRTsKKwlpZiAoc2dfYWxsb2NfdGFibGUodGFibGUsIHBhZ2Vjb3VudCwgR0ZQX0tFUk5FTCkp CisJCWdvdG8gZnJlZV9idWZmZXI7CisKKwlzZyA9IHRhYmxlLT5zZ2w7CisJZm9yIChwZyA9IDA7 IHBnIDwgcGFnZWNvdW50OyBwZysrKSB7CisJCXN0cnVjdCBwYWdlICpwYWdlOwogCQkvKgogCQkg KiBBdm9pZCB0cnlpbmcgdG8gYWxsb2NhdGUgbWVtb3J5IGlmIHRoZSBwcm9jZXNzCi0JCSAqIGhh cyBiZWVuIGtpbGxlZCBieSBieSBTSUdLSUxMCisJCSAqIGhhcyBiZWVuIGtpbGxlZCBieSBTSUdL SUxMCiAJCSAqLwogCQlpZiAoZmF0YWxfc2lnbmFsX3BlbmRpbmcoY3VycmVudCkpCi0JCQlnb3Rv IGVycjE7Ci0KLQkJaGVscGVyX2J1ZmZlci0+cGFnZXNbcGddID0gYWxsb2NfcGFnZShHRlBfS0VS TkVMIHwgX19HRlBfWkVSTyk7Ci0JCWlmICghaGVscGVyX2J1ZmZlci0+cGFnZXNbcGddKQotCQkJ Z290byBlcnIxOworCQkJZ290byBmcmVlX3BhZ2VzOworCQlwYWdlID0gYWxsb2NfcGFnZShHRlBf S0VSTkVMIHwgX19HRlBfWkVSTyk7CisJCWlmICghcGFnZSkKKwkJCWdvdG8gZnJlZV9wYWdlczsK KwkJc2dfc2V0X3BhZ2Uoc2csIHBhZ2UsIHBhZ2Vfc2l6ZShwYWdlKSwgMCk7CisJCXNnID0gc2df bmV4dChzZyk7CiAJfQogCiAJLyogY3JlYXRlIHRoZSBkbWFidWYgKi8KLQlkbWFidWYgPSBoZWFw X2hlbHBlcl9leHBvcnRfZG1hYnVmKGhlbHBlcl9idWZmZXIsIGZkX2ZsYWdzKTsKKwlleHBfaW5m by5vcHMgPSAmc3lzdGVtX2hlYXBfYnVmX29wczsKKwlleHBfaW5mby5zaXplID0gYnVmZmVyLT5s ZW47CisJZXhwX2luZm8uZmxhZ3MgPSBmZF9mbGFnczsKKwlleHBfaW5mby5wcml2ID0gYnVmZmVy OworCWRtYWJ1ZiA9IGRtYV9idWZfZXhwb3J0KCZleHBfaW5mbyk7CiAJaWYgKElTX0VSUihkbWFi dWYpKSB7CiAJCXJldCA9IFBUUl9FUlIoZG1hYnVmKTsKLQkJZ290byBlcnIxOworCQlnb3RvIGZy ZWVfcGFnZXM7CiAJfQogCi0JaGVscGVyX2J1ZmZlci0+ZG1hYnVmID0gZG1hYnVmOwotCiAJcmV0 ID0gZG1hX2J1Zl9mZChkbWFidWYsIGZkX2ZsYWdzKTsKIAlpZiAocmV0IDwgMCkgewogCQlkbWFf YnVmX3B1dChkbWFidWYpOwpAQCAtOTAsMTIgKzM0MywxMiBAQCBzdGF0aWMgaW50IHN5c3RlbV9o ZWFwX2FsbG9jYXRlKHN0cnVjdCBkbWFfaGVhcCAqaGVhcCwKIAogCXJldHVybiByZXQ7CiAKLWVy cjE6Ci0Jd2hpbGUgKHBnID4gMCkKLQkJX19mcmVlX3BhZ2UoaGVscGVyX2J1ZmZlci0+cGFnZXNb LS1wZ10pOwotCWtmcmVlKGhlbHBlcl9idWZmZXItPnBhZ2VzKTsKLWVycjA6Ci0Ja2ZyZWUoaGVs cGVyX2J1ZmZlcik7CitmcmVlX3BhZ2VzOgorCWZvcl9lYWNoX3NndGFibGVfc2codGFibGUsIHNn LCBpKQorCQlfX2ZyZWVfcGFnZShzZ19wYWdlKHNnKSk7CisJc2dfZnJlZV90YWJsZSh0YWJsZSk7 CitmcmVlX2J1ZmZlcjoKKwlrZnJlZShidWZmZXIpOwogCiAJcmV0dXJuIHJldDsKIH0KQEAgLTEw Nyw3ICszNjAsNiBAQCBzdGF0aWMgY29uc3Qgc3RydWN0IGRtYV9oZWFwX29wcyBzeXN0ZW1faGVh cF9vcHMgPSB7CiBzdGF0aWMgaW50IHN5c3RlbV9oZWFwX2NyZWF0ZSh2b2lkKQogewogCXN0cnVj dCBkbWFfaGVhcF9leHBvcnRfaW5mbyBleHBfaW5mbzsKLQlpbnQgcmV0ID0gMDsKIAogCWV4cF9p bmZvLm5hbWUgPSAic3lzdGVtIjsKIAlleHBfaW5mby5vcHMgPSAmc3lzdGVtX2hlYXBfb3BzOwpA QCAtMTE1LDkgKzM2Nyw5IEBAIHN0YXRpYyBpbnQgc3lzdGVtX2hlYXBfY3JlYXRlKHZvaWQpCiAK IAlzeXNfaGVhcCA9IGRtYV9oZWFwX2FkZCgmZXhwX2luZm8pOwogCWlmIChJU19FUlIoc3lzX2hl YXApKQotCQlyZXQgPSBQVFJfRVJSKHN5c19oZWFwKTsKKwkJcmV0dXJuIFBUUl9FUlIoc3lzX2hl YXApOwogCi0JcmV0dXJuIHJldDsKKwlyZXR1cm4gMDsKIH0KIG1vZHVsZV9pbml0KHN5c3RlbV9o ZWFwX2NyZWF0ZSk7CiBNT0RVTEVfTElDRU5TRSgiR1BMIHYyIik7Ci0tIAoyLjE3LjEKCl9fX19f X19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fX19fCmRyaS1kZXZlbCBtYWls aW5nIGxpc3QKZHJpLWRldmVsQGxpc3RzLmZyZWVkZXNrdG9wLm9yZwpodHRwczovL2xpc3RzLmZy ZWVkZXNrdG9wLm9yZy9tYWlsbWFuL2xpc3RpbmZvL2RyaS1kZXZlbAo=