rust: fix English typos found by checkpatch.pl

Signed-off-by: Miguel Ojeda <[email protected]>

Author: ojeda

drivers/android/process.rs

@@ -287,12 +287,12 @@ impl Process {
         Ok(process.into())
     }
 
-    /// Attemps to fetch a work item from the process queue.
+    /// Attempts to fetch a work item from the process queue.
     pub(crate) fn get_work(&self) -> Option<Ref<dyn DeliverToRead>> {
         self.inner.lock().work.pop_front()
     }
 
-    /// Attemps to fetch a work item from the process queue. If none is available, it registers the
+    /// Attempts to fetch a work item from the process queue. If none is available, it registers the
     /// given thread as ready to receive work directly.
     ///
     /// This must only be called when the thread is not participating in a transaction chain; when

drivers/android/thread.rs

@@ -245,7 +245,7 @@ impl Thread {
             process,
             // SAFETY: `inner` is initialised in the call to `spinlock_init` below.
             inner: unsafe { SpinLock::new(InnerThread::new()) },
-            // SAFETY: `work_condvar` is initalised in the call to `condvar_init` below.
+            // SAFETY: `work_condvar` is initialised in the call to `condvar_init` below.
             work_condvar: unsafe { CondVar::new() },
             links: Links::new(),
         })?);

rust/kernel/amba.rs

@@ -77,7 +77,7 @@ impl<T: Driver> driver::DriverOps for Adapter<T> {
         name: &'static CStr,
         module: &'static ThisModule,
     ) -> Result {
-        // SAFETY: By the safety requirements of this function (defined in the trait defintion),
+        // SAFETY: By the safety requirements of this function (defined in the trait definition),
         // `reg` is non-null and valid.
         let amba = unsafe { &mut *reg };
         amba.drv.name = name.as_char_ptr();

rust/kernel/clk.rs

@@ -47,7 +47,7 @@ impl Drop for Clk {
     }
 }
 
-// SAFETY: `Clk` is not restricted to a single thread so it it safe
+// SAFETY: `Clk` is not restricted to a single thread so it is safe
 // to move it between threads.
 unsafe impl Send for Clk {}
 

rust/kernel/lib.rs

@@ -178,7 +178,7 @@ pub struct KParamGuard<'a> {
 impl<'a> Drop for KParamGuard<'a> {
     fn drop(&mut self) {
         // SAFETY: `kernel_param_lock` will check if the pointer is null and
-        // use the built-in mutex in that case. The existance of `self`
+        // use the built-in mutex in that case. The existence of `self`
         // guarantees that the lock is held.
         unsafe { bindings::kernel_param_unlock(self.this_module.0) }
     }

rust/kernel/module_param.rs

@@ -118,7 +118,7 @@ pub trait ModuleParam: core::fmt::Display + core::marker::Sized {
 
 /// Trait for parsing integers.
 ///
-/// Strings begining with `0x`, `0o`, or `0b` are parsed as hex, octal, or
+/// Strings beginning with `0x`, `0o`, or `0b` are parsed as hex, octal, or
 /// binary respectively. Strings beginning with `0` otherwise are parsed as
 /// octal. Anything else is parsed as decimal. A leading `+` or `-` is also
 /// permitted. Any string parsed by [`kstrtol()`] or [`kstrtoul()`] will be

rust/kernel/pages.rs

@@ -79,7 +79,7 @@ impl<const ORDER: u32> Pages<ORDER> {
         Ok(())
     }
 
-    /// Maps the pages and writes into them from the given bufer.
+    /// Maps the pages and writes into them from the given buffer.
     ///
     /// # Safety
     ///

rust/kernel/platform.rs

@@ -32,7 +32,7 @@ impl<T: Driver> driver::DriverOps for Adapter<T> {
         name: &'static CStr,
         module: &'static ThisModule,
     ) -> Result {
-        // SAFETY: By the safety requirements of this function (defined in the trait defintion),
+        // SAFETY: By the safety requirements of this function (defined in the trait definition),
         // `reg` is non-null and valid.
         let pdrv = unsafe { &mut *reg };
 

rust/kernel/sync/guard.rs

@@ -94,7 +94,7 @@ impl LockInfo for WriteLock {
 ///   may access the protected data once the lock is held, that is, between calls to `lock_noguard`
 ///   and `unlock`.
 /// - Implementers of all other markers must ensure that a mutable reference to the protected data
-///   is not active in any thread/CPU because at least one shared refence is active between calls
+///   is not active in any thread/CPU because at least one shared reference is active between calls
 ///   to `lock_noguard` and `unlock`.
 pub unsafe trait Lock<I: LockInfo = WriteLock> {
     /// The type of the data protected by the lock.

rust/kernel/sync/revocable.rs

@@ -1,6 +1,6 @@
 // SPDX-License-Identifier: GPL-2.0
 
-//! Synchronisation primitives where acccess to their contents can be revoked at runtime.
+//! Synchronisation primitives where access to their contents can be revoked at runtime.
 
 use crate::{
     bindings,