- added -r to depmod to actually check modules instead of rejecting

[packages/kernel.git] / linux-2.4.20-sched-O1+preempt.patch

diff -urN linux-2.4.20/CREDITS linux-2.4.20-o1-preempt/CREDITS
--- linux-2.4.20/CREDITS        Fri Nov 29 00:53:08 2002
+++ linux-2.4.20-o1-preempt/CREDITS     Tue Feb 18 03:52:06 2003
@@ -1001,8 +1001,8 @@
 
 N: Nigel Gamble
 E: nigel@nrg.org
-E: nigel@sgi.com
 D: Interrupt-driven printer driver
+D: Preemptible kernel
 S: 120 Alley Way
 S: Mountain View, California 94040
 S: USA
diff -urN linux-2.4.20/Documentation/Configure.help linux-2.4.20-o1-preempt/Documentation/Configure.help
--- linux-2.4.20/Documentation/Configure.help   Fri Nov 29 00:53:08 2002
+++ linux-2.4.20-o1-preempt/Documentation/Configure.help        Tue Feb 18 03:52:06 2003
@@ -279,6 +279,17 @@
   If you have a system with several CPUs, you do not need to say Y
   here: the local APIC will be used automatically.
 
+Preemptible Kernel
+CONFIG_PREEMPT
+  This option reduces the latency of the kernel when reacting to
+  real-time or interactive events by allowing a low priority process to
+  be preempted even if it is in kernel mode executing a system call.
+  This allows applications to run more reliably even when the system is
+  under load.
+
+  Say Y here if you are building a kernel for a desktop, embedded or
+  real-time system.  Say N if you are unsure.
+
 Kernel math emulation
 CONFIG_MATH_EMULATION
   Linux can emulate a math coprocessor (used for floating point
@@ -4094,6 +4105,38 @@
   You may say M here for module support and later load the module when
   you have use for it; the module is called binfmt_misc.o. If you
   don't know what to answer at this point, say Y.
+
+Maximum User Real-Time Priority
+CONFIG_MAX_USER_RT_PRIO
+  The maximum user real-time priority. Tasks with priorities from
+  zero through one less than this value are scheduled as real-time.
+  To the application, a higher priority value implies a higher
+  priority task.
+
+  The minimum allowed value is 100 and the maximum allowed value
+  is (arbitrary) 1000. Values specified outside this range will
+  be rounded accordingly during compile-time. The default is 100.
+  Setting this higher than 100 is safe but will result in slightly
+  more processing overhead in the scheduler. 
+
+  Unless you are doing specialized real-time computing and require
+  a much larger range than usual, the default is fine.
+
+Maximum Kernel Real-Time Priority
+CONFIG_MAX_RT_PRIO
+  The difference between the maximum real-time priority and the
+  maximum user real-time priority.  Usually this value is zero,
+  which sets the maximum real-time priority to the same as the
+  maximum user real-time priority.  Setting this higher,
+  however, will allow kernel threads to set their priority to a
+  value higher than any user task. This is safe, but will result
+  in slightly more processing overhead in the scheduler.
+
+  This value can be at most 200.  The default is zero, i.e. the
+  maximum priority and maximum user priority are the same.
+
+  Unless you are doing specialized real-time programming with
+  kernel threads, the default is fine.
 
 Kernel support for JAVA binaries
 CONFIG_BINFMT_JAVA
diff -urN linux-2.4.20/Documentation/preempt-locking.txt linux-2.4.20-o1-preempt/Documentation/preempt-locking.txt
--- linux-2.4.20/Documentation/preempt-locking.txt      Thu Jan  1 01:00:00 1970
+++ linux-2.4.20-o1-preempt/Documentation/preempt-locking.txt   Tue Feb 18 03:52:06 2003
@@ -0,0 +1,104 @@
+                 Proper Locking Under a Preemptible Kernel:
+                      Keeping Kernel Code Preempt-Safe
+                         Robert Love <rml@tech9.net>
+                          Last Updated: 22 Jan 2002
+
+
+INTRODUCTION
+
+
+A preemptible kernel creates new locking issues.  The issues are the same as
+those under SMP: concurrency and reentrancy.  Thankfully, the Linux preemptible
+kernel model leverages existing SMP locking mechanisms.  Thus, the kernel
+requires explicit additional locking for very few additional situations.
+
+This document is for all kernel hackers.  Developing code in the kernel
+requires protecting these situations.
+ 
+
+RULE #1: Per-CPU data structures need explicit protection
+
+
+Two similar problems arise. An example code snippet:
+
+       struct this_needs_locking tux[NR_CPUS];
+       tux[smp_processor_id()] = some_value;
+       /* task is preempted here... */
+       something = tux[smp_processor_id()];
+
+First, since the data is per-CPU, it may not have explicit SMP locking, but
+require it otherwise.  Second, when a preempted task is finally rescheduled,
+the previous value of smp_processor_id may not equal the current.  You must
+protect these situations by disabling preemption around them.
+
+
+RULE #2: CPU state must be protected.
+
+
+Under preemption, the state of the CPU must be protected.  This is arch-
+dependent, but includes CPU structures and state not preserved over a context
+switch.  For example, on x86, entering and exiting FPU mode is now a critical
+section that must occur while preemption is disabled.  Think what would happen
+if the kernel is executing a floating-point instruction and is then preempted.
+Remember, the kernel does not save FPU state except for user tasks.  Therefore,
+upon preemption, the FPU registers will be sold to the lowest bidder.  Thus,
+preemption must be disabled around such regions.
+
+Note, some FPU functions are already explicitly preempt safe.  For example,
+kernel_fpu_begin and kernel_fpu_end will disable and enable preemption.
+However, math_state_restore must be called with preemption disabled.
+
+
+RULE #3: Lock acquire and release must be performed by same task
+
+
+A lock acquired in one task must be released by the same task.  This
+means you can't do oddball things like acquire a lock and go off to
+play while another task releases it.  If you want to do something
+like this, acquire and release the task in the same code path and
+have the caller wait on an event by the other task.
+
+
+SOLUTION
+
+
+Data protection under preemption is achieved by disabling preemption for the
+duration of the critical region.
+
+preempt_enable()               decrement the preempt counter
+preempt_disable()              increment the preempt counter
+preempt_enable_no_resched()    decrement, but do not immediately preempt
+preempt_get_count()            return the preempt counter
+
+The functions are nestable.  In other words, you can call preempt_disable
+n-times in a code path, and preemption will not be reenabled until the n-th
+call to preempt_enable.  The preempt statements define to nothing if
+preemption is not enabled.
+
+Note that you do not need to explicitly prevent preemption if you are holding
+any locks or interrupts are disabled, since preemption is implicitly disabled
+in those cases.
+
+Example:
+
+       cpucache_t *cc; /* this is per-CPU */
+       preempt_disable();
+       cc = cc_data(searchp);
+       if (cc && cc->avail) {
+               __free_block(searchp, cc_entry(cc), cc->avail);
+               cc->avail = 0;
+       }
+       preempt_enable();
+       return 0;
+
+Notice how the preemption statements must encompass every reference of the
+critical variables.  Another example:
+
+       int buf[NR_CPUS];
+       set_cpu_val(buf);
+       if (buf[smp_processor_id()] == -1) printf(KERN_INFO "wee!\n");
+       spin_lock(&buf_lock);
+       /* ... */
+
+This code is not preempt-safe, but see how easily we can fix it by simply
+moving the spin_lock up two lines.
diff -urN linux-2.4.20/Documentation/sched-coding.txt linux-2.4.20-o1-preempt/Documentation/sched-coding.txt
--- linux-2.4.20/Documentation/sched-coding.txt Thu Jan  1 01:00:00 1970
+++ linux-2.4.20-o1-preempt/Documentation/sched-coding.txt      Tue Feb 18 03:51:29 2003
@@ -0,0 +1,126 @@
+     Reference for various scheduler-related methods in the O(1) scheduler
+               Robert Love <rml@tech9.net>, MontaVista Software
+
+
+Note most of these methods are local to kernel/sched.c - this is by design.
+The scheduler is meant to be self-contained and abstracted away.  This document
+is primarily for understanding the scheduler, not interfacing to it.  Some of
+the discussed interfaces, however, are general process/scheduling methods.
+They are typically defined in include/linux/sched.h.
+
+
+Main Scheduling Methods
+-----------------------
+
+void load_balance(runqueue_t *this_rq, int idle)
+       Attempts to pull tasks from one cpu to another to balance cpu usage,
+       if needed.  This method is called explicitly if the runqueues are
+       inbalanced or periodically by the timer tick.  Prior to calling,
+       the current runqueue must be locked and interrupts disabled.
+
+void schedule()
+       The main scheduling function.  Upon return, the highest priority
+       process will be active.
+
+
+Locking
+-------
+
+Each runqueue has its own lock, rq->lock.  When multiple runqueues need
+to be locked, lock acquires must be ordered by ascending &runqueue value.
+
+A specific runqueue is locked via
+
+       task_rq_lock(task_t pid, unsigned long *flags)
+
+which disables preemption, disables interrupts, and locks the runqueue pid is
+running on.  Likewise,
+
+       task_rq_unlock(task_t pid, unsigned long *flags)
+
+unlocks the runqueue pid is running on, restores interrupts to their previous
+state, and reenables preemption.
+
+The routines
+
+       double_rq_lock(runqueue_t *rq1, runqueue_t *rq2)
+
+and
+
+       double_rq_unlock(runqueue_t *rq1, runqueue_t rq2)
+
+safely lock and unlock, respectively, the two specified runqueues.  They do
+not, however, disable and restore interrupts.  Users are required to do so
+manually before and after calls.
+
+
+Values
+------
+
+MAX_PRIO
+       The maximum priority of the system, stored in the task as task->prio.
+       Lower priorities are higher.  Normal (non-RT) priorities range from
+       MAX_RT_PRIO to (MAX_PRIO - 1).
+MAX_RT_PRIO
+       The maximum real-time priority of the system.  Valid RT priorities
+       range from 0 to (MAX_RT_PRIO - 1).
+MAX_USER_RT_PRIO
+       The maximum real-time priority that is exported to user-space.  Should
+       always be equal to or less than MAX_RT_PRIO.  Setting it less allows
+       kernel threads to have higher priorities than any user-space task.
+MIN_TIMESLICE
+MAX_TIMESLICE
+       Respectively, the minimum and maximum timeslices (quanta) of a process.
+
+Data
+----
+
+struct runqueue
+       The main per-CPU runqueue data structure.
+struct task_struct
+       The main per-process data structure.
+
+
+General Methods
+---------------
+
+cpu_rq(cpu)
+       Returns the runqueue of the specified cpu.
+this_rq()
+       Returns the runqueue of the current cpu.
+task_rq(pid)
+       Returns the runqueue which holds the specified pid.
+cpu_curr(cpu)
+       Returns the task currently running on the given cpu.
+rt_task(pid)
+       Returns true if pid is real-time, false if not.
+
+
+Process Control Methods
+-----------------------
+
+void set_user_nice(task_t *p, long nice)
+       Sets the "nice" value of task p to the given value.
+int setscheduler(pid_t pid, int policy, struct sched_param *param)
+       Sets the scheduling policy and parameters for the given pid.
+void set_cpus_allowed(task_t *p, unsigned long new_mask)
+       Sets a given task's CPU affinity and migrates it to a proper cpu.
+       Callers must have a valid reference to the task and assure the
+       task not exit prematurely.  No locks can be held during the call.
+set_task_state(tsk, state_value)
+       Sets the given task's state to the given value.
+set_current_state(state_value)
+       Sets the current task's state to the given value.
+void set_tsk_need_resched(struct task_struct *tsk)
+       Sets need_resched in the given task.
+void clear_tsk_need_resched(struct task_struct *tsk)
+       Clears need_resched in the given task.
+void set_need_resched()
+       Sets need_resched in the current task.
+void clear_need_resched()
+       Clears need_resched in the current task.
+int need_resched()
+       Returns true if need_resched is set in the current task, false
+       otherwise.
+yield()
+       Place the current process at the end of the runqueue and call schedule.
diff -urN linux-2.4.20/Documentation/sched-design.txt linux-2.4.20-o1-preempt/Documentation/sched-design.txt
--- linux-2.4.20/Documentation/sched-design.txt Thu Jan  1 01:00:00 1970
+++ linux-2.4.20-o1-preempt/Documentation/sched-design.txt      Tue Feb 18 03:51:29 2003
@@ -0,0 +1,165 @@
+                  Goals, Design and Implementation of the
+                     new ultra-scalable O(1) scheduler
+
+
+  This is an edited version of an email Ingo Molnar sent to
+  lkml on 4 Jan 2002.  It describes the goals, design, and
+  implementation of Ingo's new ultra-scalable O(1) scheduler.
+  Last Updated: 18 April 2002.
+
+
+Goal
+====
+
+The main goal of the new scheduler is to keep all the good things we know
+and love about the current Linux scheduler:
+
+ - good interactive performance even during high load: if the user
+   types or clicks then the system must react instantly and must execute
+   the user tasks smoothly, even during considerable background load.
+
+ - good scheduling/wakeup performance with 1-2 runnable processes.
+
+ - fairness: no process should stay without any timeslice for any
+   unreasonable amount of time. No process should get an unjustly high
+   amount of CPU time.
+
+ - priorities: less important tasks can be started with lower priority,
+   more important tasks with higher priority.
+
+ - SMP efficiency: no CPU should stay idle if there is work to do.
+
+ - SMP affinity: processes which run on one CPU should stay affine to
+   that CPU. Processes should not bounce between CPUs too frequently.
+
+ - plus additional scheduler features: RT scheduling, CPU binding.
+
+and the goal is also to add a few new things:
+
+ - fully O(1) scheduling. Are you tired of the recalculation loop
+   blowing the L1 cache away every now and then? Do you think the goodness
+   loop is taking a bit too long to finish if there are lots of runnable
+   processes? This new scheduler takes no prisoners: wakeup(), schedule(),
+   the timer interrupt are all O(1) algorithms. There is no recalculation
+   loop. There is no goodness loop either.
+
+ - 'perfect' SMP scalability. With the new scheduler there is no 'big'
+   runqueue_lock anymore - it's all per-CPU runqueues and locks - two
+   tasks on two separate CPUs can wake up, schedule and context-switch
+   completely in parallel, without any interlocking. All
+   scheduling-relevant data is structured for maximum scalability.
+
+ - better SMP affinity. The old scheduler has a particular weakness that
+   causes the random bouncing of tasks between CPUs if/when higher
+   priority/interactive tasks, this was observed and reported by many
+   people. The reason is that the timeslice recalculation loop first needs
+   every currently running task to consume its timeslice. But when this
+   happens on eg. an 8-way system, then this property starves an
+   increasing number of CPUs from executing any process. Once the last
+   task that has a timeslice left has finished using up that timeslice,
+   the recalculation loop is triggered and other CPUs can start executing
+   tasks again - after having idled around for a number of timer ticks.
+   The more CPUs, the worse this effect.
+
+   Furthermore, this same effect causes the bouncing effect as well:
+   whenever there is such a 'timeslice squeeze' of the global runqueue,
+   idle processors start executing tasks which are not affine to that CPU.
+   (because the affine tasks have finished off their timeslices already.)
+
+   The new scheduler solves this problem by distributing timeslices on a
+   per-CPU basis, without having any global synchronization or
+   recalculation.
+
+ - batch scheduling. A significant proportion of computing-intensive tasks
+   benefit from batch-scheduling, where timeslices are long and processes
+   are roundrobin scheduled. The new scheduler does such batch-scheduling
+   of the lowest priority tasks - so nice +19 jobs will get
+   'batch-scheduled' automatically. With this scheduler, nice +19 jobs are
+   in essence SCHED_IDLE, from an interactiveness point of view.
+
+ - handle extreme loads more smoothly, without breakdown and scheduling
+   storms.
+
+ - O(1) RT scheduling. For those RT folks who are paranoid about the
+   O(nr_running) property of the goodness loop and the recalculation loop.
+
+ - run fork()ed children before the parent. Andrea has pointed out the
+   advantages of this a few months ago, but patches for this feature
+   do not work with the old scheduler as well as they should,
+   because idle processes often steal the new child before the fork()ing
+   CPU gets to execute it.
+
+
+Design
+======
+
+the core of the new scheduler are the following mechanizms:
+
+ - *two*, priority-ordered 'priority arrays' per CPU. There is an 'active'
+   array and an 'expired' array. The active array contains all tasks that
+   are affine to this CPU and have timeslices left. The expired array
+   contains all tasks which have used up their timeslices - but this array
+   is kept sorted as well. The active and expired array is not accessed
+   directly, it's accessed through two pointers in the per-CPU runqueue
+   structure. If all active tasks are used up then we 'switch' the two
+   pointers and from now on the ready-to-go (former-) expired array is the
+   active array - and the empty active array serves as the new collector
+   for expired tasks.
+
+ - there is a 64-bit bitmap cache for array indices. Finding the highest
+   priority task is thus a matter of two x86 BSFL bit-search instructions.
+
+the split-array solution enables us to have an arbitrary number of active
+and expired tasks, and the recalculation of timeslices can be done
+immediately when the timeslice expires. Because the arrays are always
+access through the pointers in the runqueue, switching the two arrays can
+be done very quickly.
+
+this is a hybride priority-list approach coupled with roundrobin
+scheduling and the array-switch method of distributing timeslices.
+
+ - there is a per-task 'load estimator'.
+
+one of the toughest things to get right is good interactive feel during
+heavy system load. While playing with various scheduler variants i found
+that the best interactive feel is achieved not by 'boosting' interactive
+tasks, but by 'punishing' tasks that want to use more CPU time than there
+is available. This method is also much easier to do in an O(1) fashion.
+
+to establish the actual 'load' the task contributes to the system, a
+complex-looking but pretty accurate method is used: there is a 4-entry
+'history' ringbuffer of the task's activities during the last 4 seconds.
+This ringbuffer is operated without much overhead. The entries tell the
+scheduler a pretty accurate load-history of the task: has it used up more
+CPU time or less during the past N seconds. [the size '4' and the interval
+of 4x 1 seconds was found by lots of experimentation - this part is
+flexible and can be changed in both directions.]
+
+the penalty a task gets for generating more load than the CPU can handle
+is a priority decrease - there is a maximum amount to this penalty
+relative to their static priority, so even fully CPU-bound tasks will
+observe each other's priorities, and will share the CPU accordingly.
+
+the SMP load-balancer can be extended/switched with additional parallel
+computing and cache hierarchy concepts: NUMA scheduling, multi-core CPUs
+can be supported easily by changing the load-balancer. Right now it's
+tuned for my SMP systems.
+
+i skipped the prev->mm == next->mm advantage - no workload i know of shows
+any sensitivity to this. It can be added back by sacrificing O(1)
+schedule() [the current and one-lower priority list can be searched for a
+that->mm == current->mm condition], but costs a fair number of cycles
+during a number of important workloads, so i wanted to avoid this as much
+as possible.
+
+- the SMP idle-task startup code was still racy and the new scheduler
+triggered this. So i streamlined the idle-setup code a bit. We do not call
+into schedule() before all processors have started up fully and all idle
+threads are in place.
+
+- the patch also cleans up a number of aspects of sched.c - moves code
+into other areas of the kernel where it's appropriate, and simplifies
+certain code paths and data constructs. As a result, the new scheduler's
+code is smaller than the old one.
+
+       Ingo
diff -urN linux-2.4.20/MAINTAINERS linux-2.4.20-o1-preempt/MAINTAINERS
--- linux-2.4.20/MAINTAINERS    Fri Nov 29 00:53:08 2002
+++ linux-2.4.20-o1-preempt/MAINTAINERS Tue Feb 18 03:52:07 2003
@@ -1310,6 +1310,14 @@
 M:     mostrows@styx.uwaterloo.ca
 S:     Maintained
 
+PREEMPTIBLE KERNEL
+P:     Robert M. Love
+M:     rml@tech9.net
+L:     linux-kernel@vger.kernel.org
+L:     kpreempt-tech@lists.sourceforge.net
+W:     http://tech9.net/rml/linux
+S:     Supported
+
 PROMISE DC4030 CACHING DISK CONTROLLER DRIVER
 P:     Peter Denison
 M:     promise@pnd-pc.demon.co.uk
diff -urN linux-2.4.20/arch/alpha/config.in linux-2.4.20-o1-preempt/arch/alpha/config.in
--- linux-2.4.20/arch/alpha/config.in   Fri Nov 29 00:53:08 2002
+++ linux-2.4.20-o1-preempt/arch/alpha/config.in        Tue Feb 18 03:51:29 2003
@@ -273,6 +273,8 @@
 bool 'System V IPC' CONFIG_SYSVIPC
 bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
 bool 'Sysctl support' CONFIG_SYSCTL
+int 'Maximum User Real-Time Priority' CONFIG_MAX_USER_RT_PRIO 100
+int 'Maximum Kernel Real-time Priority' CONFIG_MAX_RT_PRIO 0
 if [ "$CONFIG_PROC_FS" = "y" ]; then
    choice 'Kernel core (/proc/kcore) format' \
        "ELF            CONFIG_KCORE_ELF        \
--- linux-2.4.20/arch/alpha/kernel/entry.S.orig Fri Mar  7 16:13:50 2003
+++ linux-2.4.20/arch/alpha/kernel/entry.S      Fri Mar  7 16:43:09 2003
@@ -695,7 +695,9 @@
 ret_from_fork:
        lda     $26,ret_from_sys_call
        mov     $17,$16
+#if CONFIG_SMP
        jsr     $31,schedule_tail
+#endif
 .end ret_from_fork
 
 .align 3
diff -urN linux-2.4.20/arch/alpha/kernel/process.c linux-2.4.20-o1-preempt/arch/alpha/kernel/process.c
--- linux-2.4.20/arch/alpha/kernel/process.c    Sun Sep 30 21:26:08 2001
+++ linux-2.4.20-o1-preempt/arch/alpha/kernel/process.c Tue Feb 18 03:51:29 2003
@@ -74,9 +74,6 @@
 cpu_idle(void)
 {
        /* An endless idle loop with no priority at all.  */
-       current->nice = 20;
-       current->counter = -100;
-
        while (1) {
                /* FIXME -- EV6 and LCA45 know how to power down
                   the CPU.  */
diff -urN linux-2.4.20/arch/alpha/kernel/smp.c linux-2.4.20-o1-preempt/arch/alpha/kernel/smp.c
--- linux-2.4.20/arch/alpha/kernel/smp.c        Sat Aug  3 02:39:42 2002
+++ linux-2.4.20-o1-preempt/arch/alpha/kernel/smp.c     Tue Feb 18 03:51:29 2003
@@ -82,6 +82,7 @@
 int smp_num_cpus = 1;          /* Number that came online.  */
 int smp_threads_ready;         /* True once the per process idle is forked. */
 cycles_t cacheflush_time;
+unsigned long cache_decay_ticks;
 
 int __cpu_number_map[NR_CPUS];
 int __cpu_logical_map[NR_CPUS];
@@ -156,11 +157,6 @@
 {
        int cpuid = hard_smp_processor_id();
 
-       if (current != init_tasks[cpu_number_map(cpuid)]) {
-               printk("BUG: smp_calling: cpu %d current %p init_tasks[cpu_number_map(cpuid)] %p\n",
-                      cpuid, current, init_tasks[cpu_number_map(cpuid)]);
-       }
-
        DBGS(("CALLIN %d state 0x%lx\n", cpuid, current->state));
 
        /* Turn on machine checks.  */
@@ -215,9 +211,6 @@
        DBGS(("smp_callin: commencing CPU %d current %p\n",
              cpuid, current));
 
-       /* Setup the scheduler for this processor.  */
-       init_idle();
-
        /* ??? This should be in init_idle.  */
        atomic_inc(&init_mm.mm_count);
        current->active_mm = &init_mm;
@@ -236,8 +229,9 @@
 smp_tune_scheduling (int cpuid)
 {
        struct percpu_struct *cpu;
-       unsigned long on_chip_cache;
-       unsigned long freq;
+       unsigned long on_chip_cache;    /* kB */
+       unsigned long freq;             /* Hz */
+       unsigned long bandwidth = 350;  /* MB/s */
 
        cpu = (struct percpu_struct*)((char*)hwrpb + hwrpb->processor_offset
                                      + cpuid * hwrpb->processor_size);
@@ -258,29 +252,21 @@
 
        case EV6_CPU:
        case EV67_CPU:
-               on_chip_cache = 64 + 64;
-               break;
-
        default:
-               on_chip_cache = 8 + 8;
+               on_chip_cache = 64 + 64;
                break;
        }
 
        freq = hwrpb->cycle_freq ? : est_cycle_freq;
 
-#if 0
-       /* Magic estimation stolen from x86 port.  */
-       cacheflush_time = freq / 1024L * on_chip_cache / 5000L;
-
-        printk("Using heuristic of %d cycles.\n",
-               cacheflush_time);
-#else
-       /* Magic value to force potential preemption of other CPUs.  */
-       cacheflush_time = INT_MAX;
+       cacheflush_time = (freq / 1000000) * (on_chip_cache << 10) / bandwidth;
+       cache_decay_ticks = cacheflush_time / (freq / 1000) * HZ / 1000;
 
-        printk("Using heuristic of %d cycles.\n",
-               cacheflush_time);
-#endif
+       printk("per-CPU timeslice cutoff: %ld.%02ld usecs.\n",
+              cacheflush_time/(freq/1000000),
+              (cacheflush_time*100/(freq/1000000)) % 100);
+       printk("task migration cache decay timeout: %ld msecs.\n",
+              (cache_decay_ticks + 1) * 1000 / HZ);
 }
 
 /*
@@ -505,14 +491,11 @@
        if (idle == &init_task)
                panic("idle process is init_task for CPU %d", cpuid);
 
-       idle->processor = cpuid;
-       idle->cpus_runnable = 1 << cpuid; /* we schedule the first task manually */
+       init_idle(idle, cpuid);
+       unhash_process(idle);
+
        __cpu_logical_map[cpunum] = cpuid;
        __cpu_number_map[cpuid] = cpunum;
- 
-       del_from_runqueue(idle);
-       unhash_process(idle);
-       init_tasks[cpunum] = idle;
 
        DBGS(("smp_boot_one_cpu: CPU %d state 0x%lx flags 0x%lx\n",
              cpuid, idle->state, idle->flags));
@@ -619,13 +602,10 @@
 
        __cpu_number_map[boot_cpuid] = 0;
        __cpu_logical_map[0] = boot_cpuid;
-       current->processor = boot_cpuid;
 
        smp_store_cpu_info(boot_cpuid);
        smp_tune_scheduling(boot_cpuid);
        smp_setup_percpu_timer(boot_cpuid);
-
-       init_idle();
 
        /* ??? This should be in init_idle.  */
        atomic_inc(&init_mm.mm_count);
diff -urN linux-2.4.20/arch/arm/config.in linux-2.4.20-o1-preempt/arch/arm/config.in
--- linux-2.4.20/arch/arm/config.in     Fri Nov 29 00:53:09 2002
+++ linux-2.4.20-o1-preempt/arch/arm/config.in  Tue Feb 18 03:52:06 2003
@@ -372,7 +372,7 @@
 else
    define_bool CONFIG_DISCONTIGMEM n
 fi
-
+dep_bool 'Preemptible Kernel' CONFIG_PREEMPT $CONFIG_CPU_32
 endmenu
 
 mainmenu_option next_comment
@@ -427,6 +427,8 @@
 bool 'System V IPC' CONFIG_SYSVIPC
 bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
 bool 'Sysctl support' CONFIG_SYSCTL
+int 'Maximum User Real-Time Priority' CONFIG_MAX_USER_RT_PRIO 100
+int 'Maximum Kernel Real-time Priority' CONFIG_MAX_RT_PRIO 0
 comment 'At least one math emulation must be selected'
 tristate 'NWFPE math emulation' CONFIG_FPE_NWFPE
 dep_tristate 'FastFPE math emulation (experimental)' CONFIG_FPE_FASTFPE $CONFIG_EXPERIMENTAL
diff -urN linux-2.4.20/arch/arm/kernel/entry-armv.S linux-2.4.20-o1-preempt/arch/arm/kernel/entry-armv.S
--- linux-2.4.20/arch/arm/kernel/entry-armv.S   Sat Aug  3 02:39:42 2002
+++ linux-2.4.20-o1-preempt/arch/arm/kernel/entry-armv.S        Tue Feb 18 03:52:07 2003
@@ -697,6 +697,12 @@
                add     r4, sp, #S_SP
                mov     r6, lr
                stmia   r4, {r5, r6, r7, r8, r9}        @ save sp_SVC, lr_SVC, pc, cpsr, old_ro
+#ifdef CONFIG_PREEMPT
+               get_current_task r9
+               ldr     r8, [r9, #TSK_PREEMPT]
+               add     r8, r8, #1
+               str     r8, [r9, #TSK_PREEMPT]
+#endif
 1:             get_irqnr_and_base r0, r6, r5, lr
                movne   r1, sp
                @
@@ -704,6 +710,25 @@
                @
                adrsvc  ne, lr, 1b
                bne     do_IRQ
+#ifdef CONFIG_PREEMPT
+2:             ldr     r8, [r9, #TSK_PREEMPT]
+               subs    r8, r8, #1
+               bne     3f
+               ldr     r7, [r9, #TSK_NEED_RESCHED]
+               teq     r7, #0
+               beq     3f
+               ldr     r6, .LCirqstat
+               ldr     r0, [r6, #IRQSTAT_BH_COUNT]
+               teq     r0, #0
+               bne     3f
+               mov     r0, #MODE_SVC
+               msr     cpsr_c, r0              @ enable interrupts
+               bl      SYMBOL_NAME(preempt_schedule)
+               mov     r0, #I_BIT | MODE_SVC
+               msr     cpsr_c, r0              @ disable interrupts
+               b       2b
+3:             str     r8, [r9, #TSK_PREEMPT]
+#endif
                ldr     r0, [sp, #S_PSR]                @ irqs are already disabled
                msr     spsr, r0
                ldmia   sp, {r0 - pc}^                  @ load r0 - pc, cpsr
@@ -761,6 +786,9 @@
 .LCprocfns:    .word   SYMBOL_NAME(processor)
 #endif
 .LCfp:         .word   SYMBOL_NAME(fp_enter)
+#ifdef CONFIG_PREEMPT
+.LCirqstat:    .word   SYMBOL_NAME(irq_stat)
+#endif
 
                irq_prio_table
 
@@ -801,6 +829,12 @@
                stmdb   r8, {sp, lr}^
                alignment_trap r4, r7, __temp_irq
                zero_fp
+               get_current_task tsk
+#ifdef CONFIG_PREEMPT
+               ldr     r0, [tsk, #TSK_PREEMPT]
+               add     r0, r0, #1
+               str     r0, [tsk, #TSK_PREEMPT]
+#endif
 1:             get_irqnr_and_base r0, r6, r5, lr
                movne   r1, sp
                adrsvc  ne, lr, 1b
@@ -808,8 +842,12 @@
                @ routine called with r0 = irq number, r1 = struct pt_regs *
                @
                bne     do_IRQ
+#ifdef CONFIG_PREEMPT
+               ldr     r0, [tsk, #TSK_PREEMPT]
+               sub     r0, r0, #1
+               str     r0, [tsk, #TSK_PREEMPT]
+#endif
                mov     why, #0
-               get_current_task tsk
                b       ret_to_user
 
                .align  5
diff -urN linux-2.4.20/arch/arm/kernel/process.c linux-2.4.20-o1-preempt/arch/arm/kernel/process.c
--- linux-2.4.20/arch/arm/kernel/process.c      Sat Aug  3 02:39:42 2002
+++ linux-2.4.20-o1-preempt/arch/arm/kernel/process.c   Tue Feb 18 03:51:29 2003
@@ -83,8 +83,6 @@
 {
        /* endless idle loop with no priority at all */
        init_idle();
-       current->nice = 20;
-       current->counter = -100;
 
        while (1) {
                void (*idle)(void) = pm_idle;
diff -urN linux-2.4.20/arch/arm/tools/getconstants.c linux-2.4.20-o1-preempt/arch/arm/tools/getconstants.c
--- linux-2.4.20/arch/arm/tools/getconstants.c  Thu Oct 11 18:04:57 2001
+++ linux-2.4.20-o1-preempt/arch/arm/tools/getconstants.c       Tue Feb 18 03:52:07 2003
@@ -13,6 +13,7 @@
 
 #include <asm/pgtable.h>
 #include <asm/uaccess.h>
+#include <asm/hardirq.h>
 
 /*
  * Make sure that the compiler and target are compatible.
@@ -38,6 +39,11 @@
 
 DEFN("TSS_SAVE",               OFF_TSK(thread.save));
 DEFN("TSS_FPESAVE",            OFF_TSK(thread.fpstate.soft.save));
+
+#ifdef CONFIG_PREEMPT
+DEFN("TSK_PREEMPT",            OFF_TSK(preempt_count));
+DEFN("IRQSTAT_BH_COUNT",       (unsigned long)&(((irq_cpustat_t *)0)->__local_bh_count));
+#endif
 
 #ifdef CONFIG_CPU_32
 DEFN("TSS_DOMAIN",             OFF_TSK(thread.domain));
diff -urN linux-2.4.20/arch/cris/config.in linux-2.4.20-o1-preempt/arch/cris/config.in
--- linux-2.4.20/arch/cris/config.in    Fri Nov 29 00:53:09 2002
+++ linux-2.4.20-o1-preempt/arch/cris/config.in Tue Feb 18 03:51:29 2003
@@ -29,6 +29,8 @@
 bool 'System V IPC' CONFIG_SYSVIPC
 bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
 bool 'Sysctl support' CONFIG_SYSCTL
+int 'Maximum User Real-Time Priority' CONFIG_MAX_USER_RT_PRIO 100
+int 'Maximum Kernel Real-time Priority' CONFIG_MAX_RT_PRIO 0
 
 tristate 'Kernel support for ELF binaries' CONFIG_BINFMT_ELF
 
diff -urN linux-2.4.20/arch/cris/kernel/process.c linux-2.4.20-o1-preempt/arch/cris/kernel/process.c
--- linux-2.4.20/arch/cris/kernel/process.c     Mon Feb 25 20:37:52 2002
+++ linux-2.4.20-o1-preempt/arch/cris/kernel/process.c  Tue Feb 18 03:51:29 2003
@@ -124,10 +124,10 @@
  
 int cpu_idle(void *unused)
 {
-       while(1) {
-               current->counter = -100;
+       init_idle();
+
+       while(1)
                schedule();
-       }
 }
 
 /* if the watchdog is enabled, we can simply disable interrupts and go
diff -urN linux-2.4.20/arch/i386/config.in linux-2.4.20-o1-preempt/arch/i386/config.in
--- linux-2.4.20/arch/i386/config.in    Fri Nov 29 00:53:09 2002
+++ linux-2.4.20-o1-preempt/arch/i386/config.in Tue Feb 18 03:52:06 2003
@@ -206,6 +206,7 @@
 bool 'Math emulation' CONFIG_MATH_EMULATION
 bool 'MTRR (Memory Type Range Register) support' CONFIG_MTRR
 bool 'Symmetric multi-processing support' CONFIG_SMP
+bool 'Preemptible Kernel' CONFIG_PREEMPT
 if [ "$CONFIG_SMP" != "y" ]; then
    bool 'Local APIC support on uniprocessors' CONFIG_X86_UP_APIC
    dep_bool 'IO-APIC support on uniprocessors' CONFIG_X86_UP_IOAPIC $CONFIG_X86_UP_APIC
@@ -224,9 +225,12 @@
    define_bool CONFIG_X86_TSC y
 fi
 
-if [ "$CONFIG_SMP" = "y" -a "$CONFIG_X86_CMPXCHG" = "y" ]; then
-   define_bool CONFIG_HAVE_DEC_LOCK y
+if [ "$CONFIG_SMP" = "y" -o "$CONFIG_PREEMPT" = "y" ]; then
+   if [ "$CONFIG_X86_CMPXCHG" = "y" ]; then
+      define_bool CONFIG_HAVE_DEC_LOCK y
+   fi
 fi
+
 endmenu
 
 mainmenu_option next_comment
@@ -286,6 +290,8 @@
 bool 'System V IPC' CONFIG_SYSVIPC
 bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
 bool 'Sysctl support' CONFIG_SYSCTL
+int 'Maximum User Real-Time Priority' CONFIG_MAX_USER_RT_PRIO 100
+int 'Maximum Kernel Real-time Priority' CONFIG_MAX_RT_PRIO 0
 if [ "$CONFIG_PROC_FS" = "y" ]; then
    choice 'Kernel core (/proc/kcore) format' \
        "ELF            CONFIG_KCORE_ELF        \
diff -urN linux-2.4.20/arch/i386/kernel/entry.S linux-2.4.20-o1-preempt/arch/i386/kernel/entry.S
--- linux-2.4.20/arch/i386/kernel/entry.S       Fri Nov 29 00:53:09 2002
+++ linux-2.4.20-o1-preempt/arch/i386/kernel/entry.S    Tue Feb 18 03:52:06 2003
@@ -73,16 +73,36 @@
  * these are offsets into the task-struct.
  */
 state          =  0
-flags          =  4
+preempt_count  =  4
 sigpending     =  8
 addr_limit     = 12
 exec_domain    = 16
 need_resched   = 20
 tsk_ptrace     = 24
-processor      = 52
+cpu            = 32
+
+/* These are offsets into the irq_stat structure
+ * There is one per cpu and it is aligned to 32
+ * byte boundry (we put that here as a shift count)
+ */
+irq_array_shift                 = CONFIG_X86_L1_CACHE_SHIFT
+
+irq_stat_local_irq_count        = 4
+irq_stat_local_bh_count         = 8
 
 ENOSYS = 38
 
+#ifdef CONFIG_SMP
+#define GET_CPU_INDX   movl cpu(%ebx),%eax;  \
+                        shll $irq_array_shift,%eax
+#define GET_CURRENT_CPU_INDX GET_CURRENT(%ebx); \
+                             GET_CPU_INDX
+#define CPU_INDX (,%eax)
+#else
+#define GET_CPU_INDX
+#define GET_CURRENT_CPU_INDX GET_CURRENT(%ebx)
+#define CPU_INDX
+#endif
 
 #define SAVE_ALL \
        cld; \
@@ -184,9 +204,11 @@
 
 
 ENTRY(ret_from_fork)
+#if CONFIG_SMP
        pushl %ebx
        call SYMBOL_NAME(schedule_tail)
        addl $4, %esp
+#endif
        GET_CURRENT(%ebx)
        testb $0x02,tsk_ptrace(%ebx)    # PT_TRACESYS
        jne tracesys_exit
@@ -255,12 +277,30 @@
        ALIGN
 ENTRY(ret_from_intr)
        GET_CURRENT(%ebx)
+#ifdef CONFIG_PREEMPT
+       cli
+       decl preempt_count(%ebx)
+#endif
 ret_from_exception:
        movl EFLAGS(%esp),%eax          # mix EFLAGS and CS
        movb CS(%esp),%al
        testl $(VM_MASK | 3),%eax       # return to VM86 mode or non-supervisor?
        jne ret_from_sys_call
+#ifdef CONFIG_PREEMPT
+       cmpl $0,preempt_count(%ebx)
+       jnz restore_all
+       cmpl $0,need_resched(%ebx)
+       jz restore_all
+       movl SYMBOL_NAME(irq_stat)+irq_stat_local_bh_count CPU_INDX,%ecx
+       addl SYMBOL_NAME(irq_stat)+irq_stat_local_irq_count CPU_INDX,%ecx
+       jnz restore_all
+       incl preempt_count(%ebx)
+       sti
+       call SYMBOL_NAME(preempt_schedule)
+       jmp ret_from_intr
+#else
        jmp restore_all
+#endif
 
        ALIGN
 reschedule:
@@ -297,6 +337,9 @@
        GET_CURRENT(%ebx)
        call *%edi
        addl $8,%esp
+#ifdef CONFIG_PREEMPT
+       cli
+#endif
        jmp ret_from_exception
 
 ENTRY(coprocessor_error)
@@ -316,12 +359,18 @@
        movl %cr0,%eax
        testl $0x4,%eax                 # EM (math emulation bit)
        jne device_not_available_emulate
+#ifdef CONFIG_PREEMPT
+       cli
+#endif
        call SYMBOL_NAME(math_state_restore)
        jmp ret_from_exception
 device_not_available_emulate:
        pushl $0                # temporary storage for ORIG_EIP
        call  SYMBOL_NAME(math_emulate)
        addl $4,%esp
+#ifdef CONFIG_PREEMPT
+       cli
+#endif
        jmp ret_from_exception
 
 ENTRY(debug)
@@ -645,8 +694,8 @@
        .long SYMBOL_NAME(sys_tkill)
        .long SYMBOL_NAME(sys_ni_syscall)       /* reserved for sendfile64 */
        .long SYMBOL_NAME(sys_ni_syscall)       /* 240 reserved for futex */
-       .long SYMBOL_NAME(sys_ni_syscall)       /* reserved for sched_setaffinity */
-       .long SYMBOL_NAME(sys_ni_syscall)       /* reserved for sched_getaffinity */
+       .long SYMBOL_NAME(sys_sched_setaffinity)
+       .long SYMBOL_NAME(sys_sched_getaffinity)
        .long SYMBOL_NAME(sys_ni_syscall)       /* sys_set_thread_area */
        .long SYMBOL_NAME(sys_ni_syscall)       /* sys_get_thread_area */
        .long SYMBOL_NAME(sys_ni_syscall)       /* 245 sys_io_setup */
diff -urN linux-2.4.20/arch/i386/kernel/i387.c linux-2.4.20-o1-preempt/arch/i386/kernel/i387.c
--- linux-2.4.20/arch/i386/kernel/i387.c        Sat Aug  3 02:39:42 2002
+++ linux-2.4.20-o1-preempt/arch/i386/kernel/i387.c     Tue Feb 18 03:52:07 2003
@@ -10,6 +10,7 @@
 
 #include <linux/config.h>
 #include <linux/sched.h>
+#include <linux/spinlock.h>
 #include <linux/init.h>
 #include <asm/processor.h>
 #include <asm/i387.h>
@@ -89,6 +90,8 @@
 {
        struct task_struct *tsk = current;
 
+       preempt_disable();
+       
        if (tsk->flags & PF_USEDFPU) {
                __save_init_fpu(tsk);
                return;
diff -urN linux-2.4.20/arch/i386/kernel/process.c linux-2.4.20-o1-preempt/arch/i386/kernel/process.c
--- linux-2.4.20/arch/i386/kernel/process.c     Sat Aug  3 02:39:42 2002
+++ linux-2.4.20-o1-preempt/arch/i386/kernel/process.c  Tue Feb 18 03:51:29 2003
@@ -82,7 +82,7 @@
 {
        if (current_cpu_data.hlt_works_ok && !hlt_counter) {
                __cli();
-               if (!current->need_resched)
+               if (!need_resched())
                        safe_halt();
                else
                        __sti();
@@ -124,15 +124,12 @@
 void cpu_idle (void)
 {
        /* endless idle loop with no priority at all */
-       init_idle();
-       current->nice = 20;
-       current->counter = -100;
 
        while (1) {
                void (*idle)(void) = pm_idle;
                if (!idle)
                        idle = default_idle;
-               while (!current->need_resched)
+               if (!current->need_resched)
                        idle();
                schedule();
                check_pgt_cache();
@@ -697,15 +694,17 @@
        asm volatile("movl %%gs,%0":"=m" (*(int *)&prev->gs));
 
        /*
-        * Restore %fs and %gs.
+        * Restore %fs and %gs if needed.
         */
-       loadsegment(fs, next->fs);
-       loadsegment(gs, next->gs);
+       if (unlikely(prev->fs | prev->gs | next->fs | next->gs)) {
+               loadsegment(fs, next->fs);
+               loadsegment(gs, next->gs);
+       }
 
        /*
         * Now maybe reload the debug registers
         */
-       if (next->debugreg[7]){
+       if (unlikely(next->debugreg[7])) {
                loaddebug(next, 0);
                loaddebug(next, 1);
                loaddebug(next, 2);
@@ -715,7 +714,7 @@
                loaddebug(next, 7);
        }
 
-       if (prev->ioperm || next->ioperm) {
+       if (unlikely(prev->ioperm || next->ioperm)) {
                if (next->ioperm) {
                        /*
                         * 4 cachelines copy ... not good, but not that
diff -urN linux-2.4.20/arch/i386/kernel/setup.c linux-2.4.20-o1-preempt/arch/i386/kernel/setup.c
--- linux-2.4.20/arch/i386/kernel/setup.c       Fri Nov 29 00:53:09 2002
+++ linux-2.4.20-o1-preempt/arch/i386/kernel/setup.c    Tue Feb 18 03:51:29 2003
@@ -3046,9 +3046,10 @@
        load_TR(nr);
        load_LDT(&init_mm);
 
-       /*
-        * Clear all 6 debug registers:
-        */
+       /* Clear %fs and %gs. */
+       asm volatile ("xorl %eax, %eax; movl %eax, %fs; movl %eax, %gs");
+
+       /* Clear all 6 debug registers: */
 
 #define CD(register) __asm__("movl %0,%%db" #register ::"r"(0) );
 
diff -urN linux-2.4.20/arch/i386/kernel/smp.c linux-2.4.20-o1-preempt/arch/i386/kernel/smp.c
--- linux-2.4.20/arch/i386/kernel/smp.c Fri Nov 29 00:53:09 2002
+++ linux-2.4.20-o1-preempt/arch/i386/kernel/smp.c      Tue Feb 18 03:52:06 2003
@@ -357,10 +357,13 @@
 
 asmlinkage void smp_invalidate_interrupt (void)
 {
-       unsigned long cpu = smp_processor_id();
+       unsigned long cpu;
+        
+       preempt_disable();
 
+       cpu = smp_processor_id();
        if (!test_bit(cpu, &flush_cpumask))
-               return;
+               goto out;
                /* 
                 * This was a BUG() but until someone can quote me the
                 * line from the intel manual that guarantees an IPI to
@@ -381,6 +384,8 @@
        }
        ack_APIC_irq();
        clear_bit(cpu, &flush_cpumask);
+out:
+       preempt_enable();
 }
 
 static void flush_tlb_others (unsigned long cpumask, struct mm_struct *mm,
@@ -430,17 +435,22 @@
 void flush_tlb_current_task(void)
 {
        struct mm_struct *mm = current->mm;
-       unsigned long cpu_mask = mm->cpu_vm_mask & ~(1 << smp_processor_id());
+       unsigned long cpu_mask;
 
+        preempt_disable();
+        cpu_mask = mm->cpu_vm_mask & ~(1UL << smp_processor_id());
        local_flush_tlb();
        if (cpu_mask)
                flush_tlb_others(cpu_mask, mm, FLUSH_ALL);
+        preempt_enable();
 }
 
 void flush_tlb_mm (struct mm_struct * mm)
 {
-       unsigned long cpu_mask = mm->cpu_vm_mask & ~(1 << smp_processor_id());
+       unsigned long cpu_mask;
 
+        preempt_disable();
+        cpu_mask = mm->cpu_vm_mask & ~(1UL << smp_processor_id());
        if (current->active_mm == mm) {
                if (current->mm)
                        local_flush_tlb();
@@ -449,13 +459,16 @@
        }
        if (cpu_mask)
                flush_tlb_others(cpu_mask, mm, FLUSH_ALL);
+        preempt_enable();
 }
 
 void flush_tlb_page(struct vm_area_struct * vma, unsigned long va)
 {
        struct mm_struct *mm = vma->vm_mm;
-       unsigned long cpu_mask = mm->cpu_vm_mask & ~(1 << smp_processor_id());
+       unsigned long cpu_mask;
 
+        preempt_disable();
+        cpu_mask = mm->cpu_vm_mask & ~(1UL << smp_processor_id());
        if (current->active_mm == mm) {
                if(current->mm)
                        __flush_tlb_one(va);
@@ -465,6 +478,7 @@
 
        if (cpu_mask)
                flush_tlb_others(cpu_mask, mm, va);
+        preempt_enable();
 }
 
 static inline void do_flush_tlb_all_local(void)
@@ -493,10 +507,20 @@
  * it goes straight through and wastes no time serializing
  * anything. Worst case is that we lose a reschedule ...
  */
-
 void smp_send_reschedule(int cpu)
 {
        send_IPI_mask(1 << cpu, RESCHEDULE_VECTOR);
+}
+
+/*
+ * this function sends a reschedule IPI to all (other) CPUs.
+ * This should only be used if some 'global' task became runnable,
+ * such as a RT task, that must be handled now. The first CPU
+ * that manages to grab the task will run it.
+ */
+void smp_send_reschedule_all(void)
+{
+       send_IPI_allbutself(RESCHEDULE_VECTOR);
 }
 
 /*
diff -urN linux-2.4.20/arch/i386/kernel/smpboot.c linux-2.4.20-o1-preempt/arch/i386/kernel/smpboot.c
--- linux-2.4.20/arch/i386/kernel/smpboot.c     Fri Nov 29 00:53:09 2002
+++ linux-2.4.20-o1-preempt/arch/i386/kernel/smpboot.c  Tue Feb 18 03:51:29 2003
@@ -308,14 +308,14 @@
                        if (tsc_values[i] < avg)
                                realdelta = -realdelta;
 
-                       printk("BIOS BUG: CPU#%d improperly initialized, has %ld usecs TSC skew! FIXED.\n",
-                               i, realdelta);
+                       printk("BIOS BUG: CPU#%d improperly initialized, has %ld usecs TSC skew! FIXED.\n", i, realdelta);
                }
 
                sum += delta;
        }
        if (!buggy)
                printk("passed.\n");
+               ;
 }
 
 static void __init synchronize_tsc_ap (void)
@@ -365,7 +365,7 @@
         * (This works even if the APIC is not enabled.)
         */
        phys_id = GET_APIC_ID(apic_read(APIC_ID));
-       cpuid = current->processor;
+       cpuid = cpu();
        if (test_and_set_bit(cpuid, &cpu_online_map)) {
                printk("huh, phys CPU#%d, CPU#%d already present??\n",
                                        phys_id, cpuid);
@@ -435,6 +435,7 @@
         */
        smp_store_cpu_info(cpuid);
 
+       disable_APIC_timer();
        /*
         * Allow the master to continue.
         */
@@ -465,6 +466,7 @@
        smp_callin();
        while (!atomic_read(&smp_commenced))
                rep_nop();
+       enable_APIC_timer();
        /*
         * low-memory mappings have been cleared, flush them from
         * the local TLBs too.
@@ -803,16 +805,13 @@
        if (!idle)
                panic("No idle process for CPU %d", cpu);
 
-       idle->processor = cpu;
-       idle->cpus_runnable = 1 << cpu; /* we schedule the first task manually */
+       init_idle(idle, cpu);
 
        map_cpu_to_boot_apicid(cpu, apicid);
 
        idle->thread.eip = (unsigned long) start_secondary;
 
-       del_from_runqueue(idle);
        unhash_process(idle);
-       init_tasks[cpu] = idle;
 
        /* start_eip had better be page-aligned! */
        start_eip = setup_trampoline();
@@ -925,6 +924,7 @@
 }
 
 cycles_t cacheflush_time;
+unsigned long cache_decay_ticks;
 
 static void smp_tune_scheduling (void)
 {
@@ -958,9 +958,13 @@
                cacheflush_time = (cpu_khz>>10) * (cachesize<<10) / bandwidth;
        }
 
+       cache_decay_ticks = (long)cacheflush_time/cpu_khz * HZ / 1000;
+
        printk("per-CPU timeslice cutoff: %ld.%02ld usecs.\n",
                (long)cacheflush_time/(cpu_khz/1000),
                ((long)cacheflush_time*100/(cpu_khz/1000)) % 100);
+       printk("task migration cache decay timeout: %ld msecs.\n",
+               (cache_decay_ticks + 1) * 1000 / HZ);
 }
 
 /*
@@ -1023,8 +1027,7 @@
        map_cpu_to_boot_apicid(0, boot_cpu_apicid);
 
        global_irq_holder = 0;
-       current->processor = 0;
-       init_idle();
+       current->cpu = 0;
        smp_tune_scheduling();
 
        /*
diff -urN linux-2.4.20/arch/i386/kernel/traps.c linux-2.4.20-o1-preempt/arch/i386/kernel/traps.c
--- linux-2.4.20/arch/i386/kernel/traps.c       Fri Nov 29 00:53:09 2002
+++ linux-2.4.20-o1-preempt/arch/i386/kernel/traps.c    Tue Feb 18 03:52:07 2003
@@ -751,6 +751,8 @@
  *
  * Careful.. There are problems with IBM-designed IRQ13 behaviour.
  * Don't touch unless you *really* know how it works.
+ *
+ * Must be called with kernel preemption disabled.
  */
 asmlinkage void math_state_restore(struct pt_regs regs)
 {
diff -urN linux-2.4.20/arch/i386/lib/dec_and_lock.c linux-2.4.20-o1-preempt/arch/i386/lib/dec_and_lock.c
--- linux-2.4.20/arch/i386/lib/dec_and_lock.c   Sat Jul  8 03:20:16 2000
+++ linux-2.4.20-o1-preempt/arch/i386/lib/dec_and_lock.c        Tue Feb 18 03:52:07 2003
@@ -8,6 +8,7 @@
  */
 
 #include <linux/spinlock.h>
+#include <linux/sched.h>
 #include <asm/atomic.h>
 
 int atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock)
diff -urN linux-2.4.20/arch/ia64/config.in linux-2.4.20-o1-preempt/arch/ia64/config.in
--- linux-2.4.20/arch/ia64/config.in    Fri Nov 29 00:53:09 2002
+++ linux-2.4.20-o1-preempt/arch/ia64/config.in Tue Feb 18 03:51:29 2003
@@ -102,6 +102,8 @@
 bool 'System V IPC' CONFIG_SYSVIPC
 bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
 bool 'Sysctl support' CONFIG_SYSCTL
+int 'Maximum User Real-Time Priority' CONFIG_MAX_USER_RT_PRIO 100
+int 'Maximum Kernel Real-time Priority' CONFIG_MAX_RT_PRIO 0
 tristate 'Kernel support for ELF binaries' CONFIG_BINFMT_ELF
 tristate 'Kernel support for MISC binaries' CONFIG_BINFMT_MISC
 
diff -urN linux-2.4.20/arch/m68k/config.in linux-2.4.20-o1-preempt/arch/m68k/config.in
--- linux-2.4.20/arch/m68k/config.in    Fri Nov 29 00:53:09 2002
+++ linux-2.4.20-o1-preempt/arch/m68k/config.in Tue Feb 18 03:51:29 2003
@@ -92,6 +92,8 @@
 bool 'System V IPC' CONFIG_SYSVIPC
 bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
 bool 'Sysctl support' CONFIG_SYSCTL
+int 'Maximum User Real-Time Priority' CONFIG_MAX_USER_RT_PRIO 100
+int 'Maximum Kernel Real-time Priority' CONFIG_MAX_RT_PRIO 0
 if [ "$CONFIG_PROC_FS" = "y" ]; then
    choice 'Kernel core (/proc/kcore) format' \
        "ELF            CONFIG_KCORE_ELF        \
diff -urN linux-2.4.20/arch/mips/config-shared.in linux-2.4.20-o1-preempt/arch/mips/config-shared.in
--- linux-2.4.20/arch/mips/config-shared.in     Fri Nov 29 00:53:09 2002
+++ linux-2.4.20-o1-preempt/arch/mips/config-shared.in  Tue Feb 18 03:52:06 2003
@@ -615,9 +615,12 @@
    define_bool CONFIG_HOTPLUG_PCI n
 fi
 
+dep_bool 'Preemptible Kernel' CONFIG_PREEMPT $CONFIG_NEW_IRQ
 bool 'System V IPC' CONFIG_SYSVIPC
 bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
 bool 'Sysctl support' CONFIG_SYSCTL
+int 'Maximum User Real-Time Priority' CONFIG_MAX_USER_RT_PRIO 100
+int 'Maximum Kernel Real-time Priority' CONFIG_MAX_RT_PRIO 0
 define_bool CONFIG_KCORE_ELF y
 define_bool CONFIG_KCORE_AOUT n
 define_bool CONFIG_BINFMT_AOUT n
diff -urN linux-2.4.20/arch/mips/kernel/i8259.c linux-2.4.20-o1-preempt/arch/mips/kernel/i8259.c
--- linux-2.4.20/arch/mips/kernel/i8259.c       Fri Nov 29 00:53:10 2002
+++ linux-2.4.20-o1-preempt/arch/mips/kernel/i8259.c    Tue Feb 18 03:52:07 2003
@@ -8,6 +8,7 @@
  * Copyright (C) 1992 Linus Torvalds
  * Copyright (C) 1994 - 2000 Ralf Baechle
  */
+#include <linux/sched.h>
 #include <linux/delay.h>
 #include <linux/init.h>
 #include <linux/ioport.h>
diff -urN linux-2.4.20/arch/mips/kernel/irq.c linux-2.4.20-o1-preempt/arch/mips/kernel/irq.c
--- linux-2.4.20/arch/mips/kernel/irq.c Fri Nov 29 00:53:10 2002
+++ linux-2.4.20-o1-preempt/arch/mips/kernel/irq.c      Tue Feb 18 03:52:07 2003
@@ -8,6 +8,8 @@
  * Copyright (C) 1992 Linus Torvalds
  * Copyright (C) 1994 - 2000 Ralf Baechle
  */
+
+#include <linux/sched.h>
 #include <linux/config.h>
 #include <linux/kernel.h>
 #include <linux/delay.h>
@@ -19,11 +21,13 @@
 #include <linux/slab.h>
 #include <linux/mm.h>
 #include <linux/random.h>
-#include <linux/sched.h>
+#include <linux/spinlock.h>
+#include <linux/ptrace.h>
 
 #include <asm/atomic.h>
 #include <asm/system.h>
 #include <asm/uaccess.h>
+#include <asm/debug.h>
 
 /*
  * Controller mappings for all interrupt sources:
@@ -429,6 +433,8 @@
        struct irqaction * action;
        unsigned int status;
 
+       preempt_disable();
+
        kstat.irqs[cpu][irq]++;
        spin_lock(&desc->lock);
        desc->handler->ack(irq);
@@ -490,6 +496,27 @@
 
        if (softirq_pending(cpu))
                do_softirq();
+
+#if defined(CONFIG_PREEMPT)
+       while (--current->preempt_count == 0) {
+               db_assert(intr_off());
+               db_assert(!in_interrupt());
+
+               if (current->need_resched == 0) {
+                       break;
+               }
+
+               current->preempt_count ++;
+               sti();
+               if (user_mode(regs)) {
+                       schedule();
+               } else {
+                       preempt_schedule();
+               }
+               cli();
+       }
+#endif
+
        return 1;
 }
 
diff -urN linux-2.4.20/arch/mips/mm/extable.c linux-2.4.20-o1-preempt/arch/mips/mm/extable.c
--- linux-2.4.20/arch/mips/mm/extable.c Fri Nov 29 00:53:10 2002
+++ linux-2.4.20-o1-preempt/arch/mips/mm/extable.c      Tue Feb 18 03:52:07 2003
@@ -3,6 +3,7 @@
  */
 #include <linux/config.h>
 #include <linux/module.h>
+#include <linux/sched.h>
 #include <linux/spinlock.h>
 #include <asm/uaccess.h>
 
diff -urN linux-2.4.20/arch/mips64/kernel/process.c linux-2.4.20-o1-preempt/arch/mips64/kernel/process.c
--- linux-2.4.20/arch/mips64/kernel/process.c   Fri Nov 29 00:53:10 2002
+++ linux-2.4.20-o1-preempt/arch/mips64/kernel/process.c        Tue Feb 18 03:51:29 2003
@@ -35,8 +35,7 @@
 {
        /* endless idle loop with no priority at all */
        init_idle();
-       current->nice = 20;
-       current->counter = -100;
+
        while (1) {
                while (!current->need_resched)
                        if (cpu_wait)
diff -urN linux-2.4.20/arch/parisc/config.in linux-2.4.20-o1-preempt/arch/parisc/config.in
--- linux-2.4.20/arch/parisc/config.in  Fri Nov 29 00:53:10 2002
+++ linux-2.4.20-o1-preempt/arch/parisc/config.in       Tue Feb 18 03:51:29 2003
@@ -83,6 +83,8 @@
 bool 'System V IPC' CONFIG_SYSVIPC
 bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
 bool 'Sysctl support' CONFIG_SYSCTL
+int 'Maximum User Real-Time Priority' CONFIG_MAX_USER_RT_PRIO 100
+int 'Maximum Kernel Real-time Priority' CONFIG_MAX_RT_PRIO 0
 define_bool CONFIG_KCORE_ELF y
 tristate 'Kernel support for ELF binaries' CONFIG_BINFMT_ELF
 tristate 'Kernel support for SOM binaries' CONFIG_BINFMT_SOM
diff -urN linux-2.4.20/arch/parisc/kernel/process.c linux-2.4.20-o1-preempt/arch/parisc/kernel/process.c
--- linux-2.4.20/arch/parisc/kernel/process.c   Fri Nov 29 00:53:10 2002
+++ linux-2.4.20-o1-preempt/arch/parisc/kernel/process.c        Tue Feb 18 03:51:29 2003
@@ -64,8 +64,6 @@
 {
        /* endless idle loop with no priority at all */
        init_idle();
-       current->nice = 20;
-       current->counter = -100;
 
        while (1) {
                while (!current->need_resched) {
diff -urN linux-2.4.20/arch/ppc/8260_io/uart.c linux-2.4.20-o1-preempt/arch/ppc/8260_io/uart.c
--- linux-2.4.20/arch/ppc/8260_io/uart.c        Sat Aug  3 02:39:43 2002
+++ linux-2.4.20-o1-preempt/arch/ppc/8260_io/uart.c     Tue Feb 18 03:51:29 2003
@@ -1732,7 +1732,6 @@
                printk("lsr = %d (jiff=%lu)...", lsr, jiffies);
 #endif
                current->state = TASK_INTERRUPTIBLE;
-/*             current->counter = 0;    make us low-priority */
                schedule_timeout(char_time);
                if (signal_pending(current))
                        break;
diff -urN linux-2.4.20/arch/ppc/8xx_io/uart.c linux-2.4.20-o1-preempt/arch/ppc/8xx_io/uart.c
--- linux-2.4.20/arch/ppc/8xx_io/uart.c Sat Aug  3 02:39:43 2002
+++ linux-2.4.20-o1-preempt/arch/ppc/8xx_io/uart.c      Tue Feb 18 03:51:29 2003
@@ -1796,7 +1796,6 @@
                printk("lsr = %d (jiff=%lu)...", lsr, jiffies);
 #endif
                current->state = TASK_INTERRUPTIBLE;
-/*             current->counter = 0;    make us low-priority */
                schedule_timeout(char_time);
                if (signal_pending(current))
                        break;
diff -urN linux-2.4.20/arch/ppc/config.in linux-2.4.20-o1-preempt/arch/ppc/config.in
--- linux-2.4.20/arch/ppc/config.in     Fri Nov 29 00:53:11 2002
+++ linux-2.4.20-o1-preempt/arch/ppc/config.in  Tue Feb 18 03:52:06 2003
@@ -112,6 +112,8 @@
   bool '  Distribute interrupts on all CPUs by default' CONFIG_IRQ_ALL_CPUS
 fi
 
+bool 'Preemptible kernel support' CONFIG_PREEMPT
+
 if [ "$CONFIG_6xx" = "y" -a "$CONFIG_8260" = "n" ];then
   bool 'AltiVec Support' CONFIG_ALTIVEC
   bool 'Thermal Management Support' CONFIG_TAU
@@ -163,6 +165,8 @@
 bool 'Sysctl support' CONFIG_SYSCTL
 bool 'System V IPC' CONFIG_SYSVIPC
 bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
+int 'Maximum User Real-Time Priority' CONFIG_MAX_USER_RT_PRIO 100
+int 'Maximum Kernel Real-time Priority' CONFIG_MAX_RT_PRIO 0
 
 # only elf supported, a.out is not -- Cort
 if [ "$CONFIG_PROC_FS" = "y" ]; then
diff -urN linux-2.4.20/arch/ppc/kernel/entry.S linux-2.4.20-o1-preempt/arch/ppc/kernel/entry.S
--- linux-2.4.20/arch/ppc/kernel/entry.S        Fri Nov 29 00:53:11 2002
+++ linux-2.4.20-o1-preempt/arch/ppc/kernel/entry.S     Tue Feb 18 03:52:07 2003
@@ -264,7 +264,9 @@
 
        .globl  ret_from_fork
 ret_from_fork:
+#if CONFIG_SMP
        bl      schedule_tail
+#endif
        lwz     r0,TASK_PTRACE(r2)
        andi.   r0,r0,PT_TRACESYS
        bnel-   syscall_trace
@@ -278,6 +278,41 @@
         */
        cmpi    0,r3,0
        beq     restore
+#ifdef CONFIG_PREEMPT
+       lwz     r3,PREEMPT_COUNT(r2)
+       cmpi    0,r3,1
+       bge     ret_from_except
+       lwz     r5,_MSR(r1)
+       andi.   r5,r5,MSR_PR
+       bne     do_signal_ret
+       lwz     r5,NEED_RESCHED(r2)
+       cmpi    0,r5,0
+       beq     ret_from_except
+       lis     r3,irq_stat@h
+       ori     r3,r3,irq_stat@l
+       lwz     r5,4(r3)
+       lwz     r3,8(r3)
+       add     r3,r3,r5
+       cmpi    0,r3,0
+       bne     ret_from_except
+       lwz     r3,PREEMPT_COUNT(r2)
+       addi    r3,r3,1
+       stw     r3,PREEMPT_COUNT(r2)
+       mfmsr   r0
+       ori     r0,r0,MSR_EE
+       mtmsr   r0
+       sync
+       bl      preempt_schedule
+       mfmsr   r0
+       rlwinm  r0,r0,0,17,15
+       mtmsr   r0
+       sync
+       lwz     r3,PREEMPT_COUNT(r2)
+       subi    r3,r3,1
+       stw     r3,PREEMPT_COUNT(r2)
+       li      r3,1
+       b       ret_from_intercept
+#endif /* CONFIG_PREEMPT */
        .globl  ret_from_except
 ret_from_except:
        lwz     r3,_MSR(r1)     /* Returning to user mode? */
diff -urN linux-2.4.20/arch/ppc/kernel/idle.c linux-2.4.20-o1-preempt/arch/ppc/kernel/idle.c
--- linux-2.4.20/arch/ppc/kernel/idle.c Fri Nov 29 00:53:11 2002
+++ linux-2.4.20-o1-preempt/arch/ppc/kernel/idle.c      Tue Feb 18 03:51:29 2003
@@ -51,9 +51,7 @@
                do_power_save = 1;
 
        /* endless loop with no priority at all */
-       current->nice = 20;
-       current->counter = -100;
-       init_idle();
+
        for (;;) {
 #ifdef CONFIG_SMP
                if (!do_power_save) {
diff -urN linux-2.4.20/arch/ppc/kernel/irq.c linux-2.4.20-o1-preempt/arch/ppc/kernel/irq.c
--- linux-2.4.20/arch/ppc/kernel/irq.c  Fri Nov 29 00:53:11 2002
+++ linux-2.4.20-o1-preempt/arch/ppc/kernel/irq.c       Tue Feb 18 03:52:07 2003
@@ -556,6 +556,34 @@
        return 1; /* lets ret_from_int know we can do checks */
 }
 
+#ifdef CONFIG_PREEMPT
+int
+preempt_intercept(struct pt_regs *regs)
+{
+       int ret;
+
+       preempt_disable();
+
+       switch(regs->trap) {
+       case 0x500:
+               ret = do_IRQ(regs);
+               break;
+#ifndef CONFIG_4xx
+       case 0x900:
+#else
+       case 0x1000:
+#endif
+               ret = timer_interrupt(regs);
+               break;
+       default:
+               BUG();
+       }
+
+       preempt_enable();
+       return ret;
+}
+#endif /* CONFIG_PREEMPT */
+
 unsigned long probe_irq_on (void)
 {
        return 0;
diff -urN linux-2.4.20/arch/ppc/kernel/misc.S linux-2.4.20-o1-preempt/arch/ppc/kernel/misc.S
--- linux-2.4.20/arch/ppc/kernel/misc.S Fri Nov 29 00:53:11 2002
+++ linux-2.4.20-o1-preempt/arch/ppc/kernel/misc.S      Tue Feb 18 03:51:29 2003
@@ -1174,8 +1174,8 @@
        .long sys_lremovexattr
        .long sys_fremovexattr  /* 220  */
        .long sys_ni_syscall    /*      reserved for sys_futex */
-       .long sys_ni_syscall    /*      reserved for sys_sched_setaffinity */
-       .long sys_ni_syscall    /*      reserved for sys_sched_getaffinity */
+       .long sys_sched_setaffinity
+       .long sys_sched_getaffinity
        .long sys_ni_syscall    /*      reserved for sys_security */
        .long sys_ni_syscall    /* 225  reserved for Tux */
        .long sys_ni_syscall    /*      reserved for sys_sendfile64 */
diff -urN linux-2.4.20/arch/ppc/kernel/mk_defs.c linux-2.4.20-o1-preempt/arch/ppc/kernel/mk_defs.c
--- linux-2.4.20/arch/ppc/kernel/mk_defs.c      Tue Aug 28 15:58:33 2001
+++ linux-2.4.20-o1-preempt/arch/ppc/kernel/mk_defs.c   Tue Feb 18 03:52:06 2003
@@ -37,11 +37,14 @@
        /*DEFINE(KERNELBASE, KERNELBASE);*/
        DEFINE(STATE, offsetof(struct task_struct, state));
        DEFINE(NEXT_TASK, offsetof(struct task_struct, next_task));
-       DEFINE(COUNTER, offsetof(struct task_struct, counter));
-       DEFINE(PROCESSOR, offsetof(struct task_struct, processor));
+       DEFINE(COUNTER, offsetof(struct task_struct, time_slice));
+       DEFINE(PROCESSOR, offsetof(struct task_struct, cpu));
        DEFINE(SIGPENDING, offsetof(struct task_struct, sigpending));
        DEFINE(THREAD, offsetof(struct task_struct, thread));
        DEFINE(MM, offsetof(struct task_struct, mm));
+#ifdef CONFIG_PREEMPT
+       DEFINE(PREEMPT_COUNT, offsetof(struct task_struct, preempt_count));
+#endif
        DEFINE(ACTIVE_MM, offsetof(struct task_struct, active_mm));
        DEFINE(TASK_STRUCT_SIZE, sizeof(struct task_struct));
        DEFINE(KSP, offsetof(struct thread_struct, ksp));
diff -urN linux-2.4.20/arch/ppc/kernel/ppc_ksyms.c linux-2.4.20-o1-preempt/arch/ppc/kernel/ppc_ksyms.c
--- linux-2.4.20/arch/ppc/kernel/ppc_ksyms.c    Fri Nov 29 00:53:11 2002
+++ linux-2.4.20-o1-preempt/arch/ppc/kernel/ppc_ksyms.c Tue Feb 18 03:51:29 2003
@@ -366,3 +366,4 @@
 EXPORT_SYMBOL_NOVERS(agp_special_page);
 #endif /* defined(CONFIG_ALL_PPC) */
 
+EXPORT_SYMBOL(ioremap_bot);
diff -urN linux-2.4.20/arch/ppc/kernel/process.c linux-2.4.20-o1-preempt/arch/ppc/kernel/process.c
--- linux-2.4.20/arch/ppc/kernel/process.c      Mon Nov 26 14:29:17 2001
+++ linux-2.4.20-o1-preempt/arch/ppc/kernel/process.c   Tue Feb 18 03:51:29 2003
@@ -270,7 +270,7 @@
 #endif
        
 #ifdef CONFIG_SMP
-       printk(" CPU: %d", current->processor);
+       printk(" CPU: %d", current->cpu);
 #endif /* CONFIG_SMP */
        
        printk("\n");
diff -urN linux-2.4.20/arch/ppc/kernel/setup.c linux-2.4.20-o1-preempt/arch/ppc/kernel/setup.c
--- linux-2.4.20/arch/ppc/kernel/setup.c        Fri Nov 29 00:53:11 2002
+++ linux-2.4.20-o1-preempt/arch/ppc/kernel/setup.c     Tue Feb 18 03:52:07 2003
@@ -498,6 +498,20 @@
        strcpy(cmd_line, CONFIG_CMDLINE);
 #endif /* CONFIG_CMDLINE */
 
+#ifdef CONFIG_PREEMPT
+       /* Override the irq routines for external & timer interrupts here,
+        * as the MMU has only been minimally setup at this point and
+        * there are no protections on page zero.
+        */
+       {
+               extern int preempt_intercept(struct pt_regs *);
+       
+               do_IRQ_intercept = (unsigned long) &preempt_intercept;
+               timer_interrupt_intercept = (unsigned long) &preempt_intercept;
+
+       }
+#endif /* CONFIG_PREEMPT */
+
        platform_init(r3, r4, r5, r6, r7);
 
        if (ppc_md.progress)
diff -urN linux-2.4.20/arch/ppc/kernel/smp.c linux-2.4.20-o1-preempt/arch/ppc/kernel/smp.c
--- linux-2.4.20/arch/ppc/kernel/smp.c  Sat Aug  3 02:39:43 2002
+++ linux-2.4.20-o1-preempt/arch/ppc/kernel/smp.c       Tue Feb 18 03:51:29 2003
@@ -54,6 +54,7 @@
 unsigned long cpu_online_map;
 int smp_hw_index[NR_CPUS];
 static struct smp_ops_t *smp_ops;
+unsigned long cache_decay_ticks;
 
 /* all cpu mappings are 1-1 -- Cort */
 volatile unsigned long cpu_callin_map[NR_CPUS];
@@ -292,9 +293,7 @@
         * cpu 0, the master -- Cort
         */
        cpu_callin_map[0] = 1;
-       current->processor = 0;
-
-       init_idle();
+       current->cpu = 0;
 
        for (i = 0; i < NR_CPUS; i++) {
                prof_counter[i] = 1;
@@ -306,6 +305,7 @@
         * timebase increments every 4 bus cycles, 32kB L1 data cache.
         */
        cacheflush_time = 5 * 1024;
+       cache_decay_ticks = cacheflush_time/5 * HZ / 1000;
 
        smp_ops = ppc_md.smp_ops;
        if (smp_ops == NULL) {
@@ -348,12 +348,9 @@
                p = init_task.prev_task;
                if (!p)
                        panic("No idle task for CPU %d", i);
-               del_from_runqueue(p);
+               init_idle(p, i);
                unhash_process(p);
-               init_tasks[i] = p;
 
-               p->processor = i;
-               p->cpus_runnable = 1 << i; /* we schedule the first task manually */
                current_set[i] = p;
 
                /*
@@ -502,7 +499,7 @@
 
 void __init smp_callin(void)
 {
-       int cpu = current->processor;
+       int cpu = current->cpu;
        
         smp_store_cpu_info(cpu);
        set_dec(tb_ticks_per_jiffy);
diff -urN linux-2.4.20/arch/ppc/lib/dec_and_lock.c linux-2.4.20-o1-preempt/arch/ppc/lib/dec_and_lock.c
--- linux-2.4.20/arch/ppc/lib/dec_and_lock.c    Fri Nov 16 19:10:08 2001
+++ linux-2.4.20-o1-preempt/arch/ppc/lib/dec_and_lock.c Tue Feb 18 03:52:07 2003
@@ -1,4 +1,5 @@
 #include <linux/module.h>
+#include <linux/sched.h>
 #include <linux/spinlock.h>
 #include <asm/atomic.h>
 #include <asm/system.h>
diff -urN linux-2.4.20/arch/ppc/mm/init.c linux-2.4.20-o1-preempt/arch/ppc/mm/init.c
--- linux-2.4.20/arch/ppc/mm/init.c     Sat Aug  3 02:39:43 2002
+++ linux-2.4.20-o1-preempt/arch/ppc/mm/init.c  Tue Feb 18 03:51:29 2003
@@ -168,9 +168,9 @@
                {
                        int iscur = 0;
 #ifdef CONFIG_SMP
-                       printk("%3d ", p->processor);
-                       if ( (p->processor != NO_PROC_ID) &&
-                            (p == current_set[p->processor]) )
+                       printk("%3d ", p->cpu);
+                       if ( (p->cpu != NO_PROC_ID) &&
+                            (p == current_set[p->cpu]) )
                        {
                                iscur = 1;
                                printk("current");
--- linux-2.4.20/arch/ppc64/kernel/entry.S.orig Fri Nov 29 00:53:11 2002
+++ linux-2.4.20/arch/ppc64/kernel/entry.S      Fri Mar  7 23:47:29 2003
@@ -292,7 +292,9 @@
        blr
 
 _GLOBAL(ret_from_fork)
+#if CONFIG_SMP
        bl      .schedule_tail
+#endif
        ld      r0,TASK_PTRACE(r13)
        andi.   r0,r0,PT_TRACESYS
        beq+    .ret_from_except
diff -urN linux-2.4.20/arch/ppc64/kernel/idle.c linux-2.4.20-o1-preempt/arch/ppc64/kernel/idle.c
--- linux-2.4.20/arch/ppc64/kernel/idle.c       Sat Aug  3 02:39:43 2002
+++ linux-2.4.20-o1-preempt/arch/ppc64/kernel/idle.c    Tue Feb 18 03:51:29 2003
@@ -76,9 +76,6 @@
        unsigned long CTRL;
 #endif
 
-       /* endless loop with no priority at all */
-       current->nice = 20;
-       current->counter = -100;
 #ifdef CONFIG_PPC_ISERIES
        /* ensure iSeries run light will be out when idle */
        current->thread.flags &= ~PPC_FLAG_RUN_LIGHT;
@@ -86,7 +83,7 @@
        CTRL &= ~RUNLATCH;
        mtspr(CTRLT, CTRL);
 #endif
-       init_idle();    
+       /* endless loop with no priority at all */
 
        lpaca = get_paca();
 
diff -urN linux-2.4.20/arch/ppc64/kernel/process.c linux-2.4.20-o1-preempt/arch/ppc64/kernel/process.c
--- linux-2.4.20/arch/ppc64/kernel/process.c    Fri Nov 29 00:53:11 2002
+++ linux-2.4.20-o1-preempt/arch/ppc64/kernel/process.c Tue Feb 18 03:51:29 2003
@@ -105,7 +105,7 @@
 #ifdef SHOW_TASK_SWITCHES
        printk("%s/%d -> %s/%d NIP %08lx cpu %d root %x/%x\n",
               prev->comm,prev->pid,
-              new->comm,new->pid,new->thread.regs->nip,new->processor,
+              new->comm,new->pid,new->thread.regs->nip,new->cpu,
               new->fs->root,prev->fs->root);
 #endif
 #ifdef CONFIG_SMP
diff -urN linux-2.4.20/arch/ppc64/kernel/smp.c linux-2.4.20-o1-preempt/arch/ppc64/kernel/smp.c
--- linux-2.4.20/arch/ppc64/kernel/smp.c        Fri Nov 29 00:53:11 2002
+++ linux-2.4.20-o1-preempt/arch/ppc64/kernel/smp.c     Tue Feb 18 03:51:29 2003
@@ -69,6 +69,7 @@
 extern atomic_t ipi_sent;
 spinlock_t kernel_flag __cacheline_aligned = SPIN_LOCK_UNLOCKED;
 cycles_t cacheflush_time;
+unsigned long cache_decay_ticks;
 static int max_cpus __initdata = NR_CPUS;
 
 unsigned long cpu_online_map;
@@ -611,9 +612,7 @@
         * cpu 0, the master -- Cort
         */
        cpu_callin_map[0] = 1;
-       current->processor = 0;
-
-       init_idle();
+       current->cpu = 0;
 
        for (i = 0; i < NR_CPUS; i++) {
                paca[i].prof_counter = 1;
@@ -637,6 +636,7 @@
         * timebase increments every 4 bus cycles, 32kB L1 data cache.
         */
        cacheflush_time = 5 * 1024;
+       cache_decay_ticks = cacheflush_time/5 * HZ / 1000;
 
        /* Probe arch for CPUs */
        cpu_nr = ppc_md.smp_probe();
@@ -684,12 +684,9 @@
 
                PPCDBG(PPCDBG_SMP,"\tProcessor %d, task = 0x%lx\n", i, p);
 
-               del_from_runqueue(p);
+               init_idle(p, i);
                unhash_process(p);
-               init_tasks[i] = p;
 
-               p->processor = i;
-               p->cpus_runnable = 1 << i; /* we schedule the first task manually */
                current_set[i].task = p;
                sp = ((unsigned long)p) + sizeof(union task_union)
                        - STACK_FRAME_OVERHEAD;
@@ -740,15 +737,13 @@
 
 void __init smp_callin(void)
 {
-       int cpu = current->processor;
+       int cpu = current->cpu;
        
         smp_store_cpu_info(cpu);
        set_dec(paca[cpu].default_decr);
        cpu_callin_map[cpu] = 1;
 
        ppc_md.smp_setup_cpu(cpu);
-
-       init_idle();
 
        set_bit(smp_processor_id(), &cpu_online_map);
        
diff -urN linux-2.4.20/arch/s390/config.in linux-2.4.20-o1-preempt/arch/s390/config.in
--- linux-2.4.20/arch/s390/config.in    Fri Nov 29 00:53:11 2002
+++ linux-2.4.20-o1-preempt/arch/s390/config.in Tue Feb 18 03:51:29 2003
@@ -49,6 +49,8 @@
 bool 'System V IPC' CONFIG_SYSVIPC
 bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
 bool 'Sysctl support' CONFIG_SYSCTL
+int 'Maximum User Real-Time Priority' CONFIG_MAX_USER_RT_PRIO 100
+int 'Maximum Kernel Real-time Priority' CONFIG_MAX_RT_PRIO 0
 define_bool CONFIG_KCORE_ELF y
 tristate 'Kernel support for ELF binaries' CONFIG_BINFMT_ELF
 tristate 'Kernel support for MISC binaries' CONFIG_BINFMT_MISC
diff -urN linux-2.4.20/arch/s390/kernel/process.c linux-2.4.20-o1-preempt/arch/s390/kernel/process.c
--- linux-2.4.20/arch/s390/kernel/process.c     Sat Aug  3 02:39:43 2002
+++ linux-2.4.20-o1-preempt/arch/s390/kernel/process.c  Tue Feb 18 03:51:29 2003
@@ -57,8 +57,7 @@
 
        /* endless idle loop with no priority at all */
         init_idle();
-       current->nice = 20;
-       current->counter = -100;
+
        while (1) {
                if (current->need_resched) {
                        schedule();
diff -urN linux-2.4.20/arch/s390x/config.in linux-2.4.20-o1-preempt/arch/s390x/config.in
--- linux-2.4.20/arch/s390x/config.in   Fri Nov 29 00:53:11 2002
+++ linux-2.4.20-o1-preempt/arch/s390x/config.in        Tue Feb 18 03:51:29 2003
@@ -52,6 +52,8 @@
 bool 'System V IPC' CONFIG_SYSVIPC
 bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
 bool 'Sysctl support' CONFIG_SYSCTL
+int 'Maximum User Real-Time Priority' CONFIG_MAX_USER_RT_PRIO 100
+int 'Maximum Kernel Real-time Priority' CONFIG_MAX_RT_PRIO 0
 define_bool CONFIG_KCORE_ELF y
 tristate 'Kernel support for ELF binaries' CONFIG_BINFMT_ELF
 tristate 'Kernel support for MISC binaries' CONFIG_BINFMT_MISC
diff -urN linux-2.4.20/arch/s390x/kernel/process.c linux-2.4.20-o1-preempt/arch/s390x/kernel/process.c
--- linux-2.4.20/arch/s390x/kernel/process.c    Fri Nov 29 00:53:11 2002
+++ linux-2.4.20-o1-preempt/arch/s390x/kernel/process.c Tue Feb 18 03:51:29 2003
@@ -57,8 +57,7 @@
 
        /* endless idle loop with no priority at all */
         init_idle();
-       current->nice = 20;
-       current->counter = -100;
+
        while (1) {
                if (current->need_resched) {
                        schedule();
diff -urN linux-2.4.20/arch/sh/config.in linux-2.4.20-o1-preempt/arch/sh/config.in
--- linux-2.4.20/arch/sh/config.in      Fri Nov 29 00:53:11 2002
+++ linux-2.4.20-o1-preempt/arch/sh/config.in   Tue Feb 18 03:52:06 2003
@@ -124,6 +124,7 @@
    hex 'Physical memory start address' CONFIG_MEMORY_START 08000000
    hex 'Physical memory size' CONFIG_MEMORY_SIZE 00400000
 fi
+bool 'Preemptible Kernel' CONFIG_PREEMPT
 endmenu
 
 if [ "$CONFIG_SH_HP690" = "y" ]; then
@@ -205,6 +206,8 @@
 bool 'System V IPC' CONFIG_SYSVIPC
 bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
 bool 'Sysctl support' CONFIG_SYSCTL
+int 'Maximum User Real-Time Priority' CONFIG_MAX_USER_RT_PRIO 100
+int 'Maximum Kernel Real-time Priority' CONFIG_MAX_RT_PRIO 0
 if [ "$CONFIG_PROC_FS" = "y" ]; then
    choice 'Kernel core (/proc/kcore) format' \
        "ELF            CONFIG_KCORE_ELF        \
diff -urN linux-2.4.20/arch/sh/kernel/entry.S linux-2.4.20-o1-preempt/arch/sh/kernel/entry.S
--- linux-2.4.20/arch/sh/kernel/entry.S Sat Aug  3 02:39:43 2002
+++ linux-2.4.20-o1-preempt/arch/sh/kernel/entry.S      Tue Feb 18 03:52:07 2003
@@ -60,10 +60,18 @@
 /*
  * These are offsets into the task-struct.
  */
-flags          =  4
+preempt_count  =  4
 sigpending     =  8
 need_resched   = 20
 tsk_ptrace     = 24
+flags          = 84
+
+/*
+ * These offsets are into irq_stat.
+ * (Find irq_cpustat_t in asm-sh/hardirq.h)
+ */
+local_irq_count =  8
+local_bh_count  = 12
 
 PT_TRACESYS  = 0x00000002
 PF_USEDFPU   = 0x00100000
@@ -143,7 +151,7 @@
        mov.l   __INV_IMASK, r11;       \
        stc     sr, r10;                \
        and     r11, r10;               \
-       stc     k_g_imask, r11; \
+       stc     k_g_imask, r11;         \
        or      r11, r10;               \
        ldc     r10, sr
 
@@ -304,8 +312,8 @@
        mov.l   @(tsk_ptrace,r0), r0    ! Is current PTRACE_SYSCALL'd?
        mov     #PT_TRACESYS, r1
        tst     r1, r0
-       bt      ret_from_syscall
-       bra     syscall_ret_trace
+       bf      syscall_ret_trace
+       bra     ret_from_syscall
         nop     
 
        .align  2
@@ -505,8 +513,6 @@
        .long   syscall_ret_trace
 __syscall_ret:
        .long   syscall_ret
-__INV_IMASK:
-       .long   0xffffff0f      ! ~(IMASK)
 
 
        .align  2
@@ -518,7 +524,84 @@
        .align  2
 1:     .long   SYMBOL_NAME(schedule)
 
+#ifdef CONFIG_PREEMPT  
+       !
+       ! Returning from interrupt during kernel mode: check if
+       ! preempt_schedule should be called. If need_resched flag
+       ! is set, preempt_count is zero, and we're not currently
+       ! in an interrupt handler (local irq or bottom half) then
+       ! call preempt_schedule. 
+       !
+       ! Increment preempt_count to prevent a nested interrupt
+       ! from reentering preempt_schedule, then decrement after
+       ! and drop through to regular interrupt return which will
+       ! jump back and check again in case such an interrupt did
+       ! come in (and didn't preempt due to preempt_count).
+       !
+       ! NOTE: because we just checked that preempt_count was
+       ! zero before getting to the call, can't we use immediate
+       ! values (1 and 0) rather than inc/dec? Also, rather than
+       ! drop through to ret_from_irq, we already know this thread
+       ! is kernel mode, can't we go direct to ret_from_kirq? In
+       ! fact, with proper interrupt nesting and so forth could
+       ! the loop simply be on the need_resched w/o checking the
+       ! other stuff again? Optimize later...
+       !
+       .align  2
+ret_from_kirq:
+       ! Nonzero preempt_count prevents scheduling
+       stc     k_current, r1
+       mov.l   @(preempt_count,r1), r0
+       cmp/eq  #0, r0
+       bf      restore_all
+       ! Zero need_resched prevents scheduling
+       mov.l   @(need_resched,r1), r0
+       cmp/eq  #0, r0
+       bt      restore_all
+       ! If in_interrupt(), don't schedule
+       mov.l   __irq_stat, r1
+       mov.l   @(local_irq_count,r1), r0
+       mov.l   @(local_bh_count,r1), r1
+       or      r1, r0
+       cmp/eq  #0, r0
+       bf      restore_all
+       ! Allow scheduling using preempt_schedule
+       ! Adjust preempt_count and SR as needed.
+       stc     k_current, r1
+       mov.l   @(preempt_count,r1), r0 ! Could replace this ...
+       add     #1, r0                  ! ... and this w/mov #1?
+       mov.l   r0, @(preempt_count,r1)
+       STI()
+       mov.l   __preempt_schedule, r0
+       jsr     @r0
+        nop    
+       /* CLI */
+       stc     sr, r0
+       or      #0xf0, r0
+       ldc     r0, sr
+       !
+       stc     k_current, r1
+       mov.l   @(preempt_count,r1), r0 ! Could replace this ...
+       add     #-1, r0                 ! ... and this w/mov #0?
+       mov.l   r0, @(preempt_count,r1)
+       ! Maybe should bra ret_from_kirq, or loop over need_resched?
+       ! For now, fall through to ret_from_irq again...
+#endif /* CONFIG_PREEMPT */
+       
 ret_from_irq:
+       mov     #OFF_SR, r0
+       mov.l   @(r0,r15), r0   ! get status register
+       shll    r0
+       shll    r0              ! kernel space?
+#ifndef CONFIG_PREEMPT
+       bt      restore_all     ! Yes, it's from kernel, go back soon
+#else /* CONFIG_PREEMPT */
+       bt      ret_from_kirq   ! From kernel: maybe preempt_schedule
+#endif /* CONFIG_PREEMPT */
+       !
+       bra     ret_from_syscall
+        nop
+
 ret_from_exception:
        mov     #OFF_SR, r0
        mov.l   @(r0,r15), r0   ! get status register
@@ -564,6 +647,13 @@
        .long   SYMBOL_NAME(do_signal)
 __irq_stat:
        .long   SYMBOL_NAME(irq_stat)
+#ifdef CONFIG_PREEMPT
+__preempt_schedule:
+       .long   SYMBOL_NAME(preempt_schedule)
+#endif /* CONFIG_PREEMPT */    
+__INV_IMASK:
+       .long   0xffffff0f      ! ~(IMASK)
+
 
        .align 2
 restore_all:
@@ -679,7 +769,7 @@
 __fpu_prepare_fd:
        .long   SYMBOL_NAME(fpu_prepare_fd)
 __init_task_flags:
-       .long   SYMBOL_NAME(init_task_union)+4
+       .long   SYMBOL_NAME(init_task_union)+flags
 __PF_USEDFPU:
        .long   PF_USEDFPU
 #endif
diff -urN linux-2.4.20/arch/sh/kernel/irq.c linux-2.4.20-o1-preempt/arch/sh/kernel/irq.c
--- linux-2.4.20/arch/sh/kernel/irq.c   Sat Sep  8 21:29:09 2001
+++ linux-2.4.20-o1-preempt/arch/sh/kernel/irq.c        Tue Feb 18 03:52:07 2003
@@ -229,6 +229,14 @@
        struct irqaction * action;
        unsigned int status;
 
+       /*
+        * At this point we're now about to actually call handlers,
+        * and interrupts might get reenabled during them... bump
+        * preempt_count to prevent any preemption while the handler
+        * called here is pending...
+        */
+       preempt_disable();
+
        /* Get IRQ number */
        asm volatile("stc       r2_bank, %0\n\t"
                     "shlr2     %0\n\t"
@@ -298,8 +306,17 @@
        desc->handler->end(irq);
        spin_unlock(&desc->lock);
 
+
        if (softirq_pending(cpu))
                do_softirq();
+
+       /*
+        * We're done with the handlers, interrupts should be
+        * currently disabled; decrement preempt_count now so
+        * as we return preemption may be allowed...
+        */
+       preempt_enable_no_resched();
+
        return 1;
 }
 
diff -urN linux-2.4.20/arch/sh/kernel/process.c linux-2.4.20-o1-preempt/arch/sh/kernel/process.c
--- linux-2.4.20/arch/sh/kernel/process.c       Mon Oct 15 22:36:48 2001
+++ linux-2.4.20-o1-preempt/arch/sh/kernel/process.c    Tue Feb 18 03:51:29 2003
@@ -40,8 +40,6 @@
 {
        /* endless idle loop with no priority at all */
        init_idle();
-       current->nice = 20;
-       current->counter = -100;
 
        while (1) {
                if (hlt_counter) {
diff -urN linux-2.4.20/arch/sparc/config.in linux-2.4.20-o1-preempt/arch/sparc/config.in
--- linux-2.4.20/arch/sparc/config.in   Fri Nov 29 00:53:12 2002
+++ linux-2.4.20-o1-preempt/arch/sparc/config.in        Tue Feb 18 03:51:29 2003
@@ -65,6 +65,8 @@
 bool 'System V IPC' CONFIG_SYSVIPC
 bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
 bool 'Sysctl support' CONFIG_SYSCTL
+int 'Maximum User Real-Time Priority' CONFIG_MAX_USER_RT_PRIO 100
+int 'Maximum Kernel Real-time Priority' CONFIG_MAX_RT_PRIO 0
 if [ "$CONFIG_PROC_FS" = "y" ]; then
    define_bool CONFIG_KCORE_ELF y
 fi
diff -urN linux-2.4.20/arch/sparc/kernel/process.c linux-2.4.20-o1-preempt/arch/sparc/kernel/process.c
--- linux-2.4.20/arch/sparc/kernel/process.c    Sat Aug  3 02:39:43 2002
+++ linux-2.4.20-o1-preempt/arch/sparc/kernel/process.c Tue Feb 18 03:51:29 2003
@@ -74,9 +74,6 @@
                goto out;
 
        /* endless idle loop with no priority at all */
-       current->nice = 20;
-       current->counter = -100;
-       init_idle();
 
        for (;;) {
                if (ARCH_SUN4C_SUN4) {
@@ -128,9 +125,6 @@
 int cpu_idle(void)
 {
        /* endless idle loop with no priority at all */
-       current->nice = 20;
-       current->counter = -100;
-       init_idle();
 
        while(1) {
                if(current->need_resched) {
diff -urN linux-2.4.20/arch/sparc/kernel/smp.c linux-2.4.20-o1-preempt/arch/sparc/kernel/smp.c
--- linux-2.4.20/arch/sparc/kernel/smp.c        Fri Dec 21 18:41:53 2001
+++ linux-2.4.20-o1-preempt/arch/sparc/kernel/smp.c     Tue Feb 18 03:51:29 2003
@@ -57,6 +57,7 @@
 volatile int __cpu_number_map[NR_CPUS];
 volatile int __cpu_logical_map[NR_CPUS];
 cycles_t cacheflush_time = 0; /* XXX */
+unsigned long cache_decay_ticks = 0; /* XXX */
 
 /* The only guaranteed locking primitive available on all Sparc
  * processors is 'ldstub [%reg + immediate], %dest_reg' which atomically
diff -urN linux-2.4.20/arch/sparc/kernel/sun4d_smp.c linux-2.4.20-o1-preempt/arch/sparc/kernel/sun4d_smp.c
--- linux-2.4.20/arch/sparc/kernel/sun4d_smp.c  Sat Aug  3 02:39:43 2002
+++ linux-2.4.20-o1-preempt/arch/sparc/kernel/sun4d_smp.c       Tue Feb 18 03:51:29 2003
@@ -107,7 +107,6 @@
         * the SMP initialization the master will be just allowed
         * to call the scheduler code.
         */
-       init_idle();
 
        /* Get our local ticker going. */
        smp_setup_percpu_timer();
@@ -127,7 +126,7 @@
        while((unsigned long)current_set[cpuid] < PAGE_OFFSET)
                barrier();
                
-       while(current_set[cpuid]->processor != cpuid)
+       while(current_set[cpuid]->cpu != cpuid)
                barrier();
                
        /* Fix idle thread fields. */
@@ -197,10 +196,8 @@
                mid_xlate[i] = i;
        __cpu_number_map[boot_cpu_id] = 0;
        __cpu_logical_map[0] = boot_cpu_id;
-       current->processor = boot_cpu_id;
        smp_store_cpu_info(boot_cpu_id);
        smp_setup_percpu_timer();
-       init_idle();
        local_flush_cache_all();
        if(linux_num_cpus == 1)
                return;  /* Not an MP box. */
@@ -222,15 +219,11 @@
                        cpucount++;
 
                        p = init_task.prev_task;
-                       init_tasks[i] = p;
 
-                       p->processor = i;
-                       p->cpus_runnable = 1 << i; /* we schedule the first task manually */
+                       init_idle(p, i);
+                       unhash_process(p);
 
                        current_set[i] = p;
-
-                       del_from_runqueue(p);
-                       unhash_process(p);
 
                        for (no = 0; no < linux_num_cpus; no++)
                                if (linux_cpus[no].mid == i)
diff -urN linux-2.4.20/arch/sparc/kernel/sun4m_smp.c linux-2.4.20-o1-preempt/arch/sparc/kernel/sun4m_smp.c
--- linux-2.4.20/arch/sparc/kernel/sun4m_smp.c  Wed Nov 21 19:31:09 2001
+++ linux-2.4.20-o1-preempt/arch/sparc/kernel/sun4m_smp.c       Tue Feb 18 03:51:29 2003
@@ -104,7 +104,6 @@
         * the SMP initialization the master will be just allowed
         * to call the scheduler code.
         */
-       init_idle();
 
        /* Allow master to continue. */
        swap((unsigned long *)&cpu_callin_map[cpuid], 1);
@@ -170,12 +169,10 @@
        mid_xlate[boot_cpu_id] = (linux_cpus[boot_cpu_id].mid & ~8);
        __cpu_number_map[boot_cpu_id] = 0;
        __cpu_logical_map[0] = boot_cpu_id;
-       current->processor = boot_cpu_id;
 
        smp_store_cpu_info(boot_cpu_id);
        set_irq_udt(mid_xlate[boot_cpu_id]);
        smp_setup_percpu_timer();
-       init_idle();
        local_flush_cache_all();
        if(linux_num_cpus == 1)
                return;  /* Not an MP box. */
@@ -195,15 +192,11 @@
                        cpucount++;
 
                        p = init_task.prev_task;
-                       init_tasks[i] = p;
 
-                       p->processor = i;
-                       p->cpus_runnable = 1 << i; /* we schedule the first task manually */
+                       init_idle(p, i);
+                       unhash_process(p);
 
                        current_set[i] = p;
-
-                       del_from_runqueue(p);
-                       unhash_process(p);
 
                        /* See trampoline.S for details... */
                        entry += ((i-1) * 3);
diff -urN linux-2.4.20/arch/sparc64/config.in linux-2.4.20-o1-preempt/arch/sparc64/config.in
--- linux-2.4.20/arch/sparc64/config.in Fri Nov 29 00:53:12 2002
+++ linux-2.4.20-o1-preempt/arch/sparc64/config.in      Tue Feb 18 03:51:29 2003
@@ -64,6 +64,8 @@
 bool 'System V IPC' CONFIG_SYSVIPC
 bool 'BSD Process Accounting' CONFIG_BSD_PROCESS_ACCT
 bool 'Sysctl support' CONFIG_SYSCTL
+int 'Maximum User Real-Time Priority' CONFIG_MAX_USER_RT_PRIO 100
+int 'Maximum Kernel Real-time Priority' CONFIG_MAX_RT_PRIO 0
 if [ "$CONFIG_PROC_FS" = "y" ]; then
    define_bool CONFIG_KCORE_ELF y
 fi
diff -urN linux-2.4.20/arch/sparc64/kernel/irq.c linux-2.4.20-o1-preempt/arch/sparc64/kernel/irq.c
--- linux-2.4.20/arch/sparc64/kernel/irq.c      Fri Nov 29 00:53:12 2002
+++ linux-2.4.20-o1-preempt/arch/sparc64/kernel/irq.c   Tue Feb 18 03:51:29 2003
@@ -162,7 +162,7 @@
                tid = ((tid & UPA_CONFIG_MID) << 9);
                tid &= IMAP_TID_UPA;
        } else {
-               tid = (starfire_translate(imap, current->processor) << 26);
+               tid = (starfire_translate(imap, current->cpu) << 26);
                tid &= IMAP_TID_UPA;
        }
 
diff -urN linux-2.4.20/arch/sparc64/kernel/process.c linux-2.4.20-o1-preempt/arch/sparc64/kernel/process.c
--- linux-2.4.20/arch/sparc64/kernel/process.c  Fri Nov 29 00:53:12 2002
+++ linux-2.4.20-o1-preempt/arch/sparc64/kernel/process.c       Tue Feb 18 03:51:29 2003
@@ -53,9 +53,6 @@
                return -EPERM;
 
        /* endless idle loop with no priority at all */
-       current->nice = 20;
-       current->counter = -100;
-       init_idle();
 
        for (;;) {
                /* If current->need_resched is zero we should really
@@ -79,14 +76,10 @@
 /*
  * the idle loop on a UltraMultiPenguin...
  */
-#define idle_me_harder()       (cpu_data[current->processor].idle_volume += 1)
-#define unidle_me()            (cpu_data[current->processor].idle_volume = 0)
+#define idle_me_harder()       (cpu_data[current->cpu].idle_volume += 1)
+#define unidle_me()            (cpu_data[current->cpu].idle_volume = 0)
 int cpu_idle(void)
 {
-       current->nice = 20;
-       current->counter = -100;
-       init_idle();
-
        while(1) {
                if (current->need_resched != 0) {
                        unidle_me();
diff -urN linux-2.4.20/arch/sparc64/kernel/smp.c linux-2.4.20-o1-preempt/arch/sparc64/kernel/smp.c
--- linux-2.4.20/arch/sparc64/kernel/smp.c      Fri Nov 29 00:53:12 2002
+++ linux-2.4.20-o1-preempt/arch/sparc64/kernel/smp.c   Tue Feb 18 03:51:29 2003
@@ -49,6 +49,8 @@
 static unsigned char boot_cpu_id;
 static int smp_activated;
 
+unsigned long cache_decay_ticks = 0; /* XXX */
+
 /* Kernel spinlock */
 spinlock_t kernel_flag __cacheline_aligned_in_smp = SPIN_LOCK_UNLOCKED;
 
@@ -259,7 +261,6 @@
        printk("Entering UltraSMPenguin Mode...\n");
        __sti();
        smp_store_cpu_info(boot_cpu_id);
-       init_idle();
 
        if (linux_num_cpus == 1)
                return;
@@ -282,12 +283,8 @@
                        cpucount++;
 
                        p = init_task.prev_task;
-                       init_tasks[cpucount] = p;
-
-                       p->processor = i;
-                       p->cpus_runnable = 1UL << i; /* we schedule the first task manually */
 
-                       del_from_runqueue(p);
+                       init_idle(p, i);
                        unhash_process(p);
 
                        callin_flag = 0;
@@ -1154,7 +1151,6 @@
        __cpu_number_map[boot_cpu_id] = 0;
        prom_cpu_nodes[boot_cpu_id] = linux_cpus[0].prom_node;
        __cpu_logical_map[0] = boot_cpu_id;
-       current->processor = boot_cpu_id;
        prof_counter(boot_cpu_id) = prof_multiplier(boot_cpu_id) = 1;
 }
 
diff -urN linux-2.4.20/drivers/block/loop.c linux-2.4.20-o1-preempt/drivers/block/loop.c
--- linux-2.4.20/drivers/block/loop.c   Fri Nov 29 00:53:12 2002
+++ linux-2.4.20-o1-preempt/drivers/block/loop.c        Tue Feb 18 03:51:29 2003
@@ -571,9 +571,6 @@
        flush_signals(current);
        spin_unlock_irq(&current->sigmask_lock);
 
-       current->policy = SCHED_OTHER;
-       current->nice = -20;
-
        spin_lock_irq(&lo->lo_lock);
        lo->lo_state = Lo_bound;
        atomic_inc(&lo->lo_pending);
diff -urN linux-2.4.20/drivers/char/drm-4.0/tdfx_drv.c linux-2.4.20-o1-preempt/drivers/char/drm-4.0/tdfx_drv.c
--- linux-2.4.20/drivers/char/drm-4.0/tdfx_drv.c        Fri Nov 29 00:53:12 2002
+++ linux-2.4.20-o1-preempt/drivers/char/drm-4.0/tdfx_drv.c     Tue Feb 18 03:51:29 2003
@@ -554,7 +554,6 @@
                                        lock.context, current->pid, j,
                                        dev->lock.lock_time, jiffies);
                                 current->state = TASK_INTERRUPTIBLE;
-                               current->policy |= SCHED_YIELD;
                                 schedule_timeout(DRM_LOCK_SLICE-j);
                                DRM_DEBUG("jiffies=%d\n", jiffies);
                         }
diff -urN linux-2.4.20/drivers/char/mwave/mwavedd.c linux-2.4.20-o1-preempt/drivers/char/mwave/mwavedd.c
--- linux-2.4.20/drivers/char/mwave/mwavedd.c   Mon Feb 25 20:37:57 2002
+++ linux-2.4.20-o1-preempt/drivers/char/mwave/mwavedd.c        Tue Feb 18 03:51:29 2003
@@ -279,7 +279,6 @@
                        pDrvData->IPCs[ipcnum].bIsHere = FALSE;
                        pDrvData->IPCs[ipcnum].bIsEnabled = TRUE;
        #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,4,0)
-                       current->nice = -20;    /* boost to provide priority timing */
        #else
                        current->priority = 0x28;       /* boost to provide priority timing */
        #endif
diff -urN linux-2.4.20/drivers/char/serial_txx927.c linux-2.4.20-o1-preempt/drivers/char/serial_txx927.c
--- linux-2.4.20/drivers/char/serial_txx927.c   Sat Aug  3 02:39:43 2002
+++ linux-2.4.20-o1-preempt/drivers/char/serial_txx927.c        Tue Feb 18 03:51:29 2003
@@ -1533,7 +1533,6 @@
                printk("cisr = %d (jiff=%lu)...", cisr, jiffies);
 #endif
                current->state = TASK_INTERRUPTIBLE;
-               current->counter = 0;   /* make us low-priority */
                schedule_timeout(char_time);
                if (signal_pending(current))
                        break;
diff -urN linux-2.4.20/drivers/ieee1394/csr.c linux-2.4.20-o1-preempt/drivers/ieee1394/csr.c
--- linux-2.4.20/drivers/ieee1394/csr.c Fri Nov 29 00:53:13 2002
+++ linux-2.4.20-o1-preempt/drivers/ieee1394/csr.c      Tue Feb 18 03:52:07 2003
@@ -10,6 +10,7 @@
  */
 
 #include <linux/string.h>
+#include <linux/sched.h>
 
 #include "ieee1394_types.h"
 #include "hosts.h"
diff -urN linux-2.4.20/drivers/md/md.c linux-2.4.20-o1-preempt/drivers/md/md.c
--- linux-2.4.20/drivers/md/md.c        Fri Nov 29 00:53:13 2002
+++ linux-2.4.20-o1-preempt/drivers/md/md.c     Tue Feb 18 03:51:29 2003
@@ -2936,8 +2936,6 @@
         * bdflush, otherwise bdflush will deadlock if there are too
         * many dirty RAID5 blocks.
         */
-       current->policy = SCHED_OTHER;
-       current->nice = -20;
        md_unlock_kernel();
 
        complete(thread->event);
@@ -3391,11 +3389,6 @@
               "(but not more than %d KB/sec) for reconstruction.\n",
               sysctl_speed_limit_max);
 
-       /*
-        * Resync has low priority.
-        */
-       current->nice = 19;
-
        is_mddev_idle(mddev); /* this also initializes IO event counters */
        for (m = 0; m < SYNC_MARKS; m++) {
                mark[m] = jiffies;
@@ -3473,16 +3466,13 @@
                currspeed = (j-mddev->resync_mark_cnt)/2/((jiffies-mddev->resync_mark)/HZ +1) +1;
 
                if (currspeed > sysctl_speed_limit_min) {
-                       current->nice = 19;
-
                        if ((currspeed > sysctl_speed_limit_max) ||
                                        !is_mddev_idle(mddev)) {
                                current->state = TASK_INTERRUPTIBLE;
                                md_schedule_timeout(HZ/4);
                                goto repeat;
                        }
-               } else
-                       current->nice = -20;
+               }
        }
        printk(KERN_INFO "md: md%d: sync done.\n",mdidx(mddev));
        err = 0;
diff -urN linux-2.4.20/drivers/sound/sound_core.c linux-2.4.20-o1-preempt/drivers/sound/sound_core.c
--- linux-2.4.20/drivers/sound/sound_core.c     Sun Sep 30 21:26:08 2001
+++ linux-2.4.20-o1-preempt/drivers/sound/sound_core.c  Tue Feb 18 03:52:07 2003
@@ -37,6 +37,7 @@
 #include <linux/config.h>
 #include <linux/module.h>
 #include <linux/init.h>
+#include <linux/sched.h>
 #include <linux/slab.h>
 #include <linux/types.h>
 #include <linux/kernel.h>
diff -urN linux-2.4.20/fs/adfs/map.c linux-2.4.20-o1-preempt/fs/adfs/map.c
--- linux-2.4.20/fs/adfs/map.c  Thu Oct 25 22:53:53 2001
+++ linux-2.4.20-o1-preempt/fs/adfs/map.c       Tue Feb 18 03:52:07 2003
@@ -12,6 +12,7 @@
 #include <linux/fs.h>
 #include <linux/adfs_fs.h>
 #include <linux/spinlock.h>
+#include <linux/sched.h>
 
 #include "adfs.h"
 
diff -urN linux-2.4.20/fs/binfmt_elf.c linux-2.4.20-o1-preempt/fs/binfmt_elf.c
--- linux-2.4.20/fs/binfmt_elf.c        Sat Aug  3 02:39:45 2002
+++ linux-2.4.20-o1-preempt/fs/binfmt_elf.c     Tue Feb 18 03:51:29 2003
@@ -1143,7 +1143,7 @@
        psinfo.pr_state = i;
        psinfo.pr_sname = (i < 0 || i > 5) ? '.' : "RSDZTD"[i];
        psinfo.pr_zomb = psinfo.pr_sname == 'Z';
-       psinfo.pr_nice = current->nice;
+       psinfo.pr_nice = task_nice(current);
        psinfo.pr_flag = current->flags;
        psinfo.pr_uid = NEW_TO_OLD_UID(current->uid);
        psinfo.pr_gid = NEW_TO_OLD_GID(current->gid);
diff -urN linux-2.4.20/fs/exec.c linux-2.4.20-o1-preempt/fs/exec.c
--- linux-2.4.20/fs/exec.c      Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/fs/exec.c   Tue Feb 18 03:52:07 2003
@@ -440,8 +440,8 @@
                active_mm = current->active_mm;
                current->mm = mm;
                current->active_mm = mm;
-               task_unlock(current);
                activate_mm(active_mm, mm);
+               task_unlock(current);
                mm_release();
                if (old_mm) {
                        if (active_mm != old_mm) BUG();
diff -urN linux-2.4.20/fs/fat/cache.c linux-2.4.20-o1-preempt/fs/fat/cache.c
--- linux-2.4.20/fs/fat/cache.c Fri Oct 12 22:48:42 2001
+++ linux-2.4.20-o1-preempt/fs/fat/cache.c      Tue Feb 18 03:52:07 2003
@@ -14,6 +14,7 @@
 #include <linux/string.h>
 #include <linux/stat.h>
 #include <linux/fat_cvf.h>
+#include <linux/sched.h>
 
 #if 0
 #  define PRINTK(x) printk x
diff -urN linux-2.4.20/fs/jffs2/background.c linux-2.4.20-o1-preempt/fs/jffs2/background.c
--- linux-2.4.20/fs/jffs2/background.c  Thu Oct 25 09:07:09 2001
+++ linux-2.4.20-o1-preempt/fs/jffs2/background.c       Tue Feb 18 03:51:29 2003
@@ -106,9 +106,6 @@
 
         sprintf(current->comm, "jffs2_gcd_mtd%d", c->mtd->index);
 
-       /* FIXME in the 2.2 backport */
-       current->nice = 10;
-
        for (;;) {
                spin_lock_irq(&current->sigmask_lock);
                siginitsetinv (&current->blocked, sigmask(SIGHUP) | sigmask(SIGKILL) | sigmask(SIGSTOP) | sigmask(SIGCONT));
diff -urN linux-2.4.20/fs/nls/nls_base.c linux-2.4.20-o1-preempt/fs/nls/nls_base.c
--- linux-2.4.20/fs/nls/nls_base.c      Sat Aug  3 02:39:45 2002
+++ linux-2.4.20-o1-preempt/fs/nls/nls_base.c   Tue Feb 18 03:52:07 2003
@@ -18,6 +18,7 @@
 #ifdef CONFIG_KMOD
 #include <linux/kmod.h>
 #endif
+#include <linux/sched.h>
 #include <linux/spinlock.h>
 
 static struct nls_table *tables;
diff -urN linux-2.4.20/fs/pipe.c linux-2.4.20-o1-preempt/fs/pipe.c
--- linux-2.4.20/fs/pipe.c      Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/fs/pipe.c   Tue Feb 18 03:51:29 2003
@@ -115,7 +115,7 @@
                 * writers synchronously that there is more
                 * room.
                 */
-               wake_up_interruptible_sync(PIPE_WAIT(*inode));
+               wake_up_interruptible(PIPE_WAIT(*inode));
                if (!PIPE_EMPTY(*inode))
                        BUG();
                goto do_more_read;
diff -urN linux-2.4.20/fs/proc/array.c linux-2.4.20-o1-preempt/fs/proc/array.c
--- linux-2.4.20/fs/proc/array.c        Sat Aug  3 02:39:45 2002
+++ linux-2.4.20-o1-preempt/fs/proc/array.c     Tue Feb 18 03:51:29 2003
@@ -338,9 +338,8 @@
 
        /* scale priority and nice values from timeslices to -20..20 */
        /* to make it look like a "normal" Unix priority/nice value  */
-       priority = task->counter;
-       priority = 20 - (priority * 10 + DEF_COUNTER / 2) / DEF_COUNTER;
-       nice = task->nice;
+       priority = task_prio(task);
+       nice = task_nice(task);
 
        read_lock(&tasklist_lock);
        ppid = task->pid ? task->p_opptr->pid : 0;
@@ -390,7 +389,7 @@
                task->nswap,
                task->cnswap,
                task->exit_signal,
-               task->processor);
+               task->cpu);
        if(mm)
                mmput(mm);
        return res;
diff -urN linux-2.4.20/fs/proc/proc_misc.c linux-2.4.20-o1-preempt/fs/proc/proc_misc.c
--- linux-2.4.20/fs/proc/proc_misc.c    Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/fs/proc/proc_misc.c Tue Feb 18 03:51:29 2003
@@ -106,11 +106,11 @@
        a = avenrun[0] + (FIXED_1/200);
        b = avenrun[1] + (FIXED_1/200);
        c = avenrun[2] + (FIXED_1/200);
-       len = sprintf(page,"%d.%02d %d.%02d %d.%02d %d/%d %d\n",
+       len = sprintf(page,"%d.%02d %d.%02d %d.%02d %ld/%d %d\n",
                LOAD_INT(a), LOAD_FRAC(a),
                LOAD_INT(b), LOAD_FRAC(b),
                LOAD_INT(c), LOAD_FRAC(c),
-               nr_running, nr_threads, last_pid);
+               nr_running(), nr_threads, last_pid);
        return proc_calc_metrics(page, start, off, count, eof, len);
 }
 
@@ -122,7 +122,7 @@
        int len;
 
        uptime = jiffies;
-       idle = init_tasks[0]->times.tms_utime + init_tasks[0]->times.tms_stime;
+       idle = init_task.times.tms_utime + init_task.times.tms_stime;
 
        /* The formula for the fraction parts really is ((t * 100) / HZ) % 100, but
           that would overflow about every five days at HZ == 100.
@@ -371,10 +371,10 @@
        }
 
        proc_sprintf(page, &off, &len,
-               "\nctxt %u\n"
+               "\nctxt %lu\n"
                "btime %lu\n"
                "processes %lu\n",
-               kstat.context_swtch,
+               nr_context_switches(),
                xtime.tv_sec - jif / HZ,
                total_forks);
 
diff -urN linux-2.4.20/fs/reiserfs/buffer2.c linux-2.4.20-o1-preempt/fs/reiserfs/buffer2.c
--- linux-2.4.20/fs/reiserfs/buffer2.c  Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/fs/reiserfs/buffer2.c       Tue Feb 18 03:51:29 2003
@@ -51,11 +51,11 @@
 struct buffer_head  * reiserfs_bread (struct super_block *super, int n_block, int n_size) 
 {
     struct buffer_head  *result;
-    PROC_EXP( unsigned int ctx_switches = kstat.context_swtch );
+    PROC_EXP( unsigned int ctx_switches = nr_context_switches(); );
 
     result = bread (super -> s_dev, n_block, n_size);
     PROC_INFO_INC( super, breads );
-    PROC_EXP( if( kstat.context_swtch != ctx_switches ) 
+    PROC_EXP( if( nr_context_switches() != ctx_switches ) 
              PROC_INFO_INC( super, bread_miss ) );
     return result;
 }
diff -urN linux-2.4.20/include/asm-alpha/bitops.h linux-2.4.20-o1-preempt/include/asm-alpha/bitops.h
--- linux-2.4.20/include/asm-alpha/bitops.h     Sat Oct 13 00:35:54 2001
+++ linux-2.4.20-o1-preempt/include/asm-alpha/bitops.h  Tue Feb 18 03:51:29 2003
@@ -3,6 +3,7 @@
 
 #include <linux/config.h>
 #include <linux/kernel.h>
+#include <asm/compiler.h>
 
 /*
  * Copyright 1994, Linus Torvalds.
@@ -60,25 +61,25 @@
 
        __asm__ __volatile__(
        "1:     ldl_l %0,%3\n"
-       "       and %0,%2,%0\n"
+       "       bic %0,%2,%0\n"
        "       stl_c %0,%1\n"
        "       beq %0,2f\n"
        ".subsection 2\n"
        "2:     br 1b\n"
        ".previous"
        :"=&r" (temp), "=m" (*m)
-       :"Ir" (~(1UL << (nr & 31))), "m" (*m));
+       :"Ir" (1UL << (nr & 31)), "m" (*m));
 }
 
 /*
  * WARNING: non atomic version.
  */
 static __inline__ void
-__change_bit(unsigned long nr, volatile void * addr)
+__clear_bit(unsigned long nr, volatile void * addr)
 {
        int *m = ((int *) addr) + (nr >> 5);
 
-       *m ^= 1 << (nr & 31);
+       *m &= ~(1 << (nr & 31));
 }
 
 static inline void
@@ -99,6 +100,17 @@
        :"Ir" (1UL << (nr & 31)), "m" (*m));
 }
 
+/*
+ * WARNING: non atomic version.
+ */
+static __inline__ void
+__change_bit(unsigned long nr, volatile void * addr)
+{
+       int *m = ((int *) addr) + (nr >> 5);
+
+       *m ^= 1 << (nr & 31);
+}
+
 static inline int
 test_and_set_bit(unsigned long nr, volatile void *addr)
 {
@@ -181,20 +193,6 @@
        return (old & mask) != 0;
 }
 
-/*
- * WARNING: non atomic version.
- */
-static __inline__ int
-__test_and_change_bit(unsigned long nr, volatile void * addr)
-{
-       unsigned long mask = 1 << (nr & 0x1f);
-       int *m = ((int *) addr) + (nr >> 5);
-       int old = *m;
-
-       *m = old ^ mask;
-       return (old & mask) != 0;
-}
-
 static inline int
 test_and_change_bit(unsigned long nr, volatile void * addr)
 {
@@ -220,6 +218,20 @@
        return oldbit != 0;
 }
 
+/*
+ * WARNING: non atomic version.
+ */
+static __inline__ int
+__test_and_change_bit(unsigned long nr, volatile void * addr)
+{
+       unsigned long mask = 1 << (nr & 0x1f);
+       int *m = ((int *) addr) + (nr >> 5);
+       int old = *m;
+
+       *m = old ^ mask;
+       return (old & mask) != 0;
+}
+
 static inline int
 test_bit(int nr, volatile void * addr)
 {
@@ -235,12 +247,15 @@
  */
 static inline unsigned long ffz_b(unsigned long x)
 {
-       unsigned long sum = 0;
+       unsigned long sum, x1, x2, x4;
 
        x = ~x & -~x;           /* set first 0 bit, clear others */
-       if (x & 0xF0) sum += 4;
-       if (x & 0xCC) sum += 2;
-       if (x & 0xAA) sum += 1;
+       x1 = x & 0xAA;
+       x2 = x & 0xCC;
+       x4 = x & 0xF0;
+       sum = x2 ? 2 : 0;
+       sum += (x4 != 0) * 4;
+       sum += (x1 != 0);
 
        return sum;
 }
@@ -257,24 +272,46 @@
 
        __asm__("cmpbge %1,%2,%0" : "=r"(bits) : "r"(word), "r"(~0UL));
        qofs = ffz_b(bits);
-       __asm__("extbl %1,%2,%0" : "=r"(bits) : "r"(word), "r"(qofs));
+       bits = __kernel_extbl(word, qofs);
        bofs = ffz_b(bits);
 
        return qofs*8 + bofs;
 #endif
 }
 
+/*
+ * __ffs = Find First set bit in word.  Undefined if no set bit exists.
+ */
+static inline unsigned long __ffs(unsigned long word)
+{
+#if defined(__alpha_cix__) && defined(__alpha_fix__)
+       /* Whee.  EV67 can calculate it directly.  */
+       unsigned long result;
+       __asm__("cttz %1,%0" : "=r"(result) : "r"(word));
+       return result;
+#else
+       unsigned long bits, qofs, bofs;
+
+       __asm__("cmpbge $31,%1,%0" : "=r"(bits) : "r"(word));
+       qofs = ffz_b(bits);
+       bits = __kernel_extbl(word, qofs);
+       bofs = ffz_b(~bits);
+
+       return qofs*8 + bofs;
+#endif
+}
+
 #ifdef __KERNEL__
 
 /*
  * ffs: find first bit set. This is defined the same way as
  * the libc and compiler builtin ffs routines, therefore
- * differs in spirit from the above ffz (man ffs).
+ * differs in spirit from the above __ffs.
  */
 
 static inline int ffs(int word)
 {
-       int result = ffz(~word);
+       int result = __ffs(word);
        return word ? result+1 : 0;
 }
 
@@ -316,6 +353,14 @@
 #define hweight16(x) hweight64((x) & 0xfffful)
 #define hweight8(x)  hweight64((x) & 0xfful)
 #else
+static inline unsigned long hweight64(unsigned long w)
+{
+       unsigned long result;
+       for (result = 0; w ; w >>= 1)
+               result += (w & 1);
+       return result;
+}
+
 #define hweight32(x) generic_hweight32(x)
 #define hweight16(x) generic_hweight16(x)
 #define hweight8(x)  generic_hweight8(x)
@@ -365,12 +410,76 @@
 }
 
 /*
- * The optimizer actually does good code for this case..
+ * Find next one bit in a bitmap reasonably efficiently.
+ */
+static inline unsigned long
+find_next_bit(void * addr, unsigned long size, unsigned long offset)
+{
+       unsigned long * p = ((unsigned long *) addr) + (offset >> 6);
+       unsigned long result = offset & ~63UL;
+       unsigned long tmp;
+
+       if (offset >= size)
+               return size;
+       size -= result;
+       offset &= 63UL;
+       if (offset) {
+               tmp = *(p++);
+               tmp &= ~0UL << offset;
+               if (size < 64)
+                       goto found_first;
+               if (tmp)
+                       goto found_middle;
+               size -= 64;
+               result += 64;
+       }
+       while (size & ~63UL) {
+               if ((tmp = *(p++)))
+                       goto found_middle;
+               result += 64;
+               size -= 64;
+       }
+       if (!size)
+               return result;
+       tmp = *p;
+found_first:
+       tmp &= ~0UL >> (64 - size);
+       if (!tmp)
+               return result + size;
+found_middle:
+       return result + __ffs(tmp);
+}
+
+/*
+ * The optimizer actually does good code for this case.
  */
 #define find_first_zero_bit(addr, size) \
        find_next_zero_bit((addr), (size), 0)
+#define find_first_bit(addr, size) \
+       find_next_bit((addr), (size), 0)
 
 #ifdef __KERNEL__
+
+/*
+ * Every architecture must define this function. It's the fastest
+ * way of searching a 140-bit bitmap where the first 100 bits are
+ * unlikely to be set. It's guaranteed that at least one of the 140
+ * bits is set.
+ */
+static inline unsigned long
+_sched_find_first_bit(unsigned long b[3])
+{
+       unsigned long b0 = b[0], b1 = b[1], b2 = b[2];
+       unsigned long ofs;
+
+       ofs = (b1 ? 64 : 128);
+       b1 = (b1 ? b1 : b2);
+       ofs = (b0 ? 0 : ofs);
+       b0 = (b0 ? b0 : b1);
+
+       return __ffs(b0) + ofs;
+}
+
 
 #define ext2_set_bit                 __test_and_set_bit
 #define ext2_clear_bit               __test_and_clear_bit
diff -urN linux-2.4.20/include/asm-alpha/smp.h linux-2.4.20-o1-preempt/include/asm-alpha/smp.h
--- linux-2.4.20/include/asm-alpha/smp.h        Fri Sep 14 00:21:32 2001
+++ linux-2.4.20-o1-preempt/include/asm-alpha/smp.h     Tue Feb 18 03:51:29 2003
@@ -55,7 +55,7 @@
 #define cpu_logical_map(cpu)  __cpu_logical_map[cpu]
 
 #define hard_smp_processor_id()        __hard_smp_processor_id()
-#define smp_processor_id()     (current->processor)
+#define smp_processor_id()     (current->cpu)
 
 extern unsigned long cpu_present_mask;
 #define cpu_online_map cpu_present_mask
--- linux-2.4.20/include/asm-alpha/spinlock.h.orig      Wed Nov 21 00:49:31 2001
+++ linux-2.4.20/include/asm-alpha/spinlock.h   Sun Mar  9 13:33:43 2003
@@ -38,12 +38,12 @@
 #define spin_unlock_wait(x)    ({ do { barrier(); } while ((x)->lock); })
 
 #if CONFIG_DEBUG_SPINLOCK
-extern void spin_unlock(spinlock_t * lock);
+extern void _raw_spin_unlock(spinlock_t * lock);
 extern void debug_spin_lock(spinlock_t * lock, const char *, int);
 extern int debug_spin_trylock(spinlock_t * lock, const char *, int);
 
-#define spin_lock(LOCK) debug_spin_lock(LOCK, __BASE_FILE__, __LINE__)
-#define spin_trylock(LOCK) debug_spin_trylock(LOCK, __BASE_FILE__, __LINE__)
+#define _raw_spin_lock(LOCK) debug_spin_lock(LOCK, __BASE_FILE__, __LINE__)
+#define _raw_spin_trylock(LOCK) debug_spin_trylock(LOCK, __BASE_FILE__, __LINE__)
 
 #define spin_lock_own(LOCK, LOCATION)                                  \
 do {                                                                   \
@@ -54,13 +54,13 @@
                       (LOCK)->lock ? "taken" : "freed", (LOCK)->on_cpu); \
 } while (0)
 #else
-static inline void spin_unlock(spinlock_t * lock)
+static inline void _raw_spin_unlock(spinlock_t * lock)
 {
        mb();
        lock->lock = 0;
 }
 
-static inline void spin_lock(spinlock_t * lock)
+static inline void _raw_spin_lock(spinlock_t * lock)
 {
        long tmp;
 
@@ -83,7 +83,7 @@
        : "m"(lock->lock) : "memory");
 }
 
-#define spin_trylock(lock) (!test_and_set_bit(0,(lock)))
+#define _raw_spin_trylock(lock) (!test_and_set_bit(0,(lock)))
 #define spin_lock_own(LOCK, LOCATION)  ((void)0)
 #endif /* CONFIG_DEBUG_SPINLOCK */
 
@@ -98,10 +98,10 @@
 #define rwlock_init(x) do { *(x) = RW_LOCK_UNLOCKED; } while(0)
 
 #if CONFIG_DEBUG_RWLOCK
-extern void write_lock(rwlock_t * lock);
-extern void read_lock(rwlock_t * lock);
+extern void _raw_write_lock(rwlock_t * lock);
+extern void _raw_read_lock(rwlock_t * lock);
 #else
-static inline void write_lock(rwlock_t * lock)
+static inline void _raw_write_lock(rwlock_t * lock)
 {
        long regx;
 
@@ -121,7 +121,7 @@
        : "0" (*(volatile int *)lock) : "memory");
 }
 
-static inline void read_lock(rwlock_t * lock)
+static inline void _raw_read_lock(rwlock_t * lock)
 {
        long regx;
 
@@ -142,13 +142,13 @@
 }
 #endif /* CONFIG_DEBUG_RWLOCK */
 
-static inline void write_unlock(rwlock_t * lock)
+static inline void _raw_write_unlock(rwlock_t * lock)
 {
        mb();
        *(volatile int *)lock = 0;
 }
 
-static inline void read_unlock(rwlock_t * lock)
+static inline void _raw_read_unlock(rwlock_t * lock)
 {
        long regx;
        __asm__ __volatile__(
diff -urN linux-2.4.20/include/asm-alpha/system.h linux-2.4.20-o1-preempt/include/asm-alpha/system.h
--- linux-2.4.20/include/asm-alpha/system.h     Fri Oct  5 03:47:08 2001
+++ linux-2.4.20-o1-preempt/include/asm-alpha/system.h  Tue Feb 18 03:51:29 2003
@@ -130,7 +130,6 @@
 extern void halt(void) __attribute__((noreturn));
 #define __halt() __asm__ __volatile__ ("call_pal %0 #halt" : : "i" (PAL_halt))
 
-#define prepare_to_switch()    do { } while(0)
 #define switch_to(prev,next,last)                      \
 do {                                                   \
        unsigned long pcbb;                             \
diff -urN linux-2.4.20/include/asm-arm/bitops.h linux-2.4.20-o1-preempt/include/asm-arm/bitops.h
--- linux-2.4.20/include/asm-arm/bitops.h       Sun Aug 12 20:14:00 2001
+++ linux-2.4.20-o1-preempt/include/asm-arm/bitops.h    Tue Feb 18 03:51:29 2003
@@ -2,6 +2,8 @@
  * Copyright 1995, Russell King.
  * Various bits and pieces copyrights include:
  *  Linus Torvalds (test_bit).
+ * Big endian support: Copyright 2001, Nicolas Pitre
+ *  reworked by rmk.
  *
  * bit 0 is the LSB of addr; bit 32 is the LSB of (addr+1).
  *
@@ -17,81 +19,271 @@
 
 #ifdef __KERNEL__
 
+#include <asm/system.h>
+
 #define smp_mb__before_clear_bit()     do { } while (0)
 #define smp_mb__after_clear_bit()      do { } while (0)
 
 /*
- * Function prototypes to keep gcc -Wall happy.
+ * These functions are the basis of our bit ops.
+ * First, the atomic bitops.
+ *
+ * The endian issue for these functions is handled by the macros below.
  */
-extern void set_bit(int nr, volatile void * addr);
+static inline void
+____atomic_set_bit_mask(unsigned int mask, volatile unsigned char *p)
+{
+       unsigned long flags;
+
+       local_irq_save(flags);
+       *p |= mask;
+       local_irq_restore(flags);
+}
+
+static inline void
+____atomic_clear_bit_mask(unsigned int mask, volatile unsigned char *p)
+{
+       unsigned long flags;
+
+       local_irq_save(flags);
+       *p &= ~mask;
+       local_irq_restore(flags);
+}
+
+static inline void
+____atomic_change_bit_mask(unsigned int mask, volatile unsigned char *p)
+{
+       unsigned long flags;
+
+       local_irq_save(flags);
+       *p ^= mask;
+       local_irq_restore(flags);
+}
 
-static inline void __set_bit(int nr, volatile void *addr)
+static inline int
+____atomic_test_and_set_bit_mask(unsigned int mask, volatile unsigned char *p)
 {
-       ((unsigned char *) addr)[nr >> 3] |= (1U << (nr & 7));
+       unsigned long flags;
+       unsigned int res;
+
+       local_irq_save(flags);
+       res = *p;
+       *p = res | mask;
+       local_irq_restore(flags);
+
+       return res & mask;
 }
 
-extern void clear_bit(int nr, volatile void * addr);
+static inline int
+____atomic_test_and_clear_bit_mask(unsigned int mask, volatile unsigned char *p)
+{
+       unsigned long flags;
+       unsigned int res;
+
+       local_irq_save(flags);
+       res = *p;
+       *p = res & ~mask;
+       local_irq_restore(flags);
+
+       return res & mask;
+}
 
-static inline void __clear_bit(int nr, volatile void *addr)
+static inline int
+____atomic_test_and_change_bit_mask(unsigned int mask, volatile unsigned char *p)
 {
-       ((unsigned char *) addr)[nr >> 3] &= ~(1U << (nr & 7));
+       unsigned long flags;
+       unsigned int res;
+
+       local_irq_save(flags);
+       res = *p;
+       *p = res ^ mask;
+       local_irq_restore(flags);
+
+       return res & mask;
 }
 
-extern void change_bit(int nr, volatile void * addr);
+/*
+ * Now the non-atomic variants.  We let the compiler handle all optimisations
+ * for these.
+ */
+static inline void ____nonatomic_set_bit(int nr, volatile void *p)
+{
+       ((unsigned char *) p)[nr >> 3] |= (1U << (nr & 7));
+}
 
-static inline void __change_bit(int nr, volatile void *addr)
+static inline void ____nonatomic_clear_bit(int nr, volatile void *p)
 {
-       ((unsigned char *) addr)[nr >> 3] ^= (1U << (nr & 7));
+       ((unsigned char *) p)[nr >> 3] &= ~(1U << (nr & 7));
 }
 
-extern int test_and_set_bit(int nr, volatile void * addr);
+static inline void ____nonatomic_change_bit(int nr, volatile void *p)
+{
+       ((unsigned char *) p)[nr >> 3] ^= (1U << (nr & 7));
+}
 
-static inline int __test_and_set_bit(int nr, volatile void *addr)
+static inline int ____nonatomic_test_and_set_bit(int nr, volatile void *p)
 {
        unsigned int mask = 1 << (nr & 7);
        unsigned int oldval;
 
-       oldval = ((unsigned char *) addr)[nr >> 3];
-       ((unsigned char *) addr)[nr >> 3] = oldval | mask;
+       oldval = ((unsigned char *) p)[nr >> 3];
+       ((unsigned char *) p)[nr >> 3] = oldval | mask;
        return oldval & mask;
 }
 
-extern int test_and_clear_bit(int nr, volatile void * addr);
-
-static inline int __test_and_clear_bit(int nr, volatile void *addr)
+static inline int ____nonatomic_test_and_clear_bit(int nr, volatile void *p)
 {
        unsigned int mask = 1 << (nr & 7);
        unsigned int oldval;
 
-       oldval = ((unsigned char *) addr)[nr >> 3];
-       ((unsigned char *) addr)[nr >> 3] = oldval & ~mask;
+       oldval = ((unsigned char *) p)[nr >> 3];
+       ((unsigned char *) p)[nr >> 3] = oldval & ~mask;
        return oldval & mask;
 }
 
-extern int test_and_change_bit(int nr, volatile void * addr);
-
-static inline int __test_and_change_bit(int nr, volatile void *addr)
+static inline int ____nonatomic_test_and_change_bit(int nr, volatile void *p)
 {
        unsigned int mask = 1 << (nr & 7);
        unsigned int oldval;
 
-       oldval = ((unsigned char *) addr)[nr >> 3];
-       ((unsigned char *) addr)[nr >> 3] = oldval ^ mask;
+       oldval = ((unsigned char *) p)[nr >> 3];
+       ((unsigned char *) p)[nr >> 3] = oldval ^ mask;
        return oldval & mask;
 }
 
-extern int find_first_zero_bit(void * addr, unsigned size);
-extern int find_next_zero_bit(void * addr, int size, int offset);
-
 /*
  * This routine doesn't need to be atomic.
  */
-static inline int test_bit(int nr, const void * addr)
+static inline int ____test_bit(int nr, const void * p)
 {
-    return ((unsigned char *) addr)[nr >> 3] & (1U << (nr & 7));
+    return ((volatile unsigned char *) p)[nr >> 3] & (1U << (nr & 7));
 }      
 
 /*
+ *  A note about Endian-ness.
+ *  -------------------------
+ *
+ * When the ARM is put into big endian mode via CR15, the processor
+ * merely swaps the order of bytes within words, thus:
+ *
+ *          ------------ physical data bus bits -----------
+ *          D31 ... D24  D23 ... D16  D15 ... D8  D7 ... D0
+ * little     byte 3       byte 2       byte 1      byte 0
+ * big        byte 0       byte 1       byte 2      byte 3
+ *
+ * This means that reading a 32-bit word at address 0 returns the same
+ * value irrespective of the endian mode bit.
+ *
+ * Peripheral devices should be connected with the data bus reversed in
+ * "Big Endian" mode.  ARM Application Note 61 is applicable, and is
+ * available from http://www.arm.com/.
+ *
+ * The following assumes that the data bus connectivity for big endian
+ * mode has been followed.
+ *
+ * Note that bit 0 is defined to be 32-bit word bit 0, not byte 0 bit 0.
+ */
+
+/*
+ * Little endian assembly bitops.  nr = 0 -> byte 0 bit 0.
+ */
+extern void _set_bit_le(int nr, volatile void * p);
+extern void _clear_bit_le(int nr, volatile void * p);
+extern void _change_bit_le(int nr, volatile void * p);
+extern int _test_and_set_bit_le(int nr, volatile void * p);
+extern int _test_and_clear_bit_le(int nr, volatile void * p);
+extern int _test_and_change_bit_le(int nr, volatile void * p);
+extern int _find_first_zero_bit_le(void * p, unsigned size);
+extern int _find_next_zero_bit_le(void * p, int size, int offset);
+
+/*
+ * Big endian assembly bitops.  nr = 0 -> byte 3 bit 0.
+ */
+extern void _set_bit_be(int nr, volatile void * p);
+extern void _clear_bit_be(int nr, volatile void * p);
+extern void _change_bit_be(int nr, volatile void * p);
+extern int _test_and_set_bit_be(int nr, volatile void * p);
+extern int _test_and_clear_bit_be(int nr, volatile void * p);
+extern int _test_and_change_bit_be(int nr, volatile void * p);
+extern int _find_first_zero_bit_be(void * p, unsigned size);
+extern int _find_next_zero_bit_be(void * p, int size, int offset);
+
+
+/*
+ * The __* form of bitops are non-atomic and may be reordered.
+ */
+#define        ATOMIC_BITOP_LE(name,nr,p)              \
+       (__builtin_constant_p(nr) ?             \
+        ____atomic_##name##_mask(1 << ((nr) & 7), \
+                       ((unsigned char *)(p)) + ((nr) >> 3)) : \
+        _##name##_le(nr,p))
+
+#define        ATOMIC_BITOP_BE(name,nr,p)              \
+       (__builtin_constant_p(nr) ?             \
+        ____atomic_##name##_mask(1 << ((nr) & 7), \
+                       ((unsigned char *)(p)) + (((nr) >> 3) ^ 3)) : \
+        _##name##_be(nr,p))
+
+#define NONATOMIC_BITOP_LE(name,nr,p)  \
+       (____nonatomic_##name(nr, p))
+
+#define NONATOMIC_BITOP_BE(name,nr,p)  \
+       (____nonatomic_##name(nr ^ 0x18, p))
+
+#ifndef __ARMEB__
+/*
+ * These are the little endian, atomic definitions.
+ */
+#define set_bit(nr,p)                  ATOMIC_BITOP_LE(set_bit,nr,p)
+#define clear_bit(nr,p)                        ATOMIC_BITOP_LE(clear_bit,nr,p)
+#define change_bit(nr,p)               ATOMIC_BITOP_LE(change_bit,nr,p)
+#define test_and_set_bit(nr,p)         ATOMIC_BITOP_LE(test_and_set_bit,nr,p)
+#define test_and_clear_bit(nr,p)       ATOMIC_BITOP_LE(test_and_clear_bit,nr,p)
+#define test_and_change_bit(nr,p)      ATOMIC_BITOP_LE(test_and_change_bit,nr,p)
+#define test_bit(nr,p)                 ____test_bit(nr,p)
+#define find_first_zero_bit(p,sz)      _find_first_zero_bit_le(p,sz)
+#define find_next_zero_bit(p,sz,off)   _find_next_zero_bit_le(p,sz,off)
+
+/*
+ * These are the little endian, non-atomic definitions.
+ */
+#define __set_bit(nr,p)                        NONATOMIC_BITOP_LE(set_bit,nr,p)
+#define __clear_bit(nr,p)              NONATOMIC_BITOP_LE(clear_bit,nr,p)
+#define __change_bit(nr,p)             NONATOMIC_BITOP_LE(change_bit,nr,p)
+#define __test_and_set_bit(nr,p)       NONATOMIC_BITOP_LE(test_and_set_bit,nr,p)
+#define __test_and_clear_bit(nr,p)     NONATOMIC_BITOP_LE(test_and_clear_bit,nr,p)
+#define __test_and_change_bit(nr,p)    NONATOMIC_BITOP_LE(test_and_change_bit,nr,p)
+#define __test_bit(nr,p)               ____test_bit(nr,p)
+
+#else
+
+/*
+ * These are the big endian, atomic definitions.
+ */
+#define set_bit(nr,p)                  ATOMIC_BITOP_BE(set_bit,nr,p)
+#define clear_bit(nr,p)                        ATOMIC_BITOP_BE(clear_bit,nr,p)
+#define change_bit(nr,p)               ATOMIC_BITOP_BE(change_bit,nr,p)
+#define test_and_set_bit(nr,p)         ATOMIC_BITOP_BE(test_and_set_bit,nr,p)
+#define test_and_clear_bit(nr,p)       ATOMIC_BITOP_BE(test_and_clear_bit,nr,p)
+#define test_and_change_bit(nr,p)      ATOMIC_BITOP_BE(test_and_change_bit,nr,p)
+#define test_bit(nr,p)                 ____test_bit((nr) ^ 0x18, p)
+#define find_first_zero_bit(p,sz)      _find_first_zero_bit_be(p,sz)
+#define find_next_zero_bit(p,sz,off)   _find_next_zero_bit_be(p,sz,off)
+
+/*
+ * These are the big endian, non-atomic definitions.
+ */
+#define __set_bit(nr,p)                        NONATOMIC_BITOP_BE(set_bit,nr,p)
+#define __clear_bit(nr,p)              NONATOMIC_BITOP_BE(clear_bit,nr,p)
+#define __change_bit(nr,p)             NONATOMIC_BITOP_BE(change_bit,nr,p)
+#define __test_and_set_bit(nr,p)       NONATOMIC_BITOP_BE(test_and_set_bit,nr,p)
+#define __test_and_clear_bit(nr,p)     NONATOMIC_BITOP_BE(test_and_clear_bit,nr,p)
+#define __test_and_change_bit(nr,p)    NONATOMIC_BITOP_BE(test_and_change_bit,nr,p)
+#define __test_bit(nr,p)               ____test_bit((nr) ^ 0x18, p)
+
+#endif
+
+/*
  * ffz = Find First Zero in word. Undefined if no zero exists,
  * so code should check against ~0UL first..
  */
@@ -110,6 +302,29 @@
 }
 
 /*
+ * ffz = Find First Zero in word. Undefined if no zero exists,
+ * so code should check against ~0UL first..
+ */
+static inline unsigned long __ffs(unsigned long word)
+{
+       int k;
+
+       k = 31;
+       if (word & 0x0000ffff) { k -= 16; word <<= 16; }
+       if (word & 0x00ff0000) { k -= 8;  word <<= 8;  }
+       if (word & 0x0f000000) { k -= 4;  word <<= 4;  }
+       if (word & 0x30000000) { k -= 2;  word <<= 2;  }
+       if (word & 0x40000000) { k -= 1; }
+        return k;
+}
+
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
+/*
  * ffs: find first bit set. This is defined the same way as
  * the libc and compiler builtin ffs routines, therefore
  * differs in spirit from the above ffz (man ffs).
@@ -118,6 +333,22 @@
 #define ffs(x) generic_ffs(x)
 
 /*
+ * Find first bit set in a 168-bit bitmap, where the first
+ * 128 bits are unlikely to be set.
+ */
+static inline int _sched_find_first_bit(unsigned long *b)
+{
+       unsigned long v;
+       unsigned int off;
+
+       for (off = 0; v = b[off], off < 4; off++) {
+               if (unlikely(v))
+                       break;
+       }
+       return __ffs(v) + off * 32;
+}
+
+/*
  * hweightN: returns the hamming weight (i.e. the number
  * of bits set) of a N-bit word
  */
@@ -126,18 +357,25 @@
 #define hweight16(x) generic_hweight16(x)
 #define hweight8(x) generic_hweight8(x)
 
-#define ext2_set_bit                   test_and_set_bit
-#define ext2_clear_bit                 test_and_clear_bit
-#define ext2_test_bit                  test_bit
-#define ext2_find_first_zero_bit       find_first_zero_bit
-#define ext2_find_next_zero_bit                find_next_zero_bit
-
-/* Bitmap functions for the minix filesystem. */
-#define minix_test_and_set_bit(nr,addr)        test_and_set_bit(nr,addr)
-#define minix_set_bit(nr,addr)         set_bit(nr,addr)
-#define minix_test_and_clear_bit(nr,addr)      test_and_clear_bit(nr,addr)
-#define minix_test_bit(nr,addr)                test_bit(nr,addr)
-#define minix_find_first_zero_bit(addr,size)   find_first_zero_bit(addr,size)
+/*
+ * Ext2 is defined to use little-endian byte ordering.
+ * These do not need to be atomic.
+ */
+#define ext2_set_bit(nr,p)                     NONATOMIC_BITOP_LE(test_and_set_bit,nr,p)
+#define ext2_clear_bit(nr,p)                   NONATOMIC_BITOP_LE(test_and_clear_bit,nr,p)
+#define ext2_test_bit(nr,p)                    __test_bit(nr,p)
+#define ext2_find_first_zero_bit(p,sz)         _find_first_zero_bit_le(p,sz)
+#define ext2_find_next_zero_bit(p,sz,off)      _find_next_zero_bit_le(p,sz,off)
+
+/*
+ * Minix is defined to use little-endian byte ordering.
+ * These do not need to be atomic.
+ */
+#define minix_set_bit(nr,p)                    NONATOMIC_BITOP_LE(set_bit,nr,p)
+#define minix_test_bit(nr,p)                   __test_bit(nr,p)
+#define minix_test_and_set_bit(nr,p)           NONATOMIC_BITOP_LE(test_and_set_bit,nr,p)
+#define minix_test_and_clear_bit(nr,p)         NONATOMIC_BITOP_LE(test_and_clear_bit,nr,p)
+#define minix_find_first_zero_bit(p,sz)                _find_first_zero_bit_le(p,sz)
 
 #endif /* __KERNEL__ */
 
diff -urN linux-2.4.20/include/asm-arm/dma.h linux-2.4.20-o1-preempt/include/asm-arm/dma.h
--- linux-2.4.20/include/asm-arm/dma.h  Sun Aug 12 20:14:00 2001
+++ linux-2.4.20-o1-preempt/include/asm-arm/dma.h       Tue Feb 18 03:52:07 2003
@@ -5,6 +5,7 @@
 
 #include <linux/config.h>
 #include <linux/spinlock.h>
+#include <linux/sched.h>
 #include <asm/system.h>
 #include <asm/memory.h>
 #include <asm/scatterlist.h>
diff -urN linux-2.4.20/include/asm-arm/hardirq.h linux-2.4.20-o1-preempt/include/asm-arm/hardirq.h
--- linux-2.4.20/include/asm-arm/hardirq.h      Thu Oct 11 18:04:57 2001
+++ linux-2.4.20-o1-preempt/include/asm-arm/hardirq.h   Tue Feb 18 03:52:07 2003
@@ -34,6 +34,7 @@
 #define irq_exit(cpu,irq)      (local_irq_count(cpu)--)
 
 #define synchronize_irq()      do { } while (0)
+#define release_irqlock(cpu)   do { } while (0)
 
 #else
 #error SMP not supported
diff -urN linux-2.4.20/include/asm-arm/pgalloc.h linux-2.4.20-o1-preempt/include/asm-arm/pgalloc.h
--- linux-2.4.20/include/asm-arm/pgalloc.h      Sun Aug 12 20:14:00 2001
+++ linux-2.4.20-o1-preempt/include/asm-arm/pgalloc.h   Tue Feb 18 03:52:07 2003
@@ -57,40 +57,48 @@
 {
        unsigned long *ret;
 
+       preempt_disable();
        if ((ret = pgd_quicklist) != NULL) {
                pgd_quicklist = (unsigned long *)__pgd_next(ret);
                ret[1] = ret[2];
                clean_dcache_entry(ret + 1);
                pgtable_cache_size--;
        }
+       preempt_enable();
        return (pgd_t *)ret;
 }
 
 static inline void free_pgd_fast(pgd_t *pgd)
 {
+       preempt_disable();
        __pgd_next(pgd) = (unsigned long) pgd_quicklist;
        pgd_quicklist = (unsigned long *) pgd;
        pgtable_cache_size++;
+       preempt_enable();
 }
 
 static inline pte_t *pte_alloc_one_fast(struct mm_struct *mm, unsigned long address)
 {
        unsigned long *ret;
 
+       preempt_disable();
        if((ret = pte_quicklist) != NULL) {
                pte_quicklist = (unsigned long *)__pte_next(ret);
                ret[0] = 0;
                clean_dcache_entry(ret);
                pgtable_cache_size--;
        }
+       preempt_enable();
        return (pte_t *)ret;
 }
 
 static inline void free_pte_fast(pte_t *pte)
 {
+       preempt_disable();
        __pte_next(pte) = (unsigned long) pte_quicklist;
        pte_quicklist = (unsigned long *) pte;
        pgtable_cache_size++;
+       preempt_enable();
 }
 
 #else  /* CONFIG_NO_PGT_CACHE */
diff -urN linux-2.4.20/include/asm-arm/smplock.h linux-2.4.20-o1-preempt/include/asm-arm/smplock.h
--- linux-2.4.20/include/asm-arm/smplock.h      Sun Aug 12 20:14:00 2001
+++ linux-2.4.20-o1-preempt/include/asm-arm/smplock.h   Tue Feb 18 03:52:07 2003
@@ -3,12 +3,17 @@
  *
  * Default SMP lock implementation
  */
+#include <linux/config.h>
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
 
 extern spinlock_t kernel_flag;
 
+#ifdef CONFIG_PREEMPT
+#define kernel_locked()                preempt_get_count()
+#else
 #define kernel_locked()                spin_is_locked(&kernel_flag)
+#endif
 
 /*
  * Release global kernel lock and global interrupt lock
@@ -40,8 +45,14 @@
  */
 static inline void lock_kernel(void)
 {
+#ifdef CONFIG_PREEMPT
+       if (current->lock_depth == -1)
+               spin_lock(&kernel_flag);
+       ++current->lock_depth;
+#else
        if (!++current->lock_depth)
                spin_lock(&kernel_flag);
+#endif
 }
 
 static inline void unlock_kernel(void)
diff -urN linux-2.4.20/include/asm-arm/softirq.h linux-2.4.20-o1-preempt/include/asm-arm/softirq.h
--- linux-2.4.20/include/asm-arm/softirq.h      Sat Sep  8 21:02:31 2001
+++ linux-2.4.20-o1-preempt/include/asm-arm/softirq.h   Tue Feb 18 03:52:07 2003
@@ -5,20 +5,22 @@
 #include <asm/hardirq.h>
 
 #define __cpu_bh_enable(cpu) \
-               do { barrier(); local_bh_count(cpu)--; } while (0)
+               do { barrier(); local_bh_count(cpu)--; preempt_enable(); } while (0)
 #define cpu_bh_disable(cpu) \
-               do { local_bh_count(cpu)++; barrier(); } while (0)
+               do { preempt_disable(); local_bh_count(cpu)++; barrier(); } while (0)
 
 #define local_bh_disable()     cpu_bh_disable(smp_processor_id())
 #define __local_bh_enable()    __cpu_bh_enable(smp_processor_id())
 
 #define in_softirq()           (local_bh_count(smp_processor_id()) != 0)
 
-#define local_bh_enable()                                              \
+#define _local_bh_enable()                                             \
 do {                                                                   \
        unsigned int *ptr = &local_bh_count(smp_processor_id());        \
        if (!--*ptr && ptr[-2])                                         \
                __asm__("bl%? __do_softirq": : : "lr");/* out of line */\
 } while (0)
+
+#define local_bh_enable() do { _local_bh_enable(); preempt_enable(); } while (0)
 
 #endif /* __ASM_SOFTIRQ_H */
diff -urN linux-2.4.20/include/asm-arm/system.h linux-2.4.20-o1-preempt/include/asm-arm/system.h
--- linux-2.4.20/include/asm-arm/system.h       Tue Nov 28 02:07:59 2000
+++ linux-2.4.20-o1-preempt/include/asm-arm/system.h    Tue Feb 18 03:52:07 2003
@@ -62,6 +62,13 @@
 #define local_irq_disable()    __cli()
 #define local_irq_enable()     __sti()
 
+#define irqs_disabled()                                \
+({                                             \
+        unsigned long cpsr_val;                        \
+        asm ("mrs %0, cpsr" : "=r" (cpsr_val));        \
+        cpsr_val & 128;                                \
+})
+
 #ifdef CONFIG_SMP
 #error SMP not supported
 
diff -urN linux-2.4.20/include/asm-cris/bitops.h linux-2.4.20-o1-preempt/include/asm-cris/bitops.h
--- linux-2.4.20/include/asm-cris/bitops.h      Mon Feb 25 20:38:10 2002
+++ linux-2.4.20-o1-preempt/include/asm-cris/bitops.h   Tue Feb 18 03:51:29 2003
@@ -22,6 +22,7 @@
 /* We use generic_ffs so get it; include guards resolve the possible
    mutually inclusion.  */
 #include <linux/bitops.h>
+#include <linux/compiler.h>
 
 /*
  * Some hacks to defeat gcc over-optimizations..
@@ -43,6 +44,8 @@
 
 #define set_bit(nr, addr)    (void)test_and_set_bit(nr, addr)
 
+#define __set_bit(nr, addr)    (void)__test_and_set_bit(nr, addr)
+
 /*
  * clear_bit - Clears a bit in memory
  * @nr: Bit to clear
@@ -56,6 +59,8 @@
 
 #define clear_bit(nr, addr)  (void)test_and_clear_bit(nr, addr)
 
+#define __clear_bit(nr, addr)  (void)__test_and_clear_bit(nr, addr)
+
 /*
  * change_bit - Toggle a bit in memory
  * @nr: Bit to clear
@@ -89,7 +94,7 @@
  * It also implies a memory barrier.
  */
 
-static __inline__ int test_and_set_bit(int nr, void *addr)
+static inline int test_and_set_bit(int nr, void *addr)
 {
        unsigned int mask, retval;
        unsigned long flags;
@@ -105,6 +110,18 @@
        return retval;
 }
 
+static inline int __test_and_set_bit(int nr, void *addr)
+{
+       unsigned int mask, retval;
+       unsigned int *adr = (unsigned int *)addr;
+       
+       adr += nr >> 5;
+       mask = 1 << (nr & 0x1f);
+       retval = (mask & *adr) != 0;
+       *adr |= mask;
+       return retval;
+}
+
 /*
  * clear_bit() doesn't provide any barrier for the compiler.
  */
@@ -120,7 +137,7 @@
  * It also implies a memory barrier.
  */
 
-static __inline__ int test_and_clear_bit(int nr, void *addr)
+static inline int test_and_clear_bit(int nr, void *addr)
 {
        unsigned int mask, retval;
        unsigned long flags;
@@ -146,7 +163,7 @@
  * but actually fail.  You must protect multiple accesses with a lock.
  */
 
-static __inline__ int __test_and_clear_bit(int nr, void *addr)
+static inline int __test_and_clear_bit(int nr, void *addr)
 {
        unsigned int mask, retval;
        unsigned int *adr = (unsigned int *)addr;
@@ -166,7 +183,7 @@
  * It also implies a memory barrier.
  */
 
-static __inline__ int test_and_change_bit(int nr, void *addr)
+static inline int test_and_change_bit(int nr, void *addr)
 {
        unsigned int mask, retval;
        unsigned long flags;
@@ -183,7 +200,7 @@
 
 /* WARNING: non atomic and it can be reordered! */
 
-static __inline__ int __test_and_change_bit(int nr, void *addr)
+static inline int __test_and_change_bit(int nr, void *addr)
 {
        unsigned int mask, retval;
        unsigned int *adr = (unsigned int *)addr;
@@ -204,7 +221,7 @@
  * This routine doesn't need to be atomic.
  */
 
-static __inline__ int test_bit(int nr, const void *addr)
+static inline int test_bit(int nr, const void *addr)
 {
        unsigned int mask;
        unsigned int *adr = (unsigned int *)addr;
@@ -225,7 +242,7 @@
  * number.  They differ in that the first function also inverts all bits
  * in the input.
  */
-static __inline__ unsigned long cris_swapnwbrlz(unsigned long w)
+static inline unsigned long cris_swapnwbrlz(unsigned long w)
 {
        /* Let's just say we return the result in the same register as the
           input.  Saying we clobber the input but can return the result
@@ -241,7 +258,7 @@
        return res;
 }
 
-static __inline__ unsigned long cris_swapwbrlz(unsigned long w)
+static inline unsigned long cris_swapwbrlz(unsigned long w)
 {
        unsigned res;
        __asm__ ("swapwbr %0 \n\t"
@@ -255,7 +272,7 @@
  * ffz = Find First Zero in word. Undefined if no zero exists,
  * so code should check against ~0UL first..
  */
-static __inline__ unsigned long ffz(unsigned long w)
+static inline unsigned long ffz(unsigned long w)
 {
        /* The generic_ffs function is used to avoid the asm when the
           argument is a constant.  */
@@ -268,7 +285,7 @@
  * Somewhat like ffz but the equivalent of generic_ffs: in contrast to
  * ffz we return the first one-bit *plus one*.
  */
-static __inline__ unsigned long ffs(unsigned long w)
+static inline unsigned long ffs(unsigned long w)
 {
        /* The generic_ffs function is used to avoid the asm when the
           argument is a constant.  */
@@ -283,7 +300,7 @@
  * @offset: The bitnumber to start searching at
  * @size: The maximum size to search
  */
-static __inline__ int find_next_zero_bit (void * addr, int size, int offset)
+static inline int find_next_zero_bit (void * addr, int size, int offset)
 {
        unsigned long *p = ((unsigned long *) addr) + (offset >> 5);
        unsigned long result = offset & ~31UL;
@@ -354,7 +371,45 @@
 #define minix_test_bit(nr,addr) test_bit(nr,addr)
 #define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
 
-#endif /* __KERNEL__ */
+#if 0
+/* TODO: see below */
+#define sched_find_first_zero_bit(addr) find_first_zero_bit(addr, 168)
+
+#else
+/* TODO: left out pending where to put it.. (there are .h dependencies) */
+
+ /*
+ * Every architecture must define this function. It's the fastest
+ * way of searching a 168-bit bitmap where the first 128 bits are
+ * unlikely to be set. It's guaranteed that at least one of the 168
+ * bits is cleared.
+ */
+#if 0
+#if MAX_RT_PRIO != 128 || MAX_PRIO != 168
+# error update this function.
+#endif
+#else
+#define MAX_RT_PRIO 128
+#define MAX_PRIO 168
+#endif
+
+static inline int sched_find_first_zero_bit(char *bitmap)
+{
+       unsigned int *b = (unsigned int *)bitmap;
+       unsigned int rt;
+
+       rt = b[0] & b[1] & b[2] & b[3];
+       if (unlikely(rt != 0xffffffff))
+               return find_first_zero_bit(bitmap, MAX_RT_PRIO);
+
+       if (b[4] != ~0)
+               return ffz(b[4]) + MAX_RT_PRIO;
+       return ffz(b[5]) + 32 + MAX_RT_PRIO;
+}
+#undef MAX_PRIO
+#undef MAX_RT_PRIO
+#endif
 
+#endif /* __KERNEL__ */
 
 #endif /* _CRIS_BITOPS_H */
diff -urN linux-2.4.20/include/asm-generic/bitops.h linux-2.4.20-o1-preempt/include/asm-generic/bitops.h
--- linux-2.4.20/include/asm-generic/bitops.h   Tue Nov 28 02:47:38 2000
+++ linux-2.4.20-o1-preempt/include/asm-generic/bitops.h        Tue Feb 18 03:51:29 2003
@@ -51,6 +51,12 @@
        return ((mask & *addr) != 0);
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
 #ifdef __KERNEL__
 
 /*
diff -urN linux-2.4.20/include/asm-i386/bitops.h linux-2.4.20-o1-preempt/include/asm-i386/bitops.h
--- linux-2.4.20/include/asm-i386/bitops.h      Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/asm-i386/bitops.h   Tue Feb 18 03:51:29 2003
@@ -6,6 +6,7 @@
  */
 
 #include <linux/config.h>
+#include <linux/compiler.h>
 
 /*
  * These have to be done with inline assembly: that way the bit-setting
@@ -75,6 +76,14 @@
                :"=m" (ADDR)
                :"Ir" (nr));
 }
+
+static __inline__ void __clear_bit(int nr, volatile void * addr)
+{
+       __asm__ __volatile__(
+               "btrl %1,%0"
+               :"=m" (ADDR)
+               :"Ir" (nr));
+}
 #define smp_mb__before_clear_bit()     barrier()
 #define smp_mb__after_clear_bit()      barrier()
 
@@ -284,6 +293,34 @@
 }
 
 /**
+ * find_first_bit - find the first set bit in a memory region
+ * @addr: The address to start the search at
+ * @size: The maximum size to search
+ *
+ * Returns the bit-number of the first set bit, not the number of the byte
+ * containing a bit.
+ */
+static __inline__ int find_first_bit(void * addr, unsigned size)
+{
+       int d0, d1;
+       int res;
+
+       /* This looks at memory. Mark it volatile to tell gcc not to move it around */
+       __asm__ __volatile__(
+               "xorl %%eax,%%eax\n\t"
+               "repe; scasl\n\t"
+               "jz 1f\n\t"
+               "leal -4(%%edi),%%edi\n\t"
+               "bsfl (%%edi),%%eax\n"
+               "1:\tsubl %%ebx,%%edi\n\t"
+               "shll $3,%%edi\n\t"
+               "addl %%edi,%%eax"
+               :"=a" (res), "=&c" (d0), "=&D" (d1)
+               :"1" ((size + 31) >> 5), "2" (addr), "b" (addr));
+       return res;
+}
+
+/**
  * find_next_zero_bit - find the first zero bit in a memory region
  * @addr: The address to base the search on
  * @offset: The bitnumber to start searching at
@@ -296,7 +333,7 @@
        
        if (bit) {
                /*
-                * Look for zero in first byte
+                * Look for zero in the first 32 bits.
                 */
                __asm__("bsfl %1,%0\n\t"
                        "jne 1f\n\t"
@@ -317,6 +354,39 @@
 }
 
 /**
+ * find_next_bit - find the first set bit in a memory region
+ * @addr: The address to base the search on
+ * @offset: The bitnumber to start searching at
+ * @size: The maximum size to search
+ */
+static __inline__ int find_next_bit (void * addr, int size, int offset)
+{
+       unsigned long * p = ((unsigned long *) addr) + (offset >> 5);
+       int set = 0, bit = offset & 31, res;
+       
+       if (bit) {
+               /*
+                * Look for nonzero in the first 32 bits:
+                */
+               __asm__("bsfl %1,%0\n\t"
+                       "jne 1f\n\t"
+                       "movl $32, %0\n"
+                       "1:"
+                       : "=r" (set)
+                       : "r" (*p >> bit));
+               if (set < (32 - bit))
+                       return set + offset;
+               set = 32 - bit;
+               p++;
+       }
+       /*
+        * No set bit yet, search remaining full words for a bit
+        */
+       res = find_first_bit (p, size - 32 * (p - (unsigned long *) addr));
+       return (offset + set + res);
+}
+
+/**
  * ffz - find first zero in word.
  * @word: The word to search
  *
@@ -330,7 +400,40 @@
        return word;
 }
 
+/**
+ * __ffs - find first bit in word.
+ * @word: The word to search
+ *
+ * Undefined if no bit exists, so code should check against 0 first.
+ */
+static __inline__ unsigned long __ffs(unsigned long word)
+{
+       __asm__("bsfl %1,%0"
+               :"=r" (word)
+               :"rm" (word));
+       return word;
+}
+
 #ifdef __KERNEL__
+
+/*
+ * Every architecture must define this function. It's the fastest
+ * way of searching a 140-bit bitmap where the first 100 bits are
+ * unlikely to be set. It's guaranteed that at least one of the 140
+ * bits is cleared.
+ */
+static inline int _sched_find_first_bit(unsigned long *b)
+{
+       if (unlikely(b[0]))
+               return __ffs(b[0]);
+       if (unlikely(b[1]))
+               return __ffs(b[1]) + 32;
+       if (unlikely(b[2]))
+               return __ffs(b[2]) + 64;
+       if (b[3])
+               return __ffs(b[3]) + 96;
+       return __ffs(b[4]) + 128;
+}
 
 /**
  * ffs - find first bit set
diff -urN linux-2.4.20/include/asm-i386/hardirq.h linux-2.4.20-o1-preempt/include/asm-i386/hardirq.h
--- linux-2.4.20/include/asm-i386/hardirq.h     Thu Nov 22 20:46:19 2001
+++ linux-2.4.20-o1-preempt/include/asm-i386/hardirq.h  Tue Feb 18 03:52:07 2003
@@ -19,12 +19,16 @@
 
 /*
  * Are we in an interrupt context? Either doing bottom half
- * or hardware interrupt processing?
+ * or hardware interrupt processing?  Note the preempt check,
+ * this is both a bugfix and an optimization.  If we are
+ * preemptible, we cannot be in an interrupt.
  */
-#define in_interrupt() ({ int __cpu = smp_processor_id(); \
-       (local_irq_count(__cpu) + local_bh_count(__cpu) != 0); })
+#define in_interrupt() (preempt_is_disabled() && \
+       ({unsigned long __cpu = smp_processor_id(); \
+       (local_irq_count(__cpu) + local_bh_count(__cpu) != 0); }))
 
-#define in_irq() (local_irq_count(smp_processor_id()) != 0)
+#define in_irq() (preempt_is_disabled() && \
+        (local_irq_count(smp_processor_id()) != 0))
 
 #ifndef CONFIG_SMP
 
@@ -35,6 +39,8 @@
 #define irq_exit(cpu, irq)     (local_irq_count(cpu)--)
 
 #define synchronize_irq()      barrier()
+
+#define release_irqlock(cpu)   do { } while (0)
 
 #else
 
diff -urN linux-2.4.20/include/asm-i386/highmem.h linux-2.4.20-o1-preempt/include/asm-i386/highmem.h
--- linux-2.4.20/include/asm-i386/highmem.h     Sat Aug  3 02:39:45 2002
+++ linux-2.4.20-o1-preempt/include/asm-i386/highmem.h  Tue Feb 18 03:52:07 2003
@@ -88,6 +88,7 @@
        enum fixed_addresses idx;
        unsigned long vaddr;
 
+       preempt_disable();
        if (page < highmem_start_page)
                return page_address(page);
 
@@ -109,8 +110,10 @@
        unsigned long vaddr = (unsigned long) kvaddr;
        enum fixed_addresses idx = type + KM_TYPE_NR*smp_processor_id();
 
-       if (vaddr < FIXADDR_START) // FIXME
+       if (vaddr < FIXADDR_START) { // FIXME
+               preempt_enable();
                return;
+       }
 
        if (vaddr != __fix_to_virt(FIX_KMAP_BEGIN+idx))
                out_of_line_bug();
@@ -122,6 +125,8 @@
        pte_clear(kmap_pte-idx);
        __flush_tlb_one(vaddr);
 #endif
+
+       preempt_enable();
 }
 
 #endif /* __KERNEL__ */
diff -urN linux-2.4.20/include/asm-i386/hw_irq.h linux-2.4.20-o1-preempt/include/asm-i386/hw_irq.h
--- linux-2.4.20/include/asm-i386/hw_irq.h      Thu Nov 22 20:46:18 2001
+++ linux-2.4.20-o1-preempt/include/asm-i386/hw_irq.h   Tue Feb 18 03:52:07 2003
@@ -95,6 +95,18 @@
 #define __STR(x) #x
 #define STR(x) __STR(x)
 
+#define GET_CURRENT \
+       "movl %esp, %ebx\n\t" \
+       "andl $-8192, %ebx\n\t"
+
+#ifdef CONFIG_PREEMPT
+#define BUMP_LOCK_COUNT \
+       GET_CURRENT \
+       "incl 4(%ebx)\n\t"
+#else
+#define BUMP_LOCK_COUNT
+#endif
+
 #define SAVE_ALL \
        "cld\n\t" \
        "pushl %es\n\t" \
@@ -108,14 +120,11 @@
        "pushl %ebx\n\t" \
        "movl $" STR(__KERNEL_DS) ",%edx\n\t" \
        "movl %edx,%ds\n\t" \
-       "movl %edx,%es\n\t"
+       "movl %edx,%es\n\t" \
+       BUMP_LOCK_COUNT
 
 #define IRQ_NAME2(nr) nr##_interrupt(void)
 #define IRQ_NAME(nr) IRQ_NAME2(IRQ##nr)
-
-#define GET_CURRENT \
-       "movl %esp, %ebx\n\t" \
-       "andl $-8192, %ebx\n\t"
 
 /*
  *     SMP has a few special interrupts for IPI messages
diff -urN linux-2.4.20/include/asm-i386/i387.h linux-2.4.20-o1-preempt/include/asm-i386/i387.h
--- linux-2.4.20/include/asm-i386/i387.h        Sat Aug  3 02:39:45 2002
+++ linux-2.4.20-o1-preempt/include/asm-i386/i387.h     Tue Feb 18 03:52:07 2003
@@ -12,6 +12,7 @@
 #define __ASM_I386_I387_H
 
 #include <linux/sched.h>
+#include <linux/spinlock.h>
 #include <asm/processor.h>
 #include <asm/sigcontext.h>
 #include <asm/user.h>
@@ -24,7 +25,7 @@
 extern void restore_fpu( struct task_struct *tsk );
 
 extern void kernel_fpu_begin(void);
-#define kernel_fpu_end() stts()
+#define kernel_fpu_end() do { stts(); preempt_enable(); } while(0)
 
 
 #define unlazy_fpu( tsk ) do { \
diff -urN linux-2.4.20/include/asm-i386/mmu_context.h linux-2.4.20-o1-preempt/include/asm-i386/mmu_context.h
--- linux-2.4.20/include/asm-i386/mmu_context.h Sat Aug  3 02:39:45 2002
+++ linux-2.4.20-o1-preempt/include/asm-i386/mmu_context.h      Tue Feb 18 03:51:29 2003
@@ -27,13 +27,13 @@
 
 static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next, struct task_struct *tsk, unsigned cpu)
 {
-       if (prev != next) {
+       if (likely(prev != next)) {
                /* stop flush ipis for the previous mm */
                clear_bit(cpu, &prev->cpu_vm_mask);
                /*
                 * Re-load LDT if necessary
                 */
-               if (prev->context.segments != next->context.segments)
+               if (unlikely(prev->context.segments != next->context.segments))
                        load_LDT(next);
 #ifdef CONFIG_SMP
                cpu_tlbstate[cpu].state = TLBSTATE_OK;
diff -urN linux-2.4.20/include/asm-i386/pgalloc.h linux-2.4.20-o1-preempt/include/asm-i386/pgalloc.h
--- linux-2.4.20/include/asm-i386/pgalloc.h     Sat Aug  3 02:39:45 2002
+++ linux-2.4.20-o1-preempt/include/asm-i386/pgalloc.h  Tue Feb 18 03:52:06 2003
@@ -75,20 +75,26 @@
 {
        unsigned long *ret;
 
+       preempt_disable();
        if ((ret = pgd_quicklist) != NULL) {
                pgd_quicklist = (unsigned long *)(*ret);
                ret[0] = 0;
                pgtable_cache_size--;
-       } else
+               preempt_enable();
+       } else {
+               preempt_enable();
                ret = (unsigned long *)get_pgd_slow();
+       }
        return (pgd_t *)ret;
 }
 
 static inline void free_pgd_fast(pgd_t *pgd)
 {
+       preempt_disable();
        *(unsigned long *)pgd = (unsigned long) pgd_quicklist;
        pgd_quicklist = (unsigned long *) pgd;
        pgtable_cache_size++;
+       preempt_enable();
 }
 
 static inline void free_pgd_slow(pgd_t *pgd)
@@ -119,19 +125,23 @@
 {
        unsigned long *ret;
 
+       preempt_disable();
        if ((ret = (unsigned long *)pte_quicklist) != NULL) {
                pte_quicklist = (unsigned long *)(*ret);
                ret[0] = ret[1];
                pgtable_cache_size--;
        }
+       preempt_enable();
        return (pte_t *)ret;
 }
 
 static inline void pte_free_fast(pte_t *pte)
 {
+       preempt_disable();
        *(unsigned long *)pte = (unsigned long) pte_quicklist;
        pte_quicklist = (unsigned long *) pte;
        pgtable_cache_size++;
+       preempt_enable();
 }
 
 static __inline__ void pte_free_slow(pte_t *pte)
@@ -224,6 +234,7 @@
 {
        struct mm_struct *active_mm;
        int state;
+       char __cacheline_padding[24];
 };
 extern struct tlb_state cpu_tlbstate[NR_CPUS];
 
diff -urN linux-2.4.20/include/asm-i386/smp.h linux-2.4.20-o1-preempt/include/asm-i386/smp.h
--- linux-2.4.20/include/asm-i386/smp.h Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/asm-i386/smp.h      Tue Feb 18 03:51:29 2003
@@ -40,6 +40,7 @@
 extern void smp_flush_tlb(void);
 extern void smp_message_irq(int cpl, void *dev_id, struct pt_regs *regs);
 extern void smp_send_reschedule(int cpu);
+extern void smp_send_reschedule_all(void);
 extern void smp_invalidate_rcv(void);          /* Process an NMI */
 extern void (*mtrr_hook) (void);
 extern void zap_low_mappings (void);
@@ -81,7 +82,7 @@
  * so this is correct in the x86 case.
  */
 
-#define smp_processor_id() (current->processor)
+#define smp_processor_id() (current->cpu)
 
 static __inline int hard_smp_processor_id(void)
 {
@@ -98,18 +99,6 @@
 #endif /* !__ASSEMBLY__ */
 
 #define NO_PROC_ID             0xFF            /* No processor magic marker */
-
-/*
- *     This magic constant controls our willingness to transfer
- *     a process across CPUs. Such a transfer incurs misses on the L1
- *     cache, and on a P6 or P5 with multiple L2 caches L2 hits. My
- *     gut feeling is this will vary by board in value. For a board
- *     with separate L2 cache it probably depends also on the RSS, and
- *     for a board with shared L2 cache it ought to decay fast as other
- *     processes are run.
- */
- 
-#define PROC_CHANGE_PENALTY    15              /* Schedule penalty */
 
 #endif
 #endif
diff -urN linux-2.4.20/include/asm-i386/smplock.h linux-2.4.20-o1-preempt/include/asm-i386/smplock.h
--- linux-2.4.20/include/asm-i386/smplock.h     Sat Aug  3 02:39:45 2002
+++ linux-2.4.20-o1-preempt/include/asm-i386/smplock.h  Tue Feb 18 03:52:07 2003
@@ -11,7 +11,15 @@
 extern spinlock_cacheline_t kernel_flag_cacheline;  
 #define kernel_flag kernel_flag_cacheline.lock      
 
+#ifdef CONFIG_SMP
 #define kernel_locked()                spin_is_locked(&kernel_flag)
+#else
+#ifdef CONFIG_PREEMPT
+#define kernel_locked()                preempt_get_count()
+#else
+#define kernel_locked()                1
+#endif
+#endif
 
 /*
  * Release global kernel lock and global interrupt lock
@@ -43,6 +51,11 @@
  */
 static __inline__ void lock_kernel(void)
 {
+#ifdef CONFIG_PREEMPT
+       if (current->lock_depth == -1)
+               spin_lock(&kernel_flag);
+       ++current->lock_depth;
+#else
 #if 1
        if (!++current->lock_depth)
                spin_lock(&kernel_flag);
@@ -54,6 +67,7 @@
                "\n9:"
                :"=m" (__dummy_lock(&kernel_flag)),
                 "=m" (current->lock_depth));
+#endif
 #endif
 }
 
diff -urN linux-2.4.20/include/asm-i386/softirq.h linux-2.4.20-o1-preempt/include/asm-i386/softirq.h
--- linux-2.4.20/include/asm-i386/softirq.h     Sat Aug  3 02:39:45 2002
+++ linux-2.4.20-o1-preempt/include/asm-i386/softirq.h  Tue Feb 18 03:52:07 2003
@@ -5,9 +5,9 @@
 #include <asm/hardirq.h>
 
 #define __cpu_bh_enable(cpu) \
-               do { barrier(); local_bh_count(cpu)--; } while (0)
+               do { barrier(); local_bh_count(cpu)--; preempt_enable(); } while (0)
 #define cpu_bh_disable(cpu) \
-               do { local_bh_count(cpu)++; barrier(); } while (0)
+               do { preempt_disable(); local_bh_count(cpu)++; barrier(); } while (0)
 
 #define local_bh_disable()     cpu_bh_disable(smp_processor_id())
 #define __local_bh_enable()    __cpu_bh_enable(smp_processor_id())
@@ -22,7 +22,7 @@
  * If you change the offsets in irq_stat then you have to
  * update this code as well.
  */
-#define local_bh_enable()                                              \
+#define _local_bh_enable()                                             \
 do {                                                                   \
        unsigned int *ptr = &local_bh_count(smp_processor_id());        \
                                                                        \
@@ -44,5 +44,7 @@
                : "r" (ptr), "i" (do_softirq)                           \
                /* no registers clobbered */ );                         \
 } while (0)
+
+#define local_bh_enable() do { _local_bh_enable(); preempt_enable(); } while (0)
 
 #endif /* __ASM_SOFTIRQ_H */
diff -urN linux-2.4.20/include/asm-i386/spinlock.h linux-2.4.20-o1-preempt/include/asm-i386/spinlock.h
--- linux-2.4.20/include/asm-i386/spinlock.h    Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/asm-i386/spinlock.h Tue Feb 18 03:52:07 2003
@@ -77,7 +77,7 @@
                :"=m" (lock->lock) : : "memory"
 
 
-static inline void spin_unlock(spinlock_t *lock)
+static inline void _raw_spin_unlock(spinlock_t *lock)
 {
 #if SPINLOCK_DEBUG
        if (lock->magic != SPINLOCK_MAGIC)
@@ -97,7 +97,7 @@
                :"=q" (oldval), "=m" (lock->lock) \
                :"0" (oldval) : "memory"
 
-static inline void spin_unlock(spinlock_t *lock)
+static inline void _raw_spin_unlock(spinlock_t *lock)
 {
        char oldval = 1;
 #if SPINLOCK_DEBUG
@@ -113,7 +113,7 @@
 
 #endif
 
-static inline int spin_trylock(spinlock_t *lock)
+static inline int _raw_spin_trylock(spinlock_t *lock)
 {
        char oldval;
        __asm__ __volatile__(
@@ -123,7 +123,7 @@
        return oldval > 0;
 }
 
-static inline void spin_lock(spinlock_t *lock)
+static inline void _raw_spin_lock(spinlock_t *lock)
 {
 #if SPINLOCK_DEBUG
        __label__ here;
@@ -179,7 +179,7 @@
  */
 /* the spinlock helpers are in arch/i386/kernel/semaphore.c */
 
-static inline void read_lock(rwlock_t *rw)
+static inline void _raw_read_lock(rwlock_t *rw)
 {
 #if SPINLOCK_DEBUG
        if (rw->magic != RWLOCK_MAGIC)
@@ -188,7 +188,7 @@
        __build_read_lock(rw, "__read_lock_failed");
 }
 
-static inline void write_lock(rwlock_t *rw)
+static inline void _raw_write_lock(rwlock_t *rw)
 {
 #if SPINLOCK_DEBUG
        if (rw->magic != RWLOCK_MAGIC)
@@ -197,10 +197,10 @@
        __build_write_lock(rw, "__write_lock_failed");
 }
 
-#define read_unlock(rw)                asm volatile("lock ; incl %0" :"=m" ((rw)->lock) : : "memory")
-#define write_unlock(rw)       asm volatile("lock ; addl $" RW_LOCK_BIAS_STR ",%0":"=m" ((rw)->lock) : : "memory")
+#define _raw_read_unlock(rw)           asm volatile("lock ; incl %0" :"=m" ((rw)->lock) : : "memory")
+#define _raw_write_unlock(rw)  asm volatile("lock ; addl $" RW_LOCK_BIAS_STR ",%0":"=m" ((rw)->lock) : : "memory")
 
-static inline int write_trylock(rwlock_t *lock)
+static inline int _raw_write_trylock(rwlock_t *lock)
 {
        atomic_t *count = (atomic_t *)lock;
        if (atomic_sub_and_test(RW_LOCK_BIAS, count))
diff -urN linux-2.4.20/include/asm-i386/system.h linux-2.4.20-o1-preempt/include/asm-i386/system.h
--- linux-2.4.20/include/asm-i386/system.h      Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/asm-i386/system.h   Tue Feb 18 03:52:06 2003
@@ -12,25 +12,22 @@
 struct task_struct;    /* one of the stranger aspects of C forward declarations.. */
 extern void FASTCALL(__switch_to(struct task_struct *prev, struct task_struct *next));
 
-#define prepare_to_switch()    do { } while(0)
 #define switch_to(prev,next,last) do {                                 \
        asm volatile("pushl %%esi\n\t"                                  \
                     "pushl %%edi\n\t"                                  \
                     "pushl %%ebp\n\t"                                  \
                     "movl %%esp,%0\n\t"        /* save ESP */          \
-                    "movl %3,%%esp\n\t"        /* restore ESP */       \
+                    "movl %2,%%esp\n\t"        /* restore ESP */       \
                     "movl $1f,%1\n\t"          /* save EIP */          \
-                    "pushl %4\n\t"             /* restore EIP */       \
+                    "pushl %3\n\t"             /* restore EIP */       \
                     "jmp __switch_to\n"                                \
                     "1:\t"                                             \
                     "popl %%ebp\n\t"                                   \
                     "popl %%edi\n\t"                                   \
                     "popl %%esi\n\t"                                   \
-                    :"=m" (prev->thread.esp),"=m" (prev->thread.eip),  \
-                     "=b" (last)                                       \
+                    :"=m" (prev->thread.esp),"=m" (prev->thread.eip)   \
                     :"m" (next->thread.esp),"m" (next->thread.eip),    \
-                     "a" (prev), "d" (next),                           \
-                     "b" (prev));                                      \
+                     "a" (prev), "d" (next));                          \
 } while (0)
 
 #define _set_base(addr,base) do { unsigned long __pr; \
@@ -321,6 +318,13 @@
 #define __sti()                        __asm__ __volatile__("sti": : :"memory")
 /* used in the idle loop; sti takes one instruction cycle to complete */
 #define safe_halt()            __asm__ __volatile__("sti; hlt": : :"memory")
+
+#define irqs_disabled()                        \
+({                                     \
+       unsigned long flags;            \
+       __save_flags(flags);            \
+       !(flags & (1<<9));              \
+})
 
 /* For spinlocks etc */
 #define local_irq_save(x)      __asm__ __volatile__("pushfl ; popl %0 ; cli":"=g" (x): /* no input */ :"memory")
diff -urN linux-2.4.20/include/asm-ia64/bitops.h linux-2.4.20-o1-preempt/include/asm-ia64/bitops.h
--- linux-2.4.20/include/asm-ia64/bitops.h      Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/asm-ia64/bitops.h   Tue Feb 18 03:51:30 2003
@@ -2,10 +2,15 @@
 #define _ASM_IA64_BITOPS_H
 
 /*
- * Copyright (C) 1998-2001 Hewlett-Packard Co
- * Copyright (C) 1998-2001 David Mosberger-Tang <davidm@hpl.hp.com>
+ * Copyright (C) 1998-2002 Hewlett-Packard Co
+ *     David Mosberger-Tang <davidm@hpl.hp.com>
+ *
+ * 02/06/02 find_next_bit() and find_first_bit() added from Erich Focht's ia64 O(1)
+ *         scheduler patch
  */
 
+#include <linux/types.h>
+
 #include <asm/system.h>
 
 /**
@@ -89,6 +94,17 @@
 }
 
 /**
+ * __clear_bit - Clears a bit in memory (non-atomic version)
+ */
+static __inline__ void
+__clear_bit (int nr, volatile void *addr)
+{
+       volatile __u32 *p = (__u32 *) addr + (nr >> 5);
+       __u32 m = 1 << (nr & 31);
+       *p &= ~m;
+}
+
+/**
  * change_bit - Toggle a bit in memory
  * @nr: Bit to clear
  * @addr: Address to start counting from
@@ -264,12 +280,11 @@
 }
 
 /**
- * ffz - find the first zero bit in a memory region
- * @x: The address to start the search at
+ * ffz - find the first zero bit in a long word
+ * @x: The long word to find the bit in
  *
- * Returns the bit-number (0..63) of the first (least significant) zero bit, not
- * the number of the byte containing a bit.  Undefined if no zero exists, so
- * code should check against ~0UL first...
+ * Returns the bit-number (0..63) of the first (least significant) zero bit.  Undefined if
+ * no zero exists, so code should check against ~0UL first...
  */
 static inline unsigned long
 ffz (unsigned long x)
@@ -280,6 +295,21 @@
        return result;
 }
 
+/**
+ * __ffs - find first bit in word.
+ * @x: The word to search
+ *
+ * Undefined if no bit exists, so code should check against 0 first.
+ */
+static __inline__ unsigned long
+__ffs (unsigned long x)
+{
+       unsigned long result;
+
+       __asm__ ("popcnt %0=%1" : "=r" (result) : "r" ((x - 1) & ~x));
+       return result;
+}
+
 #ifdef __KERNEL__
 
 /*
@@ -296,6 +326,12 @@
        return exp - 0xffff;
 }
 
+static int
+fls (int x)
+{
+       return ia64_fls((unsigned int) x);
+}
+
 /*
  * ffs: find first bit set. This is defined the same way as the libc and compiler builtin
  * ffs routines, therefore differs in spirit from the above ffz (man ffs): it operates on
@@ -368,8 +404,53 @@
  */
 #define find_first_zero_bit(addr, size) find_next_zero_bit((addr), (size), 0)
 
+/*
+ * Find next bit in a bitmap reasonably efficiently..
+ */
+static inline int
+find_next_bit (void *addr, unsigned long size, unsigned long offset)
+{
+       unsigned long *p = ((unsigned long *) addr) + (offset >> 6);
+       unsigned long result = offset & ~63UL;
+       unsigned long tmp;
+
+       if (offset >= size)
+               return size;
+       size -= result;
+       offset &= 63UL;
+       if (offset) {
+               tmp = *(p++);
+               tmp &= ~0UL << offset;
+               if (size < 64)
+                       goto found_first;
+               if (tmp)
+                       goto found_middle;
+               size -= 64;
+               result += 64;
+       }
+       while (size & ~63UL) {
+               if ((tmp = *(p++)))
+                       goto found_middle;
+               result += 64;
+               size -= 64;
+       }
+       if (!size)
+               return result;
+       tmp = *p;
+  found_first:
+       tmp &= ~0UL >> (64-size);
+       if (tmp == 0UL)         /* Are any bits set? */
+               return result + size; /* Nope. */
+  found_middle:
+       return result + __ffs(tmp);
+}
+
+#define find_first_bit(addr, size) find_next_bit((addr), (size), 0)
+
 #ifdef __KERNEL__
 
+#define __clear_bit(nr, addr)        clear_bit(nr, addr)
+
 #define ext2_set_bit                 test_and_set_bit
 #define ext2_clear_bit               test_and_clear_bit
 #define ext2_test_bit                test_bit
@@ -382,6 +463,16 @@
 #define minix_test_and_clear_bit(nr,addr)      test_and_clear_bit(nr,addr)
 #define minix_test_bit(nr,addr)                        test_bit(nr,addr)
 #define minix_find_first_zero_bit(addr,size)   find_first_zero_bit(addr,size)
+
+static inline int
+_sched_find_first_bit (unsigned long *b)
+{
+       if (unlikely(b[0]))
+               return __ffs(b[0]);
+       if (unlikely(b[1]))
+               return 64 + __ffs(b[1]);
+       return __ffs(b[2]) + 128;
+}
 
 #endif /* __KERNEL__ */
 
diff -urN linux-2.4.20/include/asm-m68k/bitops.h linux-2.4.20-o1-preempt/include/asm-m68k/bitops.h
--- linux-2.4.20/include/asm-m68k/bitops.h      Thu Oct 25 22:53:55 2001
+++ linux-2.4.20-o1-preempt/include/asm-m68k/bitops.h   Tue Feb 18 03:51:30 2003
@@ -97,6 +97,7 @@
   (__builtin_constant_p(nr) ? \
    __constant_clear_bit(nr, vaddr) : \
    __generic_clear_bit(nr, vaddr))
+#define __clear_bit(nr,vaddr) clear_bit(nr,vaddr)
 
 extern __inline__ void __constant_clear_bit(int nr, volatile void * vaddr)
 {
@@ -239,6 +240,28 @@
 
        return 32 - cnt;
 }
+#define __ffs(x) (ffs(x) - 1)
+
+
+/*
+ * Every architecture must define this function. It's the fastest
+ * way of searching a 140-bit bitmap where the first 100 bits are
+ * unlikely to be set. It's guaranteed that at least one of the 140
+ * bits is cleared.
+ */
+static inline int _sched_find_first_bit(unsigned long *b)
+{
+       if (unlikely(b[0]))
+               return __ffs(b[0]);
+       if (unlikely(b[1]))
+               return __ffs(b[1]) + 32;
+       if (unlikely(b[2]))
+               return __ffs(b[2]) + 64;
+       if (b[3])
+               return __ffs(b[3]) + 96;
+       return __ffs(b[4]) + 128;
+}
+
 
 /*
  * hweightN: returns the hamming weight (i.e. the number
diff -urN linux-2.4.20/include/asm-mips/bitops.h linux-2.4.20-o1-preempt/include/asm-mips/bitops.h
--- linux-2.4.20/include/asm-mips/bitops.h      Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/asm-mips/bitops.h   Tue Feb 18 03:51:30 2003
@@ -43,6 +43,8 @@
 
 #ifdef CONFIG_CPU_HAS_LLSC
 
+#include <asm/mipsregs.h>
+
 /*
  * These functions for MIPS ISA > 1 are interrupt and SMP proof and
  * interrupt friendly
@@ -628,7 +630,8 @@
                "2:"
                : "=r" (res), "=r" (dummy), "=r" (addr)
                : "0" ((signed int) 0), "1" ((unsigned int) 0xffffffff),
-                 "2" (addr), "r" (size));
+                 "2" (addr), "r" (size)
+               : "$1");
 
        return res;
 }
@@ -663,7 +666,8 @@
                        ".set\treorder\n"
                        "1:"
                        : "=r" (set), "=r" (dummy)
-                       : "0" (0), "1" (1 << bit), "r" (*p));
+                       : "0" (0), "1" (1 << bit), "r" (*p)
+                       : "$1");
                if (set < (32 - bit))
                        return set + offset;
                set = 32 - bit;
@@ -684,20 +688,29 @@
  *
  * Undefined if no zero exists, so code should check against ~0UL first.
  */
-static __inline__ unsigned long ffz(unsigned long word)
+extern __inline__ unsigned long ffz(unsigned long word)
 {
-       int b = 0, s;
+       unsigned int    __res;
+       unsigned int    mask = 1;
 
-       word = ~word;
-       s = 16; if (word << 16 != 0) s = 0; b += s; word >>= s;
-       s =  8; if (word << 24 != 0) s = 0; b += s; word >>= s;
-       s =  4; if (word << 28 != 0) s = 0; b += s; word >>= s;
-       s =  2; if (word << 30 != 0) s = 0; b += s; word >>= s;
-       s =  1; if (word << 31 != 0) s = 0; b += s;
+       __asm__ (
+               ".set\tnoreorder\n\t"
+               ".set\tnoat\n\t"
+               "move\t%0,$0\n"
+               "1:\tand\t$1,%2,%1\n\t"
+               "beqz\t$1,2f\n\t"
+               "sll\t%1,1\n\t"
+               "bnez\t%1,1b\n\t"
+               "addiu\t%0,1\n\t"
+               ".set\tat\n\t"
+               ".set\treorder\n"
+               "2:\n\t"
+               : "=&r" (__res), "=r" (mask)
+               : "r" (word), "1" (mask)
+               : "$1");
 
-       return b;
+       return __res;
 }
-
 
 #ifdef __KERNEL__
 
diff -urN linux-2.4.20/include/asm-mips/smplock.h linux-2.4.20-o1-preempt/include/asm-mips/smplock.h
--- linux-2.4.20/include/asm-mips/smplock.h     Sat Aug  3 02:39:45 2002
+++ linux-2.4.20-o1-preempt/include/asm-mips/smplock.h  Tue Feb 18 03:52:06 2003
@@ -5,12 +5,21 @@
  *
  * Default SMP lock implementation
  */
+#include <linux/config.h>
 #include <linux/interrupt.h>
 #include <linux/spinlock.h>
 
 extern spinlock_t kernel_flag;
 
+#ifdef CONFIG_SMP
 #define kernel_locked()                spin_is_locked(&kernel_flag)
+#else
+#ifdef CONFIG_PREEMPT
+#define kernel_locked()         preempt_get_count()
+#else
+#define kernel_locked()         1
+#endif
+#endif
 
 /*
  * Release global kernel lock and global interrupt lock
@@ -42,8 +51,14 @@
  */
 extern __inline__ void lock_kernel(void)
 {
+#ifdef CONFIG_PREEMPT
+       if (current->lock_depth == -1)
+               spin_lock(&kernel_flag);
+       ++current->lock_depth;
+#else
        if (!++current->lock_depth)
                spin_lock(&kernel_flag);
+#endif
 }
 
 extern __inline__ void unlock_kernel(void)
diff -urN linux-2.4.20/include/asm-mips/softirq.h linux-2.4.20-o1-preempt/include/asm-mips/softirq.h
--- linux-2.4.20/include/asm-mips/softirq.h     Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/asm-mips/softirq.h  Tue Feb 18 03:52:06 2003
@@ -15,6 +15,7 @@
 
 static inline void cpu_bh_disable(int cpu)
 {
+       preempt_disable();
        local_bh_count(cpu)++;
        barrier();
 }
@@ -23,6 +24,7 @@
 {
        barrier();
        local_bh_count(cpu)--;
+       preempt_enable();
 }
 
 
@@ -36,6 +38,7 @@
        cpu = smp_processor_id();                               \
        if (!--local_bh_count(cpu) && softirq_pending(cpu))     \
                do_softirq();                                   \
+       preempt_enable();                                       \
 } while (0)
 
 #define in_softirq() (local_bh_count(smp_processor_id()) != 0)
diff -urN linux-2.4.20/include/asm-mips/system.h linux-2.4.20-o1-preempt/include/asm-mips/system.h
--- linux-2.4.20/include/asm-mips/system.h      Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/asm-mips/system.h   Tue Feb 18 03:52:06 2003
@@ -322,4 +322,18 @@
 #define die_if_kernel(msg, regs)                                       \
        __die_if_kernel(msg, regs, __FILE__ ":", __FUNCTION__, __LINE__)
 
+extern __inline__ int intr_on(void)
+{
+       unsigned long flags;
+       save_flags(flags);
+       return flags & 1;
+}
+
+extern __inline__ int intr_off(void)
+{
+       return ! intr_on();
+}
+
+#define irqs_disabled()        intr_off()
+
 #endif /* _ASM_SYSTEM_H */
diff -urN linux-2.4.20/include/asm-mips64/bitops.h linux-2.4.20-o1-preempt/include/asm-mips64/bitops.h
--- linux-2.4.20/include/asm-mips64/bitops.h    Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/asm-mips64/bitops.h Tue Feb 18 03:51:30 2003
@@ -19,6 +19,7 @@
 
 #include <asm/system.h>
 #include <asm/sgidefs.h>
+#include <asm/mipsregs.h>
 
 /*
  * set_bit - Atomically set a bit in memory
@@ -30,7 +31,8 @@
  * Note that @nr may be almost arbitrarily large; this function is not
  * restricted to acting on a single-word quantity.
  */
-static inline void set_bit(unsigned long nr, volatile void *addr)
+extern __inline__ void
+set_bit(unsigned long nr, volatile void *addr)
 {
        unsigned long *m = ((unsigned long *) addr) + (nr >> 6);
        unsigned long temp;
@@ -54,7 +56,7 @@
  * If it's called on the same region of memory simultaneously, the effect
  * may be that only one operation succeeds.
  */
-static inline void __set_bit(int nr, volatile void * addr)
+extern __inline__ void __set_bit(int nr, volatile void * addr)
 {
        unsigned long * m = ((unsigned long *) addr) + (nr >> 6);
 
@@ -71,7 +73,8 @@
  * you should call smp_mb__before_clear_bit() and/or smp_mb__after_clear_bit()
  * in order to ensure changes are visible on other processors.
  */
-static inline void clear_bit(unsigned long nr, volatile void *addr)
+extern __inline__ void
+clear_bit(unsigned long nr, volatile void *addr)
 {
        unsigned long *m = ((unsigned long *) addr) + (nr >> 6);
        unsigned long temp;
@@ -97,7 +100,8 @@
  * Note that @nr may be almost arbitrarily large; this function is not
  * restricted to acting on a single-word quantity.
  */
-static inline void change_bit(unsigned long nr, volatile void *addr)
+extern __inline__ void
+change_bit(unsigned long nr, volatile void *addr)
 {
        unsigned long *m = ((unsigned long *) addr) + (nr >> 6);
        unsigned long temp;
@@ -120,7 +124,7 @@
  * If it's called on the same region of memory simultaneously, the effect
  * may be that only one operation succeeds.
  */
-static inline void __change_bit(int nr, volatile void * addr)
+extern __inline__ void __change_bit(int nr, volatile void * addr)
 {
        unsigned long * m = ((unsigned long *) addr) + (nr >> 6);
 
@@ -135,8 +139,8 @@
  * This operation is atomic and cannot be reordered.
  * It also implies a memory barrier.
  */
-static inline unsigned long test_and_set_bit(unsigned long nr,
-                                            volatile void *addr)
+extern __inline__ unsigned long
+test_and_set_bit(unsigned long nr, volatile void *addr)
 {
        unsigned long *m = ((unsigned long *) addr) + (nr >> 6);
        unsigned long temp, res;
@@ -168,7 +172,8 @@
  * If two examples of this operation race, one can appear to succeed
  * but actually fail.  You must protect multiple accesses with a lock.
  */
-static inline int __test_and_set_bit(int nr, volatile void *addr)
+extern __inline__ int
+__test_and_set_bit(int nr, volatile void * addr)
 {
        unsigned long mask, retval;
        long *a = (unsigned long *) addr;
@@ -189,8 +194,8 @@
  * This operation is atomic and cannot be reordered.
  * It also implies a memory barrier.
  */
-static inline unsigned long test_and_clear_bit(unsigned long nr,
-                                              volatile void *addr)
+extern __inline__ unsigned long
+test_and_clear_bit(unsigned long nr, volatile void *addr)
 {
        unsigned long *m = ((unsigned long *) addr) + (nr >> 6);
        unsigned long temp, res;
@@ -223,7 +228,8 @@
  * If two examples of this operation race, one can appear to succeed
  * but actually fail.  You must protect multiple accesses with a lock.
  */
-static inline int __test_and_clear_bit(int nr, volatile void * addr)
+extern __inline__ int
+__test_and_clear_bit(int nr, volatile void * addr)
 {
        unsigned long mask, retval;
        unsigned long *a = (unsigned long *) addr;
@@ -244,8 +250,8 @@
  * This operation is atomic and cannot be reordered.
  * It also implies a memory barrier.
  */
-static inline unsigned long test_and_change_bit(unsigned long nr,
-                                               volatile void *addr)
+extern __inline__ unsigned long
+test_and_change_bit(unsigned long nr, volatile void *addr)
 {
        unsigned long *m = ((unsigned long *) addr) + (nr >> 6);
        unsigned long temp, res;
@@ -277,7 +283,8 @@
  * If two examples of this operation race, one can appear to succeed
  * but actually fail.  You must protect multiple accesses with a lock.
  */
-static inline int __test_and_change_bit(int nr, volatile void *addr)
+extern __inline__ int
+__test_and_change_bit(int nr, volatile void * addr)
 {
        unsigned long mask, retval;
        unsigned long *a = (unsigned long *) addr;
@@ -294,7 +301,8 @@
  * @nr: bit number to test
  * @addr: Address to start counting from
  */
-static inline unsigned long test_bit(int nr, volatile void * addr)
+extern __inline__ unsigned long
+test_bit(int nr, volatile void * addr)
 {
        return 1UL & (((volatile unsigned long *) addr)[nr >> 6] >> (nr & 0x3f));
 }
@@ -311,7 +319,8 @@
  * Returns the bit-number of the first zero bit, not the number of the byte
  * containing a bit.
  */
-static inline int find_first_zero_bit (void *addr, unsigned size)
+extern __inline__ int
+find_first_zero_bit (void *addr, unsigned size)
 {
        unsigned long dummy;
        int res;
@@ -347,7 +356,8 @@
                "2:"
                : "=r" (res), "=r" (dummy), "=r" (addr)
                : "0" ((signed int) 0), "1" ((unsigned int) 0xffffffff),
-                 "2" (addr), "r" (size));
+                 "2" (addr), "r" (size)
+               : "$1");
 
        return res;
 }
@@ -358,7 +368,8 @@
  * @offset: The bitnumber to start searching at
  * @size: The maximum size to search
  */
-static inline int find_next_zero_bit (void * addr, int size, int offset)
+extern __inline__ int
+find_next_zero_bit (void * addr, int size, int offset)
 {
        unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
        int set = 0, bit = offset & 31, res;
@@ -379,7 +390,8 @@
                        ".set\treorder\n"
                        "1:"
                        : "=r" (set), "=r" (dummy)
-                       : "0" (0), "1" (1 << bit), "r" (*p));
+                       : "0" (0), "1" (1 << bit), "r" (*p)
+                       : "$1");
                if (set < (32 - bit))
                        return set + offset;
                set = 32 - bit;
@@ -400,19 +412,20 @@
  *
  * Undefined if no zero exists, so code should check against ~0UL first.
  */
-static __inline__ unsigned long ffz(unsigned long word)
+extern __inline__ unsigned long ffz(unsigned long word)
 {
-       int b = 0, s;
+       unsigned long k;
 
        word = ~word;
-        s = 32; if (word << 32 != 0) s = 0; b += s; word >>= s;
-        s = 16; if (word << 48 != 0) s = 0; b += s; word >>= s;
-        s =  8; if (word << 56 != 0) s = 0; b += s; word >>= s;
-        s =  4; if (word << 60 != 0) s = 0; b += s; word >>= s;
-        s =  2; if (word << 62 != 0) s = 0; b += s; word >>= s;
-        s =  1; if (word << 63 != 0) s = 0; b += s;
+       k = 63;
+       if (word & 0x00000000ffffffffUL) { k -= 32; word <<= 32; }
+       if (word & 0x0000ffff00000000UL) { k -= 16; word <<= 16; }
+       if (word & 0x00ff000000000000UL) { k -= 8;  word <<= 8;  }
+       if (word & 0x0f00000000000000UL) { k -= 4;  word <<= 4;  }
+       if (word & 0x3000000000000000UL) { k -= 2;  word <<= 2;  }
+       if (word & 0x4000000000000000UL) { k -= 1; }
 
-       return b;
+       return k;
 }
 
 #ifdef __KERNEL__
@@ -450,8 +463,8 @@
  * @offset: The bitnumber to start searching at
  * @size: The maximum size to search
  */
-static inline unsigned long find_next_zero_bit(void *addr, unsigned long size,
-                                              unsigned long offset)
+extern __inline__ unsigned long
+find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
 {
        unsigned long *p = ((unsigned long *) addr) + (offset >> 6);
        unsigned long result = offset & ~63UL;
@@ -498,7 +511,8 @@
 
 #ifdef __MIPSEB__
 
-static inline int ext2_set_bit(int nr,void * addr)
+extern inline int
+ext2_set_bit(int nr,void * addr)
 {
        int             mask, retval, flags;
        unsigned char   *ADDR = (unsigned char *) addr;
@@ -512,7 +526,8 @@
        return retval;
 }
 
-static inline int ext2_clear_bit(int nr, void * addr)
+extern inline int
+ext2_clear_bit(int nr, void * addr)
 {
        int             mask, retval, flags;
        unsigned char   *ADDR = (unsigned char *) addr;
@@ -526,7 +541,8 @@
        return retval;
 }
 
-static inline int ext2_test_bit(int nr, const void * addr)
+extern inline int
+ext2_test_bit(int nr, const void * addr)
 {
        int                     mask;
        const unsigned char     *ADDR = (const unsigned char *) addr;
@@ -539,9 +555,8 @@
 #define ext2_find_first_zero_bit(addr, size) \
         ext2_find_next_zero_bit((addr), (size), 0)
 
-static inline unsigned int ext2_find_next_zero_bit(void *addr,
-                                                  unsigned long size,
-                                                  unsigned long offset)
+extern inline unsigned int
+ext2_find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
 {
        unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
        unsigned int result = offset & ~31UL;
diff -urN linux-2.4.20/include/asm-ppc/bitops.h linux-2.4.20-o1-preempt/include/asm-ppc/bitops.h
--- linux-2.4.20/include/asm-ppc/bitops.h       Tue Jun 12 04:15:27 2001
+++ linux-2.4.20-o1-preempt/include/asm-ppc/bitops.h    Tue Feb 18 03:51:30 2003
@@ -10,7 +10,9 @@
 #define _PPC_BITOPS_H
 
 #include <linux/config.h>
+#include <linux/compiler.h>
 #include <asm/byteorder.h>
+#include <asm/atomic.h>
 
 /*
  * The test_and_*_bit operations are taken to imply a memory barrier
@@ -28,7 +30,7 @@
  * These used to be if'd out here because using : "cc" as a constraint
  * resulted in errors from egcs.  Things appear to be OK with gcc-2.95.
  */
-static __inline__ void set_bit(int nr, volatile void * addr)
+static __inline__ void set_bit(int nr, volatile unsigned long * addr)
 {
        unsigned long old;
        unsigned long mask = 1 << (nr & 0x1f);
@@ -37,6 +39,7 @@
        __asm__ __volatile__("\n\
 1:     lwarx   %0,0,%3 \n\
        or      %0,%0,%2 \n\
+       dcbt    0,%3 \n\
        stwcx.  %0,0,%3 \n\
        bne-    1b"
        : "=&r" (old), "=m" (*p)
@@ -47,7 +50,7 @@
 /*
  * non-atomic version
  */
-static __inline__ void __set_bit(int nr, volatile void *addr)
+static __inline__ void __set_bit(int nr, volatile unsigned long *addr)
 {
        unsigned long mask = 1 << (nr & 0x1f);
        unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
@@ -61,7 +64,7 @@
 #define smp_mb__before_clear_bit()     smp_mb()
 #define smp_mb__after_clear_bit()      smp_mb()
 
-static __inline__ void clear_bit(int nr, volatile void *addr)
+static __inline__ void clear_bit(int nr, volatile unsigned long *addr)
 {
        unsigned long old;
        unsigned long mask = 1 << (nr & 0x1f);
@@ -70,6 +73,7 @@
        __asm__ __volatile__("\n\
 1:     lwarx   %0,0,%3 \n\
        andc    %0,%0,%2 \n\
+       dcbt    0,%3 \n\
        stwcx.  %0,0,%3 \n\
        bne-    1b"
        : "=&r" (old), "=m" (*p)
@@ -80,7 +84,7 @@
 /*
  * non-atomic version
  */
-static __inline__ void __clear_bit(int nr, volatile void *addr)
+static __inline__ void __clear_bit(int nr, volatile unsigned long *addr)
 {
        unsigned long mask = 1 << (nr & 0x1f);
        unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
@@ -88,7 +92,7 @@
        *p &= ~mask;
 }
 
-static __inline__ void change_bit(int nr, volatile void *addr)
+static __inline__ void change_bit(int nr, volatile unsigned long *addr)
 {
        unsigned long old;
        unsigned long mask = 1 << (nr & 0x1f);
@@ -97,6 +101,7 @@
        __asm__ __volatile__("\n\
 1:     lwarx   %0,0,%3 \n\
        xor     %0,%0,%2 \n\
+       dcbt    0,%3 \n\
        stwcx.  %0,0,%3 \n\
        bne-    1b"
        : "=&r" (old), "=m" (*p)
@@ -107,7 +112,7 @@
 /*
  * non-atomic version
  */
-static __inline__ void __change_bit(int nr, volatile void *addr)
+static __inline__ void __change_bit(int nr, volatile unsigned long *addr)
 {
        unsigned long mask = 1 << (nr & 0x1f);
        unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
@@ -118,7 +123,7 @@
 /*
  * test_and_*_bit do imply a memory barrier (?)
  */
-static __inline__ int test_and_set_bit(int nr, volatile void *addr)
+static __inline__ int test_and_set_bit(int nr, volatile unsigned long *addr)
 {
        unsigned int old, t;
        unsigned int mask = 1 << (nr & 0x1f);
@@ -127,6 +132,7 @@
        __asm__ __volatile__(SMP_WMB "\n\
 1:     lwarx   %0,0,%4 \n\
        or      %1,%0,%3 \n\
+       dcbt    0,%4 \n\
        stwcx.  %1,0,%4 \n\
        bne     1b"
        SMP_MB
@@ -140,7 +146,7 @@
 /*
  * non-atomic version
  */
-static __inline__ int __test_and_set_bit(int nr, volatile void *addr)
+static __inline__ int __test_and_set_bit(int nr, volatile unsigned long *addr)
 {
        unsigned long mask = 1 << (nr & 0x1f);
        unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
@@ -150,7 +156,7 @@
        return (old & mask) != 0;
 }
 
-static __inline__ int test_and_clear_bit(int nr, volatile void *addr)
+static __inline__ int test_and_clear_bit(int nr, volatile unsigned long *addr)
 {
        unsigned int old, t;
        unsigned int mask = 1 << (nr & 0x1f);
@@ -159,6 +165,7 @@
        __asm__ __volatile__(SMP_WMB "\n\
 1:     lwarx   %0,0,%4 \n\
        andc    %1,%0,%3 \n\
+       dcbt    0,%4 \n\
        stwcx.  %1,0,%4 \n\
        bne     1b"
        SMP_MB
@@ -172,7 +179,7 @@
 /*
  * non-atomic version
  */
-static __inline__ int __test_and_clear_bit(int nr, volatile void *addr)
+static __inline__ int __test_and_clear_bit(int nr, volatile unsigned long *addr)
 {
        unsigned long mask = 1 << (nr & 0x1f);
        unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
@@ -182,7 +189,7 @@
        return (old & mask) != 0;
 }
 
-static __inline__ int test_and_change_bit(int nr, volatile void *addr)
+static __inline__ int test_and_change_bit(int nr, volatile unsigned long *addr)
 {
        unsigned int old, t;
        unsigned int mask = 1 << (nr & 0x1f);
@@ -191,6 +198,7 @@
        __asm__ __volatile__(SMP_WMB "\n\
 1:     lwarx   %0,0,%4 \n\
        xor     %1,%0,%3 \n\
+       dcbt    0,%4 \n\
        stwcx.  %1,0,%4 \n\
        bne     1b"
        SMP_MB
@@ -204,7 +212,7 @@
 /*
  * non-atomic version
  */
-static __inline__ int __test_and_change_bit(int nr, volatile void *addr)
+static __inline__ int __test_and_change_bit(int nr, volatile unsigned long *addr)
 {
        unsigned long mask = 1 << (nr & 0x1f);
        unsigned long *p = ((unsigned long *)addr) + (nr >> 5);
@@ -214,7 +222,7 @@
        return (old & mask) != 0;
 }
 
-static __inline__ int test_bit(int nr, __const__ volatile void *addr)
+static __inline__ int test_bit(int nr, __const__ volatile unsigned long *addr)
 {
        __const__ unsigned int *p = (__const__ unsigned int *) addr;
 
@@ -222,7 +230,7 @@
 }
 
 /* Return the bit position of the most significant 1 bit in a word */
-static __inline__ int __ilog2(unsigned int x)
+static __inline__ int __ilog2(unsigned long x)
 {
        int lz;
 
@@ -230,7 +238,7 @@
        return 31 - lz;
 }
 
-static __inline__ int ffz(unsigned int x)
+static __inline__ int ffz(unsigned long x)
 {
        if ((x = ~x) == 0)
                return 32;
@@ -239,6 +247,11 @@
 
 #ifdef __KERNEL__
 
+static inline int __ffs(unsigned long x)
+{
+       return __ilog2(x & -x);
+}
+
 /*
  * ffs: find first bit set. This is defined the same way as
  * the libc and compiler builtin ffs routines, therefore
@@ -250,6 +263,18 @@
 }
 
 /*
+ * fls: find last (most-significant) bit set.
+ * Note fls(0) = 0, fls(1) = 1, fls(0x80000000) = 32.
+ */
+static __inline__ int fls(unsigned int x)
+{
+       int lz;
+
+       asm ("cntlzw %0,%1" : "=r" (lz) : "r" (x));
+       return 32 - lz;
+}
+
+/*
  * hweightN: returns the hamming weight (i.e. the number
  * of bits set) of a N-bit word
  */
@@ -261,13 +286,86 @@
 #endif /* __KERNEL__ */
 
 /*
+ * Find the first bit set in a 140-bit bitmap.
+ * The first 100 bits are unlikely to be set.
+ */
+static inline int _sched_find_first_bit(unsigned long *b)
+{
+       if (unlikely(b[0]))
+               return __ffs(b[0]);
+       if (unlikely(b[1]))
+               return __ffs(b[1]) + 32;
+       if (unlikely(b[2]))
+               return __ffs(b[2]) + 64;
+       if (b[3])
+               return __ffs(b[3]) + 96;
+       return __ffs(b[4]) + 128;
+}
+
+/**
+ * find_next_bit - find the next set bit in a memory region
+ * @addr: The address to base the search on
+ * @offset: The bitnumber to start searching at
+ * @size: The maximum size to search
+ */
+static __inline__ unsigned long find_next_bit(unsigned long *addr,
+       unsigned long size, unsigned long offset)
+{
+       unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
+       unsigned int result = offset & ~31UL;
+       unsigned int tmp;
+
+       if (offset >= size)
+               return size;
+       size -= result;
+       offset &= 31UL;
+       if (offset) {
+               tmp = *p++;
+               tmp &= ~0UL << offset;
+               if (size < 32)
+                       goto found_first;
+               if (tmp)
+                       goto found_middle;
+               size -= 32;
+               result += 32;
+       }
+       while (size >= 32) {
+               if ((tmp = *p++) != 0)
+                       goto found_middle;
+               result += 32;
+               size -= 32;
+       }
+       if (!size)
+               return result;
+       tmp = *p;
+
+found_first:
+       tmp &= ~0UL >> (32 - size);
+       if (tmp == 0UL)        /* Are any bits set? */
+               return result + size; /* Nope. */
+found_middle:
+       return result + __ffs(tmp);
+}
+
+/**
+ * find_first_bit - find the first set bit in a memory region
+ * @addr: The address to start the search at
+ * @size: The maximum size to search
+ *
+ * Returns the bit-number of the first set bit, not the number of the byte
+ * containing a bit.
+ */
+#define find_first_bit(addr, size) \
+       find_next_bit((addr), (size), 0)
+
+/*
  * This implementation of find_{first,next}_zero_bit was stolen from
  * Linus' asm-alpha/bitops.h.
  */
 #define find_first_zero_bit(addr, size) \
        find_next_zero_bit((addr), (size), 0)
 
-static __inline__ unsigned long find_next_zero_bit(void * addr,
+static __inline__ unsigned long find_next_zero_bit(unsigned long * addr,
        unsigned long size, unsigned long offset)
 {
        unsigned int * p = ((unsigned int *) addr) + (offset >> 5);
@@ -308,8 +406,8 @@
 
 #ifdef __KERNEL__
 
-#define ext2_set_bit(nr, addr)         __test_and_set_bit((nr) ^ 0x18, addr)
-#define ext2_clear_bit(nr, addr)       __test_and_clear_bit((nr) ^ 0x18, addr)
+#define ext2_set_bit(nr, addr) __test_and_set_bit((nr) ^ 0x18, (unsigned long *)(addr))
+#define ext2_clear_bit(nr, addr) __test_and_clear_bit((nr) ^ 0x18, (unsigned long *)(addr))
 
 static __inline__ int ext2_test_bit(int nr, __const__ void * addr)
 {
diff -urN linux-2.4.20/include/asm-ppc/dma.h linux-2.4.20-o1-preempt/include/asm-ppc/dma.h
--- linux-2.4.20/include/asm-ppc/dma.h  Tue May 22 00:02:06 2001
+++ linux-2.4.20-o1-preempt/include/asm-ppc/dma.h       Tue Feb 18 03:52:06 2003
@@ -14,6 +14,7 @@
 #include <linux/config.h>
 #include <asm/io.h>
 #include <linux/spinlock.h>
+#include <linux/sched.h>
 #include <asm/system.h>
 
 /*
diff -urN linux-2.4.20/include/asm-ppc/hardirq.h linux-2.4.20-o1-preempt/include/asm-ppc/hardirq.h
--- linux-2.4.20/include/asm-ppc/hardirq.h      Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/asm-ppc/hardirq.h   Tue Feb 18 03:52:06 2003
@@ -48,6 +48,7 @@
 #define hardirq_exit(cpu)      (local_irq_count(cpu)--)
 
 #define synchronize_irq()      do { } while (0)
+#define release_irqlock(cpu)   do { } while (0)
 
 #else /* CONFIG_SMP */
 
diff -urN linux-2.4.20/include/asm-ppc/highmem.h linux-2.4.20-o1-preempt/include/asm-ppc/highmem.h
--- linux-2.4.20/include/asm-ppc/highmem.h      Mon Jul  2 23:34:57 2001
+++ linux-2.4.20-o1-preempt/include/asm-ppc/highmem.h   Tue Feb 18 03:52:06 2003
@@ -84,6 +84,7 @@
        unsigned int idx;
        unsigned long vaddr;
 
+       preempt_disable();
        if (page < highmem_start_page)
                return page_address(page);
 
@@ -105,8 +106,10 @@
        unsigned long vaddr = (unsigned long) kvaddr;
        unsigned int idx = type + KM_TYPE_NR*smp_processor_id();
 
-       if (vaddr < KMAP_FIX_BEGIN) // FIXME
+       if (vaddr < KMAP_FIX_BEGIN) { // FIXME
+               preempt_enable();
                return;
+       }
 
        if (vaddr != KMAP_FIX_BEGIN + idx * PAGE_SIZE)
                BUG();
@@ -118,6 +121,7 @@
        pte_clear(kmap_pte+idx);
        flush_tlb_page(0, vaddr);
 #endif
+       preempt_enable();
 }
 
 #endif /* __KERNEL__ */
diff -urN linux-2.4.20/include/asm-ppc/hw_irq.h linux-2.4.20-o1-preempt/include/asm-ppc/hw_irq.h
--- linux-2.4.20/include/asm-ppc/hw_irq.h       Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/asm-ppc/hw_irq.h    Tue Feb 18 03:52:06 2003
@@ -22,6 +22,12 @@
 #define __save_flags(flags) __save_flags_ptr((unsigned long *)&flags)
 #define __save_and_cli(flags) ({__save_flags(flags);__cli();})
 
+#define mfmsr()                ({unsigned int rval; \
+                       asm volatile("mfmsr %0" : "=r" (rval)); rval;})
+#define mtmsr(v)       asm volatile("mtmsr %0" : : "r" (v))
+
+#define irqs_disabled()        ((mfmsr() & MSR_EE) == 0)
+
 extern void do_lost_interrupts(unsigned long);
 
 #define mask_irq(irq) ({if (irq_desc[irq].handler && irq_desc[irq].handler->disable) irq_desc[irq].handler->disable(irq);})
diff -urN linux-2.4.20/include/asm-ppc/mmu_context.h linux-2.4.20-o1-preempt/include/asm-ppc/mmu_context.h
--- linux-2.4.20/include/asm-ppc/mmu_context.h  Tue Oct  2 18:12:44 2001
+++ linux-2.4.20-o1-preempt/include/asm-ppc/mmu_context.h       Tue Feb 18 03:52:06 2003
@@ -158,6 +158,10 @@
 static inline void switch_mm(struct mm_struct *prev, struct mm_struct *next,
                             struct task_struct *tsk, int cpu)
 {
+#ifdef CONFIG_PREEMPT
+       if (preempt_get_count() == 0)
+               BUG();
+#endif
        tsk->thread.pgdir = next->pgd;
        get_mmu_context(next);
        set_context(next->context, next->pgd);
diff -urN linux-2.4.20/include/asm-ppc/pgalloc.h linux-2.4.20-o1-preempt/include/asm-ppc/pgalloc.h
--- linux-2.4.20/include/asm-ppc/pgalloc.h      Tue May 22 00:02:06 2001
+++ linux-2.4.20-o1-preempt/include/asm-ppc/pgalloc.h   Tue Feb 18 03:52:06 2003
@@ -68,20 +68,25 @@
 {
         unsigned long *ret;
 
+       preempt_disable();
         if ((ret = pgd_quicklist) != NULL) {
                 pgd_quicklist = (unsigned long *)(*ret);
                 ret[0] = 0;
                 pgtable_cache_size--;
+               preempt_enable();
         } else
+               preempt_enable();
                 ret = (unsigned long *)get_pgd_slow();
         return (pgd_t *)ret;
 }
 
 extern __inline__ void free_pgd_fast(pgd_t *pgd)
 {
+       preempt_disable();
         *(unsigned long **)pgd = pgd_quicklist;
         pgd_quicklist = (unsigned long *) pgd;
         pgtable_cache_size++;
+       preempt_enable();
 }
 
 extern __inline__ void free_pgd_slow(pgd_t *pgd)
@@ -120,19 +125,23 @@
 {
         unsigned long *ret;
 
+       preempt_disable();
         if ((ret = pte_quicklist) != NULL) {
                 pte_quicklist = (unsigned long *)(*ret);
                 ret[0] = 0;
                 pgtable_cache_size--;
        }
+       preempt_enable();
         return (pte_t *)ret;
 }
 
 extern __inline__ void pte_free_fast(pte_t *pte)
 {
+       preempt_disable();
         *(unsigned long **)pte = pte_quicklist;
         pte_quicklist = (unsigned long *) pte;
         pgtable_cache_size++;
+       preempt_enable();
 }
 
 extern __inline__ void pte_free_slow(pte_t *pte)
diff -urN linux-2.4.20/include/asm-ppc/smp.h linux-2.4.20-o1-preempt/include/asm-ppc/smp.h
--- linux-2.4.20/include/asm-ppc/smp.h  Sat Aug  3 02:39:45 2002
+++ linux-2.4.20-o1-preempt/include/asm-ppc/smp.h       Tue Feb 18 03:51:30 2003
@@ -48,7 +48,7 @@
 #define cpu_logical_map(cpu) (cpu)
 #define cpu_number_map(x) (x)
 
-#define smp_processor_id() (current->processor)
+#define smp_processor_id() (current->cpu)
 
 extern int smp_hw_index[NR_CPUS];
 #define hard_smp_processor_id() (smp_hw_index[smp_processor_id()])
diff -urN linux-2.4.20/include/asm-ppc/smplock.h linux-2.4.20-o1-preempt/include/asm-ppc/smplock.h
--- linux-2.4.20/include/asm-ppc/smplock.h      Sat Nov  3 02:43:54 2001
+++ linux-2.4.20-o1-preempt/include/asm-ppc/smplock.h   Tue Feb 18 03:52:06 2003
@@ -15,7 +15,15 @@
 
 extern spinlock_t kernel_flag;
 
+#ifdef CONFIG_SMP
 #define kernel_locked()                spin_is_locked(&kernel_flag)
+#else
+#ifdef CONFIG_PREEMPT
+#define kernel_locked()                preempt_get_count()
+#else
+#define kernel_locked()                1
+#endif
+#endif
 
 /*
  * Release global kernel lock and global interrupt lock
@@ -47,8 +55,14 @@
  */
 static __inline__ void lock_kernel(void)
 {
+#ifdef CONFIG_PREEMPT
+       if (current->lock_depth == -1)
+               spin_lock(&kernel_flag);
+       ++current->lock_depth;
+#else
        if (!++current->lock_depth)
                spin_lock(&kernel_flag);
+#endif
 }
 
 static __inline__ void unlock_kernel(void)
diff -urN linux-2.4.20/include/asm-ppc/softirq.h linux-2.4.20-o1-preempt/include/asm-ppc/softirq.h
--- linux-2.4.20/include/asm-ppc/softirq.h      Sat Sep  8 21:02:31 2001
+++ linux-2.4.20-o1-preempt/include/asm-ppc/softirq.h   Tue Feb 18 03:52:06 2003
@@ -10,6 +10,7 @@
 
 #define local_bh_disable()                     \
 do {                                           \
+       preempt_disable();                      \
        local_bh_count(smp_processor_id())++;   \
        barrier();                              \
 } while (0)
@@ -18,14 +19,21 @@
 do {                                           \
        barrier();                              \
        local_bh_count(smp_processor_id())--;   \
+       preempt_enable();                       \
 } while (0)
 
-#define local_bh_enable()                              \
+#define _local_bh_enable()                             \
 do {                                                   \
        if (!--local_bh_count(smp_processor_id())       \
            && softirq_pending(smp_processor_id())) {   \
                do_softirq();                           \
        }                                               \
+} while (0)
+
+#define local_bh_enable()                      \
+do {                                           \
+       _local_bh_enable();                     \
+       preempt_enable();                       \
 } while (0)
 
 #define in_softirq() (local_bh_count(smp_processor_id()) != 0)
--- linux-2.4.20/include/asm-ppc/spinlock.h.orig        Fri Nov 29 00:53:15 2002
+++ linux-2.4.20/include/asm-ppc/spinlock.h     Sun Mar  9 13:15:14 2003
@@ -44,17 +44,17 @@
 extern int spin_trylock(spinlock_t *lock);
 extern unsigned long __spin_trylock(volatile unsigned long *lock);
 
-#define spin_lock(lp)                  _spin_lock(lp)
-#define spin_unlock(lp)                        _spin_unlock(lp)
+#define _raw_spin_lock(lp)                     _spin_lock(lp)
+#define _raw_spin_unlock(lp)                   _spin_unlock(lp)
 
 #else /* ! SPINLOCK_DEBUG */
 
-static inline void spin_lock(spinlock_t *lock)
+static inline void _raw_spin_lock(spinlock_t *lock)
 {
        unsigned long tmp;
 
        __asm__ __volatile__(
-       "b      1f                      # spin_lock\n\
+       "b      1f                      # _raw_spin_lock\n\
 2:     lwzx    %0,0,%1\n\
        cmpwi   0,%0,0\n\
        bne+    2b\n\
@@ -69,13 +69,13 @@
        : "cr0", "memory");
 }
 
-static inline void spin_unlock(spinlock_t *lock)
+static inline void _raw_spin_unlock(spinlock_t *lock)
 {
-       __asm__ __volatile__("eieio             # spin_unlock": : :"memory");
+       __asm__ __volatile__("eieio             # _raw_spin_unlock": : :"memory");
        lock->lock = 0;
 }
 
-#define spin_trylock(lock) (!test_and_set_bit(0,(lock)))
+#define _raw_spin_trylock(lock) (!test_and_set_bit(0,(lock)))
 
 #endif
 
@@ -112,19 +112,19 @@
 extern void _write_lock(rwlock_t *rw);
 extern void _write_unlock(rwlock_t *rw);
 
-#define read_lock(rw)          _read_lock(rw)
-#define write_lock(rw)         _write_lock(rw)
-#define write_unlock(rw)       _write_unlock(rw)
-#define read_unlock(rw)                _read_unlock(rw)
+#define _raw_read_lock(rw)             _read_lock(rw)
+#define _raw_write_lock(rw)            _write_lock(rw)
+#define _raw_write_unlock(rw)  _write_unlock(rw)
+#define _raw_read_unlock(rw)           _read_unlock(rw)
 
 #else /* ! SPINLOCK_DEBUG */
 
-static __inline__ void read_lock(rwlock_t *rw)
+static __inline__ void _raw_read_lock(rwlock_t *rw)
 {
        unsigned int tmp;
 
        __asm__ __volatile__(
-       "b              2f              # read_lock\n\
+       "b              2f              # _raw_read_lock\n\
 1:     lwzx            %0,0,%1\n\
        cmpwi           0,%0,0\n\
        blt+            1b\n\
@@ -139,12 +139,12 @@
        : "cr0", "memory");
 }
 
-static __inline__ void read_unlock(rwlock_t *rw)
+static __inline__ void _raw_read_unlock(rwlock_t *rw)
 {
        unsigned int tmp;
 
        __asm__ __volatile__(
-       "eieio                          # read_unlock\n\
+       "eieio                          # _raw_read_unlock\n\
 1:     lwarx           %0,0,%1\n\
        addic           %0,%0,-1\n\
        stwcx.          %0,0,%1\n\
@@ -154,7 +154,7 @@
        : "cr0", "memory");
 }
 
-static __inline__ void write_lock(rwlock_t *rw)
+static __inline__ void _raw_write_lock(rwlock_t *rw)
 {
        unsigned int tmp;
 
@@ -174,9 +174,9 @@
        : "cr0", "memory");
 }
 
-static __inline__ void write_unlock(rwlock_t *rw)
+static __inline__ void _raw_write_unlock(rwlock_t *rw)
 {
-       __asm__ __volatile__("eieio             # write_unlock": : :"memory");
+       __asm__ __volatile__("eieio             # raw_write_unlock": : :"memory");
        rw->lock = 0;
 }
 
diff -urN linux-2.4.20/include/asm-ppc/unistd.h linux-2.4.20-o1-preempt/include/asm-ppc/unistd.h
--- linux-2.4.20/include/asm-ppc/unistd.h       Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/asm-ppc/unistd.h    Tue Feb 18 03:51:30 2003
@@ -228,7 +228,6 @@
 #define __NR_removexattr       218
 #define __NR_lremovexattr      219
 #define __NR_fremovexattr      220
-#if 0
 #define __NR_futex             221
 #define __NR_sched_setaffinity 222
 #define __NR_sched_getaffinity 223
@@ -240,7 +239,6 @@
 #define __NR_io_getevents      229
 #define __NR_io_submit         230
 #define __NR_io_cancel         231
-#endif
 
 #define __NR(n)        #n
 
diff -urN linux-2.4.20/include/asm-ppc64/bitops.h linux-2.4.20-o1-preempt/include/asm-ppc64/bitops.h
--- linux-2.4.20/include/asm-ppc64/bitops.h     Sat Aug  3 02:39:45 2002
+++ linux-2.4.20-o1-preempt/include/asm-ppc64/bitops.h  Tue Feb 18 03:51:30 2003
@@ -33,7 +33,6 @@
 
 #ifdef __KERNEL__
 
-#include <asm/byteorder.h>
 #include <asm/memory.h>
 
 /*
@@ -42,12 +41,12 @@
 #define smp_mb__before_clear_bit()     smp_mb()
 #define smp_mb__after_clear_bit()      smp_mb()
 
-static __inline__ int test_bit(unsigned long nr, __const__ volatile void *addr)
+static __inline__ int test_bit(unsigned long nr, __const__ volatile unsigned long *addr)
 {
        return (1UL & (((__const__ long *) addr)[nr >> 6] >> (nr & 63)));
 }
 
-static __inline__ void set_bit(unsigned long nr, volatile void *addr)
+static __inline__ void set_bit(unsigned long nr, volatile unsigned long *addr)
 {
        unsigned long old;
        unsigned long mask = 1UL << (nr & 0x3f);
@@ -63,7 +62,7 @@
        : "cc");
 }
 
-static __inline__ void clear_bit(unsigned long nr, volatile void *addr)
+static __inline__ void clear_bit(unsigned long nr, volatile unsigned long *addr)
 {
        unsigned long old;
        unsigned long mask = 1UL << (nr & 0x3f);
@@ -79,7 +78,7 @@
        : "cc");
 }
 
-static __inline__ void change_bit(unsigned long nr, volatile void *addr)
+static __inline__ void change_bit(unsigned long nr, volatile unsigned long *addr)
 {
        unsigned long old;
        unsigned long mask = 1UL << (nr & 0x3f);
@@ -95,7 +94,7 @@
        : "cc");
 }
 
-static __inline__ int test_and_set_bit(unsigned long nr, volatile void *addr)
+static __inline__ int test_and_set_bit(unsigned long nr, volatile unsigned long *addr)
 {
        unsigned long old, t;
        unsigned long mask = 1UL << (nr & 0x3f);
@@ -115,7 +114,7 @@
        return (old & mask) != 0;
 }
 
-static __inline__ int test_and_clear_bit(unsigned long nr, volatile void *addr)
+static __inline__ int test_and_clear_bit(unsigned long nr, volatile unsigned long *addr)
 {
        unsigned long old, t;
        unsigned long mask = 1UL << (nr & 0x3f);
@@ -135,7 +134,7 @@
        return (old & mask) != 0;
 }
 
-static __inline__ int test_and_change_bit(unsigned long nr, volatile void *addr)
+static __inline__ int test_and_change_bit(unsigned long nr, volatile unsigned long *addr)
 {
        unsigned long old, t;
        unsigned long mask = 1UL << (nr & 0x3f);
@@ -158,7 +157,7 @@
 /*
  * non-atomic versions
  */
-static __inline__ void __set_bit(unsigned long nr, volatile void *addr)
+static __inline__ void __set_bit(unsigned long nr, volatile unsigned long *addr)
 {
        unsigned long mask = 1UL << (nr & 0x3f);
        unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
@@ -166,7 +165,7 @@
        *p |= mask;
 }
 
-static __inline__ void __clear_bit(unsigned long nr, volatile void *addr)
+static __inline__ void __clear_bit(unsigned long nr, volatile unsigned long *addr)
 {
        unsigned long mask = 1UL << (nr & 0x3f);
        unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
@@ -174,7 +173,7 @@
        *p &= ~mask;
 }
 
-static __inline__ void __change_bit(unsigned long nr, volatile void *addr)
+static __inline__ void __change_bit(unsigned long nr, volatile unsigned long *addr)
 {
        unsigned long mask = 1UL << (nr & 0x3f);
        unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
@@ -182,7 +181,7 @@
        *p ^= mask;
 }
 
-static __inline__ int __test_and_set_bit(unsigned long nr, volatile void *addr)
+static __inline__ int __test_and_set_bit(unsigned long nr, volatile unsigned long *addr)
 {
        unsigned long mask = 1UL << (nr & 0x3f);
        unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
@@ -192,7 +191,7 @@
        return (old & mask) != 0;
 }
 
-static __inline__ int __test_and_clear_bit(unsigned long nr, volatile void *addr)
+static __inline__ int __test_and_clear_bit(unsigned long nr, volatile unsigned long *addr)
 {
        unsigned long mask = 1UL << (nr & 0x3f);
        unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
@@ -202,7 +201,7 @@
        return (old & mask) != 0;
 }
 
-static __inline__ int __test_and_change_bit(unsigned long nr, volatile void *addr)
+static __inline__ int __test_and_change_bit(unsigned long nr, volatile unsigned long *addr)
 {
        unsigned long mask = 1UL << (nr & 0x3f);
        unsigned long *p = ((unsigned long *)addr) + (nr >> 6);
@@ -224,54 +223,46 @@
        return 63 - lz;
 }
 
-/* Return the zero-based bit position
- *  from RIGHT TO LEFT  63 --> 0
- *   of the most significant (left-most) 1-bit in an 8-byte area.
- */
-static __inline__ long cnt_trailing_zeros(unsigned long mask)
-{
-        long cnt;
-
-       asm(
-"      addi    %0,%1,-1        \n\
-       andc    %0,%0,%1        \n\
-       cntlzd  %0,%0           \n\
-       subfic  %0,%0,64"
-       : "=r" (cnt)
-       : "r" (mask));
-       return cnt;
-}
-
-
-
 /*
- * ffz = Find First Zero in word. Undefined if no zero exists,
- *    Determines the bit position of the LEAST significant
- *    (rightmost) 0 bit in the specified DOUBLE-WORD.
- *    The returned bit position will be zero-based, starting
- *    from the right side (63 - 0).
- *    the code should check against ~0UL first..
+ * Determines the bit position of the least significant (rightmost) 0 bit
+ * in the specified double word. The returned bit position will be zero-based,
+ * starting from the right side (63 - 0).
  */
 static __inline__ unsigned long ffz(unsigned long x)
 {
-       u32  tempRC;
-
-       /* Change all of x's 1s to 0s and 0s to 1s in x.
-        * And insure at least 1 zero exists in the 8 byte area.
-        */
+       /* no zero exists anywhere in the 8 byte area. */
        if ((x = ~x) == 0)
-               /* no zero exists anywhere in the 8 byte area. */
                return 64;
 
-       /* Calculate the bit position of the least significant '1' bit in x
-        * (since x has been changed this will actually be the least
-        * significant '0' bit in the original x).
-        * Note: (x & -x) gives us a mask that is the LEAST significant
-        * (RIGHT-most) 1-bit of the value in x.
+       /*
+        * Calculate the bit position of the least signficant '1' bit in x
+        * (since x has been changed this will actually be the least signficant
+        * '0' bit in * the original x).  Note: (x & -x) gives us a mask that
+        * is the least significant * (RIGHT-most) 1-bit of the value in x.
         */
-       tempRC = __ilog2(x & -x);
+       return __ilog2(x & -x);
+}
+
+static __inline__ int __ffs(unsigned long x)
+{
+       return __ilog2(x & -x);
+}
 
-       return tempRC;
+/*
+ * Every architecture must define this function. It's the fastest
+ * way of searching a 140-bit bitmap where the first 100 bits are
+ * unlikely to be set. It's guaranteed that at least one of the 140
+ * bits is cleared.
+ */
+static inline int _sched_find_first_bit(unsigned long *b)
+{
+       if (unlikely(b[0]))
+               return __ffs(b[0]);
+       if (unlikely(((unsigned int)b[1])))
+               return __ffs(b[1]) + 64;
+       if (b[1] >> 32)
+               return __ffs(b[1] >> 32) + 96;
+       return __ffs(b[2]) + 128;
 }
 
 /*
@@ -281,8 +272,8 @@
  */
 static __inline__ int ffs(int x)
 {
-       int result = ffz(~x);
-       return x ? result+1 : 0;
+       unsigned long i = (unsigned long)x;
+       return __ilog2(i & -i) + 1;
 }
 
 /*
@@ -293,139 +284,82 @@
 #define hweight16(x) generic_hweight16(x)
 #define hweight8(x) generic_hweight8(x)
 
-extern unsigned long find_next_zero_bit(void * addr, unsigned long size,
-                                       unsigned long offset);
-/*
- * The optimizer actually does good code for this case..
- */
-#define find_first_zero_bit(addr, size) find_next_zero_bit((addr), (size), 0)
-
-/* Bitmap functions for the ext2 filesystem. */
-#define _EXT2_HAVE_ASM_BITOPS_
+extern unsigned long find_next_zero_bit(unsigned long *addr, unsigned long size, unsigned long offset);
+#define find_first_zero_bit(addr, size) \
+       find_next_zero_bit((addr), (size), 0)
+
+extern unsigned long find_next_bit(unsigned long *addr, unsigned long size, unsigned long offset);
+#define find_first_bit(addr, size) \
+       find_next_bit((addr), (size), 0)
+
+extern unsigned long find_next_zero_le_bit(unsigned long *addr, unsigned long size, unsigned long offset);
+#define find_first_zero_le_bit(addr, size) \
+       find_next_zero_le_bit((addr), (size), 0)
 
-static __inline__ int ext2_set_bit(int nr, void* addr)
+static __inline__ int test_le_bit(unsigned long nr, __const__ unsigned long * addr)
 {
-       /* This method needs to take into account the fact that the ext2 file system represents
-        *  it's bitmaps as "little endian" unsigned integers.
-        * Note: this method is not atomic, but ext2 does not need it to be.
-        */
-       int mask;
-       int oldbit;
-       unsigned char* ADDR = (unsigned char*) addr;
-
-       /* Determine the BYTE containing the specified bit
-        * (nr) - important as if we go to a byte there are no
-        * little endian concerns.
-        */
-       ADDR += nr >> 3;
-       mask = 1 << (nr & 0x07);  /* Create a mask to the bit within this byte. */
-       oldbit = *ADDR & mask;  /* Save the bit's previous value. */
-       *ADDR |= mask;  /* Turn the bit on. */
-       return oldbit;  /* Return the bit's previous value. */
+       __const__ unsigned char *ADDR = (__const__ unsigned char *) addr;
+       return (ADDR[nr >> 3] >> (nr & 7)) & 1;
 }
 
-static __inline__ int ext2_clear_bit(int nr, void* addr)
+/*
+ * non-atomic versions
+ */
+static __inline__ void __set_le_bit(unsigned long nr, unsigned long *addr)
 {
-       /* This method needs to take into account the fact that the ext2 file system represents
-        * | it's bitmaps as "little endian" unsigned integers.
-        * Note: this method is not atomic, but ext2 does not need it to be.
-        */
-        int     mask;
-        int oldbit;
-        unsigned char* ADDR = (unsigned char*) addr;
+       unsigned char *ADDR = (unsigned char *)addr;
 
-       /* Determine the BYTE containing the specified bit (nr)
-        *  - important as if we go to a byte there are no little endian concerns.
-        */
-        ADDR += nr >> 3;
-        mask = 1 << (nr & 0x07);  /* Create a mask to the bit within this byte. */
-        oldbit = *ADDR & mask;  /* Save the bit's previous value. */
-        *ADDR = *ADDR & ~mask;  /* Turn the bit off. */
-        return oldbit;  /* Return the bit's previous value. */
-}
-
-static __inline__ int ext2_test_bit(int nr, __const__ void * addr)
-{
-       /* This method needs to take into account the fact that the ext2 file system represents
-        * | it's bitmaps as "little endian" unsigned integers.
-        * Determine the BYTE containing the specified bit (nr),
-        *   then shift to the right the correct number of bits and return that bit's value.
-        */
-       __const__ unsigned char *ADDR = (__const__ unsigned char *) addr;
-       return (ADDR[nr >> 3] >> (nr & 7)) & 1;
+       ADDR += nr >> 3;
+       *ADDR |= 1 << (nr & 0x07);
 }
 
-/* Returns the bit position of the most significant 1 bit in a WORD. */
-static __inline__ int ext2_ilog2(unsigned int x)
+static __inline__ void __clear_le_bit(unsigned long nr, unsigned long *addr)
 {
-        int lz;
+       unsigned char *ADDR = (unsigned char *)addr;
 
-        asm ("cntlzw %0,%1" : "=r" (lz) : "r" (x));
-        return 31 - lz;
+       ADDR += nr >> 3;
+       *ADDR &= ~(1 << (nr & 0x07));
 }
 
-/* ext2_ffz = ext2's Find First Zero.
- *    Determines the bit position of the LEAST significant (rightmost) 0 bit in the specified WORD.
- *    The returned bit position will be zero-based, starting from the right side (31 - 0).
- */
-static __inline__ int ext2_ffz(unsigned int x)
+static __inline__ int __test_and_set_le_bit(unsigned long nr, unsigned long *addr)
 {
-       u32  tempRC;
-       /* Change all of x's 1s to 0s and 0s to 1s in x.  And insure at least 1 zero exists in the word. */
-       if ((x = ~x) == 0)
-               /* no zero exists anywhere in the 4 byte area. */
-               return 32;
-       /* Calculate the bit position of the least significant '1' bit in x
-        * (since x has been changed this will actually be the least
-        * significant '0' bit in the original x).
-        * Note: (x & -x) gives us a mask that is the LEAST significant
-        * (RIGHT-most) 1-bit of the value in x.
-        */
-       tempRC = ext2_ilog2(x & -x);
-       return tempRC;
+       int mask, retval;
+       unsigned char *ADDR = (unsigned char *)addr;
+
+       ADDR += nr >> 3;
+       mask = 1 << (nr & 0x07);
+       retval = (mask & *ADDR) != 0;
+       *ADDR |= mask;
+       return retval;
 }
 
-static __inline__ u32 ext2_find_next_zero_bit(void* addr, u32 size, u32 offset)
+static __inline__ int __test_and_clear_le_bit(unsigned long nr, unsigned long *addr)
 {
-       /* This method needs to take into account the fact that the ext2 file system represents
-        * | it's bitmaps as "little endian" unsigned integers.
-        */
-        unsigned int *p = ((unsigned int *) addr) + (offset >> 5);
-        unsigned int result = offset & ~31;
-        unsigned int tmp;
-
-        if (offset >= size)
-                return size;
-        size -= result;
-        offset &= 31;
-        if (offset) {
-                tmp = cpu_to_le32p(p++);
-                tmp |= ~0U >> (32-offset); /* bug or feature ? */
-                if (size < 32)
-                        goto found_first;
-                if (tmp != ~0)
-                        goto found_middle;
-                size -= 32;
-                result += 32;
-        }
-        while (size >= 32) {
-                if ((tmp = cpu_to_le32p(p++)) != ~0)
-                        goto found_middle;
-                result += 32;
-                size -= 32;
-        }
-        if (!size)
-                return result;
-        tmp = cpu_to_le32p(p);
-found_first:
-        tmp |= ~0 << size;
-        if (tmp == ~0)          /* Are any bits zero? */
-                return result + size; /* Nope. */
-found_middle:
-        return result + ext2_ffz(tmp);
-}
+       int mask, retval;
+       unsigned char *ADDR = (unsigned char *)addr;
 
-#define ext2_find_first_zero_bit(addr, size) ext2_find_next_zero_bit((addr), (size), 0)
+       ADDR += nr >> 3;
+       mask = 1 << (nr & 0x07);
+       retval = (mask & *ADDR) != 0;
+       *ADDR &= ~mask;
+       return retval;
+}
+
+#define ext2_set_bit(nr,addr) \
+       __test_and_set_le_bit((nr),(unsigned long*)addr)
+#define ext2_clear_bit(nr, addr) \
+       __test_and_clear_le_bit((nr),(unsigned long*)addr)
+#define ext2_test_bit(nr, addr)      test_le_bit((nr),(unsigned long*)addr)
+#define ext2_find_first_zero_bit(addr, size) \
+       find_first_zero_le_bit((unsigned long*)addr, size)
+#define ext2_find_next_zero_bit(addr, size, off) \
+       find_next_zero_le_bit((unsigned long*)addr, size, off)
+
+#define minix_test_and_set_bit(nr,addr)                test_and_set_bit(nr,addr)
+#define minix_set_bit(nr,addr)                 set_bit(nr,addr)
+#define minix_test_and_clear_bit(nr,addr)      test_and_clear_bit(nr,addr)
+#define minix_test_bit(nr,addr)                        test_bit(nr,addr)
+#define minix_find_first_zero_bit(addr,size)   find_first_zero_bit(addr,size)
 
 #endif /* __KERNEL__ */
 #endif /* _PPC64_BITOPS_H */
--- linux-2.4.20/include/asm-ppc64/spinlock.h.orig      Sat Aug  3 02:39:45 2002
+++ linux-2.4.20/include/asm-ppc64/spinlock.h   Sun Mar  9 13:36:03 2003
@@ -23,12 +23,12 @@
 
 #define spin_is_locked(x)      ((x)->lock != 0)
 
-static __inline__ int spin_trylock(spinlock_t *lock)
+static __inline__ int _raw_spin_trylock(spinlock_t *lock)
 {
        unsigned int tmp;
 
        __asm__ __volatile__(
-"1:    lwarx           %0,0,%1         # spin_trylock\n\
+"1:    lwarx           %0,0,%1         # _raw_spin_trylock\n\
        cmpwi           0,%0,0\n\
        li              %0,0\n\
        bne-            2f\n\
@@ -43,12 +43,12 @@
        return tmp;
 }
 
-static __inline__ void spin_lock(spinlock_t *lock)
+static __inline__ void _raw_spin_lock(spinlock_t *lock)
 {
        unsigned int tmp;
 
        __asm__ __volatile__(
-       "b              2f              # spin_lock\n\
+       "b              2f              # _raw_spin_lock\n\
 1:     or              1,1,1           # spin at low priority\n\
        lwzx            %0,0,%1\n\
        cmpwi           0,%0,0\n\
@@ -65,9 +65,9 @@
        : "cr0", "memory");
 }
 
-static __inline__ void spin_unlock(spinlock_t *lock)
+static __inline__ void _raw_spin_unlock(spinlock_t *lock)
 {
-       __asm__ __volatile__("lwsync    # spin_unlock": : :"memory");
+       __asm__ __volatile__("lwsync    # _raw_spin_unlock": : :"memory");
        lock->lock = 0;
 }
 
@@ -109,12 +109,12 @@
        return ret;
 }
 
-static __inline__ void read_lock(rwlock_t *rw)
+static __inline__ void _raw_read_lock(rwlock_t *rw)
 {
        unsigned int tmp;
 
        __asm__ __volatile__(
-       "b              2f              # read_lock\n\
+       "b              2f              # _raw_read_lock\n\
 1:     or              1,1,1           # spin at low priority\n\
        lwax            %0,0,%1\n\
        cmpwi           0,%0,0\n\
@@ -132,12 +132,12 @@
        : "cr0", "memory");
 }
 
-static __inline__ void read_unlock(rwlock_t *rw)
+static __inline__ void _raw_read_unlock(rwlock_t *rw)
 {
        unsigned int tmp;
 
        __asm__ __volatile__(
-       "lwsync                         # read_unlock\n\
+       "lwsync                         # _raw_read_unlock\n\
 1:     lwarx           %0,0,%1\n\
        addic           %0,%0,-1\n\
        stwcx.          %0,0,%1\n\
@@ -168,12 +168,12 @@
        return ret;
 }
 
-static __inline__ void write_lock(rwlock_t *rw)
+static __inline__ void _raw_write_lock(rwlock_t *rw)
 {
        unsigned int tmp;
 
        __asm__ __volatile__(
-       "b              2f              # write_lock\n\
+       "b              2f              # _raw_write_lock\n\
 1:     or              1,1,1           # spin at low priority\n\
        lwax            %0,0,%1\n\
        cmpwi           0,%0,0\n\
@@ -190,9 +190,9 @@
        : "cr0", "memory");
 }
 
-static __inline__ void write_unlock(rwlock_t *rw)
+static __inline__ void _raw_write_unlock(rwlock_t *rw)
 {
-       __asm__ __volatile__("lwsync            # write_unlock": : :"memory");
+       __asm__ __volatile__("lwsync            # _raw_write_unlock": : :"memory");
        rw->lock = 0;
 }
 
diff -urN linux-2.4.20/include/asm-s390/bitops.h linux-2.4.20-o1-preempt/include/asm-s390/bitops.h
--- linux-2.4.20/include/asm-s390/bitops.h      Sat Aug  3 02:39:45 2002
+++ linux-2.4.20-o1-preempt/include/asm-s390/bitops.h   Tue Feb 18 03:51:30 2003
@@ -47,272 +47,217 @@
 extern const char _oi_bitmap[];
 extern const char _ni_bitmap[];
 extern const char _zb_findmap[];
+extern const char _sb_findmap[];
 
 #ifdef CONFIG_SMP
 /*
  * SMP save set_bit routine based on compare and swap (CS)
  */
-static __inline__ void set_bit_cs(int nr, volatile void * addr)
+static inline void set_bit_cs(int nr, volatile void *ptr)
 {
-       unsigned long bits, mask;
-        __asm__ __volatile__(
+        unsigned long addr, old, new, mask;
+
+       addr = (unsigned long) ptr;
 #if ALIGN_CS == 1
-             "   lhi   %2,3\n"         /* CS must be aligned on 4 byte b. */
-             "   nr    %2,%1\n"        /* isolate last 2 bits of address */
-             "   xr    %1,%2\n"        /* make addr % 4 == 0 */
-             "   sll   %2,3\n"
-             "   ar    %0,%2\n"        /* add alignement to bitnr */
+       addr ^= addr & 3;               /* align address to 4 */
+       nr += (addr & 3) << 3;          /* add alignment to bit number */
 #endif
-             "   lhi   %2,31\n"
-             "   nr    %2,%0\n"        /* make shift value */
-             "   xr    %0,%2\n"
-             "   srl   %0,3\n"
-             "   lhi   %3,1\n"
-             "   la    %1,0(%0,%1)\n"  /* calc. address for CS */
-             "   sll   %3,0(%2)\n"       /* make OR mask */
-             "   l     %0,0(%1)\n"
-             "0: lr    %2,%0\n"         /* CS loop starts here */
-             "   or    %2,%3\n"          /* set bit */
-             "   cs    %0,%2,0(%1)\n"
-             "   jl    0b"
-             : "+a" (nr), "+a" (addr), "=&a" (bits), "=&d" (mask) :
-             : "cc", "memory" );
+       addr += (nr ^ (nr & 31)) >> 3;  /* calculate address for CS */
+       mask = 1UL << (nr & 31);        /* make OR mask */
+       asm volatile(
+               "   l   %0,0(%4)\n"
+               "0: lr  %1,%0\n"
+               "   or  %1,%3\n"
+               "   cs  %0,%1,0(%4)\n"
+               "   jl  0b"
+               : "=&d" (old), "=&d" (new), "+m" (*(unsigned int *) addr)
+               : "d" (mask), "a" (addr) 
+               : "cc" );
 }
 
 /*
  * SMP save clear_bit routine based on compare and swap (CS)
  */
-static __inline__ void clear_bit_cs(int nr, volatile void * addr)
+static inline void clear_bit_cs(int nr, volatile void *ptr)
 {
-        static const int minusone = -1;
-       unsigned long bits, mask;
-        __asm__ __volatile__(
+        unsigned long addr, old, new, mask;
+
+       addr = (unsigned long) ptr;
 #if ALIGN_CS == 1
-             "   lhi   %2,3\n"         /* CS must be aligned on 4 byte b. */
-             "   nr    %2,%1\n"        /* isolate last 2 bits of address */
-             "   xr    %1,%2\n"        /* make addr % 4 == 0 */
-             "   sll   %2,3\n"
-             "   ar    %0,%2\n"        /* add alignement to bitnr */
+       addr ^= addr & 3;               /* align address to 4 */
+       nr += (addr & 3) << 3;          /* add alignment to bit number */
 #endif
-             "   lhi   %2,31\n"
-             "   nr    %2,%0\n"        /* make shift value */
-             "   xr    %0,%2\n"
-             "   srl   %0,3\n"
-             "   lhi   %3,1\n"
-             "   la    %1,0(%0,%1)\n"  /* calc. address for CS */
-             "   sll   %3,0(%2)\n"
-             "   x     %3,%4\n"        /* make AND mask */
-             "   l     %0,0(%1)\n"
-             "0: lr    %2,%0\n"        /* CS loop starts here */
-             "   nr    %2,%3\n"        /* clear bit */
-             "   cs    %0,%2,0(%1)\n"
-             "   jl    0b"
-             : "+a" (nr), "+a" (addr), "=&a" (bits), "=&d" (mask)
-             : "m" (minusone) : "cc", "memory" );
+       addr += (nr ^ (nr & 31)) >> 3;  /* calculate address for CS */
+       mask = ~(1UL << (nr & 31));     /* make AND mask */
+       asm volatile(
+               "   l   %0,0(%4)\n"
+               "0: lr  %1,%0\n"
+               "   nr  %1,%3\n"
+               "   cs  %0,%1,0(%4)\n"
+               "   jl  0b"
+               : "=&d" (old), "=&d" (new), "+m" (*(unsigned int *) addr)
+               : "d" (mask), "a" (addr) 
+               : "cc" );
 }
 
 /*
  * SMP save change_bit routine based on compare and swap (CS)
  */
-static __inline__ void change_bit_cs(int nr, volatile void * addr)
+static inline void change_bit_cs(int nr, volatile void *ptr)
 {
-       unsigned long bits, mask;
-        __asm__ __volatile__(
+        unsigned long addr, old, new, mask;
+
+       addr = (unsigned long) ptr;
 #if ALIGN_CS == 1
-             "   lhi   %2,3\n"         /* CS must be aligned on 4 byte b. */
-             "   nr    %2,%1\n"        /* isolate last 2 bits of address */
-             "   xr    %1,%2\n"        /* make addr % 4 == 0 */
-             "   sll   %2,3\n"
-             "   ar    %0,%2\n"        /* add alignement to bitnr */
+       addr ^= addr & 3;               /* align address to 4 */
+       nr += (addr & 3) << 3;          /* add alignment to bit number */
 #endif
-             "   lhi   %2,31\n"
-             "   nr    %2,%0\n"        /* make shift value */
-             "   xr    %0,%2\n"
-             "   srl   %0,3\n"
-             "   lhi   %3,1\n"
-             "   la    %1,0(%0,%1)\n"  /* calc. address for CS */
-             "   sll   %3,0(%2)\n"     /* make XR mask */
-             "   l     %0,0(%1)\n"
-             "0: lr    %2,%0\n"        /* CS loop starts here */
-             "   xr    %2,%3\n"        /* change bit */
-             "   cs    %0,%2,0(%1)\n"
-             "   jl    0b"
-             : "+a" (nr), "+a" (addr), "=&a" (bits), "=&d" (mask) : 
-             : "cc", "memory" );
+       addr += (nr ^ (nr & 31)) >> 3;  /* calculate address for CS */
+       mask = 1UL << (nr & 31);        /* make XOR mask */
+       asm volatile(
+               "   l   %0,0(%4)\n"
+               "0: lr  %1,%0\n"
+               "   xr  %1,%3\n"
+               "   cs  %0,%1,0(%4)\n"
+               "   jl  0b"
+               : "=&d" (old), "=&d" (new), "+m" (*(unsigned int *) addr)
+               : "d" (mask), "a" (addr) 
+               : "cc" );
 }
 
 /*
  * SMP save test_and_set_bit routine based on compare and swap (CS)
  */
-static __inline__ int test_and_set_bit_cs(int nr, volatile void * addr)
+static inline int test_and_set_bit_cs(int nr, volatile void *ptr)
 {
-       unsigned long bits, mask;
-        __asm__ __volatile__(
+        unsigned long addr, old, new, mask;
+
+       addr = (unsigned long) ptr;
 #if ALIGN_CS == 1
-             "   lhi   %2,3\n"         /* CS must be aligned on 4 byte b. */
-             "   nr    %2,%1\n"        /* isolate last 2 bits of address */
-             "   xr    %1,%2\n"        /* make addr % 4 == 0 */
-             "   sll   %2,3\n"
-             "   ar    %0,%2\n"        /* add alignement to bitnr */
+       addr ^= addr & 3;               /* align address to 4 */
+       nr += (addr & 3) << 3;          /* add alignment to bit number */
 #endif
-             "   lhi   %2,31\n"
-             "   nr    %2,%0\n"        /* make shift value */
-             "   xr    %0,%2\n"
-             "   srl   %0,3\n"
-             "   lhi   %3,1\n"
-             "   la    %1,0(%0,%1)\n"  /* calc. address for CS */
-             "   sll   %3,0(%2)\n"     /* make OR mask */
-             "   l     %0,0(%1)\n"
-             "0: lr    %2,%0\n"        /* CS loop starts here */
-             "   or    %2,%3\n"        /* set bit */
-             "   cs    %0,%2,0(%1)\n"
-             "   jl    0b\n"
-             "   nr    %0,%3\n"        /* isolate old bit */
-             : "+a" (nr), "+a" (addr), "=&a" (bits), "=&d" (mask) :
-             : "cc", "memory" );
-        return nr != 0;
+       addr += (nr ^ (nr & 31)) >> 3;  /* calculate address for CS */
+       mask = 1UL << (nr & 31);        /* make OR/test mask */
+       asm volatile(
+               "   l   %0,0(%4)\n"
+               "0: lr  %1,%0\n"
+               "   or  %1,%3\n"
+               "   cs  %0,%1,0(%4)\n"
+               "   jl  0b"
+               : "=&d" (old), "=&d" (new), "+m" (*(unsigned int *) addr)
+               : "d" (mask), "a" (addr) 
+               : "cc" );
+       return (old & mask) != 0;
 }
 
 /*
  * SMP save test_and_clear_bit routine based on compare and swap (CS)
  */
-static __inline__ int test_and_clear_bit_cs(int nr, volatile void * addr)
+static inline int test_and_clear_bit_cs(int nr, volatile void *ptr)
 {
-        static const int minusone = -1;
-       unsigned long bits, mask;
-        __asm__ __volatile__(
+        unsigned long addr, old, new, mask;
+
+       addr = (unsigned long) ptr;
 #if ALIGN_CS == 1
-             "   lhi   %2,3\n"         /* CS must be aligned on 4 byte b. */
-             "   nr    %2,%1\n"        /* isolate last 2 bits of address */
-             "   xr    %1,%2\n"        /* make addr % 4 == 0 */
-             "   sll   %2,3\n"
-             "   ar    %0,%2\n"        /* add alignement to bitnr */
+       addr ^= addr & 3;               /* align address to 4 */
+       nr += (addr & 3) << 3;          /* add alignment to bit number */
 #endif
-             "   lhi   %2,31\n"
-             "   nr    %2,%0\n"        /* make shift value */
-             "   xr    %0,%2\n"
-             "   srl   %0,3\n"
-             "   lhi   %3,1\n"
-             "   la    %1,0(%0,%1)\n"  /* calc. address for CS */
-             "   sll   %3,0(%2)\n"
-             "   l     %0,0(%1)\n"
-             "   x     %3,%4\n"        /* make AND mask */
-             "0: lr    %2,%0\n"        /* CS loop starts here */
-             "   nr    %2,%3\n"        /* clear bit */
-             "   cs    %0,%2,0(%1)\n"
-             "   jl    0b\n"
-             "   x     %3,%4\n"
-             "   nr    %0,%3\n"         /* isolate old bit */
-             : "+a" (nr), "+a" (addr), "=&a" (bits), "=&d" (mask)
-             : "m" (minusone) : "cc", "memory" );
-        return nr;
+       addr += (nr ^ (nr & 31)) >> 3;  /* calculate address for CS */
+       mask = ~(1UL << (nr & 31));     /* make AND mask */
+       asm volatile(
+               "   l   %0,0(%4)\n"
+               "0: lr  %1,%0\n"
+               "   nr  %1,%3\n"
+               "   cs  %0,%1,0(%4)\n"
+               "   jl  0b"
+               : "=&d" (old), "=&d" (new), "+m" (*(unsigned int *) addr)
+               : "d" (mask), "a" (addr) 
+               : "cc" );
+       return (old ^ new) != 0;
 }
 
 /*
  * SMP save test_and_change_bit routine based on compare and swap (CS) 
  */
-static __inline__ int test_and_change_bit_cs(int nr, volatile void * addr)
+static inline int test_and_change_bit_cs(int nr, volatile void *ptr)
 {
-       unsigned long bits, mask;
-        __asm__ __volatile__(
+        unsigned long addr, old, new, mask;
+
+       addr = (unsigned long) ptr;
 #if ALIGN_CS == 1
-             "   lhi   %2,3\n"         /* CS must be aligned on 4 byte b. */
-             "   nr    %2,%1\n"        /* isolate last 2 bits of address */
-             "   xr    %1,%2\n"        /* make addr % 4 == 0 */
-             "   sll   %2,3\n"
-             "   ar    %0,%2\n"        /* add alignement to bitnr */
+       addr ^= addr & 3;               /* align address to 4 */
+       nr += (addr & 3) << 3;          /* add alignment to bit number */
 #endif
-             "   lhi   %2,31\n"
-             "   nr    %2,%0\n"        /* make shift value */
-             "   xr    %0,%2\n"
-             "   srl   %0,3\n"
-             "   lhi   %3,1\n"
-             "   la    %1,0(%0,%1)\n"  /* calc. address for CS */
-             "   sll   %3,0(%2)\n"     /* make OR mask */
-             "   l     %0,0(%1)\n"
-             "0: lr    %2,%0\n"        /* CS loop starts here */
-             "   xr    %2,%3\n"        /* change bit */
-             "   cs    %0,%2,0(%1)\n"
-             "   jl    0b\n"
-             "   nr    %0,%3\n"        /* isolate old bit */
-             : "+a" (nr), "+a" (addr), "=&a" (bits), "=&d" (mask) :
-             : "cc", "memory" );
-        return nr != 0;
+       addr += (nr ^ (nr & 31)) >> 3;  /* calculate address for CS */
+       mask = 1UL << (nr & 31);        /* make XOR mask */
+       asm volatile(
+               "   l   %0,0(%4)\n"
+               "0: lr  %1,%0\n"
+               "   xr  %1,%3\n"
+               "   cs  %0,%1,0(%4)\n"
+               "   jl  0b"
+               : "=&d" (old), "=&d" (new), "+m" (*(unsigned int *) addr)
+               : "d" (mask), "a" (addr) 
+               : "cc" );
+       return (old & mask) != 0;
 }
 #endif /* CONFIG_SMP */
 
 /*
  * fast, non-SMP set_bit routine
  */
-static __inline__ void __set_bit(int nr, volatile void * addr)
+static inline void __set_bit(int nr, volatile void *ptr)
 {
-       unsigned long reg1, reg2;
-        __asm__ __volatile__(
-             "   lhi   %1,24\n"
-             "   lhi   %0,7\n"
-             "   xr    %1,%2\n"
-             "   nr    %0,%2\n"
-             "   srl   %1,3\n"
-             "   la    %1,0(%1,%3)\n"
-             "   la    %0,0(%0,%4)\n"
-             "   oc    0(1,%1),0(%0)"
-             : "=&a" (reg1), "=&a" (reg2)
-             : "r" (nr), "a" (addr), "a" (&_oi_bitmap) : "cc", "memory" );
-}
-
-static __inline__ void 
-__constant_set_bit(const int nr, volatile void * addr)
-{
-  switch (nr&7) {
-  case 0:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x01"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3))) 
-                          : : "1", "cc", "memory");
-    break;
-  case 1:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x02"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 2:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x04"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 3:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x08"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 4:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x10"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 5:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x20"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 6:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x40"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 7:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x80"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  }
+       unsigned long addr;
+
+       addr = (unsigned long) ptr + ((nr ^ 24) >> 3);
+        asm volatile("oc 0(1,%1),0(%2)"
+                    : "+m" (*(char *) addr)
+                    : "a" (addr), "a" (_oi_bitmap + (nr & 7))
+                    : "cc" );
+}
+
+static inline void 
+__constant_set_bit(const int nr, volatile void *ptr)
+{
+       unsigned long addr;
+
+       addr = ((unsigned long) ptr) + ((nr >> 3) ^ 3);
+       switch (nr&7) {
+       case 0:
+               asm volatile ("oi 0(%1),0x01"
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 1:
+               asm volatile ("oi 0(%1),0x02"
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 2:
+               asm volatile ("oi 0(%1),0x04" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 3:
+               asm volatile ("oi 0(%1),0x08" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 4:
+               asm volatile ("oi 0(%1),0x10" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 5:
+               asm volatile ("oi 0(%1),0x20" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 6:
+               asm volatile ("oi 0(%1),0x40" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 7:
+               asm volatile ("oi 0(%1),0x80" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       }
 }
 
 #define set_bit_simple(nr,addr) \
@@ -323,76 +268,58 @@
 /*
  * fast, non-SMP clear_bit routine
  */
-static __inline__ void 
-__clear_bit(int nr, volatile void * addr)
+static inline void 
+__clear_bit(int nr, volatile void *ptr)
 {
-       unsigned long reg1, reg2;
-        __asm__ __volatile__(
-             "   lhi   %1,24\n"
-             "   lhi   %0,7\n"
-             "   xr    %1,%2\n"
-             "   nr    %0,%2\n"
-             "   srl   %1,3\n"
-             "   la    %1,0(%1,%3)\n"
-             "   la    %0,0(%0,%4)\n"
-             "   nc    0(1,%1),0(%0)"
-             : "=&a" (reg1), "=&a" (reg2)
-             : "r" (nr), "a" (addr), "a" (&_ni_bitmap) : "cc", "memory" );
-}
-
-static __inline__ void 
-__constant_clear_bit(const int nr, volatile void * addr)
-{
-  switch (nr&7) {
-  case 0:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0xFE"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 1:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0xFD"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 2:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0xFB"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 3:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0xF7"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 4:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0xEF"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "cc", "memory" );
-    break;
-  case 5:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0xDF"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 6:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0xBF"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 7:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0x7F"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  }
+       unsigned long addr;
+
+       addr = (unsigned long) ptr + ((nr ^ 24) >> 3);
+        asm volatile("nc 0(1,%1),0(%2)"
+                    : "+m" (*(char *) addr)
+                    : "a" (addr), "a" (_ni_bitmap + (nr & 7))
+                    : "cc" );
+}
+
+static inline void 
+__constant_clear_bit(const int nr, volatile void *ptr)
+{
+       unsigned long addr;
+
+       addr = ((unsigned long) ptr) + ((nr >> 3) ^ 3);
+       switch (nr&7) {
+       case 0:
+               asm volatile ("ni 0(%1),0xFE"
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 1:
+               asm volatile ("ni 0(%1),0xFD" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 2:
+               asm volatile ("ni 0(%1),0xFB" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 3:
+               asm volatile ("ni 0(%1),0xF7" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 4:
+               asm volatile ("ni 0(%1),0xEF" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 5:
+               asm volatile ("ni 0(%1),0xDF" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 6:
+               asm volatile ("ni 0(%1),0xBF" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 7:
+               asm volatile ("ni 0(%1),0x7F" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       }
 }
 
 #define clear_bit_simple(nr,addr) \
@@ -403,75 +330,57 @@
 /* 
  * fast, non-SMP change_bit routine 
  */
-static __inline__ void __change_bit(int nr, volatile void * addr)
+static inline void __change_bit(int nr, volatile void *ptr)
 {
-       unsigned long reg1, reg2;
-        __asm__ __volatile__(
-             "   lhi   %1,24\n"
-             "   lhi   %0,7\n"
-             "   xr    %1,%2\n"
-             "   nr    %0,%2\n"
-             "   srl   %1,3\n"
-             "   la    %1,0(%1,%3)\n"
-             "   la    %0,0(%0,%4)\n"
-             "   xc    0(1,%1),0(%0)"
-             : "=&a" (reg1), "=&a" (reg2)
-             : "r" (nr), "a" (addr), "a" (&_oi_bitmap) : "cc", "memory" );
-}
-
-static __inline__ void 
-__constant_change_bit(const int nr, volatile void * addr) 
-{
-  switch (nr&7) {
-  case 0:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x01"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "cc", "memory" );
-    break;
-  case 1:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x02"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "cc", "memory" );
-    break;
-  case 2:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x04"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "cc", "memory" );
-    break;
-  case 3:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x08"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "cc", "memory" );
-    break;
-  case 4:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x10"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "cc", "memory" );
-    break;
-  case 5:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x20"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 6:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x40"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 7:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x80"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^3)))
-                          : : "1", "cc", "memory" );
-    break;
-  }
+       unsigned long addr;
+
+       addr = (unsigned long) ptr + ((nr ^ 24) >> 3);
+        asm volatile("xc 0(1,%1),0(%2)"
+                    : "+m" (*(char *) addr)
+                    : "a" (addr), "a" (_oi_bitmap + (nr & 7))
+                    : "cc" );
+}
+
+static inline void 
+__constant_change_bit(const int nr, volatile void *ptr) 
+{
+       unsigned long addr;
+
+       addr = ((unsigned long) ptr) + ((nr >> 3) ^ 3);
+       switch (nr&7) {
+       case 0:
+               asm volatile ("xi 0(%1),0x01" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 1:
+               asm volatile ("xi 0(%1),0x02" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 2:
+               asm volatile ("xi 0(%1),0x04" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 3:
+               asm volatile ("xi 0(%1),0x08" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 4:
+               asm volatile ("xi 0(%1),0x10" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 5:
+               asm volatile ("xi 0(%1),0x20" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 6:
+               asm volatile ("xi 0(%1),0x40" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 7:
+               asm volatile ("xi 0(%1),0x80" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       }
 }
 
 #define change_bit_simple(nr,addr) \
@@ -482,74 +391,54 @@
 /*
  * fast, non-SMP test_and_set_bit routine
  */
-static __inline__ int test_and_set_bit_simple(int nr, volatile void * addr)
+static inline int test_and_set_bit_simple(int nr, volatile void *ptr)
 {
-       unsigned long reg1, reg2;
-        int oldbit;
-        __asm__ __volatile__(
-             "   lhi   %1,24\n"
-             "   lhi   %2,7\n"
-             "   xr    %1,%3\n"
-             "   nr    %2,%3\n"
-             "   srl   %1,3\n"
-             "   la    %1,0(%1,%4)\n"
-             "   ic    %0,0(%1)\n"
-             "   srl   %0,0(%2)\n"
-             "   la    %2,0(%2,%5)\n"
-             "   oc    0(1,%1),0(%2)"
-             : "=d&" (oldbit), "=&a" (reg1), "=&a" (reg2)
-             : "r" (nr), "a" (addr), "a" (&_oi_bitmap) : "cc", "memory" );
-        return oldbit & 1;
+       unsigned long addr;
+       unsigned char ch;
+
+       addr = (unsigned long) ptr + ((nr ^ 24) >> 3);
+       ch = *(unsigned char *) addr;
+        asm volatile("oc 0(1,%1),0(%2)"
+                    : "+m" (*(char *) addr)
+                    : "a" (addr), "a" (_oi_bitmap + (nr & 7))
+                    : "cc" );
+       return (ch >> (nr & 7)) & 1;
 }
 #define __test_and_set_bit(X,Y)                test_and_set_bit_simple(X,Y)
 
 /*
  * fast, non-SMP test_and_clear_bit routine
  */
-static __inline__ int test_and_clear_bit_simple(int nr, volatile void * addr)
+static inline int test_and_clear_bit_simple(int nr, volatile void *ptr)
 {
-       unsigned long reg1, reg2;
-        int oldbit;
+       unsigned long addr;
+       unsigned char ch;
 
-        __asm__ __volatile__(
-             "   lhi   %1,24\n"
-             "   lhi   %2,7\n"
-             "   xr    %1,%3\n"
-             "   nr    %2,%3\n"
-             "   srl   %1,3\n"
-             "   la    %1,0(%1,%4)\n"
-             "   ic    %0,0(%1)\n"
-             "   srl   %0,0(%2)\n"
-             "   la    %2,0(%2,%5)\n"
-             "   nc    0(1,%1),0(%2)"
-             : "=d&" (oldbit), "=&a" (reg1), "=&a" (reg2)
-             : "r" (nr), "a" (addr), "a" (&_ni_bitmap) : "cc", "memory" );
-        return oldbit & 1;
+       addr = (unsigned long) ptr + ((nr ^ 24) >> 3);
+       ch = *(unsigned char *) addr;
+        asm volatile("nc 0(1,%1),0(%2)"
+                    : "+m" (*(char *) addr)
+                    : "a" (addr), "a" (_ni_bitmap + (nr & 7))
+                    : "cc" );
+       return (ch >> (nr & 7)) & 1;
 }
 #define __test_and_clear_bit(X,Y)      test_and_clear_bit_simple(X,Y)
 
 /*
  * fast, non-SMP test_and_change_bit routine
  */
-static __inline__ int test_and_change_bit_simple(int nr, volatile void * addr)
+static inline int test_and_change_bit_simple(int nr, volatile void *ptr)
 {
-       unsigned long reg1, reg2;
-        int oldbit;
+       unsigned long addr;
+       unsigned char ch;
 
-        __asm__ __volatile__(
-             "   lhi   %1,24\n"
-             "   lhi   %2,7\n"
-             "   xr    %1,%3\n"
-             "   nr    %2,%1\n"
-             "   srl   %1,3\n"
-             "   la    %1,0(%1,%4)\n"
-             "   ic    %0,0(%1)\n"
-             "   srl   %0,0(%2)\n"
-             "   la    %2,0(%2,%5)\n"
-             "   xc    0(1,%1),0(%2)"
-             : "=d&" (oldbit), "=&a" (reg1), "=&a" (reg2)
-             : "r" (nr), "a" (addr), "a" (&_oi_bitmap) : "cc", "memory" );
-        return oldbit & 1;
+       addr = (unsigned long) ptr + ((nr ^ 24) >> 3);
+       ch = *(unsigned char *) addr;
+        asm volatile("xc 0(1,%1),0(%2)"
+                    : "+m" (*(char *) addr)
+                    : "a" (addr), "a" (_oi_bitmap + (nr & 7))
+                    : "cc" );
+       return (ch >> (nr & 7)) & 1;
 }
 #define __test_and_change_bit(X,Y)     test_and_change_bit_simple(X,Y)
 
@@ -574,25 +463,17 @@
  * This routine doesn't need to be atomic.
  */
 
-static __inline__ int __test_bit(int nr, volatile void * addr)
+static inline int __test_bit(int nr, volatile void *ptr)
 {
-       unsigned long reg1, reg2;
-        int oldbit;
+       unsigned long addr;
+       unsigned char ch;
 
-        __asm__ __volatile__(
-             "   lhi   %2,24\n"
-             "   lhi   %1,7\n"
-             "   xr    %2,%3\n"
-             "   nr    %1,%3\n"
-             "   srl   %2,3\n"
-             "   ic    %0,0(%2,%4)\n"
-             "   srl   %0,0(%1)"
-             : "=d&" (oldbit), "=&a" (reg1), "=&a" (reg2)
-             : "r" (nr), "a" (addr) : "cc" );
-        return oldbit & 1;
+       addr = (unsigned long) ptr + ((nr ^ 24) >> 3);
+       ch = *(unsigned char *) addr;
+       return (ch >> (nr & 7)) & 1;
 }
 
-static __inline__ int __constant_test_bit(int nr, volatile void * addr) {
+static inline int __constant_test_bit(int nr, volatile void * addr) {
     return (((volatile char *) addr)[(nr>>3)^3] & (1<<(nr&7))) != 0;
 }
 
@@ -604,7 +485,7 @@
 /*
  * Find-bit routines..
  */
-static __inline__ int find_first_zero_bit(void * addr, unsigned size)
+static inline int find_first_zero_bit(void * addr, unsigned size)
 {
        unsigned long cmp, count;
         int res;
@@ -642,7 +523,45 @@
         return (res < size) ? res : size;
 }
 
-static __inline__ int find_next_zero_bit (void * addr, int size, int offset)
+static inline int find_first_bit(void * addr, unsigned size)
+{
+       unsigned long cmp, count;
+        int res;
+
+        if (!size)
+                return 0;
+        __asm__("   slr  %1,%1\n"
+                "   lr   %2,%3\n"
+                "   slr  %0,%0\n"
+                "   ahi  %2,31\n"
+                "   srl  %2,5\n"
+                "0: c    %1,0(%0,%4)\n"
+                "   jne  1f\n"
+                "   ahi  %0,4\n"
+                "   brct %2,0b\n"
+                "   lr   %0,%3\n"
+                "   j    4f\n"
+                "1: l    %2,0(%0,%4)\n"
+                "   sll  %0,3\n"
+                "   lhi  %1,0xff\n"
+                "   tml  %2,0xffff\n"
+                "   jnz  2f\n"
+                "   ahi  %0,16\n"
+                "   srl  %2,16\n"
+                "2: tml  %2,0x00ff\n"
+                "   jnz  3f\n"
+                "   ahi  %0,8\n"
+                "   srl  %2,8\n"
+                "3: nr   %2,%1\n"
+                "   ic   %2,0(%2,%5)\n"
+                "   alr  %0,%2\n"
+                "4:"
+                : "=&a" (res), "=&d" (cmp), "=&a" (count)
+                : "a" (size), "a" (addr), "a" (&_sb_findmap) : "cc" );
+        return (res < size) ? res : size;
+}
+
+static inline int find_next_zero_bit (void * addr, int size, int offset)
 {
         unsigned long * p = ((unsigned long *) addr) + (offset >> 5);
         unsigned long bitvec, reg;
@@ -680,11 +599,49 @@
         return (offset + res);
 }
 
+static inline int find_next_bit (void * addr, int size, int offset)
+{
+        unsigned long * p = ((unsigned long *) addr) + (offset >> 5);
+        unsigned long bitvec, reg;
+        int set, bit = offset & 31, res;
+
+        if (bit) {
+                /*
+                 * Look for set bit in first word
+                 */
+                bitvec = (*p) >> bit;
+                __asm__("   slr  %0,%0\n"
+                        "   lhi  %2,0xff\n"
+                        "   tml  %1,0xffff\n"
+                        "   jnz  0f\n"
+                        "   ahi  %0,16\n"
+                        "   srl  %1,16\n"
+                        "0: tml  %1,0x00ff\n"
+                        "   jnz  1f\n"
+                        "   ahi  %0,8\n"
+                        "   srl  %1,8\n"
+                        "1: nr   %1,%2\n"
+                        "   ic   %1,0(%1,%3)\n"
+                        "   alr  %0,%1"
+                        : "=&d" (set), "+a" (bitvec), "=&d" (reg)
+                        : "a" (&_sb_findmap) : "cc" );
+                if (set < (32 - bit))
+                        return set + offset;
+                offset += 32 - bit;
+                p++;
+        }
+        /*
+         * No set bit yet, search remaining full words for a bit
+         */
+        res = find_first_bit (p, size - 32 * (p - (unsigned long *) addr));
+        return (offset + res);
+}
+
 /*
  * ffz = Find First Zero in word. Undefined if no zero exists,
  * so code should check against ~0UL first..
  */
-static __inline__ unsigned long ffz(unsigned long word)
+static inline unsigned long ffz(unsigned long word)
 {
        unsigned long reg;
         int result;
@@ -708,40 +665,109 @@
 }
 
 /*
+ * __ffs = find first bit in word. Undefined if no bit exists,
+ * so code should check against 0UL first..
+ */
+static inline unsigned long __ffs(unsigned long word)
+{
+       unsigned long reg, result;
+
+        __asm__("   slr  %0,%0\n"
+                "   lhi  %2,0xff\n"
+                "   tml  %1,0xffff\n"
+                "   jnz  0f\n"
+                "   ahi  %0,16\n"
+                "   srl  %1,16\n"
+                "0: tml  %1,0x00ff\n"
+                "   jnz  1f\n"
+                "   ahi  %0,8\n"
+                "   srl  %1,8\n"
+                "1: nr   %1,%2\n"
+                "   ic   %1,0(%1,%3)\n"
+                "   alr  %0,%1"
+                : "=&d" (result), "+a" (word), "=&d" (reg)
+                : "a" (&_sb_findmap) : "cc" );
+        return result;
+}
+
+/*
+ * Every architecture must define this function. It's the fastest
+ * way of searching a 140-bit bitmap where the first 100 bits are
+ * unlikely to be set. It's guaranteed that at least one of the 140
+ * bits is cleared.
+ */
+static inline int _sched_find_first_bit(unsigned long *b)
+{
+       return find_first_bit(b, 140);
+}
+
+/*
  * ffs: find first bit set. This is defined the same way as
  * the libc and compiler builtin ffs routines, therefore
  * differs in spirit from the above ffz (man ffs).
  */
 
-extern int __inline__ ffs (int x)
+extern int inline ffs (int x)
 {
-        int r;
+        int r = 1;
 
         if (x == 0)
-          return 0;
-        __asm__("    slr  %0,%0\n"
-                "    tml  %1,0xffff\n"
+               return 0;
+        __asm__("    tml  %1,0xffff\n"
                 "    jnz  0f\n"
-                "    ahi  %0,16\n"
                 "    srl  %1,16\n"
+                "    ahi  %0,16\n"
                 "0:  tml  %1,0x00ff\n"
                 "    jnz  1f\n"
-                "    ahi  %0,8\n"
                 "    srl  %1,8\n"
+                "    ahi  %0,8\n"
                 "1:  tml  %1,0x000f\n"
                 "    jnz  2f\n"
-                "    ahi  %0,4\n"
                 "    srl  %1,4\n"
+                "    ahi  %0,4\n"
                 "2:  tml  %1,0x0003\n"
                 "    jnz  3f\n"
-                "    ahi  %0,2\n"
                 "    srl  %1,2\n"
+                "    ahi  %0,2\n"
                 "3:  tml  %1,0x0001\n"
                 "    jnz  4f\n"
                 "    ahi  %0,1\n"
                 "4:"
                 : "=&d" (r), "+d" (x) : : "cc" );
-        return r+1;
+        return r;
+}
+
+/*
+ * fls: find last bit set.
+ */
+extern __inline__ int fls(int x)
+{
+       int r = 32;
+
+       if (x == 0)
+               return 0;
+       __asm__("    tmh  %1,0xffff\n"
+               "    jz   0f\n"
+               "    sll  %1,16\n"
+               "    ahi  %0,-16\n"
+               "0:  tmh  %1,0xff00\n"
+               "    jz   1f\n"
+               "    sll  %1,8\n"
+               "    ahi  %0,-8\n"
+               "1:  tmh  %1,0xf000\n"
+               "    jz   2f\n"
+               "    sll  %1,4\n"
+               "    ahi  %0,-4\n"
+               "2:  tmh  %1,0xc000\n"
+               "    jz   3f\n"
+               "    sll  %1,2\n"
+               "    ahi  %0,-2\n"
+               "3:  tmh  %1,0x8000\n"
+               "    jz   4f\n"
+               "    ahi  %0,-1\n"
+               "4:"
+               : "+d" (r), "+d" (x) : : "cc" );
+       return r;
 }
 
 /*
@@ -769,7 +795,7 @@
 #define ext2_set_bit(nr, addr)       test_and_set_bit((nr)^24, addr)
 #define ext2_clear_bit(nr, addr)     test_and_clear_bit((nr)^24, addr)
 #define ext2_test_bit(nr, addr)      test_bit((nr)^24, addr)
-static __inline__ int ext2_find_first_zero_bit(void *vaddr, unsigned size)
+static inline int ext2_find_first_zero_bit(void *vaddr, unsigned size)
 {
        unsigned long cmp, count;
         int res;
@@ -808,7 +834,7 @@
         return (res < size) ? res : size;
 }
 
-static __inline__ int 
+static inline int 
 ext2_find_next_zero_bit(void *vaddr, unsigned size, unsigned offset)
 {
         unsigned long *addr = vaddr;
diff -urN linux-2.4.20/include/asm-s390x/bitops.h linux-2.4.20-o1-preempt/include/asm-s390x/bitops.h
--- linux-2.4.20/include/asm-s390x/bitops.h     Sat Aug  3 02:39:45 2002
+++ linux-2.4.20-o1-preempt/include/asm-s390x/bitops.h  Tue Feb 18 03:51:30 2003
@@ -51,271 +51,220 @@
 extern const char _oi_bitmap[];
 extern const char _ni_bitmap[];
 extern const char _zb_findmap[];
+extern const char _sb_findmap[];
 
 #ifdef CONFIG_SMP
 /*
  * SMP save set_bit routine based on compare and swap (CS)
  */
-static __inline__ void set_bit_cs(unsigned long nr, volatile void * addr)
+static inline void set_bit_cs(unsigned long nr, volatile void *ptr)
 {
-        unsigned long bits, mask;
-        __asm__ __volatile__(
+        unsigned long addr, old, new, mask;
+
+       addr = (unsigned long) ptr;
 #if ALIGN_CS == 1
-             "   lghi  %2,7\n"         /* CS must be aligned on 4 byte b. */
-             "   ngr   %2,%1\n"        /* isolate last 2 bits of address */
-             "   xgr   %1,%2\n"        /* make addr % 4 == 0 */
-             "   sllg  %2,%2,3\n"
-             "   agr   %0,%2\n"        /* add alignement to bitnr */
+       addr ^= addr & 7;               /* align address to 8 */
+       nr += (addr & 7) << 3;          /* add alignment to bit number */
 #endif
-             "   lghi  %2,63\n"
-             "   nr    %2,%0\n"        /* make shift value */
-             "   xr    %0,%2\n"
-             "   srlg  %0,%0,3\n"
-             "   lghi  %3,1\n"
-             "   la    %1,0(%0,%1)\n"  /* calc. address for CS */
-             "   sllg  %3,%3,0(%2)\n"  /* make OR mask */
-             "   lg    %0,0(%1)\n"
-             "0: lgr   %2,%0\n"        /* CS loop starts here */
-             "   ogr   %2,%3\n"        /* set bit */
-             "   csg   %0,%2,0(%1)\n"
-             "   jl    0b"
-             : "+a" (nr), "+a" (addr), "=&a" (bits), "=&d" (mask) :
-             : "cc", "memory" );
+       addr += (nr ^ (nr & 63)) >> 3;  /* calculate address for CS */
+       mask = 1UL << (nr & 63);        /* make OR mask */
+       asm volatile(
+               "   lg   %0,0(%4)\n"
+               "0: lgr  %1,%0\n"
+               "   ogr  %1,%3\n"
+               "   csg  %0,%1,0(%4)\n"
+               "   jl   0b"
+               : "=&d" (old), "=&d" (new), "+m" (*(unsigned long *) addr)
+               : "d" (mask), "a" (addr) 
+               : "cc" );
 }
 
 /*
  * SMP save clear_bit routine based on compare and swap (CS)
  */
-static __inline__ void clear_bit_cs(unsigned long nr, volatile void * addr)
+static inline void clear_bit_cs(unsigned long nr, volatile void *ptr)
 {
-        unsigned long bits, mask;
-        __asm__ __volatile__(
+        unsigned long addr, old, new, mask;
+
+       addr = (unsigned long) ptr;
 #if ALIGN_CS == 1
-             "   lghi  %2,7\n"         /* CS must be aligned on 4 byte b. */
-             "   ngr   %2,%1\n"        /* isolate last 2 bits of address */
-             "   xgr   %1,%2\n"        /* make addr % 4 == 0 */
-             "   sllg  %2,%2,3\n"
-             "   agr   %0,%2\n"        /* add alignement to bitnr */
+       addr ^= addr & 7;               /* align address to 8 */
+       nr += (addr & 7) << 3;          /* add alignment to bit number */
 #endif
-             "   lghi  %2,63\n"
-             "   nr    %2,%0\n"        /* make shift value */
-             "   xr    %0,%2\n"
-             "   srlg  %0,%0,3\n"
-             "   lghi  %3,-2\n"
-             "   la    %1,0(%0,%1)\n"  /* calc. address for CS */
-             "   lghi  %3,-2\n"
-             "   rllg  %3,%3,0(%2)\n"  /* make AND mask */
-             "   lg    %0,0(%1)\n"
-             "0: lgr   %2,%0\n"        /* CS loop starts here */
-             "   ngr   %2,%3\n"        /* clear bit */
-             "   csg   %0,%2,0(%1)\n"
-             "   jl    0b"
-             : "+a" (nr), "+a" (addr), "=&a" (bits), "=&d" (mask) :
-             : "cc", "memory" );
+       addr += (nr ^ (nr & 63)) >> 3;  /* calculate address for CS */
+       mask = ~(1UL << (nr & 63));     /* make AND mask */
+       asm volatile(
+               "   lg   %0,0(%4)\n"
+               "0: lgr  %1,%0\n"
+               "   ngr  %1,%3\n"
+               "   csg  %0,%1,0(%4)\n"
+               "   jl   0b"
+               : "=&d" (old), "=&d" (new), "+m" (*(unsigned long *) addr)
+               : "d" (mask), "a" (addr) 
+               : "cc" );
 }
 
 /*
  * SMP save change_bit routine based on compare and swap (CS)
  */
-static __inline__ void change_bit_cs(unsigned long nr, volatile void * addr)
+static inline void change_bit_cs(unsigned long nr, volatile void *ptr)
 {
-        unsigned long bits, mask;
-        __asm__ __volatile__(
+        unsigned long addr, old, new, mask;
+
+       addr = (unsigned long) ptr;
 #if ALIGN_CS == 1
-             "   lghi  %2,7\n"         /* CS must be aligned on 4 byte b. */
-             "   ngr   %2,%1\n"        /* isolate last 2 bits of address */
-             "   xgr   %1,%2\n"        /* make addr % 4 == 0 */
-             "   sllg  %2,%2,3\n"
-             "   agr   %0,%2\n"        /* add alignement to bitnr */
+       addr ^= addr & 7;               /* align address to 8 */
+       nr += (addr & 7) << 3;          /* add alignment to bit number */
 #endif
-             "   lghi  %2,63\n"
-             "   nr    %2,%0\n"        /* make shift value */
-             "   xr    %0,%2\n"
-             "   srlg  %0,%0,3\n"
-             "   lghi  %3,1\n"
-             "   la    %1,0(%0,%1)\n"  /* calc. address for CS */
-             "   sllg  %3,%3,0(%2)\n"  /* make XR mask */
-             "   lg    %0,0(%1)\n"
-             "0: lgr   %2,%0\n"        /* CS loop starts here */
-             "   xgr   %2,%3\n"        /* change bit */
-             "   csg   %0,%2,0(%1)\n"
-             "   jl    0b"
-             : "+a" (nr), "+a" (addr), "=&a" (bits), "=&d" (mask) : 
-             : "cc", "memory" );
+       addr += (nr ^ (nr & 63)) >> 3;  /* calculate address for CS */
+       mask = 1UL << (nr & 63);        /* make XOR mask */
+       asm volatile(
+               "   lg   %0,0(%4)\n"
+               "0: lgr  %1,%0\n"
+               "   xgr  %1,%3\n"
+               "   csg  %0,%1,0(%4)\n"
+               "   jl   0b"
+               : "=&d" (old), "=&d" (new), "+m" (*(unsigned long *) addr)
+               : "d" (mask), "a" (addr) 
+               : "cc" );
 }
 
 /*
  * SMP save test_and_set_bit routine based on compare and swap (CS)
  */
-static __inline__ int 
-test_and_set_bit_cs(unsigned long nr, volatile void * addr)
+static inline int 
+test_and_set_bit_cs(unsigned long nr, volatile void *ptr)
 {
-        unsigned long bits, mask;
-        __asm__ __volatile__(
+        unsigned long addr, old, new, mask;
+
+       addr = (unsigned long) ptr;
 #if ALIGN_CS == 1
-             "   lghi  %2,7\n"         /* CS must be aligned on 4 byte b. */
-             "   ngr   %2,%1\n"        /* isolate last 2 bits of address */
-             "   xgr   %1,%2\n"        /* make addr % 4 == 0 */
-             "   sllg  %2,%2,3\n"
-             "   agr   %0,%2\n"        /* add alignement to bitnr */
+       addr ^= addr & 7;               /* align address to 8 */
+       nr += (addr & 7) << 3;          /* add alignment to bit number */
 #endif
-             "   lghi  %2,63\n"
-             "   nr    %2,%0\n"        /* make shift value */
-             "   xr    %0,%2\n"
-             "   srlg  %0,%0,3\n"
-             "   lghi  %3,1\n"
-             "   la    %1,0(%0,%1)\n"  /* calc. address for CS */
-             "   sllg  %3,%3,0(%2)\n"  /* make OR mask */
-             "   lg    %0,0(%1)\n"
-             "0: lgr   %2,%0\n"        /* CS loop starts here */
-             "   ogr   %2,%3\n"        /* set bit */
-             "   csg   %0,%2,0(%1)\n"
-             "   jl    0b\n"
-             "   ngr   %0,%3\n"        /* isolate old bit */
-             : "+a" (nr), "+a" (addr), "=&a" (bits), "=&d" (mask) :
-             : "cc", "memory" );
-        return nr != 0;
+       addr += (nr ^ (nr & 63)) >> 3;  /* calculate address for CS */
+       mask = 1UL << (nr & 63);        /* make OR/test mask */
+       asm volatile(
+               "   lg   %0,0(%4)\n"
+               "0: lgr  %1,%0\n"
+               "   ogr  %1,%3\n"
+               "   csg  %0,%1,0(%4)\n"
+               "   jl   0b"
+               : "=&d" (old), "=&d" (new), "+m" (*(unsigned long *) addr)
+               : "d" (mask), "a" (addr) 
+               : "cc" );
+       return (old & mask) != 0;
 }
 
 /*
  * SMP save test_and_clear_bit routine based on compare and swap (CS)
  */
-static __inline__ int
-test_and_clear_bit_cs(unsigned long nr, volatile void * addr)
+static inline int
+test_and_clear_bit_cs(unsigned long nr, volatile void *ptr)
 {
-        unsigned long bits, mask;
-        __asm__ __volatile__(
+        unsigned long addr, old, new, mask;
+
+       addr = (unsigned long) ptr;
 #if ALIGN_CS == 1
-             "   lghi  %2,7\n"         /* CS must be aligned on 4 byte b. */
-             "   ngr   %2,%1\n"        /* isolate last 2 bits of address */
-             "   xgr   %1,%2\n"        /* make addr % 4 == 0 */
-             "   sllg  %2,%2,3\n"
-             "   agr   %0,%2\n"        /* add alignement to bitnr */
+       addr ^= addr & 7;               /* align address to 8 */
+       nr += (addr & 7) << 3;          /* add alignment to bit number */
 #endif
-             "   lghi  %2,63\n"
-             "   nr    %2,%0\n"        /* make shift value */
-             "   xr    %0,%2\n"
-             "   srlg  %0,%0,3\n"
-             "   lghi  %3,-2\n"
-             "   la    %1,0(%0,%1)\n"  /* calc. address for CS */
-             "   rllg  %3,%3,0(%2)\n"  /* make AND mask */
-             "   lg    %0,0(%1)\n"
-             "0: lgr   %2,%0\n"        /* CS loop starts here */
-             "   ngr   %2,%3\n"        /* clear bit */
-             "   csg   %0,%2,0(%1)\n"
-             "   jl    0b\n"
-             "   xgr   %0,%2\n"        /* isolate old bit */
-             : "+a" (nr), "+a" (addr), "=&a" (bits), "=&d" (mask) :
-             : "cc", "memory" );
-        return nr != 0;
+       addr += (nr ^ (nr & 63)) >> 3;  /* calculate address for CS */
+       mask = ~(1UL << (nr & 63));     /* make AND mask */
+       asm volatile(
+               "   lg   %0,0(%4)\n"
+               "0: lgr  %1,%0\n"
+               "   ngr  %1,%3\n"
+               "   csg  %0,%1,0(%4)\n"
+               "   jl   0b"
+               : "=&d" (old), "=&d" (new), "+m" (*(unsigned long *) addr)
+               : "d" (mask), "a" (addr) 
+               : "cc" );
+       return (old ^ new) != 0;
 }
 
 /*
  * SMP save test_and_change_bit routine based on compare and swap (CS) 
  */
-static __inline__ int
-test_and_change_bit_cs(unsigned long nr, volatile void * addr)
+static inline int
+test_and_change_bit_cs(unsigned long nr, volatile void *ptr)
 {
-        unsigned long bits, mask;
-        __asm__ __volatile__(
+        unsigned long addr, old, new, mask;
+
+       addr = (unsigned long) ptr;
 #if ALIGN_CS == 1
-             "   lghi  %2,7\n"         /* CS must be aligned on 4 byte b. */
-             "   ngr   %2,%1\n"        /* isolate last 2 bits of address */
-             "   xgr   %1,%2\n"        /* make addr % 4 == 0 */
-             "   sllg  %2,%2,3\n"
-             "   agr   %0,%2\n"        /* add alignement to bitnr */
+       addr ^= addr & 7;               /* align address to 8 */
+       nr += (addr & 7) << 3;          /* add alignment to bit number */
 #endif
-             "   lghi  %2,63\n"
-             "   nr    %2,%0\n"        /* make shift value */
-             "   xr    %0,%2\n"
-             "   srlg  %0,%0,3\n"
-             "   lghi  %3,1\n"
-             "   la    %1,0(%0,%1)\n"  /* calc. address for CS */
-             "   sllg  %3,%3,0(%2)\n"  /* make OR mask */
-             "   lg    %0,0(%1)\n"
-             "0: lgr   %2,%0\n"        /* CS loop starts here */
-             "   xgr   %2,%3\n"        /* change bit */
-             "   csg   %0,%2,0(%1)\n"
-             "   jl    0b\n"
-             "   ngr   %0,%3\n"        /* isolate old bit */
-             : "+a" (nr), "+a" (addr), "=&a" (bits), "=&d" (mask) :
-             : "cc", "memory" );
-        return nr != 0;
+       addr += (nr ^ (nr & 63)) >> 3;  /* calculate address for CS */
+       mask = 1UL << (nr & 63);        /* make XOR mask */
+       asm volatile(
+               "   lg   %0,0(%4)\n"
+               "0: lgr  %1,%0\n"
+               "   xgr  %1,%3\n"
+               "   csg  %0,%1,0(%4)\n"
+               "   jl   0b"
+               : "=&d" (old), "=&d" (new), "+m" (*(unsigned long *) addr)
+               : "d" (mask), "a" (addr) 
+               : "cc" );
+       return (old & mask) != 0;
 }
 #endif /* CONFIG_SMP */
 
 /*
  * fast, non-SMP set_bit routine
  */
-static __inline__ void __set_bit(unsigned long nr, volatile void * addr)
+static inline void __set_bit(unsigned long nr, volatile void *ptr)
 {
-       unsigned long reg1, reg2;
-        __asm__ __volatile__(
-             "   lghi  %1,56\n"
-             "   lghi  %0,7\n"
-             "   xgr   %1,%2\n"
-             "   nr    %0,%2\n"
-             "   srlg  %1,%1,3\n"
-             "   la    %1,0(%1,%3)\n"
-             "   la    %0,0(%0,%4)\n"
-             "   oc    0(1,%1),0(%0)"
-             : "=&a" (reg1), "=&a" (reg2)
-             : "a" (nr), "a" (addr), "a" (&_oi_bitmap) : "cc", "memory" );
-}
-
-static __inline__ void 
-__constant_set_bit(const unsigned long nr, volatile void * addr)
-{
-  switch (nr&7) {
-  case 0:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x01"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7))) 
-                          : : "1", "cc", "memory");
-    break;
-  case 1:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x02"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 2:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x04"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 3:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x08"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 4:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x10"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 5:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x20"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 6:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x40"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 7:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "oi 0(1),0x80"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  }
+       unsigned long addr;
+
+       addr = (unsigned long) ptr + ((nr ^ 56) >> 3);
+        asm volatile("oc 0(1,%1),0(%2)"
+                    : "+m" (*(char *) addr)
+                    : "a" (addr), "a" (_oi_bitmap + (nr & 7))
+                    : "cc" );
+}
+
+static inline void 
+__constant_set_bit(const unsigned long nr, volatile void *ptr)
+{
+       unsigned long addr;
+
+       addr = ((unsigned long) ptr) + ((nr >> 3) ^ 7);
+       switch (nr&7) {
+       case 0:
+               asm volatile ("oi 0(%1),0x01"
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 1:
+               asm volatile ("oi 0(%1),0x02"
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 2:
+               asm volatile ("oi 0(%1),0x04" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 3:
+               asm volatile ("oi 0(%1),0x08" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 4:
+               asm volatile ("oi 0(%1),0x10" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 5:
+               asm volatile ("oi 0(%1),0x20" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 6:
+               asm volatile ("oi 0(%1),0x40" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 7:
+               asm volatile ("oi 0(%1),0x80" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       }
 }
 
 #define set_bit_simple(nr,addr) \
@@ -326,76 +275,58 @@
 /*
  * fast, non-SMP clear_bit routine
  */
-static __inline__ void 
-__clear_bit(unsigned long nr, volatile void * addr)
+static inline void 
+__clear_bit(unsigned long nr, volatile void *ptr)
 {
-       unsigned long reg1, reg2;
-        __asm__ __volatile__(
-             "   lghi  %1,56\n"
-             "   lghi  %0,7\n"
-             "   xgr   %1,%2\n"
-             "   nr    %0,%2\n"
-             "   srlg  %1,%1,3\n"
-             "   la    %1,0(%1,%3)\n"
-             "   la    %0,0(%0,%4)\n"
-             "   nc    0(1,%1),0(%0)"
-             : "=&a" (reg1), "=&a" (reg2)
-            : "d" (nr), "a" (addr), "a" (&_ni_bitmap) : "cc", "memory" );
-}
-
-static __inline__ void 
-__constant_clear_bit(const unsigned long nr, volatile void * addr)
-{
-  switch (nr&7) {
-  case 0:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0xFE"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 1:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0xFD"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 2:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0xFB"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 3:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0xF7"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 4:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0xEF"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "cc", "memory" );
-    break;
-  case 5:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0xDF"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 6:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0xBF"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 7:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "ni 0(1),0x7F"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  }
+       unsigned long addr;
+
+       addr = (unsigned long) ptr + ((nr ^ 56) >> 3);
+        asm volatile("nc 0(1,%1),0(%2)"
+                    : "+m" (*(char *) addr)
+                    : "a" (addr), "a" (_ni_bitmap + (nr & 7))
+                    : "cc" );
+}
+
+static inline void 
+__constant_clear_bit(const unsigned long nr, volatile void *ptr)
+{
+       unsigned long addr;
+
+       addr = ((unsigned long) ptr) + ((nr >> 3) ^ 7);
+       switch (nr&7) {
+       case 0:
+               asm volatile ("ni 0(%1),0xFE" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 1:
+               asm volatile ("ni 0(%1),0xFD"
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 2:
+               asm volatile ("ni 0(%1),0xFB" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 3:
+               asm volatile ("ni 0(%1),0xF7" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 4:
+               asm volatile ("ni 0(%1),0xEF" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 5:
+               asm volatile ("ni 0(%1),0xDF" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 6:
+               asm volatile ("ni 0(%1),0xBF" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 7:
+               asm volatile ("ni 0(%1),0x7F" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       }
 }
 
 #define clear_bit_simple(nr,addr) \
@@ -406,75 +337,57 @@
 /* 
  * fast, non-SMP change_bit routine 
  */
-static __inline__ void __change_bit(unsigned long nr, volatile void * addr)
+static inline void __change_bit(unsigned long nr, volatile void *ptr)
 {
-       unsigned long reg1, reg2;
-        __asm__ __volatile__(
-             "   lghi  %1,56\n"
-             "   lghi  %0,7\n"
-             "   xgr   %1,%2\n"
-             "   nr    %0,%2\n"
-             "   srlg  %1,%1,3\n"
-             "   la    %1,0(%1,%3)\n"
-             "   la    %0,0(%0,%4)\n"
-             "   xc    0(1,%1),0(%0)"
-             : "=&a" (reg1), "=&a" (reg2)
-            : "d" (nr), "a" (addr), "a" (&_oi_bitmap) : "cc", "memory" );
-}
-
-static __inline__ void 
-__constant_change_bit(const unsigned long nr, volatile void * addr) 
-{
-  switch (nr&7) {
-  case 0:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x01"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "cc", "memory" );
-    break;
-  case 1:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x02"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "cc", "memory" );
-    break;
-  case 2:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x04"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "cc", "memory" );
-    break;
-  case 3:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x08"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "cc", "memory" );
-    break;
-  case 4:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x10"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "cc", "memory" );
-    break;
-  case 5:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x20"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 6:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x40"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  case 7:
-    __asm__ __volatile__ ("la 1,%0\n\t"
-                          "xi 0(1),0x80"
-                          : "=m" (*((volatile char *) addr + ((nr>>3)^7)))
-                          : : "1", "cc", "memory" );
-    break;
-  }
+       unsigned long addr;
+
+       addr = (unsigned long) ptr + ((nr ^ 56) >> 3);
+        asm volatile("xc 0(1,%1),0(%2)"
+                    :  "+m" (*(char *) addr)
+                    : "a" (addr), "a" (_oi_bitmap + (nr & 7))
+                    : "cc" );
+}
+
+static inline void 
+__constant_change_bit(const unsigned long nr, volatile void *ptr) 
+{
+       unsigned long addr;
+
+       addr = ((unsigned long) ptr) + ((nr >> 3) ^ 7);
+       switch (nr&7) {
+       case 0:
+               asm volatile ("xi 0(%1),0x01" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 1:
+               asm volatile ("xi 0(%1),0x02" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 2:
+               asm volatile ("xi 0(%1),0x04" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 3:
+               asm volatile ("xi 0(%1),0x08" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 4:
+               asm volatile ("xi 0(%1),0x10" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 5:
+               asm volatile ("xi 0(%1),0x20" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 6:
+               asm volatile ("xi 0(%1),0x40" 
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       case 7:
+               asm volatile ("xi 0(%1),0x80"
+                             : "+m" (*(char *) addr) : "a" (addr) : "cc" );
+               break;
+       }
 }
 
 #define change_bit_simple(nr,addr) \
@@ -485,77 +398,57 @@
 /*
  * fast, non-SMP test_and_set_bit routine
  */
-static __inline__ int
-test_and_set_bit_simple(unsigned long nr, volatile void * addr)
+static inline int
+test_and_set_bit_simple(unsigned long nr, volatile void *ptr)
 {
-       unsigned long reg1, reg2;
-        int oldbit;
-        __asm__ __volatile__(
-             "   lghi  %1,56\n"
-             "   lghi  %2,7\n"
-             "   xgr   %1,%3\n"
-             "   nr    %2,%3\n"
-             "   srlg  %1,%1,3\n"
-             "   la    %1,0(%1,%4)\n"
-             "   ic    %0,0(%1)\n"
-             "   srl   %0,0(%2)\n"
-             "   la    %2,0(%2,%5)\n"
-             "   oc    0(1,%1),0(%2)"
-             : "=&d" (oldbit), "=&a" (reg1), "=&a" (reg2)
-            : "d" (nr), "a" (addr), "a" (&_oi_bitmap) : "cc", "memory" );
-        return oldbit & 1;
+       unsigned long addr;
+       unsigned char ch;
+
+       addr = (unsigned long) ptr + ((nr ^ 56) >> 3);
+       ch = *(unsigned char *) addr;
+        asm volatile("oc 0(1,%1),0(%2)"
+                    : "+m" (*(char *) addr)
+                    : "a" (addr), "a" (_oi_bitmap + (nr & 7))
+                    : "cc" );
+       return (ch >> (nr & 7)) & 1;
 }
 #define __test_and_set_bit(X,Y)                test_and_set_bit_simple(X,Y)
 
 /*
  * fast, non-SMP test_and_clear_bit routine
  */
-static __inline__ int
-test_and_clear_bit_simple(unsigned long nr, volatile void * addr)
+static inline int
+test_and_clear_bit_simple(unsigned long nr, volatile void *ptr)
 {
-       unsigned long reg1, reg2;
-        int oldbit;
+       unsigned long addr;
+       unsigned char ch;
 
-        __asm__ __volatile__(
-             "   lghi  %1,56\n"
-             "   lghi  %2,7\n"
-             "   xgr   %1,%3\n"
-             "   nr    %2,%3\n"
-             "   srlg  %1,%1,3\n"
-             "   la    %1,0(%1,%4)\n"
-             "   ic    %0,0(%1)\n"
-             "   srl   %0,0(%2)\n"
-             "   la    %2,0(%2,%5)\n"
-             "   nc    0(1,%1),0(%2)"
-             : "=&d" (oldbit), "=&a" (reg1), "=&a" (reg2)
-            : "d" (nr), "a" (addr), "a" (&_ni_bitmap) : "cc", "memory" );
-        return oldbit & 1;
+       addr = (unsigned long) ptr + ((nr ^ 56) >> 3);
+       ch = *(unsigned char *) addr;
+        asm volatile("nc 0(1,%1),0(%2)"
+                    : "+m" (*(char *) addr)
+                    : "a" (addr), "a" (_ni_bitmap + (nr & 7))
+                    : "cc" );
+       return (ch >> (nr & 7)) & 1;
 }
 #define __test_and_clear_bit(X,Y)      test_and_clear_bit_simple(X,Y)
 
 /*
  * fast, non-SMP test_and_change_bit routine
  */
-static __inline__ int
-test_and_change_bit_simple(unsigned long nr, volatile void * addr)
+static inline int
+test_and_change_bit_simple(unsigned long nr, volatile void *ptr)
 {
-       unsigned long reg1, reg2;
-        int oldbit;
+       unsigned long addr;
+       unsigned char ch;
 
-        __asm__ __volatile__(
-             "   lghi  %1,56\n"
-             "   lghi  %2,7\n"
-             "   xgr   %1,%3\n"
-             "   nr    %2,%3\n"
-             "   srlg  %1,%1,3\n"
-             "   la    %1,0(%1,%4)\n"
-             "   ic    %0,0(%1)\n"
-             "   srl   %0,0(%2)\n"
-             "   la    %2,0(%2,%5)\n"
-             "   xc    0(1,%1),0(%2)"
-             : "=&d" (oldbit), "=&a" (reg1), "=&a" (reg2)
-            : "d" (nr), "a" (addr), "a" (&_oi_bitmap) : "cc", "memory" );
-        return oldbit & 1;
+       addr = (unsigned long) ptr + ((nr ^ 56) >> 3);
+       ch = *(unsigned char *) addr;
+        asm volatile("xc 0(1,%1),0(%2)"
+                    : "+m" (*(char *) addr)
+                    : "a" (addr), "a" (_oi_bitmap + (nr & 7))
+                    : "cc" );
+       return (ch >> (nr & 7)) & 1;
 }
 #define __test_and_change_bit(X,Y)     test_and_change_bit_simple(X,Y)
 
@@ -580,26 +473,18 @@
  * This routine doesn't need to be atomic.
  */
 
-static __inline__ int __test_bit(unsigned long nr, volatile void * addr)
+static inline int __test_bit(unsigned long nr, volatile void *ptr)
 {
-       unsigned long reg1, reg2;
-        int oldbit;
+       unsigned long addr;
+       unsigned char ch;
 
-        __asm__ __volatile__(
-             "   lghi  %2,56\n"
-             "   lghi  %1,7\n"
-             "   xgr   %2,%3\n"
-             "   nr    %1,%3\n"
-             "   srlg  %2,%2,3\n"
-             "   ic    %0,0(%2,%4)\n"
-             "   srl   %0,0(%1)\n"
-             : "=&d" (oldbit), "=&a" (reg1), "=&a" (reg2)
-            : "d" (nr), "a" (addr) : "cc" );
-        return oldbit & 1;
+       addr = (unsigned long) ptr + ((nr ^ 56) >> 3);
+       ch = *(unsigned char *) addr;
+       return (ch >> (nr & 7)) & 1;
 }
 
-static __inline__ int 
-__constant_test_bit(unsigned long nr, volatile void * addr) {
+static inline int 
+__constant_test_bit(unsigned long nr, volatile void *addr) {
     return (((volatile char *) addr)[(nr>>3)^7] & (1<<(nr&7))) != 0;
 }
 
@@ -611,7 +496,7 @@
 /*
  * Find-bit routines..
  */
-static __inline__ unsigned long
+static inline unsigned long
 find_first_zero_bit(void * addr, unsigned long size)
 {
         unsigned long res, cmp, count;
@@ -653,7 +538,49 @@
         return (res < size) ? res : size;
 }
 
-static __inline__ unsigned long
+static inline unsigned long
+find_first_bit(void * addr, unsigned long size)
+{
+        unsigned long res, cmp, count;
+
+        if (!size)
+                return 0;
+        __asm__("   slgr  %1,%1\n"
+                "   lgr   %2,%3\n"
+                "   slgr  %0,%0\n"
+                "   aghi  %2,63\n"
+                "   srlg  %2,%2,6\n"
+                "0: cg    %1,0(%0,%4)\n"
+                "   jne   1f\n"
+                "   aghi  %0,8\n"
+                "   brct  %2,0b\n"
+                "   lgr   %0,%3\n"
+                "   j     5f\n"
+                "1: lg    %2,0(%0,%4)\n"
+                "   sllg  %0,%0,3\n"
+                "   clr   %2,%1\n"
+               "   jne   2f\n"
+               "   aghi  %0,32\n"
+                "   srlg  %2,%2,32\n"
+               "2: lghi  %1,0xff\n"
+                "   tmll  %2,0xffff\n"
+                "   jnz   3f\n"
+                "   aghi  %0,16\n"
+                "   srl   %2,16\n"
+                "3: tmll  %2,0x00ff\n"
+                "   jnz   4f\n"
+                "   aghi  %0,8\n"
+                "   srl   %2,8\n"
+                "4: ngr   %2,%1\n"
+                "   ic    %2,0(%2,%5)\n"
+                "   algr  %0,%2\n"
+                "5:"
+                : "=&a" (res), "=&d" (cmp), "=&a" (count)
+               : "a" (size), "a" (addr), "a" (&_sb_findmap) : "cc" );
+        return (res < size) ? res : size;
+}
+
+static inline unsigned long
 find_next_zero_bit (void * addr, unsigned long size, unsigned long offset)
 {
         unsigned long * p = ((unsigned long *) addr) + (offset >> 6);
@@ -697,14 +624,56 @@
         return (offset + res);
 }
 
+static inline unsigned long
+find_next_bit (void * addr, unsigned long size, unsigned long offset)
+{
+        unsigned long * p = ((unsigned long *) addr) + (offset >> 6);
+        unsigned long bitvec, reg;
+        unsigned long set, bit = offset & 63, res;
+
+        if (bit) {
+                /*
+                 * Look for zero in first word
+                 */
+                bitvec = (*p) >> bit;
+                __asm__("   slgr %0,%0\n"
+                        "   ltr  %1,%1\n"
+                        "   jnz  0f\n"
+                        "   aghi %0,32\n"
+                        "   srlg %1,%1,32\n"
+                       "0: lghi %2,0xff\n"
+                        "   tmll %1,0xffff\n"
+                        "   jnz  1f\n"
+                        "   aghi %0,16\n"
+                        "   srlg %1,%1,16\n"
+                        "1: tmll %1,0x00ff\n"
+                        "   jnz  2f\n"
+                        "   aghi %0,8\n"
+                        "   srlg %1,%1,8\n"
+                        "2: ngr  %1,%2\n"
+                        "   ic   %1,0(%1,%3)\n"
+                        "   algr %0,%1"
+                        : "=&d" (set), "+a" (bitvec), "=&d" (reg)
+                        : "a" (&_sb_findmap) : "cc" );
+                if (set < (64 - bit))
+                        return set + offset;
+                offset += 64 - bit;
+                p++;
+        }
+        /*
+         * No set bit yet, search remaining full words for a bit
+         */
+        res = find_first_bit (p, size - 64 * (p - (unsigned long *) addr));
+        return (offset + res);
+}
+
 /*
  * ffz = Find First Zero in word. Undefined if no zero exists,
  * so code should check against ~0UL first..
  */
-static __inline__ unsigned long ffz(unsigned long word)
+static inline unsigned long ffz(unsigned long word)
 {
-       unsigned long reg;
-        int result;
+       unsigned long reg, result;
 
         __asm__("   lhi  %2,-1\n"
                 "   slgr %0,%0\n"
@@ -730,40 +699,112 @@
 }
 
 /*
+ * __ffs = find first bit in word. Undefined if no bit exists,
+ * so code should check against 0UL first..
+ */
+static inline unsigned long __ffs (unsigned long word)
+{
+        unsigned long reg, result;
+
+        __asm__("   slgr %0,%0\n"
+                "   ltr  %1,%1\n"
+                "   jnz  0f\n"
+                "   aghi %0,32\n"
+                "   srlg %1,%1,32\n"
+                "0: lghi %2,0xff\n"
+                "   tmll %1,0xffff\n"
+                "   jnz  1f\n"
+                "   aghi %0,16\n"
+                "   srlg %1,%1,16\n"
+                "1: tmll %1,0x00ff\n"
+                "   jnz  2f\n"
+                "   aghi %0,8\n"
+                "   srlg %1,%1,8\n"
+                "2: ngr  %1,%2\n"
+                "   ic   %1,0(%1,%3)\n"
+                "   algr %0,%1"
+                : "=&d" (result), "+a" (word), "=&d" (reg)
+                : "a" (&_sb_findmap) : "cc" );
+        return result;
+}
+
+/*
+ * Every architecture must define this function. It's the fastest
+ * way of searching a 140-bit bitmap where the first 100 bits are
+ * unlikely to be set. It's guaranteed that at least one of the 140
+ * bits is cleared.
+ */
+static inline int _sched_find_first_bit(unsigned long *b)
+{
+       return find_first_bit(b, 140);
+}
+
+/*
  * ffs: find first bit set. This is defined the same way as
  * the libc and compiler builtin ffs routines, therefore
  * differs in spirit from the above ffz (man ffs).
  */
-
-extern int __inline__ ffs (int x)
+extern int inline ffs (int x)
 {
-        int r;
+        int r = 1;
 
         if (x == 0)
-          return 0;
-        __asm__("    slr  %0,%0\n"
-                "    tml  %1,0xffff\n"
+               return 0;
+        __asm__("    tml  %1,0xffff\n"
                 "    jnz  0f\n"
-                "    ahi  %0,16\n"
                 "    srl  %1,16\n"
+                "    ahi  %0,16\n"
                 "0:  tml  %1,0x00ff\n"
                 "    jnz  1f\n"
-                "    ahi  %0,8\n"
                 "    srl  %1,8\n"
+                "    ahi  %0,8\n"
                 "1:  tml  %1,0x000f\n"
                 "    jnz  2f\n"
-                "    ahi  %0,4\n"
                 "    srl  %1,4\n"
+                "    ahi  %0,4\n"
                 "2:  tml  %1,0x0003\n"
                 "    jnz  3f\n"
-                "    ahi  %0,2\n"
                 "    srl  %1,2\n"
+                "    ahi  %0,2\n"
                 "3:  tml  %1,0x0001\n"
                 "    jnz  4f\n"
                 "    ahi  %0,1\n"
                 "4:"
                 : "=&d" (r), "+d" (x) : : "cc" );
-        return r+1;
+        return r;
+}
+
+/*
+ * fls: find last bit set.
+ */
+extern __inline__ int fls(int x)
+{
+       int r = 32;
+
+       if (x == 0)
+               return 0;
+       __asm__("    tmh  %1,0xffff\n"
+               "    jz   0f\n"
+               "    sll  %1,16\n"
+               "    ahi  %0,-16\n"
+               "0:  tmh  %1,0xff00\n"
+               "    jz   1f\n"
+               "    sll  %1,8\n"
+               "    ahi  %0,-8\n"
+               "1:  tmh  %1,0xf000\n"
+               "    jz   2f\n"
+               "    sll  %1,4\n"
+               "    ahi  %0,-4\n"
+               "2:  tmh  %1,0xc000\n"
+               "    jz   3f\n"
+               "    sll  %1,2\n"
+               "    ahi  %0,-2\n"
+               "3:  tmh  %1,0x8000\n"
+               "    jz   4f\n"
+               "    ahi  %0,-1\n"
+               "4:"
+               : "+d" (r), "+d" (x) : : "cc" );
+       return r;
 }
 
 /*
@@ -791,7 +832,7 @@
 #define ext2_set_bit(nr, addr)       test_and_set_bit((nr)^56, addr)
 #define ext2_clear_bit(nr, addr)     test_and_clear_bit((nr)^56, addr)
 #define ext2_test_bit(nr, addr)      test_bit((nr)^56, addr)
-static __inline__ unsigned long
+static inline unsigned long
 ext2_find_first_zero_bit(void *vaddr, unsigned long size)
 {
         unsigned long res, cmp, count;
@@ -833,7 +874,7 @@
         return (res < size) ? res : size;
 }
 
-static __inline__ unsigned long
+static inline unsigned long
 ext2_find_next_zero_bit(void *vaddr, unsigned long size, unsigned long offset)
 {
         unsigned long *addr = vaddr;
diff -urN linux-2.4.20/include/asm-sh/hardirq.h linux-2.4.20-o1-preempt/include/asm-sh/hardirq.h
--- linux-2.4.20/include/asm-sh/hardirq.h       Sat Sep  8 21:29:09 2001
+++ linux-2.4.20-o1-preempt/include/asm-sh/hardirq.h    Tue Feb 18 03:52:06 2003
@@ -34,6 +34,8 @@
 
 #define synchronize_irq()      barrier()
 
+#define release_irqlock(cpu)   do { } while (0)
+
 #else
 
 #error Super-H SMP is not available
diff -urN linux-2.4.20/include/asm-sh/smplock.h linux-2.4.20-o1-preempt/include/asm-sh/smplock.h
--- linux-2.4.20/include/asm-sh/smplock.h       Sat Sep  8 21:29:09 2001
+++ linux-2.4.20-o1-preempt/include/asm-sh/smplock.h    Tue Feb 18 03:52:06 2003
@@ -9,15 +9,88 @@
 
 #include <linux/config.h>
 
-#ifndef CONFIG_SMP
-
+#if !defined(CONFIG_SMP) && !defined(CONFIG_PREEMPT)
+/*
+ * Should never happen, since linux/smp_lock.h catches this case;
+ * but in case this file is included directly with neither SMP nor
+ * PREEMPT configuration, provide same dummys as linux/smp_lock.h
+ */
 #define lock_kernel()                          do { } while(0)
 #define unlock_kernel()                                do { } while(0)
-#define release_kernel_lock(task, cpu, depth)  ((depth) = 1)
-#define reacquire_kernel_lock(task, cpu, depth)        do { } while(0)
+#define release_kernel_lock(task, cpu)         do { } while(0)
+#define reacquire_kernel_lock(task)            do { } while(0)
+#define kernel_locked()                1
+
+#else /* CONFIG_SMP || CONFIG_PREEMPT */
+
+#if CONFIG_SMP
+#error "We do not support SMP on SH yet"
+#endif
+/*
+ * Default SMP lock implementation (i.e. the i386 version)
+ */
+
+#include <linux/interrupt.h>
+#include <linux/spinlock.h>
+
+extern spinlock_t kernel_flag;
+#define lock_bkl() spin_lock(&kernel_flag)
+#define unlock_bkl() spin_unlock(&kernel_flag)
 
+#ifdef CONFIG_SMP
+#define kernel_locked()                spin_is_locked(&kernel_flag)
+#elif  CONFIG_PREEMPT
+#define kernel_locked()                preempt_get_count()
+#else  /* neither */
+#define kernel_locked()                1
+#endif
+
+/*
+ * Release global kernel lock and global interrupt lock
+ */
+#define release_kernel_lock(task, cpu) \
+do { \
+       if (task->lock_depth >= 0) \
+               spin_unlock(&kernel_flag); \
+       release_irqlock(cpu); \
+       __sti(); \
+} while (0)
+
+/*
+ * Re-acquire the kernel lock
+ */
+#define reacquire_kernel_lock(task) \
+do { \
+       if (task->lock_depth >= 0) \
+               spin_lock(&kernel_flag); \
+} while (0)
+
+/*
+ * Getting the big kernel lock.
+ *
+ * This cannot happen asynchronously,
+ * so we only need to worry about other
+ * CPU's.
+ */
+static __inline__ void lock_kernel(void)
+{
+#ifdef CONFIG_PREEMPT
+       if (current->lock_depth == -1)
+               spin_lock(&kernel_flag);
+       ++current->lock_depth;
 #else
-#error "We do not support SMP on SH"
-#endif /* CONFIG_SMP */
+       if (!++current->lock_depth)
+               spin_lock(&kernel_flag);
+#endif
+}
+
+static __inline__ void unlock_kernel(void)
+{
+       if (current->lock_depth < 0)
+               BUG();
+       if (--current->lock_depth < 0)
+               spin_unlock(&kernel_flag);
+}
+#endif /* CONFIG_SMP || CONFIG_PREEMPT */
 
 #endif /* __ASM_SH_SMPLOCK_H */
diff -urN linux-2.4.20/include/asm-sh/softirq.h linux-2.4.20-o1-preempt/include/asm-sh/softirq.h
--- linux-2.4.20/include/asm-sh/softirq.h       Sat Sep  8 21:29:09 2001
+++ linux-2.4.20-o1-preempt/include/asm-sh/softirq.h    Tue Feb 18 03:52:06 2003
@@ -6,6 +6,7 @@
 
 #define local_bh_disable()                     \
 do {                                           \
+       preempt_disable();                      \
        local_bh_count(smp_processor_id())++;   \
        barrier();                              \
 } while (0)
@@ -14,6 +15,7 @@
 do {                                           \
        barrier();                              \
        local_bh_count(smp_processor_id())--;   \
+       preempt_enable();                       \
 } while (0)
 
 #define local_bh_enable()                              \
@@ -23,6 +25,7 @@
            && softirq_pending(smp_processor_id())) {   \
                do_softirq();                           \
        }                                               \
+       preempt_enable();                               \
 } while (0)
 
 #define in_softirq() (local_bh_count(smp_processor_id()) != 0)
diff -urN linux-2.4.20/include/asm-sh/system.h linux-2.4.20-o1-preempt/include/asm-sh/system.h
--- linux-2.4.20/include/asm-sh/system.h        Sat Sep  8 21:29:09 2001
+++ linux-2.4.20-o1-preempt/include/asm-sh/system.h     Tue Feb 18 03:52:06 2003
@@ -285,4 +285,17 @@
 void disable_hlt(void);
 void enable_hlt(void);
 
+/*
+ * irqs_disabled - are interrupts disabled?
+ */
+static inline int irqs_disabled(void) 
+{
+       unsigned long flags;
+
+       __save_flags(flags);
+       if (flags & 0x000000f0)
+               return 1;
+       return 0;
+}
+
 #endif
diff -urN linux-2.4.20/include/asm-sparc/bitops.h linux-2.4.20-o1-preempt/include/asm-sparc/bitops.h
--- linux-2.4.20/include/asm-sparc/bitops.h     Fri Dec 21 18:42:03 2001
+++ linux-2.4.20-o1-preempt/include/asm-sparc/bitops.h  Tue Feb 18 03:51:30 2003
@@ -13,6 +13,23 @@
 #include <asm/byteorder.h>
 #include <asm/system.h>
 
+/**
+ * __ffs - find first bit in word.
+ * @word: The word to search
+ *
+ * Undefined if no bit exists, so code should check against 0 first.
+ */
+static __inline__ unsigned long __ffs(unsigned long word)
+{
+       unsigned long result = 0;
+
+       while (!(word & 1UL)) {
+               result++;
+               word >>= 1;
+       }
+       return result;
+}
+
 #ifdef __KERNEL__
 
 /*
@@ -205,6 +222,25 @@
                word >>= 1;
        }
        return result;
+}
+
+/*
+ * Every architecture must define this function. It's the fastest
+ * way of searching a 140-bit bitmap where the first 100 bits are
+ * unlikely to be set. It's guaranteed that at least one of the 140
+ * bits is cleared.
+ */
+static inline int _sched_find_first_bit(unsigned long *b)
+{
+       if (unlikely(b[0]))
+               return __ffs(b[0]);
+       if (unlikely(b[1]))
+               return __ffs(b[1]) + 32;
+       if (unlikely(b[2]))
+               return __ffs(b[2]) + 64;
+       if (b[3])
+               return __ffs(b[3]) + 96;
+       return __ffs(b[4]) + 128;
 }
 
 /*
--- linux-2.4.20/include/asm-sparc/spinlock.h.orig      Wed Oct 31 00:08:11 2001
+++ linux-2.4.20/include/asm-sparc/spinlock.h   Sun Mar  9 13:41:06 2003
@@ -36,9 +36,9 @@
 extern int _spin_trylock(spinlock_t *lock);
 extern void _do_spin_unlock(spinlock_t *lock);
 
-#define spin_trylock(lp)       _spin_trylock(lp)
-#define spin_lock(lock)                _do_spin_lock(lock, "spin_lock")
-#define spin_unlock(lock)      _do_spin_unlock(lock)
+#define _raw_spin_trylock(lp)  _spin_trylock(lp)
+#define _raw_spin_lock(lock)           _do_spin_lock(lock, "_raw_spin_lock")
+#define _raw_spin_unlock(lock) _do_spin_unlock(lock)
 
 struct _rwlock_debug {
        volatile unsigned int lock;
@@ -56,28 +56,28 @@
 extern void _do_write_lock(rwlock_t *rw, char *str);
 extern void _do_write_unlock(rwlock_t *rw);
 
-#define read_lock(lock)        \
+#define _raw_read_lock(lock)   \
 do {   unsigned long flags; \
        __save_and_cli(flags); \
-       _do_read_lock(lock, "read_lock"); \
+       _do_read_lock(lock, "_raw_read_lock"); \
        __restore_flags(flags); \
 } while(0)
 
-#define read_unlock(lock) \
+#define _raw_read_unlock(lock) \
 do {   unsigned long flags; \
        __save_and_cli(flags); \
-       _do_read_unlock(lock, "read_unlock"); \
+       _do_read_unlock(lock, "_raw_read_unlock"); \
        __restore_flags(flags); \
 } while(0)
 
-#define write_lock(lock) \
+#define _raw_write_lock(lock) \
 do {   unsigned long flags; \
        __save_and_cli(flags); \
-       _do_write_lock(lock, "write_lock"); \
+       _do_write_lock(lock, "_raw_write_lock"); \
        __restore_flags(flags); \
 } while(0)
 
-#define write_unlock(lock) \
+#define _raw_write_unlock(lock) \
 do {   unsigned long flags; \
        __save_and_cli(flags); \
        _do_write_unlock(lock); \
@@ -97,7 +97,7 @@
        barrier(); \
 } while(*((volatile unsigned char *)lock))
 
-extern __inline__ void spin_lock(spinlock_t *lock)
+extern __inline__ void _raw_spin_lock(spinlock_t *lock)
 {
        __asm__ __volatile__(
        "\n1:\n\t"
@@ -117,7 +117,7 @@
        : "g2", "memory", "cc");
 }
 
-extern __inline__ int spin_trylock(spinlock_t *lock)
+extern __inline__ int _raw_spin_trylock(spinlock_t *lock)
 {
        unsigned int result;
        __asm__ __volatile__("ldstub [%1], %0"
@@ -127,7 +127,7 @@
        return (result == 0);
 }
 
-extern __inline__ void spin_unlock(spinlock_t *lock)
+extern __inline__ void _raw_spin_unlock(spinlock_t *lock)
 {
        __asm__ __volatile__("stb %%g0, [%0]" : : "r" (lock) : "memory");
 }
@@ -178,7 +178,7 @@
        : "g2", "g4", "memory", "cc");
 }
 
-#define read_lock(lock) \
+#define _raw_read_lock(lock) \
 do {   unsigned long flags; \
        __save_and_cli(flags); \
        _read_lock(lock); \
@@ -198,14 +198,14 @@
        : "g2", "g4", "memory", "cc");
 }
 
-#define read_unlock(lock) \
+#define _raw_read_unlock(lock) \
 do {   unsigned long flags; \
        __save_and_cli(flags); \
        _read_unlock(lock); \
        __restore_flags(flags); \
 } while(0)
 
-extern __inline__ void write_lock(rwlock_t *rw)
+extern __inline__ void _raw_write_lock(rwlock_t *rw)
 {
        register rwlock_t *lp asm("g1");
        lp = rw;
@@ -218,7 +218,7 @@
        : "g2", "g4", "memory", "cc");
 }
 
-#define write_unlock(rw)       do { (rw)->lock = 0; } while(0)
+#define _raw_write_unlock(rw)  do { (rw)->lock = 0; } while(0)
 
 #endif /* SPIN_LOCK_DEBUG */
 
diff -urN linux-2.4.20/include/asm-sparc/system.h linux-2.4.20-o1-preempt/include/asm-sparc/system.h
--- linux-2.4.20/include/asm-sparc/system.h     Wed Oct 31 00:08:11 2001
+++ linux-2.4.20-o1-preempt/include/asm-sparc/system.h  Tue Feb 18 03:51:30 2003
@@ -88,7 +88,7 @@
  *
  * SWITCH_ENTER and SWITH_DO_LAZY_FPU do not work yet (e.g. SMP does not work)
  */
-#define prepare_to_switch() do { \
+#define prepare_arch_switch(rq, next) do { \
        __asm__ __volatile__( \
        ".globl\tflush_patch_switch\nflush_patch_switch:\n\t" \
        "save %sp, -0x40, %sp; save %sp, -0x40, %sp; save %sp, -0x40, %sp\n\t" \
@@ -96,6 +96,8 @@
        "save %sp, -0x40, %sp\n\t" \
        "restore; restore; restore; restore; restore; restore; restore"); \
 } while(0)
+#define finish_arch_switch(rq, next)   do{ }while(0)
+#define task_running(rq, p)            ((rq)->curr == (p))
 
        /* Much care has gone into this code, do not touch it.
         *
diff -urN linux-2.4.20/include/asm-sparc64/bitops.h linux-2.4.20-o1-preempt/include/asm-sparc64/bitops.h
--- linux-2.4.20/include/asm-sparc64/bitops.h   Fri Dec 21 18:42:03 2001
+++ linux-2.4.20-o1-preempt/include/asm-sparc64/bitops.h        Tue Feb 18 03:51:30 2003
@@ -7,11 +7,12 @@
 #ifndef _SPARC64_BITOPS_H
 #define _SPARC64_BITOPS_H
 
+#include <linux/compiler.h>
 #include <asm/byteorder.h>
 
-extern long ___test_and_set_bit(unsigned long nr, volatile void *addr);
-extern long ___test_and_clear_bit(unsigned long nr, volatile void *addr);
-extern long ___test_and_change_bit(unsigned long nr, volatile void *addr);
+extern long ___test_and_set_bit(unsigned long nr, volatile unsigned long *addr);
+extern long ___test_and_clear_bit(unsigned long nr, volatile unsigned long *addr);
+extern long ___test_and_change_bit(unsigned long nr, volatile unsigned long *addr);
 
 #define test_and_set_bit(nr,addr)      ({___test_and_set_bit(nr,addr)!=0;})
 #define test_and_clear_bit(nr,addr)    ({___test_and_clear_bit(nr,addr)!=0;})
@@ -21,109 +22,132 @@
 #define change_bit(nr,addr)            ((void)___test_and_change_bit(nr,addr))
 
 /* "non-atomic" versions... */
-#define __set_bit(X,Y)                                 \
-do {   unsigned long __nr = (X);                       \
-       long *__m = ((long *) (Y)) + (__nr >> 6);       \
-       *__m |= (1UL << (__nr & 63));                   \
-} while (0)
-#define __clear_bit(X,Y)                               \
-do {   unsigned long __nr = (X);                       \
-       long *__m = ((long *) (Y)) + (__nr >> 6);       \
-       *__m &= ~(1UL << (__nr & 63));                  \
-} while (0)
-#define __change_bit(X,Y)                              \
-do {   unsigned long __nr = (X);                       \
-       long *__m = ((long *) (Y)) + (__nr >> 6);       \
-       *__m ^= (1UL << (__nr & 63));                   \
-} while (0)
-#define __test_and_set_bit(X,Y)                                \
-({     unsigned long __nr = (X);                       \
-       long *__m = ((long *) (Y)) + (__nr >> 6);       \
-       long __old = *__m;                              \
-       long __mask = (1UL << (__nr & 63));             \
-       *__m = (__old | __mask);                        \
-       ((__old & __mask) != 0);                        \
-})
-#define __test_and_clear_bit(X,Y)                      \
-({     unsigned long __nr = (X);                       \
-       long *__m = ((long *) (Y)) + (__nr >> 6);       \
-       long __old = *__m;                              \
-       long __mask = (1UL << (__nr & 63));             \
-       *__m = (__old & ~__mask);                       \
-       ((__old & __mask) != 0);                        \
-})
-#define __test_and_change_bit(X,Y)                     \
-({     unsigned long __nr = (X);                       \
-       long *__m = ((long *) (Y)) + (__nr >> 6);       \
-       long __old = *__m;                              \
-       long __mask = (1UL << (__nr & 63));             \
-       *__m = (__old ^ __mask);                        \
-       ((__old & __mask) != 0);                        \
-})
+
+static __inline__ void __set_bit(int nr, volatile unsigned long *addr)
+{
+       volatile unsigned long *m = addr + (nr >> 6);
+
+       *m |= (1UL << (nr & 63));
+}
+
+static __inline__ void __clear_bit(int nr, volatile unsigned long *addr)
+{
+       volatile unsigned long *m = addr + (nr >> 6);
+
+       *m &= ~(1UL << (nr & 63));
+}
+
+static __inline__ void __change_bit(int nr, volatile unsigned long *addr)
+{
+       volatile unsigned long *m = addr + (nr >> 6);
+
+       *m ^= (1UL << (nr & 63));
+}
+
+static __inline__ int __test_and_set_bit(int nr, volatile unsigned long *addr)
+{
+       volatile unsigned long *m = addr + (nr >> 6);
+       long old = *m;
+       long mask = (1UL << (nr & 63));
+
+       *m = (old | mask);
+       return ((old & mask) != 0);
+}
+
+static __inline__ int __test_and_clear_bit(int nr, volatile unsigned long *addr)
+{
+       volatile unsigned long *m = addr + (nr >> 6);
+       long old = *m;
+       long mask = (1UL << (nr & 63));
+
+       *m = (old & ~mask);
+       return ((old & mask) != 0);
+}
+
+static __inline__ int __test_and_change_bit(int nr, volatile unsigned long *addr)
+{
+       volatile unsigned long *m = addr + (nr >> 6);
+       long old = *m;
+       long mask = (1UL << (nr & 63));
+
+       *m = (old ^ mask);
+       return ((old & mask) != 0);
+}
 
 #define smp_mb__before_clear_bit()     do { } while(0)
 #define smp_mb__after_clear_bit()      do { } while(0)
 
-extern __inline__ int test_bit(int nr, __const__ void *addr)
+static __inline__ int test_bit(int nr, __const__ volatile unsigned long *addr)
 {
-       return (1UL & (((__const__ long *) addr)[nr >> 6] >> (nr & 63))) != 0UL;
+       return (1UL & ((addr)[nr >> 6] >> (nr & 63))) != 0UL;
 }
 
 /* The easy/cheese version for now. */
-extern __inline__ unsigned long ffz(unsigned long word)
+static __inline__ unsigned long ffz(unsigned long word)
 {
        unsigned long result;
 
-#ifdef ULTRA_HAS_POPULATION_COUNT      /* Thanks for nothing Sun... */
-       __asm__ __volatile__(
-"      brz,pn  %0, 1f\n"
-"       neg    %0, %%g1\n"
-"      xnor    %0, %%g1, %%g2\n"
-"      popc    %%g2, %0\n"
-"1:    " : "=&r" (result)
-         : "0" (word)
-         : "g1", "g2");
-#else
-#if 1 /* def EASY_CHEESE_VERSION */
        result = 0;
        while(word & 1) {
                result++;
                word >>= 1;
        }
-#else
-       unsigned long tmp;
+       return result;
+}
 
-       result = 0;     
-       tmp = ~word & -~word;
-       if (!(unsigned)tmp) {
-               tmp >>= 32;
-               result = 32;
-       }
-       if (!(unsigned short)tmp) {
-               tmp >>= 16;
-               result += 16;
-       }
-       if (!(unsigned char)tmp) {
-               tmp >>= 8;
-               result += 8;
+/**
+ * __ffs - find first bit in word.
+ * @word: The word to search
+ *
+ * Undefined if no bit exists, so code should check against 0 first.
+ */
+static __inline__ unsigned long __ffs(unsigned long word)
+{
+       unsigned long result = 0;
+
+       while (!(word & 1UL)) {
+               result++;
+               word >>= 1;
        }
-       if (tmp & 0xf0) result += 4;
-       if (tmp & 0xcc) result += 2;
-       if (tmp & 0xaa) result ++;
-#endif
-#endif
        return result;
 }
 
+/*
+ * fls: find last bit set.
+ */
+
+#define fls(x) generic_fls(x)
+
 #ifdef __KERNEL__
 
 /*
+ * Every architecture must define this function. It's the fastest
+ * way of searching a 140-bit bitmap where the first 100 bits are
+ * unlikely to be set. It's guaranteed that at least one of the 140
+ * bits is cleared.
+ */
+static inline int _sched_find_first_bit(unsigned long *b)
+{
+       if (unlikely(b[0]))
+               return __ffs(b[0]);
+       if (unlikely(((unsigned int)b[1])))
+               return __ffs(b[1]) + 64;
+       if (b[1] >> 32)
+               return __ffs(b[1] >> 32) + 96;
+       return __ffs(b[2]) + 128;
+}
+
+/*
  * ffs: find first bit set. This is defined the same way as
  * the libc and compiler builtin ffs routines, therefore
  * differs in spirit from the above ffz (man ffs).
  */
-
-#define ffs(x) generic_ffs(x)
+static __inline__ int ffs(int x)
+{
+       if (!x)
+               return 0;
+       return __ffs((unsigned long)x);
+}
 
 /*
  * hweightN: returns the hamming weight (i.e. the number
@@ -132,7 +156,7 @@
 
 #ifdef ULTRA_HAS_POPULATION_COUNT
 
-extern __inline__ unsigned int hweight32(unsigned int w)
+static __inline__ unsigned int hweight32(unsigned int w)
 {
        unsigned int res;
 
@@ -140,7 +164,7 @@
        return res;
 }
 
-extern __inline__ unsigned int hweight16(unsigned int w)
+static __inline__ unsigned int hweight16(unsigned int w)
 {
        unsigned int res;
 
@@ -148,7 +172,7 @@
        return res;
 }
 
-extern __inline__ unsigned int hweight8(unsigned int w)
+static __inline__ unsigned int hweight8(unsigned int w)
 {
        unsigned int res;
 
@@ -165,14 +189,69 @@
 #endif
 #endif /* __KERNEL__ */
 
+/**
+ * find_next_bit - find the next set bit in a memory region
+ * @addr: The address to base the search on
+ * @offset: The bitnumber to start searching at
+ * @size: The maximum size to search
+ */
+static __inline__ unsigned long find_next_bit(unsigned long *addr, unsigned long size, unsigned long offset)
+{
+       unsigned long *p = addr + (offset >> 6);
+       unsigned long result = offset & ~63UL;
+       unsigned long tmp;
+
+       if (offset >= size)
+               return size;
+       size -= result;
+       offset &= 63UL;
+       if (offset) {
+               tmp = *(p++);
+               tmp &= (~0UL << offset);
+               if (size < 64)
+                       goto found_first;
+               if (tmp)
+                       goto found_middle;
+               size -= 64;
+               result += 64;
+       }
+       while (size & ~63UL) {
+               if ((tmp = *(p++)))
+                       goto found_middle;
+               result += 64;
+               size -= 64;
+       }
+       if (!size)
+               return result;
+       tmp = *p;
+
+found_first:
+       tmp &= (~0UL >> (64 - size));
+       if (tmp == 0UL)        /* Are any bits set? */
+               return result + size; /* Nope. */
+found_middle:
+       return result + __ffs(tmp);
+}
+
+/**
+ * find_first_bit - find the first set bit in a memory region
+ * @addr: The address to start the search at
+ * @size: The maximum size to search
+ *
+ * Returns the bit-number of the first set bit, not the number of the byte
+ * containing a bit.
+ */
+#define find_first_bit(addr, size) \
+       find_next_bit((addr), (size), 0)
+
 /* find_next_zero_bit() finds the first zero bit in a bit string of length
  * 'size' bits, starting the search at bit 'offset'. This is largely based
  * on Linus's ALPHA routines, which are pretty portable BTW.
  */
 
-extern __inline__ unsigned long find_next_zero_bit(void *addr, unsigned long size, unsigned long offset)
+static __inline__ unsigned long find_next_zero_bit(unsigned long *addr, unsigned long size, unsigned long offset)
 {
-       unsigned long *p = ((unsigned long *) addr) + (offset >> 6);
+       unsigned long *p = addr + (offset >> 6);
        unsigned long result = offset & ~63UL;
        unsigned long tmp;
 
@@ -211,15 +290,15 @@
 #define find_first_zero_bit(addr, size) \
         find_next_zero_bit((addr), (size), 0)
 
-extern long ___test_and_set_le_bit(int nr, volatile void *addr);
-extern long ___test_and_clear_le_bit(int nr, volatile void *addr);
+extern long ___test_and_set_le_bit(int nr, volatile unsigned long *addr);
+extern long ___test_and_clear_le_bit(int nr, volatile unsigned long *addr);
 
 #define test_and_set_le_bit(nr,addr)   ({___test_and_set_le_bit(nr,addr)!=0;})
 #define test_and_clear_le_bit(nr,addr) ({___test_and_clear_le_bit(nr,addr)!=0;})
 #define set_le_bit(nr,addr)            ((void)___test_and_set_le_bit(nr,addr))
 #define clear_le_bit(nr,addr)          ((void)___test_and_clear_le_bit(nr,addr))
 
-extern __inline__ int test_le_bit(int nr, __const__ void * addr)
+static __inline__ int test_le_bit(int nr, __const__ unsigned long * addr)
 {
        int                     mask;
        __const__ unsigned char *ADDR = (__const__ unsigned char *) addr;
@@ -232,9 +311,9 @@
 #define find_first_zero_le_bit(addr, size) \
         find_next_zero_le_bit((addr), (size), 0)
 
-extern __inline__ unsigned long find_next_zero_le_bit(void *addr, unsigned long size, unsigned long offset)
+static __inline__ unsigned long find_next_zero_le_bit(unsigned long *addr, unsigned long size, unsigned long offset)
 {
-       unsigned long *p = ((unsigned long *) addr) + (offset >> 6);
+       unsigned long *p = addr + (offset >> 6);
        unsigned long result = offset & ~63UL;
        unsigned long tmp;
 
@@ -271,18 +350,22 @@
 
 #ifdef __KERNEL__
 
-#define ext2_set_bit                   test_and_set_le_bit
-#define ext2_clear_bit                 test_and_clear_le_bit
-#define ext2_test_bit                          test_le_bit
-#define ext2_find_first_zero_bit       find_first_zero_le_bit
-#define ext2_find_next_zero_bit                find_next_zero_le_bit
+#define ext2_set_bit(nr,addr)          test_and_set_le_bit((nr),(unsigned long *)(addr))
+#define ext2_clear_bit(nr,addr)                test_and_clear_le_bit((nr),(unsigned long *)(addr))
+#define ext2_test_bit(nr,addr)         test_le_bit((nr),(unsigned long *)(addr))
+#define ext2_find_first_zero_bit(addr, size) \
+       find_first_zero_le_bit((unsigned long *)(addr), (size))
+#define ext2_find_next_zero_bit(addr, size, off) \
+       find_next_zero_le_bit((unsigned long *)(addr), (size), (off))
 
 /* Bitmap functions for the minix filesystem.  */
-#define minix_test_and_set_bit(nr,addr) test_and_set_bit(nr,addr)
-#define minix_set_bit(nr,addr) set_bit(nr,addr)
-#define minix_test_and_clear_bit(nr,addr) test_and_clear_bit(nr,addr)
-#define minix_test_bit(nr,addr) test_bit(nr,addr)
-#define minix_find_first_zero_bit(addr,size) find_first_zero_bit(addr,size)
+#define minix_test_and_set_bit(nr,addr)        test_and_set_bit((nr),(unsigned long *)(addr))
+#define minix_set_bit(nr,addr)         set_bit((nr),(unsigned long *)(addr))
+#define minix_test_and_clear_bit(nr,addr) \
+       test_and_clear_bit((nr),(unsigned long *)(addr))
+#define minix_test_bit(nr,addr)                test_bit((nr),(unsigned long *)(addr))
+#define minix_find_first_zero_bit(addr,size) \
+       find_first_zero_bit((unsigned long *)(addr),(size))
 
 #endif /* __KERNEL__ */
 
diff -urN linux-2.4.20/include/asm-sparc64/smp.h linux-2.4.20-o1-preempt/include/asm-sparc64/smp.h
--- linux-2.4.20/include/asm-sparc64/smp.h      Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/asm-sparc64/smp.h   Tue Feb 18 03:51:30 2003
@@ -103,7 +103,7 @@
        }
 }
 
-#define smp_processor_id() (current->processor)
+#define smp_processor_id() (current->cpu)
 
 /* This needn't do anything as we do not sleep the cpu
  * inside of the idler task, so an interrupt is not needed
--- linux-2.4.20/include/asm-sparc64/spinlock.h~        Fri Dec 21 18:42:03 2001
+++ linux-2.4.20/include/asm-sparc64/spinlock.h Sun Mar  9 13:43:48 2003
@@ -40,7 +40,7 @@
 do {   membar("#LoadLoad");    \
 } while(*((volatile unsigned char *)lock))
 
-extern __inline__ void spin_lock(spinlock_t *lock)
+extern __inline__ void _raw_spin_lock(spinlock_t *lock)
 {
        __asm__ __volatile__(
 "1:    ldstub          [%0], %%g7\n"
@@ -57,7 +57,7 @@
        : "g7", "memory");
 }
 
-extern __inline__ int spin_trylock(spinlock_t *lock)
+extern __inline__ int _raw_spin_trylock(spinlock_t *lock)
 {
        unsigned int result;
        __asm__ __volatile__("ldstub [%1], %0\n\t"
@@ -68,7 +68,7 @@
        return (result == 0);
 }
 
-extern __inline__ void spin_unlock(spinlock_t *lock)
+extern __inline__ void _raw_spin_unlock(spinlock_t *lock)
 {
        __asm__ __volatile__("membar    #StoreStore | #LoadStore\n\t"
                             "stb       %%g0, [%0]"
@@ -99,9 +99,9 @@
 extern void _do_spin_unlock (spinlock_t *lock);
 extern int _spin_trylock (spinlock_t *lock);
 
-#define spin_trylock(lp)       _spin_trylock(lp)
-#define spin_lock(lock)                _do_spin_lock(lock, "spin_lock")
-#define spin_unlock(lock)      _do_spin_unlock(lock)
+#define _raw_spin_trylock(lp)  _spin_trylock(lp)
+#define _raw_spin_lock(lock)           _do_spin_lock(lock, "_raw_spin_lock")
+#define _raw_spin_unlock(lock) _do_spin_unlock(lock)
 
 #endif /* CONFIG_DEBUG_SPINLOCK */
 
@@ -118,10 +118,10 @@
 extern void __write_lock(rwlock_t *);
 extern void __write_unlock(rwlock_t *);
 
-#define read_lock(p)   __read_lock(p)
-#define read_unlock(p) __read_unlock(p)
-#define write_lock(p)  __write_lock(p)
-#define write_unlock(p)        __write_unlock(p)
+#define _raw_read_lock(p)      __read_lock(p)
+#define _raw_read_unlock(p)    __read_unlock(p)
+#define _raw_write_lock(p)     __write_lock(p)
+#define _raw_write_unlock(p)   __write_unlock(p)
 
 #else /* !(CONFIG_DEBUG_SPINLOCK) */
 
@@ -138,28 +138,28 @@
 extern void _do_write_lock(rwlock_t *rw, char *str);
 extern void _do_write_unlock(rwlock_t *rw);
 
-#define read_lock(lock)        \
+#define _raw_read_lock(lock)   \
 do {   unsigned long flags; \
        __save_and_cli(flags); \
-       _do_read_lock(lock, "read_lock"); \
+       _do_read_lock(lock, "_raw_read_lock"); \
        __restore_flags(flags); \
 } while(0)
 
-#define read_unlock(lock) \
+#define _raw_read_unlock(lock) \
 do {   unsigned long flags; \
        __save_and_cli(flags); \
-       _do_read_unlock(lock, "read_unlock"); \
+       _do_read_unlock(lock, "_raw_read_unlock"); \
        __restore_flags(flags); \
 } while(0)
 
-#define write_lock(lock) \
+#define _raw_write_lock(lock) \
 do {   unsigned long flags; \
        __save_and_cli(flags); \
-       _do_write_lock(lock, "write_lock"); \
+       _do_write_lock(lock, "_raw_write_lock"); \
        __restore_flags(flags); \
 } while(0)
 
-#define write_unlock(lock) \
+#define _raw_write_unlock(lock) \
 do {   unsigned long flags; \
        __save_and_cli(flags); \
        _do_write_unlock(lock); \
diff -urN linux-2.4.20/include/asm-sparc64/system.h linux-2.4.20-o1-preempt/include/asm-sparc64/system.h
--- linux-2.4.20/include/asm-sparc64/system.h   Sat Aug  3 02:39:45 2002
+++ linux-2.4.20-o1-preempt/include/asm-sparc64/system.h        Tue Feb 18 03:51:30 2003
@@ -143,7 +143,18 @@
 
 #define flush_user_windows flushw_user
 #define flush_register_windows flushw_all
-#define prepare_to_switch flushw_all
+
+#define prepare_arch_schedule(prev)            task_lock(prev)
+#define finish_arch_schedule(prev)             task_unlock(prev)
+#define prepare_arch_switch(rq, next)           \
+do {    spin_lock(&(next)->switch_lock);        \
+        spin_unlock(&(rq)->lock);               \
+        flushw_all();                           \
+} while (0)
+
+#define finish_arch_switch(rq, prev)            \
+do {    spin_unlock_irq(&(prev)->switch_lock);  \
+} while (0)
 
 #ifndef CONFIG_DEBUG_SPINLOCK
 #define CHECK_LOCKS(PREV)      do { } while(0)
diff -urN linux-2.4.20/include/linux/brlock.h linux-2.4.20-o1-preempt/include/linux/brlock.h
--- linux-2.4.20/include/linux/brlock.h Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/linux/brlock.h      Tue Feb 18 03:52:06 2003
@@ -171,11 +171,11 @@
 }
 
 #else
-# define br_read_lock(idx)     ((void)(idx))
-# define br_read_unlock(idx)   ((void)(idx))
-# define br_write_lock(idx)    ((void)(idx))
-# define br_write_unlock(idx)  ((void)(idx))
-#endif
+# define br_read_lock(idx)     ({ (void)(idx); preempt_disable(); })
+# define br_read_unlock(idx)   ({ (void)(idx); preempt_enable(); })
+# define br_write_lock(idx)    ({ (void)(idx); preempt_disable(); })
+# define br_write_unlock(idx)  ({ (void)(idx); preempt_enable(); })
+#endif /* CONFIG_SMP */
 
 /*
  * Now enumerate all of the possible sw/hw IRQ protected
diff -urN linux-2.4.20/include/linux/capability.h linux-2.4.20-o1-preempt/include/linux/capability.h
--- linux-2.4.20/include/linux/capability.h     Thu Nov 22 20:46:19 2001
+++ linux-2.4.20-o1-preempt/include/linux/capability.h  Tue Feb 18 03:51:30 2003
@@ -243,6 +243,7 @@
 /* Allow use of FIFO and round-robin (realtime) scheduling on own
    processes and setting the scheduling algorithm used by another
    process. */
+/* Allow setting cpu affinity on other processes */
 
 #define CAP_SYS_NICE         23
 
diff -urN linux-2.4.20/include/linux/dcache.h linux-2.4.20-o1-preempt/include/linux/dcache.h
--- linux-2.4.20/include/linux/dcache.h Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/linux/dcache.h      Tue Feb 18 03:52:06 2003
@@ -127,31 +127,6 @@
 
 extern spinlock_t dcache_lock;
 
-/**
- * d_drop - drop a dentry
- * @dentry: dentry to drop
- *
- * d_drop() unhashes the entry from the parent
- * dentry hashes, so that it won't be found through
- * a VFS lookup any more. Note that this is different
- * from deleting the dentry - d_delete will try to
- * mark the dentry negative if possible, giving a
- * successful _negative_ lookup, while d_drop will
- * just make the cache lookup fail.
- *
- * d_drop() is used mainly for stuff that wants
- * to invalidate a dentry for some reason (NFS
- * timeouts or autofs deletes).
- */
-
-static __inline__ void d_drop(struct dentry * dentry)
-{
-       spin_lock(&dcache_lock);
-       list_del(&dentry->d_hash);
-       INIT_LIST_HEAD(&dentry->d_hash);
-       spin_unlock(&dcache_lock);
-}
-
 static __inline__ int dname_external(struct dentry *d)
 {
        return d->d_name.name != d->d_iname; 
@@ -276,3 +251,34 @@
 #endif /* __KERNEL__ */
 
 #endif /* __LINUX_DCACHE_H */
+
+#if !defined(__LINUX_DCACHE_H_INLINES) && defined(_TASK_STRUCT_DEFINED)
+#define __LINUX_DCACHE_H_INLINES
+
+#ifdef __KERNEL__
+/**
+ * d_drop - drop a dentry
+ * @dentry: dentry to drop
+ *
+ * d_drop() unhashes the entry from the parent
+ * dentry hashes, so that it won't be found through
+ * a VFS lookup any more. Note that this is different
+ * from deleting the dentry - d_delete will try to
+ * mark the dentry negative if possible, giving a
+ * successful _negative_ lookup, while d_drop will
+ * just make the cache lookup fail.
+ *
+ * d_drop() is used mainly for stuff that wants
+ * to invalidate a dentry for some reason (NFS
+ * timeouts or autofs deletes).
+ */
+
+static __inline__ void d_drop(struct dentry * dentry)
+{
+       spin_lock(&dcache_lock);
+       list_del(&dentry->d_hash);
+       INIT_LIST_HEAD(&dentry->d_hash);
+       spin_unlock(&dcache_lock);
+}
+#endif
+#endif
diff -urN linux-2.4.20/include/linux/fs_struct.h linux-2.4.20-o1-preempt/include/linux/fs_struct.h
--- linux-2.4.20/include/linux/fs_struct.h      Sat Jul 14 00:10:44 2001
+++ linux-2.4.20-o1-preempt/include/linux/fs_struct.h   Tue Feb 18 03:52:06 2003
@@ -20,6 +20,15 @@
 extern void exit_fs(struct task_struct *);
 extern void set_fs_altroot(void);
 
+struct fs_struct *copy_fs_struct(struct fs_struct *old);
+void put_fs_struct(struct fs_struct *fs);
+
+#endif
+#endif
+
+#if !defined(_LINUX_FS_STRUCT_H_INLINES) && defined(_TASK_STRUCT_DEFINED)
+#define _LINUX_FS_STRUCT_H_INLINES
+#ifdef __KERNEL__
 /*
  * Replace the fs->{rootmnt,root} with {mnt,dentry}. Put the old values.
  * It can block. Requires the big lock held.
@@ -65,9 +74,5 @@
                mntput(old_pwdmnt);
        }
 }
-
-struct fs_struct *copy_fs_struct(struct fs_struct *old);
-void put_fs_struct(struct fs_struct *fs);
-
 #endif
 #endif
diff -urN linux-2.4.20/include/linux/kernel_stat.h linux-2.4.20-o1-preempt/include/linux/kernel_stat.h
--- linux-2.4.20/include/linux/kernel_stat.h    Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/linux/kernel_stat.h Tue Feb 18 03:51:30 2003
@@ -31,7 +31,6 @@
 #elif !defined(CONFIG_ARCH_S390)
        unsigned int irqs[NR_CPUS][NR_IRQS];
 #endif
-       unsigned int context_swtch;
 };
 
 extern struct kernel_stat kstat;
diff -urN linux-2.4.20/include/linux/sched.h linux-2.4.20-o1-preempt/include/linux/sched.h
--- linux-2.4.20/include/linux/sched.h  Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/linux/sched.h       Tue Feb 18 03:52:06 2003
@@ -6,6 +6,7 @@
 extern unsigned long event;
 
 #include <linux/config.h>
+#include <linux/compiler.h>
 #include <linux/binfmts.h>
 #include <linux/threads.h>
 #include <linux/kernel.h>
@@ -21,7 +22,7 @@
 #include <asm/mmu.h>
 
 #include <linux/smp.h>
-#include <linux/tty.h>
+//#include <linux/tty.h>
 #include <linux/sem.h>
 #include <linux/signal.h>
 #include <linux/securebits.h>
@@ -73,10 +74,12 @@
 #define CT_TO_SECS(x)  ((x) / HZ)
 #define CT_TO_USECS(x) (((x) % HZ) * 1000000/HZ)
 
-extern int nr_running, nr_threads;
+extern int nr_threads;
 extern int last_pid;
+extern unsigned long nr_running(void);
+extern unsigned long nr_uninterruptible(void);
 
-#include <linux/fs.h>
+//#include <linux/fs.h>
 #include <linux/time.h>
 #include <linux/param.h>
 #include <linux/resource.h>
@@ -91,6 +94,7 @@
 #define TASK_UNINTERRUPTIBLE   2
 #define TASK_ZOMBIE            4
 #define TASK_STOPPED           8
+#define PREEMPT_ACTIVE         0x4000000
 
 #define __set_task_state(tsk, state_value)             \
        do { (tsk)->state = (state_value); } while (0)
@@ -119,12 +123,6 @@
 #define SCHED_FIFO             1
 #define SCHED_RR               2
 
-/*
- * This is an additional bit set when we want to
- * yield the CPU for one re-schedule..
- */
-#define SCHED_YIELD            0x10
-
 struct sched_param {
        int sched_priority;
 };
@@ -142,21 +140,28 @@
  * a separate lock).
  */
 extern rwlock_t tasklist_lock;
-extern spinlock_t runqueue_lock;
 extern spinlock_t mmlist_lock;
 
+typedef struct task_struct task_t;
+
 extern void sched_init(void);
-extern void init_idle(void);
+extern void init_idle(task_t *idle, int cpu);
 extern void show_state(void);
 extern void cpu_init (void);
 extern void trap_init(void);
 extern void update_process_times(int user);
-extern void update_one_process(struct task_struct *p, unsigned long user,
+extern void update_one_process(task_t *p, unsigned long user,
                               unsigned long system, int cpu);
+extern void scheduler_tick(int user_tick, int system);
+extern void migration_init(void);
+extern unsigned long cache_decay_ticks;
 
 #define        MAX_SCHEDULE_TIMEOUT    LONG_MAX
 extern signed long FASTCALL(schedule_timeout(signed long timeout));
 asmlinkage void schedule(void);
+#ifdef CONFIG_PREEMPT
+asmlinkage void preempt_schedule(void);
+#endif
 
 extern int schedule_task(struct tq_struct *task);
 extern void flush_scheduled_tasks(void);
@@ -164,6 +169,51 @@
 extern int current_is_keventd(void);
 
 /*
+ * Priority of a process goes from 0..MAX_PRIO-1, valid RT
+ * priority is 0..MAX_RT_PRIO-1, and SCHED_OTHER tasks are
+ * in the range MAX_RT_PRIO..MAX_PRIO-1. Priority values
+ * are inverted: lower p->prio value means higher priority.
+ *
+ * The MAX_RT_USER_PRIO value allows the actual maximum
+ * RT priority to be separate from the value exported to
+ * user-space.  This allows kernel threads to set their
+ * priority to a value higher than any user task. Note:
+ * MAX_RT_PRIO must not be smaller than MAX_USER_RT_PRIO.
+ *
+ * Both values are configurable at compile-time.
+ */
+
+#if CONFIG_MAX_USER_RT_PRIO < 100
+#define MAX_USER_RT_PRIO       100
+#elif CONFIG_MAX_USER_RT_PRIO > 1000
+#define MAX_USER_RT_PRIO       1000
+#else
+#define MAX_USER_RT_PRIO       CONFIG_MAX_USER_RT_PRIO
+#endif
+
+#if CONFIG_MAX_RT_PRIO < 0
+#define MAX_RT_PRIO            MAX_USER_RT_PRIO
+#elif CONFIG_MAX_RT_PRIO > 200
+#define MAX_RT_PRIO            (MAX_USER_RT_PRIO + 200)
+#else
+#define MAX_RT_PRIO            (MAX_USER_RT_PRIO + CONFIG_MAX_RT_PRIO)
+#endif
+
+#define MAX_PRIO               (MAX_RT_PRIO + 40)
+
+/*
+ * The maximum RT priority is configurable.  If the resulting
+ * bitmap is 160-bits , we can use a hand-coded routine which
+ * is optimal.  Otherwise, we fall back on a generic routine for
+ * finding the first set bit from an arbitrarily-sized bitmap.
+ */
+#if MAX_PRIO < 160 && MAX_PRIO > 127
+#define sched_find_first_bit(map)      _sched_find_first_bit(map)
+#else
+#define sched_find_first_bit(map)      find_first_bit(map, MAX_PRIO)
+#endif
+
+/*
  * The default fd array needs to be at least BITS_PER_LONG,
  * as this is the granularity returned by copy_fdset().
  */
@@ -284,12 +334,14 @@
 extern struct user_struct root_user;
 #define INIT_USER (&root_user)
 
+typedef struct prio_array prio_array_t;
+
 struct task_struct {
        /*
         * offsets of these are hardcoded elsewhere - touch with care
         */
        volatile long state;    /* -1 unrunnable, 0 runnable, >0 stopped */
-       unsigned long flags;    /* per process flags, defined below */
+       int preempt_count;      /* 0 => preemptable, <0 => BUG */
        int sigpending;
        mm_segment_t addr_limit;        /* thread address space:
                                                0-0xBFFFFFFF for user-thead
@@ -301,36 +353,28 @@
 
        int lock_depth;         /* Lock depth */
 
-/*
- * offset 32 begins here on 32-bit platforms. We keep
- * all fields in a single cacheline that are needed for
- * the goodness() loop in schedule().
- */
-       long counter;
-       long nice;
-       unsigned long policy;
-       struct mm_struct *mm;
-       int processor;
-       /*
-        * cpus_runnable is ~0 if the process is not running on any
-        * CPU. It's (1 << cpu) if it's running on a CPU. This mask
-        * is updated under the runqueue lock.
-        *
-        * To determine whether a process might run on a CPU, this
-        * mask is AND-ed with cpus_allowed.
-        */
-       unsigned long cpus_runnable, cpus_allowed;
        /*
-        * (only the 'next' pointer fits into the cacheline, but
-        * that's just fine.)
+        * offset 32 begins here on 32-bit platforms.
         */
-       struct list_head run_list;
-       unsigned long sleep_time;
+       unsigned int cpu;
+       int prio, static_prio;
+       list_t run_list;
+       prio_array_t *array;
+
+       unsigned long sleep_avg;
+       unsigned long sleep_timestamp;
+
+       unsigned long policy;
+       unsigned long cpus_allowed;
+       unsigned int time_slice, first_time_slice;
+
+       task_t *next_task, *prev_task;
 
-       struct task_struct *next_task, *prev_task;
-       struct mm_struct *active_mm;
+       struct mm_struct *mm, *active_mm;
        struct list_head local_pages;
+
        unsigned int allocation_order, nr_local_pages;
+       unsigned long flags;
 
 /* task state */
        struct linux_binfmt *binfmt;
@@ -351,12 +395,12 @@
         * older sibling, respectively.  (p->father can be replaced with 
         * p->p_pptr->pid)
         */
-       struct task_struct *p_opptr, *p_pptr, *p_cptr, *p_ysptr, *p_osptr;
+       task_t *p_opptr, *p_pptr, *p_cptr, *p_ysptr, *p_osptr;
        struct list_head thread_group;
 
        /* PID hash table linkage. */
-       struct task_struct *pidhash_next;
-       struct task_struct **pidhash_pprev;
+       task_t *pidhash_next;
+       task_t **pidhash_pprev;
 
        wait_queue_head_t wait_chldexit;        /* for wait4() */
        struct completion *vfork_done;          /* for vfork() */
@@ -415,6 +459,8 @@
        u32 self_exec_id;
 /* Protection of (de-)allocation: mm, files, fs, tty */
        spinlock_t alloc_lock;
+/* context-switch lock */
+        spinlock_t switch_lock;
 
 /* journalling filesystem info */
        void *journal_info;
@@ -454,9 +500,15 @@
  */
 #define _STK_LIM       (8*1024*1024)
 
-#define DEF_COUNTER    (10*HZ/100)     /* 100 ms time slice */
-#define MAX_COUNTER    (20*HZ/100)
-#define DEF_NICE       (0)
+#if CONFIG_SMP
+extern void set_cpus_allowed(task_t *p, unsigned long new_mask);
+#else
+#define set_cpus_allowed(p, new_mask)  do { } while (0)
+#endif
+
+extern void set_user_nice(task_t *p, long nice);
+extern int task_prio(task_t *p);
+extern int task_nice(task_t *p);
 
 extern void yield(void);
 
@@ -477,14 +529,14 @@
     addr_limit:                KERNEL_DS,                                      \
     exec_domain:       &default_exec_domain,                           \
     lock_depth:                -1,                                             \
-    counter:           DEF_COUNTER,                                    \
-    nice:              DEF_NICE,                                       \
+    prio:              MAX_PRIO-20,                                    \
+    static_prio:       MAX_PRIO-20,                                    \
     policy:            SCHED_OTHER,                                    \
+    cpus_allowed:      -1,                                             \
     mm:                        NULL,                                           \
     active_mm:         &init_mm,                                       \
-    cpus_runnable:     -1,                                             \
-    cpus_allowed:      -1,                                             \
     run_list:          LIST_HEAD_INIT(tsk.run_list),                   \
+    time_slice:                HZ,                                             \
     next_task:         &tsk,                                           \
     prev_task:         &tsk,                                           \
     p_opptr:           &tsk,                                           \
@@ -509,6 +561,7 @@
     pending:           { NULL, &tsk.pending.head, {{0}}},              \
     blocked:           {{0}},                                          \
     alloc_lock:                SPIN_LOCK_UNLOCKED,                             \
+    switch_lock:        SPIN_LOCK_UNLOCKED,                             \
     journal_info:      NULL,                                           \
 }
 
@@ -518,24 +571,23 @@
 #endif
 
 union task_union {
-       struct task_struct task;
+       task_t task;
        unsigned long stack[INIT_TASK_SIZE/sizeof(long)];
 };
 
 extern union task_union init_task_union;
 
 extern struct   mm_struct init_mm;
-extern struct task_struct *init_tasks[NR_CPUS];
 
 /* PID hashing. (shouldnt this be dynamic?) */
 #define PIDHASH_SZ (4096 >> 2)
-extern struct task_struct *pidhash[PIDHASH_SZ];
+extern task_t *pidhash[PIDHASH_SZ];
 
 #define pid_hashfn(x)  ((((x) >> 8) ^ (x)) & (PIDHASH_SZ - 1))
 
-static inline void hash_pid(struct task_struct *p)
+static inline void hash_pid(task_t *p)
 {
-       struct task_struct **htable = &pidhash[pid_hashfn(p->pid)];
+       task_t **htable = &pidhash[pid_hashfn(p->pid)];
 
        if((p->pidhash_next = *htable) != NULL)
                (*htable)->pidhash_pprev = &p->pidhash_next;
@@ -543,16 +595,16 @@
        p->pidhash_pprev = htable;
 }
 
-static inline void unhash_pid(struct task_struct *p)
+static inline void unhash_pid(task_t *p)
 {
        if(p->pidhash_next)
                p->pidhash_next->pidhash_pprev = p->pidhash_pprev;
        *p->pidhash_pprev = p->pidhash_next;
 }
 
-static inline struct task_struct *find_task_by_pid(int pid)
+static inline task_t *find_task_by_pid(int pid)
 {
-       struct task_struct *p, **htable = &pidhash[pid_hashfn(pid)];
+       task_t *p, **htable = &pidhash[pid_hashfn(pid)];
 
        for(p = *htable; p && p->pid != pid; p = p->pidhash_next)
                ;
@@ -560,19 +612,6 @@
        return p;
 }
 
-#define task_has_cpu(tsk) ((tsk)->cpus_runnable != ~0UL)
-
-static inline void task_set_cpu(struct task_struct *tsk, unsigned int cpu)
-{
-       tsk->processor = cpu;
-       tsk->cpus_runnable = 1UL << cpu;
-}
-
-static inline void task_release_cpu(struct task_struct *tsk)
-{
-       tsk->cpus_runnable = ~0UL;
-}
-
 /* per-UID process charging. */
 extern struct user_struct * alloc_uid(uid_t);
 extern void free_uid(struct user_struct *);
@@ -599,47 +638,50 @@
 extern void FASTCALL(interruptible_sleep_on(wait_queue_head_t *q));
 extern long FASTCALL(interruptible_sleep_on_timeout(wait_queue_head_t *q,
                                                    signed long timeout));
-extern int FASTCALL(wake_up_process(struct task_struct * tsk));
+extern int FASTCALL(wake_up_process(task_t * p));
+extern void FASTCALL(wake_up_forked_process(task_t * p));
 
 #define wake_up(x)                     __wake_up((x),TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 1)
 #define wake_up_nr(x, nr)              __wake_up((x),TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, nr)
 #define wake_up_all(x)                 __wake_up((x),TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 0)
-#define wake_up_sync(x)                        __wake_up_sync((x),TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 1)
-#define wake_up_sync_nr(x, nr)         __wake_up_sync((x),TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, nr)
 #define wake_up_interruptible(x)       __wake_up((x),TASK_INTERRUPTIBLE, 1)
 #define wake_up_interruptible_nr(x, nr)        __wake_up((x),TASK_INTERRUPTIBLE, nr)
 #define wake_up_interruptible_all(x)   __wake_up((x),TASK_INTERRUPTIBLE, 0)
-#define wake_up_interruptible_sync(x)  __wake_up_sync((x),TASK_INTERRUPTIBLE, 1)
-#define wake_up_interruptible_sync_nr(x, nr) __wake_up_sync((x),TASK_INTERRUPTIBLE,  nr)
+#ifdef CONFIG_SMP
+#define wake_up_interruptible_sync(x)   __wake_up_sync((x),TASK_INTERRUPTIBLE, 1)
+#else
+#define wake_up_interruptible_sync(x)   __wake_up((x),TASK_INTERRUPTIBLE, 1)
+#endif
+
 asmlinkage long sys_wait4(pid_t pid,unsigned int * stat_addr, int options, struct rusage * ru);
 
 extern int in_group_p(gid_t);
 extern int in_egroup_p(gid_t);
 
 extern void proc_caches_init(void);
-extern void flush_signals(struct task_struct *);
-extern void flush_signal_handlers(struct task_struct *);
+extern void flush_signals(task_t *);
+extern void flush_signal_handlers(task_t *);
 extern void sig_exit(int, int, struct siginfo *);
 extern int dequeue_signal(sigset_t *, siginfo_t *);
 extern void block_all_signals(int (*notifier)(void *priv), void *priv,
                              sigset_t *mask);
 extern void unblock_all_signals(void);
-extern int send_sig_info(int, struct siginfo *, struct task_struct *);
-extern int force_sig_info(int, struct siginfo *, struct task_struct *);
+extern int send_sig_info(int, struct siginfo *, task_t *);
+extern int force_sig_info(int, struct siginfo *, task_t *);
 extern int kill_pg_info(int, struct siginfo *, pid_t);
 extern int kill_sl_info(int, struct siginfo *, pid_t);
 extern int kill_proc_info(int, struct siginfo *, pid_t);
-extern void notify_parent(struct task_struct *, int);
-extern void do_notify_parent(struct task_struct *, int);
-extern void force_sig(int, struct task_struct *);
-extern int send_sig(int, struct task_struct *, int);
+extern void notify_parent(task_t *, int);
+extern void do_notify_parent(task_t *, int);
+extern void force_sig(int, task_t *);
+extern int send_sig(int, task_t *, int);
 extern int kill_pg(pid_t, int, int);
 extern int kill_sl(pid_t, int, int);
 extern int kill_proc(pid_t, int, int);
 extern int do_sigaction(int, const struct k_sigaction *, struct k_sigaction *);
 extern int do_sigaltstack(const stack_t *, stack_t *, unsigned long);
 
-static inline int signal_pending(struct task_struct *p)
+static inline int signal_pending(task_t *p)
 {
        return (p->sigpending != 0);
 }
@@ -678,7 +720,7 @@
    This is required every time the blocked sigset_t changes.
    All callers should have t->sigmask_lock.  */
 
-static inline void recalc_sigpending(struct task_struct *t)
+static inline void recalc_sigpending(task_t *t)
 {
        t->sigpending = has_pending_signals(&t->pending.signal, &t->blocked);
 }
@@ -785,16 +827,17 @@
 extern int expand_fdset(struct files_struct *, int nr);
 extern void free_fdset(fd_set *, int);
 
-extern int  copy_thread(int, unsigned long, unsigned long, unsigned long, struct task_struct *, struct pt_regs *);
+extern int  copy_thread(int, unsigned long, unsigned long, unsigned long, task_t *, struct pt_regs *);
 extern void flush_thread(void);
 extern void exit_thread(void);
 
-extern void exit_mm(struct task_struct *);
-extern void exit_files(struct task_struct *);
-extern void exit_sighand(struct task_struct *);
+extern void exit_mm(task_t *);
+extern void exit_files(task_t *);
+extern void exit_sighand(task_t *);
 
 extern void reparent_to_init(void);
 extern void daemonize(void);
+extern task_t *child_reaper;
 
 extern int do_execve(char *, char **, char **, struct pt_regs *);
 extern int do_fork(unsigned long, unsigned long, struct pt_regs *, unsigned long);
@@ -803,6 +846,9 @@
 extern void FASTCALL(add_wait_queue_exclusive(wait_queue_head_t *q, wait_queue_t * wait));
 extern void FASTCALL(remove_wait_queue(wait_queue_head_t *q, wait_queue_t * wait));
 
+extern void wait_task_inactive(task_t * p);
+extern void kick_if_running(task_t * p);
+
 #define __wait_event(wq, condition)                                    \
 do {                                                                   \
        wait_queue_t __wait;                                            \
@@ -884,27 +930,12 @@
        for (task = next_thread(current) ; task != current ; task = next_thread(task))
 
 #define next_thread(p) \
-       list_entry((p)->thread_group.next, struct task_struct, thread_group)
+       list_entry((p)->thread_group.next, task_t, thread_group)
 
 #define thread_group_leader(p) (p->pid == p->tgid)
 
-static inline void del_from_runqueue(struct task_struct * p)
+static inline void unhash_process(task_t *p)
 {
-       nr_running--;
-       p->sleep_time = jiffies;
-       list_del(&p->run_list);
-       p->run_list.next = NULL;
-}
-
-static inline int task_on_runqueue(struct task_struct *p)
-{
-       return (p->run_list.next != NULL);
-}
-
-static inline void unhash_process(struct task_struct *p)
-{
-       if (task_on_runqueue(p))
-               out_of_line_bug();
        write_lock_irq(&tasklist_lock);
        nr_threads--;
        unhash_pid(p);
@@ -914,12 +945,12 @@
 }
 
 /* Protects ->fs, ->files, ->mm, and synchronises with wait4().  Nests inside tasklist_lock */
-static inline void task_lock(struct task_struct *p)
+static inline void task_lock(task_t *p)
 {
        spin_lock(&p->alloc_lock);
 }
 
-static inline void task_unlock(struct task_struct *p)
+static inline void task_unlock(task_t *p)
 {
        spin_unlock(&p->alloc_lock);
 }
@@ -943,6 +974,26 @@
        return res;
 }
 
+static inline void set_need_resched(void)
+{
+       current->need_resched = 1;
+}
+
+static inline void clear_need_resched(void)
+{
+       current->need_resched = 0;
+}
+
+static inline void set_tsk_need_resched(task_t *tsk)
+{
+       tsk->need_resched = 1;
+}
+
+static inline void clear_tsk_need_resched(task_t *tsk)
+{
+       tsk->need_resched = 0;
+}
+
 static inline int need_resched(void)
 {
        return (unlikely(current->need_resched));
@@ -955,5 +1006,11 @@
                __cond_resched();
 }
 
+#define _TASK_STRUCT_DEFINED
+#include <linux/dcache.h>
+#include <linux/tqueue.h>
+#include <linux/fs_struct.h>
+
 #endif /* __KERNEL__ */
+
 #endif
diff -urN linux-2.4.20/include/linux/smp.h linux-2.4.20-o1-preempt/include/linux/smp.h
--- linux-2.4.20/include/linux/smp.h    Thu Nov 22 20:46:19 2001
+++ linux-2.4.20-o1-preempt/include/linux/smp.h Tue Feb 18 03:51:30 2003
@@ -86,6 +86,14 @@
 #define cpu_number_map(cpu)                    0
 #define smp_call_function(func,info,retry,wait)        ({ 0; })
 #define cpu_online_map                         1
+static inline void smp_send_reschedule(int cpu) { }
+static inline void smp_send_reschedule_all(void) { }
 
 #endif
+
+/*
+ * Common definitions:
+ */
+#define cpu()                                  smp_processor_id()
+
 #endif
diff -urN linux-2.4.20/include/linux/smp_lock.h linux-2.4.20-o1-preempt/include/linux/smp_lock.h
--- linux-2.4.20/include/linux/smp_lock.h       Thu Nov 22 20:46:27 2001
+++ linux-2.4.20-o1-preempt/include/linux/smp_lock.h    Tue Feb 18 03:52:06 2003
@@ -3,7 +3,7 @@
 
 #include <linux/config.h>
 
-#ifndef CONFIG_SMP
+#if !defined(CONFIG_SMP) && !defined(CONFIG_PREEMPT)
 
 #define lock_kernel()                          do { } while(0)
 #define unlock_kernel()                                do { } while(0)
diff -urN linux-2.4.20/include/linux/spinlock.h linux-2.4.20-o1-preempt/include/linux/spinlock.h
--- linux-2.4.20/include/linux/spinlock.h       Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/include/linux/spinlock.h    Tue Feb 18 03:52:06 2003
@@ -2,6 +2,7 @@
 #define __LINUX_SPINLOCK_H
 
 #include <linux/config.h>
+#include <linux/compiler.h>
 
 /*
  * These are the generic versions of the spinlocks and read-write
@@ -62,8 +63,10 @@
 
 #if (DEBUG_SPINLOCKS < 1)
 
+#ifndef CONFIG_PREEMPT
 #define atomic_dec_and_lock(atomic,lock) atomic_dec_and_test(atomic)
 #define ATOMIC_DEC_AND_LOCK
+#endif
 
 /*
  * Your basic spinlocks, allowing only a single CPU anywhere
@@ -80,11 +83,11 @@
 #endif
 
 #define spin_lock_init(lock)   do { } while(0)
-#define spin_lock(lock)                (void)(lock) /* Not "unused variable". */
+#define _raw_spin_lock(lock)   (void)(lock) /* Not "unused variable". */
 #define spin_is_locked(lock)   (0)
-#define spin_trylock(lock)     ({1; })
+#define _raw_spin_trylock(lock)        ({1; })
 #define spin_unlock_wait(lock) do { } while(0)
-#define spin_unlock(lock)      do { } while(0)
+#define _raw_spin_unlock(lock) do { } while(0)
 
 #elif (DEBUG_SPINLOCKS < 2)
 
@@ -144,12 +147,77 @@
 #endif
 
 #define rwlock_init(lock)      do { } while(0)
-#define read_lock(lock)                (void)(lock) /* Not "unused variable". */
-#define read_unlock(lock)      do { } while(0)
-#define write_lock(lock)       (void)(lock) /* Not "unused variable". */
-#define write_unlock(lock)     do { } while(0)
+#define _raw_read_lock(lock)   (void)(lock) /* Not "unused variable". */
+#define _raw_read_unlock(lock) do { } while(0)
+#define _raw_write_lock(lock)  (void)(lock) /* Not "unused variable". */
+#define _raw_write_unlock(lock)        do { } while(0)
 
 #endif /* !SMP */
+
+#ifdef CONFIG_PREEMPT
+
+#define preempt_get_count()    (current->preempt_count)
+#define preempt_is_disabled()  (preempt_get_count() != 0)
+
+#define preempt_disable() \
+do { \
+       ++current->preempt_count; \
+       barrier(); \
+} while (0)
+
+#define preempt_enable_no_resched() \
+do { \
+       --current->preempt_count; \
+       barrier(); \
+} while (0)
+
+#define preempt_enable() \
+do { \
+       --current->preempt_count; \
+       barrier(); \
+       if (unlikely(current->preempt_count < current->need_resched)) \
+               preempt_schedule(); \
+} while (0)
+
+#define spin_lock(lock)        \
+do { \
+       preempt_disable(); \
+       _raw_spin_lock(lock); \
+} while(0)
+
+#define spin_trylock(lock)     ({preempt_disable(); _raw_spin_trylock(lock) ? \
+                               1 : ({preempt_enable(); 0;});})
+#define spin_unlock(lock) \
+do { \
+       _raw_spin_unlock(lock); \
+       preempt_enable(); \
+} while (0)
+
+#define read_lock(lock)                ({preempt_disable(); _raw_read_lock(lock);})
+#define read_unlock(lock)      ({_raw_read_unlock(lock); preempt_enable();})
+#define write_lock(lock)       ({preempt_disable(); _raw_write_lock(lock);})
+#define write_unlock(lock)     ({_raw_write_unlock(lock); preempt_enable();})
+#define write_trylock(lock)    ({preempt_disable();_raw_write_trylock(lock) ? \
+                               1 : ({preempt_enable(); 0;});})
+
+#else
+
+#define preempt_get_count()    (0)
+#define preempt_is_disabled()  (1)
+#define preempt_disable()      do { } while (0)
+#define preempt_enable_no_resched()    do {} while(0)
+#define preempt_enable()       do { } while (0)
+
+#define spin_lock(lock)                _raw_spin_lock(lock)
+#define spin_trylock(lock)     _raw_spin_trylock(lock)
+#define spin_unlock(lock)      _raw_spin_unlock(lock)
+
+#define read_lock(lock)                _raw_read_lock(lock)
+#define read_unlock(lock)      _raw_read_unlock(lock)
+#define write_lock(lock)       _raw_write_lock(lock)
+#define write_unlock(lock)     _raw_write_unlock(lock)
+#define write_trylock(lock)    _raw_write_trylock(lock)
+#endif
 
 /* "lock on reference count zero" */
 #ifndef ATOMIC_DEC_AND_LOCK
diff -urN linux-2.4.20/include/linux/tqueue.h linux-2.4.20-o1-preempt/include/linux/tqueue.h
--- linux-2.4.20/include/linux/tqueue.h Thu Nov 22 20:46:19 2001
+++ linux-2.4.20-o1-preempt/include/linux/tqueue.h      Tue Feb 18 03:52:06 2003
@@ -94,6 +94,22 @@
 extern spinlock_t tqueue_lock;
 
 /*
+ * Call all "bottom halfs" on a given list.
+ */
+
+extern void __run_task_queue(task_queue *list);
+
+static inline void run_task_queue(task_queue *list)
+{
+       if (TQ_ACTIVE(*list))
+               __run_task_queue(list);
+}
+
+#endif /* _LINUX_TQUEUE_H */
+
+#if !defined(_LINUX_TQUEUE_H_INLINES) && defined(_TASK_STRUCT_DEFINED)
+#define _LINUX_TQUEUE_H_INLINES
+/*
  * Queue a task on a tq.  Return non-zero if it was successfully
  * added.
  */
@@ -109,17 +125,4 @@
        }
        return ret;
 }
-
-/*
- * Call all "bottom halfs" on a given list.
- */
-
-extern void __run_task_queue(task_queue *list);
-
-static inline void run_task_queue(task_queue *list)
-{
-       if (TQ_ACTIVE(*list))
-               __run_task_queue(list);
-}
-
-#endif /* _LINUX_TQUEUE_H */
+#endif
diff -urN linux-2.4.20/include/linux/wait.h linux-2.4.20-o1-preempt/include/linux/wait.h
--- linux-2.4.20/include/linux/wait.h   Thu Nov 22 20:46:19 2001
+++ linux-2.4.20-o1-preempt/include/linux/wait.h        Tue Feb 18 03:51:30 2003
@@ -59,6 +59,7 @@
 # define wq_write_lock_irq write_lock_irq
 # define wq_write_lock_irqsave write_lock_irqsave
 # define wq_write_unlock_irqrestore write_unlock_irqrestore
+# define wq_write_unlock_irq write_unlock_irq
 # define wq_write_unlock write_unlock
 #else
 # define wq_lock_t spinlock_t
@@ -71,6 +72,7 @@
 # define wq_write_lock_irq spin_lock_irq
 # define wq_write_lock_irqsave spin_lock_irqsave
 # define wq_write_unlock_irqrestore spin_unlock_irqrestore
+# define wq_write_unlock_irq spin_unlock_irq
 # define wq_write_unlock spin_unlock
 #endif
 
diff -urN linux-2.4.20/init/main.c linux-2.4.20-o1-preempt/init/main.c
--- linux-2.4.20/init/main.c    Sat Aug  3 02:39:46 2002
+++ linux-2.4.20-o1-preempt/init/main.c Tue Feb 18 03:51:30 2003
@@ -288,8 +288,6 @@
 extern void setup_arch(char **);
 extern void cpu_idle(void);
 
-unsigned long wait_init_idle;
-
 #ifndef CONFIG_SMP
 
 #ifdef CONFIG_X86_LOCAL_APIC
@@ -298,34 +296,24 @@
        APIC_init_uniprocessor();
 }
 #else
-#define smp_init()     do { } while (0)
+#define smp_init()      do { } while (0)
 #endif
 
 #else
 
-
 /* Called by boot processor to activate the rest. */
 static void __init smp_init(void)
 {
        /* Get other processors into their bootup holding patterns. */
        smp_boot_cpus();
-       wait_init_idle = cpu_online_map;
-       clear_bit(current->processor, &wait_init_idle); /* Don't wait on me! */
 
        smp_threads_ready=1;
        smp_commence();
-
-       /* Wait for the other cpus to set up their idle processes */
-       printk("Waiting on wait_init_idle (map = 0x%lx)\n", wait_init_idle);
-       while (wait_init_idle) {
-               cpu_relax();
-               barrier();
-       }
-       printk("All processors have done init_idle\n");
 }
 
 #endif
 
+
 /*
  * We need to finalize in a non-__init function or else race conditions
  * between the root thread and the init thread may cause start_kernel to
@@ -337,9 +325,8 @@
 {
        kernel_thread(init, NULL, CLONE_FS | CLONE_FILES | CLONE_SIGNAL);
        unlock_kernel();
-       current->need_resched = 1;
-       cpu_idle();
-} 
+       cpu_idle();
+}
 
 /*
  *     Activate the first processor.
@@ -424,14 +411,18 @@
        ipc_init();
 #endif
        check_bugs();
+
        printk("POSIX conformance testing by UNIFIX\n");
 
-       /* 
-        *      We count on the initial thread going ok 
-        *      Like idlers init is an unlocked kernel thread, which will
-        *      make syscalls (and thus be locked).
+       init_idle(current, smp_processor_id());
+       /*
+        *      We count on the initial thread going ok
+        *      Like idlers init is an unlocked kernel thread, which will
+        *      make syscalls (and thus be locked).
         */
        smp_init();
+
+       /* Do the rest non-__init'ed, we're now alive */
        rest_init();
 }
 
@@ -460,6 +451,10 @@
  */
 static void __init do_basic_setup(void)
 {
+       /* Start the per-CPU migration threads */
+#if CONFIG_SMP
+       migration_init();
+#endif
 
        /*
         * Tell the world that we're going to be the grim
diff -urN linux-2.4.20/kernel/capability.c linux-2.4.20-o1-preempt/kernel/capability.c
--- linux-2.4.20/kernel/capability.c    Sat Jun 24 06:06:37 2000
+++ linux-2.4.20-o1-preempt/kernel/capability.c Tue Feb 18 03:51:30 2003
@@ -8,6 +8,8 @@
 #include <linux/mm.h>
 #include <asm/uaccess.h>
 
+unsigned securebits = SECUREBITS_DEFAULT; /* systemwide security settings */
+
 kernel_cap_t cap_bset = CAP_INIT_EFF_SET;
 
 /* Note: never hold tasklist_lock while spinning for this one */
diff -urN linux-2.4.20/kernel/exit.c linux-2.4.20-o1-preempt/kernel/exit.c
--- linux-2.4.20/kernel/exit.c  Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/kernel/exit.c       Tue Feb 18 03:52:06 2003
@@ -28,49 +28,22 @@
 
 static void release_task(struct task_struct * p)
 {
-       if (p != current) {
+       if (p == current)
+               BUG();
 #ifdef CONFIG_SMP
-               /*
-                * Wait to make sure the process isn't on the
-                * runqueue (active on some other CPU still)
-                */
-               for (;;) {
-                       task_lock(p);
-                       if (!task_has_cpu(p))
-                               break;
-                       task_unlock(p);
-                       do {
-                               cpu_relax();
-                               barrier();
-                       } while (task_has_cpu(p));
-               }
-               task_unlock(p);
+       wait_task_inactive(p);
 #endif
-               atomic_dec(&p->user->processes);
-               free_uid(p->user);
-               unhash_process(p);
-
-               release_thread(p);
-               current->cmin_flt += p->min_flt + p->cmin_flt;
-               current->cmaj_flt += p->maj_flt + p->cmaj_flt;
-               current->cnswap += p->nswap + p->cnswap;
-               /*
-                * Potentially available timeslices are retrieved
-                * here - this way the parent does not get penalized
-                * for creating too many processes.
-                *
-                * (this cannot be used to artificially 'generate'
-                * timeslices, because any timeslice recovered here
-                * was given away by the parent in the first place.)
-                */
-               current->counter += p->counter;
-               if (current->counter >= MAX_COUNTER)
-                       current->counter = MAX_COUNTER;
-               p->pid = 0;
-               free_task_struct(p);
-       } else {
-               printk("task releasing itself\n");
-       }
+       atomic_dec(&p->user->processes);
+       free_uid(p->user);
+       unhash_process(p);
+
+       release_thread(p);
+       current->cmin_flt += p->min_flt + p->cmin_flt;
+       current->cmaj_flt += p->maj_flt + p->cmaj_flt;
+       current->cnswap += p->nswap + p->cnswap;
+       sched_exit(p);
+       p->pid = 0;
+       free_task_struct(p);
 }
 
 /*
@@ -150,6 +123,79 @@
        return retval;
 }
 
+/**
+ * reparent_to_init() - Reparent the calling kernel thread to the init task.
+ *
+ * If a kernel thread is launched as a result of a system call, or if
+ * it ever exits, it should generally reparent itself to init so that
+ * it is correctly cleaned up on exit.
+ *
+ * The various task state such as scheduling policy and priority may have
+ * been inherited from a user process, so we reset them to sane values here.
+ *
+ * NOTE that reparent_to_init() gives the caller full capabilities.
+ */
+void reparent_to_init(void)
+{
+       write_lock_irq(&tasklist_lock);
+
+       /* Reparent to init */
+       REMOVE_LINKS(current);
+       current->p_pptr = child_reaper;
+       current->p_opptr = child_reaper;
+       SET_LINKS(current);
+
+       /* Set the exit signal to SIGCHLD so we signal init on exit */
+       current->exit_signal = SIGCHLD;
+
+       current->ptrace = 0;
+       if ((current->policy == SCHED_OTHER) && (task_nice(current) < 0))
+               set_user_nice(current, 0);
+       /* cpus_allowed? */
+       /* rt_priority? */
+       /* signals? */
+       current->cap_effective = CAP_INIT_EFF_SET;
+       current->cap_inheritable = CAP_INIT_INH_SET;
+       current->cap_permitted = CAP_FULL_SET;
+       current->keep_capabilities = 0;
+       memcpy(current->rlim, init_task.rlim, sizeof(*(current->rlim)));
+       current->user = INIT_USER;
+
+       write_unlock_irq(&tasklist_lock);
+}
+
+/*
+ *     Put all the gunge required to become a kernel thread without
+ *     attached user resources in one place where it belongs.
+ */
+
+void daemonize(void)
+{
+       struct fs_struct *fs;
+
+
+       /*
+        * If we were started as result of loading a module, close all of the
+        * user space pages.  We don't need them, and if we didn't close them
+        * they would be locked into memory.
+        */
+       exit_mm(current);
+
+       current->session = 1;
+       current->pgrp = 1;
+       current->tty = NULL;
+
+       /* Become as one with the init task */
+
+       exit_fs(current);       /* current->fs->count--; */
+       fs = init_task.fs;
+       current->fs = fs;
+       atomic_inc(&fs->count);
+       exit_files(current);
+       current->files = init_task.files;
+       atomic_inc(&current->files->count);
+}
+
 /*
  * When we die, we re-parent all our children.
  * Try to give them to another thread in our thread
@@ -171,6 +217,7 @@
                        /* Make sure we're not reparenting to ourselves */
                        p->p_opptr = child_reaper;
 
+                       p->first_time_slice = 0;
                        if (p->pdeath_signal) send_sig(p->pdeath_signal, p, 0);
                }
        }
@@ -313,8 +360,8 @@
                /* more a memory barrier than a real lock */
                task_lock(tsk);
                tsk->mm = NULL;
-               task_unlock(tsk);
                enter_lazy_tlb(mm, current, smp_processor_id());
+               task_unlock(tsk);
                mmput(mm);
        }
 }
@@ -434,6 +481,11 @@
                panic("Attempted to kill init!");
        tsk->flags |= PF_EXITING;
        del_timer_sync(&tsk->real_timer);
+
+       if (unlikely(preempt_get_count()))
+               printk(KERN_INFO "note: %s[%d] exited with preempt_count %d\n",
+                               current->comm, current->pid,
+                               preempt_get_count());
 
 fake_volatile:
 #ifdef CONFIG_BSD_PROCESS_ACCT
diff -urN linux-2.4.20/kernel/fork.c linux-2.4.20-o1-preempt/kernel/fork.c
--- linux-2.4.20/kernel/fork.c  Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/kernel/fork.c       Tue Feb 18 03:52:06 2003
@@ -30,7 +30,6 @@
 
 /* The idle threads do not count.. */
 int nr_threads;
-int nr_running;
 
 int max_threads;
 unsigned long total_forks;     /* Handle normal Linux uptimes. */
@@ -38,6 +37,8 @@
 
 struct task_struct *pidhash[PIDHASH_SZ];
 
+rwlock_t tasklist_lock __cacheline_aligned = RW_LOCK_UNLOCKED;  /* outer */
+
 void add_wait_queue(wait_queue_head_t *q, wait_queue_t * wait)
 {
        unsigned long flags;
@@ -629,6 +630,13 @@
        if (p->binfmt && p->binfmt->module)
                __MOD_INC_USE_COUNT(p->binfmt->module);
 
+#ifdef CONFIG_PREEMPT
+       /*
+        * Continue with preemption disabled as part of the context
+        * switch, so start with preempt_count set to 1.
+        */
+       p->preempt_count = 1;
+#endif
        p->did_exec = 0;
        p->swappable = 0;
        p->state = TASK_UNINTERRUPTIBLE;
@@ -638,8 +646,7 @@
        if (p->pid == 0 && current->pid != 0)
                goto bad_fork_cleanup;
 
-       p->run_list.next = NULL;
-       p->run_list.prev = NULL;
+       INIT_LIST_HEAD(&p->run_list);
 
        p->p_cptr = NULL;
        init_waitqueue_head(&p->wait_chldexit);
@@ -649,6 +656,7 @@
                init_completion(&vfork);
        }
        spin_lock_init(&p->alloc_lock);
+       spin_lock_init(&p->switch_lock);
 
        p->sigpending = 0;
        init_sigpending(&p->pending);
@@ -665,14 +673,15 @@
 #ifdef CONFIG_SMP
        {
                int i;
-               p->cpus_runnable = ~0UL;
-               p->processor = current->processor;
+
                /* ?? should we just memset this ?? */
                for(i = 0; i < smp_num_cpus; i++)
-                       p->per_cpu_utime[i] = p->per_cpu_stime[i] = 0;
+                       p->per_cpu_utime[cpu_logical_map(i)] =
+                               p->per_cpu_stime[cpu_logical_map(i)] = 0;
                spin_lock_init(&p->sigmask_lock);
        }
 #endif
+       p->array = NULL;
        p->lock_depth = -1;             /* -1 = no lock */
        p->start_time = jiffies;
 
@@ -706,15 +715,27 @@
        p->pdeath_signal = 0;
 
        /*
-        * "share" dynamic priority between parent and child, thus the
-        * total amount of dynamic priorities in the system doesn't change,
-        * more scheduling fairness. This is only important in the first
-        * timeslice, on the long run the scheduling behaviour is unchanged.
-        */
-       p->counter = (current->counter + 1) >> 1;
-       current->counter >>= 1;
-       if (!current->counter)
-               current->need_resched = 1;
+        * Share the timeslice between parent and child, thus the
+        * total amount of pending timeslices in the system doesnt change,
+        * resulting in more scheduling fairness.
+        */
+       __cli();
+       if (!current->time_slice)
+               BUG();
+       p->time_slice = (current->time_slice + 1) >> 1;
+       current->time_slice >>= 1;
+       p->first_time_slice = 1;
+       if (!current->time_slice) {
+               /*
+                * This case is rare, it happens when the parent has only
+                * a single jiffy left from its timeslice. Taking the
+                * runqueue lock is not a problem.
+                */
+               current->time_slice = 1;
+               scheduler_tick(0,0);
+       }
+       p->sleep_timestamp = jiffies;
+       __sti();
 
        /*
         * Ok, add it to the run-queues and make it
@@ -750,11 +771,16 @@
 
        if (p->ptrace & PT_PTRACED)
                send_sig(SIGSTOP, p, 1);
-
-       wake_up_process(p);             /* do this last */
+       wake_up_forked_process(p);      /* do this last */
        ++total_forks;
        if (clone_flags & CLONE_VFORK)
                wait_for_completion(&vfork);
+       else
+               /*
+                * Let the child process run first, to avoid most of the
+                * COW overhead when the child exec()s afterwards.
+                */
+               current->need_resched = 1;
 
 fork_out:
        return retval;
diff -urN linux-2.4.20/kernel/ksyms.c linux-2.4.20-o1-preempt/kernel/ksyms.c
--- linux-2.4.20/kernel/ksyms.c Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/kernel/ksyms.c      Tue Feb 18 03:52:06 2003
@@ -443,16 +443,23 @@
 /* process management */
 EXPORT_SYMBOL(complete_and_exit);
 EXPORT_SYMBOL(__wake_up);
-EXPORT_SYMBOL(__wake_up_sync);
 EXPORT_SYMBOL(wake_up_process);
 EXPORT_SYMBOL(sleep_on);
 EXPORT_SYMBOL(sleep_on_timeout);
 EXPORT_SYMBOL(interruptible_sleep_on);
 EXPORT_SYMBOL(interruptible_sleep_on_timeout);
 EXPORT_SYMBOL(schedule);
+#ifdef CONFIG_PREEMPT
+EXPORT_SYMBOL(preempt_schedule);
+#endif
 EXPORT_SYMBOL(schedule_timeout);
 EXPORT_SYMBOL(yield);
 EXPORT_SYMBOL(__cond_resched);
+EXPORT_SYMBOL(set_user_nice);
+#ifdef CONFIG_SMP
+EXPORT_SYMBOL_GPL(set_cpus_allowed);
+#endif
+EXPORT_SYMBOL(nr_context_switches);
 EXPORT_SYMBOL(jiffies);
 EXPORT_SYMBOL(xtime);
 EXPORT_SYMBOL(do_gettimeofday);
@@ -463,7 +470,6 @@
 #endif
 
 EXPORT_SYMBOL(kstat);
-EXPORT_SYMBOL(nr_running);
 
 /* misc */
 EXPORT_SYMBOL(panic);
diff -urN linux-2.4.20/kernel/printk.c linux-2.4.20-o1-preempt/kernel/printk.c
--- linux-2.4.20/kernel/printk.c        Sat Aug  3 02:39:46 2002
+++ linux-2.4.20-o1-preempt/kernel/printk.c     Tue Feb 18 03:51:30 2003
@@ -26,6 +26,7 @@
 #include <linux/module.h>
 #include <linux/interrupt.h>                   /* For in_interrupt() */
 #include <linux/config.h>
+#include <linux/delay.h>
 
 #include <asm/uaccess.h>
 
diff -urN linux-2.4.20/kernel/ptrace.c linux-2.4.20-o1-preempt/kernel/ptrace.c
--- linux-2.4.20/kernel/ptrace.c        Sat Aug  3 02:39:46 2002
+++ linux-2.4.20-o1-preempt/kernel/ptrace.c     Tue Feb 18 03:51:30 2003
@@ -31,20 +31,7 @@
                if (child->state != TASK_STOPPED)
                        return -ESRCH;
 #ifdef CONFIG_SMP
-               /* Make sure the child gets off its CPU.. */
-               for (;;) {
-                       task_lock(child);
-                       if (!task_has_cpu(child))
-                               break;
-                       task_unlock(child);
-                       do {
-                               if (child->state != TASK_STOPPED)
-                                       return -ESRCH;
-                               barrier();
-                               cpu_relax();
-                       } while (task_has_cpu(child));
-               }
-               task_unlock(child);
+               wait_task_inactive(child);
 #endif         
        }
 
diff -urN linux-2.4.20/kernel/sched.c linux-2.4.20-o1-preempt/kernel/sched.c
--- linux-2.4.20/kernel/sched.c Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/kernel/sched.c      Tue Feb 18 03:52:06 2003
@@ -3,340 +3,332 @@
  *
  *  Kernel scheduler and related syscalls
  *
- *  Copyright (C) 1991, 1992  Linus Torvalds
+ *  Copyright (C) 1991-2002  Linus Torvalds
  *
  *  1996-12-23  Modified by Dave Grothe to fix bugs in semaphores and
  *              make semaphores SMP safe
  *  1998-11-19 Implemented schedule_timeout() and related stuff
  *             by Andrea Arcangeli
- *  1998-12-28  Implemented better SMP scheduling by Ingo Molnar
+ *  2002-01-04 New ultra-scalable O(1) scheduler by Ingo Molnar:
+ *             hybrid priority-list and round-robin design with
+ *             an array-switch method of distributing timeslices
+ *             and per-CPU runqueues.  Additional code by Davide
+ *             Libenzi, Robert Love, and Rusty Russell.
  */
 
-/*
- * 'sched.c' is the main kernel file. It contains scheduling primitives
- * (sleep_on, wakeup, schedule etc) as well as a number of simple system
- * call functions (type getpid()), which just extract a field from
- * current-task
- */
-
-#include <linux/config.h>
 #include <linux/mm.h>
-#include <linux/init.h>
-#include <linux/smp_lock.h>
 #include <linux/nmi.h>
 #include <linux/interrupt.h>
-#include <linux/kernel_stat.h>
-#include <linux/completion.h>
-#include <linux/prefetch.h>
-#include <linux/compiler.h>
-
+#include <linux/init.h>
 #include <asm/uaccess.h>
+#include <linux/smp_lock.h>
 #include <asm/mmu_context.h>
-
-extern void timer_bh(void);
-extern void tqueue_bh(void);
-extern void immediate_bh(void);
+#include <linux/kernel_stat.h>
+#include <linux/completion.h>
 
 /*
- * scheduler variables
+ * Convert user-nice values [ -20 ... 0 ... 19 ]
+ * to static priority [ MAX_RT_PRIO..MAX_PRIO-1 ],
+ * and back.
  */
+#define NICE_TO_PRIO(nice)     (MAX_RT_PRIO + (nice) + 20)
+#define PRIO_TO_NICE(prio)     ((prio) - MAX_RT_PRIO - 20)
+#define TASK_NICE(p)           PRIO_TO_NICE((p)->static_prio)
 
-unsigned securebits = SECUREBITS_DEFAULT; /* systemwide security settings */
-
-extern void mem_use(void);
+/*
+ * 'User priority' is the nice value converted to something we
+ * can work with better when scaling various scheduler parameters,
+ * it's a [ 0 ... 39 ] range.
+ */
+#define USER_PRIO(p)           ((p)-MAX_RT_PRIO)
+#define TASK_USER_PRIO(p)      USER_PRIO((p)->static_prio)
+#define MAX_USER_PRIO          (USER_PRIO(MAX_PRIO))
 
 /*
- * Scheduling quanta.
- *
- * NOTE! The unix "nice" value influences how long a process
- * gets. The nice value ranges from -20 to +19, where a -20
- * is a "high-priority" task, and a "+10" is a low-priority
- * task.
+ * These are the 'tuning knobs' of the scheduler:
  *
- * We want the time-slice to be around 50ms or so, so this
- * calculation depends on the value of HZ.
+ * Minimum timeslice is 10 msecs, default timeslice is 150 msecs,
+ * maximum timeslice is 300 msecs. Timeslices get refilled after
+ * they expire.
  */
-#if HZ < 200
-#define TICK_SCALE(x)  ((x) >> 2)
-#elif HZ < 400
-#define TICK_SCALE(x)  ((x) >> 1)
-#elif HZ < 800
-#define TICK_SCALE(x)  (x)
-#elif HZ < 1600
-#define TICK_SCALE(x)  ((x) << 1)
-#else
-#define TICK_SCALE(x)  ((x) << 2)
-#endif
-
-#define NICE_TO_TICKS(nice)    (TICK_SCALE(20-(nice))+1)
-
+#define MIN_TIMESLICE          ( 10 * HZ / 1000)
+#define MAX_TIMESLICE          (300 * HZ / 1000)
+#define CHILD_PENALTY          95
+#define PARENT_PENALTY         100
+#define EXIT_WEIGHT            3
+#define PRIO_BONUS_RATIO       25
+#define INTERACTIVE_DELTA      2
+#define MAX_SLEEP_AVG          (2*HZ)
+#define STARVATION_LIMIT       (2*HZ)
 
 /*
- *     Init task must be ok at boot for the ix86 as we will check its signals
- *     via the SMP irq return path.
+ * If a task is 'interactive' then we reinsert it in the active
+ * array after it has expired its current timeslice. (it will not
+ * continue to run immediately, it will still roundrobin with
+ * other interactive tasks.)
+ *
+ * This part scales the interactivity limit depending on niceness.
+ *
+ * We scale it linearly, offset by the INTERACTIVE_DELTA delta.
+ * Here are a few examples of different nice levels:
+ *
+ *  TASK_INTERACTIVE(-20): [1,1,1,1,1,1,1,1,1,0,0]
+ *  TASK_INTERACTIVE(-10): [1,1,1,1,1,1,1,0,0,0,0]
+ *  TASK_INTERACTIVE(  0): [1,1,1,1,0,0,0,0,0,0,0]
+ *  TASK_INTERACTIVE( 10): [1,1,0,0,0,0,0,0,0,0,0]
+ *  TASK_INTERACTIVE( 19): [0,0,0,0,0,0,0,0,0,0,0]
+ *
+ * (the X axis represents the possible -5 ... 0 ... +5 dynamic
+ *  priority range a task can explore, a value of '1' means the
+ *  task is rated interactive.)
+ *
+ * Ie. nice +19 tasks can never get 'interactive' enough to be
+ * reinserted into the active array. And only heavily CPU-hog nice -20
+ * tasks will be expired. Default nice 0 tasks are somewhere between,
+ * it takes some effort for them to get interactive, but it's not
+ * too hard.
  */
- 
-struct task_struct * init_tasks[NR_CPUS] = {&init_task, };
+
+#define SCALE(v1,v1_max,v2_max) \
+       (v1) * (v2_max) / (v1_max)
+
+#define DELTA(p) \
+       (SCALE(TASK_NICE(p), 40, MAX_USER_PRIO*PRIO_BONUS_RATIO/100) + \
+               INTERACTIVE_DELTA)
+
+#define TASK_INTERACTIVE(p) \
+       ((p)->prio <= (p)->static_prio - DELTA(p))
 
 /*
- * The tasklist_lock protects the linked list of processes.
+ * TASK_TIMESLICE scales user-nice values [ -20 ... 19 ]
+ * to time slice values.
  *
- * The runqueue_lock locks the parts that actually access
- * and change the run-queues, and have to be interrupt-safe.
- *
- * If both locks are to be concurrently held, the runqueue_lock
- * nests inside the tasklist_lock.
- *
- * task->alloc_lock nests inside tasklist_lock.
+ * The higher a process's priority, the bigger timeslices
+ * it gets during one round of execution. But even the lowest
+ * priority process gets MIN_TIMESLICE worth of execution time.
  */
-spinlock_t runqueue_lock __cacheline_aligned = SPIN_LOCK_UNLOCKED;  /* inner */
-rwlock_t tasklist_lock __cacheline_aligned = RW_LOCK_UNLOCKED; /* outer */
 
-static LIST_HEAD(runqueue_head);
+#define TASK_TIMESLICE(p) (MIN_TIMESLICE + \
+       ((MAX_TIMESLICE - MIN_TIMESLICE) * (MAX_PRIO-1-(p)->static_prio)/39))
 
 /*
- * We align per-CPU scheduling data on cacheline boundaries,
- * to prevent cacheline ping-pong.
+ * These are the runqueue data structures:
  */
-static union {
-       struct schedule_data {
-               struct task_struct * curr;
-               cycles_t last_schedule;
-       } schedule_data;
-       char __pad [SMP_CACHE_BYTES];
-} aligned_data [NR_CPUS] __cacheline_aligned = { {{&init_task,0}}};
 
-#define cpu_curr(cpu) aligned_data[(cpu)].schedule_data.curr
-#define last_schedule(cpu) aligned_data[(cpu)].schedule_data.last_schedule
+#define BITMAP_SIZE ((((MAX_PRIO+1+7)/8)+sizeof(long)-1)/sizeof(long))
 
-struct kernel_stat kstat;
-extern struct task_struct *child_reaper;
+typedef struct runqueue runqueue_t;
 
-#ifdef CONFIG_SMP
+struct prio_array {
+       int nr_active;
+       unsigned long bitmap[BITMAP_SIZE];
+       list_t queue[MAX_PRIO];
+};
 
-#define idle_task(cpu) (init_tasks[cpu_number_map(cpu)])
-#define can_schedule(p,cpu) \
-       ((p)->cpus_runnable & (p)->cpus_allowed & (1 << cpu))
+/*
+ * This is the main, per-CPU runqueue data structure.
+ *
+ * Locking rule: those places that want to lock multiple runqueues
+ * (such as the load balancing or the process migration code), lock
+ * acquire operations must be ordered by ascending &runqueue.
+ */
+struct runqueue {
+       spinlock_t lock;
+       unsigned long nr_running, nr_switches, expired_timestamp;
+       task_t *curr, *idle;
+       prio_array_t *active, *expired, arrays[2];
+       long nr_uninterruptible;
+       int prev_nr_running[NR_CPUS];
+       task_t *migration_thread;
+       list_t migration_queue;
+} ____cacheline_aligned;
+
+static struct runqueue runqueues[NR_CPUS] __cacheline_aligned;
+
+#define cpu_rq(cpu)            (runqueues + (cpu))
+#define this_rq()              cpu_rq(smp_processor_id())
+#define task_rq(p)             cpu_rq((p)->cpu)
+#define cpu_curr(cpu)          (cpu_rq(cpu)->curr)
+#define rt_task(p)             ((p)->prio < MAX_RT_PRIO)
 
-#else
+/*
+ * Default context-switch locking:
+ */
+#ifndef prepare_arch_switch
+# define prepare_arch_switch(rq, next) do { } while(0)
+# define finish_arch_switch(rq, next)  spin_unlock_irq(&(rq)->lock)
+#endif
 
-#define idle_task(cpu) (&init_task)
-#define can_schedule(p,cpu) (1)
+/*
+ * task_rq_lock - lock the runqueue a given task resides on and disable
+ * interrupts.  Note the ordering: we can safely lookup the task_rq without
+ * explicitly disabling preemption.
+ */
+static inline runqueue_t *task_rq_lock(task_t *p, unsigned long *flags)
+{
+       struct runqueue *rq;
 
-#endif
+repeat_lock_task:
+       preempt_disable();
+       rq = task_rq(p);
+       spin_lock_irqsave(&rq->lock, *flags);
+       if (unlikely(rq != task_rq(p))) {
+               spin_unlock_irqrestore(&rq->lock, *flags);
+               preempt_enable();
+               goto repeat_lock_task;
+       }
+       return rq;
+}
 
-void scheduling_functions_start_here(void) { }
+static inline void task_rq_unlock(runqueue_t *rq, unsigned long *flags)
+{
+       spin_unlock_irqrestore(&rq->lock, *flags);
+       preempt_enable();
+}
 
 /*
- * This is the function that decides how desirable a process is..
- * You can weigh different processes against each other depending
- * on what CPU they've run on lately etc to try to handle cache
- * and TLB miss penalties.
- *
- * Return values:
- *      -1000: never select this
- *          0: out of time, recalculate counters (but it might still be
- *             selected)
- *        +ve: "goodness" value (the larger, the better)
- *      +1000: realtime process, select this.
+ * Adding/removing a task to/from a priority array:
  */
+static inline void dequeue_task(struct task_struct *p, prio_array_t *array)
+{
+       array->nr_active--;
+       list_del(&p->run_list);
+       if (list_empty(array->queue + p->prio))
+               __clear_bit(p->prio, array->bitmap);
+}
 
-static inline int goodness(struct task_struct * p, int this_cpu, struct mm_struct *this_mm)
+static inline void enqueue_task(struct task_struct *p, prio_array_t *array)
 {
-       int weight;
+       list_add_tail(&p->run_list, array->queue + p->prio);
+       __set_bit(p->prio, array->bitmap);
+       array->nr_active++;
+       p->array = array;
+}
 
-       /*
-        * select the current process after every other
-        * runnable process, but before the idle thread.
-        * Also, dont trigger a counter recalculation.
-        */
-       weight = -1;
-       if (p->policy & SCHED_YIELD)
-               goto out;
+static inline int effective_prio(task_t *p)
+{
+       int bonus, prio;
 
        /*
-        * Non-RT process - normal case first.
+        * Here we scale the actual sleep average [0 .... MAX_SLEEP_AVG]
+        * into the -5 ... 0 ... +5 bonus/penalty range.
+        *
+        * We use 25% of the full 0...39 priority range so that:
+        *
+        * 1) nice +19 interactive tasks do not preempt nice 0 CPU hogs.
+        * 2) nice -20 CPU hogs do not get preempted by nice 0 tasks.
+        *
+        * Both properties are important to certain workloads.
         */
-       if (p->policy == SCHED_OTHER) {
+       bonus = MAX_USER_PRIO*PRIO_BONUS_RATIO*p->sleep_avg/MAX_SLEEP_AVG/100 -
+                       MAX_USER_PRIO*PRIO_BONUS_RATIO/100/2;
+
+       prio = p->static_prio - bonus;
+       if (prio < MAX_RT_PRIO)
+               prio = MAX_RT_PRIO;
+       if (prio > MAX_PRIO-1)
+               prio = MAX_PRIO-1;
+       return prio;
+}
+
+static inline void activate_task(task_t *p, runqueue_t *rq)
+{
+       unsigned long sleep_time = jiffies - p->sleep_timestamp;
+       prio_array_t *array = rq->active;
+
+       if (!rt_task(p) && sleep_time) {
                /*
-                * Give the process a first-approximation goodness value
-                * according to the number of clock-ticks it has left.
-                *
-                * Don't do any other calculations if the time slice is
-                * over..
+                * This code gives a bonus to interactive tasks. We update
+                * an 'average sleep time' value here, based on
+                * sleep_timestamp. The more time a task spends sleeping,
+                * the higher the average gets - and the higher the priority
+                * boost gets as well.
                 */
-               weight = p->counter;
-               if (!weight)
-                       goto out;
-                       
-#ifdef CONFIG_SMP
-               /* Give a largish advantage to the same processor...   */
-               /* (this is equivalent to penalizing other processors) */
-               if (p->processor == this_cpu)
-                       weight += PROC_CHANGE_PENALTY;
-#endif
-
-               /* .. and a slight advantage to the current MM */
-               if (p->mm == this_mm || !p->mm)
-                       weight += 1;
-               weight += 20 - p->nice;
-               goto out;
+               p->sleep_avg += sleep_time;
+               if (p->sleep_avg > MAX_SLEEP_AVG)
+                       p->sleep_avg = MAX_SLEEP_AVG;
+               p->prio = effective_prio(p);
        }
+       enqueue_task(p, array);
+       rq->nr_running++;
+}
 
-       /*
-        * Realtime process, select the first one on the
-        * runqueue (taking priorities within processes
-        * into account).
-        */
-       weight = 1000 + p->rt_priority;
-out:
-       return weight;
+static inline void deactivate_task(struct task_struct *p, runqueue_t *rq)
+{
+       rq->nr_running--;
+       if (p->state == TASK_UNINTERRUPTIBLE)
+               rq->nr_uninterruptible++;
+       dequeue_task(p, p->array);
+       p->array = NULL;
 }
 
-/*
- * the 'goodness value' of replacing a process on a given CPU.
- * positive value means 'replace', zero or negative means 'dont'.
- */
-static inline int preemption_goodness(struct task_struct * prev, struct task_struct * p, int cpu)
+static inline void resched_task(task_t *p)
 {
-       return goodness(p, cpu, prev->active_mm) - goodness(prev, cpu, prev->active_mm);
+#ifdef CONFIG_SMP
+       int need_resched;
+
+       preempt_disable();
+       need_resched = p->need_resched;
+       set_tsk_need_resched(p);
+       if (!need_resched && (p->cpu != smp_processor_id()))
+               smp_send_reschedule(p->cpu);
+#else
+       preempt_disable();
+       set_tsk_need_resched(p);
+#endif
+       preempt_enable();
 }
 
+#ifdef CONFIG_SMP
+
 /*
- * This is ugly, but reschedule_idle() is very timing-critical.
- * We are called with the runqueue spinlock held and we must
- * not claim the tasklist_lock.
+ * Wait for a process to unschedule. This is used by the exit() and
+ * ptrace() code.
  */
-static FASTCALL(void reschedule_idle(struct task_struct * p));
-
-static void reschedule_idle(struct task_struct * p)
+void wait_task_inactive(task_t * p)
 {
-#ifdef CONFIG_SMP
-       int this_cpu = smp_processor_id();
-       struct task_struct *tsk, *target_tsk;
-       int cpu, best_cpu, i, max_prio;
-       cycles_t oldest_idle;
-
-       /*
-        * shortcut if the woken up task's last CPU is
-        * idle now.
-        */
-       best_cpu = p->processor;
-       if (can_schedule(p, best_cpu)) {
-               tsk = idle_task(best_cpu);
-               if (cpu_curr(best_cpu) == tsk) {
-                       int need_resched;
-send_now_idle:
-                       /*
-                        * If need_resched == -1 then we can skip sending
-                        * the IPI altogether, tsk->need_resched is
-                        * actively watched by the idle thread.
-                        */
-                       need_resched = tsk->need_resched;
-                       tsk->need_resched = 1;
-                       if ((best_cpu != this_cpu) && !need_resched)
-                               smp_send_reschedule(best_cpu);
-                       return;
-               }
-       }
-
-       /*
-        * We know that the preferred CPU has a cache-affine current
-        * process, lets try to find a new idle CPU for the woken-up
-        * process. Select the least recently active idle CPU. (that
-        * one will have the least active cache context.) Also find
-        * the executing process which has the least priority.
-        */
-       oldest_idle = (cycles_t) -1;
-       target_tsk = NULL;
-       max_prio = 0;
+       unsigned long flags;
+       runqueue_t *rq;
 
-       for (i = 0; i < smp_num_cpus; i++) {
-               cpu = cpu_logical_map(i);
-               if (!can_schedule(p, cpu))
-                       continue;
-               tsk = cpu_curr(cpu);
+repeat:
+       preempt_disable();
+       rq = task_rq(p);
+       if (unlikely(rq->curr == p)) {
+               cpu_relax();
+               barrier();
                /*
-                * We use the first available idle CPU. This creates
-                * a priority list between idle CPUs, but this is not
-                * a problem.
+                * enable/disable preemption just to make this
+                * a preemption point - we are busy-waiting
+                * anyway.
                 */
-               if (tsk == idle_task(cpu)) {
-#if defined(__i386__) && defined(CONFIG_SMP)
-                        /*
-                        * Check if two siblings are idle in the same
-                        * physical package. Use them if found.
-                        */
-                       if (smp_num_siblings == 2) {
-                               if (cpu_curr(cpu_sibling_map[cpu]) == 
-                                   idle_task(cpu_sibling_map[cpu])) {
-                                       oldest_idle = last_schedule(cpu);
-                                       target_tsk = tsk;
-                                       break;
-                               }
-                               
-                        }
-#endif         
-                       if (last_schedule(cpu) < oldest_idle) {
-                               oldest_idle = last_schedule(cpu);
-                               target_tsk = tsk;
-                       }
-               } else {
-                       if (oldest_idle == -1ULL) {
-                               int prio = preemption_goodness(tsk, p, cpu);
-
-                               if (prio > max_prio) {
-                                       max_prio = prio;
-                                       target_tsk = tsk;
-                               }
-                       }
-               }
+               preempt_enable();
+               goto repeat;
        }
-       tsk = target_tsk;
-       if (tsk) {
-               if (oldest_idle != -1ULL) {
-                       best_cpu = tsk->processor;
-                       goto send_now_idle;
-               }
-               tsk->need_resched = 1;
-               if (tsk->processor != this_cpu)
-                       smp_send_reschedule(tsk->processor);
-       }
-       return;
-               
-
-#else /* UP */
-       int this_cpu = smp_processor_id();
-       struct task_struct *tsk;
-
-       tsk = cpu_curr(this_cpu);
-       if (preemption_goodness(tsk, p, this_cpu) > 0)
-               tsk->need_resched = 1;
-#endif
+       rq = task_rq_lock(p, &flags);
+       if (unlikely(rq->curr == p)) {
+               task_rq_unlock(rq, &flags);
+               preempt_enable();
+               goto repeat;
+       }
+       task_rq_unlock(rq, &flags);
+       preempt_enable();
 }
 
 /*
- * Careful!
- *
- * This has to add the process to the _end_ of the 
- * run-queue, not the beginning. The goodness value will
- * determine whether this process will run next. This is
- * important to get SCHED_FIFO and SCHED_RR right, where
- * a process that is either pre-empted or its time slice
- * has expired, should be moved to the tail of the run 
- * queue for its priority - Bhavesh Davda
+ * Kick the remote CPU if the task is running currently,
+ * this code is used by the signal code to signal tasks
+ * which are in user-mode as quickly as possible.
+ *
+ * (Note that we do this lockless - if the task does anything
+ * while the message is in flight then it will notice the
+ * sigpending condition anyway.)
  */
-static inline void add_to_runqueue(struct task_struct * p)
+void kick_if_running(task_t * p)
 {
-       list_add_tail(&p->run_list, &runqueue_head);
-       nr_running++;
-}
-
-static inline void move_last_runqueue(struct task_struct * p)
-{
-       list_del(&p->run_list);
-       list_add_tail(&p->run_list, &runqueue_head);
+       if (p == task_rq(p)->curr && p->cpu != smp_processor_id())
+               resched_task(p);
 }
+#endif
 
 /*
  * Wake up a process. Put it on the run-queue if it's not
@@ -345,429 +337,648 @@
  * progress), and as such you're allowed to do the simpler
  * "current->state = TASK_RUNNING" to mark yourself runnable
  * without the overhead of this.
+ *
+ * returns failure only if the task is already active.
  */
-static inline int try_to_wake_up(struct task_struct * p, int synchronous)
+static int try_to_wake_up(task_t * p, int sync)
 {
        unsigned long flags;
        int success = 0;
+       long old_state;
+       runqueue_t *rq;
 
-       /*
-        * We want the common case fall through straight, thus the goto.
-        */
-       spin_lock_irqsave(&runqueue_lock, flags);
+repeat_lock_task:
+       rq = task_rq_lock(p, &flags);
+       old_state = p->state;
+       if (!p->array) {
+               if (unlikely(sync) &&
+                   rq->curr != p &&
+                   p->cpu != smp_processor_id() &&
+                   p->cpus_allowed & (1UL << smp_processor_id())) {
+                       p->cpu = smp_processor_id();
+                       task_rq_unlock(rq, &flags);
+                       goto repeat_lock_task;
+               }
+               if (old_state == TASK_UNINTERRUPTIBLE)
+                       rq->nr_uninterruptible--;
+               activate_task(p, rq);
+               if (p->prio < rq->curr->prio)
+                       resched_task(rq->curr);
+               success = 1;
+       }
        p->state = TASK_RUNNING;
-       if (task_on_runqueue(p))
-               goto out;
-       add_to_runqueue(p);
-       if (!synchronous || !(p->cpus_allowed & (1 << smp_processor_id())))
-               reschedule_idle(p);
-       success = 1;
-out:
-       spin_unlock_irqrestore(&runqueue_lock, flags);
+       task_rq_unlock(rq, &flags);
+
        return success;
 }
 
-inline int wake_up_process(struct task_struct * p)
+int wake_up_process(task_t * p)
 {
        return try_to_wake_up(p, 0);
 }
 
-static void process_timeout(unsigned long __data)
+void wake_up_forked_process(task_t * p)
 {
-       struct task_struct * p = (struct task_struct *) __data;
+       runqueue_t *rq;
 
-       wake_up_process(p);
+       preempt_disable();
+       rq = this_rq();
+       spin_lock_irq(&rq->lock);
+
+       p->state = TASK_RUNNING;
+       if (!rt_task(p)) {
+               /*
+                * We decrease the sleep average of forking parents
+                * and children as well, to keep max-interactive tasks
+                * from forking tasks that are max-interactive.
+                */
+               current->sleep_avg = current->sleep_avg * PARENT_PENALTY / 100;
+               p->sleep_avg = p->sleep_avg * CHILD_PENALTY / 100;
+               p->prio = effective_prio(p);
+       }
+       p->cpu = smp_processor_id();
+       activate_task(p, rq);
+       spin_unlock_irq(&rq->lock);
+       preempt_enable();
 }
 
-/**
- * schedule_timeout - sleep until timeout
- * @timeout: timeout value in jiffies
- *
- * Make the current task sleep until @timeout jiffies have
- * elapsed. The routine will return immediately unless
- * the current task state has been set (see set_current_state()).
- *
- * You can set the task state as follows -
- *
- * %TASK_UNINTERRUPTIBLE - at least @timeout jiffies are guaranteed to
- * pass before the routine returns. The routine will return 0
- *
- * %TASK_INTERRUPTIBLE - the routine may return early if a signal is
- * delivered to the current task. In this case the remaining time
- * in jiffies will be returned, or 0 if the timer expired in time
- *
- * The current task state is guaranteed to be TASK_RUNNING when this 
- * routine returns.
- *
- * Specifying a @timeout value of %MAX_SCHEDULE_TIMEOUT will schedule
- * the CPU away without a bound on the timeout. In this case the return
- * value will be %MAX_SCHEDULE_TIMEOUT.
- *
- * In all cases the return value is guaranteed to be non-negative.
+/*
+ * Potentially available exiting-child timeslices are
+ * retrieved here - this way the parent does not get
+ * penalized for creating too many processes.
+ *
+ * (this cannot be used to 'generate' timeslices
+ * artificially, because any timeslice recovered here
+ * was given away by the parent in the first place.)
  */
-signed long schedule_timeout(signed long timeout)
+void sched_exit(task_t * p)
 {
-       struct timer_list timer;
-       unsigned long expire;
+       __cli();
+       if (p->first_time_slice) {
+               current->time_slice += p->time_slice;
+               if (unlikely(current->time_slice > MAX_TIMESLICE))
+                       current->time_slice = MAX_TIMESLICE;
+       }
+       __sti();
+       /*
+        * If the child was a (relative-) CPU hog then decrease
+        * the sleep_avg of the parent as well.
+        */
+       if (p->sleep_avg < current->sleep_avg)
+               current->sleep_avg = (current->sleep_avg * EXIT_WEIGHT +
+                       p->sleep_avg) / (EXIT_WEIGHT + 1);
+}
 
-       switch (timeout)
-       {
-       case MAX_SCHEDULE_TIMEOUT:
-               /*
-                * These two special cases are useful to be comfortable
-                * in the caller. Nothing more. We could take
-                * MAX_SCHEDULE_TIMEOUT from one of the negative value
-                * but I' d like to return a valid offset (>=0) to allow
-                * the caller to do everything it want with the retval.
-                */
-               schedule();
-               goto out;
-       default:
-               /*
-                * Another bit of PARANOID. Note that the retval will be
-                * 0 since no piece of kernel is supposed to do a check
-                * for a negative retval of schedule_timeout() (since it
-                * should never happens anyway). You just have the printk()
-                * that will tell you if something is gone wrong and where.
-                */
-               if (timeout < 0)
-               {
-                       printk(KERN_ERR "schedule_timeout: wrong timeout "
-                              "value %lx from %p\n", timeout,
-                              __builtin_return_address(0));
-                       current->state = TASK_RUNNING;
-                       goto out;
-               }
+#if CONFIG_SMP || CONFIG_PREEMPT
+asmlinkage void schedule_tail(task_t *prev)
+{
+       finish_arch_switch(this_rq(), prev);
+}
+#endif
+
+static inline task_t * context_switch(task_t *prev, task_t *next)
+{
+       struct mm_struct *mm = next->mm;
+       struct mm_struct *oldmm = prev->active_mm;
+
+       if (unlikely(!mm)) {
+               next->active_mm = oldmm;
+               atomic_inc(&oldmm->mm_count);
+               enter_lazy_tlb(oldmm, next, smp_processor_id());
+       } else
+               switch_mm(oldmm, mm, next, smp_processor_id());
+
+       if (unlikely(!prev->mm)) {
+               prev->active_mm = NULL;
+               mmdrop(oldmm);
        }
 
-       expire = timeout + jiffies;
+       /* Here we just switch the register state and the stack. */
+       switch_to(prev, next, prev);
 
-       init_timer(&timer);
-       timer.expires = expire;
-       timer.data = (unsigned long) current;
-       timer.function = process_timeout;
+       return prev;
+}
 
-       add_timer(&timer);
-       schedule();
-       del_timer_sync(&timer);
+unsigned long nr_running(void)
+{
+       unsigned long i, sum = 0;
 
-       timeout = expire - jiffies;
+       for (i = 0; i < smp_num_cpus; i++)
+               sum += cpu_rq(cpu_logical_map(i))->nr_running;
 
- out:
-       return timeout < 0 ? 0 : timeout;
+       return sum;
 }
 
-/*
- * schedule_tail() is getting called from the fork return path. This
- * cleans up all remaining scheduler things, without impacting the
- * common case.
- */
-static inline void __schedule_tail(struct task_struct *prev)
+/* Note: the per-cpu information is useful only to get the cumulative result */
+unsigned long nr_uninterruptible(void)
 {
-#ifdef CONFIG_SMP
-       int policy;
+       unsigned long i, sum = 0;
 
-       /*
-        * prev->policy can be written from here only before `prev'
-        * can be scheduled (before setting prev->cpus_runnable to ~0UL).
-        * Of course it must also be read before allowing prev
-        * to be rescheduled, but since the write depends on the read
-        * to complete, wmb() is enough. (the spin_lock() acquired
-        * before setting cpus_runnable is not enough because the spin_lock()
-        * common code semantics allows code outside the critical section
-        * to enter inside the critical section)
-        */
-       policy = prev->policy;
-       prev->policy = policy & ~SCHED_YIELD;
-       wmb();
-
-       /*
-        * fast path falls through. We have to clear cpus_runnable before
-        * checking prev->state to avoid a wakeup race. Protect against
-        * the task exiting early.
-        */
-       task_lock(prev);
-       task_release_cpu(prev);
-       mb();
-       if (prev->state == TASK_RUNNING)
-               goto needs_resched;
+       for (i = 0; i < smp_num_cpus; i++)
+               sum += cpu_rq(cpu_logical_map(i))->nr_uninterruptible;
 
-out_unlock:
-       task_unlock(prev);      /* Synchronise here with release_task() if prev is TASK_ZOMBIE */
-       return;
+       return sum;
+}
 
-       /*
-        * Slow path - we 'push' the previous process and
-        * reschedule_idle() will attempt to find a new
-        * processor for it. (but it might preempt the
-        * current process as well.) We must take the runqueue
-        * lock and re-check prev->state to be correct. It might
-        * still happen that this process has a preemption
-        * 'in progress' already - but this is not a problem and
-        * might happen in other circumstances as well.
-        */
-needs_resched:
-       {
-               unsigned long flags;
+unsigned long nr_context_switches(void)
+{
+       unsigned long i, sum = 0;
 
-               /*
-                * Avoid taking the runqueue lock in cases where
-                * no preemption-check is necessery:
-                */
-               if ((prev == idle_task(smp_processor_id())) ||
-                                               (policy & SCHED_YIELD))
-                       goto out_unlock;
+       for (i = 0; i < smp_num_cpus; i++)
+               sum += cpu_rq(cpu_logical_map(i))->nr_switches;
 
-               spin_lock_irqsave(&runqueue_lock, flags);
-               if ((prev->state == TASK_RUNNING) && !task_has_cpu(prev))
-                       reschedule_idle(prev);
-               spin_unlock_irqrestore(&runqueue_lock, flags);
-               goto out_unlock;
+       return sum;
+}
+
+#if CONFIG_SMP
+/*
+ * Lock the busiest runqueue as well, this_rq is locked already.
+ * Recalculate nr_running if we have to drop the runqueue lock.
+ */
+static inline unsigned int double_lock_balance(runqueue_t *this_rq,
+       runqueue_t *busiest, int this_cpu, int idle, unsigned int nr_running)
+{
+       if (unlikely(!spin_trylock(&busiest->lock))) {
+               if (busiest < this_rq) {
+                       spin_unlock(&this_rq->lock);
+                       spin_lock(&busiest->lock);
+                       spin_lock(&this_rq->lock);
+                       /* Need to recalculate nr_running */
+                       if (idle || (this_rq->nr_running > this_rq->prev_nr_running[this_cpu]))
+                               nr_running = this_rq->nr_running;
+                       else
+                               nr_running = this_rq->prev_nr_running[this_cpu];
+               } else
+                       spin_lock(&busiest->lock);
        }
-#else
-       prev->policy &= ~SCHED_YIELD;
-#endif /* CONFIG_SMP */
+       return nr_running;
 }
 
-asmlinkage void schedule_tail(struct task_struct *prev)
+/*
+ * Move a task from a remote runqueue to the local runqueue.
+ * Both runqueues must be locked.
+ */
+static inline void pull_task(runqueue_t *src_rq, prio_array_t *src_array, task_t *p, runqueue_t *this_rq, int this_cpu)
 {
-       __schedule_tail(prev);
+       dequeue_task(p, src_array);
+       src_rq->nr_running--;
+       p->cpu = this_cpu;
+       this_rq->nr_running++;
+       enqueue_task(p, this_rq->active);
+       /*
+        * Note that idle threads have a prio of MAX_PRIO, for this test
+        * to be always true for them.
+        */
+       if (p->prio < this_rq->curr->prio)
+               set_need_resched();
 }
 
 /*
- *  'schedule()' is the scheduler function. It's a very simple and nice
- * scheduler: it's not perfect, but certainly works for most things.
+ * Current runqueue is empty, or rebalance tick: if there is an
+ * inbalance (current runqueue is too short) then pull from
+ * busiest runqueue(s).
  *
- * The goto is "interesting".
- *
- *   NOTE!!  Task 0 is the 'idle' task, which gets called when no other
- * tasks can run. It can not be killed, and it cannot sleep. The 'state'
- * information in task[0] is never used.
+ * We call this with the current runqueue locked,
+ * irqs disabled.
  */
-asmlinkage void schedule(void)
+static void load_balance(runqueue_t *this_rq, int idle)
 {
-       struct schedule_data * sched_data;
-       struct task_struct *prev, *next, *p;
-       struct list_head *tmp;
-       int this_cpu, c;
-
-
-       spin_lock_prefetch(&runqueue_lock);
-
-       BUG_ON(!current->active_mm);
-need_resched_back:
-       prev = current;
-       this_cpu = prev->processor;
-
-       if (unlikely(in_interrupt())) {
-               printk("Scheduling in interrupt\n");
-               BUG();
-       }
-
-       release_kernel_lock(prev, this_cpu);
+       int imbalance, nr_running, load, max_load,
+               idx, i, this_cpu = smp_processor_id();
+       task_t *tmp;
+       runqueue_t *busiest, *rq_src;
+       prio_array_t *array;
+       list_t *head, *curr;
 
        /*
-        * 'sched_data' is protected by the fact that we can run
-        * only one process per CPU.
+        * We search all runqueues to find the most busy one.
+        * We do this lockless to reduce cache-bouncing overhead,
+        * we re-check the 'best' source CPU later on again, with
+        * the lock held.
+        *
+        * We fend off statistical fluctuations in runqueue lengths by
+        * saving the runqueue length during the previous load-balancing
+        * operation and using the smaller one the current and saved lengths.
+        * If a runqueue is long enough for a longer amount of time then
+        * we recognize it and pull tasks from it.
+        *
+        * The 'current runqueue length' is a statistical maximum variable,
+        * for that one we take the longer one - to avoid fluctuations in
+        * the other direction. So for a load-balance to happen it needs
+        * stable long runqueue on the target CPU and stable short runqueue
+        * on the local runqueue.
+        *
+        * We make an exception if this CPU is about to become idle - in
+        * that case we are less picky about moving a task across CPUs and
+        * take what can be taken.
         */
-       sched_data = & aligned_data[this_cpu].schedule_data;
+       if (idle || (this_rq->nr_running > this_rq->prev_nr_running[this_cpu]))
+               nr_running = this_rq->nr_running;
+       else
+               nr_running = this_rq->prev_nr_running[this_cpu];
 
-       spin_lock_irq(&runqueue_lock);
+       busiest = NULL;
+       max_load = 1;
+       for (i = 0; i < smp_num_cpus; i++) {
+               int logical = cpu_logical_map(i);
 
-       /* move an exhausted RR process to be last.. */
-       if (unlikely(prev->policy == SCHED_RR))
-               if (!prev->counter) {
-                       prev->counter = NICE_TO_TICKS(prev->nice);
-                       move_last_runqueue(prev);
+               rq_src = cpu_rq(logical);
+               if (idle || (rq_src->nr_running < this_rq->prev_nr_running[logical]))
+                       load = rq_src->nr_running;
+               else
+                       load = this_rq->prev_nr_running[logical];
+               this_rq->prev_nr_running[logical] = rq_src->nr_running;
+
+               if ((load > max_load) && (rq_src != this_rq)) {
+                       busiest = rq_src;
+                       max_load = load;
                }
-
-       switch (prev->state) {
-               case TASK_INTERRUPTIBLE:
-                       if (signal_pending(prev)) {
-                               prev->state = TASK_RUNNING;
-                               break;
-                       }
-               default:
-                       del_from_runqueue(prev);
-               case TASK_RUNNING:;
        }
-       prev->need_resched = 0;
 
+       if (likely(!busiest))
+               return;
+
+       imbalance = (max_load - nr_running) / 2;
+
+       /* It needs an at least ~25% imbalance to trigger balancing. */
+       if (!idle && (imbalance < (max_load + 3)/4))
+               return;
+
+       nr_running = double_lock_balance(this_rq, busiest, this_cpu, idle, nr_running);
        /*
-        * this is the scheduler proper:
+        * Make sure nothing changed since we checked the
+        * runqueue length.
         */
+       if (busiest->nr_running <= nr_running + 1)
+               goto out_unlock;
 
-repeat_schedule:
        /*
-        * Default process to select..
+        * We first consider expired tasks. Those will likely not be
+        * executed in the near future, and they are most likely to
+        * be cache-cold, thus switching CPUs has the least effect
+        * on them.
         */
-       next = idle_task(this_cpu);
-       c = -1000;
-       list_for_each(tmp, &runqueue_head) {
-               p = list_entry(tmp, struct task_struct, run_list);
-               if (can_schedule(p, this_cpu)) {
-                       int weight = goodness(p, this_cpu, prev->active_mm);
-                       if (weight > c)
-                               c = weight, next = p;
+       if (busiest->expired->nr_active)
+               array = busiest->expired;
+       else
+               array = busiest->active;
+
+new_array:
+       /* Start searching at priority 0: */
+       idx = 0;
+skip_bitmap:
+       if (!idx)
+               idx = sched_find_first_bit(array->bitmap);
+       else
+               idx = find_next_bit(array->bitmap, MAX_PRIO, idx);
+       if (idx == MAX_PRIO) {
+               if (array == busiest->expired) {
+                       array = busiest->active;
+                       goto new_array;
                }
+               goto out_unlock;
        }
 
-       /* Do we need to re-calculate counters? */
-       if (unlikely(!c)) {
-               struct task_struct *p;
-
-               spin_unlock_irq(&runqueue_lock);
-               read_lock(&tasklist_lock);
-               for_each_task(p)
-                       p->counter = (p->counter >> 1) + NICE_TO_TICKS(p->nice);
-               read_unlock(&tasklist_lock);
-               spin_lock_irq(&runqueue_lock);
-               goto repeat_schedule;
+       head = array->queue + idx;
+       curr = head->prev;
+skip_queue:
+       tmp = list_entry(curr, task_t, run_list);
+
+       /*
+        * We do not migrate tasks that are:
+        * 1) running (obviously), or
+        * 2) cannot be migrated to this CPU due to cpus_allowed, or
+        * 3) are cache-hot on their current CPU.
+        */
+
+#define CAN_MIGRATE_TASK(p,rq,this_cpu)                                        \
+       ((jiffies - (p)->sleep_timestamp > cache_decay_ticks) &&        \
+               ((p) != (rq)->curr) &&                                  \
+                       ((p)->cpus_allowed & (1UL << (this_cpu))))
+
+       curr = curr->prev;
+
+       if (!CAN_MIGRATE_TASK(tmp, busiest, this_cpu)) {
+               if (curr != head)
+                       goto skip_queue;
+               idx++;
+               goto skip_bitmap;
+       }
+       pull_task(busiest, array, tmp, this_rq, this_cpu);
+       if (!idle && --imbalance) {
+               if (curr != head)
+                       goto skip_queue;
+               idx++;
+               goto skip_bitmap;
        }
+out_unlock:
+       spin_unlock(&busiest->lock);
+}
 
-       /*
-        * from this point on nothing can prevent us from
-        * switching to the next task, save this fact in
-        * sched_data.
-        */
-       sched_data->curr = next;
-       task_set_cpu(next, this_cpu);
-       spin_unlock_irq(&runqueue_lock);
+/*
+ * One of the idle_cpu_tick() or the busy_cpu_tick() function will
+ * gets called every timer tick, on every CPU. Our balancing action
+ * frequency and balancing agressivity depends on whether the CPU is
+ * idle or not.
+ *
+ * busy-rebalance every 250 msecs. idle-rebalance every 1 msec. (or on
+ * systems with HZ=100, every 10 msecs.)
+ */
+#define BUSY_REBALANCE_TICK (HZ/4 ?: 1)
+#define IDLE_REBALANCE_TICK (HZ/1000 ?: 1)
 
-       if (unlikely(prev == next)) {
-               /* We won't go through the normal tail, so do this by hand */
-               prev->policy &= ~SCHED_YIELD;
-               goto same_process;
-       }
+static inline void idle_tick(void)
+{
+       if (jiffies % IDLE_REBALANCE_TICK)
+               return;
+       spin_lock(&this_rq()->lock);
+       load_balance(this_rq(), 1);
+       spin_unlock(&this_rq()->lock);
+}
 
-#ifdef CONFIG_SMP
-       /*
-        * maintain the per-process 'last schedule' value.
-        * (this has to be recalculated even if we reschedule to
-        * the same process) Currently this is only used on SMP,
-        * and it's approximate, so we do not have to maintain
-        * it while holding the runqueue spinlock.
-        */
-       sched_data->last_schedule = get_cycles();
+#endif
+
+/*
+ * We place interactive tasks back into the active array, if possible.
+ *
+ * To guarantee that this does not starve expired tasks we ignore the
+ * interactivity of a task if the first expired task had to wait more
+ * than a 'reasonable' amount of time. This deadline timeout is
+ * load-dependent, as the frequency of array switched decreases with
+ * increasing number of running tasks:
+ */
+#define EXPIRED_STARVING(rq) \
+               ((rq)->expired_timestamp && \
+               (jiffies - (rq)->expired_timestamp >= \
+                       STARVATION_LIMIT * ((rq)->nr_running) + 1))
+
+/*
+ * This function gets called by the timer code, with HZ frequency.
+ * We call it with interrupts disabled.
+ */
+void scheduler_tick(int user_tick, int system)
+{
+       int cpu = smp_processor_id();
+       runqueue_t *rq = this_rq();
+       task_t *p = current;
+
+       if (p == rq->idle) {
+               if (local_bh_count(cpu) || local_irq_count(cpu) > 1)
+                       kstat.per_cpu_system[cpu] += system;
+#if CONFIG_SMP
+               idle_tick();
+#endif
+               return;
+       }
+       if (TASK_NICE(p) > 0)
+               kstat.per_cpu_nice[cpu] += user_tick;
+       else
+               kstat.per_cpu_user[cpu] += user_tick;
+       kstat.per_cpu_system[cpu] += system;
 
+       /* Task might have expired already, but not scheduled off yet */
+       if (p->array != rq->active) {
+               set_tsk_need_resched(p);
+               return;
+       }
+       spin_lock(&rq->lock);
+       if (unlikely(rt_task(p))) {
+               /*
+                * RR tasks need a special form of timeslice management.
+                * FIFO tasks have no timeslices.
+                */
+               if ((p->policy == SCHED_RR) && !--p->time_slice) {
+                       p->time_slice = TASK_TIMESLICE(p);
+                       p->first_time_slice = 0;
+                       set_tsk_need_resched(p);
+
+                       /* put it at the end of the queue: */
+                       dequeue_task(p, rq->active);
+                       enqueue_task(p, rq->active);
+               }
+               goto out;
+       }
        /*
-        * We drop the scheduler lock early (it's a global spinlock),
-        * thus we have to lock the previous process from getting
-        * rescheduled during switch_to().
-        */
+        * The task was running during this tick - update the
+        * time slice counter and the sleep average. Note: we
+        * do not update a process's priority until it either
+        * goes to sleep or uses up its timeslice. This makes
+        * it possible for interactive tasks to use up their
+        * timeslices at their highest priority levels.
+        */
+       if (p->sleep_avg)
+               p->sleep_avg--;
+       if (!--p->time_slice) {
+               dequeue_task(p, rq->active);
+               set_tsk_need_resched(p);
+               p->prio = effective_prio(p);
+               p->time_slice = TASK_TIMESLICE(p);
+               p->first_time_slice = 0;
+
+               if (!TASK_INTERACTIVE(p) || EXPIRED_STARVING(rq)) {
+                       if (!rq->expired_timestamp)
+                               rq->expired_timestamp = jiffies;
+                       enqueue_task(p, rq->expired);
+               } else
+                       enqueue_task(p, rq->active);
+       }
+out:
+#if CONFIG_SMP
+       if (!(jiffies % BUSY_REBALANCE_TICK))
+               load_balance(rq, 0);
+#endif
+       spin_unlock(&rq->lock);
+}
 
-#endif /* CONFIG_SMP */
+void scheduling_functions_start_here(void) { }
 
-       kstat.context_swtch++;
+/*
+ * 'schedule()' is the main scheduler function.
+ */
+asmlinkage void schedule(void)
+{
+       task_t *prev, *next;
+       runqueue_t *rq;
+       prio_array_t *array;
+       list_t *queue;
+       int idx;
+
+       if (unlikely(in_interrupt()))
+               BUG();
+
+need_resched:
+       preempt_disable();
+       prev = current;
+       rq = this_rq();
+
+       release_kernel_lock(prev, smp_processor_id());
+       prev->sleep_timestamp = jiffies;
+       spin_lock_irq(&rq->lock);
+
+#ifdef CONFIG_PREEMPT
        /*
-        * there are 3 processes which are affected by a context switch:
-        *
-        * prev == .... ==> (last => next)
-        *
-        * It's the 'much more previous' 'prev' that is on next's stack,
-        * but prev is set to (the just run) 'last' process by switch_to().
-        * This might sound slightly confusing but makes tons of sense.
+        * entering from preempt_schedule, off a kernel preemption,
+        * go straight to picking the next task.
         */
-       prepare_to_switch();
-       {
-               struct mm_struct *mm = next->mm;
-               struct mm_struct *oldmm = prev->active_mm;
-               if (!mm) {
-                       BUG_ON(next->active_mm);
-                       next->active_mm = oldmm;
-                       atomic_inc(&oldmm->mm_count);
-                       enter_lazy_tlb(oldmm, next, this_cpu);
-               } else {
-                       BUG_ON(next->active_mm != mm);
-                       switch_mm(oldmm, mm, next, this_cpu);
-               }
-
-               if (!prev->mm) {
-                       prev->active_mm = NULL;
-                       mmdrop(oldmm);
+       if (unlikely(preempt_get_count() & PREEMPT_ACTIVE))
+               goto pick_next_task;
+#endif
+       switch (prev->state) {
+       case TASK_INTERRUPTIBLE:
+               if (unlikely(signal_pending(prev))) {
+                       prev->state = TASK_RUNNING;
+                       break;
                }
+       default:
+               deactivate_task(prev, rq);
+       case TASK_RUNNING:
+               ;
+       }
+#if CONFIG_SMP || CONFIG_PREEMPT
+pick_next_task:
+#endif
+       if (unlikely(!rq->nr_running)) {
+#if CONFIG_SMP
+               load_balance(rq, 1);
+               if (rq->nr_running)
+                       goto pick_next_task;
+#endif
+               next = rq->idle;
+               rq->expired_timestamp = 0;
+               goto switch_tasks;
        }
 
+       array = rq->active;
+       if (unlikely(!array->nr_active)) {
+               /*
+                * Switch the active and expired arrays.
+                */
+               rq->active = rq->expired;
+               rq->expired = array;
+               array = rq->active;
+               rq->expired_timestamp = 0;
+       }
+
+       idx = sched_find_first_bit(array->bitmap);
+       queue = array->queue + idx;
+       next = list_entry(queue->next, task_t, run_list);
+
+switch_tasks:
+       prefetch(next);
+       clear_tsk_need_resched(prev);
+
+       if (likely(prev != next)) {
+               rq->nr_switches++;
+               rq->curr = next;
+       
+               prepare_arch_switch(rq, next);
+               prev = context_switch(prev, next);
+               barrier();
+               rq = this_rq();
+               finish_arch_switch(rq, prev);
+       } else
+               spin_unlock_irq(&rq->lock);
+
+       reacquire_kernel_lock(current);
+       preempt_enable_no_resched();
+       if (need_resched())
+               goto need_resched;
+}
+
+#ifdef CONFIG_PREEMPT
+/*
+ * this is is the entry point to schedule() from in-kernel preemption.
+ */
+asmlinkage void preempt_schedule(void)
+{
        /*
-        * This just switches the register state and the
-        * stack.
+        * Interrupts disabled implies no kernel preemption.  Just return.
         */
-       switch_to(prev, next, prev);
-       __schedule_tail(prev);
+       if (unlikely(irqs_disabled()))
+               return;
 
-same_process:
-       reacquire_kernel_lock(current);
-       if (current->need_resched)
-               goto need_resched_back;
-       return;
+need_resched:
+       current->preempt_count += PREEMPT_ACTIVE;
+       schedule();
+       current->preempt_count -= PREEMPT_ACTIVE;
+
+       /* we can miss a preemption between schedule() and now */
+       barrier();
+       if (unlikely((current->need_resched)))
+               goto need_resched;
 }
+#endif /* CONFIG_PREEMPT */
 
 /*
- * The core wakeup function.  Non-exclusive wakeups (nr_exclusive == 0) just wake everything
- * up.  If it's an exclusive wakeup (nr_exclusive == small +ve number) then we wake all the
- * non-exclusive tasks and one exclusive task.
+ * The core wakeup function.  Non-exclusive wakeups (nr_exclusive == 0) just
+ * wake everything up.  If it's an exclusive wakeup (nr_exclusive == small +ve
+ * number) then we wake all the non-exclusive tasks and one exclusive task.
  *
  * There are circumstances in which we can try to wake a task which has already
- * started to run but is not in state TASK_RUNNING.  try_to_wake_up() returns zero
- * in this (rare) case, and we handle it by contonuing to scan the queue.
+ * started to run but is not in state TASK_RUNNING.  try_to_wake_up() returns
+ * zero in this (rare) case, and we handle it by continuing to scan the queue.
  */
-static inline void __wake_up_common (wait_queue_head_t *q, unsigned int mode,
-                                    int nr_exclusive, const int sync)
+static inline void __wake_up_common(wait_queue_head_t *q, unsigned int mode, int nr_exclusive, int sync)
 {
        struct list_head *tmp;
-       struct task_struct *p;
-
-       CHECK_MAGIC_WQHEAD(q);
-       WQ_CHECK_LIST_HEAD(&q->task_list);
-       
-       list_for_each(tmp,&q->task_list) {
-               unsigned int state;
-                wait_queue_t *curr = list_entry(tmp, wait_queue_t, task_list);
+       unsigned int state;
+       wait_queue_t *curr;
+       task_t *p;
 
-               CHECK_MAGIC(curr->__magic);
+       list_for_each(tmp, &q->task_list) {
+               curr = list_entry(tmp, wait_queue_t, task_list);
                p = curr->task;
                state = p->state;
-               if (state & mode) {
-                       WQ_NOTE_WAKER(curr);
-                       if (try_to_wake_up(p, sync) && (curr->flags&WQ_FLAG_EXCLUSIVE) && !--nr_exclusive)
+               if ((state & mode) && try_to_wake_up(p, sync) &&
+                       ((curr->flags & WQ_FLAG_EXCLUSIVE) && !--nr_exclusive))
                                break;
-               }
        }
 }
 
-void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr)
+void __wake_up(wait_queue_head_t *q, unsigned int mode, int nr_exclusive)
 {
-       if (q) {
-               unsigned long flags;
-               wq_read_lock_irqsave(&q->lock, flags);
-               __wake_up_common(q, mode, nr, 0);
-               wq_read_unlock_irqrestore(&q->lock, flags);
-       }
+       unsigned long flags;
+
+       if (unlikely(!q))
+               return;
+
+       wq_read_lock_irqsave(&q->lock, flags);
+       __wake_up_common(q, mode, nr_exclusive, 0);
+       wq_read_unlock_irqrestore(&q->lock, flags);
 }
 
-void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr)
+#if CONFIG_SMP
+
+void __wake_up_sync(wait_queue_head_t *q, unsigned int mode, int nr_exclusive)
 {
-       if (q) {
-               unsigned long flags;
-               wq_read_lock_irqsave(&q->lock, flags);
-               __wake_up_common(q, mode, nr, 1);
-               wq_read_unlock_irqrestore(&q->lock, flags);
-       }
+       unsigned long flags;
+
+       if (unlikely(!q))
+               return;
+
+       wq_read_lock_irqsave(&q->lock, flags);
+       if (likely(nr_exclusive))
+               __wake_up_common(q, mode, nr_exclusive, 1);
+       else
+               __wake_up_common(q, mode, nr_exclusive, 0);
+       wq_read_unlock_irqrestore(&q->lock, flags);
 }
 
+#endif
+ 
 void complete(struct completion *x)
 {
        unsigned long flags;
 
-       spin_lock_irqsave(&x->wait.lock, flags);
+       wq_write_lock_irqsave(&x->wait.lock, flags);
        x->done++;
        __wake_up_common(&x->wait, TASK_UNINTERRUPTIBLE | TASK_INTERRUPTIBLE, 1, 0);
-       spin_unlock_irqrestore(&x->wait.lock, flags);
+       wq_write_unlock_irqrestore(&x->wait.lock, flags);
 }
 
 void wait_for_completion(struct completion *x)
 {
-       spin_lock_irq(&x->wait.lock);
+       wq_write_lock_irq(&x->wait.lock);
        if (!x->done) {
                DECLARE_WAITQUEUE(wait, current);
 
@@ -775,14 +986,14 @@
                __add_wait_queue_tail(&x->wait, &wait);
                do {
                        __set_current_state(TASK_UNINTERRUPTIBLE);
-                       spin_unlock_irq(&x->wait.lock);
+                       wq_write_unlock_irq(&x->wait.lock);
                        schedule();
-                       spin_lock_irq(&x->wait.lock);
+                       wq_write_lock_irq(&x->wait.lock);
                } while (!x->done);
                __remove_wait_queue(&x->wait, &wait);
        }
        x->done--;
-       spin_unlock_irq(&x->wait.lock);
+       wq_write_unlock_irq(&x->wait.lock);
 }
 
 #define        SLEEP_ON_VAR                            \
@@ -850,6 +1061,41 @@
 
 void scheduling_functions_end_here(void) { }
 
+void set_user_nice(task_t *p, long nice)
+{
+       unsigned long flags;
+       prio_array_t *array;
+       runqueue_t *rq;
+
+       if (TASK_NICE(p) == nice || nice < -20 || nice > 19)
+               return;
+       /*
+        * We have to be careful, if called from sys_setpriority(),
+        * the task might be in the middle of scheduling on another CPU.
+        */
+       rq = task_rq_lock(p, &flags);
+       if (rt_task(p)) {
+               p->static_prio = NICE_TO_PRIO(nice);
+               goto out_unlock;
+       }
+       array = p->array;
+       if (array)
+               dequeue_task(p, array);
+       p->static_prio = NICE_TO_PRIO(nice);
+       p->prio = NICE_TO_PRIO(nice);
+       if (array) {
+               enqueue_task(p, array);
+               /*
+                * If the task is running and lowered its priority,
+                * or increased its priority then reschedule its CPU:
+                */
+               if ((NICE_TO_PRIO(nice) < p->static_prio) || (p == rq->curr))
+                       resched_task(rq->curr);
+       }
+out_unlock:
+       task_rq_unlock(rq, &flags);
+}
+
 #ifndef __alpha__
 
 /*
@@ -860,7 +1106,7 @@
 
 asmlinkage long sys_nice(int increment)
 {
-       long newprio;
+       long nice;
 
        /*
         *      Setpriority might change our priority at the same moment.
@@ -876,32 +1122,51 @@
        if (increment > 40)
                increment = 40;
 
-       newprio = current->nice + increment;
-       if (newprio < -20)
-               newprio = -20;
-       if (newprio > 19)
-               newprio = 19;
-       current->nice = newprio;
+       nice = PRIO_TO_NICE(current->static_prio) + increment;
+       if (nice < -20)
+               nice = -20;
+       if (nice > 19)
+               nice = 19;
+       set_user_nice(current, nice);
        return 0;
 }
 
 #endif
 
-static inline struct task_struct *find_process_by_pid(pid_t pid)
+/*
+ * This is the priority value as seen by users in /proc
+ *
+ * RT tasks are offset by -200. Normal tasks are centered
+ * around 0, value goes from -16 to +15.
+ */
+int task_prio(task_t *p)
+{
+       return p->prio - MAX_USER_RT_PRIO;
+}
+
+int task_nice(task_t *p)
 {
-       struct task_struct *tsk = current;
+       return TASK_NICE(p);
+}
 
-       if (pid)
-               tsk = find_task_by_pid(pid);
-       return tsk;
+int idle_cpu(int cpu)
+{
+       return cpu_curr(cpu) == cpu_rq(cpu)->idle;
 }
 
-static int setscheduler(pid_t pid, int policy, 
-                       struct sched_param *param)
+static inline task_t *find_process_by_pid(pid_t pid)
+{
+       return pid ? find_task_by_pid(pid) : current;
+}
+
+static int setscheduler(pid_t pid, int policy, struct sched_param *param)
 {
        struct sched_param lp;
-       struct task_struct *p;
+       prio_array_t *array;
+       unsigned long flags;
+       runqueue_t *rq;
        int retval;
+       task_t *p;
 
        retval = -EINVAL;
        if (!param || pid < 0)
@@ -915,14 +1180,19 @@
         * We play safe to avoid deadlocks.
         */
        read_lock_irq(&tasklist_lock);
-       spin_lock(&runqueue_lock);
 
        p = find_process_by_pid(pid);
 
        retval = -ESRCH;
        if (!p)
-               goto out_unlock;
-                       
+               goto out_unlock_tasklist;
+
+       /*
+        * To be able to change p->policy safely, the apropriate
+        * runqueue lock must be held.
+        */
+       rq = task_rq_lock(p, &flags);
+
        if (policy < 0)
                policy = p->policy;
        else {
@@ -931,40 +1201,48 @@
                                policy != SCHED_OTHER)
                        goto out_unlock;
        }
-       
+
        /*
-        * Valid priorities for SCHED_FIFO and SCHED_RR are 1..99, valid
-        * priority for SCHED_OTHER is 0.
+        * Valid priorities for SCHED_FIFO and SCHED_RR are
+        * 1..MAX_USER_RT_PRIO-1, valid priority for SCHED_OTHER is 0.
         */
        retval = -EINVAL;
-       if (lp.sched_priority < 0 || lp.sched_priority > 99)
+       if (lp.sched_priority < 0 || lp.sched_priority > MAX_USER_RT_PRIO-1)
                goto out_unlock;
        if ((policy == SCHED_OTHER) != (lp.sched_priority == 0))
                goto out_unlock;
 
        retval = -EPERM;
-       if ((policy == SCHED_FIFO || policy == SCHED_RR) && 
+       if ((policy == SCHED_FIFO || policy == SCHED_RR) &&
            !capable(CAP_SYS_NICE))
                goto out_unlock;
        if ((current->euid != p->euid) && (current->euid != p->uid) &&
            !capable(CAP_SYS_NICE))
                goto out_unlock;
 
+       array = p->array;
+       if (array)
+               deactivate_task(p, task_rq(p));
        retval = 0;
        p->policy = policy;
        p->rt_priority = lp.sched_priority;
-
-       current->need_resched = 1;
+       if (policy != SCHED_OTHER)
+               p->prio = MAX_USER_RT_PRIO-1 - p->rt_priority;
+       else
+               p->prio = p->static_prio;
+       if (array)
+               activate_task(p, task_rq(p));
 
 out_unlock:
-       spin_unlock(&runqueue_lock);
+       task_rq_unlock(rq, &flags);
+out_unlock_tasklist:
        read_unlock_irq(&tasklist_lock);
 
 out_nounlock:
        return retval;
 }
 
-asmlinkage long sys_sched_setscheduler(pid_t pid, int policy, 
+asmlinkage long sys_sched_setscheduler(pid_t pid, int policy,
                                      struct sched_param *param)
 {
        return setscheduler(pid, policy, param);
@@ -977,7 +1255,7 @@
 
 asmlinkage long sys_sched_getscheduler(pid_t pid)
 {
-       struct task_struct *p;
+       task_t *p;
        int retval;
 
        retval = -EINVAL;
@@ -988,16 +1266,107 @@
        read_lock(&tasklist_lock);
        p = find_process_by_pid(pid);
        if (p)
-               retval = p->policy & ~SCHED_YIELD;
+               retval = p->policy;
        read_unlock(&tasklist_lock);
 
 out_nounlock:
        return retval;
 }
 
+/**
+ * sys_sched_setaffinity - set the cpu affinity of a process
+ * @pid: pid of the process
+ * @len: length in bytes of the bitmask pointed to by user_mask_ptr
+ * @user_mask_ptr: user-space pointer to the new cpu mask
+ */
+asmlinkage int sys_sched_setaffinity(pid_t pid, unsigned int len,
+                                    unsigned long *user_mask_ptr)
+{
+       unsigned long new_mask;
+       task_t *p;
+       int retval;
+
+       if (len < sizeof(new_mask))
+               return -EINVAL;
+
+       if (copy_from_user(&new_mask, user_mask_ptr, sizeof(new_mask)))
+               return -EFAULT;
+
+       new_mask &= cpu_online_map;
+       if (!new_mask)
+               return -EINVAL;
+
+       /*
+        * We cannot hold a lock across a call to set_cpus_allowed, however
+        * we need to assure our task does not slip out from under us.  Since
+        * we are only concerned that its task_struct remains, we can pin it
+        * here and decrement the usage count when we are done.
+        */
+       read_lock(&tasklist_lock);
+
+       p = find_process_by_pid(pid);
+       if (!p) {
+               read_unlock(&tasklist_lock);
+               return -ESRCH;
+       }
+
+       get_task_struct(p);
+       read_unlock(&tasklist_lock);
+
+       retval = -EPERM;
+       if ((current->euid != p->euid) && (current->euid != p->uid) &&
+                       !capable(CAP_SYS_NICE))
+               goto out_unlock;
+
+       retval = 0;
+       set_cpus_allowed(p, new_mask);
+
+out_unlock:
+       free_task_struct(p);
+       return retval;
+}
+
+/**
+ * sys_sched_getaffinity - get the cpu affinity of a process
+ * @pid: pid of the process
+ * @len: length in bytes of the bitmask pointed to by user_mask_ptr
+ * @user_mask_ptr: user-space pointer to hold the current cpu mask
+ */
+asmlinkage int sys_sched_getaffinity(pid_t pid, unsigned int len,
+                                    unsigned long *user_mask_ptr)
+{
+       unsigned long mask;
+       unsigned int real_len;
+       task_t *p;
+       int retval;
+
+       real_len = sizeof(mask);
+
+       if (len < real_len)
+               return -EINVAL;
+
+       read_lock(&tasklist_lock);
+
+       retval = -ESRCH;
+       p = find_process_by_pid(pid);
+       if (!p)
+               goto out_unlock;
+
+       retval = 0;
+       mask = p->cpus_allowed & cpu_online_map;
+
+out_unlock:
+       read_unlock(&tasklist_lock);
+       if (retval)
+               return retval;
+       if (copy_to_user(user_mask_ptr, &mask, real_len))
+               return -EFAULT;
+       return real_len;
+}
+
 asmlinkage long sys_sched_getparam(pid_t pid, struct sched_param *param)
 {
-       struct task_struct *p;
+       task_t *p;
        struct sched_param lp;
        int retval;
 
@@ -1028,42 +1397,43 @@
 
 asmlinkage long sys_sched_yield(void)
 {
-       /*
-        * Trick. sched_yield() first counts the number of truly 
-        * 'pending' runnable processes, then returns if it's
-        * only the current processes. (This test does not have
-        * to be atomic.) In threaded applications this optimization
-        * gets triggered quite often.
-        */
-
-       int nr_pending = nr_running;
-
-#if CONFIG_SMP
+       runqueue_t *rq;
+       prio_array_t *array = current->array;
        int i;
 
-       // Subtract non-idle processes running on other CPUs.
-       for (i = 0; i < smp_num_cpus; i++) {
-               int cpu = cpu_logical_map(i);
-               if (aligned_data[cpu].schedule_data.curr != idle_task(cpu))
-                       nr_pending--;
+       preempt_disable();
+       rq = this_rq();
+       spin_lock_irq(&rq->lock);
+       
+       if (unlikely(rt_task(current))) {
+               list_del(&current->run_list);
+               list_add_tail(&current->run_list, array->queue + current->prio);
+               goto out_unlock;
        }
-#else
-       // on UP this process is on the runqueue as well
-       nr_pending--;
-#endif
-       if (nr_pending) {
-               /*
-                * This process can only be rescheduled by us,
-                * so this is safe without any locking.
-                */
-               if (current->policy == SCHED_OTHER)
-                       current->policy |= SCHED_YIELD;
-               current->need_resched = 1;
-
-               spin_lock_irq(&runqueue_lock);
-               move_last_runqueue(current);
-               spin_unlock_irq(&runqueue_lock);
+
+       list_del(&current->run_list);
+       if (!list_empty(array->queue + current->prio)) {
+               list_add(&current->run_list, array->queue[current->prio].next);
+               goto out_unlock;
        }
+       __clear_bit(current->prio, array->bitmap);
+
+       i = sched_find_first_bit(array->bitmap);
+
+       if (i == MAX_PRIO || i <= current->prio)
+               i = current->prio;
+       else
+               current->prio = i;
+
+       list_add(&current->run_list, array->queue[i].next);
+       __set_bit(i, array->bitmap);
+
+out_unlock:
+       spin_unlock_irq(&rq->lock);
+       preempt_enable_no_resched();
+
+       schedule();
+
        return 0;
 }
 
@@ -1075,14 +1445,13 @@
  */
 void yield(void)
 {
-       set_current_state(TASK_RUNNING);
+       __set_current_state(TASK_RUNNING);
        sys_sched_yield();
-       schedule();
 }
 
 void __cond_resched(void)
 {
-       set_current_state(TASK_RUNNING);
+       __set_current_state(TASK_RUNNING);
        schedule();
 }
 
@@ -1093,7 +1462,7 @@
        switch (policy) {
        case SCHED_FIFO:
        case SCHED_RR:
-               ret = 99;
+               ret = MAX_USER_RT_PRIO-1;
                break;
        case SCHED_OTHER:
                ret = 0;
@@ -1120,7 +1489,7 @@
 asmlinkage long sys_sched_rr_get_interval(pid_t pid, struct timespec *interval)
 {
        struct timespec t;
-       struct task_struct *p;
+       task_t *p;
        int retval = -EINVAL;
 
        if (pid < 0)
@@ -1130,8 +1499,8 @@
        read_lock(&tasklist_lock);
        p = find_process_by_pid(pid);
        if (p)
-               jiffies_to_timespec(p->policy & SCHED_FIFO ? 0 : NICE_TO_TICKS(p->nice),
-                                   &t);
+               jiffies_to_timespec(p->policy & SCHED_FIFO ?
+                                        0 : TASK_TIMESLICE(p), &t);
        read_unlock(&tasklist_lock);
        if (p)
                retval = copy_to_user(interval, &t, sizeof(t)) ? -EFAULT : 0;
@@ -1139,14 +1508,14 @@
        return retval;
 }
 
-static void show_task(struct task_struct * p)
+static void show_task(task_t * p)
 {
        unsigned long free = 0;
        int state;
        static const char * stat_nam[] = { "R", "S", "D", "Z", "T", "W" };
 
        printk("%-13.13s ", p->comm);
-       state = p->state ? ffz(~p->state) + 1 : 0;
+       state = p->state ? __ffs(p->state) + 1 : 0;
        if (((unsigned) state) < sizeof(stat_nam)/sizeof(char *))
                printk(stat_nam[state]);
        else
@@ -1187,7 +1556,7 @@
                printk(" (NOTLB)\n");
 
        {
-               extern void show_trace_task(struct task_struct *tsk);
+               extern void show_trace_task(task_t *tsk);
                show_trace_task(p);
        }
 }
@@ -1209,7 +1578,7 @@
 
 void show_state(void)
 {
-       struct task_struct *p;
+       task_t *p;
 
 #if (BITS_PER_LONG == 32)
        printk("\n"
@@ -1232,128 +1601,283 @@
        read_unlock(&tasklist_lock);
 }
 
-/**
- * reparent_to_init() - Reparent the calling kernel thread to the init task.
- *
- * If a kernel thread is launched as a result of a system call, or if
- * it ever exits, it should generally reparent itself to init so that
- * it is correctly cleaned up on exit.
+/*
+ * double_rq_lock - safely lock two runqueues
  *
- * The various task state such as scheduling policy and priority may have
- * been inherited fro a user process, so we reset them to sane values here.
+ * Note this does not disable interrupts like task_rq_lock,
+ * you need to do so manually before calling.
+ */
+static inline void double_rq_lock(runqueue_t *rq1, runqueue_t *rq2)
+{
+       if (rq1 == rq2)
+               spin_lock(&rq1->lock);
+       else {
+               if (rq1 < rq2) {
+                       spin_lock(&rq1->lock);
+                       spin_lock(&rq2->lock);
+               } else {
+                       spin_lock(&rq2->lock);
+                       spin_lock(&rq1->lock);
+               }
+       }
+}
+
+/*
+ * double_rq_unlock - safely unlock two runqueues
  *
- * NOTE that reparent_to_init() gives the caller full capabilities.
+ * Note this does not restore interrupts like task_rq_unlock,
+ * you need to do so manually after calling.
  */
-void reparent_to_init(void)
+static inline void double_rq_unlock(runqueue_t *rq1, runqueue_t *rq2)
 {
-       struct task_struct *this_task = current;
+       spin_unlock(&rq1->lock);
+       if (rq1 != rq2)
+               spin_unlock(&rq2->lock);
+}
+
+void __init init_idle(task_t *idle, int cpu)
+{
+       runqueue_t *idle_rq = cpu_rq(cpu), *rq = cpu_rq(idle->cpu);
+       unsigned long flags;
 
-       write_lock_irq(&tasklist_lock);
+       __save_flags(flags);
+       __cli();
+       double_rq_lock(idle_rq, rq);
+
+       idle_rq->curr = idle_rq->idle = idle;
+       deactivate_task(idle, rq);
+       idle->array = NULL;
+       idle->prio = MAX_PRIO;
+       idle->state = TASK_RUNNING;
+       idle->cpu = cpu;
+       double_rq_unlock(idle_rq, rq);
+       set_tsk_need_resched(idle);
+       __restore_flags(flags);
 
-       /* Reparent to init */
-       REMOVE_LINKS(this_task);
-       this_task->p_pptr = child_reaper;
-       this_task->p_opptr = child_reaper;
-       SET_LINKS(this_task);
+       /* Set the preempt count _outside_ the spinlocks! */
+       idle->preempt_count = (idle->lock_depth >= 0);
+}
+
+extern void init_timervecs(void);
+extern void timer_bh(void);
+extern void tqueue_bh(void);
+extern void immediate_bh(void);
+
+void __init sched_init(void)
+{
+       runqueue_t *rq;
+       int i, j, k;
 
-       /* Set the exit signal to SIGCHLD so we signal init on exit */
-       this_task->exit_signal = SIGCHLD;
+       for (i = 0; i < NR_CPUS; i++) {
+               prio_array_t *array;
 
-       /* We also take the runqueue_lock while altering task fields
-        * which affect scheduling decisions */
-       spin_lock(&runqueue_lock);
+               rq = cpu_rq(i);
+               rq->active = rq->arrays;
+               rq->expired = rq->arrays + 1;
+               spin_lock_init(&rq->lock);
+               INIT_LIST_HEAD(&rq->migration_queue);
+
+               for (j = 0; j < 2; j++) {
+                       array = rq->arrays + j;
+                       for (k = 0; k < MAX_PRIO; k++) {
+                               INIT_LIST_HEAD(array->queue + k);
+                               __clear_bit(k, array->bitmap);
+                       }
+                       // delimiter for bitsearch
+                       __set_bit(MAX_PRIO, array->bitmap);
+               }
+       }
+       /*
+        * We have to do a little magic to get the first
+        * process right in SMP mode.
+        */
+       rq = this_rq();
+       rq->curr = current;
+       rq->idle = current;
+       current->cpu = smp_processor_id();
+       wake_up_process(current);
 
-       this_task->ptrace = 0;
-       this_task->nice = DEF_NICE;
-       this_task->policy = SCHED_OTHER;
-       /* cpus_allowed? */
-       /* rt_priority? */
-       /* signals? */
-       this_task->cap_effective = CAP_INIT_EFF_SET;
-       this_task->cap_inheritable = CAP_INIT_INH_SET;
-       this_task->cap_permitted = CAP_FULL_SET;
-       this_task->keep_capabilities = 0;
-       memcpy(this_task->rlim, init_task.rlim, sizeof(*(this_task->rlim)));
-       this_task->user = INIT_USER;
+       init_timervecs();
+       init_bh(TIMER_BH, timer_bh);
+       init_bh(TQUEUE_BH, tqueue_bh);
+       init_bh(IMMEDIATE_BH, immediate_bh);
 
-       spin_unlock(&runqueue_lock);
-       write_unlock_irq(&tasklist_lock);
+       /*
+        * The boot idle thread does lazy MMU switching as well:
+        */
+       atomic_inc(&init_mm.mm_count);
+       enter_lazy_tlb(&init_mm, current, smp_processor_id());
 }
 
+#if CONFIG_SMP
+
 /*
- *     Put all the gunge required to become a kernel thread without
- *     attached user resources in one place where it belongs.
+ * This is how migration works:
+ *
+ * 1) we queue a migration_req_t structure in the source CPU's
+ *    runqueue and wake up that CPU's migration thread.
+ * 2) we down() the locked semaphore => thread blocks.
+ * 3) migration thread wakes up (implicitly it forces the migrated
+ *    thread off the CPU)
+ * 4) it gets the migration request and checks whether the migrated
+ *    task is still in the wrong runqueue.
+ * 5) if it's in the wrong runqueue then the migration thread removes
+ *    it and puts it into the right queue.
+ * 6) migration thread up()s the semaphore.
+ * 7) we wake up and the migration is done.
  */
 
-void daemonize(void)
+typedef struct {
+       list_t list;
+       task_t *task;
+       struct completion done;
+} migration_req_t;
+
+/*
+ * Change a given task's CPU affinity. Migrate the process to a
+ * proper CPU and schedule it away if the CPU it's executing on
+ * is removed from the allowed bitmask.
+ *
+ * NOTE: the caller must have a valid reference to the task, the
+ * task must not exit() & deallocate itself prematurely.  The
+ * call is not atomic; no spinlocks may be held.
+ */
+void set_cpus_allowed(task_t *p, unsigned long new_mask)
 {
-       struct fs_struct *fs;
+       unsigned long flags;
+       migration_req_t req;
+       runqueue_t *rq;
 
+       new_mask &= cpu_online_map;
+       if (!new_mask)
+               BUG();
 
+       preempt_disable();
+       rq = task_rq_lock(p, &flags);
+       p->cpus_allowed = new_mask;
        /*
-        * If we were started as result of loading a module, close all of the
-        * user space pages.  We don't need them, and if we didn't close them
-        * they would be locked into memory.
+        * Can the task run on the task's current CPU? If not then
+        * migrate the process off to a proper CPU.
         */
-       exit_mm(current);
+       if (new_mask & (1UL << p->cpu)) {
+               task_rq_unlock(rq, &flags);
+               return;
+       }
 
-       current->session = 1;
-       current->pgrp = 1;
-       current->tty = NULL;
+       /*
+        * If the task is not on a runqueue, then it is safe to
+        * simply update the task's cpu field.
+        */
+       if (!p->array && (p != rq->curr)) {
+               p->cpu = __ffs(p->cpus_allowed);
+               task_rq_unlock(rq, &flags);
+               return;
+       }
 
-       /* Become as one with the init task */
+       init_completion(&req.done);
+       req.task = p;
+       list_add(&req.list, &rq->migration_queue);
+       task_rq_unlock(rq, &flags);
+       wake_up_process(rq->migration_thread);
 
-       exit_fs(current);       /* current->fs->count--; */
-       fs = init_task.fs;
-       current->fs = fs;
-       atomic_inc(&fs->count);
-       exit_files(current);
-       current->files = init_task.files;
-       atomic_inc(&current->files->count);
+       wait_for_completion(&req.done);
+       preempt_enable();
 }
 
-extern unsigned long wait_init_idle;
+static __initdata int master_migration_thread;
 
-void __init init_idle(void)
+static int migration_thread(void * bind_cpu)
 {
-       struct schedule_data * sched_data;
-       sched_data = &aligned_data[smp_processor_id()].schedule_data;
+       int cpu = cpu_logical_map((int) (long) bind_cpu);
+       struct sched_param param = { sched_priority: MAX_RT_PRIO-1 };
+       runqueue_t *rq;
+       int ret;
 
-       if (current != &init_task && task_on_runqueue(current)) {
-               printk("UGH! (%d:%d) was on the runqueue, removing.\n",
-                       smp_processor_id(), current->pid);
-               del_from_runqueue(current);
+       daemonize();
+       sigfillset(&current->blocked);
+       set_fs(KERNEL_DS);
+       /*
+        * The first migration thread is started on the boot CPU, it
+        * migrates the other migration threads to their destination CPUs.
+        */
+       if (cpu != master_migration_thread) {
+               while (!cpu_rq(master_migration_thread)->migration_thread)
+                       yield();
+               set_cpus_allowed(current, 1UL << cpu);
        }
-       sched_data->curr = current;
-       sched_data->last_schedule = get_cycles();
-       clear_bit(current->processor, &wait_init_idle);
-}
+       printk("migration_task %d on cpu=%d\n", cpu, smp_processor_id());
+       ret = setscheduler(0, SCHED_FIFO, &param);
 
-extern void init_timervecs (void);
+       rq = this_rq();
+       rq->migration_thread = current;
 
-void __init sched_init(void)
-{
-       /*
-        * We have to do a little magic to get the first
-        * process right in SMP mode.
-        */
-       int cpu = smp_processor_id();
-       int nr;
+       sprintf(current->comm, "migration_CPU%d", smp_processor_id());
 
-       init_task.processor = cpu;
+       for (;;) {
+               runqueue_t *rq_src, *rq_dest;
+               struct list_head *head;
+               int cpu_src, cpu_dest;
+               migration_req_t *req;
+               unsigned long flags;
+               task_t *p;
 
-       for(nr = 0; nr < PIDHASH_SZ; nr++)
-               pidhash[nr] = NULL;
+               spin_lock_irqsave(&rq->lock, flags);
+               head = &rq->migration_queue;
+               current->state = TASK_INTERRUPTIBLE;
+               if (list_empty(head)) {
+                       spin_unlock_irqrestore(&rq->lock, flags);
+                       schedule();
+                       continue;
+               }
+               req = list_entry(head->next, migration_req_t, list);
+               list_del_init(head->next);
+               spin_unlock_irqrestore(&rq->lock, flags);
+
+               p = req->task;
+               cpu_dest = __ffs(p->cpus_allowed);
+               rq_dest = cpu_rq(cpu_dest);
+repeat:
+               cpu_src = p->cpu;
+               rq_src = cpu_rq(cpu_src);
+
+               local_irq_save(flags);
+               double_rq_lock(rq_src, rq_dest);
+               if (p->cpu != cpu_src) {
+                       double_rq_unlock(rq_src, rq_dest);
+                       local_irq_restore(flags);
+                       goto repeat;
+               }
+               if (rq_src == rq) {
+                       p->cpu = cpu_dest;
+                       if (p->array) {
+                               deactivate_task(p, rq_src);
+                               activate_task(p, rq_dest);
+                       }
+               }
+               double_rq_unlock(rq_src, rq_dest);
+               local_irq_restore(flags);
 
-       init_timervecs();
+               complete(&req->done);
+       }
+}
 
-       init_bh(TIMER_BH, timer_bh);
-       init_bh(TQUEUE_BH, tqueue_bh);
-       init_bh(IMMEDIATE_BH, immediate_bh);
+void __init migration_init(void)
+{
+       int cpu;
 
-       /*
-        * The boot idle thread does lazy MMU switching as well:
-        */
-       atomic_inc(&init_mm.mm_count);
-       enter_lazy_tlb(&init_mm, current, cpu);
+       master_migration_thread = smp_processor_id();
+       current->cpus_allowed = 1UL << master_migration_thread;
+
+       for (cpu = 0; cpu < smp_num_cpus; cpu++) {
+               if (kernel_thread(migration_thread, (void *) (long) cpu,
+                               CLONE_FS | CLONE_FILES | CLONE_SIGNAL) < 0)
+                       BUG();
+       }
+       current->cpus_allowed = -1L;
+
+       for (cpu = 0; cpu < smp_num_cpus; cpu++)
+               while (!cpu_rq(cpu_logical_map(cpu))->migration_thread)
+                       schedule_timeout(2);
 }
+
+#endif /* CONFIG_SMP */
diff -urN linux-2.4.20/kernel/signal.c linux-2.4.20-o1-preempt/kernel/signal.c
--- linux-2.4.20/kernel/signal.c        Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/kernel/signal.c     Tue Feb 18 03:51:30 2003
@@ -490,12 +490,9 @@
         * process of changing - but no harm is done by that
         * other than doing an extra (lightweight) IPI interrupt.
         */
-       spin_lock(&runqueue_lock);
-       if (task_has_cpu(t) && t->processor != smp_processor_id())
-               smp_send_reschedule(t->processor);
-       spin_unlock(&runqueue_lock);
-#endif /* CONFIG_SMP */
-
+       if ((t->state == TASK_RUNNING) && (t->cpu != cpu()))
+               kick_if_running(t);
+#endif
        if (t->state & TASK_INTERRUPTIBLE) {
                wake_up_process(t);
                return;
diff -urN linux-2.4.20/kernel/softirq.c linux-2.4.20-o1-preempt/kernel/softirq.c
--- linux-2.4.20/kernel/softirq.c       Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/kernel/softirq.c    Tue Feb 18 03:51:30 2003
@@ -364,13 +364,13 @@
        int cpu = cpu_logical_map(bind_cpu);
 
        daemonize();
-       current->nice = 19;
+       set_user_nice(current, 19);
        sigfillset(&current->blocked);
 
        /* Migrate to the right CPU */
-       current->cpus_allowed = 1UL << cpu;
-       while (smp_processor_id() != cpu)
-               schedule();
+       set_cpus_allowed(current, 1UL << cpu);
+       if (cpu() != cpu)
+               BUG();
 
        sprintf(current->comm, "ksoftirqd_CPU%d", bind_cpu);
 
@@ -395,7 +395,7 @@
        }
 }
 
-static __init int spawn_ksoftirqd(void)
+__init int spawn_ksoftirqd(void)
 {
        int cpu;
 
diff -urN linux-2.4.20/kernel/sys.c linux-2.4.20-o1-preempt/kernel/sys.c
--- linux-2.4.20/kernel/sys.c   Sat Aug  3 02:39:46 2002
+++ linux-2.4.20-o1-preempt/kernel/sys.c        Tue Feb 18 03:51:30 2003
@@ -220,10 +220,10 @@
                }
                if (error == -ESRCH)
                        error = 0;
-               if (niceval < p->nice && !capable(CAP_SYS_NICE))
+               if (niceval < task_nice(p) && !capable(CAP_SYS_NICE))
                        error = -EACCES;
                else
-                       p->nice = niceval;
+                       set_user_nice(p, niceval);
        }
        read_unlock(&tasklist_lock);
 
@@ -249,7 +249,7 @@
                long niceval;
                if (!proc_sel(p, which, who))
                        continue;
-               niceval = 20 - p->nice;
+               niceval = 20 - task_nice(p);
                if (niceval > retval)
                        retval = niceval;
        }
diff -urN linux-2.4.20/kernel/timer.c linux-2.4.20-o1-preempt/kernel/timer.c
--- linux-2.4.20/kernel/timer.c Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/kernel/timer.c      Tue Feb 18 03:51:30 2003
@@ -25,6 +25,8 @@
 
 #include <asm/uaccess.h>
 
+struct kernel_stat kstat;
+
 /*
  * Timekeeping variables
  */
@@ -598,25 +600,7 @@
        int cpu = smp_processor_id(), system = user_tick ^ 1;
 
        update_one_process(p, user_tick, system, cpu);
-       if (p->pid) {
-               if (--p->counter <= 0) {
-                       p->counter = 0;
-                       /*
-                        * SCHED_FIFO is priority preemption, so this is 
-                        * not the place to decide whether to reschedule a
-                        * SCHED_FIFO task or not - Bhavesh Davda
-                        */
-                       if (p->policy != SCHED_FIFO) {
-                               p->need_resched = 1;
-                       }
-               }
-               if (p->nice > 0)
-                       kstat.per_cpu_nice[cpu] += user_tick;
-               else
-                       kstat.per_cpu_user[cpu] += user_tick;
-               kstat.per_cpu_system[cpu] += system;
-       } else if (local_bh_count(cpu) || local_irq_count(cpu) > 1)
-               kstat.per_cpu_system[cpu] += system;
+       scheduler_tick(user_tick, system);
 }
 
 /*
@@ -624,17 +608,7 @@
  */
 static unsigned long count_active_tasks(void)
 {
-       struct task_struct *p;
-       unsigned long nr = 0;
-
-       read_lock(&tasklist_lock);
-       for_each_task(p) {
-               if ((p->state == TASK_RUNNING ||
-                    (p->state & TASK_UNINTERRUPTIBLE)))
-                       nr += FIXED_1;
-       }
-       read_unlock(&tasklist_lock);
-       return nr;
+       return (nr_running() + nr_uninterruptible()) * FIXED_1;
 }
 
 /*
@@ -827,6 +801,89 @@
 
 #endif
 
+static void process_timeout(unsigned long __data)
+{
+       wake_up_process((task_t *)__data);
+}
+
+/**
+ * schedule_timeout - sleep until timeout
+ * @timeout: timeout value in jiffies
+ *
+ * Make the current task sleep until @timeout jiffies have
+ * elapsed. The routine will return immediately unless
+ * the current task state has been set (see set_current_state()).
+ *
+ * You can set the task state as follows -
+ *
+ * %TASK_UNINTERRUPTIBLE - at least @timeout jiffies are guaranteed to
+ * pass before the routine returns. The routine will return 0
+ *
+ * %TASK_INTERRUPTIBLE - the routine may return early if a signal is
+ * delivered to the current task. In this case the remaining time
+ * in jiffies will be returned, or 0 if the timer expired in time
+ *
+ * The current task state is guaranteed to be TASK_RUNNING when this 
+ * routine returns.
+ *
+ * Specifying a @timeout value of %MAX_SCHEDULE_TIMEOUT will schedule
+ * the CPU away without a bound on the timeout. In this case the return
+ * value will be %MAX_SCHEDULE_TIMEOUT.
+ *
+ * In all cases the return value is guaranteed to be non-negative.
+ */
+signed long schedule_timeout(signed long timeout)
+{
+       struct timer_list timer;
+       unsigned long expire;
+
+       switch (timeout)
+       {
+       case MAX_SCHEDULE_TIMEOUT:
+               /*
+                * These two special cases are useful to be comfortable
+                * in the caller. Nothing more. We could take
+                * MAX_SCHEDULE_TIMEOUT from one of the negative value
+                * but I' d like to return a valid offset (>=0) to allow
+                * the caller to do everything it want with the retval.
+                */
+               schedule();
+               goto out;
+       default:
+               /*
+                * Another bit of PARANOID. Note that the retval will be
+                * 0 since no piece of kernel is supposed to do a check
+                * for a negative retval of schedule_timeout() (since it
+                * should never happens anyway). You just have the printk()
+                * that will tell you if something is gone wrong and where.
+                */
+               if (timeout < 0)
+               {
+                       printk(KERN_ERR "schedule_timeout: wrong timeout "
+                              "value %lx from %p\n", timeout,
+                              __builtin_return_address(0));
+                       current->state = TASK_RUNNING;
+                       goto out;
+               }
+       }
+
+       expire = timeout + jiffies;
+
+       init_timer(&timer);
+       timer.expires = expire;
+       timer.data = (unsigned long) current;
+       timer.function = process_timeout;
+
+       add_timer(&timer);
+       schedule();
+       del_timer_sync(&timer);
+
+       timeout = expire - jiffies;
+
+ out:
+       return timeout < 0 ? 0 : timeout;
+}
+
 /* Thread ID - the internal kernel "pid" */
 asmlinkage long sys_gettid(void)
 {
@@ -873,4 +930,3 @@
        }
        return 0;
 }
-
diff -urN linux-2.4.20/lib/dec_and_lock.c linux-2.4.20-o1-preempt/lib/dec_and_lock.c
--- linux-2.4.20/lib/dec_and_lock.c     Wed Oct  3 18:11:26 2001
+++ linux-2.4.20-o1-preempt/lib/dec_and_lock.c  Tue Feb 18 03:52:06 2003
@@ -1,5 +1,6 @@
 #include <linux/module.h>
 #include <linux/spinlock.h>
+#include <linux/sched.h>
 #include <asm/atomic.h>
 
 /*
diff -urN linux-2.4.20/mm/oom_kill.c linux-2.4.20-o1-preempt/mm/oom_kill.c
--- linux-2.4.20/mm/oom_kill.c  Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/mm/oom_kill.c       Tue Feb 18 03:51:30 2003
@@ -82,7 +82,7 @@
         * Niced processes are most likely less important, so double
         * their badness points.
         */
-       if (p->nice > 0)
+       if (task_nice(p) > 0)
                points *= 2;
 
        /*
@@ -146,7 +146,7 @@
         * all the memory it needs. That way it should be able to
         * exit() and clear out its resources quickly...
         */
-       p->counter = 5 * HZ;
+       p->time_slice = HZ;
        p->flags |= PF_MEMALLOC | PF_MEMDIE;
 
        /* This process has hardware access, be more careful. */
diff -urN linux-2.4.20/mm/slab.c linux-2.4.20-o1-preempt/mm/slab.c
--- linux-2.4.20/mm/slab.c      Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/mm/slab.c   Tue Feb 18 03:52:06 2003
@@ -49,7 +49,8 @@
  *  constructors and destructors are called without any locking.
  *  Several members in kmem_cache_t and slab_t never change, they
  *     are accessed without any locking.
- *  The per-cpu arrays are never accessed from the wrong cpu, no locking.
+ *  The per-cpu arrays are never accessed from the wrong cpu, no locking,
+ *     and local interrupts are disabled so slab code is preempt-safe.
  *  The non-constant members are protected with a per-cache irq spinlock.
  *
  * Further notes from the original documentation:
diff -urN linux-2.4.20/net/core/dev.c linux-2.4.20-o1-preempt/net/core/dev.c
--- linux-2.4.20/net/core/dev.c Fri Nov 29 00:53:15 2002
+++ linux-2.4.20-o1-preempt/net/core/dev.c      Tue Feb 18 03:52:06 2003
@@ -1049,9 +1049,15 @@
                int cpu = smp_processor_id();
 
                if (dev->xmit_lock_owner != cpu) {
+                       /*
+                        * The spin_lock effectivly does a preempt lock, but 
+                        * we are about to drop that...
+                        */
+                       preempt_disable();
                        spin_unlock(&dev->queue_lock);
                        spin_lock(&dev->xmit_lock);
                        dev->xmit_lock_owner = cpu;
+                       preempt_enable();
 
                        if (!netif_queue_stopped(dev)) {
                                if (netdev_nit)
diff -urN linux-2.4.20/net/core/skbuff.c linux-2.4.20-o1-preempt/net/core/skbuff.c
--- linux-2.4.20/net/core/skbuff.c      Sat Aug  3 02:39:46 2002
+++ linux-2.4.20-o1-preempt/net/core/skbuff.c   Tue Feb 18 03:52:06 2003
@@ -111,33 +111,37 @@
 
 static __inline__ struct sk_buff *skb_head_from_pool(void)
 {
-       struct sk_buff_head *list = &skb_head_pool[smp_processor_id()].list;
+       struct sk_buff_head *list;
+       struct sk_buff *skb = NULL;
+       unsigned long flags;
 
-       if (skb_queue_len(list)) {
-               struct sk_buff *skb;
-               unsigned long flags;
+       local_irq_save(flags);
 
-               local_irq_save(flags);
+       list = &skb_head_pool[smp_processor_id()].list;
+
+       if (skb_queue_len(list))
                skb = __skb_dequeue(list);
-               local_irq_restore(flags);
-               return skb;
-       }
-       return NULL;
+
+       local_irq_restore(flags);
+       return skb;
 }
 
 static __inline__ void skb_head_to_pool(struct sk_buff *skb)
 {
-       struct sk_buff_head *list = &skb_head_pool[smp_processor_id()].list;
+       struct sk_buff_head *list;
+       unsigned long flags;
 
-       if (skb_queue_len(list) < sysctl_hot_list_len) {
-               unsigned long flags;
+       local_irq_save(flags);
+       list = &skb_head_pool[smp_processor_id()].list;
 
-               local_irq_save(flags);
+       if (skb_queue_len(list) < sysctl_hot_list_len) {
                __skb_queue_head(list, skb);
                local_irq_restore(flags);
 
                return;
        }
+
+       local_irq_restore(flags);
        kmem_cache_free(skbuff_head_cache, skb);
 }
 
diff -urN linux-2.4.20/net/socket.c linux-2.4.20-o1-preempt/net/socket.c
--- linux-2.4.20/net/socket.c   Fri Nov 29 00:53:16 2002
+++ linux-2.4.20-o1-preempt/net/socket.c        Tue Feb 18 03:52:07 2003
@@ -132,7 +132,7 @@
 
 static struct net_proto_family *net_families[NPROTO];
 
-#ifdef CONFIG_SMP
+#if defined(CONFIG_SMP) || defined(CONFIG_PREEMPT)
 static atomic_t net_family_lockct = ATOMIC_INIT(0);
 static spinlock_t net_family_lock = SPIN_LOCK_UNLOCKED;
 
diff -urN linux-2.4.20/net/sunrpc/pmap_clnt.c linux-2.4.20-o1-preempt/net/sunrpc/pmap_clnt.c
--- linux-2.4.20/net/sunrpc/pmap_clnt.c Sat Aug  3 02:39:46 2002
+++ linux-2.4.20-o1-preempt/net/sunrpc/pmap_clnt.c      Tue Feb 18 03:52:07 2003
@@ -12,6 +12,7 @@
 #include <linux/config.h>
 #include <linux/types.h>
 #include <linux/socket.h>
+#include <linux/sched.h>
 #include <linux/kernel.h>
 #include <linux/errno.h>
 #include <linux/uio.h>