1 files changed, 47 insertions, 63 deletions

diff --git a/arch/um/kernel/process.c b/arch/um/kernel/process.c
index d3b9c62e73c7..7c037fa9c5b8 100644
--- a/arch/um/kernel/process.c
+++ b/arch/um/kernel/process.c
@@ -1,51 +1,29 @@
 /*
- * Copyright (C) 2000, 2001, 2002 Jeff Dike (jdike@karaya.com)
+ * Copyright (C) 2000 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Copyright 2003 PathScale, Inc.
  * Licensed under the GPL
  */
 
-#include "linux/kernel.h"
-#include "linux/sched.h"
-#include "linux/interrupt.h"
-#include "linux/string.h"
+#include "linux/stddef.h"
+#include "linux/err.h"
+#include "linux/hardirq.h"
 #include "linux/mm.h"
-#include "linux/slab.h"
-#include "linux/utsname.h"
-#include "linux/fs.h"
-#include "linux/utime.h"
-#include "linux/smp_lock.h"
-#include "linux/module.h"
-#include "linux/init.h"
-#include "linux/capability.h"
-#include "linux/vmalloc.h"
-#include "linux/spinlock.h"
+#include "linux/personality.h"
 #include "linux/proc_fs.h"
 #include "linux/ptrace.h"
 #include "linux/random.h"
-#include "linux/personality.h"
-#include "asm/unistd.h"
-#include "asm/mman.h"
-#include "asm/segment.h"
-#include "asm/stat.h"
+#include "linux/sched.h"
+#include "linux/threads.h"
 #include "asm/pgtable.h"
-#include "asm/processor.h"
-#include "asm/tlbflush.h"
 #include "asm/uaccess.h"
-#include "asm/user.h"
-#include "kern_util.h"
 #include "as-layout.h"
-#include "kern.h"
-#include "signal_kern.h"
-#include "init.h"
-#include "irq_user.h"
-#include "mem_user.h"
-#include "tlb.h"
-#include "frame_kern.h"
-#include "sigcontext.h"
+#include "kern_util.h"
 #include "os.h"
 #include "skas.h"
+#include "tlb.h"
 
-/* This is a per-cpu array.  A processor only modifies its entry and it only
+/*
+ * This is a per-cpu array.  A processor only modifies its entry and it only
  * cares about its entry, so it's OK if another processor is modifying its
  * entry.
  */
