From nobody Fri Oct 3 23:02:06 2025 Received: from mail-pf1-f176.google.com (mail-pf1-f176.google.com [209.85.210.176]) (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 7D83030149D for ; Fri, 22 Aug 2025 12:56:38 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.176 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755867399; cv=none; b=FwS9/7Cb8hqzHKT30XljgODunrCJK2b4VI52JypUiEVH6iJWxo8tqLBugyvrvuV5RPDR+cFt/I6Tiy7QpNkfp6+ZxS3YAqZMs6eOmSfDswj+gLS/lmn9kuzAXolks4IE2HMk1KR84abCbQbO3niumBUkwEqo1ivvdP8Lk5IWZIE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755867399; c=relaxed/simple; bh=2p8LG69KmCVA8ZLTUV6rgT5Wy5/pv1AhMG9wpLxMJIE=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=paMuQboToiCTehdtkx32ow8/5QVjPQys91X4pMyY88ZkjNNKC0jD14oqckT+B8cg23aOUlV/CXfczQn62NmRkBO30flhFfKI+/eQkb8whLp+UhGHpRou0owZhl0rNjpefHLkD9wXs1XTQ8e5gbXezYEwPNV48QRz0Stx6X8q7Ng= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=furiosa.ai; spf=none smtp.mailfrom=furiosa.ai; dkim=pass (1024-bit key) header.d=furiosa.ai header.i=@furiosa.ai header.b=QAuNGGSP; arc=none smtp.client-ip=209.85.210.176 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=furiosa.ai Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=furiosa.ai Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=furiosa.ai header.i=@furiosa.ai header.b="QAuNGGSP" Received: by mail-pf1-f176.google.com with SMTP id d2e1a72fcca58-76e6cbb9956so1672269b3a.0 for ; Fri, 22 Aug 2025 05:56:38 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=furiosa.ai; s=google; t=1755867398; x=1756472198; 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; bh=p8fwNJeHNHWIWunBevE6xxfqz+V4AStymQDWUp+Nzso=; b=QAuNGGSP0ojjaY4qas+ib2P3xKaP0KlZxo0Mkc7/aOaHvUbtVAKBQTEKEYP6WUZf2U 5zE61e8nwoVb6zR9o2wvyoaWdvf0vnzk6Wl+EXSsbV7+y207FcKbqAXhMcx2jXURHEMy 3dDiFoAFGabwz9w8srf+x7zObFXNYgcQwfIWk= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1755867398; x=1756472198; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=p8fwNJeHNHWIWunBevE6xxfqz+V4AStymQDWUp+Nzso=; b=b/rl06RiXna8vJpkCaMB1DEyYmhBQ1FjNzXzECb9ixmTKZeSr2e1ubxgAO7SqGUqxP TCUSfS/XpgiEEtXB0KlTVtjZyWGtHjG1aVpuWqy9Xk0ohiCDTabry6tHHwVoNrx7SKbO 9fJj/0ueQuGvZ1E3e3J3hB3AhG3RnqdwYj4R86XRbiRVQ+8AUfbI2ltY0QVLJSx1Wnuh YZY5YOvmyaWx1L9jc+e7sgrhYQ6m69iRXV4RJ5Vk89A41KT7BDraC4ZsfPOm5CmpcaG2 f2/03eh4BUF/qUFgbtlABB49KyetS9bOC2eXGlCzfqW4St6TL6ee2OdeYC0tzhQxr/cA sIdg== X-Forwarded-Encrypted: i=1; AJvYcCWKrcnfES1IVrOyCveYIcygqh4EDARN/YcNKetckhmW/dY7Nrd2Gg8MsEAvzEJd+pbByIP8eNOJYE0gFuU=@vger.kernel.org X-Gm-Message-State: AOJu0Ywa5lb/twqNcsI+OIlDYJdgJ7goxwD622cVjKwRNlQDyyc5Q6M4 I0Ih5EunLibPy+79fAKR/I5OOwQotDrgr0W69ya3qI7YBGMmTCrlfp89FpzYrU6SilA= X-Gm-Gg: ASbGncsLKW/CkRjXuvbJRpolkoJJA2gY3JPQ+SWF6sgGuO8ITR+2GSaKKKVap20ARdA dbMLcE930A0IGYN8Vsrgv7SzYfVf12twzOdD16UWQyhbl0LRHQ8n+vxNu3Qd2hgalcfUzeNwA2+ 24cwwonUQOyKSdysXbUCPICp790JkX489YEFCVzpOOEUdD6c3yuFf39egDnUIGeFarGSkkMkMLJ aFn3X3Dzy1UyK7tj6W1ViqolY53+yfyP0iy47Jkj4H3DKuoA2CkZJ7L2oWYh/We5E80arAP34DV zw1GoTtgCwS0YZJuoVeJjbB8v2bLDJzmMP+qIuQsxHJl3E8ca1I5ebEOTCHmCumGI6Y7l8xXHx7 tELx9YIvP9+WjzjIXH+KW30KVE7A8659wb64K5dwh2S6x/sVVaUxJ7YOiqxKEhNDCs/N967FU X-Google-Smtp-Source: AGHT+IHDhJuu9+cO4uxsw6AoUa51QjPpNUdCs5GI2HWZsOmJ82BW0DSG2NIaLQoRPu3I8EhQjTg/gQ== X-Received: by 2002:a05:6a20:430d:b0:23d:9cca:e710 with SMTP id adf61e73a8af0-24340de334bmr4095404637.44.1755867397819; Fri, 22 Aug 2025 05:56:37 -0700 (PDT) Received: from sidong.sidong.yang.office.furiosa.vpn ([175.195.128.78]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b4764003537sm7194544a12.25.2025.08.22.05.56.34 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 22 Aug 2025 05:56:37 -0700 (PDT) From: Sidong Yang To: Jens Axboe , Daniel Almeida , Caleb Sander Mateos , Benno Lossin Cc: Miguel Ojeda , Arnd Bergmann , Greg Kroah-Hartman , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, io-uring@vger.kernel.org, Sidong Yang Subject: [RFC PATCH v3 1/5] rust: bindings: add io_uring headers in bindings_helper.h Date: Fri, 22 Aug 2025 12:55:51 +0000 Message-ID: <20250822125555.8620-2-sidong.yang@furiosa.ai> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250822125555.8620-1-sidong.yang@furiosa.ai> References: <20250822125555.8620-1-sidong.yang@furiosa.ai> 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" This patch adds two headers io_uring.h io_uring/cmd.h in bindings_helper for implementing rust io_uring abstraction. Signed-off-by: Sidong Yang --- rust/bindings/bindings_helper.h | 2 ++ 1 file changed, 2 insertions(+) diff --git a/rust/bindings/bindings_helper.h b/rust/bindings/bindings_helpe= r.h index 84d60635e8a9..96beaea73755 100644 --- a/rust/bindings/bindings_helper.h +++ b/rust/bindings/bindings_helper.h @@ -75,6 +75,8 @@ #include #include #include +#include +#include #include =20 #if defined(CONFIG_DRM_PANIC_SCREEN_QR_CODE) --=20 2.43.0 From nobody Fri Oct 3 23:02:06 2025 Received: from mail-pf1-f176.google.com (mail-pf1-f176.google.com [209.85.210.176]) (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 3150C302CD1 for ; Fri, 22 Aug 2025 12:56:42 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.176 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755867403; cv=none; b=Qf6MPnfTdIBloJspbZk3A4EMaJjAn2TUyzl1AMM3rB8x0H4pcL0DbKjP9Sedm+gIxUaonkRPkhk4SdsO7W70Es0YlmSejJZGnijrVD7YCKsV5FHoKyRC9zpQRf9hrqpTXWLNrQn9TJYEkR5npCI8j8c+2RWag4CccFSS6Fmd/sc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755867403; c=relaxed/simple; bh=QcgTbWambBF60BQIQEKWl9c7KUFGhDsO+zeYwk/r4Kk=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=gxkPzrQnYZlnzrYte3qXl2nmQDFv7Ow35vV3bjXtkF4MzvNQlWwHKJfVeLkH3pJIQjleBK95uTvP5Dh5xCSDYMKYKgo5/iV1U/XzvlsOv5HYQ+pcgCld+8+bjKAjIt+CPc6ETHqMiRDEW4aLW1ZtiKcVN63WHikURyhp71jRceY= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=furiosa.ai; spf=none smtp.mailfrom=furiosa.ai; dkim=pass (1024-bit key) header.d=furiosa.ai header.i=@furiosa.ai header.b=DcKgRGWQ; arc=none smtp.client-ip=209.85.210.176 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=furiosa.ai Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=furiosa.ai Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=furiosa.ai header.i=@furiosa.ai header.b="DcKgRGWQ" Received: by mail-pf1-f176.google.com with SMTP id d2e1a72fcca58-76e2ea79219so2527796b3a.2 for ; Fri, 22 Aug 2025 05:56:42 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=furiosa.ai; s=google; t=1755867401; x=1756472201; 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; bh=ln9ocDQtv3JdgjgPJ2w8JqxkmO9wxFyJcAceGQE4xpc=; b=DcKgRGWQiqYEfSnw88Li/LRJS3kk/UzNzxPRjWTaWt18wLJKrdC83vkrxyKaizMQRa FW/3RJ2nh0Pmc8yljhdt9oDR+uBBDoziB8Ni+IL/O/dlDJPqCbzn4Buo8C2B8EFFF5W0 dmSkcQRH2a2ENAJaIKYD+mdfGG5e3dDZAuQgo= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1755867401; x=1756472201; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=ln9ocDQtv3JdgjgPJ2w8JqxkmO9wxFyJcAceGQE4xpc=; b=X/t6tO7/L6kQo16M6DtfjfEV02chaNgzquAbhOGFfdMap+XicrrX2WY8PfckeYjOW9 h6rzOX7fpdlkuwkRiqAtBWlLw1WkyHAjXfk9Qh4kOiAYhbl3+qujwrqtLKNz2m2l8QhO sYgBDCvE8PWfsaQl9TWprwDz4/46pNIZESalX25/o0utx+YtMbCqRRcifM4oLiVC1UkT Xk0pVm8hs0PlqiMpu1XwQ13VOw4BiP85LH4u9NmeMe89tNkAKteba+B0hd0RnvpALuqg ngy9VS5BtRQ+Btfe9QfAEhT4h2JNkG6nJE1XDOKQk+LQS3hShklpALk9JWCD3rltrYDK v69A== X-Forwarded-Encrypted: i=1; AJvYcCWYs97uPVSRHpNJgGOWXHNWW5e3tkg4751S97/ctZO3KE57tAGwS0mGzPv2hrtVqAxk9xMviG0xTUBtQ3U=@vger.kernel.org X-Gm-Message-State: AOJu0Yzq1uVCigYSeX0uYNvulHptF7PG1uoHsivqbOVKTVb1/38hyV/o ekVD1F3Yvmk6/I17xn3P4oo3jey99JbkJXynRk2D/aihMfovHRLbJkogtj37FGB2zvw= X-Gm-Gg: ASbGnctpNeqxbLw8jve6OQ+5cHdLn9EeM/RiBh6tfhI1LOkY2m/ErcYfLiRN0YILkKB eijVJ4txqX9PrJ4D0eTZFxsjfGZ0qwFN4Uk5JzTWg9sbX3m7P9iP/U7IiXzgVXxL0+hXCV68MbO V7Y3UvNoI+04Hz9EkL/pX8RmhLuxye5yjedW10t+QzdXU38JtpH7EO+kKl5l/U3HI7cfI5oeCro e2PjKlKtUTS8fmBALytGb37KXc2K8L7I+F9IC381hCC1jtImdJEGdUd/OtJE4ru96pNJw0MC2l5 SxA4yjhPdycpR6kCPdMRxW2C6qdbKhtES3JPKbG09u43o3UUUN/ylt08v8eVMXwR3du5fxNnEIS EA4cLb2KP3jNKLNc0b29iPtCMVEvG7N2dHzT/UYj7NMU9kJne8AYI7+c+9p3Kxg== X-Google-Smtp-Source: AGHT+IH1S3ZNnZrawdMbvtvsQWSSBWdj/g2T1gkOTrmr98XOtngGqtBjqHpAKjepX0TGtaqYnPrHTA== X-Received: by 2002:a05:6a20:1585:b0:220:94b1:f1b8 with SMTP id adf61e73a8af0-2434092dc84mr4314487637.0.1755867401476; Fri, 22 Aug 2025 05:56:41 -0700 (PDT) Received: from sidong.sidong.yang.office.furiosa.vpn ([175.195.128.78]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b4764003537sm7194544a12.25.2025.08.22.05.56.38 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 22 Aug 2025 05:56:41 -0700 (PDT) From: Sidong Yang To: Jens Axboe , Daniel Almeida , Caleb Sander Mateos , Benno Lossin Cc: Miguel Ojeda , Arnd Bergmann , Greg Kroah-Hartman , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, io-uring@vger.kernel.org, Sidong Yang Subject: [RFC PATCH v3 2/5] io_uring/cmd: zero-init pdu in io_uring_cmd_prep() to avoid UB Date: Fri, 22 Aug 2025 12:55:52 +0000 Message-ID: <20250822125555.8620-3-sidong.yang@furiosa.ai> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250822125555.8620-1-sidong.yang@furiosa.ai> References: <20250822125555.8620-1-sidong.yang@furiosa.ai> 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" The pdu field in io_uring_cmd may contain stale data when a request object is recycled from the slab cache. Accessing uninitialized or garbage memory can lead to undefined behavior in users of the pdu. Ensure the pdu buffer is cleared during io_uring_cmd_prep() so that each command starts from a well-defined state. This avoids exposing uninitialized memory and prevents potential misinterpretation of data from previous requests. No functional change is intended other than guaranteeing that pdu is always zero-initialized before use. Signed-off-by: Sidong Yang --- io_uring/uring_cmd.c | 1 + 1 file changed, 1 insertion(+) diff --git a/io_uring/uring_cmd.c b/io_uring/uring_cmd.c index 053bac89b6c0..2492525d4e43 100644 --- a/io_uring/uring_cmd.c +++ b/io_uring/uring_cmd.c @@ -203,6 +203,7 @@ int io_uring_cmd_prep(struct io_kiocb *req, const struc= t io_uring_sqe *sqe) if (!ac) return -ENOMEM; ioucmd->sqe =3D sqe; + memset(&ioucmd->pdu, 0, sizeof(ioucmd->pdu)); return 0; } =20 --=20 2.43.0 From nobody Fri Oct 3 23:02:06 2025 Received: from mail-pg1-f169.google.com (mail-pg1-f169.google.com [209.85.215.169]) (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 15F402FD7BC for ; Fri, 22 Aug 2025 12:56:45 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.215.169 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755867408; cv=none; b=sCsIHYNOt0y0uV49H4n6mhhCfajvN79ynTq7JbnuCN+zMWbl1nwkto4IjkVaD2JV9KRuseGt95MrenuFq21LIYvRy3Szk0A36JIeJReWGGFfu4qQufGOl3y1dlklPc1oxaYC8jamnyaJEHY6Ps8a6RTI7k2w7GHV1TtI52EE5lc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755867408; c=relaxed/simple; bh=NV6+rJDxkCRhM79mHIfKFRRwVUmLGb/zYkCLHClc0as=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=nOktr7am6t4+DK4/QVCpnC8fMEok/1WTLx5fTPIOkUT5l2j9l0yXYMhM1uQywH8x6qx6yQkeMi81wv+dWFV5S2cc5uXD7S7aTGVJ7IOvkpxAOoLl33rbZgulKGuJQ34vnruVU8wfT3zJuQDD8ddtsYjV97f1aQtTP5dYkpPP0ys= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=furiosa.ai; spf=none smtp.mailfrom=furiosa.ai; dkim=pass (1024-bit key) header.d=furiosa.ai header.i=@furiosa.ai header.b=M72lKuoK; arc=none smtp.client-ip=209.85.215.169 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=furiosa.ai Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=furiosa.ai Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=furiosa.ai header.i=@furiosa.ai header.b="M72lKuoK" Received: by mail-pg1-f169.google.com with SMTP id 41be03b00d2f7-b474e8d6d04so1812673a12.0 for ; Fri, 22 Aug 2025 05:56:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=furiosa.ai; s=google; t=1755867405; x=1756472205; 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; bh=PvQIwb1NNcq0g0gNIsMaMiMcUpYuzVOnVto3+pLplyI=; b=M72lKuoKsB4FnfcvL5JS+VjNYxyT4xryr5Qj1GIy9mlx22AgT3ePm+vFxl8NPQ9Ghe OtWkgMeUHDL4yyzAFPqg7Ky6tNKJcnJBvigOt1SnsWz5e4Cjvt+IDy00EwblH2m1ps8K sQwJEtw0FpTbTg7lUwz76jTCaOjEsO/vaGkp4= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1755867405; x=1756472205; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=PvQIwb1NNcq0g0gNIsMaMiMcUpYuzVOnVto3+pLplyI=; b=OVkrktUh/xpIveLPO3ok2YZViO9bbyg5YALE5NqdXHN+CV7ljxdZOaimMHzv9CAz0C O+hg+CQ13YbqBORKBIikwOTAxWAy/nv92HaGSwAb2LhPLjbLk0ZVGYogbDCkxgm0nolO o/KLb217djAyZITDjtPLRZxPbVwvzHzeFovYyoo+fJIxVfZsjE3T6zgjTSmG7ql23OwD w1U04Y9TOIgqmX+dok5hxjoyYYhqu+N3LYQwQd00AuDOr6FwP+2dqjW8KLO3VNpPQHAH XQqM/dkPW4IdG3yMek78cK75ZH/EwhoNr2EGjR/Snfa4hmzx2qqSmC5ztVcsM6aEOEfv rcQA== X-Forwarded-Encrypted: i=1; AJvYcCXWx7wR8qDodYX2Zu1/9Ed1HlnU/SmsKWW2Jkrtc0/+vJk9gb+FmT91DWShOjMroar8n2+2FzeZhIwMTjU=@vger.kernel.org X-Gm-Message-State: AOJu0Yw6bGb2fsmwUiIrYXJXduSnZwBzKq41N34t9qvHpMyrJArA1epZ HLcdEbl7OVq3rK/C2220mPd64opiyn2XqX3hxPZpp/Uww3o5gNtc8UV8hMVuR8jfIrTwfmhfVMz e3y6N X-Gm-Gg: ASbGncuEzlJElSPIl7zZZan0BMbxhVsS+5ciQ+Tjk+lEcU2xZYLHyUn6ALYZeS5r5Lm O5hePdJfCs92BfFsyo3CzJJsrPbRBpykJA6l7dXAf8dspJbU4JObxTSw6YifzI/6cs0rtg+1itY Qkh2mZiHxxrMiyNOhz4YR9q9Id5aHIeCZVA/qSzRFxZDk0H982bvWLGIcwB26N1RG9vLMMz/LJu Zz2PjShd6tEdBSyY1PGF3R3eLxMzbDXCC2ceAxujN5CFFfuKcvyWYXXCrcG9ke25u3zLYoqCiD6 UtYS+i9OUVWtijBEJg8EEiUU8e5y0bC1VzfVn6YrprId/Tm7qk7LY/fcB/DF8wJDTX2DksYNxT7 xYO/+eJDoxQZoA1jOcMkNqrox6HGU8fgIPer0FkVfXy0ptZiM8fWtRSK7D8UspWepSwtoB6ub1A NM6sqPMFQ= X-Google-Smtp-Source: AGHT+IFUsehCGOfZistHEaN6+J+4p2f5uUzKwncvYpuYdsFqJWvzkLLRlUScB/Cvtgvlof1Oz+7Xvg== X-Received: by 2002:a17:903:320d:b0:245:f53f:f7bc with SMTP id d9443c01a7336-2462edee95bmr32712685ad.9.1755867405306; Fri, 22 Aug 2025 05:56:45 -0700 (PDT) Received: from sidong.sidong.yang.office.furiosa.vpn ([175.195.128.78]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b4764003537sm7194544a12.25.2025.08.22.05.56.41 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 22 Aug 2025 05:56:44 -0700 (PDT) From: Sidong Yang To: Jens Axboe , Daniel Almeida , Caleb Sander Mateos , Benno Lossin Cc: Miguel Ojeda , Arnd Bergmann , Greg Kroah-Hartman , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, io-uring@vger.kernel.org, Sidong Yang Subject: [RFC PATCH v3 3/5] rust: io_uring: introduce rust abstraction for io-uring cmd Date: Fri, 22 Aug 2025 12:55:53 +0000 Message-ID: <20250822125555.8620-4-sidong.yang@furiosa.ai> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250822125555.8620-1-sidong.yang@furiosa.ai> References: <20250822125555.8620-1-sidong.yang@furiosa.ai> 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" Implment the io-uring abstractions needed for miscdevicecs and other char devices that have io-uring command interface. * `io_uring::IoUringCmd` : Rust abstraction for `io_uring_cmd` which will be used as arg for `MiscDevice::uring_cmd()`. And driver can get `cmd_op` sent from userspace. Also it has `flags` which includes option that is reissued. * `io_uring::IoUringSqe` : Rust abstraction for `io_uring_sqe` which could be get from `IoUringCmd::sqe()` and driver could get `cmd_data` from userspace. Also `IoUringSqe` has more data like opcode could be used= in driver. Signed-off-by: Sidong Yang --- rust/kernel/io_uring.rs | 306 ++++++++++++++++++++++++++++++++++++++++ rust/kernel/lib.rs | 1 + 2 files changed, 307 insertions(+) create mode 100644 rust/kernel/io_uring.rs diff --git a/rust/kernel/io_uring.rs b/rust/kernel/io_uring.rs new file mode 100644 index 000000000000..61e88bdf4e42 --- /dev/null +++ b/rust/kernel/io_uring.rs @@ -0,0 +1,306 @@ +// SPDX-License-Identifier: GPL-2.0 +// SPDX-FileCopyrightText: (C) 2025 Furiosa AI + +//! Abstractions for io-uring. +//! +//! This module provides types for implements io-uring interface for char = device. +//! +//! +//! C headers: [`include/linux/io_uring/cmd.h`](srctree/include/linux/io_u= ring/cmd.h) and +//! [`include/linux/io_uring/io_uring.h`](srctree/include/linux/io_uring/i= o_uring.h) + +use core::{mem::MaybeUninit, pin::Pin}; + +use crate::error::from_result; +use crate::transmute::{AsBytes, FromBytes}; +use crate::{fs::File, types::Opaque}; + +use crate::prelude::*; + +/// io-uring opcode +pub mod opcode { + /// opcode for uring cmd + pub const URING_CMD: u32 =3D bindings::io_uring_op_IORING_OP_URING_CMD; +} + +/// A Rust abstraction for the Linux kernel's `io_uring_cmd` structure. +/// +/// This structure is a safe, opaque wrapper around the raw C `io_uring_cm= d` +/// binding from the Linux kernel. It represents a command structure used +/// in io_uring operations within the kernel. +/// This type is used internally by the io_uring subsystem to manage +/// asynchronous I/O commands. +/// +/// This type should not be constructed or manipulated directly by +/// kernel module developers. +/// +/// # INVARIANT +/// - `self.inner` always points to a valid, live `bindings::io_uring_cmd`. +#[repr(transparent)] +pub struct IoUringCmd { + /// An opaque wrapper containing the actual `io_uring_cmd` data. + inner: Opaque, +} + +impl IoUringCmd { + /// Returns the cmd_op with associated with the `io_uring_cmd`. + #[inline] + pub fn cmd_op(&self) -> u32 { + // SAFETY: `self.inner` is guaranteed by the type invariant to poi= nt + // to a live `io_uring_cmd`, so dereferencing is safe. + unsafe { (*self.inner.get()).cmd_op } + } + + /// Returns the flags with associated with the `io_uring_cmd`. + #[inline] + pub fn flags(&self) -> u32 { + // SAFETY: `self.inner` is guaranteed by the type invariant to poi= nt + // to a live `io_uring_cmd`, so dereferencing is safe. + unsafe { (*self.inner.get()).flags } + } + + /// Reads protocol data unit as `T` that impl `FromBytes` from uring c= md + /// + /// Fails with [`EFAULT`] if size of `T` is bigger than pdu size. + #[inline] + pub fn read_pdu(&self) -> Result { + // SAFETY: `self.inner` is guaranteed by the type invariant to poi= nt + // to a live `io_uring_cmd`, so dereferencing is safe. + let inner =3D unsafe { &mut *self.inner.get() }; + + let len =3D size_of::(); + if len > inner.pdu.len() { + return Err(EFAULT); + } + + let mut out: MaybeUninit =3D MaybeUninit::uninit(); + let ptr =3D &raw mut inner.pdu as *const c_void; + + // SAFETY: + // * The `ptr` is valid pointer from `self.inner` that is guarante= ed by type invariant. + // * The `out` is valid pointer that points `T` which impls `FromB= ytes` and checked + // size of `T` is smaller than pdu size. + unsafe { + core::ptr::copy_nonoverlapping(ptr, out.as_mut_ptr().cast::(), len); + } + + // SAFETY: The read above has initialized all bytes in `out`, and = since `T` implements + // `FromBytes`, any bit-pattern is a valid value for this type. + Ok(unsafe { out.assume_init() }) + } + + /// Writes the provided `value` to `pdu` in uring_cmd `self` + /// + /// Fails with [`EFAULT`] if size of `T` is bigger than pdu size. + #[inline] + pub fn write_pdu(&mut self, value: &T) -> Result<()> { + // SAFETY: `self.inner` is guaranteed by the type invariant to poi= nt + // to a live `io_uring_cmd`, so dereferencing is safe. + let inner =3D unsafe { &mut *self.inner.get() }; + + let len =3D size_of::(); + if len > inner.pdu.len() { + return Err(EFAULT); + } + + let src =3D (value as *const T).cast::(); + let dst =3D &raw mut inner.pdu as *mut c_void; + + // SAFETY: + // * The `src` is points valid memory that is guaranteed by `T` im= pls `AsBytes` + // * The `dst` is valid. It's from `self.inner` that is guaranteed= by type invariant. + // * It's safe to copy because size of `T` is no more than len of = pdu. + unsafe { + core::ptr::copy_nonoverlapping(src, dst, len); + } + + Ok(()) + } + + /// Constructs a new [`IoUringCmd`] from a raw `io_uring_cmd` + /// + /// # Safety + /// + /// The caller must guarantee that: + /// - `ptr` is non-null, properly aligned, and points to a valid + /// `bindings::io_uring_cmd`. + /// - The pointed-to memory remains initialized and valid for the enti= re + /// lifetime `'a` of the returned reference. + /// - While the returned `Pin<&'a mut IoUringCmd>` is alive, the under= lying + /// object is **not moved** (pinning requirement). + /// - **Aliasing rules:** the returned `&mut` has **exclusive** access= to the same + /// object for its entire lifetime: + /// - No other `&mut` **or** `&` references to the same `io_uring_cm= d` may be + /// alive at the same time. + /// - There must be no concurrent reads/writes through raw pointers,= FFI, or + /// other kernel paths to the same object during this lifetime. + /// - If the object can be touched from other contexts (e.g. IRQ/ano= ther CPU), + /// the caller must provide synchronization to uphold this exclusi= vity. + /// - This function relies on `IoUringCmd` being `repr(transparent)` o= ver + /// `bindings::io_uring_cmd` so the cast preserves layout. + #[inline] + pub unsafe fn from_raw<'a>(ptr: *mut bindings::io_uring_cmd) -> Pin<&'= a mut IoUringCmd> { + // SAFETY: + // * The caller guarantees that the pointer is not dangling and st= ays + // valid for the duration of 'a. + // * The cast is okay because `IoUringCmd` is `repr(transparent)` = and + // has the same memory layout as `bindings::io_uring_cmd`. + // * The returned `Pin` ensures that the object cannot be moved, w= hich + // is required because the kernel may hold pointers to this memo= ry + // location and moving it would invalidate those pointers. + unsafe { Pin::new_unchecked(&mut *ptr.cast()) } + } + + /// Returns the file that referenced by uring cmd self. + #[inline] + pub fn file(&self) -> &File { + // SAFETY: `self.inner` is guaranteed by the type invariant to poi= nt + // to a live `io_uring_cmd`, so dereferencing is safe. + let file =3D unsafe { (*self.inner.get()).file }; + + // SAFETY: + // * The `file` points valid file. + // * refcount is positive after submission queue entry issued. + // * There is no active fdget_pos region on the file on this threa= d. + unsafe { File::from_raw_file(file) } + } + + /// Returns an reference to the [`IoUringSqe`] associated with this co= mmand. + #[inline] + pub fn sqe(&self) -> &IoUringSqe { + // SAFETY: `self.inner` is guaranteed by the type invariant to poi= nt + // to a live `io_uring_cmd`, so dereferencing is safe. + let sqe =3D unsafe { (*self.inner.get()).sqe }; + // SAFETY: The call guarantees that the `sqe` points valid io_urin= g_sqe. + unsafe { IoUringSqe::from_raw(sqe) } + } + + /// Completes an this [`IoUringCmd`] request that was previously queue= d. + /// + /// # Safety + /// + /// - This function must be called **only** for a command whose `uring= _cmd` + /// handler previously returned **`-EIOCBQUEUED`** to io_uring. + /// + /// # Parameters + /// + /// - `ret`: Result to return to userspace. + /// - `res2`: Extra for big completion queue entry `IORING_SETUP_CQE32= `. + /// - `issue_flags`: Flags associated with this request, typically the= same + /// as those passed to the `uring_cmd` handler. + #[inline] + pub fn done(self: Pin<&mut IoUringCmd>, ret: Result, res2: u64, i= ssue_flags: u32) { + let ret =3D from_result(|| ret) as isize; + // SAFETY: The call guarantees that `self.inner` is not dangling a= nd stays valid + unsafe { + bindings::io_uring_cmd_done(self.inner.get(), ret, res2, issue= _flags); + } + } +} + +/// A Rust abstraction for the Linux kernel's `io_uring_sqe` structure. +/// +/// This structure is a safe, opaque wrapper around the raw C [`io_uring_s= qe`](srctree/include/uapi/linux/io_uring.h) +/// binding from the Linux kernel. It represents a Submission Queue Entry +/// used in io_uring operations within the kernel. +/// +/// # Type Safety +/// +/// The `#[repr(transparent)]` attribute ensures that this wrapper has +/// the same memory layout as the underlying `io_uring_sqe` structure, +/// allowing it to be safely transmuted between the two representations. +/// +/// # Fields +/// +/// * `inner` - An opaque wrapper containing the actual `io_uring_sqe` dat= a. +/// The `Opaque` type prevents direct access to the internal +/// structure fields, ensuring memory safety and encapsulation. +/// +/// # Usage +/// +/// This type represents a submission queue entry that describes an I/O +/// operation to be executed by the io_uring subsystem. It contains +/// information such as the operation type, file descriptor, buffer +/// pointers, and other operation-specific data. +/// +/// Users can obtain this type from [`IoUringCmd::sqe()`] method, which +/// extracts the submission queue entry associated with a command. +/// +/// This type should not be constructed or manipulated directly by +/// kernel module developers. +/// +/// # INVARIANT +/// - `self.inner` always points to a valid, live `bindings::io_uring_sqe`. +#[repr(transparent)] +pub struct IoUringSqe { + inner: Opaque, +} + +impl IoUringSqe { + /// Reads and interprets the `cmd` field of an `bindings::io_uring_sqe= ` as a value of type `T`. + /// + /// # Safety & Invariants + /// - Construction of `T` is delegated to `FromBytes`, which guarantee= s that `T` has no + /// invalid bit patterns and can be safely reconstructed from raw by= tes. + /// - **Limitation:** This implementation does not support `IORING_SET= UP_SQE128` (larger SQE entries). + /// Only the standard `io_uring_sqe` layout is handled here. + /// + /// # Errors + /// * Returns `EINVAL` if the `self` does not hold a `opcode::URING_CM= D`. + /// * Returns `EFAULT` if the command buffer is smaller than the reque= sted type `T`. + /// + /// # Returns + /// * On success, returns a `T` deserialized from the `cmd`. + /// * On failure, returns an appropriate error as described above. + pub fn cmd_data(&self) -> Result { + // SAFETY: `self.inner` guaranteed by the type invariant to point + // to a live `io_uring_sqe`, so dereferencing is safe. + let sqe =3D unsafe { &*self.inner.get() }; + + if u32::from(sqe.opcode) !=3D opcode::URING_CMD { + return Err(EINVAL); + } + + // SAFETY: Accessing the `sqe.cmd` union field is safe because we'= ve + // verified that `sqe.opcode =3D=3D IORING_OP_URING_CMD`, which gu= arantees + // that this union variant is initialized and valid. + let cmd =3D unsafe { sqe.__bindgen_anon_6.cmd.as_ref() }; + let cmd_len =3D size_of_val(&sqe.__bindgen_anon_6.bindgen_union_fi= eld); + + if cmd_len < size_of::() { + return Err(EFAULT); + } + + let cmd_ptr =3D cmd.as_ptr() as *mut T; + + // SAFETY: `cmd_ptr` is valid from `self.inner` which is guarantee= d by + // type variant. And also it points to initialized `T` from usersp= ace. + let ret =3D unsafe { core::ptr::read_unaligned(cmd_ptr) }; + + Ok(ret) + } + + /// Constructs a new `IoUringSqe` from a raw `io_uring_sqe`. + /// + /// # Safety + /// + /// The caller must guarantee that: + /// - `ptr` is non-null, properly aligned, and points to a valid initi= alized + /// `bindings::io_uring_sqe`. + /// - The pointed-to memory remains valid (not freed or repurposed) fo= r the + /// entire lifetime `'a` of the returned reference. + /// - **Aliasing rules (for `&T`):** while the returned `&'a IoUringSq= e` is + /// alive, there must be **no mutable access** to the same object th= rough any + /// path (no `&mut`, no raw-pointer writes, no FFI/IRQ/other-CPU wri= ters). + /// Multiple `&` is fine **only if all of them are read-only** for t= he entire + /// overlapping lifetime. + /// - This relies on `IoUringSqe` being `repr(transparent)` over + /// `bindings::io_uring_sqe`, so the cast preserves layout. + #[inline] + pub unsafe fn from_raw<'a>(ptr: *const bindings::io_uring_sqe) -> &'a = IoUringSqe { + // SAFETY: The caller guarantees that the pointer is not dangling = and stays valid for the + // duration of 'a. The cast is okay because `IoUringSqe` is `repr(= transparent)` and has the + // same memory layout as `bindings::io_uring_sqe`. + unsafe { &*ptr.cast() } + } +} diff --git a/rust/kernel/lib.rs b/rust/kernel/lib.rs index ed53169e795c..d38cf7137401 100644 --- a/rust/kernel/lib.rs +++ b/rust/kernel/lib.rs @@ -91,6 +91,7 @@ pub mod fs; pub mod init; pub mod io; +pub mod io_uring; pub mod ioctl; pub mod jump_label; #[cfg(CONFIG_KUNIT)] --=20 2.43.0 From nobody Fri Oct 3 23:02:06 2025 Received: from mail-pf1-f180.google.com (mail-pf1-f180.google.com [209.85.210.180]) (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 C83A4307490 for ; Fri, 22 Aug 2025 12:56:49 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.180 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755867411; cv=none; b=QEVtuNx1nA1itEjgaTZ6/vGM7dTBjqrPS8qM0UtdAZs6O75zq1WRK0RtE/B9eqFblIz4zANo+ShOyO9LdN3kjwlqsw8mQLhUugwTf6Q9jUrwtohsMmKXOjd0qYExKgUCNKZbfFQkafZBK+ydzWng0hp7hpT+mG+RWlDki7YYR90= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755867411; c=relaxed/simple; bh=Kgha9M2aktOgnDSytFmmY+NS6OnOUezCcL8YMo7VSnY=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=Dr2aYsWyajWRrEMAODQXP5xFNdjUYH4EVMuMdOFt0PwDwUkwkbDJb6EXxp5jRa9D1FBUU65UIurYUMisDRtoO2itLdL74iWTSXqtvbhRLNyE4FblhLDJ2F6y+E0OcoCTpkILYKM3qNMC1zEUdeYIlkxhlyYk/AgqcMt6iMVkq3M= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=furiosa.ai; spf=none smtp.mailfrom=furiosa.ai; dkim=pass (1024-bit key) header.d=furiosa.ai header.i=@furiosa.ai header.b=gAJKGmdK; arc=none smtp.client-ip=209.85.210.180 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=furiosa.ai Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=furiosa.ai Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=furiosa.ai header.i=@furiosa.ai header.b="gAJKGmdK" Received: by mail-pf1-f180.google.com with SMTP id d2e1a72fcca58-76e34c4ce54so1907890b3a.0 for ; Fri, 22 Aug 2025 05:56:49 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=furiosa.ai; s=google; t=1755867409; x=1756472209; 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; bh=Fpc3G4jkNpPP+8gbkzeuRuDbKnBFZfB7UrIuz+P/mto=; b=gAJKGmdKnDBU/z1X6hNTP4jUPFXoiSJCsx2GxsWmYl3fDO0WYvP2uJj2j8I32acloV cygrRrktHOCubpd+blNL1p9nUdDdrOnS8Kx4LwyUTgRhUPh+2E7/NViaIJF7K7MCEJ9p wRfEqjNXCGKn+C9n1uozPKVRCBjR9OgS0//VU= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1755867409; x=1756472209; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=Fpc3G4jkNpPP+8gbkzeuRuDbKnBFZfB7UrIuz+P/mto=; b=Dh/L6JPKy/uQuIQ1FfkzWX1iVqkcMqy6CkmPSWb1Pd8sNBUSsSXmSsD+HLanutfX1y Z28nUhIMXRs8dbSuwTL3L6by6cBCDLjz9SUhXpItE1DNjbw0N137JyttomWU/pkU7/W9 4iV847dKdK6g8mCW2NcfHgC/3fzxu4KBLUpvpmiI0gU/KWMduVbNgeC91WPxbcCOevwE 3y8z/m3lwnWcgG0NRr4C/yIpUBOoluqu3mORBWxzPjuHlUbCt2aDM6zUuASLRjVQWbMw L97dbJRytGu3s7qGQZAYPVsyS17DkQ96XGNjfvMqShahdiv3zlG9Ynvauk3MNDk4Nq/s ZjjQ== X-Forwarded-Encrypted: i=1; AJvYcCUpdbN/tnkvWJmepa+CbLINSKOovdWweVrQ7jxzSKQ5CxWliP9wlwpTmFb8+qJ9fvYhTZ35ANxbkn34Ng0=@vger.kernel.org X-Gm-Message-State: AOJu0YzLGrRbrHyGUN368+tJ2apekZHz7kzrbwmLsOtWR2KWwqYNBdYu kRLMbWizMIgrPlyuMfijkhYd/GHJ2gOlFNJkWWh+kHxeJf6QaaJ8WPWNfdXfc/Pk+ADy1kePdtF nAzLL X-Gm-Gg: ASbGncsu85z0DProCPG6MdLX4s29L6I0KQUkgRdwsoJ+bNJp4V4QlTTYY0Vj6nAwB+r QFTTrjbMjAcS5Mfh7T5AKpd3rnLLvZfIGve2sZPEu3DaiGSAHzccoKh0Yug19LdhAyeLuUz0f4M okcxaTXyXz/VRrKhQTH2JLI8uzypfUFrLR7logYfibOMfnDk44wr1ThlhFM7jip/Y3P8PbZkuvY FAtgE0svedKZxNbbWofhefooqWZdX9gxMPYumCWCWVR0WNUCUXfWk5ubJEWDZw1COOzkJM9fQl2 Uo92i7HGBMb6eYkrOSo6Wbig8AZdWvjnH6mgZXd1S6+mRfF8mncTOeRj5hQtzlUNAiEFTopy13F zKGkDkYy0TWGHEhmOuVPUIg6qbBvNHMJeNlTzCc+6loFnyDW7xQC9wmRc5/RZx6pD9sL4QtO1 X-Google-Smtp-Source: AGHT+IEKR0Ev77BkY8PeWKbKpMu9lsAQ4CC61YA/ParYg5pJ6IvbBCFoZtzUSMCIDkhNoiLwiTh+1g== X-Received: by 2002:a05:6a21:3297:b0:243:78a:82c5 with SMTP id adf61e73a8af0-243302e2cfcmr8212059637.26.1755867408937; Fri, 22 Aug 2025 05:56:48 -0700 (PDT) Received: from sidong.sidong.yang.office.furiosa.vpn ([175.195.128.78]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b4764003537sm7194544a12.25.2025.08.22.05.56.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 22 Aug 2025 05:56:48 -0700 (PDT) From: Sidong Yang To: Jens Axboe , Daniel Almeida , Caleb Sander Mateos , Benno Lossin Cc: Miguel Ojeda , Arnd Bergmann , Greg Kroah-Hartman , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, io-uring@vger.kernel.org, Sidong Yang Subject: [RFC PATCH v3 4/5] rust: miscdevice: Add `uring_cmd` support Date: Fri, 22 Aug 2025 12:55:54 +0000 Message-ID: <20250822125555.8620-5-sidong.yang@furiosa.ai> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250822125555.8620-1-sidong.yang@furiosa.ai> References: <20250822125555.8620-1-sidong.yang@furiosa.ai> 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" This patch introduces support for `uring_cmd` to the `miscdevice` framework. This is achieved by adding a new `uring_cmd` method to the `MiscDevice` trait and wiring it up to the corresponding `file_operations` entry. The `uring_cmd` function provides a mechanism for `io_uring` to issue commands to a device driver. The new `uring_cmd` method takes the device, an `IoUringCmd` object, and issue flags as arguments. The `IoUringCmd` object is a safe Rust abstraction around the raw `io_uring_cmd` struct. To enable `uring_cmd` for a specific misc device, the `HAS_URING_CMD` constant must be set to `true` in the `MiscDevice` implementation. Signed-off-by: Sidong Yang --- rust/kernel/miscdevice.rs | 53 ++++++++++++++++++++++++++++++++++++++- 1 file changed, 52 insertions(+), 1 deletion(-) diff --git a/rust/kernel/miscdevice.rs b/rust/kernel/miscdevice.rs index 6373fe183b27..fcef579218ba 100644 --- a/rust/kernel/miscdevice.rs +++ b/rust/kernel/miscdevice.rs @@ -11,9 +11,10 @@ use crate::{ bindings, device::Device, - error::{to_result, Error, Result, VTABLE_DEFAULT_ERROR}, + error::{from_result, to_result, Error, Result, VTABLE_DEFAULT_ERROR}, ffi::{c_int, c_long, c_uint, c_ulong}, fs::File, + io_uring::IoUringCmd, mm::virt::VmaNew, prelude::*, seq_file::SeqFile, @@ -180,6 +181,21 @@ fn show_fdinfo( ) { build_error!(VTABLE_DEFAULT_ERROR) } + + /// Handler for uring_cmd. + /// + /// This function is invoked when userspace process submits an uring_c= md op + /// on io-uring submission queue. The `device` is borrowed instance de= fined + /// by `Ptr`. The `io_uring_cmd` would be used for get arguments cmd_o= p, sqe, + /// cmd_data. The `issue_flags` is the flags includes options for urin= g_cmd. + /// The options are listed in `kernel::io_uring::cmd_flags`. + fn uring_cmd( + _device: ::Borrowed<'_>, + _io_uring_cmd: Pin<&mut IoUringCmd>, + _issue_flags: u32, + ) -> Result { + build_error!(VTABLE_DEFAULT_ERROR) + } } =20 /// A vtable for the file operations of a Rust miscdevice. @@ -337,6 +353,36 @@ impl MiscdeviceVTable { T::show_fdinfo(device, m, file); } =20 + /// # Safety + /// + /// The caller must ensure that: + /// - The pointer `ioucmd` is not null and points to a valid `bindings= ::io_uring_cmd`. + unsafe extern "C" fn uring_cmd( + ioucmd: *mut bindings::io_uring_cmd, + issue_flags: ffi::c_uint, + ) -> c_int { + // SAFETY: `file` referenced by `ioucmd` is valid pointer. It's as= signed in + // uring cmd preparation. So dereferencing is safe. + let raw_file =3D unsafe { (*ioucmd).file }; + + // SAFETY: `private_data` is guaranteed that it has valid pointer = after + // this file opened. So dereferencing is safe. + let private =3D unsafe { (*raw_file).private_data }.cast(); + + // SAFETY: `ioucmd` is not null and points to valid memory `bindin= gs::io_uring_cmd` + // and the memory pointed by `ioucmd` is valid and will not be mov= ed or + // freed for the lifetime of returned value `ioucmd` + let ioucmd =3D unsafe { IoUringCmd::from_raw(ioucmd) }; + + // SAFETY: This call is safe because `private` is returned by + // `into_foreign` in [`open`]. And it's guaranteed + // that `from_foreign` is called by [`release`] after the end of + // the lifetime of `device` + let device =3D unsafe { ::borrow(private= ) }; + + from_result(|| T::uring_cmd(device, ioucmd, issue_flags)) + } + const VTABLE: bindings::file_operations =3D bindings::file_operations { open: Some(Self::open), release: Some(Self::release), @@ -359,6 +405,11 @@ impl MiscdeviceVTable { } else { None }, + uring_cmd: if T::HAS_URING_CMD { + Some(Self::uring_cmd) + } else { + None + }, // SAFETY: All zeros is a valid value for `bindings::file_operatio= ns`. ..unsafe { MaybeUninit::zeroed().assume_init() } }; --=20 2.43.0 From nobody Fri Oct 3 23:02:06 2025 Received: from mail-pf1-f169.google.com (mail-pf1-f169.google.com [209.85.210.169]) (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 4F1F73074AE for ; Fri, 22 Aug 2025 12:56:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.210.169 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755867415; cv=none; b=pdgVT2Epd1OSbnlh3Wibc4et3sGW09pN0ybRktXxt6VaTNZAXB7AXRU7ugLwsyNXf9dSeZs8EMubHVcXwKu84bSU4kajIL/iq0/aZ0wfCrGWwywHn5qw02XygKYWIeZ5CzP24oWqlvCfCyWbXiPS4UaowqWHWUI0b7jYnkscwZE= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1755867415; c=relaxed/simple; bh=jDvtrC5CYptCtxvl1U1Uu8QRkjqDfNI+DFDh7ZSPlf4=; h=From:To:Cc:Subject:Date:Message-ID:In-Reply-To:References: MIME-Version; b=uw646oycG8Rd7dmN/TCqeol2SahGoOKxQacNnQ27mkDpc3ngqAptcvUXftXK87fylBEiN1Hy/9MMiHX7ZZ9RJ4XicZDQd5nViASctsMQuPejm5aT52gMnXBEUO+ZI3W6drRhIcHYVt2CbvXtaFCA6yXjyUdhtDbTBEjB6Mo0wr4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=furiosa.ai; spf=none smtp.mailfrom=furiosa.ai; dkim=pass (1024-bit key) header.d=furiosa.ai header.i=@furiosa.ai header.b=jhgwxhRh; arc=none smtp.client-ip=209.85.210.169 Authentication-Results: smtp.subspace.kernel.org; dmarc=pass (p=none dis=none) header.from=furiosa.ai Authentication-Results: smtp.subspace.kernel.org; spf=none smtp.mailfrom=furiosa.ai Authentication-Results: smtp.subspace.kernel.org; dkim=pass (1024-bit key) header.d=furiosa.ai header.i=@furiosa.ai header.b="jhgwxhRh" Received: by mail-pf1-f169.google.com with SMTP id d2e1a72fcca58-76e4fc419a9so1951554b3a.0 for ; Fri, 22 Aug 2025 05:56:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=furiosa.ai; s=google; t=1755867413; x=1756472213; 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; bh=fXCktcs4uaU2hiRFJow79+DYdsVC7eWvfPeFta3o3tc=; b=jhgwxhRhJ50Lutz1dhkRQLf4/yEHXMm6f+B7VFIw1Rk6gldvVYPMYe57LHmaQwWg4b 0vyZDhFUoT3nSVKLQTZRn9M/24iBgVNyrl0iJzgNj/tvcuK8rMLu4+ECv8IQH2xDcpUh qrTEWA70pmMjfbsRObwEwZhDhoJNBvHEeHG9s= X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1755867413; x=1756472213; h=content-transfer-encoding:mime-version:references:in-reply-to :message-id:date:subject:cc:to:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=fXCktcs4uaU2hiRFJow79+DYdsVC7eWvfPeFta3o3tc=; b=wG7l7iGFuBupyaBFWxHOObcMrhvQmu2Cj0xC7kgnfWYFV/lcHZwc4VkT45Qqu02W2W VJ4URFVPBWJi1qvrqcojiWC0bGsb6FyD0IWuE+MZITXVgm2Qb9a1RQD3LxyLpVEriL9A QHCHiMQ/qd/OPzfyOHv/82rxdDUCsJVuTNy1VJhl7aGvx9EPNnspYVInl6SLuIIh8gi/ aax1qIOoU72+VtBkVMTIDxdYxGfYCosq2qWh8AmVuO51vxBMt/p2I0IHU0BRe/rE1VGt Y4dRT7zNpNURIwlusPwN2Ny/nttJ0i1kA9d2v2loa2jtPvBTZgEGcrE+i2KQJgUg3Im5 /KWg== X-Forwarded-Encrypted: i=1; AJvYcCVJPRvAEJ5RikvOm3END5U8MIxNpuKtrzSmPCDvWeDX42y2r2ppu+0Vb3TQbdu1iP+Y522kI3js3FlZQxs=@vger.kernel.org X-Gm-Message-State: AOJu0YzK9Nv3TqsCytFnfUBHGGKgR/2nErMwWIvcllMBBs2xuEffBEFS WLGIYNc6R5//axa8S0XidlbbEICe8sjTFGtd2UU6sa+mlMyfv/iyUq3LFCeVxyWArxM= X-Gm-Gg: ASbGncv4MVqlVzl65Wm3maSqeeRWBsfH2aw9ps2bFETFj1Px/Xt3dd0OU49YanDqziq fPvumiQn/N7EJnQpWROphnRvoWQXt4j9Cdctnj2IuGWXoGj+Xc3o0pBgOn4Eran/vveovydTMCF b17lNEwK0QA6k8loCoWxXphnrCD/nA6kBT2rtoHUtqAoVyhSTmH1n6YWEmWGK7QDqb0k41Fbhv2 i82FZkCLsF/4n314RjhUdmMNKzJ3tzYvGEVKiMaEiV8WVCzofj1QNQrK3SeJ791Pxs4KEzQiglX o47OTBuWXJkuSqZlZwOt/FVzH3GQZVx8wBZ5yKxieSFItcoFlOpPLX5pfMrPZF3TMxzyXguKBNY o9yhmP+XKlDQLFENiM2tXE+40hhFogiwMylXzq0QdaWHWaIDAZ5MLWDpdG9MnrjAOyC004Hde X-Google-Smtp-Source: AGHT+IFGbkRU2SiqYXwwtNzw8KR7yGF/eBcv+rngOtyo7AEtcczOr+DJBGYp8ZsX+UVe04WKTVUGEQ== X-Received: by 2002:a05:6a20:1585:b0:232:7c7b:1c7b with SMTP id adf61e73a8af0-24340c429e2mr4973342637.14.1755867412700; Fri, 22 Aug 2025 05:56:52 -0700 (PDT) Received: from sidong.sidong.yang.office.furiosa.vpn ([175.195.128.78]) by smtp.gmail.com with ESMTPSA id 41be03b00d2f7-b4764003537sm7194544a12.25.2025.08.22.05.56.49 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Fri, 22 Aug 2025 05:56:52 -0700 (PDT) From: Sidong Yang To: Jens Axboe , Daniel Almeida , Caleb Sander Mateos , Benno Lossin Cc: Miguel Ojeda , Arnd Bergmann , Greg Kroah-Hartman , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, io-uring@vger.kernel.org, Sidong Yang Subject: [RFC PATCH v3 5/5] samples: rust: Add `uring_cmd` example to `rust_misc_device` Date: Fri, 22 Aug 2025 12:55:55 +0000 Message-ID: <20250822125555.8620-6-sidong.yang@furiosa.ai> X-Mailer: git-send-email 2.43.0 In-Reply-To: <20250822125555.8620-1-sidong.yang@furiosa.ai> References: <20250822125555.8620-1-sidong.yang@furiosa.ai> 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" This patch extends the `rust_misc_device` sample to demonstrate how to use the `uring_cmd` interface for asynchronous device operations. The new implementation handles two `uring_cmd` operations: * `RUST_MISC_DEV_URING_CMD_SET_VALUE`: Sets a value in the device. * `RUST_MISC_DEV_URING_CMD_GET_VALUE`: Gets a value from the device. To use this new functionality, users can submit `IORING_OP_URING_CMD` operations to the `rust_misc_device` character device. Signed-off-by: Sidong Yang --- samples/rust/rust_misc_device.rs | 27 +++++++++++++++++++++++++++ 1 file changed, 27 insertions(+) diff --git a/samples/rust/rust_misc_device.rs b/samples/rust/rust_misc_devi= ce.rs index e7ab77448f75..1f25d2b1f4d8 100644 --- a/samples/rust/rust_misc_device.rs +++ b/samples/rust/rust_misc_device.rs @@ -101,6 +101,7 @@ c_str, device::Device, fs::File, + io_uring::IoUringCmd, ioctl::{_IO, _IOC_SIZE, _IOR, _IOW}, miscdevice::{MiscDevice, MiscDeviceOptions, MiscDeviceRegistration}, new_mutex, @@ -114,6 +115,9 @@ const RUST_MISC_DEV_GET_VALUE: u32 =3D _IOR::('|' as u32, 0x81); const RUST_MISC_DEV_SET_VALUE: u32 =3D _IOW::('|' as u32, 0x82); =20 +const RUST_MISC_DEV_URING_CMD_SET_VALUE: u32 =3D _IOR::('|' as u32, 0= x83); +const RUST_MISC_DEV_URING_CMD_GET_VALUE: u32 =3D _IOW::('|' as u32, 0= x84); + module! { type: RustMiscDeviceModule, name: "rust_misc_device", @@ -192,6 +196,29 @@ fn ioctl(me: Pin<&RustMiscDevice>, _file: &File, cmd: = u32, arg: usize) -> Result =20 Ok(0) } + + fn uring_cmd( + me: Pin<&RustMiscDevice>, + io_uring_cmd: Pin<&mut IoUringCmd>, + _issue_flags: u32, + ) -> Result { + dev_info!(me.dev, "UringCmd Rust Misc Device Sample\n"); + + let cmd =3D io_uring_cmd.cmd_op(); + let addr: usize =3D io_uring_cmd.sqe().cmd_data()?; + let user_ptr =3D UserPtr::from_addr(addr); + let user_slice =3D UserSlice::new(user_ptr, 8); + + match cmd { + RUST_MISC_DEV_URING_CMD_SET_VALUE =3D> me.set_value(user_slice= .reader())?, + RUST_MISC_DEV_URING_CMD_GET_VALUE =3D> me.get_value(user_slice= .writer())?, + _ =3D> { + dev_err!(me.dev, "-> uring_cmd not recognised: {}\n", cmd); + return Err(ENOTTY); + } + }; + Ok(0) + } } =20 #[pinned_drop] --=20 2.43.0