Received-SPF: pass (google.com: domain of linux-kernel+bounces-29606-linux.lists.archive=gmail.com@vger.kernel.org designates 147.75.80.249 as permitted sender) client-ip=147.75.80.249;
Precedence: bulk
MIME-Version: 1.0
References: <20240116160141.165951-1-kernel@valentinobst.de> <20240116220634.168103-1-kernel@valentinobst.de>
In-Reply-To: <20240116220634.168103-1-kernel@valentinobst.de>
From: Trevor Gross <tmgross@umich.edu>
Date: Wed, 17 Jan 2024 20:05:55 -0500
Message-ID: <CALNs47sqzqWzE-5srCq7_ePVx3HGaJ9EkwGbbFnqH9xCJXDByw@mail.gmail.com>
Subject: Re: [PATCH 07/13] rust: kernel: unify spelling of refcount in docs
To: Valentin Obst <kernel@valentinobst.de>
Cc: Miguel Ojeda <ojeda@kernel.org>, Alex Gaynor <alex.gaynor@gmail.com>, 
	Wedson Almeida Filho <wedsonaf@gmail.com>, Boqun Feng <boqun.feng@gmail.com>, Gary Guo <gary@garyguo.net>, 
	=?UTF-8?Q?Bj=C3=B6rn_Roy_Baron?= <bjorn3_gh@protonmail.com>, 
	Benno Lossin <benno.lossin@proton.me>, Andreas Hindborg <a.hindborg@samsung.com>, 
	Alice Ryhl <aliceryhl@google.com>, rust-for-linux@vger.kernel.org, 
	linux-kernel@vger.kernel.org
Content-Type: text/plain; charset="UTF-8"
Content-Transfer-Encoding: quoted-printable

On Tue, Jan 16, 2024 at 5:37=E2=80=AFPM Valentin Obst <kernel@valentinobst.=
de> wrote:
>
> Replace instances of 'ref-count[ed]' with 'refcount[ed]' to increase
> consistency within the Rust documentation. The latter form is used more
> widely in the rest of the kernel:
>
> ```console
> $ rg '(\*|//).*?\srefcount(|ed)[\s,.]' | wc -l
> 1605
> $ rg '(\*|//).*?\sref-count(|ed)[\s,.]' | wc -l
> 43
> ```
>
> (numbers are for Commit 052d534373b7)
>
> Signed-off-by: Valentin Obst <kernel@valentinobst.de>
> ---
>  rust/kernel/sync/arc.rs | 8 ++++----
>  rust/kernel/task.rs     | 4 ++--
>  2 files changed, 6 insertions(+), 6 deletions(-)
>
> diff --git a/rust/kernel/sync/arc.rs b/rust/kernel/sync/arc.rs
> index 77cdbcf7bd2e..6c46b1affca5 100644
> --- a/rust/kernel/sync/arc.rs
> +++ b/rust/kernel/sync/arc.rs
> @@ -56,7 +56,7 @@
>  ///     b: u32,
>  /// }
>  ///
> -/// // Create a ref-counted instance of `Example`.
> +/// // Create a refcounted instance of `Example`.
>  /// let obj =3D Arc::try_new(Example { a: 10, b: 20 })?;
>  ///
>  /// // Get a new pointer to `obj` and increment the refcount.
> @@ -510,7 +510,7 @@ fn deref(&self) -> &Self::Target {
>  /// # test().unwrap();
>  /// ```
>  ///
> -/// In the following example we first allocate memory for a ref-counted =
`Example` but we don't
> +/// In the following example we first allocate memory for a refcounted `=
Example` but we don't
>  /// initialise it on allocation. We do initialise it later with a call t=
o [`UniqueArc::write`],
>  /// followed by a conversion to `Arc<Example>`. This is particularly use=
ful when allocation happens
>  /// in one context (e.g., sleepable) and initialisation in another (e.g.=
, atomic):
> @@ -560,7 +560,7 @@ impl<T> UniqueArc<T> {
>      /// Tries to allocate a new [`UniqueArc`] instance.
>      pub fn try_new(value: T) -> Result<Self, AllocError> {
>          Ok(Self {
> -            // INVARIANT: The newly-created object has a ref-count of 1.
> +            // INVARIANT: The newly-created object has a refcount of 1.
>              inner: Arc::try_new(value)?,
>          })
>      }
> @@ -574,7 +574,7 @@ pub fn try_new_uninit() -> Result<UniqueArc<MaybeUnin=
it<T>>, AllocError> {
>              data <- init::uninit::<T, AllocError>(),
>          }? AllocError))?;
>          Ok(UniqueArc {
> -            // INVARIANT: The newly-created object has a ref-count of 1.
> +            // INVARIANT: The newly-created object has a refcount of 1.
>              // SAFETY: The pointer from the `Box` is valid.
>              inner: unsafe { Arc::from_inner(Box::leak(inner).into()) },
>          })
> diff --git a/rust/kernel/task.rs b/rust/kernel/task.rs
> index 9451932d5d86..818ac51b06b6 100644
> --- a/rust/kernel/task.rs
> +++ b/rust/kernel/task.rs
> @@ -23,7 +23,7 @@ macro_rules! current {
>  ///
>  /// All instances are valid tasks created by the C portion of the kernel=
.
>  ///
> -/// Instances of this type are always ref-counted, that is, a call to `g=
et_task_struct` ensures
> +/// Instances of this type are always refcounted, that is, a call to `ge=
t_task_struct` ensures
>  /// that the allocation remains valid at least until the matching call t=
o `put_task_struct`.
>  ///
>  /// # Examples
> @@ -147,7 +147,7 @@ pub fn wake_up(&self) {
>      }
>  }
>
> -// SAFETY: The type invariants guarantee that `Task` is always ref-count=
ed.
> +// SAFETY: The type invariants guarantee that `Task` is always refcounte=
d.
>  unsafe impl crate::types::AlwaysRefCounted for Task {
>      fn inc_ref(&self) {
>          // SAFETY: The existence of a shared reference means that the re=
fcount is nonzero.
> --
> 2.43.0
>

Reviewed-by: Trevor Gross <tmgross@umich.edu>