From nobody Sun Jun 14 01:35:34 2026 Received: from mail-pf1-f201.google.com (mail-pf1-f201.google.com [209.85.210.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 2D99A28002B for ; Tue, 5 May 2026 00:27:41 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1777940862; cv=none; b=A/wgWHDglFGrFP0nbcpZE7WQikk6cDUHPddRRf5P4twuvtufge4KA3Zn8JbZsWfXHMoT7iomoCRerRj+uq8EeB/310zELBaPskryQVTQdKDhfCMrwkTdEPVZG2sYikDXHXI8DaylG5i/hRLirXlipRNwY8un3gn7CRhNudrdo8c= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1777940862; c=relaxed/simple; bh=6vPJz5FklGOmRIlTlxNWv/NMzXGEFSNYxGd2jakuq1k=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=DDmFVDXX4fdaeY4R0iJxZqjYtVBWCzT03eg7ytsk6ZOXEQpSXKrJN9jJ7CUSdoyFBAdMUrgEhKxoGYf8b2vkxET739FQ6DMnbL4AQThfwOJYTrNNPaO0WgrwEyc76JxXebZiU+tirWkiiK9mXgbIyT//x/EcwK1TdBPHSBCjTaE= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--skhawaja.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=rXg8Xfa0; arc=none smtp.client-ip=209.85.210.201 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--skhawaja.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="rXg8Xfa0" Received: by mail-pf1-f201.google.com with SMTP id d2e1a72fcca58-837cc5bc6deso944135b3a.3 for ; Mon, 04 May 2026 17:27:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20251104; t=1777940860; x=1778545660; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=b+FOv1S5jZxTI8xiOq/TIFYAKVGB2GSKJ5eXMG7ksgc=; b=rXg8Xfa0WzMWCIGkhkqORTXLBHm39I+xEqo8msLWUMFu8pYDRTxbHtEiG5s+QUocvM UWkCblU/fWOkiTgrzRjOOLwlPnKpOBEQfsIZqkRWngIRvIlUcDIpEXYQv5YjCbZRdkl5 zR1mdukgCm4NeCs629lYxO4DJv2ExgXKiVSQKSd6/JM3mQ+SCyHlK4S9SSkoCrBKYroS 9r81pQ1adfvmJ59eh1yYEzPr9oM83ZzgvYgkAS9xPfDdXQxn9E/iMfNgPKU9OtXwQvzx 0j1buKMhuNVyY+JzHv4Kw2ONwtgEreoDaTxhS+mR9l9nMgFkZng4yIge3d055d0Djias uoFA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1777940860; x=1778545660; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=b+FOv1S5jZxTI8xiOq/TIFYAKVGB2GSKJ5eXMG7ksgc=; b=LO8gCCqdaYrHbT+9ch77gmm+bKEJiY6ChYfAo9/Yl/wSzjQg/fKzlN2Qm8A6aXWD93 FTqBmnYiSHZm9NH8Ghw3QySSOdqnYVmWX52W3hqieSJyGYqg+LlO+i6qUbJpdgh443em h0Fx0fRrGIOWj9dZaiJ7464OiyglVAJX+HOhg1AxtRa7XhqdJ9YClUqoCWZ2z3dLafcG oyuiK6d7PunCi9plLQXT+3/Hm2kt9ZMm6y+PPwKXeTMZnoVopkF1ui0IcQW4/4CMbnGi tE91JB3Xlcc+/bdGEYMjt+5P7Z1XUkMg329B48fpInqoUPnBb4fZTflaoIhU9jtpNNUv ufUg== X-Forwarded-Encrypted: i=1; AFNElJ9WkZVeR24VNh/rLAg/aORu0qxcXa5Sn0aH9cuz0trOWfq7qbtlWWIyEqHSH9+kH/pYOMavoaQfu41RnhM=@vger.kernel.org X-Gm-Message-State: AOJu0Yz2m9yGeOxGjXv6ZtcGk14nJ8ntjgLYxFYy7k3lf77baJa3lQdW vheU0yKAGb1C74OlY0BDA6eDlHkZrGs7HkSx7XWGlGNlKc/F81SsDoVU6a3emCS/VUqkmjqGigh VLqt7jAj1dR4VDw== X-Received: from pfnj5.prod.google.com ([2002:aa7:83c5:0:b0:82f:8a3b:87f0]) (user=skhawaja job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6a00:1f04:b0:836:5c3c:2051 with SMTP id d2e1a72fcca58-83923d96a31mr1009427b3a.23.1777940860319; Mon, 04 May 2026 17:27:40 -0700 (PDT) Date: Tue, 5 May 2026 00:27:34 +0000 In-Reply-To: <20260505002737.2213734-1-skhawaja@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20260505002737.2213734-1-skhawaja@google.com> X-Mailer: git-send-email 2.54.0.545.g6539524ca2-goog Message-ID: <20260505002737.2213734-2-skhawaja@google.com> Subject: [RFC PATCH 1/4] dma: Add DMA allocation preservation KHO ABI From: Samiullah Khawaja To: Marek Szyprowski , Will Deacon , Jason Gunthorpe Cc: Samiullah Khawaja , Pasha Tatashin , Mike Rapoport , Pratyush Yadav , Alexander Graf , Robin Murphy , Kevin Tian , iommu@lists.linux.dev, kexec@lists.infradead.org, linux-mm@kvack.org, linux-kernel@vger.kernel.org, David Matlack , Andrew Morton , Pranjal Shrivastava , Vipin Sharma Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" The DMA allocations can be backed by a variety of allocators. Add KHO ABI for the preservation of contiguous allocations that are done through dma-direct. Signed-off-by: Samiullah Khawaja --- include/linux/kho/abi/dma_alloc.h | 30 ++++++++++++++++++++++++++++++ 1 file changed, 30 insertions(+) create mode 100644 include/linux/kho/abi/dma_alloc.h diff --git a/include/linux/kho/abi/dma_alloc.h b/include/linux/kho/abi/dma_= alloc.h new file mode 100644 index 000000000000..46e61db81abe --- /dev/null +++ b/include/linux/kho/abi/dma_alloc.h @@ -0,0 +1,30 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +#ifndef _LINUX_KHO_ABI_DMA_ALLOC_H +#define _LINUX_KHO_ABI_DMA_ALLOC_H + +#include + +/** + * DOC: DMA Alloc ABI + * + * This header defines the structures used to serialize the state of DMA + * allocations, done by device driver, across a Live Update. + * + * Only DMA allocations done through dma-direct that are contiguous and + * allocated using alloc_page are supported. + */ + +/** + * struct dma_alloc_ser - Serialized state of a single DMA allocation + * @page_phys: Physical address of the preserved pages + * @size: Size of the DMA allocation + * @force_decrypted: Whether the memory is force decrypted in previous ker= nel + */ +struct dma_alloc_ser { + u64 page_phys; + u64 size; + u8 force_decrypted; + u8 padding[7]; +} __packed; + +#endif /* _LINUX_KHO_ABI_DMA_ALLOC_H */ --=20 2.54.0.545.g6539524ca2-goog From nobody Sun Jun 14 01:35:34 2026 Received: from mail-pf1-f202.google.com (mail-pf1-f202.google.com [209.85.210.202]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id BB1C8286D73 for ; Tue, 5 May 2026 00:27:42 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.202 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1777940864; cv=none; b=KfEhks5jIGhaOQFEJHc+OLtz162Y7kQOI6KVx+96qSmb6h2CwC1+mc32/d959RJhc8RZHN9UHI8YQQMJK3sBuTostyImxodUo+I2yD9CZL4QSX5rdUWKkK+bBEMioHuHdfF5+wkiPKitz+QVtx+NNvlBeGUcHlsOdOB6wBV8w0A= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1777940864; c=relaxed/simple; bh=CCcGBBN0jmPI/uNBfL2Btoc6e31bbEmFkyduYlT94ZM=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=D4OWWeNq32+Uk60J1C8JkiHCTk9uYAor1Z7rxyOwndz71A6BBsQLqLvormxHPGMHhqT/qzi4oVDNYeXGed5KJKoYuYnewdVfgOH2O9gX94A9OlW5LyGtfJ+1QiLnKAb5u6lZoZoYIVcABmqgRTdGkYD7Jg8Wxv6FQGbINh16/rw= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--skhawaja.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=iMALeVGU; arc=none smtp.client-ip=209.85.210.202 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--skhawaja.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="iMALeVGU" Received: by mail-pf1-f202.google.com with SMTP id d2e1a72fcca58-8230d6d54a5so3503628b3a.1 for ; Mon, 04 May 2026 17:27:42 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20251104; t=1777940862; x=1778545662; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=fPL/zEjIbq1+/WxDxvRlbVhXmcB0wkR7Z2KUt1rRxnY=; b=iMALeVGUeVk/rJM6g+Dw5FKK3mHBBH2NuKS44R0L4w62A8f/nWEzEEC++w5U9IOGY3 t600pjkYLyJphwcS9SljyYMlS+3akcW1rUPHXGi+k/GJ51iAlao+3JjOWjsat9isTlq4 rzyyFH4D+DBnr3ZY4I8RHVvUXkv984UbJOuswYG13O4GaiiyeMdIKxMGvkyrUU/0E0ya eSP3iwsxP3lHf6ZarxfBu7hbgnFRWBbmiX2gB1IPAtY0InWzuu80AOEdANI+vtrm0uf/ GSqY/TMKgtPT8XHlR+TfEPgkGMNH2AhyVLavPY6t+izckBL8Ki79p8bnIXa4IedtfUI4 MhRw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1777940862; x=1778545662; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=fPL/zEjIbq1+/WxDxvRlbVhXmcB0wkR7Z2KUt1rRxnY=; b=n0Od+ohD6e1XnstfVuU+9Uv0AqYwtvKyHH5gTHaTwxTygjX4mlMQq8kUf6S86gaO8h cagOVT5t8OIoDzaQhNDbhILipXHuJd40mxaTYrd8PrMIkdhJWoJzH4Ruq9ls2G2w1wdH mXXQWuA0HIrXxYgo+MbHLMDcxpfxNakGJ6r+uAcpFFuavFHdTKdyPVaWA6+V5kEoy5rQ IdPu7ztXrk5X+g2W7JR1tHAeGX8FJgg26Ndb0tiDdbPYCxFCQdaAo/iAa1EMV7NCAK3P ebcGldz3xwM4CzP4tRBlEfgqStXkeZ6YBXesa2IYhueKzjRrDZ0PK4Guxfos9bnCbnQ2 Pr9Q== X-Forwarded-Encrypted: i=1; AFNElJ/wTa0qoTsm5bEin9ZJcfe/mSEuKU2V52xNBHYwoFOPo5PrehP7MOii8z11zcZJtLaomwHPWtb9cnRAl3w=@vger.kernel.org X-Gm-Message-State: AOJu0YxBPhk78E8U6jOLbptN6OV1NYXtAWoV+CjNx4wxm1VCdh5SilYr CelGk4RSCH/dBC5k60LXeHJJhw99UcLqksf/B5sE21a5VVj9tWjy1BwuX5bnSVg6C7Tq+wR2h6B V5jX+TID6HIwqFw== X-Received: from pfbgj10.prod.google.com ([2002:a05:6a00:840a:b0:82f:d8c0:fef8]) (user=skhawaja job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6a00:340e:b0:837:8a0c:8f70 with SMTP id d2e1a72fcca58-838fe8703c4mr1212855b3a.28.1777940861986; Mon, 04 May 2026 17:27:41 -0700 (PDT) Date: Tue, 5 May 2026 00:27:35 +0000 In-Reply-To: <20260505002737.2213734-1-skhawaja@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20260505002737.2213734-1-skhawaja@google.com> X-Mailer: git-send-email 2.54.0.545.g6539524ca2-goog Message-ID: <20260505002737.2213734-3-skhawaja@google.com> Subject: [RFC PATCH 2/4] dma/pool: Add an API to check if DMA allocation is from pool From: Samiullah Khawaja To: Marek Szyprowski , Will Deacon , Jason Gunthorpe Cc: Samiullah Khawaja , Pasha Tatashin , Mike Rapoport , Pratyush Yadav , Alexander Graf , Robin Murphy , Kevin Tian , iommu@lists.linux.dev, kexec@lists.infradead.org, linux-mm@kvack.org, linux-kernel@vger.kernel.org, David Matlack , Andrew Morton , Pranjal Shrivastava , Vipin Sharma Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" DMA allocations can be done through DMA pools, add an API that can be used to check if an allocation is done from a pool. This will be used in the later commit during preservation of DMA allocation. Signed-off-by: Samiullah Khawaja --- include/linux/dma-map-ops.h | 1 + kernel/dma/pool.c | 13 +++++++++++++ 2 files changed, 14 insertions(+) diff --git a/include/linux/dma-map-ops.h b/include/linux/dma-map-ops.h index 6a1832a73cad..6a0bc4ea2467 100644 --- a/include/linux/dma-map-ops.h +++ b/include/linux/dma-map-ops.h @@ -216,6 +216,7 @@ struct page *dma_alloc_from_pool(struct device *dev, si= ze_t size, bool (*phys_addr_ok)(struct device *, phys_addr_t, size_t)); bool dma_free_from_pool(struct device *dev, void *start, size_t size); =20 +bool dma_is_from_pool(struct device *dev, void *start, size_t size); int dma_direct_set_offset(struct device *dev, phys_addr_t cpu_start, dma_addr_t dma_start, u64 size); =20 diff --git a/kernel/dma/pool.c b/kernel/dma/pool.c index 2b2fbb709242..32ce4d6d7683 100644 --- a/kernel/dma/pool.c +++ b/kernel/dma/pool.c @@ -307,3 +307,16 @@ bool dma_free_from_pool(struct device *dev, void *star= t, size_t size) =20 return false; } + +bool dma_is_from_pool(struct device *dev, void *start, size_t size) +{ + struct gen_pool *pool =3D NULL; + + while ((pool =3D dma_guess_pool(pool, 0))) { + if (!gen_pool_has_addr(pool, (unsigned long)start, size)) + continue; + return true; + } + + return false; +} --=20 2.54.0.545.g6539524ca2-goog From nobody Sun Jun 14 01:35:34 2026 Received: from mail-pf1-f202.google.com (mail-pf1-f202.google.com [209.85.210.202]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id A23AE282F32 for ; Tue, 5 May 2026 00:27:44 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.202 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1777940866; cv=none; b=JF6J0FoAyae+eBSr5Vy5kF0K5wrmQGxolNO0klObt7/XDnd4hizOU+AnxgnzSOYC07UbJ1eNDeB2t6CeGbeVLMA6XnlYYkdy2lQD6ns1L48IpgbPBVcsRSgqmdcM5uUoO2P6B06N0XdpH8FhLLUCBtxnsTdTaRPVRhZTFeUhfOY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1777940866; c=relaxed/simple; bh=aM+uxzi74ErOIQV1wNCkBoE1fYEbHevhpMfCkOITqpY=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=kMFkt2U6zXmPVrPbAlihd48b7A+R/qhT8xtl2UDuf2dIBxRLQZjrnY2QcR4aPZGHsA7LGnIo1YzXYDwgKhF/xBrEgVWB8BQf17YjdMdsurlBmh6aGdVT3RSpbXNBV1q50bxuRiQa26H87V2nmYvq9nkkv31WDALzGUCjMBnX7no= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--skhawaja.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=NvZTtg34; arc=none smtp.client-ip=209.85.210.202 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--skhawaja.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="NvZTtg34" Received: by mail-pf1-f202.google.com with SMTP id d2e1a72fcca58-8375e2df478so619616b3a.1 for ; Mon, 04 May 2026 17:27:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20251104; t=1777940864; x=1778545664; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=M2hjkJ1In2ag1iLE+KuZ3epwvTGInKsCURDrkdhtZDM=; b=NvZTtg34I49l3sTT4J435tiCXcJdrCOUOA0AHOUHXi5b8UKWRGnUd1UKEcQsfIq3gR rhbXmU4zn+3XiD3/LtTdOETB9h7iXoM7L7ufhjmVFyN7SNsKXsmck2eJZu5Y6/cAN39f eZHz8cV09SB74/D9nq74up2ZFvQqbghzGuBFtpORc+fAe+qeGgUuHPpsCjva1qDtR/9K eCXNB+rXjJfeMHQ36+GLc7mGlIKCLpxngE/1790F2aoBc3kINFoyqIkHhEVX/6VqE7fN S7ZbIMKSHHTrcGgJCglwJ9F6e6664w0gTvkr1YBw7yWHoScYeJ6k7b1vTlZzvc1sLPob hKfQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1777940864; x=1778545664; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=M2hjkJ1In2ag1iLE+KuZ3epwvTGInKsCURDrkdhtZDM=; b=PSwhyelreCe8PPWPOIx/Vb2H/UGcRUDpgmnRpZnS/lkrp5AcQOMk8bkLNJ5C0qwjNQ eb3ES6wj/4GA/o1yCH8TwG1DNLo+/AbkxyhdevlAmAHQeWkaDDXl2sIastxeYM2LcZbH RJIDPjvfZzPntX4UyCvQb5oWTOBdqPG7iZtheBUiqLWeFWA7VLhG7ntr6XLNkq9ySeoz nFrh4VQPMmvkZBX8Xa+t22hFYUEHrIv5upNQ6L1/GyE3nKGSKa5XFUPExqLSFN3q9EXR vUxaqXpz88BsBg36WDVey5A05tyOP1acRQs1ZjDsswbCT9ShiQyBC9LrIGWAvZFdbk6a 2Mhw== X-Forwarded-Encrypted: i=1; AFNElJ9AgeHZZHhuXcs6Bjiy13YHSd21+hJ7JLUUjyrhSc5vF8Gchtli/Q1qtUFzm/7MFRwu6vKXfECBPZWd3cU=@vger.kernel.org X-Gm-Message-State: AOJu0YzEpHuueqVpeWh0CpPsKMJBqOlwLlrpfDAok1ouXUtQvXmUVsdX fqF9W52YffjpOYQvrpMIidV41Hpi4SAiayUaYdr2DuLbGk4UKy5DjcH3E7dJ1G3I6OzXSGKJoaA o8l9WSLj6SNQEyg== X-Received: from pfde22.prod.google.com ([2002:aa7:8c56:0:b0:82f:4abd:a354]) (user=skhawaja job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6a00:4fcd:b0:838:af72:fb35 with SMTP id d2e1a72fcca58-83921ef6ff6mr943516b3a.10.1777940863669; Mon, 04 May 2026 17:27:43 -0700 (PDT) Date: Tue, 5 May 2026 00:27:36 +0000 In-Reply-To: <20260505002737.2213734-1-skhawaja@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20260505002737.2213734-1-skhawaja@google.com> X-Mailer: git-send-email 2.54.0.545.g6539524ca2-goog Message-ID: <20260505002737.2213734-4-skhawaja@google.com> Subject: [RFC PATCH 3/4] dma-direct: Add API to preserve/restore allocations From: Samiullah Khawaja To: Marek Szyprowski , Will Deacon , Jason Gunthorpe Cc: Samiullah Khawaja , Pasha Tatashin , Mike Rapoport , Pratyush Yadav , Alexander Graf , Robin Murphy , Kevin Tian , iommu@lists.linux.dev, kexec@lists.infradead.org, linux-mm@kvack.org, linux-kernel@vger.kernel.org, David Matlack , Andrew Morton , Pranjal Shrivastava , Vipin Sharma Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add an API to preserve/restore the DMA direct allocation for liveupdate. The underlying memory is preserved/restored using KHO. During restore the memory is setup based on the device configuration, gfp flags and allocation attributes. Once restored, the driver can use the usual dma_free* API to deallocate the restored DMA allocation. This API will be used to add support in dma_alloc* APIs to preseve/restore the DMA allocations. Signed-off-by: Samiullah Khawaja --- include/linux/dma-direct.h | 29 +++++++ kernel/dma/Kconfig | 3 + kernel/dma/direct.c | 163 +++++++++++++++++++++++++++++++++++++ 3 files changed, 195 insertions(+) diff --git a/include/linux/dma-direct.h b/include/linux/dma-direct.h index c249912456f9..0efe2bc1a815 100644 --- a/include/linux/dma-direct.h +++ b/include/linux/dma-direct.h @@ -141,6 +141,35 @@ static inline bool dma_capable(struct device *dev, dma= _addr_t addr, size_t size, u64 dma_direct_get_required_mask(struct device *dev); void *dma_direct_alloc(struct device *dev, size_t size, dma_addr_t *dma_ha= ndle, gfp_t gfp, unsigned long attrs); + +#ifdef CONFIG_DMA_LIVEUPDATE +int dma_direct_preserve_allocation(struct device *dev, void *cpu_addr, + size_t size, dma_addr_t dma_handle, + unsigned long attrs, u64 *state); +void dma_direct_unpreserve_allocation(struct device *dev, u64 state); +void *dma_direct_restore_allocation(struct device *dev, size_t size, + dma_addr_t *dma_handle, gfp_t gfp, + unsigned long attrs, u64 state); +#else +static inline int dma_direct_preserve_allocation(struct device *dev, void = *cpu_addr, + size_t size, dma_addr_t dma_handle, + unsigned long attrs, u64 *state) +{ + return -EOPNOTSUPP; +} + +static inline void dma_direct_unpreserve_allocation(struct device *dev, u6= 4 state) +{ +} + +static inline void *dma_direct_restore_allocation(struct device *dev, size= _t size, + dma_addr_t *dma_handle, gfp_t gfp, + unsigned long attrs, u64 state) +{ + return NULL; +} +#endif + void dma_direct_free(struct device *dev, size_t size, void *cpu_addr, dma_addr_t dma_addr, unsigned long attrs); struct page *dma_direct_alloc_pages(struct device *dev, size_t size, diff --git a/kernel/dma/Kconfig b/kernel/dma/Kconfig index bfef21b4a9ae..d92852942c6c 100644 --- a/kernel/dma/Kconfig +++ b/kernel/dma/Kconfig @@ -265,3 +265,6 @@ config DMA_MAP_BENCHMARK performance of dma_(un)map_page. =20 See tools/testing/selftests/dma/dma_map_benchmark.c + +config DMA_LIVEUPDATE + bool "Enable preservation of DMA direct allocations" diff --git a/kernel/dma/direct.c b/kernel/dma/direct.c index ec887f443741..c2b98f91900a 100644 --- a/kernel/dma/direct.c +++ b/kernel/dma/direct.c @@ -6,6 +6,8 @@ */ #include /* for max_pfn */ #include +#include +#include #include #include #include @@ -307,6 +309,167 @@ void *dma_direct_alloc(struct device *dev, size_t siz= e, return NULL; } =20 +#ifdef CONFIG_DMA_LIVEUPDATE +int dma_direct_preserve_allocation(struct device *dev, void *cpu_addr, + size_t size, dma_addr_t dma_handle, + unsigned long attrs, u64 *state) +{ + struct dma_alloc_ser *ser; + int ret; + + if (!kho_is_enabled()) + return -EOPNOTSUPP; + + if (IS_ENABLED(CONFIG_DMA_CMA)) + return -EOPNOTSUPP; + + if ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) && + !force_dma_unencrypted(dev) && !is_swiotlb_for_alloc(dev)) + return -EOPNOTSUPP; + + if (IS_ENABLED(CONFIG_ARCH_HAS_DMA_ALLOC) && + !dev_is_dma_coherent(dev) && + !is_swiotlb_for_alloc(dev)) + return -EOPNOTSUPP; + + if (IS_ENABLED(CONFIG_DMA_GLOBAL_POOL) && + !dev_is_dma_coherent(dev)) + return -EOPNOTSUPP; + + if (IS_ENABLED(CONFIG_DMA_COHERENT_POOL) && + dma_is_from_pool(dev, cpu_addr, PAGE_ALIGN(size))) + return -EOPNOTSUPP; + + ser =3D kho_alloc_preserve(sizeof(*ser)); + if (IS_ERR(ser)) + return PTR_ERR(ser); + + ser->page_phys =3D dma_to_phys(dev, dma_handle); + ser->force_decrypted =3D force_dma_unencrypted(dev); + ser->size =3D size; + + ret =3D kho_preserve_pages(phys_to_page(ser->page_phys), + size >> PAGE_SHIFT); + if (ret) { + kho_unpreserve_free(ser); + return ret; + } + + *state =3D virt_to_phys(ser); + return 0; +} + +void dma_direct_unpreserve_allocation(struct device *dev, u64 state) +{ + struct dma_alloc_ser *ser; + + if (!kho_is_enabled()) + return; + + ser =3D phys_to_virt(state); + kho_unpreserve_pages(phys_to_page(ser->page_phys), + ser->size >> PAGE_SHIFT); + kho_unpreserve_free(ser); +} + +void *dma_direct_restore_allocation(struct device *dev, size_t size, + dma_addr_t *dma_handle, gfp_t gfp, + unsigned long attrs, u64 state) +{ + bool remap =3D false, set_uncached =3D false; + struct dma_alloc_ser *ser =3D NULL; + struct page *page; + void *cpu_addr; + + if (!kho_is_enabled()) + return NULL; + + ser =3D phys_to_virt(state); + page =3D phys_to_page(ser->page_phys); + + if ((attrs & DMA_ATTR_NO_KERNEL_MAPPING) && + !force_dma_unencrypted(dev) && !is_swiotlb_for_alloc(dev)) + return NULL; + + if (!dev_is_dma_coherent(dev)) { + if (IS_ENABLED(CONFIG_ARCH_HAS_DMA_ALLOC) && + !is_swiotlb_for_alloc(dev)) + return NULL; + + if (IS_ENABLED(CONFIG_DMA_GLOBAL_POOL)) + return NULL; + + set_uncached =3D IS_ENABLED(CONFIG_ARCH_HAS_DMA_SET_UNCACHED); + remap =3D IS_ENABLED(CONFIG_DMA_DIRECT_REMAP); + if (!set_uncached && !remap) + return NULL; + } + + if (PageHighMem(page)) { + remap =3D true; + set_uncached =3D false; + } + + /* + * Remapping will be blocking so return error. The preserved memory + * might be already decrypted in the previous kernel, but the decryption + * call is not guaranteed to be non-blocking so return error always if + * decryption is required. + */ + if ((remap || force_dma_unencrypted(dev)) && + dma_direct_use_pool(dev, gfp)) + return NULL; + + /* + * Encryption scheme changed between two kernels and this might cause + * issues if device/driver is not handling it properly. + */ + WARN_ON_ONCE(ser->force_decrypted !=3D force_dma_unencrypted(dev)); + + /* + * arch_dma_prep_coherent() should make sure that any cache lines from + * the previous kernel, if the device was coherent previously or cached + * mapping in this kernel during init are not problamatic for + * non-coherent allocations. + */ + if (remap) { + pgprot_t prot =3D dma_pgprot(dev, PAGE_KERNEL, attrs); + + if (force_dma_unencrypted(dev)) + prot =3D pgprot_decrypted(prot); + + arch_dma_prep_coherent(page, size); + + cpu_addr =3D dma_common_contiguous_remap(page, size, prot, + __builtin_return_address(0)); + if (!cpu_addr) + return NULL; + } else { + cpu_addr =3D page_address(page); + if (dma_set_decrypted(dev, cpu_addr, size)) + return NULL; + } + + if (set_uncached) { + arch_dma_prep_coherent(page, size); + cpu_addr =3D arch_dma_set_uncached(cpu_addr, size); + if (IS_ERR(cpu_addr)) + return NULL; + } + + *dma_handle =3D phys_to_dma_direct(dev, ser->page_phys); + + /* + * Cannot free the restored pages on error here as these might be in use + * by a device with direct allocation in the previous kernel. + */ + WARN_ON(!kho_restore_pages(ser->page_phys, + ser->size >> PAGE_SHIFT)); + kho_restore_free(ser); + return cpu_addr; +} +#endif + void dma_direct_free(struct device *dev, size_t size, void *cpu_addr, dma_addr_t dma_addr, unsigned long attrs) { --=20 2.54.0.545.g6539524ca2-goog From nobody Sun Jun 14 01:35:34 2026 Received: from mail-pf1-f202.google.com (mail-pf1-f202.google.com [209.85.210.202]) (using TLSv1.2 with cipher ECDHE-RSA-AES128-GCM-SHA256 (128/128 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 6ACD8283FEA for ; Tue, 5 May 2026 00:27:46 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.202 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1777940870; cv=none; b=j4yxTjH1051lwBZkcs5R+zWge/9aAyk7bCt+tZhgM1aUJLzbchdlFUK3w6OvC4ZcgX2q5P62vdqg3uAUs24GZrnWn3h9JCU6pG0MlKblQODdeP91tdTIHMFpwZhhXfUQul88y8cDvCfeU6wC6Q5FCRiKBi+IzvTWLQTe2RIJhBs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1777940870; c=relaxed/simple; bh=HageMQ77INdDXdvwF/mB+wcQSqkX+jiMsu2ThXNuUzs=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=jvnsm4NLlYYJc8kYRt8AwRxOZPc/J8FhzgB+hScGMH6iKlidarl0uN5Z+FicWWZ6cYLPBX07OZ3462wnQxyofCLoymCPTmjLQ46iY8wfL2zLSHFFAbwRcB+uus0ltUDroZgKoMCQVspl5iQjeWzys6f/QYUgnPOcjwsjIV38tlc= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--skhawaja.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=hyKNXcoM; arc=none smtp.client-ip=209.85.210.202 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=flex--skhawaja.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="hyKNXcoM" Received: by mail-pf1-f202.google.com with SMTP id d2e1a72fcca58-82d40278103so2750592b3a.2 for ; Mon, 04 May 2026 17:27:46 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20251104; t=1777940866; x=1778545666; darn=vger.kernel.org; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:from:to:cc:subject:date:message-id:reply-to; bh=zufAZqrs7wE5NdNZHdqCW4lBwECX6d0FSow8KZpRsP8=; b=hyKNXcoMGIOI/hGeNOwqnM6H1Y7NAFaL4GoSr4x3DMbT5mXrfShBG2FleT3knQ8c5h 8GNKofqwcwJMytBxRS3dXdWu9hyASMHpcfloUOiBzGcDxDmQCsgO/qJEUUCsh2sAwYvo YclEm+vLKgVVw3bM/IFR1kkl4qZ2BcGsZy6RF5L+BVtfig8dr3Sni0+PNCc4jKdFKr7o LCR306UeBW4qtctzEzVsZgtDB6fJZB/4HLDikPD5XTpGosNuvZuBR/JkLyur53Mf/sk6 +wPF/+oywpjJazeDp4dPbtsRaEfeMBAFrYt1SkWkz3wPyHK62T4BA4GxAmQ78DG3XAB6 Kzaw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1777940866; x=1778545666; h=cc:to:from:subject:message-id:references:mime-version:in-reply-to :date:x-gm-message-state:from:to:cc:subject:date:message-id:reply-to; bh=zufAZqrs7wE5NdNZHdqCW4lBwECX6d0FSow8KZpRsP8=; b=Uj8iz0ORFbaPJdpVtHfNE+AfEm/kuuniF2cMxcDBABeoapJSsyV7LWDl5ZIJH8qj3i fPVP83+Du6Be7gL8P/56nH2iEHNA4/sOKBrCU60SwW9ETK1ng3EPtKW7ioteCVSh2+BQ DVmGj14w16tR0+U78Ckgri5SIl6cROdmdoMYKx26Cabt3Cmkfk63Hcmo/8pCFDr+cvYA TD8zxwjHysSuCLfagZlan327VMbacFnw1+qU5EgV91raJon6N5TLaviSz0AHK2rX+RXV osiSu6jg/KegQkTK0lgYXlHBOEFyn/MahEtq+Fw1RhjONPuPnU2mxeQDwdooDX0+hcQT NXBA== X-Forwarded-Encrypted: i=1; AFNElJ8T1oo0Z3Jql4C/cSuib0gAP48W3WJkfnp/pohQWsiZSpIx5FPcZRGMJ3T3MzDzcz4wWgfRiuWu5sLB5jE=@vger.kernel.org X-Gm-Message-State: AOJu0YzFFxKleQ+8qVkoipMXlGDKfC+P3a5r7/TSqAqs1qK6XCd7LsEy Iig3WMh8yqpLMm6KqZgxeZHXDCv3wadOVFZBk9gzBStFxsIrPimnIiT1RTYRUXbnhLP7qaH84UI Lc74ewsGFaUuu8w== X-Received: from pfbmb14.prod.google.com ([2002:a05:6a00:760e:b0:838:5125:b5e4]) (user=skhawaja job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6a00:3003:b0:835:42cf:1f7a with SMTP id d2e1a72fcca58-83921ef6cf1mr905533b3a.6.1777940865363; Mon, 04 May 2026 17:27:45 -0700 (PDT) Date: Tue, 5 May 2026 00:27:37 +0000 In-Reply-To: <20260505002737.2213734-1-skhawaja@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20260505002737.2213734-1-skhawaja@google.com> X-Mailer: git-send-email 2.54.0.545.g6539524ca2-goog Message-ID: <20260505002737.2213734-5-skhawaja@google.com> Subject: [RFC PATCH 4/4] dma-mapping: Add API to preserve/restore DMA allocation From: Samiullah Khawaja To: Marek Szyprowski , Will Deacon , Jason Gunthorpe Cc: Samiullah Khawaja , Pasha Tatashin , Mike Rapoport , Pratyush Yadav , Alexander Graf , Robin Murphy , Kevin Tian , iommu@lists.linux.dev, kexec@lists.infradead.org, linux-mm@kvack.org, linux-kernel@vger.kernel.org, David Matlack , Andrew Morton , Pranjal Shrivastava , Vipin Sharma Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add new DMA APIs that allow preserving/restoring DMA allocations across live update. Signed-off-by: Samiullah Khawaja --- include/linux/dma-mapping.h | 50 +++++++++++++++++++++++++++++++++++ kernel/dma/mapping.c | 52 +++++++++++++++++++++++++++++++++++++ 2 files changed, 102 insertions(+) diff --git a/include/linux/dma-mapping.h b/include/linux/dma-mapping.h index db8ab24a54f4..3756fc15467b 100644 --- a/include/linux/dma-mapping.h +++ b/include/linux/dma-mapping.h @@ -210,6 +210,15 @@ void *dma_vmap_noncontiguous(struct device *dev, size_= t size, void dma_vunmap_noncontiguous(struct device *dev, void *vaddr); int dma_mmap_noncontiguous(struct device *dev, struct vm_area_struct *vma, size_t size, struct sg_table *sgt); +#ifdef CONFIG_DMA_LIVEUPDATE +int dma_preserve_allocation_attrs(struct device *dev, void *cpu_addr, + size_t size, dma_addr_t dma_handle, + unsigned long attrs, u64 *state); +void dma_unpreserve_allocation(struct device *dev, u64 state); +void *dma_restore_allocation_attrs(struct device *dev, size_t size, + dma_addr_t *dma_handle, gfp_t gfp, + unsigned long attrs, u64 state); +#endif #else /* CONFIG_HAS_DMA */ static inline dma_addr_t dma_map_page_attrs(struct device *dev, struct page *page, size_t offset, size_t size, @@ -496,6 +505,26 @@ static inline bool dma_need_unmap(struct device *dev) } #endif /* !CONFIG_HAS_DMA || !CONFIG_DMA_NEED_SYNC */ =20 +#if !defined(CONFIG_DMA_LIVEUPDATE) || !defined(CONFIG_HAS_DMA) +static inline int dma_preserve_allocation_attrs(struct device *dev, void *= cpu_addr, + size_t size, dma_addr_t dma_handle, + unsigned long attrs, u64 *state) +{ + return -EOPNOTSUPP; +} + +static inline void dma_unpreserve_allocation(struct device *dev, u64 state) +{ +} + +static inline void *dma_restore_allocation_attrs(struct device *dev, size_= t size, + dma_addr_t *dma_handle, gfp_t gfp, + unsigned long attrs, u64 state) +{ + return NULL; +} +#endif + struct page *dma_alloc_pages(struct device *dev, size_t size, dma_addr_t *dma_handle, enum dma_data_direction dir, gfp_t gfp); void dma_free_pages(struct device *dev, size_t size, struct page *page, @@ -618,6 +647,27 @@ static inline void *dma_alloc_coherent(struct device *= dev, size_t size, (gfp & __GFP_NOWARN) ? DMA_ATTR_NO_WARN : 0); } =20 +static inline int dma_preserve_coherent_allocation(struct device *dev, voi= d *cpu_addr, + size_t size, dma_addr_t dma_handle, u64 *state) +{ + return dma_preserve_allocation_attrs(dev, cpu_addr, size, + dma_handle, 0, state); +} + +static inline void dma_unpreserve_coherent_allocation(struct device *dev, = u64 state) +{ + dma_unpreserve_allocation(dev, state); +} + +static inline void *dma_restore_coherent_allocation(struct device *dev, si= ze_t size, + dma_addr_t *dma_handle, + gfp_t gfp, u64 state) +{ + return dma_restore_allocation_attrs(dev, size, dma_handle, gfp, + (gfp & __GFP_NOWARN) ? DMA_ATTR_NO_WARN : 0, + state); +} + static inline void dma_free_coherent(struct device *dev, size_t size, void *cpu_addr, dma_addr_t dma_handle) { diff --git a/kernel/dma/mapping.c b/kernel/dma/mapping.c index 23ed8eb9233e..c315b74a0884 100644 --- a/kernel/dma/mapping.c +++ b/kernel/dma/mapping.c @@ -12,6 +12,8 @@ #include #include #include +#include +#include #include #include #include @@ -628,6 +630,56 @@ u64 dma_get_required_mask(struct device *dev) } EXPORT_SYMBOL_GPL(dma_get_required_mask); =20 +#ifdef CONFIG_DMA_LIVEUPDATE +int dma_preserve_allocation_attrs(struct device *dev, void *cpu_addr, + size_t size, dma_addr_t dma_handle, + unsigned long attrs, u64 *state) +{ + const struct dma_map_ops *ops =3D get_dma_ops(dev); + +#ifdef CONFIG_DMA_DECLARE_COHERENT + return -EOPNOTSUPP; +#endif + + if (dma_alloc_direct(dev, ops)) + return dma_direct_preserve_allocation(dev, cpu_addr, size, + dma_handle, attrs, + state); + + return -EOPNOTSUPP; +} +EXPORT_SYMBOL(dma_preserve_allocation_attrs); + +void dma_unpreserve_allocation(struct device *dev, u64 state) +{ + const struct dma_map_ops *ops =3D get_dma_ops(dev); + + if (dma_alloc_direct(dev, ops)) + dma_direct_unpreserve_allocation(dev, state); +} +EXPORT_SYMBOL(dma_unpreserve_allocation); + +void *dma_restore_allocation_attrs(struct device *dev, size_t size, + dma_addr_t *dma_handle, gfp_t gfp, + unsigned long attrs, u64 state) +{ + const struct dma_map_ops *ops =3D get_dma_ops(dev); + + WARN_ON_ONCE(!dev->coherent_dma_mask); + +#ifdef CONFIG_DMA_DECLARE_COHERENT + return NULL; +#endif + + if (dma_alloc_direct(dev, ops)) + return dma_direct_restore_allocation(dev, size, dma_handle, + gfp, attrs, state); + + return NULL; +} +EXPORT_SYMBOL(dma_restore_allocation_attrs); +#endif + void *dma_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_han= dle, gfp_t flag, unsigned long attrs) { --=20 2.54.0.545.g6539524ca2-goog