uml: style fixes pass 3

Formatting changes in the files which have been changed in the course
of folding foo_skas functions into their callers.  These include:
	copyright updates
	header file trimming
	style fixes
	adding severity to printks

These changes should be entirely non-functional.

Signed-off-by: Jeff Dike <jdike@linux.intel.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

4 files changed, 104 insertions, 120 deletions

diff --git a/arch/um/sys-x86_64/fault.c b/arch/um/sys-x86_64/fault.c
index 79f37ef3dceb..ce85117fc64e 100644
--- a/arch/um/sys-x86_64/fault.c
+++ b/arch/um/sys-x86_64/fault.c
@@ -14,14 +14,15 @@ struct exception_table_entry
 };
 
 const struct exception_table_entry *search_exception_tables(unsigned long add);
+
 int arch_fixup(unsigned long address, struct uml_pt_regs *regs)
 {
         const struct exception_table_entry *fixup;
 
         fixup = search_exception_tables(address);
-        if(fixup != 0){
+        if (fixup != 0) {
                 UPT_IP(regs) = fixup->fixup;
-                return(1);
+                return 1;
         }
-        return(0);
+        return 0;
 }
diff --git a/arch/um/sys-x86_64/signal.c b/arch/um/sys-x86_64/signal.c
index a06d66d0c409..9001d17fc3d8 100644
--- a/arch/um/sys-x86_64/signal.c
+++ b/arch/um/sys-x86_64/signal.c
@@ -3,16 +3,11 @@
  * Licensed under the GPL
  */
 
-#include "linux/stddef.h"
-#include "linux/errno.h"
 #include "linux/personality.h"
 #include "linux/ptrace.h"
-#include "asm/current.h"
+#include "asm/unistd.h"
 #include "asm/uaccess.h"
-#include "asm/sigcontext.h"
-#include "asm/ptrace.h"
-#include "asm/arch/ucontext.h"
-#include "sysdep/ptrace.h"
+#include "asm/ucontext.h"
 #include "frame_kern.h"
 #include "skas.h"
 
@@ -20,28 +15,28 @@ void copy_sc(struct uml_pt_regs *regs, void *from)
 {
         struct sigcontext *sc = from;
 
-#define GETREG(regs, regno, sc, regname) \
-       (regs)->regs[(regno) / sizeof(unsigned long)] = (sc)->regname
-
-       GETREG(regs, R8, sc, r8);
-       GETREG(regs, R9, sc, r9);
-       GETREG(regs, R10, sc, r10);
-       GETREG(regs, R11, sc, r11);
-       GETREG(regs, R12, sc, r12);
-       GETREG(regs, R13, sc, r13);
-       GETREG(regs, R14, sc, r14);
-       GETREG(regs, R15, sc, r15);
-       GETREG(regs, RDI, sc, rdi);
-       GETREG(regs, RSI, sc, rsi);
-       GETREG(regs, RBP, sc, rbp);
-       GETREG(regs, RBX, sc, rbx);
-       GETREG(regs, RDX, sc, rdx);
-       GETREG(regs, RAX, sc, rax);
-       GETREG(regs, RCX, sc, rcx);
-       GETREG(regs, RSP, sc, rsp);
-       GETREG(regs, RIP, sc, rip);
-       GETREG(regs, EFLAGS, sc, eflags);
-       GETREG(regs, CS, sc, cs);
+#define GETREG(regs, regno, sc, regname)                                \
+        (regs)->regs[(regno) / sizeof(unsigned long)] = (sc)->regname
+
+        GETREG(regs, R8, sc, r8);
+        GETREG(regs, R9, sc, r9);
+        GETREG(regs, R10, sc, r10);
+        GETREG(regs, R11, sc, r11);
+        GETREG(regs, R12, sc, r12);
+        GETREG(regs, R13, sc, r13);
+        GETREG(regs, R14, sc, r14);
+        GETREG(regs, R15, sc, r15);
+        GETREG(regs, RDI, sc, rdi);
+        GETREG(regs, RSI, sc, rsi);
+        GETREG(regs, RBP, sc, rbp);
+        GETREG(regs, RBX, sc, rbx);
+        GETREG(regs, RDX, sc, rdx);
+        GETREG(regs, RAX, sc, rax);
+        GETREG(regs, RCX, sc, rcx);
+        GETREG(regs, RSP, sc, rsp);
+        GETREG(regs, RIP, sc, rip);
+        GETREG(regs, EFLAGS, sc, eflags);
+        GETREG(regs, CS, sc, cs);
 
 #undef GETREG
 }
@@ -49,58 +44,58 @@ void copy_sc(struct uml_pt_regs *regs, void *from)
 static int copy_sc_from_user(struct pt_regs *regs,
                              struct sigcontext __user *from)
 {
-       int err = 0;
-
-#define GETREG(regs, regno, sc, regname) \
-       __get_user((regs)->regs.regs[(regno) / sizeof(unsigned long)], \
-                  &(sc)->regname)
-
-       err |= GETREG(regs, R8, from, r8);
-       err |= GETREG(regs, R9, from, r9);
-       err |= GETREG(regs, R10, from, r10);
-       err |= GETREG(regs, R11, from, r11);
-       err |= GETREG(regs, R12, from, r12);
-       err |= GETREG(regs, R13, from, r13);
-       err |= GETREG(regs, R14, from, r14);
-       err |= GETREG(regs, R15, from, r15);
-       err |= GETREG(regs, RDI, from, rdi);
-       err |= GETREG(regs, RSI, from, rsi);
-       err |= GETREG(regs, RBP, from, rbp);
-       err |= GETREG(regs, RBX, from, rbx);
-       err |= GETREG(regs, RDX, from, rdx);
-       err |= GETREG(regs, RAX, from, rax);
-       err |= GETREG(regs, RCX, from, rcx);
-       err |= GETREG(regs, RSP, from, rsp);
-       err |= GETREG(regs, RIP, from, rip);
-       err |= GETREG(regs, EFLAGS, from, eflags);
-       err |= GETREG(regs, CS, from, cs);
+        int err = 0;
+
+#define GETREG(regs, regno, sc, regname)                                \
+        __get_user((regs)->regs.regs[(regno) / sizeof(unsigned long)],  \
+                   &(sc)->regname)
+
+        err |= GETREG(regs, R8, from, r8);
+        err |= GETREG(regs, R9, from, r9);
+        err |= GETREG(regs, R10, from, r10);
+        err |= GETREG(regs, R11, from, r11);
+        err |= GETREG(regs, R12, from, r12);
+        err |= GETREG(regs, R13, from, r13);
+        err |= GETREG(regs, R14, from, r14);
+        err |= GETREG(regs, R15, from, r15);
+        err |= GETREG(regs, RDI, from, rdi);
+        err |= GETREG(regs, RSI, from, rsi);
+        err |= GETREG(regs, RBP, from, rbp);
+        err |= GETREG(regs, RBX, from, rbx);
+        err |= GETREG(regs, RDX, from, rdx);
+        err |= GETREG(regs, RAX, from, rax);
+        err |= GETREG(regs, RCX, from, rcx);
+        err |= GETREG(regs, RSP, from, rsp);
+        err |= GETREG(regs, RIP, from, rip);
+        err |= GETREG(regs, EFLAGS, from, eflags);
+        err |= GETREG(regs, CS, from, cs);
 
 #undef GETREG
 
-       return err;
+        return err;
 }
 
 static int copy_sc_to_user(struct sigcontext __user *to,
                            struct _fpstate __user *to_fp, struct pt_regs *regs,
                            unsigned long mask, unsigned long sp)
 {
-        struct faultinfo * fi = &current->thread.arch.faultinfo;
+        struct faultinfo * fi = &current->thread.arch.faultinfo;
         int err = 0;
 
         err |= __put_user(0, &to->gs);
         err |= __put_user(0, &to->fs);
 
-#define PUTREG(regs, regno, sc, regname) \
-       __put_user((regs)->regs.regs[(regno) / sizeof(unsigned long)], \
-                  &(sc)->regname)
+#define PUTREG(regs, regno, sc, regname)                                \
+        __put_user((regs)->regs.regs[(regno) / sizeof(unsigned long)],  \
+                   &(sc)->regname)
 
         err |= PUTREG(regs, RDI, to, rdi);
         err |= PUTREG(regs, RSI, to, rsi);
         err |= PUTREG(regs, RBP, to, rbp);
-        /* Must use orignal RSP, which is passed in, rather than what's in
-         * the pt_regs, because that's already been updated to point at the
-         * signal frame.
-         */
+        /* Must use orignal RSP, which is passed in, rather than what's in
+         * the pt_regs, because that's already been updated to point at the
+         * signal frame.
+         */
         err |= __put_user(sp, &to->rsp);
         err |= PUTREG(regs, RBX, to, rbx);
         err |= PUTREG(regs, RDX, to, rdx);
@@ -116,9 +111,9 @@ static int copy_sc_to_user(struct sigcontext __user *to,
         err |= PUTREG(regs, R15, to, r15);
         err |= PUTREG(regs, CS, to, cs); /* XXX x86_64 doesn't do this */
 
-        err |= __put_user(fi->cr2, &to->cr2);
-        err |= __put_user(fi->error_code, &to->err);
-        err |= __put_user(fi->trap_no, &to->trapno);
+        err |= __put_user(fi->cr2, &to->cr2);
+        err |= __put_user(fi->error_code, &to->err);
+        err |= __put_user(fi->trap_no, &to->trapno);
 
         err |= PUTREG(regs, RIP, to, rip);
         err |= PUTREG(regs, EFLAGS, to, eflags);
@@ -131,9 +126,9 @@ static int copy_sc_to_user(struct sigcontext __user *to,
 
 struct rt_sigframe
 {
-       char __user *pretcode;
-       struct ucontext uc;
-       struct siginfo info;
+        char __user *pretcode;
+        struct ucontext uc;
+        struct siginfo info;
 };
 
 #define round_down(m, n) (((m) / (n)) * (n))
@@ -151,7 +146,7 @@ int setup_signal_stack_si(unsigned long stack_top, int sig,
         frame = (struct rt_sigframe __user *)
                 round_down(stack_top - sizeof(struct rt_sigframe), 16);
         /* Subtract 128 for a red zone and 8 for proper alignment */
-        frame = (struct rt_sigframe __user *) ((unsigned long) frame - 128 - 8);
+        frame = (struct rt_sigframe __user *) ((unsigned long) frame - 128 - 8);
 
         if (!access_ok(VERIFY_WRITE, fp, sizeof(struct _fpstate)))
                 goto out;
@@ -241,7 +236,7 @@ long sys_rt_sigreturn(struct pt_regs *regs)
         struct ucontext __user *uc = &frame->uc;
         sigset_t set;
 
-        if(copy_from_user(&set, &uc->uc_sigmask, sizeof(set)))
+        if (copy_from_user(&set, &uc->uc_sigmask, sizeof(set)))
                 goto segfault;
 
         sigdelsetmask(&set, ~_BLOCKABLE);
@@ -251,7 +246,7 @@ long sys_rt_sigreturn(struct pt_regs *regs)
         recalc_sigpending();
         spin_unlock_irq(&current->sighand->siglock);
 
-        if(copy_sc_from_user(&current->thread.regs, &uc->uc_mcontext))
+        if (copy_sc_from_user(&current->thread.regs, &uc->uc_mcontext))
                 goto segfault;
 
         /* Avoid ERESTART handling */
@@ -262,13 +257,3 @@ long sys_rt_sigreturn(struct pt_regs *regs)
         force_sig(SIGSEGV, current);
         return 0;
 }
-/*
- * Overrides for Emacs so that we follow Linus's tabbing style.
- * Emacs will notice this stuff at the end of the file and automatically
- * adjust the settings for this buffer only.  This must remain at the end
- * of the file.
- * ---------------------------------------------------------------------------
- * Local variables:
- * c-file-style: "linux"
- * End:
- */
diff --git a/arch/um/sys-x86_64/syscalls.c b/arch/um/sys-x86_64/syscalls.c
index bbcab773b23d..58ae06562b4a 100644
--- a/arch/um/sys-x86_64/syscalls.c
+++ b/arch/um/sys-x86_64/syscalls.c
@@ -1,36 +1,34 @@
 /*
+ * Copyright (C) 2003 - 2007 Jeff Dike (jdike@{addtoit,linux.intel}.com)
  * Copyright 2003 PathScale, Inc.
  *
  * Licensed under the GPL
  */
 
 #include "linux/linkage.h"
-#include "linux/slab.h"
-#include "linux/shm.h"
-#include "linux/utsname.h"
 #include "linux/personality.h"
-#include "asm/uaccess.h"
-#define __FRAME_OFFSETS
-#include "asm/ptrace.h"
-#include "asm/unistd.h"
+#include "linux/utsname.h"
 #include "asm/prctl.h" /* XXX This should get the constants from libc */
-#include "kern.h"
+#include "asm/uaccess.h"
 #include "os.h"
 
 asmlinkage long sys_uname64(struct new_utsname __user * name)
 {
         int err;
+
         down_read(&uts_sem);
         err = copy_to_user(name, utsname(), sizeof (*name));
         up_read(&uts_sem);
+
         if (personality(current->personality) == PER_LINUX32)
                 err |= copy_to_user(&name->machine, "i686", 5);
+
         return err ? -EFAULT : 0;
 }
 
 long arch_prctl(struct task_struct *task, int code, unsigned long __user *addr)
 {
-        unsigned long *ptr = addr, tmp;
+        unsigned long *ptr = addr, tmp;
         long ret;
         int pid = task->mm->context.skas.id.u.pid;
 
@@ -47,42 +45,42 @@ long arch_prctl(struct task_struct *task, int code, unsigned long __user *addr)
          * arch_prctl is run on the host, then the registers are read
          * back.
          */
-        switch(code){
+        switch (code) {
         case ARCH_SET_FS:
         case ARCH_SET_GS:
-                restore_registers(pid, &current->thread.regs.regs);
-                break;
-        case ARCH_GET_FS:
-        case ARCH_GET_GS:
-                /*
-                 * With these two, we read to a local pointer and
-                 * put_user it to the userspace pointer that we were
-                 * given.  If addr isn't valid (because it hasn't been
-                 * faulted in or is just bogus), we want put_user to
-                 * fault it in (or return -EFAULT) instead of having
-                 * the host return -EFAULT.
-                 */
-                ptr = &tmp;
-        }
+                restore_registers(pid, &current->thread.regs.regs);
+                break;
+        case ARCH_GET_FS:
+        case ARCH_GET_GS:
+                /*
+                 * With these two, we read to a local pointer and
+                 * put_user it to the userspace pointer that we were
+                 * given.  If addr isn't valid (because it hasn't been
+                 * faulted in or is just bogus), we want put_user to
+                 * fault it in (or return -EFAULT) instead of having
+                 * the host return -EFAULT.
+                 */
+                ptr = &tmp;
+        }
 
-        ret = os_arch_prctl(pid, code, ptr);
-        if(ret)
-                return ret;
+        ret = os_arch_prctl(pid, code, ptr);
+        if (ret)
+                return ret;
 
-        switch(code){
+        switch (code) {
         case ARCH_SET_FS:
                 current->thread.arch.fs = (unsigned long) ptr;
                 save_registers(pid, &current->thread.regs.regs);
                 break;
         case ARCH_SET_GS:
-                save_registers(pid, &current->thread.regs.regs);
+                save_registers(pid, &current->thread.regs.regs);
                 break;
         case ARCH_GET_FS:
                 ret = put_user(tmp, addr);
-                break;
+                break;
         case ARCH_GET_GS:
                 ret = put_user(tmp, addr);
-                break;
+                break;
         }
 
         return ret;
@@ -109,8 +107,8 @@ long sys_clone(unsigned long clone_flags, unsigned long newsp,
 
 void arch_switch_to(struct task_struct *from, struct task_struct *to)
 {
-        if((to->thread.arch.fs == 0) || (to->mm == NULL))
-                return;
+        if ((to->thread.arch.fs == 0) || (to->mm == NULL))
+                return;
 
-        arch_prctl(to, ARCH_SET_FS, (void __user *) to->thread.arch.fs);
+        arch_prctl(to, ARCH_SET_FS, (void __user *) to->thread.arch.fs);
 }
diff --git a/arch/um/sys-x86_64/tls.c b/arch/um/sys-x86_64/tls.c
index fcd5217c26a5..3bd19a51ad6b 100644
--- a/arch/um/sys-x86_64/tls.c
+++ b/arch/um/sys-x86_64/tls.c
@@ -13,5 +13,5 @@ int arch_copy_tls(struct task_struct *t)
          */
         t->thread.arch.fs = t->thread.regs.regs.regs[R8 / sizeof(long)];
 
-        return 0;
+        return 0;
 }