3910l1.orig100664 777 330 762 7050105607 12113 0ustar ljeditorljeditListing 1. Kernel Patch to Limit Forking 2.3.26/kernel/fork.c Thu Oct 28 22:30:51 1999 +++ /tmp/fork.c Tue Nov 9 01:34:36 1999 @@ -591,6 +591,14 @@ int retval = -ENOMEM; struct task_struct *p; DECLARE_MUTEX_LOCKED(sem); + static long last_fork; + + while (time_after(last_fork+1, jiffies)) + { + __set_current_state(TASK_INTERRUPTIBLE); + schedule_timeout(1); + } + last_fork = jiffies; if (clone_flags & CLONE_PID) { /* This is only allowed from the boot up thread */ 3910l2.orig100664 777 330 4513 7050105734 12133 0ustar ljeditorljeditListing 2. Kernel Patch Implementing Processor Affinity --- 2.3.38-pset/include/linux/sched.h.~1~ Tue Jan 11 14:46:45 2000 +++ 2.3.38-pset/include/linux/sched.h Tue Jan 11 17:58:52 2000 @@ -363,6 +363,7 @@ u32 self_exec_id; /* Protection of fields allocatio/deallocation */ struct semaphore exit_sem; + int bind_cpu; }; /* @@ -430,6 +431,7 @@ /* signals */ SPIN_LOCK_UNLOCKED, &init_signals, {{0}}, {{0}}, NULL, &init_task.sigqueue, 0, 0, \ /* exec cts */ 0,0, \ /* exit_sem */ __MUTEX_INITIALIZER(name.exit_sem), +NO_PROC_ID, } #ifndef INIT_TASK_SIZE --- 2.3.38-pset/kernel/sched.c.~1~ Sun Jan 9 20:45:31 2000 +++ 2.3.38-pset/kernel/sched.c Tue Jan 11 18:16:45 2000 @@ -72,11 +72,13 @@ struct schedule_data { struct task_struct * curr; cycles_t last_schedule; + int bind; } 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 cpu_bind(cpu) (aligned_data[(cpu)].bind) struct kernel_stat kstat = { 0 }; @@ -94,6 +96,25 @@ void scheduling_functions_start_here(void) { } +static int not_deadlocking(void) + + int i; + + for (i = 0; i < smp_num_cpus; i++) { + int cpu; + + cpu = cpu_logical_map(i); + if (!cpu_bind(cpu)) + return 1; + } + return 0; +} + +void set_bind_cpu(int cpu, int set) +{ + cpu_bind(cpu_logical_map(cpu)) = set; +} + /* * This is the function that decides how desirable a process is.. * You can weigh different processes against each other depending @@ -111,6 +132,9 @@ static inline int goodness(struct task_struct * p, int this_cpu, struct mm_struct *this_mm) { int weight; + + if (not_deadlocking() && cpu_bind(this_cpu) && p->bind_cpu != this_cpu) + return 0; /* * Realtime process, select the first one on the --- 2.3.38-pset/kernel/sys.c.~1~ Tue Nov 2 12:06:25 1999 +++ 2.3.38-pset/kernel/sys.c Tue Jan 11 18:18:34 2000 @@ -1027,6 +1027,19 @@ } current->dumpable = arg2; break; + case PR_SET_CPU: + { + extern void set_bind_cpu(int, int); + + error = -EINVAL; + if (arg2 >= smp_num_cpus || arg2 < 0) + break; + + error = 0; + current->bind_cpu = cpu_logical_map(arg2); + set_bind_cpu(arg3, 1); + break; + } default: error = -EINVAL; break; 3910l3.orig100664 777 330 2670 7050106000 12121 0ustar ljeditorljeditListing 3. Goodness Function /* linux/kernel/sched.c * 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. */ static inline int goodness(struct task_struct * p, int this_cpu, struct mm_struct *this_mm) { int weight; /* * Realtime process, select the first one on the * runqueue (taking priorities within processes * into account). */ if (p->policy != SCHED_OTHER) { weight = 1000 + p->rt_priority; goto out; } /* * 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.. */ weight = p->counter; if (!weight) goto out; #ifdef __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) weight += 1; weight += p->priority; out: return weight; } 3910l4.orig100664 777 330 3010 7050106033 12115 0ustar ljeditorljeditListing 4. reschedule_idle static void reschedule_idle(struct task_struct * p) { #ifdef __SMP__ int this_cpu = smp_processor_id(), target_cpu; struct task_struct *tsk, *target_tsk; int cpu, best_cpu, i; unsigned long flags; spin_lock_irqsave(&runqueue_lock, flags); /* * shortcut if the woken up task's last CPU is * idle now. */ best_cpu = p->processor; target_tsk = idle_task(best_cpu); if (cpu_curr(best_cpu) == target_tsk) goto send_now; target_tsk = NULL; for (i = 0; i < smp_num_cpus; i++) { cpu = cpu_logical_map(i); tsk = cpu_curr(cpu); if (tsk == idle_task(cpu)) target_tsk = tsk; } if (target_tsk && p->avg_slice > cacheflush_time) goto send_now; tsk = cpu_curr(best_cpu); if (preemption_goodness(tsk, p, best_cpu) > 0) target_tsk = tsk; /* * found any suitable CPU? */ if (!target_tsk) goto out_no_target; send_now: target_cpu = target_tsk->processor; target_tsk->need_resched = 1; spin_unlock_irqrestore(&runqueue_lock, flags); /* * the APIC stuff can go outside of the lock because * it uses no task information, only CPU#. */ if (target_cpu != this_cpu) smp_send_reschedule(target_cpu); return; out_no_target: spin_unlock_irqrestore(&runqueue_lock, flags); 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 } ------- cut and paste from linux/kernel/sched.c ---------