@@ -54,15 +32,15 @@ struct cpu_task cpu_tasks[NR_CPUS] = { [0 ... NR_CPUS - 1] = { -1, NULL } };
 static inline int external_pid(struct task_struct *task)
 {
         /* FIXME: Need to look up userspace_pid by cpu */
-        return(userspace_pid[0]);
+        return userspace_pid[0];
 }
 
 int pid_to_processor_id(int pid)
 {
         int i;
 
-        for(i = 0; i < ncpus; i++){
-                if(cpu_tasks[i].pid == pid)
+        for(i = 0; i < ncpus; i++) {
+                if (cpu_tasks[i].pid == pid)
                         return i;
         }
         return -1;
@@ -118,7 +96,7 @@ void *_switch_to(void *prev, void *next, void *last)
                 current->thread.saved_task = NULL;
 
                 /* XXX need to check runqueues[cpu].idle */
-                if(current->pid == 0)
+                if (current->pid == 0)
                         switch_timers(0);
 
                 switch_threads(&from->thread.switch_buf,
@@ -126,10 +104,10 @@ void *_switch_to(void *prev, void *next, void *last)
 
                 arch_switch_to(current->thread.prev_sched, current);
 
-                if(current->pid == 0)
+                if (current->pid == 0)
                         switch_timers(1);
 
-                if(current->thread.saved_task)
+                if (current->thread.saved_task)
                         show_regs(&(current->thread.regs));
                 next= current->thread.saved_task;
                 prev= current;
@@ -141,9 +119,9 @@ void *_switch_to(void *prev, void *next, void *last)
 
 void interrupt_end(void)
 {
-        if(need_resched())
+        if (need_resched())
                 schedule();
-        if(test_tsk_thread_flag(current, TIF_SIGPENDING))
+        if (test_tsk_thread_flag(current, TIF_SIGPENDING))
                 do_signal();
 }
 
@@ -158,7 +136,8 @@ void *get_current(void)
 
 extern void schedule_tail(struct task_struct *prev);
 
-/* This is called magically, by its address being stuffed in a jmp_buf
+/*
+ * This is called magically, by its address being stuffed in a jmp_buf
  * and being longjmp-d to.
  */
 void new_thread_handler(void)
@@ -166,18 +145,19 @@ void new_thread_handler(void)
         int (*fn)(void *), n;
         void *arg;
 
-        if(current->thread.prev_sched != NULL)
+        if (current->thread.prev_sched != NULL)
                 schedule_tail(current->thread.prev_sched);
         current->thread.prev_sched = NULL;
 
         fn = current->thread.request.u.thread.proc;
         arg = current->thread.request.u.thread.arg;
 
-        /* The return value is 1 if the kernel thread execs a process,
+        /*
+         * The return value is 1 if the kernel thread execs a process,
          * 0 if it just exits
          */
         n = run_kernel_thread(fn, arg, &current->thread.exec_buf);
-        if(n == 1){
+        if (n == 1) {
                 /* Handle any immediate reschedules or signals */
                 interrupt_end();
                 userspace(&current->thread.regs.regs);
@@ -189,14 +169,16 @@ void new_thread_handler(void)
 void fork_handler(void)
 {
         force_flush_all();
-        if(current->thread.prev_sched == NULL)
+        if (current->thread.prev_sched == NULL)
                 panic("blech");
 
         schedule_tail(current->thread.prev_sched);
 
-        /* XXX: if interrupt_end() calls schedule, this call to
+        /*
+         * XXX: if interrupt_end() calls schedule, this call to
          * arch_switch_to isn't needed. We could want to apply this to
-         * improve performance. -bb */
+         * improve performance. -bb
+         */
         arch_switch_to(current->thread.prev_sched, current);
 
         current->thread.prev_sched = NULL;
@@ -216,11 +198,11 @@ int copy_thread(int nr, unsigned long clone_flags, unsigned long sp,
 
         p->thread = (struct thread_struct) INIT_THREAD;
 
-        if(current->thread.forking){
+        if (current->thread.forking) {
                 memcpy(&p->thread.regs.regs, &regs->regs,
                        sizeof(p->thread.regs.regs));
                 REGS_SET_SYSCALL_RETURN(p->thread.regs.regs.regs, 0);
-                if(sp != 0)
+                if (sp != 0)
                         REGS_SP(p->thread.regs.regs.regs) = sp;
 
                 handler = fork_handler;
@@ -259,14 +241,14 @@ void initial_thread_cb(void (*proc)(void *), void *arg)
 
 void default_idle(void)
 {
-        while(1){
+        while(1) {
                 /* endless idle loop with no priority at all */
 
                 /*
                  * although we are an idle CPU, we do not want to
                  * get into the scheduler unnecessarily.
                  */
-                if(need_resched())
+                if (need_resched())
                         schedule();
 
                 idle_sleep(10);
@@ -288,26 +270,26 @@ void *um_virt_to_phys(struct task_struct *task, unsigned long addr,
         pte_t *pte;
         pte_t ptent;
 
-        if(task->mm == NULL)
+        if (task->mm == NULL)
                 return ERR_PTR(-EINVAL);
         pgd = pgd_offset(task->mm, addr);
-        if(!pgd_present(*pgd))
+        if (!pgd_present(*pgd))
                 return ERR_PTR(-EINVAL);
 
         pud = pud_offset(pgd, addr);
-        if(!pud_present(*pud))
+        if (!pud_present(*pud))
                 return ERR_PTR(-EINVAL);
 
         pmd = pmd_offset(pud, addr);
-        if(!pmd_present(*pmd))
+        if (!pmd_present(*pmd))
                 return ERR_PTR(-EINVAL);
 
         pte = pte_offset_kernel(pmd, addr);
         ptent = *pte;
-        if(!pte_present(ptent))
+        if (!pte_present(ptent))
                 return ERR_PTR(-EINVAL);
 
-        if(pte_out != NULL)
+        if (pte_out != NULL)
                 *pte_out = ptent;
         return (void *) (pte_val(ptent) & PAGE_MASK) + (addr & ~PAGE_MASK);
 }
@@ -380,7 +362,7 @@ int smp_sigio_handler(void)
 #ifdef CONFIG_SMP
         int cpu = current_thread->cpu;
         IPI_handler(cpu);
-        if(cpu != 0)
+        if (cpu != 0)
                 return 1;
 #endif
         return 0;
@@ -408,7 +390,8 @@ int get_using_sysemu(void)
 
 static int proc_read_sysemu(char *buf, char **start, off_t offset, int size,int *eof, void *data)
 {
-        if (snprintf(buf, size, "%d\n", get_using_sysemu()) < size) /*No overflow*/
+        if (snprintf(buf, size, "%d\n", get_using_sysemu()) < size)
+                /* No overflow */
                 *eof = 1;
 
         return strlen(buf);
@@ -423,7 +406,8 @@ static int proc_write_sysemu(struct file *file,const char __user *buf, unsigned
 
         if (tmp[0] >= '0' && tmp[0] <= '2')
                 set_using_sysemu(tmp[0] - '0');
-        return count; /*We use the first char, but pretend to write everything*/
+        /* We use the first char, but pretend to write everything */
+        return count;
 }
 
 int __init make_proc_sysemu(void)
@@ -453,10 +437,10 @@ int singlestepping(void * t)
         struct task_struct *task = t ? t : current;
 
         if ( ! (task->ptrace & PT_DTRACE) )
-                return(0);
+                return 0;
 
         if (task->thread.singlestep_syscall)
-                return(1);
+                return 1;
 
         return 2;
 }