From nobody Tue Feb 10 04:23:13 2026 Received: from mail-wm1-f74.google.com (mail-wm1-f74.google.com [209.85.128.74]) (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 0AB68219307 for ; Tue, 29 Apr 2025 14:44:40 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.74 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745937882; cv=none; b=ZD/PqbOMduToKiLDyiE1kkl5AtjoZUkIZZ8iCUpMfKgXnx6khA0M81jtROUqvCIzOhayxcJO0aVD5XdGxQHbibwC8LMAOsrtN+nvhWyFyMoLfUri9qDHolGW9gdbQAHn1Wj4WuxU7Yu9P+jTkwjTr0nTv5yb1VfVwUnM9uHfydY= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745937882; c=relaxed/simple; bh=K5++jtkWdFKeGKaBv79rQOtxNbNpObzYBnqu3tQEGaA=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=UpqtecIPrebgF8ApJXPppOi2L1uT2n6S3kuCUXVopdJE1a+pS+0xiKPWcCKZ0VnPRYUh8MNWP+aHUgEP5XFhNieFz5uHFAT0ABspdimtUcUbZoo44pcNzyf9BHXGHSi6fjkcOjbYA37SWX1UN8uSevchR5d4Rl9opMERiOxnLdk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--aliceryhl.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=VOxkzU8k; arc=none smtp.client-ip=209.85.128.74 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--aliceryhl.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="VOxkzU8k" Received: by mail-wm1-f74.google.com with SMTP id 5b1f17b1804b1-43d007b2c79so37681745e9.2 for ; Tue, 29 Apr 2025 07:44:40 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1745937879; x=1746542679; 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=6B9w1IN3J8l+gx2wlL6oxYawXvUUUb3KDtVl/y0wnY0=; b=VOxkzU8kXkPC5NWlEnALKGhJVRmPnPMCqoE98K/UVhnxZDK9lHyX7S1isfWdGO8B6d fsHP4lV/gEouqgK882bUv1NQ9758U0mP21rqbOgRTuQkhvjorey0PvEtbCKv4c3LNgNE ooba5egb1wm4HpIFK4LNFVgqNYD/y6tsM6OzMwYVXLKn9dj0WTp43xwNwjFkXxgrNHju Jqa/HtNcpAQZjGsV9v6xWzollxjI6KpFm49ZomoyRvGfIQHLF+ySRNgn0nyWbUMx+xgz G3C7MLLtp+IFWdhVqnbwrgQTM6MnSLSuM4oDB0NkaNNPbPU2gKmeO1XfzpVY30qGByc1 PekQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1745937879; x=1746542679; 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=6B9w1IN3J8l+gx2wlL6oxYawXvUUUb3KDtVl/y0wnY0=; b=nv0QLOhy8rtk3eNmDaxVk+H6hGDvVi7zJ7aKXEGgybWIVOti31JGN0sUFZMGD9p1q5 uQ3Rr8zbvXYD1FdqSQMgke2hB0zA7R6OtoZK7m7LP8zsIMes5/Y/bStLpIqfUTWz6+7q uMCnDv7xQDCXkf+vdd5Li8C4gQIqRjGnb5X0evr0JJXkYl56MTnNfaJVLVUJvXhj80yN 5adj17UiLlcBa9zgyfH08P77J8tMBnfdXsYBI8ewPYoth10isyGcz4t4Ec66S/hLiMoN v5+NXzD/YOxzidyDlexzz1vpUsyZUi3eh6anVaD71Dd2QOufKa8UBMdwS0je6Ksd1dTw 6OfA== X-Forwarded-Encrypted: i=1; AJvYcCWMq03suvFnSlSoqtSTAv3x6ip8J2qyhCR4ZlbBVdi7d3ICw4odum2gAdAiv1vDvrfdJB458ssrIZ8AHew=@vger.kernel.org X-Gm-Message-State: AOJu0Yw6uRjdvJ3MVLQX7n9eConbpUafoPeDJ2agjUP+VagO7KxDdek7 v2grOJW6bo7tSx2A4kBI1hDvypIRdwyOsP4mJ0Q8cVpOMdtilyG+j7ytb4lr7WiofOxM2v+T4Pz OTxBtkm7Z87ChkQ== X-Google-Smtp-Source: AGHT+IEJ8sOOOHYMa5Vb9TKyn1mOsPbkuM0Gwu6IBt4Hyt0X1N1f51tfO/ybPraISY9tVDCZrhmBYdDqgjt1EBw= X-Received: from wmqd10.prod.google.com ([2002:a05:600c:34ca:b0:43b:c336:7b29]) (user=aliceryhl job=prod-delivery.src-stubby-dispatcher) by 2002:a05:600c:1909:b0:43d:fa59:af97 with SMTP id 5b1f17b1804b1-441ad4ff981mr22703445e9.32.1745937879469; Tue, 29 Apr 2025 07:44:39 -0700 (PDT) Date: Tue, 29 Apr 2025 14:44:21 +0000 In-Reply-To: <20250429-vec-methods-v4-0-dad4436ff82d@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250429-vec-methods-v4-0-dad4436ff82d@google.com> X-Developer-Key: i=aliceryhl@google.com; a=openpgp; fpr=49F6C1FAA74960F43A5B86A1EE7A392FDE96209F X-Developer-Signature: v=1; a=openpgp-sha256; l=1339; i=aliceryhl@google.com; h=from:subject:message-id; bh=K5++jtkWdFKeGKaBv79rQOtxNbNpObzYBnqu3tQEGaA=; b=owEBbQKS/ZANAwAKAQRYvu5YxjlGAcsmYgBoEOXSNjAcDgC2N2uwDD9iN46zr6Pr3b6c+NT/b FxApjeQvNeJAjMEAAEKAB0WIQSDkqKUTWQHCvFIvbIEWL7uWMY5RgUCaBDl0gAKCRAEWL7uWMY5 RiNMD/4m27KxuNiQidWUStcThfFshtZS8opY8NjFTvgQ6jbCRcKlsiXuumuv96FgEW1l5udi4h/ zVjIWIC9RwK3PCmlBKK5lTqjqHb8+vkV+z+YqFsLDKEc+UmuWQBwKSoQYh2+TvaFdj8v9GCOs/J 8KbGn6a5855JyjXyZqUzijnAjdcq4lMqEx8M9GvYCMyDv2zzX/EhalNrGLI5NUs95f58fGhF75h 5Q5waEIZn6Bx2AXMwjlXUJ6dWGTsbrCGcrufRKYfep+pZ7KSpUrAeWWT1AYPQHacS5BYJycEW8S UVwus3OU1dQcXEfrLksSnJZ8cefoqijLhdCs7d+hJj5y/P4ee1QV0YuCaUSdbgeifio1NqR17N1 236vq3soN2M3eibHKo0RdwEttBBHJlwFhFErBAL0cQDoCFZgy+tpvW/8iqd1HquuiL7bxjDUwsT hNFS4sE5fBXQ3iqsnJrmLnzfcat4As6glzvQkSWxcHbes3QLMB5sW8GbYKwqK6RJ6UB//227BnS 1hLlRTA3x3m2enlzGdJFCRaPywq2EfYJhtWNuRNqXzeP4N70oxpGUBYnXjXE7DXQO7Bhmn0egq9 SQRTZFg/AXxY3uH1tQ2QuhtkE+O6c53Gwl2b+GQsMLVdwffI0RfvgPIWg+uNsURJ43Etxj421O5 ldSz0sl/zHKzn3g== X-Mailer: b4 0.14.2 Message-ID: <20250429-vec-methods-v4-1-dad4436ff82d@google.com> Subject: [PATCH v4 1/7] rust: alloc: add Vec::clear From: Alice Ryhl To: Danilo Krummrich Cc: Matthew Maurer , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, Alice Ryhl , Benno Lossin , Tamir Duberstein Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Our custom Vec type is missing the stdlib method `clear`, thus add it. It will be used in the miscdevice sample. Reviewed-by: Benno Lossin Reviewed-by: Tamir Duberstein Signed-off-by: Alice Ryhl --- rust/kernel/alloc/kvec.rs | 20 ++++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/rust/kernel/alloc/kvec.rs b/rust/kernel/alloc/kvec.rs index 5798e2c890a2140a12303706578ffa2a85423167..412a2fe3ce79a0681175bf358e8= e0f628e77e875 100644 --- a/rust/kernel/alloc/kvec.rs +++ b/rust/kernel/alloc/kvec.rs @@ -413,6 +413,26 @@ pub fn into_raw_parts(self) -> (*mut T, usize, usize) { (ptr, len, capacity) } =20 + /// Clears the vector, removing all values. + /// + /// Note that this method has no effect on the allocated capacity + /// of the vector. + /// + /// # Examples + /// + /// ``` + /// let mut v =3D kernel::kvec![1, 2, 3]?; + /// + /// v.clear(); + /// + /// assert!(v.is_empty()); + /// # Ok::<(), Error>(()) + /// ``` + #[inline] + pub fn clear(&mut self) { + self.truncate(0); + } + /// Ensures that the capacity exceeds the length by at least `addition= al` elements. /// /// # Examples --=20 2.49.0.901.g37484f566f-goog From nobody Tue Feb 10 04:23:13 2026 Received: from mail-wm1-f73.google.com (mail-wm1-f73.google.com [209.85.128.73]) (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 6D05921B195 for ; Tue, 29 Apr 2025 14:44:43 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.73 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745937886; cv=none; b=odgFydDonu6V7/imO/Wri+fktSAvTvtF7zdLb4RQst/u9NBd2htcsm67bB0ySYvo+UC6Ru40pcqUFKuxEmECxkF2MyFOyYF+72KpNlgVR6IE1dvn4TQaEkTzRNYsypNegpcqvrqYnuIjMt/3AaKgdAPU+mZb/AE18utTC0R7OK8= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745937886; c=relaxed/simple; bh=Hiakr7Y9aYp+t0qkrintpujLcwt0vMBhaVvBld3CMvQ=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=r6XhwvwzjqKVdwpDcK1bLk9OMpFagI7HkidJ1cwyZQUAv5WjDrqLXYizGtkRFzFiG5NeKZOw0peCQmf3oETuDp/m48+4qW1l/Gmq3qV8b3GC5mNo2P46H+JbrE18XVP/4edka+K/E3gWy2i/mANWJ++3kpOLQHIF/YWs6ObM9N4= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--aliceryhl.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=A6wIORcY; arc=none smtp.client-ip=209.85.128.73 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--aliceryhl.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="A6wIORcY" Received: by mail-wm1-f73.google.com with SMTP id 5b1f17b1804b1-43ea256f039so45627885e9.0 for ; Tue, 29 Apr 2025 07:44:43 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1745937882; x=1746542682; 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=s939wDzCcsIUv32fGMnjwXbycHwC2LyhdpkAIZGUK8E=; b=A6wIORcY7pWBFLxQPxION0b/v80wbAr2uEwEIrOA5zKoVX6XzUVsCcGD35PUbLWZS3 8PF7aXaYV2/By54Lwh0HmjGy2u7+sIvtQZLE5cGP0cywc86Ms9etckedWn6mnXUtkzq9 XdAxsXp+yof5Fb/haJFKZMm3mqFwLO1G1YR5gvFaE0WikABtEWQkk5cSWyivnP/hCKtu ESWqOzJp/2PlI//epL0BTCYaYn4cDkebsmY4kTNk/Lid0r1AQSPkFdIIq1rIL4SDUY2u uV3h7GAh84zIhv5OSRP3yV6oU+wvnBxVkeB6/Ns/azTIXVyJpKzfEBZYmXwg+kPokDuc KLSA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1745937882; x=1746542682; 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=s939wDzCcsIUv32fGMnjwXbycHwC2LyhdpkAIZGUK8E=; b=M9XOsEuS04Q+LlKZokAMhLW/y7q478Moj3v+6ewA1/8xQgLP5/kkNeNB3Up94Fe8Mg UcAONpzv7mgJ+143N9JubxK6UR7bSRHbhB+HBcOrb4469s+op/S0wMOpD7ndnSdEWFfO 2FQ1PO/uslp6bTWwDKI09RTftTY9KWrbCY9uGIckBNwzx4upCF3lVp3psaZBZI094yuA 9CZ+zyVCFyaFsXhPwo36V9KNxHc4JqdYoFrRllW/h0/p9X4Rm5DHN7h3bXSTLrjMd1DS +aG1HDvcGqrvSgNYyEELtu3WOfYAjL+c330y/5UTqHNjkIXeg9DzvQkVHRM5t9RWqG6w 2wkg== X-Forwarded-Encrypted: i=1; AJvYcCUMloU8i65gVMRpr5y2LhBeB2M+xISQiS2BE3DGSN0/DNql1iW/fWje1hxC1sNAGL5+/NV6d+OwMhGVQ/w=@vger.kernel.org X-Gm-Message-State: AOJu0YybRi2oMdK2ZJNRx9BHBPnMi+KRXPXr65b/lLD6G5ZekBbLg8nU gjB87Ir740uNo17ScWvJ9t3Npx+bG/lejww+Abrr/jxA9HYxDDKU86AfktWkQpfQBeR3Aseb91G 8MEHgpvNB2xl1bA== X-Google-Smtp-Source: AGHT+IFD19DC6VNFdYNHaJ5B7QYfDpABloUHji8YWEgBpm0M3wFbbm8SDhfVUUEtTh/LkNEshZM3o0hDQuHw7n0= X-Received: from wmbbd17.prod.google.com ([2002:a05:600c:1f11:b0:440:5e10:a596]) (user=aliceryhl job=prod-delivery.src-stubby-dispatcher) by 2002:a05:600c:3b0a:b0:43c:f63c:babb with SMTP id 5b1f17b1804b1-441ac84b420mr30698235e9.1.1745937881832; Tue, 29 Apr 2025 07:44:41 -0700 (PDT) Date: Tue, 29 Apr 2025 14:44:22 +0000 In-Reply-To: <20250429-vec-methods-v4-0-dad4436ff82d@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250429-vec-methods-v4-0-dad4436ff82d@google.com> X-Developer-Key: i=aliceryhl@google.com; a=openpgp; fpr=49F6C1FAA74960F43A5B86A1EE7A392FDE96209F X-Developer-Signature: v=1; a=openpgp-sha256; l=1873; i=aliceryhl@google.com; h=from:subject:message-id; bh=Hiakr7Y9aYp+t0qkrintpujLcwt0vMBhaVvBld3CMvQ=; b=owEBbQKS/ZANAwAKAQRYvu5YxjlGAcsmYgBoEOXSNUMSfaKjzrQ8//RXnlSgRBdfrVgIxEqPV n/6wNru+VKJAjMEAAEKAB0WIQSDkqKUTWQHCvFIvbIEWL7uWMY5RgUCaBDl0gAKCRAEWL7uWMY5 RlmiEACIdJOy+8wpGjYitzbsFLExkryvyKH+MbykJsYTYqDZjsQGFdT4+9q0q2womW5yrrag8qP vixnqJ4xGGBaLv0xtMD41UESRvHuV4xXuQYarqGC6vbmVWajdOSPjxH9H7kd9k+py7a92Cak0iT IxRmZ5RpcV9rZ9WEdXOthMC/5NtNTa1/TmMY9PJWHdjknsOUPdJP7d6jvf9Qa4wxieDJclJOBTg lBpTb+9E8fi5bsw3QZLN7nMPZoHBeYQvyA+poQ8qluFTVrg97OJdhVe+yCvbMeuSRC2FtEG+OrN bUKSg0pyq37oNY1KIxrViGFDhdhpTrP4gevrhUbToGV4zga5t/f6P69AUx7vchrpp2IwPlNXz+A qZvGjeHtSU3fPq405GorDflI2r4cTg0QjvxE1uDJOj/IdTqvjtzD6p/ikwStTLPWpefMYhGOB0m +ihAflNQutzotktkTvmXo+9w277W9ZuHV0ymKr/IjM+M90waKuvFIfdtmDW4wcoENHhrY9mQ7+7 HU/2+4d7ew1afSYyBjwW+20PlPEA4H7/8vI850aB0XEpvthp+pdRQ8hVmPtegeH0wpfXCiv0dSD rFTTLE93K9ycZ17yIPwhbAiarl+aHpUwCdn9egxavBn1CrTGt8mSVwLnq7dWKzJczWBkz4dgnci 5DsIGS28+xlpmDw== X-Mailer: b4 0.14.2 Message-ID: <20250429-vec-methods-v4-2-dad4436ff82d@google.com> Subject: [PATCH v4 2/7] rust: alloc: add Vec::pop From: Alice Ryhl To: Danilo Krummrich Cc: Matthew Maurer , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, Alice Ryhl Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable This introduces a basic method that our custom Vec is missing. I expect that it will be used in many places, but at the time of writing, Rust Binder has six calls to Vec::pop. Signed-off-by: Alice Ryhl --- rust/kernel/alloc/kvec.rs | 31 +++++++++++++++++++++++++++++++ 1 file changed, 31 insertions(+) diff --git a/rust/kernel/alloc/kvec.rs b/rust/kernel/alloc/kvec.rs index 412a2fe3ce79a0681175bf358e8e0f628e77e875..ebca0cfd31c67f3ce13c4825d70= 39e34bb54f4d4 100644 --- a/rust/kernel/alloc/kvec.rs +++ b/rust/kernel/alloc/kvec.rs @@ -320,6 +320,37 @@ pub fn push(&mut self, v: T, flags: Flags) -> Result<(= ), AllocError> { Ok(()) } =20 + /// Removes the last element from a vector and returns it, or `None` i= f it is empty. + /// + /// # Examples + /// + /// ``` + /// let mut v =3D KVec::new(); + /// v.push(1, GFP_KERNEL)?; + /// v.push(2, GFP_KERNEL)?; + /// assert_eq!(&v, &[1, 2]); + /// + /// assert_eq!(v.pop(), Some(2)); + /// assert_eq!(v.pop(), Some(1)); + /// assert_eq!(v.pop(), None); + /// # Ok::<(), Error>(()) + /// ``` + pub fn pop(&mut self) -> Option { + if self.is_empty() { + return None; + } + + let removed: *mut T =3D { + // SAFETY: We just checked that the length is at least one. + let slice =3D unsafe { self.dec_len(1) }; + // SAFETY: The argument to `dec_len` was 1 so this returns a s= lice of length 1. + unsafe { slice.get_unchecked_mut(0) } + }; + + // SAFETY: The guarantees of `dec_len` allow us to take ownership = of this value. + Some(unsafe { removed.read() }) + } + /// Creates a new [`Vec`] instance with at least the given capacity. /// /// # Examples --=20 2.49.0.901.g37484f566f-goog From nobody Tue Feb 10 04:23:13 2026 Received: from mail-wm1-f74.google.com (mail-wm1-f74.google.com [209.85.128.74]) (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 B9A7F21B9C2 for ; Tue, 29 Apr 2025 14:44:45 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.74 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745937887; cv=none; b=io7VwKc64JqcTVrEN4oijZtBMoQHe69BQXhBQKNSkTL7YGUuzpNBEzcVn4jMfQ/VJkgGk1obvMlL7GWMOufkTb78KY8JEYsI9ksEy2eB3ASpT0soYgfxsawwZ7XXWY9Qxd40S8asLeKGkI1gFwwM55qofS0zok8FMo+AKM8/Spc= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745937887; c=relaxed/simple; bh=D9q72Tm7LijWnbymPuTzwtfVCSEeFnm/o1uM8aRtROw=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=J1pe+8T7eiy8gkVY/gKfv4A64594GDXkym6niFPnLaGTatfkffz1sRYunl/qYA6cev3qA6C9ZZN/zYvL3Iw9sB4VIChR3RNsbfClp8O4oS3GZ7/xZEpoNRjw+Xn3lF3dn3/4SBOurpB48R+/BVLIziCmBUnfxS1lykdeuKbaJUM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--aliceryhl.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=uaCm+t5I; arc=none smtp.client-ip=209.85.128.74 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--aliceryhl.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="uaCm+t5I" Received: by mail-wm1-f74.google.com with SMTP id 5b1f17b1804b1-44059976a1fso24536175e9.1 for ; Tue, 29 Apr 2025 07:44:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1745937884; x=1746542684; 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=aiSfQ27fj5IBPSxh2S/xTxj4UGqPN2v0kl/9jDk2lMc=; b=uaCm+t5IafJoKGQhclJDeKXzAHr4lTeb+q1Y7wkY6O9vqJTT/Wu9CI5bCJryIZO4vR XufnvM3LiF2zCq9V0kaFJK8xERDAWcNT5kB05DDxADM/sYp5kGA4qzZyt46/No6HEPCl pWte1bmqmIP6ghXhhiue0LP2NXQWhwULaYBsmk2MQCB4fxVEYYjrzl/VJJq66h40ZPRN udxO2Xnh9Wv3Ju0i4K8FXVndfb6kfKw0c3xilK2tCopFEesBXU+rfker61mnVWo4Bal0 j1fcLDLmFOhANPx3gZGLZTDwrQ3lOhCZFU0TuFkvHgd/0Nxio0eHT6DEznX980S4CkSo YuuQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1745937884; x=1746542684; 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=aiSfQ27fj5IBPSxh2S/xTxj4UGqPN2v0kl/9jDk2lMc=; b=LKgRnmPZMl+vap0seWr4IhcGcdrnuy3APNm36x124XX214RBrEKBBuwB3OQmfuJn8X 1QD0vloER4IOJ6AMOQTCzHd3fFzrhjeI9+4mbw3PgdiMAArlxLE2ftypApmNFIvivqtg pUX0LORgzdRMGCbWEpWM7NtHTwXPaO22yKuA6ZIn05kcY51efL8tjpHZHuXcWwBxaz2a HHZlBHYD3FNDHOBdXlHlLDDLxNRxMypWtwbcaMTSHOs3wd7Y1AVbtiZFEZrwaAbSkE1s JX+101SwWSZBmMXYDGXrpLWVZKqH3N6JfBaGOwQfMboGVNcU77yGJiIi6Fe1kKnrUYJV PbKQ== X-Forwarded-Encrypted: i=1; AJvYcCUE8pKNjiqLDmzgfunlsQcHK/R7nrwVUKC9QSIHQuk8unigvCELlWBFKv+qrlIJD7Z1DQKmnzX77dUowcc=@vger.kernel.org X-Gm-Message-State: AOJu0Yxwk3Os3zZ/sBuEmm3mOvYIhJe5le1kN8RMgtT1IsSB1DDfaB4J +c22q9eBYn99FHInCo+VLJKI9o6n8JflO9lf0zO7Vl0c/WcY2gaR9thDKmjCWJHanDjbhdmlu7C qhVBqIDwGuEnBug== X-Google-Smtp-Source: AGHT+IFW8oPuiDi4AxR/k5oC+wq4WdArS/W0TAkFwKimwoaNCA6P3cmgo99NtWs7vVEgqJD8BPJ4WuLbuqbzZqQ= X-Received: from wmbbi8.prod.google.com ([2002:a05:600c:3d88:b0:43d:1ef1:b314]) (user=aliceryhl job=prod-delivery.src-stubby-dispatcher) by 2002:a05:600c:4f0f:b0:43b:ca39:6c75 with SMTP id 5b1f17b1804b1-441ac8f6276mr34688715e9.16.1745937884207; Tue, 29 Apr 2025 07:44:44 -0700 (PDT) Date: Tue, 29 Apr 2025 14:44:23 +0000 In-Reply-To: <20250429-vec-methods-v4-0-dad4436ff82d@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250429-vec-methods-v4-0-dad4436ff82d@google.com> X-Developer-Key: i=aliceryhl@google.com; a=openpgp; fpr=49F6C1FAA74960F43A5B86A1EE7A392FDE96209F X-Developer-Signature: v=1; a=openpgp-sha256; l=3286; i=aliceryhl@google.com; h=from:subject:message-id; bh=D9q72Tm7LijWnbymPuTzwtfVCSEeFnm/o1uM8aRtROw=; b=kA0DAAoBBFi+7ljGOUYByyZiAGgQ5dKil7OziBsp/gjNDysCANqEFAme6m5Lm0BBoV6lIHn5f YkCMwQAAQoAHRYhBIOSopRNZAcK8Ui9sgRYvu5YxjlGBQJoEOXSAAoJEARYvu5YxjlGhIEP/0vk IWevYIbWyuqO5bUIN/IN75Qn4wkxSCMEDwT7rU1NeTo5qe9zYzcglv/ukXIybFC1Hr3rro2cw1/ wp+PQesE2htTDeACEgjmntpNRG0QNlJE91ilno7Vdm3EmRKw5Vb5fPalq5aS6wcmQTxYtjhohFX hAsL4jSSUSWkMKPPI0ykoOnNzeHTZouVoUKVSj1h1ZcBivtC1vpP9kWlnDn1mJuqtrz0bCKbVNg 8nenqSNGN0y76ulOl9z32MrbtZWSIi+/sRfOzcoFXK3kbeEUP8K1m3LOf7fbz+GyIBceNcbrZZ+ P1HLDXmVTMqAcCqtvqBVHWEyCaAnI9/bV44lTtFxdkAP1SbvulSbN5ETNJim1z8SsXwrMWgdxdU asAM9KrmVmEHH6xwKlTWpxUIs9/di52hOFcaUqSFQ3BDdmdKDeP5mCA8anE5Asm1dJvfDhZ5HAC wbtWVzas2g7dDKtIyVJJtBkDE878Lygd7X/aBlbb/wmiVt0aR1+T4VyWznfxMpknZ3QRshM0oR3 Ph6pP06tCqs1lC87YH6P1VctGmvtB7bcgX8QhJ3QtUNmCOjjrX+ViCyxamJJqOf79f4e5oi0u8Q Xhq95KuE+tVJmCagQlcqwQwwTLOENa2o8O5fYVxsn7vTA7caotPLRZLTJvEZo9FgFEfdn9tUGUu YgkTn X-Mailer: b4 0.14.2 Message-ID: <20250429-vec-methods-v4-3-dad4436ff82d@google.com> Subject: [PATCH v4 3/7] rust: alloc: add Vec::push_within_capacity From: Alice Ryhl To: Danilo Krummrich Cc: Matthew Maurer , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, Alice Ryhl , Boqun Feng Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable This introduces a new method called `push_within_capacity` for appending to a vector without attempting to allocate if the capacity is full. Rust Binder will use this in various places to safely push to a vector while holding a spinlock. The implementation is moved to a push_within_capacity_unchecked method. This is preferred over having push() call push_within_capacity() followed by an unwrap_unchecked() for simpler unsafe. Reviewed-by: Boqun Feng Signed-off-by: Alice Ryhl --- rust/kernel/alloc/kvec.rs | 43 +++++++++++++++++++++++++++++++++++++++---- 1 file changed, 39 insertions(+), 4 deletions(-) diff --git a/rust/kernel/alloc/kvec.rs b/rust/kernel/alloc/kvec.rs index ebca0cfd31c67f3ce13c4825d7039e34bb54f4d4..78a602e0f00494a52df0e0aa5ee= dc68967a3011e 100644 --- a/rust/kernel/alloc/kvec.rs +++ b/rust/kernel/alloc/kvec.rs @@ -307,17 +307,52 @@ pub fn spare_capacity_mut(&mut self) -> &mut [MaybeUn= init] { /// ``` pub fn push(&mut self, v: T, flags: Flags) -> Result<(), AllocError> { self.reserve(1, flags)?; + // SAFETY: The call to `reserve` was successful, so the capacity i= s at least one greater + // than the length. + unsafe { self.push_within_capacity_unchecked(v) }; + Ok(()) + } + + /// Appends an element to the back of the [`Vec`] instance without rea= llocating. + /// + /// Fails if the vector does not have capacity for the new element. + /// + /// # Examples + /// + /// ``` + /// let mut v =3D KVec::with_capacity(10, GFP_KERNEL)?; + /// for i in 0..10 { + /// v.push_within_capacity(i).unwrap(); + /// } + /// + /// assert!(v.push_within_capacity(10).is_err()); + /// # Ok::<(), Error>(()) + /// ``` + pub fn push_within_capacity(&mut self, v: T) -> Result<(), T> { + if self.len() < self.capacity() { + // SAFETY: The length is less than the capacity. + unsafe { self.push_within_capacity_unchecked(v) }; + Ok(()) + } else { + Err(v) + } + } =20 + /// Appends an element to the back of the [`Vec`] instance without rea= llocating. + /// + /// # Safety + /// + /// The length must be less than the capacity. + pub unsafe fn push_within_capacity_unchecked(&mut self, v: T) { let spare =3D self.spare_capacity_mut(); =20 - // SAFETY: The call to `reserve` was successful so the spare capac= ity is at least 1. + // SAFETY: By the safety requirements, `spare` is non-empty. unsafe { spare.get_unchecked_mut(0) }.write(v); =20 // SAFETY: We just initialised the first spare entry, so it is saf= e to increase the length - // by 1. We also know that the new length is <=3D capacity because= of the previous call to - // `reserve` above. + // by 1. We also know that the new length is <=3D capacity because= the caller guarantees that + // the length is less than the capacity at the beginning of this f= unction. unsafe { self.inc_len(1) }; - Ok(()) } =20 /// Removes the last element from a vector and returns it, or `None` i= f it is empty. --=20 2.49.0.901.g37484f566f-goog From nobody Tue Feb 10 04:23:13 2026 Received: from mail-wm1-f74.google.com (mail-wm1-f74.google.com [209.85.128.74]) (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 E712F21CFF7 for ; Tue, 29 Apr 2025 14:44:48 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.74 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745937890; cv=none; b=g/QwdOINTJzuE2dUtWZ4lWv49Sgk4HV4DTyhVlTvPtqbgqLBkIqwqCZHHrxEe24q/wqPqMTZ1Wgesbt1s8itmXTH1Ab7erTD9yn63fI7Qtc5Ea14T5CgOnB3dLvmQ5/jGCmXWa+ydqSCGkaOd6epyxBPYyT584QBks/nuKl6u48= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745937890; c=relaxed/simple; bh=1X6QV7LMXeaPLgyMDH16gC5yJhAadudg+klWVEnNVAM=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=WOHAV10+RjemwfD8nT1WyE/i4jyRB1vzsmAYKGPEswzC/D/g5YbZheisDifqeOZk57eFUjXf1BpdmDtZNr9omsA2fs6vZq/YVtFM2PqV1wWXODX3RYyucDD1dz5A1geomL8Ybhp6EIK5xY6CBLNDfeK/EtffatnBfBBMJLOFRM8= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--aliceryhl.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=zzsSK0Ff; arc=none smtp.client-ip=209.85.128.74 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--aliceryhl.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="zzsSK0Ff" Received: by mail-wm1-f74.google.com with SMTP id 5b1f17b1804b1-43d00017e9dso34214265e9.0 for ; Tue, 29 Apr 2025 07:44:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1745937887; x=1746542687; 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=Aw8SMoJoJ0vdE9jmgPG+tjZtPjb6PDbEV0V4jzbTcEc=; b=zzsSK0FfLnMBW80HSTpgEo9msUUFPTjDtuI0tLHCJTZ5EjLo62Mi9kWMP1HsGut6j5 6bx0bafpQP4S+DxHjia7vVGS/fLnrhvYK0FCU9uW33vhAcnFu2NLNRB1DjjgNYAgezpe w/CRywMKyybcZX0RxCYdUDqdiYfsLFW6chowMLWJMnlkuHTaucgRbHJEJ4sUAEXC8Rtt RjM/2QDQVtTjivkKAVngfzRv3fbEzwT9sIAuSufQCf1VRvDZDNFPCx+lYJB6RUAwgIBn aWqcPKnLVno5ukB0Sso7c3kueyj2XinTafbGYaZJn4ZXnpJubQ+KdIoNbCZxfHyvl2as 6/CA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1745937887; x=1746542687; 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=Aw8SMoJoJ0vdE9jmgPG+tjZtPjb6PDbEV0V4jzbTcEc=; b=dcshrvqTBIwlyiiT0vrGq+NZvjJrcMIMGBz+nPLMHc5uceM2eArNiFZFblXYueBBXV XkRzA4H0GiE4J0x/4OG9haoLWD4/LFC5RFJKvGiGdbIkT5a0gPl4qoMOMzPySXCE3ANB rzQUxxvcUxuxUU7wa1IWzzK8Z1g670xvmWVgOnPFYFngMFyytBFCUQPrOTo3Mj0F55Rl 09MkbJA0RwqyCZUTRtuiXZJKlrkWfuILyjyQx4I0dz1viVKi6gRyqIL6F1kCaqECGJ4L t8fk4ZtnWUzPst0Ji3GB1WyWqYnChDVHNiEU7htMCmp5P/3o44I03dh/Ppih/d1WUSMJ kvDg== X-Forwarded-Encrypted: i=1; AJvYcCVR7ipmCSpTcb9OlBet71XbgVCXSVT4gIHeCN3VIU3YDDhdcsIoC9axszBO9T1akq+dfP/pHrBFi+lW6Qk=@vger.kernel.org X-Gm-Message-State: AOJu0YzI4xC1wwPpmzV8iPbJOi5yZWDs/u49Id1cO4b3jooZhY9tAP0a DFXrlZMJpWp5MfhVSbJ6vxg62mfO9VMVYBe3etbYs2/UB47aSCoUnKXuqvwdqkZgGVBI2yS0WJ4 nU1/f45zIsL3CKw== X-Google-Smtp-Source: AGHT+IEfHbIDKQuLE5wpGBwNgeZINiUEJCFamqt7ahLjL7XOWrQKYyH+IX4HnUMIxYOYQr0FwaVvzbF57EkyitU= X-Received: from wmbfk10.prod.google.com ([2002:a05:600c:cca:b0:43e:9aac:5a49]) (user=aliceryhl job=prod-delivery.src-stubby-dispatcher) by 2002:a05:600c:3d10:b0:43d:94:2d1e with SMTP id 5b1f17b1804b1-441ad3b5e87mr30499135e9.13.1745937887639; Tue, 29 Apr 2025 07:44:47 -0700 (PDT) Date: Tue, 29 Apr 2025 14:44:24 +0000 In-Reply-To: <20250429-vec-methods-v4-0-dad4436ff82d@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250429-vec-methods-v4-0-dad4436ff82d@google.com> X-Developer-Key: i=aliceryhl@google.com; a=openpgp; fpr=49F6C1FAA74960F43A5B86A1EE7A392FDE96209F X-Developer-Signature: v=1; a=openpgp-sha256; l=3070; i=aliceryhl@google.com; h=from:subject:message-id; bh=1X6QV7LMXeaPLgyMDH16gC5yJhAadudg+klWVEnNVAM=; b=owEBbQKS/ZANAwAKAQRYvu5YxjlGAcsmYgBoEOXSsgahz5UZI6rrsTFFn4ZKTCFt36ztjVPe0 0im3Q4BYoyJAjMEAAEKAB0WIQSDkqKUTWQHCvFIvbIEWL7uWMY5RgUCaBDl0gAKCRAEWL7uWMY5 Rn4pEACy6IOo7ljDLEYh2+6Q+g56vuW3HAgDo+OWg5l0Fp1RRnkD+YObjDDGK2UWNitixoJXYmm ddsjl4Et9UTH9YiZg5VAuVaiM5Nlev4X/KkB/Ie4Qk8+XVvWPeeR9OMyrkOzOxrkmhC6tWhq5Hj ubXqxqc34eFhtBHjeu9tWtN3toKW7c1CDmTE+uoCp1eosUIh5Vq5Uf5zJyV9iEV5qYMctxZFGG7 5Tc8t2ugdVFqqTwvdEODNyuN0sbqK4L8IuSKkUDlRlHvaXFyWKJ4MxxwJxZMYMu3ISXOdMq6k5y EOXsb76N2wjCrSb6nzi7Xe4EzFW5mj/vTJtHBV3pUCYo2KiapcgEmBDrwKirPgsNX8c2Gu0VTnA JkVOXh2f+SUMY4vNZnifJRAzi/PAT7Brskf3SQCs1+CBg3qM2qdgeEIAOadZSZMOC7GjZMDb7Gp SBov5+I7fE5N/tyunRFFqy0IcjAt/5JLPhW5FdzWwcn3PLKLO0vjP63fLBLJNUfGZYr/Pal82Gp V71Aa3J8tLC85+a+iX+yBG3rM/KiO1ciERzCg3yA1siZk29GzhFHMP/rbczs+zyUyCEZ+B8lqbF 1sR3BHg9HEuySlOSWLZb/Mso+EffqUxIVdKZgm/QZIMa/NKlkEA0VHPEFGOt+FDDZskmgnFsqxc 0VD2DQi+gg9WTug== X-Mailer: b4 0.14.2 Message-ID: <20250429-vec-methods-v4-4-dad4436ff82d@google.com> Subject: [PATCH v4 4/7] rust: alloc: add Vec::drain_all From: Alice Ryhl To: Danilo Krummrich Cc: Matthew Maurer , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, Alice Ryhl Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable This is like the stdlib method drain, except that it's hard-coded to use the entire vector's range. Rust Binder uses it in the range allocator to take ownership of everything in a vector in a case where reusing the vector is desirable. Implementing `DrainAll` in terms of `slice::IterMut` lets us reuse some nice optimizations in core for the case where T is a ZST. Signed-off-by: Alice Ryhl --- rust/kernel/alloc/kvec.rs | 60 +++++++++++++++++++++++++++++++++++++++++++= ++++ 1 file changed, 60 insertions(+) diff --git a/rust/kernel/alloc/kvec.rs b/rust/kernel/alloc/kvec.rs index 78a602e0f00494a52df0e0aa5eedc68967a3011e..72bc743ec88bf7b91a0a1ffd9f8= 30cfe4f983ffd 100644 --- a/rust/kernel/alloc/kvec.rs +++ b/rust/kernel/alloc/kvec.rs @@ -583,6 +583,31 @@ pub fn truncate(&mut self, len: usize) { unsafe { ptr::drop_in_place(ptr) }; } } + + /// Takes ownership of all items in this vector without consuming the = allocation. + /// + /// # Examples + /// + /// ``` + /// let mut v =3D kernel::kvec![0, 1, 2, 3]?; + /// + /// for (i, j) in v.drain_all().enumerate() { + /// assert_eq!(i, j); + /// } + /// + /// assert!(v.capacity() >=3D 4); + /// # Ok::<(), Error>(()) + /// ``` + pub fn drain_all(&mut self) -> DrainAll<'_, T> { + let len =3D self.len(); + // SAFETY: The length is not greater than the length. + let elems =3D unsafe { self.dec_len(len) }; + // INVARIANT: The first `len` elements of the spare capacity are v= alid values, and as we + // just set the length to zero, we may transfer ownership to the `= DrainAll` object. + DrainAll { + elements: elems.iter_mut(), + } + } } =20 impl Vec { @@ -1070,3 +1095,38 @@ fn into_iter(self) -> Self::IntoIter { } } } + +/// An iterator that owns all items in a vector, but does not own its allo= cation. +/// +/// # Invariants +/// +/// Every `&mut T` returned by the iterator references a `T` that the iter= ator may take ownership +/// of. +pub struct DrainAll<'vec, T> { + elements: slice::IterMut<'vec, T>, +} + +impl<'vec, T> Iterator for DrainAll<'vec, T> { + type Item =3D T; + + fn next(&mut self) -> Option { + let elem: *mut T =3D self.elements.next()?; + // SAFETY: By the type invariants, we may take ownership of this v= alue. + Some(unsafe { elem.read() }) + } + + fn size_hint(&self) -> (usize, Option) { + self.elements.size_hint() + } +} + +impl<'vec, T> Drop for DrainAll<'vec, T> { + fn drop(&mut self) { + if core::mem::needs_drop::() { + let iter =3D core::mem::take(&mut self.elements); + let ptr: *mut [T] =3D iter.into_slice(); + // SAFETY: By the type invariants, we own these values so we m= ay destroy them. + unsafe { ptr::drop_in_place(ptr) }; + } + } +} --=20 2.49.0.901.g37484f566f-goog From nobody Tue Feb 10 04:23:13 2026 Received: from mail-wr1-f73.google.com (mail-wr1-f73.google.com [209.85.221.73]) (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 9803C220696 for ; Tue, 29 Apr 2025 14:44:51 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.221.73 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745937893; cv=none; b=GeO/Ul02XoGIkftRaQ/06zJBivDlFF7SdBAk1PUa6cUkC6qq2UeepadayBLFyklrvapkzgmc7yfJm/6REkzZ0OW5VLGZ5v0K8e/rYAqoyOSAs+0Jj0niffnYcPsAegFpqAU5iKkkafg2rqnzNqeiWWzmPSe2mjqVITla5I8hQOs= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745937893; c=relaxed/simple; bh=AdpVzWf/iSEg4CY8RxM9JhdoOUZnrP3eK8KVcPmJkTc=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=fuqiS14bz6DAOJvqUJF0JN3x+IF92TqE4E/Bm3wgIzSSp3tjIbfAUv0g2rhgKffVwpS4GIxhLsd8Dbdd8uqzTLq1VIq7Fvql8ACwZzGmKwrYSSUVcmu1ViSoQdm3K7zNFTi4GvCUWQMG6TNWf9OIbbZI/CkWvkEQFb1DMb3oKRk= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--aliceryhl.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=n+mbkoiv; arc=none smtp.client-ip=209.85.221.73 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--aliceryhl.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="n+mbkoiv" Received: by mail-wr1-f73.google.com with SMTP id ffacd0b85a97d-39143311936so2081561f8f.0 for ; Tue, 29 Apr 2025 07:44:51 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1745937890; x=1746542690; 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=A42+m41OcL/e/spEAKjlneIVplUFFprYUT5iY2HFKbA=; b=n+mbkoiv74YrQS1sN2CZa3SZWiu1zJUL6NQ5VI960KOD83qBNs0/zoX30PwUjRkAwB uKQYH0Dy+e23r7sIp+PUig7KFCAc9XUa3+uOI3yaQgilSazbC7kabeuVGUvKnh7yeIuY 1VJvyq6FXPRraKnsu8DQNxwChTLglayfXkxnDH92bi2BXRx9ppOaejDei+ATjiA0ukY4 9U7tMRafO/YAD0bW/3FoVtj+lLOEQb9/a+bmNBzOdZ0eUDCcW8nAE1651zVcSwkBlRJM 4PEO3cYdWEmLG/e0IYBHwBkGLgugXLgXMLkcMd15zGG1CdjP1TVrMg+0q5saIXknufWx DoxQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1745937890; x=1746542690; 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=A42+m41OcL/e/spEAKjlneIVplUFFprYUT5iY2HFKbA=; b=KqV99cxywgHe3uIUHTnXMhDgL2ipjMH8kKTA8p/RTlSNdWilODr/9hsf+jMI8SlYUd zpHhawfLY9syBaEtZWW3K8mA706fmejOV0LPdanbtrv1o3TM0qQFDRbrc9UfHdKJ3RiV FQ7UiQFi5/UFxTZAiaQvX3Qe8G8Z0Gn8sqiKin5vJ0GCxJlBa4f9YTt5HXN6Bp0YRyyV B+bSe58WAz9943l15VopdWIB2tWJhhB0qWpEiS5DoArULIhqE/c2UhL5hfa6YliK6TtZ EfETbS+dsasJCM3CERZ5ZrWVjltBpC0JwdNThjsOmgGwVWs/+DkDC6vC5OMq7Dgk98zl ukCw== X-Forwarded-Encrypted: i=1; AJvYcCWyljdmjUGWpsB0qrWf5xEEmniHCB2Nq+8mLZKws3W0t/5xnxfQ4CxbuGXXvkArIj/7qJbpm0WwBRfohkc=@vger.kernel.org X-Gm-Message-State: AOJu0YwGUlktbJP/y+DqcaCCQu3pZl6nXjI6iwjZc5jQzfPTWg9UnKLM TVvNblfXF1zUXPkkHS32OrZTJaTQaESngZrUVhtuKuSlZVqVfeh8v5FC5Bvm10wmqLFSPeDRuBN DkUN5YVGrYr/htA== X-Google-Smtp-Source: AGHT+IHhJSK+7koiunSSzcCVzQ77aTvXG1iPV+Hp+spfU9/Yl4M6sM7CtYRYW/0JJQWitygkl9Q//K8CiNm8ifA= X-Received: from wmhu21.prod.google.com ([2002:a05:600c:a375:b0:43d:1f28:b8bf]) (user=aliceryhl job=prod-delivery.src-stubby-dispatcher) by 2002:a05:6000:18af:b0:39f:e50:af8 with SMTP id ffacd0b85a97d-3a08a35195emr2803148f8f.18.1745937890061; Tue, 29 Apr 2025 07:44:50 -0700 (PDT) Date: Tue, 29 Apr 2025 14:44:25 +0000 In-Reply-To: <20250429-vec-methods-v4-0-dad4436ff82d@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250429-vec-methods-v4-0-dad4436ff82d@google.com> X-Developer-Key: i=aliceryhl@google.com; a=openpgp; fpr=49F6C1FAA74960F43A5B86A1EE7A392FDE96209F X-Developer-Signature: v=1; a=openpgp-sha256; l=3500; i=aliceryhl@google.com; h=from:subject:message-id; bh=AdpVzWf/iSEg4CY8RxM9JhdoOUZnrP3eK8KVcPmJkTc=; b=owEBbQKS/ZANAwAKAQRYvu5YxjlGAcsmYgBoEOXSDpUMekv/1pyCb0+9ojAEvqMM9IZquOAtR FVfCW1aQ0eJAjMEAAEKAB0WIQSDkqKUTWQHCvFIvbIEWL7uWMY5RgUCaBDl0gAKCRAEWL7uWMY5 RmrtD/9sBsZBHn6oUzRnbNq/WOOtkd42Go6fbOgk4zEhQxOolpceVwPJahLf3cFklxRtwDqLFyt 3XgiDnwa24W6CoZTuIvf7AZtElX8yNyhKDuEGYooVhmmjZEZ4xu3x3o8LTdes7PPh0WJsArljfA dfNGUDyf/3qOybY/pHwdBTnlBqK0gkvEVyQC1LAF1jcPLOzEbLRrs299gJx2u5E8oqOubZc+MEf kZIMa1azekniBuEguuUo2VIvLUpVDPIqZiS+v2KQmn1Pqejvi7zLkXntK1XhSl7xHvnLKgkKHGS MrdoWoBzajGX5bhWS5/8u5gXXKdMwk596pEb+AXIFAARcCaVbMclNMTkNSJ7ivmiQM1JLw+qmyj ayueiOn2ZXkTzUJKkC+wFxcWsLRAoSXgs+JjUn4S02pIPwe0gu6IpwSEuEvb5sUZu1+GGmJ3dQ4 bWUdSeJQZonofi/Y07Q59X0CNCowXsop+88y5mTji/seKD+F8HUDHaspnz0aIONbFbtczK2ykao zOVPa6KXqmpmdDhP+uuegBSw39rukri/dbML+Yq895K8I6A8279k1gBpJXG3/g8x1SONOqMgCe9 +XCvout0xzhhvdmIB9b9rY2oeWjAN7EnOyuAl/74HyB0oyX6z6RbZbblEKaLOUaak3VOm2jYqmY CoHwQ9LbqVSi9pQ== X-Mailer: b4 0.14.2 Message-ID: <20250429-vec-methods-v4-5-dad4436ff82d@google.com> Subject: [PATCH v4 5/7] rust: alloc: add Vec::retain From: Alice Ryhl To: Danilo Krummrich Cc: Matthew Maurer , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, Alice Ryhl Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable This adds a common Vec method called `retain` that removes all elements that don't match a certain condition. Rust Binder uses it to find all processes that match a given pid. The stdlib retain method takes &T rather than &mut T and has a separate retain_mut for the &mut T case. However, this is considered an API mistake that can't be fixed now due to backwards compatibility. There's no reason for us to repeat that mistake. Signed-off-by: Alice Ryhl --- rust/kernel/alloc/kvec.rs | 72 +++++++++++++++++++++++++++++++++++++++++++= ++++ 1 file changed, 72 insertions(+) diff --git a/rust/kernel/alloc/kvec.rs b/rust/kernel/alloc/kvec.rs index 72bc743ec88bf7b91a0a1ffd9f830cfe4f983ffd..357f5a37c7b1d15b709a10c1622= 92841eed0e376 100644 --- a/rust/kernel/alloc/kvec.rs +++ b/rust/kernel/alloc/kvec.rs @@ -608,6 +608,29 @@ pub fn drain_all(&mut self) -> DrainAll<'_, T> { elements: elems.iter_mut(), } } + + /// Removes all elements that don't match the provided closure. + /// + /// # Examples + /// + /// ``` + /// let mut v =3D kernel::kvec![1, 2, 3, 4]?; + /// v.retain(|i| *i % 2 =3D=3D 0); + /// assert_eq!(v, [2, 4]); + /// # Ok::<(), Error>(()) + /// ``` + pub fn retain(&mut self, mut f: impl FnMut(&mut T) -> bool) { + let mut num_kept =3D 0; + let mut next_to_check =3D 0; + while let Some(to_check) =3D self.get_mut(next_to_check) { + if f(to_check) { + self.swap(num_kept, next_to_check); + num_kept +=3D 1; + } + next_to_check +=3D 1; + } + self.truncate(num_kept); + } } =20 impl Vec { @@ -1130,3 +1153,52 @@ fn drop(&mut self) { } } } + +#[macros::kunit_tests(rust_kvec_kunit)] +mod tests { + use super::*; + use crate::prelude::*; + + #[test] + fn test_kvec_retain() { + /// Verify correctness for one specific function. + #[expect(clippy::needless_range_loop)] + fn verify(c: &[bool]) { + let mut vec1: KVec =3D KVec::with_capacity(c.len(), GFP= _KERNEL).unwrap(); + let mut vec2: KVec =3D KVec::with_capacity(c.len(), GFP= _KERNEL).unwrap(); + + for i in 0..c.len() { + vec1.push_within_capacity(i).unwrap(); + if c[i] { + vec2.push_within_capacity(i).unwrap(); + } + } + + vec1.retain(|i| c[*i]); + + assert_eq!(vec1, vec2); + } + + /// Add one to a binary integer represented as a boolean array. + fn add(value: &mut [bool]) { + let mut carry =3D true; + for v in value { + let new_v =3D carry !=3D *v; + carry =3D carry && *v; + *v =3D new_v; + } + } + + // This boolean array represents a function from index to boolean.= We check that `retain` + // behaves correctly for all possible boolean arrays of every poss= ible length less than + // ten. + let mut func =3D KVec::with_capacity(10, GFP_KERNEL).unwrap(); + for len in 0..10 { + for _ in 0u32..1u32 << len { + verify(&func); + add(&mut func); + } + func.push_within_capacity(false).unwrap(); + } + } +} --=20 2.49.0.901.g37484f566f-goog From nobody Tue Feb 10 04:23:13 2026 Received: from mail-wm1-f73.google.com (mail-wm1-f73.google.com [209.85.128.73]) (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 761152206AB for ; Tue, 29 Apr 2025 14:44:53 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.73 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745937895; cv=none; b=Ugj5RaFgJlsV9RyQe0KstUv0yKik3YP1FhFmk/iQRhXsCVyvp33eZwWS6M5f4/6vfCJhJbHtAQbHWcXqDJMM/d+NEJXuAZqY9Q+j69CqMVDw6bbQnx///PvWh3HkPntSQLVTfWa0f7OPf01n7o/AqeuO7QCOBc3sp7RL12vFwOg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745937895; c=relaxed/simple; bh=qKzOcKApDQ3/WTq2wvyZxabH+Dt7na3cpwPeiFsPJhs=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=tROYq0QxW8WNrtTZw/EWviDhKRb/gOAYQhmqTMFJoe1dmBfN2orFkYn+xqpbiLR89LpYVnaVr4NijXBLbUPwyPVYw1cnu1drZneloEhAHzsydV7pmEHQCXBImRW62tLUAzsvqZ7Op/cw/NqwKhxKhvb11Vorjt/nP5a2x7B+EeU= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--aliceryhl.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=neaVFTSk; arc=none smtp.client-ip=209.85.128.73 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--aliceryhl.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="neaVFTSk" Received: by mail-wm1-f73.google.com with SMTP id 5b1f17b1804b1-43d00017e9dso34214735e9.0 for ; Tue, 29 Apr 2025 07:44:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1745937892; x=1746542692; 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=k3qwMBYZmHUsyj2Nk+6ObSDHgL4pbNZApkxHSNRkjQw=; b=neaVFTSkToD2VBt7XSDt1ZsfHfJXjMcAk8wOmfi5LIBmjSu9WLFoKpSFHXdTk43oUq Z2hWuGhy0pbfYjymL5jzCQ7SrUd9hwro4Qb8NSQEmjbIgnepFAH1p3XFdRxnsvylpY3Z HvVTY7HZv4YdptV53zmP5XBIdFnTD6ZWkruO7BAyCWFnRUtW3ATObrPJB474KnNJtxDu hQqEMiHKEUWaaB8VgrORT/sgQ8PEfm50Yt+41/u/SUnZBy+IqsxuSYFxPPvFmin46BO+ ymBNZ0cK5rU9KlQJep85jGA2eYQV1O9mPyDBFXZq83hLV7schAxLduXD4gbKyT5EPUW9 4h6Q== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1745937892; x=1746542692; 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=k3qwMBYZmHUsyj2Nk+6ObSDHgL4pbNZApkxHSNRkjQw=; b=KrLN7vGImj0Hfa8b3rG8U9XZPzoRmVaLAI2npuqBfflBMYCEyegF2E+F8woYeyCZon n8fKOh6Ei2t7hFoOZMHZTl8U6Bp/RIxaBTIdAdJxA9wJnpKLXytPJsrygIeOhMeBT3x+ vOGEKu0vNkXYfCpAS9xd13VxFTFgsEHELJRPBabGTHnkaDTntypSv336xZ6yrMBx/w5o EYm5/D2BoxrC9KBkylNApH55TScwKJQRqdr85drnBCaxgNdebhHDtaHzRzhdLi/ZeoOK eSP9Mwj7ngXFqzxM70jw7DowrOX+qYpdt2RPd5THHagpyGcIaNDTCMJUyAi65J9TFaai 6MFw== X-Forwarded-Encrypted: i=1; AJvYcCWfTRNiVmXHcslljS2PLDnwtIaEkp1xUjBgVRaS9M+W1cxDKVRWJfIIbOaYtMMF6tV7W3zVDRYXSgrlon0=@vger.kernel.org X-Gm-Message-State: AOJu0Yxg4SjQaV5XiuV901nvcBTbqzyWA6StuYVaA8ULorxiDP2LGWAP BPt038cZfYT4ROXLSaY472drbrRqv86J686eamYSsQvDl2RJVkc+f2J9gilX9YO2in+f24Xrnkl rDk1evL2RrRcBow== X-Google-Smtp-Source: AGHT+IF2aNX1fNGdZZZeLNAlTaCENgmErVSBtsB1SZiKmphy6/obRIVI+1aIV/UvMVpUUrZubjzW42YxgrxWvxk= X-Received: from wmbgw25.prod.google.com ([2002:a05:600c:8519:b0:440:59df:376a]) (user=aliceryhl job=prod-delivery.src-stubby-dispatcher) by 2002:a05:600c:a4c:b0:43d:7588:6687 with SMTP id 5b1f17b1804b1-441ad3b5c21mr32584045e9.12.1745937892219; Tue, 29 Apr 2025 07:44:52 -0700 (PDT) Date: Tue, 29 Apr 2025 14:44:26 +0000 In-Reply-To: <20250429-vec-methods-v4-0-dad4436ff82d@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250429-vec-methods-v4-0-dad4436ff82d@google.com> X-Developer-Key: i=aliceryhl@google.com; a=openpgp; fpr=49F6C1FAA74960F43A5B86A1EE7A392FDE96209F X-Developer-Signature: v=1; a=openpgp-sha256; l=2186; i=aliceryhl@google.com; h=from:subject:message-id; bh=qKzOcKApDQ3/WTq2wvyZxabH+Dt7na3cpwPeiFsPJhs=; b=owEBbQKS/ZANAwAKAQRYvu5YxjlGAcsmYgBoEOXT+A2THDjTmpUO+v5rehdFPXSy/pGAttWkA 7Z9Y/QtX9OJAjMEAAEKAB0WIQSDkqKUTWQHCvFIvbIEWL7uWMY5RgUCaBDl0wAKCRAEWL7uWMY5 RkHZEACzgHz49qQfBnO86qlMJR99vNVtvNkoh3Z7Gy8ZjJz5cqT3Qw+EnA9Himsww0udm8zRhue iTca1mnlEJ9b3/7QU8tE1sjCE79cAHC/IN04fMnsiTiyqJfYm/L73509w2eEFjGs2hVPCgfKK/p vgsLfC2Shi5FDo4SdhKZv60ol4M4fKCtGT5iKGVxJyh7rJYb+078zj2uP60xSHP7mKSyXvDvi50 56ulAeQkrgBqGPyWAWBCQX36HFMSH2hkZSEGUoIjIeJbgRk1lewKXvCM30p7DMP8Pe6CFQYkO9o BqqrdSnUaW0CNKPty69x0CDi/4So34INVRkZLLqxgSq5sCBgaPcj4YMdq2Kmc1fwdQth4I1xHkX H2BEUQQBmichuDL4r/x6I9Z4EnQXocovZXI7HXZyeHhyVsvqqdNXpOY9v0iUN0WsNDRtgXq90qV C9MLMqb5qlT/AXN6siornmJ6ZcI1AgjugKQu5pRu8XccbzcpWYIzPXO2M0cpaS92MazG/y+o4pX W/ELrhJu1TVAtqTN4pbnLTMWC90JkWlqGTTQN96EDITJD6OBl0/voBptXtOjboZ2r5zLexluWhC yGeZ3NkTfhwCuL3ZoahEAIjWknzo34xqTRmn/CDOKk40bfEy15tFJybODFDDbcc/zz/VcQIDW0a nFnGNUO0TUZPk9w== X-Mailer: b4 0.14.2 Message-ID: <20250429-vec-methods-v4-6-dad4436ff82d@google.com> Subject: [PATCH v4 6/7] rust: alloc: add Vec::remove From: Alice Ryhl To: Danilo Krummrich Cc: Matthew Maurer , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, Alice Ryhl Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable This is needed by Rust Binder in the range allocator, and by upcoming GPU drivers during firmware initialization. Signed-off-by: Alice Ryhl --- rust/kernel/alloc/kvec.rs | 36 ++++++++++++++++++++++++++++++++++++ 1 file changed, 36 insertions(+) diff --git a/rust/kernel/alloc/kvec.rs b/rust/kernel/alloc/kvec.rs index 357f5a37c7b1d15b709a10c162292841eed0e376..0682108951675cbee05faa130e5= a9ce72fc343ba 100644 --- a/rust/kernel/alloc/kvec.rs +++ b/rust/kernel/alloc/kvec.rs @@ -386,6 +386,42 @@ pub fn pop(&mut self) -> Option { Some(unsafe { removed.read() }) } =20 + /// Removes the element at the given index. + /// + /// # Panics + /// + /// Panics if the index is out of bounds. + /// + /// # Examples + /// + /// ``` + /// let mut v =3D kernel::kvec![1, 2, 3]?; + /// assert_eq!(v.remove(1), 2); + /// assert_eq!(v, [1, 3]); + /// # Ok::<(), Error>(()) + /// ``` + pub fn remove(&mut self, i: usize) -> T { + // INVARIANT: This breaks the invariants by invalidating the value= at index `i`, but we + // restore the invariants below. + // SAFETY: Since `&self[i]` did not result in a panic, the value a= t index `i` is valid. + let value =3D unsafe { ptr::read(&self[i]) }; + + // SAFETY: We checked that `i` is in-bounds. + let p =3D unsafe { self.as_mut_ptr().add(i) }; + + // INVARIANT: After this call, the invalid value is at the last sl= ot, so the Vec invariants + // are restored after the below call to `dec_len(1)`. + // SAFETY: `p.add(1).add(self.len - i - 1)` is `i+1+len-i-1 =3D=3D= len` elements after the + // beginning of the vector, so this is in-bounds of the vector's a= llocation. + unsafe { ptr::copy(p.add(1), p, self.len - i - 1) }; + + // SAFETY: Since the access at the beginning of this call did not = panic, the length is at + // least one. + unsafe { self.dec_len(1) }; + + value + } + /// Creates a new [`Vec`] instance with at least the given capacity. /// /// # Examples --=20 2.49.0.901.g37484f566f-goog From nobody Tue Feb 10 04:23:13 2026 Received: from mail-wm1-f74.google.com (mail-wm1-f74.google.com [209.85.128.74]) (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 809E5221568 for ; Tue, 29 Apr 2025 14:44:55 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=209.85.128.74 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745937897; cv=none; b=Sz5o9YHkt/GXeRCpxP2zNRsaJpwFSoMgtRlnTxgkU99plFIJ13KHjyUwN+Pr7KjaKZ+KxeuCPTqZNvkI2Ml+/XuXbEYslif+VqbyVvNgrf8251rodcGmODGBrhgBWPHTaC6Wq3QLTH9v0FfklbQxQSep8GAmvHphWdAP7TsAAlM= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1745937897; c=relaxed/simple; bh=lpvEgUX7rF9U71IW1suFe1v4Cuv24FiswYAVVSqnMAc=; h=Date:In-Reply-To:Mime-Version:References:Message-ID:Subject:From: To:Cc:Content-Type; b=QJzPSA5JhCvhp5ubl8DGocVwV9+lo4akny/GV9R1XMZlcZMFeIwNOnM3BuKSW42luiZ4nWtiHIRD9Z7jOyx/zZM2STpnpdESYyNk//NEi2xJ9szNcvEHaBw3ZheqvVeVK5JMfrhrQMB0bzCMN/GYIGbu8PJw7c+WaPq1bBr62Ic= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dmarc=pass (p=reject dis=none) header.from=google.com; spf=pass smtp.mailfrom=flex--aliceryhl.bounces.google.com; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b=tvlZDzz3; arc=none smtp.client-ip=209.85.128.74 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--aliceryhl.bounces.google.com Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=google.com header.i=@google.com header.b="tvlZDzz3" Received: by mail-wm1-f74.google.com with SMTP id 5b1f17b1804b1-43cf446681cso35947645e9.1 for ; Tue, 29 Apr 2025 07:44:55 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=20230601; t=1745937894; x=1746542694; 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=mv0mTLyyjWQP9SGntPKBVZR+DB04+FyoS2G+H2BmFJ0=; b=tvlZDzz3ukQ3vTg2SUon8s9Z0Cq5CruGNVGrep90WD5E94XrVyQExrHPIPIB+ZYZY0 ibzZ3OGuT6tPY+9yhS+XjsFSEM0uI5UPLMhAkz4EtG0WijxQ6XXAo1ix1Ax5Af+XZZNo OEURh2iNyiQctPIpQP/OwG6mSN7BMh0XQPgh2kgvsnywDRA5jWvj2IdTKw1s1W304YGE EcKgYaxCwVg3zyMvu12v2giTfxK53dT8dYdit5eIdR+S8GbEK4/YagjLjQnfRfigUKJp SPxjlWeazYSbDZeqlhulHtlrB9wOBXUEe4G/2USyZpoC3YUQZp9OLTCRFsaqQimZIGUT 7mXA== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20230601; t=1745937894; x=1746542694; 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=mv0mTLyyjWQP9SGntPKBVZR+DB04+FyoS2G+H2BmFJ0=; b=F1FSIT+i6Uv5XsFt1r1rIyqTV3VAphrJuUn/K4wLAz/PYFWgdM699Cm5N1dzfOv8cw 7cqf37XVsAzB14JbO+YW9bvH7hPiYfoyYWU6gUeiAMSp6B3FNtql8Efu/QonNV6R8Qy0 43wtX7PwKXDPO1k4Eq1fVm8P3Mem2SoGIg9J3jIu6kpBo4+pU/QD96HoXdpkSUxKQBzO 3FGTxyb725YHDaldAxZbGhS63NT6FNIdLN+pUSoOtKPusjc6VCLjPuwI2aDln524eTgq JqYXXEQ7qmQ584HvM/SpN2TlsVMF9IC07VfBDHrfR5UKrBxApYHft0F1JKaPQrTYA+fz SJGw== X-Forwarded-Encrypted: i=1; AJvYcCV7+YMhzj4zoXhUcl+CUTMw5YbfLdGrKFk8QgNrT+pWGJ+BKv/SVHMv4mftQ+mnyn2kfE2rEc5jRr9vJeQ=@vger.kernel.org X-Gm-Message-State: AOJu0YziHHb86tTN6cI4IsL4zmAKcO3dIPx2+ptfWyDgekO6ounun6h9 vvhQPBH3EoTkAPafyNsmGtyQqjArClxW4Zt08hc0g1Zs3YJ1wM6OEk+7mDdfk67o0MvE9gDqvyK yJJFRD/Vv8ro0Og== X-Google-Smtp-Source: AGHT+IHViXi3ljRbYG2m6vfiPDON6W7Vxy1R4JL3IYK+GjqIdY8+eCKx52Eukzwa6FjuinT7d/AtH+SSZ1gEPOU= X-Received: from wmbfk10.prod.google.com ([2002:a05:600c:cca:b0:43e:9aac:5a49]) (user=aliceryhl job=prod-delivery.src-stubby-dispatcher) by 2002:a05:600c:4e08:b0:43d:2313:7b4a with SMTP id 5b1f17b1804b1-441ac84f24fmr42492955e9.3.1745937894297; Tue, 29 Apr 2025 07:44:54 -0700 (PDT) Date: Tue, 29 Apr 2025 14:44:27 +0000 In-Reply-To: <20250429-vec-methods-v4-0-dad4436ff82d@google.com> Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: Mime-Version: 1.0 References: <20250429-vec-methods-v4-0-dad4436ff82d@google.com> X-Developer-Key: i=aliceryhl@google.com; a=openpgp; fpr=49F6C1FAA74960F43A5B86A1EE7A392FDE96209F X-Developer-Signature: v=1; a=openpgp-sha256; l=2514; i=aliceryhl@google.com; h=from:subject:message-id; bh=lpvEgUX7rF9U71IW1suFe1v4Cuv24FiswYAVVSqnMAc=; b=owEBbQKS/ZANAwAKAQRYvu5YxjlGAcsmYgBoEOXTRPhf6cCev8g4j060AgJ76gK1QzLdyxK0f 4YqZNhNs4KJAjMEAAEKAB0WIQSDkqKUTWQHCvFIvbIEWL7uWMY5RgUCaBDl0wAKCRAEWL7uWMY5 RvPkEACfBVeHtNA2xPFiTyRXzGAHM4EB6ppgpUbOQir5lqebvXV433YXljMDZUOsjjgXkGV91tO B7/80rZDUge3NIO9ZPmIPX3T1xnhkj6NSg9Er8Pg/0PsA2T7YtB1RIfpRS+uAULwFZIgZy/lTJD bjhnDqLgClNSJwE4Bs7xSTDLLmE+QKgrQ3Qiw8jySc7Q91Fk0huJ1A6OmlbK8GMgyXUTcPIJyrA 2iB2AF3EIyXWOBB1BDp2q381TbzW52YsqOCHYRJfWpqy0yodvcfZQ/In9qwiFetZu3vEs6JMOkj GGVRl7x80+6PZkSp8IDKl9AnGXCNbchpwjMsHDhiaG829+xBzqr0Z4Pn6LHefKlqO4+8JCBos3E DI++awdf37mmXB1xiNN81/D8BUrQ+9hCapWEkfv8uUdkRF80z+Z7fIidZWIQHkjKr4w7ApFEhV1 NDst3ZSWdnHIR1R60oMZE2WCfVuDnDLLFkjl6p7qptaRekVxWZvvnpg1wXqMkKB96HStclJBGBe SvTCqNRwWsoyObBspnMOXczcNmjz3W6uJarpVs3lUQM2cus/rZTNZkCTo7WTGDBmjq5mVkEsdbh nK9RjzpxKLhzLVsbMey+LoAwaH35y7vCU82N3BCxs10ajv/ailknDcaWt/8XTUEzA5lKmQeLoc0 1waSih/EtTefziQ== X-Mailer: b4 0.14.2 Message-ID: <20250429-vec-methods-v4-7-dad4436ff82d@google.com> Subject: [PATCH v4 7/7] rust: alloc: add Vec::insert_within_capacity From: Alice Ryhl To: Danilo Krummrich Cc: Matthew Maurer , rust-for-linux@vger.kernel.org, linux-kernel@vger.kernel.org, Alice Ryhl Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable This adds a variant of Vec::insert that does not allocate memory. This makes it safe to use this function while holding a spinlock. Rust Binder uses it for the range allocator fast path. Signed-off-by: Alice Ryhl --- rust/kernel/alloc/kvec.rs | 39 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 39 insertions(+) diff --git a/rust/kernel/alloc/kvec.rs b/rust/kernel/alloc/kvec.rs index 0682108951675cbee05faa130e5a9ce72fc343ba..998afdcde47bec94b2c9d990ba3= afbb3488ea99e 100644 --- a/rust/kernel/alloc/kvec.rs +++ b/rust/kernel/alloc/kvec.rs @@ -355,6 +355,45 @@ pub unsafe fn push_within_capacity_unchecked(&mut self= , v: T) { unsafe { self.inc_len(1) }; } =20 + /// Inserts an element at the given index in the [`Vec`] instance. + /// + /// Fails if the vector does not have capacity for the new element. Pa= nics if the index is out + /// of bounds. + /// + /// # Examples + /// + /// ``` + /// let mut v =3D KVec::with_capacity(10, GFP_KERNEL)?; + /// for i in 0..10 { + /// v.push_within_capacity(i).unwrap(); + /// } + /// + /// assert!(v.push_within_capacity(10).is_err()); + /// # Ok::<(), Error>(()) + /// ``` + pub fn insert_within_capacity(&mut self, index: usize, element: T) -> = Result<(), T> { + let len =3D self.len(); + assert!(index <=3D len); + + if len >=3D self.capacity() { + return Err(element); + } + + // SAFETY: This is in bounds since `index <=3D len < capacity`. + let p =3D unsafe { self.as_mut_ptr().add(index) }; + // INVARIANT: This breaks the Vec invariants by making `index` con= tain an invalid element, + // but we restore the invariants below. + // SAFETY: Both the src and dst ranges end no later than one eleme= nt after the length. + // Since the length is less than the capacity, both ranges are in = bounds of the allocation. + unsafe { ptr::copy(p, p.add(1), len - index) }; + // INVARIANT: This restores the Vec invariants. + // SAFETY: The pointer is in-bounds of the allocation. + unsafe { ptr::write(p, element) }; + // SAFETY: Index `len` contains a valid element due to the above c= opy and write. + unsafe { self.inc_len(1) }; + Ok(()) + } + /// Removes the last element from a vector and returns it, or `None` i= f it is empty. /// /// # Examples --=20 2.49.0.901.g37484f566f-goog