Kernel: Use the templated copy_to/from_user() in more places

These ensure that the "to" and "from" pointers have the same type,
and also that we copy the correct number of bytes.

Kernel/Process.cpp

@@ -1783,7 +1783,7 @@ int Process::sys$lstat(const char* user_path, size_t path_length, stat* user_sta
     auto result = metadata_or_error.value().stat(statbuf);
     if (result.is_error())
         return result;
-    copy_to_user(user_statbuf, &statbuf, sizeof(statbuf));
+    copy_to_user(user_statbuf, &statbuf);
     return 0;
 }
 
@@ -1802,7 +1802,7 @@ int Process::sys$stat(const char* user_path, size_t path_length, stat* user_stat
     auto result = metadata_or_error.value().stat(statbuf);
     if (result.is_error())
         return result;
-    copy_to_user(user_statbuf, &statbuf, sizeof(statbuf));
+    copy_to_user(user_statbuf, &statbuf);
     return 0;
 }
 
@@ -2003,12 +2003,12 @@ int Process::sys$pipe(int pipefd[2], int flags)
     int reader_fd = alloc_fd();
     m_fds[reader_fd].set(fifo->open_direction(FIFO::Direction::Reader), fd_flags);
     m_fds[reader_fd].description->set_readable(true);
-    copy_to_user(&pipefd[0], &reader_fd, sizeof(reader_fd));
+    copy_to_user(&pipefd[0], &reader_fd);
 
     int writer_fd = alloc_fd();
     m_fds[writer_fd].set(fifo->open_direction(FIFO::Direction::Writer), fd_flags);
     m_fds[writer_fd].description->set_writable(true);
-    copy_to_user(&pipefd[1], &writer_fd, sizeof(writer_fd));
+    copy_to_user(&pipefd[1], &writer_fd);
 
     return 0;
 }
@@ -2333,7 +2333,7 @@ pid_t Process::sys$waitpid(pid_t waitee, int* wstatus, int options)
     }
 
     if (wstatus)
-        copy_to_user(wstatus, &exit_status, sizeof(exit_status));
+        copy_to_user(wstatus, &exit_status);
     return waitee_pid;
 }
 
@@ -2517,7 +2517,7 @@ int Process::sys$sigprocmask(int how, const sigset_t* set, sigset_t* old_set)
     if (old_set) {
         if (!validate_write_typed(old_set))
             return -EFAULT;
-        copy_to_user(old_set, &current->m_signal_mask, sizeof(current->m_signal_mask));
+        copy_to_user(old_set, &current->m_signal_mask);
     }
     if (set) {
         if (!validate_read_typed(set))
@@ -2546,7 +2546,7 @@ int Process::sys$sigpending(sigset_t* set)
     REQUIRE_PROMISE(stdio);
     if (!validate_write_typed(set))
         return -EFAULT;
-    copy_to_user(set, &current->m_pending_signals, sizeof(current->m_pending_signals));
+    copy_to_user(set, &current->m_pending_signals);
     return 0;
 }
 
@@ -2562,11 +2562,11 @@ int Process::sys$sigaction(int signum, const sigaction* act, sigaction* old_act)
     if (old_act) {
         if (!validate_write_typed(old_act))
             return -EFAULT;
-        copy_to_user(&old_act->sa_flags, &action.flags, sizeof(action.flags));
+        copy_to_user(&old_act->sa_flags, &action.flags);
         copy_to_user(&old_act->sa_sigaction, &action.handler_or_sigaction, sizeof(action.handler_or_sigaction));
     }
     copy_from_user(&action.flags, &act->sa_flags);
-    copy_from_user(&action.handler_or_sigaction, &act->sa_sigaction, sizeof(action.flags));
+    copy_from_user(&action.handler_or_sigaction, &act->sa_sigaction, sizeof(action.handler_or_sigaction));
     return 0;
 }
 
@@ -2649,10 +2649,10 @@ clock_t Process::sys$times(tms* times)
     REQUIRE_PROMISE(stdio);
     if (!validate_write_typed(times))
         return -EFAULT;
-    copy_to_user(&times->tms_utime, &m_ticks_in_user, sizeof(m_ticks_in_user));
-    copy_to_user(&times->tms_stime, &m_ticks_in_kernel, sizeof(m_ticks_in_kernel));
-    copy_to_user(&times->tms_cutime, &m_ticks_in_user_for_dead_children, sizeof(m_ticks_in_user_for_dead_children));
-    copy_to_user(&times->tms_cstime, &m_ticks_in_kernel_for_dead_children, sizeof(m_ticks_in_kernel_for_dead_children));
+    copy_to_user(&times->tms_utime, &m_ticks_in_user);
+    copy_to_user(&times->tms_stime, &m_ticks_in_kernel);
+    copy_to_user(&times->tms_cutime, &m_ticks_in_user_for_dead_children);
+    copy_to_user(&times->tms_cstime, &m_ticks_in_kernel_for_dead_children);
     return g_uptime & 0x7fffffff;
 }
 
@@ -3297,7 +3297,7 @@ int Process::sys$sched_setparam(pid_t pid, const struct sched_param* param)
         return -EFAULT;
 
     int desired_priority;
-    copy_from_user(&desired_priority, &param->sched_priority, sizeof(desired_priority));
+    copy_from_user(&desired_priority, &param->sched_priority);
 
     InterruptDisabler disabler;
     auto* peer = this;
@@ -3336,7 +3336,7 @@ int Process::sys$sched_getparam(pid_t pid, struct sched_param* param)
 
     // FIXME: This doesn't seem like the way to get the right thread!
     int priority = peer->any_thread().priority();
-    copy_to_user(&param->sched_priority, &priority, sizeof(priority));
+    copy_to_user(&param->sched_priority, &priority);
     return 0;
 }
 
@@ -3708,7 +3708,7 @@ int Process::sys$join_thread(int tid, void** exit_value)
     thread = nullptr;
 
     if (exit_value)
-        copy_to_user(exit_value, &joinee_exit_value, sizeof(joinee_exit_value));
+        copy_to_user(exit_value, &joinee_exit_value);
     return 0;
 }
 

Kernel/Thread.cpp

@@ -459,7 +459,7 @@ bool Thread::has_signal_handler(u8 signal) const
 static void push_value_on_user_stack(u32* stack, u32 data)
 {
     *stack -= 4;
-    copy_to_user((u32*)*stack, &data, sizeof(u32));
+    copy_to_user((u32*)*stack, &data);
 }
 
 ShouldUnblockThread Thread::dispatch_signal(u8 signal)
@@ -601,11 +601,11 @@ void Thread::set_default_signal_dispositions()
     m_signal_action_data[SIGWINCH].handler_or_sigaction = VirtualAddress(SIG_IGN);
 }
 
-void Thread::push_value_on_stack(u32 value)
+void Thread::push_value_on_stack(uintptr_t value)
 {
     m_tss.esp -= 4;
-    u32* stack_ptr = (u32*)m_tss.esp;
-    copy_to_user(stack_ptr, &value, sizeof(value));
+    uintptr_t* stack_ptr = (uintptr_t*)m_tss.esp;
+    copy_to_user(stack_ptr, &value);
 }
 
 RegisterDump& Thread::get_register_dump_from_stack()

Kernel/Thread.h

@@ -365,7 +365,7 @@ public:
     FPUState& fpu_state() { return *m_fpu_state; }
 
     void set_default_signal_dispositions();
-    void push_value_on_stack(u32);
+    void push_value_on_stack(uintptr_t);
 
     u32 make_userspace_stack_for_main_thread(Vector<String> arguments, Vector<String> environment);