From nobody Sat Jul 25 19:26:33 2026 Received: from mail-pj1-f52.google.com (mail-pj1-f52.google.com [209.85.216.52]) (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 8C6813AD529 for ; Tue, 14 Jul 2026 11:47:16 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.52 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784029638; cv=none; b=HVg9ZAEl7Ept6F+lhqVS/rU6XU6zGCWq5tOC5TH/43y2njLWoFb3FVHgCns0b5DAKI1F1TTqoUyXnbkDC/P8silTO2vPiEdyMLEAodUiY4K+w1E3hkTJ99Jb6Kk6Q4aY6pEvB7m1VdXGZjBHi1fV3n9OoBFIxcDwp3rAXVxfbvQ= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784029638; c=relaxed/simple; bh=DF0tuHwjjdOjosgy0BJiTXrXk5A2su/avHcXKW7FWl0=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version:Content-Type; b=FEb1aIUL14D1RRLSMETwxa5ZKWtp0Ga7rJRUbvHdLqJ4ad/R+37sPqXsyVUHwdhH/2QuGBs028fTEpU7Ri1BUYDoAi2AzS7gKaxtwJPd4sdg5dQnkckoM1LLTtAaycTGWpi6VZG1TKxJ2QpgenbmnJYZTpWIH9HAexW57ZfV39w= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=GFq4DFrF; arc=none smtp.client-ip=209.85.216.52 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="GFq4DFrF" Received: by mail-pj1-f52.google.com with SMTP id 98e67ed59e1d1-381b831d535so989043a91.0 for ; Tue, 14 Jul 2026 04:47:16 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1784029636; x=1784634436; darn=vger.kernel.org; h=content-transfer-encoding:content-type:mime-version:references :in-reply-to:message-id:date:subject:cc:to:from:from:to:cc:subject :date:message-id:reply-to:content-type; bh=D6JbozRMrTeKv2vOMW74ecX1vJXvga7e7fLYQK001e4=; b=GFq4DFrFmpYwjm3grvLJ6RM4sI+U8iqrxdXa+KfICuy19dfkjN3O8V10Lyb/XALo5R bDKWJHBgw/dwdhZNCfR/DE6uCBjLLQXaNmDvzwPRrYTsF09+U7Nu7iy1VGqVm4B/g+Q6 ko0mv7DchbnlJakfD8WCbGu9yExTNaEngq6lQPKlx50rgGCjOCgO6ASnRJmeqzrShsd8 0NFl9x7Xl3Fe/rV17HNnIBFfd/CBNj46co4eg+xdH4mBoIht272tWHt93NxlJPvK0TWf qtZN0Hr5q2Ki+JNAKxn6YPGxpnmtGcWsXapMad7Xu5NJcZJHSzCZHhMQTU0aKuZS+rOg 46Fw== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1784029636; x=1784634436; h=content-transfer-encoding:content-type:mime-version:references :in-reply-to:message-id:date:subject:cc:to:from:x-gm-gg :x-gm-message-state:from:to:cc:subject:date:message-id:reply-to :content-type; bh=D6JbozRMrTeKv2vOMW74ecX1vJXvga7e7fLYQK001e4=; b=POlDZ+kzh2+uwUpX6/wUTSo464bLbQQFXnig2gt238+snLKuEVoTri3d4BD3+sbXZ7 7qHKQt6r4VGfgkNKaLumUZWU+AOnAVwGucYeFM7TnQSIM3YJStzkek8ILbXTLQv+Fyl4 IwvNkS+U3HGk5gE2CbkDqEl+eiAk72yhg654r4r4+MFGtGpsd+ppTpq3QyWiKifH5bM+ 3uU4HyhrVmoXSXFfbtzJeeiYDj0WQNTEiFuiFJyYE6CRPO0c9WJ8GjUoLP1zG3GUud/8 P+lj25tN5HfeZLTqM9q26Rbn6jk1p/wA6n8i/NmUHV1cuIO/MdhOV43MGXgPGfyiJxMY b26g== X-Forwarded-Encrypted: i=1; AHgh+RpB653JMlwnFYARxmcFrCfoW/WDfxXqbEKFz7zRZl8MPnjY1bLpAIlk2QLX+rS2o3fIEsE6zFhuSPKxB7w=@vger.kernel.org X-Gm-Message-State: AOJu0YyPMkBoMZZoppfP3DxCAhqc9tLDdELiOPqM7yV+dZsalDiyXZ+C EgiQCE60QEc2StnzCYQjsik4vCobzQa0JGSD+VhcOAu5OF3pCrO92qV/ X-Gm-Gg: AfdE7ckpHHdryzGBvBxVAxgCAYAJHEFJvgP83v+CuMJ9rQPngYxxsunmhecyU77u5L3 R4xRmfDDEogKDXZPQOnFLlfAEhn0yfoR9Ekt9JVvG/UNWWJodFNZuRkcmJLHXl3s+LhUTlkJzCb vc0aSt/8YT/4ZYO7i5phKRjfgt4SyH9l4Q5/WSSLsMrBTCj7dx0xi4pAh/yrKEuGgOAiZAk0loc cdAqOS0Lp1eJm1m4nHd/HVgLmkbTGjKt9a+H5yALJ+rVrpw9X6WKctjmOeiDl2njoR510XVcpGl yg3V5BTj+7yXKm4H3EmTKoiz2haYSmXkvfCu7j0DYG5ni0Q0ymQRbF3xgf6Obg/E6kBVO1+27Xs agi8omRTVzOZL8ztTzzgnlfzjlkx5Z7EBpb+xg3HkkyIMDVyG0zYr4Xysq92ZlcK8i69GST2R9h Cf/8PT4yrT35/6OSM9 X-Received: by 2002:a17:90b:3ccc:b0:37f:c2a8:ce45 with SMTP id 98e67ed59e1d1-38dc73b936emr12193575a91.4.1784029635683; Tue, 14 Jul 2026 04:47:15 -0700 (PDT) Received: from baineng-pc.. ([117.133.183.252]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-38e17470008sm1356162a91.17.2026.07.14.04.47.10 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 14 Jul 2026 04:47:15 -0700 (PDT) From: Baineng Shou To: Sumit Semwal , =?UTF-8?q?Christian=20K=C3=B6nig?= , "T . J . Mercier" , Benjamin Gaignard , Brian Starkey , John Stultz , Sandeep Patil , "Andrew F . Davis" , Srinivas Kandagatla Cc: stable@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org, linux-arm-msm@vger.kernel.org, Baineng Shou Subject: [PATCH v3 1/2] dma-buf: dma-heap: don't publish fd before copy_to_user() succeeds Date: Tue, 14 Jul 2026 19:46:53 +0800 Message-Id: <20260714114654.3885457-2-shoubaineng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260714114654.3885457-1-shoubaineng@gmail.com> References: <20260714114654.3885457-1-shoubaineng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable DMA_HEAP_IOCTL_ALLOC allocates a dma-buf and installs an fd into the caller's fd table via dma_buf_fd() -> fd_install() before dma_heap_ioctl() copies the result back to userspace. If the trailing copy_to_user() fails, userspace never learns the fd number, but the fd (and the underlying dma-buf reference) are already visible to other threads in the same process and are leaked for the lifetime of the process. The obvious "close it on the failure path" fix is unsafe: once fd_install() has run, another thread can already dup() the fd, send it via SCM_RIGHTS, or close() it and let its number be reused, so a subsequent close_fd() from the ioctl path can operate on an unrelated file. This was pointed out by Christian K=C3=B6nig on v1 [1]. Restructure the allocation path so that fd_install() is the last, unfailable step of a successful ioctl: 1. heap->ops->allocate() creates the dma_buf. 2. get_unused_fd_flags() reserves an fd number in the caller's fd table without publishing it, so no other thread can observe it. 3. copy_to_user() delivers the fd number to userspace; on failure the fd is returned with put_unused_fd() and the dma_buf reference is dropped with dma_buf_put(), leaving no user- visible state behind. 4. dma_buf_fd_install() publishes the fd and emits the trace_dma_buf_fd tracepoint -- from here on the ioctl cannot fail. A new dma_buf_fd_install() helper is introduced in dma-buf.c to wrap fd_install() together with the DMA_BUF_TRACE() call, preserving the export tracing that dma_buf_fd() provides. dma_heap_ioctl_allocate() is refactored to return the struct dma_buf * directly (returning ERR_PTR on failure) so the caller holds the dmabuf reference across steps 3 and 4. The failure at step 3 is easily reachable from userspace: pass a struct dma_heap_allocation_data that lives in a page whose protection is flipped to PROT_READ between copy_from_user() and copy_to_user() (e.g. via mprotect()). Before this change each such ioctl leaks one dmabuf fd; after it, the fd table is unchanged on failure and only /dev/dma_heap/ remains open. No UAPI or heap-driver interface change. [1] https://lore.kernel.org/dri-devel/175e98de-f414-47d7-81c1-c0fe0a8f7f62@= amd.com/ Fixes: c02a81fba74f ("dma-buf: Add dma-buf heaps framework") Cc: stable@vger.kernel.org Reviewed-by: T.J. Mercier Signed-off-by: Baineng Shou --- drivers/dma-buf/dma-buf.c | 20 ++++++++++ drivers/dma-buf/dma-heap.c | 80 +++++++++++++++++++------------------- include/linux/dma-buf.h | 1 + 3 files changed, 61 insertions(+), 40 deletions(-) diff --git a/drivers/dma-buf/dma-buf.c b/drivers/dma-buf/dma-buf.c index d504c636dc29..4c9add51f9ef 100644 --- a/drivers/dma-buf/dma-buf.c +++ b/drivers/dma-buf/dma-buf.c @@ -803,6 +803,26 @@ int dma_buf_fd(struct dma_buf *dmabuf, int flags) } EXPORT_SYMBOL_NS_GPL(dma_buf_fd, "DMA_BUF"); =20 +/** + * dma_buf_fd_install - install a reserved fd for a dma-buf + * @dmabuf: [in] pointer to dma_buf + * @fd: [in] fd reserved with get_unused_fd_flags() + * + * Publishes a previously reserved fd into the caller's fd table. + * Must only be called after all fallible work (e.g. copy_to_user) + * has succeeded, as it cannot be undone safely once called. + * + * The caller is responsible for having emitted the trace event + * (via dma_buf_fd() or get_unused_fd_flags() + this function) + * before calling this. + */ +void dma_buf_fd_install(struct dma_buf *dmabuf, int fd) +{ + DMA_BUF_TRACE(trace_dma_buf_fd, dmabuf, fd); + fd_install(fd, dmabuf->file); +} +EXPORT_SYMBOL_NS_GPL(dma_buf_fd_install, "DMA_BUF"); + /** * dma_buf_get - returns the struct dma_buf related to an fd * @fd: [in] fd associated with the struct dma_buf to be returned diff --git a/drivers/dma-buf/dma-heap.c b/drivers/dma-buf/dma-heap.c index a76bf3f8b071..43c32fb28313 100644 --- a/drivers/dma-buf/dma-heap.c +++ b/drivers/dma-buf/dma-heap.c @@ -55,33 +55,6 @@ MODULE_PARM_DESC(mem_accounting, "Enable cgroup-based memory accounting for dma-buf heap allocations (de= fault=3Dfalse)."); EXPORT_SYMBOL_NS_GPL(mem_accounting, "DMA_BUF_HEAP"); =20 -static int dma_heap_buffer_alloc(struct dma_heap *heap, size_t len, - u32 fd_flags, - u64 heap_flags) -{ - struct dma_buf *dmabuf; - int fd; - - /* - * Allocations from all heaps have to begin - * and end on page boundaries. - */ - len =3D PAGE_ALIGN(len); - if (!len) - return -EINVAL; - - dmabuf =3D heap->ops->allocate(heap, len, fd_flags, heap_flags); - if (IS_ERR(dmabuf)) - return PTR_ERR(dmabuf); - - fd =3D dma_buf_fd(dmabuf, fd_flags); - if (fd < 0) { - dma_buf_put(dmabuf); - /* just return, as put will call release and that will free */ - } - return fd; -} - static int dma_heap_open(struct inode *inode, struct file *file) { struct dma_heap *heap; @@ -99,30 +72,42 @@ static int dma_heap_open(struct inode *inode, struct fi= le *file) return 0; } =20 -static long dma_heap_ioctl_allocate(struct file *file, void *data) +static struct dma_buf *dma_heap_ioctl_allocate(struct file *file, void *da= ta) { struct dma_heap_allocation_data *heap_allocation =3D data; struct dma_heap *heap =3D file->private_data; + struct dma_buf *dmabuf; int fd; + size_t len; =20 if (heap_allocation->fd) - return -EINVAL; + return ERR_PTR(-EINVAL); =20 if (heap_allocation->fd_flags & ~DMA_HEAP_VALID_FD_FLAGS) - return -EINVAL; + return ERR_PTR(-EINVAL); =20 if (heap_allocation->heap_flags & ~DMA_HEAP_VALID_HEAP_FLAGS) - return -EINVAL; + return ERR_PTR(-EINVAL); + + len =3D PAGE_ALIGN(heap_allocation->len); + if (!len) + return ERR_PTR(-EINVAL); + + dmabuf =3D heap->ops->allocate(heap, len, heap_allocation->fd_flags, + heap_allocation->heap_flags); =20 - fd =3D dma_heap_buffer_alloc(heap, heap_allocation->len, - heap_allocation->fd_flags, - heap_allocation->heap_flags); - if (fd < 0) - return fd; + if (IS_ERR(dmabuf)) + return dmabuf; + + fd =3D get_unused_fd_flags(heap_allocation->fd_flags); + if (fd < 0) { + dma_buf_put(dmabuf); + return ERR_PTR(fd); + } =20 heap_allocation->fd =3D fd; =20 - return 0; + return dmabuf; } =20 static unsigned int dma_heap_ioctl_cmds[] =3D { @@ -138,6 +123,8 @@ static long dma_heap_ioctl(struct file *file, unsigned = int ucmd, unsigned int in_size, out_size, drv_size, ksize; int nr =3D _IOC_NR(ucmd); int ret =3D 0; + int fd; + struct dma_buf *dmabuf; =20 if (nr >=3D ARRAY_SIZE(dma_heap_ioctl_cmds)) return -EINVAL; @@ -174,15 +161,28 @@ static long dma_heap_ioctl(struct file *file, unsigne= d int ucmd, =20 switch (kcmd) { case DMA_HEAP_IOCTL_ALLOC: - ret =3D dma_heap_ioctl_allocate(file, kdata); + dmabuf =3D dma_heap_ioctl_allocate(file, kdata); + + if (IS_ERR(dmabuf)) { + ret =3D PTR_ERR(dmabuf); + break; + } + + fd =3D ((struct dma_heap_allocation_data *)kdata)->fd; + if (copy_to_user((void __user *)arg, kdata, out_size) !=3D 0) { + put_unused_fd(fd); + dma_buf_put(dmabuf); + ret =3D -EFAULT; + } else { + dma_buf_fd_install(dmabuf, fd); + } + break; default: ret =3D -ENOTTY; goto err; } =20 - if (copy_to_user((void __user *)arg, kdata, out_size) !=3D 0) - ret =3D -EFAULT; err: if (kdata !=3D stack_kdata) kfree(kdata); diff --git a/include/linux/dma-buf.h b/include/linux/dma-buf.h index d1203da56fc5..d15b2b31d3c9 100644 --- a/include/linux/dma-buf.h +++ b/include/linux/dma-buf.h @@ -567,6 +567,7 @@ void dma_buf_unpin(struct dma_buf_attachment *attach); struct dma_buf *dma_buf_export(const struct dma_buf_export_info *exp_info); =20 int dma_buf_fd(struct dma_buf *dmabuf, int flags); +void dma_buf_fd_install(struct dma_buf *dmabuf, int fd); struct dma_buf *dma_buf_get(int fd); void dma_buf_put(struct dma_buf *dmabuf); =20 --=20 2.34.1 From nobody Sat Jul 25 19:26:34 2026 Received: from mail-pj1-f42.google.com (mail-pj1-f42.google.com [209.85.216.42]) (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 AA5DC3ACEF6 for ; Tue, 14 Jul 2026 11:47:25 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.216.42 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784029647; cv=none; b=Df5e5zgZjwl1lMsMW4EBPQU3+4+mx0k6vJC5BbPVzkM0Fmhi4QnMBvia+Gg/87pNUG5+siIQkGYvKwGGgcLZVrtzicyNYZwN6ddl43c6rFYYXLKNNQBAdCuTTKLwWsPPITEJl9QExYOUgCNcp9JXip2n26g45qMFHP5A72vHPeU= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1784029647; c=relaxed/simple; bh=Uy7FphsDH/6m7cGZVypayztHXs5inLwbY1LCe/lb3fU=; h=From:To:Cc:Subject:Date:Message-Id:In-Reply-To:References: MIME-Version; b=GmraLU3R9ZdLmolPbjhI/44e8bVCuXJzOlZaiTInF0/d9hN1e7C89PanO5brnuVtynKUUYYtOBApfT93+fAvOyPSfStbT5CHZISDLECF67AOwub2LHWiWfwdKOusHHHDKmVbnj0iraddE9bqOsnnze2GVAgKH8k2iNA83/UBZ0A= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com; spf=pass smtp.mailfrom=gmail.com; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b=bZpA9tl5; arc=none smtp.client-ip=209.85.216.42 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=gmail.com Authentication-Results: smtp.subspace.kernel.org; spf=pass smtp.mailfrom=gmail.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=gmail.com header.i=@gmail.com header.b="bZpA9tl5" Received: by mail-pj1-f42.google.com with SMTP id 98e67ed59e1d1-38dc69c74b8so2529957a91.0 for ; Tue, 14 Jul 2026 04:47:25 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20251104; t=1784029645; x=1784634445; darn=vger.kernel.org; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:from:to:cc:subject:date :message-id:reply-to:content-type; bh=9XJ+pkLF/zrrWNVQ3+TJme7MRR7lpIC8LYwT0f9F3iM=; b=bZpA9tl51WlU+QiBJo8jM1Z6kfYLdOPx2EyT+1a8r3OVqbH93QegbWnDa/UGcM9bY3 +ry9inNECLk6OdJlJEstk4vJA6MXI7Jd9ZINBJTkLpSp5gO6VzvS3LvVzlkztPeItCAs WG2urDN7YBP3O+O9+0p7gKTTBdaMtl2LT2+eFlIbh/oCIIZ3BIpZGLmO42E0xV7UY/gg J5iU6zUpyfZFUleDZp5kSFv5sgrBv3hYWdb9a337HwzyjUbBCkpDHdG4Zzl/dB7yTPs6 LczNcdEfMHygENFbb8nBwtQnRlh1ZO18wFyixHoduDuGUPh7w86NSfOPov6qVFroFXJJ pdTA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20251104; t=1784029645; x=1784634445; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-gg:x-gm-message-state:from :to:cc:subject:date:message-id:reply-to:content-type; bh=9XJ+pkLF/zrrWNVQ3+TJme7MRR7lpIC8LYwT0f9F3iM=; b=ZTFcuWc4u3UuNwOudaQzjl83EtNRg+9JwoRIkmLKQQKS0OS65eusAznNJKemFPNDgr A0Xvkvj6t9otfy8KPRTDCjoNeJkQxpjqBU+L+VpgD370Uc2nsBw+EGq5l3RbX4yfr8PL wItVs4L1XTHOAFUa+GIANpBQXfGgOl+CgjafFZU++W9WWMHPAZT8b/5xawT87FpPSD1I JIUUE5hr9o8u2FKUDyBLNlnxBhqJk9Mrl/eDlqsFPfrjxQrT932Gh7RQNV4Dr0kp3y3p dW5uq8ewRYaiRXzvlfFMtEthJCbT3gYiQs4PSvqhWFONOyzCFVRe4PG1y5sID3ijjBtv 7MpQ== X-Forwarded-Encrypted: i=1; AHgh+RrEgFbpThEQaJMGMfBVt1aQVEAYmj0qYuxvfb4cnKpcGDojnhg9a7gF0TTJHr1cTBj4WB4fsxT+qRJvloY=@vger.kernel.org X-Gm-Message-State: AOJu0YxngT/q5i2Gq5vmcPhNmzLuFKgUw2F2EYbNX9/WRDHG5l3iWxYY foBeVT02tvgAMqqSZSpJOTI3cevmymE91o7bBytkzzf+ypnnU8huLahK X-Gm-Gg: AfdE7clm+wTBGC4vl1RMx7o1yp1Vdf5TlaC2Wt6shG6CAyhvwwlpJR291mo46C+C4aU 1eAl9/5ueC89l1ExIQT+YR+o5z9h2syMZ/D9oZqEZPSfVRSF5QaCtXKS2cxm7asmEq9ZoPhJ0KF xK0nVKno+ERSpSl22Ziu4yxpIwLgGBRKpzKrr5Y/Z8+sA3gevxPqgaRH+Ed1DrGCfGsR3X18E+a gdXERAnSuFvlZwv0WWh6CV5Us9xZNd3aqA3yc71cVjf86AU7Z9nmtTZeiZft2qH8u16utv+Wg7P eIosvNTPwdGWFYybc/SleU9GWeBJ4lv9MaoM34cdTHdPxwN5Fu2W72+OvAfTc82rBDeWi40Yu/N UjF1Zb4wXiYnBCIDdEvBKuQwoxrIBawEiM7c7/58c19biSUyBcpv/LRlFxB7FC0fBdDI2jp4Mdv +/uhM1tTgB0N4YoMuf X-Received: by 2002:a17:90b:3dcb:b0:387:e0bb:5804 with SMTP id 98e67ed59e1d1-38dc7bc50femr12271219a91.43.1784029644922; Tue, 14 Jul 2026 04:47:24 -0700 (PDT) Received: from baineng-pc.. ([117.133.183.252]) by smtp.gmail.com with ESMTPSA id 98e67ed59e1d1-38e17470008sm1356162a91.17.2026.07.14.04.47.19 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Tue, 14 Jul 2026 04:47:24 -0700 (PDT) From: Baineng Shou To: Sumit Semwal , =?UTF-8?q?Christian=20K=C3=B6nig?= , "T . J . Mercier" , Benjamin Gaignard , Brian Starkey , John Stultz , Sandeep Patil , "Andrew F . Davis" , Srinivas Kandagatla Cc: stable@vger.kernel.org, dri-devel@lists.freedesktop.org, linux-media@vger.kernel.org, linaro-mm-sig@lists.linaro.org, linux-kernel@vger.kernel.org, linux-arm-msm@vger.kernel.org, Baineng Shou Subject: [PATCH v3 2/2] misc: fastrpc: don't publish fd before copy_to_user() succeeds Date: Tue, 14 Jul 2026 19:46:54 +0800 Message-Id: <20260714114654.3885457-3-shoubaineng@gmail.com> X-Mailer: git-send-email 2.34.1 In-Reply-To: <20260714114654.3885457-1-shoubaineng@gmail.com> References: <20260714114654.3885457-1-shoubaineng@gmail.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" fastrpc_ioctl_alloc_dmabuf() calls dma_buf_fd() which installs the fd into the caller's fd table before copy_to_user() copies the fd number back to userspace. If copy_to_user() fails, the fd is already visible to other threads in the same process but the ioctl returns -EFAULT. The existing comment in the code even acknowledges the problem: "The usercopy failed, but we can't do much about it, as dma_buf_fd() already called fd_install()..." Now that dma_buf_fd_install() is available (introduced to fix the same issue in dma-heap), apply the same pattern here: reserve the fd with get_unused_fd_flags(), attempt copy_to_user(), and only on success call dma_buf_fd_install() to publish it atomically with the tracepoint. On copy_to_user() failure, put_unused_fd() and dma_buf_put() cleanly unwind without any user-visible side effects. Fixes: 6cffd79504ce ("misc: fastrpc: Add support for dmabuf exporter") Cc: stable@vger.kernel.org Signed-off-by: Baineng Shou Reviewed-by: T.J. Mercier --- drivers/misc/fastrpc.c | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) diff --git a/drivers/misc/fastrpc.c b/drivers/misc/fastrpc.c index f3a49384586d..c5143cd25767 100644 --- a/drivers/misc/fastrpc.c +++ b/drivers/misc/fastrpc.c @@ -1709,24 +1709,20 @@ static int fastrpc_dmabuf_alloc(struct fastrpc_user= *fl, char __user *argp) return err; } =20 - bp.fd =3D dma_buf_fd(buf->dmabuf, O_ACCMODE); + bp.fd =3D get_unused_fd_flags(O_ACCMODE); if (bp.fd < 0) { dma_buf_put(buf->dmabuf); - return -EINVAL; + return bp.fd; } =20 if (copy_to_user(argp, &bp, sizeof(bp))) { - /* - * The usercopy failed, but we can't do much about it, as - * dma_buf_fd() already called fd_install() and made the - * file descriptor accessible for the current process. It - * might already be closed and dmabuf no longer valid when - * we reach this point. Therefore "leak" the fd and rely on - * the process exit path to do any required cleanup. - */ + put_unused_fd(bp.fd); + dma_buf_put(buf->dmabuf); return -EFAULT; } =20 + dma_buf_fd_install(buf->dmabuf, bp.fd); + return 0; } =20 --=20 2.34.1