Gitweb:     
http://git.kernel.org/git/?p=linux/kernel/git/torvalds/linux-2.6.git;a=commit;h=fb8e569c1d4f44a4632e2db95a27ed45734d4705
Commit:     fb8e569c1d4f44a4632e2db95a27ed45734d4705
Parent:     5db141a9469c8446a179696bc7d374f4cd9b207a
Author:     Paul Mundt <[EMAIL PROTECTED]>
AuthorDate: Wed Nov 21 17:55:12 2007 +0900
Committer:  Paul Mundt <[EMAIL PROTECTED]>
CommitDate: Mon Jan 28 13:18:53 2008 +0900

    sh: Fix up user_fpu_struct typo for SH-5.
    
    Signed-off-by: Paul Mundt <[EMAIL PROTECTED]>
---
 arch/sh64/kernel/asm-offsets.c |   33 ---------
 arch/sh64/kernel/init_task.c   |   46 -------------
 arch/sh64/kernel/semaphore.c   |  140 ----------------------------------------
 include/asm-sh/user.h          |    2 +-
 4 files changed, 1 insertions(+), 220 deletions(-)

diff --git a/arch/sh64/kernel/asm-offsets.c b/arch/sh64/kernel/asm-offsets.c
deleted file mode 100644
index ca76537..0000000
--- a/arch/sh64/kernel/asm-offsets.c
+++ /dev/null
@@ -1,33 +0,0 @@
-/*
- * This program is used to generate definitions needed by
- * assembly language modules.
- *
- * We use the technique used in the OSF Mach kernel code:
- * generate asm statements containing #defines,
- * compile this file to assembler, and then extract the
- * #defines from the assembly-language output.
- */
-
-#include <linux/stddef.h>
-#include <linux/types.h>
-#include <linux/mm.h>
-#include <asm/thread_info.h>
-
-#define DEFINE(sym, val) \
-        asm volatile("\n->" #sym " %0 " #val : : "i" (val))
-
-#define BLANK() asm volatile("\n->" : : )
-
-int main(void)
-{
-       /* offsets into the thread_info struct */
-       DEFINE(TI_TASK,         offsetof(struct thread_info, task));
-       DEFINE(TI_EXEC_DOMAIN,  offsetof(struct thread_info, exec_domain));
-       DEFINE(TI_FLAGS,        offsetof(struct thread_info, flags));
-       DEFINE(TI_PRE_COUNT,    offsetof(struct thread_info, preempt_count));
-       DEFINE(TI_CPU,          offsetof(struct thread_info, cpu));
-       DEFINE(TI_ADDR_LIMIT,   offsetof(struct thread_info, addr_limit));
-       DEFINE(TI_RESTART_BLOCK,offsetof(struct thread_info, restart_block));
-
-       return 0;
-}
diff --git a/arch/sh64/kernel/init_task.c b/arch/sh64/kernel/init_task.c
deleted file mode 100644
index deee8bf..0000000
--- a/arch/sh64/kernel/init_task.c
+++ /dev/null
@@ -1,46 +0,0 @@
-/*
- * This file is subject to the terms and conditions of the GNU General Public
- * License.  See the file "COPYING" in the main directory of this archive
- * for more details.
- *
- * arch/sh64/kernel/init_task.c
- *
- * Copyright (C) 2000, 2001  Paolo Alberelli
- * Copyright (C) 2003  Paul Mundt
- *
- */
-#include <linux/rwsem.h>
-#include <linux/mm.h>
-#include <linux/sched.h>
-#include <linux/init_task.h>
-#include <linux/mqueue.h>
-#include <linux/fs.h>
-#include <asm/uaccess.h>
-#include <asm/pgtable.h>
-
-static struct fs_struct init_fs = INIT_FS;
-static struct files_struct init_files = INIT_FILES;
-static struct signal_struct init_signals = INIT_SIGNALS(init_signals);
-static struct sighand_struct init_sighand = INIT_SIGHAND(init_sighand);
-struct mm_struct init_mm = INIT_MM(init_mm);
-
-struct pt_regs fake_swapper_regs;
-
-/*
- * Initial thread structure.
- *
- * We need to make sure that this is THREAD_SIZE-byte aligned due
- * to the way process stacks are handled. This is done by having a
- * special "init_task" linker map entry..
- */
-union thread_union init_thread_union
-       __attribute__((__section__(".data.init_task"))) =
-               { INIT_THREAD_INFO(init_task) };
-
-/*
- * Initial task structure.
- *
- * All other task structs will be allocated on slabs in fork.c
- */
-struct task_struct init_task = INIT_TASK(init_task);
-
diff --git a/arch/sh64/kernel/semaphore.c b/arch/sh64/kernel/semaphore.c
deleted file mode 100644
index 72c1653..0000000
--- a/arch/sh64/kernel/semaphore.c
+++ /dev/null
@@ -1,140 +0,0 @@
-/*
- * Just taken from alpha implementation.
- * This can't work well, perhaps.
- */
-/*
- *  Generic semaphore code. Buyer beware. Do your own
- * specific changes in <asm/semaphore-helper.h>
- */
-
-#include <linux/errno.h>
-#include <linux/rwsem.h>
-#include <linux/sched.h>
-#include <linux/wait.h>
-#include <linux/init.h>
-#include <asm/semaphore.h>
-#include <asm/semaphore-helper.h>
-
-spinlock_t semaphore_wake_lock;
-
-/*
- * Semaphores are implemented using a two-way counter:
- * The "count" variable is decremented for each process
- * that tries to sleep, while the "waking" variable is
- * incremented when the "up()" code goes to wake up waiting
- * processes.
- *
- * Notably, the inline "up()" and "down()" functions can
- * efficiently test if they need to do any extra work (up
- * needs to do something only if count was negative before
- * the increment operation.
- *
- * waking_non_zero() (from asm/semaphore.h) must execute
- * atomically.
- *
- * When __up() is called, the count was negative before
- * incrementing it, and we need to wake up somebody.
- *
- * This routine adds one to the count of processes that need to
- * wake up and exit.  ALL waiting processes actually wake up but
- * only the one that gets to the "waking" field first will gate
- * through and acquire the semaphore.  The others will go back
- * to sleep.
- *
- * Note that these functions are only called when there is
- * contention on the lock, and as such all this is the
- * "non-critical" part of the whole semaphore business. The
- * critical part is the inline stuff in <asm/semaphore.h>
- * where we want to avoid any extra jumps and calls.
- */
-void __up(struct semaphore *sem)
-{
-       wake_one_more(sem);
-       wake_up(&sem->wait);
-}
-
-/*
- * Perform the "down" function.  Return zero for semaphore acquired,
- * return negative for signalled out of the function.
- *
- * If called from __down, the return is ignored and the wait loop is
- * not interruptible.  This means that a task waiting on a semaphore
- * using "down()" cannot be killed until someone does an "up()" on
- * the semaphore.
- *
- * If called from __down_interruptible, the return value gets checked
- * upon return.  If the return value is negative then the task continues
- * with the negative value in the return register (it can be tested by
- * the caller).
- *
- * Either form may be used in conjunction with "up()".
- *
- */
-
-#define DOWN_VAR                               \
-       struct task_struct *tsk = current;      \
-       wait_queue_t wait;                      \
-       init_waitqueue_entry(&wait, tsk);
-
-#define DOWN_HEAD(task_state)                                          \
-                                                                       \
-                                                                       \
-       tsk->state = (task_state);                                      \
-       add_wait_queue(&sem->wait, &wait);                              \
-                                                                       \
-       /*                                                              \
-        * Ok, we're set up.  sem->count is known to be less than zero  \
-        * so we must wait.                                             \
-        *                                                              \
-        * We can let go the lock for purposes of waiting.              \
-        * We re-acquire it after awaking so as to protect              \
-        * all semaphore operations.                                    \
-        *                                                              \
-        * If "up()" is called before we call waking_non_zero() then    \
-        * we will catch it right away.  If it is called later then     \
-        * we will have to go through a wakeup cycle to catch it.       \
-        *                                                              \
-        * Multiple waiters contend for the semaphore lock to see       \
-        * who gets to gate through and who has to wait some more.      \
-        */                                                             \
-       for (;;) {
-
-#define DOWN_TAIL(task_state)                  \
-               tsk->state = (task_state);      \
-       }                                       \
-       tsk->state = TASK_RUNNING;              \
-       remove_wait_queue(&sem->wait, &wait);
-
-void __sched __down(struct semaphore * sem)
-{
-       DOWN_VAR
-       DOWN_HEAD(TASK_UNINTERRUPTIBLE)
-       if (waking_non_zero(sem))
-               break;
-       schedule();
-       DOWN_TAIL(TASK_UNINTERRUPTIBLE)
-}
-
-int __sched __down_interruptible(struct semaphore * sem)
-{
-       int ret = 0;
-       DOWN_VAR
-       DOWN_HEAD(TASK_INTERRUPTIBLE)
-
-       ret = waking_non_zero_interruptible(sem, tsk);
-       if (ret)
-       {
-               if (ret == 1)
-                       /* ret != 0 only if we get interrupted -arca */
-                       ret = 0;
-               break;
-       }
-       schedule();
-       DOWN_TAIL(TASK_INTERRUPTIBLE)
-       return ret;
-}
-
-int __down_trylock(struct semaphore * sem)
-{
-       return waking_non_zero_trylock(sem);
-}
diff --git a/include/asm-sh/user.h b/include/asm-sh/user.h
index 706b1c7..1a4f43c 100644
--- a/include/asm-sh/user.h
+++ b/include/asm-sh/user.h
@@ -28,7 +28,7 @@
  */
 
 #if defined(__SH5__) || defined(CONFIG_CPU_SH5)
-struct user fpu_struct {
+struct user_fpu_struct {
        unsigned long fp_regs[32];
        unsigned int fpscr;
 };
-
To unsubscribe from this list: send the line "unsubscribe git-commits-head" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at  http://vger.kernel.org/majordomo-info.html

Reply via email to