From patchwork Tue Aug 2 09:58:39 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Olivier Masse X-Patchwork-Id: 595033 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id BF1BDC00140 for ; Tue, 2 Aug 2022 09:58:57 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236351AbiHBJ64 (ORCPT ); Tue, 2 Aug 2022 05:58:56 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42164 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236168AbiHBJ6y (ORCPT ); Tue, 2 Aug 2022 05:58:54 -0400 Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05on2081.outbound.protection.outlook.com [40.107.20.81]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 300EF4B0C4; Tue, 2 Aug 2022 02:58:53 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=OrAAmiL71WJEZ2sYcwu162xdjsCfJz+mi7d/EviKKbG6KkKoS1cEZp57kwt5M2caT/5fpTNOpTgb/bGZfk1MP9rb8rwBHC8SPthFRrFj7TURgGMrd9QoBcQ7u8Q5JsFC3vO6bdtsyXSx/S0LUY/vvSGuNiDjLNMXH7dWTy34egH02ufX1MJs7m17IdVfV2lAkg077YbuVekb5YocaRpjjt3GrAS7L/4GwAzlPJBaeplyzwHouAFWbDsXMdlyqmPhg/B6N0e8iqmm9WYRa0biiTCbIcrItwyCIu5z+XgqmqhyQlqR1jEYLln5RWwGFow+u4wQ1T2TCMgYxV4rTf1Ywg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=wXOdF3cE6IyAZrsT4wTECkt/yCciaBYokLHgvJeWwJ4=; b=ICi+ZmSbWO9+hfxeVNHXBoztbMHjnE80WQtf34gxy9x71ekVVLh30XZsqSTbzhl7usF+X49k5IFDa77pJ+lT4/JrtHcYvNkAXWsC2ncaUm1tOfAoXML21GdMMtHslNCzMQlysRMJ71JnWcuaHHU46SbuyIRIj8FMszSH1tfsAfZzrHZBX6pabLij5VzR9TALy+oUiAhAE5YrmQy6QdCjnbk89dKwM/aGgIpEqgdHst9Sg6fVCJzMBH6Twe48KwinSc7hgxxIqnRpy+qWwsy6iKn38F920sEucxDUufw3SDivAi2sQSLkAkZj1P/v1l4W/b6oFmBEgqqqHujBt5HfPA== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=nxp.com; dmarc=pass action=none header.from=nxp.com; dkim=pass header.d=nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=wXOdF3cE6IyAZrsT4wTECkt/yCciaBYokLHgvJeWwJ4=; b=RMEpMqfhlhwZTCCuJdBytFnkHQwT2TjkzRvZq6PvpJ9fHE7fMk1Z+YJ+wPLin72I8paK2y/07aO7+3PCARnLBFSovApPgxqoq943CA89gn2ThQAHvy5HxRRtv34iP6cq99TYsNJ9qK8vOCHsvn7adqElJK1h2xSnE2rbwmuruoA= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=nxp.com; Received: from AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) by AS8PR04MB8341.eurprd04.prod.outlook.com (2603:10a6:20b:3b0::24) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5482.16; Tue, 2 Aug 2022 09:58:51 +0000 Received: from AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b]) by AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b%5]) with mapi id 15.20.5482.011; Tue, 2 Aug 2022 09:58:51 +0000 From: Olivier Masse To: sumit.semwal@linaro.org, benjamin.gaignard@collabora.com, Brian.Starkey@arm.com, christian.koenig@amd.com, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org Cc: clement.faure@nxp.com, olivier.masse@nxp.com Subject: [PATCH 1/5] ANDROID: dma-buf: heaps: Add deferred-free-helper library code Date: Tue, 2 Aug 2022 11:58:39 +0200 Message-Id: <20220802095843.14614-2-olivier.masse@nxp.com> X-Mailer: git-send-email 2.25.0 In-Reply-To: <20220802095843.14614-1-olivier.masse@nxp.com> References: <20220802095843.14614-1-olivier.masse@nxp.com> X-ClientProxiedBy: AM3PR07CA0145.eurprd07.prod.outlook.com (2603:10a6:207:8::31) To AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: a0696432-f15e-42e3-edcf-08da746d9994 X-MS-TrafficTypeDiagnostic: AS8PR04MB8341:EE_ X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 4j7UWFRmKfOkhZ9E1PD5Am1xX/1ykjbLzUYkFeGXDQPUQJZWkWm+30KxykNIVXKC2UCJGS9UXrL1PEkNpSwAjkjQSV3rqfohOudMgEoH9ewkbxdtDLdMoNDBuBAtnDazjUkdl3rrXVSeWwIPhOGVPKdoHoJt2etVAMQ7nBZZuarljoF/DZe2oeE+IO4neWq+V2vMCtEKikksoqSakAunl7qkTQd9uQaZgv8K5qoDoHOP1x7iAbukQMIikTgYfGT+QDq1S53EHZ74K9VHoOyc0rz4ibudKKG+YvArmyUu3+rn1qoIU0BR4PmrhNT04tkkIrbgUAgIL8u9Py/gznfjgqIMyzOWdLyCA2hSJWaKfS5y/jo6yiZEQOvCdxQ3NKsuboawC2YBrBo731d880r2TNnwxiV80fJXO6RrJZld6rYJ/9gWRfCmG+vxsECHK7Ku93Ik1ipTTOv2TQnuDC2kJoeBCwK5ad0g7/t9A/Z8VjFiJZXkAC8HuM5GmJuI0CPDH/m6MkgiWKMaWZcvoVe8AwtrL/gOkmg8urq9evZGoe51bnDV0p6Ga50zlXSEZy/79urTHD639M8S9pg2IznlyrlWrkmjqdMkzKRfGyThmgVb6gDN10rGsoYWPHQAze8jgs4BfoW/78MuJYLcMRCoLL6UgQRQIV/VfPbh+BxMSs0eJRZ1gO9/+5dlFezBc3Shf7djOd/jY4XYOxc8o8tjiwEMEGoR+H3T0vNs6YpwsDHAHtTON7dKcEWdSxLXW265/zI+hPdjQhJ2ld+jzYOP9T3bG1lIKQJLk4koeUditEo= X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:AM0PR04MB6737.eurprd04.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230016)(4636009)(396003)(346002)(366004)(136003)(39860400002)(376002)(41300700001)(2906002)(83380400001)(2616005)(86362001)(6666004)(52116002)(6506007)(44832011)(1076003)(36756003)(26005)(6512007)(38100700002)(186003)(38350700002)(6486002)(5660300002)(8676002)(66556008)(66476007)(66946007)(8936002)(478600001)(4326008)(316002); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?q?+hyDQfI/PnFnlP/s5tYkc50HD5bC?= =?utf-8?q?f1hR8LOQoZhOICQm+RpFZBf8D0ylkWekF/bnv88WPOnJYcJaYpo5ZX2u54ovsmkna?= =?utf-8?q?0nCqi2dPGcDcQd7iL77GlWtNYc1xcJ1YNg+RIIKPPn1TNmyGRm49Y6v33VGDsxTze?= =?utf-8?q?giA7+Q5zPxJZbHs0jW+fECWdD99g/+YGOuePjNQthhIb9PnCw8zp80toBH947jgHD?= =?utf-8?q?a9YsRfhyvRHNSN6t23yD8WCBSr+GKh52F1ZXSm5XRP7bdghtZeE2t+3+twJdRyiR2?= =?utf-8?q?iIV8ASYjw2HXorq/e6/FeIo8iP1ldObgcKFZMS/FfjIBj+zyQRFK6Wg7dQMsn+lKk?= =?utf-8?q?IJqLbnrdhg3CGXWlwqpGbqMR5J/UGItQ6lY85+cVjXbyuf4ae1eP0TyBskpQvXpTe?= =?utf-8?q?GsE2AwDqr3Gz5GYNrFXcB7QxUzbtZw0jqUFb7xf0Ffej8p5NfV+8hSf4z24k4atmn?= =?utf-8?q?jZNDD3b33Wr0V//N1W7UtGV2a8M5o1XRN02s+q5Ze5qyZcmXjuUIZUuFebTMwCJm3?= =?utf-8?q?l2gcDjAyqF0OtFW2E3QpSsj/2A5O6yxT52/uYVmAbusdID8FeV/ijaCHDUC6MTwwX?= =?utf-8?q?qUp7SkNdyxirqnimDeY9AdkPjxYHfHr4q5Al/qpRXi5mFOhLL9cB2PfxyqI7SD2B7?= =?utf-8?q?Py2Zc/Oxk1IUaIcVpFqV+bJHWRxUZt2yjODD1c3H+MgY0teGu3Oth0ThA2VpJ76DM?= =?utf-8?q?gzBGMUkHzwa56dVABfROk23Ew8xkw+kN7wa1lD5RYDk0U2DvqP7Ij4z8vCLZPrkwL?= =?utf-8?q?cbSelBIXB2xkfxcDAxFrARka7QVgPbWzAEanolswfUZ9CcoachdtdbIkmWevxAYp3?= =?utf-8?q?IlOrUMi3ZxSuGsCmN+RNb9ssosRt2lZsDZ/ZKFlf02OiNdykcUZTROnVQx+oRRSAl?= =?utf-8?q?ueYDJHaKGSNQpSNIe9HzXFDD3U+TIcG54fkdtY8LWP91qq0pFoEu9KojvzL5nwMJL?= =?utf-8?q?SDqEaaALcN/rfq1hkAC6dc5nIJe2zanTfsL+XazGNaO5dFxJUr1WsbRghULd6oc4Z?= =?utf-8?q?/cBpYublDARj8eAt480N8n0Fgh8HURl2C7ppsZ+TG4QO+7qJ2uC7+aqMuwmJDe2MC?= =?utf-8?q?I1d6L7im9aut7QnBIv0hD91ZpHlkpzyji0XkvaLgDtT5wtZ080P7EK9+kPprdPJZ6?= =?utf-8?q?oxjgvrHZqgSQaXwhGMIMsPE91VpC1P3bkcJ+UkfyBhes9F6i541fX0YK5X62ipeX0?= =?utf-8?q?IIazcWF/bWJq5YF4OKz4Y4K+4b4OZqOgyG9ILRsnAenQK+pzyDaGsq51Za8vSijig?= =?utf-8?q?E+upWDEiVEbkTXldsM8DCwOj1XBEWWeqmB09jwI2Z9Y+OK0CqyKcAsUDd4uH6PaxO?= =?utf-8?q?6mEHPsMDmeR323NChJOlnVYZJWjtdL2coqaV8NXk2lxid6YvZs7qSsPdrTP/bw9nd?= =?utf-8?q?sB6HgWw+hhoiSfnn2gzp6++bZyp+O6iiHEiyDOZcDLSyFv1DrjYhTsf3xpP2ELEjA?= =?utf-8?q?sClMmdij9o7zQeh+peQ9KwguNP3p4L5rsbKNVrTwSTH322atVZ/ii+uhXwqf8DPyR?= =?utf-8?q?k5szjkSEsnvH?= X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: a0696432-f15e-42e3-edcf-08da746d9994 X-MS-Exchange-CrossTenant-AuthSource: AM0PR04MB6737.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 02 Aug 2022 09:58:51.2496 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: kwtc640SNxd0zYeuD/PzoeUH9BLGiec7c8muO2Mcr5RCmYh/PLkhOu7uaB2fb5QGo3f3ov9WL/C4wIg1rvm6NQ== X-MS-Exchange-Transport-CrossTenantHeadersStamped: AS8PR04MB8341 Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org From: John Stultz This patch provides infrastructure for deferring buffer frees. This is a feature ION provided which when used with some form of a page pool, provides a nice performance boost in an allocation microbenchmark. The reason it helps is it allows the page-zeroing to be done out of the normal allocation/free path, and pushed off to a kthread. As not all heaps will find this useful, its implemented as a optional helper library that heaps can utilize. Cc: Daniel Vetter Cc: Sumit Semwal Cc: Liam Mark Cc: Chris Goldsworthy Cc: Laura Abbott Cc: Brian Starkey Cc: Hridya Valsaraju Cc: Suren Baghdasaryan Cc: Sandeep Patil Cc: Daniel Mentz 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 Bug: 168742043 --- drivers/dma-buf/heaps/Kconfig | 3 + drivers/dma-buf/heaps/Makefile | 1 + drivers/dma-buf/heaps/deferred-free-helper.c | 136 +++++++++++++++++++ drivers/dma-buf/heaps/deferred-free-helper.h | 63 +++++++++ 4 files changed, 203 insertions(+) create mode 100644 drivers/dma-buf/heaps/deferred-free-helper.c create mode 100644 drivers/dma-buf/heaps/deferred-free-helper.h diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig index 3782eeeb91c0..8ee64277a5d2 100644 --- a/drivers/dma-buf/heaps/Kconfig +++ b/drivers/dma-buf/heaps/Kconfig @@ -1,3 +1,6 @@ +config DMABUF_HEAPS_DEFERRED_FREE + tristate + config DMABUF_HEAPS_SYSTEM bool "DMA-BUF System Heap" depends on DMABUF_HEAPS diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile index 29733f84c354..5de95b77e169 100644 --- a/drivers/dma-buf/heaps/Makefile +++ b/drivers/dma-buf/heaps/Makefile @@ -1,4 +1,5 @@ # SPDX-License-Identifier: GPL-2.0 +obj-$(CONFIG_DMABUF_HEAPS_DEFERRED_FREE) += deferred-free-helper.o obj-$(CONFIG_DMABUF_HEAPS_SYSTEM) += system_heap.o obj-$(CONFIG_DMABUF_HEAPS_CMA) += cma_heap.o obj-$(CONFIG_DMABUF_HEAPS_DSP) += dsp_heap.o diff --git a/drivers/dma-buf/heaps/deferred-free-helper.c b/drivers/dma-buf/heaps/deferred-free-helper.c new file mode 100644 index 000000000000..478faa319908 --- /dev/null +++ b/drivers/dma-buf/heaps/deferred-free-helper.c @@ -0,0 +1,136 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Deferred dmabuf freeing helper + * + * Copyright (C) 2020 Linaro, Ltd. + * + * Based on the ION page pool code + * Copyright (C) 2011 Google, Inc. + */ + +#include +#include +#include +#include +#include + +#include "deferred-free-helper.h" + +static LIST_HEAD(free_list); +static size_t list_nr_pages; +static wait_queue_head_t freelist_waitqueue; +static struct task_struct *freelist_task; +static DEFINE_SPINLOCK(free_list_lock); + +void deferred_free(struct deferred_freelist_item *item, + void (*free)(struct deferred_freelist_item*, + enum df_reason), + size_t nr_pages) +{ + unsigned long flags; + + if (!nr_pages) + return; + + INIT_LIST_HEAD(&item->list); + item->nr_pages = nr_pages; + item->free = free; + + spin_lock_irqsave(&free_list_lock, flags); + list_add(&item->list, &free_list); + list_nr_pages += nr_pages; + spin_unlock_irqrestore(&free_list_lock, flags); + wake_up(&freelist_waitqueue); +} +EXPORT_SYMBOL_GPL(deferred_free); + +static size_t free_one_item(enum df_reason reason) +{ + unsigned long flags; + size_t nr_pages; + struct deferred_freelist_item *item; + + spin_lock_irqsave(&free_list_lock, flags); + if (list_empty(&free_list)) { + spin_unlock_irqrestore(&free_list_lock, flags); + return 0; + } + item = list_first_entry(&free_list, struct deferred_freelist_item, list); + list_del(&item->list); + nr_pages = item->nr_pages; + list_nr_pages -= nr_pages; + spin_unlock_irqrestore(&free_list_lock, flags); + + item->free(item, reason); + return nr_pages; +} + +static unsigned long get_freelist_nr_pages(void) +{ + unsigned long nr_pages; + unsigned long flags; + + spin_lock_irqsave(&free_list_lock, flags); + nr_pages = list_nr_pages; + spin_unlock_irqrestore(&free_list_lock, flags); + return nr_pages; +} + +static unsigned long freelist_shrink_count(struct shrinker *shrinker, + struct shrink_control *sc) +{ + return get_freelist_nr_pages(); +} + +static unsigned long freelist_shrink_scan(struct shrinker *shrinker, + struct shrink_control *sc) +{ + unsigned long total_freed = 0; + + while (total_freed < sc->nr_to_scan) { + size_t pages_freed = free_one_item(DF_UNDER_PRESSURE); + + if (!pages_freed) + break; + + total_freed += pages_freed; + } + + return total_freed; +} + +static struct shrinker freelist_shrinker = { + .count_objects = freelist_shrink_count, + .scan_objects = freelist_shrink_scan, + .seeks = DEFAULT_SEEKS, + .batch = 0, +}; + +static int deferred_free_thread(void *data) +{ + while (true) { + wait_event_freezable(freelist_waitqueue, + get_freelist_nr_pages() > 0); + + free_one_item(DF_NORMAL); + } + + return 0; +} + +static int deferred_freelist_init(void) +{ + init_waitqueue_head(&freelist_waitqueue); + freelist_task = kthread_run(deferred_free_thread, NULL, + "%s", "dmabuf-deferred-free-worker"); + if (IS_ERR(freelist_task)) { + pr_err("Creating thread for deferred free failed\n"); + return PTR_ERR(freelist_task); + } + sched_set_normal(freelist_task, 19); + + return register_shrinker(&freelist_shrinker); +} +module_init(deferred_freelist_init); +MODULE_LICENSE("GPL v2"); + diff --git a/drivers/dma-buf/heaps/deferred-free-helper.h b/drivers/dma-buf/heaps/deferred-free-helper.h new file mode 100644 index 000000000000..4ed5893fdf3a --- /dev/null +++ b/drivers/dma-buf/heaps/deferred-free-helper.h @@ -0,0 +1,63 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Deferred dmabuf freeing helper + * + * Copyright (C) 2020 Linaro, Ltd. + * + * Based on the ION page pool code + * Copyright (C) 2011 Google, Inc. + */ + +#ifndef DEFERRED_FREE_HELPER_H +#define DEFERRED_FREE_HELPER_H + +/** + * df_reason - enum for reason why item was freed + * + * This provides a reason for why the free function was called + * on the item. This is useful when deferred_free is used in + * combination with a pagepool, so under pressure the page can + * be immediately freed. + * + * DF_NORMAL: Normal deferred free + * + * DF_UNDER_PRESSURE: Free was called because the system + * is under memory pressure. Usually + * from a shrinker. Avoid allocating + * memory in the free call, as it may + * fail. + */ +enum df_reason { + DF_NORMAL, + DF_UNDER_PRESSURE, +}; + +/** + * deferred_freelist_item - item structure for deferred freelist + * + * This is to be added to the structure for whatever you want to + * defer freeing on. + * + * @nr_pages: number of pages used by item to be freed + * @free: function pointer to be called when freeing the item + * @list: list entry for the deferred list + */ +struct deferred_freelist_item { + size_t nr_pages; + void (*free)(struct deferred_freelist_item *i, + enum df_reason reason); + struct list_head list; +}; + +/** + * deferred_free - add item to the deferred free list + * + * @item: Pointer to deferred_freelist_item field of a structure + * @free: Function pointer to the free call + * @nr_pages: number of pages to be freed + */ +void deferred_free(struct deferred_freelist_item *item, + void (*free)(struct deferred_freelist_item *i, + enum df_reason reason), + size_t nr_pages); +#endif From patchwork Tue Aug 2 09:58:40 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 8bit X-Patchwork-Submitter: Olivier Masse X-Patchwork-Id: 595715 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 349AFC00140 for ; Tue, 2 Aug 2022 09:59:01 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236378AbiHBJ66 (ORCPT ); Tue, 2 Aug 2022 05:58:58 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42182 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236353AbiHBJ64 (ORCPT ); Tue, 2 Aug 2022 05:58:56 -0400 Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05on2081.outbound.protection.outlook.com [40.107.20.81]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 5A83F48C9B; Tue, 2 Aug 2022 02:58:54 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=lhYAwWmzEbXWMWfplvvTPs2jdv7G5K/U4X06eCW2LDiUDLYFCrTWZNdvmwAbAKnFyV5r+T6SIqU1z+jZIXMnhiWPLKIUun4caev1LGsSmmYrybXBxybv95TxkHO74BZeensHNJyuH2TViLOP+Ra1LlMbVNQA9i4WJrJrrlFbXQuakvv7xkdwep04hl8RUjyGBK7khA17mdkiHS1wkj1nUR+NTMmhLJhD4E+8Dn5bEdsQnz9t8snIzVulVNvt2mHZilnpAn/Np6njvnLS0A5XaA+76Xq3gbhNfJXoQvtkZuF0p6Lid2ESWWJTLx+4WIsEC3+iHS18kZZvDnBvtMniKA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=B6F4CMRdmn0GSb1NELVUv8fyXfsdW1uJtKJqqy0RZHs=; b=c04TM49Wfkm+Bng/rkCbN1wkDmskI1ZKdrsB8axBnq/NWm4ujX4jwrne9WSYqtJpJDuh05NDR6I79Cve8QnmigtG5rPjtkO9oxF+cvmE9jgILx7CpxpRVdpCyeYn5yD9uugBrPNVT3IxHCy2u7wXuJn0o5u5sg0Vo7axo/1awLun3/DG3Lfaonf7A0wA27AEIEn6zd1OsEe9pBWQlG0qs8LhnkP27aoShq+5c4b3aew0XN3a/nF5eUqseiAMP8gVq5lXqpEIf3jdFEdLNJrGMrinNyRbOdJ2e3R1tCnYtujEyusEKEpcU67h0ZDeuWt1ahId5v4HGI3jBI5akRfT0g== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=nxp.com; dmarc=pass action=none header.from=nxp.com; dkim=pass header.d=nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=B6F4CMRdmn0GSb1NELVUv8fyXfsdW1uJtKJqqy0RZHs=; b=hHeWLaNkxVsyN7YIJ58EQ18YBZNAoOfutrJWRBbRDlwwq6dvopuX9ARso3HH86ArB9vC1zZpQRPXnwvZYQ5GOHRRnFC+MVnMdTy6izvE4lS6aEk8/5GOQXiZpIYOX1w7AuWleeuTccqAZlgr/a5KXjshZdKoDnNCUfEO/DwqZrk= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=nxp.com; Received: from AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) by AS8PR04MB8341.eurprd04.prod.outlook.com (2603:10a6:20b:3b0::24) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5482.16; Tue, 2 Aug 2022 09:58:52 +0000 Received: from AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b]) by AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b%5]) with mapi id 15.20.5482.011; Tue, 2 Aug 2022 09:58:52 +0000 From: Olivier Masse To: sumit.semwal@linaro.org, benjamin.gaignard@collabora.com, Brian.Starkey@arm.com, christian.koenig@amd.com, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org Cc: clement.faure@nxp.com, olivier.masse@nxp.com Subject: [PATCH 2/5] ANDROID: dma-buf: heaps: Add a shrinker controlled page pool Date: Tue, 2 Aug 2022 11:58:40 +0200 Message-Id: <20220802095843.14614-3-olivier.masse@nxp.com> X-Mailer: git-send-email 2.25.0 In-Reply-To: <20220802095843.14614-1-olivier.masse@nxp.com> References: <20220802095843.14614-1-olivier.masse@nxp.com> X-ClientProxiedBy: AM3PR07CA0145.eurprd07.prod.outlook.com (2603:10a6:207:8::31) To AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: d1aa91d2-bdc0-4ee8-19a8-08da746d9a88 X-MS-TrafficTypeDiagnostic: AS8PR04MB8341:EE_ X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: OrZ+Mf2Im1BWeUgPbN/aeFSeGEekynp4KPB7T98fHlEIdvs8OvGsFdFjRALozCFA/gkdbPPx8avo2CD8IiVLwq+FeSb8bhmN6/XlBai9zjnk3AxtOwM3OLZlimRwL8CqtaFhuNRNKwlIDrMs5/4KhN5msNAX3uN5jV0zNOy6QCN1PzcY8iXmqTAeysEiahk7f5aUCnErBUBN5RLp/d0ErRHmNVel8fVNnN0Fvbiwvy+mSpV/px610mP07GPKuBuuD5mt9DmAW3e5bLCvWBVXhjYMvBhf+eLO4bjMq7RBV0T7wyvKk/p5jBheFx6tyC0FcFtx8GDT8MMnGpzvS1D5mzy50PZWhJmMpbkior99F0gtjL18MSveLPzWY2hKg6IVpXNCpmJb5xy6OogG1nHO4S0jD137ouRxhNPXsgdJEQQr6mJFOfEMOyNVhYh3E4YBWxajhnaDygzA/+sSWe91gaiB6b8Jp3hUrYaNTrlJ367MK7c3+OizXmgzbkSZjJAYX68XVnh8pG2cLmfaqW9W1zzXaI1lvhOYfZJ1PFxo99yupkGA7FV0SYfHOggsBOl/ep6QVvRzdsl7KftFJjK7HSsO6WoofMu5qv/GyPD9jv16t2B8eqrv4bnPg7tQ8wHkV35oDV3IoVqrkDBYHFFRkQYjCb0dczyEwr0rXbYgNOkiFdiSzIGHAC0L9t/RS0agtyy0VDFvRPCizmcZDeJng2mEoG22k4Mqv+2WKUuoKuf15iZnnxaKifyFewTFJNeJGUgUipQyIoS3Fbd0xOXrhKV9n4OiQUltOV11TZx6Crk= X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:AM0PR04MB6737.eurprd04.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230016)(4636009)(396003)(346002)(366004)(136003)(39860400002)(376002)(41300700001)(2906002)(83380400001)(2616005)(86362001)(6666004)(52116002)(6506007)(44832011)(1076003)(30864003)(36756003)(26005)(6512007)(38100700002)(186003)(38350700002)(6486002)(5660300002)(8676002)(66556008)(66476007)(66946007)(8936002)(478600001)(4326008)(316002); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: =?utf-8?q?9GrWezgtjpF/neKQaeu2sOFhzACQ?= =?utf-8?q?CpNpyXw5AT75hwFad626OyvF5/bjPp5X6wgI9da3SW4pplKq2oO3EC2uZqoJJvo6+?= =?utf-8?q?eDr/4ErDUWP1cyrhN6fan2+2Vq8AaDefj6+okul6nkGFiRG1xW+mO4xf4XAKg+FcZ?= =?utf-8?q?7v8KZN2ij1t4yO5Jrg5QIVtH4exOSpo07Mn+vw65Gq4eZ6hDYczaTx16UXhTj7Yap?= =?utf-8?q?MD0K4vWEi4hUgM54VAkdPDxaBZzsqWqN4FfM6KWKs6WH7R3pvwcwcph3EkBUhfzOi?= =?utf-8?q?EcXvj0aTMC9XOLRNZSEFfHu3rx9CvkxFSELrV7jiYisK47M8EoJkgqQ9jxsdoZ2bn?= =?utf-8?q?gtGVLr7vpo45C/K1GPPzcM7mSkyck+lhVgKCQ6yp0zzZEsF4SPAAJxwY74cpruwP8?= =?utf-8?q?n/U7jSzx6NYT5HRoeNgkw/HikNGFDMqQR7iMURu24ID4z9RFMg87Iweur/DCG1xrE?= =?utf-8?q?o+Vs/BQoK/pKbPuPt7902ruINKN3gDWMz6LAwOdyH1F9wBmsbeAXadQ1FPg7Zfrvg?= =?utf-8?q?Db+sWG3m+dZg/+ywZOcs0PCjAZTt8Zigqsvze0/gwAJfClJtlaJk2NZa7bphXv1Qo?= =?utf-8?q?8WaZHNs2trpMprc3yOG5KwdEGmVjZ7JOr/J1eIY+KVicHnL4wRAjVrsF6L30n9/Jh?= =?utf-8?q?kBHV0z8BcHPFoSLeiTznINlnJiQnhqXGnAqLSoeD8dbmuKJXFb3/6HP8DMs0z8j9j?= =?utf-8?q?KTPRoFjw5vgF9a+lu9x7K4JQpuufu2HAiY7+xql35tr8ZSWkOGg0zw/wJ5Cw7MBKk?= =?utf-8?q?vb4dpaEuuadUFU8bcX0fTdH0hKutAIQULh409eltO6wWYFlgw08V+9OqMv7LYci6I?= =?utf-8?q?az5DcFLbibpquFxrxJcjP+ELI6x9CV58hJIxs0FY5MglfeLHzVinwNSD/UipjqYp1?= =?utf-8?q?EhOv/eVJw7RTLcCUGKnFFmuHCwDg9qzyb+7FVWPTSDXm469l6H6zlrdxUwTjgx8yE?= =?utf-8?q?jRfCEDDwIQQtdD9UTntn5l+SuU/Jb9NsD635oMqo0UzDy7JXRybfBloTZt81W408K?= =?utf-8?q?Xa94DgczyElh+wcs3hdk6IXV22GV1MMLQIDm6GpVFfJvu5aCAO5u82UYf3zagUMz2?= =?utf-8?q?Q11qdiqvTLnhbXCfkQoLM9dDkrEZQWyCsznAG2q5G0iI3lpnsUMt85ED3wocYtSZz?= =?utf-8?q?7kbg1IKy141QlFXp9yDOqCtcmo8fvkcySzg+pQcG1XyiaAZ1VAhlMTUZs6+iY36v0?= =?utf-8?q?BFh8inzs0T3oS7bUbkdA1JFWHbNajQJdHkJE003G+WX3asytLtSALTt79Ei/KY6Ne?= =?utf-8?q?A94UXrcabdh1gw5sKURhECXZ0/FnXhUC8Sw3vVHfiqqMoxjCuO0HCTiO5kRbB2dlE?= =?utf-8?q?U19GHk1N68Cy4iccCAcryEZFBl1HA9VkZsg5pYk5snv3C9w2bnP5OXIG+SEPDoP/g?= =?utf-8?q?wD//f6RUATYymq1frrTtdNGeu8GtfM36X7sceuH62BoiHU9cmHwi+SzlbaV2XhQyH?= =?utf-8?q?y03V0uP1xpWj0o7rigEyUf0OtWjNgYeIJ99deCwwGqn1Qp+rdTfbqzUe9BkSK6iQ3?= =?utf-8?q?2qnk95Y7Wilb?= X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: d1aa91d2-bdc0-4ee8-19a8-08da746d9a88 X-MS-Exchange-CrossTenant-AuthSource: AM0PR04MB6737.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 02 Aug 2022 09:58:52.0620 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: JJVQHhZVNHPI+vhQST2F/FbSJjoy0Oqz6BAmLzShGIaCRPcNiniHit7RCDbtHPsZK50coI1r7PjNQ7KlBC0mfw== X-MS-Exchange-Transport-CrossTenantHeadersStamped: AS8PR04MB8341 Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org From: John Stultz This patch adds a simple shrinker controlled page pool to the dmabuf heaps subsystem. This replaces the use of the networking page_pool, over concerns that the lack of a shrinker for that implementation may cause additional low-memory kills TODO: Take another pass at trying to unify this w/ the ttm pool Thoughts and feedback would be greatly appreciated! 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: Andrew Morton Cc: Dave Hansen Cc: linux-mm@kvack.org Cc: linux-media@vger.kernel.org Cc: dri-devel@lists.freedesktop.org Signed-off-by: John Stultz Signed-off-by: Olivier Masse Bug: 168742043 --- drivers/dma-buf/heaps/Kconfig | 3 + drivers/dma-buf/heaps/Makefile | 1 + drivers/dma-buf/heaps/page_pool.c | 246 ++++++++++++++++++++++++++++++ drivers/dma-buf/heaps/page_pool.h | 55 +++++++ 4 files changed, 305 insertions(+) create mode 100644 drivers/dma-buf/heaps/page_pool.c create mode 100644 drivers/dma-buf/heaps/page_pool.h diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig index 8ee64277a5d2..6a33193a7b3e 100644 --- a/drivers/dma-buf/heaps/Kconfig +++ b/drivers/dma-buf/heaps/Kconfig @@ -1,6 +1,9 @@ config DMABUF_HEAPS_DEFERRED_FREE tristate +config DMABUF_HEAPS_PAGE_POOL + tristate + config DMABUF_HEAPS_SYSTEM bool "DMA-BUF System Heap" depends on DMABUF_HEAPS diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile index 5de95b77e169..e70722ea615e 100644 --- a/drivers/dma-buf/heaps/Makefile +++ b/drivers/dma-buf/heaps/Makefile @@ -1,5 +1,6 @@ # SPDX-License-Identifier: GPL-2.0 obj-$(CONFIG_DMABUF_HEAPS_DEFERRED_FREE) += deferred-free-helper.o +obj-$(CONFIG_DMABUF_HEAPS_PAGE_POOL) += page_pool.o obj-$(CONFIG_DMABUF_HEAPS_SYSTEM) += system_heap.o obj-$(CONFIG_DMABUF_HEAPS_CMA) += cma_heap.o obj-$(CONFIG_DMABUF_HEAPS_DSP) += dsp_heap.o diff --git a/drivers/dma-buf/heaps/page_pool.c b/drivers/dma-buf/heaps/page_pool.c new file mode 100644 index 000000000000..3dd4c3862dca --- /dev/null +++ b/drivers/dma-buf/heaps/page_pool.c @@ -0,0 +1,246 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * DMA BUF page pool system + * + * Copyright (C) 2020 Linaro Ltd. + * + * Based on the ION page pool code + * Copyright (C) 2011 Google, Inc. + */ + +#include +#include +#include +#include +#include +#include "page_pool.h" + +static LIST_HEAD(pool_list); +static DEFINE_MUTEX(pool_list_lock); + +static struct page *dmabuf_page_pool_alloc_pages(struct dmabuf_page_pool *pool) +{ + if (fatal_signal_pending(current)) + return NULL; + return alloc_pages(pool->gfp_mask, pool->order); +} + +static void dmabuf_page_pool_free_pages(struct dmabuf_page_pool *pool, + struct page *page) +{ + __free_pages(page, pool->order); +} + +static void dmabuf_page_pool_add(struct dmabuf_page_pool *pool, struct page *page) +{ + int index; + + if (PageHighMem(page)) + index = POOL_HIGHPAGE; + else + index = POOL_LOWPAGE; + + mutex_lock(&pool->mutex); + list_add_tail(&page->lru, &pool->items[index]); + pool->count[index]++; + mod_node_page_state(page_pgdat(page), NR_KERNEL_MISC_RECLAIMABLE, + 1 << pool->order); + mutex_unlock(&pool->mutex); +} + +static struct page *dmabuf_page_pool_remove(struct dmabuf_page_pool *pool, int index) +{ + struct page *page; + + mutex_lock(&pool->mutex); + page = list_first_entry_or_null(&pool->items[index], struct page, lru); + if (page) { + pool->count[index]--; + list_del(&page->lru); + mod_node_page_state(page_pgdat(page), NR_KERNEL_MISC_RECLAIMABLE, + -(1 << pool->order)); + } + mutex_unlock(&pool->mutex); + + return page; +} + +static struct page *dmabuf_page_pool_fetch(struct dmabuf_page_pool *pool) +{ + struct page *page = NULL; + + page = dmabuf_page_pool_remove(pool, POOL_HIGHPAGE); + if (!page) + page = dmabuf_page_pool_remove(pool, POOL_LOWPAGE); + + return page; +} + +struct page *dmabuf_page_pool_alloc(struct dmabuf_page_pool *pool) +{ + struct page *page = NULL; + + if (WARN_ON(!pool)) + return NULL; + + page = dmabuf_page_pool_fetch(pool); + if (!page) + page = dmabuf_page_pool_alloc_pages(pool); + + return page; +} +EXPORT_SYMBOL_GPL(dmabuf_page_pool_alloc); + +void dmabuf_page_pool_free(struct dmabuf_page_pool *pool, struct page *page) +{ + if (WARN_ON(pool->order != compound_order(page))) + return; + + dmabuf_page_pool_add(pool, page); +} +EXPORT_SYMBOL_GPL(dmabuf_page_pool_free); + +static int dmabuf_page_pool_total(struct dmabuf_page_pool *pool, bool high) +{ + int count = pool->count[POOL_LOWPAGE]; + + if (high) + count += pool->count[POOL_HIGHPAGE]; + + return count << pool->order; +} + +struct dmabuf_page_pool *dmabuf_page_pool_create(gfp_t gfp_mask, unsigned int order) +{ + struct dmabuf_page_pool *pool = kmalloc(sizeof(*pool), GFP_KERNEL); + int i; + + if (!pool) + return NULL; + + for (i = 0; i < POOL_TYPE_SIZE; i++) { + pool->count[i] = 0; + INIT_LIST_HEAD(&pool->items[i]); + } + pool->gfp_mask = gfp_mask | __GFP_COMP; + pool->order = order; + mutex_init(&pool->mutex); + + mutex_lock(&pool_list_lock); + list_add(&pool->list, &pool_list); + mutex_unlock(&pool_list_lock); + + return pool; +} +EXPORT_SYMBOL_GPL(dmabuf_page_pool_create); + +void dmabuf_page_pool_destroy(struct dmabuf_page_pool *pool) +{ + struct page *page; + int i; + + /* Remove us from the pool list */ + mutex_lock(&pool_list_lock); + list_del(&pool->list); + mutex_unlock(&pool_list_lock); + + /* Free any remaining pages in the pool */ + for (i = 0; i < POOL_TYPE_SIZE; i++) { + while ((page = dmabuf_page_pool_remove(pool, i))) + dmabuf_page_pool_free_pages(pool, page); + } + + kfree(pool); +} +EXPORT_SYMBOL_GPL(dmabuf_page_pool_destroy); + +static int dmabuf_page_pool_do_shrink(struct dmabuf_page_pool *pool, gfp_t gfp_mask, + int nr_to_scan) +{ + int freed = 0; + bool high; + + if (current_is_kswapd()) + high = true; + else + high = !!(gfp_mask & __GFP_HIGHMEM); + + if (nr_to_scan == 0) + return dmabuf_page_pool_total(pool, high); + + while (freed < nr_to_scan) { + struct page *page; + + /* Try to free low pages first */ + page = dmabuf_page_pool_remove(pool, POOL_LOWPAGE); + if (!page) + page = dmabuf_page_pool_remove(pool, POOL_HIGHPAGE); + + if (!page) + break; + + dmabuf_page_pool_free_pages(pool, page); + freed += (1 << pool->order); + } + + return freed; +} + +static int dmabuf_page_pool_shrink(gfp_t gfp_mask, int nr_to_scan) +{ + struct dmabuf_page_pool *pool; + int nr_total = 0; + int nr_freed; + bool only_scan = false; + + if (!nr_to_scan) + only_scan = true; + + mutex_lock(&pool_list_lock); + list_for_each_entry(pool, &pool_list, list) { + if (only_scan) { + nr_total += dmabuf_page_pool_do_shrink(pool, + gfp_mask, + nr_to_scan); + } else { + nr_freed = dmabuf_page_pool_do_shrink(pool, + gfp_mask, + nr_to_scan); + nr_to_scan -= nr_freed; + nr_total += nr_freed; + if (nr_to_scan <= 0) + break; + } + } + mutex_unlock(&pool_list_lock); + + return nr_total; +} + +static unsigned long dmabuf_page_pool_shrink_count(struct shrinker *shrinker, + struct shrink_control *sc) +{ + return dmabuf_page_pool_shrink(sc->gfp_mask, 0); +} + +static unsigned long dmabuf_page_pool_shrink_scan(struct shrinker *shrinker, + struct shrink_control *sc) +{ + if (sc->nr_to_scan == 0) + return 0; + return dmabuf_page_pool_shrink(sc->gfp_mask, sc->nr_to_scan); +} + +struct shrinker pool_shrinker = { + .count_objects = dmabuf_page_pool_shrink_count, + .scan_objects = dmabuf_page_pool_shrink_scan, + .seeks = DEFAULT_SEEKS, + .batch = 0, +}; + +static int dmabuf_page_pool_init_shrinker(void) +{ + return register_shrinker(&pool_shrinker); +} +module_init(dmabuf_page_pool_init_shrinker); +MODULE_LICENSE("GPL v2"); diff --git a/drivers/dma-buf/heaps/page_pool.h b/drivers/dma-buf/heaps/page_pool.h new file mode 100644 index 000000000000..e3ec9eaacbc2 --- /dev/null +++ b/drivers/dma-buf/heaps/page_pool.h @@ -0,0 +1,55 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * DMA BUF PagePool implementation + * Based on earlier ION code by Google + * + * Copyright (C) 2011 Google, Inc. + * Copyright (C) 2020 Linaro Ltd. + */ + +#ifndef _DMABUF_PAGE_POOL_H +#define _DMABUF_PAGE_POOL_H + +#include +#include +#include +#include +#include +#include + +/* page types we track in the pool */ +enum { + POOL_LOWPAGE, /* Clean lowmem pages */ + POOL_HIGHPAGE, /* Clean highmem pages */ + + POOL_TYPE_SIZE +}; + +/** + * struct dmabuf_page_pool - pagepool struct + * @count[]: array of number of pages of that type in the pool + * @items[]: array of list of pages of the specific type + * @mutex: lock protecting this struct and especially the count + * item list + * @gfp_mask: gfp_mask to use from alloc + * @order: order of pages in the pool + * @list: list node for list of pools + * + * Allows you to keep a pool of pre allocated pages to use + */ +struct dmabuf_page_pool { + int count[POOL_TYPE_SIZE]; + struct list_head items[POOL_TYPE_SIZE]; + struct mutex mutex; + gfp_t gfp_mask; + unsigned int order; + struct list_head list; +}; + +struct dmabuf_page_pool *dmabuf_page_pool_create(gfp_t gfp_mask, + unsigned int order); +void dmabuf_page_pool_destroy(struct dmabuf_page_pool *pool); +struct page *dmabuf_page_pool_alloc(struct dmabuf_page_pool *pool); +void dmabuf_page_pool_free(struct dmabuf_page_pool *pool, struct page *page); + +#endif /* _DMABUF_PAGE_POOL_H */ From patchwork Tue Aug 2 09:58:41 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Olivier Masse X-Patchwork-Id: 595032 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id B76C1C19F2B for ; Tue, 2 Aug 2022 09:59:05 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236404AbiHBJ7E (ORCPT ); Tue, 2 Aug 2022 05:59:04 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42222 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236368AbiHBJ66 (ORCPT ); Tue, 2 Aug 2022 05:58:58 -0400 Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05on2081.outbound.protection.outlook.com [40.107.20.81]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 4C7AC4B0D0; Tue, 2 Aug 2022 02:58:56 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=fAyb09nd/oxYF2HHyOIzdifj0LwovxhxsMt7wXDaqTlxUEFyWDTDM6m1scRQ8wHiQ1WBfOtcrqGaa78E1xs3JnpXLw7gaKKJO93/h0pm7bo4w9TdMf+xNAUeoPiB6RvLp3WrVrZ+juMrL6asbgji88a2BXX8PrEOarbKpxFO7sbbsc23SoXnlW/DnBEQ+2JjzEVHXvLsYxxsFBlBSkUArnuwLvzk28aZRVlcdmKVgnYhCzJ+UyT9qPh+KI9mcLzZtwCv4vqnHasu2BWQ1ZDTtpFMRu9Yq2BvYquilgYFiuJF9hMaPNC6Fsf75yTaw2ULumnZhdZ8i0b4piJ30bZx/g== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=Lk8z61pSjUyn51VI9T8eBY3Ubnc7j16YLC8/9J63+4k=; b=QbOSOWbZqt9CSWaMF3aM57bneDYWJiYnTesycTAhzldKkP4I+TbVYme0xwn1dXPzWtCDsmsE47qMMZeh7f3elC2f+jJRp/wIheNIAkuwl9jTuDw65orE4fmzTApK4+mi2YUpB3iVm2hLWA6DiDueFixrN8VV77MrJG0s5YJVhgGkAVhFvcknKIG05iVYSJTDjWOWJemMeMRk8oNIvm28OIBJzEh6j5XHU+blTyoKMXYCUDAHNAHdIvgxgSlHs7Erxi8XIqKRb5ecXOtMV/acHmhiCr63nIx9ohhiRss29JuYOOU9x5FNFUJFr8KB/shgfVWjahjqeZTHxABM/jiFXg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=nxp.com; dmarc=pass action=none header.from=nxp.com; dkim=pass header.d=nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=Lk8z61pSjUyn51VI9T8eBY3Ubnc7j16YLC8/9J63+4k=; b=YA7144S06dZgXkQvxUNM6dW3kpWhC6nCiaxX0loZw7Qhd9V2vF6QQmCC5aTQsTuRIDqhp+1Ml42Sk7mzz1qcTj7UrCTfIUsuOwk1UKwBwevk6f5MADQxvS54ktEUy/KYAN1RApfRj/8WmcYERY2dXxOCTLsRiKWJDMpVEA0nHNU= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=nxp.com; Received: from AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) by AS8PR04MB8341.eurprd04.prod.outlook.com (2603:10a6:20b:3b0::24) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5482.16; Tue, 2 Aug 2022 09:58:53 +0000 Received: from AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b]) by AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b%5]) with mapi id 15.20.5482.011; Tue, 2 Aug 2022 09:58:52 +0000 From: Olivier Masse To: sumit.semwal@linaro.org, benjamin.gaignard@collabora.com, Brian.Starkey@arm.com, christian.koenig@amd.com, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org Cc: clement.faure@nxp.com, olivier.masse@nxp.com Subject: [PATCH 3/5] dma-buf: heaps: add Linaro secure dmabuf heap support Date: Tue, 2 Aug 2022 11:58:41 +0200 Message-Id: <20220802095843.14614-4-olivier.masse@nxp.com> X-Mailer: git-send-email 2.25.0 In-Reply-To: <20220802095843.14614-1-olivier.masse@nxp.com> References: <20220802095843.14614-1-olivier.masse@nxp.com> X-ClientProxiedBy: AM3PR07CA0145.eurprd07.prod.outlook.com (2603:10a6:207:8::31) To AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 3c3323bc-c935-4a49-c419-08da746d9af5 X-MS-TrafficTypeDiagnostic: AS8PR04MB8341:EE_ X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 3VJUOiXuJkxZk8uXTbdXPV4FOnmukCl8oeyHT5nadlKsz0HcrdrGP6BMBg9k8LNP/szZyemJw9O0FMhCWDEvpFtLSh+gMpGDyBs0cmW7RTfScuCXk9zL5BLly5jGM0zKCuuGRJo3xGkovLqdbmZVXSe+fqCJ+Z41q+Nqgz/xJqR08xljDh+TO5O8usZan9hk+Sxk8Z8siPQ1cuZh/No+p9qvTBNhjDeXsEVfBnykivqvnv1hfKdoiZ5uvUeENN/OoVHzkprl7lVOppE6aXxbl9zTyZTbJjM4llpqV80PvHStiJEFnuWOJ0W491mQADDzfwWjRl4KZ/TlU+VBnjLn5485X25Z6tsI9x9mvy63gbxrmU5b7uh5wscDyJ5AeHQMeE1p0IRGcQUO4eCrttRMB/UMX9gDSauSRnAgePiLDkOqhEtnGr5czIc2lGFNro8m3G6NsqEiWZTjARFTlj81jUU/Fw6VROLRGT6VonHcXmuQbpXZlwG68JlMISyUaMpv8EPJ7AHSgTeoeuLMwwAKfNNM2kNvMP3yZ93GtFP9FcoDRgrqdEh9FAFVr/h9p2sGi9r7MiVjUukubC7jTXNjQu38EZViEImwFj2sw0Su6PRdt3PSgpq/kQ4a1Oy+Vf+ROleCIz5rwWyPoCS3/YTD8+w71IOsB+b97lgALabIMjGK5JIhmKq1jPfU/QffkaoF3/Qu7/y1G+j2zWeVMLGFfFNZC9AOa56N3lkx4A8Ux6kYXXRmU6ddE95osjDYmBMa6kJOnec5cSmakaibUcDkICrJxLA2WDfPUQEUavFnYiE= X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:AM0PR04MB6737.eurprd04.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230016)(4636009)(396003)(346002)(366004)(136003)(39860400002)(376002)(41300700001)(2906002)(83380400001)(2616005)(86362001)(6666004)(52116002)(6506007)(44832011)(1076003)(30864003)(36756003)(26005)(6512007)(38100700002)(186003)(38350700002)(6486002)(5660300002)(8676002)(66556008)(66476007)(66946007)(8936002)(478600001)(4326008)(316002); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: RtVU1wcVxH2WPoDSDnZpQBbfWhWRfIPe6FnRQ7p++u0XGdPj4XSUEXTVKgDlLzeS2YpSiRdr0jC9mIPLl5PW24quP5nL1My5IdzE3v0VUeejF/shnTIRRBsqU85eUoqHND56TVMb967kNmLxTzqykXCyXJ2K/QN0iHTBGjjV++Xa25Lq9+7kiTqAcfq/U7p1jELq0X4EhZu/sddsSjZPFtOMYRjt3dYyX334bH7Grkw6yTNIUftV1T5QXmBPprTs0ASfj48ao/UBJ2kEGI7WHw87y8vL+5C61QoyOj7YCIYM0J6xMrau+6Xn7EoBBV/3GtNUTQPTO/hhvtktZqvQDAWTl8cGe7S2QMVHJik7CAsTvJomGuf/kNMI+Taph562icO3aU3B7olQK8eqf1HYtX0Sy0707qZDnMqewQ0NyObvc6lNx8x69Xn3uXtxCsAx0Libe3t9onPVleqEN7Q6QKll2JX2DS0YjLy5Vn4I62LUzOgdF/13NBZuce5AXH15ALjDNCuDJZO7DLS7KXlEKXd9MSmWzeH03se8unc46J01XdIzQc4S1JCOMfo7eunCeal3Rrdr5IwtJgjFHeADX8sggtoi/kFmj5Ma54cINZZ/HWLw2vBHonSvWMjRZUASY7xxhTnIcRuaUiJewRDGeb3n+JeXjm2Q9TnywQ8EhHHLmQ8k95KD9n3zdIf+vmMpxwKm5VNizjsbjvXa6sBLZfdrbmTzEYdZHF34qQLeL9aKZR0p9e5gP/mkL+nm3ErvWWQJ+zJMiMujlUy6lZAEqJdfGlTYGpv5vMajU7dydV7kQ5TvSVllBgEtx4im9yddIX8jC+flDvxZhMlrdghftDRn8cyX7tyancVrQ3qLnva+cEvGdT+TNtErCFZFTHmPUCjAON36S0sZ51J2YCvDoytDlUf/IK9fgdST+fOwZBSMNgfzppMyBBN6QBoihyKiQrLotc/gboFily66xwP9fEl9UHkyxFMJx2FNXVfo51gLxXIM5jKFHjmQsOGvJ0yXb6wkQkJ3lHEYPj3+alov26D/uA9zJyGBtC5y0xoWDHd0eSrpBuwKQPPDS1uo/LgzQ772Oa7ilsKe1qFqR0my93le5bSiqE7NZVycRsRKWV/wY6SjSV/peRgKfy1TYPcntr2sEFzUFDWTA1OZBCjS2PAtlYUr5EomTkh4l3v2cQmHjTLU/cqHzW65Dco+r6zBV1n5wxpXPRsYK+1pamqZGhPVgT8hFRE3/FEuIgh+TA7c5tYgxJ5o41gWMq0AIf3F5DnlI3eIAvi/zVDOGie9zpAt3B1d0RQWXp9jqioxrUHpHupY8UWenF2CNqWfA74HrXZ1BQMoQkuVh//oFlu23SPMVsm1pONWTYmfQpNaaY14TVJhEdU/JUZp5yyzU8UvY2F+c+xtaCXs6SrW6ncb8z+wxcRuP+SY0YglghD2tkplp3OpnUwyQ//9+f6TkzBbIgOPLXb7WZ20bWlEQtizrtgWc74c6G3Q1SrUiKvrFiwri5r6P3o3RQL3rNBp99ktsiYEC2OdZPSl4sa7XdOm6huGV1ny4KB8u+BULo8JBl/lGC1sP747f8Zerucrwwyb X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: 3c3323bc-c935-4a49-c419-08da746d9af5 X-MS-Exchange-CrossTenant-AuthSource: AM0PR04MB6737.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 02 Aug 2022 09:58:52.8901 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: IslUwqqCqgJank03GR1fwYylWB6A1KouinKSk9UMpkq1K5CY/N/sS+MTz/sdJ2R8CtYtciIzIOkcnMffkM9wfA== X-MS-Exchange-Transport-CrossTenantHeadersStamped: AS8PR04MB8341 Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org add Linaro secure heap bindings: linaro,secure-heap use genalloc to allocate/free buffer from buffer pool. buffer pool info is from dts. use sg_table instore the allocated memory info, the length of sg_table is 1. implement secure_heap_buf_ops to implement buffer share in difference device: 1. Userspace passes this fd to all drivers it wants this buffer to share with: First the filedescriptor is converted to a &dma_buf using dma_buf_get(). Then the buffer is attached to the device using dma_buf_attach(). 2. Once the buffer is attached to all devices userspace can initiate DMA access to the shared buffer. In the kernel this is done by calling dma_buf_map_attachment() 3. get sg_table with dma_buf_map_attachment in difference device. Signed-off-by: Olivier Masse --- drivers/dma-buf/heaps/Kconfig | 21 +- drivers/dma-buf/heaps/Makefile | 1 + drivers/dma-buf/heaps/secure_heap.c | 588 ++++++++++++++++++++++++++++ 3 files changed, 606 insertions(+), 4 deletions(-) create mode 100644 drivers/dma-buf/heaps/secure_heap.c diff --git a/drivers/dma-buf/heaps/Kconfig b/drivers/dma-buf/heaps/Kconfig index 6a33193a7b3e..b2406932192e 100644 --- a/drivers/dma-buf/heaps/Kconfig +++ b/drivers/dma-buf/heaps/Kconfig @@ -1,8 +1,12 @@ -config DMABUF_HEAPS_DEFERRED_FREE - tristate +menuconfig DMABUF_HEAPS_DEFERRED_FREE + bool "DMA-BUF heaps deferred-free library" + help + Choose this option to enable the DMA-BUF heaps deferred-free library. -config DMABUF_HEAPS_PAGE_POOL - tristate +menuconfig DMABUF_HEAPS_PAGE_POOL + bool "DMA-BUF heaps page-pool library" + help + Choose this option to enable the DMA-BUF heaps page-pool library. config DMABUF_HEAPS_SYSTEM bool "DMA-BUF System Heap" @@ -26,3 +30,12 @@ config DMABUF_HEAPS_DSP Choose this option to enable the dsp dmabuf heap. The dsp heap is allocated by gen allocater. it's allocated according the dts. If in doubt, say Y. + +config DMABUF_HEAPS_SECURE + tristate "DMA-BUF Secure Heap" + depends on DMABUF_HEAPS && DMABUF_HEAPS_DEFERRED_FREE + help + Choose this option to enable the secure dmabuf heap. The secure heap + pools are defined according to the DT. Heaps are allocated + in the pools using gen allocater. + If in doubt, say Y. diff --git a/drivers/dma-buf/heaps/Makefile b/drivers/dma-buf/heaps/Makefile index e70722ea615e..08f6aa5919d1 100644 --- a/drivers/dma-buf/heaps/Makefile +++ b/drivers/dma-buf/heaps/Makefile @@ -4,3 +4,4 @@ obj-$(CONFIG_DMABUF_HEAPS_PAGE_POOL) += page_pool.o obj-$(CONFIG_DMABUF_HEAPS_SYSTEM) += system_heap.o obj-$(CONFIG_DMABUF_HEAPS_CMA) += cma_heap.o obj-$(CONFIG_DMABUF_HEAPS_DSP) += dsp_heap.o +obj-$(CONFIG_DMABUF_HEAPS_SECURE) += secure_heap.o diff --git a/drivers/dma-buf/heaps/secure_heap.c b/drivers/dma-buf/heaps/secure_heap.c new file mode 100644 index 000000000000..31aac5d050b4 --- /dev/null +++ b/drivers/dma-buf/heaps/secure_heap.c @@ -0,0 +1,588 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * DMABUF secure heap exporter + * + * Copyright 2021 NXP. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "deferred-free-helper.h" +#include "page_pool.h" + +#define MAX_SECURE_HEAP 2 +#define MAX_HEAP_NAME_LEN 32 + +struct secure_heap_buffer { + struct dma_heap *heap; + struct list_head attachments; + struct mutex lock; + unsigned long len; + struct sg_table sg_table; + int vmap_cnt; + struct deferred_freelist_item deferred_free; + void *vaddr; + bool uncached; +}; + +struct dma_heap_attachment { + struct device *dev; + struct sg_table *table; + struct list_head list; + bool no_map; + bool mapped; + bool uncached; +}; + +struct secure_heap_info { + struct gen_pool *pool; + + bool no_map; +}; + +struct rmem_secure { + phys_addr_t base; + phys_addr_t size; + + char name[MAX_HEAP_NAME_LEN]; + + bool no_map; +}; + +static struct rmem_secure secure_data[MAX_SECURE_HEAP] = {0}; +static unsigned int secure_data_count; + +static struct sg_table *dup_sg_table(struct sg_table *table) +{ + 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->dma_address = sg->dma_address; +#ifdef CONFIG_NEED_SG_DMA_LENGTH + new_sg->dma_length = sg->dma_length; +#endif + new_sg = sg_next(new_sg); + } + + return new_table; +} + +static int secure_heap_attach(struct dma_buf *dmabuf, + struct dma_buf_attachment *attachment) +{ + struct secure_heap_buffer *buffer = dmabuf->priv; + struct secure_heap_info *info = dma_heap_get_drvdata(buffer->heap); + 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); + a->no_map = info->no_map; + a->mapped = false; + a->uncached = buffer->uncached; + attachment->priv = a; + + mutex_lock(&buffer->lock); + list_add(&a->list, &buffer->attachments); + mutex_unlock(&buffer->lock); + + return 0; +} + +static void secure_heap_detach(struct dma_buf *dmabuf, + struct dma_buf_attachment *attachment) +{ + struct secure_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 *secure_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 attr = 0; + int ret; + + if (!a->no_map) { + if (a->uncached) + attr = DMA_ATTR_SKIP_CPU_SYNC; + + ret = dma_map_sgtable(attachment->dev, table, direction, attr); + if (ret) + return ERR_PTR(ret); + + a->mapped = true; + } + + return table; +} + +static void secure_heap_unmap_dma_buf(struct dma_buf_attachment *attachment, + struct sg_table *table, + enum dma_data_direction direction) +{ + struct dma_heap_attachment *a = attachment->priv; + int attr = 0; + + if (!a->no_map) { + if (a->uncached) + attr = DMA_ATTR_SKIP_CPU_SYNC; + + a->mapped = false; + dma_unmap_sgtable(attachment->dev, table, direction, attr); + } +} + +static int secure_heap_dma_buf_begin_cpu_access(struct dma_buf *dmabuf, + enum dma_data_direction direction) +{ + struct secure_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); + + if (!buffer->uncached) { + list_for_each_entry(a, &buffer->attachments, list) { + if (!a->mapped) + continue; + dma_sync_sgtable_for_cpu(a->dev, a->table, direction); + } + } + mutex_unlock(&buffer->lock); + + return 0; +} + +static int secure_heap_dma_buf_end_cpu_access(struct dma_buf *dmabuf, + enum dma_data_direction direction) +{ + struct secure_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); + + if (!buffer->uncached) { + list_for_each_entry(a, &buffer->attachments, list) { + if (!a->mapped) + continue; + dma_sync_sgtable_for_device(a->dev, a->table, direction); + } + } + mutex_unlock(&buffer->lock); + + return 0; +} + +static int secure_heap_mmap(struct dma_buf *dmabuf, struct vm_area_struct *vma) +{ + struct secure_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; + + if (buffer->uncached) + vma->vm_page_prot = pgprot_writecombine(vma->vm_page_prot); + + 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; + } + return 0; +} + +static void *secure_heap_do_vmap(struct secure_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; + pgprot_t pgprot = PAGE_KERNEL; + void *vaddr; + + if (!pages) + return ERR_PTR(-ENOMEM); + + if (buffer->uncached) + pgprot = pgprot_writecombine(PAGE_KERNEL); + + for_each_sgtable_page(table, &piter, 0) { + WARN_ON(tmp - pages >= npages); + *tmp++ = sg_page_iter_page(&piter); + } + + vaddr = vmap(pages, npages, VM_MAP, pgprot); + vfree(pages); + + if (!vaddr) + return ERR_PTR(-ENOMEM); + + return vaddr; +} + +static int secure_heap_vmap(struct dma_buf *dmabuf, struct dma_buf_map *map) +{ + struct secure_heap_buffer *buffer = dmabuf->priv; + void *vaddr; + int ret = 0; + + mutex_lock(&buffer->lock); + if (buffer->vmap_cnt) { + buffer->vmap_cnt++; + goto out; + } + + vaddr = secure_heap_do_vmap(buffer); + if (IS_ERR(vaddr)) { + ret = PTR_ERR(vaddr); + goto out; + } + + buffer->vaddr = vaddr; + buffer->vmap_cnt++; + dma_buf_map_set_vaddr(map, buffer->vaddr); +out: + mutex_unlock(&buffer->lock); + + return ret; +} + +static void secure_heap_vunmap(struct dma_buf *dmabuf, struct dma_buf_map *map) +{ + struct secure_heap_buffer *buffer = dmabuf->priv; + + mutex_lock(&buffer->lock); + if (!--buffer->vmap_cnt) { + vunmap(buffer->vaddr); + buffer->vaddr = NULL; + } + mutex_unlock(&buffer->lock); + dma_buf_map_clear(map); +} + +static void secure_heap_zero_buffer(struct secure_heap_buffer *buffer) +{ + struct sg_table *sgt = &buffer->sg_table; + struct sg_page_iter piter; + struct page *p; + void *vaddr; + + for_each_sgtable_page(sgt, &piter, 0) { + p = sg_page_iter_page(&piter); + vaddr = kmap_atomic(p); + memset(vaddr, 0, PAGE_SIZE); + kunmap_atomic(vaddr); + } +} + +static void secure_heap_buf_free(struct deferred_freelist_item *item, + enum df_reason reason) +{ + struct secure_heap_buffer *buffer; + struct secure_heap_info *info; + struct sg_table *table; + struct scatterlist *sg; + int i; + + buffer = container_of(item, struct secure_heap_buffer, deferred_free); + info = dma_heap_get_drvdata(buffer->heap); + + if (!info->no_map) { + // Zero the buffer pages before adding back to the pool + if (reason == DF_NORMAL) + secure_heap_zero_buffer(buffer); + } + + table = &buffer->sg_table; + for_each_sg(table->sgl, sg, table->nents, i) + gen_pool_free(info->pool, sg_dma_address(sg), sg_dma_len(sg)); + + sg_free_table(table); + kfree(buffer); +} + +static void secure_heap_dma_buf_release(struct dma_buf *dmabuf) +{ + struct secure_heap_buffer *buffer = dmabuf->priv; + int npages = PAGE_ALIGN(buffer->len) / PAGE_SIZE; + + deferred_free(&buffer->deferred_free, secure_heap_buf_free, npages); +} + +static const struct dma_buf_ops secure_heap_buf_ops = { + .attach = secure_heap_attach, + .detach = secure_heap_detach, + .map_dma_buf = secure_heap_map_dma_buf, + .unmap_dma_buf = secure_heap_unmap_dma_buf, + .begin_cpu_access = secure_heap_dma_buf_begin_cpu_access, + .end_cpu_access = secure_heap_dma_buf_end_cpu_access, + .mmap = secure_heap_mmap, + .vmap = secure_heap_vmap, + .vunmap = secure_heap_vunmap, + .release = secure_heap_dma_buf_release, +}; + +static struct dma_buf *secure_heap_do_allocate(struct dma_heap *heap, + unsigned long len, + unsigned long fd_flags, + unsigned long heap_flags, + bool uncached) +{ + struct secure_heap_buffer *buffer; + struct secure_heap_info *info = dma_heap_get_drvdata(heap); + DEFINE_DMA_BUF_EXPORT_INFO(exp_info); + unsigned long size = roundup(len, PAGE_SIZE); + struct dma_buf *dmabuf; + struct sg_table *table; + int ret = -ENOMEM; + unsigned long phy_addr; + + buffer = kzalloc(sizeof(*buffer), GFP_KERNEL); + if (!buffer) + return ERR_PTR(-ENOMEM); + + INIT_LIST_HEAD(&buffer->attachments); + mutex_init(&buffer->lock); + buffer->heap = heap; + buffer->len = size; + buffer->uncached = uncached; + + phy_addr = gen_pool_alloc(info->pool, size); + if (!phy_addr) + goto free_buffer; + + table = &buffer->sg_table; + if (sg_alloc_table(table, 1, GFP_KERNEL)) + goto free_pool; + + sg_set_page(table->sgl, phys_to_page(phy_addr), size, 0); + sg_dma_address(table->sgl) = phy_addr; + sg_dma_len(table->sgl) = size; + + /* create the dmabuf */ + exp_info.exp_name = dma_heap_get_name(heap); + exp_info.ops = &secure_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 free_pages; + } + + return dmabuf; + +free_pages: + sg_free_table(table); + +free_pool: + gen_pool_free(info->pool, phy_addr, size); + +free_buffer: + mutex_destroy(&buffer->lock); + kfree(buffer); + + return ERR_PTR(ret); +} + +static struct dma_buf *secure_heap_allocate(struct dma_heap *heap, + unsigned long len, + unsigned long fd_flags, + unsigned long heap_flags) +{ + // use uncache buffer here by default + return secure_heap_do_allocate(heap, len, fd_flags, heap_flags, true); + // use cache buffer + // return secure_heap_do_allocate(heap, len, fd_flags, heap_flags, false); +} + +static const struct dma_heap_ops secure_heap_ops = { + .allocate = secure_heap_allocate, +}; + +static int secure_heap_add(struct rmem_secure *rmem) +{ + struct dma_heap *secure_heap; + struct dma_heap_export_info exp_info; + struct secure_heap_info *info = NULL; + struct gen_pool *pool = NULL; + int ret = -EINVAL; + + if (rmem->base == 0 || rmem->size == 0) { + pr_err("secure_data base or size is not correct\n"); + goto error; + } + + info = kzalloc(sizeof(*info), GFP_KERNEL); + if (!info) { + pr_err("dmabuf info allocation failed\n"); + ret = -ENOMEM; + goto error; + } + + pool = gen_pool_create(PAGE_SHIFT, -1); + if (!pool) { + pr_err("can't create gen pool\n"); + ret = -ENOMEM; + goto error; + } + + if (gen_pool_add(pool, rmem->base, rmem->size, -1) < 0) { + pr_err("failed to add memory into pool\n"); + ret = -ENOMEM; + goto error; + } + + info->pool = pool; + info->no_map = rmem->no_map; + + exp_info.name = rmem->name; + exp_info.ops = &secure_heap_ops; + exp_info.priv = info; + + secure_heap = dma_heap_add(&exp_info); + if (IS_ERR(secure_heap)) { + pr_err("dmabuf secure heap allocation failed\n"); + ret = PTR_ERR(secure_heap); + goto error; + } + + return 0; + +error: + kfree(info); + if (pool) + gen_pool_destroy(pool); + + return ret; +} + +static int secure_heap_create(void) +{ + unsigned int i; + int ret; + + for (i = 0; i < secure_data_count; i++) { + ret = secure_heap_add(&secure_data[i]); + if (ret) + return ret; + } + return 0; +} + +static int rmem_secure_heap_device_init(struct reserved_mem *rmem, + struct device *dev) +{ + dev_set_drvdata(dev, rmem); + return 0; +} + +static void rmem_secure_heap_device_release(struct reserved_mem *rmem, + struct device *dev) +{ + dev_set_drvdata(dev, NULL); +} + +static const struct reserved_mem_ops rmem_dma_ops = { + .device_init = rmem_secure_heap_device_init, + .device_release = rmem_secure_heap_device_release, +}; + +static int __init rmem_secure_heap_setup(struct reserved_mem *rmem) +{ + if (secure_data_count < MAX_SECURE_HEAP) { + int name_len = 0; + char *s = rmem->name; + + secure_data[secure_data_count].base = rmem->base; + secure_data[secure_data_count].size = rmem->size; + secure_data[secure_data_count].no_map = + (of_get_flat_dt_prop(rmem->fdt_node, "no-map", NULL) != NULL); + + while (name_len < MAX_HEAP_NAME_LEN) { + if ((*s == '@') || (*s == '\0')) + break; + name_len++; + s++; + } + if (name_len == MAX_HEAP_NAME_LEN) + name_len--; + + strncpy(secure_data[secure_data_count].name, rmem->name, name_len); + + rmem->ops = &rmem_dma_ops; + pr_info("Reserved memory: DMA buf secure pool %s at %pa, size %ld MiB\n", + secure_data[secure_data_count].name, + &rmem->base, (unsigned long)rmem->size / SZ_1M); + + secure_data_count++; + return 0; + } + WARN_ONCE(1, "Cannot handle more than %u secure heaps\n", MAX_SECURE_HEAP); + return -EINVAL; +} + +RESERVEDMEM_OF_DECLARE(secure_heap, "linaro,secure-heap", rmem_secure_heap_setup); + +module_init(secure_heap_create); +MODULE_LICENSE("GPL v2"); From patchwork Tue Aug 2 09:58:42 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Olivier Masse X-Patchwork-Id: 595714 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2A03AC19F2D for ; Tue, 2 Aug 2022 09:59:07 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236421AbiHBJ7G (ORCPT ); Tue, 2 Aug 2022 05:59:06 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42260 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236384AbiHBJ67 (ORCPT ); Tue, 2 Aug 2022 05:58:59 -0400 Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05on2081.outbound.protection.outlook.com [40.107.20.81]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 675CB4B0D9; Tue, 2 Aug 2022 02:58:58 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=RKZ30Yxv9kMZrofK0pOWwUgxqDVpuyFlmqLbKm4mnh9z7t1ciHh4L/3BdCQ3O99c/zCzv0SNcQaXv/E3G7Lja8Qqpz4STvEtODXjoHo/3rXA46mlBiYe0TMmtUV7vy5v4+u8UoPSp8Za5wjjfGZLdqKjHLDTgsJ2zIzNbB0ELpXrU+GnsM5Kt95kybYPPcah5YgPOVagHBz0ZGx4Ui1xfT916rg8TF6hiSJq18zjDAv+Z9MrRhMr2q4fRVfqRNWEJt6iQ52SD03C5e8GDLyrcMLMsZoSKhZ/VMjBk5U6tmBCqle1iIewXwIgfV96w8bmyXyMD3CGqTcbdcUI8AUk9Q== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=K4xR/woOXLlHvmkQLuIa5OL1e0+nSDFpkc1bQc3CCzg=; b=g0+hv2gWUACAScgCO9Un8zI0dR1QrZo69uQawKKCquVoiifhsWKlEe+iY/mrBUz/O9NPSWiBoIubF6sW9tzmf3JmRVU22gBgpulbWsc95GbIRLHKxsFwSW8l4cDu7KKumKQQCxqJDJFoVBYoB530Z853Rvqp5vmOuAzWCKVJ2viOOE74xr0lqztT2PE62Z13ACSfmoMuNCkK9IfdlNrWGH09qFBxZas4piOlkUkcJiZ/ORMx4JU9ccwi0VXLt/90NTfStYe7gLsT4FnuRIqw2+/F+QxQ252PdopzbDChgT3K/YORMJnmF3tZhDOCvzBBFob4T4OyEA+/cSmKHH2B2w== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=nxp.com; dmarc=pass action=none header.from=nxp.com; dkim=pass header.d=nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=K4xR/woOXLlHvmkQLuIa5OL1e0+nSDFpkc1bQc3CCzg=; b=gwuI7OBxjXwQZUv+SL8LBuGOhdiHFiLcRp0Zd2MYwf1Wcw+BKQNugIBRyDAeB6+KDsayTA0QWwUUj83EunwcHA1AEs8jhQ4/zX4CiBr/PeqZDkglHsUfwR0xxbTZJJ4yZuN+k7QLVJ9vKrpX2Mt83GOwqhKtNUMEWYFkXKQsqdA= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=nxp.com; Received: from AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) by AS8PR04MB8341.eurprd04.prod.outlook.com (2603:10a6:20b:3b0::24) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5482.16; Tue, 2 Aug 2022 09:58:53 +0000 Received: from AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b]) by AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b%5]) with mapi id 15.20.5482.011; Tue, 2 Aug 2022 09:58:53 +0000 From: Olivier Masse To: sumit.semwal@linaro.org, benjamin.gaignard@collabora.com, Brian.Starkey@arm.com, christian.koenig@amd.com, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org Cc: clement.faure@nxp.com, olivier.masse@nxp.com Subject: [PATCH 4/5] dt-bindings: reserved-memory: add linaro,secure-heap Date: Tue, 2 Aug 2022 11:58:42 +0200 Message-Id: <20220802095843.14614-5-olivier.masse@nxp.com> X-Mailer: git-send-email 2.25.0 In-Reply-To: <20220802095843.14614-1-olivier.masse@nxp.com> References: <20220802095843.14614-1-olivier.masse@nxp.com> X-ClientProxiedBy: AM3PR07CA0145.eurprd07.prod.outlook.com (2603:10a6:207:8::31) To AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 75cdf14a-ff6b-4faf-5a09-08da746d9b6f X-MS-TrafficTypeDiagnostic: AS8PR04MB8341:EE_ X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: Ep7FuFEqKt2zJczPpTiJyNMvQFLWQjjHi436wZsUoAzm57Chl1aLtRybYYAdlUy2yw1ImIbvzUYlserI8rPAA/dE49pkho4xnfsgrcxOU2DghrgTrqwzTcoa8/DncU04wONRx9v1wEd534TAX4Kux0GC1KRfCYy/qGernET/5RQo7lMP/BAr/Y09BQFf2u4+lMEpL3Wpz1DI96WEhDni4Wjutxb4mJjo2vHHdHWpauy9LLts/xQijyvAVC6kXfHFN42RKsV9KrsQ3tyUTiMsnqVMNScaoa3WxtlOb/uCLD/A20qwTfhzjvocNzwDRk1JrbbyG59RgqhVy6FnO3BeDQv8h/rUgeXZ4Nv4r+rV9p6UPVk8H2fSLF+AyRedM4G8WLRSXXybC4xGb2feOsNZYYzRhzxe9wVoJ9H04Jk0Z86fBP6IqZVo23bvq7oADjmHa1/JxsLLabvNQZyzKebpPmz7a/FI3PbGp1rCRayn88PaLg+3bdjJUax0pU4kOEcS925UwfJs5HzBzoUwKFaZTIlK3Q4+uMk5pRMK1Eu95oOad93DIyuXtujapQHVltXReclK/7uaoa50O/F5ehV09fj6VwrFcPpkKLDAR9nJPeOlV/7a5hgwk2CiA4onLkrt/4NYx/z2AayK82Xh4TPvQi4moV1hxTz/nLpGJsS37OACm2/lHG696dwiTgvbswtAFeVGMQzkG57eToxxmp+teDfe/sDSJhmxR3CSSELRPIzeNURsIu76snI1XlGCkFHJxDU93cum/K2I1nFyh52qLAfWQvwujLO/5/cCegj8g5OXOiwu8VplNykyVUCYcphztnPckaprE4M2kOKkXNIA+lqgbQvIhRoExwBxYKFIqBc= X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:AM0PR04MB6737.eurprd04.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230016)(4636009)(396003)(346002)(366004)(136003)(39860400002)(376002)(41300700001)(2906002)(83380400001)(2616005)(86362001)(6666004)(52116002)(6506007)(44832011)(1076003)(36756003)(26005)(6512007)(38100700002)(186003)(38350700002)(6486002)(5660300002)(8676002)(66556008)(66476007)(66946007)(8936002)(478600001)(4326008)(316002)(966005); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: LXxq85t2tpLuzH0dSrDUBcqA3pujmVT7+8H7G1RxgqzcUSWuy0axs3fyv3RM0CAO5OqnY8nrZ2QbR30Sz/BCWbzytSkWkz4YHmxnxldlkGdF6pIW/OfKf0wWdO0Ezh9YJUF4eUWU/dSH/1Sno97JKY0MnRBKnHhcUewBoIMCfKfntdk/i7t8s5lgkljP+rBSv7geCcBtKktYg080ddOpj4d8RAcJ/33/4rBXX45n515ZUlqWDNsatjlarQG3l+lv+Pw7LGuaurE2sgsz3M2THRnRn/mu72yLF2gRNoibQI63kggg5A3mfgoDJUrA0hnoNlb8fLZike0+/ksQAD9JGyg5JTxKeFsymQ3m2MBucYanqFti248mLYs4bihDdNEtNzjpiSBN0X5UCk5HE3mdbrgIcp10q6zWic/c4K5fNCu7BGJX2bmUztxCxZ1I/OCXrUKZL4+FFJJS5hlI/nXUn3zO1R7oRHcuCDVAXbNfzdrOJ0sK9T11MArjuxQyp2RjRIAfJP+Ojeqe7mq2ahxvl71/GgrJ46tJiKetbxdu6hmy0bfV47TFJ2ICLSF/0dy8RJykWZov/MAiiOjEbbWJuxYMD/raICBbYU3ai4u0EsdMjkbBorpQbYkMbxfKk3qA8vnAllW5dl2/ChzYNTOREcOjkHjhIwHFtDWs8XyK0+b6+X/7jokdRGC/+pI+lWJK8f5A88qVyrK4djYuXB78W9YtCQGMfN+aV9gehgVD+w0pLjbSncTFg8KVPZTWn09kTYuycQh6L91XagxIWB08X2n/ZmP0IqNRXgZX0GapSpSeBSKJvsUAYUypdzDItQsRf7eCaPozByYu2OTUcMwQ+jO3E8+z1uqZbJ3eWWlgJptjOTY16/ygRUSv0mMnqUwC63ihyiBX9hkuK4vfme+CVvbiQfvmhN2KaaUKMgmmSCjWg8fjttURakup+OpQkizCmOAOajmrWmiWJmWo+9G85Rv9VT8f/lIcPTgERvscXU1JZrKIJYLgvbzDBc5D/hnVvAFi33a7LEpmKNVGYh91iWYk+Knptv7gCP8j2G1e7QetnMXq9DvpNQhJhdoNe78PxFZNsdUPHWSOLFgnK2vKWx40oBvqjqWYOFBJsMAVYBJeTENii7zLKASLl24h6F3s3d3OGUXFMgl+wjcm0T2ZE0+DHJ/V0WEytCNHw9uncH8Mp+8xem28kZwwGClo4kGsT4E+JWKDlOM+DC2DUMZ0Hcsc91IcL2uQf6V1rmsCEhvJdWV7Nx2lXqZcSxtmQbXF1jkHQOF9d8349XnAi6qH0wWEE9IQcIiIG1me4GBLzLPHfovEL4qYa/n+vWPjxKCGc1k64yNWW1U++gRhDfncbrP0I62YouRc9EldsY3Lk7JpuFGEIDulS4Qx15jIRUKG5tdwgYgX3g/9LVhD6WVCPvYwZBo0VJFGB87pWZi8rl/BBQkIJNzm7OjvrIh7yDturgPysP5VEBhhbA6k/ZKasX/7qzp8zIJPHpTxiHypI4IG+AK9HiNlmMbZmrfIwIuaX5SueXRjLRdCTE1IOXdlpRSm1YvfxOjvE+v1wzn7qN1XWOWFYM1uZNDz+SunhFnt X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: 75cdf14a-ff6b-4faf-5a09-08da746d9b6f X-MS-Exchange-CrossTenant-AuthSource: AM0PR04MB6737.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 02 Aug 2022 09:58:53.6244 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: aqEHAmRMpZxJXpI403FoUa7gn8OjolFDzYfuLopI1dJqRc5Lxzwx2jjO0mFHe4aNSRkIs7GXsA6Nn9P07WndIQ== X-MS-Exchange-Transport-CrossTenantHeadersStamped: AS8PR04MB8341 Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org DMABUF Reserved memory definition for OP-TEE SDP feaure. Signed-off-by: Olivier Masse --- .../reserved-memory/linaro,secure-heap.yaml | 56 +++++++++++++++++++ 1 file changed, 56 insertions(+) create mode 100644 Documentation/devicetree/bindings/reserved-memory/linaro,secure-heap.yaml diff --git a/Documentation/devicetree/bindings/reserved-memory/linaro,secure-heap.yaml b/Documentation/devicetree/bindings/reserved-memory/linaro,secure-heap.yaml new file mode 100644 index 000000000000..80522a4e2989 --- /dev/null +++ b/Documentation/devicetree/bindings/reserved-memory/linaro,secure-heap.yaml @@ -0,0 +1,56 @@ +# SPDX-License-Identifier: (GPL-2.0 OR BSD-2-Clause) +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/reserved-memory/linaro,secure-heap.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Linaro Secure DMABUF Heap + +maintainers: + - Olivier Masse + +description: + Linaro OP-TEE firmware needs a reserved memory for the + Secure Data Path feature (aka SDP). + The purpose is to provide a secure memory heap which allow + non-secure OS to allocate/free secure buffers. + The TEE is reponsible for protecting the SDP memory buffers. + TEE Trusted Application can access secure memory references + provided as parameters (DMABUF file descriptor). + +allOf: + - $ref: "reserved-memory.yaml" + +properties: + compatible: + const: linaro,secure-heap + + reg: + description: + Region of memory reserved for OP-TEE SDP feature + + no-map: + $ref: /schemas/types.yaml#/definitions/flag + description: + Avoid creating a virtual mapping of the region as part of the OS' + standard mapping of system memory. + +unevaluatedProperties: false + +required: + - compatible + - reg + - no-map + +examples: + - | + reserved-memory { + #address-cells = <2>; + #size-cells = <2>; + + sdp@3e800000 { + compatible = "linaro,secure-heap"; + no-map; + reg = <0 0x3E800000 0 0x00400000>; + }; + }; From patchwork Tue Aug 2 09:58:43 2022 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Olivier Masse X-Patchwork-Id: 595031 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id 2FC5AC00140 for ; Tue, 2 Aug 2022 09:59:12 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S236432AbiHBJ7J (ORCPT ); Tue, 2 Aug 2022 05:59:09 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:42278 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S236385AbiHBJ7A (ORCPT ); Tue, 2 Aug 2022 05:59:00 -0400 Received: from EUR05-DB8-obe.outbound.protection.outlook.com (mail-db8eur05on2081.outbound.protection.outlook.com [40.107.20.81]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 7E1124B0C9; Tue, 2 Aug 2022 02:58:59 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; s=arcselector9901; d=microsoft.com; cv=none; b=eDwRj+yjEJSvNRpVq6aK1qC7Qip5Q3RIwjQDOR1lseqtlBfg1kvRCocdKywFRzWy/0r8hHIiOpNV7AwTX3UVGvGxHW9MnGyOY9PMlhiMZZdKHJaCJXS/PfVDzHCyujsco+eXUf7B8nV0RzPwQuWWDOFMBT084pcBH8o5b/Ru48R/Z5ZRBKpfTDd1ZV//cu2VcPGmbGJfAg7PU15JBjcxIWl/2Vjz9LgBJDr0kU7VksO/PPFndELkYxTeVj/gBoVJdJOyX65B6eoOX0NFL5KQcIWclQ5wM5G/8sECSgv+WieTRxhchV91eTAxHv33ewp7dqV2duTVzPm3RUa9/KTPuQ== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=microsoft.com; s=arcselector9901; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-AntiSpam-MessageData-ChunkCount:X-MS-Exchange-AntiSpam-MessageData-0:X-MS-Exchange-AntiSpam-MessageData-1; bh=JMaUYaQcN4WcuDP2F3cy1CDudujZulTsfHyIvpHi2No=; b=icpEcizahJ3iDQv9xzooReFlRHAgJF3ZDylbfL9d/th3Ocz8cTSvY/GJ4VvdSX3ribyAsXfOq228v4oo4dfZ5Yq96PR/tOzUtPjnRFJ1e7vm58MPYAfM1MYP7/D0BS/1klDynUZ9rfAumrb1zkh70pzyrflWI/3Uqh8m/RmHWAd2EAY8KQyJrsMnN4Wdt8apIXUBFE5s4oIEdIPJfMB5aqj/6XZPChH2fZw+ov8Rmrr/Uub4o0BhysTMf74wRegR/RgWKhjDJ6VO63N7ZIFyaotp3jSZwEc+Ua9TTthzcdiGZv9KH8Kp81RUK80Y8bPSl/vvEK7/KVBfF5sn/aGzyg== ARC-Authentication-Results: i=1; mx.microsoft.com 1; spf=pass smtp.mailfrom=nxp.com; dmarc=pass action=none header.from=nxp.com; dkim=pass header.d=nxp.com; arc=none DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nxp.com; s=selector2; h=From:Date:Subject:Message-ID:Content-Type:MIME-Version:X-MS-Exchange-SenderADCheck; bh=JMaUYaQcN4WcuDP2F3cy1CDudujZulTsfHyIvpHi2No=; b=ITC6Q6ai+LFYlnRUbOVAtjiEoF37uJn7lVsueg7ZLJBpXVlDDyzFcPwEyj+EWcYczcJrFfnCSgLcok6CQyT2cjENCFPXbkj4kfbZBSs/GvYUDp2A13e/ZmHYC2L3MwnNdwNF7vvLa5Z1XDssz1DDWbcsz4HqNSWkp2zl2puNzrw= Authentication-Results: dkim=none (message not signed) header.d=none;dmarc=none action=none header.from=nxp.com; Received: from AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) by AS8PR04MB8341.eurprd04.prod.outlook.com (2603:10a6:20b:3b0::24) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.20.5482.16; Tue, 2 Aug 2022 09:58:54 +0000 Received: from AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b]) by AM0PR04MB6737.eurprd04.prod.outlook.com ([fe80::6ca7:299e:d92f:7d1b%5]) with mapi id 15.20.5482.011; Tue, 2 Aug 2022 09:58:54 +0000 From: Olivier Masse To: sumit.semwal@linaro.org, benjamin.gaignard@collabora.com, Brian.Starkey@arm.com, christian.koenig@amd.com, linux-media@vger.kernel.org, dri-devel@lists.freedesktop.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org Cc: clement.faure@nxp.com, olivier.masse@nxp.com Subject: [PATCH 5/5] plat-hikey: Add linaro,secure-heap compatible Date: Tue, 2 Aug 2022 11:58:43 +0200 Message-Id: <20220802095843.14614-6-olivier.masse@nxp.com> X-Mailer: git-send-email 2.25.0 In-Reply-To: <20220802095843.14614-1-olivier.masse@nxp.com> References: <20220802095843.14614-1-olivier.masse@nxp.com> X-ClientProxiedBy: AM3PR07CA0145.eurprd07.prod.outlook.com (2603:10a6:207:8::31) To AM0PR04MB6737.eurprd04.prod.outlook.com (2603:10a6:208:176::18) MIME-Version: 1.0 X-MS-PublicTrafficType: Email X-MS-Office365-Filtering-Correlation-Id: 219c9b1e-b2c4-4692-8da2-08da746d9be6 X-MS-TrafficTypeDiagnostic: AS8PR04MB8341:EE_ X-MS-Exchange-SenderADCheck: 1 X-MS-Exchange-AntiSpam-Relay: 0 X-Microsoft-Antispam: BCL:0; X-Microsoft-Antispam-Message-Info: 7dpQHTNFi7odGQcvJk16ccjyLXpRdt16fWo4qhXIVDJf3UZz7uCLvjC/5JnmtfozspZlAgwNFycRj8g4r+YeHsmaBRC98e5CnEC+xpfnvw/PgGiPlepeu6EZy1zYg1ecaUmgQ70d5jbKZxikCKPrymdFtRwNeGiZC4g7l4tT+HblPbUlNAw9IuqMuqrbHP/Wswq7lvJBYVimgWnE3gvUEEL0KZrIgjGLCvyAjnUebkWGsSpffoGJ+Kc5HQ+rF91OJ7PFcJ7AtVaybrbpRr82enf58zEXlHbfZS90VUwGm/+/hXaM31bWXXSHTJpLiDopWFHp8AQlsOfPtzW2vZQFMKklvKET6sIVW3/fyKnMkIfh8ttS4MRMnVWvWMrU0UCjjXJ6nFFmHrOPeNPoq8dZtvimksgiv/k3EXt0uxXDCExkFAVUJ3SM4e8zbjJApxh6qMZ9EwiFm+u8h8Nj814mOCk9jDhasjdDzRHHUq+bNofRzr52UxVzx28FtvQzYMp4esmnf+O0J7rgeDPDKINetdgDgW1Q8IiQu2zYxH+e22qOLMllFHHkGVbzbJmOY+KdOcdrvAS45a88VS1MTOrow4F3zEHOxJQx4psR0YXsMX1nM1fsAU6kqOKZAqAPLvFcHwmtiFog5TorBVh0rIMqIkq0Yt7uh9kurU2bLSYhIdmCvoiaIElsKXljO7MbejNurJVA/AdGy8CKQiabCzjZIAae6WQMKNwXSpHZZ3870CAr98KR6WXZ+qQ1wbJ4MthWfqN149LXcy6fI4VvnIOV9WJnRQInAD/q+1DfoNHJCsI= X-Forefront-Antispam-Report: CIP:255.255.255.255; CTRY:; LANG:en; SCL:1; SRV:; IPV:NLI; SFV:NSPM; H:AM0PR04MB6737.eurprd04.prod.outlook.com; PTR:; CAT:NONE; SFS:(13230016)(4636009)(396003)(346002)(366004)(136003)(39860400002)(376002)(41300700001)(2906002)(83380400001)(2616005)(86362001)(6666004)(52116002)(6506007)(44832011)(1076003)(36756003)(26005)(6512007)(38100700002)(186003)(38350700002)(6486002)(5660300002)(8676002)(66556008)(66476007)(66946007)(8936002)(478600001)(4326008)(316002); DIR:OUT; SFP:1101; X-MS-Exchange-AntiSpam-MessageData-ChunkCount: 1 X-MS-Exchange-AntiSpam-MessageData-0: w44S6pk0jx5fXLp4QdyaZ1RCUQh13jmGIQ0caYHy7TLUvg0m1QEmImdq/eDEE18iktoe3LZBKzF2r2l+lxS0jll3NZt3Ak7xPbWZA/XOkSsKC0EV2sVVYzkE0oAHJi0+2VzphTpy9JyX9eW9Yic1e5p2+PAMVlgM5oTzyHZ/f6Ag5q1+xbVmUSwmeg7jDobMyW6TW8yt/mAzbsgqSWinSTP0iij/wU34wl37uUzuiQoTkeQnYROzQgMADxkyBbzS6KKjXNJcqHCWivhu3SrjpmP9NjS2voK6Tf0EDwYVd7ozqYiGh8qIbl7aK+W8DNFWUevbkGKrFqP3PqP17FIUkUyTxBG1KClSpbXii5M7NucMl0gNCwKXRPmBUxS2OkQ4GsolrdwEqHdGMn3t7OI0aKCAnFSUQh5yyE2E5VNoDChyVPqpQwwC3wGW1E+WSPryEWEAfD2UYgViowrSRWKT3TCM6CAnBjDXsIpbFxoQvrPfIf1hq/5S79TPotyTNzMRd/6bncdFAm/liAAnK2bHwXE4N+1KnhaQn3musgza7T6rtlgCRFA2jeM2+NDHtggtILtAJdDLVc2tdY2j2UNfoOR2RQX6oenQtZe2N5vhARUywUaVlEkiScf/ga8cadEPAmFzJiWwoH++HZf0ldPeKU6VzaWkmP6MAnjgAZL8j24jVJAs4YKmuLZNhcGWEZo477bTm3WzeEh7ciLV8EXPXiaArxOIrUFKA/BFOaRvjv4JnEw3xIHs43OzttEKvvDhCAxIm1iRmTS27iulAA07fxUPUavq7dPOco6wcwsJxqM6g+bFT0dS/9t7ArEzdAQZVooQilRIpHU5gXSnY9nEWmIvu0a+LiBbgRiW2Ztl2eAT1j6rEBZ+M7KGRDD6LgBhkD7SX3f5N1zM8fjet9/eD8yYt+5X/Y6CL/mUfqsVN/ZxxLl37ut8r/s4Dmcfd7FDDG28pdtMFfV3YeEPV4DNx3kuVWofRNqBm/hQw7I2fOsox25qbu/abN1+T/A9BZmHSANSgfyDWOgUOr7dQlt+WufYdk+Eko0AZM0fgFkxqs+Wl2v8GxkKaSvOmbhGea/r8pz8+7Wz1Gtmt4rCJEimvqLEZtxViIGzWUMdQvBc07O6RrmxHRfxymrFrQfH9koVNSI4rxPtGA0jmeWwL7hUvVOKTYvyfQB0OtwNe55xuhvcDHV3DTbgdEVi6l056lJPMBo775fF5Q3K0Tuu0i11ojWf1Z2dblT0NbZVQTRuiuYyU6XiQeHCnZGRc56Nfg9QIqYOB2NZdaqIy3/NmuMGgU3mBW/JNZf8IBFCsOWG/ZaKFCFiX7gbUOZkwXenJHFfQqnBc9xlVS1NncYu+BMMGeVUa0SduJqEB2ew0+PDs786jw07/agkR9qhlsKLHjW9pfP1n7qHTUcCk0BFg/BSjV9B9efs60MfBTlIQzA2lqIKmcMVW1JOkC2ZRrndKeD/iFaPlwI4rUeNrQroQEZDk7IU0VG/G1S5+Oszs3xE6afG64oUzxAwZXizyI9ier27cVjLi2w0YzIiue6ayZd3iIJk/Z4JA2+Utt/T9nZFZpLskxUt4/xGPZMrF0NXRUa2 X-OriginatorOrg: nxp.com X-MS-Exchange-CrossTenant-Network-Message-Id: 219c9b1e-b2c4-4692-8da2-08da746d9be6 X-MS-Exchange-CrossTenant-AuthSource: AM0PR04MB6737.eurprd04.prod.outlook.com X-MS-Exchange-CrossTenant-AuthAs: Internal X-MS-Exchange-CrossTenant-OriginalArrivalTime: 02 Aug 2022 09:58:54.3587 (UTC) X-MS-Exchange-CrossTenant-FromEntityHeader: Hosted X-MS-Exchange-CrossTenant-Id: 686ea1d3-bc2b-4c6f-a92c-d99c5c301635 X-MS-Exchange-CrossTenant-MailboxType: HOSTED X-MS-Exchange-CrossTenant-UserPrincipalName: XbUbVGGO3CBWraDX6qkrzPjjNmBRvqTX9hINUUh2Of1C44RobwJOOdDpd+US+wC7bKn0V4ldQp0PDyx8NceGXg== X-MS-Exchange-Transport-CrossTenantHeadersStamped: AS8PR04MB8341 Precedence: bulk List-ID: X-Mailing-List: linux-media@vger.kernel.org Add DMABUF_HEAPS_SECURE in defconfig Signed-off-by: Olivier Masse --- arch/arm64/boot/dts/hisilicon/hi6220-hikey.dts | 11 +++++++++++ arch/arm64/configs/defconfig | 4 ++++ 2 files changed, 15 insertions(+) diff --git a/arch/arm64/boot/dts/hisilicon/hi6220-hikey.dts b/arch/arm64/boot/dts/hisilicon/hi6220-hikey.dts index 3df2afb2f637..e4af0d914279 100644 --- a/arch/arm64/boot/dts/hisilicon/hi6220-hikey.dts +++ b/arch/arm64/boot/dts/hisilicon/hi6220-hikey.dts @@ -258,6 +258,17 @@ optee { }; }; + reserved-memory { + #address-cells = <2>; + #size-cells = <2>; + + sdp@3e800000 { + compatible = "linaro,secure-heap"; + no-map; + reg = <0 0x3E800000 0 0x00400000>; + }; + }; + sound_card { compatible = "audio-graph-card"; dais = <&i2s0_port0>; diff --git a/arch/arm64/configs/defconfig b/arch/arm64/configs/defconfig index c09b07c22d57..4b625043313d 100644 --- a/arch/arm64/configs/defconfig +++ b/arch/arm64/configs/defconfig @@ -1465,6 +1465,10 @@ CONFIG_CRYPTO_DEV_HISI_SEC2=m CONFIG_CRYPTO_DEV_HISI_ZIP=m CONFIG_CRYPTO_DEV_HISI_HPRE=m CONFIG_CRYPTO_DEV_HISI_TRNG=m +CONFIG_DMABUF_HEAPS=y +CONFIG_DMABUF_HEAPS_DEFERRED_FREE=y +CONFIG_DMABUF_HEAPS_PAGE_POOL=y +CONFIG_DMABUF_HEAPS_SECURE=y CONFIG_CMA_SIZE_MBYTES=32 CONFIG_PRINTK_TIME=y CONFIG_DEBUG_KERNEL=y