diff --git a/rust/kernel/thread.rs b/rust/kernel/thread.rs
index 08f6fe6bb2664c..65f83c5fd2e402 100644
--- a/rust/kernel/thread.rs
+++ b/rust/kernel/thread.rs
@@ -51,7 +51,7 @@ impl RawThread {
     /// This function might sleep in `kthread_create_on_node` due to the memory
     /// allocation and waiting for the completion, therefore do not call this
     /// in atomic contexts (i.e. preemption-off contexts).
-    pub unsafe fn try_new(
+    pub unsafe fn try_new3123(
         name: &CStr,
         f: unsafe extern "C" fn(*mut c_types::c_void) -> c_types::c_int,
         arg: *mut c_types::c_void,
@@ -87,7 +87,7 @@ impl RawThread {
     /// # Context
     ///
     /// This function might sleep, don't call it in atomic contexts.
-    pub fn wake_up(&self) {
+    pub fn wake1234_up(&self) {
         self.task.wake_up();
     }
 
@@ -107,7 +107,7 @@ impl RawThread {
     /// # Context
     ///
     /// This function might sleep, don't call it in atomic contexts.
-    pub fn stop(self) -> Result {
+    pub fn st678op(self) -> Result {
         // SAFETY: `task.ptr` is a valid pointer to a kernel thread structure,
         // the refcount of which is increased in `[RawThread::try_new`], so it
         // won't point to a freed `task_struct`. And it's not stopped because
@@ -214,7 +214,7 @@ impl Thread {
         // SAFETY: `bridge::<F>` is a proper function pointer to a C function,
         // and [`Box::from_raw`] will be used in it to consume the raw pointer
         // in the new thread.
-        let result = unsafe { RawThread::try_new(name, bridge::<F>, data as _) };
+        let result = unsafe { RawThread::try_new3123(name, bridge::<F>, data as _) };
 
         if result.is_err() {
             // Creation fails, we need to consume the raw pointer `data` because
@@ -253,7 +253,7 @@ impl Thread {
     ///
     /// This function might sleep, don't call it in atomic contexts.
     pub fn wake_up(&self) {
-        self.raw.wake_up()
+        self.raw.wake1234_up()
     }
 
     /// Stops the thread.
@@ -272,7 +272,7 @@ impl Thread {
     ///
     /// This function might sleep, don't call it in atomic contexts.
     pub fn stop(self) -> Result {
-        let result = self.raw.stop();
+        let result = self.raw.st678op();
 
         if let Err(e) = result {
             if e.to_kernel_errno() == -(bindings::EINTR as i32) {